Merge branch 'master' of https://github.com/dotnet/coreclr into refactor_packaging

2718 files changed, 65258 insertions, 220391 deletions

diff --git a/.gitattributes b/.gitattributes
index ea1c23bb34..519ecbb037 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -66,3 +66,11 @@
 *.sh text eol=lf
 src/pal/tests/palsuite/paltestlist.txt text eol=lf
 src/pal/tests/palsuite/paltestlist_to_be_reviewed.txt text eol=lf
+
+tests/src/JIT/Performance/CodeQuality/BenchmarksGame/regexdna/regexdna-input25.txt text eol=lf
+tests/src/JIT/Performance/CodeQuality/BenchmarksGame/regexdna/regexdna-input25000.txt text eol=lf
+tests/src/JIT/Performance/CodeQuality/BenchmarksGame/revcomp/revcomp-input25.txt text eol=lf
+tests/src/JIT/Performance/CodeQuality/BenchmarksGame/revcomp/revcomp-input25000.txt text eol=lf
+tests/src/JIT/Performance/CodeQuality/BenchmarksGame/k-nucleotide/knucleotide-input.txt text eol=lf
+tests/src/JIT/Performance/CodeQuality/BenchmarksGame/k-nucleotide/knucleotide-input-big.txt text eol=lf
+
diff --git a/.gitignore b/.gitignore
index 702c37daa3..f5d049b3d0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -298,6 +298,7 @@ Makefile
 
 # Cross compilation
 cross/rootfs/*
+cross/android-rootfs/*
 # add x86 as it is ignored in 'Build results'
 !cross/x86
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index cdf157e186..c9a75e521a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -103,7 +103,7 @@ else (WIN32)
       # Ensure that objcopy is present
       if (DEFINED ENV{CROSSCOMPILE} AND NOT DEFINED CLR_CROSS_COMPONENTS_BUILD)
         if (CMAKE_SYSTEM_PROCESSOR STREQUAL armv7l OR CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64)
-          find_program(OBJCOPY ${TOOLCHAIN}-objcopy)
+          find_program(OBJCOPY ${TOOLCHAIN_PREFIX}objcopy)
         elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL i686)
           find_program(OBJCOPY objcopy)
         else()
@@ -544,9 +544,9 @@ include(pgosupport.cmake)
 #     - project which require platform header not clr's
 #     - do not depend on clr's compile definitions
 #-----------------------------------------
-if(CLR_CMAKE_PLATFORM_UNIX)
+if(CLR_CMAKE_PLATFORM_UNIX AND NOT DEFINED CLR_CROSS_COMPONENTS_BUILD)
   add_subdirectory(src/corefx)
-endif(CLR_CMAKE_PLATFORM_UNIX)
+endif()
 
 if(CLR_CMAKE_PLATFORM_UNIX)
     add_subdirectory(src/ToolBox/SOS/lldbplugin)
diff --git a/Documentation/botr/clr-abi.md b/Documentation/botr/clr-abi.md
index b100ee9cd2..6719522409 100644
--- a/Documentation/botr/clr-abi.md
+++ b/Documentation/botr/clr-abi.md
@@ -285,7 +285,7 @@ The PSPSym is a pointer-sized local variable in the frame of the main function a
 
 The VM uses the PSPSym to find other locals it cares about (such as the generics context in a funclet frame). The JIT uses it to re-establish the frame pointer register, so that the frame pointer is the same value in a funclet as it is in the main function body.
 
-When a funclet is called, it is passed the *Establisher Frame Pointer*. For AMD64 this is true for all funclets and it is passed as the first argument in RCX, but for ARM and ARM64 this is only true for first pass funclets (currently just filters) and it is passed as the second argument in R1. The Establisher Frame Pointer is a stack pointer of an interesting "parent" frame in the exception processing system. For the CLR, it points either to the main function frame or a dynamically enclosing funclet frame from the same function, for the funclet being invoked. The value of the Establisher Frame Pointer is Initial-SP on AMD64, Caller-SP on ARM and ARM64.
+When a funclet is called, it is passed the *Establisher Frame Pointer*. For AMD64 this is true for all funclets and it is passed as the first argument in RCX, but for ARM and ARM64 this is only true for first pass funclets (currently just filters) and it is passed as the second argument in R1. The Establisher Frame Pointer is a stack pointer of an interesting "parent" frame in the exception processing system. For the CLR, it points either to the main function frame or a dynamically enclosing funclet frame from the same function, for the funclet being invoked. The value of the Establisher Frame Pointer is Initial-SP on AMD64, Caller-SP on x86, ARM, and ARM64.
 
 Using the establisher frame, the funclet wants to load the value of the PSPSym. Since we don't know if the Establisher Frame is from the main function or a funclet, we design the main function and funclet frame layouts to place the PSPSym at an identical, small, constant offset from the Establisher Frame in each case. (This is also required because we only report a single offset to the PSPSym in the GC information, and that offset must be valid for the main function and all of its funclets). Then, the funclet uses this known offset to compute the PSPSym address and read its value. From this, it can compute the value of the frame pointer (which is a constant offset from the PSPSym value) and set the frame register to be the same as the parent function. Also, the funclet writes the value of the PSPSym to its own frame's PSPSym. This "copying" of the PSPSym happens for every funclet invocation, in particular, for every nested funclet invocation.
 
diff --git a/Documentation/building/android.md b/Documentation/building/android.md
new file mode 100644
index 0000000000..cfb509dc2f
--- /dev/null
+++ b/Documentation/building/android.md
@@ -0,0 +1,102 @@
+Cross Compilation for Android on Linux
+======================================
+
+Through cross compilation, on Linux it is possible to build CoreCLR for arm64 Android.
+
+Requirements
+------------
+
+You'll need to generate a toolchain and a sysroot for Android. There's a script which takes care of the required steps.
+
+Generating the rootfs
+---------------------
+
+To generate the rootfs, run the following command in the `coreclr` folder:
+
+```
+cross/init-android-rootfs.sh
+```
+
+This will download the NDK and any packages required to compile Android on your system. It's over 1 GB of data, so it may take a while.
+
+
+Cross compiling CoreCLR
+-----------------------
+Once the rootfs has been generated, it will be possible to cross compile CoreCLR. 
+
+When cross compiling, you need to set both the `CONFIG_DIR` and `ROOTFS_DIR` variables.
+
+To compile for arm64, run:
+
+```
+CONFIG_DIR=`realpath cross/android/arm64` ROOTFS_DIR=`realpath cross/android-rootfs/toolchain/arm64/sysroot` ./build.sh cross arm64 skipgenerateversion skipmscorlib cmakeargs -DENABLE_LLDBPLUGIN=0
+```
+
+The resulting binaries will be found in `bin/Product/Linux.BuildArch.BuildType/`
+
+Running the PAL tests on Android
+--------------------------------
+
+You can run the PAL tests on an Android device. To run the tests, you first copy the PAL tests to your Android phone using
+`adb`, and then run them in an interactive Android shell using `adb shell`:
+
+To copy the PAL tests over to an Android phone:
+```
+adb push bin/obj/Linux.arm64.Debug/src/pal/tests/palsuite/ /data/local/tmp/coreclr/src/pal/tests/palsuite
+adb push cross/android/toolchain/arm64/sysroot/usr/lib/libuuid.so.1 /data/local/tmp/coreclr/lib
+adb push cross/android/toolchain/arm64/sysroot/usr/lib/libintl.so /data/local/tmp/coreclr/lib
+adb push cross/android/toolchain/arm64/sysroot/usr/lib/libandroid-support.so /data/local/tmp/coreclr/lib/
+adb push cross/android/toolchain/arm64/sysroot/usr/lib/libandroid-glob.so /data/local/tmp/coreclr/lib/
+adb push src/pal/tests/palsuite/paltestlist.txt /data/local/tmp/coreclr
+adb push src/pal/tests/palsuite/runpaltests.sh /data/local/tmp/coreclr/
+```
+
+Then, use `adb shell` to launch a shell on Android. Inside that shell, you can launch the PAL tests:
+```
+LD_LIBRARY_PATH=/data/local/tmp/coreclr/lib ./runpaltests.sh /data/local/tmp/coreclr/
+```
+
+Debugging coreclr on Android
+----------------------------
+
+You can debug coreclr on Android using a remote lldb server which you run on your Android device.
+
+First, push the lldb server to Android:
+
+```
+adb push cross/android/lldb/2.2/android/arm64-v8a/lldb-server /data/local/tmp/
+```
+
+Then, launch the lldb server on the Android device. Open a shell using `adb shell` and run:
+
+```
+adb shell
+cd /data/local/tmp
+./lldb-server platform --listen *:1234
+```
+
+After that, you'll need to forward port 1234 from your Android device to your PC:
+```
+adb forward tcp:1234 tcp:1234
+```
+
+Finally, install lldb on your PC and connect to the debug server running on your Android device:
+
+```
+lldb-3.9
+(lldb) platform select remote-android
+  Platform: remote-android
+ Connected: no
+(lldb) platform connect connect://localhost:1234
+  Platform: remote-android
+    Triple: aarch64-*-linux-android
+OS Version: 23.0.0 (3.10.84-perf-gf38969a)
+    Kernel: #1 SMP PREEMPT Fri Sep 16 11:29:29 2016
+  Hostname: localhost
+ Connected: yes
+WorkingDir: /data/local/tmp
+
+(lldb) target create coreclr/pal/tests/palsuite/file_io/CopyFileA/test4/paltest_copyfilea_test4
+(lldb) env LD_LIBRARY_PATH=/data/local/tmp/coreclr/lib
+(lldb) run
+```
diff --git a/Documentation/building/testing-with-corefx.md b/Documentation/building/testing-with-corefx.md
index 4f9886f78d..defc8f8e8b 100644
--- a/Documentation/building/testing-with-corefx.md
+++ b/Documentation/building/testing-with-corefx.md
@@ -3,18 +3,23 @@ Testing with CoreFX
 
 It may be valuable to use CoreFX tests to validate your changes to CoreCLR or mscorlib.
 
-**Windows**
+**NOTE:** The `BUILDTOOLS_OVERRIDE_RUNTIME` property no longer works.
 
-As part of building tests, CoreFX restores a copy of the runtime from myget, in order to update the runtime that is deployed, a special build property `BUILDTOOLS_OVERRIDE_RUNTIME` can be used. If this is set, the CoreFX testing targets will copy all the files in the folder it points to into the test folder, overwriting any files that exist.
+**Replace runtime between build.[cmd|sh] and build-tests.[cmd|sh]**
 
-To run tests, follow the procedure for [running tests in CoreFX](https://github.com/dotnet/corefx/blob/master/Documentation/building/windows-instructions.md). You can pass `/p:BUILDTOOLS_OVERRIDE_RUNTIME=<path-to-coreclr>\bin\Product\Windows_NT.x64.Release` to build.cmd to set this property, e.g. (note the space between the "--" and the "/p" option):
+Use the following instructions to test a change to the dotnet/coreclr repo using dotnet/corefx tests.  Refer to the [CoreFx Developer Guide](https://github.com/dotnet/corefx/blob/master/Documentation/project-docs/developer-guide.md) for information about CoreFx build scripts.
 
-```
-build.cmd -Release -- /p:BUILDTOOLS_OVERRIDE_RUNTIME=<root of coreclr repo>\bin\Product\Windows_NT.x64.Checked
-```
+1. Build the CoreClr runtime you wish to test under `<coreclr_root>`
+2. Build the CoreFx repo (`build.[cmd|sh]`) under `<corefx_root>`, but don't build tests yet
+3. Copy the contents of the CoreCLR binary root you wish to test into the CoreFx runtime folder (`<flavor>` below) created in step #2.  For example:
 
-**FreeBSD, Linux, NetBSD, OS X**
+  `copy <coreclr_root>\bin\Product\Windows_NT.<arch>.<build_type>\* <corefx_root>\bin\runtime\<flavor>`  
+  -or-  
+  `cp <coreclr_root>/bin/Product/<os>.<arch>.<build_type>/* <corefx_root>/bin/runtime/<flavor>`  
+  
+4. Run the CoreFx `build-tests.[cmd|sh]` script as described in the Developer Guide.
+
+**CI Script**
+
+[run-corefx-tests.py](https://github.com/dotnet/coreclr/blob/master/tests/scripts/run-corefx-tests.py) will clone dotnet/corefx and run steps 2-4 above automatically.  It is primarily intended to be run by the dotnet/coreclr CI system, but it might provide a useful reference or shortcut for individuals running the tests locally.
 
-Refer to the procedure for [running tests in CoreFX](https://github.com/dotnet/corefx/blob/master/Documentation/building/cross-platform-testing.md)
-- Note the --coreclr-bins and --mscorlib-bins arguments to [run-test.sh](https://github.com/dotnet/corefx/blob/master/run-test.sh)
-- Pass in paths to your private build of CoreCLR
diff --git a/Documentation/building/unix-test-instructions.md b/Documentation/building/unix-test-instructions.md
index 9cf7507443..563c3e8c68 100644
--- a/Documentation/building/unix-test-instructions.md
+++ b/Documentation/building/unix-test-instructions.md
@@ -36,8 +36,7 @@ Run tests (`Debug` may be replaced with `Release` or `Checked`, depending on whi
 >     --testNativeBinDir=~/coreclr/bin/obj/Linux.x64.Debug/tests
 >     --coreClrBinDir=~/coreclr/bin/Product/Linux.x64.Debug
 >     --mscorlibDir=/media/coreclr/bin/Product/Linux.x64.Debug
->     --coreFxBinDir="~/corefx/bin/Linux.AnyCPU.Debug;~/corefx/bin/Unix.AnyCPU.Debug;~/corefx/bin/AnyOS.AnyCPU.Debug"
->     --coreFxNativeBinDir=~/corefx/bin/Linux.x64.Debug
+>     --coreFxBinDir=~/corefx/bin/runtime/netcoreapp-Linux-Debug-x64
 > ```
 
 The method above will copy dependencies from the set of directories provided to create an 'overlay' directory.
diff --git a/Documentation/design-docs/finally-optimizations.md b/Documentation/design-docs/finally-optimizations.md
index ddc6dbd93c..d35d5a47bd 100644
--- a/Documentation/design-docs/finally-optimizations.md
+++ b/Documentation/design-docs/finally-optimizations.md
@@ -18,8 +18,8 @@ which is almost like a regular function with a prolog and epilog. A
 custom calling convention gives the funclet access to the parent stack
 frame.
 
-In this proposal we outline two optimizations for finallys: removing
-empty finallys and finally cloning.
+In this proposal we outline three optimizations for finallys: removing
+empty trys, removing empty finallys and finally cloning.
 
 Empty Finally Removal
 ---------------------
@@ -175,6 +175,42 @@ G_M60484_IG06:
 Empty finally removal is unconditionally profitable: it should always
 reduce code size and improve code speed.
 
+Empty Try Removal
+---------------------
+
+If the try region of a try-finally is empty, and the jitted code will
+execute on a runtime that does not protect finally execution from
+thread abort, then the try-finally can be replaced with just the
+content of the finally.
+
+Empty trys with non-empty finallys often exist in code that must run
+under both thread-abort aware and non-thread-abort aware runtimes. In
+the former case the placement of cleanup code in the finally ensures
+that the cleanup code will execute fully. But if thread abort is not
+possible, the extra protection offered by the finally is not needed.
+
+Empty try removal looks for try-finallys where the try region does
+nothing except invoke the finally. There are currently two different
+EH implementation models, so the try screening has two cases:
+
+* callfinally thunks (x64/arm64): the try must be a single empty
+basic block that always jumps to a callfinally that is the first
+half of a callfinally/always pair;
+* non-callfinally thunks (x86/arm32): the try must be a
+callfinally/always pair where the first block is an empty callfinally.
+
+The screening then verifies that the callfinally identified above is
+the only callfinally for the try. No other callfinallys are expected
+because this try cannot have multiple leaves and its handler cannot be
+reached by nested exit paths.
+
+When the empty try is identified, the jit modifies the
+callfinally/always pair to branch to the handler, modifies the
+handler's return to branch directly to the continuation (the
+branch target of the second half of the callfinally/always pair),
+updates various status flags on the blocks, and then removes the
+try-finally region.
+
 Finally Cloning
 ---------------
 
diff --git a/Documentation/design-docs/lsra-throughput.md b/Documentation/design-docs/lsra-throughput.md
new file mode 100644
index 0000000000..4fd704c763
--- /dev/null
+++ b/Documentation/design-docs/lsra-throughput.md
@@ -0,0 +1,74 @@
+Improving LSRA Throughput
+=========================
+
+There are a number of ways in which the current implementation of linear scan register allocation (LSRA) is sub-optimal:
+* I'm not certain that the extra pass that enumerates the nodes before the current `TreeNodeInfoInit` pass must be separate.
+  Further investigation is needed.
+* The identification of opportunities for "containment" (i.e. where the computation of a node's result can be folded into the parent,
+such as a load or store) is done during `Lowering` and communicated to the register allocator via a `gtLsraInfo` field on the node, that
+is otherwise unused, and is basically duplicated when the `RefPosition`s are built for the node.
+  * A more efficient representation of "containment" could allow this to remain in `Lowering`, where existing transformations already
+    take into account the parent context.
+    * This would also have the additional benefit of simplifying the containment check, which is done at least once for each node
+      (at the beginning of `CodeGen::genCodeForTreeNode()`), and then additionally when considering whether the operands of the current
+      node are contained.
+  * Alternatively, the containment analysis could be done during the building of `RefPosition`s, though see below.
+* Similarly, the specification of register requirements is done during the final pass of `Lowering`, and fundamentally requires more
+  space (it must specify register masks for sources, destination and any internal registers). In addition, the requirement for a new
+  register definition (the destination of the node, or any internal registers) is independent of the parent, so this could be done in
+  `LinearScan::buildRefPositionsForNode()` without having to do a dual traversal, unlike the identification of contained nodes.
+* After building `RefPositions`, they are traversed in order to set the last use bits.
+  This is done separately because there are currently inconsistencies between the gtNext/gtPrev links and the actual order of codegen.
+  Once this is resolved, the lastUse bits should be set prior to register allocation by the liveness pass (#7256).
+* The `RefPosition`s are all created prior to beginning the register allocation pass. However, they are only really needed in advance
+  for the lclVars, which, unlike the "tree temps", have multiple definitions and may be live across basic blocks.
+  The `RefPositions`s for the tree temps could potentially be allocated on-the-fly, saving memory and probably improving locality (#7257).
+* The loop over all the candidate registers in `LinearScan::tryAllocateFreeReg()` and in `LinearScan::allocateBusyReg()` could be
+  short-circuited when a register is found that has the best possible score. Additionally, in the case of MinOpts, it could potentially
+  short-circuit as soon as a suitable candidate is found, though one would want to weight the throughput benefit against the code
+  quality impact. 
+
+Representing Containedness
+==========================
+My original plan for this was to combine all of the functionality of the current `TreeNodeInfoInit` pass with the building of `RefPositions`,
+and eliminate `gtLsraInfo`.
+The idea was to later consider pulling the containment analysis back into the first phase of `Lowering`.
+However, after beginning down that path (extracting the `TreeNodeInfoInit` methods into separate lsra{arch}.cpp files), I realized that
+there would be a great deal of throw-away work to put the containment analysis into `LinearScan`, only to potentially pull it out later.
+
+Furthermore, the representation of containedness is not very clean:
+* `Lowering` first communicates this as a combination of implicit knowledge of a node's behavior and its `gtLsraInfo.dstCount`.
+* Later, during `CodeGen`, it is determined by combining similar implicit node characteristics with the presence or absence of a register.
+
+I propose instead to do the following:
+* Add a flag to each node to indicate whether or not it is a tree root.
+  * To free up such a flag, I propose to eliminate `GTF_REG_VAL` for the non-`LEGACY_BACKEND`. Doing so will require some additional cleanup,
+    but in the process a number of hacks can be eliminated that are currently there to workaround the fact that the emitter was designed
+    to work with a code generator that dynamically assigned registers, and set that flag when the code had been generated to put it in a
+    register, unlike the RyuJIT backend, which assigns the registers before generating code.
+* Define new register values:
+  * `REG_UNK` is assigned by `Lowering` when a register is required.
+  * `REG_OPT` is assigned by `Lowering` when a register is optional at both definition and use.
+  * `REG_OPT_USE` is assigned by `Lowering` when a register is required at the definition, but optional at the use.
+  * I don't know if we need `REG_OPT_DEF`, but that could be added as well.
+* Having done this, we can greatly simplify `IsContained()`.
+
+It may be more effective to use the extra bit for an actual `GTF_CONTAINED` flag, and that is something we might want to consider
+eventually, but initially it is easier to simplify the containedness check using `GTF_TREE_ROOT` without having to change all the
+places that currently mark nodes as contained.
+
+Combining Containedness Analysis with Lowering
+==============================================
+Once we've changed containedness to use the above representation, we can move the code to set it into the first pass of `Lowering`.
+There are likely to be some phase ordering challenges, but I don't think they will be prohibitive.
+
+Eliminating gtLsraInfo
+======================
+Issue #7225.
+
+After the containedness changes above, all that remains to communicate via `gtLsraInfo` is the register requirements.
+This step would still use the `TreeNodeInfo` data structure and the `TreeNodeInfoInit()` methods, but they would be called as
+each node is handled by `LinearScan::buildRefPositionsForNode()`.
+
+
+ 
diff --git a/Documentation/design-docs/tailcalls-with-helpers.md b/Documentation/design-docs/tailcalls-with-helpers.md
new file mode 100644
index 0000000000..e23b51e130
--- /dev/null
+++ b/Documentation/design-docs/tailcalls-with-helpers.md
@@ -0,0 +1,460 @@
+# The current way of handling tail-calls
+## Fast tail calls
+These are tail calls that are handled directly by the jitter and no runtime cooperation is needed. They are limited to cases where:
+* Return value and call target arguments are all either primitive types, reference types, or valuetypes with a single primitive type or reference type fields
+* The aligned size of call target arguments is less or equal to aligned size of caller arguments
+
+## Tail calls using a helper
+Tail calls in cases where we cannot perform the call in a simple way are implemented using a tail call helper. Here is a rough description of how it works:
+* For each tail call target, the jitter asks runtime to generate an assembler argument copying routine. This routine reads vararg list of arguments and places the arguments in their proper slots in the CONTEXT or on the stack. Together with the argument copying routine, the runtime also builds a list of offsets of references and byrefs for return value of reference type or structs returned in a hidden return buffer and for structs passed by ref. The gc layout data block is stored at the end of the argument copying thunk. 
+* At the time of the tail call, the caller generates a vararg list of all arguments of the tail called function and then calls JIT_TailCall runtime function. It passes it the copying routine address, the target address and the vararg list of the arguments.
+* The JIT_TailCall then performs the following:
+  * It calls RtlVirtualUnwind twice to get the context of the caller of the caller of the tail call to simulate the effect of running epilog of the caller of the tail call and also its return.
+  * It prepares stack space for the callee stack arguments, a helper explicit TailCallFrame and also a CONTEXT structure where the argument registers of the callee, stack pointer and the target function address are set. In case the tail call caller has enough space for the callee arguments and the TailCallFrame in its stack frame, that space is used directly for the callee arguments. Otherwise the stack arguments area is allocated at the top of the stack. This slightly differs in the case the tail call was called from another tail called function - the TailCallFrame already exists and so it is not recreated. The TailCallFrame also keeps a pointer to the list of gc reference offsets of the arguments and structure return buffer members. The stack walker during GC then uses that to ensure proper GC liveness of those references.
+  * It calls the copying routine to translate the arguments from the vararg list to the just reserved stack area and the context.
+  * If the stack arguments and TailCaillFrame didn't fit into the caller's stack frame, these data are now moved to the final location
+  * RtlRestoreContext is used to start executing the callee.
+
+There are several issues with this approach:
+* It is expensive to port to new platforms
+  * Parsing the vararg list is not possible to do in a portable way on Unix. Unlike on Windows, the list is not stored a linear sequence of the parameter data bytes in memory. va_list on Unix is an opaque data type, some of the parameters can be in registers and some in the memory.
+  * Generating the copying asm routine needs to be done for each target architecture / platform differently. And it is also very complex, error prone and impossible to do on platforms where code generation at runtime is not allowed.
+* It is slower than it has to be
+  * The parameters are copied possibly twice - once from the vararg list to the stack and then one more time if there was not enough space in the caller's stack frame.
+  * RtlRestoreContext restores all registers from the CONTEXT structure, not just a subset of them that is really necessary for the functionality, so it results in another unnecessary memory accesses.
+* Stack walking over the stack frames of the tail calls requires runtime assistance.
+ 
+# The new approach to tail calls using helpers
+## Objectives
+The new way of handling tail calls using helpers was designed with the following objectives:
+* It should be cheap to port to new platforms, architectures and code generators
+* It needs to work in both jitted and AOT compiled scenarios
+* It should support platforms where runtime code generation is not possible
+* The tail calls should be reasonably fast compared to regular calls with the same arguments
+* The tail calls should not be slower than existing mechanism on Windows
+* No runtime assistance should be necessary for unwinding stack with tail call frames on it
+* The stack should be unwindable at any spot during the tail calls to properly support sampling profilers and similar tools.
+* Stack walk during GC must be able to always correctly report GC references. 
+* It should work in all cases except those where a tail call is not allowed as described in the ECMA 335 standard section III.2.4
+
+## Requirements
+* The code generator needs to be able to compile a tail call to a target as a call to a thunk with the same parameters as the target, but void return, followed by a jump to an assembler helper.
+
+## Implementation
+This section describes the helper functions and data structures that the tail calls use and also describes the tail call sequence step by step. 
+### Helper functions
+The tail calls use the following thunks and helpers:
+* StoreArguments - this thunk stores the arguments into a thread local storage together with the address of the corresponding CallTarget thunk and a descriptor of locations and types of managed references in the stored arguments data. This thunk is generated as IL and compiled by the jitter or AOT compiler. There is one such thunk per tail call target.
+It has a signature that is compatible with the tailcall target function except for the return type which is void. But it is not the same. It gets the same arguments as the tail call target function, but it would also get "this" pointer and the generic context as explicit arguments if the tail call target requires them. Arguments of generic reference types are passed as "object" so that the StoreArguments doesn't have to be generic.
+* CallTarget - this thunk gets the arguments buffer that was filled by the StoreArguments thunk, loads the arguments from the buffer, releases the buffer and calls the target function using calli. The signature used for the calli would ensure that all arguments including the optional hidden return buffer and the generic context are passed in the right registers / stack slots. Generic reference arguments will be specified as "object" in the signature so that the CallTarget doesn't have to be generic. 
+The CallTarget is also generated as IL and compiled by the jitter or AOT compiler. There is one such thunk per tail call target. This thunk has the same return type as the tailcall target or return "object" if the return type of the tail call target is a generic reference type.
+* TailCallHelper - this is an assembler helper that is responsible for restoring stack pointer to the location where it was when the first function in a tail call chain was entered and then jumping to the CallTarget thunk. This helper is common for all tail call targets. 
+In a context of each tailcall invocation, the TailCallHelper will be handled by the jitter as if it had the same return type as the tail call target. That means that if the tail call target needs a hidden return buffer for returning structs, the pointer to this buffer will be passed to the TailCallHelper the same way as it would be passed to the tail call target. The TailCallHelper would then pass this hidden argument to the CallTarget helper.
+There will be two flavors of this helper, based on whether the tail call target needs a hidden return buffer or not:
+  * TailCallHelper
+  * TailCallHelper_RetBuf
+
+### Helper data structures
+The tail calls use the following data structures:
+* Thread local storage for arguments. It stores the arguments of a tail call for a short period of time between the StoreArguments and CallTarget calls.
+* Arguments GC descriptor - descriptor of locations and types of managed references in the arguments.
+* TailCallHelperStack - a per thread stack of helper entries that is used to determine whether a tail call is chained or not. Its entries are allocated as local variables in CallTarget thunks. Each entry contains:
+  * Stack pointer captured right before a call to a tail call target
+  * ChainCall flag indicating whether the CallTarget thunk should return after the call to the tail call target or whether it should execute its epilog and jump to TailCallHelper instead. The latter is used by the TailCallHelper to remove the stack frame of the CallTarget before making a tail call from a tail called function. 
+  * Pointer to the next entry on the stack.
+
+### Tail call sequence
+* The caller calls the StoreArguments thunk corresponding to the callee to store the pointer to the tail call target function, its arguments, their GC descriptors, optional "this" and generic context arguments and the corresponding CallTarget thunk address in a thread local storage.
+* The caller executes its epilog, restoring stack pointer and callee saved registers to their values when the caller was entered.
+* The caller jumps to the TailCallHelper. This function performs the following operations:
+  * Get the topmost TailCallHelperStack entry for the current thread.
+  * Check if the previous stack frame is a CallTarget thunk frame by comparing the stack pointer value stored in the TailCallHelperStack entry to the current CFA (call frame address). If it matches, it means that the previous stack frame belongs to a CallTarget thunk and so the tail call caller was also tail called.
+  * If the previous frame was a CallTarget thunk, its stack frame needs to be removed to ensure that the stack will not grow when tail calls are chained. Set ChainCall flag in the TailCallHelperStack entry and return. That returns control to the CallTarget thunk. It checks the ChainCall flag and since it set, it executes its epilog and jumps to the TailCallHelper again.
+  * If the previous frame was not a CallTarget thunk, get the address of the CallTarget thunk of the tailcall target from the arguments buffer and jump to it.
+* The CallTarget thunk function then does the following operation:
+  * Create local instance of TailCallHelperStack entry and store the current stack pointer value in it.
+  * Push the entry to the TailCallHelperStack of the current thread.
+  * Get the arguments buffer from the thread local storage, extract the regular arguments and the optional "this" and generic context arguments and the target function pointer. Release the buffer and call the target function. The frame of the CallTarget thunk ensures that the arguments of the target are GC protected until the target function returns or tail calls to another function.
+  * Pop the TailCallHelperStack entry from the TailCallHelperStack of the current thread.
+  * Check the ChainCall flag in the TailCallHelperStack entry. If it is set, run epilog and jump to the TailCallHelper.
+  * If the ChainCall flag is clear, it means that the last function in the tail call chain has returned. So return the return value of the target function.
+ 
+## Work that needs to be done to implement the new tail calls mechanism
+### JIT (compiler in the AOT scenario)
+* Modify compilation of tail calls with helper so that a tail call is compiled as a call to the StoreArguments thunk followed by the jump to the assembler TailCallHelper. In other words, the 
+```
+tail. call/callvirt <method>
+ret
+```
+becomes
+```
+call/callvirt <StoreArguments thunk>
+tail. call <TailCallHelper>
+ret
+```
+### Runtime (compiler in the AOT scenario)
+* Add generation of the StoreArguments and CallTarget IL thunks to the runtime (compiler tool chain in at AOT scenario). As a possible optimization, In the AOT scenario, the thunks can be generated by the compiler as native code directly without the intermediate IL.
+* For the JIT scenario, add a new method to the JIT to EE interface to get the StoreArguments thunk method handle for a given target method and the TailCallHelper address.
+
+### Runtime in both scenarios
+* Add support for the arguments buffer, which means:
+  * Add functions to create, release and get the buffer for a thread
+  * Add support for GC scanning the arguments buffers.
+* Implement the TailCallHelper asm helper for all architectures
+### Debugging in both scenarios
+Ensure that the stepping in a debugger works correctly. In CoreCLR, the TailCallStubManager needs to be updated accordingly.
+
+## Example code
+
+```C#
+struct S
+{
+    public S(long p1, long p2, long p3)
+    {
+        s1 = p1; s2 = p2; s3 = p3;
+    }
+ 
+    public long s1, s2, s3;
+}
+ 
+struct T
+{
+    public T(S s)
+    {
+        t1 = s.s1; t2 = s.s2; t3 = s.s3 t4 = 4;
+    }
+    public long t1, t2, t3, t4;
+}
+ 
+struct U
+{
+    public U(T t)
+    {
+        u1 = t.t1; u2 = t.t2; u3 = t.t3 u4 = t.t4; u5 = 5;
+    }
+    public long u1, u2, u3, u4, u5;
+}
+
+int D(U u)
+{
+    int local;
+    Console.WriteLine("In C, U = [{0}, {1}, {2}, {3}, {4}", u.u1, u.u2, u.u3, u.u4, u.u5);
+    return 1;
+}
+ 
+int C(T t)
+{
+    int local;
+    Console.WriteLine("In C");
+    U args = new U(t);
+    return tailcall D(args);
+}
+ 
+int B(S s)
+{
+    int local;
+    Console.WriteLine("In B");
+    T args = new T(S);
+    return tailcall C(args);
+}
+ 
+int A()
+{
+    S args = new S(1, 2, 3);
+    int result = B(args);
+    Console.WriteLine("Done, result = {0}\n", result);
+}
+```
+
+## Example code execution
+This section shows how stack evolves during the execution of the example code above. Execution starts at function A, but the details below start at the interesting point where the first tail call is about to be called.
+### B is about to tail call C
+```
+* Return address of A
+* Callee saved registers and locals of A
+* Stack arguments of B
+* Return address of B
+* Callee saved registers and locals of B
+```
+### Arguments of C are stored in the thread local buffer, now we are in the TailCallHelper
+The callee saved registers and locals of B are not on the stack anymore 
+```
+* Return address of A
+* Callee saved registers and locals of A
+* Stack arguments of B
+* Return address of B
+```
+
+### In CallTarget thunk for C, about to call C
+The thunk will now extract parameters for C from the thread local storage and call C.
+```
+* Return address of A
+* Callee saved registers and locals of A
+* Stack arguments of B
+* Return address of B
+* Callee saved registers and locals of CallTarget thunk for C
+```
+### C is about to tail call D
+```
+* Return address of A
+* Callee saved registers and locals of A
+* Stack arguments of B
+* Return address of B
+* Callee saved registers and locals of CallTarget thunk for C
+* Stack arguments of C
+* Return address of C
+* Callee saved registers and locals of C
+```
+### Arguments of D are stored in the thread local buffer, now we are in the TailCallHelper
+The callee saved registers and locals of C are not on the stack anymore. 
+But we still have the return address of C, stack arguments of C and callee saved registers and locals of CallTarget thunk for C on the stack.
+We need to remove them as well to prevent stack growing.
+The TailCallHelper detects that the previous stack frame was the frame of the CallTarget thunk for C and so it sets the ChainCall flag in the topmost TailCallHelperStackEntry and returns to CallTarget thunk for C in order to let it cleanup its stack frame.    
+```
+* Return address of A
+* Callee saved registers and locals of A
+* Stack arguments of B
+* Return address of B
+* Callee saved registers and locals of CallTarget thunk for C
+* Stack arguments of C
+* Return address of C
+```
+### Returned to CallTarget thunk for C with ChainCall flag in the TailCallHelperStackEntry **set**
+The thunk checks the ChainCall flag and since it is set, it runs its epilog and then jumps to the TailCallHelper. 
+```
+* Return address of A
+* Callee saved registers and locals of A
+* Stack arguments of B
+* Return address of B
+* Callee saved registers and locals of CallTarget thunk for C
+```
+### Back in TailCallHelper
+Now the stack is back in the state where we have made the previous tail call. Since the previous stack frame was not a CallTarget thunk frame, we just jump to the CallTarget thunk for D.  
+```
+* Return address of A
+* Callee saved registers and locals of A
+* Stack arguments of B
+* Return address of B
+```
+### In CallTarget thunk for D, about to call D
+The thunk will now extract parameters for D from the thread local storage and call D.
+```
+* Return address of A
+* Callee saved registers and locals of A
+* Stack arguments of B
+* Return address of B
+* Callee saved registers and locals of CallTarget thunk for D
+```
+### In D
+We are in the last function of the chain, so after it does its work, it returns to its CallTarget thunk. 
+```
+* Return address of A
+* Callee saved registers and locals of A
+* Stack arguments of B
+* Return address of B
+* Callee saved registers and locals of CallTarget thunk for D
+* Stack arguments of D
+* Return address of D
+* Callee saved registers and locals of D
+```
+### Returned to CallTarget thunk for D with ChainCall flag in the TailCallHelperStackEntry **clear**
+The thunk checks the ChainCall flag and since it is clear, it recognizes we are now returning from the call chain and so it returns the result of the D. 
+```
+* Return address of A
+* Callee saved registers and locals of A
+* Stack arguments of B
+* Return address of B
+* Callee saved registers and locals of CallTarget thunk for D
+```
+### Returned to A
+We are back in A and we have the return value of the call chain.
+```
+* Return address of A
+* Callee saved registers and locals of A
+```
+
+## Example of thunks generated for a simple generic method
+
+```C#
+struct Point
+{
+    public int x;
+    public int y;
+    public int z;
+}
+
+class Foo
+{
+    public Point Test<T>(int x, T t) where T : class
+    {
+        Console.WriteLine("T: {0}", typeof(t));
+        return new Point(x, x, x);
+    }
+}
+```
+
+For tail calling the Test function, the IL helpers could look e.g. as follows:
+
+```IL
+.method public static void StoreArgumentsTest(native int target, object thisObj, native int genericContext, int x, object t) cil managed
+{
+    .maxstack 4
+    .locals init (
+       [0] native int buffer,
+    )
+
+    call native int AllocateArgumentBuffer(56)
+    stloc.0
+
+    ldloc.0
+    ldc.i8 0x12345678 // pointer to the GC descriptor of the arguments buffer
+    stind.i
+    ldloc.0
+    sizeof native int
+    add
+    stloc.0
+
+    ldloc.0
+    ldftn Point CallTargetTest()
+    stind.i
+    ldloc.0
+    sizeof native int
+    add
+    stloc.0
+
+    ldloc.0
+    ldarg.1 // "thisObj"
+    stobj object
+    ldloc.0
+    sizeof object
+    add
+    stloc.0
+
+    ldloc.0
+    ldarg.2 // "genericContext"
+    stind.i
+    ldloc.0
+    sizeof native int
+    add
+    stloc.0
+
+    ldloc.0
+    ldarg.3 // "x"
+    stind.i4
+    ldloc.0
+    sizeof native int
+    add
+    stloc.0
+
+    ldloc.0
+    ldarg.4 // "t"
+    stobj object
+    ldloc.0
+    sizeof object
+    add
+    stloc.0
+
+    ldloc.0
+    ldarg.0 // "target"
+    stind.i
+
+    ret
+}
+
+```
+
+```IL
+.method public static Point CallTargetTest() cil managed
+{
+    .maxstack 4
+    .locals init (
+       [0] native int buffer,
+       [1] valuetype TailCallHelperStackEntry entry,
+       [2] Point result
+    )
+
+    // Initialize the TailCallHelperStackEntry
+    // chainCall = false
+    // sp = current sp
+
+    ldloca.s 1
+    ldc.i4.0
+    stfld bool TailCallHelperStackEntry::chainCall
+    ldloca.s 1
+    call native int GetCurrentSp()
+    stfld native int TailCallHelperStackEntry::sp
+
+    ldloca.s 1 // TailCallHelperStackEntry
+    call void PushHelperStackEntry(native int)
+
+    // Prepare arguments for the tail call target
+
+    call native int FetchArgumentBuffer()
+    sizeof native int
+    add // skip the pointer to the GC descriptor of the arguments buffer
+    sizeof native int
+    add // skip the address of the CallTargetTest in the buffer, it is used by the TailCallHelper only
+    stloc.0
+
+    ldloc.0
+    ldobj object // this
+    ldloc.0
+    sizeof object
+    add
+    stloc.0
+
+    ldloc.0
+    ldind.i // generic context
+    ldloc.0
+    sizeof native int
+    add
+    stloc.0
+
+    ldloc.0
+    ldind.i4 // int x
+    ldloc.0
+    sizeof native int
+    add
+    stloc.0
+
+    ldloc.0
+    ldobj object // T t
+    ldloc.0
+    sizeof object
+    add
+
+    ldobj native int // tailcall target
+
+    // The arguments buffer is not needed anymore
+    call void ReleaseArgumentBuffer()
+
+    .try
+    {
+        calli Point (object, native int, int32, object) // this, generic context, x, t
+        stloc.2
+        leave.s Done
+    }
+    finally
+    {
+        ldloca.s 1 // TailCallHelperStackEntry
+        call void PopHelperStackEntry(native int)
+        endfinally
+    }
+
+Done:
+    ldloc.1 // TailCallHelperStackEntry
+    ldfld bool TailCallHelperStackEntry::chainCall
+    brfalse.s NotChained
+
+    // Jump to the TailCallHelper that will call to the next tail call in the chain.
+    // The stack frame of the current CallTargetTest is reclaimed and epilog executed
+    // before the TailCallHelper is entered.
+    tail.call int32 TailCallHelper()
+    ret
+
+NotChained:
+    // Now we are returning from a chain of tail calls to the caller of this chain
+    ldloc.2
+    ret
+}
+```
\ No newline at end of file
diff --git a/Documentation/project-docs/glossary.md b/Documentation/project-docs/glossary.md
index 670254ddb6..f4ae1c5127 100644
--- a/Documentation/project-docs/glossary.md
+++ b/Documentation/project-docs/glossary.md
@@ -5,6 +5,7 @@ This glossary defines terms, both common and more niche, that are important to u
 
 As much as possible, we should link to the most authoritative and recent source of information for a term. That approach should be the most helpful for people who want to learn more about a topic.
 
+* BBT: Microsoft internal early version of C/C++ PGO. See https://www.microsoft.com/windows/cse/bit_projects.mspx.
 * BOTR: Book Of The Runtime.
 * CLR: Common Language Runtime.
 * COMPlus: An early name for the .NET platform, back when it was envisioned as a successor to the COM platform (hence, "COM+"). Used in various places in the CLR infrastructure, most prominently as a common prefix for the names of internal configuration settings. Note that this is different from the product that eventually ended up being named [COM+](https://msdn.microsoft.com/en-us/library/windows/desktop/ms685978.aspx).
@@ -12,19 +13,25 @@ As much as possible, we should link to the most authoritative and recent source
 * DAC: Data Access Component. An abstraction layer over the internal structures in the runtime.
 * EE: Execution Engine.
 * GC: [Garbage Collector](https://github.com/dotnet/coreclr/blob/master/Documentation/botr/garbage-collection.md).
+* IPC: Inter-Process Communicaton
 * JIT: [Just-in-Time](https://github.com/dotnet/coreclr/blob/master/Documentation/botr/ryujit-overview.md) compiler. RyuJIT is the code name for the next generation Just-in-Time(aka "JIT") for the .NET runtime.
 * LCG: Lightweight Code Generation. An early name for [dynamic methods](https://github.com/dotnet/coreclr/blob/master/src/mscorlib/src/System/Reflection/Emit/DynamicMethod.cs).
+* MD: MetaData
 * NGen: Native Image Generator.
 * NYI: Not Yet Implemented
 * PAL: [Platform Adaptation Layer](http://archive.oreilly.com/pub/a/dotnet/2002/03/04/rotor.html). Provides an abstraction layer between the runtime and the operating system
 * PE: Portable Executable.
+* PGO: Profile Guided Optimization - see [details](https://blogs.msdn.microsoft.com/vcblog/2008/11/12/pogo/)
+* POGO: Profile Guided Optimization - see [details](https://blogs.msdn.microsoft.com/vcblog/2008/11/12/pogo/)
 * ProjectN: Codename for the first version of [.NET Native for UWP](https://msdn.microsoft.com/en-us/vstudio/dotnetnative.aspx).
 * ReadyToRun: A flavor of native images - command line switch of [crossgen](../building/crossgen.md).
 * Redhawk: Codename for experimental minimal managed code runtime that evolved into [CoreRT](https://github.com/dotnet/corert/).
 * SOS: [Son of Strike](http://blogs.msdn.com/b/jasonz/archive/2003/10/21/53581.aspx). The debugging extension for DbgEng based debuggers. Uses the DAC as an abstraction layer for its operation.
+* SuperPMI: JIT component test framework (super fast JIT testing - it mocks/replays EE in EE-JIT interface) - see [SuperPMI details](https://github.com/dotnet/coreclr/blob/master/src/ToolBox/superpmi/readme.txt).
 * SVR: The CLR used to be built as two variants, with one called "mscorsvr.dll", to mean the "server" version. In particular, it contained the server GC implementation, which was intended for multi-threaded apps capable of taking advantage of multiple processors. In the .NET Framework 2 release, the two variants were merged into "mscorwks.dll". The WKS version was the default, however the SVR version remained available.
 * TPA: Trusted Platform Assemblies used to be a special set of assemblies that comprised the platform assemblies, when it was originally designed. As of today, it is simply the set of assemblies known to constitute the application.
 * URT: Universal Runtime. Ancient name for what ended up being .NET, is used in the WinError facility name FACILITY_URT.
 * VSD: [Virtual Stub Dispatch](../botr/virtual-stub-dispatch.md). Technique of using stubs for virtual method invocations instead of the traditional virtual method table.
 * VM: Virtual machine.
 * WKS: The CLR used to be built as two variants, with one called "mscorwks.dll", to mean the "workstation" version. In particular, it contained the client GC implementation, which was intended for single-threaded apps, independent of how many processors were on the machine. In the .NET Framework 2 release, the two variants were merged into "mscorwks.dll". The WKS version was the default, however the SVR version remained available.
+* ZAP: Original code name for NGen
diff --git a/build-test.cmd b/build-test.cmd
index a2ff71746b..85753abccf 100644
--- a/build-test.cmd
+++ b/build-test.cmd
@@ -23,6 +23,9 @@ set "__PackagesDir=%__ProjectDir%\packages"
 set "__RootBinDir=%__ProjectDir%\bin"
 set "__LogsDir=%__RootBinDir%\Logs"
 
+:: Default __Exclude to issues.targets
+set __Exclude=%__TestDir%\issues.targets
+
 REM __unprocessedBuildArgs are args that we pass to msbuild (e.g. /p:__BuildArch=x64)
 set "__args= %*"
 set processedArgs=
@@ -51,8 +54,9 @@ if /i "%1" == "checked"               (set __BuildType=Checked&set processedArgs
 if /i "%1" == "skipmanaged"           (set __SkipManaged=1&set processedArgs=!processedArgs! %1&shift&goto Arg_Loop)
 if /i "%1" == "updateinvalidpackages" (set __UpdateInvalidPackagesArg=1&set processedArgs=!processedArgs! %1&shift&goto Arg_Loop)
 if /i "%1" == "toolset_dir"           (set __ToolsetDir=%2&set __PassThroughArgs=%__PassThroughArgs% %2&set processedArgs=!processedArgs! %1 %2&shift&shift&goto Arg_Loop)
-if /i "%1" == "buildagainstpackages"  (set __BuildAgainstPackages=1&set __BuildAgainstPackagesArg=-BuildTestsAgainstPackages&shift&goto Arg_Loop)
+if /i "%1" == "buildagainstpackages"  (set __BuildAgainstPackages=1&set __BuildAgainstPackagesArg=-BuildTestsAgainstPackages&set processedArgs=!processedArgs! %1&shift&goto Arg_Loop)
 if /i "%1" == "runtimeid"             (set __RuntimeId=%2&set processedArgs=!processedArgs! %1 %2&shift&shift&goto Arg_Loop)
+if /i "%1" == "Exclude"              (set __Exclude=%2&set processedArgs=!processedArgs! %1 %2&shift&shift&goto Arg_Loop)
 
 if [!processedArgs!]==[] (
   call set __UnprocessedBuildArgs=!__args!
@@ -189,6 +193,8 @@ set __msbuildLog=/flp:Verbosity=normal;LogFile="%__BuildLog%"
 set __msbuildWrn=/flp1:WarningsOnly;LogFile="%__BuildWrn%"
 set __msbuildErr=/flp2:ErrorsOnly;LogFile="%__BuildErr%"
 
+set "__TestWorkingDir=%__RootBinDir%\tests\%__BuildOS%.%__BuildArch%.%__BuildType%"
+
 if not defined __BuildAgainstPackages goto SkipRestoreProduct
 REM =========================================================================================
 REM ===
@@ -196,10 +202,9 @@ REM === Restore product binaries from packages
 REM ===
 REM =========================================================================================
 
-set "__TestWorkingDir=%__RootBinDir%\tests\%__BuildOS%.%__BuildArch%.%__BuildType%"
 if not defined XunitTestBinBase       set  XunitTestBinBase=%__TestWorkingDir%
 set "CORE_ROOT=%XunitTestBinBase%\Tests\Core_Root"
-set "CORE_OVERLAY=%XunitTestBinBase%\Tests\coreoverlay"
+set "CORE_OVERLAY=%XunitTestBinBase%\Tests\Core_Root_%__RuntimeId%"
 
 call "%__ProjectDir%\run.cmd" build -Project=%__ProjectDir%\tests\build.proj  -UpdateDependencies -BatchRestorePackages -MsBuildLog=!__msbuildLog! -MsBuildWrn=!__msbuildWrn! -MsBuildErr=!__msbuildErr! %__RunArgs% %__BuildAgainstPackagesArg% %__unprocessedBuildArgs%
 
@@ -219,13 +224,13 @@ if defined __RuntimeId (
     )
 
     call "%__ProjectDir%\run.cmd" build -Project=%__ProjectDir%\tests\runtest.proj -CreateNonWindowsTestOverlay -RuntimeId="%__RuntimeId%"  -MsBuildLog=!__msbuildLog! -MsBuildWrn=!__msbuildWrn! -MsBuildErr=!__msbuildErr! %__RunArgs% %__BuildAgainstPackagesArg% %__unprocessedBuildArgs%
-    for /R %__PackagesDir%\TestNativeBins\%__RuntimeId% %%f in (*.so) do copy %%f %Core_Overlay%
-    for /R %__PackagesDir%\TestNativeBins\%__RuntimeId% %%f in (*.dylib) do copy %%f %Core_Overlay%
+    for /R %__PackagesDir%\TestNativeBins\%__RuntimeId%\%__BuildType% %%f in (*.so) do copy %%f %Core_Overlay%
+    for /R %__PackagesDir%\TestNativeBins\%__RuntimeId%\%__BuildType% %%f in (*.dylib) do copy %%f %Core_Overlay%
 
     echo %__MsgPrefix% Created the runtime layout for %__RuntimeId% in %CORE_OVERLAY%
 )
 
-echo %__MsgPrefix% Created the runtime layout with all dependencies in %CORE_ROOT%
+echo %__MsgPrefix% Restored CoreCLR product from packages
 
 :SkipRestoreProduct
 
@@ -265,7 +270,38 @@ if errorlevel 1 (
     exit /b 1
 )
 
+REM Prepare the Test Drop
+REM Cleans any NI from the last run
+powershell "Get-ChildItem -path %__TestWorkingDir% -Include '*.ni.*' -Recurse -Force | Remove-Item -force"
+REM Cleans up any lock folder used for synchronization from last run
+powershell "Get-ChildItem -path %__TestWorkingDir% -Include 'lock' -Recurse -Force |  where {$_.Attributes -eq 'Directory'}| Remove-Item -force -Recurse"
+
 set CORE_ROOT=%__TestBinDir%\Tests\Core_Root
+if exist "%CORE_ROOT%" rd /s /q "%CORE_ROOT%"
+md "%CORE_ROOT%"
+xcopy /s "%__BinDir%" "%CORE_ROOT%"
+
+echo %__MsgPrefix%Creating test wrappers...
+
+set RuntimeIdArg=
+
+if defined __RuntimeId (
+    set RuntimeIdArg=-RuntimeID="%__RuntimeId%"
+)
+
+set __BuildLogRootName=Tests_XunitWrapper
+set __BuildLog=%__LogsDir%\%__BuildLogRootName%_%__BuildOS%__%__BuildArch%__%__BuildType%.log
+set __BuildWrn=%__LogsDir%\%__BuildLogRootName%_%__BuildOS%__%__BuildArch%__%__BuildType%.wrn
+set __BuildErr=%__LogsDir%\%__BuildLogRootName%_%__BuildOS%__%__BuildArch%__%__BuildType%.err
+set __msbuildLog=/flp:Verbosity=diag;LogFile="%__BuildLog%"
+set __msbuildWrn=/flp1:WarningsOnly;LogFile="%__BuildWrn%"
+set __msbuildErr=/flp2:ErrorsOnly;LogFile="%__BuildErr%"
+
+call %__ProjectDir%\run.cmd build -Project=%__ProjectDir%\tests\runtest.proj -BuildWrappers -MsBuildEventLogging=" " -MsBuildLog=!__msbuildLog! -MsBuildWrn=!__msbuildWrn! -MsBuildErr=!__msbuildErr! %__RunArgs% %__BuildAgainstPackagesArg% %__unprocessedBuildArgs% %RuntimeIdArg%
+if errorlevel 1 (
+    echo Xunit Wrapper build failed
+    exit /b 1
+)
 
 echo %__MsgPrefix%Creating test overlay...
 
@@ -277,7 +313,7 @@ set __msbuildLog=/flp:Verbosity=normal;LogFile="%__BuildLog%"
 set __msbuildWrn=/flp1:WarningsOnly;LogFile="%__BuildWrn%"
 set __msbuildErr=/flp2:ErrorsOnly;LogFile="%__BuildErr%"
 
-call "%__ProjectDir%\run.cmd" build -Project=%__ProjectDir%\tests\runtest.proj -testOverlay -MsBuildLog=!__msbuildLog! -MsBuildWrn=!__msbuildWrn! -MsBuildErr=!__msbuildErr! %__RunArgs% %__unprocessedBuildArgs%
+call %__ProjectDir%\run.cmd build -Project=%__ProjectDir%\tests\runtest.proj -testOverlay -MsBuildLog=!__msbuildLog! -MsBuildWrn=!__msbuildWrn! -MsBuildErr=!__msbuildErr! %__RunArgs% %__unprocessedBuildArgs%
 if errorlevel 1 (
     echo %__MsgPrefix%Error: build failed. Refer to the build log files for details:
     echo     %__BuildLog%
@@ -286,6 +322,28 @@ if errorlevel 1 (
     exit /b 1
 )
 
+if not defined __BuildAgainstPackages goto SkipPrepForPublish
+
+set __BuildLogRootName=Helix_Prep
+set __BuildLog=%__LogsDir%\%__BuildLogRootName%_%__BuildOS%__%__BuildArch%__%__BuildType%.log
+set __BuildWrn=%__LogsDir%\%__BuildLogRootName%_%__BuildOS%__%__BuildArch%__%__BuildType%.wrn
+set __BuildErr=%__LogsDir%\%__BuildLogRootName%_%__BuildOS%__%__BuildArch%__%__BuildType%.err
+set __msbuildLog=/flp:Verbosity=normal;LogFile="%__BuildLog%"
+set __msbuildWrn=/flp1:WarningsOnly;LogFile="%__BuildWrn%"
+set __msbuildErr=/flp2:ErrorsOnly;LogFile="%__BuildErr%"
+
+REM =========================================================================================
+REM ===
+REM === Prep test binaries for Helix publishing
+REM ===
+REM =========================================================================================
+
+call %__ProjectDir%\run.cmd build -Project=%__ProjectDir%\tests\helixprep.proj  -MsBuildLog=!__msbuildLog! -MsBuildWrn=!__msbuildWrn! -MsBuildErr=!__msbuildErr! %__RunArgs% %__BuildAgainstPackagesArg% %__unprocessedBuildArgs% %RuntimeIdArg%
+
+echo %__MsgPrefix% Prepped test binaries for publishing
+
+:SkipPrepForPublish
+
 REM =========================================================================================
 REM ===
 REM === All builds complete!
@@ -308,8 +366,10 @@ echo Build type: -buildType: one of Debug, Checked, Release ^(default: Debug^).
 echo updateinvalidpackageversions: Runs the target to update package versions.
 echo buildagainstpackages: builds tests against restored packages, instead of against a built product.
 echo runtimeid ^<ID^>: Builds a test overlay for the specified OS (Only supported when building against packages). Supported IDs are:
+echo     alpine.3.4.3-x64: Builds overlay for Alpine 3.4.3
 echo     debian.8-x64: Builds overlay for Debian 8
 echo     fedora.23-x64: Builds overlay for Fedora 23
+echo     fedora.24-x64: Builds overlay for Fedora 23
 echo     opensuse.13.2-x64: Builds overlay for OpenSUSE 13.2
 echo     opensuse.42.1-x64: Builds overlay for OpenSUSE 42.1
 echo     osx.10.10-x64: Builds overlay for OSX 10.10
@@ -317,6 +377,8 @@ echo     rhel.7-x64: Builds overlay for RHEL 7 or CentOS
 echo     ubuntu.14.04-x64: Builds overlay for Ubuntu 14.04
 echo     ubuntu.16.04-x64: Builds overlay for Ubuntu 16.04
 echo     ubuntu.16.10-x64: Builds overlay for Ubuntu 16.10
+echo Exclude- Optional parameter - specify location of default exclusion file (defaults to tests\issues.targets if not specified)
+echo     Set to "" to disable default exclusion file.
 echo -- ... : all arguments following this tag will be passed directly to msbuild.
 echo -priority=^<N^> : specify a set of test that will be built and run, with priority N.
 echo     0: Build only priority 0 cases as essential testcases (default)
diff --git a/build.cmd b/build.cmd
index 1d95307a6e..a37428ca6b 100644
--- a/build.cmd
+++ b/build.cmd
@@ -388,13 +388,15 @@ if %__BuildNativeCoreLib% EQU 1 (
     "%__CrossgenExe%" /Platform_Assemblies_Paths "%__BinDir%" /out "%__BinDir%\System.Private.CoreLib.ni.dll" "%__BinDir%\System.Private.CoreLib.dll" > "%__CrossGenCoreLibLog%" 2>&1
     if NOT !errorlevel! == 0 (
         echo %__MsgPrefix%Error: CrossGen System.Private.CoreLib build failed. Refer to %__CrossGenCoreLibLog%
-        echo     %__CrossGenCoreLibLog%
+        :: Put it in the same log, helpful for Jenkins
+        type %__CrossGenCoreLibLog%
         exit /b 1
     )
     "%__CrossgenExe%" /Platform_Assemblies_Paths "%__BinDir%" /CreatePdb "%__BinDir%\PDB" "%__BinDir%\System.Private.CoreLib.ni.dll" >> "%__CrossGenCoreLibLog%" 2>&1
     if NOT !errorlevel! == 0 (
         echo %__MsgPrefix%Error: CrossGen /CreatePdb System.Private.CoreLib build failed. Refer to %__CrossGenCoreLibLog%
-        echo     %__CrossGenCoreLibLog%
+        :: Put it in the same log, helpful for Jenkins
+        type %__CrossGenCoreLibLog%
         exit /b 1
     )
 
@@ -417,8 +419,9 @@ if %__BuildNativeCoreLib% EQU 1 (
     )
 
     if NOT !err! == 0 (
-        echo %__MsgPrefix%Error: CrossGen mscorlib facade build failed. Refer to the build log file for details:
-        echo     !__CrossGenCoreLibLog!
+        echo %__MsgPrefix%Error: CrossGen mscorlib facade build failed. Refer to !__CrossGenCoreLibLog!
+        :: Put it in the same log, helpful for Jenkins
+        type %__CrossGenCoreLibLog%        
         exit /b 1
     )
 )
diff --git a/build.sh b/build.sh
index a312f469a6..bc4adb43df 100755
--- a/build.sh
+++ b/build.sh
@@ -277,6 +277,8 @@ build_cross_arch_component()
     
     export __CMakeBinDir="$__CrossComponentBinDir"
     export CROSSCOMPONENT=1
+    __IncludeTests=
+
     if [ $CROSSCOMPILE == 1 ]; then
         TARGET_ROOTFS="$ROOTFS_DIR"
         if [ -n "$CAC_ROOTFS_DIR" ]; then
@@ -476,7 +478,6 @@ case $CPUName in
         ;;
 
     aarch64)
-        echo "Unsupported CPU $CPUName detected, build might not succeed!"
         __BuildArch=arm64
         __HostArch=arm64
         ;;
diff --git a/clr.coreclr.props b/clr.coreclr.props
index ed5dd1a2ec..9211976c39 100644
--- a/clr.coreclr.props
+++ b/clr.coreclr.props
@@ -50,6 +50,7 @@
     <!-- The rejit feature is available only on supported architectures (x86 & x64) -->
     <FeatureReJIT Condition="('$(TargetArch)' == 'i386') or ('$(TargetArch)' == 'amd64')">true</FeatureReJIT>
     <FeatureManagedEtw>true</FeatureManagedEtw>
+    <FeatureManagedEtwChannels>true</FeatureManagedEtwChannels>
     <BinderDebugLog Condition="'$(_BuildType)'=='dbg'">true</BinderDebugLog>
     <FeatureAppX>true</FeatureAppX>
     <FeatureWinMDResilient>true</FeatureWinMDResilient>
diff --git a/clr.defines.targets b/clr.defines.targets
index c3bb70dbad..61ee17a419 100644
--- a/clr.defines.targets
+++ b/clr.defines.targets
@@ -7,16 +7,12 @@
         <CDefines Condition="'$(FeatureAppX)' == 'true'">$(CDefines);FEATURE_APPX</CDefines>
         <CDefines Condition="'$(FeatureArrayStubAsIL)' == 'true'">$(CDefines);FEATURE_ARRAYSTUB_AS_IL</CDefines>
         <CDefines Condition="'$(FeatureStubsAsIL)' == 'true'">$(CDefines);FEATURE_STUBS_AS_IL</CDefines>
-        <CDefines Condition="'$(FeatureCasPolicy)' == 'true'">$(CDefines);FEATURE_CAS_POLICY</CDefines>
         <CDefines Condition="'$(FeatureClassicCominterop)' == 'true'">$(CDefines);FEATURE_CLASSIC_COMINTEROP</CDefines>
-        <CDefines Condition="'$(FeatureClickonce)' == 'true'">$(CDefines);FEATURE_CLICKONCE</CDefines>
         <CDefines Condition="'$(FeatureTraceLogging)' == 'true'">$(CDefines);FEATURE_TRACELOGGING</CDefines>
         <CDefines Condition="'$(FeatureCollectibleTypes)' == 'true'">$(CDefines);FEATURE_COLLECTIBLE_TYPES</CDefines>
         <CDefines Condition="'$(FeatureCominterop)' == 'true'">$(CDefines);FEATURE_COMINTEROP</CDefines>
         <CDefines Condition="'$(FeatureICastable)' == 'true'">$(CDefines);FEATURE_ICASTABLE</CDefines>
         <CDefines Condition="'$(FeatureCominteropApartmentSupport)' == 'true'">$(CDefines);FEATURE_COMINTEROP_APARTMENT_SUPPORT</CDefines>
-        <CDefines Condition="'$(FeatureCominteropRegistration)' == 'true'">$(CDefines);FEATURE_COMINTEROP_REGISTRATION</CDefines>
-        <CDefines Condition="'$(FeatureCominteropTlbSupport)' == 'true'">$(CDefines);FEATURE_COMINTEROP_TLB_SUPPORT</CDefines>
         <CDefines Condition="'$(FeatureCominteropUnmanagedActivation)' == 'true'">$(CDefines);FEATURE_COMINTEROP_UNMANAGED_ACTIVATION</CDefines>
         <CDefines Condition="'$(FeatureCominteropWinRTManagedActivation)' == 'true'">$(CDefines);FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION</CDefines>  <!-- Enables code required to activate managed winrt from native-->
         <CDefines Condition="'$(FeatureCoreFxGlobalization)' == 'true'">$(CDefines);FEATURE_COREFX_GLOBALIZATION</CDefines>
@@ -26,7 +22,6 @@
         <CDefines Condition="'$(FeatureEventTrace)' == 'true'">$(CDefines);FEATURE_EVENT_TRACE</CDefines>
         <CDefines Condition="'$(FeatureXplatEventSource)' == 'true'">$(CDefines);FEATURE_EVENTSOURCE_XPLAT</CDefines>
         <CDefines Condition="'$(FeatureFullNGen)' == 'true'">$(CDefines);FEATURE_FULL_NGEN</CDefines>
-        <CDefines Condition="'$(FeatureFusion)' == 'true'">$(CDefines);FEATURE_FUSION</CDefines>
         <CDefines Condition="'$(FeatureHijack)' == 'true'">$(CDefines);FEATURE_HIJACK</CDefines>
         <CDefines Condition="'$(FeatureImpersonation)' == 'true'">$(CDefines);FEATURE_IMPERSONATION</CDefines>
         <CDefines Condition="'$(FeatureIncludeAllInterfaces)' == 'true'">$(CDefines);FEATURE_INCLUDE_ALL_INTERFACES</CDefines>
@@ -40,8 +35,8 @@
         <CDefines Condition="'$(FeatureLegacyNetCFDbgHostControl)' == 'true'">$(CDefines);FEATURE_LEGACYNETCF_DBG_HOST_CONTROL</CDefines> 
         <CDefines Condition="'$(FeatureMacl)' == 'true'">$(CDefines);FEATURE_MACL</CDefines>
         <CDefines Condition="'$(FeatureManagedEtw)' == 'true'">$(CDefines);FEATURE_MANAGED_ETW</CDefines>
+        <CDefines Condition="'$(FeatureManagedEtwChannels)' == 'true'">$(CDefines);FEATURE_MANAGED_ETW_CHANNELS</CDefines>
         <CDefines Condition="'$(FeatureMdaSupported)' == 'true'">$(CDefines);MDA_SUPPORTED</CDefines>
-        <CDefines Condition="'$(FeatureMergeCultureSupportAndEngine)' == 'true'">$(CDefines);FEATURE_MERGE_CULTURE_SUPPORT_AND_ENGINE</CDefines>
         <CDefines Condition="'$(FeatureMergeJitAndEngine)' == 'true'">$(CDefines);FEATURE_MERGE_JIT_AND_ENGINE</CDefines>
         <CDefines Condition="'$(FeatureMetadataEmit)' == 'true'">$(CDefines);FEATURE_METADATA_EMIT</CDefines>
         <CDefines Condition="'$(FeatureMetadataEmitAll)' == 'true'">$(CDefines);FEATURE_METADATA_EMIT_ALL</CDefines>
@@ -71,7 +66,6 @@
         <CDefines Condition="'$(FeatureStrongnameDelaySigningAllowed)' == 'true'">$(CDefines);FEATURE_STRONGNAME_DELAY_SIGNING_ALLOWED</CDefines>
         <CDefines Condition="'$(FeatureSvrGc)' == 'true'">$(CDefines);FEATURE_SVR_GC</CDefines>
         <CDefines Condition="'$(FeaturePerfMap)' == 'true'">$(CDefines);FEATURE_PERFMAP</CDefines>
-        <CDefines Condition="'$(FeatureSyntheticCultures)' == 'true'">$(CDefines);FEATURE_SYNTHETIC_CULTURES</CDefines>
         <CDefines Condition="'$(FeatureTypeEquivalence)' == 'true'">$(CDefines);FEATURE_TYPEEQUIVALENCE</CDefines>
         <CDefines Condition="'$(FeatureUefChainmanager)' == 'true'">$(CDefines);FEATURE_UEF_CHAINMANAGER</CDefines>
         <CDefines Condition="'$(FeatureUseLcid)' == 'true'">$(CDefines);FEATURE_USE_LCID</CDefines>
@@ -96,9 +90,7 @@
         <DefineConstants Condition="'$(FeatureAppX)' == 'true'">$(DefineConstants);FEATURE_APPX</DefineConstants>
         <DefineConstants Condition="'$(FeatureArrayStubAsIL)' == 'true'">$(DefineConstants);FEATURE_ARRAYSTUB_AS_IL</DefineConstants>
         <DefineConstants Condition="'$(FeatureStubsAsIL)' == 'true'">$(DefineConstants);FEATURE_STUBS_AS_IL</DefineConstants>
-        <DefineConstants Condition="'$(FeatureCasPolicy)' == 'true'">$(DefineConstants);FEATURE_CAS_POLICY</DefineConstants>
         <DefineConstants Condition="'$(FeatureClassicCominterop)' == 'true'">$(DefineConstants);FEATURE_CLASSIC_COMINTEROP</DefineConstants>
-        <DefineConstants Condition="'$(FeatureClickonce)' == 'true'">$(DefineConstants);FEATURE_CLICKONCE</DefineConstants>
         <DefineConstants Condition="'$(FeatureCominterop)' == 'true'">$(DefineConstants);FEATURE_COMINTEROP</DefineConstants>
         <DefineConstants Condition="'$(FeatureCominteropApartmentSupport)' == 'true'">$(DefineConstants);FEATURE_COMINTEROP_APARTMENT_SUPPORT</DefineConstants>
         <DefineConstants Condition="'$(FeatureCominteropUnmanagedActivation)' == 'true'">$(DefineConstants);FEATURE_COMINTEROP_UNMANAGED_ACTIVATION</DefineConstants>
@@ -106,7 +98,6 @@
         <DefineConstants Condition="'$(FeatureCoreFxGlobalization)' == 'true'">$(DefineConstants);FEATURE_COREFX_GLOBALIZATION</DefineConstants>
         <DefineConstants Condition="'$(FeatureDisplayCultureInfo)' == 'true'">$(DefineConstants);FEATURE_DISPLAY_CULTURE_INFO</DefineConstants>
         <DefineConstants Condition="'$(FeatureDisplayRegionInfo)' == 'true'">$(DefineConstants);FEATURE_DISPLAY_REGION_INFO</DefineConstants>
-        <DefineConstants Condition="'$(FeatureFusion)' == 'true'">$(DefineConstants);FEATURE_FUSION</DefineConstants>
         <DefineConstants Condition="'$(FeatureHosting)' == 'true'">$(DefineConstants);FEATURE_HOSTING</DefineConstants>
         <DefineConstants Condition="'$(FeatureIdentityReference)' == 'true'">$(DefineConstants);FEATURE_IDENTITY_REFERENCE</DefineConstants>
         <DefineConstants Condition="'$(FeatureImpersonation)' == 'true'">$(DefineConstants);FEATURE_IMPERSONATION</DefineConstants>
@@ -117,6 +108,7 @@
         <DefineConstants Condition="'$(FeatureIsostoreLight)' == 'true'">$(DefineConstants);FEATURE_ISOSTORE_LIGHT</DefineConstants>
         <DefineConstants Condition="'$(FeatureMacl)' == 'true'">$(DefineConstants);FEATURE_MACL</DefineConstants>
         <DefineConstants Condition="'$(FeatureManagedEtw)' == 'true'">$(DefineConstants);FEATURE_MANAGED_ETW</DefineConstants>
+        <DefineConstants Condition="'$(FeatureManagedEtwChannels)' == 'true'">$(DefineConstants);FEATURE_MANAGED_ETW_CHANNELS</DefineConstants>
         <DefineConstants Condition="'$(FeatureMultiModuleAssemblies)' == 'true'">$(DefineConstants);FEATURE_MULTIMODULE_ASSEMBLIES</DefineConstants>
         <DefineConstants Condition="'$(FeatureNongenericCollections)' == 'true'">$(DefineConstants);FEATURE_NONGENERIC_COLLECTIONS</DefineConstants>
         <DefineConstants Condition="'$(FeaturePal)' == 'true'">$(DefineConstants);FEATURE_PAL</DefineConstants>
@@ -127,7 +119,6 @@
         <DefineConstants Condition="'$(FeatureReflectionOnlyLoad)' == 'true'">$(DefineConstants);FEATURE_REFLECTION_ONLY_LOAD</DefineConstants>
         <DefineConstants Condition="'$(FeatureRemoting)' == 'true'">$(DefineConstants);FEATURE_REMOTING</DefineConstants>
         <DefineConstants Condition="'$(FeatureSortTables)' == 'true'">$(DefineConstants);FEATURE_SORT_TABLES</DefineConstants>
-        <DefineConstants Condition="'$(FeatureSyntheticCultures)' == 'true'">$(DefineConstants);FEATURE_SYNTHETIC_CULTURES</DefineConstants>
         <DefineConstants Condition="'$(FeatureTypeEquivalence)' == 'true'">$(DefineConstants);FEATURE_TYPEEQUIVALENCE</DefineConstants>
         <DefineConstants Condition="'$(FeatureUseLcid)' == 'true'">$(DefineConstants);FEATURE_USE_LCID</DefineConstants>
         <DefineConstants Condition="'$(FeatureValidator)' == 'true'">$(DefineConstants);FEATURE_VALIDATOR</DefineConstants>
diff --git a/clr.props b/clr.props
index 21462c96f8..b1d3618609 100644
--- a/clr.props
+++ b/clr.props
@@ -126,7 +126,6 @@
     <!-- If you add new features to this list make sure that they are not affecting codegen or content of datastructures persisted in NGen image -->
     <EnCSupported>false</EnCSupported>
     <PerfcountersSupportedBuild>false</PerfcountersSupportedBuild>
-    <FeatureCasPolicy>false</FeatureCasPolicy>
     <FeatureEventTrace>false</FeatureEventTrace>
     <FeatureFusion>false</FeatureFusion>
     <FeatureIncludeAllInterfaces>false</FeatureIncludeAllInterfaces>
@@ -242,7 +241,6 @@
     <ResgenDefines Condition="'$(FeatureImpersonation)' == '1'">$(ResgenDefines) /define:FEATURE_IMPERSONATION</ResgenDefines> 
     <ResgenDefines Condition="'$(FeatureIsostore)' == '1'">$(ResgenDefines) /define:FEATURE_ISOSTORE</ResgenDefines> 
     <ResgenDefines Condition="'$(FeatureMacl)' == '1'">$(ResgenDefines) /define:FEATURE_MACL</ResgenDefines> 
-    <ResgenDefines Condition="'$(FeatureCasPolicy)' == '1'">$(ResgenDefines) /define:FEATURE_CAS_POLICY</ResgenDefines> 
     <ResgenDefines Condition="'$(FeatureRemoting)' == '1'">$(ResgenDefines) /define:FEATURE_REMOTING</ResgenDefines> 
     <ResgenDefines Condition="'$(FeatureIdentityReference)' == '1'">$(ResgenDefines) /define:FEATURE_IDENTITY_REFERENCE</ResgenDefines> 
     <ResgenDefines Condition="'$(FeatureDisplayCultureInfo)' == '1'">$(ResgenDefines) /define:FEATURE_DISPLAY_CULTURE_INFO</ResgenDefines> 
diff --git a/clrdefinitions.cmake b/clrdefinitions.cmake
index a2b920c194..38d1b7d353 100644
--- a/clrdefinitions.cmake
+++ b/clrdefinitions.cmake
@@ -53,11 +53,11 @@ if (CLR_CMAKE_PLATFORM_UNIX)
     add_definitions(-D_XOPEN_SOURCE)
   endif(CLR_CMAKE_PLATFORM_DARWIN)
 
-  if (CLR_CMAKE_PLATFORM_UNIX_AMD64)
+  if (CLR_CMAKE_TARGET_ARCH_AMD64)
     add_definitions(-DUNIX_AMD64_ABI)
-  elseif (CLR_CMAKE_PLATFORM_UNIX_ARM)
+  elseif (CLR_CMAKE_TARGET_ARCH_ARM)
     add_definitions(-DUNIX_ARM_ABI)
-  elseif (CLR_CMAKE_PLATFORM_UNIX_X86)
+  elseif (CLR_CMAKE_TARGET_ARCH_I386)
     add_definitions(-DUNIX_X86_ABI)
   endif()
 
@@ -97,7 +97,6 @@ if(CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_ARM OR CLR_CMAKE_TARGET_
     add_definitions(-DFEATURE_ARRAYSTUB_AS_IL)
 endif()
 
-add_definitions(-DFEATURE_ASYNC_IO)
 add_definitions(-DFEATURE_COLLECTIBLE_TYPES)
 
 if(WIN32)
@@ -124,16 +123,13 @@ endif(FEATURE_EVENT_TRACE)
 if(CLR_CMAKE_PLATFORM_UNIX)
     add_definitions(-DFEATURE_EVENTSOURCE_XPLAT=1)
 endif(CLR_CMAKE_PLATFORM_UNIX)
-add_definitions(-DFEATURE_EXCEPTIONDISPATCHINFO)
-add_definitions(-DFEATURE_EXCEPTION_NOTIFICATIONS)
 # NetBSD doesn't implement this feature
 if(NOT CMAKE_SYSTEM_NAME STREQUAL NetBSD)
     add_definitions(-DFEATURE_HIJACK)
 endif(NOT CMAKE_SYSTEM_NAME STREQUAL NetBSD)
-add_definitions(-DFEATURE_HOST_ASSEMBLY_RESOLVER)
 add_definitions(-DFEATURE_ICASTABLE)
 if (WIN32 AND (CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_I386))
-add_definitions(-DFEATURE_INTEROP_DEBUGGING)
+    add_definitions(-DFEATURE_INTEROP_DEBUGGING)
 endif (WIN32 AND (CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_I386))
 if (CLR_CMAKE_PLATFORM_UNIX OR CLR_CMAKE_TARGET_ARCH_ARM64)
   add_definitions(-DFEATURE_IMPLICIT_TLS)
@@ -142,18 +138,15 @@ endif(CLR_CMAKE_PLATFORM_UNIX OR CLR_CMAKE_TARGET_ARCH_ARM64)
 add_definitions(-DFEATURE_ISYM_READER)
 add_definitions(-DFEATURE_LOADER_OPTIMIZATION)
 if (NOT CLR_CMAKE_PLATFORM_UNIX)
-add_definitions(-DFEATURE_MANAGED_ETW)
+    add_definitions(-DFEATURE_MANAGED_ETW)
 endif(NOT CLR_CMAKE_PLATFORM_UNIX)
 add_definitions(-DFEATURE_MANAGED_ETW_CHANNELS)
-add_definitions(-DFEATURE_MAIN_CLR_MODULE_USES_CORE_NAME)
-add_definitions(-DFEATURE_MERGE_CULTURE_SUPPORT_AND_ENGINE)
 
 if(FEATURE_MERGE_JIT_AND_ENGINE)
   # Disable the following for UNIX altjit on Windows
   add_definitions(-DFEATURE_MERGE_JIT_AND_ENGINE)
 endif(FEATURE_MERGE_JIT_AND_ENGINE)
 add_definitions(-DFEATURE_MULTICOREJIT)
-add_definitions(-DFEATURE_NORM_IDNA_ONLY)
 if(CLR_CMAKE_PLATFORM_UNIX)
   add_definitions(-DFEATURE_PAL)
   add_definitions(-DFEATURE_PAL_SXS)
@@ -180,8 +173,6 @@ if (CLR_CMAKE_PLATFORM_UNIX OR CLR_CMAKE_TARGET_ARCH_ARM64)
 endif ()
 add_definitions(-DFEATURE_SVR_GC)
 add_definitions(-DFEATURE_SYMDIFF)
-add_definitions(-DFEATURE_SYNCHRONIZATIONCONTEXT_WAIT)
-add_definitions(-DFEATURE_SYNTHETIC_CULTURES)
 if(CLR_CMAKE_PLATFORM_UNIX_AMD64)
   add_definitions(-DFEATURE_MULTIREG_RETURN)
   add_definitions(-DFEATURE_UNIX_AMD64_STRUCT_PASSING)
@@ -191,7 +182,6 @@ add_definitions(-DFEATURE_USE_ASM_GC_WRITE_BARRIERS)
 if(CLR_CMAKE_PLATFORM_ARCH_AMD64 AND NOT WIN32)
   add_definitions(-DFEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP)
 endif(CLR_CMAKE_PLATFORM_ARCH_AMD64 AND NOT WIN32)
-add_definitions(-DFEATURE_VERSIONING)
 if(WIN32)
     add_definitions(-DFEATURE_VERSIONING_LOG)
 endif(WIN32)
@@ -204,5 +194,3 @@ add_definitions(-DFEATURE_WINMD_RESILIENT)
 add_definitions(-D_SECURE_SCL=0)
 add_definitions(-DUNICODE)
 add_definitions(-D_UNICODE)
-
-add_definitions(-DFEATURE_SPAN_OF_T)
diff --git a/config.json b/config.json
index 1849272be1..be0b4bd121 100644
--- a/config.json
+++ b/config.json
@@ -294,6 +294,12 @@
       "values": [ true, false ],
       "defaultValue": true
     },
+    "BuildWrappers": {
+      "description": "Builds test Xunit wrappers",
+      "valueType": "property",
+      "values": [ true, false ],
+      "defaultValue": true
+    },
     "RuntimeId": {
       "description": "Specifies the OS to build Core_Root for",
       "valueType": "property",
@@ -435,6 +441,13 @@
             "Project": "./src/syncAzure.proj"
           }
         },
+        "n": {
+          "description": "Downloads test native binaries. The values for '-AzureAccount', '-AzureToken', and '-Container' are required",
+          "settings": {
+            "Project": "./src/syncAzure.proj",
+            "PublishTestNativeBins": "true"
+          }
+        },
         "azureToken": {
           "description": "Account token to connect to Azure Blob storage.",
           "settings": {
@@ -453,6 +466,12 @@
             "__Container": "default"
           }
         },
+        "runtimeId": {
+          "description": "Runtime ID of the binaries in the specified container.",
+          "settings": {
+            "RuntimeId": "default"
+          }
+        },
         "verbose": {
           "description": "Passes /flp:v=diag to the msbuild command or the value passed by the user.",
           "settings": {
@@ -470,12 +489,6 @@
           "settings": {
             "BuildNumberMinor": "default"
           }
-        },
-        "PublishTestNativeBins": {
-          "description": "Downloads Published test native binaries.",
-          "settings": {
-            "PublishTestNativeBins": "default"
-          }
         }
       },
       "defaultValues": {
@@ -602,4 +615,4 @@
       "valueTypes": {}
     }
   }
-}
+}
\ No newline at end of file
diff --git a/cross/build-android-rootfs.sh b/cross/build-android-rootfs.sh
new file mode 100755
index 0000000000..7627294a26
--- /dev/null
+++ b/cross/build-android-rootfs.sh
@@ -0,0 +1,145 @@
+#!/usr/bin/env bash
+
+usage()
+{
+    echo "Creates a toolchain and sysroot used for cross-compiling for Android."
+    echo.
+    echo "Usage: $0 [BuildArch] [ApiLevel]"
+    echo.
+    echo "BuildArch is the target architecture of Android. Currently only arm64 is supported."
+    echo "ApiLevel is the target Android API level. API levels usually match to Android releases. See https://source.android.com/source/build-numbers.html"
+    echo.
+    echo "By default, the toolchain and sysroot will be generated in cross/android-rootfs/toolchain/[BuildArch]. You can change this behavior"
+    echo "by setting the TOOLCHAIN_DIR environment variable"
+    echo.
+    echo "By default, the NDK will be downloaded into the cross/android-rootfs/android-ndk-r13b directory. If you already have an NDK installation,"
+    echo "you can set the NDK_DIR environment variable to have this script use that installation of the NDK."
+    exit 1
+}
+
+__ApiLevel=21 # The minimum platform for arm64 is API level 21
+__BuildArch=arm64
+__AndroidArch=aarch64
+
+for i in "$@"
+    do
+        lowerI="$(echo $i | awk '{print tolower($0)}')"
+        case $lowerI in
+        -?|-h|--help)
+            usage
+            exit 1
+            ;;
+        arm64)
+            __BuildArch=arm64
+            __AndroidArch=aarch64
+            ;;
+        *[0-9])
+            __ApiLevel=$i
+            ;;
+        *)
+            __UnprocessedBuildArgs="$__UnprocessedBuildArgs $i"
+            ;;
+    esac
+done
+
+# Obtain the location of the bash script to figure out where the root of the repo is.
+__CrossDir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+__Android_Cross_Dir="$__CrossDir/android-rootfs"
+__NDK_Dir="$__Android_Cross_Dir/android-ndk-r13b"
+__libunwind_Dir="$__Android_Cross_Dir/libunwind"
+__lldb_Dir="$__Android_Cross_Dir/lldb"
+__ToolchainDir="$__Android_Cross_Dir/toolchain/$__BuildArch"
+
+if [[ -n "$TOOLCHAIN_DIR" ]]; then
+    __ToolchainDir=$TOOLCHAIN_DIR
+fi
+
+if [[ -n "$NDK_DIR" ]]; then
+    __NDK_Dir=$NDK_DIR
+fi
+
+echo "Target API level: $__ApiLevel"
+echo "Target architecture: $__BuildArch"
+echo "NDK location: $__NDK_Dir"
+echo "Target Toolchain location: $__ToolchainDir"
+
+# Download the NDK if required
+if [ ! -d $__NDK_Dir ]; then
+    echo Downloading the NDK into $__NDK_Dir
+    mkdir -p $__NDK_Dir
+    wget -nv -nc --show-progress https://dl.google.com/android/repository/android-ndk-r13b-linux-x86_64.zip -O $__Android_Cross_Dir/android-ndk-r13b-linux-x86_64.zip
+    unzip -q $__Android_Cross_Dir/android-ndk-r13b-linux-x86_64.zip -d $__Android_Cross_Dir
+fi
+
+if [ ! -d $__lldb_Dir ]; then
+    mkdir -p $__lldb_Dir
+    echo Downloading LLDB into $__lldb_Dir
+    wget -nv -nc --show-progress https://dl.google.com/android/repository/lldb-2.3.3614996-linux-x86_64.zip -O $__Android_Cross_Dir/lldb-2.3.3614996-linux-x86_64.zip
+    unzip -q $__Android_Cross_Dir/lldb-2.3.3614996-linux-x86_64.zip -d $__lldb_Dir
+fi
+
+# Create the RootFS for both arm64 as well as aarch
+rm -rf $__Android_Cross_Dir/toolchain
+
+echo Generating the $__BuildArch toolchain
+$__NDK_Dir/build/tools/make_standalone_toolchain.py --arch $__BuildArch --api $__ApiLevel --install-dir $__ToolchainDir
+
+# Install the required packages into the toolchain
+rm -rf $__Android_Cross_Dir/deb/
+rm -rf $__Android_Cross_Dir/tmp
+
+mkdir -p $__Android_Cross_Dir/deb/
+mkdir -p $__Android_Cross_Dir/tmp/$arch/
+wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/libicu_58.2_$__AndroidArch.deb -O $__Android_Cross_Dir/deb/libicu_58.2_$__AndroidArch.deb
+wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/libicu-dev_58.2_$__AndroidArch.deb -O $__Android_Cross_Dir/deb/libicu-dev_58.2_$__AndroidArch.deb
+wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/libuuid-dev_1.0.3_$__AndroidArch.deb -O $__Android_Cross_Dir/deb/libuuid-dev_1.0.3_$__AndroidArch.deb
+wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/libuuid_1.0.3_$__AndroidArch.deb -O $__Android_Cross_Dir/deb/libuuid_1.0.3_$__AndroidArch.deb
+wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/libandroid-glob-dev_0.3_$__AndroidArch.deb -O $__Android_Cross_Dir/deb/libandroid-glob-dev_0.3_$__AndroidArch.deb
+wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/libandroid-glob_0.3_$__AndroidArch.deb -O $__Android_Cross_Dir/deb/libandroid-glob_0.3_$__AndroidArch.deb
+wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/libandroid-support-dev_13.10_$__AndroidArch.deb -O $__Android_Cross_Dir/deb/libandroid-support-dev_13.10_$__AndroidArch.deb
+wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/libandroid-support_13.10_$__AndroidArch.deb -O $__Android_Cross_Dir/deb/libandroid-support_13.10_$__AndroidArch.deb
+wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/liblzma-dev_5.2.3_$__AndroidArch.deb  -O $__Android_Cross_Dir/deb/liblzma-dev_5.2.3_$__AndroidArch.deb
+wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/liblzma_5.2.3_$__AndroidArch.deb -O $__Android_Cross_Dir/deb/liblzma_5.2.3_$__AndroidArch.deb
+wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/libcurl-dev_7.52.1_$__AndroidArch.deb -O $__Android_Cross_Dir/deb/libcurl-dev_7.52.1_$__AndroidArch.deb
+wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/libcurl_7.52.1_$__AndroidArch.deb -O $__Android_Cross_Dir/deb/libcurl_7.52.1_$__AndroidArch.deb
+
+echo Unpacking Termux packages
+dpkg -x $__Android_Cross_Dir/deb/libicu_58.2_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/
+dpkg -x $__Android_Cross_Dir/deb/libicu-dev_58.2_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/
+dpkg -x $__Android_Cross_Dir/deb/libuuid-dev_1.0.3_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/
+dpkg -x $__Android_Cross_Dir/deb/libuuid_1.0.3_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/
+dpkg -x $__Android_Cross_Dir/deb/libandroid-glob-dev_0.3_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/
+dpkg -x $__Android_Cross_Dir/deb/libandroid-glob_0.3_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/
+dpkg -x $__Android_Cross_Dir/deb/libandroid-support-dev_13.10_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/
+dpkg -x $__Android_Cross_Dir/deb/libandroid-support_13.10_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/
+dpkg -x $__Android_Cross_Dir/deb/liblzma-dev_5.2.3_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/
+dpkg -x $__Android_Cross_Dir/deb/liblzma_5.2.3_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/
+dpkg -x $__Android_Cross_Dir/deb/libcurl-dev_7.52.1_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/
+dpkg -x $__Android_Cross_Dir/deb/libcurl_7.52.1_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/
+
+cp -R $__Android_Cross_Dir/tmp/$__AndroidArch/data/data/com.termux/files/usr/* $__ToolchainDir/sysroot/usr/
+
+# Prepare libunwind
+if [ ! -d $__libunwind_Dir ]; then
+    git clone https://android.googlesource.com/platform/external/libunwind/ $__libunwind_Dir
+fi
+
+cd $__libunwind_Dir
+git checkout android-6.0.0_r26
+git checkout -- .
+git clean -xfd
+
+# libunwind is available on Android, but not included in the NDK.
+echo Building libunwind
+autoreconf --force -v --install 2> /dev/null
+./configure CC=$__ToolchainDir/bin/$__AndroidArch-linux-android-clang --with-sysroot=$__ToolchainDir/sysroot --host=x86_64 --target=$__AndroidArch-eabi --disable-coredump --prefix=$__ToolchainDir/sysroot/usr 2> /dev/null
+make > /dev/null
+make install > /dev/null
+
+# This header file is missing
+cp include/libunwind.h $__ToolchainDir/sysroot/usr/include/
+
+echo Now run:
+echo CONFIG_DIR=\`realpath cross/android/arm64\` ROOTFS_DIR=\`realpath $__ToolchainDir/sysroot\` ./build.sh cross arm64 skipgenerateversion skipmscorlib cmakeargs -DENABLE_LLDBPLUGIN=0
+
diff --git a/dependencies.props b/dependencies.props
index eb246acbac..36e16b012b 100644
--- a/dependencies.props
+++ b/dependencies.props
@@ -1,18 +1,18 @@
 <Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <!-- Source of truth for dependency tooling: the commit hash of the dotnet/versions master branch as of the last auto-upgrade. -->
   <PropertyGroup>
-    <CoreFxCurrentRef>e4023aa1941968c816d1ba2c46c6761074b873aa</CoreFxCurrentRef>
-    <CoreClrCurrentRef>e4023aa1941968c816d1ba2c46c6761074b873aa</CoreClrCurrentRef>
+    <CoreFxCurrentRef>9bdceed2f3a12a62e66c5202a13f3220ccc10f89</CoreFxCurrentRef>
+    <CoreClrCurrentRef>9bdceed2f3a12a62e66c5202a13f3220ccc10f89</CoreClrCurrentRef>
   </PropertyGroup>
 
   <!-- Auto-upgraded properties for each build info dependency. -->
   <PropertyGroup>
-    <CoreFxExpectedPrerelease>beta-24924-02</CoreFxExpectedPrerelease>
+    <CoreFxExpectedPrerelease>beta-25007-01</CoreFxExpectedPrerelease>
   </PropertyGroup>
 
   <!-- Full package version strings that are used in other parts of the build. -->
   <PropertyGroup>
-    <CoreClrPackageVersion>1.2.0-beta-24924-01</CoreClrPackageVersion>
+    <CoreClrPackageVersion>2.0.0-beta-25007-01</CoreClrPackageVersion>
     <XunitPackageVersion>2.2.0-beta2-build3300</XunitPackageVersion>
   </PropertyGroup>
 
diff --git a/dir.props b/dir.props
index ec09b00597..291de517d0 100644
--- a/dir.props
+++ b/dir.props
@@ -83,9 +83,8 @@
   <!-- Output paths -->
   <PropertyGroup>
     <BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)' == ''">$(RootBinDir)obj\</BaseIntermediateOutputPath>
-    <IntermediateOutputPath Condition="'$(IntermediateOutputPath)' == ''">$(BaseIntermediateOutputPath)\$(BuildOS).$(BuildArch).$(BuildType)</IntermediateOutputPath>
-    <OutputPath Condition="'$(OutputPath)' == ''">$(BaseIntermediateOutputPath)\$(BuildOS).$(BuildArch).$(BuildType)</OutputPath>
-    <FinalOutputPath Condition="'$(FinalOutputPath)' == ''">$(BinDir)</FinalOutputPath>
+    <IntermediateOutputPath Condition="'$(IntermediateOutputPath)' == ''">$(BaseIntermediateOutputPath)$(BuildOS).$(BuildArch).$(BuildType)\$(MSBuildProjectName)</IntermediateOutputPath>
+    <OutputPath Condition="'$(OutputPath)' == ''">$(BinDir)</OutputPath>
   </PropertyGroup>
 
   <Import Condition="Exists('$(ToolsDir)BuildVersion.targets')" Project="$(ToolsDir)BuildVersion.targets" />
@@ -153,7 +152,7 @@
     <ProjectUrl>https://dot.net</ProjectUrl>
 
     <!-- Central place to set the versions of all nuget packages produced in the repo -->
-    <PackageVersion Condition="'$(PackageVersion)' == ''">1.2.0</PackageVersion>
+    <PackageVersion Condition="'$(PackageVersion)' == ''">2.0.0</PackageVersion>
     
     <!-- Set the boolean below to true to generate packages with stabilized versions -->
     <StabilizePackageVersion Condition="'$(StabilizePackageVersion)' == ''">false</StabilizePackageVersion>
diff --git a/functions.cmake b/functions.cmake
index f2c52daf5e..7d69dcb707 100644
--- a/functions.cmake
+++ b/functions.cmake
@@ -222,7 +222,7 @@ endfunction()
 function(verify_dependencies targetName errorMessage)
     # We don't need to verify dependencies on OSX, since missing dependencies
     # result in link error over there.
-    if (NOT CLR_CMAKE_PLATFORM_DARWIN)
+    if (NOT CLR_CMAKE_PLATFORM_DARWIN AND NOT CLR_CMAKE_PLATFORM_ANDROID)
         add_custom_command(
             TARGET ${targetName}
             POST_BUILD
diff --git a/netci.groovy b/netci.groovy
index 6203a03888..56c548272d 100755
--- a/netci.groovy
+++ b/netci.groovy
@@ -22,7 +22,6 @@ def static getOSGroup(def os) {
         'Windows_NT':'Windows_NT',
         'FreeBSD':'FreeBSD',
         'CentOS7.1': 'Linux',
-        'OpenSUSE13.2': 'Linux',
         'OpenSUSE42.1': 'Linux',
         'LinuxARMEmulator': 'Linux']
     def osGroup = osGroupMap.get(os, null) 
@@ -45,7 +44,6 @@ class Constants {
                'Windows_NT_BuildOnly',
                'FreeBSD',
                'CentOS7.1',
-               'OpenSUSE13.2',
                'OpenSUSE42.1',
                'RHEL7.2',
                'LinuxARMEmulator',
@@ -53,7 +51,7 @@ class Constants {
                'Ubuntu16.10',
                'Fedora23']
 
-    def static crossList = ['Ubuntu', 'OSX', 'CentOS7.1', 'RHEL7.2', 'Debian8.4', 'OpenSUSE13.2']
+    def static crossList = ['Ubuntu', 'OSX', 'CentOS7.1', 'RHEL7.2', 'Debian8.4']
 
     // This is a set of JIT stress modes combined with the set of variables that
     // need to be set to actually enable that stress mode.  The key of the map is the stress mode and
@@ -590,7 +588,7 @@ def static addTriggers(def job, def branch, def isPR, def architecture, def os,
         return
     }
     
-    def bidailyCrossList = ['RHEL7.2', 'Debian8.4', 'OpenSUSE13.2']
+    def bidailyCrossList = ['RHEL7.2', 'Debian8.4']
     // Non pull request builds.
     if (!isPR) {
         addNonPRTriggers(job, branch, isPR, architecture, os, configuration, scenario, isFlowJob, isWindowsBuildOnlyJob, isLinuxEmulatorBuild, bidailyCrossList)
@@ -619,7 +617,6 @@ def static addTriggers(def job, def branch, def isPR, def architecture, def os,
 
             switch (os) {
                 // OpenSUSE, Debian & RedHat get trigger phrases for pri 0 build, and pri 1 build & test
-                case 'OpenSUSE13.2':
                 case 'Debian8.4':
                 case 'RHEL7.2':
                     if (scenario == 'default') {
@@ -1186,13 +1183,46 @@ def static addTriggers(def job, def branch, def isPR, def architecture, def os,
                contextString += " and Test"
             }
 
-            def arm64Users = ['erozenfeld', 'kyulee1', 'pgavlin', 'russellhadley', 'swaroop-sridhar', 'JosephTremoulet', 'jashook', 'RussKeldorph', 'gkhanna79', 'briansull', 'cmckinsey', 'jkotas', 'ramarag', 'markwilkie', 'rahku', 'tzwlai', 'weshaggard']
+            def arm64Users = [
+                'adiaaida',
+                'AndyAyersMS',
+                'briansull',
+                'BruceForstall',
+                'CarolEidt',
+                'cmckinsey',
+                'erozenfeld',
+                'jashook',
+                'JosephTremoulet',
+                'pgavlin',
+                'pkukol',
+                'russellhadley',
+                'RussKeldorph',
+                'sandreenko',
+                'sivarv',
+                'swaroop-sridhar',
+                'gkhanna79',
+                'jkotas',
+                'markwilkie',
+                'rahku',
+                'ramarag',
+                'tzwlai',
+                'weshaggard'
+            ]
+
             switch (os) {
                 case 'Windows_NT':
                     switch (scenario) {
                         case 'default':
-                            Utilities.addPrivateGithubPRTriggerForBranch(job, branch, contextString,
-                            "(?i).*test\\W+${os}\\W+${architecture}\\W+${configuration}.*", null, arm64Users)
+                            // For now only run Debug jobs on PR Trigger.
+                            if (configuration != 'Debug') {
+                                Utilities.addPrivateGithubPRTriggerForBranch(job, branch, contextString,
+                                "(?i).*test\\W+${os}\\W+${architecture}\\W+${configuration}.*", null, arm64Users)
+                            }
+                            else {
+                                // Add "Checked Build And Test" and "Debug Build" to the above users' PRs since many of them
+                                // are at higher risk of ARM64-breaking changes.
+                                Utilities.addDefaultPrivateGithubPRTriggerForBranch(job, branch, contextString, null, arm64Users)
+                            }
                             break
                         case 'pri1r2r':
                         case 'gcstress0x3':
@@ -1783,13 +1813,15 @@ def static calculateBuildCommands(def newJob, def scenario, def branch, def isPR
                 case 'x86lb':
                     def arch = architecture
                     def buildOpts = ''
+                    
+                    // We need to explicitly run build-test.cmd with Exclude for x86compatjit and x86lb, so skip tests.
                     if (architecture == 'x86compatjit') {
                         arch = 'x86'
-                        buildOpts = 'compatjitcrossgen'
+                        buildOpts = 'compatjitcrossgen skiptests'
                     }
                     else if (architecture == 'x86lb') {
                         arch = 'x86'
-                        buildOpts = 'legacyjitcrossgen'
+                        buildOpts = 'legacyjitcrossgen skiptests'
                     }
                     
                     if (Constants.jitStressModeScenarios.containsKey(scenario) ||
@@ -1918,8 +1950,8 @@ def static calculateBuildCommands(def newJob, def scenario, def branch, def isPR
                                 setTestJobTimeOut(newJob, scenario)
 
                                 // Archive and process (only) the test results
-                                Utilities.addArchival(newJob, "${workspaceRelativeFxRoot}/bin/tests/**/testResults.xml")
-                                Utilities.addXUnitDotNETResults(newJob, "${workspaceRelativeFxRoot}/bin/tests/**/testResults.xml")
+                                Utilities.addArchival(newJob, "${workspaceRelativeFxRoot}/bin/**/testResults.xml")
+                                Utilities.addXUnitDotNETResults(newJob, "${workspaceRelativeFxRoot}/bin/**/testResults.xml")
                             }
                             else {
                                 buildCommands += "%WORKSPACE%\\tests\\runtest.cmd ${runtestArguments} TestEnv ${stepScriptLocation}"
@@ -1930,11 +1962,15 @@ def static calculateBuildCommands(def newJob, def scenario, def branch, def isPR
                         }                                        
                         else if (architecture == 'x86compatjit') {
                             def testEnvLocation = "%WORKSPACE%\\tests\\x86\\compatjit_x86_testenv.cmd"
-                            buildCommands += "tests\\runtest.cmd ${runtestArguments} Exclude0 x86_legacy_backend_issues.targets TestEnv ${testEnvLocation}"
+                            def excludeLocation = "%WORKSPACE%\\tests\\x86_legacy_backend_issues.targets"
+                            buildCommands += "build-test.cmd ${runtestArguments} Exclude ${excludeLocation}"
+                            buildCommands += "tests\\runtest.cmd ${runtestArguments} TestEnv ${testEnvLocation}"
                         }
                         else if (architecture == 'x86lb') {
                             def testEnvLocation = "%WORKSPACE%\\tests\\x86\\legacyjit_x86_testenv.cmd"
-                            buildCommands += "tests\\runtest.cmd ${runtestArguments} Exclude0 x86_legacy_backend_issues.targets TestEnv ${testEnvLocation}"
+                            def excludeLocation = "%WORKSPACE%\\tests\\x86_legacy_backend_issues.targets"
+                            buildCommands += "build-test.cmd ${runtestArguments} Exclude ${excludeLocation}"
+                            buildCommands += "tests\\runtest.cmd ${runtestArguments} TestEnv ${testEnvLocation}"
                         }
                     }
 
@@ -1997,6 +2033,9 @@ def static calculateBuildCommands(def newJob, def scenario, def branch, def isPR
                        buildCommands += "set __TestIntermediateDir=int&&build.cmd ${lowerConfiguration} ${architecture} toolset_dir C:\\ats2"
                     }
                     else {
+                       // Up the timeout for arm64 testing.
+                       Utilities.setJobTimeout(newJob, 240)
+
                        buildCommands += "set __TestIntermediateDir=int&&build.cmd skiptests ${lowerConfiguration} ${architecture} toolset_dir C:\\ats2"
                        // Test build and run are launched together.
                        buildCommands += "python tests\\scripts\\arm64_post_build.py -repo_root %WORKSPACE% -arch ${architecture} -build_type ${lowerConfiguration} -scenario ${scenario} -key_location C:\\tools\\key.txt"
@@ -2021,7 +2060,6 @@ def static calculateBuildCommands(def newJob, def scenario, def branch, def isPR
         case 'FreeBSD':
         case 'CentOS7.1':
         case 'RHEL7.2':
-        case 'OpenSUSE13.2':
         case 'OpenSUSE42.1':
         case 'Fedora23': // editor brace matching: {
             switch (architecture) {
@@ -2048,7 +2086,7 @@ def static calculateBuildCommands(def newJob, def scenario, def branch, def isPR
                     if (!enableCorefxTesting) {
                         // We run pal tests on all OS but generate mscorlib (and thus, nuget packages)
                         // only on supported OS platforms.
-                        if ((os == 'FreeBSD') || (os == 'OpenSUSE13.2'))
+                        if (os == 'FreeBSD')
                         {
                             buildCommands += "./build.sh skipmscorlib verbose ${lowerConfiguration} ${arch} ${standaloneGc}"
                         }
@@ -2089,8 +2127,8 @@ def static calculateBuildCommands(def newJob, def scenario, def branch, def isPR
                         setTestJobTimeOut(newJob, scenario)
 
                         // Archive and process (only) the test results
-                        Utilities.addArchival(newJob, "${workspaceRelativeFxRoot}/bin/tests/**/testResults.xml")
-                        Utilities.addXUnitDotNETResults(newJob, "${workspaceRelativeFxRoot}/bin/tests/**/testResults.xml")
+                        Utilities.addArchival(newJob, "${workspaceRelativeFxRoot}/bin/**/testResults.xml")
+                        Utilities.addXUnitDotNETResults(newJob, "${workspaceRelativeFxRoot}/bin/**/testResults.xml")
                     }
                     break
                 case 'arm64':
@@ -2467,7 +2505,7 @@ combinedScenarios.each { scenario ->
                                     copyArtifacts("${corefxFolder}/linuxarmemulator_softfp_cross_${lowerConfiguration}") {
                                         includePatterns('bin/build.tar.gz')
                                         buildSelector {
-                                            latestSaved()
+                                            latestSuccessful(true)
                                         }
                                     }
                                 }
@@ -2503,7 +2541,7 @@ combinedScenarios.each { scenario ->
                             return
                         }
                         //Skip stress modes for these scenarios
-                        if (os == 'RHEL7.2' || os == 'Debian8.4' || os == 'OpenSUSE13.2') {
+                        if (os == 'RHEL7.2' || os == 'Debian8.4') {
                             return
                         }
                     }
@@ -2525,8 +2563,8 @@ combinedScenarios.each { scenario ->
                             return
                         }
                     }
-                    // For RedHat, Debian, and OpenSUSE, we only do Release pri1 builds.
-                    else if (os == 'RHEL7.2' || os == 'Debian8.4' || os == 'OpenSUSE13.2') {
+                    // For RedHat and Debian, we only do Release pri1 builds.
+                    else if (os == 'RHEL7.2' || os == 'Debian8.4') {
                         if (scenario != 'pri1') {
                             return
                         }
@@ -2787,9 +2825,6 @@ combinedScenarios.each { scenario ->
                                 // Get corefx
                                 shell("git clone https://github.com/dotnet/corefx fx")
 
-                                // CoreFX is changing their output format and scripts, pick a stable version until all that work has landed.
-                                shell("git -C ./fx checkout 551fe49174378adcbf785c0ab12fc69355cef6e8")
-
                                 // Build Linux corefx
                                 shell("./fx/build-native.sh -release -buildArch=x64 -os=Linux")
                                 shell("./fx/build-managed.sh -release -buildArch=x64 -osgroup=Linux -skiptests")
@@ -2815,8 +2850,7 @@ combinedScenarios.each { scenario ->
                 --testNativeBinDir=\"\$(pwd)/clr/bin/obj/${osGroup}.${architecture}.${configuration}/tests\" \\
                 --coreClrBinDir=\"\$(pwd)/clr/bin/Product/${osGroup}.${architecture}.${configuration}\" \\
                 --mscorlibDir=\"\$(pwd)/clr/bin/Product/${osGroup}.${architecture}.${configuration}\" \\
-                --coreFxBinDir=\"\$(pwd)/fx/bin/${osGroup}.AnyCPU.Release;\$(pwd)/fx/bin/Unix.AnyCPU.Release;\$(pwd)/fx/bin/AnyOS.AnyCPU.Release\" \\
-                --coreFxNativeBinDir=\"\$(pwd)/fx/bin/${osGroup}.${architecture}.Release\" \\
+                --coreFxBinDir=\"\$(pwd)/fx/bin/runtime/netcoreapp-${osGroup}-Release-${architecture}\" \\
                 --crossgen --runcrossgentests""")
 
                                 // Run coreclr tests w/ server GC & HeapVerify enabled
@@ -2855,12 +2889,13 @@ combinedScenarios.each { scenario ->
                                 copyArtifacts("${corefxFolder}/${osJobName}_release") {
                                     includePatterns('bin/build.tar.gz')
                                     buildSelector {
-                                        latestSaved()
+                                        latestSuccessful(true)
                                     }
                                 }
                         
+                                shell ("mkdir ./bin/CoreFxBinDir")
                                 // Unpack the corefx binaries
-                                shell("tar -xf ./bin/build.tar.gz")
+                                shell("tar -xf ./bin/build.tar.gz -C ./bin/CoreFxBinDir")
 
                                 // Unzip the tests first.  Exit with 0
                                 shell("unzip -q -o ./bin/tests/tests.zip -d ./bin/tests/Windows_NT.${architecture}.${configuration} || exit 0")
@@ -2884,8 +2919,7 @@ combinedScenarios.each { scenario ->
                 --testNativeBinDir=\"\${WORKSPACE}/bin/obj/${osGroup}.${architecture}.${configuration}/tests\" \\
                 --coreClrBinDir=\"\${WORKSPACE}/bin/Product/${osGroup}.${architecture}.${configuration}\" \\
                 --mscorlibDir=\"\${WORKSPACE}/bin/Product/${osGroup}.${architecture}.${configuration}\" \\
-                --coreFxBinDir=\"\${WORKSPACE}/bin/${osGroup}.AnyCPU.Release;\${WORKSPACE}/bin/Unix.AnyCPU.Release;\${WORKSPACE}/bin/AnyOS.AnyCPU.Release\" \\
-                --coreFxNativeBinDir=\"\${WORKSPACE}/bin/${osGroup}.${architecture}.Release\" \\
+                --coreFxBinDir=\"\${WORKSPACE}/bin/CoreFxBinDir\" \\
                 --limitedDumpGeneration \\
                 ${testEnvOpt} ${serverGCString} ${gcstressStr} ${crossgenStr} ${runcrossgentestsStr} ${runjitstressStr} ${runjitstressregsStr} ${runjitmioptsStr} ${runjitforcerelocsStr} ${runjitdisasmStr} ${sequentialString} ${playlistString}""")
                             }
diff --git a/perf.groovy b/perf.groovy
index b2dfedd20f..1eb9f19525 100644
--- a/perf.groovy
+++ b/perf.groovy
@@ -27,8 +27,8 @@ def static getOSGroup(def os) {
 // Setup perflab tests runs
 [true, false].each { isPR ->
     ['Windows_NT'].each { os ->
-		['x64'].each { architecture ->
-			def newJob = job(Utilities.getFullJobName(project, "perf_perflab_${os}", isPR)) {
+		['x64', 'x86'].each { architecture ->
+			def newJob = job(Utilities.getFullJobName(project, "perf_perflab_${os}_${architecture}", isPR)) {
 				// Set the label.
 				label('windows_clr_perf')
 				wrappers {
@@ -76,9 +76,9 @@ def static getOSGroup(def os) {
 
 			if (isPR) {
 				TriggerBuilder builder = TriggerBuilder.triggerOnPullRequest()
-				builder.setGithubContext("${os} CoreCLR Perf Tests")
+				builder.setGithubContext("${os} ${architecture} CoreCLR Perf Tests")
 				builder.triggerOnlyOnComment()
-				builder.setCustomTriggerPhrase("(?i).*test\\W+${os}\\W+perf.*")
+				builder.setCustomTriggerPhrase("(?i).*test\\W+${os}_${architecture}\\W+perf.*")
 				builder.triggerForBranch(branch)
 				builder.emitTrigger(newJob)
 			}
@@ -128,8 +128,7 @@ def static getOSGroup(def os) {
                 --testNativeBinDir=\"\${WORKSPACE}/bin/obj/${osGroup}.${architecture}.${configuration}/tests\" \\
                 --coreClrBinDir=\"\${WORKSPACE}/bin/Product/${osGroup}.${architecture}.${configuration}\" \\
                 --mscorlibDir=\"\${WORKSPACE}/bin/Product/${osGroup}.${architecture}.${configuration}\" \\
-                --coreFxBinDir=\"\${WORKSPACE}/corefx/bin/${osGroup}.AnyCPU.${configuration};\${WORKSPACE}/corefx/bin/Unix.AnyCPU.${configuration};\${WORKSPACE}/corefx/bin/AnyOS.AnyCPU.${configuration}\" \\
-                --coreFxNativeBinDir=\"\${WORKSPACE}/corefx/bin/${osGroup}.${architecture}.${configuration}\" \\
+                --coreFxBinDir=\"\${WORKSPACE}/corefx\" \\
 				--runType=\"${runType}\" \\
 				--benchViewOS=\"${os}\" \\
 				--uploadToBenchview""")
diff --git a/src/.nuget/Microsoft.NETCore.ILAsm/Microsoft.NETCore.ILAsm.pkgproj b/src/.nuget/Microsoft.NETCore.ILAsm/Microsoft.NETCore.ILAsm.pkgproj
index bfa4bd833d..cf5d9094b3 100644
--- a/src/.nuget/Microsoft.NETCore.ILAsm/Microsoft.NETCore.ILAsm.pkgproj
+++ b/src/.nuget/Microsoft.NETCore.ILAsm/Microsoft.NETCore.ILAsm.pkgproj
@@ -3,7 +3,7 @@
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" />
 
   <PropertyGroup Condition="'$(PackageTargetRuntime)' == ''">
-    <PackagePlatforms>x64;x86;arm64;arm;</PackagePlatforms>  
+    <PackagePlatforms>x64;x86;arm64;arm;armel;</PackagePlatforms>  
     <IsLineupPackage Condition="'$(IsLineupPackage)' == ''">true</IsLineupPackage>
   </PropertyGroup>
 
diff --git a/src/.nuget/Microsoft.NETCore.ILDAsm/Microsoft.NETCore.ILDAsm.pkgproj b/src/.nuget/Microsoft.NETCore.ILDAsm/Microsoft.NETCore.ILDAsm.pkgproj
index 4236e316ec..73c27ae8c2 100644
--- a/src/.nuget/Microsoft.NETCore.ILDAsm/Microsoft.NETCore.ILDAsm.pkgproj
+++ b/src/.nuget/Microsoft.NETCore.ILDAsm/Microsoft.NETCore.ILDAsm.pkgproj
@@ -3,7 +3,7 @@
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" />
 
   <PropertyGroup Condition="'$(PackageTargetRuntime)' == ''">
-    <PackagePlatforms>x64;x86;arm64;arm;</PackagePlatforms>  
+    <PackagePlatforms>x64;x86;arm64;arm;armel;</PackagePlatforms>  
     <IsLineupPackage Condition="'$(IsLineupPackage)' == ''">true</IsLineupPackage>
   </PropertyGroup>
 
diff --git a/src/.nuget/Microsoft.NETCore.Jit/Microsoft.NETCore.Jit.pkgproj b/src/.nuget/Microsoft.NETCore.Jit/Microsoft.NETCore.Jit.pkgproj
index 5ed709e2b3..a0ef5c99ac 100644
--- a/src/.nuget/Microsoft.NETCore.Jit/Microsoft.NETCore.Jit.pkgproj
+++ b/src/.nuget/Microsoft.NETCore.Jit/Microsoft.NETCore.Jit.pkgproj
@@ -3,7 +3,7 @@
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" />
 
   <PropertyGroup Condition="'$(PackageTargetRuntime)' == ''">
-    <PackagePlatforms>x64;x86;arm64;arm;</PackagePlatforms>  
+    <PackagePlatforms>x64;x86;arm64;arm;armel;</PackagePlatforms>  
     <IsLineupPackage Condition="'$(IsLineupPackage)' == ''">true</IsLineupPackage>
   </PropertyGroup>
 
diff --git a/src/.nuget/Microsoft.NETCore.Runtime.CoreCLR/Microsoft.NETCore.Runtime.CoreCLR.pkgproj b/src/.nuget/Microsoft.NETCore.Runtime.CoreCLR/Microsoft.NETCore.Runtime.CoreCLR.pkgproj
index bf3177bef6..5c933c167c 100644
--- a/src/.nuget/Microsoft.NETCore.Runtime.CoreCLR/Microsoft.NETCore.Runtime.CoreCLR.pkgproj
+++ b/src/.nuget/Microsoft.NETCore.Runtime.CoreCLR/Microsoft.NETCore.Runtime.CoreCLR.pkgproj
@@ -3,7 +3,7 @@
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" />
 
   <PropertyGroup Condition="'$(PackageTargetRuntime)' == ''">
-    <PackagePlatforms>x64;x86;arm64;arm;</PackagePlatforms>  
+    <PackagePlatforms>x64;x86;arm64;arm;armel;</PackagePlatforms>  
     <IsLineupPackage Condition="'$(IsLineupPackage)' == ''">true</IsLineupPackage>
   </PropertyGroup>
   
diff --git a/src/.nuget/Microsoft.NETCore.TestHost/Microsoft.NETCore.TestHost.pkgproj b/src/.nuget/Microsoft.NETCore.TestHost/Microsoft.NETCore.TestHost.pkgproj
index 991d7621c2..d65f0ec714 100644
--- a/src/.nuget/Microsoft.NETCore.TestHost/Microsoft.NETCore.TestHost.pkgproj
+++ b/src/.nuget/Microsoft.NETCore.TestHost/Microsoft.NETCore.TestHost.pkgproj
@@ -3,7 +3,7 @@
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" />
 
   <PropertyGroup Condition="'$(PackageTargetRuntime)' == ''">
-    <PackagePlatforms>x64;x86;arm64;arm;</PackagePlatforms>  
+    <PackagePlatforms>x64;x86;arm64;arm;armel;</PackagePlatforms>  
     <IsLineupPackage Condition="'$(IsLineupPackage)' == ''">true</IsLineupPackage>
   </PropertyGroup>
 
diff --git a/src/.nuget/descriptions.json b/src/.nuget/descriptions.json
index ccb6af8bbd..a9038c0936 100644
--- a/src/.nuget/descriptions.json
+++ b/src/.nuget/descriptions.json
@@ -11,12 +11,12 @@
     },
     {
         "Name": "Microsoft.NETCore.Runtime.CoreCLR",
-        "Description": "The .NET Core runtime, called CoreCLR, and the base library, called mscorlib. It includes the garbage collector, JIT compiler, base .NET data types and many low-level classes.",
+        "Description": "The .NET Core runtime, called CoreCLR, and the base library, called System.Private.CoreLib. It includes the garbage collector, JIT compiler, base .NET data types and many low-level classes.",
         "CommonTypes": [ ]
     },
     {
         "Name": "Microsoft.TargetingPack.Private.CoreCLR",
-        "Description": "Contains a private targeting pack which contains only the CoreCLR mscorlib reference assembly. Used for producing platform specific libraries such as facades.",
+        "Description": "Contains a private targeting pack which contains only the CoreCLR System.Private.CoreLib reference assembly. Used for producing platform specific libraries such as facades.",
         "CommonTypes": [ ]
     },
     {
diff --git a/src/ToolBox/SOS/Strike/disasm.h b/src/ToolBox/SOS/Strike/disasm.h
index 59fc168a6e..2a2d9f7779 100644
--- a/src/ToolBox/SOS/Strike/disasm.h
+++ b/src/ToolBox/SOS/Strike/disasm.h
@@ -54,9 +54,6 @@ LPCWSTR EHTypedClauseTypeName(const DACEHInfo* pEHInfo);
 
 struct SOSEHInfo
 {
-#ifndef FEATURE_CORECLR
-    __field_ecount(EHCount)
-#endif
     DACEHInfo  *m_pInfos;
     UINT        EHCount;
     CLRDATA_ADDRESS methodStart;
diff --git a/src/ToolBox/SOS/Strike/exts.cpp b/src/ToolBox/SOS/Strike/exts.cpp
index 0b1f976cc2..566ba35f19 100644
--- a/src/ToolBox/SOS/Strike/exts.cpp
+++ b/src/ToolBox/SOS/Strike/exts.cpp
@@ -111,30 +111,29 @@ ArchQuery(void)
     {
         targetMachine = AMD64Machine::GetInstance();
     }
-#endif // SOS_TARGET_AMD64
-#ifdef SOS_TARGET_X86
+#elif defined(SOS_TARGET_X86)
     if (targetArchitecture == IMAGE_FILE_MACHINE_I386)
     {
         targetMachine = X86Machine::GetInstance();
     }
-#endif // SOS_TARGET_X86
-#ifdef SOS_TARGET_ARM
+#elif defined(SOS_TARGET_ARM)
     if (targetArchitecture == IMAGE_FILE_MACHINE_ARMNT)
     {
         targetMachine = ARMMachine::GetInstance();
     }
-#endif // SOS_TARGET_ARM
-#ifdef SOS_TARGET_ARM64
+#elif defined(SOS_TARGET_ARM64)
     if (targetArchitecture == IMAGE_FILE_MACHINE_ARM64)
     {
         targetMachine = ARM64Machine::GetInstance();
     }
-#endif // SOS_TARGET_ARM64
+#else
+#error "Undefined target architecture"
+#endif
 
     if (targetMachine == NULL)
     {
         g_targetMachine = NULL;
-        ExtErr("SOS does not support the current target architecture.\n");
+        ExtErr("SOS does not support the current target architecture 0x%llx.\n", targetArchitecture);
         return E_FAIL;
     }
 
diff --git a/src/ToolBox/SOS/Strike/gcroot.cpp b/src/ToolBox/SOS/Strike/gcroot.cpp
index f68b935e21..86080989ec 100644
--- a/src/ToolBox/SOS/Strike/gcroot.cpp
+++ b/src/ToolBox/SOS/Strike/gcroot.cpp
@@ -40,18 +40,14 @@
 #include "safemath.h"
 
 
-#ifdef _ASSERTE
 #undef _ASSERTE
-#endif
 
-#ifndef _ASSERTE
 #ifdef _DEBUG
 #define _ASSERTE(expr)         \
     do { if (!(expr) ) { ExtErr("_ASSERTE fired:\n\t%s\n", #expr); if (IsDebuggerPresent()) DebugBreak(); } } while (0)
 #else
 #define _ASSERTE(x)
 #endif
-#endif // ASSERTE
 
 inline size_t ALIGN_DOWN( size_t val, size_t alignment )
 {
diff --git a/src/ToolBox/SOS/Strike/inc/dbgeng.h b/src/ToolBox/SOS/Strike/inc/dbgeng.h
index 73e4d19f99..cf04574c12 100644
--- a/src/ToolBox/SOS/Strike/inc/dbgeng.h
+++ b/src/ToolBox/SOS/Strike/inc/dbgeng.h
@@ -42,7 +42,11 @@ typedef struct _MEMORY_BASIC_INFORMATION64* PMEMORY_BASIC_INFORMATION64;
 #define __out_xcount(x)
 #define __inout
 #define __inout_opt
-#define __reserved
+// Android defines various fields on struct which are named __reserved[x]; for example, in wchar.h,
+// so we must prefix __reserved with __clr_
+#define __clr_reserved
+#else
+#define __clr_reserved __reserved
 #endif
 
 #ifdef __cplusplus
@@ -1509,7 +1513,7 @@ DECLARE_INTERFACE_(IDebugClient, IUnknown)
         THIS_
         __in ULONG Flags,
         __in PCSTR Options,
-        __in_opt __reserved PVOID Reserved
+        __in_opt __clr_reserved PVOID Reserved
         ) PURE;
     STDMETHOD(ConnectProcessServer)(
         THIS_
@@ -1937,7 +1941,7 @@ DECLARE_INTERFACE_(IDebugClient2, IUnknown)
         THIS_
         __in ULONG Flags,
         __in PCSTR Options,
-        __in_opt __reserved PVOID Reserved
+        __in_opt __clr_reserved PVOID Reserved
         ) PURE;
     STDMETHOD(ConnectProcessServer)(
         THIS_
@@ -2394,7 +2398,7 @@ DECLARE_INTERFACE_(IDebugClient3, IUnknown)
         THIS_
         __in ULONG Flags,
         __in PCSTR Options,
-        __in_opt __reserved PVOID Reserved
+        __in_opt __clr_reserved PVOID Reserved
         ) PURE;
     STDMETHOD(ConnectProcessServer)(
         THIS_
@@ -2902,7 +2906,7 @@ DECLARE_INTERFACE_(IDebugClient4, IUnknown)
         THIS_
         __in ULONG Flags,
         __in PCSTR Options,
-        __in_opt __reserved PVOID Reserved
+        __in_opt __clr_reserved PVOID Reserved
         ) PURE;
     STDMETHOD(ConnectProcessServer)(
         THIS_
@@ -3449,7 +3453,7 @@ DECLARE_INTERFACE_(IDebugClient5, IUnknown)
         THIS_
         __in ULONG Flags,
         __in PCSTR Options,
-        __in_opt __reserved PVOID Reserved
+        __in_opt __clr_reserved PVOID Reserved
         ) PURE;
     STDMETHOD(ConnectProcessServer)(
         THIS_
@@ -3961,7 +3965,7 @@ DECLARE_INTERFACE_(IDebugClient5, IUnknown)
         THIS_
         __in ULONG Flags,
         __in PCWSTR Options,
-        __in_opt __reserved PVOID Reserved
+        __in_opt __clr_reserved PVOID Reserved
         ) PURE;
     STDMETHOD(ConnectProcessServerWide)(
         THIS_
diff --git a/src/ToolBox/SOS/Strike/sos.cpp b/src/ToolBox/SOS/Strike/sos.cpp
index 351199c058..64ee4b9a0c 100644
--- a/src/ToolBox/SOS/Strike/sos.cpp
+++ b/src/ToolBox/SOS/Strike/sos.cpp
@@ -17,9 +17,7 @@
 #include "gcdesc.h"
 
 
-#ifdef _ASSERTE
 #undef _ASSERTE
-#endif
 
 namespace sos
 {
diff --git a/src/ToolBox/SOS/Strike/strike.cpp b/src/ToolBox/SOS/Strike/strike.cpp
index 3bb3f50200..31c58dfe4d 100644
--- a/src/ToolBox/SOS/Strike/strike.cpp
+++ b/src/ToolBox/SOS/Strike/strike.cpp
@@ -2090,11 +2090,9 @@ struct StackTraceElement
     UINT_PTR        ip;
     UINT_PTR        sp;
     DWORD_PTR       pFunc;  // MethodDesc
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
     // TRUE if this element represents the last frame of the foreign
     // exception stack trace.
     BOOL            fIsLastFrameFromForeignStackTrace;
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 
 };
 
diff --git a/src/ToolBox/SOS/Strike/util.cpp b/src/ToolBox/SOS/Strike/util.cpp
index b6336fb143..3cdebcf0f4 100644
--- a/src/ToolBox/SOS/Strike/util.cpp
+++ b/src/ToolBox/SOS/Strike/util.cpp
@@ -4793,10 +4793,8 @@ HRESULT InitCorDebugInterface()
     // Need to pick the appropriate SKU of CLR to detect
 #if defined(FEATURE_CORESYSTEM)
     GUID skuId = CLR_ID_ONECORE_CLR;
-#elif defined(FEATURE_CORECLR)
-    GUID skuId = CLR_ID_CORECLR;
 #else
-    GUID skuId = CLR_ID_V4_DESKTOP;
+    GUID skuId = CLR_ID_CORECLR;
 #endif
     CLRDebuggingImpl* pDebuggingImpl = new CLRDebuggingImpl(skuId);
     hr = pDebuggingImpl->QueryInterface(IID_ICLRDebugging, (LPVOID *)&pClrDebugging);
diff --git a/src/ToolBox/SOS/lldbplugin/CMakeLists.txt b/src/ToolBox/SOS/lldbplugin/CMakeLists.txt
index 8ae2c9b646..29b36e8fa2 100644
--- a/src/ToolBox/SOS/lldbplugin/CMakeLists.txt
+++ b/src/ToolBox/SOS/lldbplugin/CMakeLists.txt
@@ -30,8 +30,11 @@ elseif(CLR_CMAKE_PLATFORM_ARCH_ARM)
     add_definitions(-DDBG_TARGET_32BIT=1)
     add_definitions(-DDBG_TARGET_ARM=1)
 elseif(CLR_CMAKE_PLATFORM_ARCH_ARM64)
-    message(WARNING "lldb is not supported on linux/aarch64 yet")
-    return()
+    add_definitions(-D_TARGET_ARM64_=1)
+    add_definitions(-DDBG_TARGET_64BIT=1)
+    add_definitions(-DDBG_TARGET_ARM64=1)
+    add_definitions(-DDBG_TARGET_WIN64=1)
+    add_definitions(-DBIT64)
 endif()
 
 set(ENABLE_LLDBPLUGIN ${CLR_CMAKE_PLATFORM_UNIX} CACHE BOOL "Enable building the SOS plugin for LLDB.")
@@ -49,13 +52,13 @@ if(NOT ENABLE_LLDBPLUGIN)
 endif()
 
 # Check for LLDB library
-find_library(LLDB NAMES LLDB lldb lldb-3.8 lldb-3.7 lldb-3.6 lldb-3.5 PATHS "${WITH_LLDB_LIBS}" PATH_SUFFIXES llvm NO_DEFAULT_PATH)
-find_library(LLDB NAMES LLDB lldb lldb-3.8 lldb-3.7 lldb-3.6 lldb-3.5 PATH_SUFFIXES llvm)
+find_library(LLDB NAMES LLDB lldb lldb-3.9 lldb-3.8 lldb-3.7 lldb-3.6 lldb-3.5 PATHS "${WITH_LLDB_LIBS}" PATH_SUFFIXES llvm NO_DEFAULT_PATH)
+find_library(LLDB NAMES LLDB lldb lldb-3.9 lldb-3.8 lldb-3.7 lldb-3.6 lldb-3.5 PATH_SUFFIXES llvm)
 if(LLDB STREQUAL LLDB-NOTFOUND)
     if(REQUIRE_LLDBPLUGIN)
-        message(FATAL_ERROR "Cannot find lldb-3.5, lldb-3.6 or lldb-3.8. Try installing lldb-3.6-dev (or the appropriate package for your platform)")
+        message(FATAL_ERROR "Cannot find lldb-3.5, lldb-3.6, lldb-3.8 or lldb-3.9. Try installing lldb-3.6-dev (or the appropriate package for your platform)")
     else()
-        message(WARNING "Cannot find lldb-3.5,lldb-3.6 or lldb-3.8. Try installing lldb-3.6-dev (or the appropriate package for your platform)")
+        message(WARNING "Cannot find lldb-3.5,lldb-3.6, lldb-3.8 or lldb-3.9. Try installing lldb-3.6-dev (or the appropriate package for your platform)")
     endif()
     return()
 endif()
@@ -63,28 +66,24 @@ endif()
 message(STATUS "LLDB: ${LLDB}")
 
 # Check for LLDB headers
-
+# Multiple versions of LLDB can install side-by-side, so we need to check for lldb in various locations.
+# If the file in a directory is found the result is stored in the variable and the search will not be repeated unless the variable is cleared.
 find_path(LLDB_H "lldb/API/LLDB.h" PATHS "${WITH_LLDB_INCLUDES}" NO_DEFAULT_PATH)
 find_path(LLDB_H "lldb/API/LLDB.h")
+
+find_path(LLDB_H "lldb/API/LLDB.h" PATHS "/usr/lib/llvm-3.9/include")
+find_path(LLDB_H "lldb/API/LLDB.h" PATHS "/usr/lib/llvm-3.8/include")
+find_path(LLDB_H "lldb/API/LLDB.h" PATHS "/usr/lib/llvm-3.7/include")
+find_path(LLDB_H "lldb/API/LLDB.h" PATHS "/usr/lib/llvm-3.6/include")
+find_path(LLDB_H "lldb/API/LLDB.h" PATHS "/usr/lib/llvm-3.5/include")
+
 if(LLDB_H STREQUAL LLDB_H-NOTFOUND)
-    find_path(LLDB_H "lldb/API/LLDB.h" PATHS "/usr/lib/llvm-3.8/include")
-    if(LLDB_H STREQUAL LLDB_H-NOTFOUND)
-		find_path(LLDB_H "lldb/API/LLDB.h" PATHS "/usr/lib/llvm-3.7/include")
-    	if(LLDB_H STREQUAL LLDB_H-NOTFOUND)
-			find_path(LLDB_H "lldb/API/LLDB.h" PATHS "/usr/lib/llvm-3.6/include")
-			if(LLDB_H STREQUAL LLDB_H-NOTFOUND)
-				find_path(LLDB_H "lldb/API/LLDB.h" PATHS "/usr/lib/llvm-3.5/include")
-				if(LLDB_H STREQUAL LLDB_H-NOTFOUND)
-					if(REQUIRE_LLDBPLUGIN)
-						message(FATAL_ERROR "Cannot find LLDB.h. Try installing lldb-3.6-dev (or the appropriate package for your platform)")
-					else()
-						message(WARNING "Cannot find LLDB.h Try installing lldb-3.6-dev (or the appropriate package for your platform)")
-					endif()
-					return()
-				endif()
-			endif()
-		endif()
+    if(REQUIRE_LLDBPLUGIN)
+        message(FATAL_ERROR "Cannot find LLDB.h. Try installing lldb-3.6-dev (or the appropriate package for your platform)")
+    else()
+        message(WARNING "Cannot find LLDB.h Try installing lldb-3.6-dev (or the appropriate package for your platform)")
     endif()
+    return()
 endif()
 
 message(STATUS "LLDB_H: ${LLDB_H}")
diff --git a/src/ToolBox/SOS/lldbplugin/inc/lldbservices.h b/src/ToolBox/SOS/lldbplugin/inc/lldbservices.h
index 16702b116d..4817e811df 100644
--- a/src/ToolBox/SOS/lldbplugin/inc/lldbservices.h
+++ b/src/ToolBox/SOS/lldbplugin/inc/lldbservices.h
@@ -81,6 +81,7 @@ extern "C" {
 #define IMAGE_FILE_MACHINE_I386              0x014c  // Intel 386.
 #define IMAGE_FILE_MACHINE_ARMNT             0x01c4  // ARM Thumb-2 Little-Endian
 #define IMAGE_FILE_MACHINE_AMD64             0x8664  // AMD64 (K8)
+#define IMAGE_FILE_MACHINE_ARM64             0xAA64  // ARM64 Little-Endian
 
 // Execution status codes used for waiting,
 // for returning current status and for
diff --git a/src/ToolBox/SOS/lldbplugin/services.cpp b/src/ToolBox/SOS/lldbplugin/services.cpp
index d2d2cf9f8e..e3eee4fc59 100644
--- a/src/ToolBox/SOS/lldbplugin/services.cpp
+++ b/src/ToolBox/SOS/lldbplugin/services.cpp
@@ -171,6 +171,10 @@ LLDBServices::VirtualUnwind(
     DWORD spToFind = dtcontext->Esp;
 #elif DBG_TARGET_ARM
     DWORD spToFind = dtcontext->Sp;
+#elif DBG_TARGET_ARM64
+    DWORD64 spToFind = dtcontext->Sp;
+#else
+#error "spToFind undefined for this platform"
 #endif
     
     int numFrames = thread.GetNumFrames();
@@ -407,6 +411,12 @@ LLDBServices::GetExecutingProcessorType(
     *type = IMAGE_FILE_MACHINE_AMD64;
 #elif DBG_TARGET_ARM
     *type = IMAGE_FILE_MACHINE_ARMNT;
+#elif DBG_TARGET_ARM64
+    *type = IMAGE_FILE_MACHINE_ARM64;
+#elif DBG_TARGET_X86
+    *type = IMAGE_FILE_MACHINE_I386;
+#else
+#error "Unsupported target"
 #endif
     return S_OK;
 }
diff --git a/src/binder/applicationcontext.cpp b/src/binder/applicationcontext.cpp
index e5c3025787..d395f4ddc1 100644
--- a/src/binder/applicationcontext.cpp
+++ b/src/binder/applicationcontext.cpp
@@ -143,9 +143,7 @@ namespace BINDER_SPACE
             m_pFailureCache = pFailureCache;
         }
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)      
         m_fCanExplicitlyBindToNativeImages = false;
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
         
     Exit:
         BINDER_LOG_LEAVE_HR(W("ApplicationContext::Init"), hr);
diff --git a/src/binder/assemblybinder.cpp b/src/binder/assemblybinder.cpp
index 517eac99d6..a73f79fb65 100644
--- a/src/binder/assemblybinder.cpp
+++ b/src/binder/assemblybinder.cpp
@@ -46,7 +46,7 @@
 
 BOOL IsCompilationProcess();
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#if !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
 #include "clrprivbindercoreclr.h"
 #include "clrprivbinderassemblyloadcontext.h"
 // Helper function in the VM, invoked by the Binder, to invoke the host assembly resolver
@@ -57,7 +57,7 @@ extern HRESULT RuntimeInvokeHostAssemblyResolver(INT_PTR pManagedAssemblyLoadCon
 // Helper to check if we have a host assembly resolver set
 extern BOOL RuntimeCanUseAppPathAssemblyResolver(DWORD adid);
 
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#endif // !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
 
 namespace BINDER_SPACE
 {
@@ -1073,12 +1073,12 @@ namespace BINDER_SPACE
                 // Dynamic binds need to be always considered a failure for binding closures
                 IF_FAIL_GO(FUSION_E_APP_DOMAIN_LOCKED);
             }
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#if !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
             else if (IgnoreRefDefMatch(dwBindFlags))
             {
                 // Skip RefDef matching if we have been asked to.
             }
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#endif // !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
             else
             {
                 // Can't give higher serciving than already bound
@@ -1393,13 +1393,13 @@ namespace BINDER_SPACE
 
             bool fUseAppPathsBasedResolver = !excludeAppPaths;
             
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#if !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
             // If Host Assembly Resolver is specified, then we will use that as the override for the default resolution mechanism (that uses AppPath probing).
             if (fUseAppPathsBasedResolver && !RuntimeCanUseAppPathAssemblyResolver(pApplicationContext->GetAppDomainId()))
             {
                 fUseAppPathsBasedResolver = false;
             }
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#endif // !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
              
             // This loop executes twice max.  First time through we probe AppNiPaths, the second time we probe AppPaths
             bool parseNiPaths = true;
@@ -1812,7 +1812,7 @@ namespace BINDER_SPACE
 
 #endif //CROSSGEN_COMPILE
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#if !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
 HRESULT AssemblyBinder::BindUsingHostAssemblyResolver (/* in */ INT_PTR pManagedAssemblyLoadContextToBindWithin,
                                                        /* in */ AssemblyName       *pAssemblyName,
                                                       /* in */ IAssemblyName      *pIAssemblyName,
@@ -1947,7 +1947,7 @@ Exit:
     BINDER_LOG_LEAVE_HR(W("AssemblyBinder::BindUsingPEImage"), hr);
     return hr;
 }
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#endif // !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
 };
 
 
diff --git a/src/binder/clrprivbinderassemblyloadcontext.cpp b/src/binder/clrprivbinderassemblyloadcontext.cpp
index 8f3a3eef49..e6f957aabe 100644
--- a/src/binder/clrprivbinderassemblyloadcontext.cpp
+++ b/src/binder/clrprivbinderassemblyloadcontext.cpp
@@ -8,7 +8,7 @@
 #include "clrprivbinderassemblyloadcontext.h"
 #include "clrprivbinderutil.h"
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#if !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
 
 using namespace BINDER_SPACE;
 
@@ -256,4 +256,4 @@ CLRPrivBinderAssemblyLoadContext::CLRPrivBinderAssemblyLoadContext()
     m_pTPABinder = NULL;
 }
 
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#endif // !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
diff --git a/src/binder/clrprivbindercoreclr.cpp b/src/binder/clrprivbindercoreclr.cpp
index d62af867ef..b7a6807520 100644
--- a/src/binder/clrprivbindercoreclr.cpp
+++ b/src/binder/clrprivbindercoreclr.cpp
@@ -62,7 +62,7 @@ HRESULT CLRPrivBinderCoreCLR::BindAssemblyByName(IAssemblyName     *pIAssemblyNa
         
         hr = BindAssemblyByNameWorker(pAssemblyName, &pCoreCLRFoundAssembly, false /* excludeAppPaths */);
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#if !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
         if ((hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)) ||
             (hr == FUSION_E_APP_DOMAIN_LOCKED) || (hr == FUSION_E_REF_DEF_MISMATCH))
         {
@@ -94,7 +94,7 @@ HRESULT CLRPrivBinderCoreCLR::BindAssemblyByName(IAssemblyName     *pIAssemblyNa
               }
             }
         }
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#endif // !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
         
         IF_FAIL_GO(hr);
 
@@ -107,7 +107,7 @@ Exit:;
     return hr;
 }
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#if !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
 HRESULT CLRPrivBinderCoreCLR::BindUsingPEImage( /* in */ PEImage *pPEImage, 
                                                             /* in */ BOOL fIsNativeImage, 
                                                             /* [retval][out] */ ICLRPrivAssembly **ppAssembly)
@@ -179,7 +179,7 @@ Exit:;
 
     return hr;
 }
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#endif // !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
 
 HRESULT CLRPrivBinderCoreCLR::VerifyBind(IAssemblyName        *AssemblyName,
                                          ICLRPrivAssembly     *pAssembly,
diff --git a/src/binder/coreclrbindercommon.cpp b/src/binder/coreclrbindercommon.cpp
index 86540fcfd5..e788c15488 100644
--- a/src/binder/coreclrbindercommon.cpp
+++ b/src/binder/coreclrbindercommon.cpp
@@ -107,12 +107,8 @@ HRESULT CCoreCLRBinderHelper::BindToSystem(ICLRPrivAssembly **ppSystemAssembly,
     EX_TRY
     {
         ReleaseHolder<BINDER_SPACE::Assembly> pAsm;
-#ifdef FEATURE_CORECLR
         StackSString systemPath(SystemDomain::System()->SystemDirectory());
         hr = AssemblyBinder::BindToSystem(systemPath, &pAsm, fBindToNativeImage);
-#else
-        AssemblySpec::BindToSystem(&pAsm);
-#endif
         if(SUCCEEDED(hr))
         {
             _ASSERTE(pAsm != NULL);
diff --git a/src/binder/inc/applicationcontext.hpp b/src/binder/inc/applicationcontext.hpp
index 4c256771eb..9c8926207c 100644
--- a/src/binder/inc/applicationcontext.hpp
+++ b/src/binder/inc/applicationcontext.hpp
@@ -174,7 +174,6 @@ namespace BINDER_SPACE
         SimpleNameToFileNameMap * m_pTrustedPlatformAssemblyMap;
         TpaFileNameHash    * m_pFileNameHash;
         
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)      
         bool m_fCanExplicitlyBindToNativeImages;
 public:        
         inline void SetExplicitBindToNativeImages(bool fCanExplicitlyBindToNativeImages)
@@ -187,7 +186,6 @@ public:
             return m_fCanExplicitlyBindToNativeImages;
         }
 protected:        
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
     };
 
 #include "applicationcontext.inl"
diff --git a/src/binder/inc/assembly.hpp b/src/binder/inc/assembly.hpp
index 5b8425a3d1..425e80567e 100644
--- a/src/binder/inc/assembly.hpp
+++ b/src/binder/inc/assembly.hpp
@@ -21,13 +21,11 @@
 #include "corpriv.h"
 #include "clrprivbinding.h"
 
-#if !defined(FEATURE_FUSION)
 #include "clrprivbindercoreclr.h"
-#endif // !defined(FEATURE_FUSION)
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#if !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
 #include "clrprivbinderassemblyloadcontext.h"
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#endif // !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
 
 STDAPI BinderAcquirePEImage(LPCTSTR   szAssemblyPath,
                             PEImage **ppPEImage,
@@ -203,13 +201,11 @@ public:
             return m_pBinder;
         }
         
-#if !defined(FEATURE_FUSION)
         friend class ::CLRPrivBinderCoreCLR;
-#endif // !defined(FEATURE_FUSION)
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#if !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
         friend class ::CLRPrivBinderAssemblyLoadContext;
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#endif // !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
     };
 
     // This is a fast version which goes around the COM interfaces and directly
diff --git a/src/binder/inc/assemblybinder.hpp b/src/binder/inc/assemblybinder.hpp
index 3a1f1e45fd..fa2f8b409a 100644
--- a/src/binder/inc/assemblybinder.hpp
+++ b/src/binder/inc/assemblybinder.hpp
@@ -74,7 +74,7 @@ namespace BINDER_SPACE
                                    /* out */ Assembly   **ppAssembly,
                                    /* in */  LPCTSTR      szMDAssemblyPath = NULL);
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#if !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
         static HRESULT BindUsingHostAssemblyResolver (/* in */ INT_PTR pManagedAssemblyLoadContextToBindWithin,
                                                       /* in */ AssemblyName       *pAssemblyName,
                                                       /* in */ IAssemblyName      *pIAssemblyName,
@@ -87,7 +87,7 @@ namespace BINDER_SPACE
                                         /* in */  PEKIND              peKind,
                                         /* in */  IMDInternalImport  *pIMetaDataAssemblyImport, 
                                         /* [retval] [out] */  Assembly **ppAssembly);          
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#endif // !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
                                  
         static HRESULT TranslatePEToArchitectureType(DWORD  *pdwPAFlags, PEKIND *PeKind);
         
@@ -98,10 +98,10 @@ namespace BINDER_SPACE
             BIND_CACHE_FAILURES = 0x01,
             BIND_CACHE_RERUN_BIND = 0x02,
             BIND_IGNORE_DYNAMIC_BINDS = 0x04
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#if !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
             ,
             BIND_IGNORE_REFDEF_MATCH = 0x8
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#endif // !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
         };
 
         static BOOL IgnoreDynamicBinds(DWORD dwBindFlags)
@@ -119,12 +119,12 @@ namespace BINDER_SPACE
             return ((dwBindFlags & BIND_CACHE_RERUN_BIND) != 0);
         }
         
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#if !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
         static BOOL IgnoreRefDefMatch(DWORD dwBindFlags)
         {
             return ((dwBindFlags & BIND_IGNORE_REFDEF_MATCH) != 0);
         }
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#endif // !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
         
         static HRESULT BindByName(/* in */  ApplicationContext *pApplicationContext,
                                   /* in */  AssemblyName       *pAssemblyName,
diff --git a/src/binder/inc/clrprivbinderassemblyloadcontext.h b/src/binder/inc/clrprivbinderassemblyloadcontext.h
index 83113f4633..9c772338d6 100644
--- a/src/binder/inc/clrprivbinderassemblyloadcontext.h
+++ b/src/binder/inc/clrprivbinderassemblyloadcontext.h
@@ -10,7 +10,7 @@
 #include "applicationcontext.hpp"
 #include "clrprivbindercoreclr.h"
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#if !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
 
 namespace BINDER_SPACE
 {
@@ -82,5 +82,5 @@ private:
     INT_PTR m_ptrManagedAssemblyLoadContext;
 };
 
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#endif // !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
 #endif // __CLRPRIVBINDERASSEMBLYLOADCONTEXT_H__
diff --git a/src/binder/inc/clrprivbindercoreclr.h b/src/binder/inc/clrprivbindercoreclr.h
index e906e01b12..9338fad3df 100644
--- a/src/binder/inc/clrprivbindercoreclr.h
+++ b/src/binder/inc/clrprivbindercoreclr.h
@@ -67,11 +67,11 @@ public:
     HRESULT PreBindByteArray(PEImage  *pPEImage, BOOL fInspectionOnly);
 #endif // CROSSGEN_COMPILE
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#if !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
     HRESULT BindUsingPEImage( /* in */ PEImage *pPEImage, 
                               /* in */ BOOL fIsNativeImage, 
                               /* [retval][out] */ ICLRPrivAssembly **ppAssembly);
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#endif // !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
 
     HRESULT BindAssemblyByNameWorker(
             BINDER_SPACE::AssemblyName *pAssemblyName,
diff --git a/src/binder/inc/fusionhelpers.hpp b/src/binder/inc/fusionhelpers.hpp
index 229ebe6c4e..7b81e8589c 100644
--- a/src/binder/inc/fusionhelpers.hpp
+++ b/src/binder/inc/fusionhelpers.hpp
@@ -21,12 +21,6 @@
 #include "ex.h"
 #include "fusion.h"
 
-#ifndef FEATURE_VERSIONING
-// Rename the fusion bind result to avoid collision with core bind result
-#define IBindResult IBindResult_Fusion
-#include "binderngen.h"
-#undef IBindResult
-#endif
 
 #include "peinformation.h"
 
diff --git a/src/classlibnative/bcltype/CMakeLists.txt b/src/classlibnative/bcltype/CMakeLists.txt
index 4df909ae35..7999c0c90f 100644
--- a/src/classlibnative/bcltype/CMakeLists.txt
+++ b/src/classlibnative/bcltype/CMakeLists.txt
@@ -7,7 +7,6 @@ endif(PerfCountersSupportedBuild)
 set(BCLTYPE_SOURCES
     arraynative.cpp
     arrayhelpers.cpp
-    console.cpp
     currency.cpp
     decimal.cpp
     windowsruntimebufferhelper.cpp
diff --git a/src/classlibnative/bcltype/arraynative.cpp b/src/classlibnative/bcltype/arraynative.cpp
index 9baba44c1e..39899b80ea 100644
--- a/src/classlibnative/bcltype/arraynative.cpp
+++ b/src/classlibnative/bcltype/arraynative.cpp
@@ -1021,7 +1021,7 @@ FCIMPL6(void, ArrayNative::ArrayCopy, ArrayBase* m_pSrc, INT32 m_iSrcIndex, Arra
 
     // cannot pass null for source or destination
     if (gc.pSrc == NULL || gc.pDst == NULL) {
-        FCThrowArgumentNullVoid(gc.pSrc==NULL ? W("source") : W("dest"));
+        FCThrowArgumentNullVoid(gc.pSrc==NULL ? W("sourceArray") : W("destinationArray"));
     }
 
     // source and destination must be arrays
@@ -1048,16 +1048,16 @@ FCIMPL6(void, ArrayNative::ArrayCopy, ArrayBase* m_pSrc, INT32 m_iSrcIndex, Arra
         FCThrowArgumentOutOfRangeVoid(W("length"), W("ArgumentOutOfRange_NeedNonNegNum"));
 
     if (m_iSrcIndex < srcLB || (m_iSrcIndex - srcLB < 0))
-        FCThrowArgumentOutOfRangeVoid(W("srcIndex"), W("ArgumentOutOfRange_ArrayLB"));
+        FCThrowArgumentOutOfRangeVoid(W("sourceIndex"), W("ArgumentOutOfRange_ArrayLB"));
         
     if (m_iDstIndex < destLB || (m_iDstIndex - destLB < 0))
-        FCThrowArgumentOutOfRangeVoid(W("dstIndex"), W("ArgumentOutOfRange_ArrayLB"));
+        FCThrowArgumentOutOfRangeVoid(W("destinationIndex"), W("ArgumentOutOfRange_ArrayLB"));
 
     if ((DWORD)(m_iSrcIndex - srcLB + m_iLength) > srcLen)
-        FCThrowResVoid(kArgumentException, W("Arg_LongerThanSrcArray"));
+        FCThrowArgumentVoid(W("sourceArray"), W("Arg_LongerThanSrcArray"));
         
     if ((DWORD)(m_iDstIndex - destLB + m_iLength) > destLen)
-        FCThrowResVoid(kArgumentException, W("Arg_LongerThanDestArray"));
+        FCThrowArgumentVoid(W("destinationArray"), W("Arg_LongerThanDestArray"));
 
     int r = 0;
 
@@ -1186,18 +1186,6 @@ void ArrayNative::CheckElementType(TypeHandle elementType)
         // TODO: We also should check for type/member visibility here. To do that we can replace
         // the following chunk of code with a simple InvokeUtil::CanAccessClass call.
         // But it's too late to make this change in Dev10 and we want SL4 to be compatible with Dev10.
-#ifndef FEATURE_CORECLR
-        // Make sure security allows us access to the array type - if it is critical, convert that to a
-        // demand for full trust
-        if (!SecurityStackWalk::HasFlagsOrFullyTrusted(0))
-        {
-            if (Security::TypeRequiresTransparencyCheck(pMT, true))
-            {
-                // If we're creating a critical type, convert the critical check into a demand for full trust
-                Security::SpecialDemand(SSWT_LATEBOUND_LINKDEMAND, SECURITY_FULL_TRUST);
-            }
-        }
-#else
         if (Security::TypeRequiresTransparencyCheck(pMT))
         {
             // The AccessCheckOptions flag doesn't matter because we just need to get the caller.
@@ -1210,7 +1198,6 @@ void ArrayNative::CheckElementType(TypeHandle elementType)
             
             accessCheckOptions.DemandMemberAccessOrFail(&sCtx, pMT, FALSE /*visibilityCheck*/);
         }        
-#endif // !FEATURE_CORECLR
 
         // Check for byref-like types.
         if (pMT->IsByRefLike())
diff --git a/src/classlibnative/bcltype/console.cpp b/src/classlibnative/bcltype/console.cpp
deleted file mode 100644
index 7dfb30a5f5..0000000000
--- a/src/classlibnative/bcltype/console.cpp
+++ /dev/null
@@ -1,152 +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.
-//
-// File: Console.cpp
-//
-
-//
-// Purpose: Native methods on System.Console
-//
-//
-
-#ifndef FEATURE_CORECLR
-
-#include "common.h"
-#include "sbuffer.h"
-#include <windows.h>
-#include "console.h"
-
-// GetConsoleTitle sometimes interprets the second parameter (nSize) as number of bytes and sometimes as the number of chars.
-// Instead of doing complicated and dangerous logic to determine if this may or may not occur,
-// we simply assume the worst and reserve a bigger buffer. This way we may use a bit more memory,
-// but we will always be safe. This macro helps us doing that:
-#define ADJUST_NUM_CHARS(numChars) ((numChars) * 2)
-
-#define BUFF_SIZE(numChars)         ( ((numChars) + 1) * sizeof(TCHAR) )
-
-// A buffer of size ConsoleNative::MaxConsoleTitleLength is quite big.
-// First, we try allocating a smaller buffer because most often, the console title is short.
-// If it turns out that the short buffer size is insufficient, we try again using a larger buffer.
-INT32 QCALLTYPE ConsoleNative::GetTitle(QCall::StringHandleOnStack outTitle, INT32& outTitleLen) {
-
-    QCALL_CONTRACT;
-    
-    INT32 result = 0;
-    
-    BEGIN_QCALL;
-
-    // Reserve buffer:   
-    InlineSBuffer< ADJUST_NUM_CHARS(BUFF_SIZE(ShortConsoleTitleLength)) > titleBuff;
-        
-    // Hold last error:
-    DWORD lastError;
-
-    // Read console title, get length of the title:    
-    
-    BYTE *buffPtr = titleBuff.OpenRawBuffer( ADJUST_NUM_CHARS(BUFF_SIZE(ShortConsoleTitleLength)) );
-    
-    SetLastError(0);
-    DWORD len = GetConsoleTitle((TCHAR *) buffPtr, ADJUST_NUM_CHARS(ShortConsoleTitleLength + 1));
-    lastError = GetLastError();
-
-    titleBuff.CloseRawBuffer();
-    
-    // If the title length is larger than supported maximum, do not bother reading it, just return the length:
-    if (len > MaxConsoleTitleLength) {
-    
-        outTitleLen = len;
-        outTitle.Set(W(""));    
-        result = 0;  
-    
-    // If title length is within valid range:
-    } else {
-    
-        // If the title is longer than the short buffer, but can fit in the max supported length,
-        // read it again with the long buffer:
-        if (len > ShortConsoleTitleLength) {
-        
-            COUNT_T buffSize = ADJUST_NUM_CHARS(BUFF_SIZE(len));
-            titleBuff.SetSize(buffSize);
-            
-            BYTE *buffPtr = titleBuff.OpenRawBuffer(buffSize);
-            
-            SetLastError(0);
-            len = GetConsoleTitle((TCHAR *) buffPtr, ADJUST_NUM_CHARS(len + 1));
-            lastError = GetLastError();
-
-            titleBuff.CloseRawBuffer();
-        }
-        
-        // Zero may indicate error or empty title. Check for error:
-        result = (INT32) (0 == len ? lastError : 0);
-        
-        // If no error, set title and length:
-        if (0 == result) {
-            const BYTE *cBuffPtr = (const BYTE *) titleBuff;
-            outTitle.Set((TCHAR *) cBuffPtr);
-            outTitleLen = (INT32) len;
-            
-        // If error, set to empty:
-        } else {            
-            outTitleLen = (INT32) -1;
-            // No need to set the title string if we have an error anyway.
-        }
-    }  // if title length is within valid range.
-        
-    END_QCALL;
-
-    return result;
-}
-
-// Block waiting for data to become available on the console stream indicated by the safe file handle passed.
-// Ensure that the thread remains abortable in the process.
-FCIMPL2(void, ConsoleStreamHelper::WaitForAvailableConsoleInput, SafeHandle* refThisUNSAFE, CLR_BOOL bIsPipe)
-{
-    FCALL_CONTRACT;
-
-    SAFEHANDLEREF refConsoleHandle(refThisUNSAFE);
-
-    HELPER_METHOD_FRAME_BEGIN_1(refConsoleHandle);
-
-    // Prevent the console handle being closed under our feet.
-    SafeHandleHolder shh(&refConsoleHandle);
-
-    // Don't pass the address of the native handle within the safe handle to DoAppropriateWait since the safe
-    // handle is on the GC heap and could be moved. Instead copy the native handle out into a stack location
-    // (this is safe because we've ref-counted the safe handle to prevent it being disposed on us).
-    HANDLE hNativeConsoleHandle = refConsoleHandle->GetHandle();
-
-    bool skipWait = false;
-
-    // If we are reading from a pipe and the other end of the pipe was closed, then do not block.  No one can write to it.
-    // Also we can skip blocking if we do have data available.  We should block if nothing is available, with the assumption 
-    // that Windows is smart enough to handle pipes where the other end is closed.
-    if (bIsPipe)
-    {
-        DWORD cBytesRead, cTotalBytesAvailable, cBytesLeftThisMessage;
-        int r = PeekNamedPipe(hNativeConsoleHandle, NULL, 0, &cBytesRead, &cTotalBytesAvailable, &cBytesLeftThisMessage);
-        if (r != 0)
-        {
-            skipWait = cTotalBytesAvailable > 0;
-        }
-        else
-        {
-            // Windows returns ERROR_BROKEN_PIPE if the other side of a pipe is closed.  However, we've seen
-            // pipes return ERROR_NO_DATA and ERROR_PIPE_NOT_CONNECTED.  Check for those too.
-            int errorCode = GetLastError();
-            skipWait = errorCode == ERROR_BROKEN_PIPE || errorCode == ERROR_NO_DATA || errorCode == ERROR_PIPE_NOT_CONNECTED;
-        }
-    }
-
-    // Perform the wait (DoAppropriateWait automatically handles thread aborts).
-    if (!skipWait)
-    {
-        GetThread()->DoAppropriateWait(1, &hNativeConsoleHandle, TRUE, INFINITE, WaitMode_Alertable);
-    }
-  
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-
-#endif  // ifndef FEATURE_CORECLR
diff --git a/src/classlibnative/bcltype/console.h b/src/classlibnative/bcltype/console.h
deleted file mode 100644
index b3772f2425..0000000000
--- a/src/classlibnative/bcltype/console.h
+++ /dev/null
@@ -1,45 +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.
-//
-// File: Console.h
-//
-
-//
-// Purpose: Native methods on System.Console
-//
-
-//
-#ifndef _CONSOLE_H_
-#define _CONSOLE_H_
-
-#ifndef FEATURE_CORECLR
-
-#include "qcall.h"
-
-class ConsoleNative {
-
-private:
-
-    // Short buffer len to try using first:
-    static const INT32 ShortConsoleTitleLength = 200;
-    
-public:
-
-    // This value is copied from Console.cs. There is said:
-    // MSDN says console titles can be up to 64KB in length.
-    // But there is an exception if the buffer lengths longer than
-    // ~24500 Unicode characters are used. Oh well.
-    static const INT32 MaxConsoleTitleLength = 24500;
-        
-    static INT32 QCALLTYPE GetTitle(QCall::StringHandleOnStack outTitle, INT32& outTitleLen);  
-};
-
-class ConsoleStreamHelper {
-public:
-    static FCDECL2(void, WaitForAvailableConsoleInput, SafeHandle* refThisUNSAFE, CLR_BOOL bIsPipe);
-};
-
-#endif  // ifndef FEATURE_CORECLR
-
-#endif  // _CONSOLE_H_
diff --git a/src/classlibnative/bcltype/number.cpp b/src/classlibnative/bcltype/number.cpp
index 3f2d63c70e..34169a77ed 100644
--- a/src/classlibnative/bcltype/number.cpp
+++ b/src/classlibnative/bcltype/number.cpp
@@ -1294,14 +1294,6 @@ STRINGREF NumberToString(NUMBER* number, wchar format, int nMaxDigits, NUMFMTREF
     STRINGREF sZero=NULL;
 
     // @TODO what if not sequential?
-#ifndef FEATURE_CORECLR
-    if (numfmt->iDigitSubstitution == 2) // native digits
-    {
-        PTRARRAYREF aDigits = numfmt->sNativeDigits;
-        if (aDigits!=NULL && aDigits->GetNumComponents()>0)
-            sZero=(STRINGREF)aDigits->GetAt(0);
-    }
-#endif    
 
     // Do the worst case calculation
     /* US English - for Double.MinValue.ToString("C99"); we require 514 characters
@@ -2557,51 +2549,6 @@ FCIMPL3_VII(Object*, COMNumber::FormatUInt64, UINT64 value, StringObject* format
 }
 FCIMPLEND
 
-#if !defined(FEATURE_CORECLR)
-//
-// Used by base types that are not in mscorlib.dll (such as System.Numerics.BigInteger in System.Core.dll)
-// Note that the allDigits buffer must be fixed across this call or you will introduce a GC Hole.
-//
-FCIMPL4(Object*, COMNumber::FormatNumberBuffer, BYTE* number, StringObject* formatUNSAFE, NumberFormatInfo* numfmtUNSAFE, __in_z wchar_t* allDigits)
-{
-    FCALL_CONTRACT;
-
-    wchar fmt;
-    int digits;
-    NUMBER* pNumber;
-
-    struct _gc
-    {
-        STRINGREF   refFormat;
-        NUMFMTREF   refNumFmt;
-        STRINGREF   refRetString;
-    } gc;
-
-    gc.refFormat    = ObjectToSTRINGREF(formatUNSAFE);
-    gc.refNumFmt    = (NUMFMTREF)numfmtUNSAFE;
-    gc.refRetString = NULL;
-
-    HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc);
-    if (gc.refNumFmt == 0) COMPlusThrowArgumentNull(W("NumberFormatInfo"));
-
-    pNumber = (NUMBER*) number;
-
-    pNumber->allDigits = allDigits;
-
-    fmt = ParseFormatSpecifier(gc.refFormat, &digits);
-    if (fmt != 0) {
-        gc.refRetString = NumberToString(pNumber, fmt, digits, gc.refNumFmt);
-    }
-    else {
-        gc.refRetString = NumberToStringFormat(pNumber, gc.refFormat, gc.refNumFmt);
-    }
-    HELPER_METHOD_FRAME_END();
-
-    return OBJECTREFToObject(gc.refRetString);
-}
-FCIMPLEND
-
-#endif // !FEATURE_CORECLR
 
 FCIMPL2(FC_BOOL_RET, COMNumber::NumberBufferToDecimal, BYTE* number, DECIMAL* value)
 {
diff --git a/src/classlibnative/bcltype/number.h b/src/classlibnative/bcltype/number.h
index 87bab3b9f6..db66435117 100644
--- a/src/classlibnative/bcltype/number.h
+++ b/src/classlibnative/bcltype/number.h
@@ -33,9 +33,6 @@ public:
     static FCDECL3(Object*, FormatUInt32,  UINT32     value, StringObject* formatUNSAFE, NumberFormatInfo* numfmtUNSAFE);
     static FCDECL3_VII(Object*, FormatInt64,   INT64  value, StringObject* formatUNSAFE, NumberFormatInfo* numfmtUNSAFE);
     static FCDECL3_VII(Object*, FormatUInt64,  UINT64 value, StringObject* formatUNSAFE, NumberFormatInfo* numfmtUNSAFE);
-#if !defined(FEATURE_CORECLR)
-    static FCDECL4(Object*, FormatNumberBuffer, BYTE* number, StringObject* formatUNSAFE, NumberFormatInfo* numfmtUNSAFE, __in_z wchar_t* allDigits);
-#endif // !FEATURE_CORECLR
     static FCDECL2(FC_BOOL_RET, NumberBufferToDecimal, BYTE* number, DECIMAL* value);
     static FCDECL2(FC_BOOL_RET, NumberBufferToDouble, BYTE* number, double* value);
     
diff --git a/src/classlibnative/bcltype/stringnative.cpp b/src/classlibnative/bcltype/stringnative.cpp
index 1e6b132b17..af6593a6be 100644
--- a/src/classlibnative/bcltype/stringnative.cpp
+++ b/src/classlibnative/bcltype/stringnative.cpp
@@ -160,12 +160,7 @@ FCIMPLEND
 inline COMNlsHashProvider * GetCurrentNlsHashProvider()
 {
     LIMITED_METHOD_CONTRACT;
-#ifndef FEATURE_CORECLR
-    AppDomain* curDomain = GetAppDomain();
-    return curDomain->m_pNlsHashProvider;
-#else
     return &COMNlsHashProvider::s_NlsHashProvider;
-#endif // FEATURE_CORECLR
 }
 
 FCIMPL3(INT32, COMString::Marvin32HashString, StringObject* thisRefUNSAFE, INT32 strLen, INT64 additionalEntropy) {
diff --git a/src/classlibnative/bcltype/system.cpp b/src/classlibnative/bcltype/system.cpp
index 8bb3409974..78775f2371 100644
--- a/src/classlibnative/bcltype/system.cpp
+++ b/src/classlibnative/bcltype/system.cpp
@@ -31,9 +31,6 @@
 #include "array.h"
 #include "eepolicy.h"
 
-#if !defined(FEATURE_CORECLR)
-#include "metahost.h"
-#endif // !FEATURE_CORECLR
 
 #ifdef FEATURE_WINDOWSPHONE
 Volatile<BOOL> g_fGetPhoneVersionInitialized;
@@ -83,20 +80,6 @@ FCIMPLEND;
 
 
 
-#ifndef FEATURE_CORECLR
-INT64 QCALLTYPE SystemNative::GetWorkingSet()
-{
-    QCALL_CONTRACT;
-
-    DWORD memUsage = 0;
-        
-    BEGIN_QCALL;
-    memUsage = WszGetWorkingSet();
-    END_QCALL;
-    
-    return memUsage;
-}
-#endif // !FEATURE_CORECLR
 
 VOID QCALLTYPE SystemNative::Exit(INT32 exitcode)
 {
@@ -312,24 +295,7 @@ FCIMPLEND
 
 FCIMPL0(StringObject*, SystemNative::GetDeveloperPath)
 {
-#ifdef FEATURE_FUSION
-    FCALL_CONTRACT;
-
-    STRINGREF   refDevPath  = NULL;
-    LPWSTR pPath = NULL;
-    DWORD lgth = 0;
-
-    HELPER_METHOD_FRAME_BEGIN_RET_1(refDevPath);
-
-    SystemDomain::System()->GetDevpathW(&pPath, &lgth);
-    if(lgth) 
-        refDevPath = StringObject::NewString(pPath, lgth);
-    
-    HELPER_METHOD_FRAME_END();
-    return (StringObject*)OBJECTREFToObject(refDevPath);
-#else
     return NULL;
-#endif
 }
 FCIMPLEND
 
@@ -377,24 +343,6 @@ FCIMPL0(StringObject*, SystemNative::GetHostBindingFile);
 }
 FCIMPLEND
 
-#ifndef FEATURE_CORECLR
-
-void QCALLTYPE SystemNative::_GetSystemVersion(QCall::StringHandleOnStack retVer)
-{
-    QCALL_CONTRACT;
-    BEGIN_QCALL;
-
-    WCHAR wszVersion[_MAX_PATH];
-    DWORD dwVersion = _MAX_PATH;
-
-    // Get the version
-    IfFailThrow(g_pCLRRuntime->GetVersionString(wszVersion, &dwVersion));
-    retVer.Set(wszVersion);
-
-    END_QCALL;
-}
-
-#endif
 
 INT32 QCALLTYPE SystemNative::GetProcessorCount()
 {
@@ -439,16 +387,7 @@ LPVOID QCALLTYPE SystemNative::GetRuntimeInterfaceImpl(
 
     BEGIN_QCALL;
 
-#ifdef FEATURE_CORECLR
     IfFailThrow(E_NOINTERFACE);
-#else
-    HRESULT hr = g_pCLRRuntime->GetInterface(clsid, riid, &pUnk);
-
-    if (FAILED(hr))
-        hr = g_pCLRRuntime->QueryInterface(riid, &pUnk);
-
-    IfFailThrow(hr);
-#endif
 
     END_QCALL;
 
@@ -560,11 +499,9 @@ void SystemNative::GenericFailFast(STRINGREF refMesgString, EXCEPTIONREF refExce
 #ifndef FEATURE_PAL    
     // If we have the exception object, then try to setup
     // the watson bucket if it has any details.
-#ifdef FEATURE_CORECLR
     // On CoreCLR, Watson may not be enabled. Thus, we should
     // skip this, if required.
     if (IsWatsonEnabled())
-#endif // FEATURE_CORECLR
     {
         BEGIN_SO_INTOLERANT_CODE(pThread);
         if ((gc.refExceptionForWatsonBucketing == NULL) || !SetupWatsonBucketsForFailFast(gc.refExceptionForWatsonBucketing))
@@ -650,34 +587,6 @@ FCIMPL2(VOID, SystemNative::FailFastWithException, StringObject* refMessageUNSAF
 FCIMPLEND
 
 
-#ifndef FEATURE_CORECLR
-BOOL QCALLTYPE SystemNative::IsCLRHosted()
-{
-    QCALL_CONTRACT;
-
-    BOOL retVal = false;
-    BEGIN_QCALL;
-    retVal = (CLRHosted() & CLRHOSTED) != 0;
-    END_QCALL;
-
-    return retVal;
-}
-
-void QCALLTYPE SystemNative::TriggerCodeContractFailure(ContractFailureKind failureKind, LPCWSTR pMessage, LPCWSTR pCondition, LPCWSTR exceptionAsString)
-{
-    QCALL_CONTRACT;
-
-    BEGIN_QCALL;
-    
-    GCX_COOP();
-
-    EEPolicy::HandleCodeContractFailure(pMessage, pCondition, exceptionAsString);
-    // Note: if the host chose to throw an exception, we've returned from this method and
-    // will throw that exception in managed code, because it's easier to pass the right parameters there.
-
-    END_QCALL;
-}
-#endif // !FEATURE_CORECLR
 
 FCIMPL0(FC_BOOL_RET, SystemNative::IsServerGC)
 {
@@ -795,104 +704,7 @@ FCIMPL1(FC_BOOL_RET, SystemNative::GetOSVersionEx, OSVERSIONINFOEXObject *osVer)
 FCIMPLEND
 
 
-#ifndef FEATURE_CORECLR  
-//
-// SystemNative::LegacyFormatMode - Fcall implementation for System.TimeSpan.LegacyFormatMode
-// checks for the DWORD "TimeSpan_LegacyFormatMode" CLR config option
-//
-FCIMPL0(FC_BOOL_RET, SystemNative::LegacyFormatMode)
-{
-    FCALL_CONTRACT;
-
-    DWORD flag = 0;
-
-    BEGIN_SO_INTOLERANT_CODE_NOTHROW(GetThread(), FCThrow(kStackOverflowException));
-    flag = CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_TimeSpan_LegacyFormatMode);
-    END_SO_INTOLERANT_CODE;
-
-    if (flag)
-        FC_RETURN_BOOL(TRUE);
-    else
-        FC_RETURN_BOOL(FALSE);
-}
-FCIMPLEND
-#endif // !FEATURE_CORECLR  
 
 	
-#ifndef FEATURE_CORECLR  
-//
-// SystemNative::CheckLegacyManagedDeflateStream - Fcall implementation for System.IO.Compression.DeflateStream
-// checks for the DWORD "NetFx45_LegacyManagedDeflateStream" CLR config option
-//
-// Move this into a separate CLRConfigQCallWrapper class once CLRConfig has been refactored!
-//
-FCIMPL0(FC_BOOL_RET, SystemNative::CheckLegacyManagedDeflateStream)
-{
-    FCALL_CONTRACT;
-
-    DWORD flag = 0;
-
-    BEGIN_SO_INTOLERANT_CODE_NOTHROW(GetThread(), FCThrow(kStackOverflowException));
-    flag = CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_NetFx45_LegacyManagedDeflateStream);
-    END_SO_INTOLERANT_CODE;
-
-    if (flag)
-        FC_RETURN_BOOL(TRUE);
-    else
-        FC_RETURN_BOOL(FALSE);
-}
-FCIMPLEND
-#endif // !FEATURE_CORECLR  
-
-#ifndef FEATURE_CORECLR  
-//
-// SystemNative::CheckThrowUnobservedTaskExceptions - Fcall implementation for System.Threading.Tasks.TaskExceptionHolder
-// checks for the DWORD "ThrowUnobservedTaskExceptions" CLR config option
-//
-FCIMPL0(FC_BOOL_RET, SystemNative::CheckThrowUnobservedTaskExceptions)
-{
-    FCALL_CONTRACT;
-
-    DWORD flag = 0;
-
-    BEGIN_SO_INTOLERANT_CODE_NOTHROW(GetThread(), FCThrow(kStackOverflowException));
-    flag = CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_ThrowUnobservedTaskExceptions);
-    END_SO_INTOLERANT_CODE;
-
-    if (flag)
-        FC_RETURN_BOOL(TRUE);
-    else
-        FC_RETURN_BOOL(FALSE);
-}
-FCIMPLEND
-
-BOOL QCALLTYPE SystemNative::LegacyDateTimeParseMode()
-{
-    QCALL_CONTRACT;
-
-    BOOL retVal = false;
-    BEGIN_QCALL;
-    retVal = (BOOL) CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_DateTime_NetFX35ParseMode);
-    END_QCALL;
-
-    return retVal;
-}
-
-//
-// This method used with DateTimeParse to fix the parsing of AM/PM like "1/10 5 AM" case
-//
-BOOL QCALLTYPE SystemNative::EnableAmPmParseAdjustment()
-{
-    QCALL_CONTRACT;
-
-    BOOL retVal = false;
-    BEGIN_QCALL;
-    retVal = (BOOL) CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_DateTime_NetFX40AmPmParseAdjustment);
-    END_QCALL;
-
-    return retVal;
-}
-
 
-#endif // !FEATURE_CORECLR  
 
diff --git a/src/classlibnative/bcltype/system.h b/src/classlibnative/bcltype/system.h
index 9edc595039..1da105841f 100644
--- a/src/classlibnative/bcltype/system.h
+++ b/src/classlibnative/bcltype/system.h
@@ -77,10 +77,6 @@ public:
     static FCDECL1(FC_BOOL_RET, GetOSVersion, OSVERSIONINFOObject *osVer);
     static FCDECL1(FC_BOOL_RET, GetOSVersionEx, OSVERSIONINFOEXObject *osVer);
 
-#ifndef FEATURE_CORECLR
-    static
-    INT64 QCALLTYPE GetWorkingSet();
-#endif // !FEATURE_CORECLR
 
     static
     void QCALLTYPE Exit(INT32 exitcode);
@@ -96,10 +92,6 @@ public:
     static FCDECL1(VOID, FailFast, StringObject* refMessageUNSAFE);
     static FCDECL2(VOID, FailFastWithExitCode, StringObject* refMessageUNSAFE, UINT exitCode);
     static FCDECL2(VOID, FailFastWithException, StringObject* refMessageUNSAFE, ExceptionObject* refExceptionUNSAFE);
-#ifndef FEATURE_CORECLR
-    static void QCALLTYPE TriggerCodeContractFailure(ContractFailureKind failureKind, LPCWSTR pMessage, LPCWSTR pCondition, LPCWSTR exceptionAsText);
-    static BOOL QCALLTYPE IsCLRHosted();
-#endif // !FEATURE_CORECLR
 
     static FCDECL0(StringObject*, GetDeveloperPath);
     static FCDECL1(Object*,       _GetEnvironmentVariable, StringObject* strVar);
@@ -123,23 +115,10 @@ public:
     // Return a method info for the method were the exception was thrown
     static FCDECL1(ReflectMethodObject*, GetMethodFromStackTrace, ArrayBase* pStackTraceUNSAFE);
 
-#ifndef FEATURE_CORECLR    
-    // Functions on the System.TimeSpan class
-    static FCDECL0(FC_BOOL_RET, LegacyFormatMode);
-	// Function on the DateTime
-    static BOOL QCALLTYPE EnableAmPmParseAdjustment();
-	static BOOL QCALLTYPE LegacyDateTimeParseMode();
-#endif // !FEATURE_CORECLR
 
 	
 // Move this into a separate CLRConfigQCallWrapper class once CLRConfif has been refactored:
-#ifndef FEATURE_CORECLR        
-    static FCDECL0(FC_BOOL_RET, CheckLegacyManagedDeflateStream);
-#endif // !FEATURE_CORECLR
 	
-#ifndef FEATURE_CORECLR        
-    static FCDECL0(FC_BOOL_RET, CheckThrowUnobservedTaskExceptions);
-#endif // !FEATURE_CORECLR
 
 private:
     // Common processing code for FailFast
diff --git a/src/classlibnative/inc/nlsinfo.h b/src/classlibnative/inc/nlsinfo.h
index a5dc13f9a8..67677c7576 100644
--- a/src/classlibnative/inc/nlsinfo.h
+++ b/src/classlibnative/inc/nlsinfo.h
@@ -68,9 +68,6 @@ class CultureDataBaseObject;
 class COMNlsInfo {
 
 public:
-#ifdef FEATURE_SYNTHETIC_CULTURES
-    static INT32  WstrToInteger4(__in_z LPCWSTR wstrLocale, __in int Radix);
-#endif // FEATURE_SYNTHETIC_CULTURES
 
     static INT32 GetCHTLanguage();
     static INT32 CallGetSystemDefaultUILanguage();
@@ -85,9 +82,7 @@ public:
     static BOOL QCALLTYPE InternalGetSystemDefaultUILanguage(QCall::StringHandleOnStack systemDefaultUiLanguage);
 
 // Added but disabled from desktop in .NET 4.0, stayed disabled in .NET 4.5
-#ifdef FEATURE_CORECLR
     static FCDECL0(Object*, nativeGetResourceFallbackArray);
-#endif
 
     //
     // Native helper functions for methods in DateTimeFormatInfo
@@ -111,11 +106,6 @@ public:
     static INT_PTR QCALLTYPE InternalInitSortHandle(LPCWSTR localeName, INT_PTR* handleOrigin);
     static INT_PTR InitSortHandleHelper(LPCWSTR localeName, INT_PTR* handleOrigin);
     static INT_PTR InternalInitOsSortHandle(LPCWSTR localeName, INT_PTR* handleOrigin);
-#ifndef FEATURE_CORECLR
-    static INT_PTR InternalInitVersionedSortHandle(LPCWSTR localeName, INT_PTR* handleOrigin);
-    static INT_PTR InternalInitVersionedSortHandle(LPCWSTR localeName, INT_PTR* handleOrigin, DWORD sortVersion);
-    static DWORD QCALLTYPE InternalGetSortVersion();
-#endif
     static BOOL QCALLTYPE InternalGetNlsVersionEx(INT_PTR handle, INT_PTR handleOrigin, LPCWSTR lpLocaleName, NLSVERSIONINFOEX * lpVersionInformation);
 
     //
@@ -124,10 +114,6 @@ public:
     static FCDECL0(INT32, nativeGetNumEncodingItems);
     static FCDECL0(EncodingDataItem *, nativeGetEncodingTableDataPointer);
     static FCDECL0(CodePageDataItem *, nativeGetCodePageTableDataPointer);
-#if FEATURE_CODEPAGES_FILE
-    static FCDECL3(LPVOID, nativeCreateOpenFileMapping,
-                       StringObject* inSectionNameUNSAFE, int inBytesToAllocate, HANDLE *mappedFile);
-#endif // FEATURE_CODEPAGES_FILE
 
     //
     //  Native helper function for methods in CharacterInfo
diff --git a/src/classlibnative/inc/nlstable.h b/src/classlibnative/inc/nlstable.h
deleted file mode 100644
index b5f5a4bca6..0000000000
--- a/src/classlibnative/inc/nlstable.h
+++ /dev/null
@@ -1,121 +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.
-
-// ==++==
-//
-
-//
-
-//
-// TODO: NLS Arrowhead - when we have win7 unicode support this can "go away"
-// ==--==
-#ifndef _NLSTABLE_H
-#define _NLSTABLE_H
-
-////////////////////////////////////////////////////////////////////////////
-//
-//  Class:    NLSTable
-// 
-//  Purpose:  The base class for NLS+ table.  This class provides the utility
-//            functions to open and map a view of NLS+ data files.
-//
-//  Date:     August 31, 1999
-//
-////////////////////////////////////////////////////////////////////////////
-
-typedef  LPWORD        P844_TABLE;     // ptr to 8:4:4 table
-
-//
-//  Macros For High and Low Nibbles of a BYTE.
-//
-#define LO_NIBBLE(b)              ((BYTE)((BYTE)(b) & 0xF))
-#define HI_NIBBLE(b)              ((BYTE)(((BYTE)(b) >> 4) & 0xF))
-
-//
-//  Macros for Extracting the 8:4:4 Index Values.
-//
-#define GET8(w)                   (HIBYTE(w))
-#define GETHI4(w)                 (HI_NIBBLE(LOBYTE(w)))
-#define GETLO4(w)                 (LO_NIBBLE(LOBYTE(w)))
-
-////////////////////////////////////////////////////////////////////////////
-//
-//  Traverse844Byte
-//
-//  Traverses the 8:4:4 translation table for the given wide character.  It
-//  returns the final value of the 8:4:4 table, which is a BYTE in length.
-//
-//  NOTE: Offsets in table are in BYTES.
-//
-//    Broken Down Version:
-//    --------------------
-//        Incr = pTable[GET8(wch)] / sizeof(WORD);
-//        Incr = pTable[Incr + GETHI4(wch)];
-//        Value = (BYTE *)pTable[Incr + GETLO4(wch)];
-//
-//   
-////////////////////////////////////////////////////////////////////////////
-
-inline BYTE& Traverse844Byte(const WORD * pTable, WCHAR wch)
-{
-    return (
-             ((BYTE *)pTable)[
-                pTable[
-                   (pTable[GET8(wch)] / sizeof(WORD)) + GETHI4(wch)
-                ] + GETLO4(wch)
-             ]
-           );
-}
-
-////////////////////////////////////////////////////////////////////////////
-//
-//  Traverse844Word
-//
-//  Traverses the 8:4:4 translation table for the given wide character.  It
-//  returns the final value of the 8:4:4 table, which is a WORD in length.
-//
-//    Broken Down Version:
-//    --------------------
-//        Incr = pTable[GET8(wch)];
-//        Incr = pTable[Incr + GETHI4(wch)];
-//        Value = pTable[Incr + GETLO4(wch)];
-//
-//   
-////////////////////////////////////////////////////////////////////////////
-
-inline WORD Traverse844Word(const WORD * pTable, WCHAR wch)
-{
-    return (pTable[pTable[pTable[GET8(wch)] + GETHI4(wch)] + GETLO4(wch)]);
-}
-
-////////////////////////////////////////////////////////////////////////////
-//
-//  GET_INCR_VALUE
-//
-//  Gets the value of a given wide character from the given 8:4:4 table.  It
-//  then uses the value as an increment by adding it to the given wide
-//  character code point.
-//
-//  NOTE:  Whenever there is no translation for the given code point, the
-//         tables will return an increment value of 0.  This way, the
-//         wide character passed in is the same value that is returned.
-//
-//  DEFINED AS A MACRO.
-//
-//   
-////////////////////////////////////////////////////////////////////////////
-
-inline WCHAR GetIncrValue(const WORD * p844Tbl, WCHAR wch)
-{
-     return ((WCHAR)(wch + Traverse844Word(p844Tbl, wch)));
-}
-
-class NLSTable
-{
-    public:
-        static HANDLE CreateSharedMemoryMapping(const LPCWSTR pMappingName, const int iSize );
-        static PBYTE OpenOrCreateMemoryMapping(const LPCWSTR pMappingName, const int iSize , HANDLE *mappedFile);
-};
-
-#endif  // _NLSTABLE_H
diff --git a/src/classlibnative/nls/CMakeLists.txt b/src/classlibnative/nls/CMakeLists.txt
index d109ec2eb0..546566e17e 100644
--- a/src/classlibnative/nls/CMakeLists.txt
+++ b/src/classlibnative/nls/CMakeLists.txt
@@ -2,7 +2,6 @@ set( COMMLS_WKS_SOURCES
   calendardata.cpp
   encodingdata.cpp
   nlsinfo.cpp
-  nlstable.cpp
 )
 
 add_library_clr(comnls_wks ${COMMLS_WKS_SOURCES})
diff --git a/src/classlibnative/nls/encodingdata.cpp b/src/classlibnative/nls/encodingdata.cpp
index bf5c73fd63..c6021256be 100644
--- a/src/classlibnative/nls/encodingdata.cpp
+++ b/src/classlibnative/nls/encodingdata.cpp
@@ -17,7 +17,6 @@
 //
 // Please KEEP this table SORTED ALPHABETICALLY! We do a binary search on this array.
 const EncodingDataItem COMNlsInfo::EncodingDataTable[] = {
-#ifdef FEATURE_CORECLR
     // encoding name, codepage.
     {"ANSI_X3.4-1968", 20127 },
     {"ANSI_X3.4-1986", 20127 },
@@ -63,429 +62,6 @@ const EncodingDataItem COMNlsInfo::EncodingDataTable[] = {
     {"x-unicode-1-1-utf-8", 65001 },
     {"x-unicode-2-0-utf-7", 65000 },
     {"x-unicode-2-0-utf-8", 65001 },
-#else
- // Total Items: 455
-// encoding name, codepage.
-{"437", 437}, 
-{"ANSI_X3.4-1968", 20127}, 
-{"ANSI_X3.4-1986", 20127}, 
-// {L"_autodetect", 50932}, 
-// {L"_autodetect_all", 50001}, 
-// {L"_autodetect_kr", 50949}, 
-{"arabic", 28596}, 
-{"ascii", 20127}, 
-{"ASMO-708", 708}, 
-{"Big5", 950}, 
-{"Big5-HKSCS", 950}, 
-{"CCSID00858", 858}, 
-{"CCSID00924", 20924}, 
-{"CCSID01140", 1140}, 
-{"CCSID01141", 1141}, 
-{"CCSID01142", 1142}, 
-{"CCSID01143", 1143}, 
-{"CCSID01144", 1144}, 
-{"CCSID01145", 1145}, 
-{"CCSID01146", 1146}, 
-{"CCSID01147", 1147}, 
-{"CCSID01148", 1148}, 
-{"CCSID01149", 1149}, 
-{"chinese", 936}, 
-{"cn-big5", 950}, 
-{"CN-GB", 936}, 
-{"CP00858", 858}, 
-{"CP00924", 20924}, 
-{"CP01140", 1140}, 
-{"CP01141", 1141}, 
-{"CP01142", 1142}, 
-{"CP01143", 1143}, 
-{"CP01144", 1144}, 
-{"CP01145", 1145}, 
-{"CP01146", 1146}, 
-{"CP01147", 1147}, 
-{"CP01148", 1148}, 
-{"CP01149", 1149}, 
-{"cp037", 37}, 
-{"cp1025", 21025}, 
-{"CP1026", 1026}, 
-{"cp1256", 1256}, 
-{"CP273", 20273}, 
-{"CP278", 20278}, 
-{"CP280", 20280}, 
-{"CP284", 20284}, 
-{"CP285", 20285}, 
-{"cp290", 20290}, 
-{"cp297", 20297}, 
-{"cp367", 20127}, 
-{"cp420", 20420}, 
-{"cp423", 20423}, 
-{"cp424", 20424}, 
-{"cp437", 437}, 
-{"CP500", 500}, 
-{"cp50227", 50227}, 
-    //{L"cp50229", 50229}, 
-{"cp819", 28591}, 
-{"cp850", 850}, 
-{"cp852", 852}, 
-{"cp855", 855}, 
-{"cp857", 857}, 
-{"cp858", 858}, 
-{"cp860", 860}, 
-{"cp861", 861}, 
-{"cp862", 862}, 
-{"cp863", 863}, 
-{"cp864", 864}, 
-{"cp865", 865}, 
-{"cp866", 866}, 
-{"cp869", 869}, 
-{"CP870", 870}, 
-{"CP871", 20871}, 
-{"cp875", 875}, 
-{"cp880", 20880}, 
-{"CP905", 20905}, 
-//{L"cp930", 50930}, 
-//{L"cp933", 50933}, 
-//{L"cp935", 50935}, 
-//{L"cp937", 50937}, 
-//{L"cp939", 50939}, 
-{"csASCII", 20127}, 
-{"csbig5", 950}, 
-{"csEUCKR", 51949}, 
-{"csEUCPkdFmtJapanese", 51932}, 
-{"csGB2312", 936}, 
-{"csGB231280", 936}, 
-{"csIBM037", 37}, 
-{"csIBM1026", 1026}, 
-{"csIBM273", 20273}, 
-{"csIBM277", 20277}, 
-{"csIBM278", 20278}, 
-{"csIBM280", 20280}, 
-{"csIBM284", 20284}, 
-{"csIBM285", 20285}, 
-{"csIBM290", 20290}, 
-{"csIBM297", 20297}, 
-{"csIBM420", 20420}, 
-{"csIBM423", 20423}, 
-{"csIBM424", 20424}, 
-{"csIBM500", 500}, 
-{"csIBM870", 870}, 
-{"csIBM871", 20871}, 
-{"csIBM880", 20880}, 
-{"csIBM905", 20905}, 
-{"csIBMThai", 20838}, 
-{"csISO2022JP", 50221}, 
-{"csISO2022KR", 50225}, 
-{"csISO58GB231280", 936}, 
-{"csISOLatin1", 28591}, 
-{"csISOLatin2", 28592}, 
-{"csISOLatin3", 28593}, 
-{"csISOLatin4", 28594}, 
-{"csISOLatin5", 28599}, 
-{"csISOLatin9", 28605}, 
-{"csISOLatinArabic", 28596}, 
-{"csISOLatinCyrillic", 28595}, 
-{"csISOLatinGreek", 28597}, 
-{"csISOLatinHebrew", 28598}, 
-{"csKOI8R", 20866}, 
-{"csKSC56011987", 949}, 
-{"csPC8CodePage437", 437}, 
-{"csShiftJIS", 932}, 
-{"csUnicode11UTF7", 65000}, 
-{"csWindows31J", 932}, 
-{"cyrillic", 28595}, 
-{"DIN_66003", 20106}, 
-{"DOS-720", 720}, 
-{"DOS-862", 862}, 
-{"DOS-874", 874}, 
-{"ebcdic-cp-ar1", 20420}, 
-{"ebcdic-cp-be", 500}, 
-{"ebcdic-cp-ca", 37}, 
-{"ebcdic-cp-ch", 500}, 
-{"EBCDIC-CP-DK", 20277}, 
-{"ebcdic-cp-es", 20284}, 
-{"ebcdic-cp-fi", 20278}, 
-{"ebcdic-cp-fr", 20297}, 
-{"ebcdic-cp-gb", 20285}, 
-{"ebcdic-cp-gr", 20423}, 
-{"ebcdic-cp-he", 20424}, 
-{"ebcdic-cp-is", 20871}, 
-{"ebcdic-cp-it", 20280}, 
-{"ebcdic-cp-nl", 37}, 
-{"EBCDIC-CP-NO", 20277}, 
-{"ebcdic-cp-roece", 870}, 
-{"ebcdic-cp-se", 20278}, 
-{"ebcdic-cp-tr", 20905}, 
-{"ebcdic-cp-us", 37}, 
-{"ebcdic-cp-wt", 37}, 
-{"ebcdic-cp-yu", 870}, 
-{"EBCDIC-Cyrillic", 20880}, 
-{"ebcdic-de-273+euro", 1141}, 
-{"ebcdic-dk-277+euro", 1142}, 
-{"ebcdic-es-284+euro", 1145}, 
-{"ebcdic-fi-278+euro", 1143}, 
-{"ebcdic-fr-297+euro", 1147}, 
-{"ebcdic-gb-285+euro", 1146}, 
-{"ebcdic-international-500+euro", 1148}, 
-{"ebcdic-is-871+euro", 1149}, 
-{"ebcdic-it-280+euro", 1144}, 
-{"EBCDIC-JP-kana", 20290}, 
-{"ebcdic-Latin9--euro", 20924}, 
-{"ebcdic-no-277+euro", 1142}, 
-{"ebcdic-se-278+euro", 1143}, 
-{"ebcdic-us-37+euro", 1140}, 
-{"ECMA-114", 28596}, 
-{"ECMA-118", 28597}, 
-{"ELOT_928", 28597}, 
-{"euc-cn", 51936}, 
-{"euc-jp", 51932}, 
-{"euc-kr", 51949}, 
-{"Extended_UNIX_Code_Packed_Format_for_Japanese", 51932}, 
-{"GB18030", 54936}, 
-{"GB2312", 936}, 
-{"GB2312-80", 936}, 
-{"GB231280", 936}, 
-{"GBK", 936}, 
-{"GB_2312-80", 936}, 
-{"German", 20106}, 
-{"greek", 28597}, 
-{"greek8", 28597}, 
-{"hebrew", 28598}, 
-{"hz-gb-2312", 52936}, 
-{"IBM-Thai", 20838}, 
-{"IBM00858", 858}, 
-{"IBM00924", 20924}, 
-{"IBM01047", 1047}, 
-{"IBM01140", 1140}, 
-{"IBM01141", 1141}, 
-{"IBM01142", 1142}, 
-{"IBM01143", 1143}, 
-{"IBM01144", 1144}, 
-{"IBM01145", 1145}, 
-{"IBM01146", 1146}, 
-{"IBM01147", 1147}, 
-{"IBM01148", 1148}, 
-{"IBM01149", 1149}, 
-{"IBM037", 37}, 
-{"IBM1026", 1026}, 
-{"IBM273", 20273}, 
-{"IBM277", 20277}, 
-{"IBM278", 20278}, 
-{"IBM280", 20280}, 
-{"IBM284", 20284}, 
-{"IBM285", 20285}, 
-{"IBM290", 20290}, 
-{"IBM297", 20297}, 
-{"IBM367", 20127}, 
-{"IBM420", 20420}, 
-{"IBM423", 20423}, 
-{"IBM424", 20424}, 
-{"IBM437", 437}, 
-{"IBM500", 500}, 
-{"ibm737", 737}, 
-{"ibm775", 775}, 
-{"ibm819", 28591}, 
-{"IBM850", 850}, 
-{"IBM852", 852}, 
-{"IBM855", 855}, 
-{"IBM857", 857}, 
-{"IBM860", 860}, 
-{"IBM861", 861}, 
-{"IBM862", 862}, 
-{"IBM863", 863}, 
-{"IBM864", 864}, 
-{"IBM865", 865}, 
-{"IBM866", 866}, 
-{"IBM869", 869}, 
-{"IBM870", 870}, 
-{"IBM871", 20871}, 
-{"IBM880", 20880}, 
-{"IBM905", 20905}, 
-{"irv", 20105}, 
-{"ISO-10646-UCS-2", 1200}, 
-{"iso-2022-jp", 50220}, 
-{"iso-2022-jpeuc", 51932}, 
-{"iso-2022-kr", 50225}, 
-{"iso-2022-kr-7", 50225}, 
-{"iso-2022-kr-7bit", 50225}, 
-{"iso-2022-kr-8", 51949}, 
-{"iso-2022-kr-8bit", 51949}, 
-{"iso-8859-1", 28591}, 
-{"iso-8859-11", 874}, 
-{"iso-8859-13", 28603}, 
-{"iso-8859-15", 28605}, 
-{"iso-8859-2", 28592}, 
-{"iso-8859-3", 28593}, 
-{"iso-8859-4", 28594}, 
-{"iso-8859-5", 28595}, 
-{"iso-8859-6", 28596}, 
-{"iso-8859-7", 28597}, 
-{"iso-8859-8", 28598}, 
-{"ISO-8859-8 Visual", 28598}, 
-{"iso-8859-8-i", 38598}, 
-{"iso-8859-9", 28599}, 
-{"iso-ir-100", 28591}, 
-{"iso-ir-101", 28592}, 
-{"iso-ir-109", 28593}, 
-{"iso-ir-110", 28594}, 
-{"iso-ir-126", 28597}, 
-{"iso-ir-127", 28596}, 
-{"iso-ir-138", 28598}, 
-{"iso-ir-144", 28595}, 
-{"iso-ir-148", 28599}, 
-{"iso-ir-149", 949}, 
-{"iso-ir-58", 936}, 
-{"iso-ir-6", 20127}, 
-{"ISO646-US", 20127}, 
-{"iso8859-1", 28591}, 
-{"iso8859-2", 28592}, 
-{"ISO_646.irv:1991", 20127}, 
-{"iso_8859-1", 28591}, 
-{"ISO_8859-15", 28605}, 
-{"iso_8859-1:1987", 28591}, 
-{"iso_8859-2", 28592}, 
-{"iso_8859-2:1987", 28592}, 
-{"ISO_8859-3", 28593}, 
-{"ISO_8859-3:1988", 28593}, 
-{"ISO_8859-4", 28594}, 
-{"ISO_8859-4:1988", 28594}, 
-{"ISO_8859-5", 28595}, 
-{"ISO_8859-5:1988", 28595}, 
-{"ISO_8859-6", 28596}, 
-{"ISO_8859-6:1987", 28596}, 
-{"ISO_8859-7", 28597}, 
-{"ISO_8859-7:1987", 28597}, 
-{"ISO_8859-8", 28598}, 
-{"ISO_8859-8:1988", 28598}, 
-{"ISO_8859-9", 28599}, 
-{"ISO_8859-9:1989", 28599}, 
-{"Johab", 1361}, 
-{"koi", 20866}, 
-{"koi8", 20866}, 
-{"koi8-r", 20866}, 
-{"koi8-ru", 21866}, 
-{"koi8-u", 21866}, 
-{"koi8r", 20866}, 
-{"korean", 949}, 
-{"ks-c-5601", 949}, 
-{"ks-c5601", 949}, 
-{"KSC5601", 949}, 
-{"KSC_5601", 949}, 
-{"ks_c_5601", 949}, 
-{"ks_c_5601-1987", 949}, 
-{"ks_c_5601-1989", 949}, 
-{"ks_c_5601_1987", 949}, 
-{"l1", 28591}, 
-{"l2", 28592}, 
-{"l3", 28593}, 
-{"l4", 28594}, 
-{"l5", 28599}, 
-{"l9", 28605}, 
-{"latin1", 28591}, 
-{"latin2", 28592}, 
-{"latin3", 28593}, 
-{"latin4", 28594}, 
-{"latin5", 28599}, 
-{"latin9", 28605}, 
-{"logical", 28598}, 
-{"macintosh", 10000}, 
-{"ms_Kanji", 932}, 
-{"Norwegian", 20108}, 
-{"NS_4551-1", 20108}, 
-{"PC-Multilingual-850+euro", 858}, 
-{"SEN_850200_B", 20107}, 
-{"shift-jis", 932}, 
-{"shift_jis", 932}, 
-{"sjis", 932}, 
-{"Swedish", 20107}, 
-{"TIS-620", 874}, 
-{"ucs-2", 1200}, 
-{"unicode", 1200}, 
-{"unicode-1-1-utf-7", 65000}, 
-{"unicode-1-1-utf-8", 65001}, 
-{"unicode-2-0-utf-7", 65000}, 
-{"unicode-2-0-utf-8", 65001}, 
-// People get confused about the FFFE here.  We can't change this because it'd break existing apps.
-// This has been this way for a long time, including in Mlang.
-{"unicodeFFFE", 1201},             // Big Endian, BOM seems backwards, think of the BOM in little endian order.
-{"us", 20127}, 
-{"us-ascii", 20127}, 
-{"utf-16", 1200}, 
-{"UTF-16BE", 1201}, 
-{"UTF-16LE", 1200},
-{"utf-32", 12000},
-{"UTF-32BE", 12001},
-{"UTF-32LE", 12000},
-{"utf-7", 65000}, 
-{"utf-8", 65001},
-{"visual", 28598}, 
-{"windows-1250", 1250}, 
-{"windows-1251", 1251}, 
-{"windows-1252", 1252}, 
-{"windows-1253", 1253}, 
-{"Windows-1254", 1254}, 
-{"windows-1255", 1255}, 
-{"windows-1256", 1256}, 
-{"windows-1257", 1257}, 
-{"windows-1258", 1258}, 
-{"windows-874", 874}, 
-{"x-ansi", 1252}, 
-{"x-Chinese-CNS", 20000}, 
-{"x-Chinese-Eten", 20002}, 
-{"x-cp1250", 1250}, 
-{"x-cp1251", 1251}, 
-{"x-cp20001", 20001}, 
-{"x-cp20003", 20003}, 
-{"x-cp20004", 20004}, 
-{"x-cp20005", 20005}, 
-{"x-cp20261", 20261}, 
-{"x-cp20269", 20269}, 
-{"x-cp20936", 20936}, 
-{"x-cp20949", 20949},
-{"x-cp50227", 50227}, 
-//{L"x-cp50229", 50229}, 
-//{L"X-EBCDIC-JapaneseAndUSCanada", 50931}, 
-{"X-EBCDIC-KoreanExtended", 20833}, 
-{"x-euc", 51932}, 
-{"x-euc-cn", 51936}, 
-{"x-euc-jp", 51932}, 
-{"x-Europa", 29001}, 
-{"x-IA5", 20105}, 
-{"x-IA5-German", 20106}, 
-{"x-IA5-Norwegian", 20108}, 
-{"x-IA5-Swedish", 20107}, 
-{"x-iscii-as", 57006}, 
-{"x-iscii-be", 57003}, 
-{"x-iscii-de", 57002}, 
-{"x-iscii-gu", 57010}, 
-{"x-iscii-ka", 57008}, 
-{"x-iscii-ma", 57009}, 
-{"x-iscii-or", 57007}, 
-{"x-iscii-pa", 57011}, 
-{"x-iscii-ta", 57004}, 
-{"x-iscii-te", 57005}, 
-{"x-mac-arabic", 10004}, 
-{"x-mac-ce", 10029}, 
-{"x-mac-chinesesimp", 10008}, 
-{"x-mac-chinesetrad", 10002}, 
-{"x-mac-croatian", 10082}, 
-{"x-mac-cyrillic", 10007}, 
-{"x-mac-greek", 10006}, 
-{"x-mac-hebrew", 10005}, 
-{"x-mac-icelandic", 10079}, 
-{"x-mac-japanese", 10001}, 
-{"x-mac-korean", 10003}, 
-{"x-mac-romanian", 10010}, 
-{"x-mac-thai", 10021}, 
-{"x-mac-turkish", 10081}, 
-{"x-mac-ukrainian", 10017}, 
-{"x-ms-cp932", 932},
-{"x-sjis", 932}, 
-{"x-unicode-1-1-utf-7", 65000}, 
-{"x-unicode-1-1-utf-8", 65001}, 
-{"x-unicode-2-0-utf-7", 65000}, 
-{"x-unicode-2-0-utf-8", 65001}, 
-{"x-x-big5", 950}, 
-
-#endif // FEATURE_CORECLR
     
 };
 
@@ -503,7 +79,6 @@ const int COMNlsInfo::m_nEncodingDataTableItems =
 //
 const CodePageDataItem COMNlsInfo::CodePageDataTable[] = {
 
-#ifdef FEATURE_CORECLR
 
 // Total Items: 
 // code page, family code page, web name, header name, body name, flags
@@ -517,160 +92,6 @@ const CodePageDataItem COMNlsInfo::CodePageDataTable[] = {
     MapCodePageDataItem(  65000, 1200, "utf-7", MIMECONTF_MAILNEWS | MIMECONTF_SAVABLE_MAILNEWS), // "Unicode (UTF-7)"
     MapCodePageDataItem(  65001, 1200, "utf-8", MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Unicode (UTF-8)"
 
-#else //FEATURE_CORECLR
-
-// Total Items: 146
-// code page, family code page, web name, header name, body name, flags
-
-
-    MapCodePageDataItem(    37,  1252, "IBM037",      0), // "IBM EBCDIC (US-Canada)"
-    MapCodePageDataItem(   437,  1252, "IBM437",      0), // "OEM United States"
-    MapCodePageDataItem(   500,  1252, "IBM500",      0), // "IBM EBCDIC (International)"
-    MapCodePageDataItem(   708,  1256, "ASMO-708",    MIMECONTF_BROWSER | MIMECONTF_SAVABLE_BROWSER), // "Arabic (ASMO 708)"
-    MapCodePageDataItem(   720,  1256, "DOS-720",     MIMECONTF_BROWSER | MIMECONTF_SAVABLE_BROWSER), // "Arabic (DOS)"
-    MapCodePageDataItem(   737,  1253, "ibm737",      0), // "Greek (DOS)"
-    MapCodePageDataItem(   775,  1257, "ibm775",      0), // "Baltic (DOS)"
-    MapCodePageDataItem(   850,  1252, "ibm850",      0), // "Western European (DOS)"
-    MapCodePageDataItem(   852,  1250, "ibm852",      MIMECONTF_BROWSER | MIMECONTF_SAVABLE_BROWSER), // "Central European (DOS)"
-    MapCodePageDataItem(   855,  1252, "IBM855",      0), // "OEM Cyrillic"
-    MapCodePageDataItem(   857,  1254, "ibm857",      0), // "Turkish (DOS)"
-    MapCodePageDataItem(   858,  1252, "IBM00858",    0), // "OEM Multilingual Latin I"
-    MapCodePageDataItem(   860,  1252, "IBM860",      0), // "Portuguese (DOS)"
-    MapCodePageDataItem(   861,  1252, "ibm861",      0), // "Icelandic (DOS)"
-    MapCodePageDataItem(   862,  1255, "DOS-862",     MIMECONTF_BROWSER | MIMECONTF_SAVABLE_BROWSER), // "Hebrew (DOS)"
-    MapCodePageDataItem(   863,  1252, "IBM863",      0), // "French Canadian (DOS)"
-    MapCodePageDataItem(   864,  1256, "IBM864",      0), // "Arabic (864)"
-    MapCodePageDataItem(   865,  1252, "IBM865",      0), // "Nordic (DOS)"
-    MapCodePageDataItem(   866,  1251, "cp866",       MIMECONTF_BROWSER | MIMECONTF_SAVABLE_BROWSER), // "Cyrillic (DOS)"
-    MapCodePageDataItem(   869,  1253, "ibm869",      0), // "Greek, Modern (DOS)"
-    MapCodePageDataItem(   870,  1250, "IBM870",      0), // "IBM EBCDIC (Multilingual Latin-2)"
-    MapCodePageDataItem(   874,   874, "windows-874", MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Thai (Windows)"
-    MapCodePageDataItem(   875,  1253, "cp875",       0), // "IBM EBCDIC (Greek Modern)"
-    MapCodePageDataItem(   932,   932, "|shift_jis|iso-2022-jp|iso-2022-jp",   MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Japanese (Shift-JIS)"
-    MapCodePageDataItem(   936,   936, "gb2312",      MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Chinese Simplified (GB2312)"
-    MapCodePageDataItem(   949,   949, "ks_c_5601-1987", MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Korean"
-    MapCodePageDataItem(   950,   950, "big5",        MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Chinese Traditional (Big5)"
-    MapCodePageDataItem(  1026,  1254, "IBM1026",     0), // "IBM EBCDIC (Turkish Latin-5)"
-    MapCodePageDataItem(  1047,  1252, "IBM01047",    0), // "IBM Latin-1"
-    MapCodePageDataItem(  1140,  1252, "IBM01140",    0), // "IBM EBCDIC (US-Canada-Euro)"
-    MapCodePageDataItem(  1141,  1252, "IBM01141",    0), // "IBM EBCDIC (Germany-Euro)"
-    MapCodePageDataItem(  1142,  1252, "IBM01142",    0), // "IBM EBCDIC (Denmark-Norway-Euro)"
-    MapCodePageDataItem(  1143,  1252, "IBM01143",    0), // "IBM EBCDIC (Finland-Sweden-Euro)"
-    MapCodePageDataItem(  1144,  1252, "IBM01144",    0), // "IBM EBCDIC (Italy-Euro)"
-    MapCodePageDataItem(  1145,  1252, "IBM01145",    0), // "IBM EBCDIC (Spain-Euro)"
-    MapCodePageDataItem(  1146,  1252, "IBM01146",    0), // "IBM EBCDIC (UK-Euro)"
-    MapCodePageDataItem(  1147,  1252, "IBM01147",    0), // "IBM EBCDIC (France-Euro)"
-    MapCodePageDataItem(  1148,  1252, "IBM01148",    0), // "IBM EBCDIC (International-Euro)"
-    MapCodePageDataItem(  1149,  1252, "IBM01149",    0), // "IBM EBCDIC (Icelandic-Euro)"
-    MapCodePageDataItem(  1200,  1200, "utf-16",      MIMECONTF_SAVABLE_BROWSER), // "Unicode"
-    MapCodePageDataItem(  1201,  1200, "utf-16BE",    0), // Big Endian, old FFFE BOM seems backwards, think of the BOM in little endian order.
-    MapCodePageDataItem(  1250,  1250, "|windows-1250|windows-1250|iso-8859-2", MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Central European (Windows)"
-    MapCodePageDataItem(  1251,  1251, "|windows-1251|windows-1251|koi8-r", MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Cyrillic (Windows)"
-    MapCodePageDataItem(  1252,  1252, "|Windows-1252|Windows-1252|iso-8859-1", MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Western European (Windows)"
-    MapCodePageDataItem(  1253,  1253, "|windows-1253|windows-1253|iso-8859-7", MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Greek (Windows)"
-    MapCodePageDataItem(  1254,  1254, "|windows-1254|windows-1254|iso-8859-9", MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Turkish (Windows)"
-    MapCodePageDataItem(  1255,  1255, "windows-1255", MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Hebrew (Windows)"
-    MapCodePageDataItem(  1256,  1256, "windows-1256", MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Arabic (Windows)"
-    MapCodePageDataItem(  1257,  1257, "windows-1257", MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Baltic (Windows)"
-    MapCodePageDataItem(  1258,  1258, "windows-1258", MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Vietnamese (Windows)"
-    MapCodePageDataItem(  1361,   949, "Johab",        0), // "Korean (Johab)"
-    MapCodePageDataItem( 10000,  1252, "macintosh",    0), // "Western European (Mac)"
-    MapCodePageDataItem( 10001,   932, "x-mac-japanese", 0), // "Japanese (Mac)"
-    MapCodePageDataItem( 10002,   950, "x-mac-chinesetrad",   0), // "Chinese Traditional (Mac)"
-    MapCodePageDataItem( 10003,   949, "x-mac-korean",        0), // "Korean (Mac)"
-    MapCodePageDataItem( 10004,  1256, "x-mac-arabic",        0), // "Arabic (Mac)"
-    MapCodePageDataItem( 10005,  1255, "x-mac-hebrew",        0), // "Hebrew (Mac)"
-    MapCodePageDataItem( 10006,  1253, "x-mac-greek",         0), // "Greek (Mac)"
-    MapCodePageDataItem( 10007,  1251, "x-mac-cyrillic",      0), // "Cyrillic (Mac)"
-    MapCodePageDataItem( 10008,   936, "x-mac-chinesesimp",   0), // "Chinese Simplified (Mac)"
-    MapCodePageDataItem( 10010,  1250, "x-mac-romanian",      0), // "Romanian (Mac)"
-    MapCodePageDataItem( 10017,  1251, "x-mac-ukrainian",     0), // "Ukrainian (Mac)"
-    MapCodePageDataItem( 10021,   874, "x-mac-thai",          0), // "Thai (Mac)"
-    MapCodePageDataItem( 10029,  1250, "x-mac-ce",            0), // "Central European (Mac)"
-    MapCodePageDataItem( 10079,  1252, "x-mac-icelandic",     0), // "Icelandic (Mac)"
-    MapCodePageDataItem( 10081,  1254, "x-mac-turkish",       0), // "Turkish (Mac)"
-    MapCodePageDataItem( 10082,  1250, "x-mac-croatian",      0), // "Croatian (Mac)"
-    MapCodePageDataItem( 12000,  1200, "utf-32",              0), // "Unicode (UTF-32)"
-    MapCodePageDataItem( 12001,  1200, "utf-32BE",            0), // "Unicode (UTF-32 Big Endian)"
-    MapCodePageDataItem( 20000,   950, "x-Chinese-CNS",       0), // "Chinese Traditional (CNS)"
-    MapCodePageDataItem( 20001,   950, "x-cp20001",           0), // "TCA Taiwan"
-    MapCodePageDataItem( 20002,   950, "x-Chinese-Eten",      0), // "Chinese Traditional (Eten)"
-    MapCodePageDataItem( 20003,   950, "x-cp20003",           0), // "IBM5550 Taiwan"
-    MapCodePageDataItem( 20004,   950, "x-cp20004",           0), // "TeleText Taiwan"
-    MapCodePageDataItem( 20005,   950, "x-cp20005",           0), // "Wang Taiwan"
-    MapCodePageDataItem( 20105,  1252, "x-IA5",               0), // "Western European (IA5)"
-    MapCodePageDataItem( 20106,  1252, "x-IA5-German",        0), // "German (IA5)"
-    MapCodePageDataItem( 20107,  1252, "x-IA5-Swedish",       0), // "Swedish (IA5)"
-    MapCodePageDataItem( 20108,  1252, "x-IA5-Norwegian",     0), // "Norwegian (IA5)"
-    MapCodePageDataItem( 20127,  1252, "us-ascii",            MIMECONTF_MAILNEWS | MIMECONTF_SAVABLE_MAILNEWS), // "US-ASCII"
-    MapCodePageDataItem( 20261,  1252, "x-cp20261",           0), // "T.61"
-    MapCodePageDataItem( 20269,  1252, "x-cp20269",           0), // "ISO-6937"
-    MapCodePageDataItem( 20273,  1252, "IBM273",              0), // "IBM EBCDIC (Germany)"
-    MapCodePageDataItem( 20277,  1252, "IBM277",              0), // "IBM EBCDIC (Denmark-Norway)"
-    MapCodePageDataItem( 20278,  1252, "IBM278",              0), // "IBM EBCDIC (Finland-Sweden)"
-    MapCodePageDataItem( 20280,  1252, "IBM280",              0), // "IBM EBCDIC (Italy)"
-    MapCodePageDataItem( 20284,  1252, "IBM284",              0), // "IBM EBCDIC (Spain)"
-    MapCodePageDataItem( 20285,  1252, "IBM285",              0), // "IBM EBCDIC (UK)"
-    MapCodePageDataItem( 20290,   932, "IBM290",              0), // "IBM EBCDIC (Japanese katakana)"
-    MapCodePageDataItem( 20297,  1252, "IBM297",              0), // "IBM EBCDIC (France)"
-    MapCodePageDataItem( 20420,  1256, "IBM420",              0), // "IBM EBCDIC (Arabic)"
-    MapCodePageDataItem( 20423,  1253, "IBM423",              0), // "IBM EBCDIC (Greek)"
-    MapCodePageDataItem( 20424,  1255, "IBM424",              0), // "IBM EBCDIC (Hebrew)"
-    MapCodePageDataItem( 20833,   949, "x-EBCDIC-KoreanExtended", 0), // "IBM EBCDIC (Korean Extended)"
-    MapCodePageDataItem( 20838,   874, "IBM-Thai",            0), // "IBM EBCDIC (Thai)"
-    MapCodePageDataItem( 20866,  1251, "koi8-r",              MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Cyrillic (KOI8-R)"
-    MapCodePageDataItem( 20871,  1252, "IBM871",              0), // "IBM EBCDIC (Icelandic)"
-    MapCodePageDataItem( 20880,  1251, "IBM880",              0), // "IBM EBCDIC (Cyrillic Russian)"
-    MapCodePageDataItem( 20905,  1254, "IBM905",              0), // "IBM EBCDIC (Turkish)"
-    MapCodePageDataItem( 20924,  1252, "IBM00924",            0), // "IBM Latin-1"
-    MapCodePageDataItem( 20932,   932, "EUC-JP",              0), // "Japanese (JIS 0208-1990 and 0212-1990)"
-    MapCodePageDataItem( 20936,   936, "x-cp20936",           0), // "Chinese Simplified (GB2312-80)"
-    MapCodePageDataItem( 20949,   949, "x-cp20949",           0), // "Korean Wansung"
-    MapCodePageDataItem( 21025,  1251, "cp1025",              0), // "IBM EBCDIC (Cyrillic Serbian-Bulgarian)"
-    MapCodePageDataItem( 21866,  1251, "koi8-u",              MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Cyrillic (KOI8-U)"
-    MapCodePageDataItem( 28591,  1252, "iso-8859-1",          MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Western European (ISO)"
-    MapCodePageDataItem( 28592,  1250, "iso-8859-2",          MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Central European (ISO)"
-    MapCodePageDataItem( 28593,  1254, "iso-8859-3",          MIMECONTF_MAILNEWS | MIMECONTF_SAVABLE_MAILNEWS), // "Latin 3 (ISO)"
-    MapCodePageDataItem( 28594,  1257, "iso-8859-4",          MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Baltic (ISO)"
-    MapCodePageDataItem( 28595,  1251, "iso-8859-5",          MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Cyrillic (ISO)"
-    MapCodePageDataItem( 28596,  1256, "iso-8859-6",          MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Arabic (ISO)"
-    MapCodePageDataItem( 28597,  1253, "iso-8859-7",          MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Greek (ISO)"
-    MapCodePageDataItem( 28598,  1255, "iso-8859-8",          MIMECONTF_BROWSER | MIMECONTF_SAVABLE_BROWSER), // "Hebrew (ISO-Visual)"
-    MapCodePageDataItem( 28599,  1254, "iso-8859-9",          MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Turkish (ISO)"
-    MapCodePageDataItem( 28603,  1257, "iso-8859-13",         MIMECONTF_MAILNEWS | MIMECONTF_SAVABLE_MAILNEWS), // "Estonian (ISO)"
-    MapCodePageDataItem( 28605,  1252, "iso-8859-15",         MIMECONTF_MAILNEWS | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Latin 9 (ISO)"
-    MapCodePageDataItem( 29001,  1252, "x-Europa",            0), // "Europa"
-    MapCodePageDataItem( 38598,  1255, "iso-8859-8-i",        MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Hebrew (ISO-Logical)"
-    MapCodePageDataItem( 50220,   932, "iso-2022-jp",         MIMECONTF_MAILNEWS | MIMECONTF_SAVABLE_MAILNEWS), // "Japanese (JIS)"
-    MapCodePageDataItem( 50221,   932, "|csISO2022JP|iso-2022-jp|iso-2022-jp", MIMECONTF_MAILNEWS | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Japanese (JIS-Allow 1 byte Kana)"
-    MapCodePageDataItem( 50222,   932, "iso-2022-jp",         0), // "Japanese (JIS-Allow 1 byte Kana - SO/SI)"
-    MapCodePageDataItem( 50225,   949, "|iso-2022-kr|euc-kr|iso-2022-kr", MIMECONTF_MAILNEWS), // "Korean (ISO)"
-    MapCodePageDataItem( 50227,   936, "x-cp50227",           0), // "Chinese Simplified (ISO-2022)"
-//MapCodePageDataItem( 50229,   950, L"x-cp50229", L"x-cp50229", L"x-cp50229", 0}, // "Chinese Traditional (ISO-2022)"
-//MapCodePageDataItem( 50930,   932, L"cp930", L"cp930", L"cp930", 0}, // "IBM EBCDIC (Japanese and Japanese Katakana)"
-//MapCodePageDataItem( 50931,   932, L"x-EBCDIC-JapaneseAndUSCanada", L"x-EBCDIC-JapaneseAndUSCanada", L"x-EBCDIC-JapaneseAndUSCanada", 0}, // "IBM EBCDIC (Japanese and US-Canada)"
-//MapCodePageDataItem( 50933,   949, L"cp933", L"cp933", L"cp933", 0}, // "IBM EBCDIC (Korean and Korean Extended)"
-//MapCodePageDataItem( 50935,   936, L"cp935", L"cp935", L"cp935", 0}, // "IBM EBCDIC (Simplified Chinese)"
-//MapCodePageDataItem( 50937,   950, L"cp937", L"cp937", L"cp937", 0}, // "IBM EBCDIC (Traditional Chinese)"
-//MapCodePageDataItem( 50939,   932, L"cp939", L"cp939", L"cp939", 0}, // "IBM EBCDIC (Japanese and Japanese-Latin)"
-    MapCodePageDataItem( 51932,   932, "euc-jp",              MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Japanese (EUC)"
-    MapCodePageDataItem( 51936,   936, "EUC-CN",              0), // "Chinese Simplified (EUC)"
-    MapCodePageDataItem( 51949,   949, "euc-kr",              MIMECONTF_MAILNEWS | MIMECONTF_SAVABLE_MAILNEWS), // "Korean (EUC)"
-    MapCodePageDataItem( 52936,   936, "hz-gb-2312",          MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Chinese Simplified (HZ)"
-    MapCodePageDataItem( 54936,   936, "GB18030",             MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Chinese Simplified (GB18030)"
-    MapCodePageDataItem( 57002, 57002, "x-iscii-de",          0), // "ISCII Devanagari"
-    MapCodePageDataItem( 57003, 57003, "x-iscii-be",          0), // "ISCII Bengali"
-    MapCodePageDataItem( 57004, 57004, "x-iscii-ta",          0), // "ISCII Tamil"
-    MapCodePageDataItem( 57005, 57005, "x-iscii-te",          0), // "ISCII Telugu"
-    MapCodePageDataItem( 57006, 57006, "x-iscii-as",          0), // "ISCII Assamese"
-    MapCodePageDataItem( 57007, 57007, "x-iscii-or",          0), // "ISCII Oriya"
-    MapCodePageDataItem( 57008, 57008, "x-iscii-ka",          0), // "ISCII Kannada"
-    MapCodePageDataItem( 57009, 57009, "x-iscii-ma",          0), // "ISCII Malayalam"
-    MapCodePageDataItem( 57010, 57010, "x-iscii-gu",          0), // "ISCII Gujarati"
-    MapCodePageDataItem( 57011, 57011, "x-iscii-pa",          0), // "ISCII Punjabi"
-    MapCodePageDataItem( 65000,  1200, "utf-7",               MIMECONTF_MAILNEWS | MIMECONTF_SAVABLE_MAILNEWS), // "Unicode (UTF-7)"
-    MapCodePageDataItem( 65001,  1200, "utf-8",               MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER), // "Unicode (UTF-8)"
-#endif // FEATURE_CORECLR
 
     // End of data.
     MapCodePageDataItem( 0, 0, NULL, 0),
diff --git a/src/classlibnative/nls/nlsinfo.cpp b/src/classlibnative/nls/nlsinfo.cpp
index 0e034c4a0c..507a18b221 100644
--- a/src/classlibnative/nls/nlsinfo.cpp
+++ b/src/classlibnative/nls/nlsinfo.cpp
@@ -33,7 +33,6 @@
 #include "metasig.h"
 #include "nls.h"
 #include "nlsinfo.h"
-#include "nlstable.h"
 
 //#include <mlang.h>
 #include "sortversioning.h"
@@ -138,72 +137,6 @@ PFN_NORMALIZATION_NORMALIZE_STRING COMNlsInfo::m_pfnNormalizationNormalizeString
 PFN_NORMALIZATION_INIT_NORMALIZATION COMNlsInfo::m_pfnNormalizationInitNormalizationFunc = NULL;
 #endif // FEATURE_COREFX_GLOBALIZATION
 
-#if FEATURE_CODEPAGES_FILE
-/*============================nativeCreateOpenFileMapping============================
-**Action: Create or open a named memory file mapping.
-**Returns: Pointer to named section, or NULL if failed
-**Arguments:
-**  StringObject*   inSectionName  - name of section to open/create
-**  int             inBytesToAllocate - desired size of memory section in bytes
-**                      We use the last 4 bytes (must be aligned, so only choose
-**                      inBytesToAllocate in multiples of 4) to indicate if the
-**                      section is set or not.  AFTER section is initialized, set
-**                      those 4 bytes to non-0, otherwise you'll get get new
-**                      heap memory all the time.
-**  HANDLE*         mappedFile - is the handle of the memory mapped file. this is
-**                      out parameter.
-**
-** NOTE: We'll try to open the same object, so we can share names.  We don't lock
-**       though, so 2 thread could get the same object, but thread 1 might not
-**       have initialized it yet.
-**
-** NOTE: For NT you should add a Global\ to the beginning of the name if you
-**       want to share it machine wide.
-**
-==============================================================================*/
-FCIMPL3(LPVOID, COMNlsInfo::nativeCreateOpenFileMapping,
-            StringObject* inSectionNameUNSAFE, int inBytesToAllocate, HANDLE *mappedFile)
-{
-    CONTRACTL
-    {
-        FCALL_CHECK;
-        PRECONDITION(CheckPointer(inSectionNameUNSAFE));
-        PRECONDITION(inBytesToAllocate % 4 == 0);
-        PRECONDITION(inBytesToAllocate > 0);
-        PRECONDITION(CheckPointer(mappedFile));
-    } CONTRACTL_END;
-
-    // Need a place for our result
-    LPVOID pResult = NULL;
-
-    STRINGREF inString(inSectionNameUNSAFE);
-    HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(inString);
-
-    _ASSERTE(inBytesToAllocate % 4 == 0);   // Expected 4 bytes boundaries so we don't get unaligned
-    _ASSERTE(inBytesToAllocate > 0);        // Pointless to have <=0 allocation
-
-    StackSString inNameStackBuffer (inString->GetBuffer());
-    pResult = NLSTable::OpenOrCreateMemoryMapping((LPCWSTR)inNameStackBuffer, inBytesToAllocate, mappedFile);
-
-    // Worst case allocate some memory, use holder
-    //    if (pResult == NULL) pResult = new BYTE[inBytesToAllocate];
-    if (pResult == NULL)
-    {
-        // Need to use a NewHolder
-        NewArrayHolder<BYTE> holder (new BYTE[inBytesToAllocate]);
-        pResult = holder;
-        // Zero out the mapCodePageCached field (an int value, and it's used to check if the section is initialized or not.)
-        BYTE* pByte = (BYTE*)pResult;
-        FillMemory(pByte + inBytesToAllocate - sizeof(int), sizeof(int), 0);
-        holder.SuppressRelease();
-    }
-
-    HELPER_METHOD_FRAME_END();
-
-    return pResult;
-}
-FCIMPLEND
-#endif // FEATURE_CODEPAGES_FILE
 
 // InternalIsSortable
 //
@@ -218,20 +151,6 @@ BOOL QCALLTYPE COMNlsInfo::InternalIsSortable(INT_PTR handle, INT_PTR handleOrig
     BOOL result = FALSE;
     BEGIN_QCALL;
 
-#ifndef FEATURE_CORECLR
-    AppDomain* curDomain = GetAppDomain();
-
-    if(!(curDomain->m_bUseOsSorting))
-    {
-        handle = EnsureValidSortHandle(handle, handleOrigin, localeName);
-        result = SortVersioning::SortDllIsDefinedString((SortVersioning::PSORTHANDLE) handle, COMPARE_STRING, 0, string, length);
-    }
-    else if(curDomain->m_pCustomSortLibrary != NULL)
-    {
-        result = (curDomain->m_pCustomSortLibrary->pIsNLSDefinedString)(COMPARE_STRING, 0, NULL, string, length);
-    }
-    else
-#endif
     {
         // Function should be COMPARE_STRING, dwFlags should be NULL, lpVersionInfo should be NULL for now
         result = NewApis::IsNLSDefinedString(COMPARE_STRING, 0, NULL, string, length);
@@ -389,7 +308,6 @@ BOOL QCALLTYPE COMNlsInfo::InternalGetUserDefaultUILanguage(QCall::StringHandleO
 }
 
 // Added but disabled from desktop in .NET 4.0, stayed disabled in .NET 4.5
-#ifdef FEATURE_CORECLR
 FCIMPL0(Object*, COMNlsInfo::nativeGetResourceFallbackArray)
 {
     CONTRACTL
@@ -452,7 +370,6 @@ FCIMPL0(Object*, COMNlsInfo::nativeGetResourceFallbackArray)
 
 }
 FCIMPLEND
-#endif // FEATURE_CORECLR
 
 INT32 COMNlsInfo::CallGetUserDefaultUILanguage()
 {
@@ -492,122 +409,12 @@ INT_PTR COMNlsInfo::EnsureValidSortHandle(INT_PTR handle, INT_PTR handleOrigin,
 {
     LIMITED_METHOD_CONTRACT;
 
-#ifndef FEATURE_CORECLR
-    AppDomain* curDomain = GetAppDomain();
-
-    if(!(curDomain->m_bUseOsSorting) && handleOrigin == (INT_PTR) SortVersioning::GetSortHandle && ((SortVersioning::PSORTHANDLE) handle)->dwNLSVersion == curDomain->m_sortVersion)
-    {
-        return handle;
-    }
-
-    if(curDomain->m_bUseOsSorting && curDomain->m_pCustomSortLibrary == NULL && handleOrigin == (INT_PTR) NewApis::LCMapStringEx)
-    {
-        return handle;
-    }
-
-    if(curDomain->m_bUseOsSorting && curDomain->m_pCustomSortLibrary != NULL && handleOrigin == (INT_PTR) curDomain->m_pCustomSortLibrary->pLCMapStringEx)
-    {
-        return handle;
-    }
-
-    // At this point, we can't reuse the sort handle (it has different sort semantics than this domain) so we need to get a new one.
-    INT_PTR newHandleOrigin;
-    return InitSortHandleHelper(localeName, &newHandleOrigin);
-#else
     // For CoreCLR, on Windows 8 and up the handle will be valid. on downlevels the handle will be null
     return handle;
-#endif
-}
-
-#ifdef FEATURE_SYNTHETIC_CULTURES
-////////////////////////////////////////////////////////////////////////////
-//
-//  WstrToInteger4
-//
-////////////////////////////////////////////////////////////////////////////
-
-/*=================================WstrToInteger4==================================
-**Action: Convert a Unicode string to an integer.  Error checking is ignored.
-**Returns: The integer value of wstr
-**Arguments:
-**      wstr: NULL terminated wide string.  Can have character 0'-'9', 'a'-'f', and 'A' - 'F'
-**      Radix: radix to be used in the conversion.
-**Exceptions: None.
-==============================================================================*/
-
-INT32 COMNlsInfo::WstrToInteger4(
-    __in_z LPCWSTR wstr,
-    __in int Radix)
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        SO_TOLERANT;
-        PRECONDITION(CheckPointer(wstr));
-        PRECONDITION(Radix > 1 && Radix <= 16);
-    } CONTRACTL_END;
-    INT32 Value = 0;
-    int Base = 1;
-
-    for (int Length = Wszlstrlen(wstr) - 1; Length >= 0; Length--)
-
-    {
-        WCHAR ch = wstr[Length];
-        _ASSERTE((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F'));
-        if (ch >= 'a')
-        {
-            ch = ch - 'a' + 'A';
-        }
-
-        Value += ((ch >= 'A') ? (ch - 'A' + 10) : (ch - '0')) * Base;
-        Base *= Radix;
-    }
-
-    return (Value);
 }
-#endif // FEATURE_SYNTHETIC_CULTURES
-
-
-#ifndef FEATURE_CORECLR
-FCIMPL1(FC_BOOL_RET, COMNlsInfo::nativeSetThreadLocale, StringObject* localeNameUNSAFE)
-{
-    CONTRACTL
-    {
-        FCALL_CHECK;
-        PRECONDITION(CheckPointer(localeNameUNSAFE));
-    } CONTRACTL_END;
-
-    LCID lcid = 0;
-
-    // TODO: NLS Arrowhead -A bit scary becausue Set ThreadLocale can't handle custom cultures?
-    STRINGREF localeName = (STRINGREF)localeNameUNSAFE;
-    HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(localeName);
-    lcid=NewApis::LocaleNameToLCID(localeName->GetBuffer(),0);
-    if (lcid == 0)
-    {
-        ThrowHR(HRESULT_FROM_WIN32(GetLastError()));
-    }
-        HELPER_METHOD_FRAME_END();
-
 
-    BOOL result = TRUE;
 
-    // SetThreadLocale doesn't handle names/custom cultures
-#ifdef _MSC_VER
-// Get rid of the SetThreadLocale warning in OACR:
-#pragma warning(push)
-#pragma warning(disable:38010)
-#endif
-    result = ::SetThreadLocale(lcid);
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
 
-    FC_RETURN_BOOL(result);
-}
-FCIMPLEND
-#endif
 
 
 FCIMPL2(Object*, COMNlsInfo::nativeGetLocaleInfoEx, StringObject* localeNameUNSAFE, INT32 lcType)
@@ -1661,18 +1468,6 @@ INT32 QCALLTYPE COMNlsInfo::InternalCompareString(
 
     handle = EnsureValidSortHandle(handle, handleOrigin, localeName);
 
-#ifndef FEATURE_CORECLR
-    AppDomain* curDomain = GetAppDomain();
-
-    if(!(curDomain->m_bUseOsSorting))
-    {
-        result = SortVersioning::SortDllCompareString((SortVersioning::PSORTHANDLE) handle, flags, &string1[offset1], length1, &string2[offset2], length2, NULL, 0);
-    }
-    else if (curDomain->m_pCustomSortLibrary != NULL) {
-        result = (curDomain->m_pCustomSortLibrary->pCompareStringEx)(handle != NULL ? NULL : localeName, flags, &string1[offset1], length1, &string2[offset2], length2, NULL, NULL, (LPARAM) handle);
-    } 
-    else 
-#endif
     {
         result = NewApis::CompareStringEx(handle != NULL ? NULL : localeName, flags, &string1[offset1], length1, &string2[offset2], length2,NULL,NULL, (LPARAM) handle);
     }
@@ -1770,40 +1565,19 @@ INT32 QCALLTYPE COMNlsInfo::InternalGetGlobalizedHashCode(INT_PTR handle, INT_PT
         COMPlusThrowArgumentNull(W("string"),W("ArgumentNull_String"));
     }
 
-#ifndef FEATURE_CORECLR
-    AppDomain* curDomain = GetAppDomain();
-#endif // FEATURE_CORECLR
 
     if(length > 0 && UseConstantSpaceHashAlgorithm() 
     // Note that we can't simply do the hash without the entropy and then try to add it after the fact we need the hash function itself to pass entropy to its inputs.
 #ifdef FEATURE_RANDOMIZED_STRING_HASHING
          && !bForceRandomizedHashing
-#ifndef FEATURE_CORECLR
-         && !curDomain->m_pNlsHashProvider->GetUseRandomHashing()
-#else
          && !COMNlsHashProvider::s_NlsHashProvider.GetUseRandomHashing()
-#endif // FEATURE_CORECLR
 #endif // FEATURE_RANDOMIZED_STRING_HASHING
        )
     {
-#ifndef FEATURE_CORECLR
-        if(!(curDomain->m_bUseOsSorting))
-        {
-            iReturnHash=SortVersioning::SortDllGetHashCode((SortVersioning::PSORTHANDLE) handle, dwFlagsIn, string, length, NULL, 0);
-        }
-        else
-#endif
         {
             int iRes = 0;
             int iHashValue = 0;
 
-#ifndef FEATURE_CORECLR
-            if (curDomain->m_pCustomSortLibrary != NULL)
-            {
-                iRes = (curDomain->m_pCustomSortLibrary->pLCMapStringEx)(localeName, dwFlagsIn | LCMAP_HASH, string, length, (LPWSTR) &iHashValue, sizeof(INT32), NULL, NULL, 0);
-            }
-            else
-#endif
             {
                 iRes = NewApis::LCMapStringEx(localeName, dwFlagsIn | LCMAP_HASH, string, length, (LPWSTR) &iHashValue, sizeof(INT32), NULL, NULL, 0);
             }
@@ -1824,17 +1598,6 @@ INT32 QCALLTYPE COMNlsInfo::InternalGetGlobalizedHashCode(INT_PTR handle, INT_PT
         //
         // Assert if we might hit an AV in LCMapStringEx for the invariant culture.
         _ASSERTE(length > 0 || (dwFlags & LCMAP_LINGUISTIC_CASING) == 0);
-#ifndef FEATURE_CORECLR
-        if(!(curDomain->m_bUseOsSorting))
-        {
-            byteCount=SortVersioning::SortDllGetSortKey((SortVersioning::PSORTHANDLE) handle, dwFlagsIn, string, length, NULL, 0, NULL, 0);
-        }
-        else if (curDomain->m_pCustomSortLibrary != NULL)
-        {
-            byteCount = (curDomain->m_pCustomSortLibrary->pLCMapStringEx)(handle != NULL ? NULL : localeName, dwFlags, string, length, NULL, 0, NULL, NULL, (LPARAM) handle);
-        }
-        else
-#endif
         {
             byteCount=NewApis::LCMapStringEx(handle != NULL ? NULL : localeName, dwFlags, string, length, NULL, 0, NULL, NULL, (LPARAM) handle);
         }
@@ -1851,26 +1614,11 @@ INT32 QCALLTYPE COMNlsInfo::InternalGetGlobalizedHashCode(INT_PTR handle, INT_PT
             CQuickBytesSpecifySize<MAX_STRING_VALUE * sizeof(WCHAR)> qbBuffer;
             BYTE* pByte = (BYTE*)qbBuffer.AllocThrows(byteCount);
 
-#ifndef FEATURE_CORECLR
-            if(!(curDomain->m_bUseOsSorting))
-            {
-                SortVersioning::SortDllGetSortKey((SortVersioning::PSORTHANDLE) handle, dwFlagsIn, string, length, pByte, byteCount, NULL, 0);
-            }
-            else if(curDomain->m_pCustomSortLibrary != NULL)
-            {
-                (curDomain->m_pCustomSortLibrary->pLCMapStringEx)(handle != NULL ? NULL : localeName, dwFlags, string, length, (LPWSTR)pByte, byteCount, NULL, NULL, (LPARAM) handle);
-            }
-            else
-#endif
             {
                 NewApis::LCMapStringEx(handle != NULL ? NULL : localeName, dwFlags, string, length, (LPWSTR)pByte, byteCount, NULL,NULL, (LPARAM) handle);
             }
 
-#ifndef FEATURE_CORECLR
-            iReturnHash = curDomain->m_pNlsHashProvider->HashSortKey(pByte, byteCount, bForceRandomizedHashing, additionalEntropy);
-#else
             iReturnHash = COMNlsHashProvider::s_NlsHashProvider.HashSortKey(pByte, byteCount, bForceRandomizedHashing, additionalEntropy);
-#endif // FEATURE_CORECLR
         }
     }
     END_QCALL;
@@ -1910,36 +1658,6 @@ FCIMPL5(FC_CHAR_RET, COMNlsInfo::InternalChangeCaseChar,
 
     handle = EnsureValidSortHandle(handle, handleOrigin, localeName->GetBuffer());
 
-#ifndef FEATURE_CORECLR
-    AppDomain* curDomain = GetAppDomain();
-
-    //For a versioned sort, Invariant should still use the OS
-    if(!(curDomain->m_bUseOsSorting) && !isInvariantLocale)
-    {
-        ret_LCMapStringEx = SortVersioning::SortDllChangeCase((SortVersioning::PSORTHANDLE) handle,
-                                    bIsToUpper?LCMAP_UPPERCASE | linguisticCasing:
-                                               LCMAP_LOWERCASE | linguisticCasing,
-                                    &wch,
-                                    1,
-                                    &retVal,
-                                    1,
-                                    NULL, 0);
-    }
-    else if(curDomain->m_pCustomSortLibrary != NULL)
-    {
-        ret_LCMapStringEx = (curDomain->m_pCustomSortLibrary->pLCMapStringEx)(handle != NULL ? NULL : localeName->GetBuffer(),
-                                   bIsToUpper?LCMAP_UPPERCASE | linguisticCasing:
-                                              LCMAP_LOWERCASE | linguisticCasing,
-                                   &wch,
-                                   1,
-                                   &retVal,
-                                   1,
-                                   NULL,
-                                   NULL,
-                                   (LPARAM) handle);
-    }
-    else
-#endif    
     {
         ret_LCMapStringEx = NewApis::LCMapStringEx(handle != NULL ? NULL : localeName->GetBuffer(),
                                    bIsToUpper?LCMAP_UPPERCASE | linguisticCasing:
@@ -2025,36 +1743,6 @@ FCIMPL5(Object*, COMNlsInfo::InternalChangeCaseString,
         LPWSTR pResultStr = gc.pResult->GetBuffer();
 
         int result;
-#ifndef FEATURE_CORECLR
-        AppDomain* curDomain = GetAppDomain();
-
-        //Invariant should always use OS
-        if(!(curDomain->m_bUseOsSorting) && !isInvariantLocale)
-        {
-            result = SortVersioning::SortDllChangeCase((SortVersioning::PSORTHANDLE) handle,
-                                        bIsToUpper?LCMAP_UPPERCASE | linguisticCasing:
-                                                   LCMAP_LOWERCASE | linguisticCasing,
-                                        gc.pString->GetBuffer(),
-                                        nLengthInput,
-                                        pResultStr,
-                                        nLengthOutput,
-                                        NULL, 0);
-        }
-        else if(curDomain->m_pCustomSortLibrary != NULL)
-        {
-            result = (curDomain->m_pCustomSortLibrary->pLCMapStringEx)(handle != NULL ? NULL : (gc.pLocale)->GetBuffer(),
-                                       bIsToUpper?LCMAP_UPPERCASE | linguisticCasing :
-                                                  LCMAP_LOWERCASE | linguisticCasing,
-                                       gc.pString->GetBuffer(),
-                                       nLengthInput,
-                                       pResultStr,
-                                       nLengthOutput,
-                                       NULL,
-                                       NULL,
-                                       (LPARAM) handle);
-        }
-        else
-#endif
         {
             result = NewApis::LCMapStringEx(handle != NULL ? NULL : (gc.pLocale)->GetBuffer(),
                                        bIsToUpper?LCMAP_UPPERCASE | linguisticCasing :
@@ -2076,34 +1764,6 @@ FCIMPL5(Object*, COMNlsInfo::InternalChangeCaseString,
                 ThrowLastError();
             }
             // need to update buffer
-#ifndef FEATURE_CORECLR
-            //Invariant should always use OS
-            if(!(curDomain->m_bUseOsSorting) && !IsInvariantLocale(gc.pLocale))
-            {
-                nLengthOutput = SortVersioning::SortDllChangeCase((SortVersioning::PSORTHANDLE) handle,
-                                            bIsToUpper?LCMAP_UPPERCASE | linguisticCasing:
-                                                       LCMAP_LOWERCASE | linguisticCasing,
-                                            gc.pString->GetBuffer(),
-                                            nLengthInput,
-                                            NULL,
-                                            0,
-                                            NULL, 0);
-            }
-            else if(curDomain->m_pCustomSortLibrary != NULL)
-            {
-                nLengthOutput = (curDomain->m_pCustomSortLibrary->pLCMapStringEx)(handle != NULL ? NULL : (gc.pLocale)->GetBuffer(),
-                                                        bIsToUpper?LCMAP_UPPERCASE | linguisticCasing :
-                                                                   LCMAP_LOWERCASE | linguisticCasing,
-                                                        gc.pString->GetBuffer(),
-                                                        nLengthInput,
-                                                        NULL,
-                                                        0,
-                                                        NULL,
-                                                        NULL,
-                                                        (LPARAM) handle);
-            }
-            else
-#endif
             {
                 nLengthOutput = NewApis::LCMapStringEx(handle != NULL ? NULL : (gc.pLocale)->GetBuffer(),
                                                         bIsToUpper?LCMAP_UPPERCASE | linguisticCasing :
@@ -2133,34 +1793,6 @@ FCIMPL5(Object*, COMNlsInfo::InternalChangeCaseString,
 
             gc.pResult = StringObject::NewString(nLengthOutput);
             pResultStr = gc.pResult->GetBuffer();
-#ifndef FEATURE_CORECLR
-            //Invariant should always use OS
-            if(!(curDomain->m_bUseOsSorting) && !IsInvariantLocale(gc.pLocale))
-            {
-                result = SortVersioning::SortDllChangeCase((SortVersioning::PSORTHANDLE) handle,
-                                            bIsToUpper?LCMAP_UPPERCASE | linguisticCasing:
-                                                       LCMAP_LOWERCASE | linguisticCasing,
-                                            gc.pString->GetBuffer(),
-                                            nLengthInput,
-                                            pResultStr,
-                                            nLengthOutput,
-                                            NULL, 0);
-            }
-            else if(curDomain->m_pCustomSortLibrary != NULL)
-            {
-                result = (curDomain->m_pCustomSortLibrary->pLCMapStringEx)(handle != NULL ? NULL : (gc.pLocale)->GetBuffer(),
-                                           bIsToUpper?LCMAP_UPPERCASE | linguisticCasing :
-                                                      LCMAP_LOWERCASE | linguisticCasing,
-                                           gc.pString->GetBuffer(),
-                                           nLengthInput,
-                                           pResultStr,
-                                           nLengthOutput,
-                                           NULL,
-                                           NULL,
-                                           (LPARAM) handle);
-            }
-            else
-#endif
             {
                 result = NewApis::LCMapStringEx(handle != NULL ? NULL : (gc.pLocale)->GetBuffer(),
                                            bIsToUpper?LCMAP_UPPERCASE | linguisticCasing :
@@ -2217,9 +1849,6 @@ FCIMPL6(INT32, COMNlsInfo::InternalGetCaseInsHash,
 
     *((LPVOID *)&strA)=pvStrA;
 
-#ifndef FEATURE_CORECLR
-    AppDomain* curDomain = GetAppDomain();
-#endif
 
     //
     // If we know that we don't have any high characters (the common case) we can
@@ -2235,11 +1864,7 @@ FCIMPL6(INT32, COMNlsInfo::InternalGetCaseInsHash,
     {
         // Notice that for Turkish and Azeri we don't get here and shouldn't use this
         // fast path because of their special Latin casing rules.
-#ifndef FEATURE_CORECLR
-        result = curDomain->m_pNlsHashProvider->HashiStringKnownLower80(strA->GetBuffer(), strA->GetStringLength(), bForceRandomizedHashing, additionalEntropy);
-#else
         result = COMNlsHashProvider::s_NlsHashProvider.HashiStringKnownLower80(strA->GetBuffer(), strA->GetStringLength(), bForceRandomizedHashing, additionalEntropy);
-#endif // FEATURE_CORECLR
     }
     else
     {
@@ -2259,29 +1884,6 @@ FCIMPL6(INT32, COMNlsInfo::InternalGetCaseInsHash,
         }
 
         int lcmapResult;
-#ifndef FEATURE_CORECLR
-        if(!(curDomain->m_bUseOsSorting))
-        {
-            lcmapResult = SortVersioning::SortDllChangeCase((SortVersioning::PSORTHANDLE) handle,
-                                                    LCMAP_UPPERCASE | linguisticCasing,
-                                                    strA->GetBuffer(),
-                                                    length,
-                                                    pNewStr,
-                                                    length,
-                                                    NULL, 0);
-        }
-        else if(curDomain->m_pCustomSortLibrary != NULL)
-        {
-            lcmapResult = (curDomain->m_pCustomSortLibrary->pLCMapStringEx)(handle != NULL ? NULL : localeName->GetBuffer(),
-                                                   LCMAP_UPPERCASE | linguisticCasing,
-                                                   strA->GetBuffer(),
-                                                   length,
-                                                   pNewStr,
-                                                   length,
-                                                   NULL, NULL, (LPARAM) handle);
-        }
-        else
-#endif
         {
             lcmapResult = NewApis::LCMapStringEx(handle != NULL ? NULL : localeName->GetBuffer(),
                                                    LCMAP_UPPERCASE | linguisticCasing,
@@ -2302,11 +1904,7 @@ FCIMPL6(INT32, COMNlsInfo::InternalGetCaseInsHash,
 
         // Get hash for the upper case of the new string
 
-#ifndef FEATURE_CORECLR
-        result = curDomain->m_pNlsHashProvider->HashString(pNewStr, length, (BOOL)bForceRandomizedHashing, additionalEntropy);
-#else
         result = COMNlsHashProvider::s_NlsHashProvider.HashString(pNewStr, length, (BOOL)bForceRandomizedHashing, additionalEntropy);
-#endif // FEATURE_CORECLR
     }
 
     END_SO_INTOLERANT_CODE
@@ -2351,23 +1949,6 @@ BOOL QCALLTYPE COMNlsInfo::InternalTryFindStringOrdinalIgnoreCase(
     else {
         lpSearchStart = &lpStringSource[sourceIndex];
     }
-#ifndef FEATURE_CORECLR
-    AppDomain* curDomain = GetAppDomain();
-
-    // Check if the default sorting is overridden
-    if (curDomain->m_pCustomSortLibrary != NULL)
-    {
-        *foundIndex = (curDomain->m_pCustomSortLibrary->pFindStringOrdinal)(
-            dwFindNLSStringFlags,
-            lpSearchStart,
-            cchSource,
-            lpStringValue,
-            cchValue,
-            TRUE);
-        result = TRUE;
-    }
-    else
-#endif
     {
 #ifndef FEATURE_CORESYSTEM
         // kernel function pointer
@@ -2443,14 +2024,6 @@ INT32 QCALLTYPE COMNlsInfo::InternalCompareStringOrdinalIgnoreCase(
     _ASSERT(length2 >= 0);
 
     // Do the comparison
-#ifndef FEATURE_CORECLR
-    AppDomain* curDomain = GetAppDomain();
-    
-    if (curDomain->m_pCustomSortLibrary != NULL) {
-        result = (curDomain->m_pCustomSortLibrary->pCompareStringOrdinal)(string1 + index1, length1, string2 + index2, length2, TRUE);
-    } 
-    else 
-#endif
     {
         result = NewApis::CompareStringOrdinal(string1 + index1, length1, string2 + index2, length2, TRUE);
     }
@@ -2601,15 +2174,6 @@ void QCALLTYPE COMNlsInfo::nativeNormalizationInitNormalization(int NormForm, BY
             if (!hNormalization)
                ThrowLastError();
         }
-#ifndef FEATURE_CORECLR
-        // in coreclr we should always find the normalization in kernel32 as it supports Win7 and up 
-        else
-        {
-            HRESULT hr = g_pCLRRuntime->LoadLibrary(NORMALIZATION_DLL, &hNormalization);
-            if (FAILED(hr))
-                ThrowHR(hr);
-        }
-#endif // FEATURE_CORECLR
 
         _ASSERTE(hNormalization != NULL);
         m_hNormalization = hNormalization;
@@ -2791,7 +2355,6 @@ FCIMPL1(FC_BOOL_RET, COMNlsInfo::nativeInitCultureData, CultureDataBaseObject *c
         gc.stringResult = StringObject::NewString(buffer, result - 1);
         SetObjectReference((OBJECTREF*)&(gc.cultureData->sSpecificCulture), gc.stringResult, NULL);
 
-#ifdef FEATURE_CORECLR
         if (!IsWindows7())
         {
             // For neutrals on Windows 7 + the neutral windows name can be the same as the neutral name,
@@ -2799,7 +2362,6 @@ FCIMPL1(FC_BOOL_RET, COMNlsInfo::nativeInitCultureData, CultureDataBaseObject *c
             gc.stringResult = StringObject::NewString(buffer, result - 1);
             SetObjectReference((OBJECTREF*)&(gc.cultureData->sWindowsName), gc.stringResult, NULL);
         }
-#endif
 
 
     }
@@ -2839,12 +2401,10 @@ FCIMPL1(FC_BOOL_RET, COMNlsInfo::nativeInitCultureData, CultureDataBaseObject *c
         SetObjectReference((OBJECTREF*)&(gc.cultureData->sName), gc.stringResult, NULL);
     }
 
-#ifdef FEATURE_CORECLR
     // For Silverlight make sure that the sorting tables are available (< Vista may not have east asian installed)
     result = NewApis::CompareStringEx(((STRINGREF)gc.cultureData->sWindowsName)->GetBuffer(),
                                       0, W("A"), 1, W("B"), 1, NULL, NULL, 0);
     if (result == 0) goto Exit;
-#endif
 
     // It succeeded.
     success = TRUE;
@@ -2907,16 +2467,9 @@ int QCALLTYPE COMNlsInfo::InternalFindNLSStringEx(
 
     BEGIN_QCALL;
 
-#ifndef FEATURE_CORECLR
-    AppDomain* curDomain = GetAppDomain();
-    handle = EnsureValidSortHandle(handle, handleOrigin, lpLocaleName);
-#endif
 
     #define RESERVED_FIND_ASCII_STRING 0x20000000       // This flag used only to tell the sorting DLL can assume the string characters are in ASCII.
 
-#ifndef FEATURE_CORECLR
-    int asciiFlag = (dwFindNLSStringFlags & RESERVED_FIND_ASCII_STRING);
-#endif // FEATURE_CORECLR
 
     dwFindNLSStringFlags &= ~RESERVED_FIND_ASCII_STRING;
 
@@ -2970,29 +2523,6 @@ int QCALLTYPE COMNlsInfo::InternalFindNLSStringEx(
     {
         if (dwFindNLSStringFlags & (FIND_FROMEND | FIND_ENDSWITH))
         {
-#ifndef FEATURE_CORECLR
-            if(!(curDomain->m_bUseOsSorting))
-            {
-                retValue = SortVersioning::SortDllFindString((SortVersioning::PSORTHANDLE) handle,
-                                                  dwFindNLSStringFlags | asciiFlag,
-                                                  &lpStringSource[sourceIndex - cchSource + 1],
-                                                  cchSource,
-                                                  lpStringValue,
-                                                  cchValue,
-                                                  NULL, NULL, 0);
-            }
-            else if(curDomain->m_pCustomSortLibrary != NULL)
-            {
-                retValue = (curDomain->m_pCustomSortLibrary->pFindNLSStringEx)(
-                                        handle != NULL ? NULL : lpLocaleName,
-                                        dwFindNLSStringFlags,
-                                        &lpStringSource[sourceIndex - cchSource + 1],
-                                        cchSource,
-                                        lpStringValue,
-                                        cchValue, NULL, NULL, NULL, (LPARAM) handle);
-            }   
-            else
-#endif
             {
                 retValue = NewApis::FindNLSStringEx(
                                         handle != NULL ? NULL : lpLocaleName,
@@ -3010,29 +2540,6 @@ int QCALLTYPE COMNlsInfo::InternalFindNLSStringEx(
         }
         else
         {
-#ifndef FEATURE_CORECLR
-            if(!(curDomain->m_bUseOsSorting))
-            {
-                retValue = SortVersioning::SortDllFindString((SortVersioning::PSORTHANDLE) handle,
-                                                  dwFindNLSStringFlags | asciiFlag,
-                                                  &lpStringSource[sourceIndex],
-                                                  cchSource,
-                                                  lpStringValue,
-                                                  cchValue,
-                                                  NULL, NULL, 0);
-            }
-            else if(curDomain->m_pCustomSortLibrary != NULL)
-            {
-                retValue = (curDomain->m_pCustomSortLibrary->pFindNLSStringEx)(
-                                        handle != NULL ? NULL : lpLocaleName,
-                                        dwFindNLSStringFlags,
-                                        &lpStringSource[sourceIndex],
-                                        cchSource,
-                                        lpStringValue,
-                                        cchValue, NULL, NULL, NULL, (LPARAM) handle);
-            }
-            else
-#endif
             {
                 retValue = NewApis::FindNLSStringEx(
                                         handle != NULL ? NULL : lpLocaleName,
@@ -3082,35 +2589,6 @@ int QCALLTYPE COMNlsInfo::InternalGetSortKey(
     BEGIN_QCALL;
 
 
-#ifndef FEATURE_CORECLR
-    handle = EnsureValidSortHandle(handle, handleOrigin, pLocaleName);
-
-    AppDomain* curDomain = GetAppDomain();
-
-    if(!(curDomain->m_bUseOsSorting))
-    {
-        retValue = SortVersioning::SortDllGetSortKey((SortVersioning::PSORTHANDLE) handle,
-                                                  flags,
-                                                  pStringSource,
-                                                  cchSource,
-                                                  pTarget,
-                                                  cchTarget,
-                                                  NULL, 0);
-    }
-    else if(curDomain->m_pCustomSortLibrary != NULL)
-    {
-        retValue = (curDomain->m_pCustomSortLibrary->pLCMapStringEx)(handle != NULL ? NULL : pLocaleName,
-                                          flags | LCMAP_SORTKEY,
-                                          pStringSource,
-                                          cchSource,
-                                          (LPWSTR)pTarget,
-                                          cchTarget,
-                                          NULL,
-                                          NULL,
-                                          (LPARAM) handle);
-    }
-    else
-#endif
     {
         // Just call NewApis::LCMapStringEx to do our work
         retValue = NewApis::LCMapStringEx(handle != NULL ? NULL : pLocaleName,
@@ -3163,86 +2641,11 @@ INT_PTR COMNlsInfo::InitSortHandleHelper(LPCWSTR localeName, __out INT_PTR* hand
 
     INT_PTR pSort = NULL;
 
-#ifndef FEATURE_CORECLR
-    AppDomain* curDomain = GetAppDomain();
-
-#if _DEBUG
-    _ASSERTE(curDomain->m_bSortingInitialized);
-#endif
-
-    if(curDomain->m_bUseOsSorting)
-    {
-        pSort = InternalInitOsSortHandle(localeName, handleOrigin);
-    }
-    else
-    {
-        pSort = InternalInitVersionedSortHandle(localeName, handleOrigin);
-    }
-#else
     // coreclr will try to initialize the handle and if running on downlevel it'll just return null
     pSort = InternalInitOsSortHandle(localeName, handleOrigin);
-#endif // FEATURE_CORECLR
     return pSort;
 }
 
-#ifndef FEATURE_CORECLR
-INT_PTR COMNlsInfo::InternalInitVersionedSortHandle(LPCWSTR localeName, __out INT_PTR* handleOrigin)
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        CANNOT_TAKE_LOCK;
-        PRECONDITION(localeName != NULL);
-    } CONTRACTL_END;
-
-    AppDomain* curDomain = GetAppDomain();
-
-    if(curDomain->m_pCustomSortLibrary != NULL)
-    {
-        return NULL;
-    }
-
-    return InternalInitVersionedSortHandle(localeName, handleOrigin, curDomain->m_sortVersion);
-}
-
-INT_PTR COMNlsInfo::InternalInitVersionedSortHandle(LPCWSTR localeName, __out INT_PTR* handleOrigin, DWORD sortVersion)
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        CANNOT_TAKE_LOCK;
-        PRECONDITION(localeName != NULL);
-    } CONTRACTL_END;
-    
-    INT_PTR pSort = NULL;
-
-    _ASSERTE(NewApis::NotLeakingFrameworkOnlyCultures(localeName));
-
-    *handleOrigin = (INT_PTR) SortVersioning::GetSortHandle;
-
-    // try the requested version
-    if(sortVersion != DEFAULT_SORT_VERSION)
-    {
-        NLSVERSIONINFO  sortVersionInfo;
-        sortVersionInfo.dwNLSVersionInfoSize = sizeof(NLSVERSIONINFO);
-        sortVersionInfo.dwNLSVersion = sortVersion;
-        sortVersionInfo.dwDefinedVersion = sortVersion;
-        pSort = (INT_PTR) SortVersioning::GetSortHandle(localeName, &sortVersionInfo);
-    }
-
-    // fallback to default version
-    if(pSort == NULL)
-    {
-        pSort = (INT_PTR) SortVersioning::GetSortHandle(localeName, NULL);
-    }
-
-    _ASSERTE(RunningOnWin8() || pSort != NULL);
-
-    return pSort;
-}
-#endif //FEATURE_CORECLR
 
 // Can return NULL
 INT_PTR COMNlsInfo::InternalInitOsSortHandle(LPCWSTR localeName, __out INT_PTR* handleOrigin)
@@ -3259,23 +2662,11 @@ INT_PTR COMNlsInfo::InternalInitOsSortHandle(LPCWSTR localeName, __out INT_PTR*
 
     AppDomain* curDomain = GetAppDomain();
 
-#ifndef FEATURE_CORECLR
-    if (RunningOnWin8() || curDomain->m_pCustomSortLibrary != NULL)
-#else
     if (RunningOnWin8())
-#endif //FEATURE_CORECLR 
     {
         LPARAM lSortHandle;
         int ret;
 
-#ifndef FEATURE_CORECLR
-        if (curDomain->m_pCustomSortLibrary != NULL)
-        {
-            ret = (curDomain->m_pCustomSortLibrary->pLCMapStringEx)(localeName, LCMAP_SORTHANDLE, NULL, 0, (LPWSTR) &lSortHandle, sizeof(LPARAM), NULL, NULL, 0);
-            *handleOrigin = (INT_PTR) curDomain->m_pCustomSortLibrary->pLCMapStringEx;
-        }
-        else
-#endif //FEATURE_CORECLR
         {
             ret = NewApis::LCMapStringEx(localeName, LCMAP_SORTHANDLE, NULL, 0, (LPWSTR) &lSortHandle, sizeof(LPARAM), NULL, NULL, 0);
             *handleOrigin = (INT_PTR) NewApis::LCMapStringEx;
@@ -3299,59 +2690,9 @@ BOOL QCALLTYPE COMNlsInfo::InternalGetNlsVersionEx(INT_PTR handle, INT_PTR handl
     BOOL ret = FALSE;
 
     BEGIN_QCALL;
-#ifndef FEATURE_CORECLR
-    AppDomain* curDomain = GetAppDomain();
-
-    if(curDomain->m_bUseOsSorting)
-    {
-        if(curDomain->m_pCustomSortLibrary != NULL)
-        {
-            ret = (curDomain->m_pCustomSortLibrary->pGetNLSVersionEx)(COMPARE_STRING, lpLocaleName, lpVersionInformation);
-        }
-        else
-        {
-            ret = GetNLSVersionEx(COMPARE_STRING, lpLocaleName, lpVersionInformation);
-        }
-    }
-    else
-    {
-        handle = EnsureValidSortHandle(handle, handleOrigin, lpLocaleName);
-
-        NLSVERSIONINFO nlsVersion;
-        nlsVersion.dwNLSVersionInfoSize = sizeof(NLSVERSIONINFO);
-
-        ret = SortVersioning::SortGetNLSVersion((SortVersioning::PSORTHANDLE) handle, COMPARE_STRING, &nlsVersion);
-
-        lpVersionInformation->dwNLSVersion = nlsVersion.dwNLSVersion;
-        lpVersionInformation->dwDefinedVersion = nlsVersion.dwDefinedVersion;
-        lpVersionInformation->dwEffectiveId = 0;
-        ZeroMemory(&(lpVersionInformation->guidCustomVersion), sizeof(GUID));                
-    }
-#else
     ret = GetNLSVersionEx(COMPARE_STRING, lpLocaleName, lpVersionInformation);
-#endif // FEATURE_CORECLR
     END_QCALL;
  
     return ret;
 }
 
-#ifndef FEATURE_CORECLR
-DWORD QCALLTYPE COMNlsInfo::InternalGetSortVersion()
-{
-    CONTRACTL {
-        QCALL_CHECK;
-    } CONTRACTL_END;
-
-    DWORD version = DEFAULT_SORT_VERSION;
-
-    BEGIN_QCALL;
-
-    AppDomain* curDomain = GetAppDomain();
-    version = curDomain->m_sortVersion;
-
-    END_QCALL;
-
-    return version;
-}
-
-#endif //FEATURE_CORECLR
diff --git a/src/classlibnative/nls/nlstable.cpp b/src/classlibnative/nls/nlstable.cpp
deleted file mode 100644
index dd395153d4..0000000000
--- a/src/classlibnative/nls/nlstable.cpp
+++ /dev/null
@@ -1,259 +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.
-
-#include "common.h"
-#include <winwrap.h>
-#include <excep.h>          // For COMPlusThrow
-#include <appdomain.hpp>
-#include <assembly.hpp>
-#include "nlstable.h"       // Class declaration
-
-#if FEATURE_CODEPAGES_FILE
-
-/*=================================CreateSharedMemoryMapping==================================
-**Action: Create a file mapping object which can be shared among different users under Windows NT/2000.
-**        Actually its just a memory mapped section of the swapfile.
-**Returns: The file mapping handle.  NULL if any error happens.
-**Arguments:
-**      pMappingName    the name of the file mapping object.
-**      iSize           Size to use
-**Exceptions: 
-**Note:
-**      This function creates a DACL which grants GENERIC_ALL access to members of the "Everyone" group.
-**      Then create a security descriptor using this DACL.  Finally, use this SA to create the file mapping object.
-** WARNING:
-**      This creates a shared file or shared paged memory section (if hFile == INVALID_HANDLE_VALUE) that is shared machine-wide
-**      Therefore for side-by-side to work, the mapping names must be unique per version!
-**      We utilize this feature for code pages in case it hasn't changed across versions we can still reuse the
-**      tables, but it seems suspicious for other applications (as commented in MapDataFile below)
-==============================================================================*/
-// static method
-HANDLE NLSTable::CreateSharedMemoryMapping(const LPCWSTR pMappingName, const int iSize ) {
-    CONTRACTL {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        PRECONDITION(iSize > 0);
-        PRECONDITION(CheckPointer(pMappingName));
-    } CONTRACTL_END;
-    
-    HANDLE hFileMap = NULL;
-
-    SECURITY_DESCRIPTOR sd ;
-    SECURITY_ATTRIBUTES sa ; 
-
-    //
-    // Create the sid for the Everyone group.
-    //
-    SID_IDENTIFIER_AUTHORITY siaWorld = SECURITY_WORLD_SID_AUTHORITY;
-    PSID pSID = NULL;     
-    int nSidSize;
-    
-    PACL pDACL = NULL; 
-    int nAclSize;
-
-    CQuickBytes newBuffer;
-    
-    if (!AllocateAndInitializeSid(&siaWorld, 1, SECURITY_WORLD_RID, 0, 0, 0, 0, 0, 0, 0, &pSID)) {            
-        goto ErrorExit;
-    }
-
-    nSidSize = GetLengthSid(pSID);
-
-    //
-    // Create Discretionary Access Control List (DACL).
-    //
-    
-    // First calculate the size of the DACL, since this is a linked-list like structure which contains one or more 
-    // ACE (access control entry)    
-    nAclSize = sizeof(ACL)                          // the header structure of ACL
-        + sizeof(ACCESS_ALLOWED_ACE) + nSidSize;     // and one "access allowed ACE".
-
-    // We know the size needed for DACL now, so create it.        
-    // An exception is thrown if OOM happens.
-    pDACL = (PACL) (newBuffer.AllocThrows(nAclSize));
-    if(!InitializeAcl( pDACL, nAclSize, ACL_REVISION ))
-        goto ErrorExit;  
-
-    // Add the "access allowed ACE", meaning:
-    //    we will allow members of the "Everyone" group to have SECTION_MAP_READ | SECTION_QUERY access to the file mapping object.
-    //    for memory sections the creator will still be allowed to create it.
-    if(!AddAccessAllowedAce( pDACL, ACL_REVISION, SECTION_MAP_READ | SECTION_QUERY, pSID ))
-        goto ErrorExit; 
-
-    //
-    // Create Security descriptor (SD).
-    //
-    if(!InitializeSecurityDescriptor( &sd, SECURITY_DESCRIPTOR_REVISION ))
-        goto ErrorExit; 
-    // Set the previously created DACL to this SD.
-    if(!SetSecurityDescriptorDacl( &sd, TRUE, pDACL, FALSE ))
-        goto ErrorExit; 
-
-    // Create Security Attribute (SA).        
-    sa.nLength = sizeof( sa ) ;
-    sa.bInheritHandle = TRUE ; 
-    sa.lpSecurityDescriptor = &sd ;
-
-    //
-    // Finally, create the file mapping using the SA.
-    //
-
-    // If we are on Windows 2000 or later, try to open it in global namespace.  The \global namespace is ignored if
-    // Terminal service is not running.
-    WCHAR globalSectionName[MAX_LONGPATH];
-    wcscpy_s(globalSectionName, COUNTOF(globalSectionName), W("Global\\"));
-    if (wcslen(pMappingName) + wcslen(globalSectionName) >= MAX_LONGPATH) {
-        goto ErrorExit;            
-    }
-    wcscat_s(globalSectionName, COUNTOF(globalSectionName), pMappingName);
-    
-    // Try to create the section in the Global\ namespace.  The CreateFileMapping() will ignore Global\ namespace if Terminal Service
-    // is not running.
-    hFileMap = WszCreateFileMapping(INVALID_HANDLE_VALUE, &sa, PAGE_READWRITE, 0, iSize, globalSectionName);
-    
-    // If not allowed to be global (like terminal server) or not WinNT, then open it in local namespace.
-    if (hFileMap == NULL)
-    {
-        // Not WinNT or access denied for Global\ namespace, try the local namespace.  When Terminal service is running, the Local\ namespace
-        // means the namespace "Sessions\<n>\BasedNamedObjects".
-        hFileMap = WszCreateFileMapping(INVALID_HANDLE_VALUE, &sa, PAGE_READWRITE, 0, iSize, pMappingName);
-    }        
-    
-ErrorExit:    
-    if(pSID)
-        FreeSid( pSID );
-
-    // If still not allowed, try building one with no name
-    if (hFileMap == NULL)
-    {
-        hFileMap = WszCreateFileMapping( 
-            INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, iSize, NULL);    
-    }
-
-    return (hFileMap) ;
-}
-
-/*=================================OpenOrCreateMemoryMapping==================================
-**Action: Opens an existing memory mapped object, or creates a new one (by calling above fn).
-**        Worst case just allocate some memory.
-**Returns: The pointer to our memory.  NULL if any error happens.
-**Arguments:
-**      pMappingName    the name of the file mapping object.
-**      iSize           Size to use
-**Exceptions:
-**
-**IMPORTANT:
-**      Memory mapped sections are cleared when set.  We expect the caller to set the last int
-**      to a non-zero value, so we test this flag.  If it is still zero when we open it, we
-**      assume that we've gotten a result in an unfinished state and allocate a new one instead
-**      of trying to use the one with the zeros.
-**
-**Note:
-**      This function creates a DACL which grants GENERIC_ALL access to members of the "Everyone" group.
-**      Then create a security descriptor using this DACL.  Finally, use this SA to create the file mapping object.
-** WARNING:
-**      This creates a shared file or shared paged memory section (if hFile == INVALID_HANDLE_VALUE) that is shared machine-wide
-**      Therefore for side-by-side to work, the mapping names must be unique per version!
-**      We utilize this feature for code pages in case it hasn't changed across versions we can still reuse the
-**      tables, but it seems suspicious for other applications (as commented in MapDataFile below)
-==============================================================================*/
-PBYTE NLSTable::OpenOrCreateMemoryMapping(const LPCWSTR pMappingName, const int iSize, HANDLE* mappedFile)
-{
-    CONTRACTL
-    {
-        THROWS;
-        DISABLED(GC_TRIGGERS); // 
-        MODE_ANY;
-        PRECONDITION(iSize % 4 == 0);
-        PRECONDITION(iSize > 0);
-        PRECONDITION(CheckPointer(pMappingName));
-        PRECONDITION(CheckPointer(mappedFile));
-    } CONTRACTL_END;
-
-    _ASSERTE(pMappingName != NULL); // Must have a string name.
-    _ASSERTE(iSize > 0);            // Pointless to have <= 0 allocation
-    _ASSERTE(iSize % 4 == 0);       // Need 4 byte alignment for flag check
-
-    LPVOID  pResult = NULL;
-
-    // Try creating/opening it.
-    HANDLE  hMap = NULL;
-
-    *mappedFile = hMap;
-    // Calls into OS a lot, should switch to preemp mode
-    GCX_PREEMP();
-
-    // First try opening it.  It might already be in existence
-    // The assumption here is that it's rare that we will hit the cases where two or more threads are trying to create
-    // the named section at the same time.  Therefore, the following code does not use critical section or mutex trying
-    // to synchornize different threads.
-
-    // Try to open it in global namespace. The global\ namespace is ignored if terminal service is not running.
-    WCHAR globalSectionName[MAX_LONGPATH];
-    wcscpy_s(globalSectionName, COUNTOF(globalSectionName), W("Global\\"));
-    if (wcslen(pMappingName) + wcslen(globalSectionName) >= MAX_LONGPATH)
-        return NULL;
-    
-    wcscat_s(globalSectionName, COUNTOF(globalSectionName), pMappingName);
-    
-    hMap = WszOpenFileMapping(FILE_MAP_READ, TRUE, globalSectionName);
-    if (hMap == NULL) {
-        // If access is denied for global\namespace or the name is not opened in global namespace, try the local namespace.
-        // Also if we're rotor or win 9x.
-        hMap = WszOpenFileMapping(FILE_MAP_READ, TRUE, pMappingName);       
-    }  
-    
-    if (hMap != NULL) {
-        // We got a section, map a view, READ ONLY!
-        pResult = MapViewOfFile( hMap, FILE_MAP_READ, 0, 0, 0);
-
-        // Anything found?
-        if (pResult != NULL)
-        {
-            // Make sure our result is allocated.  We expect a non-0 flag to be set for last int of our section
-            const int* pFlag = (int*)(((BYTE*)pResult) + iSize - 4);
-            if (*pFlag != 0)
-            {
-                *mappedFile = hMap;
-                // Found a valid already opened section!
-                return (PBYTE)pResult;
-            }
-
-            // Couldn't find it, unmap it.
-            UnmapViewOfFile(pResult);
-            pResult = NULL;
-        }
-
-        // We can't use this one, so close it
-        CloseHandle(hMap);
-        hMap = NULL;
-    }
-    
-    // Didn't get a section, try to create one, NT/XP/.Net gets security permissions, 9X doesn't,
-    // but our helper fn takes care of that for us.
-    hMap = NLSTable::CreateSharedMemoryMapping(pMappingName, iSize);
-
-    // Were we successfull?
-    if (hMap != NULL)
-    {
-        // We have hMap, try to get our section
-        pResult = MapViewOfFile( hMap, FILE_MAP_ALL_ACCESS, 0, 0, 0);
-
-        // Don't close hMap unless we aren't using it.
-        // That confuses the mapping stuff and we lose the name, it'll close when runtime shuts down.
-        if (pResult == NULL)
-        {
-            CloseHandle(hMap);
-            hMap = NULL;
-        }
-        // There is no need to zero out the mapCodePageCached field, since the initial contents of the pages in the file mapping object are zero.
-        
-        *mappedFile = hMap;
-    }
-
-    return (PBYTE)pResult;
-}
-
-#endif
diff --git a/src/coreclr/hosts/unixcoreconsole/CMakeLists.txt b/src/coreclr/hosts/unixcoreconsole/CMakeLists.txt
index 8988e60dcf..94587b5374 100644
--- a/src/coreclr/hosts/unixcoreconsole/CMakeLists.txt
+++ b/src/coreclr/hosts/unixcoreconsole/CMakeLists.txt
@@ -23,11 +23,16 @@ endif(NOT CMAKE_SYSTEM_NAME STREQUAL FreeBSD AND NOT CMAKE_SYSTEM_NAME STREQUAL
 # pthread by the process executable ensures that all locks are initialized properly.
 target_link_libraries(coreconsole
     unixcoreruncommon
-    pthread
 )
 
+if(NOT CLR_CMAKE_PLATFORM_ANDROID)
+  target_link_libraries(coreconsole
+    pthread
+  )
+endif()
+
 add_dependencies(coreconsole
     coreclr
 )
 
-install_clr(coreconsole)
\ No newline at end of file
+install_clr(coreconsole)
diff --git a/src/coreclr/hosts/unixcorerun/CMakeLists.txt b/src/coreclr/hosts/unixcorerun/CMakeLists.txt
index b32c9833bf..b5dc730aaf 100644
--- a/src/coreclr/hosts/unixcorerun/CMakeLists.txt
+++ b/src/coreclr/hosts/unixcorerun/CMakeLists.txt
@@ -23,11 +23,17 @@ endif(NOT CMAKE_SYSTEM_NAME STREQUAL FreeBSD AND NOT CMAKE_SYSTEM_NAME STREQUAL
 # pthread by the process executable ensures that all locks are initialized properly.
 target_link_libraries(corerun
     unixcoreruncommon
-    pthread
 )
 
+# Android implements pthread natively
+if(NOT CLR_CMAKE_PLATFORM_ANDROID)
+  target_link_libraries(corerun
+    pthread
+  )
+endif()
+
 add_dependencies(corerun
     coreclr
 )
 
-install_clr(corerun)
\ No newline at end of file
+install_clr(corerun)
diff --git a/src/debug/daccess/dacdbiimpl.cpp b/src/debug/daccess/dacdbiimpl.cpp
index ae266e8a6f..0ac5dc04ea 100644
--- a/src/debug/daccess/dacdbiimpl.cpp
+++ b/src/debug/daccess/dacdbiimpl.cpp
@@ -25,9 +25,6 @@
 #include "stackwalk.h"
 
 #include "dacdbiimpl.h"
-#ifndef FEATURE_CORECLR
-#include "assemblyusagelogmanager.h"
-#endif
 
 #ifdef FEATURE_COMINTEROP
 #include "runtimecallablewrapper.h"
@@ -3473,12 +3470,7 @@ void DacDbiInterfaceImpl::GetStackFramesFromException(VMPTR_Object vmObject, Dac
             currentFrame.vmDomainFile.SetHostPtr(pDomainFile);
             currentFrame.ip = currentElement.ip;
             currentFrame.methodDef = currentElement.pFunc->GetMemberDef();
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
             currentFrame.isLastForeignExceptionFrame = currentElement.fIsLastFrameFromForeignStackTrace;
-#else
-            // for CLRs lacking exception dispatch info just set it to 0
-            currentFrame.isLastForeignExceptionFrame = 0;
-#endif
         }
     }
 }
@@ -5684,28 +5676,7 @@ VMPTR_Object DacDbiInterfaceImpl::GetObject(CORDB_ADDRESS ptr)
 
 HRESULT DacDbiInterfaceImpl::EnableNGENPolicy(CorDebugNGENPolicy ePolicy)
 {
-#ifndef FEATURE_CORECLR
-    DD_ENTER_MAY_THROW;
-
-    // translate from our publicly exposed enum to the appropriate internal value
-    AssemblyUsageLogManager::ASSEMBLY_USAGE_LOG_FLAGS asmFlag = AssemblyUsageLogManager::ASSEMBLY_USAGE_LOG_FLAGS_NONE;
-
-    switch (ePolicy)
-    {
-    case DISABLE_LOCAL_NIC:
-        asmFlag = AssemblyUsageLogManager::ASSEMBLY_USAGE_LOG_FLAGS_APPLOCALNGENDISABLED;
-        break;
-    default:
-        return E_INVALIDARG;
-    }
-
-    // we should have made some selection
-    _ASSERTE(asmFlag != AssemblyUsageLogManager::ASSEMBLY_USAGE_LOG_FLAGS_NONE);
-
-    return AssemblyUsageLogManager::SetUsageLogFlag(asmFlag, TRUE);
-#else
     return E_NOTIMPL;
-#endif // FEATURE_CORECLR
 }
 
 HRESULT DacDbiInterfaceImpl::SetNGENCompilerFlags(DWORD dwFlags)
diff --git a/src/debug/daccess/dacdbiimplstackwalk.cpp b/src/debug/daccess/dacdbiimplstackwalk.cpp
index 7ab7ac7f95..29c9626db8 100644
--- a/src/debug/daccess/dacdbiimplstackwalk.cpp
+++ b/src/debug/daccess/dacdbiimplstackwalk.cpp
@@ -1156,13 +1156,13 @@ void DacDbiInterfaceImpl::UpdateContextFromRegDisp(REGDISPLAY * pRegDisp,
     // Do a partial copy first.
     pContext->ContextFlags = (CONTEXT_INTEGER | CONTEXT_CONTROL);
 
-    pContext->Edi = *pRegDisp->pEdi;
-    pContext->Esi = *pRegDisp->pEsi;
-    pContext->Ebx = *pRegDisp->pEbx;
-    pContext->Ebp = *pRegDisp->pEbp;
-    pContext->Eax = *pRegDisp->pEax;
-    pContext->Ecx = *pRegDisp->pEcx;
-    pContext->Edx = *pRegDisp->pEdx;
+    pContext->Edi = *pRegDisp->GetEdiLocation();
+    pContext->Esi = *pRegDisp->GetEsiLocation();
+    pContext->Ebx = *pRegDisp->GetEbxLocation();
+    pContext->Ebp = *pRegDisp->GetEbpLocation();
+    pContext->Eax = *pRegDisp->GetEaxLocation();
+    pContext->Ecx = *pRegDisp->GetEcxLocation();
+    pContext->Edx = *pRegDisp->GetEdxLocation();
     pContext->Esp = pRegDisp->SP;
     pContext->Eip = pRegDisp->ControlPC;
 
diff --git a/src/debug/daccess/datatargetadapter.cpp b/src/debug/daccess/datatargetadapter.cpp
index f2a1cc652a..4d4031d724 100644
--- a/src/debug/daccess/datatargetadapter.cpp
+++ b/src/debug/daccess/datatargetadapter.cpp
@@ -127,8 +127,12 @@ DataTargetAdapter::GetPlatform(
         platform = CORDB_PLATFORM_POSIX_ARM;
         break;
 
-    case IMAGE_FILE_MACHINE_IA64:
     case IMAGE_FILE_MACHINE_ARM64:
+        ulExpectedPointerSize = 8;
+        platform = CORDB_PLATFORM_POSIX_ARM64;
+	break;
+
+    case IMAGE_FILE_MACHINE_IA64:
         _ASSERTE_MSG(false, "Not supported platform.");
         return E_NOTIMPL;
         
diff --git a/src/debug/daccess/enummem.cpp b/src/debug/daccess/enummem.cpp
index 0f38aa582a..16a9ceec11 100644
--- a/src/debug/daccess/enummem.cpp
+++ b/src/debug/daccess/enummem.cpp
@@ -292,9 +292,6 @@ HRESULT ClrDataAccess::EnumMemCLRStatic(IN CLRDataEnumMemoryFlags flags)
     CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pValueTypeClass.EnumMem(); )
     CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pEnumClass.EnumMem(); )
     CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pThreadClass.EnumMem(); )
-#ifdef FEATURE_CER
-    CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pCriticalFinalizerObjectClass.EnumMem(); )
-#endif
     CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pFreeObjectMethodTable.EnumMem(); )
     CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_pObjectCtorMD.EnumMem(); )
     CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( g_fHostConfig.EnumMem(); )
diff --git a/src/debug/daccess/nidump.cpp b/src/debug/daccess/nidump.cpp
index 23e76c4fe4..c300e6fa01 100644
--- a/src/debug/daccess/nidump.cpp
+++ b/src/debug/daccess/nidump.cpp
@@ -19,7 +19,6 @@
 #include <algorithm>
 #endif
 
-#include <constrainedexecutionregion.h>
 
 #include <formattype.h>
 
@@ -623,20 +622,6 @@ void NativeImageDumper::DumpAssemblySignature(CORCOMPILE_ASSEMBLY_SIGNATURE & as
                           CORCOMPILE_ASSEMBLY_SIGNATURE, COR_INFO );
 }
 
-#ifndef FEATURE_CORECLR
-
-const NativeImageDumper::EnumMnemonics s_CorCompileDependencyInfoFlags[] =
-{
-#define CMDI_ENTRY(f) NativeImageDumper::EnumMnemonics(CORCOMPILE_DEPENDENCY_ ## f, W(#f))
-
-#ifdef FEATURE_APTCA
-    CMDI_ENTRY(IS_APTCA),
-    CMDI_ENTRY(IS_CAPTCA),
-#endif //FEATURE_APTCA
-#undef CMDI_ENTRY
-};
-
-#endif //!FEATURE_CORECLR
 
 //error code return?
 void
@@ -1102,12 +1087,6 @@ NativeImageDumper::DumpNativeImage()
             WriteFieldMDTokenImport( dwAssemblyDef, deps[i].dwAssemblyDef,
                                      CORCOMPILE_DEPENDENCY, COR_INFO,
                                      m_manifestImport );
-#ifndef FEATURE_CORECLR
-            DisplayWriteFieldEnumerated( dependencyInfo, deps[i].dependencyInfo,
-                                         CORCOMPILE_DEPENDENCY,
-                                         s_CorCompileDependencyInfoFlags, W(", "),
-                                         COR_INFO );
-#endif // !FEATURE_CORECLR
             DisplayStartStructureWithOffset( signAssemblyDef,
                                              DPtrToPreferredAddr(deps + i) + offsetof(CORCOMPILE_DEPENDENCY, signAssemblyDef),
                                              sizeof(deps[i]).signAssemblyDef,
@@ -3749,9 +3728,6 @@ const NativeImageDumper::EnumMnemonics s_MSDFlags[] =
 {
 #define MSD_ENTRY(f) NativeImageDumper::EnumMnemonics(ModuleSecurityDescriptorFlags_ ## f, W(#f))
     MSD_ENTRY(IsComputed),
-#ifdef FEATURE_APTCA
-    MSD_ENTRY(IsAPTCA),
-#endif // FEATURE_APTCA
     MSD_ENTRY(IsAllCritical),
     MSD_ENTRY(IsAllTransparent),
     MSD_ENTRY(IsTreatAsSafe),
@@ -4088,25 +4064,6 @@ void NativeImageDumper::DumpModule( PTR_Module module )
                  (int)(module->m_maxDynamicEntries
                  * sizeof(*(module->m_pDynamicStaticsInfo))));
 
-#ifdef FEATURE_CER
-    DisplayWriteFieldInt( m_dwReliabilityContract,
-                          module->m_dwReliabilityContract, Module, MODULE );
-
-    DisplayWriteFieldPointer( m_pCerPrepInfo,
-                              DataPtrToDisplay((TADDR)module->m_pCerPrepInfo),
-                              Module, MODULE );
-    DisplayWriteFieldPointer( m_pCerCrst, DataPtrToDisplay((TADDR)module->m_pCerCrst),
-                              Module, MODULE );
-    _ASSERTE(module->m_pCerPrepInfo == NULL && module->m_pCerCrst == NULL);
-
-    IF_OPT_OR(MODULE, SLIM_MODULE_TBLS)
-    {
-        PTR_CerNgenRootTable table( TO_TADDR(module->m_pCerNgenRootTable) );
-        DumpNgenRootTable( table, "m_pCerNgenRootTable",
-                           offsetof(Module, m_pCerNgenRootTable),
-                           fieldsize(Module, m_pCerNgenRootTable) );
-    }
-#endif
 
 
     _ASSERTE(module->m_debuggerSpecificData.m_pDynamicILCrst == NULL);
@@ -4154,87 +4111,6 @@ bool NativeImageDumper::isPrecode(TADDR maybePrecode)
     return !!module->IsZappedPrecode(maybePrecode);
 }
 
-#ifdef FEATURE_CER
-void NativeImageDumper::DumpNgenRootTable( PTR_CerNgenRootTable table,
-                                           const char * name, unsigned offset,
-                                           unsigned fieldSize )
-{
-    if( table == NULL )
-    {
-        IF_OPT(MODULE)
-        {
-            m_display->WriteFieldPointer( name, (unsigned)DPtrToPreferredAddr(table),
-                                          offset, fieldSize );
-        }
-        return;
-    }
-    IF_OPT(MODULE)
-    {
-        m_display->StartStructureWithOffset( name, offset, fieldSize,
-                                             DPtrToPreferredAddr(table),
-                                             sizeof(*table) ); 
-    }
-
-    DisplayWriteFieldPointer( m_cRoots, table->GetRootCount(),
-                              CerNgenRootTable, MODULE );
-    DisplayWriteFieldAddress( m_pRestoreBitmap,
-                              DataPtrToDisplay((TADDR)table->GetRestoreBitmap()),
-                              table->SizeOfRestoreBitmap(),
-                              CerNgenRootTable, MODULE );
-    DisplayWriteFieldInt( m_cSlots, table->m_cSlots, CerNgenRootTable,
-                          MODULE );
-    DisplayStartArray( "Roots", NULL, SLIM_MODULE_TBLS );
-
-    PTR_CerRoot roots(TO_TADDR(table->GetRoots()));
-    for( unsigned i = 0; i < table->GetRootCount(); ++i )
-    {
-        PTR_CerRoot root = roots + i;
-        DisplayStartStructure( "CerRoot", DPtrToPreferredAddr(root),
-                               sizeof(*root), SLIM_MODULE_TBLS );
-        WriteFieldMethodDesc( m_pRootMD,
-                              PTR_MethodDesc(TO_TADDR(root->m_pRootMD)),
-                              CerRoot, SLIM_MODULE_TBLS );
-
-        DisplayStartArray( "MethodContexts", NULL, SLIM_MODULE_TBLS );
-
-        PTR_MethodContextElement ctx(TO_TADDR(root->m_pList));
-        bool dumpedSentinel = false;
-        while( !dumpedSentinel )
-        {
-            DisplayStartStructure( "MethodContext",
-                                   DPtrToPreferredAddr(ctx),
-                                   sizeof(*ctx), SLIM_MODULE_TBLS );
-            if( ctx->m_pMethodDesc.IsNull() )
-                dumpedSentinel = true;
-            WriteFieldMethodDesc( m_pMethodDesc,
-                                  ctx->m_pMethodDesc.GetValue(),
-                                  MethodContextElement, SLIM_MODULE_TBLS );
-
-            if (!ctx->m_pExactMT.IsNull())
-            {
-                WriteFieldMethodTable( m_pExactMT,
-                                       ctx->m_pExactMT.GetValue(),
-                                       MethodContextElement, SLIM_MODULE_TBLS );    
-            }
-
-            DisplayEndStructure( SLIM_MODULE_TBLS ); //MethodContext
-            ++ctx;
-        }
-
-        DisplayEndArray( "Total Contexts", SLIM_MODULE_TBLS); //MethodContexts
-        DisplayEndStructure(SLIM_MODULE_TBLS); //CerRoot
-    }
-
-    DisplayEndArray( "Total Roots", SLIM_MODULE_TBLS ); //Roots
-
-    /* REVISIT_TODO Wed 10/05/2005
-     * m_cSlots seems to be set to something, but the number seems
-     * completely useless.  What is up with that?
-     */
-
-    DisplayEndStructure( MODULE ); //CERNgenRootTable
-}
-#endif // FEATURE_CER
 
 void NativeImageDumper::IterateTypeDefToMTCallback( TADDR mtTarget,
                                                     TADDR flags,
@@ -7643,9 +7519,7 @@ NativeImageDumper::DumpMethodTable( PTR_MethodTable mt, const char * name,
         else
         {
             _ASSERTE(mt->GetNumVtableSlots() > 0 );
-            /* REVISIT_TODO Tue 12/13/2005
-             * One liner copied from CrossDomainCalls.cpp
-             */
+
             unsigned size = sizeof(RemotableMethodInfo) * mt->GetNumVtableSlots();
             //one remotable method info for each method.
             m_display->StartStructureWithOffset( "OptionalMember_RemotableMethodInfo",
@@ -9039,14 +8913,6 @@ NativeImageDumper::DumpEEClassForMethodTable( PTR_MethodTable mt )
         DisplayWriteFieldInt( m_cbModuleDynamicID, pClassOptional->m_cbModuleDynamicID,
                               EEClassOptionalFields, EECLASSES );
 
-#ifdef FEATURE_CER
-        /* REVISIT_TODO Fri 10/14/2005
-         * Use the macros from ConstrainedExecutionRegion.cpp on this?
-         */
-        DisplayWriteFieldUInt( m_dwReliabilityContract,
-                               clazz->GetReliabilityContract(),
-                               EEClassOptionalFields, EECLASSES );
-#endif
 
         DisplayWriteFieldEnumerated( m_SecProps, clazz->GetSecurityProperties()->dwFlags,
                                      EEClassOptionalFields, s_SecurityProperties, W("|"),
diff --git a/src/debug/daccess/request.cpp b/src/debug/daccess/request.cpp
index 35ab5a0814..5caf54585a 100644
--- a/src/debug/daccess/request.cpp
+++ b/src/debug/daccess/request.cpp
@@ -2295,10 +2295,6 @@ ClrDataAccess::GetFailedAssemblyData(CLRDATA_ADDRESS assembly, unsigned int *pCo
     }
     else
     {
-#ifdef FEATURE_FUSION
-        if (pContext)
-            *pContext = pAssembly->context;
-#endif
         if (pResult)
             *pResult = pAssembly->error;
     }
@@ -2679,10 +2675,6 @@ ClrDataAccess::GetAssemblyData(CLRDATA_ADDRESS cdBaseDomainPtr, CLRDATA_ADDRESS
 
     if (pAssembly->GetManifestFile())
     {
-#ifdef FEATURE_FUSION    
-        assemblyData->LoadContext = pAssembly->GetManifestFile()->GetLoadContext();
-        assemblyData->dwLocationFlags = pAssembly->GetManifestFile()->GetLocationFlags();
-#endif
         
     }
 
diff --git a/src/debug/daccess/stdafx.h b/src/debug/daccess/stdafx.h
index 5c2d37688b..1c19ebff10 100644
--- a/src/debug/daccess/stdafx.h
+++ b/src/debug/daccess/stdafx.h
@@ -47,9 +47,6 @@
 #include <xcordebug.h>
 #include "dacimpl.h"
 
-#if defined(FEATURE_APPX_BINDER)
-#include <clrprivbinderappx.h>
-#endif // defined(FEATURE_APPX)
 
 #define STRSAFE_NO_DEPRECATE
 #include <strsafe.h>
diff --git a/src/debug/debug-pal/unix/twowaypipe.cpp b/src/debug/debug-pal/unix/twowaypipe.cpp
index db4599aeb9..9dfe1e3ecb 100644
--- a/src/debug/debug-pal/unix/twowaypipe.cpp
+++ b/src/debug/debug-pal/unix/twowaypipe.cpp
@@ -24,11 +24,16 @@ bool TwoWayPipe::CreateServer(DWORD id)
     PAL_GetTransportPipeName(m_inPipeName, id, "in");
     PAL_GetTransportPipeName(m_outPipeName, id, "out");
 
+    unlink(m_inPipeName);
+
     if (mkfifo(m_inPipeName, S_IRWXU) == -1)
     {
         return false;
     }
 
+
+    unlink(m_outPipeName);
+
     if (mkfifo(m_outPipeName, S_IRWXU) == -1)
     {
         unlink(m_inPipeName);
diff --git a/src/debug/di/cordb.cpp b/src/debug/di/cordb.cpp
index 497225fd67..76cfc85ffa 100644
--- a/src/debug/di/cordb.cpp
+++ b/src/debug/di/cordb.cpp
@@ -86,7 +86,7 @@ HINSTANCE       g_hInst;                // Instance handle to this piece of code
 //*****************************************************************************
 STDAPI CreateCordbObject(int iDebuggerVersion, IUnknown ** ppCordb)
 {
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_DBGIPC_TRANSPORT_DI) && !defined(FEATURE_CORESYSTEM)
+#if !defined(FEATURE_DBGIPC_TRANSPORT_DI) && !defined(FEATURE_CORESYSTEM)
     // This API should not be called for Windows CoreCLR unless we are doing interop-debugging
     // (which is only supported internally).  Use code:CoreCLRCreateCordbObject instead.
     if (CLRConfig::GetConfigValue(CLRConfig::INTERNAL_DbgEnableMixedModeDebugging) == 0)
@@ -94,7 +94,7 @@ STDAPI CreateCordbObject(int iDebuggerVersion, IUnknown ** ppCordb)
         _ASSERTE(!"Deprecated entry point CreateCordbObject() is called on Windows CoreCLR\n");
         return E_NOTIMPL;
     }
-#endif // FEATURE_CORECLR && !FEATURE_DBGIPC_TRANSPORT_DI
+#endif // !defined(FEATURE_DBGIPC_TRANSPORT_DI) && !defined(FEATURE_CORESYSTEM)
 
     if (ppCordb == NULL)
     {
@@ -108,7 +108,6 @@ STDAPI CreateCordbObject(int iDebuggerVersion, IUnknown ** ppCordb)
     return Cordb::CreateObject((CorDebugInterfaceVersion)iDebuggerVersion, IID_ICorDebug, (void **) ppCordb);
 }
 
-#if defined(FEATURE_CORECLR)
 //
 // Public API.  
 // Telesto Creation path - only way to debug multi-instance.  
@@ -161,7 +160,6 @@ STDAPI CoreCLRCreateCordbObject(int iDebuggerVersion, DWORD pid, HMODULE hmodTar
     return hr;
 }
 
-#endif // FEATURE_CORECLR
 
 
 
diff --git a/src/debug/di/process.cpp b/src/debug/di/process.cpp
index a5496eee54..927b438aff 100644
--- a/src/debug/di/process.cpp
+++ b/src/debug/di/process.cpp
@@ -2363,18 +2363,7 @@ HRESULT CordbProcess::EnumerateHandles(CorGCReferenceType types, ICorDebugGCRefe
 
 HRESULT CordbProcess::EnableNGENPolicy(CorDebugNGENPolicy ePolicy)
 {
-#ifdef FEATURE_CORECLR
     return E_NOTIMPL;
-#else
-    HRESULT hr = S_OK;
-    PUBLIC_API_BEGIN(this);
-
-    IDacDbiInterface* pDAC = GetProcess()->GetDAC();
-    hr = pDAC->EnableNGENPolicy(ePolicy);
-
-    PUBLIC_API_END(hr);
-    return hr;
-#endif
 }
 
 
@@ -7509,33 +7498,6 @@ void CordbProcess::VerifyControlBlock()
     // For Telesto, Dbi and Wks have a more flexible versioning allowed, as described by the Debugger
     // Version Protocol String in DEBUGGER_PROTOCOL_STRING in DbgIpcEvents.h. This allows different build
     // numbers, but the other protocol numbers should still match.
-#if !defined(FEATURE_CORECLR)
-    bool fSkipVerCheck = false;
-#if _DEBUG
-    // In debug builds, allow us to disable the version check to help with applying hotfixes.
-    // The hotfix may be built against a compatible IPC protocol, but have a slightly different build number.
-    fSkipVerCheck = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_DbgSkipVerCheck) != 0;
-#endif
-
-    if (!fSkipVerCheck)
-    {
-        //
-        // These asserts double check that the version of the Right Side matches the version of the left side.
-        //
-        // If you hit these asserts, it is probably because you rebuilt mscordbi without rebuilding mscorwks, or rebuilt
-        // mscorwks without rebuilding mscordbi. You might be able to ignore these asserts, but proceed at your own risk.
-        //
-        CONSISTENCY_CHECK_MSGF(VER_PRODUCTBUILD == GetDCB()->m_verMajor,
-            ("version of %s (%d) in the debuggee does not match version of mscordbi.dll (%d) in the debugger.\n"
-             "This means your setup is wrong. You can ignore this but proceed at your own risk.\n", 
-             MAIN_CLR_DLL_NAME_A, GetDCB()->m_verMajor, VER_PRODUCTBUILD));
-        CONSISTENCY_CHECK_MSGF(VER_PRODUCTBUILD_QFE == GetDCB()->m_verMinor,
-            ("QFE version of %s (%d) in the debuggee does not match QFE version of mscordbi.dll (%d) in the debugger.\n"
-             "Both dlls have build # (%d).\n"
-             "This means your setup is wrong. You can ignore this but proceed at your own risk.\n", 
-             MAIN_CLR_DLL_NAME_A, GetDCB()->m_verMinor, VER_PRODUCTBUILD_QFE, VER_PRODUCTBUILD));
-    }
-#endif // !FEATURE_CORECLR
 
     // These assertions verify that the debug manager is behaving correctly.
     // An assertion failure here means that the runtime version of the debuggee is different from the runtime version of
@@ -15210,11 +15172,7 @@ bool CordbProcess::IsCompatibleWith(DWORD clrMajorVersion)
     //  honored for SLv4.
     if (requiredVersion <= 0)
     {
-#if defined(FEATURE_CORECLR)
         requiredVersion = 2;
-#else
-        requiredVersion = 4;
-#endif
     }
 
     // Compare the version we were created for against the minimum required
diff --git a/src/debug/di/rsmain.cpp b/src/debug/di/rsmain.cpp
index 0f5778789f..2a93619b2a 100644
--- a/src/debug/di/rsmain.cpp
+++ b/src/debug/di/rsmain.cpp
@@ -1308,7 +1308,6 @@ HRESULT Cordb::WaitForIPCEventFromProcess(CordbProcess* process,
                                                        event);
 }
 
-#ifdef FEATURE_CORECLR
 HRESULT Cordb::SetTargetCLR(HMODULE hmodTargetCLR)
 {
     if (m_initialized)
@@ -1332,7 +1331,6 @@ HRESULT Cordb::SetTargetCLR(HMODULE hmodTargetCLR)
 
     return S_OK;
 }
-#endif // FEATURE_CORECLR
 
 //-----------------------------------------------------------
 // ICorDebug
@@ -1411,7 +1409,7 @@ HRESULT Cordb::SetUnmanagedHandler(ICorDebugUnmanagedCallback *pCallback)
 // It is currently supported on Mac CoreCLR, but that may change.
 bool Cordb::IsCreateProcessSupported()
 {
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_DBGIPC_TRANSPORT_DI)
+#if !defined(FEATURE_DBGIPC_TRANSPORT_DI)
     return false;
 #else 
     return true;
@@ -1425,14 +1423,14 @@ bool Cordb::IsInteropDebuggingSupported()
     // ICorDebug::SetUnmanagedHandler for details.
 #ifdef FEATURE_INTEROP_DEBUGGING
 
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_CORESYSTEM)
+#if !defined(FEATURE_CORESYSTEM)
     // Interop debugging is only supported internally on CoreCLR.
     // Check if the special reg key is set.  If not, then we don't allow interop debugging.
     if (CLRConfig::GetConfigValue(CLRConfig::INTERNAL_DbgEnableMixedModeDebugging) == 0)
     {
         return false;
     }
-#endif // FEATURE_CORECLR
+#endif // FEATURE_CORESYSTEM
 
     return true;
 #else
diff --git a/src/debug/di/rsmda.cpp b/src/debug/di/rsmda.cpp
index d69b448309..751fdc8938 100644
--- a/src/debug/di/rsmda.cpp
+++ b/src/debug/di/rsmda.cpp
@@ -150,11 +150,7 @@ HRESULT CordbMDA::GetName(ULONG32 cchName, ULONG32 * pcchName, __out_ecount_part
     HRESULT hr = S_OK;
     PUBLIC_API_BEGIN(this)
     {    
-#if defined(FEATURE_CORECLR)
         hr = E_NOTIMPL;
-#else  // !FEATURE_CORECLR
-        hr = CopyOutString(m_szName, cchName, pcchName, szName);
-#endif // FEATURE_CORECLR
     }
     PUBLIC_API_END(hr);
     return hr;
@@ -169,11 +165,7 @@ HRESULT CordbMDA::GetDescription(ULONG32 cchName, ULONG32 * pcchName, __out_ecou
     HRESULT hr = S_OK;
     PUBLIC_API_BEGIN(this)
     {        
-#if defined(FEATURE_CORECLR)
         hr = E_NOTIMPL;
-#else  // !FEATURE_CORECLR
-        hr = CopyOutString(m_szDescription, cchName, pcchName, szName);
-#endif // FEATURE_CORECLR
     }
     PUBLIC_API_END(hr);
     return hr;
@@ -190,11 +182,7 @@ HRESULT CordbMDA::GetXML(ULONG32 cchName, ULONG32 * pcchName, __out_ecount_part_
     HRESULT hr = S_OK;
     PUBLIC_API_BEGIN(this)
     {        
-#if defined(FEATURE_CORECLR)
         hr = E_NOTIMPL;
-#else  // !FEATURE_CORECLR
-        hr = CopyOutString(m_szXml, cchName, pcchName, szName);
-#endif // FEATURE_CORECLR
     }
     PUBLIC_API_END(hr);
     return hr;
@@ -208,12 +196,7 @@ HRESULT CordbMDA::GetFlags(CorDebugMDAFlags * pFlags)
     HRESULT hr = S_OK;
     PUBLIC_API_BEGIN(this)
     {        
-#if defined(FEATURE_CORECLR)
         hr = E_NOTIMPL;
-#else  // !FEATURE_CORECLR
-        ValidateOrThrow(pFlags);
-        *pFlags = this->m_flags;
-#endif // FEATURE_CORECLR
     }
     PUBLIC_API_END(hr);
     return hr;
@@ -229,13 +212,7 @@ HRESULT CordbMDA::GetOSThreadId(DWORD * pOsTid)
     HRESULT hr = S_OK;
     PUBLIC_API_BEGIN(this)
     {        
-#if defined(FEATURE_CORECLR)
         hr = E_NOTIMPL;
-#else  // !FEATURE_CORECLR
-        ValidateOrThrow(pOsTid);
-        
-        *pOsTid = this->m_dwOSTID;
-#endif // FEATURE_CORECLR
     }
     PUBLIC_API_END(hr);
     return hr;
diff --git a/src/debug/di/rspriv.h b/src/debug/di/rspriv.h
index 8f369b7414..d714517985 100644
--- a/src/debug/di/rspriv.h
+++ b/src/debug/di/rspriv.h
@@ -2199,9 +2199,7 @@ public:
     // ICorDebug
     //-----------------------------------------------------------
 
-#ifdef FEATURE_CORECLR
     HRESULT SetTargetCLR(HMODULE hmodTargetCLR);
-#endif // FEATURE_CORECLR
 
     COM_METHOD Initialize();
     COM_METHOD Terminate();
diff --git a/src/debug/di/shimprocess.cpp b/src/debug/di/shimprocess.cpp
index a6fc15407e..46c35fdc2b 100644
--- a/src/debug/di/shimprocess.cpp
+++ b/src/debug/di/shimprocess.cpp
@@ -1850,11 +1850,7 @@ HMODULE ShimProcess::GetDacModule()
     //   mscordaccore.dll  <-- coreclr
     //   mscordacwks.dll   <-- desktop
     PCWSTR eeFlavor = 
-#if defined(FEATURE_MAIN_CLR_MODULE_USES_CORE_NAME)
         W("mscordaccore.dll");
-#else
-        W("mscordacwks.dll");
-#endif
     
 #endif // FEATURE_PAL
     wszAccessDllPath.Append(eeFlavor);
diff --git a/src/debug/ee/dactable.cpp b/src/debug/ee/dactable.cpp
index c37bbed744..a54fa7515c 100644
--- a/src/debug/ee/dactable.cpp
+++ b/src/debug/ee/dactable.cpp
@@ -40,11 +40,7 @@ extern DWORD gThreadTLSIndex;
 extern DWORD gAppDomainTLSIndex;
 
 #ifdef FEATURE_APPX
-#if defined(FEATURE_CORECLR)
 extern BOOL g_fAppX;
-#else
-extern PTR_AppXRTInfo g_pAppXRTInfo;
-#endif
 #endif // FEATURE_APPX
 
 DacGlobals g_dacTable;
diff --git a/src/debug/ee/debugger.cpp b/src/debug/ee/debugger.cpp
index 1f2126b9f0..df2e9a444e 100644
--- a/src/debug/ee/debugger.cpp
+++ b/src/debug/ee/debugger.cpp
@@ -43,9 +43,7 @@
 #include "datatest.h"
 #endif // TEST_DATA_CONSISTENCY
 
-#if defined(FEATURE_CORECLR)
 #include "dbgenginemetrics.h"
-#endif // FEATURE_CORECLR
 
 #include "../../vm/rejit.h"
 
@@ -1896,7 +1894,7 @@ void Debugger::SendCreateProcess(DebuggerLockHolder * pDbgLockHolder)
     pDbgLockHolder->Acquire();
 }
 
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_PAL)
+#if !defined(FEATURE_PAL)
 
 HANDLE g_hContinueStartupEvent = INVALID_HANDLE_VALUE;
 
@@ -1966,7 +1964,7 @@ void NotifyDebuggerOfTelestoStartup()
     g_hContinueStartupEvent = NULL;
 }
 
-#endif // FEATURE_CORECLR && !FEATURE_PAL
+#endif // !FEATURE_PAL
 
 //---------------------------------------------------------------------------------------
 //
@@ -1999,7 +1997,7 @@ HRESULT Debugger::Startup(void)
 
     _ASSERTE(g_pEEInterface != NULL);
 
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_PAL)
+#if !defined(FEATURE_PAL)
     if (IsWatsonEnabled() || IsTelestoDebugPackInstalled())
     {
         // Iff the debug pack is installed, then go through the telesto debugging pipeline.
@@ -2018,7 +2016,7 @@ HRESULT Debugger::Startup(void)
         // The transport requires the debug pack to be present.  Otherwise it'll raise a fatal error.
         return S_FALSE;
     }
-#endif // FEATURE_CORECLR && !FEATURE_PAL
+#endif // !FEATURE_PAL
 
     {
         DebuggerLockHolder dbgLockHolder(this);
@@ -9589,23 +9587,6 @@ void Debugger::LoadModule(Module* pRuntimeModule,
     SENDIPCEVENT_BEGIN(this, pThread);
 
 
-#ifdef FEATURE_FUSION
-    // Fix for issue Whidbey - 106398
-    // Populate the pdb to fusion cache.
-
-    //
-    if (pRuntimeModule->IsIStream() == FALSE)
-    {
-        SUPPRESS_ALLOCATION_ASSERTS_IN_THIS_SCOPE;
-
-        HRESULT hrCopy = S_OK;
-        EX_TRY
-        {
-            pRuntimeModule->FusionCopyPDBs(pRuntimeModule->GetPath());
-        }
-        EX_CATCH_HRESULT(hrCopy); // ignore failures
-    }
-#endif // FEATURE_FUSION
 
     DebuggerIPCEvent* ipce = NULL;
 
@@ -9804,7 +9785,6 @@ void Debugger::LoadModuleFinished(Module * pRuntimeModule, AppDomain * pAppDomai
 //   Use code:Debugger.SendUpdateModuleSymsEventAndBlock for that.
 void Debugger::SendRawUpdateModuleSymsEvent(Module *pRuntimeModule, AppDomain *pAppDomain)
 {
-// @telest - do we need an #ifdef FEATURE_FUSION here?
     CONTRACTL
     {
         NOTHROW;
@@ -14964,21 +14944,6 @@ HRESULT Debugger::CopyModulePdb(Module* pRuntimeModule)
     }
 
     HRESULT hr = S_OK;
-#ifdef FEATURE_FUSION
-    //
-    // Populate the pdb to fusion cache.
-    //
-    if (pRuntimeModule->IsIStream() == FALSE)
-    {
-        SUPPRESS_ALLOCATION_ASSERTS_IN_THIS_SCOPE;
-        
-        EX_TRY
-        {
-            pRuntimeModule->FusionCopyPDBs(pRuntimeModule->GetPath());
-        }
-        EX_CATCH_HRESULT(hr); // ignore failures
-    }
-#endif // FEATURE_FUSION
 
     return hr;
 }
diff --git a/src/debug/ee/debugger.inl b/src/debug/ee/debugger.inl
index 54ac8b9316..57372868c0 100644
--- a/src/debug/ee/debugger.inl
+++ b/src/debug/ee/debugger.inl
@@ -235,13 +235,13 @@ inline void FuncEvalFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
     // Update all registers in the reg display from the CONTEXT we stored when the thread was hijacked for this func
     // eval. We have to update all registers, not just the callee saved registers, because we can hijack a thread at any
     // point for a func eval, not just at a call site.
-    pRD->pEdi = &(pDE->m_context.Edi);
-    pRD->pEsi = &(pDE->m_context.Esi);
-    pRD->pEbx = &(pDE->m_context.Ebx);
-    pRD->pEdx = &(pDE->m_context.Edx);
-    pRD->pEcx = &(pDE->m_context.Ecx);
-    pRD->pEax = &(pDE->m_context.Eax);
-    pRD->pEbp = &(pDE->m_context.Ebp);
+    pRD->SetEdiLocation(&(pDE->m_context.Edi));
+    pRD->SetEsiLocation(&(pDE->m_context.Esi));
+    pRD->SetEbxLocation(&(pDE->m_context.Ebx));
+    pRD->SetEdxLocation(&(pDE->m_context.Edx));
+    pRD->SetEcxLocation(&(pDE->m_context.Ecx));
+    pRD->SetEaxLocation(&(pDE->m_context.Eax));
+    pRD->SetEbpLocation(&(pDE->m_context.Ebp));
     pRD->SP   = (DWORD)GetSP(&pDE->m_context);
     pRD->PCTAddr = GetReturnAddressPtr();
     pRD->ControlPC = *PTR_PCODE(pRD->PCTAddr);
diff --git a/src/debug/ee/i386/x86walker.cpp b/src/debug/ee/i386/x86walker.cpp
index 5266668c3f..8b62797484 100644
--- a/src/debug/ee/i386/x86walker.cpp
+++ b/src/debug/ee/i386/x86walker.cpp
@@ -292,28 +292,28 @@ DWORD NativeWalker::GetRegisterValue(int registerNumber)
     switch (registerNumber)
     {
     case 0:
-        return *m_registers->pEax;
+        return *m_registers->GetEaxLocation();
         break;
     case 1:
-        return *m_registers->pEcx;
+        return *m_registers->GetEcxLocation();
         break;
     case 2:
-        return *m_registers->pEdx;
+        return *m_registers->GetEdxLocation();
         break;
     case 3:
-        return *m_registers->pEbx;
+        return *m_registers->GetEbxLocation();
         break;
     case 4:
         return m_registers->SP;
         break;
     case 5:
-        return *m_registers->pEbp;
+        return *m_registers->GetEbpLocation();
         break;
     case 6:
-        return *m_registers->pEsi;
+        return *m_registers->GetEsiLocation();
         break;
     case 7:
-        return *m_registers->pEdi;
+        return *m_registers->GetEdiLocation();
         break;
     default:
         _ASSERTE(!"Invalid register number!");
diff --git a/src/debug/ee/stdafx.h b/src/debug/ee/stdafx.h
index 7ccfa8d984..519ce510c4 100644
--- a/src/debug/ee/stdafx.h
+++ b/src/debug/ee/stdafx.h
@@ -12,10 +12,6 @@
 #include <stdio.h>
 
 #include <windows.h>
-#if !defined(FEATURE_CORECLR)
-#undef GetCurrentTime // works around a macro def conflict of GetCurrentTime
-#include <windows.ui.xaml.h>
-#endif // !FEATURE_CORECLR
 
 #include <switches.h>
 #include <winwrap.h>
diff --git a/src/debug/inc/dbgtargetcontext.h b/src/debug/inc/dbgtargetcontext.h
index 22b1c84096..c2b45ee059 100644
--- a/src/debug/inc/dbgtargetcontext.h
+++ b/src/debug/inc/dbgtargetcontext.h
@@ -371,6 +371,14 @@ typedef DECLSPEC_ALIGN(8) struct {
 #define DT_CONTEXT_FULL (DT_CONTEXT_CONTROL | DT_CONTEXT_INTEGER | DT_CONTEXT_FLOATING_POINT)
 #define DT_CONTEXT_ALL (DT_CONTEXT_CONTROL | DT_CONTEXT_INTEGER | DT_CONTEXT_FLOATING_POINT | DT_CONTEXT_DEBUG_REGISTERS)
 
+#define DT_ARM64_MAX_BREAKPOINTS     8
+#define DT_ARM64_MAX_WATCHPOINTS     2
+
+typedef struct {
+    ULONGLONG Low;
+    LONGLONG High;
+} DT_NEON128;
+
 typedef DECLSPEC_ALIGN(16) struct {
     //
     // Control flags.
@@ -426,7 +434,7 @@ typedef DECLSPEC_ALIGN(16) struct {
     // Floating Point/NEON Registers
     //
 
-    /* +0x110 */ NEON128 V[32];
+    /* +0x110 */ DT_NEON128 V[32];
     /* +0x310 */ DWORD Fpcr;
     /* +0x314 */ DWORD Fpsr;
 
@@ -434,10 +442,10 @@ typedef DECLSPEC_ALIGN(16) struct {
     // Debug registers
     //
 
-    /* +0x318 */ DWORD Bcr[ARM64_MAX_BREAKPOINTS];
-    /* +0x338 */ DWORD64 Bvr[ARM64_MAX_BREAKPOINTS];
-    /* +0x378 */ DWORD Wcr[ARM64_MAX_WATCHPOINTS];
-    /* +0x380 */ DWORD64 Wvr[ARM64_MAX_WATCHPOINTS];
+    /* +0x318 */ DWORD Bcr[DT_ARM64_MAX_BREAKPOINTS];
+    /* +0x338 */ DWORD64 Bvr[DT_ARM64_MAX_BREAKPOINTS];
+    /* +0x378 */ DWORD Wcr[DT_ARM64_MAX_WATCHPOINTS];
+    /* +0x380 */ DWORD64 Wvr[DT_ARM64_MAX_WATCHPOINTS];
     /* +0x390 */
 
 } DT_CONTEXT;
diff --git a/src/debug/shared/i386/primitives.cpp b/src/debug/shared/i386/primitives.cpp
index d3c7c76b8d..ab22a5d4b1 100644
--- a/src/debug/shared/i386/primitives.cpp
+++ b/src/debug/shared/i386/primitives.cpp
@@ -88,12 +88,12 @@ void SetDebuggerREGDISPLAYFromREGDISPLAY(DebuggerREGDISPLAY* pDRD, REGDISPLAY* p
     // Frame pointer        
     LPVOID FPAddress = GetRegdisplayFPAddress(pRD);
     pDRD->FP  = (FPAddress == NULL ? 0 : *((SIZE_T *)FPAddress));
-    pDRD->Edi  = (pRD->pEdi == NULL ? 0 : *(pRD->pEdi));
-    pDRD->Esi  = (pRD->pEsi == NULL ? 0 : *(pRD->pEsi));
-    pDRD->Ebx  = (pRD->pEbx == NULL ? 0 : *(pRD->pEbx));
-    pDRD->Edx  = (pRD->pEdx == NULL ? 0 : *(pRD->pEdx));
-    pDRD->Ecx  = (pRD->pEcx == NULL ? 0 : *(pRD->pEcx));
-    pDRD->Eax  = (pRD->pEax == NULL ? 0 : *(pRD->pEax));
+    pDRD->Edi = (pRD->GetEdiLocation() == NULL ? 0 : *pRD->GetEdiLocation());
+    pDRD->Esi = (pRD->GetEsiLocation() == NULL ? 0 : *pRD->GetEsiLocation());
+    pDRD->Ebx = (pRD->GetEbxLocation() == NULL ? 0 : *pRD->GetEbxLocation());
+    pDRD->Edx = (pRD->GetEdxLocation() == NULL ? 0 : *pRD->GetEdxLocation());
+    pDRD->Ecx = (pRD->GetEcxLocation() == NULL ? 0 : *pRD->GetEcxLocation());
+    pDRD->Eax = (pRD->GetEsiLocation() == NULL ? 0 : *pRD->GetEaxLocation());
 
 #if defined(USE_REMOTE_REGISTER_ADDRESS)
     pDRD->pFP = PushedRegAddr(pRD, FPAddress);
diff --git a/src/dlls/dbgshim/dbgshim.cpp b/src/dlls/dbgshim/dbgshim.cpp
index 5f15cabe97..39c966a3ce 100644
--- a/src/dlls/dbgshim/dbgshim.cpp
+++ b/src/dlls/dbgshim/dbgshim.cpp
@@ -1818,10 +1818,8 @@ CLRCreateInstance(
     
 #if defined(FEATURE_CORESYSTEM)
     GUID skuId = CLR_ID_ONECORE_CLR;
-#elif defined(FEATURE_CORECLR)
-    GUID skuId = CLR_ID_CORECLR;
 #else
-    GUID skuId = CLR_ID_V4_DESKTOP;
+    GUID skuId = CLR_ID_CORECLR;
 #endif
     
     CLRDebuggingImpl *pDebuggingImpl = new CLRDebuggingImpl(skuId);
diff --git a/src/dlls/mscordbi/mscordbi.src b/src/dlls/mscordbi/mscordbi.src
index 0baa49537e..3b1f37720d 100644
--- a/src/dlls/mscordbi/mscordbi.src
+++ b/src/dlls/mscordbi/mscordbi.src
@@ -18,9 +18,7 @@ EXPORTS
     OpenVirtualProcess private 
     OpenVirtualProcess2
 
-#ifdef FEATURE_CORECLR
     CoreCLRCreateCordbObject private
-#endif // FEATURE_CORECLR
 
 #if defined(FEATURE_DBGIPC_TRANSPORT_DI)
     DllGetClassObject private
diff --git a/src/dlls/mscoree/mscoree.cpp b/src/dlls/mscoree/mscoree.cpp
index 8ec460eedd..f33f0955e4 100644
--- a/src/dlls/mscoree/mscoree.cpp
+++ b/src/dlls/mscoree/mscoree.cpp
@@ -383,30 +383,6 @@ STDAPI ReOpenMetaDataWithMemoryEx(
     return hr;
 }
 
-#ifdef FEATURE_FUSION
-// ---------------------------------------------------------------------------
-// %%Function: GetAssemblyMDImport
-// This function gets the IMDAssemblyImport given the filename
-// ---------------------------------------------------------------------------
-STDAPI GetAssemblyMDImport(             // Return code.
-    LPCWSTR     szFileName,             // [in] The scope to open.
-    REFIID      riid,                   // [in] The interface desired.
-    IUnknown    **ppIUnk)               // [out] Return interface on success.
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-    HRESULT hr=S_OK;
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    hr=GetAssemblyMDInternalImport(szFileName, riid, ppIUnk);
-    END_ENTRYPOINT_NOTHROW;
-    return hr;
-}
-#endif
 
 #ifndef CROSSGEN_COMPILE
 // ---------------------------------------------------------------------------
diff --git a/src/dlls/mscoree/mscorwks_ntdef.src b/src/dlls/mscoree/mscorwks_ntdef.src
index 13656d7aca..8115475418 100644
--- a/src/dlls/mscoree/mscorwks_ntdef.src
+++ b/src/dlls/mscoree/mscorwks_ntdef.src
@@ -7,7 +7,6 @@ EXPORTS
 ;   Common exports
 ;
 
-#ifdef FEATURE_CORECLR
 
 
         GetCLRRuntimeHost
@@ -29,170 +28,3 @@ EXPORTS
         GetMetaDataInternalInterfaceFromPublic
         GetMetaDataPublicInterfaceFromInternal
 
-#else //FEATURE_CORECLR 
-
-;   VM
-        DllGetClassObjectInternal                               private
-        DllGetActivationFactoryImpl                             private
-        GetClassActivatorForApplicationImpl                     private
-        MetaDataGetDispenser
-        GetMetaDataInternalInterface
-        GetMetaDataInternalInterfaceFromPublic
-        GetMetaDataPublicInterfaceFromInternal
-        _CorExeMain2
-        _CorDllMain                                                     
-        CoInitializeEE
-        CoUninitializeEE
-        CoInitializeCor                                                 
-        CoUninitializeCor                                               
-        PostErrorVA                                               
-
-        LoadStringRC                                            @22
-        ReOpenMetaDataWithMemory                                @23
-
-        LoadStringRCEx
-	ReOpenMetaDataWithMemoryEx				private
-        TranslateSecurityAttributes                             private
-        GetPermissionRequests
-        CorExitProcess
-#ifdef FEATURE_CLICKONCE
-        CorLaunchApplication
-#endif
-
-        CorMarkThreadInThreadPool
-
-        LogHelp_LogAssert                                       private
-        LogHelp_NoGuiOnAssert                                   private
-        LogHelp_TerminateOnAssert                               private
-
-        GetPrivateContextsPerfCounters                          private
-
-        GetAssemblyMDImport                                     private
-
-        IEE                                                     private
-        
-#ifdef FEATURE_FUSION        
-; Fusion
-        GetCachePath
-        CreateAssemblyNameObject
-        CreateApplicationContext
-        CreateAssemblyCache
-        CreateAssemblyEnum       
-        CreateHistoryReader
-        LookupHistoryAssembly
-        GetHistoryFileDirectory
-        PreBindAssembly
-        PreBindAssemblyEx
-        SetMSIHandleForLogging
-        NukeDownloadedCache      
-        ClearDownloadCache      
-        GetCLRIdentityManager
-        CreateAssemblyConfigCookie
-        DestroyAssemblyConfigCookie
-        CompareAssemblyIdentity
-        CompareAssemblyIdentityWithConfig
-        InitializeFusion                                        private
-        CopyPDBs                                                private
-        DeleteShadowCache                                       private
-#endif        
-; Strong Name
-        StrongNameErrorInfo
-        StrongNameFreeBuffer
-        StrongNameKeyGen
-        StrongNameKeyGenEx
-        StrongNameKeyInstall
-        StrongNameKeyDelete
-        StrongNameGetPublicKey
-        StrongNameSignatureGeneration
-        StrongNameSignatureGenerationEx
-        StrongNameTokenFromAssembly
-        StrongNameTokenFromAssemblyEx
-        StrongNameTokenFromPublicKey
-        StrongNameSignatureVerification
-        StrongNameCompareAssemblies
-        StrongNameHashSize
-        StrongNameSignatureSize
-        StrongNameSignatureVerificationEx
-        GetHashFromAssemblyFile
-        GetHashFromAssemblyFileW
-        GetHashFromBlob
-        GetHashFromFile
-        GetHashFromFileW
-        GetHashFromHandle
-        StrongNameSignatureVerificationFromImage
-        StrongNameGetBlob
-        StrongNameGetBlobFromImage
-        StrongNameSignatureVerificationEx2
-        StrongNameGetPublicKeyEx
-        StrongNameDigestGenerate
-        StrongNameDigestSign
-        StrongNameDigestEmbed
-
-;   VM
-#ifdef FEATURE_COMINTEROP
-        DllCanUnloadNowInternal                                 private
-#endif
-#ifdef FEATURE_COMINTEROP_REGISTRATION
-        ClrCreateManagedInstance
-        DllRegisterServerInternal                               private
-        DllUnregisterServerInternal                             private
-        EEDllRegisterServer                                     private
-        EEDllUnregisterServer                                   private
-#endif
-        SetRuntimeInfo
-        _CorExeMain                                                     
-#ifdef FEATURE_MIXEDMODE
-        CorDllMainForThunk                                      private
-#endif
-        CoEEShutDownCOM
-#ifdef FEATURE_PREJIT
-        NGenCreateNGenWorker
-        LegacyNGenCreateZapper
-        LegacyNGenFreeZapper
-        LegacyNGenTryEnumerateFusionCache
-        LegacyNGenCompile
-#endif
-        GetAddrOfContractShutoffFlag                            private
-        GetCLRFunction                                          private
-
-#ifdef PROFILING_SUPPORTED
-        AttachProfiler                                          private
-#endif // PROFILING_SUPPORTED
-        
-#ifdef FEATURE_FUSION
-;   Fusion
-        CreateInstallReferenceEnum
-        InstallCustomModule
-        GetAssemblyIdentityFromFile
-        GetIdentityAuthority                                    private
-        ParseManifest                                           private
-        CreateCMSFromXml                                        private
-        GetAppIdAuthority                                       private
-        GetUserStore                                            private
-        CreateActContext                                        private
-        GetUserStateManager                                     private
-;        CreateCMSFromXmlInternal                                private        
-;        GetUserStoreInternal                                    private
-;        ParseManifestInternal                                   private
-;        CreateActContextInternal                                private
-;        GetUserStateManagerInternal                             private
-	CertCreateAuthenticodeLicense				private
-	CertTimestampAuthenticodeLicense			private
-	CertVerifyAuthenticodeLicense				private
-	CertFreeAuthenticodeSignerInfo				private
-	CertFreeAuthenticodeTimestamperInfo			private
-	_AxlPublicKeyBlobToPublicKeyToken			private
-	_AxlRSAKeyValueToPublicKeyToken				private
-        _AxlGetIssuerPublicKeyHash                              private
-#endif // FEATURE_FUSION
-       
-;
-;   win64 common 
-; 
-#ifdef _WIN64
-        GetRuntimeStackWalkInfo
-#endif
-
-        Nirvana_Dummy                                           @24 NONAME PRIVATE
-
-#endif //FEATURE_CORECLR
diff --git a/src/dlls/mscorrc/fuslog.rc b/src/dlls/mscorrc/fuslog.rc
index 8a106fa084..c02d1b692b 100644
--- a/src/dlls/mscorrc/fuslog.rc
+++ b/src/dlls/mscorrc/fuslog.rc
@@ -3,295 +3,6 @@
 // See the LICENSE file in the project root for more information.
 #include "fusres.h"
 
-#ifdef FEATURE_FUSION
-
-STRINGTABLE DISCARDABLE
-BEGIN
-    ID_FUSLOG_ASSEMBLY_CREATION_FAILURE              L"WRN: Found match in cache, but cannot create assembly from the cache information."
-    ID_FUSLOG_ASSEMBLY_LOOKUP_FAILURE                L"LOG: GAC Lookup was unsuccessful."
-    ID_FUSLOG_ISEQUAL_DIFF_NAME                      L"WRN: Comparing the assembly name resulted in the mismatch: NAME"
-    ID_FUSLOG_ISEQUAL_DIFF_VERSION_MAJOR             L"WRN: Comparing the assembly name resulted in the mismatch: Major Version"
-    ID_FUSLOG_ISEQUAL_DIFF_VERSION_MINOR             L"WRN: Comparing the assembly name resulted in the mismatch: Minor Version"
-    ID_FUSLOG_ISEQUAL_DIFF_VERSION_REVISION          L"WRN: Comparing the assembly name resulted in the mismatch: Revision Number"
-    ID_FUSLOG_ISEQUAL_DIFF_VERSION_BUILD             L"WRN: Comparing the assembly name resulted in the mismatch: Build Number"
-    ID_FUSLOG_ISEQUAL_DIFF_PUBLIC_KEY_TOKEN          L"WRN: Comparing the assembly name resulted in the mismatch: PUBLIC KEY TOKEN"
-    ID_FUSLOG_ISEQUAL_DIFF_CULTURE                   L"WRN: Comparing the assembly name resulted in the mismatch: CULTURE"
-    ID_FUSLOG_ISEQUAL_DIFF_CUSTOM                    L"WRN: Comparing the assembly name resulted in the mismatch: CUSTOM"
-    ID_FUSLOG_CANONICALIZATION_ERROR                 L"ERR: Fatal error occurred attempting to canonicalize the codebase for this bind."
-END
-
-STRINGTABLE DISCARDABLE
-BEGIN
-    ID_FUSLOG_POLICY_CACHE_FAILURE                   L"LOG: Unable to prepare policy cache object."
-    ID_FUSLOG_APP_CFG_PIGGYBACK                      L"LOG: Download of application configuration file is already in progress."
-    ID_FUSLOG_PREBIND_INFO_START                     L"=== Pre-bind state information ==="
-    ID_FUSLOG_PREBIND_INFO_DISPLAY_NAME              L"LOG: DisplayName = %ws\n (%ws)"
-    ID_FUSLOG_PREBIND_INFO_WHERE_REF                 L"LOG: Where-ref bind. Location = %ws"
-    ID_FUSLOG_PREBIND_INFO_APPBASE                   L"LOG: Appbase = %ws"
-    ID_FUSLOG_PREBIND_INFO_PRIVATE_PATH              L"LOG: Initial PrivatePath = %ws"
-    ID_FUSLOG_PREBIND_INFO_DYNAMIC_BASE              L"LOG: Dynamic Base = %ws"
-    ID_FUSLOG_PREBIND_INFO_CACHE_BASE                L"LOG: Cache Base = %ws"
-    ID_FUSLOG_PREBIND_INFO_APP_NAME                  L"LOG: AppName = %ws"
-    ID_FUSLOG_PREBIND_INFO_END                       L"==="
-    ID_FUSLOG_APP_CFG_DOWNLOAD                       L"LOG: Attempting application configuration file download."
-    ID_FUSLOG_APP_CFG_DOWNLOAD_LOCATION              L"LOG: Download of application configuration file was attempted from %ws."
-    ID_FUSLOG_CFG_NOT_EXIST                          L"LOG: Configuration file %ws does not exist."
-    ID_FUSLOG_APP_CFG_FOUND                          L"LOG: Found application configuration file (%ws)."
-END
-
-STRINGTABLE DISCARDABLE
-BEGIN
-    ID_FUSLOG_DEVOVERRIDE_REF_DEF_MISMATCH           L"LOG: Found assembly in DEVOVERRIDE location [%ws], but the assembly reference did not match the assembly definition found."
-    ID_FUSLOG_DEVOVERRIDE_SIGNATURE_CHECK_FAILED     L"LOG: Found assembly in DEVOVERRIDE location [%ws], but signature validation failed."
-    ID_FUSLOG_XML_PRIVATE_ASM_REDIRECT               L"WRN: Binding redirects specified for assemblies without strong names are ignored."
-    ID_FUSLOG_XML_PARSE_ERROR_CODE                   L"ERR: There was an error parsing XML (hr = 0x%x)."
-    ID_FUSLOG_XML_ASSEMBLYIDENTITY_MISSING_NAME      L"WRN: The assemblyIdentity was not processed because the name attribute was missing."
-    ID_FUSLOG_XML_BINDINGREDIRECT_INSUFFICIENT_DATA  L"WRN: bindingRedirect tag not processed due to insufficient data."
-    ID_FUSLOG_XML_CODEBASE_HREF_MISSING              L"WRN: codeBase tag not processed because href not present."
-    ID_FUSLOG_XML_MULTIPLE_IDENTITIES                L"WRN: Invalid XML. Encountered more than 1 assemblyIdentity inside single dependentAssembly. Ignoring."
-    ID_FUSLOG_PRIVATE_PATH_DUPLICATE                 L"WRN: Private path set. Ignoring duplicate entry."
-    ID_FUSLOG_POLICY_NOT_APPLIED                     L"LOG: Policy not being applied to reference at this time (private, custom, partial, or location-based assembly bind)."
-    ID_FUSLOG_NO_APP_CONFIG_FILE                     L"LOG: No application configuration file found."
-    ID_FUSLOG_APP_CONFIG_FILE                        L"LOG: Using application configuration file: %ws"
-    ID_FUSLOG_HOST_CONFIG_FILE                       L"LOG: Using host configuration file: %ws"
-    ID_FUSLOG_HOST_CONFIG_FILE_MISSING               L"LOG: Host configuration file not found."
-    ID_FUSLOG_XML_INVALID_PROCESSORARCHITECTURE      L"WRN: Invalid processor architecture is specified in assemblyIdentity. Valid processor architectures are neutral/x86/IA64/AMD64."
-END
-    
-STRINGTABLE DISCARDABLE
-BEGIN
-    ID_FUSLOG_HOST_CFG_REDIRECT                      L"LOG: Redirect found in host configuration file: %ws redirected to %ws."
-    ID_FUSLOG_HOST_CFG_NO_REDIRECT                   L"LOG: No redirect found in host configuration file."
-    ID_FUSLOG_APP_CFG_REDIRECT                       L"LOG: Redirect found in application configuration file: %ws redirected to %ws."
-    ID_FUSLOG_APP_CFG_SAFE_MODE                      L"LOG: Safe mode is set (publisher policy disallowed)."
-    ID_FUSLOG_PUB_CFG_MISSING                        L"LOG: Publisher policy file is not found."
-    ID_FUSLOG_PUB_CFG_FOUND                          L"LOG: Publisher policy file is found at %ws."
-    ID_FUSLOG_PUB_CFG_REDIRECT                       L"LOG: Publisher policy file redirect is found: %ws redirected to %ws."
-    ID_FUSLOG_PUBLISHER_POLICY_CONFIG_MISSING        L"ERR: Publisher policy assembly is found, but there is no config file."
-    ID_FUSLOG_MACHINE_CFG_MISSING                    L"LOG: Machine configuration file does not exist at %ws."
-    ID_FUSLOG_MACHINE_CFG_FOUND                      L"LOG: Using machine configuration file from %ws."
-    ID_FUSLOG_MACHINE_CFG_REDIRECT                   L"LOG: Machine configuration policy file redirect found: %ws redirected to %ws."
-    ID_FUSLOG_REDIRECT_NO_CODEBASE                   L"WRN: Binding redirect encountered, but could not retrieve codebase."
-    ID_FUSLOG_POLICY_CODEBASE                        L"LOG: Using codebase from policy file: %ws."
-    ID_FUSLOG_POST_POLICY_REFERENCE                  L"LOG: Post-policy reference: %ws"
-    ID_FUSLOG_APPLY_POLICY_FAILED                    L"ERR: Failed to apply policy (hr = 0x%x)."
-    ID_FUSLOG_CFG_PRIVATE_PATH                       L"LOG: Private path hint found in configuration file: %s."
-    ID_FUSLOG_CAB_ASM_NOT_FOUND                      L"LOG: Unable to find target assembly in CAB file."
-END
-
-STRINGTABLE DISCARDABLE
-BEGIN
-    ID_FUSLOG_XML_PARSE_ERROR_FILE                   L"WRN: Error parsing XML file %ws. Ignoring."
-    ID_FUSLOG_CODEBASE_RETRIEVE_FAILURE              L"ERR: A fatal error occurred when retrieving next codebase for download (hr = 0x%x)."
-    ID_FUSLOG_ATTEMPT_NEW_DOWNLOAD                   L"LOG: Attempting download of new URL %ws."
-    ID_FUSLOG_LOADER_PERMISSION_CHECK_FAILURE        L"ERR: Loader location access permission check failed for URL %ws (hr = 0x%x)."
-    ID_FUSLOG_PROBE_FAIL_BUT_ASM_FOUND               L"LOG: Probing in application directory failed, but assembly bind was still able to complete."
-    ID_FUSLOG_ASM_SETUP_FAILURE                      L"ERR: Failed to complete setup of assembly (hr = 0x%x). Probing terminated."
-    ID_FUSLOG_PREDOWNLOAD_FAILURE                    L"ERR: Unrecoverable error occurred during pre-download check (hr = 0x%x)."
-    ID_FUSLOG_URLMON_MISSING                         L"WRN: Unable to find URLMON.DLL. Assemblies cannot be downloaded."
-    ID_FUSLOG_DOWNLOAD_PIGGYBACK                     L"LOG: Duplicate download found. Re-using the download in progress."
-    ID_FUSLOG_DOWNLOAD_SUCCESS                       L"LOG: Assembly download was successful. Attempting setup of file: %ws"
-    ID_FUSLOG_LAST_MOD_FAILURE                       L"ERR: Unable to extract last modified time from %ws."
-    ID_FUSLOG_MSI_CODEBASE_UNSUPPORTED               L"WRN: Current version does not support CODEBASEs to .MSI files. Setup is unable to complete."
-    ID_FUSLOG_FAILED_PROBING                         L"LOG: All probing URLs attempted and failed."
-    ID_FUSLOG_PARTIAL_GAC_UNSUPPORTED                L"ERR: Partial binds to assemblies in the global assembly cache are not supported."
-    ID_FUSLOG_GAC_LOOKUP_SUCCESS                     L"LOG: Lookup in global assembly cache succeeded."
-    ID_FUSLOG_MSI_INSTALL_ATTEMPT                    L"LOG: Attempting to install assembly using Windows Installer."
-    ID_FUSLOG_PREVIOUS_FAILED                        L"LOG: The same bind was seen before, and was failed with hr = 0x%x."
-END    
-
-
-STRINGTABLE DISCARDABLE
-BEGIN
-    ID_FUSLOG_MSI_ASM_INSTALL_SUCCESS                L"LOG: Successfully installed assembly using Windows Installer."
-    ID_FUSLOG_POLICY_CACHE_INSERT_FAILURE            L"ERR: Error inserting entry into policy cache."
-    ID_FUSLOG_MSI_SUCCESS_FUSION_SETUP_FAIL          L"WRN: Windows Installer was able to provide the requested assembly, but setup of resulting file failed."
-    ID_FUSLOG_SETUP_RUN_FROM_SOURCE                  L"LOG: Entering run-from-source setup phase."
-    ID_FUSLOG_SETUP_RUN_FROM_SOURCE_FAILURE          L"ERR: Run-from-source setup phase failed with hr = 0x%x."
-    ID_FUSLOG_MODULE_INTEGRITY_CHECK_FAILURE         L"ERR: Module integrity check failed."
-    ID_FUSLOG_SETUP_DOWNLOAD_CACHE                   L"LOG: Entering download cache setup phase."
-    ID_FUSLOG_REF_DEF_MISMATCH                       L"ERR: The assembly reference did not match the assembly definition found."
-    ID_FUSLOG_SETUP_FAILURE                          L"ERR: Setup failed with hr = 0x%x."
-    ID_FUSLOG_IGNORE_INVALID_PROBE                   L"WRN: Not probing location %ws, because the location falls outside of the appbase."
-    ID_FUSLOG_CACHE_LOOKUP_SUCCESS                   L"LOG: Found assembly by looking in the GAC."
-    ID_FUSLOG_PREJIT_NOT_FOUND                       L"ERR: Expected to find a pre-jit assembly in cache, but assembly was not found."
-    ID_FUSLOG_CODEBASE_CONSTRUCTION_FAILURE          L"ERR: Error occurred constructing the probing codebase list."
-    ID_FUSLOG_CODEBASE_UNAVAILABLE                   L"ERR: No codebases found to download from."
-    ID_FUSLOG_DOWNLOAD_CACHE_LOOKUP_SUCCESS          L"LOG: Found assembly by looking in the download cache."
-    ID_FUSLOG_SETUP_CAB                              L"LOG: Setting up CAB file."
-END    
-
-STRINGTABLE DISCARDABLE
-BEGIN
-    ID_FUSLOG_TEMP_DIR_CREATE_FAILURE                L"ERR: Unable to create a temporary directory (hr = 0x%x)."
-    ID_FUSLOG_CAB_EXTRACT_FAILURE                    L"ERR: Unable to extract the CAB file (hr = 0x%x)."
-    ID_FUSLOG_CAB_ASM_FOUND                          L"LOG: Found matching assembly from CAB file: %ws."
-    ID_FUSLOG_CAB_EXTRACT_SUCCESS                    L"LOG: Successfully extracted assembly from CAB file."
-    ID_FUSLOG_DOWNLOAD_CACHE_CREATE_FAILURE          L"ERR: Unable to create assembly in download cache (hr = 0x%x)."
-    ID_FUSLOG_CAB_ASM_NOT_FOUND_EXTRACTED            L"LOG: Unable to find assembly from extracted CAB location: %ws."
-    ID_FUSLOG_TEMP_DIR_REMOVE_FAILURE                L"ERR: Unable to remove temporary directory: %ws."
-    ID_FUSLOG_MANIFEST_EXTRACT_FAILURE               L"ERR: Error extracting manifest import from file (hr = 0x%x)."
-    ID_FUSLOG_NAME_DEF_EXTRACT_FAILURE               L"ERR: Error retrieving assembly name definition from manifest import (hr = 0x%x)."
-    ID_FUSLOG_INVALID_ASM_PLATFORM                   L"ERR: Invalid assembly platform or ContentType in file (hr = 0x%x)."
-    ID_FUSLOG_INVALID_PRIVATE_ASM_LOCATION           L"LOG: Private assembly found in invalid location."
-    ID_FUSLOG_PARTIAL_ASM_IN_APP_DIR                 L"LOG: A partially-specified assembly bind succeeded from the application directory. Need to re-apply policy."
-    ID_FUSLOG_LOADFROM_DEFAULT_MISMATCH              L"LOG: Assembly in default load context is loaded from a different location than the one in LoadFrom context."
-    ID_FUSLOG_WHERE_REF_APPLY_POLICY                 L"LOG: Re-apply policy for where-ref bind." 
-    ID_FUSLOG_WHERE_REF_GAC_MATCH                    L"LOG: Codebase matches assembly in GAC."
-    ID_FUSLOG_WHERE_REF_GAC_MISMATCH                 L"LOG: Codebase does not match assembly in GAC."
-    ID_FUSLOG_WHERE_REF_LOAD_CONTEXT_MATCH           L"LOG: Where-ref bind Codebase matches what is found in default context. Keep the result in default context."    
-    ID_FUSLOG_WHERE_REF_LOAD_CONTEXT_MISMATCH        L"LOG: Where-ref bind Codebase does not match what is found in default context. Keep the result in LoadFrom context."
-    ID_FUSLOG_REPROBE_REQUIRED                       L"LOG: The post-policy assembly reference requires probing again."
-    ID_FUSLOG_SWITCH_TO_DEFAULT_CONTEXT              L"LOG: Switch from LoadFrom context to default context."
-    ID_FUSLOG_SWITCH_TO_LOADFROM_CONTEXT             L"LOG: Switch from default context to LoadFrom context."
-    ID_FUSLOG_DUPLICATE_ASM_COMMIT                   L"WRN: A duplicate assembly was found while copying the assembly item to the cache."
-    ID_FUSLOG_COPY_FILE_FAILURE                      L"ERR: Unable to copy file to cache location."
-    ID_FUSLOG_INVALID_LOCATION_INFO                  L"ERR: The private assembly was located outside of appbase. Source Url = %ws."
-END    
-
-STRINGTABLE DISCARDABLE
-BEGIN
-    ID_FUSLOG_ASYNC_CFG_DOWNLOAD_SUCCESS             L"LOG: The asynchronous application configuration file download successful. Download location %ws"
-    ID_FUSLOG_ASYNC_CFG_DOWNLOAD_FAILURE             L"LOG: The asynchronous configuration file download unsuccessful."
-    ID_FUSLOG_CACHE_ITEM_CREATE_FAILURE              L"ERR: Unable to create assembly cache item (hr = 0x%x)."
-    ID_FUSLOG_CACHE_ITEM_COMMIT_FAILURE              L"ERR: Unable to commit cache item. Attempt to put assembly in cache unsuccessful (hr = 0x%x)."
-    ID_FUSLOG_LOADCTX_HIT                            L"LOG: Reusing an assembly instance that was previously loaded (%ws)."
-    ID_FUSLOG_BIND_SUCCESS                           L"LOG: Binding succeeds. Returns assembly from %ws."
-    ID_FUSLOG_ASSEMBLY_NAME_DEF                      L"LOG: Assembly Name is: %ws"
-END    
-
-
-STRINGTABLE DISCARDABLE
-BEGIN
-    ID_FUSLOG_OPERATION_SUCCESSFUL                   L"The operation was successful."
-    ID_FUSLOG_OPERATION_FAILED                       L"The operation failed."
-    ID_FUSLOG_DETAILED_LOG                           L"--- A detailed error log follows. \n"
-    ID_FUSLOG_HEADER_TEXT                            L"*** Assembly Binder Log Entry "
-    ID_FUSLOG_BIND_RESULT_TEXT                       L"Bind result: hr = 0x%x. %ws"
-    ID_FUSLOG_NO_DESCRIPTION                         L"No description available.\n"
-    ID_FUSLOG_FUSION_DLL_PATH                        L"Assembly manager loaded from: "
-    ID_FUSLOG_EXECUTABLE                             L"Running under executable "
-    ID_FUSLOG_QUALIFIED_ASSEMBLY                     L"LOG: Partial reference qualified from config file. New reference: %ws."
-    ID_FUSLOG_CALLING_ASSEMBLY                       L"Calling assembly : %ws."
-    ID_FUSLOG_CFG_ASSEMBLY_STORE                     L"LOG: AssemblyStore path = %ws"
- END
-
-STRINGTABLE DISCARDABLE
-BEGIN
-    ID_FUSLOG_PARTIAL_BIND_DEBUG                     L"ERR: Partial GAC binds disallowed. [Partial Name = %ws : Calling Assembly = %ws : EXE Name = %ws]."
-    ID_FUSLOG_DISALLOW_APPLY_PUB_POLICY              L"WRN: Application configuration file safe mode disallowed."
-    ID_FUSLOG_DISALLOW_APP_BINDING_REDIRECTS         L"WRN: Application configuration file binding redirects disallowed."
-    ID_FUSLOG_PREBIND_INFO_DEVOVERRIDE_GLOBAL        L"LOG: Global DEVOVERRIDE path = %ws"
-    ID_FUSLOG_PREBIND_INFO_DEVOVERRIDE_LOCAL         L"LOG: Local DEVOVERRIDE path = %ws"
-    ID_FUSLOG_DEVOVERRIDE_FOUND                      L"LOG: Found assembly in DEVOVERRIDE path %ws"
-    ID_FUSLOG_DEVOVERRIDE_MISS                       L"LOG: Did not find assembly in DEVOVERRIDE path %ws"
-    ID_FUSLOG_PREBIND_INFO_DEVPATH                   L"LOG: DEVPATH = %ws"
-    ID_FUSLOG_ASSEMBLYSTORE_DUPLICATE                L"WRN: assemblyStore has already been set. Ignoring duplicate entry."
-    ID_FUSLOG_DEVOVERRIDE_DUPLICATE                  L"WRN: devOverridePath has already been set. Ignoring duplicate entry."
-    ID_FUSLOG_DISALLOW_APP_BASE_PROBING              L"WRN: App base probing is disallowed."
-    ID_FUSLOG_INSPECTION_ONLY                        L"LOG: This is an inspection only bind."
-    ID_FUSLOG_SHOW_START_LOAD_CONTEXT                L"LOG: This bind starts in %ws load context."
-    ID_FUSLOG_SHOW_RESULT_LOAD_CONTEXT               L"LOG: Assembly is loaded in %ws load context."
-    ID_FUSLOG_LOAD_CONTEXT_PA_MISMATCH               L"ERR: An assembly with different processor architecture is already loaded."
-    ID_FUSLOG_INCOMPATIBLE_PROCESSOR_ARCHITECTURE    L"ERR: Attempt to load an assembly with ProcessorArchitecture incompatible with the running process."
-END
-
-STRINGTABLE DISCARDABLE
-BEGIN
-    ID_FUSLOG_ISEQUAL_DIFF_RETARGET                  L"WRN: Comparing the assembly name resulted in the mismatch: Retargetable flag"
-    ID_FUSLOG_ISEQUAL_DIFF_PROCESSOR_ARCHITECTURE    L"WRN: Comparing the assembly name resulted in mismatch of Processor Architecture: Ref %ws, Def %ws."
-    ID_FUSLOG_ISEQUAL_DIFF_CONTENT_TYPE              L"WRN: Comparing the assembly name resulted in the mismatch: Content Type"
-    ID_FUSLOG_RETARGET_CFG_MISSING                   L"LOG: Retarget policy is not found."
-    ID_FUSLOG_RETARGET_CFG_NAME_REDIRECT             L"LOG: Name redirect found in retarget config: %ws redirected to %ws."
-    ID_FUSLOG_RETARGET_CFG_VER_REDIRECT              L"LOG: Version redirect found in retarget config: %ws redirected to %ws."
-    ID_FUSLOG_RETARGET_CFG_PKT_REDIRECT              L"LOG: PublicKeyToken redirect found in retarget config: %ws redirected to %ws."
-    ID_FUSLOG_XML_PARSE_ERROR_MEMORY                 L"ERR: Parse XML memory stream failed." 
-    ID_FUSLOG_XML_BINDINGRETARGET_INSUFFICIENT_DATA  L"ERR: bindingRetarget tag is not processed due to insufficient data."
-    ID_FUSLOG_FX_CFG_MISSING                         L"Log: framework config is not found."
-    ID_FUSLOG_FX_CFG_VER_REDIRECT                    L"LOG: Version redirect found in framework config: %ws redirected to %ws."
-    ID_FUSLOG_APPLIESTO_DUPLICATE                    L"WRN: appliesTo has already been set. Ignoring duplicate appliesTo."
-    ID_FUSLOG_PORTABILITY_CFG_NAME_REDIRECT          L"LOG: Name redirect found in portability config: %ws redirected to %ws."
-    ID_FUSLOG_PORTABILITY_CFG_VER_REDIRECT           L"LOG: Version redirect found in portability config: %ws redirected to %ws."
-    ID_FUSLOG_PORTABILITY_CFG_PKT_REDIRECT           L"LOG: PublicKeyToken redirect found in portability config: %ws redirected to %ws."
-    ID_FUSLOG_WARNING_SUPPORTPORTABILITY_MISSING_PKT L"WRN: supportPortability tag is not processed due to missing PKT attribute."
-    ID_FUSLOG_WARNING_SUPPORTPORTABILITY_MISSING_ENABLE L"WRN: supportPortability tag is not processed due to missing enable attribute."
-    ID_FUSLOG_WARNING_SUPPORTPORTABILITY_INVALID_ENABLE L"WRN: supportPortability tag is not processed due to enable attribute not being 'true' or 'false'."
-
-END
-
-STRINGTABLE DISCARDABLE
-BEGIN
-    ID_FUSLOG_LOADCTX_HIT_HOST                      L"LOG: Reusing a host assembly instance that was previously loaded."
-    ID_FUSLOG_HOST_RESOLVED                         L"LOG: Assembly binding is resolved by the host."
-    ID_FUSLOG_ADMIN_CFG_POLICY_CODEBASE             L"LOG: Codebase hint found in machine config file: %ws"
-    ID_FUSLOG_PROCESSOR_ARCHITECTURE_LOCKED         L"LOG: ProcessorArchitecture is locked to %ws."
-    ID_FUSLOG_CHECK_HOST                            L"LOG: Fusion is hosted. Check host about this assembly."
-    ID_FUSLOG_NOT_IN_CLR_LOADED_LIST                L"LOG: Assembly is not in CLR Loaded list. Asking host assembly store."
-    ID_FUSLOG_IN_CLR_LOADED_LIST                    L"LOG: Assembly is in CLR Loaded list. Proceed to normal probing."
-    ID_FUSLOG_HOST_STORE_NOT_AVAILABLE              L"WRN: Host did not provide an assembly store."
-    ID_FUSLOG_HOST_STORE_RESOLVE_TRY                L"LOG: Try host assembly store with assembly %ws."
-    ID_FUSLOG_HOST_STORE_RESOLVE_FAILED             L"WRN: Host assembly store does not contain this assembly."
-    ID_FUSLOG_HOST_STORE_PARTIAL_NAME_SKIP          L"LOG: Input is partial name. Skip host assembly store lookup." 
-    ID_FUSLOG_HOST_GAC_ASM_MISMATCH                 L"WRN: The assembly returned from host store has different signature from the one in GAC."
-    ID_FUSLOG_HOST_RESULT                           L"LOG: Host store returns assembly stream with id = %I64u, context = %I64u."
-    ID_FUSLOG_HOST_NO_DEBUG_STREAM                  L"LOG: Host store does not provide debug stream."
-END
-
-STRINGTABLE DISCARDABLE
-BEGIN
-    ID_FUSLOG_EXPLICIT_BIND_IJW                     L"LOG: IJW explicit bind. File path:%ws."
-    ID_FUSLOG_EXPLICIT_BIND_EXE                     L"LOG: EXE explicit bind. File path:%ws."
-    ID_FUSLOG_EXPLICIT_BIND_IJW_BIND_FAIL           L"ERR: IJW assembly bind failure. hr = 0x%x."
-    ID_FUSLOG_EXPLICIT_BIND_IJW_PATH_DIFF           L"LOG: IJW assembly bind returned a different path: %ws. Use the file provided."
-    ID_FUSLOG_EXPLICIT_BIND_IJW_PATH_MATCH          L"LOG: IJW assembly bind returned the same manifest path."
-    ID_FUSLOG_EXPLICIT_BIND_IJW_NOT_FOUND           L"LOG: IJW assembly bind returned file not found." 
-    ID_FUSLOG_EXPLICIT_BIND_EXE_LOADCONTEXT_COLLISION L"ERR: Assembly with the same identity has already been loaded."
-END
-
-STRINGTABLE DISCARDABLE
-BEGIN
-    ID_FUSLOG_LOG_TURNED_OFF                        L"WRN: Assembly binding logging is turned OFF."
-    ID_FUSLOG_LOG_TURN_ON_HKLM                      L"To enable assembly bind failure logging, set the registry value [HKLM\\Software\\Microsoft\\Fusion!EnableLog] (DWORD) to 1."
-    ID_FUSLOG_LOG_PERF_WARNING                      L"Note: There is some performance penalty associated with assembly bind failure logging."
-    ID_FUSLOG_LOG_TURN_OFF_HKLM                     L"To turn this feature off, remove the registry value [HKLM\\Software\\Microsoft\\Fusion!EnableLog]."
-    ID_FUSLOG_UNSUPPORTED_LINKED_CONFIGURATION      L"ERR: Unsupported linked configuration location: %ws"
-    ID_FUSLOG_LINKED_CONFIGURATION_PARSE_ERROR      L"ERR: Error processing linked configurations (hr = 0x%x)"
-    ID_FUSLOG_LINKED_CONFIGURATION_DUPLICATE        L"WRN: Ignoring duplicate linked configuration"
-    ID_FUSLOG_PROCESSING_LINKED_CONFIGURATION       L"LOG: Processing linked configuration: %ws"
-    ID_FUSLOG_MISSING_CACHE_FILE                    L"ERR: Downloaded file was not cached. The web server may be configured to expire content immediately."
-    ID_FUSLOG_NO_PARTIAL_NAME_FOR_HOST_APPBASE_COMMON_ASM L"ERR: Partial Name Binding is not allowed when the same assembly exists in both the host assembly store and application base."
-END
-
-STRINGTABLE DISCARDABLE
-BEGIN
-    ID_FUSLOG_WARNING_PARTIAL_NAME_HEADER           L"WRN: Partial binding information was supplied for an assembly:"
-    ID_FUSLOG_WARNING_PARTIAL_NAME_DETAIL           L"WRN: A partial bind occurs when only part of the assembly display name is provided.\r\nWRN: This might result in the binder loading an incorrect assembly.\r\nWRN: It is recommended to provide a fully specified textual identity for the assembly,\r\nWRN: that consists of the simple name, version, culture, and public key token.\r\nWRN: See whitepaper http://go.microsoft.com/fwlink/?LinkId=109270 for more information and common solutions to this issue."
-    ID_FUSLOG_WARNING_PARTIAL_NAME_INSTANCE         L"WRN: Assembly Name: %s | Domain ID: %d"
-    ID_FUSLOG_WARNING_MULTIPLE_VERSIONS_HEADER      L"WRN: Multiple versions of the same assembly were loaded into one context of an application domain:"
-    ID_FUSLOG_WARNING_MULTIPLE_VERSIONS_DETAIL      L"WRN: This might lead to runtime failures.\r\nWRN: It is recommended that you remove the dependency on multiple versions, and change the app.config file to point to the required version of the assembly only.\r\nWRN: See whitepaper http://go.microsoft.com/fwlink/?LinkId=109270 for more information."
-    ID_FUSLOG_WARNING_MULTIPLE_VERSIONS_INSTANCE    L"WRN: Context: %s | Domain ID: %d | Assembly Name: %s"
-    ID_FUSLOG_WARNING_MULTIPLE_CONTEXTS_HEADER      L"WRN: The same assembly was loaded into multiple contexts of an application domain:"
-    ID_FUSLOG_WARNING_MULTIPLE_CONTEXTS_DETAIL      L"WRN: This might lead to runtime failures.\r\nWRN: It is recommended to inspect your application on whether this is intentional or not.\r\nWRN: See whitepaper http://go.microsoft.com/fwlink/?LinkId=109270 for more information and common solutions to this issue."
-END
-
-STRINGTABLE DISCARDABLE
-BEGIN
-    ID_FUSLOG_BINDING_STATUS_BEGIN                   L"BEGIN : %s"
-    ID_FUSLOG_BINDING_STATUS_END                     L"END"
-    ID_FUSLOG_BINDING_STATUS_END_HR                  L"END   : %s"
-    ID_FUSLOG_BINDING_STATUS_NATIVE_DEPENDENCY       L"Native image dependency bind."
-    ID_FUSLOG_BINDING_STATUS_IMMERSIVE               L"Immersive bind."
-    ID_FUSLOG_BINDING_STATUS_FRAMEWORK               L"Framework bind."
-    ID_FUSLOG_BINDING_STATUS_FX_ASSEMBLY_BLOCKED     L"Found .NET Framework assembly is not supported in AppX."
-    ID_FUSLOG_BINDING_STATUS_LOAD_FILE               L"Assembly.LoadFile bind."
-    ID_FUSLOG_BINDING_STATUS_WINRT                   L"Windows Runtime Type bind."
-    ID_FUSLOG_BINDING_DEPENDENCY_NAME                L"Dependency name: %s"
-    ID_FUSLOG_BINDING_STATUS_FOUND                   L"Found: %s"
-    ID_FUSLOG_BINDING_STATUS_IL_IMAGE                L"IL image bind."
-    ID_FUSLOG_BINDING_STATUS_NATIVE_IMAGE            L"Native image bind."
-END
-
-#else // FEATURE_FUSION
 
 STRINGTABLE DISCARDABLE
 BEGIN
@@ -346,4 +57,3 @@ BEGIN
     ID_FUSLOG_BINDING_HEADER_END                     L"--- A detailed log follows."
 END
 
-#endif // FEATURE_FUSION
diff --git a/src/dlls/mscorrc/fusres.h b/src/dlls/mscorrc/fusres.h
index 6d3e1b2216..6d6ddd1e9f 100644
--- a/src/dlls/mscorrc/fusres.h
+++ b/src/dlls/mscorrc/fusres.h
@@ -4,254 +4,6 @@
 #ifndef __FUSION_RESOURCE_H_
 #define __FUSION_RESOURCE_H_
 
-#ifdef FEATURE_FUSION
-
-#define ID_FUSLOG_ASSEMBLY_CREATION_FAILURE              10000
-#define ID_FUSLOG_ASSEMBLY_LOOKUP_FAILURE                10001
-#define ID_FUSLOG_ISEQUAL_DIFF_NAME                      10005
-#define ID_FUSLOG_ISEQUAL_DIFF_VERSION_MAJOR             10006
-#define ID_FUSLOG_ISEQUAL_DIFF_VERSION_MINOR             10007
-#define ID_FUSLOG_ISEQUAL_DIFF_VERSION_REVISION          10008
-#define ID_FUSLOG_ISEQUAL_DIFF_VERSION_BUILD             10009
-#define ID_FUSLOG_ISEQUAL_DIFF_PUBLIC_KEY_TOKEN          10010
-#define ID_FUSLOG_ISEQUAL_DIFF_CULTURE                   10011
-#define ID_FUSLOG_ISEQUAL_DIFF_CUSTOM                    10012
-#define ID_FUSLOG_CANONICALIZATION_ERROR                 10014
-#define ID_FUSLOG_POLICY_CACHE_FAILURE                   10016
-#define ID_FUSLOG_APP_CFG_PIGGYBACK                      10017
-#define ID_FUSLOG_PREBIND_INFO_START                     10018
-#define ID_FUSLOG_PREBIND_INFO_DISPLAY_NAME              10019
-#define ID_FUSLOG_PREBIND_INFO_WHERE_REF                 10020
-#define ID_FUSLOG_PREBIND_INFO_APPBASE                   10021
-#define ID_FUSLOG_PREBIND_INFO_PRIVATE_PATH              10023
-#define ID_FUSLOG_PREBIND_INFO_DYNAMIC_BASE              10024
-#define ID_FUSLOG_PREBIND_INFO_CACHE_BASE                10025
-#define ID_FUSLOG_PREBIND_INFO_APP_NAME                  10026
-#define ID_FUSLOG_PREBIND_INFO_END                       10027
-#define ID_FUSLOG_APP_CFG_DOWNLOAD                       10028
-#define ID_FUSLOG_APP_CFG_DOWNLOAD_LOCATION              10029
-#define ID_FUSLOG_LOADCTX_HIT                            10030
-#define ID_FUSLOG_CFG_NOT_EXIST                          10031
-#define ID_FUSLOG_APP_CFG_FOUND                          10032
-#define ID_FUSLOG_DEVOVERRIDE_REF_DEF_MISMATCH           10036
-#define ID_FUSLOG_DEVOVERRIDE_SIGNATURE_CHECK_FAILED     10037
-#define ID_FUSLOG_XML_PRIVATE_ASM_REDIRECT               10039
-#define ID_FUSLOG_XML_PARSE_ERROR_CODE                   10041
-#define ID_FUSLOG_XML_ASSEMBLYIDENTITY_MISSING_NAME      10042
-#define ID_FUSLOG_XML_BINDINGREDIRECT_INSUFFICIENT_DATA  10043
-#define ID_FUSLOG_XML_CODEBASE_HREF_MISSING              10044
-#define ID_FUSLOG_XML_MULTIPLE_IDENTITIES                10045
-#define ID_FUSLOG_PRIVATE_PATH_DUPLICATE                 10046
-#define ID_FUSLOG_POLICY_NOT_APPLIED                     10047
-#define ID_FUSLOG_HOST_CONFIG_FILE                       10048
-#define ID_FUSLOG_HOST_CONFIG_FILE_MISSING               10049
-#define ID_FUSLOG_HOST_CFG_REDIRECT                      10051
-#define ID_FUSLOG_HOST_CFG_NO_REDIRECT                   10052
-#define ID_FUSLOG_APP_CFG_REDIRECT                       10053
-#define ID_FUSLOG_APP_CFG_SAFE_MODE                      10054
-#define ID_FUSLOG_PUB_CFG_MISSING                        10055
-#define ID_FUSLOG_PUB_CFG_FOUND                          10056
-#define ID_FUSLOG_PUB_CFG_REDIRECT                       10057
-#define ID_FUSLOG_MACHINE_CFG_MISSING                    10058
-#define ID_FUSLOG_MACHINE_CFG_FOUND                      10059
-#define ID_FUSLOG_MACHINE_CFG_REDIRECT                   10060
-#define ID_FUSLOG_REDIRECT_NO_CODEBASE                   10061
-#define ID_FUSLOG_POLICY_CODEBASE                        10062
-#define ID_FUSLOG_POST_POLICY_REFERENCE                  10063
-#define ID_FUSLOG_APPLY_POLICY_FAILED                    10064
-#define ID_FUSLOG_CFG_PRIVATE_PATH                       10065
-#define ID_FUSLOG_XML_PARSE_ERROR_FILE                   10066
-#define ID_FUSLOG_CODEBASE_RETRIEVE_FAILURE              10067
-#define ID_FUSLOG_ATTEMPT_NEW_DOWNLOAD                   10068
-#define ID_FUSLOG_PROBE_FAIL_BUT_ASM_FOUND               10069
-#define ID_FUSLOG_ASM_SETUP_FAILURE                      10070
-#define ID_FUSLOG_PREDOWNLOAD_FAILURE                    10071
-#define ID_FUSLOG_URLMON_MISSING                         10072
-#define ID_FUSLOG_DOWNLOAD_PIGGYBACK                     10073
-#define ID_FUSLOG_DOWNLOAD_SUCCESS                       10074
-#define ID_FUSLOG_LAST_MOD_FAILURE                       10075
-#define ID_FUSLOG_MSI_CODEBASE_UNSUPPORTED               10076
-#define ID_FUSLOG_CAB_ASM_NOT_FOUND_EXTRACTED            10077
-#define ID_FUSLOG_FAILED_PROBING                         10078
-#define ID_FUSLOG_PARTIAL_GAC_UNSUPPORTED                10079
-#define ID_FUSLOG_GAC_LOOKUP_SUCCESS                     10080
-#define ID_FUSLOG_MSI_INSTALL_ATTEMPT                    10081
-#define ID_FUSLOG_MSI_ASM_INSTALL_SUCCESS                10082
-#define ID_FUSLOG_POLICY_CACHE_INSERT_FAILURE            10084
-#define ID_FUSLOG_MSI_SUCCESS_FUSION_SETUP_FAIL          10085
-#define ID_FUSLOG_SETUP_RUN_FROM_SOURCE                  10086
-#define ID_FUSLOG_MODULE_INTEGRITY_CHECK_FAILURE         10087
-#define ID_FUSLOG_SETUP_DOWNLOAD_CACHE                   10088
-#define ID_FUSLOG_REF_DEF_MISMATCH                       10089
-#define ID_FUSLOG_SETUP_FAILURE                          10090
-#define ID_FUSLOG_IGNORE_INVALID_PROBE                   10091
-#define ID_FUSLOG_CACHE_LOOKUP_SUCCESS                   10092
-#define ID_FUSLOG_PREJIT_NOT_FOUND                       10093
-#define ID_FUSLOG_CODEBASE_CONSTRUCTION_FAILURE          10094
-#define ID_FUSLOG_CODEBASE_UNAVAILABLE                   10095
-#define ID_FUSLOG_DOWNLOAD_CACHE_LOOKUP_SUCCESS          10096
-#define ID_FUSLOG_SETUP_CAB                              10097
-#define ID_FUSLOG_TEMP_DIR_CREATE_FAILURE                10098
-#define ID_FUSLOG_CAB_EXTRACT_FAILURE                    10099
-#define ID_FUSLOG_CAB_ASM_FOUND                          10100
-#define ID_FUSLOG_CAB_EXTRACT_SUCCESS                    10101
-#define ID_FUSLOG_DOWNLOAD_CACHE_CREATE_FAILURE          10102
-#define ID_FUSLOG_CAB_ASM_NOT_FOUND                      10103
-#define ID_FUSLOG_TEMP_DIR_REMOVE_FAILURE                10104
-#define ID_FUSLOG_MANIFEST_EXTRACT_FAILURE               10105
-#define ID_FUSLOG_NAME_DEF_EXTRACT_FAILURE               10106
-#define ID_FUSLOG_INVALID_PRIVATE_ASM_LOCATION           10107
-#define ID_FUSLOG_PARTIAL_ASM_IN_APP_DIR                 10108
-#define ID_FUSLOG_REPROBE_REQUIRED                       10109
-#define ID_FUSLOG_DUPLICATE_ASM_COMMIT                   10110
-#define ID_FUSLOG_INVALID_ASM_PLATFORM                   10111
-#define ID_FUSLOG_COPY_FILE_FAILURE                      10112
-#define ID_FUSLOG_INVALID_LOCATION_INFO                  10113
-#define ID_FUSLOG_ASYNC_CFG_DOWNLOAD_SUCCESS             10114
-#define ID_FUSLOG_ASYNC_CFG_DOWNLOAD_FAILURE             10115
-#define ID_FUSLOG_CACHE_ITEM_CREATE_FAILURE              10116
-#define ID_FUSLOG_CACHE_ITEM_COMMIT_FAILURE              10117
-
-
-#define ID_FUSLOG_OPERATION_SUCCESSFUL                   10118
-#define ID_FUSLOG_OPERATION_FAILED                       10119
-#define ID_FUSLOG_DETAILED_LOG                           10120
-#define ID_FUSLOG_HEADER_TEXT                            10121
-#define ID_FUSLOG_BIND_RESULT_TEXT                       10122
-#define ID_FUSLOG_NO_DESCRIPTION                         10123
-#define ID_FUSLOG_FUSION_DLL_PATH                        10124
-#define ID_FUSLOG_EXECUTABLE                             10125
-
-#define ID_FUSLOG_QUALIFIED_ASSEMBLY                     10126
-#define ID_FUSLOG_CALLING_ASSEMBLY                       10127
-
-#define ID_FUSLOG_CFG_ASSEMBLY_STORE                     10128
-#define ID_FUSLOG_SETUP_RUN_FROM_SOURCE_FAILURE          10129
-
-#define ID_FUSLOG_ISEQUAL_DIFF_RETARGET                  10130
-#define ID_FUSLOG_RETARGET_CFG_MISSING                   10131
-#define ID_FUSLOG_RETARGET_CFG_NAME_REDIRECT             10132
-#define ID_FUSLOG_RETARGET_CFG_VER_REDIRECT              10133
-#define ID_FUSLOG_RETARGET_CFG_PKT_REDIRECT              10134
-#define ID_FUSLOG_XML_PARSE_ERROR_MEMORY                 10135
-#define ID_FUSLOG_XML_BINDINGRETARGET_INSUFFICIENT_DATA  10136
-#define ID_FUSLOG_XML_INVALID_PROCESSORARCHITECTURE      10137
-
-#define ID_FUSLOG_BIND_SUCCESS                           10139
-
-#define ID_FUSLOG_CROSS_SITE_REDIRECT                    10140
-#define ID_FUSLOG_DISALLOW_APPLY_PUB_POLICY              10141
-#define ID_FUSLOG_DISALLOW_APP_BINDING_REDIRECTS         10142
-#define ID_FUSLOG_DISALLOW_APP_BASE_PROBING              10143
-#define ID_FUSLOG_INSPECTION_ONLY                        10144
-#define ID_FUSLOG_SHOW_START_LOAD_CONTEXT                10145
-#define ID_FUSLOG_SHOW_RESULT_LOAD_CONTEXT               10146
-#define ID_FUSLOG_LOAD_CONTEXT_PA_MISMATCH               10147
-
-#define ID_FUSLOG_FX_CFG_MISSING                         10150
-#define ID_FUSLOG_FX_CFG_VER_REDIRECT                    10151
-#define ID_FUSLOG_APPLIESTO_DUPLICATE                    10152
-
-#define ID_FUSLOG_PREBIND_INFO_DEVOVERRIDE_GLOBAL        10153
-#define ID_FUSLOG_PREBIND_INFO_DEVOVERRIDE_LOCAL         10154
-#define ID_FUSLOG_DEVOVERRIDE_FOUND                      10155
-#define ID_FUSLOG_DEVOVERRIDE_MISS                       10156
-#define ID_FUSLOG_PREBIND_INFO_DEVPATH                   10157
-#define ID_FUSLOG_ASSEMBLYSTORE_DUPLICATE                10158
-#define ID_FUSLOG_DEVOVERRIDE_DUPLICATE                  10159
-
-#define ID_FUSLOG_LOADCTX_HIT_HOST                       10160
-#define ID_FUSLOG_HOST_RESOLVED                          10161
-#define ID_FUSLOG_ADMIN_CFG_POLICY_CODEBASE              10162
-#define ID_FUSLOG_PROCESSOR_ARCHITECTURE_LOCKED          10163
-#define ID_FUSLOG_CHECK_HOST                             10164
-#define ID_FUSLOG_NOT_IN_CLR_LOADED_LIST                 10165
-#define ID_FUSLOG_IN_CLR_LOADED_LIST                     10166
-#define ID_FUSLOG_HOST_STORE_RESOLVE_TRY                 10167
-#define ID_FUSLOG_HOST_STORE_RESOLVE_FAILED              10168
-#define ID_FUSLOG_HOST_STORE_NOT_AVAILABLE               10169
-
-// 10170 - 10211 used by native binder
-
-#define ID_FUSLOG_EXPLICIT_BIND_IJW                      10220
-#define ID_FUSLOG_EXPLICIT_BIND_EXE                      10221
-#define ID_FUSLOG_EXPLICIT_BIND_IJW_BIND_FAIL            10222
-#define ID_FUSLOG_EXPLICIT_BIND_IJW_PATH_DIFF            10223
-#define ID_FUSLOG_EXPLICIT_BIND_IJW_PATH_MATCH           10224
-#define ID_FUSLOG_EXPLICIT_BIND_IJW_NOT_FOUND            10225
-#define ID_FUSLOG_EXPLICIT_BIND_EXE_LOADCONTEXT_COLLISION 10226
-
-#define ID_FUSLOG_PUBLISHER_POLICY_CONFIG_MISSING        10231
-
-#define ID_FUSLOG_UNSUPPORTED_LINKED_CONFIGURATION       10300
-#define ID_FUSLOG_LINKED_CONFIGURATION_PARSE_ERROR       10301
-#define ID_FUSLOG_LINKED_CONFIGURATION_DUPLICATE         10302
-#define ID_FUSLOG_PROCESSING_LINKED_CONFIGURATION        10303
-
-#define ID_FUSLOG_ISEQUAL_DIFF_PROCESSOR_ARCHITECTURE    10310
-#define ID_FUSLOG_ISEQUAL_DIFF_CONTENT_TYPE              10311
-
-#define ID_FUSLOG_WHERE_REF_APPLY_POLICY                 10320
-#define ID_FUSLOG_SWITCH_TO_DEFAULT_CONTEXT              10321
-#define ID_FUSLOG_SWITCH_TO_LOADFROM_CONTEXT             10322
-#define ID_FUSLOG_WHERE_REF_GAC_MATCH                    10323
-#define ID_FUSLOG_WHERE_REF_GAC_MISMATCH                 10324
-#define ID_FUSLOG_WHERE_REF_LOAD_CONTEXT_MATCH           10325
-#define ID_FUSLOG_WHERE_REF_LOAD_CONTEXT_MISMATCH        10326
-#define ID_FUSLOG_HOST_STORE_PARTIAL_NAME_SKIP           10327
-#define ID_FUSLOG_MISSING_CACHE_FILE                     10328
-#define ID_FUSLOG_HOST_GAC_ASM_MISMATCH                  10329
-#define ID_FUSLOG_HOST_RESULT                            10330
-#define ID_FUSLOG_HOST_NO_DEBUG_STREAM                   10331
-#define ID_FUSLOG_APP_CONFIG_FILE                        10332
-#define ID_FUSLOG_NO_APP_CONFIG_FILE                     10333
-#define ID_FUSLOG_ASSEMBLY_NAME_DEF                      10334
-#define ID_FUSLOG_PREVIOUS_FAILED                        10335
-#define ID_FUSLOG_LOADFROM_DEFAULT_MISMATCH              10336
-#define ID_FUSLOG_LOADER_PERMISSION_CHECK_FAILURE        10337
-#define ID_FUSLOG_INCOMPATIBLE_PROCESSOR_ARCHITECTURE    10338
-#define ID_FUSLOG_NO_PARTIAL_NAME_FOR_HOST_APPBASE_COMMON_ASM 10339
-
-// 10400 - 10500 used by native binder
-
-#define ID_FUSLOG_LOG_TURNED_OFF                         10990
-#define ID_FUSLOG_LOG_TURN_ON_HKLM                       10991
-#define ID_FUSLOG_LOG_PERF_WARNING                       10992
-#define ID_FUSLOG_LOG_TURN_OFF_HKLM                      10993
-
-#define ID_FUSLOG_PARTIAL_BIND_DEBUG                     11000
-
-#define ID_FUSLOG_WARNING_PARTIAL_NAME_HEADER            11001
-#define ID_FUSLOG_WARNING_PARTIAL_NAME_DETAIL            11002
-#define ID_FUSLOG_WARNING_PARTIAL_NAME_INSTANCE          11003
-#define ID_FUSLOG_WARNING_MULTIPLE_VERSIONS_HEADER       11004
-#define ID_FUSLOG_WARNING_MULTIPLE_VERSIONS_DETAIL       11005
-#define ID_FUSLOG_WARNING_MULTIPLE_VERSIONS_INSTANCE     11006
-#define ID_FUSLOG_WARNING_MULTIPLE_CONTEXTS_HEADER       11007
-#define ID_FUSLOG_WARNING_MULTIPLE_CONTEXTS_DETAIL       11008
-
-#define ID_FUSLOG_PORTABILITY_CFG_NAME_REDIRECT          11011
-#define ID_FUSLOG_PORTABILITY_CFG_VER_REDIRECT           11012
-#define ID_FUSLOG_PORTABILITY_CFG_PKT_REDIRECT           11013
-#define ID_FUSLOG_WARNING_SUPPORTPORTABILITY_MISSING_PKT 11014
-#define ID_FUSLOG_WARNING_SUPPORTPORTABILITY_MISSING_ENABLE 11015
-#define ID_FUSLOG_WARNING_SUPPORTPORTABILITY_INVALID_ENABLE 11016
-
-#define ID_FUSLOG_BINDING_STATUS_BEGIN                   11020
-#define ID_FUSLOG_BINDING_STATUS_END                     11021
-#define ID_FUSLOG_BINDING_STATUS_END_HR                  11022
-#define ID_FUSLOG_BINDING_STATUS_NATIVE_DEPENDENCY       11023
-#define ID_FUSLOG_BINDING_STATUS_IMMERSIVE               11024
-#define ID_FUSLOG_BINDING_STATUS_FRAMEWORK               11025
-#define ID_FUSLOG_BINDING_STATUS_LOAD_FILE               11026
-#define ID_FUSLOG_BINDING_STATUS_WINRT                   11027
-#define ID_FUSLOG_BINDING_DEPENDENCY_NAME                11028
-#define ID_FUSLOG_BINDING_STATUS_FOUND                   11029
-#define ID_FUSLOG_BINDING_STATUS_IL_IMAGE                11030
-#define ID_FUSLOG_BINDING_STATUS_NATIVE_IMAGE            11031
-#define ID_FUSLOG_BINDING_STATUS_FX_ASSEMBLY_BLOCKED     11032
-
-#else //!FEATURE_FUSION
 
 // we have 10000 to 10125 available (and more)
 // Used are 10000 to 10042
@@ -305,6 +57,5 @@
 #define ID_FUSLOG_BINDING_HEADER_BIND_RESULT_ERROR       10041
 #define ID_FUSLOG_BINDING_HEADER_END                     10042
 
-#endif //!FEATURE_FUSION
 
 #endif  // __FUSION_RESOURCE_H_
diff --git a/src/dlls/mscorrc/include.rc b/src/dlls/mscorrc/include.rc
index ee46940871..50c7c779ae 100644
--- a/src/dlls/mscorrc/include.rc
+++ b/src/dlls/mscorrc/include.rc
@@ -4,4 +4,3 @@
 
 #include "mscorrc.rc"
 #include "fuslog.rc"
-#include "nativelog.rc"
diff --git a/src/dlls/mscorrc/mscorrc.rc b/src/dlls/mscorrc/mscorrc.rc
index 138db55b66..bb2a9ee0fb 100644
--- a/src/dlls/mscorrc/mscorrc.rc
+++ b/src/dlls/mscorrc/mscorrc.rc
@@ -994,11 +994,7 @@ BEGIN
     IDS_EE_LOAD_BAD_MAIN_SIG                "Main method for type '%1' has invalid signature."
     IDS_EE_LOAD_CIRCULAR_DEPENDENCY         "A circular dependency was detected when loading file or assembly '%1'."
 
-#ifdef FEATURE_CORECLR
     IDS_EE_FILE_NOT_FOUND                   "File or assembly name '%1' was not found."
-#else
-    IDS_EE_FILE_NOT_FOUND                   "File or assembly name '%1', or one of its dependencies, was not found."
-#endif
 
     IDS_EE_TOO_MANY_OPEN_FILES              "The system cannot open file '%1'.  There may be too many open files."
     IDS_EE_SHARING_VIOLATION                "Cannot access file '%1' because it is being used by another process."
@@ -1376,11 +1372,7 @@ BEGIN
     IDS_EE_CANNOT_HAVE_ASSEMBLY_SPEC        "Unexpected assembly-qualifier in a typename."
     IDS_EE_NEEDS_ASSEMBLY_SPEC              "Typename needs an assembly qualifier."
 
-#ifdef FEATURE_CORECLR
     IDS_EE_FILELOAD_ERROR_GENERIC           "Could not load file or assembly '%1'. %2"
-#else
-    IDS_EE_FILELOAD_ERROR_GENERIC           "Could not load file or assembly '%1' or one of its dependencies. %2"
-#endif
 
     IDS_EE_CRYPTO_UNKNOWN_OPERATION         "Unknown import key operation specified."
 
@@ -1509,11 +1501,7 @@ BEGIN
 
     IDS_CLASSLOAD_OVERLAPPING_INTERFACES "The type '%1' in assembly '%2' has a contracting interface set for some instantiations"
     
-#ifdef FEATURE_CORECLR
     IDS_CLASSLOAD_32BITCLRLOADING64BITASSEMBLY "Attempted to load a 64-bit assembly on a 32-bit platform."
-#else // !FEATURE_CORECLR
-    IDS_CLASSLOAD_32BITCLRLOADING64BITASSEMBLY "Attempted to load a 64-bit assembly on a 32-bit platform. Use ReflectionOnlyLoad() instead if trying to load for reflection purposes."
-#endif // FEATURE_CORECLR    
 
     IDS_CLASSLOAD_CONSTRAINT_MISMATCH_ON_IMPLICIT_OVERRIDE  "Method '%3' on type '%1' from assembly '%2' tried to implicitly override a method with weaker type parameter constraints."
     IDS_CLASSLOAD_CONSTRAINT_MISMATCH_ON_IMPLICIT_IMPLEMENTATION "Method '%3' on type '%1' from assembly '%2' tried to implicitly implement an interface method with weaker type parameter constraints."
@@ -1545,17 +1533,9 @@ BEGIN
     IDS_UNMARSHALABLE_DEMAND_OBJECT         "The security object (Permission or PermissionSet) used for performing a Demand caused an error relating to serialization/deserialization."
     IDS_EE_OBJECT_TO_VARIANT_NOT_SUPPORTED  "Invalid managed/unmanaged type combination (Marshaling to and from COM VARIANTs isn't supported)."
     IDS_EE_OBJECT_TO_ITF_NOT_SUPPORTED      "Invalid managed/unmanaged type combination (Marshaling to and from COM interface pointers isn't supported)."
-#ifdef FEATURE_CORECLR
     IDS_TYPE_INHERITANCE_RULES_VIOLATED     "Inheritance security rules violated by type: '%1'. Derived types must either match the security accessibility of the base type or be less accessible.  If the base class has a non-transparent default constructor, the derived class must also have a default constructor, and the method inheritance rules apply across those two methods."
-#else // !FEATURE_CORECLR
-    IDS_TYPE_INHERITANCE_RULES_VIOLATED     "Inheritance security rules violated by type: '%1'. Derived types must either match the security accessibility of the base type or be less accessible."
-#endif // FEATURE_CORECLR
     IDS_METHOD_INHERITANCE_RULES_VIOLATED   "Inheritance security rules violated while overriding member: '%1'. Security accessibility of the overriding method must match the security accessibility of the method being overriden."
     IDS_CRITICAL_METHOD_ACCESS_DENIED       "Attempt to access method %1 in violation of security transparency rules failed."
-#ifdef FEATURE_CAS_POLICY
-    IDS_E_LOADFROM_REMOTE_SOURCE            "An attempt was made to load an assembly from a network location which would have caused the assembly to be sandboxed in previous versions of the .NET Framework. This release of the .NET Framework does not enable CAS policy by default, so this load may be dangerous. If this load is not intended to sandbox the assembly, please enable the loadFromRemoteSources switch. See http://go.microsoft.com/fwlink/?LinkId=155569 for more information."
-    IDS_E_LOADFROM_REMOTE_SOURCE_MOTW       "An attempt was made to load an assembly that was downloaded from a network location, which would have caused the assembly to be sandboxed in previous versions of the .NET Framework. This release of the .NET Framework does not enable CAS policy by default, so this load may be dangerous. If this assembly is trusted, either remove the Zone marker from it or enable the loadFromRemoteSources switch. See http://go.microsoft.com/fwlink/?LinkId=155569 for more information."
-#endif // FEATURE_CAS_POLICY
     IDS_CRITICAL_TYPE_ACCESS_DENIED         "Attempt to access type %1 in violation of security transparency rules failed."
     IDS_APPLICATION_ASSEMBLY_EXEC_DENIED    "Application assemblies cannot be directly executed: %1"
     IDS_REFLECTION_METHOD_ACCESS_DENIED     "Application code cannot access %1 using Reflection."
@@ -1574,11 +1554,9 @@ BEGIN
     IDS_E_CRITICAL_FIELD_ACCESS_DENIED      "Attempt by security transparent method '%1' to access security critical field '%2' failed.%3"
     IDS_E_CRITICAL_METHOD_ACCESS_DENIED     "Attempt by security transparent method '%1' to access security critical method '%2' failed.%3"
     IDS_E_CRITICAL_TYPE_ACCESS_DENIED       "Attempt by security transparent method '%1' to access security critical type '%2' failed.%3"
-#ifdef FEATURE_CORECLR
     IDS_E_DELEGATE_BINDING_TRANSPARENCY     "A delegate of type '%1' cannot be bound to the method '%2' due to security transparency rules. Ensure the delegate type and the method being bound have compatible security transparency."
     IDS_E_DELEGATE_FULLTRUST_ARPIC_1        "Delegate '%1' must be bound to a method in a fully-trusted assembly and the method must have the AllowReversePinvokeCallsAttribute."
     IDS_E_DELEGATE_FULLTRUST_ARPIC_2        "Cannot create a Delegate for marshalling out unless it is bound to a method in a fully-trusted assembly and the method has the AllowReversePinvokeCallsAttribute."
-#endif
     IDS_E_ACCESSING_PRIVATE_FRAMEWORK_CODE  "Reflection invocation to internal or private types or members in the framework is not allowed."
 
     IDS_EE_TORNSTATE                        "Unexpected change made to file '%1'."
@@ -1591,10 +1569,6 @@ STRINGTABLE DISCARDABLE
 BEGIN
     IDS_ACCESS_EXCEPTION_CONTEXT_LEVEL2_APTCA           "Assembly '%1' is marked with the AllowPartiallyTrustedCallersAttribute, and uses the level 2 security transparency model.  Level 2 transparency causes all methods in AllowPartiallyTrustedCallers assemblies to become security transparent by default, which may be the cause of this exception."
     IDS_ACCESS_EXCEPTION_CONTEXT_PT_TRANSPARENT         "Assembly '%1' is partially trusted, which causes the CLR to make it entirely security transparent regardless of any transparency annotations in the assembly itself.  In order to access security critical code, this assembly must be fully trusted."
-#ifdef FEATURE_APTCA
-    IDS_ACCESS_EXCEPTION_CONTEXT_APTCA_KILLBIT          "Assembly '%1' has had an APTCA killbit set for it, which prevents it from being used by partial trust or security transparent code."
-    IDS_ACCESS_EXCEPTION_CONTEXT_CONDITIONAL_APTCA      "Assembly '%1' is a conditionally APTCA assembly which is not enabled in the current AppDomain.  To enable this assembly to be used by partial trust or security transparent code, please add assembly name '%2' to the the PartialTrustVisibleAssemblies list when creating the AppDomain."
-#endif // FEATURE_APTCA
 END
 
 // These strings are generated from within the EE for streams
@@ -1612,11 +1586,7 @@ STRINGTABLE DISCARDABLE
 BEGIN
     IDS_ER_APPLICATION                       "Application: "
     IDS_ER_UNKNOWN                           "unknown"
-#ifndef FEATURE_CORECLR
-    IDS_ER_FRAMEWORK_VERSION                 "Framework Version: "
-#else // FEATURE_CORECLR
     IDS_ER_FRAMEWORK_VERSION                 "CoreCLR Version: "
-#endif // !FEATURE_CORECLR
     IDS_ER_UNHANDLEDEXCEPTION                "Description: The process was terminated due to an unhandled exception."
     IDS_ER_UNHANDLEDEXCEPTIONMSG             "Exception Info: "
     IDS_ER_MANAGEDFAILFAST                   "Description: The application requested process termination through System.Environment.FailFast(string message)."
@@ -2121,15 +2091,7 @@ BEGIN
     IDS_DIALOG_BOX_IGNORE_BUTTON        "&Ignore"
 END
 
-#ifndef FEATURE_CORECLR
-// OOB servicing
-STRINGTABLE DISCARDABLE 
-BEGIN
-    IDS_EE_ASSEMBLY_ON_DENY_LIST        "The assembly %1 that the application tried to load has a known vulnerability. Please go to %2 to find a fix for this issue."
-END
-#endif
 
-#ifdef FEATURE_CORECLR
 STRINGTABLE DISCARDABLE 
 BEGIN
     IDS_EE_BADMARSHAL_TYPE_ANSIBSTR                   "Marshalling as AnsiBStr is not supported"
@@ -2140,9 +2102,7 @@ BEGIN
     IDS_EE_BADMARSHAL_TYPE_IDISPATCH                  "Marshalling as IDispatch is not supported"
     IDS_EE_ERROR_IDISPATCH                            "IDispatch and IDispatchEx are not supported"
 END
-#endif // FEATURE_CORECLR
 
-#ifdef FEATURE_HOST_ASSEMBLY_RESOLVER
 STRINGTABLE DISCARDABLE 
 BEGIN
     IDS_HOST_ASSEMBLY_RESOLVER_ASSEMBLY_ALREADY_LOADED_IN_CONTEXT "Assembly with same name is already loaded"
@@ -2150,7 +2110,6 @@ BEGIN
     IDS_HOST_ASSEMBLY_RESOLVER_INCOMPATIBLE_BINDING_CONTEXT "Assembly is already bound to an incompatible binding context."
     IDS_HOST_ASSEMBLY_RESOLVER_INCOMPATIBLE_TPA_BINDING_CONTEXT "Default binding context is already attached to managed load context."
 END
-#endif // FEATURE_HOST_ASSEMBLY_RESOLVER
 
 STRINGTABLE DISCARDABLE 
 BEGIN
diff --git a/src/dlls/mscorrc/nativelog.rc b/src/dlls/mscorrc/nativelog.rc
deleted file mode 100644
index 33e94dc129..0000000000
--- a/src/dlls/mscorrc/nativelog.rc
+++ /dev/null
@@ -1,32 +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.
-#include "nativeres.h"
-
-#ifdef FEATURE_FUSION
-
-STRINGTABLE DISCARDABLE
-BEGIN
-    ID_FUSLOG_NGEN_BIND_IL_PROVIDED                   L"LOG: IL assembly loaded from %ws." 
-    ID_FUSLOG_NGEN_BIND_LOADFROM_NOT_ALLOWED          L"WRN: Native image will not be probed in LoadFrom context. Native image will only be probed in default load context, like with Assembly.Load()."
-    ID_FUSLOG_NGEN_BIND_SUCCESS                       L"LOG: Bind to native image succeeded."
-    ID_FUSLOG_NGEN_BIND_FAIL                          L"ERR: Error encountered when binding to native image assembly. (hr = 0x%x)."
-    ID_FUSLOG_NGEN_BIND_NO_MATCH                      L"WRN: No matching native image found."
-    ID_FUSLOG_NGEN_BIND_NGEN_REJECT_CONFIG_MASK       L"WRN: Native image compile options do not match request. Looking for next native image."
-    ID_FUSLOG_NGEN_BIND_NI_DEPEND_START               L"LOG: [Level %d]Start validating native image dependency %ws."
-    ID_FUSLOG_NGEN_BIND_IL_DEPEND_START               L"LOG: [Level %d]Start validating IL dependency %ws."
-    ID_FUSLOG_NGEN_BIND_VALIDATE_DEPENDENCIES         L"LOG: Start validating all the dependencies."
-    ID_FUSLOG_NGEN_BIND_VALIDATE_DEPENDENCIES_SUCCESS L"LOG: Validation of dependencies succeeded."
-    ID_FUSLOG_NGEN_BIND_REJECT_IL_NOT_FOUND           L"WRN: Cannot load IL assembly. (hr = 0x%x)."
-    ID_FUSLOG_NGEN_BIND_MISSING_FOUND                 L"WRN: Dependency assembly was not found at ngen time, but is found at binding time. Disallow using this native image."
-    ID_FUSLOG_NGEN_BIND_AUXCORRUPTION_GENERAL         L"ERR: Rejecting native image due to corrupted or missing .aux file (%ws)."
-    ID_FUSLOG_NGEN_BIND_AUX_REOPTIMIZED               L"LOG: Successfully updated stale timestamp in .aux file (%ws)."
-    ID_FUSLOG_NGEN_BIND_REJECT_SIG                    L"WRN: Signature of the IL assembly does not match record in .aux file. Validation stops."
-    ID_FUSLOG_NGEN_BIND_REJECT_TP                     L"WRN: TPBand of the IL assembly does not match record in .aux file. Validation stops."
-    ID_FUSLOG_NGEN_BIND_REJECT_TIMESTAMP_SIGFALLBACK  L"WRN: Timestamp of the IL assembly does not match record in .aux file. Loading IL to compare signature."
-    ID_FUSLOG_NGEN_BIND_REJECT_TIMESTAMP_TPFALLBACK   L"WRN: Timestamp of the IL assembly does not match record in .aux file. Loading IL to compare TPBand."
-    ID_FUSLOG_NGEN_BIND_CHANGED_BINDING_POLICY        L"WRN: Assembly resolved to a different version or identity than expected. Check if binding policy changed since native image built."
-    ID_FUSLOG_NGEN_BIND_REJECT_OPTOUT                 L"WRN: The application has opted out of using native images for this assembly."
-END
-
-#endif // FEATURE_FUSION
diff --git a/src/dlls/mscorrc/nativeres.h b/src/dlls/mscorrc/nativeres.h
deleted file mode 100644
index d1315176f8..0000000000
--- a/src/dlls/mscorrc/nativeres.h
+++ /dev/null
@@ -1,35 +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.
-#ifndef __NATIVE_BINDER_RESOURCE_H_
-#define __NATIVE_BINDER_RESOURCE_H_
-
-#ifdef FEATURE_FUSION
-
-#define ID_FUSLOG_NGEN_BIND_IL_PROVIDED                   10204
-#define ID_FUSLOG_NGEN_BIND_LOADFROM_NOT_ALLOWED          10174
-#define ID_FUSLOG_NGEN_BIND_SUCCESS                       10171
-#define ID_FUSLOG_NGEN_BIND_FAIL                          10172
-#define ID_FUSLOG_NGEN_BIND_NO_MATCH                      10179
-#define ID_FUSLOG_NGEN_BIND_NGEN_REJECT_CONFIG_MASK       10178
-#define ID_FUSLOG_NGEN_BIND_NI_DEPEND_START               10206
-#define ID_FUSLOG_NGEN_BIND_IL_DEPEND_START               10207
-#define ID_FUSLOG_NGEN_BIND_VALIDATE_DEPENDENCIES         10197
-#define ID_FUSLOG_NGEN_BIND_VALIDATE_DEPENDENCIES_SUCCESS 10200
-#define ID_FUSLOG_NGEN_BIND_REJECT_IL_NOT_FOUND           10183
-#define ID_FUSLOG_NGEN_BIND_MISSING_FOUND                 10209
-
-// Ids 10400 - 10500 reserved for new native binder messages
-// If more ids are needed, reserve them in fusres.h
-#define ID_FUSLOG_NGEN_BIND_AUXCORRUPTION_GENERAL         10400
-#define ID_FUSLOG_NGEN_BIND_AUX_REOPTIMIZED               10401
-#define ID_FUSLOG_NGEN_BIND_REJECT_SIG                    10402
-#define ID_FUSLOG_NGEN_BIND_REJECT_TP                     10403
-#define ID_FUSLOG_NGEN_BIND_REJECT_TIMESTAMP_SIGFALLBACK  10404
-#define ID_FUSLOG_NGEN_BIND_REJECT_TIMESTAMP_TPFALLBACK   10405
-#define ID_FUSLOG_NGEN_BIND_CHANGED_BINDING_POLICY        10406
-#define ID_FUSLOG_NGEN_BIND_REJECT_OPTOUT                 10407
-
-#endif // FEATURE_FUSION
-
-#endif // __NATIVE_BINDER_RESOURCE_H_
diff --git a/src/dlls/mscorrc/resource.h b/src/dlls/mscorrc/resource.h
index 77e937a81e..6153246bb4 100644
--- a/src/dlls/mscorrc/resource.h
+++ b/src/dlls/mscorrc/resource.h
@@ -812,16 +812,12 @@
 #define IDS_E_TRANSPARENT_CALL_NATIVE           0x2120
 #define IDS_E_TRANSPARENT_REFLECTION            0x2121
 
-#ifdef FEATURE_CORECLR
 #define IDS_E_DELEGATE_BINDING_TRANSPARENCY     0x2122
-#endif
 
 #define IDS_E_ACCESSING_PRIVATE_FRAMEWORK_CODE  0x2123
 
-#ifdef FEATURE_CORECLR
 #define IDS_E_DELEGATE_FULLTRUST_ARPIC_1          0x2124
 #define IDS_E_DELEGATE_FULLTRUST_ARPIC_2          0x2125
-#endif
 
 #define IDS_ACCESS_EXCEPTION_CONTEXT_LEVEL2_APTCA       0x2200
 #define IDS_ACCESS_EXCEPTION_CONTEXT_APTCA_KILLBIT      0x2201
@@ -870,10 +866,8 @@
 #define IDS_E_PROF_TIMEOUT_WAITING_FOR_CONCURRENT_GC    0x251D
 
 
-#ifdef FEATURE_CORECLR
 #define IDS_EE_LINK_FOR_ERROR_MESSAGES          0x2600
 #define IDS_EE_LINK_FOR_DEBUGGING_MESSAGES      0x2601          
-#endif
 
 #define IDS_DIALOG_BOX_ABORT_BUTTON             0x2602
 #define IDS_DIALOG_BOX_DEBUG_BUTTON             0x2603
@@ -920,15 +914,11 @@
 #define IDS_EE_INTEROP_DLL_IMPORT_ON_USER_METHOD 0x262b
 #endif
 
-#ifndef FEATURE_CORECLR
-#define IDS_EE_ASSEMBLY_ON_DENY_LIST            0x262c
-#endif
 
 #ifdef FEATURE_COMINTEROP
 #define IDS_EE_WINRT_WEAKREF_BAD_TYPE           0x262e
 #endif // FEATURE_COMINTEROP
 
-#ifdef FEATURE_CORECLR
 #define IDS_EE_BADMARSHAL_TYPE_ANSIBSTR         0x262f
 #define IDS_EE_BADMARSHAL_TYPE_VBBYVALSTR       0x2630
 #define IDS_EE_BADMARSHAL_TYPE_REFERENCECUSTOMMARSHALER  0x2631
@@ -936,14 +926,11 @@
 #define IDS_EE_BADMARSHAL_TYPE_ASANYA           0x2633
 #define IDS_EE_BADMARSHAL_TYPE_IDISPATCH        0x2634
 #define IDS_EE_ERROR_IDISPATCH                  0x2635
-#endif // FEATURE_CORECLR
 
-#ifdef FEATURE_HOST_ASSEMBLY_RESOLVER
 #define IDS_HOST_ASSEMBLY_RESOLVER_ASSEMBLY_ALREADY_LOADED_IN_CONTEXT                  0x2636
 #define IDS_HOST_ASSEMBLY_RESOLVER_DYNAMICALLY_EMITTED_ASSEMBLIES_UNSUPPORTED          0x2637
 #define IDS_HOST_ASSEMBLY_RESOLVER_INCOMPATIBLE_BINDING_CONTEXT                        0x2638
 #define IDS_HOST_ASSEMBLY_RESOLVER_INCOMPATIBLE_TPA_BINDING_CONTEXT                    0x2639
-#endif // FEATURE_HOST_ASSEMBLY_RESOLVER
 
 #define IDS_NATIVE_IMAGE_CANNOT_BE_LOADED_MULTIPLE_TIMES                               0x263a
 
diff --git a/src/gc/gc.cpp b/src/gc/gc.cpp
index df77170d2b..66c8b6afbc 100644
--- a/src/gc/gc.cpp
+++ b/src/gc/gc.cpp
@@ -7042,6 +7042,7 @@ int gc_heap::grow_brick_card_tables (uint8_t* start,
     uint8_t* ha = g_gc_highest_address;
     uint8_t* saved_g_lowest_address = min (start, g_gc_lowest_address);
     uint8_t* saved_g_highest_address = max (end, g_gc_highest_address);
+    seg_mapping* new_seg_mapping_table = nullptr;
 #ifdef BACKGROUND_GC
     // This value is only for logging purpose - it's not necessarily exactly what we 
     // would commit for mark array but close enough for diagnostics purpose.
@@ -7202,14 +7203,18 @@ int gc_heap::grow_brick_card_tables (uint8_t* start,
 
 #ifdef GROWABLE_SEG_MAPPING_TABLE
         {
-            seg_mapping* new_seg_mapping_table = (seg_mapping*)(mem + st_table_offset_aligned);
+            new_seg_mapping_table = (seg_mapping*)(mem + st_table_offset_aligned);
             new_seg_mapping_table = (seg_mapping*)((uint8_t*)new_seg_mapping_table -
                                               size_seg_mapping_table_of (0, (align_lower_segment (saved_g_lowest_address))));
             memcpy(&new_seg_mapping_table[seg_mapping_word_of(g_gc_lowest_address)],
                 &seg_mapping_table[seg_mapping_word_of(g_gc_lowest_address)],
                 size_seg_mapping_table_of(g_gc_lowest_address, g_gc_highest_address));
 
-            seg_mapping_table = new_seg_mapping_table;
+            // new_seg_mapping_table gets assigned to seg_mapping_table at the bottom of this function,
+            // not here. The reason for this is that, if we fail at mark array committing (OOM) and we've
+            // already switched seg_mapping_table to point to the new mapping table, we'll decommit it and
+            // run into trouble. By not assigning here, we're making sure that we will not change seg_mapping_table
+            // if an OOM occurs.
         }
 #endif //GROWABLE_SEG_MAPPING_TABLE
 
@@ -7223,7 +7228,7 @@ int gc_heap::grow_brick_card_tables (uint8_t* start,
         translated_ct = translate_card_table (ct);
 
         dprintf (GC_TABLE_LOG, ("card table: %Ix(translated: %Ix), seg map: %Ix, mark array: %Ix", 
-            (size_t)ct, (size_t)translated_ct, (size_t)seg_mapping_table, (size_t)card_table_mark_array (ct)));
+            (size_t)ct, (size_t)translated_ct, (size_t)new_seg_mapping_table, (size_t)card_table_mark_array (ct)));
 
 #ifdef BACKGROUND_GC
         if (hp->should_commit_mark_array())
@@ -7301,6 +7306,9 @@ int gc_heap::grow_brick_card_tables (uint8_t* start,
             g_gc_card_table = translated_ct;
         }
 
+        seg_mapping_table = new_seg_mapping_table;
+
+        GCToOSInterface::FlushProcessWriteBuffers();
         g_gc_lowest_address = saved_g_lowest_address;
         g_gc_highest_address = saved_g_highest_address;
 
diff --git a/src/ilasm/asmman.cpp b/src/ilasm/asmman.cpp
index dba481faf2..0f0d1cff71 100644
--- a/src/ilasm/asmman.cpp
+++ b/src/ilasm/asmman.cpp
@@ -10,9 +10,6 @@
 
 #include "assembler.h"
 #include "strongname.h"
-#ifndef FEATURE_CORECLR
-#include "LegacyActivationShim.h"
-#endif
 #include <limits.h>
 #include <fusion.h>
 
@@ -153,78 +150,6 @@ void    AsmMan::SetModuleName(__inout_opt __nullterminated char* szName)
     }
 }
 //==============================================================================================================
-// Borrowed from VM\assembly.cpp
-#ifndef FEATURE_CORECLR
-HRESULT GetHash(__in LPWSTR moduleName,
-                          ALG_ID iHashAlg,
-                          BYTE** pbCurrentValue,  // should be NULL
-                          DWORD *cbCurrentValue)
-{
-    HRESULT     hr = E_FAIL;
-    HCRYPTPROV  hProv = 0;
-    HCRYPTHASH  hHash = 0;
-    DWORD       dwCount = sizeof(DWORD);
-    PBYTE       pbBuffer = NULL;
-    DWORD       dwBufferLen;
-    HANDLE      hFile = INVALID_HANDLE_VALUE;
-    HANDLE      hMapFile = NULL;
-    
-    hFile = WszCreateFile(moduleName, GENERIC_READ, FILE_SHARE_READ,
-                         0, OPEN_EXISTING, 0, 0);
-    if (hFile == INVALID_HANDLE_VALUE) return E_FAIL;
-
-    dwBufferLen = SafeGetFileSize(hFile,NULL);
-    if (dwBufferLen == 0xffffffff)
-    {
-        hr = HRESULT_FROM_WIN32(GetLastError());
-        goto exit;
-    }
-    hMapFile = WszCreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
-    if (hMapFile == NULL) goto exit;
-
-    pbBuffer = (PBYTE) MapViewOfFile(hMapFile, FILE_MAP_READ, 0, 0, 0);
-    if (pbBuffer == NULL) goto exit;
-
-    // No need to late bind this stuff, all these crypto API entry points happen
-    // to live in ADVAPI32.
-
-    if ((!WszCryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) ||
-        (!CryptCreateHash(hProv, iHashAlg, 0, 0, &hHash)) ||
-        (!CryptHashData(hHash, pbBuffer, dwBufferLen, 0)) ||
-        (!CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE *) cbCurrentValue, 
-                            &dwCount, 0))) {
-        hr = HRESULT_FROM_WIN32(GetLastError());
-        goto exit;
-    }
-
-    *pbCurrentValue = new BYTE[*cbCurrentValue];
-    if (!(*pbCurrentValue)) {
-        hr = E_OUTOFMEMORY;
-        goto exit;
-    }
-
-    if(!CryptGetHashParam(hHash, HP_HASHVAL, *pbCurrentValue, cbCurrentValue, 0)) {
-        hr = HRESULT_FROM_WIN32(GetLastError());
-        delete[] *pbCurrentValue;
-        *pbCurrentValue = 0;
-        goto exit;
-    }
-
-    hr = S_OK;
-
- exit:
-    if (pbBuffer) UnmapViewOfFile(pbBuffer);
-    if (hMapFile) CloseHandle(hMapFile); 
-    CloseHandle(hFile);
-    if (hHash)
-        CryptDestroyHash(hHash);
-    if (hProv)
-        CryptReleaseContext(hProv, 0);
-
-    return hr;
-}
-#endif // !FEATURE_CORECLR
-//==============================================================================================================
 
 void    AsmMan::AddFile(__in __nullterminated char* szName, DWORD dwAttr, BinStr* pHashBlob)
 {
@@ -277,13 +202,6 @@ void    AsmMan::EmitFiles()
             if(m_pAssembly      // and assembly is defined
                 && m_pAssembly->ulHashAlgorithm) // and hash algorithm is defined...
             { // then try to compute it
-#ifndef FEATURE_CORECLR
-                if(SUCCEEDED(GetHash(wzUniBuf,(ALG_ID)(m_pAssembly->ulHashAlgorithm),&pHash,&cbHash)))
-                {
-                    tmp->pHash = new BinStr(pHash,cbHash);
-                }
-                else
-#endif // !FEATURE_CORECLR
                 {
                     pHash = NULL;
                     cbHash = 0;
@@ -449,145 +367,6 @@ void    AsmMan::EndAssembly()
                 m_pCurAsmRef = NULL;
                 return;
             }
-#ifndef FEATURE_CORECLR
-            if(m_pCurAsmRef->isAutodetect)
-            {
-                IAssemblyName* pIAsmName;
-                HRESULT hr;
-                // Convert name to Unicode
-                WszMultiByteToWideChar(g_uCodePage,0,m_pCurAsmRef->szName,-1,wzUniBuf,dwUniBuf);
-                hr = CreateAssemblyNameObject(&pIAsmName,wzUniBuf,CANOF_PARSE_DISPLAY_NAME,NULL);
-                if(SUCCEEDED(hr))
-                {
-                    // set enumeration criteria: what is known about AsmRef (besides name)
-                    if(m_pCurAsmRef->usVerMajor != (USHORT)0xFFFF)
-                        pIAsmName->SetProperty(ASM_NAME_MAJOR_VERSION,&(m_pCurAsmRef->usVerMajor),2);
-                    if(m_pCurAsmRef->usVerMinor != (USHORT)0xFFFF)
-                        pIAsmName->SetProperty(ASM_NAME_MINOR_VERSION,&(m_pCurAsmRef->usVerMinor),2);
-                    if(m_pCurAsmRef->usBuild != (USHORT)0xFFFF)
-                        pIAsmName->SetProperty(ASM_NAME_BUILD_NUMBER,&(m_pCurAsmRef->usBuild),2);
-                    if(m_pCurAsmRef->usRevision != (USHORT)0xFFFF)
-                        pIAsmName->SetProperty(ASM_NAME_REVISION_NUMBER,&(m_pCurAsmRef->usRevision),2);
-                    if(m_pCurAsmRef->pPublicKeyToken)
-                        pIAsmName->SetProperty(ASM_NAME_PUBLIC_KEY_TOKEN,
-                                               m_pCurAsmRef->pPublicKeyToken->ptr(),
-                                               m_pCurAsmRef->pPublicKeyToken->length());
-                    if(m_pCurAsmRef->pLocale)
-                        pIAsmName->SetProperty(ASM_NAME_CULTURE,
-                                               m_pCurAsmRef->pLocale->ptr(),
-                                               m_pCurAsmRef->pLocale->length());
-
-                    // enumerate assemblies
-                    IAssemblyEnum* pIAsmEnum = NULL;
-                    hr = CreateAssemblyEnum(&pIAsmEnum, NULL, pIAsmName, ASM_CACHE_GAC, NULL);
-                    if(SUCCEEDED(hr))
-                    {
-                        IAssemblyName* pIAsmNameFound;
-                        IAssemblyName* pIAsmNameLatestVer = NULL;
-                        ULONGLONG   ullVer=0, ullVerLatest=0;
-                        DWORD  dwVerHi, dwVerLo;
-    
-                        // find the latest and greatest, if any
-                        for(;;)
-                        {
-                            pIAsmNameFound = NULL;
-                            hr = pIAsmEnum->GetNextAssembly(NULL,&pIAsmNameFound,0); 
-                            if(SUCCEEDED(hr) && pIAsmNameFound)
-                            {
-    
-                                pIAsmNameFound->GetVersion(&dwVerHi,&dwVerLo);
-                                ullVer = (ULONGLONG)dwVerHi;
-                                ullVer <<= sizeof(DWORD);
-                                ullVer |= dwVerLo;
-                                if(ullVer > ullVerLatest)
-                                {
-                                    if(pIAsmNameLatestVer)
-                                       pIAsmNameLatestVer->Release(); 
-                                    ullVerLatest = ullVer;
-                                    pIAsmNameLatestVer = pIAsmNameFound;
-                                }
-                                else
-                                    pIAsmNameFound->Release();
-                            }
-                            else break;
-                        }
-                        // if found, fill the gaps
-                        if(pIAsmNameLatestVer)
-                        {
-                            DWORD cbSize=0;
-                            USHORT usDummy=0;
-
-                            if(m_pCurAsmRef->pPublicKeyToken == NULL)
-                            {
-                                cbSize = 1024;
-                                pIAsmNameLatestVer->GetProperty(ASM_NAME_PUBLIC_KEY_TOKEN,
-                                                wzUniBuf, &cbSize);
-                                if(cbSize)
-                                {
-                                    if((m_pCurAsmRef->pPublicKeyToken = new BinStr()))
-                                        memcpy(m_pCurAsmRef->pPublicKeyToken->getBuff(cbSize),
-                                            wzUniBuf, cbSize);
-                                }
-                            }
-    
-                            if(m_pCurAsmRef->usVerMajor == (USHORT)0xFFFF)
-                            {
-                                cbSize = (DWORD)sizeof(WORD);
-                                pIAsmNameLatestVer->GetProperty(ASM_NAME_MAJOR_VERSION,
-                                                &usDummy, &cbSize);
-                                m_pCurAsmRef->usVerMajor = usDummy;
-                            }
-                            if(m_pCurAsmRef->usVerMinor == (USHORT)0xFFFF)
-                            {
-                                cbSize = (DWORD)sizeof(WORD);
-                                pIAsmNameLatestVer->GetProperty(ASM_NAME_MINOR_VERSION,
-                                                &usDummy, &cbSize);
-                                m_pCurAsmRef->usVerMinor = usDummy;
-                            }
-                            if(m_pCurAsmRef->usBuild == (USHORT)0xFFFF)
-                            {
-                                cbSize = (DWORD)sizeof(WORD);
-                                pIAsmNameLatestVer->GetProperty(ASM_NAME_BUILD_NUMBER,
-                                                &usDummy, &cbSize);
-                                m_pCurAsmRef->usBuild = usDummy;
-                            }
-                            if(m_pCurAsmRef->usRevision == (USHORT)0xFFFF)
-                            {
-                                cbSize = (DWORD)sizeof(WORD);
-                                pIAsmNameLatestVer->GetProperty(ASM_NAME_REVISION_NUMBER,
-                                                &usDummy, &cbSize);
-                                m_pCurAsmRef->usRevision = usDummy;
-                            }
-                            
-                            if(m_pCurAsmRef->pLocale == NULL)
-                            {
-                                cbSize = 1024;
-                                pIAsmNameLatestVer->GetProperty(ASM_NAME_CULTURE,
-                                                wzUniBuf, &cbSize);
-
-                                if(cbSize > (DWORD)sizeof(WCHAR))
-                                {
-                                    if((m_pCurAsmRef->pLocale = new BinStr()))
-                                        memcpy(m_pCurAsmRef->pLocale->getBuff(cbSize),
-                                            wzUniBuf, cbSize);
-                                }
-                            }
-                            pIAsmNameLatestVer->Release(); 
-                        }
-                        else
-                            report->warn("Failed to autodetect assembly '%s'\n",m_pCurAsmRef->szName);
-                        // if no assembly found, leave it as is, it might be not a GAC assembly
-    
-                        pIAsmEnum->Release();
-                    }
-                    else
-                        report->error("Failed to enum assemblies %S, hr=0x%08X\n",wzUniBuf,hr);
-                    pIAsmName->Release();
-                }
-                else
-                    report->error("Failed to create assembly name object for %S, hr=0x%08X\n",wzUniBuf,hr);
-            } // end if isAutodetect
-#endif // !FEATURE_CORECLR
             m_AsmRefLst.PUSH(m_pCurAsmRef);
             m_pCurAsmRef->tkTok = TokenFromRid(m_AsmRefLst.COUNT(),mdtAssemblyRef);
         }
@@ -608,29 +387,9 @@ void    AsmMan::EndAssembly()
                 // character of the source ('@' for container).
                 if (*(((Assembler*)m_pAssembler)->m_wzKeySourceName) == L'@')
                 {
-#ifdef FEATURE_CORECLR
                     report->error("Error: ilasm on CoreCLR does not support getting public key from container.\n");
                     m_pCurAsmRef = NULL;
                     return;
-#else
-                    // Extract public key from container (works whether
-                    // container has just a public key or an entire key
-                    // pair).
-                    m_sStrongName.m_wzKeyContainer = &((Assembler*)m_pAssembler)->m_wzKeySourceName[1];
-                    if (FAILED(hr = LegacyActivationShim::StrongNameGetPublicKey_HRESULT(
-                        m_sStrongName.m_wzKeyContainer, 
-                        NULL, 
-                        0, 
-                        &m_sStrongName.m_pbPublicKey, 
-                        &m_sStrongName.m_cbPublicKey)))
-                    {
-                        report->error("Failed to extract public key from '%S': 0x%08X\n",m_sStrongName.m_wzKeyContainer,hr);
-                        m_pCurAsmRef = NULL;
-                        return;
-                    }
-                    m_sStrongName.m_fFullSign = TRUE;
-                    m_sStrongName.m_dwPublicKeyAllocated = AsmManStrongName::AllocatedBySNApi;
-#endif // FEATURE_CORECLR
                 }
                 else
                 {
@@ -696,33 +455,9 @@ void    AsmMan::EndAssembly()
                     // from a consistent place.
                     if (m_sStrongName.m_fFullSign)
                     {
-#ifdef FEATURE_CORECLR
                         report->error("Error: ilasm on CoreCLR does not support full sign.\n");
                         m_pCurAsmRef = NULL;
                         return;
-#else
-                        m_sStrongName.m_pbPrivateKey = m_sStrongName.m_pbPublicKey;
-                        m_sStrongName.m_cbPrivateKey = m_sStrongName.m_cbPublicKey;
-
-                        m_sStrongName.m_pbPublicKey = NULL;
-                        m_sStrongName.m_cbPublicKey = NULL;
-                        m_sStrongName.m_dwPublicKeyAllocated = AsmManStrongName::NotAllocated;
-
-                        // Retrieve the public key portion as a byte blob.
-                        if (FAILED(hr = LegacyActivationShim::StrongNameGetPublicKey_HRESULT(
-                            NULL, 
-                            m_sStrongName.m_pbPrivateKey, 
-                            m_sStrongName.m_cbPrivateKey, 
-                            &m_sStrongName.m_pbPublicKey, 
-                            &m_sStrongName.m_cbPublicKey)))
-                        {
-                            report->error("Failed to extract public key: 0x%08X\n",hr);
-                            m_pCurAsmRef = NULL;
-                            return;
-                        }
-    
-                        m_sStrongName.m_dwPublicKeyAllocated = AsmManStrongName::AllocatedBySNApi;
-#endif // FEATURE_CORECLR
                     }
                 }
             }
diff --git a/src/ilasm/asmman.hpp b/src/ilasm/asmman.hpp
index 35d8fdc0bc..0ee875b805 100644
--- a/src/ilasm/asmman.hpp
+++ b/src/ilasm/asmman.hpp
@@ -9,9 +9,6 @@
 #define ASMMAN_HPP
 
 #include "strongname.h"
-#ifndef FEATURE_CORECLR
-#include "LegacyActivationShim.h"
-#endif
 #include "specstrings.h"
 
 struct AsmManFile
@@ -173,13 +170,6 @@ struct AsmManStrongName
     AsmManStrongName() { ZeroMemory(this, sizeof(*this)); }
     ~AsmManStrongName()
     {
-#ifndef FEATURE_CORECLR
-        if (m_dwPublicKeyAllocated == AllocatedBySNApi)
-        {
-            LegacyActivationShim::StrongNameFreeBuffer(m_pbPublicKey);
-        }
-        else
-#endif
         if (m_dwPublicKeyAllocated == AllocatedByNew)
             delete [] m_pbPublicKey;
 
diff --git a/src/ilasm/asmtemplates.h b/src/ilasm/asmtemplates.h
index eb2b413abf..b7d3025f02 100644
--- a/src/ilasm/asmtemplates.h
+++ b/src/ilasm/asmtemplates.h
@@ -60,54 +60,6 @@ private:
 };
 
 
-#if (0)
-template <class T>
-class FIFO
-{
-public:
-    inline FIFO() { m_pHead = m_pTail = NULL; m_ulCount = 0;};
-    inline ~FIFO() {T *val; while(val = POP()) delete val; };
-    void PUSH(T *item) 
-    {
-        m_pTemp = new LIST_EL <T>(item); 
-        if(m_pTail) m_pTail->m_Next = m_pTemp;
-        m_pTail = m_pTemp;
-        if(m_pHead == NULL) m_pHead = m_pTemp;
-        m_ulCount++;
-    };
-    T* POP() 
-    {
-        T* ret = NULL;
-        if(m_pTemp = m_pHead)
-        {
-            m_pHead = m_pHead->m_Next;
-            ret = m_pTemp->m_Ptr;
-            delete m_pTemp;
-            if(m_pHead == NULL) m_pTail = NULL;
-            m_ulCount--;
-        }
-        return ret;
-    };
-    ULONG COUNT() { return m_ulCount; };
-    T* PEEK(ULONG idx)
-    {
-        T* ret = NULL;
-        ULONG   i;
-        if(idx < m_ulCount)
-        {
-            if(idx == m_ulCount-1) m_pTemp = m_pTail;
-            else for(m_pTemp = m_pHead, i = 0; i < idx; m_pTemp = m_pTemp->m_Next, i++);
-            ret = m_pTemp->m_Ptr;
-        }
-        return ret;
-    };
-private:
-    LIST_EL <T> *m_pHead;
-    LIST_EL <T> *m_pTail;
-    LIST_EL <T> *m_pTemp;
-    ULONG       m_ulCount;
-};
-#else
 template <class T>
 class FIFO
 {
@@ -180,7 +132,6 @@ private:
     ULONG       m_ulOffset;
     ULONG       m_ulArrLen;
 };
-#endif
 
 
 template <class T> struct Indx256
diff --git a/src/ilasm/assem.cpp b/src/ilasm/assem.cpp
index 18247621f9..6416dfe5c7 100644
--- a/src/ilasm/assem.cpp
+++ b/src/ilasm/assem.cpp
@@ -231,24 +231,18 @@ Assembler::~Assembler()
         m_pDisp = NULL;
     }
 
-#ifdef FEATURE_CORECLR
 #ifdef FEATURE_PAL
     if (g_loader != NULL)
     {
         g_loader->Finish();
     }
 #endif
-#else
-    if (m_fDidCoInitialise)
-        CoUninitialize();
-#endif // FEATURE_CORECLR
 
 }
 
 
 BOOL Assembler::Init()
 {
-#ifdef FEATURE_CORECLR
 #ifdef FEATURE_PAL
     g_loader = CoreCLRLoader::Create(g_pszExeFile);
     if (g_loader == NULL)
@@ -259,14 +253,6 @@ BOOL Assembler::Init()
 #else
     metaDataGetDispenser = (MetaDataGetDispenserFunc)MetaDataGetDispenser;
 #endif // FEATURE_PAL
-#else
-    if(!m_fDidCoInitialise)
-    {
-        if (FAILED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
-            return FALSE;
-        m_fDidCoInitialise = TRUE;
-    }
-#endif // FEATURE_CORECLR
     if (m_pCeeFileGen != NULL) {
         if (m_pCeeFile)
             m_pCeeFileGen->DestroyCeeFile(&m_pCeeFile);
diff --git a/src/ilasm/assembler.cpp b/src/ilasm/assembler.cpp
index 49d4ee9712..92fd681af6 100644
--- a/src/ilasm/assembler.cpp
+++ b/src/ilasm/assembler.cpp
@@ -99,17 +99,6 @@ mdToken Assembler::ResolveClassRef(mdToken tkResScope, __in __nullterminated con
     mdToken *ptkSpecial = NULL;
 
     if(pszFullClassName == NULL) return mdTokenNil;
-#if (0)
-    if (m_fInitialisedMetaData == FALSE)
-    {
-        if (FAILED(InitMetaData())) // impl. see WRITER.CPP
-        {
-            _ASSERTE(0);
-            if(ppClass) *ppClass = NULL;
-            return mdTokenNil;
-        }
-    }
-#endif
 
     switch(strlen(pszFullClassName))
     {
@@ -2213,26 +2202,6 @@ void Assembler::EmitBytes(BYTE *p, unsigned len)
 BinStr* Assembler::EncodeSecAttr(__in __nullterminated char* szReflName, BinStr* pbsSecAttrBlob, unsigned nProps)
 {
     unsigned cnt;
-#if (0)
-    // Emit MemberRef for .ctor
-    mdToken tkMscorlib = m_fIsMscorlib ? 1 : GetAsmRef("mscorlib");
-    char buffer[64];
-    BinStr  *pbsSig = new BinStr();
-
-    strcpy(buffer,"System.Security.Permissions.SecurityAction");
-    mdToken tkSecAction = ResolveClassRef(tkMscorlib,buffer, NULL);
-
-    pbsSig->appendInt8(IMAGE_CEE_CS_CALLCONV_HASTHIS);
-    pbsSig->appendInt8(1); //corEmitInt(pbsSig,1);
-    pbsSig->appendInt8(ELEMENT_TYPE_VOID);
-    pbsSig->appendInt8(ELEMENT_TYPE_VALUETYPE);
-    cnt = CorSigCompressToken(tkSecAction, pbsSig->getBuff(5));
-    pbsSig->remove(5 - cnt);
-    
-    char* szName = new char[16];
-    strcpy(szName,".ctor");
-    MakeMemberRef(tkSecAttr,szName,pbsSig);
-#endif
 
     // build the blob As BinStr
     unsigned L = (unsigned) strlen(szReflName);
diff --git a/src/ilasm/assembler.h b/src/ilasm/assembler.h
index cbb591ac1c..2e3404f7d3 100644
--- a/src/ilasm/assembler.h
+++ b/src/ilasm/assembler.h
@@ -56,7 +56,7 @@
 extern CoreCLRLoader *g_loader;
 extern char *g_pszExeFile;
 #endif
-typedef int(*MetaDataGetDispenserFunc) (
+typedef int(STDAPICALLTYPE *MetaDataGetDispenserFunc) (
     REFCLSID    rclsid,                 // The class to desired.
     REFIID      riid,                   // Interface wanted on class factory.
     LPVOID FAR  *ppv);                  // Return interface pointer here.
@@ -1049,10 +1049,6 @@ public:
     void EmitSecurityInfo(mdToken           token,
                           PermissionDecl*   pPermissions,
                           PermissionSetDecl*pPermissionSets);
-#ifndef FEATURE_CORECLR
-    HRESULT AllocateStrongNameSignature();
-    HRESULT StrongNameSign();
-#endif
     BinStr* EncodeSecAttr(__in __nullterminated char* szReflName, BinStr* pbsSecAttrBlob, unsigned nProps);
 
     // Custom values paraphernalia:
@@ -1189,9 +1185,6 @@ public:
     unsigned NumTypeDefs() {return m_TypeDefDList.COUNT();};
 private:
     HRESULT GetCAName(mdToken tkCA, __out LPWSTR *ppszName);
-#ifndef FEATURE_CORECLR
-    HRESULT GetSignatureKey();
-#endif
 };
 
 #endif  // Assember_h
diff --git a/src/ilasm/grammar_after.cpp b/src/ilasm/grammar_after.cpp
index c8634801c7..344e504f05 100644
--- a/src/ilasm/grammar_after.cpp
+++ b/src/ilasm/grammar_after.cpp
@@ -372,16 +372,6 @@ static void AppendStringWithLength(BinStr* pbs, __in __nullterminated char* sz)
 /* fetch the next token, and return it   Also set the yylval.union if the
    lexical token also has a value */
    
-#if (0)   
-
-#define IsAlpha(x) ((('A' <= (x))&&((x) <= 'Z'))||(('a' <= (x))&&((x) <= 'z')))
-#define IsDigit(x) (('0' <= (x))&&((x) <= '9'))
-#define IsAlNum(x) (IsAlpha(x) || IsDigit(x))
-#define IsValidStartingSymbol(x) (IsAlpha(x)||((x)=='#')||((x)=='_')||((x)=='@')||((x)=='$'))
-#define IsValidContinuingSymbol(x) (IsAlNum(x)||((x)=='_')||((x)=='@')||((x)=='$')||((x)=='?'))
-void SetSymbolTables() { ; }
-
-#else
 
 BOOL _Alpha[128];
 BOOL _Digit[128];
@@ -433,7 +423,6 @@ BOOL IsAlNum(unsigned x) { return (x < 128)&&_AlNum[x]; }
 BOOL IsValidStartingSymbol(unsigned x) { return (x < 128)&&_ValidSS[x]; }     
 BOOL IsValidContinuingSymbol(unsigned x) { return (x < 128)&&_ValidCS[x]; } 
 
-#endif
 
 char* nextBlank(__in __nullterminated char* curPos)
 {
diff --git a/src/ilasm/grammar_before.cpp b/src/ilasm/grammar_before.cpp
index 42d2927fa5..dd30416bae 100644
--- a/src/ilasm/grammar_before.cpp
+++ b/src/ilasm/grammar_before.cpp
@@ -29,17 +29,6 @@ static AsmParse* parser = 0;
 #define PASMM   (parser->assem->m_pManifest)
 #define PENV    (parser->penv)
 
-#if (0)
-
-#define nextchar                parser->penv->pfn_nextchar
-#define Sym                     parser->penv->pfn_Sym
-#define NewStrFromToken         parser->penv->pfn_NewStrFromToken
-#define NewStaticStrFromToken   parser->penv->pfn_NewStaticStrFromToken
-#define GetDouble               parser->penv->pfn_GetDouble
-
-void SetFunctionPtrs() {;}
-
-#else
 
 
 PFN_NEXTCHAR    nextchar;
@@ -57,7 +46,6 @@ void SetFunctionPtrs()
     GetDouble = PENV->pfn_GetDouble;
 }    
     
-#endif    
 
 static char* newStringWDel(__in __nullterminated char* str1, char delimiter, __in __nullterminated char* str3 = 0);
 static char* newString(__in __nullterminated const char* str1);
diff --git a/src/ilasm/main.cpp b/src/ilasm/main.cpp
index 2bef40dd47..35f4545a05 100644
--- a/src/ilasm/main.cpp
+++ b/src/ilasm/main.cpp
@@ -248,12 +248,8 @@ extern "C" int _cdecl wmain(int argc, __in WCHAR **argv)
                     else if (!_stricmp(szOpt, "DEB"))
                     {
                       pAsm->m_dwIncludeDebugInfo = 0x101;
-#ifdef FEATURE_CORECLR
                       // PDB is ignored under 'DEB' option for ilasm on CoreCLR.
                       // https://github.com/dotnet/coreclr/issues/2982
-#else
-                      pAsm->m_fGeneratePDB = TRUE;
-#endif
                       bNoDebug = FALSE;
 
                       WCHAR *pStr = EqualOrColon(argv[i]);
@@ -281,12 +277,8 @@ extern "C" int _cdecl wmain(int argc, __in WCHAR **argv)
                     }
                     else if (!_stricmp(szOpt, "PDB"))
                     {
-#ifdef FEATURE_CORECLR
                       // 'PDB' option is ignored for ilasm on CoreCLR.
                       // https://github.com/dotnet/coreclr/issues/2982
-#else
-                      pAsm->m_fGeneratePDB = TRUE;
-#endif
                       bNoDebug = FALSE;
                     }
                     else if (!_stricmp(szOpt, "CLO"))
@@ -746,21 +738,8 @@ extern "C" int _cdecl wmain(int argc, __in WCHAR **argv)
                                     exitval = 1;
                                     pParser->msg("Failed to write output file, error code=0x%08X\n",hr);
                                 }
-#ifndef FEATURE_CORECLR
-                                else if (pAsm->m_pManifest->m_sStrongName.m_fFullSign)
-                                {
-                                    // Strong name sign the resultant assembly.
-                                    if(pAsm->m_fReportProgress) pParser->msg("Signing file with strong name\n");
-                                    if (FAILED(hr=pAsm->StrongNameSign()))
-                                    {
-                                        exitval = 1;
-                                        pParser->msg("Failed to strong name sign output file, error code=0x%08X\n",hr);
-                                    }
-                                }
-#endif
                                 if(bClock) cw.cEnd = GetTickCount();
 #define ENC_ENABLED
-#ifdef ENC_ENABLED
                                 if(exitval==0)
                                 {
                                     pAsm->m_fENCMode = TRUE;
@@ -857,7 +836,6 @@ extern "C" int _cdecl wmain(int argc, __in WCHAR **argv)
                                         }
                                     } // end for(iFile)
                                 } // end if(exitval==0)
-#endif
                             }
 
                         }
@@ -922,12 +900,6 @@ extern "C" int _cdecl wmain(int argc, __in WCHAR **argv)
 #pragma warning(pop)
 #endif
 
-#ifndef FEATURE_CORECLR
-HINSTANCE GetModuleInst()
-{
-    return (NULL);
-}
-#endif // !FEATURE_CORECLR
 
 #ifdef FEATURE_PAL
 int main(int argc, char* str[])
diff --git a/src/ilasm/method.cpp b/src/ilasm/method.cpp
index 18f6c47b00..8fc300c23a 100644
--- a/src/ilasm/method.cpp
+++ b/src/ilasm/method.cpp
@@ -93,16 +93,6 @@ void Method::OpenScope()
     {
         psc->dwStart = m_pAssembler->m_CurPC;
         psc->pSuperScope = m_pCurrScope;
-#if(0)
-        LinePC *pLPC = new LinePC;
-        if(pLPC)
-        {
-            pLPC->Line = m_pAssembler->m_ulCurLine;
-            pLPC->Column = m_pAssembler->m_ulCurColumn;
-            pLPC->PC = m_pAssembler->m_CurPC;
-            m_LinePCList.PUSH(pLPC);
-        }
-#endif
         m_pCurrScope->SubScope.PUSH(psc);
         m_pCurrScope = psc;
     }
@@ -116,16 +106,6 @@ void Method::CloseScope()
         if((pVD = m_Locals.PEEK(pAN->dwAttr))) pVD->bInScope = FALSE;
     }
     m_pCurrScope->dwEnd = m_pAssembler->m_CurPC;
-#if(0)
-    LinePC *pLPC = new LinePC;
-    if(pLPC)
-    {
-        pLPC->Line = m_pAssembler->m_ulCurLine;
-        pLPC->Column = m_pAssembler->m_ulCurColumn;
-        pLPC->PC = m_pAssembler->m_CurPC;
-        m_LinePCList.PUSH(pLPC);
-    }
-#endif
     m_pCurrScope = m_pCurrScope->pSuperScope;
 }
 
diff --git a/src/ilasm/writer.cpp b/src/ilasm/writer.cpp
index b5b87ce1ad..85f29af5e7 100644
--- a/src/ilasm/writer.cpp
+++ b/src/ilasm/writer.cpp
@@ -10,10 +10,6 @@
 #include "assembler.h"
 
 #include "ceefilegenwriter.h"
-#ifndef FEATURE_CORECLR
-#include "strongname.h"
-#include "LegacyActivationShim.h"
-#endif
 
 #ifndef _MSC_VER
 //cloned definition from ntimage.h that is removed for non MSVC builds
@@ -34,17 +30,8 @@ HRESULT Assembler::InitMetaData()
 
     if(bClock) bClock->cMDInitBegin = GetTickCount();
 
-#ifdef FEATURE_CORECLR
     hr = metaDataGetDispenser(CLSID_CorMetaDataDispenser,
         IID_IMetaDataDispenserEx, (void **)&m_pDisp);
-#else
-    hr = LegacyActivationShim::ClrCoCreateInstance(
-        CLSID_CorMetaDataDispenser, 
-        NULL, 
-        CLSCTX_INPROC_SERVER, 
-        IID_IMetaDataDispenserEx, 
-        (void **)&m_pDisp);
-#endif
     if (FAILED(hr))
         goto exit;
 
@@ -66,25 +53,6 @@ HRESULT Assembler::InitMetaData()
     if(FAILED(hr = m_pEmitter->QueryInterface(IID_IMetaDataImport2, (void**)&m_pImporter)))
         goto exit;
 
-#ifndef FEATURE_CORECLR
-    hr = CoCreateInstance(CLSID_CorSymWriter_SxS,
-                           NULL,
-                           CLSCTX_INPROC_SERVER,
-                           IID_ISymUnmanagedWriter,
-                           (void **)&m_pSymWriter);
-    if(SUCCEEDED(hr))
-    {
-        if(m_pSymWriter) m_pSymWriter->Initialize((IUnknown*)m_pEmitter,
-                                                  m_wzOutputFileName,
-                                                  NULL,
-                                                  TRUE);
-    }
-    else
-    {
-        fprintf(stderr, "Error: QueryInterface(IID_ISymUnmanagedWriter) returns %X\n",hr);
-        m_pSymWriter = NULL;
-    }
-#endif // !FEATURE_CORECLR
 
     //m_Parser = new AsmParse(m_pEmitter);
     m_fInitialisedMetaData = TRUE;
@@ -687,197 +655,6 @@ BYTE HexToByte (CHAR wc)
     return (BYTE) (wc - L'a' + 10);
 }
 
-#ifndef FEATURE_CORECLR
-bool GetBytesFromHex (LPCSTR szPublicKeyHexString, ULONG cchPublicKeyHexString, BYTE** buffer, ULONG *cbBufferSize)
-{
-    ULONG cchHex = cchPublicKeyHexString;
-    if (cchHex % 2 != 0)
-        return false;
-    *cbBufferSize = cchHex / 2;
-
-    *buffer = new BYTE[*cbBufferSize];
-    if (!*buffer)
-        return false;
-
-    for (ULONG i = 0; i < *cbBufferSize; i++)
-    {
-        BYTE msn = HexToByte(*szPublicKeyHexString);
-        BYTE lsn = HexToByte(*(szPublicKeyHexString + 1));
-        if (msn == 0xFF || lsn == 0xFF)
-        {
-            delete[] *buffer;
-            return false;
-        }
-
-        (*buffer)[i] = (BYTE) ( (msn << 4) | lsn );
-        szPublicKeyHexString += 2;
-    }
-
-    return true;
-}
-
-HRESULT Assembler::GetSignatureKey()
-{
-    HRESULT     hr = S_OK;
-    ULONG        cbSize = 0;
-    void *            pvData = NULL;
-    LPWSTR      pName = NULL;
-    
-    CustomDescrList* pCDList = &m_pManifest->m_pAssembly->m_CustomDescrList;
-    
-    for (ULONG i = 0;i < pCDList->COUNT(); i++)
-    {
-        CustomDescr* pCD = pCDList->PEEK(i);
-
-        if(pCD->pBlob)
-        {
-            pvData = (void *)(pCD->pBlob->ptr());
-            cbSize = pCD->pBlob->length();
-            pCD->tkOwner = m_pManifest->m_pAssembly->tkTok;
-            mdToken tkOwnerType, tkTypeType = TypeFromToken(pCD->tkType);
-            
-            if (GetCAName(pCD->tkType, &pName) != S_OK)
-                continue;
-
-            if (wcscmp(pName, L"System.Reflection.AssemblySignatureKeyAttribute") == 0)
-            {
-                    if (cbSize < sizeof(WORD) || GET_UNALIGNED_VAL16(pvData) != 1)
-                    {
-                        hr = E_FAIL;
-                        break;;
-                    }
-                    pvData = (unsigned char *)pvData  + sizeof(WORD);
-                    cbSize -= sizeof(WORD);
-                    
-                    // String is stored as compressed length, UTF8.
-                    if (*(const BYTE*)pvData != 0xFF)
-                    {
-                        PCCOR_SIGNATURE sig = (PCCOR_SIGNATURE)pvData;
-                        cbSize -= CorSigUncompressedDataSize(sig);
-                        DWORD len = CorSigUncompressData(sig);
-                        pvData = (void *)sig;
-                        if (cbSize < len)
-                        {
-                            hr = E_FAIL;
-                            break;
-                        }
-
-                        AsmManStrongName   *pSN = &m_pManifest->m_sStrongName;
-                        GetBytesFromHex((LPCSTR)pvData, len, &pSN->m_pbSignatureKey, &pSN->m_cbSignatureKey);
-                    }
-                    
-                    break;
-            }
-            
-            if (pName)
-            {
-                delete pName;
-                pName = NULL;
-            }
-        }
-    }
-
-    if (pName)
-        delete pName;
-    return hr;
-}
-
-HRESULT Assembler::AllocateStrongNameSignature()
-{
-    HRESULT             hr = S_OK;
-    HCEESECTION         hSection;
-    DWORD               dwDataLength;
-    DWORD               dwDataOffset;
-    DWORD               dwDataRVA;
-    VOID               *pvBuffer;
-    AsmManStrongName   *pSN = &m_pManifest->m_sStrongName;
-
-    // Pulls  the AssemblySignatureKey attribute from m_CustomDescrList
-    // If present, populate the pSN->m_pbSignatureKey from the AssemblySignatureKeyAttribute blob
-    if (FAILED(hr = GetSignatureKey()))
-    {
-        return hr;
-    }
-
-   // Determine size of signature blob.
-    if (pSN->m_pbSignatureKey != NULL)
-    {
-        // If m_pbSignatureKey present use it, else fall back to using identity key.
-        if (FAILED(hr = LegacyActivationShim::StrongNameSignatureSize_HRESULT(
-            pSN->m_pbSignatureKey, 
-            pSN->m_cbSignatureKey, 
-            &dwDataLength)))
-         {
-            return hr;
-        }
-    }
-    else if (FAILED(hr = LegacyActivationShim::StrongNameSignatureSize_HRESULT(
-            pSN->m_pbPublicKey, 
-            pSN->m_cbPublicKey, 
-            &dwDataLength)))
-    {
-        return hr;
-    }
-
-    // Grab memory in the section for our stuff.
-    if (FAILED(hr = m_pCeeFileGen->GetIlSection(m_pCeeFile,
-                                                &hSection)))
-        return hr;
-
-    if (FAILED(hr = m_pCeeFileGen->GetSectionBlock(hSection,
-                                                   dwDataLength,
-                                                   4,
-                                                   &pvBuffer)))
-        return hr;
-
-    // Where did we get that memory?
-    if (FAILED(hr = m_pCeeFileGen->GetSectionDataLen(hSection,
-                                                     &dwDataOffset)))
-        return hr;
-
-    dwDataOffset -= dwDataLength;
-
-    // Convert to an RVA.
-    if (FAILED(hr = m_pCeeFileGen->GetMethodRVA(m_pCeeFile,
-                                                dwDataOffset,
-                                                &dwDataRVA)))
-        return hr;
-
-    // Emit the directory entry.
-    if (FAILED(hr = m_pCeeFileGen->SetStrongNameEntry(m_pCeeFile,
-                                                      dwDataLength,
-                                                      dwDataRVA)))
-        return hr;
-
-    return S_OK;
-}
-
-HRESULT Assembler::StrongNameSign()
-{
-    LPWSTR              wszOutputFile;
-    HRESULT             hr = S_OK;
-    AsmManStrongName   *pSN = &m_pManifest->m_sStrongName;
-
-    // Determine what the ouput PE was called.
-    if (FAILED(hr = m_pCeeFileGen->GetOutputFileName(m_pCeeFile,
-                                                     &wszOutputFile)))
-        return hr;
-
-    // Update the output PE image with a strong name signature.
-    if (FAILED(hr = LegacyActivationShim::StrongNameSignatureGeneration_HRESULT(
-        wszOutputFile, 
-        pSN->m_wzKeyContainer, 
-        pSN->m_pbPrivateKey, 
-        pSN->m_cbPrivateKey, 
-        NULL, 
-        NULL)))
-    {
-        return hr;
-    }
-
-    return S_OK;
-}
-#endif // !FEATURE_CORECLR
 
 BOOL Assembler::EmitFieldsMethods(Class* pClass)
 {
@@ -1231,13 +1008,6 @@ HRESULT Assembler::CreatePEFile(__in __nullterminated WCHAR *pwzOutputFilename)
 
     if(bClock) bClock->cMDEmit1 = GetTickCount();
 
-#ifndef FEATURE_CORECLR
-    // Allocate space for a strong name signature if we're delay or full
-    // signing the assembly.
-    if (m_pManifest->m_sStrongName.m_pbPublicKey)
-        if (FAILED(hr = AllocateStrongNameSignature()))
-            goto exit;
-#endif
 
     if(bClock) bClock->cMDEmit2 = GetTickCount();
 
diff --git a/src/ilasm/writer_enc.cpp b/src/ilasm/writer_enc.cpp
index 055b2edca9..eee9c00a0a 100644
--- a/src/ilasm/writer_enc.cpp
+++ b/src/ilasm/writer_enc.cpp
@@ -70,28 +70,6 @@ HRESULT Assembler::InitMetaDataForENC(__in __nullterminated WCHAR* wzOrigFileNam
     if(!Init()) goto exit; // close and re-open CeeFileGen and CeeFile
     hr = S_OK;
 
-#ifndef FEATURE_CORECLR
-    hr = CoCreateInstance(CLSID_CorSymWriter_SxS,
-                           NULL,
-                           CLSCTX_INPROC_SERVER,
-                           IID_ISymUnmanagedWriter,
-                           (void **)&m_pSymWriter);
-    if(SUCCEEDED(hr))
-    {
-        WCHAR* pwc = &wzOrigFileName[wcslen(wzOrigFileName)];
-        wcscat_s(wzOrigFileName,MAX_SCOPE_LENGTH,W(".pdb"));
-        if(m_pSymWriter) m_pSymWriter->Initialize((IUnknown*)m_pEmitter,
-                                                  wzOrigFileName,
-                                                  NULL,
-                                                  TRUE);
-        *pwc = 0;
-    }
-    else 
-    {
-        fprintf(stderr, "Error: CoCreateInstance(IID_ISymUnmanagedWriter) returns %X\n",hr);
-        m_pSymWriter = NULL;
-    }
-#endif
 
 exit:
     return hr;
@@ -453,43 +431,6 @@ REPT_STEP
         pBaseMDEmit->Release();
     }
 
-#if(0)
-//===================================================================================
-    // release SymWriter interfaces
-    if (m_pSymWriter != NULL)
-    {
-        m_pSymWriter->Close();
-        m_pSymWriter->Release();
-        m_pSymWriter = NULL;
-    }
-
-    hr = CoCreateInstance(CLSID_CorSymWriter_SxS,
-                           NULL,
-                           CLSCTX_INPROC_SERVER,
-                           IID_ISymUnmanagedWriter,
-                           (void **)&m_pSymWriter);
-    if(SUCCEEDED(hr))
-    {
-        WCHAR* pwc = &pwzOutputFilename[wcslen(pwzOutputFilename)];
-        wcscat(pwzOutputFilename,L".pdb");
-        if(m_pSymWriter) m_pSymWriter->Initialize((IUnknown*)m_pEmitter,
-                                                  pwzOutputFilename,
-                                                  NULL,
-                                                  TRUE);
-        *pwc = 0;
-    }
-    else 
-    {
-        fprintf(stderr, "Error: CoCreateInstance(IID_ISymUnmanagedWriter) returns %X\n",hr);
-        m_pSymWriter = NULL;
-    }
-    
-    m_fENCMode = FALSE;
-    if(FAILED(hr=CreatePEFile(pwzOutputFilename))) 
-        report->msg("Could not create output file, error code=0x%08X\n",hr);
-    m_fENCMode = TRUE;
-//=====================================================================================    
-#endif
 
     // release all interfaces
     if (m_pSymWriter != NULL)
diff --git a/src/ildasm/dasm.cpp b/src/ildasm/dasm.cpp
index 7b6bca926e..0cb5cc8932 100644
--- a/src/ildasm/dasm.cpp
+++ b/src/ildasm/dasm.cpp
@@ -4576,36 +4576,6 @@ BOOL DumpClass(mdTypeDef cl, DWORD dwEntryPointToken, void* GUICookie, ULONG Wha
     pszClassName = (char*)(pc1 ? pc1 : "");
     pszNamespace = (char*)(pc2 ? pc2 : "");
 
-#if (0)
-
-    if((!IsTdNested(dwClassAttrs)))
-    {
-        // take care of namespace, if any
-        if(strcmp(pszNamespace,g_szNamespace))
-        {
-            if(strlen(g_szNamespace))
-            {
-                if(g_szAsmCodeIndent[0]) g_szAsmCodeIndent[strlen(g_szAsmCodeIndent)-2] = 0;
-                szptr = &szString[0];
-                szptr+=sprintf_s(szptr,SZSTRING_SIZE,"%s%s ",g_szAsmCodeIndent,UNSCOPE());
-                sprintf_s(szptr,SZSTRING_REMAINING_SIZE(szptr),COMMENT("// end of namespace %s"),ProperName(g_szNamespace));
-                printLine(GUICookie,szString);
-                printLine(GUICookie,"");
-            }
-            strcpy_s(g_szNamespace,MAX_MEMBER_LENGTH,pszNamespace);
-            if(strlen(g_szNamespace))
-            {
-                sprintf_s(szString,SZSTRING_SIZE,"%s%s %s",
-                    g_szAsmCodeIndent,KEYWORD(".namespace"), ProperName(g_szNamespace));
-                printLine(GUICookie,szString);
-                sprintf_s(szString,SZSTRING_SIZE,"%s%s",g_szAsmCodeIndent,SCOPE());
-                printLine(GUICookie,szString);
-                strcat_s(g_szAsmCodeIndent,MAX_MEMBER_LENGTH,"  ");
-            }
-        }
-    }
-
-#endif
 
     szptr = &szString[0];
     szptr+=sprintf_s(szptr,SZSTRING_SIZE,"%s%s ",g_szAsmCodeIndent,KEYWORD(".class"));
@@ -7571,24 +7541,6 @@ DoneInitialization:
                 }
             }
 
-#if (0)
-            /* Third, dump GC/EH info about the native methods, using the IPMap */
-            IMAGE_DATA_DIRECTORY *pIPMap;
-            if (g_pPELoader->IsPE32())
-            {
-                pIPMap = &g_pPELoader->ntHeaders32()->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION];
-            }
-            else
-            {
-                pIPMap = &g_pPELoader->ntHeaders64()->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION];
-            }
-            DWORD        IPMapSize;
-            const BYTE * ipmap;
-            IPMapSize  = VAL32(pIPMap->Size);
-            g_pPELoader->getVAforRVA(VAL32(pIPMap->VirtualAddress), (void **) &ipmap);
-
-            DumpNativeInfo(ipmap, IPMapSize);
-#endif
 
             // If there were "ldptr", dump the .rdata section with labels
             if(g_iPtrCount)
diff --git a/src/ildasm/dis.h b/src/ildasm/dis.h
index 595e097ae6..9a1af93943 100644
--- a/src/ildasm/dis.h
+++ b/src/ildasm/dis.h
@@ -152,24 +152,24 @@ char *DumpGenericPars(__inout_ecount(SZSTRING_SIZE) char* szString,
 #define CHECK_REMAINING_SIZE if(ovadd_le((size_t)szString, SZSTRING_SIZE_M4, (size_t)szptr)) break;
 #define SZSTRING_REMAINING_SIZE(x) (ovadd_le((size_t)szString,SZSTRING_SIZE,(size_t)(x))?0:(SZSTRING_SIZE-((size_t)(x)-(size_t)szString)))
 
-typedef int (*MetaDataGetDispenserFunc) (
+typedef int (STDAPICALLTYPE *MetaDataGetDispenserFunc) (
     REFCLSID    rclsid,                 // The class to desired.
     REFIID      riid,                   // Interface wanted on class factory.
     LPVOID FAR  *ppv);                  // Return interface pointer here.
 
-typedef int (*GetMetaDataInternalInterfaceFunc) (
+typedef int (STDAPICALLTYPE *GetMetaDataInternalInterfaceFunc) (
     LPVOID      pData,                  // [IN] in memory metadata section
     ULONG       cbData,                 // [IN] size of the metadata section
     DWORD       flags,                  // [IN] CorOpenFlags
     REFIID      riid,                   // [IN] desired interface
     void        **ppv);                 // [OUT] returned interface
 
-typedef int (*GetMetaDataInternalInterfaceFromPublicFunc) (
+typedef int (STDAPICALLTYPE *GetMetaDataInternalInterfaceFromPublicFunc) (
     IUnknown    *pv,                    // [IN] Given interface
     REFIID      riid,                   // [IN] desired interface
     void        **ppv);                 // [OUT] returned interface
 
-typedef int (*GetMetaDataPublicInterfaceFromInternalFunc) (
+typedef int (STDAPICALLTYPE *GetMetaDataPublicInterfaceFromInternalFunc) (
     void        *pv,                    // [IN] Given interface
     REFIID      riid,                   // [IN] desired interface
     void        **ppv);                 // [OUT] returned interface
diff --git a/src/inc/CMakeLists.txt b/src/inc/CMakeLists.txt
index d38fa40773..40499b44ea 100644
--- a/src/inc/CMakeLists.txt
+++ b/src/inc/CMakeLists.txt
@@ -9,7 +9,6 @@ set( CORGUIDS_IDL_SOURCES
   ivalidator.idl
   ivehandler.idl
   gchost.idl
-  fusionpriv.idl
   mscorsvc.idl
   tlbimpexp.idl
   clrprivappxhosting.idl
diff --git a/src/inc/MSCOREE.IDL b/src/inc/MSCOREE.IDL
index 67605e23d4..e543124304 100644
--- a/src/inc/MSCOREE.IDL
+++ b/src/inc/MSCOREE.IDL
@@ -10,21 +10,9 @@
  **                                                                                  **
  **************************************************************************************/
 
-#ifdef FEATURE_CORECLR
-// API deprecation does not apply to CoreCLR
 cpp_quote("#define DECLARE_DEPRECATED ")
 cpp_quote("#define DEPRECATED_CLR_STDAPI STDAPI")
-#else // !FEATURE_CORECLR
-// API deprecation is only applicable to Desktop runtime.
-cpp_quote("#ifndef USE_DEPRECATED_CLR_API_WITHOUT_WARNING")
-cpp_quote("#define DEPRECATED_CLR_API_MESG \"This API has been deprecated. Refer to http://go.microsoft.com/fwlink/?LinkId=143720 for more details.\"")
-cpp_quote("#define DECLARE_DEPRECATED __declspec(deprecated(DEPRECATED_CLR_API_MESG))")
-cpp_quote("#define DEPRECATED_CLR_STDAPI EXTERN_C DECLARE_DEPRECATED HRESULT STDAPICALLTYPE")
-cpp_quote("#else // USE_DEPRECATED_CLR_API_WITHOUT_WARNING")
-cpp_quote("#define DECLARE_DEPRECATED ")
-cpp_quote("#define DEPRECATED_CLR_STDAPI STDAPI")
-cpp_quote("#endif // !USE_DEPRECATED_CLR_API_WITHOUT_WARNING")
-#endif // FEATURE_CORECLR
+
 cpp_quote("")
 
 //
@@ -38,10 +26,8 @@ import "ivalidator.idl";
 
 #include "product_version.h"
 
-#ifdef FEATURE_CORECLR
 cpp_quote("struct IActivationFactory;")
 interface IActivationFactory;
-#endif
 
 const char* CLR_MAJOR_VERSION = VER_MAJORVERSION;
 const char* CLR_MINOR_VERSION = VER_MINORVERSION;
@@ -192,15 +178,12 @@ cpp_quote("EXTERN_GUID(IID_ICLROnEventManager, 0x1D0E0132, 0xE64F, 0x493D, 0x92,
 // IID ICLRRuntimeHost: uuid(90F1A06C-7712-4762-86B5-7A5EBA6BDB02)
 cpp_quote("EXTERN_GUID(IID_ICLRRuntimeHost, 0x90F1A06C, 0x7712, 0x4762, 0x86, 0xB5, 0x7A, 0x5E, 0xBA, 0x6B, 0xDB, 0x02);")
 
-#ifdef FEATURE_CORECLR
 // IID ICLRRuntimeHost2: uuid(712AB73F-2C22-4807-AD7E-F501D7B72C2D)
 cpp_quote("EXTERN_GUID(IID_ICLRRuntimeHost2, 0x712AB73F, 0x2C22, 0x4807, 0xAD, 0x7E, 0xF5, 0x01, 0xD7, 0xb7, 0x2C, 0x2D);")
 
 // IID IID_ICLRExecutionManager: uuid(1000A3E7-B420-4620-AE30-FB19B587AD1D)
 cpp_quote("EXTERN_GUID(IID_ICLRExecutionManager, 0x1000A3E7, 0xB420, 0x4620, 0xAE, 0x30, 0xFB, 0x19, 0xB5, 0x87, 0xAD, 0x1D);")
 
-#endif // FEATURE_CORECLR
-
 #ifdef FEATURE_INCLUDE_ALL_INTERFACES
 // IID ICLRHostProtectionManager :     uuid{89F25F5C-CEEF-43e1-9CFA-A68CE863AAAC}
 cpp_quote("EXTERN_GUID(IID_ICLRHostProtectionManager, 0x89f25f5c, 0xceef, 0x43e1, 0x9c, 0xfa, 0xa6, 0x8c, 0xe8, 0x63, 0xaa, 0xac);")
@@ -271,24 +254,7 @@ cpp_quote("EXTERN_GUID(IID_ITypeNameFactory, 0xB81FF171, 0x20F3, 0x11d2, 0x8d, 0
 #pragma midl_echo("DEPRECATED_CLR_STDAPI LoadStringRCEx(LCID lcid, UINT iResouceID, _Out_writes_z_(iMax) LPWSTR szBuffer, int iMax, int bQuiet, int *pcwchUsed);")
 #endif
 
-#ifndef FEATURE_CORECLR
-// Ideally we would like to make the function pointer definition below as DEPRECATED_CLR_STDAPI. However,
-// since it is referenced in the following definition of LockClrVersion, it will result in a build failure
-// in our own build (since we treat warnings as errors).
-//
-// However, there is no other usage of this pointer outside LockClrVersion. Thus, we will not mark
-// the pointer as legacy API. This will ensure we can build the runtime and if someone tries to use
-// it via LockClrVersion, they will have build warning since LockClrVersion is marked as legacy API.
-#pragma midl_echo("typedef HRESULT (__stdcall *FLockClrVersionCallback) ();")
-#pragma midl_echo("DEPRECATED_CLR_STDAPI LockClrVersion(FLockClrVersionCallback hostCallback,FLockClrVersionCallback *pBeginHostSetup,FLockClrVersionCallback *pEndHostSetup);")
-#pragma midl_echo("DEPRECATED_CLR_STDAPI CreateDebuggingInterfaceFromVersion(int iDebuggerVersion, LPCWSTR szDebuggeeVersion, IUnknown ** ppCordb);")
-#pragma midl_echo("DEPRECATED_CLR_STDAPI GetVersionFromProcess(HANDLE hProcess, _Out_writes_to_(cchBuffer, *dwLength) LPWSTR pVersion, DWORD cchBuffer, _Out_ DWORD* dwLength);")
-#endif
-
-
-#ifdef FEATURE_CORECLR
 #pragma midl_echo("typedef HRESULT  (STDAPICALLTYPE *FnGetCLRRuntimeHost)(REFIID riid, IUnknown **pUnk);")
-#endif
 
 typedef enum {
     HOST_TYPE_DEFAULT     = 0x0,
@@ -324,11 +290,9 @@ typedef enum {
   STARTUP_TRIM_GC_COMMIT        = 0x80000,                      // GC uses less committed space when system memory low
   STARTUP_ETW                   = 0x100000,
   STARTUP_ARM                   = 0x400000,                     // Enable the ARM feature.
-#ifdef FEATURE_CORECLR
   STARTUP_SINGLE_APPDOMAIN      = 0x800000,                      // application runs in default domain, no more domains are created 
   STARTUP_APPX_APP_MODEL        = 0x1000000,                     // jupiter app
   STARTUP_DISABLE_RANDOMIZED_STRING_HASHING     = 0x2000000      // Disable the randomized string hashing
-#endif
 } STARTUP_FLAGS;
 
 typedef enum {
@@ -356,11 +320,8 @@ typedef enum
     APPDOMAIN_SECURITY_DEFAULT =0x0, 
     APPDOMAIN_SECURITY_SANDBOXED = 0x1,       // appdomain is sandboxed
     APPDOMAIN_SECURITY_FORBID_CROSSAD_REVERSE_PINVOKE = 0x2,         // no cross ad reverse pinvokes
-#ifdef FEATURE_CORECLR
     APPDOMAIN_IGNORE_UNHANDLED_EXCEPTIONS = 0x4, //
-#endif //FEATURE_CORECLR
     APPDOMAIN_FORCE_TRIVIAL_WAIT_OPERATIONS = 0x08, // do not pump messages during wait operations, do not call sync context
-#ifdef FEATURE_CORECLR
     // When passed by the host, this flag will allow any assembly to perform PInvoke or COMInterop operations.
     // Otherwise, by default, only platform assemblies can perform those operations.
     APPDOMAIN_ENABLE_PINVOKE_AND_CLASSIC_COMINTEROP = 0x10, 
@@ -369,7 +330,6 @@ typedef enum
     APPDOMAIN_ENABLE_ASSEMBLY_LOADFILE = 0x80,
 
     APPDOMAIN_DISABLE_TRANSPARENCY_ENFORCEMENT = 0x100,
-#endif //FEATURE_CORECLR  
 } APPDOMAIN_SECURITY_FLAGS;
 
 #pragma midl_echo("STDAPI GetRequestedRuntimeVersionForCLSID(REFCLSID rclsid, _Out_writes_opt_(cchBuffer) LPWSTR pVersion, DWORD cchBuffer, _Out_opt_ DWORD* dwLength, CLSID_RESOLUTION_FLAGS dwResolutionFlags);")
@@ -1980,8 +1940,6 @@ interface ICLRRuntimeHost : IUnknown
                                       [out] DWORD  *pReturnValue);
 };
 
-#ifdef FEATURE_CORECLR
-
 // Keys for ICLRRuntmeHost2::Authenticate. No longer required.
 cpp_quote("#define CORECLR_HOST_AUTHENTICATION_KEY 0x1C6CA6F94025800LL")
 cpp_quote("#define CORECLR_HOST_AUTHENTICATION_KEY_NONGEN 0x1C6CA6F94025801LL")
@@ -2054,8 +2012,6 @@ interface ICLRExecutionManager : IUnknown
     HRESULT Resume([in] DWORD dwAppDomainId);
 }
 
-#endif // FEATURE_CORECLR
-
 //*****************************************************************************
 // Interface to utilize HostProtection
 //*****************************************************************************
diff --git a/src/inc/appxutil.h b/src/inc/appxutil.h
index 2892ab7dd8..893c429c95 100644
--- a/src/inc/appxutil.h
+++ b/src/inc/appxutil.h
@@ -24,7 +24,6 @@ template <typename T>
 class NewArrayHolder;
 BOOL WinRTSupported();
 
-#ifdef FEATURE_CORECLR
 
 namespace AppX
 {
@@ -45,92 +44,6 @@ namespace AppX
 #endif // DACCESS_COMPILE
 };
 
-#else // FEATURE_CORECLR
-
-struct AppXRTInfo;
-typedef DPTR(AppXRTInfo) PTR_AppXRTInfo;
-
-//---------------------------------------------------------------------------------------------
-namespace AppX
-{
-    // cleans up resources allocated in InitAppXRT()
-    void ShutDown();
-
-    // Returns true if process is immersive (or if running in mockup environment).
-    // NOTE: a return value of true doesn't necessarily indicate that the process is a
-    //       real Metro app, e.g. it could be an ngen process compiling an AppX assembly.
-    bool IsAppXProcess();
-
-#ifdef DACCESS_COMPILE
-    bool DacIsAppXProcess();
-#endif // DACCESS_COMPILE
-
-    // Returns true if process is immersive (or if running in mockup environment).
-    // Use only in NOFAULT regions when you are 100% sure that code:IsAppXProcess has been already called.
-    // This function does not initialize (no faults).
-    bool IsAppXProcess_Initialized_NoFault();
-
-    // Returns true if process is NGen worker compiling an AppX assembly.
-    bool IsAppXNGen();
-
-    // Returns true if the host OS supports immersive apps.
-    inline bool IsAppXSupported()
-    { return WinRTSupported() != FALSE; }
-
-    LPCWSTR GetHeadPackageMoniker();
-
-    HRESULT GetCurrentPackageId(
-        __inout PUINT32 pBufferLength,
-        __out PBYTE pBuffer);
-
-    HRESULT GetCurrentPackageInfo(
-        __in UINT32 dwFlags,
-        __inout PUINT32 pcbBuffer,
-        __out PBYTE pbBuffer,
-        __out PUINT32 nCount);
-
-    bool IsAdaptiveApp();
-    HRESULT GetCurrentPackageRoot(_Inout_ UINT32* length, _Out_opt_ PWSTR packageRoot);
-    HRESULT GetWinMetadataDirForAdaptiveApps(_Out_ LPWSTR* winMetadDataDir);
-#ifdef FEATURE_APPX_BINDER
-    enum FindFindInPackageFlags
-    {
-        FindFindInPackageFlags_None = 0,
-        FindFindInPackageFlags_AllowLongFormatPath = 1,
-        FindFindInPackageFlags_SkipCurrentPackageGraph = 2, // Only search in alt path
-    };
-
-    // If the function succeeds, pcchPathName is set to the length of the string that is copied to the buffer,
-    // in characters, including the terminating null character, and the function returns S_OK. If the buffer
-    // is too small, pcchPathName is set to the length of the buffer required (in characters),
-    // including the terminating null character, and the function returns ERROR_INSUFFICIENT_BUFFER.
-    HRESULT FindFileInCurrentPackage(
-        __in PCWSTR pszFileName,
-        __inout PUINT32 pcchPathName,
-        __out PWSTR pszPathName,
-        __in UINT32 uiFlags = PACKAGE_FILTER_CLR_DEFAULT,
-        __in PCWSTR *rgwzAltPaths = NULL,
-        __in UINT32 cAltPaths = 0,
-        FindFindInPackageFlags findInCurrentPackageFlags = FindFindInPackageFlags_None);
-#endif // FEATURE_APPX_BINDER
-
-    // Attempts to retrieve the AppContainer SID for the specified process.
-    // For non-AppContainer processes the function will return S_FALSE and pAppContainerTokenInfo will be NULL.
-    // For AppContainer processes the function will return S_OK and pAppContainerTokenInfo will contain data.
-    // Note that there might be legitimate cases where this function fails (caller doesn't have permissions to
-    // OpenProcess() for example) so any callers must account for such failures.
-    // Use of NewArrayHolder permits method to reuse info for current process (dwPid == self) or to allocate
-    // memory (dwPid != self). Cast the result to PTOKEN_APPCONTAINER_INFORMATION;
-    HRESULT GetAppContainerTokenInfoForProcess(
-        DWORD dwPid,
-        NewArrayHolder<BYTE>& pbAppContainerTokenInfo, // Cast to PTOKEN_APPCONTAINER_INFORMATION on return.
-        DWORD* pcbAppContainerTokenInfo = nullptr);
-
-    // Called during NGen to pretend that we are in a certain package.
-    HRESULT SetCurrentPackageForNGen(__in PCWSTR pszPackageFullName);
-}
-
-#endif // FEATURE_CORECLR
 
 #else // FEATURE_APPX
 
diff --git a/src/inc/binderngen.idl b/src/inc/binderngen.idl
index d20cf93701..f3d41cd6a6 100644
--- a/src/inc/binderngen.idl
+++ b/src/inc/binderngen.idl
@@ -36,7 +36,6 @@ cpp_quote("#endif")
 
 // interface IAssemblyName defined in fusion.idl
 // interface IAssemblyEnum defined in fusion.idl
-// interface IFusionBindLog defined in fusionpriv.idl
 // interface ICorSvcLogger defined in mscorsvc.idl
 
 interface IAssemblyLocation;
diff --git a/src/inc/clrconfigvalues.h b/src/inc/clrconfigvalues.h
index cf71e46bbf..6a30af16db 100644
--- a/src/inc/clrconfigvalues.h
+++ b/src/inc/clrconfigvalues.h
@@ -123,13 +123,9 @@ CONFIG_DWORD_INFO(INTERNAL_AppDomainNoUnload, W("AppDomainNoUnload"), 0, "Not us
 RETAIL_CONFIG_STRING_INFO_EX(INTERNAL_TargetFrameworkMoniker, W("TargetFrameworkMoniker"), "Allows the test team to specify what TargetFrameworkMoniker to use.", CLRConfig::IgnoreHKLM | CLRConfig::IgnoreHKCU | CLRConfig::IgnoreConfigFiles | CLRConfig::IgnoreWindowsQuirkDB)
 RETAIL_CONFIG_STRING_INFO_EX(INTERNAL_AppContextSwitchOverrides, W("AppContextSwitchOverrides"), "Allows default switch values defined in AppContext to be overwritten by values in the Config", CLRConfig::IgnoreEnv | CLRConfig::IgnoreHKLM | CLRConfig::IgnoreHKCU | CLRConfig::IgnoreWindowsQuirkDB | CLRConfig::ConfigFile_ApplicationFirst)
 
-#ifdef FEATURE_CORECLR
 // For the proposal and discussion on why finalizers are not run on shutdown by default anymore in CoreCLR, see the API review:
 // https://github.com/dotnet/corefx/issues/5205
 #define DEFAULT_FinalizeOnShutdown (0)
-#else
-#define DEFAULT_FinalizeOnShutdown (1)
-#endif
 RETAIL_CONFIG_DWORD_INFO(EXTERNAL_FinalizeOnShutdown, W("FinalizeOnShutdown"), DEFAULT_FinalizeOnShutdown, "When enabled, on shutdown, blocks all user threads and calls finalizers for all finalizable objects, including live objects")
 
 //
@@ -312,9 +308,7 @@ RETAIL_CONFIG_DWORD_INFO(UNSUPPORTED_gcConcurrent, W("gcConcurrent"), (DWORD)-1,
 #ifdef FEATURE_CONSERVATIVE_GC
 RETAIL_CONFIG_DWORD_INFO(UNSUPPORTED_gcConservative, W("gcConservative"), 0, "Enables/Disables conservative GC")
 #endif
-#ifdef FEATURE_CORECLR
 RETAIL_CONFIG_DWORD_INFO(UNSUPPORTED_gcServer, W("gcServer"), 0, "Enables server GC")
-#endif
 CONFIG_STRING_INFO(INTERNAL_GcCoverage, W("GcCoverage"), "specify a method or regular expression of method names to run with GCStress")
 CONFIG_STRING_INFO(INTERNAL_SkipGCCoverage, W("SkipGcCoverage"), "specify a list of assembly names to skip with GC Coverage")
 RETAIL_CONFIG_DWORD_INFO_DIRECT_ACCESS(UNSUPPORTED_gcForceCompact, W("gcForceCompact"), "When set to true, always do compacting GC")
@@ -386,7 +380,7 @@ CONFIG_STRING_INFO_EX(INTERNAL_JitDebugBreak, W("JitDebugBreak"), "", CLRConfig:
 CONFIG_DWORD_INFO_DIRECT_ACCESS(INTERNAL_JitDebuggable, W("JitDebuggable"), "")
 CONFIG_DWORD_INFO_EX(INTERNAL_JitDefaultFill, W("JitDefaultFill"), 0xDD, "In debug builds, initialize the memory allocated by the nra with this byte.", CLRConfig::REGUTIL_default)
 CONFIG_DWORD_INFO_EX(INTERNAL_JitDirectAlloc, W("JitDirectAlloc"), 0, "", CLRConfig::REGUTIL_default)
-#if (!defined(DEBUG) && !defined(_DEBUG)) || (defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR))
+#if !defined(DEBUG) && !defined(_DEBUG)
 #define INTERNAL_JitEnableNoWayAssert_Default 0
 #else
 #define INTERNAL_JitEnableNoWayAssert_Default 1
@@ -477,7 +471,7 @@ RETAIL_CONFIG_DWORD_INFO(EXTERNAL_UseLegacyJit, W("useLegacyJit"), 0, "Set to 1
 RETAIL_CONFIG_STRING_INFO_EX(EXTERNAL_DisableNativeImageLoadList, W("DisableNativeImageLoadList"), "Refuse to load native images corresponding to one of the assemblies on this semicolon-delimited list of assembly names.", CLRConfig::REGUTIL_default)
 #endif
 
-#if defined(FEATURE_CORECLR) && defined(_TARGET_X86_)
+#if defined(_TARGET_X86_)
 RETAIL_CONFIG_DWORD_INFO(EXTERNAL_UseWindowsX86CoreLegacyJit, W("UseWindowsX86CoreLegacyJit"), 0, "Set to 1 to do all JITing with compatjit.dll. Only applicable to Windows x86 .NET Core.")
 #endif
 
@@ -562,13 +556,13 @@ CONFIG_DWORD_INFO_EX(INTERNAL_JitLoopHoistStats, W("JitLoopHoistStats"), 0, "Dis
 CONFIG_DWORD_INFO_EX(INTERNAL_JitDebugLogLoopCloning, W("JitDebugLogLoopCloning"), 0, "In debug builds log places where loop cloning optimizations are performed on the fast path.", CLRConfig::REGUTIL_default);
 CONFIG_DWORD_INFO_EX(INTERNAL_JitVNMapSelLimit, W("JitVNMapSelLimit"), 0, "If non-zero, assert if # of VNF_MapSelect applications considered reaches this", CLRConfig::REGUTIL_default)
 RETAIL_CONFIG_DWORD_INFO(INTERNAL_JitVNMapSelBudget, W("JitVNMapSelBudget"), 100, "Max # of MapSelect's considered for a particular top-level invocation.")
-#if defined(_TARGET_AMD64_)
+#if defined(_TARGET_AMD64_) || defined(_TARGET_X86_)
 #define EXTERNAL_FeatureSIMD_Default 1
 #define EXTERNAL_JitEnableAVX_Default 1
-#else // !defined(_TARGET_AMD64_)
+#else // !defined(_TARGET_AMD64_) && !defined(_TARGET_X86_)
 #define EXTERNAL_FeatureSIMD_Default 0
 #define EXTERNAL_JitEnableAVX_Default 0
-#endif // !defined(_TARGET_AMD64_)
+#endif // !defined(_TARGET_AMD64_) && !defined(_TARGET_X86_)
 RETAIL_CONFIG_DWORD_INFO_EX(EXTERNAL_FeatureSIMD, W("FeatureSIMD"), EXTERNAL_FeatureSIMD_Default, "Enable SIMD support with companion SIMDVector.dll", CLRConfig::REGUTIL_default)
 RETAIL_CONFIG_DWORD_INFO_EX(EXTERNAL_EnableAVX, W("EnableAVX"), EXTERNAL_JitEnableAVX_Default, "Enable AVX instruction set for wide operations as default", CLRConfig::REGUTIL_default)
 
@@ -670,9 +664,6 @@ CONFIG_DWORD_INFO_EX(INTERNAL_MD_RegMetaDump, W("MD_RegMetaDump"), 0, "? Dump MD
 CONFIG_DWORD_INFO_EX(INTERNAL_MD_TlbImp_BreakOnErr, W("MD_TlbImp_BreakOnErr"), 0, "ASSERT when importing TLB into MD", CLRConfig::REGUTIL_default)
 CONFIG_STRING_INFO_EX(INTERNAL_MD_TlbImp_BreakOnTypeImport, W("MD_TlbImp_BreakOnTypeImport"), "ASSERT when importing a type from TLB", (CLRConfig::LookupOptions) (CLRConfig::REGUTIL_default | CLRConfig::DontPrependCOMPlus_))
 // MetaData - Desktop-only
-#ifndef FEATURE_CORECLR
-RETAIL_CONFIG_DWORD_INFO_EX(INTERNAL_MD_UseMinimalDeltas, W("MD_UseMinimalDeltas"), 1, "? Some MD modifications when applying EnC?", CLRConfig::REGUTIL_default)
-#endif //!FEATURE_CORECLR
 CONFIG_DWORD_INFO_EX(INTERNAL_MD_WinMD_Disable, W("MD_WinMD_Disable"), 0, "Never activate the WinMD import adapter", CLRConfig::REGUTIL_default)
 CONFIG_DWORD_INFO_EX(INTERNAL_MD_WinMD_AssertOnIllegalUsage, W("MD_WinMD_AssertOnIllegalUsage"), 0, "ASSERT if a WinMD import adapter detects a tool incompatibility", CLRConfig::REGUTIL_default)
 
@@ -777,12 +768,7 @@ RETAIL_CONFIG_STRING_INFO_EX(UNSUPPORTED_NicPath, W("NicPath"), "Redirects NIC a
 RETAIL_CONFIG_DWORD_INFO(INTERNAL_NGenTaskDelayStart, W("NGenTaskDelayStart"), 0, "Use NGen Task delay start trigger, instead of critical idle task")
 
 // Flag for cross-platform ngen: Removes all execution of managed or third-party code in the ngen compilation process.
-#ifdef FEATURE_CORECLR
 RETAIL_CONFIG_DWORD_INFO(INTERNAL_Ningen, W("Ningen"), 1, "Enable no-impact ngen")
-#else
-// Ningen is off by default for desktop to reduce compat risk
-RETAIL_CONFIG_DWORD_INFO(INTERNAL_Ningen, W("Ningen"), 0, "Enable no-impact ngen")
-#endif
 
 CONFIG_DWORD_INFO(INTERNAL_NoASLRForNgen, W("NoASLRForNgen"), 0, "Turn off IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE bit in generated ngen images. Makes nidump output repeatable from run to run.")
 RETAIL_CONFIG_DWORD_INFO_EX(EXTERNAL_NgenAllowOutput, W("NgenAllowOutput"), 0, "If set to 1, the NGEN worker will bind to the parent console, thus allowing stdout output to work", CLRConfig::REGUTIL_default)
@@ -1027,11 +1013,7 @@ CONFIG_DWORD_INFO(INTERNAL_DebugAssertOnMissedCOWPage, W("DebugAssertOnMissedCOW
 
 #endif //FEATURE_LAZY_COW_PAGES
 
-#ifdef FEATURE_CORECLR
 RETAIL_CONFIG_DWORD_INFO(EXTERNAL_ReadyToRun, W("ReadyToRun"), 1, "Enable/disable use of ReadyToRun native code") // On by default for CoreCLR
-#else
-RETAIL_CONFIG_DWORD_INFO(EXTERNAL_ReadyToRun, W("ReadyToRun"), 0, "Enable/disable use of ReadyToRun native code") // Off by default for desktop
-#endif
 RETAIL_CONFIG_STRING_INFO(EXTERNAL_ReadyToRunExcludeList, W("ReadyToRunExcludeList"), "List of assemblies that cannot use Ready to Run images")
 RETAIL_CONFIG_STRING_INFO(EXTERNAL_ReadyToRunLogFile, W("ReadyToRunLogFile"), "Name of file to log success/failure of using Ready to Run images")
 
@@ -1076,7 +1058,6 @@ CONFIG_DWORD_INFO_DIRECT_ACCESS(INTERNAL_AlwaysUseMetadataInterfaceMapLayout, W(
 CONFIG_DWORD_INFO(INTERNAL_AssertOnUnneededThis, W("AssertOnUnneededThis"), 0, "While the ConfigDWORD is unnecessary, the contained ASSERT should be kept. This may result in some work tracking down violating MethodDescCallSites.")
 CONFIG_DWORD_INFO_EX(INTERNAL_AssertStacktrace, W("AssertStacktrace"), 1, "", CLRConfig::REGUTIL_default)
 RETAIL_CONFIG_STRING_INFO_DIRECT_ACCESS(UNSUPPORTED_BuildFlavor, W("BuildFlavor"), "Choice of build flavor (wks or svr) of CLR")
-CONFIG_DWORD_INFO(INTERNAL_CerLogging, W("CerLogging"), 0, "In vm\\ConstrainedExecutionRegion.cpp.  Debug-only logging when we prepare methods, find reliability contract problems, restore stuff from ngen images, etc.")
 CONFIG_DWORD_INFO_EX(INTERNAL_clearNativeImageStress, W("clearNativeImageStress"), 0, "", CLRConfig::REGUTIL_default)
 RETAIL_CONFIG_STRING_INFO_DIRECT_ACCESS(INTERNAL_CLRLoadLogDir, W("CLRLoadLogDir"), "Enable logging of CLR selection")
 RETAIL_CONFIG_STRING_INFO_EX(EXTERNAL_CONFIG, W("CONFIG"), "Used to specify an XML config file for EEConfig", CLRConfig::REGUTIL_default)
@@ -1128,11 +1109,7 @@ CONFIG_DWORD_INFO_EX(INTERNAL_MscorsnLogging, W("MscorsnLogging"), 0, "Enables s
 RETAIL_CONFIG_DWORD_INFO_EX(EXTERNAL_NativeImageRequire, W("NativeImageRequire"), 0, "", CLRConfig::REGUTIL_default)
 CONFIG_DWORD_INFO_EX(INTERNAL_NestedEhOom, W("NestedEhOom"), 0, "", CLRConfig::REGUTIL_default)
 RETAIL_CONFIG_DWORD_INFO_EX(EXTERNAL_NO_SO_NOT_MAINLINE, W("NO_SO_NOT_MAINLINE"), 0, "", CLRConfig::REGUTIL_default)
-#if defined(CROSSGEN_COMPILE) || defined(FEATURE_CORECLR)
 #define INTERNAL_NoGuiOnAssert_Default 1
-#else
-#define INTERNAL_NoGuiOnAssert_Default 0
-#endif
 RETAIL_CONFIG_DWORD_INFO_EX(INTERNAL_NoGuiOnAssert, W("NoGuiOnAssert"), INTERNAL_NoGuiOnAssert_Default, "", CLRConfig::REGUTIL_default)
 RETAIL_CONFIG_DWORD_INFO_EX(EXTERNAL_NoProcedureSplitting, W("NoProcedureSplitting"), 0, "", CLRConfig::REGUTIL_default)
 CONFIG_DWORD_INFO_EX(INTERNAL_NoStringInterning, W("NoStringInterning"), 1, "Disallows string interning. I see no value in it anymore.", CLRConfig::REGUTIL_default)
diff --git a/src/inc/clrhost.h b/src/inc/clrhost.h
index 8cd9e3e9c2..9fe978f95a 100644
--- a/src/inc/clrhost.h
+++ b/src/inc/clrhost.h
@@ -364,9 +364,7 @@ private:
     SEMAPHORE_COOKIE m_semaphore;
 };
 
-#if defined(FEATURE_CORECLR) || !defined(SELF_NO_HOST) || defined(DACCESS_COMPILE)
 HMODULE GetCLRModule ();
-#endif // defined(FEATURE_CORECLR) || !defined(SELF_NO_HOST) || defined(DACCESS_COMPILE)
 
 #ifndef FEATURE_NO_HOST
 /*
diff --git a/src/inc/clrinternal.idl b/src/inc/clrinternal.idl
index 4193d1bfe8..0c93f4ae6d 100644
--- a/src/inc/clrinternal.idl
+++ b/src/inc/clrinternal.idl
@@ -16,17 +16,7 @@ import "unknwn.idl";
 // import mscoree.idl for BucketParameters definition
 import "mscoree.idl";
 
-#ifndef FEATURE_CORECLR
-import "hstring.idl";
-#endif //!FEATURE_CORECLR
 
-#ifndef FEATURE_CORECLR
-interface IActivationFactory;
-cpp_quote("interface IActivationFactory;")
-
-interface IWinRTClassActivator;
-cpp_quote("interface IWinRTClassActivator;")
-#endif //!FEATURE_CORECLR
 
 cpp_quote("#if 0")
 
@@ -97,30 +87,6 @@ cpp_quote("EXTERN_GUID(CLR_ID_ONECORE_CLR, 0xb1ee760d, 0x6c4a, 0x4533, 0xba, 0x4
 // IID_IPrivateManagedExceptionReporting :     uuid{AD76A023-332D-4298-8001-07AA9350DCA4}
 cpp_quote("EXTERN_GUID(IID_IPrivateManagedExceptionReporting, 0xad76a023, 0x332d, 0x4298, 0x80, 0x01, 0x07, 0xaa, 0x93, 0x50, 0xdc, 0xa4);")
 
-#ifndef FEATURE_CORECLR
-// CLSID CLRRuntimeHostInternal :    uuid(f7721072-bf57-476d-89f8-a7625d27683a)
-cpp_quote("EXTERN_GUID(CLSID_CLRRuntimeHostInternal, 0xf7721072, 0xbf57, 0x476d, 0x89, 0xf8, 0xa7, 0x62, 0x5d, 0x27, 0x68, 0x3a);")
-// IID ICLRRuntimeHostInternal :     uuid{07C4E752-3CBA-4A07-9943-B5F206382178}
-cpp_quote("EXTERN_GUID(IID_ICLRRuntimeHostInternal, 0x07c4e752, 0x3cba, 0x4a07, 0x99, 0x43, 0xb5, 0xf2, 0x06, 0x38, 0x21, 0x78);")
-
-// CLSID_CLRShimControlInternal : uuid(62D02A5B-F527-44d8-80BC-650BBD3CB082)
-cpp_quote("EXTERN_GUID(CLSID_CLRShimControlInternal, 0x62d02a5b, 0xf527, 0x44d8, 0x80, 0xbc, 0x65, 0xb, 0xbd, 0x3c, 0xb0, 0x82);")
-
-// IID ICLRShimControlInternal :     uuid{826AAAD7-717B-44f8-9BB0-7DAC368B85A5}
-cpp_quote("EXTERN_GUID(IID_ICLRShimControlInternal, 0x826AAAD7, 0x717b, 0x44f8, 0x9b, 0xb0, 0x7d, 0xac, 0x36, 0x8b, 0x85, 0xa5);")
-
-// CLSID_CLRActivationFactory :     uuid{5B132A7D-DA8E-461b-A0F2-109141C768CB}
-cpp_quote("EXTERN_GUID(CLSID_CLRActivationFactory, 0x5b132a7d, 0xda8e, 0x461b, 0xa0, 0xf2, 0x10, 0x91, 0x41, 0xc7, 0x68, 0xcb );")
-
-// IID_ICLRActivationFactory :     uuid{331F2F6C-385F-462c-9125-816712FB2BC6}
-cpp_quote("EXTERN_GUID(IID_ICLRActivationFactory, 0x331f2f6c, 0x385f, 0x462c, 0x91, 0x25, 0x81, 0x67, 0x12, 0xfb, 0x2b, 0xc6);")
-
-// IID_ICLRActivationFactory2 :    uuid{035049E5-2658-40C0-9269-21C48D8F0748}
-cpp_quote("EXTERN_GUID(IID_ICLRActivationFactory2, 0x035049E5, 0x2658, 0x40C0, 0x92, 0x69, 0x21, 0xC4, 0x8D, 0x8F, 0x07, 0x48);")
-
-// IID IID_ICLRExecutionManager: uuid(1000A3E7-B420-4620-AE30-FB19B587AD1D)
-cpp_quote("EXTERN_GUID(IID_ICLRExecutionManager, 0x1000A3E7, 0xB420, 0x4620, 0xAE, 0x30, 0xFB, 0x19, 0xB5, 0x87, 0xAD, 0x1D);")
-#endif // !FEATURE_CORECLR
 
 //*****************************************************************************
 // Interface for exposing services from the EE to other DLLs of the CLR.
@@ -327,165 +293,4 @@ interface IPrivateManagedExceptionReporting : IUnknown
     HRESULT GetBucketParametersForCurrentException([out]BucketParameters *pParams);
 }
 
-#ifndef FEATURE_CORECLR
-/**************************************************************************************
- ** ICLRRuntimeHostInternal                                                          **
- ** This is the functionality used only by CLR internal tools that moved from being  **
- ** flat APIs (loading the latest runtime) to something that is runtime-specific and **
- ** requires the runtime to be loaded.                                               **
- **************************************************************************************/
-[
-    uuid(07C4E752-3CBA-4A07-9943-B5F206382178),
-    version(1.0),
-    helpstring("CLR internal hosting interface for V4.0"),
-    local
-]
-interface ICLRRuntimeHostInternal : IUnknown
-{
-    HRESULT MetaDataGetDispenser(
-        [in]                        REFCLSID   rclsid, 
-        [in]                        REFIID     riid, 
-        [out, iid_is(riid), retval] IUnknown **ppInterface);
-    
-    HRESULT GetAssemblyMDImport(
-        [in]                        LPCWSTR    wszFileName, // The scope (file name) to open.
-        [in]                        REFIID     riid,        // Desired interface.
-        [out, iid_is(riid), retval] IUnknown **ppIUnk);     // Returned interface on success.
-    
-    HRESULT GetMetaDataInternalInterface(
-        [in, size_is(cbData)]       BYTE   *pbData,         // MetaData data.
-        [in]                        ULONG   cbData,         // MetaData data size.
-        [in]                        DWORD   flags,          // Flags.
-        [in]                        REFIID  riid,           // Desired interface.
-        [out, iid_is(riid), retval] LPVOID *ppInterface);   // Returned interface.
-    
-    HRESULT GetMetaDataInternalInterfaceFromPublic(
-        [in]                        IUnknown *pInterface,   // Given interface.
-        [in]                        REFIID    riid,         // Desired interface.
-        [out, iid_is(riid), retval] LPVOID   *ppInterface); // Returned interface.
-    
-    HRESULT GetMetaDataPublicInterfaceFromInternal(
-        [in]                        IUnknown *pInterface,   // Given interface.
-        [in]                        REFIID    riid,         // Desired interface.
-        [out, iid_is(riid), retval] LPVOID   *ppInterface); // Returned interface.
-    
-    /**********************************************************************************
-     ** Returns the version string that MD emitter should by default write to images.**
-     ** Supersedes: GetCORRequiredVersion                                            **
-     **********************************************************************************/
-    HRESULT GetImageVersionString(
-        [out, size_is(*pcchBuffer), annotation("__out_ecount_opt(*pcchBuffer)")] LPWSTR pwzBuffer,       // Returned version string.
-        [in, out]                   DWORD *pcchBuffer);     // Buffer size/version length.
-
-    /**********************************************************************************
-     ** Locks the given module for this runtime. The HRESULT is S_OK if it is the    **
-     ** runtime represented by this instance, S_FALSE if somebody beat us to it.     **
-     **********************************************************************************/
-    HRESULT LockModuleForRuntime(
-        [in]                        BYTE   *pModuleBase,    // Address where the module is mapped.
-        [in]                        REFIID  riid,           // Desired interface.
-        [out, iid_is(riid)]         LPVOID *ppRuntime);     // The owning runtime.
-
-    /**********************************************************************************
-     ** Asks the Shim to attempt a graceful shutdown of all other runtimes loaded    **
-     ** in this process, then to exit the process via ::ExitProcess(). V4+ runtimes  **
-     ** call this instead of ::ExitProcess().                                        **
-     **********************************************************************************/
-    HRESULT ShutdownAllRuntimesThenExit(
-        [in]                        UINT    exitCode);      // Process exit code.
-
-    /**********************************************************************************
-     ** GetTrueOSVersion - Bypasses the OS compatibility shim                        **
-     **********************************************************************************/
-    HRESULT GetTrueOSVersion(
-        [out, in]                    LPOSVERSIONINFO   osvi);     // OS Version.
-
-    /**********************************************************************************
-     ** Returns the runtime that a COM component with the given CLSID would be       **
-     ** activated in. Returns runtime represented by this instance for Fx types.     **
-     **********************************************************************************/
-    HRESULT GetRuntimeForManagedCOMObject(
-        [in]                        REFCLSID rclsid,            // CLSID of the component.
-        [in]                        REFIID   riid,              // Desired runtime interface.
-        [out, iid_is(riid), retval] LPVOID  *ppRuntime);        // Returned runtime.
-};  // interface ICLRRuntimeHostInternal
-
-/**************************************************************************************
- ** ICLRShimControlInternal                                                          **
- ** This is the functionality used only by CLR internal tools that moved from being  **
- ** flat APIs (loading the latest runtime) to controlshim behavior                   **
- **************************************************************************************/
-[
-    uuid(826AAAD7-717B-44f8-9BB0-7DAC368B85A5),
-    version(1.0),
-    helpstring("CLR internal hosting interface for V4.0"),
-    local
-]
-interface ICLRShimControlInternal : IUnknown
-{
-    HRESULT SetShouldSkipSkuCheck(
-        [in]                        BOOL       bValue
-        );
-};  // interface ICLRRuntimeHostInternal
-
-
-
-/**************************************************************************************
- ** ICLRActivationFactory                                                            **
- ** This is the functionality used only by CLR to provide in-proc                    **
- ** hosting                                                                          **
- **************************************************************************************/
-[
-    uuid(331F2F6C-385F-462c-9125-816712FB2BC6),
-    version(1.0),
-    helpstring("CLR internal activation factory for V4.5"),
-    local
-]
-interface ICLRActivationFactory : IUnknown
-{
-    HRESULT CreateFactory([in] LPCWSTR activatableClassId, 
-                           [out, retval] IActivationFactory** factory);
-
-};  // interface ICLRActivationFactory
-
-/**************************************************************************************
- ** ICLRActivationFactory2                                                           **
- ** This is functionality exposed by the CLR to enable hosting WinRT components in a **
- ** non-AppX process                                                                 **
- **************************************************************************************/
-[
-    uuid(035049E5-2658-40C0-9269-21C48D8F0748),
-    version(1.0),
-    helpstring("CLR internal activation factory for desktop WinRT activation"),
-    local
-]
-interface ICLRActivationFactory2 : ICLRActivationFactory
-{
-    HRESULT GetClassActivatorForApplication(HSTRING appPath, [out] IWinRTClassActivator** ppActivator);
-};
-
-typedef enum 
-{
-    PAUSE_APP_DOMAINS = 0x1
-
-} PauseFlags;
-
-[
-    uuid(1000A3E7-B420-4620-AE30-FB19B587AD1D),
-    version(1.0),
-    helpstring("Pause and Resume Interface"),
-    pointer_default(unique),
-    local
-]
-interface ICLRExecutionManager : IUnknown
-{
-    // Pause all managed threads
-    // Parameters are ignored and reserved for future use.
-    HRESULT Pause([in] DWORD dwAppDomainId, [in] DWORD dwFlags);
-
-    // Resume managed threads
-    // Parameters are ignored and reserved for future use.
-    HRESULT Resume([in] DWORD dwAppDomainId);
-}
-#endif // !FEATURE_CORECLR
 
diff --git a/src/inc/clrnt.h b/src/inc/clrnt.h
index 08a93a4961..ebea066663 100644
--- a/src/inc/clrnt.h
+++ b/src/inc/clrnt.h
@@ -80,10 +80,8 @@
 #define __field_ecount(EHCount)
 #endif
 
-#ifdef FEATURE_CORECLR
 #undef _Ret_bytecap_
 #define _Ret_bytecap_(_Size) 
-#endif
 
 #ifndef NT_SUCCESS
 #define NT_SUCCESS(Status) (((NTSTATUS)(Status)) >= 0)
diff --git a/src/inc/clrprivbinderutil.h b/src/inc/clrprivbinderutil.h
index 129e90388e..d42f2b8d66 100644
--- a/src/inc/clrprivbinderutil.h
+++ b/src/inc/clrprivbinderutil.h
@@ -11,9 +11,6 @@
 
 #include "holder.h"
 #include "internalunknownimpl.h"
-#ifdef FEATURE_FUSION
-#include "fusion.h"
-#endif
 #include "clrprivbinding.h"
 #include "slist.h"
 #ifdef FEATURE_COMINTEROP
@@ -89,125 +86,6 @@ namespace CLRPrivBinderUtil
     }
 
     //=====================================================================================================================
-#ifdef FEATURE_FUSION
-    class CLRPrivAssemblyBindResultWrapper :
-        public IUnknownCommon<
-        IBindResult,
-        IAssemblyLocation>
-    {
-    public:
-        //-----------------------------------------------------------------------------------------------------------------
-        CLRPrivAssemblyBindResultWrapper(
-            IAssemblyName *pIAssemblyName,
-            PCWSTR wzAssemblyPath,
-            IILFingerprintFactory *pILFingerprintFactory
-            );
-
-        //-----------------------------------------------------------------------------------------------------------------
-        ~CLRPrivAssemblyBindResultWrapper();
-
-    protected:
-        //=================================================================================================================
-        // IBindResult methods
-
-        //-----------------------------------------------------------------------------------------------------------------
-        STDMETHOD(GetAssemblyNameDef)(
-            /*out*/ IAssemblyName **ppIAssemblyNameDef);
-
-        //-----------------------------------------------------------------------------------------------------------------
-        STDMETHOD(GetNextAssemblyModuleName)(
-            /*in*/      DWORD   dwNIndex,
-            __inout_ecount(*pdwCCModuleName)    LPWSTR  pwzModuleName,
-            /*in, out, annotation("__inout")*/  LPDWORD pdwCCModuleName);
-
-        //-----------------------------------------------------------------------------------------------------------------
-        STDMETHOD(GetAssemblyLocation)(
-            /*out*/ IAssemblyLocation **ppIAssemblyLocation);
-
-        //-----------------------------------------------------------------------------------------------------------------
-        STDMETHOD(GetNativeImage)(
-            /*out*/ IBindResult **ppIBindResultNI,
-            /*out*/ BOOL         *pfIBindResultNIProbed);
-
-        //-----------------------------------------------------------------------------------------------------------------
-        STDMETHOD(SetNativeImage)(
-            /*in*/  IBindResult  *pIBindResultNI,
-            /*out*/ IBindResult **ppIBindResultNIFinal);
-
-        //-----------------------------------------------------------------------------------------------------------------
-        STDMETHOD(IsEqual)(
-            /*in*/ IUnknown *pIUnk);
-
-        //-----------------------------------------------------------------------------------------------------------------
-        STDMETHOD(GetNextAssemblyNameRef)(
-            /*in*/  DWORD           dwNIndex,
-            /*out*/ IAssemblyName **ppIAssemblyNameRef);
-
-        //-----------------------------------------------------------------------------------------------------------------
-        STDMETHOD(GetNextDependentAssembly)(
-            /*in*/  DWORD      dwNIndex,
-            /*out*/ IUnknown **ppIUnknownAssembly);
-
-        //-----------------------------------------------------------------------------------------------------------------
-        STDMETHOD(GetAssemblyLocationOfILImage)(
-            /*out*/ IAssemblyLocation **ppAssemblyLocation);
-
-        //-----------------------------------------------------------------------------------------------------------------
-        STDMETHOD(GetILFingerprint)(
-            /*out*/ IILFingerprint **ppFingerprint);
-
-        //-----------------------------------------------------------------------------------------------------------------
-        STDMETHOD(GetSourceILTimestamp)(
-            /*out*/ FILETIME* pFileTime);
-
-        //-----------------------------------------------------------------------------------------------------------------
-        STDMETHOD(GetSourceILSize)(
-            /*out*/ DWORD* pSize);
-
-        //-----------------------------------------------------------------------------------------------------------------
-        STDMETHOD(GetNIInfo)(
-            /*out*/ INativeImageInstallInfo** pInfo);
-
-        //-----------------------------------------------------------------------------------------------------------------
-        STDMETHOD(GetFlags)(
-            /*out*/ DWORD * pdwFlags);
-
-        //=================================================================================================================
-        // IAssemblyLocation methods
-
-        //-----------------------------------------------------------------------------------------------------------------
-        STDMETHOD(GetLocationType)(
-            /*out*/DWORD *pdwLocationType);
-
-        //-----------------------------------------------------------------------------------------------------------------
-        STDMETHOD(GetPath)(
-            __inout_ecount(*pdwccAssemblyPath)  LPWSTR  pwzAssemblyPath,
-            /*in, annotation("__inout")*/       LPDWORD pdwccAssemblyPath);
-
-        //-----------------------------------------------------------------------------------------------------------------
-        STDMETHOD(GetHostID)(
-            /*out*/ UINT64 *puiHostID);
-
-    private:
-        inline PCWSTR GetILAssemblyPath()
-        { LIMITED_METHOD_CONTRACT; return m_wzAssemblyPath; }
-
-        NewArrayHolder<WCHAR>       m_wzAssemblyPath;
-        IAssemblyName *             m_pIAssemblyName;
-
-        // Since m_bIBindResultNISet and m_pIBindResultNI are separate data, they both need
-        // to be treated as volatile, making sure to always fetch m_bIBindResultNISet first
-        // and only read m_pIBindResultNI if m_bIBindResultNISet is true.
-        Volatile<bool>              m_bIBindResultNISet;
-        VolatilePtr<IBindResult>    m_pIBindResultNI;
-
-        IILFingerprint *            m_pIILFingerprint;
-        ReleaseHolder<IILFingerprintFactory> m_pILFingerprintFactory;
-
-        // Used as a leaf lock for publishing, such as m_pIBindResultNI.
-        Crst m_lock;
-    };  // class CLRPrivAssemblyBindResultWrapper
-#endif // FEATURE_FUSION
 
     //=================================================================================================================
     // Used to create an identity-only ICLRPrivAssembly from an ICLRPrivBinder. This is currently used when
@@ -859,9 +737,6 @@ namespace CLRPrivBinderUtil
     /** probably should be exposed on an instance (of something) method rather that magically calling GetAppDomain() **/
     ICLRPrivAssembly* RaiseAssemblyResolveEvent(IAssemblyName *pAssemblyName, ICLRPrivAssembly* pRequestingAssembly);
 
-    /** PLACEHOLDER - CLRPRivBinderFusion::BindAssemblyByName throws, despite being an HRESULT function,
-    most presumably because returning HRESULT is too lossy   **/
-
     /** Ultimately, only the binder can do ref-def matching, and it should be opaque to CLR. 
      This is not trivial to do, however, since we cannot do data conversion as the function is nofault **/
     BOOL CompareHostBinderSpecs(AssemblySpec* a1, AssemblySpec* a2);
diff --git a/src/inc/clrtypes.h b/src/inc/clrtypes.h
index 5f9de0cbf1..b0b1fc23f4 100644
--- a/src/inc/clrtypes.h
+++ b/src/inc/clrtypes.h
@@ -12,7 +12,7 @@
 #ifndef CLRTYPES_H_
 #define CLRTYPES_H_
 
-#if defined(_MSC_VER) && !defined(SOURCE_FORMATTING) && (!defined(FEATURE_CORECLR) || defined(FEATURE_CORESYSTEM))
+#if defined(_MSC_VER) && !defined(SOURCE_FORMATTING) && defined(FEATURE_CORESYSTEM)
     // Prefer intsafe.h when available, which defines many of the MAX/MIN
     // values below (which is why they are in #ifndef blocks).
     #include <intsafe.h>
diff --git a/src/inc/cor.h b/src/inc/cor.h
index 9fd279e74b..a050eb42aa 100644
--- a/src/inc/cor.h
+++ b/src/inc/cor.h
@@ -171,7 +171,6 @@ DEPRECATED_CLR_STDAPI_(void)   CoUninitializeEE(BOOL fFlags);
 DEPRECATED_CLR_STDAPI_(void)   CoEEShutDownCOM(void);
 
 
-#ifdef FEATURE_MAIN_CLR_MODULE_USES_CORE_NAME
 
 #define MAIN_CLR_MODULE_NAME_W        W("coreclr")
 #define MAIN_CLR_MODULE_NAME_A         "coreclr"
@@ -179,24 +178,10 @@ DEPRECATED_CLR_STDAPI_(void)   CoEEShutDownCOM(void);
 #define MAIN_CLR_DLL_NAME_W           MAKEDLLNAME_W(MAIN_CLR_MODULE_NAME_W)
 #define MAIN_CLR_DLL_NAME_A           MAKEDLLNAME_A(MAIN_CLR_MODULE_NAME_A)
 
-#else //FEATURE_MAIN_CLR_MODULE_USES_CORE_NAME
 
-#define MAIN_CLR_MODULE_NAME_W        L"clr"
-#define MAIN_CLR_MODULE_NAME_A         "clr"
 
-#define MAIN_CLR_DLL_NAME_W           MAKEDLLNAME_W(MAIN_CLR_MODULE_NAME_W)
-#define MAIN_CLR_DLL_NAME_A           MAKEDLLNAME_A(MAIN_CLR_MODULE_NAME_A)
-
-#endif //FEATURE_MAIN_CLR_MODULE_USES_CORE_NAME
-
-
-#ifdef FEATURE_CORECLR
 #define MSCOREE_SHIM_W               MAIN_CLR_DLL_NAME_W
 #define MSCOREE_SHIM_A               MAIN_CLR_DLL_NAME_A
-#else
-#define MSCOREE_SHIM_W                L"mscoree.dll"
-#define MSCOREE_SHIM_A                "mscoree.dll"
-#endif // FEATURE_CORECLR
 
 #define SWITCHOUT_HANDLE_VALUE ((HANDLE)(LONG_PTR)-2)
 
diff --git a/src/inc/corcompile.h b/src/inc/corcompile.h
index 73463146c6..e2d3c05d82 100644
--- a/src/inc/corcompile.h
+++ b/src/inc/corcompile.h
@@ -32,11 +32,6 @@
 #include <corhdr.h>
 #include <corinfo.h>
 #include <corjit.h>
-#ifdef FEATURE_FUSION
-#include <fusion.h>
-#include <fusionpriv.h>
-#include <binderngen.h>
-#endif //FEATURE_FUSION
 #include <sstring.h>
 #include <shash.h>
 #include <daccess.h>
@@ -190,14 +185,8 @@ enum CorCompileCodegen
     CORCOMPILE_CODEGEN_PROFILING            = 0x0004,   // supports profiling
     CORCOMPILE_CODEGEN_PROF_INSTRUMENTING   = 0x0008,   // code is instrumented to collect profile count info
 
-#if defined(_TARGET_AMD64_) && !defined(FEATURE_CORECLR)
-    CORCOMPILE_CODEGEN_USE_RYUJIT           = 0x0100,   // code is generated by Ryu JIT
-#endif
 };
 
-#if defined(_TARGET_AMD64_) && !defined(FEATURE_CORECLR)
-bool UseRyuJit();
-#endif
 
 // Used for INativeImageInstallInfo::GetConfigMask()
 // A bind will ask for the particular bits it needs set; if all bits are set, it is a match.  Additional
@@ -833,13 +822,8 @@ struct CORCOMPILE_ASSEMBLY_SIGNATURE
 
 typedef enum
 {
-#ifdef FEATURE_CORECLR
     CORECLR_INFO,
     CROSSGEN_COMPILER_INFO,
-#else
-    CLR_INFO,
-    NGEN_COMPILER_INFO,
-#endif
     NUM_RUNTIME_DLLS
 } CorCompileRuntimeDlls;
 
@@ -894,18 +878,6 @@ struct CORCOMPILE_VERSION_INFO
 };
 
 
-#ifndef FEATURE_CORECLR
-enum CorCompileDependencyInfo
-{
-#ifdef FEATURE_APTCA
-    CORCOMPILE_DEPENDENCY_IS_APTCA          = 0x1,
-    CORCOMPILE_DEPENDENCY_IS_CAPTCA         = 0x2,
-#endif //FEATURE_APTCA
-
-    CORCOMPILE_DEPENDENCY_PEKIND_MASK       = 0xff00,
-    CORCOMPILE_DEPENDENCY_PEKIND_SHIFT      = 8,
-};
-#endif //!FEATURE_CORECLR
 
 
 struct CORCOMPILE_DEPENDENCY
@@ -919,14 +891,7 @@ struct CORCOMPILE_DEPENDENCY
 
     CORCOMPILE_NGEN_SIGNATURE       signNativeImage;    // INVALID_NGEN_SIGNATURE if this a soft-bound dependency
 
-#ifdef FEATURE_APTCA
-    // Win32 version info for tracking dependency references to strong-named assemblies with APTCA
-    ULARGE_INTEGER                  uliFileVersion; // OS file version ~ NOT assembly version
-#endif //FEATURE_APTCA
 
-#ifndef FEATURE_CORECLR
-    CorCompileDependencyInfo        dependencyInfo;  //Flags about the dependency
-#endif //!FEATURE_CORECLR
 };
 
 /*********************************************************************************/
@@ -1438,13 +1403,6 @@ class ICorCompilationDomain
             DWORD                   *cDependencies
             ) = 0;
 
-#ifdef FEATURE_FUSION
-    // Use to retrieve the IBindContext to be used by the native binder.
-    // This is typically passed into InstallNativeAssembly.
-    virtual HRESULT GetIBindContext(
-            IBindContext **ppBindCtx
-            ) = 0;
-#endif
 
 #ifdef CROSSGEN_COMPILE
     virtual HRESULT SetPlatformWinmdPaths(
@@ -1456,14 +1414,13 @@ class ICorCompilationDomain
 /*********************************************************************************
  * ICorCompileInfo is the interface for a compiler
  *********************************************************************************/
-
 // Define function pointer ENCODEMODULE_CALLBACK
-typedef DWORD (__stdcall *ENCODEMODULE_CALLBACK)(LPVOID pModuleContext, CORINFO_MODULE_HANDLE moduleHandle);
+typedef DWORD (*ENCODEMODULE_CALLBACK)(LPVOID pModuleContext, CORINFO_MODULE_HANDLE moduleHandle);
 
 // Define function pointer DEFINETOKEN_CALLBACK
-typedef void (__stdcall *DEFINETOKEN_CALLBACK)(LPVOID pModuleContext, CORINFO_MODULE_HANDLE moduleHandle, DWORD index, mdTypeRef* token);
+typedef void (*DEFINETOKEN_CALLBACK)(LPVOID pModuleContext, CORINFO_MODULE_HANDLE moduleHandle, DWORD index, mdTypeRef* token);
 
-typedef HRESULT (__stdcall *CROSS_DOMAIN_CALLBACK)(LPVOID pArgs);
+typedef HRESULT (*CROSS_DOMAIN_CALLBACK)(LPVOID pArgs);
 
 class ICorCompileInfo
 {
@@ -1524,34 +1481,6 @@ class ICorCompileInfo
             CORINFO_ASSEMBLY_HANDLE *pHandle
             ) = 0;
 
-#ifdef FEATURE_FUSION
-    // Loads an assembly via fusion into the EE
-    // and returns a handle to it.
-    virtual HRESULT LoadAssemblyByName(
-            LPCWSTR                  wzName,
-            CORINFO_ASSEMBLY_HANDLE *pHandle
-            ) = 0;
-
-    // Loads an assembly via ref into the EE
-    // and returns a handle to it. The last parameter
-    // optionally allows an IAssemblyName for the ref
-    // (pre-policy) to be returned
-    virtual HRESULT LoadAssemblyRef(
-            IMDInternalImport       *pAssemblyImport,
-            mdAssemblyRef           ref,
-            CORINFO_ASSEMBLY_HANDLE *pHandle,
-            IAssemblyName           **refAssemblyName = NULL
-            ) = 0;
-
-    // Loads an assembly via its IAssemblyName.  This is 
-    // used by NGEN createpdb when generating PDBs for AutoNGENd images (it reads the
-    // IAssemblyName from the AUX file).
-    virtual HRESULT LoadAssemblyByIAssemblyName(
-            IAssemblyName           *pAssemblyName,
-            CORINFO_ASSEMBLY_HANDLE *pHandle
-            ) = 0;
-
-#endif //FEATURE_FUSION
 
 #ifdef FEATURE_COMINTEROP
     // Loads a WinRT typeref into the EE and returns
@@ -1575,19 +1504,6 @@ class ICorCompileInfo
             CORINFO_MODULE_HANDLE   *pHandle
             ) = 0;
 
-#ifndef FEATURE_CORECLR
-    // Check if the assembly supports automatic NGen
-    virtual BOOL SupportsAutoNGen(
-        CORINFO_ASSEMBLY_HANDLE assembly
-        ) = 0;
-
-    // Tell OS to set cached signing level of the native image based on input assemblies
-    virtual HRESULT SetCachedSigningLevel(
-        HANDLE hNI,
-        HANDLE *pModules,
-        COUNT_T nModules
-        ) = 0;
-#endif
 
     // Checks to see if an up to date zap exists for the
     // assembly
@@ -1604,22 +1520,6 @@ class ICorCompileInfo
             CORINFO_MODULE_HANDLE       module
             ) = 0;
 
-#ifdef FEATURE_FUSION
-    enum GetAssemblyNameFlags
-    {
-        GANF_Default    = 0,
-        GANF_Simple     = 1,
-    };
-
-    // Returns the fusion name of an assembly
-    virtual HRESULT GetAssemblyName(
-            CORINFO_ASSEMBLY_HANDLE hAssembly,
-            DWORD                   dwFlags,
-            __out_ecount(*cchAssemblyName)
-            __out_z LPWSTR          wzAssemblyName, 
-            LPDWORD                 cchAssemblyName
-            ) = 0;
-#endif //FEATURE_FUSION
 
     // Returns the dependency load setting for an assembly ref
     virtual HRESULT GetLoadHint(
@@ -1909,9 +1809,7 @@ extern "C" unsigned __stdcall PartialNGenStressPercentage();
 // create a PDB dumping all functions in hAssembly into pdbPath
 extern "C" HRESULT __stdcall CreatePdb(CORINFO_ASSEMBLY_HANDLE hAssembly, BSTR pNativeImagePath, BSTR pPdbPath, BOOL pdbLines, BSTR pManagedPdbSearchPath, LPCWSTR pDiasymreaderPath);
 
-#if defined(FEATURE_CORECLR) || defined(CROSSGEN_COMPILE)
 extern bool g_fNGenMissingDependenciesOk;
-#endif
 
 extern bool g_fNGenWinMDResilient;
 
diff --git a/src/inc/corhost.h b/src/inc/corhost.h
index 579088ca61..ada1757514 100644
--- a/src/inc/corhost.h
+++ b/src/inc/corhost.h
@@ -28,9 +28,6 @@
 
 #include "ivehandler.h"
 #include "ivalidator.h"
-#ifdef FEATURE_FUSION
-#include "fusion.h"
-#endif
 #include "holder.h"
 
 #include "clrprivhosting.h"
@@ -46,210 +43,6 @@ class DangerousNonHostedSpinLock;
 class AppDomain;
 class Assembly;
 
-#if !defined(FEATURE_CORECLR)
-class CorThreadpool : public ICorThreadpool
-{
-public:
-    HRESULT STDMETHODCALLTYPE  CorRegisterWaitForSingleObject(PHANDLE phNewWaitObject,
-                                                              HANDLE hWaitObject,
-                                                              WAITORTIMERCALLBACK Callback,
-                                                              PVOID Context,
-                                                              ULONG timeout,
-                                                              BOOL  executeOnlyOnce,
-                                                              BOOL* pResult);
-
-    HRESULT STDMETHODCALLTYPE  CorBindIoCompletionCallback(HANDLE fileHandle, LPOVERLAPPED_COMPLETION_ROUTINE callback);
-
-    HRESULT STDMETHODCALLTYPE  CorUnregisterWait(HANDLE hWaitObject,HANDLE CompletionEvent, BOOL* pResult);
-
-    HRESULT STDMETHODCALLTYPE  CorQueueUserWorkItem(LPTHREAD_START_ROUTINE Function,PVOID Context,BOOL executeOnlyOnce, BOOL* pResult );
-
-    HRESULT STDMETHODCALLTYPE  CorCallOrQueueUserWorkItem(LPTHREAD_START_ROUTINE Function,PVOID Context,BOOL* pResult );
-
-    HRESULT STDMETHODCALLTYPE  CorCreateTimer(PHANDLE phNewTimer,
-                                              WAITORTIMERCALLBACK Callback,
-                                              PVOID Parameter,
-                                              DWORD DueTime,
-                                              DWORD Period,
-                                              BOOL* pResult);
-
-    HRESULT STDMETHODCALLTYPE  CorDeleteTimer(HANDLE Timer, HANDLE CompletionEvent, BOOL* pResult);
-
-    HRESULT STDMETHODCALLTYPE  CorChangeTimer(HANDLE Timer,ULONG DueTime,ULONG Period, BOOL* pResult);
-
-    HRESULT STDMETHODCALLTYPE CorSetMaxThreads(DWORD MaxWorkerThreads,
-                                               DWORD MaxIOCompletionThreads);
-
-    HRESULT STDMETHODCALLTYPE CorGetMaxThreads(DWORD *MaxWorkerThreads,
-                                               DWORD *MaxIOCompletionThreads);
-
-    HRESULT STDMETHODCALLTYPE CorGetAvailableThreads(DWORD *AvailableWorkerThreads,
-                                                  DWORD *AvailableIOCompletionThreads);
-};
-
-class CorGCHost : public IGCHost2
-{
-public:
-    // IGCHost
-    STDMETHODIMP STDMETHODCALLTYPE SetGCStartupLimits(
-        DWORD SegmentSize,
-        DWORD MaxGen0Size);
-
-    STDMETHODIMP STDMETHODCALLTYPE Collect(
-        LONG Generation);
-
-    STDMETHODIMP STDMETHODCALLTYPE GetStats(
-        COR_GC_STATS *pStats);
-
-    STDMETHODIMP STDMETHODCALLTYPE GetThreadStats(
-        DWORD *pFiberCookie,
-        COR_GC_THREAD_STATS *pStats);
-
-    STDMETHODIMP STDMETHODCALLTYPE SetVirtualMemLimit(
-        SIZE_T sztMaxVirtualMemMB);
-
-    // IGCHost2
-    STDMETHODIMP STDMETHODCALLTYPE SetGCStartupLimitsEx(
-        SIZE_T SegmentSize,
-        SIZE_T MaxGen0Size);
-
-private:
-
-    HRESULT _SetGCSegmentSize(SIZE_T SegmentSize);
-    HRESULT _SetGCMaxGen0Size(SIZE_T MaxGen0Size);
-};
-
-class CorConfiguration : public ICorConfiguration
-{
-public:
-    virtual HRESULT STDMETHODCALLTYPE SetGCThreadControl(
-        /* [in] */ IGCThreadControl __RPC_FAR *pGCThreadControl);
-
-    virtual HRESULT STDMETHODCALLTYPE SetGCHostControl(
-        /* [in] */ IGCHostControl __RPC_FAR *pGCHostControl);
-
-    virtual HRESULT STDMETHODCALLTYPE SetDebuggerThreadControl(
-        /* [in] */ IDebuggerThreadControl __RPC_FAR *pDebuggerThreadControl);
-
-    virtual HRESULT STDMETHODCALLTYPE AddDebuggerSpecialThread(
-        /* [in] */ DWORD dwSpecialThreadId);
-
-    // This mechanism isn't thread-safe with respect to reference counting, because
-    // the runtime will use the cached pointer without adding extra refcounts to protect
-    // itself.  So if one thread calls GetGCThreadControl & another thread calls
-    // ICorHost::SetGCThreadControl, we have a race.
-    static IGCThreadControl *GetGCThreadControl()
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        return m_CachedGCThreadControl;
-    }
-
-    static IGCHostControl *GetGCHostControl()
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        return m_CachedGCHostControl;
-    }
-
-    static IDebuggerThreadControl *GetDebuggerThreadControl()
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        return m_CachedDebuggerThreadControl;
-    }
-
-    static DWORD GetDebuggerSpecialThreadCount()
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        return m_DSTCount;
-    }
-
-    static DWORD *GetDebuggerSpecialThreadArray()
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        return m_DSTArray;
-    }
-
-    // Helper function that returns true if the thread is in the debugger special thread list
-    static BOOL IsDebuggerSpecialThread(DWORD dwThreadId);
-
-    // Helper function to update the thread list in the debugger control block
-    static HRESULT RefreshDebuggerSpecialThreadList();
-
-    // Clean up debugger thread control object, called at shutdown
-    static void CleanupDebuggerThreadControl();
-
-private:
-    // Cache the IGCThreadControl interface until the EE is started, at which point
-    // we pass it through.
-    static IGCThreadControl *m_CachedGCThreadControl;
-    static IGCHostControl *m_CachedGCHostControl;
-    static IDebuggerThreadControl *m_CachedDebuggerThreadControl;
-
-    // Array of ID's of threads that should be considered "special" to
-    // the debugging services.
-    static DWORD *m_DSTArray;
-    static DWORD  m_DSTArraySize;
-    static DWORD  m_DSTCount;
-};
-
-class CorValidator : public IValidator
-{
-protected:
-    CorValidator() {LIMITED_METHOD_CONTRACT;}
-
-public:
-    STDMETHODIMP STDMETHODCALLTYPE Validate(
-            IVEHandler        *veh,
-            IUnknown          *pAppDomain,
-            unsigned long      ulFlags,
-            unsigned long      ulMaxError,
-            unsigned long      token,
-            __in_z LPWSTR             fileName,
-            BYTE               *pe,
-            unsigned long      ulSize);
-
-    STDMETHODIMP STDMETHODCALLTYPE FormatEventInfo(
-            HRESULT            hVECode,
-            VEContext          Context,
-            __out_ecount(ulMaxLength) LPWSTR             msg,
-            unsigned long      ulMaxLength,
-            SAFEARRAY         *psa);
-};
-
-class CLRValidator : public ICLRValidator
-{
-protected:
-    CLRValidator() {LIMITED_METHOD_CONTRACT;}
-
-public:
-    STDMETHODIMP STDMETHODCALLTYPE Validate(
-            IVEHandler        *veh,
-            unsigned long      ulAppDomainId,
-            unsigned long      ulFlags,
-            unsigned long      ulMaxError,
-            unsigned long      token,
-            __in_z LPWSTR             fileName,
-            BYTE               *pe,
-            unsigned long      ulSize);
-
-    STDMETHODIMP STDMETHODCALLTYPE FormatEventInfo(
-            HRESULT            hVECode,
-            VEContext          Context,
-            __out_ecount(ulMaxLength) LPWSTR             msg,
-            unsigned long      ulMaxLength,
-            SAFEARRAY         *psa);
-};
-
-class CorDebuggerInfo : public IDebuggerInfo
-{
-public:
-    STDMETHODIMP IsDebuggerAttached(BOOL *pbAttached);
-};
-#endif // !defined(FEATURE_CORECLR)
 
 class CorExecutionManager
     : public ICLRExecutionManager
@@ -271,9 +64,7 @@ protected:
     CorRuntimeHostBase()
     :m_Started(FALSE),
      m_cRef(0)
-#ifdef FEATURE_CORECLR
     , m_fStarted(FALSE)
-#endif // FEATURE_CORECLR
     {LIMITED_METHOD_CONTRACT;}
 
     STDMETHODIMP_(ULONG) AddRef(void);
@@ -336,11 +127,9 @@ protected:
 
     LONG        m_cRef;                 // Ref count.
 
-#ifdef FEATURE_CORECLR
     // This flag will be used to ensure that a CoreCLR host can invoke Start/Stop in pairs only.
     BOOL m_fStarted; 
     BOOL m_fAppDomainCreated; // this flag is used when an appdomain can only create a single appdomain
-#endif // FEATURE_CORECLR
 
     static ULONG       m_Version;              // Version of ICorRuntimeHost.
                                         // Some functions are only available in ICLRRuntimeHost.
@@ -358,162 +147,6 @@ public:
 
 };
 
-#if !defined(FEATURE_CORECLR) // simple hosting
-class CorHost :
-    public CorRuntimeHostBase, public ICorRuntimeHost, public CorThreadpool
-    , public CorGCHost, public CorConfiguration
-    , public CorValidator, public CorDebuggerInfo
-    , public CorExecutionManager
-{
-public:
-    CorHost() {WRAPPER_NO_CONTRACT;}
-
-    // *** IUnknown methods ***
-    STDMETHODIMP    QueryInterface(REFIID riid, void** ppv);
-    STDMETHODIMP_(ULONG) AddRef(void)
-    {
-        WRAPPER_NO_CONTRACT;
-        STATIC_CONTRACT_SO_TOLERANT;
-        return CorRuntimeHostBase::AddRef();
-    }
-    STDMETHODIMP_(ULONG) Release(void);
-
-
-    // *** ICorRuntimeHost methods ***
-    // Returns an object for configuring the runtime prior to
-    // it starting. If the runtime has been initialized this
-    // routine returns an error. See ICorConfiguration.
-    STDMETHODIMP GetConfiguration(ICorConfiguration** pConfiguration);
-
-
-    // Starts the runtime. This is equivalent to CoInitializeCor();
-    STDMETHODIMP Start(void);
-
-    STDMETHODIMP Stop();
-
-    // Creates a domain in the runtime. The identity array is
-    // a pointer to an array TYPE containing IIdentity objects defining
-    // the security identity.
-    STDMETHODIMP CreateDomain(LPCWSTR pwzFriendlyName,   // Optional
-                              IUnknown* pIdentityArray, // Optional
-                              IUnknown ** pAppDomain)
-    {
-        WRAPPER_NO_CONTRACT;
-        STATIC_CONTRACT_SO_TOLERANT;
-        return CorRuntimeHostBase::CreateDomain(pwzFriendlyName,pIdentityArray,pAppDomain);
-    }
-
-    // Returns the default domain.
-    STDMETHODIMP GetDefaultDomain(IUnknown ** pAppDomain)
-    {
-        WRAPPER_NO_CONTRACT;
-        STATIC_CONTRACT_SO_TOLERANT;
-        return CorRuntimeHostBase::GetDefaultDomain(pAppDomain);
-    }
-
-    // Enumerate currently existing domains.
-    STDMETHODIMP EnumDomains(HDOMAINENUM *hEnum)
-    {
-        WRAPPER_NO_CONTRACT;
-        STATIC_CONTRACT_SO_TOLERANT;
-        return CorRuntimeHostBase::EnumDomains(hEnum);
-    }
-
-    // Returns S_FALSE when there are no more domains. A domain
-    // is passed out only when S_OK is returned.
-    STDMETHODIMP NextDomain(HDOMAINENUM hEnum,
-                            IUnknown** pAppDomain)
-    {
-        WRAPPER_NO_CONTRACT;
-        STATIC_CONTRACT_SO_TOLERANT;
-        return CorRuntimeHostBase::NextDomain(hEnum,pAppDomain);
-    }
-
-    // Close the enumeration releasing resources
-    STDMETHODIMP CloseEnum(HDOMAINENUM hEnum)
-    {
-        WRAPPER_NO_CONTRACT;
-        STATIC_CONTRACT_SO_TOLERANT;
-        return CorRuntimeHostBase::CloseEnum(hEnum);
-    }
-
-    STDMETHODIMP CreateDomainEx(LPCWSTR pwzFriendlyName,
-                                IUnknown* pSetup, // Optional
-                                IUnknown* pEvidence, // Optional
-                                IUnknown ** pAppDomain)
-    {
-        WRAPPER_NO_CONTRACT;
-        STATIC_CONTRACT_SO_TOLERANT;
-        return CorRuntimeHostBase::CreateDomainEx(pwzFriendlyName,pSetup,pEvidence,pAppDomain);
-    }
-
-    // Create appdomain setup object that can be passed into CreateDomainEx
-    STDMETHODIMP CreateDomainSetup(IUnknown** pAppDomainSetup)
-    {
-        WRAPPER_NO_CONTRACT;
-        STATIC_CONTRACT_SO_TOLERANT;
-        return CorRuntimeHostBase::CreateDomainSetup(pAppDomainSetup);
-    }
-
-    // Create Evidence object that can be passed into CreateDomainEx
-    STDMETHODIMP CreateEvidence(IUnknown** pEvidence)
-    {
-        WRAPPER_NO_CONTRACT;
-        STATIC_CONTRACT_SO_TOLERANT;
-        return CorRuntimeHostBase::CreateEvidence(pEvidence);
-    }
-
-    // Unload a domain, releasing the reference will only release the
-    // the wrapper to the domain not unload the domain.
-    STDMETHODIMP UnloadDomain(IUnknown* pAppDomain)
-    {
-        WRAPPER_NO_CONTRACT;
-        STATIC_CONTRACT_SO_TOLERANT;
-        return CorRuntimeHostBase::UnloadDomain(pAppDomain);
-    }
-
-    // Returns the threads domain if there is one.
-    STDMETHODIMP CurrentDomain(IUnknown ** pAppDomain)
-    {
-        WRAPPER_NO_CONTRACT;
-        STATIC_CONTRACT_SO_TOLERANT;
-        return CorRuntimeHostBase::CurrentDomain(pAppDomain);
-    }
-
-    // TODO: Following 4 APIs should be move to CorHost for V1.
-    STDMETHODIMP CreateLogicalThreadState();    // Return code.
-    STDMETHODIMP DeleteLogicalThreadState();    // Return code.
-    STDMETHODIMP SwitchInLogicalThreadState(    // Return code.
-        DWORD *pFiberCookie                     // [in] Cookie that indicates the fiber to use.
-        );
-
-    STDMETHODIMP SwitchOutLogicalThreadState(   // Return code.
-        DWORD **pFiberCookie                    // [out] Cookie that indicates the fiber being switched out.
-        );
-
-    STDMETHODIMP LocksHeldByLogicalThread(      // Return code.
-        DWORD *pCount                           // [out] Number of locks that the current thread holds.
-        )
-    {
-        WRAPPER_NO_CONTRACT;
-        STATIC_CONTRACT_SO_TOLERANT;
-        return CorRuntimeHostBase::LocksHeldByLogicalThread(pCount);
-    }
-
-    // Class factory hook-up.
-    static HRESULT CreateObject(REFIID riid, void **ppUnk);
-
-    STDMETHODIMP MapFile(                       // Return code.
-        HANDLE     hFile,                       // [in]  Handle for file
-        HMODULE   *hMapAddress                  // [out] HINSTANCE for mapped file
-        )
-    {
-        WRAPPER_NO_CONTRACT;
-        STATIC_CONTRACT_SO_TOLERANT;
-        return CorRuntimeHostBase::MapFile(hFile,hMapAddress);
-    }
-};
-#endif // !defined(FEATURE_CORECLR)
 
 class ConnectionNameTable;
 typedef DPTR(class ConnectionNameTable) PTR_ConnectionNameTable;
@@ -725,17 +358,7 @@ class CorHost2 :
 #ifndef FEATURE_PAL    
     , public IPrivateManagedExceptionReporting /* This interface is for internal Watson testing only*/
 #endif // FEATURE_PAL    
-#ifdef FEATURE_CORECLR
     , public ICLRRuntimeHost2
-#else
-    , public CorThreadpool
-    , public CorGCHost
-    , public CorConfiguration
-    , public CLRValidator
-    , public CorDebuggerInfo
-    , public ICLRRuntimeHost
-    , public ICLRPrivRuntime
-#endif // FEATURE_CORECLR
     , public CorExecutionManager
 {
     friend struct _DacGlobals;
@@ -755,12 +378,6 @@ public:
 
 
     // *** ICorRuntimeHost methods ***
-#ifndef FEATURE_CORECLR
-    // Returns an object for configuring the runtime prior to
-    // it starting. If the runtime has been initialized this
-    // routine returns an error. See ICorConfiguration.
-    STDMETHODIMP GetConfiguration(ICorConfiguration** pConfiguration);
-#endif // FEATURE_CORECLR
 
 #ifndef FEATURE_PAL    
     // defined in IPrivateManagedExceptionReporting interface for internal Watson testing only
@@ -818,7 +435,6 @@ public:
                                            LPCWSTR pwzArgument,
                                            DWORD   *pReturnValue);
 
-#ifdef FEATURE_CORECLR
     // *** ICLRRuntimeHost2 methods ***
     STDMETHODIMP CreateAppDomainWithManager(
         LPCWSTR wszFriendlyName,
@@ -853,44 +469,13 @@ public:
         LPCWSTR* argv,
         DWORD* pReturnValue);
 
-#endif // !FEATURE_CORECLR
 
-#if !defined(FEATURE_CORECLR)
-    /**********************************************************************************
-     ** ICLRPrivRuntime Methods
-     **********************************************************************************/
-    STDMETHODIMP GetInterface(
-        REFCLSID rclsid,
-        REFIID   riid,
-        LPVOID * ppUnk);
-
-    STDMETHODIMP CreateAppDomain(
-        LPCWSTR pwzFriendlyName,
-        ICLRPrivBinder * pBinder,
-        LPDWORD pdwAppDomainId);
-
-    STDMETHODIMP CreateDelegate(
-        DWORD appDomainID,
-        LPCWSTR wszAssemblyName,
-        LPCWSTR wszClassName,
-        LPCWSTR wszMethodName,
-        LPVOID * ppvDelegate);
-
-    STDMETHODIMP ExecuteMain(
-        ICLRPrivBinder * pBinder,
-        int * pRetVal);
-
-#endif // !FEATURE_CORECLR
 
     static IHostControl *GetHostControl ()
     {
         LIMITED_METHOD_CONTRACT;
 
-#ifdef FEATURE_CORECLR
         return NULL;
-#else // FEATURE_CORECLR
-        return m_HostControl;
-#endif // FEATURE_CORECLR
     }
 
 #ifdef FEATURE_INCLUDE_ALL_INTERFACES
@@ -898,110 +483,70 @@ public:
     {
         LIMITED_METHOD_CONTRACT;
 
-#ifdef FEATURE_CORECLR
         return NULL;
-#else // FEATURE_CORECLR
-        return m_HostMemoryManager;
-#endif // FEATURE_CORECLR
     }
 
     static IHostMalloc *GetHostMalloc ()
     {
         LIMITED_METHOD_CONTRACT;
 
-#ifdef FEATURE_CORECLR
         return NULL;
-#else // FEATURE_CORECLR
-        return m_HostMalloc;
-#endif // FEATURE_CORECLR
     }
 
     static IHostTaskManager *GetHostTaskManager ()
     {
         LIMITED_METHOD_CONTRACT;
 
-#ifdef FEATURE_CORECLR
         return NULL;
-#else // FEATURE_CORECLR
-        return m_HostTaskManager;
-#endif // FEATURE_CORECLR
     }
 
     static IHostThreadpoolManager *GetHostThreadpoolManager ()
     {
         LIMITED_METHOD_CONTRACT;
 
-#ifdef FEATURE_CORECLR
         return NULL;
-#else // FEATURE_CORECLR
-        return m_HostThreadpoolManager;
-#endif // FEATURE_CORECLR
     }
 
     static IHostIoCompletionManager *GetHostIoCompletionManager ()
     {
         LIMITED_METHOD_CONTRACT;
 
-#ifdef FEATURE_CORECLR
         return NULL;
-#else // FEATURE_CORECLR
-        return m_HostIoCompletionManager;
-#endif // FEATURE_CORECLR
     }
 
     static IHostSyncManager *GetHostSyncManager ()
     {
         LIMITED_METHOD_CONTRACT;
 
-#ifdef FEATURE_CORECLR
         return NULL;
-#else // FEATURE_CORECLR
-        return m_HostSyncManager;
-#endif // FEATURE_CORECLR
     }
 
     static IHostAssemblyManager *GetHostAssemblyManager()
     {
         LIMITED_METHOD_CONTRACT;
 
-#ifdef FEATURE_CORECLR
         return NULL;
-#else // FEATURE_CORECLR
-        return m_HostAssemblyManager;
-#endif // FEATURE_CORECLR
     }
 
     static IHostGCManager *GetHostGCManager()
     {
         LIMITED_METHOD_CONTRACT;
 
-#ifdef FEATURE_CORECLR
         return NULL;
-#else // FEATURE_CORECLR
-        return m_HostGCManager;
-#endif // FEATURE_CORECLR
     }
 
     static IHostSecurityManager *GetHostSecurityManager()
     {
         LIMITED_METHOD_CONTRACT;
 
-#ifdef FEATURE_CORECLR
         return NULL;
-#else // FEATURE_CORECLR
-        return m_HostSecurityManager;
-#endif // FEATURE_CORECLR
     }
 
     static IHostPolicyManager *GetHostPolicyManager ()
     {
         LIMITED_METHOD_CONTRACT;
 
-#ifdef FEATURE_CORECLR
         return NULL;
-#else // FEATURE_CORECLR
-        return m_HostPolicyManager;
-#endif // FEATURE_CORECLR
     }
 #endif // FEATURE_INCLUDE_ALL_INTERFACES
 
@@ -1009,12 +554,7 @@ public:
     {
         LIMITED_METHOD_CONTRACT;
 
-#ifdef FEATURE_CORECLR
         return 0;
-#else // FEATURE_CORECLR
-        _ASSERTE (m_HostOverlappedExtensionSize != -1);
-        return m_HostOverlappedExtensionSize;
-#endif // FEATURE_CORECLR
     }
 
 #ifdef FEATURE_INCLUDE_ALL_INTERFACES
@@ -1022,32 +562,13 @@ public:
     {
         LIMITED_METHOD_CONTRACT;
 
-#ifdef FEATURE_CORECLR
         return NULL;
-#else // FEATURE_CORECLR
-        return m_pHostDomainNeutralAsms;
-#endif // FEATURE_CORECLR
     }
 #endif // FEATURE_INCLUDE_ALL_INTERFACES
 
-#ifndef FEATURE_CORECLR
-    static HRESULT SetFlagsAndHostConfig(STARTUP_FLAGS dwStartupFlags, LPCWSTR pwzHostConfigFile, BOOL fFinalize);
-    static LPCWSTR GetHostConfigFile();
-
-    static void GetDefaultAppDomainProperties(StringArrayList **ppPropertyNames, StringArrayList **ppPropertyValues);
-#endif // !FEATURE_CORECLR
 
     static STARTUP_FLAGS GetStartupFlags();
 
-#ifndef FEATURE_CORECLR
-    static HRESULT SetPropertiesForDefaultAppDomain(DWORD nProperties,
-                                                    __in_ecount(nProperties) LPCWSTR *pwszPropertyNames,
-                                                    __in_ecount(nProperties) LPCWSTR *pwszPropertyValues);
-
-    static HRESULT SetAppDomainManagerType(LPCWSTR wszAppDomainManagerAssembly,
-                                           LPCWSTR wszAppDomainManagerType,
-                                           EInitializeNewDomainFlags dwInitializeDomainFlags);
-#endif // FEATURE_CORECLR
 
     static LPCWSTR GetAppDomainManagerAsm();
 
@@ -1069,14 +590,12 @@ public:
     static BOOL IsLoadFromBlocked(); // LoadFrom, LoadFile and Load(byte[]) are blocked in certain hosting scenarios
 
 private:
-#ifdef FEATURE_CORECLR
     // This flag indicates if this instance was the first to load and start CoreCLR
     BOOL m_fFirstToLoadCLR;
 
     // This flag indicates if the host has authenticated with us or not
     BOOL m_fIsHostAuthenticated;
 
-#endif // FEATURE_CORECLR
 
     // Helpers for both ICLRRuntimeHost2 and ICLRPrivRuntime
     HRESULT _CreateAppDomain(
@@ -1087,9 +606,6 @@ private:
         int nProperties, 
         LPCWSTR* pPropertyNames, 
         LPCWSTR* pPropertyValues,
-#if !defined(FEATURE_CORECLR)
-        ICLRPrivBinder* pBinder,
-#endif
         DWORD* pAppDomainID);
 
     HRESULT _CreateDelegate(
@@ -1110,29 +626,6 @@ private:
     static LPCWSTR s_wszAppDomainManagerType;
     static EInitializeNewDomainFlags s_dwDomainManagerInitFlags;
 
-#if !defined(FEATURE_CORECLR)
-    static StringArrayList s_defaultDomainPropertyNames;
-    static StringArrayList s_defaultDomainPropertyValues;
-
-protected:
-    static IHostMemoryManager *m_HostMemoryManager;
-    static IHostMalloc *m_HostMalloc;
-    static IHostTaskManager  *m_HostTaskManager;
-    static IHostThreadpoolManager *m_HostThreadpoolManager;
-    static IHostIoCompletionManager *m_HostIoCompletionManager;
-    static IHostSyncManager *m_HostSyncManager;
-    static IHostAssemblyManager *m_HostAssemblyManager;
-    static IHostGCManager *m_HostGCManager;
-    static IHostSecurityManager *m_HostSecurityManager;
-    static IHostPolicyManager *m_HostPolicyManager;
-    static int m_HostOverlappedExtensionSize;
-    static ICLRAssemblyReferenceList *m_pHostDomainNeutralAsms;
-
-    static WCHAR m_wzHostConfigFile[_MAX_PATH];
-
-    static BOOL m_dwFlagsFinalized;
-    static DangerousNonHostedSpinLock m_FlagsLock; // protects the flags and host config
-#endif // !defined(FEATURE_CORECLR)
 
     SVAL_DECL(STARTUP_FLAGS, m_dwStartupFlags);
 };
diff --git a/src/inc/corpolicy.h b/src/inc/corpolicy.h
index ce37db463e..21d615bc82 100644
--- a/src/inc/corpolicy.h
+++ b/src/inc/corpolicy.h
@@ -28,46 +28,6 @@ extern "C" {
 { 0xd41e4f1f, 0xa407, 0x11d1, {0x8b, 0xc9, 0x0, 0xc0, 0x4f, 0xa3, 0xa, 0x41 } }
 
 
-#ifndef FEATURE_CORECLR
-// See if we're set up to do a version check
-#if (VER_MAJORVERSION < 4)
-#error "Looks like major version isn't set correctly. Are you including product_version.h?"
-#endif
-
-// The following check has been added to ensure the right thing is done 
-// for SxS compatibility of mscorsecimpl.dll when moving to a new framework 
-// version. 
-//
-// The library is registered using a full path and a GUID in the following location:
-// HKLM\SOFTWARE\Microsoft\Cryptography\Providers\Trust\*
-// With a new SxS version of the framework, we need to move to a new
-// GUID so older versions continue to work unimpacted.
-//
-// The check will fail when the runtime version changes; when it does,
-// please do the following:
-//
-// If the new version is NOT a SxS release with the version number in the #if, 
-// update the version number in the #if below to the new version and you're done.
-//
-// If the new release is a SxS release, then there's a bit more work involved:
-// 1. Change COREE_POLICY_PROVIDER in CorPolicy.h to a new GUID.
-// 2. Update batchSetup to use the new GUID. To do so, update
-//    all occurrences of the GUID in 
-//    ndp\clr\src\dlls\mscorsecimpl\mscorsecimpl.vrg
-// 3. Update "real" setup to use the new GUID. To do so, update
-//    all occurrences of the GUID in 
-//    setupauthoring\netfx\clr\Components\mscorsec.dll.ddc
-// 4. Update the version number in the #if below.
-
-#if !(VER_MAJORVERSION == 4 && VER_MINORVERSION == 0)
-#error "The guid for mscorsecimpl needs to change when the runtime version changes"
-#endif
-
-// {A7F4C378-21BE-494e-BA0F-BB12C5D208C5}
-#define COREE_POLICY_PROVIDER \
-{ 0xa7f4c378, 0x21be, 0x494e, {0xba, 0x0f, 0xbb, 0x12, 0xc5, 0xd2, 0x08, 0xc5 } }
-
-#endif //#ifndef FEATURE_CORECLR
 
 // This structure is returned from the winverify trust call, free up the structure
 // using CoTaskMemAlloc except for COREE_POLICY_PROVIDER which uses LocalALLoc.
diff --git a/src/inc/corpriv.h b/src/inc/corpriv.h
index 8c737c7607..c422351402 100644
--- a/src/inc/corpriv.h
+++ b/src/inc/corpriv.h
@@ -23,10 +23,6 @@
 #include "peinformation.h"
 //
 
-#ifndef FEATURE_CORECLR
-interface IILFingerprint;
-interface IILFingerprintFactory;
-#endif
 interface IAssemblyName;
 
 // PE images loaded through the runtime.
@@ -44,9 +40,7 @@ STDAPI MetaDataGetDispenser(            // Return HRESULT
 STDAPI RuntimeCheckLocationAccess(LPCWSTR wszLocation);
 STDAPI RuntimeIsNativeImageOptedOut(IAssemblyName* pAssemblyDef);
 
-#ifdef FEATURE_VERSIONING
 LocaleID RuntimeGetFileSystemLocale();
-#endif // FEATURE_VERSIONING
 
 BOOL RuntimeFileNotFound(HRESULT hr);
 
@@ -331,11 +325,6 @@ STDAPI RuntimeOpenImageInternal(LPCWSTR pszFileName, HCORMODULE* hHandle,
 STDAPI RuntimeOpenImageByStream(IStream* pIStream, UINT64 AssemblyId, DWORD dwModuleId,
                                 HCORMODULE* hHandle, DWORD *pdwLength, MDInternalImportFlags flags);
 
-#ifndef FEATURE_CORECLR
-// NOTE: Performance critical codepaths should cache the result of this function.
-STDAPI RuntimeGetILFingerprintForPath(LPCWSTR path, IILFingerprint **ppFingerprint);
-STDAPI RuntimeCreateCachingILFingerprintFactory(IILFingerprintFactory **ppILFingerprintFactory);
-#endif //!FEATURE_CORECLR
 void   RuntimeAddRefHandle(HCORMODULE hHandle);
 STDAPI RuntimeReleaseHandle(HCORMODULE hHandle);
 STDAPI RuntimeGetImageBase(HCORMODULE hHandle, LPVOID* base, BOOL bMapped, COUNT_T* dwSize);
@@ -480,153 +469,6 @@ struct CORCOMPILE_VERSION_INFO;
 struct CORCOMPILE_DEPENDENCY;
 typedef GUID CORCOMPILE_NGEN_SIGNATURE;
 
-#ifdef FEATURE_FUSION
-//**********************************************************************
-// Gets the dependancies of a native image. If these change, then
-// the native image cannot be used.
-//
-// IMetaDataImport::GetAssemblyRefProps() can be used to obtain information about
-// the mdAssemblyRefs.
-//*****************************************************************************
-
-// {814C9E35-3F3F-4975-977A-371F0A878AC7}
-EXTERN_GUID(IID_INativeImageDependency, 0x814c9e35, 0x3f3f, 0x4975, 0x97, 0x7a, 0x37, 0x1f, 0xa, 0x87, 0x8a, 0xc7);
-
-DECLARE_INTERFACE_(INativeImageDependency, IUnknown)
-{
-    // Get the referenced assembly
-    STDMETHOD (GetILAssemblyRef) (
-        mdAssemblyRef * pAssemblyRef        // [OUT]
-        ) PURE;
-
-    // Get the post-policy assembly actually used
-    STDMETHOD (GetILAssemblyDef) (
-        mdAssemblyRef * ppAssemblyDef,          // [OUT]
-        CORCOMPILE_ASSEMBLY_SIGNATURE * pSign   // [OUT]
-        ) PURE;
-
-    // Get the native image corresponding to GetILAssemblyDef() IF
-    // there is a hard-bound (directly-referenced) native dependancy
-    //
-    // We do not need the configStrig because configStrings have to
-    // be an exact part. Any partial matches are factored out into GetConfigMask()
-    STDMETHOD (GetNativeAssemblyDef) (
-        CORCOMPILE_NGEN_SIGNATURE * pNativeSign // [OUT] INVALID_NGEN_SIGNATURE if there is no hard-bound dependancy
-        ) PURE;
-
-    // Get PEKIND of the referenced assembly
-    STDMETHOD (GetPEKind) (
-        PEKIND * CorPEKind                      // [OUT]
-        ) PURE;
-
-};  // INativeImageDependency
-
-//*****************************************************************************
-//
-// Fusion uses IFusionNativeImageInfo to obtain (and cache) informaton
-// about a native image being installed into the native image cache.
-// This allows Fusion to bind directly to native images
-// without requiring (expensively) binding to the IL assembly first.
-//
-// IMetaDataAssemblyImport can be queried for this interface
-//
-//*****************************************************************************
-// {0EA273D0-B4DA-4008-A60D-8D6EFFDD6E91}
-EXTERN_GUID(IID_INativeImageInstallInfo, 0xea273d0, 0xb4da, 0x4008, 0xa6, 0xd, 0x8d, 0x6e, 0xff, 0xdd, 0x6e, 0x91);
-
-DECLARE_INTERFACE_(INativeImageInstallInfo, IUnknown)
-{
-    // Signature of the ngen image
-    // This matches the argument type of INativeImageDependency::GetNativeAssemblyDef
-    
-    STDMETHOD (GetSignature) (
-        CORCOMPILE_NGEN_SIGNATURE * pNgenSign // [OUT]
-        ) PURE;
-
-
-    // CLR timestamp, CPU, compile options, OS type and other attributes of the
-    // NI image. This can be used to verify that the NI image was built
-    // with the running CLR.
-
-    STDMETHOD (GetVersionInfo) (
-        CORCOMPILE_VERSION_INFO * pVersionInfo // [OUT]
-        ) PURE;
-            
-
-    // Signature of the source IL assembly. This can be used to
-    // verify that the IL image matches a candidate ngen image.
-    // This matches the argument type of IAssemblyRuntimeSignature::CheckSignature
-    //
-
-    STDMETHOD (GetILSignature) (
-        CORCOMPILE_ASSEMBLY_SIGNATURE * pILSign // [OUT]
-        ) PURE;
-
-    // A partial match is allowed for the current NativeImage to be valid
-    
-    STDMETHOD (GetConfigMask) (
-        DWORD * pConfigMask // [OUT]
-        ) PURE;
-
-    //
-    // Dependancy assemblies. The native image is only valid
-    // if the dependancies have not changed.
-    //
-
-    STDMETHOD (EnumDependencies) (
-        HCORENUM * phEnum,                  // [IN/OUT] - Pointer to the enum
-        INativeImageDependency *rDeps[],    // [OUT]
-        ULONG cMax,                         // [IN] Max dependancies to enumerate in this iteration
-        DWORD * pdwCount                    // [OUT] - Number of dependancies actually enumerated
-        ) PURE;
-
-
-    // Retrieve a specific dependency by the ngen signature.
-
-    STDMETHOD (GetDependency) (
-        const CORCOMPILE_NGEN_SIGNATURE *pcngenSign,  // [IN] ngenSig of dependency you want
-        CORCOMPILE_DEPENDENCY           *pDep         // [OUT] matching dependency
-        ) PURE;
-    
-};  // INativeImageInstallInfo
-
-//*****************************************************************************
-//
-// Runtime callback made by Fusion into the CLR to determine if the NativeAssembly
-// can be used. The pUnkBindSink argument of CAssemblyName::BindToObject() can
-// be queried for this interface
-//
-//*****************************************************************************
-// {065AA013-9BDC-447c-922F-FEE929908447}
-EXTERN_GUID(IID_INativeImageEvaluate, 0x65aa013, 0x9bdc, 0x447c, 0x92, 0x2f, 0xfe, 0xe9, 0x29, 0x90, 0x84, 0x47);
-
-#ifdef _PREFAST_
-#pragma warning(push)
-#pragma warning(disable:28718) 
-#endif //_PREFAST_
-
-interface IAssembly;
-
-#ifdef _PREFAST_
-#pragma warning(pop)
-#endif //_PREFAST_
-
-
-DECLARE_INTERFACE_(INativeImageEvaluate, IUnknown)
-{
-    // This will be called before the assemblies are actually loaded.
-    //
-    // Returns S_FALSE if the native-image cannot be used.
-    
-    STDMETHOD (Evaluate) (
-        IAssembly *pILAssembly,             // [IN] IL assembly in question
-        IAssembly *pNativeAssembly,         // [IN] NGen image we are trying to use for pILAssembly 
-        BYTE * pbCachedData,                // [IN] Data cached when the native-image was generated
-        DWORD dwDataSize                    // [IN] Size of the pbCachedData buffer
-        ) PURE;
-};  // INativeImageEvaluate
-
-#endif // FEATURE_FUSION
 
 //**********************************************************************
 // Internal versions of shim functions for use by the CLR.
@@ -676,10 +518,6 @@ STDAPI GetRequestedRuntimeInfoInternal(LPCWSTR pExe,
 // and is shared by the desktop and coreclr's which have separate native binders.
 // Hence, this interface inherits a lot of "baggage."
 
-#ifdef FEATURE_FUSION
-interface IFusionBindLog;
-interface IAssemblyName;
-#endif // FEATURE_FUSION
 
 
 // A small shim around PEAssemblies/IBindResult that allow us to write Fusion/CLR-agnostic code
@@ -694,10 +532,6 @@ class LoggableAssembly
 {
   public:
     virtual SString         DisplayString() = 0;        // Returns an unspecified representation suitable for injecting into log messages.   
-#ifdef FEATURE_FUSION
-    virtual IAssemblyName*  FusionAssemblyName() = 0;   // Can return NULL. Caller must NOT release result.
-    virtual IFusionBindLog* FusionBindLog() = 0;        // Can return NULL. Caller must NOT release result.
-#endif // FEATURE_FUSION
 };
 
 
@@ -720,11 +554,6 @@ BOOL RuntimeVerifyNativeImageDependency(const CORCOMPILE_DEPENDENCY   *pExpected
 
 
 
-#ifndef FEATURE_CORECLR
-
-#include "iilfingerprint.h"
-
-#endif //!FEATURE_CORECLR
 
 #endif  // _CORPRIV_H_
 // EOF =======================================================================
diff --git a/src/inc/daccess.h b/src/inc/daccess.h
index 3e3a62c746..8ca9587a4c 100644
--- a/src/inc/daccess.h
+++ b/src/inc/daccess.h
@@ -2445,13 +2445,8 @@ typedef DPTR(PTR_PCODE) PTR_PTR_PCODE;
 #endif
 
 // Macros like MAIN_CLR_MODULE_NAME* for the DAC module
-#ifdef FEATURE_MAIN_CLR_MODULE_USES_CORE_NAME
 #define MAIN_DAC_MODULE_NAME_W  W("mscordaccore")
 #define MAIN_DAC_MODULE_DLL_NAME_W  W("mscordaccore.dll")
-#else
-#define MAIN_DAC_MODULE_NAME_W  W("mscordacwks")
-#define MAIN_DAC_MODULE_DLL_NAME_W  W("mscordacwks.dll")
-#endif
 
 // TARGET_CONSISTENCY_CHECK represents a condition that should not fail unless the DAC target is corrupt. 
 // This is in contrast to ASSERTs in DAC infrastructure code which shouldn't fail regardless of the memory
diff --git a/src/inc/dacvars.h b/src/inc/dacvars.h
index 0a60684ad1..e86cb8b579 100644
--- a/src/inc/dacvars.h
+++ b/src/inc/dacvars.h
@@ -160,11 +160,7 @@ DEFINE_DACVAR(ULONG, int, CCLRErrorReportingManager__g_ECustomDumpFlavor, CCLREr
 DEFINE_DACVAR(ULONG, PTR_SString, SString__s_Empty, SString::s_Empty)
 
 #ifdef FEATURE_APPX
-#if defined(FEATURE_CORECLR)
 DEFINE_DACVAR(ULONG, BOOL, dac__g_fAppX, ::g_fAppX)
-#else
-DEFINE_DACVAR(ULONG, PTR_AppXRTInfo, dac__g_pAppXRTInfo, ::g_pAppXRTInfo)
-#endif
 #endif // FEATURE_APPX
 
 DEFINE_DACVAR(ULONG, BOOL, SString__s_IsANSIMultibyte, SString::s_IsANSIMultibyte)
@@ -218,9 +214,7 @@ DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pStringClass, ::g_pStringClass
 DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pArrayClass, ::g_pArrayClass)
 DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pSZArrayHelperClass, ::g_pSZArrayHelperClass)
 DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pNullableClass, ::g_pNullableClass)
-#ifdef FEATURE_SPAN_OF_T
 DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pByReferenceClass, ::g_pByReferenceClass)
-#endif
 DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pExceptionClass, ::g_pExceptionClass)
 DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pThreadAbortExceptionClass, ::g_pThreadAbortExceptionClass)
 DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pOutOfMemoryExceptionClass, ::g_pOutOfMemoryExceptionClass)
@@ -233,12 +227,6 @@ DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pOverlappedDataClass, ::g_pOve
 DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pValueTypeClass, ::g_pValueTypeClass)
 DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pEnumClass, ::g_pEnumClass)
 DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pThreadClass, ::g_pThreadClass)
-#ifdef FEATURE_CER
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pCriticalFinalizerObjectClass, ::g_pCriticalFinalizerObjectClass)
-#endif
-#ifndef FEATURE_CORECLR
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pAsyncFileStream_AsyncResultClass, ::g_pAsyncFileStream_AsyncResultClass)
-#endif // !FEATURE_CORECLR
 DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pPredefinedArrayTypes, ::g_pPredefinedArrayTypes)
 DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_TypedReferenceMT, ::g_TypedReferenceMT)
 DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pByteArrayMT, ::g_pByteArrayMT)
@@ -252,9 +240,6 @@ DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pBaseRuntimeClass, ::g_pBaseRu
 DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pICastableInterface, ::g_pICastableInterface)
 #endif // FEATURE_ICASTABLE
 
-#ifdef FEATURE_CER
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pPrepareConstrainedRegionsMethod, ::g_pPrepareConstrainedRegionsMethod)
-#endif
 DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pExecuteBackoutCodeHelperMethod, ::g_pExecuteBackoutCodeHelperMethod)
 
 DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pObjectCtorMD, ::g_pObjectCtorMD)
@@ -316,12 +301,10 @@ DEFINE_DACVAR(ULONG, PTR_BYTE, WKS__gc_heap__saved_sweep_ephemeral_start, WKS::g
 DEFINE_DACVAR(ULONG, PTR_BYTE, WKS__gc_heap__background_saved_lowest_address, WKS::gc_heap::background_saved_lowest_address)
 DEFINE_DACVAR(ULONG, PTR_BYTE, WKS__gc_heap__background_saved_highest_address, WKS::gc_heap::background_saved_highest_address)
 
-#ifdef FEATURE_CORECLR
 #ifndef FEATURE_PAL
 DEFINE_DACVAR(ULONG, HANDLE, dac__g_hContinueStartupEvent, ::g_hContinueStartupEvent)
 #endif // !FEATURE_PAL
 DEFINE_DACVAR(ULONG, DWORD, CorHost2__m_dwStartupFlags, CorHost2::m_dwStartupFlags)
-#endif // FEATURE_CORECLR
 
 DEFINE_DACVAR(ULONG, HRESULT, dac__g_hrFatalError, ::g_hrFatalError)
 
@@ -329,13 +312,7 @@ DEFINE_DACVAR(ULONG, HRESULT, dac__g_hrFatalError, ::g_hrFatalError)
     DEFINE_DACVAR(ULONG, DWORD, PEFile__s_NGENDebugFlags, PEFile::s_NGENDebugFlags)
 #endif //defined(DEBUGGING_SUPPORTED) && defined (FEATURE_PREJIT)
 
-#ifndef FEATURE_CORECLR
-DEFINE_DACVAR(ULONG, DWORD, AssemblyUsageLogManager__s_UsageLogFlags, AssemblyUsageLogManager::s_UsageLogFlags)
-#endif // FEATURE_CORECLR
 
-#if defined(FEATURE_APPX_BINDER)
-DEFINE_DACVAR(ULONG, PTR_CLRPrivBinderAppX, CLRPrivBinderAppX__s_pSingleton, CLRPrivBinderAppX::s_pSingleton)
-#endif //defined(FEATURE_APPX)
 
 #ifdef FEATURE_MINIMETADATA_IN_TRIAGEDUMPS
 DEFINE_DACVAR(ULONG, DWORD, dac__g_MiniMetaDataBuffMaxSize, ::g_MiniMetaDataBuffMaxSize)
diff --git a/src/inc/eetwain.h b/src/inc/eetwain.h
index 5b88be38eb..54e9a34464 100644
--- a/src/inc/eetwain.h
+++ b/src/inc/eetwain.h
@@ -36,6 +36,9 @@
 #define USE_GC_INFO_DECODER
 #endif
 
+#if (defined(_TARGET_X86_) && !defined(FEATURE_PAL)) || defined(_TARGET_AMD64_)
+#define HAS_QUICKUNWIND
+#endif
 
 #if CHECK_APP_DOMAIN_LEAKS
 #define CHECK_APP_DOMAIN    GC_CALL_CHECK_APP_DOMAIN
@@ -226,6 +229,7 @@ virtual unsigned FindEndOfLastInterruptibleRegion(unsigned curOffset,
                                                   GCInfoToken gcInfoToken) = 0;
 #endif // _TARGET_AMD64_ && _DEBUG
 
+#ifndef CROSSGEN_COMPILE
 /*
     Enumerate all live object references in that function using
     the virtual register set. Same reference location cannot be enumerated
@@ -239,13 +243,17 @@ virtual bool EnumGcRefs(PREGDISPLAY     pContext,
                         GCEnumCallback  pCallback,
                         LPVOID          hCallBack,
                         DWORD           relOffsetOverride = NO_OVERRIDE_OFFSET) = 0;
+#endif // !CROSSGEN_COMPILE
 
+#if !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
 /*
     Return the address of the local security object reference
     (if available).
 */
 virtual OBJECTREF* GetAddrOfSecurityObject(CrawlFrame *pCF) = 0;
+#endif // !DACCESS_COMPILE && !CROSSGEN_COMPILE
 
+#ifndef CROSSGEN_COMPILE
 /*
     For a non-static method, "this" pointer is passed in as argument 0.
     However, if there is a "ldarga 0" or "starg 0" in the IL, 
@@ -258,18 +266,22 @@ virtual OBJECTREF* GetAddrOfSecurityObject(CrawlFrame *pCF) = 0;
 */
 virtual OBJECTREF GetInstance(PREGDISPLAY     pContext,
                               EECodeInfo*     pCodeInfo) = 0;
+#endif // !CROSSGEN_COMPILE
 
+#ifndef CROSSGEN_COMPILE
 /*
     Returns the extra argument passed to to shared generic code if it is still alive.
     Returns NULL in all other cases.
 */
 virtual PTR_VOID GetParamTypeArg(PREGDISPLAY     pContext,
                                  EECodeInfo *    pCodeInfo) = 0;
+#endif // !CROSSGEN_COMPILE
 
 // Returns the type of the context parameter (this, methodtable, methoddesc, or none)
 virtual GenericParamContextType GetParamContextType(PREGDISPLAY     pContext,
                                                     EECodeInfo *    pCodeInfo) = 0;
 
+#ifndef CROSSGEN_COMPILE
 /*
     Returns the offset of the GuardStack cookie if it exists.
     Returns NULL if there is no cookie.
@@ -277,7 +289,9 @@ virtual GenericParamContextType GetParamContextType(PREGDISPLAY     pContext,
 virtual void * GetGSCookieAddr(PREGDISPLAY     pContext,
                                EECodeInfo    * pCodeInfo,
                                CodeManState  * pState) = 0;
+#endif
 
+#ifndef USE_GC_INFO_DECODER
 /*
   Returns true if the given IP is in the given method's prolog or an epilog.
 */
@@ -292,6 +306,7 @@ virtual bool IsInSynchronizedRegion(
                 DWORD       relOffset,
                 GCInfoToken gcInfoToken,
                 unsigned    flags) = 0;
+#endif // !USE_GC_INFO_DECODER
 
 /*
   Returns the size of a given function as reported in the GC info (does
@@ -306,15 +321,18 @@ Returns the ReturnKind of a given function as reported in the GC info.
 
 virtual ReturnKind GetReturnKind(GCInfoToken gcInfotoken) = 0;
 
+#ifndef USE_GC_INFO_DECODER
 /*
   Returns the size of the frame (barring localloc)
 */
 virtual unsigned int GetFrameSize(GCInfoToken gcInfoToken) = 0;
+#endif // USE_GC_INFO_DECODER
 
 #ifndef DACCESS_COMPILE
 
 /* Debugger API */
 
+#ifndef WIN64EXCEPTIONS
 virtual const BYTE*     GetFinallyReturnAddr(PREGDISPLAY pReg)=0;
 
 virtual BOOL            IsInFilter(GCInfoToken gcInfoToken,
@@ -322,7 +340,6 @@ virtual BOOL            IsInFilter(GCInfoToken gcInfoToken,
                                    PCONTEXT pCtx,
                                    DWORD curNestLevel) = 0;
 
-#ifndef WIN64EXCEPTIONS
 virtual BOOL            LeaveFinally(GCInfoToken gcInfoToken,
                                      unsigned offset,
                                      PCONTEXT pCtx) = 0;
@@ -430,6 +447,7 @@ bool UnwindStackFrame(
                 StackwalkCacheUnwindInfo  *pUnwindInfo);
 #endif // CROSSGEN_COMPILE
 
+#ifdef HAS_QUICKUNWIND
 enum QuickUnwindFlag
 {
     UnwindCurrentStackFrame,
@@ -446,6 +464,7 @@ void QuickUnwindStackFrame(
              PREGDISPLAY pRD,
              StackwalkCacheEntry *pCacheEntry,
              QuickUnwindFlag flag);
+#endif // HAS_QUICKUNWIND
 
 /*
     Is the function currently at a "GC safe point" ?
@@ -467,6 +486,7 @@ unsigned FindEndOfLastInterruptibleRegion(unsigned curOffset,
                                           GCInfoToken gcInfoToken);
 #endif // _TARGET_AMD64_ && _DEBUG
 
+#ifndef CROSSGEN_COMPILE
 /*
     Enumerate all live object references in that function using
     the virtual register set. Same reference location cannot be enumerated
@@ -481,6 +501,7 @@ bool EnumGcRefs(PREGDISPLAY     pContext,
                 GCEnumCallback  pCallback,
                 LPVOID          hCallBack,
                 DWORD           relOffsetOverride = NO_OVERRIDE_OFFSET);
+#endif // !CROSSGEN_COMPILE
 
 #ifdef FEATURE_CONSERVATIVE_GC
 // Temporary conservative collection, for testing purposes, until we have
@@ -492,6 +513,7 @@ bool EnumGcRefsConservative(PREGDISPLAY     pRD,
                             LPVOID          hCallBack);
 #endif // FEATURE_CONSERVATIVE_GC
 
+#ifdef _TARGET_X86_
 /*
    Return the address of the local security object reference
    using data that was previously cached before in UnwindStackFrame
@@ -500,15 +522,21 @@ bool EnumGcRefsConservative(PREGDISPLAY     pRD,
 static OBJECTREF* GetAddrOfSecurityObjectFromCachedInfo(
         PREGDISPLAY pRD,
         StackwalkCacheUnwindInfo * stackwalkCacheUnwindInfo);
+#endif // _TARGET_X86_
 
+#if !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
 virtual
 OBJECTREF* GetAddrOfSecurityObject(CrawlFrame *pCF) DAC_UNEXPECTED();
+#endif // !DACCESS_COMPILE && !CROSSGEN_COMPILE
 
+#ifndef CROSSGEN_COMPILE
 virtual
 OBJECTREF GetInstance(
                 PREGDISPLAY     pContext,
                 EECodeInfo *    pCodeInfo);
+#endif // !CROSSGEN_COMPILE
 
+#ifndef CROSSGEN_COMPILE
 /*
     Returns the extra argument passed to to shared generic code if it is still alive.
     Returns NULL in all other cases.
@@ -516,12 +544,13 @@ OBJECTREF GetInstance(
 virtual
 PTR_VOID GetParamTypeArg(PREGDISPLAY     pContext,
                          EECodeInfo *    pCodeInfo);
+#endif // !CROSSGEN_COMPILE
 
 // Returns the type of the context parameter (this, methodtable, methoddesc, or none)
 virtual GenericParamContextType GetParamContextType(PREGDISPLAY     pContext,
                                                     EECodeInfo *    pCodeInfo);
 
-#if defined(WIN64EXCEPTIONS) && !defined(CROSSGEN_COMPILE)
+#if defined(WIN64EXCEPTIONS) && defined(USE_GC_INFO_DECODER) && !defined(CROSSGEN_COMPILE)
 /*
     Returns the generics token.  This is used by GetInstance() and GetParamTypeArg() on WIN64.
 */
@@ -534,8 +563,9 @@ PTR_VOID GetExactGenericsToken(SIZE_T          baseStackSlot,
                                EECodeInfo *    pCodeInfo);
 
 
-#endif // WIN64EXCEPTIONS && !CROSSGEN_COMPILE
+#endif // WIN64EXCEPTIONS && USE_GC_INFO_DECODER && !CROSSGEN_COMPILE
 
+#ifndef CROSSGEN_COMPILE
 /*
     Returns the offset of the GuardStack cookie if it exists.
     Returns NULL if there is no cookie.
@@ -544,8 +574,10 @@ virtual
 void * GetGSCookieAddr(PREGDISPLAY     pContext,
                        EECodeInfo    * pCodeInfo,
                        CodeManState  * pState);
+#endif
 
 
+#ifndef USE_GC_INFO_DECODER
 /*
   Returns true if the given IP is in the given method's prolog or an epilog.
 */
@@ -563,6 +595,7 @@ bool IsInSynchronizedRegion(
                 DWORD       relOffset,
                 GCInfoToken gcInfoToken,
                 unsigned    flags);
+#endif // !USE_GC_INFO_DECODER
 
 /*
   Returns the size of a given function.
@@ -575,20 +608,22 @@ Returns the ReturnKind of a given function.
 */
 virtual ReturnKind GetReturnKind(GCInfoToken gcInfotoken);
 
+#ifndef USE_GC_INFO_DECODER
 /*
   Returns the size of the frame (barring localloc)
 */
 virtual
 unsigned int GetFrameSize(GCInfoToken gcInfoToken);
+#endif // USE_GC_INFO_DECODER
 
 #ifndef DACCESS_COMPILE
 
+#ifndef WIN64EXCEPTIONS
 virtual const BYTE* GetFinallyReturnAddr(PREGDISPLAY pReg);
 virtual BOOL IsInFilter(GCInfoToken gcInfoToken,
                         unsigned offset,
                         PCONTEXT pCtx,
                           DWORD curNestLevel);
-#ifndef WIN64EXCEPTIONS
 virtual BOOL LeaveFinally(GCInfoToken gcInfoToken,
                           unsigned offset,
                           PCONTEXT pCtx);
diff --git a/src/inc/fusion.idl b/src/inc/fusion.idl
index e64909e845..4056d168ba 100644
--- a/src/inc/fusion.idl
+++ b/src/inc/fusion.idl
@@ -31,27 +31,12 @@ cpp_quote("#ifdef _MSC_VER")
 cpp_quote("#pragma once")
 cpp_quote("#endif")
 
-#if !defined(FEATURE_FUSION) && !defined(FEATURE_VERSIONING)
-cpp_quote("#if defined(_CLR_BLD) && !defined(FEATURE_FUSION)")
-cpp_quote("#error FEATURE_FUSION is not enabled, please do not include fusion.h")
-cpp_quote("#endif")
-#endif // !defined(FEATURE_FUSION) && !defined(FEATURE_VERSIONING)
 
 interface IAssemblyCache;
 interface IAssemblyCacheItem;
 interface IAssemblyName;
 interface IAssemblyEnum;
 
-#ifdef FEATURE_FUSION
-typedef enum
-{
-    ASM_CACHE_ZAP            = 0x1,
-    ASM_CACHE_GAC            = 0x2,
-    ASM_CACHE_DOWNLOAD       = 0x4,
-    ASM_CACHE_ROOT           = 0x8,  //This is only meaningful on GetCachePath. 
-    ASM_CACHE_ROOT_EX        = 0x80  // Only valid when used with GetCachePath. 
-} ASM_CACHE_FLAGS;
-#endif
 
 cpp_quote("#ifndef PEKIND_ENUM_DEFINED")
 cpp_quote("#define PEKIND_ENUM_DEFINED")
@@ -76,160 +61,6 @@ typedef enum _tagAssemblyContentType
     AssemblyContentType_Invalid         = 0xffffffff
 } AssemblyContentType;
 
-#ifdef FEATURE_FUSION
-///////////////////////////////////////////////////////////////////////////////
-//
-// IAssemblyCache
-//
-///////////////////////////////////////////////////////////////////////////////
-
-cpp_quote("// {E707DCDE-D1CD-11D2-BAB9-00C04F8ECEAE}")
-cpp_quote("EXTERN_GUID(IID_IAssemblyCache, 0xE707DCDE, 0xD1CD, 0x11D2, 0xBA, 0xB9, 0x00, 0xC0, 0x4F, 0x8E, 0xCE, 0xAE);")
-
-[
-        local,
-        object,
-        uuid(e707dcde-d1cd-11d2-bab9-00c04f8eceae),
-        pointer_default(unique)
-]
-interface IAssemblyCache : IUnknown
-{
-    cpp_quote("// {8cedc215-ac4b-488b-93c0-a50a49cb2fb8}")
-    cpp_quote("EXTERN_GUID(FUSION_REFCOUNT_UNINSTALL_SUBKEY_GUID, 0x8cedc215, 0xac4b, 0x488b, 0x93, 0xc0, 0xa5, 0x0a, 0x49, 0xcb, 0x2f, 0xb8);")
-    cpp_quote("")
-    cpp_quote("// {b02f9d65-fb77-4f7a-afa5-b391309f11c9}")
-    cpp_quote("EXTERN_GUID(FUSION_REFCOUNT_FILEPATH_GUID, 0xb02f9d65, 0xfb77, 0x4f7a, 0xaf, 0xa5, 0xb3, 0x91, 0x30, 0x9f, 0x11, 0xc9);")
-    cpp_quote("")
-    cpp_quote("// {2ec93463-b0c3-45e1-8364-327e96aea856}")
-    cpp_quote("EXTERN_GUID(FUSION_REFCOUNT_OPAQUE_STRING_GUID, 0x2ec93463, 0xb0c3, 0x45e1, 0x83, 0x64, 0x32, 0x7e, 0x96, 0xae, 0xa8, 0x56);")
-
-    cpp_quote(" // {25df0fc1-7f97-4070-add7-4b13bbfd7cb8} // this GUID cannot be used for installing into GAC.")
-    cpp_quote("EXTERN_GUID(FUSION_REFCOUNT_MSI_GUID,  0x25df0fc1, 0x7f97, 0x4070, 0xad, 0xd7, 0x4b, 0x13, 0xbb, 0xfd, 0x7c, 0xb8); ")
-
-    cpp_quote(" // {d16d444c-56d8-11d5-882d-0080c847b195}")
-    cpp_quote("EXTERN_GUID(FUSION_REFCOUNT_OSINSTALL_GUID, 0xd16d444c, 0x56d8, 0x11d5, 0x88, 0x2d, 0x00, 0x80, 0xc8, 0x47, 0xb1, 0x95); ")
-
-    typedef struct _FUSION_INSTALL_REFERENCE_
-    {
-        DWORD  cbSize;
-        DWORD  dwFlags;
-        GUID   guidScheme; // contains one of the pre-defined guids.
-        LPCWSTR szIdentifier;  // unique identifier for app installing this  assembly.
-        LPCWSTR szNonCannonicalData;  // data is description; relevent to the guid above 
-    } FUSION_INSTALL_REFERENCE, *LPFUSION_INSTALL_REFERENCE;
-
-    typedef const FUSION_INSTALL_REFERENCE  *LPCFUSION_INSTALL_REFERENCE;
-
-
-    typedef struct _ASSEMBLY_INFO
-    {
-        ULONG cbAssemblyInfo; // size of this structure for future expansion
-        DWORD dwAssemblyFlags;
-        ULARGE_INTEGER uliAssemblySizeInKB;
-        LPWSTR pszCurrentAssemblyPathBuf;
-        ULONG   cchBuf; // size of path buf.
-    } ASSEMBLY_INFO;
-
-    cpp_quote("#define IASSEMBLYCACHE_INSTALL_FLAG_REFRESH       (0x00000001)")
-    cpp_quote("#define IASSEMBLYCACHE_INSTALL_FLAG_FORCE_REFRESH (0x00000002)")
-
-    cpp_quote("#define IASSEMBLYCACHE_UNINSTALL_DISPOSITION_UNINSTALLED (1)")
-    cpp_quote("#define IASSEMBLYCACHE_UNINSTALL_DISPOSITION_STILL_IN_USE (2)")
-    cpp_quote("#define IASSEMBLYCACHE_UNINSTALL_DISPOSITION_ALREADY_UNINSTALLED (3)")
-    cpp_quote("#define IASSEMBLYCACHE_UNINSTALL_DISPOSITION_DELETE_PENDING (4)")
-    cpp_quote("#define IASSEMBLYCACHE_UNINSTALL_DISPOSITION_HAS_INSTALL_REFERENCES (5)")
-    cpp_quote("#define IASSEMBLYCACHE_UNINSTALL_DISPOSITION_REFERENCE_NOT_FOUND (6)")
-
-    cpp_quote("#define QUERYASMINFO_FLAG_VALIDATE        (0x00000001)")
-    cpp_quote("#define QUERYASMINFO_FLAG_GETSIZE         (0x00000002)")
-
-    // these flags are for dwAssemblyFlags field in struct _ASSEMBLY_INFO  
-    cpp_quote("#define ASSEMBLYINFO_FLAG_INSTALLED       (0x00000001)")
-    cpp_quote("#define ASSEMBLYINFO_FLAG_PAYLOADRESIDENT (0x00000002)")
-
-    HRESULT UninstallAssembly(
-        [in] DWORD dwFlags,
-        [in] LPCWSTR pszAssemblyName, 
-        [in] LPCFUSION_INSTALL_REFERENCE pRefData, 
-        [out, optional] ULONG *pulDisposition
-        );
- 
-    HRESULT QueryAssemblyInfo(
-        [in] DWORD dwFlags,
-        [in] LPCWSTR pszAssemblyName,
-        [in, out] ASSEMBLY_INFO *pAsmInfo
-        );
- 
-    HRESULT CreateAssemblyCacheItem( 
-        [in] DWORD dwFlags,
-        [in] PVOID pvReserved,
-        [out] IAssemblyCacheItem **ppAsmItem,
-        [in, optional] LPCWSTR pszAssemblyName  // uncanonicalized, comma separted name=value pairs.
-        );
-        
-    HRESULT CreateAssemblyScavenger
-    (
-        [out]   IUnknown **ppUnkReserved
-    );
-
-    HRESULT InstallAssembly( // if you use this, fusion will do the streaming & commit.
-        [in] DWORD dwFlags,
-        [in] LPCWSTR pszManifestFilePath, 
-        [in] LPCFUSION_INSTALL_REFERENCE pRefData
-        );
-
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// IAssemblyCacheItem
-//
-///////////////////////////////////////////////////////////////////////////////
-
-cpp_quote("// {9e3aaeb4-d1cd-11d2-bab9-00c04f8eceae}")
-cpp_quote("EXTERN_GUID(IID_IAssemblyCacheItem, 0x9e3aaeb4,0xd1cd,0x11d2,0xba,0xb9,0x00,0xc0,0x4f,0x8e,0xce,0xae);")
-
-[
-        local,
-        object,
-        uuid(9e3aaeb4-d1cd-11d2-bab9-00c04f8eceae),
-        pointer_default(unique)
-]
-interface IAssemblyCacheItem : IUnknown
-{
-    cpp_quote("#define STREAM_FORMAT_COMPLIB_MODULE    0")
-    cpp_quote("#define STREAM_FORMAT_COMPLIB_MANIFEST  1")
-    cpp_quote("#define STREAM_FORMAT_WIN32_MODULE      2")
-    cpp_quote("#define STREAM_FORMAT_WIN32_MANIFEST    4")
-    
-    cpp_quote("#define IASSEMBLYCACHEITEM_COMMIT_FLAG_REFRESH       (0x00000001)")
-    cpp_quote("#define IASSEMBLYCACHEITEM_COMMIT_FLAG_FORCE_REFRESH (0x00000002)")
-    
-    cpp_quote("#define IASSEMBLYCACHEITEM_COMMIT_DISPOSITION_INSTALLED (1)") // first time install
-    cpp_quote("#define IASSEMBLYCACHEITEM_COMMIT_DISPOSITION_REFRESHED (2)") // overwrite, if existing
-    cpp_quote("#define IASSEMBLYCACHEITEM_COMMIT_DISPOSITION_ALREADY_INSTALLED (3)") // existing, 
-    
-
-    HRESULT CreateStream(
-        [in] DWORD dwFlags,                         // For general API flags
-        [in] LPCWSTR pszStreamName,                 // Name of the stream to be passed in
-        [in] DWORD dwFormat,                        // format of the file to be streamed in.
-        [in] DWORD dwFormatFlags,                   // format-specific flags
-        [out] IStream **ppIStream,
-        [in, optional] ULARGE_INTEGER *puliMaxSize  // Max size of the Stream.
-        );
- 
-    HRESULT Commit
-    (
-        [in] DWORD dwFlags, // For general API flags like IASSEMBLYCACHEITEM _COMMIT_FLAG_REFRESH 
-        [out, optional] ULONG *pulDisposition
-    ); 
- 
-    HRESULT AbortItem(); // If you have created IAssemblyCacheItem and don't plan to use it, its good idea to call AbortItem before releasing it.
-
-}
-#endif // FEATURE_FUSION
 
 ///////////////////////////////////////////////////////////////////////////////
 //
@@ -406,125 +237,6 @@ interface IAssemblyName: IUnknown
         
 }
 
-#ifdef FEATURE_FUSION
-///////////////////////////////////////////////////////////////////////////////
-//
-// IAssemblyEnum
-//
-///////////////////////////////////////////////////////////////////////////////
-cpp_quote("// {21B8916C-F28E-11D2-A473-00C04F8EF448}")
-cpp_quote("EXTERN_GUID(IID_IAssemblyEnum, 0x21B8916C,0xF28E,0x11D2,0xA4,0x73,0x00,0xC0,0x4F,0x8E,0xF4,0x48);")
-
-[
-        local,
-        object,
-        uuid(21b8916c-f28e-11d2-a473-00c04f8ef448),
-        pointer_default(unique)
-]
-interface IAssemblyEnum : IUnknown
-{
-
-    HRESULT GetNextAssembly
-    (
-        [in]                  LPVOID                pvReserved,
-        [out]                 IAssemblyName       **ppName,
-        [in]                  DWORD                 dwFlags
-    );
-
-    HRESULT Reset(void);
-
-    HRESULT Clone 
-    (
-        [out] IAssemblyEnum **ppEnum
-    );
-    
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// IInstallReferenceItem
-//
-///////////////////////////////////////////////////////////////////////////////
-
-cpp_quote("// {582dac66-e678-449f-aba6-6faaec8a9394}")
-cpp_quote("EXTERN_GUID(IID_IInstallReferenceItem, 0x582dac66,0xe678,0x449f,0xab,0xa6,0x6f,0xaa,0xec,0x8a,0x93,0x94);")
-
-[
-        local,
-        object,
-        uuid(582dac66-e678-449f-aba6-6faaec8a9394),
-        pointer_default(unique)
-]
-interface IInstallReferenceItem : IUnknown
-{
-    HRESULT GetReference
-    (
-    [out] LPFUSION_INSTALL_REFERENCE *ppRefData,
-    [in]  DWORD dwFlags,
-    [in]  LPVOID pvReserved
-    );
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// IInstallReferenceEnum
-//
-///////////////////////////////////////////////////////////////////////////////
-
-cpp_quote("// {56b1a988-7c0c-4aa2-8639-c3eb5a90226f}")
-cpp_quote("EXTERN_GUID(IID_IInstallReferenceEnum, 0x56b1a988,0x7c0c,0x4aa2,0x86,0x39,0xc3,0xeb,0x5a,0x90,0x22,0x6f);")
-
-[
-        local,
-        object,
-        uuid(56b1a988-7c0c-4aa2-8639-c3eb5a90226f),
-        pointer_default(unique)
-]
-interface IInstallReferenceEnum : IUnknown
-{
-    HRESULT GetNextInstallReferenceItem
-            (
-            [out] IInstallReferenceItem **ppRefItem,
-            [in]  DWORD dwFlags,
-            [in]  LPVOID pvReserved
-            );
-}
-
-typedef enum _tagAssemblyComparisonResult 
-{
-    ACR_Unknown,                    // Unknown 
-    ACR_EquivalentFullMatch,        // all fields match
-    ACR_EquivalentWeakNamed,        // match based on weak-name, version numbers ignored
-    ACR_EquivalentFXUnified,        // match based on FX-unification of version numbers
-    ACR_EquivalentUnified,          // match based on legacy-unification of version numbers
-    ACR_NonEquivalentVersion,       // all fields match except version field
-    ACR_NonEquivalent,              // no match
-
-    ACR_EquivalentPartialMatch,
-    ACR_EquivalentPartialWeakNamed,  
-    ACR_EquivalentPartialUnified,
-    ACR_EquivalentPartialFXUnified,
-    ACR_NonEquivalentPartialVersion     
-} AssemblyComparisonResult;
-
-                                
-#pragma midl_echo("STDAPI CreateAssemblyConfigCookie(LPCWSTR wzConfigFilePath, struct AssemblyConfig **ppAssemblyConfigOut);")
-#pragma midl_echo("STDAPI DestroyAssemblyConfigCookie(struct AssemblyConfig *pAssemblyConfig);")
-
-#pragma midl_echo("STDAPI CompareAssemblyIdentity(LPCWSTR pwzAssemblyIdentity1, BOOL fUnified1, LPCWSTR pwzAssemblyIdentity2, BOOL fUnified2, BOOL *pfEquivalent, AssemblyComparisonResult *pResult); ")
-#pragma midl_echo("STDAPI CompareAssemblyIdentityWithConfig(LPCWSTR pwzAssemblyIdentity1, BOOL fUnified1, LPCWSTR pwzAssemblyIdentity2, BOOL fUnified2, struct AssemblyConfig *pAssemblyConfig, BOOL *pfEquivalent, AssemblyComparisonResult *pResult); ")
-#pragma midl_echo("STDAPI CreateInstallReferenceEnum(IInstallReferenceEnum **ppRefEnum, IAssemblyName *pName, DWORD dwFlags, LPVOID pvReserved);      ")
-#pragma midl_echo("STDAPI CreateAssemblyEnum(IAssemblyEnum **pEnum, IUnknown *pUnkReserved, IAssemblyName *pName, DWORD dwFlags, LPVOID pvReserved);      ") 
-#endif // FEATURE_FUSION
 
 #pragma midl_echo("STDAPI CreateAssemblyNameObject(LPASSEMBLYNAME *ppAssemblyNameObj, LPCWSTR szAssemblyName, DWORD dwFlags, LPVOID pvReserved);             ")
 
-#ifdef FEATURE_FUSION
-#pragma midl_echo("STDAPI CreateAssemblyCache(IAssemblyCache **ppAsmCache, DWORD dwReserved); ")
-#pragma midl_echo("STDAPI GetCachePath(ASM_CACHE_FLAGS dwCacheFlags,  _Out_writes_to_(*pcchPath,*pcchPath) LPWSTR pwzCachePath, PDWORD pcchPath); ")
-#pragma midl_echo("STDAPI GetAssemblyIdentityFromFile(LPCWSTR pwzFilePAth, REFIID riid, IUnknown **ppIdentity); ")
-#pragma midl_echo("STDAPI ClearDownloadCache();")
-#pragma midl_echo("typedef unsigned long MSIHANDLE;")
-#pragma midl_echo("STDAPI SetMSIHandleForLogging(MSIHANDLE hMSIHandle);")
-#endif // FEATURE_FUSION
diff --git a/src/inc/fusionbind.h b/src/inc/fusionbind.h
deleted file mode 100644
index 8628d3f9ce..0000000000
--- a/src/inc/fusionbind.h
+++ /dev/null
@@ -1,316 +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.
-
-
-
-/*============================================================
-**
-** Header:  FusionBind.hpp
-**
-** Purpose: Implements FusionBind (loader domain) architecture
-**
-**
-===========================================================*/
-#ifndef _FUSIONBIND_H
-#define _FUSIONBIND_H
-
-#ifndef FEATURE_FUSION
-#error FEATURE_FUSION is not enabled, please do not include fusionbind.h
-#endif
-
-#include <fusion.h>
-#include <fusionpriv.h>
-#include "metadata.h"
-#include "fusionsink.h"
-#include "utilcode.h"
-#include "loaderheap.h"
-#include "fusionsetup.h"
-#include "sstring.h"
-#include "ex.h"
-#ifdef PAL_STDCPP_COMPAT
-#include <type_traits>
-#else
-#include "clr_std/type_traits"
-#endif
-
-#include "binderngen.h"
-#include "clrprivbinding.h"
-
-class FusionBind
-{
-public:
-
-    //****************************************************************************************
-    //
-
-    static HRESULT GetVersion(__out_ecount(*pdwVersion) LPWSTR pVersion, __inout DWORD* pdwVersion);
-  
-    
-    //****************************************************************************************
-    //
-    // Creates a fusion context for the application domain. All ApplicationContext properties
-    // must be set in the AppDomain store prior to this call. Any changes or additions to the
-    // AppDomain store are ignored.
-    static HRESULT CreateFusionContext(LPCWSTR pzName, IApplicationContext** ppFusionContext);
-
-
-    //****************************************************************************************
-    //
-    // Loads an environmental value into the fusion context
-    static HRESULT AddEnvironmentProperty(__in LPCWSTR variable, 
-                                          __in LPCWSTR pProperty, 
-                                          IApplicationContext* pFusionContext);
-
-    //****************************************************************************************
-    //
-    static HRESULT SetupFusionContext(LPCWSTR szAppBase,
-                                      LPCWSTR szPrivateBin,
-                                      IApplicationContext** ppFusionContext);
-
-    // Starts remote load of an assembly. The thread is parked on 
-    // an event waiting for fusion to report success or failure.
-    static HRESULT RemoteLoad(IApplicationContext * pFusionContext, 
-                              FusionSink* pSink, 
-                              IAssemblyName *pName, 
-                              IAssembly *pParentAssembly,
-                              LPCWSTR pCodeBase,
-                              IAssembly** ppIAssembly,
-                              IHostAssembly** ppIHostAssembly,
-                              IBindResult** ppNativeFusionAssembly,
-                              BOOL fForIntrospectionOnly,
-                              BOOL fSuppressSecurityChecks);
-
-    static HRESULT RemoteLoadModule(IApplicationContext * pFusionContext, 
-                                    IAssemblyModuleImport* pModule, 
-                                    FusionSink *pSink,
-                                    IAssemblyModuleImport** pResult);
-
-    static BOOL VerifyBindingStringW(LPCWSTR pwStr) {
-        WRAPPER_NO_CONTRACT;
-        if (wcschr(pwStr, '\\') ||
-            wcschr(pwStr, '/') ||
-            wcschr(pwStr, ':'))
-            return FALSE;
-
-        return TRUE;
-    }
-
-    static HRESULT VerifyBindingString(LPCSTR pName) {
-        CONTRACTL
-        {
-            NOTHROW;
-            GC_NOTRIGGER;
-            INJECT_FAULT(return E_OUTOFMEMORY;);
-        }
-        CONTRACTL_END;
-
-        DWORD dwStrLen = WszMultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, pName, -1, NULL, NULL);
-        CQuickBytes qb;
-        LPWSTR pwStr = (LPWSTR) qb.AllocNoThrow(dwStrLen*sizeof(WCHAR));
-        if (!pwStr)
-            return E_OUTOFMEMORY;
-        
-        if(!WszMultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, pName, -1, pwStr, dwStrLen))
-            return HRESULT_FROM_GetLastError();
-
-        if (VerifyBindingStringW(pwStr))
-            return S_OK;
-        else
-            return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
-    }
-
-    static void GetAssemblyManifestModulePath(IAssembly *pFusionAssembly, SString &result)
-    {
-        CONTRACTL
-        {
-            THROWS;
-            INJECT_FAULT(ThrowOutOfMemory());
-        }
-        CONTRACTL_END;
-
-        DWORD dwSize = 0;
-        LPWSTR buffer = NULL;
-        COUNT_T allocation = result.GetUnicodeAllocation();
-        if (allocation > 0) {
-            // pass in the buffer if we got one
-            dwSize = allocation + 1;
-            buffer = result.OpenUnicodeBuffer(allocation);
-        }
-        HRESULT hr = pFusionAssembly->GetManifestModulePath(buffer, &dwSize);
-        if (hr == HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER))
-        {
-            if (buffer != NULL) 
-                result.CloseBuffer(0);
-            buffer = result.OpenUnicodeBuffer(dwSize-1);
-            hr = pFusionAssembly->GetManifestModulePath(buffer, &dwSize);
-        }
-        if (buffer != NULL)
-            result.CloseBuffer((SUCCEEDED(hr) && dwSize >= 1) ? (dwSize-1) : 0);
-        IfFailThrow(hr);
-    }
-
-    static SString& GetAssemblyNameDisplayName(
-        IAssemblyName *pName,
-        SString &result,
-        DWORD flags = 0 /* default */)
-    {
-        CONTRACTL
-        {
-            GC_NOTRIGGER;
-            THROWS;
-            INJECT_FAULT(ThrowOutOfMemory());
-        }
-        CONTRACTL_END;
-
-        DWORD dwSize = 0;
-        LPWSTR buffer = NULL;
-        COUNT_T allocation = result.GetUnicodeAllocation();
-        if (allocation > 0)
-        {
-            // pass in the buffer if we got one
-            dwSize = allocation + 1;
-            buffer = result.OpenUnicodeBuffer(allocation);
-        }
-
-        HRESULT hr = pName->GetDisplayName(buffer, &dwSize, flags);
-        if (hr == HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER))
-        {
-            if (buffer != NULL) 
-                result.CloseBuffer(0);
-            buffer = result.OpenUnicodeBuffer(dwSize-1);
-            hr = pName->GetDisplayName(buffer, &dwSize, flags);
-        }
-
-        if (buffer != NULL)
-        {
-            result.CloseBuffer((SUCCEEDED(hr) && dwSize >= 1) ? (dwSize-1) : 0);
-        }
-
-        IfFailThrow(hr);
-        return result;
-    }
-
-    static BOOL GetAssemblyNameStringProperty(IAssemblyName *pName, DWORD property, SString &result)
-    {
-        CONTRACTL
-        {
-            THROWS;
-            INJECT_FAULT(ThrowOutOfMemory());
-        }
-        CONTRACTL_END;
-
-        DWORD dwSize = 0;
-        LPWSTR buffer = NULL;
-        COUNT_T allocation = result.GetUnicodeAllocation();
-        if (allocation > 0) {
-            // pass in the buffer if we got one
-            dwSize = (allocation + 1) * sizeof(WCHAR);
-            buffer = result.OpenUnicodeBuffer(allocation);
-        }
-        HRESULT hr = pName->GetProperty(property, (LPVOID)buffer, &dwSize);
-        if (hr == HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER))
-        {
-            if (buffer != NULL) 
-                result.CloseBuffer(0);
-            buffer = result.OpenUnicodeBuffer(dwSize/sizeof(WCHAR) - 1);
-            hr = pName->GetProperty(property, (LPVOID)buffer, &dwSize);
-        }
-        if (buffer != NULL)
-            result.CloseBuffer((SUCCEEDED(hr) && dwSize >= sizeof(WCHAR)) ? (dwSize/sizeof(WCHAR)-1) : 0);
-        if (hr == HRESULT_FROM_WIN32(ERROR_NOT_FOUND))
-        {
-            return FALSE;
-        }
-        IfFailThrow(hr);
-              
-        return TRUE;
-    }
-
-    static BOOL GetApplicationContextStringProperty(IApplicationContext *pContext, 
-                                                    LPCWSTR property, SString &result)
-    {
-        CONTRACTL
-        {
-            THROWS;
-            INJECT_FAULT(ThrowOutOfMemory());
-        }
-        CONTRACTL_END;
-
-        DWORD dwSize = 0;
-        LPWSTR buffer = NULL;
-        COUNT_T allocation = result.GetUnicodeAllocation();
-        if (allocation > 0) {
-            // pass in the buffer if we got one
-            dwSize = (allocation + 1) * sizeof(WCHAR);
-            buffer = result.OpenUnicodeBuffer(allocation);
-        }
-        HRESULT hr = pContext->Get(property, (LPVOID)buffer, &dwSize, 0);
-        if (hr == HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER))
-        {
-            if (buffer != NULL) 
-                result.CloseBuffer(0);
-            buffer = result.OpenUnicodeBuffer(dwSize/sizeof(WCHAR) - 1);
-            hr = pContext->Get(property, (LPVOID)buffer, &dwSize, 0);
-        }
-        if (buffer != NULL)
-            result.CloseBuffer((SUCCEEDED(hr) && dwSize >= sizeof(WCHAR)) ? (dwSize/sizeof(WCHAR)-1) : 0);
-        if (hr == HRESULT_FROM_WIN32(ERROR_NOT_FOUND))
-        {
-            return FALSE;
-        }
-        IfFailThrow(hr);
-
-        return TRUE;
-    }
-
-    static BOOL GetApplicationContextDWORDProperty(IApplicationContext *pContext, 
-                                                   LPCWSTR property, DWORD *result)
-    {
-        CONTRACTL
-        {
-            THROWS;
-            INJECT_FAULT(return E_OUTOFMEMORY;);
-        }
-        CONTRACTL_END;
-
-        DWORD dwSize = sizeof(DWORD);
-        HRESULT hr = pContext->Get(property, result, &dwSize, 0);
-        if (hr == HRESULT_FROM_WIN32(ERROR_NOT_FOUND))
-            return FALSE;
-
-        IfFailThrow(hr);
-        
-        return TRUE;
-    }
-
-    static void SetApplicationContextStringProperty(IApplicationContext *pContext, LPCWSTR property, 
-                                                    SString &value)
-    {
-        CONTRACTL
-        {
-            THROWS;
-            INJECT_FAULT(ThrowOutOfMemory());
-        }
-        CONTRACTL_END;
-
-        IfFailThrow(pContext->Set(property, (void *) value.GetUnicode(), 
-                                  (value.GetCount()+1)*sizeof(WCHAR), 0));
-    }
-
-    static void SetApplicationContextDWORDProperty(IApplicationContext *pContext, LPCWSTR property, 
-                                                   DWORD value)
-    {
-        CONTRACTL
-        {
-            THROWS;
-            INJECT_FAULT(ThrowOutOfMemory());
-        }
-        CONTRACTL_END;
-
-        IfFailThrow(pContext->Set(property, &value, sizeof(value), 0));
-    }
-};
-
-#endif
-
diff --git a/src/inc/fusionpriv.idl b/src/inc/fusionpriv.idl
deleted file mode 100644
index f9aaefcd9c..0000000000
--- a/src/inc/fusionpriv.idl
+++ /dev/null
@@ -1,970 +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.
-//+---------------------------------------------------------------------------
-//
-//  Microsoft Windows
-//  File:       fusionpriv.idl
-//
-//  Contents:   Fusion Interfaces
-//
-//  Classes:
-//
-//  Functions:
-//
-//
-//----------------------------------------------------------------------------
-cpp_quote("//=--------------------------------------------------------------------------=")
-cpp_quote("// fusionpriv.h")
-cpp_quote("//=--------------------------------------------------------------------------=")
-cpp_quote("// Licensed to the .NET Foundation under one or more agreements.")
-cpp_quote("// The .NET Foundation licenses this file to you under the MIT license.")
-cpp_quote("// See the LICENSE file in the project root for more information.")
-cpp_quote("//=--------------------------------------------------------------------------=")
-cpp_quote("")
-cpp_quote("#ifdef _MSC_VER")
-cpp_quote("#pragma comment(lib,\"uuid.lib\")")
-cpp_quote("#endif")
-cpp_quote("")
-cpp_quote("//---------------------------------------------------------------------------=")
-cpp_quote("// Fusion Interfaces.")
-cpp_quote("")
-
-cpp_quote("#if defined(_CLR_BLD) && !defined(FEATURE_FUSION)")
-cpp_quote("#error FEATURE_FUSION is not enabled, please do not include fusionpriv.h")
-cpp_quote("#endif")
-
-
-import "objidl.idl";
-import "oleidl.idl";
-import "fusion.idl";
-
-#ifndef FEATURE_CORECLR
-import "binderngen.idl";
-#endif
-
-cpp_quote("#ifdef _MSC_VER")
-cpp_quote("#pragma once")
-cpp_quote("#endif")
-
-interface IAssembly;
-interface IAssemblyBindSink;
-interface IAssemblyBinding;
-interface IAssemblyManifestImport;
-interface IAssemblyModuleImport;
-interface IAssemblyBindingClosure;
-
-interface IAssemblyNameBinder;
-interface IHistoryAssembly;
-interface IHistoryReader;
-interface IFusionBindLog;
-
-interface IAssemblyScavenger;
-
-interface IHostAssembly;
-interface IHostAssemblyModuleImport;
-
-interface IMetaDataAssemblyImport;
-#pragma midl_echo("struct IMetaDataAssemblyImport;")
-
-struct AssemblyReferenceClosureWalkContextForProfAPI;
-
-cpp_quote("EXTERN_C const IID IID_IApplicationContext;       ")
-cpp_quote("EXTERN_C const IID IID_IAssembly;           ")
-cpp_quote("EXTERN_C const IID IID_IAssemblyBindSink;   ")
-cpp_quote("EXTERN_C const IID IID_IAssemblyBinding;   ")
-cpp_quote("EXTERN_C const IID IID_IAssemblyManifestImport;")
-cpp_quote("EXTERN_C const IID IID_IAssemblyModuleImport;  ")
-
-cpp_quote("EXTERN_C const IID IID_IHistoryAssembly;      ")
-cpp_quote("EXTERN_C const IID IID_IHistoryReader;      ")
-cpp_quote("EXTERN_C const IID IID_IMetaDataAssemblyImportControl;      ")
-
-cpp_quote("EXTERN_C const IID IID_IAssemblyScavenger;  ")
-
-cpp_quote("EXTERN_C const IID IID_IHostAssembly; ")
-cpp_quote("EXTERN_C const IID IID_IHostAssemblyModuleImport; ")
-//
-// Bind flags for IAssemblyName::BindToObject
-//
-// External caller of IAssemblyName::BindToObject should only use ASM_BINDF_PARENT_ASM_HINT/ASM_BINDF_NONE/ASM_BINDF_INSPECTION_ONLY.
-// The rest is used internally by fusion. They can(and should) be set via IApplicationContext::Set.
-//
-typedef enum
-{
-    ASM_BINDF_NONE                            = 0x0,
-    ASM_BINDF_FORCE_CACHE_INSTALL             = 0x1,
-    ASM_BINDF_RFS_INTEGRITY_CHECK             = 0x2,
-    ASM_BINDF_RFS_MODULE_CHECK                = 0x4,
-    ASM_BINDF_BINPATH_PROBE_ONLY              = 0x8,
-    //ASM_BINDF_SHARED_BINPATH_HINT             = 0x10, 
-    ASM_BINDF_PARENT_ASM_HINT                 = 0x20,
-    ASM_BINDF_DISALLOW_APPLYPUBLISHERPOLICY   = 0x40,
-    ASM_BINDF_DISALLOW_APPBINDINGREDIRECTS    = 0x80,
-    ASM_BINDF_DISABLE_FX_UNIFICATION          = 0x100, 
-    ASM_BINDF_DO_NOT_PROBE_NATIVE_IMAGE       = 0x200,
-    ASM_BINDF_DISABLE_DOWNLOAD                = 0x400,
-    ASM_BINDF_INSPECTION_ONLY                 = 0x800,
-    ASM_BINDF_DISALLOW_APP_BASE_PROBING       = 0x1000,
-    ASM_BINDF_SUPPRESS_SECURITY_CHECKS        = 0x2000
-} ASM_BIND_FLAGS;
-
-typedef enum tagDEVOVERRIDEMODE {
-    DEVOVERRIDE_LOCAL     = 0x1,
-    DEVOVERRIDE_GLOBAL    = 0x2
-} DEVOVERRIDEMODE;
-
-typedef	enum tagWALK_LEVEL
-{
-    LEVEL_STARTING,				// only basic info
-    LEVEL_WINRTCHECK,           // WinRT specific checks
-    LEVEL_GACCHECK,				// until find something outside of the GAC
-    LEVEL_COMPLETE,				// no reason to request higher than this
-    LEVEL_FXPREDICTED,			// full walk, but FX assemblies were predicted
-    LEVEL_FXPROBED				// full walk, but FX assemblies could not be predicted
-} WALK_LEVEL;
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// IHistoryAssembly
-//
-///////////////////////////////////////////////////////////////////////////////
-[
-        local,
-        object,
-        uuid(e6096a07-e188-4a49-8d50-2a0172a0d205),
-        pointer_default(unique)
-]
-interface IHistoryAssembly : IUnknown
-{
-    HRESULT GetAssemblyName
-    (
-        [out, annotation("__out")] LPWSTR wzAsmName,
-        [in, out, annotation("__inout")] DWORD *pdwSize
-    );
-    
-    HRESULT GetPublicKeyToken
-    (
-        [out, annotation("__out")] LPWSTR wzPublicKeyToken,
-        [in, out, annotation("__inout")] DWORD *pdwSize
-    );
-    
-    HRESULT GetCulture
-    (
-        [out, annotation("__out")] LPWSTR wzCulture,
-        [in, out, annotation("__inout")] DWORD *pdwSize
-    );
-    
-    HRESULT GetReferenceVersion
-    (
-        [out, annotation("__out")] LPWSTR wzVerRef,
-        [in, out, annotation("__inout")] DWORD *pdwSize
-    );
-        
-    HRESULT GetActivationDate
-    (
-        [out, annotation("__out")] LPWSTR wzActivationDate, 
-        [in, out, annotation("__inout")] DWORD *pdwSize
-    );
-    
-    HRESULT GetAppCfgVersion
-    (
-        [out, annotation("__out")] LPWSTR pwzVerAppCfg, 
-        [in, out, annotation("__inout")] DWORD *pdwSize
-    );
-    
-    HRESULT GetPublisherCfgVersion
-    (
-        [out, annotation("__out")] LPWSTR pwzVerPublisherCfg, 
-        [in, out, annotation("__inout")] DWORD *pdwSize
-    );
-    
-    HRESULT GetAdminCfgVersion
-    (
-        [out, annotation("__out")] LPWSTR pwzAdminCfg,
-        [in, out, annotation("__inout")] DWORD *pdwSize
-    );
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// IHistoryReader
-//
-///////////////////////////////////////////////////////////////////////////////
-[
-        local,
-        object,
-        uuid(1d23df4d-a1e2-4b8b-93d6-6ea3dc285a54),
-        pointer_default(unique)
-]
-interface IHistoryReader : IUnknown
-{
-    HRESULT GetFilePath
-    (
-        [out, annotation("__out")] LPWSTR wzFilePath,
-        [in, out, annotation("__inout")] DWORD *pdwSize
-    );
-    
-    HRESULT GetApplicationName
-    (
-        [out, annotation("__out")] LPWSTR wzAppName, 
-        [in, out, annotation("__inout")] DWORD *pdwSize
-    );
-
-    HRESULT GetEXEModulePath
-    (
-        [out, annotation("__out")] LPWSTR wzExePath, 
-        [in, out, annotation("__inout")] DWORD *pdwSize
-    );
-    
-    
-    HRESULT GetNumActivations
-    (
-        [out] DWORD *pdwNumActivations
-    );
-    
-    HRESULT GetActivationDate
-    (
-        [in] DWORD dwIdx, 
-        [out] FILETIME *pftDate
-    );
-    
-    HRESULT GetRunTimeVersion
-    (
-        [in] FILETIME *pftActivationDate,
-        [out, annotation("__out")] LPWSTR wzRunTimeVersion, 
-        [in, out, annotation("__inout")] DWORD *pdwSize
-    );
-    
-    HRESULT GetNumAssemblies
-    (
-        [in] FILETIME *pftActivationDate, 
-        [out] DWORD *pdwNumAsms
-    );
-        
-    HRESULT GetHistoryAssembly
-    (
-        [in] FILETIME *pftActivationDate, 
-        [in] DWORD dwIdx,
-        [out] IHistoryAssembly **ppHistAsm
-    );
-}
-    
-typedef enum {
-    LOADCTX_TYPE_DEFAULT,
-    LOADCTX_TYPE_LOADFROM,
-    LOADCTX_TYPE_UNKNOWN,
-    LOADCTX_TYPE_HOSTED,    // Assembly bind was provided by hosted binder.
-} LOADCTX_TYPE;
-
-// Log for normal assembly binding
-cpp_quote("#define FUSION_BIND_LOG_CATEGORY_DEFAULT       0")
-// Log for native image binding
-cpp_quote("#define FUSION_BIND_LOG_CATEGORY_NGEN          1")
-// max entry for bind log kinds. Should always point to the biggest one
-cpp_quote("#define FUSION_BIND_LOG_CATEGORY_MAX           2")
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// IFusionBindLog
-//
-///////////////////////////////////////////////////////////////////////////////
-
-[
-        local,
-        object,
-        uuid(67E9F87D-8B8A-4a90-9D3E-85ED5B2DCC83),
-        pointer_default(unique)
-]
-interface IFusionBindLog : IUnknown
-{
-    HRESULT SetResultCode
-    (
-        [in]        DWORD   dwLogCategory,
-        [in]        HRESULT hr
-    );
-
-    HRESULT GetResultCode
-    (
-        [in]       DWORD   dwLogCategory,
-        [out]       HRESULT *pHr
-    );
-    
-    HRESULT GetBindLog
-    (
-        [in]       DWORD             dwDetailLevel,
-        [in]       DWORD             dwLogCategory, 
-        [out, annotation("__out_opt")]      LPWSTR            pwzDebugLog,
-        [in, out, annotation("__inout")]  DWORD            *pcbDebugLog
-    );
-
-    HRESULT LogMessage
-    (
-        [in]       DWORD             dwDetailLevel,
-        [in]       DWORD             dwLogCategory, 
-        [in]       LPCWSTR           pwzDebugLog
-    );
-
-    HRESULT Flush
-    (
-        [in]       DWORD             dwDetailLevel,
-        [in]       DWORD             dwLogCategory
-    );
-
-    HRESULT GetBindingID
-    (
-        [out]      ULONGLONG        *pullBindingID
-    );
-
-    HRESULT ETWTraceLogMessage
-    (
-        [in]       DWORD             dwETWLogCategory, 
-        [in]       IAssemblyName     *pAsm
-    );
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// IAssemblyManifestImport
-// 
-///////////////////////////////////////////////////////////////////////////////
-[
-        local,
-        object,
-        uuid( de9a68ba-0fa2-11d3-94aa-00c04fc308ff),
-        pointer_default(unique)
-]
-interface IAssemblyManifestImport: IUnknown
-{
-    typedef [unique] IAssemblyManifestImport *LPASSEMBLY_MANIFEST_IMPORT;
-    
-    HRESULT GetAssemblyNameDef(
-        [out] IAssemblyName **ppAssemblyName);
-
-    HRESULT GetNextAssemblyNameRef(
-        [in]        DWORD            nIndex,
-        [out]       IAssemblyName ** ppAssemblyName);
-
-    HRESULT GetNextAssemblyModule(
-        [in]       DWORD                    nIndex,
-        [out]      IAssemblyModuleImport **ppImport);
-
-    HRESULT GetModuleByName(
-        [in]       LPCOLESTR               szModuleName,
-        [out]      IAssemblyModuleImport **ppModImport);
-
-    HRESULT GetManifestModulePath(
-        [out, size_is(*pccModulePath), annotation("__out_ecount_full(*pccModulePath)")]  LPOLESTR szModulePath, 
-        [in, out]  LPDWORD pccModulePath);
-
-    HRESULT GetInternalMDImport(
-        [out] IMetaDataAssemblyImport **ppMDImport);
-
-    HRESULT LoadDataFromMDImport(
-        [in] IMetaDataAssemblyImport *ppMDImport);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// IApplicationContext
-//
-///////////////////////////////////////////////////////////////////////////////
-[
-        local,
-        object,
-        uuid(7c23ff90-33af-11d3-95da-00a024a85b51),
-        pointer_default(unique)
-]
-interface IApplicationContext: IUnknown
-{
-    cpp_quote("// App context configuration variables")
-    cpp_quote("#define ACTAG_APP_BASE_URL            L\"APPBASE\"")
-    cpp_quote("#define ACTAG_MACHINE_CONFIG          L\"MACHINE_CONFIG\"")
-    cpp_quote("#define ACTAG_APP_PRIVATE_BINPATH     L\"PRIVATE_BINPATH\"")
-    cpp_quote("#define ACTAG_APP_SHARED_BINPATH      L\"SHARED_BINPATH\"")
-    cpp_quote("#define ACTAG_APP_SNAPSHOT_ID         L\"SNAPSHOT_ID\"")
-    cpp_quote("#define ACTAG_APP_CONFIG_FILE         L\"APP_CONFIG_FILE\"")
-    cpp_quote("#define ACTAG_APP_ID                  L\"APPLICATION_ID\"")
-    cpp_quote("#define ACTAG_APP_SHADOW_COPY_DIRS    L\"SHADOW_COPY_DIRS\"")
-    cpp_quote("#define ACTAG_APP_DYNAMIC_BASE        L\"DYNAMIC_BASE\"")
-    cpp_quote("#define ACTAG_APP_CACHE_BASE          L\"CACHE_BASE\"")
-    cpp_quote("#define ACTAG_APP_NAME                L\"APP_NAME\"")
-    cpp_quote("#define ACTAG_DEV_PATH                L\"DEV_PATH\"")
-    cpp_quote("#define ACTAG_HOST_CONFIG_FILE        L\"HOST_CONFIG\"")
-    cpp_quote("#define ACTAG_SXS_ACTIVATION_CONTEXT  L\"SXS\"")
-    cpp_quote("#define ACTAG_APP_CFG_LOCAL_FILEPATH  L\"APP_CFG_LOCAL_FILEPATH\"")
-    cpp_quote("#define ACTAG_ZAP_STRING              L\"ZAP_STRING\"")
-    cpp_quote("#define ACTAG_ZAP_CONFIG_FLAGS        L\"ZAP_CONFIG_FLAGS\"")
-    cpp_quote("#define ACTAG_APP_DOMAIN_ID           L\"APPDOMAIN_ID\"")
-    cpp_quote("#define ACTAG_APP_CONFIG_BLOB         L\"APP_CONFIG_BLOB\"")
-    cpp_quote("#define ACTAG_FX_ONLY                 L\"FX_ONLY\"")
-   
-    cpp_quote("// App context flag overrides")
-    cpp_quote("#define ACTAG_FORCE_CACHE_INSTALL     L\"FORCE_CACHE_INSTALL\"")
-    cpp_quote("#define ACTAG_RFS_INTEGRITY_CHECK     L\"RFS_INTEGRITY_CHECK\"")
-    cpp_quote("#define ACTAG_RFS_MODULE_CHECK        L\"RFS_MODULE_CHECK\"")
-    cpp_quote("#define ACTAG_BINPATH_PROBE_ONLY      L\"BINPATH_PROBE_ONLY\"")
-    cpp_quote("#define ACTAG_DISALLOW_APPLYPUBLISHERPOLICY  L\"DISALLOW_APP\"")
-    cpp_quote("#define ACTAG_DISALLOW_APP_BINDING_REDIRECTS  L\"DISALLOW_APP_REDIRECTS\"")
-    cpp_quote("#define ACTAG_DISALLOW_APP_BASE_PROBING L\"DISALLOW_APP_BASE_PROBING\"")
-    cpp_quote("#define ACTAG_CODE_DOWNLOAD_DISABLED  L\"CODE_DOWNLOAD_DISABLED\"")
-    cpp_quote("#define ACTAG_DISABLE_FX_ASM_UNIFICATION  L\"DISABLE_FX_ASM_UNIFICATION\"")
-
-    typedef [unique] IApplicationContext *LPAPPLICATIONCONTEXT;
-    
-    typedef enum
-    {
-        APP_CTX_FLAGS_INTERFACE = 0x1
-    } APP_FLAGS;
-
-    HRESULT SetContextNameObject(
-        [in]    LPASSEMBLYNAME pName);
-
-    HRESULT GetContextNameObject(
-        [out]   LPASSEMBLYNAME * ppName);
-
-
-    HRESULT Set(
-        [in]    LPCOLESTR szName, 
-        [in]    LPVOID pvValue,
-        [in]    DWORD  cbValue,
-        [in]    DWORD  dwFlags);
-
-    HRESULT Get(
-        [in]         LPCOLESTR szName, 
-        [out]        LPVOID   pvValue,
-        [in, out]    LPDWORD  pcbValue,
-        [in]         DWORD    dwFlags);
-        
-    HRESULT GetDynamicDirectory(
-        [out, annotation("__out_ecount_opt(*pdwSize)")]         LPWSTR wzDynamicDir,
-        [in, out]     LPDWORD pdwSize);
-        
-    HRESULT GetAppCacheDirectory(
-        [out, annotation("__out_ecount_opt(*pdwSize)")]         LPWSTR wzAppCacheDir,
-        [in, out]     LPDWORD pdwSize);
-    
-    HRESULT RegisterKnownAssembly(
-        [in]          IAssemblyName *pName,
-        [in]          LPCWSTR pwzAsmURL,
-        [out]         IAssembly **ppAsmOut);
-    
-    HRESULT PrefetchAppConfigFile();
-        
-    // This will give a IAssemblyBindingClosure object without really walking
-    // the closure. Any of the APIs on IAssemblyBindingClosure may trigger a 
-    // real walking. 
-    //
-    // This closure is not cached in fusion. Caller is responsible to cache the closure.
-    //
-    // pUnk is the result of a previous bind within the same application context. 
-    // It could be IHostAssembly or IAssembly. The assembly has to be strongly named.
-    // 
-    // dwSharingFlags cannot be 0 now.
-    HRESULT GetAssemblyBindingClosure(
-        [in]  IUnknown *pUnk,
-        [in]  LPCWSTR pwzNativeImagePath,
-        [out] IAssemblyBindingClosure **ppAsmClosure
-        );
-}
-
-[
-        local,
-        object,
-        uuid(56972d9d-0f6c-47de-a038-e82d5de3a777),
-        pointer_default(unique)
-]
-interface IAssemblyNameBinder : IUnknown 
-{
-    HRESULT BindToObject(
-        [in]      REFIID               refIID,
-        [in]      IUnknown            *pUnkSink, 
-        [in]      IUnknown            *pUnkContext,
-        [in]      LPCOLESTR            szCodeBase,
-        [in]      LONGLONG             llFlags,
-        [in]      LPVOID               pParentAssembly,
-        [in]      DWORD                cbReserved,
-        [out]     LPVOID               *ppv,
-        [out]     LPVOID               *ppvNI);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// IAssembly
-//
-///////////////////////////////////////////////////////////////////////////////
-[
-        local,
-        object,
-        uuid(ff08d7d4-04c2-11d3-94aa-00c04fc308ff),
-        pointer_default(unique)
-]
-interface IAssembly : IUnknown
-{
-    typedef [unique] IAssembly *LPASSEMBLY;
-    
-    cpp_quote("#define ASMLOC_LOCATION_MASK          0x0000001B")
-    cpp_quote("#define ASMLOC_UNKNOWN                0x00000000")
-    cpp_quote("#define ASMLOC_GAC                    0x00000001")
-    cpp_quote("#define ASMLOC_DOWNLOAD_CACHE         0x00000002")
-    cpp_quote("#define ASMLOC_RUN_FROM_SOURCE        0x00000003")
-    cpp_quote("#define ASMLOC_CODEBASE_HINT          0x00000004")
-    cpp_quote("#define ASMLOC_ZAP                    0x00000008")
-    cpp_quote("#define ASMLOC_DEV_OVERRIDE           0x00000010")
-    
-    HRESULT GetAssemblyNameDef(
-        [out] IAssemblyName **ppAssemblyName);
-
-    HRESULT GetNextAssemblyNameRef(
-        [in] DWORD nIndex,
-        [out] IAssemblyName **ppAssemblyName);
-        
-    HRESULT GetNextAssemblyModule(
-        [in] DWORD nIndex,
-        [out] IAssemblyModuleImport **ppModImport);
-
-    HRESULT GetModuleByName(
-        [in]       LPCOLESTR               szModuleName,
-        [out]      IAssemblyModuleImport **ppModImport);
-
-    HRESULT GetManifestModulePath(
-        [out, size_is(*pccModulePath), annotation("__out_ecount_full_opt(*pccModulePath)")]  LPOLESTR szModulePath, 
-        [in, out]  LPDWORD pccModulePath);
-        
-    HRESULT GetAssemblyPath(
-        [out, size_is(*lpcwBuffer), annotation("__out_ecount_full_opt(*lpcwBuffer)")] LPOLESTR pStr,
-        [in, out] LPDWORD lpcwBuffer);
-
-    HRESULT GetAssemblyLocation(
-        [out] DWORD *pdwAsmLocation);
-        
-    LOADCTX_TYPE GetFusionLoadContext();
-
-    HRESULT GetNextHardBoundDependency(
-        [in]    DWORD dwIndex, 
-        [out]   IAssembly **ppILAsm, 
-        [out]   IAssembly **ppNIAsm);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// IAssemblyBindingClosureEnumerator
-//
-///////////////////////////////////////////////////////////////////////////////
-[
-        local,
-        object,
-        uuid(b3f1e4ed-cb09-4b85-9a1b-6809582f1ebc),
-        pointer_default(unique)
-]
-interface IAssemblyBindingClosureEnumerator : IUnknown
-{
-    // Get the next assembly in the closure's path
-    HRESULT GetNextAssemblyPath(
-        [out] LPCOLESTR *ppPath,
-        [out] LPCOLESTR *ppniPath);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// IAssemblyBindingClosure
-//
-///////////////////////////////////////////////////////////////////////////////
-[
-        local,
-        object,
-        uuid(415c226a-e513-41ba-9651-9c48e97aa5de),
-        pointer_default(unique)
-]
-interface IAssemblyBindingClosure : IUnknown
-{
-    // Test if all the assemblies in the closure are in GAC.
-    // return:
-    //      S_OK        all assemblies are in GAC.
-    //      S_FALSE     not all assemblies are in GAC.
-    //      otherwise   failure.
-    HRESULT IsAllAssembliesInGAC();
-
-    // Test to see if two closures are semantically the same
-    // under the specified sharing context.
-    // return:
-    //      S_OK        Equal.
-    //      S_FALSE     Not Equal.
-    //      otherwise   failure.
-    HRESULT IsEqual(
-        [in] IAssemblyBindingClosure *pAssemblyClosure
-        );
-
-    HRESULT GetNextFailureAssembly(
-        [in]  DWORD dwIndex, 
-        [out] IAssemblyName **ppName,
-        [out] HRESULT *pHResult);
-
-	// ensure enough data is available
-    HRESULT EnsureWalked(
-        [in] IUnknown *pStartingAssembly, 
-        [in] IApplicationContext *pAppCtx, 
-        [in] WALK_LEVEL level);
-
-    // Iterate over assembly paths in the closure
-    HRESULT EnumerateAssemblies(
-        [out] IAssemblyBindingClosureEnumerator **ppEnumerator);
-
-    HRESULT HasBeenWalked([in] WALK_LEVEL level);
-
-    // Test if the assembly might have unknonwn dependecies because of WinRT
-    // return:
-    //      S_OK        May.
-    //      S_FALSE     No, all dependecies are traceable or FX.
-    //      otherwise   failure.
-    HRESULT MayHaveUnknownDependencies();
-
-
-    // The closure walker asks the profiler (when present) for any additional
-    // assembly references the profiler wishes to add.  This method is then called
-    // back by the profiler for each such assembly reference.
-    HRESULT AddProfilerAssemblyReference(
-        [in] LPVOID pbPublicKeyOrToken,
-        [in] ULONG cbPublicKeyOrToken,
-        [in] LPCWSTR     szName,
-        [in] LPVOID pMetaData,
-        [in] void  *pbHashValue,
-        [in] ULONG       cbHashValue,
-        [in] DWORD       dwAssemblyRefFlags,
-        [in] struct AssemblyReferenceClosureWalkContextForProfAPI * pContext);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// IAssemblyBindSink
-//
-///////////////////////////////////////////////////////////////////////////////
-[
-        local,
-        object,
-        uuid(af0bc960-0b9a-11d3-95ca-00a024a85b51),
-        pointer_default(unique)
-]
-interface IAssemblyBindSink : IUnknown
-{
-    typedef [unique] IAssemblyBindSink *LPASSEMBLY_BIND_SINK;
-    
-    typedef struct _tagFusionBindInfo
-    {
-        IFusionBindLog             *pdbglog;
-        IAssemblyName              *pNamePolicy;
-        DWORD                       dwPoliciesApplied;
-    } FusionBindInfo;
-
-    typedef enum
-    {
-        ASM_NOTIFICATION_START,
-        ASM_NOTIFICATION_PROGRESS,
-        ASM_NOTIFICATION_SUSPEND,
-        ASM_NOTIFICATION_ATTEMPT_NEXT_CODEBASE,
-        ASM_NOTIFICATION_BIND_INFO,
-        ASM_NOTIFICATION_DONE,
-        ASM_NOTIFICATION_NATIVE_IMAGE_DONE        
-    } ASM_NOTIFICATION;
-
-
-    HRESULT OnProgress(
-        [in]    DWORD          dwNotification,
-        [in]    HRESULT        hrNotification,
-        [in]    LPCWSTR        szNotification,
-        [in]    DWORD          dwProgress,
-        [in]    DWORD          dwProgressMax,
-        [in]    LPVOID         pvBindInfo,
-        [in]    IUnknown      *pUnk);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// IAssemblyBinding
-//
-///////////////////////////////////////////////////////////////////////////////
-[
-        local,
-        object,
-        uuid(cfe52a80-12bd-11d3-95ca-00a024a85b51),
-        pointer_default(unique)
-]
-interface IAssemblyBinding : IUnknown
-{
-    typedef [unique] IAssemblyBinding *LPASSEMBLY_BINDINDING;
-
-    HRESULT Control(
-        [in]    HRESULT        hrControl);
-
-    HRESULT DoDefaultUI(
-        [in]    HWND    hWnd,
-        [in]    DWORD   dwFlags);   
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// IAssemblyModuleImport
-//
-///////////////////////////////////////////////////////////////////////////////
-[
-        local,
-        object,
-        uuid(da0cd4b0-1117-11d3-95ca-00a024a85b51),
-        pointer_default(unique)
-]
-interface IAssemblyModuleImport : IStream
-{
-    typedef [unique] IAssemblyModuleImport *LPASSEMBLY_MODULE_IMPORT;
-
-    HRESULT GetModuleName(
-        [out, size_is(*pccModuleName), annotation("__out_ecount_full_opt(*pccModuleName)")]  LPOLESTR szModuleName, 
-        [in, out]  LPDWORD pccModuleName);
-
-    HRESULT GetHashAlgId(
-        [out]   LPDWORD pdwHashAlgId);
-
-    HRESULT GetHashValue(
-        [out, size_is(*pcbHashValue)] BYTE *pbHashValue,
-        [in, out] LPDWORD pcbHashValue);
-
-    HRESULT GetFlags(
-        [out]  LPDWORD pdwFlags);
-
-    HRESULT GetModulePath(
-        [out, size_is(*pccModulePath), annotation("__out_ecount_full_opt(*pccModulePath)")]  LPOLESTR szModulePath, 
-        [in, out]  LPDWORD pccModulePath);
-        
-    BOOL IsAvailable();
-    
-    HRESULT BindToObject(
-        [in]       IAssemblyBindSink *pBindSink,
-        [in]       IApplicationContext *pAppCtx,
-        [in]       LONGLONG llFlags,
-        [out]      LPVOID *ppv);
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// IAssemblyScavenger
-//
-///////////////////////////////////////////////////////////////////////////////
-[
-        local,
-        object,
-        uuid(21b8916c-f28e-11d2-a473-00ccff8ef448),
-        pointer_default(unique)
-]
-interface IAssemblyScavenger : IUnknown
-{
-
-    HRESULT  ScavengeAssemblyCache
-    (
-    );
-
-    HRESULT GetCacheDiskQuotas
-    (
-        [out] DWORD *pdwZapQuotaInGAC,
-        [out] DWORD *pdwDownloadQuotaAdmin,
-        [out] DWORD *pdwDownloadQuotaUser
-    );
-
-    HRESULT SetCacheDiskQuotas
-    (
-        [in] DWORD dwZapQuotaInGAC,
-        [in] DWORD dwDownloadQuotaAdmin,
-        [in] DWORD dwDownloadQuotaUser
-    );
-
-    HRESULT  GetCurrentCacheUsage
-    (
-        [out] DWORD *dwZapUsage,
-        [out] DWORD *dwDownloadUsage
-    );
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-
-[
-        local,
-        object,
-        uuid(D8FB9BD6-3969-11d3-B4AF-00C04F8ECB26),
-        pointer_default(unique)
-]
-interface ICodebaseList : IUnknown
-{
-    HRESULT AddCodebase
-    (
-        [in]       LPCWSTR              wzCodebase,
-        [in]       DWORD                dwFlags
-    );
-    
-    HRESULT RemoveCodebase
-    (
-        [in]       DWORD               dwIndex
-    );
-    
-    HRESULT RemoveAll();
-    
-    HRESULT GetCount
-    (
-        [out]      DWORD              *pdwCount
-    );
-    
-    HRESULT GetCodebase
-    (
-        [in]       DWORD               dwIndex,
-        [out]      DWORD              *pdwFlags,
-        [out, annotation("__out_ecount_opt(*pcbCodebase)")]      
-                    LPWSTR              wzCodebase,
-        [in, out]  DWORD              *pcbCodebase
-    );
-}
-
-[
-        local,
-        object,
-        uuid(0A6F16F8-ACD7-11d3-B4ED-00C04F8ECB26),
-        pointer_default(unique)
-]
-interface IDownloadMgr : IUnknown
-{
-    HRESULT PreDownloadCheck
-    (
-        [out]      void **ppv,
-        [out]      void **ppvNI
-    );
-
-    HRESULT DoSetup
-    (
-        [in]       LPCWSTR              wzSourceUrl,
-        [in]       LPCWSTR              wzFilePath,
-        [in]       const FILETIME      *pftLastMod,
-        [out]      IUnknown             **ppUnk,
-        [out]      IUnknown             **ppAsmNI
-    );
-    
-    HRESULT ProbeFailed
-    (
-        [out]      IUnknown             **ppUnk
-    );
-    
-    HRESULT IsDuplicate
-    (
-        [out]      IDownloadMgr         *ppDLMgr
-    );
-    
-    HRESULT LogResult();
-
-    HRESULT DownloadEnabled
-    (
-        [out]      BOOL *pbEnabled
-    );
-    
-    HRESULT GetBindInfo
-    (
-        [out]      FusionBindInfo       *pBindInfo
-    );
-
-    HRESULT CacheBindingResult
-    (
-        [in]        HRESULT hrResult
-    );
-}
-
-
-[
-        local,
-        object,
-        uuid(711f7c2d-8234-4505-b02f-7554f46cbf29),
-        pointer_default(unique)
-]
-interface IHostAssembly : IUnknown
-{
-    typedef [unique] IHostAssembly *LPHOSTASSEMBLY;  
-   
-    HRESULT GetAssemblyNameDef(
-        [out] IAssemblyName **ppAssemblyName);
-
-    HRESULT GetNextAssemblyNameRef(
-        [in] DWORD nIndex,
-        [out] IAssemblyName **ppAssemblyName);
-        
-    HRESULT GetNextAssemblyModule(
-        [in] DWORD nIndex,
-        [out] IHostAssemblyModuleImport **ppModImport);
-
-    HRESULT GetModuleByName(
-        [in]       LPCOLESTR                   szModuleName,
-        [out]      IHostAssemblyModuleImport **ppModImport);
-
-    // Always release the copy in fusion
-    HRESULT GetAssemblyStream(
-        [out]      IStream **ppStreamAsm);
-        
-    HRESULT GetAssemblyId(
-        [out]      UINT64 *pAssemblyId);
-
-    // Always release the copy in fusion
-    HRESULT GetAssemblyDebugStream(
-        [out]      IStream **ppDebugStream);
-
-    LOADCTX_TYPE GetFusionLoadContext(
-        );
-        
-    HRESULT GetAssemblyContext(
-        [out]      UINT64 *pdwAssemblyContext);
-}
-
-[
-        local,
-        object,
-        uuid(b6f2729d-6c0f-4944-b692-e5a2ce2c6e7a),
-        pointer_default(unique)
-]
-interface IHostAssemblyModuleImport : IUnknown
-{
-    typedef [unique] IHostAssemblyModuleImport *LPHOSTASSEMBLY_MODULE_IMPORT;
-
-    HRESULT GetModuleName(
-        [out, size_is(*pccModuleName), annotation("__out_ecount_full(*pccModuleName)")]  LPOLESTR szModuleName, 
-        [in, out]  LPDWORD pccModuleName);
-
-    HRESULT GetModuleStream(
-        [out]  IStream **ppStreamModule);
-        
-    HRESULT GetModuleId(
-        [out]  DWORD  *pdwModuleId);
-
-    HRESULT GetModuleDebugStream(
-        [out]  IStream **ppDebugStream);
-}    
-
-
-#pragma midl_echo("STDAPI CreateHistoryReader(LPCWSTR wzFilePath, IHistoryReader **ppHistReader);")
-#pragma midl_echo("STDAPI LookupHistoryAssembly(LPCWSTR pwzFilePath, FILETIME *pftActivationDate, LPCWSTR pwzAsmName, LPCWSTR pwzPublicKeyToken, LPCWSTR wzCulture, LPCWSTR pwzVerRef, IHistoryAssembly **pHistAsm);")
-#pragma midl_echo("STDAPI GetHistoryFileDirectory(__out_ecount_opt(*pdwSize) LPWSTR wzDir, DWORD *pdwSize);")
-#pragma midl_echo("STDAPI PreBindAssembly(IApplicationContext *pAppCtx, IAssemblyName *pName, IAssembly *pAsmParent, IAssemblyName **ppNamePostPolicy, LPVOID pvReserved); ")
-
-#pragma midl_echo("STDAPI CreateApplicationContext(IAssemblyName *pName, LPAPPLICATIONCONTEXT *ppCtx);             ")
-#pragma midl_echo("STDAPI IsRetargetableAssembly(IAssemblyName *pName, BOOL *pbIsRetargetable);             ")
-#pragma midl_echo("STDAPI IsOptionallyRetargetableAssembly(IAssemblyName *pName, BOOL *pbIsRetargetable);             ")
-
-
-cpp_quote("#define EXPLICITBIND_FLAGS_NON_BINDABLE          0x0")
-cpp_quote("#define EXPLICITBIND_FLAGS_EXE                   0x1")
-
-#ifndef FEATURE_CORECLR
-#pragma midl_echo("HRESULT BindToSystem(IAssemblyName *pNameSystem, LPCWSTR pcwzSystemDirectory, IUnknown *pNIEva, IApplicationContext *pAppCtx, IAssembly **ppAsmOut, IBindResult **ppNIAsmOut, IFusionBindLog **ppdbglog);")
-
-#pragma midl_echo("HRESULT ExplicitBind(LPCWSTR wzPath, IApplicationContext *pAppCtx, DWORD dwFlags, IUnknown *pNIEva, IAssembly **ppAsmOut, IBindResult **ppNIAsmOut, IFusionBindLog **ppdbglog);")
-
-#pragma midl_echo("HRESULT GetBindContextFromApplicationContext(IApplicationContext *pAppCtx, IBindContext **ppBindCtx);")
-
-#pragma midl_echo("HRESULT SetApplicationContext_WinRTBinder(IApplicationContext * pAppCtx, IBindContext * pWinRTBinder);")
-
-// Used by InstallNativeImage() to extract dependency names from the NI's CORCOMPILE_DEPENDENCY_INFO records.
-#pragma midl_echo("STDAPI FusionGetAssemblyNameRefFromMDImport(IMetaDataAssemblyImport *pMDImport, /* This is really an mdAssemblyRef */ DWORD mdar, DWORD dwFlags, IAssemblyName **ppName);")
-
-#endif //!FEATURE_CORECLR
diff --git a/src/inc/fusionsink.h b/src/inc/fusionsink.h
deleted file mode 100644
index adf88d4cd4..0000000000
--- a/src/inc/fusionsink.h
+++ /dev/null
@@ -1,129 +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.
-
-
-
-/*============================================================
-**
-** Header:  FusionSink.hpp
-**
-** Purpose: Implements FusionSink
-**
-**
-===========================================================*/
-#ifndef _FUSIONSINK_H
-#define _FUSIONSINK_H
-
-#include <fusion.h>
-#include <fusionpriv.h>
-#include "corhlpr.h"
-#include "corpriv.h"
-
-class FusionSink : public IAssemblyBindSink, public INativeImageEvaluate
-{
-public:
-    
-    FusionSink() :
-        m_punk(NULL),
-        m_pNIunk(NULL),
-        m_pAbortUnk(NULL),
-        m_pFusionLog(NULL),
-        m_cRef(1),
-        m_hEvent(NULL),
-        m_LastResult(S_OK)
-    {
-        WRAPPER_NO_CONTRACT;
-    }
-
-    virtual void Reset()
-    {
-        CONTRACTL
-        {
-            INSTANCE_CHECK;
-            NOTHROW;
-        }
-        CONTRACTL_END;
-
-        if(m_pAbortUnk) {
-            m_pAbortUnk->Release();
-            m_pAbortUnk = NULL;
-        }
-
-        if(m_punk) {
-            m_punk->Release();
-            m_punk = NULL;
-        }
-
-        if(m_pNIunk) {
-            m_pNIunk->Release();
-            m_pNIunk = NULL;
-        }
-        
-        if(m_pFusionLog) {
-            m_pFusionLog->Release();
-            m_pFusionLog = NULL;
-        }
-
-        m_LastResult = S_OK;
-    }
-
-    ~FusionSink()
-    {
-        CONTRACTL
-        {
-            DESTRUCTOR_CHECK;
-            NOTHROW;
-        }
-        CONTRACTL_END;
- 
-        if(m_hEvent) {
-            delete m_hEvent;
-            m_hEvent = NULL;
-        }
-
-        Reset();
-    }
-
-    HRESULT AssemblyResetEvent();
-    HRESULT LastResult()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return m_LastResult;
-    }
-
-    STDMETHODIMP QueryInterface(REFIID riid, void **ppInterface);
-    ULONG STDMETHODCALLTYPE AddRef(void); 
-    ULONG STDMETHODCALLTYPE Release(void);
-    
-    STDMETHODIMP OnProgress(DWORD dwNotification,
-                            HRESULT hrNotification,
-                            LPCWSTR szNotification,
-                            DWORD dwProgress,
-                            DWORD dwProgressMax,
-                            LPVOID pvBindInfo,
-                            IUnknown* punk);
-
-    // Wait on the event.
-    virtual HRESULT Wait();
-
-    STDMETHODIMP Evaluate(
-        IAssembly *pILAssembly, 
-        IAssembly *pNativeAssembly,
-        BYTE * pbCachedData,
-        DWORD dwDataSize);
-    
-    IUnknown*    m_punk;      // Getting an assembly
-    IUnknown*    m_pNIunk;      // Getting an assembly    
-    IUnknown*    m_pAbortUnk; // pUnk for aborting a bind
-    IFusionBindLog *m_pFusionLog;
-
-protected:
-    HRESULT AssemblyCreateEvent();
-
-    LONG        m_cRef;    // Ref count.
-    Event      *m_hEvent;  // Event to block thread.
-    HRESULT     m_LastResult; // Last notification result
-};
-
-#endif  // _FUSIONSINK_H
diff --git a/src/inc/holder.h b/src/inc/holder.h
index a4d19bbf92..a92eeabaab 100644
--- a/src/inc/holder.h
+++ b/src/inc/holder.h
@@ -65,12 +65,6 @@
 
 #ifdef _DEBUG
 
-#ifdef FEATURE_FUSION
-namespace NATIVE_BINDER_SPACE
-{
-    class NativeAssembly;
-}
-#endif //FEATURE_FUSION
 
 //------------------------------------------------------------------------------------------------
 // This is used to make Visual Studio autoexp.dat work sensibly with holders again.
@@ -95,26 +89,11 @@ struct AutoExpVisibleValue
     union
     {
         // Only include a class name here if it is customarily referred to through an abstract interface.
-#ifdef FEATURE_FUSION
-        const class CAssemblyName                           *_asCAssemblyName;
-        const class CAssembly                               *_asCAssembly;
-        const class CAssemblyManifestImport                 *_asCAssemblyManifestImport;
-        const class CAssemblyModuleImport                   *_asCAssemblyModuleImport;
-        const class CHostAssembly                           *_asCHostAssembly;
-        const class CHostAssemblyModuleImport               *_asCHostAssemblyModuleImport;
-        const class BindResult                              *_asBindResult;
-        const class BindContext                             *_asBindContext;
-        const class NATIVE_BINDER_SPACE::NativeAssembly     *_asNativeAssembly;
-        const class AssemblyLocation                        *_asAssemblyLocation;
-#endif //FEATURE_FUSION
 
 #if defined(FEATURE_APPX)
         const class AppXBindResultImpl                      *_asAppXBindResultImpl;
 #endif
 
-#ifndef FEATURE_CORECLR
-        const class PEFingerprint                           *_asPEFingerprint;
-#endif //!FEATURE_CORECLR
         const void                                          *_pPreventEmptyUnion;
     };
 };
@@ -1214,16 +1193,6 @@ FORCEINLINE void VoidDeleteFile(LPCWSTR wszFilePath) { WszDeleteFile(wszFilePath
 typedef Wrapper<LPCWSTR, DoNothing<LPCWSTR>, VoidDeleteFile, NULL> DeleteFileHolder;
 #endif // WszDeleteFile
 
-#if !defined(FEATURE_CORECLR) || defined(FEATURE_CRYPTO)
-// Crypto holders
-FORCEINLINE void VoidCryptReleaseContext(HCRYPTPROV h) { CryptReleaseContext(h, 0); }
-FORCEINLINE void VoidCryptDestroyHash(HCRYPTHASH h) { CryptDestroyHash(h); }
-FORCEINLINE void VoidCryptDestroyKey(HCRYPTKEY h) { CryptDestroyKey(h); }
-
-typedef Wrapper<HCRYPTPROV, DoNothing, VoidCryptReleaseContext, 0> HandleCSPHolder;
-typedef Wrapper<HCRYPTHASH, DoNothing, VoidCryptDestroyHash, 0> HandleHashHolder;
-typedef Wrapper<HCRYPTKEY, DoNothing, VoidCryptDestroyKey, 0> HandleKeyHolder;
-#endif // !FEATURE_CORECLR || FEATURE_CRYPTO
 
 //-----------------------------------------------------------------------------
 // Misc holders
diff --git a/src/inc/jithelpers.h b/src/inc/jithelpers.h
index 89d4be7efc..f84db9142d 100644
--- a/src/inc/jithelpers.h
+++ b/src/inc/jithelpers.h
@@ -135,8 +135,7 @@
     JITHELPER(CORINFO_HELP_FIELD_ACCESS_EXCEPTION,JIT_ThrowFieldAccessException, CORINFO_HELP_SIG_REG_ONLY)
     JITHELPER(CORINFO_HELP_CLASS_ACCESS_EXCEPTION,JIT_ThrowClassAccessException, CORINFO_HELP_SIG_REG_ONLY)
 
-// UNIXTODO: Disable JIT_EndCatch after revising the jitter not to use this (for x86/Linux)
-#ifndef _TARGET_X86_
+#ifdef WIN64EXCEPTIONS
     JITHELPER(CORINFO_HELP_ENDCATCH,            NULL,               CORINFO_HELP_SIG_CANNOT_USE_ALIGN_STUB)
 #else
     JITHELPER(CORINFO_HELP_ENDCATCH,            JIT_EndCatch,       CORINFO_HELP_SIG_CANNOT_USE_ALIGN_STUB)
diff --git a/src/inc/longfilepathwrappers.h b/src/inc/longfilepathwrappers.h
index a0ffe38da5..3bb9166990 100644
--- a/src/inc/longfilepathwrappers.h
+++ b/src/inc/longfilepathwrappers.h
@@ -152,120 +152,5 @@ DWORD WINAPI GetEnvironmentVariableWrapper(
 
 BOOL PAL_GetPALDirectoryWrapper(SString& pbuffer);
 
-#ifndef FEATURE_CORECLR
-//Temporarily providing direct OS Calls Till All of the Desktop CLR start using the above format
-inline DWORD
-SearchPathWrapper(
-    _In_opt_ LPCWSTR lpPath,
-    _In_ LPCWSTR lpFileName,
-    _In_opt_ LPCWSTR lpExtension,
-    _In_ BOOL getPath,
-    _Out_     LPWSTR  lpBuffer,
-    _Out_opt_ LPWSTR * lpFilePart
-    )
-{
-    return SearchPathW(
-        lpPath,
-        lpFileName,
-        lpExtension,
-        getPath,
-        lpBuffer,
-        lpFilePart
-        );
-}
-
-
-inline DWORD
-GetShortPathNameWrapper(
-    _In_ LPCWSTR lpszLongPath,
-    _Out_ LPWSTR  lpszShortPath,
-    _In_  DWORD   cchBuffer
-    )
-{
-    return GetShortPathNameW(
-        lpszLongPath,
-        lpszShortPath,
-        cchBuffer
-        );
-}
-
-inline DWORD
-GetLongPathNameWrapper(
-    _In_ LPCWSTR lpszShortPath,
-    _Out_ LPWSTR  lpszLongPath,
-    _In_  DWORD   cchBuffer
-    )
-{
-    return GetLongPathNameW(
-        lpszShortPath,
-        lpszLongPath,
-        cchBuffer
-        );
-}
-
-inline UINT GetTempFileNameWrapper(
-    _In_  LPCWSTR lpPathName,
-    _In_  LPCWSTR lpPrefixString,
-    _In_  UINT    uUnique,
-    _Out_ LPWSTR  lpTempFileName
-    )
-{
-    return GetTempFileNameW(
-        lpPathName,
-        lpPrefixString,
-        uUnique,
-        lpTempFileName
-        );
-}
-
-inline DWORD GetTempPathWrapper(
-    _In_  DWORD  nBufferLength,
-    _Out_ LPWSTR lpBuffer
-    )
-{
-    return GetTempPathW(
-        nBufferLength,
-        lpBuffer
-        );
-}
-
-inline DWORD GetCurrentDirectoryWrapper(
-    _In_  DWORD  nBufferLength,
-    _Out_ LPWSTR lpBuffer
-    )
-{
-    return GetCurrentDirectoryW(
-        nBufferLength,
-        lpBuffer
-        );
-}
-
-inline DWORD
-GetModuleFileNameWrapper(
-    _In_opt_ HMODULE hModule,
-    _Out_    LPWSTR  lpFilename,
-    _In_     DWORD   nSize
-    )
-{
-    return GetModuleFileNameW(
-        hModule,
-        lpFilename,
-        nSize
-        );
-}
-
-inline DWORD GetEnvironmentVariableWrapper(
-    _In_opt_  LPCWSTR lpName,
-    _Out_opt_ LPWSTR  lpBuffer,
-    _In_      DWORD   nSize
-    )
-{
-    return GetEnvironmentVariableW(
-       lpName,
-       lpBuffer,
-       nSize
-        );
-}
-#endif //FEATURE_CORECLR
 #endif //_WIN_PATH_APIS_WRAPPER_
 
diff --git a/src/inc/metadatatracker.h b/src/inc/metadatatracker.h
index 93ecaab983..00aa56afae 100644
--- a/src/inc/metadatatracker.h
+++ b/src/inc/metadatatracker.h
@@ -5,7 +5,7 @@
 #ifndef _METADATATRACKER_H_
 #define _METADATATRACKER_H_
 
-#if defined(FEATURE_PREJIT) && (!defined(FEATURE_CORECLR) || defined(FEATURE_WINDOWSPHONE))
+#if defined(FEATURE_PREJIT) && defined(FEATURE_WINDOWSPHONE)
 
 #define METADATATRACKER_DATA 1
 #if !defined(DACCESS_COMPILE)
diff --git a/src/inc/palclr.h b/src/inc/palclr.h
index 85c802f65b..9b78578732 100644
--- a/src/inc/palclr.h
+++ b/src/inc/palclr.h
@@ -617,6 +617,8 @@
 #define MAX_PATH_FNAME   MAX_PATH /* max. length of full pathname */
 #endif
 
+#define __clr_reserved __reserved
+
 #endif // __PALCLR_H__
 
 #include "palclr_win.h"
diff --git a/src/inc/palclr_win.h b/src/inc/palclr_win.h
index 18edc6c8f5..372f467cbd 100644
--- a/src/inc/palclr_win.h
+++ b/src/inc/palclr_win.h
@@ -83,67 +83,6 @@
 // WIN_PAL_ENDTRY
 //
 
-#if !defined(FEATURE_CORECLR)
-
-#include "staticcontract.h"
-
-#define WIN_PAL_TRY_NAKED                                                       \
-    {                                                                           \
-        bool __exHandled; __exHandled = false;                                  \
-        DWORD __exCode; __exCode = 0;                                           \
-        __try                                                                   \
-        {
-
-#define WIN_PAL_TRY                                                             \
-    {                                                                           \
-        WIN_PAL_TRY_NAKED                                                       \
-        WIN_PAL_TRY_HANDLER_DBG_BEGIN
-
-#define WIN_PAL_TRY_FOR_DLLMAIN(_reason)                                        \
-    {                                                                           \
-        WIN_PAL_TRY_NAKED                                                       \
-        WIN_PAL_TRY_HANDLER_DBG_BEGIN_DLLMAIN(_reason)
-
-// Note: PAL_SEH_RESTORE_GUARD_PAGE is only ever defined in clrex.h, so we only restore guard pages automatically
-// when these macros are used from within the VM.
-#define WIN_PAL_SEH_RESTORE_GUARD_PAGE PAL_SEH_RESTORE_GUARD_PAGE
- 
-#define WIN_PAL_EXCEPT_NAKED(Disposition)                                       \
-    } __except(__exCode = GetExceptionCode(), Disposition) {                    \
-        __exHandled = true;                                                     \
-        WIN_PAL_SEH_RESTORE_GUARD_PAGE
-
-#define WIN_PAL_EXCEPT(Disposition)                                             \
-        WIN_PAL_TRY_HANDLER_DBG_END                                             \
-        WIN_PAL_EXCEPT_NAKED(Disposition)
-
-#define WIN_PAL_EXCEPT_FILTER_NAKED(pfnFilter, pvFilterParameter)                                       \
-    } __except(__exCode = GetExceptionCode(), pfnFilter(GetExceptionInformation(), pvFilterParameter)) {  \
-        __exHandled = true;                                                     \
-        WIN_PAL_SEH_RESTORE_GUARD_PAGE
-
-#define WIN_PAL_EXCEPT_FILTER(pfnFilter, pvFilterParameter)                     \
-        WIN_PAL_TRY_HANDLER_DBG_END                                             \
-        WIN_PAL_EXCEPT_FILTER_NAKED(pfnFilter, pvFilterParameter)
-
-#define WIN_PAL_FINALLY_NAKED                                                   \
-    } __finally {                                                               \
-
-#define WIN_PAL_FINALLY                                                             \
-        WIN_PAL_TRY_HANDLER_DBG_END                                             \
-        WIN_PAL_FINALLY_NAKED
-
-#define WIN_PAL_ENDTRY_NAKED                                                    \
-        }                                                                       \
-    }                                                                           \
-
-#define WIN_PAL_ENDTRY                                                          \
-            }                                                                   \
-            WIN_PAL_ENDTRY_NAKED_DBG                                            \
-        }                                                                       \
-    }
-
-#endif // !PAL_WIN_SEH
 
 
 #if defined(_DEBUG_IMPL) && !defined(JIT_BUILD) && !defined(JIT64_BUILD) && !defined(_ARM_) // @ARMTODO
diff --git a/src/inc/regdisp.h b/src/inc/regdisp.h
index 1b09ca0085..d08c44c904 100644
--- a/src/inc/regdisp.h
+++ b/src/inc/regdisp.h
@@ -8,24 +8,20 @@
 
 #ifdef DEBUG_REGDISPLAY
 class Thread;
-
+struct REGDISPLAY;
 void CheckRegDisplaySP (REGDISPLAY *pRD);
 #endif // DEBUG_REGDISPLAY
 
+struct REGDISPLAY_BASE {
+    PT_CONTEXT pContext;    // This is the context of the active call frame;
+                            // either returned by GetContext or provided at
+                            // exception time.
+                            //
+                            // This will be used to resume execution, so
+                            // do NOT trash it! But DO update any static
+                            // registers here.
 
-#if defined(_TARGET_X86_)
-
-struct REGDISPLAY {
-    PCONTEXT pContext;    // points to current Context; either
-                          // returned by GetContext or provided
-                          // at exception time.
-
-#ifndef WIN64EXCEPTIONS
-    // TODO: Unify with pCurrentContext / pCallerContext used on 64-bit
-    PCONTEXT pContextForUnwind; // scratch context for unwinding
-                                // used to preserve context saved in the frame that 
-                                // could be otherwise wiped by the unwinding
-#else // !WIN64EXCEPTIONS
+#ifdef WIN64EXCEPTIONS
     PT_CONTEXT pCurrentContext;   // [trashed] points to current Context of stackwalk
     PT_CONTEXT pCallerContext;    // [trashed] points to the Context of the caller during stackwalk -- used for GC crawls
 
@@ -42,12 +38,43 @@ struct REGDISPLAY {
 
     T_KNONVOLATILE_CONTEXT_POINTERS ctxPtrsOne;  // used by stackwalk
     T_KNONVOLATILE_CONTEXT_POINTERS ctxPtrsTwo;  // used by stackwalk
-#endif // !WIN64EXCEPTIONS
+#endif // WIN64EXCEPTIONS
 
 #ifdef DEBUG_REGDISPLAY
     Thread *_pThread;
 #endif // DEBUG_REGDISPLAY
 
+    TADDR SP;
+    TADDR ControlPC;
+};
+
+inline PCODE GetControlPC(REGDISPLAY_BASE *pRD) {
+    LIMITED_METHOD_DAC_CONTRACT;
+    return (PCODE)(pRD->ControlPC);
+}
+
+inline TADDR GetRegdisplaySP(REGDISPLAY_BASE *pRD) {
+    LIMITED_METHOD_DAC_CONTRACT;
+
+    return pRD->SP;
+}
+
+inline void SetRegdisplaySP(REGDISPLAY_BASE *pRD, LPVOID sp) {
+    LIMITED_METHOD_DAC_CONTRACT;
+
+    pRD->SP = (TADDR)sp;
+}
+
+#if defined(_TARGET_X86_)
+
+struct REGDISPLAY : public REGDISPLAY_BASE {
+
+#ifndef WIN64EXCEPTIONS
+    // TODO: Unify with pCurrentContext / pCallerContext used on 64-bit
+    PCONTEXT pContextForUnwind; // scratch context for unwinding
+                                // used to preserve context saved in the frame that
+                                // could be otherwise wiped by the unwinding
+
     DWORD * pEdi;
     DWORD * pEsi;
     DWORD * pEbx;
@@ -56,52 +83,68 @@ struct REGDISPLAY {
     DWORD * pEax;
 
     DWORD * pEbp;
-    DWORD   SP;                // Stack Pointer
-    PCODE   ControlPC;
-    TADDR   PCTAddr;
+#endif // !WIN64EXCEPTIONS
 
-};
+#ifndef WIN64EXCEPTIONS
 
-inline TADDR GetRegdisplaySP(REGDISPLAY *display) {
-    LIMITED_METHOD_DAC_CONTRACT;
+#define REG_METHODS(reg) \
+    inline PDWORD Get##reg##Location(void) { return p##reg;  } \
+    inline void   Set##reg##Location(PDWORD p##reg) { this->p##reg = p##reg; }
 
-    return (TADDR)display->SP;
-}
+#else // !WIN64EXCEPTIONS
 
-inline void SetRegdisplaySP(REGDISPLAY *display, LPVOID sp ) {
-    LIMITED_METHOD_DAC_CONTRACT;
+#define REG_METHODS(reg) \
+    inline PDWORD Get##reg##Location(void) { return pCurrentContextPointers->reg; } \
+    inline void   Set##reg##Location(PDWORD p##reg) { pCurrentContextPointers->reg = p##reg; }
 
-    (display->SP) = (DWORD)(size_t)sp;
-}
+#endif // WIN64EXCEPTIONS
+
+    REG_METHODS(Eax)
+    REG_METHODS(Ecx)
+    REG_METHODS(Edx)
+
+    REG_METHODS(Ebx)
+    REG_METHODS(Esi)
+    REG_METHODS(Edi)
+    REG_METHODS(Ebp)
+
+#undef REG_METHODS
+
+    TADDR   PCTAddr;
+};
 
 inline TADDR GetRegdisplayFP(REGDISPLAY *display) {
     LIMITED_METHOD_DAC_CONTRACT;
 
-    return (TADDR)*(display->pEbp);
+    return (TADDR)*display->GetEbpLocation();
 }
 
 inline LPVOID GetRegdisplayFPAddress(REGDISPLAY *display) {
     LIMITED_METHOD_CONTRACT;
     
-    return (LPVOID)display->pEbp;
+    return (LPVOID)display->GetEbpLocation();
 }
 
-inline PCODE GetControlPC(REGDISPLAY *display) {
-    LIMITED_METHOD_DAC_CONTRACT;
-
-    return display->ControlPC;
-}
 
 // This function tells us if the given stack pointer is in one of the frames of the functions called by the given frame
 inline BOOL IsInCalleesFrames(REGDISPLAY *display, LPVOID stackPointer) {
     LIMITED_METHOD_CONTRACT;
 
+#ifdef WIN64EXCEPTIONS
+    return stackPointer < ((LPVOID)(display->SP));
+#else
     return (TADDR)stackPointer < display->PCTAddr;
+#endif
 }
 inline TADDR GetRegdisplayStackMark(REGDISPLAY *display) {
     LIMITED_METHOD_DAC_CONTRACT;
 
+#ifdef WIN64EXCEPTIONS
+    _ASSERTE(GetRegdisplaySP(display) == GetSP(display->pCurrentContext));
+    return GetRegdisplaySP(display);
+#else
     return display->PCTAddr;
+#endif
 }
 
 #elif defined(_WIN64)
@@ -135,42 +178,18 @@ typedef struct _Arm64VolatileContextPointer
     };
 } Arm64VolatileContextPointer;
 #endif //_TARGET_ARM64_
-struct REGDISPLAY {
-    PT_CONTEXT pContext;          // This is the context of the active call frame.  This
-                                // will be used to resume execution, so do not use trash it!
-                                // But DO update any static registers here.
-
-    PT_CONTEXT pCurrentContext;   // [trashed] points to current Context of stackwalk
-    PT_CONTEXT pCallerContext;    // [trashed] points to the Context of the caller during stackwalk -- used for GC crawls
-
-    size_t  ControlPC;
-
-    size_t  SP;
-
-    T_KNONVOLATILE_CONTEXT_POINTERS *pCurrentContextPointers;  // [trashed] points to current context pointers of stackwalk
-    T_KNONVOLATILE_CONTEXT_POINTERS *pCallerContextPointers;   // [trashed] points to the context pointers of the caller during stackwalk -- used for GC crawls
+struct REGDISPLAY : public REGDISPLAY_BASE {
 #ifdef _TARGET_ARM64_
     Arm64VolatileContextPointer     volatileCurrContextPointers;
 #endif
 
-    BOOL IsCallerContextValid;  // TRUE if pCallerContext really contains the caller's context
-    BOOL IsCallerSPValid;       // Don't add usage of this field.  This is only temporary.
-
-    T_CONTEXT  ctxOne;    // used by stackwalk
-    T_CONTEXT  ctxTwo;    // used by stackwalk
-
-    T_KNONVOLATILE_CONTEXT_POINTERS ctxPtrsOne;  // used by stackwalk
-    T_KNONVOLATILE_CONTEXT_POINTERS ctxPtrsTwo;  // used by stackwalk
-
-#ifdef DEBUG_REGDISPLAY
-    Thread *_pThread;
-#endif // DEBUG_REGDISPLAY
+    REGDISPLAY()
+    {
+        // Initialize
+        memset(this, 0, sizeof(REGDISPLAY));
+    }
 };
 
-inline TADDR GetRegdisplaySP(REGDISPLAY *display) {
-    LIMITED_METHOD_DAC_CONTRACT;
-    return (TADDR)display->SP;
-}
 
 inline TADDR GetRegdisplayFP(REGDISPLAY *display) {
     LIMITED_METHOD_CONTRACT;
@@ -182,13 +201,6 @@ inline TADDR GetRegdisplayFPAddress(REGDISPLAY *display) {
     return NULL; 
 }
 
-inline PCODE GetControlPC(REGDISPLAY *display) {
-    LIMITED_METHOD_DAC_CONTRACT;
-    return (PCODE)(display->ControlPC);
-}
-
-
-
 // This function tells us if the given stack pointer is in one of the frames of the functions called by the given frame
 inline BOOL IsInCalleesFrames(REGDISPLAY *display, LPVOID stackPointer)
 {
@@ -214,7 +226,6 @@ inline TADDR GetRegdisplayStackMark(REGDISPLAY *display)
 #endif // _TARGET_AMD64_
 }
 
-
 #elif defined(_TARGET_ARM_)
 
 // ResumableFrame is pushed on the stack before
@@ -235,31 +246,11 @@ typedef struct _ArmVolatileContextPointer
     PDWORD R12;
 } ArmVolatileContextPointer;
 
-struct REGDISPLAY {
-    PT_CONTEXT pContext;          // points to current Context; either
-                                // returned by GetContext or provided
-                                // at exception time.
-
-    PT_CONTEXT pCurrentContext;   // [trashed] points to current Context of stackwalk
-    PT_CONTEXT pCallerContext;    // [trashed] points to the Context of the caller during stackwalk -- used for GC crawls
-
-    T_KNONVOLATILE_CONTEXT_POINTERS ctxPtrsOne;  // used by stackwalk
-    T_KNONVOLATILE_CONTEXT_POINTERS ctxPtrsTwo;  // used by stackwalk
-
-    PT_KNONVOLATILE_CONTEXT_POINTERS pCurrentContextPointers;
-    PT_KNONVOLATILE_CONTEXT_POINTERS pCallerContextPointers;
+struct REGDISPLAY : public REGDISPLAY_BASE {
     ArmVolatileContextPointer     volatileCurrContextPointers;
 
-    BOOL IsCallerContextValid;  // TRUE if pCallerContext really contains the caller's context
-    BOOL IsCallerSPValid;       // Don't add usage of this field.  This is only temporary.
-
-    DWORD     SP;
-    DWORD     ControlPC; 
     DWORD *  pPC;                // processor neutral name
 
-    T_CONTEXT  ctxOne;    // used by stackwalk
-    T_CONTEXT  ctxTwo;    // used in ExceptionTracker::InitializeCrawlFrame
-
     REGDISPLAY()
     {
         // Initialize regdisplay
@@ -268,24 +259,8 @@ struct REGDISPLAY {
         // Setup the pointer to ControlPC field
         pPC = &ControlPC;
     }
-
-#ifdef DEBUG_REGDISPLAY
-    Thread *_pThread;
-#endif // DEBUG_REGDISPLAY
-
 };
 
-inline TADDR GetRegdisplaySP(REGDISPLAY *display) {
-    LIMITED_METHOD_DAC_CONTRACT;
-    return (TADDR)(size_t)display->SP;
-}
-
-inline PCODE GetControlPC(REGDISPLAY *display) {
-    LIMITED_METHOD_DAC_CONTRACT;
-    return (PCODE)(display->ControlPC);
-}
-
-
 // This function tells us if the given stack pointer is in one of the frames of the functions called by the given frame
 inline BOOL IsInCalleesFrames(REGDISPLAY *display, LPVOID stackPointer) {
     LIMITED_METHOD_CONTRACT;
@@ -299,29 +274,15 @@ inline TADDR GetRegdisplayStackMark(REGDISPLAY *display) {
     return GetSP(display->pCallerContext);
 }
 
-
-
 #else // none of the above processors
 
 PORTABILITY_WARNING("RegDisplay functions are not implemented on this platform.")
 
-struct REGDISPLAY {
-    PCONTEXT pContext;          // points to current Context
-    size_t   SP;
+struct REGDISPLAY : public REGDISPLAY_BASE {
     size_t * FramePtr;
     SLOT   * pPC;
 };
 
-inline PCODE GetControlPC(REGDISPLAY *display) {
-    LIMITED_METHOD_CONTRACT;
-    return (PCODE) NULL;
-}
-
-inline LPVOID GetRegdisplaySP(REGDISPLAY *display) {
-    LIMITED_METHOD_DAC_CONTRACT;
-    return (LPVOID)display->SP;
-}
-
 inline TADDR GetRegdisplayFP(REGDISPLAY *display) {
     LIMITED_METHOD_CONTRACT;
     return (TADDR)*(display->FramePtr);
@@ -410,32 +371,6 @@ inline void FillRegDisplay(const PREGDISPLAY pRD, PT_CONTEXT pctx, PT_CONTEXT pC
 
 #else // !WIN64EXCEPTIONS
     pRD->pContext   = pctx;
-#ifdef _TARGET_AMD64_
-    for (int i = 0; i < 16; i++)
-    {
-        *(&pRD->ctxPtrsOne.Rax + i) = (&pctx->Rax + i);
-    }
-#elif defined(_TARGET_ARM64_) // _TARGET_AMD64_
-    for (int i = 0; i < 12; i++)
-    {
-        *(&pRD->ctxPtrsOne.X19 + i) = (&pctx->X19 + i);
-    }
-#elif defined(_TARGET_ARM_) // _TARGET_ARM64_
-    // Copy over the nonvolatile integer registers (R4-R11)
-    for (int i = 0; i < 8; i++)
-    {
-        *(&pRD->ctxPtrsOne.R4 + i) = (&pctx->R4 + i);
-    }
-
-    pRD->ctxPtrsOne.Lr = &pctx->Lr;
-#elif defined(_TARGET_X86_) // _TARGET_ARM_
-    for (int i = 0; i < 4; ++i)
-    {
-        *(&pRD->ctxPtrsOne.Ebx + i) = (&pctx->Ebx + i);
-    }
-#else // _TARGET_X86_
-    PORTABILITY_ASSERT("FillRegDisplay");
-#endif // _TARGET_???_ (ELSE)
 
     // Setup the references
     pRD->pCurrentContextPointers = &pRD->ctxPtrsOne;
@@ -446,7 +381,7 @@ inline void FillRegDisplay(const PREGDISPLAY pRD, PT_CONTEXT pctx, PT_CONTEXT pC
 
     // copy the active context to initialize our stackwalk
     *(pRD->pCurrentContext)     = *(pctx);
-    
+
     // copy the caller context as well if it's specified
     if (pCallerCtx == NULL)
     {
@@ -460,9 +395,33 @@ inline void FillRegDisplay(const PREGDISPLAY pRD, PT_CONTEXT pctx, PT_CONTEXT pC
         pRD->IsCallerSPValid      = TRUE;        // Don't add usage of this field.  This is only temporary.
     }
 
-#ifdef _TARGET_ARM_
+#ifdef _TARGET_AMD64_
+    for (int i = 0; i < 16; i++)
+    {
+        *(&pRD->ctxPtrsOne.Rax + i) = (&pctx->Rax + i);
+    }
+#elif defined(_TARGET_ARM64_) // _TARGET_AMD64_
+    for (int i = 0; i < 12; i++)
+    {
+        *(&pRD->ctxPtrsOne.X19 + i) = (&pctx->X19 + i);
+    }
+#elif defined(_TARGET_ARM_) // _TARGET_ARM64_
+    // Copy over the nonvolatile integer registers (R4-R11)
+    for (int i = 0; i < 8; i++)
+    {
+        *(&pRD->ctxPtrsOne.R4 + i) = (&pctx->R4 + i);
+    }
+
+    pRD->ctxPtrsOne.Lr = &pctx->Lr;
     pRD->pPC = &pRD->pCurrentContext->Pc;
-#endif
+#elif defined(_TARGET_X86_) // _TARGET_ARM_
+    for (int i = 0; i < 7; i++)
+    {
+        *(&pRD->ctxPtrsOne.Esi + i) = (&pctx->Esi + i);
+    }
+#else // _TARGET_X86_
+    PORTABILITY_ASSERT("FillRegDisplay");
+#endif // _TARGET_???_ (ELSE)
 
 #ifdef DEBUG_REGDISPLAY
     pRD->_pThread = NULL;
diff --git a/src/inc/registrywrapper.h b/src/inc/registrywrapper.h
index bd6afe190b..6b284506bb 100644
--- a/src/inc/registrywrapper.h
+++ b/src/inc/registrywrapper.h
@@ -11,38 +11,10 @@
 #ifndef __REGISTRYWRAPPER_H
 #define __REGISTRYWRAPPER_H
 
-#if !defined(FEATURE_UTILCODE_NO_DEPENDENCIES) && !defined(FEATURE_CORECLR)
-
-// Registry API wrappers
-
-LONG ClrRegCreateKeyEx(
-        HKEY hKey,
-        LPCWSTR lpSubKey,
-        DWORD Reserved,
-        __in_opt LPWSTR lpClass,
-        DWORD dwOptions,
-        REGSAM samDesired,
-        LPSECURITY_ATTRIBUTES lpSecurityAttributes,
-        PHKEY phkResult,
-        LPDWORD lpdwDisposition
-        );
-
-LONG ClrRegOpenKeyEx(
-        HKEY hKey,
-        LPCWSTR lpSubKey,
-        DWORD ulOptions,
-        REGSAM samDesired,
-        PHKEY phkResult
-        );
-
-bool IsNgenOffline();
-
-#else
 
 #define ClrRegCreateKeyEx RegCreateKeyExW
 #define ClrRegOpenKeyEx RegOpenKeyExW
 #define IsNgenOffline() false
 
-#endif
 
 #endif // __REGISTRYWRAPPER_H
diff --git a/src/inc/shimload.h b/src/inc/shimload.h
index 9a6ab7de6f..a2651d1aff 100644
--- a/src/inc/shimload.h
+++ b/src/inc/shimload.h
@@ -14,17 +14,6 @@
 #ifndef _SHIMLOAD_H
 #define _SHIMLOAD_H
 
-#ifndef FEATURE_CORECLR
-#include <delayimp.h>
-
-extern FARPROC __stdcall ShimDelayLoadHook(unsigned        dliNotify,          // What event has occurred, dli* flag.
-                                           DelayLoadInfo   *pdli);             // Description of the event.
-
-//and one for safe mode
-extern FARPROC __stdcall ShimSafeModeDelayLoadHook(unsigned        dliNotify,          // What event has occurred, dli* flag.
-                                           DelayLoadInfo   *pdli);             // Description of the event.
-
-#endif
 
 //*****************************************************************************
 // Sets/Gets the directory based on the location of the module. This routine
diff --git a/src/inc/sortversioning.h b/src/inc/sortversioning.h
index fe3e878802..0af8095b81 100644
--- a/src/inc/sortversioning.h
+++ b/src/inc/sortversioning.h
@@ -32,8 +32,9 @@ namespace SortVersioning
         __in int cchSrc,
         __out_bcount_opt(cbDest) LPBYTE pDest,
         __in int cbDest,
-        __reserved LPVOID lpReserved,
-        __reserved LPARAM lParam);
+
+        __clr_reserved LPVOID lpReserved,
+        __clr_reserved LPARAM lParam);
 
     typedef int (*SORTCHANGECASE) (
         __in PSORTHANDLE pSortHandle,
@@ -42,8 +43,8 @@ namespace SortVersioning
         __in int cchSrc,
         __out_ecount_opt(cchDest) LPWSTR pDest,
         __in int cchDest,
-        __reserved LPVOID lpReserved,
-        __reserved LPARAM lParam);
+        __clr_reserved LPVOID lpReserved,
+        __clr_reserved LPARAM lParam);
 
     typedef int (*SORTCOMPARESTRING) (
         __in PSORTHANDLE pSortHandle,
@@ -52,8 +53,8 @@ namespace SortVersioning
         __in int cchCount1,
         __in LPCWSTR lpString2,
         __in int cchCount2,
-        __reserved LPVOID lpReserved,
-        __reserved LPARAM lParam);
+        __clr_reserved LPVOID lpReserved,
+        __clr_reserved LPARAM lParam);
 
     typedef int (*SORTFINDSTRING) (
         __in                    PSORTHANDLE pSortHandle,
@@ -63,8 +64,8 @@ namespace SortVersioning
         __in_ecount(cchValue)   LPCWSTR lpStringValue,
         __in                    int cchValue,
         __out_opt               LPINT pcchFound,
-        __reserved              LPVOID lpReserved,
-        __reserved              LPARAM lParam);
+        __clr_reserved          LPVOID lpReserved,
+        __clr_reserved          LPARAM lParam);
 
     typedef BOOL (*SORTISDEFINEDSTRING) (
         __in                PSORTHANDLE     pSortHandle,
@@ -78,8 +79,8 @@ namespace SortVersioning
         __in DWORD dwFlags,
         __in_ecount(cchSrc) LPCWSTR pSrc,
         __in int cchSrc,
-        __reserved LPVOID lpReserved,
-        __reserved LPARAM lParam);
+        __clr_reserved LPVOID lpReserved,
+        __clr_reserved LPARAM lParam);
 
 #define SORT_NAME_SIZE 85
 
@@ -114,8 +115,8 @@ namespace SortVersioning
                                __in_ecount(cchCount2) LPCWSTR lpString2,
                                __in int cchCount2,
                                __in_opt CONST NLSVERSIONINFO * lpVersionInformation,
-                               __reserved LPVOID lpReserved,
-                               __reserved LPARAM lParam );
+                               __clr_reserved LPVOID lpReserved,
+                               __clr_reserved LPARAM lParam );
     __success(return != 0) int WINAPI SortDllCompareString(
         __in PSORTHANDLE pSort,
         __in DWORD dwCmpFlags,
@@ -134,8 +135,8 @@ namespace SortVersioning
                            __out_ecount_opt(cchDest)  LPWSTR lpDestStr, // really this should be __out_awcount_opt(dwMapFlags & LCMAP_SORTKEY, cchDest)
                            __in int cchDest,
                            __in_opt CONST NLSVERSIONINFO * lpVersionInformation,
-                           __reserved LPVOID lpReserved,
-                           __reserved LPARAM lParam );    
+                           __clr_reserved LPVOID lpReserved,
+                           __clr_reserved LPARAM lParam );    
 
    __success(return != 0) int WINAPI SortDllChangeCase(
         __in PSORTHANDLE pSort,
@@ -165,8 +166,8 @@ namespace SortVersioning
                         __in int cchValue,
                         __out_opt LPINT pcchFound,
                         __in_opt CONST NLSVERSIONINFO * lpVersionInformation,
-                        __reserved LPVOID lpReserved,
-                        __reserved LPARAM lParam);
+                        __clr_reserved LPVOID lpReserved,
+                        __clr_reserved LPARAM lParam);
 
     __success(return != 0) int WINAPI SortDllFindString(
         __in PSORTHANDLE pSort,
diff --git a/src/inc/stacktrace.h b/src/inc/stacktrace.h
index 49e951780c..9152116d39 100644
--- a/src/inc/stacktrace.h
+++ b/src/inc/stacktrace.h
@@ -74,7 +74,7 @@ void GetStringFromStackLevels(UINT ifrStart, UINT cfrTotal, __out_ecount(cchMaxA
 ******************************************************************** robch */
 void GetStringFromAddr(DWORD_PTR dwAddr, __out_ecount(cchMaxAssertStackLevelStringLen) LPSTR szString);
 
-#if defined(_TARGET_X86_) && defined(FEATURE_CORECLR) && !defined(FEATURE_PAL)
+#if defined(_TARGET_X86_) && !defined(FEATURE_PAL)
 /****************************************************************************
 * ClrCaptureContext *
 *-------------------*
@@ -83,9 +83,9 @@ void GetStringFromAddr(DWORD_PTR dwAddr, __out_ecount(cchMaxAssertStackLevelStri
 *       support this, so we need it for CoreCLR 4, if we require Win2K support
 ****************************************************************************/
 extern "C" void __stdcall ClrCaptureContext(__out PCONTEXT ctx);
-#else // _TARGET_X86_ && FEATURE_CORECLR && !FEATURE_PAL
+#else // _TARGET_X86_ && !FEATURE_PAL
 #define ClrCaptureContext RtlCaptureContext
-#endif // _TARGET_X86_ && FEATURE_CORECLR && !FEATURE_PAL
+#endif // _TARGET_X86_ && !FEATURE_PAL
 
 
 #endif
diff --git a/src/inc/stdmacros.h b/src/inc/stdmacros.h
index ab77a2cd91..3ec8bec6f3 100644
--- a/src/inc/stdmacros.h
+++ b/src/inc/stdmacros.h
@@ -277,7 +277,7 @@ inline ULONG RoundUpToPower2(ULONG x)
 
 
 #define DBG_GET_CLASS_NAME(pMT)        \
-        (pMT)->GetClass()->GetDebugClassName()
+        (((pMT) == NULL)  ? NULL : (pMT)->GetClass()->GetDebugClassName())
 
 #define DBG_CLASS_NAME_MT(pMT)         \
         (DBG_GET_CLASS_NAME(pMT) == NULL) ? "<null-class>" : DBG_GET_CLASS_NAME(pMT) 
diff --git a/src/inc/switches.h b/src/inc/switches.h
index bb3ca28e12..bb303876e8 100644
--- a/src/inc/switches.h
+++ b/src/inc/switches.h
@@ -10,9 +10,6 @@
 #define STRESS_HEAP
 #endif
 
-#if !defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)
-#define STRESS_THREAD
-#endif
 
 #define VERIFY_HEAP
 
@@ -67,9 +64,6 @@
 #define GC_STATS
 #endif
 
-#if !defined(FEATURE_CORECLR)
-#define EMIT_FIXUPS
-#endif
 
 #if defined(_DEBUG) && !defined(DACCESS_COMPILE) && (defined(_TARGET_X86_) || defined(_TARGET_AMD64_))
 // On x86/x64 Windows debug builds, respect the COMPlus_EnforceEEThreadNotRequiredContracts
@@ -110,16 +104,12 @@
 // ALLOW_SXS_JIT_NGEN enables AltJit support for NGEN, via COMPlus_AltJitNgen / COMPlus_AltJitName.
 // Note that if ALLOW_SXS_JIT_NGEN is defined, then ALLOW_SXS_JIT must be defined.
 #define ALLOW_SXS_JIT
-#if defined(ALLOW_SXS_JIT)
 #define ALLOW_SXS_JIT_NGEN
-#endif // ALLOW_SXS_JIT
 
-#if defined(FEATURE_CORECLR)
 //master switch for gc suspension not based on hijacking
 #define FEATURE_ENABLE_GCPOLL
-#endif //FEATURE_CORECLR
 
-#if defined(FEATURE_ENABLE_GCPOLL) && defined(_TARGET_X86_)
+#if defined(_TARGET_X86_)
 //this enables a fast version of the GC Poll helper instead of the default portable one.
 #define ENABLE_FAST_GCPOLL_HELPER
 #endif // defined(FEATURE_ENABLE_GCPOLL) && defined(_TARGET_X86_)
@@ -132,18 +122,13 @@
 #define PLATFORM_SUPPORTS_SAFE_THREADSUSPEND
 #endif // !FEATURE_PAL
 
-#if !defined(PLATFORM_SUPPORTS_SAFE_THREADSUSPEND) && !defined(FEATURE_ENABLE_GCPOLL)
-#error "Platform must support either safe thread suspension or GC polling"
-#endif
 
 #if defined(STRESS_HEAP) && defined(_DEBUG) && defined(FEATURE_HIJACK)
 #define HAVE_GCCOVER
 #endif
 
-#ifdef FEATURE_CORECLR
 //Turns on a startup delay to allow simulation of slower and faster startup times.
 #define ENABLE_STARTUP_DELAY
-#endif
 
 
 #ifndef ALLOW_LOCAL_WORKER
@@ -182,28 +167,14 @@
 #define FEATURE_PROFAPI_EVENT_LOGGING
 #endif // defined(PROFILING_SUPPORTED)
 
-// Windows desktop supports the profiling API attach / detach feature.
-// This will eventually be supported on coreclr as well. 
-#if defined(PROFILING_SUPPORTED) && !defined(FEATURE_CORECLR)
-#define FEATURE_PROFAPI_ATTACH_DETACH
-#endif
-
-// Windows desktop DAC builds need to see some of the data used in the profiling API
-// attach / detach feature, particularly Thread::m_dwProfilerEvacuationCounter 
-#if defined(PROFILING_SUPPORTED_DATA) && !defined(FEATURE_CORECLR)
-#define DATA_PROFAPI_ATTACH_DETACH
-#endif
-
 // MUST NEVER CHECK IN WITH THIS ENABLED.
 // This is just for convenience in doing performance investigations in a checked-out enlistment.
 // #define FEATURE_ENABLE_NO_RANGE_CHECKS
 
-#ifndef FEATURE_CORECLR
 // This controls whether a compilation-timing feature that relies on Windows APIs, if available, else direct
 // hardware instructions (rdtsc), for accessing high-resolution hardware timers is enabled. This is disabled
 // in Silverlight (just to avoid thinking about whether the extra code space is worthwhile).
 #define FEATURE_JIT_TIMER
-#endif // FEATURE_CORECLR
 
 // This feature in RyuJIT supersedes the FEATURE_JIT_TIMER. In addition to supporting the time log file, this
 // feature also supports using COMPlus_JitTimeLogCsv=a.csv, which will dump method-level and phase-level timing
@@ -221,9 +192,7 @@
 // are treated as potential pinned interior pointers. When enabled, the runtime flag COMPLUS_GCCONSERVATIVE 
 // determines dynamically whether GC is conservative. Note that appdomain unload, LCG and unloadable assemblies
 // do not work reliably with conservative GC.
-#ifdef FEATURE_CORECLR
 #define FEATURE_CONSERVATIVE_GC 1
-#endif
 
 #if (defined(_TARGET_ARM_) && !defined(ARM_SOFTFP)) || defined(_TARGET_ARM64_)
 #define FEATURE_HFA
@@ -246,7 +215,7 @@
 #define FEATURE_MINIMETADATA_IN_TRIAGEDUMPS
 #endif // defined(FEATURE_CORESYSTEM)
 
-#if defined(FEATURE_PREJIT) && defined(FEATURE_CORECLR) && defined(FEATURE_CORESYSTEM)
+#if defined(FEATURE_PREJIT) && defined(FEATURE_CORESYSTEM)
 // Desktop CLR allows profilers and debuggers to opt out of loading NGENd images, and to
 // JIT everything instead. "FEATURE_TREAT_NI_AS_MSIL_DURING_DIAGNOSTICS" is roughly the
 // equivalent for Apollo, where MSIL images may not be available at all.
@@ -260,7 +229,7 @@
 // If defined, support interpretation.
 #if !defined(CROSSGEN_COMPILE)
 
-#if defined(ALLOW_SXS_JIT) && !defined(FEATURE_PAL)
+#if !defined(FEATURE_PAL)
 #define FEATURE_STACK_SAMPLING
 #endif // defined (ALLOW_SXS_JIT)
 
diff --git a/src/inc/tlbutils.h b/src/inc/tlbutils.h
deleted file mode 100644
index 54a274587c..0000000000
--- a/src/inc/tlbutils.h
+++ /dev/null
@@ -1,52 +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.
-
-//
-// Utilities used to help manipulating typelibs
-//
-
-
-#ifndef _TLBUTILS_H
-#define _TLBUTILS_H
-
-#ifndef FEATURE_COMINTEROP_TLB_SUPPORT
-#error FEATURE_COMINTEROP_TLB_SUPPORT is required for this file
-#endif // FEATURE_COMINTEROP_TLB_SUPPORT
-
-#include "windows.h"
-#include "utilcode.h"
-
-struct StdConvertibleItfInfo
-{
-    LPUTF8      m_strMngTypeName;
-    GUID      * m_pNativeTypeIID;
-    LPUTF8      m_strCustomMarshalerTypeName;
-    LPUTF8      m_strCookie;
-};
-
-// This method returns the custom marshaler info to convert the native interface
-// to its managed equivalent. Or null if the interface is not a standard convertible interface.
-const StdConvertibleItfInfo *GetConvertionInfoFromNativeIID(REFGUID rGuidNativeItf);
-
-// This function determines the namespace name for a TypeLib.
-HRESULT GetNamespaceNameForTypeLib(     // S_OK or error.
-    ITypeLib    *pITLB,                 // [IN] The TypeLib.
-    BSTR        *pwzNamespace);         // [OUT] Put the namespace name here.
-
-// This function determines the namespace.name for a TypeInfo.  If no namespace
-//  is provided, it is retrieved from the containing library.
-HRESULT GetManagedNameForTypeInfo(      // S_OK or error.
-    ITypeInfo   *pITI,                  // [IN] The TypeInfo.
-    LPCWSTR     wzNamespace,            // [IN, OPTIONAL] Default namespace name.
-    LPCWSTR     wzAsmName,              // [IN, OPTIONAL] Assembly name.
-    BSTR        *pwzName);              // [OUT] Put the name here.
-
-#endif // _TLBUTILS_H
-
-
-
-
-
-
-
diff --git a/src/inc/utilcode.h b/src/inc/utilcode.h
index a1a083638b..5394f1beb2 100644
--- a/src/inc/utilcode.h
+++ b/src/inc/utilcode.h
@@ -51,7 +51,6 @@ const WCHAR kWatsonName2[] = W("drwtsn32");
 #define WINDOWS_KERNEL32_DLLNAME_A "kernel32"
 #define WINDOWS_KERNEL32_DLLNAME_W W("kernel32")
 
-#if defined(FEATURE_CORECLR)
 #define CoreLibName_W W("System.Private.CoreLib")
 #define CoreLibName_IL_W W("System.Private.CoreLib.dll")
 #define CoreLibName_NI_W W("System.Private.CoreLib.ni.dll")
@@ -64,20 +63,6 @@ const WCHAR kWatsonName2[] = W("drwtsn32");
 #define CoreLibSatelliteName_A "System.Private.CoreLib.resources"
 #define CoreLibSatelliteNameLen 32
 #define LegacyCoreLibName_A "mscorlib"
-#else // !defined(FEATURE_CORECLR)
-#define CoreLibName_W W("mscorlib")
-#define CoreLibName_IL_W W("mscorlib.dll")
-#define CoreLibName_NI_W W("mscorlib.ni.dll")
-#define CoreLibName_TLB_W W("mscorlib.tlb")
-#define CoreLibName_A "mscorlib"
-#define CoreLibName_IL_A "mscorlib.dll"
-#define CoreLibName_NI_A "mscorlib.ni.dll"
-#define CoreLibName_TLB_A "mscorlib.tlb"
-#define CoreLibNameLen 8
-#define CoreLibSatelliteName_A "mscorlib.resources"
-#define CoreLibSatelliteNameLen 18
-#define LegacyCoreLibName_A "mscorlib"
-#endif // defined(FEATURE_CORECLR)
 
 class StringArrayList;
 
@@ -814,10 +799,8 @@ public:
 
     // Get the default resource location (mscorrc.dll for desktop, mscorrc.debug.dll for CoreCLR)
     static CCompRC* GetDefaultResourceDll();
-#ifdef FEATURE_CORECLR
     // Get the generic messages dll (Silverlight only, mscorrc.dll)
     static CCompRC* GetFallbackResourceDll();
-#endif
     static void ShutdownDefaultResourceDll();
     static void GetDefaultCallbacks(
                     FPGETTHREADUICULTURENAMES* fpGetThreadUICultureNames,
@@ -842,12 +825,10 @@ public:
                 fpGetThreadUICultureNames,
                 fpGetThreadUICultureId);
 
-#ifdef FEATURE_CORECLR
         m_FallbackResourceDll.SetResourceCultureCallbacks(
                 fpGetThreadUICultureNames,
                 fpGetThreadUICultureId);
 
-#endif
     }
 
 #ifdef USE_FORMATMESSAGE_WRAPPER
@@ -881,12 +862,10 @@ private:
     static CCompRC  m_DefaultResourceDll;
     static LPCWSTR  m_pDefaultResource;
 
-#ifdef FEATURE_CORECLR
     // fallback resources if debug pack is not installed
     static LONG     m_dwFallbackInitialized;
     static CCompRC  m_FallbackResourceDll;
     static LPCWSTR  m_pFallbackResource;
-#endif
 
     // We must map between a thread's int and a dll instance.
     // Since we only expect 1 language almost all of the time, we'll special case
@@ -1143,13 +1122,6 @@ void    SplitPathInterior(
     __out_opt LPCWSTR *pwszFileName, __out_opt size_t *pcchFileName,
     __out_opt LPCWSTR *pwszExt,      __out_opt size_t *pcchExt);
 
-#ifndef FEATURE_CORECLR
-void    MakePath(__out_ecount (MAX_LONGPATH) register WCHAR *path, 
-                 __in LPCWSTR drive, 
-                 __in LPCWSTR dir, 
-                 __in LPCWSTR fname, 
-                 __in LPCWSTR ext);
-#endif
 
 void    MakePath(__out CQuickWSTR &path,
                  __in LPCWSTR drive,
@@ -1243,13 +1215,9 @@ public:
 
     static void   FreeConfigString(__in __in_z LPWSTR name);
 
-#ifdef FEATURE_CORECLR
 private:
-#endif //FEATURE_CORECLR
     static LPWSTR EnvGetString(LPCWSTR name, BOOL fPrependCOMPLUS);
-#ifdef FEATURE_CORECLR
 public:
-#endif //FEATURE_CORECLR
 
     static BOOL UseRegistry();
 
@@ -1267,138 +1235,6 @@ private:
         BOOL fPrependCOMPLUS = TRUE);
 public:
 
-#ifndef FEATURE_CORECLR
-    static void AllowRegistryUse(BOOL fAllowUse);
-
-
-//*****************************************************************************
-// Open's the given key and returns the value desired.  If the key or value is
-// not found, then the default is returned.
-//*****************************************************************************
-    static long GetLong(                    // Return value from registry or default.
-        LPCTSTR     szName,                 // Name of value to get.
-        long        iDefault,               // Default value to return if not found.
-        LPCTSTR     szKey=NULL,             // Name of key, NULL==default.
-        HKEY        hKey=HKEY_LOCAL_MACHINE);// What key to work on.
-
-//*****************************************************************************
-// Open's the given key and returns the value desired.  If the key or value is
-// not found, then the default is returned.
-//*****************************************************************************
-    static long SetLong(                    // Return value from registry or default.
-        LPCTSTR     szName,                 // Name of value to get.
-        long        iValue,                 // Value to set.
-        LPCTSTR     szKey=NULL,             // Name of key, NULL==default.
-        HKEY        hKey=HKEY_LOCAL_MACHINE);// What key to work on.
-
-//*****************************************************************************
-// Open's the given key and returns the value desired.  If the key or value is
-// not found, then it's created
-//*****************************************************************************
-    static long SetOrCreateLong(            // Return value from registry or default.
-        LPCTSTR     szName,                 // Name of value to get.
-        long        iValue,                 // Value to set.
-        LPCTSTR     szKey=NULL,             // Name of key, NULL==default.
-        HKEY        hKey=HKEY_LOCAL_MACHINE);// What key to work on.
-
-
-
-//*****************************************************************************
-// Set an entry in the registry of the form:
-// HKEY_CLASSES_ROOT\szKey\szSubkey = szValue.  If szSubkey or szValue are
-// NULL, omit them from the above expression.
-//*****************************************************************************
-    static BOOL SetKeyAndValue(             // TRUE or FALSE.
-        LPCTSTR     szKey,                  // Name of the reg key to set.
-        LPCTSTR     szSubkey,               // Optional subkey of szKey.
-        LPCTSTR     szValue);               // Optional value for szKey\szSubkey.
-
-//*****************************************************************************
-// Delete an entry in the registry of the form:
-// HKEY_CLASSES_ROOT\szKey\szSubkey.
-//*****************************************************************************
-    static LONG DeleteKey(                  // TRUE or FALSE.
-        LPCTSTR     szKey,                  // Name of the reg key to set.
-        LPCTSTR     szSubkey);              // Subkey of szKey.
-
-//*****************************************************************************
-// Open the key, create a new keyword and value pair under it.
-//*****************************************************************************
-    static BOOL SetRegValue(                // Return status.
-        LPCTSTR     szKeyName,              // Name of full key.
-        LPCTSTR     szKeyword,              // Name of keyword.
-        LPCTSTR     szValue);               // Value of keyword.
-
-//*****************************************************************************
-// Does standard registration of a CoClass with a progid.
-//*****************************************************************************
-    static HRESULT RegisterCOMClass(        // Return code.
-        REFCLSID    rclsid,                 // Class ID.
-        LPCTSTR     szDesc,                 // Description of the class.
-        LPCTSTR     szProgIDPrefix,         // Prefix for progid.
-        int         iVersion,               // Version # for progid.
-        LPCTSTR     szClassProgID,          // Class progid.
-        LPCTSTR     szThreadingModel,       // What threading model to use.
-        LPCTSTR     szModule,               // Path to class.
-        HINSTANCE   hInst,                  // Handle to module being registered
-        LPCTSTR     szAssemblyName,         // Optional assembly name
-        LPCTSTR     szVersion,              // Optional Runtime Version (directry containing runtime)
-        BOOL        fExternal,              // flag - External to mscoree.
-        BOOL        fRelativePath);         // flag - Relative path in szModule
-
-//*****************************************************************************
-// Unregister the basic information in the system registry for a given object
-// class.
-//*****************************************************************************
-    static HRESULT UnregisterCOMClass(      // Return code.
-        REFCLSID    rclsid,                 // Class ID we are registering.
-        LPCTSTR     szProgIDPrefix,         // Prefix for progid.
-        int         iVersion,               // Version # for progid.
-        LPCTSTR     szClassProgID,          // Class progid.
-        BOOL        fExternal);             // flag - External to mscoree.
-
-//*****************************************************************************
-// Does standard registration of a CoClass with a progid.
-// NOTE: This is the non-side-by-side execution version.
-//*****************************************************************************
-    static HRESULT RegisterCOMClass(        // Return code.
-        REFCLSID    rclsid,                 // Class ID.
-        LPCTSTR     szDesc,                 // Description of the class.
-        LPCTSTR     szProgIDPrefix,         // Prefix for progid.
-        int         iVersion,               // Version # for progid.
-        LPCTSTR     szClassProgID,          // Class progid.
-        LPCTSTR     szThreadingModel,       // What threading model to use.
-        LPCTSTR     szModule,               // Path to class.
-        BOOL        bInprocServer = true);  // Whether we register the server as inproc or local
-
-//*****************************************************************************
-// Unregister the basic information in the system registry for a given object
-// class.
-// NOTE: This is the non-side-by-side execution version.
-//*****************************************************************************
-    static HRESULT UnregisterCOMClass(      // Return code.
-        REFCLSID    rclsid,                 // Class ID we are registering.
-        LPCTSTR     szProgIDPrefix,         // Prefix for progid.
-        int         iVersion,               // Version # for progid.
-        LPCTSTR     szClassProgID);         // Class progid.
-
-//*****************************************************************************
-// Register a type library.
-//*****************************************************************************
-    static HRESULT RegisterTypeLib(         // Return code.
-        REFGUID     rtlbid,                 // TypeLib ID we are registering.
-        int         iVersion,               // Typelib version.
-        LPCTSTR     szDesc,                 // TypeLib description.
-        LPCTSTR     szModule);              // Path to the typelib.
-
-//*****************************************************************************
-// Remove the registry keys for a type library.
-//*****************************************************************************
-    static HRESULT UnregisterTypeLib(       // Return code.
-        REFGUID     rtlbid,                 // TypeLib ID we are registering.
-        int         iVersion);              // Typelib version.
-
-#endif //#ifndef FEATURE_CORECLR
 
 //*****************************************************************************
 // (Optional) Initialize the config registry cache
@@ -1408,31 +1244,6 @@ public:
 
 private:
 
-#ifndef FEATURE_CORECLR
-
-//*****************************************************************************
-// Register the basics for a in proc server.
-//*****************************************************************************
-    static HRESULT RegisterClassBase(       // Return code.
-        REFCLSID    rclsid,                 // Class ID we are registering.
-        LPCTSTR     szDesc,                 // Class description.
-        LPCTSTR     szProgID,               // Class prog ID.
-        LPCTSTR     szIndepProgID,          // Class version independant prog ID.
-        __out_ecount (cchOutCLSID) LPTSTR szOutCLSID, // CLSID formatted in character form.
-        DWORD      cchOutCLSID);           // Out CLS ID buffer size in characters
-
-
-//*****************************************************************************
-// Delete the basic settings for an inproc server.
-//*****************************************************************************
-    static HRESULT UnregisterClassBase(     // Return code.
-        REFCLSID    rclsid,                 // Class ID we are registering.
-        LPCTSTR     szProgID,               // Class prog ID.
-        LPCTSTR     szIndepProgID,          // Class version independant prog ID.
-        __out_ecount (cchOutCLSID) LPTSTR      szOutCLSID,            // Return formatted class ID here.
-        DWORD      cchOutCLSID);           // Out CLS ID buffer size in characters
-
-#endif //#ifndef FEATURE_CORECLR
 
 //*****************************************************************************
 // Return TRUE if the registry value name might have been seen in the registry
@@ -4688,18 +4499,6 @@ public:
         return NtCurrentTeb()->ProcessEnvironmentBlock;
     }
 
-#ifndef FEATURE_CORECLR
-    static void* GetFiberDataPtr()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return ClrTeb::IsCurrentThreadAFiber()? GetCurrentFiber() : NULL;
-    }
-
-    static BOOL IsCurrentThreadAFiber()
-    {
-        return IsThreadAFiber();
-    }
-#endif
 
     static void* InvalidFiberPtrId()
     {
@@ -5205,22 +5004,6 @@ typedef Wrapper<BSTR, DoNothing, HolderSysFreeString> BSTRHolder;
 
 BOOL FileExists(LPCWSTR filename);
 
-#ifndef FEATURE_CORECLR
-class FileLockHolder
-{
-public:
-    FileLockHolder();   
-    ~FileLockHolder();
-    
-    virtual void Acquire(LPCWSTR lockName, HANDLE hInterrupt = 0, BOOL* pInterrupted = NULL);
-    HRESULT AcquireNoThrow(LPCWSTR lockName, HANDLE hInterrupt = 0, BOOL* pInterrupted = NULL);
-    
-    static BOOL IsTaken(LPCWSTR lockName);
-    void Release();    
-private:        
-    HANDLE  _hLock;
-};
-#endif // FEATURE_CORECLR
 
 // a class for general x.x version info
 class MajorMinorVersionInfo
@@ -5336,7 +5119,6 @@ struct CoreClrCallbacks
     pfnGetCLRFunction_t         m_pfnGetCLRFunction;
 };
 
-#if defined(FEATURE_CORECLR) || !defined(SELF_NO_HOST) || defined(DACCESS_COMPILE)
 
 // For DAC, we include this functionality only when EH SxS is enabled.
 
@@ -5362,7 +5144,6 @@ void OnUninitializedCoreClrCallbacks();
 #define VALIDATECORECLRCALLBACKS()
 #endif //_DEBUG
 
-#endif // defined(FEATURE_CORECLR) || !defined(SELF_NO_HOST) || defined(DACCESS_COMPILE)
 
 #ifdef FEATURE_CORRUPTING_EXCEPTIONS
 
@@ -5572,33 +5353,6 @@ void* FindLocalizedFile(_In_z_ LPCWSTR wzResourceDllName, LocalizedFileHandler l
 BOOL IsClrHostedLegacyComObject(REFCLSID rclsid);
 
 
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-
-// No utilcode code should use the global LoadLibraryShim anymore. UtilCode::LoadLibraryShim will do
-// the right thing based on whether the hosted or non-hosted utilcode is linked to. Using the global
-// LoadLibraryShim will result in a deprecated use warning.
-
-#ifdef SELF_NO_HOST
-#define LEGACY_ACTIVATION_SHIM_LOAD_LIBRARY WszLoadLibrary
-#include "legacyactivationshim.h"
-#include "mscoreepriv.h"
-
-namespace UtilCode
-{
-    inline HRESULT LoadLibraryShim(LPCWSTR szDllName, LPCWSTR szVersion, LPVOID pvReserved, HMODULE *phModDll)
-    {
-        return LegacyActivationShim::LoadLibraryShim(szDllName, szVersion, pvReserved, phModDll);
-    }
-};
-#else // SELF_NO_HOST
-namespace UtilCode
-{
-    // Hosted environment
-    HRESULT LoadLibraryShim(LPCWSTR szDllName, LPCWSTR szVersion, LPVOID pvReserved, HMODULE *phModDll);
-};
-#endif // SELF_NO_HOST
-
-#endif // !FEATURE_CORECLR && !CROSSGEN_COMPILE
 
 
 // Helper to support termination due to heap corruption
@@ -5606,10 +5360,6 @@ namespace UtilCode
 void EnableTerminationOnHeapCorruption();
 
 
-#if !defined(FEATURE_CORECLR)
-// On success, sets pwszProcessExePath (required) to full path to process EXE.
-HRESULT GetProcessExePath(LPCWSTR *pwszProcessExePath);
-#endif
 
 namespace Clr { namespace Util
 {
diff --git a/src/inc/vptr_list.h b/src/inc/vptr_list.h
index bac0c1165e..86c12aec35 100644
--- a/src/inc/vptr_list.h
+++ b/src/inc/vptr_list.h
@@ -27,9 +27,6 @@ VPTR_CLASS(Module)
 VPTR_CLASS(ReflectionModule)
 
 VPTR_CLASS(AppDomain)
-#ifndef FEATURE_CORECLR // FEATURE_NATIVE_IMAGE_GENERATION
-VPTR_MULTI_CLASS(CompilationDomain, AppDomain)
-#endif
 VPTR_CLASS(SharedDomain)
 VPTR_CLASS(SystemDomain)
 
@@ -68,9 +65,6 @@ VPTR_CLASS(MappedImageLayout)
 VPTR_CLASS(LoadedImageLayout)
 #endif // !CROSSGEN_COMPILE && !FEATURE_PAL
 VPTR_CLASS(FlatImageLayout)
-#ifdef FEATURE_FUSION
-VPTR_CLASS(StreamImageLayout)
-#endif
 #ifdef FEATURE_COMINTEROP 
 VPTR_CLASS(ComMethodFrame)
 VPTR_CLASS(ComPlusMethodFrame)
diff --git a/src/inc/winwrap.h b/src/inc/winwrap.h
index 4a012d3726..be098156a2 100644
--- a/src/inc/winwrap.h
+++ b/src/inc/winwrap.h
@@ -633,16 +633,6 @@
 #define WszRegQueryValueExTrue RegQueryValueExW
 #define WszRegQueryStringValueEx RegQueryValueExW
 
-#ifndef FEATURE_CORECLR
-#define WszRegDeleteKey RegDeleteKeyW
-#define WszRegCreateKeyEx ClrRegCreateKeyEx
-#define WszRegSetValueEx RegSetValueExW
-#define WszRegDeleteValue RegDeleteValueW
-#define WszRegLoadKey RegLoadKeyW
-#define WszRegUnLoadKey RegUnLoadKeyW
-#define WszRegRestoreKey RegRestoreKeyW
-#define WszRegReplaceKey RegReplaceKeyW
-#endif //#ifndef FEATURE_CORECLR
 
 #define WszRegQueryInfoKey RegQueryInfoKeyW
 #define WszRegEnumValue RegEnumValueW
diff --git a/src/inc/zapper.h b/src/inc/zapper.h
index 1018505faa..80229fc528 100644
--- a/src/inc/zapper.h
+++ b/src/inc/zapper.h
@@ -18,9 +18,6 @@
 #include "shash.h"
 #include "utilcode.h"
 #include "corjit.h"
-#ifdef FEATURE_FUSION
-#include "binderngen.h"
-#endif
 #include "corcompile.h"
 #include "corhlprpriv.h"
 #include "ngen.h"
@@ -115,22 +112,20 @@ class Zapper
     BOOL                    m_failed;
     CorInfoRegionKind       m_currentRegionKind;
 
-#if defined(FEATURE_CORECLR) || defined(CROSSGEN_COMPILE)
     SString                 m_platformAssembliesPaths;
     SString                 m_trustedPlatformAssemblies;
     SString                 m_platformResourceRoots;
     SString                 m_appPaths;
     SString                 m_appNiPaths;
     SString                 m_platformWinmdPaths;
-#endif // FEATURE_CORECLR || CROSSGEN_COMPILE
 
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#if !defined(FEATURE_MERGE_JIT_AND_ENGINE)
     SString                 m_CLRJITPath;
     bool                    m_fDontLoadJit;
-#endif // defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
-#if defined(FEATURE_CORECLR) && !defined(NO_NGENPDB)
+#endif // !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#if !defined(NO_NGENPDB)
     SString                 m_DiasymreaderPath;
-#endif // defined(FEATURE_CORECLR) && !defined(NO_NGENPDB)
+#endif // !defined(NO_NGENPDB)
     bool                    m_fForceFullTrust;
 
     SString                 m_outputFilename;
@@ -270,65 +265,6 @@ class Zapper
         }
     } m_assemblyDependencies;
 
-#ifndef FEATURE_CORECLR // No load lists on CoreCLR
-    struct loadLists
-    {
-        loadLists() :
-            m_loadAlwaysList(NULL),
-            m_loadSometimesList(NULL),
-            m_loadNeverList(NULL)
-        {
-        }
-
-        SAFEARRAY *m_loadAlwaysList;
-        SAFEARRAY *m_loadSometimesList;
-        SAFEARRAY *m_loadNeverList;
-
-        void SetLoadLists(SAFEARRAY *loadAlwaysList, SAFEARRAY *loadSometimesList, SAFEARRAY *loadNeverList)
-        {
-            m_loadAlwaysList    = loadAlwaysList;
-            m_loadSometimesList = loadSometimesList;
-            m_loadNeverList     = loadNeverList;
-        }
-
-    } m_loadLists;
-
-    void SetLoadLists(SAFEARRAY *loadAlwaysList, SAFEARRAY *loadSometimesList, SAFEARRAY *loadNeverList)
-    {
-        m_loadLists.SetLoadLists(loadAlwaysList, loadSometimesList, loadNeverList);
-    }
-
-    void SetAssemblyHardBindList()
-    {
-        SAFEARRAY *loadAlwaysList = m_loadLists.m_loadAlwaysList;
-        if (loadAlwaysList == NULL)
-        {
-            return;
-        }
-
-        LONG ubound = 0;
-        IfFailThrow(SafeArrayGetUBound(loadAlwaysList, 1, &ubound));
-
-        BSTR *pArrBstr = NULL;
-        IfFailThrow(SafeArrayAccessData(loadAlwaysList, reinterpret_cast<void **>(&pArrBstr)));
-
-        EX_TRY
-        {
-            _ASSERTE((ubound + 1) >= 0);
-            m_pEECompileInfo->SetAssemblyHardBindList(reinterpret_cast<LPWSTR *>(pArrBstr), ubound + 1);
-        }
-        EX_CATCH
-        {
-            // If something went wrong, try to unlock the OLE array
-            // Do not verify the outcome, as we can do nothing about it
-            SafeArrayUnaccessData(loadAlwaysList);
-            EX_RETHROW;
-        }
-        EX_END_CATCH_UNREACHABLE;
-
-        IfFailThrow(SafeArrayUnaccessData(loadAlwaysList));
-    }
-#endif // !FEATURE_CORECLR
 
   public:
 
@@ -355,30 +291,6 @@ class Zapper
     void InitEE(BOOL fForceDebug, BOOL fForceProfile, BOOL fForceInstrument);
     void LoadAndInitializeJITForNgen(LPCWSTR pwzJitName, OUT HINSTANCE* phJit, OUT ICorJitCompiler** ppICorJitCompiler);
 
-#ifdef FEATURE_FUSION
-    HRESULT TryEnumerateFusionCache(LPCWSTR assemblyName, bool fPrint, bool fDelete);
-    int EnumerateFusionCache(LPCWSTR assemblyName, bool fPrint, bool fDelete,
-            CORCOMPILE_NGEN_SIGNATURE * pNativeImageSig = NULL);
-    void PrintFusionCacheEntry(CorSvcLogLevel logLevel, IAssemblyName *pZapAssemblyName);
-    void DeleteFusionCacheEntry(IAssemblyName *pZapAssemblyName);
-    void DeleteFusionCacheEntry(LPCWSTR assemblyName, CORCOMPILE_NGEN_SIGNATURE *pNativeImageSig);
-
-    void PrintDependencies(
-            IMetaDataAssemblyImport * pAssemblyImport,
-            CORCOMPILE_DEPENDENCY * pDependencies,
-            COUNT_T cDependencies,
-            SString &s);
-    BOOL VerifyDependencies(
-            IMDInternalImport * pAssemblyImport,
-            CORCOMPILE_DEPENDENCY * pDependencies,
-            COUNT_T cDependencies);
-
-    void PrintAssemblyVersionInfo(IAssemblyName *pZapAssemblyName, SString &s);
-
-    IAssemblyName *GetAssemblyFusionName(IMetaDataAssemblyImport *pImport);
-    IAssemblyName *GetAssemblyRefFusionName(IMetaDataAssemblyImport *pImport,
-                                            mdAssemblyRef ar);
-#endif //FEATURE_FUSION
 
     BOOL IsAssembly(LPCWSTR path);
 
@@ -442,7 +354,6 @@ class Zapper
 
     void            GetOutputFolder();
 
-#if defined(FEATURE_CORECLR) || defined(CROSSGEN_COMPILE)
     void SetPlatformAssembliesPaths(LPCWSTR pwzPlatformAssembliesPaths);
     void SetTrustedPlatformAssemblies(LPCWSTR pwzTrustedPlatformAssemblies);
     void SetPlatformResourceRoots(LPCWSTR pwzPlatformResourceRoots);
@@ -450,16 +361,15 @@ class Zapper
     void SetAppNiPaths(LPCWSTR pwzAppNiPaths);
     void SetPlatformWinmdPaths(LPCWSTR pwzPlatformWinmdPaths);
     void SetForceFullTrust(bool val);
-#endif // FEATURE_CORECLR || CROSSGEN_COMPILE
 
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#if !defined(FEATURE_MERGE_JIT_AND_ENGINE)
     void SetCLRJITPath(LPCWSTR pwszCLRJITPath);
     void SetDontLoadJit();
-#endif // defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#endif // !defined(FEATURE_MERGE_JIT_AND_ENGINE)
 
-#if defined(FEATURE_CORECLR) && !defined(NO_NGENPDB)
+#if !defined(NO_NGENPDB)
     void SetDiasymreaderPath(LPCWSTR pwzDiasymreaderPath);
-#endif // defined(FEATURE_CORECLR) && !defined(NO_NGENPDB)
+#endif // !defined(NO_NGENPDB)
 
     void SetOutputFilename(LPCWSTR pwszOutputFilename);
     SString GetOutputFileName();
@@ -544,9 +454,7 @@ class ZapperOptions
 
     bool       m_legacyMode;          // true if the zapper was invoked using legacy mode
 
-#ifdef FEATURE_CORECLR
     bool        m_fNoMetaData;          // Do not copy metadata and IL to native image
-#endif
 
     ZapperOptions();
     ~ZapperOptions();
diff --git a/src/ipcman/ipcsharedsrc.cpp b/src/ipcman/ipcsharedsrc.cpp
index ed1e7dc1ba..bb0f46bf0d 100644
--- a/src/ipcman/ipcsharedsrc.cpp
+++ b/src/ipcman/ipcsharedsrc.cpp
@@ -18,9 +18,6 @@
 #include "ipcshared.h"
 #include "ipcmanagerinterface.h"
 
-#ifndef FEATURE_CORECLR
-#include "AppXUtil.h"
-#endif
 
 #if defined(FEATURE_IPCMAN)
 
@@ -170,41 +167,6 @@ HRESULT IPCShared::GenerateBlockTableName(DWORD pid, SString & sName, HANDLE & p
         return hr;
     }
 
-#ifndef FEATURE_CORECLR
-    // when pid != GetCurrentProcessId() it means we're the consumer opening other process perf counter data
-    if (pid != GetCurrentProcessId())
-    {
-        // if the target process is inside an appcontainer we need to add the appcontainer SID to the boundary descriptor.
-        NewArrayHolder<BYTE> pbTokenMem;
-        hr = AppX::GetAppContainerTokenInfoForProcess(pid, pbTokenMem);
-
-        if (FAILED(hr))
-        {
-            // failed to open the target's process, continue on
-            // assuming that the process isn't in an AppContainer.
-            _ASSERTE(pbTokenMem == NULL);
-        }
-        else
-        {
-            if (hr == S_FALSE)
-            {
-                // not an appcontainer
-                _ASSERTE(pbTokenMem == NULL);
-            }
-            else
-            {
-                // process is an appcontainer so add the SID
-                PTOKEN_APPCONTAINER_INFORMATION pAppContainerTokenInfo =
-                    reinterpret_cast<PTOKEN_APPCONTAINER_INFORMATION>(pbTokenMem.GetValue());
-                _ASSERTE(pAppContainerTokenInfo);
-                _ASSERTE(pAppContainerTokenInfo->TokenAppContainer);
-
-                if (!(*pAddSIDToBoundaryDescriptor)(&pBoundaryDesc, pAppContainerTokenInfo->TokenAppContainer))
-                    return HRESULT_FROM_WIN32(GetLastError());
-            }
-        }
-    }
-#endif // FEATURE_CORECLR
     
     if(bCreate)
     {
@@ -666,10 +628,6 @@ BOOL IPCShared::InitializeGenericIPCAcl(DWORD pid, BOOL bRestrictiveACL, PACL *p
     int iSIDforAdmin = -1;
     int iSIDforUsers = -1;
     int iSIDforLoggingUsers = -1;
-#if !defined (DACCESS_COMPILE) && !defined(FEATURE_CORECLR)
-    NewArrayHolder<BYTE> pbTokenMem;
-    PTOKEN_APPCONTAINER_INFORMATION pAppContainerTokenInfo = NULL;
-#endif
 
     PermStruct[0].rgPSID = NULL;
 
@@ -802,39 +760,6 @@ BOOL IPCShared::InitializeGenericIPCAcl(DWORD pid, BOOL bRestrictiveACL, PACL *p
             // non-fatal error, so don't goto errorexit
         }
 
-#if !defined(DACCESS_COMPILE) && !defined(FEATURE_CORECLR)
-        // when running on win8 if the process is an appcontainer then add the appcontainer SID to the ACL
-        // going down this code path means we're creating the descriptor for our current PID.
-        _ASSERTE(pid == GetCurrentProcessId());
-        hr = AppX::GetAppContainerTokenInfoForProcess(pid, pbTokenMem);
-
-        if (FAILED(hr))
-        {
-            // failed to open the target's process, continue on
-            // assuming that the process isn't in an AppContainer.
-            _ASSERTE(pbTokenMem == NULL);
-        }
-        else
-        {
-            if (hr == S_FALSE)
-            {
-                // not an appcontainer
-                _ASSERTE(pbTokenMem == NULL);
-            }
-            else
-            {
-                // process is an appcontainer so add the SID
-                pAppContainerTokenInfo =
-                    reinterpret_cast<PTOKEN_APPCONTAINER_INFORMATION>(pbTokenMem.GetValue());
-                _ASSERTE(pAppContainerTokenInfo);
-                _ASSERTE(pAppContainerTokenInfo->TokenAppContainer);
-
-                PermStruct[cActualACECount].rgPSID = pAppContainerTokenInfo->TokenAppContainer;
-                PermStruct[cActualACECount].rgAccessFlags = GetAccessFlagsForObject(whatObject, FALSE);
-                ++cActualACECount;
-            }
-        }
-#endif // !defined(DACCESS_COMPILE) && !defined(FEATURE_CORECLR)        
     }
 
     _ASSERTE(cActualACECount <= MaxNumberACEs);
diff --git a/src/jit/CMakeLists.txt b/src/jit/CMakeLists.txt
index 1fbbb355b0..db6e5973ba 100644
--- a/src/jit/CMakeLists.txt
+++ b/src/jit/CMakeLists.txt
@@ -81,6 +81,7 @@ if(CLR_CMAKE_TARGET_ARCH_AMD64)
     codegenxarch.cpp
     emitxarch.cpp
     lowerxarch.cpp
+    lsraxarch.cpp
     simd.cpp
     simdcodegenxarch.cpp
     targetamd64.cpp
@@ -92,6 +93,7 @@ elseif(CLR_CMAKE_TARGET_ARCH_ARM)
     decomposelongs.cpp
     emitarm.cpp
     lowerarm.cpp
+    lsraarm.cpp
     targetarm.cpp
     unwindarm.cpp
   )
@@ -101,6 +103,7 @@ elseif(CLR_CMAKE_TARGET_ARCH_I386)
     decomposelongs.cpp
     emitxarch.cpp
     lowerxarch.cpp
+    lsraxarch.cpp
     simd.cpp
     simdcodegenxarch.cpp
     targetx86.cpp
@@ -111,6 +114,7 @@ elseif(CLR_CMAKE_TARGET_ARCH_ARM64)
     codegenarm64.cpp
     emitarm64.cpp
     lowerarm64.cpp
+    lsraarm64.cpp
     targetarm64.cpp
     unwindarm.cpp
     unwindarm64.cpp
diff --git a/src/jit/DIRS.proj b/src/jit/DIRS.proj
index 6d1c06d3f0..eb00cc1d64 100644
--- a/src/jit/DIRS.proj
+++ b/src/jit/DIRS.proj
@@ -26,8 +26,8 @@
   <ItemGroup Condition="'$(BuildExePhase)' == '1' and '$(BuildProjectName)' != 'CoreSys'">
 
     <!-- Build the "FrankenJit" (RyuJIT front-end, legacy back-end) and "FrankenAltjit". These can't conflict with the names of the JIT32 directory outputs. -->
-    <ProjectFile Condition="'$(BuildArchitecture)' == 'i386' or '$(BuildArchitecture)' == 'arm'"  Include="frankenjit\frankenjit.nativeproj" />
-    <ProjectFile Condition="'$(BuildArchitecture)' == 'i386'"                                     Include="frankenaltjit\frankenaltjit.nativeproj" />
+    <ProjectFile Condition="'$(BuildArchitecture)' == 'arm'"  Include="frankenjit\frankenjit.nativeproj" />
+    <ProjectFile Condition="'$(BuildArchitecture)' == 'i386'" Include="frankenaltjit\frankenaltjit.nativeproj" />
 
     <!-- This might be useful, to help make sure JIT devs build all configurations of the JIT (including crossgen), but
          it appears to cause problems with the build system, and it slows down normal JIT developer productivity by adding a seldom-useful build.
diff --git a/src/jit/block.cpp b/src/jit/block.cpp
index bb6a57c25b..6d8bc348fd 100644
--- a/src/jit/block.cpp
+++ b/src/jit/block.cpp
@@ -572,10 +572,10 @@ void BasicBlock::dspBlockHeader(Compiler* compiler,
 
 #endif // DEBUG
 
-// Allocation function for HeapPhiArg.
-void* BasicBlock::HeapPhiArg::operator new(size_t sz, Compiler* comp)
+// Allocation function for MemoryPhiArg.
+void* BasicBlock::MemoryPhiArg::operator new(size_t sz, Compiler* comp)
 {
-    return comp->compGetMem(sz, CMK_HeapPhiArg);
+    return comp->compGetMem(sz, CMK_MemoryPhiArg);
 }
 
 //------------------------------------------------------------------------
@@ -773,7 +773,7 @@ BasicBlock* BasicBlock::GetUniqueSucc()
 }
 
 // Static vars.
-BasicBlock::HeapPhiArg* BasicBlock::EmptyHeapPhiDef = (BasicBlock::HeapPhiArg*)0x1;
+BasicBlock::MemoryPhiArg* BasicBlock::EmptyMemoryPhiDef = (BasicBlock::MemoryPhiArg*)0x1;
 
 unsigned PtrKeyFuncs<BasicBlock>::GetHashCode(const BasicBlock* ptr)
 {
diff --git a/src/jit/block.h b/src/jit/block.h
index 3d45ea0171..786b83178f 100644
--- a/src/jit/block.h
+++ b/src/jit/block.h
@@ -144,6 +144,88 @@ struct EntryState
     StackEntry* esStack;               // ptr to  stack
 };
 
+// Enumeration of the kinds of memory whose state changes the compiler tracks
+enum MemoryKind
+{
+    ByrefExposed = 0, // Includes anything byrefs can read/write (everything in GcHeap, address-taken locals,
+                      //                                          unmanaged heap, callers' locals, etc.)
+    GcHeap,           // Includes actual GC heap, and also static fields
+    MemoryKindCount,  // Number of MemoryKinds
+};
+#ifdef DEBUG
+const char* const memoryKindNames[] = {"ByrefExposed", "GcHeap"};
+#endif // DEBUG
+
+// Bitmask describing a set of memory kinds (usable in bitfields)
+typedef unsigned int MemoryKindSet;
+
+// Bitmask for a MemoryKindSet containing just the specified MemoryKind
+inline MemoryKindSet memoryKindSet(MemoryKind memoryKind)
+{
+    return (1U << memoryKind);
+}
+
+// Bitmask for a MemoryKindSet containing the specified MemoryKinds
+template <typename... MemoryKinds>
+inline MemoryKindSet memoryKindSet(MemoryKind memoryKind, MemoryKinds... memoryKinds)
+{
+    return memoryKindSet(memoryKind) | memoryKindSet(memoryKinds...);
+}
+
+// Bitmask containing all the MemoryKinds
+const MemoryKindSet fullMemoryKindSet = (1 << MemoryKindCount) - 1;
+
+// Bitmask containing no MemoryKinds
+const MemoryKindSet emptyMemoryKindSet = 0;
+
+// Standard iterator class for iterating through MemoryKinds
+class MemoryKindIterator
+{
+    int value;
+
+public:
+    explicit inline MemoryKindIterator(int val) : value(val)
+    {
+    }
+    inline MemoryKindIterator& operator++()
+    {
+        ++value;
+        return *this;
+    }
+    inline MemoryKindIterator operator++(int)
+    {
+        return MemoryKindIterator(value++);
+    }
+    inline MemoryKind operator*()
+    {
+        return static_cast<MemoryKind>(value);
+    }
+    friend bool operator==(const MemoryKindIterator& left, const MemoryKindIterator& right)
+    {
+        return left.value == right.value;
+    }
+    friend bool operator!=(const MemoryKindIterator& left, const MemoryKindIterator& right)
+    {
+        return left.value != right.value;
+    }
+};
+
+// Empty struct that allows enumerating memory kinds via `for(MemoryKind kind : allMemoryKinds())`
+struct allMemoryKinds
+{
+    inline allMemoryKinds()
+    {
+    }
+    inline MemoryKindIterator begin()
+    {
+        return MemoryKindIterator(0);
+    }
+    inline MemoryKindIterator end()
+    {
+        return MemoryKindIterator(MemoryKindCount);
+    }
+};
+
 // This encapsulates the "exception handling" successors of a block.  That is,
 // if a basic block BB1 occurs in a try block, we consider the first basic block
 // BB2 of the corresponding handler to be an "EH successor" of BB1.  Because we
@@ -808,41 +890,42 @@ struct BasicBlock : private LIR::Range
     VARSET_TP bbLiveIn;  // variables live on entry
     VARSET_TP bbLiveOut; // variables live on exit
 
-    // Use, def, live in/out information for the implicit "Heap" variable.
-    unsigned bbHeapUse : 1; // must be set to true for any block that references the global Heap
-    unsigned bbHeapDef : 1; // must be set to true for any block that mutates the global Heap
-    unsigned bbHeapLiveIn : 1;
-    unsigned bbHeapLiveOut : 1;
-    unsigned bbHeapHavoc : 1; // If true, at some point the block does an operation that leaves the heap
-                              // in an unknown state. (E.g., unanalyzed call, store through unknown
-                              // pointer...)
+    // Use, def, live in/out information for the implicit memory variable.
+    MemoryKindSet bbMemoryUse : MemoryKindCount; // must be set for any MemoryKinds this block references
+    MemoryKindSet bbMemoryDef : MemoryKindCount; // must be set for any MemoryKinds this block mutates
+    MemoryKindSet bbMemoryLiveIn : MemoryKindCount;
+    MemoryKindSet bbMemoryLiveOut : MemoryKindCount;
+    MemoryKindSet bbMemoryHavoc : MemoryKindCount; // If true, at some point the block does an operation
+                                                   // that leaves memory in an unknown state. (E.g.,
+                                                   // unanalyzed call, store through unknown pointer...)
 
-    // We want to make phi functions for the special implicit var "Heap".  But since this is not a real
+    // We want to make phi functions for the special implicit var memory.  But since this is not a real
     // lclVar, and thus has no local #, we can't use a GenTreePhiArg.  Instead, we use this struct.
-    struct HeapPhiArg
+    struct MemoryPhiArg
     {
-        unsigned    m_ssaNum;  // SSA# for incoming value.
-        HeapPhiArg* m_nextArg; // Next arg in the list, else NULL.
+        unsigned      m_ssaNum;  // SSA# for incoming value.
+        MemoryPhiArg* m_nextArg; // Next arg in the list, else NULL.
 
         unsigned GetSsaNum()
         {
             return m_ssaNum;
         }
 
-        HeapPhiArg(unsigned ssaNum, HeapPhiArg* nextArg = nullptr) : m_ssaNum(ssaNum), m_nextArg(nextArg)
+        MemoryPhiArg(unsigned ssaNum, MemoryPhiArg* nextArg = nullptr) : m_ssaNum(ssaNum), m_nextArg(nextArg)
         {
         }
 
         void* operator new(size_t sz, class Compiler* comp);
     };
-    static HeapPhiArg* EmptyHeapPhiDef; // Special value (0x1, FWIW) to represent a to-be-filled in Phi arg list
-                                        // for Heap.
-    HeapPhiArg* bbHeapSsaPhiFunc;       // If the "in" Heap SSA var is not a phi definition, this value is NULL.
-                                        // Otherwise, it is either the special value EmptyHeapPhiDefn, to indicate
-                                        // that Heap needs a phi definition on entry, or else it is the linked list
-                                        // of the phi arguments.
-    unsigned bbHeapSsaNumIn;            // The SSA # of "Heap" on entry to the block.
-    unsigned bbHeapSsaNumOut;           // The SSA # of "Heap" on exit from the block.
+    static MemoryPhiArg* EmptyMemoryPhiDef; // Special value (0x1, FWIW) to represent a to-be-filled in Phi arg list
+                                            // for Heap.
+    MemoryPhiArg* bbMemorySsaPhiFunc[MemoryKindCount]; // If the "in" Heap SSA var is not a phi definition, this value
+                                                       // is NULL.
+    // Otherwise, it is either the special value EmptyMemoryPhiDefn, to indicate
+    // that Heap needs a phi definition on entry, or else it is the linked list
+    // of the phi arguments.
+    unsigned bbMemorySsaNumIn[MemoryKindCount];  // The SSA # of memory on entry to the block.
+    unsigned bbMemorySsaNumOut[MemoryKindCount]; // The SSA # of memory on exit from the block.
 
     VARSET_TP bbScope; // variables in scope over the block
 
diff --git a/src/jit/codegen.h b/src/jit/codegen.h
index 090283ee50..507970ee15 100755
--- a/src/jit/codegen.h
+++ b/src/jit/codegen.h
@@ -470,6 +470,9 @@ protected:
     void genSetPSPSym(regNumber initReg, bool* pInitRegZeroed);
 
     void genUpdateCurrentFunclet(BasicBlock* block);
+#if defined(_TARGET_ARM_)
+    void genInsertNopForUnwinder(BasicBlock* block);
+#endif
 
 #else // FEATURE_EH_FUNCLETS
 
@@ -479,6 +482,13 @@ protected:
         return;
     }
 
+#if defined(_TARGET_ARM_)
+    void genInsertNopForUnwinder(BasicBlock* block)
+    {
+        return;
+    }
+#endif
+
 #endif // FEATURE_EH_FUNCLETS
 
     void genGeneratePrologsAndEpilogs();
diff --git a/src/jit/codegenarm.cpp b/src/jit/codegenarm.cpp
index 2884fe0056..580cad5053 100644
--- a/src/jit/codegenarm.cpp
+++ b/src/jit/codegenarm.cpp
@@ -50,17 +50,45 @@ void CodeGen::genEmitGSCookieCheck(bool pushReg)
 //------------------------------------------------------------------------
 // genCallFinally: Generate a call to the finally block.
 //
-BasicBlock* CodeGen::genCallFinally(BasicBlock* block, BasicBlock* lblk)
+BasicBlock* CodeGen::genCallFinally(BasicBlock* block)
 {
-    NYI("ARM genCallFinally");
-    return block;
+    BasicBlock* bbFinallyRet = nullptr;
+
+    // We don't have retless calls, since we use the BBJ_ALWAYS to point at a NOP pad where
+    // we would have otherwise created retless calls.
+    assert(block->isBBCallAlwaysPair());
+
+    assert(block->bbNext != NULL);
+    assert(block->bbNext->bbJumpKind == BBJ_ALWAYS);
+    assert(block->bbNext->bbJumpDest != NULL);
+    assert(block->bbNext->bbJumpDest->bbFlags & BBF_FINALLY_TARGET);
+
+    bbFinallyRet = block->bbNext->bbJumpDest;
+    bbFinallyRet->bbFlags |= BBF_JMP_TARGET;
+
+    // Load the address where the finally funclet should return into LR.
+    // The funclet prolog/epilog will do "push {lr}" / "pop {pc}" to do the return.
+    getEmitter()->emitIns_R_L(INS_movw, EA_4BYTE_DSP_RELOC, bbFinallyRet, REG_LR);
+    getEmitter()->emitIns_R_L(INS_movt, EA_4BYTE_DSP_RELOC, bbFinallyRet, REG_LR);
+
+    // Jump to the finally BB
+    inst_JMP(EJ_jmp, block->bbJumpDest);
+
+    // The BBJ_ALWAYS is used because the BBJ_CALLFINALLY can't point to the
+    // jump target using bbJumpDest - that is already used to point
+    // to the finally block. So just skip past the BBJ_ALWAYS unless the
+    // block is RETLESS.
+    assert(!(block->bbFlags & BBF_RETLESS_CALL));
+    assert(block->isBBCallAlwaysPair());
+    return block->bbNext;
 }
 
 //------------------------------------------------------------------------
 // genEHCatchRet:
 void CodeGen::genEHCatchRet(BasicBlock* block)
 {
-    NYI("ARM genEHCatchRet");
+    getEmitter()->emitIns_R_L(INS_movw, EA_4BYTE_DSP_RELOC, block->bbJumpDest, REG_INTRET);
+    getEmitter()->emitIns_R_L(INS_movt, EA_4BYTE_DSP_RELOC, block->bbJumpDest, REG_INTRET);
 }
 
 //---------------------------------------------------------------------
@@ -93,7 +121,8 @@ void CodeGen::genIntrinsic(GenTreePtr treeNode)
             break;
 
         case CORINFO_INTRINSIC_Sqrt:
-            NYI_ARM("genIntrinsic for sqrt - not implementd yet");
+            genConsumeOperands(treeNode->AsOp());
+            getEmitter()->emitInsBinary(INS_vsqrt, emitTypeSize(treeNode), treeNode, srcNode);
             break;
 
         default:
@@ -294,7 +323,14 @@ void CodeGen::genCodeForTreeNode(GenTreePtr treeNode)
             // The src must be a register.
             regNumber operandReg = genConsumeReg(operand);
 
-            getEmitter()->emitIns_R_R_I(ins, emitTypeSize(treeNode), targetReg, operandReg, 0);
+            if (ins == INS_vneg)
+            {
+                getEmitter()->emitIns_R_R(ins, emitTypeSize(treeNode), targetReg, operandReg);
+            }
+            else
+            {
+                getEmitter()->emitIns_R_R_I(ins, emitTypeSize(treeNode), targetReg, operandReg, 0);
+            }
         }
             genProduceReg(treeNode);
             break;
@@ -309,6 +345,8 @@ void CodeGen::genCodeForTreeNode(GenTreePtr treeNode)
         case GT_SUB:
         case GT_MUL:
         {
+            genConsumeOperands(treeNode->AsOp());
+
             const genTreeOps oper = treeNode->OperGet();
             if ((oper == GT_ADD || oper == GT_SUB || oper == GT_MUL) && treeNode->gtOverflow())
             {
@@ -323,56 +361,8 @@ void CodeGen::genCodeForTreeNode(GenTreePtr treeNode)
             // The arithmetic node must be sitting in a register (since it's not contained)
             noway_assert(targetReg != REG_NA);
 
-            regNumber op1reg = op1->gtRegNum;
-            regNumber op2reg = op2->gtRegNum;
-
-            GenTreePtr dst;
-            GenTreePtr src;
-
-            genConsumeIfReg(op1);
-            genConsumeIfReg(op2);
-
-            if (!varTypeIsFloating(targetType))
-            {
-                // This is the case of reg1 = reg1 op reg2
-                // We're ready to emit the instruction without any moves
-                if (op1reg == targetReg)
-                {
-                    dst = op1;
-                    src = op2;
-                }
-                // We have reg1 = reg2 op reg1
-                // In order for this operation to be correct
-                // we need that op is a commutative operation so
-                // we can convert it into reg1 = reg1 op reg2 and emit
-                // the same code as above
-                else if (op2reg == targetReg)
-                {
-                    assert(GenTree::OperIsCommutative(treeNode->OperGet()));
-                    dst = op2;
-                    src = op1;
-                }
-                // dest, op1 and op2 registers are different:
-                // reg3 = reg1 op reg2
-                // We can implement this by issuing a mov:
-                // reg3 = reg1
-                // reg3 = reg3 op reg2
-                else
-                {
-                    inst_RV_RV(ins_Move_Extend(targetType, true), targetReg, op1reg, op1->gtType);
-                    regTracker.rsTrackRegCopy(targetReg, op1reg);
-                    gcInfo.gcMarkRegPtrVal(targetReg, targetType);
-                    dst = treeNode;
-                    src = op2;
-                }
-
-                regNumber r = emit->emitInsBinary(ins, emitTypeSize(treeNode), dst, src);
-                assert(r == targetReg);
-            }
-            else
-            {
-                emit->emitIns_R_R_R(ins, emitTypeSize(treeNode), targetReg, op1reg, op2reg);
-            }
+            regNumber r = emit->emitInsTernary(ins, emitTypeSize(treeNode), treeNode, op1, op2);
+            assert(r == targetReg);
         }
             genProduceReg(treeNode);
             break;
@@ -380,6 +370,7 @@ void CodeGen::genCodeForTreeNode(GenTreePtr treeNode)
         case GT_LSH:
         case GT_RSH:
         case GT_RSZ:
+        case GT_ROR:
             genCodeForShift(treeNode);
             // genCodeForShift() calls genProduceReg()
             break;
@@ -472,45 +463,103 @@ void CodeGen::genCodeForTreeNode(GenTreePtr treeNode)
 
         case GT_STORE_LCL_FLD:
         {
-            NYI_IF(targetType == TYP_STRUCT, "GT_STORE_LCL_FLD: struct store local field not supported");
+            noway_assert(targetType != TYP_STRUCT);
+
+            // record the offset
+            unsigned offset = treeNode->gtLclFld.gtLclOffs;
+
+            // We must have a stack store with GT_STORE_LCL_FLD
             noway_assert(!treeNode->InReg());
+            noway_assert(targetReg == REG_NA);
 
-            GenTreePtr op1 = treeNode->gtOp.gtOp1->gtEffectiveVal();
-            genConsumeIfReg(op1);
-            emit->emitInsBinary(ins_Store(targetType), emitTypeSize(treeNode), treeNode, op1);
+            GenTreeLclVarCommon* varNode = treeNode->AsLclVarCommon();
+            unsigned             varNum  = varNode->gtLclNum;
+            assert(varNum < compiler->lvaCount);
+            LclVarDsc* varDsc = &(compiler->lvaTable[varNum]);
+
+            // Ensure that lclVar nodes are typed correctly.
+            assert(!varDsc->lvNormalizeOnStore() || targetType == genActualType(varDsc->TypeGet()));
+
+            GenTreePtr  data = treeNode->gtOp.gtOp1->gtEffectiveVal();
+            instruction ins  = ins_Store(targetType);
+            emitAttr    attr = emitTypeSize(targetType);
+            if (data->isContainedIntOrIImmed())
+            {
+                assert(data->IsIntegralConst(0));
+                NYI_ARM("st.lclFld contained operand");
+            }
+            else
+            {
+                assert(!data->isContained());
+                genConsumeReg(data);
+                emit->emitIns_S_R(ins, attr, data->gtRegNum, varNum, offset);
+            }
+
+            genUpdateLife(varNode);
+            varDsc->lvRegNum = REG_STK;
         }
         break;
 
         case GT_STORE_LCL_VAR:
         {
-            NYI_IF(targetType == TYP_STRUCT, "struct store local not supported");
+            GenTreeLclVarCommon* varNode = treeNode->AsLclVarCommon();
 
-            GenTreePtr op1 = treeNode->gtOp.gtOp1->gtEffectiveVal();
-            genConsumeIfReg(op1);
-            if (treeNode->gtRegNum == REG_NA)
-            {
-                // stack store
-                emit->emitInsMov(ins_Store(targetType), emitTypeSize(treeNode), treeNode);
-                compiler->lvaTable[treeNode->AsLclVarCommon()->gtLclNum].lvRegNum = REG_STK;
-            }
-            else if (op1->isContained())
+            unsigned varNum = varNode->gtLclNum;
+            assert(varNum < compiler->lvaCount);
+            LclVarDsc* varDsc = &(compiler->lvaTable[varNum]);
+            unsigned   offset = 0;
+
+            // Ensure that lclVar nodes are typed correctly.
+            assert(!varDsc->lvNormalizeOnStore() || targetType == genActualType(varDsc->TypeGet()));
+
+            GenTreePtr data = treeNode->gtOp.gtOp1->gtEffectiveVal();
+
+            // var = call, where call returns a multi-reg return value
+            // case is handled separately.
+            if (data->gtSkipReloadOrCopy()->IsMultiRegCall())
             {
-                // Currently, we assume that the contained source of a GT_STORE_LCL_VAR writing to a register
-                // must be a constant. However, in the future we might want to support a contained memory op.
-                // This is a bit tricky because we have to decide it's contained before register allocation,
-                // and this would be a case where, once that's done, we need to mark that node as always
-                // requiring a register - which we always assume now anyway, but once we "optimize" that
-                // we'll have to take cases like this into account.
-                assert((op1->gtRegNum == REG_NA) && op1->OperIsConst());
-                genSetRegToConst(treeNode->gtRegNum, targetType, op1);
+                NYI_ARM("st.lclVar multi-reg value");
             }
-            else if (op1->gtRegNum != treeNode->gtRegNum)
+            else
             {
-                assert(op1->gtRegNum != REG_NA);
-                emit->emitInsBinary(ins_Move_Extend(targetType, true), emitTypeSize(treeNode), treeNode, op1);
+                genConsumeRegs(data);
+
+                regNumber dataReg = REG_NA;
+                if (data->isContainedIntOrIImmed())
+                {
+                    assert(data->IsIntegralConst(0));
+                    NYI_ARM("st.lclVar contained operand");
+                }
+                else
+                {
+                    assert(!data->isContained());
+                    dataReg = data->gtRegNum;
+                }
+                assert(dataReg != REG_NA);
+
+                if (targetReg == REG_NA) // store into stack based LclVar
+                {
+                    inst_set_SV_var(varNode);
+
+                    instruction ins  = ins_Store(targetType);
+                    emitAttr    attr = emitTypeSize(targetType);
+
+                    emit->emitIns_S_R(ins, attr, dataReg, varNum, offset);
+
+                    genUpdateLife(varNode);
+
+                    varDsc->lvRegNum = REG_STK;
+                }
+                else // store into register (i.e move into register)
+                {
+                    if (dataReg != targetReg)
+                    {
+                        // Assign into targetReg when dataReg (from op1) is not the same register
+                        inst_RV_RV(ins_Copy(targetType), targetReg, dataReg, targetType);
+                    }
+                    genProduceReg(treeNode);
+                }
             }
-            if (treeNode->gtRegNum != REG_NA)
-                genProduceReg(treeNode);
         }
         break;
 
@@ -560,7 +609,7 @@ void CodeGen::genCodeForTreeNode(GenTreePtr treeNode)
 
         case GT_IND:
             genConsumeAddress(treeNode->AsIndir()->Addr());
-            emit->emitInsMov(ins_Load(treeNode->TypeGet()), emitTypeSize(treeNode), treeNode);
+            emit->emitInsLoadStoreOp(ins_Load(targetType), emitTypeSize(treeNode), targetReg, treeNode->AsIndir());
             genProduceReg(treeNode);
             break;
 
@@ -777,7 +826,8 @@ void CodeGen::genCodeForTreeNode(GenTreePtr treeNode)
                     genConsumeAddress(addr);
                 }
 
-                emit->emitInsMov(ins_Store(data->TypeGet()), emitTypeSize(storeInd), storeInd);
+                emit->emitInsLoadStoreOp(ins_Store(targetType), emitTypeSize(storeInd), data->gtRegNum,
+                                         treeNode->AsIndir());
             }
         }
         break;
@@ -944,6 +994,14 @@ void CodeGen::genCodeForTreeNode(GenTreePtr treeNode)
             genProduceReg(treeNode);
             break;
 
+        case GT_JMPTABLE:
+            genJumpTable(treeNode);
+            break;
+
+        case GT_SWITCH_TABLE:
+            genTableBasedSwitch(treeNode);
+            break;
+
         case GT_IL_OFFSET:
             // Do nothing; these nodes are simply markers for debug info.
             break;
@@ -952,7 +1010,7 @@ void CodeGen::genCodeForTreeNode(GenTreePtr treeNode)
         {
 #ifdef DEBUG
             char message[256];
-            _snprintf_s(message, _countof(message), _TRUNCATE, "NYI: Unimplemented node type %s\n",
+            _snprintf_s(message, _countof(message), _TRUNCATE, "NYI: Unimplemented node type %s",
                         GenTree::NodeName(treeNode->OperGet()));
             NYIRAW(message);
 #else
@@ -975,6 +1033,54 @@ void CodeGen::genLockedInstructions(GenTreeOp* treeNode)
 }
 
 //------------------------------------------------------------------------
+// genTableBasedSwitch: generate code for a switch statement based on a table of ip-relative offsets
+//
+void CodeGen::genTableBasedSwitch(GenTree* treeNode)
+{
+    genConsumeOperands(treeNode->AsOp());
+    regNumber idxReg  = treeNode->gtOp.gtOp1->gtRegNum;
+    regNumber baseReg = treeNode->gtOp.gtOp2->gtRegNum;
+
+    regNumber tmpReg = genRegNumFromMask(treeNode->gtRsvdRegs);
+
+    getEmitter()->emitIns_R_ARX(INS_ldr, EA_4BYTE, REG_PC, baseReg, idxReg, TARGET_POINTER_SIZE, 0);
+}
+
+//------------------------------------------------------------------------
+// genJumpTable: emits the table and an instruction to get the address of the first element
+//
+void CodeGen::genJumpTable(GenTree* treeNode)
+{
+    noway_assert(compiler->compCurBB->bbJumpKind == BBJ_SWITCH);
+    assert(treeNode->OperGet() == GT_JMPTABLE);
+
+    unsigned     jumpCount = compiler->compCurBB->bbJumpSwt->bbsCount;
+    BasicBlock** jumpTable = compiler->compCurBB->bbJumpSwt->bbsDstTab;
+    unsigned     jmpTabBase;
+
+    jmpTabBase = getEmitter()->emitBBTableDataGenBeg(jumpCount, false);
+
+    JITDUMP("\n      J_M%03u_DS%02u LABEL   DWORD\n", Compiler::s_compMethodsCount, jmpTabBase);
+
+    for (unsigned i = 0; i < jumpCount; i++)
+    {
+        BasicBlock* target = *jumpTable++;
+        noway_assert(target->bbFlags & BBF_JMP_TARGET);
+
+        JITDUMP("            DD      L_M%03u_BB%02u\n", Compiler::s_compMethodsCount, target->bbNum);
+
+        getEmitter()->emitDataGenData(i, target);
+    }
+
+    getEmitter()->emitDataGenEnd();
+
+    getEmitter()->emitIns_R_D(INS_movw, EA_HANDLE_CNS_RELOC, jmpTabBase, treeNode->gtRegNum);
+    getEmitter()->emitIns_R_D(INS_movt, EA_HANDLE_CNS_RELOC, jmpTabBase, treeNode->gtRegNum);
+
+    genProduceReg(treeNode);
+}
+
+//------------------------------------------------------------------------
 // genRangeCheck: generate code for GT_ARR_BOUNDS_CHECK node.
 //
 void CodeGen::genRangeCheck(GenTreePtr oper)
@@ -1088,6 +1194,9 @@ instruction CodeGen::genGetInsForOper(genTreeOps oper, var_types type)
         case GT_XOR:
             ins = INS_XOR;
             break;
+        case GT_ROR:
+            ins = INS_ror;
+            break;
         default:
             unreached();
             break;
@@ -1114,13 +1223,12 @@ void CodeGen::genCodeForShift(GenTreePtr tree)
 
     assert(tree->gtRegNum != REG_NA);
 
-    GenTreePtr operand = tree->gtGetOp1();
-    genConsumeReg(operand);
+    genConsumeOperands(tree->AsOp());
 
+    GenTreePtr operand = tree->gtGetOp1();
     GenTreePtr shiftBy = tree->gtGetOp2();
     if (!shiftBy->IsCnsIntOrI())
     {
-        genConsumeReg(shiftBy);
         getEmitter()->emitIns_R_R_R(ins, size, tree->gtRegNum, operand->gtRegNum, shiftBy->gtRegNum);
     }
     else
diff --git a/src/jit/codegenarm64.cpp b/src/jit/codegenarm64.cpp
index 585038b1b9..48d6f76453 100644
--- a/src/jit/codegenarm64.cpp
+++ b/src/jit/codegenarm64.cpp
@@ -1326,7 +1326,7 @@ void CodeGen::genEmitGSCookieCheck(bool pushReg)
     genDefineTempLabel(gsCheckBlk);
 }
 
-BasicBlock* CodeGen::genCallFinally(BasicBlock* block, BasicBlock* lblk)
+BasicBlock* CodeGen::genCallFinally(BasicBlock* block)
 {
     // Generate a call to the finally, like this:
     //      mov         x0,qword ptr [fp + 10H] / sp    // Load x0 with PSPSym, or sp if PSPSym is not used
@@ -1387,8 +1387,6 @@ BasicBlock* CodeGen::genCallFinally(BasicBlock* block, BasicBlock* lblk)
     if (!(block->bbFlags & BBF_RETLESS_CALL))
     {
         assert(block->isBBCallAlwaysPair());
-
-        lblk  = block;
         block = block->bbNext;
     }
     return block;
@@ -3380,7 +3378,14 @@ void CodeGen::genCodeForInitBlk(GenTreeBlk* initBlkNode)
 
     assert(!dstAddr->isContained());
     assert(!initVal->isContained());
-    assert(initBlkNode->gtRsvdRegs == RBM_ARG_2);
+    if (initBlkNode->gtOper == GT_STORE_DYN_BLK)
+    {
+        assert(initBlkNode->AsDynBlk()->gtDynamicSize->gtRegNum == REG_ARG_2);
+    }
+    else
+    {
+        assert(initBlkNode->gtRsvdRegs == RBM_ARG_2);
+    }
 
 // TODO-ARM64-CQ: When initblk loop unrolling is implemented
 //                put this assert back on.
diff --git a/src/jit/codegencommon.cpp b/src/jit/codegencommon.cpp
index 396ea77374..65cc6de472 100644
--- a/src/jit/codegencommon.cpp
+++ b/src/jit/codegencommon.cpp
@@ -2814,6 +2814,37 @@ void CodeGen::genUpdateCurrentFunclet(BasicBlock* block)
         }
     }
 }
+
+#if defined(_TARGET_ARM_)
+void CodeGen::genInsertNopForUnwinder(BasicBlock* block)
+{
+    // If this block is the target of a finally return, we need to add a preceding NOP, in the same EH region,
+    // so the unwinder doesn't get confused by our "movw lr, xxx; movt lr, xxx; b Lyyy" calling convention that
+    // calls the funclet during non-exceptional control flow.
+    if (block->bbFlags & BBF_FINALLY_TARGET)
+    {
+        assert(block->bbFlags & BBF_JMP_TARGET);
+
+#ifdef DEBUG
+        if (compiler->verbose)
+        {
+            printf("\nEmitting finally target NOP predecessor for BB%02u\n", block->bbNum);
+        }
+#endif
+        // Create a label that we'll use for computing the start of an EH region, if this block is
+        // at the beginning of such a region. If we used the existing bbEmitCookie as is for
+        // determining the EH regions, then this NOP would end up outside of the region, if this
+        // block starts an EH region. If we pointed the existing bbEmitCookie here, then the NOP
+        // would be executed, which we would prefer not to do.
+
+        block->bbUnwindNopEmitCookie =
+            getEmitter()->emitAddLabel(gcInfo.gcVarPtrSetCur, gcInfo.gcRegGCrefSetCur, gcInfo.gcRegByrefSetCur);
+
+        instGen(INS_nop);
+    }
+}
+#endif
+
 #endif // FEATURE_EH_FUNCLETS
 
 /*****************************************************************************
@@ -3165,12 +3196,17 @@ void CodeGen::genGenerateCode(void** codePtr, ULONG* nativeSizeOfCode)
     /* Check our max stack level. Needed for fgAddCodeRef().
        We need to relax the assert as our estimation won't include code-gen
        stack changes (which we know don't affect fgAddCodeRef()) */
-    noway_assert(getEmitter()->emitMaxStackDepth <=
-                 (compiler->fgPtrArgCntMax +              // Max number of pointer-sized stack arguments.
-                  compiler->compHndBBtabCount +           // Return address for locally-called finallys
-                  genTypeStSz(TYP_LONG) +                 // longs/doubles may be transferred via stack, etc
-                  (compiler->compTailCallUsed ? 4 : 0))); // CORINFO_HELP_TAILCALL args
+    {
+        unsigned maxAllowedStackDepth = compiler->fgPtrArgCntMax +    // Max number of pointer-sized stack arguments.
+                                        compiler->compHndBBtabCount + // Return address for locally-called finallys
+                                        genTypeStSz(TYP_LONG) +       // longs/doubles may be transferred via stack, etc
+                                        (compiler->compTailCallUsed ? 4 : 0); // CORINFO_HELP_TAILCALL args
+#if defined(UNIX_X86_ABI)
+        maxAllowedStackDepth += genTypeStSz(TYP_INT) * 3; // stack align for x86 - allow up to 3 INT's for padding
 #endif
+        noway_assert(getEmitter()->emitMaxStackDepth <= maxAllowedStackDepth);
+    }
+#endif // EMIT_TRACK_STACK_DEPTH
 
     *nativeSizeOfCode                 = codeSize;
     compiler->info.compNativeCodeSize = (UNATIVE_OFFSET)codeSize;
diff --git a/src/jit/codegenlegacy.cpp b/src/jit/codegenlegacy.cpp
index f1243a64d6..c616546b0c 100644
--- a/src/jit/codegenlegacy.cpp
+++ b/src/jit/codegenlegacy.cpp
@@ -2593,7 +2593,7 @@ regMaskTP CodeGen::genRestoreAddrMode(GenTreePtr addr, GenTreePtr tree, bool loc
 
             if (tree->gtOp.gtOp1)
                 regMask |= genRestoreAddrMode(addr, tree->gtOp.gtOp1, lockPhase);
-            if (tree->gtGetOp2())
+            if (tree->gtGetOp2IfPresent())
                 regMask |= genRestoreAddrMode(addr, tree->gtOp.gtOp2, lockPhase);
         }
         else if (tree->gtOper == GT_ARR_ELEM)
@@ -3042,7 +3042,7 @@ AGAIN:
 
     noway_assert(kind & GTK_SMPOP);
 
-    if (tree->gtGetOp2())
+    if (tree->gtGetOp2IfPresent())
     {
         genEvalSideEffects(tree->gtOp.gtOp1);
 
@@ -9692,7 +9692,7 @@ void CodeGen::genCodeForTreeSmpOp(GenTreePtr tree, regMaskTP destReg, regMaskTP
     const genTreeOps oper     = tree->OperGet();
     const var_types  treeType = tree->TypeGet();
     GenTreePtr       op1      = tree->gtOp.gtOp1;
-    GenTreePtr       op2      = tree->gtGetOp2();
+    GenTreePtr       op2      = tree->gtGetOp2IfPresent();
     regNumber        reg      = DUMMY_INIT(REG_CORRUPT);
     regMaskTP        regs     = regSet.rsMaskUsed;
     regMaskTP        needReg  = destReg;
@@ -12680,30 +12680,7 @@ void CodeGen::genCodeForBBlist()
 
 #if FEATURE_EH_FUNCLETS
 #if defined(_TARGET_ARM_)
-        // If this block is the target of a finally return, we need to add a preceding NOP, in the same EH region,
-        // so the unwinder doesn't get confused by our "movw lr, xxx; movt lr, xxx; b Lyyy" calling convention that
-        // calls the funclet during non-exceptional control flow.
-        if (block->bbFlags & BBF_FINALLY_TARGET)
-        {
-            assert(block->bbFlags & BBF_JMP_TARGET);
-
-#ifdef DEBUG
-            if (compiler->verbose)
-            {
-                printf("\nEmitting finally target NOP predecessor for BB%02u\n", block->bbNum);
-            }
-#endif
-            // Create a label that we'll use for computing the start of an EH region, if this block is
-            // at the beginning of such a region. If we used the existing bbEmitCookie as is for
-            // determining the EH regions, then this NOP would end up outside of the region, if this
-            // block starts an EH region. If we pointed the existing bbEmitCookie here, then the NOP
-            // would be executed, which we would prefer not to do.
-
-            block->bbUnwindNopEmitCookie =
-                getEmitter()->emitAddLabel(gcInfo.gcVarPtrSetCur, gcInfo.gcRegGCrefSetCur, gcInfo.gcRegByrefSetCur);
-
-            instGen(INS_nop);
-        }
+        genInsertNopForUnwinder(block);
 #endif // defined(_TARGET_ARM_)
 
         genUpdateCurrentFunclet(block);
@@ -13397,7 +13374,7 @@ void CodeGen::genCodeForTreeLng(GenTreePtr tree, regMaskTP needReg, regMaskTP av
         int         helper;
 
         GenTreePtr op1 = tree->gtOp.gtOp1;
-        GenTreePtr op2 = tree->gtGetOp2();
+        GenTreePtr op2 = tree->gtGetOp2IfPresent();
 
         switch (oper)
         {
@@ -14541,79 +14518,6 @@ void CodeGen::genCodeForTreeLng(GenTreePtr tree, regMaskTP needReg, regMaskTP av
 
                 goto DONE;
 
-#if LONG_ASG_OPS
-
-            case GT_ASG_OR:
-                insLo = insHi = INS_OR;
-                goto ASG_OPR;
-            case GT_ASG_XOR:
-                insLo = insHi = INS_XOR;
-                goto ASG_OPR;
-            case GT_ASG_AND:
-                insLo = insHi = INS_AND;
-                goto ASG_OPR;
-            case GT_ASG_SUB:
-                insLo = INS_sub;
-                insHi = INS_SUBC;
-                goto ASG_OPR;
-            case GT_ASG_ADD:
-                insLo = INS_add;
-                insHi = INS_ADDC;
-                goto ASG_OPR;
-
-            ASG_OPR:
-
-                if (op2->gtOper == GT_CNS_LNG)
-                {
-                    __int64 lval = op2->gtLngCon.gtLconVal;
-
-                    /* Make the target addressable */
-
-                    addrReg = genMakeAddressable(op1, needReg, RegSet::FREE_REG);
-
-                    /* Optimize some special cases */
-
-                    doLo = doHi = true;
-
-                    /* Check for "(op1 AND -1)" and "(op1 [X]OR 0)" */
-
-                    switch (oper)
-                    {
-                        case GT_ASG_AND:
-                            if ((int)(lval) == -1)
-                                doLo = false;
-                            if ((int)(lval >> 32) == -1)
-                                doHi = false;
-                            break;
-
-                        case GT_ASG_OR:
-                        case GT_ASG_XOR:
-                            if (!(lval & 0x00000000FFFFFFFF))
-                                doLo = false;
-                            if (!(lval & 0xFFFFFFFF00000000))
-                                doHi = false;
-                            break;
-                    }
-
-                    if (doLo)
-                        inst_TT_IV(insLo, op1, (int)(lval), 0);
-                    if (doHi)
-                        inst_TT_IV(insHi, op1, (int)(lval >> 32), 4);
-
-                    bool isArith = (oper == GT_ASG_ADD || oper == GT_ASG_SUB);
-                    if (doLo || doHi)
-                        tree->gtFlags |= GTF_ZSF_SET;
-
-                    genDoneAddressable(op1, addrReg, RegSet::FREE_REG);
-                    goto DONE_ASSG_REGS;
-                }
-
-                /* TODO: allow non-const long assignment operators */
-
-                noway_assert(!"non-const long asgop NYI");
-
-#endif // LONG_ASG_OPS
-
             case GT_IND:
             case GT_NULLCHECK:
             {
@@ -20737,17 +20641,17 @@ GenTreePtr Compiler::fgLegacyPerStatementLocalVarLiveness(GenTreePtr startNode,
     VARSET_TP VARSET_INIT(this, defSet_BeforeSplit, fgCurDefSet); // Store the current fgCurDefSet and fgCurUseSet so
     VARSET_TP VARSET_INIT(this, useSet_BeforeSplit, fgCurUseSet); // we can restore then before entering the elseTree.
 
-    bool heapUse_BeforeSplit   = fgCurHeapUse;
-    bool heapDef_BeforeSplit   = fgCurHeapDef;
-    bool heapHavoc_BeforeSplit = fgCurHeapHavoc;
+    MemoryKindSet memoryUse_BeforeSplit   = fgCurMemoryUse;
+    MemoryKindSet memoryDef_BeforeSplit   = fgCurMemoryDef;
+    MemoryKindSet memoryHavoc_BeforeSplit = fgCurMemoryHavoc;
 
     VARSET_TP VARSET_INIT_NOCOPY(defSet_AfterThenTree, VarSetOps::MakeEmpty(this)); // These two variables will store
                                                                                     // the USE and DEF sets after
     VARSET_TP VARSET_INIT_NOCOPY(useSet_AfterThenTree, VarSetOps::MakeEmpty(this)); // evaluating the thenTree.
 
-    bool heapUse_AfterThenTree   = fgCurHeapUse;
-    bool heapDef_AfterThenTree   = fgCurHeapDef;
-    bool heapHavoc_AfterThenTree = fgCurHeapHavoc;
+    MemoryKindSet memoryUse_AfterThenTree   = fgCurMemoryUse;
+    MemoryKindSet memoryDef_AfterThenTree   = fgCurMemoryDef;
+    MemoryKindSet memoryHavoc_AfterThenTree = fgCurMemoryHavoc;
 
     // relopNode is either NULL or a GTF_RELOP_QMARK node.
     assert(!relopNode || (relopNode->OperKind() & GTK_RELOP) && (relopNode->gtFlags & GTF_RELOP_QMARK));
@@ -20774,9 +20678,9 @@ GenTreePtr Compiler::fgLegacyPerStatementLocalVarLiveness(GenTreePtr startNode,
                 VarSetOps::IntersectionD(this, fgCurDefSet, defSet_AfterThenTree);
                 VarSetOps::UnionD(this, fgCurUseSet, useSet_AfterThenTree);
 
-                fgCurHeapDef   = fgCurHeapDef && heapDef_AfterThenTree;
-                fgCurHeapHavoc = fgCurHeapHavoc && heapHavoc_AfterThenTree;
-                fgCurHeapUse   = fgCurHeapUse || heapUse_AfterThenTree;
+                fgCurMemoryDef   = fgCurMemoryDef & memoryDef_AfterThenTree;
+                fgCurMemoryHavoc = fgCurMemoryHavoc & memoryHavoc_AfterThenTree;
+                fgCurMemoryUse   = fgCurMemoryUse | memoryUse_AfterThenTree;
 
                 // Return the GT_QMARK node itself so the caller can continue from there.
                 // NOTE: the caller will get to the next node by doing the "tree = tree->gtNext"
@@ -20793,16 +20697,16 @@ GenTreePtr Compiler::fgLegacyPerStatementLocalVarLiveness(GenTreePtr startNode,
                 VarSetOps::Assign(this, defSet_AfterThenTree, fgCurDefSet);
                 VarSetOps::Assign(this, useSet_AfterThenTree, fgCurUseSet);
 
-                heapDef_AfterThenTree   = fgCurHeapDef;
-                heapHavoc_AfterThenTree = fgCurHeapHavoc;
-                heapUse_AfterThenTree   = fgCurHeapUse;
+                memoryDef_AfterThenTree   = fgCurMemoryDef;
+                memoryHavoc_AfterThenTree = fgCurMemoryHavoc;
+                memoryUse_AfterThenTree   = fgCurMemoryUse;
 
                 VarSetOps::Assign(this, fgCurDefSet, defSet_BeforeSplit);
                 VarSetOps::Assign(this, fgCurUseSet, useSet_BeforeSplit);
 
-                fgCurHeapDef   = heapDef_BeforeSplit;
-                fgCurHeapHavoc = heapHavoc_BeforeSplit;
-                fgCurHeapUse   = heapUse_BeforeSplit;
+                fgCurMemoryDef   = memoryDef_BeforeSplit;
+                fgCurMemoryHavoc = memoryHavoc_BeforeSplit;
+                fgCurMemoryUse   = memoryUse_BeforeSplit;
 
                 break;
 
@@ -20816,39 +20720,39 @@ GenTreePtr Compiler::fgLegacyPerStatementLocalVarLiveness(GenTreePtr startNode,
                 break;
 
             case GT_CLS_VAR:
-                // For Volatile indirection, first mutate the global heap
+                // For Volatile indirection, first mutate GcHeap/ByrefExposed
                 // see comments in ValueNum.cpp (under case GT_CLS_VAR)
                 // This models Volatile reads as def-then-use of the heap.
                 // and allows for a CSE of a subsequent non-volatile read
                 if ((tree->gtFlags & GTF_FLD_VOLATILE) != 0)
                 {
                     // For any Volatile indirection, we must handle it as a
-                    // definition of the global heap
-                    fgCurHeapDef = true;
+                    // definition of GcHeap/ByrefExposed
+                    fgCurMemoryDef |= memoryKindSet(GcHeap, ByrefExposed);
                 }
                 // If the GT_CLS_VAR is the lhs of an assignment, we'll handle it as a heap def, when we get to
                 // assignment.
                 // Otherwise, we treat it as a use here.
                 if ((tree->gtFlags & GTF_CLS_VAR_ASG_LHS) == 0)
                 {
-                    fgCurHeapUse = true;
+                    fgCurMemoryUse |= memoryKindSet(GcHeap, ByrefExposed);
                 }
                 break;
 
             case GT_IND:
-                // For Volatile indirection, first mutate the global heap
+                // For Volatile indirection, first mutate GcHeap/ByrefExposed
                 // see comments in ValueNum.cpp (under case GT_CLS_VAR)
                 // This models Volatile reads as def-then-use of the heap.
                 // and allows for a CSE of a subsequent non-volatile read
                 if ((tree->gtFlags & GTF_IND_VOLATILE) != 0)
                 {
                     // For any Volatile indirection, we must handle it as a
-                    // definition of the global heap
-                    fgCurHeapDef = true;
+                    // definition of GcHeap/ByrefExposed
+                    fgCurMemoryDef |= memoryKindSet(GcHeap, ByrefExposed);
                 }
 
                 // If the GT_IND is the lhs of an assignment, we'll handle it
-                // as a heap def, when we get to assignment.
+                // as a heap/byref def, when we get to assignment.
                 // Otherwise, we treat it as a use here.
                 if ((tree->gtFlags & GTF_IND_ASG_LHS) == 0)
                 {
@@ -20857,7 +20761,7 @@ GenTreePtr Compiler::fgLegacyPerStatementLocalVarLiveness(GenTreePtr startNode,
                     GenTreePtr           addrArg         = tree->gtOp.gtOp1->gtEffectiveVal(/*commaOnly*/ true);
                     if (!addrArg->DefinesLocalAddr(this, /*width doesn't matter*/ 0, &dummyLclVarTree, &dummyIsEntire))
                     {
-                        fgCurHeapUse = true;
+                        fgCurMemoryUse |= memoryKindSet(GcHeap, ByrefExposed);
                     }
                     else
                     {
@@ -20874,22 +20778,23 @@ GenTreePtr Compiler::fgLegacyPerStatementLocalVarLiveness(GenTreePtr startNode,
                 unreached();
                 break;
 
-            // We'll assume these are use-then-defs of the heap.
+            // We'll assume these are use-then-defs of GcHeap/ByrefExposed.
             case GT_LOCKADD:
             case GT_XADD:
             case GT_XCHG:
             case GT_CMPXCHG:
-                fgCurHeapUse   = true;
-                fgCurHeapDef   = true;
-                fgCurHeapHavoc = true;
+                fgCurMemoryUse |= memoryKindSet(GcHeap, ByrefExposed);
+                fgCurMemoryDef |= memoryKindSet(GcHeap, ByrefExposed);
+                fgCurMemoryHavoc |= memoryKindSet(GcHeap, ByrefExposed);
                 break;
 
             case GT_MEMORYBARRIER:
-                // Simliar to any Volatile indirection, we must handle this as a definition of the global heap
-                fgCurHeapDef = true;
+                // Simliar to any Volatile indirection, we must handle this as a definition of GcHeap/ByrefExposed
+                fgCurMemoryDef |= memoryKindSet(GcHeap, ByrefExposed);
                 break;
 
-            // For now, all calls read/write the heap, the latter in its entirety.  Might tighten this case later.
+            // For now, all calls read/write GcHeap/ByrefExposed, writes in their entirety.  Might tighten this case
+            // later.
             case GT_CALL:
             {
                 GenTreeCall* call    = tree->AsCall();
@@ -20905,9 +20810,9 @@ GenTreePtr Compiler::fgLegacyPerStatementLocalVarLiveness(GenTreePtr startNode,
                 }
                 if (modHeap)
                 {
-                    fgCurHeapUse   = true;
-                    fgCurHeapDef   = true;
-                    fgCurHeapHavoc = true;
+                    fgCurMemoryUse |= memoryKindSet(GcHeap, ByrefExposed);
+                    fgCurMemoryDef |= memoryKindSet(GcHeap, ByrefExposed);
+                    fgCurMemoryHavoc |= memoryKindSet(GcHeap, ByrefExposed);
                 }
             }
 
@@ -20939,14 +20844,26 @@ GenTreePtr Compiler::fgLegacyPerStatementLocalVarLiveness(GenTreePtr startNode,
 
             default:
 
-                // Determine whether it defines a heap location.
+                // Determine what memory kinds it defines.
                 if (tree->OperIsAssignment() || tree->OperIsBlkOp())
                 {
                     GenTreeLclVarCommon* dummyLclVarTree = NULL;
-                    if (!tree->DefinesLocal(this, &dummyLclVarTree))
+                    if (tree->DefinesLocal(this, &dummyLclVarTree))
+                    {
+                        if (lvaVarAddrExposed(dummyLclVarTree->gtLclNum))
+                        {
+                            fgCurMemoryDef |= memoryKindSet(ByrefExposed);
+
+                            // We've found a store that modifies ByrefExposed
+                            // memory but not GcHeap memory, so track their
+                            // states separately.
+                            byrefStatesMatchGcHeapStates = false;
+                        }
+                    }
+                    else
                     {
-                        // If it doesn't define a local, then it might update the heap.
-                        fgCurHeapDef = true;
+                        // If it doesn't define a local, then it might update GcHeap/ByrefExposed.
+                        fgCurMemoryDef |= memoryKindSet(GcHeap, ByrefExposed);
                     }
                 }
 
diff --git a/src/jit/codegenlinear.cpp b/src/jit/codegenlinear.cpp
index 6829d96a8f..001048e64a 100644
--- a/src/jit/codegenlinear.cpp
+++ b/src/jit/codegenlinear.cpp
@@ -133,9 +133,8 @@ void CodeGen::genCodeForBBlist()
      */
 
     BasicBlock* block;
-    BasicBlock* lblk; /* previous block */
 
-    for (lblk = nullptr, block = compiler->fgFirstBB; block != nullptr; lblk = block, block = block->bbNext)
+    for (block = compiler->fgFirstBB; block != nullptr; block = block->bbNext)
     {
 #ifdef DEBUG
         if (compiler->verbose)
@@ -247,6 +246,10 @@ void CodeGen::genCodeForBBlist()
             }
         }
 
+#if FEATURE_EH_FUNCLETS && defined(_TARGET_ARM_)
+        genInsertNopForUnwinder(block);
+#endif
+
         /* Start a new code output block */
 
         genUpdateCurrentFunclet(block);
@@ -284,7 +287,7 @@ void CodeGen::genCodeForBBlist()
             }
 #endif
             // We should never have a block that falls through into the Cold section
-            noway_assert(!lblk->bbFallsThrough());
+            noway_assert(!block->bbPrev->bbFallsThrough());
 
             // We require the block that starts the Cold section to have a label
             noway_assert(block->bbEmitCookie);
@@ -602,7 +605,7 @@ void CodeGen::genCodeForBBlist()
                 break;
 
             case BBJ_CALLFINALLY:
-                block = genCallFinally(block, lblk);
+                block = genCallFinally(block);
                 break;
 
 #if FEATURE_EH_FUNCLETS
diff --git a/src/jit/codegenlinear.h b/src/jit/codegenlinear.h
index 406ab779f1..c8a5af657a 100644
--- a/src/jit/codegenlinear.h
+++ b/src/jit/codegenlinear.h
@@ -93,10 +93,11 @@ void genSIMDCheck(GenTree* treeNode);
 // their size rounded to TARGET_POINTER_SIZE (which is 8 bytes on 64-bit targets) and hence
 // Vector3 locals could be treated as TYP_SIMD16 while reading/writing.
 void genStoreIndTypeSIMD12(GenTree* treeNode);
-void genStoreLclFldTypeSIMD12(GenTree* treeNode);
 void genLoadIndTypeSIMD12(GenTree* treeNode);
+void genStoreLclTypeSIMD12(GenTree* treeNode);
 void genLoadLclTypeSIMD12(GenTree* treeNode);
 #ifdef _TARGET_X86_
+void genStoreSIMD12ToStack(regNumber operandReg, regNumber tmpReg);
 void genPutArgStkSIMD12(GenTree* treeNode);
 #endif // _TARGET_X86_
 #endif // FEATURE_SIMD
@@ -217,7 +218,7 @@ void genCallInstruction(GenTreePtr call);
 
 void genJmpMethod(GenTreePtr jmp);
 
-BasicBlock* genCallFinally(BasicBlock* block, BasicBlock* lblk);
+BasicBlock* genCallFinally(BasicBlock* block);
 
 #if FEATURE_EH_FUNCLETS
 void genEHCatchRet(BasicBlock* block);
diff --git a/src/jit/codegenxarch.cpp b/src/jit/codegenxarch.cpp
index 11d37b28f6..e893da6035 100644
--- a/src/jit/codegenxarch.cpp
+++ b/src/jit/codegenxarch.cpp
@@ -226,7 +226,7 @@ void CodeGen::genEmitGSCookieCheck(bool pushReg)
     genPopRegs(pushedRegs, byrefPushedRegs, norefPushedRegs);
 }
 
-BasicBlock* CodeGen::genCallFinally(BasicBlock* block, BasicBlock* lblk)
+BasicBlock* CodeGen::genCallFinally(BasicBlock* block)
 {
 #if FEATURE_EH_FUNCLETS
     // Generate a call to the finally, like this:
@@ -354,8 +354,6 @@ BasicBlock* CodeGen::genCallFinally(BasicBlock* block, BasicBlock* lblk)
     if (!(block->bbFlags & BBF_RETLESS_CALL))
     {
         assert(block->isBBCallAlwaysPair());
-
-        lblk  = block;
         block = block->bbNext;
     }
     return block;
@@ -1491,10 +1489,11 @@ void CodeGen::genCodeForTreeNode(GenTreePtr treeNode)
             // storing of TYP_SIMD12 (i.e. Vector3) field
             if (treeNode->TypeGet() == TYP_SIMD12)
             {
-                genStoreLclFldTypeSIMD12(treeNode);
+                genStoreLclTypeSIMD12(treeNode);
                 break;
             }
-#endif
+#endif // FEATURE_SIMD
+
             GenTreePtr op1 = treeNode->gtGetOp1();
             genConsumeRegs(op1);
             emit->emitInsBinary(ins_Store(targetType), emitTypeSize(treeNode), treeNode, op1);
@@ -1531,6 +1530,13 @@ void CodeGen::genCodeForTreeNode(GenTreePtr treeNode)
 #endif // !defined(_TARGET_64BIT_)
 
 #ifdef FEATURE_SIMD
+                // storing of TYP_SIMD12 (i.e. Vector3) field
+                if (treeNode->TypeGet() == TYP_SIMD12)
+                {
+                    genStoreLclTypeSIMD12(treeNode);
+                    break;
+                }
+
                 if (varTypeIsSIMD(targetType) && (targetReg != REG_NA) && op1->IsCnsIntOrI())
                 {
                     // This is only possible for a zero-init.
@@ -2637,16 +2643,14 @@ void CodeGen::genLclHeap(GenTreePtr tree)
         // Loop:
         genDefineTempLabel(loop);
 
-#if defined(_TARGET_AMD64_)
-        // Push two 8-byte zeros. This matches the 16-byte STACK_ALIGN value.
-        static_assert_no_msg(STACK_ALIGN == (REGSIZE_BYTES * 2));
-        inst_IV(INS_push_hide, 0); // --- push 8-byte 0
-        inst_IV(INS_push_hide, 0); // --- push 8-byte 0
-#elif defined(_TARGET_X86_)
-        // Push a single 4-byte zero. This matches the 4-byte STACK_ALIGN value.
-        static_assert_no_msg(STACK_ALIGN == REGSIZE_BYTES);
-        inst_IV(INS_push_hide, 0); // --- push 4-byte 0
-#endif // _TARGET_X86_
+        static_assert_no_msg((STACK_ALIGN % REGSIZE_BYTES) == 0);
+        unsigned const count = (STACK_ALIGN / REGSIZE_BYTES);
+
+        for (unsigned i = 0; i < count; i++)
+        {
+            inst_IV(INS_push_hide, 0); // --- push REG_SIZE bytes of 0
+        }
+        // Note that the stack must always be aligned to STACK_ALIGN bytes
 
         // Decrement the loop counter and loop if not done.
         inst_RV(INS_dec, regCnt, TYP_I_IMPL);
@@ -4886,9 +4890,9 @@ void CodeGen::genCallInstruction(GenTreePtr node)
                 stackArgBytes += argBytes;
             }
             else
-            {
 #endif // FEATURE_PUT_STRUCT_ARG_STK
 
+            {
                 stackArgBytes += genTypeSize(genActualType(arg->TypeGet()));
             }
         }
@@ -5127,6 +5131,15 @@ void CodeGen::genCallInstruction(GenTreePtr node)
                     retSize MULTIREG_HAS_SECOND_GC_RET_ONLY_ARG(secondRetSize), ilOffset);
     }
 
+#if defined(UNIX_X86_ABI)
+    // Put back the stack pointer if there was any padding for stack alignment
+    unsigned padStackAlign = call->fgArgInfo->GetPadStackAlign();
+    if (padStackAlign != 0)
+    {
+        inst_RV_IV(INS_add, REG_SPBASE, padStackAlign * TARGET_POINTER_SIZE, EA_PTRSIZE);
+    }
+#endif // UNIX_X86_ABI
+
     // if it was a pinvoke we may have needed to get the address of a label
     if (genPendingCallLabel)
     {
@@ -7450,7 +7463,7 @@ unsigned CodeGen::getBaseVarForPutArgStk(GenTreePtr treeNode)
 
 #ifdef _TARGET_X86_
 //---------------------------------------------------------------------
-// adjustStackForPutArgStk:
+// genAdjustStackForPutArgStk:
 //    adjust the stack pointer for a putArgStk node if necessary.
 //
 // Arguments:
@@ -7458,6 +7471,12 @@ unsigned CodeGen::getBaseVarForPutArgStk(GenTreePtr treeNode)
 //
 // Returns: true if the stack pointer was adjusted; false otherwise.
 //
+// Notes:
+//    Sets `m_pushStkArg` to true if the stack arg needs to be pushed,
+//    false if the stack arg needs to be stored at the current stack
+//    pointer address. This is exactly the opposite of the return value
+//    of this function.
+//
 bool CodeGen::genAdjustStackForPutArgStk(GenTreePutArgStk* putArgStk)
 {
 #ifdef FEATURE_SIMD
@@ -7515,11 +7534,10 @@ bool CodeGen::genAdjustStackForPutArgStk(GenTreePutArgStk* putArgStk)
 }
 
 //---------------------------------------------------------------------
-// genPutArgStkFieldList - generate code for passing an arg on the stack.
+// genPutArgStkFieldList - generate code for passing a GT_FIELD_LIST arg on the stack.
 //
 // Arguments
-//    treeNode      - the GT_PUTARG_STK node
-//    targetType    - the type of the treeNode
+//    treeNode      - the GT_PUTARG_STK node whose op1 is a GT_FIELD_LIST
 //
 // Return value:
 //    None
@@ -7531,24 +7549,36 @@ void CodeGen::genPutArgStkFieldList(GenTreePutArgStk* putArgStk)
 
     // Set m_pushStkArg and pre-adjust the stack if necessary.
     const bool preAdjustedStack = genAdjustStackForPutArgStk(putArgStk);
+
     // For now, we only support the "push" case; we will push a full slot for the first field of each slot
     // within the struct.
     assert((putArgStk->isPushKind()) && !preAdjustedStack && m_pushStkArg);
 
-    // If we have pre-adjusted the stack and are simply storing the fields in order) set the offset to 0.
+    // If we have pre-adjusted the stack and are simply storing the fields in order, set the offset to 0.
     // (Note that this mode is not currently being used.)
     // If we are pushing the arguments (i.e. we have not pre-adjusted the stack), then we are pushing them
     // in reverse order, so we start with the current field offset at the size of the struct arg (which must be
     // a multiple of the target pointer size).
     unsigned  currentOffset   = (preAdjustedStack) ? 0 : putArgStk->getArgSize();
     unsigned  prevFieldOffset = currentOffset;
-    regNumber tmpReg          = REG_NA;
+    regNumber intTmpReg       = REG_NA;
+    regNumber simdTmpReg      = REG_NA;
     if (putArgStk->gtRsvdRegs != RBM_NONE)
     {
-        assert(genCountBits(putArgStk->gtRsvdRegs) == 1);
-        tmpReg = genRegNumFromMask(putArgStk->gtRsvdRegs);
-        assert(genIsValidIntReg(tmpReg));
+        regMaskTP rsvdRegs = putArgStk->gtRsvdRegs;
+        if ((rsvdRegs & RBM_ALLINT) != 0)
+        {
+            intTmpReg = genRegNumFromMask(rsvdRegs & RBM_ALLINT);
+            assert(genIsValidIntReg(intTmpReg));
+        }
+        if ((rsvdRegs & RBM_ALLFLOAT) != 0)
+        {
+            simdTmpReg = genRegNumFromMask(rsvdRegs & RBM_ALLFLOAT);
+            assert(genIsValidFloatReg(simdTmpReg));
+        }
+        assert(genCountBits(rsvdRegs) == (unsigned)((intTmpReg == REG_NA) ? 0 : 1) + ((simdTmpReg == REG_NA) ? 0 : 1));
     }
+
     for (GenTreeFieldList* current = fieldList; current != nullptr; current = current->Rest())
     {
         GenTree* const fieldNode   = current->Current();
@@ -7576,7 +7606,7 @@ void CodeGen::genPutArgStkFieldList(GenTreePutArgStk* putArgStk)
         // able to detect stores into the outgoing argument area of the stack on x86.
         const bool fieldIsSlot = ((fieldOffset % 4) == 0) && ((prevFieldOffset - fieldOffset) >= 4);
         int        adjustment  = roundUp(currentOffset - fieldOffset, 4);
-        if (fieldIsSlot)
+        if (fieldIsSlot && !varTypeIsSIMD(fieldType))
         {
             fieldType         = genActualType(fieldType);
             unsigned pushSize = genTypeSize(fieldType);
@@ -7594,12 +7624,13 @@ void CodeGen::genPutArgStkFieldList(GenTreePutArgStk* putArgStk)
         else
         {
             m_pushStkArg = false;
+
             // We always "push" floating point fields (i.e. they are full slot values that don't
             // require special handling).
-            assert(varTypeIsIntegralOrI(fieldNode));
+            assert(varTypeIsIntegralOrI(fieldNode) || varTypeIsSIMD(fieldNode));
+
             // If we can't push this field, it needs to be in a register so that we can store
             // it to the stack location.
-            assert(tmpReg != REG_NA);
             if (adjustment != 0)
             {
                 // This moves the stack pointer to fieldOffset.
@@ -7611,15 +7642,16 @@ void CodeGen::genPutArgStkFieldList(GenTreePutArgStk* putArgStk)
             }
 
             // Does it need to be in a byte register?
-            // If so, we'll use tmpReg, which must have been allocated as a byte register.
+            // If so, we'll use intTmpReg, which must have been allocated as a byte register.
             // If it's already in a register, but not a byteable one, then move it.
             if (varTypeIsByte(fieldType) && ((argReg == REG_NA) || ((genRegMask(argReg) & RBM_BYTE_REGS) == 0)))
             {
-                noway_assert((genRegMask(tmpReg) & RBM_BYTE_REGS) != 0);
+                assert(intTmpReg != REG_NA);
+                noway_assert((genRegMask(intTmpReg) & RBM_BYTE_REGS) != 0);
                 if (argReg != REG_NA)
                 {
-                    inst_RV_RV(INS_mov, tmpReg, argReg, fieldType);
-                    argReg = tmpReg;
+                    inst_RV_RV(INS_mov, intTmpReg, argReg, fieldType);
+                    argReg = intTmpReg;
                 }
             }
         }
@@ -7630,6 +7662,7 @@ void CodeGen::genPutArgStkFieldList(GenTreePutArgStk* putArgStk)
             {
                 if (fieldNode->isUsedFromSpillTemp())
                 {
+                    assert(!varTypeIsSIMD(fieldType)); // Q: can we get here with SIMD?
                     assert(fieldNode->IsRegOptional());
                     TempDsc* tmp = getSpillTempDsc(fieldNode);
                     getEmitter()->emitIns_S(INS_push, emitActualTypeSize(fieldNode->TypeGet()), tmp->tdTempNum(), 0);
@@ -7662,25 +7695,35 @@ void CodeGen::genPutArgStkFieldList(GenTreePutArgStk* putArgStk)
             }
             else
             {
-                // The stack has been adjusted and we will load the field to tmpReg and then store it on the stack.
+                // The stack has been adjusted and we will load the field to intTmpReg and then store it on the stack.
                 assert(varTypeIsIntegralOrI(fieldNode));
                 switch (fieldNode->OperGet())
                 {
                     case GT_LCL_VAR:
-                        inst_RV_TT(INS_mov, tmpReg, fieldNode);
+                        inst_RV_TT(INS_mov, intTmpReg, fieldNode);
                         break;
                     case GT_CNS_INT:
-                        genSetRegToConst(tmpReg, fieldNode->TypeGet(), fieldNode);
+                        genSetRegToConst(intTmpReg, fieldNode->TypeGet(), fieldNode);
                         break;
                     default:
                         unreached();
                 }
-                genStoreRegToStackArg(fieldType, tmpReg, fieldOffset - currentOffset);
+                genStoreRegToStackArg(fieldType, intTmpReg, fieldOffset - currentOffset);
             }
         }
         else
         {
-            genStoreRegToStackArg(fieldType, argReg, fieldOffset - currentOffset);
+#if defined(_TARGET_X86_) && defined(FEATURE_SIMD)
+            if (fieldType == TYP_SIMD12)
+            {
+                assert(genIsValidFloatReg(simdTmpReg));
+                genStoreSIMD12ToStack(argReg, simdTmpReg);
+            }
+            else
+#endif // defined(_TARGET_X86_) && defined(FEATURE_SIMD)
+            {
+                genStoreRegToStackArg(fieldType, argReg, fieldOffset - currentOffset);
+            }
             if (m_pushStkArg)
             {
                 // We always push a slot-rounded size
@@ -7715,13 +7758,15 @@ void CodeGen::genPutArgStk(GenTreePutArgStk* putArgStk)
 
 #ifdef _TARGET_X86_
 
-#ifdef FEATURE_SIMD
-    if (targetType == TYP_SIMD12)
+#if defined(UNIX_X86_ABI)
+    // For each call, first stack argument has the padding for alignment
+    // if this value is not zero, use it to adjust the ESP
+    unsigned argPadding = putArgStk->getArgPadding();
+    if (argPadding != 0)
     {
-        genPutArgStkSIMD12(putArgStk);
-        return;
+        inst_RV_IV(INS_sub, REG_SPBASE, argPadding * TARGET_POINTER_SIZE, EA_PTRSIZE);
     }
-#endif // FEATURE_SIMD
+#endif
 
     if (varTypeIsStruct(targetType))
     {
@@ -7950,6 +7995,14 @@ void CodeGen::genPutStructArgStk(GenTreePutArgStk* putArgStk)
 {
     var_types targetType = putArgStk->TypeGet();
 
+#if defined(_TARGET_X86_) && defined(FEATURE_SIMD)
+    if (targetType == TYP_SIMD12)
+    {
+        genPutArgStkSIMD12(putArgStk);
+        return;
+    }
+#endif // defined(_TARGET_X86_) && defined(FEATURE_SIMD)
+
     if (varTypeIsSIMD(targetType))
     {
         regNumber srcReg = genConsumeReg(putArgStk->gtGetOp1());
@@ -8032,7 +8085,7 @@ void CodeGen::genPutStructArgStk(GenTreePutArgStk* putArgStk)
                 slotAttr = EA_BYREF;
             }
 
-            const unsigned offset = i * 4;
+            const unsigned offset = i * TARGET_POINTER_SIZE;
             if (srcAddrInReg)
             {
                 getEmitter()->emitIns_AR_R(INS_push, slotAttr, REG_NA, srcRegNum, offset);
@@ -8041,7 +8094,7 @@ void CodeGen::genPutStructArgStk(GenTreePutArgStk* putArgStk)
             {
                 getEmitter()->emitIns_S(INS_push, slotAttr, srcLclNum, srcLclOffset + offset);
             }
-            genStackLevel += 4;
+            genStackLevel += TARGET_POINTER_SIZE;
         }
 #else // !defined(_TARGET_X86_)
 
diff --git a/src/jit/compiler.cpp b/src/jit/compiler.cpp
index bdf527f9e6..711f6ce56d 100644
--- a/src/jit/compiler.cpp
+++ b/src/jit/compiler.cpp
@@ -1639,12 +1639,12 @@ void Compiler::compDisplayStaticSizes(FILE* fout)
             sizeof(bbDummy->bbLiveIn));
     fprintf(fout, "Offset / size of bbLiveOut             = %3u / %3u\n", offsetof(BasicBlock, bbLiveOut),
             sizeof(bbDummy->bbLiveOut));
-    fprintf(fout, "Offset / size of bbHeapSsaPhiFunc      = %3u / %3u\n", offsetof(BasicBlock, bbHeapSsaPhiFunc),
-            sizeof(bbDummy->bbHeapSsaPhiFunc));
-    fprintf(fout, "Offset / size of bbHeapSsaNumIn        = %3u / %3u\n", offsetof(BasicBlock, bbHeapSsaNumIn),
-            sizeof(bbDummy->bbHeapSsaNumIn));
-    fprintf(fout, "Offset / size of bbHeapSsaNumOut       = %3u / %3u\n", offsetof(BasicBlock, bbHeapSsaNumOut),
-            sizeof(bbDummy->bbHeapSsaNumOut));
+    fprintf(fout, "Offset / size of bbMemorySsaPhiFunc      = %3u / %3u\n", offsetof(BasicBlock, bbMemorySsaPhiFunc),
+            sizeof(bbDummy->bbMemorySsaPhiFunc));
+    fprintf(fout, "Offset / size of bbMemorySsaNumIn        = %3u / %3u\n", offsetof(BasicBlock, bbMemorySsaNumIn),
+            sizeof(bbDummy->bbMemorySsaNumIn));
+    fprintf(fout, "Offset / size of bbMemorySsaNumOut       = %3u / %3u\n", offsetof(BasicBlock, bbMemorySsaNumOut),
+            sizeof(bbDummy->bbMemorySsaNumOut));
     fprintf(fout, "Offset / size of bbScope               = %3u / %3u\n", offsetof(BasicBlock, bbScope),
             sizeof(bbDummy->bbScope));
     fprintf(fout, "Offset / size of bbCseGen              = %3u / %3u\n", offsetof(BasicBlock, bbCseGen),
@@ -1786,9 +1786,9 @@ void Compiler::compInit(ArenaAllocator* pAlloc, InlineInfo* inlineInfo)
         impSpillCliquePredMembers = ExpandArray<BYTE>(getAllocator());
         impSpillCliqueSuccMembers = ExpandArray<BYTE>(getAllocator());
 
-        memset(&lvHeapPerSsaData, 0, sizeof(PerSsaArray));
-        lvHeapPerSsaData.Init(getAllocator());
-        lvHeapNumSsaNames = 0;
+        memset(&lvMemoryPerSsaData, 0, sizeof(PerSsaArray));
+        lvMemoryPerSsaData.Init(getAllocator());
+        lvMemoryNumSsaNames = 0;
 
         //
         // Initialize all the per-method statistics gathering data structures.
@@ -1869,8 +1869,11 @@ void Compiler::compInit(ArenaAllocator* pAlloc, InlineInfo* inlineInfo)
     m_fieldSeqStore      = nullptr;
     m_zeroOffsetFieldMap = nullptr;
     m_arrayInfoMap       = nullptr;
-    m_heapSsaMap         = nullptr;
     m_refAnyClass        = nullptr;
+    for (MemoryKind memoryKind : allMemoryKinds())
+    {
+        m_memorySsaMap[memoryKind] = nullptr;
+    }
 
 #ifdef DEBUG
     if (!compIsForInlining())
@@ -3028,13 +3031,31 @@ void Compiler::compInitOptions(JitFlags* jitFlags)
     setUsesSIMDTypes(false);
 #endif // FEATURE_SIMD
 
-    if (compIsForInlining() || compIsForImportOnly())
+    if (compIsForImportOnly())
+    {
+        return;
+    }
+
+#if FEATURE_TAILCALL_OPT
+    // By default opportunistic tail call optimization is enabled.
+    // Recognition is done in the importer so this must be set for
+    // inlinees as well.
+    opts.compTailCallOpt = true;
+#endif // FEATURE_TAILCALL_OPT
+
+    if (compIsForInlining())
     {
         return;
     }
+
     // The rest of the opts fields that we initialize here
     // should only be used when we generate code for the method
     // They should not be used when importing or inlining
+    CLANG_FORMAT_COMMENT_ANCHOR;
+
+#if FEATURE_TAILCALL_OPT
+    opts.compTailCallLoopOpt = true;
+#endif // FEATURE_TAILCALL_OPT
 
     opts.genFPorder = true;
     opts.genFPopt   = true;
@@ -3042,12 +3063,6 @@ void Compiler::compInitOptions(JitFlags* jitFlags)
     opts.instrCount = 0;
     opts.lvRefCount = 0;
 
-#if FEATURE_TAILCALL_OPT
-    // By default opportunistic tail call optimization is enabled
-    opts.compTailCallOpt     = true;
-    opts.compTailCallLoopOpt = true;
-#endif
-
 #ifdef PROFILING_SUPPORTED
     opts.compJitELTHookEnabled = false;
 #endif // PROFILING_SUPPORTED
@@ -4194,11 +4209,17 @@ void Compiler::compCompile(void** methodCodePtr, ULONG* methodCodeSize, JitFlags
     assert(!fgComputePredsDone);
     if (fgCheapPredsValid)
     {
-        // Remove cheap predecessors before inlining; allowing the cheap predecessor lists to be inserted
-        // with inlined blocks causes problems.
+        // Remove cheap predecessors before inlining and fat call transformation;
+        // allowing the cheap predecessor lists to be inserted causes problems
+        // with splitting existing blocks.
         fgRemovePreds();
     }
 
+    if (IsTargetAbi(CORINFO_CORERT_ABI) && doesMethodHaveFatPointer())
+    {
+        fgTransformFatCalli();
+    }
+
     EndPhase(PHASE_IMPORTATION);
 
     if (compIsForInlining())
@@ -4435,7 +4456,7 @@ void Compiler::compCompile(void** methodCodePtr, ULONG* methodCodeSize, JitFlags
         bool doRangeAnalysis = true;
         int  iterations      = 1;
 
-#ifdef DEBUG
+#if defined(OPT_CONFIG)
         doSsa           = (JitConfig.JitDoSsa() != 0);
         doEarlyProp     = doSsa && (JitConfig.JitDoEarlyProp() != 0);
         doValueNum      = doSsa && (JitConfig.JitDoValueNumber() != 0);
@@ -4448,7 +4469,7 @@ void Compiler::compCompile(void** methodCodePtr, ULONG* methodCodeSize, JitFlags
         {
             iterations = JitConfig.JitOptRepeatCount();
         }
-#endif
+#endif // defined(OPT_CONFIG)
 
         while (iterations > 0)
         {
@@ -6697,16 +6718,7 @@ Compiler::NodeToIntMap* Compiler::FindReachableNodesInNodeTestData()
                         if (arg->gtFlags & GTF_LATE_ARG)
                         {
                             // Find the corresponding late arg.
-                            GenTreePtr lateArg = nullptr;
-                            for (unsigned j = 0; j < call->fgArgInfo->ArgCount(); j++)
-                            {
-                                if (call->fgArgInfo->ArgTable()[j]->argNum == i)
-                                {
-                                    lateArg = call->fgArgInfo->ArgTable()[j]->node;
-                                    break;
-                                }
-                            }
-                            assert(lateArg != nullptr);
+                            GenTreePtr lateArg = call->fgArgInfo->GetLateArg(i);
                             if (GetNodeTestData()->Lookup(lateArg, &tlAndN))
                             {
                                 reachable->Set(lateArg, 0);
@@ -6794,14 +6806,14 @@ void Compiler::CopyTestDataToCloneTree(GenTreePtr from, GenTreePtr to)
             assert(to->gtOp.gtOp1 == nullptr);
         }
 
-        if (from->gtGetOp2() != nullptr)
+        if (from->gtGetOp2IfPresent() != nullptr)
         {
-            assert(to->gtGetOp2() != nullptr);
+            assert(to->gtGetOp2IfPresent() != nullptr);
             CopyTestDataToCloneTree(from->gtGetOp2(), to->gtGetOp2());
         }
         else
         {
-            assert(to->gtGetOp2() == nullptr);
+            assert(to->gtGetOp2IfPresent() == nullptr);
         }
 
         return;
@@ -7795,6 +7807,9 @@ void JitTimer::PrintCsvHeader()
     FILE* fp = _wfopen(jitTimeLogCsv, W("a"));
     if (fp != nullptr)
     {
+        // Seek to the end of the file s.t. `ftell` doesn't lie to us on Windows
+        fseek(fp, 0, SEEK_END);
+
         // Write the header if the file is empty
         if (ftell(fp) == 0)
         {
@@ -7812,6 +7827,9 @@ void JitTimer::PrintCsvHeader()
 
             InlineStrategy::DumpCsvHeader(fp);
 
+            fprintf(fp, "\"Executable Code Bytes\",");
+            fprintf(fp, "\"GC Info Bytes\",");
+            fprintf(fp, "\"Total Bytes Allocated\",");
             fprintf(fp, "\"Total Cycles\",");
             fprintf(fp, "\"CPS\"\n");
         }
@@ -7862,6 +7880,9 @@ void JitTimer::PrintCsvMethodStats(Compiler* comp)
 
     comp->m_inlineStrategy->DumpCsvData(fp);
 
+    fprintf(fp, "%Iu,", comp->info.compNativeCodeSize);
+    fprintf(fp, "%Iu,", comp->compInfoBlkSize);
+    fprintf(fp, "%Iu,", comp->compGetAllocator()->getTotalBytesAllocated());
     fprintf(fp, "%I64u,", m_info.m_totalCycles);
     fprintf(fp, "%f\n", CycleTimer::CyclesPerSecond());
     fclose(fp);
diff --git a/src/jit/compiler.h b/src/jit/compiler.h
index cce4dfb25b..7c5565c9c7 100644
--- a/src/jit/compiler.h
+++ b/src/jit/compiler.h
@@ -268,10 +268,6 @@ public:
     unsigned char lvDisqualify : 1;   // variable is no longer OK for add copy optimization
     unsigned char lvVolatileHint : 1; // hint for AssertionProp
 #endif
-#if FANCY_ARRAY_OPT
-    unsigned char lvAssignOne : 1; // assigned at least  once?
-    unsigned char lvAssignTwo : 1; // assigned at least twice?
-#endif
 
     unsigned char lvSpilled : 1; // enregistered variable was spilled
 #ifndef _TARGET_64BIT_
@@ -674,7 +670,7 @@ public:
 #endif // defined(_TARGET_64BIT_)
     }
 
-    unsigned lvSize() // Size needed for storage representation. Only used for structs or TYP_BLK.
+    unsigned lvSize() const // Size needed for storage representation. Only used for structs or TYP_BLK.
     {
         // TODO-Review: Sometimes we get called on ARM with HFA struct variables that have been promoted,
         // where the struct itself is no longer used because all access is via its member fields.
@@ -692,7 +688,8 @@ public:
 
 #if defined(FEATURE_SIMD) && !defined(_TARGET_64BIT_)
         // For 32-bit architectures, we make local variable SIMD12 types 16 bytes instead of just 12. We can't do
-        // this for arguments, which must be passed according the defined ABI.
+        // this for arguments, which must be passed according the defined ABI. We don't want to do this for
+        // dependently promoted struct fields, but we don't know that here. See lvaMapSimd12ToSimd16().
         if ((lvType == TYP_SIMD12) && !lvIsParam)
         {
             assert(lvExactSize == 12);
@@ -709,10 +706,6 @@ public:
 
     BYTE* lvGcLayout; // GC layout info for structs
 
-#if FANCY_ARRAY_OPT
-    GenTreePtr lvKnownDim; // array size if known
-#endif
-
 #if ASSERTION_PROP
     BlockSet   lvRefBlks;          // Set of blocks that contain refs
     GenTreePtr lvDefStmt;          // Pointer to the statement with the single definition
@@ -1193,6 +1186,11 @@ struct fgArgTabEntry
     unsigned alignment;  // 1 or 2 (slots/registers)
     unsigned lateArgInx; // index into gtCallLateArgs list
     unsigned tmpNum;     // the LclVar number if we had to force evaluation of this arg
+#if defined(UNIX_X86_ABI)
+    unsigned padStkAlign; // Count of number of padding slots for stack alignment. For each Call, only the first
+                          // argument may have a value to emit "sub esp, n" to adjust the stack before pushing
+                          // the argument.
+#endif
 
     bool isSplit : 1;       // True when this argument is split between the registers and OutArg area
     bool needTmp : 1;       // True when we force this argument's evaluation into a temp LclVar
@@ -1270,6 +1268,10 @@ class fgArgInfo
     unsigned   argCount;    // Updatable arg count value
     unsigned   nextSlotNum; // Updatable slot count value
     unsigned   stkLevel;    // Stack depth when we make this call (for x86)
+#if defined(UNIX_X86_ABI)
+    unsigned padStkAlign; // Count of number of padding slots for stack alignment. This value is used to turn back
+                          // stack pointer before it was adjusted after each Call
+#endif
 
     unsigned          argTableSize; // size of argTable array (equal to the argCount when done with fgMorphArgs)
     bool              hasRegArgs;   // true if we have one or more register arguments
@@ -1319,6 +1321,10 @@ public:
 
     void ArgsComplete();
 
+#if defined(UNIX_X86_ABI)
+    void ArgsAlignPadding();
+#endif
+
     void SortArgs();
 
     void EvalArgsToTemps();
@@ -1338,6 +1344,12 @@ public:
     {
         return nextSlotNum;
     }
+#if defined(UNIX_X86_ABI)
+    unsigned GetPadStackAlign()
+    {
+        return padStkAlign;
+    }
+#endif
     bool HasRegArgs()
     {
         return hasRegArgs;
@@ -1350,6 +1362,9 @@ public:
     {
         return argsComplete;
     }
+
+    // Get the late arg for arg at position argIndex.  Caller must ensure this position has a late arg.
+    GenTreePtr GetLateArg(unsigned argIndex);
 };
 
 #ifdef DEBUG
@@ -1988,6 +2003,7 @@ public:
                                SIMDIntrinsicID simdIntrinsicID,
                                var_types       baseType,
                                unsigned        size);
+    void SetOpLclRelatedToSIMDIntrinsic(GenTreePtr op);
 #endif
 
     GenTreePtr gtNewLclLNode(unsigned lnum, var_types type, IL_OFFSETX ILoffs = BAD_IL_OFFSET);
@@ -2660,6 +2676,35 @@ public:
     bool lvaIsFieldOfDependentlyPromotedStruct(const LclVarDsc* varDsc);
     bool lvaIsGCTracked(const LclVarDsc* varDsc);
 
+#if defined(FEATURE_SIMD)
+    bool lvaMapSimd12ToSimd16(const LclVarDsc* varDsc)
+    {
+        assert(varDsc->lvType == TYP_SIMD12);
+        assert(varDsc->lvExactSize == 12);
+
+#if defined(_TARGET_64BIT_)
+        assert(varDsc->lvSize() == 16);
+        return true;
+#else // !defined(_TARGET_64BIT_)
+
+        // For 32-bit architectures, we make local variable SIMD12 types 16 bytes instead of just 12. lvSize()
+        // already does this calculation. However, we also need to prevent mapping types if the var is a
+        // depenendently promoted struct field, which must remain its exact size within its parent struct.
+        // However, we don't know this until late, so we may have already pretended the field is bigger
+        // before that.
+        if ((varDsc->lvSize() == 16) && !lvaIsFieldOfDependentlyPromotedStruct(varDsc))
+        {
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+
+#endif // !defined(_TARGET_64BIT_)
+    }
+#endif // defined(FEATURE_SIMD)
+
     BYTE* lvaGetGcLayout(unsigned varNum);
     bool lvaTypeIsGC(unsigned varNum);
     unsigned lvaGSSecurityCookie; // LclVar number
@@ -2704,21 +2749,21 @@ protected:
     static fgWalkPreFn lvaMarkLclRefsCallback;
     void lvaMarkLclRefs(GenTreePtr tree);
 
-    // Keeps the mapping from SSA #'s to VN's for the implicit "Heap" variable.
-    PerSsaArray lvHeapPerSsaData;
-    unsigned    lvHeapNumSsaNames;
+    // Keeps the mapping from SSA #'s to VN's for the implicit memory variables.
+    PerSsaArray lvMemoryPerSsaData;
+    unsigned    lvMemoryNumSsaNames;
 
 public:
-    // Returns the address of the per-Ssa data for "Heap" at the given ssaNum (which is required
+    // Returns the address of the per-Ssa data for memory at the given ssaNum (which is required
     // not to be the SsaConfig::RESERVED_SSA_NUM, which indicates that the variable is
     // not an SSA variable).
-    LclSsaVarDsc* GetHeapPerSsaData(unsigned ssaNum)
+    LclSsaVarDsc* GetMemoryPerSsaData(unsigned ssaNum)
     {
         assert(ssaNum != SsaConfig::RESERVED_SSA_NUM);
         assert(SsaConfig::RESERVED_SSA_NUM == 0);
         ssaNum--;
-        assert(ssaNum < lvHeapNumSsaNames);
-        return &lvHeapPerSsaData.GetRef(ssaNum);
+        assert(ssaNum < lvMemoryNumSsaNames);
+        return &lvMemoryPerSsaData.GetRef(ssaNum);
     }
 
     /*
@@ -3433,6 +3478,7 @@ public:
     bool fgComputePredsDone; // Have we computed the bbPreds list
     bool fgCheapPredsValid;  // Is the bbCheapPreds list valid?
     bool fgDomsComputed;     // Have we computed the dominator sets?
+    bool fgOptimizedFinally; // Did we optimize any try-finallys?
 
     bool     fgHasSwitch;  // any BBJ_SWITCH jumps?
     bool     fgHasPostfix; // any postfix ++/-- found?
@@ -3501,12 +3547,20 @@ public:
 
     void fgImport();
 
+    void fgTransformFatCalli();
+
     void fgInline();
 
+    void fgRemoveEmptyTry();
+
     void fgRemoveEmptyFinally();
 
     void fgCloneFinally();
 
+    void fgCleanupContinuation(BasicBlock* continuation);
+
+    void fgUpdateFinallyTargetFlags();
+
     GenTreePtr fgGetCritSectOfStaticMethod();
 
 #if !defined(_TARGET_X86_)
@@ -3752,18 +3806,18 @@ public:
     // tree node).
     void fgValueNumber();
 
-    // Updates "fgCurHeap" via the assignment H[elemTypeEq][arrVN][inx][fldSeq] = rhsVN.
+    // Computes new GcHeap VN via the assignment H[elemTypeEq][arrVN][inx][fldSeq] = rhsVN.
     // Assumes that "elemTypeEq" is the (equivalence class rep) of the array element type.
     // The 'indType' is the indirection type of the lhs of the assignment and will typically
     // match the element type of the array or fldSeq.  When this type doesn't match
     // or if the fldSeq is 'NotAField' we invalidate the array contents H[elemTypeEq][arrVN]
     //
-    void fgValueNumberArrIndexAssign(CORINFO_CLASS_HANDLE elemTypeEq,
-                                     ValueNum             arrVN,
-                                     ValueNum             inxVN,
-                                     FieldSeqNode*        fldSeq,
-                                     ValueNum             rhsVN,
-                                     var_types            indType);
+    ValueNum fgValueNumberArrIndexAssign(CORINFO_CLASS_HANDLE elemTypeEq,
+                                         ValueNum             arrVN,
+                                         ValueNum             inxVN,
+                                         FieldSeqNode*        fldSeq,
+                                         ValueNum             rhsVN,
+                                         var_types            indType);
 
     // Requires that "tree" is a GT_IND marked as an array index, and that its address argument
     // has been parsed to yield the other input arguments.  If evaluation of the address
@@ -3783,10 +3837,13 @@ public:
 
     // Requires "funcApp" to be a VNF_PtrToArrElem, and "addrXvn" to represent the exception set thrown
     // by evaluating the array index expression "tree".  Returns the value number resulting from
-    // dereferencing the array in the current heap state.  If "tree" is non-null, it must be the
+    // dereferencing the array in the current GcHeap state.  If "tree" is non-null, it must be the
     // "GT_IND" that does the dereference, and it is given the returned value number.
     ValueNum fgValueNumberArrIndexVal(GenTreePtr tree, struct VNFuncApp* funcApp, ValueNum addrXvn);
 
+    // Compute the value number for a byref-exposed load of the given type via the given pointerVN.
+    ValueNum fgValueNumberByrefExposedLoad(var_types type, ValueNum pointerVN);
+
     unsigned fgVNPassesCompleted; // Number of times fgValueNumber has been run.
 
     // Utility functions for fgValueNumber.
@@ -3796,15 +3853,27 @@ public:
 
     // Requires that "entryBlock" is the entry block of loop "loopNum", and that "loopNum" is the
     // innermost loop of which "entryBlock" is the entry.  Returns the value number that should be
-    // assumed for the heap at the start "entryBlk".
-    ValueNum fgHeapVNForLoopSideEffects(BasicBlock* entryBlock, unsigned loopNum);
+    // assumed for the memoryKind at the start "entryBlk".
+    ValueNum fgMemoryVNForLoopSideEffects(MemoryKind memoryKind, BasicBlock* entryBlock, unsigned loopNum);
+
+    // Called when an operation (performed by "tree", described by "msg") may cause the GcHeap to be mutated.
+    // As GcHeap is a subset of ByrefExposed, this will also annotate the ByrefExposed mutation.
+    void fgMutateGcHeap(GenTreePtr tree DEBUGARG(const char* msg));
+
+    // Called when an operation (performed by "tree", described by "msg") may cause an address-exposed local to be
+    // mutated.
+    void fgMutateAddressExposedLocal(GenTreePtr tree DEBUGARG(const char* msg));
+
+    // For a GC heap store at curTree, record the new curMemoryVN's and update curTree's MemorySsaMap.
+    // As GcHeap is a subset of ByrefExposed, this will also record the ByrefExposed store.
+    void recordGcHeapStore(GenTreePtr curTree, ValueNum gcHeapVN DEBUGARG(const char* msg));
 
-    // Called when an operation (performed by "tree", described by "msg") may cause the global Heap to be mutated.
-    void fgMutateHeap(GenTreePtr tree DEBUGARG(const char* msg));
+    // For a store to an address-exposed local at curTree, record the new curMemoryVN and update curTree's MemorySsaMap.
+    void recordAddressExposedLocalStore(GenTreePtr curTree, ValueNum memoryVN DEBUGARG(const char* msg));
 
-    // Tree caused an update in the current heap VN.  If "tree" has an associated heap SSA #, record that
+    // Tree caused an update in the current memory VN.  If "tree" has an associated heap SSA #, record that
     // value in that SSA #.
-    void fgValueNumberRecordHeapSsa(GenTreePtr tree);
+    void fgValueNumberRecordMemorySsa(MemoryKind memoryKind, GenTreePtr tree);
 
     // The input 'tree' is a leaf node that is a constant
     // Assign the proper value number to the tree
@@ -3843,11 +3912,11 @@ public:
     // Requires "helpFunc" to be pure.  Returns the corresponding VNFunc.
     VNFunc fgValueNumberHelperMethVNFunc(CorInfoHelpFunc helpFunc);
 
-    // This is the current value number for the "Heap" implicit variable while
-    // doing value numbering.  This is the value number under the "liberal" interpretation
-    // of heap values; the "conservative" interpretation needs no VN, since every access of
-    // the heap yields an unknown value.
-    ValueNum fgCurHeapVN;
+    // These are the current value number for the memory implicit variables while
+    // doing value numbering.  These are the value numbers under the "liberal" interpretation
+    // of memory values; the "conservative" interpretation needs no VN, since every access of
+    // memory yields an unknown value.
+    ValueNum fgCurMemoryVN[MemoryKindCount];
 
     // Return a "pseudo"-class handle for an array element type.  If "elemType" is TYP_STRUCT,
     // requires "elemStructType" to be non-null (and to have a low-order zero).  Otherwise, low order bit
@@ -4531,7 +4600,6 @@ private:
     static MorphAddrContext s_CopyBlockMAC;
 
 #ifdef FEATURE_SIMD
-    GenTreePtr fgCopySIMDNode(GenTreeSIMD* simdNode);
     GenTreePtr getSIMDStructFromField(GenTreePtr tree,
                                       var_types* baseTypeOut,
                                       unsigned*  indexOut,
@@ -4620,9 +4688,11 @@ private:
     VARSET_TP fgCurUseSet; // vars used     by block (before an assignment)
     VARSET_TP fgCurDefSet; // vars assigned by block (before a use)
 
-    bool fgCurHeapUse;   // True iff the current basic block uses the heap before defining it.
-    bool fgCurHeapDef;   // True iff the current basic block defines the heap.
-    bool fgCurHeapHavoc; // True if  the current basic block is known to set the heap to a "havoc" value.
+    MemoryKindSet fgCurMemoryUse;   // True iff the current basic block uses memory.
+    MemoryKindSet fgCurMemoryDef;   // True iff the current basic block modifies memory.
+    MemoryKindSet fgCurMemoryHavoc; // True if  the current basic block is known to set memory to a "havoc" value.
+
+    bool byrefStatesMatchGcHeapStates; // True iff GcHeap and ByrefExposed memory have all the same def points.
 
     void fgMarkUseDef(GenTreeLclVarCommon* tree);
 
@@ -4693,6 +4763,9 @@ private:
 
 #ifdef DEBUG
     static fgWalkPreFn fgDebugCheckInlineCandidates;
+
+    void               CheckNoFatPointerCandidatesLeft();
+    static fgWalkPreFn fgDebugCheckFatPointerCandidates;
 #endif
 
     void         fgPromoteStructs();
@@ -4975,9 +5048,10 @@ public:
 #define LPFLG_ASGVARS_INC 0x8000 // "lpAsgVars" is incomplete -- vars beyond those representable in an AllVarSet
                                  // type are assigned to.
 
-        bool lpLoopHasHeapHavoc; // The loop contains an operation that we assume has arbitrary heap side effects.
-                                 // If this is set, the fields below may not be accurate (since they become irrelevant.)
-        bool lpContainsCall;     // True if executing the loop body *may* execute a call
+        bool lpLoopHasMemoryHavoc[MemoryKindCount]; // The loop contains an operation that we assume has arbitrary
+                                                    // memory side effects.  If this is set, the fields below
+                                                    // may not be accurate (since they become irrelevant.)
+        bool lpContainsCall;                        // True if executing the loop body *may* execute a call
 
         VARSET_TP lpVarInOut;  // The set of variables that are IN or OUT during the execution of this loop
         VARSET_TP lpVarUseDef; // The set of variables that are USE or DEF during the execution of this loop
@@ -5314,6 +5388,9 @@ protected:
 
         treeStmtLstPtr csdTreeList; // list of matching tree nodes: head
         treeStmtLstPtr csdTreeLast; // list of matching tree nodes: tail
+
+        ValueNum defConservativeVN; // if all def occurrences share the same conservative value
+                                    // number, this will reflect it; otherwise, NoVN.
     };
 
     static const size_t s_optCSEhashSize;
@@ -5469,11 +5546,27 @@ public:
         }
     };
 
-#define OMF_HAS_NEWARRAY 0x00000001  // Method contains 'new' of an array
-#define OMF_HAS_NEWOBJ 0x00000002    // Method contains 'new' of an object type.
-#define OMF_HAS_ARRAYREF 0x00000004  // Method contains array element loads or stores.
-#define OMF_HAS_VTABLEREF 0x00000008 // Method contains method table reference.
-#define OMF_HAS_NULLCHECK 0x00000010 // Method contains null check.
+#define OMF_HAS_NEWARRAY 0x00000001   // Method contains 'new' of an array
+#define OMF_HAS_NEWOBJ 0x00000002     // Method contains 'new' of an object type.
+#define OMF_HAS_ARRAYREF 0x00000004   // Method contains array element loads or stores.
+#define OMF_HAS_VTABLEREF 0x00000008  // Method contains method table reference.
+#define OMF_HAS_NULLCHECK 0x00000010  // Method contains null check.
+#define OMF_HAS_FATPOINTER 0x00000020 // Method contains call, that needs fat pointer transformation.
+
+    bool doesMethodHaveFatPointer()
+    {
+        return (optMethodFlags & OMF_HAS_FATPOINTER) != 0;
+    }
+
+    void setMethodHasFatPointer()
+    {
+        optMethodFlags |= OMF_HAS_FATPOINTER;
+    }
+
+    void clearMethodHasFatPointer()
+    {
+        optMethodFlags &= ~OMF_HAS_FATPOINTER;
+    }
 
     unsigned optMethodFlags;
 
@@ -5938,10 +6031,6 @@ protected:
     ssize_t optGetArrayRefScaleAndIndex(GenTreePtr mul, GenTreePtr* pIndex DEBUGARG(bool bRngChk));
     GenTreePtr optFindLocalInit(BasicBlock* block, GenTreePtr local, VARSET_TP* pKilledInOut, bool* isKilledAfterInit);
 
-#if FANCY_ARRAY_OPT
-    bool optIsNoMore(GenTreePtr op1, GenTreePtr op2, int add1 = 0, int add2 = 0);
-#endif
-
     bool optReachWithoutCall(BasicBlock* srcBB, BasicBlock* dstBB);
 
 protected:
@@ -7701,8 +7790,11 @@ public:
         bool genFPopt;   // Can we do frame-pointer-omission optimization?
         bool altJit;     // True if we are an altjit and are compiling this method
 
+#ifdef OPT_CONFIG
+        bool optRepeat; // Repeat optimizer phases k times
+#endif
+
 #ifdef DEBUG
-        bool optRepeat;                // Repeat optimizer phases k times
         bool compProcedureSplittingEH; // Separate cold code from hot code for functions with EH
         bool dspCode;                  // Display native code generated
         bool dspEHTable;               // Display the EH table reported to the VM
@@ -7810,11 +7902,22 @@ public:
         /* These should not be exhaustively used as they might */                               \
         /* hide/trivialize other areas */                                                       \
                                                                                                 \
-        STRESS_MODE(REGS) STRESS_MODE(DBL_ALN) STRESS_MODE(LCL_FLDS) STRESS_MODE(UNROLL_LOOPS)  \
-        STRESS_MODE(MAKE_CSE) STRESS_MODE(LEGACY_INLINE) STRESS_MODE(CLONE_EXPR)                \
-        STRESS_MODE(USE_FCOMI) STRESS_MODE(USE_CMOV) STRESS_MODE(FOLD)                          \
-        STRESS_MODE(BB_PROFILE) STRESS_MODE(OPT_BOOLS_GC) STRESS_MODE(REMORPH_TREES)            \
-        STRESS_MODE(64RSLT_MUL) STRESS_MODE(DO_WHILE_LOOPS) STRESS_MODE(MIN_OPTS)               \
+        STRESS_MODE(REGS)                                                                       \
+        STRESS_MODE(DBL_ALN)                                                                    \
+        STRESS_MODE(LCL_FLDS)                                                                   \
+        STRESS_MODE(UNROLL_LOOPS)                                                               \
+        STRESS_MODE(MAKE_CSE)                                                                   \
+        STRESS_MODE(LEGACY_INLINE)                                                              \
+        STRESS_MODE(CLONE_EXPR)                                                                 \
+        STRESS_MODE(USE_FCOMI)                                                                  \
+        STRESS_MODE(USE_CMOV)                                                                   \
+        STRESS_MODE(FOLD)                                                                       \
+        STRESS_MODE(BB_PROFILE)                                                                 \
+        STRESS_MODE(OPT_BOOLS_GC)                                                               \
+        STRESS_MODE(REMORPH_TREES)                                                              \
+        STRESS_MODE(64RSLT_MUL)                                                                 \
+        STRESS_MODE(DO_WHILE_LOOPS)                                                             \
+        STRESS_MODE(MIN_OPTS)                                                                   \
         STRESS_MODE(REVERSE_FLAG)     /* Will set GTF_REVERSE_OPS whenever we can */            \
         STRESS_MODE(REVERSE_COMMA)    /* Will reverse commas created  with gtNewCommaNode */    \
         STRESS_MODE(TAILCALL)         /* Will make the call as a tailcall whenever legal */     \
@@ -7823,17 +7926,23 @@ public:
         STRESS_MODE(NULL_OBJECT_CHECK)                                                          \
         STRESS_MODE(PINVOKE_RESTORE_ESP)                                                        \
         STRESS_MODE(RANDOM_INLINE)                                                              \
+        STRESS_MODE(SWITCH_CMP_BR_EXPANSION)                                                    \
+        STRESS_MODE(GENERIC_VARN)                                                               \
                                                                                                 \
-        STRESS_MODE(GENERIC_VARN) STRESS_MODE(COUNT_VARN)                                       \
+        /* After COUNT_VARN, stress level 2 does all of these all the time */                   \
+                                                                                                \
+        STRESS_MODE(COUNT_VARN)                                                                 \
                                                                                                 \
         /* "Check" stress areas that can be exhaustively used if we */                          \
         /*  dont care about performance at all */                                               \
                                                                                                 \
         STRESS_MODE(FORCE_INLINE) /* Treat every method as AggressiveInlining */                \
         STRESS_MODE(CHK_FLOW_UPDATE)                                                            \
-        STRESS_MODE(EMITTER) STRESS_MODE(CHK_REIMPORT) STRESS_MODE(FLATFP)                      \
-                                                                                                \
-        STRESS_MODE(GENERIC_CHECK) STRESS_MODE(COUNT)                                           \
+        STRESS_MODE(EMITTER)                                                                    \
+        STRESS_MODE(CHK_REIMPORT)                                                               \
+        STRESS_MODE(FLATFP)                                                                     \
+        STRESS_MODE(GENERIC_CHECK)                                                              \
+        STRESS_MODE(COUNT)
 
     enum                compStressArea
     {
@@ -8978,21 +9087,28 @@ public:
         return compRoot->m_arrayInfoMap;
     }
 
-    NodeToUnsignedMap* m_heapSsaMap;
+    NodeToUnsignedMap* m_memorySsaMap[MemoryKindCount];
 
-    // In some cases, we want to assign intermediate SSA #'s to heap states, and know what nodes create those heap
-    // states. (We do this for try blocks, where, if the try block doesn't do a call that loses track of the heap state,
-    // all the possible heap states are possible initial states of the corresponding catch block(s).)
-    NodeToUnsignedMap* GetHeapSsaMap()
+    // In some cases, we want to assign intermediate SSA #'s to memory states, and know what nodes create those memory
+    // states. (We do this for try blocks, where, if the try block doesn't do a call that loses track of the memory
+    // state, all the possible memory states are possible initial states of the corresponding catch block(s).)
+    NodeToUnsignedMap* GetMemorySsaMap(MemoryKind memoryKind)
     {
+        if (memoryKind == GcHeap && byrefStatesMatchGcHeapStates)
+        {
+            // Use the same map for GCHeap and ByrefExposed when their states match.
+            memoryKind = ByrefExposed;
+        }
+
+        assert(memoryKind < MemoryKindCount);
         Compiler* compRoot = impInlineRoot();
-        if (compRoot->m_heapSsaMap == nullptr)
+        if (compRoot->m_memorySsaMap[memoryKind] == nullptr)
         {
             // Create a CompAllocator that labels sub-structure with CMK_ArrayInfoMap, and use that for allocation.
-            IAllocator* ialloc     = new (this, CMK_ArrayInfoMap) CompAllocator(this, CMK_ArrayInfoMap);
-            compRoot->m_heapSsaMap = new (ialloc) NodeToUnsignedMap(ialloc);
+            IAllocator* ialloc                   = new (this, CMK_ArrayInfoMap) CompAllocator(this, CMK_ArrayInfoMap);
+            compRoot->m_memorySsaMap[memoryKind] = new (ialloc) NodeToUnsignedMap(ialloc);
         }
-        return compRoot->m_heapSsaMap;
+        return compRoot->m_memorySsaMap[memoryKind];
     }
 
     // The Refany type is the only struct type whose structure is implicitly assumed by IL.  We need its fields.
diff --git a/src/jit/compiler.hpp b/src/jit/compiler.hpp
index ca9da82321..6baf601892 100644
--- a/src/jit/compiler.hpp
+++ b/src/jit/compiler.hpp
@@ -4687,10 +4687,10 @@ inline void BasicBlock::InitVarSets(Compiler* comp)
     VarSetOps::AssignNoCopy(comp, bbLiveOut, VarSetOps::MakeEmpty(comp));
     VarSetOps::AssignNoCopy(comp, bbScope, VarSetOps::MakeEmpty(comp));
 
-    bbHeapUse     = false;
-    bbHeapDef     = false;
-    bbHeapLiveIn  = false;
-    bbHeapLiveOut = false;
+    bbMemoryUse     = emptyMemoryKindSet;
+    bbMemoryDef     = emptyMemoryKindSet;
+    bbMemoryLiveIn  = emptyMemoryKindSet;
+    bbMemoryLiveOut = emptyMemoryKindSet;
 }
 
 // Returns true if the basic block ends with GT_JMP
diff --git a/src/jit/compmemkind.h b/src/jit/compmemkind.h
index e27d2071f7..b22bf6de1e 100644
--- a/src/jit/compmemkind.h
+++ b/src/jit/compmemkind.h
@@ -39,7 +39,7 @@ CompMemKindMacro(IndirAssignMap)
 CompMemKindMacro(FieldSeqStore)
 CompMemKindMacro(ZeroOffsetFieldMap)
 CompMemKindMacro(ArrayInfoMap)
-CompMemKindMacro(HeapPhiArg)
+CompMemKindMacro(MemoryPhiArg)
 CompMemKindMacro(CSE)
 CompMemKindMacro(GC)
 CompMemKindMacro(CorSig)
diff --git a/src/jit/compphases.h b/src/jit/compphases.h
index 655170f406..5038d6e9c9 100644
--- a/src/jit/compphases.h
+++ b/src/jit/compphases.h
@@ -26,6 +26,9 @@ CompPhaseNameMacro(PHASE_POST_IMPORT,            "Post-import",
 CompPhaseNameMacro(PHASE_MORPH_INIT,             "Morph - Init",                   "MOR-INIT" ,false, -1)
 CompPhaseNameMacro(PHASE_MORPH_INLINE,           "Morph - Inlining",               "MOR-INL",  false, -1)
 CompPhaseNameMacro(PHASE_MORPH_IMPBYREF,         "Morph - ByRefs",                 "MOR-BYREF",false, -1)
+CompPhaseNameMacro(PHASE_EMPTY_TRY,              "Remove empty try",               "EMPTYTRY", false, -1)
+CompPhaseNameMacro(PHASE_EMPTY_FINALLY,          "Remove empty finally",           "EMPTYFIN", false, -1)
+CompPhaseNameMacro(PHASE_CLONE_FINALLY,          "Clone finally",                  "CLONEFIN", false, -1)
 CompPhaseNameMacro(PHASE_STR_ADRLCL,             "Morph - Structs/AddrExp",        "MOR-STRAL",false, -1)
 CompPhaseNameMacro(PHASE_MORPH_GLOBAL,           "Morph - Global",                 "MOR-GLOB", false, -1)
 CompPhaseNameMacro(PHASE_MORPH_END,              "Morph - Finish",                 "MOR-END",  false, -1)
@@ -98,9 +101,6 @@ CompPhaseNameMacro(PHASE_EMIT_GCEH,              "Emit GC+EH tables",
 // for calls through ICorJitInfo across all "real" phases.
 CompPhaseNameMacro(PHASE_CLR_API,                "CLR API calls",                  "CLR-API",  false, -1)
 #endif
-
-CompPhaseNameMacro(PHASE_EMPTY_FINALLY,          "Remove empty finally",           "EMPTYFIN",  false, -1)
-CompPhaseNameMacro(PHASE_CLONE_FINALLY,          "Clone finally",                  "CLONEFIN",  false, -1)
 // clang-format on
 
 #undef CompPhaseNameMacro
diff --git a/src/jit/decomposelongs.cpp b/src/jit/decomposelongs.cpp
index 2716631abc..407ae1c35b 100644
--- a/src/jit/decomposelongs.cpp
+++ b/src/jit/decomposelongs.cpp
@@ -249,6 +249,12 @@ GenTree* DecomposeLongs::DecomposeNode(GenTree* tree)
             nextNode = DecomposeRotate(use);
             break;
 
+#ifdef FEATURE_SIMD
+        case GT_SIMD:
+            nextNode = DecomposeSimd(use);
+            break;
+#endif // FEATURE_SIMD
+
         case GT_LOCKADD:
         case GT_XADD:
         case GT_XCHG:
@@ -1562,6 +1568,163 @@ GenTree* DecomposeLongs::DecomposeUMod(LIR::Use& use)
     return FinalizeDecomposition(use, loResult, hiResult, hiResult);
 }
 
+#ifdef FEATURE_SIMD
+
+//------------------------------------------------------------------------
+// DecomposeSimd: Decompose GT_SIMD.
+//
+// Arguments:
+//    use - the LIR::Use object for the def that needs to be decomposed.
+//
+// Return Value:
+//    The next node to process.
+//
+GenTree* DecomposeLongs::DecomposeSimd(LIR::Use& use)
+{
+    GenTree*   tree = use.Def();
+    genTreeOps oper = tree->OperGet();
+
+    assert(oper == GT_SIMD);
+
+    GenTreeSIMD* simdTree = tree->AsSIMD();
+
+    switch (simdTree->gtSIMDIntrinsicID)
+    {
+        case SIMDIntrinsicGetItem:
+            return DecomposeSimdGetItem(use);
+
+        default:
+            noway_assert(!"unexpected GT_SIMD node in long decomposition");
+            break;
+    }
+
+    return nullptr;
+}
+
+//------------------------------------------------------------------------
+// DecomposeSimdGetItem: Decompose GT_SIMD -- SIMDIntrinsicGetItem.
+//
+// Decompose a get[i] node on Vector<long>. For:
+//
+// GT_SIMD{get_item}[long](simd_var, index)
+//
+// create:
+//
+// tmp_simd_var = simd_var
+// tmp_index = index
+// loResult = GT_SIMD{get_item}[int](tmp_simd_var, tmp_index * 2)
+// hiResult = GT_SIMD{get_item}[int](tmp_simd_var, tmp_index * 2 + 1)
+// return: GT_LONG(loResult, hiResult)
+//
+// This isn't optimal codegen, since SIMDIntrinsicGetItem sometimes requires
+// temps that could be shared, for example.
+//
+// Arguments:
+//    use - the LIR::Use object for the def that needs to be decomposed.
+//
+// Return Value:
+//    The next node to process.
+//
+GenTree* DecomposeLongs::DecomposeSimdGetItem(LIR::Use& use)
+{
+    GenTree*   tree = use.Def();
+    genTreeOps oper = tree->OperGet();
+
+    assert(oper == GT_SIMD);
+
+    GenTreeSIMD* simdTree = tree->AsSIMD();
+    var_types    baseType = simdTree->gtSIMDBaseType;
+    unsigned     simdSize = simdTree->gtSIMDSize;
+
+    assert(simdTree->gtSIMDIntrinsicID == SIMDIntrinsicGetItem);
+    assert(varTypeIsLong(baseType));
+    assert(varTypeIsLong(simdTree));
+    assert(varTypeIsSIMD(simdTree->gtOp.gtOp1->gtType));
+    assert(simdTree->gtOp.gtOp2->gtType == TYP_INT);
+
+    bool    indexIsConst = simdTree->gtOp.gtOp2->IsCnsIntOrI();
+    ssize_t index        = 0;
+    if (indexIsConst)
+    {
+        index = simdTree->gtOp.gtOp2->gtIntCon.gtIconVal;
+    }
+
+    LIR::Use op1(Range(), &simdTree->gtOp.gtOp1, simdTree);
+    unsigned simdTmpVarNum = op1.ReplaceWithLclVar(m_compiler, m_blockWeight);
+    JITDUMP("[DecomposeSimdGetItem]: Saving op1 tree to a temp var:\n");
+    DISPTREERANGE(Range(), op1.Def());
+
+    unsigned indexTmpVarNum = 0;
+    if (!indexIsConst)
+    {
+        LIR::Use op2(Range(), &simdTree->gtOp.gtOp2, simdTree);
+        indexTmpVarNum = op2.ReplaceWithLclVar(m_compiler, m_blockWeight);
+        JITDUMP("[DecomposeSimdGetItem]: Saving op2 tree to a temp var:\n");
+        DISPTREERANGE(Range(), op2.Def());
+    }
+
+    // Create:
+    //      loResult = GT_SIMD{get_item}[int](tmp_simd_var, index * 2)
+
+    GenTree* simdTmpVar1 = m_compiler->gtNewLclLNode(simdTmpVarNum, simdTree->gtOp.gtOp1->gtType);
+    GenTree* indexTimesTwo1;
+
+    if (indexIsConst)
+    {
+        // Reuse the existing index constant node.
+        indexTimesTwo1 = simdTree->gtOp.gtOp2;
+        Range().Remove(indexTimesTwo1);
+        indexTimesTwo1->gtIntCon.gtIconVal = index * 2;
+
+        Range().InsertBefore(simdTree, simdTmpVar1, indexTimesTwo1);
+    }
+    else
+    {
+        GenTree* indexTmpVar1 = m_compiler->gtNewLclLNode(indexTmpVarNum, TYP_INT);
+        GenTree* two1         = m_compiler->gtNewIconNode(2, TYP_INT);
+        indexTimesTwo1        = m_compiler->gtNewOperNode(GT_MUL, TYP_INT, indexTmpVar1, two1);
+        Range().InsertBefore(simdTree, simdTmpVar1, indexTmpVar1, two1, indexTimesTwo1);
+    }
+
+    GenTree* loResult =
+        m_compiler->gtNewSIMDNode(TYP_INT, simdTmpVar1, indexTimesTwo1, SIMDIntrinsicGetItem, TYP_INT, simdSize);
+    Range().InsertBefore(simdTree, loResult);
+
+    // Create:
+    //      hiResult = GT_SIMD{get_item}[int](tmp_simd_var, index * 2 + 1)
+
+    GenTree* simdTmpVar2 = m_compiler->gtNewLclLNode(simdTmpVarNum, simdTree->gtOp.gtOp1->gtType);
+    GenTree* indexTimesTwoPlusOne;
+
+    if (indexIsConst)
+    {
+        indexTimesTwoPlusOne = m_compiler->gtNewIconNode(index * 2 + 1, TYP_INT);
+        Range().InsertBefore(simdTree, simdTmpVar2, indexTimesTwoPlusOne);
+    }
+    else
+    {
+        GenTree* indexTmpVar2   = m_compiler->gtNewLclLNode(indexTmpVarNum, TYP_INT);
+        GenTree* two2           = m_compiler->gtNewIconNode(2, TYP_INT);
+        GenTree* indexTimesTwo2 = m_compiler->gtNewOperNode(GT_MUL, TYP_INT, indexTmpVar2, two2);
+        GenTree* one            = m_compiler->gtNewIconNode(1, TYP_INT);
+        indexTimesTwoPlusOne    = m_compiler->gtNewOperNode(GT_ADD, TYP_INT, indexTimesTwo2, one);
+        Range().InsertBefore(simdTree, simdTmpVar2, indexTmpVar2, two2, indexTimesTwo2);
+        Range().InsertBefore(simdTree, one, indexTimesTwoPlusOne);
+    }
+
+    GenTree* hiResult =
+        m_compiler->gtNewSIMDNode(TYP_INT, simdTmpVar2, indexTimesTwoPlusOne, SIMDIntrinsicGetItem, TYP_INT, simdSize);
+    Range().InsertBefore(simdTree, hiResult);
+
+    // Done with the original tree; remove it.
+
+    Range().Remove(simdTree);
+
+    return FinalizeDecomposition(use, loResult, hiResult, hiResult);
+}
+
+#endif // FEATURE_SIMD
+
 //------------------------------------------------------------------------
 // StoreNodeToVar: Check if the user is a STORE_LCL_VAR, and if it isn't,
 // store the node to a var. Then decompose the new LclVar.
diff --git a/src/jit/decomposelongs.h b/src/jit/decomposelongs.h
index 8965a0b330..ff4f4ac880 100644
--- a/src/jit/decomposelongs.h
+++ b/src/jit/decomposelongs.h
@@ -55,6 +55,8 @@ private:
     GenTree* DecomposeRotate(LIR::Use& use);
     GenTree* DecomposeMul(LIR::Use& use);
     GenTree* DecomposeUMod(LIR::Use& use);
+    GenTree* DecomposeSimd(LIR::Use& use);
+    GenTree* DecomposeSimdGetItem(LIR::Use& use);
 
     // Helper functions
     GenTree* FinalizeDecomposition(LIR::Use& use, GenTree* loResult, GenTree* hiResult, GenTree* insertResultAfter);
diff --git a/src/jit/ee_il_dll.cpp b/src/jit/ee_il_dll.cpp
index dcadaa9453..a29a3ef6b6 100644
--- a/src/jit/ee_il_dll.cpp
+++ b/src/jit/ee_il_dll.cpp
@@ -409,13 +409,25 @@ unsigned CILJit::getMaxIntrinsicSIMDVectorLength(DWORD cpuCompileFlags)
     {
         if (JitConfig.EnableAVX() != 0)
         {
+            if (GetJitTls() != nullptr && JitTls::GetCompiler() != nullptr)
+            {
+                JITDUMP("getMaxIntrinsicSIMDVectorLength: returning 32\n");
+            }
             return 32;
         }
     }
 #endif // FEATURE_AVX_SUPPORT
+    if (GetJitTls() != nullptr && JitTls::GetCompiler() != nullptr)
+    {
+        JITDUMP("getMaxIntrinsicSIMDVectorLength: returning 16\n");
+    }
     return 16;
 #endif // _TARGET_XARCH_
 #else  // !FEATURE_SIMD
+    if (GetJitTls() != nullptr && JitTls::GetCompiler() != nullptr)
+    {
+        JITDUMP("getMaxIntrinsicSIMDVectorLength: returning 0\n");
+    }
     return 0;
 #endif // !FEATURE_SIMD
 }
diff --git a/src/jit/emitarm.cpp b/src/jit/emitarm.cpp
index 1b3ef1bdc7..f7943f2ffd 100644
--- a/src/jit/emitarm.cpp
+++ b/src/jit/emitarm.cpp
@@ -7528,89 +7528,99 @@ void emitter::emitDispFrameRef(int varx, int disp, int offs, bool asmfm)
 
 #ifndef LEGACY_BACKEND
 
-// this is very similar to emitInsBinary and probably could be folded in to same
-// except the requirements on the incoming parameter are different,
-// ex: the memory op in storeind case must NOT be contained
-void emitter::emitInsMov(instruction ins, emitAttr attr, GenTree* node)
+void emitter::emitInsLoadStoreOp(instruction ins, emitAttr attr, regNumber dataReg, GenTreeIndir* indir)
 {
-    switch (node->OperGet())
+    GenTree* addr = indir->Addr();
+    GenTree* data = indir->gtOp.gtOp2;
+
+    if (addr->isContained())
     {
-        case GT_IND:
-        case GT_STOREIND:
-        {
-            GenTreeIndir* indir = node->AsIndir();
-            GenTree*      addr  = indir->Addr();
-            GenTree*      data  = indir->gtOp.gtOp2;
+        assert(addr->OperGet() == GT_LCL_VAR_ADDR || addr->OperGet() == GT_LEA);
 
-            regNumber reg = (node->OperGet() == GT_IND) ? node->gtRegNum : data->gtRegNum;
+        int   offset = 0;
+        DWORD lsl    = 0;
 
-            if (addr->isContained())
+        if (addr->OperGet() == GT_LEA)
+        {
+            offset = (int)addr->AsAddrMode()->gtOffset;
+            if (addr->AsAddrMode()->gtScale > 0)
             {
-                assert(addr->OperGet() == GT_LCL_VAR_ADDR || addr->OperGet() == GT_LEA);
+                assert(isPow2(addr->AsAddrMode()->gtScale));
+                BitScanForward(&lsl, addr->AsAddrMode()->gtScale);
+            }
+        }
+
+        GenTree* memBase = indir->Base();
 
-                int   offset = 0;
-                DWORD lsl    = 0;
+        if (indir->HasIndex())
+        {
+            GenTree* index = indir->Index();
 
-                if (addr->OperGet() == GT_LEA)
+            if (offset != 0)
+            {
+                regMaskTP tmpRegMask = indir->gtRsvdRegs;
+                regNumber tmpReg     = genRegNumFromMask(tmpRegMask);
+                noway_assert(tmpReg != REG_NA);
+
+                if (emitIns_valid_imm_for_add(offset, INS_FLAGS_DONT_CARE))
                 {
-                    offset = (int)addr->AsAddrMode()->gtOffset;
-                    if (addr->AsAddrMode()->gtScale > 0)
+                    if (lsl > 0)
                     {
-                        assert(isPow2(addr->AsAddrMode()->gtScale));
-                        BitScanForward(&lsl, addr->AsAddrMode()->gtScale);
+                        // Generate code to set tmpReg = base + index*scale
+                        emitIns_R_R_R_I(INS_add, EA_PTRSIZE, tmpReg, memBase->gtRegNum, index->gtRegNum, lsl,
+                                        INS_FLAGS_DONT_CARE, INS_OPTS_LSL);
+                    }
+                    else // no scale
+                    {
+                        // Generate code to set tmpReg = base + index
+                        emitIns_R_R_R(INS_add, EA_PTRSIZE, tmpReg, memBase->gtRegNum, index->gtRegNum);
                     }
-                }
 
-                GenTree* memBase = indir->Base();
+                    noway_assert(emitInsIsLoad(ins) || (tmpReg != dataReg));
 
-                if (indir->HasIndex())
-                {
-                    NYI_ARM("emitInsMov HasIndex");
+                    // Then load/store dataReg from/to [tmpReg + offset]
+                    emitIns_R_R_I(ins, attr, dataReg, tmpReg, offset);
                 }
-                else
+                else // large offset
                 {
-                    // TODO check offset is valid for encoding
-                    emitIns_R_R_I(ins, attr, reg, memBase->gtRegNum, offset);
+                    // First load/store tmpReg with the large offset constant
+                    codeGen->instGen_Set_Reg_To_Imm(EA_PTRSIZE, tmpReg, offset);
+                    // Then add the base register
+                    //      rd = rd + base
+                    emitIns_R_R_R(INS_add, EA_PTRSIZE, tmpReg, tmpReg, memBase->gtRegNum);
+
+                    noway_assert(emitInsIsLoad(ins) || (tmpReg != dataReg));
+                    noway_assert(tmpReg != index->gtRegNum);
+
+                    // Then load/store dataReg from/to [tmpReg + index*scale]
+                    emitIns_R_R_R_I(ins, attr, dataReg, tmpReg, index->gtRegNum, lsl, INS_FLAGS_DONT_CARE,
+                                    INS_OPTS_LSL);
                 }
             }
-            else
+            else // (offset == 0)
             {
-                if (addr->OperGet() == GT_CLS_VAR_ADDR)
+                if (lsl > 0)
                 {
-                    emitIns_C_R(ins, attr, addr->gtClsVar.gtClsVarHnd, data->gtRegNum, 0);
+                    // Then load/store dataReg from/to [memBase + index*scale]
+                    emitIns_R_R_R_I(ins, attr, dataReg, memBase->gtRegNum, index->gtRegNum, lsl, INS_FLAGS_DONT_CARE,
+                                    INS_OPTS_LSL);
                 }
-                else
+                else // no scale
                 {
-                    emitIns_R_R(ins, attr, reg, addr->gtRegNum);
+                    // Then load/store dataReg from/to [memBase + index]
+                    emitIns_R_R_R(ins, attr, dataReg, memBase->gtRegNum, index->gtRegNum);
                 }
             }
         }
-        break;
-
-        case GT_STORE_LCL_VAR:
+        else
         {
-            GenTreeLclVarCommon* varNode = node->AsLclVarCommon();
-
-            GenTree* data = node->gtOp.gtOp1->gtEffectiveVal();
-            codeGen->inst_set_SV_var(varNode);
-            assert(varNode->gtRegNum == REG_NA); // stack store
-
-            if (data->isContainedIntOrIImmed())
-            {
-                emitIns_S_I(ins, attr, varNode->GetLclNum(), 0, (int)data->AsIntConCommon()->IconValue());
-                codeGen->genUpdateLife(varNode);
-            }
-            else
-            {
-                assert(!data->isContained());
-                emitIns_S_R(ins, attr, data->gtRegNum, varNode->GetLclNum(), 0);
-                codeGen->genUpdateLife(varNode);
-            }
+            // TODO check offset is valid for encoding
+            emitIns_R_R_I(ins, attr, dataReg, memBase->gtRegNum, offset);
         }
-            return;
-
-        default:
-            unreached();
+    }
+    else
+    {
+        emitIns_R_R(ins, attr, dataReg, addr->gtRegNum);
     }
 }
 
@@ -7646,5 +7656,174 @@ regNumber emitter::emitInsBinary(instruction ins, emitAttr attr, GenTree* dst, G
     }
 }
 
+regNumber emitter::emitInsTernary(instruction ins, emitAttr attr, GenTree* dst, GenTree* src1, GenTree* src2)
+{
+    regNumber result = REG_NA;
+
+    // dst can only be a reg
+    assert(!dst->isContained());
+
+    // find immed (if any) - it cannot be a dst
+    // Only one src can be an int.
+    GenTreeIntConCommon* intConst  = nullptr;
+    GenTree*             nonIntReg = nullptr;
+
+    if (varTypeIsFloating(dst))
+    {
+        // src1 can only be a reg
+        assert(!src1->isContained());
+        // src2 can only be a reg
+        assert(!src2->isContained());
+    }
+    else // not floating point
+    {
+        // src2 can be immed or reg
+        assert(!src2->isContained() || src2->isContainedIntOrIImmed());
+
+        // Check src2 first as we can always allow it to be a contained immediate
+        if (src2->isContainedIntOrIImmed())
+        {
+            intConst  = src2->AsIntConCommon();
+            nonIntReg = src1;
+        }
+        // Only for commutative operations do we check src1 and allow it to be a contained immediate
+        else if (dst->OperIsCommutative())
+        {
+            // src1 can be immed or reg
+            assert(!src1->isContained() || src1->isContainedIntOrIImmed());
+
+            // Check src1 and allow it to be a contained immediate
+            if (src1->isContainedIntOrIImmed())
+            {
+                assert(!src2->isContainedIntOrIImmed());
+                intConst  = src1->AsIntConCommon();
+                nonIntReg = src2;
+            }
+        }
+        else
+        {
+            // src1 can only be a reg
+            assert(!src1->isContained());
+        }
+    }
+    bool      isMulOverflow = false;
+    bool      isUnsignedMul = false;
+    regNumber extraReg      = REG_NA;
+    if (dst->gtOverflowEx())
+    {
+        NYI_ARM("emitInsTernary overflow");
+#if 0
+        if (ins == INS_add)
+        {
+            ins = INS_adds;
+        }
+        else if (ins == INS_sub)
+        {
+            ins = INS_subs;
+        }
+        else if (ins == INS_mul)
+        {
+            isMulOverflow = true;
+            isUnsignedMul = ((dst->gtFlags & GTF_UNSIGNED) != 0);
+            assert(intConst == nullptr); // overflow format doesn't support an int constant operand
+        }
+        else
+        {
+            assert(!"Invalid ins for overflow check");
+        }
+#endif
+    }
+    if (intConst != nullptr)
+    {
+        emitIns_R_R_I(ins, attr, dst->gtRegNum, nonIntReg->gtRegNum, intConst->IconValue());
+    }
+    else
+    {
+        if (isMulOverflow)
+        {
+            NYI_ARM("emitInsTernary overflow");
+#if 0
+            // Make sure that we have an internal register
+            assert(genCountBits(dst->gtRsvdRegs) == 2);
+
+            // There will be two bits set in tmpRegsMask.
+            // Remove the bit for 'dst->gtRegNum' from 'tmpRegsMask'
+            regMaskTP tmpRegsMask = dst->gtRsvdRegs & ~genRegMask(dst->gtRegNum);
+            assert(tmpRegsMask != RBM_NONE);
+            regMaskTP tmpRegMask = genFindLowestBit(tmpRegsMask); // set tmpRegMsk to a one-bit mask
+            extraReg             = genRegNumFromMask(tmpRegMask); // set tmpReg from that mask
+
+            if (isUnsignedMul)
+            {
+                if (attr == EA_4BYTE)
+                {
+                    // Compute 8 byte results from 4 byte by 4 byte multiplication.
+                    emitIns_R_R_R(INS_umull, EA_8BYTE, dst->gtRegNum, src1->gtRegNum, src2->gtRegNum);
+
+                    // Get the high result by shifting dst.
+                    emitIns_R_R_I(INS_lsr, EA_8BYTE, extraReg, dst->gtRegNum, 32);
+                }
+                else
+                {
+                    assert(attr == EA_8BYTE);
+                    // Compute the high result.
+                    emitIns_R_R_R(INS_umulh, attr, extraReg, src1->gtRegNum, src2->gtRegNum);
+
+                    // Now multiply without skewing the high result.
+                    emitIns_R_R_R(ins, attr, dst->gtRegNum, src1->gtRegNum, src2->gtRegNum);
+                }
+
+                // zero-sign bit comparision to detect overflow.
+                emitIns_R_I(INS_cmp, attr, extraReg, 0);
+            }
+            else
+            {
+                int bitShift = 0;
+                if (attr == EA_4BYTE)
+                {
+                    // Compute 8 byte results from 4 byte by 4 byte multiplication.
+                    emitIns_R_R_R(INS_smull, EA_8BYTE, dst->gtRegNum, src1->gtRegNum, src2->gtRegNum);
+
+                    // Get the high result by shifting dst.
+                    emitIns_R_R_I(INS_lsr, EA_8BYTE, extraReg, dst->gtRegNum, 32);
+
+                    bitShift = 31;
+                }
+                else
+                {
+                    assert(attr == EA_8BYTE);
+                    // Save the high result in a temporary register.
+                    emitIns_R_R_R(INS_smulh, attr, extraReg, src1->gtRegNum, src2->gtRegNum);
+
+                    // Now multiply without skewing the high result.
+                    emitIns_R_R_R(ins, attr, dst->gtRegNum, src1->gtRegNum, src2->gtRegNum);
+
+                    bitShift = 63;
+                }
+
+                // Sign bit comparision to detect overflow.
+                emitIns_R_R_I(INS_cmp, attr, extraReg, dst->gtRegNum, bitShift, INS_OPTS_ASR);
+            }
+#endif
+        }
+        else
+        {
+            // We can just multiply.
+            emitIns_R_R_R(ins, attr, dst->gtRegNum, src1->gtRegNum, src2->gtRegNum);
+        }
+    }
+
+    if (dst->gtOverflowEx())
+    {
+        NYI_ARM("emitInsTernary overflow");
+#if 0
+        assert(!varTypeIsFloating(dst));
+        codeGen->genCheckOverflow(dst);
+#endif
+    }
+
+    return dst->gtRegNum;
+}
+
 #endif // !LEGACY_BACKEND
 #endif // defined(_TARGET_ARM_)
diff --git a/src/jit/emitarm.h b/src/jit/emitarm.h
index 1440148f42..6c153a1a33 100644
--- a/src/jit/emitarm.h
+++ b/src/jit/emitarm.h
@@ -109,6 +109,10 @@ bool emitInsIsLoad(instruction ins);
 bool emitInsIsStore(instruction ins);
 bool emitInsIsLoadOrStore(instruction ins);
 
+// Generate code for a load or store operation and handle the case
+// of contained GT_LEA op1 with [base + index<<scale + offset]
+void emitInsLoadStoreOp(instruction ins, emitAttr attr, regNumber dataReg, GenTreeIndir* indir);
+
 /*****************************************************************************
 *
 *  Convert between an index scale in bytes to a smaller encoding used for
diff --git a/src/jit/emitxarch.cpp b/src/jit/emitxarch.cpp
index de875b25b7..be5cefbfea 100644
--- a/src/jit/emitxarch.cpp
+++ b/src/jit/emitxarch.cpp
@@ -57,10 +57,6 @@ bool emitter::IsAVXInstruction(instruction ins)
 #endif
 }
 
-#ifdef _TARGET_AMD64_
-#define REX_PREFIX_MASK 0xFF00000000LL
-#endif // _TARGET_AMD64_
-
 #ifdef FEATURE_AVX_SUPPORT
 // Returns true if the AVX instruction is a binary operator that requires 3 operands.
 // When we emit an instruction with only two operands, we will duplicate the destination
@@ -717,12 +713,10 @@ unsigned emitter::emitGetPrefixSize(code_t code)
         return 3;
     }
 
-#ifdef _TARGET_AMD64_
-    if (code & REX_PREFIX_MASK)
+    if (hasRexPrefix(code))
     {
         return 1;
     }
-#endif // _TARGET_AMD64_
 
     return 0;
 }
@@ -1882,10 +1876,9 @@ UNATIVE_OFFSET emitter::emitInsSizeAM(instrDesc* id, code_t code)
         }
     }
 
-#ifdef _TARGET_AMD64_
     size += emitGetVexPrefixAdjustedSize(ins, attrSize, code);
 
-    if (code & REX_PREFIX_MASK)
+    if (hasRexPrefix(code))
     {
         // REX prefix
         size += emitGetRexPrefixSize(ins);
@@ -1900,7 +1893,6 @@ UNATIVE_OFFSET emitter::emitInsSizeAM(instrDesc* id, code_t code)
         // Should have a REX byte
         size += emitGetRexPrefixSize(ins);
     }
-#endif // _TARGET_AMD64_
 
     if (rgx == REG_NA)
     {
@@ -2303,9 +2295,7 @@ void emitter::emitIns(instruction ins)
     }
 #endif // DEBUG
 
-#ifdef _TARGET_AMD64_
-    assert((code & REX_PREFIX_MASK) == 0); // Can't have a REX bit with no operands, right?
-#endif                                     // _TARGET_AMD64_
+    assert(!hasRexPrefix(code)); // Can't have a REX bit with no operands, right?
 
     if (code & 0xFF000000)
     {
@@ -3997,16 +3987,14 @@ void emitter::emitIns_C_I(instruction ins, emitAttr attr, CORINFO_FIELD_HANDLE f
     code_t         code = insCodeMI(ins);
     UNATIVE_OFFSET sz   = emitInsSizeCV(id, code, val);
 
-#ifdef _TARGET_AMD64_
     // Vex prefix
     sz += emitGetVexPrefixAdjustedSize(ins, attr, insCodeMI(ins));
 
     // REX prefix, if not already included in "code"
-    if (TakesRexWPrefix(ins, attr) && (code & REX_PREFIX_MASK) == 0)
+    if (TakesRexWPrefix(ins, attr) && !hasRexPrefix(code))
     {
         sz += emitGetRexPrefixSize(ins);
     }
-#endif // _TARGET_AMD64_
 
     id->idAddr()->iiaFieldHnd = fldHnd;
     id->idCodeSize(sz);
diff --git a/src/jit/emitxarch.h b/src/jit/emitxarch.h
index 40f22ed526..9c435e5d87 100644
--- a/src/jit/emitxarch.h
+++ b/src/jit/emitxarch.h
@@ -109,6 +109,16 @@ void SetUseSSE3_4(bool value)
 }
 bool Is4ByteSSE4Instruction(instruction ins);
 
+bool hasRexPrefix(code_t code)
+{
+#ifdef _TARGET_AMD64_
+    const code_t REX_PREFIX_MASK = 0xFF00000000LL;
+    return (code & REX_PREFIX_MASK) != 0;
+#else  // !_TARGET_AMD64_
+    return false;
+#endif // !_TARGET_AMD64_
+}
+
 #ifdef FEATURE_AVX_SUPPORT
 
 // 3-byte VEX prefix starts with byte 0xC4
@@ -178,7 +188,7 @@ bool IsThreeOperandAVXInstruction(instruction ins)
 }
 bool Is4ByteAVXInstruction(instruction ins);
 #else  // !FEATURE_AVX_SUPPORT
-bool                     UseAVX()
+bool UseAVX()
 {
     return false;
 }
diff --git a/src/jit/flowgraph.cpp b/src/jit/flowgraph.cpp
index 1a4def446d..50318b0940 100644
--- a/src/jit/flowgraph.cpp
+++ b/src/jit/flowgraph.cpp
@@ -13758,7 +13758,7 @@ bool Compiler::fgOptimizeBranchToNext(BasicBlock* block, BasicBlock* bNext, Basi
 {
     assert(block->bbJumpKind == BBJ_COND || block->bbJumpKind == BBJ_ALWAYS);
     assert(block->bbJumpDest == bNext);
-    assert(block->bbNext = bNext);
+    assert(block->bbNext == bNext);
     assert(block->bbPrev == bPrev);
 
     if (block->bbJumpKind == BBJ_ALWAYS)
@@ -17793,7 +17793,7 @@ void Compiler::fgSetTreeSeqHelper(GenTreePtr tree, bool isLIR)
     if (kind & GTK_SMPOP)
     {
         GenTreePtr op1 = tree->gtOp.gtOp1;
-        GenTreePtr op2 = tree->gtGetOp2();
+        GenTreePtr op2 = tree->gtGetOp2IfPresent();
 
         // Special handling for GT_LIST
         if (tree->OperGet() == GT_LIST)
@@ -20329,7 +20329,7 @@ void Compiler::fgDebugCheckFlags(GenTreePtr tree)
     else if (kind & GTK_SMPOP)
     {
         GenTreePtr op1 = tree->gtOp.gtOp1;
-        GenTreePtr op2 = tree->gtGetOp2();
+        GenTreePtr op2 = tree->gtGetOp2IfPresent();
 
         // During GS work, we make shadow copies for params.
         // In gsParamsToShadows(), we create a shadow var of TYP_INT for every small type param.
@@ -22635,33 +22635,8 @@ void Compiler::fgRemoveEmptyFinally()
                 leaveBlock->bbFlags &= ~BBF_KEEP_BBJ_ALWAYS;
                 fgRemoveBlock(leaveBlock, true);
 
-                // The postTryFinallyBlock may be a finalStep block.
-                // It is now a normal block, so clear the special keep
-                // always flag.
-                postTryFinallyBlock->bbFlags &= ~BBF_KEEP_BBJ_ALWAYS;
-
-#if FEATURE_EH_FUNCLETS && defined(_TARGET_ARM_)
-                // Also, clear the finally target bit for arm
-                fgClearFinallyTargetBit(postTryFinallyBlock);
-#endif // FEATURE_EH_FUNCLETS && defined(_TARGET_ARM_)
-
-#if !FEATURE_EH_FUNCLETS
-                // Remove the GT_END_LFIN from the post-try-finally block.
-                // remove it since there is no finally anymore. Note we only
-                // expect to see one statement.
-                bool foundEndLFin = false;
-                for (GenTreeStmt* stmt = postTryFinallyBlock->firstStmt(); stmt != nullptr; stmt = stmt->gtNextStmt)
-                {
-                    GenTreePtr expr = stmt->gtStmtExpr;
-                    if (expr->gtOper == GT_END_LFIN)
-                    {
-                        assert(!foundEndLFin);
-                        fgRemoveStmt(postTryFinallyBlock, stmt);
-                        foundEndLFin = true;
-                    }
-                }
-                assert(foundEndLFin);
-#endif // !FEATURE_EH_FUNCLETS
+                // Cleanup the postTryFinallyBlock
+                fgCleanupContinuation(postTryFinallyBlock);
 
                 // Make sure iteration isn't going off the deep end.
                 assert(leaveBlock != endCallFinallyRangeBlock);
@@ -22728,6 +22703,7 @@ void Compiler::fgRemoveEmptyFinally()
     if (emptyCount > 0)
     {
         JITDUMP("fgRemoveEmptyFinally() removed %u try-finally clauses from %u finallys\n", emptyCount, finallyCount);
+        fgOptimizedFinally = true;
 
 #ifdef DEBUG
         if (verbose)
@@ -22746,6 +22722,314 @@ void Compiler::fgRemoveEmptyFinally()
 }
 
 //------------------------------------------------------------------------
+// fgRemoveEmptyTry: Optimize try/finallys where the try is empty
+//
+// Notes:
+//    In runtimes where thread abort is not possible, `try {} finally {S}`
+//    can be optimized to simply `S`. This method looks for such
+//    cases and removes the try-finally from the EH table, making
+//    suitable flow, block flag, statement, and region updates.
+//
+//    This optimization is not legal in runtimes that support thread
+//    abort because those runtimes ensure that a finally is completely
+//    executed before continuing to process the thread abort.  With
+//    this optimization, the code block `S` can lose special
+//    within-finally status and so complete execution is no longer
+//    guaranteed.
+
+void Compiler::fgRemoveEmptyTry()
+{
+    JITDUMP("\n*************** In fgRemoveEmptyTry()\n");
+
+#ifdef FEATURE_CORECLR
+    bool enableRemoveEmptyTry = true;
+#else
+    // Code in a finally gets special treatment in the presence of
+    // thread abort.
+    bool enableRemoveEmptyTry = false;
+#endif // FEATURE_CORECLR
+
+#ifdef DEBUG
+    // Allow override to enable/disable.
+    enableRemoveEmptyTry = (JitConfig.JitEnableRemoveEmptyTry() == 1);
+#endif // DEBUG
+
+    if (!enableRemoveEmptyTry)
+    {
+        JITDUMP("Empty try removal disabled.\n");
+        return;
+    }
+
+    if (compHndBBtabCount == 0)
+    {
+        JITDUMP("No EH in this method, nothing to remove.\n");
+        return;
+    }
+
+    if (opts.MinOpts())
+    {
+        JITDUMP("Method compiled with minOpts, no removal.\n");
+        return;
+    }
+
+    if (opts.compDbgCode)
+    {
+        JITDUMP("Method compiled with debug codegen, no removal.\n");
+        return;
+    }
+
+#ifdef DEBUG
+    if (verbose)
+    {
+        printf("\n*************** Before fgRemoveEmptyTry()\n");
+        fgDispBasicBlocks();
+        fgDispHandlerTab();
+        printf("\n");
+    }
+#endif // DEBUG
+
+    // Look for try-finallys where the try is empty.
+    unsigned emptyCount = 0;
+    unsigned XTnum      = 0;
+    while (XTnum < compHndBBtabCount)
+    {
+        EHblkDsc* const HBtab = &compHndBBtab[XTnum];
+
+        // Check if this is a try/finally.  We could also look for empty
+        // try/fault but presumably those are rare.
+        if (!HBtab->HasFinallyHandler())
+        {
+            JITDUMP("EH#%u is not a try-finally; skipping.\n", XTnum);
+            XTnum++;
+            continue;
+        }
+
+        // Examine the try region
+        BasicBlock* const firstTryBlock     = HBtab->ebdTryBeg;
+        BasicBlock* const lastTryBlock      = HBtab->ebdTryLast;
+        BasicBlock* const firstHandlerBlock = HBtab->ebdHndBeg;
+        BasicBlock* const lastHandlerBlock  = HBtab->ebdHndLast;
+        BasicBlock* const endHandlerBlock   = lastHandlerBlock->bbNext;
+
+        assert(firstTryBlock->getTryIndex() == XTnum);
+
+        // Limit for now to trys that contain only a callfinally pair
+        // or branch to same.
+        if (!firstTryBlock->isEmpty())
+        {
+            JITDUMP("EH#%u first try block BB%02u not empty; skipping.\n", XTnum, firstTryBlock->bbNum);
+            XTnum++;
+            continue;
+        }
+
+#if FEATURE_EH_CALLFINALLY_THUNKS
+
+        // Look for blocks that are always jumps to a call finally
+        // pair that targets the finally
+        if (firstTryBlock->bbJumpKind != BBJ_ALWAYS)
+        {
+            JITDUMP("EH#%u first try block BB%02u not jump to a callfinally; skipping.\n", XTnum, firstTryBlock->bbNum);
+            XTnum++;
+            continue;
+        }
+
+        BasicBlock* const callFinally = firstTryBlock->bbJumpDest;
+
+        // Look for call always pair. Note this will also disqualify
+        // empty try removal in cases where the finally doesn't
+        // return.
+        if (!callFinally->isBBCallAlwaysPair() || (callFinally->bbJumpDest != firstHandlerBlock))
+        {
+            JITDUMP("EH#%u first try block BB%02u always jumps but not to a callfinally; skipping.\n", XTnum,
+                    firstTryBlock->bbNum);
+            XTnum++;
+            continue;
+        }
+
+        // Try itself must be a single block.
+        if (firstTryBlock != lastTryBlock)
+        {
+            JITDUMP("EH#%u first try block BB%02u not only block in try; skipping.\n", XTnum,
+                    firstTryBlock->bbNext->bbNum);
+            XTnum++;
+            continue;
+        }
+
+#else
+        // Look for call always pair within the try itself. Note this
+        // will also disqualify empty try removal in cases where the
+        // finally doesn't return.
+        if (!firstTryBlock->isBBCallAlwaysPair() || (firstTryBlock->bbJumpDest != firstHandlerBlock))
+        {
+            JITDUMP("EH#%u first try block BB%02u not a callfinally; skipping.\n", XTnum, firstTryBlock->bbNum);
+            XTnum++;
+            continue;
+        }
+
+        BasicBlock* const callFinally = firstTryBlock;
+
+        // Try must be a callalways pair of blocks.
+        if (firstTryBlock->bbNext != lastTryBlock)
+        {
+            JITDUMP("EH#%u block BB%02u not last block in try; skipping.\n", XTnum, firstTryBlock->bbNext->bbNum);
+            XTnum++;
+            continue;
+        }
+
+#endif // FEATURE_EH_CALLFINALLY_THUNKS
+
+        JITDUMP("EH#%u has empty try, removing the try region and promoting the finally.\n", XTnum);
+
+        // There should be just one callfinally that invokes this
+        // finally, the one we found above. Verify this.
+        BasicBlock* firstCallFinallyRangeBlock = nullptr;
+        BasicBlock* endCallFinallyRangeBlock   = nullptr;
+        bool        verifiedSingleCallfinally  = true;
+        ehGetCallFinallyBlockRange(XTnum, &firstCallFinallyRangeBlock, &endCallFinallyRangeBlock);
+
+        for (BasicBlock* block = firstCallFinallyRangeBlock; block != endCallFinallyRangeBlock; block = block->bbNext)
+        {
+            if ((block->bbJumpKind == BBJ_CALLFINALLY) && (block->bbJumpDest == firstHandlerBlock))
+            {
+                assert(block->isBBCallAlwaysPair());
+
+                if (block != callFinally)
+                {
+                    JITDUMP("EH#%u found unexpected callfinally BB%02u; skipping.\n");
+                    verifiedSingleCallfinally = false;
+                    break;
+                }
+
+                block = block->bbNext;
+            }
+        }
+
+        if (!verifiedSingleCallfinally)
+        {
+            JITDUMP("EH#%u -- unexpectedly -- has multiple callfinallys; skipping.\n");
+            XTnum++;
+            assert(verifiedSingleCallfinally);
+            continue;
+        }
+
+        // Time to optimize.
+        //
+        // (1) Convert the callfinally to a normal jump to the handler
+        callFinally->bbJumpKind = BBJ_ALWAYS;
+
+        // Identify the leave block and the continuation
+        BasicBlock* const leave        = callFinally->bbNext;
+        BasicBlock* const continuation = leave->bbJumpDest;
+
+        // (2) Cleanup the leave so it can be deleted by subsequent opts
+        assert((leave->bbFlags & BBF_KEEP_BBJ_ALWAYS) != 0);
+        leave->bbFlags &= ~BBF_KEEP_BBJ_ALWAYS;
+
+        // (3) Cleanup the continuation
+        fgCleanupContinuation(continuation);
+
+        // (4) Find enclosing try region for the try, if any, and
+        // update the try region for the blocks in the try. Note the
+        // handler region (if any) won't change.
+        //
+        // Kind of overkill to loop here, but hey.
+        for (BasicBlock* block = firstTryBlock; block != nullptr; block = block->bbNext)
+        {
+            // Look for blocks directly contained in this try, and
+            // update the try region appropriately.
+            //
+            // The try region for blocks transitively contained (say in a
+            // child try) will get updated by the subsequent call to
+            // fgRemoveEHTableEntry.
+            if (block->getTryIndex() == XTnum)
+            {
+                if (firstHandlerBlock->hasTryIndex())
+                {
+                    block->setTryIndex(firstHandlerBlock->getTryIndex());
+                }
+                else
+                {
+                    block->clearTryIndex();
+                }
+            }
+
+            if (block == firstTryBlock)
+            {
+                assert((block->bbFlags & BBF_TRY_BEG) != 0);
+                block->bbFlags &= ~BBF_TRY_BEG;
+            }
+
+            if (block == lastTryBlock)
+            {
+                break;
+            }
+        }
+
+        // (5) Update the directly contained handler blocks' handler index.
+        // Handler index of any nested blocks will update when we
+        // remove the EH table entry.  Change handler exits to jump to
+        // the continuation.  Clear catch type on handler entry.
+        for (BasicBlock* block = firstHandlerBlock; block != endHandlerBlock; block = block->bbNext)
+        {
+            if (block == firstHandlerBlock)
+            {
+                block->bbCatchTyp = BBCT_NONE;
+            }
+
+            if (block->getHndIndex() == XTnum)
+            {
+                if (firstTryBlock->hasHndIndex())
+                {
+                    block->setHndIndex(firstTryBlock->getHndIndex());
+                }
+                else
+                {
+                    block->clearHndIndex();
+                }
+
+                if (block->bbJumpKind == BBJ_EHFINALLYRET)
+                {
+                    GenTreeStmt* finallyRet     = block->lastStmt();
+                    GenTreePtr   finallyRetExpr = finallyRet->gtStmtExpr;
+                    assert(finallyRetExpr->gtOper == GT_RETFILT);
+                    fgRemoveStmt(block, finallyRet);
+                    block->bbJumpKind = BBJ_ALWAYS;
+                    block->bbJumpDest = continuation;
+                }
+            }
+        }
+
+        // (6) Remove the try-finally EH region. This will compact the
+        // EH table so XTnum now points at the next entry and will update
+        // the EH region indices of any nested EH in the (former) handler.
+        fgRemoveEHTableEntry(XTnum);
+
+        // Another one bites the dust...
+        emptyCount++;
+    }
+
+    if (emptyCount > 0)
+    {
+        JITDUMP("fgRemoveEmptyTry() optimized %u empty-try try-finally clauses\n", emptyCount);
+        fgOptimizedFinally = true;
+
+#ifdef DEBUG
+        if (verbose)
+        {
+            printf("\n*************** After fgRemoveEmptyTry()\n");
+            fgDispBasicBlocks();
+            fgDispHandlerTab();
+            printf("\n");
+        }
+
+        fgVerifyHandlerTab();
+        fgDebugCheckBBlist(false, false);
+
+#endif // DEBUG
+    }
+}
+
+//------------------------------------------------------------------------
 // fgCloneFinally: Optimize normal exit path from a try/finally
 //
 // Notes:
@@ -22776,7 +23060,7 @@ void Compiler::fgCloneFinally()
 {
     JITDUMP("\n*************** In fgCloneFinally()\n");
 
-#if FEATURE_CORECLR
+#ifdef FEATURE_CORECLR
     bool enableCloning = true;
 #else
     // Finally cloning currently doesn't provide sufficient protection
@@ -22784,7 +23068,7 @@ void Compiler::fgCloneFinally()
     bool enableCloning = false;
 #endif // FEATURE_CORECLR
 
-#if DEBUG
+#ifdef DEBUG
     // Allow override to enable/disable.
     enableCloning = (JitConfig.JitEnableFinallyCloning() == 1);
 #endif // DEBUG
@@ -23280,34 +23564,8 @@ void Compiler::fgCloneFinally()
         BasicBlock* firstClonedBlock = blockMap[firstBlock];
         firstClonedBlock->bbCatchTyp = BBCT_NONE;
 
-        // The normalCallFinallyReturn may be a finalStep block.  It
-        // is now a normal block, since all the callfinallies that
-        // return to it are now going via the clone, so clear the
-        // special keep always flag.
-        normalCallFinallyReturn->bbFlags &= ~BBF_KEEP_BBJ_ALWAYS;
-
-#if FEATURE_EH_FUNCLETS && defined(_TARGET_ARM_)
-        // Also, clear the finally target bit for arm
-        fgClearFinallyTargetBit(normalCallFinallyReturn);
-#endif // FEATURE_EH_FUNCLETS && defined(_TARGET_ARM_)
-
-#if !FEATURE_EH_FUNCLETS
-        // Remove the GT_END_LFIN from the post-try-finally block.
-        // remove it since there is no finally anymore. Note we only
-        // expect to see one statement.
-        bool foundEndLFin = false;
-        for (GenTreeStmt* stmt = normalCallFinallyReturn->firstStmt(); stmt != nullptr; stmt = stmt->gtNextStmt)
-        {
-            GenTreePtr expr = stmt->gtStmtExpr;
-            if (expr->gtOper == GT_END_LFIN)
-            {
-                assert(!foundEndLFin);
-                fgRemoveStmt(normalCallFinallyReturn, stmt);
-                foundEndLFin = true;
-            }
-        }
-        assert(foundEndLFin);
-#endif
+        // Cleanup the contination
+        fgCleanupContinuation(normalCallFinallyReturn);
 
         // Todo -- mark cloned blocks as a cloned finally....
 
@@ -23319,6 +23577,7 @@ void Compiler::fgCloneFinally()
     if (cloneCount > 0)
     {
         JITDUMP("fgCloneFinally() cloned %u finally handlers\n", cloneCount);
+        fgOptimizedFinally = true;
 
 #ifdef DEBUG
         if (verbose)
@@ -23530,3 +23789,470 @@ void Compiler::fgDebugCheckTryFinallyExits()
 }
 
 #endif // DEBUG
+
+//------------------------------------------------------------------------
+// fgCleanupContinuation: cleanup a finally continuation after a
+// finally is removed or converted to normal control flow.
+//
+// Notes:
+//    The continuation is the block targeted by the second half of
+//    a callfinally/always pair.
+//
+//    Used by finally cloning, empty try removal, and empty
+//    finally removal.
+//
+//    BBF_FINALLY_TARGET bbFlag is left unchanged by this method
+//    since it cannot be incrementally updated. Proper updates happen
+//    when fgUpdateFinallyTargetFlags runs after all finally optimizations.
+
+void Compiler::fgCleanupContinuation(BasicBlock* continuation)
+{
+    // The continuation may be a finalStep block.
+    // It is now a normal block, so clear the special keep
+    // always flag.
+    continuation->bbFlags &= ~BBF_KEEP_BBJ_ALWAYS;
+
+#if !FEATURE_EH_FUNCLETS
+    // Remove the GT_END_LFIN from the continuation,
+    // Note we only expect to see one such statement.
+    bool foundEndLFin = false;
+    for (GenTreeStmt* stmt = continuation->firstStmt(); stmt != nullptr; stmt = stmt->gtNextStmt)
+    {
+        GenTreePtr expr = stmt->gtStmtExpr;
+        if (expr->gtOper == GT_END_LFIN)
+        {
+            assert(!foundEndLFin);
+            fgRemoveStmt(continuation, stmt);
+            foundEndLFin = true;
+        }
+    }
+    assert(foundEndLFin);
+#endif // !FEATURE_EH_FUNCLETS
+}
+
+//------------------------------------------------------------------------
+// fgUpdateFinallyTargetFlags: recompute BBF_FINALLY_TARGET bits for all blocks
+// after finally optimizations have run.
+
+void Compiler::fgUpdateFinallyTargetFlags()
+{
+#if FEATURE_EH_FUNCLETS && defined(_TARGET_ARM_)
+
+    // Any fixup required?
+    if (!fgOptimizedFinally)
+    {
+        JITDUMP("In fgUpdateFinallyTargetFlags - no finally opts, no fixup required\n");
+        return;
+    }
+
+    JITDUMP("In fgUpdateFinallyTargetFlags, updating finally target flag bits\n");
+
+    // Walk all blocks, and reset the target bits.
+    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    {
+        block->bbFlags &= ~BBF_FINALLY_TARGET;
+    }
+
+    // Walk all blocks again, and set the target bits.
+    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    {
+        if (block->isBBCallAlwaysPair())
+        {
+            BasicBlock* const leave        = block->bbNext;
+            BasicBlock* const continuation = leave->bbJumpDest;
+
+            if ((continuation->bbFlags & BBF_FINALLY_TARGET) == 0)
+            {
+                JITDUMP("Found callfinally BB%02u; setting finally target bit on BB%02u\n", block->bbNum,
+                        continuation->bbNum);
+
+                continuation->bbFlags |= BBF_FINALLY_TARGET;
+            }
+        }
+    }
+#endif // FEATURE_EH_FUNCLETS && defined(_TARGET_ARM_)
+}
+
+// FatCalliTransformer transforms calli that can use fat function pointer.
+// Fat function pointer is pointer with the second least significant bit set,
+// if the bit is set, the pointer (after clearing the bit) actually points to
+// a tuple <method pointer, instantiation argument pointer> where
+// instantiationArgument is a hidden first argument required by method pointer.
+//
+// Fat pointers are used in CoreRT as a replacement for instantiating stubs,
+// because CoreRT can't generate stubs in runtime.
+//
+// Jit is responsible for the checking the bit, do the regular call if it is not set
+// or load hidden argument, fix the pointer and make a call with the fixed pointer and
+// the instantiation argument.
+//
+// before:
+//   current block
+//   {
+//     previous statements
+//     transforming statement
+//     {
+//       call with GTF_CALL_M_FAT_POINTER_CHECK flag set in function ptr
+//     }
+//     subsequent statements
+//   }
+//
+// after:
+//   current block
+//   {
+//     previous statements
+//   } BBJ_NONE check block
+//   check block
+//   {
+//     jump to else if function ptr has GTF_CALL_M_FAT_POINTER_CHECK set.
+//   } BBJ_COND then block, else block
+//   then block
+//   {
+//     original statement
+//   } BBJ_ALWAYS remainder block
+//   else block
+//   {
+//     unset GTF_CALL_M_FAT_POINTER_CHECK
+//     load actual function pointer
+//     load instantiation argument
+//     create newArgList = (instantiation argument, original argList)
+//     call (actual function pointer, newArgList)
+//   } BBJ_NONE remainder block
+//   remainder block
+//   {
+//     subsequent statements
+//   }
+//
+class FatCalliTransformer
+{
+public:
+    FatCalliTransformer(Compiler* compiler) : compiler(compiler)
+    {
+    }
+
+    //------------------------------------------------------------------------
+    // Run: run transformation for each block.
+    //
+    void Run()
+    {
+        for (BasicBlock* block = compiler->fgFirstBB; block != nullptr; block = block->bbNext)
+        {
+            TransformBlock(block);
+        }
+    }
+
+private:
+    //------------------------------------------------------------------------
+    // TransformBlock: look through statements and transform statements with fat pointer calls.
+    //
+    void TransformBlock(BasicBlock* block)
+    {
+        for (GenTreeStmt* stmt = block->firstStmt(); stmt != nullptr; stmt = stmt->gtNextStmt)
+        {
+            if (ContainsFatCalli(stmt))
+            {
+                StatementTransformer stmtTransformer(compiler, block, stmt);
+                stmtTransformer.Run();
+            }
+        }
+    }
+
+    //------------------------------------------------------------------------
+    // ContainsFatCalli: check does this statement contain fat pointer call.
+    //
+    // Checks fatPointerCandidate in form of call() or lclVar = call().
+    //
+    // Return Value:
+    //    true if contains, false otherwise.
+    //
+    bool ContainsFatCalli(GenTreeStmt* stmt)
+    {
+        GenTreePtr fatPointerCandidate = stmt->gtStmtExpr;
+        if (fatPointerCandidate->OperIsAssignment())
+        {
+            fatPointerCandidate = fatPointerCandidate->gtGetOp2();
+        }
+        return fatPointerCandidate->IsCall() && fatPointerCandidate->AsCall()->IsFatPointerCandidate();
+    }
+
+    class StatementTransformer
+    {
+    public:
+        StatementTransformer(Compiler* compiler, BasicBlock* block, GenTreeStmt* stmt)
+            : compiler(compiler), currBlock(block), stmt(stmt)
+        {
+            remainderBlock  = nullptr;
+            checkBlock      = nullptr;
+            thenBlock       = nullptr;
+            elseBlock       = nullptr;
+            doesReturnValue = stmt->gtStmtExpr->OperIsAssignment();
+            origCall        = GetCall(stmt);
+            fptrAddress     = origCall->gtCallAddr;
+            pointerType     = fptrAddress->TypeGet();
+        }
+
+        //------------------------------------------------------------------------
+        // Run: transform the statement as described above.
+        //
+        void Run()
+        {
+            ClearFatFlag();
+            CreateRemainder();
+            CreateCheck();
+            CreateThen();
+            CreateElse();
+
+            RemoveOldStatement();
+            SetWeights();
+            ChainFlow();
+        }
+
+    private:
+        //------------------------------------------------------------------------
+        // GetCall: find a call in a statement.
+        //
+        // Arguments:
+        //    callStmt - the statement with the call inside.
+        //
+        // Return Value:
+        //    call tree node pointer.
+        GenTreeCall* GetCall(GenTreeStmt* callStmt)
+        {
+            GenTreePtr   tree = callStmt->gtStmtExpr;
+            GenTreeCall* call = nullptr;
+            if (doesReturnValue)
+            {
+                assert(tree->OperIsAssignment());
+                call = tree->gtGetOp2()->AsCall();
+            }
+            else
+            {
+                call = tree->AsCall(); // call with void return type.
+            }
+            return call;
+        }
+
+        //------------------------------------------------------------------------
+        // ClearFatFlag: clear fat pointer candidate flag from the original call.
+        //
+        void ClearFatFlag()
+        {
+            origCall->ClearFatPointerCandidate();
+        }
+
+        //------------------------------------------------------------------------
+        // CreateRemainder: split current block at the fat call stmt and
+        // insert statements after the call into remainderBlock.
+        //
+        void CreateRemainder()
+        {
+            remainderBlock          = compiler->fgSplitBlockAfterStatement(currBlock, stmt);
+            unsigned propagateFlags = currBlock->bbFlags & BBF_GC_SAFE_POINT;
+            remainderBlock->bbFlags |= BBF_JMP_TARGET | BBF_HAS_LABEL | propagateFlags;
+        }
+
+        //------------------------------------------------------------------------
+        // CreateCheck: create check block, that checks fat pointer bit set.
+        //
+        void CreateCheck()
+        {
+            checkBlock                 = CreateAndInsertBasicBlock(BBJ_COND, currBlock);
+            GenTreePtr fatPointerMask  = new (compiler, GT_CNS_INT) GenTreeIntCon(TYP_I_IMPL, FAT_POINTER_MASK);
+            GenTreePtr fptrAddressCopy = compiler->gtCloneExpr(fptrAddress);
+            GenTreePtr fatPointerAnd   = compiler->gtNewOperNode(GT_AND, TYP_I_IMPL, fptrAddressCopy, fatPointerMask);
+            GenTreePtr zero            = new (compiler, GT_CNS_INT) GenTreeIntCon(TYP_I_IMPL, 0);
+            GenTreePtr fatPointerCmp   = compiler->gtNewOperNode(GT_NE, TYP_INT, fatPointerAnd, zero);
+            GenTreePtr jmpTree         = compiler->gtNewOperNode(GT_JTRUE, TYP_VOID, fatPointerCmp);
+            GenTreePtr jmpStmt         = compiler->fgNewStmtFromTree(jmpTree, stmt->gtStmt.gtStmtILoffsx);
+            compiler->fgInsertStmtAtEnd(checkBlock, jmpStmt);
+        }
+
+        //------------------------------------------------------------------------
+        // CreateCheck: create then block, that is executed if call address is not fat pointer.
+        //
+        void CreateThen()
+        {
+            thenBlock                 = CreateAndInsertBasicBlock(BBJ_ALWAYS, checkBlock);
+            GenTreePtr nonFatCallStmt = compiler->gtCloneExpr(stmt)->AsStmt();
+            compiler->fgInsertStmtAtEnd(thenBlock, nonFatCallStmt);
+        }
+
+        //------------------------------------------------------------------------
+        // CreateCheck: create else block, that is executed if call address is fat pointer.
+        //
+        void CreateElse()
+        {
+            elseBlock = CreateAndInsertBasicBlock(BBJ_NONE, thenBlock);
+
+            GenTreePtr fixedFptrAddress  = GetFixedFptrAddress();
+            GenTreePtr actualCallAddress = compiler->gtNewOperNode(GT_IND, pointerType, fixedFptrAddress);
+            GenTreePtr hiddenArgument    = GetHiddenArgument(fixedFptrAddress);
+
+            GenTreeStmt* fatStmt = CreateFatCallStmt(actualCallAddress, hiddenArgument);
+            compiler->fgInsertStmtAtEnd(elseBlock, fatStmt);
+        }
+
+        //------------------------------------------------------------------------
+        // CreateAndInsertBasicBlock: ask compiler to create new basic block.
+        // and insert in into the basic block list.
+        //
+        // Arguments:
+        //    jumpKind - jump kind for the new basic block
+        //    insertAfter - basic block, after which compiler has to insert the new one.
+        //
+        // Return Value:
+        //    new basic block.
+        BasicBlock* CreateAndInsertBasicBlock(BBjumpKinds jumpKind, BasicBlock* insertAfter)
+        {
+            BasicBlock* block = compiler->fgNewBBafter(jumpKind, insertAfter, true);
+            if ((insertAfter->bbFlags & BBF_INTERNAL) == 0)
+            {
+                block->bbFlags &= ~BBF_INTERNAL;
+                block->bbFlags |= BBF_IMPORTED;
+            }
+            return block;
+        }
+
+        //------------------------------------------------------------------------
+        // GetFixedFptrAddress: clear fat pointer bit from fat pointer address.
+        //
+        // Return Value:
+        //    address without fat pointer bit set.
+        GenTreePtr GetFixedFptrAddress()
+        {
+            GenTreePtr fptrAddressCopy = compiler->gtCloneExpr(fptrAddress);
+            GenTreePtr fatPointerMask  = new (compiler, GT_CNS_INT) GenTreeIntCon(TYP_I_IMPL, FAT_POINTER_MASK);
+            return compiler->gtNewOperNode(GT_XOR, pointerType, fptrAddressCopy, fatPointerMask);
+        }
+
+        //------------------------------------------------------------------------
+        // GetHiddenArgument: load hidden argument.
+        //
+        // Arguments:
+        //    fixedFptrAddress - pointer to the tuple <methodPointer, instantiationArgumentPointer>
+        //
+        // Return Value:
+        //    loaded hidden argument.
+        GenTreePtr GetHiddenArgument(GenTreePtr fixedFptrAddress)
+        {
+            GenTreePtr fixedFptrAddressCopy = compiler->gtCloneExpr(fixedFptrAddress);
+            GenTreePtr wordSize = new (compiler, GT_CNS_INT) GenTreeIntCon(TYP_I_IMPL, genTypeSize(TYP_I_IMPL));
+            GenTreePtr hiddenArgumentPtrPtr =
+                compiler->gtNewOperNode(GT_ADD, pointerType, fixedFptrAddressCopy, wordSize);
+            GenTreePtr hiddenArgumentPtr = compiler->gtNewOperNode(GT_IND, pointerType, hiddenArgumentPtrPtr);
+            return compiler->gtNewOperNode(GT_IND, fixedFptrAddressCopy->TypeGet(), hiddenArgumentPtr);
+        }
+
+        //------------------------------------------------------------------------
+        // CreateFatCallStmt: create call with fixed call address and hidden argument in the args list.
+        //
+        // Arguments:
+        //    actualCallAddress - fixed call address
+        //    hiddenArgument - loaded hidden argument
+        //
+        // Return Value:
+        //    created call node.
+        GenTreeStmt* CreateFatCallStmt(GenTreePtr actualCallAddress, GenTreePtr hiddenArgument)
+        {
+            GenTreeStmt* fatStmt = compiler->gtCloneExpr(stmt)->AsStmt();
+            GenTreePtr   fatTree = fatStmt->gtStmtExpr;
+            GenTreeCall* fatCall = GetCall(fatStmt);
+            fatCall->gtCallAddr  = actualCallAddress;
+            GenTreeArgList* args = fatCall->gtCallArgs;
+            args                 = compiler->gtNewListNode(hiddenArgument, args);
+            fatCall->gtCallArgs  = args;
+            return fatStmt;
+        }
+
+        //------------------------------------------------------------------------
+        // RemoveOldStatement: remove original stmt from current block.
+        //
+        void RemoveOldStatement()
+        {
+            compiler->fgRemoveStmt(currBlock, stmt);
+        }
+
+        //------------------------------------------------------------------------
+        // SetWeights: set weights for new blocks.
+        //
+        void SetWeights()
+        {
+            remainderBlock->inheritWeight(currBlock);
+            checkBlock->inheritWeight(currBlock);
+            thenBlock->inheritWeightPercentage(currBlock, HIGH_PROBABILITY);
+            elseBlock->inheritWeightPercentage(currBlock, 100 - HIGH_PROBABILITY);
+        }
+
+        //------------------------------------------------------------------------
+        // ChainFlow: link new blocks into correct cfg.
+        //
+        void ChainFlow()
+        {
+            assert(!compiler->fgComputePredsDone);
+            checkBlock->bbJumpDest = elseBlock;
+            thenBlock->bbJumpDest  = remainderBlock;
+        }
+
+        Compiler*    compiler;
+        BasicBlock*  currBlock;
+        BasicBlock*  remainderBlock;
+        BasicBlock*  checkBlock;
+        BasicBlock*  thenBlock;
+        BasicBlock*  elseBlock;
+        GenTreeStmt* stmt;
+        GenTreeCall* origCall;
+        GenTreePtr   fptrAddress;
+        var_types    pointerType;
+        bool         doesReturnValue;
+
+        const int FAT_POINTER_MASK = 0x2;
+        const int HIGH_PROBABILITY = 80;
+    };
+
+    Compiler* compiler;
+};
+
+#ifdef DEBUG
+
+//------------------------------------------------------------------------
+// fgDebugCheckFatPointerCandidates: callback to make sure there are no more GTF_CALL_M_FAT_POINTER_CHECK calls.
+//
+Compiler::fgWalkResult Compiler::fgDebugCheckFatPointerCandidates(GenTreePtr* pTree, fgWalkData* data)
+{
+    GenTreePtr tree = *pTree;
+    if (tree->IsCall())
+    {
+        assert(!tree->AsCall()->IsFatPointerCandidate());
+    }
+    return WALK_CONTINUE;
+}
+
+//------------------------------------------------------------------------
+// CheckNoFatPointerCandidatesLeft: walk through blocks and check that there are no fat pointer candidates left.
+//
+void Compiler::CheckNoFatPointerCandidatesLeft()
+{
+    assert(!doesMethodHaveFatPointer());
+    for (BasicBlock* block = fgFirstBB; block != nullptr; block = block->bbNext)
+    {
+        for (GenTreeStmt* stmt = fgFirstBB->firstStmt(); stmt != nullptr; stmt = stmt->gtNextStmt)
+        {
+            fgWalkTreePre(&stmt->gtStmtExpr, fgDebugCheckFatPointerCandidates);
+        }
+    }
+}
+#endif
+
+//------------------------------------------------------------------------
+// fgTransformFatCalli: find and transform fat calls.
+//
+void Compiler::fgTransformFatCalli()
+{
+    assert(IsTargetAbi(CORINFO_CORERT_ABI));
+    FatCalliTransformer fatCalliTransformer(this);
+    fatCalliTransformer.Run();
+    clearMethodHasFatPointer();
+#ifdef DEBUG
+    CheckNoFatPointerCandidatesLeft();
+#endif
+}
diff --git a/src/jit/gcinfo.cpp b/src/jit/gcinfo.cpp
index b64fd0a174..e2f76f3b13 100644
--- a/src/jit/gcinfo.cpp
+++ b/src/jit/gcinfo.cpp
@@ -265,6 +265,12 @@ GCInfo::WriteBarrierForm GCInfo::gcIsWriteBarrierCandidate(GenTreePtr tgt, GenTr
         case GT_STOREIND:
 #endif               // !LEGACY_BACKEND
         case GT_IND: /* Could be the managed heap */
+            if (tgt->TypeGet() == TYP_BYREF)
+            {
+                // Byref values cannot be in managed heap.
+                // This case occurs for Span<T>.
+                return WBF_NoBarrier;
+            }
             return gcWriteBarrierFormFromTargetAddress(tgt->gtOp.gtOp1);
 
         case GT_LEA:
diff --git a/src/jit/gentree.cpp b/src/jit/gentree.cpp
index 58342bc707..7af500f877 100644
--- a/src/jit/gentree.cpp
+++ b/src/jit/gentree.cpp
@@ -678,7 +678,7 @@ Compiler::fgWalkResult Compiler::fgWalkTreePreRec(GenTreePtr* pTree, fgWalkData*
 
         if (kind & GTK_SMPOP)
         {
-            if (tree->gtGetOp2())
+            if (tree->gtGetOp2IfPresent())
             {
                 if (tree->gtOp.gtOp1 != nullptr)
                 {
@@ -1301,7 +1301,7 @@ Compiler::fgWalkResult Compiler::fgWalkTreeRec(GenTreePtr* pTree, fgWalkData* fg
             }
         }
 
-        if (tree->gtGetOp2())
+        if (tree->gtGetOp2IfPresent())
         {
             result = fgWalkTreeRec<doPreOrder, doPostOrder>(&tree->gtOp.gtOp2, fgWalkData);
             if (result == WALK_ABORT)
@@ -2447,7 +2447,7 @@ AGAIN:
 
     if (kind & GTK_SMPOP)
     {
-        if (tree->gtGetOp2())
+        if (tree->gtGetOp2IfPresent())
         {
             if (gtHasRef(tree->gtOp.gtOp1, lclNum, defOnly))
             {
@@ -3181,7 +3181,7 @@ AGAIN:
             }
         }
 
-        if (tree->gtGetOp2())
+        if (tree->gtGetOp2IfPresent())
         {
             /* It's a binary operator */
             if (!lvaLclVarRefsAccum(tree->gtOp.gtOp1, findPtr, refsPtr, &allVars, &trkdVars))
@@ -4151,7 +4151,7 @@ unsigned Compiler::gtSetEvalOrder(GenTree* tree)
         unsigned lvl2; // scratch variable
 
         GenTreePtr op1 = tree->gtOp.gtOp1;
-        GenTreePtr op2 = tree->gtGetOp2();
+        GenTreePtr op2 = tree->gtGetOp2IfPresent();
 
         costEx = 0;
         costSz = 0;
@@ -5766,7 +5766,7 @@ void Compiler::gtComputeFPlvls(GenTreePtr tree)
     if (kind & GTK_SMPOP)
     {
         GenTreePtr op1 = tree->gtOp.gtOp1;
-        GenTreePtr op2 = tree->gtGetOp2();
+        GenTreePtr op2 = tree->gtGetOp2IfPresent();
 
         /* Check for some special cases */
 
@@ -7581,9 +7581,7 @@ void Compiler::gtBlockOpInit(GenTreePtr result, GenTreePtr dst, GenTreePtr srcOr
 
             if (dst->OperIsLocal() && varTypeIsStruct(dst))
             {
-                unsigned   lclNum                = dst->AsLclVarCommon()->GetLclNum();
-                LclVarDsc* lclVarDsc             = &lvaTable[lclNum];
-                lclVarDsc->lvUsedInSIMDIntrinsic = true;
+                setLclRelatedToSIMDIntrinsic(dst);
             }
         }
     }
@@ -8087,7 +8085,7 @@ GenTreePtr Compiler::gtCloneExpr(
             case GT_SIMD:
             {
                 GenTreeSIMD* simdOp = tree->AsSIMD();
-                copy                = gtNewSIMDNode(simdOp->TypeGet(), simdOp->gtGetOp1(), simdOp->gtGetOp2(),
+                copy                = gtNewSIMDNode(simdOp->TypeGet(), simdOp->gtGetOp1(), simdOp->gtGetOp2IfPresent(),
                                      simdOp->gtSIMDIntrinsicID, simdOp->gtSIMDBaseType, simdOp->gtSIMDSize);
             }
             break;
@@ -8135,7 +8133,7 @@ GenTreePtr Compiler::gtCloneExpr(
             }
         }
 
-        if (tree->gtGetOp2())
+        if (tree->gtGetOp2IfPresent())
         {
             copy->gtOp.gtOp2 = gtCloneExpr(tree->gtOp.gtOp2, addFlags, deepVarNum, deepVarVal);
         }
@@ -8186,7 +8184,7 @@ GenTreePtr Compiler::gtCloneExpr(
         {
             copy->gtFlags |= (copy->gtOp.gtOp1->gtFlags & GTF_ALL_EFFECT);
         }
-        if (copy->gtGetOp2() != nullptr)
+        if (copy->gtGetOp2IfPresent() != nullptr)
         {
             copy->gtFlags |= (copy->gtGetOp2()->gtFlags & GTF_ALL_EFFECT);
         }
@@ -11319,7 +11317,7 @@ void Compiler::gtDispTree(GenTreePtr   tree,
     {
         if (!topOnly)
         {
-            if (tree->gtGetOp2())
+            if (tree->gtGetOp2IfPresent())
             {
                 // Label the childMsgs of the GT_COLON operator
                 // op2 is the then part
@@ -12683,7 +12681,7 @@ GenTreePtr Compiler::gtFoldExprConst(GenTreePtr tree)
     assert(kind & (GTK_UNOP | GTK_BINOP));
 
     GenTreePtr op1 = tree->gtOp.gtOp1;
-    GenTreePtr op2 = tree->gtGetOp2();
+    GenTreePtr op2 = tree->gtGetOp2IfPresent();
 
     if (!opts.OptEnabled(CLFLG_CONSTANTFOLD))
     {
@@ -14575,7 +14573,7 @@ void Compiler::gtExtractSideEffList(GenTreePtr  expr,
     if (kind & GTK_SMPOP)
     {
         GenTreePtr op1 = expr->gtOp.gtOp1;
-        GenTreePtr op2 = expr->gtGetOp2();
+        GenTreePtr op2 = expr->gtGetOp2IfPresent();
 
         if (flags & GTF_EXCEPT)
         {
@@ -15129,14 +15127,17 @@ BasicBlock* Compiler::bbNewBasicBlock(BBjumpKinds jumpKind)
         VarSetOps::AssignNoCopy(this, block->bbScope, VarSetOps::UninitVal());
     }
 
-    block->bbHeapUse     = false;
-    block->bbHeapDef     = false;
-    block->bbHeapLiveIn  = false;
-    block->bbHeapLiveOut = false;
+    block->bbMemoryUse     = emptyMemoryKindSet;
+    block->bbMemoryDef     = emptyMemoryKindSet;
+    block->bbMemoryLiveIn  = emptyMemoryKindSet;
+    block->bbMemoryLiveOut = emptyMemoryKindSet;
 
-    block->bbHeapSsaPhiFunc = nullptr;
-    block->bbHeapSsaNumIn   = 0;
-    block->bbHeapSsaNumOut  = 0;
+    for (MemoryKind memoryKind : allMemoryKinds())
+    {
+        block->bbMemorySsaPhiFunc[memoryKind] = nullptr;
+        block->bbMemorySsaNumIn[memoryKind]   = 0;
+        block->bbMemorySsaNumOut[memoryKind]  = 0;
+    }
 
     // Make sure we reserve a NOT_IN_LOOP value that isn't a legal table index.
     static_assert_no_msg(MAX_LOOP_NUM < BasicBlock::NOT_IN_LOOP);
@@ -16323,8 +16324,15 @@ CORINFO_CLASS_HANDLE Compiler::gtGetStructHandleIfPresent(GenTree* tree)
             case GT_ASG:
                 structHnd = gtGetStructHandleIfPresent(tree->gtGetOp1());
                 break;
-            case GT_LCL_VAR:
             case GT_LCL_FLD:
+#ifdef FEATURE_SIMD
+                if (varTypeIsSIMD(tree))
+                {
+                    structHnd = gtGetStructHandleForSIMD(tree->gtType, TYP_FLOAT);
+                }
+#endif
+                break;
+            case GT_LCL_VAR:
                 structHnd = lvaTable[tree->AsLclVarCommon()->gtLclNum].lvVerTypeInfo.GetClassHandle();
                 break;
             case GT_RETURN:
@@ -16862,15 +16870,8 @@ bool FieldSeqNode::IsPseudoField()
 GenTreeSIMD* Compiler::gtNewSIMDNode(
     var_types type, GenTreePtr op1, SIMDIntrinsicID simdIntrinsicID, var_types baseType, unsigned size)
 {
-    // TODO-CQ: An operand may be a GT_OBJ(GT_ADDR(GT_LCL_VAR))), in which case it should be
-    // marked lvUsedInSIMDIntrinsic.
     assert(op1 != nullptr);
-    if (op1->OperGet() == GT_LCL_VAR)
-    {
-        unsigned   lclNum                = op1->AsLclVarCommon()->GetLclNum();
-        LclVarDsc* lclVarDsc             = &lvaTable[lclNum];
-        lclVarDsc->lvUsedInSIMDIntrinsic = true;
-    }
+    SetOpLclRelatedToSIMDIntrinsic(op1);
 
     return new (this, GT_SIMD) GenTreeSIMD(type, op1, simdIntrinsicID, baseType, size);
 }
@@ -16878,24 +16879,34 @@ GenTreeSIMD* Compiler::gtNewSIMDNode(
 GenTreeSIMD* Compiler::gtNewSIMDNode(
     var_types type, GenTreePtr op1, GenTreePtr op2, SIMDIntrinsicID simdIntrinsicID, var_types baseType, unsigned size)
 {
-    // TODO-CQ: An operand may be a GT_OBJ(GT_ADDR(GT_LCL_VAR))), in which case it should be
-    // marked lvUsedInSIMDIntrinsic.
     assert(op1 != nullptr);
-    if (op1->OperIsLocal())
+    SetOpLclRelatedToSIMDIntrinsic(op1);
+    if (op2 != nullptr)
     {
-        unsigned   lclNum                = op1->AsLclVarCommon()->GetLclNum();
-        LclVarDsc* lclVarDsc             = &lvaTable[lclNum];
-        lclVarDsc->lvUsedInSIMDIntrinsic = true;
+        SetOpLclRelatedToSIMDIntrinsic(op2);
     }
 
-    if (op2 != nullptr && op2->OperIsLocal())
+    return new (this, GT_SIMD) GenTreeSIMD(type, op1, op2, simdIntrinsicID, baseType, size);
+}
+
+//-------------------------------------------------------------------
+// SetOpLclRelatedToSIMDIntrinsic: Determine if the tree has a local var that needs to be set
+// as used by a SIMD intrinsic, and if so, set that local var appropriately.
+//
+// Arguments:
+//     op - The tree, to be an operand of a new GT_SIMD node, to check.
+//
+void Compiler::SetOpLclRelatedToSIMDIntrinsic(GenTreePtr op)
+{
+    if (op->OperIsLocal())
     {
-        unsigned   lclNum                = op2->AsLclVarCommon()->GetLclNum();
-        LclVarDsc* lclVarDsc             = &lvaTable[lclNum];
-        lclVarDsc->lvUsedInSIMDIntrinsic = true;
+        setLclRelatedToSIMDIntrinsic(op);
+    }
+    else if ((op->OperGet() == GT_OBJ) && (op->gtOp.gtOp1->OperGet() == GT_ADDR) &&
+             op->gtOp.gtOp1->gtOp.gtOp1->OperIsLocal())
+    {
+        setLclRelatedToSIMDIntrinsic(op->gtOp.gtOp1->gtOp.gtOp1);
     }
-
-    return new (this, GT_SIMD) GenTreeSIMD(type, op1, op2, simdIntrinsicID, baseType, size);
 }
 
 bool GenTree::isCommutativeSIMDIntrinsic()
diff --git a/src/jit/gentree.h b/src/jit/gentree.h
index e752e19c6f..0ea8321e77 100644
--- a/src/jit/gentree.h
+++ b/src/jit/gentree.h
@@ -590,7 +590,8 @@ public:
 
     bool isUsedFromMemory() const
     {
-        return ((isContained() && (isMemoryOp() || (OperGet() == GT_LCL_VAR))) || isUsedFromSpillTemp());
+        return ((isContained() && (isMemoryOp() || (OperGet() == GT_LCL_VAR) || (OperGet() == GT_CNS_DBL))) ||
+                isUsedFromSpillTemp());
     }
 
     bool isLclVarUsedFromMemory() const
@@ -1602,8 +1603,14 @@ public:
 
     inline GenTreePtr gtGetOp1();
 
+    // Directly return op2. Asserts the node is binary. Might return nullptr if the binary node allows
+    // a nullptr op2, such as GT_LIST. This is more efficient than gtGetOp2IfPresent() if you know what
+    // node type you have.
     inline GenTreePtr gtGetOp2();
 
+    // The returned pointer might be nullptr if the node is not binary, or if non-null op2 is not required.
+    inline GenTreePtr gtGetOp2IfPresent();
+
     // Given a tree node, if this is a child of that node, return the pointer to the child node so that it
     // can be modified; otherwise, return null.
     GenTreePtr* gtGetChildPointer(GenTreePtr parent);
@@ -3262,43 +3269,52 @@ struct GenTreeCall final : public GenTree
 #endif
     }
 
-#define GTF_CALL_M_EXPLICIT_TAILCALL                                                                                   \
-    0x0001                         // GT_CALL -- the call is "tail" prefixed and importer has performed tail call checks
-#define GTF_CALL_M_TAILCALL 0x0002 // GT_CALL -- the call is a tailcall
-#define GTF_CALL_M_VARARGS 0x0004  // GT_CALL -- the call uses varargs ABI
-#define GTF_CALL_M_RETBUFFARG 0x0008        // GT_CALL -- first parameter is the return buffer argument
-#define GTF_CALL_M_DELEGATE_INV 0x0010      // GT_CALL -- call to Delegate.Invoke
-#define GTF_CALL_M_NOGCCHECK 0x0020         // GT_CALL -- not a call for computing full interruptability
-#define GTF_CALL_M_SPECIAL_INTRINSIC 0x0040 // GT_CALL -- function that could be optimized as an intrinsic
-                                            // in special cases. Used to optimize fast way out in morphing
-#define GTF_CALL_M_UNMGD_THISCALL                                                                                      \
-    0x0080 // "this" pointer (first argument) should be enregistered (only for GTF_CALL_UNMANAGED)
-#define GTF_CALL_M_VIRTSTUB_REL_INDIRECT                                                                               \
-    0x0080 // the virtstub is indirected through a relative address (only for GTF_CALL_VIRT_STUB)
-#define GTF_CALL_M_NONVIRT_SAME_THIS                                                                                   \
-    0x0080 // callee "this" pointer is equal to caller this pointer (only for GTF_CALL_NONVIRT)
-#define GTF_CALL_M_FRAME_VAR_DEATH 0x0100 // GT_CALL -- the compLvFrameListRoot variable dies here (last use)
+// clang-format off
+
+#define GTF_CALL_M_EXPLICIT_TAILCALL     0x00000001 // GT_CALL -- the call is "tail" prefixed and 
+                                                    // importer has performed tail call checks
+#define GTF_CALL_M_TAILCALL              0x00000002 // GT_CALL -- the call is a tailcall
+#define GTF_CALL_M_VARARGS               0x00000004 // GT_CALL -- the call uses varargs ABI
+#define GTF_CALL_M_RETBUFFARG            0x00000008 // GT_CALL -- first parameter is the return buffer argument
+#define GTF_CALL_M_DELEGATE_INV          0x00000010 // GT_CALL -- call to Delegate.Invoke
+#define GTF_CALL_M_NOGCCHECK             0x00000020 // GT_CALL -- not a call for computing full interruptability
+#define GTF_CALL_M_SPECIAL_INTRINSIC     0x00000040 // GT_CALL -- function that could be optimized as an intrinsic
+                                                    // in special cases. Used to optimize fast way out in morphing
+#define GTF_CALL_M_UNMGD_THISCALL        0x00000080 // GT_CALL -- "this" pointer (first argument) 
+                                                    // should be enregistered (only for GTF_CALL_UNMANAGED)
+#define GTF_CALL_M_VIRTSTUB_REL_INDIRECT 0x00000080 // the virtstub is indirected through 
+                                                    // a relative address (only for GTF_CALL_VIRT_STUB)
+#define GTF_CALL_M_NONVIRT_SAME_THIS     0x00000080 // GT_CALL -- callee "this" pointer is 
+                                                    // equal to caller this pointer (only for GTF_CALL_NONVIRT)
+#define GTF_CALL_M_FRAME_VAR_DEATH       0x00000100 // GT_CALL -- the compLvFrameListRoot variable dies here (last use)
 
 #ifndef LEGACY_BACKEND
-#define GTF_CALL_M_TAILCALL_VIA_HELPER 0x0200 // GT_CALL -- call is a tail call dispatched via tail call JIT helper.
-#endif                                        // !LEGACY_BACKEND
+#define GTF_CALL_M_TAILCALL_VIA_HELPER   0x00000200 // GT_CALL -- call is a tail call dispatched via tail call JIT helper.
+#endif
 
 #if FEATURE_TAILCALL_OPT
-#define GTF_CALL_M_IMPLICIT_TAILCALL                                                                                   \
-    0x0400 // GT_CALL -- call is an opportunistic tail call and importer has performed tail call checks
-#define GTF_CALL_M_TAILCALL_TO_LOOP                                                                                    \
-    0x0800 // GT_CALL -- call is a fast recursive tail call that can be converted into a loop
+#define GTF_CALL_M_IMPLICIT_TAILCALL     0x00000400 // GT_CALL -- call is an opportunistic 
+                                                    // tail call and importer has performed tail call checks
+#define GTF_CALL_M_TAILCALL_TO_LOOP      0x00000800 // GT_CALL -- call is a fast recursive tail call
+                                                    // that can be converted into a loop
 #endif
 
-#define GTF_CALL_M_PINVOKE 0x1000 // GT_CALL -- call is a pinvoke.  This mirrors VM flag CORINFO_FLG_PINVOKE.
-                                  // A call marked as Pinvoke is not necessarily a GT_CALL_UNMANAGED. For e.g.
-                                  // an IL Stub dynamically generated for a PInvoke declaration is flagged as
-                                  // a Pinvoke but not as an unmanaged call. See impCheckForPInvokeCall() to
-                                  // know when these flags are set.
+#define GTF_CALL_M_PINVOKE               0x00001000 // GT_CALL -- call is a pinvoke.  This mirrors VM flag CORINFO_FLG_PINVOKE.
+                                                    // A call marked as Pinvoke is not necessarily a GT_CALL_UNMANAGED. For e.g.
+                                                    // an IL Stub dynamically generated for a PInvoke declaration is flagged as
+                                                    // a Pinvoke but not as an unmanaged call. See impCheckForPInvokeCall() to
+                                                    // know when these flags are set.
 
-#define GTF_CALL_M_R2R_REL_INDIRECT 0x2000    // GT_CALL -- ready to run call is indirected through a relative address
-#define GTF_CALL_M_DOES_NOT_RETURN 0x4000     // GT_CALL -- call does not return
-#define GTF_CALL_M_SECURE_DELEGATE_INV 0x8000 // GT_CALL -- call is in secure delegate
+#define GTF_CALL_M_R2R_REL_INDIRECT      0x00002000 // GT_CALL -- ready to run call is indirected through a relative address
+#define GTF_CALL_M_DOES_NOT_RETURN       0x00004000 // GT_CALL -- call does not return
+#define GTF_CALL_M_SECURE_DELEGATE_INV   0x00008000 // GT_CALL -- call is in secure delegate
+#define GTF_CALL_M_FAT_POINTER_CHECK     0x00010000 // GT_CALL -- CoreRT managed calli needs transformation, that checks
+                                                    // special bit in calli address. If it is set, then it is necessary 
+                                                    // to restore real function address and load hidden argument 
+                                                    // as the first argument for calli. It is CoreRT replacement for instantiating 
+                                                    // stubs, because executable code cannot be generated at runtime.
+
+    // clang-format on
 
     bool IsUnmanaged() const
     {
@@ -3496,9 +3512,24 @@ struct GenTreeCall final : public GenTree
         return (gtCallMoreFlags & GTF_CALL_M_DOES_NOT_RETURN) != 0;
     }
 
+    bool IsFatPointerCandidate() const
+    {
+        return (gtCallMoreFlags & GTF_CALL_M_FAT_POINTER_CHECK) != 0;
+    }
+
     bool IsPure(Compiler* compiler) const;
 
-    unsigned short gtCallMoreFlags; // in addition to gtFlags
+    void ClearFatPointerCandidate()
+    {
+        gtCallMoreFlags &= ~GTF_CALL_M_FAT_POINTER_CHECK;
+    }
+
+    void SetFatPointerCandidate()
+    {
+        gtCallMoreFlags |= GTF_CALL_M_FAT_POINTER_CHECK;
+    }
+
+    unsigned gtCallMoreFlags; // in addition to gtFlags
 
     unsigned char gtCallType : 3;   // value from the gtCallTypes enumeration
     unsigned char gtReturnType : 5; // exact return type
@@ -4545,6 +4576,9 @@ struct GenTreePhiArg : public GenTreeLclVarCommon
 struct GenTreePutArgStk : public GenTreeUnOp
 {
     unsigned gtSlotNum; // Slot number of the argument to be passed on stack
+#if defined(UNIX_X86_ABI)
+    unsigned gtPadAlign; // Number of padding slots for stack alignment
+#endif
 
 #if FEATURE_FASTTAILCALL
     bool putInIncomingArgArea; // Whether this arg needs to be placed in incoming arg area.
@@ -4560,6 +4594,9 @@ struct GenTreePutArgStk : public GenTreeUnOp
                          DEBUGARG(bool largeNode = false))
         : GenTreeUnOp(oper, type DEBUGARG(largeNode))
         , gtSlotNum(slotNum)
+#if defined(UNIX_X86_ABI)
+        , gtPadAlign(0)
+#endif
         , putInIncomingArgArea(_putInIncomingArgArea)
 #ifdef FEATURE_PUT_STRUCT_ARG_STK
         , gtPutArgStkKind(Kind::Invalid)
@@ -4581,6 +4618,9 @@ struct GenTreePutArgStk : public GenTreeUnOp
                          DEBUGARG(bool largeNode = false))
         : GenTreeUnOp(oper, type, op1 DEBUGARG(largeNode))
         , gtSlotNum(slotNum)
+#if defined(UNIX_X86_ABI)
+        , gtPadAlign(0)
+#endif
         , putInIncomingArgArea(_putInIncomingArgArea)
 #ifdef FEATURE_PUT_STRUCT_ARG_STK
         , gtPutArgStkKind(Kind::Invalid)
@@ -4602,6 +4642,9 @@ struct GenTreePutArgStk : public GenTreeUnOp
                          DEBUGARG(GenTreePtr callNode = NULL) DEBUGARG(bool largeNode = false))
         : GenTreeUnOp(oper, type DEBUGARG(largeNode))
         , gtSlotNum(slotNum)
+#if defined(UNIX_X86_ABI)
+        , gtPadAlign(0)
+#endif
 #ifdef FEATURE_PUT_STRUCT_ARG_STK
         , gtPutArgStkKind(Kind::Invalid)
         , gtNumSlots(numSlots)
@@ -4621,6 +4664,9 @@ struct GenTreePutArgStk : public GenTreeUnOp
                          DEBUGARG(GenTreePtr callNode = NULL) DEBUGARG(bool largeNode = false))
         : GenTreeUnOp(oper, type, op1 DEBUGARG(largeNode))
         , gtSlotNum(slotNum)
+#if defined(UNIX_X86_ABI)
+        , gtPadAlign(0)
+#endif
 #ifdef FEATURE_PUT_STRUCT_ARG_STK
         , gtPutArgStkKind(Kind::Invalid)
         , gtNumSlots(numSlots)
@@ -4639,6 +4685,18 @@ struct GenTreePutArgStk : public GenTreeUnOp
         return gtSlotNum * TARGET_POINTER_SIZE;
     }
 
+#if defined(UNIX_X86_ABI)
+    unsigned getArgPadding()
+    {
+        return gtPadAlign;
+    }
+
+    void setArgPadding(unsigned padAlign)
+    {
+        gtPadAlign = padAlign;
+    }
+#endif
+
 #ifdef FEATURE_PUT_STRUCT_ARG_STK
     unsigned getArgSize()
     {
@@ -4982,7 +5040,7 @@ inline bool GenTree::IsIntegralConstVector(ssize_t constVal)
     if ((gtOper == GT_SIMD) && (gtSIMD.gtSIMDIntrinsicID == SIMDIntrinsicInit) && gtGetOp1()->IsIntegralConst(constVal))
     {
         assert(varTypeIsIntegral(gtSIMD.gtSIMDBaseType));
-        assert(gtGetOp2() == nullptr);
+        assert(gtGetOp2IfPresent() == nullptr);
         return true;
     }
 #endif
@@ -5163,12 +5221,24 @@ inline bool GenTree::RequiresNonNullOp2(genTreeOps oper)
 
 inline GenTreePtr GenTree::gtGetOp2()
 {
+    assert(OperIsBinary());
+
+    GenTreePtr op2 = gtOp.gtOp2;
+
+    // Only allow null op2 if the node type allows it, e.g. GT_LIST.
+    assert((op2 != nullptr) || !RequiresNonNullOp2(gtOper));
+
+    return op2;
+}
+
+inline GenTreePtr GenTree::gtGetOp2IfPresent()
+{
     /* gtOp.gtOp2 is only valid for GTK_BINOP nodes. */
 
     GenTreePtr op2 = OperIsBinary() ? gtOp.gtOp2 : nullptr;
 
     // This documents the genTreeOps for which gtOp.gtOp2 cannot be nullptr.
-    // This helps prefix in its analyis of code which calls gtGetOp2()
+    // This helps prefix in its analysis of code which calls gtGetOp2()
 
     assert((op2 != nullptr) || !RequiresNonNullOp2(gtOper));
 
diff --git a/src/jit/importer.cpp b/src/jit/importer.cpp
index 026628dbee..1849a57848 100644
--- a/src/jit/importer.cpp
+++ b/src/jit/importer.cpp
@@ -1514,10 +1514,8 @@ var_types Compiler::impNormStructType(CORINFO_CLASS_HANDLE structHnd,
                 {
                     *pSimdBaseType = simdBaseType;
                 }
-#ifdef _TARGET_AMD64_
-                // Amd64: also indicate that we use floating point registers
+                // Also indicate that we use floating point registers.
                 compFloatingPointUsed = true;
-#endif
             }
         }
     }
@@ -6434,6 +6432,7 @@ var_types Compiler::impImportCall(OPCODE                  opcode,
         eeGetSig(pResolvedToken->token, info.compScopeHnd, impTokenLookupContextHandle, &calliSig);
 
         callRetTyp = JITtype2varType(calliSig.retType);
+        clsHnd     = calliSig.retTypeClass;
 
         call = impImportIndirectCall(&calliSig, ilOffset);
 
@@ -6462,6 +6461,16 @@ var_types Compiler::impImportCall(OPCODE                  opcode,
         call->gtCall.callSig  = new (this, CMK_CorSig) CORINFO_SIG_INFO;
         *call->gtCall.callSig = calliSig;
 #endif // DEBUG
+
+        if (IsTargetAbi(CORINFO_CORERT_ABI))
+        {
+            bool managedCall = (calliSig.callConv & GTF_CALL_UNMANAGED) == 0;
+            if (managedCall)
+            {
+                call->AsCall()->SetFatPointerCandidate();
+                setMethodHasFatPointer();
+            }
+        }
     }
     else // (opcode != CEE_CALLI)
     {
@@ -6608,7 +6617,6 @@ var_types Compiler::impImportCall(OPCODE                  opcode,
         if ((mflags & CORINFO_FLG_VIRTUAL) && (mflags & CORINFO_FLG_EnC) && (opcode == CEE_CALLVIRT))
         {
             NO_WAY("Virtual call to a function added via EnC is not supported");
-            goto DONE_CALL;
         }
 
         if ((sig->callConv & CORINFO_CALLCONV_MASK) != CORINFO_CALLCONV_DEFAULT &&
@@ -7544,10 +7552,8 @@ DONE:
         }
     }
 
-// Note: we assume that small return types are already normalized by the managed callee
-// or by the pinvoke stub for calls to unmanaged code.
-
-DONE_CALL:
+    // Note: we assume that small return types are already normalized by the managed callee
+    // or by the pinvoke stub for calls to unmanaged code.
 
     if (!bIntrinsicImported)
     {
@@ -7592,6 +7598,7 @@ DONE_CALL:
         impMarkInlineCandidate(call, exactContextHnd, callInfo);
     }
 
+DONE_CALL:
     // Push or append the result of the call
     if (callRetTyp == TYP_VOID)
     {
@@ -7644,9 +7651,11 @@ DONE_CALL:
             }
         }
 
-        if (call->gtOper == GT_CALL)
+        if (call->IsCall())
         {
             // Sometimes "call" is not a GT_CALL (if we imported an intrinsic that didn't turn into a call)
+
+            bool fatPointerCandidate = call->AsCall()->IsFatPointerCandidate();
             if (varTypeIsStruct(callRetTyp))
             {
                 call = impFixupCallStructReturn(call, sig->retTypeClass);
@@ -7655,6 +7664,7 @@ DONE_CALL:
             if ((call->gtFlags & GTF_CALL_INLINE_CANDIDATE) != 0)
             {
                 assert(opts.OptEnabled(CLFLG_INLINING));
+                assert(!fatPointerCandidate); // We should not try to inline calli.
 
                 // Make the call its own tree (spill the stack if needed).
                 impAppendTree(call, (unsigned)CHECK_SPILL_ALL, impCurStmtOffs);
@@ -7664,10 +7674,51 @@ DONE_CALL:
             }
             else
             {
+                if (fatPointerCandidate)
+                {
+                    // fatPointer candidates should be in statements of the form call() or var = call().
+                    // Such form allows to find statements with fat calls without walking through whole trees
+                    // and removes problems with cutting trees.
+                    assert(!bIntrinsicImported);
+                    assert(IsTargetAbi(CORINFO_CORERT_ABI));
+                    if (call->OperGet() != GT_LCL_VAR) // can be already converted by impFixupCallStructReturn.
+                    {
+                        unsigned   calliSlot  = lvaGrabTemp(true DEBUGARG("calli"));
+                        LclVarDsc* varDsc     = &lvaTable[calliSlot];
+                        varDsc->lvVerTypeInfo = tiRetVal;
+                        impAssignTempGen(calliSlot, call, clsHnd, (unsigned)CHECK_SPILL_NONE);
+                        // impAssignTempGen can change src arg list and return type for call that returns struct.
+                        var_types type = genActualType(lvaTable[calliSlot].TypeGet());
+                        call           = gtNewLclvNode(calliSlot, type);
+                    }
+                }
+
                 // For non-candidates we must also spill, since we
                 // might have locals live on the eval stack that this
                 // call can modify.
-                impSpillSideEffects(true, CHECK_SPILL_ALL DEBUGARG("non-inline candidate call"));
+                //
+                // Suppress this for certain well-known call targets
+                // that we know won't modify locals, eg calls that are
+                // recognized in gtCanOptimizeTypeEquality. Otherwise
+                // we may break key fragile pattern matches later on.
+                bool spillStack = true;
+                if (call->IsCall())
+                {
+                    GenTreeCall* callNode = call->AsCall();
+                    if ((callNode->gtCallType == CT_HELPER) && gtIsTypeHandleToRuntimeTypeHelper(callNode))
+                    {
+                        spillStack = false;
+                    }
+                    else if ((callNode->gtCallMoreFlags & GTF_CALL_M_SPECIAL_INTRINSIC) != 0)
+                    {
+                        spillStack = false;
+                    }
+                }
+
+                if (spillStack)
+                {
+                    impSpillSideEffects(true, CHECK_SPILL_ALL DEBUGARG("non-inline candidate call"));
+                }
             }
         }
 
@@ -12742,11 +12793,31 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                             prefixFlags |= PREFIX_TAILCALL_EXPLICIT;
                         }
                     }
+                }
+
+                // This is split up to avoid goto flow warnings.
+                bool isRecursive;
+                isRecursive = !compIsForInlining() && (callInfo.hMethod == info.compMethodHnd);
 
-                    // Note that when running under tail call stress, a call will be marked as explicit tail prefixed
-                    // hence will not be considered for implicit tail calling.
-                    bool isRecursive = (callInfo.hMethod == info.compMethodHnd);
-                    if (impIsImplicitTailCallCandidate(opcode, codeAddr + sz, codeEndp, prefixFlags, isRecursive))
+                // Note that when running under tail call stress, a call will be marked as explicit tail prefixed
+                // hence will not be considered for implicit tail calling.
+                if (impIsImplicitTailCallCandidate(opcode, codeAddr + sz, codeEndp, prefixFlags, isRecursive))
+                {
+                    if (compIsForInlining())
+                    {
+#if FEATURE_TAILCALL_OPT_SHARED_RETURN
+                        // Are we inlining at an implicit tail call site? If so the we can flag
+                        // implicit tail call sites in the inline body. These call sites
+                        // often end up in non BBJ_RETURN blocks, so only flag them when
+                        // we're able to handle shared returns.
+                        if (impInlineInfo->iciCall->IsImplicitTailCall())
+                        {
+                            JITDUMP(" (Inline Implicit Tail call: prefixFlags |= PREFIX_TAILCALL_IMPLICIT)");
+                            prefixFlags |= PREFIX_TAILCALL_IMPLICIT;
+                        }
+#endif // FEATURE_TAILCALL_OPT_SHARED_RETURN
+                    }
+                    else
                     {
                         JITDUMP(" (Implicit Tail call: prefixFlags |= PREFIX_TAILCALL_IMPLICIT)");
                         prefixFlags |= PREFIX_TAILCALL_IMPLICIT;
@@ -12765,7 +12836,7 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                     impHandleAccessAllowed(callInfo.accessAllowed, &callInfo.callsiteCalloutHelper);
 
 #if 0 // DevDiv 410397 - This breaks too many obfuscated apps to do this in an in-place release
-     
+
                 // DevDiv 291703 - we need to check for accessibility between the caller of InitializeArray
                 // and the field it is reading, thus it is now unverifiable to not immediately precede with
                 // ldtoken <filed token>, and we now check accessibility
diff --git a/src/jit/instr.cpp b/src/jit/instr.cpp
index edc4483c6b..35db2a5716 100644
--- a/src/jit/instr.cpp
+++ b/src/jit/instr.cpp
@@ -2326,7 +2326,7 @@ void CodeGen::inst_RV_TT(instruction ins,
 #if CPU_LOAD_STORE_ARCH
     if (ins == INS_mov)
     {
-#if defined(_TARGET_ARM_)
+#if defined(_TARGET_ARM_) && CPU_LONG_USES_REGPAIR
         if (tree->TypeGet() != TYP_LONG)
         {
             ins = ins_Move_Extend(tree->TypeGet(), (tree->gtFlags & GTF_REG_VAL) != 0);
@@ -2341,7 +2341,7 @@ void CodeGen::inst_RV_TT(instruction ins,
             ins = ins_Move_Extend(TYP_INT,
                                   (tree->gtFlags & GTF_REG_VAL) != 0 && genRegPairHi(tree->gtRegPair) != REG_STK);
         }
-#elif defined(_TARGET_ARM64_)
+#elif defined(_TARGET_ARM_) || defined(_TARGET_ARM64_)
         ins = ins_Move_Extend(tree->TypeGet(), (tree->gtFlags & GTF_REG_VAL) != 0);
 #else
         NYI("CodeGen::inst_RV_TT with INS_mov");
@@ -2485,9 +2485,11 @@ AGAIN:
                 default:
                     regNumber regTmp;
 #ifndef LEGACY_BACKEND
+#if CPU_LONG_USES_REGPAIR
                     if (tree->TypeGet() == TYP_LONG)
                         regTmp = (offs == 0) ? genRegPairLo(tree->gtRegPair) : genRegPairHi(tree->gtRegPair);
                     else
+#endif // CPU_LONG_USES_REGPAIR
                         regTmp = tree->gtRegNum;
 #else  // LEGACY_BACKEND
                     if (varTypeIsFloating(tree))
@@ -2595,17 +2597,6 @@ AGAIN:
                 constVal = (ssize_t)(tree->gtLngCon.gtLconVal >> 32);
                 size     = EA_4BYTE;
             }
-#ifndef LEGACY_BACKEND
-#ifdef _TARGET_ARM_
-            if ((ins != INS_mov) && !arm_Valid_Imm_For_Instr(ins, constVal, flags))
-            {
-                regNumber constReg = (offs == 0) ? genRegPairLo(tree->gtRegPair) : genRegPairHi(tree->gtRegPair);
-                instGen_Set_Reg_To_Imm(size, constReg, constVal);
-                getEmitter()->emitIns_R_R(ins, size, reg, constReg, flags);
-                break;
-            }
-#endif // _TARGET_ARM_
-#endif // !LEGACY_BACKEND
 
             inst_RV_IV(ins, reg, constVal, size, flags);
             break;
@@ -3513,6 +3504,12 @@ instruction CodeGen::ins_CopyIntToFloat(var_types srcType, var_types dstType)
 {
     // On SSE2/AVX - the same instruction is used for moving double/quad word to XMM/YMM register.
     assert((srcType == TYP_INT) || (srcType == TYP_UINT) || (srcType == TYP_LONG) || (srcType == TYP_ULONG));
+
+#if !defined(_TARGET_64BIT_)
+    // No 64-bit registers on x86.
+    assert((srcType != TYP_LONG) && (srcType != TYP_ULONG));
+#endif // !defined(_TARGET_64BIT_)
+
     return INS_mov_i2xmm;
 }
 
@@ -3520,6 +3517,12 @@ instruction CodeGen::ins_CopyFloatToInt(var_types srcType, var_types dstType)
 {
     // On SSE2/AVX - the same instruction is used for moving double/quad word of XMM/YMM to an integer register.
     assert((dstType == TYP_INT) || (dstType == TYP_UINT) || (dstType == TYP_LONG) || (dstType == TYP_ULONG));
+
+#if !defined(_TARGET_64BIT_)
+    // No 64-bit registers on x86.
+    assert((dstType != TYP_LONG) && (dstType != TYP_ULONG));
+#endif // !defined(_TARGET_64BIT_)
+
     return INS_mov_xmm2i;
 }
 
diff --git a/src/jit/jit.h b/src/jit/jit.h
index c485ff0bea..05b154e15a 100644
--- a/src/jit/jit.h
+++ b/src/jit/jit.h
@@ -416,14 +416,6 @@ typedef ptrdiff_t ssize_t;
 
 //=============================================================================
 
-#define FANCY_ARRAY_OPT 0 // optimize more complex index checks
-
-//=============================================================================
-
-#define LONG_ASG_OPS 0 // implementation isn't complete yet
-
-//=============================================================================
-
 #define OPT_MULT_ADDSUB 1 // optimize consecutive "lclVar += or -= icon"
 #define OPT_BOOL_OPS 1    // optimize boolean operations
 
diff --git a/src/jit/jit.settings.targets b/src/jit/jit.settings.targets
index 6c0474a00c..8749b80242 100644
--- a/src/jit/jit.settings.targets
+++ b/src/jit/jit.settings.targets
@@ -95,9 +95,11 @@
     <ItemGroup Condition="'$(TargetArch)'=='i386'">
         <CppCompile Include="..\emitXArch.cpp" />
         <CppCompile Include="..\TargetX86.cpp" />
+        <CppCompile Include="..\unwindx86.cpp" />
         <CppCompile Condition="'$(ClDefines.Contains(`LEGACY_BACKEND`))'=='True'" Include="..\stackfp.cpp" />
         <CppCompile Condition="'$(ClDefines.Contains(`LEGACY_BACKEND`))'=='False'"  Include="..\DecomposeLongs.cpp" />
         <CppCompile Condition="'$(ClDefines.Contains(`LEGACY_BACKEND`))'=='False'"  Include="..\LowerXArch.cpp" />
+        <CppCompile Condition="'$(ClDefines.Contains(`LEGACY_BACKEND`))'=='False'"  Include="..\lsraxarch.cpp" />
         <CppCompile Condition="'$(ClDefines.Contains(`LEGACY_BACKEND`))'=='False'"  Include="..\CodeGenXArch.cpp" />
         <CppCompile Condition="'$(ClDefines.Contains(`LEGACY_BACKEND`))'=='False'"  Include="..\SIMD.cpp" />
         <CppCompile Condition="'$(ClDefines.Contains(`LEGACY_BACKEND`))'=='False'"  Include="..\SIMDCodeGenXArch.cpp" />
@@ -107,6 +109,7 @@
         <CppCompile Include="..\emitXArch.cpp" />
         <CppCompile Include="..\TargetAmd64.cpp" />
         <CppCompile Include="..\LowerXArch.cpp" />
+        <CppCompile Include="..\lsraxarch.cpp" />
         <CppCompile Include="..\CodeGenXArch.cpp" />
         <CppCompile Include="..\SIMD.cpp" />
         <CppCompile Include="..\SIMDCodeGenXArch.cpp" />
@@ -118,6 +121,7 @@
         <CppCompile Condition="'$(ClDefines.Contains(`LEGACY_BACKEND`))'=='True'" Include="..\registerfp.cpp" />
         <CppCompile Condition="'$(ClDefines.Contains(`LEGACY_BACKEND`))'=='False'"  Include="..\DecomposeLongs.cpp" />
         <CppCompile Condition="'$(ClDefines.Contains(`LEGACY_BACKEND`))'=='False'"  Include="..\LowerArm.cpp" />
+        <CppCompile Condition="'$(ClDefines.Contains(`LEGACY_BACKEND`))'=='False'"  Include="..\lsraarm.cpp" />
         <CppCompile Condition="'$(ClDefines.Contains(`LEGACY_BACKEND`))'=='False'"  Include="..\CodeGenArm.cpp" />
         <CppCompile Include="..\unwindArm.cpp" />
     </ItemGroup>
@@ -126,6 +130,7 @@
         <CppCompile Include="..\emitarm64.cpp" />
         <CppCompile Include="..\TargetArm64.cpp" />
         <CppCompile Include="..\LowerArm64.cpp" />
+        <CppCompile Include="..\lsraarm64.cpp" />
         <CppCompile Include="..\CodeGenArm64.cpp" />
         <CppCompile Include="..\unwindArm.cpp" />
         <CppCompile Include="..\unwindArm64.cpp" />
diff --git a/src/jit/jitconfigvalues.h b/src/jit/jitconfigvalues.h
index 8a25af05eb..ea6a3aac23 100644
--- a/src/jit/jitconfigvalues.h
+++ b/src/jit/jitconfigvalues.h
@@ -6,6 +6,10 @@
 #error CONFIG_INTEGER, CONFIG_STRING, and CONFIG_METHODSET must be defined before including this file.
 #endif // !defined(CONFIG_INTEGER) || !defined(CONFIG_STRING) || !defined(CONFIG_METHODSET)
 
+#ifdef DEBUG
+#define OPT_CONFIG // Enable optimization level configuration.
+#endif
+
 #if defined(DEBUG)
 CONFIG_INTEGER(AltJitLimit, W("AltJitLimit"), 0)               // Max number of functions to use altjit for (decimal)
 CONFIG_INTEGER(AltJitSkipOnAssert, W("AltJitSkipOnAssert"), 0) // If AltJit hits an assert, fall back to the fallback
@@ -36,13 +40,6 @@ CONFIG_INTEGER(JitDebugLogLoopCloning, W("JitDebugLogLoopCloning"), 0) // In deb
 CONFIG_INTEGER(JitDefaultFill, W("JitDefaultFill"), 0xff) // In debug builds, initialize the memory allocated by the nra
                                                           // with this byte.
 CONFIG_INTEGER(JitDirectAlloc, W("JitDirectAlloc"), 0)
-CONFIG_INTEGER(JitDoAssertionProp, W("JitDoAssertionProp"), 1) // Perform assertion propagation optimization
-CONFIG_INTEGER(JitDoCopyProp, W("JitDoCopyProp"), 1)   // Perform copy propagation on variables that appear redundant
-CONFIG_INTEGER(JitDoEarlyProp, W("JitDoEarlyProp"), 1) // Perform Early Value Propagataion
-CONFIG_INTEGER(JitDoLoopHoisting, W("JitDoLoopHoisting"), 1)   // Perform loop hoisting on loop invariant values
-CONFIG_INTEGER(JitDoRangeAnalysis, W("JitDoRangeAnalysis"), 1) // Perform range check analysis
-CONFIG_INTEGER(JitDoSsa, W("JitDoSsa"), 1) // Perform Static Single Assignment (SSA) numbering on the variables
-CONFIG_INTEGER(JitDoValueNumber, W("JitDoValueNumber"), 1) // Perform value numbering on method expressions
 CONFIG_INTEGER(JitDoubleAlign, W("JitDoubleAlign"), 1)
 CONFIG_INTEGER(JitDumpASCII, W("JitDumpASCII"), 1)         // Uses only ASCII characters in tree dumps
 CONFIG_INTEGER(JitDumpFgDot, W("JitDumpFgDot"), 0)         // Set to non-zero to emit Dot instead of Xml Flowgraph dump
@@ -154,12 +151,10 @@ CONFIG_METHODSET(JitNoProcedureSplittingEH, W("JitNoProcedureSplittingEH")) // D
                                                                             // exception handling
 CONFIG_METHODSET(JitStressOnly, W("JitStressOnly")) // Internal Jit stress mode: stress only the specified method(s)
 CONFIG_METHODSET(JitUnwindDump, W("JitUnwindDump")) // Dump the unwind codes for the method
-CONFIG_METHODSET(JitOptRepeat, W("JitOptRepeat"))   // Runs optimizer multiple times on the method
-CONFIG_INTEGER(JitOptRepeatCount, W("JitOptRepeatCount"), 2) // Number of times to repeat opts when repeating
-CONFIG_METHODSET(NgenDisasm, W("NgenDisasm"))                // Same as JitDisasm, but for ngen
-CONFIG_METHODSET(NgenDump, W("NgenDump"))                    // Same as JitDump, but for ngen
-CONFIG_METHODSET(NgenDumpIR, W("NgenDumpIR"))                // Same as JitDumpIR, but for ngen
-CONFIG_METHODSET(NgenEHDump, W("NgenEHDump"))                // Dump the EH table for the method, as reported to the VM
+CONFIG_METHODSET(NgenDisasm, W("NgenDisasm"))       // Same as JitDisasm, but for ngen
+CONFIG_METHODSET(NgenDump, W("NgenDump"))           // Same as JitDump, but for ngen
+CONFIG_METHODSET(NgenDumpIR, W("NgenDumpIR"))       // Same as JitDumpIR, but for ngen
+CONFIG_METHODSET(NgenEHDump, W("NgenEHDump"))       // Dump the EH table for the method, as reported to the VM
 CONFIG_METHODSET(NgenGCDump, W("NgenGCDump"))
 CONFIG_METHODSET(NgenUnwindDump, W("NgenUnwindDump")) // Dump the unwind codes for the method
 CONFIG_STRING(JitDumpFg, W("JitDumpFg"))              // Dumps Xml/Dot Flowgraph for specified method
@@ -204,13 +199,14 @@ CONFIG_INTEGER(AltJitAssertOnNYI, W("AltJitAssertOnNYI"), 1) // Controls the Alt
 CONFIG_INTEGER(EnableSSE3_4, W("EnableSSE3_4"), 1) // Enable SSE3, SSSE3, SSE 4.1 and 4.2 instruction set as default
 #endif
 
-#if defined(_TARGET_AMD64_)
-CONFIG_INTEGER(EnableAVX, W("EnableAVX"), 1) // Enable AVX instruction set for wide operations as default.
-// When both AVX and SSE3_4 are set, we will use the most capable instruction set available
-// which will prefer AVX over SSE3/4.
-#else  // !defined(_TARGET_AMD64_)
-CONFIG_INTEGER(EnableAVX, W("EnableAVX"), 0)                 // Enable AVX instruction set for wide operations as default
-#endif // defined(_TARGET_AMD64_)
+#if defined(_TARGET_AMD64_) || defined(_TARGET_X86_)
+// Enable AVX instruction set for wide operations as default. When both AVX and SSE3_4 are set, we will use the most
+// capable instruction set available which will prefer AVX over SSE3/4.
+CONFIG_INTEGER(EnableAVX, W("EnableAVX"), 1)
+#else  // !defined(_TARGET_AMD64_) && !defined(_TARGET_X86_)
+// Enable AVX instruction set for wide operations as default
+CONFIG_INTEGER(EnableAVX, W("EnableAVX"), 0)
+#endif // !defined(_TARGET_AMD64_) && !defined(_TARGET_X86_)
 
 #if !defined(DEBUG) && !defined(_DEBUG)
 CONFIG_INTEGER(JitEnableNoWayAssert, W("JitEnableNoWayAssert"), 0)
@@ -235,6 +231,19 @@ CONFIG_INTEGER(JitInlineSIMDMultiplier, W("JitInlineSIMDMultiplier"), 3)
 CONFIG_INTEGER(JitNoRngChks, W("JitNoRngChks"), 0) // If 1, don't generate range checks
 #endif                                             // defined(FEATURE_ENABLE_NO_RANGE_CHECKS)
 
+#if defined(OPT_CONFIG)
+CONFIG_INTEGER(JitDoAssertionProp, W("JitDoAssertionProp"), 1) // Perform assertion propagation optimization
+CONFIG_INTEGER(JitDoCopyProp, W("JitDoCopyProp"), 1)   // Perform copy propagation on variables that appear redundant
+CONFIG_INTEGER(JitDoEarlyProp, W("JitDoEarlyProp"), 1) // Perform Early Value Propagataion
+CONFIG_INTEGER(JitDoLoopHoisting, W("JitDoLoopHoisting"), 1)   // Perform loop hoisting on loop invariant values
+CONFIG_INTEGER(JitDoRangeAnalysis, W("JitDoRangeAnalysis"), 1) // Perform range check analysis
+CONFIG_INTEGER(JitDoSsa, W("JitDoSsa"), 1) // Perform Static Single Assignment (SSA) numbering on the variables
+CONFIG_INTEGER(JitDoValueNumber, W("JitDoValueNumber"), 1) // Perform value numbering on method expressions
+
+CONFIG_METHODSET(JitOptRepeat, W("JitOptRepeat"))            // Runs optimizer multiple times on the method
+CONFIG_INTEGER(JitOptRepeatCount, W("JitOptRepeatCount"), 2) // Number of times to repeat opts when repeating
+#endif                                                       // defined(OPT_CONFIG)
+
 CONFIG_INTEGER(JitRegisterFP, W("JitRegisterFP"), 3)           // Control FP enregistration
 CONFIG_INTEGER(JitTelemetry, W("JitTelemetry"), 1)             // If non-zero, gather JIT telemetry data
 CONFIG_INTEGER(JitVNMapSelBudget, W("JitVNMapSelBudget"), 100) // Max # of MapSelect's considered for a particular
@@ -277,8 +286,10 @@ CONFIG_INTEGER(JitEECallTimingInfo, W("JitEECallTimingInfo"), 0)
 #if defined(DEBUG)
 #if defined(FEATURE_CORECLR)
 CONFIG_INTEGER(JitEnableFinallyCloning, W("JitEnableFinallyCloning"), 1)
+CONFIG_INTEGER(JitEnableRemoveEmptyTry, W("JitEnableRemoveEmptyTry"), 1)
 #else
 CONFIG_INTEGER(JitEnableFinallyCloning, W("JitEnableFinallyCloning"), 0)
+CONFIG_INTEGER(JitEnableRemoveEmptyTry, W("JitEnableRemoveEmptyTry"), 0)
 #endif // defined(FEATURE_CORECLR)
 #endif // DEBUG
 
diff --git a/src/jit/lclvars.cpp b/src/jit/lclvars.cpp
index dc20daaa58..b4e4cc6e55 100644
--- a/src/jit/lclvars.cpp
+++ b/src/jit/lclvars.cpp
@@ -465,7 +465,7 @@ void Compiler::lvaInitRetBuffArg(InitVarDscInfo* varDscInfo)
             varDsc->lvArgReg       = genMapIntRegArgNumToRegNum(retBuffArgNum);
         }
 
-#if FEATURE_MULTIREG__ARGS
+#if FEATURE_MULTIREG_ARGS
         varDsc->lvOtherArgReg = REG_NA;
 #endif
         varDsc->setPrefReg(varDsc->lvArgReg, this);
@@ -488,6 +488,16 @@ void Compiler::lvaInitRetBuffArg(InitVarDscInfo* varDscInfo)
                 varDsc->lvType = TYP_I_IMPL;
             }
         }
+#ifdef FEATURE_SIMD
+        else if (featureSIMD && varTypeIsSIMD(info.compRetType))
+        {
+            varDsc->lvSIMDType = true;
+            varDsc->lvBaseType =
+                getBaseTypeAndSizeOfSIMDType(info.compMethodInfo->args.retTypeClass, &varDsc->lvExactSize);
+            assert(varDsc->lvBaseType != TYP_UNKNOWN);
+        }
+#endif // FEATURE_SIMD
+
         assert(isValidIntArgReg(varDsc->lvArgReg));
 
 #ifdef DEBUG
@@ -1059,7 +1069,7 @@ void Compiler::lvaInitVarArgsHandle(InitVarDscInfo* varDscInfo)
 
             varDsc->lvIsRegArg = 1;
             varDsc->lvArgReg   = genMapRegArgNumToRegNum(varArgHndArgNum, TYP_I_IMPL);
-#if FEATURE_MULTIREG__ARGS
+#if FEATURE_MULTIREG_ARGS
             varDsc->lvOtherArgReg = REG_NA;
 #endif
             varDsc->setPrefReg(varDsc->lvArgReg, this);
@@ -1581,8 +1591,10 @@ void Compiler::lvaCanPromoteStructType(CORINFO_CLASS_HANDLE    typeHnd,
 #endif // _TARGET_ARM_
         }
 
-        // If we saw any GC pointer fields above then the CORINFO_FLG_CONTAINS_GC_PTR has to be set!
-        noway_assert((containsGCpointers == false) || ((typeFlags & CORINFO_FLG_CONTAINS_GC_PTR) != 0));
+        // If we saw any GC pointer or by-ref fields above then CORINFO_FLG_CONTAINS_GC_PTR or
+        // CORINFO_FLG_CONTAINS_STACK_PTR has to be set!
+        noway_assert((containsGCpointers == false) ||
+                     ((typeFlags & (CORINFO_FLG_CONTAINS_GC_PTR | CORINFO_FLG_CONTAINS_STACK_PTR)) != 0));
 
         // If we have "Custom Layout" then we might have an explicit Size attribute
         // Managed C++ uses this for its structs, such C++ types will not contain GC pointers.
@@ -1992,14 +2004,14 @@ bool Compiler::lvaIsMultiregStruct(LclVarDsc* varDsc)
 
         if (howToPassStruct == SPK_ByValueAsHfa)
         {
-            assert(type = TYP_STRUCT);
+            assert(type == TYP_STRUCT);
             return true;
         }
 
 #if defined(FEATURE_UNIX_AMD64_STRUCT_PASSING) || defined(_TARGET_ARM64_)
         if (howToPassStruct == SPK_ByValue)
         {
-            assert(type = TYP_STRUCT);
+            assert(type == TYP_STRUCT);
             return true;
         }
 #endif
@@ -3126,37 +3138,6 @@ void Compiler::lvaMarkLclRefs(GenTreePtr tree)
 #endif
     }
 
-#if FANCY_ARRAY_OPT
-
-    /* Special case: assignment node */
-
-    if (tree->gtOper == GT_ASG)
-    {
-        if (tree->gtType == TYP_INT)
-        {
-            unsigned   lclNum1;
-            LclVarDsc* varDsc1;
-
-            GenTreePtr op1 = tree->gtOp.gtOp1;
-
-            if (op1->gtOper != GT_LCL_VAR)
-                return;
-
-            lclNum1 = op1->gtLclVarCommon.gtLclNum;
-            noway_assert(lclNum1 < lvaCount);
-            varDsc1 = lvaTable + lclNum1;
-
-            if (varDsc1->lvAssignOne)
-                varDsc1->lvAssignTwo = true;
-            else
-                varDsc1->lvAssignOne = true;
-        }
-
-        return;
-    }
-
-#endif
-
 #ifdef _TARGET_XARCH_
     /* Special case: integer shift node by a variable amount */
 
@@ -5794,6 +5775,7 @@ void Compiler::lvaAlignFrame()
 
 #elif defined(_TARGET_X86_)
 
+#if DOUBLE_ALIGN
     if (genDoubleAlign())
     {
         // Double Frame Alignement for x86 is handled in Compiler::lvaAssignVirtualFrameOffsetsToLocals()
@@ -5804,6 +5786,30 @@ void Compiler::lvaAlignFrame()
             lvaIncrementFrameSize(sizeof(void*));
         }
     }
+#endif
+
+    if (STACK_ALIGN > REGSIZE_BYTES)
+    {
+        if (lvaDoneFrameLayout != FINAL_FRAME_LAYOUT)
+        {
+            // If we are not doing final layout, we don't know the exact value of compLclFrameSize
+            // and thus do not know how much we will need to add in order to be aligned.
+            // We add the maximum pad that we could ever have (which is 12)
+            lvaIncrementFrameSize(STACK_ALIGN - REGSIZE_BYTES);
+        }
+
+        // Align the stack with STACK_ALIGN value.
+        int adjustFrameSize = compLclFrameSize;
+#if defined(UNIX_X86_ABI)
+        // we need to consider spilled register(s) plus return address and/or EBP
+        int adjustCount = compCalleeRegsPushed + 1 + (codeGen->isFramePointerUsed() ? 1 : 0);
+        adjustFrameSize += (adjustCount * REGSIZE_BYTES) % STACK_ALIGN;
+#endif
+        if ((adjustFrameSize % STACK_ALIGN) != 0)
+        {
+            lvaIncrementFrameSize(STACK_ALIGN - (adjustFrameSize % STACK_ALIGN));
+        }
+    }
 
 #else
     NYI("TARGET specific lvaAlignFrame");
diff --git a/src/jit/liveness.cpp b/src/jit/liveness.cpp
index 08e13b694c..c6663185e4 100644
--- a/src/jit/liveness.cpp
+++ b/src/jit/liveness.cpp
@@ -37,12 +37,17 @@ void Compiler::fgMarkUseDef(GenTreeLclVarCommon* tree)
         varDsc->lvRefCnt = 1;
     }
 
+    const bool isDef = (tree->gtFlags & GTF_VAR_DEF) != 0;
+    const bool isUse = !isDef || ((tree->gtFlags & (GTF_VAR_USEASG | GTF_VAR_USEDEF)) != 0);
+
     if (varDsc->lvTracked)
     {
         assert(varDsc->lvVarIndex < lvaTrackedCount);
 
-        const bool isDef = (tree->gtFlags & GTF_VAR_DEF) != 0;
-        const bool isUse = !isDef || ((tree->gtFlags & (GTF_VAR_USEASG | GTF_VAR_USEDEF)) != 0);
+        // We don't treat stores to tracked locals as modifications of ByrefExposed memory;
+        // Make sure no tracked local is addr-exposed, to make sure we don't incorrectly CSE byref
+        // loads aliasing it across a store to it.
+        assert(!varDsc->lvAddrExposed);
 
         if (isUse && !VarSetOps::IsMember(this, fgCurDefSet, varDsc->lvVarIndex))
         {
@@ -56,33 +61,56 @@ void Compiler::fgMarkUseDef(GenTreeLclVarCommon* tree)
             VarSetOps::AddElemD(this, fgCurDefSet, varDsc->lvVarIndex);
         }
     }
-    else if (varTypeIsStruct(varDsc))
+    else
     {
-        lvaPromotionType promotionType = lvaGetPromotionType(varDsc);
-
-        if (promotionType != PROMOTION_TYPE_NONE)
+        if (varDsc->lvAddrExposed)
         {
-            VARSET_TP VARSET_INIT_NOCOPY(bitMask, VarSetOps::MakeEmpty(this));
+            // Reflect the effect on ByrefExposed memory
 
-            for (unsigned i = varDsc->lvFieldLclStart; i < varDsc->lvFieldLclStart + varDsc->lvFieldCnt; ++i)
+            if (isUse)
             {
-                noway_assert(lvaTable[i].lvIsStructField);
-                if (lvaTable[i].lvTracked)
-                {
-                    noway_assert(lvaTable[i].lvVarIndex < lvaTrackedCount);
-                    VarSetOps::AddElemD(this, bitMask, lvaTable[i].lvVarIndex);
-                }
+                fgCurMemoryUse |= memoryKindSet(ByrefExposed);
             }
-
-            // For pure defs (i.e. not an "update" def which is also a use), add to the (all) def set.
-            if ((tree->gtFlags & GTF_VAR_DEF) != 0 && (tree->gtFlags & (GTF_VAR_USEASG | GTF_VAR_USEDEF)) == 0)
+            if (isDef)
             {
-                VarSetOps::UnionD(this, fgCurDefSet, bitMask);
+                fgCurMemoryDef |= memoryKindSet(ByrefExposed);
+
+                // We've found a store that modifies ByrefExposed
+                // memory but not GcHeap memory, so track their
+                // states separately.
+                byrefStatesMatchGcHeapStates = false;
             }
-            else if (!VarSetOps::IsSubset(this, bitMask, fgCurDefSet))
+        }
+
+        if (varTypeIsStruct(varDsc))
+        {
+            lvaPromotionType promotionType = lvaGetPromotionType(varDsc);
+
+            if (promotionType != PROMOTION_TYPE_NONE)
             {
-                // Mark as used any struct fields that are not yet defined.
-                VarSetOps::UnionD(this, fgCurUseSet, bitMask);
+                VARSET_TP VARSET_INIT_NOCOPY(bitMask, VarSetOps::MakeEmpty(this));
+
+                for (unsigned i = varDsc->lvFieldLclStart; i < varDsc->lvFieldLclStart + varDsc->lvFieldCnt; ++i)
+                {
+                    noway_assert(lvaTable[i].lvIsStructField);
+                    if (lvaTable[i].lvTracked)
+                    {
+                        noway_assert(lvaTable[i].lvVarIndex < lvaTrackedCount);
+                        VarSetOps::AddElemD(this, bitMask, lvaTable[i].lvVarIndex);
+                    }
+                }
+
+                // For pure defs (i.e. not an "update" def which is also a use), add to the (all) def set.
+                if (!isUse)
+                {
+                    assert(isDef);
+                    VarSetOps::UnionD(this, fgCurDefSet, bitMask);
+                }
+                else if (!VarSetOps::IsSubset(this, bitMask, fgCurDefSet))
+                {
+                    // Mark as used any struct fields that are not yet defined.
+                    VarSetOps::UnionD(this, fgCurUseSet, bitMask);
+                }
             }
         }
     }
@@ -197,7 +225,7 @@ void Compiler::fgLocalVarLivenessInit()
 #ifndef LEGACY_BACKEND
 //------------------------------------------------------------------------
 // fgPerNodeLocalVarLiveness:
-//   Set fgCurHeapUse and fgCurHeapDef when the global heap is read or updated
+//   Set fgCurMemoryUse and fgCurMemoryDef when memory is read or updated
 //   Call fgMarkUseDef for any Local variables encountered
 //
 // Arguments:
@@ -225,38 +253,39 @@ void Compiler::fgPerNodeLocalVarLiveness(GenTree* tree)
             break;
 
         case GT_CLS_VAR:
-            // For Volatile indirection, first mutate the global heap
-            // see comments in ValueNum.cpp (under case GT_CLS_VAR)
-            // This models Volatile reads as def-then-use of the heap.
-            // and allows for a CSE of a subsequent non-volatile read
+            // For Volatile indirection, first mutate GcHeap/ByrefExposed.
+            // See comments in ValueNum.cpp (under case GT_CLS_VAR)
+            // This models Volatile reads as def-then-use of memory
+            // and allows for a CSE of a subsequent non-volatile read.
             if ((tree->gtFlags & GTF_FLD_VOLATILE) != 0)
             {
                 // For any Volatile indirection, we must handle it as a
-                // definition of the global heap
-                fgCurHeapDef = true;
+                // definition of GcHeap/ByrefExposed
+                fgCurMemoryDef |= memoryKindSet(GcHeap, ByrefExposed);
             }
-            // If the GT_CLS_VAR is the lhs of an assignment, we'll handle it as a heap def, when we get to assignment.
+            // If the GT_CLS_VAR is the lhs of an assignment, we'll handle it as a GcHeap/ByrefExposed def, when we get
+            // to the assignment.
             // Otherwise, we treat it as a use here.
             if ((tree->gtFlags & GTF_CLS_VAR_ASG_LHS) == 0)
             {
-                fgCurHeapUse = true;
+                fgCurMemoryUse |= memoryKindSet(GcHeap, ByrefExposed);
             }
             break;
 
         case GT_IND:
-            // For Volatile indirection, first mutate the global heap
+            // For Volatile indirection, first mutate GcHeap/ByrefExposed
             // see comments in ValueNum.cpp (under case GT_CLS_VAR)
-            // This models Volatile reads as def-then-use of the heap.
+            // This models Volatile reads as def-then-use of memory.
             // and allows for a CSE of a subsequent non-volatile read
             if ((tree->gtFlags & GTF_IND_VOLATILE) != 0)
             {
                 // For any Volatile indirection, we must handle it as a
-                // definition of the global heap
-                fgCurHeapDef = true;
+                // definition of the GcHeap/ByrefExposed
+                fgCurMemoryDef |= memoryKindSet(GcHeap, ByrefExposed);
             }
 
             // If the GT_IND is the lhs of an assignment, we'll handle it
-            // as a heap def, when we get to assignment.
+            // as a memory def, when we get to assignment.
             // Otherwise, we treat it as a use here.
             if ((tree->gtFlags & GTF_IND_ASG_LHS) == 0)
             {
@@ -265,7 +294,7 @@ void Compiler::fgPerNodeLocalVarLiveness(GenTree* tree)
                 GenTreePtr           addrArg         = tree->gtOp.gtOp1->gtEffectiveVal(/*commaOnly*/ true);
                 if (!addrArg->DefinesLocalAddr(this, /*width doesn't matter*/ 0, &dummyLclVarTree, &dummyIsEntire))
                 {
-                    fgCurHeapUse = true;
+                    fgCurMemoryUse |= memoryKindSet(GcHeap, ByrefExposed);
                 }
                 else
                 {
@@ -282,22 +311,22 @@ void Compiler::fgPerNodeLocalVarLiveness(GenTree* tree)
             unreached();
             break;
 
-        // We'll assume these are use-then-defs of the heap.
+        // We'll assume these are use-then-defs of memory.
         case GT_LOCKADD:
         case GT_XADD:
         case GT_XCHG:
         case GT_CMPXCHG:
-            fgCurHeapUse   = true;
-            fgCurHeapDef   = true;
-            fgCurHeapHavoc = true;
+            fgCurMemoryUse |= memoryKindSet(GcHeap, ByrefExposed);
+            fgCurMemoryDef |= memoryKindSet(GcHeap, ByrefExposed);
+            fgCurMemoryHavoc |= memoryKindSet(GcHeap, ByrefExposed);
             break;
 
         case GT_MEMORYBARRIER:
-            // Simliar to any Volatile indirection, we must handle this as a definition of the global heap
-            fgCurHeapDef = true;
+            // Simliar to any Volatile indirection, we must handle this as a definition of GcHeap/ByrefExposed
+            fgCurMemoryDef |= memoryKindSet(GcHeap, ByrefExposed);
             break;
 
-        // For now, all calls read/write the heap, the latter in its entirety.  Might tighten this case later.
+        // For now, all calls read/write GcHeap/ByrefExposed, writes in their entirety.  Might tighten this case later.
         case GT_CALL:
         {
             GenTreeCall* call    = tree->AsCall();
@@ -313,9 +342,9 @@ void Compiler::fgPerNodeLocalVarLiveness(GenTree* tree)
             }
             if (modHeap)
             {
-                fgCurHeapUse   = true;
-                fgCurHeapDef   = true;
-                fgCurHeapHavoc = true;
+                fgCurMemoryUse |= memoryKindSet(GcHeap, ByrefExposed);
+                fgCurMemoryDef |= memoryKindSet(GcHeap, ByrefExposed);
+                fgCurMemoryHavoc |= memoryKindSet(GcHeap, ByrefExposed);
             }
         }
 
@@ -351,14 +380,26 @@ void Compiler::fgPerNodeLocalVarLiveness(GenTree* tree)
 
         default:
 
-            // Determine whether it defines a heap location.
+            // Determine what memory locations it defines.
             if (tree->OperIsAssignment() || tree->OperIsBlkOp())
             {
                 GenTreeLclVarCommon* dummyLclVarTree = nullptr;
-                if (!tree->DefinesLocal(this, &dummyLclVarTree))
+                if (tree->DefinesLocal(this, &dummyLclVarTree))
+                {
+                    if (lvaVarAddrExposed(dummyLclVarTree->gtLclNum))
+                    {
+                        fgCurMemoryDef |= memoryKindSet(ByrefExposed);
+
+                        // We've found a store that modifies ByrefExposed
+                        // memory but not GcHeap memory, so track their
+                        // states separately.
+                        byrefStatesMatchGcHeapStates = false;
+                    }
+                }
+                else
                 {
-                    // If it doesn't define a local, then it might update the heap.
-                    fgCurHeapDef = true;
+                    // If it doesn't define a local, then it might update GcHeap/ByrefExposed.
+                    fgCurMemoryDef |= memoryKindSet(GcHeap, ByrefExposed);
                 }
             }
             break;
@@ -409,10 +450,10 @@ void Compiler::fgPerBlockLocalVarLiveness()
             VarSetOps::Assign(this, block->bbVarDef, liveAll);
             VarSetOps::Assign(this, block->bbLiveIn, liveAll);
             VarSetOps::Assign(this, block->bbLiveOut, liveAll);
-            block->bbHeapUse     = true;
-            block->bbHeapDef     = true;
-            block->bbHeapLiveIn  = true;
-            block->bbHeapLiveOut = true;
+            block->bbMemoryUse     = fullMemoryKindSet;
+            block->bbMemoryDef     = fullMemoryKindSet;
+            block->bbMemoryLiveIn  = fullMemoryKindSet;
+            block->bbMemoryLiveOut = fullMemoryKindSet;
 
             switch (block->bbJumpKind)
             {
@@ -425,6 +466,11 @@ void Compiler::fgPerBlockLocalVarLiveness()
                     break;
             }
         }
+
+        // In minopts, we don't explicitly build SSA or value-number; GcHeap and
+        // ByrefExposed implicitly (conservatively) change state at each instr.
+        byrefStatesMatchGcHeapStates = true;
+
         return;
     }
 
@@ -434,14 +480,18 @@ void Compiler::fgPerBlockLocalVarLiveness()
     VarSetOps::AssignNoCopy(this, fgCurUseSet, VarSetOps::MakeEmpty(this));
     VarSetOps::AssignNoCopy(this, fgCurDefSet, VarSetOps::MakeEmpty(this));
 
+    // GC Heap and ByrefExposed can share states unless we see a def of byref-exposed
+    // memory that is not a GC Heap def.
+    byrefStatesMatchGcHeapStates = true;
+
     for (block = fgFirstBB; block; block = block->bbNext)
     {
         VarSetOps::ClearD(this, fgCurUseSet);
         VarSetOps::ClearD(this, fgCurDefSet);
 
-        fgCurHeapUse   = false;
-        fgCurHeapDef   = false;
-        fgCurHeapHavoc = false;
+        fgCurMemoryUse   = emptyMemoryKindSet;
+        fgCurMemoryDef   = emptyMemoryKindSet;
+        fgCurMemoryHavoc = emptyMemoryKindSet;
 
         compCurBB = block;
         if (!block->IsLIR())
@@ -501,19 +551,25 @@ void Compiler::fgPerBlockLocalVarLiveness()
             printf("BB%02u", block->bbNum);
             printf(" USE(%d)=", VarSetOps::Count(this, fgCurUseSet));
             lvaDispVarSet(fgCurUseSet, allVars);
-            if (fgCurHeapUse)
+            for (MemoryKind memoryKind : allMemoryKinds())
             {
-                printf(" + HEAP");
+                if ((fgCurMemoryUse & memoryKindSet(memoryKind)) != 0)
+                {
+                    printf(" + %s", memoryKindNames[memoryKind]);
+                }
             }
             printf("\n     DEF(%d)=", VarSetOps::Count(this, fgCurDefSet));
             lvaDispVarSet(fgCurDefSet, allVars);
-            if (fgCurHeapDef)
-            {
-                printf(" + HEAP");
-            }
-            if (fgCurHeapHavoc)
+            for (MemoryKind memoryKind : allMemoryKinds())
             {
-                printf("*");
+                if ((fgCurMemoryDef & memoryKindSet(memoryKind)) != 0)
+                {
+                    printf(" + %s", memoryKindNames[memoryKind]);
+                }
+                if ((fgCurMemoryHavoc & memoryKindSet(memoryKind)) != 0)
+                {
+                    printf("*");
+                }
             }
             printf("\n\n");
         }
@@ -521,15 +577,23 @@ void Compiler::fgPerBlockLocalVarLiveness()
 
         VarSetOps::Assign(this, block->bbVarUse, fgCurUseSet);
         VarSetOps::Assign(this, block->bbVarDef, fgCurDefSet);
-        block->bbHeapUse   = fgCurHeapUse;
-        block->bbHeapDef   = fgCurHeapDef;
-        block->bbHeapHavoc = fgCurHeapHavoc;
+        block->bbMemoryUse   = fgCurMemoryUse;
+        block->bbMemoryDef   = fgCurMemoryDef;
+        block->bbMemoryHavoc = fgCurMemoryHavoc;
 
         /* also initialize the IN set, just in case we will do multiple DFAs */
 
         VarSetOps::AssignNoCopy(this, block->bbLiveIn, VarSetOps::MakeEmpty(this));
-        block->bbHeapLiveIn = false;
+        block->bbMemoryLiveIn = emptyMemoryKindSet;
+    }
+
+#ifdef DEBUG
+    if (verbose)
+    {
+        printf("** Memory liveness computed, GcHeap states and ByrefExposed states %s\n",
+               (byrefStatesMatchGcHeapStates ? "match" : "diverge"));
     }
+#endif // DEBUG
 }
 
 // Helper functions to mark variables live over their entire scope
@@ -1066,16 +1130,16 @@ class LiveVarAnalysis
 
     bool m_hasPossibleBackEdge;
 
-    bool      m_heapLiveIn;
-    bool      m_heapLiveOut;
+    unsigned  m_memoryLiveIn;
+    unsigned  m_memoryLiveOut;
     VARSET_TP m_liveIn;
     VARSET_TP m_liveOut;
 
     LiveVarAnalysis(Compiler* compiler)
         : m_compiler(compiler)
         , m_hasPossibleBackEdge(false)
-        , m_heapLiveIn(false)
-        , m_heapLiveOut(false)
+        , m_memoryLiveIn(emptyMemoryKindSet)
+        , m_memoryLiveOut(emptyMemoryKindSet)
         , m_liveIn(VarSetOps::MakeEmpty(compiler))
         , m_liveOut(VarSetOps::MakeEmpty(compiler))
     {
@@ -1085,7 +1149,7 @@ class LiveVarAnalysis
     {
         /* Compute the 'liveOut' set */
         VarSetOps::ClearD(m_compiler, m_liveOut);
-        m_heapLiveOut = false;
+        m_memoryLiveOut = emptyMemoryKindSet;
         if (block->endsWithJmpMethod(m_compiler))
         {
             // A JMP uses all the arguments, so mark them all
@@ -1108,7 +1172,7 @@ class LiveVarAnalysis
         {
             BasicBlock* succ = (*succs);
             VarSetOps::UnionD(m_compiler, m_liveOut, succ->bbLiveIn);
-            m_heapLiveOut = m_heapLiveOut || (*succs)->bbHeapLiveIn;
+            m_memoryLiveOut |= (*succs)->bbMemoryLiveIn;
             if (succ->bbNum <= block->bbNum)
             {
                 m_hasPossibleBackEdge = true;
@@ -1129,9 +1193,9 @@ class LiveVarAnalysis
         VarSetOps::DiffD(m_compiler, m_liveIn, block->bbVarDef);
         VarSetOps::UnionD(m_compiler, m_liveIn, block->bbVarUse);
 
-        // Even if block->bbHeapDef is set, we must assume that it doesn't kill heap liveness from m_heapLiveOut,
-        // since (without proof otherwise) the use and def may touch different heap memory at run-time.
-        m_heapLiveIn = m_heapLiveOut || block->bbHeapUse;
+        // Even if block->bbMemoryDef is set, we must assume that it doesn't kill memory liveness from m_memoryLiveOut,
+        // since (without proof otherwise) the use and def may touch different memory at run-time.
+        m_memoryLiveIn = m_memoryLiveOut | block->bbMemoryUse;
 
         /* Can exceptions from this block be handled (in this function)? */
 
@@ -1183,14 +1247,14 @@ class LiveVarAnalysis
             }
         }
 
-        const bool heapLiveInChanged = (block->bbHeapLiveIn == 1) != m_heapLiveIn;
-        if (heapLiveInChanged || (block->bbHeapLiveOut == 1) != m_heapLiveOut)
+        const bool memoryLiveInChanged = (block->bbMemoryLiveIn != m_memoryLiveIn);
+        if (memoryLiveInChanged || (block->bbMemoryLiveOut != m_memoryLiveOut))
         {
-            block->bbHeapLiveIn  = m_heapLiveIn;
-            block->bbHeapLiveOut = m_heapLiveOut;
+            block->bbMemoryLiveIn  = m_memoryLiveIn;
+            block->bbMemoryLiveOut = m_memoryLiveOut;
         }
 
-        return liveInChanged || heapLiveInChanged;
+        return liveInChanged || memoryLiveInChanged;
     }
 
     void Run(bool updateInternalOnly)
@@ -1209,8 +1273,8 @@ class LiveVarAnalysis
             VarSetOps::ClearD(m_compiler, m_liveIn);
             VarSetOps::ClearD(m_compiler, m_liveOut);
 
-            m_heapLiveIn  = false;
-            m_heapLiveOut = false;
+            m_memoryLiveIn  = emptyMemoryKindSet;
+            m_memoryLiveOut = emptyMemoryKindSet;
 
             for (BasicBlock* block = m_compiler->fgLastBB; block; block = block->bbPrev)
             {
@@ -2961,15 +3025,21 @@ void Compiler::fgDispBBLiveness(BasicBlock* block)
     printf("BB%02u", block->bbNum);
     printf(" IN (%d)=", VarSetOps::Count(this, block->bbLiveIn));
     lvaDispVarSet(block->bbLiveIn, allVars);
-    if (block->bbHeapLiveIn)
+    for (MemoryKind memoryKind : allMemoryKinds())
     {
-        printf(" + HEAP");
+        if ((block->bbMemoryLiveIn & memoryKindSet(memoryKind)) != 0)
+        {
+            printf(" + %s", memoryKindNames[memoryKind]);
+        }
     }
     printf("\n     OUT(%d)=", VarSetOps::Count(this, block->bbLiveOut));
     lvaDispVarSet(block->bbLiveOut, allVars);
-    if (block->bbHeapLiveOut)
+    for (MemoryKind memoryKind : allMemoryKinds())
     {
-        printf(" + HEAP");
+        if ((block->bbMemoryLiveOut & memoryKindSet(memoryKind)) != 0)
+        {
+            printf(" + %s", memoryKindNames[memoryKind]);
+        }
     }
     printf("\n\n");
 }
diff --git a/src/jit/lower.cpp b/src/jit/lower.cpp
index a339d562a0..b3a674eec2 100644
--- a/src/jit/lower.cpp
+++ b/src/jit/lower.cpp
@@ -167,8 +167,13 @@ GenTree* Lowering::LowerNode(GenTree* node)
         case GT_STORE_BLK:
         case GT_STORE_OBJ:
         case GT_STORE_DYN_BLK:
-            LowerBlockStore(node->AsBlk());
-            break;
+        {
+            // TODO-Cleanup: Consider moving this code to LowerBlockStore, which is currently
+            // called from TreeNodeInfoInitBlockStore, and calling that method here.
+            GenTreeBlk* blkNode = node->AsBlk();
+            TryCreateAddrMode(LIR::Use(BlockRange(), &blkNode->Addr(), blkNode), false);
+        }
+        break;
 
 #ifdef FEATURE_SIMD
         case GT_SIMD:
@@ -236,20 +241,14 @@ GenTree* Lowering::LowerNode(GenTree* node)
                 unsigned   varNum = node->AsLclVarCommon()->GetLclNum();
                 LclVarDsc* varDsc = &comp->lvaTable[varNum];
 
-#if defined(_TARGET_64BIT_)
-                assert(varDsc->lvSize() == 16);
-                node->gtType = TYP_SIMD16;
-#else  // !_TARGET_64BIT_
-                if (varDsc->lvSize() == 16)
+                if (comp->lvaMapSimd12ToSimd16(varDsc))
                 {
+                    JITDUMP("Mapping TYP_SIMD12 lclvar node to TYP_SIMD16:\n");
+                    DISPNODE(node);
+                    JITDUMP("============");
+
                     node->gtType = TYP_SIMD16;
                 }
-                else
-                {
-                    // The following assert is guaranteed by lvSize().
-                    assert(varDsc->lvIsParam);
-                }
-#endif // !_TARGET_64BIT_
             }
 #endif // FEATURE_SIMD
             __fallthrough;
@@ -549,7 +548,7 @@ GenTree* Lowering::LowerSwitch(GenTree* node)
     // If the number of possible destinations is small enough, we proceed to expand the switch
     // into a series of conditional branches, otherwise we follow the jump table based switch
     // transformation.
-    else if (jumpCnt < minSwitchTabJumpCnt)
+    else if ((jumpCnt < minSwitchTabJumpCnt) || comp->compStressCompile(Compiler::STRESS_SWITCH_CMP_BR_EXPANSION, 50))
     {
         // Lower the switch into a series of compare and branch IR trees.
         //
@@ -639,7 +638,7 @@ GenTree* Lowering::LowerSwitch(GenTree* node)
 
                 GenTreePtr gtCaseBranch = comp->gtNewOperNode(GT_JTRUE, TYP_VOID, gtCaseCond);
                 LIR::Range caseRange    = LIR::SeqTree(comp, gtCaseBranch);
-                currentBBRange->InsertAtEnd(std::move(condRange));
+                currentBBRange->InsertAtEnd(std::move(caseRange));
             }
         }
 
@@ -944,6 +943,11 @@ GenTreePtr Lowering::NewPutArg(GenTreeCall* call, GenTreePtr arg, fgArgTabEntryP
                              info->slotNum PUT_STRUCT_ARG_STK_ONLY_ARG(info->numSlots) DEBUGARG(call));
 #endif
 
+#if defined(UNIX_X86_ABI)
+        assert((info->padStkAlign > 0 && info->numSlots > 0) || (info->padStkAlign == 0));
+        putArg->AsPutArgStk()->setArgPadding(info->padStkAlign);
+#endif
+
 #ifdef FEATURE_PUT_STRUCT_ARG_STK
         // If the ArgTabEntry indicates that this arg is a struct
         // get and store the number of slots that are references.
@@ -1183,9 +1187,6 @@ void Lowering::LowerCall(GenTree* node)
 
     LowerArgsForCall(call);
 
-// RyuJIT arm is not set up for lowered call control
-#ifndef _TARGET_ARM_
-
     // note that everything generated from this point on runs AFTER the outgoing args are placed
     GenTree* result = nullptr;
 
@@ -1290,7 +1291,6 @@ void Lowering::LowerCall(GenTree* node)
 
         call->gtControlExpr = result;
     }
-#endif //!_TARGET_ARM_
 
     if (comp->opts.IsJit64Compat())
     {
@@ -1859,6 +1859,7 @@ GenTree* Lowering::LowerTailCallViaHelper(GenTreeCall* call, GenTree* callTarget
     bool               isClosed;
     LIR::ReadOnlyRange secondArgRange = BlockRange().GetTreeRange(arg0, &isClosed);
     assert(isClosed);
+    BlockRange().Remove(std::move(secondArgRange));
 
     argEntry->node->gtOp.gtOp1 = callTarget;
 
@@ -3673,18 +3674,19 @@ GenTree* Lowering::TryCreateAddrMode(LIR::Use&& use, bool isIndir)
     // make sure there are not any side effects between def of leaves and use
     if (!doAddrMode || AreSourcesPossiblyModifiedLocals(addr, base, index))
     {
-        JITDUMP("  No addressing mode\n");
+        JITDUMP("No addressing mode:\n  ");
+        DISPNODE(addr);
         return addr;
     }
 
     GenTreePtr arrLength = nullptr;
 
     JITDUMP("Addressing mode:\n");
-    JITDUMP("  Base\n");
+    JITDUMP("  Base\n    ");
     DISPNODE(base);
     if (index != nullptr)
     {
-        JITDUMP("  + Index * %u + %u\n", scale, offset);
+        JITDUMP("  + Index * %u + %u\n    ", scale, offset);
         DISPNODE(index);
     }
     else
@@ -4198,12 +4200,6 @@ void Lowering::LowerStoreInd(GenTree* node)
     node->AsStoreInd()->SetRMWStatusDefault();
 }
 
-void Lowering::LowerBlockStore(GenTreeBlk* blkNode)
-{
-    GenTree* src = blkNode->Data();
-    TryCreateAddrMode(LIR::Use(BlockRange(), &blkNode->Addr(), blkNode), false);
-}
-
 //------------------------------------------------------------------------
 // LowerArrElem: Lower a GT_ARR_ELEM node
 //
@@ -4478,13 +4474,12 @@ void Lowering::DoPhase()
         m_block = block;
         for (GenTree* node : BlockRange().NonPhiNodes())
         {
-/* We increment the number position of each tree node by 2 to
-* simplify the logic when there's the case of a tree that implicitly
-* does a dual-definition of temps (the long case).  In this case
-* is easier to already have an idle spot to handle a dual-def instead
-* of making some messy adjustments if we only increment the
-* number position by one.
-*/
+            // We increment the number position of each tree node by 2 to simplify the logic when there's the case of
+            // a tree that implicitly does a dual-definition of temps (the long case).  In this case it is easier to
+            // already have an idle spot to handle a dual-def instead of making some messy adjustments if we only
+            // increment the number position by one.
+            CLANG_FORMAT_COMMENT_ANCHOR;
+
 #ifdef DEBUG
             node->gtSeqNum = currentLoc;
 #endif
diff --git a/src/jit/lower.h b/src/jit/lower.h
index fae251a7fa..57b4127f26 100644
--- a/src/jit/lower.h
+++ b/src/jit/lower.h
@@ -166,7 +166,7 @@ private:
     // operands.
     //
     // Arguments:
-    //     tree  -  Gentree of a bininary operation.
+    //     tree  -  Gentree of a binary operation.
     //
     // Returns
     //     None.
@@ -192,6 +192,7 @@ private:
         }
     }
 #endif // defined(_TARGET_XARCH_)
+    void TreeNodeInfoInitStoreLoc(GenTree* tree);
     void TreeNodeInfoInitReturn(GenTree* tree);
     void TreeNodeInfoInitShiftRotate(GenTree* tree);
     void TreeNodeInfoInitCall(GenTreeCall* call);
@@ -201,17 +202,26 @@ private:
     void TreeNodeInfoInitLogicalOp(GenTree* tree);
     void TreeNodeInfoInitModDiv(GenTree* tree);
     void TreeNodeInfoInitIntrinsic(GenTree* tree);
+    void TreeNodeInfoInitStoreLoc(GenTreeLclVarCommon* tree);
+    void TreeNodeInfoInitIndir(GenTree* indirTree);
+    void TreeNodeInfoInitGCWriteBarrier(GenTree* tree);
+#if !CPU_LOAD_STORE_ARCH
+    bool TreeNodeInfoInitIfRMWMemOp(GenTreePtr storeInd);
+#endif
 #ifdef FEATURE_SIMD
     void TreeNodeInfoInitSIMD(GenTree* tree);
 #endif // FEATURE_SIMD
     void TreeNodeInfoInitCast(GenTree* tree);
 #ifdef _TARGET_ARM64_
+    void LowerPutArgStk(GenTreePutArgStk* argNode, fgArgTabEntryPtr info);
     void TreeNodeInfoInitPutArgStk(GenTreePutArgStk* argNode, fgArgTabEntryPtr info);
 #endif // _TARGET_ARM64_
 #ifdef _TARGET_ARM_
+    void LowerPutArgStk(GenTreePutArgStk* argNode, fgArgTabEntryPtr info);
     void TreeNodeInfoInitPutArgStk(GenTreePutArgStk* argNode, fgArgTabEntryPtr info);
 #endif // _TARGET_ARM64_
 #ifdef FEATURE_PUT_STRUCT_ARG_STK
+    void LowerPutArgStk(GenTreePutArgStk* tree);
     void TreeNodeInfoInitPutArgStk(GenTreePutArgStk* tree);
 #endif // FEATURE_PUT_STRUCT_ARG_STK
     void TreeNodeInfoInitLclHeap(GenTree* tree);
@@ -232,7 +242,7 @@ private:
     void LowerCast(GenTree* node);
 
 #if defined(_TARGET_XARCH_)
-    void SetMulOpCounts(GenTreePtr tree);
+    void TreeNodeInfoInitMul(GenTreePtr tree);
     void SetContainsAVXFlags(bool isFloatingPointType = true, unsigned sizeOfSIMDVector = 0);
 #endif // defined(_TARGET_XARCH_)
 
@@ -240,11 +250,8 @@ private:
     bool IsRMWIndirCandidate(GenTree* operand, GenTree* storeInd);
     bool IsBinOpInRMWStoreInd(GenTreePtr tree);
     bool IsRMWMemOpRootedAtStoreInd(GenTreePtr storeIndTree, GenTreePtr* indirCandidate, GenTreePtr* indirOpSource);
-    bool SetStoreIndOpCountsIfRMWMemOp(GenTreePtr storeInd);
 #endif
     void LowerStoreLoc(GenTreeLclVarCommon* tree);
-    void SetIndirAddrOpCounts(GenTree* indirTree);
-    void LowerGCWriteBarrier(GenTree* tree);
     GenTree* LowerArrElem(GenTree* node);
     void LowerRotate(GenTree* tree);
 
diff --git a/src/jit/lowerarm.cpp b/src/jit/lowerarm.cpp
index 42dfbee4f2..9792b8a9c6 100644
--- a/src/jit/lowerarm.cpp
+++ b/src/jit/lowerarm.cpp
@@ -38,35 +38,12 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 //
 // Notes:
 //    This involves:
-//    - Setting the appropriate candidates for a store of a multi-reg call return value.
-//    - Handling of contained immediates and widening operations of unsigneds.
+//    - Widening operations of unsigneds.
 //
 void Lowering::LowerStoreLoc(GenTreeLclVarCommon* storeLoc)
 {
-    TreeNodeInfo* info = &(storeLoc->gtLsraInfo);
-
-    // Is this the case of var = call where call is returning
-    // a value in multiple return registers?
-    GenTree* op1 = storeLoc->gtGetOp1();
-    if (op1->IsMultiRegCall())
-    {
-        // backend expects to see this case only for store lclvar.
-        assert(storeLoc->OperGet() == GT_STORE_LCL_VAR);
-
-        // srcCount = number of registers in which the value is returned by call
-        GenTreeCall*    call        = op1->AsCall();
-        ReturnTypeDesc* retTypeDesc = call->GetReturnTypeDesc();
-        info->srcCount              = retTypeDesc->GetReturnRegCount();
-
-        // Call node srcCandidates = Bitwise-OR(allregs(GetReturnRegType(i))) for all i=0..RetRegCount-1
-        regMaskTP srcCandidates = m_lsra->allMultiRegCallNodeRegs(call);
-        op1->gtLsraInfo.setSrcCandidates(m_lsra, srcCandidates);
-        return;
-    }
-
-    CheckImmedAndMakeContained(storeLoc, op1);
-
     // Try to widen the ops if they are going into a local var.
+    GenTree* op1 = storeLoc->gtGetOp1();
     if ((storeLoc->gtOper == GT_STORE_LCL_VAR) && (op1->gtOper == GT_CNS_INT))
     {
         GenTreeIntCon* con    = op1->AsIntCon();
@@ -116,24 +93,6 @@ void Lowering::LowerStoreLoc(GenTreeLclVarCommon* storeLoc)
 }
 
 //------------------------------------------------------------------------
-// TreeNodeInfoInitCmp: Lower a GT comparison node.
-//
-// Arguments:
-//    tree - the node to lower
-//
-// Return Value:
-//    None.
-//
-void Lowering::TreeNodeInfoInitCmp(GenTreePtr tree)
-{
-    TreeNodeInfo* info = &(tree->gtLsraInfo);
-
-    info->srcCount = 2;
-    info->dstCount = 1;
-    CheckImmedAndMakeContained(tree, tree->gtOp.gtOp2);
-}
-
-//------------------------------------------------------------------------
 // LowerCast: Lower GT_CAST(srcType, DstType) nodes.
 //
 // Arguments:
@@ -239,520 +198,7 @@ void Lowering::LowerRotate(GenTreePtr tree)
 }
 
 //------------------------------------------------------------------------
-// LowerGCWriteBarrier: GC lowering helper.
-//
-// Arguments:
-//    tree - the node to lower
-//
-// Return Value:
-//    None.
-//
-void Lowering::LowerGCWriteBarrier(GenTree* tree)
-{
-    GenTreePtr dst  = tree;
-    GenTreePtr addr = tree->gtOp.gtOp1;
-    GenTreePtr src  = tree->gtOp.gtOp2;
-
-    if (addr->OperGet() == GT_LEA)
-    {
-        // In the case where we are doing a helper assignment, if the dst
-        // is an indir through an lea, we need to actually instantiate the
-        // lea in a register
-        GenTreeAddrMode* lea = addr->AsAddrMode();
-
-        short leaSrcCount = 0;
-        if (lea->Base() != nullptr)
-        {
-            leaSrcCount++;
-        }
-        if (lea->Index() != nullptr)
-        {
-            leaSrcCount++;
-        }
-        lea->gtLsraInfo.srcCount = leaSrcCount;
-        lea->gtLsraInfo.dstCount = 1;
-    }
-
-#if NOGC_WRITE_BARRIERS
-    NYI_ARM("NOGC_WRITE_BARRIERS");
-#else
-    // For the standard JIT Helper calls
-    // op1 goes into REG_ARG_0 and
-    // op2 goes into REG_ARG_1
-    //
-    addr->gtLsraInfo.setSrcCandidates(m_lsra, RBM_ARG_0);
-    src->gtLsraInfo.setSrcCandidates(m_lsra, RBM_ARG_1);
-#endif // NOGC_WRITE_BARRIERS
-
-    // Both src and dst must reside in a register, which they should since we haven't set
-    // either of them as contained.
-    assert(addr->gtLsraInfo.dstCount == 1);
-    assert(src->gtLsraInfo.dstCount == 1);
-}
-
-//------------------------------------------------------------------------
-// SetIndirAddrOpCounts: Specify register requirements for address expression
-//                       of an indirection operation.
-//
-// Arguments:
-//    indirTree - GT_IND, GT_STOREIND, block node or GT_NULLCHECK gentree node
-//
-void Lowering::SetIndirAddrOpCounts(GenTreePtr indirTree)
-{
-    assert(indirTree->OperIsIndir());
-    // If this is the rhs of a block copy (i.e. non-enregisterable struct),
-    // it has no register requirements.
-    if (indirTree->TypeGet() == TYP_STRUCT)
-    {
-        return;
-    }
-
-    GenTreePtr    addr = indirTree->gtGetOp1();
-    TreeNodeInfo* info = &(indirTree->gtLsraInfo);
-
-    GenTreePtr base  = nullptr;
-    GenTreePtr index = nullptr;
-    unsigned   cns   = 0;
-    unsigned   mul;
-    bool       rev;
-    bool       modifiedSources = false;
-
-    if ((addr->OperGet() == GT_LEA) && IsSafeToContainMem(indirTree, addr))
-    {
-        GenTreeAddrMode* lea = addr->AsAddrMode();
-        base                 = lea->Base();
-        index                = lea->Index();
-        cns                  = lea->gtOffset;
-
-        m_lsra->clearOperandCounts(addr);
-        // The srcCount is decremented because addr is now "contained",
-        // then we account for the base and index below, if they are non-null.
-        info->srcCount--;
-    }
-    else if (comp->codeGen->genCreateAddrMode(addr, -1, true, 0, &rev, &base, &index, &mul, &cns, true /*nogen*/) &&
-             !(modifiedSources = AreSourcesPossiblyModifiedLocals(indirTree, base, index)))
-    {
-        // An addressing mode will be constructed that may cause some
-        // nodes to not need a register, and cause others' lifetimes to be extended
-        // to the GT_IND or even its parent if it's an assignment
-
-        assert(base != addr);
-        m_lsra->clearOperandCounts(addr);
-
-        GenTreePtr arrLength = nullptr;
-
-        // Traverse the computation below GT_IND to find the operands
-        // for the addressing mode, marking the various constants and
-        // intermediate results as not consuming/producing.
-        // If the traversal were more complex, we might consider using
-        // a traversal function, but the addressing mode is only made
-        // up of simple arithmetic operators, and the code generator
-        // only traverses one leg of each node.
-
-        bool       foundBase  = (base == nullptr);
-        bool       foundIndex = (index == nullptr);
-        GenTreePtr nextChild  = nullptr;
-        for (GenTreePtr child = addr; child != nullptr && !child->OperIsLeaf(); child = nextChild)
-        {
-            nextChild      = nullptr;
-            GenTreePtr op1 = child->gtOp.gtOp1;
-            GenTreePtr op2 = (child->OperIsBinary()) ? child->gtOp.gtOp2 : nullptr;
-
-            if (op1 == base)
-            {
-                foundBase = true;
-            }
-            else if (op1 == index)
-            {
-                foundIndex = true;
-            }
-            else
-            {
-                m_lsra->clearOperandCounts(op1);
-                if (!op1->OperIsLeaf())
-                {
-                    nextChild = op1;
-                }
-            }
-
-            if (op2 != nullptr)
-            {
-                if (op2 == base)
-                {
-                    foundBase = true;
-                }
-                else if (op2 == index)
-                {
-                    foundIndex = true;
-                }
-                else
-                {
-                    m_lsra->clearOperandCounts(op2);
-                    if (!op2->OperIsLeaf())
-                    {
-                        assert(nextChild == nullptr);
-                        nextChild = op2;
-                    }
-                }
-            }
-        }
-        assert(foundBase && foundIndex);
-        info->srcCount--; // it gets incremented below.
-    }
-    else if (addr->gtOper == GT_ARR_ELEM)
-    {
-        // The GT_ARR_ELEM consumes all the indices and produces the offset.
-        // The array object lives until the mem access.
-        // We also consume the target register to which the address is
-        // computed
-
-        info->srcCount++;
-        assert(addr->gtLsraInfo.srcCount >= 2);
-        addr->gtLsraInfo.srcCount -= 1;
-    }
-    else
-    {
-        // it is nothing but a plain indir
-        info->srcCount--; // base gets added in below
-        base = addr;
-    }
-
-    if (base != nullptr)
-    {
-        info->srcCount++;
-    }
-
-    if (index != nullptr && !modifiedSources)
-    {
-        info->srcCount++;
-    }
-}
-
-//------------------------------------------------------------------------
-// TreeNodeInfoInitReturn: Set the NodeInfo for a GT_RETURN.
-//
-// Arguments:
-//    tree - The node of interest
-//
-// Return Value:
-//    None.
-//
-void Lowering::TreeNodeInfoInitReturn(GenTree* tree)
-{
-    TreeNodeInfo* info     = &(tree->gtLsraInfo);
-    LinearScan*   l        = m_lsra;
-    Compiler*     compiler = comp;
-
-    GenTree*  op1           = tree->gtGetOp1();
-    regMaskTP useCandidates = RBM_NONE;
-
-    info->srcCount = (tree->TypeGet() == TYP_VOID) ? 0 : 1;
-    info->dstCount = 0;
-
-    if (varTypeIsStruct(tree))
-    {
-        NYI_ARM("struct return");
-    }
-    else
-    {
-        // Non-struct type return - determine useCandidates
-        switch (tree->TypeGet())
-        {
-            case TYP_VOID:
-                useCandidates = RBM_NONE;
-                break;
-            case TYP_FLOAT:
-                useCandidates = RBM_FLOATRET;
-                break;
-            case TYP_DOUBLE:
-                useCandidates = RBM_DOUBLERET;
-                break;
-            case TYP_LONG:
-                useCandidates = RBM_LNGRET;
-                break;
-            default:
-                useCandidates = RBM_INTRET;
-                break;
-        }
-    }
-
-    if (useCandidates != RBM_NONE)
-    {
-        tree->gtOp.gtOp1->gtLsraInfo.setSrcCandidates(l, useCandidates);
-    }
-}
-
-//------------------------------------------------------------------------
-// TreeNodeInfoInitCall: Set the NodeInfo for a call.
-//
-// Arguments:
-//    call - The call node of interest
-//
-// Return Value:
-//    None.
-//
-void Lowering::TreeNodeInfoInitCall(GenTreeCall* call)
-{
-    TreeNodeInfo*   info              = &(call->gtLsraInfo);
-    LinearScan*     l                 = m_lsra;
-    Compiler*       compiler          = comp;
-    bool            hasMultiRegRetVal = false;
-    ReturnTypeDesc* retTypeDesc       = nullptr;
-
-    info->srcCount = 0;
-    if (call->TypeGet() != TYP_VOID)
-    {
-        hasMultiRegRetVal = call->HasMultiRegRetVal();
-        if (hasMultiRegRetVal)
-        {
-            // dst count = number of registers in which the value is returned by call
-            retTypeDesc    = call->GetReturnTypeDesc();
-            info->dstCount = retTypeDesc->GetReturnRegCount();
-        }
-        else
-        {
-            info->dstCount = 1;
-        }
-    }
-    else
-    {
-        info->dstCount = 0;
-    }
-
-    GenTree* ctrlExpr = call->gtControlExpr;
-    if (call->gtCallType == CT_INDIRECT)
-    {
-        // either gtControlExpr != null or gtCallAddr != null.
-        // Both cannot be non-null at the same time.
-        assert(ctrlExpr == nullptr);
-        assert(call->gtCallAddr != nullptr);
-        ctrlExpr = call->gtCallAddr;
-    }
-
-    // set reg requirements on call target represented as control sequence.
-    if (ctrlExpr != nullptr)
-    {
-        // we should never see a gtControlExpr whose type is void.
-        assert(ctrlExpr->TypeGet() != TYP_VOID);
-
-        info->srcCount++;
-        // In case of fast tail implemented as jmp, make sure that gtControlExpr is
-        // computed into a register.
-        if (call->IsFastTailCall())
-        {
-            NYI_ARM("tail call");
-        }
-    }
-    else
-    {
-        info->internalIntCount = 1;
-    }
-
-    RegisterType registerType = call->TypeGet();
-
-    // Set destination candidates for return value of the call.
-    if (hasMultiRegRetVal)
-    {
-        assert(retTypeDesc != nullptr);
-        info->setDstCandidates(l, retTypeDesc->GetABIReturnRegs());
-    }
-    else if (varTypeIsFloating(registerType))
-    {
-        info->setDstCandidates(l, RBM_FLOATRET);
-    }
-    else if (registerType == TYP_LONG)
-    {
-        info->setDstCandidates(l, RBM_LNGRET);
-    }
-    else
-    {
-        info->setDstCandidates(l, RBM_INTRET);
-    }
-
-    // If there is an explicit this pointer, we don't want that node to produce anything
-    // as it is redundant
-    if (call->gtCallObjp != nullptr)
-    {
-        GenTreePtr thisPtrNode = call->gtCallObjp;
-
-        if (thisPtrNode->gtOper == GT_PUTARG_REG)
-        {
-            l->clearOperandCounts(thisPtrNode);
-            l->clearDstCount(thisPtrNode->gtOp.gtOp1);
-        }
-        else
-        {
-            l->clearDstCount(thisPtrNode);
-        }
-    }
-
-    // First, count reg args
-    bool callHasFloatRegArgs = false;
-
-    for (GenTreePtr list = call->gtCallLateArgs; list; list = list->MoveNext())
-    {
-        assert(list->OperIsList());
-
-        GenTreePtr argNode = list->Current();
-
-        fgArgTabEntryPtr curArgTabEntry = compiler->gtArgEntryByNode(call, argNode);
-        assert(curArgTabEntry);
-
-        if (curArgTabEntry->regNum == REG_STK)
-        {
-            // late arg that is not passed in a register
-            assert(argNode->gtOper == GT_PUTARG_STK);
-
-            TreeNodeInfoInitPutArgStk(argNode->AsPutArgStk(), curArgTabEntry);
-            continue;
-        }
-
-        var_types argType    = argNode->TypeGet();
-        bool      argIsFloat = varTypeIsFloating(argType);
-        callHasFloatRegArgs |= argIsFloat;
-
-        regNumber argReg = curArgTabEntry->regNum;
-        // We will setup argMask to the set of all registers that compose this argument
-        regMaskTP argMask = 0;
-
-        argNode = argNode->gtEffectiveVal();
-
-        // A GT_FIELD_LIST has a TYP_VOID, but is used to represent a multireg struct
-        if (varTypeIsStruct(argNode) || (argNode->gtOper == GT_FIELD_LIST))
-        {
-            GenTreePtr actualArgNode = argNode;
-            unsigned   originalSize  = 0;
-
-            if (argNode->gtOper == GT_FIELD_LIST)
-            {
-                // There could be up to 2-4 PUTARG_REGs in the list (3 or 4 can only occur for HFAs)
-                GenTreeFieldList* fieldListPtr = argNode->AsFieldList();
-
-                // Initailize the first register and the first regmask in our list
-                regNumber targetReg    = argReg;
-                regMaskTP targetMask   = genRegMask(targetReg);
-                unsigned  iterationNum = 0;
-                originalSize           = 0;
-
-                for (; fieldListPtr; fieldListPtr = fieldListPtr->Rest())
-                {
-                    GenTreePtr putArgRegNode = fieldListPtr->Current();
-                    assert(putArgRegNode->gtOper == GT_PUTARG_REG);
-                    GenTreePtr putArgChild = putArgRegNode->gtOp.gtOp1;
-
-                    originalSize += REGSIZE_BYTES; // 8 bytes
-
-                    // Record the register requirements for the GT_PUTARG_REG node
-                    putArgRegNode->gtLsraInfo.setDstCandidates(l, targetMask);
-                    putArgRegNode->gtLsraInfo.setSrcCandidates(l, targetMask);
-
-                    // To avoid redundant moves, request that the argument child tree be
-                    // computed in the register in which the argument is passed to the call.
-                    putArgChild->gtLsraInfo.setSrcCandidates(l, targetMask);
-
-                    // We consume one source for each item in this list
-                    info->srcCount++;
-                    iterationNum++;
-
-                    // Update targetReg and targetMask for the next putarg_reg (if any)
-                    targetReg  = genRegArgNext(targetReg);
-                    targetMask = genRegMask(targetReg);
-                }
-            }
-            else
-            {
-#ifdef DEBUG
-                compiler->gtDispTreeRange(BlockRange(), argNode);
-#endif
-                noway_assert(!"Unsupported TYP_STRUCT arg kind");
-            }
-
-            unsigned  slots          = ((unsigned)(roundUp(originalSize, REGSIZE_BYTES))) / REGSIZE_BYTES;
-            regNumber curReg         = argReg;
-            regNumber lastReg        = argIsFloat ? REG_ARG_FP_LAST : REG_ARG_LAST;
-            unsigned  remainingSlots = slots;
-
-            while (remainingSlots > 0)
-            {
-                argMask |= genRegMask(curReg);
-                remainingSlots--;
-
-                if (curReg == lastReg)
-                    break;
-
-                curReg = genRegArgNext(curReg);
-            }
-
-            // Struct typed arguments must be fully passed in registers (Reg/Stk split not allowed)
-            noway_assert(remainingSlots == 0);
-            argNode->gtLsraInfo.internalIntCount = 0;
-        }
-        else // A scalar argument (not a struct)
-        {
-            // We consume one source
-            info->srcCount++;
-
-            argMask |= genRegMask(argReg);
-            argNode->gtLsraInfo.setDstCandidates(l, argMask);
-            argNode->gtLsraInfo.setSrcCandidates(l, argMask);
-
-            if (argNode->gtOper == GT_PUTARG_REG)
-            {
-                GenTreePtr putArgChild = argNode->gtOp.gtOp1;
-
-                // To avoid redundant moves, request that the argument child tree be
-                // computed in the register in which the argument is passed to the call.
-                putArgChild->gtLsraInfo.setSrcCandidates(l, argMask);
-            }
-        }
-    }
-
-    // Now, count stack args
-    // Note that these need to be computed into a register, but then
-    // they're just stored to the stack - so the reg doesn't
-    // need to remain live until the call.  In fact, it must not
-    // because the code generator doesn't actually consider it live,
-    // so it can't be spilled.
-
-    GenTreePtr args = call->gtCallArgs;
-    while (args)
-    {
-        GenTreePtr arg = args->gtOp.gtOp1;
-
-        // Skip arguments that have been moved to the Late Arg list
-        if (!(args->gtFlags & GTF_LATE_ARG))
-        {
-            if (arg->gtOper == GT_PUTARG_STK)
-            {
-                fgArgTabEntryPtr curArgTabEntry = compiler->gtArgEntryByNode(call, arg);
-                assert(curArgTabEntry);
-
-                assert(curArgTabEntry->regNum == REG_STK);
-
-                TreeNodeInfoInitPutArgStk(arg->AsPutArgStk(), curArgTabEntry);
-            }
-            else
-            {
-                TreeNodeInfo* argInfo = &(arg->gtLsraInfo);
-                if (argInfo->dstCount != 0)
-                {
-                    argInfo->isLocalDefUse = true;
-                }
-
-                argInfo->dstCount = 0;
-            }
-        }
-        args = args->gtOp.gtOp2;
-    }
-
-    if (call->IsVarargs() && callHasFloatRegArgs && !call->IsFastTailCall() && (ctrlExpr != nullptr))
-    {
-        NYI_ARM("float reg varargs");
-    }
-}
-
-//------------------------------------------------------------------------
-// TreeNodeInfoInitPutArgStk: Set the NodeInfo for a GT_PUTARG_STK node
+// LowerPutArgStk: Lower a GT_PUTARG_STK node
 //
 // Arguments:
 //    argNode - a GT_PUTARG_STK node
@@ -761,464 +207,10 @@ void Lowering::TreeNodeInfoInitCall(GenTreeCall* call)
 //    None.
 //
 // Notes:
-//    Set the child node(s) to be contained when we have a multireg arg
+//    There is currently no Lowering required for this on ARM.
 //
-void Lowering::TreeNodeInfoInitPutArgStk(GenTreePutArgStk* argNode, fgArgTabEntryPtr info)
+void Lowering::LowerPutArgStk(GenTreePutArgStk* argNode, fgArgTabEntryPtr info)
 {
-    assert(argNode->gtOper == GT_PUTARG_STK);
-
-    GenTreePtr putArgChild = argNode->gtOp.gtOp1;
-
-    // Initialize 'argNode' as not contained, as this is both the default case
-    //  and how MakeSrcContained expects to find things setup.
-    //
-    argNode->gtLsraInfo.srcCount = 1;
-    argNode->gtLsraInfo.dstCount = 0;
-
-    // Do we have a TYP_STRUCT argument (or a GT_FIELD_LIST), if so it must be a multireg pass-by-value struct
-    if ((putArgChild->TypeGet() == TYP_STRUCT) || (putArgChild->OperGet() == GT_FIELD_LIST))
-    {
-        // We will use store instructions that each write a register sized value
-
-        if (putArgChild->OperGet() == GT_FIELD_LIST)
-        {
-            // We consume all of the items in the GT_FIELD_LIST
-            argNode->gtLsraInfo.srcCount = info->numSlots;
-        }
-        else
-        {
-            // We could use a ldp/stp sequence so we need two internal registers
-            argNode->gtLsraInfo.internalIntCount = 2;
-
-            if (putArgChild->OperGet() == GT_OBJ)
-            {
-                GenTreePtr objChild = putArgChild->gtOp.gtOp1;
-                if (objChild->OperGet() == GT_LCL_VAR_ADDR)
-                {
-                    // We will generate all of the code for the GT_PUTARG_STK, the GT_OBJ and the GT_LCL_VAR_ADDR
-                    // as one contained operation
-                    //
-                    MakeSrcContained(putArgChild, objChild);
-                }
-            }
-
-            // We will generate all of the code for the GT_PUTARG_STK and it's child node
-            // as one contained operation
-            //
-            MakeSrcContained(argNode, putArgChild);
-        }
-    }
-    else
-    {
-        // We must not have a multi-reg struct
-        assert(info->numSlots == 1);
-    }
-}
-
-//------------------------------------------------------------------------
-// TreeNodeInfoInit: Set the register requirements for RA.
-//
-// Notes:
-//    Takes care of annotating the register requirements
-//    for every TreeNodeInfo struct that maps to each tree node.
-//
-// Preconditions:
-//    LSRA has been initialized and there is a TreeNodeInfo node
-//    already allocated and initialized for every tree in the IR.
-//
-// Postconditions:
-//    Every TreeNodeInfo instance has the right annotations on register
-//    requirements needed by LSRA to build the Interval Table (source,
-//    destination and internal [temp] register counts).
-//    This code is refactored originally from LSRA.
-//
-void Lowering::TreeNodeInfoInit(GenTree* tree)
-{
-    LinearScan* l        = m_lsra;
-    Compiler*   compiler = comp;
-
-    unsigned      kind         = tree->OperKind();
-    TreeNodeInfo* info         = &(tree->gtLsraInfo);
-    RegisterType  registerType = TypeGet(tree);
-
-    JITDUMP("TreeNodeInfoInit for: ");
-    DISPNODE(tree);
-
-    switch (tree->OperGet())
-    {
-        GenTree* op1;
-        GenTree* op2;
-
-        case GT_STORE_LCL_FLD:
-        case GT_STORE_LCL_VAR:
-            info->srcCount = 1;
-            info->dstCount = 0;
-            LowerStoreLoc(tree->AsLclVarCommon());
-            break;
-
-        case GT_NOP:
-            // A GT_NOP is either a passthrough (if it is void, or if it has
-            // a child), but must be considered to produce a dummy value if it
-            // has a type but no child
-            info->srcCount = 0;
-            if (tree->TypeGet() != TYP_VOID && tree->gtOp.gtOp1 == nullptr)
-            {
-                info->dstCount = 1;
-            }
-            else
-            {
-                info->dstCount = 0;
-            }
-            break;
-
-        case GT_INTRINSIC:
-        {
-            // TODO-ARM: Implement other type of intrinsics (round, sqrt and etc.)
-            // Both operand and its result must be of the same floating point type.
-            op1 = tree->gtOp.gtOp1;
-            assert(varTypeIsFloating(op1));
-            assert(op1->TypeGet() == tree->TypeGet());
-
-            switch (tree->gtIntrinsic.gtIntrinsicId)
-            {
-                case CORINFO_INTRINSIC_Abs:
-                    info->srcCount = 1;
-                    info->dstCount = 1;
-                    break;
-                default:
-                    NYI_ARM("Lowering::TreeNodeInfoInit for GT_INRINSIC");
-                    break;
-            }
-        }
-        break;
-
-        case GT_CAST:
-        {
-            info->srcCount = 1;
-            info->dstCount = 1;
-
-            // Non-overflow casts to/from float/double are done using SSE2 instructions
-            // and that allow the source operand to be either a reg or memop. Given the
-            // fact that casts from small int to float/double are done as two-level casts,
-            // the source operand is always guaranteed to be of size 4 or 8 bytes.
-            var_types  castToType = tree->CastToType();
-            GenTreePtr castOp     = tree->gtCast.CastOp();
-            var_types  castOpType = castOp->TypeGet();
-            if (tree->gtFlags & GTF_UNSIGNED)
-            {
-                castOpType = genUnsignedType(castOpType);
-            }
-#ifdef DEBUG
-            if (!tree->gtOverflow() && (varTypeIsFloating(castToType) || varTypeIsFloating(castOpType)))
-            {
-                // If converting to float/double, the operand must be 4 or 8 byte in size.
-                if (varTypeIsFloating(castToType))
-                {
-                    unsigned opSize = genTypeSize(castOpType);
-                    assert(opSize == 4 || opSize == 8);
-                }
-            }
-#endif // DEBUG
-
-            if (tree->gtOverflow())
-            {
-                NYI_ARM("overflow checks");
-            }
-        }
-        break;
-
-        case GT_JTRUE:
-            info->srcCount = 0;
-            info->dstCount = 0;
-            l->clearDstCount(tree->gtOp.gtOp1);
-            break;
-
-        case GT_JMP:
-            info->srcCount = 0;
-            info->dstCount = 0;
-            break;
-
-        case GT_SWITCH:
-            // This should never occur since switch nodes must not be visible at this
-            // point in the JIT.
-            info->srcCount = 0;
-            info->dstCount = 0; // To avoid getting uninit errors.
-            noway_assert(!"Switch must be lowered at this point");
-            break;
-
-        case GT_JMPTABLE:
-            info->srcCount = 0;
-            info->dstCount = 1;
-            break;
-
-        case GT_SWITCH_TABLE:
-            info->srcCount         = 2;
-            info->internalIntCount = 1;
-            info->dstCount         = 0;
-            break;
-
-        case GT_ASG:
-        case GT_ASG_ADD:
-        case GT_ASG_SUB:
-            noway_assert(!"We should never hit any assignment operator in lowering");
-            info->srcCount = 0;
-            info->dstCount = 0;
-            break;
-
-        case GT_ADD:
-        case GT_SUB:
-            if (varTypeIsFloating(tree->TypeGet()))
-            {
-                // overflow operations aren't supported on float/double types.
-                assert(!tree->gtOverflow());
-
-                // No implicit conversions at this stage as the expectation is that
-                // everything is made explicit by adding casts.
-                assert(tree->gtOp.gtOp1->TypeGet() == tree->gtOp.gtOp2->TypeGet());
-
-                info->srcCount = 2;
-                info->dstCount = 1;
-
-                break;
-            }
-
-            __fallthrough;
-
-        case GT_AND:
-        case GT_OR:
-        case GT_XOR:
-            info->srcCount = 2;
-            info->dstCount = 1;
-            // Check and make op2 contained (if it is a containable immediate)
-            CheckImmedAndMakeContained(tree, tree->gtOp.gtOp2);
-            break;
-
-        case GT_MUL:
-            if (tree->gtOverflow())
-            {
-                // Need a register different from target reg to check for overflow.
-                info->internalIntCount = 2;
-            }
-            __fallthrough;
-
-        case GT_DIV:
-        case GT_MULHI:
-        case GT_UDIV:
-        {
-            info->srcCount = 2;
-            info->dstCount = 1;
-        }
-        break;
-
-        case GT_LIST:
-        case GT_FIELD_LIST:
-        case GT_ARGPLACE:
-        case GT_NO_OP:
-        case GT_START_NONGC:
-        case GT_PROF_HOOK:
-            info->srcCount = 0;
-            info->dstCount = 0;
-            break;
-
-        case GT_CNS_DBL:
-            info->srcCount = 0;
-            info->dstCount = 1;
-            if (tree->TypeGet() == TYP_FLOAT)
-            {
-                // An int register for float constant
-                info->internalIntCount = 1;
-            }
-            else
-            {
-                // TYP_DOUBLE
-                assert(tree->TypeGet() == TYP_DOUBLE);
-
-                // Two int registers for double constant
-                info->internalIntCount = 2;
-            }
-            break;
-
-        case GT_RETURN:
-            TreeNodeInfoInitReturn(tree);
-            break;
-
-        case GT_RETFILT:
-            if (tree->TypeGet() == TYP_VOID)
-            {
-                info->srcCount = 0;
-                info->dstCount = 0;
-            }
-            else
-            {
-                assert(tree->TypeGet() == TYP_INT);
-
-                info->srcCount = 1;
-                info->dstCount = 0;
-
-                info->setSrcCandidates(l, RBM_INTRET);
-                tree->gtOp.gtOp1->gtLsraInfo.setSrcCandidates(l, RBM_INTRET);
-            }
-            break;
-
-        case GT_LEA:
-        {
-            GenTreeAddrMode* lea = tree->AsAddrMode();
-
-            GenTree* base  = lea->Base();
-            GenTree* index = lea->Index();
-            unsigned cns   = lea->gtOffset;
-
-            // This LEA is instantiating an address,
-            // so we set up the srcCount and dstCount here.
-            info->srcCount = 0;
-            if (base != nullptr)
-            {
-                info->srcCount++;
-            }
-            if (index != nullptr)
-            {
-                info->srcCount++;
-            }
-            info->dstCount = 1;
-
-            if ((index != nullptr) && (cns != 0))
-            {
-                NYI_ARM("GT_LEA: index and cns are not nil");
-            }
-            else if (!emitter::emitIns_valid_imm_for_add(cns, INS_FLAGS_DONT_CARE))
-            {
-                NYI_ARM("GT_LEA: invalid imm");
-            }
-        }
-        break;
-
-        case GT_NEG:
-            info->srcCount = 1;
-            info->dstCount = 1;
-            break;
-
-        case GT_NOT:
-            info->srcCount = 1;
-            info->dstCount = 1;
-            break;
-
-        case GT_LSH:
-        case GT_RSH:
-        case GT_RSZ:
-        case GT_ROR:
-        {
-            info->srcCount = 2;
-            info->dstCount = 1;
-
-            GenTreePtr shiftBy = tree->gtOp.gtOp2;
-            GenTreePtr source  = tree->gtOp.gtOp1;
-            if (shiftBy->IsCnsIntOrI())
-            {
-                l->clearDstCount(shiftBy);
-                info->srcCount--;
-            }
-        }
-        break;
-
-        case GT_EQ:
-        case GT_NE:
-        case GT_LT:
-        case GT_LE:
-        case GT_GE:
-        case GT_GT:
-            TreeNodeInfoInitCmp(tree);
-            break;
-
-        case GT_CALL:
-            TreeNodeInfoInitCall(tree->AsCall());
-            break;
-
-        case GT_STOREIND:
-        {
-            info->srcCount = 2;
-            info->dstCount = 0;
-            GenTree* src   = tree->gtOp.gtOp2;
-
-            if (compiler->codeGen->gcInfo.gcIsWriteBarrierAsgNode(tree))
-            {
-                LowerGCWriteBarrier(tree);
-                break;
-            }
-
-            SetIndirAddrOpCounts(tree);
-        }
-        break;
-
-        case GT_NULLCHECK:
-            info->dstCount      = 0;
-            info->srcCount      = 1;
-            info->isLocalDefUse = true;
-            // null check is an indirection on an addr
-            SetIndirAddrOpCounts(tree);
-            break;
-
-        case GT_IND:
-            info->dstCount = 1;
-            info->srcCount = 1;
-            SetIndirAddrOpCounts(tree);
-            break;
-
-        case GT_CATCH_ARG:
-            info->srcCount = 0;
-            info->dstCount = 1;
-            info->setDstCandidates(l, RBM_EXCEPTION_OBJECT);
-            break;
-
-        case GT_CLS_VAR:
-            info->srcCount = 0;
-            // GT_CLS_VAR, by the time we reach the backend, must always
-            // be a pure use.
-            // It will produce a result of the type of the
-            // node, and use an internal register for the address.
-
-            info->dstCount = 1;
-            assert((tree->gtFlags & (GTF_VAR_DEF | GTF_VAR_USEASG | GTF_VAR_USEDEF)) == 0);
-            info->internalIntCount = 1;
-            break;
-
-        default:
-#ifdef DEBUG
-            JitTls::GetCompiler()->gtDispTree(tree);
-#endif
-            NYI_ARM("TreeNodeInfoInit default case");
-        case GT_LCL_FLD:
-        case GT_LCL_VAR:
-        case GT_LCL_VAR_ADDR:
-        case GT_CLS_VAR_ADDR:
-        case GT_IL_OFFSET:
-        case GT_CNS_INT:
-        case GT_PUTARG_REG:
-        case GT_PUTARG_STK:
-            info->dstCount = tree->IsValue() ? 1 : 0;
-            if (kind & (GTK_CONST | GTK_LEAF))
-            {
-                info->srcCount = 0;
-            }
-            else if (kind & (GTK_SMPOP))
-            {
-                if (tree->gtGetOp2() != nullptr)
-                {
-                    info->srcCount = 2;
-                }
-                else
-                {
-                    info->srcCount = 1;
-                }
-            }
-            else
-            {
-                unreached();
-            }
-            break;
-    } // end switch (tree->OperGet())
-
-    // We need to be sure that we've set info->srcCount and info->dstCount appropriately
-    assert((info->dstCount < 2) || tree->IsMultiRegCall());
 }
 
 //------------------------------------------------------------------------
diff --git a/src/jit/lowerarm64.cpp b/src/jit/lowerarm64.cpp
index f87f260b11..f5bc55e10c 100644
--- a/src/jit/lowerarm64.cpp
+++ b/src/jit/lowerarm64.cpp
@@ -29,34 +29,20 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 #include "sideeffects.h"
 #include "lower.h"
 
-// there is not much lowering to do with storing a local but
-// we do some handling of contained immediates and widening operations of unsigneds
+//------------------------------------------------------------------------
+// LowerStoreLoc: Lower a store of a lclVar
+//
+// Arguments:
+//    storeLoc - the local store (GT_STORE_LCL_FLD or GT_STORE_LCL_VAR)
+//
+// Notes:
+//    This involves:
+//    - Widening operations of unsigneds.
+
 void Lowering::LowerStoreLoc(GenTreeLclVarCommon* storeLoc)
 {
-    TreeNodeInfo* info = &(storeLoc->gtLsraInfo);
-
-    // Is this the case of var = call where call is returning
-    // a value in multiple return registers?
-    GenTree* op1 = storeLoc->gtGetOp1();
-    if (op1->IsMultiRegCall())
-    {
-        // backend expects to see this case only for store lclvar.
-        assert(storeLoc->OperGet() == GT_STORE_LCL_VAR);
-
-        // srcCount = number of registers in which the value is returned by call
-        GenTreeCall*    call        = op1->AsCall();
-        ReturnTypeDesc* retTypeDesc = call->GetReturnTypeDesc();
-        info->srcCount              = retTypeDesc->GetReturnRegCount();
-
-        // Call node srcCandidates = Bitwise-OR(allregs(GetReturnRegType(i))) for all i=0..RetRegCount-1
-        regMaskTP srcCandidates = m_lsra->allMultiRegCallNodeRegs(call);
-        op1->gtLsraInfo.setSrcCandidates(m_lsra, srcCandidates);
-        return;
-    }
-
-    CheckImmedAndMakeContained(storeLoc, op1);
-
     // Try to widen the ops if they are going into a local var.
+    GenTree* op1 = storeLoc->gtGetOp1();
     if ((storeLoc->gtOper == GT_STORE_LCL_VAR) && (op1->gtOper == GT_CNS_INT))
     {
         GenTreeIntCon* con    = op1->AsIntCon();
@@ -105,1120 +91,8 @@ void Lowering::LowerStoreLoc(GenTreeLclVarCommon* storeLoc)
     }
 }
 
-/**
- * Takes care of annotating the register requirements
- * for every TreeNodeInfo struct that maps to each tree node.
- * Preconditions:
- *    LSRA has been initialized and there is a TreeNodeInfo node
- *    already allocated and initialized for every tree in the IR.
- * Postconditions:
- *    Every TreeNodeInfo instance has the right annotations on register
- *    requirements needed by LSRA to build the Interval Table (source,
- *    destination and internal [temp] register counts).
- *    This code is refactored originally from LSRA.
- */
-void Lowering::TreeNodeInfoInit(GenTree* tree)
-{
-    LinearScan* l        = m_lsra;
-    Compiler*   compiler = comp;
-
-    unsigned      kind         = tree->OperKind();
-    TreeNodeInfo* info         = &(tree->gtLsraInfo);
-    RegisterType  registerType = TypeGet(tree);
-
-    JITDUMP("TreeNodeInfoInit for: ");
-    DISPNODE(tree);
-    JITDUMP("\n");
-
-    switch (tree->OperGet())
-    {
-        GenTree* op1;
-        GenTree* op2;
-
-        default:
-            info->dstCount = tree->IsValue() ? 1 : 0;
-            if (kind & (GTK_CONST | GTK_LEAF))
-            {
-                info->srcCount = 0;
-            }
-            else if (kind & (GTK_SMPOP))
-            {
-                if (tree->gtGetOp2() != nullptr)
-                {
-                    info->srcCount = 2;
-                }
-                else
-                {
-                    info->srcCount = 1;
-                }
-            }
-            else
-            {
-                unreached();
-            }
-            break;
-
-        case GT_STORE_LCL_FLD:
-        case GT_STORE_LCL_VAR:
-            info->srcCount = 1;
-            info->dstCount = 0;
-            LowerStoreLoc(tree->AsLclVarCommon());
-            break;
-
-        case GT_BOX:
-            noway_assert(!"box should not exist here");
-            // The result of 'op1' is also the final result
-            info->srcCount = 0;
-            info->dstCount = 0;
-            break;
-
-        case GT_PHYSREGDST:
-            info->srcCount = 1;
-            info->dstCount = 0;
-            break;
-
-        case GT_COMMA:
-        {
-            GenTreePtr firstOperand;
-            GenTreePtr secondOperand;
-            if (tree->gtFlags & GTF_REVERSE_OPS)
-            {
-                firstOperand  = tree->gtOp.gtOp2;
-                secondOperand = tree->gtOp.gtOp1;
-            }
-            else
-            {
-                firstOperand  = tree->gtOp.gtOp1;
-                secondOperand = tree->gtOp.gtOp2;
-            }
-            if (firstOperand->TypeGet() != TYP_VOID)
-            {
-                firstOperand->gtLsraInfo.isLocalDefUse = true;
-                firstOperand->gtLsraInfo.dstCount      = 0;
-            }
-            if (tree->TypeGet() == TYP_VOID && secondOperand->TypeGet() != TYP_VOID)
-            {
-                secondOperand->gtLsraInfo.isLocalDefUse = true;
-                secondOperand->gtLsraInfo.dstCount      = 0;
-            }
-        }
-
-            __fallthrough;
-
-        case GT_LIST:
-        case GT_FIELD_LIST:
-        case GT_ARGPLACE:
-        case GT_NO_OP:
-        case GT_START_NONGC:
-        case GT_PROF_HOOK:
-            info->srcCount = 0;
-            info->dstCount = 0;
-            break;
-
-        case GT_CNS_DBL:
-            info->srcCount = 0;
-            info->dstCount = 1;
-            {
-                GenTreeDblCon* dblConst   = tree->AsDblCon();
-                double         constValue = dblConst->gtDblCon.gtDconVal;
-
-                if (emitter::emitIns_valid_imm_for_fmov(constValue))
-                {
-                    // Directly encode constant to instructions.
-                }
-                else
-                {
-                    // Reserve int to load constant from memory (IF_LARGELDC)
-                    info->internalIntCount = 1;
-                }
-            }
-            break;
-
-        case GT_QMARK:
-        case GT_COLON:
-            info->srcCount = 0;
-            info->dstCount = 0;
-            unreached();
-            break;
-
-        case GT_RETURN:
-            TreeNodeInfoInitReturn(tree);
-            break;
-
-        case GT_RETFILT:
-            if (tree->TypeGet() == TYP_VOID)
-            {
-                info->srcCount = 0;
-                info->dstCount = 0;
-            }
-            else
-            {
-                assert(tree->TypeGet() == TYP_INT);
-
-                info->srcCount = 1;
-                info->dstCount = 0;
-
-                info->setSrcCandidates(l, RBM_INTRET);
-                tree->gtOp.gtOp1->gtLsraInfo.setSrcCandidates(l, RBM_INTRET);
-            }
-            break;
-
-        case GT_NOP:
-            // A GT_NOP is either a passthrough (if it is void, or if it has
-            // a child), but must be considered to produce a dummy value if it
-            // has a type but no child
-            info->srcCount = 0;
-            if (tree->TypeGet() != TYP_VOID && tree->gtOp.gtOp1 == nullptr)
-            {
-                info->dstCount = 1;
-            }
-            else
-            {
-                info->dstCount = 0;
-            }
-            break;
-
-        case GT_JTRUE:
-            info->srcCount = 0;
-            info->dstCount = 0;
-            l->clearDstCount(tree->gtOp.gtOp1);
-            break;
-
-        case GT_JMP:
-            info->srcCount = 0;
-            info->dstCount = 0;
-            break;
-
-        case GT_SWITCH:
-            // This should never occur since switch nodes must not be visible at this
-            // point in the JIT.
-            info->srcCount = 0;
-            info->dstCount = 0; // To avoid getting uninit errors.
-            noway_assert(!"Switch must be lowered at this point");
-            break;
-
-        case GT_JMPTABLE:
-            info->srcCount = 0;
-            info->dstCount = 1;
-            break;
-
-        case GT_SWITCH_TABLE:
-            info->srcCount         = 2;
-            info->internalIntCount = 1;
-            info->dstCount         = 0;
-            break;
-
-        case GT_ASG:
-        case GT_ASG_ADD:
-        case GT_ASG_SUB:
-            noway_assert(!"We should never hit any assignment operator in lowering");
-            info->srcCount = 0;
-            info->dstCount = 0;
-            break;
-
-        case GT_ADD:
-        case GT_SUB:
-            if (varTypeIsFloating(tree->TypeGet()))
-            {
-                // overflow operations aren't supported on float/double types.
-                assert(!tree->gtOverflow());
-
-                // No implicit conversions at this stage as the expectation is that
-                // everything is made explicit by adding casts.
-                assert(tree->gtOp.gtOp1->TypeGet() == tree->gtOp.gtOp2->TypeGet());
-
-                info->srcCount = 2;
-                info->dstCount = 1;
-
-                break;
-            }
-
-            __fallthrough;
-
-        case GT_AND:
-        case GT_OR:
-        case GT_XOR:
-            info->srcCount = 2;
-            info->dstCount = 1;
-            // Check and make op2 contained (if it is a containable immediate)
-            CheckImmedAndMakeContained(tree, tree->gtOp.gtOp2);
-            break;
-
-        case GT_RETURNTRAP:
-            // this just turns into a compare of its child with an int
-            // + a conditional call
-            info->srcCount = 1;
-            info->dstCount = 0;
-            break;
-
-        case GT_MOD:
-        case GT_UMOD:
-            NYI_IF(varTypeIsFloating(tree->TypeGet()), "FP Remainder in ARM64");
-            assert(!"Shouldn't see an integer typed GT_MOD node in ARM64");
-            break;
-
-        case GT_MUL:
-            if (tree->gtOverflow())
-            {
-                // Need a register different from target reg to check for overflow.
-                info->internalIntCount = 2;
-            }
-            __fallthrough;
-
-        case GT_DIV:
-        case GT_MULHI:
-        case GT_UDIV:
-        {
-            info->srcCount = 2;
-            info->dstCount = 1;
-        }
-        break;
-
-        case GT_INTRINSIC:
-        {
-            // TODO-ARM64-NYI
-            // Right now only Abs/Round/Sqrt are treated as math intrinsics
-            noway_assert((tree->gtIntrinsic.gtIntrinsicId == CORINFO_INTRINSIC_Abs) ||
-                         (tree->gtIntrinsic.gtIntrinsicId == CORINFO_INTRINSIC_Round) ||
-                         (tree->gtIntrinsic.gtIntrinsicId == CORINFO_INTRINSIC_Sqrt));
-
-            // Both operand and its result must be of the same floating point type.
-            op1 = tree->gtOp.gtOp1;
-            assert(varTypeIsFloating(op1));
-            assert(op1->TypeGet() == tree->TypeGet());
-
-            info->srcCount = 1;
-            info->dstCount = 1;
-        }
-        break;
-
-#ifdef FEATURE_SIMD
-        case GT_SIMD:
-            TreeNodeInfoInitSIMD(tree);
-            break;
-#endif // FEATURE_SIMD
-
-        case GT_CAST:
-        {
-            // TODO-ARM64-CQ: Int-To-Int conversions - castOp cannot be a memory op and must have an assigned
-            //                register.
-            //         see CodeGen::genIntToIntCast()
-
-            info->srcCount = 1;
-            info->dstCount = 1;
-
-            // Non-overflow casts to/from float/double are done using SSE2 instructions
-            // and that allow the source operand to be either a reg or memop. Given the
-            // fact that casts from small int to float/double are done as two-level casts,
-            // the source operand is always guaranteed to be of size 4 or 8 bytes.
-            var_types  castToType = tree->CastToType();
-            GenTreePtr castOp     = tree->gtCast.CastOp();
-            var_types  castOpType = castOp->TypeGet();
-            if (tree->gtFlags & GTF_UNSIGNED)
-            {
-                castOpType = genUnsignedType(castOpType);
-            }
-#ifdef DEBUG
-            if (!tree->gtOverflow() && (varTypeIsFloating(castToType) || varTypeIsFloating(castOpType)))
-            {
-                // If converting to float/double, the operand must be 4 or 8 byte in size.
-                if (varTypeIsFloating(castToType))
-                {
-                    unsigned opSize = genTypeSize(castOpType);
-                    assert(opSize == 4 || opSize == 8);
-                }
-            }
-#endif // DEBUG
-            // Some overflow checks need a temp reg
-
-            CastInfo castInfo;
-
-            // Get information about the cast.
-            getCastDescription(tree, &castInfo);
-
-            if (castInfo.requiresOverflowCheck)
-            {
-                var_types srcType = castOp->TypeGet();
-                emitAttr  cmpSize = EA_ATTR(genTypeSize(srcType));
-
-                // If we cannot store the comparisons in an immediate for either
-                // comparing against the max or min value, then we will need to
-                // reserve a temporary register.
-
-                bool canStoreMaxValue = emitter::emitIns_valid_imm_for_cmp(castInfo.typeMax, cmpSize);
-                bool canStoreMinValue = emitter::emitIns_valid_imm_for_cmp(castInfo.typeMin, cmpSize);
-
-                if (!canStoreMaxValue || !canStoreMinValue)
-                {
-                    info->internalIntCount = 1;
-                }
-            }
-        }
-        break;
-
-        case GT_NEG:
-            info->srcCount = 1;
-            info->dstCount = 1;
-            break;
-
-        case GT_NOT:
-            info->srcCount = 1;
-            info->dstCount = 1;
-            break;
-
-        case GT_LSH:
-        case GT_RSH:
-        case GT_RSZ:
-        case GT_ROR:
-        {
-            info->srcCount = 2;
-            info->dstCount = 1;
-
-            GenTreePtr shiftBy = tree->gtOp.gtOp2;
-            GenTreePtr source  = tree->gtOp.gtOp1;
-            if (shiftBy->IsCnsIntOrI())
-            {
-                l->clearDstCount(shiftBy);
-                info->srcCount--;
-            }
-        }
-        break;
-
-        case GT_EQ:
-        case GT_NE:
-        case GT_LT:
-        case GT_LE:
-        case GT_GE:
-        case GT_GT:
-            TreeNodeInfoInitCmp(tree);
-            break;
-
-        case GT_CKFINITE:
-            info->srcCount         = 1;
-            info->dstCount         = 1;
-            info->internalIntCount = 1;
-            break;
-
-        case GT_CMPXCHG:
-            info->srcCount = 3;
-            info->dstCount = 1;
-
-            // TODO-ARM64-NYI
-            NYI("CMPXCHG");
-            break;
-
-        case GT_LOCKADD:
-            info->srcCount = 2;
-            info->dstCount = 0;
-            CheckImmedAndMakeContained(tree, tree->gtOp.gtOp2);
-            break;
-
-        case GT_CALL:
-            TreeNodeInfoInitCall(tree->AsCall());
-            break;
-
-        case GT_ADDR:
-        {
-            // For a GT_ADDR, the child node should not be evaluated into a register
-            GenTreePtr child = tree->gtOp.gtOp1;
-            assert(!l->isCandidateLocalRef(child));
-            l->clearDstCount(child);
-            info->srcCount = 0;
-            info->dstCount = 1;
-        }
-        break;
-
-        case GT_BLK:
-        case GT_DYN_BLK:
-            // These should all be eliminated prior to Lowering.
-            assert(!"Non-store block node in Lowering");
-            info->srcCount = 0;
-            info->dstCount = 0;
-            break;
-
-        case GT_STORE_BLK:
-        case GT_STORE_OBJ:
-        case GT_STORE_DYN_BLK:
-            TreeNodeInfoInitBlockStore(tree->AsBlk());
-            break;
-
-        case GT_INIT_VAL:
-            // Always a passthrough of its child's value.
-            info->srcCount = 0;
-            info->dstCount = 0;
-            break;
-
-        case GT_LCLHEAP:
-        {
-            info->srcCount = 1;
-            info->dstCount = 1;
-
-            // Need a variable number of temp regs (see genLclHeap() in codegenamd64.cpp):
-            // Here '-' means don't care.
-            //
-            //  Size?                   Init Memory?    # temp regs
-            //   0                          -               0
-            //   const and <=6 ptr words    -               0
-            //   const and <PageSize        No              0
-            //   >6 ptr words               Yes           hasPspSym ? 1 : 0
-            //   Non-const                  Yes           hasPspSym ? 1 : 0
-            //   Non-const                  No              2
-            //
-            // PSPSym - If the method has PSPSym increment internalIntCount by 1.
-            //
-            bool hasPspSym;
-#if FEATURE_EH_FUNCLETS
-            hasPspSym = (compiler->lvaPSPSym != BAD_VAR_NUM);
-#else
-            hasPspSym = false;
-#endif
-
-            GenTreePtr size = tree->gtOp.gtOp1;
-            if (size->IsCnsIntOrI())
-            {
-                MakeSrcContained(tree, size);
-
-                size_t sizeVal = size->gtIntCon.gtIconVal;
-
-                if (sizeVal == 0)
-                {
-                    info->internalIntCount = 0;
-                }
-                else
-                {
-                    // Compute the amount of memory to properly STACK_ALIGN.
-                    // Note: The Gentree node is not updated here as it is cheap to recompute stack aligned size.
-                    // This should also help in debugging as we can examine the original size specified with
-                    // localloc.
-                    sizeVal                          = AlignUp(sizeVal, STACK_ALIGN);
-                    size_t cntStackAlignedWidthItems = (sizeVal >> STACK_ALIGN_SHIFT);
-
-                    // For small allocations upto 4 'stp' instructions (i.e. 64 bytes of localloc)
-                    //
-                    if (cntStackAlignedWidthItems <= 4)
-                    {
-                        info->internalIntCount = 0;
-                    }
-                    else if (!compiler->info.compInitMem)
-                    {
-                        // No need to initialize allocated stack space.
-                        if (sizeVal < compiler->eeGetPageSize())
-                        {
-                            info->internalIntCount = 0;
-                        }
-                        else
-                        {
-                            // We need two registers: regCnt and RegTmp
-                            info->internalIntCount = 2;
-                        }
-                    }
-                    else
-                    {
-                        // greater than 4 and need to zero initialize allocated stack space.
-                        // If the method has PSPSym, we need an internal register to hold regCnt
-                        // since targetReg allocated to GT_LCLHEAP node could be the same as one of
-                        // the the internal registers.
-                        info->internalIntCount = hasPspSym ? 1 : 0;
-                    }
-                }
-            }
-            else
-            {
-                if (!compiler->info.compInitMem)
-                {
-                    info->internalIntCount = 2;
-                }
-                else
-                {
-                    // If the method has PSPSym, we need an internal register to hold regCnt
-                    // since targetReg allocated to GT_LCLHEAP node could be the same as one of
-                    // the the internal registers.
-                    info->internalIntCount = hasPspSym ? 1 : 0;
-                }
-            }
-
-            // If the method has PSPSym, we would need an addtional register to relocate it on stack.
-            if (hasPspSym)
-            {
-                // Exclude const size 0
-                if (!size->IsCnsIntOrI() || (size->gtIntCon.gtIconVal > 0))
-                    info->internalIntCount++;
-            }
-        }
-        break;
-
-        case GT_ARR_BOUNDS_CHECK:
-#ifdef FEATURE_SIMD
-        case GT_SIMD_CHK:
-#endif // FEATURE_SIMD
-        {
-            GenTreeBoundsChk* node = tree->AsBoundsChk();
-            // Consumes arrLen & index - has no result
-            info->srcCount = 2;
-            info->dstCount = 0;
-
-            GenTree* intCns = nullptr;
-            GenTree* other  = nullptr;
-            if (CheckImmedAndMakeContained(tree, node->gtIndex))
-            {
-                intCns = node->gtIndex;
-                other  = node->gtArrLen;
-            }
-            else if (CheckImmedAndMakeContained(tree, node->gtArrLen))
-            {
-                intCns = node->gtArrLen;
-                other  = node->gtIndex;
-            }
-            else
-            {
-                other = node->gtIndex;
-            }
-        }
-        break;
-
-        case GT_ARR_ELEM:
-            // These must have been lowered to GT_ARR_INDEX
-            noway_assert(!"We should never see a GT_ARR_ELEM in lowering");
-            info->srcCount = 0;
-            info->dstCount = 0;
-            break;
-
-        case GT_ARR_INDEX:
-            info->srcCount = 2;
-            info->dstCount = 1;
-
-            // We need one internal register when generating code for GT_ARR_INDEX, however the
-            // register allocator always may just give us the same one as it gives us for the 'dst'
-            // as a workaround we will just ask for two internal registers.
-            //
-            info->internalIntCount = 2;
-
-            // For GT_ARR_INDEX, the lifetime of the arrObj must be extended because it is actually used multiple
-            // times while the result is being computed.
-            tree->AsArrIndex()->ArrObj()->gtLsraInfo.isDelayFree = true;
-            info->hasDelayFreeSrc                                = true;
-            break;
-
-        case GT_ARR_OFFSET:
-            // This consumes the offset, if any, the arrObj and the effective index,
-            // and produces the flattened offset for this dimension.
-            info->srcCount         = 3;
-            info->dstCount         = 1;
-            info->internalIntCount = 1;
-
-            // we don't want to generate code for this
-            if (tree->gtArrOffs.gtOffset->IsIntegralConst(0))
-            {
-                MakeSrcContained(tree, tree->gtArrOffs.gtOffset);
-            }
-            break;
-
-        case GT_LEA:
-        {
-            GenTreeAddrMode* lea = tree->AsAddrMode();
-
-            GenTree* base  = lea->Base();
-            GenTree* index = lea->Index();
-            unsigned cns   = lea->gtOffset;
-
-            // This LEA is instantiating an address,
-            // so we set up the srcCount and dstCount here.
-            info->srcCount = 0;
-            if (base != nullptr)
-            {
-                info->srcCount++;
-            }
-            if (index != nullptr)
-            {
-                info->srcCount++;
-            }
-            info->dstCount = 1;
-
-            // On ARM64 we may need a single internal register
-            // (when both conditions are true then we still only need a single internal register)
-            if ((index != nullptr) && (cns != 0))
-            {
-                // ARM64 does not support both Index and offset so we need an internal register
-                info->internalIntCount = 1;
-            }
-            else if (!emitter::emitIns_valid_imm_for_add(cns, EA_8BYTE))
-            {
-                // This offset can't be contained in the add instruction, so we need an internal register
-                info->internalIntCount = 1;
-            }
-        }
-        break;
-
-        case GT_STOREIND:
-        {
-            info->srcCount = 2;
-            info->dstCount = 0;
-            GenTree* src   = tree->gtOp.gtOp2;
-
-            if (compiler->codeGen->gcInfo.gcIsWriteBarrierAsgNode(tree))
-            {
-                LowerGCWriteBarrier(tree);
-                break;
-            }
-            if (!varTypeIsFloating(src->TypeGet()) && src->IsIntegralConst(0))
-            {
-                // an integer zero for 'src' can be contained.
-                MakeSrcContained(tree, src);
-            }
-
-            SetIndirAddrOpCounts(tree);
-        }
-        break;
-
-        case GT_NULLCHECK:
-            info->dstCount      = 0;
-            info->srcCount      = 1;
-            info->isLocalDefUse = true;
-            // null check is an indirection on an addr
-            SetIndirAddrOpCounts(tree);
-            break;
-
-        case GT_IND:
-            info->dstCount = 1;
-            info->srcCount = 1;
-            SetIndirAddrOpCounts(tree);
-            break;
-
-        case GT_CATCH_ARG:
-            info->srcCount = 0;
-            info->dstCount = 1;
-            info->setDstCandidates(l, RBM_EXCEPTION_OBJECT);
-            break;
-
-        case GT_CLS_VAR:
-            info->srcCount = 0;
-            // GT_CLS_VAR, by the time we reach the backend, must always
-            // be a pure use.
-            // It will produce a result of the type of the
-            // node, and use an internal register for the address.
-
-            info->dstCount = 1;
-            assert((tree->gtFlags & (GTF_VAR_DEF | GTF_VAR_USEASG | GTF_VAR_USEDEF)) == 0);
-            info->internalIntCount = 1;
-            break;
-    } // end switch (tree->OperGet())
-
-    // We need to be sure that we've set info->srcCount and info->dstCount appropriately
-    assert((info->dstCount < 2) || tree->IsMultiRegCall());
-}
-//------------------------------------------------------------------------
-// TreeNodeInfoInitReturn: Set the NodeInfo for a GT_RETURN.
-//
-// Arguments:
-//    tree      - The node of interest
-//
-// Return Value:
-//    None.
-//
-void Lowering::TreeNodeInfoInitReturn(GenTree* tree)
-{
-    TreeNodeInfo* info     = &(tree->gtLsraInfo);
-    LinearScan*   l        = m_lsra;
-    Compiler*     compiler = comp;
-
-    GenTree*  op1           = tree->gtGetOp1();
-    regMaskTP useCandidates = RBM_NONE;
-
-    info->srcCount = (tree->TypeGet() == TYP_VOID) ? 0 : 1;
-    info->dstCount = 0;
-
-    if (varTypeIsStruct(tree))
-    {
-        // op1 has to be either an lclvar or a multi-reg returning call
-        if ((op1->OperGet() == GT_LCL_VAR) || (op1->OperGet() == GT_LCL_FLD))
-        {
-            GenTreeLclVarCommon* lclVarCommon = op1->AsLclVarCommon();
-            LclVarDsc*           varDsc       = &(compiler->lvaTable[lclVarCommon->gtLclNum]);
-            assert(varDsc->lvIsMultiRegRet);
-
-            // Mark var as contained if not enregistrable.
-            if (!varTypeIsEnregisterableStruct(op1))
-            {
-                MakeSrcContained(tree, op1);
-            }
-        }
-        else
-        {
-            noway_assert(op1->IsMultiRegCall());
-
-            ReturnTypeDesc* retTypeDesc = op1->AsCall()->GetReturnTypeDesc();
-            info->srcCount              = retTypeDesc->GetReturnRegCount();
-            useCandidates               = retTypeDesc->GetABIReturnRegs();
-        }
-    }
-    else
-    {
-        // Non-struct type return - determine useCandidates
-        switch (tree->TypeGet())
-        {
-            case TYP_VOID:
-                useCandidates = RBM_NONE;
-                break;
-            case TYP_FLOAT:
-                useCandidates = RBM_FLOATRET;
-                break;
-            case TYP_DOUBLE:
-                useCandidates = RBM_DOUBLERET;
-                break;
-            case TYP_LONG:
-                useCandidates = RBM_LNGRET;
-                break;
-            default:
-                useCandidates = RBM_INTRET;
-                break;
-        }
-    }
-
-    if (useCandidates != RBM_NONE)
-    {
-        tree->gtOp.gtOp1->gtLsraInfo.setSrcCandidates(l, useCandidates);
-    }
-}
-
-//------------------------------------------------------------------------
-// TreeNodeInfoInitCall: Set the NodeInfo for a call.
-//
-// Arguments:
-//    call      - The call node of interest
-//
-// Return Value:
-//    None.
-//
-void Lowering::TreeNodeInfoInitCall(GenTreeCall* call)
-{
-    TreeNodeInfo*   info              = &(call->gtLsraInfo);
-    LinearScan*     l                 = m_lsra;
-    Compiler*       compiler          = comp;
-    bool            hasMultiRegRetVal = false;
-    ReturnTypeDesc* retTypeDesc       = nullptr;
-
-    info->srcCount = 0;
-    if (call->TypeGet() != TYP_VOID)
-    {
-        hasMultiRegRetVal = call->HasMultiRegRetVal();
-        if (hasMultiRegRetVal)
-        {
-            // dst count = number of registers in which the value is returned by call
-            retTypeDesc    = call->GetReturnTypeDesc();
-            info->dstCount = retTypeDesc->GetReturnRegCount();
-        }
-        else
-        {
-            info->dstCount = 1;
-        }
-    }
-    else
-    {
-        info->dstCount = 0;
-    }
-
-    GenTree* ctrlExpr = call->gtControlExpr;
-    if (call->gtCallType == CT_INDIRECT)
-    {
-        // either gtControlExpr != null or gtCallAddr != null.
-        // Both cannot be non-null at the same time.
-        assert(ctrlExpr == nullptr);
-        assert(call->gtCallAddr != nullptr);
-        ctrlExpr = call->gtCallAddr;
-    }
-
-    // set reg requirements on call target represented as control sequence.
-    if (ctrlExpr != nullptr)
-    {
-        // we should never see a gtControlExpr whose type is void.
-        assert(ctrlExpr->TypeGet() != TYP_VOID);
-
-        info->srcCount++;
-
-        // In case of fast tail implemented as jmp, make sure that gtControlExpr is
-        // computed into a register.
-        if (call->IsFastTailCall())
-        {
-            // Fast tail call - make sure that call target is always computed in IP0
-            // so that epilog sequence can generate "br xip0" to achieve fast tail call.
-            ctrlExpr->gtLsraInfo.setSrcCandidates(l, genRegMask(REG_IP0));
-        }
-    }
-
-    RegisterType registerType = call->TypeGet();
-
-    // Set destination candidates for return value of the call.
-    if (hasMultiRegRetVal)
-    {
-        assert(retTypeDesc != nullptr);
-        info->setDstCandidates(l, retTypeDesc->GetABIReturnRegs());
-    }
-    else if (varTypeIsFloating(registerType))
-    {
-        info->setDstCandidates(l, RBM_FLOATRET);
-    }
-    else if (registerType == TYP_LONG)
-    {
-        info->setDstCandidates(l, RBM_LNGRET);
-    }
-    else
-    {
-        info->setDstCandidates(l, RBM_INTRET);
-    }
-
-    // If there is an explicit this pointer, we don't want that node to produce anything
-    // as it is redundant
-    if (call->gtCallObjp != nullptr)
-    {
-        GenTreePtr thisPtrNode = call->gtCallObjp;
-
-        if (thisPtrNode->gtOper == GT_PUTARG_REG)
-        {
-            l->clearOperandCounts(thisPtrNode);
-            l->clearDstCount(thisPtrNode->gtOp.gtOp1);
-        }
-        else
-        {
-            l->clearDstCount(thisPtrNode);
-        }
-    }
-
-    // First, count reg args
-    bool callHasFloatRegArgs = false;
-
-    for (GenTreePtr list = call->gtCallLateArgs; list; list = list->MoveNext())
-    {
-        assert(list->OperIsList());
-
-        GenTreePtr argNode = list->Current();
-
-        fgArgTabEntryPtr curArgTabEntry = compiler->gtArgEntryByNode(call, argNode);
-        assert(curArgTabEntry);
-
-        if (curArgTabEntry->regNum == REG_STK)
-        {
-            // late arg that is not passed in a register
-            assert(argNode->gtOper == GT_PUTARG_STK);
-
-            TreeNodeInfoInitPutArgStk(argNode->AsPutArgStk(), curArgTabEntry);
-            continue;
-        }
-
-        var_types argType    = argNode->TypeGet();
-        bool      argIsFloat = varTypeIsFloating(argType);
-        callHasFloatRegArgs |= argIsFloat;
-
-        regNumber argReg = curArgTabEntry->regNum;
-        // We will setup argMask to the set of all registers that compose this argument
-        regMaskTP argMask = 0;
-
-        argNode = argNode->gtEffectiveVal();
-
-        // A GT_FIELD_LIST has a TYP_VOID, but is used to represent a multireg struct
-        if (varTypeIsStruct(argNode) || (argNode->gtOper == GT_FIELD_LIST))
-        {
-            GenTreePtr actualArgNode = argNode;
-            unsigned   originalSize  = 0;
-
-            if (argNode->gtOper == GT_FIELD_LIST)
-            {
-                // There could be up to 2-4 PUTARG_REGs in the list (3 or 4 can only occur for HFAs)
-                GenTreeFieldList* fieldListPtr = argNode->AsFieldList();
-
-                // Initailize the first register and the first regmask in our list
-                regNumber targetReg    = argReg;
-                regMaskTP targetMask   = genRegMask(targetReg);
-                unsigned  iterationNum = 0;
-                originalSize           = 0;
-
-                for (; fieldListPtr; fieldListPtr = fieldListPtr->Rest())
-                {
-                    GenTreePtr putArgRegNode = fieldListPtr->Current();
-                    assert(putArgRegNode->gtOper == GT_PUTARG_REG);
-                    GenTreePtr putArgChild = putArgRegNode->gtOp.gtOp1;
-
-                    originalSize += REGSIZE_BYTES; // 8 bytes
-
-                    // Record the register requirements for the GT_PUTARG_REG node
-                    putArgRegNode->gtLsraInfo.setDstCandidates(l, targetMask);
-                    putArgRegNode->gtLsraInfo.setSrcCandidates(l, targetMask);
-
-                    // To avoid redundant moves, request that the argument child tree be
-                    // computed in the register in which the argument is passed to the call.
-                    putArgChild->gtLsraInfo.setSrcCandidates(l, targetMask);
-
-                    // We consume one source for each item in this list
-                    info->srcCount++;
-                    iterationNum++;
-
-                    // Update targetReg and targetMask for the next putarg_reg (if any)
-                    targetReg  = genRegArgNext(targetReg);
-                    targetMask = genRegMask(targetReg);
-                }
-            }
-            else
-            {
-#ifdef DEBUG
-                compiler->gtDispTreeRange(BlockRange(), argNode);
-#endif
-                noway_assert(!"Unsupported TYP_STRUCT arg kind");
-            }
-
-            unsigned  slots          = ((unsigned)(roundUp(originalSize, REGSIZE_BYTES))) / REGSIZE_BYTES;
-            regNumber curReg         = argReg;
-            regNumber lastReg        = argIsFloat ? REG_ARG_FP_LAST : REG_ARG_LAST;
-            unsigned  remainingSlots = slots;
-
-            while (remainingSlots > 0)
-            {
-                argMask |= genRegMask(curReg);
-                remainingSlots--;
-
-                if (curReg == lastReg)
-                    break;
-
-                curReg = genRegArgNext(curReg);
-            }
-
-            // Struct typed arguments must be fully passed in registers (Reg/Stk split not allowed)
-            noway_assert(remainingSlots == 0);
-            argNode->gtLsraInfo.internalIntCount = 0;
-        }
-        else // A scalar argument (not a struct)
-        {
-            // We consume one source
-            info->srcCount++;
-
-            argMask |= genRegMask(argReg);
-            argNode->gtLsraInfo.setDstCandidates(l, argMask);
-            argNode->gtLsraInfo.setSrcCandidates(l, argMask);
-
-            if (argNode->gtOper == GT_PUTARG_REG)
-            {
-                GenTreePtr putArgChild = argNode->gtOp.gtOp1;
-
-                // To avoid redundant moves, request that the argument child tree be
-                // computed in the register in which the argument is passed to the call.
-                putArgChild->gtLsraInfo.setSrcCandidates(l, argMask);
-            }
-        }
-    }
-
-    // Now, count stack args
-    // Note that these need to be computed into a register, but then
-    // they're just stored to the stack - so the reg doesn't
-    // need to remain live until the call.  In fact, it must not
-    // because the code generator doesn't actually consider it live,
-    // so it can't be spilled.
-
-    GenTreePtr args = call->gtCallArgs;
-    while (args)
-    {
-        GenTreePtr arg = args->gtOp.gtOp1;
-
-        // Skip arguments that have been moved to the Late Arg list
-        if (!(args->gtFlags & GTF_LATE_ARG))
-        {
-            if (arg->gtOper == GT_PUTARG_STK)
-            {
-                fgArgTabEntryPtr curArgTabEntry = compiler->gtArgEntryByNode(call, arg);
-                assert(curArgTabEntry);
-
-                assert(curArgTabEntry->regNum == REG_STK);
-
-                TreeNodeInfoInitPutArgStk(arg->AsPutArgStk(), curArgTabEntry);
-            }
-            else
-            {
-                TreeNodeInfo* argInfo = &(arg->gtLsraInfo);
-                if (argInfo->dstCount != 0)
-                {
-                    argInfo->isLocalDefUse = true;
-                }
-
-                argInfo->dstCount = 0;
-            }
-        }
-        args = args->gtOp.gtOp2;
-    }
-
-    // If it is a fast tail call, it is already preferenced to use IP0.
-    // Therefore, no need set src candidates on call tgt again.
-    if (call->IsVarargs() && callHasFloatRegArgs && !call->IsFastTailCall() && (ctrlExpr != nullptr))
-    {
-        // Don't assign the call target to any of the argument registers because
-        // we will use them to also pass floating point arguments as required
-        // by Arm64 ABI.
-        ctrlExpr->gtLsraInfo.setSrcCandidates(l, l->allRegs(TYP_INT) & ~(RBM_ARG_REGS));
-    }
-}
-
 //------------------------------------------------------------------------
-//  TreeNodeInfoInitPutArgStk: Set the NodeInfo for a GT_PUTARG_STK node
-//
-// Arguments:
-//    argNode       - a GT_PUTARG_STK node
-//
-// Return Value:
-//    None.
-//
-// Notes:
-//    Set the child node(s) to be contained when we have a multireg arg
-//
-void Lowering::TreeNodeInfoInitPutArgStk(GenTreePutArgStk* argNode, fgArgTabEntryPtr info)
-{
-    assert(argNode->gtOper == GT_PUTARG_STK);
-
-    GenTreePtr putArgChild = argNode->gtOp.gtOp1;
-
-    // Initialize 'argNode' as not contained, as this is both the default case
-    //  and how MakeSrcContained expects to find things setup.
-    //
-    argNode->gtLsraInfo.srcCount = 1;
-    argNode->gtLsraInfo.dstCount = 0;
-
-    // Do we have a TYP_STRUCT argument (or a GT_FIELD_LIST), if so it must be a multireg pass-by-value struct
-    if ((putArgChild->TypeGet() == TYP_STRUCT) || (putArgChild->OperGet() == GT_FIELD_LIST))
-    {
-        // We will use store instructions that each write a register sized value
-
-        if (putArgChild->OperGet() == GT_FIELD_LIST)
-        {
-            // We consume all of the items in the GT_FIELD_LIST
-            argNode->gtLsraInfo.srcCount = info->numSlots;
-        }
-        else
-        {
-            // We could use a ldp/stp sequence so we need two internal registers
-            argNode->gtLsraInfo.internalIntCount = 2;
-
-            if (putArgChild->OperGet() == GT_OBJ)
-            {
-                GenTreePtr objChild = putArgChild->gtOp.gtOp1;
-                if (objChild->OperGet() == GT_LCL_VAR_ADDR)
-                {
-                    // We will generate all of the code for the GT_PUTARG_STK, the GT_OBJ and the GT_LCL_VAR_ADDR
-                    // as one contained operation
-                    //
-                    MakeSrcContained(putArgChild, objChild);
-                }
-            }
-
-            // We will generate all of the code for the GT_PUTARG_STK and it's child node
-            // as one contained operation
-            //
-            MakeSrcContained(argNode, putArgChild);
-        }
-    }
-    else
-    {
-        // We must not have a multi-reg struct
-        assert(info->numSlots == 1);
-    }
-}
-
-//------------------------------------------------------------------------
-// TreeNodeInfoInitBlockStore: Set the NodeInfo for a block store.
+// LowerBlockStore: Set block store type
 //
 // Arguments:
 //    blkNode       - The block store node of interest
@@ -1226,22 +100,17 @@ void Lowering::TreeNodeInfoInitPutArgStk(GenTreePutArgStk* argNode, fgArgTabEntr
 // Return Value:
 //    None.
 //
-// Notes:
 
-void Lowering::TreeNodeInfoInitBlockStore(GenTreeBlk* blkNode)
+void Lowering::LowerBlockStore(GenTreeBlk* blkNode)
 {
-    GenTree*    dstAddr  = blkNode->Addr();
-    unsigned    size     = blkNode->gtBlkSize;
-    GenTree*    source   = blkNode->Data();
-    LinearScan* l        = m_lsra;
-    Compiler*   compiler = comp;
+    GenTree*  dstAddr  = blkNode->Addr();
+    unsigned  size     = blkNode->gtBlkSize;
+    GenTree*  source   = blkNode->Data();
+    Compiler* compiler = comp;
 
     // Sources are dest address and initVal or source.
-    // We may require an additional source or temp register for the size.
-    blkNode->gtLsraInfo.srcCount = 2;
-    blkNode->gtLsraInfo.dstCount = 0;
-    GenTreePtr srcAddrOrFill     = nullptr;
-    bool       isInitBlk         = blkNode->OperIsInitBlkOp();
+    GenTreePtr srcAddrOrFill = nullptr;
+    bool       isInitBlk     = blkNode->OperIsInitBlkOp();
 
     if (!isInitBlk)
     {
@@ -1253,20 +122,6 @@ void Lowering::TreeNodeInfoInitBlockStore(GenTreeBlk* blkNode)
         if (source->gtOper == GT_IND)
         {
             srcAddrOrFill = blkNode->Data()->gtGetOp1();
-            // We're effectively setting source as contained, but can't call MakeSrcContained, because the
-            // "inheritance" of the srcCount is to a child not a parent - it would "just work" but could be misleading.
-            // If srcAddr is already non-contained, we don't need to change it.
-            if (srcAddrOrFill->gtLsraInfo.getDstCount() == 0)
-            {
-                srcAddrOrFill->gtLsraInfo.setDstCount(1);
-                srcAddrOrFill->gtLsraInfo.setSrcCount(source->gtLsraInfo.srcCount);
-            }
-            m_lsra->clearOperandCounts(source);
-        }
-        else if (!source->IsMultiRegCall() && !source->OperIsSIMD())
-        {
-            assert(source->IsLocal());
-            MakeSrcContained(blkNode, source);
         }
     }
 
@@ -1303,41 +158,12 @@ void Lowering::TreeNodeInfoInitBlockStore(GenTreeBlk* blkNode)
                 initVal->gtIntCon.gtIconVal = 0x0101010101010101LL * fill;
                 initVal->gtType = TYP_LONG;
             }
-
-            // In case we have a buffer >= 16 bytes
-            // we can use SSE2 to do a 128-bit store in a single
-            // instruction.
-            if (size >= XMM_REGSIZE_BYTES)
-            {
-                // Reserve an XMM register to fill it with 
-                // a pack of 16 init value constants.
-                blkNode->gtLsraInfo.internalFloatCount = 1;
-                blkNode->gtLsraInfo.setInternalCandidates(l, l->internalFloatRegCandidates());
-            }
             initBlkNode->gtBlkOpKind = GenTreeBlkOp::BlkOpKindUnroll;
-            }
         }
         else
 #endif // 0
         {
-            // The helper follows the regular ABI.
-            dstAddr->gtLsraInfo.setSrcCandidates(l, RBM_ARG_0);
-            initVal->gtLsraInfo.setSrcCandidates(l, RBM_ARG_1);
             blkNode->gtBlkOpKind = GenTreeBlk::BlkOpKindHelper;
-            if (size != 0)
-            {
-                // Reserve a temp register for the block size argument.
-                blkNode->gtLsraInfo.setInternalCandidates(l, RBM_ARG_2);
-                blkNode->gtLsraInfo.internalIntCount = 1;
-            }
-            else
-            {
-                // The block size argument is a third argument to GT_STORE_DYN_BLK
-                noway_assert(blkNode->gtOper == GT_STORE_DYN_BLK);
-                blkNode->gtLsraInfo.setSrcCount(3);
-                GenTree* sizeNode = blkNode->AsDynBlk()->gtDynamicSize;
-                sizeNode->gtLsraInfo.setSrcCandidates(l, RBM_ARG_2);
-            }
         }
     }
     else
@@ -1373,18 +199,7 @@ void Lowering::TreeNodeInfoInitBlockStore(GenTreeBlk* blkNode)
             assert(objNode->HasGCPtr());
 #endif
 
-            // We don't need to materialize the struct size but we still need
-            // a temporary register to perform the sequence of loads and stores.
-            blkNode->gtLsraInfo.internalIntCount = 1;
-
-            dstAddr->gtLsraInfo.setSrcCandidates(l, RBM_WRITE_BARRIER_DST_BYREF);
-            // If we have a source address we want it in REG_WRITE_BARRIER_SRC_BYREF.
-            // Otherwise, if it is a local, codegen will put its address in REG_WRITE_BARRIER_SRC_BYREF,
-            // which is killed by a StoreObj (and thus needn't be reserved).
-            if (srcAddrOrFill != nullptr)
-            {
-                srcAddrOrFill->gtLsraInfo.setSrcCandidates(l, RBM_WRITE_BARRIER_SRC_BYREF);
-            }
+            blkNode->gtBlkOpKind = GenTreeBlk::BlkOpKindUnroll;
         }
         else
         {
@@ -1395,41 +210,12 @@ void Lowering::TreeNodeInfoInitBlockStore(GenTreeBlk* blkNode)
 #if 0
             // In case of a CpBlk with a constant size and less than CPBLK_UNROLL_LIMIT size
             // we should unroll the loop to improve CQ.
+            // For reference see the code in lowerxarch.cpp.
 
             // TODO-ARM64-CQ: cpblk loop unrolling is currently not implemented.
 
             if ((size != 0) && (size <= INITBLK_UNROLL_LIMIT))
             {
-                // If we have a buffer between XMM_REGSIZE_BYTES and CPBLK_UNROLL_LIMIT bytes, we'll use SSE2. 
-                // Structs and buffer with sizes <= CPBLK_UNROLL_LIMIT bytes are occurring in more than 95% of
-                // our framework assemblies, so this is the main code generation scheme we'll use.
-                if ((size & (XMM_REGSIZE_BYTES - 1)) != 0)
-                {
-                    info->internalIntCount++;
-                    info->addInternalCandidates(l, l->allRegs(TYP_INT));
-                }
-
-                if (size >= XMM_REGSIZE_BYTES)
-                {
-                    // If we have a buffer larger than XMM_REGSIZE_BYTES, 
-                    // reserve an XMM register to use it for a 
-                    // series of 16-byte loads and stores.
-                    blkNode->gtLsraInfo.internalFloatCount = 1;
-                    blkNode->gtLsraInfo.addInternalCandidates(l, l->internalFloatRegCandidates());
-                }
-
-                // If src or dst are on stack, we don't have to generate the address into a register
-                // because it's just some constant+SP
-                if (srcAddr != nullptr && srcAddrOrFill->OperIsLocalAddr())
-                {
-                    MakeSrcContained(blkNode, srcAddrOrFill);
-                }
-
-                if (dstAddr->OperIsLocalAddr())
-                {
-                    MakeSrcContained(blkNode, dstAddr);
-                }
-
                 blkNode->gtBlkOpKind = GenTreeBlk::BlkOpKindUnroll;
             }
             else
@@ -1438,444 +224,10 @@ void Lowering::TreeNodeInfoInitBlockStore(GenTreeBlk* blkNode)
                 // In case we have a constant integer this means we went beyond
                 // CPBLK_UNROLL_LIMIT bytes of size, still we should never have the case of
                 // any GC-Pointers in the src struct.
-
-                dstAddr->gtLsraInfo.setSrcCandidates(l, RBM_ARG_0);
-                // The srcAddr goes in arg1.
-                if (srcAddrOrFill != nullptr)
-                {
-                    srcAddrOrFill->gtLsraInfo.setSrcCandidates(l, RBM_ARG_1);
-                }
-                if (size != 0)
-                {
-                    // Reserve a temp register for the block size argument.
-                    internalIntCandidates |= RBM_ARG_2;
-                    internalIntCount++;
-                }
-                else
-                {
-                    // The block size argument is a third argument to GT_STORE_DYN_BLK
-                    noway_assert(blkNode->gtOper == GT_STORE_DYN_BLK);
-                    blkNode->gtLsraInfo.setSrcCount(3);
-                    GenTree* blockSize = blkNode->AsDynBlk()->gtDynamicSize;
-                    blockSize->gtLsraInfo.setSrcCandidates(l, RBM_ARG_2);
-                }
                 blkNode->gtBlkOpKind = GenTreeBlk::BlkOpKindHelper;
             }
-            if (internalIntCount != 0)
-            {
-                blkNode->gtLsraInfo.internalIntCount = internalIntCount;
-                blkNode->gtLsraInfo.setInternalCandidates(l, internalIntCandidates);
-            }
-        }
-    }
-}
-
-#ifdef FEATURE_SIMD
-//------------------------------------------------------------------------
-// TreeNodeInfoInitSIMD: Set the NodeInfo for a GT_SIMD tree.
-//
-// Arguments:
-//    tree       - The GT_SIMD node of interest
-//
-// Return Value:
-//    None.
-
-void Lowering::TreeNodeInfoInitSIMD(GenTree* tree)
-{
-    NYI("TreeNodeInfoInitSIMD");
-    GenTreeSIMD*  simdTree = tree->AsSIMD();
-    TreeNodeInfo* info     = &(tree->gtLsraInfo);
-    LinearScan*   lsra     = m_lsra;
-    info->dstCount         = 1;
-    switch (simdTree->gtSIMDIntrinsicID)
-    {
-        case SIMDIntrinsicInit:
-        {
-            // This sets all fields of a SIMD struct to the given value.
-            // Mark op1 as contained if it is either zero or int constant of all 1's.
-            info->srcCount = 1;
-            GenTree* op1   = tree->gtOp.gtOp1;
-            if (op1->IsIntegralConst(0) || (simdTree->gtSIMDBaseType == TYP_INT && op1->IsCnsIntOrI() &&
-                                            op1->AsIntConCommon()->IconValue() == 0xffffffff) ||
-                (simdTree->gtSIMDBaseType == TYP_LONG && op1->IsCnsIntOrI() &&
-                 op1->AsIntConCommon()->IconValue() == 0xffffffffffffffffLL))
-            {
-                MakeSrcContained(tree, tree->gtOp.gtOp1);
-                info->srcCount = 0;
-            }
-        }
-        break;
-
-        case SIMDIntrinsicInitN:
-            info->srcCount = (int)(simdTree->gtSIMDSize / genTypeSize(simdTree->gtSIMDBaseType));
-            // Need an internal register to stitch together all the values into a single vector in an XMM reg.
-            info->internalFloatCount = 1;
-            info->setInternalCandidates(lsra, lsra->allSIMDRegs());
-            break;
-
-        case SIMDIntrinsicInitArray:
-            // We have an array and an index, which may be contained.
-            info->srcCount = 2;
-            CheckImmedAndMakeContained(tree, tree->gtGetOp2());
-            break;
-
-        case SIMDIntrinsicDiv:
-            // SSE2 has no instruction support for division on integer vectors
-            noway_assert(varTypeIsFloating(simdTree->gtSIMDBaseType));
-            info->srcCount = 2;
-            break;
-
-        case SIMDIntrinsicAbs:
-            // This gets implemented as bitwise-And operation with a mask
-            // and hence should never see it here.
-            unreached();
-            break;
-
-        case SIMDIntrinsicSqrt:
-            // SSE2 has no instruction support for sqrt on integer vectors.
-            noway_assert(varTypeIsFloating(simdTree->gtSIMDBaseType));
-            info->srcCount = 1;
-            break;
-
-        case SIMDIntrinsicAdd:
-        case SIMDIntrinsicSub:
-        case SIMDIntrinsicMul:
-        case SIMDIntrinsicBitwiseAnd:
-        case SIMDIntrinsicBitwiseAndNot:
-        case SIMDIntrinsicBitwiseOr:
-        case SIMDIntrinsicBitwiseXor:
-        case SIMDIntrinsicMin:
-        case SIMDIntrinsicMax:
-            info->srcCount = 2;
-
-            // SSE2 32-bit integer multiplication requires two temp regs
-            if (simdTree->gtSIMDIntrinsicID == SIMDIntrinsicMul && simdTree->gtSIMDBaseType == TYP_INT)
-            {
-                info->internalFloatCount = 2;
-                info->setInternalCandidates(lsra, lsra->allSIMDRegs());
-            }
-            break;
-
-        case SIMDIntrinsicEqual:
-            info->srcCount = 2;
-            break;
-
-        // SSE2 doesn't support < and <= directly on int vectors.
-        // Instead we need to use > and >= with swapped operands.
-        case SIMDIntrinsicLessThan:
-        case SIMDIntrinsicLessThanOrEqual:
-            info->srcCount = 2;
-            noway_assert(!varTypeIsIntegral(simdTree->gtSIMDBaseType));
-            break;
-
-        // SIMDIntrinsicEqual is supported only on non-floating point base type vectors.
-        // SSE2 cmpps/pd doesn't support > and >=  directly on float/double vectors.
-        // Instead we need to use <  and <= with swapped operands.
-        case SIMDIntrinsicGreaterThan:
-            noway_assert(!varTypeIsFloating(simdTree->gtSIMDBaseType));
-            info->srcCount = 2;
-            break;
-
-        case SIMDIntrinsicGreaterThanOrEqual:
-            noway_assert(!varTypeIsFloating(simdTree->gtSIMDBaseType));
-            info->srcCount = 2;
-
-            // a >= b = (a==b) | (a>b)
-            // To hold intermediate result of a==b and a>b we need two distinct
-            // registers.  We can use targetReg and one internal reg provided
-            // they are distinct which is not guaranteed. Therefore, we request
-            // two internal registers so that one of the internal registers has
-            // to be different from targetReg.
-            info->internalFloatCount = 2;
-            info->setInternalCandidates(lsra, lsra->allSIMDRegs());
-            break;
-
-        case SIMDIntrinsicOpEquality:
-        case SIMDIntrinsicOpInEquality:
-            // Need two SIMD registers as scratch.
-            // See genSIMDIntrinsicRelOp() for details on code sequence generate and
-            // the need for two scratch registers.
-            info->srcCount           = 2;
-            info->internalFloatCount = 2;
-            info->setInternalCandidates(lsra, lsra->allSIMDRegs());
-            break;
-
-        case SIMDIntrinsicDotProduct:
-            // Also need an internal register as scratch. Further we need that targetReg and internal reg
-            // are two distinct regs.  It is achieved by requesting two internal registers and one of them
-            // has to be different from targetReg.
-            //
-            // See genSIMDIntrinsicDotProduct() for details on code sequence generated and
-            // the need for scratch registers.
-            info->srcCount           = 2;
-            info->internalFloatCount = 2;
-            info->setInternalCandidates(lsra, lsra->allSIMDRegs());
-            break;
-
-        case SIMDIntrinsicGetItem:
-            // This implements get_Item method. The sources are:
-            //  - the source SIMD struct
-            //  - index (which element to get)
-            // The result is baseType of SIMD struct.
-            info->srcCount = 2;
-
-            op2 = tree->gtGetOp2()
-                  // If the index is a constant, mark it as contained.
-                  if (CheckImmedAndMakeContained(tree, op2))
-            {
-                info->srcCount = 1;
-            }
-
-            // If the index is not a constant, we will use the SIMD temp location to store the vector.
-            // Otherwise, if the baseType is floating point, the targetReg will be a xmm reg and we
-            // can use that in the process of extracting the element.
-            // In all other cases with constant index, we need a temp xmm register to extract the
-            // element if index is other than zero.
-            if (!op2->IsCnsIntOrI())
-            {
-                (void)comp->getSIMDInitTempVarNum();
-            }
-            else if (!varTypeIsFloating(simdTree->gtSIMDBaseType) && !op2->IsIntegralConst(0))
-            {
-                info->internalFloatCount = 1;
-                info->setInternalCandidates(lsra, lsra->allSIMDRegs());
-            }
-            break;
-
-        case SIMDIntrinsicCast:
-            info->srcCount = 1;
-            break;
-
-        // These should have been transformed in terms of other intrinsics
-        case SIMDIntrinsicOpEquality:
-        case SIMDIntrinsicOpInEquality:
-            assert("OpEquality/OpInEquality intrinsics should not be seen during Lowering.");
-            unreached();
-
-        case SIMDIntrinsicGetX:
-        case SIMDIntrinsicGetY:
-        case SIMDIntrinsicGetZ:
-        case SIMDIntrinsicGetW:
-        case SIMDIntrinsicGetOne:
-        case SIMDIntrinsicGetZero:
-        case SIMDIntrinsicGetLength:
-        case SIMDIntrinsicGetAllOnes:
-            assert(!"Get intrinsics should not be seen during Lowering.");
-            unreached();
-
-        default:
-            noway_assert(!"Unimplemented SIMD node type.");
-            unreached();
-    }
-}
-#endif // FEATURE_SIMD
-
-void Lowering::LowerGCWriteBarrier(GenTree* tree)
-{
-    GenTreePtr dst  = tree;
-    GenTreePtr addr = tree->gtOp.gtOp1;
-    GenTreePtr src  = tree->gtOp.gtOp2;
-
-    if (addr->OperGet() == GT_LEA)
-    {
-        // In the case where we are doing a helper assignment, if the dst
-        // is an indir through an lea, we need to actually instantiate the
-        // lea in a register
-        GenTreeAddrMode* lea = addr->AsAddrMode();
-
-        short leaSrcCount = 0;
-        if (lea->Base() != nullptr)
-        {
-            leaSrcCount++;
-        }
-        if (lea->Index() != nullptr)
-        {
-            leaSrcCount++;
-        }
-        lea->gtLsraInfo.srcCount = leaSrcCount;
-        lea->gtLsraInfo.dstCount = 1;
-    }
-
-#if NOGC_WRITE_BARRIERS
-    // For the NOGC JIT Helper calls
-    //
-    // the 'addr' goes into x14 (REG_WRITE_BARRIER_DST_BYREF)
-    // the 'src'  goes into x15 (REG_WRITE_BARRIER)
-    //
-    addr->gtLsraInfo.setSrcCandidates(m_lsra, RBM_WRITE_BARRIER_DST_BYREF);
-    src->gtLsraInfo.setSrcCandidates(m_lsra, RBM_WRITE_BARRIER);
-#else
-    // For the standard JIT Helper calls
-    // op1 goes into REG_ARG_0 and
-    // op2 goes into REG_ARG_1
-    //
-    addr->gtLsraInfo.setSrcCandidates(m_lsra, RBM_ARG_0);
-    src->gtLsraInfo.setSrcCandidates(m_lsra, RBM_ARG_1);
-#endif // NOGC_WRITE_BARRIERS
-
-    // Both src and dst must reside in a register, which they should since we haven't set
-    // either of them as contained.
-    assert(addr->gtLsraInfo.dstCount == 1);
-    assert(src->gtLsraInfo.dstCount == 1);
-}
-
-//-----------------------------------------------------------------------------------------
-// Specify register requirements for address expression of an indirection operation.
-//
-// Arguments:
-//    indirTree    -   GT_IND, GT_STOREIND, block node or GT_NULLCHECK gentree node
-//
-void Lowering::SetIndirAddrOpCounts(GenTreePtr indirTree)
-{
-    assert(indirTree->OperIsIndir());
-    // If this is the rhs of a block copy (i.e. non-enregisterable struct),
-    // it has no register requirements.
-    if (indirTree->TypeGet() == TYP_STRUCT)
-    {
-        return;
-    }
-
-    GenTreePtr    addr = indirTree->gtGetOp1();
-    TreeNodeInfo* info = &(indirTree->gtLsraInfo);
-
-    GenTreePtr base  = nullptr;
-    GenTreePtr index = nullptr;
-    unsigned   cns   = 0;
-    unsigned   mul;
-    bool       rev;
-    bool       modifiedSources = false;
-
-    if ((addr->OperGet() == GT_LEA) && IsSafeToContainMem(indirTree, addr))
-    {
-        GenTreeAddrMode* lea = addr->AsAddrMode();
-        base                 = lea->Base();
-        index                = lea->Index();
-        cns                  = lea->gtOffset;
-
-        m_lsra->clearOperandCounts(addr);
-        // The srcCount is decremented because addr is now "contained",
-        // then we account for the base and index below, if they are non-null.
-        info->srcCount--;
-    }
-    else if (comp->codeGen->genCreateAddrMode(addr, -1, true, 0, &rev, &base, &index, &mul, &cns, true /*nogen*/) &&
-             !(modifiedSources = AreSourcesPossiblyModifiedLocals(indirTree, base, index)))
-    {
-        // An addressing mode will be constructed that may cause some
-        // nodes to not need a register, and cause others' lifetimes to be extended
-        // to the GT_IND or even its parent if it's an assignment
-
-        assert(base != addr);
-        m_lsra->clearOperandCounts(addr);
-
-        GenTreePtr arrLength = nullptr;
-
-        // Traverse the computation below GT_IND to find the operands
-        // for the addressing mode, marking the various constants and
-        // intermediate results as not consuming/producing.
-        // If the traversal were more complex, we might consider using
-        // a traversal function, but the addressing mode is only made
-        // up of simple arithmetic operators, and the code generator
-        // only traverses one leg of each node.
-
-        bool       foundBase  = (base == nullptr);
-        bool       foundIndex = (index == nullptr);
-        GenTreePtr nextChild  = nullptr;
-        for (GenTreePtr child = addr; child != nullptr && !child->OperIsLeaf(); child = nextChild)
-        {
-            nextChild      = nullptr;
-            GenTreePtr op1 = child->gtOp.gtOp1;
-            GenTreePtr op2 = (child->OperIsBinary()) ? child->gtOp.gtOp2 : nullptr;
-
-            if (op1 == base)
-            {
-                foundBase = true;
-            }
-            else if (op1 == index)
-            {
-                foundIndex = true;
-            }
-            else
-            {
-                m_lsra->clearOperandCounts(op1);
-                if (!op1->OperIsLeaf())
-                {
-                    nextChild = op1;
-                }
-            }
-
-            if (op2 != nullptr)
-            {
-                if (op2 == base)
-                {
-                    foundBase = true;
-                }
-                else if (op2 == index)
-                {
-                    foundIndex = true;
-                }
-                else
-                {
-                    m_lsra->clearOperandCounts(op2);
-                    if (!op2->OperIsLeaf())
-                    {
-                        assert(nextChild == nullptr);
-                        nextChild = op2;
-                    }
-                }
-            }
         }
-        assert(foundBase && foundIndex);
-        info->srcCount--; // it gets incremented below.
-    }
-    else if (addr->gtOper == GT_ARR_ELEM)
-    {
-        // The GT_ARR_ELEM consumes all the indices and produces the offset.
-        // The array object lives until the mem access.
-        // We also consume the target register to which the address is
-        // computed
-
-        info->srcCount++;
-        assert(addr->gtLsraInfo.srcCount >= 2);
-        addr->gtLsraInfo.srcCount -= 1;
     }
-    else
-    {
-        // it is nothing but a plain indir
-        info->srcCount--; // base gets added in below
-        base = addr;
-    }
-
-    if (base != nullptr)
-    {
-        info->srcCount++;
-    }
-
-    if (index != nullptr && !modifiedSources)
-    {
-        info->srcCount++;
-    }
-
-    // On ARM64 we may need a single internal register
-    // (when both conditions are true then we still only need a single internal register)
-    if ((index != nullptr) && (cns != 0))
-    {
-        // ARM64 does not support both Index and offset so we need an internal register
-        info->internalIntCount = 1;
-    }
-    else if (!emitter::emitIns_valid_imm_for_ldst_offset(cns, emitTypeSize(indirTree)))
-    {
-        // This offset can't be contained in the ldr/str instruction, so we need an internal register
-        info->internalIntCount = 1;
-    }
-}
-
-void Lowering::TreeNodeInfoInitCmp(GenTreePtr tree)
-{
-    TreeNodeInfo* info = &(tree->gtLsraInfo);
-
-    info->srcCount = 2;
-    info->dstCount = 1;
-    CheckImmedAndMakeContained(tree, tree->gtOp.gtOp2);
 }
 
 /* Lower GT_CAST(srcType, DstType) nodes.
diff --git a/src/jit/lowerxarch.cpp b/src/jit/lowerxarch.cpp
index 8a67415523..f89a3dfc7b 100644
--- a/src/jit/lowerxarch.cpp
+++ b/src/jit/lowerxarch.cpp
@@ -42,61 +42,11 @@ void Lowering::LowerRotate(GenTreePtr tree)
 //
 // Notes:
 //    This involves:
-//    - Setting the appropriate candidates for a store of a multi-reg call return value.
-//    - Requesting an internal register for SIMD12 stores.
-//    - Handling of contained immediates and widening operations of unsigneds.
+//    - Widening operations of unsigneds.
 
 void Lowering::LowerStoreLoc(GenTreeLclVarCommon* storeLoc)
 {
-    TreeNodeInfo* info = &(storeLoc->gtLsraInfo);
-
-    // Is this the case of var = call where call is returning
-    // a value in multiple return registers?
     GenTree* op1 = storeLoc->gtGetOp1();
-    if (op1->IsMultiRegCall())
-    {
-        // backend expects to see this case only for store lclvar.
-        assert(storeLoc->OperGet() == GT_STORE_LCL_VAR);
-
-        // srcCount = number of registers in which the value is returned by call
-        GenTreeCall*    call        = op1->AsCall();
-        ReturnTypeDesc* retTypeDesc = call->GetReturnTypeDesc();
-        info->srcCount              = retTypeDesc->GetReturnRegCount();
-
-        // Call node srcCandidates = Bitwise-OR(allregs(GetReturnRegType(i))) for all i=0..RetRegCount-1
-        regMaskTP srcCandidates = m_lsra->allMultiRegCallNodeRegs(call);
-        op1->gtLsraInfo.setSrcCandidates(m_lsra, srcCandidates);
-        return;
-    }
-
-#ifdef FEATURE_SIMD
-    if (varTypeIsSIMD(storeLoc))
-    {
-        if (op1->IsCnsIntOrI())
-        {
-            // InitBlk
-            MakeSrcContained(storeLoc, op1);
-        }
-        else if ((storeLoc->TypeGet() == TYP_SIMD12) && (storeLoc->OperGet() == GT_STORE_LCL_FLD))
-        {
-            // Need an additional register to extract upper 4 bytes of Vector3.
-            info->internalFloatCount = 1;
-            info->setInternalCandidates(m_lsra, m_lsra->allSIMDRegs());
-
-            // In this case don't mark the operand as contained as we want it to
-            // be evaluated into an xmm register
-        }
-        return;
-    }
-#endif // FEATURE_SIMD
-
-    // If the source is a containable immediate, make it contained, unless it is
-    // an int-size or larger store of zero to memory, because we can generate smaller code
-    // by zeroing a register and then storing it.
-    if (IsContainableImmed(storeLoc, op1) && (!op1->IsIntegralConst(0) || varTypeIsSmall(storeLoc)))
-    {
-        MakeSrcContained(storeLoc, op1);
-    }
 
     // Try to widen the ops if they are going into a local var.
     if ((storeLoc->gtOper == GT_STORE_LCL_VAR) && (storeLoc->gtOp1->gtOper == GT_CNS_INT))
@@ -148,1503 +98,8 @@ void Lowering::LowerStoreLoc(GenTreeLclVarCommon* storeLoc)
     }
 }
 
-/**
- * Takes care of annotating the register requirements
- * for every TreeNodeInfo struct that maps to each tree node.
- * Preconditions:
- *    LSRA Has been initialized and there is a TreeNodeInfo node
- *    already allocated and initialized for every tree in the IR.
- * Postconditions:
- *    Every TreeNodeInfo instance has the right annotations on register
- *    requirements needed by LSRA to build the Interval Table (source,
- *    destination and internal [temp] register counts).
- *    This code is refactored originally from LSRA.
- */
-void Lowering::TreeNodeInfoInit(GenTree* tree)
-{
-    LinearScan* l        = m_lsra;
-    Compiler*   compiler = comp;
-
-    TreeNodeInfo* info = &(tree->gtLsraInfo);
-    // floating type generates AVX instruction (vmovss etc.), set the flag
-    SetContainsAVXFlags(varTypeIsFloating(tree->TypeGet()));
-    switch (tree->OperGet())
-    {
-        GenTree* op1;
-        GenTree* op2;
-
-        default:
-            TreeNodeInfoInitSimple(tree);
-            break;
-
-        case GT_LCL_FLD:
-        case GT_LCL_VAR:
-            info->srcCount = 0;
-            info->dstCount = 1;
-
-#ifdef FEATURE_SIMD
-            // Need an additional register to read upper 4 bytes of Vector3.
-            if (tree->TypeGet() == TYP_SIMD12)
-            {
-                // We need an internal register different from targetReg in which 'tree' produces its result
-                // because both targetReg and internal reg will be in use at the same time.
-                info->internalFloatCount     = 1;
-                info->isInternalRegDelayFree = true;
-                info->setInternalCandidates(m_lsra, m_lsra->allSIMDRegs());
-            }
-#endif
-            break;
-
-        case GT_STORE_LCL_FLD:
-        case GT_STORE_LCL_VAR:
-#ifdef _TARGET_X86_
-            if (tree->gtGetOp1()->OperGet() == GT_LONG)
-            {
-                info->srcCount = 2;
-            }
-            else
-#endif // _TARGET_X86_
-            {
-                info->srcCount = 1;
-            }
-            info->dstCount = 0;
-            LowerStoreLoc(tree->AsLclVarCommon());
-            break;
-
-        case GT_BOX:
-            noway_assert(!"box should not exist here");
-            // The result of 'op1' is also the final result
-            info->srcCount = 0;
-            info->dstCount = 0;
-            break;
-
-        case GT_PHYSREGDST:
-            info->srcCount = 1;
-            info->dstCount = 0;
-            break;
-
-        case GT_COMMA:
-        {
-            GenTreePtr firstOperand;
-            GenTreePtr secondOperand;
-            if (tree->gtFlags & GTF_REVERSE_OPS)
-            {
-                firstOperand  = tree->gtOp.gtOp2;
-                secondOperand = tree->gtOp.gtOp1;
-            }
-            else
-            {
-                firstOperand  = tree->gtOp.gtOp1;
-                secondOperand = tree->gtOp.gtOp2;
-            }
-            if (firstOperand->TypeGet() != TYP_VOID)
-            {
-                firstOperand->gtLsraInfo.isLocalDefUse = true;
-                firstOperand->gtLsraInfo.dstCount      = 0;
-            }
-            if (tree->TypeGet() == TYP_VOID && secondOperand->TypeGet() != TYP_VOID)
-            {
-                secondOperand->gtLsraInfo.isLocalDefUse = true;
-                secondOperand->gtLsraInfo.dstCount      = 0;
-            }
-        }
-            info->srcCount = 0;
-            info->dstCount = 0;
-            break;
-
-        case GT_LIST:
-        case GT_FIELD_LIST:
-        case GT_ARGPLACE:
-        case GT_NO_OP:
-        case GT_START_NONGC:
-        case GT_PROF_HOOK:
-            info->srcCount = 0;
-            info->dstCount = 0;
-            break;
-
-        case GT_CNS_DBL:
-            info->srcCount = 0;
-            info->dstCount = 1;
-            break;
-
-#if !defined(_TARGET_64BIT_)
-
-        case GT_LONG:
-            if ((tree->gtLIRFlags & LIR::Flags::IsUnusedValue) != 0)
-            {
-                // An unused GT_LONG node needs to consume its sources.
-                info->srcCount = 2;
-            }
-            else
-            {
-                // Passthrough
-                info->srcCount = 0;
-            }
-
-            info->dstCount = 0;
-            break;
-
-#endif // !defined(_TARGET_64BIT_)
-
-        case GT_QMARK:
-        case GT_COLON:
-            info->srcCount = 0;
-            info->dstCount = 0;
-            unreached();
-            break;
-
-        case GT_RETURN:
-            TreeNodeInfoInitReturn(tree);
-            break;
-
-        case GT_RETFILT:
-            if (tree->TypeGet() == TYP_VOID)
-            {
-                info->srcCount = 0;
-                info->dstCount = 0;
-            }
-            else
-            {
-                assert(tree->TypeGet() == TYP_INT);
-
-                info->srcCount = 1;
-                info->dstCount = 0;
-
-                info->setSrcCandidates(l, RBM_INTRET);
-                tree->gtOp.gtOp1->gtLsraInfo.setSrcCandidates(l, RBM_INTRET);
-            }
-            break;
-
-        // A GT_NOP is either a passthrough (if it is void, or if it has
-        // a child), but must be considered to produce a dummy value if it
-        // has a type but no child
-        case GT_NOP:
-            info->srcCount = 0;
-            if (tree->TypeGet() != TYP_VOID && tree->gtOp.gtOp1 == nullptr)
-            {
-                info->dstCount = 1;
-            }
-            else
-            {
-                info->dstCount = 0;
-            }
-            break;
-
-        case GT_JTRUE:
-        {
-            info->srcCount = 0;
-            info->dstCount = 0;
-
-            GenTree* cmp = tree->gtGetOp1();
-            l->clearDstCount(cmp);
-
-#ifdef FEATURE_SIMD
-            // Say we have the following IR
-            //   simdCompareResult = GT_SIMD((In)Equality, v1, v2)
-            //   integerCompareResult = GT_EQ/NE(simdCompareResult, true/false)
-            //   GT_JTRUE(integerCompareResult)
-            //
-            // In this case we don't need to generate code for GT_EQ_/NE, since SIMD (In)Equality
-            // intrinsic would set or clear Zero flag.
-
-            genTreeOps cmpOper = cmp->OperGet();
-            if (cmpOper == GT_EQ || cmpOper == GT_NE)
-            {
-                GenTree* cmpOp1 = cmp->gtGetOp1();
-                GenTree* cmpOp2 = cmp->gtGetOp2();
-
-                if (cmpOp1->IsSIMDEqualityOrInequality() && (cmpOp2->IsIntegralConst(0) || cmpOp2->IsIntegralConst(1)))
-                {
-                    // clear dstCount on SIMD node to indicate that
-                    // result doesn't need to be materialized into a register.
-                    l->clearOperandCounts(cmp);
-                    l->clearDstCount(cmpOp1);
-                    l->clearOperandCounts(cmpOp2);
-
-                    // Codegen of SIMD (in)Equality uses target integer reg
-                    // only for setting flags.  Target reg is not needed on AVX
-                    // when comparing against Vector Zero.  In all other cases
-                    // we need to reserve an int type internal register, since we
-                    // have cleared dstCount.
-                    if (compiler->canUseAVX() && cmpOp1->gtGetOp2()->IsIntegralConstVector(0))
-                    {
-                        // We don't need an internal register,since we use vptest
-                        // for setting flags.
-                    }
-                    else
-                    {
-                        ++(cmpOp1->gtLsraInfo.internalIntCount);
-                        regMaskTP internalCandidates = cmpOp1->gtLsraInfo.getInternalCandidates(l);
-                        internalCandidates |= l->allRegs(TYP_INT);
-                        cmpOp1->gtLsraInfo.setInternalCandidates(l, internalCandidates);
-                    }
-
-                    // We would have to reverse compare oper in the following cases:
-                    // 1) SIMD Equality: Sets Zero flag on equal otherwise clears it.
-                    //    Therefore, if compare oper is == or != against false(0), we will
-                    //    be checking opposite of what is required.
-                    //
-                    // 2) SIMD inEquality: Clears Zero flag on true otherwise sets it.
-                    //    Therefore, if compare oper is == or != against true(1), we will
-                    //    be checking opposite of what is required.
-                    GenTreeSIMD* simdNode = cmpOp1->AsSIMD();
-                    if (simdNode->gtSIMDIntrinsicID == SIMDIntrinsicOpEquality)
-                    {
-                        if (cmpOp2->IsIntegralConst(0))
-                        {
-                            cmp->SetOper(GenTree::ReverseRelop(cmpOper));
-                        }
-                    }
-                    else
-                    {
-                        assert(simdNode->gtSIMDIntrinsicID == SIMDIntrinsicOpInEquality);
-                        if (cmpOp2->IsIntegralConst(1))
-                        {
-                            cmp->SetOper(GenTree::ReverseRelop(cmpOper));
-                        }
-                    }
-                }
-            }
-#endif // FEATURE_SIMD
-        }
-        break;
-
-        case GT_JCC:
-            info->srcCount = 0;
-            info->dstCount = 0;
-            break;
-
-        case GT_JMP:
-            info->srcCount = 0;
-            info->dstCount = 0;
-            break;
-
-        case GT_SWITCH:
-            // This should never occur since switch nodes must not be visible at this
-            // point in the JIT.
-            info->srcCount = 0;
-            info->dstCount = 0; // To avoid getting uninit errors.
-            noway_assert(!"Switch must be lowered at this point");
-            break;
-
-        case GT_JMPTABLE:
-            info->srcCount = 0;
-            info->dstCount = 1;
-            break;
-
-        case GT_SWITCH_TABLE:
-            info->srcCount         = 2;
-            info->internalIntCount = 1;
-            info->dstCount         = 0;
-            break;
-
-        case GT_ASG:
-        case GT_ASG_ADD:
-        case GT_ASG_SUB:
-            noway_assert(!"We should never hit any assignment operator in lowering");
-            info->srcCount = 0;
-            info->dstCount = 0;
-            break;
-
-#if !defined(_TARGET_64BIT_)
-        case GT_ADD_LO:
-        case GT_ADD_HI:
-        case GT_SUB_LO:
-        case GT_SUB_HI:
-#endif
-        case GT_ADD:
-        case GT_SUB:
-            // SSE2 arithmetic instructions doesn't support the form "op mem, xmm".
-            // Rather they only support "op xmm, mem/xmm" form.
-            if (varTypeIsFloating(tree->TypeGet()))
-            {
-                // overflow operations aren't supported on float/double types.
-                assert(!tree->gtOverflow());
-
-                op1 = tree->gtGetOp1();
-                op2 = tree->gtGetOp2();
-
-                // No implicit conversions at this stage as the expectation is that
-                // everything is made explicit by adding casts.
-                assert(op1->TypeGet() == op2->TypeGet());
-
-                info->srcCount = 2;
-                info->dstCount = 1;
-
-                if (op2->isMemoryOp() || op2->IsCnsNonZeroFltOrDbl())
-                {
-                    MakeSrcContained(tree, op2);
-                }
-                else if (tree->OperIsCommutative() &&
-                         (op1->IsCnsNonZeroFltOrDbl() || (op1->isMemoryOp() && IsSafeToContainMem(tree, op1))))
-                {
-                    // Though we have GT_ADD(op1=memOp, op2=non-memOp, we try to reorder the operands
-                    // as long as it is safe so that the following efficient code sequence is generated:
-                    //      addss/sd targetReg, memOp    (if op1Reg == targetReg) OR
-                    //      movaps targetReg, op2Reg; addss/sd targetReg, [memOp]
-                    //
-                    // Instead of
-                    //      movss op1Reg, [memOp]; addss/sd targetReg, Op2Reg  (if op1Reg == targetReg) OR
-                    //      movss op1Reg, [memOp]; movaps targetReg, op1Reg, addss/sd targetReg, Op2Reg
-                    MakeSrcContained(tree, op1);
-                }
-                else
-                {
-                    // If there are no containable operands, we can make an operand reg optional.
-                    SetRegOptionalForBinOp(tree);
-                }
-                break;
-            }
-
-            __fallthrough;
-
-        case GT_AND:
-        case GT_OR:
-        case GT_XOR:
-            TreeNodeInfoInitLogicalOp(tree);
-            break;
-
-        case GT_RETURNTRAP:
-            // this just turns into a compare of its child with an int
-            // + a conditional call
-            info->srcCount = 1;
-            info->dstCount = 0;
-            if (tree->gtOp.gtOp1->isIndir())
-            {
-                MakeSrcContained(tree, tree->gtOp.gtOp1);
-            }
-            info->internalIntCount = 1;
-            info->setInternalCandidates(l, l->allRegs(TYP_INT));
-            break;
-
-        case GT_MOD:
-        case GT_DIV:
-        case GT_UMOD:
-        case GT_UDIV:
-            TreeNodeInfoInitModDiv(tree);
-            break;
-
-        case GT_MUL:
-        case GT_MULHI:
-#if defined(_TARGET_X86_) && !defined(LEGACY_BACKEND)
-        case GT_MUL_LONG:
-#endif
-            SetMulOpCounts(tree);
-            break;
-
-        case GT_INTRINSIC:
-            TreeNodeInfoInitIntrinsic(tree);
-            break;
-
-#ifdef FEATURE_SIMD
-        case GT_SIMD:
-            TreeNodeInfoInitSIMD(tree);
-            break;
-#endif // FEATURE_SIMD
-
-        case GT_CAST:
-            TreeNodeInfoInitCast(tree);
-            break;
-
-        case GT_NEG:
-            info->srcCount = 1;
-            info->dstCount = 1;
-
-            // TODO-XArch-CQ:
-            // SSE instruction set doesn't have an instruction to negate a number.
-            // The recommended way is to xor the float/double number with a bitmask.
-            // The only way to xor is using xorps or xorpd both of which operate on
-            // 128-bit operands.  To hold the bit-mask we would need another xmm
-            // register or a 16-byte aligned 128-bit data constant. Right now emitter
-            // lacks the support for emitting such constants or instruction with mem
-            // addressing mode referring to a 128-bit operand. For now we use an
-            // internal xmm register to load 32/64-bit bitmask from data section.
-            // Note that by trading additional data section memory (128-bit) we can
-            // save on the need for an internal register and also a memory-to-reg
-            // move.
-            //
-            // Note: another option to avoid internal register requirement is by
-            // lowering as GT_SUB(0, src).  This will generate code different from
-            // Jit64 and could possibly result in compat issues (?).
-            if (varTypeIsFloating(tree))
-            {
-                info->internalFloatCount = 1;
-                info->setInternalCandidates(l, l->internalFloatRegCandidates());
-            }
-            else
-            {
-                // Codegen of this tree node sets ZF and SF flags.
-                tree->gtFlags |= GTF_ZSF_SET;
-            }
-            break;
-
-        case GT_NOT:
-            info->srcCount = 1;
-            info->dstCount = 1;
-            break;
-
-        case GT_LSH:
-        case GT_RSH:
-        case GT_RSZ:
-        case GT_ROL:
-        case GT_ROR:
-#ifdef _TARGET_X86_
-        case GT_LSH_HI:
-        case GT_RSH_LO:
-#endif
-            TreeNodeInfoInitShiftRotate(tree);
-            break;
-
-        case GT_EQ:
-        case GT_NE:
-        case GT_LT:
-        case GT_LE:
-        case GT_GE:
-        case GT_GT:
-        case GT_TEST_EQ:
-        case GT_TEST_NE:
-            TreeNodeInfoInitCmp(tree);
-            break;
-
-        case GT_CKFINITE:
-            info->srcCount         = 1;
-            info->dstCount         = 1;
-            info->internalIntCount = 1;
-            break;
-
-        case GT_CMPXCHG:
-            info->srcCount = 3;
-            info->dstCount = 1;
-
-            // comparand is preferenced to RAX.
-            // Remaining two operands can be in any reg other than RAX.
-            tree->gtCmpXchg.gtOpComparand->gtLsraInfo.setSrcCandidates(l, RBM_RAX);
-            tree->gtCmpXchg.gtOpLocation->gtLsraInfo.setSrcCandidates(l, l->allRegs(TYP_INT) & ~RBM_RAX);
-            tree->gtCmpXchg.gtOpValue->gtLsraInfo.setSrcCandidates(l, l->allRegs(TYP_INT) & ~RBM_RAX);
-            tree->gtLsraInfo.setDstCandidates(l, RBM_RAX);
-            break;
-
-        case GT_LOCKADD:
-            info->srcCount = 2;
-            info->dstCount = (tree->TypeGet() == TYP_VOID) ? 0 : 1;
-
-            CheckImmedAndMakeContained(tree, tree->gtOp.gtOp2);
-            break;
-
-        case GT_CALL:
-            TreeNodeInfoInitCall(tree->AsCall());
-            break;
-
-        case GT_ADDR:
-        {
-            // For a GT_ADDR, the child node should not be evaluated into a register
-            GenTreePtr child = tree->gtOp.gtOp1;
-            assert(!l->isCandidateLocalRef(child));
-            l->clearDstCount(child);
-            info->srcCount = 0;
-            info->dstCount = 1;
-        }
-        break;
-
-#if !defined(FEATURE_PUT_STRUCT_ARG_STK)
-        case GT_OBJ:
-#endif
-        case GT_BLK:
-        case GT_DYN_BLK:
-            // These should all be eliminated prior to Lowering.
-            assert(!"Non-store block node in Lowering");
-            info->srcCount = 0;
-            info->dstCount = 0;
-            break;
-
-#ifdef FEATURE_PUT_STRUCT_ARG_STK
-        case GT_PUTARG_STK:
-            TreeNodeInfoInitPutArgStk(tree->AsPutArgStk());
-            break;
-#endif // FEATURE_PUT_STRUCT_ARG_STK
-
-        case GT_STORE_BLK:
-        case GT_STORE_OBJ:
-        case GT_STORE_DYN_BLK:
-            TreeNodeInfoInitBlockStore(tree->AsBlk());
-            break;
-
-        case GT_INIT_VAL:
-            // Always a passthrough of its child's value.
-            info->srcCount = 0;
-            info->dstCount = 0;
-            break;
-
-        case GT_LCLHEAP:
-            TreeNodeInfoInitLclHeap(tree);
-            break;
-
-        case GT_ARR_BOUNDS_CHECK:
-#ifdef FEATURE_SIMD
-        case GT_SIMD_CHK:
-#endif // FEATURE_SIMD
-        {
-            GenTreeBoundsChk* node = tree->AsBoundsChk();
-            // Consumes arrLen & index - has no result
-            info->srcCount = 2;
-            info->dstCount = 0;
-
-            GenTreePtr other;
-            if (CheckImmedAndMakeContained(tree, node->gtIndex))
-            {
-                other = node->gtArrLen;
-            }
-            else if (CheckImmedAndMakeContained(tree, node->gtArrLen))
-            {
-                other = node->gtIndex;
-            }
-            else if (node->gtIndex->isMemoryOp())
-            {
-                other = node->gtIndex;
-            }
-            else
-            {
-                other = node->gtArrLen;
-            }
-
-            if (node->gtIndex->TypeGet() == node->gtArrLen->TypeGet())
-            {
-                if (other->isMemoryOp())
-                {
-                    MakeSrcContained(tree, other);
-                }
-                else
-                {
-                    // We can mark 'other' as reg optional, since it is not contained.
-                    SetRegOptional(other);
-                }
-            }
-        }
-        break;
-
-        case GT_ARR_ELEM:
-            // These must have been lowered to GT_ARR_INDEX
-            noway_assert(!"We should never see a GT_ARR_ELEM in lowering");
-            info->srcCount = 0;
-            info->dstCount = 0;
-            break;
-
-        case GT_ARR_INDEX:
-            info->srcCount = 2;
-            info->dstCount = 1;
-            // For GT_ARR_INDEX, the lifetime of the arrObj must be extended because it is actually used multiple
-            // times while the result is being computed.
-            tree->AsArrIndex()->ArrObj()->gtLsraInfo.isDelayFree = true;
-            info->hasDelayFreeSrc                                = true;
-            break;
-
-        case GT_ARR_OFFSET:
-            // This consumes the offset, if any, the arrObj and the effective index,
-            // and produces the flattened offset for this dimension.
-            info->srcCount = 3;
-            info->dstCount = 1;
-
-            // we don't want to generate code for this
-            if (tree->gtArrOffs.gtOffset->IsIntegralConst(0))
-            {
-                MakeSrcContained(tree, tree->gtArrOffs.gtOffset);
-            }
-            else
-            {
-                // Here we simply need an internal register, which must be different
-                // from any of the operand's registers, but may be the same as targetReg.
-                info->internalIntCount = 1;
-            }
-            break;
-
-        case GT_LEA:
-            // The LEA usually passes its operands through to the GT_IND, in which case we'll
-            // clear the info->srcCount and info->dstCount later, but we may be instantiating an address,
-            // so we set them here.
-            info->srcCount = 0;
-            if (tree->AsAddrMode()->HasBase())
-            {
-                info->srcCount++;
-            }
-            if (tree->AsAddrMode()->HasIndex())
-            {
-                info->srcCount++;
-            }
-            info->dstCount = 1;
-            break;
-
-        case GT_STOREIND:
-        {
-            info->srcCount = 2;
-            info->dstCount = 0;
-            GenTree* src   = tree->gtOp.gtOp2;
-
-            if (compiler->codeGen->gcInfo.gcIsWriteBarrierAsgNode(tree))
-            {
-                LowerGCWriteBarrier(tree);
-                break;
-            }
-
-            // If the source is a containable immediate, make it contained, unless it is
-            // an int-size or larger store of zero to memory, because we can generate smaller code
-            // by zeroing a register and then storing it.
-            if (IsContainableImmed(tree, src) &&
-                (!src->IsIntegralConst(0) || varTypeIsSmall(tree) || tree->gtGetOp1()->OperGet() == GT_CLS_VAR_ADDR))
-            {
-                MakeSrcContained(tree, src);
-            }
-            else if (!varTypeIsFloating(tree))
-            {
-                // Perform recognition of trees with the following structure:
-                //        StoreInd(addr, BinOp(expr, GT_IND(addr)))
-                // to be able to fold this into an instruction of the form
-                //        BINOP [addr], register
-                // where register is the actual place where 'expr' is computed.
-                //
-                // SSE2 doesn't support RMW form of instructions.
-                if (SetStoreIndOpCountsIfRMWMemOp(tree))
-                {
-                    break;
-                }
-            }
-
-            SetIndirAddrOpCounts(tree);
-        }
-        break;
-
-        case GT_NULLCHECK:
-            info->dstCount      = 0;
-            info->srcCount      = 1;
-            info->isLocalDefUse = true;
-            break;
-
-        case GT_IND:
-            info->dstCount = 1;
-            info->srcCount = 1;
-            SetIndirAddrOpCounts(tree);
-            break;
-
-        case GT_CATCH_ARG:
-            info->srcCount = 0;
-            info->dstCount = 1;
-            info->setDstCandidates(l, RBM_EXCEPTION_OBJECT);
-            break;
-
-#if !FEATURE_EH_FUNCLETS
-        case GT_END_LFIN:
-            info->srcCount = 0;
-            info->dstCount = 0;
-            break;
-#endif
-
-        case GT_CLS_VAR:
-            // These nodes are eliminated by rationalizer.
-            JITDUMP("Unexpected node %s in Lower.\n", GenTree::NodeName(tree->OperGet()));
-            unreached();
-            break;
-    } // end switch (tree->OperGet())
-
-    // If op2 of a binary-op gets marked as contained, then binary-op srcCount will be 1.
-    // Even then we would like to set isTgtPref on Op1.
-    if (tree->OperIsBinary() && info->srcCount >= 1)
-    {
-        if (isRMWRegOper(tree))
-        {
-            GenTree* op1 = tree->gtOp.gtOp1;
-            GenTree* op2 = tree->gtOp.gtOp2;
-
-            // Commutative opers like add/mul/and/or/xor could reverse the order of
-            // operands if it is safe to do so.  In such a case we would like op2 to be
-            // target preferenced instead of op1.
-            if (tree->OperIsCommutative() && op1->gtLsraInfo.dstCount == 0 && op2 != nullptr)
-            {
-                op1 = op2;
-                op2 = tree->gtOp.gtOp1;
-            }
-
-            // If we have a read-modify-write operation, we want to preference op1 to the target.
-            // If op1 is contained, we don't want to preference it, but it won't
-            // show up as a source in that case, so it will be ignored.
-            op1->gtLsraInfo.isTgtPref = true;
-
-            // Is this a non-commutative operator, or is op2 a contained memory op?
-            // (Note that we can't call IsContained() at this point because it uses exactly the
-            // same information we're currently computing.)
-            // In either case, we need to make op2 remain live until the op is complete, by marking
-            // the source(s) associated with op2 as "delayFree".
-            // Note that if op2 of a binary RMW operator is a memory op, even if the operator
-            // is commutative, codegen cannot reverse them.
-            // TODO-XArch-CQ: This is not actually the case for all RMW binary operators, but there's
-            // more work to be done to correctly reverse the operands if they involve memory
-            // operands.  Also, we may need to handle more cases than GT_IND, especially once
-            // we've modified the register allocator to not require all nodes to be assigned
-            // a register (e.g. a spilled lclVar can often be referenced directly from memory).
-            // Note that we may have a null op2, even with 2 sources, if op1 is a base/index memory op.
-
-            GenTree* delayUseSrc = nullptr;
-            // TODO-XArch-Cleanup: We should make the indirection explicit on these nodes so that we don't have
-            // to special case them.
-            if (tree->OperGet() == GT_XADD || tree->OperGet() == GT_XCHG || tree->OperGet() == GT_LOCKADD)
-            {
-                // These tree nodes will have their op1 marked as isDelayFree=true.
-                // Hence these tree nodes should have a Def position so that op1's reg
-                // gets freed at DefLoc+1.
-                if (tree->TypeGet() == TYP_VOID)
-                {
-                    // Right now a GT_XADD node could be morphed into a
-                    // GT_LOCKADD of TYP_VOID. See gtExtractSideEffList().
-                    // Note that it is advantageous to use GT_LOCKADD
-                    // instead of of GT_XADD as the former uses lock.add,
-                    // which allows its second operand to be a contained
-                    // immediate wheres xadd instruction requires its
-                    // second operand to be in a register.
-                    assert(tree->gtLsraInfo.dstCount == 0);
-
-                    // Give it an artificial type and mark it isLocalDefUse = true.
-                    // This would result in a Def position created but not considered
-                    // consumed by its parent node.
-                    tree->gtType                   = TYP_INT;
-                    tree->gtLsraInfo.isLocalDefUse = true;
-                }
-                else
-                {
-                    assert(tree->gtLsraInfo.dstCount != 0);
-                }
-
-                delayUseSrc = op1;
-            }
-            else if ((op2 != nullptr) &&
-                     (!tree->OperIsCommutative() || (op2->isMemoryOp() && (op2->gtLsraInfo.srcCount == 0))))
-            {
-                delayUseSrc = op2;
-            }
-            if (delayUseSrc != nullptr)
-            {
-                // If delayUseSrc is an indirection and it doesn't produce a result, then we need to set "delayFree'
-                // on the base & index, if any.
-                // Otherwise, we set it on delayUseSrc itself.
-                if (delayUseSrc->isIndir() && (delayUseSrc->gtLsraInfo.dstCount == 0))
-                {
-                    GenTree* base  = delayUseSrc->AsIndir()->Base();
-                    GenTree* index = delayUseSrc->AsIndir()->Index();
-                    if (base != nullptr)
-                    {
-                        base->gtLsraInfo.isDelayFree = true;
-                    }
-                    if (index != nullptr)
-                    {
-                        index->gtLsraInfo.isDelayFree = true;
-                    }
-                }
-                else
-                {
-                    delayUseSrc->gtLsraInfo.isDelayFree = true;
-                }
-                info->hasDelayFreeSrc = true;
-            }
-        }
-    }
-
-    TreeNodeInfoInitCheckByteable(tree);
-
-    // We need to be sure that we've set info->srcCount and info->dstCount appropriately
-    assert((info->dstCount < 2) || (tree->IsMultiRegCall() && info->dstCount == MAX_RET_REG_COUNT));
-}
-
 //------------------------------------------------------------------------
-// TreeNodeInfoInitCheckByteable: Check the tree to see if "byte-able" registers are
-// required, and set the tree node info accordingly.
-//
-// Arguments:
-//    tree      - The node of interest
-//
-// Return Value:
-//    None.
-//
-void Lowering::TreeNodeInfoInitCheckByteable(GenTree* tree)
-{
-#ifdef _TARGET_X86_
-    LinearScan*   l    = m_lsra;
-    TreeNodeInfo* info = &(tree->gtLsraInfo);
-
-    // Exclude RBM_NON_BYTE_REGS from dst candidates of tree node and src candidates of operands
-    // if the tree node is a byte type.
-    //
-    // Though this looks conservative in theory, in practice we could not think of a case where
-    // the below logic leads to conservative register specification.  In future when or if we find
-    // one such case, this logic needs to be fine tuned for that case(s).
-
-    if (ExcludeNonByteableRegisters(tree))
-    {
-        regMaskTP regMask;
-        if (info->dstCount > 0)
-        {
-            regMask = info->getDstCandidates(l);
-            assert(regMask != RBM_NONE);
-            info->setDstCandidates(l, regMask & ~RBM_NON_BYTE_REGS);
-        }
-
-        if (tree->OperIsSimple() && (info->srcCount > 0))
-        {
-            // No need to set src candidates on a contained child operand.
-            GenTree* op = tree->gtOp.gtOp1;
-            assert(op != nullptr);
-            bool containedNode = (op->gtLsraInfo.srcCount == 0) && (op->gtLsraInfo.dstCount == 0);
-            if (!containedNode)
-            {
-                regMask = op->gtLsraInfo.getSrcCandidates(l);
-                assert(regMask != RBM_NONE);
-                op->gtLsraInfo.setSrcCandidates(l, regMask & ~RBM_NON_BYTE_REGS);
-            }
-
-            if (tree->OperIsBinary() && (tree->gtOp.gtOp2 != nullptr))
-            {
-                op            = tree->gtOp.gtOp2;
-                containedNode = (op->gtLsraInfo.srcCount == 0) && (op->gtLsraInfo.dstCount == 0);
-                if (!containedNode)
-                {
-                    regMask = op->gtLsraInfo.getSrcCandidates(l);
-                    assert(regMask != RBM_NONE);
-                    op->gtLsraInfo.setSrcCandidates(l, regMask & ~RBM_NON_BYTE_REGS);
-                }
-            }
-        }
-    }
-#endif //_TARGET_X86_
-}
-
-//------------------------------------------------------------------------
-// TreeNodeInfoInitSimple: Sets the srcCount and dstCount for all the trees
-// without special handling based on the tree node type.
-//
-// Arguments:
-//    tree      - The node of interest
-//
-// Return Value:
-//    None.
-//
-void Lowering::TreeNodeInfoInitSimple(GenTree* tree)
-{
-    TreeNodeInfo* info = &(tree->gtLsraInfo);
-    unsigned      kind = tree->OperKind();
-    info->dstCount     = tree->IsValue() ? 1 : 0;
-    if (kind & (GTK_CONST | GTK_LEAF))
-    {
-        info->srcCount = 0;
-    }
-    else if (kind & (GTK_SMPOP))
-    {
-        if (tree->gtGetOp2() != nullptr)
-        {
-            info->srcCount = 2;
-        }
-        else
-        {
-            info->srcCount = 1;
-        }
-    }
-    else
-    {
-        unreached();
-    }
-}
-
-//------------------------------------------------------------------------
-// TreeNodeInfoInitReturn: Set the NodeInfo for a GT_RETURN.
-//
-// Arguments:
-//    tree      - The node of interest
-//
-// Return Value:
-//    None.
-//
-void Lowering::TreeNodeInfoInitReturn(GenTree* tree)
-{
-    TreeNodeInfo* info     = &(tree->gtLsraInfo);
-    LinearScan*   l        = m_lsra;
-    Compiler*     compiler = comp;
-
-#if !defined(_TARGET_64BIT_)
-    if (tree->TypeGet() == TYP_LONG)
-    {
-        GenTree* op1 = tree->gtGetOp1();
-        noway_assert(op1->OperGet() == GT_LONG);
-        GenTree* loVal = op1->gtGetOp1();
-        GenTree* hiVal = op1->gtGetOp2();
-        info->srcCount = 2;
-        loVal->gtLsraInfo.setSrcCandidates(l, RBM_LNGRET_LO);
-        hiVal->gtLsraInfo.setSrcCandidates(l, RBM_LNGRET_HI);
-        info->dstCount = 0;
-    }
-    else
-#endif // !defined(_TARGET_64BIT_)
-    {
-        GenTree*  op1           = tree->gtGetOp1();
-        regMaskTP useCandidates = RBM_NONE;
-
-        info->srcCount = (tree->TypeGet() == TYP_VOID) ? 0 : 1;
-        info->dstCount = 0;
-
-#ifdef FEATURE_UNIX_AMD64_STRUCT_PASSING
-        if (varTypeIsStruct(tree))
-        {
-            // op1 has to be either an lclvar or a multi-reg returning call
-            if (op1->OperGet() == GT_LCL_VAR)
-            {
-                GenTreeLclVarCommon* lclVarCommon = op1->AsLclVarCommon();
-                LclVarDsc*           varDsc       = &(compiler->lvaTable[lclVarCommon->gtLclNum]);
-                assert(varDsc->lvIsMultiRegRet);
-
-                // Mark var as contained if not enregistrable.
-                if (!varTypeIsEnregisterableStruct(op1))
-                {
-                    MakeSrcContained(tree, op1);
-                }
-            }
-            else
-            {
-                noway_assert(op1->IsMultiRegCall());
-
-                ReturnTypeDesc* retTypeDesc = op1->AsCall()->GetReturnTypeDesc();
-                info->srcCount              = retTypeDesc->GetReturnRegCount();
-                useCandidates               = retTypeDesc->GetABIReturnRegs();
-            }
-        }
-        else
-#endif // FEATURE_UNIX_AMD64_STRUCT_PASSING
-        {
-            // Non-struct type return - determine useCandidates
-            switch (tree->TypeGet())
-            {
-                case TYP_VOID:
-                    useCandidates = RBM_NONE;
-                    break;
-                case TYP_FLOAT:
-                    useCandidates = RBM_FLOATRET;
-                    break;
-                case TYP_DOUBLE:
-                    useCandidates = RBM_DOUBLERET;
-                    break;
-#if defined(_TARGET_64BIT_)
-                case TYP_LONG:
-                    useCandidates = RBM_LNGRET;
-                    break;
-#endif // defined(_TARGET_64BIT_)
-                default:
-                    useCandidates = RBM_INTRET;
-                    break;
-            }
-        }
-
-        if (useCandidates != RBM_NONE)
-        {
-            op1->gtLsraInfo.setSrcCandidates(l, useCandidates);
-        }
-    }
-}
-
-//------------------------------------------------------------------------
-// TreeNodeInfoInitShiftRotate: Set the NodeInfo for a shift or rotate.
-//
-// Arguments:
-//    tree      - The node of interest
-//
-// Return Value:
-//    None.
-//
-void Lowering::TreeNodeInfoInitShiftRotate(GenTree* tree)
-{
-    TreeNodeInfo* info = &(tree->gtLsraInfo);
-    LinearScan*   l    = m_lsra;
-
-    info->srcCount = 2;
-    info->dstCount = 1;
-
-    // For shift operations, we need that the number
-    // of bits moved gets stored in CL in case
-    // the number of bits to shift is not a constant.
-    GenTreePtr shiftBy = tree->gtOp.gtOp2;
-    GenTreePtr source  = tree->gtOp.gtOp1;
-
-#ifdef _TARGET_X86_
-    // The first operand of a GT_LSH_HI and GT_RSH_LO oper is a GT_LONG so that
-    // we can have a three operand form. Increment the srcCount.
-    if (tree->OperGet() == GT_LSH_HI || tree->OperGet() == GT_RSH_LO)
-    {
-        assert(source->OperGet() == GT_LONG);
-
-        info->srcCount++;
-
-        if (tree->OperGet() == GT_LSH_HI)
-        {
-            GenTreePtr sourceLo              = source->gtOp.gtOp1;
-            sourceLo->gtLsraInfo.isDelayFree = true;
-        }
-        else
-        {
-            GenTreePtr sourceHi              = source->gtOp.gtOp2;
-            sourceHi->gtLsraInfo.isDelayFree = true;
-        }
-
-        source->gtLsraInfo.hasDelayFreeSrc = true;
-        info->hasDelayFreeSrc              = true;
-    }
-#endif
-
-    // x64 can encode 8 bits of shift and it will use 5 or 6. (the others are masked off)
-    // We will allow whatever can be encoded - hope you know what you are doing.
-    if (!IsContainableImmed(tree, shiftBy) || (shiftBy->gtIntConCommon.IconValue() > 255) ||
-        (shiftBy->gtIntConCommon.IconValue() < 0))
-    {
-        source->gtLsraInfo.setSrcCandidates(l, l->allRegs(TYP_INT) & ~RBM_RCX);
-        shiftBy->gtLsraInfo.setSrcCandidates(l, RBM_RCX);
-        info->setDstCandidates(l, l->allRegs(TYP_INT) & ~RBM_RCX);
-    }
-    else
-    {
-        MakeSrcContained(tree, shiftBy);
-
-        // Note that Rotate Left/Right instructions don't set ZF and SF flags.
-        //
-        // If the operand being shifted is 32-bits then upper three bits are masked
-        // by hardware to get actual shift count.  Similarly for 64-bit operands
-        // shift count is narrowed to [0..63].  If the resulting shift count is zero,
-        // then shift operation won't modify flags.
-        //
-        // TODO-CQ-XARCH: We can optimize generating 'test' instruction for GT_EQ/NE(shift, 0)
-        // if the shift count is known to be non-zero and in the range depending on the
-        // operand size.
-    }
-}
-
-//------------------------------------------------------------------------
-// TreeNodeInfoInitCall: Set the NodeInfo for a call.
-//
-// Arguments:
-//    call      - The call node of interest
-//
-// Return Value:
-//    None.
-//
-void Lowering::TreeNodeInfoInitCall(GenTreeCall* call)
-{
-    TreeNodeInfo*   info              = &(call->gtLsraInfo);
-    LinearScan*     l                 = m_lsra;
-    Compiler*       compiler          = comp;
-    bool            hasMultiRegRetVal = false;
-    ReturnTypeDesc* retTypeDesc       = nullptr;
-
-    info->srcCount = 0;
-    if (call->TypeGet() != TYP_VOID)
-    {
-        hasMultiRegRetVal = call->HasMultiRegRetVal();
-        if (hasMultiRegRetVal)
-        {
-            // dst count = number of registers in which the value is returned by call
-            retTypeDesc    = call->GetReturnTypeDesc();
-            info->dstCount = retTypeDesc->GetReturnRegCount();
-        }
-        else
-        {
-            info->dstCount = 1;
-        }
-    }
-    else
-    {
-        info->dstCount = 0;
-    }
-
-    GenTree* ctrlExpr = call->gtControlExpr;
-    if (call->gtCallType == CT_INDIRECT)
-    {
-        // either gtControlExpr != null or gtCallAddr != null.
-        // Both cannot be non-null at the same time.
-        assert(ctrlExpr == nullptr);
-        assert(call->gtCallAddr != nullptr);
-        ctrlExpr = call->gtCallAddr;
-
-#ifdef _TARGET_X86_
-        // Fast tail calls aren't currently supported on x86, but if they ever are, the code
-        // below that handles indirect VSD calls will need to be fixed.
-        assert(!call->IsFastTailCall() || !call->IsVirtualStub());
-#endif // _TARGET_X86_
-    }
-
-    // set reg requirements on call target represented as control sequence.
-    if (ctrlExpr != nullptr)
-    {
-        // we should never see a gtControlExpr whose type is void.
-        assert(ctrlExpr->TypeGet() != TYP_VOID);
-
-        // call can take a Rm op on x64
-        info->srcCount++;
-
-        // In case of fast tail implemented as jmp, make sure that gtControlExpr is
-        // computed into a register.
-        if (!call->IsFastTailCall())
-        {
-#ifdef _TARGET_X86_
-            // On x86, we need to generate a very specific pattern for indirect VSD calls:
-            //
-            //    3-byte nop
-            //    call dword ptr [eax]
-            //
-            // Where EAX is also used as an argument to the stub dispatch helper. Make
-            // sure that the call target address is computed into EAX in this case.
-            if (call->IsVirtualStub() && (call->gtCallType == CT_INDIRECT))
-            {
-                assert(ctrlExpr->isIndir());
-
-                ctrlExpr->gtGetOp1()->gtLsraInfo.setSrcCandidates(l, RBM_VIRTUAL_STUB_TARGET);
-                MakeSrcContained(call, ctrlExpr);
-            }
-            else
-#endif // _TARGET_X86_
-                if (ctrlExpr->isIndir())
-            {
-                MakeSrcContained(call, ctrlExpr);
-            }
-        }
-        else
-        {
-            // Fast tail call - make sure that call target is always computed in RAX
-            // so that epilog sequence can generate "jmp rax" to achieve fast tail call.
-            ctrlExpr->gtLsraInfo.setSrcCandidates(l, RBM_RAX);
-        }
-    }
-
-    // If this is a varargs call, we will clear the internal candidates in case we need
-    // to reserve some integer registers for copying float args.
-    // We have to do this because otherwise the default candidates are allRegs, and adding
-    // the individual specific registers will have no effect.
-    if (call->IsVarargs())
-    {
-        info->setInternalCandidates(l, RBM_NONE);
-    }
-
-    RegisterType registerType = call->TypeGet();
-
-    // Set destination candidates for return value of the call.
-    CLANG_FORMAT_COMMENT_ANCHOR;
-
-#ifdef _TARGET_X86_
-    if (call->IsHelperCall(compiler, CORINFO_HELP_INIT_PINVOKE_FRAME))
-    {
-        // The x86 CORINFO_HELP_INIT_PINVOKE_FRAME helper uses a custom calling convention that returns with
-        // TCB in REG_PINVOKE_TCB. AMD64/ARM64 use the standard calling convention. fgMorphCall() sets the
-        // correct argument registers.
-        info->setDstCandidates(l, RBM_PINVOKE_TCB);
-    }
-    else
-#endif // _TARGET_X86_
-        if (hasMultiRegRetVal)
-    {
-        assert(retTypeDesc != nullptr);
-        info->setDstCandidates(l, retTypeDesc->GetABIReturnRegs());
-    }
-    else if (varTypeIsFloating(registerType))
-    {
-#ifdef _TARGET_X86_
-        // The return value will be on the X87 stack, and we will need to move it.
-        info->setDstCandidates(l, l->allRegs(registerType));
-#else  // !_TARGET_X86_
-        info->setDstCandidates(l, RBM_FLOATRET);
-#endif // !_TARGET_X86_
-    }
-    else if (registerType == TYP_LONG)
-    {
-        info->setDstCandidates(l, RBM_LNGRET);
-    }
-    else
-    {
-        info->setDstCandidates(l, RBM_INTRET);
-    }
-
-    // number of args to a call =
-    // callRegArgs + (callargs - placeholders, setup, etc)
-    // there is an explicit thisPtr but it is redundant
-
-    // If there is an explicit this pointer, we don't want that node to produce anything
-    // as it is redundant
-    if (call->gtCallObjp != nullptr)
-    {
-        GenTreePtr thisPtrNode = call->gtCallObjp;
-
-        if (thisPtrNode->gtOper == GT_PUTARG_REG)
-        {
-            l->clearOperandCounts(thisPtrNode);
-            l->clearDstCount(thisPtrNode->gtOp.gtOp1);
-        }
-        else
-        {
-            l->clearDstCount(thisPtrNode);
-        }
-    }
-
-#if FEATURE_VARARG
-    bool callHasFloatRegArgs = false;
-#endif // !FEATURE_VARARG
-
-    // First, count reg args
-    for (GenTreePtr list = call->gtCallLateArgs; list; list = list->MoveNext())
-    {
-        assert(list->OperIsList());
-
-        GenTreePtr argNode = list->Current();
-
-        fgArgTabEntryPtr curArgTabEntry = compiler->gtArgEntryByNode(call, argNode);
-        assert(curArgTabEntry);
-
-        if (curArgTabEntry->regNum == REG_STK)
-        {
-            // late arg that is not passed in a register
-            DISPNODE(argNode);
-            assert(argNode->gtOper == GT_PUTARG_STK);
-            argNode->gtLsraInfo.srcCount = 1;
-            argNode->gtLsraInfo.dstCount = 0;
-
-#ifdef FEATURE_PUT_STRUCT_ARG_STK
-            // If the node is TYP_STRUCT and it is put on stack with
-            // putarg_stk operation, we consume and produce no registers.
-            // In this case the embedded Obj node should not produce
-            // registers too since it is contained.
-            // Note that if it is a SIMD type the argument will be in a register.
-            if (argNode->TypeGet() == TYP_STRUCT)
-            {
-                assert(argNode->gtOp.gtOp1 != nullptr && argNode->gtOp.gtOp1->OperGet() == GT_OBJ);
-                argNode->gtOp.gtOp1->gtLsraInfo.dstCount = 0;
-                argNode->gtLsraInfo.srcCount             = 0;
-            }
-#endif // FEATURE_PUT_STRUCT_ARG_STK
-            continue;
-        }
-
-        regNumber argReg    = REG_NA;
-        regMaskTP argMask   = RBM_NONE;
-        short     regCount  = 0;
-        bool      isOnStack = true;
-        if (curArgTabEntry->regNum != REG_STK)
-        {
-            isOnStack         = false;
-            var_types argType = argNode->TypeGet();
-
-#if FEATURE_VARARG
-            callHasFloatRegArgs |= varTypeIsFloating(argType);
-#endif // !FEATURE_VARARG
-
-            argReg   = curArgTabEntry->regNum;
-            regCount = 1;
-
-            // Default case is that we consume one source; modify this later (e.g. for
-            // promoted structs)
-            info->srcCount++;
-
-            argMask = genRegMask(argReg);
-            argNode = argNode->gtEffectiveVal();
-        }
-
-        // If the struct arg is wrapped in CPYBLK the type of the param will be TYP_VOID.
-        // Use the curArgTabEntry's isStruct to get whether the param is a struct.
-        if (varTypeIsStruct(argNode) PUT_STRUCT_ARG_STK_ONLY(|| curArgTabEntry->isStruct))
-        {
-            unsigned   originalSize = 0;
-            LclVarDsc* varDsc       = nullptr;
-            if (argNode->gtOper == GT_LCL_VAR)
-            {
-                varDsc       = compiler->lvaTable + argNode->gtLclVarCommon.gtLclNum;
-                originalSize = varDsc->lvSize();
-            }
-            else if (argNode->gtOper == GT_MKREFANY)
-            {
-                originalSize = 2 * TARGET_POINTER_SIZE;
-            }
-            else if (argNode->gtOper == GT_OBJ)
-            {
-                noway_assert(!"GT_OBJ not supported for amd64");
-            }
-#ifdef FEATURE_UNIX_AMD64_STRUCT_PASSING
-            else if (argNode->gtOper == GT_PUTARG_REG)
-            {
-                originalSize = genTypeSize(argNode->gtType);
-            }
-            else if (argNode->gtOper == GT_FIELD_LIST)
-            {
-                originalSize = 0;
-
-                // There could be up to 2 PUTARG_REGs in the list
-                GenTreeFieldList* fieldListPtr = argNode->AsFieldList();
-                unsigned          iterationNum = 0;
-                for (; fieldListPtr; fieldListPtr = fieldListPtr->Rest())
-                {
-                    GenTreePtr putArgRegNode = fieldListPtr->Current();
-                    assert(putArgRegNode->gtOper == GT_PUTARG_REG);
-
-                    if (iterationNum == 0)
-                    {
-                        varDsc       = compiler->lvaTable + putArgRegNode->gtOp.gtOp1->gtLclVarCommon.gtLclNum;
-                        originalSize = varDsc->lvSize();
-                        assert(originalSize != 0);
-                    }
-                    else
-                    {
-                        // Need an extra source for every node, but the first in the list.
-                        info->srcCount++;
-
-                        // Get the mask for the second putarg_reg
-                        argMask = genRegMask(curArgTabEntry->otherRegNum);
-                    }
-
-                    putArgRegNode->gtLsraInfo.setDstCandidates(l, argMask);
-                    putArgRegNode->gtLsraInfo.setSrcCandidates(l, argMask);
-
-                    // To avoid redundant moves, have the argument child tree computed in the
-                    // register in which the argument is passed to the call.
-                    putArgRegNode->gtOp.gtOp1->gtLsraInfo.setSrcCandidates(l, l->getUseCandidates(putArgRegNode));
-                    iterationNum++;
-                }
-
-                assert(iterationNum <= CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS);
-            }
-#endif // FEATURE_UNIX_AMD64_STRUCT_PASSING
-            else
-            {
-                noway_assert(!"Can't predict unsupported TYP_STRUCT arg kind");
-            }
-
-            unsigned slots          = ((unsigned)(roundUp(originalSize, TARGET_POINTER_SIZE))) / REGSIZE_BYTES;
-            unsigned remainingSlots = slots;
-
-            if (!isOnStack)
-            {
-                remainingSlots = slots - 1;
-
-                regNumber reg = (regNumber)(argReg + 1);
-                while (remainingSlots > 0 && reg <= REG_ARG_LAST)
-                {
-                    argMask |= genRegMask(reg);
-                    reg = (regNumber)(reg + 1);
-                    remainingSlots--;
-                    regCount++;
-                }
-            }
-
-            short internalIntCount = 0;
-            if (remainingSlots > 0)
-            {
-#ifdef FEATURE_UNIX_AMD64_STRUCT_PASSING
-                // This TYP_STRUCT argument is also passed in the outgoing argument area
-                // We need a register to address the TYP_STRUCT
-                internalIntCount = 1;
-#else  // FEATURE_UNIX_AMD64_STRUCT_PASSING
-                // And we may need 2
-                internalIntCount            = 2;
-#endif // FEATURE_UNIX_AMD64_STRUCT_PASSING
-            }
-            argNode->gtLsraInfo.internalIntCount = internalIntCount;
-
-#ifdef FEATURE_UNIX_AMD64_STRUCT_PASSING
-            if (argNode->gtOper == GT_PUTARG_REG)
-            {
-                argNode->gtLsraInfo.setDstCandidates(l, argMask);
-                argNode->gtLsraInfo.setSrcCandidates(l, argMask);
-            }
-#endif // FEATURE_UNIX_AMD64_STRUCT_PASSING
-        }
-        else
-        {
-            argNode->gtLsraInfo.setDstCandidates(l, argMask);
-            argNode->gtLsraInfo.setSrcCandidates(l, argMask);
-        }
-
-        // To avoid redundant moves, have the argument child tree computed in the
-        // register in which the argument is passed to the call.
-        if (argNode->gtOper == GT_PUTARG_REG)
-        {
-            argNode->gtOp.gtOp1->gtLsraInfo.setSrcCandidates(l, l->getUseCandidates(argNode));
-        }
-
-#if FEATURE_VARARG
-        // In the case of a varargs call, the ABI dictates that if we have floating point args,
-        // we must pass the enregistered arguments in both the integer and floating point registers.
-        // Since the integer register is not associated with this arg node, we will reserve it as
-        // an internal register so that it is not used during the evaluation of the call node
-        // (e.g. for the target).
-        if (call->IsVarargs() && varTypeIsFloating(argNode))
-        {
-            regNumber targetReg = compiler->getCallArgIntRegister(argReg);
-            info->setInternalIntCount(info->internalIntCount + 1);
-            info->addInternalCandidates(l, genRegMask(targetReg));
-        }
-#endif // FEATURE_VARARG
-    }
-
-    // Now, count stack args
-    // Note that these need to be computed into a register, but then
-    // they're just stored to the stack - so the reg doesn't
-    // need to remain live until the call.  In fact, it must not
-    // because the code generator doesn't actually consider it live,
-    // so it can't be spilled.
-
-    GenTreePtr args = call->gtCallArgs;
-    while (args)
-    {
-        GenTreePtr arg = args->gtOp.gtOp1;
-        if (!(args->gtFlags & GTF_LATE_ARG))
-        {
-            TreeNodeInfo* argInfo = &(arg->gtLsraInfo);
-            if (argInfo->dstCount != 0)
-            {
-                argInfo->isLocalDefUse = true;
-            }
-
-            // If the child of GT_PUTARG_STK is a constant, we don't need a register to
-            // move it to memory (stack location).
-            //
-            // On AMD64, we don't want to make 0 contained, because we can generate smaller code
-            // by zeroing a register and then storing it. E.g.:
-            //      xor rdx, rdx
-            //      mov gword ptr [rsp+28H], rdx
-            // is 2 bytes smaller than:
-            //      mov gword ptr [rsp+28H], 0
-            //
-            // On x86, we push stack arguments; we don't use 'mov'. So:
-            //      push 0
-            // is 1 byte smaller than:
-            //      xor rdx, rdx
-            //      push rdx
-
-            argInfo->dstCount = 0;
-            if (arg->gtOper == GT_PUTARG_STK)
-            {
-                GenTree* op1 = arg->gtOp.gtOp1;
-                if (IsContainableImmed(arg, op1)
-#if defined(_TARGET_AMD64_)
-                    && !op1->IsIntegralConst(0)
-#endif // _TARGET_AMD64_
-                        )
-                {
-                    MakeSrcContained(arg, op1);
-                }
-            }
-        }
-        args = args->gtOp.gtOp2;
-    }
-
-#if FEATURE_VARARG
-    // If it is a fast tail call, it is already preferenced to use RAX.
-    // Therefore, no need set src candidates on call tgt again.
-    if (call->IsVarargs() && callHasFloatRegArgs && !call->IsFastTailCall() && (ctrlExpr != nullptr))
-    {
-        // Don't assign the call target to any of the argument registers because
-        // we will use them to also pass floating point arguments as required
-        // by Amd64 ABI.
-        ctrlExpr->gtLsraInfo.setSrcCandidates(l, l->allRegs(TYP_INT) & ~(RBM_ARG_REGS));
-    }
-#endif // !FEATURE_VARARG
-}
-
-//------------------------------------------------------------------------
-// TreeNodeInfoInitBlockStore: Set the NodeInfo for a block store.
+// LowerBlockStore: Set block store type
 //
 // Arguments:
 //    blkNode       - The block store node of interest
@@ -1652,25 +107,15 @@ void Lowering::TreeNodeInfoInitCall(GenTreeCall* call)
 // Return Value:
 //    None.
 //
-void Lowering::TreeNodeInfoInitBlockStore(GenTreeBlk* blkNode)
+void Lowering::LowerBlockStore(GenTreeBlk* blkNode)
 {
-    GenTree*    dstAddr  = blkNode->Addr();
-    unsigned    size     = blkNode->gtBlkSize;
-    GenTree*    source   = blkNode->Data();
-    LinearScan* l        = m_lsra;
-    Compiler*   compiler = comp;
-
-    // Sources are dest address, initVal or source.
-    // We may require an additional source or temp register for the size.
-    blkNode->gtLsraInfo.srcCount = 2;
-    blkNode->gtLsraInfo.dstCount = 0;
-    blkNode->gtLsraInfo.setInternalCandidates(l, RBM_NONE);
+    GenTree*   dstAddr       = blkNode->Addr();
+    unsigned   size          = blkNode->gtBlkSize;
+    GenTree*   source        = blkNode->Data();
+    Compiler*  compiler      = comp;
     GenTreePtr srcAddrOrFill = nullptr;
     bool       isInitBlk     = blkNode->OperIsInitBlkOp();
 
-    regMaskTP dstAddrRegMask = RBM_NONE;
-    regMaskTP sourceRegMask  = RBM_NONE;
-    regMaskTP blkSizeRegMask = RBM_NONE;
     if (!isInitBlk)
     {
         // CopyObj or CopyBlk
@@ -1681,20 +126,6 @@ void Lowering::TreeNodeInfoInitBlockStore(GenTreeBlk* blkNode)
         if (source->gtOper == GT_IND)
         {
             srcAddrOrFill = blkNode->Data()->gtGetOp1();
-            // We're effectively setting source as contained, but can't call MakeSrcContained, because the
-            // "inheritance" of the srcCount is to a child not a parent - it would "just work" but could be misleading.
-            // If srcAddr is already non-contained, we don't need to change it.
-            if (srcAddrOrFill->gtLsraInfo.getDstCount() == 0)
-            {
-                srcAddrOrFill->gtLsraInfo.setDstCount(1);
-                srcAddrOrFill->gtLsraInfo.setSrcCount(source->gtLsraInfo.srcCount);
-            }
-            m_lsra->clearOperandCounts(source);
-        }
-        else if (!source->IsMultiRegCall() && !source->OperIsSIMD())
-        {
-            assert(source->IsLocal());
-            MakeSrcContained(blkNode, source);
         }
     }
 
@@ -1748,60 +179,18 @@ void Lowering::TreeNodeInfoInitBlockStore(GenTreeBlk* blkNode)
                 initVal->gtIntCon.gtIconVal = 0x01010101 * fill;
 #endif // !_TARGET_AMD64_
 
-                // In case we have a buffer >= 16 bytes
-                // we can use SSE2 to do a 128-bit store in a single
-                // instruction.
-                if (size >= XMM_REGSIZE_BYTES)
-                {
-                    // Reserve an XMM register to fill it with
-                    // a pack of 16 init value constants.
-                    blkNode->gtLsraInfo.internalFloatCount = 1;
-                    blkNode->gtLsraInfo.setInternalCandidates(l, l->internalFloatRegCandidates());
-                    if ((fill == 0) && ((size & 0xf) == 0))
-                    {
-                        MakeSrcContained(blkNode, source);
-                    }
-                    // use XMM register to fill with constants, it's AVX instruction and set the flag
-                    SetContainsAVXFlags();
-                }
                 blkNode->gtBlkOpKind = GenTreeBlk::BlkOpKindUnroll;
-
-#ifdef _TARGET_X86_
-                if ((size & 1) != 0)
-                {
-                    // On x86, you can't address the lower byte of ESI, EDI, ESP, or EBP when doing
-                    // a "mov byte ptr [dest], val". If the fill size is odd, we will try to do this
-                    // when unrolling, so only allow byteable registers as the source value. (We could
-                    // consider just using BlkOpKindRepInstr instead.)
-                    sourceRegMask = RBM_BYTE_REGS;
-                }
-#endif // _TARGET_X86_
             }
             else
             {
-                // rep stos has the following register requirements:
-                // a) The memory address to be in RDI.
-                // b) The fill value has to be in RAX.
-                // c) The buffer size will go in RCX.
-                dstAddrRegMask       = RBM_RDI;
-                srcAddrOrFill        = initVal;
-                sourceRegMask        = RBM_RAX;
-                blkSizeRegMask       = RBM_RCX;
                 blkNode->gtBlkOpKind = GenTreeBlk::BlkOpKindRepInstr;
             }
         }
         else
         {
 #ifdef _TARGET_AMD64_
-            // The helper follows the regular AMD64 ABI.
-            dstAddrRegMask       = RBM_ARG_0;
-            sourceRegMask        = RBM_ARG_1;
-            blkSizeRegMask       = RBM_ARG_2;
             blkNode->gtBlkOpKind = GenTreeBlk::BlkOpKindHelper;
 #else  // !_TARGET_AMD64_
-            dstAddrRegMask                  = RBM_RDI;
-            sourceRegMask                   = RBM_RAX;
-            blkSizeRegMask                  = RBM_RCX;
             blkNode->gtBlkOpKind            = GenTreeBlk::BlkOpKindRepInstr;
 #endif // !_TARGET_AMD64_
         }
@@ -1885,19 +274,12 @@ void Lowering::TreeNodeInfoInitBlockStore(GenTreeBlk* blkNode)
         if (IsRepMovsProfitable)
         {
             // We need the size of the contiguous Non-GC-region to be in RCX to call rep movsq.
-            blkSizeRegMask       = RBM_RCX;
             blkNode->gtBlkOpKind = GenTreeBlk::BlkOpKindRepInstr;
         }
         else
         {
             blkNode->gtBlkOpKind = GenTreeBlk::BlkOpKindUnroll;
         }
-
-        dstAddrRegMask = RBM_RDI;
-
-        // The srcAddr must be in a register.  If it was under a GT_IND, we need to subsume all of its
-        // sources.
-        sourceRegMask = RBM_RSI;
     }
     else
     {
@@ -1918,122 +300,31 @@ void Lowering::TreeNodeInfoInitBlockStore(GenTreeBlk* blkNode)
             // our framework assemblies, so this is the main code generation scheme we'll use.
             if (size <= CPBLK_UNROLL_LIMIT)
             {
-                // If we have a remainder smaller than XMM_REGSIZE_BYTES, we need an integer temp reg.
-                //
-                // x86 specific note: if the size is odd, the last copy operation would be of size 1 byte.
-                // But on x86 only RBM_BYTE_REGS could be used as byte registers.  Therefore, exclude
-                // RBM_NON_BYTE_REGS from internal candidates.
-                if ((size & (XMM_REGSIZE_BYTES - 1)) != 0)
-                {
-                    blkNode->gtLsraInfo.internalIntCount++;
-                    regMaskTP regMask = l->allRegs(TYP_INT);
-
-#ifdef _TARGET_X86_
-                    if ((size % 2) != 0)
-                    {
-                        regMask &= ~RBM_NON_BYTE_REGS;
-                    }
-#endif
-                    blkNode->gtLsraInfo.setInternalCandidates(l, regMask);
-                }
-
-                if (size >= XMM_REGSIZE_BYTES)
-                {
-                    // If we have a buffer larger than XMM_REGSIZE_BYTES,
-                    // reserve an XMM register to use it for a
-                    // series of 16-byte loads and stores.
-                    blkNode->gtLsraInfo.internalFloatCount = 1;
-                    blkNode->gtLsraInfo.addInternalCandidates(l, l->internalFloatRegCandidates());
-                    // Uses XMM reg for load and store and hence check to see whether AVX instructions
-                    // are used for codegen, set ContainsAVX flag
-                    SetContainsAVXFlags();
-                }
-
-                // If src or dst are on stack, we don't have to generate the address into a register
-                // because it's just some constant+SP
-                if (srcAddrOrFill != nullptr && srcAddrOrFill->OperIsLocalAddr())
-                {
-                    MakeSrcContained(blkNode, srcAddrOrFill);
-                }
-
-                if (dstAddr->OperIsLocalAddr())
-                {
-                    MakeSrcContained(blkNode, dstAddr);
-                }
-
                 blkNode->gtBlkOpKind = GenTreeBlk::BlkOpKindUnroll;
             }
             else
             {
-                blkNode->gtLsraInfo.setInternalCandidates(l, RBM_NONE);
-                dstAddrRegMask       = RBM_RDI;
-                sourceRegMask        = RBM_RSI;
-                blkSizeRegMask       = RBM_RCX;
                 blkNode->gtBlkOpKind = GenTreeBlk::BlkOpKindRepInstr;
             }
         }
 #ifdef _TARGET_AMD64_
         else
         {
-            // In case we have a constant integer this means we went beyond
-            // CPBLK_MOVS_LIMIT bytes of size, still we should never have the case of
-            // any GC-Pointers in the src struct.
-            blkNode->gtLsraInfo.setInternalCandidates(l, RBM_NONE);
-            dstAddrRegMask       = RBM_ARG_0;
-            sourceRegMask        = RBM_ARG_1;
-            blkSizeRegMask       = RBM_ARG_2;
             blkNode->gtBlkOpKind = GenTreeBlk::BlkOpKindHelper;
         }
 #elif defined(_TARGET_X86_)
         else
         {
-            dstAddrRegMask       = RBM_RDI;
-            sourceRegMask        = RBM_RSI;
-            blkSizeRegMask       = RBM_RCX;
             blkNode->gtBlkOpKind = GenTreeBlk::BlkOpKindRepInstr;
         }
 #endif // _TARGET_X86_
         assert(blkNode->gtBlkOpKind != GenTreeBlk::BlkOpKindInvalid);
     }
-    if (dstAddrRegMask != RBM_NONE)
-    {
-        dstAddr->gtLsraInfo.setSrcCandidates(l, dstAddrRegMask);
-    }
-    if (sourceRegMask != RBM_NONE)
-    {
-        if (srcAddrOrFill != nullptr)
-        {
-            srcAddrOrFill->gtLsraInfo.setSrcCandidates(l, sourceRegMask);
-        }
-        else
-        {
-            // This is a local source; we'll use a temp register for its address.
-            blkNode->gtLsraInfo.addInternalCandidates(l, sourceRegMask);
-            blkNode->gtLsraInfo.internalIntCount++;
-        }
-    }
-    if (blkSizeRegMask != RBM_NONE)
-    {
-        if (size != 0)
-        {
-            // Reserve a temp register for the block size argument.
-            blkNode->gtLsraInfo.addInternalCandidates(l, blkSizeRegMask);
-            blkNode->gtLsraInfo.internalIntCount++;
-        }
-        else
-        {
-            // The block size argument is a third argument to GT_STORE_DYN_BLK
-            noway_assert(blkNode->gtOper == GT_STORE_DYN_BLK);
-            blkNode->gtLsraInfo.setSrcCount(3);
-            GenTree* blockSize = blkNode->AsDynBlk()->gtDynamicSize;
-            blockSize->gtLsraInfo.setSrcCandidates(l, blkSizeRegMask);
-        }
-    }
 }
 
 #ifdef FEATURE_PUT_STRUCT_ARG_STK
 //------------------------------------------------------------------------
-// TreeNodeInfoInitPutArgStk: Set the NodeInfo for a GT_PUTARG_STK.
+// LowerPutArgStk: Lower a GT_PUTARG_STK.
 //
 // Arguments:
 //    tree      - The node of interest
@@ -2041,11 +332,8 @@ void Lowering::TreeNodeInfoInitBlockStore(GenTreeBlk* blkNode)
 // Return Value:
 //    None.
 //
-void Lowering::TreeNodeInfoInitPutArgStk(GenTreePutArgStk* putArgStk)
+void Lowering::LowerPutArgStk(GenTreePutArgStk* putArgStk)
 {
-    TreeNodeInfo* info = &(putArgStk->gtLsraInfo);
-    LinearScan*   l    = m_lsra;
-
 #ifdef _TARGET_X86_
     if (putArgStk->gtOp1->gtOper == GT_FIELD_LIST)
     {
@@ -2088,9 +376,6 @@ void Lowering::TreeNodeInfoInitPutArgStk(GenTreePutArgStk* putArgStk)
             fieldCount++;
         }
 
-        info->srcCount = fieldCount;
-        info->dstCount = 0;
-
         // In theory, the upper bound for the size of a field list is 8: these constructs only appear when passing the
         // collection of lclVars that represent the fields of a promoted struct lclVar, and we do not promote struct
         // lclVars with more than 4 fields. If each of these lclVars is of type long, decomposition will split the
@@ -2121,9 +406,8 @@ void Lowering::TreeNodeInfoInitPutArgStk(GenTreePutArgStk* putArgStk)
             putArgStk->gtOp1 = fieldList;
         }
 
-        // Now that the fields have been sorted, initialize the LSRA info.
+        // Now that the fields have been sorted, the kind of code we will generate.
         bool     allFieldsAreSlots = true;
-        bool     needsByteTemp     = false;
         unsigned prevOffset        = putArgStk->getArgSize();
         for (GenTreeFieldList* current = fieldList; current != nullptr; current = current->Rest())
         {
@@ -2132,56 +416,12 @@ void Lowering::TreeNodeInfoInitPutArgStk(GenTreePutArgStk* putArgStk)
             const unsigned  fieldOffset = current->gtFieldOffset;
             assert(fieldType != TYP_LONG);
 
-            // For x86 we must mark all integral fields as contained or reg-optional, and handle them
-            // accordingly in code generation, since we may have up to 8 fields, which cannot all be in
-            // registers to be consumed atomically by the call.
-            if (varTypeIsIntegralOrI(fieldNode))
-            {
-                if (fieldNode->OperGet() == GT_LCL_VAR)
-                {
-                    LclVarDsc* varDsc = &(comp->lvaTable[fieldNode->AsLclVarCommon()->gtLclNum]);
-                    if (varDsc->lvTracked && !varDsc->lvDoNotEnregister)
-                    {
-                        SetRegOptional(fieldNode);
-                    }
-                    else
-                    {
-                        MakeSrcContained(putArgStk, fieldNode);
-                    }
-                }
-                else if (fieldNode->IsIntCnsFitsInI32())
-                {
-                    MakeSrcContained(putArgStk, fieldNode);
-                }
-                else
-                {
-                    // For the case where we cannot directly push the value, if we run out of registers,
-                    // it would be better to defer computation until we are pushing the arguments rather
-                    // than spilling, but this situation is not all that common, as most cases of promoted
-                    // structs do not have a large number of fields, and of those most are lclVars or
-                    // copy-propagated constants.
-                    SetRegOptional(fieldNode);
-                }
-            }
-            else
-            {
-                assert(varTypeIsFloating(fieldNode));
-            }
-
             // We can treat as a slot any field that is stored at a slot boundary, where the previous
             // field is not in the same slot. (Note that we store the fields in reverse order.)
             const bool fieldIsSlot = ((fieldOffset % 4) == 0) && ((prevOffset - fieldOffset) >= 4);
             if (!fieldIsSlot)
             {
                 allFieldsAreSlots = false;
-                if (varTypeIsByte(fieldType))
-                {
-                    // If this field is a slot--i.e. it is an integer field that is 4-byte aligned and takes up 4 bytes
-                    // (including padding)--we can store the whole value rather than just the byte. Otherwise, we will
-                    // need a byte-addressable register for the store. We will enforce this requirement on an internal
-                    // register, which we can use to copy multiple byte values.
-                    needsByteTemp = true;
-                }
             }
 
             if (varTypeIsGC(fieldType))
@@ -2205,35 +445,13 @@ void Lowering::TreeNodeInfoInitPutArgStk(GenTreePutArgStk* putArgStk)
         else
         {
             putArgStk->gtPutArgStkKind = GenTreePutArgStk::Kind::Push;
-            // If any of the fields cannot be stored with an actual push, we may need a temporary
-            // register to load the value before storing it to the stack location.
-            info->internalIntCount = 1;
-            regMaskTP regMask      = l->allRegs(TYP_INT);
-            if (needsByteTemp)
-            {
-                regMask &= ~RBM_NON_BYTE_REGS;
-            }
-            info->setInternalCandidates(l, regMask);
         }
         return;
     }
 #endif // _TARGET_X86_
 
-#if defined(FEATURE_SIMD) && defined(_TARGET_X86_)
-    // For PutArgStk of a TYP_SIMD12, we need an extra register.
-    if (putArgStk->TypeGet() == TYP_SIMD12)
-    {
-        info->srcCount           = putArgStk->gtOp1->gtLsraInfo.dstCount;
-        info->dstCount           = 0;
-        info->internalFloatCount = 1;
-        info->setInternalCandidates(l, l->allSIMDRegs());
-        return;
-    }
-#endif // defined(FEATURE_SIMD) && defined(_TARGET_X86_)
-
     if (putArgStk->TypeGet() != TYP_STRUCT)
     {
-        TreeNodeInfoInitSimple(putArgStk);
         return;
     }
 
@@ -2241,21 +459,6 @@ void Lowering::TreeNodeInfoInitPutArgStk(GenTreePutArgStk* putArgStk)
     GenTreePtr src     = putArgStk->gtOp1;
     GenTreePtr srcAddr = nullptr;
 
-    bool haveLocalAddr = false;
-    if ((src->OperGet() == GT_OBJ) || (src->OperGet() == GT_IND))
-    {
-        srcAddr = src->gtOp.gtOp1;
-        assert(srcAddr != nullptr);
-        haveLocalAddr = srcAddr->OperIsLocalAddr();
-    }
-    else
-    {
-        assert(varTypeIsSIMD(putArgStk));
-    }
-
-    info->srcCount = src->gtLsraInfo.dstCount;
-    info->dstCount = 0;
-
     // In case of a CpBlk we could use a helper call. In case of putarg_stk we
     // can't do that since the helper call could kill some already set up outgoing args.
     // TODO-Amd64-Unix: converge the code for putarg_stk with cpyblk/cpyobj.
@@ -2275,38 +478,6 @@ void Lowering::TreeNodeInfoInitPutArgStk(GenTreePutArgStk* putArgStk)
     // our framework assemblies, so this is the main code generation scheme we'll use.
     if (size <= CPBLK_UNROLL_LIMIT && putArgStk->gtNumberReferenceSlots == 0)
     {
-        // If we have a remainder smaller than XMM_REGSIZE_BYTES, we need an integer temp reg.
-        //
-        // x86 specific note: if the size is odd, the last copy operation would be of size 1 byte.
-        // But on x86 only RBM_BYTE_REGS could be used as byte registers.  Therefore, exclude
-        // RBM_NON_BYTE_REGS from internal candidates.
-        if ((size & (XMM_REGSIZE_BYTES - 1)) != 0)
-        {
-            info->internalIntCount++;
-            regMaskTP regMask = l->allRegs(TYP_INT);
-
-#ifdef _TARGET_X86_
-            if ((size % 2) != 0)
-            {
-                regMask &= ~RBM_NON_BYTE_REGS;
-            }
-#endif
-            info->setInternalCandidates(l, regMask);
-        }
-
-#ifdef _TARGET_X86_
-        if (size >= 8)
-#else  // !_TARGET_X86_
-        if (size >= XMM_REGSIZE_BYTES)
-#endif // !_TARGET_X86_
-        {
-            // If we have a buffer larger than or equal to XMM_REGSIZE_BYTES on x64/ux,
-            // or larger than or equal to 8 bytes on x86, reserve an XMM register to use it for a
-            // series of 16-byte loads and stores.
-            info->internalFloatCount = 1;
-            info->addInternalCandidates(l, l->internalFloatRegCandidates());
-        }
-
 #ifdef _TARGET_X86_
         if (size < XMM_REGSIZE_BYTES)
         {
@@ -2328,1201 +499,11 @@ void Lowering::TreeNodeInfoInitPutArgStk(GenTreePutArgStk* putArgStk)
 #endif // _TARGET_X86_
     else
     {
-        info->internalIntCount += 3;
-        info->setInternalCandidates(l, (RBM_RDI | RBM_RCX | RBM_RSI));
-
         putArgStk->gtPutArgStkKind = GenTreePutArgStk::Kind::RepInstr;
     }
-
-    // Always mark the OBJ and ADDR as contained trees by the putarg_stk. The codegen will deal with this tree.
-    MakeSrcContained(putArgStk, src);
-
-    if (haveLocalAddr)
-    {
-        // If the source address is the address of a lclVar, make the source address contained to avoid unnecessary
-        // copies.
-        //
-        // To avoid an assertion in MakeSrcContained, increment the parent's source count beforehand and decrement it
-        // afterwards.
-        info->srcCount++;
-        MakeSrcContained(putArgStk, srcAddr);
-        info->srcCount--;
-    }
 }
 #endif // FEATURE_PUT_STRUCT_ARG_STK
 
-//------------------------------------------------------------------------
-// TreeNodeInfoInitLclHeap: Set the NodeInfo for a GT_LCLHEAP.
-//
-// Arguments:
-//    tree      - The node of interest
-//
-// Return Value:
-//    None.
-//
-void Lowering::TreeNodeInfoInitLclHeap(GenTree* tree)
-{
-    TreeNodeInfo* info     = &(tree->gtLsraInfo);
-    LinearScan*   l        = m_lsra;
-    Compiler*     compiler = comp;
-
-    info->srcCount = 1;
-    info->dstCount = 1;
-
-    // Need a variable number of temp regs (see genLclHeap() in codegenamd64.cpp):
-    // Here '-' means don't care.
-    //
-    //     Size?                    Init Memory?         # temp regs
-    //      0                            -                  0 (returns 0)
-    //      const and <=6 reg words      -                  0 (pushes '0')
-    //      const and >6 reg words       Yes                0 (pushes '0')
-    //      const and <PageSize          No                 0 (amd64) 1 (x86)
-    //                                                        (x86:tmpReg for sutracting from esp)
-    //      const and >=PageSize         No                 2 (regCnt and tmpReg for subtracing from sp)
-    //      Non-const                    Yes                0 (regCnt=targetReg and pushes '0')
-    //      Non-const                    No                 2 (regCnt and tmpReg for subtracting from sp)
-    //
-    // Note: Here we don't need internal register to be different from targetReg.
-    // Rather, require it to be different from operand's reg.
-
-    GenTreePtr size = tree->gtOp.gtOp1;
-    if (size->IsCnsIntOrI())
-    {
-        MakeSrcContained(tree, size);
-
-        size_t sizeVal = size->gtIntCon.gtIconVal;
-
-        if (sizeVal == 0)
-        {
-            info->internalIntCount = 0;
-        }
-        else
-        {
-            // Compute the amount of memory to properly STACK_ALIGN.
-            // Note: The Gentree node is not updated here as it is cheap to recompute stack aligned size.
-            // This should also help in debugging as we can examine the original size specified with localloc.
-            sizeVal = AlignUp(sizeVal, STACK_ALIGN);
-
-            // For small allocations up to 6 pointer sized words (i.e. 48 bytes of localloc)
-            // we will generate 'push 0'.
-            assert((sizeVal % REGSIZE_BYTES) == 0);
-            size_t cntRegSizedWords = sizeVal / REGSIZE_BYTES;
-            if (cntRegSizedWords <= 6)
-            {
-                info->internalIntCount = 0;
-            }
-            else if (!compiler->info.compInitMem)
-            {
-                // No need to initialize allocated stack space.
-                if (sizeVal < compiler->eeGetPageSize())
-                {
-#ifdef _TARGET_X86_
-                    info->internalIntCount = 1; // x86 needs a register here to avoid generating "sub" on ESP.
-#else                                           // !_TARGET_X86_
-                    info->internalIntCount = 0;
-#endif                                          // !_TARGET_X86_
-                }
-                else
-                {
-                    // We need two registers: regCnt and RegTmp
-                    info->internalIntCount = 2;
-                }
-            }
-            else
-            {
-                // >6 and need to zero initialize allocated stack space.
-                info->internalIntCount = 0;
-            }
-        }
-    }
-    else
-    {
-        if (!compiler->info.compInitMem)
-        {
-            info->internalIntCount = 2;
-        }
-        else
-        {
-            info->internalIntCount = 0;
-        }
-    }
-}
-
-//------------------------------------------------------------------------
-// TreeNodeInfoInitLogicalOp: Set the NodeInfo for GT_AND/GT_OR/GT_XOR,
-// as well as GT_ADD/GT_SUB.
-//
-// Arguments:
-//    tree      - The node of interest
-//
-// Return Value:
-//    None.
-//
-void Lowering::TreeNodeInfoInitLogicalOp(GenTree* tree)
-{
-    TreeNodeInfo* info = &(tree->gtLsraInfo);
-    LinearScan*   l    = m_lsra;
-
-    // We're not marking a constant hanging on the left of the add
-    // as containable so we assign it to a register having CQ impact.
-    // TODO-XArch-CQ: Detect this case and support both generating a single instruction
-    // for GT_ADD(Constant, SomeTree)
-    info->srcCount = 2;
-    info->dstCount = 1;
-
-    GenTree* op1 = tree->gtGetOp1();
-    GenTree* op2 = tree->gtGetOp2();
-
-    // We can directly encode the second operand if it is either a containable constant or a memory-op.
-    // In case of memory-op, we can encode it directly provided its type matches with 'tree' type.
-    // This is because during codegen, type of 'tree' is used to determine emit Type size. If the types
-    // do not match, they get normalized (i.e. sign/zero extended) on load into a register.
-    bool       directlyEncodable = false;
-    bool       binOpInRMW        = false;
-    GenTreePtr operand           = nullptr;
-
-    if (IsContainableImmed(tree, op2))
-    {
-        directlyEncodable = true;
-        operand           = op2;
-    }
-    else
-    {
-        binOpInRMW = IsBinOpInRMWStoreInd(tree);
-        if (!binOpInRMW)
-        {
-            if (op2->isMemoryOp() && tree->TypeGet() == op2->TypeGet())
-            {
-                directlyEncodable = true;
-                operand           = op2;
-            }
-            else if (tree->OperIsCommutative())
-            {
-                if (IsContainableImmed(tree, op1) ||
-                    (op1->isMemoryOp() && tree->TypeGet() == op1->TypeGet() && IsSafeToContainMem(tree, op1)))
-                {
-                    // If it is safe, we can reverse the order of operands of commutative operations for efficient
-                    // codegen
-                    directlyEncodable = true;
-                    operand           = op1;
-                }
-            }
-        }
-    }
-
-    if (directlyEncodable)
-    {
-        assert(operand != nullptr);
-        MakeSrcContained(tree, operand);
-    }
-    else if (!binOpInRMW)
-    {
-        // If this binary op neither has contained operands, nor is a
-        // Read-Modify-Write (RMW) operation, we can mark its operands
-        // as reg optional.
-        SetRegOptionalForBinOp(tree);
-    }
-
-    // Codegen of this tree node sets ZF and SF flags.
-    tree->gtFlags |= GTF_ZSF_SET;
-}
-
-//------------------------------------------------------------------------
-// TreeNodeInfoInitModDiv: Set the NodeInfo for GT_MOD/GT_DIV/GT_UMOD/GT_UDIV.
-//
-// Arguments:
-//    tree      - The node of interest
-//
-// Return Value:
-//    None.
-//
-void Lowering::TreeNodeInfoInitModDiv(GenTree* tree)
-{
-    TreeNodeInfo* info = &(tree->gtLsraInfo);
-    LinearScan*   l    = m_lsra;
-
-    GenTree* op1 = tree->gtGetOp1();
-    GenTree* op2 = tree->gtGetOp2();
-
-    info->srcCount = 2;
-    info->dstCount = 1;
-
-    switch (tree->OperGet())
-    {
-        case GT_MOD:
-        case GT_DIV:
-            if (varTypeIsFloating(tree->TypeGet()))
-            {
-                // No implicit conversions at this stage as the expectation is that
-                // everything is made explicit by adding casts.
-                assert(op1->TypeGet() == op2->TypeGet());
-
-                if (op2->isMemoryOp() || op2->IsCnsNonZeroFltOrDbl())
-                {
-                    MakeSrcContained(tree, op2);
-                }
-                else
-                {
-                    // If there are no containable operands, we can make an operand reg optional.
-                    // SSE2 allows only op2 to be a memory-op.
-                    SetRegOptional(op2);
-                }
-
-                return;
-            }
-            break;
-
-        default:
-            break;
-    }
-
-    // Amd64 Div/Idiv instruction:
-    //    Dividend in RAX:RDX  and computes
-    //    Quotient in RAX, Remainder in RDX
-
-    if (tree->OperGet() == GT_MOD || tree->OperGet() == GT_UMOD)
-    {
-        // We are interested in just the remainder.
-        // RAX is used as a trashable register during computation of remainder.
-        info->setDstCandidates(l, RBM_RDX);
-    }
-    else
-    {
-        // We are interested in just the quotient.
-        // RDX gets used as trashable register during computation of quotient
-        info->setDstCandidates(l, RBM_RAX);
-    }
-
-    bool op2CanBeRegOptional = true;
-#ifdef _TARGET_X86_
-    if (op1->OperGet() == GT_LONG)
-    {
-        // To avoid reg move would like to have op1's low part in RAX and high part in RDX.
-        GenTree* loVal = op1->gtGetOp1();
-        GenTree* hiVal = op1->gtGetOp2();
-
-        // Src count is actually 3, so increment.
-        assert(op2->IsCnsIntOrI());
-        assert(tree->OperGet() == GT_UMOD);
-        info->srcCount++;
-        op2CanBeRegOptional = false;
-
-        // This situation also requires an internal register.
-        info->internalIntCount = 1;
-        info->setInternalCandidates(l, l->allRegs(TYP_INT));
-
-        loVal->gtLsraInfo.setSrcCandidates(l, RBM_EAX);
-        hiVal->gtLsraInfo.setSrcCandidates(l, RBM_EDX);
-    }
-    else
-#endif
-    {
-        // If possible would like to have op1 in RAX to avoid a register move
-        op1->gtLsraInfo.setSrcCandidates(l, RBM_RAX);
-    }
-
-    // divisor can be an r/m, but the memory indirection must be of the same size as the divide
-    if (op2->isMemoryOp() && (op2->TypeGet() == tree->TypeGet()))
-    {
-        MakeSrcContained(tree, op2);
-    }
-    else if (op2CanBeRegOptional)
-    {
-        op2->gtLsraInfo.setSrcCandidates(l, l->allRegs(TYP_INT) & ~(RBM_RAX | RBM_RDX));
-
-        // If there are no containable operands, we can make an operand reg optional.
-        // Div instruction allows only op2 to be a memory op.
-        SetRegOptional(op2);
-    }
-}
-
-//------------------------------------------------------------------------
-// TreeNodeInfoInitIntrinsic: Set the NodeInfo for a GT_INTRINSIC.
-//
-// Arguments:
-//    tree      - The node of interest
-//
-// Return Value:
-//    None.
-//
-void Lowering::TreeNodeInfoInitIntrinsic(GenTree* tree)
-{
-    TreeNodeInfo* info = &(tree->gtLsraInfo);
-    LinearScan*   l    = m_lsra;
-
-    // Both operand and its result must be of floating point type.
-    GenTree* op1 = tree->gtGetOp1();
-    assert(varTypeIsFloating(op1));
-    assert(op1->TypeGet() == tree->TypeGet());
-
-    info->srcCount = 1;
-    info->dstCount = 1;
-
-    switch (tree->gtIntrinsic.gtIntrinsicId)
-    {
-        case CORINFO_INTRINSIC_Sqrt:
-            if (op1->isMemoryOp() || op1->IsCnsNonZeroFltOrDbl())
-            {
-                MakeSrcContained(tree, op1);
-            }
-            else
-            {
-                // Mark the operand as reg optional since codegen can still
-                // generate code if op1 is on stack.
-                SetRegOptional(op1);
-            }
-            break;
-
-        case CORINFO_INTRINSIC_Abs:
-            // Abs(float x) = x & 0x7fffffff
-            // Abs(double x) = x & 0x7ffffff ffffffff
-
-            // In case of Abs we need an internal register to hold mask.
-
-            // TODO-XArch-CQ: avoid using an internal register for the mask.
-            // Andps or andpd both will operate on 128-bit operands.
-            // The data section constant to hold the mask is a 64-bit size.
-            // Therefore, we need both the operand and mask to be in
-            // xmm register. When we add support in emitter to emit 128-bit
-            // data constants and instructions that operate on 128-bit
-            // memory operands we can avoid the need for an internal register.
-            if (tree->gtIntrinsic.gtIntrinsicId == CORINFO_INTRINSIC_Abs)
-            {
-                info->internalFloatCount = 1;
-                info->setInternalCandidates(l, l->internalFloatRegCandidates());
-            }
-            break;
-
-#ifdef _TARGET_X86_
-        case CORINFO_INTRINSIC_Cos:
-        case CORINFO_INTRINSIC_Sin:
-        case CORINFO_INTRINSIC_Round:
-            NYI_X86("Math intrinsics Cos, Sin and Round");
-            break;
-#endif // _TARGET_X86_
-
-        default:
-            // Right now only Sqrt/Abs are treated as math intrinsics
-            noway_assert(!"Unsupported math intrinsic");
-            unreached();
-            break;
-    }
-}
-
-#ifdef FEATURE_SIMD
-//------------------------------------------------------------------------
-// TreeNodeInfoInitSIMD: Set the NodeInfo for a GT_SIMD tree.
-//
-// Arguments:
-//    tree       - The GT_SIMD node of interest
-//
-// Return Value:
-//    None.
-
-void Lowering::TreeNodeInfoInitSIMD(GenTree* tree)
-{
-    GenTreeSIMD*  simdTree = tree->AsSIMD();
-    TreeNodeInfo* info     = &(tree->gtLsraInfo);
-    LinearScan*   lsra     = m_lsra;
-    info->dstCount         = 1;
-    SetContainsAVXFlags(true, simdTree->gtSIMDSize);
-    switch (simdTree->gtSIMDIntrinsicID)
-    {
-        GenTree* op1;
-        GenTree* op2;
-
-        case SIMDIntrinsicInit:
-        {
-            info->srcCount = 1;
-            op1            = tree->gtOp.gtOp1;
-
-            // This sets all fields of a SIMD struct to the given value.
-            // Mark op1 as contained if it is either zero or int constant of all 1's,
-            // or a float constant with 16 or 32 byte simdType (AVX case)
-            //
-            // Should never see small int base type vectors except for zero initialization.
-            assert(!varTypeIsSmallInt(simdTree->gtSIMDBaseType) || op1->IsIntegralConst(0));
-
-            if (op1->IsFPZero() || op1->IsIntegralConst(0) ||
-                (varTypeIsIntegral(simdTree->gtSIMDBaseType) && op1->IsIntegralConst(-1)))
-            {
-                MakeSrcContained(tree, tree->gtOp.gtOp1);
-                info->srcCount = 0;
-            }
-            else if ((comp->getSIMDInstructionSet() == InstructionSet_AVX) &&
-                     ((simdTree->gtSIMDSize == 16) || (simdTree->gtSIMDSize == 32)))
-            {
-                // Either op1 is a float or dbl constant or an addr
-                if (op1->IsCnsFltOrDbl() || op1->OperIsLocalAddr())
-                {
-                    MakeSrcContained(tree, tree->gtOp.gtOp1);
-                    info->srcCount = 0;
-                }
-            }
-        }
-        break;
-
-        case SIMDIntrinsicInitN:
-        {
-            info->srcCount = (short)(simdTree->gtSIMDSize / genTypeSize(simdTree->gtSIMDBaseType));
-
-            // Need an internal register to stitch together all the values into a single vector in a SIMD reg.
-            info->internalFloatCount = 1;
-            info->setInternalCandidates(lsra, lsra->allSIMDRegs());
-        }
-        break;
-
-        case SIMDIntrinsicInitArray:
-            // We have an array and an index, which may be contained.
-            info->srcCount = 2;
-            CheckImmedAndMakeContained(tree, tree->gtGetOp2());
-            break;
-
-        case SIMDIntrinsicDiv:
-            // SSE2 has no instruction support for division on integer vectors
-            noway_assert(varTypeIsFloating(simdTree->gtSIMDBaseType));
-            info->srcCount = 2;
-            break;
-
-        case SIMDIntrinsicAbs:
-            // float/double vectors: This gets implemented as bitwise-And operation
-            // with a mask and hence should never see  here.
-            //
-            // Must be a Vector<int> or Vector<short> Vector<sbyte>
-            assert(simdTree->gtSIMDBaseType == TYP_INT || simdTree->gtSIMDBaseType == TYP_SHORT ||
-                   simdTree->gtSIMDBaseType == TYP_BYTE);
-            assert(comp->getSIMDInstructionSet() >= InstructionSet_SSE3_4);
-            info->srcCount = 1;
-            break;
-
-        case SIMDIntrinsicSqrt:
-            // SSE2 has no instruction support for sqrt on integer vectors.
-            noway_assert(varTypeIsFloating(simdTree->gtSIMDBaseType));
-            info->srcCount = 1;
-            break;
-
-        case SIMDIntrinsicAdd:
-        case SIMDIntrinsicSub:
-        case SIMDIntrinsicMul:
-        case SIMDIntrinsicBitwiseAnd:
-        case SIMDIntrinsicBitwiseAndNot:
-        case SIMDIntrinsicBitwiseOr:
-        case SIMDIntrinsicBitwiseXor:
-        case SIMDIntrinsicMin:
-        case SIMDIntrinsicMax:
-            info->srcCount = 2;
-
-            // SSE2 32-bit integer multiplication requires two temp regs
-            if (simdTree->gtSIMDIntrinsicID == SIMDIntrinsicMul && simdTree->gtSIMDBaseType == TYP_INT &&
-                comp->getSIMDInstructionSet() == InstructionSet_SSE2)
-            {
-                info->internalFloatCount = 2;
-                info->setInternalCandidates(lsra, lsra->allSIMDRegs());
-            }
-            break;
-
-        case SIMDIntrinsicEqual:
-            info->srcCount = 2;
-            break;
-
-        // SSE2 doesn't support < and <= directly on int vectors.
-        // Instead we need to use > and >= with swapped operands.
-        case SIMDIntrinsicLessThan:
-        case SIMDIntrinsicLessThanOrEqual:
-            info->srcCount = 2;
-            noway_assert(!varTypeIsIntegral(simdTree->gtSIMDBaseType));
-            break;
-
-        // SIMDIntrinsicEqual is supported only on non-floating point base type vectors.
-        // SSE2 cmpps/pd doesn't support > and >=  directly on float/double vectors.
-        // Instead we need to use <  and <= with swapped operands.
-        case SIMDIntrinsicGreaterThan:
-            noway_assert(!varTypeIsFloating(simdTree->gtSIMDBaseType));
-            info->srcCount = 2;
-            break;
-
-        case SIMDIntrinsicOpEquality:
-        case SIMDIntrinsicOpInEquality:
-            info->srcCount = 2;
-
-            // On SSE4/AVX, we can generate optimal code for (in)equality
-            // against zero using ptest. We can safely do the this optimization
-            // for integral vectors but not for floating-point for the reason
-            // that we have +0.0 and -0.0 and +0.0 == -0.0
-            op2 = tree->gtGetOp2();
-            if ((comp->getSIMDInstructionSet() >= InstructionSet_SSE3_4) && op2->IsIntegralConstVector(0))
-            {
-                MakeSrcContained(tree, op2);
-            }
-            else
-            {
-
-                // Need one SIMD register as scratch.
-                // See genSIMDIntrinsicRelOp() for details on code sequence generated and
-                // the need for one scratch register.
-                //
-                // Note these intrinsics produce a BOOL result, hence internal float
-                // registers reserved are guaranteed to be different from target
-                // integer register without explicitly specifying.
-                info->internalFloatCount = 1;
-                info->setInternalCandidates(lsra, lsra->allSIMDRegs());
-            }
-            break;
-
-        case SIMDIntrinsicDotProduct:
-            // Float/Double vectors:
-            // For SSE, or AVX with 32-byte vectors, we also need an internal register
-            // as scratch. Further we need the targetReg and internal reg to be distinct
-            // registers. Note that if this is a TYP_SIMD16 or smaller on AVX, then we
-            // don't need a tmpReg.
-            //
-            // 32-byte integer vector on SSE4/AVX:
-            // will take advantage of phaddd, which operates only on 128-bit xmm reg.
-            // This will need 1 (in case of SSE4) or 2 (in case of AVX) internal
-            // registers since targetReg is an int type register.
-            //
-            // See genSIMDIntrinsicDotProduct() for details on code sequence generated
-            // and the need for scratch registers.
-            if (varTypeIsFloating(simdTree->gtSIMDBaseType))
-            {
-                if ((comp->getSIMDInstructionSet() == InstructionSet_SSE2) ||
-                    (simdTree->gtOp.gtOp1->TypeGet() == TYP_SIMD32))
-                {
-                    info->internalFloatCount     = 1;
-                    info->isInternalRegDelayFree = true;
-                    info->setInternalCandidates(lsra, lsra->allSIMDRegs());
-                }
-                // else don't need scratch reg(s).
-            }
-            else
-            {
-                assert(simdTree->gtSIMDBaseType == TYP_INT && comp->getSIMDInstructionSet() >= InstructionSet_SSE3_4);
-
-                // No need to set isInternalRegDelayFree since targetReg is a
-                // an int type reg and guaranteed to be different from xmm/ymm
-                // regs.
-                info->internalFloatCount = comp->canUseAVX() ? 2 : 1;
-                info->setInternalCandidates(lsra, lsra->allSIMDRegs());
-            }
-            info->srcCount = 2;
-            break;
-
-        case SIMDIntrinsicGetItem:
-        {
-            // This implements get_Item method. The sources are:
-            //  - the source SIMD struct
-            //  - index (which element to get)
-            // The result is baseType of SIMD struct.
-            info->srcCount = 2;
-            op1            = tree->gtOp.gtOp1;
-            op2            = tree->gtOp.gtOp2;
-
-            // If the index is a constant, mark it as contained.
-            if (CheckImmedAndMakeContained(tree, op2))
-            {
-                info->srcCount = 1;
-            }
-
-            if (op1->isMemoryOp())
-            {
-                MakeSrcContained(tree, op1);
-
-                // Although GT_IND of TYP_SIMD12 reserves an internal float
-                // register for reading 4 and 8 bytes from memory and
-                // assembling them into target XMM reg, it is not required
-                // in this case.
-                op1->gtLsraInfo.internalIntCount   = 0;
-                op1->gtLsraInfo.internalFloatCount = 0;
-            }
-            else
-            {
-                // If the index is not a constant, we will use the SIMD temp location to store the vector.
-                // Otherwise, if the baseType is floating point, the targetReg will be a xmm reg and we
-                // can use that in the process of extracting the element.
-                //
-                // If the index is a constant and base type is a small int we can use pextrw, but on AVX
-                // we will need a temp if are indexing into the upper half of the AVX register.
-                // In all other cases with constant index, we need a temp xmm register to extract the
-                // element if index is other than zero.
-
-                if (!op2->IsCnsIntOrI())
-                {
-                    (void)comp->getSIMDInitTempVarNum();
-                }
-                else if (!varTypeIsFloating(simdTree->gtSIMDBaseType))
-                {
-                    bool needFloatTemp;
-                    if (varTypeIsSmallInt(simdTree->gtSIMDBaseType) &&
-                        (comp->getSIMDInstructionSet() == InstructionSet_AVX))
-                    {
-                        int byteShiftCnt = (int)op2->AsIntCon()->gtIconVal * genTypeSize(simdTree->gtSIMDBaseType);
-                        needFloatTemp    = (byteShiftCnt >= 16);
-                    }
-                    else
-                    {
-                        needFloatTemp = !op2->IsIntegralConst(0);
-                    }
-
-                    if (needFloatTemp)
-                    {
-                        info->internalFloatCount = 1;
-                        info->setInternalCandidates(lsra, lsra->allSIMDRegs());
-                    }
-                }
-            }
-        }
-        break;
-
-        case SIMDIntrinsicSetX:
-        case SIMDIntrinsicSetY:
-        case SIMDIntrinsicSetZ:
-        case SIMDIntrinsicSetW:
-            info->srcCount = 2;
-
-            // We need an internal integer register for SSE2 codegen
-            if (comp->getSIMDInstructionSet() == InstructionSet_SSE2)
-            {
-                info->internalIntCount = 1;
-                info->setInternalCandidates(lsra, lsra->allRegs(TYP_INT));
-            }
-
-            break;
-
-        case SIMDIntrinsicCast:
-            info->srcCount = 1;
-            break;
-
-        case SIMDIntrinsicShuffleSSE2:
-            info->srcCount = 2;
-            // Second operand is an integer constant and marked as contained.
-            op2 = tree->gtOp.gtOp2;
-            noway_assert(op2->IsCnsIntOrI());
-            MakeSrcContained(tree, op2);
-            break;
-
-        case SIMDIntrinsicGetX:
-        case SIMDIntrinsicGetY:
-        case SIMDIntrinsicGetZ:
-        case SIMDIntrinsicGetW:
-        case SIMDIntrinsicGetOne:
-        case SIMDIntrinsicGetZero:
-        case SIMDIntrinsicGetCount:
-        case SIMDIntrinsicGetAllOnes:
-            assert(!"Get intrinsics should not be seen during Lowering.");
-            unreached();
-
-        default:
-            noway_assert(!"Unimplemented SIMD node type.");
-            unreached();
-    }
-}
-#endif // FEATURE_SIMD
-
-//------------------------------------------------------------------------
-// TreeNodeInfoInitCast: Set the NodeInfo for a GT_CAST.
-//
-// Arguments:
-//    tree      - The node of interest
-//
-// Return Value:
-//    None.
-//
-void Lowering::TreeNodeInfoInitCast(GenTree* tree)
-{
-    TreeNodeInfo* info = &(tree->gtLsraInfo);
-
-    // TODO-XArch-CQ: Int-To-Int conversions - castOp cannot be a memory op and must have an assigned register.
-    //         see CodeGen::genIntToIntCast()
-
-    info->srcCount = 1;
-    info->dstCount = 1;
-
-    // Non-overflow casts to/from float/double are done using SSE2 instructions
-    // and that allow the source operand to be either a reg or memop. Given the
-    // fact that casts from small int to float/double are done as two-level casts,
-    // the source operand is always guaranteed to be of size 4 or 8 bytes.
-    var_types  castToType = tree->CastToType();
-    GenTreePtr castOp     = tree->gtCast.CastOp();
-    var_types  castOpType = castOp->TypeGet();
-    if (tree->gtFlags & GTF_UNSIGNED)
-    {
-        castOpType = genUnsignedType(castOpType);
-    }
-
-    if (!tree->gtOverflow() && (varTypeIsFloating(castToType) || varTypeIsFloating(castOpType)))
-    {
-#ifdef DEBUG
-        // If converting to float/double, the operand must be 4 or 8 byte in size.
-        if (varTypeIsFloating(castToType))
-        {
-            unsigned opSize = genTypeSize(castOpType);
-            assert(opSize == 4 || opSize == 8);
-        }
-#endif // DEBUG
-
-        // U8 -> R8 conversion requires that the operand be in a register.
-        if (castOpType != TYP_ULONG)
-        {
-            if (castOp->isMemoryOp() || castOp->IsCnsNonZeroFltOrDbl())
-            {
-                MakeSrcContained(tree, castOp);
-            }
-            else
-            {
-                // Mark castOp as reg optional to indicate codegen
-                // can still generate code if it is on stack.
-                SetRegOptional(castOp);
-            }
-        }
-    }
-
-#if !defined(_TARGET_64BIT_)
-    if (varTypeIsLong(castOpType))
-    {
-        noway_assert(castOp->OperGet() == GT_LONG);
-        info->srcCount = 2;
-    }
-#endif // !defined(_TARGET_64BIT_)
-
-    // some overflow checks need a temp reg:
-    //  - GT_CAST from INT64/UINT64 to UINT32
-    if (tree->gtOverflow() && (castToType == TYP_UINT))
-    {
-        if (genTypeSize(castOpType) == 8)
-        {
-            // Here we don't need internal register to be different from targetReg,
-            // rather require it to be different from operand's reg.
-            info->internalIntCount = 1;
-        }
-    }
-}
-
-void Lowering::LowerGCWriteBarrier(GenTree* tree)
-{
-    assert(tree->OperGet() == GT_STOREIND);
-
-    GenTreeStoreInd* dst  = tree->AsStoreInd();
-    GenTreePtr       addr = dst->Addr();
-    GenTreePtr       src  = dst->Data();
-
-    if (addr->OperGet() == GT_LEA)
-    {
-        // In the case where we are doing a helper assignment, if the dst
-        // is an indir through an lea, we need to actually instantiate the
-        // lea in a register
-        GenTreeAddrMode* lea = addr->AsAddrMode();
-
-        int leaSrcCount = 0;
-        if (lea->HasBase())
-        {
-            leaSrcCount++;
-        }
-        if (lea->HasIndex())
-        {
-            leaSrcCount++;
-        }
-        lea->gtLsraInfo.srcCount = leaSrcCount;
-        lea->gtLsraInfo.dstCount = 1;
-    }
-
-    bool useOptimizedWriteBarrierHelper = false; // By default, assume no optimized write barriers.
-
-#if NOGC_WRITE_BARRIERS
-
-#if defined(_TARGET_X86_)
-
-    useOptimizedWriteBarrierHelper = true; // On x86, use the optimized write barriers by default.
-#ifdef DEBUG
-    GCInfo::WriteBarrierForm wbf = comp->codeGen->gcInfo.gcIsWriteBarrierCandidate(tree, src);
-    if (wbf == GCInfo::WBF_NoBarrier_CheckNotHeapInDebug) // This one is always a call to a C++ method.
-    {
-        useOptimizedWriteBarrierHelper = false;
-    }
-#endif
-
-    if (useOptimizedWriteBarrierHelper)
-    {
-        // Special write barrier:
-        // op1 (addr) goes into REG_WRITE_BARRIER (rdx) and
-        // op2 (src) goes into any int register.
-        addr->gtLsraInfo.setSrcCandidates(m_lsra, RBM_WRITE_BARRIER);
-        src->gtLsraInfo.setSrcCandidates(m_lsra, RBM_WRITE_BARRIER_SRC);
-    }
-
-#else // !defined(_TARGET_X86_)
-#error "NOGC_WRITE_BARRIERS is not supported"
-#endif // !defined(_TARGET_X86_)
-
-#endif // NOGC_WRITE_BARRIERS
-
-    if (!useOptimizedWriteBarrierHelper)
-    {
-        // For the standard JIT Helper calls:
-        // op1 (addr) goes into REG_ARG_0 and
-        // op2 (src) goes into REG_ARG_1
-        addr->gtLsraInfo.setSrcCandidates(m_lsra, RBM_ARG_0);
-        src->gtLsraInfo.setSrcCandidates(m_lsra, RBM_ARG_1);
-    }
-
-    // Both src and dst must reside in a register, which they should since we haven't set
-    // either of them as contained.
-    assert(addr->gtLsraInfo.dstCount == 1);
-    assert(src->gtLsraInfo.dstCount == 1);
-}
-
-//-----------------------------------------------------------------------------------------
-// Specify register requirements for address expression of an indirection operation.
-//
-// Arguments:
-//    indirTree    -   GT_IND or GT_STOREIND gentree node
-//
-void Lowering::SetIndirAddrOpCounts(GenTreePtr indirTree)
-{
-    assert(indirTree->isIndir());
-    // If this is the rhs of a block copy (i.e. non-enregisterable struct),
-    // it has no register requirements.
-    if (indirTree->TypeGet() == TYP_STRUCT)
-    {
-        return;
-    }
-
-    GenTreePtr    addr = indirTree->gtGetOp1();
-    TreeNodeInfo* info = &(indirTree->gtLsraInfo);
-
-    GenTreePtr base  = nullptr;
-    GenTreePtr index = nullptr;
-    unsigned   mul, cns;
-    bool       rev;
-
-#ifdef FEATURE_SIMD
-    // If indirTree is of TYP_SIMD12, don't mark addr as contained
-    // so that it always get computed to a register.  This would
-    // mean codegen side logic doesn't need to handle all possible
-    // addr expressions that could be contained.
-    //
-    // TODO-XArch-CQ: handle other addr mode expressions that could be marked
-    // as contained.
-    if (indirTree->TypeGet() == TYP_SIMD12)
-    {
-        // Vector3 is read/written as two reads/writes: 8 byte and 4 byte.
-        // To assemble the vector properly we would need an additional
-        // XMM register.
-        info->internalFloatCount = 1;
-
-        // In case of GT_IND we need an internal register different from targetReg and
-        // both of the registers are used at the same time.
-        if (indirTree->OperGet() == GT_IND)
-        {
-            info->isInternalRegDelayFree = true;
-        }
-
-        info->setInternalCandidates(m_lsra, m_lsra->allSIMDRegs());
-
-        return;
-    }
-#endif // FEATURE_SIMD
-
-    if ((indirTree->gtFlags & GTF_IND_REQ_ADDR_IN_REG) != 0)
-    {
-        // The address of an indirection that requires its address in a reg.
-        // Skip any further processing that might otherwise make it contained.
-    }
-    else if ((addr->OperGet() == GT_CLS_VAR_ADDR) || (addr->OperGet() == GT_LCL_VAR_ADDR))
-    {
-        // These nodes go into an addr mode:
-        // - GT_CLS_VAR_ADDR turns into a constant.
-        // - GT_LCL_VAR_ADDR is a stack addr mode.
-
-        // make this contained, it turns into a constant that goes into an addr mode
-        MakeSrcContained(indirTree, addr);
-    }
-    else if (addr->IsCnsIntOrI() && addr->AsIntConCommon()->FitsInAddrBase(comp))
-    {
-        // Amd64:
-        // We can mark any pc-relative 32-bit addr as containable, except for a direct VSD call address.
-        // (i.e. those VSD calls for which stub addr is known during JIT compilation time).  In this case,
-        // VM requires us to pass stub addr in REG_VIRTUAL_STUB_PARAM - see LowerVirtualStubCall().  For
-        // that reason we cannot mark such an addr as contained.  Note that this is not an issue for
-        // indirect VSD calls since morphArgs() is explicitly materializing hidden param as a non-standard
-        // argument.
-        //
-        // Workaround:
-        // Note that LowerVirtualStubCall() sets addr->gtRegNum to REG_VIRTUAL_STUB_PARAM and Lowering::doPhase()
-        // sets destination candidates on such nodes and resets addr->gtRegNum to REG_NA before calling
-        // TreeNodeInfoInit(). Ideally we should set a flag on addr nodes that shouldn't be marked as contained
-        // (in LowerVirtualStubCall()), but we don't have any GTF_* flags left for that purpose.  As a workaround
-        // an explicit check is made here.
-        //
-        // On x86, direct VSD is done via a relative branch, and in fact it MUST be contained.
-        MakeSrcContained(indirTree, addr);
-    }
-    else if ((addr->OperGet() == GT_LEA) && IsSafeToContainMem(indirTree, addr))
-    {
-        MakeSrcContained(indirTree, addr);
-    }
-    else if (comp->codeGen->genCreateAddrMode(addr, -1, true, 0, &rev, &base, &index, &mul, &cns, true /*nogen*/) &&
-             !AreSourcesPossiblyModifiedLocals(indirTree, base, index))
-    {
-        // An addressing mode will be constructed that may cause some
-        // nodes to not need a register, and cause others' lifetimes to be extended
-        // to the GT_IND or even its parent if it's an assignment
-
-        assert(base != addr);
-        m_lsra->clearOperandCounts(addr);
-
-        const bool hasBase  = base != nullptr;
-        const bool hasIndex = index != nullptr;
-        assert(hasBase || hasIndex); // At least one of a base or an index must be present.
-
-        // If the addressing mode has both a base and an index, bump its source count by one. If it only has one or the
-        // other, its source count is already correct (due to the source for the address itself).
-        if (hasBase && hasIndex)
-        {
-            info->srcCount++;
-        }
-
-        // Traverse the computation below GT_IND to find the operands
-        // for the addressing mode, marking the various constants and
-        // intermediate results as not consuming/producing.
-        // If the traversal were more complex, we might consider using
-        // a traversal function, but the addressing mode is only made
-        // up of simple arithmetic operators, and the code generator
-        // only traverses one leg of each node.
-
-        bool foundBase  = !hasBase;
-        bool foundIndex = !hasIndex;
-        for (GenTree *child = addr, *nextChild = nullptr; child != nullptr && !child->OperIsLeaf(); child = nextChild)
-        {
-            nextChild    = nullptr;
-            GenTree* op1 = child->gtOp.gtOp1;
-            GenTree* op2 = (child->OperIsBinary()) ? child->gtOp.gtOp2 : nullptr;
-
-            if (op1 == base)
-            {
-                foundBase = true;
-            }
-            else if (op1 == index)
-            {
-                foundIndex = true;
-            }
-            else
-            {
-                m_lsra->clearOperandCounts(op1);
-                if (!op1->OperIsLeaf())
-                {
-                    nextChild = op1;
-                }
-            }
-
-            if (op2 != nullptr)
-            {
-                if (op2 == base)
-                {
-                    foundBase = true;
-                }
-                else if (op2 == index)
-                {
-                    foundIndex = true;
-                }
-                else
-                {
-                    m_lsra->clearOperandCounts(op2);
-                    if (!op2->OperIsLeaf())
-                    {
-                        assert(nextChild == nullptr);
-                        nextChild = op2;
-                    }
-                }
-            }
-        }
-        assert(foundBase && foundIndex);
-    }
-    else if (addr->gtOper == GT_ARR_ELEM)
-    {
-        // The GT_ARR_ELEM consumes all the indices and produces the offset.
-        // The array object lives until the mem access.
-        // We also consume the target register to which the address is
-        // computed
-
-        info->srcCount++;
-        assert(addr->gtLsraInfo.srcCount >= 2);
-        addr->gtLsraInfo.srcCount -= 1;
-    }
-}
-
-void Lowering::TreeNodeInfoInitCmp(GenTreePtr tree)
-{
-    assert(tree->OperIsCompare());
-
-    TreeNodeInfo* info = &(tree->gtLsraInfo);
-
-    info->srcCount = 2;
-    info->dstCount = 1;
-
-#ifdef _TARGET_X86_
-    // If the compare is used by a jump, we just need to set the condition codes. If not, then we need
-    // to store the result into the low byte of a register, which requires the dst be a byteable register.
-    // We always set the dst candidates, though, because if this is compare is consumed by a jump, they
-    // won't be used. We might be able to use GTF_RELOP_JMP_USED to determine this case, but it's not clear
-    // that flag is maintained until this location (especially for decomposed long compares).
-    info->setDstCandidates(m_lsra, RBM_BYTE_REGS);
-#endif // _TARGET_X86_
-
-    GenTreePtr op1     = tree->gtOp.gtOp1;
-    GenTreePtr op2     = tree->gtOp.gtOp2;
-    var_types  op1Type = op1->TypeGet();
-    var_types  op2Type = op2->TypeGet();
-
-#if !defined(_TARGET_64BIT_)
-    // Long compares will consume GT_LONG nodes, each of which produces two results.
-    // Thus for each long operand there will be an additional source.
-    // TODO-X86-CQ: Mark hiOp2 and loOp2 as contained if it is a constant or a memory op.
-    if (varTypeIsLong(op1Type))
-    {
-        info->srcCount++;
-    }
-    if (varTypeIsLong(op2Type))
-    {
-        info->srcCount++;
-    }
-#endif // !defined(_TARGET_64BIT_)
-
-    // If either of op1 or op2 is floating point values, then we need to use
-    // ucomiss or ucomisd to compare, both of which support the following form:
-    //     ucomis[s|d] xmm, xmm/mem
-    // That is only the second operand can be a memory op.
-    //
-    // Second operand is a memory Op:  Note that depending on comparison operator,
-    // the operands of ucomis[s|d] need to be reversed.  Therefore, either op1 or
-    // op2 can be a memory op depending on the comparison operator.
-    if (varTypeIsFloating(op1Type))
-    {
-        // The type of the operands has to be the same and no implicit conversions at this stage.
-        assert(op1Type == op2Type);
-
-        bool reverseOps;
-        if ((tree->gtFlags & GTF_RELOP_NAN_UN) != 0)
-        {
-            // Unordered comparison case
-            reverseOps = tree->OperIs(GT_GT, GT_GE);
-        }
-        else
-        {
-            reverseOps = tree->OperIs(GT_LT, GT_LE);
-        }
-
-        GenTreePtr otherOp;
-        if (reverseOps)
-        {
-            otherOp = op1;
-        }
-        else
-        {
-            otherOp = op2;
-        }
-
-        assert(otherOp != nullptr);
-        if (otherOp->IsCnsNonZeroFltOrDbl())
-        {
-            MakeSrcContained(tree, otherOp);
-        }
-        else if (otherOp->isMemoryOp() && ((otherOp == op2) || IsSafeToContainMem(tree, otherOp)))
-        {
-            MakeSrcContained(tree, otherOp);
-        }
-        else
-        {
-            // SSE2 allows only otherOp to be a memory-op. Since otherOp is not
-            // contained, we can mark it reg-optional.
-            SetRegOptional(otherOp);
-        }
-
-        return;
-    }
-
-    // TODO-XArch-CQ: factor out cmp optimization in 'genCondSetFlags' to be used here
-    // or in other backend.
-
-    if (CheckImmedAndMakeContained(tree, op2))
-    {
-        // If the types are the same, or if the constant is of the correct size,
-        // we can treat the isMemoryOp as contained.
-        if (op1Type == op2Type)
-        {
-            if (op1->isMemoryOp())
-            {
-                MakeSrcContained(tree, op1);
-            }
-            // If op1 codegen sets ZF and SF flags and ==/!= against
-            // zero, we don't need to generate test instruction,
-            // provided we don't have another GenTree node between op1
-            // and tree that could potentially modify flags.
-            //
-            // TODO-CQ: right now the below peep is inexpensive and
-            // gets the benefit in most of cases because in majority
-            // of cases op1, op2 and tree would be in that order in
-            // execution.  In general we should be able to check that all
-            // the nodes that come after op1 in execution order do not
-            // modify the flags so that it is safe to avoid generating a
-            // test instruction.  Such a check requires that on each
-            // GenTree node we need to set the info whether its codegen
-            // will modify flags.
-            //
-            // TODO-CQ: We can optimize compare against zero in the
-            // following cases by generating the branch as indicated
-            // against each case.
-            //  1) unsigned compare
-            //        < 0  - always FALSE
-            //       <= 0  - ZF=1 and jne
-            //        > 0  - ZF=0 and je
-            //       >= 0  - always TRUE
-            //
-            // 2) signed compare
-            //        < 0  - SF=1 and js
-            //       >= 0  - SF=0 and jns
-            else if (tree->OperIs(GT_EQ, GT_NE) && op1->gtSetZSFlags() && op2->IsIntegralConst(0) &&
-                     (op1->gtNext == op2) && (op2->gtNext == tree))
-            {
-                // Require codegen of op1 to set the flags.
-                assert(!op1->gtSetFlags());
-                op1->gtFlags |= GTF_SET_FLAGS;
-            }
-            else
-            {
-                SetRegOptional(op1);
-            }
-        }
-    }
-    else if (op1Type == op2Type)
-    {
-        // Note that TEST does not have a r,rm encoding like CMP has but we can still
-        // contain the second operand because the emitter maps both r,rm and rm,r to
-        // the same instruction code. This avoids the need to special case TEST here.
-        if (op2->isMemoryOp())
-        {
-            MakeSrcContained(tree, op2);
-        }
-        else if (op1->isMemoryOp() && IsSafeToContainMem(tree, op1))
-        {
-            MakeSrcContained(tree, op1);
-        }
-        else if (op1->IsCnsIntOrI())
-        {
-            // TODO-CQ: We should be able to support swapping op1 and op2 to generate cmp reg, imm,
-            // but there is currently an assert in CodeGen::genCompareInt().
-            // https://github.com/dotnet/coreclr/issues/7270
-            SetRegOptional(op2);
-        }
-        else
-        {
-            // One of op1 or op2 could be marked as reg optional
-            // to indicate that codegen can still generate code
-            // if one of them is on stack.
-            SetRegOptional(PreferredRegOptionalOperand(tree));
-        }
-    }
-}
-
 /* Lower GT_CAST(srcType, DstType) nodes.
  *
  * Casts from small int type to float/double are transformed as follows:
@@ -3969,337 +950,6 @@ bool Lowering::IsRMWMemOpRootedAtStoreInd(GenTreePtr tree, GenTreePtr* outIndirC
     return true;
 }
 
-//--------------------------------------------------------------------------------------------
-// SetStoreIndOpCountsIfRMWMemOp checks to see if there is a RMW memory operation rooted at
-// GT_STOREIND node and if so will mark register requirements for nodes under storeInd so
-// that CodeGen will generate a single instruction of the form:
-//
-//         binOp [addressing mode], reg
-//
-// Parameters
-//         storeInd   - GT_STOREIND node
-//
-// Return value
-//         True, if RMW memory op tree pattern is recognized and op counts are set.
-//         False otherwise.
-//
-bool Lowering::SetStoreIndOpCountsIfRMWMemOp(GenTreePtr storeInd)
-{
-    assert(storeInd->OperGet() == GT_STOREIND);
-
-    // SSE2 doesn't support RMW on float values
-    assert(!varTypeIsFloating(storeInd));
-
-    // Terminology:
-    // indirDst = memory write of an addr mode  (i.e. storeind destination)
-    // indirSrc = value being written to memory (i.e. storeind source which could a binary/unary op)
-    // indirCandidate = memory read i.e. a gtInd of an addr mode
-    // indirOpSource = source operand used in binary/unary op (i.e. source operand of indirSrc node)
-
-    GenTreePtr indirCandidate = nullptr;
-    GenTreePtr indirOpSource  = nullptr;
-
-    if (!IsRMWMemOpRootedAtStoreInd(storeInd, &indirCandidate, &indirOpSource))
-    {
-        JITDUMP("Lower of StoreInd didn't mark the node as self contained for reason: %d\n",
-                storeInd->AsStoreInd()->GetRMWStatus());
-        DISPTREERANGE(BlockRange(), storeInd);
-        return false;
-    }
-
-    GenTreePtr indirDst = storeInd->gtGetOp1();
-    GenTreePtr indirSrc = storeInd->gtGetOp2();
-    genTreeOps oper     = indirSrc->OperGet();
-
-    // At this point we have successfully detected a RMW memory op of one of the following forms
-    //         storeInd(indirDst, indirSrc(indirCandidate, indirOpSource)) OR
-    //         storeInd(indirDst, indirSrc(indirOpSource, indirCandidate) in case of commutative operations OR
-    //         storeInd(indirDst, indirSrc(indirCandidate) in case of unary operations
-    //
-    // Here indirSrc = one of the supported binary or unary operation for RMW of memory
-    //      indirCandidate = a GT_IND node
-    //      indirCandidateChild = operand of GT_IND indirCandidate
-    //
-    // The logic below essentially does the following
-    //      set storeInd src count to that of the dst count of indirOpSource
-    //      clear operand counts on indirSrc  (i.e. marked as contained and storeInd will generate code for it)
-    //      clear operand counts on indirCandidate
-    //      clear operand counts on indirDst except when it is a GT_LCL_VAR or GT_CNS_INT that doesn't fit within addr
-    //      base
-    //      Increment src count of storeInd to account for the registers required to form indirDst addr mode
-    //      clear operand counts on indirCandidateChild
-
-    TreeNodeInfo* info = &(storeInd->gtLsraInfo);
-    info->dstCount     = 0;
-
-    if (GenTree::OperIsBinary(oper))
-    {
-        // On Xarch RMW operations require that the source memory-op be in a register.
-        assert(!indirOpSource->isMemoryOp() || indirOpSource->gtLsraInfo.dstCount == 1);
-        JITDUMP("Lower succesfully detected an assignment of the form: *addrMode BinOp= source\n");
-        info->srcCount = indirOpSource->gtLsraInfo.dstCount;
-    }
-    else
-    {
-        assert(GenTree::OperIsUnary(oper));
-        JITDUMP("Lower succesfully detected an assignment of the form: *addrMode = UnaryOp(*addrMode)\n");
-        info->srcCount = 0;
-    }
-    DISPTREERANGE(BlockRange(), storeInd);
-
-    m_lsra->clearOperandCounts(indirSrc);
-    m_lsra->clearOperandCounts(indirCandidate);
-
-    GenTreePtr indirCandidateChild = indirCandidate->gtGetOp1();
-    if (indirCandidateChild->OperGet() == GT_LEA)
-    {
-        GenTreeAddrMode* addrMode = indirCandidateChild->AsAddrMode();
-
-        if (addrMode->HasBase())
-        {
-            assert(addrMode->Base()->OperIsLeaf());
-            m_lsra->clearOperandCounts(addrMode->Base());
-            info->srcCount++;
-        }
-
-        if (addrMode->HasIndex())
-        {
-            assert(addrMode->Index()->OperIsLeaf());
-            m_lsra->clearOperandCounts(addrMode->Index());
-            info->srcCount++;
-        }
-
-        m_lsra->clearOperandCounts(indirDst);
-    }
-    else
-    {
-        assert(indirCandidateChild->OperGet() == GT_LCL_VAR || indirCandidateChild->OperGet() == GT_LCL_VAR_ADDR ||
-               indirCandidateChild->OperGet() == GT_CLS_VAR_ADDR || indirCandidateChild->OperGet() == GT_CNS_INT);
-
-        // If it is a GT_LCL_VAR, it still needs the reg to hold the address.
-        // We would still need a reg for GT_CNS_INT if it doesn't fit within addressing mode base.
-        // For GT_CLS_VAR_ADDR, we don't need a reg to hold the address, because field address value is known at jit
-        // time. Also, we don't need a reg for GT_CLS_VAR_ADDR.
-        if (indirCandidateChild->OperGet() == GT_LCL_VAR_ADDR || indirCandidateChild->OperGet() == GT_CLS_VAR_ADDR)
-        {
-            m_lsra->clearOperandCounts(indirDst);
-        }
-        else if (indirCandidateChild->IsCnsIntOrI() && indirCandidateChild->AsIntConCommon()->FitsInAddrBase(comp))
-        {
-            m_lsra->clearOperandCounts(indirDst);
-        }
-        else
-        {
-            // Need a reg and hence increment src count of storeind
-            info->srcCount += indirCandidateChild->gtLsraInfo.dstCount;
-        }
-    }
-    m_lsra->clearOperandCounts(indirCandidateChild);
-
-#ifdef _TARGET_X86_
-    if (varTypeIsByte(storeInd))
-    {
-        // If storeInd is of TYP_BYTE, set indirOpSources to byteable registers.
-        bool containedNode = indirOpSource->gtLsraInfo.dstCount == 0;
-        if (!containedNode)
-        {
-            regMaskTP regMask = indirOpSource->gtLsraInfo.getSrcCandidates(m_lsra);
-            assert(regMask != RBM_NONE);
-            indirOpSource->gtLsraInfo.setSrcCandidates(m_lsra, regMask & ~RBM_NON_BYTE_REGS);
-        }
-    }
-#endif
-
-    return true;
-}
-
-/**
- * Takes care of annotating the src and dst register
- * requirements for a GT_MUL treenode.
- */
-void Lowering::SetMulOpCounts(GenTreePtr tree)
-{
-#if defined(_TARGET_X86_)
-    assert(tree->OperGet() == GT_MUL || tree->OperGet() == GT_MULHI || tree->OperGet() == GT_MUL_LONG);
-#else
-    assert(tree->OperGet() == GT_MUL || tree->OperGet() == GT_MULHI);
-#endif
-    TreeNodeInfo* info = &(tree->gtLsraInfo);
-
-    info->srcCount = 2;
-    info->dstCount = 1;
-
-    GenTreePtr op1 = tree->gtOp.gtOp1;
-    GenTreePtr op2 = tree->gtOp.gtOp2;
-
-    // Case of float/double mul.
-    if (varTypeIsFloating(tree->TypeGet()))
-    {
-        assert(tree->OperGet() == GT_MUL);
-
-        if (op2->isMemoryOp() || op2->IsCnsNonZeroFltOrDbl())
-        {
-            MakeSrcContained(tree, op2);
-        }
-        else if (op1->IsCnsNonZeroFltOrDbl() || (op1->isMemoryOp() && IsSafeToContainMem(tree, op1)))
-        {
-            // Since  GT_MUL is commutative, we will try to re-order operands if it is safe to
-            // generate more efficient code sequence for the case of GT_MUL(op1=memOp, op2=non-memOp)
-            MakeSrcContained(tree, op1);
-        }
-        else
-        {
-            // If there are no containable operands, we can make an operand reg optional.
-            SetRegOptionalForBinOp(tree);
-        }
-        return;
-    }
-
-    bool       isUnsignedMultiply    = ((tree->gtFlags & GTF_UNSIGNED) != 0);
-    bool       requiresOverflowCheck = tree->gtOverflowEx();
-    bool       useLeaEncoding        = false;
-    GenTreePtr memOp                 = nullptr;
-
-    bool                 hasImpliedFirstOperand = false;
-    GenTreeIntConCommon* imm                    = nullptr;
-    GenTreePtr           other                  = nullptr;
-
-// There are three forms of x86 multiply:
-// one-op form:     RDX:RAX = RAX * r/m
-// two-op form:     reg *= r/m
-// three-op form:   reg = r/m * imm
-
-// This special widening 32x32->64 MUL is not used on x64
-#if defined(_TARGET_X86_)
-    if (tree->OperGet() != GT_MUL_LONG)
-#endif
-    {
-        assert((tree->gtFlags & GTF_MUL_64RSLT) == 0);
-    }
-
-    // Multiply should never be using small types
-    assert(!varTypeIsSmall(tree->TypeGet()));
-
-    // We do use the widening multiply to implement
-    // the overflow checking for unsigned multiply
-    //
-    if (isUnsignedMultiply && requiresOverflowCheck)
-    {
-        // The only encoding provided is RDX:RAX = RAX * rm
-        //
-        // Here we set RAX as the only destination candidate
-        // In LSRA we set the kill set for this operation to RBM_RAX|RBM_RDX
-        //
-        info->setDstCandidates(m_lsra, RBM_RAX);
-        hasImpliedFirstOperand = true;
-    }
-    else if (tree->OperGet() == GT_MULHI)
-    {
-        // Have to use the encoding:RDX:RAX = RAX * rm. Since we only care about the
-        // upper 32 bits of the result set the destination candidate to REG_RDX.
-        info->setDstCandidates(m_lsra, RBM_RDX);
-        hasImpliedFirstOperand = true;
-    }
-#if defined(_TARGET_X86_)
-    else if (tree->OperGet() == GT_MUL_LONG)
-    {
-        // have to use the encoding:RDX:RAX = RAX * rm
-        info->setDstCandidates(m_lsra, RBM_RAX);
-        hasImpliedFirstOperand = true;
-    }
-#endif
-    else if (IsContainableImmed(tree, op2) || IsContainableImmed(tree, op1))
-    {
-        if (IsContainableImmed(tree, op2))
-        {
-            imm   = op2->AsIntConCommon();
-            other = op1;
-        }
-        else
-        {
-            imm   = op1->AsIntConCommon();
-            other = op2;
-        }
-
-        // CQ: We want to rewrite this into a LEA
-        ssize_t immVal = imm->AsIntConCommon()->IconValue();
-        if (!requiresOverflowCheck && (immVal == 3 || immVal == 5 || immVal == 9))
-        {
-            useLeaEncoding = true;
-        }
-
-        MakeSrcContained(tree, imm); // The imm is always contained
-        if (other->isMemoryOp())
-        {
-            memOp = other; // memOp may be contained below
-        }
-    }
-
-    // We allow one operand to be a contained memory operand.
-    // The memory op type must match with the 'tree' type.
-    // This is because during codegen we use 'tree' type to derive EmitTypeSize.
-    // E.g op1 type = byte, op2 type = byte but GT_MUL tree type is int.
-    //
-    if (memOp == nullptr && op2->isMemoryOp())
-    {
-        memOp = op2;
-    }
-
-    // To generate an LEA we need to force memOp into a register
-    // so don't allow memOp to be 'contained'
-    //
-    if (!useLeaEncoding)
-    {
-        if ((memOp != nullptr) && (memOp->TypeGet() == tree->TypeGet()) && IsSafeToContainMem(tree, memOp))
-        {
-            MakeSrcContained(tree, memOp);
-        }
-        else if (imm != nullptr)
-        {
-            // Has a contained immediate operand.
-            // Only 'other' operand can be marked as reg optional.
-            assert(other != nullptr);
-            SetRegOptional(other);
-        }
-        else if (hasImpliedFirstOperand)
-        {
-            // Only op2 can be marke as reg optional.
-            SetRegOptional(op2);
-        }
-        else
-        {
-            // If there are no containable operands, we can make either of op1 or op2
-            // as reg optional.
-            SetRegOptionalForBinOp(tree);
-        }
-    }
-}
-
-//------------------------------------------------------------------------------
-// SetContainsAVXFlags: Set ContainsAVX flag when it is floating type, set
-// Contains256bitAVX flag when SIMD vector size is 32 bytes
-//
-// Arguments:
-//    isFloatingPointType   - true if it is floating point type
-//    sizeOfSIMDVector      - SIMD Vector size
-//
-void Lowering::SetContainsAVXFlags(bool isFloatingPointType /* = true */, unsigned sizeOfSIMDVector /* = 0*/)
-{
-#ifdef FEATURE_AVX_SUPPORT
-    if (isFloatingPointType)
-    {
-        if (comp->getFloatingPointInstructionSet() == InstructionSet_AVX)
-        {
-            comp->getEmitter()->SetContainsAVX(true);
-        }
-        if (sizeOfSIMDVector == 32 && comp->getSIMDInstructionSet() == InstructionSet_AVX)
-        {
-            comp->getEmitter()->SetContains256bitAVX(true);
-        }
-    }
-#endif
-}
-
 //------------------------------------------------------------------------------
 // isRMWRegOper: Can this binary tree node be used in a Read-Modify-Write format
 //
@@ -4490,71 +1140,6 @@ GenTree* Lowering::PreferredRegOptionalOperand(GenTree* tree)
     return preferredOp;
 }
 
-#ifdef _TARGET_X86_
-//------------------------------------------------------------------------
-// ExcludeNonByteableRegisters: Determines if we need to exclude non-byteable registers for
-// various reasons
-//
-// Arguments:
-//    tree      - The node of interest
-//
-// Return Value:
-//    If we need to exclude non-byteable registers
-//
-bool Lowering::ExcludeNonByteableRegisters(GenTree* tree)
-{
-    // Example1: GT_STOREIND(byte, addr, op2) - storeind of byte sized value from op2 into mem 'addr'
-    // Storeind itself will not produce any value and hence dstCount=0. But op2 could be TYP_INT
-    // value. In this case we need to exclude esi/edi from the src candidates of op2.
-    if (varTypeIsByte(tree))
-    {
-        return true;
-    }
-    // Example2: GT_CAST(int <- bool <- int) - here type of GT_CAST node is int and castToType is bool.
-    else if ((tree->OperGet() == GT_CAST) && varTypeIsByte(tree->CastToType()))
-    {
-        return true;
-    }
-    else if (tree->OperIsCompare())
-    {
-        GenTree* op1 = tree->gtGetOp1();
-        GenTree* op2 = tree->gtGetOp2();
-
-        // Example3: GT_EQ(int, op1 of type ubyte, op2 of type ubyte) - in this case codegen uses
-        // ubyte as the result of comparison and if the result needs to be materialized into a reg
-        // simply zero extend it to TYP_INT size.  Here is an example of generated code:
-        //         cmp dl, byte ptr[addr mode]
-        //         movzx edx, dl
-        if (varTypeIsByte(op1) && varTypeIsByte(op2))
-        {
-            return true;
-        }
-        // Example4: GT_EQ(int, op1 of type ubyte, op2 is GT_CNS_INT) - in this case codegen uses
-        // ubyte as the result of the comparison and if the result needs to be materialized into a reg
-        // simply zero extend it to TYP_INT size.
-        else if (varTypeIsByte(op1) && op2->IsCnsIntOrI())
-        {
-            return true;
-        }
-        // Example4: GT_EQ(int, op1 is GT_CNS_INT, op2 of type ubyte) - in this case codegen uses
-        // ubyte as the result of the comparison and if the result needs to be materialized into a reg
-        // simply zero extend it to TYP_INT size.
-        else if (op1->IsCnsIntOrI() && varTypeIsByte(op2))
-        {
-            return true;
-        }
-        else
-        {
-            return false;
-        }
-    }
-    else
-    {
-        return false;
-    }
-}
-#endif // _TARGET_X86_
-
 #endif // _TARGET_XARCH_
 
 #endif // !LEGACY_BACKEND
diff --git a/src/jit/lsra.cpp b/src/jit/lsra.cpp
index 006d6a0dea..ac76e29364 100644
--- a/src/jit/lsra.cpp
+++ b/src/jit/lsra.cpp
@@ -3417,7 +3417,7 @@ static int ComputeOperandDstCount(GenTree* operand)
 // ComputeAvailableSrcCount: computes the number of registers available as
 //                           sources for a node.
 //
-// This is simply the sum of the number of registers prduced by each
+// This is simply the sum of the number of registers produced by each
 // operand to the node.
 //
 // Arguments:
@@ -3436,7 +3436,7 @@ static int ComputeAvailableSrcCount(GenTree* node)
 
     return numSources;
 }
-#endif
+#endif // DEBUG
 
 void LinearScan::buildRefPositionsForNode(GenTree*                  tree,
                                           BasicBlock*               block,
diff --git a/src/jit/lsraarm.cpp b/src/jit/lsraarm.cpp
new file mode 100644
index 0000000000..a347139cb4
--- /dev/null
+++ b/src/jit/lsraarm.cpp
@@ -0,0 +1,1105 @@
+// 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.
+
+/*XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+XX                                                                           XX
+XX                     Register Requirements for ARM                         XX
+XX                                                                           XX
+XX  This encapsulates all the logic for setting register requirements for    XX
+XX  the ARM  architecture.                                                   XX
+XX                                                                           XX
+XX                                                                           XX
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+*/
+
+#include "jitpch.h"
+#ifdef _MSC_VER
+#pragma hdrstop
+#endif
+
+#ifndef LEGACY_BACKEND // This file is ONLY used for the RyuJIT backend that uses the linear scan register allocator
+
+#ifdef _TARGET_ARM_
+
+#include "jit.h"
+#include "sideeffects.h"
+#include "lower.h"
+#include "lsra.h"
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitStoreLoc: Lower a store of a lclVar
+//
+// Arguments:
+//    storeLoc - the local store (GT_STORE_LCL_FLD or GT_STORE_LCL_VAR)
+//
+// Notes:
+//    This involves:
+//    - Setting the appropriate candidates for a store of a multi-reg call return value.
+//    - Handling of contained immediates and widening operations of unsigneds.
+//
+void Lowering::TreeNodeInfoInitStoreLoc(GenTreeLclVarCommon* storeLoc)
+{
+    TreeNodeInfo* info = &(storeLoc->gtLsraInfo);
+
+    // Is this the case of var = call where call is returning
+    // a value in multiple return registers?
+    GenTree* op1 = storeLoc->gtGetOp1();
+    if (op1->IsMultiRegCall())
+    {
+        // backend expects to see this case only for store lclvar.
+        assert(storeLoc->OperGet() == GT_STORE_LCL_VAR);
+
+        // srcCount = number of registers in which the value is returned by call
+        GenTreeCall*    call        = op1->AsCall();
+        ReturnTypeDesc* retTypeDesc = call->GetReturnTypeDesc();
+        info->srcCount              = retTypeDesc->GetReturnRegCount();
+
+        // Call node srcCandidates = Bitwise-OR(allregs(GetReturnRegType(i))) for all i=0..RetRegCount-1
+        regMaskTP srcCandidates = m_lsra->allMultiRegCallNodeRegs(call);
+        op1->gtLsraInfo.setSrcCandidates(m_lsra, srcCandidates);
+        return;
+    }
+
+    CheckImmedAndMakeContained(storeLoc, op1);
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitCmp: Lower a GT comparison node.
+//
+// Arguments:
+//    tree - the node to lower
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitCmp(GenTreePtr tree)
+{
+    TreeNodeInfo* info = &(tree->gtLsraInfo);
+
+    info->srcCount = 2;
+    info->dstCount = 1;
+    CheckImmedAndMakeContained(tree, tree->gtOp.gtOp2);
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitGCWriteBarrier: GC lowering helper.
+//
+// Arguments:
+//    tree - the node to lower
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitGCWriteBarrier(GenTree* tree)
+{
+    GenTreePtr dst  = tree;
+    GenTreePtr addr = tree->gtOp.gtOp1;
+    GenTreePtr src  = tree->gtOp.gtOp2;
+
+    if (addr->OperGet() == GT_LEA)
+    {
+        // In the case where we are doing a helper assignment, if the dst
+        // is an indir through an lea, we need to actually instantiate the
+        // lea in a register
+        GenTreeAddrMode* lea = addr->AsAddrMode();
+
+        short leaSrcCount = 0;
+        if (lea->Base() != nullptr)
+        {
+            leaSrcCount++;
+        }
+        if (lea->Index() != nullptr)
+        {
+            leaSrcCount++;
+        }
+        lea->gtLsraInfo.srcCount = leaSrcCount;
+        lea->gtLsraInfo.dstCount = 1;
+    }
+
+#if NOGC_WRITE_BARRIERS
+    NYI_ARM("NOGC_WRITE_BARRIERS");
+#else
+    // For the standard JIT Helper calls
+    // op1 goes into REG_ARG_0 and
+    // op2 goes into REG_ARG_1
+    //
+    addr->gtLsraInfo.setSrcCandidates(m_lsra, RBM_ARG_0);
+    src->gtLsraInfo.setSrcCandidates(m_lsra, RBM_ARG_1);
+#endif // NOGC_WRITE_BARRIERS
+
+    // Both src and dst must reside in a register, which they should since we haven't set
+    // either of them as contained.
+    assert(addr->gtLsraInfo.dstCount == 1);
+    assert(src->gtLsraInfo.dstCount == 1);
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitIndir: Specify register requirements for address expression
+//                       of an indirection operation.
+//
+// Arguments:
+//    indirTree - GT_IND, GT_STOREIND, block node or GT_NULLCHECK gentree node
+//
+void Lowering::TreeNodeInfoInitIndir(GenTreePtr indirTree)
+{
+    assert(indirTree->OperIsIndir());
+    // If this is the rhs of a block copy (i.e. non-enregisterable struct),
+    // it has no register requirements.
+    if (indirTree->TypeGet() == TYP_STRUCT)
+    {
+        return;
+    }
+
+    GenTreePtr    addr = indirTree->gtGetOp1();
+    TreeNodeInfo* info = &(indirTree->gtLsraInfo);
+
+    GenTreePtr base  = nullptr;
+    GenTreePtr index = nullptr;
+    unsigned   cns   = 0;
+    unsigned   mul;
+    bool       rev;
+    bool       modifiedSources = false;
+
+    if ((addr->OperGet() == GT_LEA) && IsSafeToContainMem(indirTree, addr))
+    {
+        GenTreeAddrMode* lea = addr->AsAddrMode();
+        base                 = lea->Base();
+        index                = lea->Index();
+        cns                  = lea->gtOffset;
+
+        m_lsra->clearOperandCounts(addr);
+        // The srcCount is decremented because addr is now "contained",
+        // then we account for the base and index below, if they are non-null.
+        info->srcCount--;
+    }
+    else if (comp->codeGen->genCreateAddrMode(addr, -1, true, 0, &rev, &base, &index, &mul, &cns, true /*nogen*/) &&
+             !(modifiedSources = AreSourcesPossiblyModifiedLocals(indirTree, base, index)))
+    {
+        // An addressing mode will be constructed that may cause some
+        // nodes to not need a register, and cause others' lifetimes to be extended
+        // to the GT_IND or even its parent if it's an assignment
+
+        assert(base != addr);
+        m_lsra->clearOperandCounts(addr);
+
+        GenTreePtr arrLength = nullptr;
+
+        // Traverse the computation below GT_IND to find the operands
+        // for the addressing mode, marking the various constants and
+        // intermediate results as not consuming/producing.
+        // If the traversal were more complex, we might consider using
+        // a traversal function, but the addressing mode is only made
+        // up of simple arithmetic operators, and the code generator
+        // only traverses one leg of each node.
+
+        bool       foundBase  = (base == nullptr);
+        bool       foundIndex = (index == nullptr);
+        GenTreePtr nextChild  = nullptr;
+        for (GenTreePtr child = addr; child != nullptr && !child->OperIsLeaf(); child = nextChild)
+        {
+            nextChild      = nullptr;
+            GenTreePtr op1 = child->gtOp.gtOp1;
+            GenTreePtr op2 = (child->OperIsBinary()) ? child->gtOp.gtOp2 : nullptr;
+
+            if (op1 == base)
+            {
+                foundBase = true;
+            }
+            else if (op1 == index)
+            {
+                foundIndex = true;
+            }
+            else
+            {
+                m_lsra->clearOperandCounts(op1);
+                if (!op1->OperIsLeaf())
+                {
+                    nextChild = op1;
+                }
+            }
+
+            if (op2 != nullptr)
+            {
+                if (op2 == base)
+                {
+                    foundBase = true;
+                }
+                else if (op2 == index)
+                {
+                    foundIndex = true;
+                }
+                else
+                {
+                    m_lsra->clearOperandCounts(op2);
+                    if (!op2->OperIsLeaf())
+                    {
+                        assert(nextChild == nullptr);
+                        nextChild = op2;
+                    }
+                }
+            }
+        }
+        assert(foundBase && foundIndex);
+        info->srcCount--; // it gets incremented below.
+    }
+    else if (addr->gtOper == GT_ARR_ELEM)
+    {
+        // The GT_ARR_ELEM consumes all the indices and produces the offset.
+        // The array object lives until the mem access.
+        // We also consume the target register to which the address is
+        // computed
+
+        info->srcCount++;
+        assert(addr->gtLsraInfo.srcCount >= 2);
+        addr->gtLsraInfo.srcCount -= 1;
+    }
+    else
+    {
+        // it is nothing but a plain indir
+        info->srcCount--; // base gets added in below
+        base = addr;
+    }
+
+    if (base != nullptr)
+    {
+        info->srcCount++;
+    }
+
+    if (index != nullptr && !modifiedSources)
+    {
+        info->srcCount++;
+        info->internalIntCount++;
+    }
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitReturn: Set the NodeInfo for a GT_RETURN.
+//
+// Arguments:
+//    tree - The node of interest
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitReturn(GenTree* tree)
+{
+    TreeNodeInfo* info     = &(tree->gtLsraInfo);
+    LinearScan*   l        = m_lsra;
+    Compiler*     compiler = comp;
+
+    GenTree*  op1           = tree->gtGetOp1();
+    regMaskTP useCandidates = RBM_NONE;
+
+    info->srcCount = (tree->TypeGet() == TYP_VOID) ? 0 : 1;
+    info->dstCount = 0;
+
+    if (varTypeIsStruct(tree))
+    {
+        NYI_ARM("struct return");
+    }
+    else
+    {
+        // Non-struct type return - determine useCandidates
+        switch (tree->TypeGet())
+        {
+            case TYP_VOID:
+                useCandidates = RBM_NONE;
+                break;
+            case TYP_FLOAT:
+                useCandidates = RBM_FLOATRET;
+                break;
+            case TYP_DOUBLE:
+                useCandidates = RBM_DOUBLERET;
+                break;
+            case TYP_LONG:
+                useCandidates = RBM_LNGRET;
+                break;
+            default:
+                useCandidates = RBM_INTRET;
+                break;
+        }
+    }
+
+    if (useCandidates != RBM_NONE)
+    {
+        tree->gtOp.gtOp1->gtLsraInfo.setSrcCandidates(l, useCandidates);
+    }
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitCall: Set the NodeInfo for a call.
+//
+// Arguments:
+//    call - The call node of interest
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitCall(GenTreeCall* call)
+{
+    TreeNodeInfo*   info              = &(call->gtLsraInfo);
+    LinearScan*     l                 = m_lsra;
+    Compiler*       compiler          = comp;
+    bool            hasMultiRegRetVal = false;
+    ReturnTypeDesc* retTypeDesc       = nullptr;
+
+    info->srcCount = 0;
+    if (call->TypeGet() != TYP_VOID)
+    {
+        hasMultiRegRetVal = call->HasMultiRegRetVal();
+        if (hasMultiRegRetVal)
+        {
+            // dst count = number of registers in which the value is returned by call
+            retTypeDesc    = call->GetReturnTypeDesc();
+            info->dstCount = retTypeDesc->GetReturnRegCount();
+        }
+        else
+        {
+            info->dstCount = 1;
+        }
+    }
+    else
+    {
+        info->dstCount = 0;
+    }
+
+    GenTree* ctrlExpr = call->gtControlExpr;
+    if (call->gtCallType == CT_INDIRECT)
+    {
+        // either gtControlExpr != null or gtCallAddr != null.
+        // Both cannot be non-null at the same time.
+        assert(ctrlExpr == nullptr);
+        assert(call->gtCallAddr != nullptr);
+        ctrlExpr = call->gtCallAddr;
+    }
+
+    // set reg requirements on call target represented as control sequence.
+    if (ctrlExpr != nullptr)
+    {
+        // we should never see a gtControlExpr whose type is void.
+        assert(ctrlExpr->TypeGet() != TYP_VOID);
+
+        info->srcCount++;
+        // In case of fast tail implemented as jmp, make sure that gtControlExpr is
+        // computed into a register.
+        if (call->IsFastTailCall())
+        {
+            NYI_ARM("tail call");
+        }
+    }
+    else
+    {
+        info->internalIntCount = 1;
+    }
+
+    RegisterType registerType = call->TypeGet();
+
+    // Set destination candidates for return value of the call.
+    if (hasMultiRegRetVal)
+    {
+        assert(retTypeDesc != nullptr);
+        info->setDstCandidates(l, retTypeDesc->GetABIReturnRegs());
+    }
+    else if (varTypeIsFloating(registerType))
+    {
+        info->setDstCandidates(l, RBM_FLOATRET);
+    }
+    else if (registerType == TYP_LONG)
+    {
+        info->setDstCandidates(l, RBM_LNGRET);
+    }
+    else
+    {
+        info->setDstCandidates(l, RBM_INTRET);
+    }
+
+    // If there is an explicit this pointer, we don't want that node to produce anything
+    // as it is redundant
+    if (call->gtCallObjp != nullptr)
+    {
+        GenTreePtr thisPtrNode = call->gtCallObjp;
+
+        if (thisPtrNode->gtOper == GT_PUTARG_REG)
+        {
+            l->clearOperandCounts(thisPtrNode);
+            l->clearDstCount(thisPtrNode->gtOp.gtOp1);
+        }
+        else
+        {
+            l->clearDstCount(thisPtrNode);
+        }
+    }
+
+    // First, count reg args
+    bool callHasFloatRegArgs = false;
+
+    for (GenTreePtr list = call->gtCallLateArgs; list; list = list->MoveNext())
+    {
+        assert(list->OperIsList());
+
+        GenTreePtr argNode = list->Current();
+
+        fgArgTabEntryPtr curArgTabEntry = compiler->gtArgEntryByNode(call, argNode);
+        assert(curArgTabEntry);
+
+        if (curArgTabEntry->regNum == REG_STK)
+        {
+            // late arg that is not passed in a register
+            assert(argNode->gtOper == GT_PUTARG_STK);
+
+            TreeNodeInfoInitPutArgStk(argNode->AsPutArgStk(), curArgTabEntry);
+            continue;
+        }
+
+        var_types argType    = argNode->TypeGet();
+        bool      argIsFloat = varTypeIsFloating(argType);
+        callHasFloatRegArgs |= argIsFloat;
+
+        regNumber argReg = curArgTabEntry->regNum;
+        // We will setup argMask to the set of all registers that compose this argument
+        regMaskTP argMask = 0;
+
+        argNode = argNode->gtEffectiveVal();
+
+        // A GT_FIELD_LIST has a TYP_VOID, but is used to represent a multireg struct
+        if (varTypeIsStruct(argNode) || (argNode->gtOper == GT_FIELD_LIST))
+        {
+            GenTreePtr actualArgNode = argNode;
+            unsigned   originalSize  = 0;
+
+            if (argNode->gtOper == GT_FIELD_LIST)
+            {
+                // There could be up to 2-4 PUTARG_REGs in the list (3 or 4 can only occur for HFAs)
+                GenTreeFieldList* fieldListPtr = argNode->AsFieldList();
+
+                // Initailize the first register and the first regmask in our list
+                regNumber targetReg    = argReg;
+                regMaskTP targetMask   = genRegMask(targetReg);
+                unsigned  iterationNum = 0;
+                originalSize           = 0;
+
+                for (; fieldListPtr; fieldListPtr = fieldListPtr->Rest())
+                {
+                    GenTreePtr putArgRegNode = fieldListPtr->Current();
+                    assert(putArgRegNode->gtOper == GT_PUTARG_REG);
+                    GenTreePtr putArgChild = putArgRegNode->gtOp.gtOp1;
+
+                    originalSize += REGSIZE_BYTES; // 8 bytes
+
+                    // Record the register requirements for the GT_PUTARG_REG node
+                    putArgRegNode->gtLsraInfo.setDstCandidates(l, targetMask);
+                    putArgRegNode->gtLsraInfo.setSrcCandidates(l, targetMask);
+
+                    // To avoid redundant moves, request that the argument child tree be
+                    // computed in the register in which the argument is passed to the call.
+                    putArgChild->gtLsraInfo.setSrcCandidates(l, targetMask);
+
+                    // We consume one source for each item in this list
+                    info->srcCount++;
+                    iterationNum++;
+
+                    // Update targetReg and targetMask for the next putarg_reg (if any)
+                    targetReg  = genRegArgNext(targetReg);
+                    targetMask = genRegMask(targetReg);
+                }
+            }
+            else
+            {
+#ifdef DEBUG
+                compiler->gtDispTreeRange(BlockRange(), argNode);
+#endif
+                noway_assert(!"Unsupported TYP_STRUCT arg kind");
+            }
+
+            unsigned  slots          = ((unsigned)(roundUp(originalSize, REGSIZE_BYTES))) / REGSIZE_BYTES;
+            regNumber curReg         = argReg;
+            regNumber lastReg        = argIsFloat ? REG_ARG_FP_LAST : REG_ARG_LAST;
+            unsigned  remainingSlots = slots;
+
+            while (remainingSlots > 0)
+            {
+                argMask |= genRegMask(curReg);
+                remainingSlots--;
+
+                if (curReg == lastReg)
+                    break;
+
+                curReg = genRegArgNext(curReg);
+            }
+
+            // Struct typed arguments must be fully passed in registers (Reg/Stk split not allowed)
+            noway_assert(remainingSlots == 0);
+            argNode->gtLsraInfo.internalIntCount = 0;
+        }
+        else // A scalar argument (not a struct)
+        {
+            // We consume one source
+            info->srcCount++;
+
+            argMask |= genRegMask(argReg);
+            argNode->gtLsraInfo.setDstCandidates(l, argMask);
+            argNode->gtLsraInfo.setSrcCandidates(l, argMask);
+
+            if (argNode->gtOper == GT_PUTARG_REG)
+            {
+                GenTreePtr putArgChild = argNode->gtOp.gtOp1;
+
+                // To avoid redundant moves, request that the argument child tree be
+                // computed in the register in which the argument is passed to the call.
+                putArgChild->gtLsraInfo.setSrcCandidates(l, argMask);
+            }
+        }
+    }
+
+    // Now, count stack args
+    // Note that these need to be computed into a register, but then
+    // they're just stored to the stack - so the reg doesn't
+    // need to remain live until the call.  In fact, it must not
+    // because the code generator doesn't actually consider it live,
+    // so it can't be spilled.
+
+    GenTreePtr args = call->gtCallArgs;
+    while (args)
+    {
+        GenTreePtr arg = args->gtOp.gtOp1;
+
+        // Skip arguments that have been moved to the Late Arg list
+        if (!(args->gtFlags & GTF_LATE_ARG))
+        {
+            if (arg->gtOper == GT_PUTARG_STK)
+            {
+                fgArgTabEntryPtr curArgTabEntry = compiler->gtArgEntryByNode(call, arg);
+                assert(curArgTabEntry);
+
+                assert(curArgTabEntry->regNum == REG_STK);
+
+                TreeNodeInfoInitPutArgStk(arg->AsPutArgStk(), curArgTabEntry);
+            }
+            else
+            {
+                TreeNodeInfo* argInfo = &(arg->gtLsraInfo);
+                if (argInfo->dstCount != 0)
+                {
+                    argInfo->isLocalDefUse = true;
+                }
+
+                argInfo->dstCount = 0;
+            }
+        }
+        args = args->gtOp.gtOp2;
+    }
+
+    if (call->IsVarargs() && callHasFloatRegArgs && !call->IsFastTailCall() && (ctrlExpr != nullptr))
+    {
+        NYI_ARM("float reg varargs");
+    }
+
+    if (call->NeedsNullCheck())
+    {
+        info->internalIntCount++;
+    }
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitPutArgStk: Set the NodeInfo for a GT_PUTARG_STK node
+//
+// Arguments:
+//    argNode - a GT_PUTARG_STK node
+//
+// Return Value:
+//    None.
+//
+// Notes:
+//    Set the child node(s) to be contained when we have a multireg arg
+//
+void Lowering::TreeNodeInfoInitPutArgStk(GenTreePutArgStk* argNode, fgArgTabEntryPtr info)
+{
+    assert(argNode->gtOper == GT_PUTARG_STK);
+
+    GenTreePtr putArgChild = argNode->gtOp.gtOp1;
+
+    // Initialize 'argNode' as not contained, as this is both the default case
+    //  and how MakeSrcContained expects to find things setup.
+    //
+    argNode->gtLsraInfo.srcCount = 1;
+    argNode->gtLsraInfo.dstCount = 0;
+
+    // Do we have a TYP_STRUCT argument (or a GT_FIELD_LIST), if so it must be a multireg pass-by-value struct
+    if ((putArgChild->TypeGet() == TYP_STRUCT) || (putArgChild->OperGet() == GT_FIELD_LIST))
+    {
+        // We will use store instructions that each write a register sized value
+
+        if (putArgChild->OperGet() == GT_FIELD_LIST)
+        {
+            // We consume all of the items in the GT_FIELD_LIST
+            argNode->gtLsraInfo.srcCount = info->numSlots;
+        }
+        else
+        {
+            // We could use a ldp/stp sequence so we need two internal registers
+            argNode->gtLsraInfo.internalIntCount = 2;
+
+            if (putArgChild->OperGet() == GT_OBJ)
+            {
+                GenTreePtr objChild = putArgChild->gtOp.gtOp1;
+                if (objChild->OperGet() == GT_LCL_VAR_ADDR)
+                {
+                    // We will generate all of the code for the GT_PUTARG_STK, the GT_OBJ and the GT_LCL_VAR_ADDR
+                    // as one contained operation
+                    //
+                    MakeSrcContained(putArgChild, objChild);
+                }
+            }
+
+            // We will generate all of the code for the GT_PUTARG_STK and it's child node
+            // as one contained operation
+            //
+            MakeSrcContained(argNode, putArgChild);
+        }
+    }
+    else
+    {
+        // We must not have a multi-reg struct
+        assert(info->numSlots == 1);
+    }
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInit: Set the register requirements for RA.
+//
+// Notes:
+//    Takes care of annotating the register requirements
+//    for every TreeNodeInfo struct that maps to each tree node.
+//
+// Preconditions:
+//    LSRA has been initialized and there is a TreeNodeInfo node
+//    already allocated and initialized for every tree in the IR.
+//
+// Postconditions:
+//    Every TreeNodeInfo instance has the right annotations on register
+//    requirements needed by LSRA to build the Interval Table (source,
+//    destination and internal [temp] register counts).
+//
+void Lowering::TreeNodeInfoInit(GenTree* tree)
+{
+    LinearScan* l        = m_lsra;
+    Compiler*   compiler = comp;
+
+    unsigned      kind         = tree->OperKind();
+    TreeNodeInfo* info         = &(tree->gtLsraInfo);
+    RegisterType  registerType = TypeGet(tree);
+
+    JITDUMP("TreeNodeInfoInit for: ");
+    DISPNODE(tree);
+
+    NYI_IF(tree->TypeGet() == TYP_STRUCT, "lowering struct");
+    NYI_IF(tree->TypeGet() == TYP_LONG, "lowering long");
+    NYI_IF(tree->TypeGet() == TYP_DOUBLE, "lowering double");
+
+    switch (tree->OperGet())
+    {
+        GenTree* op1;
+        GenTree* op2;
+
+        case GT_STORE_LCL_FLD:
+        case GT_STORE_LCL_VAR:
+            info->srcCount = 1;
+            info->dstCount = 0;
+            LowerStoreLoc(tree->AsLclVarCommon());
+            TreeNodeInfoInitStoreLoc(tree->AsLclVarCommon());
+            break;
+
+        case GT_NOP:
+            // A GT_NOP is either a passthrough (if it is void, or if it has
+            // a child), but must be considered to produce a dummy value if it
+            // has a type but no child
+            info->srcCount = 0;
+            if (tree->TypeGet() != TYP_VOID && tree->gtOp.gtOp1 == nullptr)
+            {
+                info->dstCount = 1;
+            }
+            else
+            {
+                info->dstCount = 0;
+            }
+            break;
+
+        case GT_INTRINSIC:
+        {
+            // TODO-ARM: Implement other type of intrinsics (round, sqrt and etc.)
+            // Both operand and its result must be of the same floating point type.
+            op1 = tree->gtOp.gtOp1;
+            assert(varTypeIsFloating(op1));
+            assert(op1->TypeGet() == tree->TypeGet());
+
+            switch (tree->gtIntrinsic.gtIntrinsicId)
+            {
+                case CORINFO_INTRINSIC_Abs:
+                case CORINFO_INTRINSIC_Sqrt:
+                    info->srcCount = 1;
+                    info->dstCount = 1;
+                    break;
+                default:
+                    NYI_ARM("Lowering::TreeNodeInfoInit for GT_INTRINSIC");
+                    break;
+            }
+        }
+        break;
+
+        case GT_CAST:
+        {
+            info->srcCount = 1;
+            info->dstCount = 1;
+
+            // Non-overflow casts to/from float/double are done using SSE2 instructions
+            // and that allow the source operand to be either a reg or memop. Given the
+            // fact that casts from small int to float/double are done as two-level casts,
+            // the source operand is always guaranteed to be of size 4 or 8 bytes.
+            var_types  castToType = tree->CastToType();
+            GenTreePtr castOp     = tree->gtCast.CastOp();
+            var_types  castOpType = castOp->TypeGet();
+            if (tree->gtFlags & GTF_UNSIGNED)
+            {
+                castOpType = genUnsignedType(castOpType);
+            }
+#ifdef DEBUG
+            if (!tree->gtOverflow() && (varTypeIsFloating(castToType) || varTypeIsFloating(castOpType)))
+            {
+                // If converting to float/double, the operand must be 4 or 8 byte in size.
+                if (varTypeIsFloating(castToType))
+                {
+                    unsigned opSize = genTypeSize(castOpType);
+                    assert(opSize == 4 || opSize == 8);
+                }
+            }
+#endif // DEBUG
+
+            if (tree->gtOverflow())
+            {
+                NYI_ARM("overflow checks");
+            }
+        }
+        break;
+
+        case GT_JTRUE:
+            info->srcCount = 0;
+            info->dstCount = 0;
+            l->clearDstCount(tree->gtOp.gtOp1);
+            break;
+
+        case GT_JMP:
+            info->srcCount = 0;
+            info->dstCount = 0;
+            break;
+
+        case GT_SWITCH:
+            // This should never occur since switch nodes must not be visible at this
+            // point in the JIT.
+            info->srcCount = 0;
+            info->dstCount = 0; // To avoid getting uninit errors.
+            noway_assert(!"Switch must be lowered at this point");
+            break;
+
+        case GT_JMPTABLE:
+            info->srcCount = 0;
+            info->dstCount = 1;
+            break;
+
+        case GT_SWITCH_TABLE:
+            info->srcCount         = 2;
+            info->internalIntCount = 1;
+            info->dstCount         = 0;
+            break;
+
+        case GT_ASG:
+        case GT_ASG_ADD:
+        case GT_ASG_SUB:
+            noway_assert(!"We should never hit any assignment operator in lowering");
+            info->srcCount = 0;
+            info->dstCount = 0;
+            break;
+
+        case GT_ADD:
+        case GT_SUB:
+            if (varTypeIsFloating(tree->TypeGet()))
+            {
+                // overflow operations aren't supported on float/double types.
+                assert(!tree->gtOverflow());
+
+                // No implicit conversions at this stage as the expectation is that
+                // everything is made explicit by adding casts.
+                assert(tree->gtOp.gtOp1->TypeGet() == tree->gtOp.gtOp2->TypeGet());
+
+                info->srcCount = 2;
+                info->dstCount = 1;
+
+                break;
+            }
+
+            __fallthrough;
+
+        case GT_AND:
+        case GT_OR:
+        case GT_XOR:
+            info->srcCount = 2;
+            info->dstCount = 1;
+            // Check and make op2 contained (if it is a containable immediate)
+            CheckImmedAndMakeContained(tree, tree->gtOp.gtOp2);
+            break;
+
+        case GT_MUL:
+            if (tree->gtOverflow())
+            {
+                // Need a register different from target reg to check for overflow.
+                info->internalIntCount = 2;
+            }
+            __fallthrough;
+
+        case GT_DIV:
+        case GT_MULHI:
+        case GT_UDIV:
+        {
+            info->srcCount = 2;
+            info->dstCount = 1;
+        }
+        break;
+
+        case GT_LIST:
+        case GT_FIELD_LIST:
+        case GT_ARGPLACE:
+        case GT_NO_OP:
+        case GT_START_NONGC:
+        case GT_PROF_HOOK:
+            info->srcCount = 0;
+            info->dstCount = 0;
+            break;
+
+        case GT_CNS_DBL:
+            info->srcCount = 0;
+            info->dstCount = 1;
+            if (tree->TypeGet() == TYP_FLOAT)
+            {
+                // An int register for float constant
+                info->internalIntCount = 1;
+            }
+            else
+            {
+                // TYP_DOUBLE
+                assert(tree->TypeGet() == TYP_DOUBLE);
+
+                // Two int registers for double constant
+                info->internalIntCount = 2;
+            }
+            break;
+
+        case GT_RETURN:
+            TreeNodeInfoInitReturn(tree);
+            break;
+
+        case GT_RETFILT:
+            if (tree->TypeGet() == TYP_VOID)
+            {
+                info->srcCount = 0;
+                info->dstCount = 0;
+            }
+            else
+            {
+                assert(tree->TypeGet() == TYP_INT);
+
+                info->srcCount = 1;
+                info->dstCount = 0;
+
+                info->setSrcCandidates(l, RBM_INTRET);
+                tree->gtOp.gtOp1->gtLsraInfo.setSrcCandidates(l, RBM_INTRET);
+            }
+            break;
+
+        case GT_ARR_BOUNDS_CHECK:
+            // Consumes arrLen and index. Has no result.
+            info->srcCount = 2;
+            info->dstCount = 0;
+            break;
+
+        case GT_LEA:
+        {
+            GenTreeAddrMode* lea = tree->AsAddrMode();
+
+            GenTree* base  = lea->Base();
+            GenTree* index = lea->Index();
+            unsigned cns   = lea->gtOffset;
+
+            // This LEA is instantiating an address,
+            // so we set up the srcCount and dstCount here.
+            info->srcCount = 0;
+            if (base != nullptr)
+            {
+                info->srcCount++;
+            }
+            if (index != nullptr)
+            {
+                info->srcCount++;
+            }
+            info->dstCount = 1;
+
+            // On ARM we may need a single internal register
+            // (when both conditions are true then we still only need a single internal register)
+            if ((index != nullptr) && (cns != 0))
+            {
+                // ARM does not support both Index and offset so we need an internal register
+                info->internalIntCount = 1;
+            }
+            else if (!emitter::emitIns_valid_imm_for_add(cns, INS_FLAGS_DONT_CARE))
+            {
+                // This offset can't be contained in the add instruction, so we need an internal register
+                info->internalIntCount = 1;
+            }
+        }
+        break;
+
+        case GT_NEG:
+            info->srcCount = 1;
+            info->dstCount = 1;
+            break;
+
+        case GT_NOT:
+            info->srcCount = 1;
+            info->dstCount = 1;
+            break;
+
+        case GT_LSH:
+        case GT_RSH:
+        case GT_RSZ:
+        case GT_ROR:
+        {
+            info->srcCount = 2;
+            info->dstCount = 1;
+
+            GenTreePtr shiftBy = tree->gtOp.gtOp2;
+            GenTreePtr source  = tree->gtOp.gtOp1;
+            if (shiftBy->IsCnsIntOrI())
+            {
+                l->clearDstCount(shiftBy);
+                info->srcCount--;
+            }
+        }
+        break;
+
+        case GT_EQ:
+        case GT_NE:
+        case GT_LT:
+        case GT_LE:
+        case GT_GE:
+        case GT_GT:
+            TreeNodeInfoInitCmp(tree);
+            break;
+
+        case GT_CALL:
+            TreeNodeInfoInitCall(tree->AsCall());
+            break;
+
+        case GT_STOREIND:
+        {
+            info->srcCount = 2;
+            info->dstCount = 0;
+            GenTree* src   = tree->gtOp.gtOp2;
+
+            if (compiler->codeGen->gcInfo.gcIsWriteBarrierAsgNode(tree))
+            {
+                TreeNodeInfoInitGCWriteBarrier(tree);
+                break;
+            }
+
+            TreeNodeInfoInitIndir(tree);
+        }
+        break;
+
+        case GT_NULLCHECK:
+            info->dstCount      = 0;
+            info->srcCount      = 1;
+            info->isLocalDefUse = true;
+            // null check is an indirection on an addr
+            TreeNodeInfoInitIndir(tree);
+            break;
+
+        case GT_IND:
+            info->dstCount = 1;
+            info->srcCount = 1;
+            TreeNodeInfoInitIndir(tree);
+            break;
+
+        case GT_CATCH_ARG:
+            info->srcCount = 0;
+            info->dstCount = 1;
+            info->setDstCandidates(l, RBM_EXCEPTION_OBJECT);
+            break;
+
+        case GT_CLS_VAR:
+            info->srcCount = 0;
+            // GT_CLS_VAR, by the time we reach the backend, must always
+            // be a pure use.
+            // It will produce a result of the type of the
+            // node, and use an internal register for the address.
+
+            info->dstCount = 1;
+            assert((tree->gtFlags & (GTF_VAR_DEF | GTF_VAR_USEASG | GTF_VAR_USEDEF)) == 0);
+            info->internalIntCount = 1;
+            break;
+
+        default:
+#ifdef DEBUG
+            char message[256];
+            _snprintf_s(message, _countof(message), _TRUNCATE, "NYI: Unimplemented node type %s",
+                        GenTree::NodeName(tree->OperGet()));
+            NYIRAW(message);
+#else
+            NYI_ARM("TreeNodeInfoInit default case");
+#endif
+        case GT_LCL_FLD:
+        case GT_LCL_FLD_ADDR:
+        case GT_LCL_VAR:
+        case GT_LCL_VAR_ADDR:
+        {
+            unsigned   varNum = tree->gtLclVarCommon.gtLclNum;
+            LclVarDsc* varDsc = comp->lvaTable + varNum;
+            NYI_IF(varTypeIsStruct(varDsc), "lowering struct var");
+            NYI_IF(varTypeIsLong(varDsc), "lowering long var");
+        }
+        case GT_PHYSREG:
+        case GT_CLS_VAR_ADDR:
+        case GT_IL_OFFSET:
+        case GT_CNS_INT:
+        case GT_PUTARG_REG:
+        case GT_PUTARG_STK:
+            info->dstCount = tree->IsValue() ? 1 : 0;
+            if (kind & (GTK_CONST | GTK_LEAF))
+            {
+                info->srcCount = 0;
+            }
+            else if (kind & (GTK_SMPOP))
+            {
+                if (tree->gtGetOp2IfPresent() != nullptr)
+                {
+                    info->srcCount = 2;
+                }
+                else
+                {
+                    info->srcCount = 1;
+                }
+            }
+            else
+            {
+                unreached();
+            }
+            break;
+    } // end switch (tree->OperGet())
+
+    // We need to be sure that we've set info->srcCount and info->dstCount appropriately
+    assert((info->dstCount < 2) || tree->IsMultiRegCall());
+}
+
+#endif // _TARGET_ARM_
+
+#endif // !LEGACY_BACKEND
diff --git a/src/jit/lsraarm64.cpp b/src/jit/lsraarm64.cpp
new file mode 100644
index 0000000000..0db30e1811
--- /dev/null
+++ b/src/jit/lsraarm64.cpp
@@ -0,0 +1,1766 @@
+// 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.
+
+/*XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+XX                                                                           XX
+XX                    Register Requirements for ARM64                        XX
+XX                                                                           XX
+XX  This encapsulates all the logic for setting register requirements for    XX
+XX  the ARM64 architecture.                                                  XX
+XX                                                                           XX
+XX                                                                           XX
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+*/
+
+#include "jitpch.h"
+#ifdef _MSC_VER
+#pragma hdrstop
+#endif
+
+#ifndef LEGACY_BACKEND // This file is ONLY used for the RyuJIT backend that uses the linear scan register allocator
+
+#ifdef _TARGET_ARM64_
+
+#include "jit.h"
+#include "sideeffects.h"
+#include "lower.h"
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitStoreLoc: Set register requirements for a store of a lclVar
+//
+// Arguments:
+//    storeLoc - the local store (GT_STORE_LCL_FLD or GT_STORE_LCL_VAR)
+//
+// Notes:
+//    This involves:
+//    - Setting the appropriate candidates for a store of a multi-reg call return value.
+//    - Handling of contained immediates.
+
+void Lowering::TreeNodeInfoInitStoreLoc(GenTreeLclVarCommon* storeLoc)
+{
+    TreeNodeInfo* info = &(storeLoc->gtLsraInfo);
+
+    // Is this the case of var = call where call is returning
+    // a value in multiple return registers?
+    GenTree* op1 = storeLoc->gtGetOp1();
+    if (op1->IsMultiRegCall())
+    {
+        // backend expects to see this case only for store lclvar.
+        assert(storeLoc->OperGet() == GT_STORE_LCL_VAR);
+
+        // srcCount = number of registers in which the value is returned by call
+        GenTreeCall*    call        = op1->AsCall();
+        ReturnTypeDesc* retTypeDesc = call->GetReturnTypeDesc();
+        info->srcCount              = retTypeDesc->GetReturnRegCount();
+
+        // Call node srcCandidates = Bitwise-OR(allregs(GetReturnRegType(i))) for all i=0..RetRegCount-1
+        regMaskTP srcCandidates = m_lsra->allMultiRegCallNodeRegs(call);
+        op1->gtLsraInfo.setSrcCandidates(m_lsra, srcCandidates);
+        return;
+    }
+
+    CheckImmedAndMakeContained(storeLoc, op1);
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInit: Set the register requirements for RA.
+//
+// Notes:
+//    Takes care of annotating the register requirements
+//    for every TreeNodeInfo struct that maps to each tree node.
+//
+// Preconditions:
+//    LSRA has been initialized and there is a TreeNodeInfo node
+//    already allocated and initialized for every tree in the IR.
+//
+// Postconditions:
+//    Every TreeNodeInfo instance has the right annotations on register
+//    requirements needed by LSRA to build the Interval Table (source,
+//    destination and internal [temp] register counts).
+//
+void Lowering::TreeNodeInfoInit(GenTree* tree)
+{
+    LinearScan* l        = m_lsra;
+    Compiler*   compiler = comp;
+
+    unsigned      kind         = tree->OperKind();
+    TreeNodeInfo* info         = &(tree->gtLsraInfo);
+    RegisterType  registerType = TypeGet(tree);
+
+    JITDUMP("TreeNodeInfoInit for: ");
+    DISPNODE(tree);
+    JITDUMP("\n");
+
+    switch (tree->OperGet())
+    {
+        GenTree* op1;
+        GenTree* op2;
+
+        default:
+            info->dstCount = tree->IsValue() ? 1 : 0;
+            if (kind & (GTK_CONST | GTK_LEAF))
+            {
+                info->srcCount = 0;
+            }
+            else if (kind & (GTK_SMPOP))
+            {
+                if (tree->gtGetOp2IfPresent() != nullptr)
+                {
+                    info->srcCount = 2;
+                }
+                else
+                {
+                    info->srcCount = 1;
+                }
+            }
+            else
+            {
+                unreached();
+            }
+            break;
+
+        case GT_STORE_LCL_FLD:
+        case GT_STORE_LCL_VAR:
+            info->srcCount = 1;
+            info->dstCount = 0;
+            LowerStoreLoc(tree->AsLclVarCommon());
+            TreeNodeInfoInitStoreLoc(tree->AsLclVarCommon());
+            break;
+
+        case GT_BOX:
+            noway_assert(!"box should not exist here");
+            // The result of 'op1' is also the final result
+            info->srcCount = 0;
+            info->dstCount = 0;
+            break;
+
+        case GT_PHYSREGDST:
+            info->srcCount = 1;
+            info->dstCount = 0;
+            break;
+
+        case GT_COMMA:
+        {
+            GenTreePtr firstOperand;
+            GenTreePtr secondOperand;
+            if (tree->gtFlags & GTF_REVERSE_OPS)
+            {
+                firstOperand  = tree->gtOp.gtOp2;
+                secondOperand = tree->gtOp.gtOp1;
+            }
+            else
+            {
+                firstOperand  = tree->gtOp.gtOp1;
+                secondOperand = tree->gtOp.gtOp2;
+            }
+            if (firstOperand->TypeGet() != TYP_VOID)
+            {
+                firstOperand->gtLsraInfo.isLocalDefUse = true;
+                firstOperand->gtLsraInfo.dstCount      = 0;
+            }
+            if (tree->TypeGet() == TYP_VOID && secondOperand->TypeGet() != TYP_VOID)
+            {
+                secondOperand->gtLsraInfo.isLocalDefUse = true;
+                secondOperand->gtLsraInfo.dstCount      = 0;
+            }
+        }
+
+            __fallthrough;
+
+        case GT_LIST:
+        case GT_FIELD_LIST:
+        case GT_ARGPLACE:
+        case GT_NO_OP:
+        case GT_START_NONGC:
+        case GT_PROF_HOOK:
+            info->srcCount = 0;
+            info->dstCount = 0;
+            break;
+
+        case GT_CNS_DBL:
+            info->srcCount = 0;
+            info->dstCount = 1;
+            {
+                GenTreeDblCon* dblConst   = tree->AsDblCon();
+                double         constValue = dblConst->gtDblCon.gtDconVal;
+
+                if (emitter::emitIns_valid_imm_for_fmov(constValue))
+                {
+                    // Directly encode constant to instructions.
+                }
+                else
+                {
+                    // Reserve int to load constant from memory (IF_LARGELDC)
+                    info->internalIntCount = 1;
+                }
+            }
+            break;
+
+        case GT_QMARK:
+        case GT_COLON:
+            info->srcCount = 0;
+            info->dstCount = 0;
+            unreached();
+            break;
+
+        case GT_RETURN:
+            TreeNodeInfoInitReturn(tree);
+            break;
+
+        case GT_RETFILT:
+            if (tree->TypeGet() == TYP_VOID)
+            {
+                info->srcCount = 0;
+                info->dstCount = 0;
+            }
+            else
+            {
+                assert(tree->TypeGet() == TYP_INT);
+
+                info->srcCount = 1;
+                info->dstCount = 0;
+
+                info->setSrcCandidates(l, RBM_INTRET);
+                tree->gtOp.gtOp1->gtLsraInfo.setSrcCandidates(l, RBM_INTRET);
+            }
+            break;
+
+        case GT_NOP:
+            // A GT_NOP is either a passthrough (if it is void, or if it has
+            // a child), but must be considered to produce a dummy value if it
+            // has a type but no child
+            info->srcCount = 0;
+            if (tree->TypeGet() != TYP_VOID && tree->gtOp.gtOp1 == nullptr)
+            {
+                info->dstCount = 1;
+            }
+            else
+            {
+                info->dstCount = 0;
+            }
+            break;
+
+        case GT_JTRUE:
+            info->srcCount = 0;
+            info->dstCount = 0;
+            l->clearDstCount(tree->gtOp.gtOp1);
+            break;
+
+        case GT_JMP:
+            info->srcCount = 0;
+            info->dstCount = 0;
+            break;
+
+        case GT_SWITCH:
+            // This should never occur since switch nodes must not be visible at this
+            // point in the JIT.
+            info->srcCount = 0;
+            info->dstCount = 0; // To avoid getting uninit errors.
+            noway_assert(!"Switch must be lowered at this point");
+            break;
+
+        case GT_JMPTABLE:
+            info->srcCount = 0;
+            info->dstCount = 1;
+            break;
+
+        case GT_SWITCH_TABLE:
+            info->srcCount         = 2;
+            info->internalIntCount = 1;
+            info->dstCount         = 0;
+            break;
+
+        case GT_ASG:
+        case GT_ASG_ADD:
+        case GT_ASG_SUB:
+            noway_assert(!"We should never hit any assignment operator in lowering");
+            info->srcCount = 0;
+            info->dstCount = 0;
+            break;
+
+        case GT_ADD:
+        case GT_SUB:
+            if (varTypeIsFloating(tree->TypeGet()))
+            {
+                // overflow operations aren't supported on float/double types.
+                assert(!tree->gtOverflow());
+
+                // No implicit conversions at this stage as the expectation is that
+                // everything is made explicit by adding casts.
+                assert(tree->gtOp.gtOp1->TypeGet() == tree->gtOp.gtOp2->TypeGet());
+
+                info->srcCount = 2;
+                info->dstCount = 1;
+
+                break;
+            }
+
+            __fallthrough;
+
+        case GT_AND:
+        case GT_OR:
+        case GT_XOR:
+            info->srcCount = 2;
+            info->dstCount = 1;
+            // Check and make op2 contained (if it is a containable immediate)
+            CheckImmedAndMakeContained(tree, tree->gtOp.gtOp2);
+            break;
+
+        case GT_RETURNTRAP:
+            // this just turns into a compare of its child with an int
+            // + a conditional call
+            info->srcCount = 1;
+            info->dstCount = 0;
+            break;
+
+        case GT_MOD:
+        case GT_UMOD:
+            NYI_IF(varTypeIsFloating(tree->TypeGet()), "FP Remainder in ARM64");
+            assert(!"Shouldn't see an integer typed GT_MOD node in ARM64");
+            break;
+
+        case GT_MUL:
+            if (tree->gtOverflow())
+            {
+                // Need a register different from target reg to check for overflow.
+                info->internalIntCount = 2;
+            }
+            __fallthrough;
+
+        case GT_DIV:
+        case GT_MULHI:
+        case GT_UDIV:
+        {
+            info->srcCount = 2;
+            info->dstCount = 1;
+        }
+        break;
+
+        case GT_INTRINSIC:
+        {
+            // TODO-ARM64-NYI
+            // Right now only Abs/Round/Sqrt are treated as math intrinsics
+            noway_assert((tree->gtIntrinsic.gtIntrinsicId == CORINFO_INTRINSIC_Abs) ||
+                         (tree->gtIntrinsic.gtIntrinsicId == CORINFO_INTRINSIC_Round) ||
+                         (tree->gtIntrinsic.gtIntrinsicId == CORINFO_INTRINSIC_Sqrt));
+
+            // Both operand and its result must be of the same floating point type.
+            op1 = tree->gtOp.gtOp1;
+            assert(varTypeIsFloating(op1));
+            assert(op1->TypeGet() == tree->TypeGet());
+
+            info->srcCount = 1;
+            info->dstCount = 1;
+        }
+        break;
+
+#ifdef FEATURE_SIMD
+        case GT_SIMD:
+            TreeNodeInfoInitSIMD(tree);
+            break;
+#endif // FEATURE_SIMD
+
+        case GT_CAST:
+        {
+            // TODO-ARM64-CQ: Int-To-Int conversions - castOp cannot be a memory op and must have an assigned
+            //                register.
+            //         see CodeGen::genIntToIntCast()
+
+            info->srcCount = 1;
+            info->dstCount = 1;
+
+            // Non-overflow casts to/from float/double are done using SSE2 instructions
+            // and that allow the source operand to be either a reg or memop. Given the
+            // fact that casts from small int to float/double are done as two-level casts,
+            // the source operand is always guaranteed to be of size 4 or 8 bytes.
+            var_types  castToType = tree->CastToType();
+            GenTreePtr castOp     = tree->gtCast.CastOp();
+            var_types  castOpType = castOp->TypeGet();
+            if (tree->gtFlags & GTF_UNSIGNED)
+            {
+                castOpType = genUnsignedType(castOpType);
+            }
+#ifdef DEBUG
+            if (!tree->gtOverflow() && (varTypeIsFloating(castToType) || varTypeIsFloating(castOpType)))
+            {
+                // If converting to float/double, the operand must be 4 or 8 byte in size.
+                if (varTypeIsFloating(castToType))
+                {
+                    unsigned opSize = genTypeSize(castOpType);
+                    assert(opSize == 4 || opSize == 8);
+                }
+            }
+#endif // DEBUG
+            // Some overflow checks need a temp reg
+
+            CastInfo castInfo;
+
+            // Get information about the cast.
+            getCastDescription(tree, &castInfo);
+
+            if (castInfo.requiresOverflowCheck)
+            {
+                var_types srcType = castOp->TypeGet();
+                emitAttr  cmpSize = EA_ATTR(genTypeSize(srcType));
+
+                // If we cannot store the comparisons in an immediate for either
+                // comparing against the max or min value, then we will need to
+                // reserve a temporary register.
+
+                bool canStoreMaxValue = emitter::emitIns_valid_imm_for_cmp(castInfo.typeMax, cmpSize);
+                bool canStoreMinValue = emitter::emitIns_valid_imm_for_cmp(castInfo.typeMin, cmpSize);
+
+                if (!canStoreMaxValue || !canStoreMinValue)
+                {
+                    info->internalIntCount = 1;
+                }
+            }
+        }
+        break;
+
+        case GT_NEG:
+            info->srcCount = 1;
+            info->dstCount = 1;
+            break;
+
+        case GT_NOT:
+            info->srcCount = 1;
+            info->dstCount = 1;
+            break;
+
+        case GT_LSH:
+        case GT_RSH:
+        case GT_RSZ:
+        case GT_ROR:
+        {
+            info->srcCount = 2;
+            info->dstCount = 1;
+
+            GenTreePtr shiftBy = tree->gtOp.gtOp2;
+            GenTreePtr source  = tree->gtOp.gtOp1;
+            if (shiftBy->IsCnsIntOrI())
+            {
+                l->clearDstCount(shiftBy);
+                info->srcCount--;
+            }
+        }
+        break;
+
+        case GT_EQ:
+        case GT_NE:
+        case GT_LT:
+        case GT_LE:
+        case GT_GE:
+        case GT_GT:
+            TreeNodeInfoInitCmp(tree);
+            break;
+
+        case GT_CKFINITE:
+            info->srcCount         = 1;
+            info->dstCount         = 1;
+            info->internalIntCount = 1;
+            break;
+
+        case GT_CMPXCHG:
+            info->srcCount = 3;
+            info->dstCount = 1;
+
+            // TODO-ARM64-NYI
+            NYI("CMPXCHG");
+            break;
+
+        case GT_LOCKADD:
+            info->srcCount = 2;
+            info->dstCount = 0;
+            CheckImmedAndMakeContained(tree, tree->gtOp.gtOp2);
+            break;
+
+        case GT_CALL:
+            TreeNodeInfoInitCall(tree->AsCall());
+            break;
+
+        case GT_ADDR:
+        {
+            // For a GT_ADDR, the child node should not be evaluated into a register
+            GenTreePtr child = tree->gtOp.gtOp1;
+            assert(!l->isCandidateLocalRef(child));
+            l->clearDstCount(child);
+            info->srcCount = 0;
+            info->dstCount = 1;
+        }
+        break;
+
+        case GT_BLK:
+        case GT_DYN_BLK:
+            // These should all be eliminated prior to Lowering.
+            assert(!"Non-store block node in Lowering");
+            info->srcCount = 0;
+            info->dstCount = 0;
+            break;
+
+        case GT_STORE_BLK:
+        case GT_STORE_OBJ:
+        case GT_STORE_DYN_BLK:
+            LowerBlockStore(tree->AsBlk());
+            TreeNodeInfoInitBlockStore(tree->AsBlk());
+            break;
+
+        case GT_INIT_VAL:
+            // Always a passthrough of its child's value.
+            info->srcCount = 0;
+            info->dstCount = 0;
+            break;
+
+        case GT_LCLHEAP:
+        {
+            info->srcCount = 1;
+            info->dstCount = 1;
+
+            // Need a variable number of temp regs (see genLclHeap() in codegenamd64.cpp):
+            // Here '-' means don't care.
+            //
+            //  Size?                   Init Memory?    # temp regs
+            //   0                          -               0
+            //   const and <=6 ptr words    -               0
+            //   const and <PageSize        No              0
+            //   >6 ptr words               Yes           hasPspSym ? 1 : 0
+            //   Non-const                  Yes           hasPspSym ? 1 : 0
+            //   Non-const                  No              2
+            //
+            // PSPSym - If the method has PSPSym increment internalIntCount by 1.
+            //
+            bool hasPspSym;
+#if FEATURE_EH_FUNCLETS
+            hasPspSym = (compiler->lvaPSPSym != BAD_VAR_NUM);
+#else
+            hasPspSym = false;
+#endif
+
+            GenTreePtr size = tree->gtOp.gtOp1;
+            if (size->IsCnsIntOrI())
+            {
+                MakeSrcContained(tree, size);
+
+                size_t sizeVal = size->gtIntCon.gtIconVal;
+
+                if (sizeVal == 0)
+                {
+                    info->internalIntCount = 0;
+                }
+                else
+                {
+                    // Compute the amount of memory to properly STACK_ALIGN.
+                    // Note: The Gentree node is not updated here as it is cheap to recompute stack aligned size.
+                    // This should also help in debugging as we can examine the original size specified with
+                    // localloc.
+                    sizeVal                          = AlignUp(sizeVal, STACK_ALIGN);
+                    size_t cntStackAlignedWidthItems = (sizeVal >> STACK_ALIGN_SHIFT);
+
+                    // For small allocations upto 4 'stp' instructions (i.e. 64 bytes of localloc)
+                    //
+                    if (cntStackAlignedWidthItems <= 4)
+                    {
+                        info->internalIntCount = 0;
+                    }
+                    else if (!compiler->info.compInitMem)
+                    {
+                        // No need to initialize allocated stack space.
+                        if (sizeVal < compiler->eeGetPageSize())
+                        {
+                            info->internalIntCount = 0;
+                        }
+                        else
+                        {
+                            // We need two registers: regCnt and RegTmp
+                            info->internalIntCount = 2;
+                        }
+                    }
+                    else
+                    {
+                        // greater than 4 and need to zero initialize allocated stack space.
+                        // If the method has PSPSym, we need an internal register to hold regCnt
+                        // since targetReg allocated to GT_LCLHEAP node could be the same as one of
+                        // the the internal registers.
+                        info->internalIntCount = hasPspSym ? 1 : 0;
+                    }
+                }
+            }
+            else
+            {
+                if (!compiler->info.compInitMem)
+                {
+                    info->internalIntCount = 2;
+                }
+                else
+                {
+                    // If the method has PSPSym, we need an internal register to hold regCnt
+                    // since targetReg allocated to GT_LCLHEAP node could be the same as one of
+                    // the the internal registers.
+                    info->internalIntCount = hasPspSym ? 1 : 0;
+                }
+            }
+
+            // If the method has PSPSym, we would need an addtional register to relocate it on stack.
+            if (hasPspSym)
+            {
+                // Exclude const size 0
+                if (!size->IsCnsIntOrI() || (size->gtIntCon.gtIconVal > 0))
+                    info->internalIntCount++;
+            }
+        }
+        break;
+
+        case GT_ARR_BOUNDS_CHECK:
+#ifdef FEATURE_SIMD
+        case GT_SIMD_CHK:
+#endif // FEATURE_SIMD
+        {
+            GenTreeBoundsChk* node = tree->AsBoundsChk();
+            // Consumes arrLen & index - has no result
+            info->srcCount = 2;
+            info->dstCount = 0;
+
+            GenTree* intCns = nullptr;
+            GenTree* other  = nullptr;
+            if (CheckImmedAndMakeContained(tree, node->gtIndex))
+            {
+                intCns = node->gtIndex;
+                other  = node->gtArrLen;
+            }
+            else if (CheckImmedAndMakeContained(tree, node->gtArrLen))
+            {
+                intCns = node->gtArrLen;
+                other  = node->gtIndex;
+            }
+            else
+            {
+                other = node->gtIndex;
+            }
+        }
+        break;
+
+        case GT_ARR_ELEM:
+            // These must have been lowered to GT_ARR_INDEX
+            noway_assert(!"We should never see a GT_ARR_ELEM in lowering");
+            info->srcCount = 0;
+            info->dstCount = 0;
+            break;
+
+        case GT_ARR_INDEX:
+            info->srcCount = 2;
+            info->dstCount = 1;
+
+            // We need one internal register when generating code for GT_ARR_INDEX, however the
+            // register allocator always may just give us the same one as it gives us for the 'dst'
+            // as a workaround we will just ask for two internal registers.
+            //
+            info->internalIntCount = 2;
+
+            // For GT_ARR_INDEX, the lifetime of the arrObj must be extended because it is actually used multiple
+            // times while the result is being computed.
+            tree->AsArrIndex()->ArrObj()->gtLsraInfo.isDelayFree = true;
+            info->hasDelayFreeSrc                                = true;
+            break;
+
+        case GT_ARR_OFFSET:
+            // This consumes the offset, if any, the arrObj and the effective index,
+            // and produces the flattened offset for this dimension.
+            info->srcCount         = 3;
+            info->dstCount         = 1;
+            info->internalIntCount = 1;
+
+            // we don't want to generate code for this
+            if (tree->gtArrOffs.gtOffset->IsIntegralConst(0))
+            {
+                MakeSrcContained(tree, tree->gtArrOffs.gtOffset);
+            }
+            break;
+
+        case GT_LEA:
+        {
+            GenTreeAddrMode* lea = tree->AsAddrMode();
+
+            GenTree* base  = lea->Base();
+            GenTree* index = lea->Index();
+            unsigned cns   = lea->gtOffset;
+
+            // This LEA is instantiating an address,
+            // so we set up the srcCount and dstCount here.
+            info->srcCount = 0;
+            if (base != nullptr)
+            {
+                info->srcCount++;
+            }
+            if (index != nullptr)
+            {
+                info->srcCount++;
+            }
+            info->dstCount = 1;
+
+            // On ARM64 we may need a single internal register
+            // (when both conditions are true then we still only need a single internal register)
+            if ((index != nullptr) && (cns != 0))
+            {
+                // ARM64 does not support both Index and offset so we need an internal register
+                info->internalIntCount = 1;
+            }
+            else if (!emitter::emitIns_valid_imm_for_add(cns, EA_8BYTE))
+            {
+                // This offset can't be contained in the add instruction, so we need an internal register
+                info->internalIntCount = 1;
+            }
+        }
+        break;
+
+        case GT_STOREIND:
+        {
+            info->srcCount = 2;
+            info->dstCount = 0;
+            GenTree* src   = tree->gtOp.gtOp2;
+
+            if (compiler->codeGen->gcInfo.gcIsWriteBarrierAsgNode(tree))
+            {
+                TreeNodeInfoInitGCWriteBarrier(tree);
+                break;
+            }
+            if (!varTypeIsFloating(src->TypeGet()) && src->IsIntegralConst(0))
+            {
+                // an integer zero for 'src' can be contained.
+                MakeSrcContained(tree, src);
+            }
+
+            TreeNodeInfoInitIndir(tree);
+        }
+        break;
+
+        case GT_NULLCHECK:
+            info->dstCount      = 0;
+            info->srcCount      = 1;
+            info->isLocalDefUse = true;
+            // null check is an indirection on an addr
+            TreeNodeInfoInitIndir(tree);
+            break;
+
+        case GT_IND:
+            info->dstCount = 1;
+            info->srcCount = 1;
+            TreeNodeInfoInitIndir(tree);
+            break;
+
+        case GT_CATCH_ARG:
+            info->srcCount = 0;
+            info->dstCount = 1;
+            info->setDstCandidates(l, RBM_EXCEPTION_OBJECT);
+            break;
+
+        case GT_CLS_VAR:
+            info->srcCount = 0;
+            // GT_CLS_VAR, by the time we reach the backend, must always
+            // be a pure use.
+            // It will produce a result of the type of the
+            // node, and use an internal register for the address.
+
+            info->dstCount = 1;
+            assert((tree->gtFlags & (GTF_VAR_DEF | GTF_VAR_USEASG | GTF_VAR_USEDEF)) == 0);
+            info->internalIntCount = 1;
+            break;
+    } // end switch (tree->OperGet())
+
+    // We need to be sure that we've set info->srcCount and info->dstCount appropriately
+    assert((info->dstCount < 2) || tree->IsMultiRegCall());
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitReturn: Set the NodeInfo for a GT_RETURN.
+//
+// Arguments:
+//    tree      - The node of interest
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitReturn(GenTree* tree)
+{
+    TreeNodeInfo* info     = &(tree->gtLsraInfo);
+    LinearScan*   l        = m_lsra;
+    Compiler*     compiler = comp;
+
+    GenTree*  op1           = tree->gtGetOp1();
+    regMaskTP useCandidates = RBM_NONE;
+
+    info->srcCount = (tree->TypeGet() == TYP_VOID) ? 0 : 1;
+    info->dstCount = 0;
+
+    if (varTypeIsStruct(tree))
+    {
+        // op1 has to be either an lclvar or a multi-reg returning call
+        if ((op1->OperGet() == GT_LCL_VAR) || (op1->OperGet() == GT_LCL_FLD))
+        {
+            GenTreeLclVarCommon* lclVarCommon = op1->AsLclVarCommon();
+            LclVarDsc*           varDsc       = &(compiler->lvaTable[lclVarCommon->gtLclNum]);
+            assert(varDsc->lvIsMultiRegRet);
+
+            // Mark var as contained if not enregistrable.
+            if (!varTypeIsEnregisterableStruct(op1))
+            {
+                MakeSrcContained(tree, op1);
+            }
+        }
+        else
+        {
+            noway_assert(op1->IsMultiRegCall());
+
+            ReturnTypeDesc* retTypeDesc = op1->AsCall()->GetReturnTypeDesc();
+            info->srcCount              = retTypeDesc->GetReturnRegCount();
+            useCandidates               = retTypeDesc->GetABIReturnRegs();
+        }
+    }
+    else
+    {
+        // Non-struct type return - determine useCandidates
+        switch (tree->TypeGet())
+        {
+            case TYP_VOID:
+                useCandidates = RBM_NONE;
+                break;
+            case TYP_FLOAT:
+                useCandidates = RBM_FLOATRET;
+                break;
+            case TYP_DOUBLE:
+                useCandidates = RBM_DOUBLERET;
+                break;
+            case TYP_LONG:
+                useCandidates = RBM_LNGRET;
+                break;
+            default:
+                useCandidates = RBM_INTRET;
+                break;
+        }
+    }
+
+    if (useCandidates != RBM_NONE)
+    {
+        tree->gtOp.gtOp1->gtLsraInfo.setSrcCandidates(l, useCandidates);
+    }
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitCall: Set the NodeInfo for a call.
+//
+// Arguments:
+//    call      - The call node of interest
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitCall(GenTreeCall* call)
+{
+    TreeNodeInfo*   info              = &(call->gtLsraInfo);
+    LinearScan*     l                 = m_lsra;
+    Compiler*       compiler          = comp;
+    bool            hasMultiRegRetVal = false;
+    ReturnTypeDesc* retTypeDesc       = nullptr;
+
+    info->srcCount = 0;
+    if (call->TypeGet() != TYP_VOID)
+    {
+        hasMultiRegRetVal = call->HasMultiRegRetVal();
+        if (hasMultiRegRetVal)
+        {
+            // dst count = number of registers in which the value is returned by call
+            retTypeDesc    = call->GetReturnTypeDesc();
+            info->dstCount = retTypeDesc->GetReturnRegCount();
+        }
+        else
+        {
+            info->dstCount = 1;
+        }
+    }
+    else
+    {
+        info->dstCount = 0;
+    }
+
+    GenTree* ctrlExpr = call->gtControlExpr;
+    if (call->gtCallType == CT_INDIRECT)
+    {
+        // either gtControlExpr != null or gtCallAddr != null.
+        // Both cannot be non-null at the same time.
+        assert(ctrlExpr == nullptr);
+        assert(call->gtCallAddr != nullptr);
+        ctrlExpr = call->gtCallAddr;
+    }
+
+    // set reg requirements on call target represented as control sequence.
+    if (ctrlExpr != nullptr)
+    {
+        // we should never see a gtControlExpr whose type is void.
+        assert(ctrlExpr->TypeGet() != TYP_VOID);
+
+        info->srcCount++;
+
+        // In case of fast tail implemented as jmp, make sure that gtControlExpr is
+        // computed into a register.
+        if (call->IsFastTailCall())
+        {
+            // Fast tail call - make sure that call target is always computed in IP0
+            // so that epilog sequence can generate "br xip0" to achieve fast tail call.
+            ctrlExpr->gtLsraInfo.setSrcCandidates(l, genRegMask(REG_IP0));
+        }
+    }
+
+    RegisterType registerType = call->TypeGet();
+
+    // Set destination candidates for return value of the call.
+    if (hasMultiRegRetVal)
+    {
+        assert(retTypeDesc != nullptr);
+        info->setDstCandidates(l, retTypeDesc->GetABIReturnRegs());
+    }
+    else if (varTypeIsFloating(registerType))
+    {
+        info->setDstCandidates(l, RBM_FLOATRET);
+    }
+    else if (registerType == TYP_LONG)
+    {
+        info->setDstCandidates(l, RBM_LNGRET);
+    }
+    else
+    {
+        info->setDstCandidates(l, RBM_INTRET);
+    }
+
+    // If there is an explicit this pointer, we don't want that node to produce anything
+    // as it is redundant
+    if (call->gtCallObjp != nullptr)
+    {
+        GenTreePtr thisPtrNode = call->gtCallObjp;
+
+        if (thisPtrNode->gtOper == GT_PUTARG_REG)
+        {
+            l->clearOperandCounts(thisPtrNode);
+            l->clearDstCount(thisPtrNode->gtOp.gtOp1);
+        }
+        else
+        {
+            l->clearDstCount(thisPtrNode);
+        }
+    }
+
+    // First, count reg args
+    bool callHasFloatRegArgs = false;
+
+    for (GenTreePtr list = call->gtCallLateArgs; list; list = list->MoveNext())
+    {
+        assert(list->OperIsList());
+
+        GenTreePtr argNode = list->Current();
+
+        fgArgTabEntryPtr curArgTabEntry = compiler->gtArgEntryByNode(call, argNode);
+        assert(curArgTabEntry);
+
+        if (curArgTabEntry->regNum == REG_STK)
+        {
+            // late arg that is not passed in a register
+            assert(argNode->gtOper == GT_PUTARG_STK);
+
+            TreeNodeInfoInitPutArgStk(argNode->AsPutArgStk(), curArgTabEntry);
+            continue;
+        }
+
+        var_types argType    = argNode->TypeGet();
+        bool      argIsFloat = varTypeIsFloating(argType);
+        callHasFloatRegArgs |= argIsFloat;
+
+        regNumber argReg = curArgTabEntry->regNum;
+        // We will setup argMask to the set of all registers that compose this argument
+        regMaskTP argMask = 0;
+
+        argNode = argNode->gtEffectiveVal();
+
+        // A GT_FIELD_LIST has a TYP_VOID, but is used to represent a multireg struct
+        if (varTypeIsStruct(argNode) || (argNode->gtOper == GT_FIELD_LIST))
+        {
+            GenTreePtr actualArgNode = argNode;
+            unsigned   originalSize  = 0;
+
+            if (argNode->gtOper == GT_FIELD_LIST)
+            {
+                // There could be up to 2-4 PUTARG_REGs in the list (3 or 4 can only occur for HFAs)
+                GenTreeFieldList* fieldListPtr = argNode->AsFieldList();
+
+                // Initailize the first register and the first regmask in our list
+                regNumber targetReg    = argReg;
+                regMaskTP targetMask   = genRegMask(targetReg);
+                unsigned  iterationNum = 0;
+                originalSize           = 0;
+
+                for (; fieldListPtr; fieldListPtr = fieldListPtr->Rest())
+                {
+                    GenTreePtr putArgRegNode = fieldListPtr->Current();
+                    assert(putArgRegNode->gtOper == GT_PUTARG_REG);
+                    GenTreePtr putArgChild = putArgRegNode->gtOp.gtOp1;
+
+                    originalSize += REGSIZE_BYTES; // 8 bytes
+
+                    // Record the register requirements for the GT_PUTARG_REG node
+                    putArgRegNode->gtLsraInfo.setDstCandidates(l, targetMask);
+                    putArgRegNode->gtLsraInfo.setSrcCandidates(l, targetMask);
+
+                    // To avoid redundant moves, request that the argument child tree be
+                    // computed in the register in which the argument is passed to the call.
+                    putArgChild->gtLsraInfo.setSrcCandidates(l, targetMask);
+
+                    // We consume one source for each item in this list
+                    info->srcCount++;
+                    iterationNum++;
+
+                    // Update targetReg and targetMask for the next putarg_reg (if any)
+                    targetReg  = genRegArgNext(targetReg);
+                    targetMask = genRegMask(targetReg);
+                }
+            }
+            else
+            {
+#ifdef DEBUG
+                compiler->gtDispTreeRange(BlockRange(), argNode);
+#endif
+                noway_assert(!"Unsupported TYP_STRUCT arg kind");
+            }
+
+            unsigned  slots          = ((unsigned)(roundUp(originalSize, REGSIZE_BYTES))) / REGSIZE_BYTES;
+            regNumber curReg         = argReg;
+            regNumber lastReg        = argIsFloat ? REG_ARG_FP_LAST : REG_ARG_LAST;
+            unsigned  remainingSlots = slots;
+
+            while (remainingSlots > 0)
+            {
+                argMask |= genRegMask(curReg);
+                remainingSlots--;
+
+                if (curReg == lastReg)
+                    break;
+
+                curReg = genRegArgNext(curReg);
+            }
+
+            // Struct typed arguments must be fully passed in registers (Reg/Stk split not allowed)
+            noway_assert(remainingSlots == 0);
+            argNode->gtLsraInfo.internalIntCount = 0;
+        }
+        else // A scalar argument (not a struct)
+        {
+            // We consume one source
+            info->srcCount++;
+
+            argMask |= genRegMask(argReg);
+            argNode->gtLsraInfo.setDstCandidates(l, argMask);
+            argNode->gtLsraInfo.setSrcCandidates(l, argMask);
+
+            if (argNode->gtOper == GT_PUTARG_REG)
+            {
+                GenTreePtr putArgChild = argNode->gtOp.gtOp1;
+
+                // To avoid redundant moves, request that the argument child tree be
+                // computed in the register in which the argument is passed to the call.
+                putArgChild->gtLsraInfo.setSrcCandidates(l, argMask);
+            }
+        }
+    }
+
+    // Now, count stack args
+    // Note that these need to be computed into a register, but then
+    // they're just stored to the stack - so the reg doesn't
+    // need to remain live until the call.  In fact, it must not
+    // because the code generator doesn't actually consider it live,
+    // so it can't be spilled.
+
+    GenTreePtr args = call->gtCallArgs;
+    while (args)
+    {
+        GenTreePtr arg = args->gtOp.gtOp1;
+
+        // Skip arguments that have been moved to the Late Arg list
+        if (!(args->gtFlags & GTF_LATE_ARG))
+        {
+            if (arg->gtOper == GT_PUTARG_STK)
+            {
+                fgArgTabEntryPtr curArgTabEntry = compiler->gtArgEntryByNode(call, arg);
+                assert(curArgTabEntry);
+
+                assert(curArgTabEntry->regNum == REG_STK);
+
+                TreeNodeInfoInitPutArgStk(arg->AsPutArgStk(), curArgTabEntry);
+            }
+            else
+            {
+                TreeNodeInfo* argInfo = &(arg->gtLsraInfo);
+                if (argInfo->dstCount != 0)
+                {
+                    argInfo->isLocalDefUse = true;
+                }
+
+                argInfo->dstCount = 0;
+            }
+        }
+        args = args->gtOp.gtOp2;
+    }
+
+    // If it is a fast tail call, it is already preferenced to use IP0.
+    // Therefore, no need set src candidates on call tgt again.
+    if (call->IsVarargs() && callHasFloatRegArgs && !call->IsFastTailCall() && (ctrlExpr != nullptr))
+    {
+        // Don't assign the call target to any of the argument registers because
+        // we will use them to also pass floating point arguments as required
+        // by Arm64 ABI.
+        ctrlExpr->gtLsraInfo.setSrcCandidates(l, l->allRegs(TYP_INT) & ~(RBM_ARG_REGS));
+    }
+}
+
+//------------------------------------------------------------------------
+//  TreeNodeInfoInitPutArgStk: Set the NodeInfo for a GT_PUTARG_STK node
+//
+// Arguments:
+//    argNode       - a GT_PUTARG_STK node
+//
+// Return Value:
+//    None.
+//
+// Notes:
+//    Set the child node(s) to be contained when we have a multireg arg
+//
+void Lowering::TreeNodeInfoInitPutArgStk(GenTreePutArgStk* argNode, fgArgTabEntryPtr info)
+{
+    assert(argNode->gtOper == GT_PUTARG_STK);
+
+    GenTreePtr putArgChild = argNode->gtOp.gtOp1;
+
+    // Initialize 'argNode' as not contained, as this is both the default case
+    //  and how MakeSrcContained expects to find things setup.
+    //
+    argNode->gtLsraInfo.srcCount = 1;
+    argNode->gtLsraInfo.dstCount = 0;
+
+    // Do we have a TYP_STRUCT argument (or a GT_FIELD_LIST), if so it must be a multireg pass-by-value struct
+    if ((putArgChild->TypeGet() == TYP_STRUCT) || (putArgChild->OperGet() == GT_FIELD_LIST))
+    {
+        // We will use store instructions that each write a register sized value
+
+        if (putArgChild->OperGet() == GT_FIELD_LIST)
+        {
+            // We consume all of the items in the GT_FIELD_LIST
+            argNode->gtLsraInfo.srcCount = info->numSlots;
+        }
+        else
+        {
+            // We could use a ldp/stp sequence so we need two internal registers
+            argNode->gtLsraInfo.internalIntCount = 2;
+
+            if (putArgChild->OperGet() == GT_OBJ)
+            {
+                GenTreePtr objChild = putArgChild->gtOp.gtOp1;
+                if (objChild->OperGet() == GT_LCL_VAR_ADDR)
+                {
+                    // We will generate all of the code for the GT_PUTARG_STK, the GT_OBJ and the GT_LCL_VAR_ADDR
+                    // as one contained operation
+                    //
+                    MakeSrcContained(putArgChild, objChild);
+                }
+            }
+
+            // We will generate all of the code for the GT_PUTARG_STK and it's child node
+            // as one contained operation
+            //
+            MakeSrcContained(argNode, putArgChild);
+        }
+    }
+    else
+    {
+        // We must not have a multi-reg struct
+        assert(info->numSlots == 1);
+    }
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitBlockStore: Set the NodeInfo for a block store.
+//
+// Arguments:
+//    blkNode       - The block store node of interest
+//
+// Return Value:
+//    None.
+//
+// Notes:
+
+void Lowering::TreeNodeInfoInitBlockStore(GenTreeBlk* blkNode)
+{
+    GenTree*    dstAddr  = blkNode->Addr();
+    unsigned    size     = blkNode->gtBlkSize;
+    GenTree*    source   = blkNode->Data();
+    LinearScan* l        = m_lsra;
+    Compiler*   compiler = comp;
+
+    // Sources are dest address and initVal or source.
+    // We may require an additional source or temp register for the size.
+    blkNode->gtLsraInfo.srcCount = 2;
+    blkNode->gtLsraInfo.dstCount = 0;
+    GenTreePtr srcAddrOrFill     = nullptr;
+    bool       isInitBlk         = blkNode->OperIsInitBlkOp();
+
+    if (!isInitBlk)
+    {
+        // CopyObj or CopyBlk
+        if (source->gtOper == GT_IND)
+        {
+            srcAddrOrFill = blkNode->Data()->gtGetOp1();
+            // We're effectively setting source as contained, but can't call MakeSrcContained, because the
+            // "inheritance" of the srcCount is to a child not a parent - it would "just work" but could be misleading.
+            // If srcAddr is already non-contained, we don't need to change it.
+            if (srcAddrOrFill->gtLsraInfo.getDstCount() == 0)
+            {
+                srcAddrOrFill->gtLsraInfo.setDstCount(1);
+                srcAddrOrFill->gtLsraInfo.setSrcCount(source->gtLsraInfo.srcCount);
+            }
+            m_lsra->clearOperandCounts(source);
+        }
+        else if (!source->IsMultiRegCall() && !source->OperIsSIMD())
+        {
+            assert(source->IsLocal());
+            MakeSrcContained(blkNode, source);
+        }
+    }
+
+    if (isInitBlk)
+    {
+        GenTreePtr initVal = source;
+        if (initVal->OperIsInitVal())
+        {
+            initVal = initVal->gtGetOp1();
+        }
+        srcAddrOrFill = initVal;
+
+#if 0
+        if (blkNode->gtBlkOpKind == GenTreeBlk::BlkOpKindUnroll)
+        {
+            // TODO-ARM64-CQ: Currently we generate a helper call for every
+            // initblk we encounter.  Later on we should implement loop unrolling
+            // code sequences to improve CQ.
+            // For reference see the code in lsraxarch.cpp.
+        }
+        else
+#endif // 0
+        {
+            assert(blkNode->gtBlkOpKind == GenTreeBlk::BlkOpKindHelper);
+            // The helper follows the regular ABI.
+            dstAddr->gtLsraInfo.setSrcCandidates(l, RBM_ARG_0);
+            initVal->gtLsraInfo.setSrcCandidates(l, RBM_ARG_1);
+            if (size != 0)
+            {
+                // Reserve a temp register for the block size argument.
+                blkNode->gtLsraInfo.setInternalCandidates(l, RBM_ARG_2);
+                blkNode->gtLsraInfo.internalIntCount = 1;
+            }
+            else
+            {
+                // The block size argument is a third argument to GT_STORE_DYN_BLK
+                noway_assert(blkNode->gtOper == GT_STORE_DYN_BLK);
+                blkNode->gtLsraInfo.setSrcCount(3);
+                GenTree* sizeNode = blkNode->AsDynBlk()->gtDynamicSize;
+                sizeNode->gtLsraInfo.setSrcCandidates(l, RBM_ARG_2);
+            }
+        }
+    }
+    else
+    {
+        // CopyObj or CopyBlk
+        // Sources are src and dest and size if not constant.
+
+        if (blkNode->OperGet() == GT_STORE_OBJ)
+        {
+            // CopyObj
+
+            // We don't need to materialize the struct size but we still need
+            // a temporary register to perform the sequence of loads and stores.
+            blkNode->gtLsraInfo.internalIntCount = 1;
+
+            dstAddr->gtLsraInfo.setSrcCandidates(l, RBM_WRITE_BARRIER_DST_BYREF);
+            // If we have a source address we want it in REG_WRITE_BARRIER_SRC_BYREF.
+            // Otherwise, if it is a local, codegen will put its address in REG_WRITE_BARRIER_SRC_BYREF,
+            // which is killed by a StoreObj (and thus needn't be reserved).
+            if (srcAddrOrFill != nullptr)
+            {
+                srcAddrOrFill->gtLsraInfo.setSrcCandidates(l, RBM_WRITE_BARRIER_SRC_BYREF);
+            }
+        }
+        else
+        {
+            // CopyBlk
+            short     internalIntCount      = 0;
+            regMaskTP internalIntCandidates = RBM_NONE;
+
+#if 0
+            if (blkNode->gtBlkOpKind == GenTreeBlk::BlkOpKindUnroll)
+            {
+                // TODO-ARM64-CQ: cpblk loop unrolling is currently not implemented.
+                // In case of a CpBlk with a constant size and less than CPBLK_UNROLL_LIMIT size
+                // we should unroll the loop to improve CQ.
+                // For reference see the code in lsraxarch.cpp.
+            }
+            else
+#endif // 0
+            {
+                assert(blkNode->gtBlkOpKind == GenTreeBlk::BlkOpKindHelper);
+                dstAddr->gtLsraInfo.setSrcCandidates(l, RBM_ARG_0);
+                // The srcAddr goes in arg1.
+                if (srcAddrOrFill != nullptr)
+                {
+                    srcAddrOrFill->gtLsraInfo.setSrcCandidates(l, RBM_ARG_1);
+                }
+                if (size != 0)
+                {
+                    // Reserve a temp register for the block size argument.
+                    internalIntCandidates |= RBM_ARG_2;
+                    internalIntCount++;
+                }
+                else
+                {
+                    // The block size argument is a third argument to GT_STORE_DYN_BLK
+                    noway_assert(blkNode->gtOper == GT_STORE_DYN_BLK);
+                    blkNode->gtLsraInfo.setSrcCount(3);
+                    GenTree* blockSize = blkNode->AsDynBlk()->gtDynamicSize;
+                    blockSize->gtLsraInfo.setSrcCandidates(l, RBM_ARG_2);
+                }
+            }
+            if (internalIntCount != 0)
+            {
+                blkNode->gtLsraInfo.internalIntCount = internalIntCount;
+                blkNode->gtLsraInfo.setInternalCandidates(l, internalIntCandidates);
+            }
+        }
+    }
+}
+
+#ifdef FEATURE_SIMD
+//------------------------------------------------------------------------
+// TreeNodeInfoInitSIMD: Set the NodeInfo for a GT_SIMD tree.
+//
+// Arguments:
+//    tree       - The GT_SIMD node of interest
+//
+// Return Value:
+//    None.
+
+void Lowering::TreeNodeInfoInitSIMD(GenTree* tree)
+{
+    NYI("TreeNodeInfoInitSIMD");
+    GenTreeSIMD*  simdTree = tree->AsSIMD();
+    TreeNodeInfo* info     = &(tree->gtLsraInfo);
+    LinearScan*   lsra     = m_lsra;
+    info->dstCount         = 1;
+    switch (simdTree->gtSIMDIntrinsicID)
+    {
+        case SIMDIntrinsicInit:
+        {
+            // This sets all fields of a SIMD struct to the given value.
+            // Mark op1 as contained if it is either zero or int constant of all 1's.
+            info->srcCount = 1;
+            GenTree* op1   = tree->gtOp.gtOp1;
+            if (op1->IsIntegralConst(0) || (simdTree->gtSIMDBaseType == TYP_INT && op1->IsCnsIntOrI() &&
+                                            op1->AsIntConCommon()->IconValue() == 0xffffffff) ||
+                (simdTree->gtSIMDBaseType == TYP_LONG && op1->IsCnsIntOrI() &&
+                 op1->AsIntConCommon()->IconValue() == 0xffffffffffffffffLL))
+            {
+                MakeSrcContained(tree, tree->gtOp.gtOp1);
+                info->srcCount = 0;
+            }
+        }
+        break;
+
+        case SIMDIntrinsicInitN:
+            info->srcCount = (int)(simdTree->gtSIMDSize / genTypeSize(simdTree->gtSIMDBaseType));
+            // Need an internal register to stitch together all the values into a single vector in an XMM reg.
+            info->internalFloatCount = 1;
+            info->setInternalCandidates(lsra, lsra->allSIMDRegs());
+            break;
+
+        case SIMDIntrinsicInitArray:
+            // We have an array and an index, which may be contained.
+            info->srcCount = 2;
+            CheckImmedAndMakeContained(tree, tree->gtGetOp2());
+            break;
+
+        case SIMDIntrinsicDiv:
+            // SSE2 has no instruction support for division on integer vectors
+            noway_assert(varTypeIsFloating(simdTree->gtSIMDBaseType));
+            info->srcCount = 2;
+            break;
+
+        case SIMDIntrinsicAbs:
+            // This gets implemented as bitwise-And operation with a mask
+            // and hence should never see it here.
+            unreached();
+            break;
+
+        case SIMDIntrinsicSqrt:
+            // SSE2 has no instruction support for sqrt on integer vectors.
+            noway_assert(varTypeIsFloating(simdTree->gtSIMDBaseType));
+            info->srcCount = 1;
+            break;
+
+        case SIMDIntrinsicAdd:
+        case SIMDIntrinsicSub:
+        case SIMDIntrinsicMul:
+        case SIMDIntrinsicBitwiseAnd:
+        case SIMDIntrinsicBitwiseAndNot:
+        case SIMDIntrinsicBitwiseOr:
+        case SIMDIntrinsicBitwiseXor:
+        case SIMDIntrinsicMin:
+        case SIMDIntrinsicMax:
+            info->srcCount = 2;
+
+            // SSE2 32-bit integer multiplication requires two temp regs
+            if (simdTree->gtSIMDIntrinsicID == SIMDIntrinsicMul && simdTree->gtSIMDBaseType == TYP_INT)
+            {
+                info->internalFloatCount = 2;
+                info->setInternalCandidates(lsra, lsra->allSIMDRegs());
+            }
+            break;
+
+        case SIMDIntrinsicEqual:
+            info->srcCount = 2;
+            break;
+
+        // SSE2 doesn't support < and <= directly on int vectors.
+        // Instead we need to use > and >= with swapped operands.
+        case SIMDIntrinsicLessThan:
+        case SIMDIntrinsicLessThanOrEqual:
+            info->srcCount = 2;
+            noway_assert(!varTypeIsIntegral(simdTree->gtSIMDBaseType));
+            break;
+
+        // SIMDIntrinsicEqual is supported only on non-floating point base type vectors.
+        // SSE2 cmpps/pd doesn't support > and >=  directly on float/double vectors.
+        // Instead we need to use <  and <= with swapped operands.
+        case SIMDIntrinsicGreaterThan:
+            noway_assert(!varTypeIsFloating(simdTree->gtSIMDBaseType));
+            info->srcCount = 2;
+            break;
+
+        case SIMDIntrinsicGreaterThanOrEqual:
+            noway_assert(!varTypeIsFloating(simdTree->gtSIMDBaseType));
+            info->srcCount = 2;
+
+            // a >= b = (a==b) | (a>b)
+            // To hold intermediate result of a==b and a>b we need two distinct
+            // registers.  We can use targetReg and one internal reg provided
+            // they are distinct which is not guaranteed. Therefore, we request
+            // two internal registers so that one of the internal registers has
+            // to be different from targetReg.
+            info->internalFloatCount = 2;
+            info->setInternalCandidates(lsra, lsra->allSIMDRegs());
+            break;
+
+        case SIMDIntrinsicOpEquality:
+        case SIMDIntrinsicOpInEquality:
+            // Need two SIMD registers as scratch.
+            // See genSIMDIntrinsicRelOp() for details on code sequence generate and
+            // the need for two scratch registers.
+            info->srcCount           = 2;
+            info->internalFloatCount = 2;
+            info->setInternalCandidates(lsra, lsra->allSIMDRegs());
+            break;
+
+        case SIMDIntrinsicDotProduct:
+            // Also need an internal register as scratch. Further we need that targetReg and internal reg
+            // are two distinct regs.  It is achieved by requesting two internal registers and one of them
+            // has to be different from targetReg.
+            //
+            // See genSIMDIntrinsicDotProduct() for details on code sequence generated and
+            // the need for scratch registers.
+            info->srcCount           = 2;
+            info->internalFloatCount = 2;
+            info->setInternalCandidates(lsra, lsra->allSIMDRegs());
+            break;
+
+        case SIMDIntrinsicGetItem:
+            // This implements get_Item method. The sources are:
+            //  - the source SIMD struct
+            //  - index (which element to get)
+            // The result is baseType of SIMD struct.
+            info->srcCount = 2;
+
+            op2 = tree->gtGetOp2();
+
+            // If the index is a constant, mark it as contained.
+            if (CheckImmedAndMakeContained(tree, op2))
+            {
+                info->srcCount = 1;
+            }
+
+            // If the index is not a constant, we will use the SIMD temp location to store the vector.
+            // Otherwise, if the baseType is floating point, the targetReg will be a xmm reg and we
+            // can use that in the process of extracting the element.
+            // In all other cases with constant index, we need a temp xmm register to extract the
+            // element if index is other than zero.
+            if (!op2->IsCnsIntOrI())
+            {
+                (void)comp->getSIMDInitTempVarNum();
+            }
+            else if (!varTypeIsFloating(simdTree->gtSIMDBaseType) && !op2->IsIntegralConst(0))
+            {
+                info->internalFloatCount = 1;
+                info->setInternalCandidates(lsra, lsra->allSIMDRegs());
+            }
+            break;
+
+        case SIMDIntrinsicCast:
+            info->srcCount = 1;
+            break;
+
+        // These should have been transformed in terms of other intrinsics
+        case SIMDIntrinsicOpEquality:
+        case SIMDIntrinsicOpInEquality:
+            assert("OpEquality/OpInEquality intrinsics should not be seen during Lowering.");
+            unreached();
+
+        case SIMDIntrinsicGetX:
+        case SIMDIntrinsicGetY:
+        case SIMDIntrinsicGetZ:
+        case SIMDIntrinsicGetW:
+        case SIMDIntrinsicGetOne:
+        case SIMDIntrinsicGetZero:
+        case SIMDIntrinsicGetLength:
+        case SIMDIntrinsicGetAllOnes:
+            assert(!"Get intrinsics should not be seen during Lowering.");
+            unreached();
+
+        default:
+            noway_assert(!"Unimplemented SIMD node type.");
+            unreached();
+    }
+}
+#endif // FEATURE_SIMD
+
+void Lowering::TreeNodeInfoInitGCWriteBarrier(GenTree* tree)
+{
+    GenTreePtr dst  = tree;
+    GenTreePtr addr = tree->gtOp.gtOp1;
+    GenTreePtr src  = tree->gtOp.gtOp2;
+
+    if (addr->OperGet() == GT_LEA)
+    {
+        // In the case where we are doing a helper assignment, if the dst
+        // is an indir through an lea, we need to actually instantiate the
+        // lea in a register
+        GenTreeAddrMode* lea = addr->AsAddrMode();
+
+        short leaSrcCount = 0;
+        if (lea->Base() != nullptr)
+        {
+            leaSrcCount++;
+        }
+        if (lea->Index() != nullptr)
+        {
+            leaSrcCount++;
+        }
+        lea->gtLsraInfo.srcCount = leaSrcCount;
+        lea->gtLsraInfo.dstCount = 1;
+    }
+
+#if NOGC_WRITE_BARRIERS
+    // For the NOGC JIT Helper calls
+    //
+    // the 'addr' goes into x14 (REG_WRITE_BARRIER_DST_BYREF)
+    // the 'src'  goes into x15 (REG_WRITE_BARRIER)
+    //
+    addr->gtLsraInfo.setSrcCandidates(m_lsra, RBM_WRITE_BARRIER_DST_BYREF);
+    src->gtLsraInfo.setSrcCandidates(m_lsra, RBM_WRITE_BARRIER);
+#else
+    // For the standard JIT Helper calls
+    // op1 goes into REG_ARG_0 and
+    // op2 goes into REG_ARG_1
+    //
+    addr->gtLsraInfo.setSrcCandidates(m_lsra, RBM_ARG_0);
+    src->gtLsraInfo.setSrcCandidates(m_lsra, RBM_ARG_1);
+#endif // NOGC_WRITE_BARRIERS
+
+    // Both src and dst must reside in a register, which they should since we haven't set
+    // either of them as contained.
+    assert(addr->gtLsraInfo.dstCount == 1);
+    assert(src->gtLsraInfo.dstCount == 1);
+}
+
+//-----------------------------------------------------------------------------------------
+// TreeNodeInfoInitIndir: Specify register requirements for address expression of an indirection operation.
+//
+// Arguments:
+//    indirTree    -   GT_IND or GT_STOREIND gentree node
+//
+void Lowering::TreeNodeInfoInitIndir(GenTreePtr indirTree)
+{
+    assert(indirTree->OperIsIndir());
+    // If this is the rhs of a block copy (i.e. non-enregisterable struct),
+    // it has no register requirements.
+    if (indirTree->TypeGet() == TYP_STRUCT)
+    {
+        return;
+    }
+
+    GenTreePtr    addr = indirTree->gtGetOp1();
+    TreeNodeInfo* info = &(indirTree->gtLsraInfo);
+
+    GenTreePtr base  = nullptr;
+    GenTreePtr index = nullptr;
+    unsigned   cns   = 0;
+    unsigned   mul;
+    bool       rev;
+    bool       modifiedSources = false;
+
+    if ((addr->OperGet() == GT_LEA) && IsSafeToContainMem(indirTree, addr))
+    {
+        GenTreeAddrMode* lea = addr->AsAddrMode();
+        base                 = lea->Base();
+        index                = lea->Index();
+        cns                  = lea->gtOffset;
+
+        m_lsra->clearOperandCounts(addr);
+        // The srcCount is decremented because addr is now "contained",
+        // then we account for the base and index below, if they are non-null.
+        info->srcCount--;
+    }
+    else if (comp->codeGen->genCreateAddrMode(addr, -1, true, 0, &rev, &base, &index, &mul, &cns, true /*nogen*/) &&
+             !(modifiedSources = AreSourcesPossiblyModifiedLocals(indirTree, base, index)))
+    {
+        // An addressing mode will be constructed that may cause some
+        // nodes to not need a register, and cause others' lifetimes to be extended
+        // to the GT_IND or even its parent if it's an assignment
+
+        assert(base != addr);
+        m_lsra->clearOperandCounts(addr);
+
+        GenTreePtr arrLength = nullptr;
+
+        // Traverse the computation below GT_IND to find the operands
+        // for the addressing mode, marking the various constants and
+        // intermediate results as not consuming/producing.
+        // If the traversal were more complex, we might consider using
+        // a traversal function, but the addressing mode is only made
+        // up of simple arithmetic operators, and the code generator
+        // only traverses one leg of each node.
+
+        bool       foundBase  = (base == nullptr);
+        bool       foundIndex = (index == nullptr);
+        GenTreePtr nextChild  = nullptr;
+        for (GenTreePtr child = addr; child != nullptr && !child->OperIsLeaf(); child = nextChild)
+        {
+            nextChild      = nullptr;
+            GenTreePtr op1 = child->gtOp.gtOp1;
+            GenTreePtr op2 = (child->OperIsBinary()) ? child->gtOp.gtOp2 : nullptr;
+
+            if (op1 == base)
+            {
+                foundBase = true;
+            }
+            else if (op1 == index)
+            {
+                foundIndex = true;
+            }
+            else
+            {
+                m_lsra->clearOperandCounts(op1);
+                if (!op1->OperIsLeaf())
+                {
+                    nextChild = op1;
+                }
+            }
+
+            if (op2 != nullptr)
+            {
+                if (op2 == base)
+                {
+                    foundBase = true;
+                }
+                else if (op2 == index)
+                {
+                    foundIndex = true;
+                }
+                else
+                {
+                    m_lsra->clearOperandCounts(op2);
+                    if (!op2->OperIsLeaf())
+                    {
+                        assert(nextChild == nullptr);
+                        nextChild = op2;
+                    }
+                }
+            }
+        }
+        assert(foundBase && foundIndex);
+        info->srcCount--; // it gets incremented below.
+    }
+    else if (addr->gtOper == GT_ARR_ELEM)
+    {
+        // The GT_ARR_ELEM consumes all the indices and produces the offset.
+        // The array object lives until the mem access.
+        // We also consume the target register to which the address is
+        // computed
+
+        info->srcCount++;
+        assert(addr->gtLsraInfo.srcCount >= 2);
+        addr->gtLsraInfo.srcCount -= 1;
+    }
+    else
+    {
+        // it is nothing but a plain indir
+        info->srcCount--; // base gets added in below
+        base = addr;
+    }
+
+    if (base != nullptr)
+    {
+        info->srcCount++;
+    }
+
+    if (index != nullptr && !modifiedSources)
+    {
+        info->srcCount++;
+    }
+
+    // On ARM64 we may need a single internal register
+    // (when both conditions are true then we still only need a single internal register)
+    if ((index != nullptr) && (cns != 0))
+    {
+        // ARM64 does not support both Index and offset so we need an internal register
+        info->internalIntCount = 1;
+    }
+    else if (!emitter::emitIns_valid_imm_for_ldst_offset(cns, emitTypeSize(indirTree)))
+    {
+        // This offset can't be contained in the ldr/str instruction, so we need an internal register
+        info->internalIntCount = 1;
+    }
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitCmp: Set the register requirements for a compare.
+//
+// Arguments:
+//    tree      - The node of interest
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitCmp(GenTreePtr tree)
+{
+    TreeNodeInfo* info = &(tree->gtLsraInfo);
+
+    info->srcCount = 2;
+    info->dstCount = 1;
+    CheckImmedAndMakeContained(tree, tree->gtOp.gtOp2);
+}
+
+#endif // _TARGET_ARM64_
+
+#endif // !LEGACY_BACKEND
diff --git a/src/jit/lsraxarch.cpp b/src/jit/lsraxarch.cpp
new file mode 100644
index 0000000000..a4da2b7ce6
--- /dev/null
+++ b/src/jit/lsraxarch.cpp
@@ -0,0 +1,3684 @@
+// 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.
+
+/*XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+XX                                                                           XX
+XX                    Register Requirements for AMD64                        XX
+XX                                                                           XX
+XX  This encapsulates all the logic for setting register requirements for    XX
+XX  the AMD64 architecture.                                                  XX
+XX                                                                           XX
+XX                                                                           XX
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+*/
+
+#include "jitpch.h"
+#ifdef _MSC_VER
+#pragma hdrstop
+#endif
+
+#ifndef LEGACY_BACKEND // This file is ONLY used for the RyuJIT backend that uses the linear scan register allocator
+
+#ifdef _TARGET_XARCH_
+
+#include "jit.h"
+#include "sideeffects.h"
+#include "lower.h"
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitStoreLoc: Set register requirements for a store of a lclVar
+//
+// Arguments:
+//    storeLoc - the local store (GT_STORE_LCL_FLD or GT_STORE_LCL_VAR)
+//
+// Notes:
+//    This involves:
+//    - Setting the appropriate candidates for a store of a multi-reg call return value.
+//    - Requesting an internal register for SIMD12 stores.
+//    - Handling of contained immediates.
+//    - Widening operations of unsigneds. (TODO: Move to 1st phase of Lowering)
+
+void Lowering::TreeNodeInfoInitStoreLoc(GenTreeLclVarCommon* storeLoc)
+{
+    TreeNodeInfo* info = &(storeLoc->gtLsraInfo);
+
+    // Is this the case of var = call where call is returning
+    // a value in multiple return registers?
+    GenTree* op1 = storeLoc->gtGetOp1();
+    if (op1->IsMultiRegCall())
+    {
+        // backend expects to see this case only for store lclvar.
+        assert(storeLoc->OperGet() == GT_STORE_LCL_VAR);
+
+        // srcCount = number of registers in which the value is returned by call
+        GenTreeCall*    call        = op1->AsCall();
+        ReturnTypeDesc* retTypeDesc = call->GetReturnTypeDesc();
+        info->srcCount              = retTypeDesc->GetReturnRegCount();
+
+        // Call node srcCandidates = Bitwise-OR(allregs(GetReturnRegType(i))) for all i=0..RetRegCount-1
+        regMaskTP srcCandidates = m_lsra->allMultiRegCallNodeRegs(call);
+        op1->gtLsraInfo.setSrcCandidates(m_lsra, srcCandidates);
+        return;
+    }
+
+#ifdef FEATURE_SIMD
+    if (varTypeIsSIMD(storeLoc))
+    {
+        if (op1->IsCnsIntOrI())
+        {
+            // InitBlk
+            MakeSrcContained(storeLoc, op1);
+        }
+        else if (storeLoc->TypeGet() == TYP_SIMD12)
+        {
+            // Need an additional register to extract upper 4 bytes of Vector3.
+            info->internalFloatCount = 1;
+            info->setInternalCandidates(m_lsra, m_lsra->allSIMDRegs());
+
+            // In this case don't mark the operand as contained as we want it to
+            // be evaluated into an xmm register
+        }
+        return;
+    }
+#endif // FEATURE_SIMD
+
+    // If the source is a containable immediate, make it contained, unless it is
+    // an int-size or larger store of zero to memory, because we can generate smaller code
+    // by zeroing a register and then storing it.
+    if (IsContainableImmed(storeLoc, op1) && (!op1->IsIntegralConst(0) || varTypeIsSmall(storeLoc)))
+    {
+        MakeSrcContained(storeLoc, op1);
+    }
+
+    // TODO: This should be moved to Lowering, but it widens the types, which changes the behavior
+    // of the above condition.
+    LowerStoreLoc(storeLoc);
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInit: Set register requirements for a node
+//
+// Arguments:
+//    treeNode - the node of interest
+//
+// Notes:
+// Preconditions:
+//    LSRA Has been initialized and there is a TreeNodeInfo node
+//    already allocated and initialized for every tree in the IR.
+// Postconditions:
+//    Every TreeNodeInfo instance has the right annotations on register
+//    requirements needed by LSRA to build the Interval Table (source,
+//    destination and internal [temp] register counts).
+//
+void Lowering::TreeNodeInfoInit(GenTree* tree)
+{
+    LinearScan* l        = m_lsra;
+    Compiler*   compiler = comp;
+
+    TreeNodeInfo* info = &(tree->gtLsraInfo);
+#ifdef DEBUG
+    if (comp->verbose)
+    {
+        printf("TreeNodeInfoInit:\n");
+        comp->gtDispTreeRange(BlockRange(), tree);
+    }
+#endif
+    // floating type generates AVX instruction (vmovss etc.), set the flag
+    SetContainsAVXFlags(varTypeIsFloating(tree->TypeGet()));
+    switch (tree->OperGet())
+    {
+        GenTree* op1;
+        GenTree* op2;
+
+        default:
+            TreeNodeInfoInitSimple(tree);
+            break;
+
+        case GT_LCL_FLD:
+        case GT_LCL_VAR:
+            info->srcCount = 0;
+            info->dstCount = 1;
+
+#ifdef FEATURE_SIMD
+            // Need an additional register to read upper 4 bytes of Vector3.
+            if (tree->TypeGet() == TYP_SIMD12)
+            {
+                // We need an internal register different from targetReg in which 'tree' produces its result
+                // because both targetReg and internal reg will be in use at the same time.
+                info->internalFloatCount     = 1;
+                info->isInternalRegDelayFree = true;
+                info->setInternalCandidates(m_lsra, m_lsra->allSIMDRegs());
+            }
+#endif
+            break;
+
+        case GT_STORE_LCL_FLD:
+        case GT_STORE_LCL_VAR:
+#ifdef _TARGET_X86_
+            if (tree->gtGetOp1()->OperGet() == GT_LONG)
+            {
+                info->srcCount = 2;
+            }
+            else
+#endif // _TARGET_X86_
+            {
+                info->srcCount = 1;
+            }
+            info->dstCount = 0;
+            TreeNodeInfoInitStoreLoc(tree->AsLclVarCommon());
+            break;
+
+        case GT_BOX:
+            noway_assert(!"box should not exist here");
+            // The result of 'op1' is also the final result
+            info->srcCount = 0;
+            info->dstCount = 0;
+            break;
+
+        case GT_PHYSREGDST:
+            info->srcCount = 1;
+            info->dstCount = 0;
+            break;
+
+        case GT_COMMA:
+        {
+            GenTreePtr firstOperand;
+            GenTreePtr secondOperand;
+            if (tree->gtFlags & GTF_REVERSE_OPS)
+            {
+                firstOperand  = tree->gtOp.gtOp2;
+                secondOperand = tree->gtOp.gtOp1;
+            }
+            else
+            {
+                firstOperand  = tree->gtOp.gtOp1;
+                secondOperand = tree->gtOp.gtOp2;
+            }
+            if (firstOperand->TypeGet() != TYP_VOID)
+            {
+                firstOperand->gtLsraInfo.isLocalDefUse = true;
+                firstOperand->gtLsraInfo.dstCount      = 0;
+            }
+            if (tree->TypeGet() == TYP_VOID && secondOperand->TypeGet() != TYP_VOID)
+            {
+                secondOperand->gtLsraInfo.isLocalDefUse = true;
+                secondOperand->gtLsraInfo.dstCount      = 0;
+            }
+        }
+            info->srcCount = 0;
+            info->dstCount = 0;
+            break;
+
+        case GT_LIST:
+        case GT_FIELD_LIST:
+        case GT_ARGPLACE:
+        case GT_NO_OP:
+        case GT_START_NONGC:
+        case GT_PROF_HOOK:
+            info->srcCount = 0;
+            info->dstCount = 0;
+            break;
+
+        case GT_CNS_DBL:
+            info->srcCount = 0;
+            info->dstCount = 1;
+            break;
+
+#if !defined(_TARGET_64BIT_)
+
+        case GT_LONG:
+            if ((tree->gtLIRFlags & LIR::Flags::IsUnusedValue) != 0)
+            {
+                // An unused GT_LONG node needs to consume its sources.
+                info->srcCount = 2;
+            }
+            else
+            {
+                // Passthrough
+                info->srcCount = 0;
+            }
+
+            info->dstCount = 0;
+            break;
+
+#endif // !defined(_TARGET_64BIT_)
+
+        case GT_QMARK:
+        case GT_COLON:
+            info->srcCount = 0;
+            info->dstCount = 0;
+            unreached();
+            break;
+
+        case GT_RETURN:
+            TreeNodeInfoInitReturn(tree);
+            break;
+
+        case GT_RETFILT:
+            if (tree->TypeGet() == TYP_VOID)
+            {
+                info->srcCount = 0;
+                info->dstCount = 0;
+            }
+            else
+            {
+                assert(tree->TypeGet() == TYP_INT);
+
+                info->srcCount = 1;
+                info->dstCount = 0;
+
+                info->setSrcCandidates(l, RBM_INTRET);
+                tree->gtOp.gtOp1->gtLsraInfo.setSrcCandidates(l, RBM_INTRET);
+            }
+            break;
+
+        // A GT_NOP is either a passthrough (if it is void, or if it has
+        // a child), but must be considered to produce a dummy value if it
+        // has a type but no child
+        case GT_NOP:
+            info->srcCount = 0;
+            if (tree->TypeGet() != TYP_VOID && tree->gtOp.gtOp1 == nullptr)
+            {
+                info->dstCount = 1;
+            }
+            else
+            {
+                info->dstCount = 0;
+            }
+            break;
+
+        case GT_JTRUE:
+        {
+            info->srcCount = 0;
+            info->dstCount = 0;
+
+            GenTree* cmp = tree->gtGetOp1();
+            l->clearDstCount(cmp);
+
+#ifdef FEATURE_SIMD
+            // Say we have the following IR
+            //   simdCompareResult = GT_SIMD((In)Equality, v1, v2)
+            //   integerCompareResult = GT_EQ/NE(simdCompareResult, true/false)
+            //   GT_JTRUE(integerCompareResult)
+            //
+            // In this case we don't need to generate code for GT_EQ_/NE, since SIMD (In)Equality
+            // intrinsic will set or clear the Zero flag.
+
+            genTreeOps cmpOper = cmp->OperGet();
+            if (cmpOper == GT_EQ || cmpOper == GT_NE)
+            {
+                GenTree* cmpOp1 = cmp->gtGetOp1();
+                GenTree* cmpOp2 = cmp->gtGetOp2();
+
+                if (cmpOp1->IsSIMDEqualityOrInequality() && (cmpOp2->IsIntegralConst(0) || cmpOp2->IsIntegralConst(1)))
+                {
+                    // We always generate code for a SIMD equality comparison, but the compare
+                    // is contained (evaluated as part of the GT_JTRUE).
+                    // Neither the SIMD node nor the immediate need to be evaluated into a register.
+                    l->clearOperandCounts(cmp);
+                    l->clearDstCount(cmpOp1);
+                    l->clearOperandCounts(cmpOp2);
+
+                    // Codegen of SIMD (in)Equality uses target integer reg only for setting flags.
+                    // A target reg is not needed on AVX when comparing against Vector Zero.
+                    // In all other cases we need to reserve an int type internal register, since we
+                    // have cleared dstCount.
+                    if (!compiler->canUseAVX() || !cmpOp1->gtGetOp2()->IsIntegralConstVector(0))
+                    {
+                        ++(cmpOp1->gtLsraInfo.internalIntCount);
+                        regMaskTP internalCandidates = cmpOp1->gtLsraInfo.getInternalCandidates(l);
+                        internalCandidates |= l->allRegs(TYP_INT);
+                        cmpOp1->gtLsraInfo.setInternalCandidates(l, internalCandidates);
+                    }
+
+                    // We have to reverse compare oper in the following cases:
+                    // 1) SIMD Equality: Sets Zero flag on equal otherwise clears it.
+                    //    Therefore, if compare oper is == or != against false(0), we will
+                    //    be checking opposite of what is required.
+                    //
+                    // 2) SIMD inEquality: Clears Zero flag on true otherwise sets it.
+                    //    Therefore, if compare oper is == or != against true(1), we will
+                    //    be checking opposite of what is required.
+                    GenTreeSIMD* simdNode = cmpOp1->AsSIMD();
+                    if (simdNode->gtSIMDIntrinsicID == SIMDIntrinsicOpEquality)
+                    {
+                        if (cmpOp2->IsIntegralConst(0))
+                        {
+                            cmp->SetOper(GenTree::ReverseRelop(cmpOper));
+                        }
+                    }
+                    else
+                    {
+                        assert(simdNode->gtSIMDIntrinsicID == SIMDIntrinsicOpInEquality);
+                        if (cmpOp2->IsIntegralConst(1))
+                        {
+                            cmp->SetOper(GenTree::ReverseRelop(cmpOper));
+                        }
+                    }
+                }
+            }
+#endif // FEATURE_SIMD
+        }
+        break;
+
+        case GT_JCC:
+            info->srcCount = 0;
+            info->dstCount = 0;
+            break;
+
+        case GT_JMP:
+            info->srcCount = 0;
+            info->dstCount = 0;
+            break;
+
+        case GT_SWITCH:
+            // This should never occur since switch nodes must not be visible at this
+            // point in the JIT.
+            info->srcCount = 0;
+            info->dstCount = 0; // To avoid getting uninit errors.
+            noway_assert(!"Switch must be lowered at this point");
+            break;
+
+        case GT_JMPTABLE:
+            info->srcCount = 0;
+            info->dstCount = 1;
+            break;
+
+        case GT_SWITCH_TABLE:
+            info->srcCount         = 2;
+            info->internalIntCount = 1;
+            info->dstCount         = 0;
+            break;
+
+        case GT_ASG:
+        case GT_ASG_ADD:
+        case GT_ASG_SUB:
+            noway_assert(!"We should never hit any assignment operator in lowering");
+            info->srcCount = 0;
+            info->dstCount = 0;
+            break;
+
+#if !defined(_TARGET_64BIT_)
+        case GT_ADD_LO:
+        case GT_ADD_HI:
+        case GT_SUB_LO:
+        case GT_SUB_HI:
+#endif
+        case GT_ADD:
+        case GT_SUB:
+            // SSE2 arithmetic instructions doesn't support the form "op mem, xmm".
+            // Rather they only support "op xmm, mem/xmm" form.
+            if (varTypeIsFloating(tree->TypeGet()))
+            {
+                // overflow operations aren't supported on float/double types.
+                assert(!tree->gtOverflow());
+
+                op1 = tree->gtGetOp1();
+                op2 = tree->gtGetOp2();
+
+                // No implicit conversions at this stage as the expectation is that
+                // everything is made explicit by adding casts.
+                assert(op1->TypeGet() == op2->TypeGet());
+
+                info->srcCount = 2;
+                info->dstCount = 1;
+
+                if (op2->isMemoryOp() || op2->IsCnsNonZeroFltOrDbl())
+                {
+                    MakeSrcContained(tree, op2);
+                }
+                else if (tree->OperIsCommutative() &&
+                         (op1->IsCnsNonZeroFltOrDbl() || (op1->isMemoryOp() && IsSafeToContainMem(tree, op1))))
+                {
+                    // Though we have GT_ADD(op1=memOp, op2=non-memOp, we try to reorder the operands
+                    // as long as it is safe so that the following efficient code sequence is generated:
+                    //      addss/sd targetReg, memOp    (if op1Reg == targetReg) OR
+                    //      movaps targetReg, op2Reg; addss/sd targetReg, [memOp]
+                    //
+                    // Instead of
+                    //      movss op1Reg, [memOp]; addss/sd targetReg, Op2Reg  (if op1Reg == targetReg) OR
+                    //      movss op1Reg, [memOp]; movaps targetReg, op1Reg, addss/sd targetReg, Op2Reg
+                    MakeSrcContained(tree, op1);
+                }
+                else
+                {
+                    // If there are no containable operands, we can make an operand reg optional.
+                    SetRegOptionalForBinOp(tree);
+                }
+                break;
+            }
+
+            __fallthrough;
+
+        case GT_AND:
+        case GT_OR:
+        case GT_XOR:
+            TreeNodeInfoInitLogicalOp(tree);
+            break;
+
+        case GT_RETURNTRAP:
+            // This just turns into a compare of its child with an int + a conditional call
+            info->srcCount = 1;
+            info->dstCount = 0;
+            if (tree->gtOp.gtOp1->isIndir())
+            {
+                MakeSrcContained(tree, tree->gtOp.gtOp1);
+            }
+            info->internalIntCount = 1;
+            info->setInternalCandidates(l, l->allRegs(TYP_INT));
+            break;
+
+        case GT_MOD:
+        case GT_DIV:
+        case GT_UMOD:
+        case GT_UDIV:
+            TreeNodeInfoInitModDiv(tree);
+            break;
+
+        case GT_MUL:
+        case GT_MULHI:
+#if defined(_TARGET_X86_) && !defined(LEGACY_BACKEND)
+        case GT_MUL_LONG:
+#endif
+            TreeNodeInfoInitMul(tree);
+            break;
+
+        case GT_INTRINSIC:
+            TreeNodeInfoInitIntrinsic(tree);
+            break;
+
+#ifdef FEATURE_SIMD
+        case GT_SIMD:
+            TreeNodeInfoInitSIMD(tree);
+            break;
+#endif // FEATURE_SIMD
+
+        case GT_CAST:
+            TreeNodeInfoInitCast(tree);
+            break;
+
+        case GT_NEG:
+            info->srcCount = 1;
+            info->dstCount = 1;
+
+            // TODO-XArch-CQ:
+            // SSE instruction set doesn't have an instruction to negate a number.
+            // The recommended way is to xor the float/double number with a bitmask.
+            // The only way to xor is using xorps or xorpd both of which operate on
+            // 128-bit operands.  To hold the bit-mask we would need another xmm
+            // register or a 16-byte aligned 128-bit data constant. Right now emitter
+            // lacks the support for emitting such constants or instruction with mem
+            // addressing mode referring to a 128-bit operand. For now we use an
+            // internal xmm register to load 32/64-bit bitmask from data section.
+            // Note that by trading additional data section memory (128-bit) we can
+            // save on the need for an internal register and also a memory-to-reg
+            // move.
+            //
+            // Note: another option to avoid internal register requirement is by
+            // lowering as GT_SUB(0, src).  This will generate code different from
+            // Jit64 and could possibly result in compat issues (?).
+            if (varTypeIsFloating(tree))
+            {
+                info->internalFloatCount = 1;
+                info->setInternalCandidates(l, l->internalFloatRegCandidates());
+            }
+            else
+            {
+                // Codegen of this tree node sets ZF and SF flags.
+                tree->gtFlags |= GTF_ZSF_SET;
+            }
+            break;
+
+        case GT_NOT:
+            info->srcCount = 1;
+            info->dstCount = 1;
+            break;
+
+        case GT_LSH:
+        case GT_RSH:
+        case GT_RSZ:
+        case GT_ROL:
+        case GT_ROR:
+#ifdef _TARGET_X86_
+        case GT_LSH_HI:
+        case GT_RSH_LO:
+#endif
+            TreeNodeInfoInitShiftRotate(tree);
+            break;
+
+        case GT_EQ:
+        case GT_NE:
+        case GT_LT:
+        case GT_LE:
+        case GT_GE:
+        case GT_GT:
+        case GT_TEST_EQ:
+        case GT_TEST_NE:
+            TreeNodeInfoInitCmp(tree);
+            break;
+
+        case GT_CKFINITE:
+            info->srcCount         = 1;
+            info->dstCount         = 1;
+            info->internalIntCount = 1;
+            break;
+
+        case GT_CMPXCHG:
+            info->srcCount = 3;
+            info->dstCount = 1;
+
+            // comparand is preferenced to RAX.
+            // Remaining two operands can be in any reg other than RAX.
+            tree->gtCmpXchg.gtOpComparand->gtLsraInfo.setSrcCandidates(l, RBM_RAX);
+            tree->gtCmpXchg.gtOpLocation->gtLsraInfo.setSrcCandidates(l, l->allRegs(TYP_INT) & ~RBM_RAX);
+            tree->gtCmpXchg.gtOpValue->gtLsraInfo.setSrcCandidates(l, l->allRegs(TYP_INT) & ~RBM_RAX);
+            tree->gtLsraInfo.setDstCandidates(l, RBM_RAX);
+            break;
+
+        case GT_LOCKADD:
+            info->srcCount = 2;
+            info->dstCount = (tree->TypeGet() == TYP_VOID) ? 0 : 1;
+
+            CheckImmedAndMakeContained(tree, tree->gtOp.gtOp2);
+            break;
+
+        case GT_CALL:
+            TreeNodeInfoInitCall(tree->AsCall());
+            break;
+
+        case GT_ADDR:
+        {
+            // For a GT_ADDR, the child node should not be evaluated into a register
+            GenTreePtr child = tree->gtOp.gtOp1;
+            assert(!l->isCandidateLocalRef(child));
+            l->clearDstCount(child);
+            info->srcCount = 0;
+            info->dstCount = 1;
+        }
+        break;
+
+#if !defined(FEATURE_PUT_STRUCT_ARG_STK)
+        case GT_OBJ:
+#endif
+        case GT_BLK:
+        case GT_DYN_BLK:
+            // These should all be eliminated prior to Lowering.
+            assert(!"Non-store block node in Lowering");
+            info->srcCount = 0;
+            info->dstCount = 0;
+            break;
+
+#ifdef FEATURE_PUT_STRUCT_ARG_STK
+        case GT_PUTARG_STK:
+            LowerPutArgStk(tree->AsPutArgStk());
+            TreeNodeInfoInitPutArgStk(tree->AsPutArgStk());
+            break;
+#endif // FEATURE_PUT_STRUCT_ARG_STK
+
+        case GT_STORE_BLK:
+        case GT_STORE_OBJ:
+        case GT_STORE_DYN_BLK:
+            LowerBlockStore(tree->AsBlk());
+            TreeNodeInfoInitBlockStore(tree->AsBlk());
+            break;
+
+        case GT_INIT_VAL:
+            // Always a passthrough of its child's value.
+            info->srcCount = 0;
+            info->dstCount = 0;
+            break;
+
+        case GT_LCLHEAP:
+            TreeNodeInfoInitLclHeap(tree);
+            break;
+
+        case GT_ARR_BOUNDS_CHECK:
+#ifdef FEATURE_SIMD
+        case GT_SIMD_CHK:
+#endif // FEATURE_SIMD
+        {
+            GenTreeBoundsChk* node = tree->AsBoundsChk();
+            // Consumes arrLen & index - has no result
+            info->srcCount = 2;
+            info->dstCount = 0;
+
+            GenTreePtr other;
+            if (CheckImmedAndMakeContained(tree, node->gtIndex))
+            {
+                other = node->gtArrLen;
+            }
+            else if (CheckImmedAndMakeContained(tree, node->gtArrLen))
+            {
+                other = node->gtIndex;
+            }
+            else if (node->gtIndex->isMemoryOp())
+            {
+                other = node->gtIndex;
+            }
+            else
+            {
+                other = node->gtArrLen;
+            }
+
+            if (node->gtIndex->TypeGet() == node->gtArrLen->TypeGet())
+            {
+                if (other->isMemoryOp())
+                {
+                    MakeSrcContained(tree, other);
+                }
+                else
+                {
+                    // We can mark 'other' as reg optional, since it is not contained.
+                    SetRegOptional(other);
+                }
+            }
+        }
+        break;
+
+        case GT_ARR_ELEM:
+            // These must have been lowered to GT_ARR_INDEX
+            noway_assert(!"We should never see a GT_ARR_ELEM in lowering");
+            info->srcCount = 0;
+            info->dstCount = 0;
+            break;
+
+        case GT_ARR_INDEX:
+            info->srcCount = 2;
+            info->dstCount = 1;
+            // For GT_ARR_INDEX, the lifetime of the arrObj must be extended because it is actually used multiple
+            // times while the result is being computed.
+            tree->AsArrIndex()->ArrObj()->gtLsraInfo.isDelayFree = true;
+            info->hasDelayFreeSrc                                = true;
+            break;
+
+        case GT_ARR_OFFSET:
+            // This consumes the offset, if any, the arrObj and the effective index,
+            // and produces the flattened offset for this dimension.
+            info->srcCount = 3;
+            info->dstCount = 1;
+
+            // we don't want to generate code for this
+            if (tree->gtArrOffs.gtOffset->IsIntegralConst(0))
+            {
+                MakeSrcContained(tree, tree->gtArrOffs.gtOffset);
+            }
+            else
+            {
+                // Here we simply need an internal register, which must be different
+                // from any of the operand's registers, but may be the same as targetReg.
+                info->internalIntCount = 1;
+            }
+            break;
+
+        case GT_LEA:
+            // The LEA usually passes its operands through to the GT_IND, in which case we'll
+            // clear the info->srcCount and info->dstCount later, but we may be instantiating an address,
+            // so we set them here.
+            info->srcCount = 0;
+            if (tree->AsAddrMode()->HasBase())
+            {
+                info->srcCount++;
+            }
+            if (tree->AsAddrMode()->HasIndex())
+            {
+                info->srcCount++;
+            }
+            info->dstCount = 1;
+            break;
+
+        case GT_STOREIND:
+        {
+            info->srcCount = 2;
+            info->dstCount = 0;
+            GenTree* src   = tree->gtOp.gtOp2;
+
+            if (compiler->codeGen->gcInfo.gcIsWriteBarrierAsgNode(tree))
+            {
+                TreeNodeInfoInitGCWriteBarrier(tree);
+                break;
+            }
+
+            // If the source is a containable immediate, make it contained, unless it is
+            // an int-size or larger store of zero to memory, because we can generate smaller code
+            // by zeroing a register and then storing it.
+            if (IsContainableImmed(tree, src) &&
+                (!src->IsIntegralConst(0) || varTypeIsSmall(tree) || tree->gtGetOp1()->OperGet() == GT_CLS_VAR_ADDR))
+            {
+                MakeSrcContained(tree, src);
+            }
+            else if (!varTypeIsFloating(tree))
+            {
+                // Perform recognition of trees with the following structure:
+                //        StoreInd(addr, BinOp(expr, GT_IND(addr)))
+                // to be able to fold this into an instruction of the form
+                //        BINOP [addr], register
+                // where register is the actual place where 'expr' is computed.
+                //
+                // SSE2 doesn't support RMW form of instructions.
+                if (TreeNodeInfoInitIfRMWMemOp(tree))
+                {
+                    break;
+                }
+            }
+
+            TreeNodeInfoInitIndir(tree);
+        }
+        break;
+
+        case GT_NULLCHECK:
+            info->dstCount      = 0;
+            info->srcCount      = 1;
+            info->isLocalDefUse = true;
+            break;
+
+        case GT_IND:
+            info->dstCount = 1;
+            info->srcCount = 1;
+            TreeNodeInfoInitIndir(tree);
+            break;
+
+        case GT_CATCH_ARG:
+            info->srcCount = 0;
+            info->dstCount = 1;
+            info->setDstCandidates(l, RBM_EXCEPTION_OBJECT);
+            break;
+
+#if !FEATURE_EH_FUNCLETS
+        case GT_END_LFIN:
+            info->srcCount = 0;
+            info->dstCount = 0;
+            break;
+#endif
+
+        case GT_CLS_VAR:
+            // These nodes are eliminated by rationalizer.
+            JITDUMP("Unexpected node %s in Lower.\n", GenTree::NodeName(tree->OperGet()));
+            unreached();
+            break;
+    } // end switch (tree->OperGet())
+
+    // If op2 of a binary-op gets marked as contained, then binary-op srcCount will be 1.
+    // Even then we would like to set isTgtPref on Op1.
+    if (tree->OperIsBinary() && info->srcCount >= 1)
+    {
+        if (isRMWRegOper(tree))
+        {
+            GenTree* op1 = tree->gtOp.gtOp1;
+            GenTree* op2 = tree->gtOp.gtOp2;
+
+            // Commutative opers like add/mul/and/or/xor could reverse the order of
+            // operands if it is safe to do so.  In such a case we would like op2 to be
+            // target preferenced instead of op1.
+            if (tree->OperIsCommutative() && op1->gtLsraInfo.dstCount == 0 && op2 != nullptr)
+            {
+                op1 = op2;
+                op2 = tree->gtOp.gtOp1;
+            }
+
+            // If we have a read-modify-write operation, we want to preference op1 to the target.
+            // If op1 is contained, we don't want to preference it, but it won't
+            // show up as a source in that case, so it will be ignored.
+            op1->gtLsraInfo.isTgtPref = true;
+
+            // Is this a non-commutative operator, or is op2 a contained memory op?
+            // (Note that we can't call IsContained() at this point because it uses exactly the
+            // same information we're currently computing.)
+            // In either case, we need to make op2 remain live until the op is complete, by marking
+            // the source(s) associated with op2 as "delayFree".
+            // Note that if op2 of a binary RMW operator is a memory op, even if the operator
+            // is commutative, codegen cannot reverse them.
+            // TODO-XArch-CQ: This is not actually the case for all RMW binary operators, but there's
+            // more work to be done to correctly reverse the operands if they involve memory
+            // operands.  Also, we may need to handle more cases than GT_IND, especially once
+            // we've modified the register allocator to not require all nodes to be assigned
+            // a register (e.g. a spilled lclVar can often be referenced directly from memory).
+            // Note that we may have a null op2, even with 2 sources, if op1 is a base/index memory op.
+
+            GenTree* delayUseSrc = nullptr;
+            // TODO-XArch-Cleanup: We should make the indirection explicit on these nodes so that we don't have
+            // to special case them.
+            if (tree->OperGet() == GT_XADD || tree->OperGet() == GT_XCHG || tree->OperGet() == GT_LOCKADD)
+            {
+                // These tree nodes will have their op1 marked as isDelayFree=true.
+                // Hence these tree nodes should have a Def position so that op1's reg
+                // gets freed at DefLoc+1.
+                if (tree->TypeGet() == TYP_VOID)
+                {
+                    // Right now a GT_XADD node could be morphed into a
+                    // GT_LOCKADD of TYP_VOID. See gtExtractSideEffList().
+                    // Note that it is advantageous to use GT_LOCKADD
+                    // instead of of GT_XADD as the former uses lock.add,
+                    // which allows its second operand to be a contained
+                    // immediate wheres xadd instruction requires its
+                    // second operand to be in a register.
+                    assert(tree->gtLsraInfo.dstCount == 0);
+
+                    // Give it an artificial type and mark it isLocalDefUse = true.
+                    // This would result in a Def position created but not considered
+                    // consumed by its parent node.
+                    tree->gtType                   = TYP_INT;
+                    tree->gtLsraInfo.isLocalDefUse = true;
+                }
+                else
+                {
+                    assert(tree->gtLsraInfo.dstCount != 0);
+                }
+
+                delayUseSrc = op1;
+            }
+            else if ((op2 != nullptr) &&
+                     (!tree->OperIsCommutative() || (op2->isMemoryOp() && (op2->gtLsraInfo.srcCount == 0))))
+            {
+                delayUseSrc = op2;
+            }
+            if (delayUseSrc != nullptr)
+            {
+                // If delayUseSrc is an indirection and it doesn't produce a result, then we need to set "delayFree'
+                // on the base & index, if any.
+                // Otherwise, we set it on delayUseSrc itself.
+                if (delayUseSrc->isIndir() && (delayUseSrc->gtLsraInfo.dstCount == 0))
+                {
+                    GenTree* base  = delayUseSrc->AsIndir()->Base();
+                    GenTree* index = delayUseSrc->AsIndir()->Index();
+                    if (base != nullptr)
+                    {
+                        base->gtLsraInfo.isDelayFree = true;
+                    }
+                    if (index != nullptr)
+                    {
+                        index->gtLsraInfo.isDelayFree = true;
+                    }
+                }
+                else
+                {
+                    delayUseSrc->gtLsraInfo.isDelayFree = true;
+                }
+                info->hasDelayFreeSrc = true;
+            }
+        }
+    }
+
+    TreeNodeInfoInitCheckByteable(tree);
+
+    // We need to be sure that we've set info->srcCount and info->dstCount appropriately
+    assert((info->dstCount < 2) || (tree->IsMultiRegCall() && info->dstCount == MAX_RET_REG_COUNT));
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitCheckByteable: Check the tree to see if "byte-able" registers are
+// required, and set the tree node info accordingly.
+//
+// Arguments:
+//    tree      - The node of interest
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitCheckByteable(GenTree* tree)
+{
+#ifdef _TARGET_X86_
+    LinearScan*   l    = m_lsra;
+    TreeNodeInfo* info = &(tree->gtLsraInfo);
+
+    // Exclude RBM_NON_BYTE_REGS from dst candidates of tree node and src candidates of operands
+    // if the tree node is a byte type.
+    //
+    // Though this looks conservative in theory, in practice we could not think of a case where
+    // the below logic leads to conservative register specification.  In future when or if we find
+    // one such case, this logic needs to be fine tuned for that case(s).
+
+    if (ExcludeNonByteableRegisters(tree))
+    {
+        regMaskTP regMask;
+        if (info->dstCount > 0)
+        {
+            regMask = info->getDstCandidates(l);
+            assert(regMask != RBM_NONE);
+            info->setDstCandidates(l, regMask & ~RBM_NON_BYTE_REGS);
+        }
+
+        if (tree->OperIsSimple() && (info->srcCount > 0))
+        {
+            // No need to set src candidates on a contained child operand.
+            GenTree* op = tree->gtOp.gtOp1;
+            assert(op != nullptr);
+            bool containedNode = (op->gtLsraInfo.srcCount == 0) && (op->gtLsraInfo.dstCount == 0);
+            if (!containedNode)
+            {
+                regMask = op->gtLsraInfo.getSrcCandidates(l);
+                assert(regMask != RBM_NONE);
+                op->gtLsraInfo.setSrcCandidates(l, regMask & ~RBM_NON_BYTE_REGS);
+            }
+
+            if (tree->OperIsBinary() && (tree->gtOp.gtOp2 != nullptr))
+            {
+                op            = tree->gtOp.gtOp2;
+                containedNode = (op->gtLsraInfo.srcCount == 0) && (op->gtLsraInfo.dstCount == 0);
+                if (!containedNode)
+                {
+                    regMask = op->gtLsraInfo.getSrcCandidates(l);
+                    assert(regMask != RBM_NONE);
+                    op->gtLsraInfo.setSrcCandidates(l, regMask & ~RBM_NON_BYTE_REGS);
+                }
+            }
+        }
+    }
+#endif //_TARGET_X86_
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitSimple: Sets the srcCount and dstCount for all the trees
+// without special handling based on the tree node type.
+//
+// Arguments:
+//    tree      - The node of interest
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitSimple(GenTree* tree)
+{
+    TreeNodeInfo* info = &(tree->gtLsraInfo);
+    unsigned      kind = tree->OperKind();
+    info->dstCount     = tree->IsValue() ? 1 : 0;
+    if (kind & (GTK_CONST | GTK_LEAF))
+    {
+        info->srcCount = 0;
+    }
+    else if (kind & (GTK_SMPOP))
+    {
+        if (tree->gtGetOp2IfPresent() != nullptr)
+        {
+            info->srcCount = 2;
+        }
+        else
+        {
+            info->srcCount = 1;
+        }
+    }
+    else
+    {
+        unreached();
+    }
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitReturn: Set the NodeInfo for a GT_RETURN.
+//
+// Arguments:
+//    tree      - The node of interest
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitReturn(GenTree* tree)
+{
+    TreeNodeInfo* info     = &(tree->gtLsraInfo);
+    LinearScan*   l        = m_lsra;
+    Compiler*     compiler = comp;
+
+#if !defined(_TARGET_64BIT_)
+    if (tree->TypeGet() == TYP_LONG)
+    {
+        GenTree* op1 = tree->gtGetOp1();
+        noway_assert(op1->OperGet() == GT_LONG);
+        GenTree* loVal = op1->gtGetOp1();
+        GenTree* hiVal = op1->gtGetOp2();
+        info->srcCount = 2;
+        loVal->gtLsraInfo.setSrcCandidates(l, RBM_LNGRET_LO);
+        hiVal->gtLsraInfo.setSrcCandidates(l, RBM_LNGRET_HI);
+        info->dstCount = 0;
+    }
+    else
+#endif // !defined(_TARGET_64BIT_)
+    {
+        GenTree*  op1           = tree->gtGetOp1();
+        regMaskTP useCandidates = RBM_NONE;
+
+        info->srcCount = (tree->TypeGet() == TYP_VOID) ? 0 : 1;
+        info->dstCount = 0;
+
+#ifdef FEATURE_UNIX_AMD64_STRUCT_PASSING
+        if (varTypeIsStruct(tree))
+        {
+            // op1 has to be either an lclvar or a multi-reg returning call
+            if (op1->OperGet() == GT_LCL_VAR)
+            {
+                GenTreeLclVarCommon* lclVarCommon = op1->AsLclVarCommon();
+                LclVarDsc*           varDsc       = &(compiler->lvaTable[lclVarCommon->gtLclNum]);
+                assert(varDsc->lvIsMultiRegRet);
+
+                // Mark var as contained if not enregistrable.
+                if (!varTypeIsEnregisterableStruct(op1))
+                {
+                    MakeSrcContained(tree, op1);
+                }
+            }
+            else
+            {
+                noway_assert(op1->IsMultiRegCall());
+
+                ReturnTypeDesc* retTypeDesc = op1->AsCall()->GetReturnTypeDesc();
+                info->srcCount              = retTypeDesc->GetReturnRegCount();
+                useCandidates               = retTypeDesc->GetABIReturnRegs();
+            }
+        }
+        else
+#endif // FEATURE_UNIX_AMD64_STRUCT_PASSING
+        {
+            // Non-struct type return - determine useCandidates
+            switch (tree->TypeGet())
+            {
+                case TYP_VOID:
+                    useCandidates = RBM_NONE;
+                    break;
+                case TYP_FLOAT:
+                    useCandidates = RBM_FLOATRET;
+                    break;
+                case TYP_DOUBLE:
+                    useCandidates = RBM_DOUBLERET;
+                    break;
+#if defined(_TARGET_64BIT_)
+                case TYP_LONG:
+                    useCandidates = RBM_LNGRET;
+                    break;
+#endif // defined(_TARGET_64BIT_)
+                default:
+                    useCandidates = RBM_INTRET;
+                    break;
+            }
+        }
+
+        if (useCandidates != RBM_NONE)
+        {
+            op1->gtLsraInfo.setSrcCandidates(l, useCandidates);
+        }
+    }
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitShiftRotate: Set the NodeInfo for a shift or rotate.
+//
+// Arguments:
+//    tree      - The node of interest
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitShiftRotate(GenTree* tree)
+{
+    TreeNodeInfo* info = &(tree->gtLsraInfo);
+    LinearScan*   l    = m_lsra;
+
+    info->srcCount = 2;
+    info->dstCount = 1;
+
+    // For shift operations, we need that the number
+    // of bits moved gets stored in CL in case
+    // the number of bits to shift is not a constant.
+    GenTreePtr shiftBy = tree->gtOp.gtOp2;
+    GenTreePtr source  = tree->gtOp.gtOp1;
+
+#ifdef _TARGET_X86_
+    // The first operand of a GT_LSH_HI and GT_RSH_LO oper is a GT_LONG so that
+    // we can have a three operand form. Increment the srcCount.
+    if (tree->OperGet() == GT_LSH_HI || tree->OperGet() == GT_RSH_LO)
+    {
+        assert(source->OperGet() == GT_LONG);
+
+        info->srcCount++;
+
+        if (tree->OperGet() == GT_LSH_HI)
+        {
+            GenTreePtr sourceLo              = source->gtOp.gtOp1;
+            sourceLo->gtLsraInfo.isDelayFree = true;
+        }
+        else
+        {
+            GenTreePtr sourceHi              = source->gtOp.gtOp2;
+            sourceHi->gtLsraInfo.isDelayFree = true;
+        }
+
+        source->gtLsraInfo.hasDelayFreeSrc = true;
+        info->hasDelayFreeSrc              = true;
+    }
+#endif
+
+    // x64 can encode 8 bits of shift and it will use 5 or 6. (the others are masked off)
+    // We will allow whatever can be encoded - hope you know what you are doing.
+    if (!IsContainableImmed(tree, shiftBy) || (shiftBy->gtIntConCommon.IconValue() > 255) ||
+        (shiftBy->gtIntConCommon.IconValue() < 0))
+    {
+        source->gtLsraInfo.setSrcCandidates(l, l->allRegs(TYP_INT) & ~RBM_RCX);
+        shiftBy->gtLsraInfo.setSrcCandidates(l, RBM_RCX);
+        info->setDstCandidates(l, l->allRegs(TYP_INT) & ~RBM_RCX);
+    }
+    else
+    {
+        MakeSrcContained(tree, shiftBy);
+
+        // Note that Rotate Left/Right instructions don't set ZF and SF flags.
+        //
+        // If the operand being shifted is 32-bits then upper three bits are masked
+        // by hardware to get actual shift count.  Similarly for 64-bit operands
+        // shift count is narrowed to [0..63].  If the resulting shift count is zero,
+        // then shift operation won't modify flags.
+        //
+        // TODO-CQ-XARCH: We can optimize generating 'test' instruction for GT_EQ/NE(shift, 0)
+        // if the shift count is known to be non-zero and in the range depending on the
+        // operand size.
+    }
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitCall: Set the NodeInfo for a call.
+//
+// Arguments:
+//    call      - The call node of interest
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitCall(GenTreeCall* call)
+{
+    TreeNodeInfo*   info              = &(call->gtLsraInfo);
+    LinearScan*     l                 = m_lsra;
+    Compiler*       compiler          = comp;
+    bool            hasMultiRegRetVal = false;
+    ReturnTypeDesc* retTypeDesc       = nullptr;
+
+    info->srcCount = 0;
+    if (call->TypeGet() != TYP_VOID)
+    {
+        hasMultiRegRetVal = call->HasMultiRegRetVal();
+        if (hasMultiRegRetVal)
+        {
+            // dst count = number of registers in which the value is returned by call
+            retTypeDesc    = call->GetReturnTypeDesc();
+            info->dstCount = retTypeDesc->GetReturnRegCount();
+        }
+        else
+        {
+            info->dstCount = 1;
+        }
+    }
+    else
+    {
+        info->dstCount = 0;
+    }
+
+    GenTree* ctrlExpr = call->gtControlExpr;
+    if (call->gtCallType == CT_INDIRECT)
+    {
+        // either gtControlExpr != null or gtCallAddr != null.
+        // Both cannot be non-null at the same time.
+        assert(ctrlExpr == nullptr);
+        assert(call->gtCallAddr != nullptr);
+        ctrlExpr = call->gtCallAddr;
+
+#ifdef _TARGET_X86_
+        // Fast tail calls aren't currently supported on x86, but if they ever are, the code
+        // below that handles indirect VSD calls will need to be fixed.
+        assert(!call->IsFastTailCall() || !call->IsVirtualStub());
+#endif // _TARGET_X86_
+    }
+
+    // set reg requirements on call target represented as control sequence.
+    if (ctrlExpr != nullptr)
+    {
+        // we should never see a gtControlExpr whose type is void.
+        assert(ctrlExpr->TypeGet() != TYP_VOID);
+
+        // call can take a Rm op on x64
+        info->srcCount++;
+
+        // In case of fast tail implemented as jmp, make sure that gtControlExpr is
+        // computed into a register.
+        if (!call->IsFastTailCall())
+        {
+#ifdef _TARGET_X86_
+            // On x86, we need to generate a very specific pattern for indirect VSD calls:
+            //
+            //    3-byte nop
+            //    call dword ptr [eax]
+            //
+            // Where EAX is also used as an argument to the stub dispatch helper. Make
+            // sure that the call target address is computed into EAX in this case.
+            if (call->IsVirtualStub() && (call->gtCallType == CT_INDIRECT))
+            {
+                assert(ctrlExpr->isIndir());
+
+                ctrlExpr->gtGetOp1()->gtLsraInfo.setSrcCandidates(l, RBM_VIRTUAL_STUB_TARGET);
+                MakeSrcContained(call, ctrlExpr);
+            }
+            else
+#endif // _TARGET_X86_
+                if (ctrlExpr->isIndir())
+            {
+                MakeSrcContained(call, ctrlExpr);
+            }
+        }
+        else
+        {
+            // Fast tail call - make sure that call target is always computed in RAX
+            // so that epilog sequence can generate "jmp rax" to achieve fast tail call.
+            ctrlExpr->gtLsraInfo.setSrcCandidates(l, RBM_RAX);
+        }
+    }
+
+    // If this is a varargs call, we will clear the internal candidates in case we need
+    // to reserve some integer registers for copying float args.
+    // We have to do this because otherwise the default candidates are allRegs, and adding
+    // the individual specific registers will have no effect.
+    if (call->IsVarargs())
+    {
+        info->setInternalCandidates(l, RBM_NONE);
+    }
+
+    RegisterType registerType = call->TypeGet();
+
+    // Set destination candidates for return value of the call.
+    CLANG_FORMAT_COMMENT_ANCHOR;
+
+#ifdef _TARGET_X86_
+    if (call->IsHelperCall(compiler, CORINFO_HELP_INIT_PINVOKE_FRAME))
+    {
+        // The x86 CORINFO_HELP_INIT_PINVOKE_FRAME helper uses a custom calling convention that returns with
+        // TCB in REG_PINVOKE_TCB. AMD64/ARM64 use the standard calling convention. fgMorphCall() sets the
+        // correct argument registers.
+        info->setDstCandidates(l, RBM_PINVOKE_TCB);
+    }
+    else
+#endif // _TARGET_X86_
+        if (hasMultiRegRetVal)
+    {
+        assert(retTypeDesc != nullptr);
+        info->setDstCandidates(l, retTypeDesc->GetABIReturnRegs());
+    }
+    else if (varTypeIsFloating(registerType))
+    {
+#ifdef _TARGET_X86_
+        // The return value will be on the X87 stack, and we will need to move it.
+        info->setDstCandidates(l, l->allRegs(registerType));
+#else  // !_TARGET_X86_
+        info->setDstCandidates(l, RBM_FLOATRET);
+#endif // !_TARGET_X86_
+    }
+    else if (registerType == TYP_LONG)
+    {
+        info->setDstCandidates(l, RBM_LNGRET);
+    }
+    else
+    {
+        info->setDstCandidates(l, RBM_INTRET);
+    }
+
+    // number of args to a call =
+    // callRegArgs + (callargs - placeholders, setup, etc)
+    // there is an explicit thisPtr but it is redundant
+
+    // If there is an explicit this pointer, we don't want that node to produce anything
+    // as it is redundant
+    if (call->gtCallObjp != nullptr)
+    {
+        GenTreePtr thisPtrNode = call->gtCallObjp;
+
+        if (thisPtrNode->gtOper == GT_PUTARG_REG)
+        {
+            l->clearOperandCounts(thisPtrNode);
+            l->clearDstCount(thisPtrNode->gtOp.gtOp1);
+        }
+        else
+        {
+            l->clearDstCount(thisPtrNode);
+        }
+    }
+
+#if FEATURE_VARARG
+    bool callHasFloatRegArgs = false;
+#endif // !FEATURE_VARARG
+
+    // First, count reg args
+    for (GenTreePtr list = call->gtCallLateArgs; list; list = list->MoveNext())
+    {
+        assert(list->OperIsList());
+
+        GenTreePtr argNode = list->Current();
+
+        fgArgTabEntryPtr curArgTabEntry = compiler->gtArgEntryByNode(call, argNode);
+        assert(curArgTabEntry);
+
+        if (curArgTabEntry->regNum == REG_STK)
+        {
+            // late arg that is not passed in a register
+            DISPNODE(argNode);
+            assert(argNode->gtOper == GT_PUTARG_STK);
+            argNode->gtLsraInfo.srcCount = 1;
+            argNode->gtLsraInfo.dstCount = 0;
+
+#ifdef FEATURE_PUT_STRUCT_ARG_STK
+            // If the node is TYP_STRUCT and it is put on stack with
+            // putarg_stk operation, we consume and produce no registers.
+            // In this case the embedded Obj node should not produce
+            // registers too since it is contained.
+            // Note that if it is a SIMD type the argument will be in a register.
+            if (argNode->TypeGet() == TYP_STRUCT)
+            {
+                assert(argNode->gtOp.gtOp1 != nullptr && argNode->gtOp.gtOp1->OperGet() == GT_OBJ);
+                argNode->gtOp.gtOp1->gtLsraInfo.dstCount = 0;
+                argNode->gtLsraInfo.srcCount             = 0;
+            }
+#endif // FEATURE_PUT_STRUCT_ARG_STK
+            continue;
+        }
+
+        regNumber argReg    = REG_NA;
+        regMaskTP argMask   = RBM_NONE;
+        short     regCount  = 0;
+        bool      isOnStack = true;
+        if (curArgTabEntry->regNum != REG_STK)
+        {
+            isOnStack         = false;
+            var_types argType = argNode->TypeGet();
+
+#if FEATURE_VARARG
+            callHasFloatRegArgs |= varTypeIsFloating(argType);
+#endif // !FEATURE_VARARG
+
+            argReg   = curArgTabEntry->regNum;
+            regCount = 1;
+
+            // Default case is that we consume one source; modify this later (e.g. for
+            // promoted structs)
+            info->srcCount++;
+
+            argMask = genRegMask(argReg);
+            argNode = argNode->gtEffectiveVal();
+        }
+
+        // If the struct arg is wrapped in CPYBLK the type of the param will be TYP_VOID.
+        // Use the curArgTabEntry's isStruct to get whether the param is a struct.
+        if (varTypeIsStruct(argNode) PUT_STRUCT_ARG_STK_ONLY(|| curArgTabEntry->isStruct))
+        {
+            unsigned   originalSize = 0;
+            LclVarDsc* varDsc       = nullptr;
+            if (argNode->gtOper == GT_LCL_VAR)
+            {
+                varDsc       = compiler->lvaTable + argNode->gtLclVarCommon.gtLclNum;
+                originalSize = varDsc->lvSize();
+            }
+            else if (argNode->gtOper == GT_MKREFANY)
+            {
+                originalSize = 2 * TARGET_POINTER_SIZE;
+            }
+            else if (argNode->gtOper == GT_OBJ)
+            {
+                noway_assert(!"GT_OBJ not supported for amd64");
+            }
+#ifdef FEATURE_UNIX_AMD64_STRUCT_PASSING
+            else if (argNode->gtOper == GT_PUTARG_REG)
+            {
+                originalSize = genTypeSize(argNode->gtType);
+            }
+            else if (argNode->gtOper == GT_FIELD_LIST)
+            {
+                originalSize = 0;
+
+                // There could be up to 2 PUTARG_REGs in the list
+                GenTreeFieldList* fieldListPtr = argNode->AsFieldList();
+                unsigned          iterationNum = 0;
+                for (; fieldListPtr; fieldListPtr = fieldListPtr->Rest())
+                {
+                    GenTreePtr putArgRegNode = fieldListPtr->Current();
+                    assert(putArgRegNode->gtOper == GT_PUTARG_REG);
+
+                    if (iterationNum == 0)
+                    {
+                        varDsc       = compiler->lvaTable + putArgRegNode->gtOp.gtOp1->gtLclVarCommon.gtLclNum;
+                        originalSize = varDsc->lvSize();
+                        assert(originalSize != 0);
+                    }
+                    else
+                    {
+                        // Need an extra source for every node, but the first in the list.
+                        info->srcCount++;
+
+                        // Get the mask for the second putarg_reg
+                        argMask = genRegMask(curArgTabEntry->otherRegNum);
+                    }
+
+                    putArgRegNode->gtLsraInfo.setDstCandidates(l, argMask);
+                    putArgRegNode->gtLsraInfo.setSrcCandidates(l, argMask);
+
+                    // To avoid redundant moves, have the argument child tree computed in the
+                    // register in which the argument is passed to the call.
+                    putArgRegNode->gtOp.gtOp1->gtLsraInfo.setSrcCandidates(l, l->getUseCandidates(putArgRegNode));
+                    iterationNum++;
+                }
+
+                assert(iterationNum <= CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS);
+            }
+#endif // FEATURE_UNIX_AMD64_STRUCT_PASSING
+            else
+            {
+                noway_assert(!"Can't predict unsupported TYP_STRUCT arg kind");
+            }
+
+            unsigned slots          = ((unsigned)(roundUp(originalSize, TARGET_POINTER_SIZE))) / REGSIZE_BYTES;
+            unsigned remainingSlots = slots;
+
+            if (!isOnStack)
+            {
+                remainingSlots = slots - 1;
+
+                regNumber reg = (regNumber)(argReg + 1);
+                while (remainingSlots > 0 && reg <= REG_ARG_LAST)
+                {
+                    argMask |= genRegMask(reg);
+                    reg = (regNumber)(reg + 1);
+                    remainingSlots--;
+                    regCount++;
+                }
+            }
+
+            short internalIntCount = 0;
+            if (remainingSlots > 0)
+            {
+#ifdef FEATURE_UNIX_AMD64_STRUCT_PASSING
+                // This TYP_STRUCT argument is also passed in the outgoing argument area
+                // We need a register to address the TYP_STRUCT
+                internalIntCount = 1;
+#else  // FEATURE_UNIX_AMD64_STRUCT_PASSING
+                // And we may need 2
+                internalIntCount           = 2;
+#endif // FEATURE_UNIX_AMD64_STRUCT_PASSING
+            }
+            argNode->gtLsraInfo.internalIntCount = internalIntCount;
+
+#ifdef FEATURE_UNIX_AMD64_STRUCT_PASSING
+            if (argNode->gtOper == GT_PUTARG_REG)
+            {
+                argNode->gtLsraInfo.setDstCandidates(l, argMask);
+                argNode->gtLsraInfo.setSrcCandidates(l, argMask);
+            }
+#endif // FEATURE_UNIX_AMD64_STRUCT_PASSING
+        }
+        else
+        {
+            argNode->gtLsraInfo.setDstCandidates(l, argMask);
+            argNode->gtLsraInfo.setSrcCandidates(l, argMask);
+        }
+
+        // To avoid redundant moves, have the argument child tree computed in the
+        // register in which the argument is passed to the call.
+        if (argNode->gtOper == GT_PUTARG_REG)
+        {
+            argNode->gtOp.gtOp1->gtLsraInfo.setSrcCandidates(l, l->getUseCandidates(argNode));
+        }
+
+#if FEATURE_VARARG
+        // In the case of a varargs call, the ABI dictates that if we have floating point args,
+        // we must pass the enregistered arguments in both the integer and floating point registers.
+        // Since the integer register is not associated with this arg node, we will reserve it as
+        // an internal register so that it is not used during the evaluation of the call node
+        // (e.g. for the target).
+        if (call->IsVarargs() && varTypeIsFloating(argNode))
+        {
+            regNumber targetReg = compiler->getCallArgIntRegister(argReg);
+            info->setInternalIntCount(info->internalIntCount + 1);
+            info->addInternalCandidates(l, genRegMask(targetReg));
+        }
+#endif // FEATURE_VARARG
+    }
+
+    // Now, count stack args
+    // Note that these need to be computed into a register, but then
+    // they're just stored to the stack - so the reg doesn't
+    // need to remain live until the call.  In fact, it must not
+    // because the code generator doesn't actually consider it live,
+    // so it can't be spilled.
+
+    GenTreePtr args = call->gtCallArgs;
+    while (args)
+    {
+        GenTreePtr arg = args->gtOp.gtOp1;
+        if (!(args->gtFlags & GTF_LATE_ARG))
+        {
+            TreeNodeInfo* argInfo = &(arg->gtLsraInfo);
+            if (argInfo->dstCount != 0)
+            {
+                argInfo->isLocalDefUse = true;
+            }
+
+            // If the child of GT_PUTARG_STK is a constant, we don't need a register to
+            // move it to memory (stack location).
+            //
+            // On AMD64, we don't want to make 0 contained, because we can generate smaller code
+            // by zeroing a register and then storing it. E.g.:
+            //      xor rdx, rdx
+            //      mov gword ptr [rsp+28H], rdx
+            // is 2 bytes smaller than:
+            //      mov gword ptr [rsp+28H], 0
+            //
+            // On x86, we push stack arguments; we don't use 'mov'. So:
+            //      push 0
+            // is 1 byte smaller than:
+            //      xor rdx, rdx
+            //      push rdx
+
+            argInfo->dstCount = 0;
+            if (arg->gtOper == GT_PUTARG_STK)
+            {
+                GenTree* op1 = arg->gtOp.gtOp1;
+                if (IsContainableImmed(arg, op1)
+#if defined(_TARGET_AMD64_)
+                    && !op1->IsIntegralConst(0)
+#endif // _TARGET_AMD64_
+                        )
+                {
+                    MakeSrcContained(arg, op1);
+                }
+            }
+        }
+        args = args->gtOp.gtOp2;
+    }
+
+#if FEATURE_VARARG
+    // If it is a fast tail call, it is already preferenced to use RAX.
+    // Therefore, no need set src candidates on call tgt again.
+    if (call->IsVarargs() && callHasFloatRegArgs && !call->IsFastTailCall() && (ctrlExpr != nullptr))
+    {
+        // Don't assign the call target to any of the argument registers because
+        // we will use them to also pass floating point arguments as required
+        // by Amd64 ABI.
+        ctrlExpr->gtLsraInfo.setSrcCandidates(l, l->allRegs(TYP_INT) & ~(RBM_ARG_REGS));
+    }
+#endif // !FEATURE_VARARG
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitBlockStore: Set the NodeInfo for a block store.
+//
+// Arguments:
+//    blkNode       - The block store node of interest
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitBlockStore(GenTreeBlk* blkNode)
+{
+    GenTree*    dstAddr  = blkNode->Addr();
+    unsigned    size     = blkNode->gtBlkSize;
+    GenTree*    source   = blkNode->Data();
+    LinearScan* l        = m_lsra;
+    Compiler*   compiler = comp;
+
+    // Sources are dest address, initVal or source.
+    // We may require an additional source or temp register for the size.
+    blkNode->gtLsraInfo.srcCount = 2;
+    blkNode->gtLsraInfo.dstCount = 0;
+    blkNode->gtLsraInfo.setInternalCandidates(l, RBM_NONE);
+    GenTreePtr srcAddrOrFill = nullptr;
+    bool       isInitBlk     = blkNode->OperIsInitBlkOp();
+
+    regMaskTP dstAddrRegMask = RBM_NONE;
+    regMaskTP sourceRegMask  = RBM_NONE;
+    regMaskTP blkSizeRegMask = RBM_NONE;
+
+    if (isInitBlk)
+    {
+        GenTree* initVal = source;
+        if (initVal->OperIsInitVal())
+        {
+            initVal = initVal->gtGetOp1();
+        }
+        srcAddrOrFill = initVal;
+
+        switch (blkNode->gtBlkOpKind)
+        {
+            case GenTreeBlk::BlkOpKindUnroll:
+                assert(initVal->IsCnsIntOrI());
+                if (size >= XMM_REGSIZE_BYTES)
+                {
+                    // Reserve an XMM register to fill it with
+                    // a pack of 16 init value constants.
+                    ssize_t fill                           = initVal->gtIntCon.gtIconVal & 0xFF;
+                    blkNode->gtLsraInfo.internalFloatCount = 1;
+                    blkNode->gtLsraInfo.setInternalCandidates(l, l->internalFloatRegCandidates());
+                    if ((fill == 0) && ((size & 0xf) == 0))
+                    {
+                        MakeSrcContained(blkNode, source);
+                    }
+                    // use XMM register to fill with constants, it's AVX instruction and set the flag
+                    SetContainsAVXFlags();
+                }
+#ifdef _TARGET_X86_
+                if ((size & 1) != 0)
+                {
+                    // On x86, you can't address the lower byte of ESI, EDI, ESP, or EBP when doing
+                    // a "mov byte ptr [dest], val". If the fill size is odd, we will try to do this
+                    // when unrolling, so only allow byteable registers as the source value. (We could
+                    // consider just using BlkOpKindRepInstr instead.)
+                    sourceRegMask = RBM_BYTE_REGS;
+                }
+#endif // _TARGET_X86_
+                break;
+
+            case GenTreeBlk::BlkOpKindRepInstr:
+                // rep stos has the following register requirements:
+                // a) The memory address to be in RDI.
+                // b) The fill value has to be in RAX.
+                // c) The buffer size will go in RCX.
+                dstAddrRegMask = RBM_RDI;
+                srcAddrOrFill  = initVal;
+                sourceRegMask  = RBM_RAX;
+                blkSizeRegMask = RBM_RCX;
+                break;
+
+            case GenTreeBlk::BlkOpKindHelper:
+#ifdef _TARGET_AMD64_
+                // The helper follows the regular AMD64 ABI.
+                dstAddrRegMask = RBM_ARG_0;
+                sourceRegMask  = RBM_ARG_1;
+                blkSizeRegMask = RBM_ARG_2;
+#else  // !_TARGET_AMD64_
+                dstAddrRegMask             = RBM_RDI;
+                sourceRegMask              = RBM_RAX;
+                blkSizeRegMask             = RBM_RCX;
+#endif // !_TARGET_AMD64_
+                break;
+
+            default:
+                unreached();
+        }
+    }
+    else
+    {
+        // CopyObj or CopyBlk
+        if (source->gtOper == GT_IND)
+        {
+            srcAddrOrFill = blkNode->Data()->gtGetOp1();
+            // We're effectively setting source as contained, but can't call MakeSrcContained, because the
+            // "inheritance" of the srcCount is to a child not a parent - it would "just work" but could be misleading.
+            // If srcAddr is already non-contained, we don't need to change it.
+            if (srcAddrOrFill->gtLsraInfo.getDstCount() == 0)
+            {
+                srcAddrOrFill->gtLsraInfo.setDstCount(1);
+                srcAddrOrFill->gtLsraInfo.setSrcCount(source->gtLsraInfo.srcCount);
+            }
+            m_lsra->clearOperandCounts(source);
+        }
+        else if (!source->IsMultiRegCall() && !source->OperIsSIMD())
+        {
+            assert(source->IsLocal());
+            MakeSrcContained(blkNode, source);
+        }
+        if (blkNode->OperGet() == GT_STORE_OBJ)
+        {
+            if (blkNode->gtBlkOpKind == GenTreeBlk::BlkOpKindRepInstr)
+            {
+                // We need the size of the contiguous Non-GC-region to be in RCX to call rep movsq.
+                blkSizeRegMask = RBM_RCX;
+            }
+            // The srcAddr must be in a register.  If it was under a GT_IND, we need to subsume all of its
+            // sources.
+            sourceRegMask  = RBM_RSI;
+            dstAddrRegMask = RBM_RDI;
+        }
+        else
+        {
+            switch (blkNode->gtBlkOpKind)
+            {
+                case GenTreeBlk::BlkOpKindUnroll:
+                    // If we have a remainder smaller than XMM_REGSIZE_BYTES, we need an integer temp reg.
+                    //
+                    // x86 specific note: if the size is odd, the last copy operation would be of size 1 byte.
+                    // But on x86 only RBM_BYTE_REGS could be used as byte registers.  Therefore, exclude
+                    // RBM_NON_BYTE_REGS from internal candidates.
+                    if ((size & (XMM_REGSIZE_BYTES - 1)) != 0)
+                    {
+                        blkNode->gtLsraInfo.internalIntCount++;
+                        regMaskTP regMask = l->allRegs(TYP_INT);
+
+#ifdef _TARGET_X86_
+                        if ((size & 1) != 0)
+                        {
+                            regMask &= ~RBM_NON_BYTE_REGS;
+                        }
+#endif
+                        blkNode->gtLsraInfo.setInternalCandidates(l, regMask);
+                    }
+
+                    if (size >= XMM_REGSIZE_BYTES)
+                    {
+                        // If we have a buffer larger than XMM_REGSIZE_BYTES,
+                        // reserve an XMM register to use it for a
+                        // series of 16-byte loads and stores.
+                        blkNode->gtLsraInfo.internalFloatCount = 1;
+                        blkNode->gtLsraInfo.addInternalCandidates(l, l->internalFloatRegCandidates());
+                        // Uses XMM reg for load and store and hence check to see whether AVX instructions
+                        // are used for codegen, set ContainsAVX flag
+                        SetContainsAVXFlags();
+                    }
+                    // If src or dst are on stack, we don't have to generate the address
+                    // into a register because it's just some constant+SP.
+                    if ((srcAddrOrFill != nullptr) && srcAddrOrFill->OperIsLocalAddr())
+                    {
+                        MakeSrcContained(blkNode, srcAddrOrFill);
+                    }
+
+                    if (dstAddr->OperIsLocalAddr())
+                    {
+                        MakeSrcContained(blkNode, dstAddr);
+                    }
+
+                    break;
+
+                case GenTreeBlk::BlkOpKindRepInstr:
+                    // rep stos has the following register requirements:
+                    // a) The dest address has to be in RDI.
+                    // b) The src address has to be in RSI.
+                    // c) The buffer size will go in RCX.
+                    dstAddrRegMask = RBM_RDI;
+                    sourceRegMask  = RBM_RSI;
+                    blkSizeRegMask = RBM_RCX;
+                    break;
+
+                case GenTreeBlk::BlkOpKindHelper:
+#ifdef _TARGET_AMD64_
+                    // The helper follows the regular AMD64 ABI.
+                    dstAddrRegMask = RBM_ARG_0;
+                    sourceRegMask  = RBM_ARG_1;
+                    blkSizeRegMask = RBM_ARG_2;
+#else  // !_TARGET_AMD64_
+                    dstAddrRegMask         = RBM_RDI;
+                    sourceRegMask          = RBM_RAX;
+                    blkSizeRegMask         = RBM_RCX;
+#endif // !_TARGET_AMD64_
+                    break;
+
+                default:
+                    unreached();
+            }
+        }
+    }
+
+    if (dstAddrRegMask != RBM_NONE)
+    {
+        dstAddr->gtLsraInfo.setSrcCandidates(l, dstAddrRegMask);
+    }
+    if (sourceRegMask != RBM_NONE)
+    {
+        if (srcAddrOrFill != nullptr)
+        {
+            srcAddrOrFill->gtLsraInfo.setSrcCandidates(l, sourceRegMask);
+        }
+        else
+        {
+            // This is a local source; we'll use a temp register for its address.
+            blkNode->gtLsraInfo.addInternalCandidates(l, sourceRegMask);
+            blkNode->gtLsraInfo.internalIntCount++;
+        }
+    }
+    if (blkSizeRegMask != RBM_NONE)
+    {
+        if (size != 0)
+        {
+            // Reserve a temp register for the block size argument.
+            blkNode->gtLsraInfo.addInternalCandidates(l, blkSizeRegMask);
+            blkNode->gtLsraInfo.internalIntCount++;
+        }
+        else
+        {
+            // The block size argument is a third argument to GT_STORE_DYN_BLK
+            noway_assert(blkNode->gtOper == GT_STORE_DYN_BLK);
+            blkNode->gtLsraInfo.setSrcCount(3);
+            GenTree* blockSize = blkNode->AsDynBlk()->gtDynamicSize;
+            blockSize->gtLsraInfo.setSrcCandidates(l, blkSizeRegMask);
+        }
+    }
+}
+
+#ifdef FEATURE_PUT_STRUCT_ARG_STK
+//------------------------------------------------------------------------
+// TreeNodeInfoInitPutArgStk: Set the NodeInfo for a GT_PUTARG_STK.
+//
+// Arguments:
+//    tree      - The node of interest
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitPutArgStk(GenTreePutArgStk* putArgStk)
+{
+    TreeNodeInfo* info = &(putArgStk->gtLsraInfo);
+    LinearScan*   l    = m_lsra;
+    info->srcCount     = 0;
+
+#ifdef _TARGET_X86_
+    if (putArgStk->gtOp1->gtOper == GT_FIELD_LIST)
+    {
+        unsigned fieldCount    = 0;
+        bool     needsByteTemp = false;
+        bool     needsSimdTemp = false;
+        unsigned prevOffset    = putArgStk->getArgSize();
+        for (GenTreeFieldList* current = putArgStk->gtOp1->AsFieldList(); current != nullptr; current = current->Rest())
+        {
+            GenTree* const  fieldNode   = current->Current();
+            const var_types fieldType   = fieldNode->TypeGet();
+            const unsigned  fieldOffset = current->gtFieldOffset;
+            assert(fieldType != TYP_LONG);
+            info->srcCount++;
+
+            // For x86 we must mark all integral fields as contained or reg-optional, and handle them
+            // accordingly in code generation, since we may have up to 8 fields, which cannot all be in
+            // registers to be consumed atomically by the call.
+            if (varTypeIsIntegralOrI(fieldNode))
+            {
+                if (fieldNode->OperGet() == GT_LCL_VAR)
+                {
+                    LclVarDsc* varDsc = &(comp->lvaTable[fieldNode->AsLclVarCommon()->gtLclNum]);
+                    if (varDsc->lvTracked && !varDsc->lvDoNotEnregister)
+                    {
+                        SetRegOptional(fieldNode);
+                    }
+                    else
+                    {
+                        MakeSrcContained(putArgStk, fieldNode);
+                    }
+                }
+                else if (fieldNode->IsIntCnsFitsInI32())
+                {
+                    MakeSrcContained(putArgStk, fieldNode);
+                }
+                else
+                {
+                    // For the case where we cannot directly push the value, if we run out of registers,
+                    // it would be better to defer computation until we are pushing the arguments rather
+                    // than spilling, but this situation is not all that common, as most cases of promoted
+                    // structs do not have a large number of fields, and of those most are lclVars or
+                    // copy-propagated constants.
+                    SetRegOptional(fieldNode);
+                }
+            }
+#if defined(FEATURE_SIMD)
+            // Note that we need to check the GT_FIELD_LIST type, not the fieldType. This is because the
+            // GT_FIELD_LIST will be TYP_SIMD12 whereas the fieldType might be TYP_SIMD16 for lclVar, where
+            // we "round up" to 16.
+            else if (current->gtFieldType == TYP_SIMD12)
+            {
+                needsSimdTemp = true;
+            }
+#endif // defined(FEATURE_SIMD)
+            else
+            {
+                assert(varTypeIsFloating(fieldNode) || varTypeIsSIMD(fieldNode));
+            }
+
+            // We can treat as a slot any field that is stored at a slot boundary, where the previous
+            // field is not in the same slot. (Note that we store the fields in reverse order.)
+            const bool fieldIsSlot = ((fieldOffset % 4) == 0) && ((prevOffset - fieldOffset) >= 4);
+            if (!fieldIsSlot)
+            {
+                if (varTypeIsByte(fieldType))
+                {
+                    // If this field is a slot--i.e. it is an integer field that is 4-byte aligned and takes up 4 bytes
+                    // (including padding)--we can store the whole value rather than just the byte. Otherwise, we will
+                    // need a byte-addressable register for the store. We will enforce this requirement on an internal
+                    // register, which we can use to copy multiple byte values.
+                    needsByteTemp = true;
+                }
+            }
+
+            if (varTypeIsGC(fieldType))
+            {
+                putArgStk->gtNumberReferenceSlots++;
+            }
+            prevOffset = fieldOffset;
+            fieldCount++;
+        }
+
+        info->dstCount = 0;
+
+        if (putArgStk->gtPutArgStkKind == GenTreePutArgStk::Kind::Push)
+        {
+            // If any of the fields cannot be stored with an actual push, we may need a temporary
+            // register to load the value before storing it to the stack location.
+            info->internalIntCount = 1;
+            regMaskTP regMask      = l->allRegs(TYP_INT);
+            if (needsByteTemp)
+            {
+                regMask &= ~RBM_NON_BYTE_REGS;
+            }
+            info->setInternalCandidates(l, regMask);
+        }
+
+#if defined(FEATURE_SIMD)
+        // For PutArgStk of a TYP_SIMD12, we need a SIMD temp register.
+        if (needsSimdTemp)
+        {
+            info->internalFloatCount += 1;
+            info->addInternalCandidates(l, l->allSIMDRegs());
+        }
+#endif // defined(FEATURE_SIMD)
+
+        return;
+    }
+#endif // _TARGET_X86_
+
+#if defined(FEATURE_SIMD) && defined(_TARGET_X86_)
+    // For PutArgStk of a TYP_SIMD12, we need an extra register.
+    if (putArgStk->TypeGet() == TYP_SIMD12)
+    {
+        info->srcCount           = putArgStk->gtOp1->gtLsraInfo.dstCount;
+        info->dstCount           = 0;
+        info->internalFloatCount = 1;
+        info->setInternalCandidates(l, l->allSIMDRegs());
+        return;
+    }
+#endif // defined(FEATURE_SIMD) && defined(_TARGET_X86_)
+
+    if (putArgStk->TypeGet() != TYP_STRUCT)
+    {
+        TreeNodeInfoInitSimple(putArgStk);
+        return;
+    }
+
+    GenTreePtr dst     = putArgStk;
+    GenTreePtr src     = putArgStk->gtOp1;
+    GenTreePtr srcAddr = nullptr;
+
+    bool haveLocalAddr = false;
+    if ((src->OperGet() == GT_OBJ) || (src->OperGet() == GT_IND))
+    {
+        srcAddr = src->gtOp.gtOp1;
+        assert(srcAddr != nullptr);
+        haveLocalAddr = srcAddr->OperIsLocalAddr();
+    }
+    else
+    {
+        assert(varTypeIsSIMD(putArgStk));
+    }
+
+    info->srcCount = src->gtLsraInfo.dstCount;
+    info->dstCount = 0;
+
+    // If we have a buffer between XMM_REGSIZE_BYTES and CPBLK_UNROLL_LIMIT bytes, we'll use SSE2.
+    // Structs and buffer with sizes <= CPBLK_UNROLL_LIMIT bytes are occurring in more than 95% of
+    // our framework assemblies, so this is the main code generation scheme we'll use.
+    ssize_t size = putArgStk->gtNumSlots * TARGET_POINTER_SIZE;
+    switch (putArgStk->gtPutArgStkKind)
+    {
+        case GenTreePutArgStk::Kind::Push:
+        case GenTreePutArgStk::Kind::PushAllSlots:
+        case GenTreePutArgStk::Kind::Unroll:
+            // If we have a remainder smaller than XMM_REGSIZE_BYTES, we need an integer temp reg.
+            //
+            // x86 specific note: if the size is odd, the last copy operation would be of size 1 byte.
+            // But on x86 only RBM_BYTE_REGS could be used as byte registers.  Therefore, exclude
+            // RBM_NON_BYTE_REGS from internal candidates.
+            if ((putArgStk->gtNumberReferenceSlots == 0) && (size & (XMM_REGSIZE_BYTES - 1)) != 0)
+            {
+                info->internalIntCount++;
+                regMaskTP regMask = l->allRegs(TYP_INT);
+
+#ifdef _TARGET_X86_
+                if ((size % 2) != 0)
+                {
+                    regMask &= ~RBM_NON_BYTE_REGS;
+                }
+#endif
+                info->setInternalCandidates(l, regMask);
+            }
+
+#ifdef _TARGET_X86_
+            if (size >= 8)
+#else  // !_TARGET_X86_
+            if (size >= XMM_REGSIZE_BYTES)
+#endif // !_TARGET_X86_
+            {
+                // If we have a buffer larger than or equal to XMM_REGSIZE_BYTES on x64/ux,
+                // or larger than or equal to 8 bytes on x86, reserve an XMM register to use it for a
+                // series of 16-byte loads and stores.
+                info->internalFloatCount = 1;
+                info->addInternalCandidates(l, l->internalFloatRegCandidates());
+                SetContainsAVXFlags();
+            }
+            break;
+
+        case GenTreePutArgStk::Kind::RepInstr:
+            info->internalIntCount += 3;
+            info->setInternalCandidates(l, (RBM_RDI | RBM_RCX | RBM_RSI));
+            break;
+
+        default:
+            unreached();
+    }
+
+    // Always mark the OBJ and ADDR as contained trees by the putarg_stk. The codegen will deal with this tree.
+    MakeSrcContained(putArgStk, src);
+
+    if (haveLocalAddr)
+    {
+        // If the source address is the address of a lclVar, make the source address contained to avoid unnecessary
+        // copies.
+        //
+        // To avoid an assertion in MakeSrcContained, increment the parent's source count beforehand and decrement it
+        // afterwards.
+        info->srcCount++;
+        MakeSrcContained(putArgStk, srcAddr);
+        info->srcCount--;
+    }
+}
+#endif // FEATURE_PUT_STRUCT_ARG_STK
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitLclHeap: Set the NodeInfo for a GT_LCLHEAP.
+//
+// Arguments:
+//    tree      - The node of interest
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitLclHeap(GenTree* tree)
+{
+    TreeNodeInfo* info     = &(tree->gtLsraInfo);
+    LinearScan*   l        = m_lsra;
+    Compiler*     compiler = comp;
+
+    info->srcCount = 1;
+    info->dstCount = 1;
+
+    // Need a variable number of temp regs (see genLclHeap() in codegenamd64.cpp):
+    // Here '-' means don't care.
+    //
+    //     Size?                    Init Memory?         # temp regs
+    //      0                            -                  0 (returns 0)
+    //      const and <=6 reg words      -                  0 (pushes '0')
+    //      const and >6 reg words       Yes                0 (pushes '0')
+    //      const and <PageSize          No                 0 (amd64) 1 (x86)
+    //                                                        (x86:tmpReg for sutracting from esp)
+    //      const and >=PageSize         No                 2 (regCnt and tmpReg for subtracing from sp)
+    //      Non-const                    Yes                0 (regCnt=targetReg and pushes '0')
+    //      Non-const                    No                 2 (regCnt and tmpReg for subtracting from sp)
+    //
+    // Note: Here we don't need internal register to be different from targetReg.
+    // Rather, require it to be different from operand's reg.
+
+    GenTreePtr size = tree->gtOp.gtOp1;
+    if (size->IsCnsIntOrI())
+    {
+        MakeSrcContained(tree, size);
+
+        size_t sizeVal = size->gtIntCon.gtIconVal;
+
+        if (sizeVal == 0)
+        {
+            info->internalIntCount = 0;
+        }
+        else
+        {
+            // Compute the amount of memory to properly STACK_ALIGN.
+            // Note: The Gentree node is not updated here as it is cheap to recompute stack aligned size.
+            // This should also help in debugging as we can examine the original size specified with localloc.
+            sizeVal = AlignUp(sizeVal, STACK_ALIGN);
+
+            // For small allocations up to 6 pointer sized words (i.e. 48 bytes of localloc)
+            // we will generate 'push 0'.
+            assert((sizeVal % REGSIZE_BYTES) == 0);
+            size_t cntRegSizedWords = sizeVal / REGSIZE_BYTES;
+            if (cntRegSizedWords <= 6)
+            {
+                info->internalIntCount = 0;
+            }
+            else if (!compiler->info.compInitMem)
+            {
+                // No need to initialize allocated stack space.
+                if (sizeVal < compiler->eeGetPageSize())
+                {
+#ifdef _TARGET_X86_
+                    info->internalIntCount = 1; // x86 needs a register here to avoid generating "sub" on ESP.
+#else                                           // !_TARGET_X86_
+                    info->internalIntCount = 0;
+#endif                                          // !_TARGET_X86_
+                }
+                else
+                {
+                    // We need two registers: regCnt and RegTmp
+                    info->internalIntCount = 2;
+                }
+            }
+            else
+            {
+                // >6 and need to zero initialize allocated stack space.
+                info->internalIntCount = 0;
+            }
+        }
+    }
+    else
+    {
+        if (!compiler->info.compInitMem)
+        {
+            info->internalIntCount = 2;
+        }
+        else
+        {
+            info->internalIntCount = 0;
+        }
+    }
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitLogicalOp: Set the NodeInfo for GT_AND/GT_OR/GT_XOR,
+// as well as GT_ADD/GT_SUB.
+//
+// Arguments:
+//    tree      - The node of interest
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitLogicalOp(GenTree* tree)
+{
+    TreeNodeInfo* info = &(tree->gtLsraInfo);
+    LinearScan*   l    = m_lsra;
+
+    // We're not marking a constant hanging on the left of the add
+    // as containable so we assign it to a register having CQ impact.
+    // TODO-XArch-CQ: Detect this case and support both generating a single instruction
+    // for GT_ADD(Constant, SomeTree)
+    info->srcCount = 2;
+    info->dstCount = 1;
+
+    GenTree* op1 = tree->gtGetOp1();
+    GenTree* op2 = tree->gtGetOp2();
+
+    // We can directly encode the second operand if it is either a containable constant or a memory-op.
+    // In case of memory-op, we can encode it directly provided its type matches with 'tree' type.
+    // This is because during codegen, type of 'tree' is used to determine emit Type size. If the types
+    // do not match, they get normalized (i.e. sign/zero extended) on load into a register.
+    bool       directlyEncodable = false;
+    bool       binOpInRMW        = false;
+    GenTreePtr operand           = nullptr;
+
+    if (IsContainableImmed(tree, op2))
+    {
+        directlyEncodable = true;
+        operand           = op2;
+    }
+    else
+    {
+        binOpInRMW = IsBinOpInRMWStoreInd(tree);
+        if (!binOpInRMW)
+        {
+            if (op2->isMemoryOp() && tree->TypeGet() == op2->TypeGet())
+            {
+                directlyEncodable = true;
+                operand           = op2;
+            }
+            else if (tree->OperIsCommutative())
+            {
+                if (IsContainableImmed(tree, op1) ||
+                    (op1->isMemoryOp() && tree->TypeGet() == op1->TypeGet() && IsSafeToContainMem(tree, op1)))
+                {
+                    // If it is safe, we can reverse the order of operands of commutative operations for efficient
+                    // codegen
+                    directlyEncodable = true;
+                    operand           = op1;
+                }
+            }
+        }
+    }
+
+    if (directlyEncodable)
+    {
+        assert(operand != nullptr);
+        MakeSrcContained(tree, operand);
+    }
+    else if (!binOpInRMW)
+    {
+        // If this binary op neither has contained operands, nor is a
+        // Read-Modify-Write (RMW) operation, we can mark its operands
+        // as reg optional.
+        SetRegOptionalForBinOp(tree);
+    }
+
+    // Codegen of this tree node sets ZF and SF flags.
+    tree->gtFlags |= GTF_ZSF_SET;
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitModDiv: Set the NodeInfo for GT_MOD/GT_DIV/GT_UMOD/GT_UDIV.
+//
+// Arguments:
+//    tree      - The node of interest
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitModDiv(GenTree* tree)
+{
+    TreeNodeInfo* info = &(tree->gtLsraInfo);
+    LinearScan*   l    = m_lsra;
+
+    GenTree* op1 = tree->gtGetOp1();
+    GenTree* op2 = tree->gtGetOp2();
+
+    info->srcCount = 2;
+    info->dstCount = 1;
+
+    switch (tree->OperGet())
+    {
+        case GT_MOD:
+        case GT_DIV:
+            if (varTypeIsFloating(tree->TypeGet()))
+            {
+                // No implicit conversions at this stage as the expectation is that
+                // everything is made explicit by adding casts.
+                assert(op1->TypeGet() == op2->TypeGet());
+
+                if (op2->isMemoryOp() || op2->IsCnsNonZeroFltOrDbl())
+                {
+                    MakeSrcContained(tree, op2);
+                }
+                else
+                {
+                    // If there are no containable operands, we can make an operand reg optional.
+                    // SSE2 allows only op2 to be a memory-op.
+                    SetRegOptional(op2);
+                }
+
+                return;
+            }
+            break;
+
+        default:
+            break;
+    }
+
+    // Amd64 Div/Idiv instruction:
+    //    Dividend in RAX:RDX  and computes
+    //    Quotient in RAX, Remainder in RDX
+
+    if (tree->OperGet() == GT_MOD || tree->OperGet() == GT_UMOD)
+    {
+        // We are interested in just the remainder.
+        // RAX is used as a trashable register during computation of remainder.
+        info->setDstCandidates(l, RBM_RDX);
+    }
+    else
+    {
+        // We are interested in just the quotient.
+        // RDX gets used as trashable register during computation of quotient
+        info->setDstCandidates(l, RBM_RAX);
+    }
+
+    bool op2CanBeRegOptional = true;
+#ifdef _TARGET_X86_
+    if (op1->OperGet() == GT_LONG)
+    {
+        // To avoid reg move would like to have op1's low part in RAX and high part in RDX.
+        GenTree* loVal = op1->gtGetOp1();
+        GenTree* hiVal = op1->gtGetOp2();
+
+        // Src count is actually 3, so increment.
+        assert(op2->IsCnsIntOrI());
+        assert(tree->OperGet() == GT_UMOD);
+        info->srcCount++;
+        op2CanBeRegOptional = false;
+
+        // This situation also requires an internal register.
+        info->internalIntCount = 1;
+        info->setInternalCandidates(l, l->allRegs(TYP_INT));
+
+        loVal->gtLsraInfo.setSrcCandidates(l, RBM_EAX);
+        hiVal->gtLsraInfo.setSrcCandidates(l, RBM_EDX);
+    }
+    else
+#endif
+    {
+        // If possible would like to have op1 in RAX to avoid a register move
+        op1->gtLsraInfo.setSrcCandidates(l, RBM_RAX);
+    }
+
+    // divisor can be an r/m, but the memory indirection must be of the same size as the divide
+    if (op2->isMemoryOp() && (op2->TypeGet() == tree->TypeGet()))
+    {
+        MakeSrcContained(tree, op2);
+    }
+    else if (op2CanBeRegOptional)
+    {
+        op2->gtLsraInfo.setSrcCandidates(l, l->allRegs(TYP_INT) & ~(RBM_RAX | RBM_RDX));
+
+        // If there are no containable operands, we can make an operand reg optional.
+        // Div instruction allows only op2 to be a memory op.
+        SetRegOptional(op2);
+    }
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitIntrinsic: Set the NodeInfo for a GT_INTRINSIC.
+//
+// Arguments:
+//    tree      - The node of interest
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitIntrinsic(GenTree* tree)
+{
+    TreeNodeInfo* info = &(tree->gtLsraInfo);
+    LinearScan*   l    = m_lsra;
+
+    // Both operand and its result must be of floating point type.
+    GenTree* op1 = tree->gtGetOp1();
+    assert(varTypeIsFloating(op1));
+    assert(op1->TypeGet() == tree->TypeGet());
+
+    info->srcCount = 1;
+    info->dstCount = 1;
+
+    switch (tree->gtIntrinsic.gtIntrinsicId)
+    {
+        case CORINFO_INTRINSIC_Sqrt:
+            if (op1->isMemoryOp() || op1->IsCnsNonZeroFltOrDbl())
+            {
+                MakeSrcContained(tree, op1);
+            }
+            else
+            {
+                // Mark the operand as reg optional since codegen can still
+                // generate code if op1 is on stack.
+                SetRegOptional(op1);
+            }
+            break;
+
+        case CORINFO_INTRINSIC_Abs:
+            // Abs(float x) = x & 0x7fffffff
+            // Abs(double x) = x & 0x7ffffff ffffffff
+
+            // In case of Abs we need an internal register to hold mask.
+
+            // TODO-XArch-CQ: avoid using an internal register for the mask.
+            // Andps or andpd both will operate on 128-bit operands.
+            // The data section constant to hold the mask is a 64-bit size.
+            // Therefore, we need both the operand and mask to be in
+            // xmm register. When we add support in emitter to emit 128-bit
+            // data constants and instructions that operate on 128-bit
+            // memory operands we can avoid the need for an internal register.
+            if (tree->gtIntrinsic.gtIntrinsicId == CORINFO_INTRINSIC_Abs)
+            {
+                info->internalFloatCount = 1;
+                info->setInternalCandidates(l, l->internalFloatRegCandidates());
+            }
+            break;
+
+#ifdef _TARGET_X86_
+        case CORINFO_INTRINSIC_Cos:
+        case CORINFO_INTRINSIC_Sin:
+        case CORINFO_INTRINSIC_Round:
+            NYI_X86("Math intrinsics Cos, Sin and Round");
+            break;
+#endif // _TARGET_X86_
+
+        default:
+            // Right now only Sqrt/Abs are treated as math intrinsics
+            noway_assert(!"Unsupported math intrinsic");
+            unreached();
+            break;
+    }
+}
+
+#ifdef FEATURE_SIMD
+//------------------------------------------------------------------------
+// TreeNodeInfoInitSIMD: Set the NodeInfo for a GT_SIMD tree.
+//
+// Arguments:
+//    tree       - The GT_SIMD node of interest
+//
+// Return Value:
+//    None.
+
+void Lowering::TreeNodeInfoInitSIMD(GenTree* tree)
+{
+    GenTreeSIMD*  simdTree = tree->AsSIMD();
+    TreeNodeInfo* info     = &(tree->gtLsraInfo);
+    LinearScan*   lsra     = m_lsra;
+    info->dstCount         = 1;
+    SetContainsAVXFlags(true, simdTree->gtSIMDSize);
+    switch (simdTree->gtSIMDIntrinsicID)
+    {
+        GenTree* op1;
+        GenTree* op2;
+
+        case SIMDIntrinsicInit:
+        {
+            op1 = tree->gtOp.gtOp1;
+
+#if !defined(_TARGET_64BIT_)
+            if (op1->OperGet() == GT_LONG)
+            {
+                info->srcCount = 2;
+            }
+            else
+#endif // !defined(_TARGET_64BIT_)
+            {
+                info->srcCount = 1;
+            }
+
+            // This sets all fields of a SIMD struct to the given value.
+            // Mark op1 as contained if it is either zero or int constant of all 1's,
+            // or a float constant with 16 or 32 byte simdType (AVX case)
+            //
+            // Should never see small int base type vectors except for zero initialization.
+            assert(!varTypeIsSmallInt(simdTree->gtSIMDBaseType) || op1->IsIntegralConst(0));
+
+#if !defined(_TARGET_64BIT_)
+            if (op1->OperGet() == GT_LONG)
+            {
+                GenTree* op1lo = op1->gtGetOp1();
+                GenTree* op1hi = op1->gtGetOp2();
+
+                if ((op1lo->IsIntegralConst(0) && op1hi->IsIntegralConst(0)) ||
+                    (op1lo->IsIntegralConst(-1) && op1hi->IsIntegralConst(-1)))
+                {
+                    assert(op1->gtLsraInfo.srcCount == 0);
+                    assert(op1->gtLsraInfo.dstCount == 0);
+                    assert(op1lo->gtLsraInfo.srcCount == 0);
+                    assert(op1lo->gtLsraInfo.dstCount == 1);
+                    assert(op1hi->gtLsraInfo.srcCount == 0);
+                    assert(op1hi->gtLsraInfo.dstCount == 1);
+
+                    op1lo->gtLsraInfo.dstCount = 0;
+                    op1hi->gtLsraInfo.dstCount = 0;
+                    info->srcCount             = 0;
+                }
+                else
+                {
+                    // need a temp
+                    info->internalFloatCount = 1;
+                    info->setInternalCandidates(lsra, lsra->allSIMDRegs());
+                    info->isInternalRegDelayFree = true;
+                }
+            }
+            else
+#endif // !defined(_TARGET_64BIT_)
+                if (op1->IsFPZero() || op1->IsIntegralConst(0) ||
+                    (varTypeIsIntegral(simdTree->gtSIMDBaseType) && op1->IsIntegralConst(-1)))
+            {
+                MakeSrcContained(tree, op1);
+                info->srcCount = 0;
+            }
+            else if ((comp->getSIMDInstructionSet() == InstructionSet_AVX) &&
+                     ((simdTree->gtSIMDSize == 16) || (simdTree->gtSIMDSize == 32)))
+            {
+                // Either op1 is a float or dbl constant or an addr
+                if (op1->IsCnsFltOrDbl() || op1->OperIsLocalAddr())
+                {
+                    MakeSrcContained(tree, op1);
+                    info->srcCount = 0;
+                }
+            }
+        }
+        break;
+
+        case SIMDIntrinsicInitN:
+        {
+            info->srcCount = (short)(simdTree->gtSIMDSize / genTypeSize(simdTree->gtSIMDBaseType));
+
+            // Need an internal register to stitch together all the values into a single vector in a SIMD reg.
+            info->internalFloatCount = 1;
+            info->setInternalCandidates(lsra, lsra->allSIMDRegs());
+        }
+        break;
+
+        case SIMDIntrinsicInitArray:
+            // We have an array and an index, which may be contained.
+            info->srcCount = 2;
+            CheckImmedAndMakeContained(tree, tree->gtGetOp2());
+            break;
+
+        case SIMDIntrinsicDiv:
+            // SSE2 has no instruction support for division on integer vectors
+            noway_assert(varTypeIsFloating(simdTree->gtSIMDBaseType));
+            info->srcCount = 2;
+            break;
+
+        case SIMDIntrinsicAbs:
+            // float/double vectors: This gets implemented as bitwise-And operation
+            // with a mask and hence should never see  here.
+            //
+            // Must be a Vector<int> or Vector<short> Vector<sbyte>
+            assert(simdTree->gtSIMDBaseType == TYP_INT || simdTree->gtSIMDBaseType == TYP_SHORT ||
+                   simdTree->gtSIMDBaseType == TYP_BYTE);
+            assert(comp->getSIMDInstructionSet() >= InstructionSet_SSE3_4);
+            info->srcCount = 1;
+            break;
+
+        case SIMDIntrinsicSqrt:
+            // SSE2 has no instruction support for sqrt on integer vectors.
+            noway_assert(varTypeIsFloating(simdTree->gtSIMDBaseType));
+            info->srcCount = 1;
+            break;
+
+        case SIMDIntrinsicAdd:
+        case SIMDIntrinsicSub:
+        case SIMDIntrinsicMul:
+        case SIMDIntrinsicBitwiseAnd:
+        case SIMDIntrinsicBitwiseAndNot:
+        case SIMDIntrinsicBitwiseOr:
+        case SIMDIntrinsicBitwiseXor:
+        case SIMDIntrinsicMin:
+        case SIMDIntrinsicMax:
+            info->srcCount = 2;
+
+            // SSE2 32-bit integer multiplication requires two temp regs
+            if (simdTree->gtSIMDIntrinsicID == SIMDIntrinsicMul && simdTree->gtSIMDBaseType == TYP_INT &&
+                comp->getSIMDInstructionSet() == InstructionSet_SSE2)
+            {
+                info->internalFloatCount = 2;
+                info->setInternalCandidates(lsra, lsra->allSIMDRegs());
+            }
+            break;
+
+        case SIMDIntrinsicEqual:
+            info->srcCount = 2;
+            break;
+
+        // SSE2 doesn't support < and <= directly on int vectors.
+        // Instead we need to use > and >= with swapped operands.
+        case SIMDIntrinsicLessThan:
+        case SIMDIntrinsicLessThanOrEqual:
+            info->srcCount = 2;
+            noway_assert(!varTypeIsIntegral(simdTree->gtSIMDBaseType));
+            break;
+
+        // SIMDIntrinsicEqual is supported only on non-floating point base type vectors.
+        // SSE2 cmpps/pd doesn't support > and >=  directly on float/double vectors.
+        // Instead we need to use <  and <= with swapped operands.
+        case SIMDIntrinsicGreaterThan:
+            noway_assert(!varTypeIsFloating(simdTree->gtSIMDBaseType));
+            info->srcCount = 2;
+            break;
+
+        case SIMDIntrinsicOpEquality:
+        case SIMDIntrinsicOpInEquality:
+            info->srcCount = 2;
+
+            // On SSE4/AVX, we can generate optimal code for (in)equality
+            // against zero using ptest. We can safely do this optimization
+            // for integral vectors but not for floating-point for the reason
+            // that we have +0.0 and -0.0 and +0.0 == -0.0
+            op2 = tree->gtGetOp2();
+            if ((comp->getSIMDInstructionSet() >= InstructionSet_SSE3_4) && op2->IsIntegralConstVector(0))
+            {
+                MakeSrcContained(tree, op2);
+            }
+            else
+            {
+                // Need one SIMD register as scratch.
+                // See genSIMDIntrinsicRelOp() for details on code sequence generated and
+                // the need for one scratch register.
+                //
+                // Note these intrinsics produce a BOOL result, hence internal float
+                // registers reserved are guaranteed to be different from target
+                // integer register without explicitly specifying.
+                info->internalFloatCount = 1;
+                info->setInternalCandidates(lsra, lsra->allSIMDRegs());
+            }
+            break;
+
+        case SIMDIntrinsicDotProduct:
+            // Float/Double vectors:
+            // For SSE, or AVX with 32-byte vectors, we also need an internal register
+            // as scratch. Further we need the targetReg and internal reg to be distinct
+            // registers. Note that if this is a TYP_SIMD16 or smaller on AVX, then we
+            // don't need a tmpReg.
+            //
+            // 32-byte integer vector on SSE4/AVX:
+            // will take advantage of phaddd, which operates only on 128-bit xmm reg.
+            // This will need 1 (in case of SSE4) or 2 (in case of AVX) internal
+            // registers since targetReg is an int type register.
+            //
+            // See genSIMDIntrinsicDotProduct() for details on code sequence generated
+            // and the need for scratch registers.
+            if (varTypeIsFloating(simdTree->gtSIMDBaseType))
+            {
+                if ((comp->getSIMDInstructionSet() == InstructionSet_SSE2) ||
+                    (simdTree->gtOp.gtOp1->TypeGet() == TYP_SIMD32))
+                {
+                    info->internalFloatCount     = 1;
+                    info->isInternalRegDelayFree = true;
+                    info->setInternalCandidates(lsra, lsra->allSIMDRegs());
+                }
+                // else don't need scratch reg(s).
+            }
+            else
+            {
+                assert(simdTree->gtSIMDBaseType == TYP_INT && comp->getSIMDInstructionSet() >= InstructionSet_SSE3_4);
+
+                // No need to set isInternalRegDelayFree since targetReg is a
+                // an int type reg and guaranteed to be different from xmm/ymm
+                // regs.
+                info->internalFloatCount = comp->canUseAVX() ? 2 : 1;
+                info->setInternalCandidates(lsra, lsra->allSIMDRegs());
+            }
+            info->srcCount = 2;
+            break;
+
+        case SIMDIntrinsicGetItem:
+        {
+            // This implements get_Item method. The sources are:
+            //  - the source SIMD struct
+            //  - index (which element to get)
+            // The result is baseType of SIMD struct.
+            info->srcCount = 2;
+            op1            = tree->gtOp.gtOp1;
+            op2            = tree->gtOp.gtOp2;
+
+            // If the index is a constant, mark it as contained.
+            if (CheckImmedAndMakeContained(tree, op2))
+            {
+                info->srcCount = 1;
+            }
+
+            if (op1->isMemoryOp())
+            {
+                MakeSrcContained(tree, op1);
+
+                // Although GT_IND of TYP_SIMD12 reserves an internal float
+                // register for reading 4 and 8 bytes from memory and
+                // assembling them into target XMM reg, it is not required
+                // in this case.
+                op1->gtLsraInfo.internalIntCount   = 0;
+                op1->gtLsraInfo.internalFloatCount = 0;
+            }
+            else
+            {
+                // If the index is not a constant, we will use the SIMD temp location to store the vector.
+                // Otherwise, if the baseType is floating point, the targetReg will be a xmm reg and we
+                // can use that in the process of extracting the element.
+                //
+                // If the index is a constant and base type is a small int we can use pextrw, but on AVX
+                // we will need a temp if are indexing into the upper half of the AVX register.
+                // In all other cases with constant index, we need a temp xmm register to extract the
+                // element if index is other than zero.
+
+                if (!op2->IsCnsIntOrI())
+                {
+                    (void)comp->getSIMDInitTempVarNum();
+                }
+                else if (!varTypeIsFloating(simdTree->gtSIMDBaseType))
+                {
+                    bool needFloatTemp;
+                    if (varTypeIsSmallInt(simdTree->gtSIMDBaseType) &&
+                        (comp->getSIMDInstructionSet() == InstructionSet_AVX))
+                    {
+                        int byteShiftCnt = (int)op2->AsIntCon()->gtIconVal * genTypeSize(simdTree->gtSIMDBaseType);
+                        needFloatTemp    = (byteShiftCnt >= 16);
+                    }
+                    else
+                    {
+                        needFloatTemp = !op2->IsIntegralConst(0);
+                    }
+
+                    if (needFloatTemp)
+                    {
+                        info->internalFloatCount = 1;
+                        info->setInternalCandidates(lsra, lsra->allSIMDRegs());
+                    }
+                }
+            }
+        }
+        break;
+
+        case SIMDIntrinsicSetX:
+        case SIMDIntrinsicSetY:
+        case SIMDIntrinsicSetZ:
+        case SIMDIntrinsicSetW:
+            info->srcCount = 2;
+
+            // We need an internal integer register for SSE2 codegen
+            if (comp->getSIMDInstructionSet() == InstructionSet_SSE2)
+            {
+                info->internalIntCount = 1;
+                info->setInternalCandidates(lsra, lsra->allRegs(TYP_INT));
+            }
+
+            break;
+
+        case SIMDIntrinsicCast:
+            info->srcCount = 1;
+            break;
+
+        case SIMDIntrinsicShuffleSSE2:
+            info->srcCount = 2;
+            // Second operand is an integer constant and marked as contained.
+            op2 = tree->gtOp.gtOp2;
+            noway_assert(op2->IsCnsIntOrI());
+            MakeSrcContained(tree, op2);
+            break;
+
+        case SIMDIntrinsicGetX:
+        case SIMDIntrinsicGetY:
+        case SIMDIntrinsicGetZ:
+        case SIMDIntrinsicGetW:
+        case SIMDIntrinsicGetOne:
+        case SIMDIntrinsicGetZero:
+        case SIMDIntrinsicGetCount:
+        case SIMDIntrinsicGetAllOnes:
+            assert(!"Get intrinsics should not be seen during Lowering.");
+            unreached();
+
+        default:
+            noway_assert(!"Unimplemented SIMD node type.");
+            unreached();
+    }
+}
+#endif // FEATURE_SIMD
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitCast: Set the NodeInfo for a GT_CAST.
+//
+// Arguments:
+//    tree      - The node of interest
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitCast(GenTree* tree)
+{
+    TreeNodeInfo* info = &(tree->gtLsraInfo);
+
+    // TODO-XArch-CQ: Int-To-Int conversions - castOp cannot be a memory op and must have an assigned register.
+    //         see CodeGen::genIntToIntCast()
+
+    info->srcCount = 1;
+    info->dstCount = 1;
+
+    // Non-overflow casts to/from float/double are done using SSE2 instructions
+    // and that allow the source operand to be either a reg or memop. Given the
+    // fact that casts from small int to float/double are done as two-level casts,
+    // the source operand is always guaranteed to be of size 4 or 8 bytes.
+    var_types  castToType = tree->CastToType();
+    GenTreePtr castOp     = tree->gtCast.CastOp();
+    var_types  castOpType = castOp->TypeGet();
+    if (tree->gtFlags & GTF_UNSIGNED)
+    {
+        castOpType = genUnsignedType(castOpType);
+    }
+
+    if (!tree->gtOverflow() && (varTypeIsFloating(castToType) || varTypeIsFloating(castOpType)))
+    {
+#ifdef DEBUG
+        // If converting to float/double, the operand must be 4 or 8 byte in size.
+        if (varTypeIsFloating(castToType))
+        {
+            unsigned opSize = genTypeSize(castOpType);
+            assert(opSize == 4 || opSize == 8);
+        }
+#endif // DEBUG
+
+        // U8 -> R8 conversion requires that the operand be in a register.
+        if (castOpType != TYP_ULONG)
+        {
+            if (castOp->isMemoryOp() || castOp->IsCnsNonZeroFltOrDbl())
+            {
+                MakeSrcContained(tree, castOp);
+            }
+            else
+            {
+                // Mark castOp as reg optional to indicate codegen
+                // can still generate code if it is on stack.
+                SetRegOptional(castOp);
+            }
+        }
+    }
+
+#if !defined(_TARGET_64BIT_)
+    if (varTypeIsLong(castOpType))
+    {
+        noway_assert(castOp->OperGet() == GT_LONG);
+        info->srcCount = 2;
+    }
+#endif // !defined(_TARGET_64BIT_)
+
+    // some overflow checks need a temp reg:
+    //  - GT_CAST from INT64/UINT64 to UINT32
+    if (tree->gtOverflow() && (castToType == TYP_UINT))
+    {
+        if (genTypeSize(castOpType) == 8)
+        {
+            // Here we don't need internal register to be different from targetReg,
+            // rather require it to be different from operand's reg.
+            info->internalIntCount = 1;
+        }
+    }
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitGCWriteBarrier: Set the NodeInfo for a GT_STOREIND requiring a write barrier.
+//
+// Arguments:
+//    tree      - The node of interest
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitGCWriteBarrier(GenTree* tree)
+{
+    assert(tree->OperGet() == GT_STOREIND);
+
+    GenTreeStoreInd* dst  = tree->AsStoreInd();
+    GenTreePtr       addr = dst->Addr();
+    GenTreePtr       src  = dst->Data();
+
+    if (addr->OperGet() == GT_LEA)
+    {
+        // In the case where we are doing a helper assignment, if the dst
+        // is an indir through an lea, we need to actually instantiate the
+        // lea in a register
+        GenTreeAddrMode* lea = addr->AsAddrMode();
+
+        int leaSrcCount = 0;
+        if (lea->HasBase())
+        {
+            leaSrcCount++;
+        }
+        if (lea->HasIndex())
+        {
+            leaSrcCount++;
+        }
+        lea->gtLsraInfo.srcCount = leaSrcCount;
+        lea->gtLsraInfo.dstCount = 1;
+    }
+
+    bool useOptimizedWriteBarrierHelper = false; // By default, assume no optimized write barriers.
+
+#if NOGC_WRITE_BARRIERS
+
+#if defined(_TARGET_X86_)
+
+    useOptimizedWriteBarrierHelper = true; // On x86, use the optimized write barriers by default.
+#ifdef DEBUG
+    GCInfo::WriteBarrierForm wbf = comp->codeGen->gcInfo.gcIsWriteBarrierCandidate(tree, src);
+    if (wbf == GCInfo::WBF_NoBarrier_CheckNotHeapInDebug) // This one is always a call to a C++ method.
+    {
+        useOptimizedWriteBarrierHelper = false;
+    }
+#endif
+
+    if (useOptimizedWriteBarrierHelper)
+    {
+        // Special write barrier:
+        // op1 (addr) goes into REG_WRITE_BARRIER (rdx) and
+        // op2 (src) goes into any int register.
+        addr->gtLsraInfo.setSrcCandidates(m_lsra, RBM_WRITE_BARRIER);
+        src->gtLsraInfo.setSrcCandidates(m_lsra, RBM_WRITE_BARRIER_SRC);
+    }
+
+#else // !defined(_TARGET_X86_)
+#error "NOGC_WRITE_BARRIERS is not supported"
+#endif // !defined(_TARGET_X86_)
+
+#endif // NOGC_WRITE_BARRIERS
+
+    if (!useOptimizedWriteBarrierHelper)
+    {
+        // For the standard JIT Helper calls:
+        // op1 (addr) goes into REG_ARG_0 and
+        // op2 (src) goes into REG_ARG_1
+        addr->gtLsraInfo.setSrcCandidates(m_lsra, RBM_ARG_0);
+        src->gtLsraInfo.setSrcCandidates(m_lsra, RBM_ARG_1);
+    }
+
+    // Both src and dst must reside in a register, which they should since we haven't set
+    // either of them as contained.
+    assert(addr->gtLsraInfo.dstCount == 1);
+    assert(src->gtLsraInfo.dstCount == 1);
+}
+
+//-----------------------------------------------------------------------------------------
+// TreeNodeInfoInitIndir: Specify register requirements for address expression of an indirection operation.
+//
+// Arguments:
+//    indirTree    -   GT_IND or GT_STOREIND gentree node
+//
+void Lowering::TreeNodeInfoInitIndir(GenTreePtr indirTree)
+{
+    assert(indirTree->isIndir());
+    // If this is the rhs of a block copy (i.e. non-enregisterable struct),
+    // it has no register requirements.
+    if (indirTree->TypeGet() == TYP_STRUCT)
+    {
+        return;
+    }
+
+    GenTreePtr    addr = indirTree->gtGetOp1();
+    TreeNodeInfo* info = &(indirTree->gtLsraInfo);
+
+    GenTreePtr base  = nullptr;
+    GenTreePtr index = nullptr;
+    unsigned   mul, cns;
+    bool       rev;
+
+#ifdef FEATURE_SIMD
+    // If indirTree is of TYP_SIMD12, don't mark addr as contained
+    // so that it always get computed to a register.  This would
+    // mean codegen side logic doesn't need to handle all possible
+    // addr expressions that could be contained.
+    //
+    // TODO-XArch-CQ: handle other addr mode expressions that could be marked
+    // as contained.
+    if (indirTree->TypeGet() == TYP_SIMD12)
+    {
+        // Vector3 is read/written as two reads/writes: 8 byte and 4 byte.
+        // To assemble the vector properly we would need an additional
+        // XMM register.
+        info->internalFloatCount = 1;
+
+        // In case of GT_IND we need an internal register different from targetReg and
+        // both of the registers are used at the same time.
+        if (indirTree->OperGet() == GT_IND)
+        {
+            info->isInternalRegDelayFree = true;
+        }
+
+        info->setInternalCandidates(m_lsra, m_lsra->allSIMDRegs());
+
+        return;
+    }
+#endif // FEATURE_SIMD
+
+    if ((indirTree->gtFlags & GTF_IND_REQ_ADDR_IN_REG) != 0)
+    {
+        // The address of an indirection that requires its address in a reg.
+        // Skip any further processing that might otherwise make it contained.
+    }
+    else if ((addr->OperGet() == GT_CLS_VAR_ADDR) || (addr->OperGet() == GT_LCL_VAR_ADDR))
+    {
+        // These nodes go into an addr mode:
+        // - GT_CLS_VAR_ADDR turns into a constant.
+        // - GT_LCL_VAR_ADDR is a stack addr mode.
+
+        // make this contained, it turns into a constant that goes into an addr mode
+        MakeSrcContained(indirTree, addr);
+    }
+    else if (addr->IsCnsIntOrI() && addr->AsIntConCommon()->FitsInAddrBase(comp))
+    {
+        // Amd64:
+        // We can mark any pc-relative 32-bit addr as containable, except for a direct VSD call address.
+        // (i.e. those VSD calls for which stub addr is known during JIT compilation time).  In this case,
+        // VM requires us to pass stub addr in REG_VIRTUAL_STUB_PARAM - see LowerVirtualStubCall().  For
+        // that reason we cannot mark such an addr as contained.  Note that this is not an issue for
+        // indirect VSD calls since morphArgs() is explicitly materializing hidden param as a non-standard
+        // argument.
+        //
+        // Workaround:
+        // Note that LowerVirtualStubCall() sets addr->gtRegNum to REG_VIRTUAL_STUB_PARAM and Lowering::doPhase()
+        // sets destination candidates on such nodes and resets addr->gtRegNum to REG_NA before calling
+        // TreeNodeInfoInit(). Ideally we should set a flag on addr nodes that shouldn't be marked as contained
+        // (in LowerVirtualStubCall()), but we don't have any GTF_* flags left for that purpose.  As a workaround
+        // an explicit check is made here.
+        //
+        // On x86, direct VSD is done via a relative branch, and in fact it MUST be contained.
+        MakeSrcContained(indirTree, addr);
+    }
+    else if ((addr->OperGet() == GT_LEA) && IsSafeToContainMem(indirTree, addr))
+    {
+        MakeSrcContained(indirTree, addr);
+    }
+    else if (addr->gtOper == GT_ARR_ELEM)
+    {
+        // The GT_ARR_ELEM consumes all the indices and produces the offset.
+        // The array object lives until the mem access.
+        // We also consume the target register to which the address is
+        // computed
+
+        info->srcCount++;
+        assert(addr->gtLsraInfo.srcCount >= 2);
+        addr->gtLsraInfo.srcCount -= 1;
+    }
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitCmp: Set the register requirements for a compare.
+//
+// Arguments:
+//    tree      - The node of interest
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitCmp(GenTreePtr tree)
+{
+    assert(tree->OperIsCompare());
+
+    TreeNodeInfo* info = &(tree->gtLsraInfo);
+
+    info->srcCount = 2;
+    info->dstCount = 1;
+
+#ifdef _TARGET_X86_
+    // If the compare is used by a jump, we just need to set the condition codes. If not, then we need
+    // to store the result into the low byte of a register, which requires the dst be a byteable register.
+    // We always set the dst candidates, though, because if this is compare is consumed by a jump, they
+    // won't be used. We might be able to use GTF_RELOP_JMP_USED to determine this case, but it's not clear
+    // that flag is maintained until this location (especially for decomposed long compares).
+    info->setDstCandidates(m_lsra, RBM_BYTE_REGS);
+#endif // _TARGET_X86_
+
+    GenTreePtr op1     = tree->gtOp.gtOp1;
+    GenTreePtr op2     = tree->gtOp.gtOp2;
+    var_types  op1Type = op1->TypeGet();
+    var_types  op2Type = op2->TypeGet();
+
+#if !defined(_TARGET_64BIT_)
+    // Long compares will consume GT_LONG nodes, each of which produces two results.
+    // Thus for each long operand there will be an additional source.
+    // TODO-X86-CQ: Mark hiOp2 and loOp2 as contained if it is a constant or a memory op.
+    if (varTypeIsLong(op1Type))
+    {
+        info->srcCount++;
+    }
+    if (varTypeIsLong(op2Type))
+    {
+        info->srcCount++;
+    }
+#endif // !defined(_TARGET_64BIT_)
+
+    // If either of op1 or op2 is floating point values, then we need to use
+    // ucomiss or ucomisd to compare, both of which support the following form:
+    //     ucomis[s|d] xmm, xmm/mem
+    // That is only the second operand can be a memory op.
+    //
+    // Second operand is a memory Op:  Note that depending on comparison operator,
+    // the operands of ucomis[s|d] need to be reversed.  Therefore, either op1 or
+    // op2 can be a memory op depending on the comparison operator.
+    if (varTypeIsFloating(op1Type))
+    {
+        // The type of the operands has to be the same and no implicit conversions at this stage.
+        assert(op1Type == op2Type);
+
+        bool reverseOps;
+        if ((tree->gtFlags & GTF_RELOP_NAN_UN) != 0)
+        {
+            // Unordered comparison case
+            reverseOps = tree->OperIs(GT_GT, GT_GE);
+        }
+        else
+        {
+            reverseOps = tree->OperIs(GT_LT, GT_LE);
+        }
+
+        GenTreePtr otherOp;
+        if (reverseOps)
+        {
+            otherOp = op1;
+        }
+        else
+        {
+            otherOp = op2;
+        }
+
+        assert(otherOp != nullptr);
+        if (otherOp->IsCnsNonZeroFltOrDbl())
+        {
+            MakeSrcContained(tree, otherOp);
+        }
+        else if (otherOp->isMemoryOp() && ((otherOp == op2) || IsSafeToContainMem(tree, otherOp)))
+        {
+            MakeSrcContained(tree, otherOp);
+        }
+        else
+        {
+            // SSE2 allows only otherOp to be a memory-op. Since otherOp is not
+            // contained, we can mark it reg-optional.
+            SetRegOptional(otherOp);
+        }
+
+        return;
+    }
+
+    // TODO-XArch-CQ: factor out cmp optimization in 'genCondSetFlags' to be used here
+    // or in other backend.
+
+    if (CheckImmedAndMakeContained(tree, op2))
+    {
+        // If the types are the same, or if the constant is of the correct size,
+        // we can treat the isMemoryOp as contained.
+        if (op1Type == op2Type)
+        {
+            if (op1->isMemoryOp())
+            {
+                MakeSrcContained(tree, op1);
+            }
+            // If op1 codegen sets ZF and SF flags and ==/!= against
+            // zero, we don't need to generate test instruction,
+            // provided we don't have another GenTree node between op1
+            // and tree that could potentially modify flags.
+            //
+            // TODO-CQ: right now the below peep is inexpensive and
+            // gets the benefit in most of cases because in majority
+            // of cases op1, op2 and tree would be in that order in
+            // execution.  In general we should be able to check that all
+            // the nodes that come after op1 in execution order do not
+            // modify the flags so that it is safe to avoid generating a
+            // test instruction.  Such a check requires that on each
+            // GenTree node we need to set the info whether its codegen
+            // will modify flags.
+            //
+            // TODO-CQ: We can optimize compare against zero in the
+            // following cases by generating the branch as indicated
+            // against each case.
+            //  1) unsigned compare
+            //        < 0  - always FALSE
+            //       <= 0  - ZF=1 and jne
+            //        > 0  - ZF=0 and je
+            //       >= 0  - always TRUE
+            //
+            // 2) signed compare
+            //        < 0  - SF=1 and js
+            //       >= 0  - SF=0 and jns
+            else if (tree->OperIs(GT_EQ, GT_NE) && op1->gtSetZSFlags() && op2->IsIntegralConst(0) &&
+                     (op1->gtNext == op2) && (op2->gtNext == tree))
+            {
+                // Require codegen of op1 to set the flags.
+                assert(!op1->gtSetFlags());
+                op1->gtFlags |= GTF_SET_FLAGS;
+            }
+            else
+            {
+                SetRegOptional(op1);
+            }
+        }
+    }
+    else if (op1Type == op2Type)
+    {
+        // Note that TEST does not have a r,rm encoding like CMP has but we can still
+        // contain the second operand because the emitter maps both r,rm and rm,r to
+        // the same instruction code. This avoids the need to special case TEST here.
+        if (op2->isMemoryOp())
+        {
+            MakeSrcContained(tree, op2);
+        }
+        else if (op1->isMemoryOp() && IsSafeToContainMem(tree, op1))
+        {
+            MakeSrcContained(tree, op1);
+        }
+        else if (op1->IsCnsIntOrI())
+        {
+            // TODO-CQ: We should be able to support swapping op1 and op2 to generate cmp reg, imm,
+            // but there is currently an assert in CodeGen::genCompareInt().
+            // https://github.com/dotnet/coreclr/issues/7270
+            SetRegOptional(op2);
+        }
+        else
+        {
+            // One of op1 or op2 could be marked as reg optional
+            // to indicate that codegen can still generate code
+            // if one of them is on stack.
+            SetRegOptional(PreferredRegOptionalOperand(tree));
+        }
+    }
+}
+
+//--------------------------------------------------------------------------------------------
+// TreeNodeInfoInitIfRMWMemOp: Checks to see if there is a RMW memory operation rooted at
+// GT_STOREIND node and if so will mark register requirements for nodes under storeInd so
+// that CodeGen will generate a single instruction of the form:
+//
+//         binOp [addressing mode], reg
+//
+// Parameters
+//         storeInd   - GT_STOREIND node
+//
+// Return value
+//         True, if RMW memory op tree pattern is recognized and op counts are set.
+//         False otherwise.
+//
+bool Lowering::TreeNodeInfoInitIfRMWMemOp(GenTreePtr storeInd)
+{
+    assert(storeInd->OperGet() == GT_STOREIND);
+
+    // SSE2 doesn't support RMW on float values
+    assert(!varTypeIsFloating(storeInd));
+
+    // Terminology:
+    // indirDst = memory write of an addr mode  (i.e. storeind destination)
+    // indirSrc = value being written to memory (i.e. storeind source which could a binary/unary op)
+    // indirCandidate = memory read i.e. a gtInd of an addr mode
+    // indirOpSource = source operand used in binary/unary op (i.e. source operand of indirSrc node)
+
+    GenTreePtr indirCandidate = nullptr;
+    GenTreePtr indirOpSource  = nullptr;
+
+    if (!IsRMWMemOpRootedAtStoreInd(storeInd, &indirCandidate, &indirOpSource))
+    {
+        JITDUMP("Lower of StoreInd didn't mark the node as self contained for reason: %d\n",
+                storeInd->AsStoreInd()->GetRMWStatus());
+        DISPTREERANGE(BlockRange(), storeInd);
+        return false;
+    }
+
+    GenTreePtr indirDst = storeInd->gtGetOp1();
+    GenTreePtr indirSrc = storeInd->gtGetOp2();
+    genTreeOps oper     = indirSrc->OperGet();
+
+    // At this point we have successfully detected a RMW memory op of one of the following forms
+    //         storeInd(indirDst, indirSrc(indirCandidate, indirOpSource)) OR
+    //         storeInd(indirDst, indirSrc(indirOpSource, indirCandidate) in case of commutative operations OR
+    //         storeInd(indirDst, indirSrc(indirCandidate) in case of unary operations
+    //
+    // Here indirSrc = one of the supported binary or unary operation for RMW of memory
+    //      indirCandidate = a GT_IND node
+    //      indirCandidateChild = operand of GT_IND indirCandidate
+    //
+    // The logic below essentially does the following
+    //      Make indirOpSource contained.
+    //      Make indirSrc contained.
+    //      Make indirCandidate contained.
+    //      Make indirCandidateChild contained.
+    //      Make indirDst contained except when it is a GT_LCL_VAR or GT_CNS_INT that doesn't fit within addr
+    //      base.
+    // Note that due to the way containment is supported, we accomplish some of the above by clearing operand counts
+    // and directly propagating them upward.
+    //
+
+    TreeNodeInfo* info = &(storeInd->gtLsraInfo);
+    info->dstCount     = 0;
+
+    if (GenTree::OperIsBinary(oper))
+    {
+        // On Xarch RMW operations require that the source memory-op be in a register.
+        assert(!indirOpSource->isMemoryOp() || indirOpSource->gtLsraInfo.dstCount == 1);
+        JITDUMP("Lower succesfully detected an assignment of the form: *addrMode BinOp= source\n");
+        info->srcCount = indirOpSource->gtLsraInfo.dstCount;
+    }
+    else
+    {
+        assert(GenTree::OperIsUnary(oper));
+        JITDUMP("Lower succesfully detected an assignment of the form: *addrMode = UnaryOp(*addrMode)\n");
+        info->srcCount = 0;
+    }
+    DISPTREERANGE(BlockRange(), storeInd);
+
+    m_lsra->clearOperandCounts(indirSrc);
+    m_lsra->clearOperandCounts(indirCandidate);
+
+    GenTreePtr indirCandidateChild = indirCandidate->gtGetOp1();
+    if (indirCandidateChild->OperGet() == GT_LEA)
+    {
+        GenTreeAddrMode* addrMode = indirCandidateChild->AsAddrMode();
+
+        if (addrMode->HasBase())
+        {
+            assert(addrMode->Base()->OperIsLeaf());
+            m_lsra->clearOperandCounts(addrMode->Base());
+            info->srcCount++;
+        }
+
+        if (addrMode->HasIndex())
+        {
+            assert(addrMode->Index()->OperIsLeaf());
+            m_lsra->clearOperandCounts(addrMode->Index());
+            info->srcCount++;
+        }
+
+        m_lsra->clearOperandCounts(indirDst);
+    }
+    else
+    {
+        assert(indirCandidateChild->OperGet() == GT_LCL_VAR || indirCandidateChild->OperGet() == GT_LCL_VAR_ADDR ||
+               indirCandidateChild->OperGet() == GT_CLS_VAR_ADDR || indirCandidateChild->OperGet() == GT_CNS_INT);
+
+        // If it is a GT_LCL_VAR, it still needs the reg to hold the address.
+        // We would still need a reg for GT_CNS_INT if it doesn't fit within addressing mode base.
+        // For GT_CLS_VAR_ADDR, we don't need a reg to hold the address, because field address value is known at jit
+        // time. Also, we don't need a reg for GT_CLS_VAR_ADDR.
+        if (indirCandidateChild->OperGet() == GT_LCL_VAR_ADDR || indirCandidateChild->OperGet() == GT_CLS_VAR_ADDR)
+        {
+            m_lsra->clearOperandCounts(indirDst);
+        }
+        else if (indirCandidateChild->IsCnsIntOrI() && indirCandidateChild->AsIntConCommon()->FitsInAddrBase(comp))
+        {
+            m_lsra->clearOperandCounts(indirDst);
+        }
+        else
+        {
+            // Need a reg and hence increment src count of storeind
+            info->srcCount += indirCandidateChild->gtLsraInfo.dstCount;
+        }
+    }
+    m_lsra->clearOperandCounts(indirCandidateChild);
+
+#ifdef _TARGET_X86_
+    if (varTypeIsByte(storeInd))
+    {
+        // If storeInd is of TYP_BYTE, set indirOpSources to byteable registers.
+        bool containedNode = indirOpSource->gtLsraInfo.dstCount == 0;
+        if (!containedNode)
+        {
+            regMaskTP regMask = indirOpSource->gtLsraInfo.getSrcCandidates(m_lsra);
+            assert(regMask != RBM_NONE);
+            indirOpSource->gtLsraInfo.setSrcCandidates(m_lsra, regMask & ~RBM_NON_BYTE_REGS);
+        }
+    }
+#endif
+
+    return true;
+}
+
+//------------------------------------------------------------------------
+// TreeNodeInfoInitMul: Set the NodeInfo for a multiply.
+//
+// Arguments:
+//    tree      - The node of interest
+//
+// Return Value:
+//    None.
+//
+void Lowering::TreeNodeInfoInitMul(GenTreePtr tree)
+{
+#if defined(_TARGET_X86_)
+    assert(tree->OperGet() == GT_MUL || tree->OperGet() == GT_MULHI || tree->OperGet() == GT_MUL_LONG);
+#else
+    assert(tree->OperGet() == GT_MUL || tree->OperGet() == GT_MULHI);
+#endif
+    TreeNodeInfo* info = &(tree->gtLsraInfo);
+
+    info->srcCount = 2;
+    info->dstCount = 1;
+
+    GenTreePtr op1 = tree->gtOp.gtOp1;
+    GenTreePtr op2 = tree->gtOp.gtOp2;
+
+    // Case of float/double mul.
+    if (varTypeIsFloating(tree->TypeGet()))
+    {
+        assert(tree->OperGet() == GT_MUL);
+
+        if (op2->isMemoryOp() || op2->IsCnsNonZeroFltOrDbl())
+        {
+            MakeSrcContained(tree, op2);
+        }
+        else if (op1->IsCnsNonZeroFltOrDbl() || (op1->isMemoryOp() && IsSafeToContainMem(tree, op1)))
+        {
+            // Since  GT_MUL is commutative, we will try to re-order operands if it is safe to
+            // generate more efficient code sequence for the case of GT_MUL(op1=memOp, op2=non-memOp)
+            MakeSrcContained(tree, op1);
+        }
+        else
+        {
+            // If there are no containable operands, we can make an operand reg optional.
+            SetRegOptionalForBinOp(tree);
+        }
+        return;
+    }
+
+    bool       isUnsignedMultiply    = ((tree->gtFlags & GTF_UNSIGNED) != 0);
+    bool       requiresOverflowCheck = tree->gtOverflowEx();
+    bool       useLeaEncoding        = false;
+    GenTreePtr memOp                 = nullptr;
+
+    bool                 hasImpliedFirstOperand = false;
+    GenTreeIntConCommon* imm                    = nullptr;
+    GenTreePtr           other                  = nullptr;
+
+    // There are three forms of x86 multiply:
+    // one-op form:     RDX:RAX = RAX * r/m
+    // two-op form:     reg *= r/m
+    // three-op form:   reg = r/m * imm
+
+    // This special widening 32x32->64 MUL is not used on x64
+    CLANG_FORMAT_COMMENT_ANCHOR;
+#if defined(_TARGET_X86_)
+    if (tree->OperGet() != GT_MUL_LONG)
+#endif
+    {
+        assert((tree->gtFlags & GTF_MUL_64RSLT) == 0);
+    }
+
+    // Multiply should never be using small types
+    assert(!varTypeIsSmall(tree->TypeGet()));
+
+    // We do use the widening multiply to implement
+    // the overflow checking for unsigned multiply
+    //
+    if (isUnsignedMultiply && requiresOverflowCheck)
+    {
+        // The only encoding provided is RDX:RAX = RAX * rm
+        //
+        // Here we set RAX as the only destination candidate
+        // In LSRA we set the kill set for this operation to RBM_RAX|RBM_RDX
+        //
+        info->setDstCandidates(m_lsra, RBM_RAX);
+        hasImpliedFirstOperand = true;
+    }
+    else if (tree->OperGet() == GT_MULHI)
+    {
+        // Have to use the encoding:RDX:RAX = RAX * rm. Since we only care about the
+        // upper 32 bits of the result set the destination candidate to REG_RDX.
+        info->setDstCandidates(m_lsra, RBM_RDX);
+        hasImpliedFirstOperand = true;
+    }
+#if defined(_TARGET_X86_)
+    else if (tree->OperGet() == GT_MUL_LONG)
+    {
+        // have to use the encoding:RDX:RAX = RAX * rm
+        info->setDstCandidates(m_lsra, RBM_RAX);
+        hasImpliedFirstOperand = true;
+    }
+#endif
+    else if (IsContainableImmed(tree, op2) || IsContainableImmed(tree, op1))
+    {
+        if (IsContainableImmed(tree, op2))
+        {
+            imm   = op2->AsIntConCommon();
+            other = op1;
+        }
+        else
+        {
+            imm   = op1->AsIntConCommon();
+            other = op2;
+        }
+
+        // CQ: We want to rewrite this into a LEA
+        ssize_t immVal = imm->AsIntConCommon()->IconValue();
+        if (!requiresOverflowCheck && (immVal == 3 || immVal == 5 || immVal == 9))
+        {
+            useLeaEncoding = true;
+        }
+
+        MakeSrcContained(tree, imm); // The imm is always contained
+        if (other->isMemoryOp())
+        {
+            memOp = other; // memOp may be contained below
+        }
+    }
+
+    // We allow one operand to be a contained memory operand.
+    // The memory op type must match with the 'tree' type.
+    // This is because during codegen we use 'tree' type to derive EmitTypeSize.
+    // E.g op1 type = byte, op2 type = byte but GT_MUL tree type is int.
+    //
+    if (memOp == nullptr && op2->isMemoryOp())
+    {
+        memOp = op2;
+    }
+
+    // To generate an LEA we need to force memOp into a register
+    // so don't allow memOp to be 'contained'
+    //
+    if (!useLeaEncoding)
+    {
+        if ((memOp != nullptr) && (memOp->TypeGet() == tree->TypeGet()) && IsSafeToContainMem(tree, memOp))
+        {
+            MakeSrcContained(tree, memOp);
+        }
+        else if (imm != nullptr)
+        {
+            // Has a contained immediate operand.
+            // Only 'other' operand can be marked as reg optional.
+            assert(other != nullptr);
+            SetRegOptional(other);
+        }
+        else if (hasImpliedFirstOperand)
+        {
+            // Only op2 can be marke as reg optional.
+            SetRegOptional(op2);
+        }
+        else
+        {
+            // If there are no containable operands, we can make either of op1 or op2
+            // as reg optional.
+            SetRegOptionalForBinOp(tree);
+        }
+    }
+}
+
+//------------------------------------------------------------------------------
+// SetContainsAVXFlags: Set ContainsAVX flag when it is floating type, set
+// Contains256bitAVX flag when SIMD vector size is 32 bytes
+//
+// Arguments:
+//    isFloatingPointType   - true if it is floating point type
+//    sizeOfSIMDVector      - SIMD Vector size
+//
+void Lowering::SetContainsAVXFlags(bool isFloatingPointType /* = true */, unsigned sizeOfSIMDVector /* = 0*/)
+{
+#ifdef FEATURE_AVX_SUPPORT
+    if (isFloatingPointType)
+    {
+        if (comp->getFloatingPointInstructionSet() == InstructionSet_AVX)
+        {
+            comp->getEmitter()->SetContainsAVX(true);
+        }
+        if (sizeOfSIMDVector == 32 && comp->getSIMDInstructionSet() == InstructionSet_AVX)
+        {
+            comp->getEmitter()->SetContains256bitAVX(true);
+        }
+    }
+#endif
+}
+
+#ifdef _TARGET_X86_
+//------------------------------------------------------------------------
+// ExcludeNonByteableRegisters: Determines if we need to exclude non-byteable registers for
+// various reasons
+//
+// Arguments:
+//    tree      - The node of interest
+//
+// Return Value:
+//    If we need to exclude non-byteable registers
+//
+bool Lowering::ExcludeNonByteableRegisters(GenTree* tree)
+{
+    // Example1: GT_STOREIND(byte, addr, op2) - storeind of byte sized value from op2 into mem 'addr'
+    // Storeind itself will not produce any value and hence dstCount=0. But op2 could be TYP_INT
+    // value. In this case we need to exclude esi/edi from the src candidates of op2.
+    if (varTypeIsByte(tree))
+    {
+        return true;
+    }
+    // Example2: GT_CAST(int <- bool <- int) - here type of GT_CAST node is int and castToType is bool.
+    else if ((tree->OperGet() == GT_CAST) && varTypeIsByte(tree->CastToType()))
+    {
+        return true;
+    }
+    else if (tree->OperIsCompare())
+    {
+        GenTree* op1 = tree->gtGetOp1();
+        GenTree* op2 = tree->gtGetOp2();
+
+        // Example3: GT_EQ(int, op1 of type ubyte, op2 of type ubyte) - in this case codegen uses
+        // ubyte as the result of comparison and if the result needs to be materialized into a reg
+        // simply zero extend it to TYP_INT size.  Here is an example of generated code:
+        //         cmp dl, byte ptr[addr mode]
+        //         movzx edx, dl
+        if (varTypeIsByte(op1) && varTypeIsByte(op2))
+        {
+            return true;
+        }
+        // Example4: GT_EQ(int, op1 of type ubyte, op2 is GT_CNS_INT) - in this case codegen uses
+        // ubyte as the result of the comparison and if the result needs to be materialized into a reg
+        // simply zero extend it to TYP_INT size.
+        else if (varTypeIsByte(op1) && op2->IsCnsIntOrI())
+        {
+            return true;
+        }
+        // Example4: GT_EQ(int, op1 is GT_CNS_INT, op2 of type ubyte) - in this case codegen uses
+        // ubyte as the result of the comparison and if the result needs to be materialized into a reg
+        // simply zero extend it to TYP_INT size.
+        else if (op1->IsCnsIntOrI() && varTypeIsByte(op2))
+        {
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+#ifdef FEATURE_SIMD
+    else if (tree->OperGet() == GT_SIMD)
+    {
+        GenTreeSIMD* simdNode = tree->AsSIMD();
+        switch (simdNode->gtSIMDIntrinsicID)
+        {
+            case SIMDIntrinsicOpEquality:
+            case SIMDIntrinsicOpInEquality:
+                // We manifest it into a byte register, so the target must be byteable.
+                return true;
+
+            case SIMDIntrinsicGetItem:
+            {
+                // This logic is duplicated from genSIMDIntrinsicGetItem().
+                // When we generate code for a SIMDIntrinsicGetItem, under certain circumstances we need to
+                // generate a movzx/movsx. On x86, these require byteable registers. So figure out which
+                // cases will require this, so the non-byteable registers can be excluded.
+
+                GenTree*  op1      = simdNode->gtGetOp1();
+                GenTree*  op2      = simdNode->gtGetOp2();
+                var_types baseType = simdNode->gtSIMDBaseType;
+                if (!op1->isMemoryOp() && op2->IsCnsIntOrI() && varTypeIsSmallInt(baseType))
+                {
+                    bool     ZeroOrSignExtnReqd = true;
+                    unsigned baseSize           = genTypeSize(baseType);
+                    if (baseSize == 1)
+                    {
+                        if ((op2->gtIntCon.gtIconVal % 2) == 1)
+                        {
+                            ZeroOrSignExtnReqd = (baseType == TYP_BYTE);
+                        }
+                    }
+                    else
+                    {
+                        assert(baseSize == 2);
+                        ZeroOrSignExtnReqd = (baseType == TYP_SHORT);
+                    }
+                    return ZeroOrSignExtnReqd;
+                }
+                break;
+            }
+
+            default:
+                break;
+        }
+        return false;
+    }
+#endif // FEATURE_SIMD
+    else
+    {
+        return false;
+    }
+}
+#endif // _TARGET_X86_
+
+#endif // _TARGET_XARCH_
+
+#endif // !LEGACY_BACKEND
diff --git a/src/jit/morph.cpp b/src/jit/morph.cpp
index 3a4d416022..1132d6ae39 100644
--- a/src/jit/morph.cpp
+++ b/src/jit/morph.cpp
@@ -855,9 +855,12 @@ fgArgInfo::fgArgInfo(Compiler* comp, GenTreePtr call, unsigned numArgs)
     compiler = comp;
     callTree = call;
     assert(call->IsCall());
-    argCount     = 0; // filled in arg count, starts at zero
-    nextSlotNum  = INIT_ARG_STACK_SLOT;
-    stkLevel     = 0;
+    argCount    = 0; // filled in arg count, starts at zero
+    nextSlotNum = INIT_ARG_STACK_SLOT;
+    stkLevel    = 0;
+#if defined(UNIX_X86_ABI)
+    padStkAlign = 0;
+#endif
     argTableSize = numArgs; // the allocated table size
 
     hasRegArgs   = false;
@@ -897,9 +900,12 @@ fgArgInfo::fgArgInfo(GenTreePtr newCall, GenTreePtr oldCall)
     ;
     callTree = newCall;
     assert(newCall->IsCall());
-    argCount     = 0; // filled in arg count, starts at zero
-    nextSlotNum  = INIT_ARG_STACK_SLOT;
-    stkLevel     = oldArgInfo->stkLevel;
+    argCount    = 0; // filled in arg count, starts at zero
+    nextSlotNum = INIT_ARG_STACK_SLOT;
+    stkLevel    = oldArgInfo->stkLevel;
+#if defined(UNIX_X86_ABI)
+    padStkAlign = oldArgInfo->padStkAlign;
+#endif
     argTableSize = oldArgInfo->argTableSize;
     argsComplete = false;
     argTable     = nullptr;
@@ -1079,16 +1085,19 @@ fgArgTabEntryPtr fgArgInfo::AddRegArg(
 {
     fgArgTabEntryPtr curArgTabEntry = new (compiler, CMK_fgArgInfo) fgArgTabEntry;
 
-    curArgTabEntry->argNum        = argNum;
-    curArgTabEntry->node          = node;
-    curArgTabEntry->parent        = parent;
-    curArgTabEntry->regNum        = regNum;
-    curArgTabEntry->slotNum       = 0;
-    curArgTabEntry->numRegs       = numRegs;
-    curArgTabEntry->numSlots      = 0;
-    curArgTabEntry->alignment     = alignment;
-    curArgTabEntry->lateArgInx    = (unsigned)-1;
-    curArgTabEntry->tmpNum        = (unsigned)-1;
+    curArgTabEntry->argNum     = argNum;
+    curArgTabEntry->node       = node;
+    curArgTabEntry->parent     = parent;
+    curArgTabEntry->regNum     = regNum;
+    curArgTabEntry->slotNum    = 0;
+    curArgTabEntry->numRegs    = numRegs;
+    curArgTabEntry->numSlots   = 0;
+    curArgTabEntry->alignment  = alignment;
+    curArgTabEntry->lateArgInx = (unsigned)-1;
+    curArgTabEntry->tmpNum     = (unsigned)-1;
+#if defined(UNIX_X86_ABI)
+    curArgTabEntry->padStkAlign = 0;
+#endif
     curArgTabEntry->isSplit       = false;
     curArgTabEntry->isTmp         = false;
     curArgTabEntry->needTmp       = false;
@@ -1154,16 +1163,19 @@ fgArgTabEntryPtr fgArgInfo::AddStkArg(unsigned   argNum,
     curArgTabEntry->isStruct = isStruct; // is this a struct arg
 #endif                                   // defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)
 
-    curArgTabEntry->argNum        = argNum;
-    curArgTabEntry->node          = node;
-    curArgTabEntry->parent        = parent;
-    curArgTabEntry->regNum        = REG_STK;
-    curArgTabEntry->slotNum       = nextSlotNum;
-    curArgTabEntry->numRegs       = 0;
-    curArgTabEntry->numSlots      = numSlots;
-    curArgTabEntry->alignment     = alignment;
-    curArgTabEntry->lateArgInx    = (unsigned)-1;
-    curArgTabEntry->tmpNum        = (unsigned)-1;
+    curArgTabEntry->argNum     = argNum;
+    curArgTabEntry->node       = node;
+    curArgTabEntry->parent     = parent;
+    curArgTabEntry->regNum     = REG_STK;
+    curArgTabEntry->slotNum    = nextSlotNum;
+    curArgTabEntry->numRegs    = 0;
+    curArgTabEntry->numSlots   = numSlots;
+    curArgTabEntry->alignment  = alignment;
+    curArgTabEntry->lateArgInx = (unsigned)-1;
+    curArgTabEntry->tmpNum     = (unsigned)-1;
+#if defined(UNIX_X86_ABI)
+    curArgTabEntry->padStkAlign = 0;
+#endif
     curArgTabEntry->isSplit       = false;
     curArgTabEntry->isTmp         = false;
     curArgTabEntry->needTmp       = false;
@@ -1689,6 +1701,52 @@ void fgArgInfo::ArgsComplete()
     argsComplete = true;
 }
 
+#if defined(UNIX_X86_ABI)
+//  Get the stack alignment value for a Call holding this object
+//
+//  NOTE: This function will calculate number of padding slots, to align the
+//  stack before pushing arguments to the stack. Padding value is stored in
+//  the first argument in fgArgTabEntry structure padStkAlign member so that
+//  code (sub esp, n) can be emitted before generating argument push in
+//  fgArgTabEntry node. As of result stack will be aligned right before
+//  making a "Call".  After the Call, stack is re-adjusted to the value it
+//  was with fgArgInfo->padStkAlign value as we cann't use the one in fgArgTabEntry.
+//
+void fgArgInfo::ArgsAlignPadding()
+{
+    // To get the padding amount, sum up all the slots and get the remainder for padding
+    unsigned         curInx;
+    unsigned         numSlots         = 0;
+    fgArgTabEntryPtr firstArgTabEntry = nullptr;
+
+    for (curInx = 0; curInx < argCount; curInx++)
+    {
+        fgArgTabEntryPtr curArgTabEntry = argTable[curInx];
+        if (curArgTabEntry->numSlots > 0)
+        {
+            // The argument may be REG_STK or constant or register that goes to stack
+            assert(nextSlotNum >= curArgTabEntry->slotNum);
+
+            numSlots += curArgTabEntry->numSlots;
+            if (firstArgTabEntry == nullptr)
+            {
+                // First argument will be used to hold the padding amount
+                firstArgTabEntry = curArgTabEntry;
+            }
+        }
+    }
+
+    if (firstArgTabEntry != nullptr)
+    {
+        const int numSlotsAligned = STACK_ALIGN / TARGET_POINTER_SIZE;
+        // Set stack align pad for the first argument
+        firstArgTabEntry->padStkAlign = AlignmentPad(numSlots, numSlotsAligned);
+        // Set also for fgArgInfo that will be used to reset stack pointer after the Call
+        this->padStkAlign = firstArgTabEntry->padStkAlign;
+    }
+}
+#endif // UNIX_X86_ABI
+
 void fgArgInfo::SortArgs()
 {
     assert(argsComplete == true);
@@ -2431,6 +2489,22 @@ void fgArgInfo::EvalArgsToTemps()
 #endif
 }
 
+// Get the late arg for arg at position argIndex.
+// argIndex - 0-based position to get late arg for.
+//            Caller must ensure this position has a late arg.
+GenTreePtr fgArgInfo::GetLateArg(unsigned argIndex)
+{
+    for (unsigned j = 0; j < this->ArgCount(); j++)
+    {
+        if (this->ArgTable()[j]->argNum == argIndex)
+        {
+            return this->ArgTable()[j]->node;
+        }
+    }
+    // Caller must ensure late arg exists.
+    unreached();
+}
+
 void fgArgInfo::RecordStkLevel(unsigned stkLvl)
 {
     assert(!IsUninitialized(stkLvl));
@@ -4211,6 +4285,11 @@ GenTreeCall* Compiler::fgMorphArgs(GenTreeCall* callNode)
     if (!reMorphing)
     {
         call->fgArgInfo->ArgsComplete();
+
+#if defined(UNIX_X86_ABI)
+        call->fgArgInfo->ArgsAlignPadding();
+#endif // UNIX_X86_ABI
+
 #ifdef LEGACY_BACKEND
         call->gtCallRegUsedMask = genIntAllRegArgMask(intArgRegNum);
 #if defined(_TARGET_ARM_)
@@ -6074,8 +6153,8 @@ GenTreePtr Compiler::fgMorphField(GenTreePtr tree, MorphAddrContext* mac)
     }
 
 #ifdef FEATURE_SIMD
-    // if this field belongs to simd struct, tranlate it to simd instrinsic.
-    if (mac == nullptr || mac->m_kind != MACK_Addr)
+    // if this field belongs to simd struct, translate it to simd instrinsic.
+    if (mac == nullptr)
     {
         GenTreePtr newTree = fgMorphFieldToSIMDIntrinsicGet(tree);
         if (newTree != tree)
@@ -6084,12 +6163,13 @@ GenTreePtr Compiler::fgMorphField(GenTreePtr tree, MorphAddrContext* mac)
             return newTree;
         }
     }
-    else if (objRef != nullptr && objRef->OperGet() == GT_ADDR && objRef->OperIsSIMD())
+    else if ((objRef != nullptr) && (objRef->OperGet() == GT_ADDR) && varTypeIsSIMD(objRef->gtGetOp1()))
     {
-        // We have a field of an SIMD intrinsic in an address-taken context.
-        // We need to copy the SIMD result to a temp, and take the field of that.
-        GenTree* copy      = fgCopySIMDNode(objRef->gtOp.gtOp1->AsSIMD());
-        objRef->gtOp.gtOp1 = copy;
+        GenTreeLclVarCommon* lcl = objRef->IsLocalAddrExpr();
+        if (lcl != nullptr)
+        {
+            lvaSetVarDoNotEnregister(lcl->gtLclNum DEBUGARG(DNER_LocalField));
+        }
     }
 #endif
 
@@ -6475,6 +6555,11 @@ GenTreePtr Compiler::fgMorphField(GenTreePtr tree, MorphAddrContext* mac)
                     addr->gtIntCon.gtFieldSeq = fieldSeq;
 
                     tree->SetOper(GT_IND);
+                    // The GTF_FLD_NULLCHECK is the same bit as GTF_IND_ARR_LEN.
+                    // We must clear it when we transform the node.
+                    // TODO-Cleanup: It appears that the GTF_FLD_NULLCHECK flag is never checked, and note
+                    // that the logic above does its own checking to determine whether a nullcheck is needed.
+                    tree->gtFlags &= ~GTF_IND_ARR_LEN;
                     tree->gtOp.gtOp1 = addr;
 
                     return fgMorphSmpOp(tree);
@@ -6514,6 +6599,11 @@ GenTreePtr Compiler::fgMorphField(GenTreePtr tree, MorphAddrContext* mac)
         }
     }
     noway_assert(tree->gtOper == GT_IND);
+    // The GTF_FLD_NULLCHECK is the same bit as GTF_IND_ARR_LEN.
+    // We must clear it when we transform the node.
+    // TODO-Cleanup: It appears that the GTF_FLD_NULLCHECK flag is never checked, and note
+    // that the logic above does its own checking to determine whether a nullcheck is needed.
+    tree->gtFlags &= ~GTF_IND_ARR_LEN;
 
     GenTreePtr res = fgMorphSmpOp(tree);
 
@@ -6653,8 +6743,10 @@ void Compiler::fgMorphCallInlineHelper(GenTreeCall* call, InlineResult* result)
         printTreeID(fgMorphStmt);
         printf(" in BB%02u:\n", compCurBB->bbNum);
         gtDispTree(fgMorphStmt);
-
-        // printf("startVars=%d.\n", startVars);
+        if (call->IsImplicitTailCall())
+        {
+            printf("Note: candidate is implicit tail call\n");
+        }
     }
 #endif
 
@@ -7800,14 +7892,15 @@ GenTreePtr Compiler::fgMorphCall(GenTreeCall* call)
             {
                 treeWithCall = stmtExpr->gtGetOp2();
             }
-            if (treeWithCall->gtOper == GT_CAST)
-            {
-                noway_assert(treeWithCall->gtGetOp1() == call && !treeWithCall->gtOverflow());
-            }
-            else
+
+            // Peel off casts
+            while (treeWithCall->gtOper == GT_CAST)
             {
-                noway_assert(treeWithCall == call);
+                noway_assert(!treeWithCall->gtOverflow());
+                treeWithCall = treeWithCall->gtGetOp1();
             }
+
+            noway_assert(treeWithCall == call);
         }
 #endif
 
@@ -8474,7 +8567,7 @@ GenTreePtr Compiler::fgMorphOneAsgBlockOp(GenTreePtr tree)
     // The SIMD type in question could be Vector2f which is 8-bytes in size.
     // The below check is to make sure that we don't turn that copyblk
     // into a assignment, since rationalizer logic will transform the
-    // copyblk apropriately. Otherwise, the transormation made in this
+    // copyblk appropriately. Otherwise, the transformation made in this
     // routine will prevent rationalizer logic and we might end up with
     // GT_ADDR(GT_SIMD) node post rationalization, leading to a noway assert
     // in codegen.
@@ -8502,6 +8595,12 @@ GenTreePtr Compiler::fgMorphOneAsgBlockOp(GenTreePtr tree)
     }
     else
     {
+        // Is this an enregisterable struct that is already a simple assignment?
+        // This can happen if we are re-morphing.
+        if ((dest->OperGet() == GT_IND) && (dest->TypeGet() != TYP_STRUCT) && isCopyBlock)
+        {
+            return tree;
+        }
         noway_assert(dest->OperIsLocal());
         lclVarTree = dest;
         destVarNum = lclVarTree->AsLclVarCommon()->gtLclNum;
@@ -9192,7 +9291,7 @@ GenTree* Compiler::fgMorphBlkNode(GenTreePtr tree, bool isDest)
         // Therefore, we insert a GT_ADDR just above the node, and wrap it in an obj or ind.
         // TODO-1stClassStructs: Consider whether this can be improved.
         // Also consider whether some of this can be included in gtNewBlockVal (though note
-        // that doing so may cause us to query the type system before we otherwise would.
+        // that doing so may cause us to query the type system before we otherwise would).
         GenTree* lastComma = nullptr;
         for (GenTree* next = tree; next != nullptr && next->gtOper == GT_COMMA; next = next->gtGetOp2())
         {
@@ -10230,31 +10329,46 @@ _Done:
 // FP architectures
 GenTree* Compiler::fgMorphForRegisterFP(GenTree* tree)
 {
-    GenTreePtr op1 = tree->gtOp.gtOp1;
-    GenTreePtr op2 = tree->gtGetOp2();
-
-    if (tree->OperIsArithmetic() && varTypeIsFloating(tree))
+    if (tree->OperIsArithmetic())
     {
-        if (op1->TypeGet() != tree->TypeGet())
+        if (varTypeIsFloating(tree))
         {
-            tree->gtOp.gtOp1 = gtNewCastNode(tree->TypeGet(), tree->gtOp.gtOp1, tree->TypeGet());
-        }
-        if (op2->TypeGet() != tree->TypeGet())
-        {
-            tree->gtOp.gtOp2 = gtNewCastNode(tree->TypeGet(), tree->gtOp.gtOp2, tree->TypeGet());
+            GenTreePtr op1 = tree->gtOp.gtOp1;
+            GenTreePtr op2 = tree->gtGetOp2();
+
+            if (op1->TypeGet() != tree->TypeGet())
+            {
+                tree->gtOp.gtOp1 = gtNewCastNode(tree->TypeGet(), op1, tree->TypeGet());
+            }
+            if (op2->TypeGet() != tree->TypeGet())
+            {
+                tree->gtOp.gtOp2 = gtNewCastNode(tree->TypeGet(), op2, tree->TypeGet());
+            }
         }
     }
-    else if (tree->OperIsCompare() && varTypeIsFloating(op1) && op1->TypeGet() != op2->TypeGet())
+    else if (tree->OperIsCompare())
     {
-        // both had better be floating, just one bigger than other
-        assert(varTypeIsFloating(op2));
-        if (op1->TypeGet() == TYP_FLOAT)
-        {
-            tree->gtOp.gtOp1 = gtNewCastNode(TYP_DOUBLE, tree->gtOp.gtOp1, TYP_DOUBLE);
-        }
-        else if (op2->TypeGet() == TYP_FLOAT)
+        GenTreePtr op1 = tree->gtOp.gtOp1;
+
+        if (varTypeIsFloating(op1))
         {
-            tree->gtOp.gtOp2 = gtNewCastNode(TYP_DOUBLE, tree->gtOp.gtOp2, TYP_DOUBLE);
+            GenTreePtr op2 = tree->gtGetOp2();
+            assert(varTypeIsFloating(op2));
+
+            if (op1->TypeGet() != op2->TypeGet())
+            {
+                // both had better be floating, just one bigger than other
+                if (op1->TypeGet() == TYP_FLOAT)
+                {
+                    assert(op2->TypeGet() == TYP_DOUBLE);
+                    tree->gtOp.gtOp1 = gtNewCastNode(TYP_DOUBLE, op1, TYP_DOUBLE);
+                }
+                else if (op2->TypeGet() == TYP_FLOAT)
+                {
+                    assert(op1->TypeGet() == TYP_DOUBLE);
+                    tree->gtOp.gtOp2 = gtNewCastNode(TYP_DOUBLE, op2, TYP_DOUBLE);
+                }
+            }
         }
     }
 
@@ -10330,50 +10444,6 @@ GenTree* Compiler::fgMorphRecognizeBoxNullable(GenTree* compare)
 
 #ifdef FEATURE_SIMD
 
-//--------------------------------------------------------------------------------------
-// fgCopySIMDNode: make a copy of a SIMD intrinsic node, e.g. so that a field can be accessed.
-//
-// Arguments:
-//    simdNode  - The GenTreeSIMD node to be copied
-//
-// Return Value:
-//    A comma node where op1 is the assignment of the simd node to a temp, and op2 is the temp lclVar.
-//
-GenTree* Compiler::fgCopySIMDNode(GenTreeSIMD* simdNode)
-{
-    // Copy the result of the SIMD intrinsic into a temp.
-    unsigned lclNum = lvaGrabTemp(true DEBUGARG("Copy of SIMD intrinsic with field access"));
-
-    CORINFO_CLASS_HANDLE simdHandle = NO_CLASS_HANDLE;
-    // We only have fields of the fixed float vectors.
-    noway_assert(simdNode->gtSIMDBaseType == TYP_FLOAT);
-    switch (simdNode->gtSIMDSize)
-    {
-        case 8:
-            simdHandle = SIMDVector2Handle;
-            break;
-        case 12:
-            simdHandle = SIMDVector3Handle;
-            break;
-        case 16:
-            simdHandle = SIMDVector4Handle;
-            break;
-        default:
-            noway_assert(!"field of unexpected SIMD type");
-            break;
-    }
-    assert(simdHandle != NO_CLASS_HANDLE);
-
-    lvaSetStruct(lclNum, simdHandle, false, true);
-    lvaTable[lclNum].lvFieldAccessed = true;
-
-    GenTree* asg           = gtNewTempAssign(lclNum, simdNode);
-    GenTree* newLclVarNode = new (this, GT_LCL_VAR) GenTreeLclVar(simdNode->TypeGet(), lclNum, BAD_IL_OFFSET);
-
-    GenTree* comma = gtNewOperNode(GT_COMMA, simdNode->TypeGet(), asg, newLclVarNode);
-    return comma;
-}
-
 //--------------------------------------------------------------------------------------------------------------
 // getSIMDStructFromField:
 //   Checking whether the field belongs to a simd struct or not. If it is, return the GenTreePtr for
@@ -10456,12 +10526,12 @@ GenTreePtr Compiler::getSIMDStructFromField(GenTreePtr tree,
 }
 
 /*****************************************************************************
-*  If a read operation tries to access simd struct field, then transform the this
-*  operation to to the SIMD intrinsic SIMDIntrinsicGetItem, and return the new tree.
+*  If a read operation tries to access simd struct field, then transform the
+*  operation to the SIMD intrinsic SIMDIntrinsicGetItem, and return the new tree.
 *  Otherwise, return the old tree.
 *  Argument:
 *   tree - GenTreePtr. If this pointer points to simd struct which is used for simd
-*          intrinsic. We will morph it as simd intrinsic SIMDIntrinsicGetItem.
+*          intrinsic, we will morph it as simd intrinsic SIMDIntrinsicGetItem.
 *  Return:
 *   A GenTreePtr which points to the new tree. If the tree is not for simd intrinsic,
 *   return nullptr.
@@ -10475,7 +10545,6 @@ GenTreePtr Compiler::fgMorphFieldToSIMDIntrinsicGet(GenTreePtr tree)
     GenTreePtr simdStructNode = getSIMDStructFromField(tree, &baseType, &index, &simdSize);
     if (simdStructNode != nullptr)
     {
-
         assert(simdSize >= ((index + 1) * genTypeSize(baseType)));
         GenTree* op2 = gtNewIconNode(index);
         tree         = gtNewSIMDNode(baseType, simdStructNode, op2, SIMDIntrinsicGetItem, baseType, simdSize);
@@ -10488,11 +10557,11 @@ GenTreePtr Compiler::fgMorphFieldToSIMDIntrinsicGet(GenTreePtr tree)
 
 /*****************************************************************************
 *  Transform an assignment of a SIMD struct field to SIMD intrinsic
-*  SIMDIntrinsicGetItem, and return a new tree. If If it is not such an assignment,
+*  SIMDIntrinsicSet*, and return a new tree. If it is not such an assignment,
 *  then return the old tree.
 *  Argument:
 *   tree - GenTreePtr. If this pointer points to simd struct which is used for simd
-*          intrinsic. We will morph it as simd intrinsic set.
+*          intrinsic, we will morph it as simd intrinsic set.
 *  Return:
 *   A GenTreePtr which points to the new tree. If the tree is not for simd intrinsic,
 *   return nullptr.
@@ -10545,7 +10614,8 @@ GenTreePtr Compiler::fgMorphFieldAssignToSIMDIntrinsicSet(GenTreePtr tree)
     return tree;
 }
 
-#endif
+#endif // FEATURE_SIMD
+
 /*****************************************************************************
  *
  *  Transform the given GTK_SMPOP tree for code generation.
@@ -10591,7 +10661,7 @@ GenTreePtr Compiler::fgMorphSmpOp(GenTreePtr tree, MorphAddrContext* mac)
         genTreeOps oper = tree->OperGet();
         var_types  typ  = tree->TypeGet();
         GenTreePtr op1  = tree->gtOp.gtOp1;
-        GenTreePtr op2  = tree->gtGetOp2();
+        GenTreePtr op2  = tree->gtGetOp2IfPresent();
 
         /*-------------------------------------------------------------------------
          * First do any PRE-ORDER processing
@@ -11216,7 +11286,7 @@ GenTreePtr Compiler::fgMorphSmpOp(GenTreePtr tree, MorphAddrContext* mac)
                 }
                 fgMorphRecognizeBoxNullable(tree);
                 op1 = tree->gtOp.gtOp1;
-                op2 = tree->gtGetOp2();
+                op2 = tree->gtGetOp2IfPresent();
 
                 break;
 
@@ -11307,12 +11377,6 @@ GenTreePtr Compiler::fgMorphSmpOp(GenTreePtr tree, MorphAddrContext* mac)
                         // comma list.  The left arg (op1) gets a fresh context.
                         subMac1 = nullptr;
                         break;
-                    case GT_ASG:
-                        if (tree->OperIsBlkOp())
-                        {
-                            subMac1 = &subIndMac1;
-                        }
-                        break;
                     case GT_OBJ:
                     case GT_BLK:
                     case GT_DYN_BLK:
@@ -11450,12 +11514,6 @@ GenTreePtr Compiler::fgMorphSmpOp(GenTreePtr tree, MorphAddrContext* mac)
                         }
                     }
                     break;
-                case GT_ASG:
-                    if (tree->OperIsBlkOp())
-                    {
-                        mac = &subIndMac2;
-                    }
-                    break;
                 default:
                     break;
             }
@@ -11621,7 +11679,7 @@ GenTreePtr Compiler::fgMorphSmpOp(GenTreePtr tree, MorphAddrContext* mac)
 
         /* gtFoldExpr could have changed op1 and op2 */
         op1 = tree->gtOp.gtOp1;
-        op2 = tree->gtGetOp2();
+        op2 = tree->gtGetOp2IfPresent();
 
         // Do we have an integer compare operation?
         //
@@ -13518,12 +13576,10 @@ GenTree* Compiler::fgMorphSmpOpOptional(GenTreeOp* tree)
             /*     and also  "a = x <op> a" into "a <op>= x" for communative ops */
             CLANG_FORMAT_COMMENT_ANCHOR;
 
-#if !LONG_ASG_OPS
             if (typ == TYP_LONG)
             {
                 break;
             }
-#endif
 
             if (varTypeIsStruct(typ) && !tree->IsPhiDefn())
             {
@@ -13679,25 +13735,9 @@ GenTree* Compiler::fgMorphSmpOpOptional(GenTreeOp* tree)
                 case GT_LSH:
                 case GT_RSH:
                 case GT_RSZ:
-
-#if LONG_ASG_OPS
-
-                    if (typ == TYP_LONG)
-                        break;
-#endif
-
                 case GT_OR:
                 case GT_XOR:
                 case GT_AND:
-
-#if LONG_ASG_OPS
-
-                    /* TODO: allow non-const long assignment operators */
-
-                    if (typ == TYP_LONG && op2->gtOp.gtOp2->gtOper != GT_CNS_LNG)
-                        break;
-#endif
-
                 ASG_OP:
                 {
                     bool bReverse       = false;
@@ -14355,7 +14395,7 @@ GenTreePtr Compiler::fgMorphToEmulatedFP(GenTreePtr tree)
     genTreeOps oper = tree->OperGet();
     var_types  typ  = tree->TypeGet();
     GenTreePtr op1  = tree->gtOp.gtOp1;
-    GenTreePtr op2  = tree->gtGetOp2();
+    GenTreePtr op2  = tree->gtGetOp2IfPresent();
 
     /*
         We have to use helper calls for all FP operations:
@@ -15992,7 +16032,6 @@ void Compiler::fgMorphBlocks()
                     // genReturnLocal
                     noway_assert(ret->OperGet() == GT_RETURN);
                     noway_assert(ret->gtGetOp1() != nullptr);
-                    noway_assert(ret->gtGetOp2() == nullptr);
 
                     GenTreePtr tree = gtNewTempAssign(genReturnLocal, ret->gtGetOp1());
 
@@ -16011,7 +16050,6 @@ void Compiler::fgMorphBlocks()
                     // Must be a void GT_RETURN with null operand; delete it as this block branches to oneReturn block
                     noway_assert(ret->TypeGet() == TYP_VOID);
                     noway_assert(ret->gtGetOp1() == nullptr);
-                    noway_assert(ret->gtGetOp2() == nullptr);
 
                     fgRemoveStmt(block, last);
                 }
@@ -16917,8 +16955,10 @@ void Compiler::fgMorph()
     fgDebugCheckBBlist(false, false);
 #endif // DEBUG
 
-// RemoveEmptyFinally is disabled on ARM due to github issue #9013
-#ifndef _TARGET_ARM_
+    fgRemoveEmptyTry();
+
+    EndPhase(PHASE_EMPTY_TRY);
+
     fgRemoveEmptyFinally();
 
     EndPhase(PHASE_EMPTY_FINALLY);
@@ -16926,7 +16966,8 @@ void Compiler::fgMorph()
     fgCloneFinally();
 
     EndPhase(PHASE_CLONE_FINALLY);
-#endif // _TARGET_ARM_
+
+    fgUpdateFinallyTargetFlags();
 
     /* For x64 and ARM64 we need to mark irregular parameters early so that they don't get promoted */
     fgMarkImplicitByRefArgs();
@@ -17033,6 +17074,14 @@ void Compiler::fgPromoteStructs()
         return;
     }
 
+#ifdef DEBUG
+    if (verbose)
+    {
+        printf("\nlvaTable before fgPromoteStructs\n");
+        lvaTableDump();
+    }
+#endif // DEBUG
+
     // The lvaTable might grow as we grab temps. Make a local copy here.
 
     unsigned startLvaCount = lvaCount;
@@ -17050,17 +17099,13 @@ void Compiler::fgPromoteStructs()
         bool       promotedVar = false;
         LclVarDsc* varDsc      = &lvaTable[lclNum];
 
-#ifdef FEATURE_SIMD
-        if (varDsc->lvSIMDType && varDsc->lvUsedInSIMDIntrinsic)
+        if (varDsc->lvIsSIMDType() && varDsc->lvIsUsedInSIMDIntrinsic())
         {
             // If we have marked this as lvUsedInSIMDIntrinsic, then we do not want to promote
             // its fields.  Instead, we will attempt to enregister the entire struct.
             varDsc->lvRegStruct = true;
         }
-        else
-#endif // FEATURE_SIMD
-            // Don't promote if we have reached the tracking limit.
-            if (lvaHaveManyLocals())
+        else if (lvaHaveManyLocals()) // Don't promote if we have reached the tracking limit.
         {
             // Print the message first time when we detected this condition
             if (!tooManyLocals)
@@ -17091,7 +17136,6 @@ void Compiler::fgPromoteStructs()
 
             if (canPromote)
             {
-
                 // We *can* promote; *should* we promote?
                 // We should only do so if promotion has potential savings.  One source of savings
                 // is if a field of the struct is accessed, since this access will be turned into
@@ -17099,9 +17143,17 @@ void Compiler::fgPromoteStructs()
                 // field accesses, but only block-level operations on the whole struct, if the struct
                 // has only one or two fields, then doing those block operations field-wise is probably faster
                 // than doing a whole-variable block operation (e.g., a hardware "copy loop" on x86).
-                // So if no fields are accessed independently, and there are three or more fields,
+                // Struct promotion also provides the following benefits: reduce stack frame size,
+                // reduce the need for zero init of stack frame and fine grained constant/copy prop.
+                // Asm diffs indicate that promoting structs up to 3 fields is a net size win.
+                // So if no fields are accessed independently, and there are four or more fields,
                 // then do not promote.
-                if (structPromotionInfo.fieldCnt > 2 && !varDsc->lvFieldAccessed)
+                //
+                // TODO: Ideally we would want to consider the impact of whether the struct is
+                // passed as a parameter or assigned the return value of a call. Because once promoted,
+                // struct copying is done by field by field assignment instead of a more efficient
+                // rep.stos or xmm reg based copy.
+                if (structPromotionInfo.fieldCnt > 3 && !varDsc->lvFieldAccessed)
                 {
                     JITDUMP("Not promoting promotable struct local V%02u: #fields = %d, fieldAccessed = %d.\n", lclNum,
                             structPromotionInfo.fieldCnt, varDsc->lvFieldAccessed);
@@ -17216,6 +17268,14 @@ void Compiler::fgPromoteStructs()
         }
 #endif // FEATURE_SIMD
     }
+
+#ifdef DEBUG
+    if (verbose)
+    {
+        printf("\nlvaTable after fgPromoteStructs\n");
+        lvaTableDump();
+    }
+#endif // DEBUG
 }
 
 Compiler::fgWalkResult Compiler::fgMorphStructField(GenTreePtr tree, fgWalkData* fgWalkPre)
diff --git a/src/jit/optcse.cpp b/src/jit/optcse.cpp
index 3ff4cea385..5ee6d84920 100644
--- a/src/jit/optcse.cpp
+++ b/src/jit/optcse.cpp
@@ -996,6 +996,17 @@ void Compiler::optValnumCSE_Availablity()
 
                         /* This is a CSE def */
 
+                        if (desc->csdDefCount == 0)
+                        {
+                            // This is the first def visited, so copy its conservative VN
+                            desc->defConservativeVN = tree->gtVNPair.GetConservative();
+                        }
+                        else if (tree->gtVNPair.GetConservative() != desc->defConservativeVN)
+                        {
+                            // This candidate has defs with differing conservative VNs
+                            desc->defConservativeVN = ValueNumStore::NoVN;
+                        }
+
                         desc->csdDefCount += 1;
                         desc->csdDefWtCnt += stmw;
 
@@ -1778,6 +1789,8 @@ public:
         m_addCSEcount++; // Record that we created a new LclVar for use as a CSE temp
         m_pCompiler->optCSEcount++;
 
+        ValueNum defConservativeVN = successfulCandidate->CseDsc()->defConservativeVN;
+
         /*  Walk all references to this CSE, adding an assignment
             to the CSE temp to all defs and changing all refs to
             a simple use of the CSE temp.
@@ -1890,6 +1903,13 @@ public:
                 //
                 cse           = m_pCompiler->gtNewLclvNode(cseLclVarNum, cseLclVarTyp);
                 cse->gtVNPair = exp->gtVNPair; // assign the proper Value Numbers
+                if (defConservativeVN != ValueNumStore::NoVN)
+                {
+                    // All defs of this CSE share the same conservative VN, and we are rewriting this
+                    // use to fetch the same value with no reload, so we can safely propagate that
+                    // conservative VN to this use.  This can help range check elimination later on.
+                    cse->gtVNPair.SetConservative(defConservativeVN);
+                }
 #ifdef DEBUG
                 cse->gtDebugFlags |= GTF_DEBUG_VAR_CSE_REF;
 #endif // DEBUG
diff --git a/src/jit/optimizer.cpp b/src/jit/optimizer.cpp
index 32ff4d3139..92edf62890 100644
--- a/src/jit/optimizer.cpp
+++ b/src/jit/optimizer.cpp
@@ -1193,7 +1193,10 @@ void Compiler::optRecordLoop(BasicBlock*   head,
     optLoopTable[loopInd].lpFlags = 0;
 
     // We haven't yet recorded any side effects.
-    optLoopTable[loopInd].lpLoopHasHeapHavoc       = false;
+    for (MemoryKind memoryKind : allMemoryKinds())
+    {
+        optLoopTable[loopInd].lpLoopHasMemoryHavoc[memoryKind] = false;
+    }
     optLoopTable[loopInd].lpFieldsModified         = nullptr;
     optLoopTable[loopInd].lpArrayElemTypesModified = nullptr;
 
@@ -6397,7 +6400,7 @@ bool Compiler::optVNIsLoopInvariant(ValueNum vn, unsigned lnum, VNToBoolMap* loo
                 res                  = !optLoopContains(lnum, ssaDef->m_defLoc.m_blk->bbNatLoopNum);
             }
         }
-        else if (funcApp.m_func == VNF_PhiHeapDef)
+        else if (funcApp.m_func == VNF_PhiMemoryDef)
         {
             BasicBlock* defnBlk = reinterpret_cast<BasicBlock*>(vnStore->ConstantValue<ssize_t>(funcApp.m_args[0]));
             res                 = !optLoopContains(lnum, defnBlk->bbNatLoopNum);
@@ -6837,7 +6840,8 @@ void Compiler::optComputeLoopSideEffectsOfBlock(BasicBlock* blk)
 
     AddVariableLivenessAllContainingLoops(mostNestedLoop, blk);
 
-    bool heapHavoc = false; // True ==> there's a call or a memory store that has arbitrary heap effects.
+    // MemoryKinds for which an in-loop call or store has arbitrary effects.
+    MemoryKindSet memoryHavoc = emptyMemoryKindSet;
 
     // Now iterate over the remaining statements, and their trees.
     for (GenTreePtr stmts = blk->FirstNonPhiDef(); (stmts != nullptr); stmts = stmts->gtNext)
@@ -6846,8 +6850,8 @@ void Compiler::optComputeLoopSideEffectsOfBlock(BasicBlock* blk)
         {
             genTreeOps oper = tree->OperGet();
 
-            // Even after we set heapHavoc we still may want to know if a loop contains calls
-            if (heapHavoc)
+            // Even after we set memoryHavoc we still may want to know if a loop contains calls
+            if (memoryHavoc == fullMemoryKindSet)
             {
                 if (oper == GT_CALL)
                 {
@@ -6858,18 +6862,18 @@ void Compiler::optComputeLoopSideEffectsOfBlock(BasicBlock* blk)
                 // If we just set lpContainsCall or it was previously set
                 if (optLoopTable[mostNestedLoop].lpContainsCall)
                 {
-                    // We can early exit after both heapHavoc and lpContainsCall are both set to true.
+                    // We can early exit after both memoryHavoc and lpContainsCall are both set to true.
                     break;
                 }
 
-                // We are just looking for GT_CALL nodes after heapHavoc was set.
+                // We are just looking for GT_CALL nodes after memoryHavoc was set.
                 continue;
             }
 
-            // otherwise heapHavoc is not set
-            assert(!heapHavoc);
+            // otherwise memoryHavoc is not set for at least one heap ID
+            assert(memoryHavoc != fullMemoryKindSet);
 
-            // This body is a distillation of the heap-side effect code of value numbering.
+            // This body is a distillation of the memory side-effect code of value numbering.
             // We also do a very limited analysis if byref PtrTo values, to cover some cases
             // that the compiler creates.
 
@@ -6884,7 +6888,7 @@ void Compiler::optComputeLoopSideEffectsOfBlock(BasicBlock* blk)
 
                     if ((tree->gtFlags & GTF_IND_VOLATILE) != 0)
                     {
-                        heapHavoc = true;
+                        memoryHavoc |= memoryKindSet(GcHeap, ByrefExposed);
                         continue;
                     }
 
@@ -6906,12 +6910,14 @@ void Compiler::optComputeLoopSideEffectsOfBlock(BasicBlock* blk)
                                 CORINFO_CLASS_HANDLE elemType =
                                     CORINFO_CLASS_HANDLE(vnStore->ConstantValue<size_t>(funcApp.m_args[0]));
                                 AddModifiedElemTypeAllContainingLoops(mostNestedLoop, elemType);
-                                // Don't set heapHavoc below.
+                                // Don't set memoryHavoc for GcHeap below.  Do set memoryHavoc for ByrefExposed
+                                // (conservatively assuming that a byref may alias the array element)
+                                memoryHavoc |= memoryKindSet(ByrefExposed);
                                 continue;
                             }
                         }
                         // Otherwise...
-                        heapHavoc = true;
+                        memoryHavoc |= memoryKindSet(GcHeap, ByrefExposed);
                     }
                     // Is the LHS an array index expression?
                     else if (lhs->ParseArrayElemForm(this, &arrInfo, &fldSeqArrElem))
@@ -6920,6 +6926,8 @@ void Compiler::optComputeLoopSideEffectsOfBlock(BasicBlock* blk)
                         // field of "S", will lose all information about the array type.
                         CORINFO_CLASS_HANDLE elemTypeEq = EncodeElemType(arrInfo.m_elemType, arrInfo.m_elemStructType);
                         AddModifiedElemTypeAllContainingLoops(mostNestedLoop, elemTypeEq);
+                        // Conservatively assume byrefs may alias this array element
+                        memoryHavoc |= memoryKindSet(ByrefExposed);
                     }
                     else
                     {
@@ -6932,7 +6940,7 @@ void Compiler::optComputeLoopSideEffectsOfBlock(BasicBlock* blk)
                         if (arg->IsFieldAddr(this, &obj, &staticOffset, &fldSeq) &&
                             (fldSeq != FieldSeqStore::NotAField()))
                         {
-                            // Get the first (object) field from field seq.  Heap[field] will yield the "field map".
+                            // Get the first (object) field from field seq.  GcHeap[field] will yield the "field map".
                             assert(fldSeq != nullptr);
                             if (fldSeq->IsFirstElemFieldSeq())
                             {
@@ -6941,10 +6949,12 @@ void Compiler::optComputeLoopSideEffectsOfBlock(BasicBlock* blk)
                             }
 
                             AddModifiedFieldAllContainingLoops(mostNestedLoop, fldSeq->m_fieldHnd);
+                            // Conservatively assume byrefs may alias this object.
+                            memoryHavoc |= memoryKindSet(ByrefExposed);
                         }
                         else
                         {
-                            heapHavoc = true;
+                            memoryHavoc |= memoryKindSet(GcHeap, ByrefExposed);
                         }
                     }
                 }
@@ -6954,13 +6964,19 @@ void Compiler::optComputeLoopSideEffectsOfBlock(BasicBlock* blk)
                     bool                 isEntire;
                     if (!tree->DefinesLocal(this, &lclVarTree, &isEntire))
                     {
-                        // For now, assume arbitrary side effects on the heap...
-                        heapHavoc = true;
+                        // For now, assume arbitrary side effects on GcHeap/ByrefExposed...
+                        memoryHavoc |= memoryKindSet(GcHeap, ByrefExposed);
+                    }
+                    else if (lvaVarAddrExposed(lclVarTree->gtLclNum))
+                    {
+                        memoryHavoc |= memoryKindSet(ByrefExposed);
                     }
                 }
                 else if (lhs->OperGet() == GT_CLS_VAR)
                 {
                     AddModifiedFieldAllContainingLoops(mostNestedLoop, lhs->gtClsVar.gtClsVarHnd);
+                    // Conservatively assume byrefs may alias this static field
+                    memoryHavoc |= memoryKindSet(ByrefExposed);
                 }
                 // Otherwise, must be local lhs form.  I should assert that.
                 else if (lhs->OperGet() == GT_LCL_VAR)
@@ -6979,6 +6995,11 @@ void Compiler::optComputeLoopSideEffectsOfBlock(BasicBlock* blk)
                                 ->m_vnPair.SetLiberal(rhsVN);
                         }
                     }
+                    // If the local is address-exposed, count this as ByrefExposed havoc
+                    if (lvaVarAddrExposed(lhsLcl->gtLclNum))
+                    {
+                        memoryHavoc |= memoryKindSet(ByrefExposed);
+                    }
                 }
             }
             else // not GenTree::OperIsAssignment(oper)
@@ -7019,7 +7040,7 @@ void Compiler::optComputeLoopSideEffectsOfBlock(BasicBlock* blk)
                     case GT_XCHG:    // Binop
                     case GT_CMPXCHG: // Specialop
                     {
-                        heapHavoc = true;
+                        memoryHavoc |= memoryKindSet(GcHeap, ByrefExposed);
                     }
                     break;
 
@@ -7035,7 +7056,7 @@ void Compiler::optComputeLoopSideEffectsOfBlock(BasicBlock* blk)
                             CorInfoHelpFunc helpFunc = eeGetHelperNum(call->gtCallMethHnd);
                             if (s_helperCallProperties.MutatesHeap(helpFunc))
                             {
-                                heapHavoc = true;
+                                memoryHavoc |= memoryKindSet(GcHeap, ByrefExposed);
                             }
                             else if (s_helperCallProperties.MayRunCctor(helpFunc))
                             {
@@ -7045,33 +7066,39 @@ void Compiler::optComputeLoopSideEffectsOfBlock(BasicBlock* blk)
                                 // and might have arbitrary side effects.
                                 if ((tree->gtFlags & GTF_CALL_HOISTABLE) == 0)
                                 {
-                                    heapHavoc = true;
+                                    memoryHavoc |= memoryKindSet(GcHeap, ByrefExposed);
                                 }
                             }
                         }
                         else
                         {
-                            heapHavoc = true;
+                            memoryHavoc |= memoryKindSet(GcHeap, ByrefExposed);
                         }
                         break;
                     }
 
                     default:
-                        // All other gtOper node kinds, leave 'heapHavoc' unchanged (i.e. false)
+                        // All other gtOper node kinds, leave 'memoryHavoc' unchanged (i.e. false)
                         break;
                 }
             }
         }
     }
 
-    if (heapHavoc)
+    if (memoryHavoc != emptyMemoryKindSet)
     {
-        // Record that all loops containing this block have heap havoc effects.
+        // Record that all loops containing this block have memory havoc effects.
         unsigned lnum = mostNestedLoop;
         while (lnum != BasicBlock::NOT_IN_LOOP)
         {
-            optLoopTable[lnum].lpLoopHasHeapHavoc = true;
-            lnum                                  = optLoopTable[lnum].lpParent;
+            for (MemoryKind memoryKind : allMemoryKinds())
+            {
+                if ((memoryHavoc & memoryKindSet(memoryKind)) != 0)
+                {
+                    optLoopTable[lnum].lpLoopHasMemoryHavoc[memoryKind] = true;
+                }
+            }
+            lnum = optLoopTable[lnum].lpParent;
         }
     }
 }
@@ -7426,57 +7453,6 @@ GenTreePtr Compiler::optFindLocalInit(BasicBlock* block,
     return rhs;
 }
 
-/*****************************************************************************
- *
- *  Return true if "op1" is guaranteed to be less then or equal to "op2".
- */
-
-#if FANCY_ARRAY_OPT
-
-bool Compiler::optIsNoMore(GenTreePtr op1, GenTreePtr op2, int add1, int add2)
-{
-    if (op1->gtOper == GT_CNS_INT && op2->gtOper == GT_CNS_INT)
-    {
-        add1 += op1->gtIntCon.gtIconVal;
-        add2 += op2->gtIntCon.gtIconVal;
-    }
-    else
-    {
-        /* Check for +/- constant on either operand */
-
-        if (op1->gtOper == GT_ADD && op1->gtOp.gtOp2->gtOper == GT_CNS_INT)
-        {
-            add1 += op1->gtOp.gtOp2->gtIntCon.gtIconVal;
-            op1 = op1->gtOp.gtOp1;
-        }
-
-        if (op2->gtOper == GT_ADD && op2->gtOp.gtOp2->gtOper == GT_CNS_INT)
-        {
-            add2 += op2->gtOp.gtOp2->gtIntCon.gtIconVal;
-            op2 = op2->gtOp.gtOp1;
-        }
-
-        /* We only allow local variable references */
-
-        if (op1->gtOper != GT_LCL_VAR)
-            return false;
-        if (op2->gtOper != GT_LCL_VAR)
-            return false;
-        if (op1->gtLclVarCommon.gtLclNum != op2->gtLclVarCommon.gtLclNum)
-            return false;
-
-        /* NOTE: Caller ensures that this variable has only one def */
-
-        // printf("limit [%d]:\n", add1); gtDispTree(op1);
-        // printf("size  [%d]:\n", add2); gtDispTree(op2);
-        // printf("\n");
-    }
-
-    return (bool)(add1 <= add2);
-}
-
-#endif
-
 //------------------------------------------------------------------------------
 // optObtainLoopCloningOpts: Identify optimization candidates and update
 //      the "context" for array optimizations.
diff --git a/src/jit/rationalize.cpp b/src/jit/rationalize.cpp
index c648ab2677..00e0bec6f7 100644
--- a/src/jit/rationalize.cpp
+++ b/src/jit/rationalize.cpp
@@ -913,7 +913,7 @@ Compiler::fgWalkResult Rationalizer::RewriteNode(GenTree** useEdge, ArrayStack<G
                     op1->gtType = simdType;
                 }
 
-                GenTree* op2 = simdNode->gtGetOp2();
+                GenTree* op2 = simdNode->gtGetOp2IfPresent();
                 if (op2 != nullptr && op2->gtType == TYP_STRUCT)
                 {
                     op2->gtType = simdType;
diff --git a/src/jit/regalloc.cpp b/src/jit/regalloc.cpp
index 8a7ad5a163..5c3895b4f2 100644
--- a/src/jit/regalloc.cpp
+++ b/src/jit/regalloc.cpp
@@ -1724,7 +1724,7 @@ regMaskTP Compiler::rpPredictBlkAsgRegUse(GenTreePtr   tree,
     bool        useBarriers   = false;
     GenTreeBlk* dst           = tree->gtGetOp1()->AsBlk();
     GenTreePtr  dstAddr       = dst->Addr();
-    GenTreePtr  srcAddrOrFill = tree->gtGetOp2();
+    GenTreePtr  srcAddrOrFill = tree->gtGetOp2IfPresent();
 
     size_t blkSize = dst->gtBlkSize;
 
@@ -2478,7 +2478,7 @@ regMaskTP Compiler::rpPredictTreeRegUse(GenTreePtr   tree,
     if (kind & GTK_SMPOP)
     {
         GenTreePtr op1 = tree->gtOp.gtOp1;
-        GenTreePtr op2 = tree->gtGetOp2();
+        GenTreePtr op2 = tree->gtGetOp2IfPresent();
 
         GenTreePtr opsPtr[3];
         regMaskTP  regsPtr[3];
diff --git a/src/jit/registerfp.cpp b/src/jit/registerfp.cpp
index 3a3143e629..ed71886cae 100644
--- a/src/jit/registerfp.cpp
+++ b/src/jit/registerfp.cpp
@@ -243,7 +243,7 @@ void CodeGen::genFloatSimple(GenTree* tree, RegSet::RegisterPreference* pref)
         case GT_COMMA:
         {
             GenTreePtr op1 = tree->gtOp.gtOp1;
-            GenTreePtr op2 = tree->gtGetOp2();
+            GenTreePtr op2 = tree->gtGetOp2IfPresent();
 
             if (tree->gtFlags & GTF_REVERSE_OPS)
             {
@@ -318,7 +318,7 @@ void CodeGen::genFloatAssign(GenTree* tree)
 {
     var_types  type = tree->TypeGet();
     GenTreePtr op1  = tree->gtGetOp1();
-    GenTreePtr op2  = tree->gtGetOp2();
+    GenTreePtr op2  = tree->gtGetOp2IfPresent();
 
     regMaskTP needRegOp1 = RBM_ALLINT;
     regMaskTP addrReg    = RBM_NONE;
@@ -846,7 +846,7 @@ void CodeGen::genFloatArith(GenTreePtr tree, RegSet::RegisterPreference* tgtPref
     var_types  type = tree->TypeGet();
     genTreeOps oper = tree->OperGet();
     GenTreePtr op1  = tree->gtGetOp1();
-    GenTreePtr op2  = tree->gtGetOp2();
+    GenTreePtr op2  = tree->gtGetOp2IfPresent();
 
     regNumber  tgtReg;
     unsigned   varNum;
diff --git a/src/jit/simd.cpp b/src/jit/simd.cpp
index 7dbe81547c..fb190c4fa1 100644
--- a/src/jit/simd.cpp
+++ b/src/jit/simd.cpp
@@ -427,16 +427,6 @@ const SIMDIntrinsicInfo* Compiler::getSIMDIntrinsicInfo(CORINFO_CLASS_HANDLE* in
         return nullptr;
     }
 
-#ifdef _TARGET_X86_
-    // NYI: support LONG type SIMD intrinsics. Need support in long decomposition.
-    // (Don't use NYI fallback mechanism; just call the function.)
-    if ((*baseType == TYP_LONG) || (*baseType == TYP_ULONG))
-    {
-        JITDUMP("NYI: x86 long base type SIMD intrinsics\n");
-        return nullptr;
-    }
-#endif // _TARGET_X86_
-
     // account for implicit "this" arg
     *argCount = sig->numArgs;
     if (sig->hasThis())
diff --git a/src/jit/simdcodegenxarch.cpp b/src/jit/simdcodegenxarch.cpp
index c816fd0691..ace36422fb 100644
--- a/src/jit/simdcodegenxarch.cpp
+++ b/src/jit/simdcodegenxarch.cpp
@@ -75,22 +75,20 @@ instruction CodeGen::getOpForSIMDIntrinsic(SIMDIntrinsicID intrinsicId, var_type
                         result = INS_vbroadcastsd;
                         break;
                     case TYP_ULONG:
-                        __fallthrough;
                     case TYP_LONG:
+                        // NOTE: for x86, this instruction is valid if the src is xmm2/m64, but NOT if it is supposed
+                        // to be TYP_LONG reg.
                         result = INS_vpbroadcastq;
                         break;
                     case TYP_UINT:
-                        __fallthrough;
                     case TYP_INT:
                         result = INS_vpbroadcastd;
                         break;
                     case TYP_CHAR:
-                        __fallthrough;
                     case TYP_SHORT:
                         result = INS_vpbroadcastw;
                         break;
                     case TYP_UBYTE:
-                        __fallthrough;
                     case TYP_BYTE:
                         result = INS_vpbroadcastb;
                         break;
@@ -99,8 +97,10 @@ instruction CodeGen::getOpForSIMDIntrinsic(SIMDIntrinsicID intrinsicId, var_type
                 }
                 break;
             }
+
             // For SSE, SIMDIntrinsicInit uses the same instruction as the SIMDIntrinsicShuffleSSE2 intrinsic.
             __fallthrough;
+
         case SIMDIntrinsicShuffleSSE2:
             if (baseType == TYP_FLOAT)
             {
@@ -116,7 +116,7 @@ instruction CodeGen::getOpForSIMDIntrinsic(SIMDIntrinsicID intrinsicId, var_type
             }
             else if (baseType == TYP_LONG || baseType == TYP_ULONG)
             {
-                // We don't have a seperate SSE2 instruction and will
+                // We don't have a separate SSE2 instruction and will
                 // use the instruction meant for doubles since it is
                 // of the same size as a long.
                 result = INS_shufpd;
@@ -619,7 +619,73 @@ void CodeGen::genSIMDIntrinsicInit(GenTreeSIMD* simdNode)
     noway_assert(!varTypeIsSmallInt(baseType) || op1->IsIntegralConst(0));
 
     instruction ins = INS_invalid;
-    if (op1->isContained())
+
+#if !defined(_TARGET_64BIT_)
+    if (op1->OperGet() == GT_LONG)
+    {
+        assert(varTypeIsLong(baseType));
+
+        GenTree* op1lo = op1->gtGetOp1();
+        GenTree* op1hi = op1->gtGetOp2();
+
+        if (op1lo->IsIntegralConst(0) && op1hi->IsIntegralConst(0))
+        {
+            genSIMDZero(targetType, baseType, targetReg);
+        }
+        else if (op1lo->IsIntegralConst(-1) && op1hi->IsIntegralConst(-1))
+        {
+            // Initialize elements of vector with all 1's: generate pcmpeqd reg, reg.
+            ins = getOpForSIMDIntrinsic(SIMDIntrinsicEqual, TYP_INT);
+            inst_RV_RV(ins, targetReg, targetReg, targetType, emitActualTypeSize(targetType));
+        }
+        else
+        {
+            // Generate:
+            //     mov_i2xmm targetReg, op1lo
+            //     mov_i2xmm xmmtmp, op1hi
+            //     shl xmmtmp, 4 bytes
+            //     por targetReg, xmmtmp
+            // Now, targetReg has the long in the low 64 bits. For SSE2, move it to the high 64 bits using:
+            //     shufpd targetReg, targetReg, 0 // move the long to all the lanes
+            // For AVX2, move it to all 4 of the 64-bit lanes using:
+            //     vpbroadcastq targetReg, targetReg
+
+            instruction ins;
+
+            regNumber op1loReg = genConsumeReg(op1lo);
+            ins                = ins_CopyIntToFloat(TYP_INT, TYP_FLOAT);
+            inst_RV_RV(ins, targetReg, op1loReg, TYP_INT, emitTypeSize(TYP_INT));
+
+            assert(simdNode->gtRsvdRegs != RBM_NONE);
+            assert(genCountBits(simdNode->gtRsvdRegs) == 1);
+            regNumber tmpReg = genRegNumFromMask(simdNode->gtRsvdRegs);
+
+            regNumber op1hiReg = genConsumeReg(op1hi);
+            ins                = ins_CopyIntToFloat(TYP_INT, TYP_FLOAT);
+            inst_RV_RV(ins, tmpReg, op1hiReg, TYP_INT, emitTypeSize(TYP_INT));
+
+            ins = getOpForSIMDIntrinsic(SIMDIntrinsicShiftLeftInternal, baseType);
+            getEmitter()->emitIns_R_I(ins, EA_16BYTE, tmpReg, 4); // shift left by 4 bytes
+
+            ins = getOpForSIMDIntrinsic(SIMDIntrinsicBitwiseOr, baseType);
+            inst_RV_RV(ins, targetReg, tmpReg, targetType, emitActualTypeSize(targetType));
+
+#ifdef FEATURE_AVX_SUPPORT
+            if (compiler->canUseAVX())
+            {
+                inst_RV_RV(INS_vpbroadcastq, targetReg, targetReg, TYP_SIMD32, emitTypeSize(TYP_SIMD32));
+            }
+            else
+#endif // FEATURE_AVX_SUPPORT
+            {
+                ins = getOpForSIMDIntrinsic(SIMDIntrinsicShuffleSSE2, baseType);
+                getEmitter()->emitIns_R_R_I(ins, emitActualTypeSize(targetType), targetReg, targetReg, 0);
+            }
+        }
+    }
+    else
+#endif // !defined(_TARGET_64BIT_)
+        if (op1->isContained())
     {
         if (op1->IsIntegralConst(0) || op1->IsFPZero())
         {
@@ -1684,6 +1750,7 @@ void CodeGen::genSIMDIntrinsicGetItem(GenTreeSIMD* simdNode)
     }
 
     noway_assert(op2->isContained());
+    noway_assert(op2->IsCnsIntOrI());
     unsigned int index        = (unsigned int)op2->gtIntCon.gtIconVal;
     unsigned int byteShiftCnt = index * genTypeSize(baseType);
 
@@ -1828,7 +1895,7 @@ void CodeGen::genSIMDIntrinsicGetItem(GenTreeSIMD* simdNode)
 
             assert(tmpReg != REG_NA);
             ins = ins_CopyFloatToInt(TYP_FLOAT, baseType);
-            // (Note that for mov_xmm2i, the int register is always in the reg2 position.
+            // (Note that for mov_xmm2i, the int register is always in the reg2 position.)
             inst_RV_RV(ins, tmpReg, targetReg, baseType);
         }
     }
@@ -2055,7 +2122,7 @@ void CodeGen::genLoadIndTypeSIMD12(GenTree* treeNode)
 }
 
 //-----------------------------------------------------------------------------
-// genStoreLclFldTypeSIMD12: store a TYP_SIMD12 (i.e. Vector3) type field.
+// genStoreLclTypeSIMD12: store a TYP_SIMD12 (i.e. Vector3) type field.
 // Since Vector3 is not a hardware supported write size, it is performed
 // as two stores: 8 byte followed by 4-byte.
 //
@@ -2065,14 +2132,19 @@ void CodeGen::genLoadIndTypeSIMD12(GenTree* treeNode)
 // Return Value:
 //    None.
 //
-void CodeGen::genStoreLclFldTypeSIMD12(GenTree* treeNode)
+void CodeGen::genStoreLclTypeSIMD12(GenTree* treeNode)
 {
-    assert(treeNode->OperGet() == GT_STORE_LCL_FLD);
+    assert((treeNode->OperGet() == GT_STORE_LCL_FLD) || (treeNode->OperGet() == GT_STORE_LCL_VAR));
 
-    unsigned offs   = treeNode->gtLclFld.gtLclOffs;
+    unsigned offs   = 0;
     unsigned varNum = treeNode->gtLclVarCommon.gtLclNum;
     assert(varNum < compiler->lvaCount);
 
+    if (treeNode->OperGet() == GT_LCL_FLD)
+    {
+        offs = treeNode->gtLclFld.gtLclOffs;
+    }
+
     GenTreePtr op1 = treeNode->gtOp.gtOp1;
     assert(!op1->isContained());
     regNumber operandReg = genConsumeReg(op1);
@@ -2140,9 +2212,38 @@ void CodeGen::genLoadLclTypeSIMD12(GenTree* treeNode)
 #ifdef _TARGET_X86_
 
 //-----------------------------------------------------------------------------
+// genStoreSIMD12ToStack: store a TYP_SIMD12 (i.e. Vector3) type field to the stack.
+// Since Vector3 is not a hardware supported write size, it is performed
+// as two stores: 8 byte followed by 4-byte. The stack is assumed to have
+// already been adjusted.
+//
+// Arguments:
+//    operandReg - the xmm register containing the SIMD12 to store.
+//    tmpReg - an xmm register that can be used as a temporary for the operation.
+//
+// Return Value:
+//    None.
+//
+void CodeGen::genStoreSIMD12ToStack(regNumber operandReg, regNumber tmpReg)
+{
+    assert(genIsValidFloatReg(operandReg));
+    assert(genIsValidFloatReg(tmpReg));
+
+    // 8-byte write
+    getEmitter()->emitIns_AR_R(ins_Store(TYP_DOUBLE), EA_8BYTE, operandReg, REG_SPBASE, 0);
+
+    // Extract upper 4-bytes from data
+    getEmitter()->emitIns_R_R_I(INS_pshufd, emitActualTypeSize(TYP_SIMD16), tmpReg, operandReg, 0x02);
+
+    // 4-byte write
+    getEmitter()->emitIns_AR_R(ins_Store(TYP_FLOAT), EA_4BYTE, tmpReg, REG_SPBASE, 8);
+}
+
+//-----------------------------------------------------------------------------
 // genPutArgStkSIMD12: store a TYP_SIMD12 (i.e. Vector3) type field.
 // Since Vector3 is not a hardware supported write size, it is performed
-// as two stores: 8 byte followed by 4-byte.
+// as two stores: 8 byte followed by 4-byte. The stack is assumed to have
+// already been adjusted.
 //
 // Arguments:
 //    treeNode - tree node that is attempting to store TYP_SIMD12 field
@@ -2163,19 +2264,7 @@ void CodeGen::genPutArgStkSIMD12(GenTree* treeNode)
     assert(genCountBits(treeNode->gtRsvdRegs) == 1);
     regNumber tmpReg = genRegNumFromMask(treeNode->gtRsvdRegs);
 
-    // Subtract from ESP; create space for argument.
-    // TODO-CQ: use 'push' instead?
-    inst_RV_IV(INS_sub, REG_SPBASE, 12, EA_PTRSIZE);
-    genStackLevel += 12;
-
-    // 8-byte write
-    getEmitter()->emitIns_AR_R(ins_Store(TYP_DOUBLE), EA_8BYTE, operandReg, REG_SPBASE, 0);
-
-    // Extract upper 4-bytes from data
-    getEmitter()->emitIns_R_R_I(INS_pshufd, emitActualTypeSize(TYP_SIMD16), tmpReg, operandReg, 0x02);
-
-    // 4-byte write
-    getEmitter()->emitIns_AR_R(ins_Store(TYP_FLOAT), EA_4BYTE, tmpReg, REG_SPBASE, 8);
+    genStoreSIMD12ToStack(operandReg, tmpReg);
 }
 
 #endif // _TARGET_X86_
diff --git a/src/jit/ssabuilder.cpp b/src/jit/ssabuilder.cpp
index 5d553c1344..3d74234b26 100644
--- a/src/jit/ssabuilder.cpp
+++ b/src/jit/ssabuilder.cpp
@@ -103,12 +103,19 @@ void Compiler::fgResetForSsa()
     {
         lvaTable[i].lvPerSsaData.Reset();
     }
-    lvHeapPerSsaData.Reset();
-    m_heapSsaMap = nullptr;
+    lvMemoryPerSsaData.Reset();
+    for (MemoryKind memoryKind : allMemoryKinds())
+    {
+        m_memorySsaMap[memoryKind] = nullptr;
+    }
+
     for (BasicBlock* blk = fgFirstBB; blk != nullptr; blk = blk->bbNext)
     {
         // Eliminate phis.
-        blk->bbHeapSsaPhiFunc = nullptr;
+        for (MemoryKind memoryKind : allMemoryKinds())
+        {
+            blk->bbMemorySsaPhiFunc[memoryKind] = nullptr;
+        }
         if (blk->bbTreeList != nullptr)
         {
             GenTreePtr last = blk->bbTreeList->gtPrev;
@@ -804,29 +811,48 @@ void SsaBuilder::InsertPhiFunctions(BasicBlock** postOrder, int count)
             }
         }
 
-        // Now make a similar phi definition if the block defines Heap.
-        if (block->bbHeapDef)
+        // Now make a similar phi definition if the block defines memory.
+        if (block->bbMemoryDef != 0)
         {
             // For each block "bbInDomFront" that is in the dominance frontier of "block".
             for (BlkSet::KeyIterator iterBlk = blkIdf->Begin(); !iterBlk.Equal(blkIdf->End()); ++iterBlk)
             {
                 BasicBlock* bbInDomFront = iterBlk.Get();
-                DBG_SSA_JITDUMP("     Considering BB%02u in dom frontier of BB%02u for Heap phis:\n",
+                DBG_SSA_JITDUMP("     Considering BB%02u in dom frontier of BB%02u for Memory phis:\n",
                                 bbInDomFront->bbNum, block->bbNum);
 
-                // Check if Heap is live into block "*iterBlk".
-                if (!bbInDomFront->bbHeapLiveIn)
+                for (MemoryKind memoryKind : allMemoryKinds())
                 {
-                    continue;
-                }
+                    if ((memoryKind == GcHeap) && m_pCompiler->byrefStatesMatchGcHeapStates)
+                    {
+                        // Share the PhiFunc with ByrefExposed.
+                        assert(memoryKind > ByrefExposed);
+                        bbInDomFront->bbMemorySsaPhiFunc[memoryKind] = bbInDomFront->bbMemorySsaPhiFunc[ByrefExposed];
+                        continue;
+                    }
 
-                // Check if we've already inserted a phi node.
-                if (bbInDomFront->bbHeapSsaPhiFunc == nullptr)
-                {
-                    // We have a variable i that is defined in block j and live at l, and l belongs to dom frontier of
-                    // j. So insert a phi node at l.
-                    JITDUMP("Inserting phi definition for Heap at start of BB%02u.\n", bbInDomFront->bbNum);
-                    bbInDomFront->bbHeapSsaPhiFunc = BasicBlock::EmptyHeapPhiDef;
+                    // Check if this memoryKind is defined in this block.
+                    if ((block->bbMemoryDef & memoryKindSet(memoryKind)) == 0)
+                    {
+                        continue;
+                    }
+
+                    // Check if memoryKind is live into block "*iterBlk".
+                    if ((bbInDomFront->bbMemoryLiveIn & memoryKindSet(memoryKind)) == 0)
+                    {
+                        continue;
+                    }
+
+                    // Check if we've already inserted a phi node.
+                    if (bbInDomFront->bbMemorySsaPhiFunc[memoryKind] == nullptr)
+                    {
+                        // We have a variable i that is defined in block j and live at l, and l belongs to dom frontier
+                        // of
+                        // j. So insert a phi node at l.
+                        JITDUMP("Inserting phi definition for %s at start of BB%02u.\n", memoryKindNames[memoryKind],
+                                bbInDomFront->bbNum);
+                        bbInDomFront->bbMemorySsaPhiFunc[memoryKind] = BasicBlock::EmptyMemoryPhiDef;
+                    }
                 }
             }
         }
@@ -944,31 +970,63 @@ void SsaBuilder::TreeRenameVariables(GenTree* tree, BasicBlock* block, SsaRename
         }
     }
 
-    // Figure out if "tree" may make a new heap state (if we care for this block).
-    if (!block->bbHeapHavoc)
+    // Figure out if "tree" may make a new GC heap state (if we care for this block).
+    if ((block->bbMemoryHavoc & memoryKindSet(GcHeap)) == 0)
     {
         if (tree->OperIsAssignment() || tree->OperIsBlkOp())
         {
             if (m_pCompiler->ehBlockHasExnFlowDsc(block))
             {
                 GenTreeLclVarCommon* lclVarNode;
-                if (!tree->DefinesLocal(m_pCompiler, &lclVarNode))
+
+                bool isLocal            = tree->DefinesLocal(m_pCompiler, &lclVarNode);
+                bool isAddrExposedLocal = isLocal && m_pCompiler->lvaVarAddrExposed(lclVarNode->gtLclNum);
+                bool hasByrefHavoc      = ((block->bbMemoryHavoc & memoryKindSet(ByrefExposed)) != 0);
+                if (!isLocal || (isAddrExposedLocal && !hasByrefHavoc))
                 {
-                    // It *may* define the heap in a non-havoc way.  Make a new SSA # -- associate with this node.
-                    unsigned count = pRenameState->CountForHeapDef();
-                    pRenameState->PushHeap(block, count);
-                    m_pCompiler->GetHeapSsaMap()->Set(tree, count);
-#ifdef DEBUG
-                    if (JitTls::GetCompiler()->verboseSsa)
+                    // It *may* define byref memory in a non-havoc way.  Make a new SSA # -- associate with this node.
+                    unsigned count = pRenameState->CountForMemoryDef();
+                    if (!hasByrefHavoc)
                     {
-                        printf("Node ");
-                        Compiler::printTreeID(tree);
-                        printf(" (in try block) may define heap; ssa # = %d.\n", count);
-                    }
+                        pRenameState->PushMemory(ByrefExposed, block, count);
+                        m_pCompiler->GetMemorySsaMap(ByrefExposed)->Set(tree, count);
+#ifdef DEBUG
+                        if (JitTls::GetCompiler()->verboseSsa)
+                        {
+                            printf("Node ");
+                            Compiler::printTreeID(tree);
+                            printf(" (in try block) may define memory; ssa # = %d.\n", count);
+                        }
 #endif // DEBUG
 
-                    // Now add this SSA # to all phis of the reachable catch blocks.
-                    AddHeapDefToHandlerPhis(block, count);
+                        // Now add this SSA # to all phis of the reachable catch blocks.
+                        AddMemoryDefToHandlerPhis(ByrefExposed, block, count);
+                    }
+
+                    if (!isLocal)
+                    {
+                        // Add a new def for GcHeap as well
+                        if (m_pCompiler->byrefStatesMatchGcHeapStates)
+                        {
+                            // GcHeap and ByrefExposed share the same stacks, SsaMap, and phis
+                            assert(!hasByrefHavoc);
+                            assert(pRenameState->CountForMemoryUse(GcHeap) == count);
+                            assert(*m_pCompiler->GetMemorySsaMap(GcHeap)->LookupPointer(tree) == count);
+                            assert(block->bbMemorySsaPhiFunc[GcHeap] == block->bbMemorySsaPhiFunc[ByrefExposed]);
+                        }
+                        else
+                        {
+                            if (!hasByrefHavoc)
+                            {
+                                // Allocate a distinct defnum for the GC Heap
+                                count = pRenameState->CountForMemoryDef();
+                            }
+
+                            pRenameState->PushMemory(GcHeap, block, count);
+                            m_pCompiler->GetMemorySsaMap(GcHeap)->Set(tree, count);
+                            AddMemoryDefToHandlerPhis(GcHeap, block, count);
+                        }
+                    }
                 }
             }
         }
@@ -1154,7 +1212,7 @@ void SsaBuilder::AddDefToHandlerPhis(BasicBlock* block, unsigned lclNum, unsigne
     }
 }
 
-void SsaBuilder::AddHeapDefToHandlerPhis(BasicBlock* block, unsigned count)
+void SsaBuilder::AddMemoryDefToHandlerPhis(MemoryKind memoryKind, BasicBlock* block, unsigned count)
 {
     if (m_pCompiler->ehBlockHasExnFlowDsc(block))
     {
@@ -1165,39 +1223,60 @@ void SsaBuilder::AddHeapDefToHandlerPhis(BasicBlock* block, unsigned count)
         }
 
         // Otherwise...
-        DBG_SSA_JITDUMP("Definition of Heap/d:%d in block BB%02u has exn handler; adding as phi arg to handlers.\n",
-                        count, block->bbNum);
+        DBG_SSA_JITDUMP("Definition of %s/d:%d in block BB%02u has exn handler; adding as phi arg to handlers.\n",
+                        memoryKindNames[memoryKind], count, block->bbNum);
         EHblkDsc* tryBlk = m_pCompiler->ehGetBlockExnFlowDsc(block);
         while (true)
         {
             BasicBlock* handler = tryBlk->ExFlowBlock();
 
-            // Is Heap live on entry to the handler?
-            if (handler->bbHeapLiveIn)
+            // Is memoryKind live on entry to the handler?
+            if ((handler->bbMemoryLiveIn & memoryKindSet(memoryKind)) != 0)
             {
-                assert(handler->bbHeapSsaPhiFunc != nullptr);
+                assert(handler->bbMemorySsaPhiFunc != nullptr);
+
+                // Add "count" to the phi args of memoryKind.
+                BasicBlock::MemoryPhiArg*& handlerMemoryPhi = handler->bbMemorySsaPhiFunc[memoryKind];
+
+#if DEBUG
+                if (m_pCompiler->byrefStatesMatchGcHeapStates)
+                {
+                    // When sharing phis for GcHeap and ByrefExposed, callers should ask to add phis
+                    // for ByrefExposed only.
+                    assert(memoryKind != GcHeap);
+                    if (memoryKind == ByrefExposed)
+                    {
+                        // The GcHeap and ByrefExposed phi funcs should always be in sync.
+                        assert(handlerMemoryPhi == handler->bbMemorySsaPhiFunc[GcHeap]);
+                    }
+                }
+#endif
 
-                // Add "count" to the phi args of Heap.
-                if (handler->bbHeapSsaPhiFunc == BasicBlock::EmptyHeapPhiDef)
+                if (handlerMemoryPhi == BasicBlock::EmptyMemoryPhiDef)
                 {
-                    handler->bbHeapSsaPhiFunc = new (m_pCompiler) BasicBlock::HeapPhiArg(count);
+                    handlerMemoryPhi = new (m_pCompiler) BasicBlock::MemoryPhiArg(count);
                 }
                 else
                 {
 #ifdef DEBUG
-                    BasicBlock::HeapPhiArg* curArg = handler->bbHeapSsaPhiFunc;
+                    BasicBlock::MemoryPhiArg* curArg = handler->bbMemorySsaPhiFunc[memoryKind];
                     while (curArg != nullptr)
                     {
                         assert(curArg->GetSsaNum() != count);
                         curArg = curArg->m_nextArg;
                     }
 #endif // DEBUG
-                    handler->bbHeapSsaPhiFunc =
-                        new (m_pCompiler) BasicBlock::HeapPhiArg(count, handler->bbHeapSsaPhiFunc);
+                    handlerMemoryPhi = new (m_pCompiler) BasicBlock::MemoryPhiArg(count, handlerMemoryPhi);
                 }
 
-                DBG_SSA_JITDUMP("   Added phi arg u:%d for Heap to phi defn in handler block BB%02u.\n", count,
-                                handler->bbNum);
+                DBG_SSA_JITDUMP("   Added phi arg u:%d for %s to phi defn in handler block BB%02u.\n", count,
+                                memoryKindNames[memoryKind], memoryKind, handler->bbNum);
+
+                if ((memoryKind == ByrefExposed) && m_pCompiler->byrefStatesMatchGcHeapStates)
+                {
+                    // Share the phi between GcHeap and ByrefExposed.
+                    handler->bbMemorySsaPhiFunc[GcHeap] = handlerMemoryPhi;
+                }
             }
             unsigned tryInd = tryBlk->ebdEnclosingTryIndex;
             if (tryInd == EHblkDsc::NO_ENCLOSING_INDEX)
@@ -1221,19 +1300,33 @@ void SsaBuilder::BlockRenameVariables(BasicBlock* block, SsaRenameState* pRename
 {
     // Walk the statements of the block and rename the tree variables.
 
-    // First handle the incoming Heap state.
-
-    // Is there an Phi definition for heap at the start of this block?
-    if (block->bbHeapSsaPhiFunc != nullptr)
+    // First handle the incoming memory states.
+    for (MemoryKind memoryKind : allMemoryKinds())
     {
-        unsigned count = pRenameState->CountForHeapDef();
-        pRenameState->PushHeap(block, count);
+        if ((memoryKind == GcHeap) && m_pCompiler->byrefStatesMatchGcHeapStates)
+        {
+            // ByrefExposed and GcHeap share any phi this block may have,
+            assert(block->bbMemorySsaPhiFunc[memoryKind] == block->bbMemorySsaPhiFunc[ByrefExposed]);
+            // so we will have already allocated a defnum for it if needed.
+            assert(memoryKind > ByrefExposed);
+            assert(pRenameState->CountForMemoryUse(memoryKind) == pRenameState->CountForMemoryUse(ByrefExposed));
+        }
+        else
+        {
+            // Is there an Phi definition for memoryKind at the start of this block?
+            if (block->bbMemorySsaPhiFunc[memoryKind] != nullptr)
+            {
+                unsigned count = pRenameState->CountForMemoryDef();
+                pRenameState->PushMemory(memoryKind, block, count);
 
-        DBG_SSA_JITDUMP("Ssa # for Heap phi on entry to BB%02u is %d.\n", block->bbNum, count);
-    }
+                DBG_SSA_JITDUMP("Ssa # for %s phi on entry to BB%02u is %d.\n", memoryKindNames[memoryKind],
+                                block->bbNum, count);
+            }
+        }
 
-    // Record the "in" Ssa # for Heap.
-    block->bbHeapSsaNumIn = pRenameState->CountForHeapUse();
+        // Record the "in" Ssa # for memoryKind.
+        block->bbMemorySsaNumIn[memoryKind] = pRenameState->CountForMemoryUse(memoryKind);
+    }
 
     // We need to iterate over phi definitions, to give them SSA names, but we need
     // to know which are which, so we don't add phi definitions to handler phi arg lists.
@@ -1253,22 +1346,38 @@ void SsaBuilder::BlockRenameVariables(BasicBlock* block, SsaRenameState* pRename
         }
     }
 
-    // Now handle the final heap state.
-
-    // If the block defines Heap, allocate an SSA variable for the final heap state in the block.
-    // (This may be redundant with the last SSA var explicitly created, but there's no harm in that.)
-    if (block->bbHeapDef)
+    // Now handle the final memory states.
+    for (MemoryKind memoryKind : allMemoryKinds())
     {
-        unsigned count = pRenameState->CountForHeapDef();
-        pRenameState->PushHeap(block, count);
-        AddHeapDefToHandlerPhis(block, count);
-    }
+        MemoryKindSet memorySet = memoryKindSet(memoryKind);
+
+        // If the block defines memory, allocate an SSA variable for the final memory state in the block.
+        // (This may be redundant with the last SSA var explicitly created, but there's no harm in that.)
+        if ((memoryKind == GcHeap) && m_pCompiler->byrefStatesMatchGcHeapStates)
+        {
+            // We've already allocated the SSA num and propagated it to shared phis, if needed,
+            // when processing ByrefExposed.
+            assert(memoryKind > ByrefExposed);
+            assert(((block->bbMemoryDef & memorySet) != 0) ==
+                   ((block->bbMemoryDef & memoryKindSet(ByrefExposed)) != 0));
+            assert(pRenameState->CountForMemoryUse(memoryKind) == pRenameState->CountForMemoryUse(ByrefExposed));
+        }
+        else
+        {
+            if ((block->bbMemoryDef & memorySet) != 0)
+            {
+                unsigned count = pRenameState->CountForMemoryDef();
+                pRenameState->PushMemory(memoryKind, block, count);
+                AddMemoryDefToHandlerPhis(memoryKind, block, count);
+            }
+        }
 
-    // Record the "out" Ssa" # for Heap.
-    block->bbHeapSsaNumOut = pRenameState->CountForHeapUse();
+        // Record the "out" Ssa" # for memoryKind.
+        block->bbMemorySsaNumOut[memoryKind] = pRenameState->CountForMemoryUse(memoryKind);
 
-    DBG_SSA_JITDUMP("Ssa # for Heap on entry to BB%02u is %d; on exit is %d.\n", block->bbNum, block->bbHeapSsaNumIn,
-                    block->bbHeapSsaNumOut);
+        DBG_SSA_JITDUMP("Ssa # for %s on entry to BB%02u is %d; on exit is %d.\n", memoryKindNames[memoryKind],
+                        block->bbNum, block->bbMemorySsaNumIn[memoryKind], block->bbMemorySsaNumOut[memoryKind]);
+    }
 }
 
 /**
@@ -1328,35 +1437,54 @@ void SsaBuilder::AssignPhiNodeRhsVariables(BasicBlock* block, SsaRenameState* pR
             m_pCompiler->fgSetStmtSeq(stmt);
         }
 
-        // Now handle Heap.
-        if (succ->bbHeapSsaPhiFunc != nullptr)
+        // Now handle memory.
+        for (MemoryKind memoryKind : allMemoryKinds())
         {
-            if (succ->bbHeapSsaPhiFunc == BasicBlock::EmptyHeapPhiDef)
-            {
-                succ->bbHeapSsaPhiFunc = new (m_pCompiler) BasicBlock::HeapPhiArg(block->bbHeapSsaNumOut);
-            }
-            else
+            BasicBlock::MemoryPhiArg*& succMemoryPhi = succ->bbMemorySsaPhiFunc[memoryKind];
+            if (succMemoryPhi != nullptr)
             {
-                BasicBlock::HeapPhiArg* curArg = succ->bbHeapSsaPhiFunc;
-                unsigned                ssaNum = block->bbHeapSsaNumOut;
-                bool                    found  = false;
-                // This is a quadratic algorithm.  We might need to consider some switch over to a hash table
-                // representation for the arguments of a phi node, to make this linear.
-                while (curArg != nullptr)
+                if ((memoryKind == GcHeap) && m_pCompiler->byrefStatesMatchGcHeapStates)
                 {
-                    if (curArg->m_ssaNum == ssaNum)
-                    {
-                        found = true;
-                        break;
-                    }
-                    curArg = curArg->m_nextArg;
+                    // We've already propagated the "out" number to the phi shared with ByrefExposed,
+                    // but still need to update bbMemorySsaPhiFunc to be in sync between GcHeap and ByrefExposed.
+                    assert(memoryKind > ByrefExposed);
+                    assert(block->bbMemorySsaNumOut[memoryKind] == block->bbMemorySsaNumOut[ByrefExposed]);
+                    assert((succ->bbMemorySsaPhiFunc[ByrefExposed] == succMemoryPhi) ||
+                           (succ->bbMemorySsaPhiFunc[ByrefExposed]->m_nextArg ==
+                            (succMemoryPhi == BasicBlock::EmptyMemoryPhiDef ? nullptr : succMemoryPhi)));
+                    succMemoryPhi = succ->bbMemorySsaPhiFunc[ByrefExposed];
+
+                    continue;
+                }
+
+                if (succMemoryPhi == BasicBlock::EmptyMemoryPhiDef)
+                {
+                    succMemoryPhi = new (m_pCompiler) BasicBlock::MemoryPhiArg(block->bbMemorySsaNumOut[memoryKind]);
                 }
-                if (!found)
+                else
                 {
-                    succ->bbHeapSsaPhiFunc = new (m_pCompiler) BasicBlock::HeapPhiArg(ssaNum, succ->bbHeapSsaPhiFunc);
+                    BasicBlock::MemoryPhiArg* curArg = succMemoryPhi;
+                    unsigned                  ssaNum = block->bbMemorySsaNumOut[memoryKind];
+                    bool                      found  = false;
+                    // This is a quadratic algorithm.  We might need to consider some switch over to a hash table
+                    // representation for the arguments of a phi node, to make this linear.
+                    while (curArg != nullptr)
+                    {
+                        if (curArg->m_ssaNum == ssaNum)
+                        {
+                            found = true;
+                            break;
+                        }
+                        curArg = curArg->m_nextArg;
+                    }
+                    if (!found)
+                    {
+                        succMemoryPhi = new (m_pCompiler) BasicBlock::MemoryPhiArg(ssaNum, succMemoryPhi);
+                    }
                 }
+                DBG_SSA_JITDUMP("  Added phi arg for %s u:%d from BB%02u in BB%02u.\n", memoryKindNames[memoryKind],
+                                block->bbMemorySsaNumOut[memoryKind], block->bbNum, succ->bbNum);
             }
-            DBG_SSA_JITDUMP("  Added phi arg for Heap from BB%02u in BB%02u.\n", block->bbNum, succ->bbNum);
         }
 
         // If "succ" is the first block of a try block (and "block" is not also in that try block)
@@ -1462,26 +1590,44 @@ void SsaBuilder::AssignPhiNodeRhsVariables(BasicBlock* block, SsaRenameState* pR
                     }
                 }
 
-                // Now handle Heap.
-                if (handlerStart->bbHeapSsaPhiFunc != nullptr)
+                // Now handle memory.
+                for (MemoryKind memoryKind : allMemoryKinds())
                 {
-                    if (handlerStart->bbHeapSsaPhiFunc == BasicBlock::EmptyHeapPhiDef)
-                    {
-                        handlerStart->bbHeapSsaPhiFunc =
-                            new (m_pCompiler) BasicBlock::HeapPhiArg(block->bbHeapSsaNumOut);
-                    }
-                    else
+                    BasicBlock::MemoryPhiArg*& handlerMemoryPhi = handlerStart->bbMemorySsaPhiFunc[memoryKind];
+                    if (handlerMemoryPhi != nullptr)
                     {
-                        // This path has a potential to introduce redundant phi args, due to multiple
-                        // preds of the same try-begin block having the same live-out heap def, and/or
-                        // due to nested try-begins each having preds with the same live-out heap def.
-                        // Avoid doing quadratic processing on handler phis, and instead live with the
-                        // occasional redundancy.
-                        handlerStart->bbHeapSsaPhiFunc = new (m_pCompiler)
-                            BasicBlock::HeapPhiArg(block->bbHeapSsaNumOut, handlerStart->bbHeapSsaPhiFunc);
+                        if ((memoryKind == GcHeap) && m_pCompiler->byrefStatesMatchGcHeapStates)
+                        {
+                            // We've already added the arg to the phi shared with ByrefExposed if needed,
+                            // but still need to update bbMemorySsaPhiFunc to stay in sync.
+                            assert(memoryKind > ByrefExposed);
+                            assert(block->bbMemorySsaNumOut[memoryKind] == block->bbMemorySsaNumOut[ByrefExposed]);
+                            assert(handlerStart->bbMemorySsaPhiFunc[ByrefExposed]->m_ssaNum ==
+                                   block->bbMemorySsaNumOut[memoryKind]);
+                            handlerMemoryPhi = handlerStart->bbMemorySsaPhiFunc[ByrefExposed];
+
+                            continue;
+                        }
+
+                        if (handlerMemoryPhi == BasicBlock::EmptyMemoryPhiDef)
+                        {
+                            handlerMemoryPhi =
+                                new (m_pCompiler) BasicBlock::MemoryPhiArg(block->bbMemorySsaNumOut[memoryKind]);
+                        }
+                        else
+                        {
+                            // This path has a potential to introduce redundant phi args, due to multiple
+                            // preds of the same try-begin block having the same live-out memory def, and/or
+                            // due to nested try-begins each having preds with the same live-out memory def.
+                            // Avoid doing quadratic processing on handler phis, and instead live with the
+                            // occasional redundancy.
+                            handlerMemoryPhi = new (m_pCompiler)
+                                BasicBlock::MemoryPhiArg(block->bbMemorySsaNumOut[memoryKind], handlerMemoryPhi);
+                        }
+                        DBG_SSA_JITDUMP("  Added phi arg for %s u:%d from BB%02u in BB%02u.\n",
+                                        memoryKindNames[memoryKind], block->bbMemorySsaNumOut[memoryKind], block->bbNum,
+                                        handlerStart->bbNum);
                     }
-                    DBG_SSA_JITDUMP("  Added phi arg for Heap from BB%02u in BB%02u.\n", block->bbNum,
-                                    handlerStart->bbNum);
                 }
 
                 tryInd = succTry->ebdEnclosingTryIndex;
@@ -1502,8 +1648,17 @@ void SsaBuilder::BlockPopStacks(BasicBlock* block, SsaRenameState* pRenameState)
     // Pop the names given to the non-phi nodes.
     pRenameState->PopBlockStacks(block);
 
-    // And for Heap.
-    pRenameState->PopBlockHeapStack(block);
+    // And for memory.
+    for (MemoryKind memoryKind : allMemoryKinds())
+    {
+        if ((memoryKind == GcHeap) && m_pCompiler->byrefStatesMatchGcHeapStates)
+        {
+            // GcHeap and ByrefExposed share a rename stack, so don't try
+            // to pop it a second time.
+            continue;
+        }
+        pRenameState->PopBlockMemoryStack(memoryKind, block);
+    }
 }
 
 /**
@@ -1552,20 +1707,32 @@ void SsaBuilder::RenameVariables(BlkToBlkSetMap* domTree, SsaRenameState* pRenam
             pRenameState->Push(nullptr, i, count);
         }
     }
-    // In ValueNum we'd assume un-inited heap gets FIRST_SSA_NUM.
-    // The heap is a parameter.  Use FIRST_SSA_NUM as first SSA name.
-    unsigned initHeapCount = pRenameState->CountForHeapDef();
-    assert(initHeapCount == SsaConfig::FIRST_SSA_NUM);
-    pRenameState->PushHeap(m_pCompiler->fgFirstBB, initHeapCount);
-
-    // Initialize the heap ssa numbers for unreachable blocks. ValueNum expects
-    // heap ssa numbers to have some intitial value.
+
+    // In ValueNum we'd assume un-inited memory gets FIRST_SSA_NUM.
+    // The memory is a parameter.  Use FIRST_SSA_NUM as first SSA name.
+    unsigned initMemoryCount = pRenameState->CountForMemoryDef();
+    assert(initMemoryCount == SsaConfig::FIRST_SSA_NUM);
+    for (MemoryKind memoryKind : allMemoryKinds())
+    {
+        if ((memoryKind == GcHeap) && m_pCompiler->byrefStatesMatchGcHeapStates)
+        {
+            // GcHeap shares its stack with ByrefExposed; don't re-push.
+            continue;
+        }
+        pRenameState->PushMemory(memoryKind, m_pCompiler->fgFirstBB, initMemoryCount);
+    }
+
+    // Initialize the memory ssa numbers for unreachable blocks. ValueNum expects
+    // memory ssa numbers to have some intitial value.
     for (BasicBlock* block = m_pCompiler->fgFirstBB; block; block = block->bbNext)
     {
         if (block->bbIDom == nullptr)
         {
-            block->bbHeapSsaNumIn  = initHeapCount;
-            block->bbHeapSsaNumOut = initHeapCount;
+            for (MemoryKind memoryKind : allMemoryKinds())
+            {
+                block->bbMemorySsaNumIn[memoryKind]  = initMemoryCount;
+                block->bbMemorySsaNumOut[memoryKind] = initMemoryCount;
+            }
         }
     }
 
@@ -1624,8 +1791,8 @@ void SsaBuilder::RenameVariables(BlkToBlkSetMap* domTree, SsaRenameState* pRenam
         }
     }
 
-    // Remember the number of Heap SSA names.
-    m_pCompiler->lvHeapNumSsaNames = pRenameState->HeapCount();
+    // Remember the number of memory SSA names.
+    m_pCompiler->lvMemoryNumSsaNames = pRenameState->MemoryCount();
 }
 
 #ifdef DEBUG
@@ -1732,7 +1899,7 @@ void SsaBuilder::Build()
 
     // Rename local variables and collect UD information for each ssa var.
     SsaRenameState* pRenameState = new (jitstd::utility::allocate<SsaRenameState>(m_allocator), jitstd::placement_t())
-        SsaRenameState(m_allocator, m_pCompiler->lvaCount);
+        SsaRenameState(m_allocator, m_pCompiler->lvaCount, m_pCompiler->byrefStatesMatchGcHeapStates);
     RenameVariables(domTree, pRenameState);
     EndPhase(PHASE_BUILD_SSA_RENAME);
 
diff --git a/src/jit/ssabuilder.h b/src/jit/ssabuilder.h
index 2fff06573e..e82a4007e3 100644
--- a/src/jit/ssabuilder.h
+++ b/src/jit/ssabuilder.h
@@ -164,8 +164,8 @@ private:
     // block of those handlers.
     void AddDefToHandlerPhis(BasicBlock* block, unsigned lclNum, unsigned count);
 
-    // Same as above, for "Heap".
-    void AddHeapDefToHandlerPhis(BasicBlock* block, unsigned count);
+    // Same as above, for memory.
+    void AddMemoryDefToHandlerPhis(MemoryKind memoryKind, BasicBlock* block, unsigned count);
 
     // Requires "block" to be non-NULL.  Requires "pRenameState" to be non-NULL and be currently used
     // for variables renaming. Assigns the rhs arguments to the phi, i.e., block's phi node arguments.
diff --git a/src/jit/ssarenamestate.cpp b/src/jit/ssarenamestate.cpp
index a1e05f192f..4ccac05a48 100644
--- a/src/jit/ssarenamestate.cpp
+++ b/src/jit/ssarenamestate.cpp
@@ -28,14 +28,17 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  *
  * @params alloc The allocator class used to allocate jitstd data.
  */
-SsaRenameState::SsaRenameState(const jitstd::allocator<int>& alloc, unsigned lvaCount)
+SsaRenameState::SsaRenameState(const jitstd::allocator<int>& alloc,
+                               unsigned                      lvaCount,
+                               bool                          byrefStatesMatchGcHeapStates)
     : counts(nullptr)
     , stacks(nullptr)
     , definedLocs(alloc)
-    , heapStack(alloc)
-    , heapCount(0)
+    , memoryStack(alloc)
+    , memoryCount(0)
     , lvaCount(lvaCount)
     , m_alloc(alloc)
+    , byrefStatesMatchGcHeapStates(byrefStatesMatchGcHeapStates)
 {
 }
 
@@ -200,11 +203,12 @@ void SsaRenameState::PopBlockStacks(BasicBlock* block)
 #endif // DEBUG
 }
 
-void SsaRenameState::PopBlockHeapStack(BasicBlock* block)
+void SsaRenameState::PopBlockMemoryStack(MemoryKind memoryKind, BasicBlock* block)
 {
-    while (heapStack.size() > 0 && heapStack.back().m_bb == block)
+    auto& stack = memoryStack[memoryKind];
+    while (stack.size() > 0 && stack.back().m_bb == block)
     {
-        heapStack.pop_back();
+        stack.pop_back();
     }
 }
 
diff --git a/src/jit/ssarenamestate.h b/src/jit/ssarenamestate.h
index 1db36c5b37..a8496b6386 100644
--- a/src/jit/ssarenamestate.h
+++ b/src/jit/ssarenamestate.h
@@ -23,6 +23,53 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 
 #include "jitstd.h"
 
+// Fixed-size array that can hold elements with no default constructor;
+// it will construct them all by forwarding whatever arguments are
+// supplied to its constructor.
+template <typename T, int N>
+class ConstructedArray
+{
+    union {
+        // Storage that gets used to hold the T objects.
+        unsigned char bytes[N * sizeof(T)];
+
+#if defined(_MSC_VER) && (_MSC_VER < 1900)
+        // With MSVC pre-VS2015, the code in the #else branch would hit error C2621,
+        // so in that case just count on pointer alignment being sufficient
+        // (currently T is only ever instantiated as jitstd::list<SsaRenameStateForBlock>)
+
+        // Unused (except to impart alignment requirement)
+        void* pointer;
+#else
+        // Unused (except to impart alignment requirement)
+        T alignedArray[N];
+#endif // defined(_MSC_VER) && (_MSC_VER < 1900)
+    };
+
+public:
+    T& operator[](size_t i)
+    {
+        return *(reinterpret_cast<T*>(bytes + i * sizeof(T)));
+    }
+
+    template <typename... Args>
+    ConstructedArray(Args&&... args)
+    {
+        for (int i = 0; i < N; ++i)
+        {
+            new (bytes + i * sizeof(T), jitstd::placement_t()) T(jitstd::forward<Args>(args)...);
+        }
+    }
+
+    ~ConstructedArray()
+    {
+        for (int i = 0; i < N; ++i)
+        {
+            operator[](i).~T();
+        }
+    }
+};
+
 struct SsaRenameStateForBlock
 {
     BasicBlock* m_bb;
@@ -54,7 +101,7 @@ struct SsaRenameState
     typedef unsigned*                            Counts;
     typedef jitstd::list<SsaRenameStateLocDef>   DefStack;
 
-    SsaRenameState(const jitstd::allocator<int>& allocator, unsigned lvaCount);
+    SsaRenameState(const jitstd::allocator<int>& allocator, unsigned lvaCount, bool byrefStatesMatchGcHeapStates);
 
     void EnsureCounts();
     void EnsureStacks();
@@ -74,32 +121,42 @@ struct SsaRenameState
     // Pop all stacks that have an entry for "bb" on top.
     void PopBlockStacks(BasicBlock* bb);
 
-    // Similar functions for the special implicit "Heap" variable.
-    unsigned CountForHeapDef()
+    // Similar functions for the special implicit memory variable.
+    unsigned CountForMemoryDef()
     {
-        if (heapCount == 0)
+        if (memoryCount == 0)
         {
-            heapCount = SsaConfig::FIRST_SSA_NUM;
+            memoryCount = SsaConfig::FIRST_SSA_NUM;
         }
-        unsigned res = heapCount;
-        heapCount++;
+        unsigned res = memoryCount;
+        memoryCount++;
         return res;
     }
-    unsigned CountForHeapUse()
+    unsigned CountForMemoryUse(MemoryKind memoryKind)
     {
-        return heapStack.back().m_count;
+        if ((memoryKind == GcHeap) && byrefStatesMatchGcHeapStates)
+        {
+            // Share rename stacks in this configuration.
+            memoryKind = ByrefExposed;
+        }
+        return memoryStack[memoryKind].back().m_count;
     }
 
-    void PushHeap(BasicBlock* bb, unsigned count)
+    void PushMemory(MemoryKind memoryKind, BasicBlock* bb, unsigned count)
     {
-        heapStack.push_back(SsaRenameStateForBlock(bb, count));
+        if ((memoryKind == GcHeap) && byrefStatesMatchGcHeapStates)
+        {
+            // Share rename stacks in this configuration.
+            memoryKind = ByrefExposed;
+        }
+        memoryStack[memoryKind].push_back(SsaRenameStateForBlock(bb, count));
     }
 
-    void PopBlockHeapStack(BasicBlock* bb);
+    void PopBlockMemoryStack(MemoryKind memoryKind, BasicBlock* bb);
 
-    unsigned HeapCount()
+    unsigned MemoryCount()
     {
-        return heapCount;
+        return memoryCount;
     }
 
 #ifdef DEBUG
@@ -117,13 +174,16 @@ private:
     // This list represents the set of locals defined in the current block.
     DefStack definedLocs;
 
-    // Same state for the special implicit Heap variable.
-    Stack    heapStack;
-    unsigned heapCount;
+    // Same state for the special implicit memory variables.
+    ConstructedArray<Stack, MemoryKindCount> memoryStack;
+    unsigned memoryCount;
 
     // Number of stacks/counts to allocate.
     unsigned lvaCount;
 
     // Allocator to allocate stacks.
     jitstd::allocator<void> m_alloc;
+
+    // Indicates whether GcHeap and ByrefExposed use the same state.
+    bool byrefStatesMatchGcHeapStates;
 };
diff --git a/src/jit/stackfp.cpp b/src/jit/stackfp.cpp
index 43c463039e..3e0eceabb7 100644
--- a/src/jit/stackfp.cpp
+++ b/src/jit/stackfp.cpp
@@ -1376,7 +1376,7 @@ void CodeGen::genCodeForTreeStackFP_Asg(GenTreePtr tree)
     emitAttr   size;
     unsigned   offs;
     GenTreePtr op1 = tree->gtOp.gtOp1;
-    GenTreePtr op2 = tree->gtGetOp2();
+    GenTreePtr op2 = tree->gtGetOp2IfPresent();
 
     assert(tree->OperGet() == GT_ASG);
 
@@ -1693,14 +1693,14 @@ void CodeGen::genCodeForTreeStackFP_Arithm(GenTreePtr tree)
     if (tree->gtFlags & GTF_REVERSE_OPS)
     {
         bReverse = true;
-        op1      = tree->gtGetOp2();
+        op1      = tree->gtGetOp2IfPresent();
         op2      = tree->gtOp.gtOp1;
     }
     else
     {
         bReverse = false;
         op1      = tree->gtOp.gtOp1;
-        op2      = tree->gtGetOp2();
+        op2      = tree->gtGetOp2IfPresent();
     }
 
     regNumber result;
@@ -1928,7 +1928,7 @@ void CodeGen::genCodeForTreeStackFP_AsgArithm(GenTreePtr tree)
     GenTreePtr op1, op2;
 
     op1 = tree->gtOp.gtOp1;
-    op2 = tree->gtGetOp2();
+    op2 = tree->gtGetOp2IfPresent();
 
     genSetupForOpStackFP(op1, op2, (tree->gtFlags & GTF_REVERSE_OPS) ? true : false, true, false, true);
 
@@ -2208,7 +2208,7 @@ void CodeGen::genCodeForTreeStackFP_SmpOp(GenTreePtr tree)
         case GT_COMMA:
         {
             GenTreePtr op1 = tree->gtOp.gtOp1;
-            GenTreePtr op2 = tree->gtGetOp2();
+            GenTreePtr op2 = tree->gtGetOp2IfPresent();
 
             if (tree->gtFlags & GTF_REVERSE_OPS)
             {
diff --git a/src/jit/target.h b/src/jit/target.h
index 6330d52889..cb2609f8f9 100644
--- a/src/jit/target.h
+++ b/src/jit/target.h
@@ -495,9 +495,15 @@ typedef unsigned short regPairNoSmall; // arm: need 12 bits
   #define MIN_ARG_AREA_FOR_CALL    0       // Minimum required outgoing argument space for a call.
 
   #define CODE_ALIGN               1       // code alignment requirement
+#if !defined(UNIX_X86_ABI)
   #define STACK_ALIGN              4       // stack alignment requirement
   #define STACK_ALIGN_SHIFT        2       // Shift-right amount to convert stack size in bytes to size in DWORD_PTRs
   #define STACK_ALIGN_SHIFT_ALL    2       // Shift-right amount to convert stack size in bytes to size in STACK_ALIGN units
+#else
+  #define STACK_ALIGN              16      // stack alignment requirement
+  #define STACK_ALIGN_SHIFT        4       // Shift-right amount to convert stack size in bytes to size in DWORD_PTRs
+  #define STACK_ALIGN_SHIFT_ALL    4       // Shift-right amount to convert stack size in bytes to size in STACK_ALIGN units
+#endif // !UNIX_X86_ABI
 
   #define RBM_INT_CALLEE_SAVED    (RBM_EBX|RBM_ESI|RBM_EDI)
   #define RBM_INT_CALLEE_TRASH    (RBM_EAX|RBM_ECX|RBM_EDX)
@@ -1176,7 +1182,11 @@ typedef unsigned short regPairNoSmall; // arm: need 12 bits
   // TODO-ARM-CQ: Check for sdiv/udiv at runtime and generate it if available
   #define USE_HELPERS_FOR_INT_DIV  1       // BeagleBoard (ARMv7A) doesn't support SDIV/UDIV
   #define CPU_LOAD_STORE_ARCH      1
+#ifdef LEGACY_BACKEND
   #define CPU_LONG_USES_REGPAIR    1
+#else
+  #define CPU_LONG_USES_REGPAIR    0
+#endif
   #define CPU_HAS_FP_SUPPORT       1
   #define ROUND_FLOAT              0       // Do not round intermed float expression results
   #define CPU_HAS_BYTE_REGS        0
@@ -1418,6 +1428,10 @@ typedef unsigned short regPairNoSmall; // arm: need 12 bits
   #define RBM_INTRET               RBM_R0
   #define REG_LNGRET               REG_PAIR_R0R1
   #define RBM_LNGRET              (RBM_R1|RBM_R0)
+  #define REG_LNGRET_LO            REG_R0
+  #define REG_LNGRET_HI            REG_R1
+  #define RBM_LNGRET_LO            RBM_R0
+  #define RBM_LNGRET_HI            RBM_R1
 
   #define REG_FLOATRET             REG_F0
   #define RBM_FLOATRET             RBM_F0
diff --git a/src/jit/utils.cpp b/src/jit/utils.cpp
index 3a45039aa7..df5bd2bea6 100644
--- a/src/jit/utils.cpp
+++ b/src/jit/utils.cpp
@@ -1358,6 +1358,7 @@ void HelperCallProperties::init()
             case CORINFO_HELP_ISINSTANCEOFCLASS:
             case CORINFO_HELP_ISINSTANCEOFANY:
             case CORINFO_HELP_READYTORUN_ISINSTANCEOF:
+            case CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE:
 
                 isPure  = true;
                 noThrow = true; // These return null for a failing cast
diff --git a/src/jit/valuenum.cpp b/src/jit/valuenum.cpp
index 8b3e710484..ed0398442f 100644
--- a/src/jit/valuenum.cpp
+++ b/src/jit/valuenum.cpp
@@ -1373,10 +1373,10 @@ TailCall:
                     goto TailCall;
                 }
             }
-            else if (funcApp.m_func == VNF_PhiDef || funcApp.m_func == VNF_PhiHeapDef)
+            else if (funcApp.m_func == VNF_PhiDef || funcApp.m_func == VNF_PhiMemoryDef)
             {
-                unsigned  lclNum = BAD_VAR_NUM;
-                bool      isHeap = false;
+                unsigned  lclNum   = BAD_VAR_NUM;
+                bool      isMemory = false;
                 VNFuncApp phiFuncApp;
                 bool      defArgIsFunc = false;
                 if (funcApp.m_func == VNF_PhiDef)
@@ -1386,8 +1386,8 @@ TailCall:
                 }
                 else
                 {
-                    assert(funcApp.m_func == VNF_PhiHeapDef);
-                    isHeap       = true;
+                    assert(funcApp.m_func == VNF_PhiMemoryDef);
+                    isMemory     = true;
                     defArgIsFunc = GetVNFunc(funcApp.m_args[1], &phiFuncApp);
                 }
                 if (defArgIsFunc && phiFuncApp.m_func == VNF_Phi)
@@ -1401,9 +1401,9 @@ TailCall:
                     assert(IsVNConstant(phiFuncApp.m_args[0]));
                     unsigned phiArgSsaNum = ConstantValue<unsigned>(phiFuncApp.m_args[0]);
                     ValueNum phiArgVN;
-                    if (isHeap)
+                    if (isMemory)
                     {
-                        phiArgVN = m_pComp->GetHeapPerSsaData(phiArgSsaNum)->m_vnPair.Get(vnk);
+                        phiArgVN = m_pComp->GetMemoryPerSsaData(phiArgSsaNum)->m_vnPair.Get(vnk);
                     }
                     else
                     {
@@ -1430,9 +1430,9 @@ TailCall:
                             }
                             assert(IsVNConstant(cur));
                             phiArgSsaNum = ConstantValue<unsigned>(cur);
-                            if (isHeap)
+                            if (isMemory)
                             {
-                                phiArgVN = m_pComp->GetHeapPerSsaData(phiArgSsaNum)->m_vnPair.Get(vnk);
+                                phiArgVN = m_pComp->GetMemoryPerSsaData(phiArgSsaNum)->m_vnPair.Get(vnk);
                             }
                             else
                             {
@@ -2465,9 +2465,10 @@ ValueNum ValueNumStore::VNApplySelectorsAssignTypeCoerce(ValueNum elem, var_type
 
 //------------------------------------------------------------------------
 // VNApplySelectorsAssign: Compute the value number corresponding to "map" but with
-//    the element at "fieldSeq" updated to have type "elem"; this is the new heap
-//    value for an assignment of value "elem" into the heap at location "fieldSeq"
-//    that occurs in block "block" and has type "indType".
+//    the element at "fieldSeq" updated to have type "elem"; this is the new memory
+//    value for an assignment of value "elem" into the memory at location "fieldSeq"
+//    that occurs in block "block" and has type "indType" (so long as the selectors
+//    into that memory occupy disjoint locations, which is true for GcHeap).
 //
 // Arguments:
 //    vnk - Identifies whether to recurse to Conservative or Liberal value numbers
@@ -2478,7 +2479,7 @@ ValueNum ValueNumStore::VNApplySelectorsAssignTypeCoerce(ValueNum elem, var_type
 //    block - Block where the assignment occurs
 //
 // Return Value:
-//    The value number corresopnding to the heap after the assignment.
+//    The value number corresponding to memory after the assignment.
 
 ValueNum ValueNumStore::VNApplySelectorsAssign(
     ValueNumKind vnk, ValueNum map, FieldSeqNode* fieldSeq, ValueNum elem, var_types indType, BasicBlock* block)
@@ -2712,17 +2713,17 @@ ValueNum ValueNumStore::ExtendPtrVN(GenTreePtr opA, FieldSeqNode* fldSeq)
     return res;
 }
 
-void Compiler::fgValueNumberArrIndexAssign(CORINFO_CLASS_HANDLE elemTypeEq,
-                                           ValueNum             arrVN,
-                                           ValueNum             inxVN,
-                                           FieldSeqNode*        fldSeq,
-                                           ValueNum             rhsVN,
-                                           var_types            indType)
+ValueNum Compiler::fgValueNumberArrIndexAssign(CORINFO_CLASS_HANDLE elemTypeEq,
+                                               ValueNum             arrVN,
+                                               ValueNum             inxVN,
+                                               FieldSeqNode*        fldSeq,
+                                               ValueNum             rhsVN,
+                                               var_types            indType)
 {
     bool      invalidateArray      = false;
     ValueNum  elemTypeEqVN         = vnStore->VNForHandle(ssize_t(elemTypeEq), GTF_ICON_CLASS_HDL);
     var_types arrElemType          = DecodeElemType(elemTypeEq);
-    ValueNum  hAtArrType           = vnStore->VNForMapSelect(VNK_Liberal, TYP_REF, fgCurHeapVN, elemTypeEqVN);
+    ValueNum  hAtArrType           = vnStore->VNForMapSelect(VNK_Liberal, TYP_REF, fgCurMemoryVN[GcHeap], elemTypeEqVN);
     ValueNum  hAtArrTypeAtArr      = vnStore->VNForMapSelect(VNK_Liberal, TYP_REF, hAtArrType, arrVN);
     ValueNum  hAtArrTypeAtArrAtInx = vnStore->VNForMapSelect(VNK_Liberal, arrElemType, hAtArrTypeAtArr, inxVN);
 
@@ -2779,7 +2780,7 @@ void Compiler::fgValueNumberArrIndexAssign(CORINFO_CLASS_HANDLE elemTypeEq,
 #ifdef DEBUG
     if (verbose)
     {
-        printf("  hAtArrType " STR_VN "%x is MapSelect(curHeap(" STR_VN "%x), ", hAtArrType, fgCurHeapVN);
+        printf("  hAtArrType " STR_VN "%x is MapSelect(curGcHeap(" STR_VN "%x), ", hAtArrType, fgCurMemoryVN[GcHeap]);
 
         if (arrElemType == TYP_STRUCT)
         {
@@ -2809,14 +2810,11 @@ void Compiler::fgValueNumberArrIndexAssign(CORINFO_CLASS_HANDLE elemTypeEq,
         vnStore->vnDump(this, newValAtArrType);
         printf("\n");
 
-        printf("  fgCurHeapVN assigned:\n");
+        printf("  fgCurMemoryVN assigned:\n");
     }
 #endif // DEBUG
 
-    // bbHeapDef must be set to true for any block that Mutates the global Heap
-    assert(compCurBB->bbHeapDef);
-
-    fgCurHeapVN = vnStore->VNForMapStore(TYP_REF, fgCurHeapVN, elemTypeEqVN, newValAtArrType);
+    return vnStore->VNForMapStore(TYP_REF, fgCurMemoryVN[GcHeap], elemTypeEqVN, newValAtArrType);
 }
 
 ValueNum Compiler::fgValueNumberArrIndexVal(GenTreePtr tree, VNFuncApp* pFuncApp, ValueNum addrXvn)
@@ -2869,14 +2867,15 @@ ValueNum Compiler::fgValueNumberArrIndexVal(GenTreePtr           tree,
     else
     {
         ValueNum elemTypeEqVN    = vnStore->VNForHandle(ssize_t(elemTypeEq), GTF_ICON_CLASS_HDL);
-        ValueNum hAtArrType      = vnStore->VNForMapSelect(VNK_Liberal, TYP_REF, fgCurHeapVN, elemTypeEqVN);
+        ValueNum hAtArrType      = vnStore->VNForMapSelect(VNK_Liberal, TYP_REF, fgCurMemoryVN[GcHeap], elemTypeEqVN);
         ValueNum hAtArrTypeAtArr = vnStore->VNForMapSelect(VNK_Liberal, TYP_REF, hAtArrType, arrVN);
         ValueNum wholeElem       = vnStore->VNForMapSelect(VNK_Liberal, elemTyp, hAtArrTypeAtArr, inxVN);
 
 #ifdef DEBUG
         if (verbose)
         {
-            printf("  hAtArrType " STR_VN "%x is MapSelect(curHeap(" STR_VN "%x), ", hAtArrType, fgCurHeapVN);
+            printf("  hAtArrType " STR_VN "%x is MapSelect(curGcHeap(" STR_VN "%x), ", hAtArrType,
+                   fgCurMemoryVN[GcHeap]);
             if (elemTyp == TYP_STRUCT)
             {
                 printf("%s[]).\n", eeGetClassName(elemTypeEq));
@@ -2923,6 +2922,17 @@ ValueNum Compiler::fgValueNumberArrIndexVal(GenTreePtr           tree,
     return selectedElem;
 }
 
+ValueNum Compiler::fgValueNumberByrefExposedLoad(var_types type, ValueNum pointerVN)
+{
+    ValueNum memoryVN = fgCurMemoryVN[ByrefExposed];
+    // The memoization for VNFunc applications does not factor in the result type, so
+    // VNF_ByrefExposedLoad takes the loaded type as an explicit parameter.
+    ValueNum typeVN = vnStore->VNForIntCon(type);
+    ValueNum loadVN = vnStore->VNForFunc(type, VNF_ByrefExposedLoad, typeVN, vnStore->VNNormVal(pointerVN), memoryVN);
+
+    return loadVN;
+}
+
 var_types ValueNumStore::TypeOfVN(ValueNum vn)
 {
     if (vn == NoVN)
@@ -4200,10 +4210,10 @@ void Compiler::fgValueNumber()
     else
     {
         ValueNumPair noVnp;
-        // Make sure the heap SSA names have no value numbers.
-        for (unsigned i = 0; i < lvHeapNumSsaNames; i++)
+        // Make sure the memory SSA names have no value numbers.
+        for (unsigned i = 0; i < lvMemoryNumSsaNames; i++)
         {
-            lvHeapPerSsaData.GetRef(i).m_vnPair = noVnp;
+            lvMemoryPerSsaData.GetRef(i).m_vnPair = noVnp;
         }
         for (BasicBlock* blk = fgFirstBB; blk != nullptr; blk = blk->bbNext)
         {
@@ -4309,13 +4319,13 @@ void Compiler::fgValueNumber()
             ssaDef->m_defLoc.m_blk = fgFirstBB;
         }
     }
-    // Give "Heap" an initial value number (about which we know nothing).
-    ValueNum heapInitVal = vnStore->VNForFunc(TYP_REF, VNF_InitVal, vnStore->VNForIntCon(-1)); // Use -1 for the heap.
-    GetHeapPerSsaData(SsaConfig::FIRST_SSA_NUM)->m_vnPair.SetBoth(heapInitVal);
+    // Give memory an initial value number (about which we know nothing).
+    ValueNum memoryInitVal = vnStore->VNForFunc(TYP_REF, VNF_InitVal, vnStore->VNForIntCon(-1)); // Use -1 for memory.
+    GetMemoryPerSsaData(SsaConfig::FIRST_SSA_NUM)->m_vnPair.SetBoth(memoryInitVal);
 #ifdef DEBUG
     if (verbose)
     {
-        printf("Heap Initial Value in BB01 is: " STR_VN "%x\n", heapInitVal);
+        printf("Memory Initial Value in BB01 is: " STR_VN "%x\n", memoryInitVal);
     }
 #endif // DEBUG
 
@@ -4488,75 +4498,93 @@ void Compiler::fgValueNumberBlock(BasicBlock* blk)
         }
     }
 
-    // Now do the same for "Heap".
-    // Is there a phi for this block?
-    if (blk->bbHeapSsaPhiFunc == nullptr)
+    // Now do the same for each MemoryKind.
+    for (MemoryKind memoryKind : allMemoryKinds())
     {
-        fgCurHeapVN = GetHeapPerSsaData(blk->bbHeapSsaNumIn)->m_vnPair.GetLiberal();
-        assert(fgCurHeapVN != ValueNumStore::NoVN);
-    }
-    else
-    {
-        unsigned loopNum;
-        ValueNum newHeapVN;
-        if (optBlockIsLoopEntry(blk, &loopNum))
+        // Is there a phi for this block?
+        if (blk->bbMemorySsaPhiFunc[memoryKind] == nullptr)
         {
-            newHeapVN = fgHeapVNForLoopSideEffects(blk, loopNum);
+            fgCurMemoryVN[memoryKind] = GetMemoryPerSsaData(blk->bbMemorySsaNumIn[memoryKind])->m_vnPair.GetLiberal();
+            assert(fgCurMemoryVN[memoryKind] != ValueNumStore::NoVN);
         }
         else
         {
-            // Are all the VN's the same?
-            BasicBlock::HeapPhiArg* phiArgs = blk->bbHeapSsaPhiFunc;
-            assert(phiArgs != BasicBlock::EmptyHeapPhiDef);
-            // There should be > 1 args to a phi.
-            assert(phiArgs->m_nextArg != nullptr);
-            ValueNum phiAppVN = vnStore->VNForIntCon(phiArgs->GetSsaNum());
-            JITDUMP("  Building phi application: $%x = SSA# %d.\n", phiAppVN, phiArgs->GetSsaNum());
-            bool     allSame = true;
-            ValueNum sameVN  = GetHeapPerSsaData(phiArgs->GetSsaNum())->m_vnPair.GetLiberal();
-            if (sameVN == ValueNumStore::NoVN)
+            if ((memoryKind == ByrefExposed) && byrefStatesMatchGcHeapStates)
             {
-                allSame = false;
+                // The update for GcHeap will copy its result to ByrefExposed.
+                assert(memoryKind < GcHeap);
+                assert(blk->bbMemorySsaPhiFunc[memoryKind] == blk->bbMemorySsaPhiFunc[GcHeap]);
+                continue;
             }
-            phiArgs = phiArgs->m_nextArg;
-            while (phiArgs != nullptr)
+
+            unsigned loopNum;
+            ValueNum newMemoryVN;
+            if (optBlockIsLoopEntry(blk, &loopNum))
+            {
+                newMemoryVN = fgMemoryVNForLoopSideEffects(memoryKind, blk, loopNum);
+            }
+            else
             {
-                ValueNum phiArgVN = GetHeapPerSsaData(phiArgs->GetSsaNum())->m_vnPair.GetLiberal();
-                if (phiArgVN == ValueNumStore::NoVN || phiArgVN != sameVN)
+                // Are all the VN's the same?
+                BasicBlock::MemoryPhiArg* phiArgs = blk->bbMemorySsaPhiFunc[memoryKind];
+                assert(phiArgs != BasicBlock::EmptyMemoryPhiDef);
+                // There should be > 1 args to a phi.
+                assert(phiArgs->m_nextArg != nullptr);
+                ValueNum phiAppVN = vnStore->VNForIntCon(phiArgs->GetSsaNum());
+                JITDUMP("  Building phi application: $%x = SSA# %d.\n", phiAppVN, phiArgs->GetSsaNum());
+                bool     allSame = true;
+                ValueNum sameVN  = GetMemoryPerSsaData(phiArgs->GetSsaNum())->m_vnPair.GetLiberal();
+                if (sameVN == ValueNumStore::NoVN)
                 {
                     allSame = false;
                 }
+                phiArgs = phiArgs->m_nextArg;
+                while (phiArgs != nullptr)
+                {
+                    ValueNum phiArgVN = GetMemoryPerSsaData(phiArgs->GetSsaNum())->m_vnPair.GetLiberal();
+                    if (phiArgVN == ValueNumStore::NoVN || phiArgVN != sameVN)
+                    {
+                        allSame = false;
+                    }
 #ifdef DEBUG
-                ValueNum oldPhiAppVN = phiAppVN;
+                    ValueNum oldPhiAppVN = phiAppVN;
 #endif
-                unsigned phiArgSSANum   = phiArgs->GetSsaNum();
-                ValueNum phiArgSSANumVN = vnStore->VNForIntCon(phiArgSSANum);
-                JITDUMP("  Building phi application: $%x = SSA# %d.\n", phiArgSSANumVN, phiArgSSANum);
-                phiAppVN = vnStore->VNForFunc(TYP_REF, VNF_Phi, phiArgSSANumVN, phiAppVN);
-                JITDUMP("  Building phi application: $%x = phi($%x, $%x).\n", phiAppVN, phiArgSSANumVN, oldPhiAppVN);
-                phiArgs = phiArgs->m_nextArg;
-            }
-            if (allSame)
-            {
-                newHeapVN = sameVN;
+                    unsigned phiArgSSANum   = phiArgs->GetSsaNum();
+                    ValueNum phiArgSSANumVN = vnStore->VNForIntCon(phiArgSSANum);
+                    JITDUMP("  Building phi application: $%x = SSA# %d.\n", phiArgSSANumVN, phiArgSSANum);
+                    phiAppVN = vnStore->VNForFunc(TYP_REF, VNF_Phi, phiArgSSANumVN, phiAppVN);
+                    JITDUMP("  Building phi application: $%x = phi($%x, $%x).\n", phiAppVN, phiArgSSANumVN,
+                            oldPhiAppVN);
+                    phiArgs = phiArgs->m_nextArg;
+                }
+                if (allSame)
+                {
+                    newMemoryVN = sameVN;
+                }
+                else
+                {
+                    newMemoryVN =
+                        vnStore->VNForFunc(TYP_REF, VNF_PhiMemoryDef, vnStore->VNForHandle(ssize_t(blk), 0), phiAppVN);
+                }
             }
-            else
+            GetMemoryPerSsaData(blk->bbMemorySsaNumIn[memoryKind])->m_vnPair.SetLiberal(newMemoryVN);
+            fgCurMemoryVN[memoryKind] = newMemoryVN;
+            if ((memoryKind == GcHeap) && byrefStatesMatchGcHeapStates)
             {
-                newHeapVN =
-                    vnStore->VNForFunc(TYP_REF, VNF_PhiHeapDef, vnStore->VNForHandle(ssize_t(blk), 0), phiAppVN);
+                // Keep the CurMemoryVNs in sync
+                fgCurMemoryVN[ByrefExposed] = newMemoryVN;
             }
         }
-        GetHeapPerSsaData(blk->bbHeapSsaNumIn)->m_vnPair.SetLiberal(newHeapVN);
-        fgCurHeapVN = newHeapVN;
-    }
 #ifdef DEBUG
-    if (verbose)
-    {
-        printf("The SSA definition for heap (#%d) at start of BB%02u is ", blk->bbHeapSsaNumIn, blk->bbNum);
-        vnPrint(fgCurHeapVN, 1);
-        printf("\n");
-    }
+        if (verbose)
+        {
+            printf("The SSA definition for %s (#%d) at start of BB%02u is ", memoryKindNames[memoryKind],
+                   blk->bbMemorySsaNumIn[memoryKind], blk->bbNum);
+            vnPrint(fgCurMemoryVN[memoryKind], 1);
+            printf("\n");
+        }
 #endif // DEBUG
+    }
 
     // Now iterate over the remaining statements, and their trees.
     for (GenTreePtr stmt = firstNonPhi; stmt != nullptr; stmt = stmt->gtNext)
@@ -4592,15 +4620,30 @@ void Compiler::fgValueNumberBlock(BasicBlock* blk)
 #endif
     }
 
-    if (blk->bbHeapSsaNumOut != blk->bbHeapSsaNumIn)
+    for (MemoryKind memoryKind : allMemoryKinds())
     {
-        GetHeapPerSsaData(blk->bbHeapSsaNumOut)->m_vnPair.SetLiberal(fgCurHeapVN);
+        if ((memoryKind == GcHeap) && byrefStatesMatchGcHeapStates)
+        {
+            // The update to the shared SSA data will have already happened for ByrefExposed.
+            assert(memoryKind > ByrefExposed);
+            assert(blk->bbMemorySsaNumOut[memoryKind] == blk->bbMemorySsaNumOut[ByrefExposed]);
+            assert(GetMemoryPerSsaData(blk->bbMemorySsaNumOut[memoryKind])->m_vnPair.GetLiberal() ==
+                   fgCurMemoryVN[memoryKind]);
+            continue;
+        }
+
+        if (blk->bbMemorySsaNumOut[memoryKind] != blk->bbMemorySsaNumIn[memoryKind])
+        {
+            GetMemoryPerSsaData(blk->bbMemorySsaNumOut[memoryKind])->m_vnPair.SetLiberal(fgCurMemoryVN[memoryKind]);
+        }
     }
 
     compCurBB = nullptr;
 }
 
-ValueNum Compiler::fgHeapVNForLoopSideEffects(BasicBlock* entryBlock, unsigned innermostLoopNum)
+ValueNum Compiler::fgMemoryVNForLoopSideEffects(MemoryKind  memoryKind,
+                                                BasicBlock* entryBlock,
+                                                unsigned    innermostLoopNum)
 {
     // "loopNum" is the innermost loop for which "blk" is the entry; find the outermost one.
     assert(innermostLoopNum != BasicBlock::NOT_IN_LOOP);
@@ -4619,27 +4662,27 @@ ValueNum Compiler::fgHeapVNForLoopSideEffects(BasicBlock* entryBlock, unsigned i
 #ifdef DEBUG
     if (verbose)
     {
-        printf("Computing heap state for block BB%02u, entry block for loops %d to %d:\n", entryBlock->bbNum,
-               innermostLoopNum, loopNum);
+        printf("Computing %s state for block BB%02u, entry block for loops %d to %d:\n", memoryKindNames[memoryKind],
+               entryBlock->bbNum, innermostLoopNum, loopNum);
     }
 #endif // DEBUG
 
-    // If this loop has heap havoc effects, just use a new, unique VN.
-    if (optLoopTable[loopNum].lpLoopHasHeapHavoc)
+    // If this loop has memory havoc effects, just use a new, unique VN.
+    if (optLoopTable[loopNum].lpLoopHasMemoryHavoc[memoryKind])
     {
         ValueNum res = vnStore->VNForExpr(entryBlock, TYP_REF);
 #ifdef DEBUG
         if (verbose)
         {
-            printf("  Loop %d has heap havoc effect; heap state is new fresh $%x.\n", loopNum, res);
+            printf("  Loop %d has memory havoc effect; heap state is new fresh $%x.\n", loopNum, res);
         }
 #endif // DEBUG
         return res;
     }
 
     // Otherwise, find the predecessors of the entry block that are not in the loop.
-    // If there is only one such, use its heap value as the "base."  If more than one,
-    // use a new unique heap VN.
+    // If there is only one such, use its memory value as the "base."  If more than one,
+    // use a new unique VN.
     BasicBlock* nonLoopPred          = nullptr;
     bool        multipleNonLoopPreds = false;
     for (flowList* pred = BlockPredsWithEH(entryBlock); pred != nullptr; pred = pred->flNext)
@@ -4671,122 +4714,187 @@ ValueNum Compiler::fgHeapVNForLoopSideEffects(BasicBlock* entryBlock, unsigned i
 #ifdef DEBUG
         if (verbose)
         {
-            printf("  Therefore, heap state is new, fresh $%x.\n", res);
+            printf("  Therefore, memory state is new, fresh $%x.\n", res);
         }
 #endif // DEBUG
         return res;
     }
     // Otherwise, there is a single non-loop pred.
     assert(nonLoopPred != nullptr);
-    // What is it's heap post-state?
-    ValueNum newHeapVN = GetHeapPerSsaData(nonLoopPred->bbHeapSsaNumOut)->m_vnPair.GetLiberal();
-    assert(newHeapVN !=
+    // What is its memory post-state?
+    ValueNum newMemoryVN = GetMemoryPerSsaData(nonLoopPred->bbMemorySsaNumOut[memoryKind])->m_vnPair.GetLiberal();
+    assert(newMemoryVN !=
            ValueNumStore::NoVN); // We must have processed the single non-loop pred before reaching the loop entry.
 
 #ifdef DEBUG
     if (verbose)
     {
-        printf("  Init heap state is $%x, with new, fresh VN at:\n", newHeapVN);
+        printf("  Init %s state is $%x, with new, fresh VN at:\n", memoryKindNames[memoryKind], newMemoryVN);
     }
 #endif // DEBUG
     // Modify "base" by setting all the modified fields/field maps/array maps to unknown values.
-    // First the fields/field maps.
-
-    Compiler::LoopDsc::FieldHandleSet* fieldsMod = optLoopTable[loopNum].lpFieldsModified;
-    if (fieldsMod != nullptr)
+    // These annotations apply specifically to the GcHeap, where we disambiguate across such stores.
+    if (memoryKind == GcHeap)
     {
-        for (Compiler::LoopDsc::FieldHandleSet::KeyIterator ki = fieldsMod->Begin(); !ki.Equal(fieldsMod->End()); ++ki)
+        // First the fields/field maps.
+        Compiler::LoopDsc::FieldHandleSet* fieldsMod = optLoopTable[loopNum].lpFieldsModified;
+        if (fieldsMod != nullptr)
         {
-            CORINFO_FIELD_HANDLE fldHnd   = ki.Get();
-            ValueNum             fldHndVN = vnStore->VNForHandle(ssize_t(fldHnd), GTF_ICON_FIELD_HDL);
+            for (Compiler::LoopDsc::FieldHandleSet::KeyIterator ki = fieldsMod->Begin(); !ki.Equal(fieldsMod->End());
+                 ++ki)
+            {
+                CORINFO_FIELD_HANDLE fldHnd   = ki.Get();
+                ValueNum             fldHndVN = vnStore->VNForHandle(ssize_t(fldHnd), GTF_ICON_FIELD_HDL);
 
 #ifdef DEBUG
-            if (verbose)
-            {
-                const char* modName;
-                const char* fldName = eeGetFieldName(fldHnd, &modName);
-                printf("     VNForHandle(Fseq[%s]) is " STR_VN "%x\n", fldName, fldHndVN);
+                if (verbose)
+                {
+                    const char* modName;
+                    const char* fldName = eeGetFieldName(fldHnd, &modName);
+                    printf("     VNForHandle(Fseq[%s]) is " STR_VN "%x\n", fldName, fldHndVN);
 
-                printf("  fgCurHeapVN assigned:\n");
-            }
+                    printf("  fgCurMemoryVN assigned:\n");
+                }
 #endif // DEBUG
 
-            newHeapVN = vnStore->VNForMapStore(TYP_REF, newHeapVN, fldHndVN, vnStore->VNForExpr(entryBlock, TYP_REF));
+                newMemoryVN =
+                    vnStore->VNForMapStore(TYP_REF, newMemoryVN, fldHndVN, vnStore->VNForExpr(entryBlock, TYP_REF));
+            }
         }
-    }
-    // Now do the array maps.
-    Compiler::LoopDsc::ClassHandleSet* elemTypesMod = optLoopTable[loopNum].lpArrayElemTypesModified;
-    if (elemTypesMod != nullptr)
-    {
-        for (Compiler::LoopDsc::ClassHandleSet::KeyIterator ki = elemTypesMod->Begin(); !ki.Equal(elemTypesMod->End());
-             ++ki)
+        // Now do the array maps.
+        Compiler::LoopDsc::ClassHandleSet* elemTypesMod = optLoopTable[loopNum].lpArrayElemTypesModified;
+        if (elemTypesMod != nullptr)
         {
-            CORINFO_CLASS_HANDLE elemClsHnd = ki.Get();
+            for (Compiler::LoopDsc::ClassHandleSet::KeyIterator ki = elemTypesMod->Begin();
+                 !ki.Equal(elemTypesMod->End()); ++ki)
+            {
+                CORINFO_CLASS_HANDLE elemClsHnd = ki.Get();
 
 #ifdef DEBUG
-            if (verbose)
-            {
-                var_types elemTyp = DecodeElemType(elemClsHnd);
-                if (varTypeIsStruct(elemTyp))
-                {
-                    printf("     Array map %s[]\n", eeGetClassName(elemClsHnd));
-                }
-                else
+                if (verbose)
                 {
-                    printf("     Array map %s[]\n", varTypeName(elemTyp));
+                    var_types elemTyp = DecodeElemType(elemClsHnd);
+                    if (varTypeIsStruct(elemTyp))
+                    {
+                        printf("     Array map %s[]\n", eeGetClassName(elemClsHnd));
+                    }
+                    else
+                    {
+                        printf("     Array map %s[]\n", varTypeName(elemTyp));
+                    }
+                    printf("  fgCurMemoryVN assigned:\n");
                 }
-                printf("  fgCurHeapVN assigned:\n");
-            }
 #endif // DEBUG
 
-            ValueNum elemTypeVN = vnStore->VNForHandle(ssize_t(elemClsHnd), GTF_ICON_CLASS_HDL);
-            ValueNum uniqueVN   = vnStore->VNForExpr(entryBlock, TYP_REF);
-            newHeapVN           = vnStore->VNForMapStore(TYP_REF, newHeapVN, elemTypeVN, uniqueVN);
+                ValueNum elemTypeVN = vnStore->VNForHandle(ssize_t(elemClsHnd), GTF_ICON_CLASS_HDL);
+                ValueNum uniqueVN   = vnStore->VNForExpr(entryBlock, TYP_REF);
+                newMemoryVN         = vnStore->VNForMapStore(TYP_REF, newMemoryVN, elemTypeVN, uniqueVN);
+            }
         }
     }
+    else
+    {
+        // If there were any fields/elements modified, this should have been recorded as havoc
+        // for ByrefExposed.
+        assert(memoryKind == ByrefExposed);
+        assert((optLoopTable[loopNum].lpFieldsModified == nullptr) ||
+               optLoopTable[loopNum].lpLoopHasMemoryHavoc[memoryKind]);
+        assert((optLoopTable[loopNum].lpArrayElemTypesModified == nullptr) ||
+               optLoopTable[loopNum].lpLoopHasMemoryHavoc[memoryKind]);
+    }
 
 #ifdef DEBUG
     if (verbose)
     {
-        printf("  Final heap state is $%x.\n", newHeapVN);
+        printf("  Final %s state is $%x.\n", memoryKindNames[memoryKind], newMemoryVN);
     }
 #endif // DEBUG
-    return newHeapVN;
+    return newMemoryVN;
 }
 
-void Compiler::fgMutateHeap(GenTreePtr tree DEBUGARG(const char* msg))
+void Compiler::fgMutateGcHeap(GenTreePtr tree DEBUGARG(const char* msg))
 {
-    // bbHeapDef must be set to true for any block that Mutates the global Heap
-    assert(compCurBB->bbHeapDef);
+    // Update the current memory VN, and if we're tracking the heap SSA # caused by this node, record it.
+    recordGcHeapStore(tree, vnStore->VNForExpr(compCurBB, TYP_REF) DEBUGARG(msg));
+}
 
-    fgCurHeapVN = vnStore->VNForExpr(compCurBB, TYP_REF);
+void Compiler::fgMutateAddressExposedLocal(GenTreePtr tree DEBUGARG(const char* msg))
+{
+    // Update the current ByrefExposed VN, and if we're tracking the heap SSA # caused by this node, record it.
+    recordAddressExposedLocalStore(tree, vnStore->VNForExpr(compCurBB) DEBUGARG(msg));
+}
 
-    // If we're tracking the heap SSA # caused by this node, record it.
-    fgValueNumberRecordHeapSsa(tree);
+void Compiler::recordGcHeapStore(GenTreePtr curTree, ValueNum gcHeapVN DEBUGARG(const char* msg))
+{
+    // bbMemoryDef must include GcHeap for any block that mutates the GC Heap
+    // and GC Heap mutations are also ByrefExposed mutations
+    assert((compCurBB->bbMemoryDef & memoryKindSet(GcHeap, ByrefExposed)) == memoryKindSet(GcHeap, ByrefExposed));
+    fgCurMemoryVN[GcHeap] = gcHeapVN;
+
+    if (byrefStatesMatchGcHeapStates)
+    {
+        // Since GcHeap and ByrefExposed share SSA nodes, they need to share
+        // value numbers too.
+        fgCurMemoryVN[ByrefExposed] = gcHeapVN;
+    }
+    else
+    {
+        // GcHeap and ByrefExposed have different defnums and VNs.  We conservatively
+        // assume that this GcHeap store may alias any byref load/store, so don't
+        // bother trying to record the map/select stuff, and instead just an opaque VN
+        // for ByrefExposed
+        fgCurMemoryVN[ByrefExposed] = vnStore->VNForExpr(compCurBB);
+    }
 
 #ifdef DEBUG
     if (verbose)
     {
-        printf("  fgCurHeapVN assigned by %s at ", msg);
-        Compiler::printTreeID(tree);
-        printf(" to new unique VN: " STR_VN "%x.\n", fgCurHeapVN);
+        printf("  fgCurMemoryVN[GcHeap] assigned by %s at ", msg);
+        Compiler::printTreeID(curTree);
+        printf(" to VN: " STR_VN "%x.\n", gcHeapVN);
     }
 #endif // DEBUG
+
+    // If byrefStatesMatchGcHeapStates is true, then since GcHeap and ByrefExposed share
+    // their SSA map entries, the below will effectively update both.
+    fgValueNumberRecordMemorySsa(GcHeap, curTree);
 }
 
-void Compiler::fgValueNumberRecordHeapSsa(GenTreePtr tree)
+void Compiler::recordAddressExposedLocalStore(GenTreePtr curTree, ValueNum memoryVN DEBUGARG(const char* msg))
+{
+    // This should only happen if GcHeap and ByrefExposed are being tracked separately;
+    // otherwise we'd go through recordGcHeapStore.
+    assert(!byrefStatesMatchGcHeapStates);
+
+    // bbMemoryDef must include ByrefExposed for any block that mutates an address-exposed local
+    assert((compCurBB->bbMemoryDef & memoryKindSet(ByrefExposed)) != 0);
+    fgCurMemoryVN[ByrefExposed] = memoryVN;
+
+#ifdef DEBUG
+    if (verbose)
+    {
+        printf("  fgCurMemoryVN[ByrefExposed] assigned by %s at ", msg);
+        Compiler::printTreeID(curTree);
+        printf(" to VN: " STR_VN "%x.\n", memoryVN);
+    }
+#endif // DEBUG
+
+    fgValueNumberRecordMemorySsa(ByrefExposed, curTree);
+}
+
+void Compiler::fgValueNumberRecordMemorySsa(MemoryKind memoryKind, GenTreePtr tree)
 {
     unsigned ssaNum;
-    if (GetHeapSsaMap()->Lookup(tree, &ssaNum))
+    if (GetMemorySsaMap(memoryKind)->Lookup(tree, &ssaNum))
     {
-        GetHeapPerSsaData(ssaNum)->m_vnPair.SetLiberal(fgCurHeapVN);
+        GetMemoryPerSsaData(ssaNum)->m_vnPair.SetLiberal(fgCurMemoryVN[memoryKind]);
 #ifdef DEBUG
         if (verbose)
         {
             printf("Node ");
             Compiler::printTreeID(tree);
-            printf(" sets heap SSA # %d to VN $%x: ", ssaNum, fgCurHeapVN);
-            vnStore->vnDump(this, fgCurHeapVN);
+            printf(" sets %s SSA # %d to VN $%x: ", memoryKindNames[memoryKind], ssaNum, fgCurMemoryVN[memoryKind]);
+            vnStore->vnDump(this, fgCurMemoryVN[memoryKind]);
             printf("\n");
         }
 #endif // DEBUG
@@ -4890,8 +4998,8 @@ void Compiler::fgValueNumberBlockAssignment(GenTreePtr tree, bool evalAsgLhsInd)
     GenTree* lhs = tree->gtGetOp1();
     GenTree* rhs = tree->gtGetOp2();
 #ifdef DEBUG
-    // Sometimes we query the heap ssa map, and need a dummy location for the ignored result.
-    unsigned heapSsaNum;
+    // Sometimes we query the memory ssa map in an assertion, and need a dummy location for the ignored result.
+    unsigned memorySsaNum;
 #endif
 
     if (tree->OperIsInitBlkOp())
@@ -4902,8 +5010,8 @@ void Compiler::fgValueNumberBlockAssignment(GenTreePtr tree, bool evalAsgLhsInd)
         if (tree->DefinesLocal(this, &lclVarTree, &isEntire))
         {
             assert(lclVarTree->gtFlags & GTF_VAR_DEF);
-            // Should not have been recorded as updating the heap.
-            assert(!GetHeapSsaMap()->Lookup(tree, &heapSsaNum));
+            // Should not have been recorded as updating the GC heap.
+            assert(!GetMemorySsaMap(GcHeap)->Lookup(tree, &memorySsaNum));
 
             unsigned lclNum = lclVarTree->GetLclNum();
 
@@ -4911,6 +5019,9 @@ void Compiler::fgValueNumberBlockAssignment(GenTreePtr tree, bool evalAsgLhsInd)
             // SSA names in which to store VN's on defs.  We'll yield unique VN's when we read from them.
             if (!fgExcludeFromSsa(lclNum))
             {
+                // Should not have been recorded as updating ByrefExposed.
+                assert(!GetMemorySsaMap(ByrefExposed)->Lookup(tree, &memorySsaNum));
+
                 unsigned lclDefSsaNum = GetSsaNumForLocalVarDef(lclVarTree);
 
                 ValueNum   initBlkVN = ValueNumStore::NoVN;
@@ -4941,12 +5052,16 @@ void Compiler::fgValueNumberBlockAssignment(GenTreePtr tree, bool evalAsgLhsInd)
                 }
 #endif // DEBUG
             }
+            else if (lvaVarAddrExposed(lclVarTree->gtLclNum))
+            {
+                fgMutateAddressExposedLocal(tree DEBUGARG("INITBLK - address-exposed local"));
+            }
         }
         else
         {
-            // For now, arbitrary side effect on Heap.
+            // For now, arbitrary side effect on GcHeap/ByrefExposed.
             // TODO-CQ: Why not be complete, and get this case right?
-            fgMutateHeap(tree DEBUGARG("INITBLK - non local"));
+            fgMutateGcHeap(tree DEBUGARG("INITBLK - non local"));
         }
         // Initblock's are of type void.  Give them the void "value" -- they may occur in argument lists, which we
         // want to be able to give VN's to.
@@ -4956,7 +5071,7 @@ void Compiler::fgValueNumberBlockAssignment(GenTreePtr tree, bool evalAsgLhsInd)
     {
         assert(tree->OperIsCopyBlkOp());
         // TODO-Cleanup: We should factor things so that we uniformly rely on "PtrTo" VN's, and
-        // the heap cases can be shared with assignments.
+        // the memory cases can be shared with assignments.
         GenTreeLclVarCommon* lclVarTree = nullptr;
         bool                 isEntire   = false;
         // Note that we don't care about exceptions here, since we're only using the values
@@ -4964,14 +5079,17 @@ void Compiler::fgValueNumberBlockAssignment(GenTreePtr tree, bool evalAsgLhsInd)
 
         if (tree->DefinesLocal(this, &lclVarTree, &isEntire))
         {
-            // Should not have been recorded as updating the heap.
-            assert(!GetHeapSsaMap()->Lookup(tree, &heapSsaNum));
+            // Should not have been recorded as updating the GC heap.
+            assert(!GetMemorySsaMap(GcHeap)->Lookup(tree, &memorySsaNum));
 
             unsigned      lhsLclNum = lclVarTree->GetLclNum();
             FieldSeqNode* lhsFldSeq = nullptr;
             // If it's excluded from SSA, don't need to do anything.
             if (!fgExcludeFromSsa(lhsLclNum))
             {
+                // Should not have been recorded as updating ByrefExposed.
+                assert(!GetMemorySsaMap(ByrefExposed)->Lookup(tree, &memorySsaNum));
+
                 unsigned lclDefSsaNum = GetSsaNumForLocalVarDef(lclVarTree);
 
                 if (lhs->IsLocalExpr(this, &lclVarTree, &lhsFldSeq) ||
@@ -5082,10 +5200,10 @@ void Compiler::fgValueNumberBlockAssignment(GenTreePtr tree, bool evalAsgLhsInd)
 
                             if (fldSeqForStaticVar != FieldSeqStore::NotAField())
                             {
-                                // We model statics as indices into the heap variable.
+                                // We model statics as indices into GcHeap (which is a subset of ByrefExposed).
                                 ValueNum selectedStaticVar;
                                 size_t   structSize = 0;
-                                selectedStaticVar   = vnStore->VNApplySelectors(VNK_Liberal, fgCurHeapVN,
+                                selectedStaticVar   = vnStore->VNApplySelectors(VNK_Liberal, fgCurMemoryVN[GcHeap],
                                                                               fldSeqForStaticVar, &structSize);
                                 selectedStaticVar =
                                     vnStore->VNApplySelectorsTypeCheck(selectedStaticVar, indType, structSize);
@@ -5162,12 +5280,16 @@ void Compiler::fgValueNumberBlockAssignment(GenTreePtr tree, bool evalAsgLhsInd)
                 }
 #endif // DEBUG
             }
+            else if (lvaVarAddrExposed(lhsLclNum))
+            {
+                fgMutateAddressExposedLocal(tree DEBUGARG("COPYBLK - address-exposed local"));
+            }
         }
         else
         {
-            // For now, arbitrary side effect on Heap.
+            // For now, arbitrary side effect on GcHeap/ByrefExposed.
             // TODO-CQ: Why not be complete, and get this case right?
-            fgMutateHeap(tree DEBUGARG("COPYBLK - non local"));
+            fgMutateGcHeap(tree DEBUGARG("COPYBLK - non local"));
         }
         // Copyblock's are of type void.  Give them the void "value" -- they may occur in argument lists, which we want
         // to be able to give VN's to.
@@ -5223,8 +5345,22 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
 
                     if (lcl->gtSsaNum == SsaConfig::RESERVED_SSA_NUM)
                     {
-                        // Not an SSA variable.  Assign each occurrence a new, unique, VN.
-                        lcl->gtVNPair.SetBoth(vnStore->VNForExpr(compCurBB, lcl->TypeGet()));
+                        // Not an SSA variable.
+
+                        if (lvaVarAddrExposed(lclNum))
+                        {
+                            // Address-exposed locals are part of ByrefExposed.
+                            ValueNum addrVN = vnStore->VNForFunc(TYP_BYREF, VNF_PtrToLoc, vnStore->VNForIntCon(lclNum),
+                                                                 vnStore->VNForFieldSeq(nullptr));
+                            ValueNum loadVN = fgValueNumberByrefExposedLoad(typ, addrVN);
+
+                            lcl->gtVNPair.SetBoth(loadVN);
+                        }
+                        else
+                        {
+                            // Assign odd cases a new, unique, VN.
+                            lcl->gtVNPair.SetBoth(vnStore->VNForExpr(compCurBB, lcl->TypeGet()));
+                        }
                     }
                     else
                     {
@@ -5366,11 +5502,11 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
 
                     if (isVolatile)
                     {
-                        // For Volatile indirection, first mutate the global heap
-                        fgMutateHeap(tree DEBUGARG("GTF_FLD_VOLATILE - read"));
+                        // For Volatile indirection, first mutate GcHeap/ByrefExposed
+                        fgMutateGcHeap(tree DEBUGARG("GTF_FLD_VOLATILE - read"));
                     }
 
-                    // We just mutate the heap if isVolatile is true, and then do the read as normal.
+                    // We just mutate GcHeap/ByrefExposed if isVolatile is true, and then do the read as normal.
                     //
                     // This allows:
                     //   1: read s;
@@ -5399,13 +5535,13 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
                     else
                     {
                         // This is a reference to heap memory.
-                        // We model statics as indices into the heap variable.
+                        // We model statics as indices into GcHeap (which is a subset of ByrefExposed).
 
                         FieldSeqNode* fldSeqForStaticVar =
                             GetFieldSeqStore()->CreateSingleton(tree->gtClsVar.gtClsVarHnd);
                         size_t structSize = 0;
-                        selectedStaticVar =
-                            vnStore->VNApplySelectors(VNK_Liberal, fgCurHeapVN, fldSeqForStaticVar, &structSize);
+                        selectedStaticVar = vnStore->VNApplySelectors(VNK_Liberal, fgCurMemoryVN[GcHeap],
+                                                                      fldSeqForStaticVar, &structSize);
                         selectedStaticVar =
                             vnStore->VNApplySelectorsTypeCheck(selectedStaticVar, tree->TypeGet(), structSize);
 
@@ -5429,8 +5565,8 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
                 break;
 
             case GT_MEMORYBARRIER: // Leaf
-                // For MEMORYBARRIER add an arbitrary side effect on Heap.
-                fgMutateHeap(tree DEBUGARG("MEMORYBARRIER"));
+                // For MEMORYBARRIER add an arbitrary side effect on GcHeap/ByrefExposed.
+                fgMutateGcHeap(tree DEBUGARG("MEMORYBARRIER"));
                 break;
 
             // These do not represent values.
@@ -5462,8 +5598,8 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
     else if (GenTree::OperIsSimple(oper))
     {
 #ifdef DEBUG
-        // Sometimes we query the heap ssa map, and need a dummy location for the ignored result.
-        unsigned heapSsaNum;
+        // Sometimes we query the memory ssa map in an assertion, and need a dummy location for the ignored result.
+        unsigned memorySsaNum;
 #endif
 
         if (GenTree::OperIsAssignment(oper) && !varTypeIsStruct(tree))
@@ -5482,7 +5618,7 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
                 // If the LHS is an IND, we didn't evaluate it when we visited it previously.
                 // But we didn't know that the parent was an op=.  We do now, so go back and evaluate it.
                 // (We actually check if the effective val is the IND.  We will have evaluated any non-last
-                // args of an LHS comma already -- including their heap effects.)
+                // args of an LHS comma already -- including their memory effects.)
                 GenTreePtr lhsVal = lhs->gtEffectiveVal(/*commaOnly*/ true);
                 if (lhsVal->OperIsIndir() || (lhsVal->OperGet() == GT_CLS_VAR))
                 {
@@ -5567,11 +5703,14 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
                     GenTreeLclVarCommon* lcl          = lhs->AsLclVarCommon();
                     unsigned             lclDefSsaNum = GetSsaNumForLocalVarDef(lcl);
 
-                    // Should not have been recorded as updating the heap.
-                    assert(!GetHeapSsaMap()->Lookup(tree, &heapSsaNum));
+                    // Should not have been recorded as updating the GC heap.
+                    assert(!GetMemorySsaMap(GcHeap)->Lookup(tree, &memorySsaNum));
 
                     if (lclDefSsaNum != SsaConfig::RESERVED_SSA_NUM)
                     {
+                        // Should not have been recorded as updating ByrefExposed mem.
+                        assert(!GetMemorySsaMap(ByrefExposed)->Lookup(tree, &memorySsaNum));
+
                         assert(rhsVNPair.GetLiberal() != ValueNumStore::NoVN);
 
                         lhs->gtVNPair                                                 = rhsVNPair;
@@ -5591,6 +5730,16 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
                         }
 #endif // DEBUG
                     }
+                    else if (lvaVarAddrExposed(lcl->gtLclNum))
+                    {
+                        // We could use MapStore here and MapSelect on reads of address-exposed locals
+                        // (using the local nums as selectors) to get e.g. propagation of values
+                        // through address-taken locals in regions of code with no calls or byref
+                        // writes.
+                        // For now, just use a new opaque VN.
+                        ValueNum heapVN = vnStore->VNForExpr(compCurBB);
+                        recordAddressExposedLocalStore(tree, heapVN DEBUGARG("local assign"));
+                    }
 #ifdef DEBUG
                     else
                     {
@@ -5598,7 +5747,8 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
                         {
                             JITDUMP("Tree ");
                             Compiler::printTreeID(tree);
-                            printf(" assigns to local var V%02u; excluded from SSA, so value not tracked.\n",
+                            printf(" assigns to non-address-taken local var V%02u; excluded from SSA, so value not "
+                                   "tracked.\n",
                                    lcl->GetLclNum());
                         }
                     }
@@ -5610,8 +5760,8 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
                     GenTreeLclFld* lclFld       = lhs->AsLclFld();
                     unsigned       lclDefSsaNum = GetSsaNumForLocalVarDef(lclFld);
 
-                    // Should not have been recorded as updating the heap.
-                    assert(!GetHeapSsaMap()->Lookup(tree, &heapSsaNum));
+                    // Should not have been recorded as updating the GC heap.
+                    assert(!GetMemorySsaMap(GcHeap)->Lookup(tree, &memorySsaNum));
 
                     if (lclDefSsaNum != SsaConfig::RESERVED_SSA_NUM)
                     {
@@ -5664,6 +5814,15 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
                         }
 #endif // DEBUG
                     }
+                    else if (lvaVarAddrExposed(lclFld->gtLclNum))
+                    {
+                        // This side-effects ByrefExposed.  Just use a new opaque VN.
+                        // As with GT_LCL_VAR, we could probably use MapStore here and MapSelect at corresponding
+                        // loads, but to do so would have to identify the subset of address-exposed locals
+                        // whose fields can be disambiguated.
+                        ValueNum heapVN = vnStore->VNForExpr(compCurBB);
+                        recordAddressExposedLocalStore(tree, heapVN DEBUGARG("local field assign"));
+                    }
                 }
                 break;
 
@@ -5678,8 +5837,8 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
 
                     if (isVolatile)
                     {
-                        // For Volatile store indirection, first mutate the global heap
-                        fgMutateHeap(lhs DEBUGARG("GTF_IND_VOLATILE - store"));
+                        // For Volatile store indirection, first mutate GcHeap/ByrefExposed
+                        fgMutateGcHeap(lhs DEBUGARG("GTF_IND_VOLATILE - store"));
                         tree->gtVNPair.SetBoth(vnStore->VNForExpr(compCurBB, lhs->TypeGet()));
                     }
 
@@ -5797,6 +5956,17 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
                                 }
 #endif // DEBUG
                             }
+                            else if (lvaVarAddrExposed(lclNum))
+                            {
+                                // Need to record the effect on ByrefExposed.
+                                // We could use MapStore here and MapSelect on reads of address-exposed locals
+                                // (using the local nums as selectors) to get e.g. propagation of values
+                                // through address-taken locals in regions of code with no calls or byref
+                                // writes.
+                                // For now, just use a new opaque VN.
+                                ValueNum heapVN = vnStore->VNForExpr(compCurBB);
+                                recordAddressExposedLocalStore(tree, heapVN DEBUGARG("PtrToLoc indir"));
+                            }
                         }
                     }
 
@@ -5832,9 +6002,9 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
                             }
 #endif // DEBUG
 
-                            fgValueNumberArrIndexAssign(elemTypeEq, arrVN, inxVN, fldSeq, rhsVNPair.GetLiberal(),
-                                                        lhs->TypeGet());
-                            fgValueNumberRecordHeapSsa(tree);
+                            ValueNum heapVN = fgValueNumberArrIndexAssign(elemTypeEq, arrVN, inxVN, fldSeq,
+                                                                          rhsVNPair.GetLiberal(), lhs->TypeGet());
+                            recordGcHeapStore(tree, heapVN DEBUGARG("Array element assignment"));
                         }
                         // It may be that we haven't parsed it yet.  Try.
                         else if (lhs->gtFlags & GTF_IND_ARR_INDEX)
@@ -5851,7 +6021,7 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
                             arg->ParseArrayAddress(this, &arrInfo, &arr, &inxVN, &fldSeq);
                             if (arr == nullptr)
                             {
-                                fgMutateHeap(tree DEBUGARG("assignment to unparseable array expression"));
+                                fgMutateGcHeap(tree DEBUGARG("assignment to unparseable array expression"));
                                 return;
                             }
                             // Otherwise, parsing succeeded.
@@ -5869,15 +6039,15 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
                                 fldSeq = GetFieldSeqStore()->Append(fldSeq, zeroOffsetFldSeq);
                             }
 
-                            fgValueNumberArrIndexAssign(elemTypeEq, arrVN, inxVN, fldSeq, rhsVNPair.GetLiberal(),
-                                                        lhs->TypeGet());
-                            fgValueNumberRecordHeapSsa(tree);
+                            ValueNum heapVN = fgValueNumberArrIndexAssign(elemTypeEq, arrVN, inxVN, fldSeq,
+                                                                          rhsVNPair.GetLiberal(), lhs->TypeGet());
+                            recordGcHeapStore(tree, heapVN DEBUGARG("assignment to unparseable array expression"));
                         }
                         else if (arg->IsFieldAddr(this, &obj, &staticOffset, &fldSeq))
                         {
                             if (fldSeq == FieldSeqStore::NotAField())
                             {
-                                fgMutateHeap(tree DEBUGARG("NotAField"));
+                                fgMutateGcHeap(tree DEBUGARG("NotAField"));
                             }
                             else
                             {
@@ -5892,8 +6062,8 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
                                     assert(staticOffset == nullptr);
                                 }
 #endif // DEBUG
-                                // Get the first (instance or static) field from field seq.  Heap[field] will yield the
-                                // "field map".
+                                // Get the first (instance or static) field from field seq.  GcHeap[field] will yield
+                                // the "field map".
                                 if (fldSeq->IsFirstElemFieldSeq())
                                 {
                                     fldSeq = fldSeq->m_next;
@@ -5906,7 +6076,8 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
 
                                 // The final field in the sequence will need to match the 'indType'
                                 var_types indType = lhs->TypeGet();
-                                ValueNum fldMapVN = vnStore->VNApplySelectors(VNK_Liberal, fgCurHeapVN, firstFieldOnly);
+                                ValueNum  fldMapVN =
+                                    vnStore->VNApplySelectors(VNK_Liberal, fgCurMemoryVN[GcHeap], firstFieldOnly);
 
                                 // The type of the field is "struct" if there are more fields in the sequence,
                                 // otherwise it is the type returned from VNApplySelectors above.
@@ -5962,8 +6133,8 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
                                                                             storeVal, indType, compCurBB);
                                     }
 
-                                    newFldMapVN = vnStore->VNApplySelectorsAssign(VNK_Liberal, fgCurHeapVN, fldSeq,
-                                                                                  storeVal, indType, compCurBB);
+                                    newFldMapVN = vnStore->VNApplySelectorsAssign(VNK_Liberal, fgCurMemoryVN[GcHeap],
+                                                                                  fldSeq, storeVal, indType, compCurBB);
                                 }
 
                                 // It is not strictly necessary to set the lhs value number,
@@ -5973,26 +6144,47 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
 #ifdef DEBUG
                                 if (verbose)
                                 {
-                                    printf("  fgCurHeapVN assigned:\n");
+                                    printf("  fgCurMemoryVN assigned:\n");
                                 }
 #endif // DEBUG
-                                // bbHeapDef must be set to true for any block that Mutates the global Heap
-                                assert(compCurBB->bbHeapDef);
+                                // bbMemoryDef must include GcHeap for any block that mutates the GC heap
+                                assert((compCurBB->bbMemoryDef & memoryKindSet(GcHeap)) != 0);
 
-                                // Update the field map for firstField in Heap to this new value.
-                                fgCurHeapVN = vnStore->VNApplySelectorsAssign(VNK_Liberal, fgCurHeapVN, firstFieldOnly,
-                                                                              newFldMapVN, indType, compCurBB);
+                                // Update the field map for firstField in GcHeap to this new value.
+                                ValueNum heapVN =
+                                    vnStore->VNApplySelectorsAssign(VNK_Liberal, fgCurMemoryVN[GcHeap], firstFieldOnly,
+                                                                    newFldMapVN, indType, compCurBB);
 
-                                fgValueNumberRecordHeapSsa(tree);
+                                recordGcHeapStore(tree, heapVN DEBUGARG("StoreField"));
                             }
                         }
                         else
                         {
-                            GenTreeLclVarCommon* dummyLclVarTree = nullptr;
-                            if (!tree->DefinesLocal(this, &dummyLclVarTree))
+                            GenTreeLclVarCommon* lclVarTree = nullptr;
+                            bool                 isLocal    = tree->DefinesLocal(this, &lclVarTree);
+
+                            if (isLocal && lvaVarAddrExposed(lclVarTree->gtLclNum))
+                            {
+                                // Store to address-exposed local; need to record the effect on ByrefExposed.
+                                // We could use MapStore here and MapSelect on reads of address-exposed locals
+                                // (using the local nums as selectors) to get e.g. propagation of values
+                                // through address-taken locals in regions of code with no calls or byref
+                                // writes.
+                                // For now, just use a new opaque VN.
+                                ValueNum memoryVN = vnStore->VNForExpr(compCurBB);
+                                recordAddressExposedLocalStore(tree, memoryVN DEBUGARG("PtrToLoc indir"));
+                            }
+                            else if (!isLocal)
                             {
-                                // If it doesn't define a local, then it might update the heap.
-                                fgMutateHeap(tree DEBUGARG("assign-of-IND"));
+                                // If it doesn't define a local, then it might update GcHeap/ByrefExposed.
+                                // For the new ByrefExposed VN, we could use an operator here like
+                                // VNF_ByrefExposedStore that carries the VNs of the pointer and RHS, then
+                                // at byref loads if the current ByrefExposed VN happens to be
+                                // VNF_ByrefExposedStore with the same pointer VN, we could propagate the
+                                // VN from the RHS to the VN for the load.  This would e.g. allow tracking
+                                // values through assignments to out params.  For now, just model this
+                                // as an opaque GcHeap/ByrefExposed mutation.
+                                fgMutateGcHeap(tree DEBUGARG("assign-of-IND"));
                             }
                         }
                     }
@@ -6008,17 +6200,17 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
 
                     if (isVolatile)
                     {
-                        // For Volatile store indirection, first mutate the global heap
-                        fgMutateHeap(lhs DEBUGARG("GTF_CLS_VAR - store")); // always change fgCurHeapVN
+                        // For Volatile store indirection, first mutate GcHeap/ByrefExposed
+                        fgMutateGcHeap(lhs DEBUGARG("GTF_CLS_VAR - store")); // always change fgCurMemoryVN
                     }
 
-                    // We model statics as indices into the heap variable.
+                    // We model statics as indices into GcHeap (which is a subset of ByrefExposed).
                     FieldSeqNode* fldSeqForStaticVar = GetFieldSeqStore()->CreateSingleton(lhs->gtClsVar.gtClsVarHnd);
                     assert(fldSeqForStaticVar != FieldSeqStore::NotAField());
 
                     ValueNum storeVal = rhsVNPair.GetLiberal(); // The value number from the rhs of the assignment
-                    storeVal = vnStore->VNApplySelectorsAssign(VNK_Liberal, fgCurHeapVN, fldSeqForStaticVar, storeVal,
-                                                               lhs->TypeGet(), compCurBB);
+                    storeVal = vnStore->VNApplySelectorsAssign(VNK_Liberal, fgCurMemoryVN[GcHeap], fldSeqForStaticVar,
+                                                               storeVal, lhs->TypeGet(), compCurBB);
 
                     // It is not strictly necessary to set the lhs value number,
                     // but the dumps read better with it set to the 'storeVal' that we just computed
@@ -6026,23 +6218,22 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
 #ifdef DEBUG
                     if (verbose)
                     {
-                        printf("  fgCurHeapVN assigned:\n");
+                        printf("  fgCurMemoryVN assigned:\n");
                     }
 #endif // DEBUG
-                    // bbHeapDef must be set to true for any block that Mutates the global Heap
-                    assert(compCurBB->bbHeapDef);
+                    // bbMemoryDef must include GcHeap for any block that mutates the GC heap
+                    assert((compCurBB->bbMemoryDef & memoryKindSet(GcHeap)) != 0);
 
-                    // Update the field map for the fgCurHeapVN
-                    fgCurHeapVN = storeVal;
-                    fgValueNumberRecordHeapSsa(tree);
+                    // Update the field map for the fgCurMemoryVN and SSA for the tree
+                    recordGcHeapStore(tree, storeVal DEBUGARG("Static Field store"));
                 }
                 break;
 
                 default:
                     assert(!"Unknown node for lhs of assignment!");
 
-                    // For Unknown stores, mutate the global heap
-                    fgMutateHeap(lhs DEBUGARG("Unkwown Assignment - store")); // always change fgCurHeapVN
+                    // For Unknown stores, mutate GcHeap/ByrefExposed
+                    fgMutateGcHeap(lhs DEBUGARG("Unkwown Assignment - store")); // always change fgCurMemoryVN
                     break;
             }
         }
@@ -6123,7 +6314,9 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
         else if ((oper == GT_IND) || GenTree::OperIsBlk(oper))
         {
             // So far, we handle cases in which the address is a ptr-to-local, or if it's
-            // a pointer to an object field.
+            // a pointer to an object field or array alement.  Other cases become uses of
+            // the current ByrefExposed value and the pointer value, so that at least we
+            // can recognize redundant loads with no stores between them.
             GenTreePtr           addr         = tree->AsIndir()->Addr();
             GenTreeLclVarCommon* lclVarTree   = nullptr;
             FieldSeqNode*        fldSeq1      = nullptr;
@@ -6150,8 +6343,8 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
             }
             else if (isVolatile)
             {
-                // For Volatile indirection, mutate the global heap
-                fgMutateHeap(tree DEBUGARG("GTF_IND_VOLATILE - read"));
+                // For Volatile indirection, mutate GcHeap/ByrefExposed
+                fgMutateGcHeap(tree DEBUGARG("GTF_IND_VOLATILE - read"));
 
                 // The value read by the GT_IND can immediately change
                 ValueNum newUniq = vnStore->VNForExpr(compCurBB, tree->TypeGet());
@@ -6299,10 +6492,10 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
                     if (fldSeqForStaticVar != FieldSeqStore::NotAField())
                     {
                         ValueNum selectedStaticVar;
-                        // We model statics as indices into the heap variable.
+                        // We model statics as indices into the GcHeap (which is a subset of ByrefExposed).
                         size_t structSize = 0;
-                        selectedStaticVar =
-                            vnStore->VNApplySelectors(VNK_Liberal, fgCurHeapVN, fldSeqForStaticVar, &structSize);
+                        selectedStaticVar = vnStore->VNApplySelectors(VNK_Liberal, fgCurMemoryVN[GcHeap],
+                                                                      fldSeqForStaticVar, &structSize);
                         selectedStaticVar = vnStore->VNApplySelectorsTypeCheck(selectedStaticVar, indType, structSize);
 
                         tree->gtVNPair.SetLiberal(selectedStaticVar);
@@ -6327,7 +6520,7 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
                     }
                     else if (fldSeq2 != nullptr)
                     {
-                        // Get the first (instance or static) field from field seq.  Heap[field] will yield the "field
+                        // Get the first (instance or static) field from field seq.  GcHeap[field] will yield the "field
                         // map".
                         CLANG_FORMAT_COMMENT_ANCHOR;
 
@@ -6346,7 +6539,7 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
                         FieldSeqNode* firstFieldOnly = GetFieldSeqStore()->CreateSingleton(fldSeq2->m_fieldHnd);
                         size_t        structSize     = 0;
                         ValueNum      fldMapVN =
-                            vnStore->VNApplySelectors(VNK_Liberal, fgCurHeapVN, firstFieldOnly, &structSize);
+                            vnStore->VNApplySelectors(VNK_Liberal, fgCurMemoryVN[GcHeap], firstFieldOnly, &structSize);
 
                         // The final field in the sequence will need to match the 'indType'
                         var_types indType = tree->TypeGet();
@@ -6390,9 +6583,12 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
                         tree->gtVNPair = vnStore->VNPWithExc(tree->gtVNPair, addrXvnp);
                     }
                 }
-                else // We don't know where the address points.
+                else // We don't know where the address points, so it is an ByrefExposed load.
                 {
-                    tree->gtVNPair.SetBoth(vnStore->VNForExpr(compCurBB, tree->TypeGet()));
+                    ValueNum addrVN = addr->gtVNPair.GetLiberal();
+                    ValueNum loadVN = fgValueNumberByrefExposedLoad(typ, addrVN);
+                    tree->gtVNPair.SetLiberal(loadVN);
+                    tree->gtVNPair.SetConservative(vnStore->VNForExpr(compCurBB, tree->TypeGet()));
                     tree->gtVNPair = vnStore->VNPWithExc(tree->gtVNPair, addrXvnp);
                 }
             }
@@ -6542,16 +6738,13 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
                 case GT_LOCKADD: // Binop
                 case GT_XADD:    // Binop
                 case GT_XCHG:    // Binop
-                    // For CMPXCHG and other intrinsics add an arbitrary side effect on Heap.
-                    fgMutateHeap(tree DEBUGARG("Interlocked intrinsic"));
+                    // For CMPXCHG and other intrinsics add an arbitrary side effect on GcHeap/ByrefExposed.
+                    fgMutateGcHeap(tree DEBUGARG("Interlocked intrinsic"));
                     tree->gtVNPair.SetBoth(vnStore->VNForExpr(compCurBB, tree->TypeGet()));
                     break;
 
                 case GT_JTRUE:
                 case GT_LIST:
-#ifndef LEGACY_BACKEND
-                case GT_FIELD_LIST:
-#endif // !LEGACY_BACKEND
                     // These nodes never need to have a ValueNumber
                     tree->gtVNPair.SetBoth(ValueNumStore::NoVN);
                     break;
@@ -6592,8 +6785,8 @@ void Compiler::fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd)
             break;
 
             case GT_CMPXCHG: // Specialop
-                // For CMPXCHG and other intrinsics add an arbitrary side effect on Heap.
-                fgMutateHeap(tree DEBUGARG("Interlocked intrinsic"));
+                // For CMPXCHG and other intrinsics add an arbitrary side effect on GcHeap/ByrefExposed.
+                fgMutateGcHeap(tree DEBUGARG("Interlocked intrinsic"));
                 tree->gtVNPair.SetBoth(vnStore->VNForExpr(compCurBB, tree->TypeGet()));
                 break;
 
@@ -6886,6 +7079,24 @@ void Compiler::fgValueNumberHelperCallFunc(GenTreeCall* call, VNFunc vnf, ValueN
     }
     else
     {
+        auto getCurrentArg = [call, &args, useEntryPointAddrAsArg0](int currentIndex) {
+            GenTreePtr arg = args->Current();
+            if ((arg->gtFlags & GTF_LATE_ARG) != 0)
+            {
+                // This arg is a setup node that moves the arg into position.
+                // Value-numbering will have visited the separate late arg that
+                // holds the actual value, and propagated/computed the value number
+                // for this arg there.
+                if (useEntryPointAddrAsArg0)
+                {
+                    // The args in the fgArgInfo don't include the entry point, so
+                    // index into them using one less than the requested index.
+                    --currentIndex;
+                }
+                return call->fgArgInfo->GetLateArg(currentIndex);
+            }
+            return arg;
+        };
         // Has at least one argument.
         ValueNumPair vnp0;
         ValueNumPair vnp0x = ValueNumStore::VNPForEmptyExcSet();
@@ -6899,7 +7110,7 @@ void Compiler::fgValueNumberHelperCallFunc(GenTreeCall* call, VNFunc vnf, ValueN
 #endif
         {
             assert(!useEntryPointAddrAsArg0);
-            ValueNumPair vnp0wx = args->Current()->gtVNPair;
+            ValueNumPair vnp0wx = getCurrentArg(0)->gtVNPair;
             vnStore->VNPUnpackExc(vnp0wx, &vnp0, &vnp0x);
 
             // Also include in the argument exception sets
@@ -6921,7 +7132,7 @@ void Compiler::fgValueNumberHelperCallFunc(GenTreeCall* call, VNFunc vnf, ValueN
         else
         {
             // Has at least two arguments.
-            ValueNumPair vnp1wx = args->Current()->gtVNPair;
+            ValueNumPair vnp1wx = getCurrentArg(1)->gtVNPair;
             ValueNumPair vnp1;
             ValueNumPair vnp1x = ValueNumStore::VNPForEmptyExcSet();
             vnStore->VNPUnpackExc(vnp1wx, &vnp1, &vnp1x);
@@ -6941,7 +7152,7 @@ void Compiler::fgValueNumberHelperCallFunc(GenTreeCall* call, VNFunc vnf, ValueN
             }
             else
             {
-                ValueNumPair vnp2wx = args->Current()->gtVNPair;
+                ValueNumPair vnp2wx = getCurrentArg(2)->gtVNPair;
                 ValueNumPair vnp2;
                 ValueNumPair vnp2x = ValueNumStore::VNPForEmptyExcSet();
                 vnStore->VNPUnpackExc(vnp2wx, &vnp2, &vnp2x);
@@ -6978,16 +7189,7 @@ void Compiler::fgValueNumberCall(GenTreeCall* call)
         if (arg->OperGet() == GT_ARGPLACE)
         {
             // Find the corresponding late arg.
-            GenTreePtr lateArg = nullptr;
-            for (unsigned j = 0; j < call->fgArgInfo->ArgCount(); j++)
-            {
-                if (call->fgArgInfo->ArgTable()[j]->argNum == i)
-                {
-                    lateArg = call->fgArgInfo->ArgTable()[j]->node;
-                    break;
-                }
-            }
-            assert(lateArg != nullptr);
+            GenTreePtr lateArg = call->fgArgInfo->GetLateArg(i);
             assert(lateArg->gtVNPair.BothDefined());
             arg->gtVNPair   = lateArg->gtVNPair;
             updatedArgPlace = true;
@@ -7018,8 +7220,8 @@ void Compiler::fgValueNumberCall(GenTreeCall* call)
 
         if (modHeap)
         {
-            // For now, arbitrary side effect on Heap.
-            fgMutateHeap(call DEBUGARG("HELPER - modifies heap"));
+            // For now, arbitrary side effect on GcHeap/ByrefExposed.
+            fgMutateGcHeap(call DEBUGARG("HELPER - modifies heap"));
         }
     }
     else
@@ -7033,8 +7235,8 @@ void Compiler::fgValueNumberCall(GenTreeCall* call)
             call->gtVNPair.SetBoth(vnStore->VNForExpr(compCurBB, call->TypeGet()));
         }
 
-        // For now, arbitrary side effect on Heap.
-        fgMutateHeap(call DEBUGARG("CALL"));
+        // For now, arbitrary side effect on GcHeap/ByrefExposed.
+        fgMutateGcHeap(call DEBUGARG("CALL"));
     }
 }
 
@@ -7264,6 +7466,10 @@ VNFunc Compiler::fgValueNumberHelperMethVNFunc(CorInfoHelpFunc helpFunc)
             vnf = VNF_IsInstanceOf;
             break;
 
+        case CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE:
+            vnf = VNF_TypeHandleToRuntimeType;
+            break;
+
         case CORINFO_HELP_READYTORUN_ISINSTANCEOF:
             vnf = VNF_ReadyToRunIsInstanceOf;
             break;
diff --git a/src/jit/valuenum.h b/src/jit/valuenum.h
index c8a57ff210..e6e0e43a33 100644
--- a/src/jit/valuenum.h
+++ b/src/jit/valuenum.h
@@ -217,7 +217,7 @@ private:
 
 #ifdef DEBUG
     // This helps test some performance pathologies related to "evaluation" of VNF_MapSelect terms,
-    // especially relating to the heap.  We count the number of applications of such terms we consider,
+    // especially relating to GcHeap/ByrefExposed.  We count the number of applications of such terms we consider,
     // and if this exceeds a limit, indicated by a COMPlus_ variable, we assert.
     unsigned m_numMapSels;
 #endif
@@ -762,7 +762,7 @@ public:
     // the function application it represents; otherwise, return "false."
     bool GetVNFunc(ValueNum vn, VNFuncApp* funcApp);
 
-    // Requires that "vn" represents a "heap address" the sum of a "TYP_REF" value and some integer
+    // Requires that "vn" represents a "GC heap address" the sum of a "TYP_REF" value and some integer
     // value.  Returns the TYP_REF value.
     ValueNum VNForRefInAddr(ValueNum vn);
 
diff --git a/src/jit/valuenumfuncs.h b/src/jit/valuenumfuncs.h
index eb17aedf28..2711b4f056 100644
--- a/src/jit/valuenumfuncs.h
+++ b/src/jit/valuenumfuncs.h
@@ -18,10 +18,10 @@ ValueNumFuncDef(PtrToLoc, 2, false, false, false)           // Pointer (byref) t
 ValueNumFuncDef(PtrToArrElem, 4, false, false, false)       // Pointer (byref) to an array element.  Args: 0: array elem type eq class var_types value, VN's of: 1: array, 2: index, 3: FieldSeq.
 ValueNumFuncDef(PtrToStatic, 1, false, false, false)        // Pointer (byref) to a static variable (or possibly a field thereof, if the static variable is a struct).  Args: 0: FieldSeq, first element
                                                      // of which is the static var.
-ValueNumFuncDef(Phi, 2, false, false, false)        // A phi function.  Only occurs as arg of PhiDef or PhiHeapDef.  Arguments are SSA numbers of var being defined.
-ValueNumFuncDef(PhiDef, 3, false, false, false)     // Args: 0: local var # (or -1 for Heap), 1: SSA #, 2: VN of definition.
-// Wouldn't need this if I'd made Heap a regular local variable...
-ValueNumFuncDef(PhiHeapDef, 2, false, false, false) // Args: 0: VN for basic block pointer, 1: VN of definition
+ValueNumFuncDef(Phi, 2, false, false, false)        // A phi function.  Only occurs as arg of PhiDef or PhiMemoryDef.  Arguments are SSA numbers of var being defined.
+ValueNumFuncDef(PhiDef, 3, false, false, false)     // Args: 0: local var # (or -1 for memory), 1: SSA #, 2: VN of definition.
+// Wouldn't need this if I'd made memory a regular local variable...
+ValueNumFuncDef(PhiMemoryDef, 2, false, false, false) // Args: 0: VN for basic block pointer, 1: VN of definition
 ValueNumFuncDef(InitVal, 1, false, false, false)    // An input arg, or init val of a local Args: 0: a constant VN.
 
 
@@ -34,9 +34,12 @@ ValueNumFuncDef(CastClass, 2, false, false, false)          // Args: 0: Handle o
 ValueNumFuncDef(IsInstanceOf, 2, false, false, false)       // Args: 0: Handle of class being queried, 1: object being queried.
 ValueNumFuncDef(ReadyToRunCastClass, 2, false, false, false)          // Args: 0: Helper stub address, 1: object being cast.
 ValueNumFuncDef(ReadyToRunIsInstanceOf, 2, false, false, false)       // Args: 0: Helper stub address, 1: object being queried.
+ValueNumFuncDef(TypeHandleToRuntimeType, 1, false, false, false)      // Args: 0: TypeHandle to translate
 
 ValueNumFuncDef(LdElemA, 3, false, false, false)            // Args: 0: array value; 1: index value; 2: type handle of element.
 
+ValueNumFuncDef(ByrefExposedLoad, 3, false, false, false)      // Args: 0: type handle/id, 1: pointer value; 2: ByrefExposed heap value
+
 ValueNumFuncDef(GetRefanyVal, 2, false, false, false)       // Args: 0: type handle; 1: typedref value.  Returns the value (asserting that the type is right).
 
 ValueNumFuncDef(GetClassFromMethodParam, 1, false, true, false)       // Args: 0: method generic argument.
diff --git a/src/jit/valuenumtype.h b/src/jit/valuenumtype.h
index f898d87532..b2ebba69c5 100644
--- a/src/jit/valuenumtype.h
+++ b/src/jit/valuenumtype.h
@@ -17,9 +17,9 @@
 typedef UINT32 ValueNum;
 
 // There are two "kinds" of value numbers, which differ in their modeling of the actions of other threads.
-// "Liberal" value numbers assume that the other threads change contents of heap locations only at
+// "Liberal" value numbers assume that the other threads change contents of memory locations only at
 // synchronization points.  Liberal VNs are appropriate, for example, in identifying CSE opportunities.
-// "Conservative" value numbers assume that the contents of heap locations change arbitrarily between
+// "Conservative" value numbers assume that the contents of memory locations change arbitrarily between
 // every two accesses.  Conservative VNs are appropriate, for example, in assertion prop, where an observation
 // of a property of the value in some storage location is used to perform an optimization downstream on
 // an operation involving the contents of that storage location.  If other threads may modify the storage
diff --git a/src/md/compiler/classfactory.cpp b/src/md/compiler/classfactory.cpp
index 603f7975aa..338095add3 100644
--- a/src/md/compiler/classfactory.cpp
+++ b/src/md/compiler/classfactory.cpp
@@ -42,14 +42,6 @@ const COCLASS_REGISTER g_CoClasses[] =
 {
 //  pClsid                              szProgID                        pfnCreateObject
     { &CLSID_CorMetaDataDispenser,        W("CorMetaDataDispenser"),        Disp::CreateObject },
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE) // coreclr doesn't export these
-    { &CLSID_CorMetaDataDispenserRuntime, W("CorMetaDataDispenserRuntime"), Disp::CreateObject },
-
-    { &CLSID_CorRuntimeHost,              W("CorRuntimeHost"),              CorHost::CreateObject },
-    { &CLSID_CLRRuntimeHost,              W("CLRRuntimeHost"),              CorHost2::CreateObject },
-    { &__uuidof(CLRPrivRuntime),          W("CLRPrivRuntime"),              CorHost2::CreateObject },
-    { &CLSID_TypeNameFactory,             NULL,                           (PFN_CREATE_OBJ)TypeNameFactoryCreateObject },
-#endif // FEATURE_CORECLR && !CROSSGEN_COMPILE
     { NULL,                               NULL,                           NULL }
 };
 
diff --git a/src/md/compiler/disp.cpp b/src/md/compiler/disp.cpp
index b091729744..5aeb7ce19f 100644
--- a/src/md/compiler/disp.cpp
+++ b/src/md/compiler/disp.cpp
@@ -16,9 +16,6 @@
 #include <corerror.h>
 #include <mdlog.h>
 #include <mdcommon.h>
-#ifdef FEATURE_COMINTEROP_TLB_SUPPORT
-#include <imptlb.h>
-#endif 
 
 #ifdef EnC_SUPPORTED
 #define ENC_DELTA_HACK
@@ -439,13 +436,6 @@ ErrExit:
     return hr;
 } // Disp::OpenScopeOnMemory
 
-#if defined(FEATURE_METADATA_IN_VM) && !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-
-#include <metahost.h>
-// Pointer to the activated CLR interface provided by the shim.
-extern ICLRRuntimeInfo * g_pCLRRuntime;
-
-#endif
 
 //*****************************************************************************
 // Get the directory where the CLR system resides.
@@ -458,27 +448,11 @@ Disp::GetCORSystemDirectory(
     DWORD                           cchBuffer,     // [in] Size of the buffer
     DWORD                          *pcchBuffer)    // [out] Number of characters returned
 {
-#if defined(FEATURE_METADATA_IN_VM) && !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-    HRESULT hr = S_OK;
-    BEGIN_ENTRYPOINT_NOTHROW;
-    
-    // This implies a machine-wide CLR install root, which may not exist for some CLR
-    // skus using standalone metadata.
-    *pcchBuffer = cchBuffer;
-    hr = g_pCLRRuntime->GetRuntimeDirectory(szBuffer, pcchBuffer);
-
-    END_ENTRYPOINT_NOTHROW;
-    
-    return hr;
-#else //!FEATURE_METADATA_IN_VM || FEATURE_CORECLR
 
-#ifdef FEATURE_CORECLR
     UNREACHABLE_MSG("Calling IMetaDataDispenser::GetCORSystemDirectory!  This code should not be "
                 "reachable or needs to be reimplemented for CoreCLR!");
-#endif //FEATURE_CORECLR
     
     return E_NOTIMPL;
-#endif //!FEATURE_METADATA_IN_VM || FEATURE_CORECLR
 } // Disp::GetCORSystemDirectory
 
 HRESULT Disp::FindAssembly(             // S_OK or error
diff --git a/src/md/compiler/mdsighelper.h b/src/md/compiler/mdsighelper.h
index 0d089729bb..49c0752fe3 100644
--- a/src/md/compiler/mdsighelper.h
+++ b/src/md/compiler/mdsighelper.h
@@ -104,13 +104,7 @@ class UnifiedAssemblySigComparer : public MDSigComparer::MDSigComparerBaseType
   protected:
     RegMeta *m_pRegMeta;
 
-#ifdef FEATURE_FUSION
-    HRESULT _CreateIAssemblyNameFromAssemblyRef(
-        mdToken tkAsmRef,
-        IAssemblyName **ppAsmName);
-#else
     HRESULT _CompareAssemblies(mdToken tkAsmRef1,mdToken tkAsmRef2, BOOL* pfEquivalent);
-#endif
 
     HRESULT _CreateTypeNameFromTypeRef(
         mdToken tkTypeRef,
diff --git a/src/md/compiler/mdvalidator.cpp b/src/md/compiler/mdvalidator.cpp
index adcfd51eb3..0b86738cfb 100644
--- a/src/md/compiler/mdvalidator.cpp
+++ b/src/md/compiler/mdvalidator.cpp
@@ -19,9 +19,6 @@
 #include "pedecoder.h"
 #include "stgio.h"
 #include "corhost.h"
-#ifdef FEATURE_FUSION
-#include "fusion.h"
-#endif
 #include "sstring.h"
 #include "nsutilpriv.h"
 #include "holder.h"
@@ -7185,123 +7182,7 @@ MDSigComparer::_CompareMethodSignatureHeader(
 //*****************************************************************************
 //*****************************************************************************
 
-#ifdef FEATURE_FUSION
-HRESULT
-UnifiedAssemblySigComparer::_CreateIAssemblyNameFromAssemblyRef(
-    mdToken         tkAsmRef,
-    IAssemblyName **ppAsmName)
-{
-    HRESULT hr;
-
-    void const *        pvPublicKey;
-    ULONG               cbPublicKey;
-    ULONG               cchName;
-    ASSEMBLYMETADATA    amd;
-    void const *        pvHashValue;
-    ULONG               cbHashValue;
-    DWORD               dwFlags;
-
-    ZeroMemory(&amd, sizeof(amd));
-    
-    IfFailRet(m_pRegMeta->GetAssemblyRefProps(tkAsmRef,
-                                  NULL,
-                                  NULL,
-                                  NULL,
-                                  0,
-                                  &cchName,
-                                  &amd,
-                                  NULL,
-                                  NULL,
-                                  NULL));
-
-    StackSString ssName;
-    StackSString ssLocale;
-    amd.szLocale = ssLocale.OpenUnicodeBuffer(amd.cbLocale);
-
-    IfFailRet(m_pRegMeta->GetAssemblyRefProps(tkAsmRef,
-                                  &pvPublicKey,
-                                  &cbPublicKey,
-                                  ssName.OpenUnicodeBuffer(cchName),
-                                  cchName,
-                                  &cchName,
-                                  &amd,
-                                  &pvHashValue,
-                                  &cbHashValue,
-                                  &dwFlags));
-
-    ssName.CloseBuffer();
-    ssLocale.CloseBuffer();
-
-    IAssemblyName *pAsmName = NULL;
-
-    IfFailRet(CreateAssemblyNameObject(&pAsmName,
-                                       ssName.GetUnicode(),
-                                       CANOF_SET_DEFAULT_VALUES,
-                                       NULL));
-
-    // Set the public key token
-    IfFailRet(pAsmName->SetProperty(ASM_NAME_PUBLIC_KEY_TOKEN,
-                                    (LPVOID)pvPublicKey,
-                                    cbPublicKey));
 
-    // Set the culture
-    if (amd.cbLocale == 0 || amd.szLocale == NULL)
-    {
-        IfFailRet(pAsmName->SetProperty(ASM_NAME_CULTURE,
-                                        W("Neutral"),
-                                        sizeof(W("Neutral"))));
-    }
-    else
-    {
-        IfFailRet(pAsmName->SetProperty(ASM_NAME_CULTURE,
-                                        amd.szLocale,
-                                        amd.cbLocale));
-    }
-
-    // Set the major version
-    IfFailRet(pAsmName->SetProperty(ASM_NAME_MAJOR_VERSION,
-                                    &amd.usMajorVersion,
-                                    sizeof(amd.usMajorVersion)));
-
-    // Set the minor version
-    IfFailRet(pAsmName->SetProperty(ASM_NAME_MINOR_VERSION,
-                                    &amd.usMinorVersion,
-                                    sizeof(amd.usMinorVersion)));
-
-    // Set the build number
-    IfFailRet(pAsmName->SetProperty(ASM_NAME_BUILD_NUMBER,
-                                    &amd.usBuildNumber,
-                                    sizeof(amd.usBuildNumber)));
-
-    // Set the revision number
-    IfFailRet(pAsmName->SetProperty(ASM_NAME_REVISION_NUMBER,
-                                    &amd.usRevisionNumber,
-                                    sizeof(amd.usRevisionNumber)));
-
-    *ppAsmName = pAsmName;
-
-    return S_OK;
-}
-
-//*****************************************************************************
-// Define holder to release IAssemblyName on exception.
-//*****************************************************************************
-void UnifiedAssemblySigComparer_IAssemblyNameRelease(IAssemblyName *value)
-{
-    if (value != NULL)
-    {
-        value->Release();
-    }
-}
-
-typedef Holder<IAssemblyName*,
-               DoNothing<IAssemblyName*>,
-               &UnifiedAssemblySigComparer_IAssemblyNameRelease,
-               NULL> UnifiedAssemblySigComparer_IAssemblyNameHolder;
-
-#endif // FEATURE_FUSION
-
-#ifndef FEATURE_FUSION
 HRESULT UnifiedAssemblySigComparer::_CompareAssemblies(mdToken tkAsmRef1,mdToken tkAsmRef2, BOOL* pfEquivalent)
 {
 
@@ -7417,7 +7298,6 @@ HRESULT UnifiedAssemblySigComparer::_CompareAssemblies(mdToken tkAsmRef1,mdToken
     return S_OK;
 
 };
-#endif // FEATURE_FUSION
 
 //*****************************************************************************
 //*****************************************************************************
@@ -7523,38 +7403,8 @@ UnifiedAssemblySigComparer::CompareToken(
     }
     BOOL fEquivalent;
 
-#ifdef FEATURE_FUSION //move into _CompareAssemblies
-    IAssemblyName *pAsmName1 = NULL;
-    IfFailRet(_CreateIAssemblyNameFromAssemblyRef(tkParent1, &pAsmName1));
-    UnifiedAssemblySigComparer_IAssemblyNameHolder anh1(pAsmName1);
-
-    IAssemblyName *pAsmName2 = NULL;
-    IfFailRet(_CreateIAssemblyNameFromAssemblyRef(tkParent2, &pAsmName2));
-    UnifiedAssemblySigComparer_IAssemblyNameHolder anh2(pAsmName2);
-
-    DWORD cchDisplayName = 0;
-
-    StackSString ssDisplayName1;
-    pAsmName1->GetDisplayName(NULL, &cchDisplayName, NULL);
-    IfFailRet(pAsmName1->GetDisplayName(ssDisplayName1.OpenUnicodeBuffer(cchDisplayName), &cchDisplayName, NULL));
-    ssDisplayName1.CloseBuffer();
-
-    StackSString ssDisplayName2;
-    pAsmName2->GetDisplayName(NULL, &cchDisplayName, NULL);
-    IfFailRet(pAsmName2->GetDisplayName(ssDisplayName2.OpenUnicodeBuffer(cchDisplayName), &cchDisplayName, NULL));
-    ssDisplayName2.CloseBuffer();
-
-    AssemblyComparisonResult res;
-    IfFailRet(CompareAssemblyIdentity(ssDisplayName1.GetUnicode(),
-                                      TRUE,
-                                      ssDisplayName2.GetUnicode(),
-                                      TRUE,
-                                      &fEquivalent,
-                                      &res));
-#else
     // no redirects supported
     IfFailRet(_CompareAssemblies(tkParent1,tkParent2,&fEquivalent));
-#endif
 
     if (!fEquivalent)
     {
diff --git a/src/md/compiler/regmeta.cpp b/src/md/compiler/regmeta.cpp
index feb1cdd31b..b849c6433a 100644
--- a/src/md/compiler/regmeta.cpp
+++ b/src/md/compiler/regmeta.cpp
@@ -581,12 +581,6 @@ RegMeta::QueryInterface(
     }
 #endif //FEATURE_METADATA_EMIT
 
-#if defined(FEATURE_METADATA_IN_VM) && !defined(FEATURE_CORECLR)
-    else if (riid == IID_IMetaDataValidate)
-    {
-        *ppUnk = (IMetaDataValidate *)this;
-    }
-#endif //defined(FEATURE_METADATA_IN_VM) && !defined(FEATURE_CORECLR)
 
 #ifdef FEATURE_METADATA_EMIT_ALL
     else if (riid == IID_IMetaDataFilter)
diff --git a/src/md/compiler/regmeta.h b/src/md/compiler/regmeta.h
index cb7bae17b5..5a003ec0a9 100644
--- a/src/md/compiler/regmeta.h
+++ b/src/md/compiler/regmeta.h
@@ -27,9 +27,6 @@
 #include <ivehandler.h>
 
 #include "sigparser.h"
-#ifdef FEATURE_FUSION
-#include "fusion.h"
-#endif
 
 #include "winmdinterfaces.h"
 
@@ -2059,9 +2056,6 @@ private:
 
     CorValidatorModuleType      m_ModuleType;
     IVEHandler                  *m_pVEHandler;
-#ifndef FEATURE_CORECLR
-    ValidateRecordFunction      m_ValidateRecordFunctionTable[TBL_COUNT];
-#endif
     CCustAttrHash               m_caHash;   // Hashed list of custom attribute types seen.
     
     bool        m_bKeepKnownCa;             // Should all known CA's be kept?
diff --git a/src/md/compiler/regmeta_vm.cpp b/src/md/compiler/regmeta_vm.cpp
index beebb08b5c..38ca308e01 100644
--- a/src/md/compiler/regmeta_vm.cpp
+++ b/src/md/compiler/regmeta_vm.cpp
@@ -29,23 +29,6 @@
 #include <metamodelrw.h>
 
 
-#ifndef FEATURE_CORECLR
-
-#include <metahost.h>
-
-// Pointer to the activated CLR interface provided by the shim.
-extern ICLRRuntimeInfo *g_pCLRRuntime;
-
-#ifdef FEATURE_METADATA_EMIT_ALL
-
-#include "iappdomainsetup.h"
-
-// {27FFF232-A7A8-40dd-8D4A-734AD59FCD41}
-EXTERN_GUID(IID_IAppDomainSetup, 0x27FFF232, 0xA7A8, 0x40dd, 0x8D, 0x4A, 0x73, 0x4A, 0xD5, 0x9F, 0xCD, 0x41);
-
-#endif //FEATURE_METADATA_EMIT_ALL
-
-#endif // !FEATURE_CORECLR
 
 
 #define DEFINE_CUSTOM_NODUPCHECK    1
@@ -117,90 +100,8 @@ HRESULT RegMeta::FindCachedReadOnlyEntry(
 //*****************************************************************************
 HRESULT RegMeta::StartupEE()
 {
-#ifdef FEATURE_CORECLR
     UNREACHABLE_MSG_RET("About to CoCreateInstance!  This code should not be "
                         "reachable or needs to be reimplemented for CoreCLR!");
-#else // !FEATURE_CORECLR
-
-    struct Param
-    {
-        RegMeta *pThis;
-        IUnknown *pSetup;
-        IAppDomainSetup *pDomainSetup;
-        bool fDoneStart;
-        HRESULT hr;
-    } param;
-    param.pThis = this;
-    param.pSetup = NULL;
-    param.pDomainSetup = NULL;
-    param.fDoneStart = false;
-    param.hr = S_OK;
-
-    PAL_TRY(Param *, pParam, &param)
-    {
-        HRESULT hr = S_OK;
-
-        DWORD dwBuffer[1 + (MAX_LONGPATH+1) * sizeof(WCHAR) / sizeof(DWORD) + 1];
-        BSTR  bstrDir = NULL;
-
-        // Create a hosting environment.
-        IfFailGo(g_pCLRRuntime->GetInterface(
-            CLSID_CorRuntimeHost, 
-            IID_ICorRuntimeHost, 
-            (void **)&pParam->pThis->m_pCorHost));
-
-        // Startup the runtime.
-        IfFailGo(pParam->pThis->m_pCorHost->Start());
-        pParam->fDoneStart = true;
-
-        // Create an AppDomain Setup so we can set the AppBase.
-        IfFailGo(pParam->pThis->m_pCorHost->CreateDomainSetup(&pParam->pSetup));
-
-        // Get the current directory (place it in a BSTR).
-        bstrDir = (BSTR)(dwBuffer + 1);
-        if ((dwBuffer[0] = (WszGetCurrentDirectory(MAX_LONGPATH + 1, bstrDir) * sizeof(WCHAR))))
-        {
-            // QI for the IAppDomainSetup interface.
-            IfFailGo(pParam->pSetup->QueryInterface(IID_IAppDomainSetup,
-                                            (void**)&pParam->pDomainSetup));
-
-            // Set the AppBase.
-            pParam->pDomainSetup->put_ApplicationBase(bstrDir);
-        }
-
-        // Create a new AppDomain.
-        IfFailGo(pParam->pThis->m_pCorHost->CreateDomainEx(W("Compilation Domain"),
-                                            pParam->pSetup,
-                                            NULL,
-                                            &pParam->pThis->m_pAppDomain));
-
-        // That's it, we're all set up.
-        _ASSERTE(pParam->pThis->m_pAppDomain != NULL);
-        pParam->pThis->m_fStartedEE = true;
-
-    ErrExit:
-        pParam->hr = hr;
-    }
-    PAL_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
-    {
-        _ASSERTE(!"Unexpected exception setting up hosting environment for security attributes");
-        param.hr = E_FAIL;
-    }
-    PAL_ENDTRY
-
-    // Cleanup temporary resources.
-    if (m_pAppDomain && FAILED(param.hr))
-        m_pAppDomain->Release();
-    if (param.pDomainSetup)
-        param.pDomainSetup->Release();
-    if (param.pSetup)
-        param.pSetup->Release();
-    if (param.fDoneStart && FAILED(param.hr))
-        m_pCorHost->Stop();
-    if (m_pCorHost && FAILED(param.hr))
-        m_pCorHost->Release();
-    return param.hr;
-#endif // FEATURE_CORECLR
 }
 
 #endif //FEATURE_METADATA_EMIT_ALL
@@ -471,63 +372,7 @@ RegMeta::ResolveTypeRef(
         goto ErrExit;
     }
 
-#ifndef FEATURE_CORECLR
-    wcscpy_s(rcModule, _MAX_PATH, wzNameSpace);
-
-    //******************
-    // Try to find the module on CORPATH
-    //******************
-
-    if ((wcsncmp(rcModule, W("System."), 16) != 0) && 
-        (wcsncmp(rcModule, W("System/"), 16) != 0))
-    {
-        // only go through regular CORPATH lookup by fully qualified class name when
-        // it is not System.*
-        hr = CORPATHService::GetClassFromCORPath(
-            rcModule,
-            tr,
-            pMiniMd,
-            riid,
-            ppIScope,
-            ptd);
-    }
-    else 
-    {
-        // force it to look for System.* in mscorlib.dll
-        hr = S_FALSE;
-    }
-
-    if (hr == S_FALSE)
-    {
-        LPWSTR szTmp;
-        WszSearchPath(
-            NULL, 
-            W("mscorlib.dll"), 
-            NULL, 
-            sizeof(rcModule) / sizeof(rcModule[0]), 
-            rcModule, 
-            &szTmp);
-
-        //*******************
-        // Last desperate try!!
-        //*******************
-
-        // Use the file name "mscorlib:
-        IfFailGo(CORPATHService::FindTypeDef(
-            rcModule, 
-            tr, 
-            pMiniMd, 
-            riid, 
-            ppIScope, 
-            ptd));
-        if (hr == S_FALSE)
-        {
-            IfFailGo(META_E_CANNOTRESOLVETYPEREF);
-        }
-    }
-#else //FEATURE_CORECLR
     IfFailGo(META_E_CANNOTRESOLVETYPEREF);
-#endif //FEATURE_CORECLR
 
 ErrExit:
     STOP_MD_PERF(ResolveTypeRef);
diff --git a/src/md/enc/imptlb.cpp b/src/md/enc/imptlb.cpp
deleted file mode 100644
index faeb0d9882..0000000000
--- a/src/md/enc/imptlb.cpp
+++ /dev/null
@@ -1,8057 +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.
-// ===========================================================================
-//  File: ImpTlb.CPP
-// 
-
-//
-
-//      ---------------------------------------------------------------
-//      Who     When        What
-//      ---------------------------------------------------------------
-//      WGE     970906      Created
-//
-// ===========================================================================
-#include "stdafx.h"
-
-#include "imptlb.h"
-#include <posterror.h>
-#include <strongname.h>
-#include <nsutilpriv.h>
-
-#include "..\compiler\regmeta.h"
-#include "..\compiler\importhelper.h"
-#include "tlbutils.h"                   // For GenerateMangledTypeName().
-#include <tlbimpexp.h>
-#include "sstring.h"
-#include "strsafe.h"
-
-#include <metahost.h>
-
-// Pointer to the activated CLR interface provided by the shim.
-extern ICLRRuntimeInfo *g_pCLRRuntime;
-
-#ifdef wcsncmp 
- #undef wcsncmp
-#endif
-#ifdef wcsncpy
- #undef wcsncpy
-#endif
-
-// deprecated: use the secureCrt replacements
-// _CRTIMP int __cdecl wcsncmp(const wchar_t *, const wchar_t *, size_t);
-// _CRTIMP wchar_t * __cdecl wcsncpy(wchar_t *, const wchar_t *, size_t);
-
-#define S_CONVERSION_LOSS _HRESULT_TYPEDEF_(3) // Non-error code meaning a conversion lost information.
-
-#define ADD_ITF_MEMBERS_TO_CLASS        // Define to add interface members to the CoClass.
-#define ITF_MEMBER_RESOLUTION_NAMEONLY  // Define to ignore signatures when looking for collisions (ie, when defined
-                                        //  void Foo(int) and void Foo(String) collide).
-
-// defines controlling ctor of non-creatable objects.
-#define NONCREATABLE_CTOR_VISIBILITY mdAssem  // Define to a visibility flag.
-
-#define MAX_CLASSNAME_SIZE 1024
-
-#ifndef lengthof
-#define lengthof(rg)    (sizeof(rg)/sizeof(rg[0]))
-#endif
-
-#ifndef IfNullGo
-#define IfNullGo(x) do {if (!(x)) IfFailGo(E_OUTOFMEMORY);} while (0)
-#endif
-
-#define BUILD_CUSTOM_ATTRIBUTE(type,bytes)  {*reinterpret_cast<UNALIGNED type*>(__pca) = bytes; __pca += sizeof(type); _ASSERTE(__pca-__ca <= sizeof(__ca));}
-#define INIT_CUSTOM_ATTRIBUTE(n)            {_ASSERTE((n) <= (sizeof(__ca)-sizeof(SHORT)));__pca = __ca; BUILD_CUSTOM_ATTRIBUTE(USHORT,1);}
-#define SIZEOF_CUSTOM_ATTRIBUTE()           ((ULONG) (__pca - __ca))
-#define PTROF_CUSTOM_ATTRIBUTE()            (&__ca[0])
-#define DECLARE_CUSTOM_ATTRIBUTE(n)         BYTE __ca[(n)+sizeof(SHORT)*2], *__pca;__pca=__ca; INIT_CUSTOM_ATTRIBUTE(n);
-#define APPEND_STRING_TO_CUSTOM_ATTRIBUTE(str) {int l = (int)strlen(str); __pca=(BYTE*)CPackedLen::PutLength(__pca,l);memcpy(__pca,str,l);__pca+=l;}
-#define FINISH_CUSTOM_ATTRIBUTE()           {BUILD_CUSTOM_ATTRIBUTE(short,0);}
-
-#define DECLARE_DYNLEN_CUSTOM_ATTRIBUTE(n)          CQuickArray<BYTE> __tmpCAArray; IfFailGo(__tmpCAArray.ReSizeNoThrow(n + sizeof(SHORT)*2)); BYTE *__ca, *__pca; __ca = __tmpCAArray.Ptr(); __pca=__ca; BUILD_CUSTOM_ATTRIBUTE(USHORT,1);
-#define BUILD_DYNLEN_CUSTOM_ATTRIBUTE(type,bytes)   {*reinterpret_cast<UNALIGNED type*>(__pca) = bytes; __pca += sizeof(type); _ASSERTE(__pca-__ca <= (int)__tmpCAArray.Size());}
-#define FINISH_DYNLEN_CUSTOM_ATTRIBUTE()            {BUILD_DYNLEN_CUSTOM_ATTRIBUTE(short,0);}
-
-#define APPEND_WIDE_STRING_TO_CUSTOM_ATTRIBUTE(str)                                             \
-{                                                                                               \
-    CQuickArray<char> __tmpStr;                                                                 \
-    int __cStr = WszWideCharToMultiByte(CP_ACP, 0, str, -1, 0, 0, NULL, NULL);                  \
-    IfFailGo(__tmpStr.ReSizeNoThrow(__cStr));                                                   \
-    __cStr = WszWideCharToMultiByte(CP_ACP, 0, str, -1, __tmpStr.Ptr(), __cStr, NULL, NULL);    \
-    __pca=(BYTE*)CPackedLen::PutLength(__pca,__cStr);                                           \
-    memcpy(__pca,__tmpStr.Ptr(),__cStr);                                                        \
-    __pca+=__cStr;                                                                              \
-}
-
-// The maximum number of bytes the encoding of a DWORD can take.
-#define DWORD_MAX_CB 4
-
-// The maximum number of bytes the encoding of a DWORD can take.
-#define STRING_OVERHEAD_MAX_CB 4
-
-// Use the unused variant types m_knowntypes for common types.
-#define VT_SLOT_FOR_GUID         VT_EMPTY
-#define VT_SLOT_FOR_IENUMERABLE  VT_NULL
-#define VT_SLOT_FOR_MULTICASTDEL VT_I2
-#define VT_SLOT_FOR_TYPE         VT_I4
-#define VT_SLOT_FOR_STRINGBUF    VT_I8
-
-static LPCWSTR szObject                             = W("System.Object");
-static LPCWSTR szValueType                          = W("System.ValueType");
-static LPCWSTR szEnum                               = W("System.Enum");
-
-static LPCWSTR TLB_CLASSLIB_ARRAY                   = {W("System.Array")};
-static LPCWSTR TLB_CLASSLIB_DATE                    = {W("System.DateTime")};
-static LPCWSTR TLB_CLASSLIB_DECIMAL                 = {W("System.Decimal")};
-static LPCWSTR TLB_CLASSLIB_VARIANT                 = {W("System.Variant")};
-static LPCWSTR TLB_CLASSLIB_GUID                    = {W("System.Guid")};
-static LPCWSTR TLB_CLASSLIB_IENUMERABLE             = {W("System.Collections.IEnumerable")};
-static LPCWSTR TLB_CLASSLIB_MULTICASTDELEGATE       = {W("System.MulticastDelegate")};
-static LPCWSTR TLB_CLASSLIB_TYPE                    = {W("System.Type")};
-static LPCWSTR TLB_CLASSLIB_STRINGBUFFER            = {W("System.Text.StringBuilder")};
-
-static LPCWSTR COM_STDOLE2                          = {W("StdOle")};
-static LPCWSTR COM_GUID                             = {W("GUID")};
-
-static const LPCWSTR        PROP_DECORATION_GET     = {W("get_")};
-static const LPCWSTR        PROP_DECORATION_SET     = {W("set_")};
-static const LPCWSTR        PROP_DECORATION_LET     = {W("let_")};
-static const int            PROP_DECORATION_LEN     = 4;
-
-static const LPCWSTR        DLL_EXTENSION           = {W(".dll")};
-static const int            DLL_EXTENSION_LEN       = 4;
-static const LPCWSTR        EXE_EXTENSION           = {W(".exe")};
-static const int            EXE_EXTENSION_LEN       = 4;
-
-static LPCWSTR const        OBJECT_INITIALIZER_NAME = {W(".ctor")};
-static const int            OBJECT_INITIALIZER_FLAGS = mdPublic | mdSpecialName;
-static const int            OBJECT_INITIALIZER_IMPL_FLAGS = miNative | miRuntime | miInternalCall;
-static const int            NONCREATABLE_OBJECT_INITIALIZER_FLAGS = NONCREATABLE_CTOR_VISIBILITY | mdSpecialName;
-
-static const COR_SIGNATURE  OBJECT_INITIALIZER_SIG[3] = { 
-    (IMAGE_CEE_CS_CALLCONV_DEFAULT | IMAGE_CEE_CS_CALLCONV_HASTHIS), 0, ELEMENT_TYPE_VOID };
-
-static const int    DEFAULT_INTERFACE_FUNC_FLAGS    = mdPublic | mdVirtual | mdAbstract | mdHideBySig | mdNewSlot;
-static const int    DEFAULT_PROPERTY_FUNC_FLAGS     = mdPublic | mdVirtual | mdAbstract | mdHideBySig | mdSpecialName | mdNewSlot;
-static const int    DEFAULT_CONST_FIELD_FLAGS       = fdPublic | fdStatic | fdLiteral;
-static const int    DEFAULT_RECORD_FIELD_FLAGS      = fdPublic;
-static const int    DELEGATE_INVOKE_FUNC_FLAGS      = mdPublic | mdVirtual;
-
-static const int    DEFAULT_ITF_FUNC_IMPL_FLAGS     = miNative | miRuntime | miInternalCall;
-
-static const WCHAR         VTBL_GAP_FUNCTION[]      = {W("_VtblGap")};
-static const int           VTBL_GAP_FUNCTION_FLAGS  = mdPublic | mdSpecialName;
-static const int           VTBL_GAP_FUNC_IMPL_FLAGS = miRuntime;
-static const COR_SIGNATURE VTBL_GAP_SIGNATURE[]     = {IMAGE_CEE_CS_CALLCONV_DEFAULT, 0, ELEMENT_TYPE_VOID};
-static const LPCWSTR       VTBL_GAP_FORMAT_1        = {W("%ls%d")};
-static const LPCWSTR       VTBL_GAP_FORMAT_N        = {W("%ls%d_%d")};
-
-static const LPCWSTR       ENUM_TYPE_NAME           = {COR_ENUM_FIELD_NAME_W};
-static const DWORD         ENUM_TYPE_FLAGS          = fdPublic;
-static const COR_SIGNATURE ENUM_TYPE_SIGNATURE[]    = {IMAGE_CEE_CS_CALLCONV_FIELD, ELEMENT_TYPE_I4};
-static const DWORD         ENUM_TYPE_SIGNATURE_SIZE = lengthof(ENUM_TYPE_SIGNATURE);
-
-static const LPCWSTR       DYNAMIC_NAMESPACE_NAME   = {W("DynamicModule")};
-
-static const LPCWSTR       UNSAFE_ITF_PREFIX        = {W("Unsafe.")};
-
-static const LPCWSTR       GET_ENUMERATOR_MEMBER_NAME = {W("GetEnumerator")};
-
-static const WCHAR         CLASS_SUFFIX[]              = {W("Class")};
-static const DWORD         CLASS_SUFFIX_LENGTH       = lengthof(CLASS_SUFFIX);
-static const WCHAR         EVENT_ITF_SUFFIX[]          = {W("_Event")};
-static const DWORD         EVENT_ITF_SUFFIX_LENGTH   = lengthof(EVENT_ITF_SUFFIX);
-static const WCHAR         EVENT_PROVIDER_SUFFIX[]     = {W("_EventProvider")};
-static const DWORD         EVENT_PROVIDER_SUFFIX_LENGTH = lengthof(EVENT_ITF_SUFFIX);
-static const WCHAR         EVENT_HANDLER_SUFFIX[]      = {W("EventHandler")};
-static const DWORD         EVENT_HANDLER_SUFFIX_LENGTH = lengthof(EVENT_HANDLER_SUFFIX);
-
-static const WCHAR         EVENT_ADD_METH_PREFIX[]          = {W("add_")};
-static const DWORD         EVENT_ADD_METH_PREFIX_LENGTH   = lengthof(EVENT_ADD_METH_PREFIX);
-static const WCHAR         EVENT_REM_METH_PREFIX[]          = {W("remove_")};
-static const DWORD         EVENT_REM_METH_PREFIX_LENGTH   = lengthof(EVENT_REM_METH_PREFIX);
-
-static const WCHAR         DELEGATE_INVOKE_METH_NAME[]      = {W("Invoke")};
-static const DWORD         DELEGATE_INVOKE_METH_NAME_LENGTH = lengthof(EVENT_ADD_METH_PREFIX);
-
-// {C013B386-CC3E-4b6d-9B67-A3AE97274BBE}
-static const GUID FREE_STATUS_GUID = 
-{ 0xc013b386, 0xcc3e, 0x4b6d, { 0x9b, 0x67, 0xa3, 0xae, 0x97, 0x27, 0x4b, 0xbe } };
-
-// {C013B387-CC3E-4b6d-9B67-A3AE97274BBE}
-static const GUID DELETED_STATUS_GUID = 
-{ 0xc013b387, 0xcc3e, 0x4b6d, { 0x9b, 0x67, 0xa3, 0xae, 0x97, 0x27, 0x4b, 0xbe } };
-
-// {C013B388-CC3E-4b6d-9B67-A3AE97274BBE}
-static const GUID USED_STATUS_GUID = 
-{ 0xc013b388, 0xcc3e, 0x4b6d, { 0x9b, 0x67, 0xa3, 0xae, 0x97, 0x27, 0x4b, 0xbe } };
-
-static const GUID IID_IEnumerable = 
-{ 0x496b0abe, 0xcdee, 0x11d3, { 0x88, 0xe8, 0x00, 0x90, 0x27, 0x54, 0xc4, 0x3a } };
-
-
- #define STRUCTLAYOUT tdSequentialLayout
-// ULONG_MAX is a flag meaning "don't convert".
-static const ULONG rdwTypeFlags[] = {
-    tdPublic | tdSealed,                                // TKIND_ENUM       = 0,
-    tdPublic | tdSealed | tdBeforeFieldInit | STRUCTLAYOUT, // TKIND_RECORD    = TKIND_ENUM + 1,    
-    tdPublic | tdAbstract,                              // TKIND_MODULE     = TKIND_RECORD + 1,
-    tdPublic | tdInterface | tdAbstract | tdImport,     // TKIND_INTERFACE  = TKIND_MODULE + 1,
-    tdPublic | tdInterface | tdAbstract | tdImport,     // TKIND_DISPATCH   = TKIND_INTERFACE + 1,
-    tdPublic | tdImport,                                // TKIND_COCLASS    = TKIND_DISPATCH + 1,
-    tdPublic | tdImport,                                // TKIND_ALIAS      = TKIND_COCLASS + 1,
-    tdPublic | tdSealed | tdExplicitLayout,             // TKIND_UNION     = TKIND_ALIAS + 1,
-    ULONG_MAX,                                          // TKIND_MAX        = TKIND_UNION + 1
-};
-static const LPCWSTR g_szTypekind[] = {
-    W("Enum         "),
-    W("Record       "),
-    W("Module       "),
-    W("Interface    "),
-    W("Dispinterface"),
-    W("Coclass      "),
-    W("Alias        "),
-    W("Union        "),
-};
-
-#define NATIVE_TYPE_NONE ((CorNativeType)(NATIVE_TYPE_MAX+1))
-
-#define NON_CONVERTED_PARAMS_FLAGS (PARAMFLAG_FRETVAL|PARAMFLAG_FLCID)
-
-
-//*****************************************************************************
-// External declarations.
-//*****************************************************************************
-extern mdAssemblyRef DefineAssemblyRefForImportedTypeLib(
-    void        *pAssembly,             // Assembly importing the typelib.
-    void        *pvModule,              // Module importing the typelib.
-    IUnknown    *pIMeta,                // IMetaData* from import module.
-    IUnknown    *pIUnk,                 // IUnknown to referenced Assembly.
-    BSTR        *pwzNamespace,          // The namespace of the resolved assembly.
-    BSTR        *pwzAsmName,            // The name of the resolved assembly.
-    Assembly    **AssemblyRef);         // The resolved assembly.
-
-extern mdAssemblyRef DefineAssemblyRefForExportedAssembly(
-    LPCWSTR     szFullName,             // Assembly full name.
-    IUnknown    *pIMeta);               // Metadata emit interface.
-
-static HRESULT _UnpackVariantToConstantBlob(VARIANT *pvar, BYTE *pcvType, void **pvValue, __int64 *pd);
-static INT64 _DoubleDateToTicks(const double d);
-static HRESULT TryGetFuncDesc(ITypeInfo *pITI, int i, FUNCDESC **ppFunc);
-
-//*****************************************************************************
-// Class factory.
-//*****************************************************************************
-CImportTlb* CImportTlb::CreateImporter(
-    LPCWSTR     szLibrary, 
-    ITypeLib    *pitlb, 
-    BOOL        bGenerateTCEAdapters, 
-    BOOL        bUnsafeInterfaces,
-    BOOL        bSafeArrayAsSystemArray,
-    BOOL        bTransformDispRetVals,
-    BOOL        bPreventClassMembers,
-    BOOL        bSerializableValueClasses)
-{
-    return new (nothrow) CImportTlb(szLibrary, pitlb, bGenerateTCEAdapters, bUnsafeInterfaces, bSafeArrayAsSystemArray, bTransformDispRetVals, bPreventClassMembers, bSerializableValueClasses);
-} // CImportTlb* CImportTlb::CreateImporter()
-
-//*****************************************************************************
-// Default constructor.
-//*****************************************************************************
-CImportTlb::CImportTlb()
- :  m_szLibrary(NULL),
-    m_pITLB(NULL),
-    m_bGenerateTCEAdapters(false),
-    m_bSafeArrayAsSystemArray(false),
-    m_bTransformDispRetVals(false),
-    m_bPreventClassMembers(false),
-    m_bSerializableValueClasses(false),
-    m_pEmit(NULL),
-    m_pImport(NULL),
-    m_pITI(NULL),
-    m_pOrigITI(NULL),
-    m_psAttr(NULL),
-    m_arSystem(mdAssemblyRefNil),
-    m_Notify(NULL),
-    m_trValueType(0),
-    m_trEnum(0),
-    m_bUnsafeInterfaces(FALSE),
-    m_tkSuppressCheckAttr(mdTokenNil),
-    m_tdHasDefault(0),
-    m_szName(NULL),
-    m_szMember(NULL),
-    m_wzNamespace(NULL),
-    m_tkInterface(0),
-    m_szInterface(NULL),
-    m_pMemberNames(NULL),
-    m_cMemberProps(0),
-    m_ImplIface(eImplIfaceNone)
-{
-    // Clear the known types array.  The values will be lazily initialized.
-    memset(m_tkKnownTypes, 0, sizeof(m_tkKnownTypes));
-    memset(m_tkAttr, 0, sizeof(m_tkAttr));
-} // CImportTlb::CImportTlb()
-
-//*****************************************************************************
-// Complex constructor.
-//*****************************************************************************
-CImportTlb::CImportTlb(
-    LPCWSTR     szLibrary,              // Name of library being imported.   
-    ITypeLib    *pitlb,                 // The type library to import from.  
-    BOOL        bGenerateTCEAdapters,   // A flag indicating if the TCE adapters are being generated.
-    BOOL        bUnsafeInterfaces,      // A flag indicating that runtime security checks should be disabled
-    BOOL        bSafeArrayAsSystemArray,// A flag indicating whether to import SAFEARRAY's as System.Array's.
-    BOOL        bTransformDispRetVals,   // A flag indicating if we should do [out,retval] transformation on disp only itfs.
-    BOOL        bPreventClassMembers,   // A flag indicating if we should add members to CoClasses.
-    BOOL        bSerializableValueClasses) // A flag indicating if we should mark value classes serializable.
- :  m_szLibrary(szLibrary),
-    m_pITLB(pitlb),
-    m_bGenerateTCEAdapters(bGenerateTCEAdapters),
-    m_bUnsafeInterfaces(bUnsafeInterfaces),
-    m_bSafeArrayAsSystemArray(bSafeArrayAsSystemArray),
-    m_bTransformDispRetVals(bTransformDispRetVals),
-    m_bPreventClassMembers(bPreventClassMembers),
-    m_bSerializableValueClasses(bSerializableValueClasses),
-    m_pEmit(0),
-    m_pImport(0),
-    m_pITI(0),
-    m_pOrigITI(0),
-    m_psAttr(0),
-    m_arSystem(mdAssemblyRefNil),
-    m_Notify(0),
-    m_trValueType(0),
-    m_trEnum(0),
-    m_tkSuppressCheckAttr(mdTokenNil),
-    m_tdHasDefault(0),
-    m_szName(0),
-    m_szMember(0),
-    m_wzNamespace(0),
-    m_tkInterface(0),
-    m_szInterface(0),
-    m_pMemberNames(0),
-    m_cMemberProps(0),
-    m_ImplIface(eImplIfaceNone)
-{
-    if (pitlb)
-        pitlb->AddRef();
-
-    // Clear the known types array.  The values will be lazily initialized.
-    memset(m_tkKnownTypes, 0, sizeof(m_tkKnownTypes));
-    memset(m_tkAttr, 0, sizeof(m_tkAttr));
-    
-#if defined(TLB_STATS)
-    m_bStats = QueryPerformanceFrequency(&m_freqVal);
-#endif
-} // CImportTlb::CImportTlb()
-
-//*****************************************************************************
-// Destructor.
-//*****************************************************************************
-CImportTlb::~CImportTlb()
-{
-    if (m_pEmit)
-        m_pEmit->Release();
-    if (m_pImport)
-        m_pImport->Release();
-    if (m_pITLB)
-        m_pITLB->Release();
-    if (m_Notify)
-        m_Notify->Release();
-
-    if (m_wzNamespace)
-        ::SysFreeString(m_wzNamespace);
-} // CImportTlb::~CImportTlb()
-
-
-//*****************************************************************************
-// Allow the user to specify a namespace to be used in the conversion.
-//*****************************************************************************
-HRESULT CImportTlb::SetNamespace(
-    WCHAR const *pNamespace)
-{
-    HRESULT     hr=S_OK;                // A result.
-    
-    IfNullGo(m_wzNamespace=::SysAllocString(pNamespace));
-    
-ErrExit:
-    
-    return hr;
-} // HRESULT CImportTlb::SetNamespace()
-
-//*****************************************************************************
-// Allow the user to specify a notification object to be used in the conversion.
-//*****************************************************************************
-HRESULT CImportTlb::SetNotification(
-    ITypeLibImporterNotifySink *pNotify)
-{
-    _ASSERTE(m_Notify == 0);
-    m_Notify = pNotify;
-    pNotify->AddRef();
-
-    return S_OK;
-} // HRESULT CImportTlb::SetNotification()
-
-//*****************************************************************************
-// Allow the user to specify the MetaData scope to be used in the conversion.
-//*****************************************************************************
-HRESULT CImportTlb::SetMetaData(
-    IUnknown    *pIUnk)
-{
-    HRESULT     hr;
-    _ASSERTE(m_pEmit == 0);
-    IfFailGo(pIUnk->QueryInterface(IID_IMetaDataEmit2, (void**)&m_pEmit));
-ErrExit:
-    return hr;    
-} // HRESULT CImportTlb::SetMetaData()
-
-//*****************************************************************************
-// Import a TypeLibrary into a CompLib.
-//*****************************************************************************
-HRESULT CImportTlb::Import()
-{
-#ifndef DACCESS_COMPILE
-    HRESULT     hr;                     // A result.
-    mdModule    md;                     // Module token.
-    VARIANT     vt = {0};               // For setting options.
-    ITypeLib2   *pITLB2 = 0;            // To get custom attributes.
-    IMetaDataDispenserEx *pDisp = 0;    // To create export scope.
-    TLIBATTR    *psAttr=0;              // The library's attributes.
-    BSTR        szLibraryName = 0;      // The library's name.
-    LPCWSTR     wzFile;                 // The filename of the typelib (no path).
-    LPCWSTR     wzSource;               // Source of the typelib, for CA.
-    
-    _ASSERTE(m_Notify);
-
-    // Quick sanity check.
-    if (!m_pITLB)
-        return (E_INVALIDARG);
-
-    // Check to see if the type library implements ITypeLib2.
-    if (m_pITLB->QueryInterface(IID_ITypeLib2, (void **)&pITLB2) != S_OK)
-        pITLB2 = 0;
-
-    // If custom attribute for namespace exists, use it.
-    if (pITLB2)
-    {
-        VARIANT vt;
-        VariantInit(&vt);
-        if (pITLB2->GetCustData(GUID_ManagedName, &vt) == S_OK)
-        {   
-            if (V_VT(&vt) == VT_BSTR)
-            {
-                // If there already was a namespace set, release it.
-                if (m_wzNamespace)
-                    SysFreeString(m_wzNamespace);
-            
-                // If the namespace ends with .dll then remove the extension.
-                LPWSTR pDest = wcsstr(vt.bstrVal, DLL_EXTENSION);
-                if (pDest && (pDest[DLL_EXTENSION_LEN] == 0 || pDest[DLL_EXTENSION_LEN] == ' '))
-                    *pDest = 0;
-
-                if (!pDest)
-                {
-                    // If the namespace ends with .exe then remove the extension.
-                    pDest = wcsstr(vt.bstrVal, EXE_EXTENSION);
-                    if (pDest && (pDest[EXE_EXTENSION_LEN] == 0 || pDest[EXE_EXTENSION_LEN] == ' '))
-                        *pDest = 0;
-                }
-
-                if (pDest)
-                {
-                    // We removed the extension so re-allocate a string of the new length.
-                    m_wzNamespace = SysAllocString(vt.bstrVal);
-                    SysFreeString(vt.bstrVal);
-                    IfNullGo(m_wzNamespace);
-                }
-                else
-                {
-                    // There was no extension to remove so we can use the string returned
-                    // by GetCustData().
-                    m_wzNamespace = vt.bstrVal;
-                }        
-            }
-            else
-            {
-                VariantClear(&vt);
-            }
-        }
-    }
-
-    // Use the namespace name if we don't know the filename.
-    if (!m_szLibrary)
-        m_szLibrary = m_wzNamespace;
-    
-    // If the typelib was exported from COM+ to begin with, don't import it.
-    if (pITLB2)
-    {
-        ::VariantInit(&vt);
-        hr = pITLB2->GetCustData(GUID_ExportedFromComPlus, &vt);
-        if (vt.vt != VT_EMPTY)
-        {
-            if (0)
-            {
-                // com emulates option is ON
-            }
-            else
-            {
-                IfFailGo(PostError(TLBX_E_CIRCULAR_IMPORT, m_szLibrary));
-            }
-        }
-    }
-
-    _ASSERTE(m_pEmit);
-    IfFailGo(m_pEmit->QueryInterface(IID_IMetaDataImport2, (void **)&m_pImport));
-
-    // Initialize the reserved names map.
-    IfFailGo(m_ReservedNames.Init());
-
-    // Initialize the default interface to class interface map for the TLB being imported.
-    IfFailGo(m_DefItfToClassItfMap.Init(m_pITLB, m_wzNamespace));
-
-    // Create the Object classref record and AssemblyRef for mscorlib.dll.
-    IfFailGo(_DefineSysRefs());    
-    
-    // Create the library record.
-    IfFailGo(_NewLibraryObject());
-
-    // Note that this was imported.
-    IfFailGo(m_pITLB->GetLibAttr(&psAttr));
-    if (SUCCEEDED(::QueryPathOfRegTypeLib(psAttr->guid, psAttr->wMajorVerNum, psAttr->wMinorVerNum,  psAttr->lcid, &szLibraryName)))
-        wzSource = szLibraryName;
-    else
-        wzSource = m_szLibrary;
-
-    // We can't base the decision on SYSKIND.  For example, we can have a SYS_WIN64 tlb loaded as 32-bit with 4-byte aligned pointers.
-    m_cbVtableSlot = 0;
-
-    IfFailGo(m_pImport->GetModuleFromScope(&md));
-    // Skip the path or drive info 
-    wzFile = wcsrchr(wzSource, W('\\'));
-    if (wzFile == 0)
-    {   // That's odd, should have been a fully qualified path.  Just use an empty string.
-        wzFile = W("");
-    }
-    else
-    {   // skip leading backslash
-        wzFile++;
-    }
-
-    // Convert the typelib.
-    IfFailGo(ConvertTypeLib());
-
-ErrExit:
-    if (psAttr)
-        m_pITLB->ReleaseTLibAttr(psAttr);
-    if (szLibraryName)
-        ::SysFreeString(szLibraryName);
-    if (pITLB2)
-        pITLB2->Release();
-    if (pDisp)
-        pDisp->Release();
-
-    return (hr);
-#else
-    DacNotImpl();
-    return E_NOTIMPL;
-#endif // #ifndef DACCESS_COMPILE
-} // HRESULT CImportTlb::Import()
-    
-//*****************************************************************************
-// Create the Complib to represent the TypeLib.
-//*****************************************************************************
-HRESULT CImportTlb::_NewLibraryObject()
-{
-    HRESULT             hr;                     // A result.
-    TLIBATTR *          psAttr=0;               // The library's attributes.
-    BSTR                szLibraryName=0;        // The library's name.
-    CQuickArray<WCHAR>  rScopeName;             // The name of the scope.
-
-    // Information about the library.
-    IfFailGo(m_pITLB->GetLibAttr(&psAttr));
-    IfFailGo(m_pITLB->GetDocumentation(MEMBERID_NIL, &szLibraryName, 0, 0, 0));
-
-    // Create the scope name by using the typelib name and adding .dll.
-    IfFailGo(rScopeName.ReSizeNoThrow(SysStringLen(szLibraryName) + 5 * sizeof(WCHAR)));
-    StringCchPrintf(rScopeName.Ptr(), rScopeName.Size(), W("%s.dll"), szLibraryName);
-
-    IfFailGo(m_pEmit->SetModuleProps(rScopeName.Ptr()));
-
-ErrExit:
-    if (psAttr)
-        m_pITLB->ReleaseTLibAttr(psAttr);
-
-    if (szLibraryName)
-        ::SysFreeString(szLibraryName);
-
-    return (hr);
-} // HRESULT CImportTlb::_NewLibraryObject()
-
-//*****************************************************************************
-// Define an assembly ref for mscorlib, typeref for Object.
-//*****************************************************************************
-HRESULT CImportTlb::_DefineSysRefs()
-{
-    HRESULT     hr;                     // A result.
-    WCHAR       szPath[_MAX_PATH];
-    WCHAR       szDrive[_MAX_DRIVE];
-    WCHAR       szDir[_MAX_PATH];
-    DWORD       dwLen;                  // Length of system directory name.
-    IMetaDataDispenserEx *pDisp = 0;    // To import mscorlib.
-    IMetaDataAssemblyImport *pAImp = 0; // To read mscorlib assembly.
-    IMetaDataAssemblyEmit *pAEmit = 0;  // To create mscorlib assembly ref.
-    ASSEMBLYMETADATA amd = {0};         // Assembly metadata.
-    mdToken     tk;                     // A token.
-    const void  *pvPublicKey;           // Public key.
-    ULONG       cbPublicKey;            // Length of public key.
-    BYTE        *pbToken=0;             // Compressed token for public key.
-    ULONG       cbToken;                // Length of token.
-    ULONG       ulHashAlg;              // Hash algorithm.
-    DWORD       dwFlags;                // Assembly flags.
-
-    // Get the dispenser.
-    IfFailGo(g_pCLRRuntime->GetInterface(
-        CLSID_CorMetaDataDispenser, 
-        IID_IMetaDataDispenserEx, 
-        (void **)&pDisp));
-
-    // Get the name of mscorlib.
-    //@todo: define, function, etc., instead of hard coded "mscorlib"
-    dwLen = lengthof(szPath) - 13; // allow space for "mscorlib" ".dll" "\0"
-    IfFailGo(pDisp->GetCORSystemDirectory(szPath, dwLen, &dwLen));
-    SplitPath(szPath, szDrive, _MAX_DRIVE, szDir, _MAX_PATH, 0, 0, 0, 0);
-    MakePath(szPath, szDrive, szDir, W("mscorlib"), W(".dll"));
-    
-    // Open the scope, get the details.
-    IfFailGo(pDisp->OpenScope(szPath, 0, IID_IMetaDataAssemblyImport, (IUnknown**)&pAImp));
-    IfFailGo(pAImp->GetAssemblyFromScope(&tk));
-    IfFailGo(pAImp->GetAssemblyProps(tk, &pvPublicKey,&cbPublicKey, &ulHashAlg, 
-        szPath,lengthof(szPath),&dwLen, &amd, &dwFlags));
-    
-    if (!StrongNameTokenFromPublicKey((BYTE*)(pvPublicKey),cbPublicKey, &pbToken,&cbToken))
-    {
-        hr = StrongNameErrorInfo();
-        goto ErrExit;
-    }
-    dwFlags &= ~afPublicKey;
-    
-    // Define the assembly ref.
-    IfFailGo(m_pEmit->QueryInterface(IID_IMetaDataAssemblyEmit, (void**)&pAEmit));
-    IfFailGo(pAEmit->DefineAssemblyRef(pbToken,cbToken, szPath, &amd,0,0,dwFlags, &m_arSystem));
-    
-    IfFailGo(m_TRMap.DefineTypeRef(m_pEmit, m_arSystem, szObject, &m_trObject));
-    
-    m_tkKnownTypes[VT_DISPATCH] = m_trObject;
-    m_tkKnownTypes[VT_UNKNOWN] = m_trObject;
-    m_tkKnownTypes[VT_VARIANT] = m_trObject;
-    
-ErrExit:
-    if (pbToken)
-        StrongNameFreeBuffer(pbToken);
-    if (pDisp)
-        pDisp->Release();
-    if (pAEmit)
-        pAEmit->Release();
-    if (pAImp)
-        pAImp->Release();
-
-    return hr;
-} // HRESULT CImportTlb::_DefineSysRefs()
-
-//*****************************************************************************
-// Lazily get the token for a CustomAttribute.
-//*****************************************************************************
-HRESULT CImportTlb::GetAttrType(
-    int         attr,                   // The attribute for which the type is desired.
-    mdToken     *pTk)                   // Put the type here.
-{
-    HRESULT     hr = S_OK;              // A result.
-    mdTypeRef   tr;                     // An intermediate typeref.
-    DWORD           dwSigSize;          // The size of the sig for special sigs.
-    DWORD           dwMaxSigSize;       // The max size of the special sig.
-    COR_SIGNATURE   *pSig;              // Pointer to the start of the sig,
-    COR_SIGNATURE   *pCurr;             // Current sig pointer.
-    mdTypeRef       trType;             // The typeref for System.Type.
-
-    _ASSERTE(attr >= 0);
-    _ASSERTE(attr < ATTR_COUNT);
-
-    //@todo: globally define these names.
-#define INTEROP_ATTRIBUTE(x) static COR_SIGNATURE x##_SIG[] = INTEROP_##x##_SIG;
-#define INTEROP_ATTRIBUTE_SPECIAL(x)
-    INTEROP_ATTRIBUTES();
-#undef INTEROP_ATTRIBUTE
-#undef INTEROP_ATTRIBUTE_SPECIAL
-#define INTEROP_ATTRIBUTE(x) \
-    case ATTR_##x: \
-        IfFailGo(m_pEmit->DefineTypeRefByName(m_arSystem, INTEROP_##x##_TYPE_W, &tr)); \
-        IfFailGo(m_pEmit->DefineMemberRef(tr, W(".ctor"), x##_SIG, lengthof(x##_SIG), &m_tkAttr[attr])); \
-        break;
-#define INTEROP_ATTRIBUTE_SPECIAL(x)
-
-    if (IsNilToken(m_tkAttr[attr]))
-    {
-        switch (attr)
-        {
-            INTEROP_ATTRIBUTES();
-
-            case ATTR_COMEVENTINTERFACE:
-            {
-                // Retrieve token for System.Type.
-                IfFailGo(GetKnownTypeToken(VT_SLOT_FOR_TYPE, &trType));
-
-                // Build the sig.
-                dwMaxSigSize = 5 + sizeof(mdTypeRef) * 2;
-                pSig = (COR_SIGNATURE*)_alloca(dwMaxSigSize);
-                pCurr = pSig;
-                *pCurr++ = IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS;
-                *pCurr++ = 2;
-                *pCurr++ = ELEMENT_TYPE_VOID;
-                *pCurr++ = ELEMENT_TYPE_CLASS;
-                pCurr += CorSigCompressToken(trType, pCurr);
-                *pCurr++ = ELEMENT_TYPE_CLASS;
-                pCurr += CorSigCompressToken(trType, pCurr);
-                dwSigSize = (DWORD)(pCurr - pSig);
-                _ASSERTE(dwSigSize <= dwMaxSigSize);
-
-                // Declare the typeref and the member ref for the CA.
-                IfFailGo(m_pEmit->DefineTypeRefByName(m_arSystem, INTEROP_COMEVENTINTERFACE_TYPE_W, &tr)); \
-                IfFailGo(m_pEmit->DefineMemberRef(tr, W(".ctor"), pSig, dwSigSize, &m_tkAttr[attr])); \
-                break;
-            }
-
-            case ATTR_COCLASS:
-            {
-                // Retrieve token for System.Type.
-                IfFailGo(GetKnownTypeToken(VT_SLOT_FOR_TYPE, &trType));
-
-                // Build the sig.
-                dwMaxSigSize = 4 + sizeof(mdTypeRef);
-                pSig = (COR_SIGNATURE*)_alloca(dwMaxSigSize);
-                pCurr = pSig;
-                *pCurr++ = IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS;
-                *pCurr++ = 1;
-                *pCurr++ = ELEMENT_TYPE_VOID;
-                *pCurr++ = ELEMENT_TYPE_CLASS;
-                pCurr += CorSigCompressToken(trType, pCurr);
-                dwSigSize = (DWORD)(pCurr - pSig);
-                _ASSERTE(dwSigSize <= dwMaxSigSize);
-
-                // Declare the typeref and the member ref for the CA.
-                IfFailGo(m_pEmit->DefineTypeRefByName(m_arSystem, INTEROP_COCLASS_TYPE_W, &tr)); \
-                IfFailGo(m_pEmit->DefineMemberRef(tr, W(".ctor"), pSig, dwSigSize, &m_tkAttr[attr])); \
-                break;
-            }
-        }
-    }
-#undef INTEROP_ATTRIBUTE
-#undef INTEROP_ATTRIBUTE_SPECIAL
-
-    *pTk = m_tkAttr[attr];
-ErrExit:
-    return hr;  
-} // HRESULT CImportTlb::GetAttrType()
-
-//*****************************************************************************
-// Create the TypeDefs.
-//*****************************************************************************
-HRESULT 
-CImportTlb::ConvertTypeLib()
-{
-    HRESULT hr;
-    int     cTi;    // Count of TypeInfos.
-    int     i;      // Loop control.
-    
-    // How many TypeInfos?
-    IfFailGo(cTi = m_pITLB->GetTypeInfoCount());
-    
-    // Iterate over them.
-    for (i = 0; i < cTi; ++i)
-    {
-        // Get the TypeInfo.
-        hr = m_pITLB->GetTypeInfo(i, &m_pITI);
-        if (SUCCEEDED(hr))
-        {
-            // Save up the original TypeInfo (may be later alias-resolved).
-            _ASSERTE(m_pOrigITI == NULL);
-            m_pOrigITI = m_pITI;
-            m_pOrigITI->AddRef();
-            
-            // Retrieve the attributes of the type info.
-            IfFailGo(m_pITI->GetTypeAttr(&m_psAttr));
-            
-            // Convert the TypeInfo.
-            hr = ConvertTypeInfo();
-            if (FAILED(hr))
-            {
-                if (hr == CEE_E_CVTRES_NOT_FOUND || hr == TLBX_I_RESOLVEREFFAILED)
-                {   // Reflection emit is broken, no need to try to continue.
-                    goto ErrExit;
-                }
-                
-                BSTR szTypeInfoName = NULL;
-                hr = m_pITI->GetDocumentation(MEMBERID_NIL, &szTypeInfoName, 0, 0, 0);
-                if (SUCCEEDED(hr))
-                {
-                    ReportEvent(NOTIF_CONVERTWARNING, TLBX_E_INVALID_TYPEINFO, szTypeInfoName);
-                }
-                else
-                {
-                    ReportEvent(NOTIF_CONVERTWARNING, TLBX_E_INVALID_TYPEINFO_UNNAMED, i);
-                }
-                if (szTypeInfoName != NULL)
-                    ::SysFreeString(szTypeInfoName);
-#if defined(_DEBUG)                
-                if (CLRConfig::GetConfigValue(CLRConfig::INTERNAL_MD_TlbImp_BreakOnErr))
-                    _ASSERTE(!"Invalid type");
-#endif                
-            }
-
-            // Release for next TypeInfo.
-            m_pOrigITI->Release();
-            m_pOrigITI = NULL;
-      
-            m_pITI->ReleaseTypeAttr(m_psAttr);
-            m_psAttr = NULL;
-            m_pITI->Release();
-            m_pITI = NULL;
-        }
-    }
-    
-ErrExit:
-    if (m_pOrigITI != NULL)
-    {
-        m_pOrigITI->Release();
-        m_pOrigITI = NULL;
-    }
-    
-    if (m_psAttr != NULL)
-    {
-        m_pITI->ReleaseTypeAttr(m_psAttr);
-        m_psAttr = NULL;
-    }
-    if (m_pITI != NULL)
-    {
-        m_pITI->Release();
-        m_pITI = NULL;
-    }
-    return hr;
-} // CImportTlb::ConvertTypeLib
-
-//*****************************************************************************
-// Convert a single ITypeInfo into the scope.
-//*****************************************************************************
-HRESULT CImportTlb::ConvertTypeInfo()   // S_OK or error.
-{
-    HRESULT     hr;                     // A result.
-    BSTR        bstrManagedName=0;      // Managed name (or part thereof).
-    CQuickArray<WCHAR> qbClassName;     // The name of the class.
-    ULONG       ulFlags;                // TypeDef flags.
-    WORD        wTypeInfoFlags;         // TypeInfo flags.  Alias flags, if an alias.
-    mdToken     tkAttr;                 // Attribute type for flags.
-    TYPEKIND    tkindAlias;             // TYPEKIND of an aliased TypeInfo.
-    GUID        guid;                   // GUID of the typeinfo.
-    BOOL        bConversionLoss=false;  // If true, info was lost converting sigs.
-    mdToken     tkParent;               // Parent of the typedef.
-    mdToken     td;                     // For looking up a TypeDef.
-    ITypeInfo2  *pITI2=0;               // For getting custom value.
-    
-#if defined(TLB_STATS)
-    WCHAR       rcStats[16];            // Buffer for stats.
-    LARGE_INTEGER __startVal;
-    QueryPerformanceCounter(&__startVal); 
-#endif
-    
-    m_tdTypeDef = mdTypeDefNil;
-    
-    // Get some information about the TypeInfo.
-    IfFailGo(m_pITI->GetDocumentation(MEMBERID_NIL, &m_szName, 0, 0, 0));
-    
-#if defined(_DEBUG)                
-    LPWSTR strShouldBreakOnTypeName = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_MD_TlbImp_BreakOnTypeImport);
-    if ((NULL != strShouldBreakOnTypeName) && (wcsncmp(strShouldBreakOnTypeName, m_szName, MAX_CLASSNAME_LENGTH) == 0))
-        _ASSERTE(!"MD_TlbImp_BreakOnTypeImport");
-#endif                
-
-    // Assume that we will be able to convert the typeinfo.
-    guid = m_psAttr->guid;
-    wTypeInfoFlags = m_psAttr->wTypeFlags;
-    
-    // If this typeinfo is an alias, see what it is an alias for.  If for a built-in
-    //  type, we will just skip it.  If for a user-defined type, we will duplicate
-    //  that definition under this alias' name and guid.
-    if (m_psAttr->typekind == TKIND_ALIAS)
-    {
-        hr = _ResolveTypeDescAliasTypeKind(m_pITI, &m_psAttr->tdescAlias, &tkindAlias);
-        IfFailGo(hr);
-        if (hr == S_OK)
-        {
-            TYPEDESC tdesc = m_psAttr->tdescAlias;
-            m_pITI->ReleaseTypeAttr(m_psAttr);
-            m_pITI->Release();
-
-            IfFailGo(_ResolveTypeDescAlias(m_pOrigITI, &tdesc, &m_pITI, &m_psAttr, &guid));
-            // Now m_pOrigITI refers to the alias whereas m_pITI is the TypeInfo of the aliased type.
-
-            // We should no longer have an alias.
-            _ASSERTE(m_psAttr->typekind == tkindAlias);
-            _ASSERTE(tkindAlias != TKIND_ALIAS);
-
-            ulFlags = rdwTypeFlags[tkindAlias];
-        }
-        else
-            ulFlags = ULONG_MAX;
-    }
-    else
-    {
-        ulFlags = rdwTypeFlags[m_psAttr->typekind];
-    }
-
-    // Figure out the name.
-
-    // If the type info is for a CoClass, we need to decorate the name.
-    if (m_psAttr->typekind == TKIND_COCLASS)
-    {
-        // Generate a mangled name for the component.
-        IfFailGo(GetManagedNameForCoClass(m_pOrigITI, qbClassName));
-        m_szMngName = qbClassName.Ptr();
-    }   
-    else 
-    {
-        IfFailGo(GetManagedNameForTypeInfo(m_pOrigITI, m_wzNamespace, NULL, &bstrManagedName));
-        m_szMngName = bstrManagedName;
-    }
-    
-    if (m_psAttr->typekind == TKIND_INTERFACE ||
-        (m_psAttr->typekind == TKIND_DISPATCH && m_psAttr->wTypeFlags & TYPEFLAG_FDUAL))
-    {
-        // If the interface is not derived from IUnknown, or not an interface, we can't convert it.
-        if (IsIUnknownDerived(m_pITI, m_psAttr) != S_OK)
-        {
-            ReportEvent(NOTIF_CONVERTWARNING, TLBX_E_NOTIUNKNOWN, m_szName);
-            ulFlags = ULONG_MAX;
-        }
-        // If the interface is not derived from IDispatch, but claims to be [dual], give a warning but convert it.
-        if ((m_psAttr->wTypeFlags & TYPEFLAG_FDUAL) && IsIDispatchDerived(m_pITI, m_psAttr) != S_OK)
-        {
-            ReportEvent(NOTIF_CONVERTWARNING, TLBX_W_DUAL_NOT_DISPATCH, m_szName);
-        }
-    }
-    else
-    if (m_psAttr->typekind == TKIND_MODULE)
-    {   // If module has no vars, skip it.  We currently don't import module functions.
-        if (m_psAttr->cVars == 0)
-            ulFlags = ULONG_MAX;
-    }
-    
-    // If something we can convert...
-    if (ulFlags != ULONG_MAX)
-    {   
-        // Interfaces derive from nil...
-        if (IsTdInterface(ulFlags))
-            tkParent = mdTypeDefNil;
-        else  // ... enums from Enum, ...
-        if (m_psAttr->typekind == TKIND_ENUM)
-        {
-            if (IsNilToken(m_trEnum))
-                IfFailGo(m_TRMap.DefineTypeRef(m_pEmit, m_arSystem, szEnum, &m_trEnum));
-            tkParent = m_trEnum;
-        }
-        else // ... structs from ValueType, ...
-        if (m_psAttr->typekind == TKIND_RECORD || m_psAttr->typekind == TKIND_UNION)
-        {
-            if (IsNilToken(m_trValueType))
-                IfFailGo(m_TRMap.DefineTypeRef(m_pEmit, m_arSystem, szValueType, &m_trValueType));
-            tkParent = m_trValueType;
-        }
-        else // ... and classes derive from Object.
-            tkParent = m_trObject;
-
-        // The typelib importer generates metadata into an empty ReflectionEmit scope.  Because
-        //  RE manages type names itself, duplicate checking is turned off.  Because of user-defined
-        //  names (via CUSTOM), it is possible for the user to declare a duplicate.  So,
-        //  before adding the new type, check for duplicates.
-        hr = m_pImport->FindTypeDefByName(m_szMngName, mdTypeDefNil, &td);
-        if (hr != CLDB_E_RECORD_NOTFOUND)
-        {
-            ReportEvent(NOTIF_CONVERTWARNING, TLBX_E_DUPLICATE_TYPE_NAME, m_szMngName);
-            IfFailGo(TLBX_E_DUPLICATE_TYPE_NAME);
-        }
-
-        // Create the typedef.
-        IfFailGo(m_pEmit->DefineTypeDef(m_szMngName, ulFlags, tkParent, 0, &m_tdTypeDef));
-        IfFailGo(_AddGuidCa(m_tdTypeDef, guid));
-
-        // Save the typeinfo flags.
-        if (wTypeInfoFlags)
-        {
-            IfFailGo(GetAttrType(ATTR_TYPELIBTYPE, &tkAttr));
-            DECLARE_CUSTOM_ATTRIBUTE(sizeof(WORD));
-            BUILD_CUSTOM_ATTRIBUTE(WORD, wTypeInfoFlags);
-            FINISH_CUSTOM_ATTRIBUTE();
-            IfFailGo(m_pEmit->DefineCustomAttribute(m_tdTypeDef, tkAttr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(),0));
-        }
-
-        // Mark unsafe interfaces (suppressed security runtime checks).
-        if (m_bUnsafeInterfaces)
-        {
-            if (m_tkSuppressCheckAttr == mdTokenNil)
-            {
-                mdTypeRef       tr;
-                COR_SIGNATURE   rSig[] = {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 0, ELEMENT_TYPE_VOID};
-                IfFailGo(m_pEmit->DefineTypeRefByName(m_arSystem, COR_SUPPRESS_UNMANAGED_CODE_CHECK_ATTRIBUTE, &tr));
-                IfFailGo(m_pEmit->DefineMemberRef(tr, COR_CTOR_METHOD_NAME_W, rSig, lengthof(rSig), &m_tkSuppressCheckAttr));
-            }
-
-            DECLARE_CUSTOM_ATTRIBUTE(0);
-            FINISH_CUSTOM_ATTRIBUTE();
-            IfFailGo(m_pEmit->DefineCustomAttribute(m_tdTypeDef, m_tkSuppressCheckAttr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(), 0));
-        }
-
-        // Fill in the details depending on the type of the TypeInfo.
-        switch (m_psAttr->typekind)
-        {
-        case TKIND_ENUM:
-            hr = ConvEnum(m_pITI, m_psAttr);
-            break;
-            
-        case TKIND_RECORD:
-            hr = ConvRecord(m_pITI, m_psAttr, FALSE);
-            break;
-            
-        case TKIND_UNION:
-            hr = ConvRecord(m_pITI, m_psAttr, TRUE);
-            break;
-            
-        case TKIND_MODULE:
-            hr = ConvModule(m_pITI, m_psAttr);
-            break;
-            
-        case TKIND_INTERFACE:
-            hr = ConvIface(m_pITI, m_psAttr);
-            break;
-            
-        case TKIND_DISPATCH:
-            hr = ConvDispatch(m_pITI, m_psAttr);
-            break;
-            
-        case TKIND_COCLASS:
-            hr = ConvCoclass(m_pITI, m_psAttr);
-            break;
-            
-        case TKIND_ALIAS:
-            _ASSERTE(!"Alias should have been resolved!");
-            break;
-            
-        default:
-            _ASSERTE(!"Unexpected TYPEKIND");
-            break;
-        }
-        if (FAILED(hr))
-            goto ErrExit;
-        
-        if (hr == S_CONVERSION_LOSS)
-        {
-            bConversionLoss = true;
-            IfFailGo(GetAttrType(ATTR_COMCONVERSIONLOSS, &tkAttr));
-            DECLARE_CUSTOM_ATTRIBUTE(0);
-            FINISH_CUSTOM_ATTRIBUTE();
-            IfFailGo(m_pEmit->DefineCustomAttribute(m_tdTypeDef, tkAttr, PTROF_CUSTOM_ATTRIBUTE(),SIZEOF_CUSTOM_ATTRIBUTE(),0));
-        }
-
-    }
-    
-    if (bConversionLoss)
-        hr = S_CONVERSION_LOSS;
-    else
-        hr = S_OK;
-        
-#if defined(TLB_STATS)
-    LARGE_INTEGER __stopVal;
-    QueryPerformanceCounter(&__stopVal);
-    DWORD __delta;
-    __delta = (DWORD)(__stopVal.QuadPart - __startVal.QuadPart);
-    StringCchPrintf(rcStats, COUNTOF(rcStats), W("  %.2f"), 
-            ((float)__delta*1000)/(float)m_freqVal.QuadPart);
-#endif
-    
-    // Report that this type has been converted.
-    ReportEvent(NOTIF_TYPECONVERTED, TLBX_I_TYPEINFO_IMPORTED, m_szName);
-    
-ErrExit:
-    if (pITI2)
-        pITI2->Release();
-    if (m_szName)
-        ::SysFreeString(m_szName), m_szName = 0;
-    if (bstrManagedName)
-        ::SysFreeString(bstrManagedName);
-    return (hr);
-} // HRESULT CImportTlb::ConvertTypeInfo()
-
-
-//*****************************************************************************
-// Determine if the type explicitly implements IEnumerable.
-//*****************************************************************************
-HRESULT CImportTlb::ExplicitlyImplementsIEnumerable(
-    ITypeInfo   *pITI,                  // ITypeInfo* to check for IEnumerable.
-    TYPEATTR    *psAttr,                // TYPEATTR of TypeInfo.
-    BOOL        fLookupPartner)         // Flag indicating if we should look at the partner itf.
-{
-    HREFTYPE    href;                   // HREFTYPE of an implemented interface.
-    ITypeInfo   *pItiIface=0;           // ITypeInfo for an interface.
-    TYPEATTR    *psAttrIface=0;         // TYPEATTR for an interface.
-    BOOL        fFoundImpl = FALSE;
-    int         i = 0;
-    HRESULT     hr = S_OK;
-    ITypeInfo*  pITISelf2 = NULL;
-    TYPEATTR    psAttrSelf2;
-    int         ImplFlags = 0;
-    
-    // Look through each of the implemented/inherited interfaces
-    for (i=0; i<psAttr->cImplTypes && !fFoundImpl; ++i)
-    {
-        // Get an interface
-        IfFailGo(pITI->GetRefTypeOfImplType(i, &href));
-        IfFailGo(pITI->GetRefTypeInfo(href, &pItiIface));
-        IfFailGo(pItiIface->GetTypeAttr(&psAttrIface));
-        IfFailGo(pITI->GetImplTypeFlags(i, &ImplFlags));
-
-        if (!(ImplFlags & IMPLTYPEFLAG_FSOURCE))
-        {
-            hr = ExplicitlyImplementsIEnumerable(pItiIface, psAttrIface, TRUE);
-            if (hr == S_OK)
-                fFoundImpl = TRUE;
-            
-            // Check this interface for the IEnumerable.
-            if (psAttrIface->guid == IID_IEnumerable)
-                fFoundImpl = TRUE;
-        }
-
-        pItiIface->ReleaseTypeAttr(psAttrIface);
-        psAttrIface = 0;
-        pItiIface->Release();
-        pItiIface = 0;
-    }
-
-    if ( fLookupPartner && (pITI->GetRefTypeOfImplType(-1, &href) == S_OK) )
-    {
-        IfFailGo(pITI->GetRefTypeInfo(href, &pItiIface));
-        IfFailGo(pItiIface->GetTypeAttr(&psAttrIface));
-
-        hr = ExplicitlyImplementsIEnumerable(pItiIface, psAttrIface, FALSE);
-        if (hr == S_OK)
-            fFoundImpl = TRUE;
-        
-        // Check this interface for the IEnumerable.
-        if (psAttrIface->guid == IID_IEnumerable)
-            fFoundImpl = TRUE;   
-    }
-
-
-ErrExit:
-    if (psAttrIface)
-        pItiIface->ReleaseTypeAttr(psAttrIface);
-    if (pItiIface)
-        pItiIface->Release();
-    
-    return (fFoundImpl) ? S_OK : S_FALSE;
-}
-
-
-//*****************************************************************************
-// Convert the details for a coclass.
-//*****************************************************************************
-#ifdef _PREFAST_
-#pragma warning(push)
-#pragma warning(disable:21000) // Suppress PREFast warning about overly large function
-#endif
-HRESULT CImportTlb::ConvCoclass(        // S_OK or error.
-    ITypeInfo   *pITI,                  // ITypeInfo* to convert.
-    TYPEATTR    *psAttr)                // TYPEATTR of TypeInfo.
-{
-    BOOL        fHadDefaultItf = FALSE;
-    HRESULT     hr;                     // A result.
-    int         i;                      // Loop control.
-    HREFTYPE    href;                   // HREFTYPE of an implemented interface.
-    ITypeInfo   *pItiIface=0;           // ITypeInfo for an interface.
-    TYPEATTR    *psAttrIface=0;         // TYPEATTR for an interface.
-    int         ImplFlags;              // ImplType flags.
-    mdToken     tkIface;                // Token for an interface.
-    CQuickArray<mdToken> rImpls;        // Array of implemented interfaces.
-    CQuickArray<mdToken> rEvents;       // Array of implemented event interfaces.
-    CQuickArray<mdToken> rTmpImpls;     // Temporary array of impls.
-    CQuickArray<ITypeInfo*> rImplTypes; // Array of implemented ITypeInfo*s.
-    CQuickArray<ITypeInfo*> rSrcTypes;  // Array of source ITypeInfo*s.
-    int         ixSrc;                  // Index into rSrcTypes for source interfaces.
-    int         ixImpl;                 // Index into rImpls for implemented interface.
-    int         ixTmpImpl;              // Index into rTmpImpls.
-    mdToken     mdCtor;                 // Dummy token for the object initializer.
-    mdToken     tkAttr;                 // Token for custom attribute type.
-    mdToken     token;                  // Dummy token for typeref.
-    BOOL        fInheritsIEnum = FALSE;
-    
-#ifdef _DEBUG
-    int         bImplIEnumerable=0;     // If true, the class implements IEnumerable.
-#endif
-
-    // Size the rImpls and rSrcs arrays large enough for impls, events, the IEnumerable itf and two ending nulls.
-    IfFailGo(rImpls.ReSizeNoThrow(psAttr->cImplTypes+2));
-    memset(rImpls.Ptr(), 0, (psAttr->cImplTypes+2)*sizeof(mdToken));
-    IfFailGo(rEvents.ReSizeNoThrow(psAttr->cImplTypes+1));
-    memset(rEvents.Ptr(), 0, (psAttr->cImplTypes+1)*sizeof(mdToken));
-    IfFailGo(rTmpImpls.ReSizeNoThrow(psAttr->cImplTypes+3));
-    memset(rTmpImpls.Ptr(), 0, (psAttr->cImplTypes+3)*sizeof(mdToken));    
-    IfFailGo(rImplTypes.ReSizeNoThrow(psAttr->cImplTypes+2));
-    memset(rImplTypes.Ptr(), 0, (psAttr->cImplTypes+2)*sizeof(ITypeInfo*));
-    IfFailGo(rSrcTypes.ReSizeNoThrow(psAttr->cImplTypes+1));
-    memset(rSrcTypes.Ptr(), 0, (psAttr->cImplTypes+1)*sizeof(ITypeInfo*));
-    ixImpl = -1;
-    ixSrc = -1;
-    ixTmpImpl = -1;
-
-    if (ExplicitlyImplementsIEnumerable(pITI, psAttr) == S_OK)
-        fInheritsIEnum = TRUE;
-
-    // Build the list of implemented and event interfaces.
-    // The EE cares about implemented interfaces, so we convert them to actual
-    //  tokens and add them to the typedef.  VB cares about event interfaces,
-    //  but we are going to add a list of typeref names as a custom attribute.
-    //  We can't build the list as we go along, because the default may not
-    //  be the first event source.  So, we store tokens for the implemented
-    //  interfaces, but ITypeInfo*s for the event sources.
-    for (i=0; i<psAttr->cImplTypes; ++i)
-    {
-        IfFailGo(pITI->GetRefTypeOfImplType(i, &href));
-        IfFailGo(pITI->GetRefTypeInfo(href, &pItiIface));
-        IfFailGo(pItiIface->GetTypeAttr(&psAttrIface));
-        IfFailGo(pITI->GetImplTypeFlags(i, &ImplFlags));
-        
-        // If the interface is derived from IUnknown, or not an interface, we can't use it as an interface.
-        // Don't add explicit IUnknown or IDispatch.
-        if ((IsIUnknownDerived(pItiIface, psAttrIface) != S_OK && psAttrIface->typekind != TKIND_DISPATCH) ||
-            psAttrIface->guid == IID_IDispatch ||
-            psAttrIface->guid == IID_IUnknown)
-        {
-            pItiIface->ReleaseTypeAttr(psAttrIface);
-            psAttrIface = 0;
-            pItiIface->Release();
-            pItiIface = 0;
-            continue;
-        }     
-
-        // Add the event to the impls list or the events list.
-        if (ImplFlags & IMPLTYPEFLAG_FSOURCE)
-        {
-            // Get the token for the event interface.
-            IfFailGo(_GetTokenForEventItf(pItiIface, &tkIface));
-
-            // If we've already marked this CoClass as implementing this source interface, don't do so again.
-            for (int iCheck=0; iCheck <= ixSrc; iCheck++)
-            {
-                if (rEvents[iCheck] == tkIface)
-                    goto LoopEnd;
-            }
-
-            // Add the source interface to the list of source interfaces.
-            ++ixSrc;
-
-            // If this is explicitly the default source interface...
-            if (ImplFlags & IMPLTYPEFLAG_FDEFAULT)
-            {   
-                // Put the def source ITypeInfo at the head of the list of source
-                // ITypeInfo's.
-                for (int ix = ixSrc; ix > 0; --ix)
-                {
-                    rSrcTypes[ix] = rSrcTypes[ix-1];
-                    rEvents[ix] = rEvents[ix-1];
-                }
-                rEvents[0] = tkIface;
-                rSrcTypes[0] = pItiIface;
-            }
-            else
-            {
-                rEvents[ixSrc] = tkIface;
-                rSrcTypes[ixSrc] = pItiIface;
-            }
-        }
-        else
-        {   
-            // Get the token for the interface.
-            IfFailGo(_GetTokenForTypeInfo(pItiIface, FALSE, &tkIface));
-
-            // If we've already marked this CoClass as implementing this interface, don't do so again.
-            for (int iCheck=0; iCheck <= ixImpl; iCheck++)
-            {
-                if (rImpls[iCheck] == tkIface)
-                    goto LoopEnd;
-            }
-    
-            // Add the implemented interface to the list of implemented interfaces.
-            ++ixImpl;
-
-            // If this is explicitly the default interface...
-            if (ImplFlags & IMPLTYPEFLAG_FDEFAULT)
-            {   
-                fHadDefaultItf = TRUE;
-                // Put the new interface at the start of the list.
-                for (int ix=ixImpl; ix > 0; --ix)
-                {
-                    rImpls[ix] = rImpls[ix-1];
-                    rImplTypes[ix] = rImplTypes[ix-1];
-                }
-                rImpls[0] = tkIface;
-                rImplTypes[0] = pItiIface;
-            }
-            else
-            {
-                rImpls[ixImpl] = tkIface;
-                rImplTypes[ixImpl] = pItiIface;
-            }
-        }
-
-LoopEnd:
-        pItiIface->ReleaseTypeAttr(psAttrIface);
-        psAttrIface = 0;
-        pItiIface = 0;  // Pointer now owned by array.
-    }
-
-    // Create an interface that will represent the class.
-    IfFailGo(_CreateClassInterface(pITI, rImplTypes[0], rImpls[0], rEvents[0], &tkIface));
-
-    // Create a temporary array of interface tokens.
-    if (fHadDefaultItf)
-    {
-        // default interface should be the first interface
-        rTmpImpls[++ixTmpImpl] = rImpls[0];
-        rTmpImpls[++ixTmpImpl] = tkIface;
-    }
-    else
-    {        
-        rTmpImpls[++ixTmpImpl] = tkIface;
-        if (ixImpl >= 0)
-            rTmpImpls[++ixTmpImpl] = rImpls[0];
-    }
-    if (ixSrc >= 0)
-        rTmpImpls[++ixTmpImpl] = rEvents[0];
-    if (ixImpl >= 0)
-    {
-        memcpy(&rTmpImpls[ixTmpImpl + 1], &rImpls[1], ixImpl * sizeof(mdTypeRef));
-        ixTmpImpl += ixImpl;
-    }
-    if (ixSrc >= 0)
-    {
-        memcpy(&rTmpImpls[ixTmpImpl + 1], &rEvents[1], ixSrc * sizeof(mdTypeRef));
-        ixTmpImpl += ixSrc;
-    }
-
-    // Check to see if the default interface has a member with a DISPID of DISPID_NEWENUM.
-    BOOL fIEnumFound = FALSE;
-    if (ixImpl >= 0)
-    {
-        // The ITypeInfo for the default interface had better be set.
-        _ASSERTE(rImplTypes[0]);
-        
-        if ( (!fInheritsIEnum) && (HasNewEnumMember(rImplTypes[0]) == S_OK) )
-        {
-            IfFailGo(GetKnownTypeToken(VT_SLOT_FOR_IENUMERABLE, &tkIface));
-            rTmpImpls[++ixTmpImpl] = tkIface;
-            fIEnumFound = TRUE;
-        }
-    }
-
-    // Else Check to see if the IEnumerable Custom Value exists on the CoClass.
-    if (!fIEnumFound)
-    {
-        BOOL CVExists = FALSE;
-        _ForceIEnumerableCVExists(pITI, &CVExists);
-        if (CVExists && !fInheritsIEnum)
-        {
-            IfFailGo(GetKnownTypeToken(VT_SLOT_FOR_IENUMERABLE, &tkIface));
-            rTmpImpls[++ixTmpImpl] = tkIface;
-            fIEnumFound = TRUE;
-        }
-    }
-
-    // Add the implemented interfaces and event interfaces to the TypeDef.
-    IfFailGo(m_pEmit->SetTypeDefProps(m_tdTypeDef, ULONG_MAX/*Classflags*/, 
-        ULONG_MAX, (mdToken*)rTmpImpls.Ptr()));
-
-    // Create an initializer for the class.  
-    ULONG ulFlags;
-    if (psAttr->wTypeFlags & TYPEFLAG_FCANCREATE)
-        ulFlags = OBJECT_INITIALIZER_FLAGS;
-    else
-        ulFlags = NONCREATABLE_OBJECT_INITIALIZER_FLAGS;
-    {
-        IfFailGo(m_pEmit->DefineMethod(m_tdTypeDef, OBJECT_INITIALIZER_NAME, ulFlags,
-            OBJECT_INITIALIZER_SIG, sizeof(OBJECT_INITIALIZER_SIG), 0/*rva*/, OBJECT_INITIALIZER_IMPL_FLAGS/*flags*/, &mdCtor));
-    }
-    
-    // Set ClassInterfaceType.None on the generated class.
-    DECLARE_CUSTOM_ATTRIBUTE(sizeof(short));
-    BUILD_CUSTOM_ATTRIBUTE(short, clsIfNone);
-    IfFailGo(GetAttrType(ATTR_CLASSINTERFACE, &tkAttr));
-    FINISH_CUSTOM_ATTRIBUTE();
-    IfFailGo(m_pEmit->DefineCustomAttribute(m_tdTypeDef, tkAttr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(), 0));
-
-
-    if (!m_bPreventClassMembers)
-    {
-        // Iterate over the implemented interfaces, and add the members to the coclass.
-        m_ImplIface = eImplIfaceDefault;
-        for (i=0; i<=ixImpl; ++i)
-        {   
-            _ASSERTE(rImplTypes[i]);
-
-            // Interface info.
-            m_tkInterface = rImpls[i];
-            pItiIface = rImplTypes[i];
-            rImplTypes[i] = 0; // ownership transferred.
-            
-            // Get interface name for decoration.
-            if (m_szInterface) 
-                ::SysFreeString(m_szInterface), m_szInterface = 0;
-            IfFailGo(pItiIface->GetDocumentation(MEMBERID_NIL, &m_szInterface, 0,0,0));
-            
-            // Add the interface members to the coclass.
-            IfFailGo(pItiIface->GetTypeAttr(&psAttrIface));
-            switch (psAttrIface->typekind)
-            {
-            case TKIND_DISPATCH:
-                hr = ConvDispatch(pItiIface, psAttrIface, false);
-                break;
-            case TKIND_INTERFACE:
-                hr = ConvIface(pItiIface, psAttrIface, false);
-                break;
-            default:
-                hr = S_OK;
-                _ASSERTE(!"Unexpected typekind for implemented interface");
-            }
-            pItiIface->ReleaseTypeAttr(psAttrIface);
-            psAttrIface = 0;
-            IfFailGo(hr);
-            m_ImplIface = eImplIface;
-            rImplTypes[i] = pItiIface;
-            pItiIface = 0; // ownership transferred back.
-        }
-
-        // Add the methods of the event interfaces to the class.
-        for (i=0; i<=ixSrc; ++i)
-            IfFailGo(_AddSrcItfMembersToClass(rEvents[i]));
-    }
-    
-    // If there are source interfaces, add a custom value for that.
-    if (ixSrc >= 0)
-    {
-        CQuickArray<char> rEvents;  // Output buffer.
-        int cbCur;              // Current location in output buffer.
-        int cbReq;              // Size of an individual piece.
-        CQuickArray<WCHAR> rEvent;
-
-        // Save 6 bytes at the beginning of the buffer for the custom attribute prolog and
-        //  the string length.  The string length may require 1, 2, or 4 bytes to express.
-        cbCur = 6;
-
-        // For each event interface...
-        for (int ix=0; ix <= ixSrc; ++ix)
-        {
-            pItiIface = rSrcTypes[ix];
-            rSrcTypes[ix] = 0;
-
-            // Get the typeref name for the interface.
-            for(;;)
-            {
-                int cchReq;
-                IfFailGo(_GetTokenForTypeInfo(pItiIface, FALSE, &token, rEvent.Ptr(), (int)rEvent.MaxSize(), &cchReq, TRUE));
-                if (cchReq <= (int)rEvent.MaxSize())
-                    break;
-                IfFailGo(rEvent.ReSizeNoThrow(cchReq));
-            }
-
-            // Append to the buffer.  See how much space is required, get it.
-            cbReq = WszWideCharToMultiByte(CP_UTF8,0, rEvent.Ptr(),-1, 0,0, 0,0);
-            
-            // make sure we have enough space for the extra terminating 0 and for the 00 00 suffix
-            size_t cbNewSize;
-            if (!ClrSafeInt<size_t>::addition(cbCur, cbReq, cbNewSize) ||
-                !ClrSafeInt<size_t>::addition(cbNewSize, 3, cbNewSize))
-            {
-                IfFailGo(COR_E_OVERFLOW);
-            }
-            if (cbNewSize > rEvents.MaxSize())
-            {
-                IfFailGo(rEvents.ReSizeNoThrow(cbNewSize));
-            }
-            // Do the conversion.
-            WszWideCharToMultiByte(CP_UTF8,0, rEvent.Ptr(),-1, rEvents.Ptr()+cbCur,cbReq, 0,0);
-            cbCur += cbReq;
-            pItiIface->Release();
-        }
-        pItiIface = 0;
-
-        // Add an extra terminating 0.
-        *(rEvents.Ptr()+cbCur) = 0;
-        ++cbCur;
-
-        // Now build the custom attribute.
-        int iLen = cbCur - 6;
-        char *pBytes = rEvents.Ptr();
-
-        // Length may be encoded with less the 4 bytes.
-        int lenPad = 4 - CPackedLen::Size(iLen);
-        _ASSERTE(lenPad >= 0);
-
-        pBytes += lenPad;
-        cbCur -= lenPad;
-
-        // Prologue.
-        pBytes[0] = 0x01;
-        pBytes[1] = 0x00;
-
-        CPackedLen::PutLength(pBytes + 2, iLen);
-
-        // Zero named properties/fields.
-        pBytes[cbCur + 0] = 0x00;
-        pBytes[cbCur + 1] = 0x00;
-        cbCur += 2;
-
-        // Finally, store it.
-        IfFailGo(GetAttrType(ATTR_COMSOURCEINTERFACES, &tkAttr));
-        IfFailGo(m_pEmit->DefineCustomAttribute(m_tdTypeDef, tkAttr, pBytes, cbCur, 0));
-    }
-
-ErrExit:
-    if (psAttrIface)
-        pItiIface->ReleaseTypeAttr(psAttrIface);
-    if (pItiIface)
-        pItiIface->Release();
-    // Clean up any left-over ITypeInfo*.
-    for (ULONG ix=0; ix < rImplTypes.Size(); ++ix)
-        if (rImplTypes[ix])
-           (rImplTypes[ix])->Release();
-    for (ULONG ix=0; ix < rSrcTypes.Size(); ++ix)
-        if (rSrcTypes[ix])
-           (rSrcTypes[ix])->Release();
-    m_tkInterface = 0;
-    if (m_szInterface)
-        ::SysFreeString(m_szInterface), m_szInterface = 0;
-    m_ImplIface = eImplIfaceNone;
-    return (hr);
-} // HRESULT CImportTlb::ConvCoclass()
-#ifdef _PREFAST_
-#pragma warning(pop)
-#endif
-
-//*****************************************************************************
-// Convert an enum to a class with fields that have default values.
-//*****************************************************************************
-HRESULT CImportTlb::ConvEnum(           // S_OK or error.
-    ITypeInfo   *pITI,                  // ITypeInfo* to convert.
-    TYPEATTR    *psAttr)                // TYPEATTR of TypeInfo.
-{
-    HRESULT     hr;                     // A result.
-    int         i;                      // Loop control.
-    VARDESC     *psVar=0;               // VARDESC for a member.
-    mdFieldDef  mdField;                // The FieldDef for the enum's type.
-
-    // Create the field definition for the enum type.  Always import as an __int32.
-    IfFailGo(m_pEmit->DefineField(m_tdTypeDef, ENUM_TYPE_NAME, ENUM_TYPE_FLAGS, ENUM_TYPE_SIGNATURE,ENUM_TYPE_SIGNATURE_SIZE, 
-        0,0, -1, &mdField));
-
-    // Iterate over the vars.
-    for (i=0; i<psAttr->cVars; ++i)
-    {
-        // Get variable information.
-        IfFailGo(pITI->GetVarDesc(i, &psVar));
-        // Do the conversion.
-        IfFailGo(_ConvConstant(pITI, psVar, true/*enum member*/));
-        // Release for next var.
-        pITI->ReleaseVarDesc(psVar);
-        psVar = 0;
-    }
-
-    hr = S_OK;
-
-ErrExit:
-    if (psVar)
-        pITI->ReleaseVarDesc(psVar);
-    return (hr);
-} // HRESULT CImportTlb::ConvEnum()
-
-//*****************************************************************************
-// Convert a record to a class with fields.
-//*****************************************************************************
-HRESULT CImportTlb::ConvRecord(         // S_OK or error.
-    ITypeInfo   *pITI,                  // ITypeInfo* to convert.
-    TYPEATTR    *psAttr,                // TYPEATTR of TypeInfo.
-    BOOL        bUnion)                 // Convert as a union?
-{
-    HRESULT     hr=S_OK;                // A result.
-    int         i;                      // Loop control.
-    VARDESC     *psVar=0;               // VARDESC for a member.
-    mdFieldDef  mdField;                // Token for a given field.
-    CQuickArray<COR_FIELD_OFFSET> rLayout; // Array for layout information.
-    BOOL        bConversionLoss=false;  // If true, some attributes were lost on conversion.
-
-    // Unions with embedded Object Types can't really be converted.  Just reserve correct size.
-    if (bUnion && (HasObjectFields(pITI, psAttr) == S_OK))
-    {
-        IfFailGo(m_pEmit->SetClassLayout(m_tdTypeDef, psAttr->cbAlignment, 0, psAttr->cbSizeInstance));
-        goto ErrExit;
-    }
-    
-    // Prepare for layout info.
-    IfFailGo(rLayout.ReSizeNoThrow(psAttr->cVars+1));
-
-    // Iterate over the vars.
-    for (i=0; i<psAttr->cVars; ++i)
-    {
-        // Get variable information.
-        IfFailGo(pITI->GetVarDesc(i, &psVar));
-        // Do the conversion.
-        IfFailGo(_ConvField(pITI, psVar, &mdField, bUnion));
-        if (hr == S_CONVERSION_LOSS)
-            bConversionLoss = true;
-        // Save the layout info.
-        rLayout[i].ridOfField = mdField;
-        rLayout[i].ulOffset = psVar->oInst;
-        // Release for next var.
-        pITI->ReleaseVarDesc(psVar);
-        psVar = 0;
-    }
-
-    // If it is a union, Save the layout information.
-    if (bUnion)
-    {
-        rLayout[psAttr->cVars].ridOfField = mdFieldDefNil;
-        IfFailGo(m_pEmit->SetClassLayout(m_tdTypeDef, psAttr->cbAlignment, rLayout.Ptr(), -1));
-    }
-    else // Not a union.  Preserve the alignment.
-        IfFailGo(m_pEmit->SetClassLayout(m_tdTypeDef, psAttr->cbAlignment, 0, -1));
-
-    // If we are marking these as serializable - do so now.
-    if (m_bSerializableValueClasses)
-    {
-        mdToken tkAttr;
-        IfFailGo(GetAttrType(ATTR_SERIALIZABLE, &tkAttr));
-        DECLARE_CUSTOM_ATTRIBUTE(0);
-        FINISH_CUSTOM_ATTRIBUTE();
-        IfFailGo(m_pEmit->DefineCustomAttribute(m_tdTypeDef, tkAttr, PTROF_CUSTOM_ATTRIBUTE(),SIZEOF_CUSTOM_ATTRIBUTE(),0));
-    }
-
-    if (bConversionLoss)
-        hr = S_CONVERSION_LOSS;
-
-ErrExit:
-    if (psVar)
-        pITI->ReleaseVarDesc(psVar);
-    return (hr);
-} // HRESULT CImportTlb::ConvRecord()
-
-//*****************************************************************************
-// Convert an module to a class with fields that have default values.
-//  @FUTURE: convert methods as PInvoke methods.
-//*****************************************************************************
-HRESULT CImportTlb::ConvModule(         // S_OK or error.
-    ITypeInfo   *pITI,                  // ITypeInfo* to convert.
-    TYPEATTR    *psAttr)                // TYPEATTR of TypeInfo.
-{
-    HRESULT     hr;                     // A result.
-    int         i;                      // Loop control.
-    VARDESC     *psVar=0;               // VARDESC for a member.
-
-    // Iterate over the vars.
-    for (i=0; i<psAttr->cVars; ++i)
-    {
-        // Get variable information.
-        IfFailGo(pITI->GetVarDesc(i, &psVar));
-        // Do the conversion.
-        IfFailGo(_ConvConstant(pITI, psVar));
-        // Release for next var.
-        pITI->ReleaseVarDesc(psVar);
-        psVar = 0;
-    }
-
-    hr = S_OK;
-
-ErrExit:
-    if (psVar)
-        pITI->ReleaseVarDesc(psVar);
-    return (hr);
-} // HRESULT CImportTlb::ConvModule()
-
-//*****************************************************************************
-// Convert metadata for an interface.
-//*****************************************************************************
-HRESULT CImportTlb::ConvIface(          // S_OK or error.
-    ITypeInfo   *pITI,                  // ITypeInfo* to convert.
-    TYPEATTR    *psAttr,                // TYPEATTR of TypeInfo.
-    BOOL        bVtblGapFuncs)          // Vtable gap functions?
-{
-    HRESULT     hr;                     // A result.
-    ITypeInfo   *pITIBase=0;            // ITypeInfo* of base interface.
-    TYPEATTR    *psAttrBase=0;          // TYPEATTR of base interface.
-    ITypeInfo   *pITISelf2=0;           // ITypeInfo* of partner.
-    TYPEATTR    *psAttrSelf2=0;         // TYPEATTR of partner.
-    mdToken     tkImpls[3]={0,0,0};     // Token of implemented interfaces.
-    int         ixImpls = 0;            // Index of current implemented interface.
-    HREFTYPE    href;                   // href of base interface.
-    mdToken     tkIface;                // Token for an interface.
-    BOOL        fInheritsIEnum = FALSE;
-
-    // If there is a partner interface, prefer it.
-    if (pITI->GetRefTypeOfImplType(-1, &href) == S_OK)
-    {
-        IfFailGo(pITI->GetRefTypeInfo(href, &pITISelf2));
-        IfFailGo(pITISelf2->GetTypeAttr(&psAttrSelf2));
-    }
-
-    // Base interface?
-    if (psAttr->cImplTypes == 1)
-    {
-        IfFailGo(pITI->GetRefTypeOfImplType(0, &href));
-        IfFailGo(pITI->GetRefTypeInfo(href, &pITIBase));
-        IfFailGo(pITIBase->GetTypeAttr(&psAttrBase));
-
-        // If this interface extends something other than IDispatch or IUnknown, record that
-        //  fact as an "implemented interface".
-        if (psAttrBase->guid != IID_IDispatch && psAttrBase->guid != IID_IUnknown)
-        {
-            // Get Token of the base interface.
-            IfFailGo(_GetTokenForTypeInfo(pITIBase, FALSE, &tkImpls[ixImpls++]));
-        }
-        else
-        {   // Maybe we're "funky"...
-            if (pITISelf2)
-            {
-                pITIBase->ReleaseTypeAttr(psAttrBase);
-                pITIBase->Release();
-                pITIBase = 0;
-                psAttrBase = 0;
-
-                if (psAttrSelf2->cImplTypes == 1)
-                {
-                    IfFailGo(pITISelf2->GetRefTypeOfImplType(0, &href));
-                    IfFailGo(pITISelf2->GetRefTypeInfo(href, &pITIBase));
-                    IfFailGo(pITIBase->GetTypeAttr(&psAttrBase));
-
-                    if (psAttrBase->guid != IID_IDispatch && psAttrBase->guid != IID_IUnknown)
-                    {
-                        // Get Token of the base interface.
-                        IfFailGo(_GetTokenForTypeInfo(pITIBase, FALSE, &tkImpls[ixImpls++]));
-                    }
-                }
-                else
-                {
-                    BSTR szTypeInfoName;
-                    pITISelf2->GetDocumentation(MEMBERID_NIL, &szTypeInfoName, 0, 0, 0);
-                    ReportEvent(NOTIF_CONVERTWARNING, TLBX_E_INVALID_TYPEINFO, szTypeInfoName);
-                    SysFreeString(szTypeInfoName);
-                    
-                    IfFailGo(TLBX_E_INVALID_TYPEINFO);
-                }
-            }
-        }
-
-        pITIBase->ReleaseTypeAttr(psAttrBase);
-        psAttrBase = 0;
-        pITIBase->Release();
-        pITIBase = 0;
-    }
-
-    if (ExplicitlyImplementsIEnumerable(pITI, psAttr) == S_OK)
-        fInheritsIEnum = TRUE;
-    
-    // If this interface has a NewEnum member then have it implement IEnumerable.
-    if ( (!fInheritsIEnum) && (HasNewEnumMember(pITI) == S_OK) )
-    {
-        IfFailGo(GetKnownTypeToken(VT_SLOT_FOR_IENUMERABLE, &tkIface));
-        tkImpls[ixImpls++] = tkIface;
-    }
-
-    // If not processing an implemented interface, add additional interface properties. 
-    if (m_ImplIface == eImplIfaceNone)
-    {
-        // Set base interface as an implemented interface.
-        if (tkImpls[0])
-            IfFailGo(m_pEmit->SetTypeDefProps(m_tdTypeDef, ULONG_MAX/*flags*/, ULONG_MAX/*extends*/, tkImpls));
-
-        // If the interface is not derived from IDispatch mark it as IUnknown based.
-        if (IsIDispatchDerived(pITI, psAttr) == S_FALSE)
-        {
-            mdMemberRef mr;
-            // Note that this is a vtable, but not IDispatch derived.
-            // Custom attribute buffer.
-            DECLARE_CUSTOM_ATTRIBUTE(sizeof(short));
-            // Set up the attribute.
-            BUILD_CUSTOM_ATTRIBUTE(short, ifVtable);
-            // Store the attribute
-            IfFailGo(GetAttrType(ATTR_INTERFACETYPE, &mr));
-            FINISH_CUSTOM_ATTRIBUTE();
-            IfFailGo(m_pEmit->DefineCustomAttribute(m_tdTypeDef, mr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(), 0));
-        }
-    }
-
-    // Convert the members on the interface (and base interfaces).
-    // If this interface had a "funky partner", base the conversion on that.
-    if (pITISelf2)
-        IfFailGo(_ConvIfaceMembers(pITISelf2, psAttrSelf2, bVtblGapFuncs, psAttr->wTypeFlags & TYPEFLAG_FDUAL, fInheritsIEnum));
-    else
-        IfFailGo(_ConvIfaceMembers(pITI, psAttr, bVtblGapFuncs, psAttr->wTypeFlags & TYPEFLAG_FDUAL, fInheritsIEnum));
-
-ErrExit:
-    if (psAttrSelf2)
-        pITISelf2->ReleaseTypeAttr(psAttrSelf2);
-    if (pITISelf2)
-        pITISelf2->Release();
-    if (psAttrBase)
-        pITIBase->ReleaseTypeAttr(psAttrBase);
-    if (pITIBase)
-        pITIBase->Release();
-    return (hr);
-} // HRESULT CImportTlb::ConvIface()
-
-//*****************************************************************************
-// Convert the metadata for a dispinterface.  Try to convert as a normal
-//  interface.
-//*****************************************************************************
-HRESULT CImportTlb::ConvDispatch(       // S_OK or error.
-    ITypeInfo   *pITI,                  // ITypeInfo* to convert.
-    TYPEATTR    *psAttr,                // TYPEATTR of TypeInfo.
-    BOOL        bVtblGapFuncs)          // Vtable gap functions for interface implementations?
-{
-    HRESULT     hr;                     // A result.
-    HREFTYPE    href;                   // Base interface href.
-    ITypeInfo   *pITIBase=0;            // Base interface ITypeInfo.
-    TYPEATTR    *psAttrBase=0;          // TYPEATTR of base interface.
-    mdMemberRef mr;                     // MemberRef for custom value.
-    DWORD       attr[2] = {0x00010001, 0x00000002};
-    BYTE        bIface = ifDispatch;    // Custom value means "dispinterface"
-    BOOL        fInheritsIEnum = FALSE;
-   
-    // If this is a dual interface, treat it like a normal interface.
-    if ((psAttr->wTypeFlags & TYPEFLAG_FDUAL))
-    {
-        hr = ConvIface(pITI, psAttr, bVtblGapFuncs);
-        goto ErrExit;
-    }
-
-    if (ExplicitlyImplementsIEnumerable(pITI, psAttr) == S_OK)
-        fInheritsIEnum = TRUE;
-
-    // If there is a vtable view of this interface (funky dispinterface).
-    //  @FUTURE: what would be really nice here would be an alias mechanism, so that we could
-    //   just point this dispinterface to that other interface, in those situations that it
-    //   is dual.  OTOH, that is probably pretty rare, because if that other interface 
-    //   were dual, why would the dispinterface even be needed?
-    if (pITI->GetRefTypeOfImplType(-1, &href) == S_OK)
-    {
-        IfFailGo(pITI->GetRefTypeInfo(href, &pITIBase));
-        IfFailGo(pITIBase->GetTypeAttr(&psAttrBase));
-        IfFailGo(_ConvIfaceMembers(pITIBase, psAttrBase, bVtblGapFuncs, TRUE, fInheritsIEnum));
-        pITIBase->ReleaseTypeAttr(psAttrBase);
-        psAttrBase = 0;
-        pITIBase->Release();
-        pITIBase = 0;
-        goto ErrExit;
-    }
-
-    // If not processing an implemented interface, mark the interface type.
-    if (m_ImplIface == eImplIfaceNone)
-    {
-        // If this interface has a NewEnum member then have it implement IEnumerable.        
-        if ((S_OK == HasNewEnumMember(pITI)) && !fInheritsIEnum)
-        {
-            mdToken     tkImpl[2] = {0,0};
-            IfFailGo(GetKnownTypeToken(VT_SLOT_FOR_IENUMERABLE, &tkImpl[0]));
-            IfFailGo(m_pEmit->SetTypeDefProps(m_tdTypeDef, ULONG_MAX, ULONG_MAX, tkImpl));
-        }
-
-        // Note that this is a dispinterface.
-        DECLARE_CUSTOM_ATTRIBUTE(sizeof(short));
-        // Set up the attribute.
-        BUILD_CUSTOM_ATTRIBUTE(short, ifDispatch);
-        // Store the attribute
-        IfFailGo(GetAttrType(ATTR_INTERFACETYPE, &mr));
-        FINISH_CUSTOM_ATTRIBUTE();
-        IfFailGo(m_pEmit->DefineCustomAttribute(m_tdTypeDef, mr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(), 0));
-    }
-
-    IfFailGo(_ConvDispatchMembers(pITI, psAttr, fInheritsIEnum));
-
-ErrExit:
-    if (psAttrBase)
-        pITIBase->ReleaseTypeAttr(psAttrBase);
-    if (pITIBase)
-        pITIBase->Release();
-    return (hr);
-} // HRESULT CImportTlb::ConvDispatch()
-
-//*****************************************************************************
-// Determine if an interface is derived from IUnknown.
-//*****************************************************************************
-HRESULT CImportTlb::IsIUnknownDerived(
-    ITypeInfo   *pITI,                  // The containing ITypeInfo.
-    TYPEATTR    *psAttr)                // The ITypeInfo's TYPEATTR
-{
-    HRESULT     hr=S_OK;                // A result.
-
-    HREFTYPE    href;                   // Base interface href.
-    ITypeInfo   *pITIBase=0;            // Base interface ITypeInfo.
-    TYPEATTR    *psAttrBase=0;          // TYPEATTR of base interface.
-
-    // This should never be called on CoClasses.
-    _ASSERTE(psAttr->typekind != TKIND_COCLASS);
-
-    // If IDispatch or IUnknown, we've recursed far enough.
-    if (IsEqualGUID(psAttr->guid, IID_IUnknown) || IsEqualGUID(psAttr->guid, IID_IDispatch))
-    {
-        goto ErrExit;
-    }
-
-    // Handle base interface.
-    if (psAttr->cImplTypes == 1)
-    {
-        IfFailGo(pITI->GetRefTypeOfImplType(0, &href));
-        IfFailGo(pITI->GetRefTypeInfo(href, &pITIBase));
-        IfFailGo(pITIBase->GetTypeAttr(&psAttrBase));
-
-        // IUnknow derived if base interface is.
-        hr = IsIUnknownDerived(pITIBase, psAttrBase);
-        pITIBase->ReleaseTypeAttr(psAttrBase);
-        psAttrBase = 0;
-        pITIBase->Release();
-        pITIBase = 0;
-    }
-    else
-    {   // No base interface, not IUnknown, not IDispatch.  Not very COM-ish, so don't try to handle.
-        hr = S_FALSE;
-    }
-
-ErrExit:
-    if (psAttrBase)
-        pITIBase->ReleaseTypeAttr(psAttrBase);
-    if (pITIBase)
-        pITIBase->Release();
-    return (hr);
-} // HRESULT CImportTlb::IsIUnknownDerived()
-
-//*****************************************************************************
-// Determine if an interface is derived from IDispatch.  Note that a pure
-//  dispinterface doesn't derive from IDispatch.
-//*****************************************************************************
-HRESULT CImportTlb::IsIDispatchDerived(
-    ITypeInfo   *pITI,                  // The containing ITypeInfo.
-    TYPEATTR    *psAttr)                // The ITypeInfo's TYPEATTR
-{
-    HRESULT     hr=S_OK;                // A result.
-
-    HREFTYPE    href;                   // Base interface href.
-    ITypeInfo   *pITIBase=0;            // Base interface ITypeInfo.
-    TYPEATTR    *psAttrBase=0;          // TYPEATTR of base interface.
-
-    // If IDispatch, we've recursed far enough.
-    if (IsEqualGUID(psAttr->guid, IID_IDispatch))
-    {
-        goto ErrExit;
-    }
-
-    if (psAttr->typekind == TKIND_DISPATCH)
-    {
-        IfFailGo(pITI->GetRefTypeOfImplType(-1, &href));
-        IfFailGo(pITI->GetRefTypeInfo(href, &pITIBase));
-        IfFailGo(pITIBase->GetTypeAttr(&psAttrBase));
-
-        // IDispatch derived if base interface is.
-        hr = IsIDispatchDerived(pITIBase, psAttrBase);
-        pITIBase->ReleaseTypeAttr(psAttrBase);
-        psAttrBase = 0;
-        pITIBase->Release();
-        pITIBase = 0;
-        
-        goto ErrExit;
-    }
-    
-    // Handle base interface.
-    if (psAttr->cImplTypes == 1)
-    {
-        IfFailGo(pITI->GetRefTypeOfImplType(0, &href));
-        IfFailGo(pITI->GetRefTypeInfo(href, &pITIBase));
-        IfFailGo(pITIBase->GetTypeAttr(&psAttrBase));
-
-        // IDispatch derived if base interface is.
-        hr = IsIDispatchDerived(pITIBase, psAttrBase);
-        pITIBase->ReleaseTypeAttr(psAttrBase);
-        psAttrBase = 0;
-        pITIBase->Release();
-        pITIBase = 0;
-    }
-    else
-    {   // No base interface, not IDispatch.  Done.
-        hr = S_FALSE;
-    }
-
-ErrExit:
-    if (psAttrBase)
-        pITIBase->ReleaseTypeAttr(psAttrBase);
-    if (pITIBase)
-        pITIBase->Release();
-    return (hr);
-} // HRESULT CImportTlb::IsIDispatchDerived()
-
-//*****************************************************************************
-// Determine if an interface has a member with a DISPID of DISPID_NEWENUM.
-//*****************************************************************************
-HRESULT CImportTlb::HasNewEnumMember(   // S_OK if has NewEnum, S_FALSE otherwise.
-    ITypeInfo   *pItfTI)                // The interface in question.
-{
-    HRESULT     hr = S_OK;              // A result.
-    BOOL        bHasNewEnumMember=FALSE;// If true, has a NewEnum
-    TYPEATTR    *pAttr = NULL;          // A TypeInfo's typeattr
-    FUNCDESC    *pFuncDesc = NULL;      // A Function's FuncDesc
-    VARDESC     *pVarDesc = NULL;       // A properties VarDesc
-    int         i;                      // Loop control.
-    ITypeInfo   *pITISelf2=0;           // Partner interface.
-    HREFTYPE    href;                   // HREF of partner.
-    WCHAR       IEnumCA[] = W("{CD2BC5C9-F452-4326-B714-F9C539D4DA58}");
-
-
-    // If there is a partner interface, prefer it.
-    if (pItfTI->GetRefTypeOfImplType(-1, &href) == S_OK)
-    {
-        IfFailGo(pItfTI->GetRefTypeInfo(href, &pITISelf2));
-        pItfTI = pITISelf2;
-    }
-
-    // Retrieve the attributes of the interface.
-    IfFailGo(pItfTI->GetTypeAttr(&pAttr));   
-
-    if ((pAttr->typekind == TKIND_DISPATCH) || ((pAttr->typekind == TKIND_INTERFACE) && (IsIDispatchDerived(pItfTI, pAttr) == S_OK)))
-    {
-        // Check to see if the ForceIEnumerable custom value exists on the type
-        _ForceIEnumerableCVExists(pItfTI, &bHasNewEnumMember);
-
-        // Check to see if the interface has a function with a DISPID of DISPID_NEWENUM.
-        for (i = 0; i < pAttr->cFuncs; i++)
-        {
-            IfFailGo(TryGetFuncDesc(pItfTI, i, &pFuncDesc)); 
-            
-            if (FuncIsNewEnum(pItfTI, pFuncDesc, i) == S_OK)
-            {
-                // Throw a warning if we find more than one func with DISPID_NEWENUM.
-                if (bHasNewEnumMember == TRUE)
-                {
-                    BSTR ObjectName;
-                    pItfTI->GetDocumentation(-1, &ObjectName, NULL, NULL, NULL);
-                    ReportEvent(NOTIF_CONVERTWARNING, TLBX_E_INVALID_TYPEINFO, ObjectName);
-                    SysFreeString(ObjectName);
-                }
-
-                // The interface has a function with a DISPID of DISPID_NEWENUM.
-                bHasNewEnumMember = TRUE;
-                break;
-            }
-            
-            pItfTI->ReleaseFuncDesc(pFuncDesc);
-            pFuncDesc = NULL;
-        }
-
-        // Check to see if the interface as a property with a DISPID of DISPID_NEWENUM.
-        for (i = 0; i < pAttr->cVars; i++)
-        {
-            IfFailGo(pItfTI->GetVarDesc(i, &pVarDesc));
-
-            if (PropertyIsNewEnum(pItfTI, pVarDesc, i) == S_OK)
-            {
-                // Throw a warning if we find more than one func with DISPID_NEWENUM.
-                if (bHasNewEnumMember == TRUE)
-                {
-                    BSTR ObjectName;
-                    pItfTI->GetDocumentation(-1, &ObjectName, NULL, NULL, NULL);
-                    ReportEvent(NOTIF_CONVERTWARNING, TLBX_E_INVALID_TYPEINFO, ObjectName);
-                    SysFreeString(ObjectName);
-                }
-
-                // The interface has a property with a DISPID of DISPID_NEWENUM.
-                bHasNewEnumMember = TRUE;
-                break;
-            }
-            
-            pItfTI->ReleaseVarDesc(pVarDesc);
-            pVarDesc = NULL;
-        }
-    }
-    else
-    {
-        // Check to see if the ForceIEnumerable custom value exists on the type
-        //  If it does, spit out a warning.
-        _ForceIEnumerableCVExists(pItfTI, &bHasNewEnumMember);
-
-        if (bHasNewEnumMember)
-        {
-            // Invalid custom attribute on the iface.
-            BSTR CustomValue = SysAllocString((const WCHAR*)&IEnumCA[0]);
-            BSTR ObjectName;
-            pItfTI->GetDocumentation(-1, &ObjectName, NULL, NULL, NULL);
-            
-            ReportEvent(NOTIF_CONVERTWARNING, TLBX_W_IENUM_CA_ON_IUNK, CustomValue, ObjectName);
-
-            SysFreeString(CustomValue);
-            SysFreeString(ObjectName);
-
-            bHasNewEnumMember = FALSE;
-        }
-    }
-
-    hr = bHasNewEnumMember ? S_OK : S_FALSE;
-
-ErrExit:
-    if (pAttr)
-        pItfTI->ReleaseTypeAttr(pAttr);
-    if (pFuncDesc)
-        pItfTI->ReleaseFuncDesc(pFuncDesc);
-    if (pVarDesc)
-        pItfTI->ReleaseVarDesc(pVarDesc);
-    if (pITISelf2)
-        pITISelf2->Release();
-    return hr;
-} // HRESULT CImportTlb::HasNewEnumMember(ITypeInfo *pItfTI)
-
-//*****************************************************************************
-// Determine if a given function is a valid NewEnum member.
-//*****************************************************************************
-HRESULT CImportTlb::FuncIsNewEnum(      // S_OK if the function is the NewEnum member S_FALSE otherwise.
-    ITypeInfo *pITI,                    // The ITypeInfo that contains the function.                                    
-    FUNCDESC *pFuncDesc,                // The function in question.
-    DWORD index)                        // The function index
-{
-
-    HRESULT         hr = S_OK;
-    BOOL            bIsValidNewEnum = FALSE;
-    TYPEDESC*       pType = NULL;
-    TYPEATTR*       pAttr = NULL;
-    ITypeInfo*      pITIUD = NULL; 
-    long            lDispSet = 0;
-    
-    _GetDispIDCA(pITI, index, &lDispSet, TRUE);
-
-    if ((pFuncDesc->memid == DISPID_NEWENUM) || (lDispSet == DISPID_NEWENUM))
-    {
-        if (pFuncDesc->funckind == FUNC_DISPATCH)
-        {
-            if ((pFuncDesc->invkind == INVOKE_PROPERTYGET) || (pFuncDesc->invkind == INVOKE_FUNC))
-            {
-                if (pFuncDesc->cParams == 0)
-                {
-                    pType = &pFuncDesc->elemdescFunc.tdesc;
-                }
-                else if ((m_bTransformDispRetVals) && (pFuncDesc->cParams == 1) && (pFuncDesc->lprgelemdescParam[0].paramdesc.wParamFlags & PARAMFLAG_FRETVAL))
-                {
-                    pType = pFuncDesc->lprgelemdescParam[0].tdesc.lptdesc;
-                }
-            }
-        }
-        else if (pFuncDesc->funckind == FUNC_PUREVIRTUAL)
-        {
-            if ((pFuncDesc->cParams == 1) &&
-                ((pFuncDesc->invkind == INVOKE_PROPERTYGET) || (pFuncDesc->invkind == INVOKE_FUNC)) &&
-                (pFuncDesc->lprgelemdescParam[0].paramdesc.wParamFlags & PARAMFLAG_FRETVAL) &&
-                (pFuncDesc->lprgelemdescParam[0].tdesc.vt == VT_PTR))
-            {
-                pType = pFuncDesc->lprgelemdescParam[0].tdesc.lptdesc;
-            }
-        }
-
-        if (pType)
-        {
-            if (pType->vt == VT_UNKNOWN || pType->vt == VT_DISPATCH)
-            {
-                // The member returns an IUnknown * or an IDispatch * which is valid.
-                bIsValidNewEnum = TRUE;
-            }
-            else if (pType->vt == VT_PTR)
-            {
-                pType =  pType->lptdesc;
-                if (pType->vt == VT_USERDEFINED)
-                {
-                    IfFailGo(pITI->GetRefTypeInfo(pType->hreftype, &pITIUD));
-                    IfFailGo(pITIUD->GetTypeAttr(&pAttr));
-                    if (IsEqualGUID(pAttr->guid, IID_IEnumVARIANT) || 
-                        IsEqualGUID(pAttr->guid, IID_IUnknown) ||
-                        IsEqualGUID(pAttr->guid, IID_IDispatch))
-                    {
-                        // The member returns a valid interface type for a NewEnum member.
-                        bIsValidNewEnum = TRUE;
-                    }
-                }
-            }
-        }
-    }        
-
-ErrExit:
-    if (pAttr)
-        pITIUD->ReleaseTypeAttr(pAttr);
-    if (pITIUD)
-        pITIUD->Release();
-    
-    if (FAILED(hr))
-        return hr;
-    else 
-        return bIsValidNewEnum ? S_OK : S_FALSE;
-} // HRESULT CImportTlb::FuncIsNewEnum(FUNCDESC *pFuncDesc)
-
-//*****************************************************************************
-// Determine if a given function is a valid NewEnum member.
-//*****************************************************************************
-HRESULT CImportTlb::PropertyIsNewEnum(    // S_OK if the function is the NewEnum member S_FALSE otherwise.
-    ITypeInfo *pITI,                      // The ITypeInfo that contains the property.
-    VARDESC *pVarDesc,                    // The function in question.
-    DWORD index)                          // The property index.
-{
-    HRESULT         hr = S_OK;
-    BOOL            bIsValidNewEnum = FALSE;
-    TYPEDESC*       pType = NULL;
-    TYPEATTR*       pAttr = NULL;
-    ITypeInfo*      pITIUD = NULL; 
-    long            lDispSet = 0;
-
-    _GetDispIDCA(pITI, index, &lDispSet, FALSE);
-  
-    if ( ((pVarDesc->memid == DISPID_NEWENUM) || (lDispSet == DISPID_NEWENUM)) && 
-        (pVarDesc->elemdescVar.paramdesc.wParamFlags & PARAMFLAG_FRETVAL) &&
-        (pVarDesc->wVarFlags & VARFLAG_FREADONLY))
-    {
-        pType = &pVarDesc->elemdescVar.tdesc;
-        if (pType->vt == VT_UNKNOWN || pType->vt == VT_DISPATCH)
-        {
-            // The member returns an IUnknown * or an IDispatch * which is valid.
-            bIsValidNewEnum = TRUE;
-        }
-        else if (pType->vt == VT_PTR)
-        {
-            pType =  pType->lptdesc;
-            if (pType->vt == VT_USERDEFINED)
-            {
-                IfFailGo(pITI->GetRefTypeInfo(pType->hreftype, &pITIUD));
-                IfFailGo(pITIUD->GetTypeAttr(&pAttr));
-                if (IsEqualGUID(pAttr->guid, IID_IEnumVARIANT) || 
-                    IsEqualGUID(pAttr->guid, IID_IUnknown) ||
-                    IsEqualGUID(pAttr->guid, IID_IDispatch))
-                {
-                    // The member returns a valid interface type for a NewEnum member.
-                    bIsValidNewEnum = TRUE;
-                }
-            }
-        }
-    }
-
-ErrExit:
-    if (pAttr)
-        pITIUD->ReleaseTypeAttr(pAttr);
-    if (pITIUD)
-        pITIUD->Release();
-
-    if (FAILED(hr))
-        return hr;
-    else 
-        return bIsValidNewEnum ? S_OK : S_FALSE;
-} // HRESULT CImportTlb::FuncIsNewEnum(FUNCDESC *pFuncDesc)
-
-//*****************************************************************************
-// Determine is a TypeInfo has any object fields.
-//*****************************************************************************
-HRESULT CImportTlb::HasObjectFields(    // S_OK, S_FALSE, or error.
-    ITypeInfo   *pITI,                  // The TypeInfo in question.
-    TYPEATTR    *psAttr)                // Attributes of the typeinfo.
-{
-    HRESULT     hr;                     // A result.
-    
-    int         i;                      // Loop control.
-    VARDESC     *psVar=0;               // VARDESC for a member.
-
-    // Iterate over the vars.
-    for (i=0; i<psAttr->cVars; ++i)
-    {
-        // Get variable information.
-        IfFailGo(pITI->GetVarDesc(i, &psVar));
-        
-        // See if it is an object type.
-        IfFailGo(IsObjectType(pITI, &psVar->elemdescVar.tdesc));
-        // If result is S_FALSE, not an Object; keep looking.
-        if (hr == S_OK)
-            goto ErrExit;
-        
-        // Release for next var.
-        pITI->ReleaseVarDesc(psVar);
-        psVar = 0;
-    }
-
-    hr = S_FALSE;    
-    
-ErrExit:
-    if (psVar)
-        pITI->ReleaseVarDesc(psVar);
-    return hr;    
-} // HRESULT CImportTlb::HasObjectFields()
-
-//*****************************************************************************
-// Is a given type an Object type?
-//*****************************************************************************
-HRESULT CImportTlb::IsObjectType(       // S_OK, S_FALSE, or error.
-    ITypeInfo   *pITI,                  // The TypeInfo in question.
-    const TYPEDESC *pType)              // The type.
-{
-    HRESULT     hr;                     // A result.
-    TYPEDESC    tdTemp;                 // Copy of TYPEDESC, for R/W.
-    ITypeInfo   *pITIAlias=0;           // Typeinfo of the aliased type.
-    TYPEATTR    *psAttrAlias=0;         // TYPEATTR of the aliased typeinfo.
-    int         bObjectField=false;     // The question to be answered.
-    int         iByRef=0;               // Indirection.
-
-    // Strip off leading VT_PTR and VT_BYREF
-    while (pType->vt == VT_PTR)
-        pType = pType->lptdesc, ++iByRef;
-    if (pType->vt & VT_BYREF)
-    {
-        tdTemp = *pType;
-        tdTemp.vt &= ~VT_BYREF;
-        pType = &tdTemp;
-        ++iByRef;
-    }
-
-    // Determine if the field is/has object type.
-    switch (pType->vt)
-    { 
-    case VT_PTR:
-        _ASSERTE(!"Should not have VT_PTR here");
-        break;
-
-    // These are object types.
-    case VT_BSTR:
-    case VT_DISPATCH:
-    case VT_VARIANT:
-    case VT_UNKNOWN:
-    case VT_SAFEARRAY:
-    case VT_LPSTR:
-    case VT_LPWSTR:
-        bObjectField = true;
-        break;
-
-    // A user-defined may or may not be/contain Object type.
-    case VT_USERDEFINED:
-        // User defined type.  Get the TypeInfo.
-        IfFailGo(pITI->GetRefTypeInfo(pType->hreftype, &pITIAlias));
-        IfFailGo(pITIAlias->GetTypeAttr(&psAttrAlias));
-
-        // Some user defined class.  Is it a value class, or a VOS class?
-        switch (psAttrAlias->typekind)
-        {
-        // Alias -- Is the aliased thing an Object type?
-        case TKIND_ALIAS:
-            hr = IsObjectType(pITIAlias, &psAttrAlias->tdescAlias);
-            goto ErrExit;
-        // Record/Enum/Union -- Does it contain an Object type?
-        case TKIND_RECORD:
-        case TKIND_ENUM:
-        case TKIND_UNION:
-            // Byref/Ptrto record is Object.  Contained record might be.
-            if (iByRef)
-                bObjectField = true;
-            else
-            {
-                hr = HasObjectFields(pITIAlias, psAttrAlias);
-                goto ErrExit;
-            }
-            break;
-        // Class/Interface -- An Object Type.
-        case TKIND_INTERFACE:
-        case TKIND_DISPATCH:
-        case TKIND_COCLASS:
-            bObjectField = true;
-            break;
-        default:
-            //case TKIND_MODULE: -- can't pass one of these as a parameter.
-            _ASSERTE(!"Unexpected typekind for user defined type");
-            bObjectField = true;
-        } // switch (psAttrAlias->typekind)
-        break;
-
-    case VT_CY:
-    case VT_DATE:
-    case VT_DECIMAL:
-        // Pointer to the value type is an object.  Contained one isn't.
-        if (iByRef)
-            bObjectField = true;
-        else
-            bObjectField = false;
-        break;
-
-    // A fixed array is an Object type.
-    case VT_CARRAY:
-        bObjectField = true;
-        break;
-
-    // Other types I4, etc., are not Object types.
-    default:
-        bObjectField = false;
-        break;
-    } // switch (vt=pType->vt)
-
-
-    hr = bObjectField ? S_OK : S_FALSE;
-
-ErrExit:
-    if (psAttrAlias)
-        pITIAlias->ReleaseTypeAttr(psAttrAlias);
-    if (pITIAlias)
-        pITIAlias->Release();
-
-    return hr;
-} // HRESULT CImportTlb::IsObjectType()
-
-//*****************************************************************************
-// Convert the functions on an interface.  Convert the functions on the
-//  base interface first, because in COM Classic, parent's functions are also
-//  in the derived interface's vtable.
-//*****************************************************************************
-HRESULT CImportTlb::_ConvIfaceMembers(
-    ITypeInfo   *pITI,                  // The containing ITypeInfo.
-    TYPEATTR    *psAttr,                // The ITypeInfo's TYPEATTR
-    BOOL        bVtblGapFuncs,          // Add functions for vtblGaps?
-    BOOL        bAddDispIds,            // Add DispIds to the member?
-    BOOL        bInheritsIEnum)         // Inherits from IEnumerable.
-{
-    HRESULT     hr=S_OK;                // A result.
-    int         i;                      // Loop control.
-    FUNCDESC    *psFunc=0;              // FUNCDESC for a member.
-
-    HREFTYPE    href;                   // Base interface href.
-    ITypeInfo   *pITIBase=0;            // Base interface ITypeInfo.
-    TYPEATTR    *psAttrBase=0;          // TYPEATTR of base interface.
-    BOOL        bConversionLoss=false;  // If true, some attributes were lost on conversion.
-
-    _ASSERTE( (psAttr->typekind == TKIND_INTERFACE) || (psAttr->typekind == TKIND_DISPATCH) );
-
-    // If IDispatch or IUnknown, we've recursed far enough.
-    if (IsEqualGUID(psAttr->guid, IID_IUnknown) || IsEqualGUID(psAttr->guid, IID_IDispatch))
-    {
-        if (m_cbVtableSlot == 0)
-        {
-            m_cbVtableSlot = psAttr->cbSizeInstance;
-        }
-        m_Slot = (psAttr->cbSizeVft / m_cbVtableSlot);
-        goto ErrExit;
-    }
-
-    // Handle base interface.
-    if (psAttr->cImplTypes == 1)
-    {
-        IfFailGo(pITI->GetRefTypeOfImplType(0, &href));
-        IfFailGo(pITI->GetRefTypeInfo(href, &pITIBase));
-        IfFailGo(pITIBase->GetTypeAttr(&psAttrBase));
-
-        IfFailGo(_ConvIfaceMembers(pITIBase, psAttrBase, bVtblGapFuncs, bAddDispIds, bInheritsIEnum));
-        
-        pITIBase->ReleaseTypeAttr(psAttrBase);
-        psAttrBase = 0;
-        pITIBase->Release();
-        pITIBase = 0;
-    }
-    else
-    {   // No base interface, not IUnknown, not IDispatch.  We shouldn't be here.
-        m_Slot = 0;
-        if (m_cbVtableSlot == 0)
-        {
-            m_cbVtableSlot = psAttr->cbSizeInstance;
-        }
-        _ASSERTE(!"Interface does not derive from IUnknown.");
-    }
-
-    // Loop over functions.
-    IfFailGo(_FindFirstUserMethod(pITI, psAttr, &i));
-    IfFailGo(BuildMemberList(pITI, i, psAttr->cFuncs, bInheritsIEnum));
-
-    BOOL bAllowIEnum = !bInheritsIEnum;
-    for (i=0; i<(int)m_MemberList.Size(); ++i)
-    {
-        // Convert the function.
-        IfFailGo(_ConvFunction(pITI, &m_MemberList[i], bVtblGapFuncs, bAddDispIds, FALSE, &bAllowIEnum));
-        if (hr == S_CONVERSION_LOSS)
-            bConversionLoss = true;
-    }
-
-    // Add the property info.
-    IfFailGo(_ConvPropertiesForFunctions(pITI, psAttr));
-    
-    if (bConversionLoss)
-        hr = S_CONVERSION_LOSS;
-
-ErrExit:
-    // Release FuncDescs.
-    FreeMemberList(pITI);
-
-    if (psAttrBase)
-        pITIBase->ReleaseTypeAttr(psAttrBase);
-    if (pITIBase)
-        pITIBase->Release();
-    if (psFunc)
-        pITI->ReleaseFuncDesc(psFunc);
-    return (hr);
-} // HRESULT CImportTlb::_ConvIfaceMembers()
-
-//*****************************************************************************
-// Convert the functions on a source interface to add_ and remove_ method.  
-// Convert the functions on the base interface first, because in COM Classic, 
-// parent's functions are also in the derived interface's vtable.
-//*****************************************************************************
-HRESULT CImportTlb::_ConvSrcIfaceMembers(
-    ITypeInfo   *pITI,                  // The containing ITypeInfo.
-    TYPEATTR    *psAttr,                // The ITypeInfo's TYPEATTR
-    BOOL        fInheritsIEnum)
-{
-    HRESULT     hr=S_OK;                // A result.
-    int         i;                      // Loop control.
-    FUNCDESC    *psFunc=0;              // FUNCDESC for a member.
-    HREFTYPE    href;                   // Base interface href.
-    ITypeInfo   *pITIBase=0;            // Base interface ITypeInfo.
-    TYPEATTR    *psAttrBase=0;          // TYPEATTR of base interface.
-    BOOL        bConversionLoss=false;  // If true, some attributes were lost on conversion.
-
-    _ASSERTE( (psAttr->typekind == TKIND_INTERFACE) || (psAttr->typekind == TKIND_DISPATCH) );
-
-    // If IDispatch or IUnknown, we've recursed far enough.
-    if (IsEqualGUID(psAttr->guid, IID_IUnknown) || IsEqualGUID(psAttr->guid, IID_IDispatch))
-    {
-        if (m_cbVtableSlot == 0)
-        {
-            m_cbVtableSlot = psAttr->cbSizeInstance;
-        }
-        m_Slot = (psAttr->cbSizeVft / m_cbVtableSlot);
-        goto ErrExit;
-    }
-
-    // Handle base interface.
-    if (psAttr->cImplTypes == 1)
-    {
-        IfFailGo(pITI->GetRefTypeOfImplType(0, &href));
-        IfFailGo(pITI->GetRefTypeInfo(href, &pITIBase));
-        IfFailGo(pITIBase->GetTypeAttr(&psAttrBase));
-
-        IfFailGo(_ConvSrcIfaceMembers(pITIBase, psAttrBase, fInheritsIEnum));
-        pITIBase->ReleaseTypeAttr(psAttrBase);
-        psAttrBase = 0;
-        pITIBase->Release();
-        pITIBase = 0;
-    }
-    else
-    {   // No base interface, not IUnknown, not IDispatch.  We shouldn't be here.
-        m_Slot = 0;
-        if (m_cbVtableSlot == 0)
-        {
-            m_cbVtableSlot = psAttr->cbSizeInstance;
-        }
-        _ASSERTE(!"Interface does not derive from IUnknown.");
-    }
-
-    // Loop over functions.
-    IfFailGo(_FindFirstUserMethod(pITI, psAttr, &i));
-    IfFailGo(BuildMemberList(pITI, i, psAttr->cFuncs, fInheritsIEnum));
-
-    // If we have any properties, we want to skip them.  Should we add gaps?
-    if (m_cMemberProps != 0)
-    {
-        ReportEvent(NOTIF_CONVERTWARNING, TLBX_W_NO_PROPS_IN_EVENTS, m_szName);
-        bConversionLoss = true;
-    }
-
-    for (i = m_cMemberProps; i<(int)m_MemberList.Size(); ++i)
-    {
-        // Convert the function.
-        IfFailGo(_GenerateEvent(pITI, &m_MemberList[i], fInheritsIEnum));
-        if (hr == S_CONVERSION_LOSS)
-            bConversionLoss = true;
-    }
-    
-    if (bConversionLoss)
-        hr = S_CONVERSION_LOSS;
-
-ErrExit:
-    // Release FuncDescs.
-    FreeMemberList(pITI);
-
-    if (psAttrBase)
-        pITIBase->ReleaseTypeAttr(psAttrBase);
-    if (pITIBase)
-        pITIBase->Release();
-    if (psFunc)
-        pITI->ReleaseFuncDesc(psFunc);
-    return (hr);
-} // HRESULT CImportTlb::_ConvIfaceMembers()
-
-//*****************************************************************************
-// Add the property definitions for property functions.
-//*****************************************************************************
-HRESULT CImportTlb::_ConvPropertiesForFunctions(
-    ITypeInfo   *pITI,                  // ITypeInfo* being converted.
-    TYPEATTR    *psAttr)                // TypeAttr for the typeinfo.
-{
-    HRESULT     hr=S_OK;                // A result.
-    int         ix;                     // Loop control.
-    int         ix2;                    // More loop control.
-    mdProperty  pd;                     // A property token.
-    USHORT      ms;                     // Some method's semantics.
-    mdToken     tk;                     // A method's token.
-    mdMethodDef mdFuncs[6] ={0};        // Array of setter, getter, other.
-    FUNCDESC    *psF=0;                 // FUNCDESC of Get, Put, or PutRef.
-    TYPEDESC    *pProperty;             // TYPEDESC of property type.
-    BOOL        bPropRetval;            // Is the property type a [retval]?
-    ULONG       ixValue;                // Index of the value parameter for putters.
-    int         ixVarArg;               // Index of vararg param, if any.
-    CQuickBytes qbComSig;               // new signature 
-    BYTE        *pbSig;                 // Pointer into the signature.
-    ULONG       sigFlags;               // Signature handling flags.
-    ULONG       cbTotal;                // Size of the signature.
-    ULONG       cb;                     // Size of a signature element.
-    LPWSTR      pszName;                // Possibly decorated name of property.
-    CQuickArray<WCHAR> qbName;          // Buffer for name decoration.
-    int         iSrcParam;              // Param count, as looping through params.
-    int         cDestParams;            // Count of destination params.
-    CQuickArray<BYTE> qbDummyNativeTypeBuf; // A dummy native type array.
-    ULONG       iNativeOfs=0;           // Current offset in native type buffer.
-    BOOL        bNewEnumMember=FALSE;   // Is this a NewEnum property?
-    BOOL        bConversionLoss=FALSE;  // Was some type not fully converted?    
-    int         cFound;                 // Functions found matching a given property.
-    
-    // Using semantics as an index, so be sure array is big enough.
-    _ASSERTE(lengthof(mdFuncs) > msOther);
-    
-    for (ix=m_cMemberProps; ix<(int)m_MemberList.Size(); ++ix)
-    {   // See if this one needs to be processed.
-        if (m_MemberList[ix].m_mdFunc == 0)
-            continue;
-        
-        MemberInfo *pMember = &m_MemberList[ix];
-        pMember->GetFuncInfo(tk, ms);
-        
-        // Get the name.
-        if (m_szMember)
-            ::SysFreeString(m_szMember), m_szMember = 0;
-        IfFailGo(pITI->GetDocumentation(pMember->m_psFunc->memid, &m_szMember, 0,0,0));
-        
-        // Found one.  Put in the right slot.
-        _ASSERTE(ms == msGetter || ms == msSetter || ms==msOther);
-        mdFuncs[msSetter] = mdFuncs[msGetter] = mdFuncs[msOther] = 0;
-        mdFuncs[ms] = tk;
-        pMember->m_mdFunc = 0;
-        
-        // Look for related functions.
-        cFound = 1;
-        for (ix2=ix+1; ix2<(int)m_MemberList.Size(); ++ix2)
-        {
-            MemberInfo *pMember2 = &m_MemberList[ix2];
-            if (pMember2->m_mdFunc != 0 && pMember2->m_psFunc->memid == pMember->m_psFunc->memid)
-            {   // Found a related function.
-                pMember2->GetFuncInfo(tk, ms);
-                _ASSERTE(ms == msGetter || ms == msSetter || ms==msOther);
-                _ASSERTE(mdFuncs[ms] == 0);
-                mdFuncs[ms] = tk;
-                pMember2->m_mdFunc = 0;
-                // If have found all three, don't bother looking for more.
-                if (++cFound == 3)
-                    break;
-            }
-        }
-        
-        // Build the signature for the property.
-        hr = _GetFunctionPropertyInfo(pMember->m_psFunc, &ms, &psF, &pProperty, &bPropRetval, TRUE, m_szMember);
-        
-        // The function really should have a property associated with it, to get here.  Check anyway.
-        _ASSERTE(pProperty);
-        if (!pProperty)
-            continue;
-
-        // Some sort of property accessor.
-        IfFailGo(qbComSig.ReSizeNoThrow(CB_MAX_ELEMENT_TYPE + 1));
-        pbSig = (BYTE *)qbComSig.Ptr();
-        cbTotal = cb = CorSigCompressData((ULONG)IMAGE_CEE_CS_CALLCONV_PROPERTY, pbSig);
-        // Count of parameters.
-        
-        // If this is a getter, see if there is a retval.
-        if (psF->invkind == INVOKE_PROPERTYGET)
-        {   // Examine each param, and count all except the [retval].
-            for (cDestParams=iSrcParam=0; iSrcParam<psF->cParams; ++iSrcParam)
-            {
-                if ((psF->lprgelemdescParam[iSrcParam].paramdesc.wParamFlags & NON_CONVERTED_PARAMS_FLAGS) == 0)
-                    ++cDestParams;
-            }
-            // There is no new value param for getters.
-            ixValue = -1;
-        }
-        else
-        {   
-            // This is a putter, so 1 param is new value, others are indices (or lcid).
-            for (cDestParams=iSrcParam=0; iSrcParam<psF->cParams-1; ++iSrcParam)
-            {
-                if ((psF->lprgelemdescParam[iSrcParam].paramdesc.wParamFlags & NON_CONVERTED_PARAMS_FLAGS) == 0)
-                    ++cDestParams;
-            }            
-            // The last parameter is the new value.
-            ixValue = psF->cParams - 1;
-        }
-
-        //-------------------------------------------------------------------------
-        // See if there is a vararg param.
-        ixVarArg = psF->cParams + 1;
-        if (psF->cParamsOpt == -1)
-        {
-            // If this is a PROPERTYPUT or PROPERTYPUTREF, skip the last non-retval parameter (it
-            //  is the new value to be set).
-            BOOL bPropVal = (psF->invkind & (INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF)) ? TRUE : FALSE;
-            // Find the vararg param.
-            for (iSrcParam=psF->cParams-1; iSrcParam>=0; --iSrcParam)
-            {
-                // The count of optional params does not include any lcid params, nor does
-                //  it include the return value, so skip those.
-                if ((psF->lprgelemdescParam[iSrcParam].paramdesc.wParamFlags & (PARAMFLAG_FRETVAL|PARAMFLAG_FLCID)) != 0)
-                    continue;
-                // If haven't yet seen the property value, this param is it, so skip it, too.
-                if (bPropVal)
-                {
-                    bPropVal = FALSE;
-                    continue;
-                }
-                ixVarArg = iSrcParam;
-                break;
-            } // for (iSrcParam=cParams-1...
-        }
-        
-        // Put in the count of index parameters.
-        _ASSERTE(cDestParams >= 0);
-        cb = CorSigCompressData(cDestParams, &pbSig[cbTotal]);
-        cbTotal += cb;
-
-        // Create the signature for the property type.
-        sigFlags = SIG_ELEM | (bPropRetval ? SIG_RET : (SigFlags)0);
-        IfFailGo(_ConvSignature(pITI, pProperty, sigFlags, qbComSig, cbTotal, &cbTotal, qbDummyNativeTypeBuf, 0, &iNativeOfs, bNewEnumMember));
-        if (hr == S_CONVERSION_LOSS)
-            bConversionLoss = true;
-
-        // Fill in the "index" part of the property's signature.
-        for (iSrcParam=0; iSrcParam<psF->cParams; ++iSrcParam)
-        {
-            if (psF->lprgelemdescParam[iSrcParam].paramdesc.wParamFlags & NON_CONVERTED_PARAMS_FLAGS)
-                continue;
-            if (iSrcParam == static_cast<int>(ixValue))
-                continue;
-            sigFlags = SIG_FUNC | SIG_USE_BYREF;
-            if (iSrcParam == ixVarArg)
-                sigFlags |= SIG_VARARG;
-            IfFailGo(_ConvSignature(pITI, &psF->lprgelemdescParam[iSrcParam].tdesc, sigFlags, qbComSig, cbTotal, &cbTotal, qbDummyNativeTypeBuf, 0, &iNativeOfs, bNewEnumMember));
-            if (hr == S_CONVERSION_LOSS)
-                bConversionLoss = true;
-        }
-
-        // Get the property name.  Add interface name and make unique, if needed.
-        // m_szInterface should be non-null if processing an implemented interface; should be null otherwise.
-        _ASSERTE(m_ImplIface == eImplIfaceNone || m_szInterface != 0);
-        IfFailGo(qbName.ReSizeNoThrow(wcslen(m_szMember)+2));
-        wcscpy_s(qbName.Ptr(), wcslen(m_szMember)+2, m_szMember); 
-        IfFailGo(GenerateUniqueMemberName(qbName, (PCCOR_SIGNATURE)qbComSig.Ptr(), cbTotal, m_szInterface, mdtProperty));
-        pszName = qbName.Ptr();
-
-        // Define the property.
-        IfFailGo(m_pEmit->DefineProperty(m_tdTypeDef, pszName, 0/*dwFlags*/, 
-                        (PCCOR_SIGNATURE) qbComSig.Ptr(), cbTotal, 0, 0, -1, 
-                        mdFuncs[msSetter], mdFuncs[msGetter], &mdFuncs[msOther], 
-                        &pd));
-
-        // Handle dispids for non-implemented interfaces, and for default interface
-        if (m_ImplIface != eImplIface)
-        {
-            // Set the dispid CA on the property.
-            long lDispSet = 1;
-            _SetDispIDCA(pITI, pMember->m_iMember, psF->memid, pd, TRUE, &lDispSet, TRUE);
-
-            // If this property is default property, add a custom attribute to the class.
-            if (lDispSet == DISPID_VALUE)
-                IfFailGo(_AddDefaultMemberCa(m_tdTypeDef, m_szMember));
-        }
-        
-        // Add the alias information if the type is an alias.
-        IfFailGo(_HandleAliasInfo(pITI, pProperty, pd));
-    }
-    
-    if (bConversionLoss)
-        hr = S_CONVERSION_LOSS;
-
-ErrExit:    
-    if (m_szMember)
-        ::SysFreeString(m_szMember), m_szMember=0;
-    
-    return hr;
-} // HRESULT CImportTlb::_ConvPropertiesForFunctions()
-
-//*****************************************************************************
-// Convert the vars and functions of a dispinterface.  Vars actually turn
-//  into a getter and possibly a setter.
-//*****************************************************************************
-HRESULT CImportTlb::_ConvDispatchMembers(
-    ITypeInfo   *pITI,                  // ITypeInfo* to convert.
-    TYPEATTR    *psAttr,                // TypeAttr of ITypeInfo.
-    BOOL        fInheritsIEnum)
-{
-    HRESULT     hr;                     // A result.
-    int         i;                      // Loop control.
-    BOOL        bConversionLoss=FALSE;  // If true, some attributes were lost on conversion.
-
-    IfFailGo(_FindFirstUserMethod(pITI, psAttr, &i));
-    IfFailGo(BuildMemberList(pITI, i, psAttr->cFuncs, fInheritsIEnum));
-    
-    // Dispatch members really have no slot.
-    m_Slot = 0;
-
-    // Loop over properties.
-    for (i=0; i<m_cMemberProps; ++i)
-    {
-        IfFailGo(_ConvProperty(pITI, &m_MemberList[i]));
-    }
-
-    // Loop over functions.
-    BOOL bAllowIEnum = !fInheritsIEnum;
-    for (; i<(int)m_MemberList.Size(); ++i)
-    {
-        // Get variable information.
-        IfFailGo(_ConvFunction(pITI, &m_MemberList[i], FALSE, TRUE, FALSE, &bAllowIEnum));
-        if (hr == S_CONVERSION_LOSS)
-            bConversionLoss = TRUE;
-    }
-
-    // Add the property info.
-    IfFailGo(_ConvPropertiesForFunctions(pITI, psAttr));
-    
-    if (bConversionLoss)
-        hr = S_CONVERSION_LOSS;
-
-ErrExit:
-    // Free the func descs.
-    FreeMemberList(pITI);
-
-    return (hr);
-} // HRESULT CImportTlb::_ConvDispatchMembers()
-
-//*****************************************************************************
-// Examine the functions on an interface, and skip the first 3 or first 7
-//  if the functions are IUnknown or IDispatch members.
-//*****************************************************************************
-HRESULT CImportTlb::_FindFirstUserMethod(
-    ITypeInfo   *pITI,                  // The Typedef to examine.
-    TYPEATTR    *psAttr,                // TYPEATTR for the typedef.
-    int         *pIx)                   // Put index of first user function here.
-{
-    HRESULT     hr = S_OK;              // A result.
-    int         i;                      // Loop control.
-    FUNCDESC    *psFunc=0;              // FUNCDESC for a member.
-    BSTR        szName=0;               // A function's name.
-
-    // Note:  this is a terrible workaround, but in some situations the methods from IUnknown / IDispatch will
-    //  show up as though native dispatch functions.
-    i = 0;
-    if (psAttr->cFuncs >= 3)
-    {
-        IfFailGo(TryGetFuncDesc(pITI, i, &psFunc));
-        if (psFunc->memid == 0x60000000 &&
-            psFunc->elemdescFunc.tdesc.vt == VT_VOID &&
-            psFunc->cParams == 2 &&
-            psFunc->lprgelemdescParam[0].tdesc.vt == VT_PTR && // -> VT_USERDEFINED
-            psFunc->lprgelemdescParam[1].tdesc.vt == VT_PTR && // -> VT_PTR -> VT_VOID
-            SUCCEEDED(pITI->GetDocumentation(psFunc->memid, &szName, 0,0,0)) &&
-            (wcscmp(szName, W("QueryInterface")) == 0) )
-                i = 3;
-        pITI->ReleaseFuncDesc(psFunc);
-        psFunc=0;
-        if (szName)
-            ::SysFreeString(szName);
-        szName = 0;
-        if (psAttr->cFuncs >= 7)
-        {
-            IfFailGo(TryGetFuncDesc(pITI, i, &psFunc));
-            if (psFunc->memid == 0x60010000 &&
-                psFunc->elemdescFunc.tdesc.vt == VT_VOID &&
-                psFunc->cParams == 1 &&
-                psFunc->lprgelemdescParam[0].tdesc.vt == VT_PTR && // -> VT_UINT
-                SUCCEEDED(pITI->GetDocumentation(psFunc->memid, &szName, 0,0,0)) &&
-                (wcscmp(szName, W("GetTypeInfoCount")) == 0) )
-                    i = 7;
-            pITI->ReleaseFuncDesc(psFunc);
-            psFunc=0;
-            if (szName)
-                ::SysFreeString(szName);
-            szName = 0;
-        }
-    }
-
-    *pIx = i;
-
-ErrExit:
-    if (psFunc)
-        pITI->ReleaseFuncDesc(psFunc);
-    if (szName)
-        ::SysFreeString(szName);
-    return (hr);
-} // HRESULT CImportTlb::_FindFirstUserMethod()
-
-//*****************************************************************************
-// Given a FUNCDESC that is has INVOKE_PROPERTY* decoration, determine
-//  the role of the function, and the property signature type.
-//*****************************************************************************
-HRESULT CImportTlb::_GetFunctionPropertyInfo(
-    FUNCDESC    *psFunc,                // Function for which to get info.
-    USHORT      *pSemantics,            // Put appropriate semantics here.
-    FUNCDESC    **ppSig,                // Put FUNCDESC for signature here.
-    TYPEDESC    **ppProperty,           // Put TYPEDESC for return here.
-    BOOL        *pbRetval,              // If true, the type is [retval]
-    BOOL        fUseLastParam,          // If true, default to the last parameter as the return value
-    BSTR        strName)                // Name of the property
-{
-    FUNCDESC    *psTmp;                 // FUNCDESC for some method.
-    FUNCDESC    *psGet=0;               // FUNCDESC for Get method defining a property.
-    FUNCDESC    *psPut=0;               // FUNCDESC for Put method defining a property.
-    FUNCDESC    *psPutRef=0;            // FUNCDESC for PutRef method defining a property.
-    FUNCDESC    *psF;                   // A FUNCDESC.
-    TYPEDESC    *pReturn=0;             // The FUNCDESC's return type.
-    int         cFound=0;               // Count of functions found.
-    int         i;                      // Loop control.
-    HRESULT     hr = S_OK;
-
-    if (psFunc->invkind & INVOKE_PROPERTYGET)
-    {   // A "Get", so return type is property type.
-        *ppSig = psFunc;
-        *pSemantics = msGetter;
-    }
-    else
-    {   
-        _ASSERTE(psFunc->invkind & (INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF));
-        // Search for the "best" method from which to grab the signature.  We prefer the Get(),
-        //  Followed by the Put(), followed by the PutRef()
-        // Also look for Put() and PutRef(), so we can 
-        for (int iFunc=0; iFunc<(int)m_MemberList.Size() && cFound<3; ++iFunc)
-        {
-            // Get a FUNCDESC from the list.
-            psTmp = m_MemberList[iFunc].m_psFunc;
-
-            // Is it for the same func?
-            if (psTmp->memid != psFunc->memid)
-                continue;
-
-            // Is it the Get()?  If so, it is the one we want.
-            if (psTmp->invkind & INVOKE_PROPERTYGET)
-            {
-                psGet = psTmp;
-                ++cFound;
-                continue;
-            }
-
-            // Is it the Put()?  Use it if we don't find a Get().
-            if (psTmp->invkind & INVOKE_PROPERTYPUT)
-            {
-                psPut = psTmp;
-                ++cFound;
-                continue;
-            }
-
-            // Is it the PutRef()?  Keep track of it.
-            if (psTmp->invkind & INVOKE_PROPERTYPUTREF)
-            {
-                psPutRef = psTmp;
-                ++cFound;
-            }
-        }
-        // Get the best FUNCDESC for the signature.
-        *ppSig = psGet ? psGet : (psPut ? psPut : psFunc);
-
-        // Determine whether this is a the "Set" or "VB specific Let" function.
-        if (psFunc->invkind & INVOKE_PROPERTYPUTREF)
-        {   // This function is the PROPERTYPUTREF.  Make it the setter.  If
-            //  there is also a PROPERTYPUT, it will be the "letter".
-            *pSemantics = msSetter;
-        }
-        else
-        {   // We are looking at the PROPERTYPUT function (the "Let" function in native VB6.).
-            
-            // If there is also a PROPERTYPUTREF, make this the "VB Specific Let" function.
-            if (psPutRef)
-            {   // A PPROPERTYPUTREF also exists, so make this the "Let" function.
-                *pSemantics = msOther;
-            }
-            else
-            {   // There is no PROPERTYPUTREF, so make this the setter.
-                *pSemantics = msSetter;
-            }
-        }
-    }
-
-    // Occasionally there is a property with no discernable type.  In that case, lose the 
-    //  property on conversion.
-
-    // Determine the type of the property, based on the "best" accessor.
-    psF = *ppSig;
-    *pbRetval = FALSE;
-    if (psF->invkind & INVOKE_PROPERTYGET)
-    {   // look for [retval].
-        for (i=psF->cParams-1; i>=0; --i)
-        {
-            if (psF->lprgelemdescParam[i].paramdesc.wParamFlags & PARAMFLAG_FRETVAL)
-            {   // will consume a level of indirection (later).
-                *pbRetval = TRUE;
-                pReturn = &psF->lprgelemdescParam[i].tdesc;
-                break;
-            }
-        }
-        // If no [retval], check return type.
-        if (!pReturn && psF->elemdescFunc.tdesc.vt != VT_VOID && psF->elemdescFunc.tdesc.vt != VT_HRESULT)
-            pReturn = &psF->elemdescFunc.tdesc;
-
-        if (fUseLastParam)
-        {
-            // We may have stripped the [retval] if this is a disp-only interface.  Just use the last parameter.
-            if (!pReturn && (psF->cParams > 0))
-                pReturn = &psF->lprgelemdescParam[psF->cParams-1].tdesc;
-        }
-        else
-        {
-            // If there is no type, don't try to set the getter.
-            if (pReturn && pReturn->vt == VT_VOID)
-                pReturn = NULL;
-        }
-
-        if (!pReturn)
-        {
-            ReportEvent(NOTIF_CONVERTWARNING, TLBX_E_PROPGET_WITHOUT_RETURN, strName, m_szMngName);
-        }
-    }
-    else
-    {   // Find lastmost param that isn't [retval].  (Should be the last param, but it is 
-        //  possible to write an IDL with a PROPERTYPUT that has a [retval].
-        for (i=psF->cParams-1; i>=0; --i)
-        {
-            if ((psF->lprgelemdescParam[psF->cParams-1].paramdesc.wParamFlags & PARAMFLAG_FRETVAL) == 0)
-            {
-                {   // First, and possibly only, param.
-                    pReturn = &psF->lprgelemdescParam[i].tdesc;
-                    break;
-                }
-            }
-        }
-    }
-
-//ErrExit:
-    if (pReturn == 0)
-        *pSemantics = 0;
-    *ppProperty = pReturn;
-
-    return hr;
-} // HRESULT CImportTlb::_GetFunctionPropertyInfo()
-
-//*****************************************************************************
-// Convert a function description to metadata entries.
-//  
-// This can be rather involved.  If the function is a INVOKE_PROPERTY*,
-//  determine if it will be converted as a COM+ property, and if so, which
-//  of up to three functions will be selected to provide the property 
-//  signature.
-// The function return type is found by scaning the parameters looking for 
-//  [retval]s.
-//*****************************************************************************
-#ifdef _PREFAST_
-#pragma warning(push)
-#pragma warning(disable:21000) // Suppress PREFast warning about overly large function
-#endif
-HRESULT CImportTlb::_ConvFunction(
-    ITypeInfo   *pITI,                  // Containing TypeInfo.
-    MemberInfo  *pMember,               // iNFO for the function.
-    BOOL        bVtblGapFuncs,          // Add functions for vtblGaps?
-    BOOL        bAddDispIds,            // Add DispIds to the member?
-    BOOL        bDelegateInvokeMeth,    // Convert function for a delegate invoke
-    BOOL*       bAllowIEnum)            // Allowed to change this function to GetEnumerator
-{
-    HRESULT     hr;                     // A result.
-    int         iSrcParam;              // Param count, as looping through params.
-    int         iDestParam;             // Param count, as looping through params.
-    int         cDestParams;            // Count of destination params.
-    int         ixOpt;                  // Index of first param that is optional due to cParamsOpt.
-    int         ixVarArg;               // Index of vararg param, if any.
-    mdMethodDef mdFunc;                 // Token of new member.
-    BSTR        szTypeName=0;           // Name of the type.
-    DWORD       dwFlags=0;              // Member flags.
-    DWORD       dwImplFlags=0;          // The impl flags.
-    WCHAR       *pszName=0;             // Possibly decorated name of member.
-    CQuickArray<WCHAR> qbName;          // Buffer for decorated name.
-    TYPEDESC    *pReturn=0;             // Return type.
-    int         bRetval=false;          // Is the return result a [retval] parameter?
-    int         ixRetval;               // Which param is the [retval]?
-    TYPEDESC    *pReturnRetval=0;       // Return type from [retval] (incl. indirection).
-    WORD        wRetFlags=0;            // Return type flags.
-    ULONG       offset=0;               // Offset of function
-    BSTR        *rszParamNames=0;       // Parameter names.
-    UINT        iNames;                 // Count of actual names.
-    CQuickBytes qbComSig;               // new signature 
-    BYTE        *pbSig;                 // Pointer into the signature.
-    ULONG       sigFlags;               // Signature handling flags.
-    CQuickArray<BYTE> qbNativeBuf;      // Native type buffer.
-    CQuickArray<BYTE> qbDummyNativeTypeBuf; // A dummy native type array.
-    CQuickArray<ULONG> qbNativeOfs;     // Offset of native type for each param.
-    CQuickArray<ULONG> qbNativeLen;     // Length of native type for each param.
-    ULONG       iNativeOfs=0;           // Current offset in native type buffer.
-    ULONG       iNewNativeOfs=0;        // New offset in native type buffer.
-    ULONG       cb;                     // Size of an element.
-    ULONG       cbTotal = 0;            // Size of the signature.
-    int         bOleCall=false;         // Is the implementation OLE style?(HRESULT or IDispatch)
-    USHORT      msSemantics=0;          // Property's methodsemantics.
-    WCHAR       szSpecial[40];          // To build name of special function.
-    mdToken     tkAttr;                 // Token for custom attribute type.
-    BOOL        bConversionLoss=false;  // If true, some attributes were lost on conversion.
-    enum {ParamRetval=-1, ParamNone=-2};
-    int         iParamError=ParamNone;  // Index of param with conversion error.
-    BOOL        bNewEnumMember = FALSE; // A flag indicating if the member is the NewEnum member.
-    int         iLCIDParam = -1;        // Index of the LCID parameter.
-    FUNCDESC    *psFunc = pMember->m_psFunc;
-
-    // If we might insert vtable gaps, then we'd better have initialized the vtable slot size.
-    _ASSERTE(!bVtblGapFuncs || (m_cbVtableSlot != 0));
-
-    // Retrieve the member name from the member info.
-    IfNullGo(m_szMember = SysAllocString(bDelegateInvokeMeth ? DELEGATE_INVOKE_METH_NAME : pMember->m_pName));
-
-#ifdef _DEBUG
-    LPWSTR funcName = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_TlbImpShouldBreakOnConvFunction);
-    if (funcName)
-    {
-        if (wcscmp(funcName, pMember->m_pName) == 0)
-            _ASSERTE(!"TlbImpBreakOnConvFunction");
-        
-        delete [] funcName;
-    }
-#endif //_DEBUG
-
-    // Determine if the member is the new enum member.
-    if ((*bAllowIEnum))
-    {
-        bNewEnumMember = FuncIsNewEnum(pITI, psFunc, pMember->m_iMember) == S_OK;
-        
-        // Once a method is converted in this interface, don't convert any more.
-        if (bNewEnumMember)
-            *bAllowIEnum = FALSE;
-    }
-    
-
-    // We should NEVER have a new enum member when we are dealing with a delegate invoke meth.
-    if (bNewEnumMember && bDelegateInvokeMeth)
-    {
-        // Get the real name of the method
-        BSTR szTypeInfoName = NULL;
-        BSTR szMemberName = NULL;
-        hr = m_pITI->GetDocumentation(MEMBERID_NIL, &szTypeInfoName, 0, 0, 0);
-        if (FAILED(hr))
-            szTypeInfoName = SysAllocString(W("???"));
-                       
-        ReportEvent(NOTIF_CONVERTWARNING, TLBX_E_EVENT_WITH_NEWENUM, szTypeInfoName);
-
-        SysFreeString(szMemberName);
-        SysFreeString(szTypeInfoName);
-        
-        IfFailGo(TLBX_E_EVENT_WITH_NEWENUM);
-    }
-
-    // If there is a gap in the vtable, emit a special function.
-    if (bVtblGapFuncs)
-    {
-        if ((psFunc->oVft / m_cbVtableSlot) != m_Slot)
-        {
-            ULONG n = psFunc->oVft / m_cbVtableSlot;
-            // Make sure slot numbers are monotonically increasing.
-            if (n < m_Slot)
-            {
-                IfFailGo(pITI->GetDocumentation(MEMBERID_NIL, &szTypeName, 0, 0, 0));
-                IfFailGo(PostError(TLBX_E_BAD_VTABLE, m_szMember, szTypeName, m_szLibrary));
-            }
-
-            n -= m_Slot;
-            if (n == 1)
-                _snwprintf_s(szSpecial, lengthof(szSpecial), lengthof(szSpecial) - 1, VTBL_GAP_FORMAT_1, VTBL_GAP_FUNCTION, m_Slot);
-            else
-                _snwprintf_s(szSpecial, lengthof(szSpecial), lengthof(szSpecial) - 1, VTBL_GAP_FORMAT_N, VTBL_GAP_FUNCTION, m_Slot, n);
-            IfFailGo(m_pEmit->DefineMethod(m_tdTypeDef, szSpecial, VTBL_GAP_FUNCTION_FLAGS, VTBL_GAP_SIGNATURE,sizeof(VTBL_GAP_SIGNATURE),
-                0/* rva*/, VTBL_GAP_FUNC_IMPL_FLAGS, &mdFunc));
-            m_Slot += n;
-        }
-        // What we will expect next time.
-        ++m_Slot;
-    }
-
-    //-------------------------------------------------------------------------
-    // Determine the return type.
-    // If this is an hresult function, prepare to munge return, params.
-    if (psFunc->elemdescFunc.tdesc.vt == VT_HRESULT)
-    {
-        bOleCall = true;
-    }
-    else
-    {
-        if ((psFunc->elemdescFunc.tdesc.vt != VT_VOID) && (psFunc->elemdescFunc.tdesc.vt != VT_HRESULT))
-            pReturn = &psFunc->elemdescFunc.tdesc;
-    }
-
-    // Look for [RETVAL].
-    for (iSrcParam=0; iSrcParam<psFunc->cParams; ++iSrcParam)
-    {
-        if (psFunc->lprgelemdescParam[iSrcParam].paramdesc.wParamFlags & PARAMFLAG_FRETVAL)
-        {   
-            // If already have a return, or a DISPATCH function, error.
-            if (pReturn != 0)
-            {   // Unexpected return found.
-                ReportEvent(NOTIF_CONVERTWARNING, TLBX_E_AMBIGUOUS_RETURN, m_szName, m_szMember);
-                IfFailGo(TLBX_E_AMBIGUOUS_RETURN);
-            }
-            else
-            {   // Found a return type.
-                wRetFlags = psFunc->lprgelemdescParam[iSrcParam].paramdesc.wParamFlags;
-                pReturn = &psFunc->lprgelemdescParam[iSrcParam].tdesc;
-                bRetval = true;
-                ixRetval = iSrcParam;
-            }
-            break;
-        }
-    }
-    
-    // Check to see if there is an LCID parameter.
-    for (iSrcParam=0;iSrcParam<psFunc->cParams;iSrcParam++)
-    {
-        if (psFunc->lprgelemdescParam[iSrcParam].paramdesc.wParamFlags & PARAMFLAG_FLCID)
-        {
-            if (iLCIDParam != -1)
-                IfFailGo(PostError(TLBX_E_MULTIPLE_LCIDS, m_szName, m_szMember));
-            iLCIDParam = iSrcParam;
-        }
-    }
-
-    //-------------------------------------------------------------------------
-    // Size buffers to accomodate parameters.
-    // Resize the native type length array.
-    IfFailGo(qbNativeBuf.ReSizeNoThrow(1));
-    IfFailGo(qbNativeLen.ReSizeNoThrow(psFunc->cParams + 1));
-    IfFailGo(qbNativeOfs.ReSizeNoThrow(psFunc->cParams + 1));
-    memset(qbNativeLen.Ptr(), 0, (psFunc->cParams + 1)*sizeof(int));
-    memset(qbNativeOfs.Ptr(), 0, (psFunc->cParams + 1)*sizeof(int));
-
-    // resize to make room for calling convention and count of argument
-    IfFailGo(qbComSig.ReSizeNoThrow(CB_MAX_ELEMENT_TYPE + 1));
-    pbSig = (BYTE *)qbComSig.Ptr();
-
-    //-------------------------------------------------------------------------
-    // Determine which params need to be marked optional, by virtue of cParamsOpt count.
-    if (psFunc->cParamsOpt == 0)
-        ixVarArg = ixOpt = psFunc->cParams + 1;
-    else
-    {
-        if (psFunc->cParamsOpt == -1)
-        {   // Varargs.
-            ixVarArg = ixOpt = psFunc->cParams + 1;
-            // If this is a PROPERTYPUT or PROPERTYPUTREF, skip the last non-retval parameter (it
-            //  is the new value to be set).
-            BOOL bPropVal = (psFunc->invkind & (INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF)) ? TRUE : FALSE;
-            // Find the vararg param.
-            for (iSrcParam=psFunc->cParams-1; iSrcParam>=0; --iSrcParam)
-            {
-                // The count of optional params does not include any lcid params, nor does
-                //  it include the return value, so skip those.
-                if ((psFunc->lprgelemdescParam[iSrcParam].paramdesc.wParamFlags & (PARAMFLAG_FRETVAL|PARAMFLAG_FLCID)) != 0)
-                    continue;
-                // If haven't yet seen the property value, this param is it, so skip it, too.
-                if (bPropVal)
-                {
-                    bPropVal = FALSE;
-                    continue;
-                }
-                ixVarArg = iSrcParam;
-                break;
-            } // for (iSrcParam=cParams-1...
-        }
-        else
-        {   // ixOpt will be index of first optional parameter.
-            short cOpt = psFunc->cParamsOpt;
-            ixOpt = 0;
-            ixVarArg = psFunc->cParams + 1;
-            for (iSrcParam=psFunc->cParams-1; iSrcParam>=0; --iSrcParam)
-            {
-                // The count of optional params does not include any lcid params, nor does
-                //  it include the return value, so skip those.
-                if ((psFunc->lprgelemdescParam[iSrcParam].paramdesc.wParamFlags & (PARAMFLAG_FRETVAL|PARAMFLAG_FLCID)) == 0)
-                {   
-                    if (--cOpt == 0)
-                    {
-                        ixOpt = iSrcParam;
-                        break;
-                    }
-                }
-            } // for (iSrcParam=cParams-1...
-        }
-    }
-
-
-    //-------------------------------------------------------------------------
-    // Get the parameter names.
-    rszParamNames = reinterpret_cast<BSTR*>(_alloca((psFunc->cParams+1) * sizeof(BSTR*)));
-
-    // Get list of names.
-    IfFailGo(pITI->GetNames(psFunc->memid, rszParamNames, psFunc->cParams+1, &iNames));
-
-    // zero name pointer for non-named params.
-    for (iSrcParam=iNames; iSrcParam<=psFunc->cParams; ++iSrcParam)
-        rszParamNames[iSrcParam] = 0;
-
-    //-------------------------------------------------------------------------
-    // Convert the calling convention, param count, and return type.
-    cDestParams = psFunc->cParams;
-    if (bRetval)
-        --cDestParams;
-    if (iLCIDParam != -1)
-        --cDestParams;
-
-    if (pReturn)
-    {   
-        // Param count
-        cbTotal = cb = CorSigCompressData((ULONG)IMAGE_CEE_CS_CALLCONV_DEFAULT | IMAGE_CEE_CS_CALLCONV_HASTHIS, pbSig);
-        cb = CorSigCompressData(cDestParams, &(pbSig[cbTotal]));
-        cbTotal += cb;
-        // Return type or [retval].
-        if (bRetval)
-            sigFlags = (SigFlags)(wRetFlags & SIG_FLAGS_MASK) | SIG_FUNC, iParamError=ixRetval;
-        else
-            sigFlags = SIG_FUNC, iParamError=ParamRetval;
-        IfFailGo(_ConvSignature(pITI, pReturn, sigFlags, qbComSig, cbTotal, &cbTotal, qbNativeBuf, iNativeOfs, &iNewNativeOfs, bNewEnumMember));
-        qbNativeLen[0] = iNewNativeOfs - iNativeOfs;
-        qbNativeOfs[0] = iNativeOfs;
-        iNativeOfs = iNewNativeOfs;
-        if (hr == S_CONVERSION_LOSS)
-            bConversionLoss = true;
-    }
-    else
-    {   // No return value
-        cbTotal = cb = CorSigCompressData((ULONG)IMAGE_CEE_CS_CALLCONV_DEFAULT | IMAGE_CEE_CS_CALLCONV_HASTHIS, pbSig);
-        cb = CorSigCompressData(cDestParams, &(pbSig[cbTotal]));
-        cbTotal += cb;
-        cb = CorSigCompressData(ELEMENT_TYPE_VOID, &pbSig[cbTotal]);
-        cbTotal += cb;
-    }
-
-    //-------------------------------------------------------------------------
-    // Translate each parameter.
-    for (iSrcParam=0, iDestParam=0; iSrcParam<psFunc->cParams; ++iSrcParam)
-    {
-        if (!(psFunc->lprgelemdescParam[iSrcParam].paramdesc.wParamFlags & NON_CONVERTED_PARAMS_FLAGS))
-        {
-            sigFlags = (SigFlags)(psFunc->lprgelemdescParam[iSrcParam].paramdesc.wParamFlags & SIG_FLAGS_MASK) | SIG_FUNC | SIG_USE_BYREF;
-            if (iSrcParam == ixVarArg)
-                sigFlags |= SIG_VARARG;
-            iParamError = iSrcParam;
-            IfFailGo(_ConvSignature(pITI, &psFunc->lprgelemdescParam[iSrcParam].tdesc, sigFlags, qbComSig, cbTotal, &cbTotal, qbNativeBuf, iNativeOfs, &iNewNativeOfs, bNewEnumMember));
-            qbNativeLen[iDestParam+1] = iNewNativeOfs - iNativeOfs;
-            qbNativeOfs[iDestParam+1] = iNativeOfs;
-            iNativeOfs = iNewNativeOfs;
-            iDestParam++;
-            if (hr == S_CONVERSION_LOSS)
-                bConversionLoss = true;
-        }
-    }
-    iParamError = ParamNone;
-
-    //-------------------------------------------------------------------------
-    // Get the previously decorated name.  Add interface name and make unique.
-    if (bDelegateInvokeMeth)
-    {
-        pszName = (WCHAR*)DELEGATE_INVOKE_METH_NAME;
-    }
-    else
-    {
-        // m_szInterface should be non-null if processing an implemented interface; should be null otherwise.
-        _ASSERTE(m_ImplIface == eImplIfaceNone || m_szInterface != 0);
-        IfFailGo(qbName.ReSizeNoThrow(wcslen(pMember->m_pName)+2));
-        wcscpy_s(qbName.Ptr(), wcslen(pMember->m_pName)+2, pMember->m_pName); 
-        IfFailGo(GenerateUniqueMemberName(qbName, (PCCOR_SIGNATURE)qbComSig.Ptr(), cbTotal, m_szInterface, mdtMethodDef));
-        pszName = qbName.Ptr();
-    }
-
-    // Determine the function's semantics, flags and impl flags.
-    if (!bDelegateInvokeMeth)
-    {
-    msSemantics = pMember->m_msSemantics;
-        dwImplFlags = DEFAULT_ITF_FUNC_IMPL_FLAGS;
-    dwFlags = msSemantics ? DEFAULT_PROPERTY_FUNC_FLAGS : DEFAULT_INTERFACE_FUNC_FLAGS;
-    // If processing an implemented interface, remove the abstract bit.  Methods on classes are not abstract.
-    if (m_ImplIface != eImplIfaceNone)
-        dwFlags &= ~mdAbstract;
-    }
-    else
-    {
-        msSemantics = 0;
-        dwImplFlags = miRuntime;
-        dwFlags = DELEGATE_INVOKE_FUNC_FLAGS;
-    }
-
-    //-------------------------------------------------------------------------
-    // Create the function definition in the metadata.
-    IfFailGo(m_pEmit->DefineMethod(m_tdTypeDef, pszName, dwFlags, (PCCOR_SIGNATURE) qbComSig.Ptr(),cbTotal, 
-        0 /* rva*/, dwImplFlags | (bOleCall ? 0 : miPreserveSig), &mdFunc));
-
-    // If the method is part of a property, save info to set up the property.
-    if (msSemantics)
-        pMember->SetFuncInfo(mdFunc, msSemantics);
-    
-    // Handle dispids for non-implemented interfaces, and for default interface
-    if (m_ImplIface != eImplIface)
-    {
-        // Add the DispIds if the flag is set.
-        long lDispSet = 1;
-        _SetDispIDCA(pITI, pMember->m_iMember, psFunc->memid, mdFunc, bAddDispIds, &lDispSet, TRUE);
-
-        // If this method is the default, and not a property accessor, add a custom attribute to the class.
-        if (lDispSet == DISPID_VALUE && msSemantics == 0)
-            IfFailGo(_AddDefaultMemberCa(m_tdTypeDef, m_szMember));
-    }
-    
-    DECLARE_CUSTOM_ATTRIBUTE(sizeof(int));
-    
-    // If this method has an LCID then set the LCIDConversion attribute.
-    if (iLCIDParam != -1)
-    {
-        // Dispid for the function.
-        BUILD_CUSTOM_ATTRIBUTE(int, iLCIDParam);
-        IfFailGo(GetAttrType(ATTR_LCIDCONVERSION, &tkAttr));
-        FINISH_CUSTOM_ATTRIBUTE();
-        IfFailGo(m_pEmit->DefineCustomAttribute(mdFunc, tkAttr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(), 0));
-    }
-
-    // Save the func flags for anyone that needs typelib's flags.
-    if (psFunc->wFuncFlags)
-    {
-        IfFailGo(GetAttrType(ATTR_TYPELIBFUNC, &tkAttr));
-        INIT_CUSTOM_ATTRIBUTE(sizeof(WORD));
-        BUILD_CUSTOM_ATTRIBUTE(WORD, psFunc->wFuncFlags);
-        FINISH_CUSTOM_ATTRIBUTE();
-        IfFailGo(m_pEmit->DefineCustomAttribute(mdFunc, tkAttr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(),0));
-    }
-
-    //-------------------------------------------------------------------------
-    // Convert the param info for the return type.
-    if (pReturn)
-    {   // store return value parameter as sequence 0
-        if (bRetval)
-        {
-            hr = _IsAlias(pITI, &psFunc->lprgelemdescParam[ixRetval].tdesc);
-            IfFailGo(hr);
-            if (qbNativeLen[0] || hr == S_OK)
-            {
-                IfFailGo(_ConvParam(pITI, mdFunc, 0, &psFunc->lprgelemdescParam[ixRetval], ParamNormal, 0 /*rszParamNames[ixRetval+1]*/, 
-                    &qbNativeBuf[qbNativeOfs[0]], qbNativeLen[0]));
-            }
-        }
-        else
-        {
-            hr = _IsAlias(pITI, &psFunc->elemdescFunc.tdesc);
-            IfFailGo(hr);
-            if (qbNativeLen[0] || hr == S_OK)
-            {
-                IfFailGo(_ConvParam(pITI, mdFunc, 0, &psFunc->elemdescFunc, ParamNormal, 0, 
-                    &qbNativeBuf[qbNativeOfs[0]], qbNativeLen[0]));
-            }
-        }
-    }
-
-    //-------------------------------------------------------------------------
-    // Convert parameter info (flags, native type, default value).
-    for (iSrcParam=iDestParam=0; iSrcParam<psFunc->cParams; ++iSrcParam)
-    {
-        if ((psFunc->lprgelemdescParam[iSrcParam].paramdesc.wParamFlags & NON_CONVERTED_PARAMS_FLAGS) == 0)
-        {
-            ParamOpts opt = ParamNormal;
-            if (iSrcParam >= ixOpt)
-                opt = ParamOptional;
-            else
-            if (iSrcParam == ixVarArg)
-                opt = ParamVarArg;
-            iDestParam++;
-            IfFailGo(_ConvParam(pITI, mdFunc, iDestParam, &psFunc->lprgelemdescParam[iSrcParam], opt, rszParamNames[iSrcParam + 1], 
-                &qbNativeBuf[qbNativeOfs[iDestParam]], qbNativeLen[iDestParam]));
-        }
-    }
-
-    
-    //-------------------------------------------------------------------------
-    // If processing an implemented interface, set up MethodImpls.
-    if (m_ImplIface != eImplIfaceNone)
-    {  
-        // Define a memberref on the implemented interface.
-        mdToken mrItfMember;
-        IfFailGo(m_pEmit->DefineMemberRef(m_tkInterface, pMember->m_pName, (PCCOR_SIGNATURE) qbComSig.Ptr(),cbTotal, &mrItfMember));
-
-        // Define a method impl.
-        IfFailGo(m_pEmit->DefineMethodImpl(m_tdTypeDef, mdFunc, mrItfMember));
-    }
-
-    if (bConversionLoss)
-    {
-        hr = S_CONVERSION_LOSS;
-        ReportEvent(NOTIF_CONVERTWARNING, TLBX_I_UNCONVERTABLE_ARGS, m_szName, m_szMember);
-    }
-
-ErrExit:
-    // Special case for typeload load failures -- they're very hard to diagnose.
-    if (hr == TYPE_E_CANTLOADLIBRARY)
-    {
-        if (iParamError >= 0 && iParamError < psFunc->cParams && rszParamNames[iParamError+1])
-            ReportEvent(NOTIF_CONVERTWARNING, TLBX_E_PARAM_ERROR_NAMED, m_szName, rszParamNames[iParamError+1], m_szMember);
-        else
-            ReportEvent(NOTIF_CONVERTWARNING, TLBX_E_PARAM_ERROR_UNNAMED, m_szName, iParamError, m_szMember);
-    }
-    if (rszParamNames)
-    {
-        for (iSrcParam=0; iSrcParam<=psFunc->cParams; ++iSrcParam)
-            if (rszParamNames[iSrcParam])
-                ::SysFreeString(rszParamNames[iSrcParam]);
-    }
-    if (m_szMember)
-        ::SysFreeString(m_szMember), m_szMember=0;
-    if (szTypeName)
-        ::SysFreeString(szTypeName);
-    
-    return (hr);
-} // HRESULT CImportTlb::_ConvFunction()
-#ifdef _PREFAST_
-#pragma warning(pop)
-#endif
-
-
-HRESULT CImportTlb::_SetHiddenCA(mdTypeDef token)
-{
-    mdToken tkAttr;
-    HRESULT hr = S_OK;
-    
-    DECLARE_CUSTOM_ATTRIBUTE(sizeof(short));
-    BUILD_CUSTOM_ATTRIBUTE(short, TYPEFLAG_FHIDDEN);
-    IfFailGo(GetAttrType(ATTR_TYPELIBTYPE, &tkAttr));
-    FINISH_CUSTOM_ATTRIBUTE();
-    m_pEmit->DefineCustomAttribute(token, tkAttr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(), 0);
-    
-ErrExit:
-    return S_OK;    
-}
-
-HRESULT CImportTlb::_ForceIEnumerableCVExists(ITypeInfo* pITI, BOOL* CVExists)
-{
-    ITypeInfo2  *pITI2 = 0;
-    *CVExists = FALSE;
-    HRESULT hr = S_OK;
-
-    pITI->QueryInterface(IID_ITypeInfo2, reinterpret_cast<void**>(&pITI2));
-
-    if (pITI2)
-    {
-        VARIANT vCustomData;
-        VariantInit(&vCustomData);
-
-        IfFailGo(pITI2->GetCustData(GUID_ForceIEnumerable, &vCustomData));
-
-        if (V_VT(&vCustomData) != VT_EMPTY)
-            *CVExists = TRUE;
-            
-        VariantClear(&vCustomData);       
-    }
-
-ErrExit:
-    if (pITI2)
-        pITI2->Release();
-        
-    return S_OK;
-}
-
-
-HRESULT CImportTlb::_GetDispIDCA(
-    ITypeInfo* pITI,
-    int iMember,
-    long* lDispSet,
-    BOOL bFunc
-    )
-{
-    ITypeInfo2  *pITI2=0;               // For getting custom value.
-    HRESULT hr = S_OK;
-    long lDispId = DISPID_UNKNOWN;
-    
-    // Get the ITypeInfo2 interface if possible
-    pITI->QueryInterface(IID_ITypeInfo2, reinterpret_cast<void**>(&pITI2));
-
-    if (pITI2)
-    {
-        VARIANT vCustomData;
-        VariantInit(&vCustomData);
-
-        if (bFunc)
-            IfFailGo(pITI2->GetFuncCustData(iMember, GUID_DispIdOverride, &vCustomData));
-        else
-            IfFailGo(pITI2->GetVarCustData(iMember, GUID_DispIdOverride, &vCustomData));
-
-        if ((V_VT(&vCustomData) == VT_I2) || (V_VT(&vCustomData) == VT_I4))
-        {
-            hr = VariantChangeType(&vCustomData, &vCustomData, 0, VT_I4);
-            if (hr == S_OK)
-                lDispId = vCustomData.lVal;
-        }
-
-        VariantClear(&vCustomData);
-    }
-
-ErrExit:
-    if (lDispSet != NULL)
-        *lDispSet = lDispId;
-
-    if (pITI2)
-        pITI2->Release();
-        
-    return S_OK;
-}
-
-
-
-HRESULT CImportTlb::_SetDispIDCA(
-    ITypeInfo* pITI,
-    int iMember,
-    long lDispId,
-    mdToken func,
-    BOOL fAlwaysAdd,
-    long* lDispSet,
-    BOOL bFunc
-    )
-{
-    WCHAR DispIDCA[] = W("{CD2BC5C9-F452-4326-B714-F9C539D4DA58}");
-    ITypeInfo2  *pITI2=0;               // For getting custom value.
-    HRESULT hr = S_OK;
-    
-    // Get the ITypeInfo2 interface if possible
-    pITI->QueryInterface(IID_ITypeInfo2, reinterpret_cast<void**>(&pITI2));
-
-    if (pITI2)
-    {
-        VARIANT vCustomData;
-        VariantInit(&vCustomData);
-
-        if (bFunc)
-            IfFailGo(pITI2->GetFuncCustData(iMember, GUID_DispIdOverride, &vCustomData));
-        else
-            IfFailGo(pITI2->GetVarCustData(iMember, GUID_DispIdOverride, &vCustomData));
-
-        if ((V_VT(&vCustomData) == VT_I2) || (V_VT(&vCustomData) == VT_I4))
-        {
-            hr = VariantChangeType(&vCustomData, &vCustomData, 0, VT_I4);
-            if (hr == S_OK)
-            {
-                lDispId = vCustomData.lVal;
-                fAlwaysAdd = true;
-            }
-        }
-        else if (V_VT(&vCustomData) != VT_EMPTY)
-        {
-            // Invalid Variant type on the data - spit out a warning.
-            BSTR CustomValue = SysAllocString((const WCHAR*)&DispIDCA[0]);
-            BSTR ObjectName;
-            IfFailGo(pITI2->GetDocumentation(iMember+1, &ObjectName, NULL, NULL, NULL));
-            
-            ReportEvent(NOTIF_CONVERTWARNING, TLBX_W_NON_INTEGRAL_CA_TYPE, CustomValue, ObjectName);
-
-            SysFreeString(CustomValue);
-            SysFreeString(ObjectName);
-        }
-
-        VariantClear(&vCustomData);
-    }
-
-    // Set the dispid CA on the property.
-    if (fAlwaysAdd)
-    {
-        mdToken tkAttr;
-        DECLARE_CUSTOM_ATTRIBUTE(sizeof(DISPID));
-        BUILD_CUSTOM_ATTRIBUTE(DISPID, lDispId);
-        IfFailGo(GetAttrType(ATTR_DISPID, &tkAttr));
-        FINISH_CUSTOM_ATTRIBUTE();
-        IfFailGo(m_pEmit->DefineCustomAttribute(func, tkAttr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(), 0));
-    }
-    
-ErrExit:
-    if (lDispSet != NULL)
-    {
-        *lDispSet = lDispId;
-    }
-
-    if (pITI2)
-        pITI2->Release();
-
-    return S_OK;
-}
-
-
-HRESULT CImportTlb::_CheckForPropertyCustomAttributes(ITypeInfo* pITI, int index, INVOKEKIND* ikind)
-{
-    HRESULT     hr;
-    VARIANT     vCustomData;
-    ITypeInfo2* pITI2       = 0;
-    BOOL        found       = FALSE;
-
-    VariantInit(&vCustomData);
-
-    // Get the ITypeInfo2 interface if possible
-    pITI->QueryInterface(IID_ITypeInfo2, reinterpret_cast<void**>(&pITI2));
-    if (pITI2)
-    {
-        // First, check for PropGet
-        hr = pITI2->GetFuncCustData(index, GUID_PropGetCA, &vCustomData);
-        IfFailGo(hr);
-        if (V_VT(&vCustomData) != VT_EMPTY)
-        {
-            *ikind = INVOKE_PROPERTYGET;
-            found = TRUE;
-            goto ErrExit;
-        }
-
-        // Second, check for PropPut
-        VariantClear(&vCustomData);
-        hr = pITI2->GetFuncCustData(index, GUID_PropPutCA, &vCustomData);
-        IfFailGo(hr);
-        if (V_VT(&vCustomData) != VT_EMPTY)
-        {
-            *ikind = INVOKE_PROPERTYPUT;
-            found = TRUE;
-            goto ErrExit;
-        }
-    }
-
-ErrExit:
-    VariantClear(&vCustomData);
-
-    if (pITI2)
-        pITI2->Release();
-
-    if (found)
-        return S_OK;
-
-    return S_FALSE;
-}
-
-//*****************************************************************************
-// Generate an event with an add and remove method 
-//*****************************************************************************
-HRESULT CImportTlb::_GenerateEvent(
-    ITypeInfo   *pITI,                  // Containing TypeInfo.
-    MemberInfo  *pMember,               // Info for the function
-    BOOL        fInheritsIEnum)
-{
-    HRESULT             hr = S_OK;      // A result.
-    mdMethodDef         mdAdd;          // Token of add_XXX method.
-    mdMethodDef         mdRemove;       // Token of remove_XXX method.
-    CQuickArray<WCHAR>  qbName;         // Buffer for decorated name.
-    CQuickArray<BYTE>   qbSig;          // The signature.
-    ULONG               cb;             // Size of an element.
-    ULONG               cbTotal = 0;    // Size of the signature.
-    mdTypeDef           tdDelegate;     // The delegate type def.
-    mdEvent             tkEvent;        // The token for the event.
-
-    // If this method is a property method, then skip the event.
-    // Also look at the property semantic - it might be we couldn't import this as a property
-    //  and fell back to a method.
-    if ((pMember->m_psFunc->invkind != INVOKE_FUNC) && (pMember->m_msSemantics != 0))
-    {
-        ReportEvent(NOTIF_CONVERTWARNING, TLBX_W_NO_PROPS_IN_EVENTS, m_szName);
-        return S_CONVERSION_LOSS;
-    }
-
-    // Generate the delegate.
-    IfFailGo(_GenerateEventDelegate(pITI, pMember, &tdDelegate, fInheritsIEnum));
-
-    // Generate the sig for the add and remove methods.
-    IfFailGo(qbSig.ReSizeNoThrow(CB_MAX_ELEMENT_TYPE * 2 + 1));
-    cbTotal = CorSigCompressData((ULONG)IMAGE_CEE_CS_CALLCONV_DEFAULT | IMAGE_CEE_CS_CALLCONV_HASTHIS, qbSig.Ptr());
-    cb = CorSigCompressData(1, &(qbSig[cbTotal]));
-    cbTotal += cb;
-    cb = CorSigCompressData(ELEMENT_TYPE_VOID, &qbSig[cbTotal]);
-    cbTotal += cb;
-    cb = CorSigCompressData(ELEMENT_TYPE_CLASS, &qbSig[cbTotal]);
-    cbTotal += cb;
-    cb = CorSigCompressToken(tdDelegate, &qbSig[cbTotal]);
-    cbTotal += cb;
-
-    // Generate the add method.
-    IfFailGo(qbName.ReSizeNoThrow(EVENT_ADD_METH_PREFIX_LENGTH + wcslen(pMember->m_pName) + 1));
-    StringCchPrintf(qbName.Ptr(), qbName.Size(), W("%s%s"), EVENT_ADD_METH_PREFIX, pMember->m_pName);   
-    IfFailGo(m_pEmit->DefineMethod(m_tdTypeDef, qbName.Ptr(), DEFAULT_INTERFACE_FUNC_FLAGS, 
-        qbSig.Ptr(), cbTotal, 0 /* rva*/, DEFAULT_ITF_FUNC_IMPL_FLAGS, &mdAdd));
-
-    // Generate the remove method.
-    IfFailGo(qbName.ReSizeNoThrow(EVENT_REM_METH_PREFIX_LENGTH + wcslen(pMember->m_pName) + 1));
-    StringCchPrintf(qbName.Ptr(), qbName.Size(), W("%s%s"), EVENT_REM_METH_PREFIX, pMember->m_pName);   
-    IfFailGo(m_pEmit->DefineMethod(m_tdTypeDef, qbName.Ptr(), DEFAULT_INTERFACE_FUNC_FLAGS, 
-        qbSig.Ptr(), cbTotal, 0 /* rva*/, DEFAULT_ITF_FUNC_IMPL_FLAGS, &mdRemove));
-
-    // Define the event itself.
-    IfFailGo(m_pEmit->DefineEvent(m_tdTypeDef, pMember->m_pName, 0, tdDelegate, 
-        mdAdd, mdRemove, mdTokenNil, NULL, &tkEvent));
-
-ErrExit:
-
-    return (hr);
-} // HRESULT CImportTlb::_GenerateEvent()
-
-//*****************************************************************************
-// Generate an add and remove method 
-//*****************************************************************************
-HRESULT CImportTlb::_GenerateEventDelegate(
-    ITypeInfo   *pITI,                  // Containing TypeInfo.
-    MemberInfo  *pMember,               // Info for the source interface func
-    mdTypeDef   *ptd,                   // The output typedef.
-    BOOL        fInheritsIEnum)
-{
-    HRESULT             hr = S_OK;                  // A result.
-    BSTR                bstrSrcItfName = NULL;      // The name of the source interface.
-    CQuickArray<WCHAR>  qbEventHandlerName;         // The name of the event handler.
-    BSTR                szOldName = NULL;           // The old value m_tdTypeDef.
-    mdTypeDef           tdOldTypeDef = NULL;        // The old value m_szName.
-    CQuickArray<BYTE>   qbSig;                      // The signature.
-    ULONG               cb;                         // Size of an element.
-    ULONG               cbTotal = 0;                // Total size of signature.
-    mdMethodDef         mdFunc;                     // The defined function.
-    mdTypeRef           trMulticastDelegate;        // The type ref for System.MulticastDelegate.
-    mdToken             tkAttr;                     // Custom attribute type.
-
-    // Store the old values of the ITypeInfo name and of the current type def.
-    szOldName = m_szName;
-    tdOldTypeDef = m_tdTypeDef;
-    m_szName = NULL;
-
-    // Retrieve the full name of the source interface.
-    IfFailGo(GetManagedNameForTypeInfo(pITI, m_wzNamespace, NULL, &bstrSrcItfName));
-
-    // Generate a unique name for the event handler which will be of the form:
-    //     <SrcItfName>_<MethodName>_EventHandler<PotentialSuffix>
-    IfFailGo(qbEventHandlerName.ReSizeNoThrow(wcslen(bstrSrcItfName) + wcslen(pMember->m_pName) + EVENT_HANDLER_SUFFIX_LENGTH + 6));
-    StringCchPrintf(qbEventHandlerName.Ptr(), qbEventHandlerName.Size(), W("%s_%s%s"), bstrSrcItfName, pMember->m_pName, EVENT_HANDLER_SUFFIX);
-    IfFailGo(GenerateUniqueTypeName(qbEventHandlerName));
-
-    // Set the information on the current type.
-    IfNullGo(m_szName = SysAllocString(qbEventHandlerName.Ptr()));
-
-    // Retrieve the parent type ref.
-    IfFailGo(GetKnownTypeToken(VT_SLOT_FOR_MULTICASTDEL, &trMulticastDelegate));
-
-    // Create the typedef for the event interface.
-    IfFailGo(m_pEmit->DefineTypeDef(m_szName, tdPublic | tdSealed, trMulticastDelegate, NULL, &m_tdTypeDef));
-
-     // Hide the interface from Object Browsers (EventHandler)
-     _SetHiddenCA(m_tdTypeDef);
-
-    // Make the interface ComVisible(false).
-    {
-        DECLARE_CUSTOM_ATTRIBUTE(sizeof(BYTE));
-        BUILD_CUSTOM_ATTRIBUTE(BYTE, FALSE);
-        IfFailGo(GetAttrType(ATTR_COMVISIBLE, &tkAttr));
-        FINISH_CUSTOM_ATTRIBUTE();
-        IfFailGo(m_pEmit->DefineCustomAttribute(m_tdTypeDef, tkAttr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(), 0));
-    }
-
-    // Generate the sig for the constructor.
-    IfFailGo(qbSig.ReSizeNoThrow(CB_MAX_ELEMENT_TYPE * 2 + 1));
-    cbTotal = CorSigCompressData((ULONG)IMAGE_CEE_CS_CALLCONV_DEFAULT | IMAGE_CEE_CS_CALLCONV_HASTHIS, qbSig.Ptr());
-    cb = CorSigCompressData(2, &(qbSig[cbTotal]));
-    cbTotal += cb;
-    cb = CorSigCompressData(ELEMENT_TYPE_VOID, &qbSig[cbTotal]);
-    cbTotal += cb;
-    cb = CorSigCompressData(ELEMENT_TYPE_OBJECT, &qbSig[cbTotal]);
-    cbTotal += cb;
-    cb = CorSigCompressData(ELEMENT_TYPE_U, &qbSig[cbTotal]);
-    cbTotal += cb;
-
-    // Generate the constructor.
-    IfFailGo(m_pEmit->DefineMethod(m_tdTypeDef, OBJECT_INITIALIZER_NAME, OBJECT_INITIALIZER_FLAGS, 
-        qbSig.Ptr(), cbTotal, 0 /* rva*/, miRuntime, &mdFunc));
-    
-    // Generate the invoke method.
-    BOOL bAllowIEnum = !fInheritsIEnum;
-    IfFailGo(_ConvFunction(pITI, pMember, FALSE, FALSE, TRUE, &bAllowIEnum));
-
-    // Set the output typedef.
-    *ptd = m_tdTypeDef;
-
-ErrExit:
-    if (m_szName)
-        ::SysFreeString(m_szName);
-    if (m_szMember)
-        ::SysFreeString(m_szMember); m_szMember=0;
-    if (bstrSrcItfName)
-        ::SysFreeString(bstrSrcItfName);
-
-    // Restore the initial values for the ITypeInfo name and the type def.
-    m_szName = szOldName;
-    m_tdTypeDef = tdOldTypeDef;
-
-    return (hr);
-} // HRESULT CImportTlb::_GenerateEventDelegate()
-
-//*****************************************************************************
-//*****************************************************************************
-struct MDTOKENHASH : HASHLINK
-{
-    mdToken tkKey;
-    mdToken tkData;
-}; // struct MDTOKENHASH : HASHLINK
-
-class CTokenHash : public CChainedHash<MDTOKENHASH>
-{
-public:
-    virtual bool InUse(MDTOKENHASH *pItem)
-    { return (pItem->tkKey != NULL); }
-
-    virtual void SetFree(MDTOKENHASH *pItem)
-    { 
-        pItem->tkKey = NULL; 
-        pItem->tkKey = NULL; 
-    }
-
-    virtual ULONG Hash(const void *pData)
-    { 
-        // Do case-insensitive hash
-        return (ULONG)(ULONG_PTR)pData; 
-    }
-
-    virtual int Cmp(const void *pData, void *pItem){
-        return (mdToken)(ULONG_PTR)pData != reinterpret_cast<MDTOKENHASH*>(pItem)->tkKey;
-    }
-}; // CTokenHash : public CChainedHash<MDTOKENHASH>
-
-//*****************************************************************************
-// Copy methods and events from a source interface to a class that sources the
-//  given interface.
-//*****************************************************************************
-HRESULT CImportTlb::_AddSrcItfMembersToClass(   // S_OK or error.
-    mdTypeRef   trSrcItf)                       // Typeref of the source interface.
-{
-    HRESULT             hr=S_OK;                // A result.
-    ULONG               i;                      // Generic counter.
-    HCORENUM            MemberEnum = NULL;      // The enum of members.
-    ULONG               cMembers = 0;           // Temp count of members.
-    mdTypeDef           tdSrcItf;               // A type def to the interface.
-    mdEvent             tkItfEvent;             // The token of the interface event.
-    mdEvent             tkClassEvent;           // The token of the class event.
-    mdToken             tkEventType;            // The event type.
-    mdMethodDef         mdItfMethod;            // The method def of the interface method.
-    mdMethodDef         mdAddMethod;            // The add method.
-    mdMethodDef         mdRemoveMethod;         // The remove method.
-    mdMethodDef         mdFireMethod;           // The fire method.
-    mdMethodDef         mdClassMethod;          // The method def of the class method.
-    CQuickArray<mdMethodDef>  qbOtherMethods;   // The other methods for the property.
-    ULONG               cchOtherMethods;        // The cound of other methods.
-    CQuickArray<WCHAR>  qbMemberName;           // Name of the member.
-    CQuickArray<WCHAR>  qbEventItfFullName;     // Full name of the event interface.
-    CQuickArray<WCHAR>  qbEventItfName;         // Name of the event interface.
-    ULONG               cchName;                // Length of a name, in wide chars.
-    ULONG               ItfMemberAttr;          // The attributes of the interface member.
-    ULONG               ItfMemberImplFlags;     // The impl flags of the interface member.               
-    PCCOR_SIGNATURE     ItfMemberSig;           // The signature of the interface member.
-    ULONG               ItfMemberSigSize;       // The size of the member signature.
-    mdMemberRef         mrItfMember;            // A member ref to the interface member def.
-    BSTR                bstrSrcItfName = NULL;  // The name of the CoClass.
-    mdAssemblyRef       ar;                     // The assembly ref.
-    CTokenHash          ItfMDToClassMDMap;      // The interface MD to class MD map.
-    MDTOKENHASH *       pItem;                  // An item in the token hashtable.
-
-    // Retrieve the name of the event interface.
-    do {
-        IfFailGo(m_pImport->GetTypeRefProps(
-            trSrcItf, 
-            &ar, 
-            qbEventItfFullName.Ptr(), 
-            (ULONG)qbEventItfFullName.MaxSize(), 
-            &cchName));
-        if (hr == CLDB_S_TRUNCATION)
-        {
-            IfFailGo(qbEventItfFullName.ReSizeNoThrow(cchName));
-            continue;
-        }
-        break;
-    } while (1);
-    IfFailGo(qbEventItfName.ReSizeNoThrow(cchName));
-    ns::SplitPath(qbEventItfFullName.Ptr(), NULL, 0, qbEventItfName.Ptr(), (int)qbEventItfName.Size());
-
-    // Resolve the typeref to a typedef.
-    IfFailGo(m_pImport->FindTypeDefByName(qbEventItfFullName.Ptr(), mdTokenNil, &tdSrcItf));
-
-    // Define methods and method impl's for all the methods in the interface.
-    while ((hr = m_pImport->EnumMethods(&MemberEnum, tdSrcItf, &mdItfMethod, 1, &cMembers)) == S_OK)
-    {
-        // Retrieve the method properties.
-        do {
-            IfFailGo(m_pImport->GetMethodProps(
-                mdItfMethod,
-                NULL,
-                qbMemberName.Ptr(),
-                (ULONG)qbMemberName.MaxSize(),
-                &cchName,
-                &ItfMemberAttr,
-                &ItfMemberSig,
-                &ItfMemberSigSize,
-                NULL,
-                &ItfMemberImplFlags));
-            if (hr == CLDB_S_TRUNCATION)
-            {
-                IfFailGo(qbMemberName.ReSizeNoThrow(cchName));
-                continue;
-            }
-            break;
-        } while (1);
-
-        // Define a member ref on the class to the interface member def.
-        IfFailGo(m_pEmit->DefineMemberRef(trSrcItf, qbMemberName.Ptr(), ItfMemberSig, ItfMemberSigSize, &mrItfMember));
-
-        // Generate a unique name for the class member.
-        IfFailGo(GenerateUniqueMemberName(qbMemberName, NULL, 0, qbEventItfName.Ptr(), mdtMethodDef));
-
-        // Define a member on the class.
-        IfFailGo(m_pEmit->DefineMethod(m_tdTypeDef, qbMemberName.Ptr(), ItfMemberAttr & ~mdAbstract,
-            ItfMemberSig, ItfMemberSigSize, 0/*rva*/, ItfMemberImplFlags, &mdClassMethod));
-
-        // Define a method impl.
-        IfFailGo(m_pEmit->DefineMethodImpl(m_tdTypeDef, mdClassMethod, mrItfMember));
-
-        // Add the interface member to the map.
-        if ((pItem = ItfMDToClassMDMap.Add((const void *)(ULONG_PTR)mdItfMethod)) == NULL)
-            IfFailGo(E_FAIL);
-        PREFIX_ASSUME(pItem != NULL);
-        pItem->tkKey = mdItfMethod;
-        pItem->tkData = mdClassMethod;
-    }
-    IfFailGo(hr);
-
-    m_pImport->CloseEnum(MemberEnum);
-    MemberEnum = NULL;
-
-    // Define all the events in the interface on the class.
-    while ((hr = m_pImport->EnumEvents(&MemberEnum, tdSrcItf, &tkItfEvent, 1, &cMembers)) == S_OK)
-    {
-        // Retrieve the properties of the property.
-        do {
-            IfFailGo(m_pImport->GetEventProps(
-                tkItfEvent,
-                NULL,               
-                qbMemberName.Ptr(),    
-                (ULONG)qbMemberName.MaxSize(),
-                &cchName,         
-                &ItfMemberAttr,   
-                &tkEventType,    
-                &mdAddMethod,
-                &mdRemoveMethod,
-                &mdFireMethod,
-                qbOtherMethods.Ptr(),
-                (ULONG)qbOtherMethods.MaxSize(),
-                &cchOtherMethods));
-            if (hr == CLDB_S_TRUNCATION)
-            {
-                IfFailGo(qbMemberName.ReSizeNoThrow(cchName));
-                IfFailGo(qbOtherMethods.ReSizeNoThrow(cchOtherMethods));
-                continue;
-            }
-            break;
-        } while (1);
-
-        // NULL terminate the array of other methods.
-        IfFailGo(qbOtherMethods.ReSizeNoThrow(cchOtherMethods + 1));
-        qbOtherMethods[cchOtherMethods] = NULL;
-
-        // Replace all the interface method def's with the equivalent class method def's.
-        if (!IsNilToken(mdAddMethod))
-        {
-            pItem = ItfMDToClassMDMap.Find((const void *)(ULONG_PTR)mdAddMethod);
-            _ASSERTE(pItem);
-            mdAddMethod = pItem->tkData;
-        }
-        if (!IsNilToken(mdRemoveMethod))
-        {
-            pItem = ItfMDToClassMDMap.Find((const void *)(ULONG_PTR)mdRemoveMethod);
-            _ASSERTE(pItem);
-            mdRemoveMethod = pItem->tkData;
-        }
-        _ASSERTE(IsNilToken(mdFireMethod));
-        _ASSERTE(cchOtherMethods == 0);
-
-        // Generate a unique name for the event.
-        IfFailGo(GenerateUniqueMemberName(qbMemberName, NULL, 0, qbEventItfName.Ptr(), mdtEvent));
-
-        // Define property on the class.
-        IfFailGo(m_pEmit->DefineEvent(m_tdTypeDef, qbMemberName.Ptr(), ItfMemberAttr,
-            tkEventType, mdAddMethod, mdRemoveMethod, mdFireMethod, qbOtherMethods.Ptr(), &tkClassEvent));
-    }
-    IfFailGo(hr);   
-
-    m_pImport->CloseEnum(MemberEnum);
-    MemberEnum = NULL;
-
-ErrExit:
-    if (MemberEnum)
-        m_pImport->CloseEnum(MemberEnum);
-    if (bstrSrcItfName)
-        ::SysFreeString(bstrSrcItfName);
-
-    return hr;
-
-#undef ITF_MEMBER_SIG
-#undef ITF_MEMBER_SIG_SIZE
-} // HRESULT CImportTlb::_AddSrcItfMembersToClass()
-
-//*****************************************************************************
-// Compare the two signatures ignoring the return type. If the signatures
-// match then TRUE will be returned, FALSE will be returned otherwise.
-// This method assumes the two signatures are in the same scope.
-//*****************************************************************************
-HRESULT CImportTlb::CompareSigsIgnoringRetType(
-    PCCOR_SIGNATURE pbSig1,           // The 1st method signature.
-    ULONG           cbSig1,           // Size of the 1st method signature.
-    PCCOR_SIGNATURE pbSig2,           // The 2nd method signature.
-    ULONG           cbSig2)           // Size of the 2nd method signature.
-{
-    HRESULT             hr = S_OK;
-    PCCOR_SIGNATURE     pbSig1Start;  
-    PCCOR_SIGNATURE     pbSig2Start;  
-    ULONG               Sig1ParamCount;
-    ULONG               Sig2ParamCount;
-    ULONG               cbSig1RetType;
-    ULONG               cbSig2RetType;
-
-    // Save the start of the signatures.
-    pbSig1Start = pbSig1;  
-    pbSig2Start = pbSig2;  
-
-    // Skip the calling conventions.
-    CorSigUncompressData(pbSig1);
-    CorSigUncompressData(pbSig2);
-
-    // Compare the param count.
-    Sig1ParamCount = CorSigUncompressData(pbSig1);
-    Sig2ParamCount = CorSigUncompressData(pbSig2);
-    if (Sig1ParamCount != Sig2ParamCount)
-        return S_FALSE;
-
-    // Skip the return type.
-    cbSig1RetType = cbSig1 - (ULONG)(pbSig1 - pbSig1Start);
-    IfFailGo(_CountBytesOfOneArg(pbSig1, &cbSig1RetType));
-    pbSig1 += cbSig1RetType;
-    cbSig2RetType = cbSig2 - (ULONG)(pbSig2 - pbSig2Start);
-    IfFailGo(_CountBytesOfOneArg(pbSig2, &cbSig2RetType));
-    pbSig2 += cbSig2RetType;
-
-    // Update the remaining sig sizes.
-    cbSig1 -= (ULONG) (pbSig1 - pbSig1Start);
-    cbSig2 -= (ULONG) (pbSig2 - pbSig2Start);
-
-    // If the remaining sig sizes are different then the sigs don't match.
-    if (cbSig1 != cbSig2)
-        return S_FALSE;
-
-    // Compare the rest of the sigs using memcmp.
-    if (memcmp(pbSig1, pbSig2, cbSig1) != 0)
-        return S_FALSE;
-
-    // The parameters match.
-    return S_OK;
-
-ErrExit:
-    // An error occurred.
-    return hr;
-} // HRESULT CImportTlb::CompareSigsIgnoringRetType()
-
-//*****************************************************************************
-// Look up a method in the emit scope. This lookup method does not take the
-// return type into account when comparing using a sig. So 2 methods with 
-// the same name, same parameters and a different return type will be 
-// considered the same.
-//*****************************************************************************
-HRESULT CImportTlb::FindMethod(         // S_OK or CLDB_E_RECORD_NOTFOUND, or error.
-    mdTypeDef   td,                     // The method typedef.
-    LPCWSTR     szName,                 // The method name.
-    PCCOR_SIGNATURE pbReqSig,              // The method signature.
-    ULONG       cbReqSig,               // Size of the method signature.
-    mdMethodDef *pmb)                   // Put the method here.
-{
-    HRESULT             hr = S_OK;          // A result.
-    PCCOR_SIGNATURE     pbFoundSig = NULL;  
-    ULONG               cbFoundSig = 0;
-    ULONG               MethodAttr;             
-    ULONG               MethodImplFlags;     
-    mdMethodDef         md;
-    CQuickArray<WCHAR>  qbMethodName;
-    HCORENUM            MethodEnum = NULL;
-    ULONG               cMethods = 0;
-    ULONG               cchName;
-    BOOL                bMethodFound = FALSE;
-
-    // Go through all the methods on the class looking for one with the
-    // same name and same parameters.
-    while ((hr = m_pImport->EnumMethods(&MethodEnum, td, &md, 1, &cMethods)) == S_OK)
-    {
-        // Retrieve the method properties.
-        do {
-            IfFailGo(m_pImport->GetMethodProps(
-                md,
-                NULL,
-                qbMethodName.Ptr(),
-                (ULONG)qbMethodName.MaxSize(),
-                &cchName,
-                &MethodAttr,
-                &pbFoundSig,
-                &cbFoundSig,
-                NULL,
-                &MethodImplFlags));
-            if (hr == CLDB_S_TRUNCATION)
-            {
-                IfFailGo(qbMethodName.ReSizeNoThrow(cchName));
-                continue;
-            }
-            break;
-        } while (1);
-
-        // Compare the name of the method.
-        if (wcscmp(szName, qbMethodName.Ptr()) != 0)
-            continue;
-
-        // If the signature of the requested method is specified, then compare
-        // the signature against the signature of the found method ignoring
-        // the return type.
-        if (pbReqSig)
-        {
-            IfFailGo(hr = CompareSigsIgnoringRetType(pbReqSig, cbReqSig, pbFoundSig, cbFoundSig));
-            if (hr == S_FALSE)
-                continue;           
-        }
-
-    // We have found the member.
-        bMethodFound = TRUE;
-        break;
-    }
-    IfFailGo(hr);
-
-ErrExit:
-    if (MethodEnum)
-        m_pImport->CloseEnum(MethodEnum);
-
-    return bMethodFound ? S_OK : CLDB_E_RECORD_NOTFOUND;
-}
-
-//*****************************************************************************
-// Look up a property in the emit scope.
-//*****************************************************************************
-HRESULT CImportTlb::FindProperty(      // S_OK or CLDB_E_RECORD_NOTFOUND, or error.
-    mdTypeDef   td,                     // The property typedef.
-    LPCWSTR     szName,                 // The property name.
-    PCCOR_SIGNATURE pbSig,                 // The property signature.
-    ULONG       cbSig,                  // Size of the property signature.
-    mdProperty  *ppr)                   // Put the property here.
-{
-    HRESULT     hr;                     // A result.
-    RegMeta     *pRegMeta = (RegMeta*)(m_pEmit);
-    LPUTF8      szNameAnsi;
-
-    if (szName == NULL)
-    {
-        return CLDB_E_RECORD_NOTFOUND;
-    }
-    UTF8STR(szName, szNameAnsi);
-
-    hr = ImportHelper::FindProperty(
-             &(pRegMeta->GetMiniStgdb()->m_MiniMd), 
-             m_tdTypeDef, 
-             szNameAnsi, 
-             pbSig, 
-             cbSig, 
-             ppr);
-    return hr;
-} // HRESULT CImportTlb::FindProperty()
-
-//*****************************************************************************
-// Look up a event in the emit scope.
-//*****************************************************************************
-HRESULT CImportTlb::FindEvent(          // S_OK or CLDB_E_RECORD_NOTFOUND, or error.
-    mdTypeDef   td,                     // The event typedef.
-    LPCWSTR     szName,                 // The event name.
-    mdEvent     *pev)                   // Put the event here.
-{
-    HRESULT     hr;                     // A result.
-    RegMeta     *pRegMeta = (RegMeta*)(m_pEmit);
-    LPUTF8      szNameAnsi;
-
-    if (szName == NULL)
-    {
-        return CLDB_E_RECORD_NOTFOUND;
-    }
-    UTF8STR(szName, szNameAnsi);
-
-    hr = ImportHelper::FindEvent(
-             &(pRegMeta->GetMiniStgdb()->m_MiniMd), 
-             m_tdTypeDef, 
-             szNameAnsi, 
-             pev);
-    return hr;
-} // HRESULT CImportTlb::FindEvent()
-
-//*****************************************************************************
-// Checks to see if the specified TYPEDESC is an alias.
-//*****************************************************************************
-HRESULT CImportTlb::_IsAlias(
-    ITypeInfo   *pITI,                  // The ITypeInfo containing the TYPEDESC.
-    TYPEDESC    *pTypeDesc)             // The token of the param, field, etc.
-{
-    HRESULT     hr = S_FALSE;           // A result.
-    ITypeInfo   *pTypeITI=0;            // The ITypeInfo of the type.
-    ITypeLib    *pTypeTLB=0;            // The TLB that contains the type.
-    TYPEATTR    *psTypeAttr=0;          // TYPEATTR of the type.
-
-    // Drill down to the actual type that is pointed to.
-    while (pTypeDesc->vt == VT_PTR)
-        pTypeDesc = pTypeDesc->lptdesc;
-
-    // If the parameter is an alias then we need to add a custom attribute to the 
-    // parameter that describes the alias.
-    if (pTypeDesc->vt == VT_USERDEFINED)
-    {
-        IfFailGo(pITI->GetRefTypeInfo(pTypeDesc->hreftype, &pTypeITI));
-        IfFailGo(pTypeITI->GetTypeAttr(&psTypeAttr));
-        if (psTypeAttr->typekind == TKIND_ALIAS)
-        {
-            hr = S_OK;
-        }
-    }
-
-ErrExit:
-    if (psTypeAttr)
-        pTypeITI->ReleaseTypeAttr(psTypeAttr);
-    if (pTypeITI)
-        pTypeITI->Release();
-    return hr;
-} // HRESULT CImportTlb::_IsAlias()
-
-//*****************************************************************************
-// Add alias information if the TYPEDESC represents an alias.
-//*****************************************************************************
-HRESULT CImportTlb::_HandleAliasInfo(
-    ITypeInfo   *pITI,                  // The ITypeInfo containing the TYPEDESC.
-    TYPEDESC    *pTypeDesc,             // The TYPEDESC.
-    mdToken     tk)                     // The token of the param, field, etc.
-{
-    HRESULT     hr = S_OK;              // A result.
-    ITypeInfo   *pTypeITI=0;            // The ITypeInfo of the type.
-    ITypeLib    *pTypeTLB=0;            // The TLB that contains the type.
-    TYPEATTR    *psTypeAttr=0;          // TYPEATTR of the type.
-    BSTR        bstrAliasTypeName=0;    // The name of the alias type.
-    BSTR        bstrAliasTypeLibName=0; // The name of the typelib that contains the alias type.
-
-    // Drill down to the actual type that is pointed to.
-    while (pTypeDesc->vt == VT_PTR)
-        pTypeDesc = pTypeDesc->lptdesc;
-
-    // If the parameter is an alias then we need to add a custom attribute to the 
-    // parameter that describes the alias.
-    if (pTypeDesc->vt == VT_USERDEFINED)
-    {
-        IfFailGo(pITI->GetRefTypeInfo(pTypeDesc->hreftype, &pTypeITI));
-        IfFailGo(pTypeITI->GetTypeAttr(&psTypeAttr));
-        if (psTypeAttr->typekind == TKIND_ALIAS)
-        {
-            // Retrieve the name of the alias type.
-            IfFailGo(pTypeITI->GetContainingTypeLib(&pTypeTLB, NULL));
-            IfFailGo(GetNamespaceOfRefTlb(pTypeTLB, &bstrAliasTypeLibName, NULL));
-            IfFailGo(GetManagedNameForTypeInfo(pTypeITI, bstrAliasTypeLibName, NULL, &bstrAliasTypeName));
-
-            // Add the ComAliasName CA to the parameter.
-            _AddStringCa(ATTR_COMALIASNAME, tk, bstrAliasTypeName);
-        }
-    }
-
-ErrExit:
-    if (psTypeAttr)
-        pTypeITI->ReleaseTypeAttr(psTypeAttr);
-    if (pTypeITI)
-        pTypeITI->Release();
-    if (pTypeTLB)
-        pTypeTLB->Release();
-    if (bstrAliasTypeLibName)
-        ::SysFreeString(bstrAliasTypeLibName);   
-    if (bstrAliasTypeName)
-        ::SysFreeString(bstrAliasTypeName);
-    return hr;
-} // HRESULT CImportTlb::_HandleAliasInfo()
-
-//*****************************************************************************
-// Convert one of a function's parameters.
-//*****************************************************************************
-HRESULT CImportTlb::_ConvParam(
-    ITypeInfo   *pITI,                  // Containing TypeInfo.
-    mdMethodDef mdFunc,                 // Owning member.
-    int         iSequence,              // Parameter sequence.
-    const ELEMDESC *pdesc,              // Param flags, default value.
-    ParamOpts   paramOpts,              // Is param normal, optional, or vararg?
-    LPCWSTR     szName,                 // Name of the parameter.
-    BYTE        *pbNative,              // Native type info, if any.
-    ULONG       cbNative)               // Size of native type info.
-{
-    HRESULT     hr;                     // A result.
-    mdParamDef  pdParam;                // Token of the parameter.
-    DWORD       dwFlags;                // Param flags.
-    USHORT      Sequence = static_cast<USHORT>(iSequence);
-    BYTE        cvType  = ELEMENT_TYPE_VOID; // ELEMENT_TYPE_* flag for constant value
-    void        *pcvValue=0;            // constant value blob
-    __int64     d;                      // For cases where value is a date.
-    int         bDecimal=0;             // If true, constant is a decimal.
-    mdToken     tkAttr;                 // For custom attribute token.
-    DECIMAL     decVal;                 // Decimal constant value.
-
-    // Compute the flags.  Only make sense on non-return params.
-    dwFlags = 0;
-    if (iSequence > 0)
-    {
-        if (pdesc->paramdesc.wParamFlags & PARAMFLAG_FIN)
-            dwFlags |= pdIn;
-        if (pdesc->paramdesc.wParamFlags & PARAMFLAG_FOUT)
-            dwFlags |= pdOut;
-        if (pdesc->paramdesc.wParamFlags & PARAMFLAG_FOPT)
-            dwFlags |= pdOptional;
-        if (paramOpts == ParamOptional)
-            dwFlags |= pdOptional;
-    }
-
-    // Get any default values.  Return type, param with iSequence==0, has no default.
-    if (pdesc->paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT && iSequence != 0)
-    {
-        switch (pdesc->paramdesc.pparamdescex->varDefaultValue.vt)
-        {
-        case VT_CY:
-        case VT_DECIMAL:
-        case VT_DATE:
-        case VT_UNKNOWN:
-        case VT_DISPATCH:
-            break;
-        default:
-            // This workaround is because a typelib can store anything that can convert to VT_I4 with a value of 0
-            //  for the default value of an interface pointer.  But, a VT_I2(0) confuses the consumers
-            //  of the managed wrapper dll.  So, if it is an interface on the unmanaged side, make
-            //  the constant value an ET_CLASS.
-            if (cbNative > 0 && (*pbNative == NATIVE_TYPE_INTF ||
-                                 *pbNative == NATIVE_TYPE_IUNKNOWN ||
-                                 *pbNative == NATIVE_TYPE_IDISPATCH))
-        {
-                cvType = ELEMENT_TYPE_CLASS;
-                pcvValue = 0;
-        }
-        else
-            IfFailGo( _UnpackVariantToConstantBlob(&pdesc->paramdesc.pparamdescex->varDefaultValue, &cvType, &pcvValue, &d) );
-        }
-    }
-
-    // Create the param definition.
-    IfFailGo(m_pEmit->DefineParam(mdFunc, iSequence, szName, dwFlags, cvType, pcvValue, -1, &pdParam));
-
-    // Add the native type if it there is any.
-    if (cbNative > 0)
-        IfFailGo(m_pEmit->SetFieldMarshal(pdParam, (PCCOR_SIGNATURE) pbNative, cbNative));
-
-    if (pdesc->paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT && iSequence != 0)
-    {
-        switch (pdesc->paramdesc.pparamdescex->varDefaultValue.vt)
-        {
-        case VT_CY:
-            IfFailGo(VarDecFromCy(pdesc->paramdesc.pparamdescex->varDefaultValue.cyVal, &decVal));
-            IfFailGo(DecimalCanonicalize(&decVal));
-            goto StoreDecimal;
-        case VT_DECIMAL:
-            // If there is a decimal constant value, set it as a custom attribute.
-            {
-            decVal = pdesc->paramdesc.pparamdescex->varDefaultValue.decVal;
-        StoreDecimal:
-            DECLARE_CUSTOM_ATTRIBUTE(sizeof(BYTE)+sizeof(BYTE)+sizeof(UINT)+sizeof(UINT)+sizeof(UINT));
-            BUILD_CUSTOM_ATTRIBUTE(BYTE, decVal.scale);
-            BUILD_CUSTOM_ATTRIBUTE(BYTE, decVal.sign);
-            BUILD_CUSTOM_ATTRIBUTE(UINT, decVal.Hi32);
-            BUILD_CUSTOM_ATTRIBUTE(UINT, decVal.Mid32);
-            BUILD_CUSTOM_ATTRIBUTE(UINT, decVal.Lo32);
-            IfFailGo(GetAttrType(ATTR_DECIMALVALUE, &tkAttr));
-            FINISH_CUSTOM_ATTRIBUTE();
-            IfFailGo(m_pEmit->DefineCustomAttribute(pdParam, tkAttr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(),0));
-            }
-            break;
-        case VT_DATE:
-            {
-            DECLARE_CUSTOM_ATTRIBUTE(sizeof(__int64));
-            __int64 date = _DoubleDateToTicks(pdesc->paramdesc.pparamdescex->varDefaultValue.date);
-            BUILD_CUSTOM_ATTRIBUTE(__int64, date);
-            IfFailGo(GetAttrType(ATTR_DATETIMEVALUE, &tkAttr));
-            FINISH_CUSTOM_ATTRIBUTE();
-            IfFailGo(m_pEmit->DefineCustomAttribute(pdParam, tkAttr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(),0));
-            }
-            break;
-        case VT_UNKNOWN:
-            {
-            DECLARE_CUSTOM_ATTRIBUTE(0);
-            IfFailGo(GetAttrType(ATTR_IUNKNOWNVALUE, &tkAttr));
-            FINISH_CUSTOM_ATTRIBUTE();
-            IfFailGo(m_pEmit->DefineCustomAttribute(pdParam, tkAttr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(),0));
-            }
-            break;
-        case VT_DISPATCH:
-            {
-            DECLARE_CUSTOM_ATTRIBUTE(0);
-            IfFailGo(GetAttrType(ATTR_IDISPATCHVALUE, &tkAttr));
-            FINISH_CUSTOM_ATTRIBUTE();
-            IfFailGo(m_pEmit->DefineCustomAttribute(pdParam, tkAttr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(),0));
-            }
-            break;
-        default:
-            break;
-        }
-    }
-
-    // Add the alias information if the param is an alias.
-    IfFailGo(_HandleAliasInfo(pITI, (TYPEDESC*)&pdesc->tdesc, pdParam));
-    
-    // If a vararg param, set the custom attribute.
-    if (paramOpts == ParamVarArg)
-    {
-        mdToken     tkAttribute;
-        DECLARE_CUSTOM_ATTRIBUTE(0);
-        FINISH_CUSTOM_ATTRIBUTE();
-        IfFailGo(GetAttrType(ATTR_PARAMARRAY, &tkAttribute));
-        IfFailGo(m_pEmit->DefineCustomAttribute(pdParam, tkAttribute, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(), 0));
-    }
-
-ErrExit:
-    return hr;
-} // HRESULT CImportTlb::_ConvParam()
-
-//*****************************************************************************
-// Convert a constant into a field with a default value.
-//*****************************************************************************
-HRESULT CImportTlb::_ConvConstant(
-    ITypeInfo   *pITI,                  // Containing TypeInfo.
-    VARDESC     *psVar,                 // VARDESC for the property.
-    BOOL        bEnumMember)            // If true, type is containing class.
-{
-    HRESULT     hr;                     // A result.
-    mdFieldDef  mdField;                // Token of the new field.
-    DWORD       dwFlags;                // Member flags.
-    CQuickBytes qbComSig;               // The COM+ Signature of the field.
-    ULONG       cb, cbTotal;
-    BYTE        cvType = ELEMENT_TYPE_VOID; // E_T_Type for constant value
-    void        *pcvValue;              // Pointer to constant value data.
-    mdToken     tkAttr;                 // Type for custom attribute.
-    __int64     d;                      // For cases where value is a date.
-    BOOL        bConversionLoss=false;  // If true, some attributes were lost on conversion.
-    BYTE        *pbSig;                 // Pointer to signature bytes.
-    CQuickArray<BYTE> qbNativeBuf;      // Native type buffer.
-    ULONG       cbNative = 0;           // Size of native type.
-    int         bDecimal = 0;           // If the value is a decimal.
-    DECIMAL     decVal;                 // Decimal constant value.
-
-    // Information about the member.
-    IfFailGo(pITI->GetDocumentation(psVar->memid, &m_szMember, 0,0,0));
-
-    // resize to make room for calling convention and count of argument
-    IfFailGo(qbComSig.ReSizeNoThrow(CB_MAX_ELEMENT_TYPE * 4));
-    pbSig = (BYTE *)qbComSig.Ptr();
-
-    // Compute properties.
-    dwFlags = DEFAULT_CONST_FIELD_FLAGS;
-
-    // Build the signature.
-    cbTotal = cb = CorSigCompressData((ULONG)IMAGE_CEE_CS_CALLCONV_FIELD, pbSig);
-    if (bEnumMember)
-    {
-        cb = CorSigCompressData(ELEMENT_TYPE_VALUETYPE, &pbSig[cbTotal]);
-        cbTotal += cb;
-        cb = CorSigCompressToken(m_tdTypeDef, reinterpret_cast<ULONG*>(&pbSig[cbTotal]));
-        cbTotal += cb;
-    }
-    else
-    {
-        // Use the conversion function to get the signature.
-        ULONG cbSave = cbTotal;
-        IfFailGo(_ConvSignature(pITI, &psVar->elemdescVar.tdesc, SIG_FLAGS_NONE, qbComSig, cbTotal, &cbTotal, qbNativeBuf, 0, &cbNative, FALSE));
-        if (hr == S_CONVERSION_LOSS)
-            bConversionLoss = true;
-        
-        if (psVar->elemdescVar.tdesc.vt == VT_DATE)
-        {
-            // But for dates, convert it as float -- DateTime is reported as R4 in a typelib!
-            cbTotal = cbSave;
-            cb = CorSigCompressData(ELEMENT_TYPE_R4, &pbSig[cbTotal]);
-            cbTotal += cb;
-        }
-    }
-    
-    // Get the default value.
-    switch (psVar->lpvarValue->vt)
-    {
-    case VT_CY:
-    case VT_DECIMAL:
-    case VT_DATE:
-    case VT_UNKNOWN:
-    case VT_DISPATCH:
-        break;
-    default:
-        // This workaround is because a typelib can store anything that can convert to VT_I4 with a value of 0
-        //  for the default value of an interface pointer.  But, a VT_I2(0) confuses the consumers
-        //  of the managed wrapper dll.  So, if it is an interface on the unmanaged side, make
-        //  the constant value an ET_CLASS.
-        BYTE *pbNative = NULL;
-        pbNative = qbNativeBuf.Ptr();
-        if (cbNative > 0 && (*pbNative == NATIVE_TYPE_INTF ||
-                             *pbNative == NATIVE_TYPE_IUNKNOWN ||
-                             *pbNative == NATIVE_TYPE_IDISPATCH))
-        {
-            cvType = ELEMENT_TYPE_CLASS;
-            pcvValue = 0;
-        }
-        else
-            IfFailGo( _UnpackVariantToConstantBlob(psVar->lpvarValue, &cvType, &pcvValue, &d) );
-    }
-
-    // Create the field definition.
-    IfFailGo(m_pEmit->DefineField(m_tdTypeDef, m_szMember, dwFlags, (PCCOR_SIGNATURE)pbSig, cbTotal, 
-        cvType, pcvValue, -1, &mdField));
-
-    switch (psVar->lpvarValue->vt)
-    {
-    case VT_CY:
-        IfFailGo(VarDecFromCy(psVar->lpvarValue->cyVal, &decVal));
-        IfFailGo(DecimalCanonicalize(&decVal));
-        goto StoreDecimal;
-    case VT_DECIMAL:
-        // If there is a decimal constant value, set it as a custom attribute.
-        {
-        decVal = psVar->lpvarValue->decVal;
-    StoreDecimal:
-        DECLARE_CUSTOM_ATTRIBUTE(sizeof(BYTE)+sizeof(BYTE)+sizeof(UINT)+sizeof(UINT)+sizeof(UINT));
-        BUILD_CUSTOM_ATTRIBUTE(BYTE, decVal.scale);
-        BUILD_CUSTOM_ATTRIBUTE(BYTE, decVal.sign);
-        BUILD_CUSTOM_ATTRIBUTE(UINT, decVal.Hi32);
-        BUILD_CUSTOM_ATTRIBUTE(UINT, decVal.Mid32);
-        BUILD_CUSTOM_ATTRIBUTE(UINT, decVal.Lo32);
-        IfFailGo(GetAttrType(ATTR_DECIMALVALUE, &tkAttr));
-        FINISH_CUSTOM_ATTRIBUTE();
-        IfFailGo(m_pEmit->DefineCustomAttribute(mdField, tkAttr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(),0));
-        }
-        break;
-    case VT_DATE:
-        {
-        DECLARE_CUSTOM_ATTRIBUTE(sizeof(__int64));
-        __int64 date = _DoubleDateToTicks(psVar->lpvarValue->date);
-        BUILD_CUSTOM_ATTRIBUTE(__int64, date);
-        IfFailGo(GetAttrType(ATTR_DATETIMEVALUE, &tkAttr));
-        FINISH_CUSTOM_ATTRIBUTE();
-        IfFailGo(m_pEmit->DefineCustomAttribute(mdField, tkAttr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(),0));
-        }
-        break;
-    case VT_UNKNOWN:
-        {
-        DECLARE_CUSTOM_ATTRIBUTE(0);
-        IfFailGo(GetAttrType(ATTR_IUNKNOWNVALUE, &tkAttr));
-        FINISH_CUSTOM_ATTRIBUTE();
-        IfFailGo(m_pEmit->DefineCustomAttribute(mdField, tkAttr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(),0));
-        }
-        break;
-    case VT_DISPATCH:
-        {
-        DECLARE_CUSTOM_ATTRIBUTE(0);
-        IfFailGo(GetAttrType(ATTR_IDISPATCHVALUE, &tkAttr));
-        FINISH_CUSTOM_ATTRIBUTE();
-        IfFailGo(m_pEmit->DefineCustomAttribute(mdField, tkAttr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(),0));
-        }
-        break;
-    default:
-        break;
-    }
-
-    // Save the field flags.
-    if (psVar->wVarFlags)
-    {
-        IfFailGo(GetAttrType(ATTR_TYPELIBVAR, &tkAttr));
-        DECLARE_CUSTOM_ATTRIBUTE(sizeof(WORD));
-        BUILD_CUSTOM_ATTRIBUTE(WORD, psVar->wVarFlags);
-        FINISH_CUSTOM_ATTRIBUTE();
-        IfFailGo(m_pEmit->DefineCustomAttribute(mdField, tkAttr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(),0));
-    }
-
-    // Set up the native description, if any.
-    if (cbNative > 0)
-        IfFailGo(m_pEmit->SetFieldMarshal(mdField, (PCCOR_SIGNATURE) qbNativeBuf.Ptr(), cbNative));
-
-    // Add the alias information if the type is an alias.
-    IfFailGo(_HandleAliasInfo(pITI, &psVar->elemdescVar.tdesc, mdField));
-    
-    if (bConversionLoss)
-    {
-        hr = S_CONVERSION_LOSS;
-        ReportEvent(NOTIF_CONVERTWARNING, TLBX_I_UNCONVERTABLE_FIELD, m_szName, m_szMember);
-    }
-
-ErrExit:
-    if (m_szMember)
-        ::SysFreeString(m_szMember), m_szMember=0;
-    return (hr);
-} // HRESULT CImportTlb::_ConvConstant()
-
-//*****************************************************************************
-// Convert a (record) field into a member.
-//*****************************************************************************
-HRESULT CImportTlb::_ConvField(
-    ITypeInfo   *pITI,                  // Containing TypeInfo.
-    VARDESC     *psVar,                 // VARDESC for the property.
-    mdFieldDef  *pmdField,              // Put field token here.
-    BOOL        bUnion)                 // Convert as a union?
-{
-    HRESULT     hr;                     // A result.
-    DWORD       dwFlags;                // Member flags.
-    CQuickBytes qbComSig;               // The COM+ Signature of the field.
-    ULONG       cb, cbTotal;            // Size of a sig element, signature.
-    BYTE        *pbSig;                 // Pointer to signature bytes.
-    CQuickArray<BYTE> qbNativeBuf;      // Native type buffer.
-    ULONG       cbNative;               // Size of native type.
-    mdToken     tkAttr;                 // CustomAttribute type.
-    BOOL        bConversionLoss=false;  // If true, some attributes were lost on conversion.
-
-    // Information about the member.
-    IfFailGo(pITI->GetDocumentation(psVar->memid, &m_szMember, 0,0,0));
-
-    // Compute properties.
-    dwFlags = DEFAULT_RECORD_FIELD_FLAGS;
-
-    // resize to make room for calling convention and count of argument
-    IfFailGo(qbComSig.ReSizeNoThrow(CB_MAX_ELEMENT_TYPE * 2));
-    pbSig = (BYTE *)qbComSig.Ptr();
-
-    // Build the signature.
-    cbTotal = cb = CorSigCompressData((ULONG)IMAGE_CEE_CS_CALLCONV_FIELD, pbSig);
-    IfFailGo(_ConvSignature(pITI, &psVar->elemdescVar.tdesc, SIG_FIELD, qbComSig, cbTotal, &cbTotal, qbNativeBuf, 0, &cbNative, FALSE));
-    if (hr == S_CONVERSION_LOSS)
-        bConversionLoss = true;
-
-    // Create the field definition.
-    IfFailGo(m_pEmit->DefineField(m_tdTypeDef, m_szMember, dwFlags, (PCCOR_SIGNATURE) qbComSig.Ptr(),cbTotal, 
-        ELEMENT_TYPE_VOID, NULL, -1, pmdField));
-
-    // Save the field flags.
-    if (psVar->wVarFlags)
-    {
-        IfFailGo(GetAttrType(ATTR_TYPELIBVAR, &tkAttr));
-        DECLARE_CUSTOM_ATTRIBUTE(sizeof(WORD));
-        BUILD_CUSTOM_ATTRIBUTE(WORD, psVar->wVarFlags);
-        FINISH_CUSTOM_ATTRIBUTE();
-        IfFailGo(m_pEmit->DefineCustomAttribute(*pmdField, tkAttr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(),0));
-    }
-
-    if (bConversionLoss)
-    {
-        IfFailGo(GetAttrType(ATTR_COMCONVERSIONLOSS, &tkAttr));
-        DECLARE_CUSTOM_ATTRIBUTE(0);
-        FINISH_CUSTOM_ATTRIBUTE();
-        IfFailGo(m_pEmit->DefineCustomAttribute(*pmdField, tkAttr, PTROF_CUSTOM_ATTRIBUTE(),SIZEOF_CUSTOM_ATTRIBUTE(),0));
-    }
-
-    // Set up the native description, if any.
-    if (cbNative > 0)
-        IfFailGo(m_pEmit->SetFieldMarshal(*pmdField, (PCCOR_SIGNATURE) qbNativeBuf.Ptr(), cbNative));
-
-    // Add the alias information if the type is an alias.
-    IfFailGo(_HandleAliasInfo(pITI, &psVar->elemdescVar.tdesc, *pmdField));
-    
-    if (bConversionLoss)
-    {
-        hr = S_CONVERSION_LOSS;
-        ReportEvent(NOTIF_CONVERTWARNING, TLBX_I_UNCONVERTABLE_FIELD, m_szName, m_szMember);
-    }
-
-ErrExit:
-    if (m_szMember)
-        ::SysFreeString(m_szMember), m_szMember=0;
-    return (hr);
-} // HRESULT CImportTlb::_ConvField()
-
-//*****************************************************************************
-// Convert a dispatch property into a pair of get/set functions.
-//*****************************************************************************
-HRESULT CImportTlb::_ConvProperty(
-    ITypeInfo   *pITI,                  // Containing TypeInfo.
-    MemberInfo  *pMember)               // VARDESC for the property.
-{
-    HRESULT     hr;                     // A result.
-    mdMethodDef mdFuncGet;              // A get function.
-    mdMethodDef mdFuncSet;              // A set function.
-    mdProperty  pdProperty;             // Property on the two functions.
-    DWORD       dwFlags;                // Function flags.
-    WCHAR       *pszName=0;             // Decorated name of member.
-    CQuickArray<WCHAR> qbName;          // Buffer for decorated name.
-    CQuickBytes qbComSig;               // com signature buffer
-    ULONG       cb;                     // Size of an element.
-    ULONG       cbTotal = 0;            // Total size of signature.
-    BYTE        *pbSig;                 // Pointer to signature buffer.
-    BOOL        bConversionLoss=false;  // If true, some attributes were lost on conversion.
-    CQuickArray<BYTE> qbNativeBuf;      // Native type buffer.
-    ULONG       iNativeOfs=0;           // Current offset in native type buffer.
-    VARDESC     *psVar = pMember->m_psVar;
-
-    // Check to see if the property is the NewEnum member.
-    if (PropertyIsNewEnum(pITI, psVar, pMember->m_iMember) == S_OK)
-        return _ConvNewEnumProperty(pITI, psVar, pMember);
-
-    // Get the name.
-    IfFailGo(pITI->GetDocumentation(psVar->memid, &m_szMember, 0,0,0));
-
-    // Create the get signature.
-    IfFailGo(qbComSig.ReSizeNoThrow(CB_MAX_ELEMENT_TYPE * 2));
-    pbSig = reinterpret_cast<BYTE*>(qbComSig.Ptr());
-    cbTotal = cb = CorSigCompressData((ULONG)IMAGE_CEE_CS_CALLCONV_DEFAULT | IMAGE_CEE_CS_CALLCONV_HASTHIS, pbSig);
-    // Getter takes zero parameters.
-    cb = CorSigCompressData(0, &(pbSig[cb]));
-    cbTotal += cb;
-    // Getter returns the property type.
-    IfFailGo(_ConvSignature(pITI, &psVar->elemdescVar.tdesc, SIG_ELEM, qbComSig, cbTotal, &cbTotal, qbNativeBuf, 0, &iNativeOfs, FALSE));
-    if (hr == S_CONVERSION_LOSS)
-        bConversionLoss = true;
-
-    // Getter properties.
-    dwFlags = DEFAULT_PROPERTY_FUNC_FLAGS;
-    // If processing an implemented interface, remove the abstract bit.  Methods on classes are not abstract.
-    if (m_ImplIface != eImplIfaceNone)
-        dwFlags &= ~mdAbstract;
-
-    // Get the previously decorated name.  Add interface name and make unique.
-    // m_szInterface should be non-null if processing an implemented interface; should be null otherwise.
-    _ASSERTE(m_ImplIface == eImplIfaceNone || m_szInterface != 0);
-    IfFailGo(qbName.ReSizeNoThrow(wcslen(pMember->m_pName)+2));
-    wcscpy_s(qbName.Ptr(), wcslen(pMember->m_pName)+2, pMember->m_pName); 
-    IfFailGo(GenerateUniqueMemberName(qbName, (PCCOR_SIGNATURE)qbComSig.Ptr(), cbTotal, m_szInterface, mdtMethodDef));
-    pszName = qbName.Ptr();
-
-    // Create the get Accessor.
-    IfFailGo(m_pEmit->DefineMethod(m_tdTypeDef, pszName, dwFlags, (PCCOR_SIGNATURE) qbComSig.Ptr(), cbTotal, 
-        0/*RVA*/, DEFAULT_ITF_FUNC_IMPL_FLAGS, &mdFuncGet));
-
-    // Handle dispids for non-implemented interfaces, and for default interface
-    if (m_ImplIface != eImplIface)
-    {
-        // Set the Dispid CA.
-        _SetDispIDCA(pITI, pMember->m_iMember, psVar->memid, mdFuncGet, TRUE, NULL, FALSE);
-    }
-    
-    // If processing an implemented interface, set up MethodImpls.
-    if (m_ImplIface != eImplIfaceNone)
-    {
-        // Define a memberref on the implemented interface.
-        mdToken mrItfMember;
-        IfFailGo(m_pEmit->DefineMemberRef(m_tkInterface, pMember->m_pName, (PCCOR_SIGNATURE) qbComSig.Ptr(),cbTotal, &mrItfMember));
-
-        // Define a method impl.
-        IfFailGo(m_pEmit->DefineMethodImpl(m_tdTypeDef, mdFuncGet, mrItfMember));
-    }
-
-    // If not a read-only var, create the setter.
-    if ((psVar->wVarFlags & VARFLAG_FREADONLY) == 0)
-    {
-        // Create the setter signature.
-        IfFailGo(qbComSig.ReSizeNoThrow(CB_MAX_ELEMENT_TYPE * 3));
-        pbSig = reinterpret_cast<BYTE*>(qbComSig.Ptr());
-        cbTotal = cb = CorSigCompressData((ULONG)IMAGE_CEE_CS_CALLCONV_DEFAULT | IMAGE_CEE_CS_CALLCONV_HASTHIS, pbSig);
-        // Setter takes one parameter.
-        cb = CorSigCompressData(1, &(pbSig[cb]));
-        cbTotal += cb;
-        // Setter returns nothing.
-        cb = CorSigCompressData(ELEMENT_TYPE_VOID, &pbSig[cbTotal]);
-        cbTotal += cb;
-        // Setter takes the property type.
-        IfFailGo(_ConvSignature(pITI, &psVar->elemdescVar.tdesc, SIG_ELEM, qbComSig, cbTotal, &cbTotal, qbNativeBuf, 0, &iNativeOfs, FALSE));
-        if (hr == S_CONVERSION_LOSS)
-            bConversionLoss = true;
-
-        // Setter properties.
-        dwFlags = DEFAULT_PROPERTY_FUNC_FLAGS;
-        // If processing an implemented interface, remove the abstract bit.  Methods on classes are not abstract.
-        if (m_ImplIface != eImplIfaceNone)
-            dwFlags &= ~mdAbstract;
-
-        // Get the previously decorated name.  Add interface name and make unique.
-        // m_szInterface should be non-null if processing an implemented interface; should be null otherwise.
-        _ASSERTE(m_ImplIface == eImplIfaceNone || m_szInterface != 0);
-        IfFailGo(qbName.ReSizeNoThrow(wcslen(pMember->m_pName2)+2));
-        wcscpy_s(qbName.Ptr(), wcslen(pMember->m_pName2)+2, pMember->m_pName2); 
-        IfFailGo(GenerateUniqueMemberName(qbName, (PCCOR_SIGNATURE)qbComSig.Ptr(), cbTotal, m_szInterface, mdtMethodDef));
-        pszName = qbName.Ptr();
-
-        // Create the setter Accessor.
-        IfFailGo(m_pEmit->DefineMethod(m_tdTypeDef, pszName, dwFlags, (PCCOR_SIGNATURE) qbComSig.Ptr(),cbTotal, 
-            0/*RVA*/, DEFAULT_ITF_FUNC_IMPL_FLAGS, &mdFuncSet));
-
-        // Handle dispids for non-implemented interfaces, and for default interface
-        if (m_ImplIface != eImplIface)
-        {
-        // Set the Dispid CA.
-            _SetDispIDCA(pITI, pMember->m_iMember, psVar->memid, mdFuncSet, TRUE, NULL, FALSE);
-    }
-        
-        // If processing an implemented interface, set up MethodImpls.
-        if (m_ImplIface != eImplIfaceNone)
-        {
-            // Define a memberref on the implemented interface.
-            mdToken mrItfMember;
-            IfFailGo(m_pEmit->DefineMemberRef(m_tkInterface, pMember->m_pName2, (PCCOR_SIGNATURE) qbComSig.Ptr(),cbTotal, &mrItfMember));
-
-            // Define a method impl.
-            IfFailGo(m_pEmit->DefineMethodImpl(m_tdTypeDef, mdFuncSet, mrItfMember));
-        }
-    }
-    else
-    {   // read-only, setter method is nil.
-        mdFuncSet = mdMethodDefNil;
-    }
-
-    // Create the property signature: 'type', or <fieldcallconv><type>
-    cbTotal = cb = CorSigCompressData((ULONG)IMAGE_CEE_CS_CALLCONV_PROPERTY, pbSig);
-    cb = CorSigCompressData(0, &(pbSig[cb]));
-    cbTotal += cb;
-    // Property is just the property type.
-    IfFailGo(_ConvSignature(pITI, &psVar->elemdescVar.tdesc, SIG_ELEM, qbComSig, cbTotal, &cbTotal, qbNativeBuf, 0, &iNativeOfs, FALSE));
-    if (hr == S_CONVERSION_LOSS)
-        bConversionLoss = true;
-
-    // Get the property name.  Add interface name and make unique, if needed.
-    // m_szInterface should be non-null if processing an implemented interface; should be null otherwise.
-    _ASSERTE(m_ImplIface == eImplIfaceNone || m_szInterface != 0);
-    IfFailGo(qbName.ReSizeNoThrow(wcslen(m_szMember)+2));
-    wcscpy_s(qbName.Ptr(), wcslen(m_szMember)+2, m_szMember); 
-    IfFailGo(GenerateUniqueMemberName(qbName, (PCCOR_SIGNATURE)qbComSig.Ptr(), cbTotal, m_szInterface, mdtProperty));
-    pszName = qbName.Ptr();
-
-    // Set up the Property on the two methods.
-    IfFailGo(m_pEmit->DefineProperty(m_tdTypeDef, pszName, 0/*dwFlags*/, (PCCOR_SIGNATURE) qbComSig.Ptr(),cbTotal, ELEMENT_TYPE_VOID, NULL/*default*/, -1,
-        mdFuncSet, mdFuncGet, NULL, &pdProperty));
-
-    // Handle dispids for non-implemented interfaces, and for default interface
-    if (m_ImplIface != eImplIface)
-    {
-        // Set the Dispid CA on the property.
-        long lDispSet = 1;
-        _SetDispIDCA(pITI, pMember->m_iMember, psVar->memid, pdProperty, TRUE, &lDispSet, FALSE);
-
-    // If this property is default property, add a custom attribute to the class.
-        if (lDispSet == DISPID_VALUE)
-        IfFailGo(_AddDefaultMemberCa(m_tdTypeDef, m_szMember));
-    }
-
-    // Add the alias information if the type is an alias.
-    IfFailGo(_HandleAliasInfo(pITI, &psVar->elemdescVar.tdesc, pdProperty));
-
-    if (bConversionLoss)
-    {
-        hr = S_CONVERSION_LOSS;
-        ReportEvent(NOTIF_CONVERTWARNING, TLBX_I_UNCONVERTABLE_ARGS, m_szName, m_szMember);
-    }
-
-ErrExit:
-    if (m_szMember)
-        ::SysFreeString(m_szMember), m_szMember=0;
-    return (hr);
-} // HRESULT CImportTlb::_ConvProperty()
-
-//*****************************************************************************
-// Convert the NewEnum dispatch property into the GetEnumerator method.
-//*****************************************************************************
-HRESULT CImportTlb::_ConvNewEnumProperty(
-    ITypeInfo   *pITI,                  // Containing TypeInfo.
-    VARDESC     *psVar,                 // VARDESC for the property.
-    MemberInfo  *pMember)
-{
-    HRESULT     hr;                     // A result.
-    mdMethodDef mdGetEnum;              // The GetEnumerator method.
-    CQuickBytes qbComSig;               // com signature buffer
-    ULONG       cb;                     // Size of an element.
-    ULONG       cbTotal = 0;            // Total size of signature.
-    BYTE        *pbSig;                 // Pointer to signature buffer.
-    BOOL        bConversionLoss=false;  // If true, some attributes were lost on conversion.
-    CQuickArray<BYTE> qbNativeBuf;      // Native type buffer.
-    ULONG       iNativeOfs=0;           // Current offset in native type buffer.
-
-    // Get the name.
-    IfFailGo(pITI->GetDocumentation(psVar->memid, &m_szMember, 0,0,0));
-
-    // Create the GetEnumerator signature.
-    IfFailGo(qbComSig.ReSizeNoThrow(CB_MAX_ELEMENT_TYPE * 2));
-    pbSig = reinterpret_cast<BYTE*>(qbComSig.Ptr());
-    cbTotal = cb = CorSigCompressData((ULONG)IMAGE_CEE_CS_CALLCONV_DEFAULT | IMAGE_CEE_CS_CALLCONV_HASTHIS, pbSig);
-
-    // GetEnumerator takes zero parameters.
-    cb = CorSigCompressData(0, &(pbSig[cb]));
-    cbTotal += cb;
-
-    // Getter returns the property type.
-    IfFailGo(_ConvSignature(pITI, &psVar->elemdescVar.tdesc, SIG_ELEM, qbComSig, cbTotal, &cbTotal, qbNativeBuf, 0, &iNativeOfs, TRUE));
-    if (hr == S_CONVERSION_LOSS)
-        bConversionLoss = true;
-
-    // Create the GetEnumerator method.
-    IfFailGo(m_pEmit->DefineMethod(m_tdTypeDef, GET_ENUMERATOR_MEMBER_NAME, DEFAULT_INTERFACE_FUNC_FLAGS, (PCCOR_SIGNATURE) qbComSig.Ptr(), cbTotal, 
-        0/*RVA*/, DEFAULT_ITF_FUNC_IMPL_FLAGS, &mdGetEnum));
-
-    // Set the Dispid CA.
-    _SetDispIDCA(pITI, pMember->m_iMember, psVar->memid, mdGetEnum, TRUE, NULL, FALSE);
-
-    // Add the alias information if the type is an alias.
-    IfFailGo(_HandleAliasInfo(pITI, &psVar->elemdescVar.tdesc, mdGetEnum));
-
-    if (bConversionLoss)
-    {
-        hr = S_CONVERSION_LOSS;
-        ReportEvent(NOTIF_CONVERTWARNING, TLBX_I_UNCONVERTABLE_ARGS, m_szName, m_szMember);
-    }
-
-ErrExit:
-    if (m_szMember)
-        ::SysFreeString(m_szMember), m_szMember=0;
-    return (hr);
-} // HRESULT CImportTlb::_ConvNewEnumProperty()
-
-//*****************************************************************************
-// Given an ITypeLib*, come up with a namespace name.  Use the typelib name
-//  unless there is one specified via custom attribute.
-//
-// NOTE:  This returns the member variable m_wzNamespace if the typelib
-//  is the importing typelib.  That must not be freed!
-//*****************************************************************************
-HRESULT CImportTlb::GetNamespaceOfRefTlb(
-    ITypeLib    *pITLB,                 // TypeLib for which to get namespace name.
-    BSTR        *pwzNamespace,          // Put the name here.
-    CImpTlbDefItfToClassItfMap **ppDefItfToClassItfMap) // Put def itf to class itf map here.
-{
-    mdAssemblyRef arDummy;
-    BSTR          wzAsmName = NULL;
-    HRESULT       hr = S_OK;
-        
-    // If already resolved, just return assembly ref.
-    if (!m_LibRefs.Find(pITLB, &arDummy, pwzNamespace, &wzAsmName, NULL, ppDefItfToClassItfMap))
-    {
-        // Add a reference to the typelib.
-        IfFailGo(_AddTlbRef(pITLB, &arDummy, pwzNamespace, &wzAsmName, ppDefItfToClassItfMap));
-    }
-
-ErrExit:
-    if (wzAsmName)
-        ::SysFreeString(wzAsmName);
-
-    return hr;
-} // HRESULT CImportTlb::GetNamespaceOfRefTlb()
-
-//*****************************************************************************
-// Given a TYPEDESC, resolve the USERDEFINED to the TYPEKIND.
-//*****************************************************************************
-HRESULT CImportTlb::_ResolveTypeDescAliasTypeKind(
-    ITypeInfo   *pITIAlias,             // The typeinfo containing the typedesc.
-    TYPEDESC    *ptdesc,                // The typedesc.
-    TYPEKIND    *ptkind)                // Put the aliased typekind.
-{
-    HRESULT     hr;                     // A result.
-    ITypeInfo   *pTIResolved=0;     // The resolved ITypeInfo.
-    TYPEATTR    *psResolved=0;      // The resolved TypeInfo's TYPEATTR
-
-    if (ptdesc->vt != VT_USERDEFINED)
-    {
-        *ptkind = TKIND_MAX;
-        return S_FALSE;
-    }
-
-    hr = _ResolveTypeDescAlias(pITIAlias, ptdesc, &pTIResolved, &psResolved);
-    if (hr == S_OK)
-        *ptkind = psResolved->typekind;
-    else
-        *ptkind = TKIND_MAX;
-
-    if (psResolved)
-        pTIResolved->ReleaseTypeAttr(psResolved);
-    if (pTIResolved)
-        pTIResolved->Release();
-
-    return hr;
-} // HRESULT CImportTlb::_ResolveTypeDescAliasTypeKind()
-
-//*****************************************************************************
-// Given a TYPEDESC in a TypeInfo, eliminate aliases (get to the aliased
-//  type).
-//*****************************************************************************
-HRESULT CImportTlb::_ResolveTypeDescAlias(
-    ITypeInfo   *pITIAlias,             // The typeinfo containing the typedesc.
-    const TYPEDESC  *ptdesc,            // The typedesc.
-    ITypeInfo   **ppTIResolved,         // Put the aliased ITypeInfo here.
-    TYPEATTR    **ppsAttrResolved,      // Put the ITypeInfo's TYPEATTR here.
-    GUID        *pGuid)                 // Caller may want aliased object's guid.
-{
-    HRESULT     hr;                     // A result.
-    ITypeInfo   *pITI=0;                // Referenced typeinfo.
-    TYPEATTR    *psAttr=0;              // TYPEATTR of referenced typeinfo.
-
-    // If the TDESC isn't a USERDEFINED, it is already resolved.
-    if (ptdesc->vt != VT_USERDEFINED)
-    {
-        *ppTIResolved = pITIAlias;
-        pITIAlias->AddRef();
-        // Need to addref the [out] psAttr.  Only way to do it:
-        IfFailGo(pITIAlias->GetTypeAttr(ppsAttrResolved));
-        hr = S_FALSE;
-        goto ErrExit;
-    }
-
-    // The TYPEDESC is a USERDEFINED.  Get the TypeInfo.
-    IfFailGo(pITIAlias->GetRefTypeInfo(ptdesc->hreftype, &pITI));
-    IfFailGo(pITI->GetTypeAttr(&psAttr));
-
-    // If the caller needs the aliased object's guid, get it now.
-    if (pGuid && *pGuid == GUID_NULL && psAttr->guid != GUID_NULL)
-        *pGuid = psAttr->guid;
-
-    // If the userdefined typeinfo is not itself an alias, then it is what the alias aliases.
-    //  Also, if the userdefined typeinfo is an alias to a builtin type, then the builtin
-    //  type is what the alias aliases.
-    if (psAttr->typekind != TKIND_ALIAS || psAttr->tdescAlias.vt != VT_USERDEFINED)
-    {
-        *ppsAttrResolved = psAttr;
-        *ppTIResolved = pITI;
-        if (psAttr->typekind == TKIND_ALIAS)
-            hr = S_FALSE;
-        psAttr = 0;
-        pITI = 0;
-        goto ErrExit;
-    }
-
-    // The userdefined type was itself an alias to a userdefined type.  Alias to what?
-    hr = _ResolveTypeDescAlias(pITI, &psAttr->tdescAlias, ppTIResolved, ppsAttrResolved, pGuid);
-
-ErrExit:
-    if (psAttr)
-        pITI->ReleaseTypeAttr(psAttr);
-    if (pITI)
-        pITI->Release();
-    return hr;
-} // HRESULT CImportTlb::_ResolveTypeDescAlias()
-
-//*****************************************************************************
-// Create the TypeInfo records (AKA classes, AKA critters).
-//*****************************************************************************
-HRESULT CImportTlb::GetKnownTypeToken(
-    VARTYPE     vt,                     // The type for which the token is desired.
-    mdTypeRef   *ptr)                   // Put the token here.
-{
-    HRESULT     hr = S_OK;                  // A result.
-
-    _ASSERTE(
-        (vt >= VT_CY && vt <= VT_DECIMAL) || (vt == VT_SAFEARRAY) || (vt == VT_SLOT_FOR_GUID) ||
-        (vt == VT_SLOT_FOR_IENUMERABLE) || (vt == VT_SLOT_FOR_MULTICASTDEL) || (vt == VT_SLOT_FOR_TYPE) ||
-        (vt == VT_SLOT_FOR_STRINGBUF));
-
-    // If it has already been added, just return it.
-    if (m_tkKnownTypes[vt])
-    {
-        *ptr = m_tkKnownTypes[vt];
-        goto ErrExit;
-    }
-
-    // Not yet created, so create the typeref now.
-    switch (vt)
-    {
-    //=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
-    // WARNING:  the VT_EMPTY slot is used for System.GUID!!        
-    case VT_SLOT_FOR_GUID:
-        _ASSERTE(VT_SLOT_FOR_GUID == VT_EMPTY);
-        IfFailGo(m_TRMap.DefineTypeRef(         
-            m_pEmit,                        // The emit scope.
-            m_arSystem,                     // The system assemblyref.
-            TLB_CLASSLIB_GUID,              // URL of the TypeDef, wide chars.
-            &m_tkKnownTypes[VT_SLOT_FOR_GUID]));    // Put mdTypeRef here
-        break;
-
-    // WARNING:  the VT_NULL slot is used for System.Collections.IEnumerable!!        
-    case VT_SLOT_FOR_IENUMERABLE:
-        _ASSERTE(VT_SLOT_FOR_IENUMERABLE == VT_NULL);
-        IfFailGo(m_TRMap.DefineTypeRef(         
-            m_pEmit,                        // The emit scope.
-            m_arSystem,                     // The system assemblyref.
-            TLB_CLASSLIB_IENUMERABLE,       // URL of the TypeDef, wide chars.
-            &m_tkKnownTypes[VT_SLOT_FOR_IENUMERABLE]));    // Put mdTypeRef here
-        break;
-
-    // WARNING:  the VT_I2 slot is used for System.MulticastDelegate!!        
-    case VT_SLOT_FOR_MULTICASTDEL:
-        _ASSERTE(VT_SLOT_FOR_MULTICASTDEL == VT_I2);
-        IfFailGo(m_TRMap.DefineTypeRef(         
-            m_pEmit,                        // The emit scope.
-            m_arSystem,                     // The system assemblyref.
-            TLB_CLASSLIB_MULTICASTDELEGATE, // URL of the TypeDef, wide chars.
-            &m_tkKnownTypes[VT_SLOT_FOR_MULTICASTDEL]));    // Put mdTypeRef here
-        break;
-
-    // WARNING:  the VT_I4 slot is used for System.Type!!        
-    case VT_SLOT_FOR_TYPE:
-        _ASSERTE(VT_SLOT_FOR_TYPE == VT_I4);
-        IfFailGo(m_TRMap.DefineTypeRef(         
-            m_pEmit,                        // The emit scope.
-            m_arSystem,                     // The system assemblyref.
-            TLB_CLASSLIB_TYPE,              // URL of the TypeDef, wide chars.
-            &m_tkKnownTypes[VT_SLOT_FOR_TYPE]));    // Put mdTypeRef here
-        break;
-
-    // WARNING:  the VT_I8 slot is used for System.Text.StringBuilder!!
-    case VT_SLOT_FOR_STRINGBUF:
-        _ASSERTE(VT_SLOT_FOR_STRINGBUF == VT_I8);
-        IfFailGo(m_TRMap.DefineTypeRef(         
-            m_pEmit,                        // The emit scope.
-            m_arSystem,                     // The system assemblyref.
-            TLB_CLASSLIB_STRINGBUFFER,      // URL of the TypeDef, wide chars.
-            &m_tkKnownTypes[VT_SLOT_FOR_STRINGBUF]));    // Put mdTypeRef here
-        break;
-
-    case VT_CY:
-        IfFailGo(m_TRMap.DefineTypeRef(         
-            m_pEmit,                        // The emit scope.
-            m_arSystem,                     // The system assemblyref.
-            TLB_CLASSLIB_DECIMAL,           // URL of the TypeDef, wide chars.
-            &m_tkKnownTypes[VT_CY]));       // Put mdTypeRef here
-        break;
-        
-    case VT_DATE:
-        IfFailGo(m_TRMap.DefineTypeRef(         
-            m_pEmit,                        // The emit scope.
-            m_arSystem,                     // The system assemblyref.
-            TLB_CLASSLIB_DATE,              // URL of the TypeDef, wide chars.
-            &m_tkKnownTypes[VT_DATE]));     // Put mdTypeRef here
-        break;
-
-    case VT_DECIMAL:
-        IfFailGo(m_TRMap.DefineTypeRef(         
-            m_pEmit,                        // The emit scope.
-            m_arSystem,                     // The system assemblyref.
-            TLB_CLASSLIB_DECIMAL,           // URL of the TypeDef, wide chars.
-            &m_tkKnownTypes[VT_DECIMAL]));  // Put mdTypeRef here
-        break;
-
-    case VT_SAFEARRAY:
-        IfFailGo(m_TRMap.DefineTypeRef(         
-            m_pEmit,                        // The emit scope.
-            m_arSystem,                     // The system assemblyref.
-            TLB_CLASSLIB_ARRAY,             // URL of the TypeDef, wide chars.
-            &m_tkKnownTypes[VT_SAFEARRAY]));  // Put mdTypeRef here
-        break;
-            
-    default:
-        _ASSERTE(!"Unknown type in GetKnownTypes");
-        IfFailGo(E_INVALIDARG);
-    }
-
-    _ASSERTE(!IsNilToken(m_tkKnownTypes[vt]));
-    *ptr = m_tkKnownTypes[vt];
-    
-ErrExit:
-    return hr;
-} // HRESULT CImportTlb::GetKnownTypeToken()
-
-
-//*****************************************************************************
-// Given an ITypeInfo for a coclass, return an ITypeInfo for the default
-//  interface.  This is either the explicitly marked default, or the first
-//  non-source interface.
-//*****************************************************************************
-HRESULT CImportTlb::GetDefaultInterface(    // Error, S_OK or S_FALSE.
-    ITypeInfo *pCoClassTI,                  // The TypeInfo of the coclass.
-    ITypeInfo **pDefaultItfTI)              // The returned default interface.
-{
-    HRESULT     hr;                 // A result
-    HREFTYPE    href;               // HREFTYPE of an implemented interface.
-    INT         ImplFlags;          // ImplType flags.
-    ITypeInfo   *pITI=NULL;         // ITypeInfo for an interface.
-    TYPEATTR    *pCoClassTypeAttr;  // The type attributes of the coclass.
-    int         NumInterfaces;      // The number of interfaces on the coclass.
-    int         i;                  // A counter.
-
-    // Initialize the default interface to NULL.
-    *pDefaultItfTI = NULL;
-
-    // Retrieve the number of interfaces the coclass has
-    IfFailGo(pCoClassTI->GetTypeAttr(&pCoClassTypeAttr));
-    NumInterfaces = pCoClassTypeAttr->cImplTypes;
-    pCoClassTI->ReleaseTypeAttr(pCoClassTypeAttr);
-
-    for (i=0; i < NumInterfaces; i++)
-    {
-        IfFailGo(pCoClassTI->GetImplTypeFlags(i, &ImplFlags));
-
-        if ((ImplFlags & (IMPLTYPEFLAG_FSOURCE | IMPLTYPEFLAG_FDEFAULT)) == IMPLTYPEFLAG_FDEFAULT)
-        {
-            // We have found a default interface.
-            if (*pDefaultItfTI)
-                (*pDefaultItfTI)->Release();
-
-            IfFailGo(pCoClassTI->GetRefTypeOfImplType(i, &href));
-            IfFailGo(pCoClassTI->GetRefTypeInfo(href, pDefaultItfTI));
-            break;
-        } 
-        else if (!(ImplFlags & IMPLTYPEFLAG_FSOURCE) && !(*pDefaultItfTI))
-        {
-            // If this is the first normal interface we encounter then we need to 
-            // hang on to it in case we don't find any default interfaces. If that
-            // happens then this is the one that will be returned.
-            IfFailGo(pCoClassTI->GetRefTypeOfImplType(i, &href));
-            IfFailGo(pCoClassTI->GetRefTypeInfo(href, pDefaultItfTI));
-        }       
-    }
-
-    // Return either S_OK or S_FALSE depending on if we have found a default interface.
-    if (*pDefaultItfTI)
-        return S_OK;
-    else
-        return S_FALSE;
-
-ErrExit:
-    if (pITI)
-        pITI->Release();
-
-    return hr;
-} // HRESULT CImportTlb::GetDefaultInterface()
-
-//*****************************************************************************
-// Given a TypeInfo, return a TypeDef/TypeRef token.
-//*****************************************************************************
-HRESULT CImportTlb::_GetTokenForTypeInfo(
-    ITypeInfo   *pITI,                  // ITypeInfo for which to get token.
-    BOOL        bConvDefItfToClassItf,  // If TRUE, convert the def itf to its class itf.
-    mdToken     *pToken,                // Put the token here.
-    __out_ecount (chTypeRef) __out_opt LPWSTR pszTypeRef, // Optional, put the name here.
-    int         chTypeRef,              // Size of the name buffer in characters.
-    int         *pchTypeRef,            // Optional, put size of name here.
-    BOOL        bAsmQualifiedName)      // Assembly qualified name or not?
-{
-    HRESULT     hr;                     // A result.
-    ITypeLib    *pITLB=0;               // Containing typelib.
-    BSTR        bstrNamespace=0;        // Namespace of the type.
-    BSTR        bstrFullName=0;         // Fully qualified name of type.
-    BSTR        bstrTempName=0;         // Temp name.
-    BSTR        bstrAsmName=0;          // Assembly name.
-    LPCWSTR     strTypeName=0;          // The type name.
-    mdAssemblyRef ar;                   // The typelib's assembly ref.
-    TYPEATTR*   psAttr = 0;             // The TYPEATTR for the type info.
-    CImpTlbDefItfToClassItfMap *pDefItfToClassItfMap; // The default interface to class interface map.
-
-    // Get the library.
-    IfFailGo(pITI->GetContainingTypeLib(&pITLB, 0));
-   
-    // Resolve the external reference.
-    IfFailGo(_AddTlbRef(pITLB, &ar, &bstrNamespace, &bstrAsmName, &pDefItfToClassItfMap));
-
-    // If are converting default interfaces to class interfaces, then check
-    // to see if we need to do the convertion for the current ITypeInfo.
-    if (bConvDefItfToClassItf)
-    {
-        // Retrieve the TYPEATTR.
-        IfFailGo(pITI->GetTypeAttr(&psAttr));
-
-        // If we are dealing with an interface, then check to see if there
-        // is a class interface we should use.
-        if (psAttr->typekind == TKIND_INTERFACE || psAttr->typekind == TKIND_DISPATCH)
-        {
-            strTypeName = pDefItfToClassItfMap->GetClassItfName(psAttr->guid);
-        }
-    }
-
-    // If we haven't found a class interface, then use the current interface.
-    if (!strTypeName)
-    {
-    // Get the name of the typeinfo.
-    IfFailGo(GetManagedNameForTypeInfo(pITI, bstrNamespace, NULL, &bstrFullName));
-        strTypeName = bstrFullName;
-    }
-    
-    // Give name back to caller, if desired.
-    if (pszTypeRef)
-        wcsncpy_s(pszTypeRef, chTypeRef, strTypeName, chTypeRef-1);
-    if (pchTypeRef)
-        *pchTypeRef = (int)(wcslen(pszTypeRef) + 1);
-
-    // Define the TypeRef (will return any existing typeref).
-    IfFailGo(m_TRMap.DefineTypeRef(m_pEmit, ar, strTypeName, pToken));
-
-    // If the caller desires an assembly qualified name, then provide it.
-    if (bAsmQualifiedName)
-    {
-        int cchAsmQualifiedName = SysStringLen(bstrFullName) + SysStringLen(bstrAsmName) + 2;
-        IfNullGo(bstrTempName = ::SysAllocStringLen(0, cchAsmQualifiedName));
-        ns::MakeAssemblyQualifiedName(bstrTempName, cchAsmQualifiedName + 1, bstrFullName, SysStringLen(bstrFullName), bstrAsmName, SysStringLen(bstrAsmName));
-        SysFreeString(bstrFullName);
-        bstrFullName = bstrTempName;
-    }
-
-    // Give name back to caller, if desired.
-    if (pszTypeRef)
-        wcsncpy_s(pszTypeRef, chTypeRef, bstrFullName, chTypeRef-1);
-    if (pchTypeRef)
-        *pchTypeRef = (int)(wcslen(pszTypeRef) + 1);
-
-ErrExit:
-    if (bstrNamespace)
-        ::SysFreeString(bstrNamespace);
-    if (bstrFullName)
-        ::SysFreeString(bstrFullName);
-    if (bstrAsmName)
-        ::SysFreeString(bstrAsmName);
-    if (pITLB)
-        pITLB->Release();
-    if (psAttr)
-        pITI->ReleaseTypeAttr(psAttr);
-
-    return (hr);
-} // HRESULT CImportTlb::_GetTokenForTypeInfo()
-
-//*****************************************************************************
-// Given a TypeInfo for a source interface, creates a new event interface
-// if none exists or returns an existing one.
-//*****************************************************************************
-HRESULT CImportTlb::_GetTokenForEventItf(ITypeInfo *pSrcItfITI, mdTypeRef *ptr)
-{
-#ifndef DACCESS_COMPILE
-    HRESULT             hr = S_OK;                  // A result.   
-    ImpTlbEventInfo*    pEventInfo;                 // The event information.
-    BSTR                bstrSrcItfName = NULL;      // The name of the CoClass.
-    CQuickArray<WCHAR>  qbEventItfName;             // The name of the event interface.
-    CQuickArray<WCHAR>  qbEventProviderName;        // The name of the event provider.
-    mdToken             tkAttr;                     // Custom attribute type.
-    BSTR                szOldName = NULL;           // The old value m_tdTypeDef.
-    mdTypeDef           tdOldTypeDef = NULL;        // The old value m_szName.
-    TYPEATTR*           psAttr = 0;                 // The TYPEATTR for the source interface.
-    mdTypeRef           trEventItf;                 // A type ref to the event interface.
-    ITypeLib*           pTypeTLB;                   // The typelib containing this interface.
-    mdAssemblyRef       ar;                         // Dummy AssmRef.
-    BSTR                wzNamespace=0;              // Namespace of the event interface assembly.
-    BSTR                wzAsmName=0;                // Assembly name of the event interface assembly.
-    Assembly*           SrcItfAssembly=0;           // The Source Event Interface assembly.
-    CQuickArray<WCHAR>  qbSrcItfName;               // The name of the source interface.
-    CImpTlbDefItfToClassItfMap *pDefItfToClassItfMap;   // The default interface to class interface map.
-    BOOL                fInheritsIEnum = FALSE;
-       
-    // Retrieve the namespace of the typelib containing this source interface.
-    IfFailGo(pSrcItfITI->GetContainingTypeLib(&pTypeTLB, NULL));
-
-    // Resolve the external reference.
-    IfFailGo(_AddTlbRef(pTypeTLB, &ar, &wzNamespace, &wzAsmName, &pDefItfToClassItfMap));
-
-    // Get the assembly + namespace the source interface resides in.  
-    //  May return all NULL - indicating the importing assembly.
-    m_LibRefs.Find(pTypeTLB, &ar, &wzNamespace, &wzAsmName, &SrcItfAssembly, NULL);
-    if (SrcItfAssembly == NULL)
-        SrcItfAssembly = m_pAssembly;
-
-    // Retrieve the full name of the source interface.
-    if (wzNamespace)
-        IfFailGo(GetManagedNameForTypeInfo(pSrcItfITI, (WCHAR*)wzNamespace, NULL, &bstrSrcItfName));
-    else
-        IfFailGo(GetManagedNameForTypeInfo(pSrcItfITI, m_wzNamespace, NULL, &bstrSrcItfName));          
-
-    // Start by looking up the event information for the source itf type info.
-    pEventInfo = m_EventInfoMap.FindEventInfo(bstrSrcItfName);
-    if (pEventInfo)
-    {
-        SysFreeString(bstrSrcItfName);
-        *ptr = pEventInfo->trEventItf;
-        return S_OK;
-    }
-
-    // Store the old values of the ITypeInfo name and of the current type def.
-    szOldName = m_szName;
-    tdOldTypeDef = m_tdTypeDef;
-    m_szName = NULL;
-
-    // Get some information about the TypeInfo.
-    IfFailGo(pSrcItfITI->GetDocumentation(MEMBERID_NIL, &m_szName, 0, 0, 0));
-    IfFailGo(pSrcItfITI->GetTypeAttr(&psAttr));
-
-    if (ExplicitlyImplementsIEnumerable(pSrcItfITI, psAttr) == S_OK)
-        fInheritsIEnum = TRUE;
-
-    // Generate a unique name for the event interface which will be of the form:
-        //     <ImportingAssemblyNamespace>.<SrcItfName>_Event<PotentialSuffix>
-
-    // Strip the namespace
-    IfFailGo(qbSrcItfName.ReSizeNoThrow(wcslen(bstrSrcItfName) + 2));
-    ns::SplitPath((WCHAR*)bstrSrcItfName, NULL, 0, qbSrcItfName.Ptr(), (int)wcslen(bstrSrcItfName) + 1);
-
-    // Add the namespace of the importing typelib and the event suffix
-    IfFailGo(qbEventItfName.ReSizeNoThrow(qbSrcItfName.Size() + wcslen(m_wzNamespace) + EVENT_ITF_SUFFIX_LENGTH + 7));
-    StringCchPrintf(qbEventItfName.Ptr(), qbEventItfName.Size(), W("%s.%s%s"), m_wzNamespace, qbSrcItfName.Ptr(), EVENT_ITF_SUFFIX);
-        IfFailGo(GenerateUniqueTypeName(qbEventItfName));
-
-    // Generate a unique name for the event provider which will be of the form:
-    //     <ImportingAssemblyNamespace>.<SrcItfName>_EventProvider<PotentialSuffix>
-
-    // Add the namespace of the imporing typelib and the event suffix
-    IfFailGo(qbEventProviderName.ReSizeNoThrow(qbSrcItfName.Size() + wcslen(m_wzNamespace) + EVENT_PROVIDER_SUFFIX_LENGTH + 7));
-    StringCchPrintf(qbEventProviderName.Ptr(), qbEventProviderName.Size(), W("%s.%s%s"), m_wzNamespace, qbSrcItfName.Ptr(), EVENT_PROVIDER_SUFFIX);
-        IfFailGo(GenerateUniqueTypeName(qbEventProviderName));
-
-    // Add the event provider as a reserved name.
-    m_ReservedNames.AddReservedName(qbEventProviderName.Ptr());
-
-    // Create the typedef for the event interface.
-    IfFailGo(m_pEmit->DefineTypeDef(qbEventItfName.Ptr(), tdPublic | tdInterface | tdAbstract, mdTypeDefNil, NULL, &m_tdTypeDef));
-
-    // Hide the event interface from the VB object browser (_Event)
-    _SetHiddenCA(m_tdTypeDef);
-
-    // Make the interface ComVisible(false).
-    {
-        DECLARE_CUSTOM_ATTRIBUTE(sizeof(BYTE));
-        BUILD_CUSTOM_ATTRIBUTE(BYTE, FALSE);
-        IfFailGo(GetAttrType(ATTR_COMVISIBLE, &tkAttr));
-        FINISH_CUSTOM_ATTRIBUTE();
-        IfFailGo(m_pEmit->DefineCustomAttribute(m_tdTypeDef, tkAttr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(), 0));
-    }
-
-    // Set the ComEventInterface CA on the interface.
-    {
-        CQuickBytes asmQualifiedSrcItfName;
-        if (!ns::MakeAssemblyQualifiedName(asmQualifiedSrcItfName, bstrSrcItfName, wzAsmName))
-            IfFailGo(E_OUTOFMEMORY);
-        DECLARE_DYNLEN_CUSTOM_ATTRIBUTE(wcslen((WCHAR*)asmQualifiedSrcItfName.Ptr()) + 5 + wcslen(qbEventProviderName.Ptr()) + 5);
-        APPEND_WIDE_STRING_TO_CUSTOM_ATTRIBUTE((WCHAR*)asmQualifiedSrcItfName.Ptr());
-        APPEND_WIDE_STRING_TO_CUSTOM_ATTRIBUTE(qbEventProviderName.Ptr());
-        IfFailGo(GetAttrType(ATTR_COMEVENTINTERFACE, &tkAttr));
-        FINISH_DYNLEN_CUSTOM_ATTRIBUTE();
-        IfFailGo(m_pEmit->DefineCustomAttribute(m_tdTypeDef, tkAttr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(), 0));
-    }
-
-    // Add the add_XXX and remove_XXX methods to the event interface.
-    IfFailGo(_ConvSrcIfaceMembers(pSrcItfITI, psAttr, fInheritsIEnum));
-
-    // Define a typeref for the event interface.
-    IfFailGo(m_pEmit->DefineTypeRefByName(TokenFromRid(1, mdtModule), qbEventItfName.Ptr(), &trEventItf));
-    
-    // Add the event info to the map.
-    IfFailGo(m_EventInfoMap.AddEventInfo(bstrSrcItfName, trEventItf, qbEventItfName.Ptr(), qbEventProviderName.Ptr(), SrcItfAssembly));
-
-    // Set the out type ref.
-    *ptr = trEventItf;
-
-ErrExit:
-    if (bstrSrcItfName)
-        ::SysFreeString(bstrSrcItfName);
-    if (m_szName)
-        ::SysFreeString(m_szName);
-    if (psAttr)
-        pSrcItfITI->ReleaseTypeAttr(psAttr);
-    if (pTypeTLB)
-        pTypeTLB->Release();
-
-    // Restore the initial values for the ITypeInfo name and the type def.
-    m_szName = szOldName;
-    m_tdTypeDef = tdOldTypeDef;
-
-    return (hr);
-#else
-    DacNotImpl();
-    return E_NOTIMPL;
-#endif // #ifndef DACCESS_COMPILE
-} // HRESULT CImportTlb::_GetTokenForEventItf()
-
-//*****************************************************************************
-// Creates an interface with the same name as the class and which implements
-// the default interface and the default event interface.
-//*****************************************************************************
-HRESULT CImportTlb::_CreateClassInterface(ITypeInfo *pCoClassITI, ITypeInfo *pDefItfITI, mdTypeRef trDefItf, mdTypeRef rtDefEvItf, mdToken *ptr)
-{
-    HRESULT     hr = S_OK;              // A result.
-    CQuickArray<mdToken> rImpls;        // Array of implemented interfaces.
-    int         ixImpl = -1;            // Index into rImpls for implemented interface.
-    mdTypeDef   tdTypeDef;              // The class interface typedef.
-    BSTR        bstrFullName = NULL;    // The name of the CoClass.
-    TYPEATTR    *psAttrIface=0;         // TYPEATTR for an interface.
-    CQuickArray<WCHAR> qbClassName;     // The name of the class.
-
-    IfFailGo(rImpls.ReSizeNoThrow(3));
-    memset(rImpls.Ptr(), 0, 3 * sizeof(mdToken));
-    if (trDefItf)
-        rImpls[++ixImpl] = trDefItf;
-    if (rtDefEvItf)
-        rImpls[++ixImpl] = rtDefEvItf;
-
-    // Retrieve the TypeAttr for the interface.
-    if (pDefItfITI)
-        IfFailGo(pDefItfITI->GetTypeAttr(&psAttrIface));
-
-    // Retrieve the name of the CoClass (use the original name if this is an alias).
-    IfFailGo(GetManagedNameForTypeInfo(m_pOrigITI, m_wzNamespace, NULL, &bstrFullName));
-
-    // Create the typedef.
-    IfFailGo(m_pEmit->DefineTypeDef(bstrFullName, rdwTypeFlags[TKIND_INTERFACE], mdTypeDefNil, 0, &tdTypeDef));
-
-    // Set the IID to the IID of the default interface.
-    IfFailGo(_AddGuidCa(tdTypeDef, psAttrIface ? psAttrIface->guid : GUID_NULL));
-
-    // Add the CoClass CA to the interface.
-    _AddStringCa(ATTR_COCLASS, tdTypeDef, m_szMngName);
-
-    // Add the implemented interfaces and event interfaces to the TypeDef.
-    IfFailGo(m_pEmit->SetTypeDefProps(tdTypeDef, ULONG_MAX/*Classflags*/, 
-        ULONG_MAX, (mdToken*)rImpls.Ptr()));
-
-    // Set the out type def.
-    *ptr = tdTypeDef;
-
-ErrExit:
-    if (bstrFullName)
-        ::SysFreeString(bstrFullName);
-    if (psAttrIface)
-        pDefItfITI->ReleaseTypeAttr(psAttrIface);
-
-    return (hr);
-} // HRESULT CImportTlb::_CreateClassInterface()
-
-//*****************************************************************************
-// Creates an interface with the same name as the class and which implements
-// the default interface and the default event interface.
-//*****************************************************************************
-HRESULT CImportTlb::GetManagedNameForCoClass(ITypeInfo *pITI, CQuickArray<WCHAR> &qbClassName)
-{ 
-    HRESULT     hr = S_OK;              // A result.
-    BSTR        bstrFullName=0;         // Fully qualified name of type.
-
-    // Retrieve the name of the CoClass.
-    IfFailGo(GetManagedNameForTypeInfo(pITI, m_wzNamespace, NULL, &bstrFullName));
-
-    // Resize the class name to accomodate the Class and potential suffix.
-    IfFailGo(qbClassName.ReSizeNoThrow(wcslen(bstrFullName) + CLASS_SUFFIX_LENGTH + 6));
-
-    // Set the class name to the CoClass name suffixed with Class.
-    StringCchPrintf(qbClassName.Ptr(), qbClassName.Size(), W("%s%s"), bstrFullName, CLASS_SUFFIX);
-
-    // Generate a unique name for the class.
-    IfFailGo(GenerateUniqueTypeName(qbClassName));
-
-ErrExit:
-    if (bstrFullName)
-        ::SysFreeString(bstrFullName);
-
-    return (hr);
-} // HRESULT CImportTlb::GetManagedNameForCoClass()
-
-//*****************************************************************************
-// Creates an interface with the same name as the class and which implements
-// the default interface and the default event interface.
-//*****************************************************************************
-HRESULT CImportTlb::GenerateUniqueTypeName(CQuickArray<WCHAR> &qbTypeName)
-{ 
-    HRESULT     hr = S_OK;              // A result.
-    WCHAR       *pSuffix=0;             // Location for suffix.
-    size_t      cchSuffix;
-    WCHAR       *pName=0;               // The name without the namespace.
-    int         iSuffix=2;              // Starting value for suffix.
-    mdToken     td;                     // For looking up a TypeDef.
-    BSTR        szTypeInfoName=0;       // Name of a typeinfo.
-    ITypeInfo   *pITI=0;                // A typeinfo.
-
-    // Resize the class name to accomodate the Class and potential suffix.
-    IfFailGo(qbTypeName.ReSizeNoThrow(wcslen(qbTypeName.Ptr()) + 6));
-
-    // Set the suffix pointer.
-    pSuffix = qbTypeName.Ptr() + wcslen(qbTypeName.Ptr());
-    cchSuffix = qbTypeName.Size() - wcslen(qbTypeName.Ptr());
-
-    // Set the name pointer.
-    WCHAR* pTemp = ns::FindSep(qbTypeName.Ptr());
-    if (pTemp == NULL)
-        pName = qbTypeName.Ptr();
-    else
-        pName = pTemp + 1;
-
-    // Attempt to find a class name that is not in use.
-    for (;;)
-    {
-        // First check to see if the type name is in use in the metadata we 
-        // have emitted so far.
-        hr = m_pImport->FindTypeDefByName(qbTypeName.Ptr(), mdTypeDefNil, &td);
-        if (hr == CLDB_E_RECORD_NOTFOUND)
-        {
-            // It is not in use in the metadata but we still need to check the
-            // typelib because the type might not have been emitted yet.
-            USHORT cReq = 4;
-            USHORT cFound = cReq;
-            BOOL bTypeInTlb = FALSE;
-            CQuickArray<ITypeInfo *> qbTI;
-            CQuickArray<MEMBERID> qbMemId;
-            
-            // Retrieve all the instances of the name in the typelib.
-            do
-            {
-                // Double the number of requested names.
-                cReq *= 2;
-
-                // Resize the array's to accomodate the resquested names.
-                IfFailGo(qbTI.ReSizeNoThrow(cReq));
-                IfFailGo(qbMemId.ReSizeNoThrow(cReq));
-
-                // Request the names.
-                cFound = cReq;
-                IfFailGo(m_pITLB->FindName(pName, 0, qbTI.Ptr(), qbMemId.Ptr(), &cFound));
-
-                // Release all the ITypeInfo's. 
-                for (int i = 0; i < cFound; i++)
-                    qbTI[i]->Release();
-            }
-            while (cReq == cFound);
-
-            // Check to see if one of the instances of the name is for a type.
-            for (int i = 0; i < cFound; i++)
-            {
-                if (qbMemId[i] == MEMBERID_NIL)
-                {
-                    bTypeInTlb = TRUE;
-                    break;
-                }
-            }
-
-            // If the type name exists in the typelib, but we didn't find it as a type,
-            //  we still need to do a deeper check, due to how FindName() works.
-            if (!bTypeInTlb && cFound > 0)
-            {
-                int                     cTi;             // Count of TypeInfos.
-                int                     i;               // Loop control.
-
-                //@todo: this iterates over every typeinfo every time!  We could cache
-                // the names, and skip the types already converted.  However, this should
-                // be pretty rare.
-
-                // How many TypeInfos?
-                IfFailGo(cTi = m_pITLB->GetTypeInfoCount());
-
-                // Iterate over them.
-                for (i=0; i<cTi; ++i)
-                {
-                    // Get the TypeInfo, and its name.
-                    IfFailGo(m_pITLB->GetTypeInfo(i, &pITI));
-                    IfFailGo(pITI->GetDocumentation(MEMBERID_NIL, &szTypeInfoName, 0, 0, 0));
-                    if (wcscmp(pName, szTypeInfoName) == 0)
-                    {
-                        bTypeInTlb = TRUE;
-                        break;
-                    }
-
-                    // Release for next TypeInfo.
-                    ::SysFreeString(szTypeInfoName);
-                    szTypeInfoName = 0;
-                    pITI->Release();
-                    pITI = 0;
-                }
-            }
-
-            // The type name is not in the typelib and not in the metadata then we still
-            // need to check to see if is a reserved name.
-            if (!bTypeInTlb)
-            {
-                if (!m_ReservedNames.IsReservedName(qbTypeName.Ptr()))
-                {
-                    // The name is not a reserved name so we can use it.
-                    break;
-                }
-            }
-        }
-        IfFailGo(hr);
-
-        // Append the new suffix to the class name.
-        StringCchPrintf(pSuffix, cchSuffix, W("_%i"), iSuffix++);
-    }
-
-ErrExit:
-    if (szTypeInfoName)
-        ::SysFreeString(szTypeInfoName);
-    if (pITI)
-        pITI->Release();
-    return (hr);
-} // HRESULT CImportTlb::GenerateUniqueTypeName()
-
-//*****************************************************************************
-// Generate a unique member name based on the interface member name.
-//*****************************************************************************
-HRESULT CImportTlb::GenerateUniqueMemberName(// S_OK or error
-    CQuickArray<WCHAR> &qbMemberName,       // Original name of member.
-    PCCOR_SIGNATURE pSig,                   // Signature of the member.
-    ULONG       cSig,                       // Length of the signature.
-    LPCWSTR     szPrefix,                   // Possible prefix for decoration.
-    mdToken     type)                       // Is it a property? (Not a method?)
-{
-    HRESULT     hr;                         // A result.
-    mdToken     tkMember;                   // Dummy location for token.
-    WCHAR       *pSuffix=0;                 // Location for suffix.
-    size_t      cchSuffix = 0;
-    int         iSuffix=2;                  // Starting value for suffix.
-
-    // Try to find a member name that is not already in use.
-    for (;;)
-    {   // See if this is (finally) a unique member or property.
-        switch (type)
-        {
-        case mdtProperty:
-            hr = FindProperty(m_tdTypeDef, qbMemberName.Ptr(), 0, 0, &tkMember);
-            // If name is OK as property, check that there is no method or 
-            // property with the name.
-            if (hr == CLDB_E_RECORD_NOTFOUND)
-                hr = FindMethod(m_tdTypeDef, qbMemberName.Ptr(), 0,0, &tkMember);
-            if (hr == CLDB_E_RECORD_NOTFOUND)
-                hr = FindEvent(m_tdTypeDef, qbMemberName.Ptr(),  &tkMember);
-            break;
-        case mdtMethodDef:
-            hr = FindMethod(m_tdTypeDef, qbMemberName.Ptr(), pSig, cSig, &tkMember);
-            // If name is OK as method, check that there is no property or 
-            // event with the name.
-            if (hr == CLDB_E_RECORD_NOTFOUND)
-                hr = FindProperty(m_tdTypeDef, qbMemberName.Ptr(), 0,0, &tkMember);
-            if (hr == CLDB_E_RECORD_NOTFOUND)
-                hr = FindEvent(m_tdTypeDef, qbMemberName.Ptr(),  &tkMember);
-            break;
-        case mdtEvent:
-            hr = FindEvent(m_tdTypeDef, qbMemberName.Ptr(),  &tkMember);
-            // If name is OK as event, check that there is no property or 
-            // method with the name.
-            if (hr == CLDB_E_RECORD_NOTFOUND)
-                hr = FindProperty(m_tdTypeDef, qbMemberName.Ptr(), 0,0, &tkMember);
-            if (hr == CLDB_E_RECORD_NOTFOUND)
-                hr = FindMethod(m_tdTypeDef, qbMemberName.Ptr(), 0,0, &tkMember);
-            break;
-        default:
-            // Unexpected type.  Make noise, but let it pass.
-            _ASSERTE(!"Unexpected token type in GenerateUniqueMemberName");
-            hr = CLDB_E_RECORD_NOTFOUND;
-        }
-
-        // If name was not found, it is unique.
-        if (hr == CLDB_E_RECORD_NOTFOUND)
-        {
-            hr = S_OK;
-            goto ErrExit;
-        }
-        // Test for failure.
-        IfFailGo(hr);
-        
-        // Make a test decoration.
-        if (szPrefix)
-        {
-            size_t iLenPrefix, iLenName;
-            iLenPrefix = wcslen(szPrefix);  
-            iLenName = wcslen(qbMemberName.Ptr());
-            IfFailGo(qbMemberName.ReSizeNoThrow(iLenName + iLenPrefix + 2));
-            // Shift by prefix length, plus '_'.  Note use of overlap-safe move.
-            memmove(&qbMemberName[iLenPrefix+1], &qbMemberName[0], (iLenName+1)*sizeof(WCHAR));
-            wcscpy_s(qbMemberName.Ptr(), iLenPrefix + 1, szPrefix);
-            qbMemberName[iLenPrefix] = W('_');
-            szPrefix = 0;
-            // Try again with prefix before trying a suffix.
-            continue;
-        }
-        if (!pSuffix)
-        {
-            IfFailGo(qbMemberName.ReSizeNoThrow(wcslen(qbMemberName.Ptr()) + 6));
-            pSuffix = qbMemberName.Ptr() + wcslen(qbMemberName.Ptr());
-            cchSuffix = qbMemberName.Size() - wcslen(qbMemberName.Ptr());
-        }
-        StringCchPrintf(pSuffix, cchSuffix, W("_%i"), iSuffix++);
-    } 
-
-ErrExit:
-    return hr;
-} // HRESULT CImportTlb::GenerateUniqueMemberName()
-
-//*****************************************************************************
-// Convert a TYPEDESC to a COM+ signature.
-//
-// Conversion rules:
-//  integral types are converted as-is.
-//  strings to strings, with native type decoration.
-//  VT_UNKNOWN, VT_DISPATCH as ref class (ie, Object)
-//  VT_PTR -> VT_USERDEFINED interface as Object
-//  VT_USERDEFINED record as value type.
-//
-// With SIG_FUNC:
-//  PTR to valuetype depends on other flags:
-//   [IN] or [RETVAL] valuetype + NATIVE_TYPE_LPSTRUCT
-//   [OUT] or [IN, OUT] byref valuetype 
-//  PTR to integral type:
-//   [IN] @todo: see atti
-//   [OUT] [IN, OUT] byref type
-//   [RETVAL] type
-//  PTR to object
-//   [IN] @todo: see atti
-//   [OUT] [IN, OUT] byref object
-//   [RETVAL] object
-// 
-// With SIG_FIELD:
-//  PTR to integral type adds ELEMENT_TYPE_PTR.
-//
-// Conversion proceeds in three steps.
-//  1) Parse the COM type info.  Accumulate VT_PTR and VT_BYREF into a count
-//     of indirections.  Follow TKIND_ALIAS to determine the ultimate aliased
-//     type, and for non-user-defined types, convert that ultimate type.
-//     Collect array sizes and udt names.  Determine element type and native
-//     type.
-//  2) Normalize to COM+ types.  Determine if there is conversion loss.
-//  3) Emit the COM+ signature.  Recurse to handle array types.  Add native
-//     type info if there is any.
-//*****************************************************************************
-#ifdef _PREFAST_
-#pragma warning(push)
-#pragma warning(disable:21000) // Suppress PREFast warning about overly large function
-#endif
-HRESULT CImportTlb::_ConvSignature(     // S_OK, S_CONVERSION_LOSS, or error.
-    ITypeInfo   *pITI,                  // [IN] The typeinfo containing the TYPEDESC.
-    const TYPEDESC *pType,              // [IN] The TYPEDESC to convert.
-    ULONG       Flags,                  // [IN] Flags describing the TYPEDESC.
-    CQuickBytes &qbSigBuf,              // [IN, OUT] A CQuickBytes containing the signature.
-    ULONG       cbSig,                  // [IN] Where to start building the signature.
-    ULONG       *pcbSig,                // [OUT] Where the signature ends (ix of first byte past; where to start next).
-    CQuickArray<BYTE> &qbNativeTypeBuf, // [IN, OUT] A CQuickBytes containing the native type.
-    ULONG       cbNativeType,           // [IN] Where to start building the native type.
-    ULONG       *pcbNativeType,         // [OUT] Where the native type ends (ix of first byte past; where to start next).
-    BOOL        bNewEnumMember,         // [IN] A flag indicating if the member is the NewEnum member.
-    int         iByRef)                 // [IN] ByRef count of caller (for recursive calls).
-{
-    HRESULT     hr=S_OK;                // A result.
-    TYPEDESC    tdTemp;                 // Copy of TYPEDESC, for R/W.
-    VARTYPE     vt;                     // The typelib signature element.
-    int         bByRef=false;           // If true, convert first pointer as "ELEMENT_TYPE_BYREF".
-    COR_SIGNATURE et=0;                 // The COM+ signature element.
-    mdToken     tk=0;                   // Token from some COM+ signature element.
-    ULONG       nt=NATIVE_TYPE_NONE;    // Native type decoration.
-    ITypeInfo   *pITIAlias=0;           // Typeinfo of the aliased type.
-    TYPEATTR    *psAttrAlias=0;         // TYPEATTR of the aliased typeinfo.
-    ITypeInfo   *pITIUD=0;              // TypeInfo of an aliased UserDefined type.
-    ITypeLib    *pITLBUD=0;             // TypeLib of an aliased UserDefined type.
-    BSTR        bstrNamespace=0;        // Namespace name.
-    BSTR        bstrName=0;             // UserDefined name.
-    int         bConversionLoss=false;  // If true, the conversion was lossy.
-    BYTE        *pbSig;                 // Byte pointer for easy pointer math.
-    ULONG       cb;                     // Size of a signature element.
-    ULONG       cElems=0;               // Count of elements in an array.
-    int         i;                      // Loop control.
-    TYPEATTR    *psAttr = 0;            // The TYPEATTR for the user defined type being converted.
-    const StdConvertibleItfInfo *pConvertionInfo = 0; // The standard convertible interface information.
-    CQuickArray<BYTE> qbNestedNativeType;// A native type buffer used for array sig convertion.
-    ULONG       iNestedNativeTypeOfs=0;  // A native type offset.
-    ULONG       nested=NATIVE_TYPE_NONE; // A nested native type.
-
-    // VT_ to ELEMENT_TYPE_ translation table.
-    struct VtSig 
-    {
-        CorElementType  et;
-        CorNativeType   nt;
-        short           flags;
-    };
-
-    // The VARIANT_TYPE to sig mapping table. 
-    static const VtSig
-    _VtInfo[MAX_TLB_VT] =
-    {   
-        // Relies on {0} initializing the entire sub-structure to 0.
-        {ELEMENT_TYPE_MAX,      NATIVE_TYPE_NONE, 0},       //    VT_EMPTY        = 0
-        {ELEMENT_TYPE_MAX,      NATIVE_TYPE_NONE, 0},       //    VT_NULL         = 1
-        {ELEMENT_TYPE_I2,       NATIVE_TYPE_NONE, 0},       //    VT_I2           = 2
-        {ELEMENT_TYPE_I4,       NATIVE_TYPE_NONE, 0},       //    VT_I4           = 3
-        {ELEMENT_TYPE_R4,       NATIVE_TYPE_NONE, 0},       //    VT_R4           = 4
-        {ELEMENT_TYPE_R8,       NATIVE_TYPE_NONE, 0},       //    VT_R8           = 5
-        {ELEMENT_TYPE_VALUETYPE,NATIVE_TYPE_CURRENCY, 0},   //    VT_CY           = 6
-        {ELEMENT_TYPE_VALUETYPE,NATIVE_TYPE_NONE, 0},       //    VT_DATE         = 7
-        {ELEMENT_TYPE_STRING,   NATIVE_TYPE_BSTR, 0},       //    VT_BSTR         = 8
-        {ELEMENT_TYPE_OBJECT,   NATIVE_TYPE_IDISPATCH, 0},  //    VT_DISPATCH     = 9
-        {ELEMENT_TYPE_I4,       NATIVE_TYPE_ERROR, 0},      //    VT_ERROR        = 10 scode
-        {ELEMENT_TYPE_BOOLEAN,  NATIVE_TYPE_NONE, 0},       //    VT_BOOL         = 11
-        {ELEMENT_TYPE_OBJECT,   NATIVE_TYPE_STRUCT, 0},     //    VT_VARIANT      = 12
-        {ELEMENT_TYPE_OBJECT,   NATIVE_TYPE_IUNKNOWN, 0},   //    VT_UNKNOWN      = 13
-        {ELEMENT_TYPE_VALUETYPE,NATIVE_TYPE_NONE, 0},       //    VT_DECIMAL      = 14
-        {ELEMENT_TYPE_MAX,      NATIVE_TYPE_NONE, 0},       //                    = 15
-        {ELEMENT_TYPE_I1,       NATIVE_TYPE_NONE, 0},       //    VT_I1           = 16
-        {ELEMENT_TYPE_U1,       NATIVE_TYPE_NONE, 0},       //    VT_UI1          = 17
-        {ELEMENT_TYPE_U2,       NATIVE_TYPE_NONE, 0},       //    VT_UI2          = 18
-        {ELEMENT_TYPE_U4,       NATIVE_TYPE_NONE, 0},       //    VT_UI4          = 19
-        {ELEMENT_TYPE_I8,       NATIVE_TYPE_NONE, 0},       //    VT_I8           = 20
-        {ELEMENT_TYPE_U8,       NATIVE_TYPE_NONE, 0},       //    VT_UI8          = 21
-        
-    // it would be nice to convert these as I and U, with NT_I4 and NT_U4, but that doesn't work.
-        {ELEMENT_TYPE_I4,       NATIVE_TYPE_NONE, 0},       //    VT_INT          = 22     INT is I4 on win32
-        {ELEMENT_TYPE_U4,       NATIVE_TYPE_NONE, 0},       //    VT_UINT         = 23     UINT is UI4 on win32
-
-        {ELEMENT_TYPE_VOID,     NATIVE_TYPE_NONE, 0},       //    VT_VOID         = 24
-    
-        {ELEMENT_TYPE_I4,       NATIVE_TYPE_ERROR, 0},      //    VT_HRESULT      = 25
-        {ELEMENT_TYPE_MAX,      NATIVE_TYPE_NONE, 0},       //    VT_PTR          = 26
-        {ELEMENT_TYPE_MAX,      NATIVE_TYPE_NONE, 0},       //    VT_SAFEARRAY    = 27
-        {ELEMENT_TYPE_SZARRAY,  NATIVE_TYPE_FIXEDARRAY, 0}, //    VT_CARRAY       = 28
-        {ELEMENT_TYPE_MAX,      NATIVE_TYPE_NONE, 0},       //    VT_USERDEFINED  = 29
-        {ELEMENT_TYPE_STRING,   NATIVE_TYPE_LPSTR, 0},      //    VT_LPSTR        = 30
-        {ELEMENT_TYPE_STRING,   NATIVE_TYPE_LPWSTR, 0},     //    VT_LPWSTR       = 31
-    };
-
-    _ASSERTE(pType && pcbSig &&  pcbNativeType);
-
-    //-------------------------------------------------------------------------
-    // Parse COM signature
-
-    // Strip off leading VT_PTR and VT_BYREF
-    while (pType->vt == VT_PTR)
-        pType = pType->lptdesc, ++iByRef;
-    if (pType->vt & VT_BYREF)
-    {
-        tdTemp = *pType;
-        tdTemp.vt &= ~VT_BYREF;
-        ++iByRef;
-        pType = &tdTemp;
-    }
-
-    // Determine the element type, and possibly the token and/or native type.
-    switch (vt=pType->vt)
-    { 
-    case VT_PTR:
-        _ASSERTE(!"Should not have VT_PTR here");
-        break;
-
-    // These are all known types (plus GUID).
-    case VT_CY:
-    case VT_DATE:
-    case VT_DECIMAL:
-        IfFailGo(GetKnownTypeToken(vt, &tk));
-        et = _VtInfo[vt].et;
-        nt = _VtInfo[vt].nt;
-        break;
-
-    case VT_SAFEARRAY:
-        if (m_bSafeArrayAsSystemArray && !IsSigVarArg(Flags))
-        {
-            IfFailGo(GetKnownTypeToken(vt, &tk));
-            et = ELEMENT_TYPE_CLASS;
-            nt = NATIVE_TYPE_SAFEARRAY;
-        }
-        else
-        {
-            IfFailGo(GetKnownTypeToken(vt, &tk));
-            et = ELEMENT_TYPE_SZARRAY;
-            nt = NATIVE_TYPE_SAFEARRAY;
-        }
-        break;
-
-    case VT_USERDEFINED:
-        // Resolve the alias to the ultimate aliased type.
-        IfFailGo(_ResolveTypeDescAlias(pITI, pType, &pITIAlias, &psAttrAlias));
-
-        // If the aliased type was built-in, convert that built-in type.
-        if (psAttrAlias->typekind == TKIND_ALIAS)
-        {   // Recurse to follow the alias chain.
-            _ASSERTE(psAttrAlias->tdescAlias.vt != VT_USERDEFINED);
-            hr = _ConvSignature(pITIAlias, &psAttrAlias->tdescAlias, Flags, qbSigBuf, cbSig, pcbSig, qbNativeTypeBuf, cbNativeType, pcbNativeType, bNewEnumMember, iByRef);
-            goto ErrExit;
-        }
-
-        // If the type is a coclass then we need to retrieve the default interface and
-        //  substitute it for the coclass.  Look up on the resolved alias, because it is
-        //  that class that has a default interface.
-        if (psAttrAlias->typekind == TKIND_COCLASS)
-        {
-            ITypeInfo *pDefaultItf = NULL;
-            hr = GetDefaultInterface(pITIAlias, &pDefaultItf);
-            if ((hr != S_OK) || !pDefaultItf)
-            {
-                hr = E_UNEXPECTED;
-                goto ErrExit;
-            }
-
-            pITIUD = pDefaultItf;
-        }
-        else
-        {   // USERDEFINED class/interface/record/union/enum.  Retrieve the type 
-            //  info for the user defined type.  Note: use the TKIND_ALIAS typeinfo 
-            //  itself for this conversion (not the aliased type) to preserve 
-            //  names, lib locations, etc.
-            IfFailGo(pITI->GetRefTypeInfo(pType->hreftype, &pITIUD));
-        }
-
-        // pITIUD points to the typeinfo for which we'll create a signature.
-        IfFailGo(pITIUD->GetDocumentation(MEMBERID_NIL, &bstrName, 0,0,0));
-        IfFailGo(pITIUD->GetContainingTypeLib(&pITLBUD, 0));
-        IfFailGo(pITIUD->GetTypeAttr(&psAttr));
-        IfFailGo(GetNamespaceNameForTypeLib(pITLBUD, &bstrNamespace));
-
-        // If the "User Defined Type" is GUID in StdOle2, convert to M.R.GUID
-        if (SString::_wcsicmp(bstrNamespace, COM_STDOLE2) == 0 && wcscmp(bstrName, COM_GUID) == 0)
-        {   // Classlib valuetype GUID.
-            et = ELEMENT_TYPE_VALUETYPE;
-            IfFailGo(GetKnownTypeToken(VT_SLOT_FOR_GUID, &tk));
-        }
-        else
-        {   // Some user defined class.  Is it a value class, or a VOS class?
-            tk = 0;
-            switch (psAttrAlias->typekind)
-            {
-            case TKIND_RECORD:
-            case TKIND_ENUM:
-            case TKIND_UNION:
-                et = ELEMENT_TYPE_VALUETYPE;
-                break;
-            case TKIND_INTERFACE:
-            case TKIND_DISPATCH:
-            case TKIND_COCLASS:
-                // A pointer to a user defined type of interface/dispatch/coclass 
-                //  is a straight COM+ object (the ref is implicit), so eliminate 
-                //  one byref count for those.
-                // Somehow, there are typelibs written with ([out, retval] IFoo *pOut);
-                if (iByRef <= 0)
-                {   
-                    // convert to an int.
-                    bConversionLoss = true;
-                    tk = 0;
-                    et = ELEMENT_TYPE_I;
-                    nt = NATIVE_TYPE_NONE;
-                    iByRef = 0;
-                    break;
-                }
-                else
-                {
-                    --iByRef;
-
-                    // Check for references to Stdole2.IUnknown or Stdole2.IDispatch.
-                    if (psAttr->guid == IID_IUnknown)
-                    {
-                        vt = VT_UNKNOWN;
-                        goto IsReallyUnknown;
-                    }
-                    else if (psAttr->guid == IID_IDispatch)
-                    {
-                        vt = VT_DISPATCH;
-                        goto IsReallyUnknown;
-                    }
-                    
-                    // Check to see if this user defined type is one of the standard ones
-                    // we generate custom marshalers for.
-                    pConvertionInfo = GetConvertionInfoFromNativeIID(psAttr->guid);
-                    if (pConvertionInfo)
-                    {
-                        // Convert the UTF8 string to unicode.
-                        int MngTypeNameStrLen = (int)(strlen(pConvertionInfo->m_strMngTypeName) + 1);
-                        WCHAR *strFullyQualifiedMngTypeName = (WCHAR *)_alloca(MngTypeNameStrLen * sizeof(WCHAR));
-                        int ret = WszMultiByteToWideChar(CP_UTF8, 0, pConvertionInfo->m_strMngTypeName, MngTypeNameStrLen, strFullyQualifiedMngTypeName, MngTypeNameStrLen);
-                        _ASSERTE(ret != 0);
-                        if (!ret)
-                            IfFailGo(HRESULT_FROM_GetLastError());
-
-                        // Create a TypeRef to the marshaller.
-                        IfFailGo(m_TRMap.DefineTypeRef(m_pEmit, m_arSystem, strFullyQualifiedMngTypeName, &tk));
-
-                        // The type is a standard interface that we need to convert.
-                        et = ELEMENT_TYPE_CLASS;
-                        nt = NATIVE_TYPE_CUSTOMMARSHALER;
-                        break;
-                    }
-                }
-                et = ELEMENT_TYPE_CLASS;
-                nt = NATIVE_TYPE_INTF;
-                break;
-            default:
-                //case TKIND_MODULE: -- can't pass one of these as a parameter.
-                //case TKIND_ALIAS: -- should already be resolved.
-                _ASSERTE(!"Unexpected typekind for user defined type");
-                et = ELEMENT_TYPE_END;
-            } // switch (psAttrAlias->typekind)
-        }
-        break;
-
-    IsReallyUnknown:
-    case VT_UNKNOWN:
-    case VT_DISPATCH:
-        // If the NewEnum member, retrieve the custom marshaler information for IEnumVARIANT.
-        if (bNewEnumMember && (pConvertionInfo=GetConvertionInfoFromNativeIID(IID_IEnumVARIANT)))
-        {
-            // Convert the UTF8 string to unicode.
-            int MngTypeNameStrLen = (int)(strlen(pConvertionInfo->m_strMngTypeName) + 1);
-            WCHAR *strFullyQualifiedMngTypeName = (WCHAR *)_alloca(MngTypeNameStrLen * sizeof(WCHAR));
-            int ret = WszMultiByteToWideChar(CP_UTF8, 0, pConvertionInfo->m_strMngTypeName, MngTypeNameStrLen, strFullyQualifiedMngTypeName, MngTypeNameStrLen);
-            _ASSERTE(ret != 0);
-            if (!ret)
-                IfFailGo(HRESULT_FROM_GetLastError());
-
-            // Create a TypeRef to the marshaller.
-            IfFailGo(m_TRMap.DefineTypeRef(m_pEmit, m_arSystem, strFullyQualifiedMngTypeName, &tk));
-
-            // The type is a standard interface that we need to convert.
-            et = ELEMENT_TYPE_CLASS;
-            nt = NATIVE_TYPE_CUSTOMMARSHALER;
-        }
-        else
-        {
-            et = _VtInfo[vt].et;
-            nt = _VtInfo[vt].nt;
-        }
-        break;
-
-    case VT_CARRAY:
-        // Determine the count of elements.
-        for (cElems=1, i=0; i<pType->lpadesc->cDims; ++i)
-            cElems *= pType->lpadesc->rgbounds[i].cElements;
-
-        // Set the native type based on weither we are dealing with a field or a method sig.
-        if (IsSigField(Flags))
-        {
-            nt = NATIVE_TYPE_FIXEDARRAY;
-        }
-        else
-        {
-            nt = NATIVE_TYPE_ARRAY;
-        }
-
-        // Set the element type.
-        et = _VtInfo[vt].et;
-        break;
-
-    case VT_BOOL:
-        // Special case for VARIANT_BOOL: If a field of a struct or union, convert
-        //  as ET_I2.
-        if (IsSigField(Flags))
-            vt = VT_I2;
-        // Fall through to default case.
-
-    default:
-        if (vt > VT_LPWSTR)
-        {
-            ReportEvent(NOTIF_CONVERTWARNING, TLBX_E_BAD_VT_TYPE, vt, m_szName, m_szMember);
-            IfFailGo(PostError(TLBX_E_BAD_VT_TYPE, vt, m_szName, m_szMember));
-        }
-        _ASSERTE(vt <= VT_LPWSTR && _VtInfo[vt].et != ELEMENT_TYPE_MAX);
-#ifdef _PREFAST_
-#pragma warning(push)
-#pragma warning(disable:26000) // "Disable PREFast/espX warning about buffer overflow"
-#endif
-        et = _VtInfo[vt].et;
-        nt = _VtInfo[vt].nt;
-#ifdef _PREFAST_
-#pragma warning(pop)
-#endif
-        break;
-    } // switch (vt=pType->vt)
-
-    //-------------------------------------------------------------------------
-    // Normalize to COM+ types.
-
-    // At this point the type, flags, and pointer nesting are known.  Is this a legal combination?
-    //  If not, what is the appropriate "simplifing assumption"?
-
-    if (et == ELEMENT_TYPE_VOID)
-    {
-        if (IsSigField(Flags))
-        {   // A void as a field.  No byref.
-            iByRef = 0;
-        }
-        else
-        {   
-            // Param or return type.  "void *" -> ET_I, "void **", "void ***",... -> ET_BYREF ET_I
-            if (iByRef > 1)
-                iByRef = 1;
-            else
-            if (iByRef == 1)
-                iByRef = 0;
-        }
-        tk = 0;
-        et = ELEMENT_TYPE_I;
-        nt = NATIVE_TYPE_NONE;
-    }
-
-    if (et == ELEMENT_TYPE_STRING && iByRef == 0 && !IsSigField(Flags) && IsSigOut(Flags))
-    {
-        // This is an [out] or [in, out] string parameter without indirections.
-        if (vt == VT_BSTR)
-        {
-            // [in, out] System.String does not make much sense. Managed strings are
-            // immutable and we do not have BSTR <-> StringBuilder marshaling support.
-            // Convert them to IntPtr.
-            bConversionLoss = true;
-            tk = 0;
-            et = ELEMENT_TYPE_I;
-            nt = NATIVE_TYPE_NONE;
-        }
-        else
-        {
-            _ASSERTE(vt == VT_LPSTR || vt == VT_LPWSTR);
-
-            // [in, out] C-strings and wide strings have a lossless conversion to StringBuilder.
-            IfFailGo(GetKnownTypeToken(VT_SLOT_FOR_STRINGBUF, &tk));
-            et = ELEMENT_TYPE_CLASS;
-
-            // nt already has the right value
-            _ASSERTE(nt == (vt == VT_LPSTR ? NATIVE_TYPE_LPSTR : NATIVE_TYPE_LPWSTR));
-        }
-    }
-
-    if (iByRef)
-    {
-        if (et == ELEMENT_TYPE_VALUETYPE && iByRef >= 2)
-        {
-            bConversionLoss = true;
-            tk = 0;
-            et = ELEMENT_TYPE_I;
-            nt = NATIVE_TYPE_NONE;
-            iByRef = 0;
-        }
-        else
-        {
-            switch (Flags & SIG_TYPE_MASK)
-            {
-            case SIG_FIELD:
-                // If ptr to valuetype or class type, we can't handle it.
-                if (et == ELEMENT_TYPE_END || 
-                    et == ELEMENT_TYPE_CLASS || 
-                    et == ELEMENT_TYPE_OBJECT || 
-                    et == ELEMENT_TYPE_VALUETYPE)
-                {
-                    bConversionLoss = true;
-                    tk = 0;
-                    et = ELEMENT_TYPE_I;
-                    nt = NATIVE_TYPE_NONE;
-                    iByRef = 0;
-                }
-                break;
-            case SIG_FUNC:
-                // Pointer to value type?
-                if (et == ELEMENT_TYPE_VALUETYPE)
-                {   
-                    // For [retval], eat one level of indirection; otherwise turn one into BYREF
-                    if (IsSigOutRet(Flags))
-                    {   // [out, retval], so reduce one level of indirection.
-                        --iByRef;
-                    }
-                    else
-                    {   // Favor BYREF over NATIVE_TYPE_LPSTRUCT
-                        if (IsSigUseByref(Flags))
-                        {
-                            bByRef = true;
-                            --iByRef;
-                        }
-                        if (iByRef > 0)
-                        {
-                            nt = NATIVE_TYPE_LPSTRUCT;
-                            --iByRef;
-                        }
-                    }
-                }
-                else // Pointer to Object or base type.
-                {   
-                    if (IsSigRet(Flags))
-                    {   // [retval] so consume one indirection.
-                        _ASSERTE(iByRef > 0);
-                        --iByRef;
-                    }
-                    if (iByRef > 0 && IsSigUseByref(Flags))
-                    {
-                        bByRef = true;
-                        --iByRef;
-                    }
-                }
-                break;
-            case SIG_ELEM:
-                // This case comes up when a property type is from a [retval].
-                if (IsSigRet(Flags))
-                {
-                    if (iByRef > 0)
-                        --iByRef;
-                }
-                break;
-            }
-        }
-    } // if (iByRef)
-
-    //-------------------------------------------------------------------------
-    // We don't want any ET_PTR, so if there are any byref counts left, bail.
-    if (iByRef)
-    {
-        bConversionLoss = true;
-        tk = 0;
-        et = ELEMENT_TYPE_I;
-        nt = NATIVE_TYPE_NONE;
-        iByRef = 0;
-        bByRef = false;
-    }
-    
-    //-------------------------------------------------------------------------
-    // Build COM+ signature.
-
-    // Type has been analyzed, and possibly modified.  Emit the COM+ signature.
-    _ASSERTE(et != ELEMENT_TYPE_MAX);
-    _ASSERTE(et != ELEMENT_TYPE_END);
-
-    // If it is a pointer to something, emit that now.
-    if (bByRef || iByRef)
-    {
-        // Size the array to hold the elements.
-        IfFailGo(qbSigBuf.ReSizeNoThrow(cbSig + CB_MAX_ELEMENT_TYPE * (iByRef+(bByRef?1:0))));
-        pbSig = reinterpret_cast<BYTE*>(qbSigBuf.Ptr());
-
-        // Put in any leading "BYREF"
-        if (bByRef)
-        {
-            pbSig = reinterpret_cast<BYTE*>(qbSigBuf.Ptr());
-            cb = CorSigCompressData(ELEMENT_TYPE_BYREF, &pbSig[cbSig]);
-            cbSig += cb;
-        }
-
-        // Put in the "PTR"s.
-        while (iByRef-- > 0)
-        {
-            cb = CorSigCompressData(ELEMENT_TYPE_PTR, &pbSig[cbSig]);
-            cbSig += cb;
-        }
-    }
-
-    // Emit the type.
-    IfFailGo(qbSigBuf.ReSizeNoThrow(cbSig + CB_MAX_ELEMENT_TYPE));
-    pbSig = reinterpret_cast<BYTE*>(qbSigBuf.Ptr());
-    cb = CorSigCompressData(et, &pbSig[cbSig]);
-    cbSig += cb;
-
-    // Add the class type, the array information, etc.
-    switch (et)
-    {
-    case ELEMENT_TYPE_CLASS:
-    case ELEMENT_TYPE_VALUETYPE:
-        // Size the array to hold the token.
-        IfFailGo(qbSigBuf.ReSizeNoThrow(cbSig + CB_MAX_ELEMENT_TYPE));
-        pbSig = reinterpret_cast<BYTE*>(qbSigBuf.Ptr());
-
-        // If the token hasn't been resolved yet, do that now.
-        if (tk == 0)
-        {
-            _ASSERTE(pITIUD);
-            IfFailGo(_GetTokenForTypeInfo(pITIUD, TRUE, &tk));
-        }
-        cb = CorSigCompressToken(tk, reinterpret_cast<ULONG*>(&pbSig[cbSig]));
-        cbSig += cb;
-        break;
-
-    case ELEMENT_TYPE_SZARRAY:
-        // map to SZARRAY <subtype>
-        IfFailGo(qbSigBuf.ReSizeNoThrow(cbSig + CB_MAX_ELEMENT_TYPE));
-        pbSig = reinterpret_cast<BYTE*>(qbSigBuf.Ptr());
-        // Recurse on the type.
-        IfFailGo(_ConvSignature(pITI, &pType->lpadesc->tdescElem, SIG_ELEM, qbSigBuf, cbSig, &cbSig, qbNestedNativeType, 0, &iNestedNativeTypeOfs, bNewEnumMember));
-        if (hr == S_CONVERSION_LOSS)
-            bConversionLoss = true;
-        break;
-
-    case VT_DISPATCH:       
-    case VT_UNKNOWN:
-    default:
-        _ASSERTE(tk == 0);
-        // et, nt assigned above.
-        break;
-    } // switch (et)
-
-    // Do any native type info.
-    if (nt != NATIVE_TYPE_NONE) 
-    {
-        if (iNestedNativeTypeOfs > 0)
-            CorSigUncompressData(reinterpret_cast<PCCOR_SIGNATURE>(qbNestedNativeType.Ptr()), &nested);
-        
-        if (nt == NATIVE_TYPE_FIXEDARRAY)
-        {
-            IfFailGo(qbNativeTypeBuf.ReSizeNoThrow(cbNativeType + NATIVE_TYPE_MAX_CB * 2 + DWORD_MAX_CB));
-            cbNativeType += CorSigCompressData(nt, &qbNativeTypeBuf[cbNativeType]);
-            cbNativeType += CorSigCompressData(cElems, &qbNativeTypeBuf[cbNativeType]);
-            if (nested == NATIVE_TYPE_BSTR || nested == NATIVE_TYPE_LPWSTR || nested == NATIVE_TYPE_LPSTR)
-            {   // Use the nested type.
-                cbNativeType += CorSigCompressData(nested, &qbNativeTypeBuf[cbNativeType]);
-            }
-            else
-            {   // Use a default sub type.
-                cbNativeType += CorSigCompressData(NATIVE_TYPE_MAX, &qbNativeTypeBuf[cbNativeType]);
-            }            
-        }
-        else if (nt == NATIVE_TYPE_ARRAY)
-        {
-            IfFailGo(qbNativeTypeBuf.ReSizeNoThrow(cbNativeType + NATIVE_TYPE_MAX_CB * 2 + DWORD_MAX_CB * 2));
-            cbNativeType += CorSigCompressData(nt, &qbNativeTypeBuf[cbNativeType]);
-            if (nested == NATIVE_TYPE_BSTR || nested == NATIVE_TYPE_LPWSTR || nested == NATIVE_TYPE_LPSTR)
-            {   // Use the nested type.
-                cbNativeType += CorSigCompressData(nested, &qbNativeTypeBuf[cbNativeType]);
-            }
-            else
-            {   // Use a default sub type.
-                cbNativeType += CorSigCompressData(NATIVE_TYPE_MAX, &qbNativeTypeBuf[cbNativeType]);
-            }
-            // Use zero for param index.
-            cbNativeType += CorSigCompressData(0, &qbNativeTypeBuf[cbNativeType]);
-            // Use count from typelib for elem count.
-            cbNativeType += CorSigCompressData(cElems, &qbNativeTypeBuf[cbNativeType]);
-        }
-        else if (nt == NATIVE_TYPE_SAFEARRAY)
-        {
-            BOOL bPtrArray = FALSE;
-            CQuickArray<WCHAR> rTemp;
-            CQuickArray<char> rTypeName;
-            LPUTF8 strTypeName = "";
-            TYPEDESC *pTypeDesc = &pType->lpadesc->tdescElem;
-            VARTYPE ArrayElemVT = pTypeDesc->vt;
-
-            if (ArrayElemVT == VT_PTR)
-            {
-                bPtrArray = TRUE;
-                pTypeDesc = pType->lpadesc->tdescElem.lptdesc;
-                ArrayElemVT = pTypeDesc->vt;
-                if ((ArrayElemVT != VT_USERDEFINED) && (ArrayElemVT != VT_VOID))
-                {
-                    // We do not support deep marshalling pointers.
-                    ArrayElemVT = VT_INT;
-                    bConversionLoss = TRUE;
-                }
-            }
-
-            // If we are dealing with a safe array of user defined types and if we 
-            // are importing safe array's as System.Array then add the SafeArrayUserDefSubType.
-            if (ArrayElemVT == VT_USERDEFINED)
-            {
-                // Resolve the alias to the ultimate aliased type.
-                IfFailGo(_ResolveTypeDescAlias(pITI, pTypeDesc, &pITIAlias, &psAttrAlias));
-
-                // If the type is a coclass then we need to retrieve the default interface and
-                //  substitute it for the coclass.  Look up on the resolved alias, because it is
-                //  that class that has a default interface.
-                if (psAttrAlias->typekind == TKIND_COCLASS)
-                {
-                    ITypeInfo *pDefaultItf = NULL;
-                    hr = GetDefaultInterface(pITIAlias, &pDefaultItf);
-                    if ((hr != S_OK) || !pDefaultItf)
-                    {
-                        hr = E_UNEXPECTED;
-                        goto ErrExit;
-                    }
-
-                    pITIUD = pDefaultItf;
-                }
-                else
-                {   // USERDEFINED interface/record/union/enum.  Retrieve the type 
-                    //  info for the user defined type.  Note: use the TKIND_ALIAS typeinfo 
-                    //  itself for this conversion (not the aliased type) to preserve 
-                    //  names, lib locations, etc.
-                    IfFailGo(pITI->GetRefTypeInfo(pTypeDesc->hreftype, &pITIUD));
-                }
-
-                // pITIUD points to the typeinfo for which we'll create a signature.
-                IfFailGo(pITIUD->GetTypeAttr(&psAttr));
-
-                // Get the typeref name for the type.
-                for(;;)
-                {
-                    int cchReq;
-                    mdToken tkDummy;
-                    IfFailGo(_GetTokenForTypeInfo(pITIUD, TRUE, &tkDummy, rTemp.Ptr(), (int)rTemp.MaxSize(), &cchReq, TRUE));
-                    if (cchReq <= (int)rTemp.MaxSize())
-                        break;
-                    IfFailGo(rTemp.ReSizeNoThrow(cchReq));
-                }
-
-                // Convert the type name to UTF8.
-                ULONG cbReq = WszWideCharToMultiByte(CP_UTF8, 0, rTemp.Ptr(), -1, 0, 0, 0, 0);
-                IfFailGo(rTypeName.ReSizeNoThrow(cbReq + 1));
-                WszWideCharToMultiByte(CP_UTF8, 0, rTemp.Ptr(), -1, rTypeName.Ptr(), cbReq, 0, 0);
-
-                // Determine the safe array element VT.
-                switch (psAttrAlias->typekind)
-                {
-                    case TKIND_RECORD:
-                    case TKIND_ENUM:
-                    case TKIND_UNION:
-                        if (bPtrArray)
-                        {
-                            ArrayElemVT = VT_INT;
-                            bConversionLoss = TRUE;
-                        }
-                        else
-                        {
-                            ArrayElemVT = psAttrAlias->typekind == TKIND_ENUM ? VT_I4 : VT_RECORD;
-                            strTypeName = rTypeName.Ptr();
-                        }
-                        break;
-
-                    case TKIND_INTERFACE:
-                    case TKIND_DISPATCH:
-                    case TKIND_COCLASS:
-                        if (!bPtrArray)
-                        {
-                            ArrayElemVT = VT_INT;
-                            bConversionLoss = TRUE;
-                        }
-                        else
-                        {
-                            if (IsIDispatchDerived(pITIUD, psAttr) == S_FALSE)
-                                ArrayElemVT = VT_UNKNOWN;
-                            else
-                                ArrayElemVT = VT_DISPATCH;
-                            strTypeName = rTypeName.Ptr();
-                        }
-                        break;
-                }
-
-                // If we are not converting the SAFEARRAY to a System.Array, then
-                // we don't need to encode the name of the user defined type.
-                if (!m_bSafeArrayAsSystemArray)
-                    strTypeName = "";
-            }
-
-            // Make sure the native type buffer is large enough.
-            ULONG TypeNameStringLen = (ULONG)strlen(strTypeName);
-            IfFailGo(qbNativeTypeBuf.ReSizeNoThrow(cbNativeType + NATIVE_TYPE_MAX_CB * 2 + DWORD_MAX_CB + TypeNameStringLen + STRING_OVERHEAD_MAX_CB));
-
-            // Add the native type to the native type info.
-            cbNativeType += CorSigCompressData(nt, &qbNativeTypeBuf[cbNativeType]);
-
-            // Add the VARTYPE of the array.
-            cbNativeType += CorSigCompressData(ArrayElemVT, &qbNativeTypeBuf[cbNativeType]);
-
-            // Add the type name to the native type info.
-            BYTE *pNativeType = (BYTE*)CPackedLen::PutLength(&qbNativeTypeBuf[cbNativeType], TypeNameStringLen);
-            cbNativeType += (ULONG)(pNativeType - &qbNativeTypeBuf[cbNativeType]);
-            memcpy(&qbNativeTypeBuf[cbNativeType], strTypeName, TypeNameStringLen);
-            cbNativeType += TypeNameStringLen;
-        }
-        else if (nt == NATIVE_TYPE_CUSTOMMARSHALER)
-        {
-            // Calculate the length of each string and then the total length of the native type info.
-            ULONG MarshalerTypeNameStringLen = (ULONG)strlen(pConvertionInfo->m_strCustomMarshalerTypeName);
-            ULONG CookieStringLen = (ULONG)strlen(pConvertionInfo->m_strCookie);
-            ULONG TotalNativeTypeLen = MarshalerTypeNameStringLen + CookieStringLen;
-            BYTE *pNativeType = 0;
-
-            // Make sure the native type buffer is large enough.
-            IfFailGo(qbNativeTypeBuf.ReSizeNoThrow(cbNativeType + NATIVE_TYPE_MAX_CB + TotalNativeTypeLen + STRING_OVERHEAD_MAX_CB * 4));
-
-            // Add the native type to the native type info.
-            cbNativeType += CorSigCompressData(nt, &qbNativeTypeBuf[cbNativeType]);
-
-            // Add an empty string for the typelib guid.
-            pNativeType = (BYTE*)CPackedLen::PutLength(&qbNativeTypeBuf[cbNativeType], 0);
-            cbNativeType += (ULONG)(pNativeType - &qbNativeTypeBuf[cbNativeType]);
-
-            // Add an empty string for the unmanaged type name.
-            pNativeType = (BYTE*)CPackedLen::PutLength(&qbNativeTypeBuf[cbNativeType], 0);
-            cbNativeType += (ULONG)(pNativeType - &qbNativeTypeBuf[cbNativeType]);
-
-            // Add the name of the custom marshaler to the native type info.
-            pNativeType = (BYTE*)CPackedLen::PutLength(&qbNativeTypeBuf[cbNativeType], MarshalerTypeNameStringLen);
-            cbNativeType += (ULONG)(pNativeType - &qbNativeTypeBuf[cbNativeType]);
-            memcpy(&qbNativeTypeBuf[cbNativeType], pConvertionInfo->m_strCustomMarshalerTypeName, MarshalerTypeNameStringLen);
-            cbNativeType += MarshalerTypeNameStringLen;
-
-            // Add the cookie to the native type info.
-            pNativeType = (BYTE*)CPackedLen::PutLength(&qbNativeTypeBuf[cbNativeType], CookieStringLen);
-            cbNativeType += (ULONG)(pNativeType - &qbNativeTypeBuf[cbNativeType]);
-            memcpy(&qbNativeTypeBuf[cbNativeType], pConvertionInfo->m_strCookie, CookieStringLen);
-            cbNativeType += CookieStringLen;
-        }
-        else
-        {
-            IfFailGo(qbNativeTypeBuf.ReSizeNoThrow(cbNativeType + NATIVE_TYPE_MAX_CB + 1));
-            cbNativeType += CorSigCompressData(nt, &qbNativeTypeBuf[cbNativeType]);
-        }
-    }
-
-    // Return the size of the native type to the caller.
-    *pcbNativeType = cbNativeType;
-
-    // Return size to caller.
-    *pcbSig = cbSig;
-
-    // If there was a conversion loss, change the return code.
-    if (bConversionLoss)
-        hr = S_CONVERSION_LOSS;
-
-ErrExit:
-    if (bstrNamespace)
-        ::SysFreeString(bstrNamespace);
-    if (bstrName)
-        ::SysFreeString(bstrName);
-    if(psAttrAlias)
-        pITIAlias->ReleaseTypeAttr(psAttrAlias);
-    if (pITIAlias)
-        pITIAlias->Release();
-    if (psAttr)
-        pITIUD->ReleaseTypeAttr(psAttr);
-    if (pITIUD)
-        pITIUD->Release();
-    if (pITLBUD)
-        pITLBUD->Release();
-
-    return hr;
-} // HRESULT CImportTlb::_ConvSignature()
-#ifdef _PREFAST_
-#pragma warning(pop)
-#endif
-
-//*****************************************************************************
-// Build a sorted list of functions to convert.  (Sort by vtable offset.)
-//*****************************************************************************
-HRESULT CImportTlb::BuildMemberList(
-    ITypeInfo   *pITI,                  // TypeInfo with functions.
-    int         iStart,                 // First function to take.
-    int         iEnd,                   // Last function to take.
-    BOOL        bInheritsIEnum)         // Inherits from IEnumerable.
-{
-    HRESULT     hr;                     // A result.
-    int         bNeedSort = false;      // If true, need to sort the array.
-    int         ix = 0;                 // Loop counter.
-    int         oVftPrev = -1;          // To see if oVft is increasing.
-    TYPEATTR    *psAttr = 0;            // TypeAttr for pITI.
-    FUNCDESC    *psFunc;                // A FUNCDESC.
-    LPWSTR      pszName;                // Working pointer for name.
-    BSTR        bstrName=0;             // Name from typelib.
-    ITypeInfo2  *pITI2=0;               // To get custom attributes.
-    VARIANT     vt;                     // Variant type.
-    BOOL        bFunctionToGetter;      // Did a given getter come from a managed function?
-    
-    ::VariantInit(&vt);
-    
-    IfFailGo(pITI->GetTypeAttr(&psAttr));
-    pITI->QueryInterface(IID_ITypeInfo2, reinterpret_cast<void**>(&pITI2));
-    
-    // Get the vars.
-    IfFailGo(m_MemberList.ReSizeNoThrow(psAttr->cVars + iEnd - iStart));
-    memset(m_MemberList.Ptr(), 0, m_MemberList.Size()*sizeof(MemberInfo));
-    for (ix=0; ix<psAttr->cVars; ++ix)
-    {
-        IfFailGo(pITI->GetVarDesc(ix, &(m_MemberList[ix].m_psVar)));
-        m_MemberList[ix].m_iMember = ix;
-    }
-    m_cMemberProps = psAttr->cVars;
-                    
-    // Get the funcs.
-    for (; iStart<iEnd; ++iStart, ++ix)
-    {
-        IfFailGo(TryGetFuncDesc(pITI, iStart, &(m_MemberList[ix].m_psFunc)));
-        psFunc = m_MemberList[ix].m_psFunc;
-        if (psFunc->oVft < oVftPrev)
-            bNeedSort = true;
-        oVftPrev = psFunc->oVft;
-        m_MemberList[ix].m_iMember = iStart;
-    }
-
-    if (bNeedSort)
-    {
-        class Sorter : public CQuickSort<MemberInfo> 
-        {
-            typedef CImportTlb::MemberInfo MemberInfo;
-        public:
-            Sorter(MemberInfo *p, int n) : CQuickSort<MemberInfo>(p,n) {}
-            virtual int Compare(MemberInfo *p1, MemberInfo *p2)
-            { 
-                if (p1->m_psFunc->oVft < p2->m_psFunc->oVft)
-                    return -1;
-                if (p1->m_psFunc->oVft == p2->m_psFunc->oVft)
-                    return 0;
-                return 1;
-            }
-        };
-        Sorter sorter(m_MemberList.Ptr()+m_cMemberProps, (int)m_MemberList.Size()-m_cMemberProps);
-        sorter.Sort();
-        // Check for duplicates.
-        oVftPrev = -1;
-        for (ix=m_cMemberProps; ix<(int)m_MemberList.Size(); ++ix)
-        {
-            if (m_MemberList[ix].m_psFunc->oVft == oVftPrev)
-            {
-                hr = TLBX_E_BAD_VTABLE;
-                break;
-            }
-            oVftPrev = m_MemberList[ix].m_psFunc->oVft;
-        }
-    }
-
-    // Build the list of unique names.
-    m_pMemberNames = new (nothrow) CWCHARPool;
-    IfNullGo(m_pMemberNames);
-    
-    // Property names.  No possibility of collisions.
-    for (ix=0; ix<m_cMemberProps; ++ix)
-    {
-        IfFailGo(pITI->GetDocumentation(m_MemberList[ix].m_psVar->memid, &bstrName, 0,0,0));
-        IfNullGo(pszName = m_pMemberNames->Alloc((ULONG)wcslen(bstrName)+PROP_DECORATION_LEN+1));
-        wcscpy_s(pszName, wcslen(bstrName)+PROP_DECORATION_LEN+1, PROP_DECORATION_GET);
-        wcscat_s(pszName, wcslen(bstrName)+PROP_DECORATION_LEN+1, bstrName);
-        m_MemberList[ix].m_pName = pszName;
-        if ((m_MemberList[ix].m_psVar->wVarFlags & VARFLAG_FREADONLY) == 0)
-        {
-            IfNullGo(pszName = m_pMemberNames->Alloc((ULONG)wcslen(bstrName)+PROP_DECORATION_LEN+1));
-            wcscpy_s(pszName, wcslen(bstrName)+PROP_DECORATION_LEN+1, PROP_DECORATION_SET);
-            wcscat_s(pszName, wcslen(bstrName)+PROP_DECORATION_LEN+1, bstrName);
-            m_MemberList[ix].m_pName2 = pszName;
-        }
-        ::SysFreeString(bstrName);
-        bstrName = 0;
-    }
-    
-    // Function names.  Because of get_/set_ decoration, collisions are possible.
-    for (ix=m_cMemberProps; ix<(int)m_MemberList.Size(); ++ix)
-    {
-        int bNewEnumMember = FALSE;
-
-        // Build a name based on invkind.
-        psFunc = m_MemberList[ix].m_psFunc;
-
-        // Unless we are doing the [out, retval] transformation for disp only interfaces,
-        // we need to clear the [retval] flag.
-        if (!m_bTransformDispRetVals)
-        {
-            if (psFunc->funckind == FUNC_DISPATCH)
-            {   // If [RETVAL] is set, clear it.
-                for (int i=0; i<psFunc->cParams; ++i)
-                    if ((psFunc->lprgelemdescParam[i].paramdesc.wParamFlags & PARAMFLAG_FRETVAL) != 0)
-                        psFunc->lprgelemdescParam[i].paramdesc.wParamFlags &= ~PARAMFLAG_FRETVAL;
-            }
-        }
-
-        BOOL bExplicitManagedName = FALSE;
-        if ( (!bNewEnumMember) && (!bInheritsIEnum) && (FuncIsNewEnum(pITI, psFunc, m_MemberList[ix].m_iMember) == S_OK) )
-        {    
-            // The member is the new enum member so set its name to GetEnumerator.
-            IfNullGo(bstrName = SysAllocString(GET_ENUMERATOR_MEMBER_NAME));
-            bNewEnumMember = TRUE;
-            
-            // To prevent additional methods from implementing the NewEnum method, we mark the interface
-            bInheritsIEnum = TRUE;
-        }
-        else
-        {
-            // If the managed name custom value is set for this member, then use it.
-            if (pITI2)
-            {
-                hr = pITI2->GetFuncCustData(m_MemberList[ix].m_iMember, GUID_ManagedName, &vt);
-                if (hr == S_OK && vt.vt == VT_BSTR)
-                {
-                    IfNullGo(bstrName = SysAllocString(vt.bstrVal));
-                    bExplicitManagedName = TRUE;
-                }
-                ::VariantClear(&vt);
-            }
-
-            if (!bstrName)
-                IfFailGo(pITI->GetDocumentation(psFunc->memid, &bstrName, 0,0,0));
-        }
-
-        // If this is a property getter, see if it was originally a function.
-        bFunctionToGetter = FALSE;
-        if (psFunc->invkind == INVOKE_PROPERTYGET && pITI2)
-        {
-            hr = pITI2->GetFuncCustData(m_MemberList[ix].m_iMember, GUID_Function2Getter, &vt);
-            if (hr == S_OK && vt.vt == VT_I4 && vt.lVal == 1)
-                bFunctionToGetter = TRUE;
-            ::VariantClear(&vt);
-        }
-
-
-        // Check for the propget and propset custom attributes if this not already a property.
-        if ( (psFunc->invkind & (INVOKE_PROPERTYGET | INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF)) == 0 )
-        {
-            INVOKEKIND ikind;
-            if (S_OK == _CheckForPropertyCustomAttributes(pITI, m_MemberList[ix].m_iMember, &ikind))
-                psFunc->invkind = ikind;
-        }        
-
-
-        // If this is a property accessor, but not the 'new enum member', and not 
-        //  originally from a managed function (that was exported as a getter),
-        //  decorate the name appropriately. If the managed name was set explicitly by
-        //  the Guid_ManagedName attribute, then don't try an decorate it.
-        ULONG nChars = 0;
-        if (!bExplicitManagedName && (psFunc->invkind & (INVOKE_PROPERTYGET | INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF) && !bNewEnumMember && !bFunctionToGetter))
-        {
-            nChars = (ULONG)wcslen(bstrName)+PROP_DECORATION_LEN+1;
-            IfNullGo(pszName = m_pMemberNames->Alloc(nChars));
-
-            USHORT      msSemantics=0;          // Property's methodsemantics.
-            FUNCDESC    *psF;                   // FUNCDESC of Get, Put, or PutRef.
-            TYPEDESC    *pProperty;             // TYPEDESC of property type.
-            BOOL        bPropRetval;            // Is the property type a [retval]?
-            IfFailGo(_GetFunctionPropertyInfo(psFunc, &msSemantics, &psF, &pProperty, &bPropRetval, FALSE, bstrName));
-            
-            m_MemberList[ix].m_msSemantics = msSemantics;
-            switch(msSemantics)
-            {
-            case msGetter:
-                wcscpy_s(pszName, nChars, PROP_DECORATION_GET);
-                break;
-            case msSetter:
-                wcscpy_s(pszName, nChars, PROP_DECORATION_SET);
-                break;
-            case msOther:
-                wcscpy_s(pszName, nChars, PROP_DECORATION_LET);
-                break;
-            default:
-                _ASSERTE(msSemantics == 0);
-                *pszName = 0;
-                break;
-            }
-            wcscat_s(pszName, nChars, bstrName);
-        }
-        else
-        {
-            nChars = (ULONG)wcslen(bstrName)+1;
-            IfNullGo(pszName = m_pMemberNames->Alloc(nChars));
-            wcscpy_s(pszName, nChars, bstrName);
-        }
-        
-        // Check for name collision, restore original name if collision occurs.
-        for (int index=0; index<ix; index++)
-        {
-            if ( (m_MemberList[index].m_pName) && (wcscmp(pszName, m_MemberList[index].m_pName) == 0) )
-            {
-                wcscpy_s(pszName, nChars, bstrName);
-                m_MemberList[ix].m_msSemantics = 0;
-            }
-        }
-
-        // Save the unique name.
-        m_MemberList[ix].m_pName = pszName;
-        ::SysFreeString(bstrName);
-        bstrName = 0;
-    }
-    
-ErrExit:
-    if (pITI2)
-        pITI2->Release();
-    if (psAttr)
-        pITI->ReleaseTypeAttr(psAttr);
-    if (bstrName)
-        ::SysFreeString(bstrName);
-    ::VariantClear(&vt);
-    return hr;
-} // HRESULT CImportTlb::BuildMemberList()
-
-//*****************************************************************************
-// Free the list built in BuildMemberList().
-//*****************************************************************************
-HRESULT CImportTlb::FreeMemberList(
-    ITypeInfo   *pITI)                  // TypeInfo with functions.
-{
-    int         ix;                     // Loop control.
-    for (ix=0; ix<m_cMemberProps; ++ix)
-        pITI->ReleaseVarDesc(m_MemberList[ix].m_psVar);
-    m_cMemberProps = 0;
-    for (; ix<(int)m_MemberList.Size(); ++ix)
-        pITI->ReleaseFuncDesc(m_MemberList[ix].m_psFunc);
-    m_MemberList.Shrink(0);
-    if (m_pMemberNames)
-    {
-        delete m_pMemberNames;
-        m_pMemberNames = 0;
-    }
-    return S_OK;
-} // HRESULT CImportTlb::FreeMemberList()
-
-//*****************************************************************************
-// Set a GUID CustomAttribute on an object.
-//*****************************************************************************
-HRESULT CImportTlb::_AddGuidCa(         // S_OK or error.
-    mdToken     tkObj,                  // Object to be attributed.
-    REFGUID     guid)                   // The GUID.
-{
-    HRESULT     hr;                     // A result.
-    mdMemberRef mr;                     // MemberRef for GUID CA.
-    WCHAR       wzGuid[40];             // Buffer for Guid, Unicode.
-    CHAR        szGuid[40];             // Buffer for Guid, Ansi.
-    DECLARE_CUSTOM_ATTRIBUTE(40);
-        
-    // If GUID_NULL, don't store it.
-    if (guid == GUID_NULL)
-        return S_OK;
-    
-    // Get the GUID as a string.
-    // ----+----1----+----2----+----3----+----4
-    // {12345678-1234-1234-1234-123456789012}
-    GuidToLPWSTR(guid, wzGuid, lengthof(wzGuid));
-    _ASSERTE(wzGuid[37] == W('}'));
-    wzGuid[37] = W('\0');
-    WszWideCharToMultiByte(CP_UTF8, 0, wzGuid+1,-1, szGuid,sizeof(szGuid), 0,0);
-    
-    // Put it in the Custom Attribute.
-    APPEND_STRING_TO_CUSTOM_ATTRIBUTE(szGuid);
-    
-    // Store the attribute
-    IfFailGo(GetAttrType(ATTR_GUID, &mr));
-    FINISH_CUSTOM_ATTRIBUTE();
-    IfFailGo(m_pEmit->DefineCustomAttribute(tkObj, mr, PTROF_CUSTOM_ATTRIBUTE(), SIZEOF_CUSTOM_ATTRIBUTE(), 0));
-    
-ErrExit:
-    return hr;    
-} // HRESULT CImportTlb::_AddGuidCa()
-    
-//*****************************************************************************
-// Add a default member as a custom attribute.
-//*****************************************************************************
-HRESULT CImportTlb::_AddDefaultMemberCa(// S_OK or error.
-    mdToken     tkObj,                  // TypeDef with default member.
-    LPCWSTR     wzName)                 // Name of the default member.
-{   
-    // Only set once per typedef.
-    if (tkObj == m_tdHasDefault)
-        return S_OK;
-    m_tdHasDefault = tkObj;
-    
-    return _AddStringCa(ATTR_DEFAULTMEMBER, tkObj, wzName);
-} // HRESULT CImportTlb::_AddDefaultMemberCa()
-    
-//*****************************************************************************
-// Add a string custom attribute of the given type to the token.
-//*****************************************************************************
-HRESULT CImportTlb::_AddStringCa(       // S_OK or error.
-    int         attr,                   // The type of the CA.
-    mdToken     tk,                     // Token to add the CA to.
-    LPCWSTR     wzString)               // String to put in the CA.
-{
-    HRESULT     hr = S_OK;                     // A result.
-    mdMemberRef mr;                     // MemberRef for DefaultMember CA.
-    BYTE        *pca;                   // Pointer to custom attribute.
-    BYTE        *ca;                    // Pointer to custom attribute.
-    int         wzLen;                  // Length of wide string.
-    int         len;                    // Length of the string.
-    CQuickArray<BYTE> buf;
-
-    if (wzString == NULL)
-    {
-        hr = E_INVALIDARG;
-        goto ErrExit;
-    }
-        
-    // Prolog, up to 4 bytes length, string, epilog
-    wzLen = (int)wcslen(wzString);
-    len = WszWideCharToMultiByte(CP_UTF8,0, wzString, wzLen, 0,0, 0,0);
-    IfFailGo(buf.ReSizeNoThrow(2 + 4 + len + 2));
-    ca = pca = buf.Ptr();
-    
-    // Add prolog.
-    *reinterpret_cast<UNALIGNED USHORT*>(pca) = 1;
-    pca += sizeof(USHORT);
-    
-    // Add length.
-    pca = reinterpret_cast<BYTE*>(CPackedLen::PutLength(pca, len));
-    
-    // Add string.
-    WszWideCharToMultiByte(CP_UTF8,0, wzString, wzLen, reinterpret_cast<char*>(pca), len, 0, 0);
-    pca += len;
-    
-    // Add epilog.
-    *reinterpret_cast<UNALIGNED USHORT*>(pca) = 0;
-    pca += sizeof(USHORT);
-    
-    // Store the attribute
-    IfFailGo(GetAttrType(attr, &mr));
-    IfFailGo(m_pEmit->DefineCustomAttribute(tk, mr, ca, (ULONG)(pca-ca), 0));
-    
-ErrExit:
-    return hr;    
-} // HRESULT CImportTlb::_AddStringCa()
-
-//*****************************************************************************
-// Add a referenced typelib to the list of referenced typelibs.  Check if
-//  it is "this" typelib first.
-//*****************************************************************************
-HRESULT CImportTlb::_AddTlbRef(         // S_OK or error.
-    ITypeLib        *pITLB,             // The referenced typelib.
-    mdAssemblyRef   *par,               // The AssemblyRef in this module.
-    BSTR            *pwzNamespace,      // The namespace contained in the resolved assembly.
-    BSTR            *pwzAsmName,        // The name of the resolved assembly.
-    CImpTlbDefItfToClassItfMap **ppDefItfToClassItfMap) // The default interface to class interface map.
-{
-    HRESULT          hr = S_OK;                       // A result.
-    IUnknown         *pIUnk=0;                        // IUnknown for external assembly.
-    mdAssemblyRef    ar=0;                            // Assembly ref in the module containing the typeref.
-    ITypeLib2        *pITLB2=0;                       // To get custom attributes.
-    VARIANT          vt;                              // Variant type.
-    Assembly*        ResolvedAssembly=0;              // The resolved assembly.
-    CImpTlbDefItfToClassItfMap *pDefItfToClassItfMap; // Temp def itf to class itf map.
-
-    // Validate the arguments.
-    _ASSERTE(pITLB && par && pwzNamespace && pwzAsmName);
-    
-    // Initialize the out parameters to NULL.
-    *par = mdTokenNil;
-    *pwzNamespace = NULL;
-    *pwzAsmName = NULL;
-    if (ppDefItfToClassItfMap)
-        *ppDefItfToClassItfMap = NULL;
-    
-    ::VariantInit(&vt);
-    
-    // If not the importing typelib, add it to the list.
-    if (pITLB == m_pITLB)
-    {   // Not an external assembly.
-        //*par = mdAssemblyRefNil;
-        *par = TokenFromRid(1, mdtModule);
-        IfNullGo(*pwzNamespace = SysAllocStringLen(m_wzNamespace, SysStringLen(m_wzNamespace)));
-        *pwzAsmName = NULL;
-        if (ppDefItfToClassItfMap)
-            *ppDefItfToClassItfMap = &m_DefItfToClassItfMap;
-        return S_OK;
-    }
-
-    // If already resolved, just return assembly ref.
-    if (m_LibRefs.Find(pITLB, par, pwzNamespace, pwzAsmName, NULL, ppDefItfToClassItfMap))
-        return S_OK;
-
-    // See if the typelib was exported, in which case it already has assembly ref information.
-    if (pITLB->QueryInterface(IID_ITypeLib2, reinterpret_cast<void**>(&pITLB2)) == S_OK)
-    {
-        hr = pITLB2->GetCustData(GUID_ExportedFromComPlus, &vt);
-        if (vt.vt == VT_BSTR)
-        {
-            // Use the CA data to get a reference.
-            //CQuickArray<BYTE> rBuf;
-            //int iLen;
-            // The buffer should have been converted with CP_ACP, and should convert back directly.
-            //IfFailGo(rBuf.ReSizeNoThrow(iLen=::SysStringLen(vt.bstrVal)));
-            //if (iLen=WszWideCharToMultiByte(CP_ACP,0, vt.bstrVal,iLen, (char*)rBuf.Ptr(),iLen, 0,0))
-            {
-                // Define the assembly ref for the exported assembly.
-                //ar = DefineAssemblyRefForExportedAssembly(rBuf.Ptr(),(DWORD)rBuf.Size(), m_pEmit);
-                ar = DefineAssemblyRefForExportedAssembly(vt.bstrVal, m_pEmit);
-
-                // Retrieve the namespace from the typelib.
-                IfFailGo(GetNamespaceNameForTypeLib(pITLB, pwzNamespace));
-
-                // Set the assembly name.
-                IfNullGo(*pwzAsmName = SysAllocStringLen(vt.bstrVal, SysStringLen(vt.bstrVal)));
-            }
-        }
-    }    
-    
-    // If it wasn't directly converted to a reference, callback to the resolver.
-    if (IsNilToken(ar))
-    {
-        // Get the assembly for that typelib.
-        if (FAILED(m_Notify->ResolveRef(pITLB, &pIUnk)))
-            IfFailGo(TLBX_I_RESOLVEREFFAILED);
-
-        // If a NULL assembly was returned, then stop converting the type but 
-        // continue the import.
-        if (pIUnk == NULL)
-            IfFailGo(TLBX_E_INVALID_TYPEINFO);
-
-        // Create an assembly ref in local assembly for referenced assembly.
-        ar = DefineAssemblyRefForImportedTypeLib(m_pAssembly, m_pModule, m_pEmit, pIUnk, pwzNamespace, pwzAsmName, &ResolvedAssembly);
-    }
-    
-    // Make sure the ref was resolved before adding to cache.
-    if (IsNilToken(ar))
-        IfFailGo(TLBX_I_RESOLVEREFFAILED);
-    
-    // Add the TLB to the list of references.
-    IfFailGo(m_LibRefs.Add(pITLB, this, ar, *pwzNamespace, *pwzAsmName, ResolvedAssembly, &pDefItfToClassItfMap));
-
-    // Set the output parameters.
-    *par = ar;
-    if (ppDefItfToClassItfMap)
-        *ppDefItfToClassItfMap = pDefItfToClassItfMap;
-
-ErrExit:
-    if (FAILED(hr))
-    {
-        if (*pwzNamespace)
-        {
-            SysFreeString(*pwzNamespace);
-            *pwzNamespace = NULL;
-        }
-        if (*pwzAsmName)
-        {
-            SysFreeString(*pwzAsmName);
-            *pwzAsmName = NULL;
-        }
-    }
-    if (pIUnk)
-        pIUnk->Release();
-    if (pITLB2)
-        pITLB2->Release();
-    VariantClear(&vt);
-
-    return hr;
-} // HRESULT CImportTlb::_AddTlbRef()
-
-//*****************************************************************************
-// Error reporting helper.
-//*****************************************************************************
-HRESULT CImportTlb::ReportEvent(        // Returns the original HR.
-    int         ev,                     // The event kind.
-    int         hrRpt,                  // HR.
-    ...)                                // Variable args.
-{
-    HRESULT     hr;                     // A result.
-    va_list     marker;                 // User text.
-    BSTR        bstrBuf=0;              // BSTR for bufferrr.
-    BSTR        bstrMsg=0;              // BSTR for message.
-    const int   iSize = 1024;           // Message size;
-    
-    // We need a BSTR anyway for the call to ReportEvent, so just allocate a
-    //  big one for the buffer.
-    IfNullGo(bstrBuf = ::SysAllocStringLen(0, iSize));
-    
-    // Format the message.
-    va_start(marker, hrRpt);
-    hr = FormatRuntimeErrorVa(bstrBuf, iSize, hrRpt, marker);
-    va_end(marker);
-    
-    // Display it.
-    IfNullGo(bstrMsg = ::SysAllocString(bstrBuf));
-    m_Notify->ReportEvent(static_cast<ImporterEventKind>(ev), hrRpt, bstrMsg);
-    
-ErrExit:    
-    // Clean up.
-    if (bstrBuf)
-        ::SysFreeString(bstrBuf);
-    if (bstrMsg)
-        ::SysFreeString(bstrMsg);
-    return hrRpt;
-} // HRESULT CImportTlb::ReportEvent()
-
-//*****************************************************************************
-// Helper function to perform the shared functions of creating a TypeRef.
-//*****************************************************************************
-HRESULT CImpTlbTypeRef::DefineTypeRef(  // S_OK or error.
-    IMetaDataEmit *pEmit,               // Emit interface.
-    mdAssemblyRef ar,                   // The system assemblyref.
-    const LPCWSTR szURL,                // URL of the TypeDef, wide chars.
-    mdTypeRef   *ptr)                   // Put mdTypeRef here
-{
-    HRESULT     hr = S_OK;              // A result.
-    LPCWSTR     szLookup;               // The name to look up.
-    mdToken     tkNester;               // Token of enclosing class.
-    
-    // If the name contains a '+', this is a nested type.  The first part becomes
-    //  the resolution scope for the part after the '+'.
-    szLookup = wcsrchr(szURL, NESTED_SEPARATOR_WCHAR);
-    if (szLookup)
-    {
-        CQuickArray<WCHAR> qbName;
-        IfFailGo(qbName.ReSizeNoThrow(szLookup - szURL + 1));
-        wcsncpy_s(qbName.Ptr(), (szLookup - szURL + 1), szURL, szLookup - szURL);
-        IfFailGo(DefineTypeRef(pEmit, ar, qbName.Ptr(), &tkNester));
-        ar = tkNester;
-        ++szLookup;
-    }
-    else
-        szLookup = szURL;
-
-    // Look for the item in the map.
-    CImpTlbTypeRef::TokenOfTypeRefHashKey sSearch, *pMapped;
-
-    sSearch.tkResolutionScope = ar;
-    sSearch.szName = szLookup;
-    pMapped = m_Map.Find(&sSearch);
-
-    if (pMapped)
-    {
-        *ptr = pMapped->tr;
-        goto ErrExit;
-    }
-
-    // Wasn't found, create a new one and add to the map.
-    hr = pEmit->DefineTypeRefByName(ar, szLookup, ptr);
-    if (SUCCEEDED(hr))
-    {
-        sSearch.tr = *ptr;
-        pMapped = m_Map.Add(&sSearch);
-        IfNullGo(pMapped);
-    }
-
-ErrExit:
-    return (hr);
-} // HRESULT CImpTlbTypeRef::DefineTypeRef()
-
-//*****************************************************************************
-// Free the held typelibs in the list of imported typelibs.
-//*****************************************************************************
-CImpTlbLibRef::~CImpTlbLibRef()
-{
-    for (ULONG i = 0; i < Size(); i++)
-    {
-        SysFreeString(operator[](i).szNameSpace);
-        delete operator[](i).pDefItfToClassItfMap;
-    }
-} // CImpTlbLibRef::~CImpTlbLibRef()
-
-//*****************************************************************************
-// Add a new typelib reference to the list.
-//*****************************************************************************
-HRESULT CImpTlbLibRef::Add(
-    ITypeLib    *pITLB,
-    CImportTlb  *pImporter,
-    mdAssemblyRef ar,
-    BSTR wzNamespace,
-    BSTR wzAsmName,
-    Assembly* assm,
-    CImpTlbDefItfToClassItfMap **ppMap)
-{
-    HRESULT     hr = S_OK;              // A result.
-    TLIBATTR    *pAttr=0;               // A typelib attribute.
-    ULONG       i;                      // Index.
-    CTlbRef     *pTlbRef=0;             // A pointer to the TlbRef struct.
-    CImpTlbDefItfToClassItfMap *pDefItfToClassItfMap = NULL;  //  ptr to the default interface to class interface map.
-    
-    // Validate the arguments.
-    _ASSERTE(wzNamespace);
-    _ASSERTE(wzAsmName);
-
-    IfFailGo(pITLB->GetLibAttr(&pAttr));
-    
-#if defined(_DEBUG)
-    for (i=0; i<Size(); ++i)
-    {
-        if (operator[](i).guid == pAttr->guid)
-        {
-            _ASSERTE(!"External TypeLib already referenced");
-            goto ErrExit;
-        }
-    }
-#else
-    i  = (ULONG)Size();
-#endif    
-
-    // Allocate and initialize the default interface to class interface map.
-    pDefItfToClassItfMap = new (nothrow) CImpTlbDefItfToClassItfMap();
-    IfNullGo(pDefItfToClassItfMap);
-    IfFailGo(pDefItfToClassItfMap->Init(pITLB, wzNamespace));
-
-    // Attemp to resize the array.
-    IfFailGo(ReSizeNoThrow(i+1));
-    pTlbRef = &operator[](i);
-    pTlbRef->guid = pAttr->guid;
-    pTlbRef->ar = ar;
-    IfNullGo(pTlbRef->szNameSpace = SysAllocString(wzNamespace));
-    IfNullGo(pTlbRef->szAsmName = SysAllocString(wzAsmName));
-    pTlbRef->pDefItfToClassItfMap = pDefItfToClassItfMap;
-    pTlbRef->Asm = assm;
-    
-ErrExit:
-    if (pAttr)
-        pITLB->ReleaseTLibAttr(pAttr);
-    if (FAILED(hr))
-    {
-        if (pTlbRef && pTlbRef->szNameSpace)
-            SysFreeString(pTlbRef->szNameSpace);
-        if (pTlbRef && pTlbRef->szAsmName)
-            SysFreeString(pTlbRef->szAsmName);
-        delete pDefItfToClassItfMap;
-    }
-    else
-    {
-        *ppMap = pDefItfToClassItfMap;
-    }
-
-    return hr;
-} // void CImpTlbLibRef::Add()
-
-//*****************************************************************************
-// Find an existing typelib reference.
-//*****************************************************************************
-int CImpTlbLibRef::Find(
-    ITypeLib    *pITLB,
-    mdAssemblyRef *par,
-    BSTR *pwzNamespace,
-    BSTR *pwzAsmName,
-    Assembly** assm,
-    CImpTlbDefItfToClassItfMap **ppDefItfToClassItfMap)
-{
-    HRESULT     hr;                     // A result.
-    TLIBATTR    *pAttr=0;               // A typelib attribute.
-    int         rslt = FALSE;           // Return result.
-    ULONG       i;                      // Loop control.
-    
-    _ASSERTE(pwzNamespace);
-    _ASSERTE(pwzAsmName);
-
-    // Initalize the out parameters to NULL.
-    *pwzNamespace = NULL;
-    *pwzAsmName = NULL;
-
-    if (assm) 
-        *assm = NULL;
-
-    IfFailGo(pITLB->GetLibAttr(&pAttr));
-    
-    for (i=0; i<Size(); ++i)
-    {
-        if (operator[](i).guid == pAttr->guid)
-        {
-            *par = operator[](i).ar;
-            IfNullGo(*pwzNamespace = SysAllocString(operator[](i).szNameSpace));
-            IfNullGo(*pwzAsmName = SysAllocString(operator[](i).szAsmName));
-            if (ppDefItfToClassItfMap)
-                *ppDefItfToClassItfMap = operator[](i).pDefItfToClassItfMap;
-            if (assm)
-                *assm = operator[](i).Asm;
-            rslt = TRUE;
-            goto ErrExit;
-        }
-    }
-    
-ErrExit:
-    if (FAILED(hr))
-    {
-        if (*pwzNamespace)
-            SysFreeString(*pwzNamespace);
-        if (*pwzAsmName)
-            SysFreeString(*pwzAsmName);
-    }
-    if (pAttr)
-        pITLB->ReleaseTLibAttr(pAttr);
-    return rslt;
-} // void CImpTlbLibRef::Find()
-
-//*****************************************************************************
-// unpack variant to an ELEMENT_TYPE_* plus a blob value
-// If VT_BOOL, it is a two-byte value.
-//*****************************************************************************
-HRESULT _UnpackVariantToConstantBlob(VARIANT *pvar, BYTE *pcvType, void **pvValue, __int64 *pd)
-{
-    HRESULT     hr = NOERROR;
-
-    switch (pvar->vt)
-    {
-    case VT_BOOL:
-        *pcvType = ELEMENT_TYPE_BOOLEAN;
-        *((VARIANT_BOOL **)pvValue) = &(pvar->boolVal);
-        break;
-    case VT_I1:
-        *pcvType = ELEMENT_TYPE_I1;
-        *((CHAR **)pvValue) = &(pvar->cVal);
-        break;
-    case VT_UI1:
-        *pcvType = ELEMENT_TYPE_U1;
-        *((BYTE **)pvValue) = &(pvar->bVal);
-        break;
-    case VT_I2:
-        *pcvType = ELEMENT_TYPE_I2;
-        *((SHORT **)pvValue) = &(pvar->iVal);
-        break;
-    case VT_UI2:
-        *pcvType = ELEMENT_TYPE_U2;
-        *((USHORT **)pvValue) = &(pvar->uiVal);
-        break;
-    case VT_I4:
-    case VT_INT:
-        *pcvType = ELEMENT_TYPE_I4;
-        *((LONG **)pvValue) = &(pvar->lVal);
-        break;
-    case VT_UI4:
-    case VT_UINT:
-        *pcvType = ELEMENT_TYPE_U4;
-        *((ULONG **)pvValue) = &(pvar->ulVal);
-        break;
-    case VT_R4:
-        *pcvType = ELEMENT_TYPE_R4;
-        *((float **)pvValue) = &(pvar->fltVal);
-        break;      
-    case VT_I8:
-        *pcvType = ELEMENT_TYPE_I8;
-        *((LONGLONG **)pvValue) = &(pvar->cyVal.int64);
-        break;
-    case VT_R8:
-        *pcvType = ELEMENT_TYPE_R8;
-        *((double **)pvValue) = &(pvar->dblVal);
-        break;
-    case VT_BSTR:
-        *pcvType = ELEMENT_TYPE_STRING;
-        *((BSTR *)pvValue) = pvar->bstrVal;     
-        break;
-
-    case VT_DATE:
-        *pcvType = ELEMENT_TYPE_I8;
-        *pd = _DoubleDateToTicks(pvar->date);
-        *((LONGLONG **)pvValue) = pd;
-        break;
-    case VT_UNKNOWN:
-    case VT_DISPATCH:
-        *pcvType = ELEMENT_TYPE_CLASS;
-        _ASSERTE(pvar->punkVal == NULL);
-        *((IUnknown ***)pvValue) = &(pvar->punkVal);        
-        break;
-    default:
-        _ASSERTE(!"Not a valid type to specify default value!");
-        IfFailGo( META_E_BAD_INPUT_PARAMETER );
-        break;
-    }
-ErrExit:
-    return hr;
-} // HRESULT _UnpackVariantToConstantBlob()
-
-//*****************************************************************************
-// Stolen from classlib.
-//*****************************************************************************
-INT64 _DoubleDateToTicks(const double d)
-{
-    const INT64 MillisPerSecond = 1000;
-    const INT64 MillisPerDay = MillisPerSecond * 60 * 60 * 24;
-    const INT64 TicksPerMillisecond = 10000;
-    const INT64 TicksPerSecond = TicksPerMillisecond * 1000;
-    const INT64 TicksPerMinute = TicksPerSecond * 60;
-    const INT64 TicksPerHour = TicksPerMinute * 60;
-    const INT64 TicksPerDay = TicksPerHour * 24;
-    const int DaysPer4Years = 365 * 4 + 1;
-    const int DaysPer100Years = DaysPer4Years * 25 - 1;
-    const int DaysPer400Years = DaysPer100Years * 4 + 1;
-    const int DaysTo1899 = DaysPer400Years * 4 + DaysPer100Years * 3 - 367;
-    const INT64 DoubleDateOffset = DaysTo1899 * TicksPerDay;
-    const int DaysTo10000 = DaysPer400Years * 25 - 366;
-    const INT64 MaxMillis = DaysTo10000 * MillisPerDay;
-
-    INT64 millis = (INT64)(d * MillisPerDay + (d >= 0? 0.5: -0.5));
-    if (millis < 0) millis -= (millis % MillisPerDay) * 2;
-    millis += DoubleDateOffset / TicksPerMillisecond;
-    if (millis < 0 || millis >= MaxMillis) {
-        return 0;
-    }
-    return millis * TicksPerMillisecond;
-} // INT64 _DoubleDateToTicks()
-
-
-//*****************************************************************************
-// Wrapper for GetFuncDesc to catch errors.
-//*****************************************************************************
-static HRESULT TryGetFuncDesc(          // S_OK or error.
-    ITypeInfo   *pITI,                  // ITypeInfo with function.
-    int         i,                      // Function index.
-    FUNCDESC    **ppFunc)               // Put FUNCDESC here.
-{
-    HRESULT     hr;                     // A return code.
-    __try
-    {
-        hr = pITI->GetFuncDesc(i, ppFunc);
-    }
-    __except(1)
-    {
-        hr = PostError(TLBX_E_TLB_EXCEPTION, _exception_code());
-    }
-    
-    return hr;
-} // static HRESULT TryGetFuncDesc()
-
-//*****************************************************************************
-// Implementation of a hashed ResolutionScope+Name to TypeRef map.
-//*****************************************************************************
-void CImpTlbTypeRef::CTokenOfTypeRefHash::Clear()
-{
-#if defined(_DEBUG)
-    // printf("Name to TypeRef cache: %d buckets, %d used, %d collisions\n", Buckets(), Count(), Collisions());
-#endif
-    CClosedHash<class TokenOfTypeRefHashKey>::Clear();
-} // void CImpTlbTypeRef::CTokenOfTypeRefHash::Clear()
-
-unsigned int CImpTlbTypeRef::CTokenOfTypeRefHash::Hash(const TokenOfTypeRefHashKey *pData)
-{
-    // Starting value for hash.
-    ULONG   hash = 5381;
-    
-    // Hash in the resolution scope token.
-    const BYTE *pbData = reinterpret_cast<const BYTE *>(&pData->tkResolutionScope);
-    int iSize = 4;
-    while (--iSize >= 0)
-    {
-        hash = ((hash << 5) + hash) ^ *pbData;
-        ++pbData;
-    }
-
-    // Hash in the typeref name.
-    LPCWSTR szStr = pData->szName;
-    int     c;
-    while ((c = *szStr) != 0)
-    {
-        hash = ((hash << 5) + hash) ^ c;
-        ++szStr;
-    }
-
-    return hash;
-} // unsigned int CImpTlbTypeRef::CTokenOfTypeRefHash::Hash()
-
-unsigned int CImpTlbTypeRef::CTokenOfTypeRefHash::Compare(const TokenOfTypeRefHashKey *p1, TokenOfTypeRefHashKey *p2)
-{
-    // Resolution scopes are fast to compare.
-    if (p1->tkResolutionScope < p2->tkResolutionScope)
-        return -1;
-    if (p1->tkResolutionScope > p2->tkResolutionScope)
-        return 1;
-    // But if they are the same, compare the names.
-    return wcscmp(p1->szName, p2->szName);
-} // unsigned int CImpTlbTypeRef::CTokenOfTypeRefHash::Compare()
-
-CImpTlbTypeRef::CTokenOfTypeRefHash::ELEMENTSTATUS CImpTlbTypeRef::CTokenOfTypeRefHash::Status(TokenOfTypeRefHashKey *p)
-{
-    if (p->tkResolutionScope == static_cast<mdToken>(FREE))
-        return (FREE);
-    if (p->tkResolutionScope == static_cast<mdToken>(DELETED))
-        return (DELETED);
-    return (USED);
-} // CImpTlbTypeRef::CTokenOfTypeRefHash::ELEMENTSTATUS CImpTlbTypeRef::CTokenOfTypeRefHash::Status()
-
-void CImpTlbTypeRef::CTokenOfTypeRefHash::SetStatus(TokenOfTypeRefHashKey *p, ELEMENTSTATUS s)
-{
-    p->tkResolutionScope = static_cast<mdToken>(s);
-} // void CImpTlbTypeRef::CTokenOfTypeRefHash::SetStatus()
-
-void *CImpTlbTypeRef::CTokenOfTypeRefHash::GetKey(TokenOfTypeRefHashKey *p)
-{
-    return p;
-} // void *CImpTlbTypeRef::CTokenOfTypeRefHash::GetKey()
-
-CImpTlbTypeRef::TokenOfTypeRefHashKey* CImpTlbTypeRef::CTokenOfTypeRefHash::Add(const TokenOfTypeRefHashKey *pData)
-{
-    LPWSTR pName;
-    const void *pvData = pData;
-    TokenOfTypeRefHashKey *pNew = Super::Add(const_cast<void*>(pvData));
-    if (pNew == 0)
-        return 0;
-    pNew->szName = pName = m_Names.Alloc((ULONG)wcslen(pData->szName)+1);
-    if (pNew->szName == 0)
-        return 0;
-    wcscpy_s(pName, wcslen(pData->szName)+1, pData->szName);
-    pNew->tkResolutionScope = pData->tkResolutionScope;
-    pNew->tr = pData->tr;
-
-    return pNew;
-} // TokenOfTypeRefHashKey* CImpTlbTypeRef::CTokenOfTypeRefHash::Add()
-
-//*****************************************************************************
-// Implementation of a hashed ITypeInfo * source interface to event information
-// map.
-//*****************************************************************************
-HRESULT CImpTlbEventInfoMap::AddEventInfo(LPCWSTR szSrcItfName, mdTypeRef trEventItf, LPCWSTR szEventItfName, LPCWSTR szEventProviderName, Assembly* SrcItfAssembly)
-{
-    ImpTlbEventInfo sNew;
-    sNew.szSrcItfName = szSrcItfName;
-    sNew.trEventItf = trEventItf;
-    sNew.szEventItfName = szEventItfName;
-    sNew.szEventProviderName = szEventProviderName;
-    sNew.SrcItfAssembly = SrcItfAssembly;
-    return Add(&sNew) != NULL ? S_OK : E_OUTOFMEMORY;
-} // BOOL CImpTlbEventInfoMap::AddEventInfo()
-
-ImpTlbEventInfo *CImpTlbEventInfoMap::FindEventInfo(LPCWSTR szSrcItfName)
-{
-    ImpTlbEventInfo sSearch, *pMapped;
-    sSearch.szSrcItfName = szSrcItfName;
-    pMapped = Find(&sSearch);
-    return pMapped;
-} // ImpTlbEventInfo *CImpTlbEventInfoMap::FindEventInfo()
-
-HRESULT CImpTlbEventInfoMap::GetEventInfoList(CQuickArray<ImpTlbEventInfo*> &qbEvInfoList)
-{
-    HRESULT hr = S_OK;
-    int cCurrEvInfo = 0;
-
-    // Resise the event info list.
-    IfFailGo(qbEvInfoList.ReSizeNoThrow(Count()));
-
-    // Retrieve the first event info.
-    ImpTlbEventInfo *pEvInfo = GetFirst();
-
-    // Add all the event info's to the list.
-    while (pEvInfo)
-    {
-        qbEvInfoList[cCurrEvInfo++] = pEvInfo;
-        pEvInfo = GetNext(pEvInfo);
-    }
-
-ErrExit:
-    return hr;    
-} // HRESULT CImpTlbEventInfoMap::GetEventInfoList()
-
-unsigned int CImpTlbEventInfoMap::Hash(const ImpTlbEventInfo *pData)
-{
-    // Starting value for hash.
-    ULONG   hash = 5381;
-    
-    // Hash in the source interface name.
-    LPCWSTR szStr = pData->szSrcItfName;
-    int     c;
-    while ((c = *szStr) != 0)
-    {
-        hash = ((hash << 5) + hash) ^ c;
-        ++szStr;
-    }
-
-    return hash;
-} // unsigned int CImpTlbEventInfoMap::Hash()
-
-unsigned int CImpTlbEventInfoMap::Compare(const ImpTlbEventInfo *p1, ImpTlbEventInfo *p2)
-{
-    // Compare the source interface names.
-    return wcscmp(p1->szSrcItfName, p2->szSrcItfName);
-} // unsigned int CImpTlbEventInfoMap::Compare()
-
-CImpTlbEventInfoMap::ELEMENTSTATUS CImpTlbEventInfoMap::Status(ImpTlbEventInfo *p)
-{
-    if (p->szSrcItfName == reinterpret_cast<LPCWSTR>(FREE))
-        return (FREE);
-    if (p->szSrcItfName == reinterpret_cast<LPCWSTR>(DELETED))
-        return (DELETED);
-    return (USED);
-} // CImpTlbEventInfoMap::ELEMENTSTATUS CImpTlbEventInfoMap::Status()
-
-void CImpTlbEventInfoMap::SetStatus(ImpTlbEventInfo *p, ELEMENTSTATUS s)
-{
-    p->szSrcItfName = reinterpret_cast<LPCWSTR>(s);
-} // void CImpTlbEventInfoMap::SetStatus()
-
-void *CImpTlbEventInfoMap::GetKey(ImpTlbEventInfo *p)
-{
-    return p;
-} // void *CImpTlbEventInfoMap::GetKey()
-
-ImpTlbEventInfo* CImpTlbEventInfoMap::Add(const ImpTlbEventInfo *pData)
-{
-    // Add the new entry to the map.
-    const void *pvData = pData;
-    ImpTlbEventInfo *pNew = Super::Add(const_cast<void*>(pvData));
-    if (pNew == 0)
-        return 0;
-
-    // Copy the source interface name.
-    pNew->szSrcItfName = m_Names.Alloc((ULONG)wcslen(pData->szSrcItfName)+1);
-    if (pNew->szSrcItfName == 0)
-        return 0;
-    wcscpy_s((LPWSTR)pNew->szSrcItfName, wcslen(pData->szSrcItfName)+1, pData->szSrcItfName);
-
-    // Copy the event interface type def.
-    pNew->trEventItf = pData->trEventItf;
-
-    // Copy the event interface name.
-    pNew->szEventItfName = m_Names.Alloc((ULONG)wcslen(pData->szEventItfName)+1);
-    if (pNew->szEventItfName == 0)
-        return 0;
-    wcscpy_s((LPWSTR)pNew->szEventItfName, wcslen(pData->szEventItfName)+1, pData->szEventItfName);
-
-    // Copy the event provider name.
-    pNew->szEventProviderName = m_Names.Alloc((ULONG)wcslen(pData->szEventProviderName)+1);
-    if (pNew->szEventProviderName == 0)
-        return 0;
-    wcscpy_s((LPWSTR)pNew->szEventProviderName, wcslen(pData->szEventProviderName)+1, pData->szEventProviderName);
-
-    // Copy the Source Interface Assembly pointer
-    pNew->SrcItfAssembly = pData->SrcItfAssembly;
-    
-    // Return the new entry.
-    return pNew;
-} // ImpTlbEventInfo* CImpTlbEventInfoMap::Add()
-
-CImpTlbDefItfToClassItfMap::CImpTlbDefItfToClassItfMap() 
-: CClosedHash<class ImpTlbClassItfInfo>(101) 
-, m_bstrNameSpace(NULL) 
-{
-}
-
-CImpTlbDefItfToClassItfMap::~CImpTlbDefItfToClassItfMap() 
-{ 
-    Clear(); 
-    if (m_bstrNameSpace)
-    {
-        ::SysFreeString(m_bstrNameSpace);
-        m_bstrNameSpace = NULL;
-    }
-}
-
-HRESULT CImpTlbDefItfToClassItfMap::Init(ITypeLib *pTlb, BSTR bstrNameSpace)
-{
-    HRESULT                 hr;                     // A result.
-    int                     cTi;                    // Count of TypeInfos.
-    int                     i;                      // Loop control.
-    TYPEATTR                *psAttr=0;              // TYPEATTR for the ITypeInfo.
-    TYPEATTR                *psDefItfAttr=0;        // TYPEATTR for the default interface.
-    ITypeInfo               *pITI=0;                // The ITypeInfo.
-    ITypeInfo               *pDefItfITI=0;          // The ITypeInfo for the default interface.
-
-    // Save the namespace.
-    IfNullGo(m_bstrNameSpace = SysAllocString(bstrNameSpace));
-
-    // How many TypeInfos?
-    IfFailGo(cTi = pTlb->GetTypeInfoCount());
-
-    // Iterate over them.
-    for (i = 0; i < cTi; ++i)
-    {
-        // Get the TypeInfo.
-        hr = pTlb->GetTypeInfo(i, &pITI);
-        if (SUCCEEDED(hr))
-        {
-            // Retrieve the attributes of the type info.
-            IfFailGo(pITI->GetTypeAttr(&psAttr));
-
-            // If we are dealing with a CoClass, then set up the default interface to 
-            // class interface mapping.
-            if (psAttr->typekind == TKIND_COCLASS)
-                IfFailGo(AddCoClassInterfaces(pITI, psAttr));
-
-            // Release for next TypeInfo.
-            if (psAttr)
-            {
-                pITI->ReleaseTypeAttr(psAttr);
-                psAttr = 0;
-            }
-            if (pITI)
-            {
-                pITI->Release();
-                pITI = 0;
-            }
-        }
-    }
-
-ErrExit:
-    if (psAttr)
-        pITI->ReleaseTypeAttr(psAttr);
-    if (pITI)
-        pITI->Release();
-
-    return (hr);
-}
-
-HRESULT CImpTlbDefItfToClassItfMap::AddCoClassInterfaces(ITypeInfo *pCoClassITI, TYPEATTR *pCoClassTypeAttr)
-{
-    HRESULT     hr;                 // A result
-    HREFTYPE    href;               // HREFTYPE of an implemented interface.
-    INT         ImplFlags;          // ImplType flags.
-    int         NumInterfaces;      // The number of interfaces on the coclass.
-    int         i;                  // A counter.
-    ITypeInfo   *pItfITI=0;         // The ITypeInfo for the current interface.
-    ITypeInfo   *pBaseItfITI=0;     // The ITypeInfo for the base interface.
-    TYPEATTR    *psItfAttr=0;       // TYPEATTR for the interface.
-    BSTR        bstrClassItfName=0; // The name of the class interface.
-
-    // Retrieve the name of the CoClass.
-    IfFailGo(GetManagedNameForTypeInfo(pCoClassITI, m_bstrNameSpace, NULL, &bstrClassItfName));
-
-    // Retrieve the default interface for the CoClass.
-    IfFailGo(CImportTlb::GetDefaultInterface(pCoClassITI, &pItfITI));
-
-    // If there is a default interface, then add it to the map.
-    if (hr == S_OK)
-    {
-        // Retrieve the attributes of the default interface type info.
-        IfFailGo(pItfITI->GetTypeAttr(&psItfAttr));
-
-        // If there already is a CoClass that implements this 
-        // interface then we do not want to do the mapping.
-        ImpTlbClassItfInfo sSearch, *pMapped;
-        sSearch.ItfIID = psItfAttr->guid;
-        pMapped = Find(&sSearch);
-        if (pMapped)
-        {
-            // There already is a CoClass that implements the interface so 
-            // we set the class itf name to NULL to indicate not to do the def 
-            // itf to class itf convertion for this interface.
-            pMapped->szClassItfName = NULL;
-        }
-        else
-        {
-            // Unless the default interface is IUnknown or IDispatch, add the 
-            // def itf to class itf entry to the map.       
-            if (psItfAttr->guid != IID_IUnknown && psItfAttr->guid != IID_IDispatch)
-            {
-                ImpTlbClassItfInfo sNew;
-                sNew.ItfIID = psItfAttr->guid;
-                sNew.szClassItfName = bstrClassItfName;
-                IfNullGo(Add(&sNew)); 
-            }
-        }
-
-        // Release for next interface.
-        pItfITI->ReleaseTypeAttr(psItfAttr);
-        psItfAttr = 0;  
-        pItfITI->Release();
-        pItfITI = 0;
-    }
-
-    // Retrieve the number of interfaces the coclass has
-    NumInterfaces = pCoClassTypeAttr->cImplTypes;
-
-    // Go through all the interfaces and add them to the map.
-    for (i=0; i < NumInterfaces; i++)
-    {
-        // Get the impl flags.
-        IfFailGo(pCoClassITI->GetImplTypeFlags(i, &ImplFlags));
-
-        // If this is an implemented interface.
-        if (!(ImplFlags & IMPLTYPEFLAG_FSOURCE))
-        {
-            IfFailGo(pCoClassITI->GetRefTypeOfImplType(i, &href));
-            IfFailGo(pCoClassITI->GetRefTypeInfo(href, &pItfITI));
-
-            do
-            {
-                // Retrieve the attributes of the interface type info.
-                IfFailGo(pItfITI->GetTypeAttr(&psItfAttr));
-
-                // If there already is a CoClass that implements this 
-                // interface then we do not want to do the mapping.
-                ImpTlbClassItfInfo sSearch, *pMapped;
-                sSearch.ItfIID = psItfAttr->guid;
-                pMapped = Find(&sSearch);
-                if (pMapped)
-                {
-                    // There already is a CoClass that implements the interface. If that
-                    // CoClass is not the current one, then we we set the class itf name 
-                    // to NULL to indicate not to do the def itf to class itf convertion 
-                    // for this interface.
-                    if (pMapped->szClassItfName && wcscmp(pMapped->szClassItfName, bstrClassItfName) != 0)
-                        pMapped->szClassItfName = NULL;
-                }
-                else
-                {
-                    // Add an entry with a NULL name to prevent future substitutions.
-                    ImpTlbClassItfInfo sNew;
-                    sNew.ItfIID = psItfAttr->guid;
-                    sNew.szClassItfName = NULL;
-                    IfNullGo(Add(&sNew)); 
-                }
-
-                // If there is a base interface, then handle it also.
-                if (psItfAttr->cImplTypes == 1)
-                {
-                    IfFailGo(pItfITI->GetRefTypeOfImplType(0, &href));
-                    IfFailGo(pItfITI->GetRefTypeInfo(href, &pBaseItfITI));                       
-                }
-
-                // Release for next interface.
-                if (psItfAttr)
-                {
-                    pItfITI->ReleaseTypeAttr(psItfAttr);
-                    psItfAttr = 0;
-                }
-                if (pItfITI)
-                {
-                    pItfITI->Release();
-                    pItfITI = 0;
-                }
-
-                // Set the current interface to the base interface.
-                pItfITI = pBaseItfITI;
-                pBaseItfITI = 0;
-            }
-            while(pItfITI);
-        }       
-    }
-
-ErrExit:
-    if (psItfAttr)
-        pItfITI->ReleaseTypeAttr(psItfAttr);
-    if (pItfITI)
-        pItfITI->Release();
-    if (bstrClassItfName)
-        ::SysFreeString(bstrClassItfName);
-
-    return hr;
-}
-
-LPCWSTR CImpTlbDefItfToClassItfMap::GetClassItfName(IID &rItfIID)
-{
-    ImpTlbClassItfInfo sSearch, *pMapped;
-    sSearch.ItfIID = rItfIID;
-    pMapped = Find(&sSearch);
-    return pMapped ? pMapped->szClassItfName : NULL;
-}
-
-unsigned int CImpTlbDefItfToClassItfMap::Hash(const ImpTlbClassItfInfo *pData)
-{
-    // Starting value for hash.
-    ULONG   hash = 5381;
-    
-    // Hash in the IID.
-    const BYTE *pbData = reinterpret_cast<const BYTE *>(&pData->ItfIID);
-    int iSize = sizeof(IID);
-    while (--iSize >= 0)
-    {
-        hash = ((hash << 5) + hash) ^ *pbData;
-        ++pbData;
-    }
-
-    return hash;
-} // unsigned int CImpTlbDefItfToClassItfMap::Hash()
-
-unsigned int CImpTlbDefItfToClassItfMap::Compare(const ImpTlbClassItfInfo *p1, ImpTlbClassItfInfo *p2)
-{
-    // Compare the IID's.
-    return memcmp(&p1->ItfIID, &p2->ItfIID, sizeof(IID));
-} // unsigned int CImpTlbEventInfoMap::Compare()
-
-CImpTlbDefItfToClassItfMap::ELEMENTSTATUS CImpTlbDefItfToClassItfMap::Status(ImpTlbClassItfInfo *p)
-{
-    if (IsEqualGUID(p->ItfIID, FREE_STATUS_GUID))
-    {
-        return (FREE);
-    }
-    else if (IsEqualGUID(p->ItfIID, DELETED_STATUS_GUID))
-    {
-        return (DELETED);
-    }
-    return (USED);
-} // CImpTlbDefItfToClassItfMap::ELEMENTSTATUS CImpTlbEventInfoMap::Status()
-
-void CImpTlbDefItfToClassItfMap::SetStatus(ImpTlbClassItfInfo *p, ELEMENTSTATUS s)
-{
-    if (s == FREE)
-    {
-        p->ItfIID = FREE_STATUS_GUID;
-    }
-    else if (s == DELETED)
-    {
-        p->ItfIID = DELETED_STATUS_GUID;
-    }
-    else
-    {
-        _ASSERTE(!"Invalid status!");
-    }
-} // void CImpTlbDefItfToClassItfMap::SetStatus()
-
-void *CImpTlbDefItfToClassItfMap::GetKey(ImpTlbClassItfInfo *p)
-{
-    return p;
-} // void *CImpTlbDefItfToClassItfMap::GetKey()
-
-ImpTlbClassItfInfo* CImpTlbDefItfToClassItfMap::Add(const ImpTlbClassItfInfo *pData)
-{
-    // Add the new entry to the map.
-    const void *pvData = pData;
-    ImpTlbClassItfInfo *pNew = Super::Add(const_cast<void*>(pvData));
-    if (pNew == 0)
-        return 0;
-
-    // Copy the IID.
-    pNew->ItfIID = pData->ItfIID;
-
-    // Copy the class interface name.
-    if (pData->szClassItfName)
-    {
-        pNew->szClassItfName = m_Names.Alloc((ULONG)wcslen(pData->szClassItfName)+1);
-        if (pNew->szClassItfName == 0)
-            return 0;
-        wcscpy_s((LPWSTR)pNew->szClassItfName, wcslen(pData->szClassItfName)+1, pData->szClassItfName);
-    }
-    else
-    {
-        pNew->szClassItfName = NULL;
-    }
-
-    // Return the new entry.
-    return pNew;
-} // ImpTlbEventInfo* CImpTlbEventInfoMap::Add()
-
-// EOF =======================================================================
diff --git a/src/md/enc/liteweightstgdbrw.cpp b/src/md/enc/liteweightstgdbrw.cpp
index 12779f59c0..de81a017b4 100644
--- a/src/md/enc/liteweightstgdbrw.cpp
+++ b/src/md/enc/liteweightstgdbrw.cpp
@@ -1251,28 +1251,5 @@ BOOL
 CLiteWeightStgdbRW::IsValidFileNameLength(
     const WCHAR * wszFileName)
 {
-#ifdef FEATURE_CORECLR
     return TRUE;
-#else
-    static const WCHAR const_wszLongPathPrefix[] = W("\\\\?\\");
-
-    if (wszFileName == NULL)
-    {
-        return TRUE;
-    }
-    size_t cchFileName = wcslen(wszFileName);
-    if (cchFileName < _MAX_PATH)
-    {
-        return TRUE;
-    }
-    if (SString::_wcsnicmp(wszFileName, const_wszLongPathPrefix, _countof(const_wszLongPathPrefix) - 1) != 0)
-    {   // Path does not have long path prefix \\?\ (as required by CreateFile API)
-        return FALSE;
-    }
-    if (cchFileName < 32767)
-    {   // Limit for the long path length as defined in CreateFile API
-        return TRUE;
-    }
-    return FALSE;
-#endif
 } // CLiteWeightStgdbRW::IsValidFileNameLength
diff --git a/src/md/enc/metamodelenc.cpp b/src/md/enc/metamodelenc.cpp
index 4d972827ca..7460d580dc 100644
--- a/src/md/enc/metamodelenc.cpp
+++ b/src/md/enc/metamodelenc.cpp
@@ -263,18 +263,6 @@ CMiniMdRW::ApplyDelta(
         return E_INVALIDARG;
     }
     
-#ifndef FEATURE_CORECLR    
-    // Verify that the delta is based on the base.
-    IfFailGo(mdDelta.getEncBaseIdOfModule(pModDelta, &GuidDelta));
-    IfFailGo(getEncBaseIdOfModule(pModBase,&GuidBase));
-    if (CLRConfig::GetConfigValue(CLRConfig::INTERNAL_MD_DeltaCheck) && 
-        CLRConfig::GetConfigValue(CLRConfig::INTERNAL_MD_UseMinimalDeltas) &&
-        (GuidDelta != GuidBase))
-    {
-        _ASSERTE(!"The Delta MetaData is based on a different generation than the current MetaData.");
-        return E_INVALIDARG;
-    }
-#endif //!FEATURE_CORECLR    
     
     // Let the other md prepare for sparse records.
     IfFailGo(mdDelta.StartENCMap());
@@ -390,19 +378,6 @@ ErrExit:
     HRESULT hrReturn = hr;
     IfFailRet(mdDelta.EndENCMap());
     
-#ifndef FEATURE_CORECLR
-    if (SUCCEEDED(hrReturn) && 
-        CLRConfig::GetConfigValue(CLRConfig::INTERNAL_MD_DeltaCheck) && 
-        CLRConfig::GetConfigValue(CLRConfig::INTERNAL_MD_UseMinimalDeltas))
-    {
-        GUID GuidNewBase;
-        
-        // We'll use the delta's 'delta guid' for our new base guid
-        IfFailRet(mdDelta.getEncIdOfModule(pModDelta, &GuidNewBase));
-        
-        IfFailRet(PutGuid(TBL_Module, ModuleRec::COL_EncBaseId, pModBase, GuidNewBase));
-    }
-#endif //!FEATURE_CORECLR
     
     return hrReturn;
 } // CMiniMdRW::ApplyDelta
diff --git a/src/md/enc/metamodelrw.cpp b/src/md/enc/metamodelrw.cpp
index f9002b6fa9..e6877bc84b 100644
--- a/src/md/enc/metamodelrw.cpp
+++ b/src/md/enc/metamodelrw.cpp
@@ -8228,19 +8228,6 @@ CMiniMdRW::ResetENCLog()
     // Get the module record.
     IfFailGo(GetModuleRecord(1, &pMod));
     
-#ifndef FEATURE_CORECLR
-    if (CLRConfig::GetConfigValue(CLRConfig::INTERNAL_MD_UseMinimalDeltas))
-    {   // Update the ENC Guids
-        GUID encid;
-        // Copy EncId as BaseId.
-        ULONG uVal = GetCol(TBL_Module, ModuleRec::COL_EncId, pMod);
-        IfFailGo(PutCol(TBL_Module, ModuleRec::COL_EncBaseId, pMod, uVal));
-
-        // Allocate a new GUID for EncId.
-        IfFailGo(CoCreateGuid(&encid));
-        IfFailGo(PutGuid(TBL_Module, ModuleRec::COL_EncId, pMod, encid));
-    }
-#endif //!FEATURE_CORECLR
     
     // Reset the pool deltas
     m_StringHeap.StartNewEnCSession();
diff --git a/src/md/inc/assemblymdinternaldisp.h b/src/md/inc/assemblymdinternaldisp.h
index 91b7d2cc29..8e8017ee9b 100644
--- a/src/md/inc/assemblymdinternaldisp.h
+++ b/src/md/inc/assemblymdinternaldisp.h
@@ -14,710 +14,5 @@
 
 #include "../runtime/mdinternalro.h"
 
-#ifdef FEATURE_FUSION
-
-#include "fusionpriv.h"
-
-struct CORCOMPILE_VERSION_INFO;
-struct CORCOMPILE_DEPENDENCY;
-
-//*****************************************************************************
-// This class can support the IMetaDataAssemblyImport and some funcationalities 
-// of IMetaDataImport on the internal import interface (IMDInternalImport).
-//*****************************************************************************
-class AssemblyMDInternalImport :
-    public IMetaDataAssemblyImport,
-    public IMetaDataImport2,
-#ifdef FEATURE_PREJIT
-    public IGetIMDInternalImport,
-#endif //FEATURE_PREJIT
-    public ISNAssemblySignature
-#ifdef FEATURE_PREJIT
-    , public INativeImageInstallInfo
-#endif  // FEATURE_PREJIT
-{
-public:
-    AssemblyMDInternalImport(IMDInternalImport *pMDInternalImport);
-    ~AssemblyMDInternalImport();
-
-    // *** IUnknown methods ***
-    STDMETHODIMP    QueryInterface(REFIID riid, void** ppUnk);
-    STDMETHODIMP_(ULONG) AddRef(void);
-    STDMETHODIMP_(ULONG) Release(void);
-
-    // *** IMetaDataAssemblyImport methods ***
-    STDMETHODIMP GetAssemblyProps (         // S_OK or error.
-        mdAssembly  mda,                    // [IN] The Assembly for which to get the properties.
-        const void  **ppbPublicKey,         // [OUT] Pointer to the public key.
-        ULONG       *pcbPublicKey,          // [OUT] Count of bytes in the public key.
-        ULONG       *pulHashAlgId,          // [OUT] Hash Algorithm.
-        __out_ecount (cchName) LPWSTR szName, // [OUT] Buffer to fill with name.
-        ULONG       cchName,                // [IN] Size of buffer in wide chars.
-        ULONG       *pchName,               // [OUT] Actual # of wide chars in name.
-        ASSEMBLYMETADATA *pMetaData,        // [OUT] Assembly MetaData.
-        DWORD       *pdwAssemblyFlags);         // [OUT] Flags.
-
-    STDMETHODIMP GetAssemblyRefProps (      // S_OK or error.
-        mdAssemblyRef mdar,                 // [IN] The AssemblyRef for which to get the properties.
-        const void  **ppbPublicKeyOrToken,  // [OUT] Pointer to the public key or token.
-        ULONG       *pcbPublicKeyOrToken,   // [OUT] Count of bytes in the public key or token.
-        __out_ecount (cchName) LPWSTR szName, // [OUT] Buffer to fill with name.
-        ULONG       cchName,                // [IN] Size of buffer in wide chars.
-        ULONG       *pchName,               // [OUT] Actual # of wide chars in name.
-        ASSEMBLYMETADATA *pMetaData,        // [OUT] Assembly MetaData.
-        const void  **ppbHashValue,         // [OUT] Hash blob.
-        ULONG       *pcbHashValue,          // [OUT] Count of bytes in the hash blob.
-        DWORD       *pdwAssemblyRefFlags);      // [OUT] Flags.
-
-    STDMETHODIMP GetFileProps (             // S_OK or error.
-        mdFile      mdf,                    // [IN] The File for which to get the properties.
-        __out_ecount (cchName) LPWSTR szName, // [OUT] Buffer to fill with name.
-        ULONG       cchName,                // [IN] Size of buffer in wide chars.
-        ULONG       *pchName,               // [OUT] Actual # of wide chars in name.
-        const void  **ppbHashValue,         // [OUT] Pointer to the Hash Value Blob.
-        ULONG       *pcbHashValue,          // [OUT] Count of bytes in the Hash Value Blob.
-        DWORD       *pdwFileFlags);         // [OUT] Flags.
-
-    STDMETHODIMP GetExportedTypeProps (          // S_OK or error.
-        mdExportedType   mdct,                   // [IN] The ExportedType for which to get the properties.
-        __out_ecount (cchName) LPWSTR szName, // [OUT] Buffer to fill with name.
-        ULONG       cchName,                // [IN] Size of buffer in wide chars.
-        ULONG       *pchName,               // [OUT] Actual # of wide chars in name.
-        mdToken     *ptkImplementation,     // [OUT] mdFile or mdAssemblyRef or mdExportedType.
-        mdTypeDef   *ptkTypeDef,            // [OUT] TypeDef token within the file.
-        DWORD       *pdwExportedTypeFlags);      // [OUT] Flags.
-
-    STDMETHODIMP GetManifestResourceProps ( // S_OK or error.
-        mdManifestResource  mdmr,           // [IN] The ManifestResource for which to get the properties.
-        __out_ecount (cchName) LPWSTR szName, // [OUT] Buffer to fill with name.
-        ULONG       cchName,                // [IN] Size of buffer in wide chars.
-        ULONG       *pchName,               // [OUT] Actual # of wide chars in name.
-        mdToken     *ptkImplementation,     // [OUT] mdFile or mdAssemblyRef that provides the ManifestResource.
-        DWORD       *pdwOffset,             // [OUT] Offset to the beginning of the resource within the file.
-        DWORD       *pdwResourceFlags);     // [OUT] Flags.
-
-    STDMETHODIMP EnumAssemblyRefs (         // S_OK or error
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-        mdAssemblyRef rAssemblyRefs[],      // [OUT] Put AssemblyRefs here.
-        ULONG       cMax,                   // [IN] Max AssemblyRefs to put.
-        ULONG       *pcTokens);             // [OUT] Put # put here.
-
-    STDMETHODIMP EnumFiles (                // S_OK or error
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-        mdFile      rFiles[],               // [OUT] Put Files here.
-        ULONG       cMax,                   // [IN] Max Files to put.
-        ULONG       *pcTokens);             // [OUT] Put # put here.
-
-    STDMETHODIMP EnumExportedTypes (        // S_OK or error
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-        mdExportedType   rExportedTypes[],  // [OUT] Put ExportedTypes here.
-        ULONG       cMax,                   // [IN] Max ExportedTypes to put.
-        ULONG       *pcTokens);             // [OUT] Put # put here.
-
-    STDMETHODIMP EnumManifestResources (    // S_OK or error
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-        mdManifestResource  rManifestResources[],   // [OUT] Put ManifestResources here.
-        ULONG       cMax,                   // [IN] Max Resources to put.
-        ULONG       *pcTokens);             // [OUT] Put # put here.
-
-    STDMETHODIMP GetAssemblyFromScope (     // S_OK or error
-        mdAssembly  *ptkAssembly);          // [OUT] Put token here.
-
-    STDMETHODIMP FindExportedTypeByName (   // S_OK or error
-        LPCWSTR     szName,                 // [IN] Name of the ExportedType.
-        mdToken     mdtExportedType,        // [IN] ExportedType for the enclosing class.
-        mdExportedType   *ptkExportedType);      // [OUT] Put the ExportedType token here.
-
-    STDMETHODIMP FindManifestResourceByName (  // S_OK or error
-        LPCWSTR     szName,                 // [IN] Name of the ManifestResource.
-        mdManifestResource *ptkManifestResource);       // [OUT] Put the ManifestResource token here.
-
-    STDMETHOD_(void, CloseEnum)(
-        HCORENUM hEnum);                    // Enum to be closed.
-
-    STDMETHODIMP FindAssembliesByName (     // S_OK or error
-        LPCWSTR  szAppBase,                 // [IN] optional - can be NULL
-        LPCWSTR  szPrivateBin,              // [IN] optional - can be NULL
-        LPCWSTR  szAssemblyName,            // [IN] required - this is the assembly you are requesting
-        IUnknown *ppIUnk[],                 // [OUT] put IMetaDataAssemblyImport pointers here
-        ULONG    cMax,                      // [IN] The max number to put
-        ULONG    *pcAssemblies);            // [OUT] The number of assemblies returned.
-
-    // *** IMetaDataImport methods ***
-    STDMETHOD(CountEnum)(HCORENUM hEnum, ULONG *pulCount);
-    STDMETHOD(ResetEnum)(HCORENUM hEnum, ULONG ulPos);     
-    STDMETHOD(EnumTypeDefs)(HCORENUM *phEnum, mdTypeDef rTypeDefs[],
-                            ULONG cMax, ULONG *pcTypeDefs);     
-    STDMETHOD(EnumInterfaceImpls)(HCORENUM *phEnum, mdTypeDef td,
-                            mdInterfaceImpl rImpls[], ULONG cMax,
-                            ULONG* pcImpls);     
-    STDMETHOD(EnumTypeRefs)(HCORENUM *phEnum, mdTypeRef rTypeRefs[],
-                            ULONG cMax, ULONG* pcTypeRefs);     
-
-    STDMETHOD(FindTypeDefByName)(           // S_OK or error.
-        LPCWSTR     szTypeDef,              // [IN] Name of the Type.
-        mdToken     tkEnclosingClass,       // [IN] TypeDef/TypeRef for Enclosing class.
-        mdTypeDef   *ptd);                  // [OUT] Put the TypeDef token here.
-
-    STDMETHOD(GetScopeProps)(
-      __out_ecount_part_opt(cchName, *pchName)
-        LPWSTR  wszName,    // [OUT] Put the name here.
-        ULONG   cchName,    // [IN] Size of name buffer in wide chars.
-        ULONG * pchName,    // [OUT] Put size of name (wide chars) here.
-        GUID *  pMvid);     // [OUT, OPTIONAL] Put MVID here.
-
-    STDMETHOD(GetModuleFromScope)(          // S_OK.
-        mdModule    *pmd);                  // [OUT] Put mdModule token here.
-
-    STDMETHOD(GetTypeDefProps)(
-        mdTypeDef td,               // [IN] TypeDef token for inquiry.
-      __out_ecount_part_opt(cchTypeDef, *pchTypeDef)
-        LPWSTR    wszTypeDef,       // [OUT] Put name here.
-        ULONG     cchTypeDef,       // [IN] size of name buffer in wide chars.
-        ULONG *   pchTypeDef,       // [OUT] put size of name (wide chars) here.
-        DWORD *   pdwTypeDefFlags,  // [OUT] Put flags here.
-        mdToken * ptkExtends);      // [OUT] Put base class TypeDef/TypeRef here.
-
-    STDMETHOD(GetInterfaceImplProps)(       // S_OK or error.
-        mdInterfaceImpl iiImpl,             // [IN] InterfaceImpl token.
-        mdTypeDef   *pClass,                // [OUT] Put implementing class token here.
-        mdToken     *ptkIface);             // [OUT] Put implemented interface token here.              
-
-    STDMETHOD(GetTypeRefProps)(
-        mdTypeRef tr,                   // [IN] TypeRef token.
-        mdToken * ptkResolutionScope,   // [OUT] Resolution scope, ModuleRef or AssemblyRef.
-      __out_ecount_part_opt(cchName, *pchName)
-        LPWSTR    wszName,              // [OUT] Name of the TypeRef.
-        ULONG     cchName,              // [IN] Size of buffer.
-        ULONG *   pchName);             // [OUT] Size of Name.
-
-    STDMETHOD(ResolveTypeRef)(mdTypeRef tr, REFIID riid, IUnknown **ppIScope, mdTypeDef *ptd);     
-
-    STDMETHOD(EnumMembers)(                 // S_OK, S_FALSE, or error. 
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.    
-        mdTypeDef   cl,                     // [IN] TypeDef to scope the enumeration.   
-        mdToken     rMembers[],             // [OUT] Put MemberDefs here.   
-        ULONG       cMax,                   // [IN] Max MemberDefs to put.  
-        ULONG       *pcTokens);             // [OUT] Put # put here.    
-
-    STDMETHOD(EnumMembersWithName)(         // S_OK, S_FALSE, or error.             
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.                
-        mdTypeDef   cl,                     // [IN] TypeDef to scope the enumeration.   
-        LPCWSTR     szName,                 // [IN] Limit results to those with this name.              
-        mdToken     rMembers[],             // [OUT] Put MemberDefs here.                   
-        ULONG       cMax,                   // [IN] Max MemberDefs to put.              
-        ULONG       *pcTokens);             // [OUT] Put # put here.    
-
-    STDMETHOD(EnumMethods)(                 // S_OK, S_FALSE, or error. 
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.    
-        mdTypeDef   cl,                     // [IN] TypeDef to scope the enumeration.   
-        mdMethodDef rMethods[],             // [OUT] Put MethodDefs here.   
-        ULONG       cMax,                   // [IN] Max MethodDefs to put.  
-        ULONG       *pcTokens);             // [OUT] Put # put here.    
-
-    STDMETHOD(EnumMethodsWithName)(         // S_OK, S_FALSE, or error.             
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.                
-        mdTypeDef   cl,                     // [IN] TypeDef to scope the enumeration.   
-        LPCWSTR     szName,                 // [IN] Limit results to those with this name.              
-        mdMethodDef rMethods[],             // [OU] Put MethodDefs here.    
-        ULONG       cMax,                   // [IN] Max MethodDefs to put.              
-        ULONG       *pcTokens);             // [OUT] Put # put here.    
-
-    STDMETHOD(EnumFields)(                 // S_OK, S_FALSE, or error.  
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.    
-        mdTypeDef   cl,                     // [IN] TypeDef to scope the enumeration.   
-        mdFieldDef  rFields[],              // [OUT] Put FieldDefs here.    
-        ULONG       cMax,                   // [IN] Max FieldDefs to put.   
-        ULONG       *pcTokens);             // [OUT] Put # put here.    
-
-    STDMETHOD(EnumFieldsWithName)(         // S_OK, S_FALSE, or error.              
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.                
-        mdTypeDef   cl,                     // [IN] TypeDef to scope the enumeration.   
-        LPCWSTR     szName,                 // [IN] Limit results to those with this name.              
-        mdFieldDef  rFields[],              // [OUT] Put MemberDefs here.                   
-        ULONG       cMax,                   // [IN] Max MemberDefs to put.              
-        ULONG       *pcTokens);             // [OUT] Put # put here.    
-
-
-    STDMETHOD(EnumParams)(                  // S_OK, S_FALSE, or error. 
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.    
-        mdMethodDef mb,                     // [IN] MethodDef to scope the enumeration. 
-        mdParamDef  rParams[],              // [OUT] Put ParamDefs here.    
-        ULONG       cMax,                   // [IN] Max ParamDefs to put.   
-        ULONG       *pcTokens);             // [OUT] Put # put here.    
-
-    STDMETHOD(EnumMemberRefs)(              // S_OK, S_FALSE, or error. 
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.    
-        mdToken     tkParent,               // [IN] Parent token to scope the enumeration.  
-        mdMemberRef rMemberRefs[],          // [OUT] Put MemberRefs here.   
-        ULONG       cMax,                   // [IN] Max MemberRefs to put.  
-        ULONG       *pcTokens);             // [OUT] Put # put here.    
-
-    STDMETHOD(EnumMethodImpls)(             // S_OK, S_FALSE, or error  
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.    
-        mdTypeDef   td,                     // [IN] TypeDef to scope the enumeration.   
-        mdToken     rMethodBody[],          // [OUT] Put Method Body tokens here.   
-        mdToken     rMethodDecl[],          // [OUT] Put Method Declaration tokens here.
-        ULONG       cMax,                   // [IN] Max tokens to put.  
-        ULONG       *pcTokens);             // [OUT] Put # put here.    
-
-    STDMETHOD(EnumPermissionSets)(          // S_OK, S_FALSE, or error. 
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.    
-        mdToken     tk,                     // [IN] if !NIL, token to scope the enumeration.    
-        DWORD       dwActions,              // [IN] if !0, return only these actions.   
-        mdPermission rPermission[],         // [OUT] Put Permissions here.  
-        ULONG       cMax,                   // [IN] Max Permissions to put. 
-        ULONG       *pcTokens);             // [OUT] Put # put here.    
-
-    STDMETHOD(FindMember)(  
-        mdTypeDef   td,                     // [IN] given typedef   
-        LPCWSTR     szName,                 // [IN] member name 
-        PCCOR_SIGNATURE pvSigBlob,          // [IN] point to a blob value of COM+ signature 
-        ULONG       cbSigBlob,              // [IN] count of bytes in the signature blob    
-        mdToken     *pmb);                  // [OUT] matching memberdef 
-
-    STDMETHOD(FindMethod)(  
-        mdTypeDef   td,                     // [IN] given typedef   
-        LPCWSTR     szName,                 // [IN] member name 
-        PCCOR_SIGNATURE pvSigBlob,          // [IN] point to a blob value of COM+ signature 
-        ULONG       cbSigBlob,              // [IN] count of bytes in the signature blob    
-        mdMethodDef *pmb);                  // [OUT] matching memberdef 
-
-    STDMETHOD(FindField)(   
-        mdTypeDef   td,                     // [IN] given typedef   
-        LPCWSTR     szName,                 // [IN] member name 
-        PCCOR_SIGNATURE pvSigBlob,          // [IN] point to a blob value of COM+ signature 
-        ULONG       cbSigBlob,              // [IN] count of bytes in the signature blob    
-        mdFieldDef  *pmb);                  // [OUT] matching memberdef 
-
-    STDMETHOD(FindMemberRef)(   
-        mdTypeRef   td,                     // [IN] given typeRef   
-        LPCWSTR     szName,                 // [IN] member name 
-        PCCOR_SIGNATURE pvSigBlob,          // [IN] point to a blob value of COM+ signature 
-        ULONG       cbSigBlob,              // [IN] count of bytes in the signature blob    
-        mdMemberRef *pmr);                  // [OUT] matching memberref 
-
-    STDMETHOD (GetMethodProps)( 
-        mdMethodDef       mb,               // The method for which to get props.
-        mdTypeDef   *     pClass,           // Put method's class here.
-      __out_ecount_part_opt(cchMethod, *pchMethod)
-        LPWSTR            wszMethod,        // Put method's name here.
-        ULONG             cchMethod,        // Size of szMethod buffer in wide chars.
-        ULONG *           pchMethod,        // Put actual size here.
-        DWORD *           pdwAttr,          // Put flags here.
-        PCCOR_SIGNATURE * ppvSigBlob,       // [OUT] point to the blob value of meta data
-        ULONG *           pcbSigBlob,       // [OUT] actual size of signature blob
-        ULONG *           pulCodeRVA,       // [OUT] codeRVA
-        DWORD *           pdwImplFlags);    // [OUT] Impl. Flags
-
-    STDMETHOD(GetMemberRefProps)(
-        mdMemberRef       mr,           // [IN] given memberref 
-        mdToken *         ptk,          // [OUT] Put classref or classdef here. 
-      __out_ecount_part_opt(cchMember, *pchMember)
-        LPWSTR            wszMember,    // [OUT] buffer to fill for member's name   
-        ULONG             cchMember,    // [IN] the count of char of szMember   
-        ULONG *           pchMember,    // [OUT] actual count of char in member name    
-        PCCOR_SIGNATURE * ppvSigBlob,   // [OUT] point to meta data blob value  
-        ULONG *           pbSig);       // [OUT] actual size of signature blob  
-
-    STDMETHOD(EnumProperties)(              // S_OK, S_FALSE, or error. 
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.    
-        mdTypeDef   td,                     // [IN] TypeDef to scope the enumeration.   
-        mdProperty  rProperties[],          // [OUT] Put Properties here.   
-        ULONG       cMax,                   // [IN] Max properties to put.  
-        ULONG       *pcProperties);         // [OUT] Put # put here.    
-
-    STDMETHOD(EnumEvents)(                  // S_OK, S_FALSE, or error. 
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.    
-        mdTypeDef   td,                     // [IN] TypeDef to scope the enumeration.   
-        mdEvent     rEvents[],              // [OUT] Put events here.   
-        ULONG       cMax,                   // [IN] Max events to put.  
-        ULONG       *pcEvents);             // [OUT] Put # put here.    
-
-    STDMETHOD(GetEventProps)(               // S_OK, S_FALSE, or error. 
-        mdEvent     ev,                     // [IN] event token 
-        mdTypeDef   *pClass,                // [OUT] typedef containing the event declarion.    
-        LPCWSTR     szEvent,                // [OUT] Event name 
-        ULONG       cchEvent,               // [IN] the count of wchar of szEvent   
-        ULONG       *pchEvent,              // [OUT] actual count of wchar for event's name 
-        DWORD       *pdwEventFlags,         // [OUT] Event flags.   
-        mdToken     *ptkEventType,          // [OUT] EventType class    
-        mdMethodDef *pmdAddOn,              // [OUT] AddOn method of the event  
-        mdMethodDef *pmdRemoveOn,           // [OUT] RemoveOn method of the event   
-        mdMethodDef *pmdFire,               // [OUT] Fire method of the event   
-        mdMethodDef rmdOtherMethod[],       // [OUT] other method of the event  
-        ULONG       cMax,                   // [IN] size of rmdOtherMethod  
-        ULONG       *pcOtherMethod);        // [OUT] total number of other method of this event 
-
-    STDMETHOD(EnumMethodSemantics)(         // S_OK, S_FALSE, or error. 
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.    
-        mdMethodDef mb,                     // [IN] MethodDef to scope the enumeration. 
-        mdToken     rEventProp[],           // [OUT] Put Event/Property here.   
-        ULONG       cMax,                   // [IN] Max properties to put.  
-        ULONG       *pcEventProp);          // [OUT] Put # put here.    
-
-    STDMETHOD(GetMethodSemantics)(          // S_OK, S_FALSE, or error. 
-        mdMethodDef mb,                     // [IN] method token    
-        mdToken     tkEventProp,            // [IN] event/property token.   
-        DWORD       *pdwSemanticsFlags);      // [OUT] the role flags for the method/propevent pair 
-
-    STDMETHOD(GetClassLayout) ( 
-        mdTypeDef   td,                     // [IN] give typedef    
-        DWORD       *pdwPackSize,           // [OUT] 1, 2, 4, 8, or 16  
-        COR_FIELD_OFFSET rFieldOffset[],    // [OUT] field offset array 
-        ULONG       cMax,                   // [IN] size of the array   
-        ULONG       *pcFieldOffset,         // [OUT] needed array size  
-        ULONG       *pulClassSize);             // [OUT] the size of the class  
-
-    STDMETHOD(GetFieldMarshal) (    
-        mdToken     tk,                     // [IN] given a field's memberdef   
-        PCCOR_SIGNATURE *ppvNativeType,     // [OUT] native type of this field  
-        ULONG       *pcbNativeType);        // [OUT] the count of bytes of *ppvNativeType   
-
-    STDMETHOD(GetRVA)(                      // S_OK or error.   
-        mdToken     tk,                     // Member for which to set offset   
-        ULONG       *pulCodeRVA,            // The offset   
-        DWORD       *pdwImplFlags);         // the implementation flags 
-
-    STDMETHOD(GetPermissionSetProps) (  
-        mdPermission pm,                    // [IN] the permission token.   
-        DWORD       *pdwAction,             // [OUT] CorDeclSecurity.   
-        void const  **ppvPermission,        // [OUT] permission blob.   
-        ULONG       *pcbPermission);        // [OUT] count of bytes of pvPermission.    
-
-    STDMETHOD(GetSigFromToken)(             // S_OK or error.   
-        mdSignature mdSig,                  // [IN] Signature token.    
-        PCCOR_SIGNATURE *ppvSig,            // [OUT] return pointer to token.   
-        ULONG       *pcbSig);               // [OUT] return size of signature.  
-
-    STDMETHOD(GetModuleRefProps)(
-        mdModuleRef mur,        // [IN] moduleref token.
-      __out_ecount_part_opt(cchName, *pchName)
-        LPWSTR      wszName,    // [OUT] buffer to fill with the moduleref name.
-        ULONG       cchName,    // [IN] size of szName in wide characters.
-        ULONG *      pchName);  // [OUT] actual count of characters in the name.
-
-    STDMETHOD(EnumModuleRefs)(              // S_OK or error.   
-        HCORENUM    *phEnum,                // [IN|OUT] pointer to the enum.    
-        mdModuleRef rModuleRefs[],          // [OUT] put modulerefs here.   
-        ULONG       cmax,                   // [IN] max memberrefs to put.  
-        ULONG       *pcModuleRefs);         // [OUT] put # put here.    
-
-    STDMETHOD(GetTypeSpecFromToken)(        // S_OK or error.   
-        mdTypeSpec typespec,                // [IN] TypeSpec token.    
-        PCCOR_SIGNATURE *ppvSig,            // [OUT] return pointer to TypeSpec signature  
-        ULONG       *pcbSig);               // [OUT] return size of signature.  
-
-    STDMETHOD(GetNameFromToken)(            // <TODO>Not Recommended! May be removed!</TODO>
-        mdToken     tk,                     // [IN] Token to get name from.  Must have a name.
-        MDUTF8CSTR  *pszUtf8NamePtr);       // [OUT] Return pointer to UTF8 name in heap.
-
-    STDMETHOD(EnumUnresolvedMethods)(       // S_OK, S_FALSE, or error. 
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.    
-        mdToken     rMethods[],             // [OUT] Put MemberDefs here.   
-        ULONG       cMax,                   // [IN] Max MemberDefs to put.  
-        ULONG       *pcTokens);             // [OUT] Put # put here.    
-
-    STDMETHOD(GetUserString)(
-        mdString stk,           // [IN] String token.
-      __out_ecount_part_opt(cchString, *pchString)
-        LPWSTR   wszString,     // [OUT] Copy of string.
-        ULONG    cchString,     // [IN] Max chars of room in szString.
-        ULONG *  pchString);    // [OUT] How many chars in actual string.
-
-    STDMETHOD(GetPinvokeMap)(
-        mdToken       tk,               // [IN] FieldDef or MethodDef.
-        DWORD *       pdwMappingFlags,  // [OUT] Flags used for mapping.
-      __out_ecount_part_opt(cchImportName, *pchImportName)
-        LPWSTR        wszImportName,    // [OUT] Import name.
-        ULONG         cchImportName,    // [IN] Size of the name buffer.
-        ULONG *       pchImportName,    // [OUT] Actual number of characters stored.
-        mdModuleRef * pmrImportDLL);    // [OUT] ModuleRef token for the target DLL.
-
-    STDMETHOD(EnumSignatures)(              // S_OK or error.
-        HCORENUM    *phEnum,                // [IN|OUT] pointer to the enum.    
-        mdSignature rSignatures[],          // [OUT] put signatures here.   
-        ULONG       cmax,                   // [IN] max signatures to put.  
-        ULONG       *pcSignatures);         // [OUT] put # put here.
-
-    STDMETHOD(EnumTypeSpecs)(               // S_OK or error.
-        HCORENUM    *phEnum,                // [IN|OUT] pointer to the enum.    
-        mdTypeSpec  rTypeSpecs[],           // [OUT] put TypeSpecs here.   
-        ULONG       cmax,                   // [IN] max TypeSpecs to put.  
-        ULONG       *pcTypeSpecs);          // [OUT] put # put here.
-
-    STDMETHOD(EnumUserStrings)(             // S_OK or error.
-        HCORENUM    *phEnum,                // [IN/OUT] pointer to the enum.
-        mdString    rStrings[],             // [OUT] put Strings here.
-        ULONG       cmax,                   // [IN] max Strings to put.
-        ULONG       *pcStrings);            // [OUT] put # put here.
-
-    STDMETHOD(GetParamForMethodIndex)(      // S_OK or error.
-        mdMethodDef md,                     // [IN] Method token.
-        ULONG       ulParamSeq,             // [IN] Parameter sequence.
-        mdParamDef  *ppd);                  // [IN] Put Param token here.
-
-    STDMETHOD(EnumCustomAttributes)(        // S_OK or error.
-        HCORENUM    *phEnum,                // [IN, OUT] COR enumerator.
-        mdToken     tk,                     // [IN] Token to scope the enumeration, 0 for all.
-        mdToken     tkType,                 // [IN] Type of interest, 0 for all.
-        mdCustomAttribute rCustomAttributes[], // [OUT] Put custom attribute tokens here.
-        ULONG       cMax,                   // [IN] Size of rCustomAttributes.
-        ULONG       *pcCustomAttributes);       // [OUT, OPTIONAL] Put count of token values here.
-
-    STDMETHOD(GetCustomAttributeProps)(     // S_OK or error.
-        mdCustomAttribute cv,               // [IN] CustomAttribute token.
-        mdToken     *ptkObj,                // [OUT, OPTIONAL] Put object token here.
-        mdToken     *ptkType,               // [OUT, OPTIONAL] Put AttrType token here.
-        void const  **ppBlob,               // [OUT, OPTIONAL] Put pointer to data here.
-        ULONG       *pcbSize);              // [OUT, OPTIONAL] Put size of date here.
-
-    STDMETHOD(FindTypeRef)(   
-        mdToken     tkResolutionScope,      // [IN] ModuleRef, AssemblyRef or TypeRef.
-        LPCWSTR     szName,                 // [IN] TypeRef Name.
-        mdTypeRef   *ptr);                  // [OUT] matching TypeRef.
-
-    STDMETHOD(GetMemberProps)(  
-        mdToken           mb,               // The member for which to get props.   
-        mdTypeDef *       pClass,           // Put member's class here. 
-      __out_ecount_part_opt(cchMember, *pchMember)
-        LPWSTR            wszMember,        // Put member's name here.  
-        ULONG             cchMember,        // Size of szMember buffer in wide chars.   
-        ULONG *           pchMember,        // Put actual size here 
-        DWORD *           pdwAttr,          // Put flags here.  
-        PCCOR_SIGNATURE * ppvSigBlob,       // [OUT] point to the blob value of meta data   
-        ULONG *           pcbSigBlob,       // [OUT] actual size of signature blob  
-        ULONG *           pulCodeRVA,       // [OUT] codeRVA    
-        DWORD *           pdwImplFlags,     // [OUT] Impl. Flags    
-        DWORD *           pdwCPlusTypeFlag, // [OUT] flag for value type. selected ELEMENT_TYPE_*   
-        UVCP_CONSTANT *   ppValue,          // [OUT] constant value 
-        ULONG *           pcchValue);       // [OUT] size of constant string in chars, 0 for non-strings.
-
-    STDMETHOD(GetFieldProps)(  
-        mdFieldDef  mb,                     // The field for which to get props.
-        mdTypeDef * pClass,                 // Put field's class here.
-      __out_ecount_part_opt(cchField, *pchField)
-        LPWSTR            szField,          // Put field's name here.
-        ULONG             cchField,         // Size of szField buffer in wide chars.
-        ULONG *           pchField,         // Put actual size here.
-        DWORD *           pdwAttr,          // Put flags here.
-        PCCOR_SIGNATURE * ppvSigBlob,       // [OUT] point to the blob value of meta data.
-        ULONG *           pcbSigBlob,       // [OUT] actual size of signature blob.
-        DWORD *           pdwCPlusTypeFlag, // [OUT] flag for value type. selected ELEMENT_TYPE_*.
-        UVCP_CONSTANT *   ppValue,          // [OUT] constant value.
-        ULONG *           pcchValue);       // [OUT] size of constant string in chars, 0 for non-strings.
-
-    STDMETHOD(GetPropertyProps)(            // S_OK, S_FALSE, or error. 
-        mdProperty  prop,                   // [IN] property token  
-        mdTypeDef   *pClass,                // [OUT] typedef containing the property declarion. 
-        LPCWSTR     szProperty,             // [OUT] Property name  
-        ULONG       cchProperty,            // [IN] the count of wchar of szProperty    
-        ULONG       *pchProperty,           // [OUT] actual count of wchar for property name    
-        DWORD       *pdwPropFlags,          // [OUT] property flags.    
-        PCCOR_SIGNATURE *ppvSig,            // [OUT] property type. pointing to meta data internal blob 
-        ULONG       *pbSig,                 // [OUT] count of bytes in *ppvSig  
-        DWORD       *pdwCPlusTypeFlag,      // [OUT] flag for value type. selected ELEMENT_TYPE_*   
-        UVCP_CONSTANT *ppDefaultValue,      // [OUT] constant value 
-        ULONG       *pcchDefaultValue,      // [OUT] size of constant string in chars, 0 for non-strings.
-        mdMethodDef *pmdSetter,             // [OUT] setter method of the property  
-        mdMethodDef *pmdGetter,             // [OUT] getter method of the property  
-        mdMethodDef rmdOtherMethod[],       // [OUT] other method of the property   
-        ULONG       cMax,                   // [IN] size of rmdOtherMethod  
-        ULONG       *pcOtherMethod);        // [OUT] total number of other method of this property  
-
-    STDMETHOD(GetParamProps)(
-        mdParamDef      tk,                 // [IN]The Parameter.
-        mdMethodDef *   pmd,                // [OUT] Parent Method token.
-        ULONG *         pulSequence,        // [OUT] Parameter sequence.
-      __out_ecount_part_opt(cchName, *pchName)
-        LPWSTR          wszName,            // [OUT] Put name here.
-        ULONG           cchName,            // [OUT] Size of name buffer.
-        ULONG *         pchName,            // [OUT] Put actual size of name here.
-        DWORD *         pdwAttr,            // [OUT] Put flags here.
-        DWORD *         pdwCPlusTypeFlag,   // [OUT] Flag for value type. selected ELEMENT_TYPE_*.
-        UVCP_CONSTANT * ppValue,            // [OUT] Constant value.
-        ULONG *         pcchValue);         // [OUT] size of constant string in chars, 0 for non-strings.
-
-    STDMETHOD(GetCustomAttributeByName)(    // S_OK or error.
-        mdToken     tkObj,                  // [IN] Object with Custom Attribute.
-        LPCWSTR     szName,                 // [IN] Name of desired Custom Attribute.
-        const void  **ppData,               // [OUT] Put pointer to data here.
-        ULONG       *pcbData);              // [OUT] Put size of data here.
-
-    STDMETHOD_(BOOL, IsValidToken)(         // True or False.
-        mdToken     tk);                    // [IN] Given token.
-
-    STDMETHOD(GetNestedClassProps)(         // S_OK or error.
-        mdTypeDef   tdNestedClass,          // [IN] NestedClass token.
-        mdTypeDef   *ptdEnclosingClass);      // [OUT] EnclosingClass token.
-
-    STDMETHOD(GetNativeCallConvFromSig)(    // S_OK or error.
-        void const  *pvSig,                 // [IN] Pointer to signature.
-        ULONG       cbSig,                  // [IN] Count of signature bytes.
-        ULONG       *pCallConv);            // [OUT] Put calling conv here (see CorPinvokemap).                                                                                        
-
-    STDMETHOD(IsGlobal)(                    // S_OK or error.
-        mdToken     pd,                     // [IN] Type, Field, or Method token.
-        int         *pbGlobal);             // [OUT] Put 1 if global, 0 otherwise.
-
-//*****************************************************************************
-// IMetaDataImport2 methods
-//*****************************************************************************
-    STDMETHOD(GetMethodSpecProps)(
-        mdMethodSpec mi,           // [IN] The method instantiation
-        mdToken *tkParent,                  // [OUT] MethodDef or MemberRef
-        PCCOR_SIGNATURE *ppvSigBlob,        // [OUT] point to the blob value of meta data   
-        ULONG       *pcbSigBlob);           // [OUT] actual size of signature blob 
-
-    STDMETHOD(GetGenericParamProps)(
-        mdGenericParam gp,              // [IN] GenericParam
-        ULONG *        pulParamSeq,     // [OUT] Index of the type parameter
-        DWORD *        pdwParamFlags,   // [OUT] Flags, for future use (e.g. variance)
-        mdToken *      ptOwner,         // [OUT] Owner (TypeDef or MethodDef)
-        DWORD *        pdwReserved,     // [OUT] For future use (e.g. non-type parameters)
-      __out_ecount_part_opt(cchName, *pchName)
-        LPWSTR         wszName,         // [OUT] Put name here
-        ULONG          cchName,         // [IN] Size of buffer
-        ULONG *        pchName);        // [OUT] Put size of name (wide chars) here.
-
-    STDMETHOD(GetGenericParamConstraintProps)( // S_OK or error.
-        mdGenericParamConstraint gpc,       // [IN] GenericParamConstraint
-        mdGenericParam *ptGenericParam,     // [OUT] GenericParam that is constrained
-        mdToken      *ptkConstraintType);   // [OUT] TypeDef/Ref/Spec constraint
-
-    STDMETHOD(EnumGenericParams)(           // S_OK or error.
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.    
-        mdToken      tk,                    // [IN] TypeDef or MethodDef whose generic parameters are requested
-        mdGenericParam rGenericParams[],    // [OUT] Put GenericParams here.   
-        ULONG       cMax,                   // [IN] Max GenericParams to put.  
-        ULONG       *pcGenericParams);      // [OUT] Put # put here.    
-
-    STDMETHOD(EnumGenericParamConstraints)( // S_OK or error.
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.    
-        mdGenericParam tk,                  // [IN] GenericParam whose constraints are requested
-        mdGenericParamConstraint rGenericParamConstraints[],    // [OUT] Put GenericParamConstraints here.   
-        ULONG       cMax,                   // [IN] Max GenericParamConstraints to put.  
-        ULONG       *pcGenericParamConstraints); // [OUT] Put # put here.
-    
-    STDMETHOD(EnumMethodSpecs)(
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.    
-        mdToken      tk,                    // [IN] MethodDef or MemberRef whose MethodSpecs are requested
-        mdMethodSpec rMethodSpecs[],        // [OUT] Put MethodSpecs here.   
-        ULONG       cMax,                   // [IN] Max tokens to put.  
-        ULONG       *pcMethodSpecs);        // [OUT] Put actual count here.    
-
-    STDMETHOD(GetPEKind)(            // S_OK or error.
-        DWORD* pdwPEKind,            // [OUT] The kind of PE (0 - not a PE)
-        DWORD* pdwMachine);          // [OUT] Machine as defined in NT header
-
-    STDMETHOD(GetVersionString)(
-      __out_ecount_part_opt(ccBufSize, *pccBufSize)
-        LPWSTR  pwzBuf,         // Put version string here.
-        DWORD   ccBufSize,      // [in] Size of the buffer, in wide chars.
-        DWORD * pccBufSize);    // [out] Size of the version string, wide chars, including terminating nul.
-    
-
-    // *** ISNAssemblySignature methods ***
-    
-    STDMETHOD(GetSNAssemblySignature)(  // S_OK or error.
-        BYTE        *pbSig,                 // [IN, OUT] Buffer to write signature
-        DWORD       *pcbSig);               // [IN, OUT] Size of buffer, bytes written
-
-
-#ifdef FEATURE_PREJIT
-    // *** IGetIMDInternalImport methods ***
-    
-    STDMETHOD(GetIMDInternalImport) (
-        IMDInternalImport ** ppIMDInternalImport); 
-
-    // *** INativeImageInstallInfo ***
-
-    STDMETHOD (GetSignature) (
-        CORCOMPILE_NGEN_SIGNATURE * pNgenSign
-        );
-
-    STDMETHOD (GetVersionInfo) (
-        CORCOMPILE_VERSION_INFO * pVersionInfo
-        );
-            
-
-    STDMETHOD (GetILSignature) (
-        CORCOMPILE_ASSEMBLY_SIGNATURE * pILSign
-        );
-
-    STDMETHOD (GetConfigMask) (
-        DWORD * pConfigMask
-        );
-
-    STDMETHOD (EnumDependencies) (
-        HCORENUM * phEnum,
-        INativeImageDependency *rDeps[],
-        ULONG cMax,
-        DWORD * pdwCount
-        );
-
-    STDMETHOD (GetDependency) (
-        const CORCOMPILE_NGEN_SIGNATURE *pcngenSign,
-        CORCOMPILE_DEPENDENCY           *pDep   
-        );
-    
-
-#endif  // FEATURE_PREJIT
-    
-    //------------ setters for privates -----------
-    void SetHandle(HCORMODULE hHandle)
-    {
-        RuntimeAddRefHandle(hHandle);
-        m_pHandle = hHandle;
-    }
-
-    void SetPEKind(DWORD dwPEKind)
-    {
-        m_dwPEKind = dwPEKind;
-    }
-
-    void SetMachine(DWORD dwMachine)
-    {
-        m_dwMachine = dwMachine;
-    }
-
-    void SetVersionString(const char* szVersionString)
-    {
-        m_szVersionString = szVersionString;
-    }
-
-    void SetBase(LPVOID base)
-    {
-        m_pBase = base;
-    }
-
-#ifdef FEATURE_PREJIT
-    void SetZapVersionInfo(CORCOMPILE_VERSION_INFO * info, CORCOMPILE_DEPENDENCY * pDeps, COUNT_T cDeps)
-    {
-        m_pZapVersionInfo = info;
-        m_pZapDependencies = pDeps;
-        m_cZapDependencies = cDeps;
-    }
-#endif // FEATURE_PREJIT
-    
-private:
-    LONG                                    m_cRef;
-    HCORMODULE                              m_pHandle;              // Handle to a cached PE image
-    LPVOID                                  m_pBase;                // File mapping (if runtime is not inited)
-#ifdef FEATURE_PREJIT
-    struct CORCOMPILE_VERSION_INFO        * m_pZapVersionInfo;      // Zap image information
-    struct CORCOMPILE_DEPENDENCY          * m_pZapDependencies;     // Zap Dependancies directory
-    COUNT_T                                 m_cZapDependencies;
-#endif  // FEATURE_PREJIT
-    IMDInternalImport                     * m_pMDInternalImport;
-    DWORD                                   m_dwPEKind;
-    DWORD                                   m_dwMachine;
-    const char                            * m_szVersionString;
-#ifdef _DEBUG
-    IMetaDataAssemblyImport               * m_pDebugMDImport;
-#endif //_DEBUG
-};
-
-#endif // FEATURE_FUSION
 
 #endif // __AssemblyMDInternalDispenser__h__
diff --git a/src/md/inc/imptlb.h b/src/md/inc/imptlb.h
deleted file mode 100644
index ba2981a415..0000000000
--- a/src/md/inc/imptlb.h
+++ /dev/null
@@ -1,777 +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.
-//*****************************************************************************
-// File: imptlb.h
-// 
-
-// 
-// TypeLib importer.
-//*****************************************************************************
-#ifndef __imptlb_h__
-#define __imptlb_h__
-
-#ifndef FEATURE_COMINTEROP
-#error FEATURE_COMINTEROP is required for this file
-#endif // FEATURE_COMINTEROP
-#ifndef FEATURE_COMINTEROP_TLB_SUPPORT
-#error FEATURE_COMINTEROP_TLB_SUPPORT is required for this file
-#endif // FEATURE_COMINTEROP_TLB_SUPPORT
-
-//#define TLB_STATS
-
-#define MAX_TLB_VT                  VT_LPWSTR + 1
-#define MAX_INIT_SIG                3
-#define MAX_COM_GUID_SIG            6
-#define MAX_COM_ADDLISTENER_SIG     8
-#define MAX_COM_REMOVELISTENER_SIG  8
-#define CB_MAX_ELEMENT_TYPE         4
-
-// Forward declarations.
-struct ITypeLibImporterNotifySink;
-class Assembly;
-class Module;
-class CImportTlb;
-
-//*****************************************************************************
-// Class to perform memory management.  Memory is not moved as the heap is 
-//  expanded, and all of the allocations are cleaned up in the destructor.
-//*****************************************************************************
-class CWCHARPool : public StgPool
-{
-public:
-    CWCHARPool() : StgPool()
-    {
-        HRESULT hr = InitNew();
-        _ASSERTE(hr == S_OK);
-    }
-
-    // Allocate some bytes from the pool.
-    WCHAR * Alloc(ULONG nChars)
-    {   
-        BYTE *pRslt;
-        // Convert from characters to bytes.
-        nChars *= sizeof(WCHAR);
-        if (nChars > GetCbSegAvailable())
-            if (!Grow(nChars))
-                return 0;
-        pRslt = GetNextLocation();
-        SegAllocate(nChars);
-        return (WCHAR*)pRslt;
-    }
-}; // class CDescPool : public StgPool
-
-
-//*****************************************************************************
-// This helper method is used to track an url to typeref token.  This makes
-// defining new typerefs faster.
-//*****************************************************************************
-class CImpTlbTypeRef
-{
-public:
-    CImpTlbTypeRef() { }
-    ~CImpTlbTypeRef() { m_Map.Clear(); }
-
-    //*****************************************************************************
-    // Look for an existing typeref in the map and return if found.  If not found,
-    // then create a new one and add it to the map for later.
-    //*****************************************************************************
-    HRESULT DefineTypeRef(                  // S_OK or error.
-        IMetaDataEmit *pEmit,               // Emit interface.
-        mdAssemblyRef ar,                   // Containing assembly.
-        const LPCWSTR szURL,                // URL of the TypeDef, wide chars.
-        mdTypeRef   *ptr);                  // Put mdTypeRef here
-
-    class TokenOfTypeRefHashKey
-    {
-    public:
-        mdToken     tkResolutionScope;      // TypeRef's resolution scope.
-        LPCWSTR     szName;                 // TypeRef's name.
-        mdTypeRef   tr;                     // The TypeRef's token.
-    };
-
-private:
-
-    class CTokenOfTypeRefHash : public CClosedHash<class TokenOfTypeRefHashKey>
-    {
-    public:
-        typedef CClosedHash<class TokenOfTypeRefHashKey> Super;
-        typedef TokenOfTypeRefHashKey T;
-
-        CTokenOfTypeRefHash() : CClosedHash<class TokenOfTypeRefHashKey>(101) {}
-        ~CTokenOfTypeRefHash() { Clear(); }
-
-        virtual void Clear();
-        
-        unsigned int Hash(const void *pData) {return Hash((const T*)pData);}
-        unsigned int Hash(const T *pData);
-
-        unsigned int Compare(const void *p1, BYTE *p2) {return Compare((const T*)p1, (T*)p2);}
-        unsigned int Compare(const T *p1, T *p2);
-
-        ELEMENTSTATUS Status(BYTE *p) {return Status((T*)p);}
-        ELEMENTSTATUS Status(T *p);
-
-        void SetStatus(BYTE *p, ELEMENTSTATUS s) {SetStatus((T*)p, s);}
-        void SetStatus(T *p, ELEMENTSTATUS s);
-
-        void* GetKey(BYTE *p) {return GetKey((T*)p);}
-        void *GetKey(T *p);
-        
-        T* Add(const T *pData);
-        
-        CWCHARPool          m_Names;        // Heap of names.
-    };
-
-    CTokenOfTypeRefHash m_Map;          // Map of namespace to token.
-};
-
-
-//*****************************************************************************
-// This helper class is used to track source interface ITypeInfo*'s to event 
-// information.
-//*****************************************************************************
-class ImpTlbEventInfo
-{
-public:
-    LPCWSTR     szSrcItfName;           // The source interface name (the key).
-    mdTypeRef   trEventItf;             // The event interface typedef.
-    LPCWSTR     szEventItfName;         // The event interface name.
-    LPCWSTR     szEventProviderName;    // The event provider name.
-    Assembly*   SrcItfAssembly;         // The assembly where source interface resides.
-};
-
-class CImpTlbEventInfoMap : protected CClosedHash<class ImpTlbEventInfo>
-{
-public:
-    typedef CClosedHash<class ImpTlbEventInfo> Super;
-    typedef ImpTlbEventInfo T;
-
-    CImpTlbEventInfoMap() : CClosedHash<class ImpTlbEventInfo>(101) {}
-    ~CImpTlbEventInfoMap() { Clear(); }
-
-    HRESULT AddEventInfo(LPCWSTR szSrcItfName, mdTypeRef trEventItf, LPCWSTR szEventItfName, LPCWSTR szEventProviderName, Assembly* SrcItfAssembly);
-    ImpTlbEventInfo *FindEventInfo(LPCWSTR szSrcItfName);
-
-    HRESULT GetEventInfoList(CQuickArray<ImpTlbEventInfo*> &qbEvInfoList);
-
-private:
-    unsigned int Hash(const void *pData) {return Hash((const T*)pData);}
-    unsigned int Hash(const T *pData);
-
-    unsigned int Compare(const void *p1, BYTE *p2) {return Compare((const T*)p1, (T*)p2);}
-    unsigned int Compare(const T *p1, T *p2);
-
-    ELEMENTSTATUS Status(BYTE *p) {return Status((T*)p);}
-    ELEMENTSTATUS Status(T *p);
-
-    void SetStatus(BYTE *p, ELEMENTSTATUS s) {SetStatus((T*)p, s);}
-    void SetStatus(T *p, ELEMENTSTATUS s);
-
-    void* GetKey(BYTE *p) {return GetKey((T*)p);}
-    void *GetKey(T *p);
-    
-    T* Add(const T *pData);
-    
-    CWCHARPool          m_Names;        // Heap of names.
-};
-
-
-#if defined(_UNICODE) || defined(UNICODE)
-#define _tHashString(szStr) HashString(szStr)
-#else
-#define _tHashString(szStr) HashStringA(szStr)
-#endif
-
-
-
-//*****************************************************************************
-// This helper template is used by the TStringMap to track an item by its
-// character name.
-//*****************************************************************************
-template <class T> class TStringMapItem : HASHENTRY
-{
-public:
-    TStringMapItem() :
-        m_szString(0)
-    {
-        LIMITED_METHOD_CONTRACT;
-    }
-    ~TStringMapItem()
-    {
-        LIMITED_METHOD_CONTRACT;
-        delete [] m_szString;
-    }
-
-    HRESULT SetString(LPCTSTR szValue)
-    {
-        WRAPPER_NO_CONTRACT;
-        int         iLen = (int)(::_tcslen(szValue) + 1);
-        if ((m_szString = new TCHAR[iLen]) == 0)
-            return (OutOfMemory());
-        ::_tcscpy_s((TCHAR*)m_szString, iLen, szValue);
-        return (S_OK);
-    }
-
-public:
-    LPTSTR      m_szString;             // Key data.
-    T           m_value;                // Value for this key.
-};
-
-
-//*****************************************************************************
-// IMPORTANT: This data structure is deprecated, please do not add any new uses.
-// The hashtable implementation that should be used instead is code:SHash.
-// If code:SHash does not work for you, talk to mailto:clrdeag.
-//*****************************************************************************
-// This template provides a map from string to item, determined by the template
-// type passed in.
-//*****************************************************************************
-template <class T, int iBuckets=17, class TAllocator=CNewData, int iMaxSize=4096>
-class TStringMap :
-    protected CHashTableAndData<TAllocator>
-{
-    typedef CHashTableAndData<TAllocator> Super;
-
-public:
-    typedef TStringMapItem<T> TItemType;
-    typedef TStringMapItem<long> TOffsetType;
-
-#ifndef DACCESS_COMPILE
-
-    TStringMap() :
-        CHashTableAndData<TAllocator>(iBuckets)
-    {
-        LIMITED_METHOD_CONTRACT;
-    }
-
-//*****************************************************************************
-// This is the second part of construction where we do all of the work that
-// can fail.  We also take the array of structs here because the calling class
-// presumably needs to allocate it in its NewInit.
-//*****************************************************************************
-    HRESULT NewInit()                   // Return status.
-    {
-        WRAPPER_NO_CONTRACT;
-        return (CHashTableAndData<TAllocator>::NewInit(
-                                    CNewData::GrowSize(0)/sizeof(TItemType),
-                                    sizeof(TItemType),
-                                    iMaxSize));
-    }
-
-//*****************************************************************************
-// For each item still allocated, invoke its dtor so it frees up anything it
-// holds onto.
-//*****************************************************************************
-    void Clear()
-    {
-        WRAPPER_NO_CONTRACT;
-        HASHFIND    sSrch;
-        TItemType   *p = (TItemType *) FindFirstEntry(&sSrch);
-
-        while (p != 0)
-        {
-            // Call dtor on the item, since m_value is contained the scalar
-            // dtor will get called.
-            p->~TStringMapItem<T>();
-            p = (TItemType *) FindNextEntry(&sSrch);
-        }
-        CHashTableAndData<TAllocator>::Clear();
-    }
-
-#endif // #ifndef DACCESS_COMPILE
-
-//*****************************************************************************
-// Retrieve an item by name.
-//*****************************************************************************
-    T *GetItem(                         // Null or object.
-        LPCTSTR     szKey)              // What to do the lookup on.
-    {
-        WRAPPER_NO_CONTRACT;
-        TItemType   sInfo;
-        TItemType   *ptr;               // Working pointer.
-
-        // Create a key.
-        sInfo.m_szString = (LPTSTR) szKey;
-
-        // Look it up in the hash table.
-        ptr = (TItemType *) Super::Find( _tHashString(szKey), (SIZE_T) &sInfo);
-
-        // Don't let dtor free our string.
-        sInfo.m_szString = 0;
-
-        // If pointer found, return to caller.  To handle T's that have
-        // an operator &(), find raw address without going through &m_value.
-        if (ptr)
-            return ((T *) ((BYTE *) ptr + offsetof(TOffsetType, m_value)));
-        else
-            return (0);
-    }
-
-//*****************************************************************************
-// Initialize an iterator and return the first item.
-//*****************************************************************************
-    TItemType *FindFirstEntry(
-        HASHFIND *psSrch)
-    {
-        WRAPPER_NO_CONTRACT;
-        TItemType   *ptr = (TItemType *) Super::FindFirstEntry(psSrch);
-
-        return (ptr);
-    }
-
-//*****************************************************************************
-// Return the next item, via an iterator.
-//*****************************************************************************
-    TItemType *FindNextEntry(
-        HASHFIND *psSrch)
-    {
-        WRAPPER_NO_CONTRACT;
-        TItemType   *ptr = (TItemType *) Super::FindNextEntry(psSrch);
-
-        return (ptr);
-    }
-
-#ifndef DACCESS_COMPILE
-
-//*****************************************************************************
-// Add an item to the list.
-//*****************************************************************************
-    HRESULT AddItem(                    // S_OK, or S_FALSE.
-        LPCTSTR     szKey,              // The key value for the item.
-        T           &item)              // Thing to add.
-    {
-        WRAPPER_NO_CONTRACT;
-        TItemType   *ptr;               // Working pointer.
-
-        // Allocate an entry in the hash table.
-        if ((ptr = (TItemType *) this->Add( _tHashString(szKey))) == 0)
-            return (OutOfMemory());
-
-        // Fill the record.
-        if (ptr->SetString(szKey) < 0)
-        {
-            DelItem(ptr);
-            return (OutOfMemory());
-        }
-
-        // Call the placement new operator on the item so it can init itself.
-        // To handle T's that have an operator &(), find raw address without
-        // going through &m_value.
-        T *p = new ((void *) ((BYTE *) ptr + offsetof(TOffsetType, m_value))) T;
-        *p = item;
-        return (S_OK);
-    }
-
-//*****************************************************************************
-// Delete an item.
-//*****************************************************************************
-    void DelItem(
-        LPCTSTR     szKey)                  // What to delete.
-    {
-        WRAPPER_NO_CONTRACT;
-        TItemType   sInfo;
-        TItemType   *ptr;               // Working pointer.
-
-        // Create a key.
-        sInfo.m_szString = (LPTSTR) szKey;
-
-        // Look it up in the hash table.
-        ptr = (TItemType *) this->Find( _tHashString(szKey), (BYTE *) &sInfo);
-
-        // Don't let dtor free our string.
-        sInfo.m_szString = 0;
-
-        // If found, delete.
-        if (ptr)
-            DelItem(ptr);
-    }
-
-#endif // #ifndef DACCESS_COMPILE
-
-//*****************************************************************************
-// Compare the keys for two collections.
-//*****************************************************************************
-    BOOL Cmp(                               // 0 or != 0.
-        SIZE_T data,                        // Raw key data on lookup.
-        const HASHENTRY *pElement)          // The element to compare data against.
-    {
-        LIMITED_METHOD_DAC_CONTRACT;
-        TItemType   *p = (TItemType *) (size_t) pElement;
-        return (::_tcscmp(((TItemType *) data)->m_szString, p->m_szString));
-    }
-
-private:
-    void DelItem(
-        TItemType   *pItem)             // Entry to delete.
-    {
-        WRAPPER_NO_CONTRACT;
-        // Need to destruct this item.
-        pItem->~TStringMapItem<T>();
-        CHashTableAndData<TAllocator>::Delete( HashString(pItem->m_szString), (HASHENTRY *)(void *)pItem);
-    }
-};
-
-class CImpTlbReservedNames
-{
-public:
-    CImpTlbReservedNames() {}
-    ~CImpTlbReservedNames() {/*m_StringMap.Clear();*/}
-
-#ifndef DACCESS_COMPILE
-    HRESULT Init() {return m_StringMap.NewInit();}
-
-    void AddReservedName(LPCWSTR szName) {BOOL flag = TRUE; m_StringMap.AddItem(szName, flag);}
-#endif
-    BOOL IsReservedName(LPCWSTR szName) {return m_StringMap.GetItem(szName) != 0;}
-
-private:
-    TStringMap<BOOL>    m_StringMap;
-};
-
-
-//*****************************************************************************
-// Helper class to keep track of the mappings from default interfaces to 
-// class interfaces.
-//*****************************************************************************
-class ImpTlbClassItfInfo
-{
-public:
-    IID         ItfIID;                 // The IID of the interface.
-    LPCWSTR     szClassItfName;         // The class interface name.
-};
-
-class CImpTlbDefItfToClassItfMap : protected CClosedHash<class ImpTlbClassItfInfo>
-{
-public:
-    typedef CClosedHash<class ImpTlbClassItfInfo> Super;
-    typedef ImpTlbClassItfInfo T;
-
-    CImpTlbDefItfToClassItfMap();
-    ~CImpTlbDefItfToClassItfMap();
-
-    HRESULT Init(ITypeLib *pTlb, BSTR bstrNameSpace);
-
-    LPCWSTR GetClassItfName(IID &rItfIID);
-
-private:
-    HRESULT AddCoClassInterfaces(ITypeInfo *pCoClassITI, TYPEATTR *pCoClassTypeAttr);
-
-    unsigned int Hash(const void *pData) {return Hash((const T*)pData);}
-    unsigned int Hash(const T *pData);
-
-    unsigned int Compare(const void *p1, BYTE *p2) {return Compare((const T*)p1, (T*)p2);}
-    unsigned int Compare(const T *p1, T *p2);
-
-    ELEMENTSTATUS Status(BYTE *p) {return Status((T*)p);}
-    ELEMENTSTATUS Status(T *p);
-
-    void SetStatus(BYTE *p, ELEMENTSTATUS s) {SetStatus((T*)p, s);}
-    void SetStatus(T *p, ELEMENTSTATUS s);
-
-    void* GetKey(BYTE *p) {return GetKey((T*)p);}
-    void *GetKey(T *p);
-    
-    T* Add(const T *pData);
-    
-    CWCHARPool          m_Names;            // Heap of names.
-    BSTR                m_bstrNameSpace;    // Namespace of the typelib.
-};
-
-
-//*****************************************************************************
-// Helper class to keep track of imported typelibs.  Typically, a typelib
-//  imports only 2 or 3 other typelibs, so a simple array is used.
-//*****************************************************************************
-struct CTlbRef
-{
-    GUID            guid;               // GUID of referenced typelib.
-    mdAssemblyRef   ar;                 // AssemblyRef for the module containing reference.
-    BSTR            szNameSpace;        // The namespace of the types contained in the assembly.
-    BSTR            szAsmName;          // The assembly name.
-    Assembly*           Asm;                            // The assembly.
-    CImpTlbDefItfToClassItfMap *pDefItfToClassItfMap; // The default interface to class interface map.
-
-    ~CTlbRef() 
-    {
-        SysFreeString(szNameSpace); 
-        SysFreeString(szAsmName);
-        delete pDefItfToClassItfMap;
-    }
-};
-
-class CImpTlbLibRef : public CQuickArray<CTlbRef>
-{
-    typedef CQuickArray<CTlbRef> base;
-public:
-    CImpTlbLibRef() {base::Shrink(0);}
-    ~CImpTlbLibRef();
-
-    HRESULT Add(ITypeLib *pITLB, CImportTlb  *pImporter, mdAssemblyRef ar, BSTR wzNamespace, BSTR wzAsmName, Assembly* assm, CImpTlbDefItfToClassItfMap **ppMap);
-    int Find(ITypeLib *pITLB, mdAssemblyRef *par, BSTR *pwzNamespace, BSTR *pwzAsmName, Assembly** assm, CImpTlbDefItfToClassItfMap **ppDefItfToClassItfMap);
-};
-
-
-class CImportTlb
-{
-public:
-    static CImportTlb* CreateImporter(LPCWSTR szLibrary, ITypeLib *pitlb, BOOL bGenerateTCEAdapters, BOOL bUnsafeInterfaces, BOOL bSafeArrayAsSystemArray, BOOL bTransformDispRetVals, BOOL bPreventClassMembers, BOOL bSerializableValueClasses);
-    
-    CImportTlb();
-    CImportTlb(LPCWSTR szLibrary, ITypeLib *pitlb, BOOL bGenerateTCEAdapters, BOOL bUnsafeInterfaces, BOOL bSafeArrayAsSystemArray, BOOL bTransformDispRetVals, BOOL bPreventClassMembers, BOOL bSerializableValueClasses);
-    ~CImportTlb();
-
-    HRESULT Import();
-    HRESULT SetNamespace(WCHAR const *pNamespace);
-    WCHAR *GetNamespace() {return m_wzNamespace;}
-    HRESULT SetNotification(ITypeLibImporterNotifySink *pINotify);
-    HRESULT SetMetaData(IUnknown *pIUnk);
-    void    SetAssembly(Assembly *pAssembly) {m_pAssembly = pAssembly;}
-    void    SetModule(Module *pModule) {m_pModule = pModule;}
-    HRESULT GetNamespaceOfRefTlb(ITypeLib *pITLB, BSTR *pwzNamespace, CImpTlbDefItfToClassItfMap **ppDefItfToClassItfMap);
-    HRESULT GetEventInfoList(CQuickArray<ImpTlbEventInfo*> &qbEvInfoList) {return m_EventInfoMap.GetEventInfoList(qbEvInfoList);}
-
-    static HRESULT GetDefaultInterface(ITypeInfo *pCoClassTI, ITypeInfo **pDefaultItfTI);
-
-protected:
-    
-    struct MemberInfo
-    {
-        union 
-        {
-            FUNCDESC    *m_psFunc;      // Pointer to FuncDesc.
-            VARDESC     *m_psVar;       // Pointer to VarDesc.
-        };
-        LPWSTR      m_pName;            // Function/Prop's name, possibly decorated.
-        int         m_iMember;          // The index of the member in the ITypeInfo.
-        union
-        {
-            LPWSTR      m_pName2;       // Prop's second name, if any.
-            mdToken     m_mdFunc;       // Function's token & semantics, if not property.
-            USHORT      m_msSemantics;  // Semantics only.
-        };
-        void SetFuncInfo(mdMethodDef mdFunc, USHORT msSemantics) {m_mdFunc = RidFromToken(mdFunc) | (msSemantics<<24);}
-        void GetFuncInfo(mdMethodDef &mdFunc, USHORT &msSemantics) {mdFunc = m_mdFunc&0xffffff | mdtMethodDef; msSemantics = m_mdFunc>>24;}
-    };
-
-    
-    HRESULT ConvertTypeLib();
-    HRESULT ConvertTypeInfo();
-
-    HRESULT ExplicitlyImplementsIEnumerable(ITypeInfo   *pITI, TYPEATTR *psAttr, BOOL fLookupPartner = TRUE);
-
-    HRESULT _NewLibraryObject();
-    HRESULT ConvCoclass(ITypeInfo *pITI, TYPEATTR *psAttr);
-    HRESULT ConvEnum(ITypeInfo *pITI, TYPEATTR *psAttr);
-    HRESULT ConvRecord(ITypeInfo *pITI, TYPEATTR *psAttr, BOOL bUnion);
-    HRESULT ConvIface(ITypeInfo *pITI, TYPEATTR *psAttr, BOOL bVtblGaps=true);
-    HRESULT ConvDispatch(ITypeInfo *pITI, TYPEATTR *psAttr, BOOL bVtblGaps=true);
-    HRESULT ConvModule(ITypeInfo *pITI, TYPEATTR *psAttr);
-
-    HRESULT IsIUnknownDerived(ITypeInfo *pITI, TYPEATTR *psAttr);
-    HRESULT IsIDispatchDerived(ITypeInfo *pITI, TYPEATTR *psAttr);
-    HRESULT HasNewEnumMember(ITypeInfo *pItfTI);
-    HRESULT FuncIsNewEnum(ITypeInfo *pITI, FUNCDESC *pFuncDesc, DWORD index);
-    HRESULT PropertyIsNewEnum(ITypeInfo *pITI, VARDESC *pVarDesc, DWORD index);
-
-    HRESULT HasObjectFields(ITypeInfo *pITI, TYPEATTR *psAttr);
-    HRESULT IsObjectType(ITypeInfo *pITI, const TYPEDESC *pType);
-    HRESULT CompareSigsIgnoringRetType(PCCOR_SIGNATURE pbSig1, ULONG cbSig1, PCCOR_SIGNATURE pbSig2, ULONG cbSig2);
-
-    HRESULT FindMethod(mdTypeDef td, LPCWSTR szName, PCCOR_SIGNATURE pbSig, ULONG cbSig, mdMethodDef *pmb);
-    HRESULT FindProperty(mdTypeDef td, LPCWSTR szName, PCCOR_SIGNATURE pSig, ULONG cbSig, mdProperty *pPr);
-    HRESULT FindEvent(mdTypeDef td, LPCWSTR szName, mdProperty *pEv);
-    
-    HRESULT ReportEvent(int ev, int hr, ...);
-    
-    HRESULT _DefineSysRefs();
-    HRESULT _GetNamespaceName(ITypeLib *pITLB, BSTR *pwzNamespace);
-    HRESULT _GetTokenForTypeInfo(ITypeInfo *pITI, BOOL bConvDefItfToClassItf, mdToken *pToken, __out_ecount (chTypeRef) __out_opt LPWSTR pszTypeRef=0, int chTypeRef=0, int *pchTypeRef=0, BOOL bAsmQualifiedName = FALSE);
-
-    HRESULT _FindFirstUserMethod(ITypeInfo *pITI, TYPEATTR *psAttr, int *pIx);
-    HRESULT _ResolveTypeDescAliasTypeKind(ITypeInfo *pITIAlias, TYPEDESC *ptdesc, TYPEKIND *ptkind);
-    HRESULT _ResolveTypeDescAlias(ITypeInfo *pITIAlias, const TYPEDESC *ptdesc, ITypeInfo **ppTIResolved, TYPEATTR **ppsAttrResolved, GUID *pGuid=0);
-
-    HRESULT _SetHiddenCA(mdTypeDef token);
-    HRESULT _ForceIEnumerableCVExists(ITypeInfo* pITI, BOOL* CVExists);
-    HRESULT _SetDispIDCA(ITypeInfo* pITI, int iMember, long lDispId, mdToken func, BOOL fAlwaysAdd, long* lDispSet, BOOL bFunc);
-    HRESULT _GetDispIDCA(ITypeInfo* pITI, int iMember, long* lDispSet, BOOL bFunc);
-    HRESULT _CheckForPropertyCustomAttributes(ITypeInfo* pITI, int index, INVOKEKIND* ikind);
-
-    HRESULT _ConvIfaceMembers(ITypeInfo *pITI, TYPEATTR *psAttr, BOOL bVtblGaps, BOOL bAddDispIds, BOOL bInheritsIEnum);
-    HRESULT _ConvSrcIfaceMembers(ITypeInfo   *pITI, TYPEATTR* psAttr, BOOL fInheritsIEnum);
-    HRESULT _ConvDispatchMembers(ITypeInfo *pITI, TYPEATTR *psAttr, BOOL fInheritsIEnum);
-    HRESULT _GetFunctionPropertyInfo(FUNCDESC *psFunc, USHORT *pSemantics, FUNCDESC **ppSig, TYPEDESC **ppProperty, BOOL *pbRetval, BOOL fUseLastParam, BSTR strName);
-    HRESULT _ConvFunction(ITypeInfo *pITI, MemberInfo *pMember, int bVtblGapFuncs, BOOL bAddDispIds, BOOL bDelegateInvokeMeth, BOOL* bAllowIEnum);
-    HRESULT _GenerateEvent(ITypeInfo *pITI, MemberInfo  *pMember, BOOL fInheritsIEnum);
-    HRESULT _GenerateEventDelegate(ITypeInfo *pITI, MemberInfo  *pMember, mdTypeDef *ptd, BOOL fInheritsIEnum);
-    HRESULT _AddSrcItfMembersToClass(mdTypeRef trSrcItf);
-
-    HRESULT _ConvPropertiesForFunctions(ITypeInfo *pITI, TYPEATTR *psAttr);
-    enum ParamOpts{ParamNormal=0, ParamOptional, ParamVarArg};
-    HRESULT _ConvParam(ITypeInfo *pITI, mdMethodDef mbFunc, int iSequence, const ELEMDESC *pdesc, ParamOpts paramOpts, const WCHAR *pszName, BYTE *pbNative, ULONG cbNative);
-    HRESULT _ConvConstant(ITypeInfo *pITI, VARDESC *psVar, BOOL bEnumMember=false);
-    HRESULT _ConvField(ITypeInfo *pITI, VARDESC *psVar, mdFieldDef *pmdField, BOOL bUnion);
-    HRESULT _ConvProperty(ITypeInfo *pITI, MemberInfo *pMember);
-    HRESULT _ConvNewEnumProperty(ITypeInfo *pITI, VARDESC *psVar, MemberInfo *pMember);
-
-    HRESULT _HandleAliasInfo(ITypeInfo *pITI, TYPEDESC *pTypeDesc, mdToken tk);
-
-    HRESULT _AddTlbRef(ITypeLib *pITLB, mdAssemblyRef *par, BSTR *pwzNamespace, BSTR *pwzAsmName, CImpTlbDefItfToClassItfMap **ppDefItfToClassItfMap);
-
-    HRESULT _AddGuidCa(mdToken tkObj, REFGUID guid);
-    HRESULT _AddDefaultMemberCa(mdToken tkObj, LPCWSTR szName);
-
-    HRESULT _AddStringCa(int attr, mdToken tk, LPCWSTR wzString);
-
-    HRESULT GetKnownTypeToken(VARTYPE vt, mdTypeRef *ptr);
-
-    HRESULT _GetTokenForEventItf(ITypeInfo *pSrcItfITI, mdTypeRef *ptr);
-    HRESULT _CreateClassInterface(ITypeInfo *pCoClassITI, ITypeInfo *pDefItfITI, mdTypeRef trDefItf, mdTypeRef rtDefEvItf, mdToken *ptr);
-
-    HRESULT GetManagedNameForCoClass(ITypeInfo *pITI, CQuickArray<WCHAR> &qbClassName);
-    HRESULT GenerateUniqueTypeName(CQuickArray<WCHAR> &qbTypeName);
-    HRESULT GenerateUniqueMemberName(CQuickArray<WCHAR> &qbMemberName, PCCOR_SIGNATURE pSig, ULONG SigSize, LPCWSTR szPrefix, mdToken type);
-    HRESULT _IsAlias(ITypeInfo *pITI, TYPEDESC *pTypeDesc);
-
-    HRESULT GetDefMemberName(ITypeInfo *pITI, BOOL bItfQualified, CQuickArray<WCHAR> &qbDefMemberName);
-
-    enum SigFlags {
-        // These match the typelib values
-        SIG_IN          = 0x0001,           // Input param.
-        SIG_OUT         = 0x0002,           // Output param.
-        SIG_RET         = 0x0008,           // Retval.  Currently unused.
-        SIG_OPT         = 0x0010,           // Optional param.  Currently unused.
-        SIG_FLAGS_MASK  = 0x001b,           // Mask of flags from TypeLib PARAMFLAGs
-
-        SIG_FUNC        = 0x0100,           // Convert signature for function.
-        SIG_FIELD       = 0x0200,           // Convert signature for field.
-        SIG_ELEM        = 0x0300,           // Convert signature for sub element (eg, array of X).
-        SIG_TYPE_MASK   = 0x0300,
-
-        SIG_USE_BYREF   = 0x1000,           // If set convert one ptr as E_T_BYREF.
-        SIG_VARARG      = 0x4000,           // If set, this is a paramarray type.  Use szArray, not System.Array.
-
-        SIG_FLAGS_NONE  = 0                 // '0' of this enum type.
-    };    
-
-    #define IsSigIn(flags)              ((flags & SIG_IN) == SIG_IN)
-    #define IsSigOut(flags)             ((flags & SIG_OUT) == SIG_OUT)
-    #define IsSigRet(flags)             ((flags & SIG_RET) == SIG_RET)
-    #define IsSigOpt(flags)             ((flags & SIG_OPT) == SIG_OPT)
-    #define IsSigOutRet(flags)          ((flags & (SIG_OUT|SIG_RET)) == (SIG_OUT|SIG_RET))
-
-    #define IsSigFunc(flags)            ((flags & SIG_TYPE_MASK) == SIG_FUNC)
-    #define IsSigField(flags)           ((flags & SIG_TYPE_MASK) == SIG_FIELD)
-    #define IsSigElem(flags)            ((flags & SIG_TYPE_MASK) == SIG_ELEM)
-    
-    #define IsSigUseByref(flags)        ((flags & SIG_USE_BYREF) == SIG_USE_BYREF)
-    #define IsSigVarArg(flags)          ((flags & SIG_VARARG) == SIG_VARARG)
-
-    HRESULT _ConvSignature(ITypeInfo *pITI, const TYPEDESC *pType, ULONG Flags, CQuickBytes &qbSigBuf, ULONG cbSig, ULONG *pcbSig, CQuickArray<BYTE> &qbNativeTypeBuf, ULONG cbNativeType, ULONG *pcbNativeType, BOOL bNewEnumMember, int iByRef=0);
-
-    // For handling out-of-order vtables.
-    CQuickArray<MemberInfo> m_MemberList;
-    CWCHARPool              *m_pMemberNames;
-    int                     m_cMemberProps;       // Count of props in memberlist.
-    HRESULT BuildMemberList(ITypeInfo *pITI, int iStart, int iEnd, BOOL bInheritsIEnum);
-    HRESULT FreeMemberList(ITypeInfo *pITI);
-
-    // List of predefined token types for custom attributes.
-#define INTEROP_ATTRIBUTES()                            \
-        INTEROP_ATTRIBUTE(DISPID)                       \
-        INTEROP_ATTRIBUTE(CLASSINTERFACE)               \
-        INTEROP_ATTRIBUTE(INTERFACETYPE)                \
-        INTEROP_ATTRIBUTE(TYPELIBTYPE)                  \
-        INTEROP_ATTRIBUTE(TYPELIBVAR)                   \
-        INTEROP_ATTRIBUTE(TYPELIBFUNC)                  \
-        INTEROP_ATTRIBUTE(COMSOURCEINTERFACES)          \
-        INTEROP_ATTRIBUTE(COMCONVERSIONLOSS)            \
-        INTEROP_ATTRIBUTE(GUID)                         \
-        INTEROP_ATTRIBUTE(DEFAULTMEMBER)                \
-        INTEROP_ATTRIBUTE(COMALIASNAME)                 \
-        INTEROP_ATTRIBUTE(PARAMARRAY)                   \
-        INTEROP_ATTRIBUTE(LCIDCONVERSION)               \
-        INTEROP_ATTRIBUTE(DECIMALVALUE)                 \
-        INTEROP_ATTRIBUTE(DATETIMEVALUE)                \
-        INTEROP_ATTRIBUTE(IUNKNOWNVALUE)                \
-        INTEROP_ATTRIBUTE(IDISPATCHVALUE)               \
-        INTEROP_ATTRIBUTE(COMVISIBLE)                   \
-        INTEROP_ATTRIBUTE(SERIALIZABLE)                 \
-        INTEROP_ATTRIBUTE_SPECIAL(COMEVENTINTERFACE)    \
-        INTEROP_ATTRIBUTE_SPECIAL(COCLASS)              \
-
-#define INTEROP_ATTRIBUTE(x) ATTR_##x,
-#define INTEROP_ATTRIBUTE_SPECIAL(x) ATTR_##x,
-    enum {INTEROP_ATTRIBUTES()
-          // Last value gives array size.
-          ATTR_COUNT};
-#undef INTEROP_ATTRIBUTE
-#undef INTEROP_ATTRIBUTE_SPECIAL
-
-    mdToken             m_tkAttr[ATTR_COUNT];
-    HRESULT GetAttrType(int attr, mdToken *ptk);
-
-    // look up table for known type
-    mdTypeRef           m_tkKnownTypes[MAX_TLB_VT];
-
-    LPCWSTR             m_szLibrary;    // Name of typelib being imported.
-    BOOL                m_bGenerateTCEAdapters;     // A flag indicating if the TCE adapters are being generated or not.
-    BOOL                m_bUnsafeInterfaces;        // A flag indicating whether runtime security checks should be disabled on an interface
-    BOOL                m_bSafeArrayAsSystemArray;  // A flag indicating whether to import SAFEARRAY's as System.Array's.
-    BOOL                m_bTransformDispRetVals;    // A flag indicating if we should do [out,retval] transformation on disp only itfs.
-    BOOL                m_bPreventClassMembers;     // A flag indicating if we should add members to CoClasses.
-    BOOL                m_bSerializableValueClasses; // A flag indicating if we should mark value classes as serializable.
-    mdMemberRef         m_tkSuppressCheckAttr;      // Cached ctor for security check custom attribute
-    ITypeLib            *m_pITLB;       // Typelib being imported.
-    IMetaDataEmit2      *m_pEmit;       // Emit API Interface pointer.
-    IMetaDataImport2    *m_pImport;     // Import API Interface pointer.
-
-    BSTR                m_wzNamespace;  // Namespace of the created TypeDefs.
-    mdTypeRef           m_trObject;     // Token of System.Object.
-    mdTypeRef           m_trValueType;  // Token of System.ValueType.
-    mdTypeRef           m_trEnum;       // Token of System.Enum.
-    mdAssemblyRef       m_arSystem;     // AssemblyRef for classlib.
-
-    ITypeInfo           *m_pITI;        // "Current" ITypeInfo being converted.
-    ITypeInfo           *m_pOrigITI;    // Original "Current" ITypeInfo being converted,
-                                        // represents TKIND_ALIAS or is equal to m_pITI.
-
-    TYPEATTR            *m_psAttr;      // "TYPEATTR" of current ITypeInfo.
-
-    BSTR                m_szName;       // Name of original current ITypeInfo.
-    BSTR                m_szMember;     // Name of current Member (method or field).
-    LPWSTR              m_szMngName;    // Full name of the managed type.
-
-    ULONG               m_cbVtableSlot; // Size of a vtable slot. 
-    ULONG               m_Slot;         // "Current" vtbl index within an interface.
-
-    void                *m_psClass;     // "Current" class record. 
-    mdTypeDef           m_tdTypeDef;    // Current TypeDef.
-    mdTypeDef           m_tdHasDefault; // Most recent TypeDef with a default.
-    enum {eImplIfaceNone, eImplIfaceDefault, eImplIface} m_ImplIface;
-    mdToken             m_tkInterface;  // Interface being added to a coclass.
-    BSTR                m_szInterface;  // Interface name for decoration.
-
-    CImpTlbTypeRef      m_TRMap;        // Typeref map.
-    CImpTlbLibRef       m_LibRefs;      // Referenced typelibs.
-    CImpTlbDefItfToClassItfMap m_DefItfToClassItfMap; // The default interface to class interface map.
-    
-    CImpTlbReservedNames m_ReservedNames;    // Reserved names.
-    CImpTlbEventInfoMap  m_EventInfoMap;     // Map of event info's.
-
-    ITypeLibImporterNotifySink *m_Notify;    // Notification object.
-    Assembly            *m_pAssembly;   // Containing assembly.
-    Module              *m_pModule;     // Module we are emiting into.
-    
-#if defined(TLB_STATS)
-    LARGE_INTEGER       m_freqVal;      // Frequency of perf counter.
-    BOOL                m_bStats;       // If true, collect timings.
-#endif // TLB_STATS
-};
-
-
-
-#endif
-
-//-eof-************************************************************************
diff --git a/src/md/inc/metamodelrw.h b/src/md/inc/metamodelrw.h
index 6e00d3cf3e..c2d24db8a5 100644
--- a/src/md/inc/metamodelrw.h
+++ b/src/md/inc/metamodelrw.h
@@ -1420,10 +1420,6 @@ public:
     void EnableDeltaMetadataGeneration() 
     {
         _ASSERTE(m_OptionValue.m_UpdateMode == MDUpdateENC);
-#ifndef FEATURE_CORECLR
-        if (CLRConfig::GetConfigValue(CLRConfig::INTERNAL_MD_UseMinimalDeltas))
-            m_OptionValue.m_UpdateMode = MDUpdateDelta;
-#endif //!FEATURE_CORECLR
     }
     void DisableDeltaMetadataGeneration() {m_OptionValue.m_UpdateMode = MDUpdateENC;}
 
diff --git a/src/md/inc/winmdinterfaces.h b/src/md/inc/winmdinterfaces.h
index 4233e615d3..47f43df083 100644
--- a/src/md/inc/winmdinterfaces.h
+++ b/src/md/inc/winmdinterfaces.h
@@ -103,15 +103,7 @@ HRESULT VerifyNotWinMDHelper(IUnknown *pUnknown
                             ,int       line
 #endif //_DEBUG
                             );
-#if defined(FEATURE_METADATA_IN_VM) && !defined(FEATURE_CORECLR)
-#ifdef _DEBUG
-#define VerifyNotWinMD(pUnknown, assertMsg) VerifyNotWinMDHelper(pUnknown, assertMsg, __FILE__, __LINE__)
-#else
-#define VerifyNotWinMD(pUnknown, assertMsg) VerifyNotWinMDHelper(pUnknown)
-#endif
-#else
 #define VerifyNotWinMD(pUnknown, assertMsg) S_OK
-#endif // FEATURE_METADATA_IN_VM 
 
 
 #endif //__WINMDINTERFACES_H__
diff --git a/src/md/runtime/mdinternaldisp.cpp b/src/md/runtime/mdinternaldisp.cpp
index 1f5725ff01..34ea0205b3 100644
--- a/src/md/runtime/mdinternaldisp.cpp
+++ b/src/md/runtime/mdinternaldisp.cpp
@@ -228,1607 +228,5 @@ ErrExit:
 }   // GetMDInternalInterface
 
 
-#ifdef FEATURE_FUSION
-
-#ifndef DACCESS_COMPILE
-
-//*****************************************************************************
-// GetAssemblyMDInternalImport.
-// Instantiating an instance of AssemblyMDInternalImport.
-// This class can support the IMetaDataAssemblyImport and some functionalities 
-// of IMetaDataImport on the internal import interface (IMDInternalImport).
-//*****************************************************************************
-STDAPI GetAssemblyMDInternalImport(     // Return code.
-    LPCWSTR     szFileName,             // [in] The scope to open.
-    REFIID      riid,                   // [in] The interface desired.
-    IUnknown    **ppIUnk)               // [out] Return interface on success.
-{
-    return GetAssemblyMDInternalImportEx(szFileName, riid, MDInternalImport_Default, ppIUnk);
-}
-
-STDAPI GetAssemblyMDInternalImportEx(   // Return code.
-    LPCWSTR     szFileName,             // [in] The scope to open.
-    REFIID      riid,                   // [in] The interface desired.
-    MDInternalImportFlags flags,        // [in] Flags to control opening the assembly
-    IUnknown    **ppIUnk,               // [out] Return interface on success.
-    HANDLE      hFile)
-{
-    HRESULT     hr;
-
-    if (!szFileName || !szFileName[0] || !ppIUnk)
-        return E_INVALIDARG;
-    
-    // Sanity check the name.
-    if (wcslen(szFileName) >= _MAX_PATH)
-        return E_INVALIDARG;
-    
-    if (memcmp(szFileName, W("file:"), 10) == 0)
-        szFileName = &szFileName[5];
-    
-    HCORMODULEHolder hModule;
-    DWORD dwFileLength;
-
-    BEGIN_SO_INTOLERANT_CODE_NO_THROW_CHECK_THREAD(return COR_E_STACKOVERFLOW);
-    
-    IfFailGoto(RuntimeOpenImageInternal(szFileName, &hModule, &dwFileLength, flags, hFile), ErrAsmExpected);
-
-    IfFailGo(GetAssemblyMDInternalImportHelper(hModule, riid, flags, ppIUnk));
-
-
-ErrAsmExpected:
-    if(hr == COR_E_BADIMAGEFORMAT)
-        hr = COR_E_ASSEMBLYEXPECTED;
-
-ErrExit:
-;
-    END_SO_INTOLERANT_CODE;
-
-    return hr;
-}
-
-HRESULT GetAssemblyMDInternalImportFromImage(
-    HCORMODULE hImage,
-    REFIID riid,
-    IUnknown **ppIUnk)
-{
-
-    HRESULT hr;
-
-    IfFailGo(GetAssemblyMDInternalImportHelper(hImage, riid, MDInternalImport_Default, ppIUnk));
-
-ErrExit:
-    return hr;
-}
-
-STDAPI GetAssemblyMDInternalImportByStream( // Return code.
-    IStream     *pIStream,              // [in] The IStream for the file
-    UINT64      AssemblyId,             // [in] Unique Id for the assembly
-    REFIID      riid,                   // [in] The interface desired.
-    IUnknown    **ppIUnk)               // [out] Return interface on success.
-{
-    return GetAssemblyMDInternalImportByStreamEx(pIStream, AssemblyId, riid, MDInternalImport_Default, ppIUnk);
-}
-
-STDAPI GetAssemblyMDInternalImportByStreamEx( // Return code.
-    IStream     *pIStream,              // [in] The IStream for the file
-    UINT64      AssemblyId,             // [in] Unique Id for the assembly
-    REFIID      riid,                   // [in] The interface desired.
-    MDInternalImportFlags flags,        // [in[ Flags to control opening the assembly
-    IUnknown    **ppIUnk)               // [out] Return interface on success.
-{
-    if (!pIStream || !ppIUnk)
-        return E_INVALIDARG;
-    
-    HRESULT hr;
-    DWORD dwFileLength;
-    HCORMODULEHolder hModule;
-    
-    BEGIN_SO_INTOLERANT_CODE_NO_THROW_CHECK_THREAD(return COR_E_STACKOVERFLOW);
-    
-    IfFailGoto(RuntimeOpenImageByStream(pIStream, AssemblyId, 0, &hModule, &dwFileLength, flags), ErrAsmExpected);
-
-    IfFailGo(GetAssemblyMDInternalImportHelper(hModule, riid, flags, ppIUnk));
-
-
-ErrAsmExpected:
-    if(hr == COR_E_BADIMAGEFORMAT)
-       hr = COR_E_ASSEMBLYEXPECTED;
-
-ErrExit:
-    ;
-    END_SO_INTOLERANT_CODE;
-
-    return hr;
-}
-
-
-HRESULT GetAssemblyMDInternalImportHelper(HCORMODULE hModule,
-                                          REFIID     riid,
-                                          MDInternalImportFlags flags,
-                                          IUnknown   **ppIUnk)
-{
-    AssemblyMDInternalImport *pAssemblyMDInternalImport = NULL;
-    HRESULT hr;
-    LPVOID base;
-    PEDecoder pe;
-    IfFailGoto(RuntimeGetImageBase(hModule,&base,TRUE,NULL), ErrAsmExpected);
-
-    if (base!=NULL)
-        IfFailGoto(pe.Init(base), ErrAsmExpected);
-    else
-    {
-        COUNT_T lgth;
-        IfFailGoto(RuntimeGetImageBase(hModule,&base,FALSE,&lgth), ErrAsmExpected);
-        pe.Init(base, lgth);
-    }
-
-    // Both of these need to pass.
-    if (!pe.HasCorHeader() || !pe.CheckCorHeader())
-        IfFailGo(COR_E_ASSEMBLYEXPECTED);
-    // Only one of these needs to.
-    if (!pe.CheckILFormat() && !pe.CheckNativeFormat())
-        IfFailGo(COR_E_BADIMAGEFORMAT);
-        
-    COUNT_T cbMetaData;
-    LPCVOID pMetaData;
-    pMetaData = pe.GetMetadata(&cbMetaData);
-
-    // Get the IL metadata.
-    IMDInternalImport *pMDInternalImport;
-    IfFailGo(RuntimeGetMDInternalImport(hModule, flags, &pMDInternalImport));
-    if (pMDInternalImport == NULL)
-        IfFailGo(E_OUTOFMEMORY);
-
-    _ASSERTE(pMDInternalImport);
-    pAssemblyMDInternalImport = new (nothrow) AssemblyMDInternalImport (pMDInternalImport);
-    if (!pAssemblyMDInternalImport) {
-        pMDInternalImport->Release();
-        IfFailGo(E_OUTOFMEMORY);
-    }
-
-    { // identify PE kind and machine type, plus the version string location
-        DWORD           dwKind=0;
-        DWORD           dwMachine=0;
-        RuntimeGetImageKind(hModule,&dwKind,&dwMachine);
-        pAssemblyMDInternalImport->SetPEKind(dwKind);
-        pAssemblyMDInternalImport->SetMachine(dwMachine);
-
-        {
-            LPCSTR pString = NULL;
-            IfFailGo(GetImageRuntimeVersionString((PVOID)pMetaData, &pString));
-
-            pAssemblyMDInternalImport->SetVersionString(pString);
-        }
-
-    }
-
-    pAssemblyMDInternalImport->SetHandle(hModule);
-
-#ifdef FEATURE_PREJIT
-    // Check for zap header for INativeImageInstallInfo
-    // Dont do this if we are returning the IL metadata as CORCOMPILE_DEPENDENCY
-    // references the native image metadata, not the IL metadata.
-
-    if (pe.HasNativeHeader() && !(flags & MDInternalImport_ILMetaData))
-    {
-        CORCOMPILE_VERSION_INFO *pNativeVersionInfo = pe.GetNativeVersionInfo();
-
-        COUNT_T cDeps;
-        CORCOMPILE_DEPENDENCY *pDeps = pe.GetNativeDependencies(&cDeps);
-
-        pAssemblyMDInternalImport->SetZapVersionInfo(pNativeVersionInfo, pDeps, cDeps);
-    }
-#endif  // FEATURE_PREJIT
-
-    IfFailGo(pAssemblyMDInternalImport->QueryInterface(riid, (void**)ppIUnk));
-
-    return hr;
-
-ErrAsmExpected:
-    if(hr == COR_E_BADIMAGEFORMAT)
-        hr = COR_E_ASSEMBLYEXPECTED;
-
-ErrExit:
-
-    if (pAssemblyMDInternalImport)
-        delete pAssemblyMDInternalImport;
-
-    return hr;
-}
-
-AssemblyMDInternalImport::AssemblyMDInternalImport (IMDInternalImport *pMDInternalImport)
-:   m_cRef(0),
-    m_pHandle(0),
-    m_pBase(NULL),
-#ifdef FEATURE_PREJIT
-    m_pZapVersionInfo(NULL),
-#endif  // FEATURE_PREJIT
-    m_pMDInternalImport(pMDInternalImport),
-    m_dwPEKind(0),
-    m_dwMachine(0),
-    m_szVersionString("")
-{
-    _ASSERTE(m_pMDInternalImport);
-} // AssemblyMDInternalImport
-
-AssemblyMDInternalImport::~AssemblyMDInternalImport () 
-{
-    m_pMDInternalImport->Release();
-
-    if (m_pBase) 
-    {
-        UnmapViewOfFile(m_pBase);
-        m_pBase = NULL;
-        CloseHandle(m_pHandle);
-    }
-    else if(m_pHandle) 
-    {
-        HRESULT hr;
-        hr = RuntimeReleaseHandle(m_pHandle);
-        _ASSERTE(SUCCEEDED(hr));
-    }
-
-    m_pHandle = NULL;
-}
-
-ULONG AssemblyMDInternalImport::AddRef()
-{
-    return InterlockedIncrement(&m_cRef);
-} // ULONG AssemblyMDInternalImport::AddRef()
-
-ULONG AssemblyMDInternalImport::Release()
-{
-    ULONG   cRef = InterlockedDecrement(&m_cRef);
-    if (!cRef)
-    {
-        VALIDATE_BACKOUT_STACK_CONSUMPTION;
-        delete this;
-    }
-    return (cRef);
-} // ULONG AssemblyMDInternalImport::Release()
-
-HRESULT AssemblyMDInternalImport::QueryInterface(REFIID riid, void **ppUnk)
-{ 
-    *ppUnk = 0;
-
-    if (riid == IID_IUnknown)
-        *ppUnk = (IUnknown *) (IMetaDataAssemblyImport *) this;
-    else if (riid == IID_IMetaDataAssemblyImport)
-        *ppUnk = (IMetaDataAssemblyImport *) this;
-    else if (riid == IID_IMetaDataImport)
-        *ppUnk = (IMetaDataImport *) this;
-    else if (riid == IID_IMetaDataImport2)
-        *ppUnk = (IMetaDataImport2 *) this;
-    else if (riid == IID_ISNAssemblySignature)
-        *ppUnk = (ISNAssemblySignature *) this;
-#ifdef FEATURE_PREJIT
-    else if (riid == IID_IGetIMDInternalImport)
-        *ppUnk = (IGetIMDInternalImport *) this;
-    else if (riid == IID_INativeImageInstallInfo && m_pZapVersionInfo)
-        *ppUnk = (INativeImageInstallInfo *) this;
-#endif  // FEATURE_PREJIT
-    else
-        return (E_NOINTERFACE);
-    AddRef();
-    return (S_OK);
-}
-
-
-STDMETHODIMP AssemblyMDInternalImport::GetAssemblyProps (      // S_OK or error.
-    mdAssembly  mda,                    // [IN] The Assembly for which to get the properties.
-    const void  **ppbPublicKey,         // [OUT] Pointer to the public key.
-    ULONG       *pcbPublicKey,          // [OUT] Count of bytes in the public key.
-    ULONG       *pulHashAlgId,          // [OUT] Hash Algorithm.
-    __out_ecount (cchName) LPWSTR szName, // [OUT] Buffer to fill with name.
-    ULONG       cchName,                // [IN] Size of buffer in wide chars.
-    ULONG       *pchName,               // [OUT] Actual # of wide chars in name.
-    ASSEMBLYMETADATA *pMetaData,        // [OUT] Assembly MetaData.
-    DWORD       *pdwAssemblyFlags)      // [OUT] Flags.
-{
-    HRESULT hr;
-    LPCSTR  _szName;
-    AssemblyMetaDataInternal _AssemblyMetaData;
-    
-    _AssemblyMetaData.ulProcessor = 0;
-    _AssemblyMetaData.ulOS = 0;
-
-    IfFailRet(m_pMDInternalImport->GetAssemblyProps(
-        mda,                            // [IN] The Assembly for which to get the properties.
-        ppbPublicKey,                   // [OUT] Pointer to the public key.
-        pcbPublicKey,                   // [OUT] Count of bytes in the public key.
-        pulHashAlgId,                   // [OUT] Hash Algorithm.
-        &_szName,                       // [OUT] Buffer to fill with name.
-        &_AssemblyMetaData,             // [OUT] Assembly MetaData.
-        pdwAssemblyFlags));             // [OUT] Flags.
-
-    if (pchName != NULL)
-    {
-        *pchName = WszMultiByteToWideChar(CP_UTF8, 0, _szName, -1, szName, cchName);
-        if (*pchName == 0)
-        {
-            return HRESULT_FROM_GetLastError();
-        }
-    }
-
-    if  (pMetaData)
-    {
-        pMetaData->usMajorVersion = _AssemblyMetaData.usMajorVersion;
-        pMetaData->usMinorVersion = _AssemblyMetaData.usMinorVersion;
-        pMetaData->usBuildNumber = _AssemblyMetaData.usBuildNumber;
-        pMetaData->usRevisionNumber = _AssemblyMetaData.usRevisionNumber;
-        pMetaData->ulProcessor = 0;
-        pMetaData->ulOS = 0;
-
-        pMetaData->cbLocale = WszMultiByteToWideChar(CP_UTF8, 0, _AssemblyMetaData.szLocale, -1, pMetaData->szLocale, pMetaData->cbLocale);
-        if (pMetaData->cbLocale == 0)
-        {
-            return HRESULT_FROM_GetLastError();
-        }
-    }
-
-    return S_OK;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetAssemblyRefProps (   // S_OK or error.
-    mdAssemblyRef mdar,                 // [IN] The AssemblyRef for which to get the properties.
-    const void  **ppbPublicKeyOrToken,  // [OUT] Pointer to the public key or token.
-    ULONG       *pcbPublicKeyOrToken,   // [OUT] Count of bytes in the public key or token.
-    __out_ecount (cchName) LPWSTR szName, // [OUT] Buffer to fill with name.
-    ULONG       cchName,                // [IN] Size of buffer in wide chars.
-    ULONG       *pchName,               // [OUT] Actual # of wide chars in name.
-    ASSEMBLYMETADATA *pMetaData,        // [OUT] Assembly MetaData.
-    const void  **ppbHashValue,         // [OUT] Hash blob.
-    ULONG       *pcbHashValue,          // [OUT] Count of bytes in the hash blob.
-    DWORD       *pdwAssemblyRefFlags)   // [OUT] Flags.
-{
-    HRESULT hr;
-    LPCSTR  _szName;
-    AssemblyMetaDataInternal _AssemblyMetaData;
-    
-    _AssemblyMetaData.ulProcessor = 0;
-    _AssemblyMetaData.ulOS = 0;
-
-    IfFailRet(m_pMDInternalImport->GetAssemblyRefProps(
-        mdar,                           // [IN] The Assembly for which to get the properties.
-        ppbPublicKeyOrToken,            // [OUT] Pointer to the public key or token.
-        pcbPublicKeyOrToken,            // [OUT] Count of bytes in the public key or token.
-        &_szName,                       // [OUT] Buffer to fill with name.
-        &_AssemblyMetaData,             // [OUT] Assembly MetaData.
-        ppbHashValue,                   // [OUT] Hash blob.
-        pcbHashValue,                   // [OUT] Count of bytes in the hash blob.
-        pdwAssemblyRefFlags));          // [OUT] Flags.
-
-    if (pchName != NULL)
-    {
-        *pchName = WszMultiByteToWideChar(CP_UTF8, 0, _szName, -1, szName, cchName);
-        if (*pchName == 0)
-        {
-            return HRESULT_FROM_GetLastError();
-        }
-    }
-
-    pMetaData->usMajorVersion = _AssemblyMetaData.usMajorVersion;
-    pMetaData->usMinorVersion = _AssemblyMetaData.usMinorVersion;
-    pMetaData->usBuildNumber = _AssemblyMetaData.usBuildNumber;
-    pMetaData->usRevisionNumber = _AssemblyMetaData.usRevisionNumber;
-    pMetaData->ulProcessor = 0;
-    pMetaData->ulOS = 0;
-
-    pMetaData->cbLocale = WszMultiByteToWideChar(CP_UTF8, 0, _AssemblyMetaData.szLocale, -1, pMetaData->szLocale, pMetaData->cbLocale);
-    if (pMetaData->cbLocale == 0)
-    {
-        return HRESULT_FROM_GetLastError();
-    }
-    
-    return S_OK;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetFileProps (          // S_OK or error.
-    mdFile      mdf,                    // [IN] The File for which to get the properties.
-    __out_ecount (cchName) LPWSTR szName, // [OUT] Buffer to fill with name.
-    ULONG       cchName,                // [IN] Size of buffer in wide chars.
-    ULONG       *pchName,               // [OUT] Actual # of wide chars in name.
-    const void  **ppbHashValue,         // [OUT] Pointer to the Hash Value Blob.
-    ULONG       *pcbHashValue,          // [OUT] Count of bytes in the Hash Value Blob.
-    DWORD       *pdwFileFlags)          // [OUT] Flags.
-{
-    HRESULT hr;
-    LPCSTR  _szName;
-    IfFailRet(m_pMDInternalImport->GetFileProps(
-        mdf,
-        &_szName,
-        ppbHashValue,
-        pcbHashValue,
-        pdwFileFlags));
-
-    if (pchName != NULL)
-    {
-        *pchName = WszMultiByteToWideChar(CP_UTF8, 0, _szName, -1, szName, cchName);
-        if (*pchName == 0)
-        {
-            return HRESULT_FROM_GetLastError();
-        }
-    }
-
-    return S_OK;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetExportedTypeProps (  // S_OK or error.
-    mdExportedType   mdct,              // [IN] The ExportedType for which to get the properties.
-    __out_ecount (cchName) LPWSTR szName, // [OUT] Buffer to fill with name.
-    ULONG       cchName,                // [IN] Size of buffer in wide chars.
-    ULONG       *pchName,               // [OUT] Actual # of wide chars in name.
-    mdToken     *ptkImplementation,     // [OUT] mdFile or mdAssemblyRef or mdExportedType.
-    mdTypeDef   *ptkTypeDef,            // [OUT] TypeDef token within the file.
-    DWORD       *pdwExportedTypeFlags)       // [OUT] Flags.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetManifestResourceProps (    // S_OK or error.
-    mdManifestResource  mdmr,           // [IN] The ManifestResource for which to get the properties.
-    __out_ecount (cchName) LPWSTR szName, // [OUT] Buffer to fill with name.
-    ULONG       cchName,                // [IN] Size of buffer in wide chars.
-    ULONG       *pchName,               // [OUT] Actual # of wide chars in name.
-    mdToken     *ptkImplementation,     // [OUT] mdFile or mdAssemblyRef that provides the ManifestResource.
-    DWORD       *pdwOffset,             // [OUT] Offset to the beginning of the resource within the file.
-    DWORD       *pdwResourceFlags)      // [OUT] Flags.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumAssemblyRefs (      // S_OK or error
-    HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-    mdAssemblyRef rAssemblyRefs[],      // [OUT] Put AssemblyRefs here.
-    ULONG       cMax,                   // [IN] Max AssemblyRefs to put.
-    ULONG       *pcTokens)              // [OUT] Put # put here.
-{
-    HENUMInternal **ppmdEnum = reinterpret_cast<HENUMInternal **> (phEnum);
-    HRESULT         hr = NOERROR;
-    HENUMInternal  *pEnum;
-    
-    if (*ppmdEnum == NULL)
-    {
-        // create the enumerator.
-        IfFailGo(HENUMInternal::CreateSimpleEnum(
-            mdtAssemblyRef,
-            0,
-            1,
-            &pEnum));
-        
-        IfFailGo(m_pMDInternalImport->EnumInit(mdtAssemblyRef, 0, pEnum));
-        
-        // set the output parameter.
-        *ppmdEnum = pEnum;
-    }
-    else
-    {
-        pEnum = *ppmdEnum;
-    }
-    
-    // we can only fill the minimum of what the caller asked for or what we have left.
-    IfFailGo(HENUMInternal::EnumWithCount(pEnum, cMax, rAssemblyRefs, pcTokens));
-ErrExit:
-    HENUMInternal::DestroyEnumIfEmpty(ppmdEnum);
-    
-    return hr;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumFiles (             // S_OK or error
-    HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-    mdFile      rFiles[],               // [OUT] Put Files here.
-    ULONG       cMax,                   // [IN] Max Files to put.
-    ULONG       *pcTokens)              // [OUT] Put # put here.
-{
-    HENUMInternal **ppmdEnum = reinterpret_cast<HENUMInternal **> (phEnum);
-    HRESULT         hr = NOERROR;
-    HENUMInternal  *pEnum;
-    
-    if (*ppmdEnum == NULL)
-    {
-        // create the enumerator.
-        IfFailGo(HENUMInternal::CreateSimpleEnum(
-            mdtFile,
-            0,
-            1,
-            &pEnum));
-        
-        IfFailGo(m_pMDInternalImport->EnumInit(mdtFile, 0, pEnum));
-        
-        // set the output parameter.
-        *ppmdEnum = pEnum;
-    }
-    else
-    {
-        pEnum = *ppmdEnum;
-    }
-    
-    // we can only fill the minimum of what the caller asked for or what we have left.
-    IfFailGo(HENUMInternal::EnumWithCount(pEnum, cMax, rFiles, pcTokens));
-    
-ErrExit:
-    HENUMInternal::DestroyEnumIfEmpty(ppmdEnum);
-    return hr;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumExportedTypes (     // S_OK or error
-    HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-    mdExportedType   rExportedTypes[],  // [OUT] Put ExportedTypes here.
-    ULONG       cMax,                   // [IN] Max ExportedTypes to put.
-    ULONG       *pcTokens)              // [OUT] Put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumManifestResources ( // S_OK or error
-    HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-    mdManifestResource  rManifestResources[],   // [OUT] Put ManifestResources here.
-    ULONG       cMax,                   // [IN] Max Resources to put.
-    ULONG       *pcTokens)              // [OUT] Put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetAssemblyFromScope (  // S_OK or error
-    mdAssembly  *ptkAssembly)           // [OUT] Put token here.
-{
-    return m_pMDInternalImport->GetAssemblyFromScope (ptkAssembly);
-}
-
-STDMETHODIMP AssemblyMDInternalImport::FindExportedTypeByName (// S_OK or error
-    LPCWSTR     szName,                 // [IN] Name of the ExportedType.
-    mdToken     mdtExportedType,        // [IN] ExportedType for the enclosing class.
-    mdExportedType   *ptkExportedType)       // [OUT] Put the ExportedType token here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::FindManifestResourceByName (  // S_OK or error
-    LPCWSTR     szName,                 // [IN] Name of the ManifestResource.
-    mdManifestResource *ptkManifestResource)        // [OUT] Put the ManifestResource token here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-void AssemblyMDInternalImport::CloseEnum (
-    HCORENUM hEnum)                     // Enum to be closed.
-{
-    HENUMInternal   *pmdEnum = reinterpret_cast<HENUMInternal *> (hEnum);
-
-    if (pmdEnum == NULL)
-        return;
-
-    HENUMInternal::DestroyEnum(pmdEnum);
-}
-
-STDMETHODIMP AssemblyMDInternalImport::FindAssembliesByName (  // S_OK or error
-    LPCWSTR  szAppBase,                 // [IN] optional - can be NULL
-    LPCWSTR  szPrivateBin,              // [IN] optional - can be NULL
-    LPCWSTR  szAssemblyName,            // [IN] required - this is the assembly you are requesting
-    IUnknown *ppIUnk[],                 // [OUT] put IMetaDataAssemblyImport pointers here
-    ULONG    cMax,                      // [IN] The max number to put
-    ULONG    *pcAssemblies)             // [OUT] The number of assemblies returned.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::CountEnum (HCORENUM hEnum, ULONG *pulCount)
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::ResetEnum (HCORENUM hEnum, ULONG ulPos)
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumTypeDefs (HCORENUM *phEnum, mdTypeDef rTypeDefs[],
-                        ULONG cMax, ULONG *pcTypeDefs)
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumInterfaceImpls (HCORENUM *phEnum, mdTypeDef td,
-                        mdInterfaceImpl rImpls[], ULONG cMax,
-                        ULONG* pcImpls)
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumTypeRefs (HCORENUM *phEnum, mdTypeRef rTypeRefs[],
-                        ULONG cMax, ULONG* pcTypeRefs)
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::FindTypeDefByName (           // S_OK or error.
-    LPCWSTR     szTypeDef,              // [IN] Name of the Type.
-    mdToken     tkEnclosingClass,       // [IN] TypeDef/TypeRef for Enclosing class.
-    mdTypeDef   *ptd)                   // [OUT] Put the TypeDef token here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetScopeProps (               // S_OK or error.
-    __out_ecount (cchName) LPWSTR szName, // [OUT] Put the name here.
-    ULONG       cchName,                // [IN] Size of name buffer in wide chars.
-    ULONG       *pchName,               // [OUT] Put size of name (wide chars) here.
-    GUID        *pmvid)                 // [OUT, OPTIONAL] Put MVID here.
-{
-    HRESULT hr;
-    LPCSTR  _szName;
-    
-    if (!m_pMDInternalImport->IsValidToken(m_pMDInternalImport->GetModuleFromScope()))
-        return COR_E_BADIMAGEFORMAT;
-
-    IfFailRet(m_pMDInternalImport->GetScopeProps(&_szName, pmvid));
-
-    if (pchName != NULL)
-    {
-        *pchName = WszMultiByteToWideChar(CP_UTF8, 0, _szName, -1, szName, cchName);
-        if (*pchName == 0)
-        {
-            return HRESULT_FROM_GetLastError();
-        }
-   }
-
-    return S_OK;
-
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetModuleFromScope (          // S_OK.
-    mdModule    *pmd)                   // [OUT] Put mdModule token here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetTypeDefProps (             // S_OK or error.
-    mdTypeDef   td,                     // [IN] TypeDef token for inquiry.
-    __out_ecount (cchTypeDef) LPWSTR szTypeDef, // [OUT] Put name here.
-    ULONG       cchTypeDef,             // [IN] size of name buffer in wide chars.
-    ULONG       *pchTypeDef,            // [OUT] put size of name (wide chars) here.
-    DWORD       *pdwTypeDefFlags,       // [OUT] Put flags here.
-    mdToken     *ptkExtends)            // [OUT] Put base class TypeDef/TypeRef here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetInterfaceImplProps (       // S_OK or error.
-    mdInterfaceImpl iiImpl,             // [IN] InterfaceImpl token.
-    mdTypeDef   *pClass,                // [OUT] Put implementing class token here.
-    mdToken     *ptkIface)              // [OUT] Put implemented interface token here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetTypeRefProps (             // S_OK or error.
-    mdTypeRef   tr,                     // [IN] TypeRef token.
-    mdToken     *ptkResolutionScope,    // [OUT] Resolution scope, ModuleRef or AssemblyRef.
-    __out_ecount (cchName) LPWSTR szName, // [OUT] Name of the TypeRef.
-    ULONG       cchName,                // [IN] Size of buffer.
-    ULONG       *pchName)               // [OUT] Size of Name.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::ResolveTypeRef (mdTypeRef tr, REFIID riid, IUnknown **ppIScope, mdTypeDef *ptd)
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumMembers (                 // S_OK, S_FALSE, or error.
-    HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-    mdTypeDef   cl,                     // [IN] TypeDef to scope the enumeration.
-    mdToken     rMembers[],             // [OUT] Put MemberDefs here.
-    ULONG       cMax,                   // [IN] Max MemberDefs to put.
-    ULONG       *pcTokens)              // [OUT] Put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumMembersWithName (         // S_OK, S_FALSE, or error.
-    HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-    mdTypeDef   cl,                     // [IN] TypeDef to scope the enumeration.
-    LPCWSTR     szName,                 // [IN] Limit results to those with this name.
-    mdToken     rMembers[],             // [OUT] Put MemberDefs here.
-    ULONG       cMax,                   // [IN] Max MemberDefs to put.
-    ULONG       *pcTokens)              // [OUT] Put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumMethods (                 // S_OK, S_FALSE, or error.
-    HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-    mdTypeDef   cl,                     // [IN] TypeDef to scope the enumeration.
-    mdMethodDef rMethods[],             // [OUT] Put MethodDefs here.
-    ULONG       cMax,                   // [IN] Max MethodDefs to put.
-    ULONG       *pcTokens)              // [OUT] Put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumMethodsWithName (         // S_OK, S_FALSE, or error.
-    HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-    mdTypeDef   cl,                     // [IN] TypeDef to scope the enumeration.
-    LPCWSTR     szName,                 // [IN] Limit results to those with this name.
-    mdMethodDef rMethods[],             // [OU] Put MethodDefs here.
-    ULONG       cMax,                   // [IN] Max MethodDefs to put.
-    ULONG       *pcTokens)              // [OUT] Put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumFields (                 // S_OK, S_FALSE, or error.
-    HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-    mdTypeDef   cl,                     // [IN] TypeDef to scope the enumeration.
-    mdFieldDef  rFields[],              // [OUT] Put FieldDefs here.
-    ULONG       cMax,                   // [IN] Max FieldDefs to put.
-    ULONG       *pcTokens)              // [OUT] Put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumFieldsWithName (         // S_OK, S_FALSE, or error.
-    HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-    mdTypeDef   cl,                     // [IN] TypeDef to scope the enumeration.
-    LPCWSTR     szName,                 // [IN] Limit results to those with this name.
-    mdFieldDef  rFields[],              // [OUT] Put MemberDefs here.
-    ULONG       cMax,                   // [IN] Max MemberDefs to put.
-    ULONG       *pcTokens)              // [OUT] Put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-
-STDMETHODIMP AssemblyMDInternalImport::EnumParams (                  // S_OK, S_FALSE, or error.
-    HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-    mdMethodDef mb,                     // [IN] MethodDef to scope the enumeration. 
-    mdParamDef  rParams[],              // [OUT] Put ParamDefs here.
-    ULONG       cMax,                   // [IN] Max ParamDefs to put.
-    ULONG       *pcTokens)              // [OUT] Put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumMemberRefs (              // S_OK, S_FALSE, or error.
-    HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-    mdToken     tkParent,               // [IN] Parent token to scope the enumeration.
-    mdMemberRef rMemberRefs[],          // [OUT] Put MemberRefs here.
-    ULONG       cMax,                   // [IN] Max MemberRefs to put.
-    ULONG       *pcTokens)              // [OUT] Put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumMethodImpls (             // S_OK, S_FALSE, or error
-    HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-    mdTypeDef   td,                     // [IN] TypeDef to scope the enumeration.
-    mdToken     rMethodBody[],          // [OUT] Put Method Body tokens here.
-    mdToken     rMethodDecl[],          // [OUT] Put Method Declaration tokens here.
-    ULONG       cMax,                   // [IN] Max tokens to put.
-    ULONG       *pcTokens)              // [OUT] Put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumPermissionSets (          // S_OK, S_FALSE, or error.
-    HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-    mdToken     tk,                     // [IN] if !NIL, token to scope the enumeration.
-    DWORD       dwActions,              // [IN] if !0, return only these actions.
-    mdPermission rPermission[],         // [OUT] Put Permissions here.
-    ULONG       cMax,                   // [IN] Max Permissions to put. 
-    ULONG       *pcTokens)              // [OUT] Put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::FindMember (
-    mdTypeDef   td,                     // [IN] given typedef
-    LPCWSTR     szName,                 // [IN] member name 
-    PCCOR_SIGNATURE pvSigBlob,          // [IN] point to a blob value of COM+ signature 
-    ULONG       cbSigBlob,              // [IN] count of bytes in the signature blob
-    mdToken     *pmb)                   // [OUT] matching memberdef 
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::FindMethod (
-    mdTypeDef   td,                     // [IN] given typedef
-    LPCWSTR     szName,                 // [IN] member name 
-    PCCOR_SIGNATURE pvSigBlob,          // [IN] point to a blob value of COM+ signature 
-    ULONG       cbSigBlob,              // [IN] count of bytes in the signature blob
-    mdMethodDef *pmb)                   // [OUT] matching memberdef 
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::FindField (
-    mdTypeDef   td,                     // [IN] given typedef
-    LPCWSTR     szName,                 // [IN] member name 
-    PCCOR_SIGNATURE pvSigBlob,          // [IN] point to a blob value of COM+ signature 
-    ULONG       cbSigBlob,              // [IN] count of bytes in the signature blob
-    mdFieldDef  *pmb)                   // [OUT] matching memberdef 
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::FindMemberRef (
-    mdTypeRef   td,                     // [IN] given typeRef
-    LPCWSTR     szName,                 // [IN] member name 
-    PCCOR_SIGNATURE pvSigBlob,          // [IN] point to a blob value of COM+ signature 
-    ULONG       cbSigBlob,              // [IN] count of bytes in the signature blob
-    mdMemberRef *pmr)                   // [OUT] matching memberref 
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetMethodProps (
-    mdMethodDef mb,                     // The method for which to get props.
-    mdTypeDef   *pClass,                // Put method's class here. 
-    __out_ecount (cchMethod) LPWSTR szMethod, // Put method's name here.
-    ULONG       cchMethod,              // Size of szMethod buffer in wide chars.
-    ULONG       *pchMethod,             // Put actual size here 
-    DWORD       *pdwAttr,               // Put flags here.
-    PCCOR_SIGNATURE *ppvSigBlob,        // [OUT] point to the blob value of meta data
-    ULONG       *pcbSigBlob,            // [OUT] actual size of signature blob
-    ULONG       *pulCodeRVA,            // [OUT] codeRVA
-    DWORD       *pdwImplFlags)          // [OUT] Impl. Flags
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetMemberRefProps (           // S_OK or error.
-    mdMemberRef mr,                     // [IN] given memberref 
-    mdToken     *ptk,                   // [OUT] Put classref or classdef here. 
-    __out_ecount (cchMember) LPWSTR szMember, // [OUT] buffer to fill for member's name
-    ULONG       cchMember,              // [IN] the count of char of szMember
-    ULONG       *pchMember,             // [OUT] actual count of char in member name
-    PCCOR_SIGNATURE *ppvSigBlob,        // [OUT] point to meta data blob value
-    ULONG       *pbSig)                 // [OUT] actual size of signature blob
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumProperties (              // S_OK, S_FALSE, or error.
-    HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-    mdTypeDef   td,                     // [IN] TypeDef to scope the enumeration.
-    mdProperty  rProperties[],          // [OUT] Put Properties here.
-    ULONG       cMax,                   // [IN] Max properties to put.
-    ULONG       *pcProperties)          // [OUT] Put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumEvents (                  // S_OK, S_FALSE, or error.
-    HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-    mdTypeDef   td,                     // [IN] TypeDef to scope the enumeration.
-    mdEvent     rEvents[],              // [OUT] Put events here.
-    ULONG       cMax,                   // [IN] Max events to put.
-    ULONG       *pcEvents)              // [OUT] Put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetEventProps (               // S_OK, S_FALSE, or error.
-    mdEvent     ev,                     // [IN] event token 
-    mdTypeDef   *pClass,                // [OUT] typedef containing the event declarion.
-    LPCWSTR     szEvent,                // [OUT] Event name 
-    ULONG       cchEvent,               // [IN] the count of wchar of szEvent
-    ULONG       *pchEvent,              // [OUT] actual count of wchar for event's name 
-    DWORD       *pdwEventFlags,         // [OUT] Event flags.
-    mdToken     *ptkEventType,          // [OUT] EventType class
-    mdMethodDef *pmdAddOn,              // [OUT] AddOn method of the event
-    mdMethodDef *pmdRemoveOn,           // [OUT] RemoveOn method of the event
-    mdMethodDef *pmdFire,               // [OUT] Fire method of the event
-    mdMethodDef rmdOtherMethod[],       // [OUT] other method of the event
-    ULONG       cMax,                   // [IN] size of rmdOtherMethod
-    ULONG       *pcOtherMethod)         // [OUT] total number of other method of this event 
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumMethodSemantics (         // S_OK, S_FALSE, or error.
-    HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-    mdMethodDef mb,                     // [IN] MethodDef to scope the enumeration. 
-    mdToken     rEventProp[],           // [OUT] Put Event/Property here.
-    ULONG       cMax,                   // [IN] Max properties to put.
-    ULONG       *pcEventProp)           // [OUT] Put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetMethodSemantics (          // S_OK, S_FALSE, or error.
-    mdMethodDef mb,                     // [IN] method token
-    mdToken     tkEventProp,            // [IN] event/property token.
-    DWORD       *pdwSemanticsFlags)       // [OUT] the role flags for the method/propevent pair 
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetClassLayout (
-    mdTypeDef   td,                     // [IN] give typedef
-    DWORD       *pdwPackSize,           // [OUT] 1, 2, 4, 8, or 16
-    COR_FIELD_OFFSET rFieldOffset[],    // [OUT] field offset array 
-    ULONG       cMax,                   // [IN] size of the array
-    ULONG       *pcFieldOffset,         // [OUT] needed array size
-    ULONG       *pulClassSize)              // [OUT] the size of the class
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetFieldMarshal (
-    mdToken     tk,                     // [IN] given a field's memberdef
-    PCCOR_SIGNATURE *ppvNativeType,     // [OUT] native type of this field
-    ULONG       *pcbNativeType)         // [OUT] the count of bytes of *ppvNativeType
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetRVA (                      // S_OK or error.
-    mdToken     tk,                     // Member for which to set offset
-    ULONG       *pulCodeRVA,            // The offset
-    DWORD       *pdwImplFlags)          // the implementation flags 
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetPermissionSetProps (
-    mdPermission pm,                    // [IN] the permission token.
-    DWORD       *pdwAction,             // [OUT] CorDeclSecurity.
-    void const  **ppvPermission,        // [OUT] permission blob.
-    ULONG       *pcbPermission)         // [OUT] count of bytes of pvPermission.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetSigFromToken (             // S_OK or error.
-    mdSignature mdSig,                  // [IN] Signature token.
-    PCCOR_SIGNATURE *ppvSig,            // [OUT] return pointer to token.
-    ULONG       *pcbSig)                // [OUT] return size of signature.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetModuleRefProps (           // S_OK or error.
-    mdModuleRef mur,                    // [IN] moduleref token.
-    __out_ecount (cchName) LPWSTR szName, // [OUT] buffer to fill with the moduleref name.
-    ULONG       cchName,                // [IN] size of szName in wide characters.
-    ULONG       *pchName)               // [OUT] actual count of characters in the name.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumModuleRefs (              // S_OK or error.
-    HCORENUM    *phEnum,                // [IN|OUT] pointer to the enum.
-    mdModuleRef rModuleRefs[],          // [OUT] put modulerefs here.
-    ULONG       cmax,                   // [IN] max memberrefs to put.
-    ULONG       *pcModuleRefs)          // [OUT] put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetTypeSpecFromToken (        // S_OK or error.
-    mdTypeSpec typespec,                // [IN] TypeSpec token.
-    PCCOR_SIGNATURE *ppvSig,            // [OUT] return pointer to TypeSpec signature
-    ULONG       *pcbSig)                // [OUT] return size of signature.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetNameFromToken (            // Not Recommended! May be removed!
-    mdToken     tk,                     // [IN] Token to get name from.  Must have a name.
-    MDUTF8CSTR  *pszUtf8NamePtr)        // [OUT] Return pointer to UTF8 name in heap.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumUnresolvedMethods (       // S_OK, S_FALSE, or error.
-    HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-    mdToken     rMethods[],             // [OUT] Put MemberDefs here.
-    ULONG       cMax,                   // [IN] Max MemberDefs to put.
-    ULONG       *pcTokens)              // [OUT] Put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetUserString (               // S_OK or error.
-    mdString    stk,                    // [IN] String token.
-    __out_ecount (cchString) LPWSTR szString, // [OUT] Copy of string.
-    ULONG       cchString,              // [IN] Max chars of room in szString.
-    ULONG       *pchString)             // [OUT] How many chars in actual string.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetPinvokeMap (               // S_OK or error.
-    mdToken     tk,                     // [IN] FieldDef or MethodDef.
-    DWORD       *pdwMappingFlags,       // [OUT] Flags used for mapping.
-    __out_ecount (cchImportName) LPWSTR szImportName, // [OUT] Import name.
-    ULONG       cchImportName,          // [IN] Size of the name buffer.
-    ULONG       *pchImportName,         // [OUT] Actual number of characters stored.
-    mdModuleRef *pmrImportDLL)          // [OUT] ModuleRef token for the target DLL.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumSignatures (              // S_OK or error.
-    HCORENUM    *phEnum,                // [IN|OUT] pointer to the enum.
-    mdSignature rSignatures[],          // [OUT] put signatures here.
-    ULONG       cmax,                   // [IN] max signatures to put.
-    ULONG       *pcSignatures)          // [OUT] put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumTypeSpecs (               // S_OK or error.
-    HCORENUM    *phEnum,                // [IN|OUT] pointer to the enum.
-    mdTypeSpec  rTypeSpecs[],           // [OUT] put TypeSpecs here.
-    ULONG       cmax,                   // [IN] max TypeSpecs to put.
-    ULONG       *pcTypeSpecs)           // [OUT] put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumUserStrings (             // S_OK or error.
-    HCORENUM    *phEnum,                // [IN/OUT] pointer to the enum.
-    mdString    rStrings[],             // [OUT] put Strings here.
-    ULONG       cmax,                   // [IN] max Strings to put.
-    ULONG       *pcStrings)             // [OUT] put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetParamForMethodIndex (      // S_OK or error.
-    mdMethodDef md,                     // [IN] Method token.
-    ULONG       ulParamSeq,             // [IN] Parameter sequence.
-    mdParamDef  *ppd)                   // [IN] Put Param token here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumCustomAttributes (        // S_OK or error.
-    HCORENUM    *phEnum,                // [IN, OUT] COR enumerator.
-    mdToken     tk,                     // [IN] Token to scope the enumeration, 0 for all.
-    mdToken     tkType,                 // [IN] Type of interest, 0 for all.
-    mdCustomAttribute rCustomAttributes[], // [OUT] Put custom attribute tokens here.
-    ULONG       cMax,                   // [IN] Size of rCustomAttributes.
-    ULONG       *pcCustomAttributes)        // [OUT, OPTIONAL] Put count of token values here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetCustomAttributeProps (     // S_OK or error.
-    mdCustomAttribute cv,               // [IN] CustomAttribute token.
-    mdToken     *ptkObj,                // [OUT, OPTIONAL] Put object token here.
-    mdToken     *ptkType,               // [OUT, OPTIONAL] Put AttrType token here.
-    void const  **ppBlob,               // [OUT, OPTIONAL] Put pointer to data here.
-    ULONG       *pcbSize)               // [OUT, OPTIONAL] Put size of date here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::FindTypeRef (
-    mdToken     tkResolutionScope,      // [IN] ModuleRef, AssemblyRef or TypeRef.
-    LPCWSTR     szName,                 // [IN] TypeRef Name.
-    mdTypeRef   *ptr)                   // [OUT] matching TypeRef.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetMemberProps (
-    mdToken     mb,                     // The member for which to get props.
-    mdTypeDef   *pClass,                // Put member's class here. 
-    __out_ecount (cchMember) LPWSTR szMember, // Put member's name here.
-    ULONG       cchMember,              // Size of szMember buffer in wide chars.
-    ULONG       *pchMember,             // Put actual size here 
-    DWORD       *pdwAttr,               // Put flags here.
-    PCCOR_SIGNATURE *ppvSigBlob,        // [OUT] point to the blob value of meta data
-    ULONG       *pcbSigBlob,            // [OUT] actual size of signature blob
-    ULONG       *pulCodeRVA,            // [OUT] codeRVA
-    DWORD       *pdwImplFlags,          // [OUT] Impl. Flags
-    DWORD       *pdwCPlusTypeFlag,      // [OUT] flag for value type. selected ELEMENT_TYPE_*
-    UVCP_CONSTANT *ppValue,             // [OUT] constant value 
-    ULONG       *pcchValue)             // [OUT] size of constant string in chars, 0 for non-strings.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetFieldProps (
-    mdFieldDef  mb,                     // The field for which to get props.
-    mdTypeDef   *pClass,                // Put field's class here.
-    __out_ecount (cchField) LPWSTR szField, // Put field's name here.
-    ULONG       cchField,               // Size of szField buffer in wide chars.
-    ULONG       *pchField,              // Put actual size here 
-    DWORD       *pdwAttr,               // Put flags here.
-    PCCOR_SIGNATURE *ppvSigBlob,        // [OUT] point to the blob value of meta data
-    ULONG       *pcbSigBlob,            // [OUT] actual size of signature blob
-    DWORD       *pdwCPlusTypeFlag,      // [OUT] flag for value type. selected ELEMENT_TYPE_*
-    UVCP_CONSTANT *ppValue,             // [OUT] constant value 
-    ULONG       *pcchValue)             // [OUT] size of constant string in chars, 0 for non-strings.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetPropertyProps (            // S_OK, S_FALSE, or error.
-    mdProperty  prop,                   // [IN] property token
-    mdTypeDef   *pClass,                // [OUT] typedef containing the property declarion. 
-    LPCWSTR     szProperty,             // [OUT] Property name
-    ULONG       cchProperty,            // [IN] the count of wchar of szProperty
-    ULONG       *pchProperty,           // [OUT] actual count of wchar for property name
-    DWORD       *pdwPropFlags,          // [OUT] property flags.
-    PCCOR_SIGNATURE *ppvSig,            // [OUT] property type. pointing to meta data internal blob 
-    ULONG       *pbSig,                 // [OUT] count of bytes in *ppvSig
-    DWORD       *pdwCPlusTypeFlag,      // [OUT] flag for value type. selected ELEMENT_TYPE_*
-    UVCP_CONSTANT *ppDefaultValue,      // [OUT] constant value 
-    ULONG       *pcchDefaultValue,      // [OUT] size of constant string in chars, 0 for non-strings.
-    mdMethodDef *pmdSetter,             // [OUT] setter method of the property
-    mdMethodDef *pmdGetter,             // [OUT] getter method of the property
-    mdMethodDef rmdOtherMethod[],       // [OUT] other method of the property
-    ULONG       cMax,                   // [IN] size of rmdOtherMethod
-    ULONG       *pcOtherMethod)         // [OUT] total number of other method of this property
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetParamProps (               // S_OK or error.
-    mdParamDef  tk,                     // [IN]The Parameter.
-    mdMethodDef *pmd,                   // [OUT] Parent Method token.
-    ULONG       *pulSequence,           // [OUT] Parameter sequence.
-    __out_ecount (cchName) LPWSTR szName, // [OUT] Put name here.
-    ULONG       cchName,                // [OUT] Size of name buffer.
-    ULONG       *pchName,               // [OUT] Put actual size of name here.
-    DWORD       *pdwAttr,               // [OUT] Put flags here.
-    DWORD       *pdwCPlusTypeFlag,      // [OUT] Flag for value type. selected ELEMENT_TYPE_*.
-    UVCP_CONSTANT *ppValue,             // [OUT] Constant value.
-    ULONG       *pcchValue)             // [OUT] size of constant string in chars, 0 for non-strings.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetCustomAttributeByName (    // S_OK or error.
-    mdToken     tkObj,                  // [IN] Object with Custom Attribute.
-    LPCWSTR     szName,                 // [IN] Name of desired Custom Attribute.
-    const void  **ppData,               // [OUT] Put pointer to data here.
-    ULONG       *pcbData)               // [OUT] Put size of data here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-BOOL AssemblyMDInternalImport::IsValidToken (         // True or False.
-    mdToken     tk)                     // [IN] Given token.
-{
-    _ASSERTE(!"NYI");
-    return FALSE;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetNestedClassProps (         // S_OK or error.
-    mdTypeDef   tdNestedClass,          // [IN] NestedClass token.
-    mdTypeDef   *ptdEnclosingClass)       // [OUT] EnclosingClass token.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetNativeCallConvFromSig (    // S_OK or error.
-    void const  *pvSig,                 // [IN] Pointer to signature.
-    ULONG       cbSig,                  // [IN] Count of signature bytes.
-    ULONG       *pCallConv)             // [OUT] Put calling conv here (see CorPinvokemap).
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::IsGlobal (                    // S_OK or error.
-    mdToken     pd,                     // [IN] Type, Field, or Method token.
-    int         *pbGlobal)              // [OUT] Put 1 if global, 0 otherwise.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetMethodSpecProps(
-        mdMethodSpec mi,                    // [IN] The method instantiation
-        mdToken *tkParent,                  // [OUT] MethodDef or MemberRef
-        PCCOR_SIGNATURE *ppvSigBlob,        // [OUT] point to the blob value of meta data
-        ULONG       *pcbSigBlob)            // [OUT] actual size of signature blob
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-// *** ISNAssemblySignature methods ***
-
-STDMETHODIMP AssemblyMDInternalImport::GetSNAssemblySignature(
-    BYTE        *pbSig,                 // [IN, OUT] Buffer to write signature
-    DWORD       *pcbSig)                // [IN, OUT] Size of buffer, bytes written
-{
-    return RuntimeGetAssemblyStrongNameHashForModule(m_pHandle, this, pbSig, pcbSig);
-}
-
-
-#include "strongname.h"
-
-#ifdef FEATURE_PREJIT
-// *** IGetIMDInternalImport ***
-STDMETHODIMP AssemblyMDInternalImport::GetIMDInternalImport(
-    IMDInternalImport ** pIMDInternalImport)
-{
-    m_pMDInternalImport->AddRef();
-    *pIMDInternalImport = m_pMDInternalImport;
-    return S_OK;
-}
-
-
-
-// ===========================================================================
-
-class CNativeImageDependency : public INativeImageDependency
-{
-public:
-    CNativeImageDependency(CORCOMPILE_DEPENDENCY * pDependency)
-        : m_cRef(1), m_pDependency(pDependency)
-    {
-    }
-    
-    ~CNativeImageDependency()
-    {
-    }
-
-    //
-    // IUnknown
-    //
-    
-    STDMETHODIMP_(ULONG) AddRef()
-    {
-        return InterlockedIncrement(&m_cRef);
-    }
-
-    STDMETHODIMP_(ULONG) Release()
-    {
-        ULONG   cRef = InterlockedDecrement(&m_cRef);
-        if (!cRef)
-            delete this;
-        return (cRef);
-    }
-
-    STDMETHODIMP QueryInterface(REFIID riid, void **ppUnk)
-    { 
-        *ppUnk = 0;
-
-        if (riid == IID_IUnknown)
-            *ppUnk = (IUnknown *) (IMetaDataAssemblyImport *) this;
-        else if (riid == IID_INativeImageDependency)
-            *ppUnk = (INativeImageDependency *) this;
-        else
-            return (E_NOINTERFACE);
-        AddRef();
-        return (S_OK);
-    }
-
-    //
-    // INativeImageDependency
-    //
-    
-    STDMETHODIMP GetILAssemblyRef(mdAssemblyRef * pAssemblyRef)
-    {
-        BEGIN_ENTRYPOINT_NOTHROW;
-
-        *pAssemblyRef = m_pDependency->dwAssemblyRef;
-        END_ENTRYPOINT_NOTHROW;
-        
-        return S_OK;
-    }
-
-    STDMETHODIMP GetILAssemblyDef(
-        mdAssemblyRef * ppAssemblyDef,
-        CORCOMPILE_ASSEMBLY_SIGNATURE * pSign)
-    {
-        BEGIN_ENTRYPOINT_NOTHROW;
-
-        *ppAssemblyDef = m_pDependency->dwAssemblyDef;
-        *pSign = m_pDependency->signAssemblyDef;
-        END_ENTRYPOINT_NOTHROW;
-
-        return S_OK;
-    }
-
-    STDMETHODIMP GetNativeAssemblyDef(CORCOMPILE_NGEN_SIGNATURE * pNativeSign)
-    {
-        BEGIN_ENTRYPOINT_NOTHROW;
-
-        *pNativeSign = m_pDependency->signNativeImage;
-        END_ENTRYPOINT_NOTHROW;
-
-        return S_OK;
-    }
-
-    STDMETHODIMP GetPEKind(PEKIND *pPEKind)
-    {
-        BEGIN_ENTRYPOINT_NOTHROW;
-
-        *pPEKind = PEKIND((m_pDependency->dependencyInfo & CORCOMPILE_DEPENDENCY_PEKIND_MASK) >> CORCOMPILE_DEPENDENCY_PEKIND_SHIFT);
-        END_ENTRYPOINT_NOTHROW;
-
-        return S_OK;
-    }
-
-protected:
-
-    LONG                        m_cRef;
-    CORCOMPILE_DEPENDENCY *     m_pDependency;
-};
-
-// ===========================================================================
-// *** INativeImageInstallInfo ***
-// ===========================================================================
-
-STDMETHODIMP AssemblyMDInternalImport::GetSignature(CORCOMPILE_NGEN_SIGNATURE * pNgenSign)
-{
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    *pNgenSign = m_pZapVersionInfo->signature;
-    END_ENTRYPOINT_NOTHROW;
-
-    return S_OK;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetVersionInfo(CORCOMPILE_VERSION_INFO * pVersionInfo)
-{
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    *pVersionInfo = *m_pZapVersionInfo;
-    END_ENTRYPOINT_NOTHROW;
-    return S_OK;
-}
-            
-
-
-STDMETHODIMP AssemblyMDInternalImport::GetILSignature(CORCOMPILE_ASSEMBLY_SIGNATURE * pILSign)
-{
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    *pILSign = m_pZapVersionInfo->sourceAssembly;
-    END_ENTRYPOINT_NOTHROW;
-    return S_OK;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetConfigMask(DWORD * pConfigMask)
-{
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    *pConfigMask = m_pZapVersionInfo->wConfigFlags;
-    END_ENTRYPOINT_NOTHROW;
-
-    return S_OK;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumDependencies (
-    HCORENUM * phEnum,                  // [IN/OUT] - Pointer to the enum
-    INativeImageDependency *rDeps[],    // [OUT]
-    ULONG cMax,                         // Max dependancies to enumerate in this iteration
-    DWORD * pdwCount                    // [OUT] - Number of dependancies actually enumerated
-    )
-{
-    HRESULT hr = S_OK;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    CORCOMPILE_DEPENDENCY * pDependenciesEnd = m_pZapDependencies + m_cZapDependencies;
-
-    CORCOMPILE_DEPENDENCY * pNextDependency;
-
-    // Is the enum just being initialized, or are we walking an existing one?
-    if ((*phEnum) == NULL)
-        pNextDependency = m_pZapDependencies;
-    else
-        pNextDependency = (CORCOMPILE_DEPENDENCY *)(*phEnum);
-
-    DWORD count;
-    for (count = 0;
-         pNextDependency < pDependenciesEnd && count < cMax;
-         count++, pNextDependency++)
-    {
-        CNativeImageDependency * pDep = new (nothrow) CNativeImageDependency(pNextDependency);
-        IfNullGo( pDep );
-
-        rDeps[count] = pDep;
-    }
-    
-    *phEnum = (HCORENUM)(pNextDependency < pDependenciesEnd) ? pNextDependency : NULL;
-    *pdwCount = count;
-
-ErrExit:
-    END_ENTRYPOINT_NOTHROW;
-    
-    return hr;
-}
-
-
-STDMETHODIMP AssemblyMDInternalImport::GetDependency (
-    const CORCOMPILE_NGEN_SIGNATURE *pcngenSign,  // [IN] ngenSig of dependency you want
-    CORCOMPILE_DEPENDENCY           *pDep         // [OUT] matching dependency
-    )
-{
-    HRESULT hr = S_OK;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    _ASSERTE(pcngenSign != NULL);
-    _ASSERTE(*pcngenSign != INVALID_NGEN_SIGNATURE);
-    _ASSERTE(pDep != NULL);
-
-    CORCOMPILE_DEPENDENCY * pDependenciesEnd = m_pZapDependencies + m_cZapDependencies;
-    CORCOMPILE_DEPENDENCY * pNextDependency = m_pZapDependencies;
-    while (pNextDependency != pDependenciesEnd)
-    {
-        if (pNextDependency->signNativeImage == *pcngenSign)
-        {
-            *pDep = *pNextDependency;
-            hr = S_OK;
-            goto ErrExit;
-        }
-        pNextDependency++;
-    }
-    hr = S_FALSE;
-
-ErrExit:
-    END_ENTRYPOINT_NOTHROW;
-    
-    return hr;
-}
-
-
-#endif  // FEATURE_PREJIT
-
-
-//*****************************************************************************
-// IMetaDataImport2 methods
-//*****************************************************************************
-STDMETHODIMP AssemblyMDInternalImport::GetGenericParamProps(      // S_OK or error.
-        mdGenericParam gp,                  // [IN] GenericParam
-        ULONG        *pulParamSeq,          // [OUT] Index of the type parameter
-        DWORD        *pdwParamFlags,        // [OUT] Flags, for future use (e.g. variance)
-        mdToken      *ptOwner,              // [OUT] Owner (TypeDef or MethodDef)
-        DWORD       *reserved,              // [OUT] For future use (e.g. non-type parameters)
-        __out_ecount (cchName) LPWSTR wzname, // [OUT] Put name here
-        ULONG        cchName,               // [IN] Size of buffer
-        ULONG        *pchName)              // [OUT] Put size of name (wide chars) here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetGenericParamConstraintProps( // S_OK or error.
-        mdGenericParamConstraint gpc,       // [IN] GenericParamConstraint
-        mdGenericParam *ptGenericParam,     // [OUT] GenericParam that is constrained
-        mdToken      *ptkConstraintType)    // [OUT] TypeDef/Ref/Spec constraint
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumGenericParams(         // S_OK or error.
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-        mdToken      tk,                    // [IN] TypeDef or MethodDef whose generic parameters are requested
-        mdGenericParam rGenericParams[],    // [OUT] Put GenericParams here.
-        ULONG       cMax,                   // [IN] Max GenericParams to put.
-        ULONG       *pcGenericParams)       // [OUT] Put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumGenericParamConstraints( // S_OK or error.
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-        mdGenericParam tk,                  // [IN] GenericParam whose constraints are requested
-        mdGenericParamConstraint rGenericParamConstraints[],    // [OUT] Put GenericParamConstraints here.
-        ULONG       cMax,                   // [IN] Max GenericParamConstraints to put.
-        ULONG       *pcGenericParamConstraints) // [OUT] Put # put here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::EnumMethodSpecs(           // S_OK or error.
-        HCORENUM    *phEnum,                // [IN|OUT] Pointer to the enum.
-        mdToken      tk,                    // [IN] MethodDef or MemberRef whose MethodSpecs are requested
-        mdMethodSpec rMethodSpecs[],        // [OUT] Put MethodSpecs here.
-        ULONG       cMax,                   // [IN] Max tokens to put.
-        ULONG       *pcMethodSpecs)         // [OUT] Put actual count here.
-{
-    _ASSERTE(!"NYI");
-    return E_NOTIMPL;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetPEKind(         // S_OK or error.
-    DWORD* pdwPEKind,           // [OUT] The kind of PE (0 - not a PE)
-    DWORD* pdwMachine)          // [OUT] Machine as defined in NT header
-{
-    HRESULT hr = S_OK;
-    if(pdwPEKind) *pdwPEKind = m_dwPEKind;
-    if(pdwMachine) *pdwMachine = m_dwMachine;
-    return hr;
-}
-
-STDMETHODIMP AssemblyMDInternalImport::GetVersionString(    // S_OK or error.
-        __out_ecount (ccBufSize) LPWSTR pwzBuf, // Put version string here.
-        DWORD ccBufSize,              // [in] size of the buffer, in wide chars
-        DWORD *pccBufSize)           // [out] Size of the version string, wide chars, including terminating nul.
-{
-    HRESULT hr=S_OK;
-    DWORD   L = WszMultiByteToWideChar(CP_UTF8,0,m_szVersionString,-1,pwzBuf,ccBufSize);
-    if(ccBufSize < L)
-        hr = HRESULT_FROM_WIN32(ERROR_BUFFER_OVERFLOW);
-
-    if(pccBufSize) *pccBufSize = L;
-    return hr;
-}
-
-#endif //!DACCESS_COMPILE
-
-#endif // FEATURE_FUSION
 
 #endif //FEATURE_METADATA_INTERNAL_APIS
diff --git a/src/md/winmd/adapter.cpp b/src/md/winmd/adapter.cpp
index 2c9dd1b9fd..d4e95b7f8b 100644
--- a/src/md/winmd/adapter.cpp
+++ b/src/md/winmd/adapter.cpp
@@ -1185,14 +1185,12 @@ void WinMDAdapter::GetExtraAssemblyRefProps(FrameworkAssemblyIndex index,
 
     if (ppPublicKeytoken)
     {
-#ifdef FEATURE_CORECLR
         if (index == FrameworkAssembly_Mscorlib)
         {
             *ppPublicKeytoken = g_rbTheSilverlightPlatformKeyToken;
             *pTokenLength = sizeof(g_rbTheSilverlightPlatformKeyToken);
         }
         else
-#endif
         {
             if (index == FrameworkAssembly_SystemNumericsVectors || index == FrameworkAssembly_SystemRuntime || index == FrameworkAssembly_SystemObjectModel)
             {
diff --git a/src/md/winmd/inc/adapter.h b/src/md/winmd/inc/adapter.h
index e42992f81f..cc422017b6 100644
--- a/src/md/winmd/inc/adapter.h
+++ b/src/md/winmd/inc/adapter.h
@@ -236,14 +236,12 @@ public:
             if (pusRevisionNumber != nullptr)
                 *pusRevisionNumber = VER_ASSEMBLYBUILD_QFE;
 
-#ifdef FEATURE_CORECLR
             // Under CoreCLR, we replace the ECMA key in the mscorlib assembly ref with the CoreCLR platform public key token
             if (ppbPublicKeyOrToken != nullptr)
             {
                 *ppbPublicKeyOrToken = g_rbTheSilverlightPlatformKeyToken;
                 *pcbPublicKeyOrToken = _countof(g_rbTheSilverlightPlatformKeyToken);
             }
-#endif
         }
         else if (RidFromToken(mdar) > m_rawAssemblyRefCount)
         {
@@ -632,11 +630,7 @@ public:
             case FrameworkAssembly_SystemRuntimeWindowsRuntimeUIXaml:
                 return "System.Runtime.WindowsRuntime.UI.Xaml";
             case FrameworkAssembly_SystemNumericsVectors:
-#ifdef FEATURE_CORECLR
                 return "System.Numerics.Vectors";
-#else
-                return "System.Numerics";
-#endif 
             default:
                 _ASSERTE(!"Invalid AssemblyRef token!");
                 return NULL;
diff --git a/src/mscorlib/Common/PinnableBufferCache.cs b/src/mscorlib/Common/PinnableBufferCache.cs
index fc6e13a899..6c85a5a2f6 100644
--- a/src/mscorlib/Common/PinnableBufferCache.cs
+++ b/src/mscorlib/Common/PinnableBufferCache.cs
@@ -11,7 +11,6 @@ using System.Collections.Concurrent;
 using System.Threading;
 using System.Runtime.CompilerServices;
 using System.Diagnostics;
-using System.Security.Permissions;
 
 #if PINNABLEBUFFERCACHE_MSCORLIB
 namespace System.Threading
@@ -21,22 +20,6 @@ namespace System
 {
     internal sealed class PinnableBufferCache
     {
-        /// <summary>
-        /// Create a new cache for pinned byte[] buffers
-        /// </summary>
-        /// <param name="cacheName">A name used in diagnostic messages</param>
-        /// <param name="numberOfElements">The size of byte[] buffers in the cache (they are all the same size)</param>
-        public PinnableBufferCache(string cacheName, int numberOfElements) : this(cacheName, () => new byte[numberOfElements]) { }
-
-        /// <summary>
-        /// Get a buffer from the buffer manager.  If no buffers exist, allocate a new one.
-        /// </summary>
-        public byte[] AllocateBuffer() { return (byte[])Allocate(); }
-
-        /// <summary>
-        /// Return a buffer back to the buffer manager.
-        /// </summary>
-        public void FreeBuffer(byte[] buffer) { Free(buffer); }
 
         /// <summary>
         /// Create a PinnableBufferCache that works on any object (it is intended for OverlappedData)
@@ -537,9 +520,6 @@ namespace System
 
         public bool IsEnabled() { return false; }
         public void DebugMessage(string message) {}
-        public void DebugMessage1(string message, long value) {}
-        public void DebugMessage2(string message, long value1, long value2) {}
-        public void DebugMessage3(string message, long value1, long value2, long value3) {}
         public void Create(string cacheName) {}
         public void AllocateBuffer(string cacheName, ulong objectId, int objectHash, int objectGen, int freeCountAfter) {}
         public void AllocateBufferFromNotGen2(string cacheName, int notGen2CountAfter) {}
@@ -560,10 +540,5 @@ namespace System
         {
             return 0;
         }
-
-        static internal unsafe long AddressOfObject(byte[] array)
-        {
-            return 0;
-        }
     }
 }
diff --git a/src/mscorlib/Common/Preprocessed/AssemblyRefs.g.cs b/src/mscorlib/Common/Preprocessed/AssemblyRefs.g.cs
index 24a1866a5d..d5866a4bcd 100644
--- a/src/mscorlib/Common/Preprocessed/AssemblyRefs.g.cs
+++ b/src/mscorlib/Common/Preprocessed/AssemblyRefs.g.cs
@@ -15,1068 +15,19 @@ using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Runtime.CompilerServices;
 
-
-// #line 1 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-/**
- * Version strings for Frameworks.
- * 
- */
-
-//
-// Insert just the #defines in winver.h, so that the
-// C# compiler can include this file after macro preprocessing.
-//
-
-
-
-
-
-
-
-
-
-// #line 21 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-
-
-
-//
-// winver.h is bad for rc.exe & csc.exe whereas verrsrc.h does not have an include guard
-// yet defines the same structure twice if RC_INVOKED is not #defined.
-// Temporarily enable RC_INVOKED protection around the #include.
-//
-
-
-
-
-
-
-// #line 1 "c:\\program files (x86)\\windows kits\\8.1\\include\\um\\verrsrc.h"
-// #line 1 "c:\\program files (x86)\\windows kits\\8.1\\include\\shared\\winapifamily.h"
-/*
-
-
-
-Module Name:
-
-    winapifamily.h
-
-Abstract:
-
-    Master include file for API family partitioning.
-
-*/
-
-
-
-
-
-// #pragma once
-// #line 21 "c:\\program files (x86)\\windows kits\\8.1\\include\\shared\\winapifamily.h"
-
-/*
- * When compiling C and C++ code using SDK header files, the development
- * environment can specify a target platform by #define-ing the
- * pre-processor symbol WINAPI_FAMILY to one of the following values.
- * Each FAMILY value denotes an application family for which a different
- * subset of the total set of header-file-defined APIs are available.
- * Setting the WINAPI_FAMILY value will effectively hide from the
- * editing and compilation environments the existence of APIs that
- * are not applicable to the family of applications targeting a
- * specific platform.
- */
-
-/*
- * The WINAPI_FAMILY values of 0 and 1 are reserved to ensure that
- * an error will occur if WINAPI_FAMILY is set to any
- * WINAPI_PARTITION value (which must be 0 or 1, see below).
- */
-
-
-
-/* The value of WINAPI_FAMILY_DESKTOP_APP may change in future SDKs. */
-/* Additional WINAPI_FAMILY values may be defined in future SDKs. */
-
-/*
- * For compatibility with Windows 8 header files, the following
- * synonym for WINAPI_FAMILY_PC_APP is temporarily #define'd.
- * Use of this symbol should be considered deprecated.
- */
-
-
-/*
- * If no WINAPI_FAMILY value is specified, then all APIs available to
- * Windows desktop applications are exposed.
- */
-
-
-// #line 59 "c:\\program files (x86)\\windows kits\\8.1\\include\\shared\\winapifamily.h"
-
-/*
- * API PARTITONs are part of an indirection mechanism for mapping between
- * individual APIs and the FAMILYs to which they apply.
- * Each PARTITION is a category or subset of named APIs.  PARTITIONs
- * are permitted to have overlapping membership -- some single API
- * might be part of more than one PARTITION.  In support of new
- * FAMILYs that might be added in future SDKs, any single current
- * PARTITION might in that future SDK be split into two or more new PARTITIONs.
- * Accordingly, application developers should avoid taking dependencies on
- * PARTITION names; developers' only dependency upon the symbols defined
- * in this file should be their reliance on the WINAPI_FAMILY names and values.
- */
-
-/*
- * Current PARTITIONS are each #undef'ed below, and then will be #define-ed
- * to be either 1 or 0 or depending on the active WINAPI_FAMILY.
- */
-
-
-
-
-
-
-
-/*
- * The mapping between families and partitions is summarized here.
- * An X indicates that the given partition is active for the given
- * platform/family.
- *
- *                             +---------------+
- *                             |  *Partition*  |
- *                             +---+---+---+---+
- *                             |   |   |   | P |
- *                             |   |   |   | H |
- *                             | D |   |   | O |
- *                             | E |   | P | N |
- *                             | S |   | C | E |
- *                             | K |   | _ | _ |
- *                             | T | A | A | A |
- * +-------------------------+-+ O | P | P | P |
- * |     *Platform/Family*    \| P | P | P | P |
- * +---------------------------+---+---+---+---+
- * | WINAPI_FAMILY_DESKTOP_APP | X | X | X |   |
- * +---------------------------+---+---+---+---+
- * |      WINAPI_FAMILY_PC_APP |   | X | X |   |
- * +---------------------------+---+---+---+---+
- * |   WINAPI_FAMILY_PHONE_APP |   | X |   | X |
- * +---------------------------+---+---+---+---+
- *
- * The table above is encoded in the following expressions,
- * each of which evaluates to 1 or 0.
- *
- * Whenever a new family is added, all of these expressions
- * need to be reconsidered.
- */
-
-
-// #line 118 "c:\\program files (x86)\\windows kits\\8.1\\include\\shared\\winapifamily.h"
-
-
-
-
-
-/*
- * For compatibility with Windows Phone 8 header files, the following
- * synonym for WINAPI_PARTITION_PHONE_APP is temporarily #define'd.
- * Use of this symbol should be regarded as deprecated.
- */
-
-
-/*
- * Header files use the WINAPI_FAMILY_PARTITION macro to assign one or
- * more declarations to some group of partitions.  The macro chooses
- * whether the preprocessor will emit or omit a sequence of declarations
- * bracketed by an #if/#endif pair.  All header file references to the
- * WINAPI_PARTITION_* values should be in the form of occurrences of
- * WINAPI_FAMILY_PARTITION(...).
- *
- * For example, the following usage of WINAPI_FAMILY_PARTITION identifies
- * a sequence of declarations that are part of both the Windows Desktop
- * Partition and the Windows-Phone-Specific Store Partition:
- *
- *     #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_PHONE_APP)
- *     ...
- *     #endif // WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_PHONE_APP)
- *
- * The comment on the closing #endif allow tools as well as people to find the
- * matching #ifdef properly.
- *
- * Usages of WINAPI_FAMILY_PARTITION may be combined, when the partitition definitions are
- * related.  In particular one might use declarations like
- * 
- *     #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
- *
- * or
- *
- *     #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP)
- *
- * Direct references to WINAPI_PARTITION_ values (eg #if !WINAPI_FAMILY_PARTITION_...)
- * should not be used.
- */ 
-
-
-/*
- * Macro used to #define or typedef a symbol used for selective deprecation
- * of individual methods of a COM interfaces that are otherwise available
- * for a given set of partitions.
- */
-
-
-/*
- * For compatibility with Windows 8 header files, the following
- * symbol is temporarily conditionally #define'd.  Additional symbols
- * like this should be not defined in winapifamily.h, but rather should be
- * introduced locally to the header files of the component that needs them.
- */
-
-
-// #line 179 "c:\\program files (x86)\\windows kits\\8.1\\include\\shared\\winapifamily.h"
-
-// #line 181 "c:\\program files (x86)\\windows kits\\8.1\\include\\shared\\winapifamily.h"
-// #line 2 "c:\\program files (x86)\\windows kits\\8.1\\include\\um\\verrsrc.h"
-
-/****************************************************************************
-**                                                                             *
-* verrsrc.h -   Version Resource definitions                                  *
-*                                                                             *
-*               Include file declaring version resources in rc files          *
-*                                                                             *
-*               *
-*                                                                             *
-\*****************************************************************************/
-
-// #pragma region Application Family
-
-
-/* ----- Symbols ----- */
-
-
-
-
-/* ----- VS_VERSION.dwFileFlags ----- */
-
-
-
-
-// #line 27 "c:\\program files (x86)\\windows kits\\8.1\\include\\um\\verrsrc.h"
-
-
-
-/* ----- VS_VERSION.dwFileFlags ----- */
-
-
-
-
-
-
-
-/* ----- VS_VERSION.dwFileOS ----- */
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-/* ----- VS_VERSION.dwFileType ----- */
-
-
-
-
-
-
-
-
-/* ----- VS_VERSION.dwFileSubtype for VFT_WINDOWS_DRV ----- */
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-/* ----- VS_VERSION.dwFileSubtype for VFT_WINDOWS_FONT ----- */
-
-
-
-
-// #line 88 "c:\\program files (x86)\\windows kits\\8.1\\include\\um\\verrsrc.h"
-// // #pragma region 
-
-// #pragma region Desktop Family
-
-
-/* ----- VerFindFile() flags ----- */
-
-
-
-
-
-
-/* ----- VerInstallFile() flags ----- */
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-// #line 171 "c:\\program files (x86)\\windows kits\\8.1\\include\\um\\verrsrc.h"
-// #pragma region 
-
-// #line 37 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-
-
-
-
-
-//
-// Include the definitions for rmj, rmm, rup, rpt
-//
-
-// #line 1 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\product_version.h"
-
-
-
-
-// #line 6 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\product_version.h"
-
-// #line 1 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\version.h"
-// #line 1 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\ndpversion_generated.h"
-
-
-
-
-// #line 6 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\ndpversion_generated.h"
-
-
-
-
-
-// #line 1 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\buildnumber.h"
-
-
-
-
-// #line 6 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\buildnumber.h"
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-// #line 12 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\ndpversion_generated.h"
-// #line 2 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\version.h"
-
-
-
-
-
-
-
-
-
-
-
-
-// #line 8 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\product_version.h"
-
-
-
-// #line 1 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\asm_version.h"
-
-
-
-
-
-
-
-
-
-
-
-// #line 13 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\asm_version.h"
-
-
-
-
-
-// #line 19 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\asm_version.h"
-
-// #line 12 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\product_version.h"
-// #line 13 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\product_version.h"
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-// #line 161 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\product_version.h"
-
-
-
-
-
-// #line 167 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\product_version.h"
-
-
-
-
-
-// #line 173 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\product_version.h"
-
-
-
-
-
-
-// #line 180 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\product_version.h"
-
-// #line 48 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-/*
- * Product version, name and copyright
- */
-
-// #line 1 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxverstrings.h"
-
-    
-        
-
-// #line 6 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxverstrings.h"
-            
-        
-
-// #line 10 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxverstrings.h"
-    
-
-
-
-// #line 15 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxverstrings.h"
-// #line 16 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxverstrings.h"
-
-// The following copyright is intended for display in the Windows Explorer property box for a DLL or EXE
-// See \\lca\pdm\TMGUIDE\Copyright\Crt_Tmk_Notices.xls for copyright guidelines
-//
-
-    
-        
-
-// #line 25 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxverstrings.h"
-            
-        
-
-// #line 29 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxverstrings.h"
-    
-
-
-
-
-
-
-// #line 37 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxverstrings.h"
-// #line 38 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxverstrings.h"
-
-// VSWhidbey #495749
-// Note: The following legal copyright is intended for situations where the copyright symbol doesn't display 
-//       properly.  For example, the following copyright should be displayed as part of the logo for DOS command-line 
-//       applications.  If you change the format or wording of the following copyright, you should apply the same
-//       change to fxresstrings.txt (for managed applications).
-
-    
-    
-// #line 48 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxverstrings.h"
-// #line 54 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-/*
- * File version, names, description.
- */
-
-// FX_VER_INTERNALNAME_STR is passed in by the build environment.
-
-
-
-
-
-
-
-// FX_VER_FILEDESCRIPTION_STR is defined in RC files that include fxver.h
-
-
-
-// #line 72 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-
-
-
-
-// #line 78 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-
-
-
-
-
-// #line 85 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-
-
-//URT_VFT passed in by the build environment.
-
-
-
-
-
-
-
-/* default is nodebug */
-
-
-
-
-// #line 102 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-// DEBUG flag is set for debug build, not set for retail build
-// #if defined(DEBUG) || defined(_DEBUG)
-// #define VER_DEBUG        VS_FF_DEBUG
-// #else  // DEBUG
-// #define VER_DEBUG        0
-// #endif // DEBUG
-
-
-/* default is prerelease */
-
-
-// #line 115 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-// #line 117 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-// PRERELEASE flag is always set unless building SHIP version
-// #ifndef _SHIP
-// #define VER_PRERELEASE   VS_FF_PRERELEASE
-// #else
-// #define VER_PRERELEASE   0
-// #endif // _SHIP
-
-
-
-// #line 128 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-// #line 130 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-// PRIVATEBUILD flag is set if not built by build lab
-// #ifndef _VSBUILD
-// #define VER_PRIVATEBUILD VS_FF_PRIVATEBUILD
-// #else  // _VSBUILD
-// #define VER_PRIVATEBUILD 0
-// #endif // _VSBUILD
-
-
-
-// #line 141 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-// #line 143 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-// #line 164 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-
-
-
-
-
-
-
-
-// #line 174 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-
-
-
-
-// #line 180 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-
-
-
-
-
-
-
-// #line 189 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-
-
-// #line 193 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-// #line 248 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-// #line 250 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-
-
-// #line 254 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-
-// #line 256 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\include\\fxver.h"
-// #line 24 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\assemblyrefs.cspp"
-
 internal static class FXAssembly {
     internal const string Version = "4.0.0.0";
 }
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-// #line 44 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\assemblyrefs.cspp"
-
 internal static class ThisAssembly {
-    internal const string Title = "System.Private.CoreLib.dll";
-    internal const string Description = "System.Private.CoreLib.dll";
-    internal const string DefaultAlias = "System.Private.CoreLib.dll";
-    internal const string Copyright = "\u00A9 Microsoft Corporation.  All rights reserved.";
     internal const string Version = "4.0.0.0";
-    internal const string InformationalVersion = "4.0.22306.0";
-    internal const string DailyBuildNumberStr = "22306";
-    internal const string BuildRevisionStr = "0";
     internal const int DailyBuildNumber = 22306;
 }
 
-
-#pragma warning disable 436
 internal static class AssemblyRef {
     internal const string EcmaPublicKey                              = "b77a5c561934e089";
     internal const string EcmaPublicKeyToken                         = "b77a5c561934e089";
-    internal const string EcmaPublicKeyFull                          = "00000000000000000400000000000000";
-
-    internal const string SilverlightPublicKey                       = "31bf3856ad364e35";
-    internal const string SilverlightPublicKeyToken                  = "31bf3856ad364e35";
-    internal const string SilverlightPublicKeyFull                   = "0024000004800000940000000602000000240000525341310004000001000100B5FC90E7027F67871E773A8FDE8938C81DD402BA65B9201D60593E96C492651E889CC13F1415EBB53FAC1131AE0BD333C5EE6021672D9718EA31A8AEBD0DA0072F25D87DBA6FC90FFD598ED4DA35E44C398C454307E8E33B8426143DAEC9F596836F97C8F74750E5975C64E2189F45DEF46B2A2B1247ADC3652BF5C308055DA9";
-
-    internal const string SilverlightPlatformPublicKey               = "7cec85d7bea7798e";
-    internal const string SilverlightPlatformPublicKeyToken          = "7cec85d7bea7798e";
-    internal const string SilverlightPlatformPublicKeyFull           = "00240000048000009400000006020000002400005253413100040000010001008D56C76F9E8649383049F383C44BE0EC204181822A6C31CF5EB7EF486944D032188EA1D3920763712CCB12D75FB77E9811149E6148E5D32FBAAB37611C1878DDC19E20EF135D0CB2CFF2BFEC3D115810C3D9069638FE4BE215DBF795861920E5AB6F7DB2E2CEEF136AC23D5DD2BF031700AEC232F6C6B1C785B4305C123B37AB";
-
-
-    internal const string PlatformPublicKey                          = SilverlightPlatformPublicKey;
-    internal const string PlatformPublicKeyToken                     = SilverlightPlatformPublicKeyToken;
-    internal const string PlatformPublicKeyFull                      = SilverlightPlatformPublicKeyFull;
-
-
-
-
-// #line 81 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\assemblyrefs.cspp"
-
-    internal const string Mscorlib                                   = "mscorlib, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + PlatformPublicKey;
-    internal const string SystemData                                 = "System.Data, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + EcmaPublicKey;
-    internal const string SystemDataOracleClient                     = "System.Data.OracleClient, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + EcmaPublicKey;
-    internal const string System                                     = "System, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + PlatformPublicKey;
-    internal const string SystemCore                                 = "System.Core, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + PlatformPublicKey;
-    internal const string SystemNumerics                             = "System.Numerics, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + PlatformPublicKey;
-    internal const string SystemRuntimeRemoting                      = "System.Runtime.Remoting, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + EcmaPublicKey;
-    internal const string SystemThreadingTasksDataflow               = "System.Threading.Tasks.Dataflow, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + PlatformPublicKey;
-    internal const string SystemWindowsForms                         = "System.Windows.Forms, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + EcmaPublicKey;
-    internal const string SystemXml                                  = "System.Xml, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + EcmaPublicKey;
-    
-    internal const string MicrosoftPublicKey                         = "b03f5f7f11d50a3a";
     internal const string MicrosoftPublicKeyToken                    = "b03f5f7f11d50a3a";
-    internal const string MicrosoftPublicKeyFull                     = "002400000480000094000000060200000024000052534131000400000100010007D1FA57C4AED9F0A32E84AA0FAEFD0DE9E8FD6AEC8F87FB03766C834C99921EB23BE79AD9D5DCC1DD9AD236132102900B723CF980957FC4E177108FC607774F29E8320E92EA05ECE4E821C0A5EFE8F1645C4C0C93C1AB99285D622CAA652C1DFAD63D745D6F2DE5F17E5EAF0FC4963D261C8A12436518206DC093344D5AD293";
-
-    internal const string SharedLibPublicKey                         = "31bf3856ad364e35";
-    internal const string SharedLibPublicKeyToken                    = "31bf3856ad364e35";
-    internal const string SharedLibPublicKeyFull                     = "0024000004800000940000000602000000240000525341310004000001000100B5FC90E7027F67871E773A8FDE8938C81DD402BA65B9201D60593E96C492651E889CC13F1415EBB53FAC1131AE0BD333C5EE6021672D9718EA31A8AEBD0DA0072F25D87DBA6FC90FFD598ED4DA35E44C398C454307E8E33B8426143DAEC9F596836F97C8F74750E5975C64E2189F45DEF46B2A2B1247ADC3652BF5C308055DA9";
-
-    internal const string SystemComponentModelDataAnnotations        = "System.ComponentModel.DataAnnotations, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + SharedLibPublicKey;
-    internal const string SystemConfiguration                        = "System.Configuration, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string SystemConfigurationInstall                 = "System.Configuration.Install, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string SystemDeployment                           = "System.Deployment, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string SystemDesign                               = "System.Design, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string SystemDirectoryServices                    = "System.DirectoryServices, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string SystemDrawingDesign                        = "System.Drawing.Design, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string SystemDrawing                              = "System.Drawing, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string SystemEnterpriseServices                   = "System.EnterpriseServices, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string SystemManagement                           = "System.Management, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string SystemMessaging                            = "System.Messaging, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string SystemNetHttp                              = "System.Net.Http, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string SystemNetHttpWebRequest                    = "System.Net.Http.WebRequest, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string SystemRuntimeSerializationFormattersSoap   = "System.Runtime.Serialization.Formatters.Soap, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
     internal const string SystemRuntimeWindowsRuntime                = "System.Runtime.WindowsRuntime, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + EcmaPublicKey;
-    internal const string SystemRuntimeWindowsRuntimeUIXaml          = "System.Runtime.WindowsRuntimeUIXaml, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + EcmaPublicKey;
-    internal const string SystemSecurity                             = "System.Security, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string SystemServiceModelWeb                      = "System.ServiceModel.Web, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + SharedLibPublicKey;
-    internal const string SystemServiceProcess                       = "System.ServiceProcess, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string SystemWeb                                  = "System.Web, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string SystemWebAbstractions                      = "System.Web.Abstractions, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + SharedLibPublicKey;
-    internal const string SystemWebDynamicData                       = "System.Web.DynamicData, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + SharedLibPublicKey;
-    internal const string SystemWebDynamicDataDesign                 = "System.Web.DynamicData.Design, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + SharedLibPublicKey;
-    internal const string SystemWebEntityDesign                      = "System.Web.Entity.Design, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + EcmaPublicKey;
-    internal const string SystemWebExtensions                        = "System.Web.Extensions, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + SharedLibPublicKey;
-    internal const string SystemWebExtensionsDesign                  = "System.Web.Extensions.Design, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + SharedLibPublicKey;
-    internal const string SystemWebMobile                            = "System.Web.Mobile, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string SystemWebRegularExpressions                = "System.Web.RegularExpressions, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string SystemWebRouting                           = "System.Web.Routing, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + SharedLibPublicKey;
-    internal const string SystemWebServices                          = "System.Web.Services, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    
-    internal const string WindowsBase                                = "WindowsBase, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + SharedLibPublicKey;
-    
-    internal const string MicrosoftVisualStudio                      = "Microsoft.VisualStudio, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string MicrosoftVisualStudioWindowsForms          = "Microsoft.VisualStudio.Windows.Forms, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string VJSharpCodeProvider                        = "VJSharpCodeProvider, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-
-    internal const string ASPBrowserCapsPublicKey                    = "b7bd7678b977bd8f";
-    internal const string ASPBrowserCapsFactory                      = "ASP.BrowserCapsFactory, Version=" + FXAssembly.Version + ", Culture=neutral, PublicKeyToken=" + ASPBrowserCapsPublicKey;
-
-
-    // We do not want these sitting in non-VS specific files.  If you need them,
-    // add this line to sources:  
-    // C_DEFINES=$(C_DEFINES) /DINCLUDE_VSREFS
-    //
-    // M.VS.dll and M.VSDesigner.dll should also be included here, but it
-    // turns out that everyone, from Data, to XSP to Winforms to diagnostics
-    // has thrown some designer-specific code into M.VS.dll or M.VSDesigner.dll.
-    //
-    
-
-
-
-
-
-// #line 157 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\assemblyrefs.cspp"
 
-    // VS Provided Assemblies... we can't strong bind to these, they 
-    // update their assembly versions too often
-    //
-    internal const string MicrosoftVSDesigner                        = "Microsoft.VSDesigner, Version=10.0.0.0, Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string MicrosoftVisualStudioWeb                   = "Microsoft.VisualStudio.Web, Version=10.0.0.0, Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string MicrosoftWebDesign                         = "Microsoft.Web.Design.Client, Version=10.0.0.0, Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string MicrosoftVSDesignerMobile                  = "Microsoft.VSDesigner.Mobile, Version=8.0.0.0, Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    internal const string MicrosoftJScript                           = "Microsoft.JScript, Version=8.0.0.0, Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    
-    //internal const string MicrosoftVSDesigner                        = "Microsoft.VSDesigner, Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;
-    //internal const string MicrosoftJScript                           = "Microsoft.JScript, Culture=neutral, PublicKeyToken=" + MicrosoftPublicKey;   
 }
-#pragma warning restore 436
-// #line 172 "d:\\projectk_2\\src\\ndp\\clr\\src\\bcl.oss\\open\\src\\common\\assemblyrefs.cspp"
diff --git a/src/mscorlib/System.Private.CoreLib.csproj b/src/mscorlib/System.Private.CoreLib.csproj
index fb8f3378f7..af5bb8f62d 100644
--- a/src/mscorlib/System.Private.CoreLib.csproj
+++ b/src/mscorlib/System.Private.CoreLib.csproj
@@ -40,12 +40,10 @@
     <NoWarn>649,3019,414,169,3015</NoWarn>
     <GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
 
-    <BclRewriterModelFile>$(MSBuildThisFileDirectory)model.xml</BclRewriterModelFile>
-
     <SignAssembly>true</SignAssembly>
     <DelaySign>true</DelaySign>
 
-    <DefineConstants>$(DefineConstants);_USE_NLS_PLUS_TABLE;RESOURCE_SATELLITE_CONFIG;INSIDE_CLR;CODE_ANALYSIS_BASELINE</DefineConstants>
+    <DefineConstants>$(DefineConstants);CORECLR;_USE_NLS_PLUS_TABLE;RESOURCE_SATELLITE_CONFIG;INSIDE_CLR;CODE_ANALYSIS_BASELINE</DefineConstants>
   </PropertyGroup>
 
   <!-- Add Serviceable attribute to the project's metadata -->
@@ -116,7 +114,6 @@
     Helper Paths
   -->
   <PropertyGroup>
-    <PostProcessingToolsPath Condition="'$(PostProcessingToolsPath)'==''">$(MSBuildThisFileDirectory)Tools\PostProcessingTools.targets</PostProcessingToolsPath>
     <CommonPath>$(MSBuildThisFileDirectory)Common</CommonPath>
     <BclSourcesRoot>$(MSBuildThisFileDirectory)src</BclSourcesRoot>
     <CoreFxSourcesRoot>$(MSBuildThisFileDirectory)corefx</CoreFxSourcesRoot>
@@ -124,23 +121,10 @@
     <NlpObjDir>$(BclSourcesRoot)\System\Globalization\Tables</NlpObjDir>
   </PropertyGroup>
   
-  <!-- Output paths -->
-  <PropertyGroup>
-    <BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)' == ''">$(RootBinDir)obj</BaseIntermediateOutputPath>
-    <IntermediateOutputPath Condition="'$(IntermediateOutputPath)' == ''">$(BaseIntermediateOutputPath)\$(BuildOS).$(BuildArch).$(Configuration)</IntermediateOutputPath>
-    <OutputPath Condition="'$(OutputPath)' == ''">$(BaseIntermediateOutputPath)\$(BuildOS).$(BuildArch).$(Configuration)</OutputPath>
-    <FinalOutputPath Condition="'$(FinalOutputPath)' == ''">$(BinDir)</FinalOutputPath>
-  </PropertyGroup>
-  
   <!-- Msbuild variables needed to get CoreCLR features to be set properly. -->
   <PropertyGroup>
     <ClrProduct>core_clr</ClrProduct>
     <BuildForCoreSystem>true</BuildForCoreSystem>
-    
-    <!-- These are needed by BCLRewriter -->
-    <_BuildType Condition="'$(Configuration)' == 'Debug'">chk</_BuildType>
-    <_BuildType Condition="'$(Configuration)' == 'Checked'">chk</_BuildType>
-    <_BuildType Condition="'$(Configuration)' == 'Release'">ret</_BuildType>
 
     <!-- These are needed to make sure we have the right set of defines -->
     <TargetArch Condition="'$(Platform)'=='x86'">i386</TargetArch>
@@ -152,7 +136,1076 @@
   <Import Project="$(MSBuildThisFileDirectory)..\..\clr.defines.targets" />
 
   <!-- Sources -->
-  <Import Project="$(MSBuildThisFileDirectory)\mscorlib.shared.sources.props" />
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\AccessedThroughPropertyAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\RuntimeHelpers.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\CompilerGeneratedAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\CustomConstantAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\DateTimeConstantAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\DiscardableAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\DecimalConstantAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\DisablePrivateReflectionAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\CompilationRelaxations.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\CompilerGlobalScopeAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\ExtensionAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\FormattableStringFactory.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\FixedBufferAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\IndexerNameAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\InternalsVisibleToAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\IsVolatile.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\MethodImplAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\FixedAddressValueTypeAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\UnsafeValueTypeAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\AssemblySettingAttributes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\TypeDependencyAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\CompilerMarshalOverride.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\jithelpers.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\Unsafe.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\SpecialNameAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\SuppressMergeCheckAttribute.cs" />
+    <MscorlibSources Condition="'$(FeatureICastable)' == 'true'" Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\ICastable.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\SuppressIldasmAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\TypeForwardedToAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\TypeForwardedFromAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\ReferenceAssemblyAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\RuntimeCompatibilityAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\RuntimeWrappedException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\ConditionalWeakTable.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\CallerFilePathAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\CallerLineNumberAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\CallerMemberNameAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\StateMachineAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\IteratorStateMachineAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\AsyncStateMachineAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\AsyncMethodBuilder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\IAsyncStateMachine.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\INotifyCompletion.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\TaskAwaiter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\YieldAwaitable.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\Reliability\CriticalFinalizerObject.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\Reliability\ReliabilityContractAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\Reliability\PrePrepareMethodAttribute.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\MemoryFailPoint.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\GcSettings.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\CollectionBase.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\ArrayList.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Comparer.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\CompatibleComparer.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\ListDictionaryInternal.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\EmptyReadOnlyDictionaryInternal.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Hashtable.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\DictionaryEntry.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\ICollection.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\IComparer.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\IDictionary.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\IDictionaryEnumerator.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\IEnumerable.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\IEnumerator.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\IEqualityComparer.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\IHashCodeProvider.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\IList.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\IStructuralEquatable.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\IStructuralComparable.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\StructuralComparisons.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ComponentModel\EditorBrowsableAttribute.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ArrayWithOffset.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\Attributes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\CallingConvention.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\CharSet.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\COMException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\CriticalHandle.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ExternalException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\GcHandle.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\GCHandleCookieTable.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\HandleRef.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ICustomMarshaler.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\InvalidOleVariantTypeException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\LayoutKind.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\Marshal.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\MarshalDirectiveException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\PInvokeMap.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\RuntimeEnvironment.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\SEHException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\SafeBuffer.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\SafeHandle.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\BStrWrapper.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\CurrencyWrapper.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ErrorWrapper.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\UnknownWrapper.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\VariantWrapper.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComMemberType.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ICustomAdapter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ICustomQueryInterface.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\InvalidComObjectException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\SafeArrayRankMismatchException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\SafeArrayTypeMismatchException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\NativeCallableAttribute.cs" />
+    <MscorlibSources Condition="'$(FeatureCominterop)' != 'true'" Include="$(BclSourcesRoot)\System\Runtime\InteropServices\NonPortable.cs" />
+    <MscorlibSources Condition="'$(FeatureCominterop)' == 'true'" Include="$(BclSourcesRoot)\System\Runtime\InteropServices\DispatchWrapper.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ICustomFactory.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Runtime\InteropServices\StringBuffer.cs" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(FeatureClassicCominterop)' == 'true'">
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ITypeLibConverter.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\Expando\IExpando.cs" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(FeatureClassicCominterop)' == 'true'">
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComEventsHelper.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComEventsInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComEventsMethod.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComEventsSink.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\NativeMethods.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IBindCtx.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IConnectionPointContainer.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IConnectionPoint.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IEnumMoniker.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IEnumConnections.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IEnumConnectionPoints.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IEnumString.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IEnumVARIANT.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IMoniker.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IPersistFile.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IRunningObjectTable.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IStream.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\ITypeComp.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\ITypeInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\ITypeLib.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\ITypeLib2.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\ITypeInfo2.cs" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(FeatureCominterop)' == 'true'">
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\Attributes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\ConstantSplittableMap.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\DictionaryKeyCollection.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\DictionaryValueCollection.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\EnumeratorToIteratorAdapter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\VectorToListAdapter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\VectorToCollectionAdapter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\VectorViewToReadOnlyCollectionAdapter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\MapToDictionaryAdapter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\MapToCollectionAdapter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\MapViewToReadOnlyCollectionAdapter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\ListToVectorAdapter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\DictionaryToMapAdapter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\BindableVectorToListAdapter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\BindableVectorToCollectionAdapter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\ListToBindableVectorAdapter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\ListToBindableVectorViewAdapter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\EventRegistrationToken.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\EventRegistrationTokenTable.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IActivationFactory.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IRestrictedErrorInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IMapViewToIReadOnlyDictionaryAdapter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IVectorViewToIReadOnlyListAdapter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IReadOnlyDictionaryToIMapViewAdapter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IReadOnlyListToIVectorViewAdapter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IteratorToEnumeratorAdapter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\ManagedActivationFactory.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\NativeMethods.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\PropertyValue.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\WindowsRuntimeMarshal.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\WindowsRuntimeMetadata.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IClosable.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\RuntimeClass.cs" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(FeatureCominterop)' == 'true'">
+    <MscorlibSources Include='$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\CLRIPropertyValueImpl.cs' />
+    <MscorlibSources Include='$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\CLRIReferenceImpl.cs' />
+    <MscorlibSources Include='$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IPropertyValue.cs' />
+    <MscorlibSources Include='$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IReference.cs' />
+    <MscorlibSources Include='$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\WindowsFoundationEventHandler.cs' />
+    <MscorlibSources Include='$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\ICustomPropertyProvider.cs' />
+    <MscorlibSources Include='$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\ICustomProperty.cs' />
+    <MscorlibSources Include='$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\CustomPropertyImpl.cs' />
+    <MscorlibSources Include='$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\WindowsRuntimeBufferHelper.cs' />
+  </ItemGroup>
+  <ItemGroup Condition="'$(FeatureCominterop)' == 'true'">
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IIterable.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IIterator.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IVector.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IMap.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\CLRIKeyValuePairImpl.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\AggregateException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\AppContext\AppContext.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\AppContext\AppContextSwitches.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\AppContext\AppContextDefaultValues.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\AppContext\AppContextDefaultValues.CoreClrOverrides.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\AppContext\AppContextDefaultValues.Defaults.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\AppContext\AppContextDefaultValues.Defaults.Central.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\CurrentTimeZone.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\TimeZone.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Object.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ICloneable.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Action.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Array.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ArraySegment.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IComparable.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IEquatable.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ThrowHelper.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Tuple.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\String.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\String.Comparison.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\String.Manipulation.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\String.Searching.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\StringComparer.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\StringComparison.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\StringSplitOptions.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\StringBuilder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\StringBuilderCache.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Exception.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\FormattableString.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\DateTime.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\DateTimeKind.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\DateTimeOffset.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\SystemException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\OutOfMemoryException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\StackOverflowException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\DataMisalignedException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ExecutionEngineException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Delegate.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\MulticastDelegate.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\__Filters.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\__HResults.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\BCLDebug.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\MemberAccessException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Activator.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\AccessViolationException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ApplicationException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\AppDomain.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\AppDomainSetup.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\AppDomainManager.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IAppDomainPauseManager.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\AppDomainAttributes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\AppDomainUnloadedException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ArgumentException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ArgumentNullException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ArgumentOutOfRangeException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ArgIterator.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ArithmeticException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ArrayTypeMismatchException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\AsyncCallback.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Attribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\AttributeTargets.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\AttributeUsageAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\BadImageFormatException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\BitConverter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Boolean.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Buffer.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Byte.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Char.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\CharEnumerator.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\CLSCompliantAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\TypeUnloadedException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\CompatibilitySwitches.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\LowLevelConsole.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Convert.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\StringFreezingAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Currency.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\DayOfWeek.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\DBNull.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Decimal.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\DefaultBinder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\DelegateSerializationHolder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\DivideByZeroException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Double.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\DuplicateWaitObjectException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Empty.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Enum.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\EntryPointNotFoundException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\DllNotFoundException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Environment.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\EventArgs.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\EventHandler.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\FieldAccessException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\FlagsAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\FormatException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\GC.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Guid.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IAsyncResult.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ICustomFormatter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IDisposable.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IFormatProvider.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IFormattable.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IndexOutOfRangeException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IObservable.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IObserver.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IProgress.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\InsufficientMemoryException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\InsufficientExecutionStackException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Lazy.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Int16.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Int32.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Int64.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IntPtr.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Internal.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\InvalidCastException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\InvalidOperationException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\InvalidProgramException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\InvalidTimeZoneException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IConvertible.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IServiceObjectProvider.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\MarshalByRefObject.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Math.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\MathF.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\mda.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\MethodAccessException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\MidpointRounding.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\MissingFieldException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\MissingMemberException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\MissingMethodException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\MulticastNotSupportedException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\NonSerializedAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\NotFiniteNumberException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\NotImplementedException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\NotSupportedException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\NullReferenceException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Number.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ObjectDisposedException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ObsoleteAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\OperatingSystem.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\OperationCanceledException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\OverflowException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ParamArrayAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ParamsArray.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ParseNumbers.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\PlatformID.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\PlatformNotSupportedException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Progress.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Random.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\RankException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ResId.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\RtType.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\RuntimeArgumentHandle.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\RuntimeHandles.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\SByte.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\SerializableAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\SharedStatics.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Single.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\StubHelpers.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ThreadAttributes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\TimeoutException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\TimeSpan.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\TimeZoneInfo.AdjustmentRule.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\TimeZoneInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\TimeZoneInfo.StringSerializer.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\TimeZoneInfo.TransitionTime.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\TimeZoneNotFoundException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Type.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\TypeAccessException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\TypeNameParser.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\TypeCode.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\TypedReference.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\TypeInitializationException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\TypeLoadException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\UInt16.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\UInt32.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\UInt64.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\UIntPtr.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\UnauthorizedAccessException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\UnitySerializationHolder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\UnhandledExceptionEventArgs.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\UnhandledExceptionEventHandler.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ValueType.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Version.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Void.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\WeakReference.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\WeakReferenceOfT.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\XmlIgnoreMemberAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\CLRConfig.cs" />
+    <MscorlibSources Condition="'$(FeatureCominterop)' == 'true'" Include="$(BclSourcesRoot)\System\__ComObject.cs" />
+    <MscorlibSources Condition="'$(FeatureCominterop)' == 'true'" Include="$(BclSourcesRoot)\System\Variant.cs" />
+    <MscorlibSources Condition="'$(FeatureClassicCominterop)' == 'true'" Include="$(BclSourcesRoot)\System\OleAutBinder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ByReference.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Span.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ReadOnlySpan.cs" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetsUnix)' == 'true'">
+    <MscorlibSources Include="$(BclSourcesRoot)\System\TimeZoneInfo.Unix.cs" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetsUnix)' != 'true'">
+    <MscorlibSources Include="$(BclSourcesRoot)\System\TimeZoneInfo.Win32.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\Internal\Runtime\Augments\EnvironmentAugments.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\Internal\Runtime\Augments\RuntimeThread.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\__Filters.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\AmbiguousMatchException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Assembly.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\AssemblyAttributes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\AssemblyName.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\AssemblyNameFlags.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Associates.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\CustomAttributeExtensions.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\CustomAttributeFormatException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Binder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\BindingFlags.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\CallingConventions.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\ConstructorInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\CustomAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\DefaultMemberAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\EventAttributes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\EventInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\FieldAttributes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\FieldInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\GenericParameterAttributes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\ICustomAttributeProvider.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\IReflectableType.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\IntrospectionExtensions.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\RuntimeReflectionExtensions.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\InterfaceMapping.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\InvalidFilterCriteriaException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\IReflect.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\LoaderAllocator.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\ManifestResourceInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\MdConstant.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\MdImport.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\MemberFilter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\MemberInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\MemberInfoSerializationHolder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\MemberTypes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\MethodAttributes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\MethodBase.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\MethodImplAttributes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\MethodInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Missing.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Module.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\ObfuscateAssemblyAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\ObfuscationAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\MethodBody.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\ParameterAttributes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\ParameterInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\ParameterModifier.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Pointer.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\PropertyAttributes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\PropertyInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\ReflectionContext.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\ReflectionTypeLoadException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\ResourceAttributes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\StrongNameKeyPair.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\TargetException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\TargetInvocationException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\TargetParameterCountException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\TypeAttributes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\TypeDelegator.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\TypeFilter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\TypeInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\AssemblyBuilder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\AssemblyBuilderData.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\AssemblyBuilderAccess.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\AQNBuilder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\ConstructorBuilder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\DynamicILGenerator.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\DynamicMethod.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\EventBuilder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\EventToken.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\FieldBuilder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\FieldToken.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\ILGenerator.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\ISymWrapperCore.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\Label.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\LocalBuilder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\MethodBuilder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\MethodBuilderInstantiation.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\SymbolType.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\SymbolMethod.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\CustomAttributeBuilder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\MethodToken.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\ModuleBuilder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\ModuleBuilderData.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\PEFileKinds.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\OpCodes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\Opcode.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\OpcodeType.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\StackBehaviour.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\OperandType.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\FlowControl.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\ParameterBuilder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\ParameterToken.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\PropertyBuilder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\PropertyToken.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\SignatureHelper.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\SignatureToken.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\StringToken.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\TypeBuilder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\TypeBuilderInstantiation.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\GenericTypeParameterBuilder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\EnumBuilder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\TypeToken.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Emit\XXXOnTypeBuilderInstantiation.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Reflection\Metadata\AssemblyExtensions.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\DateTimeFormat.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\DateTimeParse.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\DateTimeStyles.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\NumberStyles.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\TimeSpanFormat.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\TimeSpanParse.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\DaylightTime.cs" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(FeatureCoreFxGlobalization)' != 'true'">
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\BidiCategory.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\Calendar.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\CalendarData.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\CalendarAlgorithmType.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\CalendarWeekRule.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\CalendricalCalculationsHelper.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\CharUnicodeInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\CompareInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\CultureInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\CultureNotFoundException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\CultureTypes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\DateTimeFormatInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\DateTimeFormatInfoScanner.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\DigitShapes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\EncodingDataItem.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\EncodingTable.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\GlobalizationAssembly.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\GregorianCalendar.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\GregorianCalendarTypes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\GregorianCalendarHelper.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\HebrewCalendar.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\HijriCalendar.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\UmAlQuraCalendar.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\PersianCalendar.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\IdnMapping.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\JapaneseCalendar.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\KoreanCalendar.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\RegionInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\SortKey.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\SortVersion.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\StringInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\TaiwanCalendar.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\TextElementEnumerator.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\TextInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\ThaiBuddhistCalendar.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\TimeSpanStyles.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\NumberFormatInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\UnicodeCategory.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\CultureData.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\HebrewNumber.cs" />
+    <MscorlibSources Condition="'$(FeatureOnlyCoreCalendars)'==''" Include="$(BclSourcesRoot)\System\Globalization\ChineseLunisolarCalendar.cs" />
+    <MscorlibSources Condition="'$(FeatureOnlyCoreCalendars)'==''" Include="$(BclSourcesRoot)\System\Globalization\EastAsianLunisolarCalendar.cs" />
+    <MscorlibSources Condition="'$(FeatureOnlyCoreCalendars)'==''" Include="$(BclSourcesRoot)\System\Globalization\JapaneseLunisolarCalendar.cs" />
+    <MscorlibSources Condition="'$(FeatureOnlyCoreCalendars)'==''" Include="$(BclSourcesRoot)\System\Globalization\JulianCalendar.cs" />
+    <MscorlibSources Condition="'$(FeatureOnlyCoreCalendars)'==''" Include="$(BclSourcesRoot)\System\Globalization\KoreanLunisolarCalendar.cs" />
+    <MscorlibSources Condition="'$(FeatureOnlyCoreCalendars)'==''" Include="$(BclSourcesRoot)\System\Globalization\TaiwanLunisolarCalendar.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\SR.cs" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(FeatureCoreFxGlobalization)' == 'true'">
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\Calendar.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\CalendarAlgorithmType.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\CalendarData.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\CalendarWeekRule.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\CalendricalCalculationsHelper.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\CharUnicodeInfo.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\CharUnicodeInfoData.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\ChineseLunisolarCalendar.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\CompareInfo.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\CultureData.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\CultureInfo.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\CultureTypes.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\CultureNotFoundException.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\DateTimeFormatInfo.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\DateTimeFormatInfoScanner.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\EastAsianLunisolarCalendar.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\GregorianCalendar.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\GregorianCalendarHelper.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\GregorianCalendarTypes.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\HebrewCalendar.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\HebrewNumber.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\HijriCalendar.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\IdnMapping.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\InternalGlobalizationHelper.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\JapaneseCalendar.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\JapaneseLunisolarCalendar.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\JulianCalendar.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\KoreanCalendar.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\KoreanLunisolarCalendar.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\NumberFormatInfo.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\PersianCalendar.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\RegionInfo.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\SortKey.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\SortVersion.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\StringInfo.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\TaiwanCalendar.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\TaiwanLunisolarCalendar.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\TextElementEnumerator.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\TextInfo.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\ThaiBuddhistCalendar.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\TimeSpanStyles.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\UmAlQuraCalendar.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\UnicodeCategory.cs " /> 
+  </ItemGroup>
+  <ItemGroup Condition="'$(FeatureCoreFxGlobalization)' == 'true' and '$(TargetsUnix)' == 'true'">
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\EncodingTable.Unix.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Globalization\EncodingDataItem.Unix.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\Normalization.Unix.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Globalization.Native\Interop.Calendar.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Globalization.Native\Interop.Casing.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Globalization.Native\Interop.Collation.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Globalization.Native\Interop.Idna.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Globalization.Native\Interop.Locale.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Globalization.Native\Interop.Normalization.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Globalization.Native\Interop.ResultCode.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Globalization.Native\Interop.TimeZoneInfo.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Globalization.Native\Interop.Utils.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\CalendarData.Unix.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\CompareInfo.Unix.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\CultureData.Unix.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\CultureInfo.Unix.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\DigitShapes.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\HijriCalendar.Unix.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\IdnMapping.Unix.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\JapaneseCalendar.Unix.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\LocaleData.Unix.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Globalization\TextInfo.Unix.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\AbandonedMutexException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\AsyncLocal.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\AutoResetEvent.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\SendOrPostCallback.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\SynchronizationContext.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\EventResetMode.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\EventWaitHandle.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\ExecutionContext.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Interlocked.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\LockRecursionException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\ManualResetEvent.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Monitor.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Mutex.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Overlapped.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\ParameterizedThreadStart.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Semaphore.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\SemaphoreFullException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\SynchronizationLockException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Thread.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\ThreadAbortException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\ThreadInterruptedException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\ThreadPool.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\ThreadPriority.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\ThreadStart.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\ThreadState.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\ThreadStateException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\ThreadStaticAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\ThreadStartException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Timeout.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Timer.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Volatile.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\WaitHandle.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\WaitHandleCannotBeOpenedException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\ApartmentState.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\SpinLock.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\SpinWait.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\CountdownEvent.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\LazyInitializer.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\ThreadLocal.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\SemaphoreSlim.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\ManualResetEventSlim.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\CancellationTokenRegistration.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\CancellationTokenSource.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\CancellationToken.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Tasks\future.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Tasks\FutureFactory.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Tasks\Task.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Tasks\TaskContinuation.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Tasks\TaskCanceledException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Tasks\TaskSchedulerException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Tasks\TaskExceptionHolder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Tasks\TaskFactory.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Tasks\TaskScheduler.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Tasks\ThreadPoolTaskScheduler.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Tasks\TaskCompletionSource.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Tasks\AsyncCausalityTracer.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Tasks\ConcurrentExclusiveSchedulerPair.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Tasks\ProducerConsumerQueues.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Tasks\TPLETWProvider.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Threading\Tasks\TaskToApm.cs" />
+    <MscorlibSources Condition="'$(FeatureCominterop)' == 'true'" Include="$(BclSourcesRoot)\System\Threading\Tasks\IAsyncCausalityTracerStatics.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\IO\FileStream.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\IO\Error.cs" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetsUnix)' == 'true'">
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Microsoft\Win32\SafeHandles\SafeFileHandle.Unix.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\IO\FileStream.Unix.cs" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetsUnix)' != 'true'">
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Microsoft\Win32\SafeHandles\SafeFileHandle.Windows.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\IO\FileStream.Win32.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\IO\FileStreamCompletionSource.Win32.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\IO\Win32Marshal.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\IO\Path.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\IO\PathInternal.cs" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetsUnix)' == 'true'">
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\IO\Path.Unix.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\IO\PathInternal.Unix.cs" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetsUnix)' != 'true'">
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\IO\Path.Win32.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\IO\Path.Windows.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\IO\PathHelper.Windows.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\IO\PathInternal.Windows.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\IO\PathInternal.Windows.StringBuffer.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Threading\DeferredDisposableLifetime.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Threading\ClrThreadPoolBoundHandle.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Threading\ClrThreadPoolBoundHandleOverlapped.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Threading\ClrThreadPoolPreAllocatedOverlapped.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\__Error.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\__HResults.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\BinaryReader.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\BinaryWriter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\Directory.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\SearchOption.cs" />    
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\DirectoryNotFoundException.cs" />  
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\DriveNotFoundException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\EncodingCache.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\EndOfStreamException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\File.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\FileAccess.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\FileLoadException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\FileMode.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\FileNotFoundException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\FileOptions.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\FileShare.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\FileSystemEnumerable.cs" Condition="'$(TargetsUnix)' == 'true'" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\IOException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\MemoryStream.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\PathTooLongException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\PinnedBufferMemoryStream.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\SeekOrigin.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\Stream.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\StreamHelpers.CopyValidation.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\TextReader.cs" Condition="'$(TargetsUnix)' == 'true'" />    
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\StreamReader.cs" Condition="'$(TargetsUnix)' == 'true'" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\UnmanagedMemoryAccessor.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\UnmanagedMemoryStream.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\IO\UnmanagedMemoryStreamWrapper.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Security\Attributes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Security\SecurityException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Security\SecurityState.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Security\VerificationException.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Security\Util\URLString.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Assert.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\AssertFilter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\AssertFilters.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\ConditionalAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Debugger.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\DebuggerAttributes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\ICustomDebuggerNotification.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\log.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\LoggingLevels.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\LogSwitch.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Stacktrace.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Stackframe.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\EditAndContinueHelper.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\ActivityTracker.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\EventActivityOptions.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\EventDescriptor.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\EventProvider.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\EventSource.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\EventSource_CoreCLR.cs" />
+    <MscorlibSources Condition="'$(FeatureXplatEventSource)' == 'true'" Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\XplatEventLogger.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\EventSourceException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\FrameworkEventSource.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\StubEnvironment.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\Winmeta.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\ArrayTypeInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\ConcurrentSet.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\ConcurrentSetItem.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\DataCollector.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\EmptyStruct.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\EnumerableTypeInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\EnumHelper.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\EventDataAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\EventFieldAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\EventFieldFormat.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\EventIgnoreAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\EventPayload.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\EventSourceOptions.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\FieldMetadata.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\InvokeTypeInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\NameInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\PropertyValue.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\PropertyAnalysis.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\SimpleEventTypes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\SimpleTypeInfos.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\Statics.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\TraceLoggingDataCollector.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\TraceLoggingDataType.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\TraceLoggingEventSource.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\TraceLoggingEventTraits.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\TraceLoggingEventTypes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\TraceLoggingMetadataCollector.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\TraceLoggingTypeInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\TypeAnalysis.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\CodeAnalysis\SuppressMessageAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Contracts\Contracts.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\Contracts\ContractsBCL.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\SymbolStore\ISymDocumentWriter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\SymbolStore\ISymWriter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\SymbolStore\SymAddressKind.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Diagnostics\SymbolStore\Token.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\ExceptionServices\CorruptingExceptionCommon.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\ExceptionServices\ExceptionServicesCommon.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\ExceptionServices\ExceptionNotification.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\Loader\AssemblyLoadContext.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\FormatterConverter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\FormatterServices.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\IDeserializationCallback.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\IFormatterConverter.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\IObjectReference.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\ISerializable.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\SerializationAttributes.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\SerializationException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\SerializationInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\SerializationInfoEnumerator.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\StreamingContext.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\SafeSerializationManager.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\Versioning\TargetFrameworkAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\Versioning\CompatibilitySwitch.cs" Condition="'$(TargetsUnix)' == 'true'" />   
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\Versioning\NonVersionableAttribute.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Configuration\Assemblies\AssemblyHashAlgorithm.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Configuration\Assemblies\AssemblyVersionCompatibility.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Runtime\Remoting\ObjectHandle.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\ASCIIEncoding.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\Decoder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\DecoderNLS.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\DecoderBestFitFallback.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\DecoderExceptionFallback.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\DecoderFallback.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\DecoderReplacementFallback.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\Encoder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\EncoderNLS.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\EncoderBestFitFallback.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\EncoderExceptionFallback.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\EncoderFallback.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\EncoderReplacementFallback.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\Encoding.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\EncodingForwarder.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\EncodingInfo.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\EncodingNLS.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\EncodingProvider.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\Latin1Encoding.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\Normalization.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\Normalization.Windows.cs" Condition="'$(TargetsUnix)' != 'true'"/>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\UnicodeEncoding.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\UTF7Encoding.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\UTF8Encoding.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Text\UTF32Encoding.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\Microsoft\Win32\UnsafeNativeMethods.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\Microsoft\Win32\Win32Native.cs" />
+    <MscorlibSources Condition="'$(FeatureWin32Registry)' == 'true'" Include="$(BclSourcesRoot)\Microsoft\Win32\Registry.cs" />
+    <MscorlibSources Condition="'$(FeatureWin32Registry)' == 'true'" Include="$(BclSourcesRoot)\Microsoft\Win32\RegistryKey.cs" />
+    <MscorlibSources Condition="'$(FeatureWin32Registry)' == 'true'" Include="$(BclSourcesRoot)\Microsoft\Win32\RegistryValueKind.cs" />
+    <MscorlibSources Condition="'$(FeatureWin32Registry)' == 'true'" Include="$(BclSourcesRoot)\Microsoft\Win32\RegistryView.cs" />
+    <MscorlibSources Condition="'$(FeatureClassicCominterop)' == 'true'" Include="$(BclSourcesRoot)\Microsoft\Win32\OAVariantLib.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Resources\__FastResourceComparer.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Resources\__HResults.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Resources\FileBasedResourceGroveler.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Resources\IResourceGroveler.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Resources\IResourceReader.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Resources\LooselyLinkedResourceReference.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Resources\ManifestBasedResourceGroveler.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Resources\MissingManifestResourceException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Resources\MissingSatelliteAssemblyException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Resources\NeutralResourcesLanguageAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Resources\ResourceFallbackManager.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Resources\ResourceManager.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Resources\ResourceReader.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Resources\ResourceSet.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Resources\ResourceTypeCode.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Resources\RuntimeResourceSet.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Resources\SatelliteContractVersionAttribute.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Resources\UltimateResourceFallbackLocation.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Nullable.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Generic\Comparer.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Generic\Dictionary.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Generic\EqualityComparer.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Generic\DebugView.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Generic\ICollection.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Generic\IComparer.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Generic\IDictionary.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Generic\IEnumerable.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Generic\IEnumerator.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Generic\IEqualityComparer.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Generic\IList.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Generic\IReadOnlyCollection.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Generic\IReadOnlyList.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Generic\IReadOnlyDictionary.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Generic\KeyNotFoundException.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Generic\KeyValuePair.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Generic\List.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Generic\ArraySortHelper.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\ObjectModel\Collection.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\ObjectModel\ReadOnlyCollection.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\ObjectModel\ReadOnlyDictionary.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\ObjectModel\KeyedCollection.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Concurrent\ConcurrentStack.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Concurrent\IProducerConsumerCollection.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Concurrent\ConcurrentDictionary.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Collections\Concurrent\ConcurrentQueue.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\Microsoft\Win32\SafeHandles\SafeFindHandle.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\Microsoft\Win32\SafeHandles\SafeLibraryHandle.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\Microsoft\Win32\SafeHandles\SafeWaitHandle.cs" />
+    <MscorlibSources Include="$(BclSourcesRoot)\Microsoft\Win32\SafeHandles\Win32SafeHandles.cs" />
+    <MscorlibSources Condition="'$(FeatureWin32Registry)' == 'true'" Include="$(BclSourcesRoot)\Microsoft\Win32\SafeHandles\SafeRegistryHandle.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(BclSourcesRoot)\System\Numerics\Hashing\HashHelpers.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Buffers\ArrayPool.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Buffers\ArrayPoolEventSource.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Buffers\ConfigurableArrayPool.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Buffers\TlsOverPerCoreLockedStacksArrayPool.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Buffers\Utilities.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Security\CryptographicException.cs" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetsUnix)' != 'true'">
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\HResults.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\Interop.BOOL.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\Interop.Errors.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\Interop.Libraries.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\BCrypt\Interop.BCryptGenRandom.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\BCrypt\Interop.NTSTATUS.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.CancelIoEx.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.CloseHandle.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.CreateFile.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.FileTypes.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.FileOperations.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.FlushFileBuffers.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.FormatMessage.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.GetFileInformationByHandleEx.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.GetFileType_SafeHandle.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.GetFullPathNameW.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.GetLongPathNameW.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.GetTempFileNameW.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.GetTempPathW.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.LockFile.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.ReadFile_SafeHandle_IntPtr.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.ReadFile_SafeHandle_NativeOverlapped.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.SafeCreateFile.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.SECURITY_ATTRIBUTES.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.SecurityOptions.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.SetEndOfFile.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.SetErrorMode.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.SetFileInformationByHandle.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.SetFilePointerEx.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.UnsafeCreateFile.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.WriteFile_SafeHandle_IntPtr.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.WriteFile_SafeHandle_NativeOverlapped.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Security\SecureString.cs" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetsUnix)' != 'true'">
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Security\SafeBSTRHandle.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Security\SecureString.Windows.cs" />
+    <!-- Interop sources -->
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\Crypt32\Interop.CryptProtectMemory.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\NtDll\Interop.ZeroMemory.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.WideCharToMultiByte.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\oleaut32\Interop.SysAllocStringLen.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Windows\oleaut32\Interop.SysStringLen.cs" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetsUnix)' == 'true'">
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\Security\SecureString.Unix.cs" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetsUnix)' == 'true'">
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\System\HResults.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\Interop.Errors.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\Interop.IOErrors.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\Interop.Libraries.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.Close.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.GetCwd.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.GetUnixName.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.Fcntl.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.FLock.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.FSync.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.FTruncate.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.LSeek.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.MksTemps.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.Open.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.OpenFlags.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.PathConf.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.Permissions.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.PosixFAdvise.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.Read.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.Stat.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.Unlink.cs" />
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.Write.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <MscorlibSources Include="$(CoreFxSourcesRoot)\Debug.cs" />
+  </ItemGroup>
 
   <!-- Include additional sources shared files in the compilation -->
   <ItemGroup>
@@ -164,6 +1217,9 @@
 
     <!-- Include Internals visible to file in the compilation -->
     <MscorlibSources Include="$(BclSourcesRoot)\mscorlib.Friends.cs" />
+
+    <!-- TODO list of types to be cleaned up from CoreLib -->
+    <MscorlibSources Include="$(BclSourcesRoot)\CleanupToDoList.cs" />
   </ItemGroup>
 
   <ItemGroup>
@@ -237,5 +1293,4 @@
 
   <Import Project="GenerateSplitStringResources.targets"/>
   <Import Project="GenerateCompilerResponseFile.targets"/>
-  <Import Project="$(PostProcessingToolsPath)" />
 </Project>
diff --git a/src/mscorlib/System.Private.CoreLib.sln b/src/mscorlib/System.Private.CoreLib.sln
index 60a2316957..4ab28af2d9 100644
--- a/src/mscorlib/System.Private.CoreLib.sln
+++ b/src/mscorlib/System.Private.CoreLib.sln
@@ -5,11 +5,6 @@ VisualStudioVersion = 14.0.25420.1
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Private.CoreLib", "System.Private.CoreLib.csproj", "{3DA06C3A-2E7B-4CB7-80ED-9B12916013F9}"
 EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{E16B1C86-C275-495B-80D6-7CE8196A18B4}"
-	ProjectSection(SolutionItems) = preProject
-		model.xml = model.xml
-	EndProjectSection
-EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Checked|amd64 = Checked|amd64
diff --git a/src/mscorlib/Tools/BclRewriter/BclRewriter.targets b/src/mscorlib/Tools/BclRewriter/BclRewriter.targets
deleted file mode 100644
index 5515b000a7..0000000000
--- a/src/mscorlib/Tools/BclRewriter/BclRewriter.targets
+++ /dev/null
@@ -1,35 +0,0 @@
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
-
-  <!-- ********************************************************************************************* -->
-  <!-- *** Task -->
-  <!-- ********************************************************************************************* -->
-
-  <PropertyGroup>
-    <BclRewriterModelFile Condition="'$(BclRewriterModelFile)'==''">$(MscorlibDir)model.xml</BclRewriterModelFile>
-    <BclRewriterWorkDir>$(IntermediateOutputPath)\BclRewriter</BclRewriterWorkDir>
-    <BclRewriterSymbolOutput>$(IntermediateOutputPath)\BclRewriter\$(TargetName).pdb</BclRewriterSymbolOutput>
-    <BclRewriterOutput>$(IntermediateOutputPath)\BclRewriter\$(TargetName)$(TargetExt)</BclRewriterOutput>
-    <TargetPath>$(BclRewriterOutput)</TargetPath>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <RewrittenAssembly Include="$(BclRewriterOutput)" />
-  </ItemGroup>
-
-  <Target Name="RewriteWithBclRewriter"
-          Inputs="$(BclRewriterModelFile);@(AnnotatedAssembly)" Outputs="@(RewrittenAssembly)" DependsOnTargets="$(BclRewriterDependencyTargets)">
-
-    <PropertyGroup>
-      <OSPlatform Condition="'$(TargetsWindows)' == 'true'">win</OSPlatform>
-      <OSPlatform Condition="'$(TargetsWindows)' != 'true'">unix</OSPlatform>
-      <BclRewriterCommand Condition="'$(BclRewriterCommand)'==''">"$(ToolRuntimePath)dotnetcli/$(ToolHost)" "$(ToolsDir)BclRewriter.exe"</BclRewriterCommand>
-    </PropertyGroup>
-
-    <Exec Command="$(BclRewriterCommand) -in:&quot;@(AnnotatedAssembly)&quot; -out:&quot;$(BclRewriterOutput)&quot; -include:&quot;$(BclRewriterModelFile)&quot; -platform:$(OSPlatform) -architecture:$(Platform) -flavor:$(_BuildType) -removeSerializable- -define:&quot;$(DefineConstants)&quot; -keepTempFiles+" StandardOutputImportance="Normal" />
-
-    <!-- Update the location of the symbol file-->
-    <PropertyGroup>
-      <CurrentAssemblyPdb>$(BclRewriterSymbolOutput)</CurrentAssemblyPdb>
-    </PropertyGroup>
-  </Target>
-</Project>
\ No newline at end of file
diff --git a/src/mscorlib/Tools/PostProcessingTools.targets b/src/mscorlib/Tools/PostProcessingTools.targets
deleted file mode 100644
index 2f48efcecb..0000000000
--- a/src/mscorlib/Tools/PostProcessingTools.targets
+++ /dev/null
@@ -1,28 +0,0 @@
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
-  <Import Project="$(MSBuildThisFileDirectory)\BclRewriter\BclRewriter.targets" />
-
-  <ItemGroup>
-    <AnnotatedAssembly Include="$(IntermediateOutputPath)$(TargetName)$(TargetExt)"/>
-
-    <Clean Include="@(RewrittenAssembly->'$(FinalOutputPath)\%(Filename)%(Extension)')" />
-    <Clean Include="$(FinalOutputPath)\$(TargetName).pdb" />
-  </ItemGroup>
-  
-  <Import Project="$(ToolsDir)toolruntime.targets" />
-
-  <PropertyGroup>
-    <CurrentAssemblyPdb>$(IntermediateOutputPath)$(TargetName).pdb</CurrentAssemblyPdb>
-    <PostProcessingTargets>RewriteWithBclRewriter</PostProcessingTargets>
-    <BclRewriterDependencyTargets>EnsureBuildToolsRuntime</BclRewriterDependencyTargets>
-  </PropertyGroup>
-
-  <Target Name="AfterBuild" DependsOnTargets="$(PostProcessingTargets)"
-          Inputs="@(RewrittenAssembly)" Outputs="$(FinalOutputPath)\%(RewrittenAssembly.FileName)%(RewrittenAssembly.Extension)">
-    
-    <!-- Copy to the final output location -->
-    <Copy Retries="3" SourceFiles="@(RewrittenAssembly)" DestinationFiles="$(FinalOutputPath)\%(RewrittenAssembly.FileName)%(RewrittenAssembly.Extension)"/>
-    <Message Importance="High" Text="$(MSBuildProjectName) -&gt; $(FinalOutputPath)%(RewrittenAssembly.FileName)%(RewrittenAssembly.Extension)" />
-    <Copy Condition="Exists('$(CurrentAssemblyPdb)')" Retries="3" SourceFiles="$(CurrentAssemblyPdb)" DestinationFiles="$(FinalOutputPath)\$(TargetName).pdb"/>
-  </Target>
-
-</Project>
\ No newline at end of file
diff --git a/src/mscorlib/corefx/Interop/Unix/Interop.Libraries.cs b/src/mscorlib/corefx/Interop/Unix/Interop.Libraries.cs
index a11a23ce8c..1b6d26e40f 100644
--- a/src/mscorlib/corefx/Interop/Unix/Interop.Libraries.cs
+++ b/src/mscorlib/corefx/Interop/Unix/Interop.Libraries.cs
@@ -7,12 +7,6 @@ internal static partial class Interop
     private static partial class Libraries
     {
         internal const string GlobalizationInterop = "System.Globalization.Native"; // CoreFX wrappers for ICU
-        // Shims
         internal const string SystemNative = "System.Native";
-        internal const string HttpNative = "System.Net.Http.Native";
-        internal const string NetSecurityNative = "System.Net.Security.Native";
-        internal const string CryptoNative = "System.Security.Cryptography.Native.OpenSsl";
-        internal const string GlobalizationNative = "System.Globalization.Native";
-        internal const string CompressionNative = "System.IO.Compression.Native";
     }
 }
diff --git a/src/mscorlib/corefx/Interop/Unix/System.Globalization.Native/Interop.Casing.cs b/src/mscorlib/corefx/Interop/Unix/System.Globalization.Native/Interop.Casing.cs
index 115a8393be..769506b8f6 100644
--- a/src/mscorlib/corefx/Interop/Unix/System.Globalization.Native/Interop.Casing.cs
+++ b/src/mscorlib/corefx/Interop/Unix/System.Globalization.Native/Interop.Casing.cs
@@ -11,15 +11,12 @@ internal static partial class Interop
 {
     internal static partial class GlobalizationInterop
     {
-        [SecurityCritical]
         [DllImport(Libraries.GlobalizationInterop, CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_ChangeCase")]
         internal unsafe static extern void ChangeCase(char* src, int srcLen, char* dstBuffer, int dstBufferCapacity, bool bToUpper);
 
-        [SecurityCritical]
         [DllImport(Libraries.GlobalizationInterop, CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_ChangeCaseInvariant")]
         internal unsafe static extern void ChangeCaseInvariant(char* src, int srcLen, char* dstBuffer, int dstBufferCapacity, bool bToUpper);
 
-        [SecurityCritical]
         [DllImport(Libraries.GlobalizationInterop, CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_ChangeCaseTurkish")]
         internal unsafe static extern void ChangeCaseTurkish(char* src, int srcLen, char* dstBuffer, int dstBufferCapacity, bool bToUpper);
     }
diff --git a/src/mscorlib/corefx/Interop/Unix/System.Globalization.Native/Interop.Collation.cs b/src/mscorlib/corefx/Interop/Unix/System.Globalization.Native/Interop.Collation.cs
index eb9e0743bc..25585c6dfb 100644
--- a/src/mscorlib/corefx/Interop/Unix/System.Globalization.Native/Interop.Collation.cs
+++ b/src/mscorlib/corefx/Interop/Unix/System.Globalization.Native/Interop.Collation.cs
@@ -11,52 +11,41 @@ internal static partial class Interop
 {
     internal static partial class GlobalizationInterop
     {
-        [SecurityCritical]
         [DllImport(Libraries.GlobalizationInterop, CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_GetSortHandle")]
         internal unsafe static extern ResultCode GetSortHandle(byte[] localeName, out SafeSortHandle sortHandle);
 
-        [SecurityCritical]
         [DllImport(Libraries.GlobalizationInterop, CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_CloseSortHandle")]
         internal unsafe static extern void CloseSortHandle(IntPtr handle);
 
-        [SecurityCritical]
         [DllImport(Libraries.GlobalizationInterop, CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_CompareString")]
         internal unsafe static extern int CompareString(SafeSortHandle sortHandle, char* lpStr1, int cwStr1Len, char* lpStr2, int cwStr2Len, CompareOptions options);
 
-        [SecurityCritical]
         [DllImport(Libraries.GlobalizationInterop, CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_IndexOf")]
         internal unsafe static extern int IndexOf(SafeSortHandle sortHandle, string target, int cwTargetLength, char* pSource, int cwSourceLength, CompareOptions options);
 
-        [SecurityCritical]
         [DllImport(Libraries.GlobalizationInterop, CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_LastIndexOf")]
         internal unsafe static extern int LastIndexOf(SafeSortHandle sortHandle, string target, int cwTargetLength, char* pSource, int cwSourceLength, CompareOptions options);
 
-        [SecurityCritical]
         [DllImport(Libraries.GlobalizationInterop, CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_IndexOfOrdinalIgnoreCase")]
         internal unsafe static extern int IndexOfOrdinalIgnoreCase(string target, int cwTargetLength, char* pSource, int cwSourceLength, bool findLast);
 
-        [SecurityCritical]
         [DllImport(Libraries.GlobalizationInterop, CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_StartsWith")]
         [return: MarshalAs(UnmanagedType.Bool)]
         internal unsafe static extern bool StartsWith(SafeSortHandle sortHandle, string target, int cwTargetLength, string source, int cwSourceLength, CompareOptions options);
 
-        [SecurityCritical]
         [DllImport(Libraries.GlobalizationInterop, CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_EndsWith")]
         [return: MarshalAs(UnmanagedType.Bool)]
         internal unsafe static extern bool EndsWith(SafeSortHandle sortHandle, string target, int cwTargetLength, string source, int cwSourceLength, CompareOptions options);
 
-        [SecurityCritical]
         [DllImport(Libraries.GlobalizationInterop, CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_GetSortKey")]
         internal unsafe static extern int GetSortKey(SafeSortHandle sortHandle, string str, int strLength, byte* sortKey, int sortKeyLength, CompareOptions options);
 
-        [SecurityCritical]
         [DllImport(Libraries.GlobalizationInterop, CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_CompareStringOrdinalIgnoreCase")]
         internal unsafe static extern int CompareStringOrdinalIgnoreCase(char* lpStr1, int cwStr1Len, char* lpStr2, int cwStr2Len);
 
         [DllImport(Libraries.GlobalizationInterop, EntryPoint = "GlobalizationNative_GetSortVersion")]
         internal static extern int GetSortVersion();
 
-        [SecurityCritical]
         internal class SafeSortHandle : SafeHandle
         {
             private SafeSortHandle() :
@@ -66,11 +55,9 @@ internal static partial class Interop
 
             public override bool IsInvalid
             {
-                [SecurityCritical]
                 get { return handle == IntPtr.Zero; }
             }
 
-            [SecurityCritical]
             protected override bool ReleaseHandle()
             {
                 CloseSortHandle(handle);
diff --git a/src/mscorlib/corefx/Interop/Windows/Interop.Libraries.cs b/src/mscorlib/corefx/Interop/Windows/Interop.Libraries.cs
index 1165a2da95..f19f9dcf52 100644
--- a/src/mscorlib/corefx/Interop/Windows/Interop.Libraries.cs
+++ b/src/mscorlib/corefx/Interop/Windows/Interop.Libraries.cs
@@ -6,77 +6,10 @@ internal static partial class Interop
 {
     internal static class Libraries
     {
-        internal const string Advapi32 = "advapi32.dll";
         internal const string BCrypt = "BCrypt.dll";
-        internal const string Combase = "combase.dll";
-        internal const string Console_L1 = "api-ms-win-core-console-l1-1-0.dll";
-        internal const string Console_L2 = "api-ms-win-core-console-l2-1-0.dll";
-        internal const string CoreFile_L1 = "api-ms-win-core-file-l1-1-0.dll";
-        internal const string CoreFile_L1_2 = "api-ms-win-core-file-l1-2-0.dll";
-        internal const string CoreFile_L2 = "api-ms-win-core-file-l2-1-0.dll";
         internal const string Crypt32 = "crypt32.dll";
-        internal const string Debug = "api-ms-win-core-debug-l1-1-0.dll";
-        internal const string Error_L1 = "api-ms-win-core-winrt-error-l1-1-0.dll";
-        internal const string ErrorHandling = "api-ms-win-core-errorhandling-l1-1-0.dll";
-        internal const string Eventing = "api-ms-win-eventing-provider-l1-1-0.dll";
-        internal const string Handle = "api-ms-win-core-handle-l1-1-0.dll";
-        internal const string Heap = "api-ms-win-core-heap-obsolete-l1-1-0.dll";
-        internal const string Heap_L1 = "api-ms-win-core-heap-l1-1-0.dll";
-        internal const string IO = "api-ms-win-core-io-l1-1-0.dll";
-        internal const string IpHlpApi = "iphlpapi.dll";
         internal const string Kernel32 = "kernel32.dll";
-        internal const string Kernel32_L1 = "api-ms-win-core-kernel32-legacy-l1-1-1.dll";
-        internal const string Kernel32_L2 = "api-ms-win-core-kernel32-legacy-l1-1-0.dll";
-        internal const string Keyboard = "ext-ms-win-ntuser-keyboard-l1-2-1.dll";
-        internal const string LibraryLoader = "api-ms-win-core-libraryloader-l1-1-0.dll";
-        internal const string Localization = "api-ms-win-core-localization-l1-2-0.dll";
-        internal const string Memory_L1_0 = "api-ms-win-core-memory-l1-1-0.dll";
-        internal const string Memory_L1_1 = "api-ms-win-core-memory-l1-1-1.dll";
-        internal const string Memory_L1_2 = "api-ms-win-core-memory-l1-1-2.dll";
-        internal const string Memory_L1_3 = "api-ms-win-core-memory-l1-1-3.dll";
-        internal const string NCrypt = "ncrypt.dll";
         internal const string NtDll = "ntdll.dll";
         internal const string OleAut32 = "oleaut32.dll";
-        internal const string Pipe = "api-ms-win-core-namedpipe-l1-1-0.dll";
-        internal const string Pipe_L2 = "api-ms-win-core-namedpipe-l1-2-1.dll";
-        internal const string ProcessEnvironment = "api-ms-win-core-processenvironment-l1-1-0.dll";
-        internal const string ProcessThread_L1 = "api-ms-win-core-processthreads-l1-1-0.dll";
-        internal const string ProcessThread_L1_1 = "api-ms-win-core-processthreads-l1-1-1.dll";
-        internal const string ProcessThread_L1_2 = "api-ms-win-core-processthreads-l1-1-2.dll";
-        internal const string ProcessTopology = "api-ms-win-core-processtopology-obsolete-l1-1-0.dll";
-        internal const string Profile = "api-ms-win-core-profile-l1-1-0.dll";
-        internal const string Psapi = "api-ms-win-core-psapi-l1-1-0.dll";
-        internal const string Psapi_Obsolete = "api-ms-win-core-psapi-obsolete-l1-1-0.dll";
-        internal const string Registry_L1 = "api-ms-win-core-registry-l1-1-0.dll";
-        internal const string Registry_L2 = "api-ms-win-core-registry-l2-1-0.dll";
-        internal const string RoBuffer = "api-ms-win-core-winrt-robuffer-l1-1-0.dll";
-        internal const string SecurityBase = "api-ms-win-security-base-l1-1-0.dll";
-        internal const string SecurityCpwl = "api-ms-win-security-cpwl-l1-1-0.dll";
-        internal const string SecurityCryptoApi = "api-ms-win-security-cryptoapi-l1-1-0.dll";
-        internal const string SecurityLsa = "api-ms-win-security-lsalookup-l2-1-0.dll";
-        internal const string SecurityLsaPolicy = "api-ms-win-security-lsapolicy-l1-1-0.dll";
-        internal const string SecurityProvider = "api-ms-win-security-provider-l1-1-0.dll";
-        internal const string SecuritySddl = "api-ms-win-security-sddl-l1-1-0.dll";
-        internal const string ServiceCore = "api-ms-win-service-core-l1-1-1.dll";
-        internal const string ServiceMgmt_L1 = "api-ms-win-service-management-l1-1-0.dll";
-        internal const string ServiceMgmt_L2 = "api-ms-win-service-management-l2-1-0.dll";
-        internal const string ServiceWinSvc = "api-ms-win-service-winsvc-l1-1-0.dll";
-        internal const string Shell = "shell32.dll";
-        internal const string ShellFolders = "ext-ms-win-shell32-shellfolders-l1-1-0.dll";
-        internal const string Sspi = "sspicli.dll";
-        internal const string String_L1 = "api-ms-win-core-string-l1-1-0.dll";
-        internal const string Synch = "api-ms-win-core-synch-l1-1-0.dll";
-        internal const string SystemInfo_L1_1 = "api-ms-win-core-sysinfo-l1-1-0.dll";
-        internal const string SystemInfo_L1_2 = "api-ms-win-core-sysinfo-l1-2-0.dll";
-        internal const string SystemInfo_L2_1 = "api-ms-win-core-sysinfo-l2-1-0.dll";
-        internal const string ThreadPool = "api-ms-win-core-threadpool-l1-2-0.dll";
-        internal const string User32 = "user32.dll";
-        internal const string Util = "api-ms-win-core-util-l1-1-0.dll";
-        internal const string Version = "api-ms-win-core-version-l1-1-0.dll";
-        internal const string WinHttp = "winhttp.dll";
-        internal const string Winsock = "Ws2_32.dll";
-        internal const string Wow64 = "api-ms-win-core-wow64-l1-1-0.dll";
-        internal const string Ws2_32 = "ws2_32.dll";
-        internal const string Zlib = "clrcompression.dll";
     }
 }
diff --git a/src/mscorlib/corefx/Interop/Windows/NtDll/Interop.ZeroMemory.cs b/src/mscorlib/corefx/Interop/Windows/NtDll/Interop.ZeroMemory.cs
index caa0329bd0..bd2a64cf14 100644
--- a/src/mscorlib/corefx/Interop/Windows/NtDll/Interop.ZeroMemory.cs
+++ b/src/mscorlib/corefx/Interop/Windows/NtDll/Interop.ZeroMemory.cs
@@ -10,8 +10,6 @@ internal partial class Interop
 {
     internal partial class NtDll
     {
-        [DllImport(Libraries.NtDll, CharSet = CharSet.Unicode, EntryPoint = "RtlZeroMemory")]
-        internal static extern void ZeroMemory(SafeBSTRHandle address, uint length);
 
         [DllImport(Libraries.NtDll, CharSet = CharSet.Unicode, EntryPoint = "RtlZeroMemory")]
         internal static extern void ZeroMemory(IntPtr address, UIntPtr length);
diff --git a/src/mscorlib/corefx/Interop/Windows/kernel32/Interop.FileOperations.cs b/src/mscorlib/corefx/Interop/Windows/kernel32/Interop.FileOperations.cs
index a24a0ba069..6e3ebb9ae9 100644
--- a/src/mscorlib/corefx/Interop/Windows/kernel32/Interop.FileOperations.cs
+++ b/src/mscorlib/corefx/Interop/Windows/kernel32/Interop.FileOperations.cs
@@ -6,29 +6,6 @@ internal partial class Interop
 {
     internal partial class Kernel32
     {
-        internal partial class IOReparseOptions
-        {
-            internal const uint IO_REPARSE_TAG_FILE_PLACEHOLDER = 0x80000015;
-            internal const uint IO_REPARSE_TAG_MOUNT_POINT = 0xA0000003;
-        }
-
-        internal partial class FileOperations
-        {
-            internal const int OPEN_EXISTING = 3;
-            internal const int COPY_FILE_FAIL_IF_EXISTS = 0x00000001;
-
-            internal const int FILE_ACTION_ADDED = 1;
-            internal const int FILE_ACTION_REMOVED = 2;
-            internal const int FILE_ACTION_MODIFIED = 3;
-            internal const int FILE_ACTION_RENAMED_OLD_NAME = 4;
-            internal const int FILE_ACTION_RENAMED_NEW_NAME = 5;
-
-            internal const int FILE_FLAG_BACKUP_SEMANTICS = 0x02000000;
-            internal const int FILE_FLAG_FIRST_PIPE_INSTANCE = 0x00080000;
-            internal const int FILE_FLAG_OVERLAPPED = 0x40000000;
-
-            internal const int FILE_LIST_DIRECTORY = 0x0001;
-        }
 
         internal const uint SEM_FAILCRITICALERRORS = 1;
     }
diff --git a/src/mscorlib/corefx/Interop/Windows/kernel32/Interop.SetFileInformationByHandle.cs b/src/mscorlib/corefx/Interop/Windows/kernel32/Interop.SetFileInformationByHandle.cs
index e7e0ef0d9b..e31a453ba9 100644
--- a/src/mscorlib/corefx/Interop/Windows/kernel32/Interop.SetFileInformationByHandle.cs
+++ b/src/mscorlib/corefx/Interop/Windows/kernel32/Interop.SetFileInformationByHandle.cs
@@ -10,39 +10,6 @@ internal partial class Interop
 {
     internal partial class Kernel32
     {
-        [DllImport(Libraries.Kernel32, SetLastError = true)]
-        internal static extern bool SetFileInformationByHandle(SafeFileHandle hFile, FILE_INFO_BY_HANDLE_CLASS FileInformationClass, ref FILE_BASIC_INFO lpFileInformation, uint dwBufferSize);
-
-        // Default values indicate "no change".  Use defaults so that we don't force callsites to be aware of the default values
-        internal static unsafe bool SetFileTime(
-            SafeFileHandle hFile,
-            long creationTime = -1,
-            long lastAccessTime = -1,
-            long lastWriteTime = -1,
-            long changeTime = -1,
-            uint fileAttributes = 0)
-        {
-            FILE_BASIC_INFO basicInfo = new FILE_BASIC_INFO()
-            {
-                CreationTime = creationTime,
-                LastAccessTime = lastAccessTime,
-                LastWriteTime = lastWriteTime,
-                ChangeTime = changeTime,
-                FileAttributes = fileAttributes
-            };
-
-            return SetFileInformationByHandle(hFile, FILE_INFO_BY_HANDLE_CLASS.FileBasicInfo, ref basicInfo, (uint)Marshal.SizeOf<FILE_BASIC_INFO>());
-        }
-
-        internal struct FILE_BASIC_INFO
-        {
-            internal long CreationTime;
-            internal long LastAccessTime;
-            internal long LastWriteTime;
-            internal long ChangeTime;
-            internal uint FileAttributes;
-        }
-
         internal enum FILE_INFO_BY_HANDLE_CLASS : uint
         {
             FileBasicInfo = 0x0u,
diff --git a/src/mscorlib/corefx/Microsoft/Win32/SafeHandles/SafeFileHandle.Unix.cs b/src/mscorlib/corefx/Microsoft/Win32/SafeHandles/SafeFileHandle.Unix.cs
index 5ddb31ad36..d13b536204 100644
--- a/src/mscorlib/corefx/Microsoft/Win32/SafeHandles/SafeFileHandle.Unix.cs
+++ b/src/mscorlib/corefx/Microsoft/Win32/SafeHandles/SafeFileHandle.Unix.cs
@@ -8,7 +8,6 @@ using System.Runtime.InteropServices;
 
 namespace Microsoft.Win32.SafeHandles
 {
-    [System.Security.SecurityCritical]
     public sealed class SafeFileHandle : SafeHandleZeroOrMinusOneIsInvalid
     {
         /// <summary>A handle value of -1.</summary>
@@ -83,7 +82,6 @@ namespace Microsoft.Win32.SafeHandles
             return handle;
         }
 
-        [System.Security.SecurityCritical]
         protected override bool ReleaseHandle()
         {
             // When the SafeFileHandle was opened, we likely issued an flock on the created descriptor in order to add 
@@ -111,7 +109,6 @@ namespace Microsoft.Win32.SafeHandles
 
         public override bool IsInvalid
         {
-            [System.Security.SecurityCritical]
             get
             {
                 long h = (long)handle;
diff --git a/src/mscorlib/corefx/SR.cs b/src/mscorlib/corefx/SR.cs
index 23890e0ea5..012bb86a66 100644
--- a/src/mscorlib/corefx/SR.cs
+++ b/src/mscorlib/corefx/SR.cs
@@ -175,7 +175,7 @@ internal static class SR
     {
         get { return Environment.GetResourceString("Argument_CustomCultureCannotBePassedByNumber"); }
     }
-       
+
     public static string Argument_EmptyDecString
     {
         get { return Environment.GetResourceString("Argument_EmptyDecString"); }
@@ -525,23 +525,23 @@ internal static class SR
     {
         get { return Environment.GetResourceString("InvalidOperation_NativeOverlappedReused"); }
     }
-        
+
     public static string ArgumentOutOfRange_Length
     {
         get { return Environment.GetResourceString("ArgumentOutOfRange_Length"); }
     }
 
-    public static string ArgumentOutOfRange_IndexString 
+    public static string ArgumentOutOfRange_IndexString
     {
         get { return Environment.GetResourceString("ArgumentOutOfRange_IndexString"); }
     }
 
-    public static string ArgumentOutOfRange_Capacity 
+    public static string ArgumentOutOfRange_Capacity
     {
         get { return Environment.GetResourceString("ArgumentOutOfRange_Capacity"); }
     }
 
-    public static string Arg_CryptographyException 
+    public static string Arg_CryptographyException
     {
         get { return Environment.GetResourceString("Arg_CryptographyException"); }
     }
@@ -595,4 +595,224 @@ internal static class SR
     {
         get { return Environment.GetResourceString("ArgumentException_ValueTupleLastArgumentNotATuple"); }
     }
+
+    internal static string SpinLock_TryEnter_ArgumentOutOfRange
+    {
+        get { return Environment.GetResourceString("SpinLock_TryEnter_ArgumentOutOfRange"); }
+    }
+
+    internal static string SpinLock_TryReliableEnter_ArgumentException
+    {
+        get { return Environment.GetResourceString("SpinLock_TryReliableEnter_ArgumentException"); }
+    }
+
+    internal static string SpinLock_TryEnter_LockRecursionException
+    {
+        get { return Environment.GetResourceString("SpinLock_TryEnter_LockRecursionException"); }
+    }
+
+    internal static string SpinLock_Exit_SynchronizationLockException
+    {
+        get { return Environment.GetResourceString("SpinLock_Exit_SynchronizationLockException"); }
+    }
+
+    internal static string SpinLock_IsHeldByCurrentThread
+    {
+        get { return Environment.GetResourceString("SpinLock_IsHeldByCurrentThread"); }
+    }
+
+    internal static string ObjectDisposed_StreamIsClosed
+    {
+        get { return Environment.GetResourceString("ObjectDisposed_StreamIsClosed"); }
+    }
+
+    internal static string Arg_SystemException
+    {
+        get { return Environment.GetResourceString("Arg_SystemException"); }
+    }
+
+    internal static string Arg_StackOverflowException
+    {
+        get { return Environment.GetResourceString("Arg_StackOverflowException"); }
+    }
+
+    internal static string Arg_DataMisalignedException
+    {
+        get { return Environment.GetResourceString("Arg_DataMisalignedException"); }
+    }
+
+    internal static string Arg_ExecutionEngineException
+    {
+        get { return Environment.GetResourceString("Arg_ExecutionEngineException"); }
+    }
+
+    internal static string Arg_AccessException
+    {
+        get { return Environment.GetResourceString("Arg_AccessException"); }
+    }
+
+    internal static string Arg_AccessViolationException
+    {
+        get { return Environment.GetResourceString("Arg_AccessViolationException"); }
+    }
+
+    internal static string Arg_ApplicationException
+    {
+        get { return Environment.GetResourceString("Arg_ApplicationException"); }
+    }
+
+    internal static string Arg_ArgumentException
+    {
+        get { return Environment.GetResourceString("Arg_ArgumentException"); }
+    }
+
+    internal static string Arg_ParamName_Name
+    {
+        get { return Environment.GetResourceString("Arg_ParamName_Name"); }
+    }
+
+    internal static string ArgumentNull_Generic
+    {
+        get { return Environment.GetResourceString("ArgumentNull_Generic"); }
+    }
+
+    internal static string Arg_ArithmeticException
+    {
+        get { return Environment.GetResourceString("Arg_ArithmeticException"); }
+    }
+
+    internal static string Arg_ArrayTypeMismatchException
+    {
+        get { return Environment.GetResourceString("Arg_ArrayTypeMismatchException"); }
+    }
+
+    internal static string Arg_DivideByZero
+    {
+        get { return Environment.GetResourceString("Arg_DivideByZero"); }
+    }
+
+    internal static string Arg_DuplicateWaitObjectException
+    {
+        get { return Environment.GetResourceString("Arg_DuplicateWaitObjectException"); }
+    }
+
+    internal static string Arg_EntryPointNotFoundException
+    {
+        get { return Environment.GetResourceString("Arg_EntryPointNotFoundException"); }
+    }
+
+    internal static string Arg_FieldAccessException
+    {
+        get { return Environment.GetResourceString("Arg_FieldAccessException"); }
+    }
+
+    internal static string Arg_FormatException
+    {
+        get { return Environment.GetResourceString("Arg_FormatException"); }
+    }
+
+    internal static string Arg_IndexOutOfRangeException
+    {
+        get { return Environment.GetResourceString("Arg_IndexOutOfRangeException"); }
+    }
+
+    internal static string Arg_InsufficientExecutionStackException
+    {
+        get { return Environment.GetResourceString("Arg_InsufficientExecutionStackException"); }
+    }
+
+    internal static string Arg_InvalidCastException
+    {
+        get { return Environment.GetResourceString("Arg_InvalidCastException"); }
+    }
+
+    internal static string Arg_InvalidOperationException
+    {
+        get { return Environment.GetResourceString("Arg_InvalidOperationException"); }
+    }
+
+    internal static string InvalidProgram_Default
+    {
+        get { return Environment.GetResourceString("InvalidProgram_Default"); }
+    }
+
+    internal static string Arg_MethodAccessException
+    {
+        get { return Environment.GetResourceString("Arg_MethodAccessException"); }
+    }
+
+    internal static string Arg_MulticastNotSupportedException
+    {
+        get { return Environment.GetResourceString("Arg_MulticastNotSupportedException"); }
+    }
+
+    internal static string Arg_NotFiniteNumberException
+    {
+        get { return Environment.GetResourceString("Arg_NotFiniteNumberException"); }
+    }
+
+    internal static string Arg_NotImplementedException
+    {
+        get { return Environment.GetResourceString("Arg_NotImplementedException"); }
+    }
+
+    internal static string Arg_NotSupportedException
+    {
+        get { return Environment.GetResourceString("Arg_NotSupportedException"); }
+    }
+
+    internal static string Arg_NullReferenceException
+    {
+        get { return Environment.GetResourceString("Arg_NullReferenceException"); }
+    }
+
+    internal static string ObjectDisposed_Generic
+    {
+        get { return Environment.GetResourceString("ObjectDisposed_Generic"); }
+    }
+
+    internal static string ObjectDisposed_ObjectName_Name
+    {
+        get { return Environment.GetResourceString("ObjectDisposed_ObjectName_Name"); }
+    }
+
+    internal static string Arg_OverflowException
+    {
+        get { return Environment.GetResourceString("Arg_OverflowException"); }
+    }
+
+    internal static string Arg_PlatformNotSupported
+    {
+        get { return Environment.GetResourceString("Arg_PlatformNotSupported"); }
+    }
+
+    internal static string Arg_RankException
+    {
+        get { return Environment.GetResourceString("Arg_RankException"); }
+    }
+
+    internal static string Arg_TimeoutException
+    {
+        get { return Environment.GetResourceString("Arg_TimeoutException"); }
+    }
+
+    internal static string Arg_TypeAccessException
+    {
+        get { return Environment.GetResourceString("Arg_TypeAccessException"); }
+    }
+
+    internal static string TypeInitialization_Default
+    {
+        get { return Environment.GetResourceString("TypeInitialization_Default"); }
+    }
+
+    internal static string TypeInitialization_Type
+    {
+        get { return Environment.GetResourceString("TypeInitialization_Type"); }
+    }
+
+    internal static string Arg_UnauthorizedAccessException
+    {
+        get { return Environment.GetResourceString("Arg_UnauthorizedAccessException"); }
+    }
 }
diff --git a/src/mscorlib/corefx/System/Globalization/Calendar.cs b/src/mscorlib/corefx/System/Globalization/Calendar.cs
index 78e9f00d08..0ff5040c74 100644
--- a/src/mscorlib/corefx/System/Globalization/Calendar.cs
+++ b/src/mscorlib/corefx/System/Globalization/Calendar.cs
@@ -29,7 +29,6 @@ namespace System.Globalization
     // since most of the calendars (or all?) have the same way of calcuating hour/minute/second.
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public abstract partial class Calendar : ICloneable
     {
         // Number of 100ns (10E-7 second) ticks per time unit
@@ -77,7 +76,6 @@ namespace System.Globalization
 
         // The minimum supported DateTime range for the calendar.
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual DateTime MinSupportedDateTime
         {
             get
@@ -88,7 +86,6 @@ namespace System.Globalization
 
         // The maximum supported DateTime range for the calendar.
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual DateTime MaxSupportedDateTime
         {
             get
@@ -97,7 +94,6 @@ namespace System.Globalization
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual CalendarAlgorithmType AlgorithmType
         {
             get
@@ -138,7 +134,6 @@ namespace System.Globalization
         //  Detect if the object is readonly.
         //
         ////////////////////////////////////////////////////////////////////////
-        [System.Runtime.InteropServices.ComVisible(false)]
         public bool IsReadOnly
         {
             get { return (_isReadOnly); }
@@ -151,7 +146,6 @@ namespace System.Globalization
         //  Is the implementation of ICloneable.
         //
         ////////////////////////////////////////////////////////////////////////
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual object Clone()
         {
             object o = MemberwiseClone();
@@ -167,7 +161,6 @@ namespace System.Globalization
         //  readonly.
         //
         ////////////////////////////////////////////////////////////////////////
-        [System.Runtime.InteropServices.ComVisible(false)]
         public static Calendar ReadOnly(Calendar calendar)
         {
             if (calendar == null) { throw new ArgumentNullException(nameof(calendar)); }
@@ -708,7 +701,6 @@ namespace System.Globalization
         // if this calendar does not have leap month, or this year is not a leap year.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual int GetLeapMonth(int year)
         {
             return (GetLeapMonth(year, CurrentEra));
@@ -718,7 +710,6 @@ namespace System.Globalization
         // if this calendar does not have leap month, or this year is not a leap year.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual int GetLeapMonth(int year, int era)
         {
             if (!IsLeapYear(year, era))
diff --git a/src/mscorlib/corefx/System/Globalization/CalendarData.Unix.cs b/src/mscorlib/corefx/System/Globalization/CalendarData.Unix.cs
index 270d62f143..19c81f17b0 100644
--- a/src/mscorlib/corefx/System/Globalization/CalendarData.Unix.cs
+++ b/src/mscorlib/corefx/System/Globalization/CalendarData.Unix.cs
@@ -64,7 +64,6 @@ namespace System.Globalization
         }
 
         // Call native side to figure out which calendars are allowed
-        [SecuritySafeCritical]
         internal static int GetCalendars(string localeName, bool useUserOverride, CalendarId[] calendars)
         {
             // NOTE: there are no 'user overrides' on Linux
@@ -87,7 +86,6 @@ namespace System.Globalization
 
         // PAL Layer ends here
 
-        [SecuritySafeCritical]
         private static bool GetCalendarInfo(string localeName, CalendarId calendarId, CalendarDataType dataType, out string calendarString)
         {
             return Interop.CallStringMethod(
@@ -239,7 +237,6 @@ namespace System.Globalization
             return index - startIndex;
         }
 
-        [SecuritySafeCritical]
         private static bool EnumMonthNames(string localeName, CalendarId calendarId, CalendarDataType dataType, out string[] monthNames)
         {
             monthNames = null;
@@ -261,7 +258,6 @@ namespace System.Globalization
             return result;
         }
 
-        [SecuritySafeCritical]
         private static bool EnumEraNames(string localeName, CalendarId calendarId, CalendarDataType dataType, out string[] eraNames)
         {
             bool result = EnumCalendarInfo(localeName, calendarId, dataType, out eraNames);
@@ -277,7 +273,6 @@ namespace System.Globalization
             return result;
         }
 
-        [SecuritySafeCritical]
         internal static bool EnumCalendarInfo(string localeName, CalendarId calendarId, CalendarDataType dataType, out string[] calendarData)
         {
             calendarData = null;
@@ -292,7 +287,6 @@ namespace System.Globalization
             return result;
         }
 
-        [SecuritySafeCritical]
         private static bool EnumCalendarInfo(string localeName, CalendarId calendarId, CalendarDataType dataType, CallbackContext callbackContext)
         {
             GCHandle context = GCHandle.Alloc(callbackContext);
@@ -306,7 +300,6 @@ namespace System.Globalization
             }
         }
 
-        [SecuritySafeCritical]
         private static void EnumCalendarInfoCallback(string calendarString, IntPtr context)
         {
             CallbackContext callbackContext = (CallbackContext)((GCHandle)context).Target;
diff --git a/src/mscorlib/corefx/System/Globalization/CalendarWeekRule.cs b/src/mscorlib/corefx/System/Globalization/CalendarWeekRule.cs
index 490951e1f0..4013ce7237 100644
--- a/src/mscorlib/corefx/System/Globalization/CalendarWeekRule.cs
+++ b/src/mscorlib/corefx/System/Globalization/CalendarWeekRule.cs
@@ -7,7 +7,6 @@ using System;
 namespace System.Globalization
 {
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum CalendarWeekRule
     {
         FirstDay = 0,           // Week 1 begins on the first day of the year
diff --git a/src/mscorlib/corefx/System/Globalization/CalendricalCalculationsHelper.cs b/src/mscorlib/corefx/System/Globalization/CalendricalCalculationsHelper.cs
index 149e63c689..7de75d6aee 100644
--- a/src/mscorlib/corefx/System/Globalization/CalendricalCalculationsHelper.cs
+++ b/src/mscorlib/corefx/System/Globalization/CalendricalCalculationsHelper.cs
@@ -22,8 +22,8 @@ namespace System.Globalization
         private const int SecondsPerMinute = 60;
         private const int MinutesPerDegree = 60;
 
-        private static readonly long StartOf1810 = GetNumberOfDays(new DateTime(1810, 1, 1));
-        private static readonly long StartOf1900Century = GetNumberOfDays(new DateTime(1900, 1, 1));
+        private static readonly long s_startOf1810 = GetNumberOfDays(new DateTime(1810, 1, 1));
+        private static readonly long s_startOf1900Century = GetNumberOfDays(new DateTime(1900, 1, 1));
 
         private static readonly double[] s_coefficients1900to1987 = new double[] { -0.00002, 0.000297, 0.025184, -0.181133, 0.553040, -0.861938, 0.677066, -0.212591 };
         private static readonly double[] s_coefficients1800to1899 = new double[] { -0.000009, 0.003844, 0.083563, 0.865736, 4.867575, 15.845535, 31.332267, 38.291999, 28.316289, 11.636204, 2.043794 };
@@ -146,7 +146,7 @@ namespace System.Globalization
         private static double CenturiesFrom1900(int gregorianYear)
         {
             long july1stOfYear = GetNumberOfDays(new DateTime(gregorianYear, 7, 1));
-            return (double)(july1stOfYear - StartOf1900Century) / DaysInUniformLengthCentury;
+            return (double)(july1stOfYear - s_startOf1900Century) / DaysInUniformLengthCentury;
         }
 
         // the following formulas defines a polynomial function which gives us the amount that the earth is slowing down for specific year ranges
@@ -154,7 +154,7 @@ namespace System.Globalization
         {
             Debug.Assert(gregorianYear < 1620 || 2020 <= gregorianYear);
             long january1stOfYear = GetNumberOfDays(new DateTime(gregorianYear, 1, 1));
-            double daysSinceStartOf1810 = january1stOfYear - StartOf1810;
+            double daysSinceStartOf1810 = january1stOfYear - s_startOf1810;
             double x = TwelveHours + daysSinceStartOf1810;
             return ((Math.Pow(x, 2) / 41048480) - 15) / SecondsPerDay;
         }
diff --git a/src/mscorlib/corefx/System/Globalization/CharUnicodeInfo.cs b/src/mscorlib/corefx/System/Globalization/CharUnicodeInfo.cs
index dc38ca405b..38ce441a78 100644
--- a/src/mscorlib/corefx/System/Globalization/CharUnicodeInfo.cs
+++ b/src/mscorlib/corefx/System/Globalization/CharUnicodeInfo.cs
@@ -194,7 +194,7 @@ namespace System.Globalization
             // Get the level 2 WORD offset from the 4 - 7 bit of ch.  This provides the base offset of the level 3 table.
             // Note that & has the lower precedence than addition, so don't forget the parathesis.
             index = s_pNumericLevel1Index[index + ((ch >> 4) & 0x000f)];
-            
+
             fixed (ushort* pUshortPtr = &(s_pNumericLevel1Index[index]))
             {
                 byte* pBytePtr = (byte*)pUshortPtr;
@@ -238,46 +238,46 @@ namespace System.Globalization
             return (InternalGetNumericValue(InternalConvertToUtf32(s, index)));
         }
 
-        public static int GetDecimalDigitValue(char ch) 
+        public static int GetDecimalDigitValue(char ch)
         {
-            return (sbyte) (InternalGetDigitValues(ch) >> 8);
+            return (sbyte)(InternalGetDigitValues(ch) >> 8);
         }
 
-        public static int GetDecimalDigitValue(String s, int index) 
+        public static int GetDecimalDigitValue(String s, int index)
         {
-            if (s == null) 
+            if (s == null)
             {
                 throw new ArgumentNullException(nameof(s));
             }
-            
-            if (index < 0 || index >= s.Length) 
+
+            if (index < 0 || index >= s.Length)
             {
                 throw new ArgumentOutOfRangeException(nameof(index), SR.ArgumentOutOfRange_Index);
             }
             Contract.EndContractBlock();
 
-            return (sbyte) (InternalGetDigitValues(InternalConvertToUtf32(s, index)) >> 8);
+            return (sbyte)(InternalGetDigitValues(InternalConvertToUtf32(s, index)) >> 8);
         }
-        
+
         public static int GetDigitValue(char ch)
         {
-            return (sbyte) (InternalGetDigitValues(ch) & 0x00FF);
+            return (sbyte)(InternalGetDigitValues(ch) & 0x00FF);
         }
 
-        public static int GetDigitValue(String s, int index) 
+        public static int GetDigitValue(String s, int index)
         {
-            if (s == null) 
+            if (s == null)
             {
                 throw new ArgumentNullException(nameof(s));
             }
-            
-            if (index < 0 || index >= s.Length) 
+
+            if (index < 0 || index >= s.Length)
             {
                 throw new ArgumentOutOfRangeException(nameof(index), SR.ArgumentOutOfRange_Index);
             }
-            
+
             Contract.EndContractBlock();
-            return (sbyte) (InternalGetDigitValues(InternalConvertToUtf32(s, index)) & 0x00FF);
+            return (sbyte)(InternalGetDigitValues(InternalConvertToUtf32(s, index)) & 0x00FF);
         }
 
         public static UnicodeCategory GetUnicodeCategory(char ch)
diff --git a/src/mscorlib/corefx/System/Globalization/ChineseLunisolarCalendar.cs b/src/mscorlib/corefx/System/Globalization/ChineseLunisolarCalendar.cs
index 271d9802ce..5002555384 100644
--- a/src/mscorlib/corefx/System/Globalization/ChineseLunisolarCalendar.cs
+++ b/src/mscorlib/corefx/System/Globalization/ChineseLunisolarCalendar.cs
@@ -42,7 +42,6 @@ namespace System.Globalization
         internal static DateTime minDate = new DateTime(MIN_GREGORIAN_YEAR, MIN_GREGORIAN_MONTH, MIN_GREGORIAN_DAY);
         internal static DateTime maxDate = new DateTime((new DateTime(MAX_GREGORIAN_YEAR, MAX_GREGORIAN_MONTH, MAX_GREGORIAN_DAY, 23, 59, 59, 999)).Ticks + 9999);
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MinSupportedDateTime
         {
             get
@@ -52,7 +51,6 @@ namespace System.Globalization
         }
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MaxSupportedDateTime
         {
             get
@@ -318,9 +316,9 @@ namespace System.Globalization
             }
         }
 
-        internal override int GetYearInfo(int LunarYear, int Index)
+        internal override int GetYearInfo(int lunarYear, int index)
         {
-            if ((LunarYear < MIN_LUNISOLAR_YEAR) || (LunarYear > MAX_LUNISOLAR_YEAR))
+            if ((lunarYear < MIN_LUNISOLAR_YEAR) || (lunarYear > MAX_LUNISOLAR_YEAR))
             {
                 throw new ArgumentOutOfRangeException(
                             "year",
@@ -330,7 +328,7 @@ namespace System.Globalization
             }
             Contract.EndContractBlock();
 
-            return s_yinfo[LunarYear - MIN_LUNISOLAR_YEAR, Index];
+            return s_yinfo[lunarYear - MIN_LUNISOLAR_YEAR, index];
         }
 
         internal override int GetYear(int year, DateTime time)
@@ -362,7 +360,6 @@ namespace System.Globalization
         {
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetEra(DateTime time)
         {
             CheckTicksRange(time.Ticks);
@@ -387,7 +384,6 @@ namespace System.Globalization
         }
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int[] Eras
         {
             get
diff --git a/src/mscorlib/corefx/System/Globalization/CompareInfo.Windows.cs b/src/mscorlib/corefx/System/Globalization/CompareInfo.Windows.cs
index 4ebaf9cb10..d4936522dd 100644
--- a/src/mscorlib/corefx/System/Globalization/CompareInfo.Windows.cs
+++ b/src/mscorlib/corefx/System/Globalization/CompareInfo.Windows.cs
@@ -351,7 +351,7 @@ namespace System.Globalization
 
         private unsafe SortKey CreateSortKey(String source, CompareOptions options)
         {
-            if (source==null) { throw new ArgumentNullException(nameof(source)); }
+            if (source == null) { throw new ArgumentNullException(nameof(source)); }
             Contract.EndContractBlock();
 
             if ((options & ValidSortkeyCtorMaskOffFlags) != 0)
@@ -362,7 +362,7 @@ namespace System.Globalization
             throw new NotImplementedException();
         }
 
-        private static unsafe bool IsSortable(char *text, int length)
+        private static unsafe bool IsSortable(char* text, int length)
         {
             // CompareInfo c = CultureInfo.InvariantCulture.CompareInfo;
             // return (InternalIsSortable(c.m_dataHandle, c.m_handleOrigin, c.m_sortName, text, text.Length));
diff --git a/src/mscorlib/corefx/System/Globalization/CultureData.Unix.cs b/src/mscorlib/corefx/System/Globalization/CultureData.Unix.cs
index 7f2f17d9f5..ba96189458 100644
--- a/src/mscorlib/corefx/System/Globalization/CultureData.Unix.cs
+++ b/src/mscorlib/corefx/System/Globalization/CultureData.Unix.cs
@@ -24,7 +24,6 @@ namespace System.Globalization
         /// This method uses the sRealName field (which is initialized by the constructor before this is called) to
         /// initialize the rest of the state of CultureData based on the underlying OS globalization library.
         /// </summary>
-        [SecuritySafeCritical]
         private unsafe bool InitCultureData()
         {
             Debug.Assert(_sRealName != null);
@@ -87,7 +86,6 @@ namespace System.Globalization
             return true;
         }
 
-        [SecuritySafeCritical]
         internal static bool GetLocaleName(string localeName, out string windowsName)
         {
             // Get the locale name from ICU
@@ -104,7 +102,6 @@ namespace System.Globalization
             return true;
         }
 
-        [SecuritySafeCritical]
         internal static bool GetDefaultLocaleName(out string windowsName)
         {
             // Get the default (system) locale name from ICU
@@ -129,7 +126,6 @@ namespace System.Globalization
 
         // For LOCALE_SPARENT we need the option of using the "real" name (forcing neutral names) instead of the
         // "windows" name, which can be specific for downlevel (< windows 7) os's.
-        [SecuritySafeCritical]
         private string GetLocaleInfo(string localeName, LocaleStringData type)
         {
             Debug.Assert(localeName != null, "[CultureData.GetLocaleInfo] Expected localeName to be not be null");
@@ -155,7 +151,6 @@ namespace System.Globalization
             return StringBuilderCache.GetStringAndRelease(sb);
         }
 
-        [SecuritySafeCritical]
         private int GetLocaleInfo(LocaleNumberData type)
         {
             Debug.Assert(_sWindowsName != null, "[CultureData.GetLocaleInfo(LocaleNumberData)] Expected _sWindowsName to be populated already");
@@ -179,7 +174,6 @@ namespace System.Globalization
             return value;
         }
 
-        [SecuritySafeCritical]
         private int[] GetLocaleInfo(LocaleGroupingData type)
         {
             Debug.Assert(_sWindowsName != null, "[CultureData.GetLocaleInfo(LocaleGroupingData)] Expected _sWindowsName to be populated already");
@@ -205,7 +199,6 @@ namespace System.Globalization
             return GetTimeFormatString(false);
         }
 
-        [SecuritySafeCritical]
         private string GetTimeFormatString(bool shortFormat)
         {
             Debug.Assert(_sWindowsName != null, "[CultureData.GetTimeFormatString(bool shortFormat)] Expected _sWindowsName to be populated already");
diff --git a/src/mscorlib/corefx/System/Globalization/CultureData.Windows.cs b/src/mscorlib/corefx/System/Globalization/CultureData.Windows.cs
index d1c99da607..0c264e5f8b 100644
--- a/src/mscorlib/corefx/System/Globalization/CultureData.Windows.cs
+++ b/src/mscorlib/corefx/System/Globalization/CultureData.Windows.cs
@@ -663,11 +663,10 @@ namespace System.Globalization
         {
             get { throw new NotImplementedException(); }
         }
-        
+
         internal bool IsReplacementCulture
         {
             get { throw new NotImplementedException(); }
         }
-        
     }
 }
diff --git a/src/mscorlib/corefx/System/Globalization/CultureNotFoundException.cs b/src/mscorlib/corefx/System/Globalization/CultureNotFoundException.cs
index 64782d28c0..d296ad88e5 100644
--- a/src/mscorlib/corefx/System/Globalization/CultureNotFoundException.cs
+++ b/src/mscorlib/corefx/System/Globalization/CultureNotFoundException.cs
@@ -3,14 +3,13 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
-using System.Threading;
 using System.Runtime.Serialization;
+using System.Threading;
 
 namespace System.Globalization
 {
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public partial class CultureNotFoundException : ArgumentException, ISerializable
+    public class CultureNotFoundException : ArgumentException, ISerializable
     {
         private string _invalidCultureName; // unrecognized culture name
         private int? _invalidCultureId;     // unrecognized culture Lcid
@@ -66,14 +65,8 @@ namespace System.Globalization
             _invalidCultureName = (string)info.GetValue("InvalidCultureName", typeof(string));
         }
 
-        [System.Security.SecurityCritical]  // auto-generated_required
         public override void GetObjectData(SerializationInfo info, StreamingContext context)
         {
-            if (info == null)
-            {
-                throw new ArgumentNullException(nameof(info));
-            }
-
             base.GetObjectData(info, context);
             info.AddValue("InvalidCultureId", _invalidCultureId, typeof(int?));
             info.AddValue("InvalidCultureName", _invalidCultureName, typeof(string));
diff --git a/src/mscorlib/corefx/System/Globalization/CultureTypes.cs b/src/mscorlib/corefx/System/Globalization/CultureTypes.cs
index 80b588aabb..35ddff6086 100644
--- a/src/mscorlib/corefx/System/Globalization/CultureTypes.cs
+++ b/src/mscorlib/corefx/System/Globalization/CultureTypes.cs
@@ -7,7 +7,7 @@
 // the rest are obsolete or not valid on Linux
 
 namespace System.Globalization
-{    
+{
     [Serializable]
     [Flags]
     public enum CultureTypes
@@ -25,4 +25,4 @@ namespace System.Globalization
         [Obsolete("This value has been deprecated.  Please use other values in CultureTypes.")]
         FrameworkCultures           = 0x0040,               // will return only the v2 cultures marked as Framework culture.
     }
-}    
+}
diff --git a/src/mscorlib/corefx/System/Globalization/DateTimeFormatInfo.cs b/src/mscorlib/corefx/System/Globalization/DateTimeFormatInfo.cs
index 38119746e2..b79ce90424 100644
--- a/src/mscorlib/corefx/System/Globalization/DateTimeFormatInfo.cs
+++ b/src/mscorlib/corefx/System/Globalization/DateTimeFormatInfo.cs
@@ -514,7 +514,6 @@ namespace System.Globalization
 
         public String AMDesignator
         {
-            // auto-generated
             get
             {
                 if (this.amDesignator == null)
@@ -1031,7 +1030,6 @@ namespace System.Globalization
 
         public String PMDesignator
         {
-            // auto-generated
             get
             {
                 if (this.pmDesignator == null)
diff --git a/src/mscorlib/corefx/System/Globalization/DigitShapes.cs b/src/mscorlib/corefx/System/Globalization/DigitShapes.cs
index 7e40033a2f..0e4dcc87c3 100644
--- a/src/mscorlib/corefx/System/Globalization/DigitShapes.cs
+++ b/src/mscorlib/corefx/System/Globalization/DigitShapes.cs
@@ -5,6 +5,7 @@
 //
 // The enumeration constants used in NumberFormatInfo.DigitSubstitution.
 //
+
 namespace System.Globalization
 {
     [Serializable]
diff --git a/src/mscorlib/corefx/System/Globalization/EastAsianLunisolarCalendar.cs b/src/mscorlib/corefx/System/Globalization/EastAsianLunisolarCalendar.cs
index 84a44a990d..f82fad8e5b 100644
--- a/src/mscorlib/corefx/System/Globalization/EastAsianLunisolarCalendar.cs
+++ b/src/mscorlib/corefx/System/Globalization/EastAsianLunisolarCalendar.cs
@@ -14,7 +14,6 @@ namespace System.Globalization
     ////////////////////////////////////////////////////////////////////////////
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public abstract class EastAsianLunisolarCalendar : Calendar
     {
         internal const int LeapMonth = 0;
diff --git a/src/mscorlib/corefx/System/Globalization/GregorianCalendar.cs b/src/mscorlib/corefx/System/Globalization/GregorianCalendar.cs
index c2ed2e012b..be5b65b385 100644
--- a/src/mscorlib/corefx/System/Globalization/GregorianCalendar.cs
+++ b/src/mscorlib/corefx/System/Globalization/GregorianCalendar.cs
@@ -19,7 +19,6 @@ namespace System.Globalization
     // 1 BeforeCurrentEra (BC)
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
 
     public class GregorianCalendar : Calendar
     {
@@ -66,7 +65,6 @@ namespace System.Globalization
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MinSupportedDateTime
         {
             get
@@ -75,7 +73,6 @@ namespace System.Globalization
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MaxSupportedDateTime
         {
             get
@@ -84,7 +81,6 @@ namespace System.Globalization
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override CalendarAlgorithmType AlgorithmType
         {
             get
@@ -510,7 +506,6 @@ namespace System.Globalization
         // if this calendar does not have leap month, or this year is not a leap year.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetLeapMonth(int year, int era)
         {
             if (era != CurrentEra && era != ADEra)
diff --git a/src/mscorlib/corefx/System/Globalization/HebrewCalendar.cs b/src/mscorlib/corefx/System/Globalization/HebrewCalendar.cs
index 7e63708382..b4f54f8fbb 100644
--- a/src/mscorlib/corefx/System/Globalization/HebrewCalendar.cs
+++ b/src/mscorlib/corefx/System/Globalization/HebrewCalendar.cs
@@ -63,7 +63,6 @@ namespace System.Globalization
 
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class HebrewCalendar : Calendar
     {
         public static readonly int HebrewEra = 1;
diff --git a/src/mscorlib/corefx/System/Globalization/HijriCalendar.Win32.cs b/src/mscorlib/corefx/System/Globalization/HijriCalendar.Win32.cs
index 5f46dce61d..869b809bff 100644
--- a/src/mscorlib/corefx/System/Globalization/HijriCalendar.Win32.cs
+++ b/src/mscorlib/corefx/System/Globalization/HijriCalendar.Win32.cs
@@ -8,9 +8,10 @@ namespace System.Globalization
 {
     public partial class HijriCalendar : Calendar
     {
-        private static int GetHijriDateAdjustment()
+        private int GetHijriDateAdjustment()
         {
-            if (_hijriAdvance == Int32.MinValue) {
+            if (_hijriAdvance == Int32.MinValue)
+            {
                 // Never been set before.  Use the system value from registry.
                 _hijriAdvance = GetAdvanceHijriDate();
             }
@@ -36,11 +37,13 @@ namespace System.Globalization
         **      "AddHijriDate+1"  =>  Add +1 days to the current calculated Hijri date.
         **      "AddHijriDate+2"  =>  Add +2 days to the current calculated Hijri date.
         ============================================================================*/
-        private static int GetAdvanceHijriDate() {
+        private static int GetAdvanceHijriDate()
+        {
             int hijriAdvance = 0;
             Microsoft.Win32.RegistryKey key = null;
 
-            try {
+            try
+            {
                 // Open in read-only mode.
                 // Use InternalOpenSubKey so that we avoid the security check.
                 key = RegistryKey.GetBaseKey(RegistryKey.HKEY_CURRENT_USER).OpenSubKey(InternationalRegKey, false);
@@ -49,21 +52,28 @@ namespace System.Globalization
             catch (ObjectDisposedException) { return 0; }
             catch (ArgumentException) { return 0; }
 
-            if (key != null) {
-                try {
+            if (key != null)
+            {
+                try
+                {
                     Object value = key.InternalGetValue(HijriAdvanceRegKeyEntry, null, false, false);
-                    if (value == null) {
+                    if (value == null)
+                    {
                         return (0);
                     }
                     String str = value.ToString();
-                    if (String.Compare(str, 0, HijriAdvanceRegKeyEntry, 0, HijriAdvanceRegKeyEntry.Length, StringComparison.OrdinalIgnoreCase) == 0) {
+                    if (String.Compare(str, 0, HijriAdvanceRegKeyEntry, 0, HijriAdvanceRegKeyEntry.Length, StringComparison.OrdinalIgnoreCase) == 0)
+                    {
                         if (str.Length == HijriAdvanceRegKeyEntry.Length)
                             hijriAdvance = -1;
-                        else {
+                        else
+                        {
                             str = str.Substring(HijriAdvanceRegKeyEntry.Length);
-                            try {
+                            try
+                            {
                                 int advance = Int32.Parse(str.ToString(), CultureInfo.InvariantCulture);
-                                if ((advance >= MinAdvancedHijri) && (advance <= MaxAdvancedHijri)) {
+                                if ((advance >= MinAdvancedHijri) && (advance <= MaxAdvancedHijri))
+                                {
                                     hijriAdvance = advance;
                                 }
                             }
@@ -75,10 +85,10 @@ namespace System.Globalization
                         }
                     }
                 }
-                finally {
+                finally
+                {
                     key.Close();
                 }
-
             }
             return (hijriAdvance);
         }
diff --git a/src/mscorlib/corefx/System/Globalization/HijriCalendar.cs b/src/mscorlib/corefx/System/Globalization/HijriCalendar.cs
index 156b2104bd..0c72d9eaf5 100644
--- a/src/mscorlib/corefx/System/Globalization/HijriCalendar.cs
+++ b/src/mscorlib/corefx/System/Globalization/HijriCalendar.cs
@@ -45,7 +45,6 @@ namespace System.Globalization
     */
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public partial class HijriCalendar : Calendar
     {
         public static readonly int HijriEra = 1;
@@ -72,7 +71,6 @@ namespace System.Globalization
         internal static readonly DateTime calendarMaxValue = DateTime.MaxValue;
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MinSupportedDateTime
         {
             get
@@ -82,7 +80,6 @@ namespace System.Globalization
         }
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MaxSupportedDateTime
         {
             get
@@ -91,7 +88,6 @@ namespace System.Globalization
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override CalendarAlgorithmType AlgorithmType
         {
             get
@@ -565,7 +561,6 @@ namespace System.Globalization
         // if this calendar does not have leap month, or this year is not a leap year.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetLeapMonth(int year, int era)
         {
             CheckYearRange(year, era);
diff --git a/src/mscorlib/corefx/System/Globalization/IdnMapping.Windows.cs b/src/mscorlib/corefx/System/Globalization/IdnMapping.Windows.cs
index f39457b750..3d3292e3db 100644
--- a/src/mscorlib/corefx/System/Globalization/IdnMapping.Windows.cs
+++ b/src/mscorlib/corefx/System/Globalization/IdnMapping.Windows.cs
@@ -7,7 +7,7 @@ using System.Runtime.InteropServices;
 
 namespace System.Globalization
 {
-    sealed partial class IdnMapping
+    public sealed partial class IdnMapping
     {
         private unsafe string GetAsciiCore(char* unicode, int count)
         {
diff --git a/src/mscorlib/corefx/System/Globalization/JapaneseCalendar.Win32.cs b/src/mscorlib/corefx/System/Globalization/JapaneseCalendar.Win32.cs
index bbde320041..a83c4fad9e 100644
--- a/src/mscorlib/corefx/System/Globalization/JapaneseCalendar.Win32.cs
+++ b/src/mscorlib/corefx/System/Globalization/JapaneseCalendar.Win32.cs
@@ -33,7 +33,7 @@ namespace System.Globalization
             // Look in the registry key and see if we can find any ranges
             int iFoundEras = 0;
             EraInfo[] registryEraRanges = null;
-            
+
             try
             {
                 // Need to access registry
@@ -59,7 +59,7 @@ namespace System.Globalization
 
                         // Remember we found one.
                         registryEraRanges[iFoundEras] = era;
-                        iFoundEras++;                        
+                        iFoundEras++;
                     }
                 }
             }
@@ -109,7 +109,7 @@ namespace System.Globalization
                 else
                 {
                     // Rest are until the next era (remember most recent era is first in array)
-                    registryEraRanges[i].maxEraYear = registryEraRanges[i-1].yearOffset + 1 - registryEraRanges[i].yearOffset;
+                    registryEraRanges[i].maxEraYear = registryEraRanges[i - 1].yearOffset + 1 - registryEraRanges[i].yearOffset;
                 }
             }
 
@@ -147,7 +147,7 @@ namespace System.Globalization
         {
             // Need inputs
             if (value == null || data == null) return null;
-            
+
             //
             // Get Date
             //
@@ -159,9 +159,9 @@ namespace System.Globalization
             int month;
             int day;
 
-            if (!Int32.TryParse(value.Substring(0,4), NumberStyles.None, NumberFormatInfo.InvariantInfo, out year) ||
-                !Int32.TryParse(value.Substring(5,2), NumberStyles.None, NumberFormatInfo.InvariantInfo, out month) ||
-                !Int32.TryParse(value.Substring(8,2), NumberStyles.None, NumberFormatInfo.InvariantInfo, out day))
+            if (!Int32.TryParse(value.Substring(0, 4), NumberStyles.None, NumberFormatInfo.InvariantInfo, out year) ||
+                !Int32.TryParse(value.Substring(5, 2), NumberStyles.None, NumberFormatInfo.InvariantInfo, out month) ||
+                !Int32.TryParse(value.Substring(8, 2), NumberStyles.None, NumberFormatInfo.InvariantInfo, out day))
             {
                 // Couldn't convert integer, fail
                 return null;
@@ -171,7 +171,7 @@ namespace System.Globalization
             // Get Strings
             //
             // Needs to be a certain length e_a_E_A at least (7 chars, exactly 4 groups)
-            String[] names = data.Split(new char[] {'_'});
+            String[] names = data.Split('_');
 
             // Should have exactly 4 parts
             // 0 - Era Name
@@ -192,18 +192,18 @@ namespace System.Globalization
             // Note that the era # and max era year need cleaned up after sorting
             // Don't use the full English Era Name (names[2])
             //
-            return new EraInfo( 0, year, month, day, year - 1, 1, 0, 
+            return new EraInfo(0, year, month, day, year - 1, 1, 0,
                                 names[0], names[1], names[3]);
         }
 
         // PAL Layer ends here
 
-        private static string[] JapaneseErasEnglishNames = new String[] { "M", "T", "S", "H" };
+        private static string[] s_japaneseErasEnglishNames = new String[] { "M", "T", "S", "H" };
 
         private static string GetJapaneseEnglishEraName(int era)
         {
             Debug.Assert(era > 0);
-            return era <= JapaneseErasEnglishNames.Length ? JapaneseErasEnglishNames[era - 1] : " ";
+            return era <= s_japaneseErasEnglishNames.Length ? s_japaneseErasEnglishNames[era - 1] : " ";
         }
     }
 }
diff --git a/src/mscorlib/corefx/System/Globalization/JapaneseCalendar.cs b/src/mscorlib/corefx/System/Globalization/JapaneseCalendar.cs
index 0b0fa77fc0..f0216c8f51 100644
--- a/src/mscorlib/corefx/System/Globalization/JapaneseCalendar.cs
+++ b/src/mscorlib/corefx/System/Globalization/JapaneseCalendar.cs
@@ -39,13 +39,11 @@ namespace System.Globalization
 
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public partial class JapaneseCalendar : Calendar
     {
         internal static readonly DateTime calendarMinValue = new DateTime(1868, 9, 8);
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MinSupportedDateTime
         {
             get
@@ -54,7 +52,6 @@ namespace System.Globalization
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MaxSupportedDateTime
         {
             get
@@ -63,7 +60,6 @@ namespace System.Globalization
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override CalendarAlgorithmType AlgorithmType
         {
             get
@@ -233,7 +229,6 @@ namespace System.Globalization
 
 
         [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
         {
             return (helper.GetWeekOfYear(time, rule, firstDayOfWeek));
@@ -281,7 +276,6 @@ namespace System.Globalization
         // if this calendar does not have leap month, or this year is not a leap year.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetLeapMonth(int year, int era)
         {
             return (helper.GetLeapMonth(year, era));
diff --git a/src/mscorlib/corefx/System/Globalization/JapaneseLunisolarCalendar.cs b/src/mscorlib/corefx/System/Globalization/JapaneseLunisolarCalendar.cs
index ecdaced2d7..cc3d34954d 100644
--- a/src/mscorlib/corefx/System/Globalization/JapaneseLunisolarCalendar.cs
+++ b/src/mscorlib/corefx/System/Globalization/JapaneseLunisolarCalendar.cs
@@ -206,9 +206,9 @@ namespace System.Globalization
             }
         }
 
-        internal override int GetYearInfo(int LunarYear, int Index)
+        internal override int GetYearInfo(int lunarYear, int index)
         {
-            if ((LunarYear < MIN_LUNISOLAR_YEAR) || (LunarYear > MAX_LUNISOLAR_YEAR))
+            if ((lunarYear < MIN_LUNISOLAR_YEAR) || (lunarYear > MAX_LUNISOLAR_YEAR))
             {
                 throw new ArgumentOutOfRangeException(
                             "year",
@@ -220,7 +220,7 @@ namespace System.Globalization
             }
             Contract.EndContractBlock();
 
-            return s_yinfo[LunarYear - MIN_LUNISOLAR_YEAR, Index];
+            return s_yinfo[lunarYear - MIN_LUNISOLAR_YEAR, index];
         }
 
         internal override int GetYear(int year, DateTime time)
diff --git a/src/mscorlib/corefx/System/Globalization/JulianCalendar.cs b/src/mscorlib/corefx/System/Globalization/JulianCalendar.cs
index a4277c6d49..43e6ad07a2 100644
--- a/src/mscorlib/corefx/System/Globalization/JulianCalendar.cs
+++ b/src/mscorlib/corefx/System/Globalization/JulianCalendar.cs
@@ -19,7 +19,6 @@ namespace System.Globalization
     //*      Julia       0001/01/03   9999/10/19
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class JulianCalendar : Calendar
     {
         public static readonly int JulianEra = 1;
@@ -49,7 +48,6 @@ namespace System.Globalization
         internal int MaxYear = 9999;
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MinSupportedDateTime
         {
             get
@@ -58,7 +56,6 @@ namespace System.Globalization
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MaxSupportedDateTime
         {
             get
@@ -67,7 +64,6 @@ namespace System.Globalization
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override CalendarAlgorithmType AlgorithmType
         {
             get
@@ -346,7 +342,6 @@ namespace System.Globalization
         // if this calendar does not have leap month, or this year is not a leap year.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetLeapMonth(int year, int era)
         {
             CheckYearEraRange(year, era);
diff --git a/src/mscorlib/corefx/System/Globalization/KoreanCalendar.cs b/src/mscorlib/corefx/System/Globalization/KoreanCalendar.cs
index 27d0aa812a..b015aa0716 100644
--- a/src/mscorlib/corefx/System/Globalization/KoreanCalendar.cs
+++ b/src/mscorlib/corefx/System/Globalization/KoreanCalendar.cs
@@ -25,7 +25,6 @@ namespace System.Globalization
 
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class KoreanCalendar : Calendar
     {
         //
@@ -51,7 +50,6 @@ namespace System.Globalization
         internal GregorianCalendarHelper helper;
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MinSupportedDateTime
         {
             get
@@ -60,7 +58,6 @@ namespace System.Globalization
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MaxSupportedDateTime
         {
             get
@@ -69,7 +66,6 @@ namespace System.Globalization
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override CalendarAlgorithmType AlgorithmType
         {
             get
@@ -160,7 +156,6 @@ namespace System.Globalization
 
 
         [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
         {
             return (helper.GetWeekOfYear(time, rule, firstDayOfWeek));
@@ -199,7 +194,6 @@ namespace System.Globalization
         // if this calendar does not have leap month, or this year is not a leap year.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetLeapMonth(int year, int era)
         {
             return (helper.GetLeapMonth(year, era));
diff --git a/src/mscorlib/corefx/System/Globalization/KoreanLunisolarCalendar.cs b/src/mscorlib/corefx/System/Globalization/KoreanLunisolarCalendar.cs
index 07d85a461e..6d091285b2 100644
--- a/src/mscorlib/corefx/System/Globalization/KoreanLunisolarCalendar.cs
+++ b/src/mscorlib/corefx/System/Globalization/KoreanLunisolarCalendar.cs
@@ -1251,9 +1251,9 @@ namespace System.Globalization
             }
         }
 
-        internal override int GetYearInfo(int LunarYear, int Index)
+        internal override int GetYearInfo(int lunarYear, int index)
         {
-            if ((LunarYear < MIN_LUNISOLAR_YEAR) || (LunarYear > MAX_LUNISOLAR_YEAR))
+            if ((lunarYear < MIN_LUNISOLAR_YEAR) || (lunarYear > MAX_LUNISOLAR_YEAR))
             {
                 throw new ArgumentOutOfRangeException(
                             "year",
@@ -1264,7 +1264,7 @@ namespace System.Globalization
                                 MAX_LUNISOLAR_YEAR));
             }
             Contract.EndContractBlock();
-            return s_yinfo[LunarYear - MIN_LUNISOLAR_YEAR, Index];
+            return s_yinfo[lunarYear - MIN_LUNISOLAR_YEAR, index];
         }
 
         internal override int GetYear(int year, DateTime time)
diff --git a/src/mscorlib/corefx/System/Globalization/RegionInfo.cs b/src/mscorlib/corefx/System/Globalization/RegionInfo.cs
index 0645ded0ab..15679d24dd 100644
--- a/src/mscorlib/corefx/System/Globalization/RegionInfo.cs
+++ b/src/mscorlib/corefx/System/Globalization/RegionInfo.cs
@@ -87,7 +87,6 @@ namespace System.Globalization
             SetName(name);
         }
 
-        [System.Security.SecuritySafeCritical]  // auto-generated
         public RegionInfo(int culture)
         {
             if (culture == CultureInfo.LOCALE_INVARIANT) //The InvariantCulture has no matching region
@@ -132,7 +131,6 @@ namespace System.Globalization
         [OnSerializing]
         private void OnSerializing(StreamingContext ctx) { }
 
-        [System.Security.SecurityCritical]  // auto-generated
         [OnDeserialized]
         private void OnDeserialized(StreamingContext ctx)
         {
diff --git a/src/mscorlib/corefx/System/Globalization/SortKey.cs b/src/mscorlib/corefx/System/Globalization/SortKey.cs
index fc151fa37e..9e22a6f332 100644
--- a/src/mscorlib/corefx/System/Globalization/SortKey.cs
+++ b/src/mscorlib/corefx/System/Globalization/SortKey.cs
@@ -19,7 +19,6 @@ namespace System.Globalization {
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public partial class SortKey
     {
diff --git a/src/mscorlib/corefx/System/Globalization/SortVersion.cs b/src/mscorlib/corefx/System/Globalization/SortVersion.cs
index 72aa6d6b7b..983179c149 100644
--- a/src/mscorlib/corefx/System/Globalization/SortVersion.cs
+++ b/src/mscorlib/corefx/System/Globalization/SortVersion.cs
@@ -5,7 +5,7 @@
 using System;
 using System.Diagnostics.Contracts;
 
-namespace System.Globalization 
+namespace System.Globalization
 {
     [Serializable]
     public sealed class SortVersion : IEquatable<SortVersion>
@@ -13,48 +13,48 @@ namespace System.Globalization
         private int _nlsVersion;
         private Guid _sortId;
 
-        public int FullVersion 
+        public int FullVersion
         {
-            get 
+            get
             {
                 return _nlsVersion;
             }
         }
 
-        public Guid SortId 
+        public Guid SortId
         {
-            get 
+            get
             {
                 return _sortId;
             }
         }
 
-        public SortVersion(int fullVersion, Guid sortId) 
-        {           
+        public SortVersion(int fullVersion, Guid sortId)
+        {
             _sortId = sortId;
             _nlsVersion = fullVersion;
         }
 
-        internal SortVersion(int nlsVersion, int effectiveId, Guid customVersion) 
+        internal SortVersion(int nlsVersion, int effectiveId, Guid customVersion)
         {
             _nlsVersion = nlsVersion;
 
-            if (customVersion == Guid.Empty) 
+            if (customVersion == Guid.Empty)
             {
-                byte b1 = (byte) (effectiveId >> 24);
-                byte b2 = (byte) ((effectiveId  & 0x00FF0000) >> 16);
-                byte b3 = (byte) ((effectiveId  & 0x0000FF00) >> 8);
-                byte b4 = (byte) (effectiveId  & 0xFF);
-                customVersion = new Guid(0,0,0,0,0,0,0,b1,b2,b3,b4);
+                byte b1 = (byte)(effectiveId >> 24);
+                byte b2 = (byte)((effectiveId & 0x00FF0000) >> 16);
+                byte b3 = (byte)((effectiveId & 0x0000FF00) >> 8);
+                byte b4 = (byte)(effectiveId & 0xFF);
+                customVersion = new Guid(0, 0, 0, 0, 0, 0, 0, b1, b2, b3, b4);
             }
 
             _sortId = customVersion;
         }
 
-        public override bool Equals(object obj) 
+        public override bool Equals(object obj)
         {
             SortVersion n = obj as SortVersion;
-            if (n != null) 
+            if (n != null)
             {
                 return this.Equals(n);
             }
@@ -62,9 +62,9 @@ namespace System.Globalization
             return false;
         }
 
-        public bool Equals(SortVersion other) 
+        public bool Equals(SortVersion other)
         {
-            if (other == null) 
+            if (other == null)
             {
                 return false;
             }
@@ -72,19 +72,19 @@ namespace System.Globalization
             return _nlsVersion == other._nlsVersion && _sortId == other._sortId;
         }
 
-        public override int GetHashCode() 
-        { 
-            return _nlsVersion * 7 | _sortId.GetHashCode(); 
+        public override int GetHashCode()
+        {
+            return _nlsVersion * 7 | _sortId.GetHashCode();
         }
 
-        public static bool operator ==(SortVersion left, SortVersion right) 
+        public static bool operator ==(SortVersion left, SortVersion right)
         {
-            if (((object) left) != null) 
+            if (((object)left) != null)
             {
                 return left.Equals(right);
             }
 
-            if (((object) right) != null) 
+            if (((object)right) != null)
             {
                 return right.Equals(left);
             }
@@ -93,7 +93,7 @@ namespace System.Globalization
             return true;
         }
 
-        public static bool operator !=(SortVersion left, SortVersion right) 
+        public static bool operator !=(SortVersion left, SortVersion right)
         {
             return !(left == right);
         }
diff --git a/src/mscorlib/corefx/System/Globalization/StringInfo.cs b/src/mscorlib/corefx/System/Globalization/StringInfo.cs
index 7558002413..f1dd30561b 100644
--- a/src/mscorlib/corefx/System/Globalization/StringInfo.cs
+++ b/src/mscorlib/corefx/System/Globalization/StringInfo.cs
@@ -20,7 +20,6 @@ using System.Runtime.Serialization;
 namespace System.Globalization
 {
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class StringInfo
     {
         [OptionalField(VersionAdded = 2)] 
@@ -53,7 +52,6 @@ namespace System.Globalization
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override bool Equals(Object value)
         {
             StringInfo that = value as StringInfo;
@@ -64,7 +62,6 @@ namespace System.Globalization
             return (false);
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetHashCode()
         {
             return _str.GetHashCode();
diff --git a/src/mscorlib/corefx/System/Globalization/TaiwanCalendar.cs b/src/mscorlib/corefx/System/Globalization/TaiwanCalendar.cs
index 36edd5b2fd..2e735e0cb9 100644
--- a/src/mscorlib/corefx/System/Globalization/TaiwanCalendar.cs
+++ b/src/mscorlib/corefx/System/Globalization/TaiwanCalendar.cs
@@ -22,7 +22,6 @@ namespace System.Globalization
     ============================================================================*/
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class TaiwanCalendar : Calendar
     {
         //
@@ -65,7 +64,6 @@ namespace System.Globalization
         internal static readonly DateTime calendarMinValue = new DateTime(1912, 1, 1);
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MinSupportedDateTime
         {
             get
@@ -74,7 +72,6 @@ namespace System.Globalization
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MaxSupportedDateTime
         {
             get
@@ -83,7 +80,6 @@ namespace System.Globalization
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override CalendarAlgorithmType AlgorithmType
         {
             get
@@ -166,7 +162,6 @@ namespace System.Globalization
 
 
         [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
         {
             return (helper.GetWeekOfYear(time, rule, firstDayOfWeek));
@@ -205,7 +200,6 @@ namespace System.Globalization
         // if this calendar does not have leap month, or this year is not a leap year.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetLeapMonth(int year, int era)
         {
             return (helper.GetLeapMonth(year, era));
diff --git a/src/mscorlib/corefx/System/Globalization/TaiwanLunisolarCalendar.cs b/src/mscorlib/corefx/System/Globalization/TaiwanLunisolarCalendar.cs
index 42b7f2473b..1f75ac9a04 100644
--- a/src/mscorlib/corefx/System/Globalization/TaiwanLunisolarCalendar.cs
+++ b/src/mscorlib/corefx/System/Globalization/TaiwanLunisolarCalendar.cs
@@ -264,9 +264,9 @@ namespace System.Globalization
             }
         }
 
-        internal override int GetYearInfo(int LunarYear, int Index)
+        internal override int GetYearInfo(int lunarYear, int index)
         {
-            if ((LunarYear < MIN_LUNISOLAR_YEAR) || (LunarYear > MAX_LUNISOLAR_YEAR))
+            if ((lunarYear < MIN_LUNISOLAR_YEAR) || (lunarYear > MAX_LUNISOLAR_YEAR))
             {
                 throw new ArgumentOutOfRangeException(
                             "year",
@@ -278,7 +278,7 @@ namespace System.Globalization
             }
             Contract.EndContractBlock();
 
-            return s_yinfo[LunarYear - MIN_LUNISOLAR_YEAR, Index];
+            return s_yinfo[lunarYear - MIN_LUNISOLAR_YEAR, index];
         }
 
         internal override int GetYear(int year, DateTime time)
diff --git a/src/mscorlib/corefx/System/Globalization/TextElementEnumerator.cs b/src/mscorlib/corefx/System/Globalization/TextElementEnumerator.cs
index c0ffc65307..464897b03f 100644
--- a/src/mscorlib/corefx/System/Globalization/TextElementEnumerator.cs
+++ b/src/mscorlib/corefx/System/Globalization/TextElementEnumerator.cs
@@ -21,7 +21,6 @@ namespace System.Globalization
     //
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class TextElementEnumerator : IEnumerator
     {
         private String _str;
diff --git a/src/mscorlib/corefx/System/Globalization/TextInfo.Unix.cs b/src/mscorlib/corefx/System/Globalization/TextInfo.Unix.cs
index 3d9b777f64..67836d89d6 100644
--- a/src/mscorlib/corefx/System/Globalization/TextInfo.Unix.cs
+++ b/src/mscorlib/corefx/System/Globalization/TextInfo.Unix.cs
@@ -33,7 +33,6 @@ namespace System.Globalization
         {
         }
 
-        [SecuritySafeCritical]
         private unsafe string ChangeCase(string s, bool toUpper)
         {
             Debug.Assert(s != null);
@@ -78,7 +77,6 @@ namespace System.Globalization
             return result;
         }
 
-        [SecuritySafeCritical]
         private unsafe char ChangeCase(char c, bool toUpper)
         {
             char dst = default(char);
diff --git a/src/mscorlib/corefx/System/Globalization/TextInfo.cs b/src/mscorlib/corefx/System/Globalization/TextInfo.cs
index 5bb376f19c..172bbd25b2 100644
--- a/src/mscorlib/corefx/System/Globalization/TextInfo.cs
+++ b/src/mscorlib/corefx/System/Globalization/TextInfo.cs
@@ -188,7 +188,6 @@ namespace System.Globalization
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public int LCID 
         {
             get 
@@ -220,7 +219,6 @@ namespace System.Globalization
         //  Detect if the object is readonly.
         //
         ////////////////////////////////////////////////////////////////////////
-        [System.Runtime.InteropServices.ComVisible(false)]
         public bool IsReadOnly
         {
             get { return (_isReadOnly); }
@@ -248,7 +246,6 @@ namespace System.Globalization
         //  readonly.
         //
         ////////////////////////////////////////////////////////////////////////
-        [System.Runtime.InteropServices.ComVisible(false)]
         public static TextInfo ReadOnly(TextInfo textInfo)
         {
             if (textInfo == null) { throw new ArgumentNullException(nameof(textInfo)); }
diff --git a/src/mscorlib/corefx/System/Globalization/ThaiBuddhistCalendar.cs b/src/mscorlib/corefx/System/Globalization/ThaiBuddhistCalendar.cs
index 8ebbfa0a69..9e6e30406c 100644
--- a/src/mscorlib/corefx/System/Globalization/ThaiBuddhistCalendar.cs
+++ b/src/mscorlib/corefx/System/Globalization/ThaiBuddhistCalendar.cs
@@ -21,7 +21,6 @@ namespace System.Globalization
     ============================================================================*/
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class ThaiBuddhistCalendar : Calendar
     {
         // Initialize our era info.
@@ -38,7 +37,6 @@ namespace System.Globalization
         internal GregorianCalendarHelper helper;
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MinSupportedDateTime
         {
             get
@@ -47,7 +45,6 @@ namespace System.Globalization
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MaxSupportedDateTime
         {
             get
@@ -56,7 +53,6 @@ namespace System.Globalization
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override CalendarAlgorithmType AlgorithmType
         {
             get
@@ -128,7 +124,6 @@ namespace System.Globalization
 
 
         [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
         {
             return (helper.GetWeekOfYear(time, rule, firstDayOfWeek));
@@ -167,7 +162,6 @@ namespace System.Globalization
         // if this calendar does not have leap month, or this year is not a leap year.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetLeapMonth(int year, int era)
         {
             return (helper.GetLeapMonth(year, era));
diff --git a/src/mscorlib/corefx/System/Globalization/UmAlQuraCalendar.cs b/src/mscorlib/corefx/System/Globalization/UmAlQuraCalendar.cs
index 997c5f2316..7b47d9c02b 100644
--- a/src/mscorlib/corefx/System/Globalization/UmAlQuraCalendar.cs
+++ b/src/mscorlib/corefx/System/Globalization/UmAlQuraCalendar.cs
@@ -41,7 +41,7 @@ namespace System.Globalization
 
         private static DateMapping[] InitDateMapping()
         {
-            short[] rawData = new short[] 
+            short[] rawData = new short[]
             {
                 //These data is taken from Tables/Excel/UmAlQura.xls please make sure that the two places are in sync
                 /*  DaysPerM     GY      GM     GD     D1   D2   D3   D4   D5   D6   D7   D8   D9   D10  D11  D12    
diff --git a/src/mscorlib/corefx/System/IO/FileStream.NetStandard17.cs b/src/mscorlib/corefx/System/IO/FileStream.NetStandard17.cs
deleted file mode 100644
index dc1385fbc0..0000000000
--- a/src/mscorlib/corefx/System/IO/FileStream.NetStandard17.cs
+++ /dev/null
@@ -1,76 +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.
-
-using Microsoft.Win32.SafeHandles;
-using System.Threading.Tasks;
-using System.Diagnostics;
-using System.Threading;
-
-namespace System.IO
-{
-    public partial class FileStream : Stream
-    {
-        public override IAsyncResult BeginRead(byte[] array, int offset, int numBytes, AsyncCallback callback, object state)
-        {
-            if (array == null)
-                throw new ArgumentNullException(nameof(array));
-            if (offset < 0)
-                throw new ArgumentOutOfRangeException(nameof(offset), SR.ArgumentOutOfRange_NeedNonNegNum);
-            if (numBytes < 0)
-                throw new ArgumentOutOfRangeException(nameof(numBytes), SR.ArgumentOutOfRange_NeedNonNegNum);
-            if (array.Length - offset < numBytes)
-                throw new ArgumentException(SR.Argument_InvalidOffLen);
-
-            if (IsClosed) throw new ObjectDisposedException(SR.ObjectDisposed_FileClosed);
-            if (!CanRead) throw new NotSupportedException(SR.NotSupported_UnreadableStream);
-
-            if (!IsAsync)
-                return base.BeginRead(array, offset, numBytes, callback, state);
-            else
-                return TaskToApm.Begin(ReadAsyncInternal(array, offset, numBytes, CancellationToken.None), callback, state);
-        }
-
-        public override IAsyncResult BeginWrite(byte[] array, int offset, int numBytes, AsyncCallback callback, object state)
-        {
-            if (array == null)
-                throw new ArgumentNullException(nameof(array));
-            if (offset < 0)
-                throw new ArgumentOutOfRangeException(nameof(offset), SR.ArgumentOutOfRange_NeedNonNegNum);
-            if (numBytes < 0)
-                throw new ArgumentOutOfRangeException(nameof(numBytes), SR.ArgumentOutOfRange_NeedNonNegNum);
-            if (array.Length - offset < numBytes)
-                throw new ArgumentException(SR.Argument_InvalidOffLen);
-
-            if (IsClosed) throw new ObjectDisposedException(SR.ObjectDisposed_FileClosed);
-            if (!CanWrite) throw new NotSupportedException(SR.NotSupported_UnwritableStream);
-
-            if (!IsAsync)
-                return base.BeginWrite(array, offset, numBytes, callback, state);
-            else
-                return TaskToApm.Begin(WriteAsyncInternal(array, offset, numBytes, CancellationToken.None), callback, state);
-        }
-
-        public override int EndRead(IAsyncResult asyncResult)
-        {
-            if (asyncResult == null)
-                throw new ArgumentNullException(nameof(asyncResult));
-
-            if (!IsAsync)
-                return base.EndRead(asyncResult);
-            else
-                return TaskToApm.End<int>(asyncResult);
-        }
-
-        public override void EndWrite(IAsyncResult asyncResult)
-        {
-            if (asyncResult == null)
-                throw new ArgumentNullException(nameof(asyncResult));
-
-            if (!IsAsync)
-                base.EndWrite(asyncResult);
-            else
-                TaskToApm.End(asyncResult);
-        }
-    }
-}
diff --git a/src/mscorlib/corefx/System/IO/FileStream.Win32.cs b/src/mscorlib/corefx/System/IO/FileStream.Win32.cs
index f6896be7ac..683eef5e43 100644
--- a/src/mscorlib/corefx/System/IO/FileStream.Win32.cs
+++ b/src/mscorlib/corefx/System/IO/FileStream.Win32.cs
@@ -1277,7 +1277,7 @@ namespace System.IO
             int r = 0;
             int numBytesRead = 0;
 
-            fixed (byte* p = bytes)
+            fixed (byte* p = &bytes[0])
             {
                 if (_useAsyncIO)
                     r = Interop.Kernel32.ReadFile(handle, p + offset, count, IntPtr.Zero, overlapped);
@@ -1322,7 +1322,7 @@ namespace System.IO
             int numBytesWritten = 0;
             int r = 0;
 
-            fixed (byte* p = bytes)
+            fixed (byte* p = &bytes[0])
             {
                 if (_useAsyncIO)
                     r = Interop.Kernel32.WriteFile(handle, p + offset, count, IntPtr.Zero, overlapped);
diff --git a/src/mscorlib/corefx/System/IO/FileStream.cs b/src/mscorlib/corefx/System/IO/FileStream.cs
index 398f5a6162..7db8518435 100644
--- a/src/mscorlib/corefx/System/IO/FileStream.cs
+++ b/src/mscorlib/corefx/System/IO/FileStream.cs
@@ -139,20 +139,6 @@ namespace System.IO
             this(path, mode, access, share, bufferSize, useAsync ? FileOptions.Asynchronous : FileOptions.None)
         { }
 
-        internal FileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options, string msgPath, bool bFromProxy)
-            : this(path, mode, access, share, bufferSize, options, msgPath, bFromProxy, useLongPath: false)
-        {
-        }
-
-        internal FileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options, string msgPath, bool bFromProxy, bool useLongPath)
-            : this(path, mode, access, share, bufferSize, options)
-        {
-            // msgPath is the path that is handed back to untrusted code, CoreCLR is always full trust
-            // bFromProxy is also related to asserting rights for limited trust and also can be ignored
-            // useLongPath was used to get around the legacy MaxPath check, this is no longer applicable as everything supports long paths
-            // checkHost is also related to limited trust scenarios
-        }
-
         public FileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options)
         {
             if (path == null)
@@ -225,24 +211,6 @@ namespace System.IO
             return handle.IsAsync.HasValue ? handle.IsAsync.Value : false;
         }
 
-        // InternalOpen, InternalCreate, and InternalAppend:
-        // Factory methods for FileStream used by File, FileInfo, and ReadLinesIterator
-        // Specifies default access and sharing options for FileStreams created by those classes
-        internal static FileStream InternalOpen(string path, int bufferSize = DefaultBufferSize, bool useAsync = DefaultIsAsync)
-        {
-            return new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize, useAsync);
-        }
-
-        internal static FileStream InternalCreate(string path, int bufferSize = DefaultBufferSize, bool useAsync = DefaultIsAsync)
-        {
-            return new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.Read, bufferSize, useAsync);
-        }
-
-        internal static FileStream InternalAppend(string path, int bufferSize = DefaultBufferSize, bool useAsync = DefaultIsAsync)
-        {
-            return new FileStream(path, FileMode.Append, FileAccess.Write, FileShare.Read, bufferSize, useAsync);
-        }
-
         [Obsolete("This property has been deprecated.  Please use FileStream's SafeFileHandle property instead.  http://go.microsoft.com/fwlink/?linkid=14202")]
         public virtual IntPtr Handle { get { return SafeFileHandle.DangerousGetHandle(); } }
 
@@ -650,5 +618,67 @@ namespace System.IO
             // on Dispose(false) call.
             Dispose(false);
         }
+
+        public override IAsyncResult BeginRead(byte[] array, int offset, int numBytes, AsyncCallback callback, object state)
+        {
+            if (array == null)
+                throw new ArgumentNullException(nameof(array));
+            if (offset < 0)
+                throw new ArgumentOutOfRangeException(nameof(offset), SR.ArgumentOutOfRange_NeedNonNegNum);
+            if (numBytes < 0)
+                throw new ArgumentOutOfRangeException(nameof(numBytes), SR.ArgumentOutOfRange_NeedNonNegNum);
+            if (array.Length - offset < numBytes)
+                throw new ArgumentException(SR.Argument_InvalidOffLen);
+
+            if (IsClosed) throw new ObjectDisposedException(SR.ObjectDisposed_FileClosed);
+            if (!CanRead) throw new NotSupportedException(SR.NotSupported_UnreadableStream);
+
+            if (!IsAsync)
+                return base.BeginRead(array, offset, numBytes, callback, state);
+            else
+                return TaskToApm.Begin(ReadAsyncInternal(array, offset, numBytes, CancellationToken.None), callback, state);
+        }
+
+        public override IAsyncResult BeginWrite(byte[] array, int offset, int numBytes, AsyncCallback callback, object state)
+        {
+            if (array == null)
+                throw new ArgumentNullException(nameof(array));
+            if (offset < 0)
+                throw new ArgumentOutOfRangeException(nameof(offset), SR.ArgumentOutOfRange_NeedNonNegNum);
+            if (numBytes < 0)
+                throw new ArgumentOutOfRangeException(nameof(numBytes), SR.ArgumentOutOfRange_NeedNonNegNum);
+            if (array.Length - offset < numBytes)
+                throw new ArgumentException(SR.Argument_InvalidOffLen);
+
+            if (IsClosed) throw new ObjectDisposedException(SR.ObjectDisposed_FileClosed);
+            if (!CanWrite) throw new NotSupportedException(SR.NotSupported_UnwritableStream);
+
+            if (!IsAsync)
+                return base.BeginWrite(array, offset, numBytes, callback, state);
+            else
+                return TaskToApm.Begin(WriteAsyncInternal(array, offset, numBytes, CancellationToken.None), callback, state);
+        }
+
+        public override int EndRead(IAsyncResult asyncResult)
+        {
+            if (asyncResult == null)
+                throw new ArgumentNullException(nameof(asyncResult));
+
+            if (!IsAsync)
+                return base.EndRead(asyncResult);
+            else
+                return TaskToApm.End<int>(asyncResult);
+        }
+
+        public override void EndWrite(IAsyncResult asyncResult)
+        {
+            if (asyncResult == null)
+                throw new ArgumentNullException(nameof(asyncResult));
+
+            if (!IsAsync)
+                base.EndWrite(asyncResult);
+            else
+                TaskToApm.End(asyncResult);
+        }
     }
 }
diff --git a/src/mscorlib/corefx/System/IO/PathInternal.Unix.cs b/src/mscorlib/corefx/System/IO/PathInternal.Unix.cs
index adc4da7e3f..08dc1d0251 100644
--- a/src/mscorlib/corefx/System/IO/PathInternal.Unix.cs
+++ b/src/mscorlib/corefx/System/IO/PathInternal.Unix.cs
@@ -43,22 +43,6 @@ namespace System.IO
         }
 
         /// <summary>
-        /// Returns true if the path is too long
-        /// </summary>
-        internal static bool IsPathTooLong(string fullPath)
-        {
-            return fullPath.Length >= Interop.Sys.MaxPath;
-        }
-
-        /// <summary>
-        /// Returns true if the directory is too long
-        /// </summary>
-        internal static bool IsDirectoryTooLong(string fullPath)
-        {
-            return fullPath.Length >= Interop.Sys.MaxPath;
-        }
-
-        /// <summary>
         /// Normalize separators in the given path. Compresses forward slash runs.
         /// </summary>
         internal static string NormalizeDirectorySeparators(string path)
@@ -110,12 +94,6 @@ namespace System.IO
             return ch == DirectorySeparatorChar;
         }
 
-        internal static bool HasInvalidVolumeSeparator(string path)
-        {
-            // This is only ever true for Windows
-            return false;
-        }
-
         internal static bool IsPartiallyQualified(string path)
         {
             // This is much simpler than Windows where paths can be rooted, but not fully qualified (such as Drive Relative)
diff --git a/src/mscorlib/corefx/System/IO/PathInternal.Windows.cs b/src/mscorlib/corefx/System/IO/PathInternal.Windows.cs
index 560b9d1b57..0ec9b30f99 100644
--- a/src/mscorlib/corefx/System/IO/PathInternal.Windows.cs
+++ b/src/mscorlib/corefx/System/IO/PathInternal.Windows.cs
@@ -74,24 +74,6 @@ namespace System.IO
         }
 
         /// <summary>
-        /// Returns true if the path is too long
-        /// </summary>
-        internal static bool IsPathTooLong(string fullPath)
-        {
-            // We'll never know precisely what will fail as paths get changed internally in Windows and
-            // may grow to exceed MaxLongPath.
-            return fullPath.Length >= MaxLongPath;
-        }
-
-        /// <summary>
-        /// Returns true if the directory is too long
-        /// </summary>
-        internal static bool IsDirectoryTooLong(string fullPath)
-        {
-            return IsPathTooLong(fullPath);
-        }
-
-        /// <summary>
         /// Adds the extended path prefix (\\?\) if not already a device path, IF the path is not relative,
         /// AND the path is more than 259 characters. (> MAX_PATH + null)
         /// </summary>
@@ -456,31 +438,5 @@ namespace System.IO
         {
             return IsDirectorySeparator(ch) || VolumeSeparatorChar == ch;
         }
-
-        /// <summary>
-        /// Validates volume separator only occurs as C: or \\?\C:. This logic is meant to filter out Alternate Data Streams.
-        /// </summary>
-        /// <returns>True if the path has an invalid volume separator.</returns>
-        internal static bool HasInvalidVolumeSeparator(string path)
-        {
-            // Toss out paths with colons that aren't a valid drive specifier.
-            // Cannot start with a colon and can only be of the form "C:" or "\\?\C:".
-            // (Note that we used to explicitly check "http:" and "file:"- these are caught by this check now.)
-
-            // We don't care about skipping starting space for extended paths. Assume no knowledge of extended paths if we're forcing old path behavior.
-            int startIndex = IsExtended(path) ? ExtendedPathPrefix.Length : PathStartSkip(path);
-
-            // If we start with a colon
-            if ((path.Length > startIndex && path[startIndex] == VolumeSeparatorChar)
-                // Or have an invalid drive letter and colon
-                || (path.Length >= startIndex + 2 && path[startIndex + 1] == VolumeSeparatorChar && !IsValidDriveChar(path[startIndex]))
-                // Or have any colons beyond the drive colon
-                || (path.Length > startIndex + 2 && path.IndexOf(VolumeSeparatorChar, startIndex + 2) != -1))
-            {
-                return true;
-            }
-
-            return false;
-        }
     }
 }
diff --git a/src/mscorlib/corefx/System/IO/PathInternal.cs b/src/mscorlib/corefx/System/IO/PathInternal.cs
index ee67680df5..6b4c3b2d30 100644
--- a/src/mscorlib/corefx/System/IO/PathInternal.cs
+++ b/src/mscorlib/corefx/System/IO/PathInternal.cs
@@ -40,64 +40,6 @@ namespace System.IO
             if (HasIllegalCharacters(path))
                 throw new ArgumentException(SR.Argument_InvalidPathChars, nameof(path));
         }
-
-
-        /// <summary>
-        /// Returns true if the given StringBuilder starts with the given value.
-        /// </summary>
-        /// <param name="value">The string to compare against the start of the StringBuilder.</param>
-        internal static bool StartsWithOrdinal(this StringBuilder builder, string value)
-        {
-            if (value == null || builder.Length < value.Length)
-                return false;
-
-            for (int i = 0; i < value.Length; i++)
-            {
-                if (builder[i] != value[i]) return false;
-            }
-            return true;
-        }
-
-        /// <summary>
-        /// Returns true if the given string starts with the given value.
-        /// </summary>
-        /// <param name="value">The string to compare against the start of the source string.</param>
-        internal static bool StartsWithOrdinal(this string source, string value)
-        {
-            if (value == null || source.Length < value.Length)
-                return false;
-
-            return source.StartsWith(value, StringComparison.Ordinal);
-        }
-
-        /// <summary>
-        /// Trims the specified characters from the end of the StringBuilder.
-        /// </summary>
-        internal static StringBuilder TrimEnd(this StringBuilder builder, params char[] trimChars)
-        {
-            if (trimChars == null || trimChars.Length == 0)
-                return builder;
-
-            int end = builder.Length - 1;
-
-            for (; end >= 0; end--)
-            {
-                int i = 0;
-                char ch = builder[end];
-                for (; i < trimChars.Length; i++)
-                {
-                    if (trimChars[i] == ch) break;
-                }
-                if (i == trimChars.Length)
-                {
-                    // Not a trim char
-                    break;
-                }
-            }
-
-            builder.Length = end + 1;
-            return builder;
-        }
         
         /// <summary>
         /// Returns the start index of the filename
diff --git a/src/mscorlib/corefx/System/IO/Win32Marshal.cs b/src/mscorlib/corefx/System/IO/Win32Marshal.cs
index 8bdab0b049..ef76c27010 100644
--- a/src/mscorlib/corefx/System/IO/Win32Marshal.cs
+++ b/src/mscorlib/corefx/System/IO/Win32Marshal.cs
@@ -23,16 +23,6 @@ namespace System.IO
         }
 
         /// <summary>
-        ///     Converts, resetting it, the last Win32 error into a corresponding <see cref="Exception"/> object, optionally 
-        ///     including the specified path in the error message.
-        /// </summary>
-        internal static Exception GetExceptionForLastWin32Error(string path)
-        {
-            int errorCode = Marshal.GetLastWin32Error();
-            return GetExceptionForWin32Error(errorCode, path);
-        }
-
-        /// <summary>
         ///     Converts the specified Win32 error into a corresponding <see cref="Exception"/> object.
         /// </summary>
         internal static Exception GetExceptionForWin32Error(int errorCode)
@@ -109,21 +99,6 @@ namespace System.IO
         }
 
         /// <summary>
-        ///     Returns a Win32 error code for the specified HRESULT if it came from FACILITY_WIN32
-        ///     If not, returns the HRESULT unchanged
-        /// </summary>
-        internal static int TryMakeWin32ErrorCodeFromHR(int hr)
-        {
-            if ((0xFFFF0000 & hr) == 0x80070000)
-            {
-                // Win32 error, Win32Marshal.GetExceptionForWin32Error expects the Win32 format
-                hr &= 0x0000FFFF;
-            }
-
-            return hr;
-        }
-
-        /// <summary>
         ///     Returns a string message for the specified Win32 error code.
         /// </summary>
         internal static string GetMessage(int errorCode)
diff --git a/src/mscorlib/corefx/System/Runtime/InteropServices/StringBuffer.cs b/src/mscorlib/corefx/System/Runtime/InteropServices/StringBuffer.cs
index 8779a63fdd..fdd0b95590 100644
--- a/src/mscorlib/corefx/System/Runtime/InteropServices/StringBuffer.cs
+++ b/src/mscorlib/corefx/System/Runtime/InteropServices/StringBuffer.cs
@@ -164,26 +164,6 @@ namespace System.Runtime.InteropServices
         }
 
         /// <summary>
-        /// Append the given string.
-        /// </summary>
-        /// <param name="value">The string to append.</param>
-        /// <param name="startIndex">The index in the input string to start appending from.</param>
-        /// <param name="count">The count of characters to copy from the input string, or -1 for all remaining.</param>
-        /// <exception cref="ArgumentNullException">Thrown if <paramref name="value"/> is null.</exception>
-        /// <exception cref="ArgumentOutOfRangeException">
-        /// Thrown if <paramref name="startIndex"/> or <paramref name="count"/> are outside the range
-        /// of <paramref name="value"/> characters.
-        /// </exception>
-        public void Append(string value, int startIndex = 0, int count = -1)
-        {
-            CopyFrom(
-                bufferIndex: _length,
-                source: value,
-                sourceIndex: startIndex,
-                count: count);
-        }
-
-        /// <summary>
         /// Append the given buffer.
         /// </summary>
         /// <param name="value">The buffer to append.</param>
diff --git a/src/mscorlib/facade/project.json b/src/mscorlib/facade/project.json
index 37f8c1ba57..b0b39a1264 100644
--- a/src/mscorlib/facade/project.json
+++ b/src/mscorlib/facade/project.json
@@ -4,6 +4,7 @@
     "System.IO": "4.1.0",
     "System.Security.Cryptography.Primitives": "4.0.0",
     "System.Security.Claims": "4.0.0",
+    "System.Security.Principal": "4.0.0"
   },
   "frameworks": {
     "netstandard1.3": {
diff --git a/src/mscorlib/model.xml b/src/mscorlib/model.xml
deleted file mode 100644
index 09a9ba8a1c..0000000000
--- a/src/mscorlib/model.xml
+++ /dev/null
@@ -1,12713 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<ThinModel>
-  <Assembly Status="ApiRoot" Name="System.Private.CoreLib">
-    <Type Name="System.AccessViolationException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member MemberType="Field" Name="_accessType" />
-      <Member MemberType="Field" Name="_ip" />
-      <Member MemberType="Field" Name="_target" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Action">
-      <Member Status="ApiRoot" Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Status="ApiRoot" Name="BeginInvoke(System.AsyncCallback,System.Object)" />
-      <Member Status="ApiRoot" Name="EndInvoke(System.IAsyncResult)" />
-      <Member Status="ApiRoot" Name="Invoke" />
-    </Type>
-    <Type Name="System.Action&lt;T&gt;">
-      <Member Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Name="BeginInvoke(T,System.AsyncCallback,System.Object)" />
-      <Member Name="EndInvoke(System.IAsyncResult)" />
-      <Member Name="Invoke(T)" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Action&lt;T1,T2&gt;">
-      <Member Status="ApiRoot" Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Status="ApiRoot" Name="BeginInvoke(T1,T2,System.AsyncCallback,System.Object)" />
-      <Member Status="ApiRoot" Name="EndInvoke(System.IAsyncResult)" />
-      <Member Status="ApiRoot" Name="Invoke(T1,T2)" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Action&lt;T1,T2,T3&gt;">
-      <Member Status="ApiRoot" Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Status="ApiRoot" Name="BeginInvoke(T1,T2,T3,System.AsyncCallback,System.Object)" />
-      <Member Status="ApiRoot" Name="EndInvoke(System.IAsyncResult)" />
-      <Member Status="ApiRoot" Name="Invoke(T1,T2,T3)" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Action&lt;T1,T2,T3,T4&gt;">
-      <Member Status="ApiRoot" Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Status="ApiRoot" Name="BeginInvoke(T1,T2,T3,T4,System.AsyncCallback,System.Object)" />
-      <Member Status="ApiRoot" Name="EndInvoke(System.IAsyncResult)" />
-      <Member Status="ApiRoot" Name="Invoke(T1,T2,T3,T4)" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Action&lt;T1,T2,T3,T4,T5&gt;">
-      <Member Status="ApiRoot" Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Status="ApiRoot" Name="BeginInvoke(T1,T2,T3,T4,T5,System.AsyncCallback,System.Object)" />
-      <Member Status="ApiRoot" Name="EndInvoke(System.IAsyncResult)" />
-      <Member Status="ApiRoot" Name="Invoke(T1,T2,T3,T4,T5)" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Action&lt;T1,T2,T3,T4,T5,T6&gt;">
-      <Member Status="ApiRoot" Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Status="ApiRoot" Name="BeginInvoke(T1,T2,T3,T4,T5,T6,System.AsyncCallback,System.Object)" />
-      <Member Status="ApiRoot" Name="EndInvoke(System.IAsyncResult)" />
-      <Member Status="ApiRoot" Name="Invoke(T1,T2,T3,T4,T5,T6)" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Action&lt;T1,T2,T3,T4,T5,T6,T7&gt;">
-      <Member Status="ApiRoot" Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Status="ApiRoot" Name="BeginInvoke(T1,T2,T3,T4,T5,T6,T7,System.AsyncCallback,System.Object)" />
-      <Member Status="ApiRoot" Name="EndInvoke(System.IAsyncResult)" />
-      <Member Status="ApiRoot" Name="Invoke(T1,T2,T3,T4,T5,T6,T7)" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Action&lt;T1,T2,T3,T4,T5,T6,T7,T8&gt;">
-      <Member Status="ApiRoot" Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Status="ApiRoot" Name="BeginInvoke(T1,T2,T3,T4,T5,T6,T7,T8,System.AsyncCallback,System.Object)" />
-      <Member Status="ApiRoot" Name="EndInvoke(System.IAsyncResult)" />
-      <Member Status="ApiRoot" Name="Invoke(T1,T2,T3,T4,T5,T6,T7,T8)" />
-    </Type>
-    <Type Name="System.Activator">
-      <Member Name="CreateComInstanceFrom(System.String,System.String)" />
-      <Member Name="CreateComInstanceFrom(System.String,System.String,System.Byte[],System.Configuration.Assemblies.AssemblyHashAlgorithm)" />
-      <Member Name="CreateInstance(System.String,System.String)" />
-      <Member Name="CreateInstance(System.String,System.String,System.Boolean,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object[],System.Globalization.CultureInfo,System.Object[])" />
-      <Member Name="CreateInstance(System.String,System.String,System.Object[])" />
-      <Member Name="CreateInstance(System.Type)" />
-      <Member Name="CreateInstance(System.Type,System.Boolean)" />
-      <Member Name="CreateInstance(System.Type,System.Object[])" />
-      <Member Name="CreateInstance(System.Type,System.Object[],System.Object[])" />
-      <Member Name="CreateInstance(System.Type,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object[],System.Globalization.CultureInfo)" />
-      <Member Name="CreateInstance(System.Type,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object[],System.Globalization.CultureInfo,System.Object[])" />
-      <Member Name="CreateInstance&lt;T&gt;" />
-      <Member Name="CreateInstanceFrom(System.String,System.String)" />
-      <Member Name="CreateInstanceFrom(System.String,System.String,System.Boolean,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object[],System.Globalization.CultureInfo,System.Object[])" />
-      <Member Name="CreateInstanceFrom(System.String,System.String,System.Object[])" />
-      <Member Status="ImplRoot" Name="System.Runtime.InteropServices._Activator.GetIDsOfNames(System.Guid@,System.IntPtr,System.UInt32,System.UInt32,System.IntPtr)" />
-      <Member Status="ImplRoot" Name="System.Runtime.InteropServices._Activator.GetTypeInfo(System.UInt32,System.UInt32,System.IntPtr)" />
-      <Member Status="ImplRoot" Name="System.Runtime.InteropServices._Activator.GetTypeInfoCount(System.UInt32@)" />
-      <Member Status="ImplRoot" Name="System.Runtime.InteropServices._Activator.Invoke(System.UInt32,System.Guid@,System.UInt32,System.Int16,System.IntPtr,System.IntPtr,System.IntPtr,System.IntPtr)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.AppDomain">
-      <Member Status="ImplRoot" Name="get_CurrentDomain" />
-      <Member Status="ImplRoot" MemberType="Property" Name="IsFullyTrusted" />
-      <Member Status="ImplRoot" Name="GetData(System.String)" />
-      <Member Status="ImplRoot" Name="ToString" />
-      <Member Status="ImplRoot" Name="SetupDomainSecurity(System.Security.Policy.Evidence,System.IntPtr,System.Boolean)" />
-      <Member Status="ImplRoot" Name="SetupDomainSecurity(System.AppDomainHandle,System.Runtime.CompilerServices.ObjectHandleOnStack,System.IntPtr,System.Boolean)" />
-      <Member Status="ImplRoot" MemberType="Event" Name="AssemblyResolve" />
-      <Member Status="ImplRoot" Name="OnAssemblyResolveEvent(System.Reflection.RuntimeAssembly,System.String)" />
-      <Member Status="ImplRoot" MemberType="Event" Name="AssemblyLoad" />
-      <Member Status="ImplRoot" MemberType="Event" Name="ResourceResolve" />
-      <Member Status="ImplRoot" MemberType="Event" Name="TypeResolve" />
-      <Member Status="ImplRoot" MemberType="Event" Name="DomainUnload" />
-      <Member Status="ImplRoot" MemberType="Field" Name="_applicationTrust" />
-      <Member Status="ImplRoot" MemberType="Field" Name="_FusionStore" />
-      <Member Status="ImplRoot" MemberType="Field" Name="_HasSetPolicy" />
-      <Member Status="ImplRoot" MemberType="Field" Name="_LocalStore" />
-      <Member Status="ImplRoot" MemberType="Field" Name="_processExit" />
-      <Member Status="ImplRoot" MemberType="Field" Name="_SecurityIdentity" />
-      <Member Status="ImplRoot" MemberType="Field" Name="_unhandledException" />
-      <Member Status="ImplRoot" Name="OnAssemblyLoadEvent(System.Reflection.RuntimeAssembly)" />
-      <Member Status="ImplRoot" Name="OnResourceResolveEvent(System.Reflection.RuntimeAssembly,System.String)" />
-      <Member Status="ImplRoot" Name="OnTypeResolveEvent(System.Reflection.RuntimeAssembly,System.String)" />
-      <Member Status="ImplRoot" Name="PrepareDataForSetup(System.String,System.AppDomainSetup,System.Security.Policy.Evidence,System.Security.Policy.Evidence,System.IntPtr,System.String,System.String[],System.String[])" />
-      <Member Status="ImplRoot" Name="Setup(System.Object)" />
-      <Member Status="ImplRoot" Name="SetupDomain(System.Boolean,System.String,System.String,System.String[],System.String[])" />
-      <Member Status="ImplRoot" Name="nCreateContext" />
-      <Member Status="ImplRoot" Name="OnDesignerNamespaceResolveEvent(System.String)" Condition="FEATURE_COMINTEROP" />
-      <Member Status="ImplRoot" MemberType="Property" Name="BaseDirectory" />
-      <Member Status="ImplRoot" Name="get_BaseDirectory" />
-    </Type>
-    <Type Name="System.AppContext">
-      <Member MemberType="Event" Name="FirstChanceException" />
-      <Member MemberType="Event" Name="ProcessExit" />
-      <Member MemberType="Event" Name="UnhandledException" />
-      <Member Name="add_FirstChanceException(System.EventHandler&lt;System.Runtime.ExceptionServices.FirstChanceExceptionEventArgs&gt;)" />
-      <Member Name="add_ProcessExit(System.EventHandler)" />
-      <Member Name="add_UnhandledException(System.UnhandledExceptionEventHandler)" />
-      <Member Name="get_BaseDirectory" />
-      <Member Name="get_TargetFrameworkName" />
-      <Member Name="GetData(System.String)" />
-      <Member Name="remove_FirstChanceException(System.EventHandler&lt;System.Runtime.ExceptionServices.FirstChanceExceptionEventArgs&gt;)" />
-      <Member Name="remove_ProcessExit(System.EventHandler)" />
-      <Member Name="remove_UnhandledException(System.UnhandledExceptionEventHandler)" />
-      <Member Name="SetData(System.String,System.Object)" />
-      <Member Name="SetSwitch(System.String,System.Boolean)" />
-      <Member Name="TryGetSwitch(System.String,System.Boolean@)" />
-      <Member MemberType="Property" Name="BaseDirectory" />
-      <Member MemberType="Property" Name="TargetFrameworkName" />
-    </Type>
-    <Type Name="System.ApplicationException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Collections.ArrayList">
-      <Member Name="ReadOnly(System.Collections.IList)" />
-    </Type>
-    <Type Name="System.ArgumentException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.String,System.String)" />
-      <Member Name="#ctor(System.String,System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="get_ParamName" />
-      <Member MemberType="Property" Name="ParamName" />
-    </Type>
-    <Type Name="System.ArgumentNullException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.ArgumentOutOfRangeException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.String,System.Object,System.String)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="get_ActualValue" />
-      <Member MemberType="Property" Name="ActualValue" />
-    </Type>
-    <Type Name="System.ArithmeticException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Array">
-      <Member Name="AsReadOnly&lt;T&gt;(T[])" />
-      <Member Name="BinarySearch(System.Array,System.Int32,System.Int32,System.Object)" />
-      <Member Name="BinarySearch(System.Array,System.Int32,System.Int32,System.Object,System.Collections.IComparer)" />
-      <Member Name="BinarySearch(System.Array,System.Object)" />
-      <Member Name="BinarySearch(System.Array,System.Object,System.Collections.IComparer)" />
-      <Member Name="BinarySearch&lt;T&gt;(T[],System.Int32,System.Int32,T)" />
-      <Member Name="BinarySearch&lt;T&gt;(T[],System.Int32,System.Int32,T,System.Collections.Generic.IComparer&lt;T&gt;)" />
-      <Member Name="BinarySearch&lt;T&gt;(T[],T)" />
-      <Member Name="BinarySearch&lt;T&gt;(T[],T,System.Collections.Generic.IComparer&lt;T&gt;)" />
-      <Member Name="Clear(System.Array,System.Int32,System.Int32)" />
-      <Member Name="Clone" />
-      <Member Name="ConstrainedCopy(System.Array,System.Int32,System.Array,System.Int32,System.Int32)" />
-      <Member Name="ConvertAll&lt;TInput,TOutput&gt;(TInput[],System.Converter&lt;TInput,TOutput&gt;)" />
-      <Member Name="Copy(System.Array,System.Array,System.Int32)" />
-      <Member Name="Copy(System.Array,System.Array,System.Int64)" />
-      <Member Name="Copy(System.Array,System.Int32,System.Array,System.Int32,System.Int32)" />
-      <Member Name="Copy(System.Array,System.Int64,System.Array,System.Int64,System.Int64)" />
-      <Member Name="CopyTo(System.Array,System.Int32)" />
-      <Member Name="CopyTo(System.Array,System.Int64)" />
-      <Member Name="CreateInstance(System.Type,System.Int32)" />
-      <Member Name="CreateInstance(System.Type,System.Int32,System.Int32)" />
-      <Member Name="CreateInstance(System.Type,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="CreateInstance(System.Type,System.Int32[])" />
-      <Member Name="CreateInstance(System.Type,System.Int32[],System.Int32[])" />
-      <Member Name="CreateInstance(System.Type,System.Int64[])" />
-      <Member Name="Empty&lt;T&gt;" />
-      <Member Name="Exists&lt;T&gt;(T[],System.Predicate&lt;T&gt;)" />
-      <Member Name="Fill&lt;T&gt;(T[],T)" />
-      <Member Name="Fill&lt;T&gt;(T[],T,System.Int32,System.Int32)" />
-      <Member Name="Find&lt;T&gt;(T[],System.Predicate&lt;T&gt;)" />
-      <Member Name="FindAll&lt;T&gt;(T[],System.Predicate&lt;T&gt;)" />
-      <Member Name="FindIndex&lt;T&gt;(T[],System.Int32,System.Int32,System.Predicate&lt;T&gt;)" />
-      <Member Name="FindIndex&lt;T&gt;(T[],System.Int32,System.Predicate&lt;T&gt;)" />
-      <Member Name="FindIndex&lt;T&gt;(T[],System.Predicate&lt;T&gt;)" />
-      <Member Name="FindLast&lt;T&gt;(T[],System.Predicate&lt;T&gt;)" />
-      <Member Name="FindLastIndex&lt;T&gt;(T[],System.Int32,System.Int32,System.Predicate&lt;T&gt;)" />
-      <Member Name="FindLastIndex&lt;T&gt;(T[],System.Int32,System.Predicate&lt;T&gt;)" />
-      <Member Name="FindLastIndex&lt;T&gt;(T[],System.Predicate&lt;T&gt;)" />
-      <Member Name="ForEach&lt;T&gt;(T[],System.Action&lt;T&gt;)" />
-      <Member Name="get_IsFixedSize" />
-      <Member Name="get_IsReadOnly" />
-      <Member Name="get_IsSynchronized" />
-      <Member Name="get_Length" />
-      <Member Name="get_LongLength" />
-      <Member Name="get_Rank" />
-      <Member Name="get_SyncRoot" />
-      <Member Name="GetEnumerator" />
-      <Member Name="GetLength(System.Int32)" />
-      <Member Name="GetLongLength(System.Int32)" />
-      <Member Name="GetLowerBound(System.Int32)" />
-      <Member Name="GetUpperBound(System.Int32)" />
-      <Member Name="GetValue(System.Int32)" />
-      <Member Name="GetValue(System.Int32,System.Int32)" />
-      <Member Name="GetValue(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="GetValue(System.Int32[])" />
-      <Member Name="GetValue(System.Int64)" />
-      <Member Name="GetValue(System.Int64,System.Int64)" />
-      <Member Name="GetValue(System.Int64,System.Int64,System.Int64)" />
-      <Member Name="GetValue(System.Int64[])" />
-      <Member Name="IndexOf(System.Array,System.Object)" />
-      <Member Name="IndexOf(System.Array,System.Object,System.Int32)" />
-      <Member Name="IndexOf(System.Array,System.Object,System.Int32,System.Int32)" />
-      <Member Name="IndexOf&lt;T&gt;(T[],T)" />
-      <Member Name="IndexOf&lt;T&gt;(T[],T,System.Int32)" />
-      <Member Name="IndexOf&lt;T&gt;(T[],T,System.Int32,System.Int32)" />
-      <Member Name="Initialize" />
-      <Member Name="LastIndexOf(System.Array,System.Object)" />
-      <Member Name="LastIndexOf(System.Array,System.Object,System.Int32)" />
-      <Member Name="LastIndexOf(System.Array,System.Object,System.Int32,System.Int32)" />
-      <Member Name="LastIndexOf&lt;T&gt;(T[],T)" />
-      <Member Name="LastIndexOf&lt;T&gt;(T[],T,System.Int32)" />
-      <Member Name="LastIndexOf&lt;T&gt;(T[],T,System.Int32,System.Int32)" />
-      <Member Name="Resize&lt;T&gt;(T[]@,System.Int32)" />
-      <Member Name="Reverse(System.Array)" />
-      <Member Name="Reverse(System.Array,System.Int32,System.Int32)" />
-      <Member Name="Reverse&lt;T&gt;(T[])" />
-      <Member Name="Reverse&lt;T&gt;(T[],System.Int32,System.Int32)" />
-      <Member Name="SetValue(System.Object,System.Int32)" />
-      <Member Name="SetValue(System.Object,System.Int32,System.Int32)" />
-      <Member Name="SetValue(System.Object,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="SetValue(System.Object,System.Int32[])" />
-      <Member Name="SetValue(System.Object,System.Int64)" />
-      <Member Name="SetValue(System.Object,System.Int64,System.Int64)" />
-      <Member Name="SetValue(System.Object,System.Int64,System.Int64,System.Int64)" />
-      <Member Name="SetValue(System.Object,System.Int64[])" />
-      <Member Name="Sort(System.Array)" />
-      <Member Name="Sort(System.Array,System.Array)" />
-      <Member Name="Sort(System.Array,System.Array,System.Collections.IComparer)" />
-      <Member Name="Sort(System.Array,System.Array,System.Int32,System.Int32)" />
-      <Member Name="Sort(System.Array,System.Array,System.Int32,System.Int32,System.Collections.IComparer)" />
-      <Member Name="Sort(System.Array,System.Collections.IComparer)" />
-      <Member Name="Sort(System.Array,System.Int32,System.Int32)" />
-      <Member Name="Sort(System.Array,System.Int32,System.Int32,System.Collections.IComparer)" />
-      <Member Name="Sort&lt;T&gt;(T[])" />
-      <Member Name="Sort&lt;T&gt;(T[],System.Collections.Generic.IComparer&lt;T&gt;)" />
-      <Member Name="Sort&lt;T&gt;(T[],System.Comparison&lt;T&gt;)" />
-      <Member Name="Sort&lt;T&gt;(T[],System.Int32,System.Int32)" />
-      <Member Name="Sort&lt;T&gt;(T[],System.Int32,System.Int32,System.Collections.Generic.IComparer&lt;T&gt;)" />
-      <Member Name="Sort&lt;TKey,TValue&gt;(TKey[],TValue[])" />
-      <Member Name="Sort&lt;TKey,TValue&gt;(TKey[],TValue[],System.Collections.Generic.IComparer&lt;TKey&gt;)" />
-      <Member Name="Sort&lt;TKey,TValue&gt;(TKey[],TValue[],System.Int32,System.Int32)" />
-      <Member Name="Sort&lt;TKey,TValue&gt;(TKey[],TValue[],System.Int32,System.Int32,System.Collections.Generic.IComparer&lt;TKey&gt;)" />
-      <Member Name="TrueForAll&lt;T&gt;(T[],System.Predicate&lt;T&gt;)" />
-      <Member MemberType="Property" Name="IsFixedSize" />
-      <Member MemberType="Property" Name="IsReadOnly" />
-      <Member MemberType="Property" Name="IsSynchronized" />
-      <Member MemberType="Property" Name="Length" />
-      <Member MemberType="Property" Name="LongLength" />
-      <Member MemberType="Property" Name="Rank" />
-      <Member MemberType="Property" Name="SyncRoot" />
-      <Member Status="ImplRoot" Name="GetDataPtrOffsetInternal" /> <!-- EE -->
-    </Type>
-    <Type Name="System.ArraySegment&lt;T&gt;">
-        <Member Name="#ctor(T[])" />
-        <Member Name="#ctor(T[],System.Int32,System.Int32)" />
-        <Member Name="Equals(System.ArraySegment&lt;T&gt;)" />
-        <Member Name="Equals(System.Object)" />
-        <Member Name="get_Array" />
-        <Member Name="get_Count" />
-        <Member Name="get_Offset" />
-        <Member Name="GetEnumerator" />
-        <Member Name="GetHashCode" />
-        <Member Name="op_Equality(System.ArraySegment&lt;T&gt;,System.ArraySegment&lt;T&gt;)" />
-        <Member Name="op_Inequality(System.ArraySegment&lt;T&gt;,System.ArraySegment&lt;T&gt;)" />
-        <Member MemberType="Property" Name="Array" />
-        <Member MemberType="Property" Name="Count" />
-        <Member MemberType="Property" Name="Offset" />
-    </Type>
-    <Type Name="System.ArraySegment&lt;T&gt;+Enumerator">
-      <Member Name="Dispose" />
-      <Member Name="get_Current" />
-      <Member Name="MoveNext" />
-      <Member MemberType="Property" Name="Current" />
-      <Member Name="System.Collections.IEnumerator.Reset" />
-    </Type>
-    <Type Name="System.ArrayTypeMismatchException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.AssemblyLoadEventHandler">
-      <Member Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Name="BeginInvoke(System.Object,System.AssemblyLoadEventArgs,System.AsyncCallback,System.Object)" />
-      <Member Name="EndInvoke(System.IAsyncResult)" />
-      <Member Name="Invoke(System.Object,System.AssemblyLoadEventArgs)" />
-    </Type>
-    <Type Name="System.AssemblyLoadEventArgs">
-      <Member Name="#ctor(System.Reflection.Assembly)" />
-      <Member Name="get_LoadedAssembly" />
-      <Member MemberType="Property" Name="LoadedAssembly" />
-    </Type>
-    <Type Name="System.AsyncCallback">
-      <Member Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Name="BeginInvoke(System.IAsyncResult,System.AsyncCallback,System.Object)" />
-      <Member Name="EndInvoke(System.IAsyncResult)" />
-      <Member Name="Invoke(System.IAsyncResult)" />
-    </Type>
-    <Type Name="System.Attribute">
-      <Member Name="#ctor" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_TypeId" />
-      <Member Name="GetCustomAttribute(System.Reflection.Assembly,System.Type)" />
-      <Member Name="GetCustomAttribute(System.Reflection.Assembly,System.Type,System.Boolean)" />
-      <Member Name="GetCustomAttribute(System.Reflection.MemberInfo,System.Type)" />
-      <Member Name="GetCustomAttribute(System.Reflection.MemberInfo,System.Type,System.Boolean)" />
-      <Member Name="GetCustomAttribute(System.Reflection.Module,System.Type)" />
-      <Member Name="GetCustomAttribute(System.Reflection.Module,System.Type,System.Boolean)" />
-      <Member Name="GetCustomAttribute(System.Reflection.ParameterInfo,System.Type)" />
-      <Member Name="GetCustomAttribute(System.Reflection.ParameterInfo,System.Type,System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Reflection.Assembly)" />
-      <Member Name="GetCustomAttributes(System.Reflection.Assembly,System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Reflection.Assembly,System.Type)" />
-      <Member Name="GetCustomAttributes(System.Reflection.Assembly,System.Type,System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Reflection.MemberInfo)" />
-      <Member Name="GetCustomAttributes(System.Reflection.MemberInfo,System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Reflection.MemberInfo,System.Type)" />
-      <Member Name="GetCustomAttributes(System.Reflection.MemberInfo,System.Type,System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Reflection.Module)" />
-      <Member Name="GetCustomAttributes(System.Reflection.Module,System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Reflection.Module,System.Type)" />
-      <Member Name="GetCustomAttributes(System.Reflection.Module,System.Type,System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Reflection.ParameterInfo)" />
-      <Member Name="GetCustomAttributes(System.Reflection.ParameterInfo,System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Reflection.ParameterInfo,System.Type)" />
-      <Member Name="GetCustomAttributes(System.Reflection.ParameterInfo,System.Type,System.Boolean)" />
-      <Member Name="GetHashCode" />
-      <Member Name="IsDefaultAttribute" />
-      <Member Name="IsDefined(System.Reflection.Assembly,System.Type)" />
-      <Member Name="IsDefined(System.Reflection.Assembly,System.Type,System.Boolean)" />
-      <Member Name="IsDefined(System.Reflection.MemberInfo,System.Type)" />
-      <Member Name="IsDefined(System.Reflection.MemberInfo,System.Type,System.Boolean)" />
-      <Member Name="IsDefined(System.Reflection.Module,System.Type)" />
-      <Member Name="IsDefined(System.Reflection.Module,System.Type,System.Boolean)" />
-      <Member Name="IsDefined(System.Reflection.ParameterInfo,System.Type)" />
-      <Member Name="IsDefined(System.Reflection.ParameterInfo,System.Type,System.Boolean)" />
-      <Member Name="Match(System.Object)" />
-      <Member MemberType="Property" Name="TypeId" />
-    </Type>
-    <Type Name="System.AttributeTargets">
-      <Member MemberType="Field" Name="All" />
-      <Member MemberType="Field" Name="Assembly" />
-      <Member MemberType="Field" Name="Class" />
-      <Member MemberType="Field" Name="Constructor" />
-      <Member MemberType="Field" Name="Delegate" />
-      <Member MemberType="Field" Name="Enum" />
-      <Member MemberType="Field" Name="Event" />
-      <Member MemberType="Field" Name="Field" />
-      <Member MemberType="Field" Name="GenericParameter" />
-      <Member MemberType="Field" Name="Interface" />
-      <Member MemberType="Field" Name="Method" />
-      <Member MemberType="Field" Name="Module" />
-      <Member MemberType="Field" Name="Parameter" />
-      <Member MemberType="Field" Name="Property" />
-      <Member MemberType="Field" Name="ReturnValue" />
-      <Member MemberType="Field" Name="Struct" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.AttributeUsageAttribute">
-      <Member Name="#ctor(System.AttributeTargets)" />
-      <Member Name="get_AllowMultiple" />
-      <Member Name="get_Inherited" />
-      <Member Name="get_ValidOn" />
-      <Member Name="set_AllowMultiple(System.Boolean)" />
-      <Member Name="set_Inherited(System.Boolean)" />
-      <Member MemberType="Property" Name="AllowMultiple" />
-      <Member MemberType="Property" Name="Inherited" />
-      <Member MemberType="Property" Name="ValidOn" />
-    </Type>
-    <Type Name="System.Base64FormattingOptions">
-      <Member MemberType="Field" Name="InsertLineBreaks" />
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.BitConverter">
-      <Member Name="DoubleToInt64Bits(System.Double)" />
-      <Member Name="Int32BitsToSingle(System.Int32)" />
-      <Member Name="Int64BitsToDouble(System.Int64)" />
-      <Member MemberType="Field" Name="IsLittleEndian" />
-      <Member Name="GetBytes(System.Boolean)" />
-      <Member Name="GetBytes(System.Char)" />
-      <Member Name="GetBytes(System.Double)" />
-      <Member Name="GetBytes(System.Single)" />
-      <Member Name="GetBytes(System.Int32)" />
-      <Member Name="GetBytes(System.Int64)" />
-      <Member Name="GetBytes(System.Int16)" />
-      <Member Name="GetBytes(System.UInt32)" />
-      <Member Name="GetBytes(System.UInt64)" />
-      <Member Name="GetBytes(System.UInt16)" />
-      <Member Name="SingleToInt32Bits(System.Single)" />
-      <Member Name="ToBoolean(System.Byte[],System.Int32)" />
-      <Member Name="ToChar(System.Byte[],System.Int32)" />
-      <Member Name="ToDouble(System.Byte[],System.Int32)" />
-      <Member Name="ToInt16(System.Byte[],System.Int32)" />
-      <Member Name="ToInt32(System.Byte[],System.Int32)" />
-      <Member Name="ToInt64(System.Byte[],System.Int32)" />
-      <Member Name="ToSingle(System.Byte[],System.Int32)" />
-      <Member Name="ToString(System.Byte[])" />
-      <Member Name="ToString(System.Byte[],System.Int32)" />
-      <Member Name="ToString(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="ToUInt16(System.Byte[],System.Int32)" />
-      <Member Name="ToUInt32(System.Byte[],System.Int32)" />
-      <Member Name="ToUInt64(System.Byte[],System.Int32)" />
-    </Type>
-    <Type Name="System.BadImageFormatException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Status="ImplRoot" Name="#ctor(System.String,System.String,System.Int32)" />
-      <Member Name="#ctor(System.String,System.String)" />
-      <Member Name="#ctor(System.String,System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="get_FileName" />
-      <Member Name="get_FusionLog" />
-      <Member Name="GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member MemberType="Property" Name="FileName" />
-      <Member MemberType="Property" Name="FusionLog" />
-    </Type>
-    <Type Name="System.Boolean">
-      <Member MemberType="Field" Name="FalseString" />
-      <Member MemberType="Field" Name="TrueString" />
-      <Member Name="CompareTo(System.Boolean)" />
-      <Member Name="CompareTo(System.Object)" />
-      <Member Name="Equals(System.Boolean)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetTypeCode" />
-      <Member Name="Parse(System.String)" />
-      <Member Name="TryParse(System.String,System.Boolean@)" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.IFormatProvider)" />
-    </Type>
-    <Type Name="System.Buffer">
-      <Member Name="BlockCopy(System.Array,System.Int32,System.Array,System.Int32,System.Int32)" />
-      <Member Name="ByteLength(System.Array)" />
-      <Member Name="GetByte(System.Array,System.Int32)" />
-      <Member Name="SetByte(System.Array,System.Int32,System.Byte)" />
-      <Member Name="MemoryCopy(System.Void*,System.Void*,System.Int64,System.Int64)" />
-      <Member Name="MemoryCopy(System.Void*,System.Void*,System.UInt64,System.UInt64)" />
-    </Type>
-    <Type Name="System.Buffers.ArrayPool&lt;T&gt;">
-      <Member Name="#ctor" />
-      <Member Name="Create" />
-      <Member Name="Create(System.Int32,System.Int32)" />
-      <Member Name="get_Shared" />
-      <Member MemberType="Property" Name="Shared" />
-      <Member Name="Rent(System.Int32)" />
-      <Member Name="Return(T[],System.Boolean)" />
-    </Type>
-    <Type Name="System.Byte">
-      <Member MemberType="Field" Name="MaxValue" />
-      <Member MemberType="Field" Name="MinValue" />
-      <Member Name="CompareTo(System.Byte)" />
-      <Member Name="CompareTo(System.Object)" />
-      <Member Name="Equals(System.Byte)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetTypeCode" />
-      <Member Name="Parse(System.String)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)" />
-      <Member Name="Parse(System.String,System.IFormatProvider)" />
-      <Member Name="TryParse(System.String,System.Byte@)" />
-      <Member Name="TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Byte@)" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.IFormatProvider)" />
-      <Member Name="ToString(System.String)" />
-      <Member Name="ToString(System.String,System.IFormatProvider)" />
-    </Type>
-    <Type Name="System.Char">
-      <Member MemberType="Field" Name="MaxValue" />
-      <Member MemberType="Field" Name="MinValue" />
-      <Member Name="CompareTo(System.Char)" />
-      <Member Name="CompareTo(System.Object)" />
-      <Member Name="ConvertFromUtf32(System.Int32)" />
-      <Member Name="ConvertToUtf32(System.Char,System.Char)" />
-      <Member Name="ConvertToUtf32(System.String,System.Int32)" />
-      <Member Name="Equals(System.Char)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetNumericValue(System.Char)" />
-      <Member Name="GetNumericValue(System.String,System.Int32)" />
-      <Member Name="GetTypeCode" />
-      <Member Name="GetUnicodeCategory(System.Char)" />
-      <Member Name="GetUnicodeCategory(System.String,System.Int32)" />
-      <Member Name="IsControl(System.Char)" />
-      <Member Name="IsControl(System.String,System.Int32)" />
-      <Member Name="IsDigit(System.Char)" />
-      <Member Name="IsDigit(System.String,System.Int32)" />
-      <Member Name="IsHighSurrogate(System.Char)" />
-      <Member Name="IsHighSurrogate(System.String,System.Int32)" />
-      <Member Name="IsLetter(System.Char)" />
-      <Member Name="IsLetter(System.String,System.Int32)" />
-      <Member Name="IsLetterOrDigit(System.Char)" />
-      <Member Name="IsLetterOrDigit(System.String,System.Int32)" />
-      <Member Name="IsLower(System.Char)" />
-      <Member Name="IsLower(System.String,System.Int32)" />
-      <Member Name="IsLowSurrogate(System.Char)" />
-      <Member Name="IsLowSurrogate(System.String,System.Int32)" />
-      <Member Name="IsNumber(System.Char)" />
-      <Member Name="IsNumber(System.String,System.Int32)" />
-      <Member Name="IsPunctuation(System.Char)" />
-      <Member Name="IsPunctuation(System.String,System.Int32)" />
-      <Member Name="IsSeparator(System.Char)" />
-      <Member Name="IsSeparator(System.String,System.Int32)" />
-      <Member Name="IsSurrogate(System.Char)" />
-      <Member Name="IsSurrogate(System.String,System.Int32)" />
-      <Member Name="IsSurrogatePair(System.Char,System.Char)" />
-      <Member Name="IsSurrogatePair(System.String,System.Int32)" />
-      <Member Name="IsSymbol(System.Char)" />
-      <Member Name="IsSymbol(System.String,System.Int32)" />
-      <Member Name="IsUpper(System.Char)" />
-      <Member Name="IsUpper(System.String,System.Int32)" />
-      <Member Name="IsWhiteSpace(System.Char)" />
-      <Member Name="IsWhiteSpace(System.String,System.Int32)" />
-      <Member Name="Parse(System.String)" />
-      <Member Name="ToLower(System.Char)" />
-      <Member Name="ToLower(System.Char,System.Globalization.CultureInfo)" />
-      <Member Name="ToLowerInvariant(System.Char)" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.Char)" />
-      <Member Name="ToString(System.IFormatProvider)" />
-      <Member Name="ToUpper(System.Char)" />
-      <Member Name="ToUpper(System.Char,System.Globalization.CultureInfo)" />
-      <Member Name="ToUpperInvariant(System.Char)" />
-      <Member Name="TryParse(System.String,System.Char@)" />
-    </Type>
-    <Type Name="System.CharEnumerator">
-      <Member Name="Clone" />
-      <Member Name="Dispose" />
-      <Member Name="get_Current" />
-      <Member Name="MoveNext" />
-      <Member Name="Reset" />
-      <Member MemberType="Property" Name="Current" />
-      <Member Name="System.Collections.IEnumerator.get_Current" />
-      <Member MemberType="Property" Name="System.Collections.IEnumerator.Current" />
-    </Type>
-    <Type Name="System.CLSCompliantAttribute">
-      <Member Name="#ctor(System.Boolean)" />
-      <Member Name="get_IsCompliant" />
-      <Member MemberType="Property" Name="IsCompliant" />
-    </Type>
-    <Type Name="System.Collections.CollectionBase">
-      <Member Name="#ctor" />
-      <Member Name="get_List" />
-      <Member MemberType="Property" Name="List" />
-    </Type>
-    <Type Name="System.Collections.DictionaryEntry">
-      <Member Name="#ctor(System.Object,System.Object)" />
-      <Member Name="get_Key" />
-      <Member Name="get_Value" />
-      <Member Name="set_Key(System.Object)" />
-      <Member Name="set_Value(System.Object)" />
-      <Member Name="Deconstruct(System.Object@,System.Object@)" />
-      <Member MemberType="Property" Name="Key" />
-      <Member MemberType="Property" Name="Value" />
-    </Type>
-    <Type Name="System.Collections.Generic.Comparer&lt;T&gt;">
-      <Member Name="#ctor" />
-      <Member Name="Compare(T,T)" />
-      <Member Name="Create(System.Comparison&lt;T&gt;)"  />
-      <Member Name="get_Default" />
-      <Member MemberType="Property" Name="Default" />
-    </Type>
-    <Type Name="System.Collections.Generic.Dictionary&lt;TKey,TValue&gt;">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Collections.Generic.IDictionary&lt;TKey,TValue&gt;)" />
-      <Member Name="#ctor(System.Collections.Generic.IDictionary&lt;TKey,TValue&gt;,System.Collections.Generic.IEqualityComparer&lt;TKey&gt;)" />
-      <Member Name="#ctor(System.Collections.Generic.IEnumerable&lt;System.Collections.Generic.KeyValuePair&lt;TKey,TValue&gt;&gt;)" />
-      <Member Name="#ctor(System.Collections.Generic.IEnumerable&lt;System.Collections.Generic.KeyValuePair&lt;TKey,TValue&gt;&gt;,System.Collections.Generic.IEqualityComparer&lt;TKey&gt;)" />
-      <Member Name="#ctor(System.Collections.Generic.IEqualityComparer&lt;TKey&gt;)" />
-      <Member Name="#ctor(System.Int32)" />
-      <Member Name="#ctor(System.Int32,System.Collections.Generic.IEqualityComparer&lt;TKey&gt;)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="Add(TKey,TValue)" />
-      <Member Name="Clear" />
-      <Member Name="ContainsKey(TKey)" />
-      <Member Name="ContainsValue(TValue)" />
-      <Member Name="get_Comparer" />
-      <Member Name="get_Count" />
-      <Member Name="get_Item(TKey)" />
-      <Member Name="get_Keys" />
-      <Member Name="get_Values" />
-      <Member Name="GetEnumerator" />
-      <Member Name="GetValueOrDefault(TKey)" />
-      <Member Name="GetValueOrDefault(TKey,TValue)" />
-      <Member Name="Remove(TKey)" />
-      <Member Name="set_Item(TKey,TValue)" />
-      <Member Name="TryGetValue(TKey,TValue@)" />
-      <Member MemberType="Property" Name="Comparer" />
-      <Member MemberType="Property" Name="Count" />
-      <Member MemberType="Property" Name="Item(TKey)" />
-      <Member MemberType="Property" Name="Keys" />
-      <Member MemberType="Property" Name="Values" />
-    </Type>
-    <Type Name="System.Collections.Generic.Dictionary&lt;TKey,TValue&gt;+Enumerator">
-      <Member Name="Dispose" />
-      <Member Name="get_Current" />
-      <Member Name="MoveNext" />
-      <Member MemberType="Property" Name="Current" />
-    </Type>
-    <Type Name="System.Collections.Generic.Dictionary&lt;TKey,TValue&gt;+KeyCollection">
-      <Member Name="#ctor(System.Collections.Generic.Dictionary&lt;TKey,TValue&gt;)" />
-      <Member Name="CopyTo(TKey[],System.Int32)" />
-      <Member Name="get_Count" />
-      <Member Name="GetEnumerator" />
-      <Member MemberType="Property" Name="Count" />
-    </Type>
-    <Type Name="System.Collections.Generic.Dictionary&lt;TKey,TValue&gt;+KeyCollection+Enumerator">
-      <Member Name="Dispose" />
-      <Member Name="get_Current" />
-      <Member Name="MoveNext" />
-      <Member MemberType="Property" Name="Current" />
-    </Type>
-    <Type Name="System.Collections.Generic.Dictionary&lt;TKey,TValue&gt;+ValueCollection">
-      <Member Name="#ctor(System.Collections.Generic.Dictionary&lt;TKey,TValue&gt;)" />
-      <Member Name="CopyTo(TValue[],System.Int32)" />
-      <Member Name="get_Count" />
-      <Member Name="GetEnumerator" />
-      <Member MemberType="Property" Name="Count" />
-    </Type>
-    <Type Name="System.Collections.Generic.Dictionary&lt;TKey,TValue&gt;+ValueCollection+Enumerator">
-      <Member Name="Dispose" />
-      <Member Name="get_Current" />
-      <Member Name="MoveNext" />
-      <Member MemberType="Property" Name="Current" />
-    </Type>
-    <Type Name="System.Collections.Generic.EqualityComparer&lt;T&gt;">
-      <Member Name="#ctor" />
-      <Member Name="Equals(T,T)" />
-      <Member Name="get_Default" />
-      <Member Name="GetHashCode(T)" />
-      <Member MemberType="Property" Name="Default" />
-    </Type>
-    <Type Name="System.Collections.Generic.ICollection&lt;T&gt;">
-      <Member Name="Add(T)" />
-      <Member Name="Clear" />
-      <Member Name="Contains(T)" />
-      <Member Name="CopyTo(T[],System.Int32)" />
-      <Member Name="get_Count" />
-      <Member Name="get_IsReadOnly" />
-      <Member Name="Remove(T)" />
-      <Member MemberType="Property" Name="Count" />
-      <Member MemberType="Property" Name="IsReadOnly" />
-    </Type>
-    <Type Name="System.Collections.Generic.IComparer&lt;T&gt;">
-      <Member Name="Compare(T,T)" />
-    </Type>
-    <Type Name="System.Collections.Generic.IDictionary&lt;TKey,TValue&gt;">
-      <Member Name="Add(TKey,TValue)" />
-      <Member Name="ContainsKey(TKey)" />
-      <Member Name="get_Item(TKey)" />
-      <Member Name="get_Keys" />
-      <Member Name="get_Values" />
-      <Member Name="Remove(TKey)" />
-      <Member Name="set_Item(TKey,TValue)" />
-      <Member Name="TryGetValue(TKey,TValue@)" />
-      <Member MemberType="Property" Name="Item(TKey)" />
-      <Member MemberType="Property" Name="Keys" />
-      <Member MemberType="Property" Name="Values" />
-    </Type>
-    <Type Name="System.Collections.Generic.IEnumerable&lt;T&gt;">
-      <Member Name="GetEnumerator" />
-    </Type>
-    <Type Name="System.Collections.Generic.IEnumerator&lt;T&gt;">
-      <Member Name="get_Current" />
-      <Member MemberType="Property" Name="Current" />
-    </Type>
-    <Type Name="System.Collections.Generic.IEqualityComparer&lt;T&gt;">
-      <Member Name="Equals(T,T)" />
-      <Member Name="GetHashCode(T)" />
-    </Type>
-    <Type Name="System.Collections.Generic.IList&lt;T&gt;">
-      <Member Name="get_Item(System.Int32)" />
-      <Member Name="IndexOf(T)" />
-      <Member Name="Insert(System.Int32,T)" />
-      <Member Name="RemoveAt(System.Int32)" />
-      <Member Name="set_Item(System.Int32,T)" />
-      <Member MemberType="Property" Name="Item(System.Int32)" />
-    </Type>
-    <Type Name="System.Collections.Generic.IReadOnlyDictionary&lt;TKey,TValue&gt;">
-      <Member Name="ContainsKey(TKey)" />
-      <Member Name="get_Item(TKey)" />
-      <Member Name="get_Keys" />
-      <Member Name="get_Values" />
-      <Member Name="TryGetValue(TKey,TValue@)" />
-      <Member MemberType="Property" Name="Item(TKey)" />
-      <Member MemberType="Property" Name="Keys" />
-      <Member MemberType="Property" Name="Values" />
-    </Type>
-    <Type Name="System.Collections.Generic.IReadOnlyList&lt;T&gt;">
-      <Member Name="get_Item(System.Int32)" />
-      <Member MemberType="Property" Name="Item(System.Int32)" />
-    </Type>
-    <Type Name="System.Collections.Generic.IReadOnlyCollection&lt;T&gt;">
-      <Member MemberType="Property" Name="Count" />
-    </Type>
-    <Type Name="System.Collections.Generic.KeyNotFoundException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Collections.Generic.KeyValuePair">
-      <Member Name="Create&lt;TKey,TValue&gt;(TKey,TValue)" />
-    </Type>
-    <Type Name="System.Collections.Generic.KeyValuePair&lt;TKey,TValue&gt;">
-      <Member Name="#ctor(TKey,TValue)" />
-      <Member Name="get_Key" />
-      <Member Name="get_Value" />
-      <Member Name="ToString" />
-      <Member Name="Deconstruct(TKey@,TValue@)" />
-      <Member MemberType="Property" Name="Key" />
-      <Member MemberType="Property" Name="Value" />
-    </Type>
-    <Type Name="System.Collections.Generic.List&lt;T&gt;">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Collections.Generic.IEnumerable&lt;T&gt;)" />
-      <Member Name="#ctor(System.Int32)" />
-      <Member Name="Add(T)" />
-      <Member Name="AddRange(System.Collections.Generic.IEnumerable&lt;T&gt;)" />
-      <Member Name="AsReadOnly" />
-      <Member Name="BinarySearch(System.Int32,System.Int32,T,System.Collections.Generic.IComparer&lt;T&gt;)" />
-      <Member Name="BinarySearch(T)" />
-      <Member Name="BinarySearch(T,System.Collections.Generic.IComparer&lt;T&gt;)" />
-      <Member Name="Clear" />
-      <Member Name="Contains(T)" />
-      <Member Name="ConvertAll&lt;TOutput&gt;(System.Converter&lt;T,TOutput&gt;)" />
-      <Member Name="CopyTo(System.Int32,T[],System.Int32,System.Int32)" />
-      <Member Name="CopyTo(T[])" />
-      <Member Name="CopyTo(T[],System.Int32)" />
-      <Member Name="Exists(System.Predicate&lt;T&gt;)" />
-      <Member Name="Find(System.Predicate&lt;T&gt;)" />
-      <Member Name="FindAll(System.Predicate&lt;T&gt;)" />
-      <Member Name="FindIndex(System.Int32,System.Int32,System.Predicate&lt;T&gt;)" />
-      <Member Name="FindIndex(System.Int32,System.Predicate&lt;T&gt;)" />
-      <Member Name="FindIndex(System.Predicate&lt;T&gt;)" />
-      <Member Name="FindLast(System.Predicate&lt;T&gt;)" />
-      <Member Name="FindLastIndex(System.Int32,System.Int32,System.Predicate&lt;T&gt;)" />
-      <Member Name="FindLastIndex(System.Int32,System.Predicate&lt;T&gt;)" />
-      <Member Name="FindLastIndex(System.Predicate&lt;T&gt;)" />
-      <Member Name="ForEach(System.Action&lt;T&gt;)" />
-      <Member Name="get_Capacity" />
-      <Member Name="get_Count" />
-      <Member Name="get_Item(System.Int32)" />
-      <Member Name="GetEnumerator" />
-      <Member Name="GetRange(System.Int32,System.Int32)" />
-      <Member Name="IndexOf(T)" />
-      <Member Name="IndexOf(T,System.Int32)" />
-      <Member Name="IndexOf(T,System.Int32,System.Int32)" />
-      <Member Name="Insert(System.Int32,T)" />
-      <Member Name="InsertRange(System.Int32,System.Collections.Generic.IEnumerable&lt;T&gt;)" />
-      <Member Name="LastIndexOf(T)" />
-      <Member Name="LastIndexOf(T,System.Int32)" />
-      <Member Name="LastIndexOf(T,System.Int32,System.Int32)" />
-      <Member Name="Remove(T)" />
-      <Member Name="RemoveAll(System.Predicate&lt;T&gt;)" />
-      <Member Name="RemoveAt(System.Int32)" />
-      <Member Name="RemoveRange(System.Int32,System.Int32)" />
-      <Member Name="Reverse" />
-      <Member Name="Reverse(System.Int32,System.Int32)" />
-      <Member Name="set_Capacity(System.Int32)" />
-      <Member Name="set_Item(System.Int32,T)" />
-      <Member Name="Sort" />
-      <Member Name="Sort(System.Collections.Generic.IComparer&lt;T&gt;)" />
-      <Member Name="Sort(System.Comparison&lt;T&gt;)" />
-      <Member Name="Sort(System.Int32,System.Int32,System.Collections.Generic.IComparer&lt;T&gt;)" />
-      <Member Name="ToArray" />
-      <Member Name="TrimExcess" />
-      <Member MemberType="Property" Name="Capacity" />
-      <Member MemberType="Property" Name="Count" />
-      <Member MemberType="Property" Name="Item(System.Int32)" />
-      <Member Name="TrueForAll(System.Predicate&lt;T&gt;)" />
-    </Type>
-    <Type Name="System.Collections.Generic.List&lt;T&gt;+Enumerator">
-      <Member Name="Dispose" />
-      <Member Name="get_Current" />
-      <Member Name="MoveNext" />
-      <Member MemberType="Property" Name="Current" />
-      <Member Name="System.Collections.IEnumerator.Reset" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Collections.Generic.Mscorlib_CollectionDebugView&lt;T&gt;">
-      <Member Status="ImplRoot" Name="#ctor(System.Collections.Generic.ICollection&lt;T&gt;)" />
-      <Member Status="ImplRoot" Name="get_Items" />
-      <Member Status="ImplRoot" MemberType="Property" Name="Items" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Collections.Generic.Mscorlib_DictionaryKeyCollectionDebugView&lt;TKey,TValue&gt;">
-      <Member Status="ImplRoot" Name="#ctor(System.Collections.Generic.ICollection&lt;TKey&gt;)" />
-      <Member Status="ImplRoot" Name="get_Items" />
-      <Member Status="ImplRoot" MemberType="Property" Name="Items" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Collections.Generic.Mscorlib_DictionaryValueCollectionDebugView&lt;TKey,TValue&gt;">
-      <Member Status="ImplRoot" Name="#ctor(System.Collections.Generic.ICollection&lt;TValue&gt;)" />
-      <Member Status="ImplRoot" Name="get_Items" />
-      <Member Status="ImplRoot" MemberType="Property" Name="Items" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Collections.Generic.Mscorlib_DictionaryDebugView&lt;K,V&gt;">
-      <Member Status="ImplRoot" Name="#ctor(System.Collections.Generic.IDictionary&lt;K,V&gt;)" />
-      <Member Status="ImplRoot" Name="get_Items" />
-      <Member Status="ImplRoot" MemberType="Property" Name="Items" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Collections.Generic.Mscorlib_KeyedCollectionDebugView&lt;K,T&gt;">
-      <Member Status="ImplRoot" Name="#ctor(System.Collections.ObjectModel.KeyedCollection&lt;K,T&gt;)" />
-      <Member Status="ImplRoot" Name="get_Items" />
-      <Member Status="ImplRoot" MemberType="Property" Name="Items" />
-    </Type>
-    <Type Name="System.Collections.ICollection">
-      <Member Name="CopyTo(System.Array,System.Int32)" />
-      <Member Name="get_Count" />
-      <Member Name="get_IsSynchronized" />
-      <Member Name="get_SyncRoot" />
-      <Member MemberType="Property" Name="Count" />
-      <Member MemberType="Property" Name="IsSynchronized" />
-      <Member MemberType="Property" Name="SyncRoot" />
-    </Type>
-    <Type Name="System.Collections.IComparer">
-      <Member Name="Compare(System.Object,System.Object)" />
-    </Type>
-    <Type Name="System.Collections.IDictionary">
-      <Member Name="Add(System.Object,System.Object)" />
-      <Member Name="Clear" />
-      <Member Name="Contains(System.Object)" />
-      <Member Name="get_IsFixedSize" />
-      <Member Name="get_IsReadOnly" />
-      <Member Name="get_Item(System.Object)" />
-      <Member Name="get_Keys" />
-      <Member Name="get_Values" />
-      <Member Name="GetEnumerator" />
-      <Member Name="Remove(System.Object)" />
-      <Member Name="set_Item(System.Object,System.Object)" />
-      <Member MemberType="Property" Name="IsFixedSize" />
-      <Member MemberType="Property" Name="IsReadOnly" />
-      <Member MemberType="Property" Name="Item(System.Object)" />
-      <Member MemberType="Property" Name="Keys" />
-      <Member MemberType="Property" Name="Values" />
-    </Type>
-    <Type Name="System.Collections.IDictionaryEnumerator">
-      <Member Name="get_Entry" />
-      <Member Name="get_Key" />
-      <Member Name="get_Value" />
-      <Member MemberType="Property" Name="Entry" />
-      <Member MemberType="Property" Name="Key" />
-      <Member MemberType="Property" Name="Value" />
-    </Type>
-    <Type Name="System.Collections.IEnumerable">
-      <Member Name="GetEnumerator" />
-    </Type>
-    <Type Name="System.Collections.IEnumerator">
-      <Member Name="get_Current" />
-      <Member Name="MoveNext" />
-      <Member Name="Reset" />
-      <Member MemberType="Property" Name="Current" />
-    </Type>
-    <Type Name="System.Collections.IEqualityComparer">
-      <Member Name="Equals(System.Object,System.Object)" />
-      <Member Name="GetHashCode(System.Object)" />
-    </Type>
-    <Type Name="System.Collections.IList">
-      <Member Name="Add(System.Object)" />
-      <Member Name="Clear" />
-      <Member Name="Contains(System.Object)" />
-      <Member Name="get_IsFixedSize" />
-      <Member Name="get_IsReadOnly" />
-      <Member Name="get_Item(System.Int32)" />
-      <Member Name="IndexOf(System.Object)" />
-      <Member Name="Insert(System.Int32,System.Object)" />
-      <Member Name="Remove(System.Object)" />
-      <Member Name="RemoveAt(System.Int32)" />
-      <Member Name="set_Item(System.Int32,System.Object)" />
-      <Member MemberType="Property" Name="IsFixedSize" />
-      <Member MemberType="Property" Name="IsReadOnly" />
-      <Member MemberType="Property" Name="Item(System.Int32)" />
-    </Type>
-    <Type Name="System.Collections.IStructuralComparable">
-      <Member Name="CompareTo(System.Object,System.Collections.IComparer)" />
-    </Type>
-    <Type Name="System.Collections.IStructuralEquatable">
-      <Member Name="Equals(System.Object,System.Collections.IEqualityComparer)" />
-      <Member Name="GetHashCode(System.Collections.IEqualityComparer)" />
-    </Type>
-    <Type Name="System.Collections.ObjectModel.Collection&lt;T&gt;">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Collections.Generic.IList&lt;T&gt;)" />
-      <Member Name="Add(T)" />
-      <Member Name="Clear" />
-      <Member Name="ClearItems" />
-      <Member Name="Contains(T)" />
-      <Member Name="CopyTo(T[],System.Int32)" />
-      <Member Name="get_Count" />
-      <Member Name="get_Item(System.Int32)" />
-      <Member Name="get_Items" />
-      <Member Name="GetEnumerator" />
-      <Member Name="IndexOf(T)" />
-      <Member Name="Insert(System.Int32,T)" />
-      <Member Name="InsertItem(System.Int32,T)" />
-      <Member Name="Remove(T)" />
-      <Member Name="RemoveAt(System.Int32)" />
-      <Member Name="RemoveItem(System.Int32)" />
-      <Member Name="set_Item(System.Int32,T)" />
-      <Member Name="SetItem(System.Int32,T)" />
-      <Member MemberType="Property" Name="Count" />
-      <Member MemberType="Property" Name="Item(System.Int32)" />
-      <Member MemberType="Property" Name="Items" />
-    </Type>
-    <Type Name="System.Collections.ObjectModel.KeyedCollection&lt;TKey,TItem&gt;">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Collections.Generic.IEqualityComparer&lt;TKey&gt;)" />
-      <Member Name="#ctor(System.Collections.Generic.IEqualityComparer&lt;TKey&gt;,System.Int32)" />
-      <Member Name="ChangeItemKey(TItem,TKey)" />
-      <Member Name="ClearItems" />
-      <Member Name="Contains(TKey)" />
-      <Member Name="get_Comparer" />
-      <Member Name="get_Dictionary" />
-      <Member Name="get_Item(TKey)" />
-      <Member Name="GetKeyForItem(TItem)" />
-      <Member Name="InsertItem(System.Int32,TItem)" />
-      <Member Name="Remove(TKey)" />
-      <Member Name="RemoveItem(System.Int32)" />
-      <Member Name="SetItem(System.Int32,TItem)" />
-      <Member MemberType="Property" Name="Comparer" />
-      <Member MemberType="Property" Name="Dictionary" />
-      <Member MemberType="Property" Name="Item(TKey)" />
-    </Type>
-    <Type Name="System.Collections.ObjectModel.ReadOnlyCollection&lt;T&gt;">
-      <Member Name="#ctor(System.Collections.Generic.IList&lt;T&gt;)" />
-      <Member Name="Contains(T)" />
-      <Member Name="CopyTo(T[],System.Int32)" />
-      <Member Name="get_Count" />
-      <Member Name="get_Item(System.Int32)" />
-      <Member Name="get_Items" />
-      <Member Name="GetEnumerator" />
-      <Member Name="IndexOf(T)" />
-      <Member MemberType="Property" Name="Count" />
-      <Member MemberType="Property" Name="Item(System.Int32)" />
-      <Member MemberType="Property" Name="Items" />
-    </Type>
-
-    <Type Name="System.Collections.ObjectModel.ReadOnlyDictionary&lt;TKey,TValue&gt;">
-      <Member Name="#ctor(System.Collections.Generic.IDictionary&lt;TKey,TValue&gt;)" />
-      <Member Name="ContainsKey(TKey)" />
-      <Member Name="get_Count" />
-      <Member Name="get_Item(TKey)" />
-      <Member Name="GetEnumerator" />
-      <Member Name="TryGetValue(TKey,TValue@)" />
-      <Member MemberType="Property" Name="Count" />
-      <Member MemberType="Property" Name="Keys" />
-      <Member MemberType="Property" Name="Values" />
-      <Member MemberType="Property" Name="Dictionary" />
-      <Member MemberType="Property" Name="Item(TKey)" />
-    </Type>
-    <Type Name="System.GCCollectionMode">
-        <Member MemberType="Field" Name="Default" />
-        <Member MemberType="Field" Name="Optimized" />
-        <Member MemberType="Field" Name="Forced" />
-    </Type>
-
-    <Type Name="System.Comparison&lt;T&gt;">
-      <Member Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Name="BeginInvoke(T,T,System.AsyncCallback,System.Object)" />
-      <Member Name="EndInvoke(System.IAsyncResult)" />
-      <Member Name="Invoke(T,T)" />
-    </Type>
-    <Type Name="System.Runtime.Loader.AssemblyLoadContext">
-      <Member Name="#ctor" />
-      <Member MemberType="Property" Name="Default" />
-      <Member Name="GetAssemblyName(System.String)" />
-      <Member Name="GetLoadContext(System.Reflection.Assembly)" />
-      <Member Name="LoadFromAssemblyName(System.Reflection.AssemblyName)" />
-      <Member Name="Load(System.Reflection.AssemblyName)" />
-      <Member Name="LoadFromAssemblyPath(System.String)" />
-      <Member Name="LoadFromNativeImagePath(System.String,System.String)" />
-      <Member Name="LoadFromStream(System.IO.Stream)" />
-      <Member Name="LoadFromStream(System.IO.Stream,System.IO.Stream)" />
-      <Member Name="Resolve(System.IntPtr,System.Reflection.AssemblyName)" />
-      <Member Name="ResolveUsingResolvingEvent(System.IntPtr,System.Reflection.AssemblyName)" />
-      <Member Name="ResolveUnmanagedDll(System.String,System.IntPtr)" />
-      <Member Name="LoadUnmanagedDll(System.String)" />
-      <Member Name="LoadUnmanagedDllFromPath(System.String)" />
-      <Member Name="GetLoadedAssemblies" />
-      <Member Name="get_Default" />
-      <Member Name="SetProfileOptimizationRoot(System.String)" />
-      <Member Name="StartProfileOptimization(System.String)" />
-      <Member MemberType="Event" Name="AssemblyLoad" />
-      <Member MemberType="Event" Name="AssemblyResolve" />
-      <Member MemberType="Event" Name="Resolving" />
-      <Member MemberType="Event" Name="ResourceResolve" />
-      <Member MemberType="Event" Name="TypeResolve" />
-      <Member MemberType="Event" Name="Unloading" />
-    </Type>
-    <Type Name="System.Runtime.MemoryFailPoint">
-      <Member Name="#ctor(System.Int32)" />
-      <Member Name="Dispose" />
-      <Member Status="ImplRoot" Name="Finalize" />
-    </Type>
-    <Type Name="System.Reflection.Metadata.AssemblyExtensions">
-      <Member Name="TryGetRawMetadata(System.Reflection.Assembly,System.Byte*@,System.Int32@)"/>
-    </Type>
-    <Type Name="System.Convert">
-      <Member MemberType="Field" Name="DBNull" />
-      <Member Name="ChangeType(System.Object,System.Type)"  />
-      <Member Name="ChangeType(System.Object,System.Type,System.IFormatProvider)" />
-      <Member Name="ChangeType(System.Object,System.TypeCode)" />
-      <Member Name="ChangeType(System.Object,System.TypeCode,System.IFormatProvider)" />
-      <Member Name="FromBase64CharArray(System.Char[],System.Int32,System.Int32)" />
-      <Member Name="FromBase64String(System.String)" />
-      <Member Name="GetTypeCode(System.Object)" />
-      <Member Name="IsDBNull(System.Object)" />
-      <Member Name="ToBase64CharArray(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32)" />
-      <Member Name="ToBase64CharArray(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32,System.Base64FormattingOptions)" />
-      <Member Name="ToBase64String(System.Byte[])" />
-      <Member Name="ToBase64String(System.Byte[],System.Base64FormattingOptions)" />
-      <Member Name="ToBase64String(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="ToBase64String(System.Byte[],System.Int32,System.Int32,System.Base64FormattingOptions)" />
-      <Member Name="ToBoolean(System.Boolean)" />
-      <Member Name="ToBoolean(System.Byte)" />
-      <Member Name="ToBoolean(System.Char)" />
-      <Member Name="ToBoolean(System.DateTime)" />
-      <Member Name="ToBoolean(System.Decimal)" />
-      <Member Name="ToBoolean(System.Double)" />
-      <Member Name="ToBoolean(System.Int16)" />
-      <Member Name="ToBoolean(System.Int32)" />
-      <Member Name="ToBoolean(System.Int64)" />
-      <Member Name="ToBoolean(System.Object)" />
-      <Member Name="ToBoolean(System.Object,System.IFormatProvider)" />
-      <Member Name="ToBoolean(System.SByte)" />
-      <Member Name="ToBoolean(System.Single)" />
-      <Member Name="ToBoolean(System.String)" />
-      <Member Name="ToBoolean(System.String,System.IFormatProvider)" />
-      <Member Name="ToBoolean(System.UInt16)" />
-      <Member Name="ToBoolean(System.UInt32)" />
-      <Member Name="ToBoolean(System.UInt64)" />
-      <Member Name="ToByte(System.Boolean)" />
-      <Member Name="ToByte(System.Byte)" />
-      <Member Name="ToByte(System.Char)" />
-      <Member Name="ToByte(System.DateTime)" />
-      <Member Name="ToByte(System.Decimal)" />
-      <Member Name="ToByte(System.Double)" />
-      <Member Name="ToByte(System.Int16)" />
-      <Member Name="ToByte(System.Int32)" />
-      <Member Name="ToByte(System.Int64)" />
-      <Member Name="ToByte(System.Object)" />
-      <Member Name="ToByte(System.Object,System.IFormatProvider)" />
-      <Member Name="ToByte(System.SByte)" />
-      <Member Name="ToByte(System.Single)" />
-      <Member Name="ToByte(System.String)" />
-      <Member Name="ToByte(System.String,System.IFormatProvider)" />
-      <Member Name="ToByte(System.String,System.Int32)" />
-      <Member Name="ToByte(System.UInt16)" />
-      <Member Name="ToByte(System.UInt32)" />
-      <Member Name="ToByte(System.UInt64)" />
-      <Member Name="ToChar(System.Boolean)" />
-      <Member Name="ToChar(System.Byte)" />
-      <Member Name="ToChar(System.Char)" />
-      <Member Name="ToChar(System.DateTime)" />
-      <Member Name="ToChar(System.Decimal)" />
-      <Member Name="ToChar(System.Double)" />
-      <Member Name="ToChar(System.Int16)" />
-      <Member Name="ToChar(System.Int32)" />
-      <Member Name="ToChar(System.Int64)" />
-      <Member Name="ToChar(System.Object)" />
-      <Member Name="ToChar(System.Object,System.IFormatProvider)" />
-      <Member Name="ToChar(System.SByte)" />
-      <Member Name="ToChar(System.Single)" />
-      <Member Name="ToChar(System.String)" />
-      <Member Name="ToChar(System.String,System.IFormatProvider)" />
-      <Member Name="ToChar(System.UInt16)" />
-      <Member Name="ToChar(System.UInt32)" />
-      <Member Name="ToChar(System.UInt64)" />
-      <Member Name="ToDateTime(System.Boolean)" />
-      <Member Name="ToDateTime(System.Byte)" />
-      <Member Name="ToDateTime(System.Char)" />
-      <Member Name="ToDateTime(System.DateTime)" />
-      <Member Name="ToDateTime(System.Decimal)" />
-      <Member Name="ToDateTime(System.Double)" />
-      <Member Name="ToDateTime(System.Int16)" />
-      <Member Name="ToDateTime(System.Int32)" />
-      <Member Name="ToDateTime(System.Int64)" />
-      <Member Name="ToDateTime(System.Object)" />
-      <Member Name="ToDateTime(System.Object,System.IFormatProvider)" />
-      <Member Name="ToDateTime(System.SByte)" />
-      <Member Name="ToDateTime(System.Single)" />
-      <Member Name="ToDateTime(System.String)" />
-      <Member Name="ToDateTime(System.String,System.IFormatProvider)" />
-      <Member Name="ToDateTime(System.UInt16)" />
-      <Member Name="ToDateTime(System.UInt32)" />
-      <Member Name="ToDateTime(System.UInt64)" />
-      <Member Name="ToDecimal(System.Boolean)" />
-      <Member Name="ToDecimal(System.Byte)" />
-      <Member Name="ToDecimal(System.Char)" />
-      <Member Name="ToDecimal(System.DateTime)" />
-      <Member Name="ToDecimal(System.Decimal)" />
-      <Member Name="ToDecimal(System.Double)" />
-      <Member Name="ToDecimal(System.Int16)" />
-      <Member Name="ToDecimal(System.Int32)" />
-      <Member Name="ToDecimal(System.Int64)" />
-      <Member Name="ToDecimal(System.Object)" />
-      <Member Name="ToDecimal(System.Object,System.IFormatProvider)" />
-      <Member Name="ToDecimal(System.SByte)" />
-      <Member Name="ToDecimal(System.Single)" />
-      <Member Name="ToDecimal(System.String)" />
-      <Member Name="ToDecimal(System.String,System.IFormatProvider)" />
-      <Member Name="ToDecimal(System.UInt16)" />
-      <Member Name="ToDecimal(System.UInt32)" />
-      <Member Name="ToDecimal(System.UInt64)" />
-      <Member Name="ToDouble(System.Boolean)" />
-      <Member Name="ToDouble(System.Byte)" />
-      <Member Name="ToDouble(System.Char)" />
-      <Member Name="ToDouble(System.DateTime)" />
-      <Member Name="ToDouble(System.Decimal)" />
-      <Member Name="ToDouble(System.Double)" />
-      <Member Name="ToDouble(System.Int16)" />
-      <Member Name="ToDouble(System.Int32)" />
-      <Member Name="ToDouble(System.Int64)" />
-      <Member Name="ToDouble(System.Object)" />
-      <Member Name="ToDouble(System.Object,System.IFormatProvider)" />
-      <Member Name="ToDouble(System.SByte)" />
-      <Member Name="ToDouble(System.Single)" />
-      <Member Name="ToDouble(System.String)" />
-      <Member Name="ToDouble(System.String,System.IFormatProvider)" />
-      <Member Name="ToDouble(System.UInt16)" />
-      <Member Name="ToDouble(System.UInt32)" />
-      <Member Name="ToDouble(System.UInt64)" />
-      <Member Name="ToInt16(System.Boolean)" />
-      <Member Name="ToInt16(System.Byte)" />
-      <Member Name="ToInt16(System.Char)" />
-      <Member Name="ToInt16(System.DateTime)" />
-      <Member Name="ToInt16(System.Decimal)" />
-      <Member Name="ToInt16(System.Double)" />
-      <Member Name="ToInt16(System.Int16)" />
-      <Member Name="ToInt16(System.Int32)" />
-      <Member Name="ToInt16(System.Int64)" />
-      <Member Name="ToInt16(System.Object)" />
-      <Member Name="ToInt16(System.Object,System.IFormatProvider)" />
-      <Member Name="ToInt16(System.SByte)" />
-      <Member Name="ToInt16(System.Single)" />
-      <Member Name="ToInt16(System.String)" />
-      <Member Name="ToInt16(System.String,System.IFormatProvider)" />
-      <Member Name="ToInt16(System.String,System.Int32)" />
-      <Member Name="ToInt16(System.UInt16)" />
-      <Member Name="ToInt16(System.UInt32)" />
-      <Member Name="ToInt16(System.UInt64)" />
-      <Member Name="ToInt32(System.Boolean)" />
-      <Member Name="ToInt32(System.Byte)" />
-      <Member Name="ToInt32(System.Char)" />
-      <Member Name="ToInt32(System.DateTime)" />
-      <Member Name="ToInt32(System.Decimal)" />
-      <Member Name="ToInt32(System.Double)" />
-      <Member Name="ToInt32(System.Int16)" />
-      <Member Name="ToInt32(System.Int32)" />
-      <Member Name="ToInt32(System.Int64)" />
-      <Member Name="ToInt32(System.Object)" />
-      <Member Name="ToInt32(System.Object,System.IFormatProvider)" />
-      <Member Name="ToInt32(System.SByte)" />
-      <Member Name="ToInt32(System.Single)" />
-      <Member Name="ToInt32(System.String)" />
-      <Member Name="ToInt32(System.String,System.IFormatProvider)" />
-      <Member Name="ToInt32(System.String,System.Int32)" />
-      <Member Name="ToInt32(System.UInt16)" />
-      <Member Name="ToInt32(System.UInt32)" />
-      <Member Name="ToInt32(System.UInt64)" />
-      <Member Name="ToInt64(System.Boolean)" />
-      <Member Name="ToInt64(System.Byte)" />
-      <Member Name="ToInt64(System.Char)" />
-      <Member Name="ToInt64(System.DateTime)" />
-      <Member Name="ToInt64(System.Decimal)" />
-      <Member Name="ToInt64(System.Double)" />
-      <Member Name="ToInt64(System.Int16)" />
-      <Member Name="ToInt64(System.Int32)" />
-      <Member Name="ToInt64(System.Int64)" />
-      <Member Name="ToInt64(System.Object)" />
-      <Member Name="ToInt64(System.Object,System.IFormatProvider)" />
-      <Member Name="ToInt64(System.SByte)" />
-      <Member Name="ToInt64(System.Single)" />
-      <Member Name="ToInt64(System.String)" />
-      <Member Name="ToInt64(System.String,System.IFormatProvider)" />
-      <Member Name="ToInt64(System.String,System.Int32)" />
-      <Member Name="ToInt64(System.UInt16)" />
-      <Member Name="ToInt64(System.UInt32)" />
-      <Member Name="ToInt64(System.UInt64)" />
-      <Member Name="ToSByte(System.Boolean)" />
-      <Member Name="ToSByte(System.Byte)" />
-      <Member Name="ToSByte(System.Char)" />
-      <Member Name="ToSByte(System.DateTime)" />
-      <Member Name="ToSByte(System.Decimal)" />
-      <Member Name="ToSByte(System.Double)" />
-      <Member Name="ToSByte(System.Int16)" />
-      <Member Name="ToSByte(System.Int32)" />
-      <Member Name="ToSByte(System.Int64)" />
-      <Member Name="ToSByte(System.Object)" />
-      <Member Name="ToSByte(System.Object,System.IFormatProvider)" />
-      <Member Name="ToSByte(System.SByte)" />
-      <Member Name="ToSByte(System.Single)" />
-      <Member Name="ToSByte(System.String)" />
-      <Member Name="ToSByte(System.String,System.IFormatProvider)" />
-      <Member Name="ToSByte(System.String,System.Int32)" />
-      <Member Name="ToSByte(System.UInt16)" />
-      <Member Name="ToSByte(System.UInt32)" />
-      <Member Name="ToSByte(System.UInt64)" />
-      <Member Name="ToSingle(System.Boolean)" />
-      <Member Name="ToSingle(System.Byte)" />
-      <Member Name="ToSingle(System.Char)" />
-      <Member Name="ToSingle(System.DateTime)" />
-      <Member Name="ToSingle(System.Decimal)" />
-      <Member Name="ToSingle(System.Double)" />
-      <Member Name="ToSingle(System.Int16)" />
-      <Member Name="ToSingle(System.Int32)" />
-      <Member Name="ToSingle(System.Int64)" />
-      <Member Name="ToSingle(System.Object)" />
-      <Member Name="ToSingle(System.Object,System.IFormatProvider)" />
-      <Member Name="ToSingle(System.SByte)" />
-      <Member Name="ToSingle(System.Single)" />
-      <Member Name="ToSingle(System.String)" />
-      <Member Name="ToSingle(System.String,System.IFormatProvider)" />
-      <Member Name="ToSingle(System.UInt16)" />
-      <Member Name="ToSingle(System.UInt32)" />
-      <Member Name="ToSingle(System.UInt64)" />
-      <Member Name="ToString(System.Boolean)" />
-      <Member Name="ToString(System.Boolean,System.IFormatProvider)" />
-      <Member Name="ToString(System.Byte)" />
-      <Member Name="ToString(System.Byte,System.IFormatProvider)" />
-      <Member Name="ToString(System.Byte,System.Int32)" />
-      <Member Name="ToString(System.Char)" />
-      <Member Name="ToString(System.Char,System.IFormatProvider)" />
-      <Member Name="ToString(System.DateTime)" />
-      <Member Name="ToString(System.DateTime,System.IFormatProvider)" />
-      <Member Name="ToString(System.Decimal)" />
-      <Member Name="ToString(System.Decimal,System.IFormatProvider)" />
-      <Member Name="ToString(System.Double)" />
-      <Member Name="ToString(System.Double,System.IFormatProvider)" />
-      <Member Name="ToString(System.Int16)" />
-      <Member Name="ToString(System.Int16,System.IFormatProvider)" />
-      <Member Name="ToString(System.Int16,System.Int32)" />
-      <Member Name="ToString(System.Int32)" />
-      <Member Name="ToString(System.Int32,System.IFormatProvider)" />
-      <Member Name="ToString(System.Int32,System.Int32)" />
-      <Member Name="ToString(System.Int64)" />
-      <Member Name="ToString(System.Int64,System.IFormatProvider)" />
-      <Member Name="ToString(System.Int64,System.Int32)" />
-      <Member Name="ToString(System.Object)" />
-      <Member Name="ToString(System.Object,System.IFormatProvider)" />
-      <Member Name="ToString(System.SByte)" />
-      <Member Name="ToString(System.SByte,System.IFormatProvider)" />
-      <Member Name="ToString(System.Single)" />
-      <Member Name="ToString(System.Single,System.IFormatProvider)" />
-      <Member Name="ToString(System.String)" />
-      <Member Name="ToString(System.String,System.IFormatProvider)" />
-      <Member Name="ToString(System.UInt16)" />
-      <Member Name="ToString(System.UInt16,System.IFormatProvider)" />
-      <Member Name="ToString(System.UInt32)" />
-      <Member Name="ToString(System.UInt32,System.IFormatProvider)" />
-      <Member Name="ToString(System.UInt64)" />
-      <Member Name="ToString(System.UInt64,System.IFormatProvider)" />
-      <Member Name="ToUInt16(System.Boolean)" />
-      <Member Name="ToUInt16(System.Byte)" />
-      <Member Name="ToUInt16(System.Char)" />
-      <Member Name="ToUInt16(System.DateTime)" />
-      <Member Name="ToUInt16(System.Decimal)" />
-      <Member Name="ToUInt16(System.Double)" />
-      <Member Name="ToUInt16(System.Int16)" />
-      <Member Name="ToUInt16(System.Int32)" />
-      <Member Name="ToUInt16(System.Int64)" />
-      <Member Name="ToUInt16(System.Object)" />
-      <Member Name="ToUInt16(System.Object,System.IFormatProvider)" />
-      <Member Name="ToUInt16(System.SByte)" />
-      <Member Name="ToUInt16(System.Single)" />
-      <Member Name="ToUInt16(System.String)" />
-      <Member Name="ToUInt16(System.String,System.IFormatProvider)" />
-      <Member Name="ToUInt16(System.String,System.Int32)" />
-      <Member Name="ToUInt16(System.UInt16)" />
-      <Member Name="ToUInt16(System.UInt32)" />
-      <Member Name="ToUInt16(System.UInt64)" />
-      <Member Name="ToUInt32(System.Boolean)" />
-      <Member Name="ToUInt32(System.Byte)" />
-      <Member Name="ToUInt32(System.Char)" />
-      <Member Name="ToUInt32(System.DateTime)" />
-      <Member Name="ToUInt32(System.Decimal)" />
-      <Member Name="ToUInt32(System.Double)" />
-      <Member Name="ToUInt32(System.Int16)" />
-      <Member Name="ToUInt32(System.Int32)" />
-      <Member Name="ToUInt32(System.Int64)" />
-      <Member Name="ToUInt32(System.Object)" />
-      <Member Name="ToUInt32(System.Object,System.IFormatProvider)" />
-      <Member Name="ToUInt32(System.SByte)" />
-      <Member Name="ToUInt32(System.Single)" />
-      <Member Name="ToUInt32(System.String)" />
-      <Member Name="ToUInt32(System.String,System.IFormatProvider)" />
-      <Member Name="ToUInt32(System.String,System.Int32)" />
-      <Member Name="ToUInt32(System.UInt16)" />
-      <Member Name="ToUInt32(System.UInt32)" />
-      <Member Name="ToUInt32(System.UInt64)" />
-      <Member Name="ToUInt64(System.Boolean)" />
-      <Member Name="ToUInt64(System.Byte)" />
-      <Member Name="ToUInt64(System.Char)" />
-      <Member Name="ToUInt64(System.DateTime)" />
-      <Member Name="ToUInt64(System.Decimal)" />
-      <Member Name="ToUInt64(System.Double)" />
-      <Member Name="ToUInt64(System.Int16)" />
-      <Member Name="ToUInt64(System.Int32)" />
-      <Member Name="ToUInt64(System.Int64)" />
-      <Member Name="ToUInt64(System.Object)" />
-      <Member Name="ToUInt64(System.Object,System.IFormatProvider)" />
-      <Member Name="ToUInt64(System.SByte)" />
-      <Member Name="ToUInt64(System.Single)" />
-      <Member Name="ToUInt64(System.String)" />
-      <Member Name="ToUInt64(System.String,System.IFormatProvider)" />
-      <Member Name="ToUInt64(System.String,System.Int32)" />
-      <Member Name="ToUInt64(System.UInt16)" />
-      <Member Name="ToUInt64(System.UInt32)" />
-      <Member Name="ToUInt64(System.UInt64)" />
-    </Type>
-    <Type Name="System.Converter&lt;TInput,TOutput&gt;">
-      <Member Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Name="BeginInvoke(TInput,System.AsyncCallback,System.Object)" />
-      <Member Name="EndInvoke(System.IAsyncResult)" />
-      <Member Name="Invoke(TInput)" />
-    </Type>
-    <Type Name="System.DataMisalignedException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.DateTime">
-      <Member MemberType="Field" Name="MaxValue" />
-      <Member MemberType="Field" Name="MinValue" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.Int32,System.Globalization.Calendar)" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.DateTimeKind)" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar)" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.DateTimeKind)" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar)" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar,System.DateTimeKind)" />
-      <Member Name="#ctor(System.Int64)" />
-      <Member Name="#ctor(System.Int64,System.DateTimeKind)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="Add(System.TimeSpan)" />
-      <Member Name="AddDays(System.Double)" />
-      <Member Name="AddHours(System.Double)" />
-      <Member Name="AddMilliseconds(System.Double)" />
-      <Member Name="AddMinutes(System.Double)" />
-      <Member Name="AddMonths(System.Int32)" />
-      <Member Name="AddSeconds(System.Double)" />
-      <Member Name="AddTicks(System.Int64)" />
-      <Member Name="AddYears(System.Int32)" />
-      <Member Name="Compare(System.DateTime,System.DateTime)" />
-      <Member Name="CompareTo(System.DateTime)" />
-      <Member Name="CompareTo(System.Object)" />
-      <Member Name="DaysInMonth(System.Int32,System.Int32)" />
-      <Member Name="Equals(System.DateTime)" />
-      <Member Name="Equals(System.DateTime,System.DateTime)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="FromBinary(System.Int64)" />
-      <Member Name="FromFileTime(System.Int64)" />
-      <Member Name="FromFileTimeUtc(System.Int64)" />
-      <Member Name="FromOADate(System.Double)" />
-      <Member Name="get_Date" />
-      <Member Name="get_Day" />
-      <Member Name="get_DayOfWeek" />
-      <Member Name="get_DayOfYear" />
-      <Member Name="get_Hour" />
-      <Member Name="get_Kind" />
-      <Member Name="get_Millisecond" />
-      <Member Name="get_Minute" />
-      <Member Name="get_Month" />
-      <Member Name="get_Now" />
-      <Member Name="get_Second" />
-      <Member Name="get_Ticks" />
-      <Member Name="get_TimeOfDay" />
-      <Member Name="get_Today" />
-      <Member Name="get_UtcNow" />
-      <Member Name="get_Year" />
-      <Member Name="GetDateTimeFormats" />
-      <Member Name="GetDateTimeFormats(System.Char)" />
-      <Member Name="GetDateTimeFormats(System.Char,System.IFormatProvider)" />
-      <Member Name="GetDateTimeFormats(System.IFormatProvider)" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetTypeCode" />
-      <Member Name="IsDaylightSavingTime" />
-      <Member Name="IsLeapYear(System.Int32)" />
-      <Member Name="op_Addition(System.DateTime,System.TimeSpan)" />
-      <Member Name="op_Equality(System.DateTime,System.DateTime)" />
-      <Member Name="op_GreaterThan(System.DateTime,System.DateTime)" />
-      <Member Name="op_GreaterThanOrEqual(System.DateTime,System.DateTime)" />
-      <Member Name="op_Inequality(System.DateTime,System.DateTime)" />
-      <Member Name="op_LessThan(System.DateTime,System.DateTime)" />
-      <Member Name="op_LessThanOrEqual(System.DateTime,System.DateTime)" />
-      <Member Name="op_Subtraction(System.DateTime,System.DateTime)" />
-      <Member Name="op_Subtraction(System.DateTime,System.TimeSpan)" />
-      <Member Name="Parse(System.String)" />
-      <Member Name="Parse(System.String,System.IFormatProvider)" />
-      <Member Name="Parse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles)" />
-      <Member Name="ParseExact(System.String,System.String,System.IFormatProvider)" />
-      <Member Name="ParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles)" />
-      <Member Name="ParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles)" />
-      <Member Name="SpecifyKind(System.DateTime,System.DateTimeKind)" />
-      <Member Name="Subtract(System.DateTime)" />
-      <Member Name="Subtract(System.TimeSpan)" />
-      <Member Name="ToBinary" />
-      <Member Name="ToFileTime" />
-      <Member Name="ToFileTimeUtc" />
-      <Member Name="ToLocalTime" />
-      <Member Name="ToLongDateString" />
-      <Member Name="ToLongTimeString" />
-      <Member Name="ToOADate" />
-      <Member Name="ToShortDateString" />
-      <Member Name="ToShortTimeString" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.IFormatProvider)" />
-      <Member Name="ToString(System.String)" />
-      <Member Name="ToString(System.String,System.IFormatProvider)" />
-      <Member Name="ToUniversalTime" />
-      <Member Name="TryParse(System.String,System.DateTime@)" />
-      <Member Name="TryParse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTime@)" />
-      <Member Name="TryParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTime@)" />
-      <Member Name="TryParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTime@)" />
-      <Member MemberType="Property" Name="Date" />
-      <Member MemberType="Property" Name="Day" />
-      <Member MemberType="Property" Name="DayOfWeek" />
-      <Member MemberType="Property" Name="DayOfYear" />
-      <Member MemberType="Property" Name="Hour" />
-      <Member MemberType="Property" Name="Kind" />
-      <Member MemberType="Property" Name="Millisecond" />
-      <Member MemberType="Property" Name="Minute" />
-      <Member MemberType="Property" Name="Month" />
-      <Member MemberType="Property" Name="Now" />
-      <Member MemberType="Property" Name="Second" />
-      <Member MemberType="Property" Name="Ticks" />
-      <Member MemberType="Property" Name="TimeOfDay" />
-      <Member MemberType="Property" Name="Today" />
-      <Member MemberType="Property" Name="UtcNow" />
-      <Member MemberType="Property" Name="Year" />
-    </Type>
-    <Type Name="System.DateTimeKind">
-      <Member MemberType="Field" Name="Local" />
-      <Member MemberType="Field" Name="Unspecified" />
-      <Member MemberType="Field" Name="Utc" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.DateTimeOffset">
-      <Member MemberType="Field" Name="MaxValue" />
-      <Member MemberType="Field" Name="MinValue" />
-      <Member Name="#ctor(System.DateTime)" />
-      <Member Name="#ctor(System.DateTime,System.TimeSpan)" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.TimeSpan)" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.TimeSpan)" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Globalization.Calendar,System.TimeSpan)" />
-      <Member Name="#ctor(System.Int64,System.TimeSpan)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="Add(System.TimeSpan)" />
-      <Member Name="AddDays(System.Double)" />
-      <Member Name="AddHours(System.Double)" />
-      <Member Name="AddMilliseconds(System.Double)" />
-      <Member Name="AddMinutes(System.Double)" />
-      <Member Name="AddMonths(System.Int32)" />
-      <Member Name="AddSeconds(System.Double)" />
-      <Member Name="AddTicks(System.Int64)" />
-      <Member Name="AddYears(System.Int32)" />
-      <Member Name="Compare(System.DateTimeOffset,System.DateTimeOffset)" />
-      <Member Name="CompareTo(System.DateTimeOffset)" />
-      <Member Name="Equals(System.DateTimeOffset)" />
-      <Member Name="Equals(System.DateTimeOffset,System.DateTimeOffset)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="EqualsExact(System.DateTimeOffset)" />
-      <Member Name="FromFileTime(System.Int64)" />
-      <Member Name="FromUnixTimeSeconds(System.Int64)" />
-      <Member Name="FromUnixTimeMilliseconds(System.Int64)" />
-      <Member Name="get_DateTime" />
-      <Member Name="get_UtcDateTime" />
-      <Member Name="get_LocalDateTime" />
-      <Member Name="get_UtcTicks" />
-      <Member Name="get_Offset" />
-      <Member Name="get_Date" />
-      <Member Name="get_Day" />
-      <Member Name="get_DayOfWeek" />
-      <Member Name="get_DayOfYear" />
-      <Member Name="get_Hour" />
-      <Member Name="get_Millisecond" />
-      <Member Name="get_Minute" />
-      <Member Name="get_Month" />
-      <Member Name="get_Now" />
-      <Member Name="get_Second" />
-      <Member Name="get_Ticks" />
-      <Member Name="get_TimeOfDay" />
-      <Member Name="get_UtcNow" />
-      <Member Name="get_Year" />
-      <Member Name="GetHashCode" />
-      <Member Name="op_Addition(System.DateTimeOffset,System.TimeSpan)" />
-      <Member Name="op_Equality(System.DateTimeOffset,System.DateTimeOffset)" />
-      <Member Name="op_GreaterThan(System.DateTimeOffset,System.DateTimeOffset)" />
-      <Member Name="op_GreaterThanOrEqual(System.DateTimeOffset,System.DateTimeOffset)" />
-      <Member Name="op_Inequality(System.DateTimeOffset,System.DateTimeOffset)" />
-      <Member Name="op_LessThan(System.DateTimeOffset,System.DateTimeOffset)" />
-      <Member Name="op_LessThanOrEqual(System.DateTimeOffset,System.DateTimeOffset)" />
-      <Member Name="op_Subtraction(System.DateTimeOffset,System.DateTimeOffset)" />
-      <Member Name="op_Subtraction(System.DateTimeOffset,System.TimeSpan)" />
-      <Member Name="Parse(System.String)" />
-      <Member Name="Parse(System.String,System.IFormatProvider)" />
-      <Member Name="Parse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles)" />
-      <Member Name="ParseExact(System.String,System.String,System.IFormatProvider)" />
-      <Member Name="ParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles)" />
-      <Member Name="ParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles)" />
-      <Member Name="TryParse(System.String,System.DateTimeOffset@)" />
-      <Member Name="TryParse(System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTimeOffset@)" />
-      <Member Name="TryParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTimeOffset@)" />
-      <Member Name="TryParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.DateTimeStyles,System.DateTimeOffset@)" />
-      <Member Name="Subtract(System.DateTimeOffset)" />
-      <Member Name="Subtract(System.TimeSpan)" />
-      <Member Name="ToFileTime" />
-      <Member Name="ToUnixTimeSeconds" />
-      <Member Name="ToUnixTimeMilliseconds" />
-      <Member Name="ToLocalTime" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.IFormatProvider)" />
-      <Member Name="ToString(System.String)" />
-      <Member Name="ToString(System.String,System.IFormatProvider)" />
-      <Member Name="ToUniversalTime" />
-      <Member Name="ToOffset(System.TimeSpan)" />
-      <Member Name="op_Implicit(System.DateTime)" ReturnType="System.DateTimeOffset" />
-      <Member MemberType="Property" Name="DateTime" />
-      <Member MemberType="Property" Name="UtcDateTime" />
-      <Member MemberType="Property" Name="LocalDateTime" />
-      <Member MemberType="Property" Name="UtcTicks" />
-      <Member MemberType="Property" Name="Offset" />
-      <Member MemberType="Property" Name="Date" />
-      <Member MemberType="Property" Name="Day" />
-      <Member MemberType="Property" Name="DayOfWeek" />
-      <Member MemberType="Property" Name="DayOfYear" />
-      <Member MemberType="Property" Name="Hour" />
-      <Member MemberType="Property" Name="Millisecond" />
-      <Member MemberType="Property" Name="Minute" />
-      <Member MemberType="Property" Name="Month" />
-      <Member MemberType="Property" Name="Now" />
-      <Member MemberType="Property" Name="Second" />
-      <Member MemberType="Property" Name="Ticks" />
-      <Member MemberType="Property" Name="TimeOfDay" />
-      <Member MemberType="Property" Name="UtcNow" />
-      <Member MemberType="Property" Name="Year" />
-    </Type>
-    <Type Name="System.DayOfWeek">
-      <Member MemberType="Field" Name="Friday" />
-      <Member MemberType="Field" Name="Monday" />
-      <Member MemberType="Field" Name="Saturday" />
-      <Member MemberType="Field" Name="Sunday" />
-      <Member MemberType="Field" Name="Thursday" />
-      <Member MemberType="Field" Name="Tuesday" />
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="Wednesday" />
-    </Type>
-    <Type Name="System.DBNull" >
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member MemberType="Field" Name="Value" />
-      <Member Name="GetTypeCode" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.IFormatProvider)" />
-    </Type>
-    <Type Name="System.Diagnostics.StackFrame">
-      <Member MemberType="Field" Name="OFFSET_UNKNOWN" />
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Boolean)" />
-      <Member Name="#ctor(System.Int32)" />
-      <Member Name="#ctor(System.Int32,System.Boolean)" />
-      <Member Name="#ctor(System.String,System.Int32)" />
-      <Member Name="#ctor(System.String,System.Int32,System.Int32)" />
-      <Member Name="GetFileColumnNumber" />
-      <Member Name="GetFileLineNumber" />
-      <Member Name="GetFileName" />
-      <Member Name="GetILOffset" />
-      <Member Name="GetMethod" />
-      <Member Name="GetNativeOffset" />
-      <Member Name="ToString" />
-    </Type>
-    <Type Name="System.Diagnostics.StackTrace">
-      <Member MemberType="Field" Name="METHODS_TO_SKIP" />
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Boolean)" />
-      <Member Name="#ctor(System.Diagnostics.StackFrame)" />
-      <Member Name="#ctor(System.Exception)" />
-      <Member Name="#ctor(System.Exception,System.Boolean)" />
-      <Member Name="#ctor(System.Exception,System.Int32)" />
-      <Member Name="#ctor(System.Exception,System.Int32,System.Boolean)" />
-      <Member Name="#ctor(System.Int32)" />
-      <Member Name="#ctor(System.Int32,System.Boolean)" />
-      <Member Name="#ctor(System.Threading.Thread,System.Boolean)" />
-      <Member Name="get_FrameCount" />
-      <Member Name="GetFrame(System.Int32)" />
-      <Member Name="GetFrames" />
-      <Member Name="GetManagedStackTraceStringHelper(System.Boolean)"/>
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="FrameCount" />
-    </Type>
-    <Type Name="System.Decimal">
-      <Member MemberType="Field" Name="MaxValue" />
-      <Member MemberType="Field" Name="MinusOne" />
-      <Member MemberType="Field" Name="MinValue" />
-      <Member MemberType="Field" Name="One" />
-      <Member MemberType="Field" Name="Zero" />
-      <Member Name="#ctor(System.Double)" />
-      <Member Name="#ctor(System.Int32)" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.Int32,System.Boolean,System.Byte)" />
-      <Member Name="#ctor(System.Int32[])" />
-      <Member Name="#ctor(System.Int64)" />
-      <Member Name="#ctor(System.Single)" />
-      <Member Name="#ctor(System.UInt32)" />
-      <Member Name="#ctor(System.UInt64)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Currency)" /> <!-- EE - il stubs -->
-      <Member Name="Add(System.Decimal,System.Decimal)" />
-      <Member Name="Ceiling(System.Decimal)" />
-      <Member Name="Compare(System.Decimal,System.Decimal)" />
-      <Member Name="CompareTo(System.Decimal)" />
-      <Member Name="CompareTo(System.Object)" />
-      <Member Name="Divide(System.Decimal,System.Decimal)" />
-      <Member Name="Equals(System.Decimal)" />
-      <Member Name="Equals(System.Decimal,System.Decimal)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Floor(System.Decimal)" />
-      <Member Name="FromOACurrency(System.Int64)" />
-      <Member Name="GetBits(System.Decimal)" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetTypeCode" />
-      <Member Name="Multiply(System.Decimal,System.Decimal)" />
-      <Member Name="Negate(System.Decimal)" />
-      <Member Status="ImplRoot" Name="OnSerializing(System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="op_Addition(System.Decimal,System.Decimal)" />
-      <Member Name="op_Decrement(System.Decimal)" />
-      <Member Name="op_Division(System.Decimal,System.Decimal)" />
-      <Member Name="op_Equality(System.Decimal,System.Decimal)" />
-      <Member Name="op_Explicit(System.Decimal)" ReturnType="System.Byte" />
-      <Member Name="op_Explicit(System.Decimal)" ReturnType="System.Char" />
-      <Member Name="op_Explicit(System.Decimal)" ReturnType="System.Double" />
-      <Member Name="op_Explicit(System.Decimal)" ReturnType="System.Int16" />
-      <Member Name="op_Explicit(System.Decimal)" ReturnType="System.Int32" />
-      <Member Name="op_Explicit(System.Decimal)" ReturnType="System.Int64" />
-      <Member Name="op_Explicit(System.Decimal)" ReturnType="System.SByte" />
-      <Member Name="op_Explicit(System.Decimal)" ReturnType="System.Single" />
-      <Member Name="op_Explicit(System.Decimal)" ReturnType="System.UInt16" />
-      <Member Name="op_Explicit(System.Decimal)" ReturnType="System.UInt32" />
-      <Member Name="op_Explicit(System.Decimal)" ReturnType="System.UInt64" />
-      <Member Name="op_Explicit(System.Double)" ReturnType="System.Decimal" />
-      <Member Name="op_Explicit(System.Single)" ReturnType="System.Decimal" />
-      <Member Name="op_GreaterThan(System.Decimal,System.Decimal)" />
-      <Member Name="op_GreaterThanOrEqual(System.Decimal,System.Decimal)" />
-      <Member Name="op_Implicit(System.Byte)" ReturnType="System.Decimal" />
-      <Member Name="op_Implicit(System.Char)" ReturnType="System.Decimal" />
-      <Member Name="op_Implicit(System.Int16)" ReturnType="System.Decimal" />
-      <Member Name="op_Implicit(System.Int32)" ReturnType="System.Decimal" />
-      <Member Name="op_Implicit(System.Int64)" ReturnType="System.Decimal" />
-      <Member Name="op_Implicit(System.SByte)" ReturnType="System.Decimal" />
-      <Member Name="op_Implicit(System.UInt16)" ReturnType="System.Decimal" />
-      <Member Name="op_Implicit(System.UInt32)" ReturnType="System.Decimal" />
-      <Member Name="op_Implicit(System.UInt64)" ReturnType="System.Decimal" />
-      <Member Name="op_Increment(System.Decimal)" />
-      <Member Name="op_Inequality(System.Decimal,System.Decimal)" />
-      <Member Name="op_LessThan(System.Decimal,System.Decimal)" />
-      <Member Name="op_LessThanOrEqual(System.Decimal,System.Decimal)" />
-      <Member Name="op_Modulus(System.Decimal,System.Decimal)" />
-      <Member Name="op_Multiply(System.Decimal,System.Decimal)" />
-      <Member Name="op_Subtraction(System.Decimal,System.Decimal)" />
-      <Member Name="op_UnaryNegation(System.Decimal)" />
-      <Member Name="op_UnaryPlus(System.Decimal)" />
-      <Member Name="Parse(System.String)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)" />
-      <Member Name="Parse(System.String,System.IFormatProvider)" />
-      <Member Name="TryParse(System.String,System.Decimal@)" />
-      <Member Name="TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Decimal@)" />
-      <Member Name="Remainder(System.Decimal,System.Decimal)" />
-      <Member Name="Round(System.Decimal)" />
-      <Member Name="Round(System.Decimal,System.Int32)" />
-      <Member Name="Round(System.Decimal,System.Int32,System.MidpointRounding)" />
-      <Member Name="Round(System.Decimal,System.MidpointRounding)" />
-      <Member Name="Subtract(System.Decimal,System.Decimal)" />
-      <Member Name="ToByte(System.Decimal)" />
-      <Member Name="ToDouble(System.Decimal)" />
-      <Member Name="ToInt16(System.Decimal)" />
-      <Member Name="ToInt32(System.Decimal)" />
-      <Member Name="ToInt64(System.Decimal)" />
-      <Member Name="ToOACurrency(System.Decimal)" />
-      <Member Name="ToSByte(System.Decimal)" />
-      <Member Name="ToSingle(System.Decimal)" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.IFormatProvider)" />
-      <Member Name="ToString(System.String)" />
-      <Member Name="ToString(System.String,System.IFormatProvider)" />
-      <Member Name="ToUInt16(System.Decimal)" />
-      <Member Name="ToUInt32(System.Decimal)" />
-      <Member Name="ToUInt64(System.Decimal)" />
-      <Member Name="Truncate(System.Decimal)" />
-    </Type>
-    <Type Name="System.Delegate">
-      <Member Name="#ctor(System.Object,System.String)" />
-      <Member Name="#ctor(System.Type,System.String)" />
-      <Member Name="Clone" />
-      <Member Name="Combine(System.Delegate,System.Delegate)" />
-      <Member Name="Combine(System.Delegate[])" />
-      <Member Name="CombineImpl(System.Delegate)" />
-      <Member Name="CreateDelegate(System.Type,System.Object,System.Reflection.MethodInfo)" />
-      <Member Name="CreateDelegate(System.Type,System.Object,System.Reflection.MethodInfo,System.Boolean)" />
-      <Member Name="CreateDelegate(System.Type,System.Object,System.String)" />
-      <Member Name="CreateDelegate(System.Type,System.Object,System.String,System.Boolean)" />
-      <Member Name="CreateDelegate(System.Type,System.Object,System.String,System.Boolean,System.Boolean)" />
-      <Member Name="CreateDelegate(System.Type,System.Reflection.MethodInfo)" />
-      <Member Name="CreateDelegate(System.Type,System.Reflection.MethodInfo,System.Boolean)" />
-      <Member Name="CreateDelegate(System.Type,System.Type,System.String)" />
-      <Member Name="CreateDelegate(System.Type,System.Type,System.String,System.Boolean)" />
-      <Member Name="CreateDelegate(System.Type,System.Type,System.String,System.Boolean,System.Boolean)" />
-      <Member Name="DynamicInvoke(System.Object[])" />
-      <Member Name="DynamicInvokeImpl(System.Object[])" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_Method" />
-      <Member Name="get_Target" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetInvocationList" />
-      <Member Name="GetMethodImpl" />
-      <Member Name="op_Equality(System.Delegate,System.Delegate)" />
-      <Member Name="op_Inequality(System.Delegate,System.Delegate)" />
-      <Member Name="Remove(System.Delegate,System.Delegate)" />
-      <Member Name="RemoveAll(System.Delegate,System.Delegate)" />
-      <Member Name="RemoveImpl(System.Delegate)" />
-      <Member MemberType="Property" Name="Target" />
-      <Member MemberType="Property" Name="Method" />
-      <Member Status="ImplRoot" Name="DelegateConstruct(System.Object,System.IntPtr)" /> <!-- EE -->
-    </Type>
-    <Type Status="ImplRoot" Name="System.DelegateSerializationHolder">
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Diagnostics.ConditionalAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_ConditionString" />
-      <Member MemberType="Property" Name="ConditionString" />
-    </Type>
-    <Type Name="System.Diagnostics.DebuggableAttribute">
-      <Member Name="#ctor(System.Boolean,System.Boolean)" />
-      <Member Name="#ctor(System.Diagnostics.DebuggableAttribute+DebuggingModes)" />
-      <Member Name="get_IsJITTrackingEnabled" />
-      <Member Name="get_IsJITOptimizerDisabled" />
-      <Member Name="get_DebuggingFlags" />
-      <Member MemberType="Property" Name="IsJITTrackingEnabled" />
-      <Member MemberType="Property" Name="IsJITOptimizerDisabled" />
-      <Member MemberType="Property" Name="DebuggingFlags" />
-    </Type>
-    <Type Name="System.Diagnostics.DebuggableAttribute+DebuggingModes">
-      <Member MemberType="Field" Name="Default" />
-      <Member MemberType="Field" Name="DisableOptimizations" />
-      <Member MemberType="Field" Name="EnableEditAndContinue" />
-      <Member MemberType="Field" Name="IgnoreSymbolStoreSequencePoints" />
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Diagnostics.Debugger">
-      <Member MemberType="Field" Name="DefaultCategory" />
-      <Member Name="#ctor" />
-      <Member Name="Break" />
-      <Member Name="get_IsAttached" />
-      <Member Name="Launch" />
-      <Member Name="IsLogging" />
-      <Member Name="Log(System.Int32,System.String,System.String)" />
-      <Member MemberType="Property" Name="IsAttached" />
-      <Member Status="ImplRoot" Name="BreakCanThrow" /> <!-- EE -->
-      <Member Name="NotifyOfCrossThreadDependency" />
-    </Type>
-    <Type Name="System.Diagnostics.DebuggerBrowsableAttribute">
-      <Member Name="#ctor(System.Diagnostics.DebuggerBrowsableState)" />
-      <Member Name="get_State" />
-      <Member MemberType="Property" Name="State" />
-    </Type>
-    <Type Name="System.Diagnostics.DebuggerHiddenAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Diagnostics.DebuggerNonUserCodeAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Diagnostics.DebuggerStepThroughAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Diagnostics.DebuggerDisplayAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_Name" />
-      <Member Name="get_Target" />
-      <Member Name="get_TargetTypeName" />
-      <Member Name="get_Type" />
-      <Member Name="get_Value" />
-      <Member Name="set_Name(System.String)" />
-      <Member Name="set_Target(System.Type)" />
-      <Member Name="set_TargetTypeName(System.String)" />
-      <Member Name="set_Type(System.String)" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="Target" />
-      <Member MemberType="Property" Name="TargetTypeName" />
-      <Member MemberType="Property" Name="Type" />
-      <Member MemberType="Property" Name="Value" />
-    </Type>
-    <Type Name="System.Diagnostics.DebuggerTypeProxyAttribute">
-      <Member Name="#ctor(System.Type)" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_ProxyTypeName" />
-      <Member Name="get_Target" />
-      <Member Name="get_TargetTypeName" />
-      <Member Name="set_Target(System.Type)" />
-      <Member Name="set_TargetTypeName(System.String)" />
-      <Member MemberType="Property" Name="ProxyTypeName" />
-      <Member MemberType="Property" Name="Target" />
-      <Member MemberType="Property" Name="TargetTypeName" />
-    </Type>
-    <Type Name="System.DivideByZeroException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.DllNotFoundException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Double">
-      <Member MemberType="Field" Name="Epsilon" />
-      <Member MemberType="Field" Name="MaxValue" />
-      <Member MemberType="Field" Name="MinValue" />
-      <Member MemberType="Field" Name="NaN" />
-      <Member MemberType="Field" Name="NegativeInfinity" />
-      <Member MemberType="Field" Name="PositiveInfinity" />
-      <Member Name="CompareTo(System.Double)" />
-      <Member Name="CompareTo(System.Object)" />
-      <Member Name="Equals(System.Double)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetTypeCode" />
-      <Member Name="IsInfinity(System.Double)" />
-      <Member Name="IsNaN(System.Double)" />
-      <Member Name="IsNegativeInfinity(System.Double)" />
-      <Member Name="IsPositiveInfinity(System.Double)" />
-      <Member Name="op_Equality(System.Double,System.Double)" />
-      <Member Name="op_GreaterThan(System.Double,System.Double)" />
-      <Member Name="op_GreaterThanOrEqual(System.Double,System.Double)" />
-      <Member Name="op_Inequality(System.Double,System.Double)" />
-      <Member Name="op_LessThan(System.Double,System.Double)" />
-      <Member Name="op_LessThanOrEqual(System.Double,System.Double)" />
-      <Member Name="Parse(System.String)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)" />
-      <Member Name="Parse(System.String,System.IFormatProvider)" />
-      <Member Name="TryParse(System.String,System.Double@)" />
-      <Member Name="TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Double@)" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.IFormatProvider)" />
-      <Member Name="ToString(System.String)" />
-      <Member Name="ToString(System.String,System.IFormatProvider)" />
-    </Type>
-    <Type Name="System.DuplicateWaitObjectException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.String,System.String)" />
-    </Type>
-    <Type Name="System.EntryPointNotFoundException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Enum">
-      <Member Name="#ctor" />
-      <Member Name="CompareTo(System.Object)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Format(System.Type,System.Object,System.String)" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetName(System.Type,System.Object)" />
-      <Member Name="GetNames(System.Type)" />
-      <Member Name="GetTypeCode" />
-      <Member Name="GetValues(System.Type)" />
-      <Member Name="GetUnderlyingType(System.Type)" />
-      <Member Name="HasFlag(System.Enum)" />
-      <Member Name="IsDefined(System.Type,System.Object)" />
-      <Member Name="Parse(System.Type,System.String)" />
-      <Member Name="Parse(System.Type,System.String,System.Boolean)" />
-      <Member Name="Parse&lt;TEnum&gt;(System.String)" />
-      <Member Name="Parse&lt;TEnum&gt;(System.String,System.Boolean)" />
-      <Member Name="ToObject(System.Type,System.Byte)" />
-      <Member Name="ToObject(System.Type,System.Int16)" />
-      <Member Name="ToObject(System.Type,System.Int32)" />
-      <Member Name="ToObject(System.Type,System.Int64)" />
-      <Member Name="ToObject(System.Type,System.Object)" />
-      <Member Name="ToObject(System.Type,System.SByte)" />
-      <Member Name="ToObject(System.Type,System.UInt16)" />
-      <Member Name="ToObject(System.Type,System.UInt32)" />
-      <Member Name="ToObject(System.Type,System.UInt64)" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.IFormatProvider)" />
-      <Member Name="ToString(System.String)" />
-      <Member Name="ToString(System.String,System.IFormatProvider)" />
-      <Member Name="TryParse(System.Type,System.String,System.Object@)" />
-      <Member Name="TryParse(System.Type,System.String,System.Boolean,System.Object@)" />
-      <Member Name="TryParse&lt;TEnum&gt;(System.String,TEnum@)" />
-      <Member Name="TryParse&lt;TEnum&gt;(System.String,System.Boolean,TEnum@)" />
-    </Type>
-    <Type Name="System.Environment">
-      <Member Name="get_CurrentManagedThreadId"  />
-      <Member Name="get_MachineName"  />
-      <Member Name="get_ProcessorCount" />
-      <Member Name="get_StackTrace" />
-      <Member Name="GetEnvironmentVariable(System.String)" />
-      <Member Name="GetEnvironmentVariables" />
-      <Member Name="GetCommandLineArgs" />
-      <Member Name="SetEnvironmentVariable(System.String,System.String)" />
-      <Member Name="ExpandEnvironmentVariables(System.String)" />
-      <Member MemberType="Property" Name="ProcessorCount" />
-      <Member MemberType="Property" Name="CurrentManagedThreadId"  />
-      <Member MemberType="Property" Name="HasShutdownStarted" />
-      <Member MemberType="Property" Name="NewLine" />
-      <Member MemberType="Property" Name="StackTrace" />
-      <Member MemberType="Property" Name="TickCount" />
-      <Member MemberType="Property" Name="Version" />
-      <Member MemberType="Property" Name="ExitCode" />
-      <Member Status="ImplRoot" Name="GetResourceStringLocal(System.String)" />
-      <Member Status="ImplRoot" Name="SetCommandLineArgs(System.String[])" />
-      <Member Name="FailFast(System.String)"  />
-      <Member Name="FailFast(System.String,System.Exception)"  />
-      <Member Name="Exit(System.Int32)" />
-    </Type>
-    <Type Name="Internal.Runtime.Augments.EnvironmentAugments">
-      <Member MemberType="Property" Name="CurrentManagedThreadId"  />
-      <Member MemberType="Property" Name="ExitCode" />
-      <Member MemberType="Property" Name="HasShutdownStarted" />
-      <Member MemberType="Property" Name="StackTrace" />
-      <Member MemberType="Property" Name="TickCount" />
-      <Member Name="get_CurrentManagedThreadId"  />
-      <Member Name="get_ExitCode" />
-      <Member Name="set_ExitCode(System.Int32)" />
-      <Member Name="get_HasShutdownStarted"  />
-      <Member Name="get_StackTrace" />
-      <Member Name="get_TickCount" />
-      <Member Name="Exit(System.Int32)" />
-      <Member Name="FailFast(System.String,System.Exception)"  />
-      <Member Name="GetCommandLineArgs" />
-      <Member Name="GetEnvironmentVariable(System.String)" />
-      <Member Name="GetEnvironmentVariable(System.String,System.EnvironmentVariableTarget)" />
-      <Member Name="GetEnvironmentVariables" />
-      <Member Name="GetEnvironmentVariables(System.EnvironmentVariableTarget)" />
-      <Member Name="SetEnvironmentVariable(System.String,System.String)" />
-      <Member Name="SetEnvironmentVariable(System.String,System.String,System.EnvironmentVariableTarget)" />
-    </Type>
-    <Type Name="System.EventArgs">
-      <Member MemberType="Field" Name="Empty" />
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.EventHandler">
-      <Member Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Name="BeginInvoke(System.Object,System.EventArgs,System.AsyncCallback,System.Object)" />
-      <Member Name="EndInvoke(System.IAsyncResult)" />
-      <Member Name="Invoke(System.Object,System.EventArgs)" />
-    </Type>
-    <Type Name="System.EventHandler&lt;TEventArgs&gt;">
-      <Member Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Name="BeginInvoke(System.Object,TEventArgs,System.AsyncCallback,System.Object)" />
-      <Member Name="EndInvoke(System.IAsyncResult)" />
-      <Member Name="Invoke(System.Object,TEventArgs)" />
-    </Type>
-    <Type Name="System.Exception">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="get_Data" />
-      <Member Name="get_HelpLink" />
-      <Member Name="get_HResult" />
-      <Member Name="get_InnerException" />
-      <Member Name="get_Message" />
-      <Member Name="get_StackTrace" />
-      <Member Name="get_Source" />
-      <Member Name="get_TargetSite" />
-      <Member Name="GetBaseException" />
-      <Member Name="GetType" />
-      <Member Name="set_HelpLink(System.String)" />
-      <Member Name="set_HResult(System.Int32)" />
-      <Member Name="set_Source(System.String)" />
-      <Member Name="ToString" />
-      <Member Name="add_SerializeObjectState(System.EventHandler&lt;System.Runtime.Serialization.SafeSerializationEventArgs&gt;)" />
-      <Member Name="remove_SerializeObjectState(System.EventHandler&lt;System.Runtime.Serialization.SafeSerializationEventArgs&gt;)" />
-      <Member MemberType="Property" Name="Data" />
-      <Member MemberType="Property" Name="HelpLink" />
-      <Member MemberType="Property" Name="HResult" />
-      <Member MemberType="Property" Name="InnerException" />
-      <Member MemberType="Property" Name="Message" />
-      <Member MemberType="Property" Name="Source" />
-      <Member MemberType="Property" Name="StackTrace" />
-      <Member MemberType="Property" Name="TargetSite" />
-      <Member MemberType="Event" Name="SerializeObjectState" />
-      <Member Status="ImplRoot" Name="InternalToString" />
-      <Member Status="ImplRoot" Name="InternalPreserveStackTrace" />
-      <Member Status="ImplRoot" Name="OnDeserialized(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" MemberType="Field" Name="_remoteStackIndex" /> <!-- EE -->
-      <Member Status="ImplRoot" MemberType="Field" Name="_exceptionMethod" /> <!-- EE -->
-      <Member Status="ImplRoot" MemberType="Field" Name="_exceptionMethodString" /> <!-- EE -->
-      <Member Status="ImplRoot" MemberType="Field" Name="_source" /> <!-- EE -->
-      <Member Status="ImplRoot" MemberType="Field" Name="_xptrs" /> <!-- EE -->
-      <Member Status="ImplRoot" MemberType="Field" Name="_xcode" /> <!-- EE -->
-      <Member Status="ImplRoot" MemberType="Field" Name="_HResult" /> <!-- EE -->
-      <Member Status="ImplRoot" Name="AddExceptionDataForRestrictedErrorInfo(System.String,System.String,System.String,System.Object,System.Boolean)" Condition="FEATURE_COMINTEROP" />
-      <Member Status="ImplRoot" Name="TryGetRestrictedLanguageErrorObject(System.Object@)" Condition="FEATURE_COMINTEROP" />
-    </Type>
-    <Type Name="System.ExecutionEngineException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.FieldAccessException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.FlagsAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.FormatException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.FormattableString">
-      <Member Name="#ctor" />
-      <Member Name="get_Format" />
-      <Member MemberType="Property" Name="Format" />
-      <Member Name="GetArguments" />
-      <Member Name="get_ArgumentCount" />
-      <Member MemberType="Property" Name="ArgumentCount" />
-      <Member Name="GetArgument(System.Int32)" />
-      <Member Name="ToString(System.IFormatProvider)" />
-      <Member Name="Invariant(System.FormattableString)" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Func&lt;TResult&gt;">
-      <Member Status="ApiRoot" Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Status="ApiRoot" Name="BeginInvoke(System.AsyncCallback,System.Object)" />
-      <Member Status="ApiRoot" Name="EndInvoke(System.IAsyncResult)" />
-      <Member Status="ApiRoot" Name="Invoke" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Func&lt;T,TResult&gt;">
-      <Member Status="ApiRoot" Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Status="ApiRoot" Name="BeginInvoke(T,System.AsyncCallback,System.Object)" />
-      <Member Status="ApiRoot" Name="EndInvoke(System.IAsyncResult)" />
-      <Member Status="ApiRoot" Name="Invoke(T)" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Func&lt;T1,T2,TResult&gt;">
-      <Member Status="ApiRoot" Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Status="ApiRoot" Name="BeginInvoke(T1,T2,System.AsyncCallback,System.Object)" />
-      <Member Status="ApiRoot" Name="EndInvoke(System.IAsyncResult)" />
-      <Member Status="ApiRoot" Name="Invoke(T1,T2)" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Func&lt;T1,T2,T3,TResult&gt;">
-      <Member Status="ApiRoot" Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Status="ApiRoot" Name="BeginInvoke(T1,T2,T3,System.AsyncCallback,System.Object)" />
-      <Member Status="ApiRoot" Name="EndInvoke(System.IAsyncResult)" />
-      <Member Status="ApiRoot" Name="Invoke(T1,T2,T3)" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Func&lt;T1,T2,T3,T4,TResult&gt;">
-      <Member Status="ApiRoot" Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Status="ApiRoot" Name="BeginInvoke(T1,T2,T3,T4,System.AsyncCallback,System.Object)" />
-      <Member Status="ApiRoot" Name="EndInvoke(System.IAsyncResult)" />
-      <Member Status="ApiRoot" Name="Invoke(T1,T2,T3,T4)" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Func&lt;T1,T2,T3,T4,T5,TResult&gt;">
-      <Member Status="ApiRoot" Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Status="ApiRoot" Name="BeginInvoke(T1,T2,T3,T4,T5,System.AsyncCallback,System.Object)" />
-      <Member Status="ApiRoot" Name="EndInvoke(System.IAsyncResult)" />
-      <Member Status="ApiRoot" Name="Invoke(T1,T2,T3,T4,T5)" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Func&lt;T1,T2,T3,T4,T5,T6,TResult&gt;">
-      <Member Status="ApiRoot" Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Status="ApiRoot" Name="BeginInvoke(T1,T2,T3,T4,T5,T6,System.AsyncCallback,System.Object)" />
-      <Member Status="ApiRoot" Name="EndInvoke(System.IAsyncResult)" />
-      <Member Status="ApiRoot" Name="Invoke(T1,T2,T3,T4,T5,T6)" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Func&lt;T1,T2,T3,T4,T5,T6,T7,TResult&gt;">
-      <Member Status="ApiRoot" Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Status="ApiRoot" Name="BeginInvoke(T1,T2,T3,T4,T5,T6,T7,System.AsyncCallback,System.Object)" />
-      <Member Status="ApiRoot" Name="EndInvoke(System.IAsyncResult)" />
-      <Member Status="ApiRoot" Name="Invoke(T1,T2,T3,T4,T5,T6,T7)" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Func&lt;T1,T2,T3,T4,T5,T6,T7,T8,TResult&gt;">
-      <Member Status="ApiRoot" Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Status="ApiRoot" Name="BeginInvoke(T1,T2,T3,T4,T5,T6,T7,T8,System.AsyncCallback,System.Object)" />
-      <Member Status="ApiRoot" Name="EndInvoke(System.IAsyncResult)" />
-      <Member Status="ApiRoot" Name="Invoke(T1,T2,T3,T4,T5,T6,T7,T8)" />
-    </Type>
-    <Type Name="System.GC">
-      <Member Name="AddMemoryPressure(System.Int64)" />
-      <Member Name="CancelFullGCNotification" />
-      <Member Name="Collect" />
-      <Member Name="Collect(System.Int32)" />
-      <Member Name="Collect(System.Int32,System.GCCollectionMode)" />
-      <Member Name="Collect(System.Int32,System.GCCollectionMode,System.Boolean)" />
-      <Member Name="Collect(System.Int32,System.GCCollectionMode,System.Boolean,System.Boolean)" />
-      <Member Name="CollectionCount(System.Int32)" />
-      <Member Name="EndNoGCRegion" />
-      <Member Name="GetAllocatedBytesForCurrentThread" />
-      <Member Name="GetGeneration(System.Object)" />
-      <Member Name="GetGeneration(System.WeakReference)" />
-      <Member Name="get_MaxGeneration" />
-      <Member Name="GetTotalMemory(System.Boolean)" />
-      <Member Name="KeepAlive(System.Object)" />
-      <Member Name="RegisterForFullGCNotification(System.Int32,System.Int32)" />
-      <Member Name="RemoveMemoryPressure(System.Int64)" />
-      <Member Name="ReRegisterForFinalize(System.Object)" />
-      <Member Name="SuppressFinalize(System.Object)" />
-      <Member Name="TryStartNoGCRegion(System.Int64)" />
-      <Member Name="TryStartNoGCRegion(System.Int64,System.Boolean)" />
-      <Member Name="TryStartNoGCRegion(System.Int64,System.Int64)" />
-      <Member Name="TryStartNoGCRegion(System.Int64,System.Int64,System.Boolean)" />
-      <Member Name="WaitForFullGCApproach" />
-      <Member Name="WaitForFullGCApproach(System.Int32)" />
-      <Member Name="WaitForFullGCComplete" />
-      <Member Name="WaitForFullGCComplete(System.Int32)" />
-      <Member Name="WaitForPendingFinalizers" />
-      <Member MemberType="Property" Name="MaxGeneration" />
-    </Type>
-    <Type Name="System.GCNotificationStatus">
-      <Member MemberType="Field" Name="Canceled" />
-      <Member MemberType="Field" Name="Failed" />
-      <Member MemberType="Field" Name="NotApplicable" />
-      <Member MemberType="Field" Name="Succeeded" />
-      <Member MemberType="Field" Name="Timeout" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Globalization.Calendar">
-      <Member MemberType="Field" Name="CurrentEra" />
-      <Member Name="#ctor" />
-      <Member Name="AddDays(System.DateTime,System.Int32)" />
-      <Member Name="AddHours(System.DateTime,System.Int32)" />
-      <Member Name="AddMilliseconds(System.DateTime,System.Double)" />
-      <Member Name="AddMinutes(System.DateTime,System.Int32)" />
-      <Member Name="AddMonths(System.DateTime,System.Int32)" />
-      <Member Name="AddSeconds(System.DateTime,System.Int32)" />
-      <Member Name="AddWeeks(System.DateTime,System.Int32)" />
-      <Member Name="AddYears(System.DateTime,System.Int32)" />
-      <Member Name="Clone" />
-      <Member Name="get_Eras" />
-      <Member Name="get_IsReadOnly" />
-      <Member Name="get_MaxSupportedDateTime" />
-      <Member Name="get_MinSupportedDateTime" />
-      <Member Name="get_TwoDigitYearMax" />
-      <Member Name="GetDayOfMonth(System.DateTime)" />
-      <Member Name="GetDayOfWeek(System.DateTime)" />
-      <Member Name="GetDayOfYear(System.DateTime)" />
-      <Member Name="GetDaysInMonth(System.Int32,System.Int32)" />
-      <Member Name="GetDaysInMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="GetDaysInYear(System.Int32)" />
-      <Member Name="GetDaysInYear(System.Int32,System.Int32)" />
-      <Member Name="GetEra(System.DateTime)" />
-      <Member Name="GetHour(System.DateTime)" />
-      <Member Name="GetLeapMonth(System.Int32)" />
-      <Member Name="GetMilliseconds(System.DateTime)" />
-      <Member Name="GetMinute(System.DateTime)" />
-      <Member Name="GetMonth(System.DateTime)" />
-      <Member Name="GetMonthsInYear(System.Int32)" />
-      <Member Name="GetMonthsInYear(System.Int32,System.Int32)" />
-      <Member Name="GetSecond(System.DateTime)" />
-      <Member Name="GetWeekOfYear(System.DateTime,System.Globalization.CalendarWeekRule,System.DayOfWeek)" />
-      <Member Name="GetYear(System.DateTime)" />
-      <Member Name="IsLeapDay(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapMonth(System.Int32,System.Int32)" />
-      <Member Name="IsLeapMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapYear(System.Int32)" />
-      <Member Name="IsLeapYear(System.Int32,System.Int32)" />
-      <Member Name="ReadOnly(System.Globalization.Calendar)" />
-      <Member Name="set_TwoDigitYearMax(System.Int32)" />
-      <Member Name="ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="ToFourDigitYear(System.Int32)" />
-      <Member MemberType="Property" Name="Eras" />
-      <Member MemberType="Property" Name="IsReadOnly" />
-      <Member MemberType="Property" Name="MaxSupportedDateTime" />
-      <Member MemberType="Property" Name="MinSupportedDateTime" />
-      <Member MemberType="Property" Name="TwoDigitYearMax" />
-      <Member Status="ImplRoot" MemberType="Field" Name="CAL_GREGORIAN" Condition="not FEATURE_COREFX_GLOBALIZATION" />
-      <Member Status="ImplRoot" MemberType="Field" Name="CAL_GREGORIAN_ARABIC" Condition="not FEATURE_COREFX_GLOBALIZATION" />
-      <Member Status="ImplRoot" MemberType="Field" Name="CAL_GREGORIAN_ME_FRENCH" Condition="not FEATURE_COREFX_GLOBALIZATION" />
-      <Member Status="ImplRoot" MemberType="Field" Name="CAL_GREGORIAN_US" Condition="not FEATURE_COREFX_GLOBALIZATION" />
-      <Member Status="ImplRoot" MemberType="Field" Name="CAL_GREGORIAN_XLIT_ENGLISH" Condition="not FEATURE_COREFX_GLOBALIZATION" />
-      <Member Status="ImplRoot" MemberType="Field" Name="CAL_GREGORIAN_XLIT_FRENCH" Condition="not FEATURE_COREFX_GLOBALIZATION" />
-    </Type>
-    <Type Name="System.Globalization.CalendarAlgorithmType">
-      <Member MemberType="Field" Name="LunarCalendar" />
-      <Member MemberType="Field" Name="LunisolarCalendar" />
-      <Member MemberType="Field" Name="SolarCalendar" />
-      <Member MemberType="Field" Name="Unknown" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Globalization.CalendarWeekRule">
-      <Member MemberType="Field" Name="FirstDay" />
-      <Member MemberType="Field" Name="FirstFourDayWeek" />
-      <Member MemberType="Field" Name="FirstFullWeek" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Globalization.CharUnicodeInfo">
-      <Member Name="GetDecimalDigitValue(System.Char)" />
-      <Member Name="GetDecimalDigitValue(System.String,System.Int32)" />
-      <Member Name="GetDigitValue(System.Char)" />
-      <Member Name="GetDigitValue(System.String,System.Int32)" />
-      <Member Name="GetNumericValue(System.Char)" />
-      <Member Name="GetNumericValue(System.String,System.Int32)" />
-      <Member Name="GetUnicodeCategory(System.Char)" />
-      <Member Name="GetUnicodeCategory(System.String,System.Int32)" />
-    </Type>
-    <Type Name="System.Globalization.ChineseLunisolarCalendar">
-      <Member MemberType="Field" Name="ChineseEra" />
-      <Member Name="#ctor" />
-      <Member Name="get_DaysInYearBeforeMinSupportedYear" />
-      <Member Name="get_Eras" />
-      <Member Name="get_MaxSupportedDateTime" />
-      <Member Name="get_MinSupportedDateTime" />
-      <Member Name="GetEra(System.DateTime)" />
-      <Member MemberType="Property" Name="DaysInYearBeforeMinSupportedYear" />
-      <Member MemberType="Property" Name="Eras" />
-      <Member MemberType="Property" Name="MaxSupportedDateTime" />
-      <Member MemberType="Property" Name="MinSupportedDateTime" />
-    </Type>
-    <Type Name="System.Globalization.CompareInfo">
-      <Member Name="Compare(System.String,System.Int32,System.Int32,System.String,System.Int32,System.Int32)" />
-      <Member Name="Compare(System.String,System.Int32,System.Int32,System.String,System.Int32,System.Int32,System.Globalization.CompareOptions)" />
-      <Member Name="Compare(System.String,System.Int32,System.String,System.Int32)" />
-      <Member Name="Compare(System.String,System.Int32,System.String,System.Int32,System.Globalization.CompareOptions)" />
-      <Member Name="Compare(System.String,System.String)" />
-      <Member Name="Compare(System.String,System.String,System.Globalization.CompareOptions)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_LCID" />
-      <Member Name="get_Name" />
-      <Member Name="get_Version" />
-      <Member Name="GetCompareInfo(System.Int32)" />
-      <Member Name="GetCompareInfo(System.Int32,System.Reflection.Assembly)" />
-      <Member Name="GetCompareInfo(System.String)" />
-      <Member Name="GetCompareInfo(System.String,System.Reflection.Assembly)" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetHashCode(System.String,System.Globalization.CompareOptions)" />
-      <Member Name="GetSortKey(System.String)" />
-      <Member Name="GetSortKey(System.String,System.Globalization.CompareOptions)" />
-      <Member Name="IndexOf(System.String,System.Char)" />
-      <Member Name="IndexOf(System.String,System.Char,System.Globalization.CompareOptions)" />
-      <Member Name="IndexOf(System.String,System.Char,System.Int32)" />
-      <Member Name="IndexOf(System.String,System.Char,System.Int32,System.Globalization.CompareOptions)" />
-      <Member Name="IndexOf(System.String,System.Char,System.Int32,System.Int32)" />
-      <Member Name="IndexOf(System.String,System.Char,System.Int32,System.Int32,System.Globalization.CompareOptions)" />
-      <Member Name="IndexOf(System.String,System.String)" />
-      <Member Name="IndexOf(System.String,System.String,System.Globalization.CompareOptions)" />
-      <Member Name="IndexOf(System.String,System.String,System.Int32)" />
-      <Member Name="IndexOf(System.String,System.String,System.Int32,System.Globalization.CompareOptions)" />
-      <Member Name="IndexOf(System.String,System.String,System.Int32,System.Int32)" />
-      <Member Name="IndexOf(System.String,System.String,System.Int32,System.Int32,System.Globalization.CompareOptions)" />
-      <Member Name="IsPrefix(System.String,System.String)" />
-      <Member Name="IsPrefix(System.String,System.String,System.Globalization.CompareOptions)" />
-      <Member Name="IsSortable(System.Char)" />
-      <Member Name="IsSortable(System.String)" />
-      <Member Name="IsSuffix(System.String,System.String)" />
-      <Member Name="IsSuffix(System.String,System.String,System.Globalization.CompareOptions)" />
-      <Member Name="LastIndexOf(System.String,System.Char)" />
-      <Member Name="LastIndexOf(System.String,System.Char,System.Globalization.CompareOptions)" />
-      <Member Name="LastIndexOf(System.String,System.Char,System.Int32)" />
-      <Member Name="LastIndexOf(System.String,System.Char,System.Int32,System.Globalization.CompareOptions)" />
-      <Member Name="LastIndexOf(System.String,System.Char,System.Int32,System.Int32)" />
-      <Member Name="LastIndexOf(System.String,System.Char,System.Int32,System.Int32,System.Globalization.CompareOptions)" />
-      <Member Name="LastIndexOf(System.String,System.String)" />
-      <Member Name="LastIndexOf(System.String,System.String,System.Globalization.CompareOptions)" />
-      <Member Name="LastIndexOf(System.String,System.String,System.Int32)" />
-      <Member Name="LastIndexOf(System.String,System.String,System.Int32,System.Globalization.CompareOptions)" />
-      <Member Name="LastIndexOf(System.String,System.String,System.Int32,System.Int32)" />
-      <Member Name="LastIndexOf(System.String,System.String,System.Int32,System.Int32,System.Globalization.CompareOptions)" />
-      <Member Status="ImplRoot" Name="OnDeserialized(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="OnDeserializing(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="OnSerializing(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="System.Runtime.Serialization.IDeserializationCallback.OnDeserialization(System.Object)" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="LCID" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="Version" />
-    </Type>
-    <Type Name="System.Globalization.CompareOptions">
-      <Member MemberType="Field" Name="IgnoreCase" />
-      <Member MemberType="Field" Name="IgnoreKanaType" />
-      <Member MemberType="Field" Name="IgnoreNonSpace" />
-      <Member MemberType="Field" Name="IgnoreSymbols" />
-      <Member MemberType="Field" Name="IgnoreWidth" />
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="Ordinal" />
-      <Member MemberType="Field" Name="OrdinalIgnoreCase" />
-      <Member MemberType="Field" Name="StringSort" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Globalization.CultureInfo">
-      <Member Name="#ctor(System.Int32)" />
-      <Member Name="#ctor(System.Int32,System.Boolean)" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Boolean)" />
-      <Member Name="ClearCachedData" />
-      <Member Name="Clone" />
-      <Member Name="CreateSpecificCulture(System.String)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_Calendar" />
-      <Member Name="get_CompareInfo" />
-      <Member Name="get_CurrentCulture" />
-      <Member Name="get_CurrentUICulture" />
-      <Member Name="get_CultureTypes" />
-      <Member Name="get_DefaultThreadCurrentCulture" />
-      <Member Name="get_DefaultThreadCurrentUICulture" />
-      <Member Name="get_DateTimeFormat" />
-      <Member Name="get_DisplayName" />
-      <Member Name="get_EnglishName" />
-      <Member Name="get_IetfLanguageTag" />
-      <Member Name="get_InstalledUICulture" />
-      <Member Name="get_InvariantCulture" />
-      <Member Name="get_IsNeutralCulture" />
-      <Member Name="get_IsReadOnly" />
-      <Member Name="get_KeyboardLayoutId" />
-      <Member Name="get_LCID" />
-      <Member Name="get_Name" />
-      <Member Name="get_NativeName" />
-      <Member Name="get_NumberFormat" />
-      <Member Name="get_OptionalCalendars" />
-      <Member Name="get_Parent" />
-      <Member Name="get_TextInfo" />
-      <Member Name="get_ThreeLetterISOLanguageName" />
-      <Member Name="get_ThreeLetterWindowsLanguageName" />
-      <Member Name="get_TwoLetterISOLanguageName" />
-      <Member Name="get_UseUserOverride" />
-      <Member Name="GetConsoleFallbackUICulture" />
-      <Member Name="GetCultureInfo(System.Int32)" />
-      <Member Name="GetCultureInfo(System.String)" />
-      <Member Name="GetCultureInfo(System.String,System.String)" />
-      <Member Name="GetCultureInfoByIetfLanguageTag(System.String)" />
-      <Member Name="GetCultures(System.Globalization.CultureTypes)" />
-      <Member Name="GetFormat(System.Type)" />
-      <Member Name="GetHashCode" />
-      <Member Status="ImplRoot" Name="OnDeserialized(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="OnSerializing(System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="ReadOnly(System.Globalization.CultureInfo)" />
-      <Member Name="set_CurrentCulture(System.Globalization.CultureInfo)" />
-      <Member Name="set_CurrentUICulture(System.Globalization.CultureInfo)" />
-      <Member Name="set_DateTimeFormat(System.Globalization.DateTimeFormatInfo)" />
-      <Member Name="set_DefaultThreadCurrentCulture(System.Globalization.CultureInfo)" />
-      <Member Name="set_DefaultThreadCurrentUICulture(System.Globalization.CultureInfo)" />
-      <Member Name="set_NumberFormat(System.Globalization.NumberFormatInfo)" />
-      <Member Name="ToString" />
-      <Member Status="ImplRoot" Name="get_SortName" />
-      <Member MemberType="Property" Name="Calendar" />
-      <Member MemberType="Property" Name="CompareInfo" />
-      <Member MemberType="Property" Name="CurrentCulture" />
-      <Member MemberType="Property" Name="CurrentUICulture" />
-      <Member MemberType="Property" Name="CultureTypes" />
-      <Member MemberType="Property" Name="DateTimeFormat" />
-      <Member MemberType="Property" Name="DefaultThreadCurrentCulture" />
-      <Member MemberType="Property" Name="DefaultThreadCurrentUICulture"/>
-      <Member MemberType="Property" Name="DisplayName" />
-      <Member MemberType="Property" Name="EnglishName" />
-      <Member MemberType="Property" Name="IetfLanguageTag" />
-      <Member MemberType="Property" Name="InstalledUICulture" />
-      <Member MemberType="Property" Name="InvariantCulture" />
-      <Member MemberType="Property" Name="IsNeutralCulture" />
-      <Member MemberType="Property" Name="IsReadOnly" />
-      <Member MemberType="Property" Name="KeyboardLayoutId" />
-      <Member MemberType="Property" Name="LCID" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="NativeName" />
-      <Member MemberType="Property" Name="NumberFormat" />
-      <Member MemberType="Property" Name="OptionalCalendars" />
-      <Member MemberType="Property" Name="Parent" />
-      <Member MemberType="Property" Name="TextInfo" />
-      <Member MemberType="Property" Name="ThreeLetterISOLanguageName" />
-      <Member MemberType="Property" Name="ThreeLetterWindowsLanguageName" />
-      <Member MemberType="Property" Name="TwoLetterISOLanguageName" />
-      <Member MemberType="Property" Name="UseUserOverride" />
-      <Member Status="ImplRoot" MemberType="Property" Name="SortName" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_parent" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_useUserOverride" Condition="not FEATURE_COREFX_GLOBALIZATION" />
-    </Type>
-    <Type Name="System.Globalization.CultureNotFoundException">
-      <Member Name="#ctor"/>
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.String,System.Int32,System.Exception)" />
-      <Member Name="#ctor(System.String,System.Int32,System.String)" />
-      <Member Name="#ctor(System.String,System.String,System.String)" />
-      <Member Name="#ctor(System.String,System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="get_InvalidCultureId" />
-      <Member Name="get_InvalidCultureName" />
-      <Member Name="get_Message" />
-      <Member Name="GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member MemberType="Property" Name="InvalidCultureId" />
-      <Member MemberType="Property" Name="InvalidCultureName" />
-      <Member MemberType="Property" Name="Message" />
-    </Type>
-    <Type Name="System.Globalization.CultureTypes">
-      <Member MemberType="Field" Name="AllCultures" />
-      <Member MemberType="Field" Name="FrameworkCultures" />
-      <Member MemberType="Field" Name="InstalledWin32Cultures" />
-      <Member MemberType="Field" Name="NeutralCultures" />
-      <Member MemberType="Field" Name="ReplacementCultures" />
-      <Member MemberType="Field" Name="SpecificCultures" />
-      <Member MemberType="Field" Name="UserCustomCulture" />
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="WindowsOnlyCultures" />
-    </Type>
-    <Type Name="System.Globalization.DateTimeFormatInfo">
-      <Member Name="#ctor" />
-      <Member Name="Clone" />
-      <Member Name="get_AbbreviatedDayNames" />
-      <Member Name="get_AbbreviatedMonthGenitiveNames" />
-      <Member Name="get_AbbreviatedMonthNames" />
-      <Member Name="get_AMDesignator" />
-      <Member Name="get_Calendar" />
-      <Member Name="get_CalendarWeekRule" />
-      <Member Name="get_CurrentInfo" />
-      <Member Name="get_DateSeparator" />
-      <Member Name="get_DayNames" />
-      <Member Name="get_FirstDayOfWeek" />
-      <Member Name="get_FullDateTimePattern" />
-      <Member Name="get_InvariantInfo" />
-      <Member Name="get_IsReadOnly" />
-      <Member Name="get_LongDatePattern" />
-      <Member Name="get_LongTimePattern" />
-      <Member Name="get_MonthDayPattern" />
-      <Member Name="get_MonthGenitiveNames" />
-      <Member Name="get_MonthNames" />
-      <Member Name="get_NativeCalendarName" />
-      <Member Name="get_PMDesignator" />
-      <Member Name="get_RFC1123Pattern" />
-      <Member Name="get_ShortDatePattern" />
-      <Member Name="get_ShortestDayNames" />
-      <Member Name="get_ShortTimePattern" />
-      <Member Name="get_SortableDateTimePattern" />
-      <Member Name="get_TimeSeparator" />
-      <Member Name="get_UniversalSortableDateTimePattern" />
-      <Member Name="get_YearMonthPattern" />
-      <Member Name="GetAbbreviatedDayName(System.DayOfWeek)" />
-      <Member Name="GetAbbreviatedEraName(System.Int32)" />
-      <Member Name="GetAbbreviatedMonthName(System.Int32)" />
-      <Member Name="GetAllDateTimePatterns" />
-      <Member Name="GetAllDateTimePatterns(System.Char)" />
-      <Member Name="GetDayName(System.DayOfWeek)" />
-      <Member Name="GetEra(System.String)" />
-      <Member Name="GetEraName(System.Int32)" />
-      <Member Name="GetFormat(System.Type)" />
-      <Member Name="GetInstance(System.IFormatProvider)" />
-      <Member Name="GetMonthName(System.Int32)" />
-      <Member Name="GetShortestDayName(System.DayOfWeek)" />
-      <Member Status="ImplRoot" Name="OnDeserialized(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="OnSerializing(System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="ReadOnly(System.Globalization.DateTimeFormatInfo)" />
-      <Member Name="set_AbbreviatedDayNames(System.String[])" />
-      <Member Name="set_AbbreviatedMonthGenitiveNames(System.String[])" />
-      <Member Name="set_AbbreviatedMonthNames(System.String[])" />
-      <Member Name="set_AMDesignator(System.String)" />
-      <Member Name="set_Calendar(System.Globalization.Calendar)" />
-      <Member Name="set_CalendarWeekRule(System.Globalization.CalendarWeekRule)" />
-      <Member Name="set_DateSeparator(System.String)" />
-      <Member Name="set_DayNames(System.String[])" />
-      <Member Name="set_FirstDayOfWeek(System.DayOfWeek)" />
-      <Member Name="set_FullDateTimePattern(System.String)" />
-      <Member Name="set_LongDatePattern(System.String)" />
-      <Member Name="set_LongTimePattern(System.String)" />
-      <Member Name="set_MonthDayPattern(System.String)" />
-      <Member Name="set_MonthGenitiveNames(System.String[])" />
-      <Member Name="set_MonthNames(System.String[])" />
-      <Member Name="set_PMDesignator(System.String)" />
-      <Member Name="set_ShortDatePattern(System.String)" />
-      <Member Name="set_ShortestDayNames(System.String[])" />
-      <Member Name="set_ShortTimePattern(System.String)" />
-      <Member Name="set_TimeSeparator(System.String)" />
-      <Member Name="set_YearMonthPattern(System.String)" />
-      <Member Name="SetAllDateTimePatterns(System.String[],System.Char)" />
-      <Member MemberType="Property" Name="AbbreviatedDayNames" />
-      <Member MemberType="Property" Name="AbbreviatedMonthGenitiveNames" />
-      <Member MemberType="Property" Name="AbbreviatedMonthNames" />
-      <Member MemberType="Property" Name="AMDesignator" />
-      <Member MemberType="Property" Name="Calendar" />
-      <Member MemberType="Property" Name="CalendarWeekRule" />
-      <Member MemberType="Property" Name="CurrentInfo" />
-      <Member MemberType="Property" Name="DateSeparator" />
-      <Member MemberType="Property" Name="DayNames" />
-      <Member MemberType="Property" Name="FirstDayOfWeek" />
-      <Member MemberType="Property" Name="FullDateTimePattern" />
-      <Member MemberType="Property" Name="InvariantInfo" />
-      <Member MemberType="Property" Name="IsReadOnly" />
-      <Member MemberType="Property" Name="LongDatePattern" />
-      <Member MemberType="Property" Name="LongTimePattern" />
-      <Member MemberType="Property" Name="MonthDayPattern" />
-      <Member MemberType="Property" Name="MonthGenitiveNames" />
-      <Member MemberType="Property" Name="MonthNames" />
-      <Member MemberType="Property" Name="NativeCalendarName" />
-      <Member MemberType="Property" Name="PMDesignator" />
-      <Member MemberType="Property" Name="RFC1123Pattern" />
-      <Member MemberType="Property" Name="ShortDatePattern" />
-      <Member MemberType="Property" Name="ShortestDayNames" />
-      <Member MemberType="Property" Name="ShortTimePattern" />
-      <Member MemberType="Property" Name="SortableDateTimePattern" />
-      <Member MemberType="Property" Name="TimeSeparator" />
-      <Member MemberType="Property" Name="UniversalSortableDateTimePattern" />
-      <Member MemberType="Property" Name="YearMonthPattern" />
-    </Type>
-    <Type Name="System.Globalization.DateTimeStyles">
-      <Member MemberType="Field" Name="AdjustToUniversal" />
-      <Member MemberType="Field" Name="AllowInnerWhite" />
-      <Member MemberType="Field" Name="AllowLeadingWhite" />
-      <Member MemberType="Field" Name="AllowTrailingWhite" />
-      <Member MemberType="Field" Name="AllowWhiteSpaces" />
-      <Member MemberType="Field" Name="AssumeLocal" />
-      <Member MemberType="Field" Name="AssumeUniversal" />
-      <Member MemberType="Field" Name="NoCurrentDateDefault" />
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="RoundtripKind" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Globalization.DaylightTime">
-      <Member Name="#ctor(System.DateTime,System.DateTime,System.TimeSpan)" />
-      <Member Name="get_Delta" />
-      <Member Name="get_End" />
-      <Member Name="get_Start" />
-      <Member MemberType="Property" Name="Delta" />
-      <Member MemberType="Property" Name="End" />
-      <Member MemberType="Property" Name="Start" />
-    </Type>
-    <Type Name="System.Globalization.DigitShapes">
-      <Member MemberType="Field" Name="Context" />
-      <Member MemberType="Field" Name="NativeNational" />
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Globalization.PersianCalendar">
-      <Member MemberType="Field" Name="PersianEra" />
-      <Member Name="#ctor" />
-      <Member Name="AddMonths(System.DateTime,System.Int32)" />
-      <Member Name="AddYears(System.DateTime,System.Int32)" />
-      <Member Name="get_AlgorithmType" />
-      <Member Name="get_Eras" />
-      <Member Name="get_MaxSupportedDateTime" />
-      <Member Name="get_MinSupportedDateTime" />
-      <Member Name="get_TwoDigitYearMax" />
-      <Member Name="GetDayOfMonth(System.DateTime)" />
-      <Member Name="GetDayOfWeek(System.DateTime)" />
-      <Member Name="GetDayOfYear(System.DateTime)" />
-      <Member Name="GetDaysInMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="GetDaysInYear(System.Int32,System.Int32)" />
-      <Member Name="GetEra(System.DateTime)" />
-      <Member Name="GetLeapMonth(System.Int32,System.Int32)" />
-      <Member Name="GetMonth(System.DateTime)" />
-      <Member Name="GetMonthsInYear(System.Int32,System.Int32)" />
-      <Member Name="GetYear(System.DateTime)" />
-      <Member Name="IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapYear(System.Int32,System.Int32)" />
-      <Member Name="set_TwoDigitYearMax(System.Int32)" />
-      <Member Name="ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="ToFourDigitYear(System.Int32)" />
-      <Member MemberType="Property" Name="AlgorithmType" Condition="not FEATURE_COREFX_GLOBALIZATION" />
-      <Member MemberType="Property" Name="Eras" />
-      <Member MemberType="Property" Name="MaxSupportedDateTime" />
-      <Member MemberType="Property" Name="MinSupportedDateTime" />
-      <Member MemberType="Property" Name="TwoDigitYearMax" />
-    </Type>
-
-    <Type Name="System.Globalization.TimeSpanStyles">
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="AssumeNegative" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Globalization.EastAsianLunisolarCalendar">
-      <Member Name="AddMonths(System.DateTime,System.Int32)" />
-      <Member Name="AddYears(System.DateTime,System.Int32)" />
-      <Member Name="get_AlgorithmType" />
-      <Member Name="get_TwoDigitYearMax" />
-      <Member Name="GetCelestialStem(System.Int32)" />
-      <Member Name="GetDayOfMonth(System.DateTime)" />
-      <Member Name="GetDayOfWeek(System.DateTime)" />
-      <Member Name="GetDayOfYear(System.DateTime)" />
-      <Member Name="GetDaysInMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="GetDaysInYear(System.Int32,System.Int32)" />
-      <Member Name="GetLeapMonth(System.Int32,System.Int32)" />
-      <Member Name="GetMonth(System.DateTime)" />
-      <Member Name="GetMonthsInYear(System.Int32,System.Int32)" />
-      <Member Name="GetSexagenaryYear(System.DateTime)" />
-      <Member Name="GetTerrestrialBranch(System.Int32)" />
-      <Member Name="GetYear(System.DateTime)" />
-      <Member Name="IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapYear(System.Int32,System.Int32)" />
-      <Member Name="set_TwoDigitYearMax(System.Int32)" />
-      <Member Name="ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="ToFourDigitYear(System.Int32)" />
-      <Member MemberType="Property" Name="AlgorithmType" Condition="not FEATURE_COREFX_GLOBALIZATION"/>
-      <Member MemberType="Property" Name="TwoDigitYearMax" />
-    </Type>
-    <Type Name="System.Globalization.GregorianCalendar">
-      <Member MemberType="Field" Name="ADEra" />
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Globalization.GregorianCalendarTypes)" />
-      <Member Name="AddMonths(System.DateTime,System.Int32)" />
-      <Member Name="AddYears(System.DateTime,System.Int32)" />
-      <Member Name="get_CalendarType" />
-      <Member Name="get_Eras" />
-      <Member Name="get_MaxSupportedDateTime" />
-      <Member Name="get_MinSupportedDateTime" />
-      <Member Name="get_TwoDigitYearMax" />
-      <Member Name="GetDayOfMonth(System.DateTime)" />
-      <Member Name="GetDayOfWeek(System.DateTime)" />
-      <Member Name="GetDayOfYear(System.DateTime)" />
-      <Member Name="GetDaysInMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="GetDaysInYear(System.Int32,System.Int32)" />
-      <Member Name="GetEra(System.DateTime)" />
-      <Member Name="GetMonth(System.DateTime)" />
-      <Member Name="GetMonthsInYear(System.Int32,System.Int32)" />
-      <Member Name="GetYear(System.DateTime)" />
-      <Member Name="IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapYear(System.Int32,System.Int32)" />
-      <Member Status="ImplRoot" Name="OnDeserialized(System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="set_CalendarType(System.Globalization.GregorianCalendarTypes)" />
-      <Member Name="set_TwoDigitYearMax(System.Int32)" />
-      <Member Name="ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="ToFourDigitYear(System.Int32)" />
-      <Member MemberType="Property" Name="CalendarType" />
-      <Member MemberType="Property" Name="Eras" />
-      <Member MemberType="Property" Name="MaxSupportedDateTime" />
-      <Member MemberType="Property" Name="MinSupportedDateTime" />
-      <Member MemberType="Property" Name="TwoDigitYearMax" />
-    </Type>
-    <Type Name="System.Globalization.GregorianCalendarTypes">
-      <Member MemberType="Field" Name="Arabic" />
-      <Member MemberType="Field" Name="Localized" />
-      <Member MemberType="Field" Name="MiddleEastFrench" />
-      <Member MemberType="Field" Name="TransliteratedEnglish" />
-      <Member MemberType="Field" Name="TransliteratedFrench" />
-      <Member MemberType="Field" Name="USEnglish" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Globalization.JapaneseCalendar">
-      <Member Name="#ctor" />
-      <Member Name="AddMonths(System.DateTime,System.Int32)" />
-      <Member Name="AddYears(System.DateTime,System.Int32)" />
-      <Member Name="get_Eras" />
-      <Member Name="get_MaxSupportedDateTime" />
-      <Member Name="get_MinSupportedDateTime" />
-      <Member Name="get_TwoDigitYearMax" />
-      <Member Name="GetDayOfMonth(System.DateTime)" />
-      <Member Name="GetDayOfWeek(System.DateTime)" />
-      <Member Name="GetDayOfYear(System.DateTime)" />
-      <Member Name="GetDaysInMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="GetDaysInYear(System.Int32,System.Int32)" />
-      <Member Name="GetEra(System.DateTime)" />
-      <Member Name="GetMonth(System.DateTime)" />
-      <Member Name="GetMonthsInYear(System.Int32,System.Int32)" />
-      <Member Name="GetWeekOfYear(System.DateTime,System.Globalization.CalendarWeekRule,System.DayOfWeek)" />
-      <Member Name="GetYear(System.DateTime)" />
-      <Member Name="IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapYear(System.Int32,System.Int32)" />
-      <Member Name="set_TwoDigitYearMax(System.Int32)" />
-      <Member Name="ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="ToFourDigitYear(System.Int32)" />
-      <Member MemberType="Property" Name="Eras" />
-      <Member MemberType="Property" Name="MaxSupportedDateTime" />
-      <Member MemberType="Property" Name="MinSupportedDateTime" />
-      <Member MemberType="Property" Name="TwoDigitYearMax" />
-    </Type>
-    <Type Name="System.Globalization.JapaneseLunisolarCalendar">
-      <Member MemberType="Field" Name="JapaneseEra" />
-      <Member Name="#ctor" />
-      <Member Name="get_DaysInYearBeforeMinSupportedYear" />
-      <Member Name="get_Eras" />
-      <Member Name="get_MaxSupportedDateTime" />
-      <Member Name="get_MinSupportedDateTime" />
-      <Member Name="GetEra(System.DateTime)" />
-      <Member MemberType="Property" Name="DaysInYearBeforeMinSupportedYear" />
-      <Member MemberType="Property" Name="Eras" />
-      <Member MemberType="Property" Name="MaxSupportedDateTime" />
-      <Member MemberType="Property" Name="MinSupportedDateTime" />
-    </Type>
-    <Type Name="System.Globalization.JulianCalendar">
-      <Member MemberType="Field" Name="JulianEra" />
-      <Member Name="#ctor" />
-      <Member Name="AddMonths(System.DateTime,System.Int32)" />
-      <Member Name="AddYears(System.DateTime,System.Int32)" />
-      <Member Name="get_AlgorithmType" />
-      <Member Name="get_Eras" />
-      <Member Name="get_MaxSupportedDateTime" />
-      <Member Name="get_MinSupportedDateTime" />
-      <Member Name="get_TwoDigitYearMax" />
-      <Member Name="GetDayOfMonth(System.DateTime)" />
-      <Member Name="GetDayOfWeek(System.DateTime)" />
-      <Member Name="GetDayOfYear(System.DateTime)" />
-      <Member Name="GetDaysInMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="GetDaysInYear(System.Int32,System.Int32)" />
-      <Member Name="GetEra(System.DateTime)" />
-      <Member Name="GetLeapMonth(System.Int32,System.Int32)" />
-      <Member Name="GetMonth(System.DateTime)" />
-      <Member Name="GetMonthsInYear(System.Int32,System.Int32)" />
-      <Member Name="GetYear(System.DateTime)" />
-      <Member Name="IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapYear(System.Int32,System.Int32)" />
-      <Member Name="set_TwoDigitYearMax(System.Int32)" />
-      <Member Name="ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="ToFourDigitYear(System.Int32)" />
-      <Member MemberType="Property" Name="AlgorithmType" Condition="not FEATURE_COREFX_GLOBALIZATION" />
-      <Member MemberType="Property" Name="Eras" />
-      <Member MemberType="Property" Name="MaxSupportedDateTime" />
-      <Member MemberType="Property" Name="MinSupportedDateTime" />
-      <Member MemberType="Property" Name="TwoDigitYearMax" />
-    </Type>
-    <Type Name="System.Globalization.HebrewCalendar">
-      <Member MemberType="Field" Name="HebrewEra" />
-      <Member Name="#ctor" />
-      <Member Name="AddMonths(System.DateTime,System.Int32)" />
-      <Member Name="AddYears(System.DateTime,System.Int32)" />
-      <Member Name="get_Eras" />
-      <Member Name="get_MaxSupportedDateTime" />
-      <Member Name="get_MinSupportedDateTime" />
-      <Member Name="get_TwoDigitYearMax" />
-      <Member Name="GetDayOfMonth(System.DateTime)" />
-      <Member Name="GetDayOfWeek(System.DateTime)" />
-      <Member Name="GetDayOfYear(System.DateTime)" />
-      <Member Name="GetDaysInMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="GetDaysInYear(System.Int32,System.Int32)" />
-      <Member Name="GetEra(System.DateTime)" />
-      <Member Name="GetLeapMonth(System.Int32,System.Int32)" />
-      <Member Name="GetMonth(System.DateTime)" />
-      <Member Name="GetMonthsInYear(System.Int32,System.Int32)" />
-      <Member Name="GetYear(System.DateTime)" />
-      <Member Name="IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapYear(System.Int32,System.Int32)" />
-      <Member Name="set_TwoDigitYearMax(System.Int32)" />
-      <Member Name="ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="ToFourDigitYear(System.Int32)" />
-      <Member MemberType="Property" Name="Eras" />
-      <Member MemberType="Property" Name="MaxSupportedDateTime" />
-      <Member MemberType="Property" Name="MinSupportedDateTime" />
-      <Member MemberType="Property" Name="TwoDigitYearMax" />
-    </Type>
-    <Type Name="System.Globalization.HijriCalendar">
-      <Member MemberType="Field" Name="HijriEra" />
-      <Member Name="#ctor" />
-      <Member Name="AddMonths(System.DateTime,System.Int32)" />
-      <Member Name="AddYears(System.DateTime,System.Int32)" />
-      <Member Name="get_Eras" />
-      <Member Name="get_HijriAdjustment" />
-      <Member Name="get_MaxSupportedDateTime" />
-      <Member Name="get_MinSupportedDateTime" />
-      <Member Name="get_TwoDigitYearMax" />
-      <Member Name="GetDayOfMonth(System.DateTime)" />
-      <Member Name="GetDayOfWeek(System.DateTime)" />
-      <Member Name="GetDayOfYear(System.DateTime)" />
-      <Member Name="GetDaysInMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="GetDaysInYear(System.Int32,System.Int32)" />
-      <Member Name="GetEra(System.DateTime)" />
-      <Member Name="GetLeapMonth(System.Int32,System.Int32)" />
-      <Member Name="GetMonth(System.DateTime)" />
-      <Member Name="GetMonthsInYear(System.Int32,System.Int32)" />
-      <Member Name="GetYear(System.DateTime)" />
-      <Member Name="IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapYear(System.Int32,System.Int32)" />
-      <Member Name="set_HijriAdjustment(System.Int32)" />
-      <Member Name="set_TwoDigitYearMax(System.Int32)" />
-      <Member Name="ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="ToFourDigitYear(System.Int32)" />
-      <Member MemberType="Property" Name="Eras" />
-      <Member MemberType="Property" Name="HijriAdjustment" />
-      <Member MemberType="Property" Name="MaxSupportedDateTime" />
-      <Member MemberType="Property" Name="MinSupportedDateTime" />
-      <Member MemberType="Property" Name="TwoDigitYearMax" />
-    </Type>
-    <Type Name="System.Globalization.IdnMapping">
-      <Member Name="#ctor" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_AllowUnassigned" />
-      <Member Name="get_UseStd3AsciiRules" />
-      <Member Name="GetAscii(System.String)" />
-      <Member Name="GetAscii(System.String,System.Int32)" />
-      <Member Name="GetAscii(System.String,System.Int32,System.Int32)" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetUnicode(System.String)" />
-      <Member Name="GetUnicode(System.String,System.Int32)" />
-      <Member Name="GetUnicode(System.String,System.Int32,System.Int32)" />
-      <Member Name="set_AllowUnassigned(System.Boolean)" />
-      <Member Name="set_UseStd3AsciiRules(System.Boolean)" />
-      <Member MemberType="Property" Name="AllowUnassigned" />
-      <Member MemberType="Property" Name="UseStd3AsciiRules" />
-    </Type>
-    <Type Name="System.Globalization.KoreanCalendar">
-      <Member MemberType="Field" Name="KoreanEra" />
-      <Member Name="#ctor" />
-      <Member Name="AddMonths(System.DateTime,System.Int32)" />
-      <Member Name="AddYears(System.DateTime,System.Int32)" />
-      <Member Name="get_Eras" />
-      <Member Name="get_MaxSupportedDateTime" />
-      <Member Name="get_MinSupportedDateTime" />
-      <Member Name="get_TwoDigitYearMax" />
-      <Member Name="GetDayOfMonth(System.DateTime)" />
-      <Member Name="GetDayOfWeek(System.DateTime)" />
-      <Member Name="GetDayOfYear(System.DateTime)" />
-      <Member Name="GetDaysInMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="GetDaysInYear(System.Int32,System.Int32)" />
-      <Member Name="GetEra(System.DateTime)" />
-      <Member Name="GetMonth(System.DateTime)" />
-      <Member Name="GetMonthsInYear(System.Int32,System.Int32)" />
-      <Member Name="GetWeekOfYear(System.DateTime,System.Globalization.CalendarWeekRule,System.DayOfWeek)" />
-      <Member Name="GetYear(System.DateTime)" />
-      <Member Name="IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapYear(System.Int32,System.Int32)" />
-      <Member Name="set_TwoDigitYearMax(System.Int32)" />
-      <Member Name="ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="ToFourDigitYear(System.Int32)" />
-      <Member MemberType="Property" Name="Eras" />
-      <Member MemberType="Property" Name="MaxSupportedDateTime" />
-      <Member MemberType="Property" Name="MinSupportedDateTime" />
-      <Member MemberType="Property" Name="TwoDigitYearMax" />
-    </Type>
-    <Type Name="System.Globalization.KoreanLunisolarCalendar">
-      <Member MemberType="Field" Name="GregorianEra" />
-      <Member Name="#ctor" />
-      <Member Name="get_DaysInYearBeforeMinSupportedYear" />
-      <Member Name="get_Eras" />
-      <Member Name="get_MaxSupportedDateTime" />
-      <Member Name="get_MinSupportedDateTime" />
-      <Member Name="GetEra(System.DateTime)" />
-      <Member MemberType="Property" Name="DaysInYearBeforeMinSupportedYear" />
-      <Member MemberType="Property" Name="Eras" />
-      <Member MemberType="Property" Name="MaxSupportedDateTime" />
-      <Member MemberType="Property" Name="MinSupportedDateTime" />
-    </Type>
-    <Type Name="System.Globalization.UmAlQuraCalendar">
-      <Member MemberType="Field" Name="UmAlQuraEra" />
-      <Member Name="#ctor" />
-      <Member Name="AddMonths(System.DateTime,System.Int32)" />
-      <Member Name="AddYears(System.DateTime,System.Int32)" />
-      <Member Name="get_Eras" />
-      <Member Name="get_MaxSupportedDateTime" />
-      <Member Name="get_MinSupportedDateTime" />
-      <Member Name="get_TwoDigitYearMax" />
-      <Member Name="GetDayOfMonth(System.DateTime)" />
-      <Member Name="GetDayOfWeek(System.DateTime)" />
-      <Member Name="GetDayOfYear(System.DateTime)" />
-      <Member Name="GetDaysInMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="GetDaysInYear(System.Int32,System.Int32)" />
-      <Member Name="GetEra(System.DateTime)" />
-      <Member Name="GetLeapMonth(System.Int32,System.Int32)" />
-      <Member Name="GetMonth(System.DateTime)" />
-      <Member Name="GetMonthsInYear(System.Int32,System.Int32)" />
-      <Member Name="GetYear(System.DateTime)" />
-      <Member Name="IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapYear(System.Int32,System.Int32)" />
-      <Member Name="set_TwoDigitYearMax(System.Int32)" />
-      <Member Name="ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="ToFourDigitYear(System.Int32)" />
-      <Member MemberType="Property" Name="Eras" />
-      <Member MemberType="Property" Name="MaxSupportedDateTime" />
-      <Member MemberType="Property" Name="MinSupportedDateTime" />
-      <Member MemberType="Property" Name="TwoDigitYearMax" />
-    </Type>
-    <Type Name="System.Globalization.NumberFormatInfo">
-      <Member Name="#ctor" />
-      <Member Name="Clone" />
-      <Member Name="get_CurrencyDecimalDigits" />
-      <Member Name="get_CurrencyDecimalSeparator" />
-      <Member Name="get_CurrencyGroupSeparator" />
-      <Member Name="get_CurrencyGroupSizes" />
-      <Member Name="get_CurrencyNegativePattern" />
-      <Member Name="get_CurrencyPositivePattern" />
-      <Member Name="get_CurrencySymbol" />
-      <Member Name="get_CurrentInfo" />
-      <Member Name="get_DigitSubstitution" />
-      <Member Name="get_InvariantInfo" />
-      <Member Name="get_IsReadOnly" />
-      <Member Name="get_NaNSymbol" />
-      <Member Name="get_NativeDigits" />
-      <Member Name="get_NegativeInfinitySymbol" />
-      <Member Name="get_NegativeSign" />
-      <Member Name="get_NumberDecimalDigits" />
-      <Member Name="get_NumberDecimalSeparator" />
-      <Member Name="get_NumberGroupSeparator" />
-      <Member Name="get_NumberGroupSizes" />
-      <Member Name="get_NumberNegativePattern" />
-      <Member Name="get_PercentDecimalDigits" />
-      <Member Name="get_PercentDecimalSeparator" />
-      <Member Name="get_PercentGroupSeparator" />
-      <Member Name="get_PercentGroupSizes" />
-      <Member Name="get_PercentNegativePattern" />
-      <Member Name="get_PercentPositivePattern" />
-      <Member Name="get_PercentSymbol" />
-      <Member Name="get_PerMilleSymbol" />
-      <Member Name="get_PositiveInfinitySymbol" />
-      <Member Name="get_PositiveSign" />
-      <Member Name="GetFormat(System.Type)" />
-      <Member Name="GetInstance(System.IFormatProvider)" />
-      <Member Status="ImplRoot" Name="OnDeserialized(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="OnDeserializing(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="OnSerializing(System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="ReadOnly(System.Globalization.NumberFormatInfo)" />
-      <Member Name="set_CurrencyDecimalDigits(System.Int32)" />
-      <Member Name="set_CurrencyDecimalSeparator(System.String)" />
-      <Member Name="set_CurrencyGroupSeparator(System.String)" />
-      <Member Name="set_CurrencyGroupSizes(System.Int32[])" />
-      <Member Name="set_CurrencyNegativePattern(System.Int32)" />
-      <Member Name="set_CurrencyPositivePattern(System.Int32)" />
-      <Member Name="set_CurrencySymbol(System.String)" />
-      <Member Name="set_DigitSubstitution(System.Globalization.DigitShapes)" />
-      <Member Name="set_NaNSymbol(System.String)" />
-      <Member Name="set_NativeDigits(System.String[])" />
-      <Member Name="set_NegativeInfinitySymbol(System.String)" />
-      <Member Name="set_NegativeSign(System.String)" />
-      <Member Name="set_NumberDecimalDigits(System.Int32)" />
-      <Member Name="set_NumberDecimalSeparator(System.String)" />
-      <Member Name="set_NumberGroupSeparator(System.String)" />
-      <Member Name="set_NumberGroupSizes(System.Int32[])" />
-      <Member Name="set_NumberNegativePattern(System.Int32)" />
-      <Member Name="set_PercentDecimalDigits(System.Int32)" />
-      <Member Name="set_PercentDecimalSeparator(System.String)" />
-      <Member Name="set_PercentGroupSeparator(System.String)" />
-      <Member Name="set_PercentGroupSizes(System.Int32[])" />
-      <Member Name="set_PercentNegativePattern(System.Int32)" />
-      <Member Name="set_PercentPositivePattern(System.Int32)" />
-      <Member Name="set_PercentSymbol(System.String)" />
-      <Member Name="set_PerMilleSymbol(System.String)" />
-      <Member Name="set_PositiveInfinitySymbol(System.String)" />
-      <Member Name="set_PositiveSign(System.String)" />
-      <Member MemberType="Property" Name="CurrencyDecimalDigits" />
-      <Member MemberType="Property" Name="CurrencyDecimalSeparator" />
-      <Member MemberType="Property" Name="CurrencyGroupSeparator" />
-      <Member MemberType="Property" Name="CurrencyGroupSizes" />
-      <Member MemberType="Property" Name="CurrencyNegativePattern" />
-      <Member MemberType="Property" Name="CurrencyPositivePattern" />
-      <Member MemberType="Property" Name="CurrencySymbol" />
-      <Member MemberType="Property" Name="CurrentInfo" />
-      <Member MemberType="Property" Name="DigitSubstitution" />
-      <Member MemberType="Property" Name="InvariantInfo" />
-      <Member MemberType="Property" Name="IsReadOnly" />
-      <Member MemberType="Property" Name="NaNSymbol" />
-      <Member MemberType="Property" Name="NativeDigits" />
-      <Member MemberType="Property" Name="NegativeInfinitySymbol" />
-      <Member MemberType="Property" Name="NegativeSign" />
-      <Member MemberType="Property" Name="NumberDecimalDigits" />
-      <Member MemberType="Property" Name="NumberDecimalSeparator" />
-      <Member MemberType="Property" Name="NumberGroupSeparator" />
-      <Member MemberType="Property" Name="NumberGroupSizes" />
-      <Member MemberType="Property" Name="NumberNegativePattern" />
-      <Member MemberType="Property" Name="PercentDecimalDigits" />
-      <Member MemberType="Property" Name="PercentDecimalSeparator" />
-      <Member MemberType="Property" Name="PercentGroupSeparator" />
-      <Member MemberType="Property" Name="PercentGroupSizes" />
-      <Member MemberType="Property" Name="PercentNegativePattern" />
-      <Member MemberType="Property" Name="PercentPositivePattern" />
-      <Member MemberType="Property" Name="PercentSymbol" />
-      <Member MemberType="Property" Name="PerMilleSymbol" />
-      <Member MemberType="Property" Name="PositiveInfinitySymbol" />
-      <Member MemberType="Property" Name="PositiveSign" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_dataItem" Condition="not FEATURE_COREFX_GLOBALIZATION" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_useUserOverride" Condition="not FEATURE_COREFX_GLOBALIZATION" />
-    </Type>
-    <Type Name="System.Globalization.NumberStyles">
-      <Member MemberType="Field" Name="AllowCurrencySymbol" />
-      <Member MemberType="Field" Name="AllowDecimalPoint" />
-      <Member MemberType="Field" Name="AllowExponent" />
-      <Member MemberType="Field" Name="AllowHexSpecifier" />
-      <Member MemberType="Field" Name="AllowLeadingSign" />
-      <Member MemberType="Field" Name="AllowLeadingWhite" />
-      <Member MemberType="Field" Name="AllowParentheses" />
-      <Member MemberType="Field" Name="AllowThousands" />
-      <Member MemberType="Field" Name="AllowTrailingSign" />
-      <Member MemberType="Field" Name="AllowTrailingWhite" />
-      <Member MemberType="Field" Name="Any" />
-      <Member MemberType="Field" Name="Currency" />
-      <Member MemberType="Field" Name="Float" />
-      <Member MemberType="Field" Name="HexNumber" />
-      <Member MemberType="Field" Name="Integer" />
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="Number" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Globalization.RegionInfo">
-      <Member Name="#ctor(System.Int32)" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_CurrencySymbol" />
-      <Member Name="get_CurrencyEnglishName" />
-      <Member Name="get_CurrencyNativeName" />
-      <Member Name="get_CurrentRegion" />
-      <Member Name="get_DisplayName" />
-      <Member Name="get_EnglishName" />
-      <Member Name="get_GeoId" />
-      <Member Name="get_IsMetric" />
-      <Member Name="get_ISOCurrencySymbol" />
-      <Member Name="get_Name" />
-      <Member Name="get_NativeName" />
-      <Member Name="get_ThreeLetterISORegionName" />
-      <Member Name="get_ThreeLetterWindowsRegionName" />
-      <Member Name="get_TwoLetterISORegionName" />
-      <Member Name="GetHashCode" />
-      <Member Status="ImplRoot" Name="OnDeserialized(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="OnSerializing(System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="CurrencySymbol" />
-      <Member MemberType="Property" Name="CurrencyEnglishName" />
-      <Member MemberType="Property" Name="CurrencyNativeName" />
-      <Member MemberType="Property" Name="CurrentRegion" />
-      <Member MemberType="Property" Name="DisplayName" />
-      <Member MemberType="Property" Name="EnglishName" />
-      <Member MemberType="Property" Name="GeoId" />
-      <Member MemberType="Property" Name="IsMetric" />
-      <Member MemberType="Property" Name="ISOCurrencySymbol" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="NativeName" />
-      <Member MemberType="Property" Name="ThreeLetterISORegionName" />
-      <Member MemberType="Property" Name="ThreeLetterWindowsRegionName" />
-      <Member MemberType="Property" Name="TwoLetterISORegionName" />
-    </Type>
-    <Type Name="System.Globalization.SortKey">
-      <Member Name="Compare(System.Globalization.SortKey,System.Globalization.SortKey)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_KeyData" />
-      <Member Name="get_OriginalString" />
-      <Member Name="GetHashCode" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="KeyData" />
-      <Member MemberType="Property" Name="OriginalString" />
-    </Type>
-    <Type Name="System.Globalization.SortVersion">
-      <Member Name="#ctor(System.Int32,System.Guid)" />
-      <Member Name="Equals(System.Globalization.SortVersion)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_FullVersion" />
-      <Member Name="get_SortId" />
-      <Member Name="GetHashCode" />
-      <Member Name="op_Equality(System.Globalization.SortVersion,System.Globalization.SortVersion)" />
-      <Member Name="op_Inequality(System.Globalization.SortVersion,System.Globalization.SortVersion)" />
-      <Member MemberType="Property" Name="FullVersion" />
-      <Member MemberType="Property" Name="SortId" />
-    </Type>
-    <Type Name="System.Globalization.StringInfo">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_LengthInTextElements" />
-      <Member Name="get_String" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetNextTextElement(System.String)" />
-      <Member Name="GetNextTextElement(System.String,System.Int32)" />
-      <Member Name="GetTextElementEnumerator(System.String)" />
-      <Member Name="GetTextElementEnumerator(System.String,System.Int32)" />
-      <Member Status="ImplRoot" Name="OnDeserialized(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="OnDeserializing(System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="ParseCombiningCharacters(System.String)" />
-      <Member Name="set_String(System.String)" />
-      <Member Name="SubstringByTextElements(System.Int32)" />
-      <Member Name="SubstringByTextElements(System.Int32,System.Int32)" />
-      <Member MemberType="Property" Name="LengthInTextElements" />
-      <Member MemberType="Property" Name="String" />
-    </Type>
-    <Type Name="System.Globalization.TaiwanCalendar">
-      <Member Name="#ctor" />
-      <Member Name="AddMonths(System.DateTime,System.Int32)" />
-      <Member Name="AddYears(System.DateTime,System.Int32)" />
-      <Member Name="get_Eras" />
-      <Member Name="get_MaxSupportedDateTime" />
-      <Member Name="get_MinSupportedDateTime" />
-      <Member Name="get_TwoDigitYearMax" />
-      <Member Name="GetDayOfMonth(System.DateTime)" />
-      <Member Name="GetDayOfWeek(System.DateTime)" />
-      <Member Name="GetDayOfYear(System.DateTime)" />
-      <Member Name="GetDaysInMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="GetDaysInYear(System.Int32,System.Int32)" />
-      <Member Name="GetEra(System.DateTime)" />
-      <Member Name="GetMonth(System.DateTime)" />
-      <Member Name="GetMonthsInYear(System.Int32,System.Int32)" />
-      <Member Name="GetWeekOfYear(System.DateTime,System.Globalization.CalendarWeekRule,System.DayOfWeek)" />
-      <Member Name="GetYear(System.DateTime)" />
-      <Member Name="IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapYear(System.Int32,System.Int32)" />
-      <Member Name="set_TwoDigitYearMax(System.Int32)" />
-      <Member Name="ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="ToFourDigitYear(System.Int32)" />
-      <Member MemberType="Property" Name="Eras" />
-      <Member MemberType="Property" Name="MaxSupportedDateTime" />
-      <Member MemberType="Property" Name="MinSupportedDateTime" />
-      <Member MemberType="Property" Name="TwoDigitYearMax" />
-    </Type>
-    <Type Name="System.Globalization.TaiwanLunisolarCalendar">
-      <Member Name="#ctor" />
-      <Member Name="get_DaysInYearBeforeMinSupportedYear" />
-      <Member Name="get_Eras" />
-      <Member Name="get_MaxSupportedDateTime" />
-      <Member Name="get_MinSupportedDateTime" />
-      <Member Name="GetEra(System.DateTime)" />
-      <Member MemberType="Property" Name="DaysInYearBeforeMinSupportedYear" />
-      <Member MemberType="Property" Name="Eras" />
-      <Member MemberType="Property" Name="MaxSupportedDateTime" />
-      <Member MemberType="Property" Name="MinSupportedDateTime" />
-    </Type>
-    <Type Name="System.Globalization.TextElementEnumerator">
-      <Member Name="get_Current" />
-      <Member Name="get_ElementIndex" />
-      <Member Name="GetTextElement" />
-      <Member Name="MoveNext" />
-      <Member Status="ImplRoot" Name="OnDeserialized(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="OnDeserializing(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="OnSerializing(System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="Reset" />
-      <Member MemberType="Property" Name="Current" />
-      <Member MemberType="Property" Name="ElementIndex" />
-    </Type>
-    <Type Name="System.Globalization.TextInfo">
-      <Member Name="Clone" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_ANSICodePage" />
-      <Member Name="get_CultureName" />
-      <Member Name="get_EBCDICCodePage" />
-      <Member Name="get_IsReadOnly" />
-      <Member Name="get_IsRightToLeft" />
-      <Member Name="get_LCID" />
-      <Member Name="get_ListSeparator" />
-      <Member Name="get_MacCodePage" />
-      <Member Name="get_OEMCodePage" />
-      <Member Name="GetHashCode" />
-      <Member Status="ImplRoot" Name="OnDeserialized(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="OnDeserializing(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="OnSerializing(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="System.Runtime.Serialization.IDeserializationCallback.OnDeserialization(System.Object)" />
-      <Member Name="ReadOnly(System.Globalization.TextInfo)" />
-      <Member Name="set_ListSeparator(System.String)" />
-      <Member Name="ToLower(System.Char)" />
-      <Member Name="ToLower(System.String)" />
-      <Member Name="ToString" />
-      <Member Name="ToTitleCase(System.String)" />
-      <Member Name="ToUpper(System.Char)" />
-      <Member Name="ToUpper(System.String)" />
-      <Member MemberType="Property" Name="ANSICodePage" />
-      <Member MemberType="Property" Name="CultureName" />
-      <Member MemberType="Property" Name="EBCDICCodePage" />
-      <Member MemberType="Property" Name="IsReadOnly" />
-      <Member MemberType="Property" Name="IsRightToLeft" />
-      <Member MemberType="Property" Name="LCID" />
-      <Member MemberType="Property" Name="ListSeparator" />
-      <Member MemberType="Property" Name="MacCodePage" />
-      <Member MemberType="Property" Name="OEMCodePage" />
-    </Type>
-    <Type Name="System.Globalization.ThaiBuddhistCalendar">
-      <Member MemberType="Field" Name="ThaiBuddhistEra" />
-      <Member Name="#ctor" />
-      <Member Name="AddMonths(System.DateTime,System.Int32)" />
-      <Member Name="AddYears(System.DateTime,System.Int32)" />
-      <Member Name="get_Eras" />
-      <Member Name="get_MaxSupportedDateTime" />
-      <Member Name="get_MinSupportedDateTime" />
-      <Member Name="get_TwoDigitYearMax" />
-      <Member Name="GetDayOfMonth(System.DateTime)" />
-      <Member Name="GetDayOfWeek(System.DateTime)" />
-      <Member Name="GetDayOfYear(System.DateTime)" />
-      <Member Name="GetDaysInMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="GetDaysInYear(System.Int32,System.Int32)" />
-      <Member Name="GetEra(System.DateTime)" />
-      <Member Name="GetMonth(System.DateTime)" />
-      <Member Name="GetMonthsInYear(System.Int32,System.Int32)" />
-      <Member Name="GetWeekOfYear(System.DateTime,System.Globalization.CalendarWeekRule,System.DayOfWeek)" />
-      <Member Name="GetYear(System.DateTime)" />
-      <Member Name="IsLeapDay(System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapMonth(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="IsLeapYear(System.Int32,System.Int32)" />
-      <Member Name="set_TwoDigitYearMax(System.Int32)" />
-      <Member Name="ToDateTime(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="ToFourDigitYear(System.Int32)" />
-      <Member MemberType="Property" Name="Eras" />
-      <Member MemberType="Property" Name="MaxSupportedDateTime" />
-      <Member MemberType="Property" Name="MinSupportedDateTime" />
-      <Member MemberType="Property" Name="TwoDigitYearMax" />
-    </Type>
-    <Type Name="System.Globalization.UnicodeCategory">
-      <Member MemberType="Field" Name="ClosePunctuation" />
-      <Member MemberType="Field" Name="ConnectorPunctuation" />
-      <Member MemberType="Field" Name="Control" />
-      <Member MemberType="Field" Name="CurrencySymbol" />
-      <Member MemberType="Field" Name="DashPunctuation" />
-      <Member MemberType="Field" Name="DecimalDigitNumber" />
-      <Member MemberType="Field" Name="EnclosingMark" />
-      <Member MemberType="Field" Name="FinalQuotePunctuation" />
-      <Member MemberType="Field" Name="Format" />
-      <Member MemberType="Field" Name="InitialQuotePunctuation" />
-      <Member MemberType="Field" Name="LetterNumber" />
-      <Member MemberType="Field" Name="LineSeparator" />
-      <Member MemberType="Field" Name="LowercaseLetter" />
-      <Member MemberType="Field" Name="MathSymbol" />
-      <Member MemberType="Field" Name="ModifierLetter" />
-      <Member MemberType="Field" Name="ModifierSymbol" />
-      <Member MemberType="Field" Name="NonSpacingMark" />
-      <Member MemberType="Field" Name="OpenPunctuation" />
-      <Member MemberType="Field" Name="OtherLetter" />
-      <Member MemberType="Field" Name="OtherNotAssigned" />
-      <Member MemberType="Field" Name="OtherNumber" />
-      <Member MemberType="Field" Name="OtherPunctuation" />
-      <Member MemberType="Field" Name="OtherSymbol" />
-      <Member MemberType="Field" Name="ParagraphSeparator" />
-      <Member MemberType="Field" Name="PrivateUse" />
-      <Member MemberType="Field" Name="SpaceSeparator" />
-      <Member MemberType="Field" Name="SpacingCombiningMark" />
-      <Member MemberType="Field" Name="Surrogate" />
-      <Member MemberType="Field" Name="TitlecaseLetter" />
-      <Member MemberType="Field" Name="UppercaseLetter" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Guid">
-      <Member MemberType="Field" Name="Empty" />
-      <Member Name="#ctor(System.Byte[])" />
-      <Member Name="#ctor(System.UInt32,System.UInt16,System.UInt16,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte)" />
-      <Member Name="#ctor(System.Int32,System.Int16,System.Int16,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte)" />
-      <Member Name="#ctor(System.Int32,System.Int16,System.Int16,System.Byte[])" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="CompareTo(System.Guid)" />
-      <Member Name="CompareTo(System.Object)" />
-      <Member Name="Equals(System.Guid)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetHashCode" />
-      <Member Name="NewGuid" />
-      <Member Name="op_Equality(System.Guid,System.Guid)" />
-      <Member Name="op_Inequality(System.Guid,System.Guid)" />
-      <Member Name="Parse(System.String)" />
-      <Member Name="ParseExact(System.String,System.String)" />
-      <Member Name="ToByteArray" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.String)" />
-      <Member Name="ToString(System.String,System.IFormatProvider)" />
-      <Member Name="TryParse(System.String,System.Guid@)" />
-      <Member Name="TryParseExact(System.String,System.String,System.Guid@)" />
-    </Type>
-    <Type Name="System.IAsyncResult">
-      <Member Name="get_AsyncState" />
-      <Member Name="get_AsyncWaitHandle" />
-      <Member Name="get_CompletedSynchronously" />
-      <Member Name="get_IsCompleted" />
-      <Member MemberType="Property" Name="AsyncState" />
-      <Member MemberType="Property" Name="AsyncWaitHandle" />
-      <Member MemberType="Property" Name="CompletedSynchronously" />
-      <Member MemberType="Property" Name="IsCompleted" />
-    </Type>
-    <Type Name="System.ICloneable">
-      <Member Name="Clone" />
-    </Type>
-    <Type Name="System.IComparable">
-      <Member Name="CompareTo(System.Object)" />
-    </Type>
-    <Type Name="System.IComparable&lt;T&gt;">
-      <Member Name="CompareTo(T)" />
-    </Type>
-    <Type Name="System.IConvertible">
-      <Member Name="GetTypeCode" />
-      <Member Name="ToBoolean(System.IFormatProvider)" />
-      <Member Name="ToByte(System.IFormatProvider)" />
-      <Member Name="ToChar(System.IFormatProvider)" />
-      <Member Name="ToDateTime(System.IFormatProvider)" />
-      <Member Name="ToDecimal(System.IFormatProvider)" />
-      <Member Name="ToDouble(System.IFormatProvider)" />
-      <Member Name="ToInt16(System.IFormatProvider)" />
-      <Member Name="ToInt32(System.IFormatProvider)" />
-      <Member Name="ToInt64(System.IFormatProvider)" />
-      <Member Name="ToSByte(System.IFormatProvider)" />
-      <Member Name="ToSingle(System.IFormatProvider)" />
-      <Member Name="ToString(System.IFormatProvider)" />
-      <Member Name="ToType(System.Type,System.IFormatProvider)" />
-      <Member Name="ToUInt16(System.IFormatProvider)" />
-      <Member Name="ToUInt32(System.IFormatProvider)" />
-      <Member Name="ToUInt64(System.IFormatProvider)" />
-    </Type>
-    <Type Name="System.ICustomFormatter">
-      <Member Name="Format(System.String,System.Object,System.IFormatProvider)" />
-    </Type>
-    <Type Name="System.IDisposable">
-      <Member Name="Dispose" />
-    </Type>
-    <Type Name="System.IEquatable&lt;T&gt;">
-      <Member Name="Equals(T)" />
-    </Type>
-    <Type Name="System.IFormatProvider">
-      <Member Name="GetFormat(System.Type)" />
-    </Type>
-    <Type Name="System.IFormattable">
-      <Member Name="ToString(System.String,System.IFormatProvider)" />
-    </Type>
-    <Type Name="System.IndexOutOfRangeException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.InsufficientExecutionStackException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Internal">
-      <Member Status="ImplRoot" Name="CommonlyUsedGenericInstantiations" />
-      <Member Status="ImplRoot" Name="CommonlyUsedWinRTRedirectedInterfaceStubs" Condition="FEATURE_COMINTEROP" />
-    </Type>
-    <Type Name="System.InsufficientMemoryException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-    </Type>
-    <Type Name="System.Int16">
-      <Member MemberType="Field" Name="MaxValue" />
-      <Member MemberType="Field" Name="MinValue" />
-      <Member Name="CompareTo(System.Int16)" />
-      <Member Name="CompareTo(System.Object)" />
-      <Member Name="Equals(System.Int16)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetTypeCode" />
-      <Member Name="Parse(System.String)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)" />
-      <Member Name="Parse(System.String,System.IFormatProvider)" />
-      <Member Name="TryParse(System.String,System.Int16@)" />
-      <Member Name="TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Int16@)" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.IFormatProvider)" />
-      <Member Name="ToString(System.String)" />
-      <Member Name="ToString(System.String,System.IFormatProvider)" />
-    </Type>
-    <Type Name="System.Int32">
-      <Member MemberType="Field" Name="MaxValue" />
-      <Member MemberType="Field" Name="MinValue" />
-      <Member Name="CompareTo(System.Int32)" />
-      <Member Name="CompareTo(System.Object)" />
-      <Member Name="Equals(System.Int32)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetTypeCode" />
-      <Member Name="Parse(System.String)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)" />
-      <Member Name="Parse(System.String,System.IFormatProvider)" />
-      <Member Name="TryParse(System.String,System.Int32@)" />
-      <Member Name="TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Int32@)" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.IFormatProvider)" />
-      <Member Name="ToString(System.String)" />
-      <Member Name="ToString(System.String,System.IFormatProvider)" />
-    </Type>
-    <Type Name="System.Int64">
-      <Member MemberType="Field" Name="MaxValue" />
-      <Member MemberType="Field" Name="MinValue" />
-      <Member Name="CompareTo(System.Int64)" />
-      <Member Name="CompareTo(System.Object)" />
-      <Member Name="Equals(System.Int64)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetTypeCode" />
-      <Member Name="Parse(System.String)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)" />
-      <Member Name="Parse(System.String,System.IFormatProvider)" />
-      <Member Name="TryParse(System.String,System.Int64@)" />
-      <Member Name="TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Int64@)" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.IFormatProvider)" />
-      <Member Name="ToString(System.String)" />
-      <Member Name="ToString(System.String,System.IFormatProvider)" />
-    </Type>
-    <Type Name="System.IntPtr">
-      <Member MemberType="Field" Name="Zero" />
-      <Member Name="#ctor(System.Int32)" />
-      <Member Name="#ctor(System.Int64)" />
-      <Member Name="#ctor(System.Void*)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="Add(System.IntPtr,System.Int32)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_Size" />
-      <Member Name="GetHashCode" />
-      <Member Name="op_Addition(System.IntPtr,System.Int32)" />
-      <Member Name="op_Equality(System.IntPtr,System.IntPtr)" />
-      <Member Name="op_Explicit(System.Int32)" ReturnType="System.IntPtr" />
-      <Member Name="op_Explicit(System.Int64)" ReturnType="System.IntPtr" />
-      <Member Name="op_Explicit(System.IntPtr)" ReturnType="System.Int32" />
-      <Member Name="op_Explicit(System.IntPtr)" ReturnType="System.Int64" />
-      <Member Name="op_Explicit(System.IntPtr)" ReturnType="System.Void*" />
-      <Member Name="op_Explicit(System.Void*)" ReturnType="System.IntPtr" />
-      <Member Name="op_Inequality(System.IntPtr,System.IntPtr)" />
-      <Member Name="op_Subtraction(System.IntPtr,System.Int32)" />
-      <Member Name="Subtract(System.IntPtr,System.Int32)" />
-      <Member Name="ToInt32" />
-      <Member Name="ToInt64" />
-      <Member Name="ToPointer" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.String)" />
-      <Member MemberType="Property" Name="Size" />
-    </Type>
-    <Type Name="System.InvalidCastException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.String,System.Int32)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.InvalidOperationException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.InvalidProgramException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.InvalidTimeZoneException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.IO.FileLoadException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.String,System.String)" />
-      <Member Name="#ctor(System.String,System.String,System.Exception)" />
-      <Member Name="#ctor(System.String,System.String,System.Int32)" /> <!-- Used by EE, do not remove -->
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="get_FileName" />
-      <Member Name="get_FusionLog" />
-      <Member MemberType="Property" Name="FusionLog" />
-    </Type>
-    <Type Name="System.IObservable&lt;T&gt;">
-      <Member Name="Subscribe(System.IObserver&lt;T&gt;)"/>
-    </Type>
-    <Type Name="System.IObserver&lt;T&gt;">
-      <Member Name="OnCompleted"/>
-      <Member Name="OnError(System.Exception)"/>
-      <Member Name="OnNext(T)"/>
-    </Type>
-    <Type Name="System.IProgress&lt;T&gt;">
-      <Member Name="Report(T)" />
-    </Type>
-    <Type Name="System.IServiceProvider">
-      <Member Name="GetService(System.Type)" />
-    </Type>
-    <Type Name="System.Lazy&lt;T&gt;">
-      <Member Name="#ctor"/>
-      <Member Name="#ctor(T)"/>
-      <Member Name="#ctor(System.Func&lt;T&gt;)"/>
-      <Member Name="#ctor(System.Boolean)"/>
-      <Member Name="#ctor(System.Threading.LazyThreadSafetyMode)"/>
-      <Member Name="#ctor(System.Func&lt;T&gt;,System.Boolean)"/>
-      <Member Name="#ctor(System.Func&lt;T&gt;,System.Threading.LazyThreadSafetyMode)"/>
-      <Member MemberType="Property" Name="IsValueCreated"/>
-      <Member Name="get_IsValueCreated"/>
-      <Member MemberType="Property" Name="Value"/>
-      <Member Name="get_Value"/>
-      <Member Status="ImplRoot" Name="OnSerializing(System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.LocalDataStoreSlot">
-      <Member Status="ImplRoot" Name="Finalize" />
-    </Type>
-    <Type Name="System.MarshalByRefObject">
-      <Member Name="#ctor" />
-      <Member Name="GetLifetimeService" />
-      <Member Name="InitializeLifetimeService" />
-      <Member Name="MemberwiseClone(System.Boolean)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.System_LazyDebugView&lt;T&gt;">
-      <Member Status="ImplRoot" Name="#ctor(System.Lazy&lt;T&gt;)"/>
-      <Member Status="ImplRoot" MemberType="Property" Name="IsValueCreated"/>
-      <Member Status="ImplRoot" Name="get_IsValueCreated"/>
-      <Member Status="ImplRoot" MemberType="Property" Name="Value"/>
-      <Member Status="ImplRoot" Name="get_Value"/>
-      <Member Status="ImplRoot" MemberType="Property" Name="Mode"/>
-      <Member Status="ImplRoot" Name="get_Mode"/>
-      <Member Status="ImplRoot" MemberType="Property" Name="IsValueFaulted"/>
-      <Member Status="ImplRoot" Name="get_IsValueFaulted"/>
-    </Type>
-    <Type Name="System.Math">
-      <Member MemberType="Field" Name="E" />
-      <Member MemberType="Field" Name="PI" />
-      <Member Name="Abs(System.Decimal)" />
-      <Member Name="Abs(System.Double)" />
-      <Member Name="Abs(System.Int16)" />
-      <Member Name="Abs(System.Int32)" />
-      <Member Name="Abs(System.Int64)" />
-      <Member Name="Abs(System.SByte)" />
-      <Member Name="Abs(System.Single)" />
-      <Member Name="Acos(System.Double)" />
-      <Member Name="Asin(System.Double)" />
-      <Member Name="Atan(System.Double)" />
-      <Member Name="Atan2(System.Double,System.Double)" />
-      <Member Name="BigMul(System.Int32,System.Int32)" />
-      <Member Name="Ceiling(System.Decimal)"  />
-      <Member Name="Ceiling(System.Double)"/>
-      <Member Name="Clamp(System.Byte,System.Byte,System.Byte)" />
-      <Member Name="Clamp(System.Decimal,System.Decimal,System.Decimal)" />
-      <Member Name="Clamp(System.Double,System.Double,System.Double)" />
-      <Member Name="Clamp(System.Int16,System.Int16,System.Int16)" />
-      <Member Name="Clamp(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="Clamp(System.Int64,System.Int64,System.Int64)" />
-      <Member Name="Clamp(System.SByte,System.SByte,System.SByte)" />
-      <Member Name="Clamp(System.Single,System.Single,System.Single)" />
-      <Member Name="Clamp(System.UInt16,System.UInt16,System.UInt16)" />
-      <Member Name="Clamp(System.UInt32,System.UInt32,System.UInt32)" />
-      <Member Name="Clamp(System.UInt64,System.UInt64,System.UInt64)" />
-      <Member Name="Cos(System.Double)" />
-      <Member Name="Cosh(System.Double)" />
-      <Member Name="DivRem(System.Int32,System.Int32,System.Int32@)" />
-      <Member Name="DivRem(System.Int64,System.Int64,System.Int64@)" />
-      <Member Name="Exp(System.Double)" />
-      <Member Name="Floor(System.Decimal)"  />
-      <Member Name="Floor(System.Double)" />
-      <Member Name="IEEERemainder(System.Double,System.Double)" />
-      <Member Name="Log(System.Double)" />
-      <Member Name="Log(System.Double,System.Double)" />
-      <Member Name="Log10(System.Double)" />
-      <Member Name="Max(System.Byte,System.Byte)" />
-      <Member Name="Max(System.Decimal,System.Decimal)" />
-      <Member Name="Max(System.Double,System.Double)" />
-      <Member Name="Max(System.Int16,System.Int16)" />
-      <Member Name="Max(System.Int32,System.Int32)" />
-      <Member Name="Max(System.Int64,System.Int64)" />
-      <Member Name="Max(System.SByte,System.SByte)" />
-      <Member Name="Max(System.Single,System.Single)" />
-      <Member Name="Max(System.UInt16,System.UInt16)" />
-      <Member Name="Max(System.UInt32,System.UInt32)" />
-      <Member Name="Max(System.UInt64,System.UInt64)" />
-      <Member Name="Min(System.Byte,System.Byte)" />
-      <Member Name="Min(System.Decimal,System.Decimal)" />
-      <Member Name="Min(System.Double,System.Double)" />
-      <Member Name="Min(System.Int16,System.Int16)" />
-      <Member Name="Min(System.Int32,System.Int32)" />
-      <Member Name="Min(System.Int64,System.Int64)" />
-      <Member Name="Min(System.SByte,System.SByte)" />
-      <Member Name="Min(System.Single,System.Single)" />
-      <Member Name="Min(System.UInt16,System.UInt16)" />
-      <Member Name="Min(System.UInt32,System.UInt32)" />
-      <Member Name="Min(System.UInt64,System.UInt64)" />
-      <Member Name="Pow(System.Double,System.Double)" />
-      <Member Name="Round(System.Decimal)" />
-      <Member Name="Round(System.Decimal,System.Int32)" />
-      <Member Name="Round(System.Decimal,System.Int32,System.MidpointRounding)"  />
-      <Member Name="Round(System.Decimal,System.MidpointRounding)"  />
-      <Member Name="Round(System.Double)" />
-      <Member Name="Round(System.Double,System.Int32)" />
-      <Member Name="Round(System.Double,System.Int32,System.MidpointRounding)"  />
-      <Member Name="Round(System.Double,System.MidpointRounding)"  />
-      <Member Name="Sign(System.Decimal)" />
-      <Member Name="Sign(System.Double)" />
-      <Member Name="Sign(System.Int16)" />
-      <Member Name="Sign(System.Int32)" />
-      <Member Name="Sign(System.Int64)" />
-      <Member Name="Sign(System.SByte)" />
-      <Member Name="Sign(System.Single)" />
-      <Member Name="Sin(System.Double)" />
-      <Member Name="Sinh(System.Double)" />
-      <Member Name="Sqrt(System.Double)" />
-      <Member Name="Tan(System.Double)" />
-      <Member Name="Tanh(System.Double)" />
-      <Member Name="Truncate(System.Decimal)"  />
-      <Member Name="Truncate(System.Double)"  />
-    </Type>
-    <Type Name="System.MathF">
-      <Member MemberType="Field" Name="E" />
-      <Member MemberType="Field" Name="PI" />
-      <Member Name="Abs(System.Single)" />
-      <Member Name="Acos(System.Single)" />
-      <Member Name="Asin(System.Single)" />
-      <Member Name="Atan(System.Single)" />
-      <Member Name="Atan2(System.Single,System.Single)" />
-      <Member Name="Ceiling(System.Single)"/>
-      <Member Name="Cos(System.Single)" />
-      <Member Name="Cosh(System.Single)" />
-      <Member Name="Exp(System.Single)" />
-      <Member Name="Floor(System.Single)" />
-      <Member Name="IEEERemainder(System.Single,System.Single)" />
-      <Member Name="Log(System.Single)" />
-      <Member Name="Log(System.Single,System.Single)" />
-      <Member Name="Log10(System.Single)" />
-      <Member Name="Max(System.Single,System.Single)" />
-      <Member Name="Min(System.Single,System.Single)" />
-      <Member Name="Pow(System.Single,System.Single)" />
-      <Member Name="Round(System.Single)" />
-      <Member Name="Round(System.Single,System.Int32)" />
-      <Member Name="Round(System.Single,System.Int32,System.MidpointRounding)"  />
-      <Member Name="Round(System.Single,System.MidpointRounding)"  />
-      <Member Name="Sign(System.Single)" />
-      <Member Name="Sin(System.Single)" />
-      <Member Name="Sinh(System.Single)" />
-      <Member Name="Sqrt(System.Single)" />
-      <Member Name="Tan(System.Single)" />
-      <Member Name="Tanh(System.Single)" />
-      <Member Name="Truncate(System.Single)"  />
-    </Type>
-    <Type Name="System.MemberAccessException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.MethodAccessException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.MidpointRounding">
-      <Member MemberType="Field" Name="AwayFromZero" />
-      <Member MemberType="Field" Name="ToEven" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.MissingFieldException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.MissingMemberException">
-      <Member MemberType="Field" Name="ClassName" />
-      <Member MemberType="Field" Name="MemberName" />
-      <Member MemberType="Field" Name="Signature" />
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.String,System.String)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.MissingMethodException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.String,System.String)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.ModuleHandle">
-      <Member MemberType="Field" Name="EmptyHandle" />
-      <Member Name="GetHashCode" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.ModuleHandle)" />
-      <Member Name="get_MDStreamVersion" />
-      <Member Name="op_Equality(System.ModuleHandle,System.ModuleHandle)" />
-      <Member Name="op_Inequality(System.ModuleHandle,System.ModuleHandle)" />
-      <Member Name="GetRuntimeTypeHandleFromMetadataToken(System.Int32)" />
-      <Member Name="GetRuntimeMethodHandleFromMetadataToken(System.Int32)" />
-      <Member Name="GetRuntimeFieldHandleFromMetadataToken(System.Int32)" />
-      <Member Name="ResolveTypeHandle(System.Int32)" />
-      <Member Name="ResolveTypeHandle(System.Int32,System.RuntimeTypeHandle[],System.RuntimeTypeHandle[])" />
-      <Member Name="ResolveMethodHandle(System.Int32)" />
-      <Member Name="ResolveMethodHandle(System.Int32,System.RuntimeTypeHandle[],System.RuntimeTypeHandle[])" />
-      <Member Name="ResolveFieldHandle(System.Int32)" />
-      <Member Name="ResolveFieldHandle(System.Int32,System.RuntimeTypeHandle[],System.RuntimeTypeHandle[])" />
-      <Member MemberType="Property" Name="MDStreamVersion" />
-    </Type>
-    <Type Name="System.MTAThreadAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.MulticastDelegate">
-      <Member Name="#ctor(System.Object,System.String)" />
-      <Member Name="#ctor(System.Type,System.String)" />
-      <Member Name="CombineImpl(System.Delegate)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetInvocationList" />
-      <Member Name="GetMethodImpl" />
-      <Member Name="GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="op_Equality(System.MulticastDelegate,System.MulticastDelegate)" />
-      <Member Name="op_Inequality(System.MulticastDelegate,System.MulticastDelegate)" />
-      <Member Name="RemoveImpl(System.Delegate)" />
-      <Member Status="ImplRoot" Name="CtorClosed(System.Object,System.IntPtr)" />
-      <Member Status="ImplRoot" Name="CtorClosedStatic(System.Object,System.IntPtr)" />
-      <Member Status="ImplRoot" Name="CtorOpened(System.Object,System.IntPtr,System.IntPtr)" />
-      <Member Status="ImplRoot" Name="CtorRTClosed(System.Object,System.IntPtr)" />
-      <Member Status="ImplRoot" Name="CtorSecureClosed(System.Object,System.IntPtr,System.IntPtr,System.IntPtr)" />
-      <Member Status="ImplRoot" Name="CtorSecureClosedStatic(System.Object,System.IntPtr,System.IntPtr,System.IntPtr)" />
-      <Member Status="ImplRoot" Name="CtorSecureOpened(System.Object,System.IntPtr,System.IntPtr,System.IntPtr,System.IntPtr)" />
-      <Member Status="ImplRoot" Name="CtorSecureRTClosed(System.Object,System.IntPtr,System.IntPtr,System.IntPtr)" />
-      <Member Status="ImplRoot" Name="CtorSecureVirtualDispatch(System.Object,System.IntPtr,System.IntPtr,System.IntPtr,System.IntPtr)" />
-      <Member Status="ImplRoot" Name="CtorVirtualDispatch(System.Object,System.IntPtr,System.IntPtr)" />
-      <Member Status="ImplRoot" Name="CtorCollectibleClosedStatic(System.Object,System.IntPtr,System.IntPtr)" />
-      <Member Status="ImplRoot" Name="CtorCollectibleOpened(System.Object,System.IntPtr,System.IntPtr,System.IntPtr)" />
-      <Member Status="ImplRoot" Name="CtorCollectibleVirtualDispatch(System.Object,System.IntPtr,System.IntPtr,System.IntPtr)" />
-    </Type>
-    <Type Name="System.MulticastNotSupportedException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.NonSerializedAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.NotFiniteNumberException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Double)" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Double)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.String,System.Double,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="get_OffendingNumber" />
-      <Member MemberType="Property" Name="OffendingNumber" />
-    </Type>
-    <Type Name="System.NotImplementedException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.NotSupportedException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Nullable">
-      <Member Name="Compare&lt;T&gt;(System.Nullable&lt;T&gt;,System.Nullable&lt;T&gt;)" />
-      <Member Name="Equals&lt;T&gt;(System.Nullable&lt;T&gt;,System.Nullable&lt;T&gt;)" />
-      <Member Name="GetUnderlyingType(System.Type)" />
-    </Type>
-    <Type Name="System.Nullable&lt;T&gt;">
-      <Member Name="#ctor(T)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_HasValue" />
-      <Member Name="get_Value" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetValueOrDefault" />
-      <Member Name="GetValueOrDefault(T)" />
-      <Member Name="op_Explicit(System.Nullable&lt;T&gt;)" ReturnType="T" />
-      <Member Name="op_Implicit(T)" ReturnType="System.Nullable&lt;T&gt;" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="HasValue" />
-      <Member MemberType="Property" Name="Value" />
-    </Type>
-    <Type Name="System.NullReferenceException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Object">
-      <Member Name="#ctor" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.Object,System.Object)" />
-      <Member Name="Finalize" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetType" />
-      <Member Name="MemberwiseClone" />
-      <Member Name="ReferenceEquals(System.Object,System.Object)" />
-      <Member Name="ToString" />
-      <Member Status="ImplRoot" Name="FieldSetter(System.String,System.String,System.Object)" /> <!-- EE -->
-      <Member Status="ImplRoot" Name="FieldGetter(System.String,System.String,System.Object@)" /> <!-- EE -->
-    </Type>
-    <Type Name="System.ObjectDisposedException">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.String,System.String)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="get_ObjectName" />
-      <Member MemberType="Property" Name="ObjectName" />
-    </Type>
-    <Type Name="System.ObsoleteAttribute">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Boolean)" />
-      <Member Name="get_IsError" />
-      <Member Name="get_Message" />
-      <Member MemberType="Property" Name="IsError" />
-      <Member MemberType="Property" Name="Message" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.OleAutBinder" Condition="FEATURE_COMINTEROP" />
-    <Type Name="System.OutOfMemoryException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.OverflowException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.ParamArrayAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.ParseNumbers">
-      <Member Status="ImplRoot" Name="StringToInt(System.String,System.Int32,System.Int32,System.Int32@)"  />
-      <Member Status="ImplRoot" Name="StringToInt(System.String,System.Int32,System.Int32,System.Int32*)"  />
-      <Member Status="ImplRoot" Name="StringToLong(System.String,System.Int32,System.Int32,System.Int32@)" />
-      <Member Status="ImplRoot" Name="StringToLong(System.String,System.Int32,System.Int32,System.Int32*)" />
-    </Type>
-    <Type Name="System.PlatformNotSupportedException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Predicate&lt;T&gt;">
-      <Member Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Name="BeginInvoke(T,System.AsyncCallback,System.Object)" />
-      <Member Name="EndInvoke(System.IAsyncResult)" />
-      <Member Name="Invoke(T)" />
-    </Type>
-    <Type Name="System.Progress&lt;T&gt;">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Action&lt;T&gt;)" />
-      <Member MemberType="Event" Name="ProgressChanged" />
-      <Member Name="OnReport(T)" />
-    </Type>
-    <Type Name="System.Random">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Int32)" />
-      <Member Name="Next" />
-      <Member Name="Next(System.Int32)" />
-      <Member Name="Next(System.Int32,System.Int32)" />
-      <Member Name="NextBytes(System.Byte[])" />
-      <Member Name="NextDouble" />
-      <Member Name="Sample" />
-    </Type>
-    <Type Name="System.RankException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Reflection.AmbiguousMatchException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Reflection.AssemblyContentType">
-        <Member MemberType="Field" Name="Default"/>
-        <Member MemberType="Field" Name="WindowsRuntime"/>
-        <Member MemberType="Field" Name="value__"/>
-    </Type>
-    <Type Name="System.Reflection.Assembly">
-      <Member Name="#ctor" />
-      <Member Name="CreateInstance(System.String)" />
-      <Member Name="CreateInstance(System.String,System.Boolean)" />
-      <Member Name="CreateInstance(System.String,System.Boolean,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object[],System.Globalization.CultureInfo,System.Object[])" />
-      <Member Name="CreateQualifiedName(System.String,System.String)" />
-      <Member Name="GetReferencedAssemblies" />
-      <Member Name="get_EntryPoint" />
-      <Member Name="get_FullName" />
-      <Member Name="get_GlobalAssemblyCache" />
-      <Member Name="get_HostContext" />
-      <Member Name="get_ImageRuntimeVersion" />
-      <Member Name="get_IsFullyTrusted" />
-      <Member Name="get_IsDynamic" />
-      <Member Name="get_CodeBase" />
-      <Member Name="get_EscapedCodeBase" />
-      <Member Name="get_Location" />
-      <Member Name="get_ManifestModule" />
-      <Member Name="get_CustomAttributes" />
-      <Member Name="get_Modules" />
-      <Member Name="get_ReflectionOnly" />
-      <Member Name="get_SecurityRuleSet" />
-      <Member Name="GetAssembly(System.Type)" />
-      <Member Name="op_Equality(System.Reflection.Assembly,System.Reflection.Assembly)" />
-      <Member Name="op_Inequality(System.Reflection.Assembly,System.Reflection.Assembly)" />
-      <Member Name="GetCallingAssembly" />
-      <Member Name="GetCustomAttributes(System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Type,System.Boolean)" />
-      <Member Name="GetCustomAttributesData" />
-      <Member Name="GetExecutingAssembly" />
-      <Member Name="GetEntryAssembly" />
-      <Member Name="GetExportedTypes" />
-      <Member Name="GetFile(System.String)" />
-      <Member Name="GetFiles" />
-      <Member Name="GetFiles(System.Boolean)" />
-      <Member Name="GetLoadedModules" />
-      <Member Name="GetLoadedModules(System.Boolean)" />
-      <Member Name="GetManifestResourceNames" />
-      <Member Name="GetManifestResourceStream(System.String)" />
-      <Member Name="GetManifestResourceInfo(System.String)" />
-      <Member Name="GetManifestResourceStream(System.Type,System.String)" />
-      <Member Name="GetModule(System.String)" />
-      <Member Name="GetModules" />
-      <Member Name="GetModules(System.Boolean)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetName(System.Boolean)" />
-      <Member Name="GetName" />
-      <Member Name="GetSatelliteAssembly(System.Globalization.CultureInfo)" />
-      <Member Name="GetSatelliteAssembly(System.Globalization.CultureInfo,System.Version)" />
-      <Member Name="GetType(System.String)" />
-      <Member Name="GetType(System.String,System.Boolean)" />
-      <Member Name="GetType(System.String,System.Boolean,System.Boolean)" />
-      <Member Name="GetTypes" />
-      <Member Name="IsDefined(System.Type,System.Boolean)" />
-      <Member Name="IsDynamic" MemberType="Property" />
-      <Member Name="Load(System.Reflection.AssemblyName)" />
-      <Member Name="Load(System.String)" />
-      <Member Name="Load(System.Byte[])" />
-      <Member Name="Load(System.Byte[],System.Byte[])" />
-      <Member Name="LoadFile(System.String)" />
-      <Member Name="LoadFrom(System.String)" />
-      <Member Name="LoadFrom(System.String,System.Byte[],System.Configuration.Assemblies.AssemblyHashAlgorithm)" />
-      <Member Name="LoadModule(System.String,System.Byte[])" />
-      <Member Name="LoadModule(System.String,System.Byte[],System.Byte[])" />
-      <Member Name="LoadWithPartialName(System.String)" />
-      <Member Name="ReflectionOnlyLoad(System.String)" />
-      <Member Name="ReflectionOnlyLoad(System.Byte[])" />
-      <Member Name="ReflectionOnlyLoadFrom(System.String)" />
-      <Member Name="ToString" />
-      <Member Name="UnsafeLoadFrom(System.String)" />
-      <Member MemberType="Property" Name="DefinedTypes" />
-      <Member MemberType="Property" Name="CustomAttributes" />
-      <Member MemberType="Property" Name="Modules" />
-      <Member MemberType="Property" Name="ExportedTypes" />
-      <Member MemberType="Property" Name="EntryPoint" />
-      <Member MemberType="Property" Name="FullName" />
-      <Member MemberType="Property" Name="GlobalAssemblyCache" />
-      <Member MemberType="Property" Name="HostContext" />
-      <Member MemberType="Property" Name="CodeBase" />
-      <Member MemberType="Property" Name="EscapedCodeBase" />
-      <Member MemberType="Property" Name="ImageRuntimeVersion" />
-      <Member MemberType="Property" Name="IsFullyTrusted" />
-      <Member MemberType="Property" Name="Location" />
-      <Member MemberType="Property" Name="ManifestModule" />
-      <Member MemberType="Property" Name="SecurityRuleSet" />
-      <Member MemberType="Event" Name="ModuleResolve" />
-      <Member Name="add_ModuleResolve(System.Reflection.ModuleResolveEventHandler)" />
-      <Member Name="remove_ModuleResolve(System.Reflection.ModuleResolveEventHandler)" />
-    </Type>
-    <Type Name="System.Reflection.IntrospectionExtensions">
-      <Member Name="GetTypeInfo(System.Type)" />
-    </Type>
-    <Type Name="System.Reflection.IReflectableType">
-      <Member Name="GetTypeInfo" />
-    </Type>
-    <Type Name="System.Reflection.ProcessorArchitecture">
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="MSIL" />
-      <Member MemberType="Field" Name="X86" />
-      <Member MemberType="Field" Name="IA64" />
-      <Member MemberType="Field" Name="Amd64" />
-      <Member MemberType="Field" Name="Arm" />
-    </Type>
-    <Type Name="System.Reflection.ReflectionContext">
-      <Member Name="#ctor" />
-      <Member Name="MapAssembly(System.Reflection.Assembly)" />
-      <Member Name="MapType(System.Reflection.TypeInfo)" />
-      <Member Name="GetTypeForObject(System.Object)" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Reflection.ResourceLocation">
-      <Member MemberType="Field" Name="ContainedInAnotherAssembly" />
-      <Member MemberType="Field" Name="ContainedInManifestFile" />
-      <Member MemberType="Field" Name="Embedded" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Reflection.RuntimeAssembly">
-      <Member Status="ImplRoot" MemberType="Event" Name="_ModuleResolve" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_assembly" />
-      <Member Status="ImplRoot" Name="OnModuleResolveEvent(System.String)" /> <!-- EE -->
-      <Member Status="ImplRoot" MemberType="Property" Name="DefinedTypes" />
-      <!-- Assembly.LoadFrom throws a NotSupportedException.  Prevent this internal helper from being stripped by the rewriter so that tests may reflect and call it since they need LoadFrom functionality -->
-      <Member Status="ImplRoot" Name="InternalLoadFrom(System.String,System.Security.Policy.Evidence,System.Byte[],System.Configuration.Assemblies.AssemblyHashAlgorithm,System.Boolean,System.Boolean,System.Threading.StackCrawlMark@)" />
-    </Type>
-    <Type Name="System.Reflection.TypeInfo">
-      <Member Name="#ctor" />
-      <Member Name="AsType" />
-      <Member MemberType="Property" Name="GenericTypeParameters" />
-      <Member Name="IsAssignableFrom(System.Reflection.TypeInfo)" />
-      <Member Name="GetDeclaredEvent(System.String)" />
-      <Member Name="GetDeclaredField(System.String)" />
-      <Member Name="GetDeclaredMethod(System.String)" />
-      <Member Name="GetDeclaredMethods(System.String)" />
-      <Member Name="GetDeclaredNestedType(System.String)" />
-      <Member Name="GetDeclaredProperty(System.String)" />
-      <Member MemberType="Property" Name="DeclaredConstructors" />
-      <Member MemberType="Property" Name="DeclaredEvents" />
-      <Member MemberType="Property" Name="DeclaredFields" />
-      <Member MemberType="Property" Name="DeclaredMembers" />
-      <Member MemberType="Property" Name="DeclaredMethods" />
-      <Member MemberType="Property" Name="DeclaredNestedTypes" />
-      <Member MemberType="Property" Name="DeclaredProperties" />
-      <Member MemberType="Property" Name="ImplementedInterfaces" />
-    </Type>
-    <Type Name="System.Reflection.AssemblyAlgorithmIdAttribute">
-      <Member Name="#ctor(System.Configuration.Assemblies.AssemblyHashAlgorithm)" />
-      <Member Name="#ctor(System.UInt32)" />
-      <Member Name="get_AlgorithmId" />
-      <Member MemberType="Property" Name="AlgorithmId" />
-    </Type>
-    <Type Name="System.Reflection.AssemblyCompanyAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_Company" />
-      <Member MemberType="Property" Name="Company" />
-    </Type>
-    <Type Name="System.Reflection.AssemblyConfigurationAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_Configuration" />
-      <Member MemberType="Property" Name="Configuration" />
-    </Type>
-    <Type Name="System.Reflection.AssemblyCopyrightAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_Copyright" />
-      <Member MemberType="Property" Name="Copyright" />
-    </Type>
-    <Type Name="System.Reflection.AssemblyCultureAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_Culture" />
-      <Member MemberType="Property" Name="Culture" />
-    </Type>
-    <Type Name="System.Reflection.AssemblyDefaultAliasAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_DefaultAlias" />
-      <Member MemberType="Property" Name="DefaultAlias" />
-    </Type>
-    <Type Name="System.Reflection.AssemblyDelaySignAttribute">
-      <Member Name="#ctor(System.Boolean)" />
-      <Member Name="get_DelaySign" />
-      <Member MemberType="Property" Name="DelaySign" />
-    </Type>
-    <Type Name="System.Reflection.AssemblyDescriptionAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_Description" />
-      <Member MemberType="Property" Name="Description" />
-    </Type>
-    <Type Name="System.Reflection.AssemblyMetadataAttribute">
-      <Member Name="#ctor(System.String,System.String)" />
-      <Member Name="get_Key" />
-      <Member Name="get_Value" />
-      <Member MemberType="Property" Name="Key" />
-      <Member MemberType="Property" Name="Value" />
-    </Type>
-    <Type Name="System.Reflection.AssemblyFlagsAttribute">
-      <Member Name="#ctor(System.UInt32)" />
-      <Member Name="#ctor(System.Int32)" />
-      <Member Name="#ctor(System.Reflection.AssemblyNameFlags)" />
-      <Member Name="get_AssemblyFlags" />
-      <Member Name="get_Flags" />
-      <Member MemberType="Property" Name="AssemblyFlags" />
-    </Type>
-    <Type Name="System.Reflection.AssemblyInformationalVersionAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_InformationalVersion" />
-      <Member MemberType="Property" Name="InformationalVersion" />
-    </Type>
-    <Type Name="System.Reflection.AssemblyKeyFileAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_KeyFile" />
-      <Member MemberType="Property" Name="KeyFile" />
-    </Type>
-    <Type Name="System.Reflection.AssemblyKeyNameAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_KeyName" />
-      <Member MemberType="Property" Name="KeyName" />
-    </Type>
-    <Type Name="System.Reflection.AssemblyName">
-      <Member Name="#ctor" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="get_CultureInfo" />
-      <Member Name="get_CultureName" />
-      <Member Name="get_CodeBase" />
-      <Member Name="get_EscapedCodeBase" />
-      <Member Name="get_ContentType" />
-      <Member Name="get_Flags" />
-      <Member Name="get_FullName" />
-      <Member Name="get_HashAlgorithm" />
-      <Member Name="get_VersionCompatibility" />
-      <Member Name="get_Name" />
-      <Member Name="get_ProcessorArchitecture" />
-      <Member Name="get_Version" />
-      <Member Name="get_KeyPair" />
-      <Member Name="GetAssemblyName(System.String)" />
-      <Member Name="GetPublicKey" />
-      <Member Name="GetPublicKeyToken" />
-      <Member Name="set_CultureInfo(System.Globalization.CultureInfo)" />
-      <Member Name="set_CodeBase(System.String)" />
-      <Member Name="set_Flags(System.Reflection.AssemblyNameFlags)" />
-      <Member Name="set_HashAlgorithm(System.Configuration.Assemblies.AssemblyHashAlgorithm)" />
-      <Member Name="set_VersionCompatibility(System.Configuration.Assemblies.AssemblyVersionCompatibility)" />
-      <Member Name="set_Name(System.String)" />
-      <Member Name="set_ProcessorArchitecture(System.Reflection.ProcessorArchitecture)" />
-      <Member Name="set_Version(System.Version)" />
-      <Member Name="set_KeyPair(System.Reflection.StrongNameKeyPair)" />
-      <Member Name="Clone" />
-      <Member Name="SetPublicKey(System.Byte[])" />
-      <Member Name="SetPublicKeyToken(System.Byte[])" />
-      <Member Name="ToString" />
-      <Member Name="GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="OnDeserialization(System.Object)" />
-      <Member Name="ReferenceMatchesDefinition(System.Reflection.AssemblyName,System.Reflection.AssemblyName)" />
-      <Member Name="#ctor(System.String)" />
-      <Member MemberType="Property" Name="CodeBase" />
-      <Member MemberType="Property" Name="CultureInfo" />
-      <Member MemberType="Property" Name="CultureName" />
-      <Member MemberType="Property" Name="ContentType" />
-      <Member MemberType="Property" Name="EscapedCodeBase" />
-      <Member MemberType="Property" Name="Flags" />
-      <Member MemberType="Property" Name="FullName" />
-      <Member MemberType="Property" Name="HashAlgorithm" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="ProcessorArchitecture" />
-      <Member MemberType="Property" Name="Version" />
-      <Member MemberType="Property" Name="VersionCompatibility" />
-      <Member MemberType="Property" Name="KeyPair" />
-    </Type>
-    <Type Name="System.Reflection.AssemblyNameFlags">
-      <Member MemberType="Field" Name="EnableJITcompileOptimizer" />
-      <Member MemberType="Field" Name="EnableJITcompileTracking" />
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="PublicKey" />
-      <Member MemberType="Field" Name="Retargetable" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Reflection.AssemblyProductAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_Product" />
-      <Member MemberType="Property" Name="Product" />
-    </Type>
-    <Type Name="System.Reflection.AssemblySignatureKeyAttribute">
-      <Member Name="#ctor(System.String,System.String)" />
-      <Member Name="get_Countersignature" />
-      <Member Name="get_PublicKey" />
-      <Member MemberType="Property" Name="Countersignature" />
-      <Member MemberType="Property" Name="PublicKey" />
-    </Type>
-    <Type Name="System.Reflection.AssemblyTitleAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_Title" />
-      <Member MemberType="Property" Name="Title" />
-    </Type>
-    <Type Name="System.Reflection.AssemblyTrademarkAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_Trademark" />
-      <Member MemberType="Property" Name="Trademark" />
-    </Type>
-    <Type Name="System.Reflection.AssemblyVersionAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_Version" />
-      <Member MemberType="Property" Name="Version" />
-    </Type>
-    <Type Name="System.Reflection.Binder">
-      <Member Name="#ctor" />
-      <Member Name="BindToField(System.Reflection.BindingFlags,System.Reflection.FieldInfo[],System.Object,System.Globalization.CultureInfo)" />
-      <Member Name="BindToMethod(System.Reflection.BindingFlags,System.Reflection.MethodBase[],System.Object[]@,System.Reflection.ParameterModifier[],System.Globalization.CultureInfo,System.String[],System.Object@)" />
-      <Member Name="ChangeType(System.Object,System.Type,System.Globalization.CultureInfo)" />
-      <Member Name="ReorderArgumentArray(System.Object[]@,System.Object)" />
-      <Member Name="SelectMethod(System.Reflection.BindingFlags,System.Reflection.MethodBase[],System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="SelectProperty(System.Reflection.BindingFlags,System.Reflection.PropertyInfo[],System.Type,System.Type[],System.Reflection.ParameterModifier[])" />
-    </Type>
-    <Type Name="System.Reflection.BindingFlags">
-      <Member MemberType="Field" Name="CreateInstance" />
-      <Member MemberType="Field" Name="DeclaredOnly" />
-      <Member MemberType="Field" Name="Default" />
-      <Member MemberType="Field" Name="ExactBinding" />
-      <Member MemberType="Field" Name="FlattenHierarchy" />
-      <Member MemberType="Field" Name="GetField" />
-      <Member MemberType="Field" Name="GetProperty" />
-      <Member MemberType="Field" Name="IgnoreCase" />
-      <Member MemberType="Field" Name="IgnoreReturn" />
-      <Member MemberType="Field" Name="Instance" />
-      <Member MemberType="Field" Name="InvokeMethod" />
-      <Member MemberType="Field" Name="NonPublic" />
-      <Member MemberType="Field" Name="OptionalParamBinding" />
-      <Member MemberType="Field" Name="Public" />
-      <Member MemberType="Field" Name="PutDispProperty" />
-      <Member MemberType="Field" Name="PutRefDispProperty" />
-      <Member MemberType="Field" Name="SetField" />
-      <Member MemberType="Field" Name="SetProperty" />
-      <Member MemberType="Field" Name="Static" />
-      <Member MemberType="Field" Name="SuppressChangeType" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Reflection.CallingConventions">
-      <Member MemberType="Field" Name="Any" />
-      <Member MemberType="Field" Name="ExplicitThis" />
-      <Member MemberType="Field" Name="HasThis" />
-      <Member MemberType="Field" Name="Standard" />
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="VarArgs" />
-    </Type>
-    <Type Name="System.Reflection.ConstructorInfo">
-      <Member Name="#ctor" />
-      <Member Name="op_Equality(System.Reflection.ConstructorInfo,System.Reflection.ConstructorInfo)" />
-      <Member Name="op_Inequality(System.Reflection.ConstructorInfo,System.Reflection.ConstructorInfo)" />
-      <Member MemberType="Field" Name="ConstructorName" />
-      <Member MemberType="Field" Name="TypeConstructorName" />
-      <Member Name="get_MemberType" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetHashCode" />
-      <Member Name="Invoke(System.Object[])" />
-      <Member Name="Invoke(System.Reflection.BindingFlags,System.Reflection.Binder,System.Object[],System.Globalization.CultureInfo)" />
-      <Member MemberType="Property" Name="MemberType" />
-    </Type>
-    <Type Name="System.Reflection.CustomAttributeData">
-      <Member Name="#ctor" />
-      <Member Name="get_AttributeType" />
-      <Member Name="get_ConstructorArguments" />
-      <Member Name="get_NamedArguments" />
-      <Member Name="get_Constructor" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetCustomAttributes(System.Reflection.Assembly)" />
-      <Member Name="GetCustomAttributes(System.Reflection.MemberInfo)" />
-      <Member Name="GetCustomAttributes(System.Reflection.Module)" />
-      <Member Name="GetCustomAttributes(System.Reflection.ParameterInfo)" />
-      <Member Name="GetHashCode" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="AttributeType" />
-      <Member MemberType="Property" Name="Constructor" />
-      <Member MemberType="Property" Name="ConstructorArguments" />
-      <Member MemberType="Property" Name="NamedArguments" />
-    </Type>
-   <Type Name="System.Reflection.CustomAttributeExtensions">
-      <Member Name="GetCustomAttribute(System.Reflection.Assembly,System.Type)" />
-      <Member Name="GetCustomAttribute(System.Reflection.MemberInfo,System.Type)" />
-      <Member Name="GetCustomAttribute(System.Reflection.MemberInfo,System.Type,System.Boolean)" />
-      <Member Name="GetCustomAttribute(System.Reflection.Module,System.Type)" />
-      <Member Name="GetCustomAttribute(System.Reflection.ParameterInfo,System.Type)" />
-      <Member Name="GetCustomAttribute(System.Reflection.ParameterInfo,System.Type,System.Boolean)" />
-      <Member Name="GetCustomAttribute&lt;T&gt;(System.Reflection.Assembly)" />
-      <Member Name="GetCustomAttribute&lt;T&gt;(System.Reflection.MemberInfo)" />
-      <Member Name="GetCustomAttribute&lt;T&gt;(System.Reflection.MemberInfo,System.Boolean)" />
-      <Member Name="GetCustomAttribute&lt;T&gt;(System.Reflection.Module)" />
-      <Member Name="GetCustomAttribute&lt;T&gt;(System.Reflection.ParameterInfo)" />
-      <Member Name="GetCustomAttribute&lt;T&gt;(System.Reflection.ParameterInfo,System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Reflection.Assembly)" />
-      <Member Name="GetCustomAttributes(System.Reflection.Assembly,System.Type)" />
-      <Member Name="GetCustomAttributes(System.Reflection.MemberInfo)" />
-      <Member Name="GetCustomAttributes(System.Reflection.MemberInfo,System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Reflection.MemberInfo,System.Type)" />
-      <Member Name="GetCustomAttributes(System.Reflection.MemberInfo,System.Type,System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Reflection.Module)" />
-      <Member Name="GetCustomAttributes(System.Reflection.Module,System.Type)" />
-      <Member Name="GetCustomAttributes(System.Reflection.ParameterInfo)" />
-      <Member Name="GetCustomAttributes(System.Reflection.ParameterInfo,System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Reflection.ParameterInfo,System.Type)" />
-      <Member Name="GetCustomAttributes(System.Reflection.ParameterInfo,System.Type,System.Boolean)" />
-      <Member Name="GetCustomAttributes&lt;T&gt;(System.Reflection.Assembly)" />
-      <Member Name="GetCustomAttributes&lt;T&gt;(System.Reflection.MemberInfo)" />
-      <Member Name="GetCustomAttributes&lt;T&gt;(System.Reflection.MemberInfo,System.Boolean)" />
-      <Member Name="GetCustomAttributes&lt;T&gt;(System.Reflection.Module)" />
-      <Member Name="GetCustomAttributes&lt;T&gt;(System.Reflection.ParameterInfo)" />
-      <Member Name="GetCustomAttributes&lt;T&gt;(System.Reflection.ParameterInfo,System.Boolean)" />
-      <Member Name="IsDefined(System.Reflection.Assembly,System.Type)" />
-      <Member Name="IsDefined(System.Reflection.MemberInfo,System.Type)" />
-      <Member Name="IsDefined(System.Reflection.MemberInfo,System.Type,System.Boolean)" />
-      <Member Name="IsDefined(System.Reflection.Module,System.Type)" />
-      <Member Name="IsDefined(System.Reflection.ParameterInfo,System.Type)" />
-      <Member Name="IsDefined(System.Reflection.ParameterInfo,System.Type,System.Boolean)" />
-    </Type>
-    <Type Name="System.Reflection.RuntimeReflectionExtensions">
-      <Member Name="GetMethodInfo(System.Delegate)" />
-      <Member Name="GetRuntimeBaseDefinition(System.Reflection.MethodInfo)" />
-      <Member Name="GetRuntimeEvent(System.Type,System.String)" />
-      <Member Name="GetRuntimeEvents(System.Type)" />
-      <Member Name="GetRuntimeField(System.Type,System.String)" />
-      <Member Name="GetRuntimeFields(System.Type)" />
-      <Member Name="GetRuntimeInterfaceMap(System.Reflection.TypeInfo,System.Type)" />
-      <Member Name="GetRuntimeMethod(System.Type,System.String,System.Type[])" />
-      <Member Name="GetRuntimeMethods(System.Type)" />
-      <Member Name="GetRuntimeProperties(System.Type)" />
-      <Member Name="GetRuntimeProperty(System.Type,System.String)" />
-    </Type>
-    <Type Name="System.Reflection.CustomAttributeNamedArgument">
-      <Member Name="#ctor(System.Reflection.MemberInfo,System.Object)" />
-      <Member Name="#ctor(System.Reflection.MemberInfo,System.Reflection.CustomAttributeTypedArgument)" />
-      <Member Name="get_IsField" />
-      <Member Name="get_MemberInfo" />
-      <Member Name="get_MemberName" />
-      <Member Name="get_TypedValue" />
-      <Member Name="op_Equality(System.Reflection.CustomAttributeNamedArgument,System.Reflection.CustomAttributeNamedArgument)" />
-      <Member Name="op_Inequality(System.Reflection.CustomAttributeNamedArgument,System.Reflection.CustomAttributeNamedArgument)" />
-      <Member MemberType="Property" Name="IsField" />
-      <Member MemberType="Property" Name="MemberName" />
-      <Member MemberType="Property" Name="TypedValue" />
-    </Type>
-    <Type Name="System.Reflection.CustomAttributeTypedArgument">
-      <Member Name="#ctor(System.Object)" />
-      <Member Name="#ctor(System.Type,System.Object)" />
-      <Member Name="get_ArgumentType" />
-      <Member Name="get_Value" />
-      <Member Name="op_Equality(System.Reflection.CustomAttributeTypedArgument,System.Reflection.CustomAttributeTypedArgument)" />
-      <Member Name="op_Inequality(System.Reflection.CustomAttributeTypedArgument,System.Reflection.CustomAttributeTypedArgument)" />
-      <Member MemberType="Property" Name="ArgumentType" />
-      <Member MemberType="Property" Name="Value" />
-    </Type>
-    <Type Name="System.Reflection.CustomAttributeFormatException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Reflection.DefaultMemberAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_MemberName" />
-      <Member MemberType="Property" Name="MemberName" />
-    </Type>
-    <Type Name="System.Reflection.Emit.AssemblyBuilder">
-      <Member Name="DefineDynamicAssembly(System.Reflection.AssemblyName,System.Reflection.Emit.AssemblyBuilderAccess)" />
-      <Member Name="DefineDynamicAssembly(System.Reflection.AssemblyName,System.Reflection.Emit.AssemblyBuilderAccess,System.Collections.Generic.IEnumerable&lt;System.Reflection.Emit.CustomAttributeBuilder&gt;)" />
-      <Member Name="SetCustomAttribute(System.Reflection.ConstructorInfo,System.Byte[])" />
-      <Member Name="DefineDynamicModule(System.String)" />
-      <Member Name="DefineDynamicModule(System.String,System.Boolean)" />
-      <Member Name="get_EntryPoint" />
-      <Member Name="get_ImageRuntimeVersion" />
-      <Member Name="GetDynamicModule(System.String)" />
-      <Member Name="GetExportedTypes" />
-      <Member Name="GetManifestResourceNames" />
-      <Member Name="GetManifestResourceStream(System.String)" />
-      <Member Name="GetManifestResourceStream(System.Type,System.String)" />
-      <Member Name="SetCustomAttribute(System.Reflection.Emit.CustomAttributeBuilder)" />
-      <Member MemberType="Property" Name="EntryPoint" />
-      <Member MemberType="Property" Name="ImageRuntimeVersion" />
-    </Type>
-    <Type Name="System.Reflection.Emit.AssemblyBuilderAccess">
-      <Member MemberType="Field" Name="Run" />
-      <Member MemberType="Field" Name="RunAndCollect" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Reflection.Emit.ConstructorBuilder">
-      <Member Name="DefineParameter(System.Int32,System.Reflection.ParameterAttributes,System.String)" />
-      <Member Name="get_Attributes" />
-      <Member Name="get_CallingConvention" />
-      <Member Name="get_DeclaringType" />
-      <Member Name="get_InitLocals" />
-      <Member Name="get_MethodHandle" />
-      <Member Name="get_Module" />
-      <Member Name="get_Name" />
-      <Member Name="get_ReflectedType" />
-      <Member Name="get_Signature" />
-      <Member Name="GetCustomAttributes(System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Type,System.Boolean)" />
-      <Member Name="GetILGenerator" />
-      <Member Name="GetILGenerator(System.Int32)" />
-      <Member Name="GetMethodImplementationFlags" />
-      <Member Name="GetModule" />
-      <Member Name="GetParameters" />
-      <Member Name="GetToken" />
-      <Member Name="Invoke(System.Object,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object[],System.Globalization.CultureInfo)" />
-      <Member Name="Invoke(System.Reflection.BindingFlags,System.Reflection.Binder,System.Object[],System.Globalization.CultureInfo)" />
-      <Member Name="IsDefined(System.Type,System.Boolean)" />
-      <Member Name="set_InitLocals(System.Boolean)" />
-      <Member Name="SetCustomAttribute(System.Reflection.ConstructorInfo,System.Byte[])" />
-      <Member Name="SetCustomAttribute(System.Reflection.Emit.CustomAttributeBuilder)" />
-      <Member Name="SetImplementationFlags(System.Reflection.MethodImplAttributes)" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="Attributes" />
-      <Member MemberType="Property" Name="CallingConvention" />
-      <Member MemberType="Property" Name="DeclaringType" />
-      <Member MemberType="Property" Name="InitLocals" />
-      <Member MemberType="Property" Name="MethodHandle" />
-      <Member MemberType="Property" Name="Module" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="ReflectedType" />
-      <Member MemberType="Property" Name="Signature" />
-    </Type>
-    <Type Name="System.Reflection.Emit.CustomAttributeBuilder">
-      <Member Name="#ctor(System.Reflection.ConstructorInfo,System.Object[])" />
-      <Member Name="#ctor(System.Reflection.ConstructorInfo,System.Object[],System.Reflection.FieldInfo[],System.Object[])" />
-      <Member Name="#ctor(System.Reflection.ConstructorInfo,System.Object[],System.Reflection.PropertyInfo[],System.Object[])" />
-      <Member Name="#ctor(System.Reflection.ConstructorInfo,System.Object[],System.Reflection.PropertyInfo[],System.Object[],System.Reflection.FieldInfo[],System.Object[])" />
-    </Type>
-    <Type Name="System.RuntimeArgumentHandle"> <!-- MC++ compiler asserts for no particularly good reason if this type is not public -->
-    </Type>
-    <Type Status="ImplRoot" Name="System.RuntimeFieldInfoStub">
-      <Member Status="ImplRoot" MemberType="Field" Name="m_keepalive" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_b" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_c" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_d" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_e" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_fieldHandle" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.RuntimeMethodInfoStub">
-      <Member Status="ImplRoot" MemberType="Field" Name="m_a" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_b" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_c" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_d" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_e" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_f" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_g" />
-    </Type>
-    <Type Name="System.RuntimeTypeHandle">
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="Equals(System.RuntimeTypeHandle)" />
-      <Member Name="op_Equality(System.Object,System.RuntimeTypeHandle)" />
-      <Member Name="op_Equality(System.RuntimeTypeHandle,System.Object)" />
-      <Member Name="GetModuleHandle" />
-      <Member Name="op_Inequality(System.Object,System.RuntimeTypeHandle)" />
-      <Member Name="op_Inequality(System.RuntimeTypeHandle,System.Object)" />
-      <Member Status="ImplRoot" Name="GetTypeHelper(System.Type,System.Type[],System.IntPtr,System.Int32)" /> <!-- EE -->
-      <Member Status="ImplRoot" Name="GetValueInternal(System.RuntimeTypeHandle)" />
-      <Member Name="get_Value" />
-      <Member MemberType="Property" Name="Value" />
-      <!-- EE -->
-    </Type>
-    <Type Name="System.Reflection.Emit.DynamicMethod">
-      <Member Name="#ctor(System.String,System.Type,System.Type[])" />
-      <Member Name="#ctor(System.String,System.Type,System.Type[],System.Boolean)" />
-      <Member Name="#ctor(System.String,System.Reflection.MethodAttributes,System.Reflection.CallingConventions,System.Type,System.Type[],System.Reflection.Module,System.Boolean)" />
-      <Member Name="#ctor(System.String,System.Reflection.MethodAttributes,System.Reflection.CallingConventions,System.Type,System.Type[],System.Type,System.Boolean)" />
-      <Member Name="#ctor(System.String,System.Type,System.Type[],System.Reflection.Module)" />
-      <Member Name="#ctor(System.String,System.Type,System.Type[],System.Reflection.Module,System.Boolean)" />
-      <Member Name="#ctor(System.String,System.Type,System.Type[],System.Type)" />
-      <Member Name="#ctor(System.String,System.Type,System.Type[],System.Type,System.Boolean)" />
-      <Member Name="CreateDelegate(System.Type)" />
-      <Member Name="CreateDelegate(System.Type,System.Object)" />
-      <Member Name="DefineParameter(System.Int32,System.Reflection.ParameterAttributes,System.String)" />
-      <Member Name="get_Attributes" />
-      <Member Name="get_CallingConvention" />
-      <Member Name="get_DeclaringType" />
-      <Member Name="get_InitLocals" />
-      <Member Name="get_MethodHandle" />
-      <Member Name="get_Module" />
-      <Member Name="get_Name" />
-      <Member Name="get_ReflectedType" />
-      <Member Name="get_ReturnParameter" />
-      <Member Name="get_ReturnType" />
-      <Member Name="get_ReturnTypeCustomAttributes" />
-      <Member Name="GetBaseDefinition" />
-      <Member Name="GetCustomAttributes(System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Type,System.Boolean)" />
-      <Member Name="GetILGenerator" />
-      <Member Name="GetILGenerator(System.Int32)" />
-      <Member Name="GetMethodImplementationFlags" />
-      <Member Name="GetParameters" />
-      <Member Name="Invoke(System.Object,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object[],System.Globalization.CultureInfo)" />
-      <Member Name="IsDefined(System.Type,System.Boolean)" />
-      <Member Name="set_InitLocals(System.Boolean)" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="Attributes" />
-      <Member MemberType="Property" Name="CallingConvention" />
-      <Member MemberType="Property" Name="DeclaringType" />
-      <Member MemberType="Property" Name="InitLocals" />
-      <Member MemberType="Property" Name="MethodHandle" />
-      <Member MemberType="Property" Name="Module" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="ReflectedType" />
-      <Member MemberType="Property" Name="ReturnParameter" />
-      <Member MemberType="Property" Name="ReturnType" />
-      <Member MemberType="Property" Name="ReturnTypeCustomAttributes" />
-    </Type>
-    <Type Name="System.Reflection.Emit.EnumBuilder">
-      <Member Name="CreateType" />
-      <Member Name="CreateTypeInfo" />
-      <Member Name="DefineLiteral(System.String,System.Object)" />
-      <Member Name="get_Assembly" />
-      <Member Name="get_AssemblyQualifiedName" />
-      <Member Name="get_BaseType" />
-      <Member Name="get_DeclaringType" />
-      <Member Name="get_FullName" />
-      <Member Name="get_GUID" />
-      <Member Name="get_Module" />
-      <Member Name="get_Name" />
-      <Member Name="get_Namespace" />
-      <Member Name="get_ReflectedType" />
-      <Member Name="get_TypeHandle" />
-      <Member Name="get_TypeToken" />
-      <Member Name="get_UnderlyingField" />
-      <Member Name="get_UnderlyingSystemType" />
-      <Member Name="GetAttributeFlagsImpl" />
-      <Member Name="GetConstructorImpl(System.Reflection.BindingFlags,System.Reflection.Binder,System.Reflection.CallingConventions,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetConstructors(System.Reflection.BindingFlags)" />
-      <Member Name="GetCustomAttributes(System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Type,System.Boolean)" />
-      <Member Name="GetElementType" />
-      <Member Name="GetEvent(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetEvents" />
-      <Member Name="GetEvents(System.Reflection.BindingFlags)" />
-      <Member Name="GetField(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetFields(System.Reflection.BindingFlags)" />
-      <Member Name="GetInterface(System.String,System.Boolean)" />
-      <Member Name="GetInterfaceMap(System.Type)" />
-      <Member Name="GetInterfaces" />
-      <Member Name="GetMember(System.String,System.Reflection.MemberTypes,System.Reflection.BindingFlags)" />
-      <Member Name="GetMembers(System.Reflection.BindingFlags)" />
-      <Member Name="GetMethodImpl(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Reflection.CallingConventions,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetMethods(System.Reflection.BindingFlags)" />
-      <Member Name="GetNestedType(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetNestedTypes(System.Reflection.BindingFlags)" />
-      <Member Name="GetProperties(System.Reflection.BindingFlags)" />
-      <Member Name="GetPropertyImpl(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Type,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="HasElementTypeImpl" />
-      <Member Name="InvokeMember(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object,System.Object[],System.Reflection.ParameterModifier[],System.Globalization.CultureInfo,System.String[])" />
-      <Member Name="IsArrayImpl" />
-      <Member Name="IsByRefImpl" />
-      <Member Name="IsCOMObjectImpl" />
-      <Member Name="IsDefined(System.Type,System.Boolean)" />
-      <Member Name="IsPointerImpl" />
-      <Member Name="IsPrimitiveImpl" />
-      <Member Name="IsValueTypeImpl" />
-      <Member Name="MakeArrayType" />
-      <Member Name="MakeArrayType(System.Int32)" />
-      <Member Name="MakeByRefType" />
-      <Member Name="MakePointerType" />
-      <Member Name="SetCustomAttribute(System.Reflection.ConstructorInfo,System.Byte[])" />
-      <Member Name="SetCustomAttribute(System.Reflection.Emit.CustomAttributeBuilder)" />
-      <Member MemberType="Property" Name="Assembly" />
-      <Member MemberType="Property" Name="AssemblyQualifiedName" />
-      <Member MemberType="Property" Name="BaseType" />
-      <Member MemberType="Property" Name="DeclaringType" />
-      <Member MemberType="Property" Name="FullName" />
-      <Member MemberType="Property" Name="GUID" />
-      <Member MemberType="Property" Name="Module" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="Namespace" />
-      <Member MemberType="Property" Name="ReflectedType" />
-      <Member MemberType="Property" Name="TypeHandle" />
-      <Member MemberType="Property" Name="TypeToken" />
-      <Member MemberType="Property" Name="UnderlyingField" />
-      <Member MemberType="Property" Name="UnderlyingSystemType" />
-    </Type>
-    <Type Name="System.Reflection.Emit.EventBuilder">
-      <Member Name="AddOtherMethod(System.Reflection.Emit.MethodBuilder)" />
-      <Member Name="GetEventToken" />
-      <Member Name="SetAddOnMethod(System.Reflection.Emit.MethodBuilder)" />
-      <Member Name="SetCustomAttribute(System.Reflection.ConstructorInfo,System.Byte[])" />
-      <Member Name="SetCustomAttribute(System.Reflection.Emit.CustomAttributeBuilder)" />
-      <Member Name="SetRaiseMethod(System.Reflection.Emit.MethodBuilder)" />
-      <Member Name="SetRemoveOnMethod(System.Reflection.Emit.MethodBuilder)" />
-    </Type>
-    <Type Name="System.Reflection.Emit.EventToken">
-      <Member MemberType="Field" Name="Empty" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.Reflection.Emit.EventToken)" />
-      <Member Name="get_Token" />
-      <Member Name="GetHashCode" />
-      <Member Name="op_Equality(System.Reflection.Emit.EventToken,System.Reflection.Emit.EventToken)" />
-      <Member Name="op_Inequality(System.Reflection.Emit.EventToken,System.Reflection.Emit.EventToken)" />
-      <Member MemberType="Property" Name="Token" />
-    </Type>
-    <Type Name="System.Reflection.Emit.FieldBuilder">
-      <Member Name="get_Attributes" />
-      <Member Name="get_DeclaringType" />
-      <Member Name="get_FieldHandle" />
-      <Member Name="get_FieldType" />
-      <Member Name="get_Module" />
-      <Member Name="get_Name" />
-      <Member Name="get_ReflectedType" />
-      <Member Name="GetCustomAttributes(System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Type,System.Boolean)" />
-      <Member Name="GetToken" />
-      <Member Name="GetValue(System.Object)" />
-      <Member Name="IsDefined(System.Type,System.Boolean)" />
-      <Member Name="SetConstant(System.Object)" />
-      <Member Name="SetCustomAttribute(System.Reflection.ConstructorInfo,System.Byte[])" />
-      <Member Name="SetCustomAttribute(System.Reflection.Emit.CustomAttributeBuilder)" />
-      <Member Name="SetOffset(System.Int32)" />
-      <Member Name="SetValue(System.Object,System.Object,System.Reflection.BindingFlags,System.Reflection.Binder,System.Globalization.CultureInfo)" />
-      <Member MemberType="Property" Name="Attributes" />
-      <Member MemberType="Property" Name="DeclaringType" />
-      <Member MemberType="Property" Name="FieldHandle" />
-      <Member MemberType="Property" Name="FieldType" />
-      <Member MemberType="Property" Name="Module" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="ReflectedType" />
-    </Type>
-    <Type Name="System.Reflection.Emit.FieldToken">
-      <Member MemberType="Field" Name="Empty" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.Reflection.Emit.FieldToken)" />
-      <Member Name="get_Token" />
-      <Member Name="GetHashCode" />
-      <Member Name="op_Equality(System.Reflection.Emit.FieldToken,System.Reflection.Emit.FieldToken)" />
-      <Member Name="op_Inequality(System.Reflection.Emit.FieldToken,System.Reflection.Emit.FieldToken)" />
-      <Member MemberType="Property" Name="Token" />
-    </Type>
-    <Type Name="System.Reflection.Emit.FlowControl">
-      <Member MemberType="Field" Name="Branch" />
-      <Member MemberType="Field" Name="Break" />
-      <Member MemberType="Field" Name="Call" />
-      <Member MemberType="Field" Name="Cond_Branch" />
-      <Member MemberType="Field" Name="Meta" />
-      <Member MemberType="Field" Name="Next" />
-      <Member MemberType="Field" Name="Phi" />
-      <Member MemberType="Field" Name="Return" />
-      <Member MemberType="Field" Name="Throw" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Reflection.Emit.GenericTypeParameterBuilder">
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_Assembly" />
-      <Member Name="get_AssemblyQualifiedName" />
-      <Member Name="get_BaseType" />
-      <Member Name="get_ContainsGenericParameters" />
-      <Member Name="get_DeclaringMethod" />
-      <Member Name="get_DeclaringType" />
-      <Member Name="get_FullName" />
-      <Member Name="get_GenericParameterPosition" />
-      <Member Name="get_GUID" />
-      <Member Name="get_IsGenericParameter" />
-      <Member Name="get_IsGenericType" />
-      <Member Name="get_IsGenericTypeDefinition" />
-      <Member Name="get_Module" />
-      <Member Name="get_Name" />
-      <Member Name="get_Namespace" />
-      <Member Name="get_ReflectedType" />
-      <Member Name="get_TypeHandle" />
-      <Member Name="get_UnderlyingSystemType" />
-      <Member Name="GetAttributeFlagsImpl" />
-      <Member Name="GetConstructorImpl(System.Reflection.BindingFlags,System.Reflection.Binder,System.Reflection.CallingConventions,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetConstructors(System.Reflection.BindingFlags)" />
-      <Member Name="GetCustomAttributes(System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Type,System.Boolean)" />
-      <Member Name="GetElementType" />
-      <Member Name="GetEvent(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetEvents" />
-      <Member Name="GetEvents(System.Reflection.BindingFlags)" />
-      <Member Name="GetField(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetFields(System.Reflection.BindingFlags)" />
-      <Member Name="GetGenericArguments" />
-      <Member Name="GetGenericTypeDefinition" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetInterface(System.String,System.Boolean)" />
-      <Member Name="GetInterfaceMap(System.Type)" />
-      <Member Name="GetInterfaces" />
-      <Member Name="GetMember(System.String,System.Reflection.MemberTypes,System.Reflection.BindingFlags)" />
-      <Member Name="GetMembers(System.Reflection.BindingFlags)" />
-      <Member Name="GetMethodImpl(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Reflection.CallingConventions,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetMethods(System.Reflection.BindingFlags)" />
-      <Member Name="GetNestedType(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetNestedTypes(System.Reflection.BindingFlags)" />
-      <Member Name="GetProperties(System.Reflection.BindingFlags)" />
-      <Member Name="GetPropertyImpl(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Type,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="HasElementTypeImpl" />
-      <Member Name="InvokeMember(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object,System.Object[],System.Reflection.ParameterModifier[],System.Globalization.CultureInfo,System.String[])" />
-      <Member Name="IsArrayImpl" />
-      <Member Name="IsAssignableFrom(System.Type)" />
-      <Member Name="IsAssignableFrom(System.Reflection.TypeInfo)" />
-      <Member Name="IsByRefImpl" />
-      <Member Name="IsCOMObjectImpl" />
-      <Member Name="IsDefined(System.Type,System.Boolean)" />
-      <Member Name="IsPointerImpl" />
-      <Member Name="IsPrimitiveImpl" />
-      <Member Name="IsSubclassOf(System.Type)" />
-      <Member Name="IsValueTypeImpl" />
-      <Member Name="MakeArrayType" />
-      <Member Name="MakeArrayType(System.Int32)" />
-      <Member Name="MakeByRefType" />
-      <Member Name="MakeGenericType(System.Type[])" />
-      <Member Name="MakePointerType" />
-      <Member Name="SetBaseTypeConstraint(System.Type)" />
-      <Member Name="SetCustomAttribute(System.Reflection.ConstructorInfo,System.Byte[])" />
-      <Member Name="SetCustomAttribute(System.Reflection.Emit.CustomAttributeBuilder)" />
-      <Member Name="SetGenericParameterAttributes(System.Reflection.GenericParameterAttributes)" />
-      <Member Name="SetInterfaceConstraints(System.Type[])" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="Assembly" />
-      <Member MemberType="Property" Name="AssemblyQualifiedName" />
-      <Member MemberType="Property" Name="BaseType" />
-      <Member MemberType="Property" Name="ContainsGenericParameters" />
-      <Member MemberType="Property" Name="DeclaringMethod" />
-      <Member MemberType="Property" Name="DeclaringType" />
-      <Member MemberType="Property" Name="FullName" />
-      <Member MemberType="Property" Name="GenericParameterPosition" />
-      <Member MemberType="Property" Name="GUID" />
-      <Member MemberType="Property" Name="IsGenericParameter" />
-      <Member MemberType="Property" Name="IsGenericType" />
-      <Member MemberType="Property" Name="IsGenericTypeDefinition" />
-      <Member MemberType="Property" Name="Module" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="Namespace" />
-      <Member MemberType="Property" Name="ReflectedType" />
-      <Member MemberType="Property" Name="TypeHandle" />
-      <Member MemberType="Property" Name="UnderlyingSystemType" />
-    </Type>
-    <Type Name="System.Reflection.Emit.ILGenerator">
-      <Member Name="BeginCatchBlock(System.Type)" />
-      <Member Name="BeginExceptFilterBlock" />
-      <Member Name="BeginExceptionBlock" />
-      <Member Name="BeginFaultBlock" />
-      <Member Name="BeginFinallyBlock" />
-      <Member Name="BeginScope" />
-      <Member Name="DeclareLocal(System.Type)" />
-      <Member Name="DeclareLocal(System.Type,System.Boolean)" />
-      <Member Name="DefineLabel" />
-      <Member Name="Emit(System.Reflection.Emit.OpCode)" />
-      <Member Name="Emit(System.Reflection.Emit.OpCode,System.Byte)" />
-      <Member Name="Emit(System.Reflection.Emit.OpCode,System.Double)" />
-      <Member Name="Emit(System.Reflection.Emit.OpCode,System.Int16)" />
-      <Member Name="Emit(System.Reflection.Emit.OpCode,System.Int32)" />
-      <Member Name="Emit(System.Reflection.Emit.OpCode,System.Int64)" />
-      <Member Name="Emit(System.Reflection.Emit.OpCode,System.Reflection.Emit.SignatureHelper)" />
-      <Member Name="Emit(System.Reflection.Emit.OpCode,System.Reflection.ConstructorInfo)" />
-      <Member Name="Emit(System.Reflection.Emit.OpCode,System.Reflection.Emit.Label)" />
-      <Member Name="Emit(System.Reflection.Emit.OpCode,System.Reflection.Emit.Label[])" />
-      <Member Name="Emit(System.Reflection.Emit.OpCode,System.Reflection.Emit.LocalBuilder)" />
-      <Member Name="Emit(System.Reflection.Emit.OpCode,System.Reflection.FieldInfo)" />
-      <Member Name="Emit(System.Reflection.Emit.OpCode,System.Reflection.MethodInfo)" />
-      <Member Name="Emit(System.Reflection.Emit.OpCode,System.SByte)" />
-      <Member Name="Emit(System.Reflection.Emit.OpCode,System.Single)" />
-      <Member Name="Emit(System.Reflection.Emit.OpCode,System.String)" />
-      <Member Name="Emit(System.Reflection.Emit.OpCode,System.Type)" />
-      <Member Name="EmitCall(System.Reflection.Emit.OpCode,System.Reflection.MethodInfo,System.Type[])" />
-      <Member Name="EmitCalli(System.Reflection.Emit.OpCode,System.Reflection.CallingConventions,System.Type,System.Type[],System.Type[])" />
-      <Member Name="EmitWriteLine(System.Reflection.Emit.LocalBuilder)" />
-      <Member Name="EmitWriteLine(System.Reflection.FieldInfo)" />
-      <Member Name="EmitWriteLine(System.String)" />
-      <Member Name="EndExceptionBlock" />
-      <Member Name="EndScope" />
-      <Member Name="MarkLabel(System.Reflection.Emit.Label)" />
-      <Member Name="MarkSequencePoint(System.Diagnostics.SymbolStore.ISymbolDocumentWriter,System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="get_ILOffset" />
-      <Member Name="ThrowException(System.Type)" />
-      <Member Name="UsingNamespace(System.String)" />
-      <Member MemberType="Property" Name="ILOffset" />
-    </Type>
-    <Type Name="System.Diagnostics.CodeAnalysis.SuppressMessageAttribute">
-      <Member Name="#ctor(System.String,System.String)" />
-      <Member MemberType="Property" Name="Category" />
-      <Member MemberType="Property" Name="CheckId" />
-      <Member MemberType="Property" Name="Scope" />
-      <Member MemberType="Property" Name="Target" />
-      <Member MemberType="Property" Name="MessageId" />
-      <Member MemberType="Property" Name="Justification" />
-    </Type>
-    <Type Name="System.Diagnostics.SymbolStore.ISymbolDocumentWriter">
-      <Member Name="SetSource(System.Byte[])" />
-      <Member Name="SetCheckSum(System.Guid,System.Byte[])" />
-    </Type>
-    <Type Name="System.Reflection.Emit.Label">
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.Reflection.Emit.Label)" />
-      <Member Name="GetHashCode" />
-      <Member Name="op_Equality(System.Reflection.Emit.Label,System.Reflection.Emit.Label)" />
-      <Member Name="op_Inequality(System.Reflection.Emit.Label,System.Reflection.Emit.Label)" />
-    </Type>
-    <Type Name="System.Reflection.Emit.LocalBuilder">
-      <Member Name="get_IsPinned" />
-      <Member Name="get_LocalIndex" />
-      <Member Name="get_LocalType" />
-      <Member Name="SetLocalSymInfo(System.String)" />
-      <Member Name="SetLocalSymInfo(System.String,System.Int32,System.Int32)" />
-      <Member MemberType="Property" Name="IsPinned" />
-      <Member MemberType="Property" Name="LocalIndex" />
-      <Member MemberType="Property" Name="LocalType" />
-    </Type>
-    <Type Name="System.Reflection.Emit.MethodBuilder">
-      <Member Name="DefineGenericParameters(System.String[])" />
-      <Member Name="DefineParameter(System.Int32,System.Reflection.ParameterAttributes,System.String)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_Attributes" />
-      <Member Name="get_CallingConvention" />
-      <Member Name="get_ContainsGenericParameters" />
-      <Member Name="get_DeclaringType" />
-      <Member Name="get_InitLocals" />
-      <Member Name="get_IsGenericMethod" />
-      <Member Name="get_IsGenericMethodDefinition" />
-      <Member Name="get_MethodHandle" />
-      <Member Name="get_Module" />
-      <Member Name="get_Name" />
-      <Member Name="get_ReflectedType" />
-      <Member Name="get_ReturnParameter" />
-      <Member Name="get_ReturnTypeCustomAttributes" />
-      <Member Name="get_Signature" />
-      <Member Name="GetBaseDefinition" />
-      <Member Name="GetCustomAttributes(System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Type,System.Boolean)" />
-      <Member Name="GetGenericArguments" />
-      <Member Name="GetGenericMethodDefinition" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetILGenerator" />
-      <Member Name="GetILGenerator(System.Int32)" />
-      <Member Name="GetMethodImplementationFlags" />
-      <Member Name="GetModule" />
-      <Member Name="GetParameters" />
-      <Member Name="GetToken" />
-      <Member Name="Invoke(System.Object,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object[],System.Globalization.CultureInfo)" />
-      <Member Name="IsDefined(System.Type,System.Boolean)" />
-      <Member Name="MakeGenericMethod(System.Type[])" />
-      <Member Name="set_InitLocals(System.Boolean)" />
-      <Member Name="SetCustomAttribute(System.Reflection.ConstructorInfo,System.Byte[])" />
-      <Member Name="SetCustomAttribute(System.Reflection.Emit.CustomAttributeBuilder)" />
-      <Member Name="SetImplementationFlags(System.Reflection.MethodImplAttributes)" />
-      <Member Name="SetParameters(System.Type[])" />
-      <Member Name="SetReturnType(System.Type)" />
-      <Member Name="SetSignature(System.Type,System.Type[],System.Type[],System.Type[],System.Type[][],System.Type[][])" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="Attributes" />
-      <Member MemberType="Property" Name="CallingConvention" />
-      <Member MemberType="Property" Name="ContainsGenericParameters" />
-      <Member MemberType="Property" Name="DeclaringType" />
-      <Member MemberType="Property" Name="InitLocals" />
-      <Member MemberType="Property" Name="IsGenericMethod" />
-      <Member MemberType="Property" Name="IsGenericMethodDefinition" />
-      <Member MemberType="Property" Name="MethodHandle" />
-      <Member MemberType="Property" Name="Module" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="ReflectedType" />
-      <Member MemberType="Property" Name="ReturnParameter" />
-      <Member MemberType="Property" Name="ReturnTypeCustomAttributes" />
-      <Member MemberType="Property" Name="Signature" />
-    </Type>
-    <Type Name="System.Reflection.Emit.MethodToken">
-      <Member MemberType="Field" Name="Empty" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.Reflection.Emit.MethodToken)" />
-      <Member Name="get_Token" />
-      <Member Name="GetHashCode" />
-      <Member Name="op_Equality(System.Reflection.Emit.MethodToken,System.Reflection.Emit.MethodToken)" />
-      <Member Name="op_Inequality(System.Reflection.Emit.MethodToken,System.Reflection.Emit.MethodToken)" />
-      <Member MemberType="Property" Name="Token" />
-    </Type>
-    <Type Name="System.Reflection.Emit.ModuleBuilder">
-      <Member Name="CreateGlobalFunctions" />
-      <Member Name="DefineDocument(System.String,System.Guid,System.Guid,System.Guid)" />
-      <Member Name="DefineEnum(System.String,System.Reflection.TypeAttributes,System.Type)" />
-      <Member Name="DefineGlobalMethod(System.String,System.Reflection.MethodAttributes,System.Reflection.CallingConventions,System.Type,System.Type[])" />
-      <Member Name="DefineGlobalMethod(System.String,System.Reflection.MethodAttributes,System.Reflection.CallingConventions,System.Type,System.Type[],System.Type[],System.Type[],System.Type[][],System.Type[][])" />
-      <Member Name="DefineGlobalMethod(System.String,System.Reflection.MethodAttributes,System.Type,System.Type[])" />
-      <Member Name="DefineInitializedData(System.String,System.Byte[],System.Reflection.FieldAttributes)" />
-      <Member Name="DefineType(System.String)" />
-      <Member Name="DefineType(System.String,System.Reflection.TypeAttributes)" />
-      <Member Name="DefineType(System.String,System.Reflection.TypeAttributes,System.Type)" />
-      <Member Name="DefineType(System.String,System.Reflection.TypeAttributes,System.Type,System.Int32)" />
-      <Member Name="DefineType(System.String,System.Reflection.TypeAttributes,System.Type,System.Reflection.Emit.PackingSize)" />
-      <Member Name="DefineType(System.String,System.Reflection.TypeAttributes,System.Type,System.Reflection.Emit.PackingSize,System.Int32)" />
-      <Member Name="DefineType(System.String,System.Reflection.TypeAttributes,System.Type,System.Type[])" />
-      <Member Name="DefineUninitializedData(System.String,System.Int32,System.Reflection.FieldAttributes)" />
-      <Member Name="get_FullyQualifiedName" />
-      <Member Name="GetArrayMethod(System.Type,System.String,System.Reflection.CallingConventions,System.Type,System.Type[])" />
-      <Member Name="GetArrayMethodToken(System.Type,System.String,System.Reflection.CallingConventions,System.Type,System.Type[])" />
-      <Member Name="GetConstructorToken(System.Reflection.ConstructorInfo)" />
-      <Member Name="GetFieldToken(System.Reflection.FieldInfo)" />
-      <Member Name="GetMethodToken(System.Reflection.MethodInfo)" />
-      <Member Name="GetSignatureToken(System.Byte[],System.Int32)" />
-      <Member Name="GetSignatureToken(System.Reflection.Emit.SignatureHelper)" />
-      <Member Name="GetStringConstant(System.String)" />
-      <Member Name="GetType(System.String)" />
-      <Member Name="GetType(System.String,System.Boolean)" />
-      <Member Name="GetType(System.String,System.Boolean,System.Boolean)" />
-      <Member Name="GetTypes" />
-      <Member Name="GetTypeToken(System.String)" />
-      <Member Name="GetTypeToken(System.Type)" />
-      <Member Name="IsTransient" />
-      <Member Name="SetCustomAttribute(System.Reflection.ConstructorInfo,System.Byte[])" />
-      <Member Name="SetCustomAttribute(System.Reflection.Emit.CustomAttributeBuilder)" />
-      <Member MemberType="Property" Name="FullyQualifiedName" />
-    </Type>
-    <Type Name="System.Reflection.Emit.OpCode">
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.Reflection.Emit.OpCode)" />
-      <Member Name="get_FlowControl" />
-      <Member Name="get_Name" />
-      <Member Name="get_OpCodeType" />
-      <Member Name="get_OperandType" />
-      <Member Name="get_Size" />
-      <Member Name="get_StackBehaviourPop" />
-      <Member Name="get_StackBehaviourPush" />
-      <Member Name="get_Value" />
-      <Member Name="GetHashCode" />
-      <Member Name="op_Equality(System.Reflection.Emit.OpCode,System.Reflection.Emit.OpCode)" />
-      <Member Name="op_Inequality(System.Reflection.Emit.OpCode,System.Reflection.Emit.OpCode)" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="FlowControl" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="OpCodeType" />
-      <Member MemberType="Property" Name="OperandType" />
-      <Member MemberType="Property" Name="Size" />
-      <Member MemberType="Property" Name="StackBehaviourPop" />
-      <Member MemberType="Property" Name="StackBehaviourPush" />
-      <Member MemberType="Property" Name="Value" />
-    </Type>
-    <Type Name="System.Reflection.Emit.OpCodes">
-      <Member MemberType="Field" Name="Add" />
-      <Member MemberType="Field" Name="Add_Ovf" />
-      <Member MemberType="Field" Name="Add_Ovf_Un" />
-      <Member MemberType="Field" Name="And" />
-      <Member MemberType="Field" Name="Arglist" />
-      <Member MemberType="Field" Name="Beq" />
-      <Member MemberType="Field" Name="Beq_S" />
-      <Member MemberType="Field" Name="Bge" />
-      <Member MemberType="Field" Name="Bge_S" />
-      <Member MemberType="Field" Name="Bge_Un" />
-      <Member MemberType="Field" Name="Bge_Un_S" />
-      <Member MemberType="Field" Name="Bgt" />
-      <Member MemberType="Field" Name="Bgt_S" />
-      <Member MemberType="Field" Name="Bgt_Un" />
-      <Member MemberType="Field" Name="Bgt_Un_S" />
-      <Member MemberType="Field" Name="Ble" />
-      <Member MemberType="Field" Name="Ble_S" />
-      <Member MemberType="Field" Name="Ble_Un" />
-      <Member MemberType="Field" Name="Ble_Un_S" />
-      <Member MemberType="Field" Name="Blt" />
-      <Member MemberType="Field" Name="Blt_S" />
-      <Member MemberType="Field" Name="Blt_Un" />
-      <Member MemberType="Field" Name="Blt_Un_S" />
-      <Member MemberType="Field" Name="Bne_Un" />
-      <Member MemberType="Field" Name="Bne_Un_S" />
-      <Member MemberType="Field" Name="Box" />
-      <Member MemberType="Field" Name="Br" />
-      <Member MemberType="Field" Name="Br_S" />
-      <Member MemberType="Field" Name="Break" />
-      <Member MemberType="Field" Name="Brfalse" />
-      <Member MemberType="Field" Name="Brfalse_S" />
-      <Member MemberType="Field" Name="Brtrue" />
-      <Member MemberType="Field" Name="Brtrue_S" />
-      <Member MemberType="Field" Name="Call" />
-      <Member MemberType="Field" Name="Calli" />
-      <Member MemberType="Field" Name="Callvirt" />
-      <Member MemberType="Field" Name="Castclass" />
-      <Member MemberType="Field" Name="Ceq" />
-      <Member MemberType="Field" Name="Cgt" />
-      <Member MemberType="Field" Name="Cgt_Un" />
-      <Member MemberType="Field" Name="Ckfinite" />
-      <Member MemberType="Field" Name="Clt" />
-      <Member MemberType="Field" Name="Clt_Un" />
-      <Member MemberType="Field" Name="Constrained" />
-      <Member MemberType="Field" Name="Conv_I" />
-      <Member MemberType="Field" Name="Conv_I1" />
-      <Member MemberType="Field" Name="Conv_I2" />
-      <Member MemberType="Field" Name="Conv_I4" />
-      <Member MemberType="Field" Name="Conv_I8" />
-      <Member MemberType="Field" Name="Conv_Ovf_I" />
-      <Member MemberType="Field" Name="Conv_Ovf_I_Un" />
-      <Member MemberType="Field" Name="Conv_Ovf_I1" />
-      <Member MemberType="Field" Name="Conv_Ovf_I1_Un" />
-      <Member MemberType="Field" Name="Conv_Ovf_I2" />
-      <Member MemberType="Field" Name="Conv_Ovf_I2_Un" />
-      <Member MemberType="Field" Name="Conv_Ovf_I4" />
-      <Member MemberType="Field" Name="Conv_Ovf_I4_Un" />
-      <Member MemberType="Field" Name="Conv_Ovf_I8" />
-      <Member MemberType="Field" Name="Conv_Ovf_I8_Un" />
-      <Member MemberType="Field" Name="Conv_Ovf_U" />
-      <Member MemberType="Field" Name="Conv_Ovf_U_Un" />
-      <Member MemberType="Field" Name="Conv_Ovf_U1" />
-      <Member MemberType="Field" Name="Conv_Ovf_U1_Un" />
-      <Member MemberType="Field" Name="Conv_Ovf_U2" />
-      <Member MemberType="Field" Name="Conv_Ovf_U2_Un" />
-      <Member MemberType="Field" Name="Conv_Ovf_U4" />
-      <Member MemberType="Field" Name="Conv_Ovf_U4_Un" />
-      <Member MemberType="Field" Name="Conv_Ovf_U8" />
-      <Member MemberType="Field" Name="Conv_Ovf_U8_Un" />
-      <Member MemberType="Field" Name="Conv_R_Un" />
-      <Member MemberType="Field" Name="Conv_R4" />
-      <Member MemberType="Field" Name="Conv_R8" />
-      <Member MemberType="Field" Name="Conv_U" />
-      <Member MemberType="Field" Name="Conv_U1" />
-      <Member MemberType="Field" Name="Conv_U2" />
-      <Member MemberType="Field" Name="Conv_U4" />
-      <Member MemberType="Field" Name="Conv_U8" />
-      <Member MemberType="Field" Name="Cpblk" />
-      <Member MemberType="Field" Name="Cpobj" />
-      <Member MemberType="Field" Name="Div" />
-      <Member MemberType="Field" Name="Div_Un" />
-      <Member MemberType="Field" Name="Dup" />
-      <Member MemberType="Field" Name="Endfilter" />
-      <Member MemberType="Field" Name="Endfinally" />
-      <Member MemberType="Field" Name="Initblk" />
-      <Member MemberType="Field" Name="Initobj" />
-      <Member MemberType="Field" Name="Isinst" />
-      <Member MemberType="Field" Name="Jmp" />
-      <Member MemberType="Field" Name="Ldarg" />
-      <Member MemberType="Field" Name="Ldarg_0" />
-      <Member MemberType="Field" Name="Ldarg_1" />
-      <Member MemberType="Field" Name="Ldarg_2" />
-      <Member MemberType="Field" Name="Ldarg_3" />
-      <Member MemberType="Field" Name="Ldarg_S" />
-      <Member MemberType="Field" Name="Ldarga" />
-      <Member MemberType="Field" Name="Ldarga_S" />
-      <Member MemberType="Field" Name="Ldc_I4" />
-      <Member MemberType="Field" Name="Ldc_I4_0" />
-      <Member MemberType="Field" Name="Ldc_I4_1" />
-      <Member MemberType="Field" Name="Ldc_I4_2" />
-      <Member MemberType="Field" Name="Ldc_I4_3" />
-      <Member MemberType="Field" Name="Ldc_I4_4" />
-      <Member MemberType="Field" Name="Ldc_I4_5" />
-      <Member MemberType="Field" Name="Ldc_I4_6" />
-      <Member MemberType="Field" Name="Ldc_I4_7" />
-      <Member MemberType="Field" Name="Ldc_I4_8" />
-      <Member MemberType="Field" Name="Ldc_I4_M1" />
-      <Member MemberType="Field" Name="Ldc_I4_S" />
-      <Member MemberType="Field" Name="Ldc_I8" />
-      <Member MemberType="Field" Name="Ldc_R4" />
-      <Member MemberType="Field" Name="Ldc_R8" />
-      <Member MemberType="Field" Name="Ldelem" />
-      <Member MemberType="Field" Name="Ldelem_I" />
-      <Member MemberType="Field" Name="Ldelem_I1" />
-      <Member MemberType="Field" Name="Ldelem_I2" />
-      <Member MemberType="Field" Name="Ldelem_I4" />
-      <Member MemberType="Field" Name="Ldelem_I8" />
-      <Member MemberType="Field" Name="Ldelem_R4" />
-      <Member MemberType="Field" Name="Ldelem_R8" />
-      <Member MemberType="Field" Name="Ldelem_Ref" />
-      <Member MemberType="Field" Name="Ldelem_U1" />
-      <Member MemberType="Field" Name="Ldelem_U2" />
-      <Member MemberType="Field" Name="Ldelem_U4" />
-      <Member MemberType="Field" Name="Ldelema" />
-      <Member MemberType="Field" Name="Ldfld" />
-      <Member MemberType="Field" Name="Ldflda" />
-      <Member MemberType="Field" Name="Ldftn" />
-      <Member MemberType="Field" Name="Ldind_I" />
-      <Member MemberType="Field" Name="Ldind_I1" />
-      <Member MemberType="Field" Name="Ldind_I2" />
-      <Member MemberType="Field" Name="Ldind_I4" />
-      <Member MemberType="Field" Name="Ldind_I8" />
-      <Member MemberType="Field" Name="Ldind_R4" />
-      <Member MemberType="Field" Name="Ldind_R8" />
-      <Member MemberType="Field" Name="Ldind_Ref" />
-      <Member MemberType="Field" Name="Ldind_U1" />
-      <Member MemberType="Field" Name="Ldind_U2" />
-      <Member MemberType="Field" Name="Ldind_U4" />
-      <Member MemberType="Field" Name="Ldlen" />
-      <Member MemberType="Field" Name="Ldloc" />
-      <Member MemberType="Field" Name="Ldloc_0" />
-      <Member MemberType="Field" Name="Ldloc_1" />
-      <Member MemberType="Field" Name="Ldloc_2" />
-      <Member MemberType="Field" Name="Ldloc_3" />
-      <Member MemberType="Field" Name="Ldloc_S" />
-      <Member MemberType="Field" Name="Ldloca" />
-      <Member MemberType="Field" Name="Ldloca_S" />
-      <Member MemberType="Field" Name="Ldnull" />
-      <Member MemberType="Field" Name="Ldobj" />
-      <Member MemberType="Field" Name="Ldsfld" />
-      <Member MemberType="Field" Name="Ldsflda" />
-      <Member MemberType="Field" Name="Ldstr" />
-      <Member MemberType="Field" Name="Ldtoken" />
-      <Member MemberType="Field" Name="Ldvirtftn" />
-      <Member MemberType="Field" Name="Leave" />
-      <Member MemberType="Field" Name="Leave_S" />
-      <Member MemberType="Field" Name="Localloc" />
-      <Member MemberType="Field" Name="Mkrefany" />
-      <Member MemberType="Field" Name="Mul" />
-      <Member MemberType="Field" Name="Mul_Ovf" />
-      <Member MemberType="Field" Name="Mul_Ovf_Un" />
-      <Member MemberType="Field" Name="Neg" />
-      <Member MemberType="Field" Name="Newarr" />
-      <Member MemberType="Field" Name="Newobj" />
-      <Member MemberType="Field" Name="Nop" />
-      <Member MemberType="Field" Name="Not" />
-      <Member MemberType="Field" Name="Or" />
-      <Member MemberType="Field" Name="Pop" />
-      <Member MemberType="Field" Name="Prefix1" />
-      <Member MemberType="Field" Name="Prefix2" />
-      <Member MemberType="Field" Name="Prefix3" />
-      <Member MemberType="Field" Name="Prefix4" />
-      <Member MemberType="Field" Name="Prefix5" />
-      <Member MemberType="Field" Name="Prefix6" />
-      <Member MemberType="Field" Name="Prefix7" />
-      <Member MemberType="Field" Name="Prefixref" />
-      <Member MemberType="Field" Name="Readonly" />
-      <Member MemberType="Field" Name="Refanytype" />
-      <Member MemberType="Field" Name="Refanyval" />
-      <Member MemberType="Field" Name="Rem" />
-      <Member MemberType="Field" Name="Rem_Un" />
-      <Member MemberType="Field" Name="Ret" />
-      <Member MemberType="Field" Name="Rethrow" />
-      <Member MemberType="Field" Name="Shl" />
-      <Member MemberType="Field" Name="Shr" />
-      <Member MemberType="Field" Name="Shr_Un" />
-      <Member MemberType="Field" Name="Sizeof" />
-      <Member MemberType="Field" Name="Starg" />
-      <Member MemberType="Field" Name="Starg_S" />
-      <Member MemberType="Field" Name="Stelem" />
-      <Member MemberType="Field" Name="Stelem_I" />
-      <Member MemberType="Field" Name="Stelem_I1" />
-      <Member MemberType="Field" Name="Stelem_I2" />
-      <Member MemberType="Field" Name="Stelem_I4" />
-      <Member MemberType="Field" Name="Stelem_I8" />
-      <Member MemberType="Field" Name="Stelem_R4" />
-      <Member MemberType="Field" Name="Stelem_R8" />
-      <Member MemberType="Field" Name="Stelem_Ref" />
-      <Member MemberType="Field" Name="Stfld" />
-      <Member MemberType="Field" Name="Stind_I" />
-      <Member MemberType="Field" Name="Stind_I1" />
-      <Member MemberType="Field" Name="Stind_I2" />
-      <Member MemberType="Field" Name="Stind_I4" />
-      <Member MemberType="Field" Name="Stind_I8" />
-      <Member MemberType="Field" Name="Stind_R4" />
-      <Member MemberType="Field" Name="Stind_R8" />
-      <Member MemberType="Field" Name="Stind_Ref" />
-      <Member MemberType="Field" Name="Stloc" />
-      <Member MemberType="Field" Name="Stloc_0" />
-      <Member MemberType="Field" Name="Stloc_1" />
-      <Member MemberType="Field" Name="Stloc_2" />
-      <Member MemberType="Field" Name="Stloc_3" />
-      <Member MemberType="Field" Name="Stloc_S" />
-      <Member MemberType="Field" Name="Stobj" />
-      <Member MemberType="Field" Name="Stsfld" />
-      <Member MemberType="Field" Name="Sub" />
-      <Member MemberType="Field" Name="Sub_Ovf" />
-      <Member MemberType="Field" Name="Sub_Ovf_Un" />
-      <Member MemberType="Field" Name="Switch" />
-      <Member MemberType="Field" Name="Tailcall" />
-      <Member MemberType="Field" Name="Throw" />
-      <Member MemberType="Field" Name="Unaligned" />
-      <Member MemberType="Field" Name="Unbox" />
-      <Member MemberType="Field" Name="Unbox_Any" />
-      <Member MemberType="Field" Name="Volatile" />
-      <Member MemberType="Field" Name="Xor" />
-      <Member Name="TakesSingleByteArgument(System.Reflection.Emit.OpCode)" />
-    </Type>
-    <Type Name="System.Reflection.Emit.OpCodeType">
-      <Member MemberType="Field" Name="Annotation" />
-      <Member MemberType="Field" Name="Macro" />
-      <Member MemberType="Field" Name="Nternal" />
-      <Member MemberType="Field" Name="Objmodel" />
-      <Member MemberType="Field" Name="Prefix" />
-      <Member MemberType="Field" Name="Primitive" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Reflection.Emit.OperandType">
-      <Member MemberType="Field" Name="InlineBrTarget" />
-      <Member MemberType="Field" Name="InlineField" />
-      <Member MemberType="Field" Name="InlineI" />
-      <Member MemberType="Field" Name="InlineI8" />
-      <Member MemberType="Field" Name="InlineMethod" />
-      <Member MemberType="Field" Name="InlineNone" />
-      <Member MemberType="Field" Name="InlinePhi" />
-      <Member MemberType="Field" Name="InlineR" />
-      <Member MemberType="Field" Name="InlineSig" />
-      <Member MemberType="Field" Name="InlineString" />
-      <Member MemberType="Field" Name="InlineSwitch" />
-      <Member MemberType="Field" Name="InlineTok" />
-      <Member MemberType="Field" Name="InlineType" />
-      <Member MemberType="Field" Name="InlineVar" />
-      <Member MemberType="Field" Name="ShortInlineBrTarget" />
-      <Member MemberType="Field" Name="ShortInlineI" />
-      <Member MemberType="Field" Name="ShortInlineR" />
-      <Member MemberType="Field" Name="ShortInlineVar" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Reflection.Emit.PackingSize">
-      <Member MemberType="Field" Name="Size1" />
-      <Member MemberType="Field" Name="Size128" />
-      <Member MemberType="Field" Name="Size16" />
-      <Member MemberType="Field" Name="Size2" />
-      <Member MemberType="Field" Name="Size32" />
-      <Member MemberType="Field" Name="Size4" />
-      <Member MemberType="Field" Name="Size64" />
-      <Member MemberType="Field" Name="Size8" />
-      <Member MemberType="Field" Name="Unspecified" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Reflection.Emit.ParameterBuilder">
-      <Member Name="get_Attributes" />
-      <Member Name="get_IsIn" />
-      <Member Name="get_IsOptional" />
-      <Member Name="get_IsOut" />
-      <Member Name="get_Name" />
-      <Member Name="get_Position" />
-      <Member Name="GetToken" />
-      <Member Name="SetConstant(System.Object)" />
-      <Member Name="SetCustomAttribute(System.Reflection.ConstructorInfo,System.Byte[])" />
-      <Member Name="SetCustomAttribute(System.Reflection.Emit.CustomAttributeBuilder)" />
-      <Member MemberType="Property" Name="Attributes" />
-      <Member MemberType="Property" Name="IsIn" />
-      <Member MemberType="Property" Name="IsOptional" />
-      <Member MemberType="Property" Name="IsOut" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="Position" />
-    </Type>
-    <Type Name="System.Reflection.Emit.ParameterToken">
-      <Member MemberType="Field" Name="Empty" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.Reflection.Emit.ParameterToken)" />
-      <Member Name="get_Token" />
-      <Member Name="GetHashCode" />
-      <Member Name="op_Equality(System.Reflection.Emit.ParameterToken,System.Reflection.Emit.ParameterToken)" />
-      <Member Name="op_Inequality(System.Reflection.Emit.ParameterToken,System.Reflection.Emit.ParameterToken)" />
-      <Member MemberType="Property" Name="Token" />
-    </Type>
-    <Type Name="System.Reflection.Emit.PEFileKinds">
-      <Member MemberType="Field" Name="ConsoleApplication" />
-      <Member MemberType="Field" Name="Dll" />
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="WindowApplication" />
-    </Type>
-    <Type Name="System.Reflection.Emit.PropertyBuilder">
-      <Member Name="AddOtherMethod(System.Reflection.Emit.MethodBuilder)" />
-      <Member Name="get_Attributes" />
-      <Member Name="get_CanRead" />
-      <Member Name="get_CanWrite" />
-      <Member Name="get_DeclaringType" />
-      <Member Name="get_Module" />
-      <Member Name="get_Name" />
-      <Member Name="get_PropertyToken" />
-      <Member Name="get_PropertyType" />
-      <Member Name="get_ReflectedType" />
-      <Member Name="GetAccessors(System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Type,System.Boolean)" />
-      <Member Name="GetGetMethod(System.Boolean)" />
-      <Member Name="GetIndexParameters" />
-      <Member Name="GetSetMethod(System.Boolean)" />
-      <Member Name="GetValue(System.Object,System.Object[])" />
-      <Member Name="GetValue(System.Object,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object[],System.Globalization.CultureInfo)" />
-      <Member Name="IsDefined(System.Type,System.Boolean)" />
-      <Member Name="SetConstant(System.Object)" />
-      <Member Name="SetCustomAttribute(System.Reflection.ConstructorInfo,System.Byte[])" />
-      <Member Name="SetCustomAttribute(System.Reflection.Emit.CustomAttributeBuilder)" />
-      <Member Name="SetGetMethod(System.Reflection.Emit.MethodBuilder)" />
-      <Member Name="SetSetMethod(System.Reflection.Emit.MethodBuilder)" />
-      <Member Name="SetValue(System.Object,System.Object,System.Object[])" />
-      <Member Name="SetValue(System.Object,System.Object,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object[],System.Globalization.CultureInfo)" />
-      <Member MemberType="Property" Name="Attributes" />
-      <Member MemberType="Property" Name="CanRead" />
-      <Member MemberType="Property" Name="CanWrite" />
-      <Member MemberType="Property" Name="DeclaringType" />
-      <Member MemberType="Property" Name="Module" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="PropertyToken" />
-      <Member MemberType="Property" Name="PropertyType" />
-      <Member MemberType="Property" Name="ReflectedType" />
-    </Type>
-    <Type Name="System.Reflection.Emit.PropertyToken">
-      <Member MemberType="Field" Name="Empty" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.Reflection.Emit.PropertyToken)" />
-      <Member Name="get_Token" />
-      <Member Name="GetHashCode" />
-      <Member Name="op_Equality(System.Reflection.Emit.PropertyToken,System.Reflection.Emit.PropertyToken)" />
-      <Member Name="op_Inequality(System.Reflection.Emit.PropertyToken,System.Reflection.Emit.PropertyToken)" />
-      <Member MemberType="Property" Name="Token" />
-    </Type>
-    <Type Name="System.Reflection.Emit.SignatureHelper">
-      <Member Name="AddArgument(System.Type)" />
-      <Member Name="AddArgument(System.Type,System.Boolean)" />
-      <Member Name="AddArgument(System.Type,System.Type[],System.Type[])" />
-      <Member Name="AddArguments(System.Type[],System.Type[][],System.Type[][])" />
-      <Member Name="AddSentinel" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetFieldSigHelper(System.Reflection.Module)" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetLocalVarSigHelper" />
-      <Member Name="GetLocalVarSigHelper(System.Reflection.Module)" />
-      <Member Name="GetMethodSigHelper(System.Reflection.CallingConventions,System.Type)" />
-      <Member Name="GetMethodSigHelper(System.Reflection.Module,System.Reflection.CallingConventions,System.Type)" />
-      <Member Name="GetMethodSigHelper(System.Reflection.Module,System.Runtime.InteropServices.CallingConvention,System.Type)" />
-      <Member Name="GetMethodSigHelper(System.Reflection.Module,System.Type,System.Type[])" />
-      <Member Name="GetMethodSigHelper(System.Runtime.InteropServices.CallingConvention,System.Type)" />
-      <Member Name="GetPropertySigHelper(System.Reflection.Module,System.Type,System.Type[])" />
-      <Member Name="GetPropertySigHelper(System.Reflection.Module,System.Type,System.Type[],System.Type[],System.Type[],System.Type[][],System.Type[][])" />
-      <Member Name="GetPropertySigHelper(System.Reflection.Module,System.Reflection.CallingConventions,System.Type,System.Type[],System.Type[],System.Type[],System.Type[][],System.Type[][])" />
-      <Member Name="GetSignature" />
-      <Member Name="ToString" />
-    </Type>
-    <Type Name="System.Reflection.Emit.SignatureToken">
-      <Member MemberType="Field" Name="Empty" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.Reflection.Emit.SignatureToken)" />
-      <Member Name="get_Token" />
-      <Member Name="GetHashCode" />
-      <Member Name="op_Equality(System.Reflection.Emit.SignatureToken,System.Reflection.Emit.SignatureToken)" />
-      <Member Name="op_Inequality(System.Reflection.Emit.SignatureToken,System.Reflection.Emit.SignatureToken)" />
-      <Member MemberType="Property" Name="Token" />
-    </Type>
-    <Type Name="System.Reflection.Emit.StackBehaviour">
-      <Member MemberType="Field" Name="Pop0" />
-      <Member MemberType="Field" Name="Pop1" />
-      <Member MemberType="Field" Name="Pop1_pop1" />
-      <Member MemberType="Field" Name="Popi" />
-      <Member MemberType="Field" Name="Popi_pop1" />
-      <Member MemberType="Field" Name="Popi_popi" />
-      <Member MemberType="Field" Name="Popi_popi_popi" />
-      <Member MemberType="Field" Name="Popi_popi8" />
-      <Member MemberType="Field" Name="Popi_popr4" />
-      <Member MemberType="Field" Name="Popi_popr8" />
-      <Member MemberType="Field" Name="Popref" />
-      <Member MemberType="Field" Name="Popref_pop1" />
-      <Member MemberType="Field" Name="Popref_popi" />
-      <Member MemberType="Field" Name="Popref_popi_pop1" />
-      <Member MemberType="Field" Name="Popref_popi_popi" />
-      <Member MemberType="Field" Name="Popref_popi_popi8" />
-      <Member MemberType="Field" Name="Popref_popi_popr4" />
-      <Member MemberType="Field" Name="Popref_popi_popr8" />
-      <Member MemberType="Field" Name="Popref_popi_popref" />
-      <Member MemberType="Field" Name="Push0" />
-      <Member MemberType="Field" Name="Push1" />
-      <Member MemberType="Field" Name="Push1_push1" />
-      <Member MemberType="Field" Name="Pushi" />
-      <Member MemberType="Field" Name="Pushi8" />
-      <Member MemberType="Field" Name="Pushr4" />
-      <Member MemberType="Field" Name="Pushr8" />
-      <Member MemberType="Field" Name="Pushref" />
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="Varpop" />
-      <Member MemberType="Field" Name="Varpush" />
-    </Type>
-    <Type Name="System.Reflection.Emit.StringToken">
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.Reflection.Emit.StringToken)" />
-      <Member Name="get_Token" />
-      <Member Name="GetHashCode" />
-      <Member Name="op_Equality(System.Reflection.Emit.StringToken,System.Reflection.Emit.StringToken)" />
-      <Member Name="op_Inequality(System.Reflection.Emit.StringToken,System.Reflection.Emit.StringToken)" />
-      <Member MemberType="Property" Name="Token" />
-    </Type>
-    <Type Name="System.Reflection.Emit.TypeBuilder">
-      <Member MemberType="Field" Name="UnspecifiedTypeSize" />
-      <Member Name="AddInterfaceImplementation(System.Type)" />
-      <Member Name="CreateType" />
-      <Member Name="IsAssignableFrom(System.Reflection.TypeInfo)" />
-      <Member Name="CreateTypeInfo" />
-      <Member Name="DefineConstructor(System.Reflection.MethodAttributes,System.Reflection.CallingConventions,System.Type[])" />
-      <Member Name="DefineConstructor(System.Reflection.MethodAttributes,System.Reflection.CallingConventions,System.Type[],System.Type[][],System.Type[][])" />
-      <Member Name="DefineDefaultConstructor(System.Reflection.MethodAttributes)" />
-      <Member Name="DefineEvent(System.String,System.Reflection.EventAttributes,System.Type)" />
-      <Member Name="DefineField(System.String,System.Type,System.Reflection.FieldAttributes)" />
-      <Member Name="DefineField(System.String,System.Type,System.Type[],System.Type[],System.Reflection.FieldAttributes)" />
-      <Member Name="DefineGenericParameters(System.String[])" />
-      <Member Name="DefineInitializedData(System.String,System.Byte[],System.Reflection.FieldAttributes)" />
-      <Member Name="DefineMethod(System.String,System.Reflection.MethodAttributes)" />
-      <Member Name="DefineMethod(System.String,System.Reflection.MethodAttributes,System.Reflection.CallingConventions)" />
-      <Member Name="DefineMethod(System.String,System.Reflection.MethodAttributes,System.Reflection.CallingConventions,System.Type,System.Type[])" />
-      <Member Name="DefineMethod(System.String,System.Reflection.MethodAttributes,System.Reflection.CallingConventions,System.Type,System.Type[],System.Type[],System.Type[],System.Type[][],System.Type[][])" />
-      <Member Name="DefineMethod(System.String,System.Reflection.MethodAttributes,System.Type,System.Type[])" />
-      <Member Name="DefineMethodOverride(System.Reflection.MethodInfo,System.Reflection.MethodInfo)" />
-      <Member Name="DefineNestedType(System.String)" />
-      <Member Name="DefineNestedType(System.String,System.Reflection.TypeAttributes)" />
-      <Member Name="DefineNestedType(System.String,System.Reflection.TypeAttributes,System.Type)" />
-      <Member Name="DefineNestedType(System.String,System.Reflection.TypeAttributes,System.Type,System.Int32)" />
-      <Member Name="DefineNestedType(System.String,System.Reflection.TypeAttributes,System.Type,System.Reflection.Emit.PackingSize)" />
-      <Member Name="DefineNestedType(System.String,System.Reflection.TypeAttributes,System.Type,System.Reflection.Emit.PackingSize,System.Int32)" />
-      <Member Name="DefineNestedType(System.String,System.Reflection.TypeAttributes,System.Type,System.Type[])" />
-      <Member Name="DefineProperty(System.String,System.Reflection.PropertyAttributes,System.Type,System.Type[])" />
-      <Member Name="DefineProperty(System.String,System.Reflection.PropertyAttributes,System.Type,System.Type[],System.Type[],System.Type[],System.Type[][],System.Type[][])" />
-      <Member Name="DefineProperty(System.String,System.Reflection.PropertyAttributes,System.Reflection.CallingConventions,System.Type,System.Type[])" />
-      <Member Name="DefineProperty(System.String,System.Reflection.PropertyAttributes,System.Reflection.CallingConventions,System.Type,System.Type[],System.Type[],System.Type[],System.Type[][],System.Type[][])" />
-      <Member Name="DefineTypeInitializer" />
-      <Member Name="DefineUninitializedData(System.String,System.Int32,System.Reflection.FieldAttributes)" />
-      <Member Name="get_Assembly" />
-      <Member Name="get_AssemblyQualifiedName" />
-      <Member Name="get_BaseType" />
-      <Member Name="get_DeclaringMethod" />
-      <Member Name="get_DeclaringType" />
-      <Member Name="get_FullName" />
-      <Member Name="get_GenericParameterAttributes" />
-      <Member Name="get_GenericParameterPosition" />
-      <Member Name="get_GUID" />
-      <Member Name="get_IsGenericParameter" />
-      <Member Name="get_IsGenericType" />
-      <Member Name="get_IsGenericTypeDefinition" />
-      <Member Name="get_Module" />
-      <Member Name="get_Name" />
-      <Member Name="get_Namespace" />
-      <Member Name="get_PackingSize" />
-      <Member Name="get_ReflectedType" />
-      <Member Name="get_Size" />
-      <Member Name="get_TypeHandle" />
-      <Member Name="get_TypeToken" />
-      <Member Name="get_UnderlyingSystemType" />
-      <Member Name="GetAttributeFlagsImpl" />
-      <Member Name="GetConstructor(System.Type,System.Reflection.ConstructorInfo)" />
-      <Member Name="GetConstructorImpl(System.Reflection.BindingFlags,System.Reflection.Binder,System.Reflection.CallingConventions,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetConstructors(System.Reflection.BindingFlags)" />
-      <Member Name="GetCustomAttributes(System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Type,System.Boolean)" />
-      <Member Name="GetElementType" />
-      <Member Name="GetEvent(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetEvents" />
-      <Member Name="GetEvents(System.Reflection.BindingFlags)" />
-      <Member Name="GetField(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetField(System.Type,System.Reflection.FieldInfo)" />
-      <Member Name="GetFields(System.Reflection.BindingFlags)" />
-      <Member Name="GetGenericArguments" />
-      <Member Name="GetGenericTypeDefinition" />
-      <Member Name="GetInterface(System.String,System.Boolean)" />
-      <Member Name="GetInterfaceMap(System.Type)" />
-      <Member Name="GetInterfaces" />
-      <Member Name="GetMember(System.String,System.Reflection.MemberTypes,System.Reflection.BindingFlags)" />
-      <Member Name="GetMembers(System.Reflection.BindingFlags)" />
-      <Member Name="GetMethod(System.Type,System.Reflection.MethodInfo)" />
-      <Member Name="GetMethodImpl(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Reflection.CallingConventions,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetMethods(System.Reflection.BindingFlags)" />
-      <Member Name="GetNestedType(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetNestedTypes(System.Reflection.BindingFlags)" />
-      <Member Name="GetProperties(System.Reflection.BindingFlags)" />
-      <Member Name="GetPropertyImpl(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Type,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="HasElementTypeImpl" />
-      <Member Name="InvokeMember(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object,System.Object[],System.Reflection.ParameterModifier[],System.Globalization.CultureInfo,System.String[])" />
-      <Member Name="IsArrayImpl" />
-      <Member Name="IsAssignableFrom(System.Type)" />
-      <Member Name="IsByRefImpl" />
-      <Member Name="IsCOMObjectImpl" />
-      <Member Name="IsCreated" />
-      <Member Name="IsDefined(System.Type,System.Boolean)" />
-      <Member Name="IsPointerImpl" />
-      <Member Name="IsPrimitiveImpl" />
-      <Member Name="IsSubclassOf(System.Type)" />
-      <Member Name="MakeArrayType" />
-      <Member Name="MakeArrayType(System.Int32)" />
-      <Member Name="MakeByRefType" />
-      <Member Name="MakeGenericType(System.Type[])" />
-      <Member Name="MakePointerType" />
-      <Member Name="SetCustomAttribute(System.Reflection.ConstructorInfo,System.Byte[])" />
-      <Member Name="SetCustomAttribute(System.Reflection.Emit.CustomAttributeBuilder)" />
-      <Member Name="SetParent(System.Type)" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="Assembly" />
-      <Member MemberType="Property" Name="AssemblyQualifiedName" />
-      <Member MemberType="Property" Name="BaseType" />
-      <Member MemberType="Property" Name="DeclaringMethod" />
-      <Member MemberType="Property" Name="DeclaringType" />
-      <Member MemberType="Property" Name="FullName" />
-      <Member MemberType="Property" Name="GenericParameterAttributes" />
-      <Member MemberType="Property" Name="GenericParameterPosition" />
-      <Member MemberType="Property" Name="GUID" />
-      <Member MemberType="Property" Name="IsGenericParameter" />
-      <Member MemberType="Property" Name="IsGenericType" />
-      <Member MemberType="Property" Name="IsGenericTypeDefinition" />
-      <Member MemberType="Property" Name="Module" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="Namespace" />
-      <Member MemberType="Property" Name="PackingSize" />
-      <Member MemberType="Property" Name="ReflectedType" />
-      <Member MemberType="Property" Name="Size" />
-      <Member MemberType="Property" Name="TypeHandle" />
-      <Member MemberType="Property" Name="TypeToken" />
-      <Member MemberType="Property" Name="UnderlyingSystemType" />
-    </Type>
-    <Type Name="System.Reflection.Emit.TypeToken">
-      <Member MemberType="Field" Name="Empty" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.Reflection.Emit.TypeToken)" />
-      <Member Name="get_Token" />
-      <Member Name="GetHashCode" />
-      <Member Name="op_Equality(System.Reflection.Emit.TypeToken,System.Reflection.Emit.TypeToken)" />
-      <Member Name="op_Inequality(System.Reflection.Emit.TypeToken,System.Reflection.Emit.TypeToken)" />
-      <Member MemberType="Property" Name="Token" />
-    </Type>
-    <Type Name="System.Reflection.EventAttributes">
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="ReservedMask" />
-      <Member MemberType="Field" Name="RTSpecialName" />
-      <Member MemberType="Field" Name="SpecialName" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Reflection.EventInfo">
-      <Member Name="#ctor" />
-      <Member Name="op_Equality(System.Reflection.EventInfo,System.Reflection.EventInfo)" />
-      <Member Name="op_Inequality(System.Reflection.EventInfo,System.Reflection.EventInfo)" />
-      <Member Name="AddEventHandler(System.Object,System.Delegate)" />
-      <Member Name="get_Attributes" />
-      <Member Name="get_AddMethod" />
-      <Member Name="get_RaiseMethod" />
-      <Member Name="get_RemoveMethod" />
-      <Member Name="get_EventHandlerType" />
-      <Member Name="get_IsMulticast" />
-      <Member Name="get_IsSpecialName" />
-      <Member Name="get_MemberType" />
-      <Member Name="GetAddMethod" />
-      <Member Name="GetAddMethod(System.Boolean)" />
-      <Member Name="GetOtherMethods" />
-      <Member Name="GetOtherMethods(System.Boolean)" />
-      <Member Name="GetRaiseMethod" />
-      <Member Name="GetRaiseMethod(System.Boolean)" />
-      <Member Name="GetRemoveMethod" />
-      <Member Name="GetRemoveMethod(System.Boolean)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetHashCode" />
-      <Member Name="RemoveEventHandler(System.Object,System.Delegate)" />
-      <Member MemberType="Property" Name="Attributes" />
-      <Member MemberType="Property" Name="AddMethod" />
-      <Member MemberType="Property" Name="RaiseMethod" />
-      <Member MemberType="Property" Name="RemoveMethod" />
-      <Member MemberType="Property" Name="EventHandlerType" />
-      <Member MemberType="Property" Name="IsMulticast" />
-      <Member MemberType="Property" Name="IsSpecialName" />
-      <Member MemberType="Property" Name="MemberType" />
-    </Type>
-    <Type Name="System.Reflection.FieldAttributes">
-      <Member MemberType="Field" Name="Assembly" />
-      <Member MemberType="Field" Name="FamANDAssem" />
-      <Member MemberType="Field" Name="Family" />
-      <Member MemberType="Field" Name="FamORAssem" />
-      <Member MemberType="Field" Name="FieldAccessMask" />
-      <Member MemberType="Field" Name="HasDefault" />
-      <Member MemberType="Field" Name="HasFieldMarshal" />
-      <Member MemberType="Field" Name="HasFieldRVA" />
-      <Member MemberType="Field" Name="InitOnly" />
-      <Member MemberType="Field" Name="Literal" />
-      <Member MemberType="Field" Name="NotSerialized" />
-      <Member MemberType="Field" Name="PinvokeImpl" />
-      <Member MemberType="Field" Name="Private" />
-      <Member MemberType="Field" Name="PrivateScope" />
-      <Member MemberType="Field" Name="Public" />
-      <Member MemberType="Field" Name="ReservedMask" />
-      <Member MemberType="Field" Name="RTSpecialName" />
-      <Member MemberType="Field" Name="SpecialName" />
-      <Member MemberType="Field" Name="Static" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Reflection.FieldInfo">
-      <Member Name="#ctor" />
-      <Member Name="op_Equality(System.Reflection.FieldInfo,System.Reflection.FieldInfo)" />
-      <Member Name="op_Inequality(System.Reflection.FieldInfo,System.Reflection.FieldInfo)" />
-      <Member Name="get_Attributes" />
-      <Member Name="get_FieldHandle" />
-      <Member Name="get_FieldType" />
-      <Member Name="get_IsAssembly" />
-      <Member Name="get_IsFamily" />
-      <Member Name="get_IsFamilyAndAssembly" />
-      <Member Name="get_IsFamilyOrAssembly" />
-      <Member Name="get_IsInitOnly" />
-      <Member Name="get_IsLiteral" />
-      <Member Name="get_IsNotSerialized" />
-      <Member Name="get_IsPinvokeImpl" />
-      <Member Name="get_IsPrivate" />
-      <Member Name="get_IsPublic" />
-      <Member Name="get_IsSecurityCritical" />
-      <Member Name="get_IsSecuritySafeCritical" />
-      <Member Name="get_IsSecurityTransparent" />
-      <Member Name="get_IsSpecialName" />
-      <Member Name="get_IsStatic" />
-      <Member Name="get_MemberType" />
-      <Member Name="GetFieldFromHandle(System.RuntimeFieldHandle)" />
-      <Member Name="GetFieldFromHandle(System.RuntimeFieldHandle,System.RuntimeTypeHandle)" />
-      <Member Name="GetValue(System.Object)" />
-      <Member Name="GetOptionalCustomModifiers" />
-      <Member Name="GetRequiredCustomModifiers" />
-      <Member Name="GetRawConstantValue" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetHashCode" />
-      <Member Name="SetValue(System.Object,System.Object)" />
-      <Member Name="SetValue(System.Object,System.Object,System.Reflection.BindingFlags,System.Reflection.Binder,System.Globalization.CultureInfo)" />
-      <Member MemberType="Property" Name="Attributes" />
-      <Member MemberType="Property" Name="FieldHandle" />
-      <Member MemberType="Property" Name="FieldType" />
-      <Member MemberType="Property" Name="IsAssembly" />
-      <Member MemberType="Property" Name="IsFamily" />
-      <Member MemberType="Property" Name="IsFamilyAndAssembly" />
-      <Member MemberType="Property" Name="IsFamilyOrAssembly" />
-      <Member MemberType="Property" Name="IsInitOnly" />
-      <Member MemberType="Property" Name="IsLiteral" />
-      <Member MemberType="Property" Name="IsNotSerialized" />
-      <Member MemberType="Property" Name="IsPinvokeImpl" />
-      <Member MemberType="Property" Name="IsPrivate" />
-      <Member MemberType="Property" Name="IsPublic" />
-      <Member MemberType="Property" Name="IsSecurityCritical" />
-      <Member MemberType="Property" Name="IsSecuritySafeCritical" />
-      <Member MemberType="Property" Name="IsSecurityTransparent" />
-      <Member MemberType="Property" Name="IsSpecialName" />
-      <Member MemberType="Property" Name="IsStatic" />
-      <Member MemberType="Property" Name="MemberType" />
-    </Type>
-    <Type Name="System.Reflection.ICustomAttributeProvider">
-      <Member Name="GetCustomAttributes(System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Type,System.Boolean)" />
-      <Member Name="IsDefined(System.Type,System.Boolean)" />
-    </Type>
-    <Type Name="System.Reflection.ImageFileMachine">
-      <Member MemberType="Field" Name="I386" />
-      <Member MemberType="Field" Name="IA64" />
-      <Member MemberType="Field" Name="AMD64" />
-      <Member MemberType="Field" Name="ARM" />
-    </Type>
-	<Type Name="System.Reflection.InvalidFilterCriteriaException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Reflection.InterfaceMapping">
-      <Member MemberType="Field" Name="InterfaceMethods" />
-      <Member MemberType="Field" Name="InterfaceType" />
-      <Member MemberType="Field" Name="TargetMethods" />
-      <Member MemberType="Field" Name="TargetType" />
-    </Type>
-    <Type Name="System.Reflection.IReflect" >
-      <Member Name="get_UnderlyingSystemType" />
-      <Member Name="GetField(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetFields(System.Reflection.BindingFlags)" />
-      <Member Name="GetMember(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetMembers(System.Reflection.BindingFlags)" />
-      <Member Name="GetMethod(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetMethod(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetMethods(System.Reflection.BindingFlags)" />
-      <Member Name="GetProperty(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetProperty(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Type,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetProperties(System.Reflection.BindingFlags)" />
-      <Member Name="InvokeMember(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object,System.Object[],System.Reflection.ParameterModifier[],System.Globalization.CultureInfo,System.String[])" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Reflection.LoaderAllocator">
-      <Member Status="ImplRoot" Name="#ctor" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_slots" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_slotsUsed" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Reflection.ManifestResourceInfo">
-      <Member Name="#ctor(System.Reflection.Assembly,System.String,System.Reflection.ResourceLocation)" />
-      <Member MemberType="Property" Name="FileName" />
-      <Member MemberType="Property" Name="ReferencedAssembly" />
-      <Member MemberType="Property" Name="ResourceLocation" />
-    </Type>
-    <Type Name="System.Reflection.MemberInfo">
-      <Member Name="#ctor" />
-      <Member Name="op_Equality(System.Reflection.MemberInfo,System.Reflection.MemberInfo)" />
-      <Member Name="op_Inequality(System.Reflection.MemberInfo,System.Reflection.MemberInfo)" />
-      <Member Name="get_CustomAttributes" />
-      <Member Name="get_DeclaringType" />
-      <Member Name="get_MemberType" />
-      <Member Name="get_MetadataToken" />
-      <Member Name="get_Name" />
-      <Member Name="get_ReflectedType" />
-      <Member Name="GetCustomAttributes(System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Type,System.Boolean)" />
-      <Member Name="GetCustomAttributesData" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetHashCode" />
-      <Member Name="IsDefined(System.Type,System.Boolean)" />
-      <Member MemberType="Property" Name="CustomAttributes" />
-      <Member MemberType="Property" Name="DeclaringType" />
-      <Member MemberType="Property" Name="MemberType" />
-      <Member MemberType="Property" Name="MetadataToken" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="ReflectedType" />
-    </Type>
-    <Type Name="System.Reflection.MemberTypes">
-      <Member MemberType="Field" Name="All" />
-      <Member MemberType="Field" Name="Constructor" />
-      <Member MemberType="Field" Name="Custom" />
-      <Member MemberType="Field" Name="Event" />
-      <Member MemberType="Field" Name="Field" />
-      <Member MemberType="Field" Name="Method" />
-      <Member MemberType="Field" Name="NestedType" />
-      <Member MemberType="Field" Name="Property" />
-      <Member MemberType="Field" Name="TypeInfo" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Reflection.MethodAttributes">
-      <Member MemberType="Field" Name="Abstract" />
-      <Member MemberType="Field" Name="Assembly" />
-      <Member MemberType="Field" Name="FamANDAssem" />
-      <Member MemberType="Field" Name="Family" />
-      <Member MemberType="Field" Name="FamORAssem" />
-      <Member MemberType="Field" Name="Final" />
-      <Member MemberType="Field" Name="HasSecurity" />
-      <Member MemberType="Field" Name="HideBySig" />
-      <Member MemberType="Field" Name="MemberAccessMask" />
-      <Member MemberType="Field" Name="NewSlot" />
-      <Member MemberType="Field" Name="PinvokeImpl" />
-      <Member MemberType="Field" Name="Private" />
-      <Member MemberType="Field" Name="PrivateScope" />
-      <Member MemberType="Field" Name="Public" />
-      <Member MemberType="Field" Name="RequireSecObject" />
-      <Member MemberType="Field" Name="ReservedMask" />
-      <Member MemberType="Field" Name="ReuseSlot" />
-      <Member MemberType="Field" Name="RTSpecialName" />
-      <Member MemberType="Field" Name="SpecialName" />
-      <Member MemberType="Field" Name="Static" />
-      <Member MemberType="Field" Name="UnmanagedExport" />
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="Virtual" />
-      <Member MemberType="Field" Name="VtableLayoutMask" />
-    </Type>
-    <Type Name="System.Reflection.MethodBase">
-      <Member Name="#ctor" />
-      <Member Name="get_Attributes" />
-      <Member Name="get_CallingConvention" />
-      <Member Name="get_ContainsGenericParameters" />
-      <Member Name="get_IsAbstract" />
-      <Member Name="get_IsAssembly" />
-      <Member Name="get_IsConstructor" />
-      <Member Name="get_IsFamily" />
-      <Member Name="get_IsFamilyAndAssembly" />
-      <Member Name="get_IsFamilyOrAssembly" />
-      <Member Name="get_IsFinal" />
-      <Member Name="get_IsGenericMethod" />
-      <Member Name="get_IsGenericMethodDefinition" />
-      <Member Name="get_IsHideBySig" />
-      <Member Name="get_IsPrivate" />
-      <Member Name="get_IsPublic" />
-      <Member Name="get_IsSpecialName" />
-      <Member Name="get_IsStatic" />
-      <Member Name="get_IsVirtual" />
-      <Member Name="get_IsSecurityCritical" />
-      <Member Name="get_IsSecuritySafeCritical" />
-      <Member Name="get_IsSecurityTransparent" />
-      <Member Name="get_MethodHandle" />
-      <Member Name="get_MethodImplementationFlags" />
-      <Member Name="GetGenericArguments" />
-      <Member Status="ImplRoot" Name="GetMethodDesc" />
-      <Member Name="GetMethodFromHandle(System.RuntimeMethodHandle)" />
-      <Member Name="GetMethodFromHandle(System.RuntimeMethodHandle,System.RuntimeTypeHandle)" />
-      <Member Name="GetMethodImplementationFlags" />
-      <Member Name="GetParameters" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="op_Equality(System.Reflection.MethodBase,System.Reflection.MethodBase)" />
-      <Member Name="op_Inequality(System.Reflection.MethodBase,System.Reflection.MethodBase)" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetMethodBody" />
-      <Member Name="Invoke(System.Object,System.Object[])" />
-      <Member Name="Invoke(System.Object,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object[],System.Globalization.CultureInfo)" />
-      <Member MemberType="Property" Name="Attributes" />
-      <Member MemberType="Property" Name="CallingConvention" />
-      <Member MemberType="Property" Name="ContainsGenericParameters" />
-      <Member MemberType="Property" Name="IsAbstract" />
-      <Member MemberType="Property" Name="IsAssembly" />
-      <Member MemberType="Property" Name="IsConstructor" />
-      <Member MemberType="Property" Name="IsFamily" />
-      <Member MemberType="Property" Name="IsFamilyAndAssembly" />
-      <Member MemberType="Property" Name="IsFamilyOrAssembly" />
-      <Member MemberType="Property" Name="IsFinal" />
-      <Member MemberType="Property" Name="IsGenericMethod" />
-      <Member MemberType="Property" Name="IsGenericMethodDefinition" />
-      <Member MemberType="Property" Name="IsHideBySig" />
-      <Member MemberType="Property" Name="IsPrivate" />
-      <Member MemberType="Property" Name="IsPublic" />
-      <Member MemberType="Property" Name="IsSpecialName" />
-      <Member MemberType="Property" Name="IsStatic" />
-      <Member MemberType="Property" Name="IsVirtual" />
-      <Member MemberType="Property" Name="IsSecurityCritical" />
-      <Member MemberType="Property" Name="IsSecuritySafeCritical" />
-      <Member MemberType="Property" Name="IsSecurityTransparent" />
-      <Member MemberType="Property" Name="MethodHandle" />
-      <Member MemberType="Property" Name="MethodImplementationFlags" />
-      <Member Name="GetCurrentMethod" />
-    </Type>
-    <Type Name="System.Reflection.MethodImplAttributes">
-      <Member MemberType="Field" Name="AggressiveInlining" />
-      <Member MemberType="Field" Name="CodeTypeMask" />
-      <Member MemberType="Field" Name="ForwardRef" />
-      <Member MemberType="Field" Name="IL" />
-      <Member MemberType="Field" Name="InternalCall" />
-      <Member MemberType="Field" Name="Managed" />
-      <Member MemberType="Field" Name="ManagedMask" />
-      <Member MemberType="Field" Name="MaxMethodImplVal" />
-      <Member MemberType="Field" Name="Native" />
-      <Member MemberType="Field" Name="NoInlining" />
-      <Member MemberType="Field" Name="OPTIL" />
-      <Member MemberType="Field" Name="PreserveSig" />
-      <Member MemberType="Field" Name="Runtime" />
-      <Member MemberType="Field" Name="Synchronized" />
-      <Member MemberType="Field" Name="Unmanaged" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Reflection.MethodInfo">
-      <Member Name="#ctor" />
-      <Member Name="op_Equality(System.Reflection.MethodInfo,System.Reflection.MethodInfo)" />
-      <Member Name="op_Inequality(System.Reflection.MethodInfo,System.Reflection.MethodInfo)" />
-      <Member Name="get_MemberType" />
-      <Member Name="get_ReturnParameter" />
-      <Member Name="get_ReturnType" />
-      <Member Name="get_ReturnTypeCustomAttributes" />
-      <Member Name="GetBaseDefinition" />
-      <Member Name="GetGenericArguments" />
-      <Member Name="GetGenericMethodDefinition" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetHashCode" />
-      <Member Name="MakeGenericMethod(System.Type[])" />
-      <Member MemberType="Property" Name="MemberType" />
-      <Member MemberType="Property" Name="ReturnParameter" />
-      <Member MemberType="Property" Name="ReturnType" />
-      <Member MemberType="Property" Name="ReturnTypeCustomAttributes" />
-    </Type>
-    <Type Name="System.Reflection.Missing">
-      <Member MemberType="Field" Name="Value" />
-      <Member Name="System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Reflection.Module">
-      <Member Name="#ctor" />
-      <Member Name="op_Equality(System.Reflection.Module,System.Reflection.Module)" />
-      <Member Name="op_Inequality(System.Reflection.Module,System.Reflection.Module)" />
-      <Member Name="get_Assembly" />
-      <Member Name="get_CustomAttributes" />
-      <Member Name="get_FullyQualifiedName" />
-      <Member Name="get_MDStreamVersion" />
-      <Member Name="get_MetadataToken" />
-      <Member Name="get_ModuleHandle" />
-      <Member Name="get_ModuleVersionId" />
-      <Member Name="get_Name" />
-      <Member Name="get_ScopeName" />
-      <Member Name="FindTypes(System.Reflection.TypeFilter,System.Object)" />
-	  <Member Name="GetCustomAttributes(System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Type,System.Boolean)" />
-      <Member Name="GetCustomAttributesData" />
-      <Member Name="GetField(System.String)" />
-      <Member Name="GetField(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetFields" />
-      <Member Name="GetFields(System.Reflection.BindingFlags)" />
-      <Member Name="GetMethod(System.String)" />
-      <Member Name="GetMethod(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Reflection.CallingConventions,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetMethod(System.String,System.Type[])" />
-      <Member Name="GetMethodImpl(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Reflection.CallingConventions,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetMethods" />
-      <Member Name="GetMethods(System.Reflection.BindingFlags)" />
-      <Member Name="GetPEKind(System.Reflection.PortableExecutableKinds@,System.Reflection.ImageFileMachine@)" />
-      <Member Name="GetType(System.String)" />
-      <Member Name="GetType(System.String,System.Boolean)" />
-      <Member Name="GetType(System.String,System.Boolean,System.Boolean)" />
-      <Member Name="GetTypes" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetHashCode" />
-      <Member Name="IsDefined(System.Type,System.Boolean)" />
-      <Member Name="IsResource" />
-      <Member Name="ResolveMember(System.Int32)" />
-      <Member Name="ResolveMember(System.Int32,System.Type[],System.Type[])" />
-      <Member Name="ResolveMethod(System.Int32)" />
-      <Member Name="ResolveMethod(System.Int32,System.Type[],System.Type[])" />
-      <Member Name="ResolveField(System.Int32)" />
-      <Member Name="ResolveField(System.Int32,System.Type[],System.Type[])" />
-      <Member Name="ResolveSignature(System.Int32)" />
-      <Member Name="ResolveString(System.Int32)" />
-      <Member Name="ResolveType(System.Int32)" />
-      <Member Name="ResolveType(System.Int32,System.Type[],System.Type[])" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="Assembly" />
-      <Member MemberType="Property" Name="CustomAttributes" />
-      <Member MemberType="Property" Name="FullyQualifiedName" />
-      <Member MemberType="Property" Name="MetadataToken" />
-      <Member MemberType="Property" Name="ModuleVersionId" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="ScopeName" />
-	  <Member MemberType="Field" Name="FilterTypeName" />
-	  <Member MemberType="Field" Name="FilterTypeNameIgnoreCase" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Reflection.RuntimeModule">
-      <Member Status="ImplRoot" MemberType="Field" Name="m_pData" /> <!-- EE -->
-      <Member Status="ImplRoot" MemberType="Field" Name="m_pFields" /> <!-- EE -->
-      <Member Status="ImplRoot" MemberType="Field" Name="m_pGlobals" /> <!-- EE -->
-      <Member Status="ImplRoot" MemberType="Field" Name="m_pRefClass" /> <!-- EE -->
-      <Member Status="ImplRoot" MemberType="Field" Name="m_runtimeType" /> <!-- EE -->
-    </Type>
-    <Type Name="System.Reflection.ModuleResolveEventHandler">
-      <Member Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Name="BeginInvoke(System.Object,System.ResolveEventArgs,System.AsyncCallback,System.Object)" />
-      <Member Name="EndInvoke(System.IAsyncResult)" />
-      <Member Name="Invoke(System.Object,System.ResolveEventArgs)" />
-    </Type>
-    <Type Name="System.Reflection.ObfuscateAssemblyAttribute">
-      <Member Name="#ctor(System.Boolean)" />
-      <Member Name="get_AssemblyIsPrivate" />
-      <Member Name="get_StripAfterObfuscation" />
-      <Member Name="set_StripAfterObfuscation(System.Boolean)" />
-      <Member MemberType="Property" Name="AssemblyIsPrivate" />
-      <Member MemberType="Property" Name="StripAfterObfuscation" />
-    </Type>
-    <Type Name="System.Reflection.ObfuscationAttribute">
-      <Member Name="#ctor" />
-      <Member Name="get_ApplyToMembers" />
-      <Member Name="get_Exclude" />
-      <Member Name="get_Feature" />
-      <Member Name="get_StripAfterObfuscation" />
-      <Member Name="set_ApplyToMembers(System.Boolean)" />
-      <Member Name="set_Exclude(System.Boolean)" />
-      <Member Name="set_Feature(System.String)" />
-      <Member Name="set_StripAfterObfuscation(System.Boolean)" />
-      <Member MemberType="Property" Name="ApplyToMembers" />
-      <Member MemberType="Property" Name="Exclude" />
-      <Member MemberType="Property" Name="Feature" />
-      <Member MemberType="Property" Name="StripAfterObfuscation" />
-    </Type>
-    <Type Name="System.Reflection.ParameterAttributes">
-      <Member MemberType="Field" Name="HasDefault" />
-      <Member MemberType="Field" Name="HasFieldMarshal" />
-      <Member MemberType="Field" Name="In" />
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="Optional" />
-      <Member MemberType="Field" Name="Out" />
-      <Member MemberType="Field" Name="Reserved3" />
-      <Member MemberType="Field" Name="Reserved4" />
-      <Member MemberType="Field" Name="ReservedMask" />
-      <Member MemberType="Field" Name="Retval" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Reflection.ParameterInfo">
-      <Member MemberType="Field" Name="AttrsImpl" />
-      <Member MemberType="Field" Name="ClassImpl" />
-      <Member MemberType="Field" Name="DefaultValueImpl" />
-      <Member MemberType="Field" Name="MemberImpl" />
-      <Member MemberType="Field" Name="NameImpl" />
-      <Member MemberType="Field" Name="PositionImpl" />
-      <Member Name="#ctor" />
-      <Member Name="get_Attributes" />
-      <Member Name="get_CustomAttributes" />
-      <Member Name="get_DefaultValue" />
-      <Member Name="get_HasDefaultValue" />
-      <Member Name="get_IsOptional" />
-      <Member Name="get_IsOut" />
-      <Member Name="get_IsIn" />
-      <Member Name="get_IsLcid" />
-      <Member Name="get_IsRetval" />
-      <Member Name="get_Member" />
-      <Member Name="get_MetadataToken" />
-      <Member Name="get_Name" />
-      <Member Name="get_ParameterType" />
-      <Member Name="get_Position" />
-      <Member Name="get_RawDefaultValue" />
-      <Member Name="GetOptionalCustomModifiers" />
-      <Member Name="GetRequiredCustomModifiers" />
-      <Member Name="GetCustomAttributes(System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Type,System.Boolean)" />
-      <Member Name="GetCustomAttributesData" />
-      <Member Name="IsDefined(System.Type,System.Boolean)" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="Attributes" />
-      <Member MemberType="Property" Name="CustomAttributes" />
-      <Member MemberType="Property" Name="DefaultValue" />
-      <Member MemberType="Property" Name="HasDefaultValue" />
-      <Member MemberType="Property" Name="IsOptional" />
-      <Member MemberType="Property" Name="IsOut" />
-      <Member MemberType="Property" Name="IsIn" />
-      <Member MemberType="Property" Name="IsRetval" />
-      <Member MemberType="Property" Name="Member" />
-      <Member MemberType="Property" Name="MetadataToken" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="ParameterType" />
-      <Member MemberType="Property" Name="Position" />
-      <Member MemberType="Property" Name="RawDefaultValue" />
-    </Type>
-    <Type Name="System.Reflection.ParameterModifier">
-      <Member Name="#ctor(System.Int32)" />
-      <Member Name="get_Item(System.Int32)" />
-      <Member Name="set_Item(System.Int32,System.Boolean)" />
-      <Member MemberType="Property" Name="Item(System.Int32)" />
-    </Type>
-    <Type Name="System.Reflection.Pointer" >
-      <Member Name="Box(System.Void*,System.Type)" />
-      <Member Name="Unbox(System.Object)" />
-      <Member Name="System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Reflection.PortableExecutableKinds">
-      <Member MemberType="Field" Name="NotAPortableExecutableImage" />
-      <Member MemberType="Field" Name="ILOnly" />
-      <Member MemberType="Field" Name="Required32Bit" />
-      <Member MemberType="Field" Name="PE32Plus" />
-      <Member MemberType="Field" Name="Unmanaged32Bit" />
-      <Member MemberType="Field" Name="Preferred32Bit" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Reflection.PropertyAttributes">
-      <Member MemberType="Field" Name="HasDefault" />
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="Reserved2" />
-      <Member MemberType="Field" Name="Reserved3" />
-      <Member MemberType="Field" Name="Reserved4" />
-      <Member MemberType="Field" Name="ReservedMask" />
-      <Member MemberType="Field" Name="RTSpecialName" />
-      <Member MemberType="Field" Name="SpecialName" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Reflection.PropertyInfo">
-      <Member Name="#ctor" />
-      <Member Name="op_Equality(System.Reflection.PropertyInfo,System.Reflection.PropertyInfo)" />
-      <Member Name="op_Inequality(System.Reflection.PropertyInfo,System.Reflection.PropertyInfo)" />
-      <Member Name="get_Attributes" />
-      <Member Name="get_CanRead" />
-      <Member Name="get_CanWrite" />
-      <Member Name="get_GetMethod" />
-      <Member Name="get_IsSpecialName" />
-      <Member Name="get_MemberType" />
-      <Member Name="get_PropertyType" />
-      <Member Name="get_SetMethod" />
-      <Member Name="GetAccessors" />
-      <Member Name="GetAccessors(System.Boolean)" />
-      <Member Name="GetConstantValue" />
-      <Member Name="GetGetMethod" />
-      <Member Name="GetGetMethod(System.Boolean)" />
-      <Member Name="GetIndexParameters" />
-      <Member Name="GetOptionalCustomModifiers" />
-      <Member Name="GetRequiredCustomModifiers" />
-      <Member Name="GetRawConstantValue" />
-      <Member Name="GetSetMethod" />
-      <Member Name="GetSetMethod(System.Boolean)" />
-      <Member Name="GetValue(System.Object)" />
-      <Member Name="GetValue(System.Object,System.Object[])" />
-      <Member Name="GetValue(System.Object,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object[],System.Globalization.CultureInfo)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetHashCode" />
-      <Member Name="SetValue(System.Object,System.Object)" />
-      <Member Name="SetValue(System.Object,System.Object,System.Object[])" />
-      <Member Name="SetValue(System.Object,System.Object,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object[],System.Globalization.CultureInfo)" />
-      <Member MemberType="Property" Name="Attributes" />
-      <Member MemberType="Property" Name="CanRead" />
-      <Member MemberType="Property" Name="CanWrite" />
-      <Member MemberType="Property" Name="GetMethod" />
-      <Member MemberType="Property" Name="SetMethod" />
-      <Member MemberType="Property" Name="IsSpecialName" />
-      <Member MemberType="Property" Name="MemberType" />
-      <Member MemberType="Property" Name="PropertyType" />
-    </Type>
-    <Type Name="System.Reflection.TargetException" >
-	  <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Reflection.TargetInvocationException">
-      <Member Name="#ctor(System.Exception)" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Reflection.TargetParameterCountException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Reflection.TypeAttributes">
-      <Member MemberType="Field" Name="Abstract" />
-      <Member MemberType="Field" Name="AnsiClass" />
-      <Member MemberType="Field" Name="AutoClass" />
-      <Member MemberType="Field" Name="AutoLayout" />
-      <Member MemberType="Field" Name="BeforeFieldInit" />
-      <Member MemberType="Field" Name="Class" />
-      <Member MemberType="Field" Name="ClassSemanticsMask" />
-      <Member MemberType="Field" Name="ExplicitLayout" />
-      <Member MemberType="Field" Name="HasSecurity" />
-      <Member MemberType="Field" Name="Import" />
-      <Member MemberType="Field" Name="Interface" />
-      <Member MemberType="Field" Name="LayoutMask" />
-      <Member MemberType="Field" Name="NestedAssembly" />
-      <Member MemberType="Field" Name="NestedFamANDAssem" />
-      <Member MemberType="Field" Name="NestedFamily" />
-      <Member MemberType="Field" Name="NestedFamORAssem" />
-      <Member MemberType="Field" Name="NestedPrivate" />
-      <Member MemberType="Field" Name="NestedPublic" />
-      <Member MemberType="Field" Name="NotPublic" />
-      <Member MemberType="Field" Name="Public" />
-      <Member MemberType="Field" Name="ReservedMask" />
-      <Member MemberType="Field" Name="RTSpecialName" />
-      <Member MemberType="Field" Name="Sealed" />
-      <Member MemberType="Field" Name="SequentialLayout" />
-      <Member MemberType="Field" Name="Serializable" />
-      <Member MemberType="Field" Name="SpecialName" />
-      <Member MemberType="Field" Name="StringFormatMask" />
-      <Member MemberType="Field" Name="UnicodeClass" />
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="VisibilityMask" />
-    </Type>
-    <Type Name="System.Reflection.TypeDelegator">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Type)" />
-      <Member Name="get_GUID" />
-      <Member Name="get_MetadataToken" />
-      <Member Name="InvokeMember(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object,System.Object[],System.Reflection.ParameterModifier[],System.Globalization.CultureInfo,System.String[])" />
-      <Member Name="get_Module" />
-      <Member Name="get_Assembly" />
-      <Member Name="get_TypeHandle" />
-      <Member Name="get_Name" />
-      <Member Name="get_FullName" />
-      <Member Name="get_Namespace" />
-      <Member Name="get_AssemblyQualifiedName" />
-      <Member Name="get_BaseType" />
-      <Member Name="GetConstructorImpl(System.Reflection.BindingFlags,System.Reflection.Binder,System.Reflection.CallingConventions,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetConstructors(System.Reflection.BindingFlags)" />
-      <Member Name="GetMethodImpl(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Reflection.CallingConventions,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetMethods(System.Reflection.BindingFlags)" />
-      <Member Name="GetField(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetFields(System.Reflection.BindingFlags)" />
-      <Member Name="GetInterface(System.String,System.Boolean)" />
-      <Member Name="GetInterfaces" />
-      <Member Name="GetEvent(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetEvents" />
-      <Member Name="GetPropertyImpl(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Type,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetProperties(System.Reflection.BindingFlags)" />
-      <Member Name="GetEvents(System.Reflection.BindingFlags)" />
-      <Member Name="GetNestedTypes(System.Reflection.BindingFlags)" />
-      <Member Name="GetNestedType(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetMember(System.String,System.Reflection.MemberTypes,System.Reflection.BindingFlags)" />
-      <Member Name="GetMembers(System.Reflection.BindingFlags)" />
-      <Member Name="GetAttributeFlagsImpl" />
-      <Member Name="IsArrayImpl" />
-      <Member Name="IsPrimitiveImpl" />
-      <Member Name="IsByRefImpl" />
-      <Member Name="IsPointerImpl" />
-      <Member Name="IsValueTypeImpl" />
-      <Member Name="IsCOMObjectImpl" />
-      <Member Name="get_IsConstructedGenericType" />
-      <Member Name="GetElementType" />
-      <Member Name="HasElementTypeImpl" />
-      <Member Name="get_UnderlyingSystemType" />
-      <Member Name="GetCustomAttributes(System.Boolean)" />
-      <Member Name="GetCustomAttributes(System.Type,System.Boolean)" />
-      <Member Name="IsDefined(System.Type,System.Boolean)" />
-      <Member Name="IsAssignableFrom(System.Reflection.TypeInfo)" />
-      <Member Name="GetInterfaceMap(System.Type)" />
-      <Member MemberType="Field" Name="typeImpl" />
-      <Member MemberType="Property" Name="GUID" />
-      <Member MemberType="Property" Name="MetadataToken" />
-      <Member MemberType="Property" Name="Module" />
-      <Member MemberType="Property" Name="Assembly" />
-      <Member MemberType="Property" Name="TypeHandle" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="FullName" />
-      <Member MemberType="Property" Name="Namespace" />
-      <Member MemberType="Property" Name="AssemblyQualifiedName" />
-      <Member MemberType="Property" Name="BaseType" />
-      <Member MemberType="Property" Name="IsConstructedGenericType" />
-      <Member MemberType="Property" Name="UnderlyingSystemType" />
-    </Type>
-    <Type Name="System.ResolveEventArgs">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Reflection.Assembly)" />
-      <Member Name="get_Name" />
-      <Member MemberType="Property" Name="Name" />
-      <Member Name="get_RequestingAssembly" />
-      <Member MemberType="Property" Name="RequestingAssembly" />
-    </Type>
-    <Type Name="System.ResolveEventHandler">
-      <Member Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Name="BeginInvoke(System.Object,System.ResolveEventArgs,System.AsyncCallback,System.Object)" />
-      <Member Name="EndInvoke(System.IAsyncResult)" />
-      <Member Name="Invoke(System.Object,System.ResolveEventArgs)" />
-    </Type>
-    <Type Name="System.Resources.MissingManifestResourceException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Resources.MissingSatelliteAssemblyException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="get_CultureName" />
-      <Member MemberType="Property" Name="CultureName"/>
-    </Type>
-    <Type Name="System.Resources.NeutralResourcesLanguageAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Resources.UltimateResourceFallbackLocation)" />
-      <Member Name="get_CultureName" />
-      <Member MemberType="Property" Name="CultureName" />
-      <Member Name="get_Location" />
-      <Member MemberType="Property" Name="Location" />
-    </Type>
-    <Type Name="System.Resources.IResourceReader">
-      <Member Name="Close"/>
-      <Member Name="GetEnumerator"/>
-    </Type>
-    <Type Name="System.Resources.ResourceReader">
-      <Member Name="#ctor(System.IO.Stream)"/>
-      <Member Name="#ctor(System.String)"/>
-      <Member Name="Close"/>
-      <Member Name="Dispose"/>
-      <Member Name="GetResourceData(System.String,System.String@,System.Byte[]@)"/>
-      <Member Name="GetEnumerator"/>
-      <Member Name="System.Collections.IEnumerable.GetEnumerator"/>
-    </Type>
-    <Type Name="System.Resources.ResourceManager">
-      <Member MemberType="Field" Name="BaseNameField" />
-      <Member MemberType="Field" Name="HeaderVersionNumber" />
-      <Member MemberType="Field" Name="MagicNumber" />
-      <Member MemberType="Field" Name="MainAssembly" />
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String,System.Reflection.Assembly)" />
-      <Member Name="#ctor(System.String,System.Reflection.Assembly,System.Type)" />
-      <Member Name="#ctor(System.Type)" />
-      <Member Name="get_BaseName" />
-      <Member Name="get_IgnoreCase" />
-      <Member Name="get_ResourceSetType" />
-      <Member Name="get_FallbackLocation" />
-      <Member Name="GetNeutralResourcesLanguage(System.Reflection.Assembly)" />
-      <Member Name="GetObject(System.String)" />
-      <Member Name="GetObject(System.String,System.Globalization.CultureInfo)" />
-      <Member Name="GetResourceFileName(System.Globalization.CultureInfo)" />
-      <Member Name="GetResourceSet(System.Globalization.CultureInfo,System.Boolean,System.Boolean)" />
-      <Member Name="GetSatelliteContractVersion(System.Reflection.Assembly)" />
-      <Member Name="GetStream(System.String)" />
-      <Member Name="GetStream(System.String,System.Globalization.CultureInfo)" />
-      <Member Name="GetString(System.String)" />
-      <Member Name="GetString(System.String,System.Globalization.CultureInfo)" />
-      <Member Name="InternalGetResourceSet(System.Globalization.CultureInfo,System.Boolean,System.Boolean)" />
-      <Member Status="ImplRoot" Name="OnDeserialized(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="OnDeserializing(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="OnSerializing(System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="ReleaseAllResources" />
-      <Member Name="set_IgnoreCase(System.Boolean)" />
-      <Member Name="set_FallbackLocation(System.Resources.UltimateResourceFallbackLocation)" />
-      <Member MemberType="Property" Name="BaseName" />
-      <Member MemberType="Property" Name="IgnoreCase" />
-      <Member MemberType="Property" Name="ResourceSetType" />
-      <Member MemberType="Property" Name="FallbackLocation" />
-      <Member Name="CreateFileBasedResourceManager(System.String,System.String,System.Type)" />
-    </Type>
-    <Type Name="System.Resources.ResourceSet">
-      <Member MemberType="Field" Name="Reader" />
-      <Member MemberType="Field" Name="Table" />
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.IO.Stream)" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.Resources.IResourceReader)" />
-      <Member Name="Close" />
-      <Member Name="Dispose" />
-      <Member Name="Dispose(System.Boolean)" />
-      <Member Name="GetDefaultReader" />
-      <Member Name="GetDefaultWriter" />
-      <Member Name="GetEnumerator" />
-      <Member Name="GetObject(System.String)" />
-      <Member Name="GetObject(System.String,System.Boolean)" />
-      <Member Name="GetString(System.String)" />
-      <Member Name="GetString(System.String,System.Boolean)" />
-      <Member Name="ReadResources" />
-    </Type>
-    <Type Name="System.Resources.SatelliteContractVersionAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_Version" />
-      <Member MemberType="Property" Name="Version" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.AccessedThroughPropertyAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_PropertyName" />
-      <Member MemberType="Property" Name="PropertyName" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.CompilationRelaxations">
-      <Member MemberType="Field" Name="NoStringInterning" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.CompilationRelaxationsAttribute">
-      <Member Name="#ctor(System.Int32)" />
-      <Member Name="#ctor(System.Runtime.CompilerServices.CompilationRelaxations)" />
-      <Member MemberType="Property" Name="CompilationRelaxations" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.CompilerMarshalOverride" />
-    <Type Name="System.Runtime.CompilerServices.CustomConstantAttribute">
-      <Member Name="#ctor" />
-      <Member Name="get_Value" />
-      <Member MemberType="Property" Name="Value" />
-    </Type>
-    <!-- If we do a Silverlight 6 release, this ContractHelper should be public in Silverlight. Tools may be able to work without it, but it helps if it's there. -->
-    <Type Name="System.Runtime.CompilerServices.ContractHelper">
-      <Member Name="RaiseContractFailedEvent(System.Diagnostics.Contracts.ContractFailureKind,System.String,System.String,System.Exception)" />
-      <Member Name="TriggerFailure(System.Diagnostics.Contracts.ContractFailureKind,System.String,System.String,System.String,System.Exception)" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.DateTimeConstantAttribute">
-      <Member Name="#ctor(System.Int64)" />
-      <Member Name="get_Value" />
-      <Member MemberType="Property" Name="Value" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.DecimalConstantAttribute">
-      <Member Name="#ctor(System.Byte,System.Byte,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="#ctor(System.Byte,System.Byte,System.UInt32,System.UInt32,System.UInt32)" />
-      <Member Name="get_Value" />
-      <Member MemberType="Property" Name="Value" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.DefaultDependencyAttribute">
-      <Member Name="#ctor(System.Runtime.CompilerServices.LoadHint)" />
-      <Member Name="get_LoadHint" />
-      <Member MemberType="Property" Name="LoadHint" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.DependencyAttribute">
-      <Member Name="#ctor(System.String,System.Runtime.CompilerServices.LoadHint)" />
-      <Member Name="get_DependentAssembly" />
-      <Member Name="get_LoadHint" />
-      <Member MemberType="Property" Name="DependentAssembly" />
-      <Member MemberType="Property" Name="LoadHint" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.DiscardableAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.DisablePrivateReflectionAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.ExtensionAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.FixedBufferAttribute">
-      <Member Name="#ctor(System.Type,System.Int32)" />
-      <Member Name="get_ElementType" />
-      <Member Name="get_Length" />
-      <Member MemberType="Property" Name="ElementType" />
-      <Member MemberType="Property" Name="Length" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.FixedAddressValueTypeAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.FormattableStringFactory">
-      <Member Name="Create(System.String,System.Object[])" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.CompilerServices.FriendAccessAllowedAttribute" />
-    <Type Name="System.Runtime.CompilerServices.IndexerNameAttribute">
-      <Member Name="#ctor(System.String)" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_AssemblyName" />
-      <Member MemberType="Property" Name="AllInternalsVisible" />
-      <Member MemberType="Property" Name="AssemblyName" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.CompilerServices.JitHelpers">
-      <Member Status="ImplRoot" Name="UnsafeEnumCastLong&lt;T&gt;(T)" />
-      <Member Status="ImplRoot" Name="UnsafeEnumCastLongInternal&lt;T&gt;(T)" Condition="DEBUG" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.SpecialNameAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.UnsafeValueTypeAttribute"> <!-- C# 3.0 compiler requires this type -->
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.SuppressMergeCheckAttribute"> <!-- for MC++ -->
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.ICastable">
-      <Member Name="IsInstanceOfInterface(System.RuntimeTypeHandle,System.Exception@)" /> <!-- EE -->
-      <Member Name="GetImplType(System.RuntimeTypeHandle)" /> <!-- EE -->
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.ICastableHelpers">
-      <Member Name="IsInstanceOfInterface(System.Runtime.CompilerServices.ICastable,System.RuntimeType,System.Exception@)" /> <!-- EE -->
-      <Member Name="GetImplType(System.Runtime.CompilerServices.ICastable,System.RuntimeType)" /> <!-- EE -->
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.IsVolatile" />  <!-- for All Compilers, [ C# and MC++ uses it] -->
-    <Type Name="System.Runtime.CompilerServices.MethodCodeType">
-      <Member MemberType="Field" Name="IL" />
-      <Member MemberType="Field" Name="Native" />
-      <Member MemberType="Field" Name="OPTIL" />
-      <Member MemberType="Field" Name="Runtime" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.MethodImplAttribute">
-      <Member MemberType="Field" Name="MethodCodeType" />
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Int16)" />
-      <Member Name="#ctor(System.Runtime.CompilerServices.MethodImplOptions)" />
-      <Member Name="get_Value" />
-      <Member MemberType="Property" Name="Value" />
-      <Member Status="ImplRoot" Name="#ctor(System.Reflection.MethodImplAttributes)" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.MethodImplOptions">
-      <Member MemberType="Field" Name="AggressiveInlining" />
-      <Member MemberType="Field" Name="ForwardRef" />
-      <Member MemberType="Field" Name="InternalCall" />
-      <Member MemberType="Field" Name="NoInlining" />
-      <Member MemberType="Field" Name="PreserveSig" />
-      <Member MemberType="Field" Name="Synchronized" />
-      <Member MemberType="Field" Name="Unmanaged" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.RuntimeHelpers">
-      <Member Name="Equals(System.Object,System.Object)" />
-      <Member Name="GetUninitializedObject(System.Type)" />
-      <Member Name="EnsureSufficientExecutionStack" />
-      <Member Name="TryEnsureSufficientExecutionStack" />
-      <Member Name="get_OffsetToStringData" />
-      <Member Name="GetObjectValue(System.Object)" />
-      <Member Name="InitializeArray(System.Array,System.RuntimeFieldHandle)" />
-      <Member Name="GetHashCode(System.Object)" />
-      <Member Name="RunClassConstructor(System.RuntimeTypeHandle)" />
-      <Member Name="RunModuleConstructor(System.ModuleHandle)" />
-      <Member Name="ExecuteCodeWithGuaranteedCleanup(System.Runtime.CompilerServices.RuntimeHelpers+TryCode,System.Runtime.CompilerServices.RuntimeHelpers+CleanupCode,System.Object)" />
-      <Member MemberType="Property" Name="OffsetToStringData" />
-      <Member Status="ImplRoot" Name="ExecuteBackoutCodeHelper(System.Object,System.Object,System.Boolean)" />
-      <Member Name="PrepareConstrainedRegions" />
-      <Member Name="PrepareConstrainedRegionsNoOP" />
-      <Member Name="PrepareContractedDelegate(System.Delegate)" />
-      <Member Name="PrepareDelegate(System.Delegate)" />
-      <Member Name="PrepareMethod(System.RuntimeMethodHandle)" />
-      <Member Name="PrepareMethod(System.RuntimeMethodHandle,System.RuntimeTypeHandle[])" />
-      <Member Name="ProbeForSufficientStack" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.RuntimeHelpers+CleanupCode">
-      <Member Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Name="BeginInvoke(System.Object,System.Boolean,System.AsyncCallback,System.Object)" />
-      <Member Name="EndInvoke(System.IAsyncResult)" />
-      <Member Name="Invoke(System.Object,System.Boolean)" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.RuntimeHelpers+TryCode">
-      <Member Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Name="BeginInvoke(System.Object,System.AsyncCallback,System.Object)" />
-      <Member Name="EndInvoke(System.IAsyncResult)" />
-      <Member Name="Invoke(System.Object)" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.ConditionalWeakTable&lt;TKey,TValue&gt;">
-      <Member Name="#ctor" />
-      <Member Name="Add(TKey,TValue)" />
-      <Member Name="AddOrUpdate(TKey,TValue)" />
-      <Member Name="Clear" />
-      <Member Name="Remove(TKey)" />
-      <Member Name="TryGetValue(TKey,TValue@)" />
-      <Member Name="GetValue(TKey,System.Runtime.CompilerServices.ConditionalWeakTable+CreateValueCallback)" />
-      <Member Name="GetOrCreateValue(TKey)" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.ConditionalWeakTable&lt;TKey,TValue&gt;+CreateValueCallback">
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.ReferenceAssemblyAttribute">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member MemberType="Property" Name="Description" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.TypeForwardedToAttribute">
-      <Member Name="#ctor(System.Type)" />
-      <Member MemberType="Property" Name="Destination" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.TypeForwardedFromAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member MemberType="Property" Name="AssemblyFullName" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.SuppressIldasmAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.ExceptionServices.HandleProcessCorruptedStateExceptionsAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <!-- #if FEATURE_EXCEPTIONDISPATCHINFO -->
-    <Type Status="ApiRoot" Name="System.Runtime.ExceptionServices.ExceptionDispatchInfo">
-      <Member Status="ApiRoot" Name="Capture(System.Exception)" />
-      <Member Status="ApiRoot" Name="Throw" />
-      <Member Name="get_SourceException" />
-      <Member MemberType="Property" Name="SourceException" />
-    </Type>
-    <!-- #endif FEATURE_EXCEPTIONDISPATCHINFO -->
-    <Type Name="System.Runtime.ExceptionServices.FirstChanceExceptionEventArgs">
-      <Member Name="#ctor(System.Exception)" />
-      <Member Name="get_Exception" />
-      <Member MemberType="Property" Name="Exception" />
-    </Type>
-    <Type Name="System.Runtime.GCLatencyMode">
-      <Member MemberType="Field" Name="Batch" />
-      <Member MemberType="Field" Name="Interactive" />
-      <Member MemberType="Field" Name="LowLatency" />
-      <Member MemberType="Field" Name="NoGCRegion" />
-      <Member MemberType="Field" Name="SustainedLowLatency" />
-    </Type>
-    <Type Name="System.Runtime.GCSettings">
-      <Member Name="get_IsServerGC" />
-      <Member Name="get_LargeObjectHeapCompactionMode" />
-      <Member Name="set_LargeObjectHeapCompactionMode(System.Runtime.GCLargeObjectHeapCompactionMode)" />
-      <Member Name="get_LatencyMode" />
-      <Member Name="set_LatencyMode(System.Runtime.GCLatencyMode)" />
-      <Member MemberType="Property" Name="IsServerGC" />
-      <Member MemberType="Property" Name="LargeObjectHeapCompactionMode" />
-      <Member MemberType="Property" Name="LatencyMode" />
-    </Type>
-    <Type Name="System.Runtime.GCLargeObjectHeapCompactionMode">
-      <Member MemberType="Field" Name="Default" />
-      <Member MemberType="Field" Name="CompactOnce" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.BStrWrapper">
-      <Member Name="#ctor(System.Object)" />
-      <Member Name="#ctor(System.String)" />
-      <Member MemberType="Property" Name="WrappedObject" />
-      <Member Name="get_WrappedObject" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.CurrencyWrapper">
-      <Member Name="#ctor(System.Decimal)" />
-      <Member Name="#ctor(System.Object)" />
-      <Member Name="get_WrappedObject" />
-      <Member MemberType="Property" Name="WrappedObject" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.DispatchWrapper">
-      <Member Name="#ctor(System.Object)" />
-      <Member Name="get_WrappedObject" />
-      <Member MemberType="Property" Name="WrappedObject" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.UnknownWrapper">
-      <Member Name="#ctor(System.Object)" />
-      <Member MemberType="Property" Name="WrappedObject" />
-      <Member Name="get_WrappedObject" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.VariantWrapper">
-      <Member Name="#ctor(System.Object)" />
-      <Member MemberType="Property" Name="WrappedObject" />
-      <Member Name="get_WrappedObject" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ErrorWrapper">
-      <Member Name="#ctor(System.Exception)" />
-      <Member Name="#ctor(System.Int32)" />
-      <Member Name="#ctor(System.Object)" />
-      <Member MemberType="Property" Name="ErrorCode" />
-      <Member Name="get_ErrorCode" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.CallingConvention">
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="Winapi" />
-      <Member MemberType="Field" Name="Cdecl" />
-      <Member MemberType="Field" Name="StdCall" />
-      <Member MemberType="Field" Name="ThisCall" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.CharSet">
-      <Member MemberType="Field" Name="Ansi" />
-      <Member MemberType="Field" Name="Auto" />
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="Unicode" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ClassInterfaceAttribute"> <!-- for VB -->
-      <Member Name="#ctor(System.Int16)" />
-      <Member Name="#ctor(System.Runtime.InteropServices.ClassInterfaceType)" />
-      <Member MemberType="Property" Name="Value" />
-      <Member Name="get_Value" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ClassInterfaceType"> <!-- for VB -->
-      <Member MemberType="Field" Name="AutoDispatch" />
-      <Member MemberType="Field" Name="AutoDual" />
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.CoClassAttribute"> <!-- MC++ compiler asserts for no particularly good reason if this type is not public -->
-      <Member Name="#ctor(System.Type)" />
-      <Member MemberType="Property" Name="CoClass" />
-      <Member Name="get_CoClass" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComDefaultInterfaceAttribute">
-      <Member Name="#ctor(System.Type)" />
-      <Member MemberType="Property" Name="Value" />
-      <Member Name="get_Value" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.COMException">
-      <Member Name="#ctor(System.String,System.Int32)" />
-      <Member Name="ToString" />
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComImportAttribute"> <!-- MC++ compiler asserts for no particularly good reason if this type is not public -->
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComInterfaceType">
-      <Member MemberType="Field" Name="InterfaceIsDual" />
-      <Member MemberType="Field" Name="InterfaceIsIUnknown" />
-      <Member MemberType="Field" Name="InterfaceIsIDispatch" />
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="InterfaceIsIInspectable" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.FILETIME">
-      <Member MemberType="Field" Name="dwHighDateTime" />
-      <Member MemberType="Field" Name="dwLowDateTime" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.STATSTG">
-      <Member MemberType="Field" Name="atime" />
-      <Member MemberType="Field" Name="cbSize" />
-      <Member MemberType="Field" Name="clsid" />
-      <Member MemberType="Field" Name="ctime" />
-      <Member MemberType="Field" Name="grfLocksSupported" />
-      <Member MemberType="Field" Name="grfMode" />
-      <Member MemberType="Field" Name="grfStateBits" />
-      <Member MemberType="Field" Name="mtime" />
-      <Member MemberType="Field" Name="pwcsName" />
-      <Member MemberType="Field" Name="reserved" />
-      <Member MemberType="Field" Name="type" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.IStream">
-      <Member Name="Read(System.Byte[],System.Int32,System.IntPtr)" />
-      <Member Name="Write(System.Byte[],System.Int32,System.IntPtr)" />
-      <Member Name="Seek(System.Int64,System.Int32,System.IntPtr)" />
-      <Member Name="SetSize(System.Int64)" />
-      <Member Name="CopyTo(System.Runtime.InteropServices.ComTypes.IStream,System.Int64,System.IntPtr,System.IntPtr)" />
-      <Member Name="Commit(System.Int32)" />
-      <Member Name="Revert" />
-      <Member Name="LockRegion(System.Int64,System.Int64,System.Int32)" />
-      <Member Name="UnlockRegion(System.Int64,System.Int64,System.Int32)" />
-      <Member Name="Stat(System.Runtime.InteropServices.ComTypes.STATSTG@,System.Int32)" />
-      <Member Name="Clone(System.Runtime.InteropServices.ComTypes.IStream@)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.DefaultCharSetAttribute"> <!-- MC++ compiler asserts for no particularly good reason if this type is not public -->
-      <Member Name="#ctor(System.Runtime.InteropServices.CharSet)" />
-      <Member MemberType="Property" Name="CharSet" />
-      <Member Name="get_CharSet" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.DispIdAttribute">
-      <Member Name="#ctor(System.Int32)" />
-      <Member MemberType="Property" Name="Value" />
-      <Member Name="get_Value" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.DllImportAttribute">
-      <Member MemberType="Field" Name="CallingConvention" />
-      <Member MemberType="Field" Name="CharSet" />
-      <Member MemberType="Field" Name="EntryPoint" />
-      <Member MemberType="Field" Name="PreserveSig" />
-      <Member MemberType="Field" Name="SetLastError" />
-      <Member MemberType="Field" Name="BestFitMapping" />       <!-- forced by desktop implementation -->
-      <Member MemberType="Field" Name="ExactSpelling" />        <!-- forced by desktop implementation -->
-      <!-- <Member MemberType="Field" Name="ThrowOnUnmappableChar" /><!- - forced by desktop implementation -->
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_Value" />
-      <Member MemberType="Property" Name="Value" />
-      <Member MemberType="Field" Name="ThrowOnUnmappableChar" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.AllowReversePInvokeCallsAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.AutomationProxyAttribute">
-      <Member Name="#ctor(System.Boolean)" />
-      <Member Name="get_Value" />
-      <Member MemberType="Property" Name="Value" />      
-    </Type>
-   <Type Name="System.Runtime.InteropServices.ComAliasNameAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_Value" />
-      <Member MemberType="Property" Name="Value" />      
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComCompatibleVersionAttribute">
-      <Member Name="#ctor(System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="get_MajorVersion" />
-      <Member MemberType="Property" Name="MajorVersion" />      
-      <Member Name="get_MinorVersion" />
-      <Member MemberType="Property" Name="MinorVersion" />      
-      <Member Name="get_BuildNumber" />
-      <Member MemberType="Property" Name="BuildNumber" />      
-      <Member Name="get_RevisionNumber" />
-      <Member MemberType="Property" Name="RevisionNumber" />      
-    </Type>    
-    <Type Name="System.Runtime.InteropServices.ComConversionLossAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComRegisterFunctionAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComUnregisterFunctionAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ExternalException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.String,System.Int32)" />
-      <Member Name="get_ErrorCode" />
-      <Member MemberType="Property" Name="ErrorCode" />
-      <Member Name="ToString" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.FieldOffsetAttribute">
-      <Member Name="#ctor(System.Int32)" />
-      <Member Name="get_Value" />
-      <Member MemberType="Property" Name="Value" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.GCHandle">
-      <Member Name="AddrOfPinnedObject" />
-      <Member Name="Alloc(System.Object)" />
-      <Member Name="Alloc(System.Object,System.Runtime.InteropServices.GCHandleType)" />
-      <Member Name="Free" />
-      <Member Name="FromIntPtr(System.IntPtr)" />
-      <Member Name="get_IsAllocated" />
-      <Member Name="get_Target" />
-      <Member Name="op_Explicit(System.IntPtr)" ReturnType="System.Runtime.InteropServices.GCHandle" />
-      <Member Name="op_Explicit(System.Runtime.InteropServices.GCHandle)" ReturnType="System.IntPtr" />
-      <Member Name="set_Target(System.Object)" />
-      <Member Name="ToIntPtr(System.Runtime.InteropServices.GCHandle)" />
-      <Member MemberType="Property" Name="IsAllocated" />
-      <Member MemberType="Property" Name="Target" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetHashCode" />
-      <Member Name="op_Equality(System.Runtime.InteropServices.GCHandle,System.Runtime.InteropServices.GCHandle)" />
-      <Member Name="op_Inequality(System.Runtime.InteropServices.GCHandle,System.Runtime.InteropServices.GCHandle)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.GCHandleType">
-      <Member MemberType="Field" Name="Normal" />
-      <Member MemberType="Field" Name="Pinned" />
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="Weak" />
-      <Member MemberType="Field" Name="WeakTrackResurrection" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.GuidAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member MemberType="Property" Name="Value" />
-      <Member Name="get_Value" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.HandleRef">
-      <Member Name="#ctor(System.Object,System.IntPtr)"/>
-      <Member MemberType="Property" Name="Handle"/>
-      <Member Name="get_Handle"/>
-      <Member MemberType="Property" Name="Wrapper"/>
-      <Member Name="get_Wrapper"/>
-      <Member Name="op_Explicit(System.Runtime.InteropServices.HandleRef)" ReturnType="System.IntPtr" />
-      <Member Name="ToIntPtr(System.Runtime.InteropServices.HandleRef)"/>
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ICustomQueryInterface">
-      <Member Name="GetInterface(System.Guid@,System.IntPtr@)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ICustomFactory">
-      <Member Name="CreateInstance(System.Type)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ImportedFromTypeLibAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_Value" />
-      <Member MemberType="Property" Name="Value" />      
-    </Type>    
-    <Type Name="System.Runtime.InteropServices.InAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.InterfaceTypeAttribute">
-      <Member Name="#ctor(System.Runtime.InteropServices.ComInterfaceType)" />
-      <Member Name="#ctor(System.Int16)" />
-      <Member Name="get_Value" />
-      <Member MemberType="Property" Name="Value" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.InvalidComObjectException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.SafeArrayRankMismatchException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.SafeArrayTypeMismatchException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.LayoutKind">
-      <Member MemberType="Field" Name="Auto" />
-      <Member MemberType="Field" Name="Explicit" />
-      <Member MemberType="Field" Name="Sequential" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.LCIDConversionAttribute">
-      <Member Name="#ctor(System.Int32)" />
-      <Member Name="get_Value" />
-      <Member MemberType="Property" Name="Value" />      
-    </Type>
-    <Type Name="System.Runtime.InteropServices.Marshal">
-      <Member MemberType="Field" Name="SystemDefaultCharSize" />
-      <Member Name="AddRef(System.IntPtr)" />
-      <Member Name="AllocHGlobal(System.Int32)" />
-      <Member Name="AllocCoTaskMem(System.Int32)" />
-      <Member Name="BindToMoniker(System.String)" />
-      <Member Name="ChangeWrapperHandleStrength(System.Object,System.Boolean)" />
-      <Member Name="CleanupUnusedObjectsInCurrentContext" />
-      <Member Name="Copy(System.Byte[],System.Int32,System.IntPtr,System.Int32)" />
-      <Member Name="Copy(System.Char[],System.Int32,System.IntPtr,System.Int32)" />
-      <Member Name="Copy(System.Double[],System.Int32,System.IntPtr,System.Int32)" />
-      <Member Name="Copy(System.Int16[],System.Int32,System.IntPtr,System.Int32)" />
-      <Member Name="Copy(System.Int32[],System.Int32,System.IntPtr,System.Int32)" />
-      <Member Name="Copy(System.Int64[],System.Int32,System.IntPtr,System.Int32)" />
-      <Member Name="Copy(System.IntPtr,System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="Copy(System.IntPtr,System.Char[],System.Int32,System.Int32)" />
-      <Member Name="Copy(System.IntPtr,System.Double[],System.Int32,System.Int32)" />
-      <Member Name="Copy(System.IntPtr,System.Int16[],System.Int32,System.Int32)" />
-      <Member Name="Copy(System.IntPtr,System.Int32[],System.Int32,System.Int32)" />
-      <Member Name="Copy(System.IntPtr,System.Int64[],System.Int32,System.Int32)" />
-      <Member Name="Copy(System.IntPtr,System.Single[],System.Int32,System.Int32)" />
-      <Member Name="Copy(System.Single[],System.Int32,System.IntPtr,System.Int32)" />
-      <Member Name="FinalReleaseComObject(System.Object)" />
-      <Member Name="FreeHGlobal(System.IntPtr)" />
-      <Member Name="FreeCoTaskMem(System.IntPtr)" />
-      <Member Name="GenerateGuidForType(System.Type)" />
-      <Member Name="GenerateProgIdForType(System.Type)" />      
-      <Member Name="GetComInterfaceForObject(System.Object,System.Type)" />
-      <Member Name="GetComInterfaceForObject(System.Object,System.Type,System.Runtime.InteropServices.CustomQueryInterfaceMode)" />
-      <Member Name="GetComObjectData(System.Object,System.Object)" />
-      <Member Name="GetDelegateForFunctionPointer(System.IntPtr,System.Type)" />
-      <Member Name="GetExceptionForHR(System.Int32)" />
-      <Member Name="GetExceptionForHR(System.Int32,System.IntPtr)" />
-      <Member Name="GetFunctionPointerForDelegate(System.Delegate)" />
-      <Member Name="GetHRForException(System.Exception)" />
-      <Member Name="GetHINSTANCE(System.Reflection.Module)" />
-      <Member Name="GetIDispatchForObject(System.Object)" />
-      <Member Name="GetIUnknownForObject(System.Object)" />
-      <Member Name="GetLastWin32Error" />
-      <Member Name="GetHRForLastWin32Error" />
-      <Member Name="GetNativeVariantForObject(System.Object,System.IntPtr)" />
-      <Member Name="GetObjectForIUnknown(System.IntPtr)" />
-      <Member Name="GetObjectForNativeVariant(System.IntPtr)" />
-      <Member Name="GetUniqueObjectForIUnknown(System.IntPtr)" />
-      <Member Name="InitializeManagedWinRTFactoryObject(System.Object,System.RuntimeType)" Condition="FEATURE_COMINTEROP" />
-      <Member Name="IsComObject(System.Object)" />
-      <Member Name="OffsetOf(System.Type,System.String)" />
-      <Member Name="Prelink(System.Reflection.MethodInfo)" />
-      <Member Name="PrelinkAll(System.Type)" />
-      <Member Name="PtrToStringAnsi(System.IntPtr)" />
-      <Member Name="PtrToStringAnsi(System.IntPtr,System.Int32)" />
-      <Member Name="PtrToStringAuto(System.IntPtr)" />
-      <Member Name="PtrToStringAuto(System.IntPtr,System.Int32)" />
-      <Member Name="PtrToStringUTF8(System.IntPtr)" />
-      <Member Name="PtrToStringUTF8(System.IntPtr,System.Int32)" />
-      <Member Name="PtrToStringUni(System.IntPtr)" />
-      <Member Name="PtrToStringUni(System.IntPtr,System.Int32)" />
-      <Member Name="PtrToStructure(System.IntPtr,System.Object)" />
-      <Member Name="PtrToStructure(System.IntPtr,System.Type)" />
-      <Member Name="QueryInterface(System.IntPtr,System.Guid@,System.IntPtr@)" />
-      <Member Name="ReadByte(System.IntPtr)" />
-      <Member Name="ReadByte(System.IntPtr,System.Int32)" />
-      <Member Name="ReadInt16(System.IntPtr)" />
-      <Member Name="ReadInt16(System.IntPtr,System.Int32)" />
-      <Member Name="ReadInt32(System.IntPtr)" />
-      <Member Name="ReadInt32(System.IntPtr,System.Int32)" />
-      <Member Name="ReadInt64(System.IntPtr)" />
-      <Member Name="ReadInt64(System.IntPtr,System.Int32)" />
-      <Member Name="ReadIntPtr(System.IntPtr)" />
-      <Member Name="ReadIntPtr(System.IntPtr,System.Int32)" />
-      <Member Name="Release(System.IntPtr)" />
-      <Member Name="ReleaseComObject(System.Object)" />
-      <Member Name="SetComObjectData(System.Object,System.Object,System.Object)" />
-      <Member Name="SetLastWin32Error(System.Int32)" />
-      <Member Name="SizeOf(System.Object)" />
-      <Member Name="SizeOf(System.Type)" />
-      <Member Name="StructureToPtr(System.Object,System.IntPtr,System.Boolean)" />
-      <Member Name="ThrowExceptionForHR(System.Int32)" />
-      <Member Name="ThrowExceptionForHR(System.Int32,System.IntPtr)" />
-      <Member Name="GetTypedObjectForIUnknown(System.IntPtr,System.Type)" />
-      <Member Name="UnsafeAddrOfPinnedArrayElement(System.Array,System.Int32)" />
-      <Member Name="WriteByte(System.IntPtr,System.Byte)" />
-      <Member Name="WriteByte(System.IntPtr,System.Int32,System.Byte)" />
-      <Member Name="WriteInt16(System.IntPtr,System.Char)" />
-      <Member Name="WriteInt16(System.IntPtr,System.Int16)" />
-      <Member Name="WriteInt16(System.IntPtr,System.Int32,System.Char)" />
-      <Member Name="WriteInt16(System.IntPtr,System.Int32,System.Int16)" />
-      <Member Name="WriteInt32(System.IntPtr,System.Int32)" />
-      <Member Name="WriteInt32(System.IntPtr,System.Int32,System.Int32)" />
-      <Member Name="WriteInt64(System.IntPtr,System.Int32,System.Int64)" />
-      <Member Name="WriteInt64(System.IntPtr,System.Int64)" />
-      <Member Name="WriteIntPtr(System.IntPtr,System.Int32,System.IntPtr)" />
-      <Member Name="WriteIntPtr(System.IntPtr,System.IntPtr)" />
-      <Member Name="ZeroFreeCoTaskMemUnicode(System.IntPtr)" />
-      <Member Status="ImplRoot" Name="InitializeWrapperForWinRT(System.Object,System.IntPtr@)" Condition="FEATURE_COMINTEROP" />
-      <Member Status="ImplRoot" Name="LoadLicenseManager" Condition="FEATURE_COMINTEROP" /><Member MemberType="Field" Name="SystemMaxDBCSCharSize" />
-      <Member Name="AllocHGlobal(System.IntPtr)" />
-      <Member Name="AreComObjectsAvailableForCleanup" />
-      <Member Name="Copy(System.IntPtr,System.IntPtr[],System.Int32,System.Int32)" />
-      <Member Name="Copy(System.IntPtr[],System.Int32,System.IntPtr,System.Int32)" />
-      <Member Name="CreateAggregatedObject(System.IntPtr,System.Object)" />
-      <Member Name="CreateAggregatedObject&lt;T&gt;(System.IntPtr,T)" />
-      <Member Name="CreateWrapperOfType(System.Object,System.Type)" />
-      <Member Name="CreateWrapperOfType&lt;T,TWrapper&gt;(T)" />
-      <Member Name="DestroyStructure(System.IntPtr,System.Type)" />
-      <Member Name="DestroyStructure&lt;T&gt;(System.IntPtr)" />
-      <Member Name="FreeBSTR(System.IntPtr)" />
-      <Member Name="GetComInterfaceForObject&lt;T,TInterface&gt;(T)" />
-      <Member Name="GetDelegateForFunctionPointer&lt;TDelegate&gt;(System.IntPtr)" />
-      <Member Name="GetExceptionCode" />
-      <Member Name="GetFunctionPointerForDelegate&lt;TDelegate&gt;(TDelegate)" />
-      <Member Name="GetNativeVariantForObject&lt;T&gt;(T,System.IntPtr)" />
-      <Member Name="GetObjectForNativeVariant&lt;T&gt;(System.IntPtr)" />
-      <Member Name="GetObjectsForNativeVariants(System.IntPtr,System.Int32)" />
-      <Member Name="GetObjectsForNativeVariants&lt;T&gt;(System.IntPtr,System.Int32)" />
-      <Member Name="GetStartComSlot(System.Type)" />
-      <Member Name="GetTypeFromCLSID(System.Guid)" />
-      <Member Name="GetTypeInfoName(System.Runtime.InteropServices.ComTypes.ITypeInfo)" />
-      <Member Name="OffsetOf&lt;T&gt;(System.String)" />
-      <Member Name="PtrToStringBSTR(System.IntPtr)" />
-      <Member Name="PtrToStructure&lt;T&gt;(System.IntPtr)" />
-      <Member Name="PtrToStructure&lt;T&gt;(System.IntPtr,T)" />
-      <Member Name="ReadByte(System.Object,System.Int32)" />
-      <Member Name="ReadInt16(System.Object,System.Int32)" />
-      <Member Name="ReadInt32(System.Object,System.Int32)" />
-      <Member Name="ReadInt64(System.Object,System.Int32)" />
-      <Member Name="ReadIntPtr(System.Object,System.Int32)" />
-      <Member Name="ReAllocCoTaskMem(System.IntPtr,System.Int32)" />
-      <Member Name="ReAllocHGlobal(System.IntPtr,System.IntPtr)" />
-      <Member Name="SizeOf&lt;T&gt;" />
-      <Member Name="SizeOf&lt;T&gt;(T)" />
-      <Member Name="StringToBSTR(System.String)" />
-      <Member Name="StringToCoTaskMemAnsi(System.String)" />
-      <Member Name="StringToCoTaskMemAuto(System.String)" />
-      <Member Name="StringToCoTaskMemUni(System.String)" />
-      <Member Name="StringToHGlobalAnsi(System.String)" />
-      <Member Name="StringToHGlobalAuto(System.String)" />
-      <Member Name="StringToHGlobalUni(System.String)" />
-      <Member Name="StringToCoTaskMemUTF8(System.String)" />
-      <Member Name="StructureToPtr&lt;T&gt;(T,System.IntPtr,System.Boolean)" />
-      <Member Name="UnsafeAddrOfPinnedArrayElement&lt;T&gt;(T[],System.Int32)" />
-      <Member Name="WriteByte(System.Object,System.Int32,System.Byte)" />
-      <Member Name="WriteInt16(System.Object,System.Int32,System.Char)" />
-      <Member Name="WriteInt16(System.Object,System.Int32,System.Int16)" />
-      <Member Name="WriteInt32(System.Object,System.Int32,System.Int32)" />
-      <Member Name="WriteInt64(System.Object,System.Int32,System.Int64)" />
-      <Member Name="WriteIntPtr(System.Object,System.Int32,System.IntPtr)" />
-      <Member Name="ZeroFreeBSTR(System.IntPtr)" />
-      <Member Name="ZeroFreeCoTaskMemAnsi(System.IntPtr)" />
-      <Member Name="ZeroFreeGlobalAllocAnsi(System.IntPtr)" />
-      <Member Name="ZeroFreeGlobalAllocUnicode(System.IntPtr)" />
-      <Member Name="ZeroFreeCoTaskMemUTF8(System.IntPtr)" />
-      <Member Name="SecureStringToCoTaskMemAnsi(System.Security.SecureString)" />
-      <Member Name="SecureStringToCoTaskMemUnicode(System.Security.SecureString)" />
-      <Member Name="SecureStringToGlobalAllocAnsi(System.Security.SecureString)" />
-      <Member Name="SecureStringToGlobalAllocUnicode(System.Security.SecureString)" />
-      <Member Name="SecureStringToBSTR(System.Security.SecureString)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.MarshalAsAttribute">
-      <Member MemberType="Field" Name="ArraySubType" />
-      <Member MemberType="Field" Name="MarshalCookie" />
-      <Member MemberType="Field" Name="MarshalType" />
-      <Member MemberType="Field" Name="MarshalTypeRef" />
-      <Member MemberType="Field" Name="SizeConst" />
-      <Member MemberType="Field" Name="SizeParamIndex" />
-      <Member Name="#ctor(System.Int16)" />
-      <Member Name="#ctor(System.Runtime.InteropServices.UnmanagedType)" />
-      <Member Name="get_Value" />
-      <Member MemberType="Property" Name="Value" />
-      <Member MemberType="Field" Name="IidParameterIndex" />
-      <Member MemberType="Field" Name="SafeArraySubType" />
-      <Member MemberType="Field" Name="SafeArrayUserDefinedSubType" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ManagedToNativeComInteropStubAttribute">
-      <Member Name="#ctor(System.Type,System.String)" />
-      <Member Name="get_ClassType" />
-      <Member MemberType="Property" Name="ClassType" />      
-      <Member Name="get_MethodName" />
-      <Member MemberType="Property" Name="MethodName" />      
-    </Type>       
-    <Type Name="System.Runtime.InteropServices.MarshalDirectiveException" >
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.NativeCallableAttribute">
-      <Member Name="#ctor" />
-      <Member MemberType="Field" Name="CallingConvention" /> <!-- EE -->
-      <Member MemberType="Field" Name="EntryPoint" /> <!-- EE -->
-    </Type>
-    <Type Name="System.Runtime.InteropServices.OptionalAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.OutAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.PreserveSigAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.PrimaryInteropAssemblyAttribute">
-      <Member Name="#ctor(System.Int32,System.Int32)" />
-      <Member Name="get_MajorVersion" />
-      <Member MemberType="Property" Name="MajorVersion" />
-      <Member Name="get_MinorVersion" />
-      <Member MemberType="Property" Name="MinorVersion" />
-    </Type>    
-    <Type Name="System.Runtime.InteropServices.ProgIdAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_Value" />
-      <Member MemberType="Property" Name="Value" />      
-    </Type>
-    <Type Name="System.Runtime.InteropServices.SafeHandle">
-      <Member MemberType="Field" Name="handle" />
-      <Member Name="#ctor(System.IntPtr,System.Boolean)" />
-      <Member Name="#ctor" />
-      <Member Name="Close" />
-      <Member Name="DangerousAddRef(System.Boolean@)" />
-      <Member Name="DangerousGetHandle" />
-      <Member Name="DangerousRelease" />
-      <Member Name="Dispose" />
-      <Member Name="Dispose(System.Boolean)" />
-      <Member Name="Finalize" />
-      <Member Name="get_IsClosed" />
-      <Member Name="get_IsInvalid" />
-      <Member Name="ReleaseHandle" />
-      <Member Name="SetHandle(System.IntPtr)" />
-      <Member Name="SetHandleAsInvalid" />
-      <Member MemberType="Property" Name="IsClosed" />
-      <Member MemberType="Property" Name="IsInvalid" />
-    </Type>
-   <Type Name="System.Runtime.InteropServices.TypeLibImportClassAttribute">
-      <Member Name="#ctor(System.Type)" />
-      <Member Name="get_Value" />
-      <Member MemberType="Property" Name="Value" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.TypeLibVersionAttribute">
-      <Member Name="#ctor(System.Int32,System.Int32)" />
-      <Member Name="get_MajorVersion" />
-      <Member MemberType="Property" Name="MajorVersion" />
-      <Member Name="get_MinorVersion" />
-      <Member MemberType="Property" Name="MinorVersion" />
-    </Type>       
-    <Type Name="System.Runtime.InteropServices.CriticalHandle">
-      <Member MemberType="Field" Name="handle" />
-      <Member MemberType="Field" Name="_stackTrace" Flavor="chk,dbg" />
-      <Member Name="#ctor(System.IntPtr)" />
-      <Member Name="#ctor" />
-      <Member Name="Close" />
-      <Member Name="Dispose" />
-      <Member Name="Dispose(System.Boolean)" />
-      <Member Name="Finalize" />
-      <Member Name="get_IsClosed" />
-      <Member Name="get_IsInvalid" />
-      <Member Name="ReleaseHandle" />
-      <Member Name="SetHandle(System.IntPtr)" />
-      <Member Name="SetHandleAsInvalid" />
-      <Member MemberType="Property" Name="IsClosed" />
-      <Member MemberType="Property" Name="IsInvalid" />
-    </Type>
-    <Type Name="Microsoft.Win32.SafeHandles.CriticalHandleMinusOneIsInvalid">
-      <Member Name="#ctor" />
-      <Member Name="get_IsInvalid" />
-    </Type>
-    <Type Name="Microsoft.Win32.SafeHandles.CriticalHandleZeroOrMinusOneIsInvalid">
-      <Member Name="#ctor" />
-      <Member Name="get_IsInvalid" />
-    </Type>
-    <Type Name="Microsoft.Win32.SafeHandles.SafeHandleMinusOneIsInvalid">
-      <Member Name="#ctor(System.Boolean)" />
-      <Member Name="get_IsInvalid" />
-    </Type>
-    <Type Name="Microsoft.Win32.SafeHandles.SafeHandleZeroOrMinusOneIsInvalid">
-      <Member Name="#ctor(System.Boolean)" />
-      <Member Name="get_IsInvalid" />
-    </Type>
-    <Type Name="Microsoft.Win32.SafeHandles.SafeFileHandle">
-      <Member Name="#ctor(System.IntPtr,System.Boolean)" />
-    </Type>
-    <Type Name="Microsoft.Win32.SafeHandles.SafeWaitHandle">
-      <Member Name="#ctor(System.IntPtr,System.Boolean)" />
-      <Member Status="ApiRoot" Name="ReleaseHandle" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.SEHException" >
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="CanResume" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.StructLayoutAttribute">
-      <Member MemberType="Field" Name="CharSet" />
-      <Member MemberType="Field" Name="Pack" />
-      <Member MemberType="Field" Name="Size" />
-      <Member Name="#ctor(System.Int16)" />
-      <Member Name="#ctor(System.Runtime.InteropServices.LayoutKind)" />
-      <Member Name="get_Value" />
-      <Member MemberType="Property" Name="Value" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.UnmanagedFunctionPointerAttribute">
-      <Member Name="#ctor(System.Runtime.InteropServices.CallingConvention)" />
-      <Member MemberType="Property" Name="CallingConvention" />
-      <Member Name="get_CallingConvention" />
-      <Member MemberType="Field" Name="BestFitMapping" />
-      <Member MemberType="Field" Name="CharSet" />
-      <Member MemberType="Field" Name="SetLastError" />
-      <Member MemberType="Field" Name="ThrowOnUnmappableChar" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.UnmanagedType">
-      <Member MemberType="Field" Name="AnsiBStr" />
-      <Member MemberType="Field" Name="AsAny" />
-      <Member MemberType="Field" Name="Bool" />
-      <Member MemberType="Field" Name="BStr" />
-      <Member MemberType="Field" Name="ByValArray" />
-      <Member MemberType="Field" Name="ByValTStr" />
-      <Member MemberType="Field" Name="Currency" />
-      <Member MemberType="Field" Name="CustomMarshaler" />
-      <Member MemberType="Field" Name="Error" />
-      <Member MemberType="Field" Name="FunctionPtr" />
-      <Member MemberType="Field" Name="I1" />
-      <Member MemberType="Field" Name="I2" />
-      <Member MemberType="Field" Name="I4" />
-      <Member MemberType="Field" Name="I8" />
-      <Member MemberType="Field" Name="IDispatch" />
-      <Member MemberType="Field" Name="Interface" />
-      <Member MemberType="Field" Name="LPArray" />
-      <Member MemberType="Field" Name="LPStr" />
-      <Member MemberType="Field" Name="LPStruct" />
-      <Member MemberType="Field" Name="LPTStr" />
-      <Member MemberType="Field" Name="LPWStr" />
-      <Member MemberType="Field" Name="LPUTF8Str" />
-      <Member MemberType="Field" Name="R4" />
-      <Member MemberType="Field" Name="R8" />
-      <Member MemberType="Field" Name="SafeArray" />
-      <Member MemberType="Field" Name="Struct" />
-      <Member MemberType="Field" Name="SysInt" />
-      <Member MemberType="Field" Name="SysUInt" />
-      <Member MemberType="Field" Name="TBStr" />
-      <Member MemberType="Field" Name="U1" />
-      <Member MemberType="Field" Name="U2" />
-      <Member MemberType="Field" Name="U4" />
-      <Member MemberType="Field" Name="U8" />
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="VariantBool" />
-      <Member MemberType="Field" Name="VBByRefStr" />
-      <Member MemberType="Field" Name="HString" />
-      <Member MemberType="Field" Name="IInspectable" />
-      <Member MemberType="Field" Name="IUnknown" />
-    </Type>
-    <Type Name="System.RuntimeFieldHandle">
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="Equals(System.RuntimeFieldHandle)" />
-      <Member Name="get_Value" />    
-      <Member Name="op_Equality(System.RuntimeFieldHandle,System.RuntimeFieldHandle)" />
-      <Member Name="op_Inequality(System.RuntimeFieldHandle,System.RuntimeFieldHandle)" />
-      <Member MemberType="Property" Name="Value" />
-    </Type>
-    <Type Name="System.RuntimeMethodHandle">
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="Equals(System.RuntimeMethodHandle)" />
-      <Member Status="ImplRoot" Name="GetValueInternal(System.RuntimeMethodHandle)" />
-      <Member Name="get_Value" />
-      <Member Name="GetFunctionPointer" />
-      <Member MemberType="Property" Name="Value" />
-      <Member Name="op_Equality(System.RuntimeMethodHandle,System.RuntimeMethodHandle)" />
-      <Member Name="op_Inequality(System.RuntimeMethodHandle,System.RuntimeMethodHandle)" />
-    </Type>
-    <Type Name="System.SByte">
-      <Member MemberType="Field" Name="MaxValue" />
-      <Member MemberType="Field" Name="MinValue" />
-      <Member Name="CompareTo(System.Object)" />
-      <Member Name="CompareTo(System.SByte)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.SByte)" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetTypeCode" />
-      <Member Name="Parse(System.String)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)" />
-      <Member Name="Parse(System.String,System.IFormatProvider)" />
-      <Member Name="TryParse(System.String,System.SByte@)" />
-      <Member Name="TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.SByte@)" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.IFormatProvider)" />
-      <Member Name="ToString(System.String)" />
-      <Member Name="ToString(System.String,System.IFormatProvider)" />
-    </Type>
-    <Type Name="System.Security.AllowPartiallyTrustedCallersAttribute">
-      <Member Name="#ctor" />
-      <Member Name="get_PartialTrustVisibilityLevel" />
-      <Member Name="set_PartialTrustVisibilityLevel(System.Security.PartialTrustVisibilityLevel)" />
-      <Member MemberType="Property" Name="PartialTrustVisibilityLevel" />
-    </Type>
-    <Type Name="System.Security.PartialTrustVisibilityLevel">
-      <Member MemberType="Field" Name="NotVisibleByDefault" />
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="VisibleToAllHosts" />
-    </Type>
-    <Type Name="System.Security.SecureString">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Char*,System.Int32)" />
-      <Member Name="get_Length" />
-      <Member MemberType="Property" Name="Length" />
-      <Member Name="AppendChar(System.Char)" />
-      <Member Name="Clear" />
-      <Member Name="Copy" />
-      <Member Name="Dispose" />
-      <Member Name="InsertAt(System.Int32,System.Char)" />
-      <Member Name="IsReadOnly" />
-      <Member Name="MakeReadOnly" />
-      <Member Name="RemoveAt(System.Int32)" />
-      <Member Name="SetAt(System.Int32,System.Char)" />
-    </Type>
-   <Type Name="System.Security.SecurityCriticalAttribute">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Security.SecurityCriticalScope)" />
-      <Member Name="get_Scope" />
-      <Member MemberType="Property" Name="Scope" />
-    </Type>
-    <Type Name="System.Security.SecurityCriticalScope">
-      <Member MemberType="Field" Name="Everything" />
-      <Member MemberType="Field" Name="Explicit" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Security.SecurityException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.String,System.Type)" />
-      <Member Name="#ctor(System.String,System.Type,System.String)" />
-      <Member Name="get_Demanded" />
-      <Member Name="get_DenySetInstance" />
-      <Member Name="get_FailedAssemblyInfo" />
-      <Member Name="get_GrantedSet" />
-      <Member Name="get_Method" />
-      <Member Name="get_PermissionState" />
-      <Member Name="get_PermissionType" />
-      <Member Name="get_PermitOnlySetInstance" />
-      <Member Name="get_RefusedSet" />
-      <Member Name="get_Url" />
-      <Member Name="GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="set_Demanded(System.Object)" />
-      <Member Name="set_DenySetInstance(System.Object)" />
-      <Member Name="set_FailedAssemblyInfo(System.Reflection.AssemblyName)" />
-      <Member Name="set_GrantedSet(System.String)" />
-      <Member Name="set_Method(System.Reflection.MethodInfo)" />
-      <Member Name="set_PermissionState(System.String)" />
-      <Member Name="set_PermissionType(System.Type)" />
-      <Member Name="set_PermitOnlySetInstance(System.Object)" />
-      <Member Name="set_RefusedSet(System.String)" />
-      <Member Name="set_Url(System.String)" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="Demanded" />
-      <Member MemberType="Property" Name="DenySetInstance" />
-      <Member MemberType="Property" Name="FailedAssemblyInfo" />
-      <Member MemberType="Property" Name="GrantedSet" />
-      <Member MemberType="Property" Name="Method" />
-      <Member MemberType="Property" Name="PermissionState" />
-      <Member MemberType="Property" Name="PermissionType" />
-      <Member MemberType="Property" Name="PermitOnlySetInstance" />
-      <Member MemberType="Property" Name="RefusedSet" />
-      <Member MemberType="Property" Name="Url" />
-    </Type>
-    <Type Name="System.Security.SecurityState">
-      <Member Name="#ctor" />
-      <Member Name="IsStateAvailable" />
-      <Member Name="EnsureState" />
-   </Type>
-    <Type Name="System.SerializableAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Single">
-      <Member MemberType="Field" Name="Epsilon" />
-      <Member MemberType="Field" Name="MaxValue" />
-      <Member MemberType="Field" Name="MinValue" />
-      <Member MemberType="Field" Name="NaN" />
-      <Member MemberType="Field" Name="NegativeInfinity" />
-      <Member MemberType="Field" Name="PositiveInfinity" />
-      <Member Name="CompareTo(System.Object)" />
-      <Member Name="CompareTo(System.Single)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.Single)" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetTypeCode" />
-      <Member Name="IsInfinity(System.Single)" />
-      <Member Name="IsNaN(System.Single)" />
-      <Member Name="IsNegativeInfinity(System.Single)" />
-      <Member Name="IsPositiveInfinity(System.Single)" />
-      <Member Name="op_Equality(System.Single,System.Single)" />
-      <Member Name="op_GreaterThan(System.Single,System.Single)" />
-      <Member Name="op_GreaterThanOrEqual(System.Single,System.Single)" />
-      <Member Name="op_Inequality(System.Single,System.Single)" />
-      <Member Name="op_LessThan(System.Single,System.Single)" />
-      <Member Name="op_LessThanOrEqual(System.Single,System.Single)" />
-      <Member Name="Parse(System.String)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)" />
-      <Member Name="Parse(System.String,System.IFormatProvider)" />
-      <Member Name="TryParse(System.String,System.Single@)" />
-      <Member Name="TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.Single@)" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.IFormatProvider)" />
-      <Member Name="ToString(System.String)" />
-      <Member Name="ToString(System.String,System.IFormatProvider)" />
-    </Type>
-    <Type Name="System.StackOverflowException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.STAThreadAttribute">
-        <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.String">
-      <Member Status="ImplRoot" MemberType="Field" Name="m_stringLength" />
-      <Member MemberType="Field" Name="Empty" />
-      <Member Name="#ctor(System.Char*)" />
-      <Member Name="#ctor(System.Char*,System.Int32,System.Int32)" />
-      <Member Name="#ctor(System.Char,System.Int32)" />
-      <Member Name="#ctor(System.Char[])" />
-      <Member Name="#ctor(System.Char[],System.Int32,System.Int32)" />
-      <Member Name="#ctor(System.SByte*)" />
-      <Member Name="#ctor(System.SByte*,System.Int32,System.Int32)" />
-      <Member Name="#ctor(System.SByte*,System.Int32,System.Int32,System.Text.Encoding)" />
-      <Member Name="Clone" />
-      <Member Name="Compare(System.String,System.Int32,System.String,System.Int32,System.Int32)" />
-      <Member Name="Compare(System.String,System.Int32,System.String,System.Int32,System.Int32,System.Boolean)" />
-      <Member Name="Compare(System.String,System.Int32,System.String,System.Int32,System.Int32,System.Boolean,System.Globalization.CultureInfo)" />
-      <Member Name="Compare(System.String,System.Int32,System.String,System.Int32,System.Int32,System.Globalization.CultureInfo,System.Globalization.CompareOptions)" />
-      <Member Name="Compare(System.String,System.Int32,System.String,System.Int32,System.Int32,System.StringComparison)" />
-      <Member Name="Compare(System.String,System.String)" />
-      <Member Name="Compare(System.String,System.String,System.Boolean)" />
-      <Member Name="Compare(System.String,System.String,System.Boolean,System.Globalization.CultureInfo)" />
-      <Member Name="Compare(System.String,System.String,System.Globalization.CultureInfo,System.Globalization.CompareOptions)" />
-      <Member Name="Compare(System.String,System.String,System.StringComparison)" />
-      <Member Name="CompareOrdinal(System.String,System.Int32,System.String,System.Int32,System.Int32)" />
-      <Member Name="CompareOrdinal(System.String,System.String)" />
-      <Member Name="CompareTo(System.Object)" />
-      <Member Name="CompareTo(System.String)" />
-      <Member Name="Concat(System.Collections.Generic.IEnumerable&lt;System.String&gt;)" />
-      <Member Name="Concat(System.Object)" />
-      <Member Name="Concat(System.Object,System.Object)" />
-      <Member Name="Concat(System.Object,System.Object,System.Object)" />
-      <Member Name="Concat(System.Object[])" />
-      <Member Name="Concat(System.String,System.String)" />
-      <Member Name="Concat(System.String,System.String,System.String)" />
-      <Member Name="Concat(System.String,System.String,System.String,System.String)" />
-      <Member Name="Concat(System.String[])" />
-      <Member Name="Concat&lt;T&gt;(System.Collections.Generic.IEnumerable&lt;T&gt;)" />
-      <Member Name="Contains(System.String)" />
-      <Member Name="Copy(System.String)" />
-      <Member Name="CopyTo(System.Int32,System.Char[],System.Int32,System.Int32)" />
-      <Member Name="EndsWith(System.String)" />
-      <Member Name="EndsWith(System.String,System.Boolean,System.Globalization.CultureInfo)" />
-      <Member Name="EndsWith(System.String,System.StringComparison)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.String)" />
-      <Member Name="Equals(System.String,System.String)" />
-      <Member Name="Equals(System.String,System.String,System.StringComparison)" />
-      <Member Name="Equals(System.String,System.StringComparison)" />
-      <Member Name="Format(System.IFormatProvider,System.String,System.Object)" />
-      <Member Name="Format(System.IFormatProvider,System.String,System.Object,System.Object)" />
-      <Member Name="Format(System.IFormatProvider,System.String,System.Object,System.Object,System.Object)" />
-      <Member Name="Format(System.IFormatProvider,System.String,System.Object[])" />
-      <Member Name="Format(System.String,System.Object)" />
-      <Member Name="Format(System.String,System.Object,System.Object)" />
-      <Member Name="Format(System.String,System.Object,System.Object,System.Object)" />
-      <Member Name="Format(System.String,System.Object[])" />
-      <Member Name="get_Chars(System.Int32)" />
-      <Member Name="get_Length" />
-      <Member Name="GetEnumerator" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetHashCode(System.StringComparison)" />
-      <Member Name="GetTypeCode" />
-      <Member Name="IndexOf(System.Char)" />
-      <Member Name="IndexOf(System.Char,System.Int32)" />
-      <Member Name="IndexOf(System.Char,System.Int32,System.Int32)" />
-      <Member Name="IndexOf(System.String)" />
-      <Member Name="IndexOf(System.String,System.Int32)" />
-      <Member Name="IndexOf(System.String,System.Int32,System.Int32)" />
-      <Member Name="IndexOf(System.String,System.Int32,System.Int32,System.StringComparison)" />
-      <Member Name="IndexOf(System.String,System.Int32,System.StringComparison)" />
-      <Member Name="IndexOf(System.String,System.StringComparison)" />
-      <Member Name="IndexOfAny(System.Char[])" />
-      <Member Name="IndexOfAny(System.Char[],System.Int32)" />
-      <Member Name="IndexOfAny(System.Char[],System.Int32,System.Int32)" />
-      <Member Name="Insert(System.Int32,System.String)" />
-      <Member Name="Intern(System.String)" />
-      <Member Name="IsInterned(System.String)" />
-      <Member Name="IsNormalized" />
-      <Member Name="IsNormalized(System.Text.NormalizationForm)" />
-      <Member Name="IsNullOrEmpty(System.String)" />
-      <Member Name="IsNullOrWhiteSpace(System.String)" />
-      <Member Name="Join(System.Char,System.Object[])" />
-      <Member Name="Join&lt;T&gt;(System.Char,System.Collections.Generic.IEnumerable&lt;T&gt;)" />
-      <Member Name="Join(System.Char,System.String[])" />
-      <Member Name="Join(System.Char,System.String[],System.Int32,System.Int32)" />
-      <Member Name="Join(System.String,System.Object[])" />
-      <Member Name="Join&lt;T&gt;(System.String,System.Collections.Generic.IEnumerable&lt;T&gt;)" />
-      <Member Name="Join(System.String,System.Collections.Generic.IEnumerable&lt;System.String&gt;)" />
-      <Member Name="Join(System.String,System.String[])" />
-      <Member Name="Join(System.String,System.String[],System.Int32,System.Int32)" />
-      <Member Name="LastIndexOf(System.Char)" />
-      <Member Name="LastIndexOf(System.Char,System.Int32)" />
-      <Member Name="LastIndexOf(System.Char,System.Int32,System.Int32)" />
-      <Member Name="LastIndexOf(System.String)" />
-      <Member Name="LastIndexOf(System.String,System.Int32)" />
-      <Member Name="LastIndexOf(System.String,System.Int32,System.Int32)" />
-      <Member Name="LastIndexOf(System.String,System.Int32,System.Int32,System.StringComparison)" />
-      <Member Name="LastIndexOf(System.String,System.Int32,System.StringComparison)" />
-      <Member Name="LastIndexOf(System.String,System.StringComparison)" />
-      <Member Name="LastIndexOfAny(System.Char[])" />
-      <Member Name="LastIndexOfAny(System.Char[],System.Int32)" />
-      <Member Name="LastIndexOfAny(System.Char[],System.Int32,System.Int32)" />
-      <Member Name="Normalize" />
-      <Member Name="Normalize(System.Text.NormalizationForm)" />
-      <Member Name="op_Equality(System.String,System.String)" />
-      <Member Name="op_Inequality(System.String,System.String)" />
-      <Member Name="PadLeft(System.Int32)" />
-      <Member Name="PadLeft(System.Int32,System.Char)" />
-      <Member Name="PadRight(System.Int32)" />
-      <Member Name="PadRight(System.Int32,System.Char)" />
-      <Member Name="Remove(System.Int32)" />
-      <Member Name="Remove(System.Int32,System.Int32)" />
-      <Member Name="Replace(System.Char,System.Char)" />
-      <Member Name="Replace(System.String,System.String)" />
-      <Member Name="Split(System.Char,System.Int32,System.StringSplitOptions)" />
-      <Member Name="Split(System.Char,System.StringSplitOptions)"/>
-      <Member Name="Split(System.Char[])" />
-      <Member Name="Split(System.Char[],System.Int32)" />
-      <Member Name="Split(System.Char[],System.Int32,System.StringSplitOptions)" />
-      <Member Name="Split(System.Char[],System.StringSplitOptions)"/>
-      <Member Name="Split(System.String,System.Int32,System.StringSplitOptions)" />
-      <Member Name="Split(System.String,System.StringSplitOptions)"/>
-      <Member Name="Split(System.String[],System.Int32,System.StringSplitOptions)" />
-      <Member Name="Split(System.String[],System.StringSplitOptions)"/>
-      <Member Name="StartsWith(System.String)" />
-      <Member Name="StartsWith(System.String,System.Boolean,System.Globalization.CultureInfo)" />
-      <Member Name="StartsWith(System.String,System.StringComparison)" />
-      <Member Name="Substring(System.Int32)" />
-      <Member Name="Substring(System.Int32,System.Int32)" />
-      <Member Name="ToCharArray" />
-      <Member Name="ToCharArray(System.Int32,System.Int32)" />
-      <Member Name="ToLower" />
-      <Member Name="ToLower(System.Globalization.CultureInfo)" />
-      <Member Name="ToLowerInvariant" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.IFormatProvider)" />
-      <Member Name="ToUpper" />
-      <Member Name="ToUpper(System.Globalization.CultureInfo)" />
-      <Member Name="ToUpperInvariant" />
-      <Member Name="Trim" />
-      <Member Name="Trim(System.Char)" />
-      <Member Name="Trim(System.Char[])" />
-      <Member Name="TrimEnd(System.Char)" />
-      <Member Name="TrimEnd(System.Char[])" />
-      <Member Name="TrimEnd" />
-      <Member Name="TrimStart(System.Char)" />
-      <Member Name="TrimStart(System.Char[])" />
-      <Member Name="TrimStart" />
-      <Member MemberType="Property" Name="Chars(System.Int32)" />
-      <Member MemberType="Property" Name="Length" />
-      <Member Status="ImplRoot" Name="System.Collections.IEnumerable.GetEnumerator" />
-      <Member Status="ImplRoot" Name="System.Collections.Generic.IEnumerable&lt;System.Char&gt;.GetEnumerator" />
-      <Member Status="ImplRoot" Name="CtorCharArray(System.Char[])" />
-      <Member Status="ImplRoot" Name="CtorCharArrayStartLength(System.Char[],System.Int32,System.Int32)" />
-      <Member Status="ImplRoot" Name="CtorCharCount(System.Char,System.Int32)" />
-      <Member Status="ImplRoot" Name="CtorCharPtr(System.Char*)" />
-      <Member Status="ImplRoot" Name="CtorCharPtrStartLength(System.Char*,System.Int32,System.Int32)" />
-      <Member Status="ImplRoot" Name="CreateString(System.SByte*,System.Int32,System.Int32,System.Text.Encoding)" /> <!-- EE -->
-      <Member Status="ImplRoot" Name="InternalCopy(System.String,System.IntPtr,System.Int32)" /> <!-- EE -->
-    </Type>
-    <Type Name="System.Collections.StructuralComparisons">
-      <Member Name="get_StructuralComparer" />
-      <Member Name="get_StructuralEqualityComparer" />
-      <Member MemberType="Property" Name="StructuralComparer" />
-      <Member MemberType="Property" Name="StructuralEqualityComparer" />
-    </Type>   
-    <Type Name="System.StringComparer">
-      <Member Name="#ctor" />
-      <Member Name="Compare(System.Object,System.Object)" />
-      <Member Name="Compare(System.String,System.String)" />
-      <Member Name="Create(System.Globalization.CultureInfo,System.Boolean)" />
-      <Member Name="Equals(System.Object,System.Object)" />
-      <Member Name="Equals(System.String,System.String)" />
-      <Member Name="FromComparison(System.StringComparison)" />
-      <Member Name="get_CurrentCulture" />
-      <Member Name="get_CurrentCultureIgnoreCase" />
-      <Member Name="get_InvariantCulture" />
-      <Member Name="get_InvariantCultureIgnoreCase" />
-      <Member Name="get_Ordinal" />
-      <Member Name="get_OrdinalIgnoreCase" />
-      <Member Name="GetHashCode(System.Object)" />
-      <Member Name="GetHashCode(System.String)" />
-      <Member MemberType="Property" Name="CurrentCulture" />
-      <Member MemberType="Property" Name="CurrentCultureIgnoreCase" />
-      <Member MemberType="Property" Name="InvariantCulture" />
-      <Member MemberType="Property" Name="InvariantCultureIgnoreCase" />
-      <Member MemberType="Property" Name="Ordinal" />
-      <Member MemberType="Property" Name="OrdinalIgnoreCase" />
-    </Type>
-    <Type Name="System.StringComparison">
-      <Member MemberType="Field" Name="CurrentCulture" />
-      <Member MemberType="Field" Name="CurrentCultureIgnoreCase" />
-      <Member MemberType="Field" Name="InvariantCulture" />
-      <Member MemberType="Field" Name="InvariantCultureIgnoreCase" />
-      <Member MemberType="Field" Name="Ordinal" />
-      <Member MemberType="Field" Name="OrdinalIgnoreCase" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.SystemException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Text.ASCIIEncoding">
-      <Member Name="#ctor" />
-      <Member Name="get_IsSingleByte" />
-      <Member Name="GetByteCount(System.Char*,System.Int32)" />
-      <Member Name="GetByteCount(System.Char[],System.Int32,System.Int32)" />
-      <Member Name="GetByteCount(System.String)" />
-      <Member Name="GetBytes(System.Char*,System.Int32,System.Byte*,System.Int32)" />
-      <Member Name="GetBytes(System.Char[],System.Int32,System.Int32,System.Byte[],System.Int32)" />
-      <Member Name="GetBytes(System.String,System.Int32,System.Int32,System.Byte[],System.Int32)" />
-      <Member Name="GetCharCount(System.Byte*,System.Int32)" />
-      <Member Name="GetCharCount(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="GetChars(System.Byte*,System.Int32,System.Char*,System.Int32)" />
-      <Member Name="GetChars(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32)" />
-      <Member Name="GetDecoder" />
-      <Member Name="GetEncoder" />
-      <Member Name="GetMaxByteCount(System.Int32)" />
-      <Member Name="GetMaxCharCount(System.Int32)" />
-      <Member Name="GetString(System.Byte[],System.Int32,System.Int32)" />
-      <Member MemberType="Property" Name="IsSingleByte" />
-    </Type>
-    <Type Name="System.Text.Decoder">
-      <Member Name="#ctor" />
-      <Member Name="Convert(System.Byte*,System.Int32,System.Char*,System.Int32,System.Boolean,System.Int32@,System.Int32@,System.Boolean@)" />
-      <Member Name="Convert(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32,System.Int32,System.Boolean,System.Int32@,System.Int32@,System.Boolean@)" />
-      <Member Name="get_Fallback" />
-      <Member Name="get_FallbackBuffer" />
-      <Member Name="GetCharCount(System.Byte*,System.Int32,System.Boolean)" />
-      <Member Name="GetCharCount(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="GetCharCount(System.Byte[],System.Int32,System.Int32,System.Boolean)" />
-      <Member Name="GetChars(System.Byte*,System.Int32,System.Char*,System.Int32,System.Boolean)" />
-      <Member Name="GetChars(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32)" />
-      <Member Name="GetChars(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32,System.Boolean)" />
-      <Member Name="Reset" />
-      <Member Name="set_Fallback(System.Text.DecoderFallback)" />
-      <Member MemberType="Property" Name="Fallback" />
-      <Member MemberType="Property" Name="FallbackBuffer" />
-    </Type>
-    <Type Name="System.Text.DecoderExceptionFallbackBuffer">
-      <Member Name="#ctor" />
-      <Member Name="Fallback(System.Byte[],System.Int32)" />
-      <Member Name="get_Remaining" />
-      <Member Name="GetNextChar" />
-      <Member Name="MovePrevious" />
-      <Member MemberType="Property" Name="Remaining" />
-    </Type>
-    <Type Name="System.Text.DecoderFallback">
-      <Member Name="#ctor" />
-      <Member Name="CreateFallbackBuffer" />
-      <Member Name="get_MaxCharCount" />
-      <Member Name="get_ReplacementFallback" />
-      <Member MemberType="Property" Name="MaxCharCount" />
-      <Member MemberType="Property" Name="ReplacementFallback" />
-      <Member Name="get_ExceptionFallback" />
-      <Member MemberType="Property" Name="ExceptionFallback" />
-    </Type>
-    <Type Name="System.Text.DecoderFallbackBuffer">
-      <Member Name="#ctor" />
-      <Member Name="Fallback(System.Byte[],System.Int32)" />
-      <Member Name="get_Remaining" />
-      <Member Name="GetNextChar" />
-      <Member Name="MovePrevious" />
-      <Member Name="Reset" />
-      <Member MemberType="Property" Name="Remaining" />
-    </Type>
-    <Type Name="System.Text.DecoderReplacementFallback">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="CreateFallbackBuffer" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_DefaultString" />
-      <Member Name="get_MaxCharCount" />
-      <Member Name="GetHashCode" />
-      <Member MemberType="Property" Name="DefaultString" />
-      <Member MemberType="Property" Name="MaxCharCount" />
-    </Type>
-    <Type Name="System.Text.DecoderReplacementFallbackBuffer">
-      <Member Name="#ctor(System.Text.DecoderReplacementFallback)" />
-      <Member Name="Fallback(System.Byte[],System.Int32)" />
-      <Member Name="get_Remaining" />
-      <Member Name="GetNextChar" />
-      <Member Name="MovePrevious" />
-      <Member Name="Reset" />
-      <Member MemberType="Property" Name="Remaining" />
-    </Type>
-    <Type Name="System.Text.DecoderExceptionFallback">
-      <Member Name="#ctor" />
-      <Member Name="CreateFallbackBuffer" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_MaxCharCount" />
-      <Member Name="GetHashCode" />
-      <Member MemberType="Property" Name="MaxCharCount" />
-    </Type>
-    <Type Name="System.Text.DecoderFallbackException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.String,System.Byte[],System.Int32)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="get_BytesUnknown" />
-      <Member Name="get_Index" />
-      <Member MemberType="Property" Name="BytesUnknown" />
-      <Member MemberType="Property" Name="Index" />
-    </Type>
-    <Type Name="System.Text.Encoder">
-      <Member Name="#ctor" />
-      <Member Name="Convert(System.Char*,System.Int32,System.Byte*,System.Int32,System.Boolean,System.Int32@,System.Int32@,System.Boolean@)" />
-      <Member Name="Convert(System.Char[],System.Int32,System.Int32,System.Byte[],System.Int32,System.Int32,System.Boolean,System.Int32@,System.Int32@,System.Boolean@)" />
-      <Member Name="get_Fallback" />
-      <Member Name="get_FallbackBuffer" />
-      <Member Name="GetByteCount(System.Char*,System.Int32,System.Boolean)" />
-      <Member Name="GetByteCount(System.Char[],System.Int32,System.Int32,System.Boolean)" />
-      <Member Name="GetBytes(System.Char*,System.Int32,System.Byte*,System.Int32,System.Boolean)" />
-      <Member Name="GetBytes(System.Char[],System.Int32,System.Int32,System.Byte[],System.Int32,System.Boolean)" />
-      <Member Name="Reset" />
-      <Member Name="set_Fallback(System.Text.EncoderFallback)" />
-      <Member MemberType="Property" Name="Fallback" />
-      <Member MemberType="Property" Name="FallbackBuffer" />
-    </Type>
-    <Type Name="System.Text.EncoderFallback">
-      <Member Name="#ctor" />
-      <Member Name="CreateFallbackBuffer" />
-      <Member Name="get_MaxCharCount" />
-      <Member Name="get_ReplacementFallback" />
-      <Member MemberType="Property" Name="MaxCharCount" />
-      <Member MemberType="Property" Name="ReplacementFallback" />
-      <Member Name="get_ExceptionFallback" />
-      <Member MemberType="Property" Name="ExceptionFallback" />
-    </Type>
-    <Type Name="System.Text.EncoderFallbackBuffer">
-      <Member Name="#ctor" />
-      <Member Name="Fallback(System.Char,System.Char,System.Int32)" />
-      <Member Name="Fallback(System.Char,System.Int32)" />
-      <Member Name="get_Remaining" />
-      <Member Name="GetNextChar" />
-      <Member Name="MovePrevious" />
-      <Member Name="Reset" />
-      <Member MemberType="Property" Name="Remaining" />
-    </Type>
-    <Type Name="System.Text.EncoderReplacementFallback">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="CreateFallbackBuffer" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_DefaultString" />
-      <Member Name="get_MaxCharCount" />
-      <Member Name="GetHashCode" />
-      <Member MemberType="Property" Name="DefaultString" />
-      <Member MemberType="Property" Name="MaxCharCount" />
-    </Type>
-    <Type Name="System.Text.EncoderExceptionFallback">
-      <Member Name="#ctor" />
-      <Member Name="CreateFallbackBuffer" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_MaxCharCount" />
-      <Member Name="GetHashCode" />
-      <Member MemberType="Property" Name="MaxCharCount" />
-    </Type>
-    <Type Name="System.Text.EncoderExceptionFallbackBuffer">
-      <Member Name="#ctor" />
-      <Member Name="Fallback(System.Char,System.Char,System.Int32)" />
-      <Member Name="Fallback(System.Char,System.Int32)" />
-      <Member Name="get_Remaining" />
-      <Member Name="GetNextChar" />
-      <Member Name="MovePrevious" />
-      <Member MemberType="Property" Name="Remaining" />
-    </Type>
-    <Type Name="System.Text.EncoderFallbackException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.String,System.Char,System.Int32)" />
-      <Member Name="#ctor(System.String,System.Char,System.Char,System.Int32)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="IsUnknownSurrogate" />
-      <Member Name="get_CharUnknown" />
-      <Member Name="get_CharUnknownHigh" />
-      <Member Name="get_CharUnknownLow" />
-      <Member Name="get_Index" />
-      <Member MemberType="Property" Name="CharUnknown" />
-      <Member MemberType="Property" Name="CharUnknownHigh" />
-      <Member MemberType="Property" Name="CharUnknownLow" />
-      <Member MemberType="Property" Name="Index" />
-    </Type>
-    <Type Name="System.Text.EncoderReplacementFallbackBuffer">
-      <Member Name="#ctor(System.Text.EncoderReplacementFallback)" />
-      <Member Name="Fallback(System.Char,System.Char,System.Int32)" />
-      <Member Name="Fallback(System.Char,System.Int32)" />
-      <Member Name="get_Remaining" />
-      <Member Name="GetNextChar" />
-      <Member Name="MovePrevious" />
-      <Member Name="Reset" />
-      <Member MemberType="Property" Name="Remaining" />
-    </Type>
-    <Type Name="System.Text.EncodingProvider">
-      <Member Name="#ctor" />
-      <Member Name="GetEncoding(System.Int32)" />
-      <Member Name="GetEncoding(System.Int32,System.Text.EncoderFallback,System.Text.DecoderFallback)" />
-      <Member Name="GetEncoding(System.String)" />
-      <Member Name="GetEncoding(System.String,System.Text.EncoderFallback,System.Text.DecoderFallback)" />
-    </Type>
-    <Type Name="System.Text.Encoding">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Int32)" />
-      <Member Name="#ctor(System.Int32,System.Text.EncoderFallback,System.Text.DecoderFallback)" />
-      <Member Name="Clone" />
-      <Member Name="Convert(System.Text.Encoding,System.Text.Encoding,System.Byte[])" />
-      <Member Name="Convert(System.Text.Encoding,System.Text.Encoding,System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_ASCII" />
-      <Member Name="get_BigEndianUnicode" />
-      <Member Name="get_BodyName" />
-      <Member Name="get_CodePage" />
-      <Member Name="get_DecoderFallback" />
-      <Member Name="get_Default" />
-      <Member Name="get_EncoderFallback" />
-      <Member Name="get_EncodingName" />
-      <Member Name="get_HeaderName" />
-      <Member Name="get_IsBrowserDisplay" />
-      <Member Name="get_IsBrowserSave" />
-      <Member Name="get_IsMailNewsDisplay" />
-      <Member Name="get_IsMailNewsSave" />
-      <Member Name="get_IsReadOnly" />
-      <Member Name="get_IsSingleByte" />
-      <Member Name="get_Unicode" />
-      <Member Name="get_UTF32" />
-      <Member Name="get_UTF7" />
-      <Member Name="get_UTF8" />
-      <Member Name="get_WebName" />
-      <Member Name="get_WindowsCodePage" />
-      <Member Name="GetByteCount(System.Char*,System.Int32)" />
-      <Member Name="GetByteCount(System.Char[])" />
-      <Member Name="GetByteCount(System.Char[],System.Int32,System.Int32)" />
-      <Member Name="GetByteCount(System.String)" />
-      <Member Name="GetByteCount(System.String,System.Int32,System.Int32)" />
-      <Member Name="GetBytes(System.Char[])" />
-      <Member Name="GetBytes(System.Char[],System.Int32,System.Int32)" />
-      <Member Name="GetBytes(System.Char[],System.Int32,System.Int32,System.Byte[],System.Int32)" />
-      <Member Name="GetBytes(System.String)" />
-      <Member Name="GetBytes(System.String,System.Int32,System.Int32)" />
-      <Member Name="GetBytes(System.String,System.Int32,System.Int32,System.Byte[],System.Int32)" />
-      <Member Name="GetBytes(System.Char*,System.Int32,System.Byte*,System.Int32)" />
-      <Member Name="GetCharCount(System.Byte[])" />
-      <Member Name="GetCharCount(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="GetChars(System.Byte*,System.Int32,System.Char*,System.Int32)" />
-      <Member Name="GetChars(System.Byte[])" />
-      <Member Name="GetChars(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="GetChars(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32)" />
-      <Member Name="GetString(System.Byte*,System.Int32)" /> <!-- New exposed API in ProjectK -->
-      <Member Name="GetDecoder" />
-      <Member Name="GetEncoder" />
-      <Member Name="RegisterProvider(System.Text.EncodingProvider)" />
-      <Member Name="GetEncoding(System.Int32)"/> <!-- For use in Framework assemblies, but not public in Win8P reference assemblies. -->
-      <Member Name="GetEncoding(System.Int32,System.Text.EncoderFallback,System.Text.DecoderFallback)" />
-      <Member Name="GetEncoding(System.String)" />
-      <Member Name="GetEncoding(System.String,System.Text.EncoderFallback,System.Text.DecoderFallback)" />
-      <Member Name="GetEncodings" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetMaxByteCount(System.Int32)" />
-      <Member Name="GetMaxCharCount(System.Int32)" />
-      <Member Name="GetPreamble" />
-      <Member Name="GetString(System.Byte[])" />
-      <Member Name="GetString(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="IsAlwaysNormalized" />
-      <Member Name="IsAlwaysNormalized(System.Text.NormalizationForm)" />
-      <Member Status="ImplRoot" Name="OnDeserialized(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="OnDeserializing(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="OnSerializing(System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="set_DecoderFallback(System.Text.DecoderFallback)" />
-      <Member Name="set_EncoderFallback(System.Text.EncoderFallback)" />
-      <Member MemberType="Property" Name="ASCII" />
-      <Member MemberType="Property" Name="BigEndianUnicode" />
-      <Member MemberType="Property" Name="BodyName" />
-      <Member MemberType="Property" Name="CodePage" />
-      <Member MemberType="Property" Name="DecoderFallback" />
-      <Member MemberType="Property" Name="Default" />
-      <Member MemberType="Property" Name="EncoderFallback" />
-      <Member MemberType="Property" Name="EncodingName" />
-      <Member MemberType="Property" Name="HeaderName" />
-      <Member MemberType="Property" Name="IsBrowserDisplay" />
-      <Member MemberType="Property" Name="IsBrowserSave" />
-      <Member MemberType="Property" Name="IsMailNewsDisplay" />
-      <Member MemberType="Property" Name="IsMailNewsSave" />
-      <Member MemberType="Property" Name="IsReadOnly" />
-      <Member MemberType="Property" Name="IsSingleByte" />
-      <Member MemberType="Property" Name="Unicode" />
-      <Member MemberType="Property" Name="UTF32" />
-      <Member MemberType="Property" Name="UTF7" />
-      <Member MemberType="Property" Name="UTF8" />
-      <Member MemberType="Property" Name="WebName" />
-    </Type>
-    <Type Name="System.Text.EncodingInfo">
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_CodePage" />
-      <Member Name="get_DisplayName" />
-      <Member Name="get_Name" />
-      <Member Name="GetEncoding" />
-      <Member Name="GetHashCode" />
-      <Member MemberType="Property" Name="CodePage" />
-      <Member MemberType="Property" Name="DisplayName" />
-      <Member MemberType="Property" Name="Name" />
-    </Type>
-    <Type Name="System.Text.NormalizationForm">
-      <Member MemberType="Field" Name="FormC" />
-      <Member MemberType="Field" Name="FormD" />
-      <Member MemberType="Field" Name="FormKC" />
-      <Member MemberType="Field" Name="FormKD" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Text.StringBuilder">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Int32)" />
-      <Member Name="#ctor(System.Int32,System.Int32)" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Int32)" />
-      <Member Name="#ctor(System.String,System.Int32,System.Int32,System.Int32)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="Append(System.Boolean)" />
-      <Member Name="Append(System.Byte)" />
-      <Member Name="Append(System.Char)" />
-      <Member Name="Append(System.Char,System.Int32)" />
-      <Member Name="Append(System.Char[])" />
-      <Member Name="Append(System.Char[],System.Int32,System.Int32)" />
-      <Member Name="Append(System.Char*,System.Int32)" />
-      <Member Name="Append(System.Decimal)" />
-      <Member Name="Append(System.Double)" />
-      <Member Name="Append(System.Int16)" />
-      <Member Name="Append(System.Int32)" />
-      <Member Name="Append(System.Int64)" />
-      <Member Name="Append(System.Object)" />
-      <Member Name="Append(System.SByte)" />
-      <Member Name="Append(System.Single)" />
-      <Member Name="Append(System.String)" />
-      <Member Name="Append(System.String,System.Int32,System.Int32)" />
-      <Member Name="Append(System.UInt16)" />
-      <Member Name="Append(System.UInt32)" />
-      <Member Name="Append(System.UInt64)" />
-      <Member Name="AppendFormat(System.IFormatProvider,System.String,System.Object)" />
-      <Member Name="AppendFormat(System.IFormatProvider,System.String,System.Object,System.Object)" />
-      <Member Name="AppendFormat(System.IFormatProvider,System.String,System.Object,System.Object,System.Object)" />
-      <Member Name="AppendFormat(System.IFormatProvider,System.String,System.Object[])" />
-      <Member Name="AppendFormat(System.String,System.Object)" />
-      <Member Name="AppendFormat(System.String,System.Object,System.Object)" />
-      <Member Name="AppendFormat(System.String,System.Object,System.Object,System.Object)" />
-      <Member Name="AppendFormat(System.String,System.Object[])" />
-      <Member Name="AppendJoin&lt;T&gt;(System.Char,System.Collections.Generic.IEnumerable&lt;T&gt;)" />
-      <Member Name="AppendJoin&lt;T&gt;(System.Char,T[])" />
-      <Member Name="AppendJoin&lt;T&gt;(System.String,System.Collections.Generic.IEnumerable&lt;T&gt;)" />
-      <Member Name="AppendJoin&lt;T&gt;(System.String,T[])" />
-      <Member Name="AppendLine" />
-      <Member Name="AppendLine(System.String)" />
-      <Member Name="Clear" />
-      <Member Name="CopyTo(System.Int32,System.Char[],System.Int32,System.Int32)" />
-      <Member Name="EnsureCapacity(System.Int32)" />
-      <Member Name="Equals(System.Text.StringBuilder)" />
-      <Member Name="get_Capacity" />
-      <Member Name="get_Chars(System.Int32)" />
-      <Member Name="get_Length" />
-      <Member Name="get_MaxCapacity" />
-      <Member Name="Insert(System.Int32,System.Boolean)" />
-      <Member Name="Insert(System.Int32,System.Byte)" />
-      <Member Name="Insert(System.Int32,System.Char)" />
-      <Member Name="Insert(System.Int32,System.Char[])" />
-      <Member Name="Insert(System.Int32,System.Char[],System.Int32,System.Int32)" />
-      <Member Name="Insert(System.Int32,System.Decimal)" />
-      <Member Name="Insert(System.Int32,System.Double)" />
-      <Member Name="Insert(System.Int32,System.Int16)" />
-      <Member Name="Insert(System.Int32,System.Int32)" />
-      <Member Name="Insert(System.Int32,System.Int64)" />
-      <Member Name="Insert(System.Int32,System.Object)" />
-      <Member Name="Insert(System.Int32,System.SByte)" />
-      <Member Name="Insert(System.Int32,System.Single)" />
-      <Member Name="Insert(System.Int32,System.String)" />
-      <Member Name="Insert(System.Int32,System.String,System.Int32)" />
-      <Member Name="Insert(System.Int32,System.UInt16)" />
-      <Member Name="Insert(System.Int32,System.UInt32)" />
-      <Member Name="Insert(System.Int32,System.UInt64)" />
-      <Member Name="Remove(System.Int32,System.Int32)" />
-      <Member Name="Replace(System.Char,System.Char)" />
-      <Member Name="Replace(System.Char,System.Char,System.Int32,System.Int32)" />
-      <Member Name="Replace(System.String,System.String)" />
-      <Member Name="Replace(System.String,System.String,System.Int32,System.Int32)" />
-      <Member Name="set_Capacity(System.Int32)" />
-      <Member Name="set_Chars(System.Int32,System.Char)" />
-      <Member Name="set_Length(System.Int32)" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.Int32,System.Int32)" />
-      <Member MemberType="Property" Name="Capacity" />
-      <Member MemberType="Property" Name="Chars(System.Int32)" />
-      <Member MemberType="Property" Name="Length" />
-      <Member MemberType="Property" Name="MaxCapacity" />
-      <Member Status="ImplRoot" Name="InternalCopy(System.IntPtr,System.Int32)" /> <!-- EE - il stubs -->
-      <Member Status="ImplRoot" Name="ReplaceBufferInternal(System.Char*,System.Int32)" /> <!-- EE - il stubs -->
-      <Member Status="ImplRoot" Name="ReplaceBufferAnsiInternal(System.SByte*,System.Int32)" /> <!-- EE - il stubs -->
-    </Type>
-    <Type Name="System.Text.UnicodeEncoding">
-      <Member MemberType="Field" Name="CharSize" />
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Boolean,System.Boolean)" />
-      <Member Name="#ctor(System.Boolean,System.Boolean,System.Boolean)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetByteCount(System.Char*,System.Int32)" />
-      <Member Name="GetByteCount(System.Char[],System.Int32,System.Int32)" />
-      <Member Name="GetByteCount(System.String)" />
-      <Member Name="GetBytes(System.Char*,System.Int32,System.Byte*,System.Int32)" />
-      <Member Name="GetBytes(System.Char[],System.Int32,System.Int32,System.Byte[],System.Int32)" />
-      <Member Name="GetBytes(System.String,System.Int32,System.Int32,System.Byte[],System.Int32)" />
-      <Member Name="GetCharCount(System.Byte*,System.Int32)" />
-      <Member Name="GetCharCount(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="GetChars(System.Byte*,System.Int32,System.Char*,System.Int32)" />
-      <Member Name="GetChars(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32)" />
-      <Member Name="GetDecoder" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetMaxByteCount(System.Int32)" />
-      <Member Name="GetMaxCharCount(System.Int32)" />
-      <Member Name="GetPreamble" />
-      <Member Status="ImplRoot" Name="OnDeserializing(System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Text.UTF32Encoding">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Boolean,System.Boolean)" />
-      <Member Name="#ctor(System.Boolean,System.Boolean,System.Boolean)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetByteCount(System.Char*,System.Int32)" />
-      <Member Name="GetByteCount(System.Char[],System.Int32,System.Int32)" />
-      <Member Name="GetByteCount(System.String)" />
-      <Member Name="GetBytes(System.Char*,System.Int32,System.Byte*,System.Int32)" />
-      <Member Name="GetBytes(System.Char[],System.Int32,System.Int32,System.Byte[],System.Int32)" />
-      <Member Name="GetBytes(System.String,System.Int32,System.Int32,System.Byte[],System.Int32)" />
-      <Member Name="GetCharCount(System.Byte*,System.Int32)" />
-      <Member Name="GetCharCount(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="GetChars(System.Byte*,System.Int32,System.Char*,System.Int32)" />
-      <Member Name="GetChars(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32)" />
-      <Member Name="GetDecoder" />
-      <Member Name="GetEncoder" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetMaxByteCount(System.Int32)" />
-      <Member Name="GetMaxCharCount(System.Int32)" />
-      <Member Name="GetPreamble" />
-      <Member Name="GetString(System.Byte[],System.Int32,System.Int32)" />
-    </Type>
-    <Type Name="System.Text.UTF7Encoding">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Boolean)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetByteCount(System.Char*,System.Int32)" />
-      <Member Name="GetByteCount(System.Char[],System.Int32,System.Int32)" />
-      <Member Name="GetByteCount(System.String)" />
-      <Member Name="GetBytes(System.Char*,System.Int32,System.Byte*,System.Int32)" />
-      <Member Name="GetBytes(System.Char[],System.Int32,System.Int32,System.Byte[],System.Int32)" />
-      <Member Name="GetBytes(System.String,System.Int32,System.Int32,System.Byte[],System.Int32)" />
-      <Member Name="GetCharCount(System.Byte*,System.Int32)" />
-      <Member Name="GetCharCount(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="GetChars(System.Byte*,System.Int32,System.Char*,System.Int32)" />
-      <Member Name="GetChars(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32)" />
-      <Member Name="GetDecoder" />
-      <Member Name="GetEncoder" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetMaxByteCount(System.Int32)" />
-      <Member Name="GetMaxCharCount(System.Int32)" />
-      <Member Name="GetString(System.Byte[],System.Int32,System.Int32)" />
-      <Member Status="ImplRoot" Name="OnDeserialized(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="OnDeserializing(System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Text.UTF8Encoding">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Boolean)" />
-      <Member Name="#ctor(System.Boolean,System.Boolean)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetByteCount(System.Char[],System.Int32,System.Int32)" />
-      <Member Name="GetByteCount(System.String)" />
-      <Member Name="GetBytes(System.Char[],System.Int32,System.Int32,System.Byte[],System.Int32)" />
-      <Member Name="GetBytes(System.String,System.Int32,System.Int32,System.Byte[],System.Int32)" />
-      <Member Name="GetCharCount(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="GetChars(System.Byte[],System.Int32,System.Int32,System.Char[],System.Int32)" />
-      <Member Name="GetDecoder" />
-      <Member Name="GetEncoder" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetMaxByteCount(System.Int32)" />
-      <Member Name="GetMaxCharCount(System.Int32)" />
-      <Member Name="GetPreamble" />
-    </Type>
-    <Type Name="System.Threading.AbandonedMutexException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Int32,System.Threading.WaitHandle)" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.String,System.Exception,System.Int32,System.Threading.WaitHandle)" />
-      <Member Name="#ctor(System.String,System.Int32,System.Threading.WaitHandle)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member MemberType="Property" Name="Mutex" />
-      <Member MemberType="Property" Name="MutexIndex" />
-    </Type>
-    <Type Name="System.Threading.ApartmentState">
-      <Member MemberType="Field" Name="MTA" />
-      <Member MemberType="Field" Name="STA" />
-      <Member MemberType="Field" Name="Unknown" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Threading.AsyncFlowControl">
-      <Member Name="Dispose" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.Threading.AsyncFlowControl)" />
-      <Member Name="GetHashCode" />
-      <Member Name="op_Equality(System.Threading.AsyncFlowControl,System.Threading.AsyncFlowControl)" />
-      <Member Name="op_Inequality(System.Threading.AsyncFlowControl,System.Threading.AsyncFlowControl)" />
-      <Member Name="Undo" />
-    </Type>
-    <Type Name="System.Threading.AutoResetEvent">
-      <Member Name="#ctor(System.Boolean)" />
-    </Type>
-    <Type Name="System.Threading.EventWaitHandle">
-      <Member Name="#ctor(System.Boolean,System.Threading.EventResetMode)" />
-      <Member Name="#ctor(System.Boolean,System.Threading.EventResetMode,System.String)" />
-      <Member Name="#ctor(System.Boolean,System.Threading.EventResetMode,System.String,System.Boolean@)" />
-      <Member Name="OpenExisting(System.String)" />
-      <Member Name="Reset" />
-      <Member Name="Set" />
-      <Member Name="TryOpenExisting(System.String,System.Threading.EventWaitHandle@)" />
-    </Type>
-    <Type Name="System.Threading.Interlocked">
-      <Member Name="Add(System.Int32@,System.Int32)" />
-      <Member Name="Add(System.Int64@,System.Int64)" />
-      <Member Name="CompareExchange(System.Double@,System.Double,System.Double)" />
-      <Member Name="CompareExchange(System.Int32@,System.Int32,System.Int32)" />
-      <Member Name="CompareExchange(System.Int64@,System.Int64,System.Int64)" />
-      <Member Name="CompareExchange(System.IntPtr@,System.IntPtr,System.IntPtr)" />
-      <Member Name="CompareExchange(System.Object@,System.Object,System.Object)" />
-      <Member Name="CompareExchange(System.Single@,System.Single,System.Single)" />
-      <Member Name="CompareExchange&lt;T&gt;(T@,T,T)" />
-      <Member Name="Decrement(System.Int32@)" />
-      <Member Name="Decrement(System.Int64@)" />
-      <Member Name="Exchange(System.Double@,System.Double)" />
-      <Member Name="Exchange(System.Int32@,System.Int32)" />
-      <Member Name="Exchange(System.Int64@,System.Int64)" />
-      <Member Name="Exchange(System.IntPtr@,System.IntPtr)" />
-      <Member Name="Exchange(System.Object@,System.Object)" />
-      <Member Name="Exchange(System.Single@,System.Single)" />
-      <Member Name="Exchange&lt;T&gt;(T@,T)" />
-      <Member Name="Increment(System.Int32@)" />
-      <Member Name="Increment(System.Int64@)" />
-      <Member Name="MemoryBarrier" />
-      <Member Name="Read(System.Int64@)" />
-    </Type>
-    <Type Name="System.Threading.LockRecursionException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Threading.Mutex">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Boolean)" />
-      <Member Name="#ctor(System.Boolean,System.String)" />
-      <Member Name="#ctor(System.Boolean,System.String,System.Boolean@)" />
-      <Member Name="OpenExisting(System.String)" />
-      <Member Name="ReleaseMutex" />
-      <Member Name="TryOpenExisting(System.String,System.Threading.Mutex@)" />
-    </Type>
-    <Type Name="System.Threading.Volatile">
-      <Member Name="Read(System.Boolean@)"/>
-      <Member Name="Read(System.SByte@)"/>
-      <Member Name="Read(System.Byte@)"/>
-      <Member Name="Read(System.Int16@)"/>
-      <Member Name="Read(System.UInt16@)"/>
-      <Member Name="Read(System.Int32@)"/>
-      <Member Name="Read(System.UInt32@)"/>
-      <Member Name="Read(System.Int64@)"/>
-      <Member Name="Read(System.UInt64@)"/>
-      <Member Name="Read(System.IntPtr@)"/>
-      <Member Name="Read(System.UIntPtr@)"/>
-      <Member Name="Read(System.Single@)"/>
-      <Member Name="Read(System.Double@)"/>
-      <Member Name="Read&lt;T&gt;(T@)"/>
-      <Member Name="Write(System.Boolean@,System.Boolean)"/>
-      <Member Name="Write(System.SByte@,System.SByte)"/>
-      <Member Name="Write(System.Byte@,System.Byte)"/>
-      <Member Name="Write(System.Int16@,System.Int16)"/>
-      <Member Name="Write(System.UInt16@,System.UInt16)"/>
-      <Member Name="Write(System.Int32@,System.Int32)"/>
-      <Member Name="Write(System.UInt32@,System.UInt32)"/>
-      <Member Name="Write(System.Int64@,System.Int64)"/>
-      <Member Name="Write(System.UInt64@,System.UInt64)"/>
-      <Member Name="Write(System.IntPtr@,System.IntPtr)"/>
-      <Member Name="Write(System.UIntPtr@,System.UIntPtr)"/>
-      <Member Name="Write(System.Single@,System.Single)"/>
-      <Member Name="Write(System.Double@,System.Double)"/>
-      <Member Name="Write&lt;T&gt;(T@,T)"/>
-    </Type>
-    <Type Status="ImplRoot" Name="System.Threading.IThreadPoolWorkItem">
-      <Member Status="ImplRoot" Name="ExecuteWorkItem"/>
-    </Type>
-    <Type Name="System.Threading.Monitor">
-      <Member Name="Enter(System.Object)" />
-      <Member Name="Enter(System.Object,System.Boolean@)" />
-      <Member Name="IsEntered(System.Object)"  />
-      <Member Name="Exit(System.Object)" />
-      <Member Name="Pulse(System.Object)" />
-      <Member Name="PulseAll(System.Object)" />
-      <Member Name="TryEnter(System.Object)" />
-      <Member Name="TryEnter(System.Object,System.Int32)" />
-      <Member Name="TryEnter(System.Object,System.TimeSpan)" />
-      <Member Name="TryEnter(System.Object,System.Boolean@)" />
-      <Member Name="TryEnter(System.Object,System.Int32,System.Boolean@)" />
-      <Member Name="TryEnter(System.Object,System.TimeSpan,System.Boolean@)" />
-      <Member Name="Wait(System.Object)" />
-      <Member Name="Wait(System.Object,System.Int32)" />
-      <Member Name="Wait(System.Object,System.Int32,System.Boolean)" />
-      <Member Name="Wait(System.Object,System.TimeSpan)" />
-      <Member Name="Wait(System.Object,System.TimeSpan,System.Boolean)" />
-    </Type>
-    <Type Name="System.Threading.ManualResetEvent">
-      <Member Name="#ctor(System.Boolean)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Threading.QueueUserWorkItemCallback">
-      <Member Status="ImplRoot" Name="#ctor(System.Threading.WaitCallback,System.Object,System.Threading.ExecutionContext)"/>
-    </Type>
-    <Type Status="ImplRoot" Name="System.Threading.QueueUserWorkItemCallbackDefaultContext">
-      <Member Status="ImplRoot" Name="#ctor(System.Threading.WaitCallback,System.Object)"/>
-    </Type>
-    <Type Name="System.Threading.SynchronizationContext">
-      <Member Name="#ctor"/>
-      <Member Name="CreateCopy"/>
-      <Member MemberType="Property" Name="Current"/>
-      <Member Status="ImplRoot" Name="InvokeWaitMethodHelper(System.Threading.SynchronizationContext,System.IntPtr[],System.Boolean,System.Int32)"/>
-      <Member Name="IsWaitNotificationRequired"/>
-      <Member Name="OperationCompleted"/>
-      <Member Name="OperationStarted"/>
-      <Member Name="Post(System.Threading.SendOrPostCallback,System.Object)"/>
-      <Member Name="Send(System.Threading.SendOrPostCallback,System.Object)"/>
-      <Member Name="SetSynchronizationContext(System.Threading.SynchronizationContext)"/>
-      <Member Name="SetWaitNotificationRequired"/>
-      <Member Name="Wait(System.IntPtr[],System.Boolean,System.Int32)"/>
-      <Member Name="WaitHelper(System.IntPtr[],System.Boolean,System.Int32)"/>
-    </Type>
-    <Type Name="System.Threading.SynchronizationLockException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Threading.Thread">
-      <Member Name="#ctor(System.Threading.ThreadStart)" />
-      <Member Name="#ctor(System.Threading.ParameterizedThreadStart)" />
-      <Member Name="MemoryBarrier" />
-      <Member Name="Finalize" />
-      <Member Name="get_CurrentCulture" />
-      <Member Name="get_CurrentThread" />
-      <Member Name="get_CurrentUICulture" />
-      <Member Name="get_ManagedThreadId" />
-      <Member Name="get_Name" />
-      <Member Name="set_Name(System.String)" />
-      <Member Name="Sleep(System.Int32)" />
-      <Member Name="Sleep(System.TimeSpan)" />
-      <Member Name="SpinWait(System.Int32)" />
-      <Member Name="Start" />
-      <Member Name="Start(System.Object)" />
-      <Member MemberType="Property" Name="CurrentCulture" />
-      <Member MemberType="Property" Name="CurrentThread" />
-      <Member MemberType="Property" Name="CurrentUICulture" />
-      <Member MemberType="Property" Name="ManagedThreadId" />
-      <Member MemberType="Property" Name="Name" />
-      <Member Status="ImplRoot" Name="InternalGetCurrentThread" />
-      <Member Status="ImplRoot" MemberType="Field" Name="DONT_USE_InternalThread" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_Priority" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_ThreadStartArg" />
-    </Type>
-    <Type Name="Internal.Runtime.Augments.RuntimeThread">
-      <Member MemberType="Property" Name="CurrentThread" />
-      <Member MemberType="Property" Name="IsAlive" />
-      <Member MemberType="Property" Name="IsBackground" />
-      <Member MemberType="Property" Name="IsThreadPoolThread" />
-      <Member MemberType="Property" Name="ManagedThreadId" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="Priority" />
-      <Member MemberType="Property" Name="ThreadState" />
-      <Member Name="Create(System.Threading.ThreadStart)" />
-      <Member Name="Create(System.Threading.ThreadStart,System.Int32)" />
-      <Member Name="Create(System.Threading.ParameterizedThreadStart)" />
-      <Member Name="Create(System.Threading.ParameterizedThreadStart,System.Int32)" />
-      <Member Name="DisableComObjectEagerCleanup" />
-      <Member Name="GetApartmentState" />
-      <Member Name="Interrupt" />
-      <Member Name="Join" />
-      <Member Name="Join(System.Int32)" />
-      <Member Name="Sleep(System.Int32)" />
-      <Member Name="SpinWait(System.Int32)" />
-      <Member Name="Start" />
-      <Member Name="Start(System.Object)" />
-      <Member Name="TrySetApartmentState(System.Threading.ApartmentState)" />
-      <Member Name="Yield" />
-    </Type>
-    <Type Name="System.Threading.ThreadAbortException">
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Threading.ThreadPool">
-      <Member Name="BindHandle(System.IntPtr)" />
-      <Member Name="BindHandle(System.Runtime.InteropServices.SafeHandle)" />
-      <Member Status="ImplRoot" Name="GetGloballyQueuedWorkItemsForDebugger"/>
-      <Member Status="ImplRoot" Name="GetLocallyQueuedWorkItemsForDebugger"/>
-      <Member Name="GetAvailableThreads(System.Int32@,System.Int32@)" />
-      <Member Name="GetMaxThreads(System.Int32@,System.Int32@)" />
-      <Member Name="GetMinThreads(System.Int32@,System.Int32@)" />
-      <Member Status="ImplRoot" Name="GetQueuedWorkItemsForDebugger"/>
-      <Member Status="ImplRoot" Name="NotifyWorkItemProgress"/>
-      <Member Name="QueueUserWorkItem(System.Threading.WaitCallback)" />
-      <Member Name="QueueUserWorkItem(System.Threading.WaitCallback,System.Object)" />
-      <Member Name="RegisterWaitForSingleObject(System.Threading.WaitHandle,System.Threading.WaitOrTimerCallback,System.Object,System.Int32,System.Boolean)" />
-      <Member Name="RegisterWaitForSingleObject(System.Threading.WaitHandle,System.Threading.WaitOrTimerCallback,System.Object,System.Int64,System.Boolean)" />
-      <Member Name="RegisterWaitForSingleObject(System.Threading.WaitHandle,System.Threading.WaitOrTimerCallback,System.Object,System.TimeSpan,System.Boolean)" />
-      <Member Name="RegisterWaitForSingleObject(System.Threading.WaitHandle,System.Threading.WaitOrTimerCallback,System.Object,System.UInt32,System.Boolean)" />
-      <Member Status="ImplRoot" Name="RegisterWaitForSingleObject(System.Threading.WaitHandle,System.Threading.WaitOrTimerCallback,System.Object,System.UInt32,System.Boolean,System.Threading.StackCrawlMark@,System.Boolean)" />
-      <Member Status="ImplRoot" Name="RegisterWaitForSingleObjectNative(System.Threading.WaitHandle,System.Object,System.UInt32,System.Boolean,System.Threading.RegisteredWaitHandle,System.Threading.StackCrawlMark@,System.Boolean)" />
-      <Member Name="SetMaxThreads(System.Int32,System.Int32)" />
-      <Member Name="SetMinThreads(System.Int32,System.Int32)" />
-      <Member Status="ImplRoot" Name="TryPopCustomWorkItem(System.Threading.IThreadPoolWorkItem)"/>
-      <Member Status="ImplRoot" Name="UnsafeQueueCustomWorkItem(System.Threading.IThreadPoolWorkItem,System.Boolean)"/>
-      <Member Name="UnsafeQueueNativeOverlapped(System.Threading.NativeOverlapped*)" />
-      <Member Name="UnsafeQueueUserWorkItem(System.Threading.WaitCallback,System.Object)" />
-      <Member Name="UnsafeRegisterWaitForSingleObject(System.Threading.WaitHandle,System.Threading.WaitOrTimerCallback,System.Object,System.Int32,System.Boolean)" />
-      <Member Name="UnsafeRegisterWaitForSingleObject(System.Threading.WaitHandle,System.Threading.WaitOrTimerCallback,System.Object,System.Int64,System.Boolean)" />
-      <Member Name="UnsafeRegisterWaitForSingleObject(System.Threading.WaitHandle,System.Threading.WaitOrTimerCallback,System.Object,System.TimeSpan,System.Boolean)" />
-      <Member Name="UnsafeRegisterWaitForSingleObject(System.Threading.WaitHandle,System.Threading.WaitOrTimerCallback,System.Object,System.UInt32,System.Boolean)" />
-    </Type>
-    <Type Name="System.Threading.ThreadPriority">
-      <Member MemberType="Field" Name="AboveNormal" />
-      <Member MemberType="Field" Name="BelowNormal" />
-      <Member MemberType="Field" Name="Highest" />
-      <Member MemberType="Field" Name="Lowest" />
-      <Member MemberType="Field" Name="Normal" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Status="ImplRoot"  Name="System.Threading.StackCrawlMark">
-      <Member MemberType="Field" Name="LookForMe" />
-      <Member MemberType="Field" Name="LookForMyCaller" />
-      <Member MemberType="Field" Name="LookForMyCallersCaller" />
-      <Member MemberType="Field" Name="LookForThread" />
-    </Type>
-    <Type Name="System.Threading.NativeOverlapped">
-      <Member MemberType="Field" Name="InternalLow" />
-      <Member MemberType="Field" Name="InternalHigh" />
-      <Member MemberType="Field" Name="OffsetLow" />
-      <Member MemberType="Field" Name="OffsetHigh" />
-      <Member MemberType="Field" Name="EventHandle" />
-    </Type>
-    <Type Name="System.Threading.Overlapped">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.Int32,System.IAsyncResult)" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.IntPtr,System.IAsyncResult)" />
-      <Member MemberType="Property" Name="AsyncResult" />
-      <Member MemberType="Property" Name="EventHandle" />
-      <Member MemberType="Property" Name="EventHandleIntPtr" />
-      <Member MemberType="Property" Name="OffsetLow" />
-      <Member MemberType="Property" Name="OffsetHigh" />
-      <Member Name="Free(System.Threading.NativeOverlapped*)" />
-      <Member Name="Pack(System.Threading.IOCompletionCallback)" />
-      <Member Name="Pack(System.Threading.IOCompletionCallback,System.Object)" />
-      <Member Name="Unpack(System.Threading.NativeOverlapped*)" />
-      <Member Name="UnsafePack(System.Threading.IOCompletionCallback)" />
-      <Member Name="UnsafePack(System.Threading.IOCompletionCallback,System.Object)" Condition="FEATURE_COMINTEROP" />
-    </Type>
-    <Type Name="System.Threading.IOCompletionCallback">
-    </Type>
-    <Type Name="System.Threading.RegisteredWaitHandle">
-      <Member Name="Unregister(System.Threading.WaitHandle)" />
-      <Member Status="ImplRoot" Name="SetHandle(System.IntPtr)" />
-      <Member Status="ImplRoot" Name="SetWaitObject(System.Threading.WaitHandle)" />
-    </Type>
-    <Type Name="System.Threading.ThreadState">
-      <Member MemberType="Field" Name="Running" />
-      <Member MemberType="Field" Name="StopRequested" />
-      <Member MemberType="Field" Name="SuspendRequested" />
-      <Member MemberType="Field" Name="Background" />
-      <Member MemberType="Field" Name="Unstarted" />
-      <Member MemberType="Field" Name="Stopped" />
-      <Member MemberType="Field" Name="WaitSleepJoin" />
-      <Member MemberType="Field" Name="Suspended" />
-      <Member MemberType="Field" Name="AbortRequested" />
-      <Member MemberType="Field" Name="Aborted" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Threading.ThreadStart">
-    </Type>
-    <Type Name="System.Threading.ParameterizedThreadStart">
-    </Type>
-    <Type Name="System.Threading.SendOrPostCallback">
-    </Type>
-    <Type Name="System.Threading.ThreadStartException">
-      <Member Status="ImplRoot" Name="#ctor(System.Exception)" /><!-- EE -->
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Threading.ThreadStateException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Threading.Timeout">
-      <Member MemberType="Field" Name="Infinite" />
-      <Member MemberType="Field" Name="InfiniteTimeSpan" />
-    </Type>
-    <Type Name="System.Threading.Timer">
-      <Member Name="#ctor(System.Threading.TimerCallback)" />
-      <Member Name="#ctor(System.Threading.TimerCallback,System.Object,System.Int32,System.Int32)" />
-      <Member Name="#ctor(System.Threading.TimerCallback,System.Object,System.Int64,System.Int64)" />
-      <Member Name="#ctor(System.Threading.TimerCallback,System.Object,System.TimeSpan,System.TimeSpan)" />
-      <Member Name="#ctor(System.Threading.TimerCallback,System.Object,System.UInt32,System.UInt32)" />
-      <Member Name="Change(System.Int32,System.Int32)" />
-      <Member Name="Change(System.Int64,System.Int64)" />
-      <Member Name="Change(System.TimeSpan,System.TimeSpan)" />
-      <Member Name="Change(System.UInt32,System.UInt32)" />
-      <Member Name="Dispose" />
-      <Member Name="Dispose(System.Threading.WaitHandle)" />
-    </Type>
-    <Type Name="System.Threading.TimerCallback">
-      <Member Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Name="BeginInvoke(System.Object,System.AsyncCallback,System.Object)" />
-      <Member Name="EndInvoke(System.IAsyncResult)" />
-      <Member Name="Invoke(System.Object)" />
-    </Type>
-    <Type Name="System.Threading.WaitCallback">
-      <Member Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Name="BeginInvoke(System.Object,System.AsyncCallback,System.Object)" />
-      <Member Name="EndInvoke(System.IAsyncResult)" />
-      <Member Name="Invoke(System.Object)" />
-    </Type>
-    <Type Name="System.Threading.WaitOrTimerCallback">
-    </Type>
-    <Type Name="System.Threading.WaitHandle">
-      <Member MemberType="Field" Name="InvalidHandle" />
-      <Member MemberType="Field" Name="WaitTimeout" />
-      <Member Name="#ctor" />
-      <Member Name="Close" />
-      <Member Name="Dispose" />
-      <Member Name="Dispose(System.Boolean)" />
-      <Member Name="get_Handle" />
-      <Member Name="set_Handle(System.IntPtr)" />
-      <Member Name="get_SafeWaitHandle" />
-      <Member Name="set_SafeWaitHandle(Microsoft.Win32.SafeHandles.SafeWaitHandle)" />
-      <Member Name="SignalAndWait(System.Threading.WaitHandle,System.Threading.WaitHandle)" />
-      <Member Name="SignalAndWait(System.Threading.WaitHandle,System.Threading.WaitHandle,System.Int32,System.Boolean)" />
-      <Member Name="SignalAndWait(System.Threading.WaitHandle,System.Threading.WaitHandle,System.TimeSpan,System.Boolean)" />
-      <Member Name="WaitAny(System.Threading.WaitHandle[])" />
-      <Member Name="WaitAny(System.Threading.WaitHandle[],System.Int32)" />
-      <Member Name="WaitAny(System.Threading.WaitHandle[],System.Int32,System.Boolean)" />
-      <Member Name="WaitAny(System.Threading.WaitHandle[],System.TimeSpan)" />
-      <Member Name="WaitAny(System.Threading.WaitHandle[],System.TimeSpan,System.Boolean)" />
-      <Member Name="WaitAll(System.Threading.WaitHandle[])" />
-      <Member Name="WaitAll(System.Threading.WaitHandle[],System.Int32)" />
-      <Member Name="WaitAll(System.Threading.WaitHandle[],System.Int32,System.Boolean)" />
-      <Member Name="WaitAll(System.Threading.WaitHandle[],System.TimeSpan)" />
-      <Member Name="WaitAll(System.Threading.WaitHandle[],System.TimeSpan,System.Boolean)" />
-      <Member Name="WaitOne" />
-      <Member Name="WaitOne(System.Int32)" />
-      <Member Name="WaitOne(System.Int32,System.Boolean)" />
-      <Member Name="WaitOne(System.TimeSpan)" />
-      <Member Name="WaitOne(System.TimeSpan,System.Boolean)" />
-      <Member MemberType="Property" Name="SafeWaitHandle" />
-    </Type>
-    <Type Name="System.Threading.WaitHandleCannotBeOpenedException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.TimeoutException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.TimeSpan">
-      <Member MemberType="Field" Name="MaxValue" />
-      <Member MemberType="Field" Name="MinValue" />
-      <Member MemberType="Field" Name="TicksPerDay" />
-      <Member MemberType="Field" Name="TicksPerHour" />
-      <Member MemberType="Field" Name="TicksPerMillisecond" />
-      <Member MemberType="Field" Name="TicksPerMinute" />
-      <Member MemberType="Field" Name="TicksPerSecond" />
-      <Member MemberType="Field" Name="Zero" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="#ctor(System.Int64)" />
-      <Member Name="Add(System.TimeSpan)" />
-      <Member Name="Compare(System.TimeSpan,System.TimeSpan)" />
-      <Member Name="CompareTo(System.Object)" />
-      <Member Name="CompareTo(System.TimeSpan)" />
-      <Member Name="Duration" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.TimeSpan)" />
-      <Member Name="Equals(System.TimeSpan,System.TimeSpan)" />
-      <Member Name="FromDays(System.Double)" />
-      <Member Name="FromHours(System.Double)" />
-      <Member Name="FromMilliseconds(System.Double)" />
-      <Member Name="FromMinutes(System.Double)" />
-      <Member Name="FromSeconds(System.Double)" />
-      <Member Name="FromTicks(System.Int64)" />
-      <Member Name="get_Days" />
-      <Member Name="get_Hours" />
-      <Member Name="get_Milliseconds" />
-      <Member Name="get_Minutes" />
-      <Member Name="get_Seconds" />
-      <Member Name="get_Ticks" />
-      <Member Name="get_TotalDays" />
-      <Member Name="get_TotalHours" />
-      <Member Name="get_TotalMilliseconds" />
-      <Member Name="get_TotalMinutes" />
-      <Member Name="get_TotalSeconds" />
-      <Member Name="GetHashCode" />
-      <Member Name="Negate" />
-      <Member Name="op_Addition(System.TimeSpan,System.TimeSpan)" />
-      <Member Name="op_Equality(System.TimeSpan,System.TimeSpan)" />
-      <Member Name="op_GreaterThan(System.TimeSpan,System.TimeSpan)" />
-      <Member Name="op_GreaterThanOrEqual(System.TimeSpan,System.TimeSpan)" />
-      <Member Name="op_Inequality(System.TimeSpan,System.TimeSpan)" />
-      <Member Name="op_LessThan(System.TimeSpan,System.TimeSpan)" />
-      <Member Name="op_LessThanOrEqual(System.TimeSpan,System.TimeSpan)" />
-      <Member Name="op_Subtraction(System.TimeSpan,System.TimeSpan)" />
-      <Member Name="op_UnaryPlus(System.TimeSpan)" />
-      <Member Name="op_UnaryNegation(System.TimeSpan)" />
-      <Member Name="Parse(System.String)" />
-      <Member Name="Parse(System.String,System.IFormatProvider)" />
-      <Member Name="ParseExact(System.String,System.String,System.IFormatProvider)" />
-      <Member Name="ParseExact(System.String,System.String[],System.IFormatProvider)" />
-      <Member Name="ParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.TimeSpanStyles)" />
-      <Member Name="ParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.TimeSpanStyles)" />
-      <Member Name="TryParse(System.String,System.TimeSpan@)" />
-      <Member Name="TryParse(System.String,System.IFormatProvider,System.TimeSpan@)" />
-      <Member Name="TryParseExact(System.String,System.String,System.IFormatProvider,System.TimeSpan@)" />
-      <Member Name="TryParseExact(System.String,System.String[],System.IFormatProvider,System.TimeSpan@)" />
-      <Member Name="TryParseExact(System.String,System.String,System.IFormatProvider,System.Globalization.TimeSpanStyles,System.TimeSpan@)" />
-      <Member Name="TryParseExact(System.String,System.String[],System.IFormatProvider,System.Globalization.TimeSpanStyles,System.TimeSpan@)" />
-      <Member Name="Subtract(System.TimeSpan)" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.String)" />
-      <Member MemberType="Property" Name="Days" />
-      <Member MemberType="Property" Name="Hours" />
-      <Member MemberType="Property" Name="Milliseconds" />
-      <Member MemberType="Property" Name="Minutes" />
-      <Member MemberType="Property" Name="Seconds" />
-      <Member MemberType="Property" Name="Ticks" />
-      <Member MemberType="Property" Name="TotalDays" />
-      <Member MemberType="Property" Name="TotalHours" />
-      <Member MemberType="Property" Name="TotalMilliseconds" />
-      <Member MemberType="Property" Name="TotalMinutes" />
-      <Member MemberType="Property" Name="TotalSeconds" />
-    </Type>
-    <Type Name="System.TimeZone">
-      <Member Name="#ctor" />
-      <Member Name="get_CurrentTimeZone" />
-      <Member Name="get_DaylightName" />
-      <Member Name="get_StandardName" />
-      <Member Name="GetDaylightChanges(System.Int32)" />
-      <Member Name="GetUtcOffset(System.DateTime)" />
-      <Member Name="IsDaylightSavingTime(System.DateTime)" />
-      <Member Name="IsDaylightSavingTime(System.DateTime,System.Globalization.DaylightTime)" />
-      <Member Name="ToLocalTime(System.DateTime)" />
-      <Member Name="ToUniversalTime(System.DateTime)" />
-      <Member MemberType="Property" Name="CurrentTimeZone" />
-      <Member MemberType="Property" Name="DaylightName" />
-      <Member MemberType="Property" Name="StandardName" />
-    </Type>
-    <Type Name="System.TimeZoneInfo">
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="ClearCachedData" />
-      <Member Name="ConvertTime(System.DateTime,System.TimeZoneInfo)" />
-      <Member Name="ConvertTime(System.DateTime,System.TimeZoneInfo,System.TimeZoneInfo)" />
-      <Member Name="ConvertTime(System.DateTimeOffset,System.TimeZoneInfo)" />
-      <Member Name="ConvertTimeBySystemTimeZoneId(System.DateTime,System.String)" />
-      <Member Name="ConvertTimeBySystemTimeZoneId(System.DateTime,System.String,System.String)" />
-      <Member Name="ConvertTimeBySystemTimeZoneId(System.DateTimeOffset,System.String)" />
-      <Member Name="ConvertTimeFromUtc(System.DateTime,System.TimeZoneInfo)" />
-      <Member Name="ConvertTimeToUtc(System.DateTime)" />
-      <Member Name="ConvertTimeToUtc(System.DateTime,System.TimeZoneInfo)" />
-      <Member Name="CreateCustomTimeZone(System.String,System.TimeSpan,System.String,System.String)" />
-      <Member Name="CreateCustomTimeZone(System.String,System.TimeSpan,System.String,System.String,System.String,System.TimeZoneInfo+AdjustmentRule[])" />
-      <Member Name="CreateCustomTimeZone(System.String,System.TimeSpan,System.String,System.String,System.String,System.TimeZoneInfo+AdjustmentRule[],System.Boolean)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.TimeZoneInfo)" />
-      <Member Name="FindSystemTimeZoneById(System.String)" />
-      <Member Name="FromSerializedString(System.String)" />
-      <Member Name="get_BaseUtcOffset" />
-      <Member Name="get_DisplayName" />
-      <Member Name="get_DaylightName" />
-      <Member Name="get_StandardName" />
-      <Member Name="get_Id" />
-      <Member Name="get_Local" />
-      <Member Name="get_SupportsDaylightSavingTime" />
-      <Member Name="get_Utc" />
-      <Member Name="GetAdjustmentRules" />
-      <Member Name="GetAmbiguousTimeOffsets(System.DateTimeOffset)" />
-      <Member Name="GetAmbiguousTimeOffsets(System.DateTime)" />
-      <Member Name="GetUtcOffset(System.DateTimeOffset)" />
-      <Member Name="GetUtcOffset(System.DateTime)" />
-      <Member Name="HasSameRules(System.TimeZoneInfo)" />
-      <Member Name="IsAmbiguousTime(System.DateTimeOffset)" />
-      <Member Name="IsAmbiguousTime(System.DateTime)" />
-      <Member Name="IsDaylightSavingTime(System.DateTimeOffset)" />
-      <Member Name="IsDaylightSavingTime(System.DateTime)" />
-      <Member Name="IsInvalidTime(System.DateTime)" />
-      <Member Name="ToSerializedString" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetSystemTimeZones" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="DaylightName" />
-      <Member MemberType="Property" Name="DisplayName" />
-      <Member MemberType="Property" Name="Id" />
-      <Member MemberType="Property" Name="Local" />
-      <Member MemberType="Property" Name="StandardName" />
-      <Member MemberType="Property" Name="BaseUtcOffset" />
-      <Member MemberType="Property" Name="SupportsDaylightSavingTime" />
-      <Member MemberType="Property" Name="Utc" />
-    </Type>
-    <Type Name="System.TimeZoneInfo+AdjustmentRule">
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <!-- CreateAdjustmentRule doesn't have a public contract, but tests and other callers can use Reflection to invoke it, so ensure it is left in mscorlib. -->
-      <Member Status="ApiRoot" Name="CreateAdjustmentRule(System.DateTime,System.DateTime,System.TimeSpan,System.TimeZoneInfo+TransitionTime,System.TimeZoneInfo+TransitionTime)" />
-      <Member Name="get_DateEnd" />
-      <Member Name="get_DateStart" />
-      <Member Name="get_DaylightDelta" />
-      <Member Name="get_DaylightTransitionEnd" />
-      <Member Name="get_DaylightTransitionStart" />
-      <Member MemberType="Property" Name="DateEnd" />
-      <Member MemberType="Property" Name="DateStart" />
-      <Member MemberType="Property" Name="DaylightDelta" />
-      <Member MemberType="Property" Name="DaylightTransitionEnd" />
-      <Member MemberType="Property" Name="DaylightTransitionStart" />
-    </Type>
-    <Type Name="System.TimeZoneInfo+TransitionTime">
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="CreateFixedDateRule(System.DateTime,System.Int32,System.Int32)" />
-      <Member Name="CreateFloatingDateRule(System.DateTime,System.Int32,System.Int32,System.DayOfWeek)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.TimeZoneInfo+TransitionTime)" />
-      <Member Name="get_Day" />
-      <Member Name="get_DayOfWeek" />
-      <Member Name="get_IsFixedDateRule" />
-      <Member Name="get_Month" />
-      <Member Name="get_TimeOfDay" />
-      <Member Name="get_Week" />
-      <Member Name="GetHashCode" />
-      <Member Name="op_Equality(System.TimeZoneInfo+TransitionTime,System.TimeZoneInfo+TransitionTime)" />
-      <Member Name="op_Inequality(System.TimeZoneInfo+TransitionTime,System.TimeZoneInfo+TransitionTime)" />
-      <Member MemberType="Property" Name="Day" />
-      <Member MemberType="Property" Name="DayOfWeek" />
-      <Member MemberType="Property" Name="IsFixedDateRule" />
-      <Member MemberType="Property" Name="Month" />
-      <Member MemberType="Property" Name="TimeOfDay" />
-      <Member MemberType="Property" Name="Week" />
-    </Type>
-    <Type Name="System.TimeZoneNotFoundException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-    </Type>
-    <Type Name="System.Tuple">
-      <Member Name="Create&lt;T1&gt;(T1)" />
-      <Member Name="Create&lt;T1,T2&gt;(T1,T2)" />
-      <Member Name="Create&lt;T1,T2,T3&gt;(T1,T2,T3)" />
-      <Member Name="Create&lt;T1,T2,T3,T4&gt;(T1,T2,T3,T4)" />
-      <Member Name="Create&lt;T1,T2,T3,T4,T5&gt;(T1,T2,T3,T4,T5)" />
-      <Member Name="Create&lt;T1,T2,T3,T4,T5,T6&gt;(T1,T2,T3,T4,T5,T6)" />
-      <Member Name="Create&lt;T1,T2,T3,T4,T5,T6,T7&gt;(T1,T2,T3,T4,T5,T6,T7)" />
-      <Member Name="Create&lt;T1,T2,T3,T4,T5,T6,T7,T8&gt;(T1,T2,T3,T4,T5,T6,T7,T8)" />
-    </Type>
-    <Type Name="System.Tuple&lt;T1&gt;">
-      <Member Name="#ctor(T1)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_Item1" />
-      <Member Name="GetHashCode" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="Item1" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.IComparable.CompareTo(System.Object)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Item(System.Int32)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Length" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Item(System.Int32)" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Length" />
-    </Type>
-    <Type Name="System.Tuple&lt;T1,T2&gt;">
-      <Member Name="#ctor(T1,T2)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_Item1" />
-      <Member Name="get_Item2" />
-      <Member Name="GetHashCode" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="Item1" />
-      <Member MemberType="Property" Name="Item2" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.IComparable.CompareTo(System.Object)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Item(System.Int32)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Length" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Item(System.Int32)" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Length" />
-    </Type>
-    <Type Name="System.Tuple&lt;T1,T2,T3&gt;">
-      <Member Name="#ctor(T1,T2,T3)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_Item1" />
-      <Member Name="get_Item2" />
-      <Member Name="get_Item3" />
-      <Member Name="GetHashCode" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="Item1" />
-      <Member MemberType="Property" Name="Item2" />
-      <Member MemberType="Property" Name="Item3" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.IComparable.CompareTo(System.Object)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Item(System.Int32)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Length" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Item(System.Int32)" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Length" />
-    </Type>
-    <Type Name="System.Tuple&lt;T1,T2,T3,T4&gt;">
-      <Member Name="#ctor(T1,T2,T3,T4)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_Item1" />
-      <Member Name="get_Item2" />
-      <Member Name="get_Item3" />
-      <Member Name="get_Item4" />
-      <Member Name="GetHashCode" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="Item1" />
-      <Member MemberType="Property" Name="Item2" />
-      <Member MemberType="Property" Name="Item3" />
-      <Member MemberType="Property" Name="Item4" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.IComparable.CompareTo(System.Object)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Item(System.Int32)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Length" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Item(System.Int32)" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Length" />
-    </Type>
-    <Type Name="System.Tuple&lt;T1,T2,T3,T4,T5&gt;">
-      <Member Name="#ctor(T1,T2,T3,T4,T5)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_Item1" />
-      <Member Name="get_Item2" />
-      <Member Name="get_Item3" />
-      <Member Name="get_Item4" />
-      <Member Name="get_Item5" />
-      <Member Name="GetHashCode" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="Item1" />
-      <Member MemberType="Property" Name="Item2" />
-      <Member MemberType="Property" Name="Item3" />
-      <Member MemberType="Property" Name="Item4" />
-      <Member MemberType="Property" Name="Item5" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.IComparable.CompareTo(System.Object)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Item(System.Int32)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Length" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Item(System.Int32)" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Length" />
-    </Type>
-    <Type Name="System.Tuple&lt;T1,T2,T3,T4,T5,T6&gt;">
-      <Member Name="#ctor(T1,T2,T3,T4,T5,T6)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_Item1" />
-      <Member Name="get_Item2" />
-      <Member Name="get_Item3" />
-      <Member Name="get_Item4" />
-      <Member Name="get_Item5" />
-      <Member Name="get_Item6" />
-      <Member Name="GetHashCode" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="Item1" />
-      <Member MemberType="Property" Name="Item2" />
-      <Member MemberType="Property" Name="Item3" />
-      <Member MemberType="Property" Name="Item4" />
-      <Member MemberType="Property" Name="Item5" />
-      <Member MemberType="Property" Name="Item6" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.IComparable.CompareTo(System.Object)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Item(System.Int32)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Length" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Item(System.Int32)" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Length" />
-    </Type>
-    <Type Name="System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7&gt;">
-      <Member Name="#ctor(T1,T2,T3,T4,T5,T6,T7)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_Item1" />
-      <Member Name="get_Item2" />
-      <Member Name="get_Item3" />
-      <Member Name="get_Item4" />
-      <Member Name="get_Item5" />
-      <Member Name="get_Item6" />
-      <Member Name="get_Item7" />
-      <Member Name="GetHashCode" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="Item1" />
-      <Member MemberType="Property" Name="Item2" />
-      <Member MemberType="Property" Name="Item3" />
-      <Member MemberType="Property" Name="Item4" />
-      <Member MemberType="Property" Name="Item5" />
-      <Member MemberType="Property" Name="Item6" />
-      <Member MemberType="Property" Name="Item7" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.IComparable.CompareTo(System.Object)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Item(System.Int32)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Length" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Item(System.Int32)" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Length" />
-    </Type>
-    <Type Name="System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,TRest&gt;">
-      <Member Name="#ctor(T1,T2,T3,T4,T5,T6,T7,TRest)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_Item1" />
-      <Member Name="get_Item2" />
-      <Member Name="get_Item3" />
-      <Member Name="get_Item4" />
-      <Member Name="get_Item5" />
-      <Member Name="get_Item6" />
-      <Member Name="get_Item7" />
-      <Member Name="get_Rest" />
-      <Member Name="GetHashCode" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="Item1" />
-      <Member MemberType="Property" Name="Item2" />
-      <Member MemberType="Property" Name="Item3" />
-      <Member MemberType="Property" Name="Item4" />
-      <Member MemberType="Property" Name="Item5" />
-      <Member MemberType="Property" Name="Item6" />
-      <Member MemberType="Property" Name="Item7" />
-      <Member MemberType="Property" Name="Rest" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.IComparable.CompareTo(System.Object)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Item(System.Int32)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Length" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Item(System.Int32)" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Length" />
-    </Type>
-    <Type Name="System.TupleExtensions">
-      <Member Name="Deconstruct&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11,T12,T13,T14,System.Tuple&lt;T15,T16,T17,T18,T19,T20,T21&gt;&gt;&gt;,T1@,T2@,T3@,T4@,T5@,T6@,T7@,T8@,T9@,T10@,T11@,T12@,T13@,T14@,T15@,T16@,T17@,T18@,T19@,T20@,T21@)" />
-      <Member Name="Deconstruct&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11,T12,T13,T14,System.Tuple&lt;T15,T16,T17,T18,T19,T20&gt;&gt;&gt;,T1@,T2@,T3@,T4@,T5@,T6@,T7@,T8@,T9@,T10@,T11@,T12@,T13@,T14@,T15@,T16@,T17@,T18@,T19@,T20@)" />
-      <Member Name="Deconstruct&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11,T12,T13,T14,System.Tuple&lt;T15,T16,T17,T18,T19&gt;&gt;&gt;,T1@,T2@,T3@,T4@,T5@,T6@,T7@,T8@,T9@,T10@,T11@,T12@,T13@,T14@,T15@,T16@,T17@,T18@,T19@)" />
-      <Member Name="Deconstruct&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11,T12,T13,T14,System.Tuple&lt;T15,T16,T17,T18&gt;&gt;&gt;,T1@,T2@,T3@,T4@,T5@,T6@,T7@,T8@,T9@,T10@,T11@,T12@,T13@,T14@,T15@,T16@,T17@,T18@)" />
-      <Member Name="Deconstruct&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11,T12,T13,T14,System.Tuple&lt;T15,T16,T17&gt;&gt;&gt;,T1@,T2@,T3@,T4@,T5@,T6@,T7@,T8@,T9@,T10@,T11@,T12@,T13@,T14@,T15@,T16@,T17@)" />
-      <Member Name="Deconstruct&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11,T12,T13,T14,System.Tuple&lt;T15,T16&gt;&gt;&gt;,T1@,T2@,T3@,T4@,T5@,T6@,T7@,T8@,T9@,T10@,T11@,T12@,T13@,T14@,T15@,T16@)" />
-      <Member Name="Deconstruct&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11,T12,T13,T14,System.Tuple&lt;T15&gt;&gt;&gt;,T1@,T2@,T3@,T4@,T5@,T6@,T7@,T8@,T9@,T10@,T11@,T12@,T13@,T14@,T15@)" />
-      <Member Name="Deconstruct&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11,T12,T13,T14&gt;&gt;,T1@,T2@,T3@,T4@,T5@,T6@,T7@,T8@,T9@,T10@,T11@,T12@,T13@,T14@)" />
-      <Member Name="Deconstruct&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11,T12,T13&gt;&gt;,T1@,T2@,T3@,T4@,T5@,T6@,T7@,T8@,T9@,T10@,T11@,T12@,T13@)" />
-      <Member Name="Deconstruct&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11,T12&gt;&gt;,T1@,T2@,T3@,T4@,T5@,T6@,T7@,T8@,T9@,T10@,T11@,T12@)" />
-      <Member Name="Deconstruct&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11&gt;&gt;,T1@,T2@,T3@,T4@,T5@,T6@,T7@,T8@,T9@,T10@,T11@)" />
-      <Member Name="Deconstruct&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10&gt;&gt;,T1@,T2@,T3@,T4@,T5@,T6@,T7@,T8@,T9@,T10@)" />
-      <Member Name="Deconstruct&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9&gt;&gt;,T1@,T2@,T3@,T4@,T5@,T6@,T7@,T8@,T9@)" />
-      <Member Name="Deconstruct&lt;T1,T2,T3,T4,T5,T6,T7,T8&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8&gt;&gt;,T1@,T2@,T3@,T4@,T5@,T6@,T7@,T8@)" />
-      <Member Name="Deconstruct&lt;T1,T2,T3,T4,T5,T6,T7&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7&gt;,T1@,T2@,T3@,T4@,T5@,T6@,T7@)" />
-      <Member Name="Deconstruct&lt;T1,T2,T3,T4,T5,T6&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6&gt;,T1@,T2@,T3@,T4@,T5@,T6@)" />
-      <Member Name="Deconstruct&lt;T1,T2,T3,T4,T5&gt;(System.Tuple&lt;T1,T2,T3,T4,T5&gt;,T1@,T2@,T3@,T4@,T5@)" />
-      <Member Name="Deconstruct&lt;T1,T2,T3,T4&gt;(System.Tuple&lt;T1,T2,T3,T4&gt;,T1@,T2@,T3@,T4@)" />
-      <Member Name="Deconstruct&lt;T1,T2,T3&gt;(System.Tuple&lt;T1,T2,T3&gt;,T1@,T2@,T3@)" />
-      <Member Name="Deconstruct&lt;T1,T2&gt;(System.Tuple&lt;T1,T2&gt;,T1@,T2@)" />
-      <Member Name="Deconstruct&lt;T1&gt;(System.Tuple&lt;T1&gt;,T1@)" />
-      <Member Name="ToTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21&gt;(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,System.ValueTuple&lt;T8,T9,T10,T11,T12,T13,T14,System.ValueTuple&lt;T15,T16,T17,T18,T19,T20,T21&gt;&gt;&gt;)" />
-      <Member Name="ToTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20&gt;(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,System.ValueTuple&lt;T8,T9,T10,T11,T12,T13,T14,System.ValueTuple&lt;T15,T16,T17,T18,T19,T20&gt;&gt;&gt;)" />
-      <Member Name="ToTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19&gt;(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,System.ValueTuple&lt;T8,T9,T10,T11,T12,T13,T14,System.ValueTuple&lt;T15,T16,T17,T18,T19&gt;&gt;&gt;)" />
-      <Member Name="ToTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18&gt;(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,System.ValueTuple&lt;T8,T9,T10,T11,T12,T13,T14,System.ValueTuple&lt;T15,T16,T17,T18&gt;&gt;&gt;)" />
-      <Member Name="ToTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17&gt;(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,System.ValueTuple&lt;T8,T9,T10,T11,T12,T13,T14,System.ValueTuple&lt;T15,T16,T17&gt;&gt;&gt;)" />
-      <Member Name="ToTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16&gt;(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,System.ValueTuple&lt;T8,T9,T10,T11,T12,T13,T14,System.ValueTuple&lt;T15,T16&gt;&gt;&gt;)" />
-      <Member Name="ToTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15&gt;(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,System.ValueTuple&lt;T8,T9,T10,T11,T12,T13,T14,System.ValueTuple&lt;T15&gt;&gt;&gt;)" />
-      <Member Name="ToTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14&gt;(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,System.ValueTuple&lt;T8,T9,T10,T11,T12,T13,T14&gt;&gt;)" />
-      <Member Name="ToTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13&gt;(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,System.ValueTuple&lt;T8,T9,T10,T11,T12,T13&gt;&gt;)" />
-      <Member Name="ToTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12&gt;(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,System.ValueTuple&lt;T8,T9,T10,T11,T12&gt;&gt;)" />
-      <Member Name="ToTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11&gt;(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,System.ValueTuple&lt;T8,T9,T10,T11&gt;&gt;)" />
-      <Member Name="ToTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10&gt;(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,System.ValueTuple&lt;T8,T9,T10&gt;&gt;)" />
-      <Member Name="ToTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9&gt;(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,System.ValueTuple&lt;T8,T9&gt;&gt;)" />
-      <Member Name="ToTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8&gt;(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,System.ValueTuple&lt;T8&gt;&gt;)" />
-      <Member Name="ToTuple&lt;T1,T2,T3,T4,T5,T6,T7&gt;(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6,T7&gt;)" />
-      <Member Name="ToTuple&lt;T1,T2,T3,T4,T5,T6&gt;(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6&gt;)" />
-      <Member Name="ToTuple&lt;T1,T2,T3,T4,T5&gt;(System.ValueTuple&lt;T1,T2,T3,T4,T5&gt;)" />
-      <Member Name="ToTuple&lt;T1,T2,T3,T4&gt;(System.ValueTuple&lt;T1,T2,T3,T4&gt;)" />
-      <Member Name="ToTuple&lt;T1,T2,T3&gt;(System.ValueTuple&lt;T1,T2,T3&gt;)" />
-      <Member Name="ToTuple&lt;T1,T2&gt;(System.ValueTuple&lt;T1,T2&gt;)" />
-      <Member Name="ToTuple&lt;T1&gt;(System.ValueTuple&lt;T1&gt;)" />
-      <Member Name="ToValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11,T12,T13,T14,System.Tuple&lt;T15,T16,T17,T18,T19,T20,T21&gt;&gt;&gt;)" />
-      <Member Name="ToValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11,T12,T13,T14,System.Tuple&lt;T15,T16,T17,T18,T19,T20&gt;&gt;&gt;)" />
-      <Member Name="ToValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11,T12,T13,T14,System.Tuple&lt;T15,T16,T17,T18,T19&gt;&gt;&gt;)" />
-      <Member Name="ToValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11,T12,T13,T14,System.Tuple&lt;T15,T16,T17,T18&gt;&gt;&gt;)" />
-      <Member Name="ToValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11,T12,T13,T14,System.Tuple&lt;T15,T16,T17&gt;&gt;&gt;)" />
-      <Member Name="ToValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11,T12,T13,T14,System.Tuple&lt;T15,T16&gt;&gt;&gt;)" />
-      <Member Name="ToValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11,T12,T13,T14,System.Tuple&lt;T15&gt;&gt;&gt;)" />
-      <Member Name="ToValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11,T12,T13,T14&gt;&gt;)" />
-      <Member Name="ToValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11,T12,T13&gt;&gt;)" />
-      <Member Name="ToValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11,T12&gt;&gt;)" />
-      <Member Name="ToValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10,T11&gt;&gt;)" />
-      <Member Name="ToValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9,T10&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9,T10&gt;&gt;)" />
-      <Member Name="ToValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8,T9&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8,T9&gt;&gt;)" />
-      <Member Name="ToValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,T8&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7,System.Tuple&lt;T8&gt;&gt;)" />
-      <Member Name="ToValueTuple&lt;T1,T2,T3,T4,T5,T6,T7&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6,T7&gt;)" />
-      <Member Name="ToValueTuple&lt;T1,T2,T3,T4,T5,T6&gt;(System.Tuple&lt;T1,T2,T3,T4,T5,T6&gt;)" />
-      <Member Name="ToValueTuple&lt;T1,T2,T3,T4,T5&gt;(System.Tuple&lt;T1,T2,T3,T4,T5&gt;)" />
-      <Member Name="ToValueTuple&lt;T1,T2,T3,T4&gt;(System.Tuple&lt;T1,T2,T3,T4&gt;)" />
-      <Member Name="ToValueTuple&lt;T1,T2,T3&gt;(System.Tuple&lt;T1,T2,T3&gt;)" />
-      <Member Name="ToValueTuple&lt;T1,T2&gt;(System.Tuple&lt;T1,T2&gt;)" />
-      <Member Name="ToValueTuple&lt;T1&gt;(System.Tuple&lt;T1&gt;)" />
-    </Type>
-    <Type Name="System.Type">
-      <Member Name="#ctor" />
-      <Member Name="op_Equality(System.Type,System.Type)" />
-      <Member Name="op_Inequality(System.Type,System.Type)" />
-      <Member MemberType="Field" Name="Delimiter" />
-      <Member MemberType="Field" Name="EmptyTypes" />
-      <Member MemberType="Field" Name="FilterAttribute" />
-      <Member MemberType="Field" Name="FilterName" />
-      <Member MemberType="Field" Name="FilterNameIgnoreCase" />
-      <Member MemberType="Field" Name="Missing" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.Type)" />
-      <Member Name="FindMembers(System.Reflection.MemberTypes,System.Reflection.BindingFlags,System.Reflection.MemberFilter,System.Object)" />
-      <Member Name="get_Assembly" />
-      <Member Name="get_AssemblyQualifiedName" />
-      <Member Name="get_Attributes" />
-      <Member Name="get_BaseType" />
-      <Member Name="get_ContainsGenericParameters" />
-      <Member Name="get_DeclaringType" />
-      <Member Name="get_DeclaringMethod" />
-      <Member Name="get_DefaultBinder" />
-      <Member Name="get_FullName" />
-      <Member Name="get_GenericParameterAttributes" />
-      <Member Name="get_GenericParameterPosition" />
-      <Member Name="get_GenericTypeArguments" />
-      <Member Name="get_GUID" />
-      <Member Name="get_HasElementType" />
-      <Member Name="get_IsAbstract" />
-      <Member Name="get_IsAnsiClass" />
-      <Member Name="get_IsArray" />
-      <Member Name="get_IsAutoClass" />
-      <Member Name="get_IsAutoLayout" />
-      <Member Name="get_IsByRef" />
-      <Member Name="get_IsConstructedGenericType" />
-      <Member Name="get_IsClass" />
-      <Member Name="get_IsCOMObject" />
-      <Member Name="get_IsEnum" />
-      <Member Name="get_IsExplicitLayout" />
-      <Member Name="get_IsGenericParameter" />
-      <Member Name="get_IsGenericType" />
-      <Member Name="get_IsGenericTypeDefinition" />
-      <Member Name="get_IsImport" />
-      <Member Name="get_IsInterface" />
-      <Member Name="get_IsLayoutSequential" />
-      <Member Name="get_IsMarshalByRef" />
-      <Member Name="get_IsNested" />
-      <Member Name="get_IsNestedAssembly" />
-      <Member Name="get_IsNestedFamANDAssem" />
-      <Member Name="get_IsNestedFamily" />
-      <Member Name="get_IsNestedFamORAssem" />
-      <Member Name="get_IsNestedPrivate" />
-      <Member Name="get_IsNestedPublic" />
-      <Member Name="get_IsNotPublic" />
-      <Member Name="get_IsPointer" />
-      <Member Name="get_IsPrimitive" />
-      <Member Name="get_IsPublic" />
-      <Member Name="get_IsSealed" />
-      <Member Name="get_IsSecurityCritical" />
-      <Member Name="get_IsSecuritySafeCritical" />
-      <Member Name="get_IsSecurityTransparent" />      
-      <Member Name="get_IsSerializable" />
-      <Member Name="get_IsSpecialName" />
-      <Member Name="get_IsUnicodeClass" />
-      <Member Name="get_IsValueType" />
-      <Member Name="get_IsVisible" />
-      <Member Name="get_MemberType" />
-      <Member Name="get_Module" />
-      <Member Name="get_Namespace" />
-      <Member Name="get_ReflectedType" />
-      <Member Name="get_TypeHandle" />
-      <Member Name="get_UnderlyingSystemType" />
-      <Member Name="GetArrayRank" />
-      <Member Name="GetAttributeFlagsImpl" />
-      <Member Name="GetConstructor(System.Reflection.BindingFlags,System.Reflection.Binder,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetConstructor(System.Reflection.BindingFlags,System.Reflection.Binder,System.Reflection.CallingConventions,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetConstructor(System.Type[])" />
-      <Member Name="GetConstructorImpl(System.Reflection.BindingFlags,System.Reflection.Binder,System.Reflection.CallingConventions,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetConstructors" />
-      <Member Name="GetConstructors(System.Reflection.BindingFlags)" />
-      <Member Name="GetDefaultMembers" />
-      <Member Name="GetElementType" />
-      <Member Name="GetEvent(System.String)" />
-      <Member Name="GetEvent(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetEvents" />
-      <Member Name="GetEvents(System.Reflection.BindingFlags)" />
-      <Member Name="GetField(System.String)" />
-      <Member Name="GetField(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetFields" />
-      <Member Name="GetFields(System.Reflection.BindingFlags)" />
-      <Member Name="GetGenericArguments" />
-      <Member Name="GetGenericParameterConstraints" />
-      <Member Name="GetGenericTypeDefinition" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetInterface(System.String,System.Boolean)" />
-      <Member Name="GetInterfaceMap(System.Type)" />
-      <Member Name="GetInterfaces" />
-      <Member Name="GetMember(System.String)" />
-      <Member Name="GetMember(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetMember(System.String,System.Reflection.MemberTypes,System.Reflection.BindingFlags)" />
-      <Member Name="GetMembers" />
-      <Member Name="GetMembers(System.Reflection.BindingFlags)" />
-      <Member Name="GetMethod(System.String)" />
-      <Member Name="GetMethod(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetMethod(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Reflection.CallingConventions,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetMethod(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetMethod(System.String,System.Type[])" />
-      <Member Name="GetMethod(System.String,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetMethodImpl(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Reflection.CallingConventions,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetMethods" />
-      <Member Name="GetMethods(System.Reflection.BindingFlags)" />
-      <Member Name="GetNestedType(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetNestedTypes(System.Reflection.BindingFlags)" />
-      <Member Name="GetProperties" />
-      <Member Name="GetProperties(System.Reflection.BindingFlags)" />
-      <Member Name="GetProperty(System.String)" />
-      <Member Name="GetProperty(System.String,System.Reflection.BindingFlags)" />
-      <Member Name="GetProperty(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Type,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetProperty(System.String,System.Type)" />
-      <Member Name="GetProperty(System.String,System.Type,System.Type[])" />
-      <Member Name="GetProperty(System.String,System.Type,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetPropertyImpl(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Type,System.Type[],System.Reflection.ParameterModifier[])" />
-      <Member Name="GetType" />
-      <Member Name="GetType(System.String)" />
-      <Member Name="GetType(System.String,System.Boolean)" />
-      <Member Name="GetType(System.String,System.Boolean,System.Boolean)" />
-      <Member Name="GetType(System.String,System.Func&lt;System.Reflection.AssemblyName,System.Reflection.Assembly&gt;,System.Func&lt;System.Reflection.Assembly,System.String,System.Boolean,System.Type&gt;)" />
-      <Member Name="GetType(System.String,System.Func&lt;System.Reflection.AssemblyName,System.Reflection.Assembly&gt;,System.Func&lt;System.Reflection.Assembly,System.String,System.Boolean,System.Type&gt;,System.Boolean)" />
-      <Member Name="GetType(System.String,System.Func&lt;System.Reflection.AssemblyName,System.Reflection.Assembly&gt;,System.Func&lt;System.Reflection.Assembly,System.String,System.Boolean,System.Type&gt;,System.Boolean,System.Boolean)" />
-      <Member Name="GetTypeArray(System.Object[])" />
-      <Member Name="GetTypeCode(System.Type)" />
-      <Member Name="GetTypeCodeImpl" />
-      <Member Name="GetTypeFromCLSID(System.Guid)" />
-      <Member Name="GetTypeFromCLSID(System.Guid,System.Boolean)" />
-      <Member Name="GetTypeFromCLSID(System.Guid,System.String)" />
-      <Member Name="GetTypeFromCLSID(System.Guid,System.String,System.Boolean)" />
-      <Member Name="GetTypeFromHandle(System.RuntimeTypeHandle)" />
-      <Member Status="ImplRoot" Name="GetTypeFromHandleUnsafe(System.IntPtr)" /> <!-- Used by System.Linq.Expressions tests -->
-      <Member Name="GetTypeFromProgID(System.String)" />
-      <Member Name="GetTypeFromProgID(System.String,System.Boolean)" />
-      <Member Name="GetTypeFromProgID(System.String,System.String)" />
-      <Member Name="GetTypeFromProgID(System.String,System.String,System.Boolean)" />
-      <Member Name="GetTypeHandle(System.Object)" />
-      <Member Name="HasElementTypeImpl" />
-      <Member Name="InvokeMember(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object,System.Object[])" />
-      <Member Name="InvokeMember(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object,System.Object[],System.Globalization.CultureInfo)" />
-      <Member Name="InvokeMember(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object,System.Object[],System.Reflection.ParameterModifier[],System.Globalization.CultureInfo,System.String[])" />
-      <Member Name="IsArrayImpl" />
-      <Member Name="IsAssignableFrom(System.Type)" />
-      <Member Name="IsByRefImpl" />
-      <Member Name="IsCOMObjectImpl" />
-      <Member Name="get_IsContextful" />
-      <Member MemberType="Property" Name="IsContextful" />
-      <Member Name="IsContextfulImpl" />
-      <Member Name="IsInstanceOfType(System.Object)" />
-      <Member Name="IsMarshalByRefImpl" />
-      <Member Name="IsPointerImpl" />
-      <Member Name="IsPrimitiveImpl" />
-      <Member Name="IsSubclassOf(System.Type)" />
-      <Member Name="IsEquivalentTo(System.Type)" />
-      <Member Name="IsValueTypeImpl" />
-      <Member Name="MakeArrayType" />
-      <Member Name="MakeArrayType(System.Int32)" />
-      <Member Name="MakeByRefType" />
-      <Member Name="MakeGenericType(System.Type[])" />
-      <Member Name="MakePointerType" />
-      <Member Name="ReflectionOnlyGetType(System.String,System.Boolean,System.Boolean)" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="Assembly" />
-      <Member MemberType="Property" Name="AssemblyQualifiedName" />
-      <Member MemberType="Property" Name="Attributes" />
-      <Member MemberType="Property" Name="BaseType" />
-      <Member MemberType="Property" Name="ContainsGenericParameters" />
-      <Member MemberType="Property" Name="DeclaringType" />
-      <Member MemberType="Property" Name="DeclaringMethod" />
-      <Member MemberType="Property" Name="DefaultBinder" />
-      <Member MemberType="Property" Name="FullName" />
-      <Member MemberType="Property" Name="GenericParameterAttributes" />
-      <Member MemberType="Property" Name="GenericParameterPosition" />
-      <Member MemberType="Property" Name="GenericTypeArguments" />
-      <Member MemberType="Property" Name="GUID" />
-      <Member MemberType="Property" Name="HasElementType" />
-      <Member MemberType="Property" Name="IsAbstract" />
-      <Member MemberType="Property" Name="IsAnsiClass" />
-      <Member MemberType="Property" Name="IsArray" />
-      <Member MemberType="Property" Name="IsAutoClass" />
-      <Member MemberType="Property" Name="IsAutoLayout" />
-      <Member MemberType="Property" Name="IsByRef" />
-      <Member MemberType="Property" Name="IsConstructedGenericType" />
-      <Member MemberType="Property" Name="IsClass" />
-      <Member MemberType="Property" Name="IsCOMObject" />
-      <Member MemberType="Property" Name="IsEnum" />
-      <Member MemberType="Property" Name="IsExplicitLayout" />
-      <Member MemberType="Property" Name="IsGenericParameter" />
-      <Member MemberType="Property" Name="IsGenericType" />
-      <Member MemberType="Property" Name="IsGenericTypeDefinition" />
-      <Member MemberType="Property" Name="IsImport" />
-      <Member MemberType="Property" Name="IsInterface" />
-      <Member MemberType="Property" Name="IsLayoutSequential" />
-      <Member MemberType="Property" Name="IsMarshalByRef" />
-      <Member MemberType="Property" Name="IsNested" />
-      <Member MemberType="Property" Name="IsNestedAssembly" />
-      <Member MemberType="Property" Name="IsNestedFamANDAssem" />
-      <Member MemberType="Property" Name="IsNestedFamily" />
-      <Member MemberType="Property" Name="IsNestedFamORAssem" />
-      <Member MemberType="Property" Name="IsNestedPrivate" />
-      <Member MemberType="Property" Name="IsNestedPublic" />
-      <Member MemberType="Property" Name="IsNotPublic" />
-      <Member MemberType="Property" Name="IsPointer" />
-      <Member MemberType="Property" Name="IsPrimitive" />
-      <Member MemberType="Property" Name="IsPublic" />
-      <Member MemberType="Property" Name="IsSealed" />
-      <Member MemberType="Property" Name="IsSerializable" />
-      <Member MemberType="Property" Name="IsSpecialName" />
-      <Member MemberType="Property" Name="IsUnicodeClass" />
-      <Member MemberType="Property" Name="IsValueType" />
-      <Member MemberType="Property" Name="IsVisible" />
-      <Member MemberType="Property" Name="MemberType" />
-      <Member MemberType="Property" Name="Module" />
-      <Member MemberType="Property" Name="Namespace" />
-      <Member MemberType="Property" Name="ReflectedType" />
-      <Member MemberType="Property" Name="TypeHandle" />
-      <Member MemberType="Property" Name="UnderlyingSystemType" />
-	  <Member Name="GetEnumName(System.Object)" />
-      <Member Name="GetEnumNames" />
-      <Member Name="GetEnumUnderlyingType" />
-      <Member Name="GetEnumValues" />
-      <Member Name="GetInterface(System.String)" />
-      <Member Name="GetNestedType(System.String)" />
-      <Member Name="GetNestedTypes" />
-      <Member Name="GetProperty(System.String,System.Type[])" />
-      <Member Name="IsEnumDefined(System.Object)" />
-      <Member Name="get_StructLayoutAttribute" />
-      <Member Name="get_TypeInitializer" />
-      <Member Name="FindInterfaces(System.Reflection.TypeFilter,System.Object)" />
-	  <Member MemberType="Property" Name="TypeInitializer" />
-      <Member MemberType="Property" Name="StructLayoutAttribute" />
-    </Type>
-    <Type Name="System.TypeAccessException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.TypeCode">
-      <Member MemberType="Field" Name="Boolean" />
-      <Member MemberType="Field" Name="Byte" />
-      <Member MemberType="Field" Name="Char" />
-      <Member MemberType="Field" Name="DateTime" />
-      <Member MemberType="Field" Name="DBNull" />
-      <Member MemberType="Field" Name="Decimal" />
-      <Member MemberType="Field" Name="Double" />
-      <Member MemberType="Field" Name="Empty" />
-      <Member MemberType="Field" Name="Int16" />
-      <Member MemberType="Field" Name="Int32" />
-      <Member MemberType="Field" Name="Int64" />
-      <Member MemberType="Field" Name="Object" />
-      <Member MemberType="Field" Name="SByte" />
-      <Member MemberType="Field" Name="Single" />
-      <Member MemberType="Field" Name="String" />
-      <Member MemberType="Field" Name="UInt16" />
-      <Member MemberType="Field" Name="UInt32" />
-      <Member MemberType="Field" Name="UInt64" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.TypeInitializationException" >
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="get_TypeName" />
-      <Member MemberType="Property" Name="TypeName" />
-    </Type>
-    <Type Name="System.TypedReference" />
-    <Type Name="System.TypeLoadException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Status="ImplRoot" Name="#ctor(System.String,System.String,System.String,System.Int32)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="get_TypeName" />
-      <Member MemberType="Property" Name="TypeName" />
-    </Type>
-    <Type Name="System.TypeUnloadedException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-    </Type>
-    <Type Name="System.UInt16">
-      <Member MemberType="Field" Name="MaxValue" />
-      <Member MemberType="Field" Name="MinValue" />
-      <Member Name="CompareTo(System.Object)" />
-      <Member Name="CompareTo(System.UInt16)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.UInt16)" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetTypeCode" />
-      <Member Name="Parse(System.String)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)" />
-      <Member Name="Parse(System.String,System.IFormatProvider)" />
-      <Member Name="TryParse(System.String,System.UInt16@)" />
-      <Member Name="TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.UInt16@)" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.IFormatProvider)" />
-      <Member Name="ToString(System.String)" />
-      <Member Name="ToString(System.String,System.IFormatProvider)" />
-    </Type>
-    <Type Name="System.UInt32">
-      <Member MemberType="Field" Name="MaxValue" />
-      <Member MemberType="Field" Name="MinValue" />
-      <Member Name="CompareTo(System.Object)" />
-      <Member Name="CompareTo(System.UInt32)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.UInt32)" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetTypeCode" />
-      <Member Name="Parse(System.String)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)" />
-      <Member Name="Parse(System.String,System.IFormatProvider)" />
-      <Member Name="TryParse(System.String,System.UInt32@)" />
-      <Member Name="TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.UInt32@)" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.IFormatProvider)" />
-      <Member Name="ToString(System.String)" />
-      <Member Name="ToString(System.String,System.IFormatProvider)" />
-    </Type>
-    <Type Name="System.UInt64">
-      <Member MemberType="Field" Name="MaxValue" />
-      <Member MemberType="Field" Name="MinValue" />
-      <Member Name="CompareTo(System.Object)" />
-      <Member Name="CompareTo(System.UInt64)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.UInt64)" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetTypeCode" />
-      <Member Name="Parse(System.String)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles)" />
-      <Member Name="Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)" />
-      <Member Name="Parse(System.String,System.IFormatProvider)" />
-      <Member Name="TryParse(System.String,System.UInt64@)" />
-      <Member Name="TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.UInt64@)" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.IFormatProvider)" />
-      <Member Name="ToString(System.String)" />
-      <Member Name="ToString(System.String,System.IFormatProvider)" />
-    </Type>
-    <Type Name="System.UIntPtr">
-      <Member MemberType="Field" Name="Zero" />
-      <Member Name="#ctor(System.UInt32)" />
-      <Member Name="#ctor(System.UInt64)" />
-      <Member Name="#ctor(System.Void*)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="Add(System.UIntPtr,System.Int32)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="get_Size" />
-      <Member Name="GetHashCode" />
-      <Member Name="op_Addition(System.UIntPtr,System.Int32)" />
-      <Member Name="op_Equality(System.UIntPtr,System.UIntPtr)" />
-      <Member Name="op_Explicit(System.UInt32)" ReturnType="System.UIntPtr" />
-      <Member Name="op_Explicit(System.UInt64)" ReturnType="System.UIntPtr" />
-      <Member Name="op_Explicit(System.UIntPtr)" ReturnType="System.UInt32" />
-      <Member Name="op_Explicit(System.UIntPtr)" ReturnType="System.UInt64" />
-      <Member Name="op_Explicit(System.UIntPtr)" ReturnType="System.Void*" />
-      <Member Name="op_Explicit(System.Void*)" ReturnType="System.UIntPtr" />
-      <Member Name="op_Inequality(System.UIntPtr,System.UIntPtr)" />
-      <Member Name="op_Subtraction(System.UIntPtr,System.Int32)" />
-      <Member Name="Subtract(System.UIntPtr,System.Int32)" />
-      <Member Name="ToPointer" />
-      <Member Name="ToString" />
-      <Member Name="ToUInt32" />
-      <Member Name="ToUInt64" />
-      <Member MemberType="Property" Name="Size" />
-    </Type>
-    <Type Name="System.UnauthorizedAccessException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.UnhandledExceptionEventArgs">
-      <Member Name="#ctor(System.Object,System.Boolean)" />
-      <Member Name="get_ExceptionObject" />
-      <Member Name="get_IsTerminating" />
-      <Member MemberType="Property" Name="ExceptionObject" />
-      <Member MemberType="Property" Name="IsTerminating" />
-    </Type>
-    <Type Name="System.UnhandledExceptionEventHandler">
-      <Member Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Name="BeginInvoke(System.Object,System.UnhandledExceptionEventArgs,System.AsyncCallback,System.Object)" />
-      <Member Name="EndInvoke(System.IAsyncResult)" />
-      <Member Name="Invoke(System.Object,System.UnhandledExceptionEventArgs)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.UnitySerializationHolder">
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.ValueType">
-      <Member Name="#ctor" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetHashCode" />
-    </Type>
-    <Type Name="System.Variant" Condition="FEATURE_COMINTEROP">
-      <Member Status="ImplRoot" MemberType="Field" Name="m_objref" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_data1" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_data2" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_flags" />
-      <Member Status="ImplRoot" Name="MarshalHelperConvertObjectToVariant(System.Object,System.Variant@)" />
-      <Member Status="ImplRoot" Name="MarshalHelperCastVariant(System.Object,System.Int32,System.Variant@)" />
-      <Member Status="ImplRoot" Name="MarshalHelperConvertVariantToObject(System.Variant@)" />
-    </Type>
-    <Type Name="System.Version">
-      <Member Name="#ctor(System.Int32,System.Int32)" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor" />
-      <Member Name="Clone" />
-      <Member Name="CompareTo(System.Object)" />
-      <Member Name="CompareTo(System.Version)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.Version)" />
-      <Member Name="get_Build" />
-      <Member Name="get_Major" />
-      <Member Name="get_MajorRevision" />
-      <Member Name="get_Minor" />
-      <Member Name="get_MinorRevision" />
-      <Member Name="get_Revision" />
-      <Member Name="GetHashCode" />
-      <Member Name="op_Equality(System.Version,System.Version)" />
-      <Member Name="op_GreaterThan(System.Version,System.Version)" />
-      <Member Name="op_GreaterThanOrEqual(System.Version,System.Version)" />
-      <Member Name="op_Inequality(System.Version,System.Version)" />
-      <Member Name="op_LessThan(System.Version,System.Version)" />
-      <Member Name="op_LessThanOrEqual(System.Version,System.Version)" />
-      <Member Name="Parse(System.String)" />
-      <Member Name="ToString" />
-      <Member Name="ToString(System.Int32)" />
-      <Member Name="TryParse(System.String,System.Version@)" />
-      <Member MemberType="Property" Name="Build" />
-      <Member MemberType="Property" Name="Major" />
-      <Member MemberType="Property" Name="MajorRevision" />
-      <Member MemberType="Property" Name="Minor" />
-      <Member MemberType="Property" Name="MinorRevision" />
-      <Member MemberType="Property" Name="Revision" />
-    </Type>
-    <Type Name="System.Void" />
-    <Type Name="System.WeakReference">
-      <Member Name="#ctor(System.Object)" />
-      <Member Name="#ctor(System.Object,System.Boolean)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="#ctor" />
-      <Member Name="get_IsAlive" />
-      <Member Name="get_Target" />
-      <Member Name="get_TrackResurrection" />
-      <Member Name="set_Target(System.Object)" />
-      <Member MemberType="Property" Name="IsAlive" />
-      <Member MemberType="Property" Name="Target" />
-      <Member MemberType="Property" Name="TrackResurrection" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.WeakReference&lt;T&gt;">
-      <Member Name="#ctor(T)" />
-      <Member Name="#ctor(T,System.Boolean)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="SetTarget(T)" />
-      <Member Name="TryGetTarget(T@)" />
-      <Member Status="ImplRoot" Name="Finalize" />
-    </Type>
-<!-- SMOSIER ADDED API ROOTS FOR C# -->
-    <Type Name="System.Runtime.CompilerServices.RuntimeCompatibilityAttribute">
-      <Member MemberType="Property" Name="WrapNonExceptionThrows" />
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.AsyncStateMachineAttribute">
-      <Member Name="#ctor(System.Type)" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.IteratorStateMachineAttribute">
-      <Member Name="#ctor(System.Type)" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.StateMachineAttribute">
-      <Member Name="#ctor(System.Type)" />
-      <Member Name="get_StateMachineType" />
-      <Member MemberType="Property" Name="StateMachineType" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.CallerFilePathAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.CallerLineNumberAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.CallerMemberNameAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.CompilerGeneratedAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.CompilerGlobalScopeAttribute">
-      <Member Name="#ctor" />
-    </Type>
-<!-- JCOUV ADDED API ROOTS FOR C# -->
-    <Type Name="System.Runtime.CompilerServices.ITuple">
-      <Member Name="get_Item(System.Int32)" />
-      <Member Name="get_Length" />
-      <Member MemberType="Property" Name="Item(System.Int32)" />
-      <Member MemberType="Property" Name="Length" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.TupleElementNamesAttribute">
-      <Member Name="#ctor(System.String[])" />
-      <Member Name="get_TransformNames" />
-      <Member MemberType="Property" Name="TransformNames" />
-    </Type>
-    <Type Name="System.ValueTuple">
-      <Member Name="CompareTo(System.ValueTuple)" />
-      <Member Name="Create" />
-      <Member Name="Create&lt;T1,T2,T3,T4,T5,T6,T7,T8&gt;(T1,T2,T3,T4,T5,T6,T7,T8)" />
-      <Member Name="Create&lt;T1,T2,T3,T4,T5,T6,T7&gt;(T1,T2,T3,T4,T5,T6,T7)" />
-      <Member Name="Create&lt;T1,T2,T3,T4,T5,T6&gt;(T1,T2,T3,T4,T5,T6)" />
-      <Member Name="Create&lt;T1,T2,T3,T4,T5&gt;(T1,T2,T3,T4,T5)" />
-      <Member Name="Create&lt;T1,T2,T3,T4&gt;(T1,T2,T3,T4)" />
-      <Member Name="Create&lt;T1,T2,T3&gt;(T1,T2,T3)" />
-      <Member Name="Create&lt;T1,T2&gt;(T1,T2)" />
-      <Member Name="Create&lt;T1&gt;(T1)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.ValueTuple)" />
-      <Member Name="GetHashCode" />
-      <Member Name="ToString" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.IComparable.CompareTo(System.Object)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Item(System.Int32)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Length" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Item(System.Int32)" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Length" />
-    </Type>
-    <Type Name="System.ValueTuple&lt;T1&gt;">
-      <Member MemberType="Field" Name="Item1" />
-      <Member Name="#ctor(T1)" />
-      <Member Name="CompareTo(System.ValueTuple&lt;T1&gt;)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.ValueTuple&lt;T1&gt;)" />
-      <Member Name="GetHashCode" />
-      <Member Name="ToString" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.IComparable.CompareTo(System.Object)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Item(System.Int32)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Length" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Item(System.Int32)" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Length" />
-    </Type>
-    <Type Name="System.ValueTuple&lt;T1,T2&gt;">
-      <Member MemberType="Field" Name="Item1" />
-      <Member MemberType="Field" Name="Item2" />
-      <Member Name="#ctor(T1,T2)" />
-      <Member Name="CompareTo(System.ValueTuple&lt;T1,T2&gt;)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.ValueTuple&lt;T1,T2&gt;)" />
-      <Member Name="GetHashCode" />
-      <Member Name="ToString" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.IComparable.CompareTo(System.Object)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Item(System.Int32)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Length" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Item(System.Int32)" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Length" />
-    </Type>
-    <Type Name="System.ValueTuple&lt;T1,T2,T3&gt;">
-      <Member MemberType="Field" Name="Item1" />
-      <Member MemberType="Field" Name="Item2" />
-      <Member MemberType="Field" Name="Item3" />
-      <Member Name="#ctor(T1,T2,T3)" />
-      <Member Name="CompareTo(System.ValueTuple&lt;T1,T2,T3&gt;)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.ValueTuple&lt;T1,T2,T3&gt;)" />
-      <Member Name="GetHashCode" />
-      <Member Name="ToString" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.IComparable.CompareTo(System.Object)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Item(System.Int32)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Length" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Item(System.Int32)" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Length" />
-    </Type>
-    <Type Name="System.ValueTuple&lt;T1,T2,T3,T4&gt;">
-      <Member MemberType="Field" Name="Item1" />
-      <Member MemberType="Field" Name="Item2" />
-      <Member MemberType="Field" Name="Item3" />
-      <Member MemberType="Field" Name="Item4" />
-      <Member Name="#ctor(T1,T2,T3,T4)" />
-      <Member Name="CompareTo(System.ValueTuple&lt;T1,T2,T3,T4&gt;)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.ValueTuple&lt;T1,T2,T3,T4&gt;)" />
-      <Member Name="GetHashCode" />
-      <Member Name="ToString" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.IComparable.CompareTo(System.Object)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Item(System.Int32)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Length" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Item(System.Int32)" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Length" />
-    </Type>
-    <Type Name="System.ValueTuple&lt;T1,T2,T3,T4,T5&gt;">
-      <Member MemberType="Field" Name="Item1" />
-      <Member MemberType="Field" Name="Item2" />
-      <Member MemberType="Field" Name="Item3" />
-      <Member MemberType="Field" Name="Item4" />
-      <Member MemberType="Field" Name="Item5" />
-      <Member Name="#ctor(T1,T2,T3,T4,T5)" />
-      <Member Name="CompareTo(System.ValueTuple&lt;T1,T2,T3,T4,T5&gt;)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.ValueTuple&lt;T1,T2,T3,T4,T5&gt;)" />
-      <Member Name="GetHashCode" />
-      <Member Name="ToString" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.IComparable.CompareTo(System.Object)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Item(System.Int32)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Length" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Item(System.Int32)" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Length" />
-    </Type>
-    <Type Name="System.ValueTuple&lt;T1,T2,T3,T4,T5,T6&gt;">
-      <Member MemberType="Field" Name="Item1" />
-      <Member MemberType="Field" Name="Item2" />
-      <Member MemberType="Field" Name="Item3" />
-      <Member MemberType="Field" Name="Item4" />
-      <Member MemberType="Field" Name="Item5" />
-      <Member MemberType="Field" Name="Item6" />
-      <Member Name="#ctor(T1,T2,T3,T4,T5,T6)" />
-      <Member Name="CompareTo(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6&gt;)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6&gt;)" />
-      <Member Name="GetHashCode" />
-      <Member Name="ToString" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.IComparable.CompareTo(System.Object)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Item(System.Int32)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Length" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Item(System.Int32)" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Length" />
-    </Type>
-    <Type Name="System.ValueTuple&lt;T1,T2,T3,T4,T5,T6,T7&gt;">
-      <Member MemberType="Field" Name="Item1" />
-      <Member MemberType="Field" Name="Item2" />
-      <Member MemberType="Field" Name="Item3" />
-      <Member MemberType="Field" Name="Item4" />
-      <Member MemberType="Field" Name="Item5" />
-      <Member MemberType="Field" Name="Item6" />
-      <Member MemberType="Field" Name="Item7" />
-      <Member Name="#ctor(T1,T2,T3,T4,T5,T6,T7)" />
-      <Member Name="CompareTo(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6,T7&gt;)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6,T7&gt;)" />
-      <Member Name="GetHashCode" />
-      <Member Name="ToString" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.IComparable.CompareTo(System.Object)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Item(System.Int32)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Length" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Item(System.Int32)" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Length" />
-    </Type>
-    <Type Name="System.ValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,TRest&gt;">
-      <Member MemberType="Field" Name="Item1" />
-      <Member MemberType="Field" Name="Item2" />
-      <Member MemberType="Field" Name="Item3" />
-      <Member MemberType="Field" Name="Item4" />
-      <Member MemberType="Field" Name="Item5" />
-      <Member MemberType="Field" Name="Item6" />
-      <Member MemberType="Field" Name="Item7" />
-      <Member MemberType="Field" Name="Rest" />
-      <Member Name="#ctor(T1,T2,T3,T4,T5,T6,T7,TRest)" />
-      <Member Name="CompareTo(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,TRest&gt;)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.ValueTuple&lt;T1,T2,T3,T4,T5,T6,T7,TRest&gt;)" />
-      <Member Name="GetHashCode" />
-      <Member Name="ToString" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer)" />
-      <Member Status="ImplRoot" Name="System.IComparable.CompareTo(System.Object)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Item(System.Int32)" />
-      <Member Status="ImplRoot" Name="System.Runtime.CompilerServices.ITuple.get_Length" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Item(System.Int32)" />
-      <Member Status="ImplRoot" MemberType="Property" Name="System.Runtime.CompilerServices.ITuple.Length" />
-    </Type>
-    <!-- SMOSIER ADDED API ROOTS FOR our build process -->
-    <Type Name="System.Runtime.InteropServices.ComVisibleAttribute">
-      <Member Name="#ctor(System.Boolean)" />
-      <Member Name="get_Value" />
-      <Member MemberType="Property" Name="Value" />
-    </Type>
-    <Type Name="System.Reflection.AssemblyFileVersionAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_Version" />
-      <Member MemberType="Property" Name="Version" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Security.Permissions.HostProtectionAttribute">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Security.Permissions.SecurityAction)" />
-      <Member Name="get_ExternalProcessMgmt" />
-      <Member Name="get_ExternalThreading" />
-      <Member Name="get_MayLeakOnAbort" />
-      <Member Name="get_Resources" />
-      <Member Name="get_SecurityInfrastructure" />
-      <Member Name="get_SelfAffectingProcessMgmt" />
-      <Member Name="get_SelfAffectingThreading" />
-      <Member Name="get_SharedState" />
-      <Member Name="get_Synchronization" />
-      <Member Name="get_UI" />
-      <Member Name="set_ExternalProcessMgmt(System.Boolean)" />
-      <Member Name="set_ExternalThreading(System.Boolean)" />
-      <Member Name="set_MayLeakOnAbort(System.Boolean)" />
-      <Member Name="set_Resources(System.Security.Permissions.HostProtectionResource)" />
-      <Member Name="set_SecurityInfrastructure(System.Boolean)" />
-      <Member Name="set_SelfAffectingProcessMgmt(System.Boolean)" />
-      <Member Name="set_SelfAffectingThreading(System.Boolean)" />
-      <Member Name="set_SharedState(System.Boolean)" />
-      <Member Name="set_Synchronization(System.Boolean)" />
-      <Member Name="set_UI(System.Boolean)" />
-      <Member MemberType="Property" Name="ExternalProcessMgmt" />
-      <Member MemberType="Property" Name="ExternalThreading" />
-      <Member MemberType="Property" Name="MayLeakOnAbort" />
-      <Member MemberType="Property" Name="Resources" />
-      <Member MemberType="Property" Name="SecurityInfrastructure" />
-      <Member MemberType="Property" Name="SelfAffectingProcessMgmt" />
-      <Member MemberType="Property" Name="SelfAffectingThreading" />
-      <Member MemberType="Property" Name="SharedState" />
-      <Member MemberType="Property" Name="Synchronization" />
-      <Member MemberType="Property" Name="UI" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Security.Permissions.HostProtectionResource" />
-    <Type Name="System.IO.BinaryReader">
-      <Member Name="#ctor(System.IO.Stream)" />
-      <Member Name="#ctor(System.IO.Stream,System.Text.Encoding)" />
-      <Member Name="#ctor(System.IO.Stream,System.Text.Encoding,System.Boolean)" />
-      <Member Name="Close" />
-      <Member Name="Dispose" />
-      <Member Name="Dispose(System.Boolean)" />
-      <Member Name="FillBuffer(System.Int32)" />
-      <Member Name="get_BaseStream" />
-      <Member Name="PeekChar" />
-      <Member Name="Read" />
-      <Member Name="Read7BitEncodedInt" />
-      <Member Name="Read(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="Read(System.Char[],System.Int32,System.Int32)" />
-      <Member Name="ReadBoolean" />
-      <Member Name="ReadByte" />
-      <Member Name="ReadBytes(System.Int32)" />
-      <Member Name="ReadChar" />
-      <Member Name="ReadChars(System.Int32)" />
-      <Member Name="ReadDecimal" />
-      <Member Name="ReadDouble" />
-      <Member Name="ReadInt16" />
-      <Member Name="ReadInt32" />
-      <Member Name="ReadInt64" />
-      <Member Name="ReadSByte" />
-      <Member Name="ReadSingle" />
-      <Member Name="ReadString" />
-      <Member Name="ReadUInt16" />
-      <Member Name="ReadUInt32" />
-      <Member Name="ReadUInt64" />
-      <Member MemberType="Property" Name="BaseStream" />
-    </Type>
-    <Type Name="System.IO.BinaryWriter">
-      <Member MemberType="Field" Name="Null" />
-      <Member MemberType="Field" Name="OutStream" />
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.IO.Stream)" />
-      <Member Name="#ctor(System.IO.Stream,System.Text.Encoding)" />
-      <Member Name="#ctor(System.IO.Stream,System.Text.Encoding,System.Boolean)" />
-      <Member Name="Close" />
-      <Member Name="Dispose" />
-      <Member Name="Dispose(System.Boolean)" />
-      <Member Name="Flush" />
-      <Member Name="get_BaseStream" />
-      <Member Name="Seek(System.Int32,System.IO.SeekOrigin)" />
-      <Member Name="Write(System.Boolean)" />
-      <Member Name="Write(System.Byte)" />
-      <Member Name="Write(System.Byte[])" />
-      <Member Name="Write(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="Write(System.Char)" />
-      <Member Name="Write(System.Char[])" />
-      <Member Name="Write(System.Char[],System.Int32,System.Int32)" />
-      <Member Name="Write(System.Decimal)" />
-      <Member Name="Write(System.Double)" />
-      <Member Name="Write(System.Int16)" />
-      <Member Name="Write(System.Int32)" />
-      <Member Name="Write(System.Int64)" />
-      <Member Name="Write(System.SByte)" />
-      <Member Name="Write(System.Single)" />
-      <Member Name="Write(System.String)" />
-      <Member Name="Write(System.UInt16)" />
-      <Member Name="Write(System.UInt32)" />
-      <Member Name="Write(System.UInt64)" />
-      <Member Name="Write7BitEncodedInt(System.Int32)" />
-      <Member MemberType="Property" Name="BaseStream" />
-    </Type>
-    <Type Name="System.IO.DirectoryNotFoundException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.IO.EndOfStreamException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.IO.FileNotFoundException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.String,System.String)" />
-      <Member Name="#ctor(System.String,System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="get_FileName" />
-      <Member Name="get_FusionLog" />
-      <Member MemberType="Property" Name="FileName" />
-      <Member MemberType="Property" Name="FusionLog" />
-      <Member Status="ImplRoot" Name="#ctor(System.String,System.String,System.Int32)" />
-    </Type>
-    <Type Name="System.IO.FileStream">
-      <Member Name="#ctor(System.IntPtr,System.IO.FileAccess)" />
-      <Member Name="#ctor(System.IntPtr,System.IO.FileAccess,System.Boolean)" />
-      <Member Name="#ctor(System.IntPtr,System.IO.FileAccess,System.Boolean,System.Int32)" />
-      <Member Name="#ctor(System.IntPtr,System.IO.FileAccess,System.Boolean,System.Int32,System.Boolean)" />
-      <Member Name="#ctor(Microsoft.Win32.SafeHandles.SafeFileHandle,System.IO.FileAccess)" />
-      <Member Name="#ctor(Microsoft.Win32.SafeHandles.SafeFileHandle,System.IO.FileAccess,System.Int32)" />
-      <Member Name="#ctor(Microsoft.Win32.SafeHandles.SafeFileHandle,System.IO.FileAccess,System.Int32,System.Boolean)" />
-      <Member Name="#ctor(System.String,System.IO.FileMode)" />
-      <Member Name="#ctor(System.String,System.IO.FileMode,System.IO.FileAccess)" />
-      <Member Name="#ctor(System.String,System.IO.FileMode,System.IO.FileAccess,System.IO.FileShare)" />
-      <Member Name="#ctor(System.String,System.IO.FileMode,System.IO.FileAccess,System.IO.FileShare,System.Int32)" />
-      <Member Name="#ctor(System.String,System.IO.FileMode,System.IO.FileAccess,System.IO.FileShare,System.Int32,System.Boolean)" />
-      <Member Name="#ctor(System.String,System.IO.FileMode,System.IO.FileAccess,System.IO.FileShare,System.Int32,System.IO.FileOptions)" />
-      <Member Name="BeginRead(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)" />
-      <Member Name="BeginWrite(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)" />
-      <Member Name="Dispose(System.Boolean)" />
-      <Member Name="EndRead(System.IAsyncResult)" />
-      <Member Name="EndWrite(System.IAsyncResult)" />
-      <Member Name="Finalize" />
-      <Member Name="Flush" />
-      <Member Name="Flush(System.Boolean)" />
-      <Member Name="FlushAsync(System.Threading.CancellationToken)" />
-      <Member Name="get_CanRead" />
-      <Member Name="get_CanSeek" />
-      <Member Name="get_CanWrite" />
-      <Member Name="get_Handle" />
-      <Member Name="get_IsAsync" />
-      <Member Name="get_Length" />
-      <Member Name="get_Name" />
-      <Member Name="get_Position" />
-      <Member Name="get_SafeFileHandle" />
-      <Member Name="Lock(System.Int64,System.Int64)" />
-      <Member Name="Read(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="ReadAsync(System.Byte[],System.Int32,System.Int32,System.Threading.CancellationToken)" />
-      <Member Name="ReadByte" />
-      <Member Name="Seek(System.Int64,System.IO.SeekOrigin)" />
-      <Member Name="set_Position(System.Int64)" />
-      <Member Name="SetLength(System.Int64)" />
-      <Member Name="Unlock(System.Int64,System.Int64)" />
-      <Member Name="Write(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="WriteAsync(System.Byte[],System.Int32,System.Int32,System.Threading.CancellationToken)" />
-      <Member Name="WriteByte(System.Byte)" />
-      <Member MemberType="Property" Name="CanRead" />
-      <Member MemberType="Property" Name="CanSeek" />
-      <Member MemberType="Property" Name="CanWrite" />
-      <Member MemberType="Property" Name="Handle" />
-      <Member MemberType="Property" Name="IsAsync" />
-      <Member MemberType="Property" Name="Length" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="Position" />
-      <Member MemberType="Property" Name="SafeFileHandle" />
-    </Type>
-    <Type Name="System.IO.IOException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.String,System.Int32)"  />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.IO.MemoryStream">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Byte[])" />
-      <Member Name="#ctor(System.Byte[],System.Boolean)" />
-      <Member Name="#ctor(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="#ctor(System.Byte[],System.Int32,System.Int32,System.Boolean)" />
-      <Member Name="#ctor(System.Byte[],System.Int32,System.Int32,System.Boolean,System.Boolean)" />
-      <Member Name="#ctor(System.Int32)" />
-      <Member Name="CopyToAsync(System.IO.Stream,System.Int32,System.Threading.CancellationToken)"  />
-      <Member Name="Dispose(System.Boolean)" />
-      <Member Name="Flush" />
-      <Member Name="FlushAsync(System.Threading.CancellationToken)"  />
-      <Member Name="get_CanRead" />
-      <Member Name="get_CanSeek" />
-      <Member Name="get_CanWrite" />
-      <Member Name="get_Capacity" />
-      <Member Name="get_Length" />
-      <Member Name="get_Position" />
-      <Member Name="GetBuffer" />
-      <Member Name="TryGetBuffer(System.ArraySegment&lt;System.Byte&gt;@)" />
-      <Member Name="Read(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="ReadAsync(System.Byte[],System.Int32,System.Int32,System.Threading.CancellationToken)"  />
-      <Member Name="ReadByte" />
-      <Member Name="Seek(System.Int64,System.IO.SeekOrigin)" />
-      <Member Name="set_Capacity(System.Int32)" />
-      <Member Name="set_Position(System.Int64)" />
-      <Member Name="SetLength(System.Int64)" />
-      <Member Name="ToArray" />
-      <Member Name="Write(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="WriteAsync(System.Byte[],System.Int32,System.Int32,System.Threading.CancellationToken)"  />
-      <Member Name="WriteByte(System.Byte)" />
-      <Member Name="WriteTo(System.IO.Stream)" />
-      <Member MemberType="Property" Name="CanRead" />
-      <Member MemberType="Property" Name="CanSeek" />
-      <Member MemberType="Property" Name="CanWrite" />
-      <Member MemberType="Property" Name="Capacity" />
-      <Member MemberType="Property" Name="Length" />
-      <Member MemberType="Property" Name="Position" />
-      <Member Status="ApiFxInternal" Name="InternalGetOriginAndLength(System.Int32@,System.Int32@)" Condition="FEATURE_COMINTEROP" />
-    </Type>
-    <Type Name="System.IO.Path">
-      <Member MemberType="Field" Name="AltDirectorySeparatorChar" />
-      <Member MemberType="Field" Name="DirectorySeparatorChar" />
-      <Member MemberType="Field" Name="PathSeparator" />
-      <Member MemberType="Field" Name="VolumeSeparatorChar" />
-      <Member MemberType="Field" Name="InvalidPathChars" />
-      <Member Name="ChangeExtension(System.String,System.String)" />
-      <Member Name="Combine(System.String,System.String)" />
-      <Member Name="Combine(System.String,System.String,System.String)" />
-      <Member Name="Combine(System.String,System.String,System.String,System.String)" />
-      <Member Name="Combine(System.String[])"  />
-      <Member Name="GetDirectoryName(System.String)" />
-      <Member Name="GetExtension(System.String)" />
-      <Member Name="GetFileName(System.String)" />
-      <Member Name="GetFileNameWithoutExtension(System.String)" />
-      <Member Name="GetFullPath(System.String)" />
-      <Member Name="GetRelativePath(System.String,System.String)" />
-      <Member Name="GetInvalidPathChars" />
-      <Member Name="GetInvalidFileNameChars"  />
-      <Member Name="GetPathRoot(System.String)" />
-      <Member Name="HasExtension(System.String)" />
-      <Member Name="IsPathRooted(System.String)" />
-      <Member Name="GetRandomFileName" />
-      <Member Name="GetTempFileName" />
-      <Member Name="GetTempPath" />
-    </Type>
-    <Type Name="System.IO.PathTooLongException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.IO.Stream">
-      <Member MemberType="Field" Name="Null" />
-      <Member Name="#ctor" />
-      <Member Name="BeginRead(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)" />
-      <Member Name="BeginWrite(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)" />
-      <Member Name="CopyTo(System.IO.Stream)" />
-      <Member Name="CopyTo(System.IO.Stream,System.Int32)" />
-      <Member Name="CopyToAsync(System.IO.Stream)"  />
-      <Member Name="CopyToAsync(System.IO.Stream,System.Int32)"  />
-      <Member Name="CopyToAsync(System.IO.Stream,System.Int32,System.Threading.CancellationToken)"  />
-      <Member Name="Close" />
-      <Member Name="CreateWaitHandle" />
-      <Member Name="Dispose" />
-      <Member Name="Dispose(System.Boolean)" />
-      <Member Name="EndRead(System.IAsyncResult)" />
-      <Member Name="EndWrite(System.IAsyncResult)" />
-      <Member Name="Flush" />
-      <Member Name="FlushAsync"  />
-      <Member Name="FlushAsync(System.Threading.CancellationToken)"  />
-      <Member Name="get_CanRead" />
-      <Member Name="get_CanSeek" />
-      <Member Name="get_CanTimeout" />
-      <Member Name="get_CanWrite" />
-      <Member Name="get_Length" />
-      <Member Name="get_Position" />
-      <Member Name="get_ReadTimeout" />
-      <Member Name="get_WriteTimeout" />
-      <Member Name="ObjectInvariant" />
-      <Member Name="Read(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="ReadByte" />
-      <Member Name="ReadAsync(System.Byte[],System.Int32,System.Int32)"  />
-      <Member Name="ReadAsync(System.Byte[],System.Int32,System.Int32,System.Threading.CancellationToken)"  />
-      <Member Name="Seek(System.Int64,System.IO.SeekOrigin)" />
-      <Member Name="set_Position(System.Int64)" />
-      <Member Name="set_ReadTimeout(System.Int32)" />
-      <Member Name="set_WriteTimeout(System.Int32)" />
-      <Member Name="SetLength(System.Int64)" />
-      <Member Name="Synchronized(System.IO.Stream)" />
-      <Member Name="Write(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="WriteAsync(System.Byte[],System.Int32,System.Int32)"  />
-      <Member Name="WriteAsync(System.Byte[],System.Int32,System.Int32,System.Threading.CancellationToken)"  />
-      <Member Name="WriteByte(System.Byte)" />
-      <Member MemberType="Property" Name="CanRead" />
-      <Member MemberType="Property" Name="CanSeek" />
-      <Member MemberType="Property" Name="CanTimeout" />
-      <Member MemberType="Property" Name="CanWrite" />
-      <Member MemberType="Property" Name="Length" />
-      <Member MemberType="Property" Name="Position" />
-      <Member MemberType="Property" Name="ReadTimeout" />
-      <Member MemberType="Property" Name="WriteTimeout" />
-    </Type>
-    <Type Name="System.IO.UnmanagedMemoryAccessor">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Runtime.InteropServices.SafeBuffer,System.Int64,System.Int64)" />
-      <Member Name="#ctor(System.Runtime.InteropServices.SafeBuffer,System.Int64,System.Int64,System.IO.FileAccess)" />
-      <Member Name="Dispose" />
-      <Member Name="Dispose(System.Boolean)" />
-      <Member Name="get_CanRead" />
-      <Member Name="get_CanWrite" />
-      <Member Name="get_Capacity" />
-      <Member Name="get_IsOpen" />
-      <Member Name="Initialize(System.Runtime.InteropServices.SafeBuffer,System.Int64,System.Int64,System.IO.FileAccess)" />
-      <Member Name="Read&lt;T&gt;(System.Int64,T@)" />
-      <Member Name="ReadArray&lt;T&gt;(System.Int64,T[],System.Int32,System.Int32)" />
-      <Member Name="ReadBoolean(System.Int64)" />
-      <Member Name="ReadByte(System.Int64)" />
-      <Member Name="ReadChar(System.Int64)" />
-      <Member Name="ReadDecimal(System.Int64)" />
-      <Member Name="ReadDouble(System.Int64)" />
-      <Member Name="ReadInt16(System.Int64)" />
-      <Member Name="ReadInt32(System.Int64)" />
-      <Member Name="ReadInt64(System.Int64)" />
-      <Member Name="ReadSByte(System.Int64)" />
-      <Member Name="ReadSingle(System.Int64)" />
-      <Member Name="ReadUInt16(System.Int64)" />
-      <Member Name="ReadUInt32(System.Int64)" />
-      <Member Name="ReadUInt64(System.Int64)" />
-      <Member Name="Write(System.Int64,System.Boolean)" />
-      <Member Name="Write(System.Int64,System.Byte)" />
-      <Member Name="Write(System.Int64,System.Char)" />
-      <Member Name="Write(System.Int64,System.Decimal)" />
-      <Member Name="Write(System.Int64,System.Double)" />
-      <Member Name="Write(System.Int64,System.Int16)" />
-      <Member Name="Write(System.Int64,System.Int32)" />
-      <Member Name="Write(System.Int64,System.Int64)" />
-      <Member Name="Write(System.Int64,System.SByte)" />
-      <Member Name="Write(System.Int64,System.Single)" />
-      <Member Name="Write(System.Int64,System.UInt16)" />
-      <Member Name="Write(System.Int64,System.UInt32)" />
-      <Member Name="Write(System.Int64,System.UInt64)" />
-      <Member Name="Write&lt;T&gt;(System.Int64,T@)" />
-      <Member Name="WriteArray&lt;T&gt;(System.Int64,T[],System.Int32,System.Int32)" />
-      <Member MemberType="Property" Name="CanRead" />
-      <Member MemberType="Property" Name="CanWrite" />
-      <Member MemberType="Property" Name="Capacity" />
-      <Member MemberType="Property" Name="IsOpen" />
-    </Type>
-    <Type Name="System.IO.UnmanagedMemoryStream">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Byte*,System.Int64)" />
-      <Member Name="#ctor(System.Byte*,System.Int64,System.Int64,System.IO.FileAccess)" />
-      <Member Name="#ctor(System.Runtime.InteropServices.SafeBuffer,System.Int64,System.Int64)" />
-      <Member Name="#ctor(System.Runtime.InteropServices.SafeBuffer,System.Int64,System.Int64,System.IO.FileAccess)" />
-      <Member Name="Dispose(System.Boolean)" />
-      <Member Name="Flush" />
-      <Member Name="get_CanRead" />
-      <Member Name="get_CanSeek" />
-      <Member Name="get_CanWrite" />
-      <Member Name="get_Capacity" />
-      <Member Name="get_Length" />
-      <Member Name="get_Position" />
-      <Member Name="get_PositionPointer" />
-      <Member Name="Initialize(System.Byte*,System.Int64,System.Int64,System.IO.FileAccess)" />
-      <Member Name="Initialize(System.Runtime.InteropServices.SafeBuffer,System.Int64,System.Int64,System.IO.FileAccess)" />
-      <Member Name="Read(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="ReadByte" />
-      <Member Name="Seek(System.Int64,System.IO.SeekOrigin)" />
-      <Member Name="set_Position(System.Int64)" />
-      <Member Name="SetLength(System.Int64)"  />
-      <Member Name="Write(System.Byte[],System.Int32,System.Int32)" />
-      <Member Name="WriteByte(System.Byte)" />
-      <Member MemberType="Property" Name="CanRead" />
-      <Member MemberType="Property" Name="CanSeek" />
-      <Member MemberType="Property" Name="CanWrite" />
-      <Member MemberType="Property" Name="Capacity" />
-      <Member MemberType="Property" Name="Length" />
-      <Member MemberType="Property" Name="Position" />
-      <Member MemberType="Property" Name="PositionPointer" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Diagnostics.Contracts.Contract" >
-        <Member MemberType="Event" Name="ContractFailed"    />
-        <Member Name="Assert(System.Boolean)" />
-        <Member Name="Assert(System.Boolean,System.String)" />
-        <Member Name="Assume(System.Boolean)" />
-        <Member Name="Assume(System.Boolean,System.String)" />
-        <Member Name="EndContractBlock" />
-        <Member Name="Ensures(System.Boolean,System.String)" />
-        <Member Name="Ensures(System.Boolean)" />
-        <Member Name="EnsuresOnThrow&lt;TException&gt;(System.Boolean)" />
-        <Member Name="EnsuresOnThrow&lt;TException&gt;(System.Boolean,System.String)" />
-        <Member Name="Exists&lt;T&gt;(System.Collections.Generic.IEnumerable&lt;T&gt;,System.Predicate&lt;T&gt;)" />
-        <Member Name="Exists(System.Int32,System.Int32,System.Predicate&lt;System.Int32&gt;)" />
-        <Member Name="ForAll&lt;T&gt;(System.Collections.Generic.IEnumerable&lt;T&gt;,System.Predicate&lt;T&gt;)" />
-        <Member Name="ForAll(System.Int32,System.Int32,System.Predicate&lt;System.Int32&gt;)" />
-        <Member Name="Invariant(System.Boolean)" />
-        <Member Name="Invariant(System.Boolean,System.String)" />
-        <Member Name="OldValue&lt;T&gt;(T)" />
-        <Member Name="Requires(System.Boolean)" />
-        <Member Name="Requires(System.Boolean,System.String)" />
-        <Member Name="Requires&lt;TException&gt;(System.Boolean)" />
-        <Member Name="Requires&lt;TException&gt;(System.Boolean,System.String)" />
-        <Member Name="Result&lt;T&gt;" />
-        <Member Name="ValueAtReturn&lt;T&gt;(T@)" />
-    </Type>
-    <Type Name="System.Diagnostics.Contracts.ContractAbbreviatorAttribute"  >
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Diagnostics.Contracts.ContractArgumentValidatorAttribute"  >
-      <Member Name="#ctor" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Diagnostics.Contracts.ContractPublicPropertyNameAttribute">
-        <Member Name="#ctor(System.String)" />
-        <Member MemberType="Property" Name="Name" />
-    </Type>
-    <Type Name="System.Diagnostics.Contracts.ContractFailedEventArgs"  >
-      <Member Name="#ctor(System.Diagnostics.Contracts.ContractFailureKind,System.String,System.String,System.Exception)" />
-      <Member Name="get_Condition" />
-      <Member Name="get_FailureKind" />
-      <Member Name="get_Handled" />
-      <Member Name="get_Message" />
-      <Member Name="get_OriginalException" />
-      <Member Name="get_Unwind" />
-      <Member Name="SetHandled" />
-      <Member Name="SetUnwind" />
-      <Member MemberType="Property" Name="Condition" />
-      <Member MemberType="Property" Name="FailureKind" />
-      <Member MemberType="Property" Name="Handled" />
-      <Member MemberType="Property" Name="Message" />
-      <Member MemberType="Property" Name="OriginalException" />
-      <Member MemberType="Property" Name="Unwind" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Diagnostics.Contracts.ContractOptionAttribute"  >
-      <Member Name="#ctor(System.String,System.String,System.Boolean)" />
-      <Member Name="#ctor(System.String,System.String,System.String)" />
-      <Member MemberType="Property" Name="Category" />
-      <Member MemberType="Property" Name="Setting" />
-      <Member MemberType="Property" Name="Enabled" />
-      <Member MemberType="Property" Name="Value" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Diagnostics.Contracts.PureAttribute">
-        <Member Name="#ctor" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Diagnostics.Contracts.ContractInvariantMethodAttribute">
-        <Member Name="#ctor" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Diagnostics.Contracts.ContractReferenceAssemblyAttribute">
-        <Member Name="#ctor" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Diagnostics.Contracts.ContractClassAttribute">
-        <Member Name="#ctor(System.Type)" />
-        <Member MemberType="Property" Name="TypeContainingContracts" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Diagnostics.Contracts.ContractClassForAttribute">
-        <Member Name="#ctor(System.Type)" />
-        <Member MemberType="Property" Name="TypeContractsAreFor" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Diagnostics.Contracts.ContractRuntimeIgnoredAttribute">
-        <Member Name="#ctor" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Diagnostics.Contracts.ContractVerificationAttribute">
-        <Member Name="#ctor(System.Boolean)" />
-        <Member MemberType="Property" Name="Value" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Diagnostics.Contracts.Internal.ContractHelper">
-        <Member Name="RaiseContractFailedEvent(System.Diagnostics.Contracts.ContractFailureKind,System.String,System.String,System.Exception)" />
-        <Member Name="TriggerFailure(System.Diagnostics.Contracts.ContractFailureKind,System.String,System.String,System.String,System.Exception)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Diagnostics.Contracts.ContractException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Diagnostics.Contracts.ContractFailureKind,System.String,System.String,System.String,System.Exception)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member MemberType="Property" Name="Condition" />
-      <Member MemberType="Property" Name="Failure" />
-      <Member MemberType="Property" Name="Kind" />
-      <Member MemberType="Property" Name="UserMessage" />
-    </Type>
-    <Type Name="System.StringSplitOptions" />
-    <Type Status="ImplRoot" Name="System.__Canon" />
-    <Type Status="ImplRoot" Name="System.__ComObject" Condition="FEATURE_COMINTEROP">
-      <Member MemberType="Field" Name="m_ObjectToDataMap" />
-      <Member Name="ReleaseSelf" />
-      <Member Name="ReleaseAllData" />
-      <Member Name="GetEventProvider(System.RuntimeType)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.BCLDebug">
-      <Member Name="GetRegistryLoggingValues(System.Boolean@,System.Boolean@,System.Int32@,System.Boolean@,System.Boolean@,System.Boolean@)" /> <!-- EE -->
-    </Type>
-    <Type Status="ImplRoot" Name="System.Configuration.Assemblies.AssemblyHashAlgorithm" />
-    <Type Status="ImplRoot" Name="System.Configuration.Assemblies.AssemblyVersionCompatibility" />
-    <Type Status="ImplRoot" Name="System.CrossAppDomainMarshaledException">
-      <Member Name="#ctor(System.String,System.Int32)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Currency">
-      <Member Status="ImplRoot" Name="#ctor(System.Decimal)" /> <!-- EE - il stubs -->
-    </Type>
-    <Type Status="ImplRoot" Name="System.Diagnostics.EditAndContinueHelper">
-      <Member MemberType="Field" Name="_objectReference" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Diagnostics.StackFrameHelper">
-      <Member Status="ImplRoot" Name="OnDeserialized(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="OnSerialized(System.Runtime.Serialization.StreamingContext)" />
-      <Member Status="ImplRoot" Name="OnSerializing(System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Diagnostics.Tracing.EventAttribute">
-      <Member Name="#ctor(System.Int32)" />
-      <Member Name="get_EventId" />
-      <Member MemberType="Property" Name="ActivityOptions" />
-      <Member MemberType="Property" Name="Channel" />
-      <Member MemberType="Property" Name="Keywords" />
-      <Member MemberType="Property" Name="Level" />
-      <Member MemberType="Property" Name="Message" />
-      <Member MemberType="Property" Name="Opcode" />
-      <Member MemberType="Property" Name="Task" />
-      <Member MemberType="Property" Name="Version" />
-      <Member MemberType="Property" Name="Tags" />
-    </Type>
-    <Type Name="System.Diagnostics.Tracing.EventActivityOptions">
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="Detachable" />
-      <Member MemberType="Field" Name="Disable" />
-      <Member MemberType="Field" Name="Recursive" />
-    </Type>
-    <Type Name="System.Diagnostics.Tracing.EventFieldFormat">
-      <Member MemberType="Field" Name="Boolean" />
-      <Member MemberType="Field" Name="Default" />
-      <Member MemberType="Field" Name="Hexadecimal" />
-      <Member MemberType="Field" Name="HResult" />
-      <Member MemberType="Field" Name="Json" />
-      <Member MemberType="Field" Name="String" />
-      <Member MemberType="Field" Name="Xml" />
-    </Type>
-    <Type Name="System.Diagnostics.Tracing.EventDescriptor">
-      <Member Name="#ctor(System.Int32,System.Byte,System.Byte,System.Int64)" />
-      <Member Name="#ctor(System.Int32,System.Byte,System.Byte,System.Byte,System.Byte,System.Int32,System.Int64)" />
-      <Member Name="get_EventId" />
-      <Member Name="get_Channel" />
-      <Member Name="get_Level" />
-      <Member Name="get_Opcode" />
-      <Member Name="get_Task" />
-      <Member Name="get_Version" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.Diagnostics.Tracing.EventDescriptor)" />
-    </Type>
-
-    <Type Name="System.Diagnostics.Tracing.EventChannel">
-      <Member MemberType="Field" Name="Admin" />
-      <Member MemberType="Field" Name="Analytic" />
-      <Member MemberType="Field" Name="Debug" />
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="Operational" />
-    </Type>
-    <Type Name="System.Diagnostics.Tracing.EventCommand">
-      <Member MemberType="Field" Name="Disable" />
-      <Member MemberType="Field" Name="Enable" />
-      <Member MemberType="Field" Name="SendManifest" />
-      <Member MemberType="Field" Name="Update" />
-    </Type>
-    <Type Name="System.Diagnostics.Tracing.EventCommandEventArgs">
-      <Member Name="get_Arguments" />
-      <Member Name="get_Command" />
-      <Member Name="DisableEvent(System.Int32)" />
-      <Member Name="EnableEvent(System.Int32)" />
-    </Type>
-    <Type Name="System.Diagnostics.Tracing.EventDataAttribute">
-      <Member Name="#ctor" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="Level" />
-      <Member MemberType="Property" Name="Opcode" />
-      <Member MemberType="Property" Name="Keywords" />
-      <Member MemberType="Property" Name="Tags" />
-    </Type>
-    <Type Name="System.Diagnostics.Tracing.EventKeywords">
-      <Member MemberType="Field" Name="AuditFailure" />
-      <Member MemberType="Field" Name="AuditSuccess" />
-      <Member MemberType="Field" Name="CorrelationHint" />
-      <Member MemberType="Field" Name="EventLogClassic" />
-      <Member MemberType="Field" Name="MicrosoftTelemetry" />
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="Sqm" />
-      <Member MemberType="Field" Name="WdiContext" />
-      <Member MemberType="Field" Name="WdiDiagnostic" />
-    </Type>
-    <Type Name="System.Diagnostics.Tracing.EventLevel">
-      <Member MemberType="Field" Name="Critical" />
-      <Member MemberType="Field" Name="Error" />
-      <Member MemberType="Field" Name="Informational" />
-      <Member MemberType="Field" Name="LogAlways" />
-      <Member MemberType="Field" Name="Verbose" />
-      <Member MemberType="Field" Name="Warning" />
-    </Type>
-    <Type Name="System.Diagnostics.Tracing.EventListener">
-      <Member Name="#ctor" />
-      <Member Name="DisableEvents(System.Diagnostics.Tracing.EventSource)" />
-      <Member Name="Dispose" />
-      <Member Name="EnableEvents(System.Diagnostics.Tracing.EventSource,System.Diagnostics.Tracing.EventLevel)" />
-      <Member Name="EnableEvents(System.Diagnostics.Tracing.EventSource,System.Diagnostics.Tracing.EventLevel,System.Diagnostics.Tracing.EventKeywords)" />
-      <Member Name="EnableEvents(System.Diagnostics.Tracing.EventSource,System.Diagnostics.Tracing.EventLevel,System.Diagnostics.Tracing.EventKeywords,System.Collections.Generic.IDictionary&lt;System.String,System.String&gt;)" />
-      <Member Name="EventSourceIndex(System.Diagnostics.Tracing.EventSource)" />
-      <Member Name="OnEventSourceCreated(System.Diagnostics.Tracing.EventSource)" />
-      <Member Name="OnEventWritten(System.Diagnostics.Tracing.EventWrittenEventArgs)" />
-    </Type>
-
-    <Type Name="System.Diagnostics.Tracing.EventManifestOptions">
-      <Member MemberType="Field" Name="AllCultures" />
-      <Member MemberType="Field" Name="AllowEventSourceOverride" />
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="OnlyIfNeededForRegistration" />
-      <Member MemberType="Field" Name="Strict" />
-    </Type>
-
-    <Type Name="System.Diagnostics.Tracing.EventOpcode">
-      <Member MemberType="Field" Name="DataCollectionStart" />
-      <Member MemberType="Field" Name="DataCollectionStop" />
-      <Member MemberType="Field" Name="Extension" />
-      <Member MemberType="Field" Name="Info" />
-      <Member MemberType="Field" Name="Receive" />
-      <Member MemberType="Field" Name="Reply" />
-      <Member MemberType="Field" Name="Resume" />
-      <Member MemberType="Field" Name="Send" />
-      <Member MemberType="Field" Name="Start" />
-      <Member MemberType="Field" Name="Stop" />
-      <Member MemberType="Field" Name="Suspend" />
-    </Type>
-
-    <Type Name="System.Diagnostics.Tracing.EventSource">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Boolean)" />
-      <Member Name="#ctor(System.Diagnostics.Tracing.EventSourceSettings)" />
-      <Member Name="#ctor(System.Diagnostics.Tracing.EventSourceSettings,System.String[])" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Diagnostics.Tracing.EventSourceSettings)" />
-      <Member Name="#ctor(System.String,System.Diagnostics.Tracing.EventSourceSettings,System.String[])" />
-      <Member Name="get_Guid" />
-      <Member Name="get_Name" />
-      <Member MemberType="Property" Name="ConstructionException" />
-      <Member MemberType="Property" Name="CurrentThreadActivityId" />
-      <Member MemberType="Event" Name="EventCommandExecuted" />
-      <Member Name="Dispose" />
-      <Member Name="Dispose(System.Boolean)" />
-      <Member Name="GenerateManifest(System.Type,System.String)" />
-      <Member Name="GenerateManifest(System.Type,System.String,System.Diagnostics.Tracing.EventManifestOptions)" />
-      <Member Name="GetGuid(System.Type)" />
-      <Member Name="GetName(System.Type)" />
-      <Member Name="GetTrait(System.String)" />
-      <Member Name="GetSources" />
-      <Member Name="IsEnabled" />
-      <Member Name="IsEnabled(System.Diagnostics.Tracing.EventLevel,System.Diagnostics.Tracing.EventKeywords)" />
-      <Member Name="IsEnabled(System.Diagnostics.Tracing.EventLevel,System.Diagnostics.Tracing.EventKeywords,System.Diagnostics.Tracing.EventChannel)" />
-      <Member Name="OnEventCommand(System.Diagnostics.Tracing.EventCommandEventArgs)" />
-      <Member Name="SendCommand(System.Diagnostics.Tracing.EventSource,System.Diagnostics.Tracing.EventCommand,System.Collections.Generic.IDictionary&lt;System.String,System.String&gt;)" />
-      <Member Name="SetCurrentThreadActivityId(System.Guid)" />
-      <Member Name="SetCurrentThreadActivityId(System.Guid,System.Guid@)" />
-      <Member MemberType="Property" Name="Settings" />
-      <Member Name="ToString" />
-      <Member Name="Write(System.String)" />
-      <Member Name="Write(System.String,System.Diagnostics.Tracing.EventSourceOptions)" />
-      <Member Name="Write&lt;T&gt;(System.String,T)" />
-      <Member Name="Write&lt;T&gt;(System.String,System.Diagnostics.Tracing.EventSourceOptions,T)" />
-      <Member Name="Write&lt;T&gt;(System.String,System.Diagnostics.Tracing.EventSourceOptions@,System.Guid@,System.Guid@,T@)" />
-      <Member Name="Write&lt;T&gt;(System.String,System.Diagnostics.Tracing.EventSourceOptions@,T@)" />
-      <Member Name="WriteEvent(System.Int32)" />
-      <Member Name="WriteEvent(System.Int32,System.Byte[])" />
-      <Member Name="WriteEvent(System.Int32,System.Int32)" />
-      <Member Name="WriteEvent(System.Int32,System.Int32,System.Int32)" />
-      <Member Name="WriteEvent(System.Int32,System.Int32,System.Int32,System.Int32)" />
-      <Member Name="WriteEvent(System.Int32,System.Int32,System.String)" />
-      <Member Name="WriteEvent(System.Int32,System.Int64)" />
-      <Member Name="WriteEvent(System.Int32,System.Int64,System.Byte[])" />
-      <Member Name="WriteEvent(System.Int32,System.Int64,System.Int64)" />
-      <Member Name="WriteEvent(System.Int32,System.Int64,System.Int64,System.Int64)" />
-      <Member Name="WriteEvent(System.Int32,System.Int64,System.String)" />
-      <Member Name="WriteEvent(System.Int32,System.Object[])" />
-      <Member Name="WriteEvent(System.Int32,System.String)" />
-      <Member Name="WriteEvent(System.Int32,System.String,System.Int32)" />
-      <Member Name="WriteEvent(System.Int32,System.String,System.Int32,System.Int32)" />
-      <Member Name="WriteEvent(System.Int32,System.String,System.Int64)" />
-      <Member Name="WriteEvent(System.Int32,System.String,System.String)" />
-      <Member Name="WriteEvent(System.Int32,System.String,System.String,System.String)" />
-      <Member Name="WriteEventCore(System.Int32,System.Int32,System.Diagnostics.Tracing.EventSource+EventData*)" />
-      <Member Name="WriteEventWithRelatedActivityId(System.Int32,System.Guid,System.Object[])" />
-      <Member Name="WriteEventWithRelatedActivityIdCore(System.Int32,System.Guid*,System.Int32,System.Diagnostics.Tracing.EventSource+EventData*)" />
-      <Member Name="get_Settings" />
-    </Type>
-    <Type Name="System.Diagnostics.Tracing.EventSource+EventData">
-      <Member MemberType="Property" Name="DataPointer" />
-      <Member MemberType="Property" Name="Size" />
-    </Type>
-
-    <Type Name="System.Diagnostics.Tracing.EventSourceAttribute">
-      <Member Name="#ctor" />
-      <Member MemberType="Property" Name="Guid" />
-      <Member MemberType="Property" Name="LocalizationResources" />
-      <Member MemberType="Property" Name="Name" />
-    </Type>
-    <Type Name="System.Diagnostics.Tracing.EventIgnoreAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Diagnostics.Tracing.EventSourceException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Diagnostics.Tracing.EventSourceOptions">
-      <Member MemberType="Property" Name="Keywords" />
-      <Member MemberType="Property" Name="Level" />
-      <Member MemberType="Property" Name="Opcode" />
-      <Member MemberType="Property" Name="Tags" />
-      <Member MemberType="Property" Name="ActivityOptions" />
-    </Type>
-    <Type Name="System.Diagnostics.Tracing.EventSourceSettings">
-      <Member MemberType="Field" Name="Default" />
-      <Member MemberType="Field" Name="EtwManifestEventFormat" />
-      <Member MemberType="Field" Name="EtwSelfDescribingEventFormat" />
-      <Member MemberType="Field" Name="ThrowOnEventWriteErrors" />
-    </Type>
-    <Type Name="System.Diagnostics.Tracing.EventTask">
-      <Member MemberType="Field" Name="None" />
-    </Type>
-    <Type Name="System.Diagnostics.Tracing.EventTags">
-      <Member MemberType="Field" Name="None" />
-    </Type>
-    <Type Name="System.Diagnostics.Tracing.EventFieldTags">
-      <Member MemberType="Field" Name="None" />
-    </Type>
-    <Type Name="System.Diagnostics.Tracing.EventFieldAttribute">
-      <Member Name="#ctor" />
-      <Member MemberType="Property" Name="Tags" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="Format" />
-    </Type>
-    <Type Name="System.Diagnostics.Tracing.EventWrittenEventArgs">
-      <Member Name="get_Channel" />
-      <Member Name="get_EventId" />
-      <Member Name="get_EventSource" />
-      <Member Name="get_Keywords" />
-      <Member Name="get_Level" />
-      <Member Name="get_Message" />
-      <Member Name="get_Opcode" />
-      <Member Name="get_Payload" />
-      <Member Name="get_PayloadNames" />
-      <Member Name="get_Task" />
-      <Member Name="get_Version" />
-      <Member Name="get_Tags" />
-      <Member MemberType="Property" Name="ActivityId" />
-      <Member MemberType="Property" Name="EventName" />
-      <Member MemberType="Property" Name="RelatedActivityId" />
-    </Type>
-    <Type Name="System.Diagnostics.Tracing.NonEventAttribute">
-      <Member Name="#ctor" />
-    </Type>
-
-   <Type Name="System.Diagnostics.Tracing.FrameworkEventSource+Tasks">
-      <Member MemberType="Field" Name="GetResponse" />
-      <Member MemberType="Field" Name="GetRequestStream" />
-      <Member MemberType="Field" Name="ThreadTransfer" />
-   </Type>
-   <Type Name="System.Diagnostics.Tracing.FrameworkEventSource+Keywords">
-      <Member MemberType="Field" Name="Loader" />
-      <Member MemberType="Field" Name="NetClient" />
-      <Member MemberType="Field" Name="DynamicTypeUsage" />
-      <Member MemberType="Field" Name="ThreadTransfer" />
-   </Type>
-   <Type Name="System.Diagnostics.Tracing.FrameworkEventSource+Opcodes">
-      <Member MemberType="Field" Name="ReceiveHandled" />
-   </Type>
-    <Type Status="ImplRoot" Name="System.IO.Stream+SynchronousAsyncResult">
-      <Member Name="get_AsyncState" />
-      <Member Name="get_AsyncWaitHandle" />
-      <Member Name="get_CompletedSynchronously" />
-      <Member Name="get_IsCompleted" />
-      <Member MemberType="Property" Name="AsyncState" />
-      <Member MemberType="Property" Name="AsyncWaitHandle" />
-      <Member MemberType="Property" Name="CompletedSynchronously" />
-      <Member MemberType="Property" Name="IsCompleted" />
-    </Type>
-    <Type Name="System.OperationCanceledException" >
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Threading.CancellationToken)" />
-      <Member Name="#ctor(System.String,System.Threading.CancellationToken)" />
-      <Member Name="#ctor(System.String,System.Exception,System.Threading.CancellationToken)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="get_CancellationToken" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Reflection.CustomAttributeCtorParameter" />
-    <Type Status="ImplRoot" Name="System.Reflection.CustomAttributeEncodedArgument" />
-    <Type Status="ImplRoot" Name="System.Reflection.CustomAttributeNamedParameter" />
-    <Type Status="ImplRoot" Name="System.Reflection.CustomAttributeType" />
-    <Type Status="ImplRoot" Name="System.Reflection.Emit.DynamicResolver" />
-    <Type Status="ImplRoot" Name="System.Reflection.Emit.DynamicResolver+SecurityControlFlags" />
-    <Type Status="ImplRoot" Name="System.Reflection.Emit.DynamicScope" />
-    <Type Name="System.Reflection.ExceptionHandlingClause" >
-      <Member Name="#ctor" />
-      <Member Name="get_CatchType" />
-      <Member Name="get_FilterOffset" />
-      <Member Name="get_Flags" />
-      <Member Name="get_HandlerLength" />
-      <Member Name="get_HandlerOffset" />
-      <Member Name="get_TryLength" />
-      <Member Name="get_TryOffset" />
-      <Member Name="ToString" />
-    </Type>
-    <Type Name="System.Reflection.ExceptionHandlingClauseOptions" >
-      <Member MemberType="Field" Name="Clause" />
-      <Member MemberType="Field" Name="Fault" />
-      <Member MemberType="Field" Name="Filter" />
-      <Member MemberType="Field" Name="Finally" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Reflection.LocalVariableInfo">
-      <Member Name="#ctor" />
-      <Member Name="get_IsPinned" />
-      <Member Name="get_LocalIndex" />
-      <Member Name="get_LocalType" />
-      <Member MemberType="Property" Name="IsPinned" />
-      <Member MemberType="Property" Name="LocalIndex" />
-      <Member MemberType="Property" Name="LocalType" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Reflection.MetadataImport">
-      <Member Name="ThrowError(System.Int32)" /> <!-- EE -->
-    </Type>
-    <Type Name="System.Reflection.MethodBody">
-      <Member Name="#ctor" />
-      <Member Name="get_ExceptionHandlingClauses" />
-      <Member Name="get_InitLocals" />
-      <Member Name="get_LocalSignatureMetadataToken" />
-      <Member Name="get_LocalVariables" />
-      <Member Name="get_MaxStackSize" />
-      <Member Name="GetILAsByteArray" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_exceptionHandlingClauses" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_IL" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_initLocals" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_localSignatureMetadataToken" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_localVariables" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_maxStackSize" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Reflection.Emit.ExceptionHandler">
-      <Member Name="op_Equality(System.Reflection.Emit.ExceptionHandler,System.Reflection.Emit.ExceptionHandler)" />
-      <Member Name="op_Inequality(System.Reflection.Emit.ExceptionHandler,System.Reflection.Emit.ExceptionHandler)" />
-    </Type>
-    <Type Name="System.Reflection.ReflectionTypeLoadException">
-      <Member Name="#ctor(System.Type[],System.Exception[])" />
-      <Member Name="#ctor(System.Type[],System.Exception[],System.String)" />
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member MemberType="Property" Name="LoaderExceptions" />
-      <Member MemberType="Property" Name="Types" />
-      <Member Name="get_LoaderExceptions" />
-      <Member Name="get_Types" />
-    </Type>
-    <Type Name="System.Reflection.ResourceAttributes">
-      <Member MemberType="Field" Name="Private" />
-      <Member MemberType="Field" Name="Public" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Reflection.RtFieldInfo">
-      <Member Status="ImplRoot" Name="GetFieldHandle" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Reflection.RuntimeConstructorInfo">
-      <Member Status="ImplRoot" MemberType="Field" Name="_empty1" />
-      <Member Status="ImplRoot" MemberType="Field" Name="_empty2" />
-      <Member Status="ImplRoot" MemberType="Field" Name="_empty3" />
-    </Type>
-    <Type Name="System.Reflection.TypeFilter">
-      <Member Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Status="ApiRoot" Name="BeginInvoke(System.Type,System.Object,System.AsyncCallback,System.Object)" />
-      <Member Status="ApiRoot" Name="EndInvoke(System.IAsyncResult)" />
-      <Member Status="ApiRoot" Name="Invoke(System.Type,System.Object)" />
-    </Type>
-    <Type Name="System.Reflection.StrongNameKeyPair">
-      <Member Name="#ctor(System.Byte[])" />
-      <Member Name="#ctor(System.IO.FileStream)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="get_PublicKey" />
-      <Member MemberType="Property" Name="PublicKey" />
-      <Member Status="ImplRoot" Name="System.Runtime.Serialization.IDeserializationCallback.OnDeserialization(System.Object)" />
-      <Member Status="ImplRoot" Name="System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.ReflectionOnlyType" />
-    <Type Status="ImplRoot" Name="System.ResId" />
-    <Type Status="ImplRoot" Name="System.Resolver">
-      <Member Name="GetJitContext(System.Int32@)" /> <!-- EE -->
-      <Member Name="GetCodeInfo(System.Int32@,System.Int32@,System.Int32@)" /> <!-- EE -->
-      <Member Name="GetLocalsSignature" /> <!-- EE -->
-      <Member Name="GetEHInfo(System.Int32,System.Void*)" /> <!-- EE -->
-      <Member Name="GetRawEHInfo" /> <!-- EE -->
-      <Member Name="GetStringLiteral(System.Int32)" /> <!-- EE -->
-      <Member Name="ResolveToken(System.Int32,System.IntPtr@,System.IntPtr@,System.IntPtr@)" /> <!-- EE -->
-      <Member Name="ResolveSignature(System.Int32,System.Int32)" /> <!-- EE -->
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.RuntimeWrappedException">
-      <Member Name="#ctor(System.Object)" /> <!-- EE -->
-      <Member Name="get_WrappedException" />
-      <Member Name="GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member MemberType="Property" Name="WrappedException" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.StringFreezingAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.CompilerServices.TypeDependencyAttribute">
-      <Member Name="#ctor(System.String)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ArrayWithOffset">
-      <Member Name="#ctor(System.Object,System.Int32)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="Equals(System.Runtime.InteropServices.ArrayWithOffset)" />
-      <Member Name="GetArray" />
-      <Member Name="GetHashCode" />
-      <Member Name="GetOffset" />
-      <Member Name="op_Equality(System.Runtime.InteropServices.ArrayWithOffset,System.Runtime.InteropServices.ArrayWithOffset)" />
-      <Member Name="op_Inequality(System.Runtime.InteropServices.ArrayWithOffset,System.Runtime.InteropServices.ArrayWithOffset)" />
-    </Type>
-     <Type Name="System.Runtime.ConstrainedExecution.ReliabilityContractAttribute">
-      <Member Name="#ctor(System.Runtime.ConstrainedExecution.Consistency,System.Runtime.ConstrainedExecution.Cer)" />
-      <Member Name="get_Cer" />
-      <Member Name="get_ConsistencyGuarantee" />
-      <Member MemberType="Property" Name="Cer" />
-      <Member MemberType="Property" Name="ConsistencyGuarantee" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.ConstrainedExecution.PrePrepareMethodAttribute" />
-    <Type Name="System.Runtime.ConstrainedExecution.CriticalFinalizerObject">
-      <Member Name="#ctor"/>
-      <Member Name="Finalize" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.Expando.IExpando">
-      <Member Name="AddField(System.String)" /> <!-- EE -->
-      <Member Name="RemoveMember(System.Reflection.MemberInfo)" /> <!-- EE -->
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ICustomMarshaler">
-      <Member Name="MarshalNativeToManaged(System.IntPtr)" /> <!-- EE -->
-      <Member Name="MarshalManagedToNative(System.Object)" /> <!-- EE -->
-      <Member Name="CleanUpNativeData(System.IntPtr)" /> <!-- EE -->
-      <Member Name="CleanUpManagedData(System.Object)" /> <!-- EE -->
-      <Member Name="GetNativeDataSize" /> <!-- EE -->
-    </Type>
-    <Type Name="System.Runtime.InteropServices.InvalidOleVariantTypeException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IStringable" Condition="FEATURE_COMINTEROP">
-      <Member Name="ToString"/>
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IIterator&lt;T&gt;" Condition="FEATURE_COMINTEROP">
-      <Member Name="get_Current"/>
-      <Member Name="get_HasCurrent" />
-      <Member Name="MoveNext"/>
-      <Member Name="GetMany(T[])"/>
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.BindableIterableToEnumerableAdapter" Condition="FEATURE_COMINTEROP">
-      <Member Name="GetEnumerator_Stub" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.BindableVectorToCollectionAdapter" Condition="FEATURE_COMINTEROP">
-      <Member Name="Count" />
-      <Member Name="IsSynchronized" />
-      <Member Name="SyncRoot" />
-      <Member Name="CopyTo(System.Array,System.Int32)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.BindableVectorToListAdapter" Condition="FEATURE_COMINTEROP">
-      <Member Name="Indexer_Get(System.Int32)" />
-      <Member Name="Indexer_Set(System.Int32,System.Object)" />
-      <Member Name="Add(System.Object)" />
-      <Member Name="Contains(System.Object)" />
-      <Member Name="Clear" />
-      <Member Name="IsFixedSize" />
-      <Member Name="IsReadOnly" />
-      <Member Name="IndexOf(System.Object)" />
-      <Member Name="Insert(System.Int32,System.Object)" />
-      <Member Name="Remove(System.Object)" />
-      <Member Name="RemoveAt(System.Int32)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.CLRIReferenceImpl&lt;T&gt;" Condition="FEATURE_COMINTEROP">
-      <Member Name="UnboxHelper(System.Object)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.CLRIKeyValuePairImpl&lt;K,V&gt;" Condition="FEATURE_COMINTEROP">
-      <Member Name="BoxHelper(System.Object)" />
-      <Member Name="UnboxHelper(System.Object)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.CLRIReferenceArrayImpl&lt;T&gt;" Condition="FEATURE_COMINTEROP">
-      <Member Name="UnboxHelper(System.Object)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.WindowsRuntime.DefaultInterfaceAttribute" Condition="FEATURE_COMINTEROP">
-      <Member Name="#ctor(System.Type)" />
-      <Member MemberType="Property" Name="DefaultInterface" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.WindowsRuntime.ReadOnlyArrayAttribute" Condition="FEATURE_COMINTEROP">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.WindowsRuntime.ReturnValueNameAttribute" Condition="FEATURE_COMINTEROP">
-      <Member Name="#ctor(System.String)" />
-      <Member MemberType="Property" Name="Name" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.WindowsRuntime.WriteOnlyArrayAttribute" Condition="FEATURE_COMINTEROP">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.DictionaryToMapAdapter" Condition="FEATURE_COMINTEROP">
-      <Member Name="Lookup&lt;K,V&gt;(K)" />
-      <Member Name="Size&lt;K,V&gt;" />
-      <Member Name="HasKey&lt;K,V&gt;(K)" />
-      <Member Name="GetView&lt;K,V&gt;" />
-      <Member Name="Insert&lt;K,V&gt;(K,V)" />
-      <Member Name="Remove&lt;K,V&gt;(K)" />
-      <Member Name="Clear&lt;K,V&gt;" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.VectorViewToReadOnlyCollectionAdapter" Condition="FEATURE_COMINTEROP">
-      <Member Name="Count&lt;T&gt;" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.MapViewToReadOnlyCollectionAdapter" Condition="FEATURE_COMINTEROP">
-      <Member Name="Count&lt;K,V&gt;" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.EnumerableToBindableIterableAdapter" Condition="FEATURE_COMINTEROP">
-      <Member Name="First_Stub" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.EnumerableToIterableAdapter" Condition="FEATURE_COMINTEROP">
-      <Member Name="First_Stub&lt;T&gt;" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken" Condition="FEATURE_COMINTEROP">
-      <Member Name="op_Equality(System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken,System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken)" />
-      <Member Name="op_Inequality(System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken,System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.WindowsRuntime.EventRegistrationTokenTable&lt;T&gt;" Condition="FEATURE_COMINTEROP">
-      <Member Name="#ctor"/>
-      <Member Name="get_InvocationList"/>
-      <Member Name="set_InvocationList(T)"/>
-      <Member MemberType="Property" Name="InvocationList"/>
-      <Member Name="AddEventHandler(T)"/>
-      <Member Name="RemoveEventHandler(System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken)"/>
-      <Member Name="RemoveEventHandler(T)"/>
-      <Member Status="ApiFxInternal" Name="ExtractHandler(System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken)" />
-      <Member Name="GetOrCreateEventRegistrationTokenTable(System.Runtime.InteropServices.WindowsRuntime.EventRegistrationTokenTable&lt;T&gt;@)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.GetEnumerator_Delegate&lt;T@&gt;" Condition="FEATURE_COMINTEROP">
-      <Member Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Name="BeginInvoke(System.AsyncCallback,System.Object)" />
-      <Member Name="EndInvoke(System.IAsyncResult)" />
-      <Member Name="Invoke" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IActivationFactory" Condition="FEATURE_COMINTEROP">
-      <Member Name="ActivateInstance"/>
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IBindableIterable" Condition="FEATURE_COMINTEROP">
-      <Member Name="First" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IBindableIterator" Condition="FEATURE_COMINTEROP">
-      <Member Name="get_Current" />
-      <Member MemberType="Property" Name="Current" />
-      <Member Name="get_HasCurrent" />
-      <Member MemberType="Property" Name="HasCurrent" />
-      <Member Name="MoveNext" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IBindableVector" Condition="FEATURE_COMINTEROP">
-      <Member Name="GetAt(System.UInt32)" />
-      <Member Name="get_Size" />
-      <Member MemberType="Property" Name="Size" />
-      <Member Name="GetView" />
-      <Member Name="IndexOf(System.Object,System.UInt32@)" />
-      <Member Name="SetAt(System.UInt32,System.Object)" />
-      <Member Name="InsertAt(System.UInt32,System.Object)" />
-      <Member Name="RemoveAt(System.UInt32)" />
-      <Member Name="Append(System.Object)" />
-      <Member Name="RemoveAtEnd" />
-      <Member Name="Clear" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IBindableVectorView" Condition="FEATURE_COMINTEROP">
-      <Member Name="GetAt(System.UInt32)" />
-      <Member Name="get_Size" />
-      <Member MemberType="Property" Name="Size" />
-      <Member Name="IndexOf(System.Object,System.UInt32@)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IClosable" Condition="FEATURE_COMINTEROP">
-      <Member Name="Close"/>
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IDisposableToIClosableAdapter" Condition="FEATURE_COMINTEROP">
-      <Member Name="#ctor"/>
-      <Member Name="Close"/>
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IClosableToIDisposableAdapter" Condition="FEATURE_COMINTEROP">
-      <Member Name="#ctor"/>
-      <Member Name="Dispose"/>
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.ICustomProperty" Condition="FEATURE_COMINTEROP">
-      <Member Name="GetValue(System.Object)"/>
-      <Member Name="GetValue(System.Object,System.Object)"/>
-      <Member Name="SetValue(System.Object,System.Object)"/>
-      <Member Name="SetValue(System.Object,System.Object,System.Object)"/>
-      <Member Name="get_CanRead"/>
-      <Member Name="get_CanWrite"/>
-      <Member Name="get_Name"/>
-      <Member Name="get_Type"/>
-      <Member MemberType="Property" Name="CanRead"/>
-      <Member MemberType="Property" Name="CanWrite"/>
-      <Member MemberType="Property" Name="Name"/>
-      <Member MemberType="Property" Name="Type"/>
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.ICustomPropertyProviderImpl" Condition="FEATURE_COMINTEROP">
-      <Member Name="CreateProperty(System.Object,System.String)" />
-      <Member Name="CreateIndexedProperty(System.Object,System.String,System.StubHelpers.TypeNameNative*)" />
-      <Member Name="GetType(System.Object,System.StubHelpers.TypeNameNative*)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.ICustomPropertyProviderProxy" Condition="FEATURE_COMINTEROP">
-      <Member Name="CreateInstance(System.Object)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IIterable&lt;T&gt;" Condition="FEATURE_COMINTEROP">
-      <Member Name="First" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IKeyValuePair&lt;K,V&gt;" Condition="FEATURE_COMINTEROP">
-      <Member Name="get_Key" />
-      <Member Name="get_Value" />
-      <Member MemberType="Property" Name="Key" />
-      <Member MemberType="Property" Name="Value" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IMap&lt;K,V&gt;" Condition="FEATURE_COMINTEROP">
-      <Member Name="Lookup(K)" />
-      <Member Name="get_Size" />
-      <Member Name="Size" MemberType="Property" />
-      <Member Name="HasKey(K)" />
-      <Member Name="GetView" />
-      <Member Name="Insert(K,V)" />
-      <Member Name="Remove(K)" />
-      <Member Name="Clear" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.Indexer_Get_Delegate&lt;T@&gt;" Condition="FEATURE_COMINTEROP">
-      <Member Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Name="BeginInvoke(System.Int32,System.AsyncCallback,System.Object)" />
-      <Member Name="EndInvoke(System.IAsyncResult)" />
-      <Member Name="Invoke(System.Int32)" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Runtime.InteropServices.WindowsRuntime.InterfaceImplementedInVersionAttribute" Condition="FEATURE_COMINTEROP">
-      <Member Name="#ctor(System.Type,System.Byte,System.Byte,System.Byte,System.Byte)"/>
-      <Member MemberType="Property" Name="BuildVersion" />
-      <Member MemberType="Property" Name="MajorVersion" />
-      <Member MemberType="Property" Name="MinorVersion" />
-      <Member MemberType="Property" Name="RevisionVersion" />
-      <Member MemberType="Property" Name="InterfaceType" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IterableToEnumerableAdapter" Condition="FEATURE_COMINTEROP">
-      <Member Name="GetEnumerator_Stub&lt;T&gt;" />
-      <Member Name="GetEnumerator_Variance_Stub&lt;T&gt;" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IMapView&lt;K,V&gt;" Condition="FEATURE_COMINTEROP">
-      <Member Name="Lookup(K)" />
-      <Member Name="get_Size" />
-      <Member Name="Size" MemberType="Property" />
-      <Member Name="HasKey(K)" />
-      <Member Name="Split(System.Runtime.InteropServices.WindowsRuntime.IMapView&lt;K,V&gt;@,System.Runtime.InteropServices.WindowsRuntime.IMapView&lt;K,V&gt;@)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IMapViewToIReadOnlyDictionaryAdapter" Condition="FEATURE_COMINTEROP">
-      <Member Name="Indexer_Get&lt;K,V&gt;(K)" />
-      <Member Name="Keys&lt;K,V&gt;" />
-      <Member Name="Values&lt;K,V&gt;" />
-      <Member Name="ContainsKey&lt;K,V&gt;(K)" />
-      <Member Name="TryGetValue&lt;K,V&gt;(K,V@)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IPropertyValue" Condition="FEATURE_COMINTEROP">
-      <Member Name="get_Type"/>
-      <Member MemberType="Property" Name="Type"/>
-      <Member Name="get_IsNumericScalar"/>
-      <Member MemberType="Property" Name="IsNumericScalar"/>
-      <Member Name="GetUInt8" />
-      <Member Name="GetInt16" />
-      <Member Name="GetUInt16" />
-      <Member Name="GetInt32" />
-      <Member Name="GetUInt32" />
-      <Member Name="GetInt64" />
-      <Member Name="GetUInt64" />
-      <Member Name="GetSingle" />
-      <Member Name="GetDouble" />
-      <Member Name="GetChar16" />
-      <Member Name="GetBoolean" />
-      <Member Name="GetString" />
-      <Member Name="GetGuid" />
-      <Member Name="GetDateTime" />
-      <Member Name="GetTimeSpan" />
-      <Member Name="GetPoint" />
-      <Member Name="GetSize" />
-      <Member Name="GetRect" />
-      <Member Name="GetUInt8Array" />
-      <Member Name="GetInt16Array" />
-      <Member Name="GetUInt16Array" />
-      <Member Name="GetInt32Array" />
-      <Member Name="GetUInt32Array" />
-      <Member Name="GetInt64Array" />
-      <Member Name="GetUInt64Array" />
-      <Member Name="GetSingleArray" />
-      <Member Name="GetDoubleArray" />
-      <Member Name="GetChar16Array" />
-      <Member Name="GetBooleanArray" />
-      <Member Name="GetStringArray" />
-      <Member Name="GetInspectableArray" />
-      <Member Name="GetGuidArray" />
-      <Member Name="GetDateTimeArray" />
-      <Member Name="GetTimeSpanArray" />
-      <Member Name="GetPointArray" />
-      <Member Name="GetSizeArray" />
-      <Member Name="GetRectArray" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IReadOnlyDictionaryToIMapViewAdapter" Condition="FEATURE_COMINTEROP">
-      <Member Name="Lookup&lt;K,V&gt;(K)" />
-      <Member Name="Size&lt;K,V&gt;" />
-      <Member Name="HasKey&lt;K,V&gt;(K)" />
-      <Member Name="Split&lt;K,V&gt;(System.Runtime.InteropServices.WindowsRuntime.IMapView&lt;K,V&gt;@,System.Runtime.InteropServices.WindowsRuntime.IMapView&lt;K,V&gt;@)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListToIVectorViewAdapter" Condition="FEATURE_COMINTEROP">
-      <Member Name="GetAt&lt;T&gt;(System.UInt32)" />
-      <Member Name="Size&lt;T&gt;" />
-      <Member Name="IndexOf&lt;T&gt;(T,System.UInt32@)" />
-      <Member Name="GetMany&lt;T&gt;(System.UInt32,T[])" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IReferenceFactory" Condition="FEATURE_COMINTEROP">
-      <Member Name="CreateIReference(System.Object)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IRestrictedErrorInfo" Condition="FEATURE_COMINTEROP">
-      <Member Name="GetErrorDetails(System.String@,System.Int32@,System.String@,System.String@)" />
-      <Member Name="GetReference(System.String@)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IVector&lt;T&gt;" Condition="FEATURE_COMINTEROP">
-      <Member Name="GetAt(System.UInt32)" />
-      <Member Name="get_Size" />
-      <Member Name="Size" MemberType="Property" />
-      <Member Name="GetView" />
-      <Member Name="IndexOf(T,System.UInt32@)" />
-      <Member Name="SetAt(System.UInt32,T)" />
-      <Member Name="RemoveAt(System.UInt32)" />
-      <Member Name="Append(T)" />
-      <Member Name="RemoveAtEnd" />
-      <Member Name="Clear" />
-      <Member Name="GetMany(System.UInt32,T[])" />
-      <Member Name="ReplaceAll(T[])" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IVectorView&lt;T&gt;" Condition="FEATURE_COMINTEROP">
-      <Member Name="GetAt(System.UInt32)" />
-      <Member Name="get_Size" />
-      <Member Name="Size" MemberType="Property" />
-      <Member Name="IndexOf(T,System.UInt32@)" />
-      <Member Name="GetMany(System.UInt32,T[])" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IVectorViewToIReadOnlyListAdapter" Condition="FEATURE_COMINTEROP">
-      <Member Name="Indexer_Get&lt;T&gt;(System.Int32)" />
-      <Member Name="Indexer_Get_Variance&lt;T&gt;(System.Int32)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.ListToBindableVectorAdapter" Condition="FEATURE_COMINTEROP">
-      <Member Name="GetAt(System.UInt32)" />
-      <Member Name="Size" />
-      <Member Name="GetView" />
-      <Member Name="IndexOf(System.Object,System.UInt32@)" />
-      <Member Name="SetAt(System.UInt32,System.Object)" />
-      <Member Name="InsertAt(System.UInt32,System.Object)" />
-      <Member Name="RemoveAt(System.UInt32)" />
-      <Member Name="Append(System.Object)" />
-      <Member Name="RemoveAtEnd" />
-      <Member Name="Clear" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.ListToVectorAdapter" Condition="FEATURE_COMINTEROP">
-      <Member Name="GetAt&lt;T&gt;(System.UInt32)" />
-      <Member Name="Size&lt;T&gt;" />
-      <Member Name="GetView&lt;T&gt;" />
-      <Member Name="IndexOf&lt;T&gt;(T,System.UInt32@)" />
-      <Member Name="SetAt&lt;T&gt;(System.UInt32,T)" />
-      <Member Name="InsertAt&lt;T&gt;(System.UInt32,T)" />
-      <Member Name="RemoveAt&lt;T&gt;(System.UInt32)" />
-      <Member Name="Append&lt;T&gt;(T)" />
-      <Member Name="RemoveAtEnd&lt;T&gt;" />
-      <Member Name="Clear&lt;T&gt;" />
-      <Member Name="GetMany&lt;T&gt;(System.UInt32,T[])" />
-      <Member Name="ReplaceAll&lt;T&gt;(T[])" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.MapToCollectionAdapter" Condition="FEATURE_COMINTEROP">
-      <Member Name="Count&lt;K,V&gt;" />
-      <Member Name="IsReadOnly&lt;K,V&gt;" />
-      <Member Name="Add&lt;K,V&gt;(System.Collections.Generic.KeyValuePair&lt;K,V&gt;)" />
-      <Member Name="Clear&lt;K,V&gt;" />
-      <Member Name="Contains&lt;K,V&gt;(System.Collections.Generic.KeyValuePair&lt;K,V&gt;)" />
-      <Member Name="CopyTo&lt;K,V&gt;(System.Collections.Generic.KeyValuePair&lt;K,V&gt;[],System.Int32)" />
-      <Member Name="Remove&lt;K,V&gt;(System.Collections.Generic.KeyValuePair&lt;K,V&gt;)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.MapToDictionaryAdapter" Condition="FEATURE_COMINTEROP">
-      <Member Name="Indexer_Get&lt;K,V&gt;(K)" />
-      <Member Name="Indexer_Set&lt;K,V&gt;(K,V)" />
-      <Member Name="Keys&lt;K,V&gt;" />
-      <Member Name="Values&lt;K,V&gt;" />
-      <Member Name="ContainsKey&lt;K,V&gt;(K)" />
-      <Member Name="Add&lt;K,V&gt;(K,V)" />
-      <Member Name="Remove&lt;K,V&gt;(K)" />
-      <Member Name="TryGetValue&lt;K,V&gt;(K,V@)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.RuntimeClass" Condition="FEATURE_COMINTEROP" />
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.VectorToCollectionAdapter" Condition="FEATURE_COMINTEROP">
-      <Member Name="Count&lt;T&gt;" />
-      <Member Name="IsReadOnly&lt;T&gt;" />
-      <Member Name="Add&lt;T&gt;(T)" />
-      <Member Name="Clear&lt;T&gt;" />
-      <Member Name="Contains&lt;T&gt;(T)" />
-      <Member Name="CopyTo&lt;T&gt;(T[],System.Int32)" />
-      <Member Name="Remove&lt;T&gt;(T)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.VectorToListAdapter" Condition="FEATURE_COMINTEROP">
-      <Member Name="Indexer_Get&lt;T&gt;(System.Int32)" />
-      <Member Name="Indexer_Set&lt;T&gt;(System.Int32,T)" />
-      <Member Name="IndexOf&lt;T&gt;(T)" />
-      <Member Name="Insert&lt;T&gt;(System.Int32,T)" />
-      <Member Name="RemoveAt&lt;T&gt;(System.Int32)" />
-    </Type>
-    <Type Status="ApiFxInternal" Name="System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeImportAttribute" Condition="FEATURE_COMINTEROP">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.WindowsFoundationEventHandler&lt;T&gt;" Condition="FEATURE_COMINTEROP">
-      <Member Name="#ctor(System.Object,System.IntPtr)" />
-      <Member Name="BeginInvoke(System.Object,T,System.AsyncCallback,System.Object)" />
-      <Member Name="EndInvoke(System.IAsyncResult)" />
-      <Member Name="Invoke(System.Object,T)" />
-    </Type>
-    <Type Status="ApiFxInternal" Name="System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeBufferHelper" Condition="FEATURE_COMINTEROP">
-      <Member Name="StoreOverlappedPtrInCCW(System.Runtime.CompilerServices.ObjectHandleOnStack,System.Threading.NativeOverlapped*)" />
-      <Member Name="StoreOverlappedInCCW(System.Object,System.Threading.NativeOverlapped*)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.WindowsRuntime.IManagedActivationFactory" Condition="FEATURE_COMINTEROP">
-      <Member Name="RunClassConstructor" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal" Condition="FEATURE_COMINTEROP">
-      <Member Status="ApiRoot" Name="GetRegistrationTokenCacheSize" />
-      <Member Name="AddEventHandler&lt;T&gt;(System.Func&lt;T,System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken&gt;,System.Action&lt;System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken&gt;,T)" />
-      <Member Name="FreeHString(System.IntPtr)" />
-      <Member Name="GetActivationFactory(System.Type)" />
-      <Member Name="GetActivationFactoryForType(System.Type)" />
-      <Member Name="GetManagedActivationFactory(System.Type)" />
-      <Member Name="PtrToStringHString(System.IntPtr)" />
-      <Member Name="RemoveAllEventHandlers(System.Action&lt;System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken&gt;)" />
-      <Member Name="RemoveEventHandler&lt;T&gt;(System.Action&lt;System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken&gt;,T)" />
-      <Member Name="StringToHString(System.String)" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Runtime.Versioning.TargetFrameworkAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member MemberType="Property" Name="FrameworkName" />
-      <Member MemberType="Property" Name="FrameworkDisplayName" />
-    </Type>
-    <Type Name="System.Runtime.Serialization.FormatterServices">
-        <Member Name="GetUninitializedObject(System.Type)" />
-    </Type>
-    <Type Name="System.Runtime.Serialization.OptionalFieldAttribute">
-      <Member Name="#ctor" />
-      <Member MemberType="Property" Name="VersionAdded" />
-    </Type>
-    <Type Name="System.Runtime.Serialization.SerializationEntry">
-      <Member MemberType="Property" Name="Value" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="ObjectType" />
-    </Type>
-    <Type Name="System.Runtime.Serialization.SerializationException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Runtime.Serialization.SerializationInfo">
-      <Member Name="#ctor(System.Type,System.Runtime.Serialization.IFormatterConverter)" />
-      <Member Name="#ctor(System.Type,System.Runtime.Serialization.IFormatterConverter,System.Boolean)" />
-      <Member Name="SetType(System.Type)" />
-      <Member Name="GetEnumerator" />
-      <Member Name="AddValue(System.String,System.Object,System.Type)" />
-      <Member Name="AddValue(System.String,System.Object)" />
-      <Member Name="AddValue(System.String,System.Boolean)" />
-      <Member Name="AddValue(System.String,System.Char)" />
-      <Member Name="AddValue(System.String,System.SByte)" />
-      <Member Name="AddValue(System.String,System.Byte)" />
-      <Member Name="AddValue(System.String,System.Int16)" />
-      <Member Name="AddValue(System.String,System.UInt16)" />
-      <Member Name="AddValue(System.String,System.Int32)" />
-      <Member Name="AddValue(System.String,System.UInt32)" />
-      <Member Name="AddValue(System.String,System.Int64)" />
-      <Member Name="AddValue(System.String,System.UInt64)" />
-      <Member Name="AddValue(System.String,System.Single)" />
-      <Member Name="AddValue(System.String,System.Double)" />
-      <Member Name="AddValue(System.String,System.Decimal)" />
-      <Member Name="AddValue(System.String,System.DateTime)" />
-      <Member Name="GetValue(System.String,System.Type)" />
-      <Member Name="GetBoolean(System.String)" />
-      <Member Name="GetChar(System.String)" />
-      <Member Name="GetSByte(System.String)" />
-      <Member Name="GetByte(System.String)" />
-      <Member Name="GetInt16(System.String)" />
-      <Member Name="GetUInt16(System.String)" />
-      <Member Name="GetInt32(System.String)" />
-      <Member Name="GetUInt32(System.String)" />
-      <Member Name="GetInt64(System.String)" />
-      <Member Name="GetUInt64(System.String)" />
-      <Member Name="GetSingle(System.String)" />
-      <Member Name="GetDouble(System.String)" />
-      <Member Name="GetDecimal(System.String)" />
-      <Member Name="GetDateTime(System.String)" />
-      <Member Name="GetString(System.String)" />
-      <Member Name="UpdateValue(System.String,System.Object,System.Type)" />
-      <Member MemberType="Property" Name="FullTypeName" />
-      <Member MemberType="Property" Name="AssemblyName" />
-      <Member MemberType="Property" Name="MemberCount" />
-      <Member MemberType="Property" Name="ObjectType" />
-      <Member MemberType="Property" Name="IsFullTypeNameSetExplicit" />
-      <Member MemberType="Property" Name="IsAssemblyNameSetExplicit" />
-    </Type>
-    <Type Name="System.Runtime.Serialization.SerializationInfoEnumerator">
-      <Member Name="MoveNext" />
-      <Member Name="Reset" />
-      <Member Name="System.Collections.IEnumerator.get_Current" />
-      <Member MemberType="Property" Name="Current" />
-      <Member MemberType="Property" Name="Name" />
-      <Member MemberType="Property" Name="Value" />
-      <Member MemberType="Property" Name="ObjectType" />
-    </Type>
-    <Type Name="System.Runtime.Serialization.IObjectReference">
-      <Member Name="GetRealObject(System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Runtime.Serialization.ISerializable">
-      <Member Name="GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Runtime.Serialization.IFormatterConverter">
-      <Member Name="Convert(System.Object,System.Type)" />
-      <Member Name="Convert(System.Object,System.TypeCode)" />
-      <Member Name="ToBoolean(System.Object)" />
-      <Member Name="ToChar(System.Object)" />
-      <Member Name="ToSByte(System.Object)" />
-      <Member Name="ToByte(System.Object)" />
-      <Member Name="ToInt16(System.Object)" />
-      <Member Name="ToUInt16(System.Object)" />
-      <Member Name="ToInt32(System.Object)" />
-      <Member Name="ToUInt32(System.Object)" />
-      <Member Name="ToInt64(System.Object)" />
-      <Member Name="ToUInt64(System.Object)" />
-      <Member Name="ToSingle(System.Object)" />
-      <Member Name="ToDouble(System.Object)" />
-      <Member Name="ToDecimal(System.Object)" />
-      <Member Name="ToDateTime(System.Object)" />
-      <Member Name="ToString(System.Object)" />
-    </Type>
-    <Type Name="System.Runtime.Serialization.IDeserializationCallback">
-      <Member Name="OnDeserialization(System.Object)" />
-    </Type>
-    <Type Name="System.Runtime.Serialization.ISafeSerializationData">
-      <Member Name="CompleteDeserialization(System.Object)" />
-    </Type>
-    <Type Name="System.Runtime.Serialization.SafeSerializationEventArgs">
-      <Member Name="AddSerializedState(System.Runtime.Serialization.ISafeSerializationData)" />
-      <Member Name="get_StreamingContext" />
-      <Member MemberType="Property" Name="StreamingContext" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Runtime.Serialization.OnSerializingAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Runtime.Serialization.OnSerializedAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Runtime.Serialization.OnDeserializingAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Runtime.Serialization.OnDeserializedAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Runtime.Serialization.StreamingContext">
-      <Member Name="#ctor(System.Runtime.Serialization.StreamingContextStates)" />
-      <Member Name="#ctor(System.Runtime.Serialization.StreamingContextStates,System.Object)" />
-      <Member MemberType="Property" Name="Context" />
-      <Member MemberType="Property" Name="State" />
-    </Type>
-    <Type Status="ApiRoot" Name="System.Runtime.Serialization.StreamingContextStates">
-      <Member MemberType="Field" Name="CrossProcess" />
-      <Member MemberType="Field" Name="CrossMachine" />
-      <Member MemberType="Field" Name="File" />
-      <Member MemberType="Field" Name="Persistence" />
-      <Member MemberType="Field" Name="Remoting" />
-      <Member MemberType="Field" Name="Other" />
-      <Member MemberType="Field" Name="Clone" />
-      <Member MemberType="Field" Name="CrossAppDomain" />
-      <Member MemberType="Field" Name="All" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.RuntimeType">
-      <Member Status="ImplRoot" MemberType="Field" Name="m_keepalive" />
-      <Member Name="GetPropertyInfo(System.RuntimeType,System.Int32)" /> <!-- EE -->
-    </Type>
-    <Type Status="ImplRoot" Name="System.Security.CodeAccessPermission" />
-    <Type Status="ImplRoot" Name="System.Security.PermissionType" />
-    <Type Status="ImplRoot" Name="System.Security.CodeAccessSecurityEngine">
-      <Member Name="CheckHelper(System.Object,System.Security.PermissionSet,System.Security.PermissionSet,System.Security.CodeAccessPermission,System.Security.PermissionToken,System.RuntimeMethodHandleInternal,System.Reflection.RuntimeAssembly,System.Security.Permissions.SecurityAction)" /> <!-- EE -->
-      <Member Name="CheckSetHelper(System.Object,System.Security.PermissionSet,System.Security.PermissionSet,System.Security.PermissionSet,System.RuntimeMethodHandleInternal,System.Reflection.RuntimeAssembly,System.Security.Permissions.SecurityAction)" /> <!-- EE -->
-    </Type>
-    <Type Status="ImplRoot" Name="System.Security.DynamicSecurityMethodAttribute" />
-    <Type Status="ImplRoot" Name="System.Security.FrameSecurityDescriptor">
-      <Member MemberType="Field" Name="m_DeclarativeDenials" />
-      <Member MemberType="Field" Name="m_DeclarativeRestrictions" />
-      <Member MemberType="Field" Name="m_denials" />
-      <Member MemberType="Field" Name="m_restriction" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Security.PermissionListSet">
-      <Member Name="CheckDemandNoThrow(System.Security.CodeAccessPermission)" /> <!-- EE -->
-      <Member Name="CheckSetDemandNoThrow(System.Security.PermissionSet)" /> <!-- EE -->
-      <Member Name="Update(System.Security.PermissionSet)" /> <!-- EE -->
-    </Type>
-    <Type Name="System.Security.Cryptography.CryptographicException">
-      <Member Name="#ctor"/>
-      <Member Name="#ctor(System.Int32)"/>
-      <Member Name="#ctor(System.String)"/>
-      <Member Name="#ctor(System.String,System.Exception)"/>
-      <Member Name="#ctor(System.String,System.String)"/>
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
- 
-    <Type Status="ImplRoot" Name="System.Security.Permissions.PermissionState" />
-    <Type Status="ImplRoot" Name="System.Security.Permissions.SecurityPermission" />
-    <Type Status="ImplRoot" Name="System.Security.PermissionSet">
-      <Member MemberType="Field" Name="m_serializedPermissionSet" />  <!-- smosier: avoid changing layout of objects mirrored in EE for now -->
-      <Member MemberType="Field" Name="m_unrestrictedPermSet" />  <!-- smosier: avoid changing layout of objects mirrored in EE for now -->
-      <Member MemberType="Field" Name="m_normalPermSet" />  <!-- smosier: avoid changing layout of objects mirrored in EE for now -->
-      <Member MemberType="Field" Name="readableonly" />  <!-- smosier: avoid changing layout of objects mirrored in EE for now -->
-      <Member Name="CreateSerialized(System.Object[],System.Boolean,System.Byte[]@,System.Security.PermissionSet@,System.Security.Permissions.HostProtectionResource,System.Boolean)" /> <!-- EE -->
-      <Member Name="Contains(System.Security.IPermission)" /> <!-- EE -->
-      <Member Name="Demand" /> <!-- EE -->
-      <Member Name="DemandNonCAS" /> <!-- EE -->
-      <Member Name="Union(System.Security.PermissionSet)" /> <!-- EE -->
-    </Type>
-    <Type Status="ImplRoot" Name="System.Security.PermissionToken" />
-    <Type Status="ImplRoot" Name="System.Security.Policy.Evidence" />
-    <Type Name="System.Security.Principal.IIdentity">
-      <Member MemberType="Property" Name="AuthenticationType" />
-      <Member MemberType="Property" Name="IsAuthenticated" />
-      <Member MemberType="Property" Name="Name" />
-      <Member Name="get_AuthenticationType" />
-      <Member Name="get_IsAuthenticated" />
-      <Member Name="get_Name" />
-    </Type>
-    <Type Name="System.Security.Principal.IPrincipal">
-      <Member MemberType="Property" Name="Identity" />
-      <Member Name="IsInRole(System.String)" />
-      <Member Name ="get_Identity" />
-    </Type>
-    <Type Name="System.Security.Principal.TokenImpersonationLevel">
-      <Member MemberType="Field" Name="Anonymous" />
-      <Member MemberType="Field" Name="Delegation" />
-      <Member MemberType="Field" Name="Identification" />
-      <Member MemberType="Field" Name="Impersonation" />
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Security.SecurityRuntime">
-      <Member Name="FrameDescHelper(System.Security.FrameSecurityDescriptor,System.Security.IPermission,System.Security.PermissionToken,System.RuntimeMethodHandleInternal)" /> <!-- EE -->
-      <Member Name="FrameDescSetHelper(System.Security.FrameSecurityDescriptor,System.Security.PermissionSet,System.Security.PermissionSet@,System.RuntimeMethodHandleInternal)" /> <!-- EE -->
-    </Type>
-    <Type Name="System.Security.SecurityRulesAttribute">
-      <Member Name="#ctor(System.Security.SecurityRuleSet)" />
-      <Member Name="get_RuleSet" />
-      <Member Name="get_SkipVerificationInFullTrust" />
-      <Member Name="set_SkipVerificationInFullTrust(System.Boolean)" />
-      <Member MemberType="Property" Name="RuleSet" />
-      <Member MemberType="Property" Name="SkipVerificationInFullTrust" />
-    </Type>
-    <Type Name="System.Security.SecurityRuleSet">
-      <Member MemberType="Field" Name="Level1" />
-      <Member MemberType="Field" Name="Level2" />
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Security.SecuritySafeCriticalAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Security.SecurityTransparentAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Security.SecurityTreatAsSafeAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Security.SuppressUnmanagedCodeSecurityAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Security.UnverifiableCodeAttribute">
-      <Member Name="#ctor" />
-    </Type>
-    <Type Name="System.Security.VerificationException" >
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.SharedStatics">
-      <Member MemberType="Field"  Name="_sharedStatics" /> <!-- EE -->
-    </Type>
-    <Type Status="ImplRoot" Name="System.SZArrayHelper">
-      <Member Name="Add&lt;T&gt;(T)" />
-      <Member Name="Clear&lt;T&gt;" />
-      <Member Name="Contains&lt;T&gt;(T)" />
-      <Member Name="CopyTo&lt;T&gt;(T[],System.Int32)" />
-      <Member Name="get_Count&lt;T&gt;" />
-      <Member Name="get_IsReadOnly&lt;T&gt;" />
-      <Member Name="get_Item&lt;T&gt;(System.Int32)" />
-      <Member Name="GetEnumerator&lt;T&gt;" />
-      <Member Name="IndexOf&lt;T&gt;(T)" />
-      <Member Name="Insert&lt;T&gt;(System.Int32,T)" />
-      <Member Name="Remove&lt;T&gt;(T)" />
-      <Member Name="RemoveAt&lt;T&gt;(System.Int32)" />
-      <Member Name="set_Item&lt;T&gt;(System.Int32,T)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Threading._IOCompletionCallback">
-      <Member Name="PerformIOCompletionCallback(System.UInt32,System.UInt32,System.Threading.NativeOverlapped*)" /> <!-- EE -->
-    </Type>
-    <Type Status="ImplRoot" Name="System.Threading._ThreadPoolWaitCallback">
-      <Member Name="PerformWaitCallback" /> <!-- EE -->
-    </Type>
-    <Type Status="ImplRoot" Name="System.Threading._ThreadPoolWaitOrTimerCallback">
-      <Member Name="PerformWaitOrTimerCallback(System.Object,System.Boolean)" /> <!-- EE -->
-    </Type>
-    <Type Status="ImplRoot" Name="System.Threading.TimerQueue">
-      <Member Name="AppDomainTimerCallback" /> <!-- EE -->
-    </Type>
-    <Type Status="ImplRoot" Name="System.Threading.InternalCrossContextDelegate" />
-    <Type Status="ImplRoot" Name="System.Threading.OverlappedData" />
-    <Type Name="System.Threading.ThreadInterruptedException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.ThreadStaticAttribute">
-        <Member Name="#ctor" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.InteropServices.PInvokeMap" />
-    <Type Name="System.ArgIterator">  <!-- for MC++ -->
-      <Member Status="ImplRoot" Name="#ctor(System.RuntimeArgumentHandle,System.Void*)" /> <!-- EE - il stubs -->
-    </Type>
-        <Type Name="System.Runtime.InteropServices.BestFitMappingAttribute">
-      <Member MemberType="Field" Name="ThrowOnUnmappableChar" />
-      <Member Name="#ctor(System.Boolean)" />
-      <Member MemberType="Property" Name="BestFitMapping" />
-      <Member Name="get_BestFitMapping" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComEventInterfaceAttribute">
-      <Member Name="#ctor(System.Type,System.Type)" />
-      <Member MemberType="Property" Name="EventProvider" />
-      <Member MemberType="Property" Name="SourceInterface" />
-      <Member Name="get_EventProvider" />
-      <Member Name="get_SourceInterface" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComEventsHelper">
-      <Member Name="Combine(System.Object,System.Guid,System.Int32,System.Delegate)" />
-      <Member Name="Remove(System.Object,System.Guid,System.Int32,System.Delegate)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComMemberType">
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="Method" />
-      <Member MemberType="Field" Name="PropGet" />
-      <Member MemberType="Field" Name="PropSet" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComSourceInterfacesAttribute">
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.Type)" />
-      <Member Name="#ctor(System.Type,System.Type)" />
-      <Member Name="#ctor(System.Type,System.Type,System.Type)" />
-      <Member Name="#ctor(System.Type,System.Type,System.Type,System.Type)" />
-      <Member MemberType="Property" Name="Value" />
-      <Member Name="get_Value" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.CustomQueryInterfaceMode">
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="Allow" />
-      <Member MemberType="Field" Name="Ignore" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.CustomQueryInterfaceResult">
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="Failed" />
-      <Member MemberType="Field" Name="Handled" />
-      <Member MemberType="Field" Name="NotHandled" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.DefaultDllImportSearchPathsAttribute">
-      <Member Name="#ctor(System.Runtime.InteropServices.DllImportSearchPath)" />
-      <Member MemberType="Property" Name="Paths" />
-      <Member Name="get_Paths" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.DllImportSearchPath">
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="ApplicationDirectory" />
-      <Member MemberType="Field" Name="AssemblyDirectory" />
-      <Member MemberType="Field" Name="LegacyBehavior" />
-      <Member MemberType="Field" Name="SafeDirectories" />
-      <Member MemberType="Field" Name="System32" />
-      <Member MemberType="Field" Name="UseDllDirectoryForDependencies" />
-      <Member MemberType="Field" Name="UserDirectories" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ICustomAdapter">
-      <Member Name="GetUnderlyingObject" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.SafeBuffer">
-      <Member Name="#ctor(System.Boolean)" />
-      <Member MemberType="Property" Name="ByteLength" />
-      <Member Name="AcquirePointer(System.Byte*@)" />
-      <Member Name="get_ByteLength" />
-      <Member Name="Initialize(System.UInt32,System.UInt32)" />
-      <Member Name="Initialize(System.UInt64)" />
-      <Member Name="Initialize&lt;T&gt;(System.UInt32)" />
-      <Member Name="Read&lt;T&gt;(System.UInt64)" />
-      <Member Name="ReadArray&lt;T&gt;(System.UInt64,T[],System.Int32,System.Int32)" />
-      <Member Name="ReleasePointer" />
-      <Member Name="Write&lt;T&gt;(System.UInt64,T)" />
-      <Member Name="WriteArray&lt;T&gt;(System.UInt64,T[],System.Int32,System.Int32)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.TypeIdentifierAttribute">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String,System.String)" />
-      <Member MemberType="Property" Name="Identifier" />
-      <Member MemberType="Property" Name="Scope" />
-      <Member Name="get_Identifier" />
-      <Member Name="get_Scope" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.VarEnum">
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="VT_ARRAY" />
-      <Member MemberType="Field" Name="VT_BLOB" />
-      <Member MemberType="Field" Name="VT_BLOB_OBJECT" />
-      <Member MemberType="Field" Name="VT_BOOL" />
-      <Member MemberType="Field" Name="VT_BSTR" />
-      <Member MemberType="Field" Name="VT_BYREF" />
-      <Member MemberType="Field" Name="VT_CARRAY" />
-      <Member MemberType="Field" Name="VT_CF" />
-      <Member MemberType="Field" Name="VT_CLSID" />
-      <Member MemberType="Field" Name="VT_CY" />
-      <Member MemberType="Field" Name="VT_DATE" />
-      <Member MemberType="Field" Name="VT_DECIMAL" />
-      <Member MemberType="Field" Name="VT_DISPATCH" />
-      <Member MemberType="Field" Name="VT_EMPTY" />
-      <Member MemberType="Field" Name="VT_ERROR" />
-      <Member MemberType="Field" Name="VT_FILETIME" />
-      <Member MemberType="Field" Name="VT_HRESULT" />
-      <Member MemberType="Field" Name="VT_I1" />
-      <Member MemberType="Field" Name="VT_I2" />
-      <Member MemberType="Field" Name="VT_I4" />
-      <Member MemberType="Field" Name="VT_I8" />
-      <Member MemberType="Field" Name="VT_INT" />
-      <Member MemberType="Field" Name="VT_LPSTR" />
-      <Member MemberType="Field" Name="VT_LPWSTR" />
-      <Member MemberType="Field" Name="VT_NULL" />
-      <Member MemberType="Field" Name="VT_PTR" />
-      <Member MemberType="Field" Name="VT_R4" />
-      <Member MemberType="Field" Name="VT_R8" />
-      <Member MemberType="Field" Name="VT_RECORD" />
-      <Member MemberType="Field" Name="VT_SAFEARRAY" />
-      <Member MemberType="Field" Name="VT_STORAGE" />
-      <Member MemberType="Field" Name="VT_STORED_OBJECT" />
-      <Member MemberType="Field" Name="VT_STREAM" />
-      <Member MemberType="Field" Name="VT_STREAMED_OBJECT" />
-      <Member MemberType="Field" Name="VT_UI1" />
-      <Member MemberType="Field" Name="VT_UI2" />
-      <Member MemberType="Field" Name="VT_UI4" />
-      <Member MemberType="Field" Name="VT_UI8" />
-      <Member MemberType="Field" Name="VT_UINT" />
-      <Member MemberType="Field" Name="VT_UNKNOWN" />
-      <Member MemberType="Field" Name="VT_USERDEFINED" />
-      <Member MemberType="Field" Name="VT_VARIANT" />
-      <Member MemberType="Field" Name="VT_VECTOR" />
-      <Member MemberType="Field" Name="VT_VOID" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.BIND_OPTS">
-      <Member MemberType="Field" Name="cbStruct" />
-      <Member MemberType="Field" Name="dwTickCountDeadline" />
-      <Member MemberType="Field" Name="grfFlags" />
-      <Member MemberType="Field" Name="grfMode" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.BINDPTR">
-      <Member MemberType="Field" Name="lpfuncdesc" />
-      <Member MemberType="Field" Name="lptcomp" />
-      <Member MemberType="Field" Name="lpvardesc" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.CALLCONV">
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="CC_CDECL" />
-      <Member MemberType="Field" Name="CC_MACPASCAL" />
-      <Member MemberType="Field" Name="CC_MAX" />
-      <Member MemberType="Field" Name="CC_MPWCDECL" />
-      <Member MemberType="Field" Name="CC_MPWPASCAL" />
-      <Member MemberType="Field" Name="CC_MSCPASCAL" />
-      <Member MemberType="Field" Name="CC_PASCAL" />
-      <Member MemberType="Field" Name="CC_RESERVED" />
-      <Member MemberType="Field" Name="CC_STDCALL" />
-      <Member MemberType="Field" Name="CC_SYSCALL" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.CONNECTDATA">
-      <Member MemberType="Field" Name="dwCookie" />
-      <Member MemberType="Field" Name="pUnk" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.DESCKIND">
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="DESCKIND_FUNCDESC" />
-      <Member MemberType="Field" Name="DESCKIND_IMPLICITAPPOBJ" />
-      <Member MemberType="Field" Name="DESCKIND_MAX" />
-      <Member MemberType="Field" Name="DESCKIND_NONE" />
-      <Member MemberType="Field" Name="DESCKIND_TYPECOMP" />
-      <Member MemberType="Field" Name="DESCKIND_VARDESC" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.DISPPARAMS">
-      <Member MemberType="Field" Name="cArgs" />
-      <Member MemberType="Field" Name="cNamedArgs" />
-      <Member MemberType="Field" Name="rgdispidNamedArgs" />
-      <Member MemberType="Field" Name="rgvarg" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.ELEMDESC">
-      <Member MemberType="Field" Name="desc" />
-      <Member MemberType="Field" Name="tdesc" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.ELEMDESC+DESCUNION">
-      <Member MemberType="Field" Name="idldesc" />
-      <Member MemberType="Field" Name="paramdesc" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.EXCEPINFO">
-      <Member MemberType="Field" Name="wCode" />
-      <Member MemberType="Field" Name="wReserved" />
-      <Member MemberType="Field" Name="dwHelpContext" />
-      <Member MemberType="Field" Name="scode" />
-      <Member MemberType="Field" Name="pfnDeferredFillIn" />
-      <Member MemberType="Field" Name="pvReserved" />
-      <Member MemberType="Field" Name="bstrDescription" />
-      <Member MemberType="Field" Name="bstrHelpFile" />
-      <Member MemberType="Field" Name="bstrSource" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.FUNCDESC">
-      <Member MemberType="Field" Name="cParams" />
-      <Member MemberType="Field" Name="cParamsOpt" />
-      <Member MemberType="Field" Name="cScodes" />
-      <Member MemberType="Field" Name="oVft" />
-      <Member MemberType="Field" Name="wFuncFlags" />
-      <Member MemberType="Field" Name="memid" />
-      <Member MemberType="Field" Name="lprgelemdescParam" />
-      <Member MemberType="Field" Name="lprgscode" />
-      <Member MemberType="Field" Name="callconv" />
-      <Member MemberType="Field" Name="elemdescFunc" />
-      <Member MemberType="Field" Name="funckind" />
-      <Member MemberType="Field" Name="invkind" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.FUNCFLAGS">
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="FUNCFLAG_FBINDABLE" />
-      <Member MemberType="Field" Name="FUNCFLAG_FDEFAULTBIND" />
-      <Member MemberType="Field" Name="FUNCFLAG_FDEFAULTCOLLELEM" />
-      <Member MemberType="Field" Name="FUNCFLAG_FDISPLAYBIND" />
-      <Member MemberType="Field" Name="FUNCFLAG_FHIDDEN" />
-      <Member MemberType="Field" Name="FUNCFLAG_FIMMEDIATEBIND" />
-      <Member MemberType="Field" Name="FUNCFLAG_FNONBROWSABLE" />
-      <Member MemberType="Field" Name="FUNCFLAG_FREPLACEABLE" />
-      <Member MemberType="Field" Name="FUNCFLAG_FREQUESTEDIT" />
-      <Member MemberType="Field" Name="FUNCFLAG_FRESTRICTED" />
-      <Member MemberType="Field" Name="FUNCFLAG_FSOURCE" />
-      <Member MemberType="Field" Name="FUNCFLAG_FUIDEFAULT" />
-      <Member MemberType="Field" Name="FUNCFLAG_FUSESGETLASTERROR" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.FUNCKIND">
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="FUNC_DISPATCH" />
-      <Member MemberType="Field" Name="FUNC_NONVIRTUAL" />
-      <Member MemberType="Field" Name="FUNC_PUREVIRTUAL" />
-      <Member MemberType="Field" Name="FUNC_STATIC" />
-      <Member MemberType="Field" Name="FUNC_VIRTUAL" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.IBindCtx">
-      <Member Name="EnumObjectParam(System.Runtime.InteropServices.ComTypes.IEnumString@)" />
-      <Member Name="GetBindOptions(System.Runtime.InteropServices.ComTypes.BIND_OPTS@)" />
-      <Member Name="GetObjectParam(System.String,System.Object@)" />
-      <Member Name="GetRunningObjectTable(System.Runtime.InteropServices.ComTypes.IRunningObjectTable@)" />
-      <Member Name="RegisterObjectBound(System.Object)" />
-      <Member Name="RegisterObjectParam(System.String,System.Object)" />
-      <Member Name="ReleaseBoundObjects" />
-      <Member Name="RevokeObjectBound(System.Object)" />
-      <Member Name="RevokeObjectParam(System.String)" />
-      <Member Name="SetBindOptions(System.Runtime.InteropServices.ComTypes.BIND_OPTS@)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.IConnectionPoint">
-      <Member Name="Advise(System.Object,System.Int32@)" />
-      <Member Name="EnumConnections(System.Runtime.InteropServices.ComTypes.IEnumConnections@)" />
-      <Member Name="GetConnectionInterface(System.Guid@)" />
-      <Member Name="GetConnectionPointContainer(System.Runtime.InteropServices.ComTypes.IConnectionPointContainer@)" />
-      <Member Name="Unadvise(System.Int32)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.IConnectionPointContainer">
-      <Member Name="EnumConnectionPoints(System.Runtime.InteropServices.ComTypes.IEnumConnectionPoints@)" />
-      <Member Name="FindConnectionPoint(System.Guid@,System.Runtime.InteropServices.ComTypes.IConnectionPoint@)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.IDLDESC">
-      <Member MemberType="Field" Name="dwReserved" />
-      <Member MemberType="Field" Name="wIDLFlags" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.IDLFLAG">
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="IDLFLAG_FIN" />
-      <Member MemberType="Field" Name="IDLFLAG_FLCID" />
-      <Member MemberType="Field" Name="IDLFLAG_FOUT" />
-      <Member MemberType="Field" Name="IDLFLAG_FRETVAL" />
-      <Member MemberType="Field" Name="IDLFLAG_NONE" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.IEnumConnectionPoints">
-      <Member Name="Clone(System.Runtime.InteropServices.ComTypes.IEnumConnectionPoints@)" />
-      <Member Name="Next(System.Int32,System.Runtime.InteropServices.ComTypes.IConnectionPoint[],System.IntPtr)" />
-      <Member Name="Reset" />
-      <Member Name="Skip(System.Int32)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.IEnumConnections">
-      <Member Name="Clone(System.Runtime.InteropServices.ComTypes.IEnumConnections@)" />
-      <Member Name="Next(System.Int32,System.Runtime.InteropServices.ComTypes.CONNECTDATA[],System.IntPtr)" />
-      <Member Name="Reset" />
-      <Member Name="Skip(System.Int32)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.IEnumMoniker">
-      <Member Name="Clone(System.Runtime.InteropServices.ComTypes.IEnumMoniker@)" />
-      <Member Name="Next(System.Int32,System.Runtime.InteropServices.ComTypes.IMoniker[],System.IntPtr)" />
-      <Member Name="Reset" />
-      <Member Name="Skip(System.Int32)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.IEnumString">
-      <Member Name="Clone(System.Runtime.InteropServices.ComTypes.IEnumString@)" />
-      <Member Name="Next(System.Int32,System.String[],System.IntPtr)" />
-      <Member Name="Reset" />
-      <Member Name="Skip(System.Int32)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.IEnumVARIANT">
-      <Member Name="Clone" />
-      <Member Name="Next(System.Int32,System.Object[],System.IntPtr)" />
-      <Member Name="Reset" />
-      <Member Name="Skip(System.Int32)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.IMoniker">
-      <Member Name="BindToObject(System.Runtime.InteropServices.ComTypes.IBindCtx,System.Runtime.InteropServices.ComTypes.IMoniker,System.Guid@,System.Object@)" />
-      <Member Name="BindToStorage(System.Runtime.InteropServices.ComTypes.IBindCtx,System.Runtime.InteropServices.ComTypes.IMoniker,System.Guid@,System.Object@)" />
-      <Member Name="CommonPrefixWith(System.Runtime.InteropServices.ComTypes.IMoniker,System.Runtime.InteropServices.ComTypes.IMoniker@)" />
-      <Member Name="ComposeWith(System.Runtime.InteropServices.ComTypes.IMoniker,System.Boolean,System.Runtime.InteropServices.ComTypes.IMoniker@)" />
-      <Member Name="Enum(System.Boolean,System.Runtime.InteropServices.ComTypes.IEnumMoniker@)" />
-      <Member Name="GetClassID(System.Guid@)" />
-      <Member Name="GetDisplayName(System.Runtime.InteropServices.ComTypes.IBindCtx,System.Runtime.InteropServices.ComTypes.IMoniker,System.String@)" />
-      <Member Name="GetSizeMax(System.Int64@)" />
-      <Member Name="GetTimeOfLastChange(System.Runtime.InteropServices.ComTypes.IBindCtx,System.Runtime.InteropServices.ComTypes.IMoniker,System.Runtime.InteropServices.ComTypes.FILETIME@)" />
-      <Member Name="Hash(System.Int32@)" />
-      <Member Name="Inverse(System.Runtime.InteropServices.ComTypes.IMoniker@)" />
-      <Member Name="IsDirty" />
-      <Member Name="IsEqual(System.Runtime.InteropServices.ComTypes.IMoniker)" />
-      <Member Name="IsRunning(System.Runtime.InteropServices.ComTypes.IBindCtx,System.Runtime.InteropServices.ComTypes.IMoniker,System.Runtime.InteropServices.ComTypes.IMoniker)" />
-      <Member Name="IsSystemMoniker(System.Int32@)" />
-      <Member Name="Load(System.Runtime.InteropServices.ComTypes.IStream)" />
-      <Member Name="ParseDisplayName(System.Runtime.InteropServices.ComTypes.IBindCtx,System.Runtime.InteropServices.ComTypes.IMoniker,System.String,System.Int32@,System.Runtime.InteropServices.ComTypes.IMoniker@)" />
-      <Member Name="Reduce(System.Runtime.InteropServices.ComTypes.IBindCtx,System.Int32,System.Runtime.InteropServices.ComTypes.IMoniker@,System.Runtime.InteropServices.ComTypes.IMoniker@)" />
-      <Member Name="RelativePathTo(System.Runtime.InteropServices.ComTypes.IMoniker,System.Runtime.InteropServices.ComTypes.IMoniker@)" />
-      <Member Name="Save(System.Runtime.InteropServices.ComTypes.IStream,System.Boolean)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.IMPLTYPEFLAGS">
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="IMPLTYPEFLAG_FDEFAULT" />
-      <Member MemberType="Field" Name="IMPLTYPEFLAG_FDEFAULTVTABLE" />
-      <Member MemberType="Field" Name="IMPLTYPEFLAG_FRESTRICTED" />
-      <Member MemberType="Field" Name="IMPLTYPEFLAG_FSOURCE" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.INVOKEKIND">
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="INVOKE_FUNC" />
-      <Member MemberType="Field" Name="INVOKE_PROPERTYGET" />
-      <Member MemberType="Field" Name="INVOKE_PROPERTYPUT" />
-      <Member MemberType="Field" Name="INVOKE_PROPERTYPUTREF" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.IPersistFile">
-      <Member Name="GetClassID(System.Guid@)" />
-      <Member Name="GetCurFile(System.String@)" />
-      <Member Name="IsDirty" />
-      <Member Name="Load(System.String,System.Int32)" />
-      <Member Name="Save(System.String,System.Boolean)" />
-      <Member Name="SaveCompleted(System.String)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.IRunningObjectTable">
-      <Member Name="EnumRunning(System.Runtime.InteropServices.ComTypes.IEnumMoniker@)" />
-      <Member Name="GetObject(System.Runtime.InteropServices.ComTypes.IMoniker,System.Object@)" />
-      <Member Name="GetTimeOfLastChange(System.Runtime.InteropServices.ComTypes.IMoniker,System.Runtime.InteropServices.ComTypes.FILETIME@)" />
-      <Member Name="IsRunning(System.Runtime.InteropServices.ComTypes.IMoniker)" />
-      <Member Name="NoteChangeTime(System.Int32,System.Runtime.InteropServices.ComTypes.FILETIME@)" />
-      <Member Name="Register(System.Int32,System.Object,System.Runtime.InteropServices.ComTypes.IMoniker)" />
-      <Member Name="Revoke(System.Int32)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.ITypeComp">
-      <Member Name="Bind(System.String,System.Int32,System.Int16,System.Runtime.InteropServices.ComTypes.ITypeInfo@,System.Runtime.InteropServices.ComTypes.DESCKIND@,System.Runtime.InteropServices.ComTypes.BINDPTR@)" />
-      <Member Name="BindType(System.String,System.Int32,System.Runtime.InteropServices.ComTypes.ITypeInfo@,System.Runtime.InteropServices.ComTypes.ITypeComp@)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.ITypeInfo">
-      <Member Name="AddressOfMember(System.Int32,System.Runtime.InteropServices.ComTypes.INVOKEKIND,System.IntPtr@)" />
-      <Member Name="CreateInstance(System.Object,System.Guid@,System.Object@)" />
-      <Member Name="GetContainingTypeLib(System.Runtime.InteropServices.ComTypes.ITypeLib@,System.Int32@)" />
-      <Member Name="GetDllEntry(System.Int32,System.Runtime.InteropServices.ComTypes.INVOKEKIND,System.IntPtr,System.IntPtr,System.IntPtr)" />
-      <Member Name="GetDocumentation(System.Int32,System.String@,System.String@,System.Int32@,System.String@)" />
-      <Member Name="GetFuncDesc(System.Int32,System.IntPtr@)" />
-      <Member Name="GetIDsOfNames(System.String[],System.Int32,System.Int32[])" />
-      <Member Name="GetImplTypeFlags(System.Int32,System.Runtime.InteropServices.ComTypes.IMPLTYPEFLAGS@)" />
-      <Member Name="GetMops(System.Int32,System.String@)" />
-      <Member Name="GetNames(System.Int32,System.String[],System.Int32,System.Int32@)" />
-      <Member Name="GetRefTypeInfo(System.Int32,System.Runtime.InteropServices.ComTypes.ITypeInfo@)" />
-      <Member Name="GetRefTypeOfImplType(System.Int32,System.Int32@)" />
-      <Member Name="GetTypeAttr(System.IntPtr@)" />
-      <Member Name="GetTypeComp(System.Runtime.InteropServices.ComTypes.ITypeComp@)" />
-      <Member Name="GetVarDesc(System.Int32,System.IntPtr@)" />
-      <Member Name="Invoke(System.Object,System.Int32,System.Int16,System.Runtime.InteropServices.ComTypes.DISPPARAMS@,System.IntPtr,System.IntPtr,System.Int32@)" />
-      <Member Name="ReleaseFuncDesc(System.IntPtr)" />
-      <Member Name="ReleaseTypeAttr(System.IntPtr)" />
-      <Member Name="ReleaseVarDesc(System.IntPtr)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.ITypeInfo2">
-      <Member Name="AddressOfMember(System.Int32,System.Runtime.InteropServices.ComTypes.INVOKEKIND,System.IntPtr@)" />
-      <Member Name="CreateInstance(System.Object,System.Guid@,System.Object@)" />
-      <Member Name="GetAllCustData(System.IntPtr)" />
-      <Member Name="GetAllFuncCustData(System.Int32,System.IntPtr)" />
-      <Member Name="GetAllImplTypeCustData(System.Int32,System.IntPtr)" />
-      <Member Name="GetAllParamCustData(System.Int32,System.Int32,System.IntPtr)" />
-      <Member Name="GetAllVarCustData(System.Int32,System.IntPtr)" />
-      <Member Name="GetContainingTypeLib(System.Runtime.InteropServices.ComTypes.ITypeLib@,System.Int32@)" />
-      <Member Name="GetCustData(System.Guid@,System.Object@)" />
-      <Member Name="GetDllEntry(System.Int32,System.Runtime.InteropServices.ComTypes.INVOKEKIND,System.IntPtr,System.IntPtr,System.IntPtr)" />
-      <Member Name="GetDocumentation(System.Int32,System.String@,System.String@,System.Int32@,System.String@)" />
-      <Member Name="GetDocumentation2(System.Int32,System.String@,System.Int32@,System.String@)" />
-      <Member Name="GetFuncCustData(System.Int32,System.Guid@,System.Object@)" />
-      <Member Name="GetFuncDesc(System.Int32,System.IntPtr@)" />
-      <Member Name="GetFuncIndexOfMemId(System.Int32,System.Runtime.InteropServices.ComTypes.INVOKEKIND,System.Int32@)" />
-      <Member Name="GetIDsOfNames(System.String[],System.Int32,System.Int32[])" />
-      <Member Name="GetImplTypeCustData(System.Int32,System.Guid@,System.Object@)" />
-      <Member Name="GetImplTypeFlags(System.Int32,System.Runtime.InteropServices.ComTypes.IMPLTYPEFLAGS@)" />
-      <Member Name="GetMops(System.Int32,System.String@)" />
-      <Member Name="GetNames(System.Int32,System.String[],System.Int32,System.Int32@)" />
-      <Member Name="GetParamCustData(System.Int32,System.Int32,System.Guid@,System.Object@)" />
-      <Member Name="GetRefTypeInfo(System.Int32,System.Runtime.InteropServices.ComTypes.ITypeInfo@)" />
-      <Member Name="GetRefTypeOfImplType(System.Int32,System.Int32@)" />
-      <Member Name="GetTypeAttr(System.IntPtr@)" />
-      <Member Name="GetTypeComp(System.Runtime.InteropServices.ComTypes.ITypeComp@)" />
-      <Member Name="GetTypeFlags(System.Int32@)" />
-      <Member Name="GetTypeKind(System.Runtime.InteropServices.ComTypes.TYPEKIND@)" />
-      <Member Name="GetVarCustData(System.Int32,System.Guid@,System.Object@)" />
-      <Member Name="GetVarDesc(System.Int32,System.IntPtr@)" />
-      <Member Name="GetVarIndexOfMemId(System.Int32,System.Int32@)" />
-      <Member Name="Invoke(System.Object,System.Int32,System.Int16,System.Runtime.InteropServices.ComTypes.DISPPARAMS@,System.IntPtr,System.IntPtr,System.Int32@)" />
-      <Member Name="ReleaseFuncDesc(System.IntPtr)" />
-      <Member Name="ReleaseTypeAttr(System.IntPtr)" />
-      <Member Name="ReleaseVarDesc(System.IntPtr)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.ITypeLib">
-      <Member Name="FindName(System.String,System.Int32,System.Runtime.InteropServices.ComTypes.ITypeInfo[],System.Int32[],System.Int16@)" />
-      <Member Name="GetDocumentation(System.Int32,System.String@,System.String@,System.Int32@,System.String@)" />
-      <Member Name="GetLibAttr(System.IntPtr@)" />
-      <Member Name="GetTypeComp(System.Runtime.InteropServices.ComTypes.ITypeComp@)" />
-      <Member Name="GetTypeInfo(System.Int32,System.Runtime.InteropServices.ComTypes.ITypeInfo@)" />
-      <Member Name="GetTypeInfoCount" />
-      <Member Name="GetTypeInfoOfGuid(System.Guid@,System.Runtime.InteropServices.ComTypes.ITypeInfo@)" />
-      <Member Name="GetTypeInfoType(System.Int32,System.Runtime.InteropServices.ComTypes.TYPEKIND@)" />
-      <Member Name="IsName(System.String,System.Int32)" />
-      <Member Name="ReleaseTLibAttr(System.IntPtr)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.ITypeLib2">
-      <Member Name="FindName(System.String,System.Int32,System.Runtime.InteropServices.ComTypes.ITypeInfo[],System.Int32[],System.Int16@)" />
-      <Member Name="GetAllCustData(System.IntPtr)" />
-      <Member Name="GetCustData(System.Guid@,System.Object@)" />
-      <Member Name="GetDocumentation(System.Int32,System.String@,System.String@,System.Int32@,System.String@)" />
-      <Member Name="GetDocumentation2(System.Int32,System.String@,System.Int32@,System.String@)" />
-      <Member Name="GetLibAttr(System.IntPtr@)" />
-      <Member Name="GetLibStatistics(System.IntPtr,System.Int32@)" />
-      <Member Name="GetTypeComp(System.Runtime.InteropServices.ComTypes.ITypeComp@)" />
-      <Member Name="GetTypeInfo(System.Int32,System.Runtime.InteropServices.ComTypes.ITypeInfo@)" />
-      <Member Name="GetTypeInfoCount" />
-      <Member Name="GetTypeInfoOfGuid(System.Guid@,System.Runtime.InteropServices.ComTypes.ITypeInfo@)" />
-      <Member Name="GetTypeInfoType(System.Int32,System.Runtime.InteropServices.ComTypes.TYPEKIND@)" />
-      <Member Name="IsName(System.String,System.Int32)" />
-      <Member Name="ReleaseTLibAttr(System.IntPtr)" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.LIBFLAGS">
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="LIBFLAG_FCONTROL" />
-      <Member MemberType="Field" Name="LIBFLAG_FHASDISKIMAGE" />
-      <Member MemberType="Field" Name="LIBFLAG_FHIDDEN" />
-      <Member MemberType="Field" Name="LIBFLAG_FRESTRICTED" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.PARAMDESC">
-      <Member MemberType="Field" Name="lpVarValue" />
-      <Member MemberType="Field" Name="wParamFlags" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.PARAMFLAG">
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="PARAMFLAG_FHASCUSTDATA" />
-      <Member MemberType="Field" Name="PARAMFLAG_FHASDEFAULT" />
-      <Member MemberType="Field" Name="PARAMFLAG_FIN" />
-      <Member MemberType="Field" Name="PARAMFLAG_FLCID" />
-      <Member MemberType="Field" Name="PARAMFLAG_FOPT" />
-      <Member MemberType="Field" Name="PARAMFLAG_FOUT" />
-      <Member MemberType="Field" Name="PARAMFLAG_FRETVAL" />
-      <Member MemberType="Field" Name="PARAMFLAG_NONE" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.SYSKIND">
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="SYS_MAC" />
-      <Member MemberType="Field" Name="SYS_WIN16" />
-      <Member MemberType="Field" Name="SYS_WIN32" />
-      <Member MemberType="Field" Name="SYS_WIN64" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.TYPEATTR">
-      <Member MemberType="Field" Name="guid" />
-      <Member MemberType="Field" Name="cbAlignment" />
-      <Member MemberType="Field" Name="cbSizeVft" />
-      <Member MemberType="Field" Name="cFuncs" />
-      <Member MemberType="Field" Name="cImplTypes" />
-      <Member MemberType="Field" Name="cVars" />
-      <Member MemberType="Field" Name="wMajorVerNum" />
-      <Member MemberType="Field" Name="wMinorVerNum" />
-      <Member MemberType="Field" Name="cbSizeInstance" />
-      <Member MemberType="Field" Name="dwReserved" />
-      <Member MemberType="Field" Name="lcid" />
-      <Member MemberType="Field" Name="MEMBER_ID_NIL" />
-      <Member MemberType="Field" Name="memidConstructor" />
-      <Member MemberType="Field" Name="memidDestructor" />
-      <Member MemberType="Field" Name="lpstrSchema" />
-      <Member MemberType="Field" Name="idldescType" />
-      <Member MemberType="Field" Name="tdescAlias" />
-      <Member MemberType="Field" Name="wTypeFlags" />
-      <Member MemberType="Field" Name="typekind" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.TYPEDESC">
-      <Member MemberType="Field" Name="vt" />
-      <Member MemberType="Field" Name="lpValue" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.TYPEFLAGS">
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="TYPEFLAG_FAGGREGATABLE" />
-      <Member MemberType="Field" Name="TYPEFLAG_FAPPOBJECT" />
-      <Member MemberType="Field" Name="TYPEFLAG_FCANCREATE" />
-      <Member MemberType="Field" Name="TYPEFLAG_FCONTROL" />
-      <Member MemberType="Field" Name="TYPEFLAG_FDISPATCHABLE" />
-      <Member MemberType="Field" Name="TYPEFLAG_FDUAL" />
-      <Member MemberType="Field" Name="TYPEFLAG_FHIDDEN" />
-      <Member MemberType="Field" Name="TYPEFLAG_FLICENSED" />
-      <Member MemberType="Field" Name="TYPEFLAG_FNONEXTENSIBLE" />
-      <Member MemberType="Field" Name="TYPEFLAG_FOLEAUTOMATION" />
-      <Member MemberType="Field" Name="TYPEFLAG_FPREDECLID" />
-      <Member MemberType="Field" Name="TYPEFLAG_FPROXY" />
-      <Member MemberType="Field" Name="TYPEFLAG_FREPLACEABLE" />
-      <Member MemberType="Field" Name="TYPEFLAG_FRESTRICTED" />
-      <Member MemberType="Field" Name="TYPEFLAG_FREVERSEBIND" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.TYPEKIND">
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="TKIND_ALIAS" />
-      <Member MemberType="Field" Name="TKIND_COCLASS" />
-      <Member MemberType="Field" Name="TKIND_DISPATCH" />
-      <Member MemberType="Field" Name="TKIND_ENUM" />
-      <Member MemberType="Field" Name="TKIND_INTERFACE" />
-      <Member MemberType="Field" Name="TKIND_MAX" />
-      <Member MemberType="Field" Name="TKIND_MODULE" />
-      <Member MemberType="Field" Name="TKIND_RECORD" />
-      <Member MemberType="Field" Name="TKIND_UNION" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.TYPELIBATTR">
-      <Member MemberType="Field" Name="guid" />
-      <Member MemberType="Field" Name="wMajorVerNum" />
-      <Member MemberType="Field" Name="wMinorVerNum" />
-      <Member MemberType="Field" Name="lcid" />
-      <Member MemberType="Field" Name="wLibFlags" />
-      <Member MemberType="Field" Name="syskind" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.VARDESC">
-      <Member MemberType="Field" Name="desc" />
-      <Member MemberType="Field" Name="wVarFlags" />
-      <Member MemberType="Field" Name="memid" />
-      <Member MemberType="Field" Name="elemdescVar" />
-      <Member MemberType="Field" Name="varkind" />
-      <Member MemberType="Field" Name="lpstrSchema" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.VARDESC+DESCUNION">
-      <Member MemberType="Field" Name="oInst" />
-      <Member MemberType="Field" Name="lpvarValue" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.VARFLAGS">
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="VARFLAG_FBINDABLE" />
-      <Member MemberType="Field" Name="VARFLAG_FDEFAULTBIND" />
-      <Member MemberType="Field" Name="VARFLAG_FDEFAULTCOLLELEM" />
-      <Member MemberType="Field" Name="VARFLAG_FDISPLAYBIND" />
-      <Member MemberType="Field" Name="VARFLAG_FHIDDEN" />
-      <Member MemberType="Field" Name="VARFLAG_FIMMEDIATEBIND" />
-      <Member MemberType="Field" Name="VARFLAG_FNONBROWSABLE" />
-      <Member MemberType="Field" Name="VARFLAG_FREADONLY" />
-      <Member MemberType="Field" Name="VARFLAG_FREPLACEABLE" />
-      <Member MemberType="Field" Name="VARFLAG_FREQUESTEDIT" />
-      <Member MemberType="Field" Name="VARFLAG_FRESTRICTED" />
-      <Member MemberType="Field" Name="VARFLAG_FSOURCE" />
-      <Member MemberType="Field" Name="VARFLAG_FUIDEFAULT" />
-    </Type>
-    <Type Name="System.Runtime.InteropServices.ComTypes.VARKIND">
-      <Member MemberType="Field" Name="value__" />
-      <Member MemberType="Field" Name="VAR_CONST" />
-      <Member MemberType="Field" Name="VAR_DISPATCH" />
-      <Member MemberType="Field" Name="VAR_PERINSTANCE" />
-      <Member MemberType="Field" Name="VAR_STATIC" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.StubHelpers">
-      <Member Name="ClearLastError" />
-      <Member Name="SetLastError" />
-      <Member Name="IsQCall(System.IntPtr)" />
-      <Member Name="InitDeclaringType(System.IntPtr)" />
-      <Member Name="GetNDirectTarget(System.IntPtr)" />
-      <Member Name="GetDelegateTarget(System.Delegate,System.IntPtr@)" />
-      <Member Name="ThrowInteropParamException(System.Int32,System.Int32)" />
-      <Member Name="AddToCleanupList(System.StubHelpers.CleanupWorkList@,System.Runtime.InteropServices.SafeHandle)" />
-      <Member Name="DestroyCleanupList(System.StubHelpers.CleanupWorkList@)" />
-      <Member Name="GetHRExceptionObject(System.Int32)" />
-      <Member Name="CreateCustomMarshalerHelper(System.IntPtr,System.Int32,System.IntPtr)" />
-      <Member Name="CheckStringLength(System.Int32)" />
-      <Member Name="DecimalCanonicalizeInternal(System.Decimal@)" />
-      <Member Name="FmtClassUpdateNativeInternal(System.Object,System.Byte*,System.StubHelpers.CleanupWorkList@)" />
-      <Member Name="FmtClassUpdateCLRInternal(System.Object,System.Byte*)" />
-      <Member Name="LayoutDestroyNativeInternal(System.Byte*,System.IntPtr)" />
-      <Member Name="AllocateInternal(System.IntPtr)" />
-      <Member Name="strlen(System.SByte*)" />
-      <Member Name="MarshalToManagedVaListInternal(System.IntPtr,System.IntPtr)" />
-      <Member Name="MarshalToUnmanagedVaListInternal(System.IntPtr,System.UInt32,System.IntPtr)" />
-      <Member Name="CalcVaListSize(System.IntPtr)" />
-      <Member Name="ProfilerBeginTransitionCallback(System.IntPtr,System.IntPtr,System.Object)" /> <!-- EE -->
-      <Member Name="ProfilerEndTransitionCallback(System.IntPtr,System.IntPtr)" /> <!-- EE -->
-      <Member Name="SafeHandleAddRef(System.Runtime.InteropServices.SafeHandle,System.Boolean@)" />
-      <Member Name="SafeHandleRelease(System.Runtime.InteropServices.SafeHandle)" />
-      <Member Name="ValidateObject(System.Object,System.IntPtr,System.Object)" />
-      <Member Name="ValidateByref(System.IntPtr,System.IntPtr,System.Object)" />
-      <Member Name="LogPinnedArgument(System.IntPtr,System.IntPtr)" />
-      <Member Name="GetStubContext" />
-      <Member Name="GetStubContextAddr" Architecture="amd64" />
-      <Member Name="GetStubContextAddr" Architecture="arm64" />
-      <Member Name="ArrayTypeCheck(System.Object,System.Object[])" Condition="FEATURE_ARRAYSTUB_AS_IL" />
-      <Member Name="MulticastDebuggerTraceHelper(System.Object,System.Int32)" Condition="FEATURE_STUBS_AS_IL" />
-      <Member Name="GetCOMHRExceptionObject(System.Int32,System.IntPtr,System.Object)" Condition="FEATURE_COMINTEROP" />
-      <Member Name="GetCOMHRExceptionObject_WinRT(System.Int32,System.IntPtr,System.Object)" Condition="FEATURE_COMINTEROP" />
-      <Member Name="GetCOMIPFromRCW(System.Object,System.IntPtr,System.IntPtr@,System.Boolean@)" Condition="FEATURE_COMINTEROP" />
-      <Member Name="GetCOMIPFromRCW_WinRT(System.Object,System.IntPtr,System.IntPtr@)" Condition="FEATURE_COMINTEROP" />
-      <Member Name="GetCOMIPFromRCW_WinRTSharedGeneric(System.Object,System.IntPtr,System.IntPtr@)" Condition="FEATURE_COMINTEROP" />
-      <Member Name="GetCOMIPFromRCW_WinRTDelegate(System.Object,System.IntPtr,System.IntPtr@)" Condition="FEATURE_COMINTEROP" />
-      <Member Name="ShouldCallWinRTInterface(System.Object,System.IntPtr)" Condition="FEATURE_COMINTEROP" />
-      <Member Name="StubRegisterRCW(System.Object)" Condition="FEATURE_COMINTEROP" />
-      <Member Name="StubUnregisterRCW(System.Object)" Condition="FEATURE_COMINTEROP" />
-      <Member Name="GetDelegateInvokeMethod(System.Delegate)" Condition="FEATURE_COMINTEROP" />
-      <Member Name="GetWinRTFactoryObject(System.IntPtr)" Condition="FEATURE_COMINTEROP" />
-      <Member Name="GetWinRTFactoryReturnValue(System.Object,System.IntPtr)" Condition="FEATURE_COMINTEROP" />
-      <Member Name="GetOuterInspectable(System.Object,System.IntPtr)" Condition="FEATURE_COMINTEROP" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.AnsiCharMarshaler">
-      <Member Name="ConvertToNative(System.Char,System.Boolean,System.Boolean)" />
-      <Member Name="ConvertToManaged(System.Byte)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.AnsiBSTRMarshaler" Condition="FEATURE_COMINTEROP">
-      <Member Name="ConvertToNative(System.Int32,System.String)" />
-      <Member Name="ConvertToManaged(System.IntPtr)" />
-      <Member Name="ClearNative(System.IntPtr)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.BSTRMarshaler" Condition="FEATURE_COMINTEROP">
-      <Member Name="ConvertToNative(System.String,System.IntPtr)" />
-      <Member Name="ConvertToManaged(System.IntPtr)" />
-      <Member Name="ClearNative(System.IntPtr)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.CSTRMarshaler">
-      <Member Name="ConvertToNative(System.Int32,System.String,System.IntPtr)" />
-      <Member Name="ConvertToManaged(System.IntPtr)" />
-      <Member Name="ClearNative(System.IntPtr)" />
-    </Type>
-     <Type Status="ImplRoot" Name="System.StubHelpers.UTF8Marshaler">
-      <Member Name="ConvertToNative(System.Int32,System.String,System.IntPtr)" />
-      <Member Name="ConvertToManaged(System.IntPtr)" />
-      <Member Name="ClearNative(System.IntPtr)" />
-    </Type>
-      <Type Status="ImplRoot" Name="System.StubHelpers.UTF8BufferMarshaler">
-      <Member Name="ConvertToNative(System.Text.StringBuilder,System.IntPtr,System.Int32)" />
-      <Member Name="ConvertToManaged(System.Text.StringBuilder,System.IntPtr)" />
-    </Type>
-    <Type Status="ApiFxInternal" Name="System.StubHelpers.EventArgsMarshaler" Condition="FEATURE_COMINTEROP">
-      <Member Name="CreateNativeNCCEventArgsInstance(System.Int32,System.Object,System.Object,System.Int32,System.Int32)"/>
-      <Member Name="CreateNativePCEventArgsInstance(System.String)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.HResultExceptionMarshaler" Condition="FEATURE_COMINTEROP">
-      <Member Name="ConvertToNative(System.Exception)" />
-      <Member Name="ConvertToManaged(System.Int32)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.KeyValuePairMarshaler" Condition="FEATURE_COMINTEROP">
-      <Member Name="ConvertToNative&lt;K,V&gt;(System.Collections.Generic.KeyValuePair&lt;K,V&gt;@)" />
-      <Member Name="ConvertToManaged&lt;K,V&gt;(System.IntPtr)" />
-      <Member Name="ConvertToManagedBox&lt;K,V&gt;(System.IntPtr)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.MngdSafeArrayMarshaler" Condition="FEATURE_COMINTEROP">
-      <Member Name="CreateMarshaler(System.IntPtr,System.IntPtr,System.Int32,System.Int32)" />
-      <Member Name="ConvertSpaceToNative(System.IntPtr,System.Object@,System.IntPtr)" />
-      <Member Name="ConvertContentsToNative(System.IntPtr,System.Object@,System.IntPtr,System.Object)" />
-      <Member Name="ConvertSpaceToManaged(System.IntPtr,System.Object@,System.IntPtr)" />
-      <Member Name="ConvertContentsToManaged(System.IntPtr,System.Object@,System.IntPtr)" />
-      <Member Name="ClearNative(System.IntPtr,System.Object@,System.IntPtr)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.MngdHiddenLengthArrayMarshaler" Condition="FEATURE_COMINTEROP">
-      <Member Name="CreateMarshaler(System.IntPtr,System.IntPtr,System.IntPtr,System.UInt16)" />
-      <Member Name="ConvertSpaceToManaged(System.IntPtr,System.Object@,System.IntPtr,System.Int32)" />
-      <Member Name="ConvertContentsToManaged(System.IntPtr,System.Object@,System.IntPtr)" />
-      <Member Name="ConvertSpaceToNative(System.IntPtr,System.Object@,System.IntPtr)" />
-      <Member Name="ConvertContentsToNative(System.IntPtr,System.Object@,System.IntPtr)" />
-      <Member Name="ClearNativeContents(System.IntPtr,System.IntPtr,System.Int32)" />
-      <Member Name="ClearNativeContents_Type(System.IntPtr,System.Int32)" />
-      <Member Name="ConvertContentsToManaged_DateTime(System.DateTimeOffset[]@,System.IntPtr)" />
-      <Member Name="ConvertContentsToManaged_Type(System.Type[]@,System.IntPtr)" />
-      <Member Name="ConvertContentsToManaged_Exception(System.Exception[]@,System.IntPtr)" />
-      <Member Name="ConvertContentsToManaged_Nullable&lt;T&gt;(System.Nullable&lt;T&gt;[]@,System.IntPtr)" />
-      <Member Name="ConvertContentsToManaged_KeyValuePair&lt;K,V&gt;(System.Collections.Generic.KeyValuePair&lt;K,V&gt;[]@,System.IntPtr)" />
-      <Member Name="ConvertContentsToNative_DateTime(System.DateTimeOffset[]@,System.IntPtr)" />
-      <Member Name="ConvertContentsToNative_Type(System.Type[]@,System.IntPtr)" />
-      <Member Name="ConvertContentsToNative_Exception(System.Exception[]@,System.IntPtr)" />
-      <Member Name="ConvertContentsToNative_Nullable&lt;T&gt;(System.Nullable&lt;T&gt;[]@,System.IntPtr)" />
-      <Member Name="ConvertContentsToNative_KeyValuePair&lt;K,V&gt;(System.Collections.Generic.KeyValuePair&lt;K,V&gt;[]@,System.IntPtr)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.NullableMarshaler" Condition="FEATURE_COMINTEROP">
-      <Member Name="ConvertToNative&lt;T&gt;(System.Nullable&lt;T&gt;@)" />
-      <Member Name="ConvertToManaged&lt;T&gt;(System.IntPtr)" />
-      <Member Name="ConvertToManagedRetVoid&lt;T&gt;(System.IntPtr,System.Nullable&lt;T&gt;@)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.WSTRBufferMarshaler">
-      <Member Name="ConvertToNative(System.String)" />
-      <Member Name="ConvertToManaged(System.IntPtr)" />
-      <Member Name="ClearNative(System.IntPtr)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.ValueClassMarshaler">
-      <Member Name="ConvertToNative(System.IntPtr,System.IntPtr,System.IntPtr,System.StubHelpers.CleanupWorkList@)" />
-      <Member Name="ConvertToManaged(System.IntPtr,System.IntPtr,System.IntPtr)" />
-      <Member Name="ClearNative(System.IntPtr,System.IntPtr)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.DateMarshaler">
-      <Member Name="ConvertToNative(System.DateTime)" />
-      <Member Name="ConvertToManaged(System.Double)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.DateTimeOffsetMarshaler" Condition="FEATURE_COMINTEROP">
-      <Member Name="ConvertToNative(System.DateTimeOffset@,System.StubHelpers.DateTimeNative@)"/>
-      <Member Name="ConvertToManaged(System.DateTimeOffset@,System.StubHelpers.DateTimeNative@)"/>
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.HStringMarshaler" Condition="FEATURE_COMINTEROP">
-      <Member Name="ConvertToNative(System.String)"/>
-      <Member Name="ConvertToNativeReference(System.String,System.Runtime.InteropServices.WindowsRuntime.HSTRING_HEADER*)"/>
-      <Member Name="ConvertToManaged(System.IntPtr)"/>
-      <Member Name="ClearNative(System.IntPtr)"/>
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.ObjectMarshaler" Condition="FEATURE_COMINTEROP">
-      <Member Name="ConvertToNative(System.Object,System.IntPtr)"/>
-      <Member Name="ConvertToManaged(System.IntPtr)"/>
-      <Member Name="ClearNative(System.IntPtr)"/>
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.InterfaceMarshaler" Condition="FEATURE_COMINTEROP">
-      <Member Name="ConvertToNative(System.Object,System.IntPtr,System.IntPtr,System.Int32)"/>
-      <Member Name="ConvertToManaged(System.IntPtr,System.IntPtr,System.IntPtr,System.Int32)"/>
-      <Member Name="ClearNative(System.IntPtr)"/>
-      <Member Name="ConvertToManagedWithoutUnboxing(System.IntPtr)"/>
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.UriMarshaler" Condition="FEATURE_COMINTEROP">
-      <Member Name="GetRawUriFromNative(System.IntPtr)"/>
-      <Member Name="CreateNativeUriInstance(System.String)"/>
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.VBByValStrMarshaler">
-      <Member Name="ConvertToNative(System.String,System.Boolean,System.Boolean,System.Int32@)" />
-      <Member Name="ConvertToManaged(System.IntPtr,System.Int32)" />
-      <Member Name="ClearNative(System.IntPtr)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.MngdNativeArrayMarshaler">
-      <Member Name="CreateMarshaler(System.IntPtr,System.IntPtr,System.Int32)" />
-      <Member Name="ConvertSpaceToNative(System.IntPtr,System.Object@,System.IntPtr)" />
-      <Member Name="ConvertContentsToNative(System.IntPtr,System.Object@,System.IntPtr)" />
-      <Member Name="ConvertSpaceToManaged(System.IntPtr,System.Object@,System.IntPtr,System.Int32)" />
-      <Member Name="ConvertContentsToManaged(System.IntPtr,System.Object@,System.IntPtr)" />
-      <Member Name="ClearNative(System.IntPtr,System.IntPtr,System.Int32)" />
-      <Member Name="ClearNativeContents(System.IntPtr,System.IntPtr,System.Int32)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.MngdRefCustomMarshaler">
-      <Member Name="CreateMarshaler(System.IntPtr,System.IntPtr)" />
-      <Member Name="ConvertContentsToNative(System.IntPtr,System.Object@,System.IntPtr)" />
-      <Member Name="ConvertContentsToManaged(System.IntPtr,System.Object@,System.IntPtr)" />
-      <Member Name="ClearNative(System.IntPtr,System.Object@,System.IntPtr)" />
-      <Member Name="ClearManaged(System.IntPtr,System.Object@,System.IntPtr)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.AsAnyMarshaler">
-       <Member Name="#ctor(System.IntPtr)" />
-       <Member Name="ConvertToNative(System.Object,System.Int32)" />
-       <Member Name="ConvertToManaged(System.Object,System.IntPtr)" />
-       <Member Name="ClearNative(System.IntPtr)" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.NativeVariant" />
-    <Type Status="ImplRoot" Name="Microsoft.Win32.Win32Native+OSVERSIONINFOEX">
-      <Member MemberType="Field" Name="OSVersionInfoSize" />
-      <Member MemberType="Field" Name="MajorVersion" />
-      <Member MemberType="Field" Name="MinorVersion" />
-      <Member MemberType="Field" Name="BuildNumber" />
-      <Member MemberType="Field" Name="PlatformId" />
-      <Member MemberType="Field" Name="CSDVersion" />
-      <Member MemberType="Field" Name="ServicePackMajor" />
-      <Member MemberType="Field" Name="ServicePackMinor" />
-      <Member MemberType="Field" Name="SuiteMask" />
-      <Member MemberType="Field" Name="ProductType" />
-      <Member MemberType="Field" Name="Reserved" />
-      <Member Name="#ctor" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.StubHelpers.TypeNameNative" Condition="FEATURE_COMINTEROP">
-      <Member MemberType="Field" Name="typeName" />
-      <Member MemberType="Field" Name="typeKind" />
-    </Type>
-    <Type Status="ImplRoot" Name="Microsoft.Win32.Win32Native+WIN32_FIND_DATA">
-      <Member MemberType="Field" Name="cFileName" />
-      <Member MemberType="Field" Name="dwFileAttributes" />
-      <Member MemberType="Field" Name="dwReserved0" />
-      <Member MemberType="Field" Name="dwReserved1" />
-      <Member MemberType="Field" Name="ftCreationTime_dwHighDateTime" />
-      <Member MemberType="Field" Name="ftCreationTime_dwLowDateTime" />
-      <Member MemberType="Field" Name="ftLastAccessTime_dwHighDateTime" />
-      <Member MemberType="Field" Name="ftLastAccessTime_dwLowDateTime" />
-      <Member MemberType="Field" Name="ftLastWriteTime_dwHighDateTime" />
-      <Member MemberType="Field" Name="ftLastWriteTime_dwLowDateTime" />
-      <Member MemberType="Field" Name="nFileSizeHigh" />
-      <Member MemberType="Field" Name="nFileSizeLow" />
-      <Member MemberType="Field" Name="cAlternateFileName" />
-      <Member Name="#ctor" />
-    </Type>
-    <!-- PFX Types -->
-    <!-- System.Threading.Tasks namespace -->
-    <Type Name="System.Threading.Tasks.TaskScheduler">
-      <Member Name="#ctor" />
-      <Member Name="TryExecuteTaskInline(System.Threading.Tasks.Task,System.Boolean)" />
-      <Member Name="TryExecuteTask(System.Threading.Tasks.Task)" />
-      <Member Name="get_MaximumConcurrencyLevel" />
-      <Member Name="get_Default" />
-      <Member Name="get_Current" />
-      <Member Name="get_Id" />
-      <Member Name="QueueTask(System.Threading.Tasks.Task)" />
-      <Member Name="TryDequeue(System.Threading.Tasks.Task)" />
-      <Member Name="GetScheduledTasks" />
-      <Member Name="FromCurrentSynchronizationContext" />
-      <Member Status="ImplRoot" Name="GetTaskSchedulersForDebugger" />
-      <Member Status="ImplRoot" Name="GetScheduledTasksForDebugger" />
-      <Member MemberType="Event" Name="UnobservedTaskException" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Threading.Tasks.TaskScheduler+SystemThreadingTasks_TaskSchedulerDebugView">
-      <Member Status="ImplRoot" Name="#ctor(System.Threading.Tasks.TaskScheduler)" />
-      <Member Status="ImplRoot" Name="get_ScheduledTasks" />
-      <Member Status="ImplRoot" Name="get_Id" />
-    </Type>
-    <Type Name="System.Threading.Tasks.TaskSchedulerException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Exception)" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Threading.Tasks.Task">
-      <Member Name="#ctor(System.Action)" />
-      <Member Name="#ctor(System.Action,System.Threading.CancellationToken)" />
-      <Member Name="#ctor(System.Action&lt;System.Object&gt;,System.Object)" />
-      <Member Name="#ctor(System.Action,System.Threading.Tasks.TaskCreationOptions)" />
-      <Member Name="#ctor(System.Action&lt;System.Object&gt;,System.Object,System.Threading.CancellationToken)" />
-      <Member Name="#ctor(System.Action,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions)" />
-      <Member Name="#ctor(System.Action&lt;System.Object&gt;,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
-      <Member Name="#ctor(System.Action&lt;System.Object&gt;,System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions)" />
-      <Member Name="ContinueWith(System.Action&lt;System.Threading.Tasks.Task&gt;)" />
-      <Member Name="ContinueWith(System.Action&lt;System.Threading.Tasks.Task&gt;,System.Threading.CancellationToken)" />
-      <Member Name="ContinueWith(System.Action&lt;System.Threading.Tasks.Task&gt;,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="ContinueWith(System.Action&lt;System.Threading.Tasks.Task&gt;,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWith(System.Action&lt;System.Threading.Tasks.Task&gt;,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWith(System.Action&lt;System.Threading.Tasks.Task,System.Object&gt;,System.Object)" />
-      <Member Name="ContinueWith(System.Action&lt;System.Threading.Tasks.Task,System.Object&gt;,System.Object,System.Threading.CancellationToken)" />
-      <Member Name="ContinueWith(System.Action&lt;System.Threading.Tasks.Task,System.Object&gt;,System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="ContinueWith(System.Action&lt;System.Threading.Tasks.Task,System.Object&gt;,System.Object,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWith(System.Action&lt;System.Threading.Tasks.Task,System.Object&gt;,System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWith&lt;TResult&gt;(System.Func&lt;System.Threading.Tasks.Task,TResult&gt;)" />
-      <Member Name="ContinueWith&lt;TResult&gt;(System.Func&lt;System.Threading.Tasks.Task,TResult&gt;,System.Threading.CancellationToken)" />
-      <Member Name="ContinueWith&lt;TResult&gt;(System.Func&lt;System.Threading.Tasks.Task,TResult&gt;,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="ContinueWith&lt;TResult&gt;(System.Func&lt;System.Threading.Tasks.Task,TResult&gt;,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWith&lt;TResult&gt;(System.Func&lt;System.Threading.Tasks.Task,TResult&gt;,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWith&lt;TResult&gt;(System.Func&lt;System.Threading.Tasks.Task,System.Object,TResult&gt;,System.Object)" />
-      <Member Name="ContinueWith&lt;TResult&gt;(System.Func&lt;System.Threading.Tasks.Task,System.Object,TResult&gt;,System.Object,System.Threading.CancellationToken)" />
-      <Member Name="ContinueWith&lt;TResult&gt;(System.Func&lt;System.Threading.Tasks.Task,System.Object,TResult&gt;,System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="ContinueWith&lt;TResult&gt;(System.Func&lt;System.Threading.Tasks.Task,System.Object,TResult&gt;,System.Object,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWith&lt;TResult&gt;(System.Func&lt;System.Threading.Tasks.Task,System.Object,TResult&gt;,System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="FromResult&lt;TResult&gt;(TResult)" />
-      <Member Name="FromException(System.Exception)" />
-      <Member Name="FromException&lt;TResult&gt;(System.Exception)" />
-      <Member Name="FromCanceled(System.Threading.CancellationToken)" />
-      <Member Name="FromCanceled&lt;TResult&gt;(System.Threading.CancellationToken)" />
-      <Member Status="ApiFxInternal" Name="FromCancellation(System.Threading.CancellationToken)" />
-      <Member Status="ApiFxInternal" Name="FromCancellation&lt;TResult&gt;(System.Threading.CancellationToken)" />
-      <Member Name="Run(System.Action)" />
-      <Member Name="Run(System.Action,System.Threading.CancellationToken)" />
-      <Member Name="Run&lt;TResult&gt;(System.Func&lt;TResult&gt;)" />
-      <Member Name="Run&lt;TResult&gt;(System.Func&lt;TResult&gt;,System.Threading.CancellationToken)" />
-      <Member Name="Run(System.Func&lt;System.Threading.Tasks.Task&gt;)" />
-      <Member Name="Run(System.Func&lt;System.Threading.Tasks.Task&gt;,System.Threading.CancellationToken)" />
-      <Member Name="Run&lt;TResult&gt;(System.Func&lt;System.Threading.Tasks.Task&lt;TResult&gt;&gt;)" />
-      <Member Name="Run&lt;TResult&gt;(System.Func&lt;System.Threading.Tasks.Task&lt;TResult&gt;&gt;,System.Threading.CancellationToken)" />
-      <Member Name="Delay(System.TimeSpan)" />
-      <Member Name="Delay(System.TimeSpan,System.Threading.CancellationToken)" />
-      <Member Name="Delay(System.Int32)" />
-      <Member Name="Delay(System.Int32,System.Threading.CancellationToken)" />
-      <Member Name="WhenAll(System.Collections.Generic.IEnumerable&lt;System.Threading.Tasks.Task&gt;)" />
-      <Member Name="WhenAll(System.Threading.Tasks.Task[])" />
-      <Member Name="WhenAll&lt;TResult&gt;(System.Collections.Generic.IEnumerable&lt;System.Threading.Tasks.Task&lt;TResult&gt;&gt;)" />
-      <Member Name="WhenAll&lt;TResult&gt;(System.Threading.Tasks.Task&lt;TResult&gt;[])" />
-      <Member Name="WhenAny(System.Collections.Generic.IEnumerable&lt;System.Threading.Tasks.Task&gt;)" />
-      <Member Name="WhenAny(System.Threading.Tasks.Task[])" />
-      <Member Name="WhenAny&lt;TResult&gt;(System.Collections.Generic.IEnumerable&lt;System.Threading.Tasks.Task&lt;TResult&gt;&gt;)" />
-      <Member Name="WhenAny&lt;TResult&gt;(System.Threading.Tasks.Task&lt;TResult&gt;[])" />
-      <Member Name="Dispose" />
-      <Member Name="Dispose(System.Boolean)" />
-      <Member Name="RunSynchronously" />
-      <Member Name="RunSynchronously(System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="Start" />
-      <Member Name="Start(System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="Wait" />
-      <Member Name="Wait(System.Int32)" />
-      <Member Name="Wait(System.Threading.CancellationToken)" />
-      <Member Name="Wait(System.TimeSpan)" />
-      <Member Name="Wait(System.Int32,System.Threading.CancellationToken)" />
-      <Member Name="WaitAll(System.Threading.Tasks.Task[])" />
-      <Member Name="WaitAll(System.Threading.Tasks.Task[],System.Int32)" />
-      <Member Name="WaitAll(System.Threading.Tasks.Task[],System.Threading.CancellationToken)" />
-      <Member Name="WaitAll(System.Threading.Tasks.Task[],System.TimeSpan)" />
-      <Member Name="WaitAll(System.Threading.Tasks.Task[],System.Int32,System.Threading.CancellationToken)" />
-      <Member Name="WaitAny(System.Threading.Tasks.Task[])" />
-      <Member Name="WaitAny(System.Threading.Tasks.Task[],System.Int32)" />
-      <Member Name="WaitAny(System.Threading.Tasks.Task[],System.Threading.CancellationToken)" />
-      <Member Name="WaitAny(System.Threading.Tasks.Task[],System.TimeSpan)" />
-      <Member Name="WaitAny(System.Threading.Tasks.Task[],System.Int32,System.Threading.CancellationToken)" />
-      <Member Name="GetAwaiter" />
-      <Member Name="ConfigureAwait(System.Boolean)" />
-      <Member Name="Yield" />
-      <Member Name="get_AsyncState" />
-      <Member Name="get_CompletedTask" />
-      <Member Name="get_CreationOptions" />
-      <Member Name="get_CurrentId" />
-      <Member Name="get_Exception" />
-      <Member Name="get_Factory" />
-      <Member Name="get_Id" />
-      <Member Name="get_IsCanceled" />
-      <Member Name="get_IsCompleted" />
-      <Member Name="get_IsFaulted" />
-      <Member Name="get_Status" />
-      <Member Status="ImplRoot" Name="get_DebuggerDisplayMethodDescription" />
-      <!--Internal members exposed to be used by Unwrap extension method in System.Core.dll-->
-      <Member Status="ImplRoot" Name="CreateUnwrapPromise&lt;TResult&gt;(System.Threading.Tasks.Task,System.Boolean)" />
-      <Member Status="ImplRoot" Name="NotifyDebuggerOfWaitCompletion"                       />
-      <Member Status="ImplRoot" Name="SetNotificationForWaitCompletion(System.Boolean)"     />
-      <!--Internal helper members exposed to be used by VS Debugger-->
-      <Member Status="ImplRoot" Name="GetDelegateContinuationsForDebugger" />
-      <Member Status="ImplRoot" Name="GetActiveTaskFromId(System.Int32)" />
-      <Member Status="ImplRoot" Name="GetActiveTasks" />
-      <Member Status="ImplRoot" Name="get_ParentForDebugger" />
-      <Member Status="ImplRoot" Name="get_StateFlagsForDebugger" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Threading.Tasks.SystemThreadingTasks_TaskDebugView">
-      <Member Status="ImplRoot" Name="#ctor(System.Threading.Tasks.Task)" />
-      <Member Status="ImplRoot" Name="get_AsyncState" />
-      <Member Status="ImplRoot" Name="get_CreationOptions" />
-      <Member Status="ImplRoot" Name="get_Exception" />
-      <Member Status="ImplRoot" Name="get_Id" />
-      <Member Status="ImplRoot" Name="get_Status" />
-      <Member Status="ImplRoot" Name="get_CancellationPending" />
-    </Type>
-    <Type Name="System.Threading.Tasks.Task&lt;TResult&gt;">
-      <Member Name="#ctor(System.Func&lt;TResult&gt;)" />
-      <Member Name="#ctor(System.Func&lt;TResult&gt;,System.Threading.CancellationToken)" />
-      <Member Name="#ctor(System.Func&lt;System.Object,TResult&gt;,System.Object)" />
-      <Member Name="#ctor(System.Func&lt;TResult&gt;,System.Threading.Tasks.TaskCreationOptions)" />
-      <Member Name="#ctor(System.Func&lt;System.Object,TResult&gt;,System.Object,System.Threading.CancellationToken)" />
-      <Member Name="#ctor(System.Func&lt;TResult&gt;,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions)" />
-      <Member Name="#ctor(System.Func&lt;System.Object,TResult&gt;,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
-      <Member Name="#ctor(System.Func&lt;System.Object,TResult&gt;,System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions)" />
-      <Member Name="ContinueWith(System.Action&lt;System.Threading.Tasks.Task&lt;TResult&gt;&gt;)" />
-      <Member Name="ContinueWith(System.Action&lt;System.Threading.Tasks.Task&lt;TResult&gt;&gt;,System.Threading.CancellationToken)" />
-      <Member Name="ContinueWith(System.Action&lt;System.Threading.Tasks.Task&lt;TResult&gt;&gt;,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="ContinueWith(System.Action&lt;System.Threading.Tasks.Task&lt;TResult&gt;&gt;,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWith(System.Action&lt;System.Threading.Tasks.Task&lt;TResult&gt;&gt;,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWith(System.Action&lt;System.Threading.Tasks.Task&lt;TResult&gt;,System.Object&gt;,System.Object)" />
-      <Member Name="ContinueWith(System.Action&lt;System.Threading.Tasks.Task&lt;TResult&gt;,System.Object&gt;,System.Object,System.Threading.CancellationToken)" />
-      <Member Name="ContinueWith(System.Action&lt;System.Threading.Tasks.Task&lt;TResult&gt;,System.Object&gt;,System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="ContinueWith(System.Action&lt;System.Threading.Tasks.Task&lt;TResult&gt;,System.Object&gt;,System.Object,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWith(System.Action&lt;System.Threading.Tasks.Task&lt;TResult&gt;,System.Object&gt;,System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWith&lt;TNewResult&gt;(System.Func&lt;System.Threading.Tasks.Task&lt;TResult&gt;,TNewResult&gt;)" />
-      <Member Name="ContinueWith&lt;TNewResult&gt;(System.Func&lt;System.Threading.Tasks.Task&lt;TResult&gt;,TNewResult&gt;,System.Threading.CancellationToken)" />
-      <Member Name="ContinueWith&lt;TNewResult&gt;(System.Func&lt;System.Threading.Tasks.Task&lt;TResult&gt;,TNewResult&gt;,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="ContinueWith&lt;TNewResult&gt;(System.Func&lt;System.Threading.Tasks.Task&lt;TResult&gt;,TNewResult&gt;,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWith&lt;TNewResult&gt;(System.Func&lt;System.Threading.Tasks.Task&lt;TResult&gt;,TNewResult&gt;,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWith&lt;TNewResult&gt;(System.Func&lt;System.Threading.Tasks.Task&lt;TResult&gt;,System.Object,TNewResult&gt;,System.Object)" />
-      <Member Name="ContinueWith&lt;TNewResult&gt;(System.Func&lt;System.Threading.Tasks.Task&lt;TResult&gt;,System.Object,TNewResult&gt;,System.Object,System.Threading.CancellationToken)" />
-      <Member Name="ContinueWith&lt;TNewResult&gt;(System.Func&lt;System.Threading.Tasks.Task&lt;TResult&gt;,System.Object,TNewResult&gt;,System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="ContinueWith&lt;TNewResult&gt;(System.Func&lt;System.Threading.Tasks.Task&lt;TResult&gt;,System.Object,TNewResult&gt;,System.Object,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWith&lt;TNewResult&gt;(System.Func&lt;System.Threading.Tasks.Task&lt;TResult&gt;,System.Object,TNewResult&gt;,System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ConfigureAwait(System.Boolean)" />
-      <Member Name="GetAwaiter" />
-      <Member Name="get_Factory" />
-      <Member Name="get_Result" />
-      <!-- DebuggerDisplayMethodDescription ysed by the debugger display-->
-      <Member Status="ImplRoot" Name="get_DebuggerDisplayMethodDescription" />
-      <Member Status="ImplRoot" Name="get_DebuggerDisplayResultDescription" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Threading.Tasks.SystemThreadingTasks_FutureDebugView&lt;TResult&gt;">
-      <Member Status="ImplRoot" Name="#ctor(System.Threading.Tasks.Task&lt;TResult&gt;)" />
-      <Member Status="ImplRoot" Name="get_AsyncState" />
-      <Member Status="ImplRoot" Name="get_CreationOptions" />
-      <Member Status="ImplRoot" Name="get_Exception" />
-      <Member Status="ImplRoot" Name="get_Id" />
-      <Member Status="ImplRoot" Name="get_Status" />
-      <Member Status="ImplRoot" Name="get_Result" />
-      <Member Status="ImplRoot" Name="get_CancellationPending" />
-    </Type>
-    <Type Name="System.Threading.Tasks.VoidTaskResult"/>
-    <Type Name="System.Threading.Tasks.TaskCanceledException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Threading.Tasks.Task)" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="get_Task" />
-    </Type>
-    <Type Name="System.Threading.Tasks.TaskCompletionSource&lt;TResult&gt;">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Object)" />
-      <Member Name="#ctor(System.Threading.Tasks.TaskCreationOptions)" />
-      <Member Name="#ctor(System.Object,System.Threading.Tasks.TaskCreationOptions)" />
-      <Member Name="SetCanceled" />
-      <Member Name="SetException(System.Exception)" />
-      <Member Name="SetException(System.Collections.Generic.IEnumerable&lt;System.Exception&gt;)" />
-      <Member Name="SetResult(TResult)" />
-      <Member Name="TrySetCanceled" />
-      <Member Name="TrySetCanceled(System.Threading.CancellationToken)" />
-      <Member Name="TrySetException(System.Exception)" />
-      <Member Name="TrySetException(System.Collections.Generic.IEnumerable&lt;System.Exception&gt;)" />
-      <Member Name="TrySetResult(TResult)" />
-      <Member Name="get_Task" />
-    </Type>
-    <Type Name="System.Threading.Tasks.TaskFactory">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Threading.CancellationToken)" />
-      <Member Name="#ctor(System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="#ctor(System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="#ctor(System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWhenAll(System.Threading.Tasks.Task[],System.Action&lt;System.Threading.Tasks.Task[]&gt;)" />
-      <Member Name="ContinueWhenAll(System.Threading.Tasks.Task[],System.Action&lt;System.Threading.Tasks.Task[]&gt;,System.Threading.CancellationToken)" />
-      <Member Name="ContinueWhenAll(System.Threading.Tasks.Task[],System.Action&lt;System.Threading.Tasks.Task[]&gt;,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="ContinueWhenAll(System.Threading.Tasks.Task[],System.Action&lt;System.Threading.Tasks.Task[]&gt;,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWhenAll&lt;TResult&gt;(System.Threading.Tasks.Task[],System.Func&lt;System.Threading.Tasks.Task[],TResult&gt;)" />
-      <Member Name="ContinueWhenAll&lt;TResult&gt;(System.Threading.Tasks.Task[],System.Func&lt;System.Threading.Tasks.Task[],TResult&gt;,System.Threading.CancellationToken)" />
-      <Member Name="ContinueWhenAll&lt;TResult&gt;(System.Threading.Tasks.Task[],System.Func&lt;System.Threading.Tasks.Task[],TResult&gt;,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="ContinueWhenAll&lt;TResult&gt;(System.Threading.Tasks.Task[],System.Func&lt;System.Threading.Tasks.Task[],TResult&gt;,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWhenAll&lt;TAntecedentResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Action&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[]&gt;)" />
-      <Member Name="ContinueWhenAll&lt;TAntecedentResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Action&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[]&gt;,System.Threading.CancellationToken)" />
-      <Member Name="ContinueWhenAll&lt;TAntecedentResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Action&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[]&gt;,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="ContinueWhenAll&lt;TAntecedentResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Action&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[]&gt;,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWhenAll&lt;TAntecedentResult,TResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Func&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],TResult&gt;)" />
-      <Member Name="ContinueWhenAll&lt;TAntecedentResult,TResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Func&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],TResult&gt;,System.Threading.CancellationToken)" />
-      <Member Name="ContinueWhenAll&lt;TAntecedentResult,TResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Func&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],TResult&gt;,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="ContinueWhenAll&lt;TAntecedentResult,TResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Func&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],TResult&gt;,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWhenAny(System.Threading.Tasks.Task[],System.Action&lt;System.Threading.Tasks.Task&gt;)" />
-      <Member Name="ContinueWhenAny(System.Threading.Tasks.Task[],System.Action&lt;System.Threading.Tasks.Task&gt;,System.Threading.CancellationToken)" />
-      <Member Name="ContinueWhenAny(System.Threading.Tasks.Task[],System.Action&lt;System.Threading.Tasks.Task&gt;,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="ContinueWhenAny(System.Threading.Tasks.Task[],System.Action&lt;System.Threading.Tasks.Task&gt;,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWhenAny&lt;TResult&gt;(System.Threading.Tasks.Task[],System.Func&lt;System.Threading.Tasks.Task,TResult&gt;)" />
-      <Member Name="ContinueWhenAny&lt;TResult&gt;(System.Threading.Tasks.Task[],System.Func&lt;System.Threading.Tasks.Task,TResult&gt;,System.Threading.CancellationToken)" />
-      <Member Name="ContinueWhenAny&lt;TResult&gt;(System.Threading.Tasks.Task[],System.Func&lt;System.Threading.Tasks.Task,TResult&gt;,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="ContinueWhenAny&lt;TResult&gt;(System.Threading.Tasks.Task[],System.Func&lt;System.Threading.Tasks.Task,TResult&gt;,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWhenAny&lt;TAntecedentResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Action&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;&gt;)" />
-      <Member Name="ContinueWhenAny&lt;TAntecedentResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Action&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;&gt;,System.Threading.CancellationToken)" />
-      <Member Name="ContinueWhenAny&lt;TAntecedentResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Action&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;&gt;,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="ContinueWhenAny&lt;TAntecedentResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Action&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;&gt;,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWhenAny&lt;TAntecedentResult,TResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Func&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;,TResult&gt;)" />
-      <Member Name="ContinueWhenAny&lt;TAntecedentResult,TResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Func&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;,TResult&gt;,System.Threading.CancellationToken)" />
-      <Member Name="ContinueWhenAny&lt;TAntecedentResult,TResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Func&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;,TResult&gt;,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="ContinueWhenAny&lt;TAntecedentResult,TResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Func&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;,TResult&gt;,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="FromAsync(System.IAsyncResult,System.Action&lt;System.IAsyncResult&gt;)"/>
-      <Member Name="FromAsync(System.IAsyncResult,System.Action&lt;System.IAsyncResult&gt;,System.Threading.Tasks.TaskCreationOptions)"/>
-      <Member Name="FromAsync(System.IAsyncResult,System.Action&lt;System.IAsyncResult&gt;,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)"/>
-      <Member Name="FromAsync&lt;TResult&gt;(System.IAsyncResult,System.Func&lt;System.IAsyncResult,TResult&gt;)"/>
-      <Member Name="FromAsync&lt;TResult&gt;(System.IAsyncResult,System.Func&lt;System.IAsyncResult,TResult&gt;,System.Threading.Tasks.TaskCreationOptions)"/>
-      <Member Name="FromAsync&lt;TResult&gt;(System.IAsyncResult,System.Func&lt;System.IAsyncResult,TResult&gt;,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)"/>
-      <Member Name="FromAsync(System.Func&lt;System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Action&lt;System.IAsyncResult&gt;,System.Object)"/>
-      <Member Name="FromAsync(System.Func&lt;System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Action&lt;System.IAsyncResult&gt;,System.Object,System.Threading.Tasks.TaskCreationOptions)"/>
-      <Member Name="FromAsync&lt;TResult&gt;(System.Func&lt;System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Func&lt;System.IAsyncResult,TResult&gt;,System.Object)"/>
-      <Member Name="FromAsync&lt;TResult&gt;(System.Func&lt;System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Func&lt;System.IAsyncResult,TResult&gt;,System.Object,System.Threading.Tasks.TaskCreationOptions)"/>
-      <Member Name="FromAsync&lt;TArg1&gt;(System.Func&lt;TArg1,System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Action&lt;System.IAsyncResult&gt;,TArg1,System.Object)"/>
-      <Member Name="FromAsync&lt;TArg1&gt;(System.Func&lt;TArg1,System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Action&lt;System.IAsyncResult&gt;,TArg1,System.Object,System.Threading.Tasks.TaskCreationOptions)"/>
-      <Member Name="FromAsync&lt;TArg1,TResult&gt;(System.Func&lt;TArg1,System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Func&lt;System.IAsyncResult,TResult&gt;,TArg1,System.Object)"/>
-      <Member Name="FromAsync&lt;TArg1,TResult&gt;(System.Func&lt;TArg1,System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Func&lt;System.IAsyncResult,TResult&gt;,TArg1,System.Object,System.Threading.Tasks.TaskCreationOptions)"/>
-      <Member Name="FromAsync&lt;TArg1,TArg2&gt;(System.Func&lt;TArg1,TArg2,System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Action&lt;System.IAsyncResult&gt;,TArg1,TArg2,System.Object)"/>
-      <Member Name="FromAsync&lt;TArg1,TArg2&gt;(System.Func&lt;TArg1,TArg2,System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Action&lt;System.IAsyncResult&gt;,TArg1,TArg2,System.Object,System.Threading.Tasks.TaskCreationOptions)"/>
-      <Member Name="FromAsync&lt;TArg1,TArg2,TResult&gt;(System.Func&lt;TArg1,TArg2,System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Func&lt;System.IAsyncResult,TResult&gt;,TArg1,TArg2,System.Object)"/>
-      <Member Name="FromAsync&lt;TArg1,TArg2,TResult&gt;(System.Func&lt;TArg1,TArg2,System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Func&lt;System.IAsyncResult,TResult&gt;,TArg1,TArg2,System.Object,System.Threading.Tasks.TaskCreationOptions)"/>
-      <Member Name="FromAsync&lt;TArg1,TArg2,TArg3&gt;(System.Func&lt;TArg1,TArg2,TArg3,System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Action&lt;System.IAsyncResult&gt;,TArg1,TArg2,TArg3,System.Object)"/>
-      <Member Name="FromAsync&lt;TArg1,TArg2,TArg3&gt;(System.Func&lt;TArg1,TArg2,TArg3,System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Action&lt;System.IAsyncResult&gt;,TArg1,TArg2,TArg3,System.Object,System.Threading.Tasks.TaskCreationOptions)"/>
-      <Member Name="FromAsync&lt;TArg1,TArg2,TArg3,TResult&gt;(System.Func&lt;TArg1,TArg2,TArg3,System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Func&lt;System.IAsyncResult,TResult&gt;,TArg1,TArg2,TArg3,System.Object)"/>
-      <Member Name="FromAsync&lt;TArg1,TArg2,TArg3,TResult&gt;(System.Func&lt;TArg1,TArg2,TArg3,System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Func&lt;System.IAsyncResult,TResult&gt;,TArg1,TArg2,TArg3,System.Object,System.Threading.Tasks.TaskCreationOptions)"/>
-      <Member Name="StartNew(System.Action)"/>
-      <Member Name="StartNew(System.Action,System.Threading.CancellationToken)"/>
-      <Member Name="StartNew(System.Action,System.Threading.Tasks.TaskCreationOptions)"/>
-      <Member Name="StartNew(System.Action,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)"/>
-      <Member Name="StartNew(System.Action&lt;System.Object&gt;,System.Object)"/>
-      <Member Name="StartNew(System.Action&lt;System.Object&gt;,System.Object,System.Threading.CancellationToken)"/>
-      <Member Name="StartNew(System.Action&lt;System.Object&gt;,System.Object,System.Threading.Tasks.TaskCreationOptions)"/>
-      <Member Name="StartNew(System.Action&lt;System.Object&gt;,System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)"/>
-      <Member Name="StartNew&lt;TResult&gt;(System.Func&lt;TResult&gt;)"/>
-      <Member Name="StartNew&lt;TResult&gt;(System.Func&lt;TResult&gt;,System.Threading.CancellationToken)"/>
-      <Member Name="StartNew&lt;TResult&gt;(System.Func&lt;TResult&gt;,System.Threading.Tasks.TaskCreationOptions)"/>
-      <Member Name="StartNew&lt;TResult&gt;(System.Func&lt;TResult&gt;,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)"/>
-      <Member Name="StartNew&lt;TResult&gt;(System.Func&lt;System.Object,TResult&gt;,System.Object)"/>
-      <Member Name="StartNew&lt;TResult&gt;(System.Func&lt;System.Object,TResult&gt;,System.Object,System.Threading.CancellationToken)"/>
-      <Member Name="StartNew&lt;TResult&gt;(System.Func&lt;System.Object,TResult&gt;,System.Object,System.Threading.Tasks.TaskCreationOptions)"/>
-      <Member Name="StartNew&lt;TResult&gt;(System.Func&lt;System.Object,TResult&gt;,System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)"/>
-      <Member Name="get_CancellationToken" />
-      <Member Name="get_CreationOptions" />
-      <Member Name="get_ContinuationOptions" />
-      <Member Name="get_Scheduler" />
-    </Type>
-    <Type Name="System.Threading.Tasks.TaskFactory&lt;TResult&gt;">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Threading.CancellationToken)" />
-      <Member Name="#ctor(System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="#ctor(System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="#ctor(System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWhenAll(System.Threading.Tasks.Task[],System.Func&lt;System.Threading.Tasks.Task[],TResult&gt;)" />
-      <Member Name="ContinueWhenAll(System.Threading.Tasks.Task[],System.Func&lt;System.Threading.Tasks.Task[],TResult&gt;,System.Threading.CancellationToken)" />
-      <Member Name="ContinueWhenAll(System.Threading.Tasks.Task[],System.Func&lt;System.Threading.Tasks.Task[],TResult&gt;,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="ContinueWhenAll(System.Threading.Tasks.Task[],System.Func&lt;System.Threading.Tasks.Task[],TResult&gt;,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWhenAll&lt;TAntecedentResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Func&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],TResult&gt;)" />
-      <Member Name="ContinueWhenAll&lt;TAntecedentResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Func&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],TResult&gt;,System.Threading.CancellationToken)" />
-      <Member Name="ContinueWhenAll&lt;TAntecedentResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Func&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],TResult&gt;,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="ContinueWhenAll&lt;TAntecedentResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Func&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],TResult&gt;,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWhenAny(System.Threading.Tasks.Task[],System.Func&lt;System.Threading.Tasks.Task,TResult&gt;)" />
-      <Member Name="ContinueWhenAny(System.Threading.Tasks.Task[],System.Func&lt;System.Threading.Tasks.Task,TResult&gt;,System.Threading.CancellationToken)" />
-      <Member Name="ContinueWhenAny(System.Threading.Tasks.Task[],System.Func&lt;System.Threading.Tasks.Task,TResult&gt;,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="ContinueWhenAny(System.Threading.Tasks.Task[],System.Func&lt;System.Threading.Tasks.Task,TResult&gt;,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="ContinueWhenAny&lt;TAntecedentResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Func&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;,TResult&gt;)" />
-      <Member Name="ContinueWhenAny&lt;TAntecedentResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Func&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;,TResult&gt;,System.Threading.CancellationToken)" />
-      <Member Name="ContinueWhenAny&lt;TAntecedentResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Func&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;,TResult&gt;,System.Threading.Tasks.TaskContinuationOptions)" />
-      <Member Name="ContinueWhenAny&lt;TAntecedentResult&gt;(System.Threading.Tasks.Task&lt;TAntecedentResult&gt;[],System.Func&lt;System.Threading.Tasks.Task&lt;TAntecedentResult&gt;,TResult&gt;,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="FromAsync(System.IAsyncResult,System.Func&lt;System.IAsyncResult,TResult&gt;)"/>
-      <Member Name="FromAsync(System.IAsyncResult,System.Func&lt;System.IAsyncResult,TResult&gt;,System.Threading.Tasks.TaskCreationOptions)"/>
-      <Member Name="FromAsync(System.IAsyncResult,System.Func&lt;System.IAsyncResult,TResult&gt;,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)"/>
-      <Member Name="FromAsync(System.Func&lt;System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Func&lt;System.IAsyncResult,TResult&gt;,System.Object)"/>
-      <Member Name="FromAsync(System.Func&lt;System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Func&lt;System.IAsyncResult,TResult&gt;,System.Object,System.Threading.Tasks.TaskCreationOptions)"/>
-      <Member Name="FromAsync&lt;TArg1&gt;(System.Func&lt;TArg1,System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Func&lt;System.IAsyncResult,TResult&gt;,TArg1,System.Object)"/>
-      <Member Name="FromAsync&lt;TArg1&gt;(System.Func&lt;TArg1,System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Func&lt;System.IAsyncResult,TResult&gt;,TArg1,System.Object,System.Threading.Tasks.TaskCreationOptions)"/>
-      <Member Name="FromAsync&lt;TArg1,TArg2&gt;(System.Func&lt;TArg1,TArg2,System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Func&lt;System.IAsyncResult,TResult&gt;,TArg1,TArg2,System.Object)"/>
-      <Member Name="FromAsync&lt;TArg1,TArg2&gt;(System.Func&lt;TArg1,TArg2,System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Func&lt;System.IAsyncResult,TResult&gt;,TArg1,TArg2,System.Object,System.Threading.Tasks.TaskCreationOptions)"/>
-      <Member Name="FromAsync&lt;TArg1,TArg2,TArg3&gt;(System.Func&lt;TArg1,TArg2,TArg3,System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Func&lt;System.IAsyncResult,TResult&gt;,TArg1,TArg2,TArg3,System.Object)"/>
-      <Member Name="FromAsync&lt;TArg1,TArg2,TArg3&gt;(System.Func&lt;TArg1,TArg2,TArg3,System.AsyncCallback,System.Object,System.IAsyncResult&gt;,System.Func&lt;System.IAsyncResult,TResult&gt;,TArg1,TArg2,TArg3,System.Object,System.Threading.Tasks.TaskCreationOptions)"/>
-      <Member Name="StartNew(System.Func&lt;TResult&gt;)"/>
-      <Member Name="StartNew(System.Func&lt;TResult&gt;,System.Threading.CancellationToken)"/>
-      <Member Name="StartNew(System.Func&lt;TResult&gt;,System.Threading.Tasks.TaskCreationOptions)"/>
-      <Member Name="StartNew(System.Func&lt;TResult&gt;,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)"/>
-      <Member Name="StartNew(System.Func&lt;System.Object,TResult&gt;,System.Object)"/>
-      <Member Name="StartNew(System.Func&lt;System.Object,TResult&gt;,System.Object,System.Threading.CancellationToken)"/>
-      <Member Name="StartNew(System.Func&lt;System.Object,TResult&gt;,System.Object,System.Threading.Tasks.TaskCreationOptions)"/>
-      <Member Name="StartNew(System.Func&lt;System.Object,TResult&gt;,System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)"/>
-      <Member Name="get_CancellationToken" />
-      <Member Name="get_CreationOptions" />
-      <Member Name="get_ContinuationOptions" />
-      <Member Name="get_Scheduler" />
-    </Type>
-    <Type Name="System.Threading.Tasks.UnobservedTaskExceptionEventArgs">
-      <Member Name="#ctor(System.AggregateException)" />
-      <Member Name="SetObserved" />
-      <Member Name="get_Exception" />
-      <Member Name="get_Observed" />
-    </Type>
-    <Type Name="System.Threading.Tasks.TaskContinuationOptions">
-      <Member MemberType="Field" Name="AttachedToParent" />
-      <Member MemberType="Field" Name="ExecuteSynchronously" />
-      <Member MemberType="Field" Name="LongRunning" />
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="NotOnCanceled" />
-      <Member MemberType="Field" Name="NotOnFaulted" />
-      <Member MemberType="Field" Name="NotOnRanToCompletion" />
-      <Member MemberType="Field" Name="OnlyOnCanceled" />
-      <Member MemberType="Field" Name="OnlyOnFaulted" />
-      <Member MemberType="Field" Name="OnlyOnRanToCompletion" />
-      <Member MemberType="Field" Name="PreferFairness" />
-      <Member MemberType="Field" Name="DenyChildAttach" />
-      <Member MemberType="Field" Name="HideScheduler" />
-      <Member MemberType="Field" Name="LazyCancellation" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Threading.Tasks.TaskCreationOptions">
-      <Member MemberType="Field" Name="AttachedToParent" />
-      <Member MemberType="Field" Name="LongRunning" />
-      <Member MemberType="Field" Name="None" />
-      <Member MemberType="Field" Name="PreferFairness" />
-      <Member MemberType="Field" Name="DenyChildAttach" />
-      <Member MemberType="Field" Name="HideScheduler" />
-      <Member MemberType="Field" Name="RunContinuationsAsynchronously" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Threading.Tasks.TaskStatus">
-      <Member MemberType="Field" Name="Created" />
-      <Member MemberType="Field" Name="WaitingForActivation" />
-      <Member MemberType="Field" Name="WaitingToRun" />
-      <Member MemberType="Field" Name="Running" />
-      <Member MemberType="Field" Name="WaitingForChildrenToComplete" />
-      <Member MemberType="Field" Name="RanToCompletion" />
-      <Member MemberType="Field" Name="Canceled" />
-      <Member MemberType="Field" Name="Faulted" />
-      <Member MemberType="Field" Name="value__" />
-    </Type>
-    <Type Name="System.Threading.Tasks.ConcurrentExclusiveSchedulerPair">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.Threading.Tasks.TaskScheduler)" />
-      <Member Name="#ctor(System.Threading.Tasks.TaskScheduler,System.Int32)" />
-      <Member Name="#ctor(System.Threading.Tasks.TaskScheduler,System.Int32,System.Int32)" />
-      <Member Name="Complete" />
-      <Member MemberType="Property" Name="Completion" />
-      <Member MemberType="Property" Name="ConcurrentScheduler" />
-      <Member MemberType="Property" Name="ExclusiveScheduler" />
-    </Type>
-   <Type Status="ImplRoot" Name="System.Threading.Tasks.ConcurrentExclusiveSchedulerPair+DebugView">
-      <Member Status="ImplRoot" Name="#ctor(System.Threading.Tasks.ConcurrentExclusiveSchedulerPair)" />
-      <Member Status="ImplRoot" MemberType="Property" Name="Mode" />
-      <Member Status="ImplRoot" MemberType="Property" Name="ScheduledExclusive" />
-      <Member Status="ImplRoot" MemberType="Property" Name="ScheduledConcurrent" />
-      <Member Status="ImplRoot" MemberType="Property" Name="CurrentlyExecutingTaskCount" />
-      <Member Status="ImplRoot" MemberType="Property" Name="TargetScheduler" />
-    </Type>
-   <Type Status="ImplRoot" Name="System.Threading.Tasks.ConcurrentExclusiveSchedulerPair+ConcurrentExclusiveTaskScheduler+DebugView">
-      <Member Status="ImplRoot" Name="#ctor(System.Threading.Tasks.ConcurrentExclusiveSchedulerPair+ConcurrentExclusiveTaskScheduler)" />
-      <Member Status="ImplRoot" MemberType="Property" Name="MaximumConcurrencyLevel" />
-      <Member Status="ImplRoot" MemberType="Property" Name="ScheduledTasks" />
-      <Member Status="ImplRoot" MemberType="Property" Name="SchedulerPair" />
-   </Type>
-   <Type Name="System.Threading.Tasks.TplEtwProvider+Tasks">
-      <Member MemberType="Field" Name="Loop" />
-      <Member MemberType="Field" Name="Invoke" />
-      <Member MemberType="Field" Name="TaskExecute" />
-      <Member MemberType="Field" Name="TaskWait" />
-      <Member MemberType="Field" Name="ForkJoin" />
-      <Member MemberType="Field" Name="TaskScheduled" />
-      <Member MemberType="Field" Name="AwaitTaskContinuationScheduled" />
-   </Type>
-   <Type Name="System.Threading.Tasks.TplEtwProvider+Keywords">
-      <Member MemberType="Field" Name="TaskTransfer" />
-      <Member MemberType="Field" Name="Tasks" />
-      <Member MemberType="Field" Name="Parallel" />
-   </Type>
-
-    <!-- System.Runtime.CompilerServices namespace -->
-    <Type Name="System.Runtime.CompilerServices.TaskAwaiter">
-      <Member Name="get_IsCompleted" />
-      <Member Name="OnCompleted(System.Action)" />
-      <Member Name="UnsafeOnCompleted(System.Action)" />
-      <Member Name="GetResult" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.TaskAwaiter&lt;TResult&gt;">
-      <Member Name="get_IsCompleted" />
-      <Member Name="OnCompleted(System.Action)" />
-      <Member Name="UnsafeOnCompleted(System.Action)" />
-      <Member Name="GetResult" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.ConfiguredTaskAwaitable">
-      <Member Name="GetAwaiter" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.ConfiguredTaskAwaitable+ConfiguredTaskAwaiter">
-      <Member Name="get_IsCompleted" />
-      <Member Name="OnCompleted(System.Action)" />
-      <Member Name="UnsafeOnCompleted(System.Action)" />
-      <Member Name="GetResult" />
-    </Type>
-     <Type Name="System.Runtime.CompilerServices.ConfiguredTaskAwaitable&lt;TResult&gt;">
-      <Member Name="GetAwaiter" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.ConfiguredTaskAwaitable&lt;TResult&gt;+ConfiguredTaskAwaiter">
-      <Member Name="get_IsCompleted" />
-      <Member Name="OnCompleted(System.Action)" />
-      <Member Name="UnsafeOnCompleted(System.Action)" />
-      <Member Name="GetResult" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.INotifyCompletion">
-      <Member Name="OnCompleted(System.Action)" />
-    </Type>
-     <Type Name="System.Runtime.CompilerServices.ICriticalNotifyCompletion">
-      <Member Name="UnsafeOnCompleted(System.Action)" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.YieldAwaitable">
-      <Member Name="GetAwaiter" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.YieldAwaitable+YieldAwaiter">
-      <Member Name="get_IsCompleted" />
-      <Member Name="OnCompleted(System.Action)" />
-      <Member Name="UnsafeOnCompleted(System.Action)" />
-      <Member Name="GetResult" />
-    </Type>
-     <Type Name="System.Runtime.CompilerServices.IAsyncStateMachine">
-      <Member Name="MoveNext" />
-      <Member Name="SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine)" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.AsyncVoidMethodBuilder">
-      <Member Name="Create" />
-      <Member Name="Start&lt;TStateMachine&gt;(TStateMachine@)" />
-      <Member Name="SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine)" />
-      <Member Name="AwaitOnCompleted&lt;TAwaiter,TStateMachine&gt;(TAwaiter@,TStateMachine@)" />
-      <Member Name="AwaitUnsafeOnCompleted&lt;TAwaiter,TStateMachine&gt;(TAwaiter@,TStateMachine@)" />
-      <Member Name="SetResult" />
-      <Member Name="SetException(System.Exception)" />
-      <!-- These are required by the debugger team.  Adding to the model file to prevent inadvertant thinning -->
-      <Member Status="ImplRoot" MemberType="Property" Name="ObjectIdForDebugger"   />
-      <Member Status="ImplRoot" Name="get_ObjectIdForDebugger"                     />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.AsyncTaskMethodBuilder">
-      <Member Name="Create" />
-      <Member Name="Start&lt;TStateMachine&gt;(TStateMachine@)" />
-      <Member Name="SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine)" />
-      <Member Name="AwaitOnCompleted&lt;TAwaiter,TStateMachine&gt;(TAwaiter@,TStateMachine@)" />
-      <Member Name="AwaitUnsafeOnCompleted&lt;TAwaiter,TStateMachine&gt;(TAwaiter@,TStateMachine@)" />
-      <Member Name="SetResult" />
-      <Member Name="SetException(System.Exception)" />
-      <Member Name="get_Task" />
-      <!-- These are required by the debugger team.  Adding to the model file to prevent inadvertant thinning -->
-      <Member Status="ImplRoot" MemberType="Property" Name="ObjectIdForDebugger" />
-      <Member Status="ImplRoot" Name="get_ObjectIdForDebugger" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_builder" />
-    </Type>
-    <Type Name="System.Runtime.CompilerServices.AsyncTaskMethodBuilder&lt;TResult&gt;" >
-      <Member Name="Create" />
-      <Member Name="Start&lt;TStateMachine&gt;(TStateMachine@)" />
-      <Member Name="SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine)" />
-      <Member Name="AwaitOnCompleted&lt;TAwaiter,TStateMachine&gt;(TAwaiter@,TStateMachine@)" />
-      <Member Name="AwaitUnsafeOnCompleted&lt;TAwaiter,TStateMachine&gt;(TAwaiter@,TStateMachine@)" />
-      <Member Name="SetResult(TResult)" />
-      <Member Name="SetException(System.Exception)" />
-      <Member Name="get_Task" />
-      <!-- These are required by the debugger team.  Adding to the model file to prevent inadvertant thinning -->
-      <Member Status="ImplRoot" MemberType="Property" Name="ObjectIdForDebugger" />
-      <Member Status="ImplRoot" Name="get_ObjectIdForDebugger" />
-      <Member Status="ImplRoot" MemberType="Field" Name="m_task" />
-    </Type>
-
-    <!-- System namespace -->
-    <Type Name="System.AggregateException">
-      <Member Name="#ctor"/>
-      <Member Name="#ctor(System.Collections.Generic.IEnumerable&lt;System.Exception&gt;)"/>
-      <Member Name="#ctor(System.Exception[])"/>
-      <Member Name="#ctor(System.String)"/>
-      <Member Name="#ctor(System.String,System.Collections.Generic.IEnumerable&lt;System.Exception&gt;)"/>
-      <Member Name="#ctor(System.String,System.Exception[])"/>
-      <Member Name="#ctor(System.String,System.Collections.Generic.IList&lt;System.Exception&gt;)"/>
-      <Member Name="#ctor(System.String,System.Exception)"/>
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="get_InnerExceptions" />
-      <Member Name="Handle(System.Func&lt;System.Exception,System.Boolean&gt;)"/>
-      <Member Name="Flatten"/>
-      <Member Name="GetBaseException"/>
-      <Member Name="ToString"/>
-    </Type>
-    <!-- System.Threading namespace -->
-    <Type Name="System.Threading.AsyncLocal&lt;T&gt;">
-      <Member Name="#ctor"/>
-      <Member Name="#ctor(System.Action&lt;System.Threading.AsyncLocalValueChangedArgs&lt;T&gt;&gt;)"/>
-      <Member Name="get_Value"/>
-      <Member Name="set_Value(T)"/>
-    </Type>
-    <Type Name="System.Threading.AsyncLocalValueChangedArgs&lt;T&gt;">
-      <Member Name="get_PreviousValue"/>
-      <Member Name="get_CurrentValue"/>
-      <Member Name="get_ThreadContextChanged"/>
-    </Type>
-    <Type Name="System.Threading.ExecutionContext">
-      <Member Status="ImplRoot" Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="Capture" />
-      <Member Name="CreateCopy" />
-      <Member Name="Dispose" />
-      <Member Name="GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-      <Member Name="IsFlowSuppressed" />
-      <Member Name="RestoreFlow" />
-      <Member Name="Run(System.Threading.ExecutionContext,System.Threading.ContextCallback,System.Object)"/>
-      <Member Name="SuppressFlow" />
-    </Type>
-    <Type Name="System.Threading.CancellationToken">
-      <Member Name="#ctor(System.Boolean)"/>
-      <Member Name="get_None" />
-      <Member Name="get_IsCancellationRequested" />
-      <Member Name="get_CanBeCanceled" />
-      <Member Name="get_WaitHandle" />
-      <Member Name="Register(System.Action)" />
-      <Member Name="Register(System.Action,System.Boolean)" />
-      <Member Name="Register(System.Action&lt;System.Object&gt;,System.Object)" />
-      <Member Name="Register(System.Action&lt;System.Object&gt;,System.Object,System.Boolean)" />
-      <Member Name="Equals(System.Threading.CancellationToken)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetHashCode" />
-      <Member Name="op_Equality(System.Threading.CancellationToken,System.Threading.CancellationToken)" />
-      <Member Name="op_Inequality(System.Threading.CancellationToken,System.Threading.CancellationToken)" />
-      <Member Name="ThrowIfCancellationRequested" />
-    </Type>
-    <Type Name="System.Threading.CancellationTokenSource">
-      <Member Name="#ctor"/>
-      <Member Name="#ctor(System.TimeSpan)" />
-      <Member Name="#ctor(System.Int32)" />
-      <Member Name="Cancel"/>
-      <Member Name="Cancel(System.Boolean)"/>
-      <Member Name="CancelAfter(System.TimeSpan)" />
-      <Member Name="CancelAfter(System.Int32)" />
-      <Member Name="CreateLinkedTokenSource(System.Threading.CancellationToken,System.Threading.CancellationToken)"/>
-      <Member Name="CreateLinkedTokenSource(System.Threading.CancellationToken[])"/>
-      <Member Name="Dispose"/>
-      <Member Name="Dispose(System.Boolean)" />
-      <Member Name="get_Token"/>
-      <Member Name="get_IsCancellationRequested"/>
-      <Member Status="ImplRoot" Name="get_CallbackCount" Condition="DEBUG"/>
-    </Type>
-    <Type Name="System.Threading.CancellationTokenRegistration">
-      <Member Name="Dispose"/>
-      <Member Name="Equals(System.Threading.CancellationTokenRegistration)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="GetHashCode" />
-      <Member Name="op_Equality(System.Threading.CancellationTokenRegistration,System.Threading.CancellationTokenRegistration)" />
-      <Member Name="op_Inequality(System.Threading.CancellationTokenRegistration,System.Threading.CancellationTokenRegistration)" />
-    </Type>
-    <Type Name="System.Threading.SpinWait">
-      <Member Name="SpinOnce"/>
-      <Member Name="Reset" />
-      <Member Name="get_Count" />
-      <Member Name="get_NextSpinWillYield" />
-      <Member Name="SpinUntil(System.Func&lt;System.Boolean&gt;)" />
-      <Member Name="SpinUntil(System.Func&lt;System.Boolean&gt;,System.TimeSpan)" />
-      <Member Name="SpinUntil(System.Func&lt;System.Boolean&gt;,System.Int32)" />
-    </Type>
-    <Type Name="System.Threading.SpinLock">
-      <Member Name="#ctor(System.Boolean)"/>
-      <Member Name="Enter(System.Boolean@)" />
-      <Member Name="TryEnter(System.Boolean@)" />
-      <Member Name="TryEnter(System.TimeSpan,System.Boolean@)" />
-      <Member Name="TryEnter(System.Int32,System.Boolean@)" />
-      <Member Name="Exit" />
-      <Member Name="Exit(System.Boolean)" />
-      <Member Name="get_IsHeld"/>
-      <Member Name="get_IsHeldByCurrentThread"/>
-      <Member Name="get_IsThreadOwnerTrackingEnabled"/>
-    </Type>
-    <Type Status="ImplRoot" Name="System.Threading.SpinLock+SystemThreading_SpinLockDebugView">
-      <Member Status="ImplRoot" Name="#ctor(System.Threading.SpinLock)"/>
-      <Member Status="ImplRoot" Name="get_IsHeld"/>
-      <Member Status="ImplRoot" Name="get_IsHeldByCurrentThread"/>
-      <Member Status="ImplRoot" Name="get_OwnerThreadID"/>
-    </Type>
-    <Type Name="System.Threading.ManualResetEventSlim">
-      <Member Name="#ctor"/>
-      <Member Name="#ctor(System.Boolean)"/>
-      <Member Name="#ctor(System.Boolean,System.Int32)"/>
-      <Member Name="Dispose"/>
-      <Member Name="Dispose(System.Boolean)" />
-      <Member Name="Set" />
-      <Member Name="Reset" />
-      <Member Name="Wait" />
-      <Member Name="Wait(System.TimeSpan)" />
-      <Member Name="Wait(System.Int32)" />
-      <Member Name="Wait(System.Threading.CancellationToken)" />
-      <Member Name="Wait(System.TimeSpan,System.Threading.CancellationToken)" />
-      <Member Name="Wait(System.Int32,System.Threading.CancellationToken)" />
-      <Member Name="get_IsSet"/>
-      <Member Name="get_SpinCount"/>
-      <Member Name="get_WaitHandle"/>
-    </Type>
-    <Type Name="System.Threading.CountdownEvent">
-      <Member Name="#ctor(System.Int32)"/>
-      <Member Name="AddCount"/>
-      <Member Name="AddCount(System.Int32)"/>
-      <Member Name="Dispose"/>
-      <Member Name="Dispose(System.Boolean)" />
-      <Member Name="Reset" />
-      <Member Name="Reset(System.Int32)" />
-      <Member Name="Signal" />
-      <Member Name="Signal(System.Int32)" />
-      <Member Name="TryAddCount"/>
-      <Member Name="TryAddCount(System.Int32)"/>
-      <Member Name="Wait" />
-      <Member Name="Wait(System.TimeSpan)" />
-      <Member Name="Wait(System.Int32)" />
-      <Member Name="Wait(System.Threading.CancellationToken)" />
-      <Member Name="Wait(System.TimeSpan,System.Threading.CancellationToken)" />
-      <Member Name="Wait(System.Int32,System.Threading.CancellationToken)" />
-      <Member Name="get_CurrentCount"/>
-      <Member Name="get_InitialCount"/>
-      <Member Name="get_IsSet"/>
-      <Member Name="get_WaitHandle"/>
-    </Type>
-    <Type Name="System.Threading.Semaphore">
-      <Member Name="#ctor(System.Int32,System.Int32)" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.String)" />
-      <Member Name="#ctor(System.Int32,System.Int32,System.String,System.Boolean@)" />
-      <Member Name="OpenExisting(System.String)" />
-      <Member Name="Release" />
-      <Member Name="Release(System.Int32)" />
-      <Member Name="TryOpenExisting(System.String,System.Threading.Semaphore@)" />
-    </Type>
-    <Type Name="System.Threading.SemaphoreSlim">
-      <Member Name="#ctor(System.Int32)"/>
-      <Member Name="#ctor(System.Int32,System.Int32)"/>
-      <Member Name="Dispose"/>
-      <Member Name="Dispose(System.Boolean)" />
-      <Member Name="Release" />
-      <Member Name="Release(System.Int32)" />
-      <Member Name="Wait" />
-      <Member Name="Wait(System.TimeSpan)" />
-      <Member Name="Wait(System.Int32)" />
-      <Member Name="Wait(System.Threading.CancellationToken)" />
-      <Member Name="Wait(System.TimeSpan,System.Threading.CancellationToken)" />
-      <Member Name="Wait(System.Int32,System.Threading.CancellationToken)" />
-      <!--WaitAsync only supported in CoreSys bcause CoreCLR build is still using V4.0 tools -->
-      <Member Name="WaitAsync" />
-      <Member Name="WaitAsync(System.TimeSpan)" />
-      <Member Name="WaitAsync(System.Int32)" />
-      <Member Name="WaitAsync(System.Threading.CancellationToken)" />
-      <Member Name="WaitAsync(System.TimeSpan,System.Threading.CancellationToken)" />
-      <Member Name="WaitAsync(System.Int32,System.Threading.CancellationToken)" />
-      <Member Name="get_CurrentCount"/>
-      <Member Name="get_AvailableWaitHandle"/>
-    </Type>
-    <Type Name="System.Threading.SemaphoreFullException">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.String)" />
-      <Member Name="#ctor(System.String,System.Exception)" />
-      <Member Name="#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
-    </Type>
-    <Type Name="System.Threading.ThreadLocal&lt;T&gt;">
-      <Member Name="#ctor"/>
-      <Member Name="#ctor(System.Boolean)"/>
-      <Member Name="#ctor(System.Func&lt;T&gt;)"/>
-      <Member Name="#ctor(System.Func&lt;T&gt;,System.Boolean)"/>
-      <Member Name="Dispose"/>
-      <Member Name="Dispose(System.Boolean)" />
-      <Member Name="ToString" />
-      <Member MemberType="Property" Name="Value" />
-      <Member Name="get_Values"/>
-      <Member Name="get_IsValueCreated"/>
-    </Type>
-    <Type Status="ImplRoot" Name="System.Threading.SystemThreading_ThreadLocalDebugView&lt;T&gt;">
-      <Member Name="#ctor(System.Threading.ThreadLocal&lt;T&gt;)"/>
-      <Member Status="ImplRoot" Name="get_Value"/>
-      <Member Status="ImplRoot" Name="get_IsValueCreated"/>
-      <Member Status="ImplRoot" Name="get_Values"/>
-    </Type>
-    <Type Name="System.Threading.LazyInitializer">
-      <Member Name="EnsureInitialized&lt;T&gt;(T@)"/>
-      <Member Name="EnsureInitialized&lt;T&gt;(T@,System.Func&lt;T&gt;)"/>
-      <Member Name="EnsureInitialized&lt;T&gt;(T@,System.Boolean@,System.Object@)"/>
-      <Member Name="EnsureInitialized&lt;T&gt;(T@,System.Boolean@,System.Object@,System.Func&lt;T&gt;)"/>
-    </Type>
-    <Type Status="ImplRoot" Name="Windows.Foundation.Diagnostics.ITracingStatusChangedEventArgs" Condition="FEATURE_COMINTEROP">
-      <Member Name="get_Enabled" />
-      <Member Name="get_TraceLevel" />
-    </Type>
-    <!--End of PFX types -->
-    <Type Name="System.Console">
-      <Member Name="Write(System.String)" />
-      <Member Name="WriteLine(System.String)" />
-      <Member Name="WriteLine" />
-    </Type>
-    <Type Name="System.Span&lt;T&gt;">
-      <Member Name="#ctor(T[])" />
-      <Member Name="#ctor(T[],System.Int32)" />
-      <Member Name="#ctor(T[],System.Int32,System.Int32)" />
-      <Member Name="#ctor(System.Void*,System.Int32)" />
-      <Member Name="DangerousGetPinnableReference" />
-      <Member Name="op_Implicit(T[])" ReturnType="System.Span&lt;T&gt;" />
-      <Member Name="op_Implicit(System.ArraySegment&lt;T&gt;)" ReturnType="System.Span&lt;T&gt;" />
-      <Member Name="op_Implicit(System.Span&lt;T&gt;)" ReturnType="System.ReadOnlySpan&lt;T&gt;" />
-      <Member Name="op_Equality(System.Span&lt;T&gt;,System.Span&lt;T&gt;)" />
-      <Member Name="op_Inequality(System.Span&lt;T&gt;,System.Span&lt;T&gt;)" />
-      <Member Name="get_Length" />
-      <Member Name="get_Empty" />
-      <Member Name="get_IsEmpty" />
-      <Member Name="get_Item(System.Int32)" />
-      <Member Name="set_Item(System.Int32,T)" />
-      <Member Name="ToArray" />
-      <Member Name="Slice(System.Int32)" />
-      <Member Name="Slice(System.Int32,System.Int32)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="DangerousCreate(System.Object,T@,System.Int32)" />
-      <Member Name="GetHashCode" />
-      <Member Name="CopyTo(System.Span&lt;T&gt;)" />
-      <Member Name="TryCopyTo(System.Span&lt;T&gt;)" />
-    </Type>
-    <Type Name="System.ReadOnlySpan&lt;T&gt;">
-      <Member Name="#ctor(T[])" />
-      <Member Name="#ctor(T[],System.Int32)" />
-      <Member Name="#ctor(T[],System.Int32,System.Int32)" />
-      <Member Name="#ctor(System.Void*,System.Int32)" />
-      <Member Name="DangerousGetPinnableReference" />
-      <Member Name="op_Implicit(T[])" ReturnType="System.ReadOnlySpan&lt;T&gt;" />
-      <Member Name="op_Implicit(System.ArraySegment&lt;T&gt;)" ReturnType="System.ReadOnlySpan&lt;T&gt;" />
-      <Member Name="op_Equality(System.ReadOnlySpan&lt;T&gt;,System.ReadOnlySpan&lt;T&gt;)" />
-      <Member Name="op_Inequality(System.ReadOnlySpan&lt;T&gt;,System.ReadOnlySpan&lt;T&gt;)" />
-      <Member Name="get_Length" />
-      <Member Name="get_Empty" />
-      <Member Name="get_IsEmpty" />
-      <Member Name="get_Item(System.Int32)" />
-      <Member Name="ToArray" />
-      <Member Name="Slice(System.Int32)" />
-      <Member Name="Slice(System.Int32,System.Int32)" />
-      <Member Name="Equals(System.Object)" />
-      <Member Name="DangerousCreate(System.Object,T@,System.Int32)" />
-      <Member Name="GetHashCode" />
-      <Member Name="TryCopyTo(System.Span&lt;T&gt;)" />
-      <Member Name="CopyTo(System.Span&lt;T&gt;)" />
-    </Type>
-    <Type Name="System.SpanExtensions">
-      <Member Name="AsBytes&lt;T&gt;(System.Span&lt;T&gt;)" />
-      <Member Name="AsBytes&lt;T&gt;(System.ReadOnlySpan&lt;T&gt;)" />
-      <Member Name="NonPortableCast&lt;TFrom,TTo&gt;(System.Span&lt;TFrom&gt;)" />
-      <Member Name="NonPortableCast&lt;TFrom,TTo&gt;(System.ReadOnlySpan&lt;TFrom&gt;)" />
-    </Type>
-    <Type Name="System.ReadOnlySpanExtensions">
-      <Member Name="Slice(System.String)" />
-      <Member Name="Slice(System.String,System.Int32)" />
-      <Member Name="Slice(System.String,System.Int32,System.Int32)" />
-    </Type>
-    <Type Name="System.ComponentModel.EditorBrowsableAttribute">
-      <Member Name="#ctor" />
-      <Member Name="#ctor(System.ComponentModel.EditorBrowsableState)" />
-      <Member Name="get_State" />
-      <Member MemberType="Property" Name="State" />
-    </Type>
-    <Type Name="System.ComponentModel.EditorBrowsableState">
-      <Member MemberType="Field" Name="Always" />
-      <Member MemberType="Field" Name="Never" />
-      <Member MemberType="Field" Name="Advanced" />
-    </Type>
-    <Type Status="ImplRoot" Name="System.Runtime.CompilerServices.Unsafe">
-      <Member Status="ImplRoot" Name="AsPointer&lt;T&gt;(T@)" />
-    </Type>
-  </Assembly>
-</ThinModel>
diff --git a/src/mscorlib/mscorlib.shared.sources.props b/src/mscorlib/mscorlib.shared.sources.props
deleted file mode 100644
index 1a51ea84da..0000000000
--- a/src/mscorlib/mscorlib.shared.sources.props
+++ /dev/null
@@ -1,1256 +0,0 @@
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\AccessedThroughPropertyAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\AssemblyAttributesGoHere.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\RuntimeHelpers.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\CompilerGeneratedAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\CustomConstantAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\DateTimeConstantAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\DiscardableAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\DecimalConstantAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\DisablePrivateReflectionAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\CompilationRelaxations.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\CompilerGlobalScopeAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\ExtensionAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\FormattableStringFactory.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\FixedBufferAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\IndexerNameAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\InternalsVisibleToAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\IsVolatile.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\MethodImplAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\FixedAddressValueTypeAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\UnsafeValueTypeAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\AssemblySettingAttributes.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\TypeDependencyAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\CompilerMarshalOverride.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\jithelpers.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\Unsafe.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\SpecialNameAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\SuppressMergeCheckAttribute.cs" />
-    <CompilerServicesSources Condition="'$(FeatureICastable)' == 'true'" Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\ICastable.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\SuppressIldasmAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\DecoratedNameAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\TypeForwardedToAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\TypeForwardedFromAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\ReferenceAssemblyAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\RuntimeCompatibilityAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\RuntimeWrappedException.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\ConditionalWeakTable.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\CallerFilePathAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\CallerLineNumberAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\CallerMemberNameAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\StateMachineAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\IteratorStateMachineAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\AsyncStateMachineAttribute.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\AsyncMethodBuilder.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\IAsyncStateMachine.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\INotifyCompletion.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\TaskAwaiter.cs" />
-    <CompilerServicesSources Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\YieldAwaitable.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <ReliabilitySources Include="$(BclSourcesRoot)\System\Runtime\Reliability\CriticalFinalizerObject.cs" />
-    <ReliabilitySources Include="$(BclSourcesRoot)\System\Runtime\Reliability\ReliabilityContractAttribute.cs" />
-    <ReliabilitySources Include="$(BclSourcesRoot)\System\Runtime\Reliability\PrePrepareMethodAttribute.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <RuntimeSources Include="$(BclSourcesRoot)\System\Runtime\MemoryFailPoint.cs" />
-    <RuntimeSources Include="$(BclSourcesRoot)\System\Runtime\GcSettings.cs" />
-    <RuntimeSources Include="$(BclSourcesRoot)\System\Runtime\ProfileOptimization.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\CollectionBase.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\ArrayList.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\Stack.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\Comparer.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\CompatibleComparer.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\ListDictionaryInternal.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\EmptyReadOnlyDictionaryInternal.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\Hashtable.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\DictionaryEntry.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\ICollection.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\IComparer.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\IDictionary.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\IDictionaryEnumerator.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\IEnumerable.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\IEnumerator.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\IEqualityComparer.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\IHashCodeProvider.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\IList.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\KeyValuePairs.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\SortedList.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\IStructuralEquatable.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\IStructuralComparable.cs" />
-    <CollectionsSources Include="$(BclSourcesRoot)\System\Collections\StructuralComparisons.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <ComponentModelSources Include="$(BclSourcesRoot)\System\ComponentModel\EditorBrowsableAttribute.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ArrayWithOffset.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\Attributes.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\CallingConvention.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\CharSet.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\COMException.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\CriticalHandle.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ExternalException.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\GcHandle.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\GCHandleCookieTable.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\HandleRef.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ICustomMarshaler.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\IException.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\InvalidOleVariantTypeException.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\LayoutKind.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\Marshal.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\MarshalDirectiveException.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\PInvokeMap.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\RuntimeEnvironment.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\SEHException.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\SafeBuffer.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\SafeHandle.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\BStrWrapper.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\CurrencyWrapper.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ErrorWrapper.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\UnknownWrapper.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\VariantWrapper.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComMemberType.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ICustomAdapter.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ICustomQueryInterface.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\InvalidComObjectException.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\SafeArrayRankMismatchException.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\SafeArrayTypeMismatchException.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\NativeCallableAttribute.cs" />
-    <InteropSources Condition="'$(FeatureCominterop)' != 'true'" Include="$(BclSourcesRoot)\System\Runtime\InteropServices\NonPortable.cs" />
-    <InteropSources Condition="'$(FeatureCominterop)' == 'true'" Include="$(BclSourcesRoot)\System\Runtime\InteropServices\DispatchWrapper.cs" />
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ICustomFactory.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <InteropSources Include="$(CoreFxSourcesRoot)\System\Runtime\InteropServices\StringBuffer.cs" />
-  </ItemGroup>
-  <ItemGroup Condition="'$(FeatureClassicCominterop)' == 'true'">
-    <InteropSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ITypeLibConverter.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <InteropExpandoSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\Expando\IExpando.cs" />
-  </ItemGroup>
-  <ItemGroup Condition="'$(FeatureClassicCominterop)' == 'true'">
-    <InteropComeventsSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComEventsHelper.cs" />
-    <InteropComeventsSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComEventsInfo.cs" />
-    <InteropComeventsSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComEventsMethod.cs" />
-    <InteropComeventsSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComEventsSink.cs" />
-    <InteropComeventsSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\NativeMethods.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <InteropComtypesSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IBindCtx.cs" />
-    <InteropComtypesSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IConnectionPointContainer.cs" />
-    <InteropComtypesSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IConnectionPoint.cs" />
-    <InteropComtypesSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IEnumMoniker.cs" />
-    <InteropComtypesSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IEnumConnections.cs" />
-    <InteropComtypesSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IEnumConnectionPoints.cs" />
-    <InteropComtypesSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IEnumString.cs" />
-    <InteropComtypesSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IEnumVARIANT.cs" />
-    <InteropComtypesSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IMoniker.cs" />
-    <InteropComtypesSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IPersistFile.cs" />
-    <InteropComtypesSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IRunningObjectTable.cs" />
-    <InteropComtypesSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\IStream.cs" />
-    <InteropComtypesSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\ITypeComp.cs" />
-    <InteropComtypesSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\ITypeInfo.cs" />
-    <InteropComtypesSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\ITypeLib.cs" />
-    <InteropComtypesSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\ITypeLib2.cs" />
-    <InteropComtypesSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ComTypes\ITypeInfo2.cs" />
-  </ItemGroup>
-  <ItemGroup Condition="'$(FeatureCominterop)' == 'true'">
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\Attributes.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\ConstantSplittableMap.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\DictionaryKeyCollection.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\DictionaryValueCollection.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\EnumeratorToIteratorAdapter.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\VectorToListAdapter.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\VectorToCollectionAdapter.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\VectorViewToReadOnlyCollectionAdapter.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\MapToDictionaryAdapter.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\MapToCollectionAdapter.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\MapViewToReadOnlyCollectionAdapter.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\ListToVectorAdapter.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\DictionaryToMapAdapter.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\BindableVectorToListAdapter.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\BindableVectorToCollectionAdapter.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\ListToBindableVectorAdapter.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\ListToBindableVectorViewAdapter.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\EventRegistrationToken.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\EventRegistrationTokenTable.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IActivationFactory.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IRestrictedErrorInfo.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IMapViewToIReadOnlyDictionaryAdapter.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IVectorViewToIReadOnlyListAdapter.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IReadOnlyDictionaryToIMapViewAdapter.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IReadOnlyListToIVectorViewAdapter.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IteratorToEnumeratorAdapter.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\ManagedActivationFactory.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\NativeMethods.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\PropertyValue.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\WindowsRuntimeMarshal.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\WindowsRuntimeMetadata.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IClosable.cs" />
-    <InteropWinRTSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\RuntimeClass.cs" />
-  </ItemGroup>
-  <ItemGroup Condition="'$(FeatureCominterop)' == 'true'">
-    <WinRTTSources Include='$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\CLRIPropertyValueImpl.cs' />
-    <WinRTTSources Include='$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\CLRIReferenceImpl.cs' />
-    <WinRTTSources Include='$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IPropertyValue.cs' />
-    <WinRTTSources Include='$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IReference.cs' />
-    <WinRTTSources Include='$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\WindowsFoundationEventHandler.cs' />
-    <WinRTTSources Include='$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\ICustomPropertyProvider.cs' />
-    <WinRTTSources Include='$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\ICustomProperty.cs' />
-    <WinRTTSources Include='$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\CustomPropertyImpl.cs' />
-    <WinRTTSources Include='$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\WindowsRuntimeBufferHelper.cs' />
-  </ItemGroup>
-  <ItemGroup Condition="'$(FeatureCominterop)' == 'true'">
-    <WinRTCollectionSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IIterable.cs" />
-    <WinRTCollectionSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IIterator.cs" />
-    <WinRTCollectionSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IVector.cs" />
-    <WinRTCollectionSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\IMap.cs" />
-    <WinRTCollectionSources Include="$(BclSourcesRoot)\System\Runtime\InteropServices\WindowsRuntime\CLRIKeyValuePairImpl.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <SystemSources Include="$(BclSourcesRoot)\System\AggregateException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\AppContext\AppContext.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\AppContext\AppContextSwitches.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\AppContext\AppContextDefaultValues.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\AppContext\AppContextDefaultValues.CoreClrOverrides.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\AppContext\AppContextDefaultValues.Defaults.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\AppContext\AppContextDefaultValues.Defaults.Central.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\CurrentTimeZone.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\TimeZone.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Object.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ICloneable.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Action.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Array.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ArraySegment.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\IComparable.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\IEquatable.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ThrowHelper.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Tuple.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\String.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\String.Comparison.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\String.Manipulation.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\String.Searching.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\StringComparer.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\StringComparison.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\StringSplitOptions.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Text\StringBuilder.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Text\StringBuilderCache.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Exception.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\FormattableString.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\DateTime.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\DateTimeKind.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\DateTimeOffset.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\SystemException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\OutOfMemoryException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\StackOverflowException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\DataMisalignedException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ExecutionEngineException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Delegate.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\MulticastDelegate.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\__Filters.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\__HResults.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\BCLDebug.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\MemberAccessException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Activator.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\AccessViolationException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ApplicationException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\AppDomain.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\AppDomainSetup.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\AppDomainManager.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\IAppDomainPauseManager.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\IAppDomain.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\AppDomainAttributes.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\AppDomainUnloadedException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ApplicationId.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ArgumentException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ArgumentNullException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ArgumentOutOfRangeException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ArgIterator.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ArithmeticException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ArrayTypeMismatchException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\AsyncCallback.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Attribute.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\AttributeTargets.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\AttributeUsageAttribute.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\BadImageFormatException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\BitConverter.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Boolean.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Buffer.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Byte.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\CannotUnloadAppDomainException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Char.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\CharEnumerator.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\CfgParser.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\CLSCompliantAttribute.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\TypeUnloadedException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\cominterfaces.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\CompatibilitySwitches.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\LowLevelConsole.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ContextMarshalException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Convert.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\StringFreezingAttribute.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Currency.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\DayOfWeek.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\DBNull.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Decimal.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\DefaultBinder.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\DelegateSerializationHolder.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\DivideByZeroException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Double.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\DuplicateWaitObjectException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Empty.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Enum.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\EntryPointNotFoundException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\DllNotFoundException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Environment.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\EventArgs.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\EventHandler.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\FieldAccessException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\FlagsAttribute.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\FormatException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\GC.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Guid.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\IAsyncResult.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ICustomFormatter.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\IDisposable.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\IFormatProvider.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\IFormattable.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\IndexOutOfRangeException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\IObservable.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\IObserver.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\IProgress.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\InsufficientMemoryException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\InsufficientExecutionStackException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Lazy.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Int16.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Int32.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Int64.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\IntPtr.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Internal.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\InvalidCastException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\InvalidOperationException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\InvalidProgramException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\InvalidTimeZoneException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\IConvertible.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\IServiceObjectProvider.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\_LocalDataStore.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\_LocalDataStoreMgr.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\MarshalByRefObject.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Math.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\MathF.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\mda.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\MethodAccessException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\MidpointRounding.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\MissingFieldException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\MissingMemberException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\MissingMethodException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\MulticastNotSupportedException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\NonSerializedAttribute.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\NotFiniteNumberException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\NotImplementedException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\NotSupportedException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\NullReferenceException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Number.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ObjectDisposedException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ObsoleteAttribute.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\OperatingSystem.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\OperationCanceledException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\OverflowException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ParamArrayAttribute.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ParamsArray.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ParseNumbers.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\PlatformID.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\PlatformNotSupportedException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Progress.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Random.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\RankException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ResId.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\RtType.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\RuntimeArgumentHandle.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\RuntimeHandles.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\SByte.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\SerializableAttribute.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\SharedStatics.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Single.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\StubHelpers.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ThreadAttributes.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\TimeoutException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\TimeSpan.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\TimeZoneInfo.AdjustmentRule.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\TimeZoneInfo.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\TimeZoneInfo.StringSerializer.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\TimeZoneInfo.TransitionTime.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\TimeZoneNotFoundException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Type.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\TypeAccessException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\TypeNameParser.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\TypeCode.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\TypedReference.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\TypeInitializationException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\TypeLoadException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\UInt16.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\UInt32.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\UInt64.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\UIntPtr.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\UnauthorizedAccessException.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\UnitySerializationHolder.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\UnhandledExceptionEventArgs.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\UnhandledExceptionEventHandler.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ValueType.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Version.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Void.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\WeakReference.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\WeakReferenceOfT.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\XmlIgnoreMemberAttribute.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\CLRConfig.cs" />
-    <SystemSources Condition="'$(FeatureCominterop)' == 'true'" Include="$(BclSourcesRoot)\System\__ComObject.cs" />
-    <SystemSources Condition="'$(FeatureCominterop)' == 'true'" Include="$(BclSourcesRoot)\System\Variant.cs" />
-    <SystemSources Condition="'$(FeatureClassicCominterop)' == 'true'" Include="$(BclSourcesRoot)\System\OleAutBinder.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ByReference.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\Span.cs" />
-    <SystemSources Include="$(BclSourcesRoot)\System\ReadOnlySpan.cs" />
-  </ItemGroup>
-  <ItemGroup Condition="'$(TargetsUnix)' == 'true'">
-    <SystemSources Include="$(BclSourcesRoot)\System\TimeZoneInfo.Unix.cs" />
-  </ItemGroup>
-  <ItemGroup Condition="'$(TargetsUnix)' != 'true'">
-    <SystemSources Include="$(BclSourcesRoot)\System\TimeZoneInfo.Win32.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <InternalSources Include="$(BclSourcesRoot)\Internal\Runtime\Augments\EnvironmentAugments.cs" />
-    <InternalSources Include="$(BclSourcesRoot)\Internal\Runtime\Augments\RuntimeThread.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\__Filters.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\AmbiguousMatchException.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\Assembly.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\AssemblyAttributes.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\AssemblyName.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\AssemblyNameProxy.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\AssemblyNameFlags.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\Associates.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\CustomAttributeExtensions.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\CustomAttributeFormatException.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\Binder.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\BindingFlags.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\CallingConventions.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\ComInterfaces.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\ConstructorInfo.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\CustomAttribute.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\DefaultMemberAttribute.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\EventAttributes.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\EventInfo.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\FieldAttributes.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\FieldInfo.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\GenericParameterAttributes.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\ICustomAttributeProvider.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\IReflectableType.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\IntrospectionExtensions.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\RuntimeReflectionExtensions.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\InterfaceMapping.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\InvalidFilterCriteriaException.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\IReflect.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\LoaderAllocator.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\ManifestResourceInfo.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\MdConstant.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\MdImport.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\MemberFilter.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\MemberInfo.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\MemberInfoSerializationHolder.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\MemberTypes.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\MethodAttributes.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\MethodBase.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\MethodImplAttributes.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\MethodInfo.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\Missing.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\Module.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\ObfuscateAssemblyAttribute.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\ObfuscationAttribute.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\MethodBody.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\ParameterAttributes.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\ParameterInfo.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\ParameterModifier.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\Pointer.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\PropertyAttributes.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\PropertyInfo.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\ReflectionContext.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\ReflectionTypeLoadException.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\ResourceAttributes.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\StrongNameKeyPair.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\TargetException.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\TargetInvocationException.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\TargetParameterCountException.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\TypeAttributes.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\TypeDelegator.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\TypeFilter.cs" />
-    <ReflectionSources Include="$(BclSourcesRoot)\System\Reflection\TypeInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\AssemblyBuilder.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\AssemblyBuilderData.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\AssemblyBuilderAccess.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\AQNBuilder.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\ComInterfaces.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\ConstructorBuilder.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\DynamicILGenerator.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\DynamicMethod.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\EventBuilder.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\EventToken.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\FieldBuilder.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\FieldToken.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\ILGenerator.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\ISymWrapperCore.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\Label.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\LocalBuilder.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\MethodBuilder.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\MethodBuilderInstantiation.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\SymbolType.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\SymbolMethod.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\CustomAttributeBuilder.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\MethodToken.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\ModuleBuilder.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\ModuleBuilderData.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\PEFileKinds.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\OpCodes.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\Opcode.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\OpcodeType.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\StackBehaviour.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\OperandType.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\FlowControl.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\ParameterBuilder.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\ParameterToken.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\PropertyBuilder.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\PropertyToken.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\SignatureHelper.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\SignatureToken.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\StringToken.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\TypeBuilder.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\TypeBuilderInstantiation.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\GenericTypeParameterBuilder.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\EnumBuilder.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\TypeToken.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\XXXOnTypeBuilderInstantiation.cs" />
-    <ReflectionEmitSources Include="$(BclSourcesRoot)\System\Reflection\Emit\UnmanagedMarshal.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <ReflectionMetadataSources Include="$(BclSourcesRoot)\System\Reflection\Metadata\AssemblyExtensions.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\DateTimeFormat.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\DateTimeParse.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\DateTimeStyles.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\NumberStyles.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\TimeSpanFormat.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\TimeSpanParse.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\DaylightTime.cs" />
-  </ItemGroup>
-  <ItemGroup Condition="'$(FeatureCoreFxGlobalization)' != 'true'">
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\BidiCategory.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\Calendar.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\CalendarData.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\CalendarAlgorithmType.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\CalendarWeekRule.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\CalendricalCalculationsHelper.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\CharUnicodeInfo.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\CompareInfo.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\CultureInfo.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\CultureNotFoundException.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\CultureTypes.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\DateTimeFormatInfo.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\DateTimeFormatInfoScanner.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\DigitShapes.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\EncodingDataItem.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\EncodingTable.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\GlobalizationAssembly.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\GregorianCalendar.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\GregorianCalendarTypes.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\GregorianCalendarHelper.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\HebrewCalendar.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\HijriCalendar.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\UmAlQuraCalendar.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\PersianCalendar.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\IdnMapping.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\JapaneseCalendar.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\KoreanCalendar.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\RegionInfo.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\SortKey.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\SortVersion.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\StringInfo.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\TaiwanCalendar.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\TextElementEnumerator.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\TextInfo.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\ThaiBuddhistCalendar.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\TimeSpanStyles.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\NumberFormatInfo.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\UnicodeCategory.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\CultureData.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\HebrewNumber.cs" />
-    <GlobalizationSources Condition="'$(FeatureOnlyCoreCalendars)'==''" Include="$(BclSourcesRoot)\System\Globalization\ChineseLunisolarCalendar.cs" />
-    <GlobalizationSources Condition="'$(FeatureOnlyCoreCalendars)'==''" Include="$(BclSourcesRoot)\System\Globalization\EastAsianLunisolarCalendar.cs" />
-    <GlobalizationSources Condition="'$(FeatureOnlyCoreCalendars)'==''" Include="$(BclSourcesRoot)\System\Globalization\JapaneseLunisolarCalendar.cs" />
-    <GlobalizationSources Condition="'$(FeatureOnlyCoreCalendars)'==''" Include="$(BclSourcesRoot)\System\Globalization\JulianCalendar.cs" />
-    <GlobalizationSources Condition="'$(FeatureOnlyCoreCalendars)'==''" Include="$(BclSourcesRoot)\System\Globalization\KoreanLunisolarCalendar.cs" />
-    <GlobalizationSources Condition="'$(FeatureOnlyCoreCalendars)'==''" Include="$(BclSourcesRoot)\System\Globalization\TaiwanLunisolarCalendar.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\SR.cs" />
-  </ItemGroup>
-  <ItemGroup Condition="'$(FeatureCoreFxGlobalization)' == 'true'">
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\Calendar.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\CalendarAlgorithmType.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\CalendarData.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\CalendarWeekRule.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\CalendricalCalculationsHelper.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\CharUnicodeInfo.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\CharUnicodeInfoData.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\ChineseLunisolarCalendar.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\CompareInfo.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\CultureData.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\CultureInfo.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\CultureTypes.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\CultureNotFoundException.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\DateTimeFormatInfo.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\DateTimeFormatInfoScanner.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\EastAsianLunisolarCalendar.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\GregorianCalendar.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\GregorianCalendarHelper.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\GregorianCalendarTypes.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\HebrewCalendar.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\HebrewNumber.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\HijriCalendar.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\IdnMapping.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\InternalGlobalizationHelper.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\JapaneseCalendar.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\JapaneseLunisolarCalendar.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\JulianCalendar.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\KoreanCalendar.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\KoreanLunisolarCalendar.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\NumberFormatInfo.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\PersianCalendar.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\RegionInfo.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\SortKey.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\SortVersion.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\StringInfo.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\TaiwanCalendar.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\TaiwanLunisolarCalendar.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\TextElementEnumerator.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\TextInfo.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\ThaiBuddhistCalendar.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\TimeSpanStyles.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\UmAlQuraCalendar.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\UnicodeCategory.cs " /> 
-  </ItemGroup>
-  <ItemGroup Condition="'$(FeatureCoreFxGlobalization)' == 'true' and '$(TargetsUnix)' == 'true'">
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\EncodingTable.Unix.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Globalization\EncodingDataItem.Unix.cs" />
-    <GlobalizationSources Include="$(BclSourcesRoot)\System\Text\Normalization.Unix.cs" />
-
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Globalization.Native\Interop.Calendar.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Globalization.Native\Interop.Casing.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Globalization.Native\Interop.Collation.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Globalization.Native\Interop.Idna.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Globalization.Native\Interop.Locale.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Globalization.Native\Interop.Normalization.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Globalization.Native\Interop.ResultCode.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Globalization.Native\Interop.TimeZoneInfo.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Globalization.Native\Interop.Utils.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\CalendarData.Unix.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\CompareInfo.Unix.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\CultureData.Unix.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\CultureInfo.Unix.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\DigitShapes.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\HijriCalendar.Unix.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\IdnMapping.Unix.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\JapaneseCalendar.Unix.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\LocaleData.Unix.cs" />
-    <GlobalizationSources Include="$(CoreFxSourcesRoot)\System\Globalization\TextInfo.Unix.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\AbandonedMutexException.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\AsyncLocal.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\AutoResetEvent.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\SendOrPostCallback.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\SynchronizationContext.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\EventResetMode.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\EventWaitHandle.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\ExecutionContext.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Interlocked.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\IObjectHandle.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\LockCookie.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\LockRecursionException.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\ManualResetEvent.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Monitor.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Mutex.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Overlapped.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\ParameterizedThreadStart.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Semaphore.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\SemaphoreFullException.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\SynchronizationLockException.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Thread.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\ThreadAbortException.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\ThreadInterruptedException.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\ThreadPool.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\ThreadPriority.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\ThreadStart.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\ThreadState.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\ThreadStateException.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\ThreadStaticAttribute.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\ThreadStartException.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Timeout.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Timer.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Volatile.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\WaitHandle.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\WaitHandleCannotBeOpenedException.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\ApartmentState.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\SpinLock.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\SpinWait.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\CountdownEvent.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\LazyInitializer.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\ThreadLocal.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\SemaphoreSlim.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\ManualResetEventSlim.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\CancellationTokenRegistration.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\CancellationTokenSource.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\CancellationToken.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Tasks\future.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Tasks\FutureFactory.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Tasks\Task.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Tasks\TaskContinuation.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Tasks\TaskCanceledException.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Tasks\TaskSchedulerException.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Tasks\TaskExceptionHolder.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Tasks\TaskFactory.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Tasks\TaskScheduler.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Tasks\ThreadPoolTaskScheduler.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Tasks\TaskCompletionSource.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Tasks\AsyncCausalityTracer.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Tasks\ConcurrentExclusiveSchedulerPair.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Tasks\ProducerConsumerQueues.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Tasks\TPLETWProvider.cs" />
-    <ThreadingSources Include="$(BclSourcesRoot)\System\Threading\Tasks\TaskToApm.cs" />
-    <ThreadingSources Condition="'$(FeatureCominterop)' == 'true'" Include="$(BclSourcesRoot)\System\Threading\Tasks\IAsyncCausalityTracerStatics.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <FileStreamSources Include="$(CoreFxSourcesRoot)\System\IO\FileStream.cs" />
-    <FileStreamSources Include="$(CoreFxSourcesRoot)\System\IO\FileStream.NetStandard17.cs" />
-    <FileStreamSources Include="$(CoreFxSourcesRoot)\System\IO\Error.cs" />
-  </ItemGroup>
-  <ItemGroup Condition="'$(TargetsUnix)' == 'true'">
-    <SafehandleSources Include="$(CoreFxSourcesRoot)\Microsoft\Win32\SafeHandles\SafeFileHandle.Unix.cs" />
-    <FileStreamSources Include="$(CoreFxSourcesRoot)\System\IO\FileStream.Unix.cs" />
-  </ItemGroup>
-  <ItemGroup Condition="'$(TargetsUnix)' != 'true'">
-    <SafehandleSources Include="$(CoreFxSourcesRoot)\Microsoft\Win32\SafeHandles\SafeFileHandle.Windows.cs" />
-    <FileStreamSources Include="$(CoreFxSourcesRoot)\System\IO\FileStream.Win32.cs" />
-    <FileStreamSources Include="$(CoreFxSourcesRoot)\System\IO\FileStreamCompletionSource.Win32.cs" />
-    <FileStreamSources Include="$(CoreFxSourcesRoot)\System\IO\Win32Marshal.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <IoSources Include="$(CoreFxSourcesRoot)\System\IO\Path.cs" />
-    <IoSources Include="$(CoreFxSourcesRoot)\System\IO\PathInternal.cs" />
-  </ItemGroup>
-  <ItemGroup Condition="'$(TargetsUnix)' == 'true'">
-    <IoSources Include="$(CoreFxSourcesRoot)\System\IO\Path.Unix.cs" />
-    <IoSources Include="$(CoreFxSourcesRoot)\System\IO\PathInternal.Unix.cs" />
-  </ItemGroup>
-  <ItemGroup Condition="'$(TargetsUnix)' != 'true'">
-    <IoSources Include="$(CoreFxSourcesRoot)\System\IO\Path.Win32.cs" />
-    <IoSources Include="$(CoreFxSourcesRoot)\System\IO\Path.Windows.cs" />
-    <IoSources Include="$(CoreFxSourcesRoot)\System\IO\PathHelper.Windows.cs" />
-    <IoSources Include="$(CoreFxSourcesRoot)\System\IO\PathInternal.Windows.cs" />
-    <IoSources Include="$(CoreFxSourcesRoot)\System\IO\PathInternal.Windows.StringBuffer.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <ThreadingSources Include="$(CoreFxSourcesRoot)\System\Threading\DeferredDisposableLifetime.cs" />
-    <ThreadingSources Include="$(CoreFxSourcesRoot)\System\Threading\ClrThreadPoolBoundHandle.cs" />
-    <ThreadingSources Include="$(CoreFxSourcesRoot)\System\Threading\ClrThreadPoolBoundHandleOverlapped.cs" />
-    <ThreadingSources Include="$(CoreFxSourcesRoot)\System\Threading\ClrThreadPoolPreAllocatedOverlapped.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <IoSources Include="$(BclSourcesRoot)\System\IO\__Error.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\__HResults.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\BinaryReader.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\BinaryWriter.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\Directory.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\SearchOption.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\DirectoryNotFoundException.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\DriveNotFoundException.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\EncodingCache.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\EndOfStreamException.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\File.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\FileAccess.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\FileLoadException.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\FileMode.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\FileNotFoundException.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\FileOptions.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\FileShare.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\FileSystemEnumerable.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\IOException.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\MemoryStream.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\PathTooLongException.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\PinnedBufferMemoryStream.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\SeekOrigin.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\Stream.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\StreamHelpers.CopyValidation.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\StreamReader.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\TextReader.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\UnmanagedMemoryAccessor.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\UnmanagedMemoryStream.cs" />
-    <IoSources Include="$(BclSourcesRoot)\System\IO\UnmanagedMemoryStreamWrapper.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\Attributes.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\BuiltInPermissionSets.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\CodeAccessPermission.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\CodeAccessSecurityEngine.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\IEvidenceFactory.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\IPermission.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\ISecurityEncodable.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\ISecurityPolicyEncodable.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\IStackWalk.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\FrameSecurityDescriptor.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\HostSecurityManager.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\NamedPermissionSet.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\PermissionSetEnumerator.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\PermissionSet.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\PermissionToken.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\PermissionSetTriple.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\PermissionListSet.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\SecurityContext.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\SecurityException.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\SecurityState.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\HostProtectionException.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\SecurityManager.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\SecurityRuntime.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\SecurityZone.cs" />
-    <SecuritySources Include="$(BclSourcesRoot)\System\Security\VerificationException.cs" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <SecUtilSources Include="$(BclSourcesRoot)\System\Security\Util\Config.cs" />
-    <SecUtilSources Include="$(BclSourcesRoot)\System\Security\Util\Hex.cs" />
-    <SecUtilSources Include="$(BclSourcesRoot)\System\Security\Util\sitestring.cs" />
-    <SecUtilSources Include="$(BclSourcesRoot)\System\Security\Util\StringExpressionSet.cs" />
-    <SecUtilSources Include="$(BclSourcesRoot)\System\Security\Util\TokenBasedSet.cs" />
-    <SecUtilSources Include="$(BclSourcesRoot)\System\Security\Util\TokenBasedSetEnumerator.cs" />
-    <SecUtilSources Include="$(BclSourcesRoot)\System\Security\Util\URLString.cs" />
-    <SecUtilSources Include="$(BclSourcesRoot)\System\Security\Util\XMLUtil.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Assert.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\AssertFilter.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\AssertFilters.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\ConditionalAttribute.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Debugger.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\DebuggerAttributes.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\ICustomDebuggerNotification.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\log.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\LoggingLevels.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\LogSwitch.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Stacktrace.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Stackframe.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\EditAndContinueHelper.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\ActivityTracker.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\EventActivityOptions.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\EventDescriptor.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\EventProvider.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\EventSource.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\EventSource_CoreCLR.cs" />
-    <DiagnosticsSources Condition="'$(FeatureXplatEventSource)' == 'true'" Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\XplatEventLogger.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\EventSourceException.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\FrameworkEventSource.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\StubEnvironment.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\Winmeta.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\ArrayTypeInfo.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\ConcurrentSet.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\ConcurrentSetItem.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\DataCollector.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\EmptyStruct.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\EnumerableTypeInfo.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\EnumHelper.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\EventDataAttribute.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\EventFieldAttribute.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\EventFieldFormat.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\EventIgnoreAttribute.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\EventPayload.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\EventSourceOptions.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\FieldMetadata.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\InvokeTypeInfo.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\NameInfo.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\PropertyValue.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\PropertyAnalysis.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\SimpleEventTypes.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\SimpleTypeInfos.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\Statics.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\TraceLoggingDataCollector.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\TraceLoggingDataType.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\TraceLoggingEventSource.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\TraceLoggingEventTraits.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\TraceLoggingEventTypes.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\TraceLoggingMetadataCollector.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\TraceLoggingTypeInfo.cs" />
-    <DiagnosticsSources Include="$(BclSourcesRoot)\System\Diagnostics\Eventing\TraceLogging\TypeAnalysis.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <DiagnosticsCodeanalysisSources Include="$(BclSourcesRoot)\System\Diagnostics\CodeAnalysis\SuppressMessageAttribute.cs" />
-    <DiagnosticsCodeanalysisSources Include="$(BclSourcesRoot)\System\Diagnostics\Contracts\Contracts.cs" />
-    <DiagnosticsCodeanalysisSources Include="$(BclSourcesRoot)\System\Diagnostics\Contracts\ContractsBCL.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <DiagnosticsSymbolstoreSources Include="$(BclSourcesRoot)\System\Diagnostics\SymbolStore\ISymDocumentWriter.cs" />
-    <DiagnosticsSymbolstoreSources Include="$(BclSourcesRoot)\System\Diagnostics\SymbolStore\ISymWriter.cs" />
-    <DiagnosticsSymbolstoreSources Include="$(BclSourcesRoot)\System\Diagnostics\SymbolStore\SymAddressKind.cs" />
-    <DiagnosticsSymbolstoreSources Include="$(BclSourcesRoot)\System\Diagnostics\SymbolStore\Token.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <ExceptionservicesSources Include="$(BclSourcesRoot)\System\Runtime\ExceptionServices\CorruptingExceptionCommon.cs" />
-    <ExceptionservicesSources Include="$(BclSourcesRoot)\System\Runtime\ExceptionServices\ExceptionServicesCommon.cs" />
-    <ExceptionservicesSources Include="$(BclSourcesRoot)\System\Runtime\ExceptionServices\ExceptionNotification.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <HostingSources Include="$(BclSourcesRoot)\System\Runtime\Loader\AssemblyLoadContext.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <SerializationSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\FormatterConverter.cs" />
-    <SerializationSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\FormatterServices.cs" />
-    <SerializationSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\IDeserializationCallback.cs" />
-    <SerializationSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\IFormatter.cs" />
-    <SerializationSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\IFormatterConverter.cs" />
-    <SerializationSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\IObjectReference.cs" />
-    <SerializationSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\ISerializable.cs" />
-    <SerializationSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\ISerializationSurrogate.cs" />
-    <SerializationSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\ISurrogateSelector.cs" />
-    <SerializationSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\MemberHolder.cs" />
-    <SerializationSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\SerializationAttributes.cs" />
-    <SerializationSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\SerializationBinder.cs" />
-    <SerializationSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\SerializationException.cs" />
-    <SerializationSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\SerializationFieldInfo.cs" />
-    <SerializationSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\SerializationInfo.cs" />
-    <SerializationSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\SerializationInfoEnumerator.cs" />
-    <SerializationSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\StreamingContext.cs" />
-    <SerializationSources Include="$(BclSourcesRoot)\System\Runtime\Serialization\SafeSerializationManager.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <VersioningSources Include="$(BclSourcesRoot)\System\Runtime\Versioning\TargetFrameworkAttribute.cs" />
-    <VersioningSources Include="$(BclSourcesRoot)\System\Runtime\Versioning\TargetFrameworkId.cs" />
-    <VersioningSources Include="$(BclSourcesRoot)\System\Runtime\Versioning\CompatibilitySwitch.cs" />
-    <VersioningSources Include="$(BclSourcesRoot)\System\Runtime\Versioning\NonVersionableAttribute.cs" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ConfigurationAssembliesSources Include="$(BclSourcesRoot)\System\Configuration\Assemblies\AssemblyHash.cs" />
-    <ConfigurationAssembliesSources Include="$(BclSourcesRoot)\System\Configuration\Assemblies\AssemblyHashAlgorithm.cs" />
-    <ConfigurationAssembliesSources Include="$(BclSourcesRoot)\System\Configuration\Assemblies\AssemblyVersionCompatibility.cs" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <RemotingSources Include="$(BclSourcesRoot)\System\Runtime\Remoting\ObjectHandle.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <TextSources Include="$(BclSourcesRoot)\System\Text\ASCIIEncoding.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\CodePageEncoding.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\Decoder.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\DecoderNLS.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\DecoderBestFitFallback.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\DecoderExceptionFallback.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\DecoderFallback.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\DecoderReplacementFallback.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\Encoder.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\EncoderNLS.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\EncoderBestFitFallback.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\EncoderExceptionFallback.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\EncoderFallback.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\EncoderReplacementFallback.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\Encoding.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\EncodingForwarder.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\EncodingInfo.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\EncodingNLS.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\EncodingProvider.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\ISCIIEncoding.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\Latin1Encoding.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\MLangCodePageEncoding.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\Normalization.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\Normalization.Windows.cs" Condition="'$(TargetsUnix)' != 'true'"/>
-    <TextSources Include="$(BclSourcesRoot)\System\Text\SurrogateEncoder.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\UnicodeEncoding.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\UTF7Encoding.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\UTF8Encoding.cs" />
-    <TextSources Include="$(BclSourcesRoot)\System\Text\UTF32Encoding.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <SecurityAclSources Include="$(BclSourcesRoot)\System\Security\AccessControl\Enums.cs" />
-  </ItemGroup>
-  <ItemGroup Condition="'$(FeatureCasPolicy)' != 'true'">
-    <SecurityPolicySources Include="$(BclSourcesRoot)\System\Security\Policy\ApplicationTrust.cs" />
-    <SecurityPolicySources Include="$(BclSourcesRoot)\System\Security\Policy\Evidence.cs" />
-    <SecurityPolicySources Include="$(BclSourcesRoot)\System\Security\Policy\EvidenceBase.cs" />
-    <SecurityPolicySources Include="$(BclSourcesRoot)\System\Security\Policy\EvidenceTypeDescriptor.cs" />
-    <SecurityPolicySources Include="$(BclSourcesRoot)\System\Security\Policy\IDelayEvaluatedEvidence.cs" />
-    <SecurityPolicySources Include="$(BclSourcesRoot)\System\Security\Policy\IIdentityPermissionFactory.cs" />
-    <SecurityPolicySources Include="$(BclSourcesRoot)\System\Security\Policy\IRuntimeEvidenceFactory.cs" />
-    <SecurityPolicySources Include="$(BclSourcesRoot)\System\Security\Policy\PolicyException.cs" />
-    <SecurityPolicySources Include="$(BclSourcesRoot)\System\Security\Policy\PolicyStatement.cs" />
-    <SecurityPolicySources Include="$(BclSourcesRoot)\System\Security\Policy\Site.cs" />
-    <SecurityPolicySources Include="$(BclSourcesRoot)\System\Security\Policy\StrongName.cs" />
-    <SecurityPolicySources Include="$(BclSourcesRoot)\System\Security\Policy\URL.cs" />
-    <SecurityPolicySources Include="$(BclSourcesRoot)\System\Security\Policy\Zone.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <XmlSources Include="$(BclSourcesRoot)\System\Security\SecurityElement.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Win32Sources Include="$(BclSourcesRoot)\Microsoft\Win32\UnsafeNativeMethods.cs" />
-    <Win32Sources Include="$(BclSourcesRoot)\Microsoft\Win32\Win32Native.cs" />
-    <Win32Sources Condition="'$(FeatureWin32Registry)' == 'true'" Include="$(BclSourcesRoot)\Microsoft\Win32\Registry.cs" />
-    <Win32Sources Condition="'$(FeatureWin32Registry)' == 'true'" Include="$(BclSourcesRoot)\Microsoft\Win32\RegistryKey.cs" />
-    <Win32Sources Condition="'$(FeatureWin32Registry)' == 'true'" Include="$(BclSourcesRoot)\Microsoft\Win32\RegistryOptions.cs" />
-    <Win32Sources Condition="'$(FeatureWin32Registry)' == 'true'" Include="$(BclSourcesRoot)\Microsoft\Win32\RegistryValueKind.cs" />
-    <Win32Sources Condition="'$(FeatureWin32Registry)' == 'true'" Include="$(BclSourcesRoot)\Microsoft\Win32\RegistryView.cs" />
-    <Win32Sources Condition="'$(FeatureClassicCominterop)' == 'true'" Include="$(BclSourcesRoot)\Microsoft\Win32\OAVariantLib.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <SecurityPrincipalSources Include="$(BclSourcesRoot)\System\Security\Principal\IIdentity.cs" />
-    <SecurityPrincipalSources Include="$(BclSourcesRoot)\System\Security\Principal\IPrincipal.cs" />
-    <SecurityPrincipalSources Include="$(BclSourcesRoot)\System\Security\Principal\TokenImpersonationLevel.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <ResourcesSources Include="$(BclSourcesRoot)\System\Resources\__FastResourceComparer.cs" />
-    <ResourcesSources Include="$(BclSourcesRoot)\System\Resources\__HResults.cs" />
-    <ResourcesSources Include="$(BclSourcesRoot)\System\Resources\FileBasedResourceGroveler.cs" />
-    <ResourcesSources Include="$(BclSourcesRoot)\System\Resources\IResourceGroveler.cs" />
-    <ResourcesSources Include="$(BclSourcesRoot)\System\Resources\IResourceReader.cs" />
-    <ResourcesSources Include="$(BclSourcesRoot)\System\Resources\IResourceWriter.cs" />
-    <ResourcesSources Include="$(BclSourcesRoot)\System\Resources\LooselyLinkedResourceReference.cs" />
-    <ResourcesSources Include="$(BclSourcesRoot)\System\Resources\ManifestBasedResourceGroveler.cs" />
-    <ResourcesSources Include="$(BclSourcesRoot)\System\Resources\MissingManifestResourceException.cs" />
-    <ResourcesSources Include="$(BclSourcesRoot)\System\Resources\MissingSatelliteAssemblyException.cs" />
-    <ResourcesSources Include="$(BclSourcesRoot)\System\Resources\NeutralResourcesLanguageAttribute.cs" />
-    <ResourcesSources Include="$(BclSourcesRoot)\System\Resources\ResourceFallbackManager.cs" />
-    <ResourcesSources Include="$(BclSourcesRoot)\System\Resources\ResourceManager.cs" />
-    <ResourcesSources Include="$(BclSourcesRoot)\System\Resources\ResourceReader.cs" />
-    <ResourcesSources Include="$(BclSourcesRoot)\System\Resources\ResourceSet.cs" />
-    <ResourcesSources Include="$(BclSourcesRoot)\System\Resources\ResourceTypeCode.cs" />
-    <ResourcesSources Include="$(BclSourcesRoot)\System\Resources\RuntimeResourceSet.cs" />
-    <ResourcesSources Include="$(BclSourcesRoot)\System\Resources\SatelliteContractVersionAttribute.cs" />
-    <ResourcesSources Include="$(BclSourcesRoot)\System\Resources\UltimateResourceFallbackLocation.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <PermissionsSources Include="$(BclSourcesRoot)\System\Security\Permissions\EnvironmentPermission.cs" />
-    <PermissionsSources Include="$(BclSourcesRoot)\System\Security\Permissions\FileDialogPermission.cs" />
-    <PermissionsSources Include="$(BclSourcesRoot)\System\Security\Permissions\FileIOPermission.cs" />
-    <PermissionsSources Include="$(BclSourcesRoot)\System\Security\Permissions\HostProtectionPermission.cs" />
-    <PermissionsSources Include="$(BclSourcesRoot)\System\Security\Permissions\IBuiltInPermission.cs" />
-    <PermissionsSources Include="$(BclSourcesRoot)\System\Security\Permissions\IsolatedStoragePermission.cs" />
-    <PermissionsSources Include="$(BclSourcesRoot)\System\Security\Permissions\IsolatedStorageFilePermission.cs" />
-    <PermissionsSources Include="$(BclSourcesRoot)\System\Security\Permissions\PermissionState.cs" />
-    <PermissionsSources Include="$(BclSourcesRoot)\System\Security\Permissions\PermissionAttributes.cs" />
-    <PermissionsSources Include="$(BclSourcesRoot)\System\Security\Permissions\ReflectionPermission.cs" />
-    <PermissionsSources Include="$(BclSourcesRoot)\System\Security\Permissions\SecurityPermission.cs" />
-    <PermissionsSources Include="$(BclSourcesRoot)\System\Security\Permissions\SiteIdentityPermission.cs" />
-    <PermissionsSources Include="$(BclSourcesRoot)\System\Security\Permissions\StrongNameIdentityPermission.cs" />
-    <PermissionsSources Include="$(BclSourcesRoot)\System\Security\Permissions\StrongNamePublicKeyBlob.cs" />
-    <PermissionsSources Include="$(BclSourcesRoot)\System\Security\Permissions\UIPermission.cs" />
-    <PermissionsSources Include="$(BclSourcesRoot)\System\Security\Permissions\URLIdentityPermission.cs" />
-    <PermissionsSources Include="$(BclSourcesRoot)\System\Security\Permissions\ZoneIdentityPermission.cs" />
-    <PermissionsSources Include="$(BclSourcesRoot)\System\Security\Permissions\GACIdentityPermission.cs" />
-    <PermissionsSources Include="$(BclSourcesRoot)\System\Security\Permissions\IUnrestrictedPermission.cs" />
-    <PermissionsSources Include="$(BclSourcesRoot)\System\Security\Permissions\keycontainerpermission.cs" />
-    <PermissionsSources Include="$(BclSourcesRoot)\System\Security\Permissions\RegistryPermission.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <GenericsSources Include="$(BclSourcesRoot)\System\Nullable.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Generic\Comparer.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Generic\Dictionary.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Generic\EqualityComparer.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Generic\DebugView.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Generic\ICollection.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Generic\IComparer.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Generic\IDictionary.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Generic\IEnumerable.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Generic\IEnumerator.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Generic\IEqualityComparer.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Generic\IList.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Generic\IReadOnlyCollection.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Generic\IReadOnlyList.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Generic\IReadOnlyDictionary.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Generic\KeyNotFoundException.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Generic\KeyValuePair.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Generic\List.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Generic\ArraySortHelper.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\ObjectModel\Collection.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\ObjectModel\ReadOnlyCollection.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\ObjectModel\ReadOnlyDictionary.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\ObjectModel\KeyedCollection.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Concurrent\ConcurrentStack.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Concurrent\IProducerConsumerCollection.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Concurrent\ConcurrentDictionary.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Concurrent\ConcurrentQueue.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Concurrent\Partitioner.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Concurrent\OrderablePartitioner.cs" />
-    <GenericsSources Include="$(BclSourcesRoot)\System\Collections\Concurrent\PartitionerStatic.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <SafehandleSources Include="$(BclSourcesRoot)\Microsoft\Win32\SafeHandles\SafeFileMappingHandle.cs" />
-    <SafehandleSources Include="$(BclSourcesRoot)\Microsoft\Win32\SafeHandles\SafeFindHandle.cs" />
-    <SafehandleSources Include="$(BclSourcesRoot)\Microsoft\Win32\SafeHandles\SafeLocalAllocHandle.cs" />
-    <SafehandleSources Include="$(BclSourcesRoot)\Microsoft\Win32\SafeHandles\SafeLibraryHandle.cs" />
-    <SafehandleSources Include="$(BclSourcesRoot)\Microsoft\Win32\SafeHandles\SafeViewOfFileHandle.cs" />
-    <SafehandleSources Include="$(BclSourcesRoot)\Microsoft\Win32\SafeHandles\SafeWaitHandle.cs" />
-    <SafehandleSources Include="$(BclSourcesRoot)\Microsoft\Win32\SafeHandles\Win32SafeHandles.cs" />
-    <SafehandleSources Condition="'$(FeatureWin32Registry)' == 'true'" Include="$(BclSourcesRoot)\Microsoft\Win32\SafeHandles\SafeRegistryHandle.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <NumericsSources Include="$(BclSourcesRoot)\System\Numerics\Hashing\HashHelpers.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <BuffersSources Include="$(CoreFxSourcesRoot)\System\Buffers\ArrayPool.cs" />
-    <BuffersSources Include="$(CoreFxSourcesRoot)\System\Buffers\ArrayPoolEventSource.cs" />
-    <BuffersSources Include="$(CoreFxSourcesRoot)\System\Buffers\ConfigurableArrayPool.cs" />
-    <BuffersSources Include="$(CoreFxSourcesRoot)\System\Buffers\TlsOverPerCoreLockedStacksArrayPool.cs" />
-    <BuffersSources Include="$(CoreFxSourcesRoot)\System\Buffers\Utilities.cs" />
-    <SecuritySources Include="$(CoreFxSourcesRoot)\System\Security\CryptographicException.cs" />
-  </ItemGroup>
-  <ItemGroup Condition="'$(TargetsUnix)' != 'true'">
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\System\HResults.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\Interop.BOOL.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\Interop.Errors.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\Interop.Libraries.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\BCrypt\Interop.BCryptGenRandom.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\BCrypt\Interop.NTSTATUS.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.CancelIoEx.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.CloseHandle.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.CreateFile.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.FileTypes.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.FileOperations.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.FlushFileBuffers.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.FormatMessage.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.GetFileInformationByHandleEx.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.GetFileType_SafeHandle.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.GetFullPathNameW.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.GetLongPathNameW.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.GetTempFileNameW.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.GetTempPathW.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.LockFile.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.ReadFile_SafeHandle_IntPtr.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.ReadFile_SafeHandle_NativeOverlapped.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.SafeCreateFile.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.SECURITY_ATTRIBUTES.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.SecurityOptions.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.SetEndOfFile.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.SetErrorMode.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.SetFileInformationByHandle.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.SetFilePointerEx.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.UnsafeCreateFile.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.WriteFile_SafeHandle_IntPtr.cs" />
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.WriteFile_SafeHandle_NativeOverlapped.cs" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <SecuritySources Include="$(CoreFxSourcesRoot)\System\Security\SecureString.cs" />
-  </ItemGroup>
-
-  <ItemGroup Condition="'$(TargetsUnix)' != 'true'">
-    <SecuritySources Include="$(CoreFxSourcesRoot)\System\Security\SafeBSTRHandle.cs" />
-    <SecuritySources Include="$(CoreFxSourcesRoot)\System\Security\SecureString.Windows.cs" />
-    <!-- Interop sources -->
-    <SecuritySources Include="$(CoreFxSourcesRoot)\Interop\Windows\Crypt32\Interop.CryptProtectMemory.cs" />
-    <SecuritySources Include="$(CoreFxSourcesRoot)\Interop\Windows\NtDll\Interop.ZeroMemory.cs" />
-    <SecuritySources Include="$(CoreFxSourcesRoot)\Interop\Windows\kernel32\Interop.WideCharToMultiByte.cs" />
-    <SecuritySources Include="$(CoreFxSourcesRoot)\Interop\Windows\oleaut32\Interop.SysAllocStringLen.cs" />
-    <SecuritySources Include="$(CoreFxSourcesRoot)\Interop\Windows\oleaut32\Interop.SysStringLen.cs" />
-  </ItemGroup>
-
-  <ItemGroup Condition="'$(TargetsUnix)' == 'true'">
-    <SecuritySources Include="$(CoreFxSourcesRoot)\System\Security\SecureString.Unix.cs" />
-  </ItemGroup>
-
-  <ItemGroup Condition="'$(TargetsUnix)' == 'true'">
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\System\HResults.cs" />
-    <UnixInteropSources Include="$(CoreFxSourcesRoot)\Interop\Unix\Interop.Errors.cs" />
-    <UnixInteropSources Include="$(CoreFxSourcesRoot)\Interop\Unix\Interop.IOErrors.cs" />
-    <UnixInteropSources Include="$(CoreFxSourcesRoot)\Interop\Unix\Interop.Libraries.cs" />
-    <UnixInteropSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.Close.cs" />
-    <UnixInteropSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.GetCwd.cs" />
-    <UnixInteropSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.GetUnixName.cs" />
-    <UnixInteropSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.Fcntl.cs" />
-    <UnixInteropSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.FLock.cs" />
-    <UnixInteropSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.FSync.cs" />
-    <UnixInteropSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.FTruncate.cs" />
-    <UnixInteropSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.LSeek.cs" />
-    <UnixInteropSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.MksTemps.cs" />
-    <UnixInteropSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.Open.cs" />
-    <UnixInteropSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.OpenFlags.cs" />
-    <UnixInteropSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.PathConf.cs" />
-    <UnixInteropSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.Permissions.cs" />
-    <UnixInteropSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.PosixFAdvise.cs" />
-    <UnixInteropSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.Read.cs" />
-    <UnixInteropSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.Stat.cs" />
-    <UnixInteropSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.Unlink.cs" />
-    <UnixInteropSources Include="$(CoreFxSourcesRoot)\Interop\Unix\System.Native\Interop.Write.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <WindowsInteropSources Include="$(CoreFxSourcesRoot)\Debug.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <MscorlibSources Include="@(SystemSources)"/>
-    <MscorlibSources Include="@(ThreadingSources)"/>
-    <MscorlibSources Include="@(DeploymentSources)"/>
-    <MscorlibSources Include="@(CollectionsSources)"/>
-    <MscorlibSources Include="@(ComponentModelSources)"/>
-    <MscorlibSources Include="@(GenericsSources)"/>
-    <MscorlibSources Include="@(DiagnosticsSources)"/>
-    <MscorlibSources Include="@(DiagnosticsCodeanalysisSources)"/>
-    <MscorlibSources Include="@(DiagnosticsSymbolstoreSources)"/>
-    <MscorlibSources Include="@(ReflectionSources)"/>
-    <MscorlibSources Include="@(ExceptionservicesSources)"/>
-    <MscorlibSources Include="@(HostingSources)"/>
-    <MscorlibSources Include="@(SerializationSources)"/>
-    <MscorlibSources Include="@(GlobalizationSources)"/>
-    <MscorlibSources Include="@(TextSources)"/>
-    <MscorlibSources Include="@(ResourcesSources)"/>
-    <MscorlibSources Include="@(Win32Sources)"/>
-    <MscorlibSources Include="@(SafehandleSources)"/>
-    <MscorlibSources Include="@(SecUtilSources)"/>
-    <MscorlibSources Include="@(SecurityPolicySources)"/>
-    <MscorlibSources Include="@(SecurityPrincipalSources)"/>
-    <MscorlibSources Include="@(ReliabilitySources)"/>
-    <MscorlibSources Include="@(InteropSources)"/>
-    <MscorlibSources Include="@(InteropComtypesSources)"/>
-    <MscorlibSources Include="@(InteropComeventsSources)"/>
-    <MscorlibSources Include="@(InteropExpandoSources)"/>
-    <MscorlibSources Include="@(InteropWinRTSources)"/>
-    <MscorlibSources Include="@(WinRTTSources)"/>
-    <MscorlibSources Include="@(WinRTCollectionSources)"/>
-    <MscorlibSources Include="@(IoSources)"/>
-    <MscorlibSources Include="@(FileStreamSources)"/>
-    <MscorlibSources Include="@(CompilerServicesSources)"/>
-    <MscorlibSources Include="@(RuntimeSources)"/>
-    <MscorlibSources Include="@(XmlSources)"/>
-    <MscorlibSources Include="@(PermissionsSources)"/>
-    <MscorlibSources Include="@(SecuritySources)"/>
-    <MscorlibSources Include="@(RemotingSources)"/>
-    <MscorlibSources Include="@(IsostoreSources)"/>
-    <MscorlibSources Include="@(SerializationFormattersSources)"/>
-    <MscorlibSources Include="@(SerializationFormattersBinarySources)"/>
-    <MscorlibSources Include="@(ReflectionEmitSources)"/>
-    <MscorlibSources Include="@(ReflectionMetadataSources)"/>
-    <MscorlibSources Include="@(ConfigurationAssembliesSources)"/>
-    <MscorlibSources Include="@(SecCryptographySources)"/>
-    <MscorlibSources Include="@(SecPublickeySources)"/>
-    <MscorlibSources Include="@(SecurityAclSources)"/>
-    <MscorlibSources Include="@(IdentitySources)"/>
-    <MscorlibSources Include="@(VersioningSources)"/>
-    <MscorlibSources Include="@(DesignerServicesSources)"/>
-    <MscorlibSources Include="@(InternalSources)"/>
-    <MscorlibSources Include="@(NumericsSources)"/>
-    <MscorlibSources Include="$(BclSourcesRoot)\GlobalSuppressions.cs"/>
-    <MscorlibSources Include="@(BuffersSources)"/>
-    <MscorlibSources Include="@(WindowsInteropSources)"/>
-    <MscorlibSources Include="@(UnixInteropSources)"/>
-  </ItemGroup>
-</Project>
diff --git a/src/mscorlib/ref/mscorlib.cs b/src/mscorlib/ref/mscorlib.cs
index 3a8ca2dc65..680bf20675 100644
--- a/src/mscorlib/ref/mscorlib.cs
+++ b/src/mscorlib/ref/mscorlib.cs
@@ -2414,12 +2414,6 @@ namespace System
         public override string ToString() { throw null; }
     }
     [System.Runtime.InteropServices.ComVisibleAttribute(true)]
-    public sealed partial class LocalDataStoreSlot
-    {
-        internal LocalDataStoreSlot() { }
-        ~LocalDataStoreSlot() { }
-    }
-    [System.Runtime.InteropServices.ComVisibleAttribute(true)]
     public abstract partial class MarshalByRefObject
     {
         protected MarshalByRefObject() { }
@@ -6829,43 +6823,6 @@ namespace System.IO
         public virtual void WriteByte(byte value) { }
     }
     [System.Runtime.InteropServices.ComVisibleAttribute(true)]
-    public partial class StreamReader : System.IO.TextReader
-    {
-        public static readonly new System.IO.StreamReader Null;
-        public StreamReader(System.IO.Stream stream) { }
-        public StreamReader(System.IO.Stream stream, bool detectEncodingFromByteOrderMarks) { }
-        public StreamReader(System.IO.Stream stream, System.Text.Encoding encoding) { }
-        public StreamReader(System.IO.Stream stream, System.Text.Encoding encoding, bool detectEncodingFromByteOrderMarks) { }
-        public StreamReader(System.IO.Stream stream, System.Text.Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize) { }
-        public StreamReader(System.IO.Stream stream, System.Text.Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize, bool leaveOpen) { }
-        public StreamReader(string path) { }
-        public StreamReader(string path, bool detectEncodingFromByteOrderMarks) { }
-        public StreamReader(string path, System.Text.Encoding encoding) { }
-        public StreamReader(string path, System.Text.Encoding encoding, bool detectEncodingFromByteOrderMarks) { }
-        [System.Security.SecuritySafeCriticalAttribute]
-        public StreamReader(string path, System.Text.Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize) { }
-        public virtual System.IO.Stream BaseStream { get { throw null; } }
-        public virtual System.Text.Encoding CurrentEncoding { get { throw null; } }
-        public bool EndOfStream { get { throw null; } }
-        public override void Close() { }
-        public void DiscardBufferedData() { }
-        protected override void Dispose(bool disposing) { }
-        public override int Peek() { throw null; }
-        public override int Read() { throw null; }
-        public override int Read(char[] buffer, int index, int count) { buffer = default(char[]); throw null; }
-        [System.Runtime.InteropServices.ComVisibleAttribute(false)]
-        public override System.Threading.Tasks.Task<int> ReadAsync(char[] buffer, int index, int count) { throw null; }
-        public override int ReadBlock(char[] buffer, int index, int count) { buffer = default(char[]); throw null; }
-        [System.Runtime.InteropServices.ComVisibleAttribute(false)]
-        public override System.Threading.Tasks.Task<int> ReadBlockAsync(char[] buffer, int index, int count) { throw null; }
-        public override string ReadLine() { throw null; }
-        [System.Runtime.InteropServices.ComVisibleAttribute(false)]
-        public override System.Threading.Tasks.Task<string> ReadLineAsync() { throw null; }
-        public override string ReadToEnd() { throw null; }
-        [System.Runtime.InteropServices.ComVisibleAttribute(false)]
-        public override System.Threading.Tasks.Task<string> ReadToEndAsync() { throw null; }
-    }
-    [System.Runtime.InteropServices.ComVisibleAttribute(true)]
     public partial class StreamWriter : System.IO.TextWriter
     {
         public static readonly new System.IO.StreamWriter Null;
@@ -6906,26 +6863,6 @@ namespace System.IO
         public override System.Threading.Tasks.Task WriteLineAsync(string value) { throw null; }
     }
     [System.Runtime.InteropServices.ComVisibleAttribute(true)]
-    public partial class StringReader : System.IO.TextReader
-    {
-        public StringReader(string s) { }
-        public override void Close() { }
-        protected override void Dispose(bool disposing) { }
-        public override int Peek() { throw null; }
-        public override int Read() { throw null; }
-        public override int Read(char[] buffer, int index, int count) { buffer = default(char[]); throw null; }
-        [System.Runtime.InteropServices.ComVisibleAttribute(false)]
-        public override System.Threading.Tasks.Task<int> ReadAsync(char[] buffer, int index, int count) { throw null; }
-        [System.Runtime.InteropServices.ComVisibleAttribute(false)]
-        public override System.Threading.Tasks.Task<int> ReadBlockAsync(char[] buffer, int index, int count) { throw null; }
-        public override string ReadLine() { throw null; }
-        [System.Runtime.InteropServices.ComVisibleAttribute(false)]
-        public override System.Threading.Tasks.Task<string> ReadLineAsync() { throw null; }
-        public override string ReadToEnd() { throw null; }
-        [System.Runtime.InteropServices.ComVisibleAttribute(false)]
-        public override System.Threading.Tasks.Task<string> ReadToEndAsync() { throw null; }
-    }
-    [System.Runtime.InteropServices.ComVisibleAttribute(true)]
     public partial class StringWriter : System.IO.TextWriter
     {
         public StringWriter() { }
@@ -6956,31 +6893,6 @@ namespace System.IO
         public override System.Threading.Tasks.Task WriteLineAsync(string value) { throw null; }
     }
     [System.Runtime.InteropServices.ComVisibleAttribute(true)]
-    public abstract partial class TextReader : System.IDisposable
-    {
-        public static readonly System.IO.TextReader Null;
-        protected TextReader() { }
-        public virtual void Close() { }
-        public void Dispose() { }
-        protected virtual void Dispose(bool disposing) { }
-        public virtual int Peek() { throw null; }
-        public virtual int Read() { throw null; }
-        public virtual int Read(char[] buffer, int index, int count) { buffer = default(char[]); throw null; }
-        [System.Runtime.InteropServices.ComVisibleAttribute(false)]
-        public virtual System.Threading.Tasks.Task<int> ReadAsync(char[] buffer, int index, int count) { throw null; }
-        public virtual int ReadBlock(char[] buffer, int index, int count) { buffer = default(char[]); throw null; }
-        [System.Runtime.InteropServices.ComVisibleAttribute(false)]
-        public virtual System.Threading.Tasks.Task<int> ReadBlockAsync(char[] buffer, int index, int count) { throw null; }
-        public virtual string ReadLine() { throw null; }
-        [System.Runtime.InteropServices.ComVisibleAttribute(false)]
-        public virtual System.Threading.Tasks.Task<string> ReadLineAsync() { throw null; }
-        public virtual string ReadToEnd() { throw null; }
-        [System.Diagnostics.DebuggerStepThroughAttribute]
-        [System.Runtime.InteropServices.ComVisibleAttribute(false)]
-        public virtual System.Threading.Tasks.Task<string> ReadToEndAsync() { throw null; }
-        public static System.IO.TextReader Synchronized(System.IO.TextReader reader) { throw null; }
-    }
-    [System.Runtime.InteropServices.ComVisibleAttribute(true)]
     public abstract partial class TextWriter : System.IDisposable
     {
         protected char[] CoreNewLine;
@@ -10345,13 +10257,6 @@ namespace System.Runtime.InteropServices
     {
         public AllowReversePInvokeCallsAttribute() { }
     }
-    [System.AttributeUsageAttribute((System.AttributeTargets)(1029), Inherited=false)]
-    [System.Runtime.InteropServices.ComVisibleAttribute(true)]
-    public sealed partial class AutomationProxyAttribute : System.Attribute
-    {
-        public AutomationProxyAttribute(bool val) { }
-        public bool Value { get { throw null; } }
-    }    
     [System.Runtime.InteropServices.ComVisibleAttribute(true)]
     [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
     public partial struct ArrayWithOffset
@@ -10422,29 +10327,6 @@ namespace System.Runtime.InteropServices
         public CoClassAttribute(System.Type coClass) { }
         public System.Type CoClass { get { throw null; } }
     }
-    [System.AttributeUsageAttribute((System.AttributeTargets)(10624), Inherited=false)]
-    [System.Runtime.InteropServices.ComVisibleAttribute(true)]
-    public sealed partial class ComAliasNameAttribute : System.Attribute
-    {
-        public ComAliasNameAttribute(String val) { }
-        public String Value { get { throw null; } }
-    }
-    [System.AttributeUsageAttribute((System.AttributeTargets)(1), Inherited=false)]
-    [System.Runtime.InteropServices.ComVisibleAttribute(true)]
-    public sealed partial class ComCompatibleVersionAttribute : System.Attribute
-    {
-        public ComCompatibleVersionAttribute(System.Int32 major, System.Int32 minor, System.Int32 build, System.Int32 revision) { }
-        public System.Int32 MajorVersion { get { throw null; } }
-        public System.Int32 MinorVersion { get { throw null; } }
-        public System.Int32 BuildNumber { get { throw null;} }
-        public System.Int32 RevisionNumber { get { throw null; } }
-    }    
-    [System.AttributeUsageAttribute((System.AttributeTargets)(32767), Inherited=false)]
-    [System.Runtime.InteropServices.ComVisibleAttribute(true)]
-    public sealed partial class ComConversionLossAttribute : Attribute
-    {
-        public ComConversionLossAttribute() { }
-    }
     [System.AttributeUsageAttribute((System.AttributeTargets)(4), Inherited=false)]
     [System.Runtime.InteropServices.ComVisibleAttribute(true)]
     public sealed partial class ComDefaultInterfaceAttribute : System.Attribute
@@ -10452,14 +10334,6 @@ namespace System.Runtime.InteropServices
         public ComDefaultInterfaceAttribute(System.Type defaultInterface) { }
         public System.Type Value { get { throw null; } }
     }
-    [System.AttributeUsageAttribute((System.AttributeTargets)(1024), Inherited=false)]
-    [System.Runtime.InteropServices.ComVisibleAttribute(true)]
-    public sealed partial class ComEventInterfaceAttribute : System.Attribute
-    {
-        public ComEventInterfaceAttribute(System.Type SourceInterface, System.Type EventProvider) { }
-        public System.Type EventProvider { get { throw null; } }
-        public System.Type SourceInterface { get { throw null; } }
-    }
     public static partial class ComEventsHelper
     {
         [System.Security.SecurityCriticalAttribute]
@@ -10499,12 +10373,6 @@ namespace System.Runtime.InteropServices
         PropGet = 1,
         PropSet = 2,
     }
-    [System.AttributeUsageAttribute((System.AttributeTargets)(64), Inherited=false)]
-    [System.Runtime.InteropServices.ComVisibleAttribute(true)]
-    public sealed partial class ComRegisterFunctionAttribute : Attribute
-    {
-        public ComRegisterFunctionAttribute() { }
-    }
     [System.AttributeUsageAttribute((System.AttributeTargets)(4), Inherited=true)]
     [System.Runtime.InteropServices.ComVisibleAttribute(true)]
     public sealed partial class ComSourceInterfacesAttribute : System.Attribute
@@ -10516,12 +10384,6 @@ namespace System.Runtime.InteropServices
         public ComSourceInterfacesAttribute(System.Type sourceInterface1, System.Type sourceInterface2, System.Type sourceInterface3, System.Type sourceInterface4) { }
         public string Value { get { throw null; } }
     }
-    [System.AttributeUsageAttribute((System.AttributeTargets)(64), Inherited=false)]
-    [System.Runtime.InteropServices.ComVisibleAttribute(true)]
-    public sealed partial class ComUnregisterFunctionAttribute : Attribute
-    {
-        public ComUnregisterFunctionAttribute() { }
-    }
     [System.AttributeUsageAttribute((System.AttributeTargets)(5597), Inherited=false)]
     [System.Runtime.InteropServices.ComVisibleAttribute(true)]
     public sealed partial class ComVisibleAttribute : System.Attribute
@@ -10722,13 +10584,6 @@ namespace System.Runtime.InteropServices
         [System.Security.SecurityCriticalAttribute]
         System.Runtime.InteropServices.CustomQueryInterfaceResult GetInterface(ref System.Guid iid, out System.IntPtr ppv);
     }
-    [System.AttributeUsageAttribute((System.AttributeTargets)(1), Inherited=false)]
-    [System.Runtime.InteropServices.ComVisibleAttribute(true)]
-    public sealed partial class ImportedFromTypeLibAttribute : System.Attribute
-    {
-        public ImportedFromTypeLibAttribute(String val) { }
-        public String Value { get { throw null; } }
-    }   
     [System.AttributeUsageAttribute((System.AttributeTargets)(2048), Inherited=false)]
     [System.Runtime.InteropServices.ComVisibleAttribute(true)]
     public sealed partial class InAttribute : System.Attribute
@@ -10772,7 +10627,7 @@ namespace System.Runtime.InteropServices
     {
         public LCIDConversionAttribute(System.Int32 val) { }
         public System.Int32 Value { get { throw null; } }
-    }    
+    }
     [System.Security.SecurityCriticalAttribute]
     public static partial class Marshal
     {
@@ -11068,14 +10923,6 @@ namespace System.Runtime.InteropServices
         [System.Security.SecurityCriticalAttribute]
         public static void ZeroFreeGlobalAllocUnicode(System.IntPtr s) { }
     }
-    [System.AttributeUsageAttribute((System.AttributeTargets)(64), Inherited=false)]
-    [System.Runtime.InteropServices.ComVisibleAttribute(true)]
-    public sealed partial class ManagedToNativeComInteropStubAttribute : System.Attribute
-    {
-        public ManagedToNativeComInteropStubAttribute(System.Type classType, System.String methodName) { }
-        public System.Type ClassType { get { throw null; } }
-        public System.String MethodName { get { throw null; } }
-    }    
     [System.AttributeUsageAttribute((System.AttributeTargets)(10496), Inherited=false)]
     [System.Runtime.InteropServices.ComVisibleAttribute(true)]
     public sealed partial class MarshalAsAttribute : System.Attribute
@@ -11128,21 +10975,13 @@ namespace System.Runtime.InteropServices
     {
         public PreserveSigAttribute() { }
     }
-    [System.AttributeUsageAttribute((System.AttributeTargets)(1), Inherited=false, AllowMultiple = true)]
-    [System.Runtime.InteropServices.ComVisibleAttribute(true)]
-    public sealed partial class PrimaryInteropAssemblyAttribute : System.Attribute
-    {
-        public PrimaryInteropAssemblyAttribute(System.Int32 major, System.Int32 minor) { }
-        public System.Int32 MajorVersion { get { throw null; } }
-        public System.Int32 MinorVersion { get { throw null; } }
-    }
     [System.AttributeUsageAttribute((System.AttributeTargets)(4), Inherited=false)]
     [System.Runtime.InteropServices.ComVisibleAttribute(true)]
     public sealed partial class ProgIdAttribute : System.Attribute
     {
         public ProgIdAttribute(String val) { }
         public String Value { get { throw null; } }
-    }  
+    }
     [System.Runtime.InteropServices.ComVisibleAttribute(true)]
     public partial class SafeArrayRankMismatchException : System.SystemException
     {
@@ -11237,21 +11076,6 @@ namespace System.Runtime.InteropServices
         public string Identifier { get { throw null; } }
         public string Scope { get { throw null; } }
     }
-    [System.AttributeUsageAttribute((System.AttributeTargets)(1024), Inherited=false)]
-    [System.Runtime.InteropServices.ComVisibleAttribute(true)]
-    public sealed partial class TypeLibImportClassAttribute : System.Attribute
-    {
-        public TypeLibImportClassAttribute(System.Type val) { }
-        public String Value { get { throw null; } }
-    }
-    [System.AttributeUsageAttribute((System.AttributeTargets)(1), Inherited=false)]
-    [System.Runtime.InteropServices.ComVisibleAttribute(true)]
-    public sealed partial class TypeLibVersionAttribute : System.Attribute
-    {
-        public TypeLibVersionAttribute(System.Int32 major, System.Int32 minor) { }
-        public System.Int32 MajorVersion { get { throw null; } }
-        public System.Int32 MinorVersion { get { throw null; } }
-    }
     [System.Runtime.InteropServices.ComVisibleAttribute(true)]
     public sealed partial class UnknownWrapper
     {
diff --git a/src/mscorlib/src/CleanupToDoList.cs b/src/mscorlib/src/CleanupToDoList.cs
new file mode 100644
index 0000000000..f07d23f8ae
--- /dev/null
+++ b/src/mscorlib/src/CleanupToDoList.cs
@@ -0,0 +1,27 @@
+// 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.
+
+//
+// Stubbed out types to be cleanup from CoreLib
+//
+
+namespace System.Security
+{
+    internal enum SecurityContextSource
+    {
+        CurrentAppDomain = 0,
+        CurrentAssembly
+    }
+}
+
+namespace System.Security.Policy
+{
+    internal sealed class Evidence
+    {
+    }
+
+    internal sealed class ApplicationTrust
+    {
+    }
+}
diff --git a/src/mscorlib/src/Internal/Runtime/Augments/RuntimeThread.cs b/src/mscorlib/src/Internal/Runtime/Augments/RuntimeThread.cs
index 3aafe01a2c..58eff98dec 100644
--- a/src/mscorlib/src/Internal/Runtime/Augments/RuntimeThread.cs
+++ b/src/mscorlib/src/Internal/Runtime/Augments/RuntimeThread.cs
@@ -9,13 +9,14 @@ using System.Runtime.CompilerServices;
 using System.Runtime.ConstrainedExecution;
 using System.Runtime.InteropServices;
 using System.Security;
-using System.Security.Permissions;
 using System.Threading;
 
 namespace Internal.Runtime.Augments
 {
     public class RuntimeThread : CriticalFinalizerObject
     {
+        internal RuntimeThread() {}
+
         public static RuntimeThread Create(ThreadStart start) => new Thread(start);
         public static RuntimeThread Create(ThreadStart start, int maxStackSize) => new Thread(start, maxStackSize);
         public static RuntimeThread Create(ParameterizedThreadStart start) => new Thread(start);
@@ -147,11 +148,9 @@ namespace Internal.Runtime.Augments
 #endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT
 
 #if FEATURE_COMINTEROP
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [MethodImpl(MethodImplOptions.InternalCall)]
         public extern void DisableComObjectEagerCleanup();
 #else // !FEATURE_COMINTEROP
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public void DisableComObjectEagerCleanup()
         {
             Debug.Assert(false); // the Thread class in CoreFX should have handled this case
@@ -163,8 +162,6 @@ namespace Internal.Runtime.Augments
         ** thread is not currently blocked in that manner, it will be interrupted
         ** when it next begins to block.
         =========================================================================*/
-#pragma warning disable 618 // obsolete types: SecurityPermissionAttribute, SecurityAction
-#pragma warning restore 618 // obsolete types: SecurityPermissionAttribute, SecurityAction
         public void Interrupt() => InterruptInternal();
 
         // Internal helper (since we can't place security demands on
diff --git a/src/mscorlib/src/Microsoft/Win32/Registry.cs b/src/mscorlib/src/Microsoft/Win32/Registry.cs
index 3ee5f4648b..bf4f73949a 100644
--- a/src/mscorlib/src/Microsoft/Win32/Registry.cs
+++ b/src/mscorlib/src/Microsoft/Win32/Registry.cs
@@ -15,8 +15,7 @@ namespace Microsoft.Win32 {
      * @security(checkClassLinking=on)
      */
     //This class contains only static members and does not need to be serializable.
-    [ComVisible(true)]
-    public static class Registry {
+    internal static class Registry {
         static Registry()
         { 
         }
@@ -130,24 +129,6 @@ namespace Microsoft.Win32 {
                 key.Close();
             }            
         }
-        
-        public static void SetValue(string keyName, string valueName, object value ) {
-            SetValue(keyName, valueName, value, RegistryValueKind.Unknown);            
-        }
-        
-        public static void SetValue(string keyName, string valueName, object value, RegistryValueKind valueKind ) {
-            string subKeyName; 
-            RegistryKey basekey = GetBaseKeyFromKeyName(keyName, out subKeyName);
-            BCLDebug.Assert(basekey != null, "basekey can't be null!");                
-            RegistryKey key = basekey.CreateSubKey(subKeyName);
-            BCLDebug.Assert(key != null, "An exception should be thrown if failed!");
-            try {
-                key.SetValue(valueName, value, valueKind);            
-            }
-            finally {
-                key.Close();
-            }
-        }                
     }
 }
 
diff --git a/src/mscorlib/src/Microsoft/Win32/RegistryKey.cs b/src/mscorlib/src/Microsoft/Win32/RegistryKey.cs
index ff678f132c..f82b276059 100644
--- a/src/mscorlib/src/Microsoft/Win32/RegistryKey.cs
+++ b/src/mscorlib/src/Microsoft/Win32/RegistryKey.cs
@@ -55,7 +55,6 @@ namespace Microsoft.Win32
     using System.Collections;
     using System.Collections.Generic;
     using System.Security;
-    using System.Security.Permissions;
     using System.Text;
     using System.Threading;
     using System.IO;
@@ -68,21 +67,6 @@ namespace Microsoft.Win32
     using System.Diagnostics.CodeAnalysis;
 
     /**
-     * Registry hive values.  Useful only for GetRemoteBaseKey
-     */
-    [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public enum RegistryHive
-    {
-        ClassesRoot = unchecked((int)0x80000000),
-        CurrentUser = unchecked((int)0x80000001),
-        LocalMachine = unchecked((int)0x80000002),
-        Users = unchecked((int)0x80000003),
-        PerformanceData = unchecked((int)0x80000004),
-        CurrentConfig = unchecked((int)0x80000005),
-    }
-
-    /**
      * Registry encapsulation. To get an instance of a RegistryKey use the
      * Registry class's static members then call OpenSubKey.
      *
@@ -90,8 +74,7 @@ namespace Microsoft.Win32
      * @security(checkDllCalls=off)
      * @security(checkClassLinking=on)
      */
-    [ComVisible(true)]
-    public sealed class RegistryKey : MarshalByRefObject, IDisposable 
+    internal sealed class RegistryKey : MarshalByRefObject, IDisposable 
     {
 
         // We could use const here, if C# supported ELEMENT_TYPE_I fully.
@@ -168,17 +151,6 @@ namespace Microsoft.Win32
          * Creates a RegistryKey.
          *
          * This key is bound to hkey, if writable is <b>false</b> then no write operations
-         * will be allowed.
-         */
-        private RegistryKey(SafeRegistryHandle  hkey, bool writable, RegistryView view)
-            : this(hkey, writable, false, false, false, view) {
-        }
-
-
-        /**
-         * Creates a RegistryKey.
-         *
-         * This key is bound to hkey, if writable is <b>false</b> then no write operations
          * will be allowed. If systemkey is set then the hkey won't be released
          * when the object is GC'ed.
          * The remoteKey flag when set to true indicates that we are dealing with registry entries
@@ -239,262 +211,11 @@ namespace Microsoft.Win32
             }
         }
 
-        public void Flush() {
-            if (hkey != null) {
-                 if (IsDirty()) {
-                     Win32Native.RegFlushKey(hkey);
-                }
-            }
-        }
-
         void IDisposable.Dispose()
         {
             Dispose(true);
         }
 
-        /**
-         * Creates a new subkey, or opens an existing one.
-         *
-         * @param subkey Name or path to subkey to create or open.
-         *
-         * @return the subkey, or <b>null</b> if the operation failed.
-         */
-        [SuppressMessage("Microsoft.Concurrency", "CA8001", Justification = "Reviewed for thread safety")]
-        public RegistryKey CreateSubKey(String subkey) {
-            return CreateSubKey(subkey, checkMode);
-        }
-
-        [ComVisible(false)]
-        public RegistryKey CreateSubKey(String subkey, RegistryKeyPermissionCheck permissionCheck) 
-        {
-            return CreateSubKeyInternal(subkey, permissionCheck, null, RegistryOptions.None);
-        }
-
-        [ComVisible(false)]
-        public RegistryKey CreateSubKey(String subkey, RegistryKeyPermissionCheck permissionCheck, RegistryOptions options) 
-        {
-            return CreateSubKeyInternal(subkey, permissionCheck, null, options);
-        }
-
-        [ComVisible(false)]
-        public RegistryKey CreateSubKey(String subkey, bool writable)
-        {
-            return CreateSubKeyInternal(subkey, writable ? RegistryKeyPermissionCheck.ReadWriteSubTree : RegistryKeyPermissionCheck.ReadSubTree, null, RegistryOptions.None);
-        }
-
-        [ComVisible(false)]
-        public RegistryKey CreateSubKey(String subkey, bool writable, RegistryOptions options)
-        {
-            return CreateSubKeyInternal(subkey, writable ? RegistryKeyPermissionCheck.ReadWriteSubTree : RegistryKeyPermissionCheck.ReadSubTree, null, options);
-        }
-
-        [ComVisible(false)]
-        private unsafe RegistryKey CreateSubKeyInternal(String subkey, RegistryKeyPermissionCheck permissionCheck, object registrySecurityObj, RegistryOptions registryOptions)
-        {
-            ValidateKeyOptions(registryOptions);
-            ValidateKeyName(subkey);
-            ValidateKeyMode(permissionCheck);            
-            EnsureWriteable();
-            subkey = FixupName(subkey); // Fixup multiple slashes to a single slash
-            
-            // only keys opened under read mode is not writable
-            if (!remoteKey) {
-                RegistryKey key = InternalOpenSubKey(subkey, (permissionCheck != RegistryKeyPermissionCheck.ReadSubTree));
-                if (key != null)  { // Key already exits
-                    CheckPermission(RegistryInternalCheck.CheckSubKeyWritePermission, subkey, false, RegistryKeyPermissionCheck.Default);
-                    CheckPermission(RegistryInternalCheck.CheckSubTreePermission, subkey, false, permissionCheck);
-                    key.checkMode = permissionCheck;
-                    return key;
-                }
-            }
-
-            CheckPermission(RegistryInternalCheck.CheckSubKeyCreatePermission, subkey, false, RegistryKeyPermissionCheck.Default);      
-
-            Win32Native.SECURITY_ATTRIBUTES secAttrs = null;
-
-            int disposition = 0;
-
-            // By default, the new key will be writable.
-            SafeRegistryHandle result = null;
-            int ret = Win32Native.RegCreateKeyEx(hkey,
-                subkey,
-                0,
-                null,
-                (int)registryOptions /* specifies if the key is volatile */,
-                GetRegistryKeyAccess(permissionCheck != RegistryKeyPermissionCheck.ReadSubTree) | (int)regView,
-                secAttrs,
-                out result,
-                out disposition);
-
-            if (ret == 0 && !result.IsInvalid) {
-                RegistryKey key = new RegistryKey(result, (permissionCheck != RegistryKeyPermissionCheck.ReadSubTree), false, remoteKey, false, regView);                
-                CheckPermission(RegistryInternalCheck.CheckSubTreePermission, subkey, false, permissionCheck);                
-                key.checkMode = permissionCheck;
-                
-                if (subkey.Length == 0)
-                    key.keyName = keyName;
-                else
-                    key.keyName = keyName + "\\" + subkey;
-                return key;
-            }
-            else if (ret != 0) // syscall failed, ret is an error code.
-                Win32Error(ret, keyName + "\\" + subkey);  // Access denied?
-
-            BCLDebug.Assert(false, "Unexpected code path in RegistryKey::CreateSubKey");
-            return null;
-        }
-
-        /**
-         * Deletes the specified subkey. Will throw an exception if the subkey has
-         * subkeys. To delete a tree of subkeys use, DeleteSubKeyTree.
-         *
-         * @param subkey SubKey to delete.
-         *
-         * @exception InvalidOperationException thrown if the subkey has child subkeys.
-         */
-        public void DeleteSubKey(String subkey) {
-            DeleteSubKey(subkey, true);
-        }
-
-        public void DeleteSubKey(String subkey, bool throwOnMissingSubKey) {
-            ValidateKeyName(subkey);        
-            EnsureWriteable();
-            subkey = FixupName(subkey); // Fixup multiple slashes to a single slash
-            CheckPermission(RegistryInternalCheck.CheckSubKeyWritePermission, subkey, false, RegistryKeyPermissionCheck.Default);
-            
-            // Open the key we are deleting and check for children. Be sure to
-            // explicitly call close to avoid keeping an extra HKEY open.
-            //
-            RegistryKey key = InternalOpenSubKey(subkey,false);
-            if (key != null) {
-                try {
-                    if (key.InternalSubKeyCount() > 0) {
-                        ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_RegRemoveSubKey);
-                    }
-                }
-                finally {
-                    key.Close();
-                }
-
-                int ret;
-
-                try {
-                    ret = Win32Native.RegDeleteKeyEx(hkey, subkey, (int)regView, 0);
-                }
-                catch (EntryPointNotFoundException) {
-                    ret = Win32Native.RegDeleteKey(hkey, subkey);
-                }
-
-                if (ret!=0) {
-                    if (ret == Win32Native.ERROR_FILE_NOT_FOUND) {
-                        if (throwOnMissingSubKey)
-                            ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RegSubKeyAbsent);
-                    }
-                    else
-                        Win32Error(ret, null);
-                }
-            }
-            else { // there is no key which also means there is no subkey
-                if (throwOnMissingSubKey)
-                    ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RegSubKeyAbsent);
-            }
-        }
-
-        /**
-         * Recursively deletes a subkey and any child subkeys.
-         *
-         * @param subkey SubKey to delete.
-         */
-        public void DeleteSubKeyTree(String subkey) {
-            DeleteSubKeyTree(subkey, true /*throwOnMissingSubKey*/);
-        }
-
-        [ComVisible(false)]
-        public void DeleteSubKeyTree(String subkey, Boolean throwOnMissingSubKey) {
-            ValidateKeyName(subkey);
-            
-            // Security concern: Deleting a hive's "" subkey would delete all
-            // of that hive's contents.  Don't allow "".
-            if (subkey.Length==0 && IsSystemKey()) {
-                ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RegKeyDelHive);
-            }
-
-            EnsureWriteable();
-
-            subkey = FixupName(subkey); // Fixup multiple slashes to a single slash
-            CheckPermission(RegistryInternalCheck.CheckSubTreeWritePermission, subkey, false, RegistryKeyPermissionCheck.Default);            
-
-            RegistryKey key = InternalOpenSubKey(subkey, true);
-            if (key != null) {
-                try {
-                    if (key.InternalSubKeyCount() > 0) {
-                        String[] keys = key.InternalGetSubKeyNames();
-
-                        for (int i=0; i<keys.Length; i++) {
-                            key.DeleteSubKeyTreeInternal(keys[i]);
-                        }
-                    }
-                }
-                finally {
-                    key.Close();
-                }
-
-                int ret;
-                try {
-                    ret = Win32Native.RegDeleteKeyEx(hkey, subkey, (int)regView, 0);
-                }
-                catch (EntryPointNotFoundException) {
-                    ret = Win32Native.RegDeleteKey(hkey, subkey);
-                }
-        
-                if (ret!=0) Win32Error(ret, null);
-            }
-            else if(throwOnMissingSubKey) {
-                ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RegSubKeyAbsent);
-            }
-        }
-
-        // An internal version which does no security checks or argument checking.  Skipping the 
-        // security checks should give us a slight perf gain on large trees. 
-        private void DeleteSubKeyTreeInternal(string subkey) {
-            RegistryKey key = InternalOpenSubKey(subkey, true);
-            if (key != null) {
-                try {
-                    if (key.InternalSubKeyCount() > 0) {
-                        String[] keys = key.InternalGetSubKeyNames();
-
-                        for (int i=0; i<keys.Length; i++) {
-                            key.DeleteSubKeyTreeInternal(keys[i]);
-                        }
-                    }
-                }
-                finally {
-                    key.Close();
-                }
-
-                int ret;
-                try {
-                    ret = Win32Native.RegDeleteKeyEx(hkey, subkey, (int)regView, 0);
-                }
-                catch (EntryPointNotFoundException) {
-                    ret = Win32Native.RegDeleteKey(hkey, subkey);
-                }
-                if (ret!=0) Win32Error(ret, null);
-            }
-            else {
-                ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RegSubKeyAbsent);
-            }
-        }
-        
-        /**
-         * Deletes the specified value from this key.
-         *
-         * @param name Name of value to delete.
-         */
-        public void DeleteValue(String name) {
-            DeleteValue(name, true);
-        }
-
         public void DeleteValue(String name, bool throwOnMissingValue) {
             EnsureWriteable();
             CheckPermission(RegistryInternalCheck.CheckValueWritePermission, name, false, RegistryKeyPermissionCheck.Default);            
@@ -552,68 +273,6 @@ namespace Microsoft.Win32
             return key;
         }
 
-
-        [ComVisible(false)]
-        public static RegistryKey OpenBaseKey(RegistryHive hKey, RegistryView view) {
-            ValidateKeyView(view);
-            CheckUnmanagedCodePermission();
-            return GetBaseKey((IntPtr)((int)hKey), view);
-        }
-
-        /**
-         * Retrieves a new RegistryKey that represents the requested key on a foreign
-         * machine.  Valid values for hKey are members of the RegistryHive enum, or
-         * Win32 integers such as:
-         *
-         * HKEY_CLASSES_ROOT,
-         * HKEY_CURRENT_USER,
-         * HKEY_LOCAL_MACHINE,
-         * HKEY_USERS,
-         * HKEY_PERFORMANCE_DATA,
-         * HKEY_CURRENT_CONFIG,
-         * HKEY_DYN_DATA.
-         *
-         * @param hKey HKEY_* to open.
-         * @param machineName the machine to connect to
-         *
-         * @return the RegistryKey requested.
-         */
-        public static RegistryKey OpenRemoteBaseKey(RegistryHive hKey, String machineName) {
-            return OpenRemoteBaseKey(hKey, machineName, RegistryView.Default);
-        }
-
-        [ComVisible(false)]
-        public static RegistryKey OpenRemoteBaseKey(RegistryHive hKey, String machineName, RegistryView view) {
-            if (machineName==null)
-                throw new ArgumentNullException(nameof(machineName));
-            int index = (int)hKey & 0x0FFFFFFF;
-            if (index < 0 || index >= hkeyNames.Length || ((int)hKey & 0xFFFFFFF0) != 0x80000000) {
-                throw new ArgumentException(Environment.GetResourceString("Arg_RegKeyOutOfRange"));
-            }
-            ValidateKeyView(view);
-
-            CheckUnmanagedCodePermission();
-            // connect to the specified remote registry
-            SafeRegistryHandle foreignHKey = null;
-            int ret = Win32Native.RegConnectRegistry(machineName, new SafeRegistryHandle(new IntPtr((int)hKey), false), out foreignHKey);
-
-            if (ret == Win32Native.ERROR_DLL_INIT_FAILED)
-                // return value indicates an error occurred
-                throw new ArgumentException(Environment.GetResourceString("Arg_DllInitFailure"));
-
-            if (ret != 0)
-                Win32ErrorStatic(ret, null);
-
-            if (foreignHKey.IsInvalid)
-                // return value indicates an error occurred
-                throw new ArgumentException(Environment.GetResourceString("Arg_RegKeyNoRemoteConnect", machineName));
-
-            RegistryKey key = new RegistryKey(foreignHKey, true, false, true, ((IntPtr) hKey) == HKEY_PERFORMANCE_DATA, view);
-            key.checkMode = RegistryKeyPermissionCheck.Default;
-            key.keyName = hkeyNames[index];
-            return key;
-        }
-
         /**
          * Retrieves a subkey. If readonly is <b>true</b>, then the subkey is opened with
          * read-only access.
@@ -685,26 +344,6 @@ namespace Microsoft.Win32
             return OpenSubKey(name, false);
         }
 
-        /**
-         * Retrieves the count of subkeys.
-         *
-         * @return a count of subkeys.
-         */
-        public int SubKeyCount {
-            get {
-                CheckPermission(RegistryInternalCheck.CheckKeyReadPermission, null, false, RegistryKeyPermissionCheck.Default);
-                return InternalSubKeyCount();
-            }
-        }
-
-        [ComVisible(false)]
-        public RegistryView View {
-            get {
-                EnsureNotDisposed();
-                return regView;
-            }
-        }
-
         internal int InternalSubKeyCount() {
                 EnsureNotDisposed();
 
@@ -770,18 +409,6 @@ namespace Microsoft.Win32
             return names;
         }
 
-        /**
-         * Retrieves the count of values.
-         *
-         * @return a count of values.
-         */
-        public int ValueCount {
-            get {
-                CheckPermission(RegistryInternalCheck.CheckKeyReadPermission, null, false, RegistryKeyPermissionCheck.Default);
-                return InternalValueCount();
-            }
-        }
-
         internal int InternalValueCount() {
             EnsureNotDisposed();
             int values = 0;
@@ -883,7 +510,6 @@ namespace Microsoft.Win32
             return InternalGetValue(name, defaultValue, false, true);
         }
 
-        [ComVisible(false)]
         public Object GetValue(String name, Object defaultValue, RegistryValueOptions options) {
             if( options < RegistryValueOptions.None || options > RegistryValueOptions.DoNotExpandEnvironmentNames) {
                 throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)options), nameof(options));
@@ -1110,37 +736,6 @@ namespace Microsoft.Win32
             return data;
         }
 
-
-        [ComVisible(false)]
-        public RegistryValueKind GetValueKind(string name) {
-            CheckPermission(RegistryInternalCheck.CheckValueReadPermission, name, false, RegistryKeyPermissionCheck.Default);
-            EnsureNotDisposed();
-
-            int type = 0;
-            int datasize = 0;
-            int ret = Win32Native.RegQueryValueEx(hkey, name, null, ref type, (byte[])null, ref datasize);
-            if (ret != 0)
-                Win32Error(ret, null);
-            if (type == Win32Native.REG_NONE)
-                return RegistryValueKind.None;
-            else if (!Enum.IsDefined(typeof(RegistryValueKind), type))
-                return RegistryValueKind.Unknown;
-            else
-                return (RegistryValueKind) type;
-        }
-
-        /**
-         * Retrieves the current state of the dirty property.
-         *
-         * A key is marked as dirty if any operation has occurred that modifies the
-         * contents of the key.
-         *
-         * @return <b>true</b> if the key has been modified.
-         */
-        private bool IsDirty() {
-            return (this.state & STATE_DIRTY) != 0;
-        }
-
         private bool IsSystemKey() {
             return (this.state & STATE_SYSTEMKEY) != 0;
         }
@@ -1153,13 +748,6 @@ namespace Microsoft.Win32
             return (this.state & STATE_PERF_DATA) != 0;
         }
 
-        public String Name {
-            get { 
-                EnsureNotDisposed();
-                return keyName; 
-            }
-        }
-
         private void SetDirty() {
             this.state |= STATE_DIRTY;
         }
@@ -1174,7 +762,6 @@ namespace Microsoft.Win32
             SetValue(name, value, RegistryValueKind.Unknown);
         }
 
-        [ComVisible(false)]
         public unsafe void SetValue(String name, Object value, RegistryValueKind valueKind) {
             if (value==null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
@@ -1392,19 +979,6 @@ namespace Microsoft.Win32
             }
         }
 
-        internal static void Win32ErrorStatic(int errorCode, String str) {
-            switch (errorCode) {
-                case Win32Native.ERROR_ACCESS_DENIED:
-                    if (str != null)
-                        throw new UnauthorizedAccessException(Environment.GetResourceString("UnauthorizedAccess_RegistryKeyGeneric_Key", str));
-                    else
-                        throw new UnauthorizedAccessException();
-    
-                default:
-                    throw new IOException(Win32Native.GetMessage(errorCode), errorCode);
-            }
-        }
-
         internal static String FixupName(String name)
         {
             BCLDebug.Assert(name!=null,"[FixupName]name!=null");
@@ -1469,301 +1043,9 @@ namespace Microsoft.Win32
 
         }
 
-        //
-        // Read/Write/Create SubKey Permission
-        //
-        private void GetSubKeyReadPermission(string subkeyName, out RegistryPermissionAccess access, out string path) {
-            access = RegistryPermissionAccess.Read;
-            path   = keyName + "\\" + subkeyName + "\\.";
-        }
-        private void GetSubKeyWritePermission(string subkeyName, out RegistryPermissionAccess access, out string path) {
-            // If we want to open a subkey of a read-only key as writeable, we need to do the check.
-            access = RegistryPermissionAccess.Write;
-            path   = keyName + "\\" + subkeyName + "\\.";
-        }
-        private void GetSubKeyCreatePermission(string subkeyName, out RegistryPermissionAccess access, out string path) {
-            access = RegistryPermissionAccess.Create;
-            path   = keyName + "\\" + subkeyName + "\\."; 
-        }
-
-        //
-        // Read/Write/ReadWrite SubTree Permission
-        //
-        private void GetSubTreeReadPermission(string subkeyName, out RegistryPermissionAccess access, out string path) {
-            access = RegistryPermissionAccess.Read;
-            path   = keyName + "\\" + subkeyName + "\\";
-        }
-        private void GetSubTreeWritePermission(string subkeyName, out RegistryPermissionAccess access, out string path) {
-            access = RegistryPermissionAccess.Write;
-            path   = keyName + "\\" + subkeyName + "\\";
-        }
-        private void GetSubTreeReadWritePermission(string subkeyName, out RegistryPermissionAccess access, out string path) {
-            access = RegistryPermissionAccess.Write | RegistryPermissionAccess.Read;
-            path   = keyName + "\\" + subkeyName;
-        }
-
-        //
-        // Read/Write/Create Value Permission
-        //
-        private void GetValueReadPermission(string valueName, out RegistryPermissionAccess access, out string path) {
-            access = RegistryPermissionAccess.Read;
-            path   = keyName+"\\"+valueName;
-        }
-        private void GetValueWritePermission(string valueName, out RegistryPermissionAccess access, out string path) {
-            access = RegistryPermissionAccess.Write;
-            path   = keyName+"\\"+valueName;                      
-        }
-        private void GetValueCreatePermission(string valueName, out RegistryPermissionAccess access, out string path) {
-            access = RegistryPermissionAccess.Create;
-            path   = keyName+"\\"+valueName;
-        }
-
-        // Read Key Permission
-        private void GetKeyReadPermission(out RegistryPermissionAccess access, out string path) {
-           access = RegistryPermissionAccess.Read;
-           path   = keyName + "\\.";
-        }
-
         private void CheckPermission(RegistryInternalCheck check, string item, bool subKeyWritable, RegistryKeyPermissionCheck subKeyCheck)
         {
-            bool demand = false;
-            RegistryPermissionAccess access = RegistryPermissionAccess.NoAccess;
-            string path = null;
-
-            switch (check) {
-                //
-                // Read/Write/Create SubKey Permission
-                //
-                case RegistryInternalCheck.CheckSubKeyReadPermission:
-                    if (remoteKey) {
-                        CheckUnmanagedCodePermission();
-                    }
-                    else {
-                        BCLDebug.Assert(checkMode == RegistryKeyPermissionCheck.Default, "Should be called from a key opened under default mode only!");
-                        BCLDebug.Assert(subKeyWritable == false, "subKeyWritable should be false (unused)");     
-                        BCLDebug.Assert(subKeyCheck == RegistryKeyPermissionCheck.Default, "subKeyCheck should be Default (unused)");
-                        demand = true;
-                        GetSubKeyReadPermission(item, out access, out path);       
-                    }
-                    break;
-                case RegistryInternalCheck.CheckSubKeyWritePermission:
-                    if (remoteKey) {
-                        CheckUnmanagedCodePermission();
-                    }
-                    else {
-                        BCLDebug.Assert(checkMode != RegistryKeyPermissionCheck.ReadSubTree, "We shouldn't allow creating sub key under read-only key!");
-                        BCLDebug.Assert(subKeyWritable == false, "subKeyWritable should be false (unused)");
-                        BCLDebug.Assert(subKeyCheck == RegistryKeyPermissionCheck.Default, "subKeyCheck should be Default (unused)");
-                        if( checkMode == RegistryKeyPermissionCheck.Default) {
-                            demand = true;
-                            GetSubKeyWritePermission(item, out access, out path);                        
-                        }
-                    }
-                    break;
-                case RegistryInternalCheck.CheckSubKeyCreatePermission:
-                    if (remoteKey) {
-                        CheckUnmanagedCodePermission();
-                    }
-                    else {
-                        BCLDebug.Assert(checkMode != RegistryKeyPermissionCheck.ReadSubTree, "We shouldn't allow creating sub key under read-only key!");            
-                        BCLDebug.Assert(subKeyWritable == false, "subKeyWritable should be false (unused)");      
-                        BCLDebug.Assert(subKeyCheck == RegistryKeyPermissionCheck.Default, "subKeyCheck should be Default (unused)");        
-                        if( checkMode == RegistryKeyPermissionCheck.Default) {  
-                            demand = true;
-                            GetSubKeyCreatePermission(item, out access, out path);
-                        }
-                    }
-                    break;
-                //
-                // Read/Write/ReadWrite SubTree Permission
-                //
-                case RegistryInternalCheck.CheckSubTreeReadPermission:
-                    if (remoteKey) {
-                        CheckUnmanagedCodePermission();
-                    }
-                    else {
-                        BCLDebug.Assert(subKeyWritable == false, "subKeyWritable should be false (unused)");  
-                        BCLDebug.Assert(subKeyCheck == RegistryKeyPermissionCheck.Default, "subKeyCheck should be Default (unused)");            
-                        if( checkMode == RegistryKeyPermissionCheck.Default) {
-                            demand = true;
-                            GetSubTreeReadPermission(item, out access, out path);
-                        }
-                    }
-                    break;
-                case RegistryInternalCheck.CheckSubTreeWritePermission:
-                    if (remoteKey) {
-                        CheckUnmanagedCodePermission();
-                    }
-                    else {
-                        BCLDebug.Assert(checkMode != RegistryKeyPermissionCheck.ReadSubTree, "We shouldn't allow writing value to read-only key!");  
-                        BCLDebug.Assert(subKeyWritable == false, "subKeyWritable should be false (unused)"); 
-                        BCLDebug.Assert(subKeyCheck == RegistryKeyPermissionCheck.Default, "subKeyCheck should be Default (unused)");             
-                        if( checkMode == RegistryKeyPermissionCheck.Default) {
-                            demand = true;
-                            GetSubTreeWritePermission(item, out access, out path);
-                        }
-                    }
-                    break;
-                case RegistryInternalCheck.CheckSubTreeReadWritePermission:
-                    if (remoteKey) {
-                        CheckUnmanagedCodePermission();
-                    }
-                    else {
-                        BCLDebug.Assert(subKeyWritable == false, "subKeyWritable should be false (unused)"); 
-                        BCLDebug.Assert(subKeyCheck == RegistryKeyPermissionCheck.Default, "subKeyCheck should be Default (unused)");             
-                        // If we want to open a subkey of a read-only key as writeable, we need to do the check.
-                        demand = true;
-                        GetSubTreeReadWritePermission(item, out access, out path);
-                    }
-                    break;
-                //
-                // Read/Write/Create Value Permission
-                //
-                case RegistryInternalCheck.CheckValueReadPermission:
-                    ///*** no remoteKey check ***///
-                    BCLDebug.Assert(subKeyWritable == false, "subKeyWritable should be false (unused)");  
-                    BCLDebug.Assert(subKeyCheck == RegistryKeyPermissionCheck.Default, "subKeyCheck should be Default (unused)");            
-                    if( checkMode == RegistryKeyPermissionCheck.Default) {
-                        // only need to check for default mode (dynamice check)
-                        demand = true;
-                        GetValueReadPermission(item, out access, out path);
-                    }
-                    break;
-                case RegistryInternalCheck.CheckValueWritePermission:
-                    if (remoteKey) {
-                        CheckUnmanagedCodePermission();
-                    }
-                    else {
-                        BCLDebug.Assert(checkMode != RegistryKeyPermissionCheck.ReadSubTree, "We shouldn't allow writing value to read-only key!");  
-                        BCLDebug.Assert(subKeyWritable == false, "subKeyWritable should be false (unused)"); 
-                        BCLDebug.Assert(subKeyCheck == RegistryKeyPermissionCheck.Default, "subKeyCheck should be Default (unused)");             
-                        // skip the security check if the key is opened under write mode            
-                        if( checkMode == RegistryKeyPermissionCheck.Default) {  
-                            demand = true;
-                            GetValueWritePermission(item, out access, out path);
-                        }
-                    }
-                    break;
-                case RegistryInternalCheck.CheckValueCreatePermission:
-                    if (remoteKey) {
-                        CheckUnmanagedCodePermission();
-                    }
-                    else {
-                        BCLDebug.Assert(checkMode != RegistryKeyPermissionCheck.ReadSubTree, "We shouldn't allow creating value under read-only key!");            
-                        BCLDebug.Assert(subKeyWritable == false, "subKeyWritable should be false (unused)"); 
-                        BCLDebug.Assert(subKeyCheck == RegistryKeyPermissionCheck.Default, "subKeyCheck should be Default (unused)");            
-                        // skip the security check if the key is opened under write mode
-                        if( checkMode == RegistryKeyPermissionCheck.Default) {
-                            demand = true;
-                            GetValueCreatePermission(item, out access, out path);
-                        }
-                    }
-                    break;
-                //
-                // CheckKeyReadPermission
-                //
-                case RegistryInternalCheck.CheckKeyReadPermission:
-                    ///*** no remoteKey check ***///
-                    if( checkMode == RegistryKeyPermissionCheck.Default) {            
-                        BCLDebug.Assert(item == null, "CheckKeyReadPermission should never have a non-null item parameter!");  
-                        BCLDebug.Assert(subKeyWritable == false, "subKeyWritable should be false (unused)"); 
-                        BCLDebug.Assert(subKeyCheck == RegistryKeyPermissionCheck.Default, "subKeyCheck should be Default (unused)");             
-
-                        // only need to check for default mode (dynamice check)   
-                        demand = true;
-                        GetKeyReadPermission(out access, out path);           
-                    }
-                    break;
-                //
-                // CheckSubTreePermission
-                //
-                case RegistryInternalCheck.CheckSubTreePermission:
-                    BCLDebug.Assert(subKeyWritable == false, "subKeyWritable should be false (unused)");   
-                    if( subKeyCheck == RegistryKeyPermissionCheck.ReadSubTree) {
-                        if( checkMode == RegistryKeyPermissionCheck.Default) {
-                            if( remoteKey) {
-                                CheckUnmanagedCodePermission();                
-                            }
-                            else {
-                                demand = true;
-                                GetSubTreeReadPermission(item, out access, out path);
-                            }
-                        }            
-                    }
-                    else if(subKeyCheck == RegistryKeyPermissionCheck.ReadWriteSubTree) {
-                        if( checkMode != RegistryKeyPermissionCheck.ReadWriteSubTree) {
-                            if( remoteKey) {
-                                CheckUnmanagedCodePermission();                
-                            }
-                            else {
-                                demand = true;
-                                GetSubTreeReadWritePermission(item, out access, out path);
-                            }
-                        }                        
-                    }
-                    break;
-
-                //
-                // CheckOpenSubKeyWithWritablePermission uses the 'subKeyWritable' parameter
-                //
-                case RegistryInternalCheck.CheckOpenSubKeyWithWritablePermission:
-                    BCLDebug.Assert(subKeyCheck == RegistryKeyPermissionCheck.Default, "subKeyCheck should be Default (unused)");            
-                    // If the parent key is not opened under default mode, we have access already.
-                    // If the parent key is opened under default mode, we need to check for permission.                        
-                    if(checkMode == RegistryKeyPermissionCheck.Default) { 
-                        if( remoteKey) {
-                            CheckUnmanagedCodePermission(); 
-                        }
-                        else {               
-                            demand = true;
-                            GetSubKeyReadPermission(item, out access, out path);
-                        }
-                        break;
-                    }                        
-                    if( subKeyWritable && (checkMode == RegistryKeyPermissionCheck.ReadSubTree)) {
-                        if( remoteKey) {
-                            CheckUnmanagedCodePermission(); 
-                        }
-                        else { 
-                            demand = true;
-                            GetSubTreeReadWritePermission(item, out access, out path);
-                        }
-                        break;
-                    }
-                    break;
-
-                //
-                // CheckOpenSubKeyPermission uses the 'subKeyCheck' parameter
-                //
-                case RegistryInternalCheck.CheckOpenSubKeyPermission:
-                    BCLDebug.Assert(subKeyWritable == false, "subKeyWritable should be false (unused)"); 
-                    if(subKeyCheck == RegistryKeyPermissionCheck.Default) {                
-                        if( checkMode == RegistryKeyPermissionCheck.Default) {
-                            if(remoteKey) {
-                                CheckUnmanagedCodePermission();
-                            }
-                            else {
-                                demand = true;
-                                GetSubKeyReadPermission(item, out access, out path);
-                            }
-                        }
-                    }  
-                    break;
-
-                default:
-                    BCLDebug.Assert(false, "CheckPermission default switch case should never be hit!");
-                    break;
-            }
-
-            if (demand) {
-                new RegistryPermission(access, path).Demand();
-            }
-        }
-     
-        static private void  CheckUnmanagedCodePermission() {               
-#pragma warning disable 618
-            new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();        
-#pragma warning restore 618
+            // TODO: Cleanup
         }
 
         private bool ContainsRegistryValue(string name) {
@@ -1798,26 +1080,6 @@ namespace Microsoft.Win32
             return winAccess;
         }
 
-        static int GetRegistryKeyAccess(RegistryKeyPermissionCheck mode) {
-            int winAccess = 0;
-            switch(mode) {
-                case RegistryKeyPermissionCheck.ReadSubTree:        
-                case RegistryKeyPermissionCheck.Default:                    
-                    winAccess =  Win32Native.KEY_READ;
-                    break;
-                                        
-                case RegistryKeyPermissionCheck.ReadWriteSubTree:
-                    winAccess = Win32Native.KEY_READ| Win32Native.KEY_WRITE;                    
-                    break;                    
-                    
-               default:
-                    BCLDebug.Assert(false, "unexpected code path");
-                    break;
-            }      
-
-            return winAccess;
-        }
-
         private RegistryKeyPermissionCheck GetSubKeyPermissonCheck(bool subkeyWritable) {
             if( checkMode == RegistryKeyPermissionCheck.Default) {
                 return checkMode;
@@ -1851,18 +1113,6 @@ namespace Microsoft.Win32
                 ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RegKeyStrLenBug);
                 
         }
-        
-        static private void ValidateKeyMode(RegistryKeyPermissionCheck mode) {
-            if( mode < RegistryKeyPermissionCheck.Default || mode > RegistryKeyPermissionCheck.ReadWriteSubTree) {
-                ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidRegistryKeyPermissionCheck, ExceptionArgument.mode);  
-            }            
-        }
-
-        static private void ValidateKeyOptions(RegistryOptions options) {
-            if (options < RegistryOptions.None || options > RegistryOptions.Volatile) {
-                ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidRegistryOptionsCheck, ExceptionArgument.options);
-            }
-        }
 
         static private void ValidateKeyView(RegistryView view) {
             if (view != RegistryView.Default && view != RegistryView.Registry32 && view != RegistryView.Registry64) {
@@ -1877,14 +1127,14 @@ namespace Microsoft.Win32
     }
 
     [Flags]
-    public enum RegistryValueOptions {
+    internal enum RegistryValueOptions {
         None = 0,
         DoNotExpandEnvironmentNames = 1
     }    
 
     // the name for this API is meant to mimic FileMode, which has similar values
 
-    public enum RegistryKeyPermissionCheck {
+    internal enum RegistryKeyPermissionCheck {
         Default = 0,
         ReadSubTree = 1,
         ReadWriteSubTree = 2
diff --git a/src/mscorlib/src/Microsoft/Win32/RegistryOptions.cs b/src/mscorlib/src/Microsoft/Win32/RegistryOptions.cs
deleted file mode 100644
index 4d5e3aaab1..0000000000
--- a/src/mscorlib/src/Microsoft/Win32/RegistryOptions.cs
+++ /dev/null
@@ -1,25 +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.
-
-//
-//
-//
-// Implements Microsoft.Win32.RegistryOptions
-//
-// ======================================================================================
-namespace Microsoft.Win32 {
-    using System;
-    
-    [Flags]
-    public enum RegistryOptions {
-        None                = Win32Native.REG_OPTION_NON_VOLATILE,  // 0x0000
-        Volatile            = Win32Native.REG_OPTION_VOLATILE,      // 0x0001
-///
-/// Consider exposing more options in a future release.  Users can access this
-/// functionality by calling [RegistryKey].Handle and pinvoking
-///
-///     CreateLink          = Win32Native.REG_OPTION_CREATE_LINK,   // 0x0002
-///     BackupRestore       = Win32Native.REG_OPTION_BACKUP_RESTORE,// 0x0004
-    };
-}
diff --git a/src/mscorlib/src/Microsoft/Win32/RegistryValueKind.cs b/src/mscorlib/src/Microsoft/Win32/RegistryValueKind.cs
index c88d5f920a..5e22275332 100644
--- a/src/mscorlib/src/Microsoft/Win32/RegistryValueKind.cs
+++ b/src/mscorlib/src/Microsoft/Win32/RegistryValueKind.cs
@@ -4,8 +4,7 @@
 
 
 namespace Microsoft.Win32 {
-[System.Runtime.InteropServices.ComVisible(true)]
-    public enum RegistryValueKind {
+    internal enum RegistryValueKind {
         String =        Win32Native.REG_SZ,
         ExpandString =  Win32Native.REG_EXPAND_SZ,
         Binary =        Win32Native.REG_BINARY,
@@ -13,7 +12,6 @@ namespace Microsoft.Win32 {
         MultiString =   Win32Native.REG_MULTI_SZ,
         QWord =         Win32Native.REG_QWORD,
         Unknown =       0,                          // REG_NONE is defined as zero but BCL
-        [System.Runtime.InteropServices.ComVisible(false)]
         None =          unchecked((int)0xFFFFFFFF), //  mistakingly overrode this value.  
     }   // Now instead of using Win32Native.REG_NONE we use "-1" and play games internally.
 }
diff --git a/src/mscorlib/src/Microsoft/Win32/RegistryView.cs b/src/mscorlib/src/Microsoft/Win32/RegistryView.cs
index 7fbc2b3391..302a603e0c 100644
--- a/src/mscorlib/src/Microsoft/Win32/RegistryView.cs
+++ b/src/mscorlib/src/Microsoft/Win32/RegistryView.cs
@@ -11,7 +11,7 @@
 namespace Microsoft.Win32 {
     using System;
     
-    public enum RegistryView {
+    internal enum RegistryView {
         Default      = 0,                           // 0x0000 operate on the default registry view
         Registry64   = Win32Native.KEY_WOW64_64KEY, // 0x0100 operate on the 64-bit registry view
         Registry32   = Win32Native.KEY_WOW64_32KEY, // 0x0200 operate on the 32-bit registry view
diff --git a/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeFileMappingHandle.cs b/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeFileMappingHandle.cs
deleted file mode 100644
index cb915fe7c3..0000000000
--- a/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeFileMappingHandle.cs
+++ /dev/null
@@ -1,39 +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.
-
-/*============================================================
-**
-**
-**
-** A wrapper for file handles
-**
-** 
-===========================================================*/
-using System;
-using System.Security;
-using System.Security.Permissions;
-using System.Runtime.InteropServices;
-using System.Runtime.CompilerServices;
-using System.Runtime.ConstrainedExecution;
-using System.Runtime.Versioning;
-
-namespace Microsoft.Win32.SafeHandles
-{
-    internal sealed class SafeFileMappingHandle : SafeHandleZeroOrMinusOneIsInvalid
-    {
-        internal SafeFileMappingHandle() : base(true) {}
-
-        // 0 is an Invalid Handle
-        internal SafeFileMappingHandle(IntPtr handle, bool ownsHandle) : base (ownsHandle)
-        {
-            SetHandle(handle);
-        }
-
-        override protected bool ReleaseHandle()
-        {
-            return Win32Native.CloseHandle(handle);
-        }
-    }
-}
-
diff --git a/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeFindHandle.cs b/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeFindHandle.cs
index 219fb77001..89ea22b855 100644
--- a/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeFindHandle.cs
+++ b/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeFindHandle.cs
@@ -13,7 +13,6 @@
 
 using System;
 using System.Security;
-using System.Security.Permissions;
 using System.Runtime.InteropServices;
 using System.Runtime.CompilerServices;
 using System.Runtime.ConstrainedExecution;
diff --git a/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeLibraryHandle.cs b/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeLibraryHandle.cs
index 23631987a5..603558c51a 100644
--- a/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeLibraryHandle.cs
+++ b/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeLibraryHandle.cs
@@ -4,7 +4,6 @@
 
 namespace Microsoft.Win32 {
     using Microsoft.Win32.SafeHandles;
-    using System.Security.Permissions;
 
     sealed internal class SafeLibraryHandle : SafeHandleZeroOrMinusOneIsInvalid {
         internal SafeLibraryHandle() : base(true) {}
diff --git a/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeLocalAllocHandle.cs b/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeLocalAllocHandle.cs
deleted file mode 100644
index d6c1577eeb..0000000000
--- a/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeLocalAllocHandle.cs
+++ /dev/null
@@ -1,29 +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.
-
-namespace Microsoft.Win32.SafeHandles
-{
-    using System;
-    using System.Runtime.CompilerServices;
-    using System.Runtime.InteropServices;
-    using System.Runtime.ConstrainedExecution;
-
-    internal sealed class SafeLocalAllocHandle : SafeBuffer {
-        private SafeLocalAllocHandle () : base(true) {}
-
-        // 0 is an Invalid Handle
-        internal SafeLocalAllocHandle (IntPtr handle) : base (true) {
-            SetHandle(handle);
-        }
-
-        internal static SafeLocalAllocHandle InvalidHandle {
-            get { return new SafeLocalAllocHandle(IntPtr.Zero); }
-        }
-
-        override protected bool ReleaseHandle()
-        {
-            return Win32Native.LocalFree(handle) == IntPtr.Zero;
-        }
-    }
-}
diff --git a/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeRegistryHandle.cs b/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeRegistryHandle.cs
index 4f96b81e72..a1e5bc4263 100644
--- a/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeRegistryHandle.cs
+++ b/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeRegistryHandle.cs
@@ -11,13 +11,12 @@
 namespace Microsoft.Win32.SafeHandles {
     using System;
     using System.Security;
-    using System.Security.Permissions;
     using System.Runtime.InteropServices;
     using System.Runtime.CompilerServices;
     using System.Runtime.ConstrainedExecution;
     using System.Runtime.Versioning;
 
-    public sealed class SafeRegistryHandle : SafeHandleZeroOrMinusOneIsInvalid {
+    internal sealed class SafeRegistryHandle : SafeHandleZeroOrMinusOneIsInvalid {
         internal SafeRegistryHandle() : base(true) {}
 
         public SafeRegistryHandle(IntPtr preexistingHandle, bool ownsHandle) : base(ownsHandle) {
@@ -30,7 +29,6 @@ namespace Microsoft.Win32.SafeHandles {
 
         [DllImport(Win32Native.ADVAPI32)]
         [SuppressUnmanagedCodeSecurity]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal static extern int RegCloseKey(IntPtr hKey);
     }
 }
diff --git a/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeViewOfFileHandle.cs b/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeViewOfFileHandle.cs
deleted file mode 100644
index 38a9323c0b..0000000000
--- a/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeViewOfFileHandle.cs
+++ /dev/null
@@ -1,46 +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.
-
-/*============================================================
-**
-**
-**
-** A wrapper for file handles
-**
-** 
-===========================================================*/
-using System;
-using System.Security;
-using System.Security.Permissions;
-using System.Runtime.InteropServices;
-using System.Runtime.CompilerServices;
-using System.Runtime.ConstrainedExecution;
-using System.Runtime.Versioning;
-using Microsoft.Win32;
-using Microsoft.Win32.SafeHandles;
-
-namespace Microsoft.Win32.SafeHandles
-{
-    internal sealed class SafeViewOfFileHandle : SafeHandleZeroOrMinusOneIsInvalid
-    {
-        internal SafeViewOfFileHandle() : base(true) {}
-
-        // 0 is an Invalid Handle
-        internal SafeViewOfFileHandle(IntPtr handle, bool ownsHandle) : base (ownsHandle) {
-            SetHandle(handle);
-        }
-
-        override protected bool ReleaseHandle()
-        {
-            if (Win32Native.UnmapViewOfFile(handle))
-            {
-                handle = IntPtr.Zero;
-                return true;
-            }
-            
-            return false;
-        }
-    }
-}
-
diff --git a/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeWaitHandle.cs b/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeWaitHandle.cs
index 0e57136952..0ebcd5c09e 100644
--- a/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeWaitHandle.cs
+++ b/src/mscorlib/src/Microsoft/Win32/SafeHandles/SafeWaitHandle.cs
@@ -14,7 +14,6 @@
 
 using System;
 using System.Security;
-using System.Security.Permissions;
 using System.Runtime.InteropServices;
 using System.Runtime.CompilerServices;
 using System.Runtime.ConstrainedExecution;
@@ -31,7 +30,6 @@ namespace Microsoft.Win32.SafeHandles {
         {
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public SafeWaitHandle(IntPtr existingHandle, bool ownsHandle) : base(ownsHandle)
         {
             SetHandle(existingHandle);
diff --git a/src/mscorlib/src/Microsoft/Win32/SafeHandles/Win32SafeHandles.cs b/src/mscorlib/src/Microsoft/Win32/SafeHandles/Win32SafeHandles.cs
index 08ae0955a8..62418131f3 100644
--- a/src/mscorlib/src/Microsoft/Win32/SafeHandles/Win32SafeHandles.cs
+++ b/src/mscorlib/src/Microsoft/Win32/SafeHandles/Win32SafeHandles.cs
@@ -18,13 +18,11 @@ namespace Microsoft.Win32.SafeHandles
     using System;
     using System.Runtime.InteropServices;
     using System.Runtime.CompilerServices;
-    using System.Security.Permissions;
     using System.Runtime.ConstrainedExecution;
 
     // Class of safe handle which uses 0 or -1 as an invalid handle.
     public abstract class SafeHandleZeroOrMinusOneIsInvalid : SafeHandle
     {
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         protected SafeHandleZeroOrMinusOneIsInvalid(bool ownsHandle) : base(IntPtr.Zero, ownsHandle) 
         {
         }
@@ -43,7 +41,6 @@ namespace Microsoft.Win32.SafeHandles
     // Class of safe handle which uses only -1 as an invalid handle.
     public abstract class SafeHandleMinusOneIsInvalid : SafeHandle
     {
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         protected SafeHandleMinusOneIsInvalid(bool ownsHandle) : base(new IntPtr(-1), ownsHandle) 
         {
         }
@@ -62,7 +59,6 @@ namespace Microsoft.Win32.SafeHandles
     // Class of critical handle which uses 0 or -1 as an invalid handle.
     public abstract class CriticalHandleZeroOrMinusOneIsInvalid : CriticalHandle
     {
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         protected CriticalHandleZeroOrMinusOneIsInvalid() : base(IntPtr.Zero) 
         {
         }
@@ -75,7 +71,6 @@ namespace Microsoft.Win32.SafeHandles
     // Class of critical handle which uses only -1 as an invalid handle.
     public abstract class CriticalHandleMinusOneIsInvalid : CriticalHandle
     {
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         protected CriticalHandleMinusOneIsInvalid() : base(new IntPtr(-1)) 
         {
         }
diff --git a/src/mscorlib/src/Microsoft/Win32/UnsafeNativeMethods.cs b/src/mscorlib/src/Microsoft/Win32/UnsafeNativeMethods.cs
index 19d638d61a..6e37b9c878 100644
--- a/src/mscorlib/src/Microsoft/Win32/UnsafeNativeMethods.cs
+++ b/src/mscorlib/src/Microsoft/Win32/UnsafeNativeMethods.cs
@@ -12,7 +12,6 @@ namespace Microsoft.Win32 {
     using System.Runtime.Serialization;
     using System.Runtime.Versioning;
     using System.Security;
-    using System.Security.Permissions;
     using System.Text;
     using System.Diagnostics.Tracing;
 
@@ -59,7 +58,6 @@ namespace Microsoft.Win32 {
                 
         [DllImport(Win32Native.KERNEL32, CharSet=System.Runtime.InteropServices.CharSet.Unicode)]
         [return: MarshalAs(UnmanagedType.Bool)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal static extern bool FreeLibrary(IntPtr hModule);
 
 
@@ -120,19 +118,6 @@ namespace Microsoft.Win32 {
             [DllImport(Win32Native.ADVAPI32, ExactSpelling = true, EntryPoint = "EventUnregister", CharSet = System.Runtime.InteropServices.CharSet.Unicode)]
             internal static extern uint EventUnregister([In] long registrationHandle);
 
-            //
-            // Writing (Publishing/Logging) APIs
-            //
-            // 
-            [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2118:ReviewSuppressUnmanagedCodeSecurityUsage")]
-            [DllImport(Win32Native.ADVAPI32, ExactSpelling = true, EntryPoint = "EventWrite", CharSet = System.Runtime.InteropServices.CharSet.Unicode)]
-            internal static extern unsafe int EventWrite(
-                    [In] long registrationHandle,
-                    [In] ref EventDescriptor eventDescriptor,
-                    [In] int userDataCount,
-                    [In] EventProvider.EventData* userData
-                    );
-
             [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2118:ReviewSuppressUnmanagedCodeSecurityUsage")]
             [DllImport(Win32Native.ADVAPI32, ExactSpelling = true, EntryPoint = "EventWriteString", CharSet = System.Runtime.InteropServices.CharSet.Unicode)]
             internal static extern unsafe int EventWriteString(
diff --git a/src/mscorlib/src/Microsoft/Win32/Win32Native.cs b/src/mscorlib/src/Microsoft/Win32/Win32Native.cs
index 4b459e3b53..b081b16ca1 100644
--- a/src/mscorlib/src/Microsoft/Win32/Win32Native.cs
+++ b/src/mscorlib/src/Microsoft/Win32/Win32Native.cs
@@ -380,20 +380,6 @@ namespace Microsoft.Win32 {
         }
 
         [StructLayout(LayoutKind.Sequential)]
-            internal struct SYSTEM_INFO {  
-            internal int dwOemId;    // This is a union of a DWORD and a struct containing 2 WORDs.
-            internal int dwPageSize;  
-            internal IntPtr lpMinimumApplicationAddress;  
-            internal IntPtr lpMaximumApplicationAddress;  
-            internal IntPtr dwActiveProcessorMask;  
-            internal int dwNumberOfProcessors;  
-            internal int dwProcessorType;  
-            internal int dwAllocationGranularity;  
-            internal short wProcessorLevel;  
-            internal short wProcessorRevision;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
         internal class SECURITY_ATTRIBUTES {
             internal int nLength = 0;
             // don't remove null, or this field will disappear in bcl.small
@@ -429,206 +415,6 @@ namespace Microsoft.Win32 {
         }
 
         [StructLayout(LayoutKind.Sequential)]
-        internal struct FILE_TIME {
-            public FILE_TIME(long fileTime) {
-                ftTimeLow = (uint) fileTime;
-                ftTimeHigh = (uint) (fileTime >> 32);
-            }
-
-            public long ToTicks() {
-                return ((long) ftTimeHigh << 32) + ftTimeLow;
-            }
-
-            internal uint ftTimeLow;
-            internal uint ftTimeHigh;
-        }
-
-        [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
-        internal struct KERB_S4U_LOGON {
-            internal uint                   MessageType;
-            internal uint                   Flags;
-            internal UNICODE_INTPTR_STRING  ClientUpn;   // REQUIRED: UPN for client
-            internal UNICODE_INTPTR_STRING  ClientRealm; // Optional: Client Realm, if known
-        }
-
-        [StructLayoutAttribute(LayoutKind.Sequential)]
-        internal struct LSA_OBJECT_ATTRIBUTES {
-            internal int Length;
-            internal IntPtr RootDirectory;
-            internal IntPtr ObjectName;
-            internal int Attributes;
-            internal IntPtr SecurityDescriptor;
-            internal IntPtr SecurityQualityOfService;
-        }
-
-        [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
-        internal struct UNICODE_STRING {
-            internal ushort Length;
-            internal ushort MaximumLength;
-            [MarshalAs(UnmanagedType.LPWStr)] internal string Buffer;
-        }
-
-        [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
-        internal struct UNICODE_INTPTR_STRING {
-            /// <remarks>
-            ///     Note - this constructor extracts the raw pointer from the safe handle, so any
-            ///     strings created with this version of the constructor will be unsafe to use after the buffer
-            ///     has been freed.
-            /// </remarks>
-            internal UNICODE_INTPTR_STRING (int stringBytes, SafeLocalAllocHandle buffer) {
-                BCLDebug.Assert(buffer == null || (stringBytes >= 0 && (ulong)stringBytes <= buffer.ByteLength),
-                                "buffer == null || (stringBytes >= 0 && stringBytes <= buffer.ByteLength)");
-
-                this.Length = (ushort) stringBytes;
-                this.MaxLength = (ushort) buffer.ByteLength;
-
-                // Marshaling with a SafePointer does not work correctly, so unfortunately we need to extract
-                // the raw handle here.
-                this.Buffer = buffer.DangerousGetHandle();
-            }
-
-            /// <remarks>
-            ///     This constructor should be used for constructing UNICODE_STRING structures with pointers
-            ///     into a block of memory managed by a SafeHandle or the GC.  It shouldn't be used to own
-            ///     any memory on its own.
-            /// </remarks>
-            internal UNICODE_INTPTR_STRING(int stringBytes, IntPtr buffer) {
-                BCLDebug.Assert((stringBytes == 0 && buffer == IntPtr.Zero) || (stringBytes > 0 && stringBytes <= UInt16.MaxValue && buffer != IntPtr.Zero),
-                                "(stringBytes == 0 && buffer == IntPtr.Zero) || (stringBytes > 0 && stringBytes <= UInt16.MaxValue && buffer != IntPtr.Zero)");
-
-                this.Length = (ushort)stringBytes;
-                this.MaxLength = (ushort)stringBytes;
-                this.Buffer = buffer;
-            }
-
-            internal ushort Length;
-            internal ushort MaxLength;
-            internal IntPtr Buffer;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        internal struct LSA_TRANSLATED_NAME {
-            internal int Use;
-            internal UNICODE_INTPTR_STRING Name;
-            internal int DomainIndex;
-        }
-
-        [StructLayoutAttribute(LayoutKind.Sequential)]
-        internal struct LSA_TRANSLATED_SID {
-            internal int Use;
-            internal uint Rid;
-            internal int DomainIndex;
-        }
-
-        [StructLayoutAttribute(LayoutKind.Sequential)]
-        internal struct LSA_TRANSLATED_SID2 {
-            internal int Use;
-            internal IntPtr Sid;
-            internal int DomainIndex;
-            uint Flags;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        internal struct LSA_TRUST_INFORMATION {
-            internal UNICODE_INTPTR_STRING Name;
-            internal IntPtr Sid;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        internal struct LSA_REFERENCED_DOMAIN_LIST {
-            internal int Entries;
-            internal IntPtr Domains;
-        }
-
-        [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
-        internal struct LUID {
-            internal uint LowPart;
-            internal uint HighPart;
-        }
-
-        [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
-        internal struct LUID_AND_ATTRIBUTES {
-            internal LUID Luid;
-            internal uint Attributes;
-        }
-
-        [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
-        internal struct QUOTA_LIMITS {
-            internal IntPtr PagedPoolLimit;
-            internal IntPtr NonPagedPoolLimit;
-            internal IntPtr MinimumWorkingSetSize;
-            internal IntPtr MaximumWorkingSetSize;
-            internal IntPtr PagefileLimit;
-            internal IntPtr TimeLimit;
-        }
-
-        [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
-        internal struct SECURITY_LOGON_SESSION_DATA {
-            internal uint       Size;
-            internal LUID       LogonId;
-            internal UNICODE_INTPTR_STRING UserName;
-            internal UNICODE_INTPTR_STRING LogonDomain;
-            internal UNICODE_INTPTR_STRING AuthenticationPackage;
-            internal uint       LogonType;
-            internal uint       Session;
-            internal IntPtr     Sid;
-            internal long       LogonTime;
-        }
-
-        [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
-        internal struct SID_AND_ATTRIBUTES {
-            internal IntPtr Sid;
-            internal uint   Attributes;
-            internal static readonly long SizeOf = (long)Marshal.SizeOf(typeof(SID_AND_ATTRIBUTES));
-        }
-
-        [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
-        internal struct TOKEN_GROUPS {
-            internal uint GroupCount;
-            internal SID_AND_ATTRIBUTES Groups; // SID_AND_ATTRIBUTES Groups[ANYSIZE_ARRAY];
-        }
-
-        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
-        internal struct TOKEN_PRIMARY_GROUP
-        {
-            internal IntPtr PrimaryGroup;
-        }
-
-        [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
-        internal struct TOKEN_PRIVILEGE {
-            internal uint                PrivilegeCount;
-            internal LUID_AND_ATTRIBUTES Privilege;
-        }
-
-        [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
-        internal struct TOKEN_SOURCE {
-            private const int TOKEN_SOURCE_LENGTH = 8;
-
-            [MarshalAs(UnmanagedType.ByValArray, SizeConst=TOKEN_SOURCE_LENGTH)]
-            internal char[] Name;
-            internal LUID   SourceIdentifier;
-        }
-
-        [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
-        internal struct TOKEN_STATISTICS {
-            internal LUID   TokenId;
-            internal LUID   AuthenticationId;
-            internal long   ExpirationTime;
-            internal uint   TokenType;
-            internal uint   ImpersonationLevel;
-            internal uint   DynamicCharged;
-            internal uint   DynamicAvailable;
-            internal uint   GroupCount;
-            internal uint   PrivilegeCount;
-            internal LUID   ModifiedId;
-        }
-
-        [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
-        internal struct TOKEN_USER {
-            internal SID_AND_ATTRIBUTES User;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
         internal struct MEMORYSTATUSEX {
             // The length field must be set to the size of this data structure.
             internal int length;
@@ -676,9 +462,6 @@ namespace Microsoft.Win32 {
         // From WinBase.h
         internal const int SEM_FAILCRITICALERRORS = 1;
 
-        [DllImport(KERNEL32, SetLastError=true)]
-        internal static extern void GetSystemInfo(ref SYSTEM_INFO lpSystemInfo);
-
         [DllImport(KERNEL32, CharSet=CharSet.Auto, BestFitMapping=true)]
         internal static extern int FormatMessage(int dwFlags, IntPtr lpSource,
                     int dwMessageId, int dwLanguageId, [Out]StringBuilder lpBuffer,
@@ -701,22 +484,13 @@ namespace Microsoft.Win32 {
         }
 
         [DllImport(KERNEL32, EntryPoint="LocalAlloc")]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         internal static extern IntPtr LocalAlloc_NoSafeHandle(int uFlags, UIntPtr sizetdwBytes);
 
-        [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true)]
-        internal static extern 
-        SafeLocalAllocHandle LocalAlloc(
-            [In] int uFlags, 
-            [In] UIntPtr sizetdwBytes);
-
         [DllImport(KERNEL32, SetLastError=true)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal static extern IntPtr LocalFree(IntPtr handle);
 
         // MSDN says the length is a SIZE_T.
         [DllImport(NTDLL, EntryPoint = "RtlZeroMemory")]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal static extern void ZeroMemory(IntPtr address, UIntPtr length);
 
         internal static bool GlobalMemoryStatusEx(ref MEMORYSTATUSEX buffer)
@@ -735,52 +509,11 @@ namespace Microsoft.Win32 {
         // the MemoryFailPoint implementation (within a CER) to increase the 
         // size of the page file, ignoring any host memory allocators.
         [DllImport(KERNEL32, SetLastError=true)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         unsafe internal static extern void * VirtualAlloc(void* address, UIntPtr numBytes, int commitOrReserve, int pageProtectionMode);
 
         [DllImport(KERNEL32, SetLastError=true)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         unsafe internal static extern bool VirtualFree(void* address, UIntPtr numBytes, int pageFreeMode);
 
-
-         
-        // Note - do NOT use this to call methods.  Use P/Invoke, which will
-        // do much better things w.r.t. marshaling, pinning memory, security 
-        // stuff, better interactions with thread aborts, etc.  This is used
-        // solely by DoesWin32MethodExist for avoiding try/catch EntryPointNotFoundException
-        // in scenarios where an OS Version check is insufficient
-        [DllImport(KERNEL32, CharSet=CharSet.Ansi, BestFitMapping=false, SetLastError=true, ExactSpelling=true)]
-        private static extern IntPtr GetProcAddress(IntPtr hModule, String methodName);
-
-        [DllImport(KERNEL32, CharSet=CharSet.Auto, BestFitMapping=false, SetLastError=true)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
-        private static extern IntPtr GetModuleHandle(String moduleName);
-
-        internal static bool DoesWin32MethodExist(String moduleName, String methodName)
-        {
-            // GetModuleHandle does not increment the module's ref count, so we don't need to call FreeLibrary.
-            IntPtr hModule = Win32Native.GetModuleHandle(moduleName);
-            if (hModule == IntPtr.Zero) {
-                BCLDebug.Assert(hModule != IntPtr.Zero, "GetModuleHandle failed.  Dll isn't loaded?");
-                return false;
-            }
-            IntPtr functionPointer = Win32Native.GetProcAddress(hModule, methodName);
-            return (functionPointer != IntPtr.Zero);       
-        }
-
-        // There is no need to call CloseProcess or to use a SafeHandle if you get the handle
-        // using GetCurrentProcess as it returns a pseudohandle
-        [DllImport(KERNEL32, SetLastError = true, CallingConvention = CallingConvention.Winapi)]
-        [return: MarshalAs(UnmanagedType.Bool)]
-        internal static extern bool IsWow64Process(
-                   [In]
-                   IntPtr hSourceProcessHandle,
-                   [Out, MarshalAs(UnmanagedType.Bool)]
-                   out bool isWow64);
-
-        [DllImport(KERNEL32, CharSet=CharSet.Auto, BestFitMapping=false)]
-        internal static extern uint GetTempPath(int bufferLen, [Out]StringBuilder buffer);
-
         [DllImport(KERNEL32, CharSet=CharSet.Ansi, ExactSpelling=true, EntryPoint="lstrlenA")]
         internal static extern int lstrlenA(IntPtr ptr);
 
@@ -788,29 +521,22 @@ namespace Microsoft.Win32 {
         internal static extern int lstrlenW(IntPtr ptr);
 
         [DllImport(Win32Native.OLEAUT32, CharSet = CharSet.Unicode)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         internal static extern IntPtr SysAllocStringLen(String src, int len);  // BSTR
 
         [DllImport(Win32Native.OLEAUT32)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal static extern uint SysStringLen(IntPtr bstr);
 
         [DllImport(Win32Native.OLEAUT32)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal static extern void SysFreeString(IntPtr bstr);
 
 #if FEATURE_COMINTEROP
         [DllImport(Win32Native.OLEAUT32)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]            
         internal static extern IntPtr SysAllocStringByteLen(byte[] str, uint len);  // BSTR
 
         [DllImport(Win32Native.OLEAUT32)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal static extern uint SysStringByteLen(IntPtr bstr);
-#endif
 
-        [DllImport(KERNEL32)]
-        internal static extern int GetACP();
+#endif
 
         [DllImport(KERNEL32, SetLastError=true)]
         internal static extern bool SetEvent(SafeWaitHandle handle);
@@ -825,134 +551,24 @@ namespace Microsoft.Win32 {
         internal static extern SafeWaitHandle OpenEvent(/* DWORD */ int desiredAccess, bool inheritHandle, String name);
 
         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]            
         internal static extern SafeWaitHandle CreateMutex(SECURITY_ATTRIBUTES lpSecurityAttributes, bool initialOwner, String name);
 
         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
         internal static extern SafeWaitHandle OpenMutex(/* DWORD */ int desiredAccess, bool inheritHandle, String name);
   
         [DllImport(KERNEL32, SetLastError=true)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]            
         internal static extern bool ReleaseMutex(SafeWaitHandle handle);
 
-        [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
-        internal unsafe static extern int GetFullPathName(char* path, int numBufferChars, char* buffer, IntPtr mustBeZero);
-
-        [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
-        internal unsafe static extern int GetFullPathName(String path, int numBufferChars, [Out]StringBuilder buffer, IntPtr mustBeZero);
-
-        [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
-        internal unsafe static extern int GetLongPathName(char* path, char* longPathBuffer, int bufferLength);
-
-        [DllImport(KERNEL32, SetLastError = true, ExactSpelling = true)]
-        internal unsafe static extern uint GetFullPathNameW(char* path, uint numBufferChars, SafeHandle buffer, IntPtr mustBeZero);
-
-        [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
-        internal static extern int GetLongPathName(String path, [Out]StringBuilder longPathBuffer, int bufferLength);
-
-        [DllImport(KERNEL32, SetLastError = true, ExactSpelling = true)]
-        internal static extern uint GetLongPathNameW(SafeHandle lpszShortPath, SafeHandle lpszLongPath, uint cchBuffer);
-
-        [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Unicode, ExactSpelling = true)]
-        internal static extern uint GetLongPathNameW(string lpszShortPath, SafeHandle lpszLongPath, uint cchBuffer);
-
-        [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
-        internal static extern SafeFileMappingHandle CreateFileMapping(SafeFileHandle hFile, IntPtr lpAttributes, uint fProtect, uint dwMaximumSizeHigh, uint dwMaximumSizeLow, String lpName);
-
-        [DllImport(KERNEL32, SetLastError=true, ExactSpelling=true)]
-        internal static extern IntPtr MapViewOfFile(
-            SafeFileMappingHandle handle, uint dwDesiredAccess, uint dwFileOffsetHigh, uint dwFileOffsetLow, UIntPtr dwNumerOfBytesToMap);
-
-        [DllImport(KERNEL32, ExactSpelling=true)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
-        internal static extern bool UnmapViewOfFile(IntPtr lpBaseAddress );
-
         [DllImport(KERNEL32, SetLastError=true)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal static extern bool CloseHandle(IntPtr handle);
 
-        [DllImport(KERNEL32)]
-        internal static extern int GetFileType(SafeFileHandle handle);
-
-        [DllImport(KERNEL32, SetLastError=true)]
-        internal static extern bool SetEndOfFile(SafeFileHandle hFile);
-
-        [DllImport(KERNEL32, SetLastError = true)]
-        [return: MarshalAs(UnmanagedType.Bool)]
-        internal static extern bool FlushFileBuffers(SafeFileHandle hFile);
-
-        [DllImport(KERNEL32, SetLastError=true, EntryPoint="SetFilePointer")]
-        private unsafe static extern int SetFilePointerWin32(SafeFileHandle handle, int lo, int * hi, int origin);
-        
-        internal unsafe static long SetFilePointer(SafeFileHandle handle, long offset, System.IO.SeekOrigin origin, out int hr) {
-            hr = 0;
-            int lo = (int) offset;
-            int hi = (int) (offset >> 32);
-            lo = SetFilePointerWin32(handle, lo, &hi, (int) origin);
-
-            if (lo == -1 && ((hr = Marshal.GetLastWin32Error()) != 0))
-                return -1;
-            return (long) (((ulong) ((uint) hi)) << 32) | ((uint) lo);
-        }
-
-        // Note there are two different ReadFile prototypes - this is to use 
-        // the type system to force you to not trip across a "feature" in 
-        // Win32's async IO support.  You can't do the following three things
-        // simultaneously: overlapped IO, free the memory for the overlapped 
-        // struct in a callback (or an EndRead method called by that callback), 
-        // and pass in an address for the numBytesRead parameter.  
-
-        [DllImport(KERNEL32, SetLastError=true)]
-        unsafe internal static extern int ReadFile(SafeFileHandle handle, byte* bytes, int numBytesToRead, IntPtr numBytesRead_mustBeZero, NativeOverlapped* overlapped);
-
-        [DllImport(KERNEL32, SetLastError=true)]
-        unsafe internal static extern int ReadFile(SafeFileHandle handle, byte* bytes, int numBytesToRead, out int numBytesRead, IntPtr mustBeZero);
-        
-        // Note there are two different WriteFile prototypes - this is to use 
-        // the type system to force you to not trip across a "feature" in 
-        // Win32's async IO support.  You can't do the following three things
-        // simultaneously: overlapped IO, free the memory for the overlapped 
-        // struct in a callback (or an EndWrite method called by that callback),
-        // and pass in an address for the numBytesRead parameter.  
-
-        [DllImport(KERNEL32, SetLastError=true)]
-        internal static unsafe extern int WriteFile(SafeFileHandle handle, byte* bytes, int numBytesToWrite, IntPtr numBytesWritten_mustBeZero, NativeOverlapped* lpOverlapped);
-
         [DllImport(KERNEL32, SetLastError=true)]
         internal static unsafe extern int WriteFile(SafeFileHandle handle, byte* bytes, int numBytesToWrite, out int numBytesWritten, IntPtr mustBeZero);
 
-        // This is only available on Vista or higher
-        [DllImport(KERNEL32, SetLastError=true)]
-        internal static unsafe extern bool CancelIoEx(SafeFileHandle handle, NativeOverlapped* lpOverlapped);
-
-        // NOTE: The out parameters are PULARGE_INTEGERs and may require
-        // some byte munging magic.
-        [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true, BestFitMapping=false)]
-        internal static extern bool GetDiskFreeSpaceEx(String drive, out long freeBytesForUser, out long totalBytes, out long freeBytes);
-
-        [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true, BestFitMapping=false)]
-        internal static extern int GetDriveType(String drive);
-
-        [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true, BestFitMapping=false)]
-        internal static extern bool GetVolumeInformation(String drive, [Out]StringBuilder volumeName, int volumeNameBufLen, out int volSerialNumber, out int maxFileNameLen, out int fileSystemFlags, [Out]StringBuilder fileSystemName, int fileSystemNameBufLen);
-
-        [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true, BestFitMapping=false)]
-        internal static extern bool SetVolumeLabel(String driveLetter, String volumeName);
-
-        // The following 4 methods are used by Microsoft.WlcProfile
-        [DllImport(KERNEL32)]
-        [return: MarshalAs(UnmanagedType.Bool)]
-        internal static extern bool QueryPerformanceCounter(out long value);
-
-        [DllImport(KERNEL32)]
-        [return: MarshalAs(UnmanagedType.Bool)]
-        internal static extern bool QueryPerformanceFrequency(out long value);
-
         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
         internal static extern SafeWaitHandle CreateSemaphore(SECURITY_ATTRIBUTES lpSecurityAttributes, int initialCount, int maximumCount, String name);
 
         [DllImport(KERNEL32, SetLastError = true)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [return: MarshalAs(UnmanagedType.Bool)]
         internal static extern bool ReleaseSemaphore(SafeWaitHandle handle, int releaseCount, out int previousCount);
 
@@ -976,24 +592,8 @@ namespace Microsoft.Win32 {
         }
 
         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true, BestFitMapping=false)]
-        internal static extern int GetWindowsDirectory([Out]StringBuilder sb, int length);
-
-        [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true, BestFitMapping=false)]
         internal static extern int GetSystemDirectory([Out]StringBuilder sb, int length);
 
-        [DllImport(KERNEL32, SetLastError=true)]
-        internal unsafe static extern bool SetFileTime(SafeFileHandle hFile, FILE_TIME* creationTime,
-                    FILE_TIME* lastAccessTime, FILE_TIME* lastWriteTime);
-
-        [DllImport(KERNEL32, SetLastError=true)]
-        internal static extern int GetFileSize(SafeFileHandle hFile, out int highSize);
-
-        [DllImport(KERNEL32, SetLastError=true)]
-        internal static extern bool LockFile(SafeFileHandle handle, int offsetLow, int offsetHigh, int countLow, int countHigh);
-        
-        [DllImport(KERNEL32, SetLastError=true)]
-        internal static extern bool UnlockFile(SafeFileHandle handle, int offsetLow, int offsetHigh, int countLow, int countHigh);
-  
         internal static readonly IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1);  // WinBase.h
 
         // Note, these are #defines used to extract handles, and are NOT handles.
@@ -1142,36 +742,6 @@ namespace Microsoft.Win32 {
         }
 
         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
-        private static extern bool CopyFileEx(String src,
-                                              String dst,
-                                              IntPtr progressRoutine,
-                                              IntPtr progressData,
-                                              ref uint cancel,
-                                              uint flags);
-
-        internal static bool CopyFile(String src, String dst, bool failIfExists)
-        {
-            uint cancel = 0;
-            return CopyFileEx(src, dst, IntPtr.Zero, IntPtr.Zero, ref cancel, failIfExists ? 1U : 0U);
-        }
-
-        [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
-        internal static extern bool CreateDirectory(
-                    String path, SECURITY_ATTRIBUTES lpSecurityAttributes);
-
-        [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
-        internal static extern bool DeleteFile(String path);
-
-        [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
-        internal static extern bool ReplaceFile(String replacedFileName, String replacementFileName, String backupFileName, int dwReplaceFlags, IntPtr lpExclude, IntPtr lpReserved);
-
-        [DllImport(ADVAPI32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
-        internal static extern bool DecryptFile(String path, int reservedMustBeZero);
-
-        [DllImport(ADVAPI32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
-        internal static extern bool EncryptFile(String path);
-
-        [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
         internal static extern SafeFindHandle FindFirstFile(String fileName, [In, Out] Win32Native.WIN32_FIND_DATA data);
 
         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
@@ -1181,14 +751,8 @@ namespace Microsoft.Win32 {
                     WIN32_FIND_DATA lpFindFileData);
 
         [DllImport(KERNEL32)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal static extern bool FindClose(IntPtr handle);
 
-        [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
-        internal static extern int GetCurrentDirectory(
-                  int nBufferLength,
-                  [Out]StringBuilder lpBuffer);
-
         [DllImport(KERNEL32, SetLastError = true, ExactSpelling = true)]
         internal static extern uint GetCurrentDirectoryW(uint nBufferLength, char[] lpBuffer);
 
@@ -1196,37 +760,11 @@ namespace Microsoft.Win32 {
         internal static extern bool GetFileAttributesEx(String name, int fileInfoLevel, ref WIN32_FILE_ATTRIBUTE_DATA lpFileInformation);
 
         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
-        internal static extern bool SetFileAttributes(String name, int attr);
-
-        [DllImport(KERNEL32, SetLastError=true)]
-        internal static extern int GetLogicalDrives();
-
-        [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true, BestFitMapping=false)]
-        internal static extern uint GetTempFileName(String tmpPath, String prefix, uint uniqueIdOrZero, [Out]StringBuilder tmpFileName);
-
-        [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
-        private static extern bool MoveFileEx(String src, String dst, uint flags);
-
-        internal static bool MoveFile(String src, String dst)
-        {
-            return MoveFileEx(src, dst, 2 /* MOVEFILE_COPY_ALLOWED */);
-        }
-
-        [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
-        internal static extern bool DeleteVolumeMountPoint(String mountPoint);
-
-        [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
-        internal static extern bool RemoveDirectory(String path);
-
-        [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
         internal static extern bool SetCurrentDirectory(String path);
 
         [DllImport(KERNEL32, SetLastError=false, EntryPoint="SetErrorMode", ExactSpelling=true)]
         private static extern int SetErrorMode_VistaAndOlder(int newMode);
 
-        [DllImport(KERNEL32, SetLastError=true, EntryPoint="SetThreadErrorMode")]
-        private static extern bool SetErrorMode_Win7AndNewer(int newMode, out int oldMode);
-
         // RTM versions of Win7 and Windows Server 2008 R2
         private static readonly Version ThreadErrorModeMinOsVersion = new Version(6, 1, 7600);
 
@@ -1241,13 +779,6 @@ namespace Microsoft.Win32 {
         [DllImport(KERNEL32)]
         internal static extern unsafe int WideCharToMultiByte(uint cp, uint flags, char* pwzSource, int cchSource, byte* pbDestBuffer, int cbDestBuffer, IntPtr null1, IntPtr null2);
 
-        // A Win32 HandlerRoutine
-        internal delegate bool ConsoleCtrlHandlerRoutine(int controlType);
-
-        [DllImport(KERNEL32, SetLastError=true)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
-        internal static extern bool SetConsoleCtrlHandler(ConsoleCtrlHandlerRoutine handler, bool addOrRemove);
-
         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true, BestFitMapping=false)]
         internal static extern bool SetEnvironmentVariable(string lpName, string lpValue);
         
@@ -1263,9 +794,6 @@ namespace Microsoft.Win32 {
         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true)]
         internal static extern uint GetCurrentProcessId();
 
-        [DllImport(ADVAPI32, CharSet=CharSet.Auto)]
-        internal static extern bool GetUserName([Out]StringBuilder lpBuffer, ref int nSize);
-
         [DllImport(KERNEL32, CharSet=CharSet.Auto, BestFitMapping=false)]
         internal extern static int GetComputerName([Out]StringBuilder nameBuffer, ref int bufferSize);
 
@@ -1282,24 +810,6 @@ namespace Microsoft.Win32 {
         internal static extern IntPtr CoTaskMemRealloc(IntPtr pv, UIntPtr cb);
 
 #if FEATURE_WIN32_REGISTRY
-        [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
-        internal static extern int RegConnectRegistry(String machineName,
-                    SafeRegistryHandle key, out SafeRegistryHandle result);
-    
-        // Note: RegCreateKeyEx won't set the last error on failure - it returns
-        // an error code if it fails.
-        [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
-        internal static extern int RegCreateKeyEx(SafeRegistryHandle hKey, String lpSubKey,
-                    int Reserved, String lpClass, int dwOptions,
-                    int samDesired, SECURITY_ATTRIBUTES lpSecurityAttributes,
-                    out SafeRegistryHandle hkResult, out int lpdwDisposition);
-    
-        [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
-        internal static extern int RegDeleteKey(SafeRegistryHandle hKey, String lpSubKey);
-
-        [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
-        internal static extern int RegDeleteKeyEx(SafeRegistryHandle hKey, String lpSubKey,
-                    int samDesired, int Reserved);
     
         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
         internal static extern int RegDeleteValue(SafeRegistryHandle hKey, String lpValueName);
@@ -1316,17 +826,9 @@ namespace Microsoft.Win32 {
                     IntPtr lpReserved_MustBeZero, int[] lpType, byte[] lpData,
                     int[] lpcbData);
     
-
-        [DllImport(ADVAPI32)]
-        internal static extern int RegFlushKey(SafeRegistryHandle hKey);
-    
         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
         internal static extern int RegOpenKeyEx(SafeRegistryHandle hKey, String lpSubKey,
                     int ulOptions, int samDesired, out SafeRegistryHandle hkResult);
-
-        [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
-        internal static extern int RegOpenKeyEx(IntPtr hKey, String lpSubKey,
-                    int ulOptions, int samDesired, out SafeRegistryHandle hkResult);
     
         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
         internal static extern int RegQueryInfoKey(SafeRegistryHandle hKey, [Out]StringBuilder lpClass,
@@ -1357,11 +859,6 @@ namespace Microsoft.Win32 {
                      ref int lpcbData);
     
         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
-        internal static extern int RegQueryValueEx(SafeRegistryHandle hKey, String lpValueName,
-                    int[] lpReserved, ref int lpType, [Out]StringBuilder lpData,
-                    ref int lpcbData);
-    
-        [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
         internal static extern int RegSetValueEx(SafeRegistryHandle hKey, String lpValueName,
                     int Reserved, RegistryValueKind dwType, byte[] lpData, int cbData);
     
@@ -1440,47 +937,11 @@ namespace Microsoft.Win32 {
         internal const int CSIDL_MYMUSIC                    = 0x000d;
         internal const int CSIDL_MYPICTURES                 = 0x0027;
 
-        [DllImport(SHELL32, CharSet=CharSet.Auto, BestFitMapping=false)]
-        internal static extern int SHGetFolderPath(IntPtr hwndOwner, int nFolder, IntPtr hToken, int dwFlags, [Out]StringBuilder lpszPath);
-
         internal const int NameSamCompatible = 2;
-        
-        [DllImport(SECUR32, CharSet=CharSet.Unicode, SetLastError=true)]     
-        // Win32 return type is BOOLEAN (which is 1 byte and not BOOL which is 4bytes)
-        internal static extern byte GetUserNameEx(int format, [Out]StringBuilder domainName, ref uint domainNameLen);
-        
-        [DllImport(ADVAPI32, CharSet=CharSet.Auto, SetLastError=true, BestFitMapping=false)]
-        internal static extern bool LookupAccountName(string machineName, string accountName, byte[] sid,
-                                 ref int sidLen, [Out]StringBuilder domainName, ref uint domainNameLen, out int peUse);
 
         [DllImport(USER32, SetLastError=true, BestFitMapping=false)]
         internal static extern IntPtr SendMessageTimeout(IntPtr hWnd, int Msg, IntPtr wParam, String lParam, uint fuFlags, uint uTimeout, IntPtr lpdwResult);
 
-        [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true)]
-        internal static extern IntPtr GetCurrentProcess();
-
-        [DllImport(KERNEL32, CharSet=CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurityAttribute()]
-        internal  unsafe static extern int WideCharToMultiByte(
-            int     CodePage,
-            UInt32    dwFlags,
-            char*  lpWideCharStr,
-            int      cchWideChar,
-            byte*    lpMultiByteStr,
-            int      cchMultiByte,
-            char*   lpDefaultChar,
-            bool*   lpUsedDefaultChar);    
-
-        [DllImport(KERNEL32, CharSet=CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurityAttribute()]
-        internal unsafe static extern int MultiByteToWideChar(
-            int     CodePage,
-            UInt32    dwFlags,
-            byte*    lpMultiByteStr,
-            int      cchMultiByte,
-            char*  lpWideCharStr,
-            int      cchWideChar);
-
         [DllImport(KERNEL32, SetLastError = true)]
         [return: MarshalAs(UnmanagedType.Bool)]
         internal extern static bool QueryUnbiasedInterruptTime(out ulong UnbiasedTime);
@@ -1491,25 +952,6 @@ namespace Microsoft.Win32 {
                            [Out, MarshalAs(UnmanagedType.LPArray)] byte[] buffer, int length);
 #else
         private const int BCRYPT_USE_SYSTEM_PREFERRED_RNG = 0x00000002;
-
-        [DllImport("BCrypt.dll", CharSet = CharSet.Unicode)]
-        private static extern uint BCryptGenRandom(IntPtr hAlgorithm, [In, Out] byte[] pbBuffer, int cbBuffer, int dwFlags);
-
-        internal static void Random(bool bStrong, byte[] buffer, int length)
-        {
-            uint status = BCryptGenRandom(IntPtr.Zero, buffer, length, BCRYPT_USE_SYSTEM_PREFERRED_RNG);
-            if (status != STATUS_SUCCESS)
-            {
-                if (status == STATUS_NO_MEMORY)
-                {
-                    throw new OutOfMemoryException();
-                }
-                else
-                {
-                    throw new InvalidOperationException();
-                }
-            }
-        }
 #endif
     }
 }
diff --git a/src/mscorlib/src/System.Private.CoreLib.txt b/src/mscorlib/src/System.Private.CoreLib.txt
index a8b7cbfffe..b4e9e297d9 100644
--- a/src/mscorlib/src/System.Private.CoreLib.txt
+++ b/src/mscorlib/src/System.Private.CoreLib.txt
@@ -330,8 +330,8 @@ Arg_MemberInfoNullModule = The Module object containing the member cannot be nul
 Arg_ParameterInfoNullMember = The MemberInfo object defining the parameter cannot be null.
 Arg_ParameterInfoNullModule = The Module object containing the parameter cannot be null.
 Arg_AssemblyNullModule = The manifest module of the assembly cannot be null.
-Arg_LongerThanSrcArray = Source array was not long enough. Check srcIndex and length, and the array's lower bounds.
-Arg_LongerThanDestArray = Destination array was not long enough. Check destIndex and length, and the array's lower bounds.
+Arg_LongerThanSrcArray = Source array was not long enough. Check the source index, length, and the array's lower bounds.
+Arg_LongerThanDestArray = Destination array was not long enough. Check the destination index, length, and the array's lower bounds.
 Arg_LowerBoundsMustMatch = The arrays' lower bounds must be identical.
 Arg_MustBeBoolean = Object must be of type Boolean.
 Arg_MustBeByte = Object must be of type Byte.
@@ -1052,7 +1052,6 @@ InvalidOperation_CantCancelCtrlBreak = Applications may not prevent control-brea
 InvalidOperation_CalledTwice = The method cannot be called twice on the same instance.
 InvalidOperation_CollectionCorrupted = A prior operation on this collection was interrupted by an exception. Collection's state is no longer trusted.
 InvalidOperation_CriticalTransparentAreMutuallyExclusive = SecurityTransparent and SecurityCritical attributes cannot be applied to the assembly scope at the same time.
-InvalidOperation_SubclassedObject = Cannot set sub-classed {0} object to {1} object.
 InvalidOperation_ExceptionStateCrossAppDomain = Thread.ExceptionState cannot access an ExceptionState from a different AppDomain.
 InvalidOperation_DebuggerLaunchFailed = Debugger unable to launch.
 InvalidOperation_ApartmentStateSwitchFailed = Failed to set the specified COM apartment state.
@@ -1389,6 +1388,8 @@ NotSupported_AssemblyLoadCodeBase = Assembly.Load with a Codebase is not support
 NotSupported_AssemblyLoadFromHash = Assembly.LoadFrom with hashValue is not supported.
 NotSupported_CannotCallEqualsOnSpan = Equals() on Span and ReadOnlySpan is not supported. Use operator== instead.
 NotSupported_CannotCallGetHashCodeOnSpan = GetHashCode() on Span and ReadOnlySpan is not supported.
+NotSupported_ReflectionOnlyLoad = Assembly.ReflectionOnlyLoad is not supported.
+NotSupported_ReflectionOnlyGetType = Type.ReflectionOnlyGetType is not supported.
 
 ; TypeLoadException
 TypeLoad_ResolveType = Could not resolve type '{0}'.
diff --git a/src/mscorlib/src/System/AccessViolationException.cs b/src/mscorlib/src/System/AccessViolationException.cs
index 308d52e9ed..12911c1b17 100644
--- a/src/mscorlib/src/System/AccessViolationException.cs
+++ b/src/mscorlib/src/System/AccessViolationException.cs
@@ -11,41 +11,38 @@
 **
 =============================================================================*/
 
-namespace System 
-{   
-    
-    using System;
-    using System.Runtime.Serialization;
-    [System.Runtime.InteropServices.ComVisible(true)]
+using System;
+using System.Runtime.Serialization;
+
+namespace System
+{
     [Serializable]
-    public class AccessViolationException : SystemException 
+    public class AccessViolationException : SystemException
     {
-        public AccessViolationException() 
-            : base(Environment.GetResourceString("Arg_AccessViolationException")) 
+        public AccessViolationException()
+            : base(SR.Arg_AccessViolationException)
         {
-            SetErrorCode(__HResults.E_POINTER);
+            HResult = __HResults.E_POINTER;
         }
-    
-        public AccessViolationException(String message) 
-            : base(message) 
+
+        public AccessViolationException(String message)
+            : base(message)
         {
-            SetErrorCode(__HResults.E_POINTER);
+            HResult = __HResults.E_POINTER;
         }
-        
-        public AccessViolationException(String message, Exception innerException) 
-            : base(message, innerException) 
+
+        public AccessViolationException(String message, Exception innerException)
+            : base(message, innerException)
         {
-            SetErrorCode(__HResults.E_POINTER);
+            HResult = __HResults.E_POINTER;
         }
 
-        protected AccessViolationException(SerializationInfo info, StreamingContext context) : base(info, context) {}
+        protected AccessViolationException(SerializationInfo info, StreamingContext context) : base(info, context) { }
 
 #pragma warning disable 169  // Field is not used from managed.
         private IntPtr _ip;             // Address of faulting instruction.
         private IntPtr _target;         // Address that could not be accessed.
         private int _accessType;        // 0:read, 1:write
 #pragma warning restore 169
-
     }
-
 }
diff --git a/src/mscorlib/src/System/Action.cs b/src/mscorlib/src/System/Action.cs
index 27f7fafe5c..23c7e93194 100644
--- a/src/mscorlib/src/System/Action.cs
+++ b/src/mscorlib/src/System/Action.cs
@@ -6,8 +6,6 @@ namespace System
 {
     public delegate void Action<in T>(T obj); 
 
-    // Action/Func delegates first shipped with .NET Framework 3.5 in System.Core.dll as part of LINQ
-    // These were type forwarded to mscorlib.dll in .NET Framework 4.0 and in Silverlight 5.0
     public delegate void Action();
     public delegate void Action<in T1,in T2>(T1 arg1, T2 arg2);
     public delegate void Action<in T1,in T2,in T3>(T1 arg1, T2 arg2, T3 arg3);
@@ -32,8 +30,6 @@ namespace System
     public delegate int Comparison<in T>(T x, T y);
 
     public delegate TOutput Converter<in TInput, out TOutput>(TInput input); 
-    
-    public delegate bool Predicate<in T>(T obj); 
 
+    public delegate bool Predicate<in T>(T obj); 
 }
-
diff --git a/src/mscorlib/src/System/Activator.cs b/src/mscorlib/src/System/Activator.cs
index 6fad8f3173..b3dd4a780f 100644
--- a/src/mscorlib/src/System/Activator.cs
+++ b/src/mscorlib/src/System/Activator.cs
@@ -22,16 +22,12 @@ namespace System {
     using StackCrawlMark = System.Threading.StackCrawlMark;
     using System.Runtime.InteropServices;
     using System.Runtime.CompilerServices;
-    using System.Security.Permissions;
     using AssemblyHashAlgorithm = System.Configuration.Assemblies.AssemblyHashAlgorithm;
     using System.Runtime.Versioning;
     using System.Diagnostics.Contracts;
 
     // Only statics, does not need to be marked with the serializable attribute
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_Activator))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class Activator : _Activator
+    public sealed class Activator
     {
         internal const int LookupMask                 = 0x000000FF;
         internal const BindingFlags ConLookup         = (BindingFlags) (BindingFlags.Instance | BindingFlags.Public);
@@ -56,7 +52,7 @@ namespace System {
             return CreateInstance(type, bindingAttr, binder, args, culture, null);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         static public Object CreateInstance(Type type,
                                             BindingFlags bindingAttr,
                                             Binder binder,
@@ -120,7 +116,7 @@ namespace System {
          * types to be created remotely without having to load the type locally.
          */
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         static public ObjectHandle CreateInstance(String assemblyName,
                                                   String typeName)
         {
@@ -137,7 +133,7 @@ namespace System {
                                   ref stackMark);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable                                                  
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod                                                  
         static public ObjectHandle CreateInstance(String assemblyName,
                                                   String typeName,
                                                   Object[] activationAttributes)
@@ -156,7 +152,7 @@ namespace System {
                                   ref stackMark);
         }
             
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         static public Object CreateInstance(Type type, bool nonPublic)
         {
             if ((object)type == null)
@@ -172,7 +168,7 @@ namespace System {
             return rt.CreateInstanceDefaultCtor(!nonPublic, false, true, ref stackMark);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         static public T CreateInstance<T>()
         {
             RuntimeType rt = typeof(T) as RuntimeType;
@@ -209,33 +205,8 @@ namespace System {
                                       null,
                                       activationAttributes);
         }
-                                  
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of CreateInstance which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
-        static public ObjectHandle CreateInstance(String assemblyName, 
-                                                  String typeName, 
-                                                  bool ignoreCase,
-                                                  BindingFlags bindingAttr, 
-                                                  Binder binder,
-                                                  Object[] args,
-                                                  CultureInfo culture,
-                                                  Object[] activationAttributes,
-                                                  Evidence securityInfo)
-        {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return CreateInstance(assemblyName,
-                                  typeName,
-                                  ignoreCase,
-                                  bindingAttr,
-                                  binder,
-                                  args,
-                                  culture,
-                                  activationAttributes,
-                                  securityInfo,
-                                  ref stackMark);
-        }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static ObjectHandle CreateInstance(string assemblyName,
                                                   string typeName,
                                                   bool ignoreCase,
@@ -286,7 +257,7 @@ namespace System {
                     // Classic managed type
                     assembly = RuntimeAssembly.InternalLoadAssemblyName(
                         assemblyName, securityInfo, null, ref stackMark,
-                        true /*thrownOnFileNotFound*/, false /*forIntrospection*/, false /*suppressSecurityChecks*/);
+                        true /*thrownOnFileNotFound*/, false /*forIntrospection*/);
                 }
             }
 
@@ -314,29 +285,6 @@ namespace System {
             }
         }
 
-        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of CreateInstanceFrom which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
-        static public ObjectHandle CreateInstanceFrom(String assemblyFile,
-                                                      String typeName, 
-                                                      bool ignoreCase,
-                                                      BindingFlags bindingAttr, 
-                                                      Binder binder,
-                                                      Object[] args,
-                                                      CultureInfo culture,
-                                                      Object[] activationAttributes,
-                                                      Evidence securityInfo)
-                                               
-        {
-            return CreateInstanceFromInternal(assemblyFile,
-                                              typeName,
-                                              ignoreCase,
-                                              bindingAttr,
-                                              binder,
-                                              args,
-                                              culture,
-                                              activationAttributes,
-                                              securityInfo);
-        }
-
         public static ObjectHandle CreateInstanceFrom(string assemblyFile,
                                                       string typeName,
                                                       bool ignoreCase,
@@ -388,120 +336,6 @@ namespace System {
             }
         }
 
-        //
-        // This API is designed to be used when a host needs to execute code in an AppDomain
-        // with restricted security permissions. In that case, we demand in the client domain
-        // and assert in the server domain because the server domain might not be trusted enough
-        // to pass the security checks when activating the type.
-        //
-
-        public static ObjectHandle CreateInstance (AppDomain domain, string assemblyName, string typeName) {
-            if (domain == null)
-                throw new ArgumentNullException(nameof(domain));
-            Contract.EndContractBlock();
-            return domain.InternalCreateInstanceWithNoSecurity(assemblyName, typeName);
-        }
-
-        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of CreateInstance which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
-        public static ObjectHandle CreateInstance (AppDomain domain,
-                                                   string assemblyName,
-                                                   string typeName,
-                                                   bool ignoreCase,
-                                                   BindingFlags bindingAttr,
-                                                   Binder binder,
-                                                   Object[] args,
-                                                   CultureInfo culture,
-                                                   Object[] activationAttributes,
-                                                   Evidence securityAttributes) {
-            if (domain == null)
-                throw new ArgumentNullException(nameof(domain));
-            Contract.EndContractBlock();
-
-            return domain.InternalCreateInstanceWithNoSecurity(assemblyName, typeName, ignoreCase, bindingAttr, binder, args, culture, activationAttributes, securityAttributes);
-        }
-
-        public static ObjectHandle CreateInstance(AppDomain domain,
-                                                  string assemblyName,
-                                                  string typeName,
-                                                  bool ignoreCase,
-                                                  BindingFlags bindingAttr,
-                                                  Binder binder,
-                                                  object[] args,
-                                                  CultureInfo culture,
-                                                  object[] activationAttributes)
-        {
-            if (domain == null)
-                throw new ArgumentNullException(nameof(domain));
-            Contract.EndContractBlock();
-
-            return domain.InternalCreateInstanceWithNoSecurity(assemblyName,
-                                                               typeName,
-                                                               ignoreCase,
-                                                               bindingAttr,
-                                                               binder,
-                                                               args,
-                                                               culture,
-                                                               activationAttributes,
-                                                               null);
-        }
-
-        //
-        // This API is designed to be used when a host needs to execute code in an AppDomain
-        // with restricted security permissions. In that case, we demand in the client domain
-        // and assert in the server domain because the server domain might not be trusted enough
-        // to pass the security checks when activating the type.
-        //
-
-        public static ObjectHandle CreateInstanceFrom (AppDomain domain, string assemblyFile, string typeName) {
-            if (domain == null)
-                throw new ArgumentNullException(nameof(domain));
-            Contract.EndContractBlock();
-            return domain.InternalCreateInstanceFromWithNoSecurity(assemblyFile, typeName);
-        }
-
-        [Obsolete("Methods which use Evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of CreateInstanceFrom which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
-        public static ObjectHandle CreateInstanceFrom (AppDomain domain,
-                                                       string assemblyFile,
-                                                       string typeName,
-                                                       bool ignoreCase,
-                                                       BindingFlags bindingAttr,
-                                                       Binder binder,
-                                                       Object[] args,
-                                                       CultureInfo culture,
-                                                       Object[] activationAttributes,
-                                                       Evidence securityAttributes) {
-            if (domain == null)
-                throw new ArgumentNullException(nameof(domain));
-            Contract.EndContractBlock();
-
-            return domain.InternalCreateInstanceFromWithNoSecurity(assemblyFile, typeName, ignoreCase, bindingAttr, binder, args, culture, activationAttributes, securityAttributes);
-        }
-
-        public static ObjectHandle CreateInstanceFrom(AppDomain domain,
-                                                      string assemblyFile,
-                                                      string typeName,
-                                                      bool ignoreCase,
-                                                      BindingFlags bindingAttr,
-                                                      Binder binder,
-                                                      object[] args,
-                                                      CultureInfo culture,
-                                                      object[] activationAttributes)
-        {
-            if (domain == null)
-                throw new ArgumentNullException(nameof(domain));
-            Contract.EndContractBlock();
-
-            return domain.InternalCreateInstanceFromWithNoSecurity(assemblyFile,
-                                                                   typeName,
-                                                                   ignoreCase,
-                                                                   bindingAttr,
-                                                                   binder,
-                                                                   args,
-                                                                   culture,
-                                                                   activationAttributes,
-                                                                   null);
-        }
-
         public static ObjectHandle CreateComInstanceFrom(String assemblyName,
                                                          String typeName)
         {
@@ -553,28 +387,6 @@ namespace System {
         private static void Log(bool test, string title, string success, string failure)
         {
         }
-
-        void _Activator.GetTypeInfoCount(out uint pcTInfo)
-        {
-            throw new NotImplementedException();
-        }
-
-        void _Activator.GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo)
-        {
-            throw new NotImplementedException();
-        }
-
-        void _Activator.GetIDsOfNames([In] ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
-        {
-            throw new NotImplementedException();
-        }
-
-        // If you implement this method, make sure to include _Activator.Invoke in VM\DangerousAPIs.h and
-        // include _Activator in SystemDomain::IsReflectionInvocationMethod in AppDomain.cpp.
-        void _Activator.Invoke(uint dispIdMember, [In] ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
-        {
-            throw new NotImplementedException();
-        }
     }
 }
 
diff --git a/src/mscorlib/src/System/AppContext/AppContext.cs b/src/mscorlib/src/System/AppContext/AppContext.cs
index e318f93b89..5a3b732fa8 100644
--- a/src/mscorlib/src/System/AppContext/AppContext.cs
+++ b/src/mscorlib/src/System/AppContext/AppContext.cs
@@ -84,7 +84,7 @@ namespace System
         }  
 
         public static event System.EventHandler ProcessExit;
-        public static event System.EventHandler Unloading;
+        internal static event System.EventHandler Unloading;
 
         private static void OnProcessExit(object sender, EventArgs e)
         {
diff --git a/src/mscorlib/src/System/AppDomain.cs b/src/mscorlib/src/System/AppDomain.cs
index 84104563c5..8e66871a12 100644
--- a/src/mscorlib/src/System/AppDomain.cs
+++ b/src/mscorlib/src/System/AppDomain.cs
@@ -20,9 +20,7 @@ namespace System
     using System.Runtime;
     using System.Runtime.CompilerServices;
     using System.Security;
-    using System.Security.Permissions;
     using System.Security.Policy;
-    using System.Security.Util;
     using System.Collections;
     using System.Collections.Generic;
     using System.Threading;
@@ -39,7 +37,6 @@ namespace System
     using System.Diagnostics.Contracts;
     using System.Runtime.ExceptionServices;
 
-    [ComVisible(true)]
     public class ResolveEventArgs : EventArgs
     {
         private String _Name;
@@ -71,7 +68,6 @@ namespace System
         }
     }
 
-    [ComVisible(true)]
     public class AssemblyLoadEventArgs : EventArgs
     {
         private Assembly _LoadedAssembly;
@@ -89,16 +85,13 @@ namespace System
     }
 
     [Serializable]
-    [ComVisible(true)]
     public delegate Assembly ResolveEventHandler(Object sender, ResolveEventArgs args);
 
     [Serializable]
-    [ComVisible(true)]
     public delegate void AssemblyLoadEventHandler(Object sender, AssemblyLoadEventArgs args);
 
     [Serializable]
-    [ComVisible(true)]
-    public delegate void AppDomainInitializer(string[] args);
+    internal delegate void AppDomainInitializer(string[] args);
 
     internal class AppDomainInitializerInfo
     {
@@ -159,7 +152,6 @@ namespace System
             if (Info==null)
                 return null;
             AppDomainInitializer retVal=null;
-            new ReflectionPermission(ReflectionPermissionFlag.MemberAccess).Assert();
             for (int i=0;i<Info.Length;i++)
             {
                 Assembly assembly=Assembly.Load(Info[i].TargetTypeAssembly);
@@ -175,12 +167,7 @@ namespace System
         }
     }
 
-
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(System._AppDomain))]
-    [ComVisible(true)]
-    public sealed class AppDomain :
-        _AppDomain, IEvidenceFactory
+    internal sealed class AppDomain
     {
         // Domain security information
         // These fields initialized from the other side only. (NOTE: order 
@@ -188,13 +175,12 @@ namespace System
         // the EE- AppDomainBaseObject in this case)
 
         private AppDomainManager _domainManager;
-        private Dictionary<String, Object[]> _LocalStore;
+        private Dictionary<String, Object> _LocalStore;
         private AppDomainSetup   _FusionStore;
         private Evidence         _SecurityIdentity;
 #pragma warning disable 169
         private Object[]         _Policies; // Called from the VM.
 #pragma warning restore 169
-        [method: System.Security.SecurityCritical]
         public event AssemblyLoadEventHandler AssemblyLoad;
 
         private ResolveEventHandler _TypeResolve;
@@ -261,7 +247,6 @@ namespace System
         }
 
 #if FEATURE_REFLECTION_ONLY_LOAD
-        [method: System.Security.SecurityCritical]
         public event ResolveEventHandler ReflectionOnlyAssemblyResolve;
 #endif // FEATURE_REFLECTION_ONLY
 
@@ -428,9 +413,7 @@ namespace System
             {
                 try
                 {
-                    new PermissionSet(PermissionState.Unrestricted).Assert();
                     _domainManager = CreateInstanceAndUnwrap(domainManagerAssembly, domainManagerType) as AppDomainManager;
-                    CodeAccessPermission.RevertAssert();
                 }
                 catch (FileNotFoundException e)
                 {
@@ -737,121 +720,6 @@ namespace System
                                             typeName);
         }
 
-        internal ObjectHandle InternalCreateInstanceWithNoSecurity (string assemblyName, string typeName) {
-            PermissionSet.s_fullTrust.Assert();
-            return CreateInstance(assemblyName, typeName);
-        }
-
-        public ObjectHandle CreateInstanceFrom(String assemblyFile,
-                                               String typeName)
-                                         
-        {
-            // jit does not check for that, so we should do it ...
-            if (this == null)
-                throw new NullReferenceException();
-            Contract.EndContractBlock();
-
-            return Activator.CreateInstanceFrom(assemblyFile,
-                                                typeName);
-        }
-
-        internal ObjectHandle InternalCreateInstanceFromWithNoSecurity (string assemblyName, string typeName) {
-            PermissionSet.s_fullTrust.Assert();
-            return CreateInstanceFrom(assemblyName, typeName);
-        }
-
-        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of CreateInstance which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
-        public ObjectHandle CreateInstance(String assemblyName, 
-                                           String typeName, 
-                                           bool ignoreCase,
-                                           BindingFlags bindingAttr, 
-                                           Binder binder,
-                                           Object[] args,
-                                           CultureInfo culture,
-                                           Object[] activationAttributes,
-                                           Evidence securityAttributes)
-        {
-            // jit does not check for that, so we should do it ...
-            if (this == null)
-                throw new NullReferenceException();
-            
-            if (assemblyName == null)
-                throw new ArgumentNullException(nameof(assemblyName));
-            Contract.EndContractBlock();
-
-#pragma warning disable 618
-            return Activator.CreateInstance(assemblyName,
-                                            typeName,
-                                            ignoreCase,
-                                            bindingAttr,
-                                            binder,
-                                            args,
-                                            culture,
-                                            activationAttributes,
-                                            securityAttributes);
-#pragma warning restore 618
-        }
-
-        internal ObjectHandle InternalCreateInstanceWithNoSecurity (string assemblyName, 
-                                                                    string typeName,
-                                                                    bool ignoreCase,
-                                                                    BindingFlags bindingAttr,
-                                                                    Binder binder,
-                                                                    Object[] args,
-                                                                    CultureInfo culture,
-                                                                    Object[] activationAttributes,
-                                                                    Evidence securityAttributes)
-        {
-            PermissionSet.s_fullTrust.Assert();
-#pragma warning disable 618
-            return CreateInstance(assemblyName, typeName, ignoreCase, bindingAttr, binder, args, culture, activationAttributes, securityAttributes);
-#pragma warning restore 618
-        }
-
-        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of CreateInstanceFrom which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
-        public ObjectHandle CreateInstanceFrom(String assemblyFile,
-                                               String typeName, 
-                                               bool ignoreCase,
-                                               BindingFlags bindingAttr, 
-                                               Binder binder,
-                                               Object[] args,
-                                               CultureInfo culture,
-                                               Object[] activationAttributes,
-                                               Evidence securityAttributes)
-
-        {
-            // jit does not check for that, so we should do it ...
-            if (this == null)
-                throw new NullReferenceException();
-            Contract.EndContractBlock();
-
-            return Activator.CreateInstanceFrom(assemblyFile,
-                                                typeName,
-                                                ignoreCase,
-                                                bindingAttr,
-                                                binder,
-                                                args,
-                                                culture,
-                                                activationAttributes,
-                                                securityAttributes);
-        }
-
-        internal ObjectHandle InternalCreateInstanceFromWithNoSecurity (string assemblyName, 
-                                                                        string typeName,
-                                                                        bool ignoreCase,
-                                                                        BindingFlags bindingAttr,
-                                                                        Binder binder,
-                                                                        Object[] args,
-                                                                        CultureInfo culture,
-                                                                        Object[] activationAttributes,
-                                                                        Evidence securityAttributes)
-        {
-            PermissionSet.s_fullTrust.Assert();
-#pragma warning disable 618
-            return CreateInstanceFrom(assemblyName, typeName, ignoreCase, bindingAttr, binder, args, culture, activationAttributes, securityAttributes);
-#pragma warning restore 618
-        }
-
         public static AppDomain CurrentDomain
         {
             get {
@@ -905,27 +773,22 @@ namespace System
         internal static extern void PublishAnonymouslyHostedDynamicMethodsAssembly(RuntimeAssembly assemblyHandle);
 
         public void SetData (string name, object data) {
-            SetDataHelper(name, data, null);
-        }
-
-        private void SetDataHelper (string name, object data, IPermission permission)
-        {
             if (name == null)
                 throw new ArgumentNullException(nameof(name));
             Contract.EndContractBlock();
 
             // SetData should only be used to set values that don't already exist.
-            object[] currentVal;
+            object currentVal;
             lock (((ICollection)LocalStore).SyncRoot) {
                 LocalStore.TryGetValue(name, out currentVal);
             }
-            if (currentVal != null && currentVal[0] != null)
+            if (currentVal != null)
             {
                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_SetData_OnlyOnce"));
             }
 
             lock (((ICollection)LocalStore).SyncRoot) {
-                LocalStore[name] = new object[] {data, permission};
+                LocalStore[name] = data;
             }
         }
 
@@ -943,17 +806,13 @@ namespace System
                     return FusionStore.LoaderOptimization;
                 else 
                 {
-                    object[] data;
+                    object data;
                     lock (((ICollection)LocalStore).SyncRoot) {
                         LocalStore.TryGetValue(name, out data);
                     }
                     if (data == null)
                         return null;
-                    if (data[1] != null) {
-                        IPermission permission = (IPermission) data[1];
-                        permission.Demand();
-                    }
-                    return data[0];
+                    return data;
                 }
             }
            else {
@@ -1180,13 +1039,13 @@ namespace System
             return null;
         }
 
-        private Dictionary<String, Object[]> LocalStore
+        private Dictionary<String, Object> LocalStore
         {
             get { 
                 if (_LocalStore != null)
                     return _LocalStore;
                 else {
-                    _LocalStore = new Dictionary<String, Object[]>();
+                    _LocalStore = new Dictionary<String, Object>();
                     return _LocalStore;
                 }
             }
@@ -1289,7 +1148,6 @@ namespace System
             };  
         } // PrepareDataForSetup
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)]
         private static Object Setup(Object arg)
         {
             Contract.Requires(arg != null && arg is Object[]);
@@ -1366,11 +1224,11 @@ namespace System
                         if(values == null)
                             throw new ArgumentNullException(propertyNames[i]);
 
-                        ad.SetDataHelper(propertyNames[i], NormalizeAppPaths(values), null);
+                        ad.SetData(propertyNames[i], NormalizeAppPaths(values));
                     }
                     else if(propertyNames[i]!= null)
                     {
-                        ad.SetDataHelper(propertyNames[i],propertyValues[i],null);     // just propagate
+                        ad.SetData(propertyNames[i],propertyValues[i]);     // just propagate
                     }
                 }
             }
@@ -1532,10 +1390,7 @@ namespace System
         {
             get
             {
-                PermissionSet grantSet = null;
-                GetGrantSet(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref grantSet));
-
-                return grantSet == null || grantSet.IsUnrestricted();
+                return true;
             }
         }
 
@@ -1551,14 +1406,12 @@ namespace System
 
         public Int32 Id
         {
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]  
             get {
                 return GetId();
             }
         }
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]              
         internal extern Int32 GetId();
 
     }
diff --git a/src/mscorlib/src/System/AppDomainAttributes.cs b/src/mscorlib/src/System/AppDomainAttributes.cs
index 0980b5fe90..960f9c1cac 100644
--- a/src/mscorlib/src/System/AppDomainAttributes.cs
+++ b/src/mscorlib/src/System/AppDomainAttributes.cs
@@ -14,8 +14,7 @@
 namespace System {
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public enum LoaderOptimization 
+    internal enum LoaderOptimization 
     {
         NotSpecified            = 0,
         SingleDomain            = 1,
@@ -26,23 +25,5 @@ namespace System {
         [Obsolete("This method has been deprecated. Please use Assembly.Load() instead. http://go.microsoft.com/fwlink/?linkid=14202")]
         DisallowBindings        = 4         
     }
-
-    [AttributeUsage (AttributeTargets.Method)]  
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class LoaderOptimizationAttribute : Attribute
-    {
-        internal byte _val;
-
-        public LoaderOptimizationAttribute(byte value)
-        {
-            _val = value;
-        }
-        public LoaderOptimizationAttribute(LoaderOptimization value)
-        {
-            _val = (byte) value;
-        }
-        public LoaderOptimization Value 
-        {  get {return (LoaderOptimization) _val;} }
-    }
 }
 
diff --git a/src/mscorlib/src/System/AppDomainManager.cs b/src/mscorlib/src/System/AppDomainManager.cs
index 71bc088d1d..bd2faa0110 100644
--- a/src/mscorlib/src/System/AppDomainManager.cs
+++ b/src/mscorlib/src/System/AppDomainManager.cs
@@ -15,8 +15,7 @@ namespace System
     using System.Security;
     using System.Runtime.InteropServices;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public class AppDomainManager : MarshalByRefObject
+    internal class AppDomainManager : MarshalByRefObject
     {
         public AppDomainManager () {}
 
diff --git a/src/mscorlib/src/System/AppDomainSetup.cs b/src/mscorlib/src/System/AppDomainSetup.cs
index f3e6f79663..284650480b 100644
--- a/src/mscorlib/src/System/AppDomainSetup.cs
+++ b/src/mscorlib/src/System/AppDomainSetup.cs
@@ -26,9 +26,7 @@ namespace System
     using System.Collections.Generic;
 
     [Serializable]
-    [ClassInterface(ClassInterfaceType.None)]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class AppDomainSetup
+    internal sealed class AppDomainSetup
     {
         [Serializable]
         internal enum LoaderInformation
@@ -54,31 +52,12 @@ namespace System
             ConfigurationBytesValue       = 15, // LOADER_CONFIGURATION_BYTES
             LoaderMaximum                 = 18  // LOADER_MAXIMUM
         }
-
+        
         // Constants from fusionsetup.h.
         private const string LOADER_OPTIMIZATION = "LOADER_OPTIMIZATION";
         private const string CONFIGURATION_EXTENSION = ".config";
-        private const string APPENV_RELATIVEPATH = "RELPATH";
-        private const string MACHINE_CONFIGURATION_FILE = "config\\machine.config";
-        private const string ACTAG_HOST_CONFIG_FILE = "HOST_CONFIG";
 
-        // Constants from fusionpriv.h
-        private const string ACTAG_APP_CONFIG_FILE = "APP_CONFIG_FILE";
-        private const string ACTAG_MACHINE_CONFIG = "MACHINE_CONFIG";
         private const string ACTAG_APP_BASE_URL = "APPBASE";
-        private const string ACTAG_APP_NAME = "APP_NAME";
-        private const string ACTAG_BINPATH_PROBE_ONLY = "BINPATH_PROBE_ONLY";
-        private const string ACTAG_APP_CACHE_BASE = "CACHE_BASE";
-        private const string ACTAG_DEV_PATH = "DEV_PATH";
-        private const string ACTAG_APP_DYNAMIC_BASE = "DYNAMIC_BASE";
-        private const string ACTAG_FORCE_CACHE_INSTALL = "FORCE_CACHE_INSTALL";
-        private const string ACTAG_APP_PRIVATE_BINPATH = "PRIVATE_BINPATH";
-        private const string ACTAG_APP_SHADOW_COPY_DIRS = "SHADOW_COPY_DIRS";
-        private const string ACTAG_DISALLOW_APPLYPUBLISHERPOLICY = "DISALLOW_APP";
-        private const string ACTAG_CODE_DOWNLOAD_DISABLED = "CODE_DOWNLOAD_DISABLED";
-        private const string ACTAG_DISALLOW_APP_BINDING_REDIRECTS = "DISALLOW_APP_REDIRECTS";
-        private const string ACTAG_DISALLOW_APP_BASE_PROBING = "DISALLOW_APP_BASE_PROBING";
-        private const string ACTAG_APP_CONFIG_BLOB = "APP_CONFIG_BLOB";
 
         // This class has an unmanaged representation so be aware you will need to make edits in vm\object.h if you change the order
         // of these fields or add new ones.
@@ -548,7 +527,7 @@ namespace System
         internal ApplicationTrust InternalGetApplicationTrust()
         {
             if (_ApplicationTrust == null) return null;
-            ApplicationTrust grantSet = new ApplicationTrust(NamedPermissionSet.GetBuiltInSet(_ApplicationTrust));
+            ApplicationTrust grantSet = new ApplicationTrust();
             return grantSet;
         }
 
diff --git a/src/mscorlib/src/System/AppDomainUnloadedException.cs b/src/mscorlib/src/System/AppDomainUnloadedException.cs
index 8ba37dc4c5..30bee7c7de 100644
--- a/src/mscorlib/src/System/AppDomainUnloadedException.cs
+++ b/src/mscorlib/src/System/AppDomainUnloadedException.cs
@@ -15,23 +15,12 @@ namespace System {
 
     using System.Runtime.Serialization;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
-    public class AppDomainUnloadedException : SystemException {
+    internal class AppDomainUnloadedException : SystemException {
         public AppDomainUnloadedException() 
             : base(Environment.GetResourceString("Arg_AppDomainUnloadedException")) {
             SetErrorCode(__HResults.COR_E_APPDOMAINUNLOADED);
         }
-    
-        public AppDomainUnloadedException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_APPDOMAINUNLOADED);
-        }
-    
-        public AppDomainUnloadedException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_APPDOMAINUNLOADED);
-        }
 
         //
         //This constructor is required for serialization.
diff --git a/src/mscorlib/src/System/ApplicationException.cs b/src/mscorlib/src/System/ApplicationException.cs
index c56746fae0..900feb57f9 100644
--- a/src/mscorlib/src/System/ApplicationException.cs
+++ b/src/mscorlib/src/System/ApplicationException.cs
@@ -12,9 +12,10 @@
 **
 =============================================================================*/
 
-namespace System {
-    
-    using System.Runtime.Serialization;
+using System.Runtime.Serialization;
+
+namespace System
+{
     // The ApplicationException is the base class for nonfatal, 
     // application errors that occur.  These exceptions are generated 
     // (i.e., thrown) by an application, not the Runtime. Applications that need 
@@ -22,35 +23,34 @@ namespace System {
     // ApplicationException extends but adds no new functionality to 
     // RecoverableException.
     // 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
-    public class ApplicationException : Exception {
-        
+    public class ApplicationException : Exception
+    {
         // Creates a new ApplicationException with its message string set to
         // the empty string, its HRESULT set to COR_E_APPLICATION, 
         // and its ExceptionInfo reference set to null. 
-        public ApplicationException() 
-            : base(Environment.GetResourceString("Arg_ApplicationException")) {
-            SetErrorCode(__HResults.COR_E_APPLICATION);
+        public ApplicationException()
+            : base(SR.Arg_ApplicationException)
+        {
+            HResult = __HResults.COR_E_APPLICATION;
         }
-        
+
         // Creates a new ApplicationException with its message string set to
         // message, its HRESULT set to COR_E_APPLICATION, 
         // and its ExceptionInfo reference set to null. 
         // 
-        public ApplicationException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_APPLICATION);
-        }
-        
-        public ApplicationException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_APPLICATION);
+        public ApplicationException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_APPLICATION;
         }
 
-        protected ApplicationException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public ApplicationException(String message, Exception innerException)
+            : base(message, innerException)
+        {
+            HResult = __HResults.COR_E_APPLICATION;
         }
 
+        protected ApplicationException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
-
 }
diff --git a/src/mscorlib/src/System/ApplicationId.cs b/src/mscorlib/src/System/ApplicationId.cs
deleted file mode 100644
index 93fc37dd99..0000000000
--- a/src/mscorlib/src/System/ApplicationId.cs
+++ /dev/null
@@ -1,141 +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.
-
-
-//
-//
-// This class identifies a deployment or manifest identity.
-//
-
-namespace System {
-    using System.Reflection;
-    using System.Security;
-    using System.Security.Policy;
-    using System.Security.Util;
-    using System.Text;
-    using System.Diagnostics.Contracts;
-
-    [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class ApplicationId {
-        private string m_name;
-        private Version m_version;
-        private string m_processorArchitecture;
-        private string m_culture;
-        internal byte[] m_publicKeyToken;
-
-        internal ApplicationId () {}
-
-        //
-        // Public.
-        //
-
-        public ApplicationId (byte[] publicKeyToken, string name, Version version, string processorArchitecture, string culture) {
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-            if (name.Length == 0)
-                throw new ArgumentException(Environment.GetResourceString("Argument_EmptyApplicationName"));
-            if (version == null)
-                throw new ArgumentNullException(nameof(version));
-            if (publicKeyToken == null)
-                throw new ArgumentNullException(nameof(publicKeyToken));
-            Contract.EndContractBlock();
-
-            m_publicKeyToken = new byte[publicKeyToken.Length];
-            Array.Copy(publicKeyToken, 0, m_publicKeyToken, 0, publicKeyToken.Length);
-            m_name = name;
-            m_version = version;
-            m_processorArchitecture = processorArchitecture;
-            m_culture = culture;
-        }
-
-        public byte[] PublicKeyToken {
-            get {
-                byte[] publicKeyToken = new byte[m_publicKeyToken.Length];
-                Array.Copy(m_publicKeyToken, 0, publicKeyToken, 0, m_publicKeyToken.Length);
-                return publicKeyToken;
-            }
-        }
-
-        public string Name {
-            get {
-                return m_name;
-            }
-        }
-
-        public Version Version {
-            get {
-                return m_version;
-            }
-        }
-
-        public string ProcessorArchitecture {
-            get {
-                return m_processorArchitecture;
-            }
-        }
-
-        public string Culture {
-            get {
-                return m_culture;
-            }
-        }
-
-        public ApplicationId Copy () {
-            return new ApplicationId(m_publicKeyToken, m_name, m_version, m_processorArchitecture, m_culture);
-        }
-
-        public override string ToString () {
-            StringBuilder sb = StringBuilderCache.Acquire();
-            sb.Append(this.m_name);
-            if (m_culture != null) {
-                sb.Append(", culture=\"");
-                sb.Append(m_culture);
-                sb.Append("\"");
-            }
-            sb.Append(", version=\"");
-            sb.Append(m_version.ToString());
-            sb.Append("\"");
-            if (m_publicKeyToken != null) {
-                sb.Append(", publicKeyToken=\"");
-                sb.Append(Hex.EncodeHexString(m_publicKeyToken));
-                sb.Append("\"");
-            }
-            if (m_processorArchitecture != null) {
-                sb.Append(", processorArchitecture =\"");
-                sb.Append(this.m_processorArchitecture);
-                sb.Append("\"");
-            }
-            return StringBuilderCache.GetStringAndRelease(sb);
-        }
-
-        public override bool Equals (Object o) {
-            ApplicationId other = (o as ApplicationId);
-            if (other == null)
-                return false;
-
-            if (!(Equals(this.m_name, other.m_name) &&
-                  Equals(this.m_version, other.m_version) &&
-                  Equals(this.m_processorArchitecture, other.m_processorArchitecture) &&
-                  Equals(this.m_culture, other.m_culture)))
-                return false;
-
-            if (this.m_publicKeyToken.Length != other.m_publicKeyToken.Length)
-                return false;
-
-            for (int i = 0; i < this.m_publicKeyToken.Length; ++i) {
-                if (this.m_publicKeyToken[i] != other.m_publicKeyToken[i])
-                    return false;
-            }
-
-            return true;
-        }
-
-        public override int GetHashCode() {
-            // Note: purposely skipping publicKeyToken, processor architecture and culture as they
-            // are less likely to make things not equal than name and version.
-            return m_name.GetHashCode() ^ m_version.GetHashCode();
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/ArgIterator.cs b/src/mscorlib/src/System/ArgIterator.cs
index c5bc379505..83a60b95e1 100644
--- a/src/mscorlib/src/System/ArgIterator.cs
+++ b/src/mscorlib/src/System/ArgIterator.cs
@@ -16,6 +16,19 @@ namespace System {
     [StructLayout(LayoutKind.Sequential)]
     public struct ArgIterator
     {
+        private IntPtr ArgCookie;               // Cookie from the EE.
+
+        // The SigPointer structure consists of the following members.  (Note: this is an inline native SigPointer data type)
+        private IntPtr sigPtr;                  // Pointer to remaining signature.
+        private IntPtr sigPtrLen;               // Remaining length of the pointer
+
+        // Note, sigPtrLen is actually a DWORD, but on 64bit systems this structure becomes
+        // 8-byte aligned, which requires us to pad it.
+            
+        private IntPtr ArgPtr;                  // Pointer to remaining args.
+        private int    RemainingArgs;           // # of remaining args.
+        
+#if VARARGS_ENABLED //The JIT doesn't support Varargs calling convention.
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         private extern ArgIterator(IntPtr arglist);
 
@@ -34,7 +47,6 @@ namespace System {
         // This is much like the C va_start macro
 
         [CLSCompliant(false)]
-
         public unsafe ArgIterator(RuntimeArgumentHandle arglist, void* ptr) : this(arglist.Value, ptr)
         {
         }
@@ -121,17 +133,54 @@ namespace System {
         {
             throw new NotSupportedException(Environment.GetResourceString("NotSupported_NYI"));
         }
+#else
+        public ArgIterator(RuntimeArgumentHandle arglist)
+        {
+            throw new PlatformNotSupportedException(); //The JIT requires work to enable ArgIterator see: https://github.com/dotnet/coreclr/issues/9204.
+        }
 
-        private IntPtr ArgCookie;               // Cookie from the EE.
+        [CLSCompliant(false)]
+        public unsafe ArgIterator(RuntimeArgumentHandle arglist, void* ptr)
+        {
+            throw new PlatformNotSupportedException(); //The JIT requires work to enable ArgIterator see: https://github.com/dotnet/coreclr/issues/9204.
+        }
 
-        // The SigPointer structure consists of the following members.  (Note: this is an inline native SigPointer data type)
-        private IntPtr sigPtr;                  // Pointer to remaining signature.
-        private IntPtr sigPtrLen;               // Remaining length of the pointer
+        public void End() 
+        { 
+            throw new PlatformNotSupportedException(); //The JIT requires work to enable ArgIterator see: https://github.com/dotnet/coreclr/issues/9204.
+        }
 
-        // Note, sigPtrLen is actually a DWORD, but on 64bit systems this structure becomes
-        // 8-byte aligned, which requires us to pad it.
-            
-        private IntPtr ArgPtr;                  // Pointer to remaining args.
-        private int    RemainingArgs;           // # of remaining args.
+        public override bool Equals(Object o) 
+        {  
+            throw new PlatformNotSupportedException(); //The JIT requires work to enable ArgIterator see: https://github.com/dotnet/coreclr/issues/9204.
+        }
+
+        public override int GetHashCode()
+        { 
+            throw new PlatformNotSupportedException(); //The JIT requires work to enable ArgIterator see: https://github.com/dotnet/coreclr/issues/9204.
+        }
+
+        [System.CLSCompliantAttribute(false)]
+        public System.TypedReference GetNextArg()
+        {
+            throw new PlatformNotSupportedException(); //The JIT requires work to enable ArgIterator see: https://github.com/dotnet/coreclr/issues/9204.
+        }
+
+        [System.CLSCompliantAttribute(false)]
+        public System.TypedReference GetNextArg(System.RuntimeTypeHandle rth)
+        {
+            throw new PlatformNotSupportedException(); //The JIT requires work to enable ArgIterator see: https://github.com/dotnet/coreclr/issues/9204.
+        }
+
+        public unsafe System.RuntimeTypeHandle GetNextArgType()
+        {
+            throw new PlatformNotSupportedException(); //The JIT requires work to enable ArgIterator see: https://github.com/dotnet/coreclr/issues/9204.
+        }
+
+        public int GetRemainingCount()
+        {  
+            throw new PlatformNotSupportedException(); //The JIT requires work to enable ArgIterator see: https://github.com/dotnet/coreclr/issues/9204.
+        }
+#endif //VARARGS_ENABLED
     }
 }
diff --git a/src/mscorlib/src/System/ArgumentException.cs b/src/mscorlib/src/System/ArgumentException.cs
index f37b7690a8..fe054a9aa0 100644
--- a/src/mscorlib/src/System/ArgumentException.cs
+++ b/src/mscorlib/src/System/ArgumentException.cs
@@ -11,84 +11,87 @@
 **
 =============================================================================*/
 
-namespace System {
-    
-    using System;
-    using System.Runtime.Remoting;
-    using System.Runtime.Serialization;
-    using System.Globalization;
-    using System.Security.Permissions;
-    using System.Diagnostics.Contracts;
+using System.Globalization;
+using System.Runtime.Serialization;
+
+namespace System
+{
     // The ArgumentException is thrown when an argument does not meet 
     // the contract of the method.  Ideally it should give a meaningful error
     // message describing what was wrong and which parameter is incorrect.
     // 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
-    public class ArgumentException : SystemException, ISerializable {
-        private String m_paramName;
-        
+    public class ArgumentException : SystemException, ISerializable
+    {
+        private String _paramName;
+
         // Creates a new ArgumentException with its message 
         // string set to the empty string. 
-        public ArgumentException() 
-            : base(Environment.GetResourceString("Arg_ArgumentException")) {
-            SetErrorCode(__HResults.COR_E_ARGUMENT);
+        public ArgumentException()
+            : base(SR.Arg_ArgumentException)
+        {
+            HResult = __HResults.COR_E_ARGUMENT;
         }
-        
+
         // Creates a new ArgumentException with its message 
         // string set to message. 
         // 
-        public ArgumentException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_ARGUMENT);
+        public ArgumentException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_ARGUMENT;
         }
-        
-        public ArgumentException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_ARGUMENT);
+
+        public ArgumentException(String message, Exception innerException)
+            : base(message, innerException)
+        {
+            HResult = __HResults.COR_E_ARGUMENT;
         }
 
-        public ArgumentException(String message, String paramName, Exception innerException) 
-            : base(message, innerException) {
-            m_paramName = paramName;
-            SetErrorCode(__HResults.COR_E_ARGUMENT);
+        public ArgumentException(String message, String paramName, Exception innerException)
+            : base(message, innerException)
+        {
+            _paramName = paramName;
+            HResult = __HResults.COR_E_ARGUMENT;
         }
-        
-        public ArgumentException (String message, String paramName)
-        
-            : base (message) {
-            m_paramName = paramName;
-            SetErrorCode(__HResults.COR_E_ARGUMENT);
+
+        public ArgumentException(String message, String paramName)
+            : base(message)
+        {
+            _paramName = paramName;
+            HResult = __HResults.COR_E_ARGUMENT;
         }
 
-        protected ArgumentException(SerializationInfo info, StreamingContext context) : base(info, context) {
-            m_paramName = info.GetString("ParamName");
+        protected ArgumentException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+            _paramName = info.GetString("ParamName");
         }
-        
+
+        public override void GetObjectData(SerializationInfo info, StreamingContext context)
+        {
+            base.GetObjectData(info, context);
+            info.AddValue("ParamName", _paramName, typeof(String));
+        }
+
         public override String Message
         {
-            get {
+            get
+            {
                 String s = base.Message;
-                if (!String.IsNullOrEmpty(m_paramName)) {
-                    String resourceString = Environment.GetResourceString("Arg_ParamName_Name", m_paramName);
+                if (!String.IsNullOrEmpty(_paramName))
+                {
+                    String resourceString = SR.Format(SR.Arg_ParamName_Name, _paramName);
                     return s + Environment.NewLine + resourceString;
                 }
                 else
                     return s;
             }
         }
-                
-        public virtual String ParamName {
-            get { return m_paramName; }
-        }
-    
-        public override void GetObjectData(SerializationInfo info, StreamingContext context) {
-            if (info==null) {
-                throw new ArgumentNullException(nameof(info));
-            }
-            Contract.EndContractBlock();
-            base.GetObjectData(info, context);
-            info.AddValue("ParamName", m_paramName, typeof(String));
+
+        public virtual String ParamName
+        {
+            get { return _paramName; }
         }
     }
 }
diff --git a/src/mscorlib/src/System/ArgumentNullException.cs b/src/mscorlib/src/System/ArgumentNullException.cs
index 661ebd29af..3a86223ccf 100644
--- a/src/mscorlib/src/System/ArgumentNullException.cs
+++ b/src/mscorlib/src/System/ArgumentNullException.cs
@@ -11,44 +11,43 @@
 **
 =============================================================================*/
 
-namespace System {
-    
-    using System;
-    using System.Runtime.Serialization;
-    using System.Runtime.Remoting;
-    using System.Security.Permissions;
-    
+using System.Runtime.Serialization;
+
+namespace System
+{
     // The ArgumentException is thrown when an argument 
     // is null when it shouldn't be.
     // 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class ArgumentNullException : ArgumentException
     {
         // Creates a new ArgumentNullException with its message 
         // string set to a default message explaining an argument was null.
-       public ArgumentNullException() 
-            : base(Environment.GetResourceString("ArgumentNull_Generic")) {
-                // Use E_POINTER - COM used that for null pointers.  Description is "invalid pointer"
-                SetErrorCode(__HResults.E_POINTER);
+        public ArgumentNullException()
+             : base(SR.ArgumentNull_Generic)
+        {
+            // Use E_POINTER - COM used that for null pointers.  Description is "invalid pointer"
+            HResult = __HResults.E_POINTER;
         }
 
-        public ArgumentNullException(String paramName) 
-            : base(Environment.GetResourceString("ArgumentNull_Generic"), paramName) {
-            SetErrorCode(__HResults.E_POINTER);
+        public ArgumentNullException(String paramName)
+            : base(SR.ArgumentNull_Generic, paramName)
+        {
+            HResult = __HResults.E_POINTER;
         }
 
-        public ArgumentNullException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.E_POINTER);
-        }
-            
-        public ArgumentNullException(String paramName, String message) 
-            : base(message, paramName) {
-            SetErrorCode(__HResults.E_POINTER);   
+        public ArgumentNullException(String message, Exception innerException)
+            : base(message, innerException)
+        {
+            HResult = __HResults.E_POINTER;
         }
 
-        protected ArgumentNullException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public ArgumentNullException(String paramName, String message)
+            : base(message, paramName)
+        {
+            HResult = __HResults.E_POINTER;
         }
+
+        protected ArgumentNullException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
 }
diff --git a/src/mscorlib/src/System/ArgumentOutOfRangeException.cs b/src/mscorlib/src/System/ArgumentOutOfRangeException.cs
index 78a90db34e..59a8434089 100644
--- a/src/mscorlib/src/System/ArgumentOutOfRangeException.cs
+++ b/src/mscorlib/src/System/ArgumentOutOfRangeException.cs
@@ -17,12 +17,10 @@ namespace System {
     using System.Runtime.Remoting;
     using System.Runtime.Serialization;
     using System.Globalization;
-    using System.Security.Permissions;
     using System.Diagnostics.Contracts;
         
     // The ArgumentOutOfRangeException is thrown when an argument 
     // is outside the legal range for that argument.  
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class ArgumentOutOfRangeException : ArgumentException, ISerializable {
      
diff --git a/src/mscorlib/src/System/ArithmeticException.cs b/src/mscorlib/src/System/ArithmeticException.cs
index f5360939cc..081ba454f5 100644
--- a/src/mscorlib/src/System/ArithmeticException.cs
+++ b/src/mscorlib/src/System/ArithmeticException.cs
@@ -11,42 +11,41 @@
 **
 =============================================================================*/
 
-namespace System {
-    
-    using System;
-    using System.Runtime.Serialization;
+using System.Runtime.Serialization;
+
+namespace System
+{
     // The ArithmeticException is thrown when overflow or underflow
     // occurs.
     // 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class ArithmeticException : SystemException
-    {        
+    {
         // Creates a new ArithmeticException with its message string set to
         // the empty string, its HRESULT set to COR_E_ARITHMETIC, 
         // and its ExceptionInfo reference set to null. 
-        public ArithmeticException() 
-            : base(Environment.GetResourceString("Arg_ArithmeticException")) {
-            SetErrorCode(__HResults.COR_E_ARITHMETIC);
+        public ArithmeticException()
+            : base(SR.Arg_ArithmeticException)
+        {
+            HResult = __HResults.COR_E_ARITHMETIC;
         }
-        
+
         // Creates a new ArithmeticException with its message string set to
         // message, its HRESULT set to COR_E_ARITHMETIC, 
         // and its ExceptionInfo reference set to null. 
         // 
-        public ArithmeticException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_ARITHMETIC);
-        }
-        
-        public ArithmeticException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_ARITHMETIC);
+        public ArithmeticException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_ARITHMETIC;
         }
 
-        protected ArithmeticException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public ArithmeticException(String message, Exception innerException)
+            : base(message, innerException)
+        {
+            HResult = __HResults.COR_E_ARITHMETIC;
         }
 
+        protected ArithmeticException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
-
 }
diff --git a/src/mscorlib/src/System/Array.cs b/src/mscorlib/src/System/Array.cs
index 7bb6ebbdd3..23989f30fb 100644
--- a/src/mscorlib/src/System/Array.cs
+++ b/src/mscorlib/src/System/Array.cs
@@ -20,13 +20,11 @@ namespace System {
     using System.Runtime.Versioning;
     using System.Security;
     using System.Diagnostics;
-    using System.Security.Permissions;
     using System.Diagnostics.Contracts;
 
     // 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]
-    [ComVisible(true)]
     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
@@ -43,7 +41,6 @@ namespace System {
             return new ReadOnlyCollection<T>(array);
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static void Resize<T>(ref T[] array, int newSize) {
             if (newSize < 0)
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.newSize, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
@@ -154,7 +151,7 @@ namespace System {
                 if (lengths[i] < 0)
                     ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.lengths, i, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
 
-            fixed (int* pLengths = lengths)
+            fixed (int* pLengths = &lengths[0])
                 return InternalCreate((void*)t.TypeHandle.Value,lengths.Length,pLengths,null);
         }
 
@@ -211,8 +208,8 @@ namespace System {
                 if (lengths[i] < 0)
                     ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.lengths, i, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
 
-            fixed (int* pLengths = lengths)
-                fixed(int* pLowerBounds = lowerBounds)
+            fixed (int* pLengths = &lengths[0])
+                fixed(int* pLowerBounds = &lowerBounds[0])
                     return InternalCreate((void*)t.TypeHandle.Value,lengths.Length,pLengths,pLowerBounds);
         }
 
@@ -224,25 +221,9 @@ namespace System {
             return CreateInstance(elementType, length);
         }
 
-        internal static Array UnsafeCreateInstance(Type elementType, int length1, int length2)
-        {
-            return CreateInstance(elementType, length1, length2);
-        }
-
-        internal static Array UnsafeCreateInstance(Type elementType, params int[] lengths)
-        {
-            return CreateInstance(elementType, lengths);
-        }
-
-        internal static Array UnsafeCreateInstance(Type elementType, int[] lengths, int[] lowerBounds)
-        {
-            return CreateInstance(elementType, lengths, lowerBounds);
-        }
-
         // Copies length elements from sourceArray, starting at index 0, to
         // destinationArray, starting at index 0.
         //
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Copy(Array sourceArray, Array destinationArray, int length)
         {
             if (sourceArray == null)
@@ -263,7 +244,6 @@ namespace System {
         // Copies length elements from sourceArray, starting at sourceIndex, to
         // destinationArray, starting at destinationIndex.
         //
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Copy(Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length) 
         {
             Copy(sourceArray, sourceIndex, destinationArray, destinationIndex, length, false);
@@ -273,7 +253,6 @@ namespace System {
         // instance & might fail when called from within a CER, or if the
         // reliable flag is true, it will either always succeed or always
         // throw an exception with no side effects.
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         internal static extern void Copy(Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length, bool reliable);
 
@@ -282,13 +261,11 @@ namespace System {
         // compatible array types based on the array element type - this 
         // method does not support casting, boxing, or primitive widening.
         // It will up-cast, assuming the array types are correct.
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static void ConstrainedCopy(Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length)
         {
             Copy(sourceArray, sourceIndex, destinationArray, destinationIndex, length, true);
         }
 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Copy(Array sourceArray, Array destinationArray, long length)
         {
             if (length > Int32.MaxValue || length < Int32.MinValue)
@@ -297,7 +274,6 @@ namespace System {
             Array.Copy(sourceArray, destinationArray, (int) length);
         }
 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Copy(Array sourceArray, long sourceIndex, Array destinationArray, long destinationIndex, long length)
         {
             if (sourceIndex > Int32.MaxValue || sourceIndex < Int32.MinValue)
@@ -315,7 +291,6 @@ namespace System {
         // at index.
         //
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static extern void Clear(Array array, int index, int length);
         
         // The various Get values...
@@ -328,7 +303,7 @@ namespace System {
             Contract.EndContractBlock();
 
             TypedReference elemref = new TypedReference();
-            fixed(int* pIndices = indices)
+            fixed(int* pIndices = &indices[0])
                 InternalGetReference(&elemref, indices.Length, pIndices);
             return TypedReference.InternalToObject(&elemref);
         }
@@ -375,7 +350,6 @@ namespace System {
             return TypedReference.InternalToObject(&elemref);
         }
 
-        [ComVisible(false)]       
         public Object GetValue(long index)
         {
             if (index > Int32.MaxValue || index < Int32.MinValue)
@@ -385,7 +359,6 @@ namespace System {
             return this.GetValue((int) index);
         }
 
-        [ComVisible(false)]
         public Object GetValue(long index1, long index2)
         {
             if (index1 > Int32.MaxValue || index1 < Int32.MinValue)
@@ -397,7 +370,6 @@ namespace System {
             return this.GetValue((int) index1, (int) index2);
         }
 
-        [ComVisible(false)]
         public Object GetValue(long index1, long index2, long index3)
         {
             if (index1 > Int32.MaxValue || index1 < Int32.MinValue)
@@ -411,7 +383,6 @@ namespace System {
             return this.GetValue((int) index1, (int) index2, (int) index3);
         }
 
-        [ComVisible(false)]
         public Object GetValue(params long[] indices)
         {
             if (indices == null)
@@ -485,12 +456,11 @@ namespace System {
             Contract.EndContractBlock();
 
             TypedReference elemref = new TypedReference();
-            fixed(int* pIndices = indices)
+            fixed(int* pIndices = &indices[0])
                 InternalGetReference(&elemref, indices.Length, pIndices);
             InternalSetValue(&elemref,value);
         }
 
-        [ComVisible(false)]
         public void SetValue(Object value, long index)
         {
             if (index > Int32.MaxValue || index < Int32.MinValue)
@@ -500,7 +470,6 @@ namespace System {
             this.SetValue(value, (int) index);
         }
 
-        [ComVisible(false)]
         public void SetValue(Object value, long index1, long index2)
         {
             if (index1 > Int32.MaxValue || index1 < Int32.MinValue)
@@ -512,7 +481,6 @@ namespace System {
             this.SetValue(value, (int) index1, (int) index2);
         }
 
-        [ComVisible(false)]
         public void SetValue(Object value, long index1, long index2, long index3)
         {
             if (index1 > Int32.MaxValue || index1 < Int32.MinValue)
@@ -526,7 +494,6 @@ namespace System {
             this.SetValue(value, (int) index1, (int) index2, (int) index3);
         }
 
-        [ComVisible(false)]
         public void SetValue(Object value, params long[] indices)
         {
             if (indices == null)
@@ -559,12 +526,10 @@ namespace System {
 
         public extern int Length {
             [Pure]
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
             [MethodImpl(MethodImplOptions.InternalCall)]
             get;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         private static int GetMedian(int low, int hi) {
             // Note both may be negative, if we are dealing with arrays w/ negative lower bounds.
             Contract.Requires(low <= hi);
@@ -580,10 +545,8 @@ namespace System {
         internal const int MaxArrayLength = 0X7FEFFFFF;
         internal const int MaxByteArrayLength = 0x7FFFFFC7;
 
-        [ComVisible(false)]
         public extern long LongLength {
             [Pure]
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
             [MethodImpl(MethodImplOptions.InternalCall)]
             get;
         }
@@ -593,7 +556,6 @@ namespace System {
         public extern int GetLength(int dimension);
 
         [Pure]
-        [ComVisible(false)]
         public long GetLongLength(int dimension) {
             //This method should throw an IndexOufOfRangeException for compat if dimension < 0 or >= Rank
             return GetLength(dimension);
@@ -601,22 +563,18 @@ namespace System {
 
         public extern int Rank {
             [Pure]
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
             [MethodImplAttribute(MethodImplOptions.InternalCall)]
             get;
         }
 
         [Pure]
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public extern int GetUpperBound(int dimension);
 
         [Pure]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         public extern int GetLowerBound(int dimension);
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         internal extern int GetDataPtrOffsetInternal();
 
@@ -783,7 +741,6 @@ namespace System {
         // is larger than the given search value.
         // 
         [Pure]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static int BinarySearch(Array array, Object value) {
             if (array==null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
@@ -807,7 +764,6 @@ namespace System {
         // is larger than the given search value.
         // 
         [Pure]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static int BinarySearch(Array array, int index, int length, Object value) {
             return BinarySearch(array, index, length, value, null);
         }
@@ -827,7 +783,6 @@ namespace System {
         // is larger than the given search value.
         // 
         [Pure]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static int BinarySearch(Array array, Object value, IComparer comparer) {
             if (array==null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
@@ -852,7 +807,6 @@ namespace System {
         // is larger than the given search value.
         // 
         [Pure]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static int BinarySearch(Array array, int index, int length, Object value, IComparer comparer) {
             if (array==null) 
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
@@ -923,11 +877,9 @@ namespace System {
         }
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         private static extern bool TrySZBinarySearch(Array sourceArray, int sourceIndex, int count, Object value, out int retVal);
         
         [Pure]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static int BinarySearch<T>(T[] array, T value) {
             if (array==null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
@@ -936,7 +888,6 @@ namespace System {
         }
 
         [Pure]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static int BinarySearch<T>(T[] array, T value, System.Collections.Generic.IComparer<T> comparer) {
             if (array==null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
@@ -945,13 +896,11 @@ namespace System {
         }
 
         [Pure]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static int BinarySearch<T>(T[] array, int index, int length, T value) {
             return BinarySearch<T>(array, index, length, value, null);
         }
 
         [Pure]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static int BinarySearch<T>(T[] array, int index, int length, T value, System.Collections.Generic.IComparer<T> comparer) {
             if (array==null) 
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
@@ -1004,7 +953,6 @@ namespace System {
         }
 
         [Pure]
-        [ComVisible(false)]
         public void CopyTo(Array array, long index)
         {
             if (index > Int32.MaxValue || index < Int32.MinValue)
@@ -1015,7 +963,6 @@ namespace System {
         }
 
         [Pure]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static T[] Empty<T>()
         {
             Contract.Ensures(Contract.Result<T[]>() != null);
@@ -1253,7 +1200,6 @@ namespace System {
         // The array is searched forwards, and the elements of the array are
         // compared to the given value using the Object.Equals method.
         // 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static int IndexOf(Array array, Object value) {
             if (array==null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
@@ -1269,7 +1215,6 @@ namespace System {
         // elements of the array are compared to the given value using the
         // Object.Equals method.
         // 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static int IndexOf(Array array, Object value, int startIndex) {
             if (array==null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
@@ -1285,7 +1230,6 @@ namespace System {
         // elements of the array are compared to the given value using the
         // Object.Equals method.
         // 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static int IndexOf(Array array, Object value, int startIndex, int count) {
             if (array==null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
@@ -1380,7 +1324,6 @@ namespace System {
         }
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         private static extern bool TrySZIndexOf(Array sourceArray, int sourceIndex, int count, Object value, out int retVal);
         
 
@@ -1388,7 +1331,6 @@ namespace System {
         // The array is searched backwards, and the elements of the array are
         // compared to the given value using the Object.Equals method.
         // 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static int LastIndexOf(Array array, Object value) {
             if (array==null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
@@ -1403,7 +1345,6 @@ namespace System {
         // startIndex and ending at index 0. The elements of the array are
         // compared to the given value using the Object.Equals method.
         // 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static int LastIndexOf(Array array, Object value, int startIndex) {
             if (array == null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
@@ -1419,7 +1360,6 @@ namespace System {
         // the array are compared to the given value using the Object.Equals
         // method.
         // 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static int LastIndexOf(Array array, Object value, int startIndex, int count) {
             if (array==null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
@@ -1531,7 +1471,6 @@ namespace System {
         }
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         private static extern bool TrySZLastIndexOf(Array sourceArray, int sourceIndex, int count, Object value, out int retVal);
 
 
@@ -1540,7 +1479,6 @@ namespace System {
         // located at index length - i - 1, where length is the
         // length of the array.
         // 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Reverse(Array array) {
             if (array==null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
@@ -1554,7 +1492,6 @@ namespace System {
         // index index + (index + count - i - 1).
         // Reliability note: This may fail because it may have to box objects.
         // 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Reverse(Array array, int index, int length) {
             if (array==null) 
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
@@ -1598,10 +1535,8 @@ namespace System {
         }
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         private static extern bool TrySZReverse(Array array, int index, int count);
 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Reverse<T>(T[] array)
         {
             if (array == null)
@@ -1610,7 +1545,6 @@ namespace System {
             Reverse(array, 0, array.Length);
         }
 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Reverse<T>(T[] array, int index, int length)
         {
             if (array == null)
@@ -1639,7 +1573,6 @@ namespace System {
         // other using the IComparable interface, which must be implemented
         // by all elements of the array.
         // 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Sort(Array array) {
             if (array==null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
@@ -1653,7 +1586,6 @@ namespace System {
         // keys to each other using the IComparable interface, which must be
         // implemented by all elements of the keys array.
         // 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Sort(Array keys, Array items) {
             if (keys==null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.keys);
@@ -1665,7 +1597,6 @@ namespace System {
         // elements to each other using the IComparable interface, which
         // must be implemented by all elements in the given section of the array.
         // 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Sort(Array array, int index, int length) {
             Sort(array, null, index, length, null);
         }
@@ -1676,7 +1607,6 @@ namespace System {
         // keys to each other using the IComparable interface, which must be
         // implemented by all elements of the keys array.
         // 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Sort(Array keys, Array items, int index, int length) {
             Sort(keys, items, index, length, null);
         }
@@ -1687,7 +1617,6 @@ namespace System {
         // IComparable interface, which in that case must be implemented by
         // all elements of the array.
         // 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Sort(Array array, IComparer comparer) {
             if (array==null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
@@ -1703,7 +1632,6 @@ namespace System {
         // the IComparable interface, which in that case must be implemented
         // by all elements of the keys array.
         // 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Sort(Array keys, Array items, IComparer comparer) {
             if (keys==null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.keys);
@@ -1717,7 +1645,6 @@ namespace System {
         // the IComparable interface, which in that case must be implemented
         // by all elements in the given section of the array.
         // 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Sort(Array array, int index, int length, IComparer comparer) {
             Sort(array, null, index, length, comparer);
         }
@@ -1730,7 +1657,6 @@ namespace System {
         // the IComparable interface, which in that case must be implemented
         // by all elements of the given section of the keys array.
         // 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Sort(Array keys, Array items, int index, int length, IComparer comparer) {
             if (keys==null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.keys);
@@ -1772,10 +1698,8 @@ namespace System {
         }
         
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         private static extern bool TrySZSort(Array keys, Array items, int left, int right);
 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Sort<T>(T[] array) {
             if (array==null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
@@ -1783,7 +1707,6 @@ namespace System {
             Sort<T>(array, 0, array.Length, null);
         }
 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Sort<TKey, TValue>(TKey[] keys, TValue[] items) {
             if (keys==null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.keys);
@@ -1791,17 +1714,14 @@ namespace System {
             Sort<TKey, TValue>(keys, items, 0, keys.Length, null);
         }
 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Sort<T>(T[] array, int index, int length) {
             Sort<T>(array, index, length, null);
         }
 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Sort<TKey, TValue>(TKey[] keys, TValue[] items, int index, int length) {
             Sort<TKey, TValue>(keys, items, index, length, null);
         }
 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Sort<T>(T[] array, System.Collections.Generic.IComparer<T> comparer) {
             if (array == null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
@@ -1809,7 +1729,6 @@ namespace System {
             Sort<T>(array, 0, array.Length, comparer);
         }
 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Sort<TKey, TValue>(TKey[] keys, TValue[] items, System.Collections.Generic.IComparer<TKey> comparer) {
             if (keys==null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.keys);
@@ -1817,7 +1736,6 @@ namespace System {
             Sort<TKey, TValue>(keys, items, 0, keys.Length, comparer);
         }
 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Sort<T>(T[] array, int index, int length, System.Collections.Generic.IComparer<T> comparer) {
             if (array==null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
@@ -1840,7 +1758,6 @@ namespace System {
             }
         }
 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         public static void Sort<TKey, TValue>(TKey[] keys, TValue[] items, int index, int length, System.Collections.Generic.IComparer<TKey> comparer) {
             if (keys==null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.keys);
diff --git a/src/mscorlib/src/System/ArraySegment.cs b/src/mscorlib/src/System/ArraySegment.cs
index b767e7bd77..03556e492a 100644
--- a/src/mscorlib/src/System/ArraySegment.cs
+++ b/src/mscorlib/src/System/ArraySegment.cs
@@ -15,8 +15,6 @@
 
 using System.Collections;
 using System.Collections.Generic;
-using System.Runtime.InteropServices;
-using System.Diagnostics;
 using System.Diagnostics.Contracts;
 
 namespace System
@@ -46,14 +44,10 @@ namespace System
 
         public ArraySegment(T[] array, int offset, int count)
         {
-            if (array == null)
-                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
-            if (offset < 0)
-                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.offset, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
-            if (count < 0)
-                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
-            if (array.Length - offset < count)
-                ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
+            // Validate arguments, check is minimal instructions with reduced branching for inlinable fast-path
+            // Failure should be rare and location determination and message is delegated to failure functions
+            if (array == null || (offset | count) < 0 || (array.Length - offset < count))
+                ThrowHelper.ThrowArraySegmentCtorValidationFailedExceptions(array, offset, count);
             Contract.EndContractBlock();
 
             _array = array;
diff --git a/src/mscorlib/src/System/ArrayTypeMismatchException.cs b/src/mscorlib/src/System/ArrayTypeMismatchException.cs
index 4f24b9d3c7..3e941fdf8e 100644
--- a/src/mscorlib/src/System/ArrayTypeMismatchException.cs
+++ b/src/mscorlib/src/System/ArrayTypeMismatchException.cs
@@ -11,42 +11,41 @@
 **
 =============================================================================*/
 
-namespace System {
-    
-    using System;
-    using System.Runtime.Serialization;
+using System.Runtime.Serialization;
+
+namespace System
+{
     // The ArrayMismatchException is thrown when an attempt to store
     // an object of the wrong type within an array occurs.
     // 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
-    public class ArrayTypeMismatchException : SystemException {
-        
+    public class ArrayTypeMismatchException : SystemException
+    {
         // Creates a new ArrayMismatchException with its message string set to
         // the empty string, its HRESULT set to COR_E_ARRAYTYPEMISMATCH, 
         // and its ExceptionInfo reference set to null. 
-        public ArrayTypeMismatchException() 
-            : base(Environment.GetResourceString("Arg_ArrayTypeMismatchException")) {
-            SetErrorCode(__HResults.COR_E_ARRAYTYPEMISMATCH);
+        public ArrayTypeMismatchException()
+            : base(SR.Arg_ArrayTypeMismatchException)
+        {
+            HResult = __HResults.COR_E_ARRAYTYPEMISMATCH;
         }
-        
+
         // Creates a new ArrayMismatchException with its message string set to
         // message, its HRESULT set to COR_E_ARRAYTYPEMISMATCH, 
         // and its ExceptionInfo reference set to null. 
         // 
-        public ArrayTypeMismatchException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_ARRAYTYPEMISMATCH);
-        }
-        
-        public ArrayTypeMismatchException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_ARRAYTYPEMISMATCH);
+        public ArrayTypeMismatchException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_ARRAYTYPEMISMATCH;
         }
 
-        protected ArrayTypeMismatchException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public ArrayTypeMismatchException(String message, Exception innerException)
+            : base(message, innerException)
+        {
+            HResult = __HResults.COR_E_ARRAYTYPEMISMATCH;
         }
 
+        protected ArrayTypeMismatchException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
-
 }
diff --git a/src/mscorlib/src/System/AsyncCallback.cs b/src/mscorlib/src/System/AsyncCallback.cs
index 69a03812e1..5c49535cff 100644
--- a/src/mscorlib/src/System/AsyncCallback.cs
+++ b/src/mscorlib/src/System/AsyncCallback.cs
@@ -9,9 +9,9 @@
 ** Purpose: Type of callback for async operations
 **
 ===========================================================*/
-namespace System {
+
+namespace System
+{
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public delegate void AsyncCallback(IAsyncResult ar);
-
 }
diff --git a/src/mscorlib/src/System/Attribute.cs b/src/mscorlib/src/System/Attribute.cs
index e77450e972..b44e13f959 100644
--- a/src/mscorlib/src/System/Attribute.cs
+++ b/src/mscorlib/src/System/Attribute.cs
@@ -13,14 +13,10 @@ namespace System {
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
     using System.Security;
-    using System.Security.Permissions;
 
     [Serializable]
     [AttributeUsageAttribute(AttributeTargets.All, Inherited = true, AllowMultiple=false)] 
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_Attribute))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public abstract class Attribute : _Attribute
+    public abstract class Attribute
     {
         #region Private Statics
 
diff --git a/src/mscorlib/src/System/AttributeTargets.cs b/src/mscorlib/src/System/AttributeTargets.cs
index 33617e9623..fdfa4ab730 100644
--- a/src/mscorlib/src/System/AttributeTargets.cs
+++ b/src/mscorlib/src/System/AttributeTargets.cs
@@ -4,37 +4,33 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
-namespace System {
-    
-    using System;
-    
+
+namespace System
+{
     // Enum used to indicate all the elements of the
     // VOS it is valid to attach this element to.
-[Serializable]
     [Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
+    [Serializable]
     public enum AttributeTargets
     {
-        Assembly      = 0x0001,
-        Module        = 0x0002,
-        Class         = 0x0004,
-        Struct        = 0x0008,
-        Enum          = 0x0010,
-        Constructor   = 0x0020,
-        Method        = 0x0040,
-        Property      = 0x0080,
-        Field         = 0x0100,
-        Event         = 0x0200,
-        Interface     = 0x0400,
-        Parameter     = 0x0800,
-        Delegate      = 0x1000,
-        ReturnValue   = 0x2000,
-        //@todo GENERICS: document GenericParameter
+        Assembly = 0x0001,
+        Module = 0x0002,
+        Class = 0x0004,
+        Struct = 0x0008,
+        Enum = 0x0010,
+        Constructor = 0x0020,
+        Method = 0x0040,
+        Property = 0x0080,
+        Field = 0x0100,
+        Event = 0x0200,
+        Interface = 0x0400,
+        Parameter = 0x0800,
+        Delegate = 0x1000,
+        ReturnValue = 0x2000,
         GenericParameter = 0x4000,
-        
-        
-        All           = Assembly | Module   | Class | Struct | Enum      | Constructor | 
-                        Method   | Property | Field | Event  | Interface | Parameter   | 
-                        Delegate | ReturnValue | GenericParameter,
+
+        All = Assembly | Module | Class | Struct | Enum | Constructor |
+                        Method | Property | Field | Event | Interface | Parameter |
+                        Delegate | ReturnValue | GenericParameter
     }
 }
diff --git a/src/mscorlib/src/System/AttributeUsageAttribute.cs b/src/mscorlib/src/System/AttributeUsageAttribute.cs
index 0c2e11caff..33f7fd805e 100644
--- a/src/mscorlib/src/System/AttributeUsageAttribute.cs
+++ b/src/mscorlib/src/System/AttributeUsageAttribute.cs
@@ -16,7 +16,6 @@ namespace System {
     /* By default, attributes are inherited and multiple attributes are not allowed */
 [Serializable]
     [AttributeUsage(AttributeTargets.Class, Inherited = true)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class AttributeUsageAttribute : Attribute
     {
         internal AttributeTargets m_attributeTarget = AttributeTargets.All; // Defaults to all
diff --git a/src/mscorlib/src/System/BCLDebug.cs b/src/mscorlib/src/System/BCLDebug.cs
index 0ca6e616f2..7556b85789 100644
--- a/src/mscorlib/src/System/BCLDebug.cs
+++ b/src/mscorlib/src/System/BCLDebug.cs
@@ -20,7 +20,6 @@ namespace System {
     using Microsoft.Win32;
     using System.Runtime.CompilerServices;
     using System.Runtime.Versioning;
-    using System.Security.Permissions;
     using System.Security;
     using System.Diagnostics.Contracts;
 
@@ -54,7 +53,6 @@ namespace System {
 #if _DEBUG
         internal static volatile bool m_domainUnloadAdded;
 #endif
-        internal static volatile PermissionSet m_MakeConsoleErrorLoggingWork;
 
         static readonly SwitchStructure[] switches = {
             new SwitchStructure("NLS",  0x00000001),
@@ -263,40 +261,6 @@ namespace System {
             System.Diagnostics.Log.LogMessage((LoggingLevels)((int)level), logSwitch, StringBuilderCache.GetStringAndRelease(sb));
         }
 
-        // Note this overload doesn't take a format string.  You probably don't 
-        // want this one.
-        [Pure]
-        [Conditional("_LOGGING")]
-        public static void Trace(String switchName, params Object[]messages) {
-            if (m_loggingNotEnabled) {
-                return;
-            }
-
-            LogSwitch logSwitch;
-            if (!CheckEnabled(switchName, LogLevel.Trace, out logSwitch)) {
-                return;
-            }
-
-            StringBuilder sb = StringBuilderCache.Acquire();
-
-            for (int i=0; i<messages.Length; i++) {
-                String s;
-                try {
-                    if (messages[i]==null) {
-                        s = "<null>";
-                    } else {
-                        s = messages[i].ToString();
-                    }
-                } catch {
-                    s = "<unable to convert>";
-                }
-                sb.Append(s);
-            }
-            
-            sb.Append(Environment.NewLine);
-            System.Diagnostics.Log.LogMessage(LoggingLevels.TraceLevel0, logSwitch, StringBuilderCache.GetStringAndRelease(sb));
-        }
-
         [Pure]
         [Conditional("_LOGGING")]
         public static void Trace(String switchName, String format, params Object[] messages) {
@@ -316,22 +280,6 @@ namespace System {
             System.Diagnostics.Log.LogMessage(LoggingLevels.TraceLevel0, logSwitch, StringBuilderCache.GetStringAndRelease(sb));
         }
 
-        [Conditional("_LOGGING")]
-        public static void DumpStack(String switchName) {
-            LogSwitch logSwitch;
-
-            if (!m_registryChecked) {
-                CheckRegistry();
-            }
-
-            if (!CheckEnabled(switchName, LogLevel.Trace, out logSwitch)) {
-                return;
-            }
-            
-            StackTrace trace = new StackTrace();
-            System.Diagnostics.Log.LogMessage(LoggingLevels.TraceLevel0, logSwitch, trace.ToString());
-        }
-
         // For perf-related asserts.  On a debug build, set the registry key
         // BCLPerfWarnings to non-zero.
         [Conditional("_DEBUG")]
@@ -377,21 +325,6 @@ namespace System {
 #endif
         }
 
-#if !BIT64 // 32
-#endif
-        internal static bool CorrectnessEnabled()
-        {
-#if BIT64
-            return false;
-#else // 32
-            if (AppDomain.CurrentDomain.IsUnloadingForcedFinalize())
-                return false;
-            if (!m_registryChecked)
-                CheckRegistry();
-            return m_correctnessWarnings;  
-#endif // BIT64
-        }
-
         // Whether SafeHandles include a stack trace showing where they 
         // were allocated.  Only useful in checked & debug builds.
         internal static bool SafeHandleStackTracesEnabled {
diff --git a/src/mscorlib/src/System/BadImageFormatException.cs b/src/mscorlib/src/System/BadImageFormatException.cs
index 3f3f4a5b6e..51a6c40771 100644
--- a/src/mscorlib/src/System/BadImageFormatException.cs
+++ b/src/mscorlib/src/System/BadImageFormatException.cs
@@ -16,11 +16,9 @@ namespace System {
     using System;
     using System.Runtime.Serialization;
     using FileLoadException = System.IO.FileLoadException;
-    using System.Security.Permissions;
     using SecurityException = System.Security.SecurityException;
     using System.Globalization;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class BadImageFormatException : SystemException {
 
diff --git a/src/mscorlib/src/System/BitConverter.cs b/src/mscorlib/src/System/BitConverter.cs
index 3a6d1c03b0..07af5a8178 100644
--- a/src/mscorlib/src/System/BitConverter.cs
+++ b/src/mscorlib/src/System/BitConverter.cs
@@ -63,7 +63,7 @@ namespace System {
             Contract.Ensures(Contract.Result<byte[]>().Length == 2);
 
             byte[] bytes = new byte[2];
-            fixed(byte* b = bytes)
+            fixed(byte* b = &bytes[0])
                 *((short*)b) = value;
             return bytes;
         }
@@ -76,7 +76,7 @@ namespace System {
             Contract.Ensures(Contract.Result<byte[]>().Length == 4);
 
             byte[] bytes = new byte[4];
-            fixed(byte* b = bytes)
+            fixed(byte* b = &bytes[0])
                 *((int*)b) = value;
             return bytes;
         }
@@ -89,7 +89,7 @@ namespace System {
             Contract.Ensures(Contract.Result<byte[]>().Length == 8);
 
             byte[] bytes = new byte[8];
-            fixed(byte* b = bytes)
+            fixed(byte* b = &bytes[0])
                 *((long*)b) = value;
             return bytes;
         }
diff --git a/src/mscorlib/src/System/Boolean.cs b/src/mscorlib/src/System/Boolean.cs
index 9aaec9a345..c085b0a020 100644
--- a/src/mscorlib/src/System/Boolean.cs
+++ b/src/mscorlib/src/System/Boolean.cs
@@ -19,7 +19,6 @@ namespace System {
     // The Boolean class provides the
     // object representation of the boolean primitive type.
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public struct Boolean : IComparable, IConvertible, IComparable<Boolean>,  IEquatable<Boolean>
     {
     
diff --git a/src/mscorlib/src/System/Buffer.cs b/src/mscorlib/src/System/Buffer.cs
index eee2a81b51..662b240b34 100644
--- a/src/mscorlib/src/System/Buffer.cs
+++ b/src/mscorlib/src/System/Buffer.cs
@@ -22,7 +22,6 @@ namespace System {
     using nuint = System.UInt32;
 #endif // BIT64
 
-[System.Runtime.InteropServices.ComVisible(true)]
     public static class Buffer
     {
         // Copies from one primitive array to another primitive array without
@@ -205,7 +204,6 @@ namespace System {
                 *(src + len) = 0;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal unsafe static void Memcpy(byte[] dest, int destIndex, byte* src, int srcIndex, int len) {
             Debug.Assert( (srcIndex >= 0) && (destIndex >= 0) && (len >= 0), "Index and length must be non-negative!");
             Debug.Assert(dest.Length - destIndex >= len, "not enough bytes in dest");
@@ -218,7 +216,6 @@ namespace System {
             }
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal unsafe static void Memcpy(byte* pDest, int destIndex, byte[] src, int srcIndex, int len)
         {
             Debug.Assert( (srcIndex >= 0) && (destIndex >= 0) && (len >= 0), "Index and length must be non-negative!");        
@@ -242,7 +239,6 @@ namespace System {
         // 1. This method is given access to other internal dlls and this close to release we do not want to change it.
         // 2. It is difficult to get this right for arm and again due to release dates we would like to visit it later.
         [FriendAccessAllowed]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 #if ARM
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         internal unsafe static extern void Memcpy(byte* dest, byte* src, int len);
@@ -255,7 +251,6 @@ namespace System {
 #endif // ARM
 
         // This method has different signature for x64 and other platforms and is done for performance reasons.
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal unsafe static void Memmove(byte* dest, byte* src, nuint len)
         {
             // P/Invoke into the native version when the buffers are overlapping and the copy needs to be performed backwards
@@ -581,7 +576,6 @@ namespace System {
 
         // Non-inlinable wrapper around the QCall that avoids poluting the fast path
         // with P/Invoke prolog/epilog.
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [MethodImplAttribute(MethodImplOptions.NoInlining)]
         private unsafe static void _Memmove(byte* dest, byte* src, nuint len)
         {
@@ -590,7 +584,6 @@ namespace System {
 
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
         [SuppressUnmanagedCodeSecurity]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         extern private unsafe static void __Memmove(byte* dest, byte* src, nuint len);
 
         // The attributes on this method are chosen for best JIT performance. 
diff --git a/src/mscorlib/src/System/Byte.cs b/src/mscorlib/src/System/Byte.cs
index 980412b69e..666fdda75b 100644
--- a/src/mscorlib/src/System/Byte.cs
+++ b/src/mscorlib/src/System/Byte.cs
@@ -22,7 +22,6 @@ namespace System {
     // The Byte class extends the Value class and 
     // provides object representation of the byte primitive type. 
     // 
-[System.Runtime.InteropServices.ComVisible(true)]
 [Serializable]
 [System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
     public struct Byte : IComparable, IFormattable, IConvertible
diff --git a/src/mscorlib/src/System/CLRConfig.cs b/src/mscorlib/src/System/CLRConfig.cs
index 01ad7c31ab..16c610b82b 100644
--- a/src/mscorlib/src/System/CLRConfig.cs
+++ b/src/mscorlib/src/System/CLRConfig.cs
@@ -9,26 +9,6 @@ using System.Security;
 
 namespace System {
 
-/// <summary>
-/// For now, this class should be the central point to collect all managed declarations
-/// of native functions designed to expose config switches.
-/// In Dev11 M2.2 we will redesign this class to expose CLRConfig from within the CLR
-/// and refactor managed Fx code to access all compat switches through here.
-/// </summary>
-[FriendAccessAllowed]
-internal class CLRConfig {
-    
-    [FriendAccessAllowed]
-    [MethodImplAttribute(MethodImplOptions.InternalCall)]
-    [SuppressUnmanagedCodeSecurity]
-    internal static extern bool CheckLegacyManagedDeflateStream();
-
-    [MethodImplAttribute(MethodImplOptions.InternalCall)]
-    [SuppressUnmanagedCodeSecurity]
-    internal static extern bool CheckThrowUnobservedTaskExceptions();
-
-}  // internal class CLRConfig
-
 }  // namespace System
 
 // file CLRConfig
diff --git a/src/mscorlib/src/System/CLSCompliantAttribute.cs b/src/mscorlib/src/System/CLSCompliantAttribute.cs
index e902049558..e03600d132 100644
--- a/src/mscorlib/src/System/CLSCompliantAttribute.cs
+++ b/src/mscorlib/src/System/CLSCompliantAttribute.cs
@@ -11,23 +11,23 @@
 **
 =============================================================================*/
 
-namespace System {
-[Serializable]
-    [AttributeUsage (AttributeTargets.All, Inherited=true, AllowMultiple=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class CLSCompliantAttribute : Attribute 
+namespace System
+{
+    [Serializable]
+    [AttributeUsage(AttributeTargets.All, Inherited = true, AllowMultiple = false)]
+    public sealed class CLSCompliantAttribute : Attribute
     {
-        private bool m_compliant;
+        private bool _compliant;
 
-        public CLSCompliantAttribute (bool isCompliant)
+        public CLSCompliantAttribute(bool isCompliant)
         {
-            m_compliant = isCompliant;
+            _compliant = isCompliant;
         }
-        public bool IsCompliant 
+        public bool IsCompliant
         {
-            get 
+            get
             {
-                return m_compliant;
+                return _compliant;
             }
         }
     }
diff --git a/src/mscorlib/src/System/CannotUnloadAppDomainException.cs b/src/mscorlib/src/System/CannotUnloadAppDomainException.cs
deleted file mode 100644
index 6b07eae5e2..0000000000
--- a/src/mscorlib/src/System/CannotUnloadAppDomainException.cs
+++ /dev/null
@@ -1,49 +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: Exception class for failed attempt to unload an AppDomain.
-**
-**
-=============================================================================*/
-
-namespace System {
-
-    using System.Runtime.Serialization;
-
-    [System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-    public class CannotUnloadAppDomainException : SystemException {
-        public CannotUnloadAppDomainException() 
-            : base(Environment.GetResourceString("Arg_CannotUnloadAppDomainException")) {
-            SetErrorCode(__HResults.COR_E_CANNOTUNLOADAPPDOMAIN);
-        }
-    
-        public CannotUnloadAppDomainException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_CANNOTUNLOADAPPDOMAIN);
-        }
-    
-        public CannotUnloadAppDomainException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_CANNOTUNLOADAPPDOMAIN);
-        }
-
-        //
-        //This constructor is required for serialization.
-        //
-        protected CannotUnloadAppDomainException(SerializationInfo info, StreamingContext context) : base(info, context) {
-        }
-    }
-}
-
-
-
-
-
-
-
diff --git a/src/mscorlib/src/System/CfgParser.cs b/src/mscorlib/src/System/CfgParser.cs
deleted file mode 100644
index b21da7fe94..0000000000
--- a/src/mscorlib/src/System/CfgParser.cs
+++ /dev/null
@@ -1,564 +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: XMLParser and Tree builder internal to BCL
- **
- **
- ===========================================================*/
-
-namespace System
-{
-    using System.Runtime.InteropServices;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Runtime.CompilerServices;
-    using System.Security.Permissions;
-    using System.Security;
-    using System.Globalization;
-    using System.IO;
-    using System.Runtime.Versioning;
-    using System.Diagnostics.Contracts;
-
-    [Serializable]
-    internal enum ConfigEvents
-    {
-        StartDocument     = 0,
-        StartDTD          = StartDocument + 1,
-        EndDTD            = StartDTD + 1,
-        StartDTDSubset    = EndDTD + 1,
-        EndDTDSubset      = StartDTDSubset + 1,
-        EndProlog         = EndDTDSubset + 1,
-        StartEntity       = EndProlog + 1,
-        EndEntity         = StartEntity + 1,
-        EndDocument       = EndEntity + 1,
-        DataAvailable     = EndDocument + 1,
-        LastEvent         = DataAvailable
-    }
-
-    [Serializable]
-    internal enum ConfigNodeType
-    {
-        Element = 1,
-        Attribute   = Element + 1,
-        Pi  = Attribute + 1,
-        XmlDecl = Pi + 1,
-        DocType = XmlDecl + 1,
-        DTDAttribute    = DocType + 1,
-        EntityDecl  = DTDAttribute + 1,
-        ElementDecl = EntityDecl + 1,
-        AttlistDecl = ElementDecl + 1,
-        Notation    = AttlistDecl + 1,
-        Group   = Notation + 1,
-        IncludeSect = Group + 1,
-        PCData  = IncludeSect + 1,
-        CData   = PCData + 1,
-        IgnoreSect  = CData + 1,
-        Comment = IgnoreSect + 1,
-        EntityRef   = Comment + 1,
-        Whitespace  = EntityRef + 1,
-        Name    = Whitespace + 1,
-        NMToken = Name + 1,
-        String  = NMToken + 1,
-        Peref   = String + 1,
-        Model   = Peref + 1,
-        ATTDef  = Model + 1,
-        ATTType = ATTDef + 1,
-        ATTPresence = ATTType + 1,
-        DTDSubset   = ATTPresence + 1,
-        LastNodeType    = DTDSubset + 1
-    } 
-
-    [Serializable]
-    internal enum ConfigNodeSubType
-    {
-        Version = (int)ConfigNodeType.LastNodeType,
-        Encoding    = Version + 1,
-        Standalone  = Encoding + 1,
-        NS  = Standalone + 1,
-        XMLSpace    = NS + 1,
-        XMLLang = XMLSpace + 1,
-        System  = XMLLang + 1,
-        Public  = System + 1,
-        NData   = Public + 1,
-        AtCData = NData + 1,
-        AtId    = AtCData + 1,
-        AtIdref = AtId + 1,
-        AtIdrefs    = AtIdref + 1,
-        AtEntity    = AtIdrefs + 1,
-        AtEntities  = AtEntity + 1,
-        AtNmToken   = AtEntities + 1,
-        AtNmTokens  = AtNmToken + 1,
-        AtNotation  = AtNmTokens + 1,
-        AtRequired  = AtNotation + 1,
-        AtImplied   = AtRequired + 1,
-        AtFixed = AtImplied + 1,
-        PentityDecl = AtFixed + 1,
-        Empty   = PentityDecl + 1,
-        Any = Empty + 1,
-        Mixed   = Any + 1,
-        Sequence    = Mixed + 1,
-        Choice  = Sequence + 1,
-        Star    = Choice + 1,
-        Plus    = Star + 1,
-        Questionmark    = Plus + 1,
-        LastSubNodeType = Questionmark + 1
-    }
-
-    internal abstract class BaseConfigHandler
-    {
-        // These delegates must be at the very start of the object
-        // This is necessary because unmanaged code takes a dependency on this layout
-        // Any changes made to this must be reflected in ConfigHelper.h in ConfigFactory class
-        protected Delegate[] eventCallbacks;
-        public BaseConfigHandler()
-        {
-            InitializeCallbacks();
-        }
-        private void InitializeCallbacks()
-        {
-            if (eventCallbacks == null)
-            {
-                eventCallbacks = new Delegate[6];
-                eventCallbacks[0] = new NotifyEventCallback(this.NotifyEvent);
-                eventCallbacks[1] = new BeginChildrenCallback(this.BeginChildren);
-                eventCallbacks[2] = new EndChildrenCallback(this.EndChildren);
-                eventCallbacks[3] = new ErrorCallback(this.Error);
-                eventCallbacks[4] = new CreateNodeCallback(this.CreateNode);
-                eventCallbacks[5] = new CreateAttributeCallback(this.CreateAttribute);
-            }
-        }
-
-        private delegate void NotifyEventCallback(ConfigEvents nEvent);
-        public abstract void NotifyEvent(ConfigEvents nEvent);
-
-        private delegate void BeginChildrenCallback(int size,
-                           ConfigNodeSubType subType,
-                           ConfigNodeType nType,
-                           int terminal,
-                           [MarshalAs(UnmanagedType.LPWStr)] String text,
-                           int textLength,
-                           int prefixLength);
-        public abstract void BeginChildren(int size,
-                           ConfigNodeSubType subType,
-                           ConfigNodeType nType,
-                           int terminal,
-                           [MarshalAs(UnmanagedType.LPWStr)] String text,
-                           int textLength,
-                           int prefixLength);
-
-        private delegate void EndChildrenCallback(int fEmpty,
-                         int size,
-                         ConfigNodeSubType subType,
-                         ConfigNodeType nType,
-                         int terminal,
-                         [MarshalAs(UnmanagedType.LPWStr)] String text,
-                         int textLength,
-                         int prefixLength);
-        public abstract void EndChildren(int fEmpty,
-                         int size,
-                         ConfigNodeSubType subType,
-                         ConfigNodeType nType,
-                         int terminal,
-                         [MarshalAs(UnmanagedType.LPWStr)] String text,
-                         int textLength,
-                         int prefixLength);
-
-        private delegate void ErrorCallback(int size,
-                   ConfigNodeSubType subType,
-                   ConfigNodeType nType,
-                   int terminal,
-                   [MarshalAs(UnmanagedType.LPWStr)]String text,
-                   int textLength,
-                   int prefixLength);
-        public abstract void Error(int size,
-                   ConfigNodeSubType subType,
-                   ConfigNodeType nType,
-                   int terminal,
-                   [MarshalAs(UnmanagedType.LPWStr)]String text,
-                   int textLength,
-                   int prefixLength);
-
-        private delegate void CreateNodeCallback(int size,
-                        ConfigNodeSubType subType,
-                        ConfigNodeType nType,
-                        int terminal,
-                        [MarshalAs(UnmanagedType.LPWStr)]String text,
-                        int textLength,
-                        int prefixLength);
-        public abstract void CreateNode(int size,
-                        ConfigNodeSubType subType,
-                        ConfigNodeType nType,
-                        int terminal,
-                        [MarshalAs(UnmanagedType.LPWStr)]String text,
-                        int textLength,
-                        int prefixLength);
-
-        private delegate void CreateAttributeCallback(int size,
-                             ConfigNodeSubType subType,
-                             ConfigNodeType nType,
-                             int terminal,
-                             [MarshalAs(UnmanagedType.LPWStr)]String text,
-                             int textLength,
-                             int prefixLength);
-        public abstract void CreateAttribute(int size,
-                             ConfigNodeSubType subType,
-                             ConfigNodeType nType,
-                             int terminal,
-                             [MarshalAs(UnmanagedType.LPWStr)]String text,
-                             int textLength,
-                             int prefixLength);
-
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        internal extern void RunParser(String fileName);
-    }
-
-    // Class used to build a DOM like tree of parsed XML
-    internal class ConfigTreeParser : BaseConfigHandler
-    {
-        ConfigNode rootNode = null;
-        ConfigNode currentNode = null;
-        String fileName = null;
-        int attributeEntry;
-        String key = null;
-        String [] treeRootPath = null; // element to start tree
-        bool parsing = false;
-        int depth = 0;
-        int pathDepth = 0;
-        int searchDepth = 0;
-        bool bNoSearchPath = false;
-
-        // Track state for error message formatting
-        String lastProcessed = null;
-        bool lastProcessedEndElement;
-
-
-        // NOTE: This parser takes a path eg. /configuration/system.runtime.remoting
-        // and will return a node which matches this.
-        internal ConfigNode Parse(String fileName, String configPath)      
-        {
-            return Parse(fileName, configPath, false);
-        }
-
-        internal ConfigNode Parse(String fileName, String configPath, bool skipSecurityStuff)
-        {
-            if (fileName == null)
-                throw new ArgumentNullException(nameof(fileName));
-            Contract.EndContractBlock();
-            this.fileName = fileName;
-            if (configPath[0] == '/'){
-                treeRootPath = configPath.Substring(1).Split('/');
-                pathDepth = treeRootPath.Length - 1;
-                bNoSearchPath = false;
-            }
-            else{
-                treeRootPath = new String[1];
-                treeRootPath[0] = configPath;
-                bNoSearchPath = true;
-            }
-
-            if (!skipSecurityStuff) {
-                (new FileIOPermission(FileIOPermissionAccess.Read, Path.GetFullPath(fileName))).Demand();
-            }
-#pragma warning disable 618
-            (new SecurityPermission(SecurityPermissionFlag.UnmanagedCode)).Assert();
-#pragma warning restore 618
-
-            try
-            {
-                RunParser(fileName);
-            }
-            catch(FileNotFoundException) {
-                throw; // Pass these through unadulterated.
-            }
-            catch(DirectoryNotFoundException) {
-                throw; // Pass these through unadulterated.
-            }
-            catch(UnauthorizedAccessException) {
-                throw;
-            }
-            catch(FileLoadException) {
-                throw;
-            }
-            catch(Exception inner) {
-                String message = GetInvalidSyntaxMessage();
-                // Neither Exception nor ApplicationException are the "right" exceptions here.
-                // Desktop throws ApplicationException for backwards compatibility.
-                // On Silverlight we don't have ApplicationException, so fall back to Exception.
-                throw new Exception(message, inner);
-            }
-            return rootNode;
-        }
-
-        public override void NotifyEvent(ConfigEvents nEvent)
-        {
-            BCLDebug.Trace("REMOTE", "NotifyEvent "+((Enum)nEvent).ToString()+"\n");
-        }
-
-        public override void BeginChildren(int size,
-                                  ConfigNodeSubType subType, 
-                                  ConfigNodeType nType,                                   
-                                  int terminal, 
-                                  [MarshalAs(UnmanagedType.LPWStr)] String text, 
-                                  int textLength, 
-                                  int prefixLength)
-        {
-            //Trace("BeginChildren",size,subType,nType,terminal,text,textLength,prefixLength,0);
-            if (!parsing &&
-                (!bNoSearchPath 
-                 && depth == (searchDepth + 1)
-                 && String.Compare(text, treeRootPath[searchDepth], StringComparison.Ordinal) == 0))
-            {
-                searchDepth++;
-            }
-        }
-
-        public override void EndChildren(int fEmpty, 
-                                int size,
-                                ConfigNodeSubType subType, 
-                                ConfigNodeType nType,                               
-                                int terminal, 
-                                [MarshalAs(UnmanagedType.LPWStr)] String text, 
-                                int textLength, 
-                                int prefixLength)
-        {
-            lastProcessed = text;
-            lastProcessedEndElement = true;
-            if (parsing)
-            {
-                //Trace("EndChildren",size,subType,nType,terminal,text,textLength,prefixLength,fEmpty);
-
-                if (currentNode == rootNode)
-                {
-                    // End of section of tree which is parsed
-                    parsing = false;
-                }
-
-                currentNode = currentNode.Parent;
-            }
-            else if (nType == ConfigNodeType.Element){
-                if(depth == searchDepth && String.Compare(text, treeRootPath[searchDepth - 1], StringComparison.Ordinal) == 0)
-                {
-                    searchDepth--;
-                    depth--;
-                }
-                else 
-                    depth--;
-            }            
-        }
-
-        public override void Error(int size,
-                          ConfigNodeSubType subType, 
-                          ConfigNodeType nType, 
-                          int terminal, 
-                          [MarshalAs(UnmanagedType.LPWStr)]String text, 
-                          int textLength, 
-                          int prefixLength)
-        {
-            //Trace("Error",size,subType,nType,terminal,text,textLength,prefixLength,0);                        
-        }
-
-        public override void CreateNode(int size,
-                               ConfigNodeSubType subType, 
-                               ConfigNodeType nType, 
-                               int terminal, 
-                               [MarshalAs(UnmanagedType.LPWStr)]String text, 
-                               int textLength, 
-                               int prefixLength)
-        {
-            //Trace("CreateNode",size,subType,nType,terminal,text,textLength,prefixLength,0);
-
-            if (nType == ConfigNodeType.Element)
-            {
-                // New Node
-                lastProcessed = text;
-                lastProcessedEndElement = false;
-
-                if (parsing  
-                    || (bNoSearchPath &&
-                        String.Compare(text, treeRootPath[0], StringComparison.OrdinalIgnoreCase) == 0)
-                    || (depth == searchDepth && searchDepth == pathDepth && 
-                        String.Compare(text, treeRootPath[pathDepth], StringComparison.OrdinalIgnoreCase) == 0 ))
-                    {
-                        parsing = true;
-                        
-                        ConfigNode parentNode = currentNode;
-                        currentNode = new ConfigNode(text, parentNode);
-                        if (rootNode == null)
-                            rootNode = currentNode;
-                        else
-                            parentNode.AddChild(currentNode);
-                    }
-                else 
-                    depth++;
-            }
-            else if (nType == ConfigNodeType.PCData)
-            {
-                // Data node
-                if (currentNode != null)
-                {
-                    currentNode.Value = text;
-                }
-            }
-        }
-
-        public override void CreateAttribute(int size,
-                                    ConfigNodeSubType subType, 
-                                    ConfigNodeType nType,                                   
-                                    int terminal, 
-                                    [MarshalAs(UnmanagedType.LPWStr)]String text, 
-                                    int textLength, 
-                                    int prefixLength)
-        {
-            //Trace("CreateAttribute",size,subType,nType,terminal,text,textLength,prefixLength,0);
-            if (parsing)
-            {
-                // if the value of the attribute is null, the parser doesn't come back, so need to store the attribute when the
-                // attribute name is encountered
-                if (nType == ConfigNodeType.Attribute)
-                {
-                    attributeEntry = currentNode.AddAttribute(text, "");
-                    key = text;
-                }
-                else if (nType == ConfigNodeType.PCData)
-                {
-                    currentNode.ReplaceAttribute(attributeEntry, key, text);
-                }
-                else
-                {
-                    String message = GetInvalidSyntaxMessage();
-                    // Neither Exception nor ApplicationException are the "right" exceptions here.
-                    // Desktop throws ApplicationException for backwards compatibility.
-                    // On Silverlight we don't have ApplicationException, so fall back to Exception.
-                    throw new Exception(message);
-                }
-            }
-        }
-
-#if _DEBUG
-        [System.Diagnostics.Conditional("_LOGGING")]        
-        private void Trace(String name,
-                           int size,
-                           ConfigNodeSubType subType, 
-                           ConfigNodeType nType,                           
-                           int terminal, 
-                           [MarshalAs(UnmanagedType.LPWStr)]String text, 
-                           int textLength, 
-                           int prefixLength, int fEmpty)
-        {
-
-            BCLDebug.Trace("REMOTE","Node "+name);
-            BCLDebug.Trace("REMOTE","text "+text);
-            BCLDebug.Trace("REMOTE","textLength "+textLength);          
-            BCLDebug.Trace("REMOTE","size "+size);
-            BCLDebug.Trace("REMOTE","subType "+((Enum)subType).ToString());
-            BCLDebug.Trace("REMOTE","nType "+((Enum)nType).ToString());
-            BCLDebug.Trace("REMOTE","terminal "+terminal);
-            BCLDebug.Trace("REMOTE","prefixLength "+prefixLength);          
-            BCLDebug.Trace("REMOTE","fEmpty "+fEmpty+"\n");
-        }
-#endif
-
-        private String GetInvalidSyntaxMessage()
-        {
-            String lastProcessedTag = null;
-
-            if (lastProcessed != null)
-                lastProcessedTag = (lastProcessedEndElement ? "</" : "<") + lastProcessed + ">";
-
-            return Environment.GetResourceString("XML_Syntax_InvalidSyntaxInFile", fileName, lastProcessedTag);
-        }
-    }
-
-    // Node in Tree produced by ConfigTreeParser
-    internal class ConfigNode
-    {
-        String m_name = null;
-        String m_value = null;
-        ConfigNode m_parent = null;
-        List<ConfigNode> m_children = new List<ConfigNode>(5);
-        List<DictionaryEntry> m_attributes = new List<DictionaryEntry>(5);
-
-        internal ConfigNode(String name, ConfigNode parent)
-        {
-            m_name = name;
-            m_parent = parent;
-        }
-
-        internal String Name
-        {
-            get {return m_name;}
-        }
-
-        internal String Value
-        {
-            get {return m_value;}
-            set {m_value = value;}
-        }
-
-        internal ConfigNode Parent
-        {
-            get {return m_parent;}
-        }
-
-        internal List<ConfigNode> Children
-        {
-            get {return m_children;}
-        }
-
-        internal List<DictionaryEntry> Attributes
-        {
-            get {return m_attributes;}
-        }
-
-        internal void AddChild(ConfigNode child)
-        {
-            child.m_parent = this;
-            m_children.Add(child);
-        }
-
-        internal int AddAttribute(String key, String value)
-        {
-            m_attributes.Add(new DictionaryEntry(key, value));
-            return m_attributes.Count-1;
-        }
-
-        internal void ReplaceAttribute(int index, String key, String value)
-        {
-            m_attributes[index] = new DictionaryEntry(key, value);
-        }
-
-#if _DEBUG
-        [System.Diagnostics.Conditional("_LOGGING")]
-        internal void Trace()
-        {
-            BCLDebug.Trace("REMOTE","************ConfigNode************");
-            BCLDebug.Trace("REMOTE","Name = "+m_name);
-            if (m_value != null)
-                BCLDebug.Trace("REMOTE","Value = "+m_value);
-            if (m_parent != null)
-                BCLDebug.Trace("REMOTE","Parent = "+m_parent.Name);
-            for (int i=0; i<m_attributes.Count; i++)
-            {
-                DictionaryEntry de = (DictionaryEntry)m_attributes[i];
-                BCLDebug.Trace("REMOTE","Key = "+de.Key+"   Value = "+de.Value);
-            }
-
-            for (int i=0; i<m_children.Count; i++)
-            {
-                ((ConfigNode)m_children[i]).Trace();
-            }
-        }
-#endif
-    }
-}
-
-
-
-
-
-
diff --git a/src/mscorlib/src/System/Char.cs b/src/mscorlib/src/System/Char.cs
index b9c9305932..7fe1c08715 100644
--- a/src/mscorlib/src/System/Char.cs
+++ b/src/mscorlib/src/System/Char.cs
@@ -21,7 +21,6 @@ namespace System {
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
 
-[System.Runtime.InteropServices.ComVisible(true)]
 [Serializable]
 [System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)] public struct Char : IComparable, IConvertible
         , IComparable<Char>, IEquatable<Char>
diff --git a/src/mscorlib/src/System/CharEnumerator.cs b/src/mscorlib/src/System/CharEnumerator.cs
index d25294c7e2..689ed7e488 100644
--- a/src/mscorlib/src/System/CharEnumerator.cs
+++ b/src/mscorlib/src/System/CharEnumerator.cs
@@ -11,65 +11,71 @@
 **
 **
 ============================================================*/
-namespace System {
 
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Diagnostics.Contracts;
+using System.Collections;
+using System.Collections.Generic;
 
-[System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable] 
-    public sealed class CharEnumerator : IEnumerator, ICloneable, IEnumerator<char>, IDisposable {
-        private String str;
-        private int index;
-        private char currentElement;
+namespace System
+{
+    public sealed class CharEnumerator : IEnumerator, IEnumerator<char>, IDisposable, ICloneable
+    {
+        private String _str;
+        private int _index;
+        private char _currentElement;
 
-        internal CharEnumerator(String str) {
-            Contract.Requires(str != null);
-            this.str = str;
-            this.index = -1;
+        internal CharEnumerator(String str)
+        {
+            _str = str;
+            _index = -1;
         }
 
-        public Object Clone() {
+        public object Clone()
+        {
             return MemberwiseClone();
         }
-    
-        public bool MoveNext() {
-            if (index < (str.Length-1)) {
-                index++;
-                currentElement = str[index];
+
+        public bool MoveNext()
+        {
+            if (_index < (_str.Length - 1))
+            {
+                _index++;
+                _currentElement = _str[_index];
                 return true;
             }
             else
-                index = str.Length;
+                _index = _str.Length;
             return false;
-
         }
 
-        public void Dispose() {
-            if (str != null)
-                index = str.Length;
-            str = null;
+        public void Dispose()
+        {
+            if (_str != null)
+                _index = _str.Length;
+            _str = null;
         }
-    
+
         /// <internalonly/>
-        Object IEnumerator.Current {
+        Object IEnumerator.Current
+        {
             get { return Current; }
         }
-    
-        public char Current {
-            get {
-                if (index == -1)
-                    throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumNotStarted));
-                if (index >= str.Length)
-                    throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumEnded));                                            
-                return currentElement;
+
+        public char Current
+        {
+            get
+            {
+                if (_index == -1)
+                    throw new InvalidOperationException(SR.InvalidOperation_EnumNotStarted);
+                if (_index >= _str.Length)
+                    throw new InvalidOperationException(SR.InvalidOperation_EnumEnded);
+                return _currentElement;
             }
         }
 
-        public void Reset() {
-            currentElement = (char)0;
-            index = -1;
+        public void Reset()
+        {
+            _currentElement = (char)0;
+            _index = -1;
         }
     }
 }
diff --git a/src/mscorlib/src/System/Collections/ArrayList.cs b/src/mscorlib/src/System/Collections/ArrayList.cs
index e7f121370b..53746e224e 100644
--- a/src/mscorlib/src/System/Collections/ArrayList.cs
+++ b/src/mscorlib/src/System/Collections/ArrayList.cs
@@ -18,7 +18,6 @@ namespace System.Collections {
     using System;
     using System.Runtime;
     using System.Security;
-    using System.Security.Permissions;
     using System.Diagnostics;
     using System.Runtime.CompilerServices;
     using System.Runtime.Serialization;
@@ -35,8 +34,7 @@ namespace System.Collections {
     [DebuggerTypeProxy(typeof(System.Collections.ArrayList.ArrayListDebugView))]   
     [DebuggerDisplay("Count = {Count}")]
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public class ArrayList : IList, ICloneable
+    internal class ArrayList : IList, ICloneable
     {
         private Object[] _items;
         [ContractPublicPropertyName("Count")]
@@ -47,12 +45,6 @@ namespace System.Collections {
         
         private const int _defaultCapacity = 4;
         private static readonly Object[] emptyArray = EmptyArray<Object>.Value; 
-    
-        // Note: this constructor is a bogus constructor that does nothing
-        // and is for use only with SyncArrayList.
-        internal ArrayList( bool trash )
-        {
-        }
 
         // Constructs a ArrayList. The list is initially empty and has a capacity
         // of zero. Upon adding the first element to the list the capacity is
@@ -175,22 +167,6 @@ namespace System.Collections {
                 _version++;
             }
         }
-    
-        // Creates a ArrayList wrapper for a particular IList.  This does not
-        // copy the contents of the IList, but only wraps the ILIst.  So any
-        // changes to the underlying list will affect the ArrayList.  This would
-        // be useful if you want to Reverse a subrange of an IList, or want to
-        // use a generic BinarySearch or Sort method without implementing one yourself.
-        // However, since these methods are generic, the performance may not be
-        // nearly as good for some operations as they would be on the IList itself.
-        //
-        public static ArrayList Adapter(IList list) {
-            if (list==null)
-                throw new ArgumentNullException(nameof(list));
-            Contract.Ensures(Contract.Result<ArrayList>() != null);
-            Contract.EndContractBlock();
-            return new IListWrapper(list);
-        }
         
         // Adds the given object to the end of this list. The size of the list is
         // increased by one. If required, the capacity of the list is doubled
@@ -211,52 +187,6 @@ namespace System.Collections {
         public virtual void AddRange(ICollection c) {
             InsertRange(_size, c);
         }
-    
-        // Searches a section of the list for a given element using a binary search
-        // algorithm. Elements of the list are compared to the search value using
-        // the given IComparer interface. If comparer is null, elements of
-        // the list are compared to the search value using the IComparable
-        // interface, which in that case must be implemented by all elements of the
-        // list and the given search value. This method assumes that the given
-        // section of the list is already sorted; if this is not the case, the
-        // result will be incorrect.
-        //
-        // The method returns the index of the given value in the list. If the
-        // list does not contain the given value, the method returns a negative
-        // integer. The bitwise complement operator (~) can be applied to a
-        // negative result to produce the index of the first element (if any) that
-        // is larger than the given search value. This is also the index at which
-        // the search value should be inserted into the list in order for the list
-        // to remain sorted.
-        // 
-        // The method uses the Array.BinarySearch method to perform the
-        // search.
-        // 
-        public virtual int BinarySearch(int index, int count, Object value, IComparer comparer) {
-            if (index < 0)
-                throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            if (count < 0)
-                throw new ArgumentOutOfRangeException(nameof(count), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            if (_size - index < count)
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-            Contract.Ensures(Contract.Result<int>() < Count);
-            Contract.Ensures(Contract.Result<int>() < index + count);
-            Contract.EndContractBlock();
-    
-            return Array.BinarySearch((Array)_items, index, count, value, comparer);
-        }
-    
-        public virtual int BinarySearch(Object value)
-        {
-            Contract.Ensures(Contract.Result<int>() < Count);
-            return BinarySearch(0, Count, value, null);
-        }
-
-        public virtual int BinarySearch(Object value, IComparer comparer)
-        {
-            Contract.Ensures(Contract.Result<int>() < Count);
-            return BinarySearch(0, Count, value, comparer);
-        }
 
     
         // Clears the contents of ArrayList.
@@ -301,13 +231,6 @@ namespace System.Collections {
                 return false;
             }
         }
-    
-        // Copies this ArrayList into array, which must be of a 
-        // compatible array type.  
-        //
-        public virtual void CopyTo(Array array) {
-            CopyTo(array, 0);
-        }
 
         // Copies this ArrayList into array, which must be of a 
         // compatible array type.  
@@ -319,20 +242,6 @@ namespace System.Collections {
             // Delegate rest of error checking to Array.Copy.
             Array.Copy(_items, 0, array, arrayIndex, _size);
         }
-    
-        // Copies a section of this list to the given array at the given index.
-        // 
-        // The method uses the Array.Copy method to copy the elements.
-        // 
-        public virtual void CopyTo(int index, Array array, int arrayIndex, int count) {
-            if (_size - index < count)
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-            if ((array != null) && (array.Rank != 1))
-                throw new ArgumentException(Environment.GetResourceString("Arg_RankMultiDimNotSupported"));
-            Contract.EndContractBlock();
-            // Delegate rest of error checking to Array.Copy.
-            Array.Copy(_items, index, array, arrayIndex, count);
-        }
 
         // Ensures that the capacity of this list is at least the given minimum
         // value. If the currect capacity of the list is less than min, the
@@ -349,28 +258,6 @@ namespace System.Collections {
             }
         }
     
-        // Returns a list wrapper that is fixed at the current size.  Operations
-        // that add or remove items will fail, however, replacing items is allowed.
-        //
-        public static IList FixedSize(IList list) {
-            if (list==null)
-                throw new ArgumentNullException(nameof(list));
-            Contract.Ensures(Contract.Result<IList>() != null);
-            Contract.EndContractBlock();
-            return new FixedSizeList(list);
-        }
-
-        // Returns a list wrapper that is fixed at the current size.  Operations
-        // that add or remove items will fail, however, replacing items is allowed.
-        //
-        public static ArrayList FixedSize(ArrayList list) {
-            if (list==null)
-                throw new ArgumentNullException(nameof(list));
-            Contract.Ensures(Contract.Result<ArrayList>() != null);
-            Contract.EndContractBlock();
-            return new FixedSizeArrayList(list);
-        }
-    
         // Returns an enumerator for this list with the given
         // permission for removal of elements. If modifications made to the list 
         // while an enumeration is in progress, the MoveNext and 
@@ -381,24 +268,6 @@ namespace System.Collections {
             return new ArrayListEnumeratorSimple(this);
         }
     
-        // Returns an enumerator for a section of this list with the given
-        // permission for removal of elements. If modifications made to the list 
-        // while an enumeration is in progress, the MoveNext and 
-        // GetObject methods of the enumerator will throw an exception.
-        //
-        public virtual IEnumerator GetEnumerator(int index, int count) {
-            if (index < 0)
-                throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            if (count < 0)
-                throw new ArgumentOutOfRangeException(nameof(count), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            if (_size - index < count)
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-            Contract.Ensures(Contract.Result<IEnumerator>() != null);
-            Contract.EndContractBlock();
-    
-            return new ArrayListEnumerator(this, index, count);
-        }
-    
         // Returns the index of the first occurrence of a given value in a range of
         // this list. The list is searched forwards from beginning to end.
         // The elements of the list are compared to the given value using the
@@ -412,41 +281,6 @@ namespace System.Collections {
             return Array.IndexOf((Array)_items, value, 0, _size);
         }
     
-        // Returns the index of the first occurrence of a given value in a range of
-        // this list. The list is searched forwards, starting at index
-        // startIndex and ending at count number of elements. The
-        // elements of the list are compared to the given value using the
-        // Object.Equals method.
-        // 
-        // This method uses the Array.IndexOf method to perform the
-        // search.
-        // 
-        public virtual int IndexOf(Object value, int startIndex) {
-            if (startIndex > _size)
-                throw new ArgumentOutOfRangeException(nameof(startIndex), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-            Contract.Ensures(Contract.Result<int>() < Count);
-            Contract.EndContractBlock();
-            return Array.IndexOf((Array)_items, value, startIndex, _size - startIndex);
-        }
-
-        // Returns the index of the first occurrence of a given value in a range of
-        // this list. The list is searched forwards, starting at index
-        // startIndex and upto count number of elements. The
-        // elements of the list are compared to the given value using the
-        // Object.Equals method.
-        // 
-        // This method uses the Array.IndexOf method to perform the
-        // search.
-        // 
-        public virtual int IndexOf(Object value, int startIndex, int count) {
-            if (startIndex > _size)
-                throw new ArgumentOutOfRangeException(nameof(startIndex), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-            if (count <0 || startIndex > _size - count) throw new ArgumentOutOfRangeException(nameof(count), Environment.GetResourceString("ArgumentOutOfRange_Count"));
-            Contract.Ensures(Contract.Result<int>() < Count);
-            Contract.EndContractBlock();
-            return Array.IndexOf((Array)_items, value, startIndex, count);
-        }
-    
         // Inserts an element into this list at a given index. The size of the list
         // is increased by one. If required, the capacity of the list is doubled
         // before inserting the new element.
@@ -494,62 +328,6 @@ namespace System.Collections {
             }
         }
     
-        // Returns the index of the last occurrence of a given value in a range of
-        // this list. The list is searched backwards, starting at the end 
-        // and ending at the first element in the list. The elements of the list 
-        // are compared to the given value using the Object.Equals method.
-        // 
-        // This method uses the Array.LastIndexOf method to perform the
-        // search.
-        // 
-        public virtual int LastIndexOf(Object value)
-        {
-            Contract.Ensures(Contract.Result<int>() < _size);
-            return LastIndexOf(value, _size - 1, _size);
-        }
-
-        // Returns the index of the last occurrence of a given value in a range of
-        // this list. The list is searched backwards, starting at index
-        // startIndex and ending at the first element in the list. The 
-        // elements of the list are compared to the given value using the 
-        // Object.Equals method.
-        // 
-        // This method uses the Array.LastIndexOf method to perform the
-        // search.
-        // 
-        public virtual int LastIndexOf(Object value, int startIndex)
-        {
-            if (startIndex >= _size)
-                throw new ArgumentOutOfRangeException(nameof(startIndex), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-            Contract.Ensures(Contract.Result<int>() < Count);
-            Contract.EndContractBlock();
-            return LastIndexOf(value, startIndex, startIndex + 1);
-        }
-
-        // Returns the index of the last occurrence of a given value in a range of
-        // this list. The list is searched backwards, starting at index
-        // startIndex and upto count elements. The elements of
-        // the list are compared to the given value using the Object.Equals
-        // method.
-        // 
-        // This method uses the Array.LastIndexOf method to perform the
-        // search.
-        // 
-        public virtual int LastIndexOf(Object value, int startIndex, int count) {
-            if (Count != 0 && (startIndex < 0 || count < 0))
-                throw new ArgumentOutOfRangeException((startIndex<0 ? nameof(startIndex) : nameof(count)), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            Contract.Ensures(Contract.Result<int>() < Count);
-            Contract.EndContractBlock();
-
-            if (_size == 0)  // Special case for an empty list
-                return -1;
-
-            if (startIndex >= _size || count > startIndex + 1) 
-                throw new ArgumentOutOfRangeException((startIndex>=_size ? nameof(startIndex) : nameof(count)), Environment.GetResourceString("ArgumentOutOfRange_BiggerThanCollection"));
-
-            return Array.LastIndexOf((Array)_items, value, startIndex, count);
-        }
-    
         // Returns a read-only IList wrapper for the given IList.
         //
         [FriendAccessAllowed]
@@ -560,16 +338,6 @@ namespace System.Collections {
             Contract.EndContractBlock();
             return new ReadOnlyList(list);
         }
-
-        // Returns a read-only ArrayList wrapper for the given ArrayList.
-        //
-        public static ArrayList ReadOnly(ArrayList list) {
-            if (list==null)
-                throw new ArgumentNullException(nameof(list));
-            Contract.Ensures(Contract.Result<ArrayList>() != null);
-            Contract.EndContractBlock();
-            return new ReadOnlyArrayList(list);
-        }
     
         // Removes the element at the given index. The size of the list is
         // decreased by one.
@@ -600,159 +368,6 @@ namespace System.Collections {
             _version++;
         }
     
-        // Removes a range of elements from this list.
-        // 
-        public virtual void RemoveRange(int index, int count) {
-            if (index < 0)
-                throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            if (count < 0)
-                throw new ArgumentOutOfRangeException(nameof(count), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            if (_size - index < count)
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-            Contract.Ensures(Count >= 0);
-            //Contract.Ensures(Count == Contract.OldValue(Count) - count);
-            Contract.EndContractBlock();
-    
-            if (count > 0) {
-                int i = _size;
-                _size -= count;
-                if (index < _size) {
-                    Array.Copy(_items, index + count, _items, index, _size - index);
-                }
-                while (i > _size) _items[--i] = null;
-                _version++;
-            }
-        }
-    
-        // Returns an IList that contains count copies of value.
-        //
-        public static ArrayList Repeat(Object value, int count) {
-            if (count < 0)
-                throw new ArgumentOutOfRangeException(nameof(count),Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            Contract.Ensures(Contract.Result<ArrayList>() != null);
-            Contract.EndContractBlock();
-
-            ArrayList list = new ArrayList((count>_defaultCapacity)?count:_defaultCapacity);
-            for(int i=0; i<count; i++)
-                list.Add(value);
-            return list;
-        }
-
-        // Reverses the elements in this list.
-        public virtual void Reverse() {
-            Reverse(0, Count);
-        }
-    
-        // Reverses the elements in a range of this list. Following a call to this
-        // method, an element in the range given by index and count
-        // which was previously located at index i will now be located at
-        // index index + (index + count - i - 1).
-        // 
-        // This method uses the Array.Reverse method to reverse the
-        // elements.
-        // 
-        public virtual void Reverse(int index, int count) {
-            if (index < 0)
-                throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            if (count < 0)
-                throw new ArgumentOutOfRangeException(nameof(count), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            if (_size - index < count)
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-            Contract.EndContractBlock();
-            Array.Reverse(_items, index, count);
-            _version++;
-        }
-    
-        // Sets the elements starting at the given index to the elements of the
-        // given collection.
-        //
-        public virtual void SetRange(int index, ICollection c) {
-            if (c==null) throw new ArgumentNullException(nameof(c), Environment.GetResourceString("ArgumentNull_Collection"));
-            Contract.EndContractBlock();
-            int count = c.Count;
-            if (index < 0 || index > _size - count) throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-            
-            if (count > 0) {
-                c.CopyTo(_items, index);
-                _version++;
-            }
-        }
-    
-        public virtual ArrayList GetRange(int index, int count) {
-            if (index < 0 || count < 0)
-                throw new ArgumentOutOfRangeException((index<0 ? nameof(index) : nameof(count)), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            if (_size - index < count)
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-            Contract.Ensures(Contract.Result<ArrayList>() != null);
-            Contract.EndContractBlock();
-            return new Range(this,index, count);
-        }
-
-        // Sorts the elements in this list.  Uses the default comparer and 
-        // Array.Sort.
-        public virtual void Sort()
-        {
-            Sort(0, Count, Comparer.Default);
-        }
-
-        // Sorts the elements in this list.  Uses Array.Sort with the
-        // provided comparer.
-        public virtual void Sort(IComparer comparer)
-        {
-            Sort(0, Count, comparer);
-        }
-
-        // Sorts the elements in a section of this list. The sort compares the
-        // elements to each other using the given IComparer interface. If
-        // comparer is null, the elements are compared to each other using
-        // the IComparable interface, which in that case must be implemented by all
-        // elements of the list.
-        // 
-        // This method uses the Array.Sort method to sort the elements.
-        // 
-        public virtual void Sort(int index, int count, IComparer comparer) {
-            if (index < 0)
-                throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            if (count < 0)
-                throw new ArgumentOutOfRangeException(nameof(count), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            if (_size - index < count)
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-            Contract.EndContractBlock();
-            
-            Array.Sort(_items, index, count, comparer);
-            _version++;
-        }
-    
-        // Returns a thread-safe wrapper around an IList.
-        //
-        public static IList Synchronized(IList list) {
-            if (list==null)
-                throw new ArgumentNullException(nameof(list));
-            Contract.Ensures(Contract.Result<IList>() != null);
-            Contract.EndContractBlock();
-            return new SyncIList(list);
-        }
-    
-        // Returns a thread-safe wrapper around a ArrayList.
-        //
-        public static ArrayList Synchronized(ArrayList list) {
-            if (list==null)
-                throw new ArgumentNullException(nameof(list));
-            Contract.Ensures(Contract.Result<ArrayList>() != null);
-            Contract.EndContractBlock();
-            return new SyncArrayList(list);
-        }
-    
-        // ToArray returns a new Object array containing the contents of the ArrayList.
-        // This requires copying the ArrayList, which is an O(n) operation.
-        public virtual Object[] ToArray() {
-            Contract.Ensures(Contract.Result<Object[]>() != null);
-
-            Object[] array = new Object[_size];
-            Array.Copy(_items, 0, array, 0, _size);
-            return array;
-        }
-    
         // ToArray returns a new array of a particular type containing the contents 
         // of the ArrayList.  This requires copying the ArrayList and potentially
         // downcasting all elements.  This copy may fail and is an O(n) operation.
@@ -768,1070 +383,6 @@ namespace System.Collections {
             return array;
         }
     
-        // Sets the capacity of this list to the size of the list. This method can
-        // be used to minimize a list's memory overhead once it is known that no
-        // new elements will be added to the list. To completely clear a list and
-        // release all memory referenced by the list, execute the following
-        // statements:
-        // 
-        // list.Clear();
-        // list.TrimToSize();
-        // 
-        public virtual void TrimToSize() {
-            Capacity = _size;
-        }
-    
-    
-        // This class wraps an IList, exposing it as a ArrayList
-        // Note this requires reimplementing half of ArrayList...
-        [Serializable]
-        private class IListWrapper : ArrayList
-        {
-            private IList _list;
-            
-            internal IListWrapper(IList list) {
-                _list = list;
-                _version = 0; // list doesn't not contain a version number
-            }
-    
-             public override int Capacity {
-                get { return _list.Count; }
-                set {
-                    if (value < Count) throw new ArgumentOutOfRangeException(nameof(value), Environment.GetResourceString("ArgumentOutOfRange_SmallCapacity"));
-                    Contract.EndContractBlock();
-                }
-            }
-    
-            public override int Count { 
-                get { return _list.Count; }
-            }
-    
-            public override bool IsReadOnly { 
-                get { return _list.IsReadOnly; }
-            }
-
-            public override bool IsFixedSize {
-                get { return _list.IsFixedSize; }
-            }
-
-        
-            public override bool IsSynchronized { 
-                get { return _list.IsSynchronized; }
-            }
-            
-             public override Object this[int index] {
-                get {
-                    return _list[index];
-                }
-                set {
-                    _list[index] = value;
-                    _version++;
-                }
-            }
-    
-            public override Object SyncRoot {
-                get { return _list.SyncRoot; }
-            }
-            
-            public override int Add(Object obj) {
-                int i = _list.Add(obj);
-                _version++;
-                return i;
-            }
-        
-            public override void AddRange(ICollection c) {
-                InsertRange(Count, c);
-            }
-    
-            // Other overloads with automatically work
-            public override int BinarySearch(int index, int count, Object value, IComparer comparer) 
-            {
-                if (index < 0 || count < 0)
-                    throw new ArgumentOutOfRangeException((index<0 ? nameof(index) : nameof(count)), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-                if (this.Count - index < count)
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-                Contract.EndContractBlock();
-                if (comparer == null)
-                    comparer = Comparer.Default;
-                
-                int lo = index;
-                int hi = index + count - 1;
-                int mid;
-                while (lo <= hi) {
-                    mid = (lo+hi)/2;
-                    int r = comparer.Compare(value, _list[mid]);
-                    if (r == 0)
-                        return mid;
-                    if (r < 0)
-                        hi = mid-1;
-                    else 
-                        lo = mid+1;
-                }
-                // return bitwise complement of the first element greater than value.
-                // Since hi is less than lo now, ~lo is the correct item.
-                return ~lo;
-            }
-    
-            public override void Clear() {
-                // If _list is an array, it will support Clear method.
-                // We shouldn't allow clear operation on a FixedSized ArrayList
-                if(_list.IsFixedSize) {
-                    throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
-                }
-
-                _list.Clear();
-                _version++;
-            }
-    
-            public override Object Clone() {
-                // This does not do a shallow copy of _list into a ArrayList!
-                // This clones the IListWrapper, creating another wrapper class!
-                return new IListWrapper(_list);
-            }
-    
-            public override bool Contains(Object obj) {
-                return _list.Contains(obj);
-            }
-    
-            public override void CopyTo(Array array, int index) {
-                _list.CopyTo(array, index);
-            }
-    
-            public override void CopyTo(int index, Array array, int arrayIndex, int count) {
-                if (array==null)
-                    throw new ArgumentNullException(nameof(array));
-                if (index < 0 || arrayIndex < 0)
-                    throw new ArgumentOutOfRangeException((index < 0) ? nameof(index) : nameof(arrayIndex), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-                if( count < 0)
-                    throw new ArgumentOutOfRangeException( nameof(count) , Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));                 
-                if (array.Length - arrayIndex < count)
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-                if (array.Rank != 1)
-                    throw new ArgumentException(Environment.GetResourceString("Arg_RankMultiDimNotSupported"));
-                Contract.EndContractBlock();
-
-                if (_list.Count - index < count)
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-                
-                for(int i=index; i<index+count; i++)
-                    array.SetValue(_list[i], arrayIndex++);
-            }
-    
-            public override IEnumerator GetEnumerator() {
-                return _list.GetEnumerator();
-            }
-    
-            public override IEnumerator GetEnumerator(int index, int count) {
-                if (index < 0 || count < 0)
-                    throw new ArgumentOutOfRangeException((index<0 ? nameof(index) : nameof(count)), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-                Contract.EndContractBlock();
-                if (_list.Count - index < count)
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-    
-                return new IListWrapperEnumWrapper(this, index, count);
-            }
-    
-            public override int IndexOf(Object value) {
-                return _list.IndexOf(value);
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override int IndexOf(Object value, int startIndex) {
-                return IndexOf(value, startIndex, _list.Count - startIndex);
-            }
-    
-            public override int IndexOf(Object value, int startIndex, int count) {
-                if (startIndex < 0 || startIndex > this.Count) throw new ArgumentOutOfRangeException(nameof(startIndex), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-                if (count < 0 || startIndex > this.Count - count) throw new ArgumentOutOfRangeException(nameof(count), Environment.GetResourceString("ArgumentOutOfRange_Count"));
-                Contract.EndContractBlock();
-
-                int endIndex = startIndex + count;
-                if (value == null) {
-                    for(int i=startIndex; i<endIndex; i++)
-                        if (_list[i] == null)
-                            return i;
-                    return -1;
-                } else {
-                    for(int i=startIndex; i<endIndex; i++)
-                        if (_list[i] != null && _list[i].Equals(value))
-                            return i;
-                    return -1;
-                }
-            }
-    
-            public override void Insert(int index, Object obj) {
-                _list.Insert(index, obj);
-                _version++;
-            }
-    
-            public override void InsertRange(int index, ICollection c) {
-                if (c==null)
-                    throw new ArgumentNullException(nameof(c), Environment.GetResourceString("ArgumentNull_Collection"));
-                if (index < 0 || index > this.Count) throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-                Contract.EndContractBlock();
-
-                if( c.Count > 0) {
-                    ArrayList al = _list as ArrayList;
-                    if( al != null) { 
-                        // We need to special case ArrayList. 
-                        // When c is a range of _list, we need to handle this in a special way.
-                        // See ArrayList.InsertRange for details.
-                        al.InsertRange(index, c);    
-                    }
-                    else {
-                        IEnumerator en = c.GetEnumerator();
-                        while(en.MoveNext()) {
-                            _list.Insert(index++, en.Current);
-                        }                   
-                    }
-                    _version++;
-                }
-            }
-    
-            public override int LastIndexOf(Object value) {
-                 return LastIndexOf(value,_list.Count - 1, _list.Count);
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override int LastIndexOf(Object value, int startIndex) {
-                return LastIndexOf(value, startIndex, startIndex + 1);
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override int LastIndexOf(Object value, int startIndex, int count) {
-                if (_list.Count == 0)
-                    return -1;
-   
-                if (startIndex < 0 || startIndex >= _list.Count) throw new ArgumentOutOfRangeException(nameof(startIndex), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-                if (count < 0 || count > startIndex + 1) throw new ArgumentOutOfRangeException(nameof(count), Environment.GetResourceString("ArgumentOutOfRange_Count"));
-
-                int endIndex = startIndex - count + 1;
-                if (value == null) {
-                    for(int i=startIndex; i >= endIndex; i--)
-                        if (_list[i] == null)
-                            return i;
-                    return -1;
-                } else {
-                    for(int i=startIndex; i >= endIndex; i--)
-                        if (_list[i] != null && _list[i].Equals(value))
-                            return i;
-                    return -1;
-                }
-            }
-    
-            public override void Remove(Object value) {
-                int index = IndexOf(value);                
-                if (index >=0) 
-                    RemoveAt(index);
-            }
-    
-            public override void RemoveAt(int index) {
-                _list.RemoveAt(index);
-                _version++;
-            }
-    
-            public override void RemoveRange(int index, int count) {
-                if (index < 0 || count < 0)
-                    throw new ArgumentOutOfRangeException((index<0 ? nameof(index) : nameof(count)), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-                Contract.EndContractBlock();
-                if (_list.Count - index < count)
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-                
-                if( count > 0)    // be consistent with ArrayList
-                    _version++;
-
-                while(count > 0) {
-                    _list.RemoveAt(index);
-                    count--;
-                }
-            }
-    
-            public override void Reverse(int index, int count) {
-                if (index < 0 || count < 0)
-                    throw new ArgumentOutOfRangeException((index<0 ? nameof(index) : nameof(count)), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-                Contract.EndContractBlock();
-                if (_list.Count - index < count)
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-    
-                int i = index;
-                int j = index + count - 1;
-                while (i < j)
-                {
-                    Object tmp = _list[i];
-                    _list[i++] = _list[j];
-                    _list[j--] = tmp;
-                }
-                _version++;
-            }
-    
-            public override void SetRange(int index, ICollection c) {
-                if (c==null) {
-                    throw new ArgumentNullException(nameof(c), Environment.GetResourceString("ArgumentNull_Collection"));
-                }
-                Contract.EndContractBlock();
-
-                if (index < 0 || index > _list.Count - c.Count) {
-                    throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_Index"));            
-                }
-                   
-                if( c.Count > 0) {                                     
-                    IEnumerator en = c.GetEnumerator();
-                    while(en.MoveNext()) {
-                        _list[index++] = en.Current;
-                    }
-                    _version++;
-                }
-            }
-    
-            public override ArrayList GetRange(int index, int count) {
-                if (index < 0 || count < 0)
-                    throw new ArgumentOutOfRangeException((index<0 ? nameof(index) : nameof(count)), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-                Contract.EndContractBlock();
-                if (_list.Count - index < count)
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-                return new Range(this,index, count);
-            }
-
-            public override void Sort(int index, int count, IComparer comparer) {
-                if (index < 0 || count < 0)
-                    throw new ArgumentOutOfRangeException((index<0 ? nameof(index) : nameof(count)), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-                Contract.EndContractBlock();
-                if (_list.Count - index < count)
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-                
-                Object [] array = new Object[count];
-                CopyTo(index, array, 0, count);
-                Array.Sort(array, 0, count, comparer);
-                for(int i=0; i<count; i++)
-                    _list[i+index] = array[i];
-
-                _version++;
-            }
-
-
-            public override Object[] ToArray() {
-                Object[] array = new Object[Count];
-                _list.CopyTo(array, 0);
-                return array;
-            }
-
-            public override Array ToArray(Type type)
-            {
-                if (type==null)
-                    throw new ArgumentNullException(nameof(type));
-                Contract.EndContractBlock();
-                Array array = Array.UnsafeCreateInstance(type, _list.Count);
-                _list.CopyTo(array, 0);
-                return array;
-            }
-
-            public override void TrimToSize()
-            {
-                // Can't really do much here...
-            }
-    
-            // This is the enumerator for an IList that's been wrapped in another
-            // class that implements all of ArrayList's methods.
-            [Serializable]
-            private sealed class IListWrapperEnumWrapper : IEnumerator, ICloneable
-            {
-                private IEnumerator _en;
-                private int _remaining;
-                private int _initialStartIndex;   // for reset
-                private int _initialCount;        // for reset
-                private bool _firstCall;       // firstCall to MoveNext
-    
-                private IListWrapperEnumWrapper()
-                {
-                }
-
-                internal IListWrapperEnumWrapper(IListWrapper listWrapper, int startIndex, int count) 
-                {
-                    _en = listWrapper.GetEnumerator();
-                    _initialStartIndex = startIndex;
-                    _initialCount = count;
-                    while(startIndex-- > 0 && _en.MoveNext());
-                    _remaining = count;
-                    _firstCall = true;
-                }
-
-                public Object Clone() {
-                    // We must clone the underlying enumerator, I think.
-                    IListWrapperEnumWrapper clone = new IListWrapperEnumWrapper();
-                    clone._en = (IEnumerator) ((ICloneable)_en).Clone();
-                    clone._initialStartIndex = _initialStartIndex;
-                    clone._initialCount = _initialCount;
-                    clone._remaining = _remaining;
-                    clone._firstCall = _firstCall;
-                    return clone;
-                }
-
-                public bool MoveNext() {
-                    if (_firstCall) {
-                        _firstCall = false;
-                        return _remaining-- > 0 && _en.MoveNext();
-                    }
-                    if (_remaining < 0)
-                        return false;
-                    bool r = _en.MoveNext();
-                    return r && _remaining-- > 0;
-                }
-                
-                public Object Current {
-                    get {
-                        if (_firstCall)
-                            throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumNotStarted));
-                        if (_remaining < 0)
-                            throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumEnded));
-                        return _en.Current;
-                    }
-                }
-    
-                public void Reset() {
-                    _en.Reset();
-                    int startIndex = _initialStartIndex;
-                    while(startIndex-- > 0 && _en.MoveNext());
-                    _remaining = _initialCount;
-                    _firstCall = true;
-                }
-            }
-        }
-    
-    
-        [Serializable]
-        private class SyncArrayList : ArrayList
-        {
-            private ArrayList _list;
-            private Object _root;
-
-            internal SyncArrayList(ArrayList list)
-                : base( false )
-            {
-                _list = list;
-                _root = list.SyncRoot;
-            }
-    
-            public override int Capacity {
-                get {
-                    lock(_root) {
-                        return _list.Capacity;
-                    }
-                }
-                [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-                set {
-                    lock(_root) {
-                        _list.Capacity = value;
-                    }
-                }
-            }
-    
-            public override int Count { 
-                get { lock(_root) { return _list.Count; } }
-            }
-    
-            public override bool IsReadOnly {
-                get { return _list.IsReadOnly; }
-            }
-
-            public override bool IsFixedSize {
-                get { return _list.IsFixedSize; }
-            }
-
-                    
-            public override bool IsSynchronized { 
-                get { return true; }
-            }
-            
-             public override Object this[int index] {
-                get {
-                    lock(_root) {
-                        return _list[index];
-                    }
-                }
-                set {
-                    lock(_root) {
-                        _list[index] = value;
-                    }
-                }
-            }
-    
-            public override Object SyncRoot {
-                get { return _root; }
-            }
-    
-            public override int Add(Object value) {
-                lock(_root) {
-                    return _list.Add(value);
-                }
-            }
-    
-            public override void AddRange(ICollection c) {
-                lock(_root) {
-                    _list.AddRange(c);
-                }
-            }
-
-            public override int BinarySearch(Object value) {
-                lock(_root) {
-                    return _list.BinarySearch(value);
-                }
-            }
-
-            public override int BinarySearch(Object value, IComparer comparer) {
-                lock(_root) {
-                    return _list.BinarySearch(value, comparer);
-                }
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override int BinarySearch(int index, int count, Object value, IComparer comparer) {
-                lock(_root) {
-                    return _list.BinarySearch(index, count, value, comparer);
-                }
-            }
-
-            public override void Clear() {
-                lock(_root) {
-                    _list.Clear();
-                }
-            }
-
-            public override Object Clone() {
-                lock(_root) {
-                    return new SyncArrayList((ArrayList)_list.Clone());
-                }
-            }
-    
-            public override bool Contains(Object item) {
-                lock(_root) {
-                    return _list.Contains(item);
-                }
-            }
-    
-            public override void CopyTo(Array array) {
-                lock(_root) {
-                    _list.CopyTo(array);
-                }
-            }
-
-            public override void CopyTo(Array array, int index) {
-                lock(_root) {
-                    _list.CopyTo(array, index);
-                }
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override void CopyTo(int index, Array array, int arrayIndex, int count) {
-                lock(_root) {
-                    _list.CopyTo(index, array, arrayIndex, count);
-                }
-            }
-    
-            public override IEnumerator GetEnumerator() {
-                lock(_root) {
-                    return _list.GetEnumerator();
-                }
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override IEnumerator GetEnumerator(int index, int count) {
-                lock(_root) {
-                    return _list.GetEnumerator(index, count);
-                }
-            }
-    
-            public override int IndexOf(Object value) {
-                lock(_root) {
-                    return _list.IndexOf(value);
-                }
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override int IndexOf(Object value, int startIndex) {
-                lock(_root) {
-                    return _list.IndexOf(value, startIndex);
-                }
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override int IndexOf(Object value, int startIndex, int count) {
-                lock(_root) {
-                    return _list.IndexOf(value, startIndex, count);
-                }
-            }
-    
-            public override void Insert(int index, Object value) {
-                lock(_root) {
-                    _list.Insert(index, value);
-                }
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override void InsertRange(int index, ICollection c) {
-                lock(_root) {
-                    _list.InsertRange(index, c);
-                }
-            }
-    
-            public override int LastIndexOf(Object value) {
-                lock(_root) {
-                    return _list.LastIndexOf(value);
-                }
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override int LastIndexOf(Object value, int startIndex) {
-                lock(_root) {
-                    return _list.LastIndexOf(value, startIndex);
-                }
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override int LastIndexOf(Object value, int startIndex, int count) {
-                lock(_root) {
-                    return _list.LastIndexOf(value, startIndex, count);
-                }
-            }
-    
-            public override void Remove(Object value) {
-                lock(_root) {
-                    _list.Remove(value);
-                }
-            }
-    
-            public override void RemoveAt(int index) {
-                lock(_root) {
-                    _list.RemoveAt(index);
-                }
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override void RemoveRange(int index, int count) {
-                lock(_root) {
-                    _list.RemoveRange(index, count);
-                }
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override void Reverse(int index, int count) {
-                lock(_root) {
-                    _list.Reverse(index, count);
-                }
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override void SetRange(int index, ICollection c) {
-                lock(_root) {
-                    _list.SetRange(index, c);
-                }
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override ArrayList GetRange(int index, int count) {
-                lock(_root) {
-                    return _list.GetRange(index, count);
-                }
-            }
-
-            public override void Sort() {
-                lock(_root) {
-                    _list.Sort();
-                }
-            }
-    
-            public override void Sort(IComparer comparer) {
-                lock(_root) {
-                    _list.Sort(comparer);
-                }
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override void Sort(int index, int count, IComparer comparer) {
-                lock(_root) {
-                    _list.Sort(index, count, comparer);
-                }
-            }
-    
-            public override Object[] ToArray() {
-                lock(_root) {
-                    return _list.ToArray();
-                }
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override Array ToArray(Type type) {
-                lock(_root) {
-                    return _list.ToArray(type);
-                }
-            }
-    
-            public override void TrimToSize() {
-                lock(_root) {
-                    _list.TrimToSize();
-                }
-            }
-        }
-    
-    
-        [Serializable]
-        private class SyncIList : IList
-        {
-            private IList _list;
-            private Object _root;
-    
-            internal SyncIList(IList list) {
-                _list = list;
-                _root = list.SyncRoot;
-            }
-    
-            public virtual int Count { 
-                get { lock(_root) { return _list.Count; } }
-            }
-    
-            public virtual bool IsReadOnly {
-                get { return _list.IsReadOnly; }
-            }
-
-            public virtual bool IsFixedSize {
-                get { return _list.IsFixedSize; }
-            }
-
-            
-            public virtual bool IsSynchronized { 
-                get { return true; }
-            }
-            
-             public virtual Object this[int index] {
-                get {
-                    lock(_root) {
-                        return _list[index];
-                    }
-                }
-                set {
-                    lock(_root) {
-                        _list[index] = value;
-                    }
-                }
-            }
-    
-            public virtual Object SyncRoot {
-                get { return _root; }
-            }
-    
-            public virtual int Add(Object value) {
-                lock(_root) {
-                    return _list.Add(value);
-                }
-            }
-                 
-    
-            public virtual void Clear() {
-                lock(_root) {
-                    _list.Clear();
-                }
-            }
-    
-            public virtual bool Contains(Object item) {
-                lock(_root) {
-                    return _list.Contains(item);
-                }
-            }
-    
-            public virtual void CopyTo(Array array, int index) {
-                lock(_root) {
-                    _list.CopyTo(array, index);
-                }
-            }
-    
-            public virtual IEnumerator GetEnumerator() {
-                lock(_root) {
-                    return _list.GetEnumerator();
-                }
-            }
-    
-            public virtual int IndexOf(Object value) {
-                lock(_root) {
-                    return _list.IndexOf(value);
-                }
-            }
-    
-            public virtual void Insert(int index, Object value) {
-                lock(_root) {
-                    _list.Insert(index, value);
-                }
-            }
-    
-            public virtual void Remove(Object value) {
-                lock(_root) {
-                    _list.Remove(value);
-                }
-            }
-    
-            public virtual void RemoveAt(int index) {
-                lock(_root) {
-                    _list.RemoveAt(index);
-                }
-            }
-        }
-    
-        [Serializable]
-        private class FixedSizeList : IList
-        {
-            private IList _list;
-    
-            internal FixedSizeList(IList l) {
-                _list = l;
-            }
-    
-            public virtual int Count { 
-                get { return _list.Count; }
-            }
-    
-            public virtual bool IsReadOnly {
-                get { return _list.IsReadOnly; }
-            }
-
-            public virtual bool IsFixedSize {
-                get { return true; }
-            }
-
-            public virtual bool IsSynchronized { 
-                get { return _list.IsSynchronized; }
-            }
-            
-             public virtual Object this[int index] {
-                get {
-                    return _list[index];
-                }
-                set {
-                    _list[index] = value;
-                }
-            }
-    
-            public virtual Object SyncRoot {
-                get { return _list.SyncRoot; }
-            }
-            
-            public virtual int Add(Object obj) {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
-            }
-    
-            public virtual void Clear() {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
-            }
-    
-            public virtual bool Contains(Object obj) {
-                return _list.Contains(obj);
-            }
-    
-            public virtual void CopyTo(Array array, int index) {
-                _list.CopyTo(array, index);
-            }
-    
-            public virtual IEnumerator GetEnumerator() {
-                return _list.GetEnumerator();
-            }
-    
-            public virtual int IndexOf(Object value) {
-                return _list.IndexOf(value);
-            }
-    
-            public virtual void Insert(int index, Object obj) {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
-            }
-    
-            public virtual void Remove(Object value) {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
-            }
-    
-            public virtual void RemoveAt(int index) {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
-            }
-        }
-
-        [Serializable]
-        private class FixedSizeArrayList : ArrayList
-        {
-            private ArrayList _list;
-    
-            internal FixedSizeArrayList(ArrayList l) {
-                _list = l;
-                _version = _list._version;
-            }
-    
-            public override int Count { 
-                get { return _list.Count; }
-            }
-    
-            public override bool IsReadOnly {
-                get { return _list.IsReadOnly; }
-            }
-
-            public override bool IsFixedSize {
-                get { return true; }
-            }
-
-            public override bool IsSynchronized { 
-                get { return _list.IsSynchronized; }
-            }
-            
-             public override Object this[int index] {
-                get {
-                    return _list[index];
-                }
-                set {
-                    _list[index] = value;
-                    _version = _list._version;
-                }
-            }
-    
-            public override Object SyncRoot {
-                get { return _list.SyncRoot; }
-            }
-            
-            public override int Add(Object obj) {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
-            }
-    
-            public override void AddRange(ICollection c) {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override int BinarySearch(int index, int count, Object value, IComparer comparer) {
-                return _list.BinarySearch(index, count, value, comparer);
-            }
-
-            public override int Capacity {
-                get { return _list.Capacity; }
-                [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-                set { throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection")); }
-            }
-
-            public override void Clear() {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
-            }
-    
-            public override Object Clone() {
-                FixedSizeArrayList arrayList = new FixedSizeArrayList(_list);
-                arrayList._list = (ArrayList)_list.Clone();
-                return arrayList;
-            }
-
-            public override bool Contains(Object obj) {
-                return _list.Contains(obj);
-            }
-    
-            public override void CopyTo(Array array, int index) {
-                _list.CopyTo(array, index);
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override void CopyTo(int index, Array array, int arrayIndex, int count) {
-                _list.CopyTo(index, array, arrayIndex, count);
-            }
-
-            public override IEnumerator GetEnumerator() {
-                return _list.GetEnumerator();
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override IEnumerator GetEnumerator(int index, int count) {
-                return _list.GetEnumerator(index, count);
-            }
-
-            public override int IndexOf(Object value) {
-                return _list.IndexOf(value);
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override int IndexOf(Object value, int startIndex) {
-                return _list.IndexOf(value, startIndex);
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override int IndexOf(Object value, int startIndex, int count) {
-                return _list.IndexOf(value, startIndex, count);
-            }
-    
-            public override void Insert(int index, Object obj) {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override void InsertRange(int index, ICollection c) {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
-            }
-
-            public override int LastIndexOf(Object value) {
-                return _list.LastIndexOf(value);
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override int LastIndexOf(Object value, int startIndex) {
-                return _list.LastIndexOf(value, startIndex);
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override int LastIndexOf(Object value, int startIndex, int count) {
-                return _list.LastIndexOf(value, startIndex, count);
-            }
-
-            public override void Remove(Object value) {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
-            }
-    
-            public override void RemoveAt(int index) {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override void RemoveRange(int index, int count) {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override void SetRange(int index, ICollection c) {
-                _list.SetRange(index, c);
-                _version = _list._version;
-            }
-
-            public override ArrayList GetRange(int index, int count) {
-                if (index < 0 || count < 0)
-                    throw new ArgumentOutOfRangeException((index<0 ? nameof(index) : nameof(count)), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-                if (Count - index < count)
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-                Contract.EndContractBlock();
-
-                return new Range(this,index, count);
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override void Reverse(int index, int count) {
-                _list.Reverse(index, count);
-                _version = _list._version;
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override void Sort(int index, int count, IComparer comparer) {
-                _list.Sort(index, count, comparer);
-                _version = _list._version;
-            }
-
-            public override Object[] ToArray() {
-                return _list.ToArray();
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override Array ToArray(Type type) {
-                return _list.ToArray(type);
-            }
-    
-            public override void TrimToSize() {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_FixedSizeCollection"));
-            }
-        }
-    
         [Serializable]
         private class ReadOnlyList : IList
         {
@@ -1908,626 +459,6 @@ namespace System.Collections {
         }
 
         [Serializable]
-        private class ReadOnlyArrayList : ArrayList
-        {
-            private ArrayList _list;
-    
-            internal ReadOnlyArrayList(ArrayList l) {
-                _list = l;
-            }
-    
-            public override int Count { 
-                get { return _list.Count; }
-            }
-    
-            public override bool IsReadOnly {
-                get { return true; }
-            }
-
-            public override bool IsFixedSize {
-                get { return true; }
-            }
-
-            public override bool IsSynchronized { 
-                get { return _list.IsSynchronized; }
-            }
-            
-             public override Object this[int index] {
-                get {
-                    return _list[index];
-                }
-                set {
-                    throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
-                }
-            }
-    
-            public override Object SyncRoot {
-                get { return _list.SyncRoot; }
-            }
-            
-            public override int Add(Object obj) {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
-            }
-    
-            public override void AddRange(ICollection c) {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override int BinarySearch(int index, int count, Object value, IComparer comparer) {
-                return _list.BinarySearch(index, count, value, comparer);
-            }
-
-
-            public override int Capacity {
-                get { return _list.Capacity; }
-                [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-                set { throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection")); }
-            }
-
-            public override void Clear() {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
-            }
-
-            public override Object Clone() {
-                ReadOnlyArrayList arrayList = new ReadOnlyArrayList(_list);
-                arrayList._list = (ArrayList)_list.Clone();
-                return arrayList;
-            }
-    
-            public override bool Contains(Object obj) {
-                return _list.Contains(obj);
-            }
-    
-            public override void CopyTo(Array array, int index) {
-                _list.CopyTo(array, index);
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override void CopyTo(int index, Array array, int arrayIndex, int count) {
-                _list.CopyTo(index, array, arrayIndex, count);
-            }
-
-            public override IEnumerator GetEnumerator() {
-                return _list.GetEnumerator();
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override IEnumerator GetEnumerator(int index, int count) {
-                return _list.GetEnumerator(index, count);
-            }
-
-            public override int IndexOf(Object value) {
-                return _list.IndexOf(value);
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override int IndexOf(Object value, int startIndex) {
-                return _list.IndexOf(value, startIndex);
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override int IndexOf(Object value, int startIndex, int count) {
-                return _list.IndexOf(value, startIndex, count);
-            }
-    
-            public override void Insert(int index, Object obj) {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override void InsertRange(int index, ICollection c) {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
-            }
-
-            public override int LastIndexOf(Object value) {
-                return _list.LastIndexOf(value);
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override int LastIndexOf(Object value, int startIndex) {
-                return _list.LastIndexOf(value, startIndex);
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override int LastIndexOf(Object value, int startIndex, int count) {
-                return _list.LastIndexOf(value, startIndex, count);
-            }
-
-            public override void Remove(Object value) {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
-            }
-    
-            public override void RemoveAt(int index) {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override void RemoveRange(int index, int count) {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override void SetRange(int index, ICollection c) {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
-            }
-    
-            public override ArrayList GetRange(int index, int count) {
-                if (index < 0 || count < 0)
-                    throw new ArgumentOutOfRangeException((index<0 ? nameof(index) : nameof(count)), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-                if (Count - index < count)
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-                Contract.EndContractBlock();
-
-                return new Range(this,index, count);
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override void Reverse(int index, int count) {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override void Sort(int index, int count, IComparer comparer) {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
-            }
-
-            public override Object[] ToArray() {
-                return _list.ToArray();
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override Array ToArray(Type type) {
-                return _list.ToArray(type);
-            }
-    
-            public override void TrimToSize() {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReadOnlyCollection"));
-            }
-        }
-
-    
-        // Implements an enumerator for a ArrayList. The enumerator uses the
-        // internal version number of the list to ensure that no modifications are
-        // made to the list while an enumeration is in progress.
-        [Serializable]
-        private sealed class ArrayListEnumerator : IEnumerator, ICloneable
-        {
-            private ArrayList list;
-            private int index;
-            private int endIndex;       // Where to stop.
-            private int version;
-            private Object currentElement;
-            private int startIndex;     // Save this for Reset.
-    
-            internal ArrayListEnumerator(ArrayList list, int index, int count) {
-                this.list = list;
-                startIndex = index;
-                this.index = index - 1;
-                endIndex = this.index + count;  // last valid index
-                version = list._version;
-                currentElement = null;
-            }
-
-            public Object Clone() {
-                return MemberwiseClone();
-            }
-    
-            public bool MoveNext() {
-                if (version != list._version) throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumFailedVersion));
-                if (index < endIndex) {
-                    currentElement = list[++index];
-                    return true;
-                }
-                else {
-                    index = endIndex + 1;
-                }
-                
-                return false;
-            }
-    
-            public Object Current {
-                get {
-                    if (index < startIndex) 
-                        throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumNotStarted));
-                    else if (index > endIndex) {
-                        throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumEnded));
-                    }
-                    return currentElement;
-                }
-            }
-       
-            public void Reset() {
-                if (version != list._version) throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumFailedVersion));
-                index = startIndex - 1;                
-            }
-        }
-
-        // Implementation of a generic list subrange. An instance of this class
-        // is returned by the default implementation of List.GetRange.
-        [Serializable]
-        private class Range: ArrayList
-        {
-            private ArrayList _baseList;
-            private int _baseIndex;
-            [ContractPublicPropertyName("Count")]
-            private int _baseSize;
-            private int _baseVersion;
-                        
-            internal Range(ArrayList list, int index, int count) : base(false) {
-                _baseList = list;
-                _baseIndex = index;
-                _baseSize = count;
-                _baseVersion = list._version;
-                // we also need to update _version field to make Range of Range work
-                _version = list._version;                
-            }
-
-            private void InternalUpdateRange()
-            {
-                if (_baseVersion != _baseList._version)
-                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_UnderlyingArrayListChanged"));
-            }
-
-            private void InternalUpdateVersion() {
-                _baseVersion++;
-                _version++;                
-            }
-            
-            public override int Add(Object value) {
-                InternalUpdateRange();
-                _baseList.Insert(_baseIndex + _baseSize, value);
-                InternalUpdateVersion();
-                return _baseSize++;
-            }
-
-            public override void AddRange(ICollection c) {
-                if( c ==  null ) {
-                    throw new ArgumentNullException(nameof(c));
-                }
-                Contract.EndContractBlock();
-
-                InternalUpdateRange();
-                int count = c.Count;
-                if( count > 0) {
-                    _baseList.InsertRange(_baseIndex + _baseSize, c);
-                    InternalUpdateVersion();
-                    _baseSize += count;
-                }
-            }
-
-            // Other overloads with automatically work 
-            public override int BinarySearch(int index, int count, Object value, IComparer comparer) {
-                if (index < 0 || count < 0)
-                    throw new ArgumentOutOfRangeException((index<0 ? nameof(index) : nameof(count)), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-                if (_baseSize - index < count)
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-                Contract.EndContractBlock();
-                InternalUpdateRange();
-
-                int i = _baseList.BinarySearch(_baseIndex + index, count, value, comparer);
-                if (i >= 0) return i - _baseIndex;
-                return i + _baseIndex;
-            }
-
-            public override int Capacity {
-                get {
-                    return _baseList.Capacity;
-                }
-             
-                set {
-                    if (value < Count) throw new ArgumentOutOfRangeException(nameof(value), Environment.GetResourceString("ArgumentOutOfRange_SmallCapacity"));
-                    Contract.EndContractBlock();
-                }
-            }
-    
-
-            public override void Clear() {
-                InternalUpdateRange();
-                if (_baseSize != 0)
-                {
-                    _baseList.RemoveRange(_baseIndex, _baseSize);
-                    InternalUpdateVersion();
-                    _baseSize = 0;
-                }
-            }
-
-            public override Object Clone() {
-                InternalUpdateRange();
-                Range arrayList = new Range(_baseList,_baseIndex,_baseSize);
-                arrayList._baseList = (ArrayList)_baseList.Clone();
-                return arrayList;
-            }
-
-            public override bool Contains(Object item) {
-              InternalUpdateRange();
-              if (item==null) {
-                    for(int i=0; i<_baseSize; i++)
-                        if (_baseList[_baseIndex + i]==null)
-                            return true;
-                    return false;
-                }
-                else {
-                    for(int i=0; i<_baseSize; i++)
-                        if (_baseList[_baseIndex + i] != null && _baseList[_baseIndex + i].Equals(item))
-                            return true;
-                    return false;
-                }
-            }
-    
-            public override void CopyTo(Array array, int index) {
-                if (array==null)
-                    throw new ArgumentNullException(nameof(array));
-                if (array.Rank != 1)
-                    throw new ArgumentException(Environment.GetResourceString("Arg_RankMultiDimNotSupported"));
-                if (index < 0)
-                    throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-                if (array.Length - index < _baseSize)
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-                Contract.EndContractBlock();
-
-                InternalUpdateRange();
-                _baseList.CopyTo(_baseIndex, array, index, _baseSize);
-            }
-
-            public override void CopyTo(int index, Array array, int arrayIndex, int count) {
-                if (array==null)
-                    throw new ArgumentNullException(nameof(array));
-                if (array.Rank != 1)
-                    throw new ArgumentException(Environment.GetResourceString("Arg_RankMultiDimNotSupported"));
-                if (index < 0 || count < 0)
-                    throw new ArgumentOutOfRangeException((index<0 ? nameof(index) : nameof(count)), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-                if (array.Length - arrayIndex < count)
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-                if (_baseSize - index < count)
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-                Contract.EndContractBlock();
-
-                InternalUpdateRange();
-                _baseList.CopyTo(_baseIndex + index, array, arrayIndex, count);
-            }
-
-            public override int Count {
-                get {
-                 InternalUpdateRange();
-                 return _baseSize; 
-                }
-            }
-
-            public override bool IsReadOnly {
-                get { return _baseList.IsReadOnly; }
-            }
-
-            public override bool IsFixedSize {
-                get { return _baseList.IsFixedSize; }
-            }
-
-            public override bool IsSynchronized {
-                get { return _baseList.IsSynchronized; }
-            }
-                                
-            public override IEnumerator GetEnumerator() {
-                return GetEnumerator(0,_baseSize);
-            }
-
-            public override IEnumerator GetEnumerator(int index, int count) {
-                if (index < 0 || count < 0)
-                    throw new ArgumentOutOfRangeException((index<0 ? nameof(index) : nameof(count)), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-                if (_baseSize - index < count)
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-                Contract.EndContractBlock();
-
-                InternalUpdateRange();
-                return _baseList.GetEnumerator(_baseIndex + index, count);
-            }
-
-            public override ArrayList GetRange(int index, int count) {
-                if (index < 0 || count < 0)
-                    throw new ArgumentOutOfRangeException((index<0 ? nameof(index) : nameof(count)), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-                if (_baseSize - index < count)
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-                Contract.EndContractBlock();
-
-                InternalUpdateRange();
-                return new Range(this, index, count);
-            }
-
-            public override Object SyncRoot {
-                get {
-                    return _baseList.SyncRoot;
-                }
-            }
-        
-
-            public override int IndexOf(Object value) {
-                InternalUpdateRange();
-                int i = _baseList.IndexOf(value, _baseIndex, _baseSize);
-                if (i >= 0) return i - _baseIndex;
-                return -1;
-            }
-
-            public override int IndexOf(Object value, int startIndex) {
-                if (startIndex < 0)
-                    throw new ArgumentOutOfRangeException(nameof(startIndex), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-                if (startIndex > _baseSize)
-                    throw new ArgumentOutOfRangeException(nameof(startIndex), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-                Contract.EndContractBlock();
-
-                InternalUpdateRange();
-                int i = _baseList.IndexOf(value, _baseIndex + startIndex, _baseSize - startIndex);
-                if (i >= 0) return i - _baseIndex;
-                return -1;
-            }
-            
-            public override int IndexOf(Object value, int startIndex, int count) {
-                if (startIndex < 0 || startIndex > _baseSize)
-                    throw new ArgumentOutOfRangeException(nameof(startIndex), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-                    
-                if (count < 0 || (startIndex > _baseSize - count))
-                    throw new ArgumentOutOfRangeException(nameof(count), Environment.GetResourceString("ArgumentOutOfRange_Count"));
-                Contract.EndContractBlock();
-
-                InternalUpdateRange();
-                int i = _baseList.IndexOf(value, _baseIndex + startIndex, count);
-                if (i >= 0) return i - _baseIndex;
-                return -1;
-            }
-
-            public override void Insert(int index, Object value) {
-                if (index < 0 || index > _baseSize) throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-                Contract.EndContractBlock();
-
-                InternalUpdateRange();
-                _baseList.Insert(_baseIndex + index, value);
-                InternalUpdateVersion();
-                _baseSize++;
-            }
-
-            public override void InsertRange(int index, ICollection c) {
-                if (index < 0 || index > _baseSize) throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-                if( c == null) {
-                    throw new ArgumentNullException(nameof(c));
-                }
-                Contract.EndContractBlock();
-
-                InternalUpdateRange();                
-                int count = c.Count;
-                if( count > 0) {
-                    _baseList.InsertRange(_baseIndex + index, c);
-                    _baseSize += count;                    
-                    InternalUpdateVersion();
-                }
-            }
-
-            public override int LastIndexOf(Object value) {
-                InternalUpdateRange();
-                int i = _baseList.LastIndexOf(value, _baseIndex + _baseSize - 1, _baseSize);
-                if (i >= 0) return i - _baseIndex;
-                return -1;
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override int LastIndexOf(Object value, int startIndex) {
-                return LastIndexOf(value, startIndex, startIndex + 1);
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override int LastIndexOf(Object value, int startIndex, int count) {
-                InternalUpdateRange();
-                if (_baseSize == 0)
-                    return -1;
-   
-                if (startIndex >= _baseSize)
-                    throw new ArgumentOutOfRangeException(nameof(startIndex), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-                if (startIndex < 0)
-                    throw new ArgumentOutOfRangeException(nameof(startIndex), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-                
-                int i = _baseList.LastIndexOf(value, _baseIndex + startIndex, count);
-                if (i >= 0) return i - _baseIndex;
-                return -1;
-            }
-
-            // Don't need to override Remove
-
-            public override void RemoveAt(int index) {
-                if (index < 0 || index >= _baseSize) throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-                Contract.EndContractBlock();
-
-                InternalUpdateRange();
-                _baseList.RemoveAt(_baseIndex + index);
-                InternalUpdateVersion();
-                _baseSize--;
-            }
-
-            public override void RemoveRange(int index, int count) {            
-                if (index < 0 || count < 0)
-                    throw new ArgumentOutOfRangeException((index<0 ? nameof(index) : nameof(count)), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-                if (_baseSize - index < count)
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-                Contract.EndContractBlock();
-
-                InternalUpdateRange();
-                // No need to call _bastList.RemoveRange if count is 0.
-                // In addition, _baseList won't change the vresion number if count is 0. 
-                if( count > 0) {
-                    _baseList.RemoveRange(_baseIndex + index, count);
-                    InternalUpdateVersion();
-                    _baseSize -= count;
-                }
-            }
-
-            public override void Reverse(int index, int count) {
-                if (index < 0 || count < 0)
-                    throw new ArgumentOutOfRangeException((index<0 ? nameof(index) : nameof(count)), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-                if (_baseSize - index < count)
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-                Contract.EndContractBlock();
-
-                InternalUpdateRange();
-                _baseList.Reverse(_baseIndex + index, count);
-                InternalUpdateVersion();
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override void SetRange(int index, ICollection c) {
-                InternalUpdateRange();
-                if (index < 0 || index >= _baseSize) throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-                _baseList.SetRange(_baseIndex + index, c);
-                if( c.Count > 0) {
-                    InternalUpdateVersion();
-                }
-            }
-
-            public override void Sort(int index, int count, IComparer comparer) {
-                if (index < 0 || count < 0)
-                    throw new ArgumentOutOfRangeException((index<0 ? nameof(index) : nameof(count)), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-                if (_baseSize - index < count)
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-                Contract.EndContractBlock();
-
-                InternalUpdateRange();
-                _baseList.Sort(_baseIndex + index, count, comparer);
-                InternalUpdateVersion();
-            }
-
-            public override Object this[int index] {
-                get {
-                    InternalUpdateRange();
-                    if (index < 0 || index >= _baseSize) throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-                    return _baseList[_baseIndex + index];
-                }
-                set {
-                    InternalUpdateRange();
-                    if (index < 0 || index >= _baseSize) throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-                    _baseList[_baseIndex + index] = value;
-                    InternalUpdateVersion();
-                }
-            }
-
-            public override Object[] ToArray() {
-                InternalUpdateRange();
-                Object[] array = new Object[_baseSize];
-                Array.Copy(_baseList._items, _baseIndex, array, 0, _baseSize);
-                return array;
-            }
-
-            public override Array ToArray(Type type) {
-                if (type==null)
-                    throw new ArgumentNullException(nameof(type));
-                Contract.EndContractBlock();
-
-                InternalUpdateRange();
-                Array array = Array.UnsafeCreateInstance(type, _baseSize);
-                _baseList.CopyTo(_baseIndex, array, 0, _baseSize);
-                return array;
-            }
-
-            public override void TrimToSize() {
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_RangeCollection"));
-            }
-        }
-
-        [Serializable]
         private sealed class ArrayListEnumeratorSimple : IEnumerator, ICloneable {
             private ArrayList list;
             private int index;
@@ -2607,20 +538,6 @@ namespace System.Collections {
 
         internal class ArrayListDebugView {
             private ArrayList arrayList; 
-        
-            public ArrayListDebugView( ArrayList arrayList) {
-                if( arrayList == null)
-                    throw new ArgumentNullException(nameof(arrayList));
-
-                this.arrayList = arrayList;
-            }
-
-            [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
-            public Object[] Items { 
-                get {
-                    return arrayList.ToArray();
-                }
-            }
         }
     }    
 }
diff --git a/src/mscorlib/src/System/Collections/CollectionBase.cs b/src/mscorlib/src/System/Collections/CollectionBase.cs
index ae0c0d302d..a3dd88a7b3 100644
--- a/src/mscorlib/src/System/Collections/CollectionBase.cs
+++ b/src/mscorlib/src/System/Collections/CollectionBase.cs
@@ -12,20 +12,14 @@ namespace System.Collections {
 
     // Useful base class for typed read/write collections where items derive from object
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public abstract class CollectionBase : IList {
-        ArrayList list;
+        private ArrayList list;
 
         protected CollectionBase() {
             list = new ArrayList();
         }
-        
-        protected CollectionBase(int capacity) {
-            list = new ArrayList(capacity);
-        }
-
 
-        protected ArrayList InnerList { 
+        internal ArrayList InnerList { 
             get { 
                 if (list == null)
                     list = new ArrayList();
@@ -37,16 +31,6 @@ namespace System.Collections {
             get { return (IList)this; }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]        
-        public int Capacity {
-            get {
-                return InnerList.Capacity;
-            }
-            set {
-                InnerList.Capacity = value;
-            }
-        }
-
 
         public int Count {
             get {
diff --git a/src/mscorlib/src/System/Collections/Comparer.cs b/src/mscorlib/src/System/Collections/Comparer.cs
index 0e3c78b529..928b0f9f9a 100644
--- a/src/mscorlib/src/System/Collections/Comparer.cs
+++ b/src/mscorlib/src/System/Collections/Comparer.cs
@@ -17,12 +17,10 @@ namespace System.Collections {
     using System;
     using System.Globalization;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     using System.Diagnostics.Contracts;
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class Comparer : IComparer , ISerializable
+    internal sealed class Comparer : IComparer , ISerializable
     {
         private CompareInfo m_compareInfo;   
         public static readonly Comparer Default = new Comparer(CultureInfo.CurrentCulture);
diff --git a/src/mscorlib/src/System/Collections/Concurrent/ConcurrentDictionary.cs b/src/mscorlib/src/System/Collections/Concurrent/ConcurrentDictionary.cs
index c1a6f7564c..8b9014a103 100644
--- a/src/mscorlib/src/System/Collections/Concurrent/ConcurrentDictionary.cs
+++ b/src/mscorlib/src/System/Collections/Concurrent/ConcurrentDictionary.cs
@@ -24,7 +24,6 @@ using System.Runtime.Serialization;
 using System.Text;
 using System.Threading;
 using System.Security;
-using System.Security.Permissions;
 
 namespace System.Collections.Concurrent
 {
@@ -37,10 +36,9 @@ namespace System.Collections.Concurrent
     /// All public and protected members of <see cref="ConcurrentDictionary{TKey,TValue}"/> are thread-safe and may be used
     /// concurrently from multiple threads.
     /// </remarks>
-    [ComVisible(false)]
     [DebuggerTypeProxy(typeof(Mscorlib_DictionaryDebugView<,>))]
     [DebuggerDisplay("Count = {Count}")]
-    public class ConcurrentDictionary<TKey, TValue> : IDictionary<TKey, TValue>, IDictionary, IReadOnlyDictionary<TKey, TValue>
+    internal class ConcurrentDictionary<TKey, TValue> : IDictionary<TKey, TValue>, IDictionary, IReadOnlyDictionary<TKey, TValue>
     {
         /// <summary>
         /// Tables that hold the internal state of the ConcurrentDictionary
@@ -139,149 +137,6 @@ namespace System.Collections.Concurrent
         /// </summary>
         public ConcurrentDictionary() : this(DefaultConcurrencyLevel, DEFAULT_CAPACITY, true, EqualityComparer<TKey>.Default) { }
 
-        /// <summary>
-        /// Initializes a new instance of the <see
-        /// cref="ConcurrentDictionary{TKey,TValue}"/>
-        /// class that is empty, has the specified concurrency level and capacity, and uses the default
-        /// comparer for the key type.
-        /// </summary>
-        /// <param name="concurrencyLevel">The estimated number of threads that will update the
-        /// <see cref="ConcurrentDictionary{TKey,TValue}"/> concurrently.</param>
-        /// <param name="capacity">The initial number of elements that the <see
-        /// cref="ConcurrentDictionary{TKey,TValue}"/>
-        /// can contain.</param>
-        /// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="concurrencyLevel"/> is
-        /// less than 1.</exception>
-        /// <exception cref="T:System.ArgumentOutOfRangeException"> <paramref name="capacity"/> is less than
-        /// 0.</exception>
-        public ConcurrentDictionary(int concurrencyLevel, int capacity) : this(concurrencyLevel, capacity, false, EqualityComparer<TKey>.Default) { }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ConcurrentDictionary{TKey,TValue}"/>
-        /// class that contains elements copied from the specified <see
-        /// cref="T:System.Collections.IEnumerable{KeyValuePair{TKey,TValue}}"/>, has the default concurrency
-        /// level, has the default initial capacity, and uses the default comparer for the key type.
-        /// </summary>
-        /// <param name="collection">The <see
-        /// cref="T:System.Collections.IEnumerable{KeyValuePair{TKey,TValue}}"/> whose elements are copied to
-        /// the new
-        /// <see cref="ConcurrentDictionary{TKey,TValue}"/>.</param>
-        /// <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> is a null reference
-        /// (Nothing in Visual Basic).</exception>
-        /// <exception cref="T:System.ArgumentException"><paramref name="collection"/> contains one or more
-        /// duplicate keys.</exception>
-        public ConcurrentDictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection) : this(collection, EqualityComparer<TKey>.Default) { }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ConcurrentDictionary{TKey,TValue}"/>
-        /// class that is empty, has the specified concurrency level and capacity, and uses the specified
-        /// <see cref="T:System.Collections.Generic.IEqualityComparer{TKey}"/>.
-        /// </summary>
-        /// <param name="comparer">The <see cref="T:System.Collections.Generic.IEqualityComparer{TKey}"/>
-        /// implementation to use when comparing keys.</param>
-        /// <exception cref="T:System.ArgumentNullException"><paramref name="comparer"/> is a null reference
-        /// (Nothing in Visual Basic).</exception>
-        public ConcurrentDictionary(IEqualityComparer<TKey> comparer) : this(DefaultConcurrencyLevel, DEFAULT_CAPACITY, true, comparer) { }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ConcurrentDictionary{TKey,TValue}"/>
-        /// class that contains elements copied from the specified <see
-        /// cref="T:System.Collections.IEnumerable"/>, has the default concurrency level, has the default
-        /// initial capacity, and uses the specified
-        /// <see cref="T:System.Collections.Generic.IEqualityComparer{TKey}"/>.
-        /// </summary>
-        /// <param name="collection">The <see
-        /// cref="T:System.Collections.IEnumerable{KeyValuePair{TKey,TValue}}"/> whose elements are copied to
-        /// the new
-        /// <see cref="ConcurrentDictionary{TKey,TValue}"/>.</param>
-        /// <param name="comparer">The <see cref="T:System.Collections.Generic.IEqualityComparer{TKey}"/>
-        /// implementation to use when comparing keys.</param>
-        /// <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> is a null reference
-        /// (Nothing in Visual Basic). -or-
-        /// <paramref name="comparer"/> is a null reference (Nothing in Visual Basic).
-        /// </exception>
-        public ConcurrentDictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection, IEqualityComparer<TKey> comparer)
-            : this(comparer)
-        {
-            if (collection == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
-
-            InitializeFromCollection(collection);
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ConcurrentDictionary{TKey,TValue}"/> 
-        /// class that contains elements copied from the specified <see cref="T:System.Collections.IEnumerable"/>, 
-        /// has the specified concurrency level, has the specified initial capacity, and uses the specified 
-        /// <see cref="T:System.Collections.Generic.IEqualityComparer{TKey}"/>.
-        /// </summary>
-        /// <param name="concurrencyLevel">The estimated number of threads that will update the 
-        /// <see cref="ConcurrentDictionary{TKey,TValue}"/> concurrently.</param>
-        /// <param name="collection">The <see cref="T:System.Collections.IEnumerable{KeyValuePair{TKey,TValue}}"/> whose elements are copied to the new 
-        /// <see cref="ConcurrentDictionary{TKey,TValue}"/>.</param>
-        /// <param name="comparer">The <see cref="T:System.Collections.Generic.IEqualityComparer{TKey}"/> implementation to use 
-        /// when comparing keys.</param>
-        /// <exception cref="T:System.ArgumentNullException">
-        /// <paramref name="collection"/> is a null reference (Nothing in Visual Basic).
-        /// -or-
-        /// <paramref name="comparer"/> is a null reference (Nothing in Visual Basic).
-        /// </exception>
-        /// <exception cref="T:System.ArgumentOutOfRangeException">
-        /// <paramref name="concurrencyLevel"/> is less than 1.
-        /// </exception>
-        /// <exception cref="T:System.ArgumentException"><paramref name="collection"/> contains one or more duplicate keys.</exception>
-        public ConcurrentDictionary(
-            int concurrencyLevel, IEnumerable<KeyValuePair<TKey, TValue>> collection, IEqualityComparer<TKey> comparer)
-            : this(concurrencyLevel, DEFAULT_CAPACITY, false, comparer)
-        {
-            if (collection == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
-            if (comparer == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.comparer);
-
-            InitializeFromCollection(collection);
-        }
-
-        private void InitializeFromCollection(IEnumerable<KeyValuePair<TKey, TValue>> collection)
-        {
-            TValue dummy;
-            foreach (KeyValuePair<TKey, TValue> pair in collection)
-            {
-                if (pair.Key == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
-
-                if (!TryAddInternal(pair.Key, pair.Value, false, false, out dummy))
-                {
-                    ThrowHelper.ThrowArgumentException(ExceptionResource.ConcurrentDictionary_SourceContainsDuplicateKeys);
-                }
-            }
-
-            if (m_budget == 0)
-            {
-                m_budget = m_tables.m_buckets.Length / m_tables.m_locks.Length;
-            }
-
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ConcurrentDictionary{TKey,TValue}"/>
-        /// class that is empty, has the specified concurrency level, has the specified initial capacity, and
-        /// uses the specified <see cref="T:System.Collections.Generic.IEqualityComparer{TKey}"/>.
-        /// </summary>
-        /// <param name="concurrencyLevel">The estimated number of threads that will update the
-        /// <see cref="ConcurrentDictionary{TKey,TValue}"/> concurrently.</param>
-        /// <param name="capacity">The initial number of elements that the <see
-        /// cref="ConcurrentDictionary{TKey,TValue}"/>
-        /// can contain.</param>
-        /// <param name="comparer">The <see cref="T:System.Collections.Generic.IEqualityComparer{TKey}"/>
-        /// implementation to use when comparing keys.</param>
-        /// <exception cref="T:System.ArgumentOutOfRangeException">
-        /// <paramref name="concurrencyLevel"/> is less than 1. -or-
-        /// <paramref name="capacity"/> is less than 0.
-        /// </exception>
-        /// <exception cref="T:System.ArgumentNullException"><paramref name="comparer"/> is a null reference
-        /// (Nothing in Visual Basic).</exception>
-        public ConcurrentDictionary(int concurrencyLevel, int capacity, IEqualityComparer<TKey> comparer)
-            : this(concurrencyLevel, capacity, false, comparer)
-        {
-        }
-
         internal ConcurrentDictionary(int concurrencyLevel, int capacity, bool growLockArray, IEqualityComparer<TKey> comparer)
         {
             if (concurrencyLevel < 1)
@@ -488,91 +343,6 @@ namespace System.Collections.Concurrent
         }
 
         /// <summary>
-        /// Compares the existing value for the specified key with a specified value, and if they're equal,
-        /// updates the key with a third value.
-        /// </summary>
-        /// <param name="key">The key whose value is compared with <paramref name="comparisonValue"/> and
-        /// possibly replaced.</param>
-        /// <param name="newValue">The value that replaces the value of the element with <paramref
-        /// name="key"/> if the comparison results in equality.</param>
-        /// <param name="comparisonValue">The value that is compared to the value of the element with
-        /// <paramref name="key"/>.</param>
-        /// <returns>true if the value with <paramref name="key"/> was equal to <paramref
-        /// name="comparisonValue"/> and replaced with <paramref name="newValue"/>; otherwise,
-        /// false.</returns>
-        /// <exception cref="T:System.ArgumentNullException"><paramref name="key"/> is a null
-        /// reference.</exception>
-        [SuppressMessage("Microsoft.Concurrency", "CA8001", Justification = "Reviewed for thread safety")]
-        public bool TryUpdate(TKey key, TValue newValue, TValue comparisonValue)
-        {
-            if (key == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
-
-            IEqualityComparer<TValue> valueComparer = EqualityComparer<TValue>.Default;
-
-            while (true)
-            {
-                int bucketNo;
-                int lockNo;
-                int hashcode;
-
-                Tables tables = m_tables;
-                IEqualityComparer<TKey> comparer = tables.m_comparer;
-
-                hashcode = comparer.GetHashCode(key);
-                GetBucketAndLockNo(hashcode, out bucketNo, out lockNo, tables.m_buckets.Length, tables.m_locks.Length);
-
-                lock (tables.m_locks[lockNo])
-                {
-                    // If the table just got resized, we may not be holding the right lock, and must retry.
-                    // This should be a rare occurence.
-                    if (tables != m_tables)
-                    {
-                        continue;
-                    }
-
-                    // Try to find this key in the bucket
-                    Node prev = null;
-                    for (Node node = tables.m_buckets[bucketNo]; node != null; node = node.m_next)
-                    {
-                        Assert((prev == null && node == tables.m_buckets[bucketNo]) || prev.m_next == node);
-                        if (comparer.Equals(node.m_key, key))
-                        {
-                            if (valueComparer.Equals(node.m_value, comparisonValue))
-                            {
-                                if (s_isValueWriteAtomic)
-                                {
-                                    node.m_value = newValue;
-                                }
-                                else
-                                {
-                                    Node newNode = new Node(node.m_key, newValue, hashcode, node.m_next);
-
-                                    if (prev == null)
-                                    {
-                                        tables.m_buckets[bucketNo] = newNode;
-                                    }
-                                    else
-                                    {
-                                        prev.m_next = newNode;
-                                    }
-                                }
-
-                                return true;
-                            }
-
-                            return false;
-                        }
-
-                        prev = node;
-                    }
-
-                    //didn't find the key
-                    return false;
-                }
-            }
-        }
-
-        /// <summary>
         /// Removes all keys and values from the <see cref="ConcurrentDictionary{TKey,TValue}"/>.
         /// </summary>
         public void Clear()
@@ -947,149 +717,6 @@ namespace System.Collections.Concurrent
             }
         }
 
-        /// <summary>
-        /// Adds a key/value pair to the <see cref="ConcurrentDictionary{TKey,TValue}"/> 
-        /// if the key does not already exist.
-        /// </summary>
-        /// <param name="key">The key of the element to add.</param>
-        /// <param name="valueFactory">The function used to generate a value for the key</param>
-        /// <exception cref="T:System.ArgumentNullException"><paramref name="key"/> is a null reference
-        /// (Nothing in Visual Basic).</exception>
-        /// <exception cref="T:System.ArgumentNullException"><paramref name="valueFactory"/> is a null reference
-        /// (Nothing in Visual Basic).</exception>
-        /// <exception cref="T:System.OverflowException">The dictionary contains too many
-        /// elements.</exception>
-        /// <returns>The value for the key.  This will be either the existing value for the key if the
-        /// key is already in the dictionary, or the new value for the key as returned by valueFactory
-        /// if the key was not in the dictionary.</returns>
-        public TValue GetOrAdd(TKey key, Func<TKey, TValue> valueFactory)
-        {
-            if (key == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
-            if (valueFactory == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.valueFactory);
-
-            TValue resultingValue;
-            if (TryGetValue(key, out resultingValue))
-            {
-                return resultingValue;
-            }
-            TryAddInternal(key, valueFactory(key), false, true, out resultingValue);
-            return resultingValue;
-        }
-
-        /// <summary>
-        /// Adds a key/value pair to the <see cref="ConcurrentDictionary{TKey,TValue}"/> 
-        /// if the key does not already exist.
-        /// </summary>
-        /// <param name="key">The key of the element to add.</param>
-        /// <param name="value">the value to be added, if the key does not already exist</param>
-        /// <exception cref="T:System.ArgumentNullException"><paramref name="key"/> is a null reference
-        /// (Nothing in Visual Basic).</exception>
-        /// <exception cref="T:System.OverflowException">The dictionary contains too many
-        /// elements.</exception>
-        /// <returns>The value for the key.  This will be either the existing value for the key if the 
-        /// key is already in the dictionary, or the new value if the key was not in the dictionary.</returns>
-        public TValue GetOrAdd(TKey key, TValue value)
-        {
-            if (key == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
-
-            TValue resultingValue;
-            TryAddInternal(key, value, false, true, out resultingValue);
-            return resultingValue;
-        }
-
-        /// <summary>
-        /// Adds a key/value pair to the <see cref="ConcurrentDictionary{TKey,TValue}"/> if the key does not already 
-        /// exist, or updates a key/value pair in the <see cref="ConcurrentDictionary{TKey,TValue}"/> if the key 
-        /// already exists.
-        /// </summary>
-        /// <param name="key">The key to be added or whose value should be updated</param>
-        /// <param name="addValueFactory">The function used to generate a value for an absent key</param>
-        /// <param name="updateValueFactory">The function used to generate a new value for an existing key
-        /// based on the key's existing value</param>
-        /// <exception cref="T:System.ArgumentNullException"><paramref name="key"/> is a null reference
-        /// (Nothing in Visual Basic).</exception>
-        /// <exception cref="T:System.ArgumentNullException"><paramref name="addValueFactory"/> is a null reference
-        /// (Nothing in Visual Basic).</exception>
-        /// <exception cref="T:System.ArgumentNullException"><paramref name="updateValueFactory"/> is a null reference
-        /// (Nothing in Visual Basic).</exception>
-        /// <exception cref="T:System.OverflowException">The dictionary contains too many
-        /// elements.</exception>
-        /// <returns>The new value for the key.  This will be either be the result of addValueFactory (if the key was 
-        /// absent) or the result of updateValueFactory (if the key was present).</returns>
-        public TValue AddOrUpdate(TKey key, Func<TKey, TValue> addValueFactory, Func<TKey, TValue, TValue> updateValueFactory)
-        {
-            if (key == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
-            if (addValueFactory == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.addValueFactory);
-            if (updateValueFactory == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.updateValueFactory);
-
-            TValue newValue, resultingValue;
-            while (true)
-            {
-                TValue oldValue;
-                if (TryGetValue(key, out oldValue))
-                //key exists, try to update
-                {
-                    newValue = updateValueFactory(key, oldValue);
-                    if (TryUpdate(key, newValue, oldValue))
-                    {
-                        return newValue;
-                    }
-                }
-                else //try add
-                {
-                    newValue = addValueFactory(key);
-                    if (TryAddInternal(key, newValue, false, true, out resultingValue))
-                    {
-                        return resultingValue;
-                    }
-                }
-            }
-        }
-
-        /// <summary>
-        /// Adds a key/value pair to the <see cref="ConcurrentDictionary{TKey,TValue}"/> if the key does not already 
-        /// exist, or updates a key/value pair in the <see cref="ConcurrentDictionary{TKey,TValue}"/> if the key 
-        /// already exists.
-        /// </summary>
-        /// <param name="key">The key to be added or whose value should be updated</param>
-        /// <param name="addValue">The value to be added for an absent key</param>
-        /// <param name="updateValueFactory">The function used to generate a new value for an existing key based on 
-        /// the key's existing value</param>
-        /// <exception cref="T:System.ArgumentNullException"><paramref name="key"/> is a null reference
-        /// (Nothing in Visual Basic).</exception>
-        /// <exception cref="T:System.ArgumentNullException"><paramref name="updateValueFactory"/> is a null reference
-        /// (Nothing in Visual Basic).</exception>
-        /// <exception cref="T:System.OverflowException">The dictionary contains too many
-        /// elements.</exception>
-        /// <returns>The new value for the key.  This will be either be the result of addValueFactory (if the key was 
-        /// absent) or the result of updateValueFactory (if the key was present).</returns>
-        public TValue AddOrUpdate(TKey key, TValue addValue, Func<TKey, TValue, TValue> updateValueFactory)
-        {
-            if (key == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
-            if (updateValueFactory == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.updateValueFactory);
-            TValue newValue, resultingValue;
-            while (true)
-            {
-                TValue oldValue;
-                if (TryGetValue(key, out oldValue))
-                //key exists, try to update
-                {
-                    newValue = updateValueFactory(key, oldValue);
-                    if (TryUpdate(key, newValue, oldValue))
-                    {
-                        return newValue;
-                    }
-                }
-                else //try add
-                {
-                    if (TryAddInternal(key, addValue, false, true, out resultingValue))
-                    {
-                        return resultingValue;
-                    }
-                }
-            }
-        }
-
 
 
         /// <summary>
diff --git a/src/mscorlib/src/System/Collections/Concurrent/ConcurrentQueue.cs b/src/mscorlib/src/System/Collections/Concurrent/ConcurrentQueue.cs
index 7aa5971690..90ada007dd 100644
--- a/src/mscorlib/src/System/Collections/Concurrent/ConcurrentQueue.cs
+++ b/src/mscorlib/src/System/Collections/Concurrent/ConcurrentQueue.cs
@@ -1,67 +1,100 @@
 // 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.
-#pragma warning disable 0420
 
-
-// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
-//
-//
-//
-// A lock-free, concurrent queue primitive, and its associated debugger view type.
-//
-// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-
-using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Diagnostics.Contracts;
-using System.Runtime.ConstrainedExecution;
 using System.Runtime.InteropServices;
 using System.Runtime.Serialization;
-using System.Security;
-using System.Security.Permissions;
 using System.Threading;
 
 namespace System.Collections.Concurrent
 {
-
     /// <summary>
     /// Represents a thread-safe first-in, first-out collection of objects.
     /// </summary>
     /// <typeparam name="T">Specifies the type of elements in the queue.</typeparam>
     /// <remarks>
-    /// All public  and protected members of <see cref="ConcurrentQueue{T}"/> are thread-safe and may be used
+    /// All public and protected members of <see cref="ConcurrentQueue{T}"/> are thread-safe and may be used
     /// concurrently from multiple threads.
     /// </remarks>
-    [ComVisible(false)]
     [DebuggerDisplay("Count = {Count}")]
     [DebuggerTypeProxy(typeof(SystemCollectionsConcurrent_ProducerConsumerCollectionDebugView<>))]
     [Serializable]
-    public class ConcurrentQueue<T> : IProducerConsumerCollection<T>, IReadOnlyCollection<T>
+    internal class ConcurrentQueue<T> : IProducerConsumerCollection<T>, IReadOnlyCollection<T>
     {
-        //fields of ConcurrentQueue
-        [NonSerialized]
-        private volatile Segment m_head;
+        // This implementation provides an unbounded, multi-producer multi-consumer queue
+        // that supports the standard Enqueue/TryDequeue operations, as well as support for
+        // snapshot enumeration (GetEnumerator, ToArray, CopyTo), peeking, and Count/IsEmpty.
+        // It is composed of a linked list of bounded ring buffers, each of which has a head
+        // and a tail index, isolated from each other to minimize false sharing.  As long as
+        // the number of elements in the queue remains less than the size of the current
+        // buffer (Segment), no additional allocations are required for enqueued items.  When
+        // the number of items exceeds the size of the current segment, the current segment is
+        // "frozen" to prevent further enqueues, and a new segment is linked from it and set
+        // as the new tail segment for subsequent enqueues.  As old segments are consumed by
+        // dequeues, the head reference is updated to point to the segment that dequeuers should
+        // try next.  To support snapshot enumeration, segments also support the notion of
+        // preserving for observation, whereby they avoid overwriting state as part of dequeues.
+        // Any operation that requires a snapshot results in all current segments being
+        // both frozen for enqueues and preserved for observation: any new enqueues will go
+        // to new segments, and dequeuers will consume from the existing segments but without
+        // overwriting the existing data.
+
+        /// <summary>Initial length of the segments used in the queue.</summary>
+        private const int InitialSegmentLength = 32;
+        /// <summary>
+        /// Maximum length of the segments used in the queue.  This is a somewhat arbitrary limit:
+        /// larger means that as long as we don't exceed the size, we avoid allocating more segments,
+        /// but if we do exceed it, then the segment becomes garbage.
+        /// </summary>
+        private const int MaxSegmentLength = 1024 * 1024;
 
+        /// <summary>
+        /// Lock used to protect cross-segment operations, including any updates to <see cref="_tail"/> or <see cref="_head"/>
+        /// and any operations that need to get a consistent view of them.
+        /// </summary>
         [NonSerialized]
-        private volatile Segment m_tail;
-
-        private T[] m_serializationArray; // Used for custom serialization.
-
-        private const int SEGMENT_SIZE = 32;
-
-        //number of snapshot takers, GetEnumerator(), ToList() and ToArray() operations take snapshot.
+        private object _crossSegmentLock;
+        /// <summary>The current tail segment.</summary>
         [NonSerialized]
-        internal volatile int m_numSnapshotTakers = 0;
+        private volatile Segment _tail;
+        /// <summary>The current head segment.</summary>
+        [NonSerialized]
+        private volatile Segment _head;
+        /// <summary>Field used to temporarily store the contents of the queue for serialization.</summary>
+        private T[] _serializationArray;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ConcurrentQueue{T}"/> class.
         /// </summary>
         public ConcurrentQueue()
         {
-            m_head = m_tail = new Segment(0, this);
+            _crossSegmentLock = new object();
+            _tail = _head = new Segment(InitialSegmentLength);
+        }
+
+        /// <summary>Set the data array to be serialized.</summary>
+        [OnSerializing]
+        private void OnSerializing(StreamingContext context)
+        {
+            _serializationArray = ToArray();
+        }
+
+        /// <summary>Clear the data array that was serialized.</summary>
+        [OnSerialized]
+        private void OnSerialized(StreamingContext context)
+        {
+            _serializationArray = null;
+        }
+
+        /// <summary>Construct the queue from the deserialized <see cref="_serializationArray"/>.</summary>
+        [OnDeserialized]
+        private void OnDeserialized(StreamingContext context)
+        {
+            Debug.Assert(_serializationArray != null);
+            InitializeFromCollection(_serializationArray);
+            _serializationArray = null;
         }
 
         /// <summary>
@@ -70,34 +103,39 @@ namespace System.Collections.Concurrent
         /// <param name="collection">A collection from which to copy elements.</param>
         private void InitializeFromCollection(IEnumerable<T> collection)
         {
-            Segment localTail = new Segment(0, this);//use this local variable to avoid the extra volatile read/write. this is safe because it is only called from ctor
-            m_head = localTail; 
-
-            int index = 0;
-            foreach (T element in collection)
+            _crossSegmentLock = new object();
+
+            // Determine the initial segment size.  We'll use the default,
+            // unless the collection is known to be larger than than, in which
+            // case we round its length up to a power of 2, as all segments must
+            // be a power of 2 in length.
+            int length = InitialSegmentLength;
+            var c = collection as ICollection<T>;
+            if (c != null)
             {
-                Debug.Assert(index >= 0 && index < SEGMENT_SIZE);
-                localTail.UnsafeAdd(element);
-                index++;
-
-                if (index >= SEGMENT_SIZE)
+                int count = c.Count;
+                if (count > length)
                 {
-                    localTail = localTail.UnsafeGrow();
-                    index = 0;
+                    length = RoundUpToPowerOf2(count);
                 }
             }
 
-            m_tail = localTail;
+            // Initialize the segment and add all of the data to it.
+            _tail = _head = new Segment(length);
+            foreach (T item in collection)
+            {
+                Enqueue(item);
+            }
         }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="ConcurrentQueue{T}"/>
-        /// class that contains elements copied from the specified collection
+        /// Initializes a new instance of the <see cref="ConcurrentQueue{T}"/> class that contains elements copied
+        /// from the specified collection.
         /// </summary>
-        /// <param name="collection">The collection whose elements are copied to the new <see
-        /// cref="ConcurrentQueue{T}"/>.</param>
-        /// <exception cref="T:System.ArgumentNullException">The <paramref name="collection"/> argument is
-        /// null.</exception>
+        /// <param name="collection">
+        /// The collection whose elements are copied to the new <see cref="ConcurrentQueue{T}"/>.
+        /// </param>
+        /// <exception cref="System.ArgumentNullException">The <paramref name="collection"/> argument is null.</exception>
         public ConcurrentQueue(IEnumerable<T> collection)
         {
             if (collection == null)
@@ -109,37 +147,15 @@ namespace System.Collections.Concurrent
         }
 
         /// <summary>
-        /// Get the data array to be serialized
-        /// </summary>
-        [OnSerializing]
-        private void OnSerializing(StreamingContext context)
-        {
-            // save the data into the serialization array to be saved
-            m_serializationArray = ToArray();
-        }
-
-        /// <summary>
-        /// Construct the queue from a previously seiralized one
-        /// </summary>
-        [OnDeserialized]
-        private void OnDeserialized(StreamingContext context)
-        {
-            Debug.Assert(m_serializationArray != null);
-            InitializeFromCollection(m_serializationArray);
-            m_serializationArray = null;
-        }
-
-        /// <summary>
-        /// Copies the elements of the <see cref="T:System.Collections.ICollection"/> to an <see
-        /// cref="T:System.Array"/>, starting at a particular
-        /// <see cref="T:System.Array"/> index.
+        /// Copies the elements of the <see cref="ICollection"/> to an <see
+        /// cref="Array"/>, starting at a particular <see cref="Array"/> index.
         /// </summary>
-        /// <param name="array">The one-dimensional <see cref="T:System.Array">Array</see> that is the
-        /// destination of the elements copied from the
-        /// <see cref="T:System.Collections.Concurrent.ConcurrentBag"/>. The <see
-        /// cref="T:System.Array">Array</see> must have zero-based indexing.</param>
-        /// <param name="index">The zero-based index in <paramref name="array"/> at which copying
-        /// begins.</param>
+        /// <param name="array">
+        /// The one-dimensional <see cref="Array">Array</see> that is the destination of the
+        /// elements copied from the <see cref="ConcurrentQueue{T}"/>. <paramref name="array"/> must have
+        /// zero-based indexing.
+        /// </param>
+        /// <param name="index">The zero-based index in <paramref name="array"/> at which copying begins.</param>
         /// <exception cref="ArgumentNullException"><paramref name="array"/> is a null reference (Nothing in
         /// Visual Basic).</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="index"/> is less than
@@ -148,100 +164,52 @@ namespace System.Collections.Concurrent
         /// <paramref name="array"/> is multidimensional. -or-
         /// <paramref name="array"/> does not have zero-based indexing. -or-
         /// <paramref name="index"/> is equal to or greater than the length of the <paramref name="array"/>
-        /// -or- The number of elements in the source <see cref="T:System.Collections.ICollection"/> is
+        /// -or- The number of elements in the source <see cref="ICollection"/> is
         /// greater than the available space from <paramref name="index"/> to the end of the destination
         /// <paramref name="array"/>. -or- The type of the source <see
-        /// cref="T:System.Collections.ICollection"/> cannot be cast automatically to the type of the
+        /// cref="ICollection"/> cannot be cast automatically to the type of the
         /// destination <paramref name="array"/>.
         /// </exception>
         void ICollection.CopyTo(Array array, int index)
         {
+            // Special-case when the Array is actually a T[], taking a faster path
+            T[] szArray = array as T[];
+            if (szArray != null)
+            {
+                CopyTo(szArray, index);
+                return;
+            }
+
             // Validate arguments.
             if (array == null)
             {
                 throw new ArgumentNullException(nameof(array));
             }
 
-            // We must be careful not to corrupt the array, so we will first accumulate an
-            // internal list of elements that we will then copy to the array. This requires
-            // some extra allocation, but is necessary since we don't know up front whether
-            // the array is sufficiently large to hold the stack's contents.
-            ((ICollection)ToList()).CopyTo(array, index);
+            // Otherwise, fall back to the slower path that first copies the contents
+            // to an array, and then uses that array's non-generic CopyTo to do the copy.
+            ToArray().CopyTo(array, index);
         }
 
         /// <summary>
-        /// Gets a value indicating whether access to the <see cref="T:System.Collections.ICollection"/> is
+        /// Gets a value indicating whether access to the <see cref="ICollection"/> is
         /// synchronized with the SyncRoot.
         /// </summary>
-        /// <value>true if access to the <see cref="T:System.Collections.ICollection"/> is synchronized
+        /// <value>true if access to the <see cref="ICollection"/> is synchronized
         /// with the SyncRoot; otherwise, false. For <see cref="ConcurrentQueue{T}"/>, this property always
         /// returns false.</value>
-        bool ICollection.IsSynchronized
-        {
-            // Gets a value indicating whether access to this collection is synchronized. Always returns
-            // false. The reason is subtle. While access is in face thread safe, it's not the case that
-            // locking on the SyncRoot would have prevented concurrent pushes and pops, as this property
-            // would typically indicate; that's because we internally use CAS operations vs. true locks.
-            get { return false; }
-        }
-
+        bool ICollection.IsSynchronized => false; // always false, as true implies synchronization via SyncRoot
 
         /// <summary>
         /// Gets an object that can be used to synchronize access to the <see
-        /// cref="T:System.Collections.ICollection"/>. This property is not supported.
-        /// </summary>
-        /// <exception cref="T:System.NotSupportedException">The SyncRoot property is not supported.</exception>
-        object ICollection.SyncRoot
-        {
-            get
-            {
-                throw new NotSupportedException(Environment.GetResourceString("ConcurrentCollection_SyncRoot_NotSupported"));
-            }
-        }
-
-        /// <summary>
-        /// Returns an enumerator that iterates through a collection.
-        /// </summary>
-        /// <returns>An <see cref="T:System.Collections.IEnumerator"/> that can be used to iterate through the collection.</returns>
-        IEnumerator IEnumerable.GetEnumerator()
-        {
-            return ((IEnumerable<T>)this).GetEnumerator();
-        }
-
-        /// <summary>
-        /// Attempts to add an object to the <see
-        /// cref="T:System.Collections.Concurrent.IProducerConsumerCollection{T}"/>.
+        /// cref="ICollection"/>. This property is not supported.
         /// </summary>
-        /// <param name="item">The object to add to the <see
-        /// cref="T:System.Collections.Concurrent.IProducerConsumerCollection{T}"/>. The value can be a null
-        /// reference (Nothing in Visual Basic) for reference types.
-        /// </param>
-        /// <returns>true if the object was added successfully; otherwise, false.</returns>
-        /// <remarks>For <see cref="ConcurrentQueue{T}"/>, this operation will always add the object to the
-        /// end of the <see cref="ConcurrentQueue{T}"/>
-        /// and return true.</remarks>
-        bool IProducerConsumerCollection<T>.TryAdd(T item)
-        {
-            Enqueue(item);
-            return true;
-        }
+        /// <exception cref="NotSupportedException">The SyncRoot property is not supported.</exception>
+        object ICollection.SyncRoot { get { throw new NotSupportedException(Environment.GetResourceString("ConcurrentCollection_SyncRoot_NotSupported")); } }
 
-        /// <summary>
-        /// Attempts to remove and return an object from the <see
-        /// cref="T:System.Collections.Concurrent.IProducerConsumerCollection{T}"/>.
-        /// </summary>
-        /// <param name="item">
-        /// When this method returns, if the operation was successful, <paramref name="item"/> contains the
-        /// object removed. If no object was available to be removed, the value is unspecified.
-        /// </param>
-        /// <returns>true if an element was removed and returned succesfully; otherwise, false.</returns>
-        /// <remarks>For <see cref="ConcurrentQueue{T}"/>, this operation will attempt to remove the object
-        /// from the beginning of the <see cref="ConcurrentQueue{T}"/>.
-        /// </remarks>
-        bool IProducerConsumerCollection<T>.TryTake(out T item)
-        {
-            return TryDequeue(out item);
-        }
+        /// <summary>Returns an enumerator that iterates through a collection.</summary>
+        /// <returns>An <see cref="IEnumerator"/> that can be used to iterate through the collection.</returns>
+        IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable<T>)this).GetEnumerator();
 
         /// <summary>
         /// Gets a value that indicates whether the <see cref="ConcurrentQueue{T}"/> is empty.
@@ -258,126 +226,43 @@ namespace System.Collections.Concurrent
         {
             get
             {
-                Segment head = m_head;
-                if (!head.IsEmpty)
-                    //fast route 1:
-                    //if current head is not empty, then queue is not empty
-                    return false;
-                else if (head.Next == null)
-                    //fast route 2:
-                    //if current head is empty and it's the last segment
-                    //then queue is empty
-                    return true;
-                else
-                //slow route:
-                //current head is empty and it is NOT the last segment,
-                //it means another thread is growing new segment 
-                {
-                    SpinWait spin = new SpinWait();
-                    while (head.IsEmpty)
-                    {
-                        if (head.Next == null)
-                            return true;
-
-                        spin.SpinOnce();
-                        head = m_head;
-                    }
-                    return false;
-                }
+                // IsEmpty == !TryPeek. We use a "resultUsed:false" peek in order to avoid marking
+                // segments as preserved for observation, making IsEmpty a cheaper way than either
+                // TryPeek(out T) or Count == 0 to check whether any elements are in the queue.
+                T ignoredResult;
+                return !TryPeek(out ignoredResult, resultUsed: false);
             }
         }
 
-        /// <summary>
-        /// Copies the elements stored in the <see cref="ConcurrentQueue{T}"/> to a new array.
-        /// </summary>
-        /// <returns>A new array containing a snapshot of elements copied from the <see
-        /// cref="ConcurrentQueue{T}"/>.</returns>
+        /// <summary>Copies the elements stored in the <see cref="ConcurrentQueue{T}"/> to a new array.</summary>
+        /// <returns>A new array containing a snapshot of elements copied from the <see cref="ConcurrentQueue{T}"/>.</returns>
         public T[] ToArray()
         {
-            return ToList().ToArray();
-        }
+            // Snap the current contents for enumeration.
+            Segment head, tail;
+            int headHead, tailTail;
+            SnapForObservation(out head, out headHead, out tail, out tailTail);
 
-        /// <summary>
-        /// Copies the <see cref="ConcurrentQueue{T}"/> elements to a new <see
-        /// cref="T:System.Collections.Generic.List{T}"/>.
-        /// </summary>
-        /// <returns>A new <see cref="T:System.Collections.Generic.List{T}"/> containing a snapshot of
-        /// elements copied from the <see cref="ConcurrentQueue{T}"/>.</returns>
-        private List<T> ToList()
-        {
-            // Increments the number of active snapshot takers. This increment must happen before the snapshot is 
-            // taken. At the same time, Decrement must happen after list copying is over. Only in this way, can it
-            // eliminate race condition when Segment.TryRemove() checks whether m_numSnapshotTakers == 0. 
-            Interlocked.Increment(ref m_numSnapshotTakers);
+            // Count the number of items in that snapped set, and use it to allocate an
+            // array of the right size.
+            long count = GetCount(head, headHead, tail, tailTail);
+            T[] arr = new T[count];
 
-            List<T> list = new List<T>();
-            try
+            // Now enumerate the contents, copying each element into the array.
+            using (IEnumerator<T> e = Enumerate(head, headHead, tail, tailTail))
             {
-                //store head and tail positions in buffer, 
-                Segment head, tail;
-                int headLow, tailHigh;
-                GetHeadTailPositions(out head, out tail, out headLow, out tailHigh);
-
-                if (head == tail)
-                {
-                    head.AddToList(list, headLow, tailHigh);
-                }
-                else
+                int i = 0;
+                while (e.MoveNext())
                 {
-                    head.AddToList(list, headLow, SEGMENT_SIZE - 1);
-                    Segment curr = head.Next;
-                    while (curr != tail)
-                    {
-                        curr.AddToList(list, 0, SEGMENT_SIZE - 1);
-                        curr = curr.Next;
-                    }
-                    //Add tail segment
-                    tail.AddToList(list, 0, tailHigh);
+                    arr[i++] = e.Current;
                 }
+                Debug.Assert(count == i);
             }
-            finally
-            {
-                // This Decrement must happen after copying is over. 
-                Interlocked.Decrement(ref m_numSnapshotTakers);
-            }
-            return list;
-        }
 
-        /// <summary>
-        /// Store the position of the current head and tail positions.
-        /// </summary>
-        /// <param name="head">return the head segment</param>
-        /// <param name="tail">return the tail segment</param>
-        /// <param name="headLow">return the head offset, value range [0, SEGMENT_SIZE]</param>
-        /// <param name="tailHigh">return the tail offset, value range [-1, SEGMENT_SIZE-1]</param>
-        private void GetHeadTailPositions(out Segment head, out Segment tail,
-            out int headLow, out int tailHigh)
-        {
-            head = m_head;
-            tail = m_tail;
-            headLow = head.Low;
-            tailHigh = tail.High;
-            SpinWait spin = new SpinWait();
-
-            //we loop until the observed values are stable and sensible.  
-            //This ensures that any update order by other methods can be tolerated.
-            while (
-                //if head and tail changed, retry
-                head != m_head || tail != m_tail
-                //if low and high pointers, retry
-                || headLow != head.Low || tailHigh != tail.High
-                //if head jumps ahead of tail because of concurrent grow and dequeue, retry
-                || head.m_index > tail.m_index)
-            {
-                spin.SpinOnce();
-                head = m_head;
-                tail = m_tail;
-                headLow = head.Low;
-                tailHigh = tail.High;
-            }
+            // And return it.
+            return arr;
         }
 
-
         /// <summary>
         /// Gets the number of elements contained in the <see cref="ConcurrentQueue{T}"/>.
         /// </summary>
@@ -391,38 +276,140 @@ namespace System.Collections.Concurrent
         {
             get
             {
-                //store head and tail positions in buffer, 
                 Segment head, tail;
-                int headLow, tailHigh;
-                GetHeadTailPositions(out head, out tail, out headLow, out tailHigh);
-
-                if (head == tail)
+                int headHead, headTail, tailHead, tailTail;
+                var spinner = new SpinWait();
+                while (true)
                 {
-                    return tailHigh - headLow + 1;
+                    // Capture the head and tail, as well as the head's head and tail.
+                    head = _head;
+                    tail = _tail;
+                    headHead = Volatile.Read(ref head._headAndTail.Head);
+                    headTail = Volatile.Read(ref head._headAndTail.Tail);
+
+                    if (head == tail)
+                    {
+                        // There was a single segment in the queue.  If the captured
+                        // values still (or again) represent reality, return the segment's
+                        // count. A single segment should be the most common case once the
+                        // queue's size has stabilized after segments have grown to
+                        // the point where growing is no longer needed.
+                        if (head == _head &&
+                            head == _tail &&
+                            headHead == Volatile.Read(ref head._headAndTail.Head) &&
+                            headTail == Volatile.Read(ref head._headAndTail.Tail))
+                        {
+                            return GetCount(head, headHead, headTail);
+                        }
+                    }
+                    else if (head._nextSegment == tail)
+                    {
+                        // There were two segments in the queue.  Get the positions
+                        // from the tail, and if the captured values still (or again) match
+                        // reality, return the sum of the counts from both segments.
+                        tailHead = Volatile.Read(ref tail._headAndTail.Head);
+                        tailTail = Volatile.Read(ref tail._headAndTail.Tail);
+                        if (head == _head &&
+                            tail == _tail &&
+                            headHead == Volatile.Read(ref head._headAndTail.Head) &&
+                            headTail == Volatile.Read(ref head._headAndTail.Tail) &&
+                            tailHead == Volatile.Read(ref tail._headAndTail.Head) &&
+                            tailTail == Volatile.Read(ref tail._headAndTail.Tail))
+                        {
+                            // We got stable values, so we can just compute the sizes based on those
+                            // values and return the sum of the counts of the segments.
+                            return GetCount(head, headHead, headTail) + GetCount(tail, tailHead, tailTail);
+                        }
+                    }
+                    else
+                    {
+                        // There were more than two segments.  Take the slower path, where we freeze the
+                        // queue and then count the now stable segments.
+                        SnapForObservation(out head, out headHead, out tail, out tailTail);
+                        return unchecked((int)GetCount(head, headHead, tail, tailTail));
+                    }
+
+                    // We raced with enqueues/dequeues and captured an inconsistent picture of the queue.
+                    // Spin and try again.
+                    spinner.SpinOnce();
                 }
+            }
+        }
 
-                //head segment
-                int count = SEGMENT_SIZE - headLow;
+        /// <summary>Computes the number of items in a segment based on a fixed head and tail in that segment.</summary>
+        private static int GetCount(Segment s, int head, int tail)
+        {
+            if (head != tail && head != tail - s.FreezeOffset)
+            {
+                head &= s._slotsMask;
+                tail &= s._slotsMask;
+                return head < tail ? tail - head : s._slots.Length - head + tail;
+            }
+            return 0;
+        }
 
-                //middle segment(s), if any, are full.
-                //We don't deal with overflow to be consistent with the behavior of generic types in CLR.
-                count += SEGMENT_SIZE * ((int)(tail.m_index - head.m_index - 1));
+        /// <summary>Gets the number of items in snapped region.</summary>
+        private static long GetCount(Segment head, int headHead, Segment tail, int tailTail)
+        {
+            // All of the segments should have been both frozen for enqueues and preserved for observation.
+            // Validate that here for head and tail; we'll validate it for intermediate segments later.
+            Debug.Assert(head._preservedForObservation);
+            Debug.Assert(head._frozenForEnqueues);
+            Debug.Assert(tail._preservedForObservation);
+            Debug.Assert(tail._frozenForEnqueues);
+
+            long count = 0;
+
+            // Head segment.  We've already marked it as frozen for enqueues, so its tail position is fixed,
+            // and we've already marked it as preserved for observation (before we grabbed the head), so we
+            // can safely enumerate from its head to its tail and access its elements.
+            int headTail = (head == tail ? tailTail : Volatile.Read(ref head._headAndTail.Tail)) - head.FreezeOffset;
+            if (headHead < headTail)
+            {
+                // Mask the head and tail for the head segment
+                headHead &= head._slotsMask;
+                headTail &= head._slotsMask;
+
+                // Increase the count by either the one or two regions, based on whether tail
+                // has wrapped to be less than head.
+                count += headHead < headTail ?
+                    headTail - headHead :
+                    head._slots.Length - headHead + headTail;
+            }
 
-                //tail segment
-                count += tailHigh + 1;
+            // We've enumerated the head.  If the tail is different from the head, we need to
+            // enumerate the remaining segments.
+            if (head != tail)
+            {
+                // Count the contents of each segment between head and tail, not including head and tail.
+                // Since there were segments before these, for our purposes we consider them to start at
+                // the 0th element, and since there is at least one segment after each, each was frozen
+                // by the time we snapped it, so we can iterate until each's frozen tail.
+                for (Segment s = head._nextSegment; s != tail; s = s._nextSegment)
+                {
+                    Debug.Assert(s._preservedForObservation);
+                    Debug.Assert(s._frozenForEnqueues);
+                    count += s._headAndTail.Tail - s.FreezeOffset;
+                }
 
-                return count;
+                // Finally, enumerate the tail.  As with the intermediate segments, there were segments
+                // before this in the snapped region, so we can start counting from the beginning. Unlike
+                // the intermediate segments, we can't just go until the Tail, as that could still be changing;
+                // instead we need to go until the tail we snapped for observation.
+                count += tailTail - tail.FreezeOffset;
             }
-        }
 
+            // Return the computed count.
+            return count;
+        }
 
         /// <summary>
         /// Copies the <see cref="ConcurrentQueue{T}"/> elements to an existing one-dimensional <see
-        /// cref="T:System.Array">Array</see>, starting at the specified array index.
+        /// cref="Array">Array</see>, starting at the specified array index.
         /// </summary>
-        /// <param name="array">The one-dimensional <see cref="T:System.Array">Array</see> that is the
+        /// <param name="array">The one-dimensional <see cref="Array">Array</see> that is the
         /// destination of the elements copied from the
-        /// <see cref="ConcurrentQueue{T}"/>. The <see cref="T:System.Array">Array</see> must have zero-based
+        /// <see cref="ConcurrentQueue{T}"/>. The <see cref="Array">Array</see> must have zero-based
         /// indexing.</param>
         /// <param name="index">The zero-based index in <paramref name="array"/> at which copying
         /// begins.</param>
@@ -442,19 +429,36 @@ namespace System.Collections.Concurrent
             {
                 throw new ArgumentNullException(nameof(array));
             }
+            if (index < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(index));
+            }
 
-            // We must be careful not to corrupt the array, so we will first accumulate an
-            // internal list of elements that we will then copy to the array. This requires
-            // some extra allocation, but is necessary since we don't know up front whether
-            // the array is sufficiently large to hold the stack's contents.
-            ToList().CopyTo(array, index);
-        }
+            // Snap for enumeration
+            Segment head, tail;
+            int headHead, tailTail;
+            SnapForObservation(out head, out headHead, out tail, out tailTail);
 
+            // Get the number of items to be enumerated
+            long count = GetCount(head, headHead, tail, tailTail);
+            if (index > array.Length - count)
+            {
+                throw new ArgumentException(Environment.GetResourceString("Arg_ArrayPlusOffTooSmall"));
+            }
 
-        /// <summary>
-        /// Returns an enumerator that iterates through the <see
-        /// cref="ConcurrentQueue{T}"/>.
-        /// </summary>
+            // Copy the items to the target array
+            int i = index;
+            using (IEnumerator<T> e = Enumerate(head, headHead, tail, tailTail))
+            {
+                while (e.MoveNext())
+                {
+                    array[i++] = e.Current;
+                }
+            }
+            Debug.Assert(count == i - index);
+        }
+
+        /// <summary>Returns an enumerator that iterates through the <see cref="ConcurrentQueue{T}"/>.</summary>
         /// <returns>An enumerator for the contents of the <see
         /// cref="ConcurrentQueue{T}"/>.</returns>
         /// <remarks>
@@ -465,124 +469,195 @@ namespace System.Collections.Concurrent
         /// </remarks>
         public IEnumerator<T> GetEnumerator()
         {
-            // Increments the number of active snapshot takers. This increment must happen before the snapshot is 
-            // taken. At the same time, Decrement must happen after the enumeration is over. Only in this way, can it
-            // eliminate race condition when Segment.TryRemove() checks whether m_numSnapshotTakers == 0. 
-            Interlocked.Increment(ref m_numSnapshotTakers);
-
-            // Takes a snapshot of the queue. 
-            // A design flaw here: if a Thread.Abort() happens, we cannot decrement m_numSnapshotTakers. But we cannot 
-            // wrap the following with a try/finally block, otherwise the decrement will happen before the yield return 
-            // statements in the GetEnumerator (head, tail, headLow, tailHigh) method.           
             Segment head, tail;
-            int headLow, tailHigh;
-            GetHeadTailPositions(out head, out tail, out headLow, out tailHigh);
-
-            //If we put yield-return here, the iterator will be lazily evaluated. As a result a snapshot of
-            // the queue is not taken when GetEnumerator is initialized but when MoveNext() is first called.
-            // This is inconsistent with existing generic collections. In order to prevent it, we capture the 
-            // value of m_head in a buffer and call out to a helper method.
-            //The old way of doing this was to return the ToList().GetEnumerator(), but ToList() was an 
-            // unnecessary perfomance hit.
-            return GetEnumerator(head, tail, headLow, tailHigh);
+            int headHead, tailTail;
+            SnapForObservation(out head, out headHead, out tail, out tailTail);
+            return Enumerate(head, headHead, tail, tailTail);
         }
 
         /// <summary>
-        /// Helper method of GetEnumerator to seperate out yield return statement, and prevent lazy evaluation. 
+        /// Gets the head and tail information of the current contents of the queue.
+        /// After this call returns, the specified region can be enumerated any number
+        /// of times and will not change.
         /// </summary>
-        private IEnumerator<T> GetEnumerator(Segment head, Segment tail, int headLow, int tailHigh)
+        private void SnapForObservation(out Segment head, out int headHead, out Segment tail, out int tailTail)
         {
-            try
+            lock (_crossSegmentLock) // _head and _tail may only change while the lock is held.
             {
-                SpinWait spin = new SpinWait();
+                // Snap the head and tail
+                head = _head;
+                tail = _tail;
+                Debug.Assert(head != null);
+                Debug.Assert(tail != null);
+                Debug.Assert(tail._nextSegment == null);
+
+                // Mark them and all segments in between as preserving, and ensure no additional items
+                // can be added to the tail.
+                for (Segment s = head; ; s = s._nextSegment)
+                {
+                    s._preservedForObservation = true;
+                    if (s == tail) break;
+                    Debug.Assert(s._frozenForEnqueues); // any non-tail should already be marked
+                }
+                tail.EnsureFrozenForEnqueues(); // we want to prevent the tailTail from moving
 
-                if (head == tail)
+                // At this point, any dequeues from any segment won't overwrite the value, and
+                // none of the existing segments can have new items enqueued.
+
+                headHead = Volatile.Read(ref head._headAndTail.Head);
+                tailTail = Volatile.Read(ref tail._headAndTail.Tail);
+            }
+        }
+
+        /// <summary>Gets the item stored in the <paramref name="i"/>th entry in <paramref name="segment"/>.</summary>
+        private T GetItemWhenAvailable(Segment segment, int i)
+        {
+            Debug.Assert(segment._preservedForObservation);
+
+            // Get the expected value for the sequence number
+            int expectedSequenceNumberAndMask = (i + 1) & segment._slotsMask;
+
+            // If the expected sequence number is not yet written, we're still waiting for
+            // an enqueuer to finish storing it.  Spin until it's there.
+            if ((segment._slots[i].SequenceNumber & segment._slotsMask) != expectedSequenceNumberAndMask)
+            {
+                var spinner = new SpinWait();
+                while ((Volatile.Read(ref segment._slots[i].SequenceNumber) & segment._slotsMask) != expectedSequenceNumberAndMask)
                 {
-                    for (int i = headLow; i <= tailHigh; i++)
-                    {
-                        // If the position is reserved by an Enqueue operation, but the value is not written into,
-                        // spin until the value is available.
-                        spin.Reset();
-                        while (!head.m_state[i].m_value)
-                        {
-                            spin.SpinOnce();
-                        }
-                        yield return head.m_array[i];
-                    }
+                    spinner.SpinOnce();
+                }
+            }
+
+            // Return the value from the slot.
+            return segment._slots[i].Item;
+        }
+
+        private IEnumerator<T> Enumerate(Segment head, int headHead, Segment tail, int tailTail)
+        {
+            Debug.Assert(head._preservedForObservation);
+            Debug.Assert(head._frozenForEnqueues);
+            Debug.Assert(tail._preservedForObservation);
+            Debug.Assert(tail._frozenForEnqueues);
+
+            // Head segment.  We've already marked it as not accepting any more enqueues,
+            // so its tail position is fixed, and we've already marked it as preserved for
+            // enumeration (before we grabbed its head), so we can safely enumerate from
+            // its head to its tail.
+            int headTail = (head == tail ? tailTail : Volatile.Read(ref head._headAndTail.Tail)) - head.FreezeOffset;
+            if (headHead < headTail)
+            {
+                headHead &= head._slotsMask;
+                headTail &= head._slotsMask;
+
+                if (headHead < headTail)
+                {
+                    for (int i = headHead; i < headTail; i++) yield return GetItemWhenAvailable(head, i);
                 }
                 else
                 {
-                    //iterate on head segment
-                    for (int i = headLow; i < SEGMENT_SIZE; i++)
-                    {
-                        // If the position is reserved by an Enqueue operation, but the value is not written into,
-                        // spin until the value is available.
-                        spin.Reset();
-                        while (!head.m_state[i].m_value)
-                        {
-                            spin.SpinOnce();
-                        }
-                        yield return head.m_array[i];
-                    }
-                    //iterate on middle segments
-                    Segment curr = head.Next;
-                    while (curr != tail)
-                    {
-                        for (int i = 0; i < SEGMENT_SIZE; i++)
-                        {
-                            // If the position is reserved by an Enqueue operation, but the value is not written into,
-                            // spin until the value is available.
-                            spin.Reset();
-                            while (!curr.m_state[i].m_value)
-                            {
-                                spin.SpinOnce();
-                            }
-                            yield return curr.m_array[i];
-                        }
-                        curr = curr.Next;
-                    }
+                    for (int i = headHead; i < head._slots.Length; i++) yield return GetItemWhenAvailable(head, i);
+                    for (int i = 0; i < headTail; i++) yield return GetItemWhenAvailable(head, i);
+                }
+            }
 
-                    //iterate on tail segment
-                    for (int i = 0; i <= tailHigh; i++)
+            // We've enumerated the head.  If the tail is the same, we're done.
+            if (head != tail)
+            {
+                // Each segment between head and tail, not including head and tail.  Since there were
+                // segments before these, for our purposes we consider it to start at the 0th element.
+                for (Segment s = head._nextSegment; s != tail; s = s._nextSegment)
+                {
+                    Debug.Assert(s._preservedForObservation, "Would have had to been preserved as a segment part of enumeration");
+                    Debug.Assert(s._frozenForEnqueues, "Would have had to be frozen for enqueues as it's intermediate");
+
+                    int sTail = s._headAndTail.Tail - s.FreezeOffset;
+                    for (int i = 0; i < sTail; i++)
                     {
-                        // If the position is reserved by an Enqueue operation, but the value is not written into,
-                        // spin until the value is available.
-                        spin.Reset();
-                        while (!tail.m_state[i].m_value)
-                        {
-                            spin.SpinOnce();
-                        }
-                        yield return tail.m_array[i];
+                        yield return GetItemWhenAvailable(s, i);
                     }
                 }
-            }
-            finally
-            {
-                // This Decrement must happen after the enumeration is over. 
-                Interlocked.Decrement(ref m_numSnapshotTakers);
+
+                // Enumerate the tail.  Since there were segments before this, we can just start at
+                // its beginning, and iterate until the tail we already grabbed.
+                tailTail -= tail.FreezeOffset;
+                for (int i = 0; i < tailTail; i++)
+                {
+                    yield return GetItemWhenAvailable(tail, i);
+                }
             }
         }
 
-        /// <summary>
-        /// Adds an object to the end of the <see cref="ConcurrentQueue{T}"/>.
-        /// </summary>
-        /// <param name="item">The object to add to the end of the <see
-        /// cref="ConcurrentQueue{T}"/>. The value can be a null reference
-        /// (Nothing in Visual Basic) for reference types.
+        /// <summary>Round the specified value up to the next power of 2, if it isn't one already.</summary>
+        private static int RoundUpToPowerOf2(int i)
+        {
+            --i;
+            i |= i >> 1;
+            i |= i >> 2;
+            i |= i >> 4;
+            i |= i >> 8;
+            i |= i >> 16;
+            return i + 1;
+        }
+
+        /// <summary>Adds an object to the end of the <see cref="ConcurrentQueue{T}"/>.</summary>
+        /// <param name="item">
+        /// The object to add to the end of the <see cref="ConcurrentQueue{T}"/>.
+        /// The value can be a null reference (Nothing in Visual Basic) for reference types.
         /// </param>
         public void Enqueue(T item)
         {
-            SpinWait spin = new SpinWait();
+            // Try to enqueue to the current tail.
+            if (!_tail.TryEnqueue(item))
+            {
+                // If we're unable to, we need to take a slow path that will
+                // try to add a new tail segment.
+                EnqueueSlow(item);
+            }
+        }
+
+        /// <summary>Adds to the end of the queue, adding a new segment if necessary.</summary>
+        private void EnqueueSlow(T item)
+        {
             while (true)
             {
-                Segment tail = m_tail;
-                if (tail.TryAppend(item))
+                Segment tail = _tail;
+
+                // Try to append to the existing tail.
+                if (tail.TryEnqueue(item))
+                {
                     return;
-                spin.SpinOnce();
+                }
+
+                // If we were unsuccessful, take the lock so that we can compare and manipulate
+                // the tail.  Assuming another enqueuer hasn't already added a new segment,
+                // do so, then loop around to try enqueueing again.
+                lock (_crossSegmentLock)
+                {
+                    if (tail == _tail)
+                    {
+                        // Make sure no one else can enqueue to this segment.
+                        tail.EnsureFrozenForEnqueues();
+
+                        // We determine the new segment's length based on the old length.
+                        // In general, we double the size of the segment, to make it less likely
+                        // that we'll need to grow again.  However, if the tail segment is marked
+                        // as preserved for observation, something caused us to avoid reusing this
+                        // segment, and if that happens a lot and we grow, we'll end up allocating
+                        // lots of wasted space.  As such, in such situations we reset back to the
+                        // initial segment length; if these observations are happening frequently,
+                        // this will help to avoid wasted memory, and if they're not, we'll
+                        // relatively quickly grow again to a larger size.
+                        int nextSize = tail._preservedForObservation ? InitialSegmentLength : tail.Capacity * 2;
+                        var newTail = new Segment(nextSize);
+
+                        // Hook up the new tail.
+                        tail._nextSegment = newTail;
+                        _tail = newTail;
+                    }
+                }
             }
         }
 
-
         /// <summary>
         /// Attempts to remove and return the object at the beginning of the <see
         /// cref="ConcurrentQueue{T}"/>.
@@ -591,369 +666,456 @@ namespace System.Collections.Concurrent
         /// When this method returns, if the operation was successful, <paramref name="result"/> contains the
         /// object removed. If no object was available to be removed, the value is unspecified.
         /// </param>
-        /// <returns>true if an element was removed and returned from the beggining of the <see
-        /// cref="ConcurrentQueue{T}"/>
-        /// succesfully; otherwise, false.</returns>
-        public bool TryDequeue(out T result)
+        /// <returns>
+        /// true if an element was removed and returned from the beginning of the
+        /// <see cref="ConcurrentQueue{T}"/> successfully; otherwise, false.
+        /// </returns>
+        public bool TryDequeue(out T result) =>
+            _head.TryDequeue(out result) || // fast-path that operates just on the head segment
+            TryDequeueSlow(out result); // slow path that needs to fix up segments
+
+        /// <summary>Tries to dequeue an item, removing empty segments as needed.</summary>
+        private bool TryDequeueSlow(out T item)
         {
-            while (!IsEmpty)
+            while (true)
             {
-                Segment head = m_head;
-                if (head.TryRemove(out result))
+                // Get the current head
+                Segment head = _head;
+
+                // Try to take.  If we're successful, we're done.
+                if (head.TryDequeue(out item))
+                {
+                    return true;
+                }
+
+                // Check to see whether this segment is the last. If it is, we can consider
+                // this to be a moment-in-time empty condition (even though between the TryDequeue
+                // check and this check, another item could have arrived).
+                if (head._nextSegment == null)
+                {
+                    item = default(T);
+                    return false;
+                }
+
+                // At this point we know that head.Next != null, which means
+                // this segment has been frozen for additional enqueues. But between
+                // the time that we ran TryDequeue and checked for a next segment,
+                // another item could have been added.  Try to dequeue one more time
+                // to confirm that the segment is indeed empty.
+                Debug.Assert(head._frozenForEnqueues);
+                if (head.TryDequeue(out item))
+                {
                     return true;
-                //since method IsEmpty spins, we don't need to spin in the while loop
+                }
+
+                // This segment is frozen (nothing more can be added) and empty (nothing is in it).
+                // Update head to point to the next segment in the list, assuming no one's beat us to it.
+                lock (_crossSegmentLock)
+                {
+                    if (head == _head)
+                    {
+                        _head = head._nextSegment;
+                    }
+                }
             }
-            result = default(T);
-            return false;
         }
 
         /// <summary>
         /// Attempts to return an object from the beginning of the <see cref="ConcurrentQueue{T}"/>
         /// without removing it.
         /// </summary>
-        /// <param name="result">When this method returns, <paramref name="result"/> contains an object from
-        /// the beginning of the <see cref="T:System.Collections.Concurrent.ConccurrentQueue{T}"/> or an
-        /// unspecified value if the operation failed.</param>
+        /// <param name="result">
+        /// When this method returns, <paramref name="result"/> contains an object from
+        /// the beginning of the <see cref="Concurrent.ConcurrentQueue{T}"/> or default(T)
+        /// if the operation failed.
+        /// </param>
         /// <returns>true if and object was returned successfully; otherwise, false.</returns>
-        public bool TryPeek(out T result)
-        {
-            Interlocked.Increment(ref m_numSnapshotTakers);
+        /// <remarks>
+        /// For determining whether the collection contains any items, use of the <see cref="IsEmpty"/>
+        /// property is recommended rather than peeking.
+        /// </remarks>
+        public bool TryPeek(out T result) => TryPeek(out result, resultUsed: true);
 
-            while (!IsEmpty)
+        /// <summary>Attempts to retrieve the value for the first element in the queue.</summary>
+        /// <param name="result">The value of the first element, if found.</param>
+        /// <param name="resultUsed">true if the result is neede; otherwise false if only the true/false outcome is needed.</param>
+        /// <returns>true if an element was found; otherwise, false.</returns>
+        private bool TryPeek(out T result, bool resultUsed)
+        {
+            // Starting with the head segment, look through all of the segments
+            // for the first one we can find that's not empty.
+            Segment s = _head;
+            while (true)
             {
-                Segment head = m_head;
-                if (head.TryPeek(out result))
+                // Grab the next segment from this one, before we peek.
+                // This is to be able to see whether the value has changed
+                // during the peek operation.
+                Segment next = Volatile.Read(ref s._nextSegment);
+
+                // Peek at the segment.  If we find an element, we're done.
+                if (s.TryPeek(out result, resultUsed))
                 {
-                    Interlocked.Decrement(ref m_numSnapshotTakers);
                     return true;
                 }
-                //since method IsEmpty spins, we don't need to spin in the while loop
+
+                // The current segment was empty at the moment we checked.
+
+                if (next != null)
+                {
+                    // If prior to the peek there was already a next segment, then
+                    // during the peek no additional items could have been enqueued
+                    // to it and we can just move on to check the next segment.
+                    Debug.Assert(next == s._nextSegment);
+                    s = next;
+                }
+                else if (Volatile.Read(ref s._nextSegment) == null)
+                {
+                    // The next segment is null.  Nothing more to peek at.
+                    break;
+                }
+
+                // The next segment was null before we peeked but non-null after.
+                // That means either when we peeked the first segment had
+                // already been frozen but the new segment not yet added,
+                // or that the first segment was empty and between the time
+                // that we peeked and then checked _nextSegment, so many items
+                // were enqueued that we filled the first segment and went
+                // into the next.  Since we need to peek in order, we simply
+                // loop around again to peek on the same segment.  The next
+                // time around on this segment we'll then either successfully
+                // peek or we'll find that next was non-null before peeking,
+                // and we'll traverse to that segment.
             }
+
             result = default(T);
-            Interlocked.Decrement(ref m_numSnapshotTakers);
             return false;
         }
 
-
         /// <summary>
-        /// private class for ConcurrentQueue. 
-        /// a queue is a linked list of small arrays, each node is called a segment.
-        /// A segment contains an array, a pointer to the next segment, and m_low, m_high indices recording
-        /// the first and last valid elements of the array.
+        /// Removes all objects from the <see cref="ConcurrentQueue{T}"/>.
         /// </summary>
-        private class Segment
+        public void Clear()
         {
-            //we define two volatile arrays: m_array and m_state. Note that the accesses to the array items 
-            //do not get volatile treatment. But we don't need to worry about loading adjacent elements or 
-            //store/load on adjacent elements would suffer reordering. 
-            // - Two stores:  these are at risk, but CLRv2 memory model guarantees store-release hence we are safe.
-            // - Two loads: because one item from two volatile arrays are accessed, the loads of the array references
-            //          are sufficient to prevent reordering of the loads of the elements.
-            internal volatile T[] m_array;
-
-            // For each entry in m_array, the corresponding entry in m_state indicates whether this position contains 
-            // a valid value. m_state is initially all false. 
-            internal volatile VolatileBool[] m_state;
-
-            //pointer to the next segment. null if the current segment is the last segment
-            private volatile Segment m_next;
-
-            //We use this zero based index to track how many segments have been created for the queue, and
-            //to compute how many active segments are there currently. 
-            // * The number of currently active segments is : m_tail.m_index - m_head.m_index + 1;
-            // * m_index is incremented with every Segment.Grow operation. We use Int64 type, and we can safely 
-            //   assume that it never overflows. To overflow, we need to do 2^63 increments, even at a rate of 4 
-            //   billion (2^32) increments per second, it takes 2^31 seconds, which is about 64 years.
-            internal readonly long m_index;
-
-            //indices of where the first and last valid values
-            // - m_low points to the position of the next element to pop from this segment, range [0, infinity)
-            //      m_low >= SEGMENT_SIZE implies the segment is disposable
-            // - m_high points to the position of the latest pushed element, range [-1, infinity)
-            //      m_high == -1 implies the segment is new and empty
-            //      m_high >= SEGMENT_SIZE-1 means this segment is ready to grow. 
-            //        and the thread who sets m_high to SEGMENT_SIZE-1 is responsible to grow the segment
-            // - Math.Min(m_low, SEGMENT_SIZE) > Math.Min(m_high, SEGMENT_SIZE-1) implies segment is empty
-            // - initially m_low =0 and m_high=-1;
-            private volatile int m_low;
-            private volatile int m_high;
-
-            private volatile ConcurrentQueue<T> m_source;
-
-            /// <summary>
-            /// Create and initialize a segment with the specified index.
-            /// </summary>
-            internal Segment(long index, ConcurrentQueue<T> source)
+            lock (_crossSegmentLock)
             {
-                m_array = new T[SEGMENT_SIZE];
-                m_state = new VolatileBool[SEGMENT_SIZE]; //all initialized to false
-                m_high = -1;
-                Debug.Assert(index >= 0);
-                m_index = index;
-                m_source = source;
-            }
-
-            /// <summary>
-            /// return the next segment
-            /// </summary>
-            internal Segment Next
-            {
-                get { return m_next; }
-            }
-
-
-            /// <summary>
-            /// return true if the current segment is empty (doesn't have any element available to dequeue, 
-            /// false otherwise
-            /// </summary>
-            internal bool IsEmpty
-            {
-                get { return (Low > High); }
-            }
-
-            /// <summary>
-            /// Add an element to the tail of the current segment
-            /// exclusively called by ConcurrentQueue.InitializedFromCollection
-            /// InitializeFromCollection is responsible to guaratee that there is no index overflow,
-            /// and there is no contention
-            /// </summary>
-            /// <param name="value"></param>
-            internal void UnsafeAdd(T value)
-            {
-                Debug.Assert(m_high < SEGMENT_SIZE - 1);
-                m_high++;
-                m_array[m_high] = value;
-                m_state[m_high].m_value = true;
+                // Simply substitute a new segment for the existing head/tail,
+                // as is done in the constructor.  Operations currently in flight
+                // may still read from or write to an existing segment that's
+                // getting dropped, meaning that in flight operations may not be
+                // linear with regards to this clear operation.  To help mitigate
+                // in-flight operations enqueuing onto the tail that's about to
+                // be dropped, we first freeze it; that'll force enqueuers to take
+                // this lock to synchronize and see the new tail.
+                _tail.EnsureFrozenForEnqueues();
+                _tail = _head = new Segment(InitialSegmentLength);
             }
+        }
 
-            /// <summary>
-            /// Create a new segment and append to the current one
-            /// Does not update the m_tail pointer
-            /// exclusively called by ConcurrentQueue.InitializedFromCollection
-            /// InitializeFromCollection is responsible to guaratee that there is no index overflow,
-            /// and there is no contention
-            /// </summary>
-            /// <returns>the reference to the new Segment</returns>
-            internal Segment UnsafeGrow()
+        /// <summary>
+        /// Provides a multi-producer, multi-consumer thread-safe bounded segment.  When the queue is full,
+        /// enqueues fail and return false.  When the queue is empty, dequeues fail and return null.
+        /// These segments are linked together to form the unbounded <see cref="ConcurrentQueue{T}"/>. 
+        /// </summary>
+        [DebuggerDisplay("Capacity = {Capacity}")]
+        private sealed class Segment
+        {
+            // Segment design is inspired by the algorithm outlined at:
+            // http://www.1024cores.net/home/lock-free-algorithms/queues/bounded-mpmc-queue
+
+            /// <summary>The array of items in this queue.  Each slot contains the item in that slot and its "sequence number".</summary>
+            internal readonly Slot[] _slots;
+            /// <summary>Mask for quickly accessing a position within the queue's array.</summary>
+            internal readonly int _slotsMask;
+            /// <summary>The head and tail positions, with padding to help avoid false sharing contention.</summary>
+            /// <remarks>Dequeueing happens from the head, enqueueing happens at the tail.</remarks>
+            internal PaddedHeadAndTail _headAndTail; // mutable struct: do not make this readonly
+
+            /// <summary>Indicates whether the segment has been marked such that dequeues don't overwrite the removed data.</summary>
+            internal bool _preservedForObservation;
+            /// <summary>Indicates whether the segment has been marked such that no additional items may be enqueued.</summary>
+            internal bool _frozenForEnqueues;
+            /// <summary>The segment following this one in the queue, or null if this segment is the last in the queue.</summary>
+            internal Segment _nextSegment;
+
+            /// <summary>Creates the segment.</summary>
+            /// <param name="boundedLength">
+            /// The maximum number of elements the segment can contain.  Must be a power of 2.
+            /// </param>
+            public Segment(int boundedLength)
             {
-                Debug.Assert(m_high >= SEGMENT_SIZE - 1);
-                Segment newSegment = new Segment(m_index + 1, m_source); //m_index is Int64, we don't need to worry about overflow
-                m_next = newSegment;
-                return newSegment;
+                // Validate the length
+                Debug.Assert(boundedLength >= 2, $"Must be >= 2, got {boundedLength}");
+                Debug.Assert((boundedLength & (boundedLength - 1)) == 0, $"Must be a power of 2, got {boundedLength}");
+
+                // Initialize the slots and the mask.  The mask is used as a way of quickly doing "% _slots.Length",
+                // instead letting us do "& _slotsMask".
+                _slots = new Slot[boundedLength];
+                _slotsMask = boundedLength - 1;
+
+                // Initialize the sequence number for each slot.  The sequence number provides a ticket that
+                // allows dequeuers to know whether they can dequeue and enqueuers to know whether they can
+                // enqueue.  An enqueuer at position N can enqueue when the sequence number is N, and a dequeuer
+                // for position N can dequeue when the sequence number is N + 1.  When an enqueuer is done writing
+                // at position N, it sets the sequence number to N so that a dequeuer will be able to dequeue,
+                // and when a dequeuer is done dequeueing at position N, it sets the sequence number to N + _slots.Length,
+                // so that when an enqueuer loops around the slots, it'll find that the sequence number at
+                // position N is N.  This also means that when an enqueuer finds that at position N the sequence
+                // number is < N, there is still a value in that slot, i.e. the segment is full, and when a
+                // dequeuer finds that the value in a slot is < N + 1, there is nothing currently available to
+                // dequeue. (It is possible for multiple enqueuers to enqueue concurrently, writing into
+                // subsequent slots, and to have the first enqueuer take longer, so that the slots for 1, 2, 3, etc.
+                // may have values, but the 0th slot may still be being filled... in that case, TryDequeue will
+                // return false.)
+                for (int i = 0; i < _slots.Length; i++)
+                {
+                    _slots[i].SequenceNumber = i;
+                }
             }
 
-            /// <summary>
-            /// Create a new segment and append to the current one
-            /// Update the m_tail pointer
-            /// This method is called when there is no contention
-            /// </summary>
-            internal void Grow()
-            {
-                //no CAS is needed, since there is no contention (other threads are blocked, busy waiting)
-                Segment newSegment = new Segment(m_index + 1, m_source);  //m_index is Int64, we don't need to worry about overflow
-                m_next = newSegment;
-                Debug.Assert(m_source.m_tail == this);
-                m_source.m_tail = m_next;
-            }
+            /// <summary>Gets the number of elements this segment can store.</summary>
+            internal int Capacity => _slots.Length;
 
+            /// <summary>Gets the "freeze offset" for this segment.</summary>
+            internal int FreezeOffset => _slots.Length * 2;
 
             /// <summary>
-            /// Try to append an element at the end of this segment.
+            /// Ensures that the segment will not accept any subsequent enqueues that aren't already underway.
             /// </summary>
-            /// <param name="value">the element to append</param>
-            /// <param name="tail">The tail.</param>
-            /// <returns>true if the element is appended, false if the current segment is full</returns>
-            /// <remarks>if appending the specified element succeeds, and after which the segment is full, 
-            /// then grow the segment</remarks>
-            internal bool TryAppend(T value)
+            /// <remarks>
+            /// When we mark a segment as being frozen for additional enqueues,
+            /// we set the <see cref="_frozenForEnqueues"/> bool, but that's mostly
+            /// as a small helper to avoid marking it twice.  The real marking comes
+            /// by modifying the Tail for the segment, increasing it by this
+            /// <see cref="FreezeOffset"/>.  This effectively knocks it off the
+            /// sequence expected by future enqueuers, such that any additional enqueuer
+            /// will be unable to enqueue due to it not lining up with the expected
+            /// sequence numbers.  This value is chosen specially so that Tail will grow
+            /// to a value that maps to the same slot but that won't be confused with
+            /// any other enqueue/dequeue sequence number.
+            /// </remarks>
+            internal void EnsureFrozenForEnqueues() // must only be called while queue's segment lock is held
             {
-                //quickly check if m_high is already over the boundary, if so, bail out
-                if (m_high >= SEGMENT_SIZE - 1)
+                if (!_frozenForEnqueues) // flag used to ensure we don't increase the Tail more than once if frozen more than once
                 {
-                    return false;
-                }
+                    _frozenForEnqueues = true;
 
-                //Now we will use a CAS to increment m_high, and store the result in newhigh.
-                //Depending on how many free spots left in this segment and how many threads are doing this Increment
-                //at this time, the returning "newhigh" can be 
-                // 1) < SEGMENT_SIZE - 1 : we took a spot in this segment, and not the last one, just insert the value
-                // 2) == SEGMENT_SIZE - 1 : we took the last spot, insert the value AND grow the segment
-                // 3) > SEGMENT_SIZE - 1 : we failed to reserve a spot in this segment, we return false to 
-                //    Queue.Enqueue method, telling it to try again in the next segment.
-
-                int newhigh = SEGMENT_SIZE; //initial value set to be over the boundary
-
-                //We need do Interlocked.Increment and value/state update in a finally block to ensure that they run
-                //without interuption. This is to prevent anything from happening between them, and another dequeue
-                //thread maybe spinning forever to wait for m_state[] to be true;
-                try
-                { }
-                finally
-                {
-                    newhigh = Interlocked.Increment(ref m_high);
-                    if (newhigh <= SEGMENT_SIZE - 1)
+                    // Increase the tail by FreezeOffset, spinning until we're successful in doing so.
+                    var spinner = new SpinWait();
+                    while (true)
                     {
-                        m_array[newhigh] = value;
-                        m_state[newhigh].m_value = true;
-                    }
-
-                    //if this thread takes up the last slot in the segment, then this thread is responsible
-                    //to grow a new segment. Calling Grow must be in the finally block too for reliability reason:
-                    //if thread abort during Grow, other threads will be left busy spinning forever.
-                    if (newhigh == SEGMENT_SIZE - 1)
-                    {
-                        Grow();
+                        int tail = Volatile.Read(ref _headAndTail.Tail);
+                        if (Interlocked.CompareExchange(ref _headAndTail.Tail, tail + FreezeOffset, tail) == tail)
+                        {
+                            break;
+                        }
+                        spinner.SpinOnce();
                     }
                 }
-
-                //if newhigh <= SEGMENT_SIZE-1, it means the current thread successfully takes up a spot
-                return newhigh <= SEGMENT_SIZE - 1;
             }
 
-
-            /// <summary>
-            /// try to remove an element from the head of current segment
-            /// </summary>
-            /// <param name="result">The result.</param>
-            /// <param name="head">The head.</param>
-            /// <returns>return false only if the current segment is empty</returns>
-            internal bool TryRemove(out T result)
+            /// <summary>Tries to dequeue an element from the queue.</summary>
+            public bool TryDequeue(out T item)
             {
-                SpinWait spin = new SpinWait();
-                int lowLocal = Low, highLocal = High;
-                while (lowLocal <= highLocal)
+                // Loop in case of contention...
+                var spinner = new SpinWait();
+                while (true)
                 {
-                    //try to update m_low
-                    if (Interlocked.CompareExchange(ref m_low, lowLocal + 1, lowLocal) == lowLocal)
-                    {
-                        //if the specified value is not available (this spot is taken by a push operation,
-                        // but the value is not written into yet), then spin
-                        SpinWait spinLocal = new SpinWait();
-                        while (!m_state[lowLocal].m_value)
-                        {
-                            spinLocal.SpinOnce();
-                        }
-                        result = m_array[lowLocal];
+                    // Get the head at which to try to dequeue.
+                    int currentHead = Volatile.Read(ref _headAndTail.Head);
+                    int slotsIndex = currentHead & _slotsMask;
 
-                        // If there is no other thread taking snapshot (GetEnumerator(), ToList(), etc), reset the deleted entry to null.
-                        // It is ok if after this conditional check m_numSnapshotTakers becomes > 0, because new snapshots won't include 
-                        // the deleted entry at m_array[lowLocal]. 
-                        if (m_source.m_numSnapshotTakers <= 0)
-                        {
-                            m_array[lowLocal] = default(T); //release the reference to the object. 
-                        }
+                    // Read the sequence number for the head position.
+                    int sequenceNumber = Volatile.Read(ref _slots[slotsIndex].SequenceNumber);
 
-                        //if the current thread sets m_low to SEGMENT_SIZE, which means the current segment becomes
-                        //disposable, then this thread is responsible to dispose this segment, and reset m_head 
-                        if (lowLocal + 1 >= SEGMENT_SIZE)
+                    // We can dequeue from this slot if it's been filled by an enqueuer, which
+                    // would have left the sequence number at pos+1.
+                    int diff = sequenceNumber - (currentHead + 1);
+                    if (diff == 0)
+                    {
+                        // We may be racing with other dequeuers.  Try to reserve the slot by incrementing
+                        // the head.  Once we've done that, no one else will be able to read from this slot,
+                        // and no enqueuer will be able to read from this slot until we've written the new
+                        // sequence number. WARNING: The next few lines are not reliable on a runtime that
+                        // supports thread aborts. If a thread abort were to sneak in after the CompareExchange
+                        // but before the Volatile.Write, enqueuers trying to enqueue into this slot would
+                        // spin indefinitely.  If this implementation is ever used on such a platform, this
+                        // if block should be wrapped in a finally / prepared region.
+                        if (Interlocked.CompareExchange(ref _headAndTail.Head, currentHead + 1, currentHead) == currentHead)
                         {
-                            //  Invariant: we only dispose the current m_head, not any other segment
-                            //  In usual situation, disposing a segment is simply seting m_head to m_head.m_next
-                            //  But there is one special case, where m_head and m_tail points to the same and ONLY
-                            //segment of the queue: Another thread A is doing Enqueue and finds that it needs to grow,
-                            //while the *current* thread is doing *this* Dequeue operation, and finds that it needs to 
-                            //dispose the current (and ONLY) segment. Then we need to wait till thread A finishes its 
-                            //Grow operation, this is the reason of having the following while loop
-                            spinLocal = new SpinWait();
-                            while (m_next == null)
+                            // Successfully reserved the slot.  Note that after the above CompareExchange, other threads
+                            // trying to dequeue from this slot will end up spinning until we do the subsequent Write.
+                            item = _slots[slotsIndex].Item;
+                            if (!Volatile.Read(ref _preservedForObservation))
                             {
-                                spinLocal.SpinOnce();
+                                // If we're preserving, though, we don't zero out the slot, as we need it for
+                                // enumerations, peeking, ToArray, etc.  And we don't update the sequence number,
+                                // so that an enqueuer will see it as full and be forced to move to a new segment.
+                                _slots[slotsIndex].Item = default(T);
+                                Volatile.Write(ref _slots[slotsIndex].SequenceNumber, currentHead + _slots.Length);
                             }
-                            Debug.Assert(m_source.m_head == this);
-                            m_source.m_head = m_next;
+                            return true;
                         }
-                        return true;
                     }
-                    else
+                    else if (diff < 0)
                     {
-                        //CAS failed due to contention: spin briefly and retry
-                        spin.SpinOnce();
-                        lowLocal = Low; highLocal = High;
+                        // The sequence number was less than what we needed, which means this slot doesn't
+                        // yet contain a value we can dequeue, i.e. the segment is empty.  Technically it's
+                        // possible that multiple enqueuers could have written concurrently, with those
+                        // getting later slots actually finishing first, so there could be elements after
+                        // this one that are available, but we need to dequeue in order.  So before declaring
+                        // failure and that the segment is empty, we check the tail to see if we're actually
+                        // empty or if we're just waiting for items in flight or after this one to become available.
+                        bool frozen = _frozenForEnqueues;
+                        int currentTail = Volatile.Read(ref _headAndTail.Tail);
+                        if (currentTail - currentHead <= 0 || (frozen && (currentTail - FreezeOffset - currentHead <= 0)))
+                        {
+                            item = default(T);
+                            return false;
+                        }
+
+                        // It's possible it could have become frozen after we checked _frozenForEnqueues
+                        // and before reading the tail.  That's ok: in that rare race condition, we just
+                        // loop around again.
                     }
-                }//end of while
-                result = default(T);
-                return false;
+
+                    // Lost a race. Spin a bit, then try again.
+                    spinner.SpinOnce();
+                }
             }
 
-            /// <summary>
-            /// try to peek the current segment
-            /// </summary>
-            /// <param name="result">holds the return value of the element at the head position, 
-            /// value set to default(T) if there is no such an element</param>
-            /// <returns>true if there are elements in the current segment, false otherwise</returns>
-            internal bool TryPeek(out T result)
+            /// <summary>Tries to peek at an element from the queue, without removing it.</summary>
+            public bool TryPeek(out T result, bool resultUsed)
             {
-                result = default(T);
-                int lowLocal = Low;
-                if (lowLocal > High)
-                    return false;
-                SpinWait spin = new SpinWait();
-                while (!m_state[lowLocal].m_value)
+                if (resultUsed)
                 {
-                    spin.SpinOnce();
+                    // In order to ensure we don't get a torn read on the value, we mark the segment
+                    // as preserving for observation.  Additional items can still be enqueued to this
+                    // segment, but no space will be freed during dequeues, such that the segment will
+                    // no longer be reusable.
+                    _preservedForObservation = true;
+                    Interlocked.MemoryBarrier();
                 }
-                result = m_array[lowLocal];
-                return true;
-            }
 
-            /// <summary>
-            /// Adds part or all of the current segment into a List.
-            /// </summary>
-            /// <param name="list">the list to which to add</param>
-            /// <param name="start">the start position</param>
-            /// <param name="end">the end position</param>
-            internal void AddToList(List<T> list, int start, int end)
-            {
-                for (int i = start; i <= end; i++)
+                // Loop in case of contention...
+                var spinner = new SpinWait();
+                while (true)
                 {
-                    SpinWait spin = new SpinWait();
-                    while (!m_state[i].m_value)
+                    // Get the head at which to try to peek.
+                    int currentHead = Volatile.Read(ref _headAndTail.Head);
+                    int slotsIndex = currentHead & _slotsMask;
+
+                    // Read the sequence number for the head position.
+                    int sequenceNumber = Volatile.Read(ref _slots[slotsIndex].SequenceNumber);
+
+                    // We can peek from this slot if it's been filled by an enqueuer, which
+                    // would have left the sequence number at pos+1.
+                    int diff = sequenceNumber - (currentHead + 1);
+                    if (diff == 0)
                     {
-                        spin.SpinOnce();
+                        result = resultUsed ? _slots[slotsIndex].Item : default(T);
+                        return true;
+                    }
+                    else if (diff < 0)
+                    {
+                        // The sequence number was less than what we needed, which means this slot doesn't
+                        // yet contain a value we can peek, i.e. the segment is empty.  Technically it's
+                        // possible that multiple enqueuers could have written concurrently, with those
+                        // getting later slots actually finishing first, so there could be elements after
+                        // this one that are available, but we need to peek in order.  So before declaring
+                        // failure and that the segment is empty, we check the tail to see if we're actually
+                        // empty or if we're just waiting for items in flight or after this one to become available.
+                        bool frozen = _frozenForEnqueues;
+                        int currentTail = Volatile.Read(ref _headAndTail.Tail);
+                        if (currentTail - currentHead <= 0 || (frozen && (currentTail - FreezeOffset - currentHead <= 0)))
+                        {
+                            result = default(T);
+                            return false;
+                        }
+
+                        // It's possible it could have become frozen after we checked _frozenForEnqueues
+                        // and before reading the tail.  That's ok: in that rare race condition, we just
+                        // loop around again.
                     }
-                    list.Add(m_array[i]);
+
+                    // Lost a race. Spin a bit, then try again.
+                    spinner.SpinOnce();
                 }
             }
 
             /// <summary>
-            /// return the position of the head of the current segment
-            /// Value range [0, SEGMENT_SIZE], if it's SEGMENT_SIZE, it means this segment is exhausted and thus empty
+            /// Attempts to enqueue the item.  If successful, the item will be stored
+            /// in the queue and true will be returned; otherwise, the item won't be stored, and false
+            /// will be returned.
             /// </summary>
-            internal int Low
+            public bool TryEnqueue(T item)
             {
-                get
+                // Loop in case of contention...
+                var spinner = new SpinWait();
+                while (true)
                 {
-                    return Math.Min(m_low, SEGMENT_SIZE);
+                    // Get the tail at which to try to return.
+                    int currentTail = Volatile.Read(ref _headAndTail.Tail);
+                    int slotsIndex = currentTail & _slotsMask;
+
+                    // Read the sequence number for the tail position.
+                    int sequenceNumber = Volatile.Read(ref _slots[slotsIndex].SequenceNumber);
+
+                    // The slot is empty and ready for us to enqueue into it if its sequence
+                    // number matches the slot.
+                    int diff = sequenceNumber - currentTail;
+                    if (diff == 0)
+                    {
+                        // We may be racing with other enqueuers.  Try to reserve the slot by incrementing
+                        // the tail.  Once we've done that, no one else will be able to write to this slot,
+                        // and no dequeuer will be able to read from this slot until we've written the new
+                        // sequence number. WARNING: The next few lines are not reliable on a runtime that
+                        // supports thread aborts. If a thread abort were to sneak in after the CompareExchange
+                        // but before the Volatile.Write, other threads will spin trying to access this slot.
+                        // If this implementation is ever used on such a platform, this if block should be
+                        // wrapped in a finally / prepared region.
+                        if (Interlocked.CompareExchange(ref _headAndTail.Tail, currentTail + 1, currentTail) == currentTail)
+                        {
+                            // Successfully reserved the slot.  Note that after the above CompareExchange, other threads
+                            // trying to return will end up spinning until we do the subsequent Write.
+                            _slots[slotsIndex].Item = item;
+                            Volatile.Write(ref _slots[slotsIndex].SequenceNumber, currentTail + 1);
+                            return true;
+                        }
+                    }
+                    else if (diff < 0)
+                    {
+                        // The sequence number was less than what we needed, which means this slot still
+                        // contains a value, i.e. the segment is full.  Technically it's possible that multiple
+                        // dequeuers could have read concurrently, with those getting later slots actually
+                        // finishing first, so there could be spaces after this one that are available, but
+                        // we need to enqueue in order.
+                        return false;
+                    }
+
+                    // Lost a race. Spin a bit, then try again.
+                    spinner.SpinOnce();
                 }
             }
 
-            /// <summary>
-            /// return the logical position of the tail of the current segment      
-            /// Value range [-1, SEGMENT_SIZE-1]. When it's -1, it means this is a new segment and has no elemnet yet
-            /// </summary>
-            internal int High
+            /// <summary>Represents a slot in the queue.</summary>
+            [StructLayout(LayoutKind.Auto)]
+            [DebuggerDisplay("Item = {Item}, SequenceNumber = {SequenceNumber}")]
+            internal struct Slot
             {
-                get
-                {
-                    //if m_high > SEGMENT_SIZE, it means it's out of range, we should return
-                    //SEGMENT_SIZE-1 as the logical position
-                    return Math.Min(m_high, SEGMENT_SIZE - 1);
-                }
+                /// <summary>The item.</summary>
+                public T Item;
+                /// <summary>The sequence number for this slot, used to synchronize between enqueuers and dequeuers.</summary>
+                public int SequenceNumber;
             }
-
         }
-    }//end of class Segment
+    }
 
-    /// <summary>
-    /// A wrapper struct for volatile bool, please note the copy of the struct it self will not be volatile
-    /// for example this statement will not include in volatilness operation volatileBool1 = volatileBool2 the jit will copy the struct and will ignore the volatile
-    /// </summary>
-    struct VolatileBool
+    /// <summary>Padded head and tail indices, to avoid false sharing between producers and consumers.</summary>
+    [DebuggerDisplay("Head = {Head}, Tail = {Tail}")]
+    [StructLayout(LayoutKind.Explicit, Size = 192)] // padding before/between/after fields based on typical cache line size of 64
+    internal struct PaddedHeadAndTail
     {
-        public VolatileBool(bool value)
-        {
-            m_value = value;
-        }
-        public volatile bool m_value;
+        [FieldOffset(64)]  public int Head;
+        [FieldOffset(128)] public int Tail;
     }
 }
diff --git a/src/mscorlib/src/System/Collections/Concurrent/ConcurrentStack.cs b/src/mscorlib/src/System/Collections/Concurrent/ConcurrentStack.cs
index c36d96c26c..10a5201f6c 100644
--- a/src/mscorlib/src/System/Collections/Concurrent/ConcurrentStack.cs
+++ b/src/mscorlib/src/System/Collections/Concurrent/ConcurrentStack.cs
@@ -20,7 +20,6 @@ using System.Diagnostics.Contracts;
 using System.Runtime.ConstrainedExecution;
 using System.Runtime.Serialization;
 using System.Security;
-using System.Security.Permissions;
 using System.Threading;
 
 namespace System.Collections.Concurrent
@@ -45,7 +44,7 @@ namespace System.Collections.Concurrent
     /// </remarks>
     [DebuggerDisplay("Count = {Count}")]
     [DebuggerTypeProxy(typeof(SystemCollectionsConcurrent_ProducerConsumerCollectionDebugView<>))]
-    public class ConcurrentStack<T> : IProducerConsumerCollection<T>, IReadOnlyCollection<T>
+    internal class ConcurrentStack<T> : IProducerConsumerCollection<T>, IReadOnlyCollection<T>
     {
         /// <summary>
         /// A simple (internal) node type used to store elements of concurrent stacks and queues.
@@ -79,61 +78,6 @@ namespace System.Collections.Concurrent
         }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="ConcurrentStack{T}"/>
-        /// class that contains elements copied from the specified collection
-        /// </summary>
-        /// <param name="collection">The collection whose elements are copied to the new <see
-        /// cref="ConcurrentStack{T}"/>.</param>
-        /// <exception cref="T:System.ArgumentNullException">The <paramref name="collection"/> argument is
-        /// null.</exception>
-        public ConcurrentStack(IEnumerable<T> collection)
-        {
-            if (collection == null)
-            {
-                throw new ArgumentNullException(nameof(collection));
-            }
-            InitializeFromCollection(collection);
-        }
-
-        /// <summary>
-        /// Initializes the contents of the stack from an existing collection.
-        /// </summary>
-        /// <param name="collection">A collection from which to copy elements.</param>
-        private void InitializeFromCollection(IEnumerable<T> collection)
-        {
-            // We just copy the contents of the collection to our stack.
-            Node lastNode = null;
-            foreach (T element in collection)
-            {
-                Node newNode = new Node(element);
-                newNode.m_next = lastNode;
-                lastNode = newNode;
-            }
-
-            m_head = lastNode;
-        }
-
-        /// <summary>
-        /// Gets a value that indicates whether the <see cref="ConcurrentStack{T}"/> is empty.
-        /// </summary>
-        /// <value>true if the <see cref="ConcurrentStack{T}"/> is empty; otherwise, false.</value>
-        /// <remarks>
-        /// For determining whether the collection contains any items, use of this property is recommended
-        /// rather than retrieving the number of items from the <see cref="Count"/> property and comparing it
-        /// to 0.  However, as this collection is intended to be accessed concurrently, it may be the case
-        /// that another thread will modify the collection after <see cref="IsEmpty"/> returns, thus invalidating
-        /// the result.
-        /// </remarks>
-        public bool IsEmpty
-        {
-            // Checks whether the stack is empty. Clearly the answer may be out of date even prior to
-            // the function returning (i.e. if another thread concurrently adds to the stack). It does
-            // guarantee, however, that, if another thread does not mutate the stack, a subsequent call
-            // to TryPop will return true -- i.e. it will also read the stack as non-empty.
-            get { return m_head == null; }
-        }
-
-        /// <summary>
         /// Gets the number of elements contained in the <see cref="ConcurrentStack{T}"/>.
         /// </summary>
         /// <value>The number of elements contained in the <see cref="ConcurrentStack{T}"/>.</value>
@@ -196,18 +140,6 @@ namespace System.Collections.Concurrent
         }
 
         /// <summary>
-        /// Removes all objects from the <see cref="ConcurrentStack{T}"/>.
-        /// </summary>
-        public void Clear()
-        {
-            // Clear the list by setting the head to null. We don't need to use an atomic
-            // operation for this: anybody who is mutating the head by pushing or popping
-            // will need to use an atomic operation to guarantee they serialize and don't
-            // overwrite our setting of the head to null.
-            m_head = null;
-        }
-
-        /// <summary>
         /// Copies the elements of the <see cref="T:System.Collections.ICollection"/> to an <see
         /// cref="T:System.Array"/>, starting at a particular
         /// <see cref="T:System.Array"/> index.
@@ -306,79 +238,6 @@ namespace System.Collections.Concurrent
             PushCore(newNode, newNode);
         }
 
-        /// <summary>
-        /// Inserts multiple objects at the top of the <see cref="ConcurrentStack{T}"/> atomically.
-        /// </summary>
-        /// <param name="items">The objects to push onto the <see cref="ConcurrentStack{T}"/>.</param>
-        /// <exception cref="ArgumentNullException"><paramref name="items"/> is a null reference
-        /// (Nothing in Visual Basic).</exception>
-        /// <remarks>
-        /// When adding multiple items to the stack, using PushRange is a more efficient
-        /// mechanism than using <see cref="Push"/> one item at a time.  Additionally, PushRange
-        /// guarantees that all of the elements will be added atomically, meaning that no other threads will
-        /// be able to inject elements between the elements being pushed.  Items at lower indices in
-        /// the <paramref name="items"/> array will be pushed before items at higher indices.
-        /// </remarks>
-        public void PushRange(T[] items)
-        {
-            if (items == null)
-            {
-                throw new ArgumentNullException(nameof(items));
-            }
-            PushRange(items, 0, items.Length);
-        }
-
-        /// <summary>
-        /// Inserts multiple objects at the top of the <see cref="ConcurrentStack{T}"/> atomically.
-        /// </summary>
-        /// <param name="items">The objects to push onto the <see cref="ConcurrentStack{T}"/>.</param>
-        /// <param name="startIndex">The zero-based offset in <paramref name="items"/> at which to begin
-        /// inserting elements onto the top of the <see cref="ConcurrentStack{T}"/>.</param>
-        /// <param name="count">The number of elements to be inserted onto the top of the <see
-        /// cref="ConcurrentStack{T}"/>.</param>
-        /// <exception cref="ArgumentNullException"><paramref name="items"/> is a null reference
-        /// (Nothing in Visual Basic).</exception>
-        /// <exception cref="ArgumentOutOfRangeException"><paramref name="startIndex"/> or <paramref
-        /// name="count"/> is negative. Or <paramref name="startIndex"/> is greater than or equal to the length 
-        /// of <paramref name="items"/>.</exception>
-        /// <exception cref="ArgumentException"><paramref name="startIndex"/> + <paramref name="count"/> is
-        /// greater than the length of <paramref name="items"/>.</exception>
-        /// <remarks>
-        /// When adding multiple items to the stack, using PushRange is a more efficient
-        /// mechanism than using <see cref="Push"/> one item at a time. Additionally, PushRange
-        /// guarantees that all of the elements will be added atomically, meaning that no other threads will
-        /// be able to inject elements between the elements being pushed. Items at lower indices in the
-        /// <paramref name="items"/> array will be pushed before items at higher indices.
-        /// </remarks>
-        public void PushRange(T[] items, int startIndex, int count)
-        {
-            ValidatePushPopRangeInput(items, startIndex, count);
-
-            // No op if the count is zero
-            if (count == 0)
-                return;
-
-
-            Node head, tail;
-            head = tail = new Node(items[startIndex]);
-            for (int i = startIndex + 1; i < startIndex + count; i++)
-            {
-                Node node = new Node(items[i]);
-                node.m_next = head;
-                head = node;
-            }
-
-            tail.m_next = m_head;
-            if (Interlocked.CompareExchange(ref m_head, head, tail.m_next) == tail.m_next)
-            {
-                return;
-            }
-
-            // If we failed, go to the slow path and loop around until we succeed.
-            PushCore(head, tail);
-
-        }
-
 
         /// <summary>
         /// Push one or many nodes into the stack, if head and tails are equal then push one node to the stack other wise push the list between head
@@ -402,73 +261,6 @@ namespace System.Collections.Concurrent
         }
 
         /// <summary>
-        /// Local helper function to validate the Pop Push range methods input
-        /// </summary>
-        private void ValidatePushPopRangeInput(T[] items, int startIndex, int count)
-        {
-            if (items == null)
-            {
-                throw new ArgumentNullException(nameof(items));
-            }
-            if (count < 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(count), Environment.GetResourceString("ConcurrentStack_PushPopRange_CountOutOfRange"));
-            }
-            int length = items.Length;
-            if (startIndex >= length || startIndex < 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(startIndex), Environment.GetResourceString("ConcurrentStack_PushPopRange_StartOutOfRange"));
-            }
-            if (length - count < startIndex) //instead of (startIndex + count > items.Length) to prevent overflow
-            {
-                throw new ArgumentException(Environment.GetResourceString("ConcurrentStack_PushPopRange_InvalidCount"));
-            }
-        }
-
-        /// <summary>
-        /// Attempts to add an object to the <see
-        /// cref="T:System.Collections.Concurrent.IProducerConsumerCollection{T}"/>.
-        /// </summary>
-        /// <param name="item">The object to add to the <see
-        /// cref="T:System.Collections.Concurrent.IProducerConsumerCollection{T}"/>. The value can be a null
-        /// reference (Nothing in Visual Basic) for reference types.
-        /// </param>
-        /// <returns>true if the object was added successfully; otherwise, false.</returns>
-        /// <remarks>For <see cref="ConcurrentStack{T}"/>, this operation
-        /// will always insert the object onto the top of the <see cref="ConcurrentStack{T}"/>
-        /// and return true.</remarks>
-        bool IProducerConsumerCollection<T>.TryAdd(T item)
-        {
-            Push(item);
-            return true;
-        }
-
-        /// <summary>
-        /// Attempts to return an object from the top of the <see cref="ConcurrentStack{T}"/>
-        /// without removing it.
-        /// </summary>
-        /// <param name="result">When this method returns, <paramref name="result"/> contains an object from
-        /// the top of the <see cref="T:System.Collections.Concurrent.ConccurrentStack{T}"/> or an
-        /// unspecified value if the operation failed.</param>
-        /// <returns>true if and object was returned successfully; otherwise, false.</returns>
-        public bool TryPeek(out T result)
-        {
-            Node head = m_head;
-
-            // If the stack is empty, return false; else return the element and true.
-            if (head == null)
-            {
-                result = default(T);
-                return false;
-            }
-            else
-            {
-                result = head.m_value;
-                return true;
-            }
-        }
-
-        /// <summary>
         /// Attempts to pop and return the object at the top of the <see cref="ConcurrentStack{T}"/>.
         /// </summary>
         /// <param name="result">
@@ -498,83 +290,6 @@ namespace System.Collections.Concurrent
         }
 
         /// <summary>
-        /// Attempts to pop and return multiple objects from the top of the <see cref="ConcurrentStack{T}"/>
-        /// atomically.
-        /// </summary>
-        /// <param name="items">
-        /// The <see cref="T:System.Array"/> to which objects popped from the top of the <see
-        /// cref="ConcurrentStack{T}"/> will be added.
-        /// </param>
-        /// <returns>The number of objects successfully popped from the top of the <see
-        /// cref="ConcurrentStack{T}"/> and inserted in
-        /// <paramref name="items"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="items"/> is a null argument (Nothing
-        /// in Visual Basic).</exception>
-        /// <remarks>
-        /// When popping multiple items, if there is little contention on the stack, using
-        /// TryPopRange can be more efficient than using <see cref="TryPop"/>
-        /// once per item to be removed.  Nodes fill the <paramref name="items"/>
-        /// with the first node to be popped at the startIndex, the second node to be popped
-        /// at startIndex + 1, and so on.
-        /// </remarks>
-        public int TryPopRange(T[] items)
-        {
-            if (items == null)
-            {
-                throw new ArgumentNullException(nameof(items));
-            }
-
-            return TryPopRange(items, 0, items.Length);
-        }
-
-        /// <summary>
-        /// Attempts to pop and return multiple objects from the top of the <see cref="ConcurrentStack{T}"/>
-        /// atomically.
-        /// </summary>
-        /// <param name="items">
-        /// The <see cref="T:System.Array"/> to which objects popped from the top of the <see
-        /// cref="ConcurrentStack{T}"/> will be added.
-        /// </param>
-        /// <param name="startIndex">The zero-based offset in <paramref name="items"/> at which to begin
-        /// inserting elements from the top of the <see cref="ConcurrentStack{T}"/>.</param>
-        /// <param name="count">The number of elements to be popped from top of the <see
-        /// cref="ConcurrentStack{T}"/> and inserted into <paramref name="items"/>.</param>
-        /// <returns>The number of objects successfully popped from the top of 
-        /// the <see cref="ConcurrentStack{T}"/> and inserted in <paramref name="items"/>.</returns>        
-        /// <exception cref="ArgumentNullException"><paramref name="items"/> is a null reference
-        /// (Nothing in Visual Basic).</exception>
-        /// <exception cref="ArgumentOutOfRangeException"><paramref name="startIndex"/> or <paramref
-        /// name="count"/> is negative. Or <paramref name="startIndex"/> is greater than or equal to the length 
-        /// of <paramref name="items"/>.</exception>
-        /// <exception cref="ArgumentException"><paramref name="startIndex"/> + <paramref name="count"/> is
-        /// greater than the length of <paramref name="items"/>.</exception>
-        /// <remarks>
-        /// When popping multiple items, if there is little contention on the stack, using
-        /// TryPopRange can be more efficient than using <see cref="TryPop"/>
-        /// once per item to be removed.  Nodes fill the <paramref name="items"/>
-        /// with the first node to be popped at the startIndex, the second node to be popped
-        /// at startIndex + 1, and so on.
-        /// </remarks>
-        public int TryPopRange(T[] items, int startIndex, int count)
-        {
-            ValidatePushPopRangeInput(items, startIndex, count);
-
-            // No op if the count is zero
-            if (count == 0)
-                return 0;
-
-            Node poppedHead;
-            int nodesCount = TryPopCore(count, out poppedHead);
-            if (nodesCount > 0)
-            {
-                CopyRemovedItems(poppedHead, items, startIndex, nodesCount);
-
-            }
-            return nodesCount;
-
-        }
-
-        /// <summary>
         /// Local helper function to Pop an item from the stack, slow path
         /// </summary>
         /// <param name="result">The popped item</param>
@@ -648,42 +363,6 @@ namespace System.Collections.Concurrent
             }
         }
 
-
-        /// <summary>
-        /// Local helper function to copy the poped elements into a given collection
-        /// </summary>
-        /// <param name="head">The head of the list to be copied</param>
-        /// <param name="collection">The collection to place the popped items in</param>
-        /// <param name="startIndex">the beginning of index of where to place the popped items</param>
-        /// <param name="nodesCount">The number of nodes.</param>
-        private void CopyRemovedItems(Node head, T[] collection, int startIndex, int nodesCount)
-        {
-            Node current = head;
-            for (int i = startIndex; i < startIndex + nodesCount; i++)
-            {
-                collection[i] = current.m_value;
-                current = current.m_next;
-            }
-
-        }
-
-        /// <summary>
-        /// Attempts to remove and return an object from the <see
-        /// cref="T:System.Collections.Concurrent.IProducerConsumerCollection{T}"/>.
-        /// </summary>
-        /// <param name="item">
-        /// When this method returns, if the operation was successful, <paramref name="item"/> contains the
-        /// object removed. If no object was available to be removed, the value is unspecified.
-        /// </param>
-        /// <returns>true if an element was removed and returned succesfully; otherwise, false.</returns>
-        /// <remarks>For <see cref="ConcurrentStack{T}"/>, this operation will attempt to pope the object at
-        /// the top of the <see cref="ConcurrentStack{T}"/>.
-        /// </remarks>
-        bool IProducerConsumerCollection<T>.TryTake(out T item)
-        {
-            return TryPop(out item);
-        }
-
         /// <summary>
         /// Copies the items stored in the <see cref="ConcurrentStack{T}"/> to a new array.
         /// </summary>
diff --git a/src/mscorlib/src/System/Collections/Concurrent/IProducerConsumerCollection.cs b/src/mscorlib/src/System/Collections/Concurrent/IProducerConsumerCollection.cs
index 56be7759c9..0347ece0ec 100644
--- a/src/mscorlib/src/System/Collections/Concurrent/IProducerConsumerCollection.cs
+++ b/src/mscorlib/src/System/Collections/Concurrent/IProducerConsumerCollection.cs
@@ -25,9 +25,8 @@ namespace System.Collections.Concurrent
     /// All implementations of this interface must enable all members of this interface
     /// to be used concurrently from multiple threads.
     /// </remarks>
-    public interface IProducerConsumerCollection<T> : IEnumerable<T>, ICollection
+    internal interface IProducerConsumerCollection<T> : IEnumerable<T>, ICollection
     {
-
         /// <summary>
         /// Copies the elements of the <see cref="IProducerConsumerCollection{T}"/> to
         /// an
@@ -51,35 +50,12 @@ namespace System.Collections.Concurrent
         void CopyTo(T[] array, int index);
 
         /// <summary>
-        /// Attempts to add an object to the <see
-        /// cref="IProducerConsumerCollection{T}"/>.
-        /// </summary>
-        /// <param name="item">The object to add to the <see
-        /// cref="IProducerConsumerCollection{T}"/>.</param>
-        /// <returns>true if the object was added successfully; otherwise, false.</returns>
-        /// <exception cref="T:System.ArgumentException">The <paramref name="item"/> was invalid for this collection.</exception>
-        bool TryAdd(T item);
-
-        /// <summary>
-        /// Attempts to remove and return an object from the <see cref="IProducerConsumerCollection{T}"/>.
-        /// </summary>
-        /// <param name="item">
-        /// When this method returns, if the object was removed and returned successfully, <paramref
-        /// name="item"/> contains the removed object. If no object was available to be removed, the value is
-        /// unspecified.
-        /// </param>
-        /// <returns>true if an object was removed and returned successfully; otherwise, false.</returns>
-        bool TryTake(out T item);
-
-        /// <summary>
         /// Copies the elements contained in the <see cref="IProducerConsumerCollection{T}"/> to a new array.
         /// </summary>
         /// <returns>A new array containing the elements copied from the <see cref="IProducerConsumerCollection{T}"/>.</returns>
         T[] ToArray();
-
     }
 
-
     /// <summary>
     /// A debugger view of the IProducerConsumerCollection that makes it simple to browse the
     /// collection's contents at a point in time.
@@ -89,28 +65,5 @@ namespace System.Collections.Concurrent
     {
         private IProducerConsumerCollection<T> m_collection; // The collection being viewed.
 
-        /// <summary>
-        /// Constructs a new debugger view object for the provided collection object.
-        /// </summary>
-        /// <param name="collection">A collection to browse in the debugger.</param>
-        public SystemCollectionsConcurrent_ProducerConsumerCollectionDebugView(IProducerConsumerCollection<T> collection)
-        {
-            if (collection == null)
-            {
-                throw new ArgumentNullException(nameof(collection));
-            }
-
-            m_collection = collection;
-        }
-
-        /// <summary>
-        /// Returns a snapshot of the underlying collection's elements.
-        /// </summary>
-        [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
-        public T[] Items
-        {
-            get { return m_collection.ToArray(); }
-        }
-
     }
 }
diff --git a/src/mscorlib/src/System/Collections/Concurrent/OrderablePartitioner.cs b/src/mscorlib/src/System/Collections/Concurrent/OrderablePartitioner.cs
deleted file mode 100644
index 33e3c88e9a..0000000000
--- a/src/mscorlib/src/System/Collections/Concurrent/OrderablePartitioner.cs
+++ /dev/null
@@ -1,280 +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.
-
-// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
-//
-//
-//
-// 
-//
-// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-
-using System;
-using System.Collections.Generic;
-using System.Security.Permissions;
-using System.Threading;
-
-namespace System.Collections.Concurrent
-{
-
-    /// <summary>
-    /// Represents a particular manner of splitting an orderable data source into multiple partitions.
-    /// </summary>
-    /// <typeparam name="TSource">Type of the elements in the collection.</typeparam>
-    /// <remarks>
-    /// <para>
-    /// Each element in each partition has an integer index associated with it, which determines the relative
-    /// order of that element against elements in other partitions.
-    /// </para>
-    /// <para>
-    /// Inheritors of <see cref="OrderablePartitioner{TSource}"/> must adhere to the following rules:
-    /// <ol>
-    /// <li>All indices must be unique, such that there may not be duplicate indices. If all indices are not
-    /// unique, the output ordering may be scrambled.</li>
-    /// <li>All indices must be non-negative. If any indices are negative, consumers of the implementation
-    /// may throw exceptions.</li>
-    /// <li><see cref="GetPartitions"/> and <see cref="GetOrderablePartitions"/> should throw a
-    /// <see cref="T:System.ArgumentOutOfRangeException"/> if the requested partition count is less than or
-    /// equal to zero.</li>
-    /// <li><see cref="GetPartitions"/> and <see cref="GetOrderablePartitions"/> should always return a number
-    /// of enumerables equal to the requested partition count. If the partitioner runs out of data and cannot
-    /// create as many partitions as requested, an empty enumerator should be returned for each of the
-    /// remaining partitions. If this rule is not followed, consumers of the implementation may throw a <see
-    /// cref="T:System.InvalidOperationException"/>.</li>
-    /// <li><see cref="GetPartitions"/>, <see cref="GetOrderablePartitions"/>,
-    /// <see cref="GetDynamicPartitions"/>, and <see cref="GetOrderableDynamicPartitions"/>
-    /// should never return null. If null is returned, a consumer of the implementation may throw a
-    /// <see cref="T:System.InvalidOperationException"/>.</li>
-    /// <li><see cref="GetPartitions"/>, <see cref="GetOrderablePartitions"/>,
-    /// <see cref="GetDynamicPartitions"/>, and <see cref="GetOrderableDynamicPartitions"/>
-    /// should always return partitions that can fully and uniquely enumerate the input data source. All of
-    /// the data and only the data contained in the input source should be enumerated, with no duplication
-    /// that was not already in the input, unless specifically required by the particular partitioner's
-    /// design. If this is not followed, the output ordering may be scrambled.</li>
-    /// <li>If <see cref="KeysOrderedInEachPartition"/> returns true, each partition must return elements
-    /// with increasing key indices.</li>
-    /// <li>If <see cref="KeysOrderedAcrossPartitions"/> returns true, all the keys in partition numbered N
-    /// must be larger than all the keys in partition numbered N-1.</li>
-    /// <li>If <see cref="KeysNormalized"/> returns true, all indices must be monotonically increasing from
-    /// 0, though not necessarily within a single partition.</li>
-    /// </ol>
-    /// </para>
-    /// </remarks>
-    public abstract class OrderablePartitioner<TSource> : Partitioner<TSource>
-    {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="OrderablePartitioner{TSource}"/> class with the
-        /// specified constraints on the index keys.
-        /// </summary>
-        /// <param name="keysOrderedInEachPartition">
-        /// Indicates whether the elements in each partition are yielded in the order of
-        /// increasing keys.
-        /// </param>
-        /// <param name="keysOrderedAcrossPartitions">
-        /// Indicates whether elements in an earlier partition always come before
-        /// elements in a later partition. If true, each element in partition 0 has a smaller order key than
-        /// any element in partition 1, each element in partition 1 has a smaller order key than any element
-        /// in partition 2, and so on.
-        /// </param>
-        /// <param name="keysNormalized">
-        /// Indicates whether keys are normalized. If true, all order keys are distinct
-        /// integers in the range [0 .. numberOfElements-1]. If false, order keys must still be dictinct, but
-        /// only their relative order is considered, not their absolute values.
-        /// </param>
-        protected OrderablePartitioner(bool keysOrderedInEachPartition, bool keysOrderedAcrossPartitions, bool keysNormalized)
-        {
-            KeysOrderedInEachPartition = keysOrderedInEachPartition;
-            KeysOrderedAcrossPartitions = keysOrderedAcrossPartitions;
-            KeysNormalized = keysNormalized;
-        }
-
-        /// <summary>
-        /// Partitions the underlying collection into the specified number of orderable partitions.
-        /// </summary>
-        /// <remarks>
-        /// Each partition is represented as an enumerator over key-value pairs.
-        /// The value of the pair is the element itself, and the key is an integer which determines
-        /// the relative ordering of this element against other elements in the data source.
-        /// </remarks>
-        /// <param name="partitionCount">The number of partitions to create.</param>
-        /// <returns>A list containing <paramref name="partitionCount"/> enumerators.</returns>
-        public abstract IList<IEnumerator<KeyValuePair<long, TSource>>> GetOrderablePartitions(int partitionCount);
-
-        /// <summary>
-        /// Creates an object that can partition the underlying collection into a variable number of
-        /// partitions.
-        /// </summary>
-        /// <remarks>
-        /// <para>
-        /// The returned object implements the <see
-        /// cref="T:System.Collections.Generic.IEnumerable{TSource}"/> interface. Calling <see
-        /// cref="System.Collections.Generic.IEnumerable{TSource}.GetEnumerator">GetEnumerator</see> on the
-        /// object creates another partition over the sequence.
-        /// </para>
-        /// <para>
-        /// Each partition is represented as an enumerator over key-value pairs. The value in the pair is the element
-        /// itself, and the key is an integer which determines the relative ordering of this element against
-        /// other elements.
-        /// </para>
-        /// <para>
-        /// The <see cref="GetOrderableDynamicPartitions"/> method is only supported if the <see
-        /// cref="System.Collections.Concurrent.Partitioner{TSource}.SupportsDynamicPartitions">SupportsDynamicPartitions</see>
-        /// property returns true.
-        /// </para>
-        /// </remarks>
-        /// <returns>An object that can create partitions over the underlying data source.</returns>
-        /// <exception cref="NotSupportedException">Dynamic partitioning is not supported by this
-        /// partitioner.</exception>
-        public virtual IEnumerable<KeyValuePair<long, TSource>> GetOrderableDynamicPartitions()
-        {
-            throw new NotSupportedException(Environment.GetResourceString("Partitioner_DynamicPartitionsNotSupported"));
-        }
-
-        /// <summary>
-        /// Gets whether elements in each partition are yielded in the order of increasing keys.
-        /// </summary>
-        public bool KeysOrderedInEachPartition { get; private set; }
-
-        /// <summary>
-        /// Gets whether elements in an earlier partition always come before elements in a later partition.
-        /// </summary>
-        /// <remarks>
-        /// If <see cref="KeysOrderedAcrossPartitions"/> returns true, each element in partition 0 has a
-        /// smaller order key than any element in partition 1, each element in partition 1 has a smaller
-        /// order key than any element in partition 2, and so on.
-        /// </remarks>
-        public bool KeysOrderedAcrossPartitions { get; private set; }
-
-        /// <summary>
-        /// Gets whether order keys are normalized.
-        /// </summary>
-        /// <remarks>
-        /// If <see cref="KeysNormalized"/> returns true, all order keys are distinct integers in the range
-        /// [0 .. numberOfElements-1]. If the property returns false, order keys must still be dictinct, but
-        /// only their relative order is considered, not their absolute values.
-        /// </remarks>
-        public bool KeysNormalized { get; private set; }
-
-        /// <summary>
-        /// Partitions the underlying collection into the given number of ordered partitions.
-        /// </summary>
-        /// <remarks>
-        /// The default implementation provides the same behavior as <see cref="GetOrderablePartitions"/> except
-        /// that the returned set of partitions does not provide the keys for the elements.
-        /// </remarks>
-        /// <param name="partitionCount">The number of partitions to create.</param>
-        /// <returns>A list containing <paramref name="partitionCount"/> enumerators.</returns>
-        public override IList<IEnumerator<TSource>> GetPartitions(int partitionCount)
-        {
-            IList<IEnumerator<KeyValuePair<long, TSource>>> orderablePartitions = GetOrderablePartitions(partitionCount);
-
-            if (orderablePartitions.Count != partitionCount)
-            {
-                throw new InvalidOperationException("OrderablePartitioner_GetPartitions_WrongNumberOfPartitions");
-            }
-
-            IEnumerator<TSource>[] partitions = new IEnumerator<TSource>[partitionCount];
-            for (int i = 0; i < partitionCount; i++)
-            {
-                partitions[i] = new EnumeratorDropIndices(orderablePartitions[i]);
-            }
-            return partitions;
-        }
-
-        /// <summary>
-        /// Creates an object that can partition the underlying collection into a variable number of
-        /// partitions.
-        /// </summary>
-        /// <remarks>
-        /// <para>
-        /// The returned object implements the <see
-        /// cref="T:System.Collections.Generic.IEnumerable{TSource}"/> interface. Calling <see
-        /// cref="System.Collections.Generic.IEnumerable{TSource}.GetEnumerator">GetEnumerator</see> on the
-        /// object creates another partition over the sequence.
-        /// </para>
-        /// <para>
-        /// The default implementation provides the same behavior as <see cref="GetOrderableDynamicPartitions"/> except
-        /// that the returned set of partitions does not provide the keys for the elements.
-        /// </para>
-        /// <para>
-        /// The <see cref="GetDynamicPartitions"/> method is only supported if the <see
-        /// cref="System.Collections.Concurrent.Partitioner{TSource}.SupportsDynamicPartitions"/>
-        /// property returns true.
-        /// </para>
-        /// </remarks>
-        /// <returns>An object that can create partitions over the underlying data source.</returns>
-        /// <exception cref="NotSupportedException">Dynamic partitioning is not supported by this
-        /// partitioner.</exception>
-        public override IEnumerable<TSource> GetDynamicPartitions()
-        {
-            IEnumerable<KeyValuePair<long, TSource>> orderablePartitions = GetOrderableDynamicPartitions();
-            return new EnumerableDropIndices(orderablePartitions);
-        }
-
-        /// <summary>
-        /// Converts an enumerable over key-value pairs to an enumerable over values.
-        /// </summary>
-        private class EnumerableDropIndices : IEnumerable<TSource>, IDisposable
-        {
-            private readonly IEnumerable<KeyValuePair<long, TSource>> m_source;
-            public EnumerableDropIndices(IEnumerable<KeyValuePair<long, TSource>> source)
-            {
-                m_source = source;
-            }
-            public IEnumerator<TSource> GetEnumerator()
-            {
-                return new EnumeratorDropIndices(m_source.GetEnumerator());
-            }
-            IEnumerator IEnumerable.GetEnumerator()
-            {
-                return ((EnumerableDropIndices)this).GetEnumerator();
-            }
-            public void Dispose()
-            {
-                IDisposable d = m_source as IDisposable;
-                if (d != null)
-                {
-                    d.Dispose();
-                }
-            }
-        }
-
-        private class EnumeratorDropIndices : IEnumerator<TSource>
-        {
-            private readonly IEnumerator<KeyValuePair<long, TSource>> m_source;
-            public EnumeratorDropIndices(IEnumerator<KeyValuePair<long, TSource>> source)
-            {
-                m_source = source;
-            }
-            public bool MoveNext()
-            {
-                return m_source.MoveNext();
-            }
-            public TSource Current
-            {
-                get
-                {
-                    return m_source.Current.Value;
-                }
-            }
-            Object IEnumerator.Current
-            {
-                get
-                {
-                    return ((EnumeratorDropIndices)this).Current;
-                }
-            }
-            public void Dispose()
-            {
-                m_source.Dispose();
-            }
-            public void Reset()
-            {
-                m_source.Reset();
-            }
-        }
-
-    }
-
-}
diff --git a/src/mscorlib/src/System/Collections/Concurrent/Partitioner.cs b/src/mscorlib/src/System/Collections/Concurrent/Partitioner.cs
deleted file mode 100644
index 0192b1942c..0000000000
--- a/src/mscorlib/src/System/Collections/Concurrent/Partitioner.cs
+++ /dev/null
@@ -1,101 +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.
-
-// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
-//
-//
-//
-// Represents a particular way of splitting a collection into multiple partitions.
-//
-// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-
-using System;
-using System.Collections.Generic;
-using System.Security.Permissions;
-using System.Threading;
-
-namespace System.Collections.Concurrent
-{
-    /// <summary>
-    /// Represents a particular manner of splitting a data source into multiple partitions.
-    /// </summary>
-    /// <typeparam name="TSource">Type of the elements in the collection.</typeparam>
-    /// <remarks>
-    /// <para>
-    /// Inheritors of <see cref="Partitioner{TSource}"/> must adhere to the following rules:
-    /// <ol>
-    /// <li><see cref="GetPartitions"/> should throw a
-    /// <see cref="T:System.ArgumentOutOfRangeException"/> if the requested partition count is less than or
-    /// equal to zero.</li>
-    /// <li><see cref="GetPartitions"/> should always return a number of enumerables equal to the requested
-    /// partition count. If the partitioner runs out of data and cannot create as many partitions as 
-    /// requested, an empty enumerator should be returned for each of the remaining partitions. If this rule
-    /// is not followed, consumers of the implementation may throw a <see
-    /// cref="T:System.InvalidOperationException"/>.</li>
-    /// <li><see cref="GetPartitions"/> and <see cref="GetDynamicPartitions"/>
-    /// should never return null. If null is returned, a consumer of the implementation may throw a
-    /// <see cref="T:System.InvalidOperationException"/>.</li>
-    /// <li><see cref="GetPartitions"/> and <see cref="GetDynamicPartitions"/> should always return
-    /// partitions that can fully and uniquely enumerate the input data source. All of the data and only the
-    /// data contained in the input source should be enumerated, with no duplication that was not already in
-    /// the input, unless specifically required by the particular partitioner's design. If this is not
-    /// followed, the output ordering may be scrambled.</li>
-    /// </ol>
-    /// </para>
-    /// </remarks>
-    public abstract class Partitioner<TSource>
-    {
-        /// <summary>
-        /// Partitions the underlying collection into the given number of partitions.
-        /// </summary>
-        /// <param name="partitionCount">The number of partitions to create.</param>
-        /// <returns>A list containing <paramref name="partitionCount"/> enumerators.</returns>
-        public abstract IList<IEnumerator<TSource>> GetPartitions(int partitionCount);
-
-        /// <summary>
-        /// Gets whether additional partitions can be created dynamically.
-        /// </summary>
-        /// <returns>
-        /// true if the <see cref="Partitioner{TSource}"/> can create partitions dynamically as they are
-        /// requested; false if the <see cref="Partitioner{TSource}"/> can only allocate
-        /// partitions statically.
-        /// </returns>
-        /// <remarks>
-        /// <para>
-        /// If a derived class does not override and implement <see cref="GetDynamicPartitions"/>,
-        /// <see cref="SupportsDynamicPartitions"/> should return false. The value of <see
-        /// cref="SupportsDynamicPartitions"/> should not vary over the lifetime of this instance.
-        /// </para>
-        /// </remarks>
-        public virtual bool SupportsDynamicPartitions
-        {
-            get { return false; }
-        }
-
-        /// <summary>
-        /// Creates an object that can partition the underlying collection into a variable number of
-        /// partitions.
-        /// </summary>
-        /// <remarks>
-        /// <para>
-        /// The returned object implements the <see
-        /// cref="T:System.Collections.Generic.IEnumerable{TSource}"/> interface. Calling <see
-        /// cref="System.Collections.Generic.IEnumerable{TSource}.GetEnumerator">GetEnumerator</see> on the
-        /// object creates another partition over the sequence.
-        /// </para>
-        /// <para>
-        /// The <see cref="GetDynamicPartitions"/> method is only supported if the <see
-        /// cref="SupportsDynamicPartitions"/>
-        /// property returns true.
-        /// </para>
-        /// </remarks>
-        /// <returns>An object that can create partitions over the underlying data source.</returns>
-        /// <exception cref="NotSupportedException">Dynamic partitioning is not supported by this
-        /// partitioner.</exception>
-        public virtual IEnumerable<TSource> GetDynamicPartitions()
-        {
-            throw new NotSupportedException(Environment.GetResourceString("Partitioner_DynamicPartitionsNotSupported"));
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Collections/Concurrent/PartitionerStatic.cs b/src/mscorlib/src/System/Collections/Concurrent/PartitionerStatic.cs
deleted file mode 100644
index 9b36c053ad..0000000000
--- a/src/mscorlib/src/System/Collections/Concurrent/PartitionerStatic.cs
+++ /dev/null
@@ -1,1715 +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.
-#pragma warning disable 0420
-
-// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
-//
-//
-//
-// A class of default partitioners for Partitioner<TSource>
-//
-// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-
-using System.Collections.Generic;
-using System.Security.Permissions;
-using System.Threading;
-using System.Diagnostics;
-using System.Diagnostics.Contracts;
-using System.Runtime.InteropServices;
-
-namespace System.Collections.Concurrent
-{
-    /// <summary>
-    /// Out-of-the-box partitioners are created with a set of default behaviors.  
-    /// For example, by default, some form of buffering and chunking will be employed to achieve 
-    /// optimal performance in the common scenario where an IEnumerable<> implementation is fast and 
-    /// non-blocking.  These behaviors can be overridden via this enumeration.
-    /// </summary>
-    [Flags]
-    public enum EnumerablePartitionerOptions
-    {
-        /// <summary>
-        /// Use the default behavior (i.e., use buffering to achieve optimal performance)
-        /// </summary>
-        None = 0x0,
-
-        /// <summary>
-        /// Creates a partitioner that will take items from the source enumerable one at a time
-        /// and will not use intermediate storage that can be accessed more efficiently by multiple threads.  
-        /// This option provides support for low latency (items will be processed as soon as they are available from 
-        /// the source) and partial support for dependencies between items (a thread cannot deadlock waiting for an item 
-        /// that it, itself, is responsible for processing).
-        /// </summary>
-        NoBuffering = 0x1
-    }
-
-    // The static class Partitioners implements 3 default partitioning strategies:
-    // 1. dynamic load balance partitioning for indexable data source (IList and arrays)
-    // 2. static partitioning for indexable data source (IList and arrays)
-    // 3. dynamic load balance partitioning for enumerables. Enumerables have indexes, which are the natural order
-    //    of elements, but enuemrators are not indexable 
-    // - data source of type IList/arrays have both dynamic and static partitioning, as 1 and 3.
-    //   We assume that the source data of IList/Array is not changing concurrently.
-    // - data source of type IEnumerable can only be partitioned dynamically (load-balance)
-    // - Dynamic partitioning methods 1 and 3 are same, both being dynamic and load-balance. But the 
-    //   implementation is different for data source of IList/Array vs. IEnumerable:
-    //   * When the source collection is IList/Arrays, we use Interlocked on the shared index; 
-    //   * When the source collection is IEnumerable, we use Monitor to wrap around the access to the source 
-    //     enumerator.
-
-    /// <summary>
-    /// Provides common partitioning strategies for arrays, lists, and enumerables.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// The static methods on <see cref="Partitioner"/> are all thread-safe and may be used concurrently
-    /// from multiple threads. However, while a created partitioner is in use, the underlying data source
-    /// should not be modified, whether from the same thread that's using a partitioner or from a separate
-    /// thread.
-    /// </para>
-    /// </remarks>
-    public static class Partitioner
-    {
-        /// <summary>
-        /// Creates an orderable partitioner from an <see cref="System.Collections.Generic.IList{T}"/>
-        /// instance.
-        /// </summary>
-        /// <typeparam name="TSource">Type of the elements in source list.</typeparam>
-        /// <param name="list">The list to be partitioned.</param>
-        /// <param name="loadBalance">
-        /// A Boolean value that indicates whether the created partitioner should dynamically
-        /// load balance between partitions rather than statically partition.
-        /// </param>
-        /// <returns>
-        /// An orderable partitioner based on the input list.
-        /// </returns>
-        public static OrderablePartitioner<TSource> Create<TSource>(IList<TSource> list, bool loadBalance)
-        {
-            if (list == null)
-            {
-                throw new ArgumentNullException(nameof(list));
-            }
-            if (loadBalance)
-            {
-                return (new DynamicPartitionerForIList<TSource>(list));
-            }
-            else
-            {
-                return (new StaticIndexRangePartitionerForIList<TSource>(list));
-            }
-        }
-
-        /// <summary>
-        /// Creates an orderable partitioner from a <see cref="System.Array"/> instance.
-        /// </summary>
-        /// <typeparam name="TSource">Type of the elements in source array.</typeparam>
-        /// <param name="array">The array to be partitioned.</param>
-        /// <param name="loadBalance">
-        /// A Boolean value that indicates whether the created partitioner should dynamically load balance
-        /// between partitions rather than statically partition.
-        /// </param>
-        /// <returns>
-        /// An orderable partitioner based on the input array.
-        /// </returns>
-        public static OrderablePartitioner<TSource> Create<TSource>(TSource[] array, bool loadBalance)
-        {
-            // This implementation uses 'ldelem' instructions for element retrieval, rather than using a
-            // method call.
-
-            if (array == null)
-            {
-                throw new ArgumentNullException(nameof(array));
-            }
-            if (loadBalance)
-            {
-                return (new DynamicPartitionerForArray<TSource>(array));
-            }
-            else
-            {
-                return (new StaticIndexRangePartitionerForArray<TSource>(array));
-            }
-        }
-
-        /// <summary>
-        /// Creates an orderable partitioner from a <see cref="System.Collections.Generic.IEnumerable{TSource}"/> instance.
-        /// </summary>
-        /// <typeparam name="TSource">Type of the elements in source enumerable.</typeparam>
-        /// <param name="source">The enumerable to be partitioned.</param>
-        /// <returns>
-        /// An orderable partitioner based on the input array.
-        /// </returns>
-        /// <remarks>
-        /// The ordering used in the created partitioner is determined by the natural order of the elements 
-        /// as retrieved from the source enumerable.
-        /// </remarks>
-        public static OrderablePartitioner<TSource> Create<TSource>(IEnumerable<TSource> source)
-        {
-            return Create<TSource>(source, EnumerablePartitionerOptions.None);
-        }
-
-        /// <summary>
-        /// Creates an orderable partitioner from a <see cref="System.Collections.Generic.IEnumerable{TSource}"/> instance.
-        /// </summary>
-        /// <typeparam name="TSource">Type of the elements in source enumerable.</typeparam>
-        /// <param name="source">The enumerable to be partitioned.</param>
-        /// <param name="partitionerOptions">Options to control the buffering behavior of the partitioner.</param>
-        /// <exception cref="T:System.ArgumentOutOfRangeException">
-        /// The <paramref name="partitionerOptions"/> argument specifies an invalid value for <see
-        /// cref="T:System.Collections.Concurrent.EnumerablePartitionerOptions"/>.
-        /// </exception>
-        /// <returns>
-        /// An orderable partitioner based on the input array.
-        /// </returns>
-        /// <remarks>
-        /// The ordering used in the created partitioner is determined by the natural order of the elements 
-        /// as retrieved from the source enumerable.
-        /// </remarks>
-        public static OrderablePartitioner<TSource> Create<TSource>(IEnumerable<TSource> source, EnumerablePartitionerOptions partitionerOptions)
-        {
-            if (source == null)
-            {
-                throw new ArgumentNullException(nameof(source));
-            }
-
-            if ((partitionerOptions & (~EnumerablePartitionerOptions.NoBuffering)) != 0)
-                throw new ArgumentOutOfRangeException(nameof(partitionerOptions));
-
-            return (new DynamicPartitionerForIEnumerable<TSource>(source, partitionerOptions));
-        }
-
-        /// <summary>Creates a partitioner that chunks the user-specified range.</summary>
-        /// <param name="fromInclusive">The lower, inclusive bound of the range.</param>
-        /// <param name="toExclusive">The upper, exclusive bound of the range.</param>
-        /// <returns>A partitioner.</returns>
-        /// <exception cref="T:System.ArgumentOutOfRangeException"> The <paramref name="toExclusive"/> argument is 
-        /// less than or equal to the <paramref name="fromInclusive"/> argument.</exception>
-        public static OrderablePartitioner<Tuple<long, long>> Create(long fromInclusive, long toExclusive)
-        {
-            // How many chunks do we want to divide the range into?  If this is 1, then the
-            // answer is "one chunk per core".  Generally, though, you'll achieve better
-            // load balancing on a busy system if you make it higher than 1.
-            int coreOversubscriptionRate = 3;
-
-            if (toExclusive <= fromInclusive) throw new ArgumentOutOfRangeException(nameof(toExclusive));
-            long rangeSize = (toExclusive - fromInclusive) /
-                (PlatformHelper.ProcessorCount * coreOversubscriptionRate);
-            if (rangeSize == 0) rangeSize = 1;
-            return Partitioner.Create(CreateRanges(fromInclusive, toExclusive, rangeSize), EnumerablePartitionerOptions.NoBuffering); // chunk one range at a time
-        }
-
-        /// <summary>Creates a partitioner that chunks the user-specified range.</summary>
-        /// <param name="fromInclusive">The lower, inclusive bound of the range.</param>
-        /// <param name="toExclusive">The upper, exclusive bound of the range.</param>
-        /// <param name="rangeSize">The size of each subrange.</param>
-        /// <returns>A partitioner.</returns>
-        /// <exception cref="T:System.ArgumentOutOfRangeException"> The <paramref name="toExclusive"/> argument is 
-        /// less than or equal to the <paramref name="fromInclusive"/> argument.</exception>
-        /// <exception cref="T:System.ArgumentOutOfRangeException"> The <paramref name="rangeSize"/> argument is 
-        /// less than or equal to 0.</exception>
-        public static OrderablePartitioner<Tuple<long, long>> Create(long fromInclusive, long toExclusive, long rangeSize)
-        {
-            if (toExclusive <= fromInclusive) throw new ArgumentOutOfRangeException(nameof(toExclusive));
-            if (rangeSize <= 0) throw new ArgumentOutOfRangeException(nameof(rangeSize));
-            return Partitioner.Create(CreateRanges(fromInclusive, toExclusive, rangeSize), EnumerablePartitionerOptions.NoBuffering); // chunk one range at a time
-        }
-
-        // Private method to parcel out range tuples.
-        private static IEnumerable<Tuple<long, long>> CreateRanges(long fromInclusive, long toExclusive, long rangeSize)
-        {
-            // Enumerate all of the ranges
-            long from, to;
-            bool shouldQuit = false;
-
-            for (long i = fromInclusive; (i < toExclusive) && !shouldQuit; i += rangeSize)
-            {
-                from = i;
-                try { checked { to = i + rangeSize; } }
-                catch (OverflowException)
-                {
-                    to = toExclusive;
-                    shouldQuit = true;
-                }
-                if (to > toExclusive) to = toExclusive;
-                yield return new Tuple<long, long>(from, to);
-            }
-        }
-
-        /// <summary>Creates a partitioner that chunks the user-specified range.</summary>
-        /// <param name="fromInclusive">The lower, inclusive bound of the range.</param>
-        /// <param name="toExclusive">The upper, exclusive bound of the range.</param>
-        /// <returns>A partitioner.</returns>
-        /// <exception cref="T:System.ArgumentOutOfRangeException"> The <paramref name="toExclusive"/> argument is 
-        /// less than or equal to the <paramref name="fromInclusive"/> argument.</exception>
-        public static OrderablePartitioner<Tuple<int, int>> Create(int fromInclusive, int toExclusive)
-        {
-            // How many chunks do we want to divide the range into?  If this is 1, then the
-            // answer is "one chunk per core".  Generally, though, you'll achieve better
-            // load balancing on a busy system if you make it higher than 1.
-            int coreOversubscriptionRate = 3;
-
-            if (toExclusive <= fromInclusive) throw new ArgumentOutOfRangeException(nameof(toExclusive));
-            int rangeSize = (toExclusive - fromInclusive) /
-                (PlatformHelper.ProcessorCount * coreOversubscriptionRate);
-            if (rangeSize == 0) rangeSize = 1;
-            return Partitioner.Create(CreateRanges(fromInclusive, toExclusive, rangeSize), EnumerablePartitionerOptions.NoBuffering); // chunk one range at a time
-        }
-
-        /// <summary>Creates a partitioner that chunks the user-specified range.</summary>
-        /// <param name="fromInclusive">The lower, inclusive bound of the range.</param>
-        /// <param name="toExclusive">The upper, exclusive bound of the range.</param>
-        /// <param name="rangeSize">The size of each subrange.</param>
-        /// <returns>A partitioner.</returns>
-        /// <exception cref="T:System.ArgumentOutOfRangeException"> The <paramref name="toExclusive"/> argument is 
-        /// less than or equal to the <paramref name="fromInclusive"/> argument.</exception>
-        /// <exception cref="T:System.ArgumentOutOfRangeException"> The <paramref name="rangeSize"/> argument is 
-        /// less than or equal to 0.</exception>
-        public static OrderablePartitioner<Tuple<int, int>> Create(int fromInclusive, int toExclusive, int rangeSize)
-        {
-            if (toExclusive <= fromInclusive) throw new ArgumentOutOfRangeException(nameof(toExclusive));
-            if (rangeSize <= 0) throw new ArgumentOutOfRangeException(nameof(rangeSize));
-            return Partitioner.Create(CreateRanges(fromInclusive, toExclusive, rangeSize), EnumerablePartitionerOptions.NoBuffering); // chunk one range at a time
-        }
-
-        // Private method to parcel out range tuples.
-        private static IEnumerable<Tuple<int, int>> CreateRanges(int fromInclusive, int toExclusive, int rangeSize)
-        {
-            // Enumerate all of the ranges
-            int from, to;
-            bool shouldQuit = false;
-
-            for (int i = fromInclusive; (i < toExclusive) && !shouldQuit; i += rangeSize)
-            {
-                from = i;
-                try { checked { to = i + rangeSize; } }
-                catch (OverflowException)
-                {
-                    to = toExclusive;
-                    shouldQuit = true;
-                }
-                if (to > toExclusive) to = toExclusive;
-                yield return new Tuple<int, int>(from, to);
-            }
-        }
-
-        #region DynamicPartitionEnumerator_Abstract class
-        /// <summary>
-        /// DynamicPartitionEnumerator_Abstract defines the enumerator for each partition for the dynamic load-balance
-        /// partitioning algorithm. 
-        /// - Partition is an enumerator of KeyValuePairs, each corresponding to an item in the data source: 
-        ///   the key is the index in the source collection; the value is the item itself.
-        /// - a set of such partitions share a reader over data source. The type of the reader is specified by
-        ///   TSourceReader. 
-        /// - each partition requests a contiguous chunk of elements at a time from the source data. The chunk 
-        ///   size is initially 1, and doubles every time until it reaches the maximum chunk size. 
-        ///   The implementation for GrabNextChunk() method has two versions: one for data source of IndexRange 
-        ///   types (IList and the array), one for data source of IEnumerable.
-        /// - The method "Reset" is not supported for any partitioning algorithm.
-        /// - The implementation for MoveNext() method is same for all dynanmic partitioners, so we provide it
-        ///   in this abstract class.
-        /// </summary>
-        /// <typeparam name="TSource">Type of the elements in the data source</typeparam>
-        /// <typeparam name="TSourceReader">Type of the reader on the data source</typeparam>
-        //TSourceReader is 
-        //  - IList<TSource>, when source data is IList<TSource>, the shared reader is source data itself
-        //  - TSource[], when source data is TSource[], the shared reader is source data itself
-        //  - IEnumerator<TSource>, when source data is IEnumerable<TSource>, and the shared reader is an 
-        //    enumerator of the source data
-        private abstract class DynamicPartitionEnumerator_Abstract<TSource, TSourceReader> : IEnumerator<KeyValuePair<long, TSource>>
-        {
-            //----------------- common fields and constructor for all dynamic partitioners -----------------
-            //--- shared by all dervied class with souce data type: IList, Array, and IEnumerator
-            protected readonly TSourceReader m_sharedReader;
-
-            protected static int s_defaultMaxChunkSize = GetDefaultChunkSize<TSource>();
-
-            //deferred allocating in MoveNext() with initial value 0, to avoid false sharing
-            //we also use the fact that: (m_currentChunkSize==null) means MoveNext is never called on this enumerator 
-            protected SharedInt m_currentChunkSize;
-
-            //deferring allocation in MoveNext() with initial value -1, to avoid false sharing
-            protected SharedInt m_localOffset;
-
-            private const int CHUNK_DOUBLING_RATE = 3; // Double the chunk size every this many grabs
-            private int m_doublingCountdown; // Number of grabs remaining until chunk size doubles
-            protected readonly int m_maxChunkSize; // s_defaultMaxChunkSize unless single-chunking is requested by the caller
-
-            // m_sharedIndex shared by this set of partitions, and particularly when m_sharedReader is IEnuerable
-            // it serves as tracking of the natual order of elements in m_sharedReader
-            // the value of this field is passed in from outside (already initialized) by the constructor, 
-            protected readonly SharedLong m_sharedIndex;
-
-            protected DynamicPartitionEnumerator_Abstract(TSourceReader sharedReader, SharedLong sharedIndex)
-                : this(sharedReader, sharedIndex, false)
-            {
-            }
-
-            protected DynamicPartitionEnumerator_Abstract(TSourceReader sharedReader, SharedLong sharedIndex, bool useSingleChunking)
-            {
-                m_sharedReader = sharedReader;
-                m_sharedIndex = sharedIndex;
-                m_maxChunkSize = useSingleChunking ? 1 : s_defaultMaxChunkSize;
-            }
-
-            // ---------------- abstract method declarations --------------
-
-            /// <summary>
-            /// Abstract method to request a contiguous chunk of elements from the source collection
-            /// </summary>
-            /// <param name="requestedChunkSize">specified number of elements requested</param>
-            /// <returns>
-            /// true if we successfully reserved at least one element (up to #=requestedChunkSize) 
-            /// false if all elements in the source collection have been reserved.
-            /// </returns>
-            //GrabNextChunk does the following: 
-            //  - grab # of requestedChunkSize elements from source data through shared reader, 
-            //  - at the time of function returns, m_currentChunkSize is updated with the number of 
-            //    elements actually got assigned (<=requestedChunkSize). 
-            //  - GrabNextChunk returns true if at least one element is assigned to this partition; 
-            //    false if the shared reader already hits the last element of the source data before 
-            //    we call GrabNextChunk
-            protected abstract bool GrabNextChunk(int requestedChunkSize);
-
-            /// <summary>
-            /// Abstract property, returns whether or not the shared reader has already read the last 
-            /// element of the source data 
-            /// </summary>
-            protected abstract bool HasNoElementsLeft { get; set; }
-
-            /// <summary>
-            /// Get the current element in the current partition. Property required by IEnumerator interface
-            /// This property is abstract because the implementation is different depending on the type
-            /// of the source data: IList, Array or IEnumerable
-            /// </summary>
-            public abstract KeyValuePair<long, TSource> Current { get; }
-
-            /// <summary>
-            /// Dispose is abstract, and depends on the type of the source data:
-            /// - For source data type IList and Array, the type of the shared reader is just the dataitself.
-            ///   We don't do anything in Dispose method for IList and Array. 
-            /// - For source data type IEnumerable, the type of the shared reader is an enumerator we created.
-            ///   Thus we need to dispose this shared reader enumerator, when there is no more active partitions
-            ///   left.
-            /// </summary>
-            public abstract void Dispose();
-
-            /// <summary>
-            /// Reset on partitions is not supported
-            /// </summary>
-            public void Reset()
-            {
-                throw new NotSupportedException();
-            }
-
-
-            /// <summary>
-            /// Get the current element in the current partition. Property required by IEnumerator interface
-            /// </summary>
-            Object IEnumerator.Current
-            {
-                get
-                {
-                    return ((DynamicPartitionEnumerator_Abstract<TSource, TSourceReader>)this).Current;
-                }
-            }
-
-            /// <summary>
-            /// Moves to the next element if any.
-            /// Try current chunk first, if the current chunk do not have any elements left, then we 
-            /// attempt to grab a chunk from the source collection.
-            /// </summary>
-            /// <returns>
-            /// true if successfully moving to the next position;
-            /// false otherwise, if and only if there is no more elements left in the current chunk 
-            /// AND the source collection is exhausted. 
-            /// </returns>
-            public bool MoveNext()
-            {
-                //perform deferred allocating of the local variables. 
-                if (m_localOffset == null)
-                {
-                    Debug.Assert(m_currentChunkSize == null);
-                    m_localOffset = new SharedInt(-1);
-                    m_currentChunkSize = new SharedInt(0);
-                    m_doublingCountdown = CHUNK_DOUBLING_RATE;
-                }
-
-                if (m_localOffset.Value < m_currentChunkSize.Value - 1)
-                //attempt to grab the next element from the local chunk
-                {
-                    m_localOffset.Value++;
-                    return true;
-                }
-                else
-                //otherwise it means we exhausted the local chunk
-                //grab a new chunk from the source enumerator
-                {
-                    // The second part of the || condition is necessary to handle the case when MoveNext() is called
-                    // after a previous MoveNext call returned false.
-                    Debug.Assert(m_localOffset.Value == m_currentChunkSize.Value - 1 || m_currentChunkSize.Value == 0);
-
-                    //set the requested chunk size to a proper value
-                    int requestedChunkSize;
-                    if (m_currentChunkSize.Value == 0) //first time grabbing from source enumerator
-                    {
-                        requestedChunkSize = 1;
-                    }
-                    else if (m_doublingCountdown > 0)
-                    {
-                        requestedChunkSize = m_currentChunkSize.Value;
-                    }
-                    else
-                    {
-                        requestedChunkSize = Math.Min(m_currentChunkSize.Value * 2, m_maxChunkSize);
-                        m_doublingCountdown = CHUNK_DOUBLING_RATE; // reset
-                    }
-
-                    // Decrement your doubling countdown
-                    m_doublingCountdown--;
-
-                    Debug.Assert(requestedChunkSize > 0 && requestedChunkSize <= m_maxChunkSize);
-                    //GrabNextChunk will update the value of m_currentChunkSize
-                    if (GrabNextChunk(requestedChunkSize))
-                    {
-                        Debug.Assert(m_currentChunkSize.Value <= requestedChunkSize && m_currentChunkSize.Value > 0);
-                        m_localOffset.Value = 0;
-                        return true;
-                    }
-                    else
-                    {
-                        return false;
-                    }
-                }
-            }
-        }
-        #endregion
-
-        #region Dynamic Partitioner for source data of IEnuemrable<> type
-        /// <summary>
-        /// Inherits from DynamicPartitioners
-        /// Provides customized implementation of GetOrderableDynamicPartitions_Factory method, to return an instance
-        /// of EnumerableOfPartitionsForIEnumerator defined internally
-        /// </summary>
-        /// <typeparam name="TSource">Type of elements in the source data</typeparam>
-        private class DynamicPartitionerForIEnumerable<TSource> : OrderablePartitioner<TSource>
-        {
-            IEnumerable<TSource> m_source;
-            readonly bool m_useSingleChunking;
-
-            //constructor
-            internal DynamicPartitionerForIEnumerable(IEnumerable<TSource> source, EnumerablePartitionerOptions partitionerOptions)
-                : base(true, false, true)
-            {
-                m_source = source;
-                m_useSingleChunking = ((partitionerOptions & EnumerablePartitionerOptions.NoBuffering) != 0);
-            }
-
-            /// <summary>
-            /// Overrides OrderablePartitioner.GetOrderablePartitions.
-            /// Partitions the underlying collection into the given number of orderable partitions.
-            /// </summary>
-            /// <param name="partitionCount">number of partitions requested</param>
-            /// <returns>A list containing <paramref name="partitionCount"/> enumerators.</returns>
-            override public IList<IEnumerator<KeyValuePair<long, TSource>>> GetOrderablePartitions(int partitionCount)
-            {
-                if (partitionCount <= 0)
-                {
-                    throw new ArgumentOutOfRangeException(nameof(partitionCount));
-                }
-                IEnumerator<KeyValuePair<long, TSource>>[] partitions
-                    = new IEnumerator<KeyValuePair<long, TSource>>[partitionCount];
-
-                IEnumerable<KeyValuePair<long, TSource>> partitionEnumerable = new InternalPartitionEnumerable(m_source.GetEnumerator(), m_useSingleChunking, true);
-                for (int i = 0; i < partitionCount; i++)
-                {
-                    partitions[i] = partitionEnumerable.GetEnumerator();
-                }
-                return partitions;
-            }
-
-            /// <summary>
-            /// Overrides OrderablePartitioner.GetOrderableDyanmicPartitions
-            /// </summary>
-            /// <returns>a enumerable collection of orderable partitions</returns>
-            override public IEnumerable<KeyValuePair<long, TSource>> GetOrderableDynamicPartitions()
-            {
-                return new InternalPartitionEnumerable(m_source.GetEnumerator(), m_useSingleChunking, false);
-            }
-
-            /// <summary>
-            /// Whether additional partitions can be created dynamically.
-            /// </summary>
-            override public bool SupportsDynamicPartitions
-            {
-                get { return true; }
-            }
-
-            #region Internal classes:  InternalPartitionEnumerable, InternalPartitionEnumerator
-            /// <summary>
-            /// Provides customized implementation for source data of IEnumerable
-            /// Different from the counterpart for IList/Array, this enumerable maintains several additional fields
-            /// shared by the partitions it owns, including a boolean "m_hasNoElementsLef", a shared lock, and a 
-            /// shared count "m_activePartitionCount" used to track active partitions when they were created statically
-            /// </summary>
-            private class InternalPartitionEnumerable : IEnumerable<KeyValuePair<long, TSource>>, IDisposable
-            {
-                //reader through which we access the source data
-                private readonly IEnumerator<TSource> m_sharedReader;
-                private SharedLong m_sharedIndex;//initial value -1
-
-                private volatile KeyValuePair<long, TSource>[] m_FillBuffer;  // intermediate buffer to reduce locking
-                private volatile int m_FillBufferSize;               // actual number of elements in m_FillBuffer. Will start
-                                                                    // at m_FillBuffer.Length, and might be reduced during the last refill
-                private volatile int m_FillBufferCurrentPosition;    //shared value to be accessed by Interlock.Increment only
-                private volatile int m_activeCopiers;               //number of active copiers
-
-                //fields shared by all partitions that this Enumerable owns, their allocation is deferred
-                private SharedBool m_hasNoElementsLeft; // no elements left at all.
-                private SharedBool m_sourceDepleted;    // no elements left in the enumerator, but there may be elements in the Fill Buffer
-
-                //shared synchronization lock, created by this Enumerable
-                private object m_sharedLock;//deferring allocation by enumerator
-
-                private bool m_disposed;
-
-                // If dynamic partitioning, then m_activePartitionCount == null
-                // If static partitioning, then it keeps track of active partition count
-                private SharedInt m_activePartitionCount;
-
-                // records whether or not the user has requested single-chunking behavior
-                private readonly bool m_useSingleChunking;
-
-                internal InternalPartitionEnumerable(IEnumerator<TSource> sharedReader, bool useSingleChunking, bool isStaticPartitioning)
-                {
-                    m_sharedReader = sharedReader;
-                    m_sharedIndex = new SharedLong(-1);
-                    m_hasNoElementsLeft = new SharedBool(false);
-                    m_sourceDepleted = new SharedBool(false);
-                    m_sharedLock = new object();
-                    m_useSingleChunking = useSingleChunking;
-
-                    // Only allocate the fill-buffer if single-chunking is not in effect
-                    if (!m_useSingleChunking)
-                    {
-                        // Time to allocate the fill buffer which is used to reduce the contention on the shared lock.
-                        // First pick the buffer size multiplier. We use 4 for when there are more than 4 cores, and just 1 for below. This is based on empirical evidence.
-                        int fillBufferMultiplier = (PlatformHelper.ProcessorCount > 4) ? 4 : 1;
-
-                        // and allocate the fill buffer using these two numbers
-                        m_FillBuffer = new KeyValuePair<long, TSource>[fillBufferMultiplier * Partitioner.GetDefaultChunkSize<TSource>()];
-                    }
-
-                    if (isStaticPartitioning)
-                    {
-                        // If this object is created for static partitioning (ie. via GetPartitions(int partitionCount), 
-                        // GetOrderablePartitions(int partitionCount)), we track the active partitions, in order to dispose 
-                        // this object when all the partitions have been disposed.
-                        m_activePartitionCount = new SharedInt(0);
-                    }
-                    else
-                    {
-                        // Otherwise this object is created for dynamic partitioning (ie, via GetDynamicPartitions(),
-                        // GetOrderableDynamicPartitions()), we do not need tracking. This object must be disposed
-                        // explicitly
-                        m_activePartitionCount = null;
-                    }
-                }
-
-                public IEnumerator<KeyValuePair<long, TSource>> GetEnumerator()
-                {
-                    if (m_disposed)
-                    {
-                        throw new ObjectDisposedException(Environment.GetResourceString("PartitionerStatic_CanNotCallGetEnumeratorAfterSourceHasBeenDisposed"));
-                    }
-                    else
-                    {
-                        return new InternalPartitionEnumerator(m_sharedReader, m_sharedIndex,
-                            m_hasNoElementsLeft, m_sharedLock, m_activePartitionCount, this, m_useSingleChunking);
-                    }
-                }
-
-
-                IEnumerator IEnumerable.GetEnumerator()
-                {
-                    return ((InternalPartitionEnumerable)this).GetEnumerator();
-                }
-
-
-                ///////////////////
-                //
-                // Used by GrabChunk_Buffered()
-                private void TryCopyFromFillBuffer(KeyValuePair<long, TSource>[] destArray, 
-                                                  int requestedChunkSize, 
-                                                  ref int actualNumElementsGrabbed)
-                {                    
-                    actualNumElementsGrabbed = 0;
-
-
-                    // making a local defensive copy of the fill buffer reference, just in case it gets nulled out
-                    KeyValuePair<long, TSource>[] fillBufferLocalRef = m_FillBuffer;
-                    if (fillBufferLocalRef == null) return;
-
-                    // first do a quick check, and give up if the current position is at the end
-                    // so that we don't do an unncessary pair of Interlocked.Increment / Decrement calls
-                    if (m_FillBufferCurrentPosition >= m_FillBufferSize)
-                    {                        
-                        return; // no elements in the buffer to copy from
-                    }
-
-                    // We might have a chance to grab elements from the buffer. We will know for sure 
-                    // when we do the Interlocked.Add below. 
-                    // But first we must register as a potential copier in order to make sure 
-                    // the elements we're copying from don't get overwritten by another thread 
-                    // that starts refilling the buffer right after our Interlocked.Add.
-                    Interlocked.Increment(ref m_activeCopiers);
-
-                    int endPos = Interlocked.Add(ref m_FillBufferCurrentPosition, requestedChunkSize);
-                    int beginPos = endPos - requestedChunkSize;
-
-                    if (beginPos < m_FillBufferSize)
-                    {
-                        // adjust index and do the actual copy
-                        actualNumElementsGrabbed = (endPos < m_FillBufferSize) ? endPos : m_FillBufferSize - beginPos;
-                        Array.Copy(fillBufferLocalRef, beginPos, destArray, 0, actualNumElementsGrabbed);
-                    }
-
-                    // let the record show we are no longer accessing the buffer
-                    Interlocked.Decrement(ref m_activeCopiers);
-                }
-
-                /// <summary>
-                /// This is the common entry point for consuming items from the source enumerable
-                /// </summary>
-                /// <returns>
-                /// true if we successfully reserved at least one element 
-                /// false if all elements in the source collection have been reserved.
-                /// </returns>
-                internal bool GrabChunk(KeyValuePair<long, TSource>[] destArray, int requestedChunkSize, ref int actualNumElementsGrabbed)
-                {
-                    actualNumElementsGrabbed = 0;
-
-                    if (m_hasNoElementsLeft.Value)
-                    {
-                        return false;
-                    }
-
-                    if (m_useSingleChunking)
-                    {
-                        return GrabChunk_Single(destArray, requestedChunkSize, ref actualNumElementsGrabbed);
-                    }
-                    else
-                    {
-                        return GrabChunk_Buffered(destArray, requestedChunkSize, ref actualNumElementsGrabbed);
-                    }
-                }
-
-                /// <summary>
-                /// Version of GrabChunk that grabs a single element at a time from the source enumerable
-                /// </summary>
-                /// <returns>
-                /// true if we successfully reserved an element 
-                /// false if all elements in the source collection have been reserved.
-                /// </returns>
-                internal bool GrabChunk_Single(KeyValuePair<long,TSource>[] destArray, int requestedChunkSize, ref int actualNumElementsGrabbed)
-                {
-                    Debug.Assert(m_useSingleChunking, "Expected m_useSingleChecking to be true");
-                    Debug.Assert(requestedChunkSize == 1, "Got requested chunk size of " + requestedChunkSize + " when single-chunking was on");
-                    Debug.Assert(actualNumElementsGrabbed == 0, "Expected actualNumElementsGrabbed == 0, instead it is " + actualNumElementsGrabbed);
-                    Debug.Assert(destArray.Length == 1, "Expected destArray to be of length 1, instead its length is " + destArray.Length);
-
-                    lock (m_sharedLock)
-                    {
-                        if (m_hasNoElementsLeft.Value) return false;
-
-                        try
-                        {
-                            if (m_sharedReader.MoveNext())
-                            {
-                                m_sharedIndex.Value = checked(m_sharedIndex.Value + 1);
-                                destArray[0]
-                                    = new KeyValuePair<long, TSource>(m_sharedIndex.Value,
-                                                                        m_sharedReader.Current);
-                                actualNumElementsGrabbed = 1;
-                                return true;
-                            }
-                            else
-                            {
-                                //if MoveNext() return false, we set the flag to inform other partitions
-                                m_sourceDepleted.Value = true;
-                                m_hasNoElementsLeft.Value = true;
-                                return false;
-                            }
-                        }
-                        catch
-                        {
-                            // On an exception, make sure that no additional items are hereafter enumerated
-                            m_sourceDepleted.Value = true;
-                            m_hasNoElementsLeft.Value = true;
-                            throw;
-                        }
-                    }
-                }
-
-
-
-                /// <summary>
-                /// Version of GrabChunk that uses buffering scheme to grab items out of source enumerable
-                /// </summary>
-                /// <returns>
-                /// true if we successfully reserved at least one element (up to #=requestedChunkSize) 
-                /// false if all elements in the source collection have been reserved.
-                /// </returns>
-                internal bool GrabChunk_Buffered(KeyValuePair<long,TSource>[] destArray, int requestedChunkSize, ref int actualNumElementsGrabbed)
-                {
-                    Debug.Assert(requestedChunkSize > 0);
-                    Debug.Assert(!m_useSingleChunking, "Did not expect to be in single-chunking mode");
-
-                    TryCopyFromFillBuffer(destArray, requestedChunkSize, ref actualNumElementsGrabbed);
-                    
-                    if (actualNumElementsGrabbed == requestedChunkSize)
-                    {
-                        // that was easy.
-                        return true;
-                    }
-                    else if (m_sourceDepleted.Value)
-                    {
-                        // looks like we both reached the end of the fill buffer, and the source was depleted previously
-                        // this means no more work to do for any other worker
-                        m_hasNoElementsLeft.Value = true;
-                        m_FillBuffer = null;
-                        return (actualNumElementsGrabbed > 0);
-                    }
-
-
-                    //
-                    //  now's the time to take the shared lock and enumerate
-                    //
-                    lock (m_sharedLock)
-                    {
-                        if (m_sourceDepleted.Value)
-                        {
-                            return (actualNumElementsGrabbed > 0);
-                        }
-                        
-                        try
-                        {
-                            // we need to make sure all array copiers are finished
-                            if (m_activeCopiers > 0)
-                            {                                    
-                                SpinWait sw = new SpinWait();
-                                while( m_activeCopiers > 0) sw.SpinOnce();
-                            }
-
-                            Debug.Assert(m_sharedIndex != null); //already been allocated in MoveNext() before calling GrabNextChunk
-
-                            // Now's the time to actually enumerate the source
-
-                            // We first fill up the requested # of elements in the caller's array
-                            // continue from the where TryCopyFromFillBuffer() left off
-                            for (; actualNumElementsGrabbed < requestedChunkSize; actualNumElementsGrabbed++)
-                            {
-                                if (m_sharedReader.MoveNext())
-                                {
-                                    m_sharedIndex.Value = checked(m_sharedIndex.Value + 1);
-                                    destArray[actualNumElementsGrabbed]
-                                        = new KeyValuePair<long, TSource>(m_sharedIndex.Value,
-                                                                          m_sharedReader.Current);
-                                }
-                                else
-                                {
-                                    //if MoveNext() return false, we set the flag to inform other partitions
-                                    m_sourceDepleted.Value = true;
-                                    break;
-                                }
-                            }
-
-                            // taking a local snapshot of m_FillBuffer in case some other thread decides to null out m_FillBuffer 
-                            // in the entry of this method after observing m_sourceCompleted = true
-                            var localFillBufferRef = m_FillBuffer;
-
-                            // If the big buffer seems to be depleted, we will also fill that up while we are under the lock
-                            // Note that this is the only place that m_FillBufferCurrentPosition can be reset
-                            if (m_sourceDepleted.Value == false && localFillBufferRef != null && 
-                                m_FillBufferCurrentPosition >= localFillBufferRef.Length)
-                            {
-                                for (int i = 0; i < localFillBufferRef.Length; i++)
-                                {
-                                    if( m_sharedReader.MoveNext())
-                                    {
-                                        m_sharedIndex.Value = checked(m_sharedIndex.Value + 1);
-                                        localFillBufferRef[i]
-                                            = new KeyValuePair<long, TSource>(m_sharedIndex.Value,
-                                                                              m_sharedReader.Current);
-                                    }
-                                    else
-                                    {
-                                        // No more elements left in the enumerator.
-                                        // Record this, so that the next request can skip the lock
-                                        m_sourceDepleted.Value = true;
-
-                                        // also record the current count in m_FillBufferSize
-                                        m_FillBufferSize = i;
-
-                                        // and exit the for loop so that we don't keep incrementing m_FillBufferSize
-                                        break;
-                                    }
-
-                                }
-
-                                m_FillBufferCurrentPosition = 0;
-                            }
-
-
-                        }
-                        catch
-                        {
-                            // If an exception occurs, don't let the other enumerators try to enumerate.
-                            // NOTE: this could instead throw an InvalidOperationException, but that would be unexpected 
-                            // and not helpful to the end user.  We know the root cause is being communicated already.)
-                            m_sourceDepleted.Value = true;
-                            m_hasNoElementsLeft.Value = true;
-                            throw;
-                        }
-                    }
-
-                    return (actualNumElementsGrabbed > 0);
-                }
-
-                public void Dispose()
-                {
-                    if (!m_disposed)
-                    {
-                        m_disposed = true;
-                        m_sharedReader.Dispose();
-                    }
-                }
-            }
-
-            /// <summary>
-            /// Inherits from DynamicPartitionEnumerator_Abstract directly
-            /// Provides customized implementation for: GrabNextChunk, HasNoElementsLeft, Current, Dispose
-            /// </summary>
-            private class InternalPartitionEnumerator : DynamicPartitionEnumerator_Abstract<TSource, IEnumerator<TSource>>
-            {
-                //---- fields ----
-                //cached local copy of the current chunk
-                private KeyValuePair<long, TSource>[] m_localList; //defer allocating to avoid false sharing
-
-                // the values of the following two fields are passed in from
-                // outside(already initialized) by the constructor, 
-                private readonly SharedBool m_hasNoElementsLeft;
-                private readonly object m_sharedLock;
-                private readonly SharedInt m_activePartitionCount;
-                private InternalPartitionEnumerable m_enumerable;
-
-                //constructor
-                internal InternalPartitionEnumerator(
-                    IEnumerator<TSource> sharedReader,
-                    SharedLong sharedIndex,
-                    SharedBool hasNoElementsLeft,
-                    object sharedLock,
-                    SharedInt activePartitionCount,
-                    InternalPartitionEnumerable enumerable,
-                    bool useSingleChunking)
-                    : base(sharedReader, sharedIndex, useSingleChunking)
-                {
-                    m_hasNoElementsLeft = hasNoElementsLeft;
-                    m_sharedLock = sharedLock;
-                    m_enumerable = enumerable;
-                    m_activePartitionCount = activePartitionCount;
-
-                    if (m_activePartitionCount != null)
-                    {
-                        // If static partitioning, we need to increase the active partition count.
-                        Interlocked.Increment(ref m_activePartitionCount.Value);
-                    }
-                }
-
-                //overriding methods
-
-                /// <summary>
-                /// Reserves a contiguous range of elements from source data
-                /// </summary>
-                /// <param name="requestedChunkSize">specified number of elements requested</param>
-                /// <returns>
-                /// true if we successfully reserved at least one element (up to #=requestedChunkSize) 
-                /// false if all elements in the source collection have been reserved.
-                /// </returns>
-                override protected bool GrabNextChunk(int requestedChunkSize)
-                {
-                    Debug.Assert(requestedChunkSize > 0);
-
-                    if (HasNoElementsLeft)
-                    {
-                        return false;
-                    }
-
-                    // defer allocation to avoid false sharing
-                    if (m_localList == null)
-                    {
-                        m_localList = new KeyValuePair<long, TSource>[m_maxChunkSize];
-                    }
-
-                    // make the actual call to the enumerable that grabs a chunk
-                    return m_enumerable.GrabChunk(m_localList, requestedChunkSize, ref m_currentChunkSize.Value);
-                }
-
-                /// <summary>
-                /// Returns whether or not the shared reader has already read the last 
-                /// element of the source data 
-                /// </summary>
-                /// <remarks>
-                /// We cannot call m_sharedReader.MoveNext(), to see if it hits the last element
-                /// or not, because we can't undo MoveNext(). Thus we need to maintain a shared 
-                /// boolean value m_hasNoElementsLeft across all partitions
-                /// </remarks>
-                override protected bool HasNoElementsLeft
-                {
-                    get { return m_hasNoElementsLeft.Value; }
-                    set
-                    {
-                        //we only set it from false to true once
-                        //we should never set it back in any circumstances
-                        Debug.Assert(value);
-                        Debug.Assert(!m_hasNoElementsLeft.Value);
-                        m_hasNoElementsLeft.Value = true;
-                    }
-                }
-
-                override public KeyValuePair<long, TSource> Current
-                {
-                    get
-                    {
-                        //verify that MoveNext is at least called once before Current is called 
-                        if (m_currentChunkSize == null)
-                        {
-                            throw new InvalidOperationException(Environment.GetResourceString("PartitionerStatic_CurrentCalledBeforeMoveNext"));
-                        }
-                        Debug.Assert(m_localList != null);
-                        Debug.Assert(m_localOffset.Value >= 0 && m_localOffset.Value < m_currentChunkSize.Value);
-                        return (m_localList[m_localOffset.Value]);
-                    }
-                }
-
-                override public void Dispose()
-                {
-                    // If this is static partitioning, ie. m_activePartitionCount != null, since the current partition 
-                    // is disposed, we decrement the number of active partitions for the shared reader. 
-                    if (m_activePartitionCount != null && Interlocked.Decrement(ref m_activePartitionCount.Value) == 0)
-                    {
-                        // If the number of active partitions becomes 0, we need to dispose the shared 
-                        // reader we created in the m_enumerable object.
-                        m_enumerable.Dispose();
-                    }
-                    // If this is dynamic partitioning, ie. m_activePartitionCount != null, then m_enumerable needs to
-                    // be disposed explicitly by the user, and we do not need to anything here
-                }
-            }
-            #endregion
-
-        }
-        #endregion
-
-        #region Dynamic Partitioner for source data of IndexRange types (IList<> and Array<>)
-        /// <summary>
-        /// Dynamic load-balance partitioner. This class is abstract and to be derived from by 
-        /// the customized partitioner classes for IList, Array, and IEnumerable
-        /// </summary>
-        /// <typeparam name="TSource">Type of the elements in the source data</typeparam>
-        /// <typeparam name="TCollection"> Type of the source data collection</typeparam>
-        private abstract class DynamicPartitionerForIndexRange_Abstract<TSource, TCollection> : OrderablePartitioner<TSource>
-        {
-            // TCollection can be: IList<TSource>, TSource[] and IEnumerable<TSource>
-            // Derived classes specify TCollection, and implement the abstract method GetOrderableDynamicPartitions_Factory accordingly
-            TCollection m_data;
-
-            /// <summary>
-            /// Constructs a new orderable partitioner 
-            /// </summary>
-            /// <param name="data">source data collection</param>
-            protected DynamicPartitionerForIndexRange_Abstract(TCollection data)
-                : base(true, false, true)
-            {
-                m_data = data;
-            }
-
-            /// <summary>
-            /// Partition the source data and create an enumerable over the resulting partitions. 
-            /// </summary>
-            /// <param name="data">the source data collection</param>
-            /// <returns>an enumerable of partitions of </returns>
-            protected abstract IEnumerable<KeyValuePair<long, TSource>> GetOrderableDynamicPartitions_Factory(TCollection data);
-
-            /// <summary>
-            /// Overrides OrderablePartitioner.GetOrderablePartitions.
-            /// Partitions the underlying collection into the given number of orderable partitions.
-            /// </summary>
-            /// <param name="partitionCount">number of partitions requested</param>
-            /// <returns>A list containing <paramref name="partitionCount"/> enumerators.</returns>
-            override public IList<IEnumerator<KeyValuePair<long, TSource>>> GetOrderablePartitions(int partitionCount)
-            {
-                if (partitionCount <= 0)
-                {
-                    throw new ArgumentOutOfRangeException(nameof(partitionCount));
-                }
-                IEnumerator<KeyValuePair<long, TSource>>[] partitions
-                    = new IEnumerator<KeyValuePair<long, TSource>>[partitionCount];
-                IEnumerable<KeyValuePair<long, TSource>> partitionEnumerable = GetOrderableDynamicPartitions_Factory(m_data);
-                for (int i = 0; i < partitionCount; i++)
-                {
-                    partitions[i] = partitionEnumerable.GetEnumerator();
-                }
-                return partitions;
-            }
-
-            /// <summary>
-            /// Overrides OrderablePartitioner.GetOrderableDyanmicPartitions
-            /// </summary>
-            /// <returns>a enumerable collection of orderable partitions</returns>
-            override public IEnumerable<KeyValuePair<long, TSource>> GetOrderableDynamicPartitions()
-            {
-                return GetOrderableDynamicPartitions_Factory(m_data);
-            }
-
-            /// <summary>
-            /// Whether additional partitions can be created dynamically.
-            /// </summary>
-            override public bool SupportsDynamicPartitions
-            {
-                get { return true; }
-            }
-
-        }
-
-        /// <summary>
-        /// Defines dynamic partition for source data of IList and Array. 
-        /// This class inherits DynamicPartitionEnumerator_Abstract
-        ///   - implements GrabNextChunk, HasNoElementsLeft, and Dispose methods for IList and Array
-        ///   - Current property still remains abstract, implementation is different for IList and Array
-        ///   - introduces another abstract method SourceCount, which returns the number of elements in
-        ///     the source data. Implementation differs for IList and Array
-        /// </summary>
-        /// <typeparam name="TSource">Type of the elements in the data source</typeparam>
-        /// <typeparam name="TSourceReader">Type of the reader on the source data</typeparam>
-        private abstract class DynamicPartitionEnumeratorForIndexRange_Abstract<TSource, TSourceReader> : DynamicPartitionEnumerator_Abstract<TSource, TSourceReader>
-        {
-            //fields
-            protected int m_startIndex; //initially zero
-
-            //constructor
-            protected DynamicPartitionEnumeratorForIndexRange_Abstract(TSourceReader sharedReader, SharedLong sharedIndex)
-                : base(sharedReader, sharedIndex)
-            {
-            }
-
-            //abstract methods
-            //the Current property is still abstract, and will be implemented by derived classes
-            //we add another abstract method SourceCount to get the number of elements from the source reader
-
-            /// <summary>
-            /// Get the number of elements from the source reader.
-            /// It calls IList.Count or Array.Length
-            /// </summary>
-            protected abstract int SourceCount { get; }
-
-            //overriding methods
-
-            /// <summary>
-            /// Reserves a contiguous range of elements from source data
-            /// </summary>
-            /// <param name="requestedChunkSize">specified number of elements requested</param>
-            /// <returns>
-            /// true if we successfully reserved at least one element (up to #=requestedChunkSize) 
-            /// false if all elements in the source collection have been reserved.
-            /// </returns>
-            override protected bool GrabNextChunk(int requestedChunkSize)
-            {
-                Debug.Assert(requestedChunkSize > 0);
-
-                while (!HasNoElementsLeft)
-                {
-                    Debug.Assert(m_sharedIndex != null);
-                    // use the new Volatile.Read method because it is cheaper than Interlocked.Read on AMD64 architecture
-                    long oldSharedIndex = Volatile.Read(ref m_sharedIndex.Value);
-
-                    if (HasNoElementsLeft)
-                    {
-                        //HasNoElementsLeft situation changed from false to true immediately
-                        //and oldSharedIndex becomes stale
-                        return false;
-                    }
-
-                    //there won't be overflow, because the index of IList/array is int, and we 
-                    //have casted it to long. 
-                    long newSharedIndex = Math.Min(SourceCount - 1, oldSharedIndex + requestedChunkSize);
-
-
-                    //the following CAS, if successful, reserves a chunk of elements [oldSharedIndex+1, newSharedIndex] 
-                    //inclusive in the source collection
-                    if (Interlocked.CompareExchange(ref m_sharedIndex.Value, newSharedIndex, oldSharedIndex)
-                        == oldSharedIndex)
-                    {
-                        //set up local indexes.
-                        //m_currentChunkSize is always set to requestedChunkSize when source data had 
-                        //enough elements of what we requested
-                        m_currentChunkSize.Value = (int)(newSharedIndex - oldSharedIndex);
-                        m_localOffset.Value = -1;
-                        m_startIndex = (int)(oldSharedIndex + 1);
-                        return true;
-                    }
-                }
-                //didn't get any element, return false;
-                return false;
-            }
-
-            /// <summary>
-            /// Returns whether or not the shared reader has already read the last 
-            /// element of the source data 
-            /// </summary>
-            override protected bool HasNoElementsLeft
-            {
-                get
-                {
-                    Debug.Assert(m_sharedIndex != null);
-                    // use the new Volatile.Read method because it is cheaper than Interlocked.Read on AMD64 architecture
-                    return Volatile.Read(ref m_sharedIndex.Value) >= SourceCount - 1;
-                }
-                set
-                {
-                    Debug.Assert(false);
-                }
-            }
-
-            /// <summary>
-            /// For source data type IList and Array, the type of the shared reader is just the data itself.
-            /// We don't do anything in Dispose method for IList and Array. 
-            /// </summary>
-            override public void Dispose()
-            { }
-        }
-
-
-        /// <summary>
-        /// Inherits from DynamicPartitioners
-        /// Provides customized implementation of GetOrderableDynamicPartitions_Factory method, to return an instance
-        /// of EnumerableOfPartitionsForIList defined internally
-        /// </summary>
-        /// <typeparam name="TSource">Type of elements in the source data</typeparam>
-        private class DynamicPartitionerForIList<TSource> : DynamicPartitionerForIndexRange_Abstract<TSource, IList<TSource>>
-        {
-            //constructor
-            internal DynamicPartitionerForIList(IList<TSource> source)
-                : base(source)
-            { }
-
-            //override methods
-            override protected IEnumerable<KeyValuePair<long, TSource>> GetOrderableDynamicPartitions_Factory(IList<TSource> m_data)
-            {
-                //m_data itself serves as shared reader
-                return new InternalPartitionEnumerable(m_data);
-            }
-
-            /// <summary>
-            /// Inherits from PartitionList_Abstract 
-            /// Provides customized implementation for source data of IList
-            /// </summary>
-            private class InternalPartitionEnumerable : IEnumerable<KeyValuePair<long, TSource>>
-            {
-                //reader through which we access the source data
-                private readonly IList<TSource> m_sharedReader;
-                private SharedLong m_sharedIndex;
-
-                internal InternalPartitionEnumerable(IList<TSource> sharedReader)
-                {
-                    m_sharedReader = sharedReader;
-                    m_sharedIndex = new SharedLong(-1);
-                }
-
-                public IEnumerator<KeyValuePair<long, TSource>> GetEnumerator()
-                {
-                    return new InternalPartitionEnumerator(m_sharedReader, m_sharedIndex);
-                }
-
-                IEnumerator IEnumerable.GetEnumerator()
-                {
-                    return ((InternalPartitionEnumerable)this).GetEnumerator();
-                }
-            }
-
-            /// <summary>
-            /// Inherits from DynamicPartitionEnumeratorForIndexRange_Abstract
-            /// Provides customized implementation of SourceCount property and Current property for IList
-            /// </summary>
-            private class InternalPartitionEnumerator : DynamicPartitionEnumeratorForIndexRange_Abstract<TSource, IList<TSource>>
-            {
-                //constructor
-                internal InternalPartitionEnumerator(IList<TSource> sharedReader, SharedLong sharedIndex)
-                    : base(sharedReader, sharedIndex)
-                { }
-
-                //overriding methods
-                override protected int SourceCount
-                {
-                    get { return m_sharedReader.Count; }
-                }
-                /// <summary>
-                /// return a KeyValuePair of the current element and its key 
-                /// </summary>
-                override public KeyValuePair<long, TSource> Current
-                {
-                    get
-                    {
-                        //verify that MoveNext is at least called once before Current is called 
-                        if (m_currentChunkSize == null)
-                        {
-                            throw new InvalidOperationException(Environment.GetResourceString("PartitionerStatic_CurrentCalledBeforeMoveNext"));
-                        }
-
-                        Debug.Assert(m_localOffset.Value >= 0 && m_localOffset.Value < m_currentChunkSize.Value);
-                        return new KeyValuePair<long, TSource>(m_startIndex + m_localOffset.Value,
-                            m_sharedReader[m_startIndex + m_localOffset.Value]);
-                    }
-                }
-            }
-        }
-
-
-
-        /// <summary>
-        /// Inherits from DynamicPartitioners
-        /// Provides customized implementation of GetOrderableDynamicPartitions_Factory method, to return an instance
-        /// of EnumerableOfPartitionsForArray defined internally
-        /// </summary>
-        /// <typeparam name="TSource">Type of elements in the source data</typeparam>
-        private class DynamicPartitionerForArray<TSource> : DynamicPartitionerForIndexRange_Abstract<TSource, TSource[]>
-        {
-            //constructor
-            internal DynamicPartitionerForArray(TSource[] source)
-                : base(source)
-            { }
-
-            //override methods
-            override protected IEnumerable<KeyValuePair<long, TSource>> GetOrderableDynamicPartitions_Factory(TSource[] m_data)
-            {
-                return new InternalPartitionEnumerable(m_data);
-            }
-
-            /// <summary>
-            /// Inherits from PartitionList_Abstract 
-            /// Provides customized implementation for source data of Array
-            /// </summary>
-            private class InternalPartitionEnumerable : IEnumerable<KeyValuePair<long, TSource>>
-            {
-                //reader through which we access the source data
-                private readonly TSource[] m_sharedReader;
-                private SharedLong m_sharedIndex;
-
-                internal InternalPartitionEnumerable(TSource[] sharedReader)
-                {
-                    m_sharedReader = sharedReader;
-                    m_sharedIndex = new SharedLong(-1);
-                }
-
-                IEnumerator IEnumerable.GetEnumerator()
-                {
-                    return ((InternalPartitionEnumerable)this).GetEnumerator();
-                }
-
-
-                public IEnumerator<KeyValuePair<long, TSource>> GetEnumerator()
-                {
-                    return new InternalPartitionEnumerator(m_sharedReader, m_sharedIndex);
-                }
-            }
-
-            /// <summary>
-            /// Inherits from DynamicPartitionEnumeratorForIndexRange_Abstract
-            /// Provides customized implementation of SourceCount property and Current property for Array
-            /// </summary>
-            private class InternalPartitionEnumerator : DynamicPartitionEnumeratorForIndexRange_Abstract<TSource, TSource[]>
-            {
-                //constructor
-                internal InternalPartitionEnumerator(TSource[] sharedReader, SharedLong sharedIndex)
-                    : base(sharedReader, sharedIndex)
-                { }
-
-                //overriding methods
-                override protected int SourceCount
-                {
-                    get { return m_sharedReader.Length; }
-                }
-
-                override public KeyValuePair<long, TSource> Current
-                {
-                    get
-                    {
-                        //verify that MoveNext is at least called once before Current is called 
-                        if (m_currentChunkSize == null)
-                        {
-                            throw new InvalidOperationException(Environment.GetResourceString("PartitionerStatic_CurrentCalledBeforeMoveNext"));
-                        }
-
-                        Debug.Assert(m_localOffset.Value >= 0 && m_localOffset.Value < m_currentChunkSize.Value);
-                        return new KeyValuePair<long, TSource>(m_startIndex + m_localOffset.Value,
-                            m_sharedReader[m_startIndex + m_localOffset.Value]);
-                    }
-                }
-            }
-        }
-        #endregion
-
-
-        #region Static partitioning for IList and Array, abstract classes
-        /// <summary>
-        /// Static partitioning over IList. 
-        /// - dynamic and load-balance
-        /// - Keys are ordered within each partition
-        /// - Keys are ordered across partitions
-        /// - Keys are normalized
-        /// - Number of partitions is fixed once specified, and the elements of the source data are 
-        /// distributed to each partition as evenly as possible. 
-        /// </summary>
-        /// <typeparam name="TSource">type of the elements</typeparam>        
-        /// <typeparam name="TCollection">Type of the source data collection</typeparam>
-        private abstract class StaticIndexRangePartitioner<TSource, TCollection> : OrderablePartitioner<TSource>
-        {
-            protected StaticIndexRangePartitioner()
-                : base(true, true, true)
-            { }
-
-            /// <summary>
-            /// Abstract method to return the number of elements in the source data
-            /// </summary>
-            protected abstract int SourceCount { get; }
-
-            /// <summary>
-            /// Abstract method to create a partition that covers a range over source data, 
-            /// starting from "startIndex", ending at "endIndex"
-            /// </summary>
-            /// <param name="startIndex">start index of the current partition on the source data</param>
-            /// <param name="endIndex">end index of the current partition on the source data</param>
-            /// <returns>a partition enumerator over the specified range</returns>
-            // The partitioning algorithm is implemented in GetOrderablePartitions method
-            // This method delegates according to source data type IList/Array
-            protected abstract IEnumerator<KeyValuePair<long, TSource>> CreatePartition(int startIndex, int endIndex);
-
-            /// <summary>
-            /// Overrides OrderablePartitioner.GetOrderablePartitions
-            /// Return a list of partitions, each of which enumerate a fixed part of the source data
-            /// The elements of the source data are distributed to each partition as evenly as possible. 
-            /// Specifically, if the total number of elements is N, and number of partitions is x, and N = a*x +b, 
-            /// where a is the quotient, and b is the remainder. Then the first b partitions each has a + 1 elements,
-            /// and the last x-b partitions each has a elements.
-            /// For example, if N=10, x =3, then 
-            ///    partition 0 ranges [0,3],
-            ///    partition 1 ranges [4,6],
-            ///    partition 2 ranges [7,9].
-            /// This also takes care of the situation of (x&gt;N), the last x-N partitions are empty enumerators. 
-            /// An empty enumerator is indicated by 
-            ///      (m_startIndex == list.Count &amp;&amp; m_endIndex == list.Count -1)
-            /// </summary>
-            /// <param name="partitionCount">specified number of partitions</param>
-            /// <returns>a list of partitions</returns>
-            override public IList<IEnumerator<KeyValuePair<long, TSource>>> GetOrderablePartitions(int partitionCount)
-            {
-                if (partitionCount <= 0)
-                {
-                    throw new ArgumentOutOfRangeException(nameof(partitionCount));
-                }
-
-                int quotient, remainder;
-                quotient = Math.DivRem(SourceCount, partitionCount, out remainder);
-
-                IEnumerator<KeyValuePair<long, TSource>>[] partitions = new IEnumerator<KeyValuePair<long, TSource>>[partitionCount];
-                int lastEndIndex = -1;
-                for (int i = 0; i < partitionCount; i++)
-                {
-                    int startIndex = lastEndIndex + 1;
-
-                    if (i < remainder)
-                    {
-                        lastEndIndex = startIndex + quotient;
-                    }
-                    else
-                    {
-                        lastEndIndex = startIndex + quotient - 1;
-                    }
-                    partitions[i] = CreatePartition(startIndex, lastEndIndex);
-                }
-                return partitions;
-            }
-        }
-
-        /// <summary>
-        /// Static Partition for IList/Array.
-        /// This class implements all methods required by IEnumerator interface, except for the Current property.
-        /// Current Property is different for IList and Array. Arrays calls 'ldelem' instructions for faster element 
-        /// retrieval.
-        /// </summary>
-        //We assume the source collection is not being updated concurrently. Otherwise it will break the  
-        //static partitioning, since each partition operates on the source collection directly, it does 
-        //not have a local cache of the elements assigned to them.  
-        private abstract class StaticIndexRangePartition<TSource> : IEnumerator<KeyValuePair<long, TSource>>
-        {
-            //the start and end position in the source collection for the current partition
-            //the partition is empty if and only if 
-            // (m_startIndex == m_data.Count && m_endIndex == m_data.Count-1)
-            protected readonly int m_startIndex;
-            protected readonly int m_endIndex;
-
-            //the current index of the current partition while enumerating on the source collection
-            protected volatile int m_offset;
-
-            /// <summary>
-            /// Constructs an instance of StaticIndexRangePartition
-            /// </summary>
-            /// <param name="startIndex">the start index in the source collection for the current partition </param>
-            /// <param name="endIndex">the end index in the source collection for the current partition</param>
-            protected StaticIndexRangePartition(int startIndex, int endIndex)
-            {
-                m_startIndex = startIndex;
-                m_endIndex = endIndex;
-                m_offset = startIndex - 1;
-            }
-
-            /// <summary>
-            /// Current Property is different for IList and Array. Arrays calls 'ldelem' instructions for faster 
-            /// element retrieval.
-            /// </summary>
-            public abstract KeyValuePair<long, TSource> Current { get; }
-
-            /// <summary>
-            /// We don't dispose the source for IList and array
-            /// </summary>
-            public void Dispose()
-            { }
-
-            public void Reset()
-            {
-                throw new NotSupportedException();
-            }
-
-            /// <summary>
-            /// Moves to the next item
-            /// Before the first MoveNext is called: m_offset == m_startIndex-1;
-            /// </summary>
-            /// <returns>true if successful, false if there is no item left</returns>
-            public bool MoveNext()
-            {
-                if (m_offset < m_endIndex)
-                {
-                    m_offset++;
-                    return true;
-                }
-                else
-                {
-                    //After we have enumerated over all elements, we set m_offset to m_endIndex +1.
-                    //The reason we do this is, for an empty enumerator, we need to tell the Current 
-                    //property whether MoveNext has been called or not. 
-                    //For an empty enumerator, it starts with (m_offset == m_startIndex-1 == m_endIndex), 
-                    //and we don't set a new value to m_offset, then the above condition will always be 
-                    //true, and the Current property will mistakenly assume MoveNext is never called.
-                    m_offset = m_endIndex + 1;
-                    return false;
-                }
-            }
-
-            Object IEnumerator.Current
-            {
-                get
-                {
-                    return ((StaticIndexRangePartition<TSource>)this).Current;
-                }
-            }
-        }
-        #endregion
-
-        #region Static partitioning for IList
-        /// <summary>
-        /// Inherits from StaticIndexRangePartitioner
-        /// Provides customized implementation of SourceCount and CreatePartition
-        /// </summary>
-        /// <typeparam name="TSource"></typeparam>
-        private class StaticIndexRangePartitionerForIList<TSource> : StaticIndexRangePartitioner<TSource, IList<TSource>>
-        {
-            IList<TSource> m_list;
-            internal StaticIndexRangePartitionerForIList(IList<TSource> list)
-                : base()
-            {
-                Debug.Assert(list != null);
-                m_list = list;
-            }
-            override protected int SourceCount
-            {
-                get { return m_list.Count; }
-            }
-            override protected IEnumerator<KeyValuePair<long, TSource>> CreatePartition(int startIndex, int endIndex)
-            {
-                return new StaticIndexRangePartitionForIList<TSource>(m_list, startIndex, endIndex);
-            }
-        }
-
-        /// <summary>
-        /// Inherits from StaticIndexRangePartition
-        /// Provides customized implementation of Current property
-        /// </summary>
-        /// <typeparam name="TSource"></typeparam>
-        private class StaticIndexRangePartitionForIList<TSource> : StaticIndexRangePartition<TSource>
-        {
-            //the source collection shared by all partitions
-            private volatile IList<TSource> m_list;
-
-            internal StaticIndexRangePartitionForIList(IList<TSource> list, int startIndex, int endIndex)
-                : base(startIndex, endIndex)
-            {
-                Debug.Assert(startIndex >= 0 && endIndex <= list.Count - 1);
-                m_list = list;
-            }
-
-            override public KeyValuePair<long, TSource> Current
-            {
-                get
-                {
-                    //verify that MoveNext is at least called once before Current is called 
-                    if (m_offset < m_startIndex)
-                    {
-                        throw new InvalidOperationException(Environment.GetResourceString("PartitionerStatic_CurrentCalledBeforeMoveNext"));
-                    }
-
-                    Debug.Assert(m_offset >= m_startIndex && m_offset <= m_endIndex);
-                    return (new KeyValuePair<long, TSource>(m_offset, m_list[m_offset]));
-                }
-            }
-        }
-        #endregion
-
-        #region static partitioning for Arrays
-        /// <summary>
-        /// Inherits from StaticIndexRangePartitioner
-        /// Provides customized implementation of SourceCount and CreatePartition for Array
-        /// </summary>
-        private class StaticIndexRangePartitionerForArray<TSource> : StaticIndexRangePartitioner<TSource, TSource[]>
-        {
-            TSource[] m_array;
-            internal StaticIndexRangePartitionerForArray(TSource[] array)
-                : base()
-            {
-                Debug.Assert(array != null);
-                m_array = array;
-            }
-            override protected int SourceCount
-            {
-                get { return m_array.Length; }
-            }
-            override protected IEnumerator<KeyValuePair<long, TSource>> CreatePartition(int startIndex, int endIndex)
-            {
-                return new StaticIndexRangePartitionForArray<TSource>(m_array, startIndex, endIndex);
-            }
-        }
-
-        /// <summary>
-        /// Inherits from StaticIndexRangePartitioner
-        /// Provides customized implementation of SourceCount and CreatePartition
-        /// </summary>
-        private class StaticIndexRangePartitionForArray<TSource> : StaticIndexRangePartition<TSource>
-        {
-            //the source collection shared by all partitions
-            private volatile TSource[] m_array;
-
-            internal StaticIndexRangePartitionForArray(TSource[] array, int startIndex, int endIndex)
-                : base(startIndex, endIndex)
-            {
-                Debug.Assert(startIndex >= 0 && endIndex <= array.Length - 1);
-                m_array = array;
-            }
-
-            override public KeyValuePair<long, TSource> Current
-            {
-                get
-                {
-                    //verify that MoveNext is at least called once before Current is called 
-                    if (m_offset < m_startIndex)
-                    {
-                        throw new InvalidOperationException(Environment.GetResourceString("PartitionerStatic_CurrentCalledBeforeMoveNext"));
-                    }
-
-                    Debug.Assert(m_offset >= m_startIndex && m_offset <= m_endIndex);
-                    return (new KeyValuePair<long, TSource>(m_offset, m_array[m_offset]));
-                }
-            }
-        }
-        #endregion
-
-
-        #region Utility functions
-        /// <summary>
-        /// A very simple primitive that allows us to share a value across multiple threads.
-        /// </summary>
-        /// <typeparam name="TSource"></typeparam>
-        private class SharedInt
-        {
-            internal volatile int Value;
-
-            internal SharedInt(int value)
-            {
-                this.Value = value;
-            }
-
-        }
-
-        /// <summary>
-        /// A very simple primitive that allows us to share a value across multiple threads.
-        /// </summary>
-        private class SharedBool
-        {
-            internal volatile bool Value;
-
-            internal SharedBool(bool value)
-            {
-                this.Value = value;
-            }
-
-        }
-
-        /// <summary>
-        /// A very simple primitive that allows us to share a value across multiple threads.
-        /// </summary>
-        private class SharedLong
-        {
-            internal long Value;
-            internal SharedLong(long value)
-            {
-                this.Value = value;
-            }
-
-        }
-
-        //--------------------
-        // The following part calculates the default chunk size. It is copied from System.Linq.Parallel.Scheduling,
-        // because mscorlib.dll cannot access System.Linq.Parallel.Scheduling
-        //--------------------
-
-        // The number of bytes we want "chunks" to be, when partitioning, etc. We choose 4 cache
-        // lines worth, assuming 128b cache line.  Most (popular) architectures use 64b cache lines,
-        // but choosing 128b works for 64b too whereas a multiple of 64b isn't necessarily sufficient
-        // for 128b cache systems.  So 128b it is.
-        private const int DEFAULT_BYTES_PER_CHUNK = 128 * 4;
-        
-        private static int GetDefaultChunkSize<TSource>()
-        {
-            int chunkSize;
-
-            if (typeof(TSource).IsValueType)
-            {
-                chunkSize = 128;
-            }
-            else
-            {
-                Debug.Assert((DEFAULT_BYTES_PER_CHUNK % IntPtr.Size) == 0, "bytes per chunk should be a multiple of pointer size");
-                chunkSize = (DEFAULT_BYTES_PER_CHUNK / IntPtr.Size);
-            }
-            return chunkSize;
-        }
-        #endregion
-    }
-}
diff --git a/src/mscorlib/src/System/Collections/DictionaryEntry.cs b/src/mscorlib/src/System/Collections/DictionaryEntry.cs
index ac505c1e13..0c5d8b2387 100644
--- a/src/mscorlib/src/System/Collections/DictionaryEntry.cs
+++ b/src/mscorlib/src/System/Collections/DictionaryEntry.cs
@@ -19,7 +19,6 @@ namespace System.Collections {
     using System.ComponentModel;
     // A DictionaryEntry holds a key and a value from a dictionary.
     // It is returned by IDictionaryEnumerator::GetEntry().
-[System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public struct DictionaryEntry
     {
diff --git a/src/mscorlib/src/System/Collections/Generic/ArraySortHelper.cs b/src/mscorlib/src/System/Collections/Generic/ArraySortHelper.cs
index 298ac3e177..0f4a2b9b78 100644
--- a/src/mscorlib/src/System/Collections/Generic/ArraySortHelper.cs
+++ b/src/mscorlib/src/System/Collections/Generic/ArraySortHelper.cs
@@ -36,8 +36,6 @@ namespace System.Collections.Generic
         // Large value types may benefit from a smaller number.
         internal const int IntrosortSizeThreshold = 16;
 
-        internal const int QuickSortDepthThreshold = 32;
-
         internal static int FloorLog2(int n)
         {
             int result = 0;
diff --git a/src/mscorlib/src/System/Collections/Generic/Comparer.cs b/src/mscorlib/src/System/Collections/Generic/Comparer.cs
index 4f06b0af69..056843a606 100644
--- a/src/mscorlib/src/System/Collections/Generic/Comparer.cs
+++ b/src/mscorlib/src/System/Collections/Generic/Comparer.cs
@@ -265,9 +265,6 @@ namespace System.Collections.Generic
             Debug.Assert(typeof(T).IsEnum, "This type is only intended to be used to compare enums!");
         }
         
-        // Used by the serialization engine.
-        private Int64EnumComparer(SerializationInfo info, StreamingContext context) { }
-        
         public override int Compare(T x, T y)
         {
             long lx = JitHelpers.UnsafeEnumCastLong(x);
diff --git a/src/mscorlib/src/System/Collections/Generic/DebugView.cs b/src/mscorlib/src/System/Collections/Generic/DebugView.cs
index d0711e551e..27c5011147 100644
--- a/src/mscorlib/src/System/Collections/Generic/DebugView.cs
+++ b/src/mscorlib/src/System/Collections/Generic/DebugView.cs
@@ -16,7 +16,6 @@
 namespace System.Collections.Generic {
     using System;
     using System.Collections.ObjectModel;
-    using System.Security.Permissions;
     using System.Diagnostics;    
     using System.Diagnostics.Contracts;
 
diff --git a/src/mscorlib/src/System/Collections/Generic/Dictionary.cs b/src/mscorlib/src/System/Collections/Generic/Dictionary.cs
index c2b2da9ad2..7b60e31031 100644
--- a/src/mscorlib/src/System/Collections/Generic/Dictionary.cs
+++ b/src/mscorlib/src/System/Collections/Generic/Dictionary.cs
@@ -48,12 +48,10 @@ namespace System.Collections.Generic {
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
 
     [DebuggerTypeProxy(typeof(Mscorlib_DictionaryDebugView<,>))]
     [DebuggerDisplay("Count = {Count}")]
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(false)]
     public class Dictionary<TKey,TValue>: IDictionary<TKey,TValue>, IDictionary, IReadOnlyDictionary<TKey, TValue>, ISerializable, IDeserializationCallback  {
     
         private struct Entry {
diff --git a/src/mscorlib/src/System/Collections/Generic/EqualityComparer.cs b/src/mscorlib/src/System/Collections/Generic/EqualityComparer.cs
index df39b59a29..0f9259d2f3 100644
--- a/src/mscorlib/src/System/Collections/Generic/EqualityComparer.cs
+++ b/src/mscorlib/src/System/Collections/Generic/EqualityComparer.cs
@@ -488,122 +488,4 @@ namespace System.Collections.Generic
             return -1;
         }
     }
-
-#if FEATURE_RANDOMIZED_STRING_HASHING
-    // This type is not serializeable by design.  It does not exist in previous versions and will be removed 
-    // Once we move the framework to using secure hashing by default.
-    internal sealed class RandomizedStringEqualityComparer : IEqualityComparer<String>, IEqualityComparer, IWellKnownStringEqualityComparer
-    {
-        private long _entropy;
-
-        public RandomizedStringEqualityComparer() {
-            _entropy = HashHelpers.GetEntropy();
-        }
-
-        public new bool Equals(object x, object y) {
-            if (x == y) return true;
-            if (x == null || y == null) return false;
-            if ((x is string) && (y is string)) return Equals((string)x, (string)y);
-            ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidArgumentForComparison);
-            return false;
-        }
-
-        [Pure]
-        public bool Equals(string x, string y) {
-            if (x != null) {
-                if (y != null) return x.Equals(y);
-                return false;
-            }
-            if (y != null) return false;
-            return true;
-        }
-
-        [Pure]
-        public int GetHashCode(String obj) {
-            if(obj == null) return 0;
-            return String.InternalMarvin32HashString(obj, obj.Length, _entropy);
-        }
-
-        [Pure]
-        public int GetHashCode(Object obj) {
-            if(obj == null) return 0;
-
-            string sObj = obj as string;
-            if(sObj != null) return  String.InternalMarvin32HashString(sObj, sObj.Length, _entropy);
-
-            return obj.GetHashCode(); 
-        }
-
-        // Equals method for the comparer itself. 
-        public override bool Equals(Object obj) {
-            RandomizedStringEqualityComparer comparer = obj as RandomizedStringEqualityComparer; 
-            return (comparer != null) && (this._entropy == comparer._entropy);
-        }
-
-        public override int GetHashCode() {
-            return (this.GetType().GetHashCode() ^ ((int) (_entropy & 0x7FFFFFFF))); 
-        }
-
-
-        IEqualityComparer IWellKnownStringEqualityComparer.GetRandomizedEqualityComparer() {
-            return new RandomizedStringEqualityComparer();
-        }
-
-        // We want to serialize the old comparer.
-        IEqualityComparer IWellKnownStringEqualityComparer.GetEqualityComparerForSerialization() {
-            return EqualityComparer<string>.Default;
-        } 
-    }
-
-    // This type is not serializeable by design.  It does not exist in previous versions and will be removed 
-    // Once we move the framework to using secure hashing by default.
-    internal sealed class RandomizedObjectEqualityComparer : IEqualityComparer, IWellKnownStringEqualityComparer
-    {
-        private long _entropy;
-
-        public RandomizedObjectEqualityComparer() {
-            _entropy = HashHelpers.GetEntropy();
-        }
-
-        [Pure]
-        public new bool Equals(Object x, Object y) {
-            if (x != null) {
-                if (y != null) return x.Equals(y);
-                return false;
-            }
-            if (y != null) return false;
-            return true;
-        }
-
-        [Pure]
-        public int GetHashCode(Object obj) {
-            if(obj == null) return 0;
-
-            string sObj = obj as string;
-            if(sObj != null) return  String.InternalMarvin32HashString(sObj, sObj.Length, _entropy);
-
-            return obj.GetHashCode();           
-        }
-
-        // Equals method for the comparer itself. 
-        public override bool Equals(Object obj){
-            RandomizedObjectEqualityComparer comparer = obj as RandomizedObjectEqualityComparer; 
-            return (comparer != null) && (this._entropy == comparer._entropy);
-        }
-
-        public override int GetHashCode() {
-            return (this.GetType().GetHashCode() ^ ((int) (_entropy & 0x7FFFFFFF))); 
-        }
-
-        IEqualityComparer IWellKnownStringEqualityComparer.GetRandomizedEqualityComparer() {
-            return new RandomizedObjectEqualityComparer();
-        }
-
-        // We want to serialize the old comparer, which in this case was null.
-        IEqualityComparer IWellKnownStringEqualityComparer.GetEqualityComparerForSerialization() {
-            return null;
-        }   
-    }
-#endif
 }
-
diff --git a/src/mscorlib/src/System/Collections/Generic/KeyNotFoundException.cs b/src/mscorlib/src/System/Collections/Generic/KeyNotFoundException.cs
index ffcd0405fd..1cd18cf808 100644
--- a/src/mscorlib/src/System/Collections/Generic/KeyNotFoundException.cs
+++ b/src/mscorlib/src/System/Collections/Generic/KeyNotFoundException.cs
@@ -20,7 +20,6 @@ namespace System.Collections.Generic {
     using System.Runtime.Serialization;
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class KeyNotFoundException  : SystemException, ISerializable {
     
         public KeyNotFoundException () 
diff --git a/src/mscorlib/src/System/Collections/Generic/List.cs b/src/mscorlib/src/System/Collections/Generic/List.cs
index 3e2947f5f9..82f6e41c36 100644
--- a/src/mscorlib/src/System/Collections/Generic/List.cs
+++ b/src/mscorlib/src/System/Collections/Generic/List.cs
@@ -12,16 +12,15 @@
 **
 ** 
 ===========================================================*/
-namespace System.Collections.Generic {
 
-    using System;
-    using System.Runtime;
-    using System.Runtime.Versioning;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-    using System.Collections.ObjectModel;
-    using System.Security.Permissions;
+using System;
+using System.Diagnostics;
+using System.Diagnostics.Contracts;
+using System.Collections.ObjectModel;
+using System.Runtime.CompilerServices;
 
+namespace System.Collections.Generic
+{
     // Implements a variable-size List that uses an array of objects to store the
     // elements. A List has a capacity, which is the allocated length
     // of the internal array. As elements are added to a List, the capacity
@@ -292,13 +291,23 @@ namespace System.Collections.Generic {
 
     
         // Clears the contents of List.
-        public void Clear() {
-            if (_size > 0)
+        public void Clear()
+        {
+            if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
             {
-                Array.Clear(_items, 0, _size); // Don't need to doc this but we clear the elements so that the gc can reclaim the references.
+                int size = _size;
                 _size = 0;
+                _version++;
+                if (size > 0)
+                {
+                    Array.Clear(_items, 0, size); // Clear the elements so that the gc can reclaim the references.
+                }
+            }
+            else
+            {
+                _size = 0;
+                _version++;
             }
-            _version++;
         }
     
         // Contains returns true if the specified element is in the List.
@@ -853,9 +862,13 @@ namespace System.Collections.Generic {
                     // copy item to the free slot.
                     _items[freeIndex++] = _items[current++];
                 }
-            }                       
-            
-            Array.Clear(_items, freeIndex, _size - freeIndex);
+            }
+
+            if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
+            {
+                Array.Clear(_items, freeIndex, _size - freeIndex); // Clear the elements so that the gc can reclaim the references.
+            }
+
             int result = _size - freeIndex;
             _size = freeIndex;
             _version++;
@@ -871,10 +884,14 @@ namespace System.Collections.Generic {
             }
             Contract.EndContractBlock();
             _size--;
-            if (index < _size) {
+            if (index < _size)
+            {
                 Array.Copy(_items, index + 1, _items, index, _size - index);
             }
-            _items[_size] = default(T);
+            if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
+            {
+                _items[_size] = default(T);
+            }
             _version++;
         }
     
@@ -899,8 +916,12 @@ namespace System.Collections.Generic {
                 if (index < _size) {
                     Array.Copy(_items, index + count, _items, index, _size - index);
                 }
-                Array.Clear(_items, _size, count);
+
                 _version++;
+                if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
+                {
+                    Array.Clear(_items, _size, count);
+                }
             }
         }
     
@@ -927,7 +948,9 @@ namespace System.Collections.Generic {
                 ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
             Contract.EndContractBlock();
 
-            Array.Reverse(_items, index, count);
+            if (count > 1) {
+                Array.Reverse(_items, index, count);
+            }
             _version++;
         }
         
@@ -966,7 +989,9 @@ namespace System.Collections.Generic {
                 ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
             Contract.EndContractBlock();
 
-            Array.Sort<T>(_items, index, count, comparer);
+            if (count > 1) {
+                Array.Sort<T>(_items, index, count, comparer);
+            }
             _version++;
         }
 
@@ -976,9 +1001,10 @@ namespace System.Collections.Generic {
             }
             Contract.EndContractBlock();
 
-            if( _size > 0) {
+            if (_size > 1) {
                 ArraySortHelper<T>.Sort(_items, 0, _size, comparison);
             }
+            _version++;
         }
 
         // ToArray returns an array containing the contents of the List.
diff --git a/src/mscorlib/src/System/Collections/Hashtable.cs b/src/mscorlib/src/System/Collections/Hashtable.cs
index d4c7d8d673..d1831dd97d 100644
--- a/src/mscorlib/src/System/Collections/Hashtable.cs
+++ b/src/mscorlib/src/System/Collections/Hashtable.cs
@@ -17,7 +17,6 @@ namespace System.Collections {
     using System;
     using System.Runtime;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     using System.Diagnostics;
     using System.Threading; 
     using System.Runtime.CompilerServices;
@@ -66,9 +65,8 @@ namespace System.Collections {
     // 
     [DebuggerTypeProxy(typeof(System.Collections.Hashtable.HashtableDebugView))]
     [DebuggerDisplay("Count = {Count}")]
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
-    public class Hashtable : IDictionary, ISerializable, IDeserializationCallback, ICloneable {
+    internal class Hashtable : IDictionary, ISerializable, IDeserializationCallback, ICloneable {
         /*
           Implementation Notes:
           The generic Dictionary was copied from Hashtable's source - any bug 
@@ -165,75 +163,6 @@ namespace System.Collections {
         private IEqualityComparer _keycomparer;
         private Object _syncRoot;
 
-        [Obsolete("Please use EqualityComparer property.")]
-        protected IHashCodeProvider hcp
-        {
-            get
-            {
-                if( _keycomparer is CompatibleComparer) {
-                    return ((CompatibleComparer)_keycomparer).HashCodeProvider;
-                }                
-                else if( _keycomparer == null) {
-                    return null;
-                }
-                else {
-                    throw new ArgumentException(Environment.GetResourceString("Arg_CannotMixComparisonInfrastructure"));
-                }                
-            }
-            set
-            {
-                if (_keycomparer is CompatibleComparer) {
-                    CompatibleComparer keyComparer = (CompatibleComparer)_keycomparer;
-                    _keycomparer = new CompatibleComparer(keyComparer.Comparer, value);
-                }
-                else if( _keycomparer == null) {
-                    _keycomparer = new CompatibleComparer((IComparer)null, value);               
-                }
-                else {
-                    throw new ArgumentException(Environment.GetResourceString("Arg_CannotMixComparisonInfrastructure"));
-                }
-            }
-        }
-
-
-        [Obsolete("Please use KeyComparer properties.")]        
-        protected IComparer comparer
-        {
-            get
-            {
-                if( _keycomparer is CompatibleComparer) {
-                    return ((CompatibleComparer)_keycomparer).Comparer;
-                }    
-                else if( _keycomparer == null) {
-                    return null;
-                }                            
-                else {
-                    throw new ArgumentException(Environment.GetResourceString("Arg_CannotMixComparisonInfrastructure"));
-                }                
-            }
-            set
-            {
-                if (_keycomparer is CompatibleComparer) {
-                    CompatibleComparer keyComparer = (CompatibleComparer)_keycomparer;
-                    _keycomparer = new CompatibleComparer(value, keyComparer.HashCodeProvider);
-                }
-                else if( _keycomparer == null) {
-                    _keycomparer = new CompatibleComparer(value, (IHashCodeProvider)null);               
-                }                
-                else {
-                    throw new ArgumentException(Environment.GetResourceString("Arg_CannotMixComparisonInfrastructure"));
-                }
-            }
-        }
-
-        protected IEqualityComparer EqualityComparer
-        {
-            get
-            {
-                return _keycomparer;
-            }
-        }
-
         // Note: this constructor is a bogus constructor that does nothing
         // and is for use only with SyncHashtable.
         internal Hashtable( bool trash )
@@ -290,126 +219,31 @@ namespace System.Collections {
             Debug.Assert( loadsize < hashsize, "Invalid hashtable loadsize!");
         }
     
-        // Constructs a new hashtable with the given initial capacity and load
-        // factor. The capacity argument serves as an indication of the
-        // number of entries the hashtable will contain. When this number (or an
-        // approximation) is known, specifying it in the constructor can eliminate
-        // a number of resizing operations that would otherwise be performed when
-        // elements are added to the hashtable. The loadFactor argument
-        // indicates the maximum ratio of hashtable entries to hashtable buckets.
-        // Smaller load factors cause faster average lookup times at the cost of
-        // increased memory consumption. A load factor of 1.0 generally provides
-        // the best balance between speed and size.  The hcp argument
-        // is used to specify an Object that will provide hash codes for all
-        // the Objects in the table.  Using this, you can in effect override
-        // GetHashCode() on each Object using your own hash function.  The 
-        // comparer argument will let you specify a custom function for
-        // comparing keys.  By specifying user-defined objects for hcp
-        // and comparer, users could make a hash table using strings
-        // as keys do case-insensitive lookups.
-        // 
-        [Obsolete("Please use Hashtable(int, float, IEqualityComparer) instead.")]
-        public Hashtable(int capacity, float loadFactor, IHashCodeProvider hcp, IComparer comparer) : this(capacity, loadFactor) {
-            if (hcp == null && comparer == null) {
-                this._keycomparer = null;
-            }
-            else {
-                this._keycomparer = new CompatibleComparer(comparer,hcp);
-            }
-        }
-    
         public Hashtable(int capacity, float loadFactor, IEqualityComparer equalityComparer) : this(capacity, loadFactor) {
             this._keycomparer = equalityComparer;
         }
-            
-        // Constructs a new hashtable using a custom hash function
-        // and a custom comparison function for keys.  This will enable scenarios
-        // such as doing lookups with case-insensitive strings.
-        // 
-        [Obsolete("Please use Hashtable(IEqualityComparer) instead.")]        
-        public Hashtable(IHashCodeProvider hcp, IComparer comparer) : this(0, 1.0f, hcp, comparer) {
-        }
 
         public Hashtable(IEqualityComparer equalityComparer) : this(0, 1.0f, equalityComparer) {
         }
-        
-        // Constructs a new hashtable using a custom hash function
-        // and a custom comparison function for keys.  This will enable scenarios
-        // such as doing lookups with case-insensitive strings.
-        // 
-        [Obsolete("Please use Hashtable(int, IEqualityComparer) instead.")]        
-        public Hashtable(int capacity, IHashCodeProvider hcp, IComparer comparer)   
-            : this(capacity, 1.0f, hcp, comparer) {
-        }
     
         public Hashtable(int capacity, IEqualityComparer equalityComparer)    
             : this(capacity, 1.0f, equalityComparer) {
         }
-    
-        // Constructs a new hashtable containing a copy of the entries in the given
-        // dictionary. The hashtable is created with a load factor of 1.0.
-        // 
-        public Hashtable(IDictionary d) : this(d, 1.0f) {
-        }
-        
-        // Constructs a new hashtable containing a copy of the entries in the given
-        // dictionary. The hashtable is created with the given load factor.
-        // 
-        public Hashtable(IDictionary d, float loadFactor) 
-            : this(d, loadFactor, (IEqualityComparer)null) {
-        }
-
-        [Obsolete("Please use Hashtable(IDictionary, IEqualityComparer) instead.")]
-        public Hashtable(IDictionary d, IHashCodeProvider hcp, IComparer comparer) 
-            : this(d, 1.0f, hcp, comparer)  {
-        }
-
-        public Hashtable(IDictionary d, IEqualityComparer equalityComparer) 
-            : this(d, 1.0f, equalityComparer)    {
-        }
 
-        [Obsolete("Please use Hashtable(IDictionary, float, IEqualityComparer) instead.")]
-        public Hashtable(IDictionary d, float loadFactor, IHashCodeProvider hcp, IComparer comparer) 
-            : this((d != null ? d.Count : 0), loadFactor, hcp, comparer) {
-            if (d==null)
-                throw new ArgumentNullException(nameof(d), Environment.GetResourceString("ArgumentNull_Dictionary"));
-            Contract.EndContractBlock();
- 
-            IDictionaryEnumerator e = d.GetEnumerator();
-            while (e.MoveNext()) Add(e.Key, e.Value);
-        }
-        
-        public Hashtable(IDictionary d, float loadFactor, IEqualityComparer equalityComparer) 
-            : this((d != null ? d.Count : 0), loadFactor, equalityComparer) {
-            if (d==null)
-                throw new ArgumentNullException(nameof(d), Environment.GetResourceString("ArgumentNull_Dictionary"));
-            Contract.EndContractBlock();
-            
-            IDictionaryEnumerator e = d.GetEnumerator();
-            while (e.MoveNext()) Add(e.Key, e.Value);
-        }        
-        
-        protected Hashtable(SerializationInfo info, StreamingContext context) {
-            //We can't do anything with the keys and values until the entire graph has been deserialized
-            //and we have a reasonable estimate that GetHashCode is not going to fail.  For the time being,
-            //we'll just cache this.  The graph is not valid until OnDeserialization has been called.
-            HashHelpers.SerializationInfoTable.Add(this, info);
-        }
-
-        // ‘InitHash’ is basically an implementation of classic DoubleHashing (see http://en.wikipedia.org/wiki/Double_hashing)  
+        // InitHash is basically an implementation of classic DoubleHashing (see http://en.wikipedia.org/wiki/Double_hashing)  
         //
-        // 1) The only ‘correctness’ requirement is that the ‘increment’ used to probe 
+        // 1) The only correctness requirement is that the increment used to probe 
         //    a. Be non-zero
-        //    b. Be relatively prime to the table size ‘hashSize’. (This is needed to insure you probe all entries in the table before you ‘wrap’ and visit entries already probed)
+        //    b. Be relatively prime to the table size hashSize. (This is needed to insure you probe all entries in the table before you wrap and visit entries already probed)
         // 2) Because we choose table sizes to be primes, we just need to insure that the increment is 0 < incr < hashSize
         //
         // Thus this function would work: Incr = 1 + (seed % (hashSize-1))
         // 
-        // While this works well for ‘uniformly distributed’ keys, in practice, non-uniformity is common. 
-        // In particular in practice we can see ‘mostly sequential’ where you get long clusters of keys that ‘pack’. 
-        // To avoid bad behavior you want it to be the case that the increment is ‘large’ even for ‘small’ values (because small 
-        // values tend to happen more in practice). Thus we multiply ‘seed’ by a number that will make these small values
-        // bigger (and not hurt large values). We picked HashPrime (101) because it was prime, and if ‘hashSize-1’ is not a multiple of HashPrime
+        // While this works well for uniformly distributed keys, in practice, non-uniformity is common.   
+        // In particular in practice we can see mostly sequential where you get long clusters of keys that pack. 
+        // To avoid bad behavior you want it to be the case that the increment is large even for small values (because small 
+        // values tend to happen more in practice). Thus we multiply seed by a number that will make these small values
+        // bigger (and not hurt large values). We picked HashPrime (101) because it was prime, and if hashSize-1 is not a multiple of HashPrime
         // (enforced in GetPrime), then incr has the potential of being every value from 1 to hashSize-1. The choice was largely arbitrary.
         // 
         // Computes the hash function:  H(key, i) = h1(key) + i*h2(key, hashSize).
@@ -439,7 +273,6 @@ namespace System.Collections {
         }
 
         // Removes all entries from this hashtable.
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public virtual void Clear() {
             Debug.Assert(!isWriterInProgress, "Race condition detected in usages of Hashtable - multiple threads appear to be writing to a Hashtable instance simultaneously!  Don't do that - use Hashtable.Synchronized.");
 
@@ -517,29 +350,6 @@ namespace System.Collections {
             } while (b.hash_coll < 0 && ++ntry < lbuckets.Length);
             return false;
         }
-
-        // Checks if this hashtable contains an entry with the given value. The
-        // values of the entries of the hashtable are compared to the given value
-        // using the Object.Equals method. This method performs a linear
-        // search and is thus be substantially slower than the ContainsKey
-        // method.
-        // 
-        public virtual bool ContainsValue(Object value) {
-
-            if (value == null) {
-                for (int i = buckets.Length; --i >= 0;) {
-                    if (buckets[i].key != null && buckets[i].key != buckets && buckets[i].val == null)
-                        return true;
-                }
-            }
-            else {
-                for (int i = buckets.Length; --i >= 0;) {
-                  Object val = buckets[i].val;
-                  if (val!=null && val.Equals(value)) return true;
-                }
-            }
-            return false;
-        }
     
         // Copies the keys of this hashtable to a given array starting at a given
         // index. This method is used by the implementation of the CopyTo method in
@@ -590,25 +400,6 @@ namespace System.Collections {
             CopyEntries(array, arrayIndex);
         }
 
-        // Copies the values in this Hashtable to an KeyValuePairs array.
-        // KeyValuePairs is different from Dictionary Entry in that it has special
-        // debugger attributes on its fields.
-        
-        internal virtual KeyValuePairs[] ToKeyValuePairsArray() {
-
-            KeyValuePairs[] array = new KeyValuePairs[count];           
-            int index = 0;            
-            bucket[] lbuckets = buckets;
-            for (int i = lbuckets.Length; --i >= 0;) {
-                Object keyv = lbuckets[i].key;
-                if ((keyv != null) && (keyv != buckets)){
-                    array[index++] = new KeyValuePairs(keyv,lbuckets[i].val);
-                }
-            }
-            
-            return array;
-        }
-
 
         // Copies the values of this hashtable to a given array starting at a given
         // index. This method is used by the implementation of the CopyTo method in
@@ -720,7 +511,6 @@ namespace System.Collections {
             version++;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         private void rehash( int newsize, bool forceNewHashCode ) {
 
             // reset occupancy
@@ -853,7 +643,6 @@ namespace System.Collections {
         // Inserts an entry into this hashtable. This method is called from the Set
         // and Add methods. If the add parameter is true and the given key already
         // exists in the hashtable, an exception is thrown.
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         private void Insert (Object key, Object nvalue, bool add) {
             if (key == null) {
                 throw new ArgumentNullException(nameof(key), Environment.GetResourceString("ArgumentNull_Key"));
@@ -987,7 +776,6 @@ namespace System.Collections {
         // key exists in the hashtable, it is removed. An ArgumentException is
         // thrown if the key is null.
         // 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public virtual void Remove(Object key) {
             if (key == null) {
                 throw new ArgumentNullException(nameof(key), Environment.GetResourceString("ArgumentNull_Key"));
@@ -1293,13 +1081,6 @@ namespace System.Collections {
             internal SyncHashtable(Hashtable table) : base(false) {
                 _table = table;
             }
-
-            internal SyncHashtable(SerializationInfo info, StreamingContext context) : base (info, context) {
-                _table = (Hashtable)info.GetValue("ParentTable", typeof(Hashtable));
-                if (_table==null) {
-                    throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientState"));
-                }
-            }
     
 
             /*================================GetObjectData=================================
@@ -1379,12 +1160,6 @@ namespace System.Collections {
                 return _table.ContainsKey(key);
             }
     
-            public override bool ContainsValue(Object key) {
-                lock(_table.SyncRoot) {                
-                    return _table.ContainsValue(key);
-                }
-            }
-    
             public override void CopyTo(Array array, int arrayIndex) {
                 lock (_table.SyncRoot) {
                     _table.CopyTo(array, arrayIndex);
@@ -1438,10 +1213,6 @@ namespace System.Collections {
             public override void OnDeserialization(Object sender) {
                 return;
             }
-
-            internal override KeyValuePairs[] ToKeyValuePairsArray() {
-                return _table.ToKeyValuePairsArray();
-            }
             
         }
     
@@ -1539,23 +1310,6 @@ namespace System.Collections {
         // internal debug view class for hashtable
         internal class HashtableDebugView {
             private Hashtable hashtable; 
-        
-            public HashtableDebugView( Hashtable hashtable) {
-                if( hashtable == null) {
-                    throw new ArgumentNullException(nameof(hashtable));
-                }
-                Contract.EndContractBlock();
-
-                this.hashtable = hashtable;
-            }
-
-
-            [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
-            public KeyValuePairs[] Items { 
-                get {
-                    return hashtable.ToKeyValuePairsArray();               
-                }
-            }
         }        
     }
 
@@ -1605,7 +1359,6 @@ namespace System.Collections {
 
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static bool IsPrime(int candidate) 
         {
             if ((candidate & 1) != 0) 
@@ -1621,7 +1374,6 @@ namespace System.Collections {
             return (candidate == 2);
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static int GetPrime(int min) 
         {
             if (min < 0)
@@ -1644,11 +1396,6 @@ namespace System.Collections {
             return min;
         }
 
-        public static int GetMinPrime() 
-        {
-            return primes[0];
-        }
-
         // Returns size of hashtable to grow to.
         public static int ExpandPrime(int oldSize)
         {
@@ -1670,33 +1417,6 @@ namespace System.Collections {
         public const int MaxPrimeArrayLength = 0x7FEFFFFD;
 
 #if FEATURE_RANDOMIZED_STRING_HASHING
-        public static bool IsWellKnownEqualityComparer(object comparer)
-        {
-            return (comparer == null || comparer == System.Collections.Generic.EqualityComparer<string>.Default || comparer is IWellKnownStringEqualityComparer); 
-        }
-
-        public static IEqualityComparer GetRandomizedEqualityComparer(object comparer)
-        {
-            Debug.Assert(comparer == null || comparer == System.Collections.Generic.EqualityComparer<string>.Default || comparer is IWellKnownStringEqualityComparer); 
-
-            if(comparer == null) {
-                return new System.Collections.Generic.RandomizedObjectEqualityComparer();
-            } 
-
-            if(comparer == System.Collections.Generic.EqualityComparer<string>.Default) {
-                return new System.Collections.Generic.RandomizedStringEqualityComparer();
-            }
-
-            IWellKnownStringEqualityComparer cmp = comparer as IWellKnownStringEqualityComparer;
-
-            if(cmp != null) {
-                return cmp.GetRandomizedEqualityComparer();
-            }
-
-            Debug.Assert(false, "Missing case in GetRandomizedEqualityComparer!");
-
-            return null;
-        }
 
         public static object GetEqualityComparerForSerialization(object comparer)
         {
@@ -1716,33 +1436,8 @@ namespace System.Collections {
         }
 
         private const int bufferSize = 1024;
-        private static byte[] data;
         private static int currentIndex = bufferSize;
         private static readonly object lockObj = new Object();
-
-        internal static long GetEntropy() 
-        {
-            lock(lockObj) {
-                long ret;
-
-                if(currentIndex == bufferSize) 
-                {
-                    if(data == null)
-                    {
-                        data = new byte[bufferSize];
-                        Debug.Assert(bufferSize % 8 == 0, "We increment our current index by 8, so our buffer size must be a multiple of 8");
-                    }
-
-                    Microsoft.Win32.Win32Native.Random(true, data, data.Length);
-                    currentIndex = 0;
-                }
-
-                ret = BitConverter.ToInt64(data, currentIndex);
-                currentIndex += 8;
-
-                return ret;
-            }
-        }
 #endif // FEATURE_RANDOMIZED_STRING_HASHING
     }
 }
diff --git a/src/mscorlib/src/System/Collections/ICollection.cs b/src/mscorlib/src/System/Collections/ICollection.cs
index 6d4d6e1a93..088928a0ef 100644
--- a/src/mscorlib/src/System/Collections/ICollection.cs
+++ b/src/mscorlib/src/System/Collections/ICollection.cs
@@ -19,7 +19,6 @@ namespace System.Collections {
 
     // Base interface for all collections, defining enumerators, size, and 
     // synchronization methods.
-    [System.Runtime.InteropServices.ComVisible(true)]
     public interface ICollection : IEnumerable
     {
         // Interfaces are not serialable
diff --git a/src/mscorlib/src/System/Collections/IComparer.cs b/src/mscorlib/src/System/Collections/IComparer.cs
index d5a3448934..574af1a768 100644
--- a/src/mscorlib/src/System/Collections/IComparer.cs
+++ b/src/mscorlib/src/System/Collections/IComparer.cs
@@ -21,7 +21,6 @@ namespace System.Collections {
     // the Array and List classes.
     // 
     // Interfaces are not serializable
-    [System.Runtime.InteropServices.ComVisible(true)]
     public interface IComparer {
         // Compares two objects. An implementation of this method must return a
         // value less than zero if x is less than y, zero if x is equal to y, or a
diff --git a/src/mscorlib/src/System/Collections/IDictionary.cs b/src/mscorlib/src/System/Collections/IDictionary.cs
index 4da89d6983..519d53ed55 100644
--- a/src/mscorlib/src/System/Collections/IDictionary.cs
+++ b/src/mscorlib/src/System/Collections/IDictionary.cs
@@ -21,7 +21,6 @@ namespace System.Collections {
     // Keys can be any non-null object.  Values can be any object.
     // You can look up a value in an IDictionary via the default indexed
     // property, Items.
-    [System.Runtime.InteropServices.ComVisible(true)]
     public interface IDictionary : ICollection
     {
         // Interfaces are not serializable
diff --git a/src/mscorlib/src/System/Collections/IDictionaryEnumerator.cs b/src/mscorlib/src/System/Collections/IDictionaryEnumerator.cs
index b995a04a0e..2f1add682c 100644
--- a/src/mscorlib/src/System/Collections/IDictionaryEnumerator.cs
+++ b/src/mscorlib/src/System/Collections/IDictionaryEnumerator.cs
@@ -44,7 +44,6 @@ namespace System.Collections {
     // return the same DictionaryEntry and avoids boxing the DictionaryEntry (boxing
     // is somewhat expensive).
     // 
-[System.Runtime.InteropServices.ComVisible(true)]
     public interface IDictionaryEnumerator : IEnumerator
     {
         // Returns the key of the current element of the enumeration. The returned
diff --git a/src/mscorlib/src/System/Collections/IEnumerable.cs b/src/mscorlib/src/System/Collections/IEnumerable.cs
index 5fa63f15d0..1d8e71cf07 100644
--- a/src/mscorlib/src/System/Collections/IEnumerable.cs
+++ b/src/mscorlib/src/System/Collections/IEnumerable.cs
@@ -21,7 +21,6 @@ namespace System.Collections {
     // Implement this interface if you need to support VB's foreach semantics.
     // Also, COM classes that support an enumerator will also implement this interface.
     [Guid("496B0ABE-CDEE-11d3-88E8-00902754C43A")]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public interface IEnumerable
     {
         // Interfaces are not serializable
diff --git a/src/mscorlib/src/System/Collections/IEnumerator.cs b/src/mscorlib/src/System/Collections/IEnumerator.cs
index 99509d15ea..4c4fc085e8 100644
--- a/src/mscorlib/src/System/Collections/IEnumerator.cs
+++ b/src/mscorlib/src/System/Collections/IEnumerator.cs
@@ -20,7 +20,6 @@ namespace System.Collections {
     // Base interface for all enumerators, providing a simple approach
     // to iterating over a collection.
     [Guid("496B0ABF-CDEE-11d3-88E8-00902754C43A")]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public interface IEnumerator
     {
         // Interfaces are not serializable
diff --git a/src/mscorlib/src/System/Collections/IEqualityComparer.cs b/src/mscorlib/src/System/Collections/IEqualityComparer.cs
index 50c732f47c..f591b11152 100644
--- a/src/mscorlib/src/System/Collections/IEqualityComparer.cs
+++ b/src/mscorlib/src/System/Collections/IEqualityComparer.cs
@@ -19,7 +19,6 @@ namespace System.Collections {
     using System;
     // An IEqualityComparer is a mechanism to consume custom performant comparison infrastructure
     // that can be consumed by some of the common collections.
-    [System.Runtime.InteropServices.ComVisible(true)]
     public interface IEqualityComparer {
         bool Equals(Object x, Object y);
         int GetHashCode(Object obj);        
diff --git a/src/mscorlib/src/System/Collections/IHashCodeProvider.cs b/src/mscorlib/src/System/Collections/IHashCodeProvider.cs
index aefa15e1e5..0ae1e3295b 100644
--- a/src/mscorlib/src/System/Collections/IHashCodeProvider.cs
+++ b/src/mscorlib/src/System/Collections/IHashCodeProvider.cs
@@ -19,8 +19,7 @@ namespace System.Collections {
     // Provides a mechanism for a hash table user to override the default
     // GetHashCode() function on Objects, providing their own hash function.
     [Obsolete("Please use IEqualityComparer instead.")]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface IHashCodeProvider 
+    internal interface IHashCodeProvider 
     {
         // Interfaces are not serializable
         // Returns a hash code for the given object.  
diff --git a/src/mscorlib/src/System/Collections/IList.cs b/src/mscorlib/src/System/Collections/IList.cs
index 8bdfe4c1d0..8b63400852 100644
--- a/src/mscorlib/src/System/Collections/IList.cs
+++ b/src/mscorlib/src/System/Collections/IList.cs
@@ -21,7 +21,6 @@ namespace System.Collections {
     // An IList is an ordered collection of objects.  The exact ordering
     // is up to the implementation of the list, ranging from a sorted
     // order to insertion order.
-    [System.Runtime.InteropServices.ComVisible(true)]
     public interface IList : ICollection
     {
         // The Item property provides methods to read and edit entries in the List.
diff --git a/src/mscorlib/src/System/Collections/KeyValuePairs.cs b/src/mscorlib/src/System/Collections/KeyValuePairs.cs
deleted file mode 100644
index 22bf92c456..0000000000
--- a/src/mscorlib/src/System/Collections/KeyValuePairs.cs
+++ /dev/null
@@ -1,40 +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: KeyValuePairs to display items in collection class under debugger
-**
-**
-===========================================================*/
-
-namespace System.Collections {
-    using System.Diagnostics;
-    
-    [DebuggerDisplay("{value}", Name = "[{key}]", Type = "" )]
-    internal class KeyValuePairs {
-        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
-        private object key;
-
-        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
-        private object value;
-
-        public KeyValuePairs(object key, object value) {
-            this.value = value;
-            this.key = key;
-        }
-
-        public object Key {
-            get { return key; }
-        }
-
-        public object Value {
-            get { return value; }
-        }
-    }    
-}
diff --git a/src/mscorlib/src/System/Collections/ObjectModel/Collection.cs b/src/mscorlib/src/System/Collections/ObjectModel/Collection.cs
index a3804ad7ab..b3b19fb616 100644
--- a/src/mscorlib/src/System/Collections/ObjectModel/Collection.cs
+++ b/src/mscorlib/src/System/Collections/ObjectModel/Collection.cs
@@ -13,7 +13,6 @@ namespace System.Collections.ObjectModel
     using System.Runtime;
     
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(false)]
     [DebuggerTypeProxy(typeof(Mscorlib_CollectionDebugView<>))]
     [DebuggerDisplay("Count = {Count}")]    
     public class Collection<T>: IList<T>, IList, IReadOnlyList<T>
diff --git a/src/mscorlib/src/System/Collections/ObjectModel/KeyedCollection.cs b/src/mscorlib/src/System/Collections/ObjectModel/KeyedCollection.cs
index b6fe6ded29..3fe7716203 100644
--- a/src/mscorlib/src/System/Collections/ObjectModel/KeyedCollection.cs
+++ b/src/mscorlib/src/System/Collections/ObjectModel/KeyedCollection.cs
@@ -12,7 +12,6 @@ namespace System.Collections.ObjectModel
     using System.Diagnostics.Contracts;
        
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(false)]
     [DebuggerTypeProxy(typeof(Mscorlib_KeyedCollectionDebugView<,>))]
     [DebuggerDisplay("Count = {Count}")]        
     public abstract class KeyedCollection<TKey,TItem>: Collection<TItem>
diff --git a/src/mscorlib/src/System/Collections/ObjectModel/ReadOnlyCollection.cs b/src/mscorlib/src/System/Collections/ObjectModel/ReadOnlyCollection.cs
index a0b8b3b459..10c48cf76d 100644
--- a/src/mscorlib/src/System/Collections/ObjectModel/ReadOnlyCollection.cs
+++ b/src/mscorlib/src/System/Collections/ObjectModel/ReadOnlyCollection.cs
@@ -13,7 +13,6 @@ namespace System.Collections.ObjectModel
     using System.Runtime;
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(false)]
     [DebuggerTypeProxy(typeof(Mscorlib_CollectionDebugView<>))]
     [DebuggerDisplay("Count = {Count}")]    
     public class ReadOnlyCollection<T>: IList<T>, IList, IReadOnlyList<T>
diff --git a/src/mscorlib/src/System/Collections/SortedList.cs b/src/mscorlib/src/System/Collections/SortedList.cs
deleted file mode 100644
index 4a480a2c37..0000000000
--- a/src/mscorlib/src/System/Collections/SortedList.cs
+++ /dev/null
@@ -1,1008 +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: A sorted dictionary.
-**
-** 
-===========================================================*/
-namespace System.Collections {
-    using System;
-    using System.Security.Permissions;
-    using System.Diagnostics;
-    using System.Diagnostics.CodeAnalysis;
-    using System.Diagnostics.Contracts;
-    using System.Globalization;
-
-    // The SortedList class implements a sorted list of keys and values. Entries in
-    // a sorted list are sorted by their keys and are accessible both by key and by
-    // index. The keys of a sorted list can be ordered either according to a
-    // specific IComparer implementation given when the sorted list is
-    // instantiated, or according to the IComparable implementation provided
-    // by the keys themselves. In either case, a sorted list does not allow entries
-    // with duplicate keys.
-    // 
-    // A sorted list internally maintains two arrays that store the keys and
-    // values of the entries. The capacity of a sorted list is the allocated
-    // length of these internal arrays. As elements are added to a sorted list, the
-    // capacity of the sorted list is automatically increased as required by
-    // reallocating the internal arrays.  The capacity is never automatically 
-    // decreased, but users can call either TrimToSize or 
-    // Capacity explicitly.
-    // 
-    // The GetKeyList and GetValueList methods of a sorted list
-    // provides access to the keys and values of the sorted list in the form of
-    // List implementations. The List objects returned by these
-    // methods are aliases for the underlying sorted list, so modifications
-    // made to those lists are directly reflected in the sorted list, and vice
-    // versa.
-    // 
-    // The SortedList class provides a convenient way to create a sorted
-    // copy of another dictionary, such as a Hashtable. For example:
-    // 
-    // Hashtable h = new Hashtable();
-    // h.Add(...);
-    // h.Add(...);
-    // ...
-    // SortedList s = new SortedList(h);
-    // 
-    // The last line above creates a sorted list that contains a copy of the keys
-    // and values stored in the hashtable. In this particular example, the keys
-    // will be ordered according to the IComparable interface, which they
-    // all must implement. To impose a different ordering, SortedList also
-    // has a constructor that allows a specific IComparer implementation to
-    // be specified.
-    // 
-    [DebuggerTypeProxy(typeof(System.Collections.SortedList.SortedListDebugView))]  
-    [DebuggerDisplay("Count = {Count}")]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    [Obsolete("Non-generic collections have been deprecated. Please use collections in System.Collections.Generic.")]
-    [Serializable]
-    public class SortedList : IDictionary, ICloneable
-    {
-        private Object[] keys;
-        private Object[] values;
-        private int _size;
-        private int version;
-        private IComparer comparer;
-        private KeyList keyList;
-        private ValueList valueList;
-        [NonSerialized]
-        private Object _syncRoot;
-    
-        private const int _defaultCapacity = 16;
-    
-        private static Object[] emptyArray = EmptyArray<Object>.Value; 
-
-        // Constructs a new sorted list. The sorted list is initially empty and has
-        // a capacity of zero. Upon adding the first element to the sorted list the
-        // capacity is increased to 16, and then increased in multiples of two as
-        // required. The elements of the sorted list are ordered according to the
-        // IComparable interface, which must be implemented by the keys of
-        // all entries added to the sorted list.
-        public SortedList() {
-            Init();
-        }
-        private void Init()
-        {
-            keys = emptyArray;
-            values = emptyArray;
-            _size = 0;
-            comparer = new Comparer(CultureInfo.CurrentCulture);
-        }
-    
-        // Constructs a new sorted list. The sorted list is initially empty and has
-        // a capacity of zero. Upon adding the first element to the sorted list the
-        // capacity is increased to 16, and then increased in multiples of two as
-        // required. The elements of the sorted list are ordered according to the
-        // IComparable interface, which must be implemented by the keys of
-        // all entries added to the sorted list.
-        //
-        public SortedList(int initialCapacity) {
-            if (initialCapacity < 0)
-                throw new ArgumentOutOfRangeException(nameof(initialCapacity), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            Contract.EndContractBlock();
-            keys = new Object[initialCapacity];
-            values = new Object[initialCapacity];
-            comparer = new Comparer(CultureInfo.CurrentCulture);            
-        }
-    
-        // Constructs a new sorted list with a given IComparer
-        // implementation. The sorted list is initially empty and has a capacity of
-        // zero. Upon adding the first element to the sorted list the capacity is
-        // increased to 16, and then increased in multiples of two as required. The
-        // elements of the sorted list are ordered according to the given
-        // IComparer implementation. If comparer is null, the
-        // elements are compared to each other using the IComparable
-        // interface, which in that case must be implemented by the keys of all
-        // entries added to the sorted list.
-        // 
-        public SortedList(IComparer comparer) 
-            : this() {
-            if (comparer != null) this.comparer = comparer;
-        }
-    
-        // Constructs a new sorted list with a given IComparer
-        // implementation and a given initial capacity. The sorted list is
-        // initially empty, but will have room for the given number of elements
-        // before any reallocations are required. The elements of the sorted list
-        // are ordered according to the given IComparer implementation. If
-        // comparer is null, the elements are compared to each other using
-        // the IComparable interface, which in that case must be implemented
-        // by the keys of all entries added to the sorted list.
-        // 
-        public SortedList(IComparer comparer, int capacity) 
-            : this(comparer) {
-            Capacity = capacity;
-        }
-    
-        // Constructs a new sorted list containing a copy of the entries in the
-        // given dictionary. The elements of the sorted list are ordered according
-        // to the IComparable interface, which must be implemented by the
-        // keys of all entries in the the given dictionary as well as keys
-        // subsequently added to the sorted list.
-        // 
-        public SortedList(IDictionary d) 
-            : this(d, null) {
-        }
-        
-        // Constructs a new sorted list containing a copy of the entries in the
-        // given dictionary. The elements of the sorted list are ordered according
-        // to the given IComparer implementation. If comparer is
-        // null, the elements are compared to each other using the
-        // IComparable interface, which in that case must be implemented
-        // by the keys of all entries in the the given dictionary as well as keys
-        // subsequently added to the sorted list.
-        // 
-        public SortedList(IDictionary d, IComparer comparer) 
-            : this(comparer, (d != null ? d.Count : 0)) {
-            if (d==null)
-                throw new ArgumentNullException(nameof(d), Environment.GetResourceString("ArgumentNull_Dictionary"));
-            Contract.EndContractBlock();
-            d.Keys.CopyTo(keys, 0);
-            d.Values.CopyTo(values, 0);
-            Array.Sort(keys, values, comparer);
-            _size = d.Count;
-        }
-        
-        // Adds an entry with the given key and value to this sorted list. An
-        // ArgumentException is thrown if the key is already present in the sorted list.
-        // 
-        public virtual void Add(Object key, Object value) {
-            if (key == null) throw new ArgumentNullException(nameof(key), Environment.GetResourceString("ArgumentNull_Key"));
-            Contract.EndContractBlock();
-            int i = Array.BinarySearch(keys, 0, _size, key, comparer);
-            if (i >= 0)
-                throw new ArgumentException(Environment.GetResourceString("Argument_AddingDuplicate__", GetKey(i), key));
-            Insert(~i, key, value);
-        }
-        
-        // Returns the capacity of this sorted list. The capacity of a sorted list
-        // represents the allocated length of the internal arrays used to store the
-        // keys and values of the list, and thus also indicates the maximum number
-        // of entries the list can contain before a reallocation of the internal
-        // arrays is required.
-        // 
-         public virtual int Capacity {
-            get {
-                return keys.Length;
-            }
-            set {
-                if (value < Count) {
-                    throw new ArgumentOutOfRangeException(nameof(value), Environment.GetResourceString("ArgumentOutOfRange_SmallCapacity"));
-                }
-                Contract.EndContractBlock();
-
-                if (value != keys.Length) {
-                    if (value > 0) {
-                        Object[] newKeys = new Object[value];
-                        Object[] newValues = new Object[value];
-                        if (_size > 0) {
-                            Array.Copy(keys, 0, newKeys, 0, _size);
-                            Array.Copy(values, 0, newValues, 0, _size);
-                        }
-                        keys = newKeys;
-                        values = newValues;
-                    }
-                    else {
-                        // size can only be zero here.
-                        Debug.Assert( _size == 0, "Size is not zero");
-                        keys = emptyArray;
-                        values = emptyArray;                      
-                    }
-                }
-            }
-        }
-            
-        // Returns the number of entries in this sorted list.
-        // 
-        public virtual int Count {
-            get {
-                return _size;
-            }
-        }
-    
-        // Returns a collection representing the keys of this sorted list. This
-        // method returns the same object as GetKeyList, but typed as an
-        // ICollection instead of an IList.
-        // 
-         public virtual ICollection Keys {
-            get {
-               return GetKeyList();
-            }
-        }
-    
-        // Returns a collection representing the values of this sorted list. This
-        // method returns the same object as GetValueList, but typed as an
-        // ICollection instead of an IList.
-        // 
-         public virtual ICollection Values {
-            get {
-                return GetValueList();
-            }
-        }
-    
-        // Is this SortedList read-only?
-        public virtual bool IsReadOnly {
-            get { return false; }
-        }
-
-        public virtual bool IsFixedSize {
-            get { return false; }
-        }
-
-        // Is this SortedList synchronized (thread-safe)?
-        public virtual bool IsSynchronized {
-            get { return false; }
-        }
-    
-        // Synchronization root for this object.
-        public virtual Object SyncRoot {
-            get { 
-                if( _syncRoot == null) {
-                    System.Threading.Interlocked.CompareExchange<Object>(ref _syncRoot, new Object(), null);    
-                }
-                return _syncRoot; 
-            }
-        }
-    
-        // Removes all entries from this sorted list.
-        public virtual void Clear() {
-            // clear does not change the capacity
-            version++;
-            Array.Clear(keys, 0, _size); // Don't need to doc this but we clear the elements so that the gc can reclaim the references.
-            Array.Clear(values, 0, _size); // Don't need to doc this but we clear the elements so that the gc can reclaim the references.
-            _size = 0;
-
-        }
-    
-        // Makes a virtually identical copy of this SortedList.  This is a shallow 
-        // copy.  IE, the Objects in the SortedList are not cloned - we copy the 
-        // references to those objects.
-        public virtual Object Clone()
-        {
-            SortedList sl = new SortedList(_size);
-            Array.Copy(keys, 0, sl.keys, 0, _size);
-            Array.Copy(values, 0, sl.values, 0, _size);
-            sl._size = _size;
-            sl.version = version;
-            sl.comparer = comparer;
-            // Don't copy keyList nor valueList.
-            return sl;
-        }
-    
-    
-        // Checks if this sorted list contains an entry with the given key.
-        // 
-        public virtual bool Contains(Object key) {
-            return IndexOfKey(key) >= 0;
-        }
-    
-        // Checks if this sorted list contains an entry with the given key.
-        // 
-        public virtual bool ContainsKey(Object key) {
-            // Yes, this is a SPEC'ed duplicate of Contains().
-            return IndexOfKey(key) >= 0;
-        }
-    
-        // Checks if this sorted list contains an entry with the given value. The
-        // values of the entries of the sorted list are compared to the given value
-        // using the Object.Equals method. This method performs a linear
-        // search and is substantially slower than the Contains
-        // method.
-        // 
-        public virtual bool ContainsValue(Object value) {
-            return IndexOfValue(value) >= 0;
-        }
-    
-        // Copies the values in this SortedList to an array.
-        public virtual void CopyTo(Array array, int arrayIndex) {
-            if (array == null)
-                throw new ArgumentNullException(nameof(array), Environment.GetResourceString("ArgumentNull_Array"));
-            if (array.Rank != 1)
-                throw new ArgumentException(Environment.GetResourceString("Arg_RankMultiDimNotSupported"));
-            if (arrayIndex < 0) 
-                throw new ArgumentOutOfRangeException(nameof(arrayIndex), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            if (array.Length - arrayIndex < Count)
-                throw new ArgumentException(Environment.GetResourceString("Arg_ArrayPlusOffTooSmall"));
-            Contract.EndContractBlock();
-            for (int i = 0; i<Count; i++) {
-                DictionaryEntry entry = new DictionaryEntry(keys[i],values[i]);
-                array.SetValue(entry, i + arrayIndex);
-            }
-        }
-
-        // Copies the values in this SortedList to an KeyValuePairs array.
-        // KeyValuePairs is different from Dictionary Entry in that it has special
-        // debugger attributes on its fields.
-        
-        internal virtual KeyValuePairs[] ToKeyValuePairsArray() {
-            KeyValuePairs[] array = new KeyValuePairs[Count];
-            for (int i = 0; i < Count; i++) {
-                array[i] = new KeyValuePairs(keys[i],values[i]);
-            }
-            return array;
-        }
-        
-        // Ensures that the capacity of this sorted list is at least the given
-        // minimum value. If the currect capacity of the list is less than
-        // min, the capacity is increased to twice the current capacity or
-        // to min, whichever is larger.
-        private void EnsureCapacity(int min) {
-            int newCapacity = keys.Length == 0? 16: keys.Length * 2;
-            // Allow the list to grow to maximum possible capacity (~2G elements) before encountering overflow.
-            // Note that this check works even when _items.Length overflowed thanks to the (uint) cast
-            if ((uint)newCapacity > Array.MaxArrayLength) newCapacity = Array.MaxArrayLength;
-            if (newCapacity < min) newCapacity = min;
-            Capacity = newCapacity;
-        }
-    
-        // Returns the value of the entry at the given index.
-        // 
-        public virtual Object GetByIndex(int index) {
-            if (index < 0 || index >= Count) 
-                throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-            Contract.EndContractBlock();
-            return values[index];
-        }
-    
-        // Returns an IEnumerator for this sorted list.  If modifications 
-        // made to the sorted list while an enumeration is in progress, 
-        // the MoveNext and Remove methods
-        // of the enumerator will throw an exception.
-        //
-        IEnumerator IEnumerable.GetEnumerator() {
-            return new SortedListEnumerator(this, 0, _size, SortedListEnumerator.DictEntry);
-        }
-
-        // Returns an IDictionaryEnumerator for this sorted list.  If modifications 
-        // made to the sorted list while an enumeration is in progress, 
-        // the MoveNext and Remove methods
-        // of the enumerator will throw an exception.
-        //
-        public virtual IDictionaryEnumerator GetEnumerator() {
-            return new SortedListEnumerator(this, 0, _size, SortedListEnumerator.DictEntry);
-        }
-        
-        // Returns the key of the entry at the given index.
-        // 
-        public virtual Object GetKey(int index) {
-            if (index < 0 || index >= Count) throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-            Contract.EndContractBlock();
-            return keys[index];
-        }
-    
-        // Returns an IList representing the keys of this sorted list. The
-        // returned list is an alias for the keys of this sorted list, so
-        // modifications made to the returned list are directly reflected in the
-        // underlying sorted list, and vice versa. The elements of the returned
-        // list are ordered in the same way as the elements of the sorted list. The
-        // returned list does not support adding, inserting, or modifying elements
-        // (the Add, AddRange, Insert, InsertRange,
-        // Reverse, Set, SetRange, and Sort methods
-        // throw exceptions), but it does allow removal of elements (through the
-        // Remove and RemoveRange methods or through an enumerator).
-        // Null is an invalid key value.
-        // 
-        public virtual IList GetKeyList() {
-            if (keyList == null) keyList = new KeyList(this);
-            return keyList;
-        }
-    
-        // Returns an IList representing the values of this sorted list. The
-        // returned list is an alias for the values of this sorted list, so
-        // modifications made to the returned list are directly reflected in the
-        // underlying sorted list, and vice versa. The elements of the returned
-        // list are ordered in the same way as the elements of the sorted list. The
-        // returned list does not support adding or inserting elements (the
-        // Add, AddRange, Insert and InsertRange
-        // methods throw exceptions), but it does allow modification and removal of
-        // elements (through the Remove, RemoveRange, Set and
-        // SetRange methods or through an enumerator).
-        // 
-        public virtual IList GetValueList() {
-            if (valueList == null) valueList = new ValueList(this);
-            return valueList;
-        }
-    
-        // Returns the value associated with the given key. If an entry with the
-        // given key is not found, the returned value is null.
-        // 
-        public virtual Object this[Object key] {
-            get {
-                int i = IndexOfKey(key);
-                if (i >= 0) return values[i];
-                return null;
-            }
-            set {
-                if (key == null) throw new ArgumentNullException(nameof(key), Environment.GetResourceString("ArgumentNull_Key"));
-                Contract.EndContractBlock();
-                int i = Array.BinarySearch(keys, 0, _size, key, comparer);
-                if (i >= 0) {
-                    values[i] = value;
-                    version++;
-                    return;
-                }
-                Insert(~i, key, value);
-            }
-        }
-    
-        // Returns the index of the entry with a given key in this sorted list. The
-        // key is located through a binary search, and thus the average execution
-        // time of this method is proportional to Log2(size), where
-        // size is the size of this sorted list. The returned value is -1 if
-        // the given key does not occur in this sorted list. Null is an invalid 
-        // key value.
-        // 
-        public virtual int IndexOfKey(Object key) {
-            if (key == null) 
-                throw new ArgumentNullException(nameof(key), Environment.GetResourceString("ArgumentNull_Key"));
-            Contract.EndContractBlock();
-            int ret = Array.BinarySearch(keys, 0, _size, key, comparer);
-            return ret >=0 ? ret : -1;
-        }
-    
-        // Returns the index of the first occurrence of an entry with a given value
-        // in this sorted list. The entry is located through a linear search, and
-        // thus the average execution time of this method is proportional to the
-        // size of this sorted list. The elements of the list are compared to the
-        // given value using the Object.Equals method.
-        // 
-        public virtual int IndexOfValue(Object value) {
-            return Array.IndexOf(values, value, 0, _size);
-        }
-    
-        // Inserts an entry with a given key and value at a given index.
-        private void Insert(int index, Object key, Object value) {
-            if (_size == keys.Length) EnsureCapacity(_size + 1);
-            if (index < _size) {
-                Array.Copy(keys, index, keys, index + 1, _size - index);
-                Array.Copy(values, index, values, index + 1, _size - index);
-            }
-            keys[index] = key;
-            values[index] = value;
-            _size++;
-            version++;
-        }
-    
-        // Removes the entry at the given index. The size of the sorted list is
-        // decreased by one.
-        // 
-        public virtual void RemoveAt(int index) {
-            if (index < 0 || index >= Count) throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-            Contract.EndContractBlock();
-            _size--;
-            if (index < _size) {
-                Array.Copy(keys, index + 1, keys, index, _size - index);
-                Array.Copy(values, index + 1, values, index, _size - index);
-            }
-            keys[_size] = null;
-            values[_size] = null;
-            version++;
-        }
-    
-        // Removes an entry from this sorted list. If an entry with the specified
-        // key exists in the sorted list, it is removed. An ArgumentException is
-        // thrown if the key is null.
-        // 
-        public virtual void Remove(Object key) {
-            int i = IndexOfKey(key);
-            if (i >= 0) 
-            RemoveAt(i);
-        }
-    
-        // Sets the value at an index to a given value.  The previous value of
-        // the given entry is overwritten.
-        // 
-        public virtual void SetByIndex(int index, Object value) {
-            if (index < 0 || index >= Count) throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-            Contract.EndContractBlock();
-            values[index] = value;
-            version++;
-        }
-        
-        // Returns a thread-safe SortedList.
-        //
-        public static SortedList Synchronized(SortedList list) {
-            if (list==null)
-                throw new ArgumentNullException(nameof(list));
-            Contract.EndContractBlock();
-            return new SyncSortedList(list);
-        }
-      
-        // Sets the capacity of this sorted list to the size of the sorted list.
-        // This method can be used to minimize a sorted list's memory overhead once
-        // it is known that no new elements will be added to the sorted list. To
-        // completely clear a sorted list and release all memory referenced by the
-        // sorted list, execute the following statements:
-        // 
-        // sortedList.Clear();
-        // sortedList.TrimToSize();
-        // 
-        public virtual void TrimToSize() {
-            Capacity = _size;
-        }
-    
-        [Serializable]
-        private class SyncSortedList : SortedList
-        {
-            private SortedList _list;
-            private Object _root;
-
-    
-            internal SyncSortedList(SortedList list) {
-                _list = list;
-                _root = list.SyncRoot;
-            }
-    
-            public override int Count { 
-                get { lock(_root) { return _list.Count; } }
-            }
-    
-            public override Object SyncRoot {
-                get { return _root; }
-            }
-
-            public override bool IsReadOnly {
-                get { return _list.IsReadOnly; }
-            }
-
-            public override bool IsFixedSize {
-                get { return _list.IsFixedSize; }
-            }
-
-
-            public override bool IsSynchronized { 
-                get { return true; }
-            }
-            
-            public override Object this[Object key] {
-                get {
-                    lock(_root) {
-                        return _list[key];
-                    }
-                }
-                set {
-                    lock(_root) {
-                        _list[key] = value;
-                    }
-                }
-            }
-    
-            public override void Add(Object key, Object value) {
-                lock(_root) {
-                    _list.Add(key, value);
-                }
-            }
-    
-            public override int Capacity {
-                get{ lock(_root) {  return _list.Capacity; } }
-            }
-
-            public override void Clear() {
-                lock(_root) {
-                    _list.Clear();
-                }
-            }
-
-            public override Object Clone() {
-                lock(_root) {
-                    return _list.Clone();
-                }
-            }
-
-            public override bool Contains(Object key) {
-                lock(_root) {
-                    return _list.Contains(key);
-                }
-            }
-    
-            public override bool ContainsKey(Object key) {
-                lock(_root) {
-                    return _list.ContainsKey(key);
-                }
-            }
-    
-            public override bool ContainsValue(Object key) {
-                lock(_root) {
-                    return _list.ContainsValue(key);
-                }
-            }
-    
-            public override void CopyTo(Array array, int index) {
-                lock(_root) {
-                    _list.CopyTo(array, index);
-                }
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override Object GetByIndex(int index) {
-                lock(_root) {
-                    return _list.GetByIndex(index);
-                }
-            }
-    
-            public override IDictionaryEnumerator GetEnumerator() {
-                lock(_root) {
-                    return _list.GetEnumerator();
-                }
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override Object GetKey(int index) {
-                lock(_root) {
-                    return _list.GetKey(index);
-                }
-            }
-    
-            public override IList GetKeyList() {
-                lock(_root) {
-                    return _list.GetKeyList();
-                }
-            }
-    
-            public override IList GetValueList() {
-                lock(_root) {
-                    return _list.GetValueList();
-                }
-            }
-    
-            public override int IndexOfKey(Object key) {
-                if (key == null)
-                    throw new ArgumentNullException(nameof(key), Environment.GetResourceString("ArgumentNull_Key"));
-                Contract.EndContractBlock();
-
-                lock(_root) {
-                    return _list.IndexOfKey(key);
-                }
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override int IndexOfValue(Object value) {
-                lock(_root) {
-                    return _list.IndexOfValue(value);
-                }
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override void RemoveAt(int index) {
-                lock(_root) {
-                    _list.RemoveAt(index);
-                }
-            }
-    
-            public override void Remove(Object key) {
-                lock(_root) {
-                    _list.Remove(key);
-                }
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-            public override void SetByIndex(int index, Object value) {
-                lock(_root) {
-                    _list.SetByIndex(index, value);
-                }
-            }
-    
-            internal override KeyValuePairs[] ToKeyValuePairsArray() {
-                return _list.ToKeyValuePairsArray();
-            }
-
-            public override void TrimToSize() {
-                lock(_root) {
-                    _list.TrimToSize();
-                }
-            }
-        }
-    
-    
-        [Serializable]
-        private class SortedListEnumerator : IDictionaryEnumerator, ICloneable
-        {
-            private SortedList sortedList;
-            private Object key;
-            private Object value;
-            private int index;
-            private int startIndex;        // Store for Reset.
-            private int endIndex;
-            private int version;
-            private bool current;       // Is the current element valid?
-            private int getObjectRetType;  // What should GetObject return?
-    
-            internal const int Keys = 1;
-            internal const int Values = 2;
-            internal const int DictEntry = 3;
-    
-            internal SortedListEnumerator(SortedList sortedList, int index, int count, 
-                                 int getObjRetType) {
-                this.sortedList = sortedList;
-                this.index = index;
-                startIndex = index;
-                endIndex = index + count;
-                version = sortedList.version;
-                getObjectRetType = getObjRetType;
-                current = false;
-            }
-    
-            public Object Clone()
-            {
-                return MemberwiseClone();
-            }
-
-            public virtual Object Key {
-                get {
-                    if (version != sortedList.version) throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumFailedVersion"));
-                    if (current == false) throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumOpCantHappen"));
-                    return key;
-                }
-            }
-    
-            public virtual bool MoveNext() {
-                if (version != sortedList.version) throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumFailedVersion"));
-                if (index < endIndex) {
-                    key = sortedList.keys[index];
-                    value = sortedList.values[index];
-                    index++;
-                    current = true;
-                    return true;
-                }
-                key = null;
-                value = null;
-                current = false;
-                return false;
-            }
-    
-            public virtual DictionaryEntry Entry {
-                get {
-                    if (version != sortedList.version) throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumFailedVersion"));
-                    if (current == false) throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumOpCantHappen"));
-                    return new DictionaryEntry(key, value);
-                }
-            }
-    
-            public virtual Object Current {
-                get {
-                    if (current == false) throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumOpCantHappen"));
-                    
-                    if (getObjectRetType==Keys)
-                        return key;
-                    else if (getObjectRetType==Values)
-                        return value;
-                    else 
-                        return new DictionaryEntry(key, value);
-                }
-            }
-    
-            public virtual Object Value {
-                get {
-                    if (version != sortedList.version) throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumFailedVersion));
-                    if (current == false) throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumOpCantHappen"));
-                    return value;
-                }
-            }
-            
-            public virtual void Reset() {
-                if (version != sortedList.version) throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumFailedVersion));
-                index = startIndex;
-                current = false;
-                key = null;
-                value = null;
-            }
-        }
-    
-        [Serializable]
-        private class KeyList : IList
-        {
-            private SortedList sortedList;
-    
-            internal KeyList(SortedList sortedList) {
-                this.sortedList = sortedList;
-            }
-    
-            public virtual int Count { 
-                get { return sortedList._size; }
-            }
-    
-            public virtual bool IsReadOnly {
-                get { return true; }
-            }
-
-            public virtual bool IsFixedSize {
-                get { return true; }
-            }
-
-            public virtual bool IsSynchronized {
-                get { return sortedList.IsSynchronized; }
-            }
-    
-            public virtual Object SyncRoot {
-                get { return sortedList.SyncRoot; }
-            }
-    
-            public virtual int Add(Object key) {
-                throw new NotSupportedException(Environment.GetResourceString(ResId.NotSupported_SortedListNestedWrite));
-                //            return 0; // suppress compiler warning
-            }
-    
-            public virtual void Clear() {
-                throw new NotSupportedException(Environment.GetResourceString(ResId.NotSupported_SortedListNestedWrite));
-            }
-    
-            public virtual bool Contains(Object key) {
-                return sortedList.Contains(key);
-            }
-    
-            public virtual void CopyTo(Array array, int arrayIndex) {
-                if (array != null && array.Rank != 1)
-                    throw new ArgumentException(Environment.GetResourceString("Arg_RankMultiDimNotSupported"));
-                Contract.EndContractBlock();
-                
-                // defer error checking to Array.Copy
-                Array.Copy(sortedList.keys, 0, array, arrayIndex, sortedList.Count);
-            }
-    
-            public virtual void Insert(int index, Object value) {
-                throw new NotSupportedException(Environment.GetResourceString(ResId.NotSupported_SortedListNestedWrite));
-            }
-    
-            public virtual Object this[int index] {
-                get {
-                    return sortedList.GetKey(index);
-                }
-                set {
-                    throw new NotSupportedException(Environment.GetResourceString("NotSupported_KeyCollectionSet"));
-                }
-            }
-    
-            public virtual IEnumerator GetEnumerator() {
-                return new SortedListEnumerator(sortedList, 0, sortedList.Count, SortedListEnumerator.Keys);
-            }
-    
-            public virtual int IndexOf(Object key) {
-                if (key==null)
-                    throw new ArgumentNullException(nameof(key), Environment.GetResourceString("ArgumentNull_Key"));
-                Contract.EndContractBlock();
-    
-                int i = Array.BinarySearch(sortedList.keys, 0,
-                                           sortedList.Count, key, sortedList.comparer);
-                if (i >= 0) return i;
-                return -1;
-            }
-    
-            public virtual void Remove(Object key) {
-                throw new NotSupportedException(Environment.GetResourceString(ResId.NotSupported_SortedListNestedWrite));
-            }
-    
-            public virtual void RemoveAt(int index) {
-                throw new NotSupportedException(Environment.GetResourceString(ResId.NotSupported_SortedListNestedWrite));
-            }
-        }
-    
-        [Serializable]
-        private class ValueList : IList
-        {
-            private SortedList sortedList;
-    
-            internal ValueList(SortedList sortedList) {
-                this.sortedList = sortedList;
-            }
-    
-            public virtual int Count { 
-                get { return sortedList._size; }
-            }
-    
-            public virtual bool IsReadOnly {
-                get { return true; }
-            }
-
-            public virtual bool IsFixedSize {
-                get { return true; }
-            }
-
-            public virtual bool IsSynchronized {
-                get { return sortedList.IsSynchronized; }
-            }
-    
-            public virtual Object SyncRoot {
-                get { return sortedList.SyncRoot; }
-            }
-    
-            public virtual int Add(Object key) {
-                throw new NotSupportedException(Environment.GetResourceString(ResId.NotSupported_SortedListNestedWrite));
-            }
-    
-            public virtual void Clear() {
-                throw new NotSupportedException(Environment.GetResourceString(ResId.NotSupported_SortedListNestedWrite));
-            }
-    
-            public virtual bool Contains(Object value) {
-                return sortedList.ContainsValue(value);
-            }
-    
-            public virtual void CopyTo(Array array, int arrayIndex) {
-                if (array != null && array.Rank != 1)
-                    throw new ArgumentException(Environment.GetResourceString("Arg_RankMultiDimNotSupported"));
-                Contract.EndContractBlock();
-                
-                // defer error checking to Array.Copy
-                Array.Copy(sortedList.values, 0, array, arrayIndex, sortedList.Count);
-            }
-    
-            public virtual void Insert(int index, Object value) {
-                throw new NotSupportedException(Environment.GetResourceString(ResId.NotSupported_SortedListNestedWrite));
-            }
-    
-            public virtual Object this[int index] {
-                get {
-                    return sortedList.GetByIndex(index);
-                }
-                set {
-                    throw new NotSupportedException(Environment.GetResourceString(ResId.NotSupported_SortedListNestedWrite));
-                }
-            }
-
-            public virtual IEnumerator GetEnumerator() {
-                return new SortedListEnumerator(sortedList, 0, sortedList.Count, SortedListEnumerator.Values);
-            }
-    
-            public virtual int IndexOf(Object value) {
-                return Array.IndexOf(sortedList.values, value, 0, sortedList.Count);
-            }
-    
-            public virtual void Remove(Object value) {
-                throw new NotSupportedException(Environment.GetResourceString(ResId.NotSupported_SortedListNestedWrite));
-            }
-    
-            public virtual void RemoveAt(int index) {
-                throw new NotSupportedException(Environment.GetResourceString(ResId.NotSupported_SortedListNestedWrite));
-            }
-            
-        }
-        
-        // internal debug view class for sorted list
-        internal class SortedListDebugView {
-            private SortedList sortedList; 
-        
-            public SortedListDebugView( SortedList sortedList) {
-                if( sortedList == null) {
-                    throw new ArgumentNullException(nameof(sortedList));
-                }
-                Contract.EndContractBlock();
-
-                this.sortedList = sortedList;            
-            }
-       
-            [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
-            public KeyValuePairs[] Items { 
-                get {
-                    return sortedList.ToKeyValuePairsArray();               
-                }
-            }
-        }        
-    }
-}
diff --git a/src/mscorlib/src/System/Collections/Stack.cs b/src/mscorlib/src/System/Collections/Stack.cs
deleted file mode 100644
index c3ad15abd8..0000000000
--- a/src/mscorlib/src/System/Collections/Stack.cs
+++ /dev/null
@@ -1,379 +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: An array implementation of a stack.
-**
-**
-=============================================================================*/
-namespace System.Collections {
-    using System;
-    using System.Security.Permissions;
-    using System.Diagnostics;
-    using System.Diagnostics.CodeAnalysis;
-    using System.Diagnostics.Contracts;
-
-    // A simple stack of objects.  Internally it is implemented as an array,
-    // so Push can be O(n).  Pop is O(1).
-    [DebuggerTypeProxy(typeof(System.Collections.Stack.StackDebugView))] 
-    [DebuggerDisplay("Count = {Count}")]
-[System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-    public class Stack : ICollection, ICloneable {
-        private Object[] _array;     // Storage for stack elements
-        [ContractPublicPropertyName("Count")]
-        private int _size;           // Number of items in the stack.
-        private int _version;        // Used to keep enumerator in sync w/ collection.
-        [NonSerialized]
-        private Object _syncRoot;
-    
-        private const int _defaultCapacity = 10;
-    
-        public Stack() {
-            _array = new Object[_defaultCapacity];
-            _size = 0;
-            _version = 0;
-        }
-    
-        // Create a stack with a specific initial capacity.  The initial capacity
-        // must be a non-negative number.
-        public Stack(int initialCapacity) {
-            if (initialCapacity < 0)
-                throw new ArgumentOutOfRangeException(nameof(initialCapacity), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            Contract.EndContractBlock();
-            if (initialCapacity < _defaultCapacity)
-                initialCapacity = _defaultCapacity;  // Simplify doubling logic in Push.
-            _array = new Object[initialCapacity];
-            _size = 0;
-            _version = 0;
-        }
-    
-        // Fills a Stack with the contents of a particular collection.  The items are
-        // pushed onto the stack in the same order they are read by the enumerator.
-        //
-        public Stack(ICollection col) : this((col==null ? 32 : col.Count))
-        {
-            if (col==null)
-                throw new ArgumentNullException(nameof(col));
-            Contract.EndContractBlock();
-            IEnumerator en = col.GetEnumerator();
-            while(en.MoveNext())
-                Push(en.Current);
-        }
-    
-        public virtual int Count {
-            get {
-                Contract.Ensures(Contract.Result<int>() >= 0);
-                return _size;
-            }
-        }
-            
-        public virtual bool IsSynchronized {
-            get { return false; }
-        }
-
-        public virtual Object SyncRoot {
-            get { 
-                if( _syncRoot == null) {
-                    System.Threading.Interlocked.CompareExchange<Object>(ref _syncRoot, new Object(), null);    
-                }
-                return _syncRoot; 
-            }
-        }
-    
-        // Removes all Objects from the Stack.
-        public virtual void Clear() {
-            Array.Clear(_array, 0, _size); // Don't need to doc this but we clear the elements so that the gc can reclaim the references.
-            _size = 0;
-            _version++;
-        }
-
-        public virtual Object Clone() {
-            Contract.Ensures(Contract.Result<Object>() != null);
-
-            Stack s = new Stack(_size);
-            s._size = _size;
-            Array.Copy(_array, 0, s._array, 0, _size);
-            s._version = _version;
-            return s;
-        }
-
-        public virtual bool Contains(Object obj) {
-            int count = _size;
-    
-            while (count-- > 0) {
-                if (obj == null) {
-                    if (_array[count] == null)
-                        return true;
-                }
-                else if (_array[count] != null && _array[count].Equals(obj)) {
-                    return true;
-                }
-            }
-            return false;
-        }
-    
-        // Copies the stack into an array.
-        public virtual void CopyTo(Array array, int index) {
-            if (array==null)
-                throw new ArgumentNullException(nameof(array));
-            if (array.Rank != 1)
-                throw new ArgumentException(Environment.GetResourceString("Arg_RankMultiDimNotSupported"));
-            if (index < 0)
-                throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            if (array.Length - index < _size)
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-            Contract.EndContractBlock();
-    
-            int i = 0;
-            if (array is Object[]) {
-                Object[] objArray = (Object[]) array;
-                while(i < _size) {
-                    objArray[i+index] = _array[_size-i-1];
-                    i++;
-                }
-            }
-            else {
-                while(i < _size) {
-                    array.SetValue(_array[_size-i-1], i+index);
-                    i++;
-                }
-            }
-        }
-    
-        // Returns an IEnumerator for this Stack.
-        public virtual IEnumerator GetEnumerator() {
-            Contract.Ensures(Contract.Result<IEnumerator>() != null);
-            return new StackEnumerator(this);
-        }
-    
-        // Returns the top object on the stack without removing it.  If the stack
-        // is empty, Peek throws an InvalidOperationException.
-        public virtual Object Peek() {
-            if (_size==0)
-                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EmptyStack"));
-            Contract.EndContractBlock();
-            return _array[_size-1];
-        }
-    
-        // Pops an item from the top of the stack.  If the stack is empty, Pop
-        // throws an InvalidOperationException.
-        public virtual Object Pop() {
-            if (_size == 0)
-                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EmptyStack"));
-            //Contract.Ensures(Count == Contract.OldValue(Count) - 1);
-            Contract.EndContractBlock();
-            _version++;
-            Object obj = _array[--_size];
-            _array[_size] = null;     // Free memory quicker.
-            return obj;
-        }
-    
-        // Pushes an item to the top of the stack.
-        // 
-        public virtual void Push(Object obj) {
-            //Contract.Ensures(Count == Contract.OldValue(Count) + 1);
-            if (_size == _array.Length) {
-                Object[] newArray = new Object[2*_array.Length];
-                Array.Copy(_array, 0, newArray, 0, _size);
-                _array = newArray;
-            }
-            _array[_size++] = obj;
-            _version++;
-        }
-    
-        // Returns a synchronized Stack.
-        //
-        public static Stack Synchronized(Stack stack) {
-            if (stack==null)
-                throw new ArgumentNullException(nameof(stack));
-            Contract.Ensures(Contract.Result<Stack>() != null);
-            Contract.EndContractBlock();
-            return new SyncStack(stack);
-        }
-    
-    
-        // Copies the Stack to an array, in the same order Pop would return the items.
-        public virtual Object[] ToArray()
-        {
-            Contract.Ensures(Contract.Result<Object[]>() != null);
-
-            Object[] objArray = new Object[_size];
-            int i = 0;
-            while(i < _size) {
-                objArray[i] = _array[_size-i-1];
-                i++;
-            }
-            return objArray;
-        }
-    
-        [Serializable]
-        private class SyncStack : Stack
-        {
-            private Stack _s;
-            private Object _root;
-    
-            internal SyncStack(Stack stack) {
-                _s = stack;
-                _root = stack.SyncRoot;
-            }
-    
-            public override bool IsSynchronized {
-                get { return true; }
-            }
-    
-            public override Object SyncRoot {
-                get {
-                    return _root;
-                }
-            }
-    
-            public override int Count { 
-                get { 
-                    lock (_root) {
-                        return _s.Count;
-                    } 
-                }
-            }
-
-            public override bool Contains(Object obj) {
-                lock (_root) {
-                    return _s.Contains(obj);
-                }
-            }
-
-            public override Object Clone()
-            {
-                lock (_root) {
-                    return new SyncStack((Stack)_s.Clone());
-                }
-            }
-          
-            public override void Clear() {
-                lock (_root) {
-                    _s.Clear();
-                }
-            }
-    
-            public override void CopyTo(Array array, int arrayIndex) {
-                lock (_root) {
-                    _s.CopyTo(array, arrayIndex);
-                }
-            }
-    
-            public override void Push(Object value) {
-                lock (_root) {
-                    _s.Push(value);
-                }
-            }
-
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Thread safety problems with precondition - can't express the precondition as of Dev10.
-            public override Object Pop() {
-                lock (_root) {
-                    return _s.Pop();
-                }
-            }
-    
-            public override IEnumerator GetEnumerator() {
-                lock (_root) {
-                    return _s.GetEnumerator();
-                }
-            }
-    
-            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Thread safety problems with precondition - can't express the precondition as of Dev10.
-            public override Object Peek() {
-                lock (_root) {
-                    return _s.Peek();
-                }
-            }
-
-            public override Object[] ToArray() {
-                lock (_root) {
-                    return _s.ToArray();
-                }
-            }
-        }
-    
-    
-        [Serializable]
-        private class StackEnumerator : IEnumerator, ICloneable
-        {
-            private Stack _stack;
-            private int _index;
-            private int _version;
-            private Object currentElement;
-    
-            internal StackEnumerator(Stack stack) {
-                _stack = stack;
-                _version = _stack._version;
-                _index = -2;
-                currentElement = null;
-            }
-
-            public Object Clone()
-            {
-                return MemberwiseClone();
-            }
-
-            public virtual bool MoveNext() {
-                bool retval;
-                if (_version != _stack._version) throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumFailedVersion));
-                if (_index == -2) {  // First call to enumerator.
-                    _index = _stack._size-1;
-                    retval = ( _index >= 0);
-                    if (retval)
-                        currentElement = _stack._array[_index];
-                    return retval;
-                }
-                if (_index == -1) {  // End of enumeration.
-                    return false;
-                }
-                
-                retval = (--_index >= 0);
-                if (retval)
-                    currentElement = _stack._array[_index];
-                else
-                    currentElement = null;
-                return retval;
-            }
-    
-            public virtual Object Current {
-                get {
-                    if (_index == -2) throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumNotStarted));
-                    if (_index == -1) throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumEnded));
-                    return currentElement;
-                }
-            }
-    
-            public virtual void Reset() {
-                if (_version != _stack._version) throw new InvalidOperationException(Environment.GetResourceString(ResId.InvalidOperation_EnumFailedVersion));
-                _index = -2;
-                currentElement = null;
-            }
-        }    
-
-        internal class StackDebugView {
-            private Stack stack; 
-        
-            public StackDebugView( Stack stack) {
-                if( stack == null)
-                    throw new ArgumentNullException(nameof(stack));
-                Contract.EndContractBlock();
-
-                this.stack = stack;
-            }
-
-            [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
-            public Object[] Items   { 
-                get {
-                    return stack.ToArray();
-                }
-            }
-        }        
-    }
-}
diff --git a/src/mscorlib/src/System/CompatibilitySwitches.cs b/src/mscorlib/src/System/CompatibilitySwitches.cs
index d699917feb..58dd640f88 100644
--- a/src/mscorlib/src/System/CompatibilitySwitches.cs
+++ b/src/mscorlib/src/System/CompatibilitySwitches.cs
@@ -10,7 +10,6 @@ namespace System
     internal static class CompatibilitySwitches
     {
         private static bool s_AreSwitchesSet;
-        private static bool s_useLatestBehaviorWhenTFMNotSpecified; // Which behavior to use when the TFM is not specified.
 
         public static bool IsCompatibilityBehaviorDefined
         {
diff --git a/src/mscorlib/src/System/Configuration/Assemblies/AssemblyHash.cs b/src/mscorlib/src/System/Configuration/Assemblies/AssemblyHash.cs
deleted file mode 100644
index a7b0e70266..0000000000
--- a/src/mscorlib/src/System/Configuration/Assemblies/AssemblyHash.cs
+++ /dev/null
@@ -1,74 +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: 
-**
-**
-===========================================================*/
-namespace System.Configuration.Assemblies {
-    using System;
-    [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    [Obsolete("The AssemblyHash class has been deprecated. http://go.microsoft.com/fwlink/?linkid=14202")]
-    public struct AssemblyHash : ICloneable
-    {
-        private AssemblyHashAlgorithm _Algorithm;
-        private byte[] _Value;
-        
-        [Obsolete("The AssemblyHash class has been deprecated. http://go.microsoft.com/fwlink/?linkid=14202")]
-        public static readonly AssemblyHash Empty = new AssemblyHash(AssemblyHashAlgorithm.None, null);
-    
-        [Obsolete("The AssemblyHash class has been deprecated. http://go.microsoft.com/fwlink/?linkid=14202")]
-        public AssemblyHash(byte[] value) {
-            _Algorithm = AssemblyHashAlgorithm.SHA1;
-            _Value = null;
-    
-            if (value != null) {
-                int length = value.Length;
-                _Value = new byte[length];
-                Array.Copy(value, _Value, length);
-            }
-        }
-    
-        [Obsolete("The AssemblyHash class has been deprecated. http://go.microsoft.com/fwlink/?linkid=14202")]
-        public AssemblyHash(AssemblyHashAlgorithm algorithm, byte[] value) {
-            _Algorithm = algorithm;
-            _Value = null;
-    
-            if (value != null) {
-                int length = value.Length;
-                _Value = new byte[length];
-                Array.Copy(value, _Value, length);
-            }
-        }
-    
-        // Hash is made up of a byte array and a value from a class of supported 
-        // algorithm types.
-        [Obsolete("The AssemblyHash class has been deprecated. http://go.microsoft.com/fwlink/?linkid=14202")]
-        public AssemblyHashAlgorithm Algorithm {
-            get { return _Algorithm; }
-            set { _Algorithm = value; }
-        }
-
-        [Obsolete("The AssemblyHash class has been deprecated. http://go.microsoft.com/fwlink/?linkid=14202")]
-        public byte[] GetValue() {
-            return _Value;
-        }
-
-        [Obsolete("The AssemblyHash class has been deprecated. http://go.microsoft.com/fwlink/?linkid=14202")]
-        public void SetValue(byte[] value) {
-            _Value = value;
-        }
-    
-        [Obsolete("The AssemblyHash class has been deprecated. http://go.microsoft.com/fwlink/?linkid=14202")]
-        public Object Clone() {
-            return new AssemblyHash(_Algorithm, _Value);
-        }
-    }
-
-}
diff --git a/src/mscorlib/src/System/Configuration/Assemblies/AssemblyHashAlgorithm.cs b/src/mscorlib/src/System/Configuration/Assemblies/AssemblyHashAlgorithm.cs
index 6c4fb3febf..a19d0344b1 100644
--- a/src/mscorlib/src/System/Configuration/Assemblies/AssemblyHashAlgorithm.cs
+++ b/src/mscorlib/src/System/Configuration/Assemblies/AssemblyHashAlgorithm.cs
@@ -16,17 +16,13 @@ namespace System.Configuration.Assemblies {
     
     using System;
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum AssemblyHashAlgorithm
     {
         None = 0,
         MD5 = 0x8003,
         SHA1 = 0x8004,
-        [ComVisible(false)]
         SHA256 = 0x800c,
-        [ComVisible(false)]
         SHA384 = 0x800d,
-        [ComVisible(false)]
         SHA512 = 0x800e,
     }
 }
diff --git a/src/mscorlib/src/System/Configuration/Assemblies/AssemblyVersionCompatibility.cs b/src/mscorlib/src/System/Configuration/Assemblies/AssemblyVersionCompatibility.cs
index 4b0f1e4236..b7e9c30c62 100644
--- a/src/mscorlib/src/System/Configuration/Assemblies/AssemblyVersionCompatibility.cs
+++ b/src/mscorlib/src/System/Configuration/Assemblies/AssemblyVersionCompatibility.cs
@@ -14,7 +14,6 @@ namespace System.Configuration.Assemblies {
     
     using System;
      [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum AssemblyVersionCompatibility
     {
         SameMachine         = 1,
diff --git a/src/mscorlib/src/System/ContextMarshalException.cs b/src/mscorlib/src/System/ContextMarshalException.cs
deleted file mode 100644
index f74a62b991..0000000000
--- a/src/mscorlib/src/System/ContextMarshalException.cs
+++ /dev/null
@@ -1,45 +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: Exception class for attempting to pass an instance through a context
-**          boundary, when the formal type and the instance's marshal style are
-**          incompatible or cannot be marshaled.
-**
-**          This is thrown by the VM when attempts to marshal the exception 
-**          object at the AppDomain transition boundary fails.
-=============================================================================*/
-
-namespace System {
-	using System.Runtime.InteropServices;
-	using System.Runtime.Remoting;
-	using System;
-	using System.Runtime.Serialization;
-    [System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-    public class ContextMarshalException : SystemException {
-        public ContextMarshalException() 
-            : base(Environment.GetResourceString("Arg_ContextMarshalException")) {
-    		SetErrorCode(__HResults.COR_E_CONTEXTMARSHAL);
-        }
-    
-        public ContextMarshalException(String message) 
-            : base(message) {
-    		SetErrorCode(__HResults.COR_E_CONTEXTMARSHAL);
-        }
-    	
-        public ContextMarshalException(String message, Exception inner) 
-            : base(message, inner) {
-    		SetErrorCode(__HResults.COR_E_CONTEXTMARSHAL);
-        }
-
-        protected ContextMarshalException(SerializationInfo info, StreamingContext context) : base(info, context) {
-        }
-
-    }
-
-}
diff --git a/src/mscorlib/src/System/Convert.cs b/src/mscorlib/src/System/Convert.cs
index 0e14f93fee..0cd3c5d715 100644
--- a/src/mscorlib/src/System/Convert.cs
+++ b/src/mscorlib/src/System/Convert.cs
@@ -2158,7 +2158,6 @@ namespace System {
             return ToBase64String(inArray, 0, inArray.Length, Base64FormattingOptions.None);
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public static String ToBase64String(byte[] inArray, Base64FormattingOptions options) {
             if (inArray==null) {
                 throw new ArgumentNullException(nameof(inArray));
@@ -2172,7 +2171,6 @@ namespace System {
             return ToBase64String(inArray, offset, length, Base64FormattingOptions.None);
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public static unsafe String ToBase64String(byte[] inArray, int offset, int length, Base64FormattingOptions options) {
             //Do data verfication
             if (inArray==null) 
@@ -2202,7 +2200,7 @@ namespace System {
 
             string returnString = string.FastAllocateString(stringLength);
             fixed (char* outChars = returnString){
-                fixed (byte* inData = inArray) {
+                fixed (byte* inData = &inArray[0]) {
                     int j = ConvertToBase64Array(outChars,inData,offset,length, insertLineBreaks);
                     BCLDebug.Assert(returnString.Length == j, "returnString.Length == j");
                     return returnString;
@@ -2218,7 +2216,6 @@ namespace System {
             return ToBase64CharArray(inArray, offsetIn, length, outArray, offsetOut, Base64FormattingOptions.None);
         }
         
-        [System.Runtime.InteropServices.ComVisible(false)]
         public static unsafe int ToBase64CharArray(byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut, Base64FormattingOptions options) {
             //Do data verfication
             if (inArray==null) 
@@ -2265,7 +2262,7 @@ namespace System {
                 throw new ArgumentOutOfRangeException(nameof(offsetOut), Environment.GetResourceString("ArgumentOutOfRange_OffsetOut"));
 
             fixed (char* outChars = &outArray[offsetOut]) {
-                fixed (byte* inData = inArray) { 
+                fixed (byte* inData = &inArray[0]) { 
                    retVal = ConvertToBase64Array(outChars,inData,offsetIn,length, insertLineBreaks);
                 }
             }
@@ -2282,7 +2279,7 @@ namespace System {
             int i;
 
             // get a pointer to the base64Table to avoid unnecessary range checking
-            fixed(char* base64 = base64Table) {
+            fixed(char* base64 = &base64Table[0]) {
                 for (i=offset; i<calcLength; i+=3)
                 {
                     if (insertLineBreaks) {
diff --git a/src/mscorlib/src/System/DBNull.cs b/src/mscorlib/src/System/DBNull.cs
index 6f80af7e21..65c85ba968 100644
--- a/src/mscorlib/src/System/DBNull.cs
+++ b/src/mscorlib/src/System/DBNull.cs
@@ -11,8 +11,6 @@ namespace System {
     using System;
     using System.Runtime.Remoting;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public sealed class DBNull : ISerializable, IConvertible {
     
diff --git a/src/mscorlib/src/System/DataMisalignedException.cs b/src/mscorlib/src/System/DataMisalignedException.cs
index e5332bb9b7..a3653e7219 100644
--- a/src/mscorlib/src/System/DataMisalignedException.cs
+++ b/src/mscorlib/src/System/DataMisalignedException.cs
@@ -9,37 +9,31 @@
 **
 =============================================================================*/
 
-namespace System 
-{
-    using System;
-    using System.Runtime.Serialization;
+using System.Runtime.Serialization;
 
+namespace System
+{
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class DataMisalignedException : SystemException 
     {
-        public DataMisalignedException() 
-            : base(Environment.GetResourceString("Arg_DataMisalignedException")) 
-        {
-            SetErrorCode(__HResults.COR_E_DATAMISALIGNED);
-        }
-    
-        public DataMisalignedException(String message) 
-            : base(message) 
+        public DataMisalignedException()
+            : base(SR.Arg_DataMisalignedException)
         {
-            SetErrorCode(__HResults.COR_E_DATAMISALIGNED);
+            HResult = __HResults.COR_E_DATAMISALIGNED;
         }
 
-        public DataMisalignedException(String message, Exception innerException) 
-            : base(message, innerException) 
+        public DataMisalignedException(String message)
+            : base(message)
         {
-            SetErrorCode(__HResults.COR_E_DATAMISALIGNED);
+            HResult = __HResults.COR_E_DATAMISALIGNED;
         }
 
-        internal DataMisalignedException(SerializationInfo info, StreamingContext context) 
-            : base (info, context) 
+        public DataMisalignedException(String message, Exception innerException)
+            : base(message, innerException)
         {
+            HResult = __HResults.COR_E_DATAMISALIGNED;
         }
-    }
 
+        internal DataMisalignedException(SerializationInfo info, StreamingContext context) : base(info, context) { }
+    }
 }
diff --git a/src/mscorlib/src/System/DateTime.cs b/src/mscorlib/src/System/DateTime.cs
index 28348257aa..3de50336a9 100644
--- a/src/mscorlib/src/System/DateTime.cs
+++ b/src/mscorlib/src/System/DateTime.cs
@@ -13,7 +13,6 @@ namespace System {
     using System.Runtime.Serialization;
     using System.Runtime.Versioning;
     using System.Security;
-    using System.Security.Permissions;
     using System.Diagnostics.Contracts;
     using CultureInfo = System.Globalization.CultureInfo;
     using Calendar = System.Globalization.Calendar;
@@ -663,7 +662,6 @@ namespace System {
             return new DateTime(DoubleDateToTicks(d), DateTimeKind.Unspecified);
         }        
 
-        [System.Security.SecurityCritical /*auto-generated_required*/]
         void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context) {
             if (info==null) {
                 throw new ArgumentNullException(nameof(info));
@@ -710,12 +708,6 @@ namespace System {
                 return (Int64)dateData;
             }
         }        
-
-        // Return the underlying data, without adjust local times to the right time zone. Needed if performance
-        // or compatibility are important.
-        internal Int64 ToBinaryRaw() {
-            return (Int64)dateData;
-        }        
     
         // Returns the date part of this DateTime. The resulting value
         // corresponds to this DateTime with the time-of-day part set to
diff --git a/src/mscorlib/src/System/DateTimeKind.cs b/src/mscorlib/src/System/DateTimeKind.cs
index 1a8a4ff6b4..6b5e690df0 100644
--- a/src/mscorlib/src/System/DateTimeKind.cs
+++ b/src/mscorlib/src/System/DateTimeKind.cs
@@ -2,14 +2,12 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-
-namespace System {
-
+namespace System
+{
     // This enum is used to indentify DateTime instances in cases when they are known to be in local time, 
     // UTC time or if this information has not been specified or is not applicable.
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum DateTimeKind
     {
         Unspecified = 0,
diff --git a/src/mscorlib/src/System/DateTimeOffset.cs b/src/mscorlib/src/System/DateTimeOffset.cs
index 5bdaa18aaa..d64ba1582e 100644
--- a/src/mscorlib/src/System/DateTimeOffset.cs
+++ b/src/mscorlib/src/System/DateTimeOffset.cs
@@ -10,7 +10,6 @@ namespace System {
     using System.Runtime.InteropServices;
     using System.Runtime.CompilerServices;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
 
diff --git a/src/mscorlib/src/System/DayOfWeek.cs b/src/mscorlib/src/System/DayOfWeek.cs
index 37b8f8975d..5d84257158 100644
--- a/src/mscorlib/src/System/DayOfWeek.cs
+++ b/src/mscorlib/src/System/DayOfWeek.cs
@@ -10,11 +10,12 @@
 **
 **
 ============================================================*/
-namespace System {
 
+namespace System
+{
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public enum DayOfWeek {
+    public enum DayOfWeek
+    {
         Sunday = 0,
         Monday = 1,
         Tuesday = 2,
diff --git a/src/mscorlib/src/System/Decimal.cs b/src/mscorlib/src/System/Decimal.cs
index fd16697199..a01ed19753 100644
--- a/src/mscorlib/src/System/Decimal.cs
+++ b/src/mscorlib/src/System/Decimal.cs
@@ -57,7 +57,6 @@ namespace System {
     // the range of the Decimal type.
     [StructLayout(LayoutKind.Sequential)]
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     [System.Runtime.Versioning.NonVersionable] // This only applies to field layout
     public struct Decimal : IFormattable, IComparable, IConvertible, IComparable<Decimal>, IEquatable<Decimal>, IDeserializationCallback
     {
@@ -346,9 +345,6 @@ namespace System {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         private static extern void FCallAddSub(ref Decimal d1, ref Decimal d2, byte bSign);
         
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        private static extern void FCallAddSubOverflowed(ref Decimal d1, ref Decimal d2, byte bSign, ref bool overflowed);
-        
         // Rounds a Decimal to an integer value. The Decimal argument is rounded
         // towards positive infinity.
         public static Decimal Ceiling(Decimal d) {
@@ -358,13 +354,11 @@ namespace System {
         // Compares two Decimal values, returning an integer that indicates their
         // relationship.
         //
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static int Compare(Decimal d1, Decimal d2) {
             return FCallCompare(ref d1, ref d2);
         }
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         private static extern int FCallCompare(ref Decimal d1, ref Decimal d2);
     
         // Compares this object to another object, returning an integer that
@@ -403,9 +397,6 @@ namespace System {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         private static extern void FCallDivide(ref Decimal d1, ref Decimal d2);
 
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        private static extern void FCallDivideOverflowed(ref Decimal d1, ref Decimal d2, ref bool overflowed);
-
     
         // Checks if this Decimal is equal to a given object. Returns true
         // if the given object is a boxed Decimal and its value is equal to the
@@ -628,14 +619,12 @@ namespace System {
     
         // Returns the larger of two Decimal values.
         //
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal static Decimal Max(Decimal d1, Decimal d2) {
             return FCallCompare(ref d1, ref d2) >= 0? d1: d2;
         }
     
         // Returns the smaller of two Decimal values.
         //
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal static Decimal Min(Decimal d1, Decimal d2) {
             return FCallCompare(ref d1, ref d2) < 0? d1: d2;
         }
@@ -697,9 +686,6 @@ namespace System {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         private static extern void FCallMultiply(ref Decimal d1, ref Decimal d2);
     
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        private static extern void FCallMultiplyOverflowed(ref Decimal d1, ref Decimal d2, ref bool overflowed);
-    
         // Returns the negated value of the given Decimal. If d is non-zero,
         // the result is -d. If d is zero, the result is zero.
         //
diff --git a/src/mscorlib/src/System/Delegate.cs b/src/mscorlib/src/System/Delegate.cs
index bca88c18e9..eefccd26d5 100644
--- a/src/mscorlib/src/System/Delegate.cs
+++ b/src/mscorlib/src/System/Delegate.cs
@@ -191,7 +191,6 @@ namespace System {
             return  a.CombineImpl(b);
         }
             
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static Delegate Combine(params Delegate[] delegates)
         {
             if (delegates == null || delegates.Length == 0)
@@ -432,7 +431,7 @@ namespace System {
         }
             
         // V1 API.
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Delegate CreateDelegate(Type type, MethodInfo method, bool throwOnBindFailure)
         {
             // Validate the parameters.
@@ -482,7 +481,7 @@ namespace System {
         }
 
         // V2 API.
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Delegate CreateDelegate(Type type, Object firstArgument, MethodInfo method, bool throwOnBindFailure)
         {
             // Validate the parameters.
diff --git a/src/mscorlib/src/System/DelegateSerializationHolder.cs b/src/mscorlib/src/System/DelegateSerializationHolder.cs
index 83fe35ad1e..061f92d42e 100644
--- a/src/mscorlib/src/System/DelegateSerializationHolder.cs
+++ b/src/mscorlib/src/System/DelegateSerializationHolder.cs
@@ -7,7 +7,6 @@ using System;
 using System.Reflection;
 using System.Runtime.Remoting;
 using System.Runtime.Serialization;
-using System.Security.Permissions;
 using System.Globalization;
 using System.Diagnostics.Contracts;
 
@@ -25,10 +24,7 @@ namespace System
             if (method == null) 
                 throw new ArgumentNullException(nameof(method));
             Contract.EndContractBlock();
-    
-            if (!method.IsPublic || (method.DeclaringType != null && !method.DeclaringType.IsVisible))
-                new ReflectionPermission(ReflectionPermissionFlag.MemberAccess).Demand();
-    
+        
             Type c = delegateType.BaseType;
 
             if (c == null || (c != typeof(Delegate) && c != typeof(MulticastDelegate)))
@@ -231,9 +227,6 @@ namespace System
                     else
                         d = Delegate.CreateDelegate(type, targetType, de.methodName);
                 }
-
-                if ((d.Method != null && !d.Method.IsPublic) || (d.Method.DeclaringType != null && !d.Method.DeclaringType.IsVisible))
-                    new ReflectionPermission(ReflectionPermissionFlag.MemberAccess).Demand();
             }
             catch (Exception e)
             {
diff --git a/src/mscorlib/src/System/Diagnostics/Assert.cs b/src/mscorlib/src/System/Diagnostics/Assert.cs
index 77cc6d8e46..9f4b86b7e4 100644
--- a/src/mscorlib/src/System/Diagnostics/Assert.cs
+++ b/src/mscorlib/src/System/Diagnostics/Assert.cs
@@ -4,7 +4,6 @@
 
 namespace System.Diagnostics {
     using System;
-    using System.Security.Permissions;
     using System.IO;
     using System.Reflection;
     using System.Runtime.CompilerServices;
@@ -36,14 +35,6 @@ namespace System.Diagnostics {
             }
         }
 
-        internal static void Check(bool condition, String conditionString, String message, int exitCode)
-        {
-            if (!condition)
-            {
-                Fail(conditionString, message, null, exitCode);
-            }
-        }
-
         internal static void Fail(String conditionString, String message)
         {
             Fail(conditionString, message, null, COR_E_FAILFAST);
diff --git a/src/mscorlib/src/System/Diagnostics/ConditionalAttribute.cs b/src/mscorlib/src/System/Diagnostics/ConditionalAttribute.cs
index b20931f9c3..c57fb59319 100644
--- a/src/mscorlib/src/System/Diagnostics/ConditionalAttribute.cs
+++ b/src/mscorlib/src/System/Diagnostics/ConditionalAttribute.cs
@@ -7,7 +7,6 @@ using System;
 namespace System.Diagnostics {
     [Serializable]
     [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, AllowMultiple=true)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class ConditionalAttribute : Attribute
     {
         public ConditionalAttribute(String conditionString)
diff --git a/src/mscorlib/src/System/Diagnostics/Contracts/Contracts.cs b/src/mscorlib/src/System/Diagnostics/Contracts/Contracts.cs
index e44f9365f1..93d6c48701 100644
--- a/src/mscorlib/src/System/Diagnostics/Contracts/Contracts.cs
+++ b/src/mscorlib/src/System/Diagnostics/Contracts/Contracts.cs
@@ -41,7 +41,6 @@ using System.Runtime.ConstrainedExecution;
 #endif
 #if FEATURE_UNTRUSTED_CALLERS
 using System.Security;
-using System.Security.Permissions;
 #endif
 
 namespace System.Diagnostics.Contracts {
@@ -294,7 +293,6 @@ namespace System.Diagnostics.Contracts {
         [Conditional("DEBUG")]
         [Conditional("CONTRACTS_FULL")]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 #endif
         public static void Assume(bool condition)
         {
@@ -315,7 +313,6 @@ namespace System.Diagnostics.Contracts {
         [Conditional("DEBUG")]
         [Conditional("CONTRACTS_FULL")]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 #endif
         public static void Assume(bool condition, String userMessage)
         {
@@ -336,7 +333,6 @@ namespace System.Diagnostics.Contracts {
         [Conditional("DEBUG")]
         [Conditional("CONTRACTS_FULL")]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 #endif
         public static void Assert(bool condition)
         {
@@ -353,7 +349,6 @@ namespace System.Diagnostics.Contracts {
         [Conditional("DEBUG")]
         [Conditional("CONTRACTS_FULL")]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 #endif
         public static void Assert(bool condition, String userMessage)
         {
@@ -377,7 +372,6 @@ namespace System.Diagnostics.Contracts {
         [Pure]
         [Conditional("CONTRACTS_FULL")]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 #endif
         public static void Requires(bool condition)
         {
@@ -397,7 +391,6 @@ namespace System.Diagnostics.Contracts {
         [Pure]
         [Conditional("CONTRACTS_FULL")]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 #endif
         public static void Requires(bool condition, String userMessage)
         {
@@ -417,7 +410,6 @@ namespace System.Diagnostics.Contracts {
         [SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter")]
         [Pure]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 #endif
         public static void Requires<TException>(bool condition) where TException : Exception
         {
@@ -439,7 +431,6 @@ namespace System.Diagnostics.Contracts {
         [SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter")]
         [Pure]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 #endif
         public static void Requires<TException>(bool condition, String userMessage) where TException : Exception
         {
@@ -462,7 +453,6 @@ namespace System.Diagnostics.Contracts {
         [Pure]
         [Conditional("CONTRACTS_FULL")]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 #endif
         public static void Ensures(bool condition)
         {
@@ -482,7 +472,6 @@ namespace System.Diagnostics.Contracts {
         [Pure]
         [Conditional("CONTRACTS_FULL")]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 #endif
         public static void Ensures(bool condition, String userMessage)
         {
@@ -503,7 +492,6 @@ namespace System.Diagnostics.Contracts {
         [Conditional("CONTRACTS_FULL")]
         [SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter", Justification = "Exception type used in tools.")]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 #endif
         public static void EnsuresOnThrow<TException>(bool condition) where TException : Exception
         {
@@ -525,7 +513,6 @@ namespace System.Diagnostics.Contracts {
         [Conditional("CONTRACTS_FULL")]
         [SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter", Justification = "Exception type used in tools.")]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 #endif
         public static void EnsuresOnThrow<TException>(bool condition, String userMessage) where TException : Exception
         {
@@ -545,7 +532,6 @@ namespace System.Diagnostics.Contracts {
         [SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter", Justification = "Not intended to be called at runtime.")]
         [Pure]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 #endif
         public static T Result<T>() { return default(T); }
 
@@ -561,7 +547,6 @@ namespace System.Diagnostics.Contracts {
         [SuppressMessage("Microsoft.Design", "CA1021:AvoidOutParameters", MessageId = "0#", Justification = "Not intended to be called at runtime.")]
         [Pure]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 #endif
         public static T ValueAtReturn<T>(out T value) { value = default(T); return value; }
 
@@ -577,7 +562,6 @@ namespace System.Diagnostics.Contracts {
         [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "value")]
         [Pure]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 #endif
         public static T OldValue<T>(T value) { return default(T); }
 
@@ -599,7 +583,6 @@ namespace System.Diagnostics.Contracts {
         [Pure]
         [Conditional("CONTRACTS_FULL")]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 #endif
         public static void Invariant(bool condition)
         {
@@ -619,7 +602,6 @@ namespace System.Diagnostics.Contracts {
         [Pure]
         [Conditional("CONTRACTS_FULL")]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 #endif
         public static void Invariant(bool condition, String userMessage)
         {
@@ -644,7 +626,6 @@ namespace System.Diagnostics.Contracts {
         /// <seealso cref="System.Collections.Generic.List&lt;T&gt;.TrueForAll"/>
         [Pure]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]  // Assumes predicate obeys CER rules.
 #endif
         public static bool ForAll(int fromInclusive, int toExclusive, Predicate<int> predicate)
         {
@@ -675,7 +656,6 @@ namespace System.Diagnostics.Contracts {
         /// <seealso cref="System.Collections.Generic.List&lt;T&gt;.TrueForAll"/>
         [Pure]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]  // Assumes predicate & collection enumerator obey CER rules.
 #endif
         public static bool ForAll<T>(IEnumerable<T> collection, Predicate<T> predicate)
         {
@@ -706,7 +686,6 @@ namespace System.Diagnostics.Contracts {
         /// <seealso cref="System.Collections.Generic.List&lt;T&gt;.Exists"/>
         [Pure]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]  // Assumes predicate obeys CER rules.
 #endif
         public static bool Exists(int fromInclusive, int toExclusive, Predicate<int> predicate)
         {
@@ -736,7 +715,6 @@ namespace System.Diagnostics.Contracts {
         /// <seealso cref="System.Collections.Generic.List&lt;T&gt;.Exists"/>
         [Pure]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]  // Assumes predicate & collection enumerator obey CER rules.
 #endif
         public static bool Exists<T>(IEnumerable<T> collection, Predicate<T> predicate)
         {
@@ -765,7 +743,6 @@ namespace System.Diagnostics.Contracts {
         /// </summary>
         [Conditional("CONTRACTS_FULL")]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 #endif
         public static void EndContractBlock() { }
 
@@ -826,7 +803,6 @@ namespace System.Diagnostics.Contracts.Internal
         [SuppressMessage("Microsoft.Design", "CA1030:UseEventsWhereAppropriate")]
         [System.Diagnostics.DebuggerNonUserCode]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 #endif
         public static string RaiseContractFailedEvent(ContractFailureKind failureKind, String userMessage, String conditionText, Exception innerException)
         {
@@ -838,7 +814,6 @@ namespace System.Diagnostics.Contracts.Internal
         /// </summary>
         [System.Diagnostics.DebuggerNonUserCode]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 #endif
         public static void TriggerFailure(ContractFailureKind kind, String displayMessage, String userMessage, String conditionText, Exception innerException)
         {
@@ -865,7 +840,6 @@ namespace System.Runtime.CompilerServices
         [SuppressMessage("Microsoft.Design", "CA1030:UseEventsWhereAppropriate")]
         [System.Diagnostics.DebuggerNonUserCode]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 #endif
         public static string RaiseContractFailedEvent(ContractFailureKind failureKind, String userMessage, String conditionText, Exception innerException)
         {
@@ -880,7 +854,6 @@ namespace System.Runtime.CompilerServices
         /// </summary>
         [System.Diagnostics.DebuggerNonUserCode]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 #endif
         public static void TriggerFailure(ContractFailureKind kind, String displayMessage, String userMessage, String conditionText, Exception innerException)
         {
diff --git a/src/mscorlib/src/System/Diagnostics/Contracts/ContractsBCL.cs b/src/mscorlib/src/System/Diagnostics/Contracts/ContractsBCL.cs
index fe574b98ce..5f4de4f666 100644
--- a/src/mscorlib/src/System/Diagnostics/Contracts/ContractsBCL.cs
+++ b/src/mscorlib/src/System/Diagnostics/Contracts/ContractsBCL.cs
@@ -35,7 +35,6 @@ using System.Runtime.ConstrainedExecution;
 #endif
 #if FEATURE_UNTRUSTED_CALLERS
 using System.Security;
-using System.Security.Permissions;
 #endif
 
 namespace System.Diagnostics.Contracts {
@@ -93,7 +92,6 @@ namespace System.Diagnostics.Contracts {
         [SuppressMessage("Microsoft.Portability", "CA1903:UseOnlyApiFromTargetedFramework", MessageId = "System.Security.SecuritySafeCriticalAttribute")]
         [System.Diagnostics.DebuggerNonUserCode]
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 #endif
         static partial void ReportFailure(ContractFailureKind failureKind, String userMessage, String conditionText, Exception innerException)
         {
@@ -145,7 +143,6 @@ namespace System.Diagnostics.Contracts {
         internal Exception thrownDuringHandler;
 
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 #endif
         public ContractFailedEventArgs(ContractFailureKind failureKind, String message, String condition, Exception originalException)
         {
@@ -422,7 +419,6 @@ namespace System.Runtime.CompilerServices
         }
 
 #if FEATURE_RELIABILITY_CONTRACTS
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 #endif
         private static String GetDisplayMessage(ContractFailureKind failureKind, String userMessage, String conditionText)
         {
diff --git a/src/mscorlib/src/System/Diagnostics/Debugger.cs b/src/mscorlib/src/System/Diagnostics/Debugger.cs
index 8ebbc0a354..21c57dbfaf 100644
--- a/src/mscorlib/src/System/Diagnostics/Debugger.cs
+++ b/src/mscorlib/src/System/Diagnostics/Debugger.cs
@@ -13,11 +13,9 @@ namespace System.Diagnostics
     using System.Reflection;
     using System.Runtime.CompilerServices;
     using System.Security;
-    using System.Security.Permissions;
     using System.Runtime.Versioning;
 
     // No data, does not need to be marked with the serializable attribute
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class Debugger
     {
         // This should have been a static class, but wasn't as of v3.5.  Clearly, this is
@@ -34,42 +32,12 @@ namespace System.Diagnostics
         // debugger is launched.
         public static void Break()
         {
-            if (!Debugger.IsAttached)
-            {
-                // Try and demand UnmanagedCodePermission.  This is done in a try block because if this
-                // fails we want to be able to silently eat the exception and just return so
-                // that the call to Break does not possibly cause an unhandled exception.
-                // The idea here is that partially trusted code shouldn't be able to launch a debugger 
-                // without the user going through Watson.
-                try
-                {
-#pragma warning disable 618
-                    new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
-#pragma warning restore 618
-                }
-
-                // If we enter this block, we do not have permission to break into the debugger
-                // and so we just return.
-                catch (SecurityException)
-                {
-                    return;
-                }
-            }
-
             // Causing a break is now allowed.
             BreakInternal();
         }
 
         static void BreakCanThrow()
         {
-            if (!Debugger.IsAttached)
-            {
-#pragma warning disable 618
-                new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
-#pragma warning restore 618
-            }
-
-            // Causing a break is now allowed.
             BreakInternal();
         }
 
@@ -84,25 +52,6 @@ namespace System.Diagnostics
             if (Debugger.IsAttached)
                 return (true);
 
-            // Try and demand UnmanagedCodePermission.  This is done in a try block because if this
-            // fails we want to be able to silently eat the exception and just return so
-            // that the call to Break does not possibly cause an unhandled exception.
-            // The idea here is that partially trusted code shouldn't be able to launch a debugger 
-            // without the user going through Watson.
-            try
-            {
-#pragma warning disable 618
-                new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
-#pragma warning restore 618
-            }
-
-            // If we enter this block, we do not have permission to break into the debugger
-            // and so we just return.
-            catch (SecurityException)
-            {
-                return (false);
-            }
-
             // Causing the debugger to launch is now allowed.
             return (LaunchInternal());
         }
@@ -134,7 +83,6 @@ namespace System.Diagnostics
         // notification will apprise the debugger that it will need  to slip a thread or abort the funceval 
         // in such a situation. The notification is subject to collection after this function returns. 
         // 
-        [method:System.Runtime.InteropServices.ComVisible(false)]
         public static void NotifyOfCrossThreadDependency()
         {
             if (Debugger.IsAttached)
diff --git a/src/mscorlib/src/System/Diagnostics/DebuggerAttributes.cs b/src/mscorlib/src/System/Diagnostics/DebuggerAttributes.cs
index 6f8bf7a975..ce9987b9e2 100644
--- a/src/mscorlib/src/System/Diagnostics/DebuggerAttributes.cs
+++ b/src/mscorlib/src/System/Diagnostics/DebuggerAttributes.cs
@@ -19,7 +19,6 @@ namespace System.Diagnostics {
     
 [Serializable]
 [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Constructor, Inherited = false)]
-    [ComVisible(true)]
     public sealed class DebuggerStepThroughAttribute : Attribute
     {
         public DebuggerStepThroughAttribute () {}
@@ -27,7 +26,6 @@ namespace System.Diagnostics {
 
 [Serializable]
 [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Constructor, Inherited = false)]
-    [ComVisible(true)]
     public sealed class DebuggerHiddenAttribute : Attribute
     {
         public DebuggerHiddenAttribute () {}
@@ -35,7 +33,6 @@ namespace System.Diagnostics {
 
 [Serializable]
 [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Constructor |AttributeTargets.Struct, Inherited = false)]
-    [ComVisible(true)]
     public sealed class DebuggerNonUserCodeAttribute : Attribute
     {
        public DebuggerNonUserCodeAttribute () {}
@@ -50,11 +47,9 @@ namespace System.Diagnostics {
     // won't preserve the debugging info, which will make debugging after
     // a JIT attach difficult.
     [AttributeUsage(AttributeTargets.Assembly|AttributeTargets.Module, AllowMultiple = false)]
-    [ComVisible(true)]
     public sealed class DebuggableAttribute : Attribute
     {
         [Flags]
-        [ComVisible(true)]
         public enum DebuggingModes 
         {
             None = 0x0,
@@ -113,7 +108,6 @@ namespace System.Diagnostics {
 
     //  Please also change the code which validates DebuggerBrowsableState variable (in this file)
     //  if you change this enum.
-    [ComVisible(true)]
     public enum DebuggerBrowsableState 
     { 
         Never = 0, 
@@ -127,7 +121,6 @@ namespace System.Diagnostics {
     // the one currently supported with the csee.dat 
     // (mcee.dat, autoexp.dat) file. 
     [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false)]
-    [ComVisible(true)]
     public sealed class DebuggerBrowsableAttribute: Attribute
     {
         private DebuggerBrowsableState state;
@@ -148,7 +141,6 @@ namespace System.Diagnostics {
 
     // DebuggerTypeProxyAttribute
     [AttributeUsage(AttributeTargets.Struct | AttributeTargets.Class | AttributeTargets.Assembly, AllowMultiple = true)]
-    [ComVisible(true)]
     public sealed class DebuggerTypeProxyAttribute: Attribute
     {
         private string typeName;
@@ -207,7 +199,6 @@ namespace System.Diagnostics {
     // however: there is no access to aliases, locals, or pointers. 
     // In addition, attributes on properties referenced in the expression are not processed.
     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Delegate | AttributeTargets.Enum | AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Assembly, AllowMultiple = true)]
-    [ComVisible(true)]
     public sealed class DebuggerDisplayAttribute : Attribute
     {
         private string name;
diff --git a/src/mscorlib/src/System/Diagnostics/Eventing/EventDescriptor.cs b/src/mscorlib/src/System/Diagnostics/Eventing/EventDescriptor.cs
index 11b6e6bac2..116b50f86c 100644
--- a/src/mscorlib/src/System/Diagnostics/Eventing/EventDescriptor.cs
+++ b/src/mscorlib/src/System/Diagnostics/Eventing/EventDescriptor.cs
@@ -22,7 +22,9 @@ namespace System.Diagnostics.Tracing
 #endif
 {
     [StructLayout(LayoutKind.Explicit, Size = 16)]
+#if !CORECLR    
     [System.Security.Permissions.HostProtection(MayLeakOnAbort = true)]
+#endif // CORECLR    
     internal struct EventDescriptor
     {
         # region private
diff --git a/src/mscorlib/src/System/Diagnostics/Eventing/EventProvider.cs b/src/mscorlib/src/System/Diagnostics/Eventing/EventProvider.cs
index 175f0f16b2..1da6a46707 100644
--- a/src/mscorlib/src/System/Diagnostics/Eventing/EventProvider.cs
+++ b/src/mscorlib/src/System/Diagnostics/Eventing/EventProvider.cs
@@ -8,7 +8,9 @@ using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Runtime.InteropServices;
 using System.Security;
+#if !CORECLR
 using System.Security.Permissions;
+#endif // !CORECLR
 using System.Threading;
 using System;
 
@@ -43,7 +45,9 @@ namespace System.Diagnostics.Tracing
     /// Only here because System.Diagnostics.EventProvider needs one more extensibility hook (when it gets a 
     /// controller callback)
     /// </summary>
+#if !CORECLR    
     [System.Security.Permissions.HostProtection(MayLeakOnAbort = true)]
+#endif // CORECLR
     internal partial class EventProvider : IDisposable
     {
         // This is the windows EVENT_DATA_DESCRIPTOR structure.  We expose it because this is what
@@ -559,7 +563,9 @@ namespace System.Diagnostics.Tracing
                 string valueName = "ControllerData_Session_" + etwSessionId.ToString(CultureInfo.InvariantCulture);
 
                 // we need to assert this permission for partial trust scenarios
+#if !CORECLR
                 (new RegistryPermission(RegistryPermissionAccess.Read, regKey)).Assert();
+#endif
                 data = Microsoft.Win32.Registry.GetValue(regKey, valueName, null) as byte[];
                 if (data != null)
                 {
diff --git a/src/mscorlib/src/System/Diagnostics/Eventing/EventSource.cs b/src/mscorlib/src/System/Diagnostics/Eventing/EventSource.cs
index c20e3bdf70..a558a1647e 100644
--- a/src/mscorlib/src/System/Diagnostics/Eventing/EventSource.cs
+++ b/src/mscorlib/src/System/Diagnostics/Eventing/EventSource.cs
@@ -15,6 +15,7 @@
 #endif // !PLATFORM_UNIX
 
 #if ES_BUILD_STANDALONE
+#define FEATURE_MANAGED_ETW_CHANNELS
 // #define FEATURE_ADVANCED_MANAGED_ETW_CHANNELS
 #endif
 
@@ -186,7 +187,9 @@ using System.Globalization;
 using System.Reflection;
 using System.Resources;
 using System.Security;
+#if !CORECLR
 using System.Security.Permissions;
+#endif // !CORECLR
 
 using System.Text;
 using System.Threading;
@@ -2346,7 +2349,11 @@ namespace System.Diagnostics.Tracing
             EventLevel eventLevel = (EventLevel)m_eventData[eventNum].Descriptor.Level;
             EventKeywords eventKeywords = unchecked((EventKeywords)((ulong)m_eventData[eventNum].Descriptor.Keywords & (~(SessionMask.All.ToEventKeywords()))));
 
+#if FEATURE_MANAGED_ETW_CHANNELS
             EventChannel channel = unchecked((EventChannel)m_eventData[eventNum].Descriptor.Channel);
+#else
+            EventChannel channel = EventChannel.None;
+#endif
 
             return IsEnabledCommon(enable, currentLevel, currentMatchAnyKeyword, eventLevel, eventKeywords, channel);
         }
@@ -2364,6 +2371,7 @@ namespace System.Diagnostics.Tracing
             // if yes, does it pass the keywords test?
             if (currentMatchAnyKeyword != 0 && eventKeywords != 0)
             {
+#if FEATURE_MANAGED_ETW_CHANNELS
                 // is there a channel with keywords that match currentMatchAnyKeyword?
                 if (eventChannel != EventChannel.None && this.m_channelData != null && this.m_channelData.Length > (int)eventChannel)
                 {
@@ -2372,6 +2380,7 @@ namespace System.Diagnostics.Tracing
                         return false;
                 }
                 else
+#endif
                 {
                     if ((unchecked((ulong)eventKeywords & (ulong)currentMatchAnyKeyword)) == 0)
                         return false;
@@ -3040,7 +3049,7 @@ namespace System.Diagnostics.Tracing
             }
             if (s_currentPid == 0)
             {
-#if ES_BUILD_STANDALONE && !ES_BUILD_PCL
+#if ES_BUILD_STANDALONE && !ES_BUILD_PCL && !CORECLR
                 // for non-BCL EventSource we must assert SecurityPermission
                 new SecurityPermission(PermissionState.Unrestricted).Assert();
 #endif
@@ -3322,7 +3331,11 @@ namespace System.Diagnostics.Tracing
                 }
 
                 // Collect task, opcode, keyword and channel information
+#if FEATURE_MANAGED_ETW_CHANNELS && FEATURE_ADVANCED_MANAGED_ETW_CHANNELS
+                foreach (var providerEnumKind in new string[] { "Keywords", "Tasks", "Opcodes", "Channels" })
+#else
                 foreach (var providerEnumKind in new string[] { "Keywords", "Tasks", "Opcodes" })
+#endif
                 {
                     Type nestedType = eventSourceType.GetNestedType(providerEnumKind);
                     if (nestedType != null)
@@ -3484,6 +3497,7 @@ namespace System.Diagnostics.Tracing
                             // Do checking for user errors (optional, but not a big deal so we do it).  
                             DebugCheckEvent(ref eventsByName, eventData, method, eventAttribute, manifest, flags);
 
+#if FEATURE_MANAGED_ETW_CHANNELS
                             // add the channel keyword for Event Viewer channel based filters. This is added for creating the EventDescriptors only
                             // and is not required for the manifest
                             if (eventAttribute.Channel != EventChannel.None)
@@ -3493,6 +3507,7 @@ namespace System.Diagnostics.Tracing
                                     eventAttribute.Keywords |= (EventKeywords)manifest.GetChannelKeyword(eventAttribute.Channel, (ulong)eventAttribute.Keywords);
                                 }
                             }
+#endif
                             string eventKey = "event_" + eventName;
                             string msg = manifest.GetLocalizedMessage(eventKey, CultureInfo.CurrentUICulture, etwFormat: false);
                             // overwrite inline message with the localized message
@@ -3510,14 +3525,18 @@ namespace System.Diagnostics.Tracing
                 {
                     TrimEventDescriptors(ref eventData);
                     source.m_eventData = eventData;     // officially initialize it. We do this at most once (it is racy otherwise). 
+#if FEATURE_MANAGED_ETW_CHANNELS
                     source.m_channelData = manifest.GetChannelData();
+#endif
                 }
 
                 // if this is an abstract event source we've already performed all the validation we can
                 if (!eventSourceType.IsAbstract() && (source == null || !source.SelfDescribingEvents))
                 {
                     bNeedsManifest = (flags & EventManifestOptions.OnlyIfNeededForRegistration) == 0
+#if FEATURE_MANAGED_ETW_CHANNELS
                                             || manifest.GetChannelData().Length > 0
+#endif
 ;
 
                     // if the manifest is not needed and we're not requested to validate the event source return early
@@ -3599,6 +3618,14 @@ namespace System.Diagnostics.Tracing
                 ulong value = unchecked((ulong)(long)staticField.GetRawConstantValue());
                 manifest.AddKeyword(staticField.Name, value);
             }
+#if FEATURE_MANAGED_ETW_CHANNELS && FEATURE_ADVANCED_MANAGED_ETW_CHANNELS
+            else if (!reflectionOnly && (staticFieldType == typeof(EventChannel)) || AttributeTypeNamesMatch(staticFieldType, typeof(EventChannel)))
+            {
+                if (providerEnumKind != "Channels") goto Error;
+                var channelAttribute = (EventChannelAttribute)GetCustomAttributeHelper(staticField, typeof(EventChannelAttribute));
+                manifest.AddChannel(staticField.Name, (byte)staticField.GetRawConstantValue(), channelAttribute);
+            }
+#endif
             return;
             Error:
             manifest.ManifestError(Resources.GetResourceString("EventSource_EnumKindMismatch", staticField.Name, staticField.FieldType.Name, providerEnumKind));
@@ -3621,7 +3648,11 @@ namespace System.Diagnostics.Tracing
             eventData[eventAttribute.EventId].Descriptor = new EventDescriptor(
                     eventAttribute.EventId,
                     eventAttribute.Version,
+#if FEATURE_MANAGED_ETW_CHANNELS
                     (byte)eventAttribute.Channel,
+#else
+                    (byte)0,
+#endif
                     (byte)eventAttribute.Level,
                     (byte)eventAttribute.Opcode,
                     (int)eventAttribute.Task,
@@ -3774,7 +3805,9 @@ namespace System.Diagnostics.Tracing
             // RET
             // 
             // If we find this pattern we return the XXX.  Otherwise we return -1.  
+#if !CORECLR
             (new ReflectionPermission(ReflectionPermissionFlag.MemberAccess)).Assert();
+#endif
             byte[] instrs = method.GetMethodBody().GetILAsByteArray();
             int retVal = -1;
             for (int idx = 0; idx < instrs.Length;)
@@ -3881,6 +3914,17 @@ namespace System.Diagnostics.Tracing
             return -1;
         }
 
+#if false // This routine is not needed at all, it was used for unit test debugging. 
+        [Conditional("DEBUG")]
+        private static void OutputDebugString(string msg)
+        {
+#if !ES_BUILD_PCL
+            msg = msg.TrimEnd('\r', '\n') +
+                    string.Format(CultureInfo.InvariantCulture, ", Thrd({0})" + Environment.NewLine, Thread.CurrentThread.ManagedThreadId);
+            System.Diagnostics.Debugger.Log(0, null, msg);
+#endif
+        }
+#endif
 
         /// <summary>
         /// Sends an error message to the debugger (outputDebugString), as well as the EventListeners 
@@ -4041,7 +4085,9 @@ namespace System.Diagnostics.Tracing
         [ThreadStatic]
         private static bool m_EventSourceInDecodeObject = false;
 
+#if FEATURE_MANAGED_ETW_CHANNELS
         internal volatile ulong[] m_channelData;
+#endif
 
 #if FEATURE_ACTIVITYSAMPLING
         private SessionMask m_curLiveSessions;          // the activity-tracing aware sessions' bits
@@ -4863,6 +4909,7 @@ namespace System.Diagnostics.Tracing
         }
 
 
+#if FEATURE_MANAGED_ETW_CHANNELS
         /// <summary>
         /// Gets the channel for the event.
         /// </summary>
@@ -4875,6 +4922,7 @@ namespace System.Diagnostics.Tracing
                 return (EventChannel)m_eventSource.m_eventData[EventId].Descriptor.Channel;
             }
         }
+#endif
 
         /// <summary>
         /// Gets the version of the event.
@@ -5002,8 +5050,10 @@ namespace System.Diagnostics.Tracing
 
         /// <summary>Event's task: allows logical grouping of events</summary>
         public EventTask Task { get; set; }
+#if FEATURE_MANAGED_ETW_CHANNELS
         /// <summary>Event's channel: defines an event log as an additional destination for the event</summary>
         public EventChannel Channel { get; set; }
+#endif
         /// <summary>Event's version</summary>
         public byte Version { get; set; }
 
@@ -5046,6 +5096,7 @@ namespace System.Diagnostics.Tracing
     }
 
     // FUTURE we may want to expose this at some point once we have a partner that can help us validate the design.
+#if FEATURE_MANAGED_ETW_CHANNELS
     /// <summary>
     /// EventChannelAttribute allows customizing channels supported by an EventSource. This attribute must be
     /// applied to an member of type EventChannel defined in a Channels class nested in the EventSource class:
@@ -5061,6 +5112,9 @@ namespace System.Diagnostics.Tracing
     /// </code>
     /// </summary>
     [AttributeUsage(AttributeTargets.Field)]
+#if FEATURE_ADVANCED_MANAGED_ETW_CHANNELS
+    public 
+#endif
     class EventChannelAttribute : Attribute
     {
         /// <summary>
@@ -5073,6 +5127,23 @@ namespace System.Diagnostics.Tracing
         /// </summary>
         public EventChannelType EventChannelType { get; set; }
 
+#if FEATURE_ADVANCED_MANAGED_ETW_CHANNELS
+        /// <summary>
+        /// Specifies the isolation for the channel
+        /// </summary>
+        public EventChannelIsolation Isolation { get; set; }
+
+        /// <summary>
+        /// Specifies an SDDL access descriptor that controls access to the log file that backs the channel.
+        /// See MSDN ((http://msdn.microsoft.com/en-us/library/windows/desktop/aa382741.aspx) for details.
+        /// </summary>
+        public string Access { get; set; } 
+
+        /// <summary>
+        /// Allows importing channels defined in external manifests
+        /// </summary>
+        public string ImportChannel { get; set; }
+#endif
 
         // TODO: there is a convention that the name is the Provider/Type   Should we provide an override?
         // public string Name { get; set; }
@@ -5081,6 +5152,9 @@ namespace System.Diagnostics.Tracing
     /// <summary>
     /// Allowed channel types
     /// </summary>
+#if FEATURE_ADVANCED_MANAGED_ETW_CHANNELS
+    public 
+#endif
     enum EventChannelType
     {
         /// <summary>The admin channel</summary>
@@ -5093,6 +5167,32 @@ namespace System.Diagnostics.Tracing
         Debug,
     }
 
+#if FEATURE_ADVANCED_MANAGED_ETW_CHANNELS
+    /// <summary>
+    /// Allowed isolation levels. See MSDN (http://msdn.microsoft.com/en-us/library/windows/desktop/aa382741.aspx) 
+    /// for the default permissions associated with each level. EventChannelIsolation and Access allows control over the 
+    /// access permissions for the channel and backing file.
+    /// </summary>
+    public 
+    enum EventChannelIsolation
+    {
+        /// <summary>
+        /// This is the default isolation level. All channels that specify Application isolation use the same ETW session
+        /// </summary>
+        Application = 1,
+        /// <summary>
+        /// All channels that specify System isolation use the same ETW session
+        /// </summary>
+        System,
+        /// <summary>
+        /// Use sparingly! When specifying Custom isolation, a separate ETW session is created for the channel.
+        /// Using Custom isolation lets you control the access permissions for the channel and backing file.
+        /// Because there are only 64 ETW sessions available, you should limit your use of Custom isolation.
+        /// </summary>
+        Custom,
+    }
+#endif
+#endif
 
     /// <summary>
     /// Describes the pre-defined command (EventCommandEventArgs.Command property) that is passed to the OnEventCommand callback.
@@ -5910,7 +6010,9 @@ namespace System.Diagnostics.Tracing
         public ManifestBuilder(string providerName, Guid providerGuid, string dllName, ResourceManager resources,
                                EventManifestOptions flags)
         {
+#if FEATURE_MANAGED_ETW_CHANNELS
             this.providerName = providerName;
+#endif
             this.flags = flags;
 
             this.resources = resources;
@@ -5992,6 +6094,7 @@ namespace System.Diagnostics.Tracing
             keywordTab[value] = name;
         }
 
+#if FEATURE_MANAGED_ETW_CHANNELS
         /// <summary>
         /// Add a channel.  channelAttribute can be null
         /// </summary>
@@ -6061,6 +6164,7 @@ namespace System.Diagnostics.Tracing
             return channelMask;
         }
 
+#endif
         public void StartEvent(string eventName, EventAttribute eventAttribute)
         {
             Debug.Assert(numParams == 0);
@@ -6086,10 +6190,12 @@ namespace System.Diagnostics.Tracing
                 events.Append(" opcode=\"").Append(GetOpcodeName(eventAttribute.Opcode, eventName)).Append("\"");
             if (eventAttribute.Task != 0)
                 events.Append(" task=\"").Append(GetTaskName(eventAttribute.Task, eventName)).Append("\"");
+#if FEATURE_MANAGED_ETW_CHANNELS
             if (eventAttribute.Channel != 0)
             {
                 events.Append(" channel=\"").Append(GetChannelName(eventAttribute.Channel, eventName, eventAttribute.Message)).Append("\"");
             }
+#endif
         }
 
         public void AddEventParameter(Type type, string name)
@@ -6155,6 +6261,7 @@ namespace System.Diagnostics.Tracing
             byteArrArgIndices = null;
         }
 
+#if FEATURE_MANAGED_ETW_CHANNELS
         // Channel keywords are generated one per channel to allow channel based filtering in event viewer. These keywords are autogenerated
         // by mc.exe for compiling a manifest and are based on the order of the channels (fields) in the Channels inner class (when advanced
         // channel support is enabled), or based on the order the predefined channels appear in the EventAttribute properties (for simple 
@@ -6194,6 +6301,7 @@ namespace System.Diagnostics.Tracing
 
             return channelKeyword;
         }
+#endif
 
         public byte[] CreateManifest()
         {
@@ -6221,6 +6329,7 @@ namespace System.Diagnostics.Tracing
         private string CreateManifestString()
         {
 
+#if FEATURE_MANAGED_ETW_CHANNELS
             // Write out the channels
             if (channelTab != null)
             {
@@ -6237,12 +6346,26 @@ namespace System.Diagnostics.Tracing
                     string elementName = "channel";
                     bool enabled = false;
                     string fullName = null;
+#if FEATURE_ADVANCED_MANAGED_ETW_CHANNELS
+                    string isolation = null;
+                    string access = null;
+#endif
                     if (channelInfo.Attribs != null)
                     {
                         var attribs = channelInfo.Attribs;
                         if (Enum.IsDefined(typeof(EventChannelType), attribs.EventChannelType))
                             channelType = attribs.EventChannelType.ToString();
                         enabled = attribs.Enabled;
+#if FEATURE_ADVANCED_MANAGED_ETW_CHANNELS
+                        if (attribs.ImportChannel != null)
+                        {
+                            fullName = attribs.ImportChannel;
+                            elementName = "importChannel";
+                        }
+                        if (Enum.IsDefined(typeof(EventChannelIsolation), attribs.Isolation))
+                            isolation = attribs.Isolation.ToString();
+                        access = attribs.Access;
+#endif
                     }
                     if (fullName == null)
                         fullName = providerName + "/" + channelInfo.Name;
@@ -6257,11 +6380,18 @@ namespace System.Diagnostics.Tracing
                         if (channelType != null)
                             sb.Append(" type=\"").Append(channelType).Append("\"");
                         sb.Append(" enabled=\"").Append(enabled.ToString().ToLower()).Append("\"");
+#if FEATURE_ADVANCED_MANAGED_ETW_CHANNELS
+                        if (access != null)
+                            sb.Append(" access=\"").Append(access).Append("\"");
+                        if (isolation != null)
+                            sb.Append(" isolation=\"").Append(isolation).Append("\"");
+#endif
                     }
                     sb.Append("/>").AppendLine();
                 }
                 sb.Append(" </channels>").AppendLine();
             }
+#endif
 
             // Write out the tasks
             if (taskTab != null)
@@ -6484,6 +6614,7 @@ namespace System.Diagnostics.Tracing
             return (((int)level >= 16) ? "" : "win:") + level.ToString();
         }
 
+#if FEATURE_MANAGED_ETW_CHANNELS
         private string GetChannelName(EventChannel channel, string eventName, string eventMessage)
         {
             ChannelInfo info = null;
@@ -6512,6 +6643,7 @@ namespace System.Diagnostics.Tracing
                 ManifestError(Resources.GetResourceString("EventSource_EventWithAdminChannelMustHaveMessage", eventName, info.Name));
             return info.Name;
         }
+#endif
         private string GetTaskName(EventTask task, string eventName)
         {
             if (task == EventTask.None)
@@ -6707,21 +6839,26 @@ namespace System.Diagnostics.Tracing
             return idx + 1;
         }
 
+#if FEATURE_MANAGED_ETW_CHANNELS
         class ChannelInfo
         {
             public string Name;
             public ulong Keywords;
             public EventChannelAttribute Attribs;
         }
+#endif
 
         Dictionary<int, string> opcodeTab;
         Dictionary<int, string> taskTab;
+#if FEATURE_MANAGED_ETW_CHANNELS
         Dictionary<int, ChannelInfo> channelTab;
+#endif
         Dictionary<ulong, string> keywordTab;
         Dictionary<string, Type> mapsTab;
 
         Dictionary<string, string> stringTab;       // Maps unlocalized strings to localized ones  
 
+#if FEATURE_MANAGED_ETW_CHANNELS
         // WCF used EventSource to mimic a existing ETW manifest.   To support this
         // in just their case, we allowed them to specify the keywords associated 
         // with their channels explicitly.   ValidPredefinedChannelKeywords is 
@@ -6730,12 +6867,15 @@ namespace System.Diagnostics.Tracing
         internal const ulong ValidPredefinedChannelKeywords = 0xF000000000000000;
         ulong nextChannelKeywordBit = 0x8000000000000000;   // available Keyword bit to be used for next channel definition, grows down
         const int MaxCountChannels = 8; // a manifest can defined at most 8 ETW channels
+#endif
 
         StringBuilder sb;               // Holds the provider information. 
         StringBuilder events;           // Holds the events. 
         StringBuilder templates;
 
+#if FEATURE_MANAGED_ETW_CHANNELS
         string providerName;
+#endif
         ResourceManager resources;      // Look up localized strings here.  
         EventManifestOptions flags;
         IList<string> errors;           // list of currently encountered errors
diff --git a/src/mscorlib/src/System/Diagnostics/Eventing/FrameworkEventSource.cs b/src/mscorlib/src/System/Diagnostics/Eventing/FrameworkEventSource.cs
index 6d3e28fcab..80c524b350 100644
--- a/src/mscorlib/src/System/Diagnostics/Eventing/FrameworkEventSource.cs
+++ b/src/mscorlib/src/System/Diagnostics/Eventing/FrameworkEventSource.cs
@@ -86,7 +86,10 @@ namespace System.Diagnostics.Tracing {
         // WriteEvent overloads (to avoid the "params" EventSource.WriteEvent
 
         // optimized for common signatures (used by the ThreadTransferSend/Receive events)
-        [NonEvent, System.Security.SecuritySafeCritical]
+        [NonEvent]
+#if !CORECLR
+        [System.Security.SecuritySafeCritical]
+#endif // !CORECLR
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Concurrency", "CA8001", Justification = "This does not need to be correct when racing with other threads")]
         private unsafe void WriteEvent(int eventId, long arg1, int arg2, string arg3, bool arg4)
         {
@@ -110,7 +113,10 @@ namespace System.Diagnostics.Tracing {
         }
 
         // optimized for common signatures (used by the ThreadTransferSend/Receive events)
-        [NonEvent, System.Security.SecuritySafeCritical]
+        [NonEvent]
+#if !CORECLR
+        [System.Security.SecuritySafeCritical]
+#endif // !CORECLR
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Concurrency", "CA8001", Justification = "This does not need to be correct when racing with other threads")]
         private unsafe void WriteEvent(int eventId, long arg1, int arg2, string arg3)
         {
@@ -132,7 +138,10 @@ namespace System.Diagnostics.Tracing {
         }
 
         // optimized for common signatures (used by the BeginGetResponse/BeginGetRequestStream events)
-        [NonEvent, System.Security.SecuritySafeCritical]
+        [NonEvent]
+#if !CORECLR
+        [System.Security.SecuritySafeCritical]
+#endif // !CORECLR
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Concurrency", "CA8001", Justification = "This does not need to be correct when racing with other threads")]
         private unsafe void WriteEvent(int eventId, long arg1, string arg2, bool arg3, bool arg4)
         {
@@ -156,7 +165,10 @@ namespace System.Diagnostics.Tracing {
         }
 
         // optimized for common signatures (used by the EndGetRequestStream event)
-        [NonEvent, System.Security.SecuritySafeCritical]
+        [NonEvent]
+#if !CORECLR
+        [System.Security.SecuritySafeCritical]
+#endif // !CORECLR
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Concurrency", "CA8001", Justification = "This does not need to be correct when racing with other threads")]
         private unsafe void WriteEvent(int eventId, long arg1, bool arg2, bool arg3)
         {
@@ -174,7 +186,10 @@ namespace System.Diagnostics.Tracing {
         }
 
         // optimized for common signatures (used by the EndGetResponse event)
-        [NonEvent, System.Security.SecuritySafeCritical]
+        [NonEvent]
+#if !CORECLR
+        [System.Security.SecuritySafeCritical]
+#endif // !CORECLR
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Concurrency", "CA8001", Justification = "This does not need to be correct when racing with other threads")]
         private unsafe void WriteEvent(int eventId, long arg1, bool arg2, bool arg3, int arg4)
         {
@@ -479,7 +494,10 @@ namespace System.Diagnostics.Tracing {
         public void ThreadPoolEnqueueWork(long workID) {
             WriteEvent(30, workID);
         }
-        [NonEvent, System.Security.SecuritySafeCritical]
+        [NonEvent]
+#if !CORECLR
+        [System.Security.SecuritySafeCritical]
+#endif // !CORECLR
         public unsafe void ThreadPoolEnqueueWorkObject(object workID) {
             // convert the Object Id to a long
             ThreadPoolEnqueueWork((long) *((void**) JitHelpers.UnsafeCastToStackPointer(ref workID)));
@@ -490,7 +508,10 @@ namespace System.Diagnostics.Tracing {
             WriteEvent(31, workID);
         }
 
-        [NonEvent, System.Security.SecuritySafeCritical]
+        [NonEvent]
+#if !CORECLR
+        [System.Security.SecuritySafeCritical]
+#endif // !CORECLR
         public unsafe void ThreadPoolDequeueWorkObject(object workID) {
             // convert the Object Id to a long
             ThreadPoolDequeueWork((long) *((void**) JitHelpers.UnsafeCastToStackPointer(ref workID)));
@@ -524,25 +545,37 @@ namespace System.Diagnostics.Tracing {
             WriteEvent(143, id, success, synchronous);
         }
 
-        [NonEvent, System.Security.SecuritySafeCritical]
+        [NonEvent]
+#if !CORECLR
+        [System.Security.SecuritySafeCritical]
+#endif // !CORECLR
         public unsafe void BeginGetResponse(object id, string uri, bool success, bool synchronous) {
             if (IsEnabled())
                 GetResponseStart(IdForObject(id), uri, success, synchronous);
         }
             
-        [NonEvent, System.Security.SecuritySafeCritical]
+        [NonEvent]
+#if !CORECLR
+        [System.Security.SecuritySafeCritical]
+#endif // !CORECLR
         public unsafe void EndGetResponse(object id, bool success, bool synchronous, int statusCode) {
             if (IsEnabled())
                 GetResponseStop(IdForObject(id), success, synchronous, statusCode);
         }
 
-        [NonEvent, System.Security.SecuritySafeCritical]
+        [NonEvent]
+#if !CORECLR
+        [System.Security.SecuritySafeCritical]
+#endif // !CORECLR
         public unsafe void BeginGetRequestStream(object id, string uri, bool success, bool synchronous) {
             if (IsEnabled())
                 GetRequestStreamStart(IdForObject(id), uri, success, synchronous);
         }
 
-        [NonEvent, System.Security.SecuritySafeCritical]
+        [NonEvent]
+#if !CORECLR
+        [System.Security.SecuritySafeCritical]
+#endif // !CORECLR
         public unsafe void EndGetRequestStream(object id, bool success, bool synchronous) {
             if (IsEnabled())
                 GetRequestStreamStop(IdForObject(id), success, synchronous);
@@ -563,7 +596,10 @@ namespace System.Diagnostics.Tracing {
         // id - is a managed object. it gets translated to the object's address. ETW listeners must
         //      keep track of GC movements in order to correlate the value passed to XyzSend with the
         //      (possibly changed) value passed to XyzReceive
-        [NonEvent, System.Security.SecuritySafeCritical]
+        [NonEvent]
+#if !CORECLR
+        [System.Security.SecuritySafeCritical]
+#endif // !CORECLR
         public unsafe void ThreadTransferSendObj(object id, int kind, string info, bool multiDequeues) {
             ThreadTransferSend((long) *((void**) JitHelpers.UnsafeCastToStackPointer(ref id)), kind, info, multiDequeues);
         }
@@ -583,7 +619,10 @@ namespace System.Diagnostics.Tracing {
         // id - is a managed object. it gets translated to the object's address. ETW listeners must
         //      keep track of GC movements in order to correlate the value passed to XyzSend with the
         //      (possibly changed) value passed to XyzReceive
-        [NonEvent, System.Security.SecuritySafeCritical]
+        [NonEvent]
+#if !CORECLR
+        [System.Security.SecuritySafeCritical]
+#endif // !CORECLR
         public unsafe void ThreadTransferReceiveObj(object id, int kind, string info) {
             ThreadTransferReceive((long) *((void**) JitHelpers.UnsafeCastToStackPointer(ref id)), kind, info);
         }
@@ -603,7 +642,10 @@ namespace System.Diagnostics.Tracing {
         // id - is a managed object. it gets translated to the object's address. ETW listeners must
         //      keep track of GC movements in order to correlate the value passed to XyzSend with the
         //      (possibly changed) value passed to XyzReceive
-        [NonEvent, System.Security.SecuritySafeCritical]
+        [NonEvent]
+#if !CORECLR
+        [System.Security.SecuritySafeCritical]
+#endif // !CORECLR
         public unsafe void ThreadTransferReceiveHandledObj(object id, int kind, string info) {
             ThreadTransferReceive((long) *((void**) JitHelpers.UnsafeCastToStackPointer(ref id)), kind, info);
         }
diff --git a/src/mscorlib/src/System/Diagnostics/Eventing/TraceLogging/EventFieldFormat.cs b/src/mscorlib/src/System/Diagnostics/Eventing/TraceLogging/EventFieldFormat.cs
index 297b06334d..fd77b07965 100644
--- a/src/mscorlib/src/System/Diagnostics/Eventing/TraceLogging/EventFieldFormat.cs
+++ b/src/mscorlib/src/System/Diagnostics/Eventing/TraceLogging/EventFieldFormat.cs
@@ -20,6 +20,12 @@ namespace System.Diagnostics.Tracing
         /// Field receives default formatting based on the field's underlying type.
         /// </summary>
         Default = 0,
+#if false 
+        /// <summary>
+        /// Field should not be displayed.
+        /// </summary>
+        NoPrint = 1,
+#endif
         /// <summary>
         /// Field should be formatted as character or string data.
         /// Typically applied to 8-bit or 16-bit integers.
@@ -39,6 +45,40 @@ namespace System.Diagnostics.Tracing
         /// </summary>
         Hexadecimal = 4,
 
+#if false 
+        /// <summary>
+        /// Field should be formatted as a process identifier. Typically applied to
+        /// 32-bit integer types.
+        /// </summary>
+        ProcessId = 5,
+
+        /// <summary>
+        /// Field should be formatted as a thread identifier. Typically applied to
+        /// 32-bit integer types.
+        /// </summary>
+        ThreadId = 6,
+
+        /// <summary>
+        /// Field should be formatted as an Internet port. Typically applied to 16-bit integer
+        /// types.
+        /// </summary>
+        Port = 7,
+        /// <summary>
+        /// Field should be formatted as an Internet Protocol v4 address. Typically applied to
+        /// 32-bit integer types.
+        /// </summary>
+        Ipv4Address = 8,
+
+        /// <summary>
+        /// Field should be formatted as an Internet Protocol v6 address. Typically applied to
+        /// byte[] types.
+        /// </summary>
+        Ipv6Address = 9,
+        /// <summary>
+        /// Field should be formatted as a SOCKADDR. Typically applied to byte[] types.
+        /// </summary>
+        SocketAddress = 10,
+#endif
         /// <summary>
         /// Field should be formatted as XML string data. Typically applied to
         /// strings or arrays of 8-bit or 16-bit integers.
@@ -50,10 +90,41 @@ namespace System.Diagnostics.Tracing
         /// strings or arrays of 8-bit or 16-bit integers.
         /// </summary>
         Json = 12,
+#if false 
+        /// <summary>
+        /// Field should be formatted as a Win32 error code. Typically applied to
+        /// 32-bit integer types.
+        /// </summary>
+        Win32Error = 13,
+
+        /// <summary>
+        /// Field should be formatted as an NTSTATUS code. Typically applied to
+        /// 32-bit integer types.
+        /// </summary>
+        NTStatus = 14,
+#endif
         /// <summary>
         /// Field should be formatted as an HRESULT code. Typically applied to
         /// 32-bit integer types.
         /// </summary>
         HResult = 15,
+#if false 
+        /// <summary>
+        /// Field should be formatted as a FILETIME. Typically applied to 64-bit
+        /// integer types. This is the default format for DateTime types.
+        /// </summary>
+        FileTime = 16,
+        /// <summary>
+        /// When applied to a numeric type, indicates that the type should be formatted
+        /// as a signed integer. This is the default format for signed integer types.
+        /// </summary>
+        Signed = 17,
+
+        /// <summary>
+        /// When applied to a numeric type, indicates that the type should be formatted
+        /// as an unsigned integer. This is the default format for unsigned integer types.
+        /// </summary>
+        Unsigned = 18,
+#endif
     }
 }
diff --git a/src/mscorlib/src/System/Diagnostics/Eventing/TraceLogging/Statics.cs b/src/mscorlib/src/System/Diagnostics/Eventing/TraceLogging/Statics.cs
index c92937caee..516c8ba19a 100644
--- a/src/mscorlib/src/System/Diagnostics/Eventing/TraceLogging/Statics.cs
+++ b/src/mscorlib/src/System/Diagnostics/Eventing/TraceLogging/Statics.cs
@@ -211,6 +211,12 @@ namespace System.Diagnostics.Tracing
                     return TraceLoggingDataType.Boolean8;
                 case EventFieldFormat.Hexadecimal:
                     return TraceLoggingDataType.HexInt8;
+#if false 
+                case EventSourceFieldFormat.Signed:
+                    return TraceLoggingDataType.Int8;
+                case EventSourceFieldFormat.Unsigned:
+                    return TraceLoggingDataType.UInt8;
+#endif
                 default:
                     return MakeDataType(native, format);
             }
@@ -234,6 +240,14 @@ namespace System.Diagnostics.Tracing
                     return TraceLoggingDataType.Char16;
                 case EventFieldFormat.Hexadecimal:
                     return TraceLoggingDataType.HexInt16;
+#if false
+                case EventSourceFieldFormat.Port:
+                    return TraceLoggingDataType.Port;
+                case EventSourceFieldFormat.Signed:
+                    return TraceLoggingDataType.Int16;
+                case EventSourceFieldFormat.Unsigned:
+                    return TraceLoggingDataType.UInt16;
+#endif
                 default:
                     return MakeDataType(native, format);
             }
@@ -257,8 +271,26 @@ namespace System.Diagnostics.Tracing
                     return TraceLoggingDataType.Boolean32;
                 case EventFieldFormat.Hexadecimal:
                     return TraceLoggingDataType.HexInt32;
+#if false 
+                case EventSourceFieldFormat.Ipv4Address:
+                    return TraceLoggingDataType.Ipv4Address;
+                case EventSourceFieldFormat.ProcessId:
+                    return TraceLoggingDataType.ProcessId;
+                case EventSourceFieldFormat.ThreadId:
+                    return TraceLoggingDataType.ThreadId;
+                case EventSourceFieldFormat.Win32Error:
+                    return TraceLoggingDataType.Win32Error;
+                case EventSourceFieldFormat.NTStatus:
+                    return TraceLoggingDataType.NTStatus;
+#endif
                 case EventFieldFormat.HResult:
                     return TraceLoggingDataType.HResult;
+#if false 
+                case EventSourceFieldFormat.Signed:
+                    return TraceLoggingDataType.Int32;
+                case EventSourceFieldFormat.Unsigned:
+                    return TraceLoggingDataType.UInt32;
+#endif
                 default:
                     return MakeDataType(native, format);
             }
@@ -280,6 +312,14 @@ namespace System.Diagnostics.Tracing
                     return native;
                 case EventFieldFormat.Hexadecimal:
                     return TraceLoggingDataType.HexInt64;
+#if false 
+                case EventSourceFieldFormat.FileTime:
+                    return TraceLoggingDataType.FileTime;
+                case EventSourceFieldFormat.Signed:
+                    return TraceLoggingDataType.Int64;
+                case EventSourceFieldFormat.Unsigned:
+                    return TraceLoggingDataType.UInt64;
+#endif
                 default:
                     return MakeDataType(native, format);
             }
@@ -301,6 +341,12 @@ namespace System.Diagnostics.Tracing
                     return native;
                 case EventFieldFormat.Hexadecimal:
                     return HexIntPtrType;
+#if false 
+                case EventSourceFieldFormat.Signed:
+                    return IntPtrType;
+                case EventSourceFieldFormat.Unsigned:
+                    return UIntPtrType;
+#endif
                 default:
                     return MakeDataType(native, format);
             }
diff --git a/src/mscorlib/src/System/Diagnostics/Eventing/TraceLogging/TraceLoggingDataType.cs b/src/mscorlib/src/System/Diagnostics/Eventing/TraceLogging/TraceLoggingDataType.cs
index b396031fe5..529948daf8 100644
--- a/src/mscorlib/src/System/Diagnostics/Eventing/TraceLogging/TraceLoggingDataType.cs
+++ b/src/mscorlib/src/System/Diagnostics/Eventing/TraceLogging/TraceLoggingDataType.cs
@@ -226,6 +226,49 @@ namespace System.Diagnostics.Tracing
         /// </summary>
         HexInt16 = UInt16 + (EventFieldFormat.Hexadecimal << 8),
 
+#if false 
+        /// <summary>
+        /// Formatted type.
+        /// Encoding assumes 32-bit value.
+        /// Decoding treats as process identifier.
+        /// </summary>
+        ProcessId = UInt32 + (EventSourceFieldFormat.ProcessId << 8),
+
+        /// <summary>
+        /// Formatted type.
+        /// Encoding assumes 32-bit value.
+        /// Decoding treats as thread identifier.
+        /// </summary>
+        ThreadId = UInt32 + (EventSourceFieldFormat.ThreadId << 8),
+
+        /// <summary>
+        /// Formatted type.
+        /// Encoding assumes 16-bit value.
+        /// Decoding treats as IP port.
+        /// </summary>
+        Port = UInt16 + (EventSourceFieldFormat.Port << 8),
+
+        /// <summary>
+        /// Formatted type.
+        /// Encoding assumes 32-bit value.
+        /// Decoding treats as IPv4 address.
+        /// </summary>
+        Ipv4Address = UInt32 + (EventSourceFieldFormat.Ipv4Address << 8),
+
+        /// <summary>
+        /// Formatted type.
+        /// Encoding assumes 16-bit bytecount followed by binary data.
+        /// Decoding treats as IPv6 address.
+        /// </summary>
+        Ipv6Address = Binary + (EventSourceFieldFormat.Ipv6Address << 8),
+
+        /// <summary>
+        /// Formatted type.
+        /// Encoding assumes 16-bit bytecount followed by binary data.
+        /// Decoding treats as SOCKADDR.
+        /// </summary>
+        SocketAddress = Binary + (EventSourceFieldFormat.SocketAddress << 8),
+#endif
         /// <summary>
         /// Formatted type.
         /// Encoding assumes null-terminated Char16 string.
@@ -281,6 +324,21 @@ namespace System.Diagnostics.Tracing
         /// Decoding treats as MBCS JSON.
         /// </summary>
         CountedMbcsJson = CountedMbcsString + (EventFieldFormat.Json << 8),
+#if false 
+        /// <summary>
+        /// Formatted type.
+        /// Encoding assumes 32-bit value.
+        /// Decoding treats as Win32 error.
+        /// </summary>
+        Win32Error = UInt32 + (EventSourceFieldFormat.Win32Error << 8),
+
+        /// <summary>
+        /// Formatted type.
+        /// Encoding assumes 32-bit value.
+        /// Decoding treats as NTSTATUS.
+        /// </summary>
+        NTStatus = UInt32 + (EventSourceFieldFormat.NTStatus << 8),
+#endif
         /// <summary>
         /// Formatted type.
         /// Encoding assumes 32-bit value.
diff --git a/src/mscorlib/src/System/Diagnostics/Eventing/TraceLogging/TraceLoggingEventSource.cs b/src/mscorlib/src/System/Diagnostics/Eventing/TraceLogging/TraceLoggingEventSource.cs
index 28a93f4a61..07a56751ea 100644
--- a/src/mscorlib/src/System/Diagnostics/Eventing/TraceLogging/TraceLoggingEventSource.cs
+++ b/src/mscorlib/src/System/Diagnostics/Eventing/TraceLogging/TraceLoggingEventSource.cs
@@ -14,6 +14,7 @@
 #endif // PLATFORM_UNIX
 
 #if ES_BUILD_STANDALONE
+#define FEATURE_MANAGED_ETW_CHANNELS
 // #define FEATURE_ADVANCED_MANAGED_ETW_CHANNELS
 #endif
 
diff --git a/src/mscorlib/src/System/Diagnostics/Eventing/Winmeta.cs b/src/mscorlib/src/System/Diagnostics/Eventing/Winmeta.cs
index d8689b610f..c93e745173 100644
--- a/src/mscorlib/src/System/Diagnostics/Eventing/Winmeta.cs
+++ b/src/mscorlib/src/System/Diagnostics/Eventing/Winmeta.cs
@@ -10,6 +10,9 @@
 ** environment.
 ** 
 ============================================================*/
+#if ES_BUILD_STANDALONE
+#define FEATURE_MANAGED_ETW_CHANNELS
+#endif
 
 #if ES_BUILD_STANDALONE
 namespace Microsoft.Diagnostics.Tracing
diff --git a/src/mscorlib/src/System/Diagnostics/Eventing/XplatEventLogger.cs b/src/mscorlib/src/System/Diagnostics/Eventing/XplatEventLogger.cs
index c96d2129f0..00155d72a0 100644
--- a/src/mscorlib/src/System/Diagnostics/Eventing/XplatEventLogger.cs
+++ b/src/mscorlib/src/System/Diagnostics/Eventing/XplatEventLogger.cs
@@ -23,7 +23,6 @@ namespace System.Diagnostics.Tracing
 
         private static bool initializedPersistentListener = false;
 
-        [System.Security.SecuritySafeCritical]
         public static EventListener InitializePersistentListener()
         {
             try{
@@ -150,7 +149,6 @@ namespace System.Diagnostics.Tracing
             }
         }
 
-        [System.Security.SecuritySafeCritical]
         private void LogOnEventWritten(EventWrittenEventArgs eventData)
         {
             string payload = "";
diff --git a/src/mscorlib/src/System/Diagnostics/LogSwitch.cs b/src/mscorlib/src/System/Diagnostics/LogSwitch.cs
index 84f6b91f65..14f0f26d98 100644
--- a/src/mscorlib/src/System/Diagnostics/LogSwitch.cs
+++ b/src/mscorlib/src/System/Diagnostics/LogSwitch.cs
@@ -79,19 +79,6 @@ namespace System.Diagnostics {
             get { return strName;}
         }
     
-        // Get property returns the description of the switch
-        public virtual String Description
-        {
-            get {return strDescription;}
-        }
-    
-    
-        // Get property returns the parent of the switch
-        public virtual LogSwitch Parent
-        {
-            get { return ParentSwitch; }
-        }
-    
     
         // Property to Get/Set the level of log messages which are "on" for the switch.  
         // 
diff --git a/src/mscorlib/src/System/Diagnostics/Stackframe.cs b/src/mscorlib/src/System/Diagnostics/Stackframe.cs
index bdfd1e044a..13d8f5cdcc 100644
--- a/src/mscorlib/src/System/Diagnostics/Stackframe.cs
+++ b/src/mscorlib/src/System/Diagnostics/Stackframe.cs
@@ -8,12 +8,10 @@ namespace System.Diagnostics {
     using System;
     using System.IO;
     using System.Reflection;
-    using System.Security.Permissions;
     using System.Diagnostics.Contracts;
 
     // There is no good reason for the methods of this class to be virtual.
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class StackFrame
     {
         private MethodBase    method;
@@ -181,17 +179,6 @@ namespace System.Diagnostics {
         //
         public virtual String GetFileName()
         {
-            if (strFileName != null)
-            {
-                // This isn't really correct, but we don't have
-                // a permission that protects discovery of potentially
-                // local urls so we'll use this.
-
-                FileIOPermission perm = new FileIOPermission( PermissionState.None );
-                perm.AllFiles = FileIOPermissionAccess.PathDiscovery;
-                perm.Demand();
-            }
-
             return strFileName;
         }
     
@@ -256,24 +243,6 @@ namespace System.Diagnostics {
 
                 bool useFileName = (strFileName != null);
 
-                if (useFileName)
-                {
-                    try
-                    {
-                        // This isn't really correct, but we don't have
-                        // a permission that protects discovery of potentially
-                        // local urls so we'll use this.
-
-                        FileIOPermission perm = new FileIOPermission(PermissionState.None);
-                        perm.AllFiles = FileIOPermissionAccess.PathDiscovery;
-                        perm.Demand();
-                    }
-                    catch (System.Security.SecurityException)
-                    {
-                        useFileName = false;
-                    }
-                }
-
                 if (!useFileName)
                     sb.Append("<filename unknown>");
                 else
diff --git a/src/mscorlib/src/System/Diagnostics/Stacktrace.cs b/src/mscorlib/src/System/Diagnostics/Stacktrace.cs
index 128ae3cea4..cd88f5108f 100644
--- a/src/mscorlib/src/System/Diagnostics/Stacktrace.cs
+++ b/src/mscorlib/src/System/Diagnostics/Stacktrace.cs
@@ -8,7 +8,6 @@ namespace System.Diagnostics {
     using System.Text;
     using System.Threading;
     using System.Security;
-    using System.Security.Permissions;
     using System.IO;
     using System.Reflection;
     using System.Runtime.InteropServices;
@@ -200,7 +199,6 @@ namespace System.Diagnostics {
         } 
 
         public virtual int GetNumberOfFrames() { return iFrameCount;}
-        public virtual void SetNumberOfFrames(int i) { iFrameCount = i;}
     
         //
         // serialization implementation
@@ -253,7 +251,6 @@ namespace System.Diagnostics {
     // StackTrace, we use an InheritanceDemand to prevent partially-trusted
     // subclasses.
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class StackTrace
     {
         private StackFrame[] frames;
@@ -516,7 +513,6 @@ namespace System.Diagnostics {
         // The nth element of this array is the same as GetFrame(n). 
         // The length of the array is the same as FrameCount.
         // 
-        [ComVisible(false)]
         public virtual StackFrame [] GetFrames()
         {
             if (frames == null || m_iNumOfFrames <= 0)
diff --git a/src/mscorlib/src/System/Diagnostics/SymbolStore/ISymDocumentWriter.cs b/src/mscorlib/src/System/Diagnostics/SymbolStore/ISymDocumentWriter.cs
index 2b7b078dbc..a1a2366c0a 100644
--- a/src/mscorlib/src/System/Diagnostics/SymbolStore/ISymDocumentWriter.cs
+++ b/src/mscorlib/src/System/Diagnostics/SymbolStore/ISymDocumentWriter.cs
@@ -17,7 +17,6 @@ namespace System.Diagnostics.SymbolStore {
     using System;
     
     // Interface does not need to be marked with the serializable attribute
-    [System.Runtime.InteropServices.ComVisible(true)]
     public interface ISymbolDocumentWriter
     {
         // SetSource will store the raw source for a document into the
diff --git a/src/mscorlib/src/System/Diagnostics/SymbolStore/ISymWriter.cs b/src/mscorlib/src/System/Diagnostics/SymbolStore/ISymWriter.cs
index a0d3640c2c..bfe9133aee 100644
--- a/src/mscorlib/src/System/Diagnostics/SymbolStore/ISymWriter.cs
+++ b/src/mscorlib/src/System/Diagnostics/SymbolStore/ISymWriter.cs
@@ -20,13 +20,8 @@ namespace System.Diagnostics.SymbolStore {
     using System.Runtime.Versioning;
 
     // Interface does not need to be marked with the serializable attribute
-[System.Runtime.InteropServices.ComVisible(true)]
-    public interface ISymbolWriter
+    internal interface ISymbolWriter
     {
-        // Set the IMetadataEmitter that this symbol writer is associated
-        // with. This must be done only once before any other ISymbolWriter
-        // methods are called.
-        void Initialize(IntPtr emitter, String filename, bool fFullBuild);
         
         // Define a source document. Guid's will be provided for the
         // languages, vendors, and document types that we currently know
@@ -36,11 +31,6 @@ namespace System.Diagnostics.SymbolStore {
                                           Guid languageVendor,
                                           Guid documentType);
     
-        // Define the method that the user has defined as their entrypoint
-        // for this module. This would be, perhaps, the user's main method
-        // rather than compiler generated stubs before main.
-        void SetUserEntryPoint(SymbolToken entryMethod);
-    
         // Open a method to emit symbol information into. The given method
         // becomes the current method for calls do define sequence points,
         // parameters and lexical scopes. There is an implicit lexical
@@ -88,9 +78,6 @@ namespace System.Diagnostics.SymbolStore {
         // last instruction in the scope.
         void CloseScope(int endOffset);
     
-        // Define the offset range for a given lexical scope.
-        void SetScopeRange(int scopeID, int startOffset, int endOffset);
-    
         // Define a single variable in the current lexical
         // scope. startOffset and endOffset are optional. If 0, then they
         // are ignored and the variable is defined over the entire
@@ -109,80 +96,17 @@ namespace System.Diagnostics.SymbolStore {
                                         int startOffset,
                                         int endOffset);
     
-        // Define a single parameter in the current method. The type of
-        // each parameter is taken from its position (sequence) within the
-        // method's signature.
-        //
-        // Note: if parameters are defined in the metadata for a given
-        // method, then clearly one would not have to define them again
-        // with calls to this method. The symbol readers will have to be
-        // smart enough to check the normal metadata for these first then
-        // fall back to the symbol store.
-        void DefineParameter(String name,
-                                    ParameterAttributes attributes,
-                                    int sequence,
-                                    SymAddressKind addrKind,
-                                    int addr1,
-                                    int addr2,
-                                    int addr3);
-    
-        // Define a single variable not within a method. This is used for
-        // certian fields in classes, bitfields, etc.
-        void DefineField(SymbolToken parent,
-                                String name,
-                                FieldAttributes attributes,
-                                byte[] signature,
-                                SymAddressKind addrKind,
-                                int addr1,
-                                int addr2,
-                                int addr3);
-    
-        // Define a single global variable.
-        void DefineGlobalVariable(String name,
-                                         FieldAttributes attributes,
-                                         byte[] signature,
-                                         SymAddressKind addrKind,
-                                         int addr1,
-                                         int addr2,
-                                         int addr3);
-    
-        // Close will close the ISymbolWriter and commit the symbols
-        // to the symbol store. The ISymbolWriter becomes invalid
-        // after this call for further updates.
-        void Close();
-    
         // Defines a custom attribute based upon its name. Not to be
         // confused with Metadata custom attributes, these attributes are
         // held in the symbol store.
         void SetSymAttribute(SymbolToken parent, String name, byte[] data);
     
-        // Opens a new namespace. Call this before defining methods or
-        // variables that live within a namespace. Namespaces can be nested.
-        void OpenNamespace(String name);
-    
-        // Close the most recently opened namespace.
-        void CloseNamespace();
-    
         // Specifies that the given, fully qualified namespace name is
         // being used within the currently open lexical scope. Closing the
         // current scope will also stop using the namespace, and the
         // namespace will be in use in all scopes that inherit from the
         // currently open scope.
         void UsingNamespace(String fullName);
-        
-        // Specifies the true start and end of a method within a source
-        // file. Use this to specify the extent of a method independently
-        // of what sequence points exist within the method.
-        void SetMethodSourceRange(ISymbolDocumentWriter startDoc,
-                                         int startLine,
-                                         int startColumn,
-                                         ISymbolDocumentWriter endDoc,
-                                         int endLine,
-                                         int endColumn);
-
-        // Used to set the underlying ISymUnmanagedWriter that a
-        // managed ISymbolWriter may use to emit symbols with.
-        void SetUnderlyingWriter(IntPtr underlyingWriter);
     }
 
 }
diff --git a/src/mscorlib/src/System/Diagnostics/SymbolStore/SymAddressKind.cs b/src/mscorlib/src/System/Diagnostics/SymbolStore/SymAddressKind.cs
index a7f866f2ec..bb50d9841b 100644
--- a/src/mscorlib/src/System/Diagnostics/SymbolStore/SymAddressKind.cs
+++ b/src/mscorlib/src/System/Diagnostics/SymbolStore/SymAddressKind.cs
@@ -16,8 +16,7 @@ namespace System.Diagnostics.SymbolStore {
     using System;
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public enum SymAddressKind
+    internal enum SymAddressKind
     {
         // ILOffset: addr1 = IL local var or param index.
         ILOffset = 1,
diff --git a/src/mscorlib/src/System/Diagnostics/SymbolStore/Token.cs b/src/mscorlib/src/System/Diagnostics/SymbolStore/Token.cs
index a8a6675a2f..cc1e4a865f 100644
--- a/src/mscorlib/src/System/Diagnostics/SymbolStore/Token.cs
+++ b/src/mscorlib/src/System/Diagnostics/SymbolStore/Token.cs
@@ -14,8 +14,7 @@ namespace System.Diagnostics.SymbolStore {
     using System;
     using System.Runtime.InteropServices;
 
-    [ComVisible(true)]
-    public struct SymbolToken
+    internal struct SymbolToken
     {
         internal int m_token;
         
@@ -37,15 +36,5 @@ namespace System.Diagnostics.SymbolStore {
         {
             return obj.m_token == m_token;
         }
-    
-        public static bool operator ==(SymbolToken a, SymbolToken b)
-        {
-            return a.Equals(b);
-        }
-        
-        public static bool operator !=(SymbolToken a, SymbolToken b)
-        {
-            return !(a == b);
-        }
     }
 }
diff --git a/src/mscorlib/src/System/Diagnostics/log.cs b/src/mscorlib/src/System/Diagnostics/log.cs
index 6916ce3a0a..d297b8fa08 100644
--- a/src/mscorlib/src/System/Diagnostics/log.cs
+++ b/src/mscorlib/src/System/Diagnostics/log.cs
@@ -5,7 +5,6 @@
 namespace System.Diagnostics {
     using System.Runtime.Remoting;
     using System;
-    using System.Security.Permissions;
     using System.IO;
     using System.Collections;
     using System.Runtime.CompilerServices;
@@ -13,18 +12,6 @@ namespace System.Diagnostics {
     using System.Runtime.Versioning;
     using System.Diagnostics.Contracts;
     using System.Diagnostics.CodeAnalysis;
-
-   // LogMessageEventHandlers are triggered when a message is generated which is
-   // "on" per its switch.
-   // 
-   // By default, the debugger (if attached) is the only event handler. 
-   // There is also a "built-in" console device which can be enabled
-   // programatically, by registry (specifics....) or environment
-   // variables.
-    [Serializable]
-    internal delegate void LogMessageEventHandler(LoggingLevels level, LogSwitch category, 
-                                                    String message, 
-                                                    StackTrace location);
     
     
    // LogSwitchLevelHandlers are triggered when the level of a LogSwitch is modified
@@ -49,7 +36,6 @@ namespace System.Diagnostics {
         // desired events are actually reported to the debugger.  
         internal static Hashtable m_Hashtable;
         private static volatile bool m_fConsoleDeviceEnabled;
-        private static LogMessageEventHandler   _LogMessageEventHandler;
         private static volatile LogSwitchLevelHandler   _LogSwitchLevelHandler;
         private static Object locker;
     
@@ -72,35 +58,6 @@ namespace System.Diagnostics {
             GlobalSwitch.MinimumLevel = LoggingLevels.ErrorLevel;
         }
     
-        public static void AddOnLogMessage(LogMessageEventHandler handler)
-        {
-            lock (locker)
-                _LogMessageEventHandler = 
-                    (LogMessageEventHandler) MulticastDelegate.Combine(_LogMessageEventHandler, handler);
-        }
-    
-        public static void RemoveOnLogMessage(LogMessageEventHandler handler)
-        {
-    
-            lock (locker)
-                _LogMessageEventHandler = 
-                    (LogMessageEventHandler) MulticastDelegate.Remove(_LogMessageEventHandler, handler);
-        }
-    
-        public static void AddOnLogSwitchLevel(LogSwitchLevelHandler handler)
-        {
-            lock (locker)
-                _LogSwitchLevelHandler = 
-                    (LogSwitchLevelHandler) MulticastDelegate.Combine(_LogSwitchLevelHandler, handler);
-        }
-    
-        public static void RemoveOnLogSwitchLevel(LogSwitchLevelHandler handler)
-        {
-            lock (locker)
-                _LogSwitchLevelHandler = 
-                    (LogSwitchLevelHandler) MulticastDelegate.Remove(_LogSwitchLevelHandler, handler);
-        }
-    
         internal static void InvokeLogSwitchLevelHandlers (LogSwitch ls, LoggingLevels newLevel)
         {
             LogSwitchLevelHandler handler = _LogSwitchLevelHandler;
@@ -119,15 +76,6 @@ namespace System.Diagnostics {
             get { return m_fConsoleDeviceEnabled; }
             set { m_fConsoleDeviceEnabled = value; }
         }
-          
-        // Generates a log message. If its switch (or a parent switch) allows the 
-        // level for the message, it is "broadcast" to all of the log
-        // devices.
-        // 
-        public static void LogMessage(LoggingLevels level, String message)
-        {
-            LogMessage (level, GlobalSwitch, message);
-        }
     
         // Generates a log message. If its switch (or a parent switch) allows the 
         // level for the message, it is "broadcast" to all of the log
@@ -168,74 +116,10 @@ namespace System.Diagnostics {
             LogMessage (LoggingLevels.TraceLevel0, logswitch, message);
         }
     
-        public static void Trace(String switchname, String message)
-        {
-            LogSwitch ls;
-            ls = LogSwitch.GetSwitch (switchname);
-            LogMessage (LoggingLevels.TraceLevel0, ls, message);            
-        }
-    
         public static void Trace(String message)
         {
             LogMessage (LoggingLevels.TraceLevel0, GlobalSwitch, message);
         }
-    
-        public static void Status(LogSwitch logswitch, String message)
-        {
-            LogMessage (LoggingLevels.StatusLevel0, logswitch, message);
-        }
-    
-        public static void Status(String switchname, String message)
-        {
-            LogSwitch ls;
-            ls = LogSwitch.GetSwitch (switchname);
-            LogMessage (LoggingLevels.StatusLevel0, ls, message);
-        }
-    
-        public static void Status(String message)
-        {
-            LogMessage (LoggingLevels.StatusLevel0, GlobalSwitch, message);
-        }
-    
-        public static void Warning(LogSwitch logswitch, String message)
-        {
-            LogMessage (LoggingLevels.WarningLevel, logswitch, message);
-        }
-    
-        public static void Warning(String switchname, String message)
-        {
-            LogSwitch ls;
-            ls = LogSwitch.GetSwitch (switchname);
-            LogMessage (LoggingLevels.WarningLevel, ls, message);
-        }
-    
-        public static void Warning(String message)
-        {
-            LogMessage (LoggingLevels.WarningLevel, GlobalSwitch, message);
-        }
-    
-        public static void Error(LogSwitch logswitch, String message)
-        {
-            LogMessage (LoggingLevels.ErrorLevel, logswitch, message);
-        }
-    
-        public static void Error(String switchname, String message)
-        {
-            LogSwitch ls;
-            ls = LogSwitch.GetSwitch (switchname);
-            LogMessage (LoggingLevels.ErrorLevel, ls, message);
-    
-        }
-
-        public static void Error(String message)
-        {
-            LogMessage (LoggingLevels.ErrorLevel, GlobalSwitch, message);
-        }
-    
-        public static void Panic(String message)
-        {
-            LogMessage (LoggingLevels.PanicLevel, GlobalSwitch, message);
-        }
         
     
         // Native method to inform the EE about the creation of a new LogSwitch
diff --git a/src/mscorlib/src/System/DivideByZeroException.cs b/src/mscorlib/src/System/DivideByZeroException.cs
index b975e81df6..4abd43adaf 100644
--- a/src/mscorlib/src/System/DivideByZeroException.cs
+++ b/src/mscorlib/src/System/DivideByZeroException.cs
@@ -11,29 +11,31 @@
 **
 =============================================================================*/
 
-namespace System {
-    
-    using System;
-    using System.Runtime.Serialization;
-[System.Runtime.InteropServices.ComVisible(true)]
+using System.Runtime.Serialization;
+
+namespace System
+{
     [Serializable]
-    public class DivideByZeroException : ArithmeticException {
-        public DivideByZeroException() 
-            : base(Environment.GetResourceString("Arg_DivideByZero")) {
-            SetErrorCode(__HResults.COR_E_DIVIDEBYZERO);
-        }
-    
-        public DivideByZeroException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_DIVIDEBYZERO);
+    public class DivideByZeroException : ArithmeticException
+    {
+        public DivideByZeroException()
+            : base(SR.Arg_DivideByZero)
+        {
+            HResult = __HResults.COR_E_DIVIDEBYZERO;
         }
-    
-        public DivideByZeroException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_DIVIDEBYZERO);
+
+        public DivideByZeroException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_DIVIDEBYZERO;
         }
 
-        protected DivideByZeroException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public DivideByZeroException(String message, Exception innerException)
+            : base(message, innerException)
+        {
+            HResult = __HResults.COR_E_DIVIDEBYZERO;
         }
+
+        protected DivideByZeroException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
 }
diff --git a/src/mscorlib/src/System/DllNotFoundException.cs b/src/mscorlib/src/System/DllNotFoundException.cs
index f860904f3f..43bb57fec2 100644
--- a/src/mscorlib/src/System/DllNotFoundException.cs
+++ b/src/mscorlib/src/System/DllNotFoundException.cs
@@ -16,7 +16,6 @@ namespace System {
     using System;
     using System.Runtime.Serialization;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class DllNotFoundException : TypeLoadException {
         public DllNotFoundException() 
diff --git a/src/mscorlib/src/System/Double.cs b/src/mscorlib/src/System/Double.cs
index ce146a1227..1e4e477366 100644
--- a/src/mscorlib/src/System/Double.cs
+++ b/src/mscorlib/src/System/Double.cs
@@ -22,7 +22,6 @@ namespace System {
 
 [Serializable]
 [StructLayout(LayoutKind.Sequential)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public struct Double : IComparable, IFormattable, IConvertible
         , IComparable<Double>, IEquatable<Double>
     {
@@ -83,7 +82,6 @@ namespace System {
         }
 
         [Pure]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public unsafe static bool IsNaN(double d)
         {
diff --git a/src/mscorlib/src/System/DuplicateWaitObjectException.cs b/src/mscorlib/src/System/DuplicateWaitObjectException.cs
index d358d964c2..da29e2ad76 100644
--- a/src/mscorlib/src/System/DuplicateWaitObjectException.cs
+++ b/src/mscorlib/src/System/DuplicateWaitObjectException.cs
@@ -11,53 +11,55 @@
 **
 =============================================================================*/
 
-namespace System {
-    
-    using System;
-    using System.Runtime.Remoting;
-    using System.Runtime.Serialization;
+using System.Runtime.Serialization;
 
+namespace System
+{
     // The DuplicateWaitObjectException is thrown when an object 
     // appears more than once in the list of objects to WaitAll or WaitAny.
     // 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
-    public class DuplicateWaitObjectException : ArgumentException {
+    public class DuplicateWaitObjectException : ArgumentException
+    {
+        private static volatile String s_duplicateWaitObjectMessage = null;
 
-        private static volatile String _duplicateWaitObjectMessage = null;
-
-        private static String DuplicateWaitObjectMessage {
-            get {
-                if (_duplicateWaitObjectMessage == null)
-                    _duplicateWaitObjectMessage = Environment.GetResourceString("Arg_DuplicateWaitObjectException");
-                return _duplicateWaitObjectMessage;
+        private static String DuplicateWaitObjectMessage
+        {
+            get
+            {
+                if (s_duplicateWaitObjectMessage == null)
+                    s_duplicateWaitObjectMessage = SR.Arg_DuplicateWaitObjectException;
+                return s_duplicateWaitObjectMessage;
             }
         }
 
         // Creates a new DuplicateWaitObjectException with its message 
         // string set to a default message.
-        public DuplicateWaitObjectException() 
-            : base(DuplicateWaitObjectMessage) {
-            SetErrorCode(__HResults.COR_E_DUPLICATEWAITOBJECT);
+        public DuplicateWaitObjectException()
+            : base(DuplicateWaitObjectMessage)
+        {
+            HResult = __HResults.COR_E_DUPLICATEWAITOBJECT;
         }
 
-        public DuplicateWaitObjectException(String parameterName) 
-            : base(DuplicateWaitObjectMessage, parameterName) {
-            SetErrorCode(__HResults.COR_E_DUPLICATEWAITOBJECT);
+        public DuplicateWaitObjectException(String parameterName)
+            : base(DuplicateWaitObjectMessage, parameterName)
+        {
+            HResult = __HResults.COR_E_DUPLICATEWAITOBJECT;
         }
 
-        public DuplicateWaitObjectException(String parameterName, String message) 
-            : base(message, parameterName) {
-            SetErrorCode(__HResults.COR_E_DUPLICATEWAITOBJECT);
+        public DuplicateWaitObjectException(String parameterName, String message)
+            : base(message, parameterName)
+        {
+            HResult = __HResults.COR_E_DUPLICATEWAITOBJECT;
         }
 
-        public DuplicateWaitObjectException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_DUPLICATEWAITOBJECT);
+        public DuplicateWaitObjectException(String message, Exception innerException)
+            : base(message, innerException)
+        {
+            HResult = __HResults.COR_E_DUPLICATEWAITOBJECT;
         }
 
         // This constructor is required for serialization
-        protected DuplicateWaitObjectException(SerializationInfo info, StreamingContext context) : base (info, context) {
-        }
+        protected DuplicateWaitObjectException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
 }
diff --git a/src/mscorlib/src/System/EntryPointNotFoundException.cs b/src/mscorlib/src/System/EntryPointNotFoundException.cs
index a65d80058e..835d33413d 100644
--- a/src/mscorlib/src/System/EntryPointNotFoundException.cs
+++ b/src/mscorlib/src/System/EntryPointNotFoundException.cs
@@ -11,32 +11,32 @@
 **
 =============================================================================*/
 
-namespace System {
-    
-    using System;
-    using System.Runtime.Serialization;
-    [System.Runtime.InteropServices.ComVisible(true)]
+using System;
+using System.Runtime.Serialization;
+
+namespace System
+{
     [Serializable]
-    public class EntryPointNotFoundException : TypeLoadException {
-        public EntryPointNotFoundException() 
-            : base(Environment.GetResourceString("Arg_EntryPointNotFoundException")) {
-            SetErrorCode(__HResults.COR_E_ENTRYPOINTNOTFOUND);
-        }
-    
-        public EntryPointNotFoundException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_ENTRYPOINTNOTFOUND);
+    public class EntryPointNotFoundException : TypeLoadException
+    {
+        public EntryPointNotFoundException()
+            : base(SR.Arg_EntryPointNotFoundException)
+        {
+            HResult = __HResults.COR_E_ENTRYPOINTNOTFOUND;
         }
-    
-        public EntryPointNotFoundException(String message, Exception inner) 
-            : base(message, inner) {
-            SetErrorCode(__HResults.COR_E_ENTRYPOINTNOTFOUND);
+
+        public EntryPointNotFoundException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_ENTRYPOINTNOTFOUND;
         }
 
-        protected EntryPointNotFoundException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public EntryPointNotFoundException(String message, Exception inner)
+            : base(message, inner)
+        {
+            HResult = __HResults.COR_E_ENTRYPOINTNOTFOUND;
         }
-    
-    
-    }
 
+        protected EntryPointNotFoundException(SerializationInfo info, StreamingContext context) : base(info, context) { }
+    }
 }
diff --git a/src/mscorlib/src/System/Enum.cs b/src/mscorlib/src/System/Enum.cs
index d39e005d48..97cfdf1b23 100644
--- a/src/mscorlib/src/System/Enum.cs
+++ b/src/mscorlib/src/System/Enum.cs
@@ -15,7 +15,6 @@ using System.Diagnostics.Contracts;
 namespace System 
 {
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public abstract class Enum : ValueType, IComparable, IFormattable, IConvertible
     {
         #region Private Constants
@@ -70,7 +69,6 @@ namespace System
                     case CorElementType.U8:
                         return (*(ulong*)pValue).ToString("X16", null);
                     default:
-                        Debug.Assert(false, "Invalid Object type in Format");
                         throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_UnknownEnumType"));
                 }
             }
@@ -105,7 +103,6 @@ namespace System
                     return ((UInt64)(Int64)value).ToString("X16", null);
                 // All unsigned types will be directly cast
                 default:
-                    Debug.Assert(false, "Invalid Object type in Format");
                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_UnknownEnumType"));
             }
         }
@@ -159,7 +156,7 @@ namespace System
             Debug.Assert(names.Length == values.Length);
 
             int index = values.Length - 1;
-            StringBuilder retval = new StringBuilder();
+            StringBuilder sb = StringBuilderCache.Acquire();
             bool firstTime = true;
             ulong saveResult = result;
 
@@ -175,31 +172,40 @@ namespace System
                 {
                     result -= values[index];
                     if (!firstTime)
-                        retval.Insert(0, enumSeparatorString);
+                        sb.Insert(0, enumSeparatorString);
 
-                    retval.Insert(0, names[index]);
+                    sb.Insert(0, names[index]);
                     firstTime = false;
                 }
 
                 index--;
             }
 
-            // We were unable to represent this number as a bitwise or of valid flags
+            string returnString;
             if (result != 0)
-                return null; // return null so the caller knows to .ToString() the input
-
-            // For the case when we have zero
-            if (saveResult == 0)
             {
+                // We were unable to represent this number as a bitwise or of valid flags
+                returnString = null; // return null so the caller knows to .ToString() the input
+            }
+            else if (saveResult == 0)
+            {
+                // For the cases when we have zero
                 if (values.Length > 0 && values[0] == 0)
-                    return names[0]; // Zero was one of the enum values.
+                {
+                    returnString = names[0]; // Zero was one of the enum values.
+                }
                 else
-                    return "0";
+                {
+                    returnString = "0";
+                }
             }
             else
             {
-                return retval.ToString(); // Return the string representation
+                returnString = sb.ToString(); // Return the string representation
             }
+
+            StringBuilderCache.Release(sb);
+            return returnString;
         }
 
         internal static ulong ToUInt64(Object value)
@@ -244,7 +250,6 @@ namespace System
                     break;
                 // All unsigned types will be directly cast
                 default:
-                    Debug.Assert(false, "Invalid Object type in ToUInt64");
                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_UnknownEnumType"));
             }
 
@@ -361,13 +366,11 @@ namespace System
             return retValue;
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static Object Parse(Type enumType, String value)
         {
             return Parse(enumType, value, false);
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static Object Parse(Type enumType, String value, bool ignoreCase)
         {
             EnumResult parseResult = new EnumResult() { canThrow = true };
@@ -525,7 +528,6 @@ namespace System
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static Type GetUnderlyingType(Type enumType)
         {
             if (enumType == null)
@@ -536,7 +538,6 @@ namespace System
             return enumType.GetEnumUnderlyingType();
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static Array GetValues(Type enumType)
         {
             if (enumType == null)
@@ -553,7 +554,6 @@ namespace System
             return GetCachedValuesAndNames(enumType, false).Values;
         }
         
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static String GetName(Type enumType, Object value)
         {
             if (enumType == null)
@@ -563,7 +563,6 @@ namespace System
             return enumType.GetEnumName(value);
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static String[] GetNames(Type enumType)
         {
             if (enumType == null)
@@ -580,7 +579,6 @@ namespace System
             return GetCachedValuesAndNames(enumType, true).Names;
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static Object ToObject(Type enumType, Object value)
         {
             if (value == null)
@@ -629,7 +627,6 @@ namespace System
         }
 
         [Pure]
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static bool IsDefined(Type enumType, Object value)
         {
             if (enumType == null)
@@ -639,7 +636,6 @@ namespace System
             return enumType.IsEnumDefined(value);
         }
         
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static String Format(Type enumType, Object value, String format)
         {
             if (enumType == null)
@@ -899,8 +895,8 @@ namespace System
         public int CompareTo(Object target)
         {
             const int retIncompatibleMethodTables = 2;  // indicates that the method tables did not match
-            const int retInvalidEnumType = 3; // indicates that the enum was of an unknown/unsupported unerlying type
-            
+            const int retInvalidEnumType = 3; // indicates that the enum was of an unknown/unsupported underlying type
+
             if (this == null)
                 throw new NullReferenceException();
             Contract.EndContractBlock();
@@ -978,61 +974,31 @@ namespace System
         #region IConvertable
         public TypeCode GetTypeCode()
         {
-            Type enumType = this.GetType();
-            Type underlyingType = GetUnderlyingType(enumType);
-
-            if (underlyingType == typeof(Int32))
-            {
-                return TypeCode.Int32;
-            }
-
-            if (underlyingType == typeof(sbyte))
-            {
-                return TypeCode.SByte;
-            }
-
-            if (underlyingType == typeof(Int16))
-            {
-                return TypeCode.Int16;
-            }
-
-            if (underlyingType == typeof(Int64))
+            switch (InternalGetCorElementType())
             {
-                return TypeCode.Int64;
-            }
-
-            if (underlyingType == typeof(UInt32))
-            {
-                return TypeCode.UInt32;
-            }
-
-            if (underlyingType == typeof(byte))
-            {
-                return TypeCode.Byte;
-            }
-
-            if (underlyingType == typeof(UInt16))
-            {
-                return TypeCode.UInt16;
-            }
-
-            if (underlyingType == typeof(UInt64))
-            {
-                return TypeCode.UInt64;
-            }
-
-            if (underlyingType == typeof(Boolean))
-            {
-                return TypeCode.Boolean;
-            }
-
-            if (underlyingType == typeof(Char))
-            {
-                return TypeCode.Char;
+                case CorElementType.I1:
+                    return TypeCode.SByte;
+                case CorElementType.U1:
+                    return TypeCode.Byte;
+                case CorElementType.Boolean:
+                    return TypeCode.Boolean;
+                case CorElementType.I2:
+                    return TypeCode.Int16;
+                case CorElementType.U2:
+                    return TypeCode.UInt16;
+                case CorElementType.Char:
+                    return TypeCode.Char;
+                case CorElementType.I4:
+                    return TypeCode.Int32;
+                case CorElementType.U4:
+                    return TypeCode.UInt32;
+                case CorElementType.I8:
+                    return TypeCode.Int64;
+                case CorElementType.U8:
+                    return TypeCode.UInt64;
+                default:
+                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_UnknownEnumType"));
             }
-
-            Debug.Assert(false, "Unknown underlying type.");
-            throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_UnknownEnumType"));
         }
 
         /// <internalonly/>
@@ -1128,7 +1094,6 @@ namespace System
     
         #region ToObject
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static Object ToObject(Type enumType, sbyte value)
         {
             if (enumType == null)
@@ -1142,7 +1107,6 @@ namespace System
             return InternalBoxEnum(rtType, value);
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static Object ToObject(Type enumType, short value)
         {
             if (enumType == null)
@@ -1156,7 +1120,6 @@ namespace System
             return InternalBoxEnum(rtType, value);
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static Object ToObject(Type enumType, int value)
         {
             if (enumType == null)
@@ -1170,7 +1133,6 @@ namespace System
             return InternalBoxEnum(rtType, value);
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static Object ToObject(Type enumType, byte value)
         {
             if (enumType == null)
@@ -1185,7 +1147,6 @@ namespace System
         }
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static Object ToObject(Type enumType, ushort value)
         {
             if (enumType == null)
@@ -1200,7 +1161,6 @@ namespace System
         }
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static Object ToObject(Type enumType, uint value)
         {
             if (enumType == null)
@@ -1214,7 +1174,6 @@ namespace System
             return InternalBoxEnum(rtType, value);
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static Object ToObject(Type enumType, long value)
         {
             if (enumType == null)
@@ -1229,7 +1188,6 @@ namespace System
         }
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static Object ToObject(Type enumType, ulong value)
         {
             if (enumType == null)
diff --git a/src/mscorlib/src/System/Environment.cs b/src/mscorlib/src/System/Environment.cs
index 518b95e0f5..e39b38c928 100644
--- a/src/mscorlib/src/System/Environment.cs
+++ b/src/mscorlib/src/System/Environment.cs
@@ -18,7 +18,6 @@ namespace System {
     using System.Globalization;
     using System.Collections;
     using System.Collections.Generic;
-    using System.Security.Permissions;
     using System.Text;
     using System.Configuration.Assemblies;
     using System.Runtime.InteropServices;
@@ -31,7 +30,6 @@ namespace System {
     using System.Runtime.Versioning;
     using System.Diagnostics.Contracts;
 
-    [ComVisible(true)]
     public enum EnvironmentVariableTarget
     {
         Process = 0,
@@ -39,7 +37,6 @@ namespace System {
         Machine = 2,
     }
 
-    [ComVisible(true)]
     public static partial class Environment
     {
         // Assume the following constants include the terminating '\0' - use <, not <=
@@ -72,23 +69,7 @@ namespace System {
 
             // Is this thread currently doing infinite resource lookups?
             private int infinitelyRecursingCount;
-
-            // Data representing one individual resource lookup on a thread.
-            internal class GetResourceStringUserData
-            {
-                public ResourceHelper m_resourceHelper;
-                public String m_key;
-                public String m_retVal;
-                public bool m_lockWasTaken;
-
-                public GetResourceStringUserData(ResourceHelper resourceHelper, String key)
-                {
-                    m_resourceHelper = resourceHelper;
-                    m_key = key;
-                }
-            }
             
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
             internal String GetResourceString(String key)  {
                 if (key == null || key.Length == 0) {
                     Debug.Assert(false, "Environment::GetResourceString with null or empty key.  Bug in caller, or weird recursive loading problem?");
@@ -114,111 +95,85 @@ namespace System {
                 // returning, we're going into an infinite loop and we should 
                 // return a bogus string.  
 
-                GetResourceStringUserData userData = new GetResourceStringUserData(this, key);
-
-                RuntimeHelpers.TryCode tryCode = new RuntimeHelpers.TryCode(GetResourceStringCode);
-                RuntimeHelpers.CleanupCode cleanupCode = new RuntimeHelpers.CleanupCode(GetResourceStringBackoutCode);
-
-                RuntimeHelpers.ExecuteCodeWithGuaranteedCleanup(tryCode, cleanupCode, userData);
-                return userData.m_retVal;
-            }
-
-            private void GetResourceStringCode(Object userDataIn)
-            {
-                GetResourceStringUserData userData = (GetResourceStringUserData) userDataIn;
-                ResourceHelper rh = userData.m_resourceHelper;
-                String key = userData.m_key;
-
-                Monitor.Enter(rh, ref userData.m_lockWasTaken);
-
-                // Are we recursively looking up the same resource?  Note - our backout code will set
-                // the ResourceHelper's currentlyLoading stack to null if an exception occurs.
-                if (rh.currentlyLoading != null && rh.currentlyLoading.Count > 0 && rh.currentlyLoading.LastIndexOf(key) != -1) {
-                    // We can start infinitely recursing for one resource lookup,
-                    // then during our failure reporting, start infinitely recursing again.
-                    // avoid that.
-                    if (rh.infinitelyRecursingCount > 0) {
-                        userData.m_retVal = "[Resource lookup failed - infinite recursion or critical failure detected.]";
-                        return;
-                    }
-                    rh.infinitelyRecursingCount++;
+                bool lockTaken = false;
+                try
+                {
+                    Monitor.Enter(this, ref lockTaken);
 
-                    // Note: our infrastructure for reporting this exception will again cause resource lookup.
-                    // This is the most direct way of dealing with that problem.
-                    String message = "Infinite recursion during resource lookup within "+System.CoreLib.Name+".  This may be a bug in "+System.CoreLib.Name+", or potentially in certain extensibility points such as assembly resolve events or CultureInfo names.  Resource name: " + key;
-                    Assert.Fail("[Recursive resource lookup bug]", message, Assert.COR_E_FAILFAST, System.Diagnostics.StackTrace.TraceFormat.NoResourceLookup);
-                    Environment.FailFast(message);
-                }
-                if (rh.currentlyLoading == null)
-                    rh.currentlyLoading = new List<string>();
+                    // Are we recursively looking up the same resource?  Note - our backout code will set
+                    // the ResourceHelper's currentlyLoading stack to null if an exception occurs.
+                    if (currentlyLoading != null && currentlyLoading.Count > 0 && currentlyLoading.LastIndexOf(key) != -1)
+                    {
+                        // We can start infinitely recursing for one resource lookup,
+                        // then during our failure reporting, start infinitely recursing again.
+                        // avoid that.
+                        if (infinitelyRecursingCount > 0)
+                        {
+                            return "[Resource lookup failed - infinite recursion or critical failure detected.]";
+                        }
+                        infinitelyRecursingCount++;
 
-                // Call class constructors preemptively, so that we cannot get into an infinite
-                // loop constructing a TypeInitializationException.  If this were omitted,
-                // we could get the Infinite recursion assert above by failing type initialization
-                // between the Push and Pop calls below.
-        
-                if (!rh.resourceManagerInited)
-                {
-                    // process-critical code here.  No ThreadAbortExceptions
-                    // can be thrown here.  Other exceptions percolate as normal.
-                    RuntimeHelpers.PrepareConstrainedRegions();
-                    try {
+                        // Note: our infrastructure for reporting this exception will again cause resource lookup.
+                        // This is the most direct way of dealing with that problem.
+                        string message = $"Infinite recursion during resource lookup within {System.CoreLib.Name}.  This may be a bug in {System.CoreLib.Name}, or potentially in certain extensibility points such as assembly resolve events or CultureInfo names.  Resource name: {key}";
+                        Assert.Fail("[Recursive resource lookup bug]", message, Assert.COR_E_FAILFAST, System.Diagnostics.StackTrace.TraceFormat.NoResourceLookup);
+                        Environment.FailFast(message);
                     }
-                    finally {
+                    if (currentlyLoading == null)
+                        currentlyLoading = new List<string>();
+
+                    // Call class constructors preemptively, so that we cannot get into an infinite
+                    // loop constructing a TypeInitializationException.  If this were omitted,
+                    // we could get the Infinite recursion assert above by failing type initialization
+                    // between the Push and Pop calls below.
+                    if (!resourceManagerInited)
+                    {
                         RuntimeHelpers.RunClassConstructor(typeof(ResourceManager).TypeHandle);
                         RuntimeHelpers.RunClassConstructor(typeof(ResourceReader).TypeHandle);
                         RuntimeHelpers.RunClassConstructor(typeof(RuntimeResourceSet).TypeHandle);
                         RuntimeHelpers.RunClassConstructor(typeof(BinaryReader).TypeHandle);
-                        rh.resourceManagerInited = true; 
+                        resourceManagerInited = true;
                     }
-            
-                } 
-        
-                rh.currentlyLoading.Add(key); // Push
-
-                if (rh.SystemResMgr == null) {
-                    rh.SystemResMgr = new ResourceManager(m_name, typeof(Object).Assembly);
-                }
-                String s = rh.SystemResMgr.GetString(key, null);
-                rh.currentlyLoading.RemoveAt(rh.currentlyLoading.Count - 1); // Pop
 
-                Debug.Assert(s!=null, "Managed resource string lookup failed.  Was your resource name misspelled?  Did you rebuild mscorlib after adding a resource to resources.txt?  Debug this w/ cordbg and bug whoever owns the code that called Environment.GetResourceString.  Resource name was: \""+key+"\"");
+                    currentlyLoading.Add(key); // Push
 
-                userData.m_retVal = s;
-            }
-
-            [PrePrepareMethod]
-            private void GetResourceStringBackoutCode(Object userDataIn, bool exceptionThrown)
-            {
-                GetResourceStringUserData userData = (GetResourceStringUserData) userDataIn;
-                ResourceHelper rh = userData.m_resourceHelper;
+                    if (SystemResMgr == null)
+                    {
+                        SystemResMgr = new ResourceManager(m_name, typeof(Object).Assembly);
+                    }
+                    string s = SystemResMgr.GetString(key, null);
+                    currentlyLoading.RemoveAt(currentlyLoading.Count - 1); // Pop
 
-                if (exceptionThrown)
+                    Debug.Assert(s != null, "Managed resource string lookup failed.  Was your resource name misspelled?  Did you rebuild mscorlib after adding a resource to resources.txt?  Debug this w/ cordbg and bug whoever owns the code that called Environment.GetResourceString.  Resource name was: \"" + key + "\"");
+                    return s;
+                }
+                catch
                 {
-                    if (userData.m_lockWasTaken) 
+                    if (lockTaken)
                     {
                         // Backout code - throw away potentially corrupt state
-                        rh.SystemResMgr = null;
-                        rh.currentlyLoading = null;
+                        SystemResMgr = null;
+                        currentlyLoading = null;
                     }
+                    throw;
                 }
-                // Release the lock, if we took it.
-                if (userData.m_lockWasTaken)
+                finally
                 {
-                    Monitor.Exit(rh);
+                    if (lockTaken)
+                    {
+                        Monitor.Exit(this);
+                    }
                 }
             }
-        
         }
 
-              private static volatile ResourceHelper m_resHelper;  // Doesn't need to be initialized as they're zero-init.
+        private static volatile ResourceHelper m_resHelper;  // Doesn't need to be initialized as they're zero-init.
 
         private const  int    MaxMachineNameLength = 256;
 
         // Private object for locking instead of locking on a public type for SQL reliability work.
         private static Object s_InternalSyncObject;
         private static Object InternalSyncObject {
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
             get {
                 if (s_InternalSyncObject == null) {
                     Object o = new Object();
@@ -266,9 +221,6 @@ namespace System {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         public static extern void FailFast(String message);
 
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        internal static extern void FailFast(String message, uint exitCode);
-
         // This overload of FailFast will allow you to specify the exception object
         // whose bucket details *could* be used when undergoing the failfast process.
         // To be specific:
@@ -292,7 +244,7 @@ namespace System {
         **Arguments: The current directory to which to switch to the setter.
         **Exceptions: 
         ==============================================================================*/
-        public static String CurrentDirectory
+        internal static String CurrentDirectory
         {
             get{
                 return Directory.GetCurrentDirectory();
@@ -304,7 +256,7 @@ namespace System {
         }
 
         // Returns the system directory (ie, C:\WinNT\System32).
-        public static String SystemDirectory {
+        internal static String SystemDirectory {
             get {
                 StringBuilder sb = new StringBuilder(Path.MaxPath);
                 int r = Win32Native.GetSystemDirectory(sb, Path.MaxPath);
@@ -316,20 +268,6 @@ namespace System {
             }
         }
 
-        // Returns the windows directory (ie, C:\WinNT).
-        // Used by NLS+ custom culures only at the moment.
-        internal static String InternalWindowsDirectory {
-            get {
-                StringBuilder sb = new StringBuilder(Path.MaxPath);
-                int r = Win32Native.GetWindowsDirectory(sb, Path.MaxPath);
-                Debug.Assert(r < Path.MaxPath, "r < Path.MaxPath");
-                if (r==0) __Error.WinIOError();
-                String path = sb.ToString();
-                
-                return path;
-            }
-        }
-
         public static String ExpandEnvironmentVariables(String name)
         {
             if (name == null)
@@ -421,15 +359,6 @@ namespace System {
             }
         }
 
-        public static int SystemPageSize {
-            get {
-                (new EnvironmentPermission(PermissionState.Unrestricted)).Demand();
-                Win32Native.SYSTEM_INFO info = new Win32Native.SYSTEM_INFO();
-                Win32Native.GetSystemInfo(ref info);
-                return info.dwPageSize;
-            }
-        }
-
         /*==============================GetCommandLineArgs==============================
         **Action: Gets the command line and splits it appropriately to deal with whitespace,
         **        quotes, and escape characters.
@@ -439,7 +368,6 @@ namespace System {
         ==============================================================================*/
         public static String[] GetCommandLineArgs()
         {
-            new EnvironmentPermission(EnvironmentPermissionAccess.Read, "Path").Demand();
             /*
              * There are multiple entry points to a hosted app.
              * The host could use ::ExecuteAssembly() or ::CreateDelegate option
@@ -515,38 +443,6 @@ namespace System {
             return block;
         }
 
-        /*===============================GetLogicalDrives===============================
-        **Action: Retrieves the names of the logical drives on this machine in the  form "C:\". 
-        **Arguments:   None.
-        **Exceptions:  IOException.
-        **Permissions: SystemInfo Permission.
-        ==============================================================================*/
-        public static String[] GetLogicalDrives() {
-            new EnvironmentPermission(PermissionState.Unrestricted).Demand();
-                                 
-            int drives = Win32Native.GetLogicalDrives();
-            if (drives==0)
-                __Error.WinIOError();
-            uint d = (uint)drives;
-            int count = 0;
-            while (d != 0) {
-                if (((int)d & 1) != 0) count++;
-                d >>= 1;
-            }
-            String[] result = new String[count];
-            char[] root = new char[] {'A', ':', '\\'};
-            d = (uint)drives;
-            count = 0;
-            while (d != 0) {
-                if (((int)d & 1) != 0) {
-                    result[count++] = new String(root);
-                }
-                d >>= 1;
-                root[0]++;
-            }
-            return result;
-        }
-        
         /*===================================NewLine====================================
         **Action: A property which returns the appropriate newline string for the given
         **        platform.
@@ -583,31 +479,13 @@ namespace System {
             }
         }
 
-        
-        /*==================================WorkingSet==================================
-        **Action:
-        **Returns:
-        **Arguments:
-        **Exceptions:
-        ==============================================================================*/
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode), SuppressUnmanagedCodeSecurity]
-        private static extern long GetWorkingSet();
-
-        public static long WorkingSet {
-            get {
-                new EnvironmentPermission(PermissionState.Unrestricted).Demand();
-                return GetWorkingSet();
-            }
-        }
-
-
         /*==================================OSVersion===================================
         **Action:
         **Returns:
         **Arguments:
         **Exceptions:
         ==============================================================================*/
-        public static OperatingSystem OSVersion {
+        internal static OperatingSystem OSVersion {
             get {
                 Contract.Ensures(Contract.Result<OperatingSystem>() != null);
 
@@ -669,7 +547,6 @@ namespace System {
             get {
                 Contract.Ensures(Contract.Result<String>() != null);
 
-                new EnvironmentPermission(PermissionState.Unrestricted).Demand();
                 return GetStackTrace(null, true);
             }
         }
@@ -719,8 +596,6 @@ namespace System {
         // if you change this method's signature then you must change the code that calls it
         // in excep.cpp and probably you will have to visit mscorlib.h to add the new signature
         // as well as metasig.h to create the new signature type
-        // NoInlining causes the caller and callee to not be inlined in mscorlib as it is an assumption of StackCrawlMark use
-        [MethodImpl(MethodImplOptions.NoInlining)]
         internal static String GetResourceStringLocal(String key) {
             if (m_resHelper == null)
                 InitResourceHelper();
@@ -737,308 +612,57 @@ namespace System {
         // thrown, we want the code size to be as small as possible.
         // Using the params object[] overload works against this since the
         // initialization of the array is done inline in the caller at the IL
-        // level. So we have overloads that simply wrap the params one, and
-        // the methods they call through to are tagged as NoInlining. 
-        // In mscorlib NoInlining causes the caller and callee to not be inlined
-        // as it is an assumption of StackCrawlMark use so it is not added 
-        // directly to these methods, but to the ones they call.
-        // That way they do not bloat either the IL or the generated asm.
+        // level. So we have overloads that simply wrap the params one.
 
+        [MethodImpl(MethodImplOptions.NoInlining)]
         internal static string GetResourceString(string key, object val0)
         {
             return GetResourceStringFormatted(key, new object[] { val0 });
         }
 
+        [MethodImpl(MethodImplOptions.NoInlining)]
         internal static string GetResourceString(string key, object val0, object val1)
         {
             return GetResourceStringFormatted(key, new object[] { val0, val1 });
         }
 
+        [MethodImpl(MethodImplOptions.NoInlining)]
         internal static string GetResourceString(string key, object val0, object val1, object val2)
         {
             return GetResourceStringFormatted(key, new object[] { val0, val1, val2 });
         }
 
+        [MethodImpl(MethodImplOptions.NoInlining)]
         internal static string GetResourceString(string key, object val0, object val1, object val2, object val3)
         {
             return GetResourceStringFormatted(key, new object[] { val0, val1, val2, val3 });
         }
 
-        internal static string GetResourceString(string key, object val0, object val1, object val2, object val3, object val4)
-        {
-            return GetResourceStringFormatted(key, new object[] { val0, val1, val2, val3, val4 });
-        }
-
-        internal static string GetResourceString(string key, object val0, object val1, object val2, object val3, object val4, object val5)
-        {
-            return GetResourceStringFormatted(key, new object[] { val0, val1, val2, val3, val4, val5 });
-        }
-
+        [MethodImpl(MethodImplOptions.NoInlining)]
         internal static String GetResourceString(string key, params object[] values)
         {
             return GetResourceStringFormatted(key, values);
         }
 
-        // NoInlining causes the caller and callee to not be inlined in mscorlib as it is an assumption of StackCrawlMark use
-        [MethodImpl(MethodImplOptions.NoInlining)]
         private static String GetResourceStringFormatted(string key, params object[] values)
         {
             string rs = GetResourceString(key);
             return String.Format(CultureInfo.CurrentCulture, rs, values);
         }
 
-        // The following two internal methods are not used anywhere within the framework,
-        // but are being kept around as external platforms built on top of us have taken 
-        // dependency by using private reflection on them for getting system resource strings 
-        private static String GetRuntimeResourceString(String key) {
-            return GetResourceString(key);
-        }
-
-        private static String GetRuntimeResourceString(String key, params Object[] values) {
-            return GetResourceStringFormatted(key,values);
-        }
-
-        public static bool Is64BitProcess {
-            get {
-#if BIT64
-                    return true;
-#else // 32
-                    return false;
-#endif
-            }
-        }
-
-        public static bool Is64BitOperatingSystem {
-            get {
-#if BIT64
-                    // 64-bit programs run only on 64-bit
-                    return true;
-#else // 32
-                    bool isWow64; // WinXP SP2+ and Win2k3 SP1+
-                    return Win32Native.DoesWin32MethodExist(Win32Native.KERNEL32, "IsWow64Process")
-                        && Win32Native.IsWow64Process(Win32Native.GetCurrentProcess(), out isWow64)
-                        && isWow64;
-#endif
-            }
-        }
-
         public static extern bool HasShutdownStarted {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
             get;
         }
 
-        public static string UserName {
-            get {
-                new EnvironmentPermission(EnvironmentPermissionAccess.Read,"UserName").Demand();
-
-                StringBuilder sb = new StringBuilder(256);
-                int size = sb.Capacity;
-                if (Win32Native.GetUserName(sb, ref size))
-                {
-                    return sb.ToString();
-                }
-                return String.Empty;
-            }
-        }
-
-        public static bool UserInteractive
+        internal static bool UserInteractive
         {
             get {
                 return true;
             }
         }
-        
-        public static string GetFolderPath(SpecialFolder folder) {
-            if (!Enum.IsDefined(typeof(SpecialFolder), folder))
-                throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)folder));
-            Contract.EndContractBlock();
-
-            return InternalGetFolderPath(folder, SpecialFolderOption.None);
-        }
-
-        public static string GetFolderPath(SpecialFolder folder, SpecialFolderOption option) {
-            if (!Enum.IsDefined(typeof(SpecialFolder),folder))
-                throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)folder));
-            if (!Enum.IsDefined(typeof(SpecialFolderOption),option))
-                throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)option));
-            Contract.EndContractBlock();
-
-            return InternalGetFolderPath(folder, option);
-        }
-
-        internal static string UnsafeGetFolderPath(SpecialFolder folder)
-        {
-            return InternalGetFolderPath(folder, SpecialFolderOption.None, suppressSecurityChecks: true);
-        }
-
-        private static string InternalGetFolderPath(SpecialFolder folder, SpecialFolderOption option, bool suppressSecurityChecks = false)
-        {
-            // This is currently customized for Windows Phone since CoreSystem doesn't support
-            // SHGetFolderPath. The allowed folder values are based on the version of .NET CF WP7 was using.
-            switch (folder)
-            {
-                case SpecialFolder.System:
-                    return SystemDirectory;
-                case SpecialFolder.ApplicationData:
-                case SpecialFolder.Favorites:
-                case SpecialFolder.Programs:
-                case SpecialFolder.StartMenu:
-                case SpecialFolder.Startup:
-                case SpecialFolder.Personal:
-                    throw new PlatformNotSupportedException();
-                default:
-                    throw new PlatformNotSupportedException();
-            }
-        }
-
-        public static string UserDomainName
-        {
-            get {
-                new EnvironmentPermission(EnvironmentPermissionAccess.Read,"UserDomain").Demand();
-
-                byte[] sid = new byte[1024];
-                int sidLen = sid.Length;
-                StringBuilder domainName = new StringBuilder(1024);
-                uint domainNameLen = (uint) domainName.Capacity;
-                int peUse;
-
-                byte ret = Win32Native.GetUserNameEx(Win32Native.NameSamCompatible, domainName, ref domainNameLen);
-                    if (ret == 1) {                        
-                        string samName = domainName.ToString();
-                        int index = samName.IndexOf('\\');
-                        if( index != -1) {
-                            return samName.Substring(0, index);
-                        }
-                    }
-                    domainNameLen = (uint) domainName.Capacity;                    
-                    
-                bool success = Win32Native.LookupAccountName(null, UserName, sid, ref sidLen, domainName, ref domainNameLen, out peUse);
-                if (!success)  {
-                    int errorCode = Marshal.GetLastWin32Error();
-                    throw new InvalidOperationException(Win32Native.GetMessage(errorCode));
-                }
-
-                return domainName.ToString();
-            }
-        }
-
-        public enum SpecialFolderOption {
-            None        = 0,
-            Create      = Win32Native.CSIDL_FLAG_CREATE,
-            DoNotVerify = Win32Native.CSIDL_FLAG_DONT_VERIFY,
-        }
-        
-//////!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!////////
-//////!!!!!! Keep the following locations synchronized            !!!!!!////////
-//////!!!!!! 1) ndp\clr\src\BCL\Microsoft\Win32\Win32Native.cs    !!!!!!////////
-//////!!!!!! 2) ndp\clr\src\BCL\System\Environment.cs             !!!!!!////////
-//////!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!////////
-        [ComVisible(true)]
-        public enum SpecialFolder {
-            //  
-            //      Represents the file system directory that serves as a common repository for
-            //       application-specific data for the current, roaming user. 
-            //     A roaming user works on more than one computer on a network. A roaming user's 
-            //       profile is kept on a server on the network and is loaded onto a system when the
-            //       user logs on. 
-            //  
-            ApplicationData =  Win32Native.CSIDL_APPDATA,
-            //  
-            //      Represents the file system directory that serves as a common repository for application-specific data that
-            //       is used by all users. 
-            //  
-            CommonApplicationData =  Win32Native.CSIDL_COMMON_APPDATA,
-            //  
-            //     Represents the file system directory that serves as a common repository for application specific data that
-            //       is used by the current, non-roaming user. 
-            //  
-            LocalApplicationData =  Win32Native.CSIDL_LOCAL_APPDATA,
-            //  
-            //     Represents the file system directory that serves as a common repository for Internet
-            //       cookies. 
-            //  
-            Cookies =  Win32Native.CSIDL_COOKIES,
-            Desktop = Win32Native.CSIDL_DESKTOP,
-            //  
-            //     Represents the file system directory that serves as a common repository for the user's
-            //       favorite items. 
-            //  
-            Favorites =  Win32Native.CSIDL_FAVORITES,
-            //  
-            //     Represents the file system directory that serves as a common repository for Internet
-            //       history items. 
-            //  
-            History =  Win32Native.CSIDL_HISTORY,
-            //  
-            //     Represents the file system directory that serves as a common repository for temporary 
-            //       Internet files. 
-            //  
-            InternetCache =  Win32Native.CSIDL_INTERNET_CACHE,
-            //  
-            //      Represents the file system directory that contains
-            //       the user's program groups. 
-            //  
-            Programs =  Win32Native.CSIDL_PROGRAMS,
-            MyComputer =  Win32Native.CSIDL_DRIVES,
-            MyMusic =  Win32Native.CSIDL_MYMUSIC,
-            MyPictures = Win32Native.CSIDL_MYPICTURES,
-            //      "My Videos" folder
-            MyVideos = Win32Native.CSIDL_MYVIDEO,
-            //  
-            //     Represents the file system directory that contains the user's most recently used
-            //       documents. 
-            //  
-            Recent =  Win32Native.CSIDL_RECENT,
-            //  
-            //     Represents the file system directory that contains Send To menu items. 
-            //  
-            SendTo =  Win32Native.CSIDL_SENDTO,
-            //  
-            //     Represents the file system directory that contains the Start menu items. 
-            //  
-            StartMenu =  Win32Native.CSIDL_STARTMENU,
-            //  
-            //     Represents the file system directory that corresponds to the user's Startup program group. The system
-            //       starts these programs whenever any user logs on to Windows NT, or
-            //       starts Windows 95 or Windows 98. 
-            //  
-            Startup =  Win32Native.CSIDL_STARTUP,
-            //  
-            //     System directory.
-            //  
-            System =  Win32Native.CSIDL_SYSTEM,
-            //  
-            //     Represents the file system directory that serves as a common repository for document
-            //       templates. 
-            //  
-            Templates =  Win32Native.CSIDL_TEMPLATES,
-            //  
-            //     Represents the file system directory used to physically store file objects on the desktop.
-            //       This should not be confused with the desktop folder itself, which is
-            //       a virtual folder. 
-            //  
-            DesktopDirectory =  Win32Native.CSIDL_DESKTOPDIRECTORY,
-            //  
-            //     Represents the file system directory that serves as a common repository for documents. 
-            //  
-            Personal =  Win32Native.CSIDL_PERSONAL, 
-            //          
-            // "MyDocuments" is a better name than "Personal"
-            //
-            MyDocuments = Win32Native.CSIDL_PERSONAL,
-            //  
-            //     Represents the program files folder. 
-            //  
-            ProgramFiles =  Win32Native.CSIDL_PROGRAM_FILES,
-            //  
-            //     Represents the folder for components that are shared across applications. 
-            //  
-            CommonProgramFiles =  Win32Native.CSIDL_PROGRAM_FILES_COMMON,
-        }
-
         public static int CurrentManagedThreadId
         {
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
             get
             {
                 return Thread.CurrentThread.ManagedThreadId;
@@ -1105,7 +729,7 @@ namespace System {
             return GetEnvironmentVariableCore(variable);
         }
 
-        public static string GetEnvironmentVariable(string variable, EnvironmentVariableTarget target)
+        internal static string GetEnvironmentVariable(string variable, EnvironmentVariableTarget target)
         {
             if (variable == null)
             {
@@ -1123,7 +747,7 @@ namespace System {
             return GetEnvironmentVariablesCore();
         }
 
-        public static IDictionary GetEnvironmentVariables(EnvironmentVariableTarget target)
+        internal static IDictionary GetEnvironmentVariables(EnvironmentVariableTarget target)
         {
             ValidateTarget(target);
 
@@ -1138,7 +762,7 @@ namespace System {
             SetEnvironmentVariableCore(variable, value);
         }
 
-        public static void SetEnvironmentVariable(string variable, string value, EnvironmentVariableTarget target)
+        internal static void SetEnvironmentVariable(string variable, string value, EnvironmentVariableTarget target)
         {
             ValidateVariableAndValue(variable, ref value);
             ValidateTarget(target);
diff --git a/src/mscorlib/src/System/EventArgs.cs b/src/mscorlib/src/System/EventArgs.cs
index 349de857d8..c0356613de 100644
--- a/src/mscorlib/src/System/EventArgs.cs
+++ b/src/mscorlib/src/System/EventArgs.cs
@@ -2,16 +2,17 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-namespace System {
-    
-    using System;
+using System;
+
+namespace System
+{
     // The base class for all event classes.
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public class EventArgs {
+    public class EventArgs
+    {
         public static readonly EventArgs Empty = new EventArgs();
-    
-        public EventArgs() 
+
+        public EventArgs()
         {
         }
     }
diff --git a/src/mscorlib/src/System/EventHandler.cs b/src/mscorlib/src/System/EventHandler.cs
index 517e1f7c26..e6923cf637 100644
--- a/src/mscorlib/src/System/EventHandler.cs
+++ b/src/mscorlib/src/System/EventHandler.cs
@@ -2,10 +2,11 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-namespace System {
-    
+using System;
+
+namespace System
+{
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public delegate void EventHandler(Object sender, EventArgs e);
 
     [Serializable]
diff --git a/src/mscorlib/src/System/Exception.cs b/src/mscorlib/src/System/Exception.cs
index 0edee80b1a..a166c1ab0a 100644
--- a/src/mscorlib/src/System/Exception.cs
+++ b/src/mscorlib/src/System/Exception.cs
@@ -18,7 +18,6 @@ namespace System {
     using System.Runtime.Serialization;
     using System.Runtime.Versioning;
     using System.Diagnostics;
-    using System.Security.Permissions;
     using System.Security;
     using System.IO;
     using System.Text;
@@ -27,11 +26,8 @@ namespace System {
     using System.Globalization;
     using System.Diagnostics.Contracts;
 
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_Exception))]
     [Serializable]
-    [ComVisible(true)]
-    public class Exception : ISerializable, _Exception
+    public class Exception : ISerializable
     {
         private void Init()
         {
@@ -537,33 +533,6 @@ namespace System {
 
         }
 
-        // This is used by remoting to preserve the server side stack trace
-        // by appending it to the message ... before the exception is rethrown
-        // at the client call site.
-        internal Exception PrepForRemoting()
-        {
-            String tmp = null;
-
-            if (_remoteStackIndex == 0)
-            {
-                tmp = Environment.NewLine+ "Server stack trace: " + Environment.NewLine
-                    + StackTrace 
-                    + Environment.NewLine + Environment.NewLine 
-                    + "Exception rethrown at ["+_remoteStackIndex+"]: " + Environment.NewLine;
-            }
-            else
-            {
-                tmp = StackTrace 
-                    + Environment.NewLine + Environment.NewLine 
-                    + "Exception rethrown at ["+_remoteStackIndex+"]: " + Environment.NewLine;
-            }
-
-            _remoteStackTraceString = tmp;
-            _remoteStackIndex++;
-
-            return this;
-        }
-
         // This method will clear the _stackTrace of the exception object upon deserialization
         // to ensure that references from another AD/Process dont get accidently used.
         [OnDeserialized]
@@ -797,19 +766,6 @@ namespace System {
         // and create a corresponding CrossAppDomainMarshaledException
         internal virtual String InternalToString()
         {
-            try 
-            {
-#pragma warning disable 618
-                SecurityPermission sp= new SecurityPermission(SecurityPermissionFlag.ControlEvidence | SecurityPermissionFlag.ControlPolicy);
-#pragma warning restore 618
-                sp.Assert();
-            }
-            catch  
-            {
-                //under normal conditions there should be no exceptions
-                //however if something wrong happens we still can call the usual ToString
-            }
-
             // Get the current stack trace string. 
             return ToString(true, true);
         }
diff --git a/src/mscorlib/src/System/ExecutionEngineException.cs b/src/mscorlib/src/System/ExecutionEngineException.cs
index 5b2592cca9..bebfd493a0 100644
--- a/src/mscorlib/src/System/ExecutionEngineException.cs
+++ b/src/mscorlib/src/System/ExecutionEngineException.cs
@@ -15,30 +15,33 @@
 **
 =============================================================================*/
 
-namespace System {
+using System;
+using System.Runtime.Serialization;
 
-	using System;
-	using System.Runtime.Serialization;
+namespace System
+{
     [Obsolete("This type previously indicated an unspecified fatal error in the runtime. The runtime no longer raises this exception so this type is obsolete.")]
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
-    public sealed class ExecutionEngineException : SystemException {
-        public ExecutionEngineException() 
-            : base(Environment.GetResourceString("Arg_ExecutionEngineException")) {
-    		SetErrorCode(__HResults.COR_E_EXECUTIONENGINE);
+    public sealed class ExecutionEngineException : SystemException
+    {
+        public ExecutionEngineException()
+            : base(SR.Arg_ExecutionEngineException)
+        {
+            HResult = __HResults.COR_E_EXECUTIONENGINE;
         }
-    
-        public ExecutionEngineException(String message) 
-            : base(message) {
-    		SetErrorCode(__HResults.COR_E_EXECUTIONENGINE);
-        }
-    
-        public ExecutionEngineException(String message, Exception innerException) 
-            : base(message, innerException) {
-    		SetErrorCode(__HResults.COR_E_EXECUTIONENGINE);
+
+        public ExecutionEngineException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_EXECUTIONENGINE;
         }
 
-        internal ExecutionEngineException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public ExecutionEngineException(String message, Exception innerException)
+            : base(message, innerException)
+        {
+            HResult = __HResults.COR_E_EXECUTIONENGINE;
         }
+
+        internal ExecutionEngineException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
 }
diff --git a/src/mscorlib/src/System/FieldAccessException.cs b/src/mscorlib/src/System/FieldAccessException.cs
index fbc3b1f592..ac62c0fcac 100644
--- a/src/mscorlib/src/System/FieldAccessException.cs
+++ b/src/mscorlib/src/System/FieldAccessException.cs
@@ -9,31 +9,31 @@
 **
 =============================================================================*/
 
-namespace System {
-    
-    using System;
-    using System.Runtime.Serialization;
-    [System.Runtime.InteropServices.ComVisible(true)]
+using System.Runtime.Serialization;
+
+namespace System
+{
     [Serializable]
-    public class FieldAccessException : MemberAccessException {
-        public FieldAccessException() 
-            : base(Environment.GetResourceString("Arg_FieldAccessException")) {
-            SetErrorCode(__HResults.COR_E_FIELDACCESS);
-        }
-    
-        public FieldAccessException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_FIELDACCESS);
+    public class FieldAccessException : MemberAccessException
+    {
+        public FieldAccessException()
+            : base(SR.Arg_FieldAccessException)
+        {
+            HResult = __HResults.COR_E_FIELDACCESS;
         }
-    
-        public FieldAccessException(String message, Exception inner) 
-            : base(message, inner) {
-            SetErrorCode(__HResults.COR_E_FIELDACCESS);
+
+        public FieldAccessException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_FIELDACCESS;
         }
 
-        protected FieldAccessException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public FieldAccessException(String message, Exception inner)
+            : base(message, inner)
+        {
+            HResult = __HResults.COR_E_FIELDACCESS;
         }
 
+        protected FieldAccessException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
-
 }
diff --git a/src/mscorlib/src/System/FlagsAttribute.cs b/src/mscorlib/src/System/FlagsAttribute.cs
index cb955cf3a1..5f8c108ae4 100644
--- a/src/mscorlib/src/System/FlagsAttribute.cs
+++ b/src/mscorlib/src/System/FlagsAttribute.cs
@@ -4,16 +4,15 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
-namespace System {
-    
-    using System;
+
+namespace System
+{
     // Custom attribute to indicate that the enum
     // should be treated as a bitfield (or set of flags).
     // An IDE may use this information to provide a richer
     // development experience.
     [Serializable]
     [AttributeUsage(AttributeTargets.Enum, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class FlagsAttribute : Attribute
     {
         public FlagsAttribute()
diff --git a/src/mscorlib/src/System/FormatException.cs b/src/mscorlib/src/System/FormatException.cs
index 2e1c8a9cd4..c5758e11cd 100644
--- a/src/mscorlib/src/System/FormatException.cs
+++ b/src/mscorlib/src/System/FormatException.cs
@@ -10,30 +10,32 @@
 **
 ** 
 ===========================================================*/
-namespace System {
-    
-    using System.Runtime.Serialization;
-    [System.Runtime.InteropServices.ComVisible(true)]
+
+using System.Runtime.Serialization;
+
+namespace System
+{
     [Serializable]
-    public class FormatException : SystemException {
-        public FormatException() 
-            : base(Environment.GetResourceString("Arg_FormatException")) {
-            SetErrorCode(__HResults.COR_E_FORMAT);
-        }
-    
-        public FormatException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_FORMAT);
+    public class FormatException : SystemException
+    {
+        public FormatException()
+            : base(SR.Arg_FormatException)
+        {
+            HResult = __HResults.COR_E_FORMAT;
         }
-        
-        public FormatException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_FORMAT);
+
+        public FormatException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_FORMAT;
         }
 
-        protected FormatException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public FormatException(String message, Exception innerException)
+            : base(message, innerException)
+        {
+            HResult = __HResults.COR_E_FORMAT;
         }
 
+        protected FormatException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
-
 }
diff --git a/src/mscorlib/src/System/FormattableString.cs b/src/mscorlib/src/System/FormattableString.cs
index 294b2c1846..6369363b5d 100644
--- a/src/mscorlib/src/System/FormattableString.cs
+++ b/src/mscorlib/src/System/FormattableString.cs
@@ -4,13 +4,13 @@
 
 /*============================================================
 **
-** Class:  FormattableString
 **
 **
 ** Purpose: implementation of the FormattableString
 ** class.
 **
 ===========================================================*/
+
 namespace System
 {
     /// <summary>
diff --git a/src/mscorlib/src/System/GC.cs b/src/mscorlib/src/System/GC.cs
index e338e44526..fd09ef7984 100644
--- a/src/mscorlib/src/System/GC.cs
+++ b/src/mscorlib/src/System/GC.cs
@@ -16,7 +16,6 @@ namespace System {
     //This class only static members and doesn't require the serializable keyword.
 
     using System;
-    using System.Security.Permissions;
     using System.Reflection;
     using System.Security;
     using System.Threading;
@@ -98,7 +97,6 @@ namespace System {
         private static extern int GetMaxGeneration();
     
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         private static extern int _CollectionCount (int generation, int getSpecialGCCount);
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
@@ -206,7 +204,6 @@ namespace System {
             _Collect(generation, iInternalModes);
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static int CollectionCount (int generation) 
         {
             if (generation<0) 
@@ -216,18 +213,6 @@ namespace System {
             Contract.EndContractBlock();
             return _CollectionCount(generation, 0);
         }
-
-        // pass in true to get the BGC or FGC count.
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
-        internal static int CollectionCount (int generation, bool getSpecialGCCount) 
-        {
-            if (generation<0) 
-            {
-                throw new ArgumentOutOfRangeException(nameof(generation), Environment.GetResourceString("ArgumentOutOfRange_GenericPositive"));
-            }
-            Contract.EndContractBlock();
-            return _CollectionCount(generation, (getSpecialGCCount ? 1 : 0));
-        }
         
         // This method DOES NOT DO ANYTHING in and of itself.  It's used to 
         // prevent a finalizable object from losing any outstanding references 
@@ -265,7 +250,6 @@ namespace System {
         // If we insert a call to GC.KeepAlive(this) at the end of Problem(), then
         // Foo doesn't get finalized and the stream stays open.
         [MethodImplAttribute(MethodImplOptions.NoInlining)] // disable optimizations
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static void KeepAlive(Object obj)
         {
         }
@@ -296,10 +280,8 @@ namespace System {
         // Indicates that the system should not call the Finalize() method on
         // an object that would normally require this call.
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         private static extern void _SuppressFinalize(Object o);
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static void SuppressFinalize(Object obj) {
             if (obj == null)
                 throw new ArgumentNullException(nameof(obj));
diff --git a/src/mscorlib/src/System/Globalization/Calendar.cs b/src/mscorlib/src/System/Globalization/Calendar.cs
index d0460386b6..1ff795ddc5 100644
--- a/src/mscorlib/src/System/Globalization/Calendar.cs
+++ b/src/mscorlib/src/System/Globalization/Calendar.cs
@@ -31,7 +31,6 @@ namespace System.Globalization {
     // since most of the calendars (or all?) have the same way of calcuating hour/minute/second.
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public abstract class Calendar : ICloneable
     {
 
@@ -98,7 +97,6 @@ namespace System.Globalization {
 
         // The minimum supported DateTime range for the calendar.
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual DateTime MinSupportedDateTime
         {
             get
@@ -109,7 +107,6 @@ namespace System.Globalization {
 
         // The maximum supported DateTime range for the calendar.
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual DateTime MaxSupportedDateTime
         {
             get
@@ -145,7 +142,6 @@ namespace System.Globalization {
 
         // Returns  the type of the calendar.
         //
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual CalendarAlgorithmType AlgorithmType
         {
             get
@@ -161,7 +157,6 @@ namespace System.Globalization {
         //  Detect if the object is readonly.
         //
         ////////////////////////////////////////////////////////////////////////
-        [System.Runtime.InteropServices.ComVisible(false)]
         public bool IsReadOnly
         {
             get { return (m_isReadOnly); }
@@ -174,7 +169,6 @@ namespace System.Globalization {
         //  Is the implementation of ICloneable.
         //
         ////////////////////////////////////////////////////////////////////////
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual Object Clone()
         {
             object o = MemberwiseClone();
@@ -190,7 +184,6 @@ namespace System.Globalization {
         //  readonly.
         //
         ////////////////////////////////////////////////////////////////////////
-        [System.Runtime.InteropServices.ComVisible(false)]
         public static Calendar ReadOnly(Calendar calendar) 
         {
             if (calendar == null)       { throw new ArgumentNullException(nameof(calendar)); }
@@ -709,7 +702,6 @@ namespace System.Globalization {
         // if this calendar does not have leap month, or this year is not a leap year.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual int GetLeapMonth(int year)
         {
             return (GetLeapMonth(year, CurrentEra));
@@ -719,7 +711,6 @@ namespace System.Globalization {
         // if this calendar does not have leap month, or this year is not a leap year.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual int GetLeapMonth(int year, int era)
         {
             if (!IsLeapYear(year, era))
diff --git a/src/mscorlib/src/System/Globalization/CalendarAlgorithmType.cs b/src/mscorlib/src/System/Globalization/CalendarAlgorithmType.cs
index 4bf636656f..33b5035a8d 100644
--- a/src/mscorlib/src/System/Globalization/CalendarAlgorithmType.cs
+++ b/src/mscorlib/src/System/Globalization/CalendarAlgorithmType.cs
@@ -5,7 +5,6 @@
 namespace System.Globalization {
     using System;
 
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum CalendarAlgorithmType {
         Unknown = 0,            // This is the default value to return in the Calendar base class.
         SolarCalendar = 1,      // Solar-base calendar, such as GregorianCalendar, jaoaneseCalendar, JulianCalendar, etc.
diff --git a/src/mscorlib/src/System/Globalization/CalendarData.cs b/src/mscorlib/src/System/Globalization/CalendarData.cs
index 6f583fbcbc..d66331b31d 100644
--- a/src/mscorlib/src/System/Globalization/CalendarData.cs
+++ b/src/mscorlib/src/System/Globalization/CalendarData.cs
@@ -400,41 +400,6 @@ namespace System.Globalization
             return "en-US";
         }
 
-        internal void FixupWin7MonthDaySemicolonBug()
-        {
-            int unescapedCharacterIndex = FindUnescapedCharacter(sMonthDay, ';');
-            if (unescapedCharacterIndex > 0)
-            {
-                sMonthDay = sMonthDay.Substring(0, unescapedCharacterIndex);
-            }
-        }
-        private static int FindUnescapedCharacter(string s, char charToFind)
-        {
-            bool inComment = false;
-            int length = s.Length;
-            for (int i = 0; i < length; i++)
-            {
-                char c = s[i];
-
-                switch (c)
-                {
-                    case '\'':
-                        inComment = !inComment;
-                        break;
-                    case '\\':
-                        i++; // escape sequence -- skip next character
-                        break;
-                    default:
-                        if (!inComment && charToFind == c)
-                        {
-                            return i;
-                        }
-                        break;
-                }
-            }
-            return -1;
-        }
-
         
         // Get native two digit year max
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
diff --git a/src/mscorlib/src/System/Globalization/CalendarWeekRule.cs b/src/mscorlib/src/System/Globalization/CalendarWeekRule.cs
index 578b5672fc..fa2a6429f1 100644
--- a/src/mscorlib/src/System/Globalization/CalendarWeekRule.cs
+++ b/src/mscorlib/src/System/Globalization/CalendarWeekRule.cs
@@ -7,7 +7,6 @@ namespace System.Globalization {
 
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum CalendarWeekRule
     {
 
diff --git a/src/mscorlib/src/System/Globalization/ChineseLunisolarCalendar.cs b/src/mscorlib/src/System/Globalization/ChineseLunisolarCalendar.cs
index 6479152e09..374ed0dcfa 100644
--- a/src/mscorlib/src/System/Globalization/ChineseLunisolarCalendar.cs
+++ b/src/mscorlib/src/System/Globalization/ChineseLunisolarCalendar.cs
@@ -44,7 +44,6 @@ namespace System.Globalization {
         internal static DateTime minDate = new DateTime(MIN_GREGORIAN_YEAR, MIN_GREGORIAN_MONTH, MIN_GREGORIAN_DAY);
         internal static DateTime maxDate = new DateTime((new DateTime(MAX_GREGORIAN_YEAR, MAX_GREGORIAN_MONTH, MAX_GREGORIAN_DAY, 23, 59, 59, 999)).Ticks + 9999);
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MinSupportedDateTime  {
             get
             {
@@ -53,7 +52,6 @@ namespace System.Globalization {
         }
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MaxSupportedDateTime {
             get
             {
@@ -371,7 +369,6 @@ namespace System.Globalization {
         }
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetEra(DateTime time) {
             CheckTicksRange(time.Ticks);
             return (ChineseEra);
@@ -391,7 +388,6 @@ namespace System.Globalization {
         }
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int[] Eras {
             get {
                 return (new int[] {ChineseEra});
diff --git a/src/mscorlib/src/System/Globalization/CompareInfo.cs b/src/mscorlib/src/System/Globalization/CompareInfo.cs
index dcf1f32e4a..6c2230b66b 100644
--- a/src/mscorlib/src/System/Globalization/CompareInfo.cs
+++ b/src/mscorlib/src/System/Globalization/CompareInfo.cs
@@ -29,7 +29,6 @@ namespace System.Globalization {
     using System.Runtime.InteropServices;
     using System.Runtime.Versioning;
     using System.Threading;
-    using System.Security.Permissions;
     using Microsoft.Win32;
     using System.Security;
     using System.Diagnostics;
@@ -45,7 +44,6 @@ namespace System.Globalization {
 
 [Serializable]
     [Flags]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum CompareOptions
     {
         None                = 0x00000000,
@@ -66,7 +64,6 @@ namespace System.Globalization {
 
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public partial class CompareInfo : IDeserializationCallback
     {
         // Mask used to check if IndexOf()/LastIndexOf()/IsPrefix()/IsPostfix() has the right flags.
@@ -217,12 +214,10 @@ namespace System.Globalization {
             return CultureInfo.GetCultureInfo(name).CompareInfo;
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public static bool IsSortable(char ch) {
             return(IsSortable(ch.ToString()));
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public static bool IsSortable(String text) {
             if (text == null) {
                 // A null param is invalid here.
@@ -316,7 +311,6 @@ namespace System.Globalization {
         //
         ////////////////////////////////////////////////////////////////////////
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual String Name
         {
             get
diff --git a/src/mscorlib/src/System/Globalization/CultureData.cs b/src/mscorlib/src/System/Globalization/CultureData.cs
index 0bcb796152..a93b7d43bb 100644
--- a/src/mscorlib/src/System/Globalization/CultureData.cs
+++ b/src/mscorlib/src/System/Globalization/CultureData.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// 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.
 
@@ -1102,15 +1102,6 @@ namespace System.Globalization
             }
         }
 
-        // (user can override) country code (RegionInfo)
-        internal int ICOUNTRY
-        {
-            get
-            {
-                return DoGetLocaleInfoInt(LOCALE_ICOUNTRY);
-            }
-        }
-
         // GeoId
         internal int IGEOID
         {
@@ -1214,15 +1205,6 @@ namespace System.Globalization
             }
         }
 
-        // Default Country
-        private int IDEFAULTCOUNTRY
-        {
-            get
-            {
-                return DoGetLocaleInfoInt(LOCALE_IDEFAULTCOUNTRY);
-            }
-        }
-
         // Console fallback name (ie: locale to use for console apps for unicode-only locales)
         internal int IINPUTLANGUAGEHANDLE
         {
@@ -1262,26 +1244,6 @@ namespace System.Globalization
             }
         }
 
-        /////////////
-        // Numbers //
-        ////////////
-
-        //                internal String sPositiveSign            ; // (user can override) positive sign
-        //                internal String sNegativeSign            ; // (user can override) negative sign
-        //                internal String[] saNativeDigits         ; // (user can override) native characters for digits 0-9
-        //                internal int iDigitSubstitution       ; // (user can override) Digit substitution 0=context, 1=none/arabic, 2=Native/national (2 seems to be unused) (Windows Only)
-        //                internal int iDigits                  ; // (user can override) number of fractional digits
-        //                internal int iNegativeNumber          ; // (user can override) negative number format
-
-        // Leading zeroes
-        private bool ILEADINGZEROS
-        {
-            get
-            {
-                return (DoGetLocaleInfoInt(LOCALE_ILZERO) == 1);
-            }
-        }
-
 
         // (user can override) grouping of digits
         internal int[] WAGROUPING
@@ -1506,15 +1468,6 @@ namespace System.Globalization
             }
         }
 
-        // Paper size
-        private int IPAPERSIZE
-        {
-            get
-            {
-                return DoGetLocaleInfoInt(LOCALE_IPAPERSIZE);
-            }
-        }
-
         ////////////////////////////
         // Calendar/Time (Gregorian) //
         ////////////////////////////
@@ -1712,20 +1665,6 @@ namespace System.Globalization
             return index;
         }
 
-        // time duration format
-        internal String[] SADURATION
-        {
-            get
-            {
-                if (this.saDurationFormats == null)
-                {
-                    String durationFormat = DoGetLocaleInfo(LOCALE_SDURATION);
-                    this.saDurationFormats = new String[] { ReescapeWin32String(durationFormat) };
-                }
-                return this.saDurationFormats;
-            }
-        }
-
         // (user can override) first day of week
         internal int IFIRSTDAYOFWEEK
         {
@@ -1944,11 +1883,6 @@ namespace System.Globalization
             return calendarData;
         }
 
-        internal int CurrentEra(int calendarId)
-        {
-            return GetCalendar(calendarId).iCurrentEra;
-        }
-
         ///////////////////
         // Text Information //
         ///////////////////
@@ -2054,48 +1988,6 @@ namespace System.Globalization
             }
         }
 
-        // Typical Scripts for this locale (latn;cyrl; etc)
-
-        private String SSCRIPTS
-        {
-            get
-            {
-                if (this.sScripts == null)
-                {
-                    this.sScripts = DoGetLocaleInfo(LOCALE_SSCRIPTS);
-                }
-                return this.sScripts;
-            }
-        }
-
-        private String SOPENTYPELANGUAGETAG
-        {
-            get
-            {
-                return DoGetLocaleInfo(LOCALE_SOPENTYPELANGUAGETAG);
-            }
-        }
-
-        private String FONTSIGNATURE
-        {
-            get
-            {
-                if (this.fontSignature == null)
-                {
-                    this.fontSignature = DoGetLocaleInfo(LOCALE_FONTSIGNATURE);
-                }
-                return this.fontSignature;
-            }
-        }
-
-        private String SKEYBOARDSTOINSTALL
-        {
-            get
-            {
-                return DoGetLocaleInfo(LOCALE_SKEYBOARDSTOINSTALL);
-            }
-        }
-
 
         internal int IDEFAULTANSICODEPAGE   // default ansi code page ID (ACP)
         {
diff --git a/src/mscorlib/src/System/Globalization/CultureInfo.cs b/src/mscorlib/src/System/Globalization/CultureInfo.cs
index 47d708b71c..ba61c146f6 100644
--- a/src/mscorlib/src/System/Globalization/CultureInfo.cs
+++ b/src/mscorlib/src/System/Globalization/CultureInfo.cs
@@ -36,7 +36,6 @@ namespace System.Globalization {
     using System.Runtime.InteropServices;
     using System.Runtime.Serialization;
     using System.Runtime.Versioning;
-    using System.Security.Permissions;
     using System.Reflection;
     using Microsoft.Win32;
     using System.Diagnostics;
@@ -44,7 +43,6 @@ namespace System.Globalization {
     using System.Resources;
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public partial class CultureInfo : ICloneable, IFormatProvider {
         //--------------------------------------------------------------------//
         //                        Internal Information                        //
@@ -366,25 +364,6 @@ namespace System.Globalization {
         }
 #endif // FEATURE_USE_LCID
 
-        //
-        // CheckDomainSafetyObject throw if the object is customized object which cannot be attached to 
-        // other object (like CultureInfo or DateTimeFormatInfo).
-        //
-
-        internal static void CheckDomainSafetyObject(Object obj, Object container)
-        {
-            if (obj.GetType().Assembly != typeof(System.Globalization.CultureInfo).Assembly) {
-                
-                throw new InvalidOperationException(
-                            String.Format(
-                                CultureInfo.CurrentCulture, 
-                                Environment.GetResourceString("InvalidOperation_SubclassedObject"), 
-                                obj.GetType(),
-                                container.GetType()));
-            }
-            Contract.EndContractBlock();
-        }
-
 #region Serialization
         // We need to store the override from the culture data record.
         private bool    m_useUserOverride;
@@ -417,21 +396,6 @@ namespace System.Globalization {
             }
 #endif
             m_isInherited = (this.GetType() != typeof(System.Globalization.CultureInfo));
-
-            // in case we have non customized CultureInfo object we shouldn't allow any customized object  
-            // to be attached to it for cross app domain safety.
-            if (this.GetType().Assembly == typeof(System.Globalization.CultureInfo).Assembly)
-            {
-                if (textInfo != null)
-                {
-                    CheckDomainSafetyObject(textInfo, this);
-                }
-                
-                if (compareInfo != null)
-                {
-                    CheckDomainSafetyObject(compareInfo, this);
-                }
-            }
         }
 
 #if FEATURE_USE_LCID
@@ -466,21 +430,8 @@ namespace System.Globalization {
             this.cultureID = this.m_cultureData.ILANGUAGE;
 #endif
         }
-#endregion Serialization
-
 
-        // Is it safe to pass the CultureInfo cross AppDomain boundaries, not necessarily as an instance
-        // member of Thread. This is different from IsSafeCrossDomain, which implies passing the CultureInfo
-        // as a Thread instance member. 
-        internal bool CanSendCrossDomain()
-        {
-            bool isSafe = false;
-            if (this.GetType() == typeof(System.Globalization.CultureInfo))
-            {
-                isSafe = true;
-            }
-            return isSafe;
-        }
+#endregion Serialization
 
         // Constructor called by SQL Server's special munged culture - creates a culture with
         // a TextInfo and CompareInfo that come from a supplied alternate source. This object
@@ -909,7 +860,6 @@ namespace System.Globalization {
         //
         ////////////////////////////////////////////////////////////////////////
 #if FEATURE_USE_LCID
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual int KeyboardLayoutId
         {
             get
@@ -970,7 +920,6 @@ namespace System.Globalization {
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public String IetfLanguageTag
         {
             get
@@ -1218,7 +1167,6 @@ namespace System.Globalization {
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public CultureTypes CultureTypes
         {
             get
@@ -1433,7 +1381,6 @@ namespace System.Globalization {
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public CultureInfo GetConsoleFallbackUICulture()
         {
             Contract.Ensures(Contract.Result<CultureInfo>() != null);
@@ -1845,9 +1792,6 @@ namespace System.Globalization {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         internal static extern int nativeGetLocaleInfoExInt(String localeName, uint field);
 
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        internal static extern bool nativeSetThreadLocale(String localeName);
-
         private static String GetDefaultLocaleName(int localeType)
         {
             Debug.Assert(localeType == LOCALE_USER_DEFAULT || localeType == LOCALE_SYSTEM_DEFAULT, "[CultureInfo.GetDefaultLocaleName] localeType must be LOCALE_USER_DEFAULT or LOCALE_SYSTEM_DEFAULT");
diff --git a/src/mscorlib/src/System/Globalization/CultureNotFoundException.cs b/src/mscorlib/src/System/Globalization/CultureNotFoundException.cs
index 17c0b43f9c..d4ab700a16 100644
--- a/src/mscorlib/src/System/Globalization/CultureNotFoundException.cs
+++ b/src/mscorlib/src/System/Globalization/CultureNotFoundException.cs
@@ -10,7 +10,6 @@ namespace System.Globalization {
     using System.Threading;
     using System.Diagnostics.Contracts;
     
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public partial class CultureNotFoundException : ArgumentException, ISerializable
     {
diff --git a/src/mscorlib/src/System/Globalization/CultureTypes.cs b/src/mscorlib/src/System/Globalization/CultureTypes.cs
index d506d50c9d..b19ab86bb1 100644
--- a/src/mscorlib/src/System/Globalization/CultureTypes.cs
+++ b/src/mscorlib/src/System/Globalization/CultureTypes.cs
@@ -11,7 +11,6 @@ namespace System.Globalization {
 
 [Serializable]
     [Flags]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum CultureTypes 
     {
         NeutralCultures             = 0x0001,             // Neutral cultures are cultures like "en", "de", "zh", etc, for enumeration this includes ALL neutrals regardless of other flags
diff --git a/src/mscorlib/src/System/Globalization/DateTimeFormat.cs b/src/mscorlib/src/System/Globalization/DateTimeFormat.cs
index c6e0591a74..1ace207952 100644
--- a/src/mscorlib/src/System/Globalization/DateTimeFormat.cs
+++ b/src/mscorlib/src/System/Globalization/DateTimeFormat.cs
@@ -1124,14 +1124,6 @@ namespace System {
         // local DateTime with a format that will be interpreted as UTC.
         internal static void InvalidFormatForLocal(String format, DateTime dateTime) {
         }
-
-        // This is an MDA for cases when the user is using a local format with
-        // a Utc DateTime.
-        internal static void InvalidFormatForUtc(String format, DateTime dateTime) {
-#if MDA_SUPPORTED
-            Mda.DateTimeInvalidLocalFormat();
-#endif
-        }
         
         
     }
diff --git a/src/mscorlib/src/System/Globalization/DateTimeFormatInfo.cs b/src/mscorlib/src/System/Globalization/DateTimeFormatInfo.cs
index ecbc6db962..b2374ef0b2 100644
--- a/src/mscorlib/src/System/Globalization/DateTimeFormatInfo.cs
+++ b/src/mscorlib/src/System/Globalization/DateTimeFormatInfo.cs
@@ -10,7 +10,6 @@ namespace System.Globalization {
     using System.Collections;
     using System.Collections.Generic;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     using System.Runtime.InteropServices;
     using System.Runtime.Versioning;
     using System.Text;
@@ -56,7 +55,6 @@ namespace System.Globalization {
 
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider
     {
         //
@@ -378,8 +376,6 @@ namespace System.Globalization {
         private int    nDataItem;
         [OptionalField(VersionAdded = 2)]
         internal bool m_isDefaultCalendar;                // NEVER USED, DO NOT USE THIS! (Serialized in Whidbey)
-        [OptionalField(VersionAdded = 2)]
-        private static volatile Hashtable s_calendarNativeNames;   // NEVER USED, DO NOT USE THIS! (Serialized in Whidbey)
 
         // This was synthesized by Whidbey so we knew what words might appear in the middle of a date string
         // Now we always synthesize so its not helpful
@@ -408,10 +404,6 @@ namespace System.Globalization {
                 calendar = (Calendar) GregorianCalendar.GetDefaultInstance().Clone();
                 calendar.SetReadOnlyState(m_isReadOnly);
             }
-            else
-            {
-                CultureInfo.CheckDomainSafetyObject(calendar, this);
-            }
             InitializeOverridableProperties(m_cultureData, calendar.ID);
 
             //
@@ -587,12 +579,6 @@ namespace System.Globalization {
                     return;
                 }
 
-                //
-                // Because the culture is agile object which can be attached to a thread and then thread can travel
-                // to another app domain then we prevent attaching any customized object to culture that we cannot contol.
-                //
-                CultureInfo.CheckDomainSafetyObject(value, this);
-
                 for (int i = 0; i < this.OptionalCalendars.Length; i++)
                 {
                     if (this.OptionalCalendars[i] == value.ID)
@@ -1370,7 +1356,6 @@ namespace System.Globalization {
 
 
         // Returns the string array of the one-letter day of week names.
-        [System.Runtime.InteropServices.ComVisible(false)]
         public String[] ShortestDayNames
         {
             get
@@ -1593,7 +1578,6 @@ namespace System.Globalization {
 
 
         // Returns the super short day of week names for the specified day of week.
-        [System.Runtime.InteropServices.ComVisible(false)]
         public  String GetShortestDayName(DayOfWeek dayOfWeek)
         {
 
@@ -1971,7 +1955,6 @@ namespace System.Globalization {
         // String nativeName = dtfi.NativeCalendarName; // Get the Japanese name for the Japanese calendar.
         // DateTimeFormatInfo dtfi = new CultureInfo("ja-JP", false).DateTimeFormat.Calendar = new GregorianCalendar(GregorianCalendarTypes.Localized);
         // String nativeName = dtfi.NativeCalendarName; // Get the Japanese name for the Gregorian calendar.
-        [System.Runtime.InteropServices.ComVisible(false)]
         public String NativeCalendarName
         {
             get
@@ -1998,7 +1981,6 @@ namespace System.Globalization {
         // WARNING: If more validation is ever done in one place, it should be done in the other.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public void SetAllDateTimePatterns(String[] patterns, char format)
         {
             if (IsReadOnly)
@@ -2061,7 +2043,6 @@ namespace System.Globalization {
             return;
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public String[] AbbreviatedMonthGenitiveNames
         {
             get
@@ -2089,7 +2070,6 @@ namespace System.Globalization {
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public String[] MonthGenitiveNames
          {
             get
diff --git a/src/mscorlib/src/System/Globalization/DateTimeStyles.cs b/src/mscorlib/src/System/Globalization/DateTimeStyles.cs
index ddae7b2f29..eadeda8e72 100644
--- a/src/mscorlib/src/System/Globalization/DateTimeStyles.cs
+++ b/src/mscorlib/src/System/Globalization/DateTimeStyles.cs
@@ -16,7 +16,6 @@ namespace System.Globalization {
 
 [Serializable]
     [Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum DateTimeStyles {
         // Bit flag indicating that leading whitespace is allowed. Character values
         // 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, and 0x0020 are considered to be
diff --git a/src/mscorlib/src/System/Globalization/DaylightTime.cs b/src/mscorlib/src/System/Globalization/DaylightTime.cs
index a164867576..a21e092955 100644
--- a/src/mscorlib/src/System/Globalization/DaylightTime.cs
+++ b/src/mscorlib/src/System/Globalization/DaylightTime.cs
@@ -8,7 +8,6 @@ namespace System.Globalization
 {
     // This class represents a starting/ending time for a period of daylight saving time.
     [Serializable]
-    [ComVisible(true)]
     public class DaylightTime
     {
         internal DateTime m_start;
diff --git a/src/mscorlib/src/System/Globalization/DigitShapes.cs b/src/mscorlib/src/System/Globalization/DigitShapes.cs
index d5b5ecc89c..1513d56f5c 100644
--- a/src/mscorlib/src/System/Globalization/DigitShapes.cs
+++ b/src/mscorlib/src/System/Globalization/DigitShapes.cs
@@ -9,7 +9,6 @@ namespace System.Globalization {
 
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum DigitShapes : int {
 
         Context         = 0x0000,   // The shape depends on the previous text in the same output.
diff --git a/src/mscorlib/src/System/Globalization/EastAsianLunisolarCalendar.cs b/src/mscorlib/src/System/Globalization/EastAsianLunisolarCalendar.cs
index 3c9391fa63..3f6df52a96 100644
--- a/src/mscorlib/src/System/Globalization/EastAsianLunisolarCalendar.cs
+++ b/src/mscorlib/src/System/Globalization/EastAsianLunisolarCalendar.cs
@@ -14,7 +14,6 @@ namespace System.Globalization {
 
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public abstract class EastAsianLunisolarCalendar : Calendar {
         internal const int LeapMonth = 0;
         internal const int Jan1Month = 1;
diff --git a/src/mscorlib/src/System/Globalization/EncodingTable.cs b/src/mscorlib/src/System/Globalization/EncodingTable.cs
index d908a2ac2b..b7c268a956 100644
--- a/src/mscorlib/src/System/Globalization/EncodingTable.cs
+++ b/src/mscorlib/src/System/Globalization/EncodingTable.cs
@@ -203,10 +203,6 @@ namespace System.Globalization
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         private unsafe static extern InternalCodePageDataItem* GetCodePageData();
-
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        internal unsafe static extern byte* nativeCreateOpenFileMapping(
-            String inSectionName, int inBytesToAllocate, out IntPtr mappedFileHandle);   
     }
     
     /*=================================InternalEncodingDataItem==========================
diff --git a/src/mscorlib/src/System/Globalization/GlobalizationAssembly.cs b/src/mscorlib/src/System/Globalization/GlobalizationAssembly.cs
index 0810d67b59..e203223eb0 100644
--- a/src/mscorlib/src/System/Globalization/GlobalizationAssembly.cs
+++ b/src/mscorlib/src/System/Globalization/GlobalizationAssembly.cs
@@ -10,7 +10,6 @@ namespace System.Globalization {
     using System.Collections.Generic;
     using System.Threading;
     using System.Security;
-    using System.Security.Permissions;
     using System.Runtime.CompilerServices;
     using System.Runtime.ConstrainedExecution;
     using System.Runtime.Versioning;
diff --git a/src/mscorlib/src/System/Globalization/GregorianCalendar.cs b/src/mscorlib/src/System/Globalization/GregorianCalendar.cs
index 6cf9b2eb85..9083e6de27 100644
--- a/src/mscorlib/src/System/Globalization/GregorianCalendar.cs
+++ b/src/mscorlib/src/System/Globalization/GregorianCalendar.cs
@@ -22,7 +22,6 @@ namespace System.Globalization {
     // 0 CurrentEra (AD)
     // 1 BeforeCurrentEra (BC)
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class GregorianCalendar : Calendar
     {
@@ -77,7 +76,6 @@ namespace System.Globalization {
         }
 #endregion Serialization
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MinSupportedDateTime
         {
             get
@@ -86,7 +84,6 @@ namespace System.Globalization {
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MaxSupportedDateTime
         {
             get
@@ -98,7 +95,6 @@ namespace System.Globalization {
         // Return the type of the Gregorian calendar.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override CalendarAlgorithmType AlgorithmType
         {
             get
@@ -495,7 +491,6 @@ namespace System.Globalization {
         // if this calendar does not have leap month, or this year is not a leap year.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetLeapMonth(int year, int era)
         {
             if (era != CurrentEra && era != ADEra)
diff --git a/src/mscorlib/src/System/Globalization/GregorianCalendarTypes.cs b/src/mscorlib/src/System/Globalization/GregorianCalendarTypes.cs
index a9e25d06bf..1af5e9221c 100644
--- a/src/mscorlib/src/System/Globalization/GregorianCalendarTypes.cs
+++ b/src/mscorlib/src/System/Globalization/GregorianCalendarTypes.cs
@@ -6,7 +6,6 @@ namespace System.Globalization {
     using System;
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum GregorianCalendarTypes {
         Localized = Calendar.CAL_GREGORIAN,
         USEnglish = Calendar.CAL_GREGORIAN_US,
diff --git a/src/mscorlib/src/System/Globalization/HebrewCalendar.cs b/src/mscorlib/src/System/Globalization/HebrewCalendar.cs
index 44cbdb8bde..190c3f17d2 100644
--- a/src/mscorlib/src/System/Globalization/HebrewCalendar.cs
+++ b/src/mscorlib/src/System/Globalization/HebrewCalendar.cs
@@ -64,7 +64,6 @@ namespace System.Globalization {
 
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public class HebrewCalendar : Calendar {
 
 
diff --git a/src/mscorlib/src/System/Globalization/HijriCalendar.cs b/src/mscorlib/src/System/Globalization/HijriCalendar.cs
index 39a01e5774..061d380285 100644
--- a/src/mscorlib/src/System/Globalization/HijriCalendar.cs
+++ b/src/mscorlib/src/System/Globalization/HijriCalendar.cs
@@ -49,7 +49,6 @@ namespace System.Globalization {
      */
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public class HijriCalendar : Calendar {
 
 
@@ -84,7 +83,6 @@ namespace System.Globalization {
         internal static readonly DateTime calendarMaxValue = DateTime.MaxValue;
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MinSupportedDateTime
         {
             get
@@ -94,7 +92,6 @@ namespace System.Globalization {
         }
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MaxSupportedDateTime
         {
             get
@@ -106,7 +103,6 @@ namespace System.Globalization {
         // Return the type of the Hijri calendar.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override CalendarAlgorithmType AlgorithmType
         {
             get
@@ -614,7 +610,6 @@ namespace System.Globalization {
         // if this calendar does not have leap month, or this year is not a leap year.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetLeapMonth(int year, int era)
         {
             CheckYearRange(year, era);
diff --git a/src/mscorlib/src/System/Globalization/JapaneseCalendar.cs b/src/mscorlib/src/System/Globalization/JapaneseCalendar.cs
index aeb60be3c0..72331f8346 100644
--- a/src/mscorlib/src/System/Globalization/JapaneseCalendar.cs
+++ b/src/mscorlib/src/System/Globalization/JapaneseCalendar.cs
@@ -8,8 +8,6 @@ namespace System.Globalization {
     using System.Diagnostics.CodeAnalysis;
     using System.Diagnostics.Contracts;
     using Microsoft.Win32;
-    using PermissionSet = System.Security.PermissionSet;
-    using System.Security.Permissions;
 
     /*=================================JapaneseCalendar==========================
     **
@@ -41,13 +39,11 @@ namespace System.Globalization {
 
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public class JapaneseCalendar : Calendar
     {
         internal static readonly DateTime calendarMinValue = new DateTime(1868, 9, 8);
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MinSupportedDateTime
         {
             get
@@ -56,7 +52,6 @@ namespace System.Globalization {
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MaxSupportedDateTime
         {
             get
@@ -68,7 +63,6 @@ namespace System.Globalization {
         // Return the type of the Japanese calendar.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override CalendarAlgorithmType AlgorithmType
         {
             get
@@ -167,10 +161,6 @@ namespace System.Globalization {
             
             try
             {
-                // Need to access registry
-                PermissionSet permSet = new PermissionSet(PermissionState.None);
-                permSet.AddPermission(new RegistryPermission(RegistryPermissionAccess.Read, c_japaneseErasHivePermissionList));
-                permSet.Assert();
                 RegistryKey key = Registry.LocalMachine.OpenSubKey(c_japaneseErasHive, writable: false);
 
                 // Abort if we didn't find anything
@@ -425,7 +415,6 @@ namespace System.Globalization {
 
 
         [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
         {
             return (helper.GetWeekOfYear(time, rule, firstDayOfWeek));
@@ -469,7 +458,6 @@ namespace System.Globalization {
         // if this calendar does not have leap month, or this year is not a leap year.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetLeapMonth(int year, int era)
         {
             return (helper.GetLeapMonth(year, era));
diff --git a/src/mscorlib/src/System/Globalization/JulianCalendar.cs b/src/mscorlib/src/System/Globalization/JulianCalendar.cs
index db286e0363..ff8801433c 100644
--- a/src/mscorlib/src/System/Globalization/JulianCalendar.cs
+++ b/src/mscorlib/src/System/Globalization/JulianCalendar.cs
@@ -18,7 +18,6 @@ namespace System.Globalization {
     //*      Julia       0001/01/03   9999/10/19
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public class JulianCalendar : Calendar {
 
 
@@ -51,7 +50,6 @@ namespace System.Globalization {
         internal int MaxYear = 9999;
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MinSupportedDateTime
         {
             get
@@ -60,7 +58,6 @@ namespace System.Globalization {
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MaxSupportedDateTime
         {
             get
@@ -72,7 +69,6 @@ namespace System.Globalization {
         // Return the type of the Julian calendar.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override CalendarAlgorithmType AlgorithmType
         {
             get
@@ -344,7 +340,6 @@ namespace System.Globalization {
         // if this calendar does not have leap month, or this year is not a leap year.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetLeapMonth(int year, int era)
         {
             CheckYearEraRange(year, era);
diff --git a/src/mscorlib/src/System/Globalization/KoreanCalendar.cs b/src/mscorlib/src/System/Globalization/KoreanCalendar.cs
index dde82b6e6b..6c5a03b7e8 100644
--- a/src/mscorlib/src/System/Globalization/KoreanCalendar.cs
+++ b/src/mscorlib/src/System/Globalization/KoreanCalendar.cs
@@ -24,7 +24,6 @@ namespace System.Globalization {
     ============================================================================*/
 
 
-[System.Runtime.InteropServices.ComVisible(true)]
     [Serializable] public class KoreanCalendar: Calendar {
         //
         // The era value for the current era.
@@ -49,7 +48,6 @@ namespace System.Globalization {
         internal GregorianCalendarHelper helper;
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MinSupportedDateTime
         {
             get
@@ -58,7 +56,6 @@ namespace System.Globalization {
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MaxSupportedDateTime
         {
             get
@@ -70,7 +67,6 @@ namespace System.Globalization {
         // Return the type of the Korean calendar.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override CalendarAlgorithmType AlgorithmType
         {
             get
@@ -165,7 +161,6 @@ namespace System.Globalization {
 
 
         [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
         {
             return (helper.GetWeekOfYear(time, rule, firstDayOfWeek));
@@ -200,7 +195,6 @@ namespace System.Globalization {
         // if this calendar does not have leap month, or this year is not a leap year.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetLeapMonth(int year, int era)
         {
             return (helper.GetLeapMonth(year, era));
diff --git a/src/mscorlib/src/System/Globalization/NumberFormatInfo.cs b/src/mscorlib/src/System/Globalization/NumberFormatInfo.cs
index 9d9c6f2db8..d95aac3d3d 100644
--- a/src/mscorlib/src/System/Globalization/NumberFormatInfo.cs
+++ b/src/mscorlib/src/System/Globalization/NumberFormatInfo.cs
@@ -3,7 +3,6 @@
 // See the LICENSE file in the project root for more information.
 
 namespace System.Globalization {
-    using System.Security.Permissions;
     using System.Runtime.Serialization;
     using System.Text;
     using System;
@@ -41,7 +40,6 @@ namespace System.Globalization {
     //
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     sealed public partial class NumberFormatInfo : ICloneable, IFormatProvider
     {
         // invariantInfo is constant irrespective of your current culture.
@@ -736,7 +734,6 @@ namespace System.Globalization {
         }
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public String[] NativeDigits
         {
             get { return (String[])nativeDigits.Clone(); }
@@ -748,7 +745,6 @@ namespace System.Globalization {
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public DigitShapes DigitSubstitution
         {
             get { return (DigitShapes)digitSubstitution; }
diff --git a/src/mscorlib/src/System/Globalization/NumberStyles.cs b/src/mscorlib/src/System/Globalization/NumberStyles.cs
index 42b9847ed3..969c07fc2a 100644
--- a/src/mscorlib/src/System/Globalization/NumberStyles.cs
+++ b/src/mscorlib/src/System/Globalization/NumberStyles.cs
@@ -16,7 +16,6 @@ namespace System.Globalization {
     using System;
     [Serializable]
     [Flags]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum NumberStyles {
         // Bit flag indicating that leading whitespace is allowed. Character values
         // 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, and 0x0020 are considered to be
diff --git a/src/mscorlib/src/System/Globalization/RegionInfo.cs b/src/mscorlib/src/System/Globalization/RegionInfo.cs
index 4bed87570f..b719af7128 100644
--- a/src/mscorlib/src/System/Globalization/RegionInfo.cs
+++ b/src/mscorlib/src/System/Globalization/RegionInfo.cs
@@ -23,7 +23,6 @@ namespace System.Globalization {
     using System.Diagnostics.Contracts;
 
     [Serializable] 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public partial class RegionInfo
     {
         //--------------------------------------------------------------------//
@@ -259,7 +258,6 @@ namespace System.Globalization {
         //  WARNING: You need a full locale name for this to make sense.        
         //
         ////////////////////////////////////////////////////////////////////////
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual String NativeName
         {
             get
@@ -329,7 +327,6 @@ namespace System.Globalization {
         }
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]        
         public virtual int GeoId 
         {
             get 
@@ -345,7 +342,6 @@ namespace System.Globalization {
         //  English name for this region's currency, ie: Swiss Franc
         //
         ////////////////////////////////////////////////////////////////////////
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual String CurrencyEnglishName
         {
             get
@@ -362,7 +358,6 @@ namespace System.Globalization {
         //  WARNING: You need a full locale name for this to make sense.
         //
         ////////////////////////////////////////////////////////////////////////
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual String CurrencyNativeName
         {
             get
diff --git a/src/mscorlib/src/System/Globalization/SortKey.cs b/src/mscorlib/src/System/Globalization/SortKey.cs
index 9c35f485e5..7c7408b009 100644
--- a/src/mscorlib/src/System/Globalization/SortKey.cs
+++ b/src/mscorlib/src/System/Globalization/SortKey.cs
@@ -19,7 +19,6 @@ namespace System.Globalization {
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public partial class SortKey
     {
diff --git a/src/mscorlib/src/System/Globalization/StringInfo.cs b/src/mscorlib/src/System/Globalization/StringInfo.cs
index d86e11592e..dc32fe9493 100644
--- a/src/mscorlib/src/System/Globalization/StringInfo.cs
+++ b/src/mscorlib/src/System/Globalization/StringInfo.cs
@@ -16,12 +16,10 @@ namespace System.Globalization {
   
     using System;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class StringInfo  
     {
 
@@ -57,7 +55,6 @@ namespace System.Globalization {
         }   
 #endregion Serialization
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override bool Equals(Object value)
         {
             StringInfo that = value as StringInfo;
@@ -68,7 +65,6 @@ namespace System.Globalization {
             return (false);
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetHashCode()
         {
             return this.m_str.GetHashCode();
diff --git a/src/mscorlib/src/System/Globalization/TaiwanCalendar.cs b/src/mscorlib/src/System/Globalization/TaiwanCalendar.cs
index 476ddeef7c..ec84a06b76 100644
--- a/src/mscorlib/src/System/Globalization/TaiwanCalendar.cs
+++ b/src/mscorlib/src/System/Globalization/TaiwanCalendar.cs
@@ -22,7 +22,6 @@ namespace System.Globalization {
     ============================================================================*/
     /* SSS_WARNINGS_ON */ /* SSS_DROP_END */  
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable] public class TaiwanCalendar: Calendar {
         //
         // The era value for the current era.
@@ -62,7 +61,6 @@ namespace System.Globalization {
         internal static readonly DateTime calendarMinValue = new DateTime(1912, 1, 1);
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MinSupportedDateTime
         {
             get
@@ -71,7 +69,6 @@ namespace System.Globalization {
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MaxSupportedDateTime
         {
             get
@@ -83,7 +80,6 @@ namespace System.Globalization {
         // Return the type of the Taiwan calendar.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override CalendarAlgorithmType AlgorithmType
         {
             get
@@ -151,7 +147,6 @@ namespace System.Globalization {
 
 
         [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
         {
             return (helper.GetWeekOfYear(time, rule, firstDayOfWeek));
@@ -186,7 +181,6 @@ namespace System.Globalization {
         // if this calendar does not have leap month, or this year is not a leap year.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetLeapMonth(int year, int era)
         {
             return (helper.GetLeapMonth(year, era));
diff --git a/src/mscorlib/src/System/Globalization/TextElementEnumerator.cs b/src/mscorlib/src/System/Globalization/TextElementEnumerator.cs
index 049ccf6f81..0fee7a0745 100644
--- a/src/mscorlib/src/System/Globalization/TextElementEnumerator.cs
+++ b/src/mscorlib/src/System/Globalization/TextElementEnumerator.cs
@@ -23,7 +23,6 @@ namespace System.Globalization {
     //
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class TextElementEnumerator: IEnumerator
     {
         private String str;
diff --git a/src/mscorlib/src/System/Globalization/TextInfo.cs b/src/mscorlib/src/System/Globalization/TextInfo.cs
index c8108e4922..9ece275dd3 100644
--- a/src/mscorlib/src/System/Globalization/TextInfo.cs
+++ b/src/mscorlib/src/System/Globalization/TextInfo.cs
@@ -23,13 +23,11 @@ namespace System.Globalization {
     using System.Runtime.CompilerServices;
     using System.Runtime.Serialization;
     using System.Runtime.Versioning;
-    using System.Security.Permissions;
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
 
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public partial class TextInfo : ICloneable, IDeserializationCallback
     {
         //--------------------------------------------------------------------//
@@ -378,7 +376,6 @@ namespace System.Globalization {
         ////////////////////////////////////////////////////////////////////////
 
 #if FEATURE_USE_LCID
-        [System.Runtime.InteropServices.ComVisible(false)]
         public int LCID 
         {
             get 
@@ -395,7 +392,6 @@ namespace System.Globalization {
         //  The name of the culture associated with the current TextInfo.
         //
         ////////////////////////////////////////////////////////////////////////
-        [System.Runtime.InteropServices.ComVisible(false)]
         public string CultureName 
         {
             get 
@@ -411,7 +407,6 @@ namespace System.Globalization {
         //  Detect if the object is readonly.
         //
         ////////////////////////////////////////////////////////////////////////
-        [System.Runtime.InteropServices.ComVisible(false)]
         public bool IsReadOnly 
         {
             get { return (m_isReadOnly); }
@@ -424,7 +419,6 @@ namespace System.Globalization {
         //  Is the implementation of ICloneable.
         //
         ////////////////////////////////////////////////////////////////////////
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual Object Clone()
         {
             object o = MemberwiseClone();
@@ -440,7 +434,6 @@ namespace System.Globalization {
         //  readonly.
         //
         ////////////////////////////////////////////////////////////////////////
-        [System.Runtime.InteropServices.ComVisible(false)]
         public static TextInfo ReadOnly(TextInfo textInfo) 
         {
             if (textInfo == null)       { throw new ArgumentNullException(nameof(textInfo)); }
@@ -487,7 +480,6 @@ namespace System.Globalization {
                 return (m_listSeparator);
             }
 
-            [System.Runtime.InteropServices.ComVisible(false)]
             set 
             {
                 if (value == null) 
@@ -901,7 +893,6 @@ namespace System.Globalization {
         //
         // Returns true if the dominant direction of text and UI such as the relative position of buttons and scroll bars
         //
-        [System.Runtime.InteropServices.ComVisible(false)]
         public bool IsRightToLeft
         {
             get
diff --git a/src/mscorlib/src/System/Globalization/ThaiBuddhistCalendar.cs b/src/mscorlib/src/System/Globalization/ThaiBuddhistCalendar.cs
index e294b51325..762c3ca7cb 100644
--- a/src/mscorlib/src/System/Globalization/ThaiBuddhistCalendar.cs
+++ b/src/mscorlib/src/System/Globalization/ThaiBuddhistCalendar.cs
@@ -21,7 +21,6 @@ namespace System.Globalization {
     ============================================================================*/
 
 
-[System.Runtime.InteropServices.ComVisible(true)]
     [Serializable] public class ThaiBuddhistCalendar: Calendar {
 
         // Initialize our era info.
@@ -40,7 +39,6 @@ namespace System.Globalization {
         internal GregorianCalendarHelper helper;
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MinSupportedDateTime
         {
             get
@@ -49,7 +47,6 @@ namespace System.Globalization {
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override DateTime MaxSupportedDateTime
         {
             get
@@ -61,7 +58,6 @@ namespace System.Globalization {
         // Return the type of the Thai Buddhist calendar.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override CalendarAlgorithmType AlgorithmType
         {
             get
@@ -123,7 +119,6 @@ namespace System.Globalization {
 
 
         [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
         {
             return (helper.GetWeekOfYear(time, rule, firstDayOfWeek));
@@ -158,7 +153,6 @@ namespace System.Globalization {
         // if this calendar does not have leap month, or this year is not a leap year.
         //
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetLeapMonth(int year, int era)
         {
             return (helper.GetLeapMonth(year, era));
diff --git a/src/mscorlib/src/System/Globalization/UnicodeCategory.cs b/src/mscorlib/src/System/Globalization/UnicodeCategory.cs
index 3848b6142f..c9898f135b 100644
--- a/src/mscorlib/src/System/Globalization/UnicodeCategory.cs
+++ b/src/mscorlib/src/System/Globalization/UnicodeCategory.cs
@@ -13,7 +13,6 @@
 namespace System.Globalization {
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum UnicodeCategory {
 
         UppercaseLetter = 0,
diff --git a/src/mscorlib/src/System/Guid.cs b/src/mscorlib/src/System/Guid.cs
index e2e36ba1b2..1116faf027 100644
--- a/src/mscorlib/src/System/Guid.cs
+++ b/src/mscorlib/src/System/Guid.cs
@@ -16,7 +16,6 @@ namespace System {
     // Represents a Globally Unique Identifier.
     [StructLayout(LayoutKind.Sequential)]
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     [System.Runtime.Versioning.NonVersionable] // This only applies to field layout
     public struct Guid : IFormattable, IComparable
         , IComparable<Guid>, IEquatable<Guid>
@@ -756,11 +755,6 @@ namespace System {
         private static unsafe bool StringToShort(String str, int requiredLength, int flags, out short result, ref GuidResult parseResult) {
             return StringToShort(str, null, requiredLength, flags, out result, ref parseResult);
         }
-        private static unsafe bool StringToShort(String str, ref int parsePos, int requiredLength, int flags, out short result, ref GuidResult parseResult) {
-            fixed(int * ppos = &parsePos) {
-                return StringToShort(str, ppos, requiredLength, flags, out result, ref parseResult);
-            }
-        }
         private static unsafe bool StringToShort(String str, int* parsePos, int requiredLength, int flags, out short result, ref GuidResult parseResult) {
             result = 0;
             int x;
@@ -813,9 +807,6 @@ namespace System {
             }
             return true;
         }
-        private static unsafe bool StringToLong(String str, int flags, out long result, ref GuidResult parseResult) {
-            return StringToLong(str, null, flags, out result, ref parseResult);
-        }
         private static unsafe bool StringToLong(String str, ref int parsePos, int flags, out long result, ref GuidResult parseResult) {
             fixed(int * ppos = &parsePos) {
                 return StringToLong(str, ppos, flags, out result, ref parseResult);
diff --git a/src/mscorlib/src/System/IAppDomain.cs b/src/mscorlib/src/System/IAppDomain.cs
deleted file mode 100644
index cdb83166c8..0000000000
--- a/src/mscorlib/src/System/IAppDomain.cs
+++ /dev/null
@@ -1,28 +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.
-
-/*============================================================
-**
-** Interface:  IAppDomain
-** 
-** 
-**
-**
-** Purpose: Properties and methods exposed to COM
-**
-** 
-===========================================================*/
-namespace System
-{
-    using System.Runtime.InteropServices;
-
-    [GuidAttribute("05F696DC-2B29-3663-AD8B-C4389CF2A713")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _AppDomain
-    {
-    }
-}
-
diff --git a/src/mscorlib/src/System/IAppDomainPauseManager.cs b/src/mscorlib/src/System/IAppDomainPauseManager.cs
index 902a79bd2a..cd3a9033de 100644
--- a/src/mscorlib/src/System/IAppDomainPauseManager.cs
+++ b/src/mscorlib/src/System/IAppDomainPauseManager.cs
@@ -32,46 +32,6 @@ namespace System
         }
         
         static readonly AppDomainPauseManager instance = new AppDomainPauseManager();
-        internal static AppDomainPauseManager Instance
-        {
-            get { return instance; }
-        }
-
-        // FAS: IAppDomainPauseConsumer interface implementation
-        // currently there is nothing we do here as the implementation
-        // of updating pause times have been moved to native CorHost2
-        public void Pausing()
-        {
-        }
-
-        public void Paused()
-        {
-            Debug.Assert(!isPaused);
-
-            if(ResumeEvent == null)
-                ResumeEvent = new ManualResetEvent(false);
-            else
-                ResumeEvent.Reset();
-
-            Timer.Pause();
-
-            // Set IsPaused at the last as other threads seeing it set, will expect a valid
-            // reset ResumeEvent. Also the requirement here is that only after Paused
-            // returns other threads should block on this event. So there is a race condition here.
-            isPaused = true;
-        }
-
-        public void Resuming()
-        {
-            Debug.Assert(isPaused);
-            isPaused = false;
-            ResumeEvent.Set();
-        }
-
-        public void Resumed()
-        {
-            Timer.Resume();
-        }
    
         private static volatile bool isPaused;
 
diff --git a/src/mscorlib/src/System/IAsyncResult.cs b/src/mscorlib/src/System/IAsyncResult.cs
index 2591c726c7..0abeaca525 100644
--- a/src/mscorlib/src/System/IAsyncResult.cs
+++ b/src/mscorlib/src/System/IAsyncResult.cs
@@ -10,11 +10,12 @@
 **          operation
 **
 ===========================================================*/
-namespace System {
-    
-    using System;
-    using System.Threading;
-[System.Runtime.InteropServices.ComVisible(true)]
+
+using System;
+using System.Threading;
+
+namespace System
+{
     public interface IAsyncResult
     {
         bool IsCompleted { get; }
@@ -22,11 +23,8 @@ namespace System {
         WaitHandle AsyncWaitHandle { get; }
 
 
-        Object     AsyncState      { get; }
+        Object AsyncState { get; }
 
-        bool       CompletedSynchronously { get; }
-   
-    
+        bool CompletedSynchronously { get; }
     }
-
 }
diff --git a/src/mscorlib/src/System/ICloneable.cs b/src/mscorlib/src/System/ICloneable.cs
index 2931802539..49657c2765 100644
--- a/src/mscorlib/src/System/ICloneable.cs
+++ b/src/mscorlib/src/System/ICloneable.cs
@@ -16,7 +16,6 @@ namespace System {
     // method which is called to create a clone of the object.   Object defines a method
     // MemberwiseClone to support default clone operations.
     // 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public interface ICloneable
     {
         // Interface does not need to be marked with the serializable attribute
diff --git a/src/mscorlib/src/System/IComparable.cs b/src/mscorlib/src/System/IComparable.cs
index 111d892129..72aeeb027c 100644
--- a/src/mscorlib/src/System/IComparable.cs
+++ b/src/mscorlib/src/System/IComparable.cs
@@ -2,18 +2,16 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-namespace System {
-    
-    using System;
+namespace System
+{
     // The IComparable interface is implemented by classes that support an
     // ordering of instances of the class. The ordering represented by
     // IComparable can be used to sort arrays and collections of objects
     // that implement the interface.
     // 
-[System.Runtime.InteropServices.ComVisible(true)]
     public interface IComparable
     {
-    // Interface does not need to be marked with the serializable attribute
+        // Interface does not need to be marked with the serializable attribute
         // Compares this object to another object, returning an integer that
         // indicates the relationship. An implementation of this method must return
         // a value less than zero if this is less than object, zero
diff --git a/src/mscorlib/src/System/IConvertible.cs b/src/mscorlib/src/System/IConvertible.cs
index 174b25b180..87351127f2 100644
--- a/src/mscorlib/src/System/IConvertible.cs
+++ b/src/mscorlib/src/System/IConvertible.cs
@@ -2,15 +2,12 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-namespace System {
-
-    using System.Diagnostics.Contracts;
-    using System.Threading;
-
+namespace System
+{
     // The IConvertible interface represents an object that contains a value. This
     // interface is implemented by the following types in the System namespace:
     // Boolean, Char, SByte, Byte, Int16, UInt16, Int32, UInt32, Int64, UInt64,
-    // Single, Double, Decimal, DateTime, TimeSpan, and String. The interface may
+    // Single, Double, Decimal, DateTime, and String. The interface may
     // be implemented by other types that are to be considered values. For example,
     // a library of nullable database types could implement IConvertible.
     //
@@ -23,7 +20,6 @@ namespace System {
     // IConvertible implementation should simply throw an InvalidCastException.
 
     [CLSCompliant(false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public interface IConvertible
     {
         // Returns the type code of this object. An implementation of this method
diff --git a/src/mscorlib/src/System/ICustomFormatter.cs b/src/mscorlib/src/System/ICustomFormatter.cs
index cbc3816a82..47340f3093 100644
--- a/src/mscorlib/src/System/ICustomFormatter.cs
+++ b/src/mscorlib/src/System/ICustomFormatter.cs
@@ -11,15 +11,14 @@
 **
 **
 ===========================================================*/
-namespace System {
-    
-    using System;
-    using System.Runtime.Serialization;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
+using System;
+
+namespace System
+{
     public interface ICustomFormatter
     {
         // Interface does not need to be marked with the serializable attribute
-        String Format (String format, Object arg, IFormatProvider formatProvider);
+        String Format(String format, Object arg, IFormatProvider formatProvider);
     }
 }
diff --git a/src/mscorlib/src/System/IDisposable.cs b/src/mscorlib/src/System/IDisposable.cs
index fcb65bea14..24f0740edc 100644
--- a/src/mscorlib/src/System/IDisposable.cs
+++ b/src/mscorlib/src/System/IDisposable.cs
@@ -11,7 +11,9 @@
 **
 ** 
 ===========================================================*/
-namespace System {
+
+namespace System
+{
     // IDisposable is an attempt at helping to solve problems with deterministic
     // finalization.  The GC of course doesn't leave any way to deterministically
     // know when a finalizer will run.  This forces classes that hold onto OS
@@ -51,8 +53,8 @@ namespace System {
     // data buffered by the StreamWriter cannot be written to the Stream.  In this
     // case, it doesn't make much sense to provide a finalizer on the StreamWriter
     // since you cannot solve this problem correctly.  
-[System.Runtime.InteropServices.ComVisible(true)]
-    public interface IDisposable {
+    public interface IDisposable
+    {
         void Dispose();
     }
 }
diff --git a/src/mscorlib/src/System/IEquatable.cs b/src/mscorlib/src/System/IEquatable.cs
index aa034da68c..1264fdd57a 100644
--- a/src/mscorlib/src/System/IEquatable.cs
+++ b/src/mscorlib/src/System/IEquatable.cs
@@ -2,13 +2,13 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-namespace System {
-    
-    using System;    
+using System;
+
+namespace System
+{
     public interface IEquatable<T>
     {
         bool Equals(T other);
     }
-
 }
 
diff --git a/src/mscorlib/src/System/IFormatProvider.cs b/src/mscorlib/src/System/IFormatProvider.cs
index a5cc783969..0c17354af3 100644
--- a/src/mscorlib/src/System/IFormatProvider.cs
+++ b/src/mscorlib/src/System/IFormatProvider.cs
@@ -10,11 +10,11 @@
 **
 **
 ============================================================*/
-namespace System {
-    
-    using System;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
+using System;
+
+namespace System
+{
     public interface IFormatProvider
     {
         // Interface does not need to be marked with the serializable attribute
diff --git a/src/mscorlib/src/System/IFormattable.cs b/src/mscorlib/src/System/IFormattable.cs
index 414b4686df..28a7d70571 100644
--- a/src/mscorlib/src/System/IFormattable.cs
+++ b/src/mscorlib/src/System/IFormattable.cs
@@ -2,12 +2,11 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-namespace System {
-    
-    using System;
-    using System.Diagnostics.Contracts;
+using System;
+using System.Diagnostics.Contracts;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
+namespace System
+{
     public interface IFormattable
     {
         [Pure]
diff --git a/src/mscorlib/src/System/IO/BinaryReader.cs b/src/mscorlib/src/System/IO/BinaryReader.cs
index 4145a7f4f6..d973860472 100644
--- a/src/mscorlib/src/System/IO/BinaryReader.cs
+++ b/src/mscorlib/src/System/IO/BinaryReader.cs
@@ -23,7 +23,6 @@ namespace System.IO {
     using System.Diagnostics.Contracts;
     using System.Security;
 
-[System.Runtime.InteropServices.ComVisible(true)]
     public class BinaryReader : IDisposable
     {
         private const int MaxCharBytesSize = 128;
diff --git a/src/mscorlib/src/System/IO/BinaryWriter.cs b/src/mscorlib/src/System/IO/BinaryWriter.cs
index f99b4d3d42..b6c562534c 100644
--- a/src/mscorlib/src/System/IO/BinaryWriter.cs
+++ b/src/mscorlib/src/System/IO/BinaryWriter.cs
@@ -26,7 +26,6 @@ namespace System.IO {
     // give unique encodings.
     //
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class BinaryWriter : IDisposable
     {
         public static readonly BinaryWriter Null = new BinaryWriter();
@@ -185,7 +184,7 @@ namespace System.IO {
 
             Debug.Assert(_encoding.GetMaxByteCount(1) <= 16, "_encoding.GetMaxByteCount(1) <= 16)");
             int numBytes = 0;
-            fixed(byte * pBytes = _buffer) {
+            fixed(byte * pBytes = &_buffer[0]) {
                 numBytes = _encoder.GetBytes(&ch, 1, pBytes, _buffer.Length, flush: true);
             }
             OutStream.Write(_buffer, 0, numBytes);
@@ -382,7 +381,7 @@ namespace System.IO {
                         }
                         fixed (char* pChars = value)
                         {
-                            fixed (byte* pBytes = _largeByteBuffer)
+                            fixed (byte* pBytes = &_largeByteBuffer[0])
                             {
                                 byteLen = _encoder.GetBytes(pChars + charStart, charCount, pBytes, _largeByteBuffer.Length, charCount == numLeft);
                             }
diff --git a/src/mscorlib/src/System/IO/Directory.cs b/src/mscorlib/src/System/IO/Directory.cs
index c3b150d470..88a669a971 100644
--- a/src/mscorlib/src/System/IO/Directory.cs
+++ b/src/mscorlib/src/System/IO/Directory.cs
@@ -17,7 +17,6 @@
 
 using System.Collections.Generic;
 using System.Security;
-using System.Security.Permissions;
 using Microsoft.Win32;
 using Microsoft.Win32.SafeHandles;
 using System.Runtime.InteropServices;
@@ -26,8 +25,7 @@ using System.Diagnostics.Contracts;
 
 namespace System.IO
 {
-    [ComVisible(true)]
-    public static class Directory {
+    internal static class Directory {
 
         // Private class that holds search data that is passed around 
         // in the heap based stack recursion
@@ -49,6 +47,7 @@ namespace System.IO
             public readonly SearchOption searchOption;
         }
 
+#if PLATFORM_UNIX
         public static IEnumerable<String> EnumerateFiles(String path, String searchPattern, SearchOption searchOption)
         {
             if (path == null)
@@ -84,13 +83,14 @@ namespace System.IO
             return FileSystemEnumerableFactory.CreateFileNameIterator(path, path, searchPattern,
                                                                         includeFiles, includeDirs, searchOption, true);
         }
+#endif // PLATFORM_UNIX        
 
         internal static String InternalGetDirectoryRoot(String path) {
               if (path == null) return null;
             return path.Substring(0, PathInternal.GetRootLength(path));
         }
 
-         /*===============================CurrentDirectory===============================
+        /*===============================CurrentDirectory===============================
         **Action:  Provides a getter and setter for the current directory.  The original
         **         current DirectoryInfo is the one from which the process was started.  
         **Returns: The current DirectoryInfo (from the getter).  Void from the setter.
diff --git a/src/mscorlib/src/System/IO/DirectoryNotFoundException.cs b/src/mscorlib/src/System/IO/DirectoryNotFoundException.cs
index 09d7e7d4e7..21211a61e7 100644
--- a/src/mscorlib/src/System/IO/DirectoryNotFoundException.cs
+++ b/src/mscorlib/src/System/IO/DirectoryNotFoundException.cs
@@ -23,7 +23,6 @@ namespace System.IO {
      * and STG_E_PATHNOTFOUND (0x80030003).
      */
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class DirectoryNotFoundException : IOException {
         public DirectoryNotFoundException() 
             : base(Environment.GetResourceString("Arg_DirectoryNotFoundException")) {
diff --git a/src/mscorlib/src/System/IO/DriveNotFoundException.cs b/src/mscorlib/src/System/IO/DriveNotFoundException.cs
index 04155bcc0e..f0245a8b28 100644
--- a/src/mscorlib/src/System/IO/DriveNotFoundException.cs
+++ b/src/mscorlib/src/System/IO/DriveNotFoundException.cs
@@ -17,8 +17,7 @@ namespace System.IO {
 
     //Thrown when trying to access a drive that is not availabe.
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public class DriveNotFoundException : IOException {
+    internal class DriveNotFoundException : IOException {
         public DriveNotFoundException() 
             : base(Environment.GetResourceString("Arg_DriveNotFoundException")) {
             SetErrorCode(__HResults.COR_E_DIRECTORYNOTFOUND);
@@ -28,11 +27,6 @@ namespace System.IO {
             : base(message) {
             SetErrorCode(__HResults.COR_E_DIRECTORYNOTFOUND);
         }
-    
-        public DriveNotFoundException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_DIRECTORYNOTFOUND);
-        }
         
         protected DriveNotFoundException(SerializationInfo info, StreamingContext context) : base(info, context) {
         }
diff --git a/src/mscorlib/src/System/IO/EndOfStreamException.cs b/src/mscorlib/src/System/IO/EndOfStreamException.cs
index 60f5109a0f..558c792a9e 100644
--- a/src/mscorlib/src/System/IO/EndOfStreamException.cs
+++ b/src/mscorlib/src/System/IO/EndOfStreamException.cs
@@ -18,7 +18,6 @@ using System.Runtime.Serialization;
 
 namespace System.IO {
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class EndOfStreamException : IOException
     {
         public EndOfStreamException() 
diff --git a/src/mscorlib/src/System/IO/File.cs b/src/mscorlib/src/System/IO/File.cs
index 0adf82283b..7cc3f431a9 100644
--- a/src/mscorlib/src/System/IO/File.cs
+++ b/src/mscorlib/src/System/IO/File.cs
@@ -14,7 +14,6 @@
 **
 ===========================================================*/
 
-using System.Security.Permissions;
 using Win32Native = Microsoft.Win32.Win32Native;
 using System.Runtime.InteropServices;
 using System.Security;
@@ -28,8 +27,7 @@ namespace System.IO
 {
     // Class for creating FileStream objects, and some basic file management
     // routines such as Delete, etc.
-    [ComVisible(true)]
-    public static class File
+    internal static class File
     {
         private const int ERROR_INVALID_PARAMETER = 87;
         internal const int GENERIC_READ = unchecked((int)0x80000000);
@@ -88,7 +86,7 @@ namespace System.IO
         {
             byte[] bytes;
             using(FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 
-                FileStream.DefaultBufferSize, FileOptions.None, Path.GetFileName(path), false, false)) {
+                FileStream.DefaultBufferSize, FileOptions.None)) {
                 // Do a blocking read
                 int index = 0;
                 long fileLength = fs.Length;
@@ -107,6 +105,7 @@ namespace System.IO
             return bytes;
         }
 
+#if PLATFORM_UNIX
         public static String[] ReadAllLines(String path)
         {
             if (path == null)
@@ -133,6 +132,7 @@ namespace System.IO
 
             return lines.ToArray();
         }
+#endif // PLATFORM_UNIX
         
         // Returns 0 on success, otherwise a Win32 error code.  Note that
         // classes should use -1 as the uninitialized state for dataInitialized.
diff --git a/src/mscorlib/src/System/IO/FileAccess.cs b/src/mscorlib/src/System/IO/FileAccess.cs
index f708a284c1..707b58f78b 100644
--- a/src/mscorlib/src/System/IO/FileAccess.cs
+++ b/src/mscorlib/src/System/IO/FileAccess.cs
@@ -23,7 +23,6 @@ namespace System.IO {
     // 
 [Serializable]
 [Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum FileAccess
     {
         // Specifies read access to the file. Data can be read from the file and
diff --git a/src/mscorlib/src/System/IO/FileLoadException.cs b/src/mscorlib/src/System/IO/FileLoadException.cs
index 2b56c00191..980d2514aa 100644
--- a/src/mscorlib/src/System/IO/FileLoadException.cs
+++ b/src/mscorlib/src/System/IO/FileLoadException.cs
@@ -20,14 +20,12 @@ using System.Runtime.Serialization;
 using System.Runtime.InteropServices;
 using System.Runtime.CompilerServices;
 using System.Security;
-using System.Security.Permissions;
 using System.Runtime.Versioning;
 using SecurityException = System.Security.SecurityException;
 
 namespace System.IO {
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class FileLoadException : IOException {
 
         private String _fileName;   // the name of the file we could not load.
diff --git a/src/mscorlib/src/System/IO/FileMode.cs b/src/mscorlib/src/System/IO/FileMode.cs
index 9b9c2024a7..3972cf0533 100644
--- a/src/mscorlib/src/System/IO/FileMode.cs
+++ b/src/mscorlib/src/System/IO/FileMode.cs
@@ -27,7 +27,6 @@ namespace System.IO {
     // exist, use Create.
     // 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum FileMode
     {
         // Creates a new file. An exception is raised if the file already exists.
diff --git a/src/mscorlib/src/System/IO/FileNotFoundException.cs b/src/mscorlib/src/System/IO/FileNotFoundException.cs
index 8cc75f8232..ad6b5386ba 100644
--- a/src/mscorlib/src/System/IO/FileNotFoundException.cs
+++ b/src/mscorlib/src/System/IO/FileNotFoundException.cs
@@ -16,14 +16,12 @@
 
 using System;
 using System.Runtime.Serialization;
-using System.Security.Permissions;
 using SecurityException = System.Security.SecurityException;
 using System.Globalization;
 
 namespace System.IO {
     // Thrown when trying to access a file that doesn't exist on disk.
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class FileNotFoundException : IOException {
 
         private String _fileName;  // The name of the file that isn't found.
diff --git a/src/mscorlib/src/System/IO/FileOptions.cs b/src/mscorlib/src/System/IO/FileOptions.cs
index ffd6ddad90..02bc99eea4 100644
--- a/src/mscorlib/src/System/IO/FileOptions.cs
+++ b/src/mscorlib/src/System/IO/FileOptions.cs
@@ -24,7 +24,6 @@ namespace System.IO {
     // a number of them made sense in managed code, at least not yet.
     [Serializable]
     [Flags]
-    [ComVisible(true)]
     public enum FileOptions
     {
         // NOTE: any change to FileOptions enum needs to be 
diff --git a/src/mscorlib/src/System/IO/FileShare.cs b/src/mscorlib/src/System/IO/FileShare.cs
index ad76d5da09..8a7d1f05e9 100644
--- a/src/mscorlib/src/System/IO/FileShare.cs
+++ b/src/mscorlib/src/System/IO/FileShare.cs
@@ -28,7 +28,6 @@ namespace System.IO {
     // 
 [Serializable]
 [Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum FileShare
     {
         // No sharing. Any request to open the file (by this process or another
diff --git a/src/mscorlib/src/System/IO/IOException.cs b/src/mscorlib/src/System/IO/IOException.cs
index b3db033b0d..ab612811b0 100644
--- a/src/mscorlib/src/System/IO/IOException.cs
+++ b/src/mscorlib/src/System/IO/IOException.cs
@@ -19,7 +19,6 @@ using System.Runtime.Serialization;
 namespace System.IO {
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class IOException : SystemException
     {
         // For debugging purposes, store the complete path in the IOException
diff --git a/src/mscorlib/src/System/IO/MemoryStream.cs b/src/mscorlib/src/System/IO/MemoryStream.cs
index bdddc83818..05aac909b5 100644
--- a/src/mscorlib/src/System/IO/MemoryStream.cs
+++ b/src/mscorlib/src/System/IO/MemoryStream.cs
@@ -23,7 +23,6 @@ using System.Diagnostics;
 using System.Diagnostics.Contracts;
 using System.Threading;
 using System.Threading.Tasks;
-using System.Security.Permissions;
 
 namespace System.IO {
     // A MemoryStream represents a Stream in memory (ie, it has no backing store).
@@ -35,7 +34,6 @@ namespace System.IO {
     // memory streams are resizable, while ones created with a byte array provide
     // a stream "view" of the data.
     [Serializable]
-    [ComVisible(true)]
     public class MemoryStream : Stream
     {
         private byte[] _buffer;    // Either allocated internally or externally.
@@ -181,7 +179,6 @@ namespace System.IO {
         public override void Flush() {
         }
 
-        [ComVisible(false)]
         public override Task FlushAsync(CancellationToken cancellationToken) {
 
             if (cancellationToken.IsCancellationRequested)
@@ -357,7 +354,6 @@ namespace System.IO {
             return n;
         }
 
-        [ComVisible(false)]
         public override Task<int> ReadAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken)
         {
             if (buffer==null)
@@ -589,7 +585,6 @@ namespace System.IO {
 
         }
 
-        [ComVisible(false)]
         public override Task WriteAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken)
         {
             if (buffer == null)
diff --git a/src/mscorlib/src/System/IO/PathTooLongException.cs b/src/mscorlib/src/System/IO/PathTooLongException.cs
index b1063232a1..a84fdfbb36 100644
--- a/src/mscorlib/src/System/IO/PathTooLongException.cs
+++ b/src/mscorlib/src/System/IO/PathTooLongException.cs
@@ -20,7 +20,6 @@ using System.Runtime.Serialization;
 namespace System.IO {
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class PathTooLongException : IOException
     {
         public PathTooLongException() 
diff --git a/src/mscorlib/src/System/IO/PinnedBufferMemoryStream.cs b/src/mscorlib/src/System/IO/PinnedBufferMemoryStream.cs
index 890669fa58..2cbd14f734 100644
--- a/src/mscorlib/src/System/IO/PinnedBufferMemoryStream.cs
+++ b/src/mscorlib/src/System/IO/PinnedBufferMemoryStream.cs
@@ -42,8 +42,8 @@ namespace System.IO {
             _pinningHandle = new GCHandle(array, GCHandleType.Pinned);
             // Now the byte[] is pinned for the lifetime of this instance.
             // But I also need to get a pointer to that block of memory...
-            fixed(byte* ptr = _array)
-                Initialize(ptr, len, len, FileAccess.Read, true);
+            fixed(byte* ptr = &_array[0])
+                Initialize(ptr, len, len, FileAccess.Read);
         }
 
         ~PinnedBufferMemoryStream()
diff --git a/src/mscorlib/src/System/IO/SearchOption.cs b/src/mscorlib/src/System/IO/SearchOption.cs
index aa9b9e37f8..e2f761cd54 100644
--- a/src/mscorlib/src/System/IO/SearchOption.cs
+++ b/src/mscorlib/src/System/IO/SearchOption.cs
@@ -20,7 +20,6 @@ using System;
 
 namespace System.IO {
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum SearchOption
     {
         // Include only the current directory in the search operation
diff --git a/src/mscorlib/src/System/IO/SeekOrigin.cs b/src/mscorlib/src/System/IO/SeekOrigin.cs
index a0a013e7aa..bff49e610f 100644
--- a/src/mscorlib/src/System/IO/SeekOrigin.cs
+++ b/src/mscorlib/src/System/IO/SeekOrigin.cs
@@ -21,7 +21,6 @@ namespace System.IO {
     // Provides seek reference points.  To seek to the end of a stream,
     // call stream.Seek(0, SeekOrigin.End).
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum SeekOrigin
     {
         // These constants match Win32's FILE_BEGIN, FILE_CURRENT, and FILE_END
diff --git a/src/mscorlib/src/System/IO/Stream.cs b/src/mscorlib/src/System/IO/Stream.cs
index 3cdfad613e..790f0a09ab 100644
--- a/src/mscorlib/src/System/IO/Stream.cs
+++ b/src/mscorlib/src/System/IO/Stream.cs
@@ -23,14 +23,12 @@ using System.Runtime.InteropServices;
 using System.Runtime.CompilerServices;
 using System.Runtime.ExceptionServices;
 using System.Security;
-using System.Security.Permissions;
 using System.Diagnostics;
 using System.Diagnostics.Contracts;
 using System.Reflection;
 
 namespace System.IO {
     [Serializable]
-    [ComVisible(true)]
     public abstract class Stream : MarshalByRefObject, IDisposable {
 
         public static readonly Stream Null = new NullStream();
@@ -65,7 +63,6 @@ namespace System.IO {
             get;
         }
 
-        [ComVisible(false)]
         public virtual bool CanTimeout {
             [Pure]
             get {
@@ -87,7 +84,6 @@ namespace System.IO {
             set;
         }
 
-        [ComVisible(false)]
         public virtual int ReadTimeout {
             get {
                 Contract.Ensures(Contract.Result<int>() >= 0);
@@ -98,7 +94,6 @@ namespace System.IO {
             }
         }
 
-        [ComVisible(false)]
         public virtual int WriteTimeout {
             get {
                 Contract.Ensures(Contract.Result<int>() >= 0);
@@ -109,7 +104,6 @@ namespace System.IO {
             }
         }
 
-        [ComVisible(false)]
         public Task CopyToAsync(Stream destination)
         {
             int bufferSize = _DefaultCopyBufferSize;
@@ -146,13 +140,11 @@ namespace System.IO {
             return CopyToAsync(destination, bufferSize);
         }
 
-        [ComVisible(false)]
         public Task CopyToAsync(Stream destination, Int32 bufferSize)
         {
             return CopyToAsync(destination, bufferSize, CancellationToken.None);
         }
 
-        [ComVisible(false)]
         public virtual Task CopyToAsync(Stream destination, Int32 bufferSize, CancellationToken cancellationToken)
         {
             StreamHelpers.ValidateCopyToArgs(this, destination, bufferSize);
@@ -278,13 +270,11 @@ namespace System.IO {
 
         public abstract void Flush();
 
-        [ComVisible(false)]
         public Task FlushAsync()
         {
             return FlushAsync(CancellationToken.None);
         }
 
-        [ComVisible(false)]
         public virtual Task FlushAsync(CancellationToken cancellationToken)
         {
             return Task.Factory.StartNew(state => ((Stream)state).Flush(), this,
@@ -398,13 +388,11 @@ namespace System.IO {
             }
         }
 
-        [ComVisible(false)]
         public Task<int> ReadAsync(Byte[] buffer, int offset, int count)
         {
             return ReadAsync(buffer, offset, count, CancellationToken.None);
         }
 
-        [ComVisible(false)]
         public virtual Task<int> ReadAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken)
         {
             // If cancellation was requested, bail early with an already completed task.
@@ -617,7 +605,6 @@ namespace System.IO {
                 _buffer = null;
             }
 
-            [MethodImpl(MethodImplOptions.NoInlining)]
             public ReadWriteTask(
                 bool isRead,
                 bool apm,
@@ -630,8 +617,6 @@ namespace System.IO {
                 Contract.Requires(buffer != null);
                 Contract.EndContractBlock();
 
-                StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-
                 // Store the arguments
                 _isRead = isRead;
                 _apm = apm;
@@ -648,8 +633,7 @@ namespace System.IO {
                 if (callback != null)
                 {
                     _callback = callback;
-                    _context = ExecutionContext.Capture(ref stackMark, 
-                        ExecutionContext.CaptureOptions.OptimizeDefaultCase | ExecutionContext.CaptureOptions.IgnoreSyncCtx);
+                    _context = ExecutionContext.Capture();
                     base.AddCompletionAction(this);
                 }
             }
@@ -683,14 +667,13 @@ namespace System.IO {
                     var invokeAsyncCallback = s_invokeAsyncCallback;
                     if (invokeAsyncCallback == null) s_invokeAsyncCallback = invokeAsyncCallback = InvokeAsyncCallback; // benign race condition
 
-                    using(context) ExecutionContext.Run(context, invokeAsyncCallback, this, true);
+                    ExecutionContext.Run(context, invokeAsyncCallback, this);
                 }
             }
 
             bool ITaskCompletionAction.InvokeMayRunArbitraryCode { get { return true; } }
         }
 
-        [ComVisible(false)]
         public Task WriteAsync(Byte[] buffer, int offset, int count)
         {
             return WriteAsync(buffer, offset, count, CancellationToken.None);
@@ -698,7 +681,6 @@ namespace System.IO {
 
 
 
-        [ComVisible(false)]
         public virtual Task WriteAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken)
         {
             // If cancellation was requested, bail early with an already completed task.
@@ -906,7 +888,6 @@ namespace System.IO {
             {
             }
 
-            [ComVisible(false)]
             public override Task FlushAsync(CancellationToken cancellationToken)
             {
                 return cancellationToken.IsCancellationRequested ?
@@ -951,7 +932,6 @@ namespace System.IO {
                 return 0;
             }
 
-            [ComVisible(false)]
             public override Task<int> ReadAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken)
             {
                 var nullReadTask = s_nullReadTask;
@@ -970,7 +950,6 @@ namespace System.IO {
             {
             }
 
-            [ComVisible(false)]
             public override Task WriteAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken)
             {
                 return cancellationToken.IsCancellationRequested ?
@@ -1106,7 +1085,6 @@ namespace System.IO {
                 get { return _stream.CanSeek; }
             }
         
-            [ComVisible(false)]
             public override bool CanTimeout {
                 [Pure]
                 get {
@@ -1135,7 +1113,6 @@ namespace System.IO {
                 }
             }
 
-            [ComVisible(false)]
             public override int ReadTimeout {
                 get {
                     return _stream.ReadTimeout;
@@ -1145,7 +1122,6 @@ namespace System.IO {
                 }
             }
 
-            [ComVisible(false)]
             public override int WriteTimeout {
                 get {
                     return _stream.WriteTimeout;
diff --git a/src/mscorlib/src/System/IO/StreamReader.cs b/src/mscorlib/src/System/IO/StreamReader.cs
index 708db088e8..6d50347b1a 100644
--- a/src/mscorlib/src/System/IO/StreamReader.cs
+++ b/src/mscorlib/src/System/IO/StreamReader.cs
@@ -8,7 +8,6 @@ using System.Runtime.Versioning;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Contracts;
-using System.Security.Permissions;
 using System.Threading.Tasks;
 
 namespace System.IO
@@ -18,8 +17,7 @@ namespace System.IO
     // whereas the Stream class is designed for byte input and output.  
     // 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public class StreamReader : TextReader
+    internal class StreamReader : TextReader
     {
         // StreamReader.Null is threadsafe.
         public new static readonly StreamReader Null = new NullStreamReader();
@@ -188,7 +186,7 @@ namespace System.IO
                 throw new ArgumentOutOfRangeException(nameof(bufferSize), Environment.GetResourceString("ArgumentOutOfRange_NeedPosNum"));
             Contract.EndContractBlock();
 
-            Stream stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, DefaultFileStreamBufferSize, FileOptions.SequentialScan, Path.GetFileName(path), false, false);
+            Stream stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, DefaultFileStreamBufferSize, FileOptions.SequentialScan);
             Init(stream, encoding, detectEncodingFromByteOrderMarks, bufferSize, false);
         }
         
@@ -757,7 +755,6 @@ namespace System.IO
         }
         
         #region Task based Async APIs
-        [ComVisible(false)]
         public override Task<String> ReadLineAsync()
         {
             // If we have been inherited into a subclass, the following implementation could be incorrect
@@ -837,7 +834,6 @@ namespace System.IO
             return GetStringAndReleaseSharedStringBuilder(sb);
         }
 
-        [ComVisible(false)]
         public override Task<String> ReadToEndAsync()
         {
             // If we have been inherited into a subclass, the following implementation could be incorrect
@@ -873,7 +869,6 @@ namespace System.IO
             return GetStringAndReleaseSharedStringBuilder(sb);
         }
 
-        [ComVisible(false)]
         public override Task<int> ReadAsync(char[] buffer, int index, int count)
         {
             if (buffer==null)
@@ -1060,7 +1055,6 @@ namespace System.IO
             return charsRead;
         }
 
-        [ComVisible(false)]
         public override Task<int> ReadBlockAsync(char[] buffer, int index, int count)
         {
             if (buffer==null)
diff --git a/src/mscorlib/src/System/IO/TextReader.cs b/src/mscorlib/src/System/IO/TextReader.cs
index 6cbadfbce5..15ba8fba7d 100644
--- a/src/mscorlib/src/System/IO/TextReader.cs
+++ b/src/mscorlib/src/System/IO/TextReader.cs
@@ -17,7 +17,6 @@
 using System.Text;
 using System.Runtime.InteropServices;
 using System.Runtime.CompilerServices;
-using System.Security.Permissions;
 using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Contracts;
 using System.Threading;
@@ -32,8 +31,7 @@ namespace System.IO {
     // This class is intended for character input, not bytes.  
     // There are methods on the Stream class for reading bytes. 
     [Serializable]
-    [ComVisible(true)]
-    public abstract class TextReader : MarshalByRefObject, IDisposable {
+    internal abstract class TextReader : MarshalByRefObject, IDisposable {
 
         public static readonly TextReader Null = new NullTextReader();
     
@@ -170,7 +168,6 @@ namespace System.IO {
         }
 
         #region Task based Async APIs
-        [ComVisible(false)]
         public virtual Task<String> ReadLineAsync()
         {
             return Task<String>.Factory.StartNew(state =>
@@ -180,7 +177,6 @@ namespace System.IO {
             this, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
         }
 
-        [ComVisible(false)]
         public async virtual Task<String> ReadToEndAsync()
         {
             char[] chars = new char[4096];
@@ -193,7 +189,6 @@ namespace System.IO {
             return sb.ToString();
         }
 
-        [ComVisible(false)]
         public virtual Task<int> ReadAsync(char[] buffer, int index, int count)
         {
             if (buffer==null)
@@ -223,7 +218,6 @@ namespace System.IO {
             tuple, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
         }
 
-        [ComVisible(false)]
         public virtual Task<int> ReadBlockAsync(char[] buffer, int index, int count)
         {
             if (buffer==null)
@@ -352,21 +346,18 @@ namespace System.IO {
             // On SyncTextReader all APIs should run synchronously, even the async ones.
             //
 
-            [ComVisible(false)]
             [MethodImplAttribute(MethodImplOptions.Synchronized)]
             public override Task<String> ReadLineAsync()
             {
                 return Task.FromResult(ReadLine());
             }
 
-            [ComVisible(false)]
             [MethodImplAttribute(MethodImplOptions.Synchronized)]
             public override Task<String> ReadToEndAsync()
             {
                 return Task.FromResult(ReadToEnd());
             }
 
-            [ComVisible(false)]
             [MethodImplAttribute(MethodImplOptions.Synchronized)]
             public override Task<int> ReadBlockAsync(char[] buffer, int index, int count)
             {
@@ -382,7 +373,6 @@ namespace System.IO {
                 return Task.FromResult(ReadBlock(buffer, index, count));
             }
 
-            [ComVisible(false)]
             [MethodImplAttribute(MethodImplOptions.Synchronized)]
             public override Task<int> ReadAsync(char[] buffer, int index, int count)
             {
diff --git a/src/mscorlib/src/System/IO/UnmanagedMemoryAccessor.cs b/src/mscorlib/src/System/IO/UnmanagedMemoryAccessor.cs
index 4208ebfb6d..f3fd71833c 100644
--- a/src/mscorlib/src/System/IO/UnmanagedMemoryAccessor.cs
+++ b/src/mscorlib/src/System/IO/UnmanagedMemoryAccessor.cs
@@ -17,7 +17,6 @@ using System.Runtime.InteropServices;
 using System.Runtime.CompilerServices;
 using System.Runtime.ConstrainedExecution;
 using System.Runtime.Versioning;
-using System.Security.Permissions;
 using Microsoft.Win32.SafeHandles;
 using System.Diagnostics;
 using System.Diagnostics.Contracts;
diff --git a/src/mscorlib/src/System/IO/UnmanagedMemoryStream.cs b/src/mscorlib/src/System/IO/UnmanagedMemoryStream.cs
index d78632639b..165b6d2b19 100644
--- a/src/mscorlib/src/System/IO/UnmanagedMemoryStream.cs
+++ b/src/mscorlib/src/System/IO/UnmanagedMemoryStream.cs
@@ -17,7 +17,6 @@ using System.Runtime;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Security;
-using System.Security.Permissions;
 using System.Threading;
 using System.Diagnostics;
 using System.Diagnostics.Contracts;
@@ -108,25 +107,14 @@ namespace System.IO {
         }
 
         public UnmanagedMemoryStream(SafeBuffer buffer, long offset, long length) {
-            Initialize(buffer, offset, length, FileAccess.Read, false);
+            Initialize(buffer, offset, length, FileAccess.Read);
         }
 
         public UnmanagedMemoryStream(SafeBuffer buffer, long offset, long length, FileAccess access) {
-            Initialize(buffer, offset, length, access, false);
-        }
-
-        // We must create one of these without doing a security check.  This
-        // class is created while security is trying to start up.  Plus, doing
-        // a Demand from Assembly.GetManifestResourceStream isn't useful.
-        internal UnmanagedMemoryStream(SafeBuffer buffer, long offset, long length, FileAccess access, bool skipSecurityCheck) {
-            Initialize(buffer, offset, length, access, skipSecurityCheck);
+            Initialize(buffer, offset, length, access);
         }
 
         protected void Initialize(SafeBuffer buffer, long offset, long length, FileAccess access) {
-            Initialize(buffer, offset, length, access, false);
-        }
-
-        internal void Initialize(SafeBuffer buffer, long offset, long length, FileAccess access, bool skipSecurityCheck) {
             if (buffer == null) {
                 throw new ArgumentNullException(nameof(buffer));
             }
@@ -147,11 +135,6 @@ namespace System.IO {
             if (_isOpen) {
                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CalledTwice"));
             }
-            if (!skipSecurityCheck) {
-#pragma warning disable 618
-                new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
-#pragma warning restore 618
-            }
 
             // check for wraparound
             unsafe {
@@ -181,31 +164,18 @@ namespace System.IO {
         [CLSCompliant(false)]
         public unsafe UnmanagedMemoryStream(byte* pointer, long length)
         {
-            Initialize(pointer, length, length, FileAccess.Read, false);
+            Initialize(pointer, length, length, FileAccess.Read);
         }
 
         [CLSCompliant(false)]
         public unsafe UnmanagedMemoryStream(byte* pointer, long length, long capacity, FileAccess access) 
         {
-            Initialize(pointer, length, capacity, access, false);
-        }
-
-        // We must create one of these without doing a security check.  This
-        // class is created while security is trying to start up.  Plus, doing
-        // a Demand from Assembly.GetManifestResourceStream isn't useful.
-        internal unsafe UnmanagedMemoryStream(byte* pointer, long length, long capacity, FileAccess access, bool skipSecurityCheck) 
-        {
-            Initialize(pointer, length, capacity, access, skipSecurityCheck);
+            Initialize(pointer, length, capacity, access);
         }
 
         [CLSCompliant(false)]
         protected unsafe void Initialize(byte* pointer, long length, long capacity, FileAccess access) 
         {
-            Initialize(pointer, length, capacity, access, false);
-        }
-
-        internal unsafe void Initialize(byte* pointer, long length, long capacity, FileAccess access, bool skipSecurityCheck) 
-        {
             if (pointer == null)
                 throw new ArgumentNullException(nameof(pointer));
             if (length < 0 || capacity < 0)
@@ -221,12 +191,6 @@ namespace System.IO {
             if (_isOpen)
                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CalledTwice"));
 
-            if (!skipSecurityCheck) {
-#pragma warning disable 618
-                new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
-#pragma warning restore 618
-            }
-
             _mem = pointer;
             _offset = 0;
             _length = length;
@@ -265,7 +229,6 @@ namespace System.IO {
             if (!_isOpen) __Error.StreamIsClosed();
         }
         
-        [ComVisible(false)] 
         public override Task FlushAsync(CancellationToken cancellationToken) { 
         
             if (cancellationToken.IsCancellationRequested) 
@@ -421,7 +384,6 @@ namespace System.IO {
             return nInt;
         }
         
-        [ComVisible(false)]
         public override Task<Int32> ReadAsync(Byte[] buffer, Int32 offset, Int32 count, CancellationToken cancellationToken) {        
             if (buffer==null)
                 throw new ArgumentNullException(nameof(buffer), Environment.GetResourceString("ArgumentNull_Buffer"));
@@ -618,7 +580,6 @@ namespace System.IO {
             return;
         }
         
-        [ComVisible(false)] 
         public override Task WriteAsync(Byte[] buffer, Int32 offset, Int32 count, CancellationToken cancellationToken) { 
         
             if (buffer==null)
diff --git a/src/mscorlib/src/System/IO/UnmanagedMemoryStreamWrapper.cs b/src/mscorlib/src/System/IO/UnmanagedMemoryStreamWrapper.cs
index 040ddbb3d7..99b257ea56 100644
--- a/src/mscorlib/src/System/IO/UnmanagedMemoryStreamWrapper.cs
+++ b/src/mscorlib/src/System/IO/UnmanagedMemoryStreamWrapper.cs
@@ -13,7 +13,6 @@
 
 using System;
 using System.Runtime.InteropServices;
-using System.Security.Permissions;
 using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Contracts;
 using System.Threading;
diff --git a/src/mscorlib/src/System/IO/__Error.cs b/src/mscorlib/src/System/IO/__Error.cs
index ad4972de54..955ddbec63 100644
--- a/src/mscorlib/src/System/IO/__Error.cs
+++ b/src/mscorlib/src/System/IO/__Error.cs
@@ -21,7 +21,6 @@ using Win32Native = Microsoft.Win32.Win32Native;
 using System.Text;
 using System.Globalization;
 using System.Security;
-using System.Security.Permissions;
 using System.Diagnostics.Contracts;
 
 namespace System.IO {
@@ -51,10 +50,6 @@ namespace System.IO {
         internal static void ReadNotSupported() {
             throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnreadableStream"));
         }
-    
-        internal static void SeekNotSupported() {
-            throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnseekableStream"));
-        }
 
         internal static void WrongAsyncResult() {
             throw new ArgumentException(Environment.GetResourceString("Arg_WrongAsyncResult"));
@@ -187,34 +182,11 @@ namespace System.IO {
                 throw new IOException(Win32Native.GetMessage(errorCode), Win32Native.MakeHRFromErrorCode(errorCode), maybeFullPath);
             }
         }
-
-        // An alternative to WinIOError with friendlier messages for drives
-        internal static void WinIODriveError(String driveName) {
-            int errorCode = Marshal.GetLastWin32Error();
-            WinIODriveError(driveName, errorCode);
-        }
-
-        internal static void WinIODriveError(String driveName, int errorCode)
-        {
-            switch (errorCode) {
-            case Win32Native.ERROR_PATH_NOT_FOUND:
-            case Win32Native.ERROR_INVALID_DRIVE:
-                throw new DriveNotFoundException(Environment.GetResourceString("IO.DriveNotFound_Drive", driveName));
-
-            default: 
-                WinIOError(errorCode, driveName);                
-                break;
-            }
-        }
     
         internal static void WriteNotSupported() {
             throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnwritableStream"));
         }
 
-        internal static void WriterClosed() {
-            throw new ObjectDisposedException(null, Environment.GetResourceString("ObjectDisposed_WriterClosed"));
-        }
-
         // From WinError.h
         internal const int ERROR_FILE_NOT_FOUND = Win32Native.ERROR_FILE_NOT_FOUND;
         internal const int ERROR_PATH_NOT_FOUND = Win32Native.ERROR_PATH_NOT_FOUND;
diff --git a/src/mscorlib/src/System/IObservable.cs b/src/mscorlib/src/System/IObservable.cs
index c231c45485..aabb0b8fb4 100644
--- a/src/mscorlib/src/System/IObservable.cs
+++ b/src/mscorlib/src/System/IObservable.cs
@@ -2,23 +2,10 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-/*============================================================
-**
-** 
-** 
-**
-**
-** Purpose: Interface for exposing an Observable in the 
-** Observer pattern
-**
-**
-===========================================================*/
-
 namespace System
 {
     public interface IObservable<out T>
     {
         IDisposable Subscribe(IObserver<T> observer);
     }
-
 }
diff --git a/src/mscorlib/src/System/IObserver.cs b/src/mscorlib/src/System/IObserver.cs
index 7f55ce0c46..39e123de8d 100644
--- a/src/mscorlib/src/System/IObserver.cs
+++ b/src/mscorlib/src/System/IObserver.cs
@@ -2,20 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-/*============================================================
-**
-** 
-** 
-**
-**
-** Purpose: Interface for exposing an Observer in the 
-** Observer pattern
-**
-**
-===========================================================*/
-
-using System;
-
 namespace System
 {
     public interface IObserver<in T>
diff --git a/src/mscorlib/src/System/IProgress.cs b/src/mscorlib/src/System/IProgress.cs
index e1043015ce..724c7bdce9 100644
--- a/src/mscorlib/src/System/IProgress.cs
+++ b/src/mscorlib/src/System/IProgress.cs
@@ -2,17 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-/*============================================================
-**
-** 
-** 
-**
-**
-** Purpose: Interface for providing progress updates.
-**
-**
-===========================================================*/
-
 namespace System
 {
     /// <summary>Defines a provider for progress updates.</summary>
diff --git a/src/mscorlib/src/System/IndexOutOfRangeException.cs b/src/mscorlib/src/System/IndexOutOfRangeException.cs
index e641b5eab4..4969c2b86d 100644
--- a/src/mscorlib/src/System/IndexOutOfRangeException.cs
+++ b/src/mscorlib/src/System/IndexOutOfRangeException.cs
@@ -11,30 +11,31 @@
 **
 =============================================================================*/
 
-namespace System {
-    
-    using System.Runtime.Serialization;
-    [System.Runtime.InteropServices.ComVisible(true)]
+using System.Runtime.Serialization;
+
+namespace System
+{
     [Serializable]
-    public sealed class IndexOutOfRangeException : SystemException {
-        public IndexOutOfRangeException() 
-            : base(Environment.GetResourceString("Arg_IndexOutOfRangeException")) {
-            SetErrorCode(__HResults.COR_E_INDEXOUTOFRANGE);
-        }
-    
-        public IndexOutOfRangeException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_INDEXOUTOFRANGE);
+    public sealed class IndexOutOfRangeException : SystemException
+    {
+        public IndexOutOfRangeException()
+            : base(SR.Arg_IndexOutOfRangeException)
+        {
+            HResult = __HResults.COR_E_INDEXOUTOFRANGE;
         }
-        
-        public IndexOutOfRangeException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_INDEXOUTOFRANGE);
+
+        public IndexOutOfRangeException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_INDEXOUTOFRANGE;
         }
 
-        internal IndexOutOfRangeException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public IndexOutOfRangeException(String message, Exception innerException)
+            : base(message, innerException)
+        {
+            HResult = __HResults.COR_E_INDEXOUTOFRANGE;
         }
 
+        internal IndexOutOfRangeException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
-
 }
diff --git a/src/mscorlib/src/System/InsufficientExecutionStackException.cs b/src/mscorlib/src/System/InsufficientExecutionStackException.cs
index 6b02f46f29..b9a4a12ddd 100644
--- a/src/mscorlib/src/System/InsufficientExecutionStackException.cs
+++ b/src/mscorlib/src/System/InsufficientExecutionStackException.cs
@@ -2,46 +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.
 
-/*=============================================================================
-**
-**
-**
-** Purpose: The exception class used when there is insufficient execution stack
-**          to allow most Framework methods to execute.
-**
-**
-=============================================================================*/
-
-namespace System {
-    
-    using System;
-    using System.Runtime.Serialization;
+using System.Runtime.Serialization;
 
+namespace System
+{
     [Serializable]
-    public sealed class InsufficientExecutionStackException : SystemException 
+    public sealed class InsufficientExecutionStackException : SystemException
     {
         public InsufficientExecutionStackException()
-            : base(Environment.GetResourceString("Arg_InsufficientExecutionStackException")) 
-        {
-            SetErrorCode(__HResults.COR_E_INSUFFICIENTEXECUTIONSTACK);
-        }
-    
-        public InsufficientExecutionStackException(String message) 
-            : base(message) 
+            : base(SR.Arg_InsufficientExecutionStackException)
         {
-            SetErrorCode(__HResults.COR_E_INSUFFICIENTEXECUTIONSTACK);
+            HResult = __HResults.COR_E_INSUFFICIENTEXECUTIONSTACK;
         }
-        
-        public InsufficientExecutionStackException(String message, Exception innerException) 
-            : base(message, innerException) 
+
+        public InsufficientExecutionStackException(String message)
+            : base(message)
         {
-            SetErrorCode(__HResults.COR_E_INSUFFICIENTEXECUTIONSTACK);
+            HResult = __HResults.COR_E_INSUFFICIENTEXECUTIONSTACK;
         }
 
-        private InsufficientExecutionStackException(SerializationInfo info, StreamingContext context)
-            : base(info, context)
+        public InsufficientExecutionStackException(String message, Exception innerException)
+            : base(message, innerException)
         {
+            HResult = __HResults.COR_E_INSUFFICIENTEXECUTIONSTACK;
         }
-        
+
+        internal InsufficientExecutionStackException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
 }
diff --git a/src/mscorlib/src/System/Int16.cs b/src/mscorlib/src/System/Int16.cs
index f02a5f2cda..a5e62233e4 100644
--- a/src/mscorlib/src/System/Int16.cs
+++ b/src/mscorlib/src/System/Int16.cs
@@ -19,7 +19,6 @@ namespace System {
     using System.Runtime.InteropServices;
     using System.Diagnostics.Contracts;
 
-[System.Runtime.InteropServices.ComVisible(true)]
 [Serializable]
 [System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
     public struct Int16 : IComparable, IFormattable, IConvertible
diff --git a/src/mscorlib/src/System/Int32.cs b/src/mscorlib/src/System/Int32.cs
index 2da55bf089..0e1ed56a41 100644
--- a/src/mscorlib/src/System/Int32.cs
+++ b/src/mscorlib/src/System/Int32.cs
@@ -21,7 +21,6 @@ namespace System {
 
 [Serializable]
 [System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)] 
-[System.Runtime.InteropServices.ComVisible(true)]
     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 e5fcf86c3b..3520ede533 100644
--- a/src/mscorlib/src/System/Int64.cs
+++ b/src/mscorlib/src/System/Int64.cs
@@ -20,7 +20,6 @@ namespace System {
 
 [Serializable]
 [System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
-[System.Runtime.InteropServices.ComVisible(true)]
     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 2d66652ab8..dbddcd319a 100644
--- a/src/mscorlib/src/System/IntPtr.cs
+++ b/src/mscorlib/src/System/IntPtr.cs
@@ -23,7 +23,6 @@ namespace System {
     using System.Diagnostics.Contracts;
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public struct IntPtr : IEquatable<IntPtr>, ISerializable
     {
         unsafe private void* m_value; // The compiler treats void* closest to uint hence explicit casts are required to preserve int behavior
@@ -32,13 +31,11 @@ namespace System {
 
         // fast way to compare IntPtr to (IntPtr)0 while IntPtr.Zero doesn't work due to slow statics access
         [Pure]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal unsafe bool IsNull()
         {
             return (this.m_value == null);
         }
 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         [System.Runtime.Versioning.NonVersionable]
         public unsafe IntPtr(int value)
         {
@@ -49,7 +46,6 @@ namespace System {
 #endif
         }
     
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         [System.Runtime.Versioning.NonVersionable]
         public unsafe IntPtr(long value)
         {
@@ -61,7 +57,6 @@ namespace System {
         }
 
         [CLSCompliant(false)]
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         [System.Runtime.Versioning.NonVersionable]
         public unsafe IntPtr(void* value)
         {
@@ -111,7 +106,6 @@ namespace System {
 #endif
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public unsafe int ToInt32() {
 #if BIT64
@@ -122,7 +116,6 @@ namespace System {
 #endif
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public unsafe long ToInt64() {
 #if BIT64
@@ -152,14 +145,12 @@ namespace System {
         }
 
 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         [System.Runtime.Versioning.NonVersionable]
         public static explicit operator IntPtr (int value) 
         {
             return new IntPtr(value);
         }
 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         [System.Runtime.Versioning.NonVersionable]
         public static explicit operator IntPtr (long value) 
         {
@@ -201,28 +192,24 @@ namespace System {
 #endif
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public unsafe static bool operator == (IntPtr value1, IntPtr value2) 
         {
             return value1.m_value == value2.m_value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public unsafe static bool operator != (IntPtr value1, IntPtr value2) 
         {
             return value1.m_value != value2.m_value;
         }
 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         [System.Runtime.Versioning.NonVersionable]
         public static IntPtr Add(IntPtr pointer, int offset)
         {
             return pointer + offset;
         }
 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         [System.Runtime.Versioning.NonVersionable]
         public static IntPtr operator +(IntPtr pointer, int offset) 
         {
@@ -233,13 +220,11 @@ namespace System {
 #endif
         }
 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         [System.Runtime.Versioning.NonVersionable]
         public static IntPtr Subtract(IntPtr pointer, int offset) {
             return pointer - offset;
         }
 
-        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
         [System.Runtime.Versioning.NonVersionable]
         public static IntPtr operator -(IntPtr pointer, int offset) {
 #if BIT64
@@ -252,7 +237,6 @@ namespace System {
         public static int Size
         {
             [Pure]
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
             [System.Runtime.Versioning.NonVersionable]
             get
             {
@@ -266,7 +250,6 @@ namespace System {
     
 
         [CLSCompliant(false)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public unsafe void* ToPointer()
         {
diff --git a/src/mscorlib/src/System/Internal.cs b/src/mscorlib/src/System/Internal.cs
index 0eb2bced72..b0860109d9 100644
--- a/src/mscorlib/src/System/Internal.cs
+++ b/src/mscorlib/src/System/Internal.cs
@@ -19,15 +19,7 @@ using System.StubHelpers;
 using System.Threading.Tasks;
 
 #if FEATURE_COMINTEROP
-
 using System.Runtime.InteropServices.WindowsRuntime;
-
-[assembly:Guid("BED7F4EA-1A96-11d2-8F08-00A0C9A6186D")]
-
-// The following attribute are required to ensure COM compatibility.
-[assembly:System.Runtime.InteropServices.ComCompatibleVersion(1, 0, 3300, 0)]
-[assembly:System.Runtime.InteropServices.TypeLibVersion(2, 4)]
-
 #endif // FEATURE_COMINTEROP
 
 [assembly:DefaultDependencyAttribute(LoadHint.Always)]
diff --git a/src/mscorlib/src/System/InvalidCastException.cs b/src/mscorlib/src/System/InvalidCastException.cs
index ba7b722434..01d92b2837 100644
--- a/src/mscorlib/src/System/InvalidCastException.cs
+++ b/src/mscorlib/src/System/InvalidCastException.cs
@@ -4,42 +4,41 @@
 
 /*=============================================================================
 **
-**
-**
-** Purpose: Exception class for bad cast conditions!
-**
+** Purpose: Exception class for invalid cast conditions!
 **
 =============================================================================*/
 
-namespace System {
-    
-    using System.Runtime.Serialization;
-    [System.Runtime.InteropServices.ComVisible(true)]
+using System.Runtime.Serialization;
+
+namespace System
+{
     [Serializable]
-    public class InvalidCastException : SystemException {
-        public InvalidCastException() 
-            : base(Environment.GetResourceString("Arg_InvalidCastException")) {
-            SetErrorCode(__HResults.COR_E_INVALIDCAST);
-        }
-    
-        public InvalidCastException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_INVALIDCAST);
+    public class InvalidCastException : SystemException
+    {
+        public InvalidCastException()
+            : base(SR.Arg_InvalidCastException)
+        {
+            HResult = __HResults.COR_E_INVALIDCAST;
         }
 
-        public InvalidCastException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_INVALIDCAST);
+        public InvalidCastException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_INVALIDCAST;
         }
 
-        protected InvalidCastException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public InvalidCastException(String message, Exception innerException)
+            : base(message, innerException)
+        {
+            HResult = __HResults.COR_E_INVALIDCAST;
         }
 
-        public InvalidCastException(String message, int errorCode) 
-            : base(message) {
-            SetErrorCode(errorCode);
+        public InvalidCastException(String message, int errorCode)
+            : base(message)
+        {
+            HResult = errorCode;
         }
 
+        protected InvalidCastException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
-
 }
diff --git a/src/mscorlib/src/System/InvalidOperationException.cs b/src/mscorlib/src/System/InvalidOperationException.cs
index 5f29e79056..24a08c8089 100644
--- a/src/mscorlib/src/System/InvalidOperationException.cs
+++ b/src/mscorlib/src/System/InvalidOperationException.cs
@@ -11,31 +11,32 @@
 **
 **
 =============================================================================*/
-namespace System {
-    
-    using System.Runtime.Serialization;
-    [System.Runtime.InteropServices.ComVisible(true)]
+
+using System.Runtime.Serialization;
+
+namespace System
+{
     [Serializable]
     public class InvalidOperationException : SystemException
     {
-        public InvalidOperationException() 
-            : base(Environment.GetResourceString("Arg_InvalidOperationException")) {
-            SetErrorCode(__HResults.COR_E_INVALIDOPERATION);
-        }
-        
-        public InvalidOperationException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_INVALIDOPERATION);
+        public InvalidOperationException()
+            : base(SR.Arg_InvalidOperationException)
+        {
+            HResult = __HResults.COR_E_INVALIDOPERATION;
         }
-    
-        public InvalidOperationException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_INVALIDOPERATION);
+
+        public InvalidOperationException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_INVALIDOPERATION;
         }
 
-        protected InvalidOperationException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public InvalidOperationException(String message, Exception innerException)
+            : base(message, innerException)
+        {
+            HResult = __HResults.COR_E_INVALIDOPERATION;
         }
 
+        protected InvalidOperationException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
 }
-
diff --git a/src/mscorlib/src/System/InvalidProgramException.cs b/src/mscorlib/src/System/InvalidProgramException.cs
index 649849a8bd..401b3a0ddb 100644
--- a/src/mscorlib/src/System/InvalidProgramException.cs
+++ b/src/mscorlib/src/System/InvalidProgramException.cs
@@ -11,31 +11,31 @@
 **
 =============================================================================*/
 
-namespace System {
+using System.Runtime.Serialization;
 
-    using System;
-    using System.Runtime.Serialization;
+namespace System
+{
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class InvalidProgramException : SystemException {
-        public InvalidProgramException() 
-            : base(Environment.GetResourceString("InvalidProgram_Default")) {
-            SetErrorCode(__HResults.COR_E_INVALIDPROGRAM);
+    public sealed class InvalidProgramException : SystemException
+    {
+        public InvalidProgramException()
+            : base(SR.InvalidProgram_Default)
+        {
+            HResult = __HResults.COR_E_INVALIDPROGRAM;
         }
-    
-        public InvalidProgramException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_INVALIDPROGRAM);
-        }
-    
-        public InvalidProgramException(String message, Exception inner) 
-            : base(message, inner) {
-            SetErrorCode(__HResults.COR_E_INVALIDPROGRAM);
+
+        public InvalidProgramException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_INVALIDPROGRAM;
         }
 
-        internal InvalidProgramException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public InvalidProgramException(String message, Exception inner)
+            : base(message, inner)
+        {
+            HResult = __HResults.COR_E_INVALIDPROGRAM;
         }
 
+        internal InvalidProgramException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
-
 }
diff --git a/src/mscorlib/src/System/InvalidTimeZoneException.cs b/src/mscorlib/src/System/InvalidTimeZoneException.cs
index f33475497a..8f0751c426 100644
--- a/src/mscorlib/src/System/InvalidTimeZoneException.cs
+++ b/src/mscorlib/src/System/InvalidTimeZoneException.cs
@@ -6,19 +6,23 @@ using System.Runtime.Serialization;
 
 namespace System
 {
-   [Serializable]
-   [System.Security.Permissions.HostProtection(MayLeakOnAbort = true)]
-   public class InvalidTimeZoneException : Exception
-   {
-       public InvalidTimeZoneException(String message)
-           : base(message) { }
+    [Serializable]
+    public class InvalidTimeZoneException : Exception
+    {
+        public InvalidTimeZoneException()
+        {
+        }
 
-       public InvalidTimeZoneException(String message, Exception innerException)
-           : base(message, innerException) { }
+        public InvalidTimeZoneException(String message)
+            : base(message)
+        {
+        }
 
-       protected InvalidTimeZoneException(SerializationInfo info, StreamingContext context)
-           : base(info, context) { }
+        public InvalidTimeZoneException(String message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
 
-       public InvalidTimeZoneException() { }
-   }
+        protected InvalidTimeZoneException(SerializationInfo info, StreamingContext context) : base(info, context) { }
+    }
 }
diff --git a/src/mscorlib/src/System/Lazy.cs b/src/mscorlib/src/System/Lazy.cs
index 85cbb9816a..0ddd6da3a2 100644
--- a/src/mscorlib/src/System/Lazy.cs
+++ b/src/mscorlib/src/System/Lazy.cs
@@ -18,7 +18,6 @@
 using System.Runtime;
 using System.Runtime.InteropServices;
 using System.Security;
-using System.Security.Permissions;
 using System.Diagnostics;
 using System.Runtime.Serialization;
 using System.Threading;
@@ -47,7 +46,6 @@ namespace System
     /// </para>
     /// </remarks>
     [Serializable]
-    [ComVisible(false)]
     [DebuggerTypeProxy(typeof(System_LazyDebugView<>))]
     [DebuggerDisplay("ThreadSafetyMode={Mode}, IsValueCreated={IsValueCreated}, IsValueFaulted={IsValueFaulted}, Value={ValueForDebugDisplay}")]
     public class Lazy<T>
diff --git a/src/mscorlib/src/System/LowLevelConsole.cs b/src/mscorlib/src/System/LowLevelConsole.cs
index 316583e276..29e69185ac 100644
--- a/src/mscorlib/src/System/LowLevelConsole.cs
+++ b/src/mscorlib/src/System/LowLevelConsole.cs
@@ -10,18 +10,14 @@ using Microsoft.Win32.SafeHandles;
 namespace System
 {
     //
-    // Simple limited console class for internal printf-style debugging in mscorlib
-    // and low-level tests that just want to depend on mscorlib.
+    // Simple limited console class for internal printf-style debugging in System.Private.CoreLib
+    // and low-level tests that want to call System.Private.CoreLib directly
     //
 
-    public static class Console
+    public static class LowLevelConsole
     {
-        static SafeFileHandle _outputHandle;
-
-        static Console()
-        {
-            _outputHandle = new SafeFileHandle(Win32Native.GetStdHandle(Win32Native.STD_OUTPUT_HANDLE), false);
-        }
+        private static readonly SafeFileHandle _outputHandle =
+            new SafeFileHandle(Win32Native.GetStdHandle(Win32Native.STD_OUTPUT_HANDLE), false);
 
         public static unsafe void Write(string s)
         {
@@ -44,4 +40,26 @@ namespace System
             Write(Environment.NewLine);
         }
      }
+
+     //
+     // Internal wrapper with the regular name for convenience. Note that it cannot be public to avoid colliding 
+     // with the full Console type.
+     //
+     internal static class Console
+     {
+        public static void Write(string s)
+        {
+            LowLevelConsole.Write(s);
+        }
+
+        public static void WriteLine(string s)
+        {
+            LowLevelConsole.WriteLine(s);
+        }
+
+        public static void WriteLine()
+        {
+            LowLevelConsole.WriteLine();
+        }
+    }
 }
diff --git a/src/mscorlib/src/System/MarshalByRefObject.cs b/src/mscorlib/src/System/MarshalByRefObject.cs
index 53ebda7672..9014de00c7 100644
--- a/src/mscorlib/src/System/MarshalByRefObject.cs
+++ b/src/mscorlib/src/System/MarshalByRefObject.cs
@@ -2,32 +2,25 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-/*============================================================
-**
-**
-**              
-**
-** Purpose: Defines the root type for all marshal by reference aka
-**          AppDomain bound types
-**          
-**
-**
-===========================================================*/
 namespace System
 {
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public abstract class MarshalByRefObject 
+    public abstract class MarshalByRefObject
     {
-        protected MarshalByRefObject() { }
+        protected MarshalByRefObject()
+        {
+        }
+
         public object GetLifetimeService()
         {
             throw new PlatformNotSupportedException();
         }
+
         public virtual object InitializeLifetimeService()
         {
             throw new PlatformNotSupportedException();
         }
+
         protected MarshalByRefObject MemberwiseClone(bool cloneIdentity)
         {
             MarshalByRefObject mbr = (MarshalByRefObject)base.MemberwiseClone();
diff --git a/src/mscorlib/src/System/Math.cs b/src/mscorlib/src/System/Math.cs
index 3ac1f0694a..8b2af3d3e4 100644
--- a/src/mscorlib/src/System/Math.cs
+++ b/src/mscorlib/src/System/Math.cs
@@ -149,7 +149,6 @@ namespace System {
         return InternalTruncate(d);
       }
             
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       [MethodImplAttribute(MethodImplOptions.InternalCall)]
       public static extern double Sqrt(double d);
       [MethodImplAttribute(MethodImplOptions.InternalCall)]
@@ -294,58 +293,49 @@ namespace System {
       **Returns the larger of val1 and val2
       ============================================================================*/
       [CLSCompliant(false)]
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       [System.Runtime.Versioning.NonVersionable]
       public static sbyte Max(sbyte val1, sbyte val2) {
         return (val1>=val2)?val1:val2;
       }
     
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       [System.Runtime.Versioning.NonVersionable]
       public static byte Max(byte val1, byte val2) {
         return (val1>=val2)?val1:val2;
       }
     
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       [System.Runtime.Versioning.NonVersionable]
       public static short Max(short val1, short val2) {
         return (val1>=val2)?val1:val2;
       }
     
       [CLSCompliant(false)]
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       [System.Runtime.Versioning.NonVersionable]
       public static ushort Max(ushort val1, ushort val2) {
         return (val1>=val2)?val1:val2;
       }
     
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       [System.Runtime.Versioning.NonVersionable]
       public static int Max(int val1, int val2) {
         return (val1>=val2)?val1:val2;
       }
     
       [CLSCompliant(false)]
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       [System.Runtime.Versioning.NonVersionable]
       public static uint Max(uint val1, uint val2) {
         return (val1>=val2)?val1:val2;
       }
     
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       [System.Runtime.Versioning.NonVersionable]
       public static long Max(long val1, long val2) {
         return (val1>=val2)?val1:val2;
       }
     
       [CLSCompliant(false)]
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       [System.Runtime.Versioning.NonVersionable]
       public static ulong Max(ulong val1, ulong val2) {
         return (val1>=val2)?val1:val2;
       }
     
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       public static float Max(float val1, float val2) {
         if (val1 > val2)
             return val1;
@@ -356,7 +346,6 @@ namespace System {
         return val2;
       }
     
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       public static double Max(double val1, double val2) {
         if (val1 > val2)
             return val1;
@@ -367,7 +356,6 @@ namespace System {
         return val2;
       }
     
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       public static Decimal Max(Decimal val1, Decimal val2) {
         return Decimal.Max(val1,val2);
       }
@@ -376,58 +364,49 @@ namespace System {
       **Returns the smaller of val1 and val2.
       ============================================================================*/
       [CLSCompliant(false)]
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       [System.Runtime.Versioning.NonVersionable]
       public static sbyte Min(sbyte val1, sbyte val2) {
         return (val1<=val2)?val1:val2;
       }
     
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       [System.Runtime.Versioning.NonVersionable]
       public static byte Min(byte val1, byte val2) {
         return (val1<=val2)?val1:val2;
       }
     
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       [System.Runtime.Versioning.NonVersionable]
       public static short Min(short val1, short val2) {
         return (val1<=val2)?val1:val2;
       }
     
       [CLSCompliant(false)]
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       [System.Runtime.Versioning.NonVersionable]
       public static ushort Min(ushort val1, ushort val2) {
         return (val1<=val2)?val1:val2;
       }
     
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       [System.Runtime.Versioning.NonVersionable]
       public static int Min(int val1, int val2) {
         return (val1<=val2)?val1:val2;
       }
     
       [CLSCompliant(false)]
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       [System.Runtime.Versioning.NonVersionable]
       public static uint Min(uint val1, uint val2) {
         return (val1<=val2)?val1:val2;
       }
     
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       [System.Runtime.Versioning.NonVersionable]
       public static long Min(long val1, long val2) {
         return (val1<=val2)?val1:val2;
       }
     
       [CLSCompliant(false)]
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       [System.Runtime.Versioning.NonVersionable]
       public static ulong Min(ulong val1, ulong val2) {
         return (val1<=val2)?val1:val2;
       }
     
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       public static float Min(float val1, float val2) {
         if (val1 < val2)
             return val1;
@@ -438,7 +417,6 @@ namespace System {
         return val2;
       }
     
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       public static double Min(double val1, double val2) {
         if (val1 < val2)
             return val1;
@@ -449,7 +427,6 @@ namespace System {
         return val2;
       }
     
-      [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
       public static Decimal Min(Decimal val1, Decimal val2) {
         return Decimal.Min(val1,val2);
       }
diff --git a/src/mscorlib/src/System/MathF.cs b/src/mscorlib/src/System/MathF.cs
index fb800924b5..545774cc32 100644
--- a/src/mscorlib/src/System/MathF.cs
+++ b/src/mscorlib/src/System/MathF.cs
@@ -143,10 +143,8 @@ namespace System {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         public static extern float Log10(float x);
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static float Max(float x, float y) => Math.Max(x, y);
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static float Min(float x, float y) => Math.Min(x, y);
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
@@ -201,7 +199,6 @@ namespace System {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         public static extern float Sinh(float x);
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         public static extern float Sqrt(float x);
 
diff --git a/src/mscorlib/src/System/MemberAccessException.cs b/src/mscorlib/src/System/MemberAccessException.cs
index bc21248dae..54eee67b07 100644
--- a/src/mscorlib/src/System/MemberAccessException.cs
+++ b/src/mscorlib/src/System/MemberAccessException.cs
@@ -8,41 +8,41 @@
 // access, due to it being removed, private or something similar.
 ////////////////////////////////////////////////////////////////////////////////
 
-namespace System {
-    
-    using System;
-    using System.Runtime.Serialization;
+using System.Runtime.Serialization;
+
+namespace System
+{
     // The MemberAccessException is thrown when trying to access a class
     // member fails.
     // 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
-    public class MemberAccessException : SystemException {
-        
+    public class MemberAccessException : SystemException
+    {
         // Creates a new MemberAccessException with its message string set to
         // the empty string, its HRESULT set to COR_E_MEMBERACCESS, 
         // and its ExceptionInfo reference set to null. 
-        public MemberAccessException() 
-            : base(Environment.GetResourceString("Arg_AccessException")) {
-            SetErrorCode(__HResults.COR_E_MEMBERACCESS);
+        public MemberAccessException()
+            : base(SR.Arg_AccessException)
+        {
+            HResult = __HResults.COR_E_MEMBERACCESS;
         }
-        
+
         // Creates a new MemberAccessException with its message string set to
         // message, its HRESULT set to COR_E_ACCESS, 
         // and its ExceptionInfo reference set to null. 
         // 
-        public MemberAccessException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_MEMBERACCESS);
-        }
-        
-        public MemberAccessException(String message, Exception inner) 
-            : base(message, inner) {
-            SetErrorCode(__HResults.COR_E_MEMBERACCESS);
+        public MemberAccessException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_MEMBERACCESS;
         }
 
-        protected MemberAccessException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public MemberAccessException(String message, Exception inner)
+            : base(message, inner)
+        {
+            HResult = __HResults.COR_E_MEMBERACCESS;
         }
 
+        protected MemberAccessException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
 }
diff --git a/src/mscorlib/src/System/MethodAccessException.cs b/src/mscorlib/src/System/MethodAccessException.cs
index 3feaf3ed54..2ecbd14d6d 100644
--- a/src/mscorlib/src/System/MethodAccessException.cs
+++ b/src/mscorlib/src/System/MethodAccessException.cs
@@ -9,31 +9,31 @@
 **
 =============================================================================*/
 
-namespace System {
-    
-    using System;
-    using System.Runtime.Serialization;
-    [System.Runtime.InteropServices.ComVisible(true)]
+using System.Runtime.Serialization;
+
+namespace System
+{
     [Serializable]
-    public class MethodAccessException : MemberAccessException {
-        public MethodAccessException() 
-            : base(Environment.GetResourceString("Arg_MethodAccessException")) {
-            SetErrorCode(__HResults.COR_E_METHODACCESS);
-        }
-    
-        public MethodAccessException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_METHODACCESS);
+    public class MethodAccessException : MemberAccessException
+    {
+        public MethodAccessException()
+            : base(SR.Arg_MethodAccessException)
+        {
+            HResult = __HResults.COR_E_METHODACCESS;
         }
-    
-        public MethodAccessException(String message, Exception inner) 
-            : base(message, inner) {
-            SetErrorCode(__HResults.COR_E_METHODACCESS);
+
+        public MethodAccessException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_METHODACCESS;
         }
 
-        protected MethodAccessException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public MethodAccessException(String message, Exception inner)
+            : base(message, inner)
+        {
+            HResult = __HResults.COR_E_METHODACCESS;
         }
 
+        protected MethodAccessException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
-
 }
diff --git a/src/mscorlib/src/System/MidpointRounding.cs b/src/mscorlib/src/System/MidpointRounding.cs
index ff709240c5..a75de43e65 100644
--- a/src/mscorlib/src/System/MidpointRounding.cs
+++ b/src/mscorlib/src/System/MidpointRounding.cs
@@ -2,11 +2,10 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-
-namespace System {
-
-[System.Runtime.InteropServices.ComVisible(true)]
-    public enum MidpointRounding {
+namespace System
+{
+    public enum MidpointRounding
+    {
         ToEven = 0,
         AwayFromZero = 1,
     }
diff --git a/src/mscorlib/src/System/MissingFieldException.cs b/src/mscorlib/src/System/MissingFieldException.cs
index d96d0378e3..660e39cb47 100644
--- a/src/mscorlib/src/System/MissingFieldException.cs
+++ b/src/mscorlib/src/System/MissingFieldException.cs
@@ -16,7 +16,6 @@ namespace System {
     using System.Runtime.Serialization;
     using System.Runtime.CompilerServices;
     using System.Globalization;
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class MissingFieldException : MissingMemberException, ISerializable {
         public MissingFieldException() 
@@ -51,14 +50,6 @@ namespace System {
             }
         }
     
-        // Called from the EE
-        private MissingFieldException(String className, String fieldName, byte[] signature)
-        {
-            ClassName   = className;
-            MemberName  = fieldName;
-            Signature   = signature;
-        }
-    
         public MissingFieldException(String className, String fieldName)
         {
             ClassName   = className;
diff --git a/src/mscorlib/src/System/MissingMemberException.cs b/src/mscorlib/src/System/MissingMemberException.cs
index ab773dc467..bb9be8827a 100644
--- a/src/mscorlib/src/System/MissingMemberException.cs
+++ b/src/mscorlib/src/System/MissingMemberException.cs
@@ -18,11 +18,9 @@ namespace System {
     using System.Runtime.Serialization;
     using System.Runtime.CompilerServices;
     using System.Globalization;
-        using System.Security.Permissions;
     using System.Runtime.Versioning;
     using System.Diagnostics.Contracts;
     
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class MissingMemberException : MemberAccessException, ISerializable {
         public MissingMemberException() 
@@ -64,16 +62,6 @@ namespace System {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         internal static extern String FormatSignature(byte [] signature);
     
-    
-    
-        // Potentially called from the EE
-        private MissingMemberException(String className, String memberName, byte[] signature)
-        {
-            ClassName   = className;
-            MemberName  = memberName;
-            Signature   = signature;
-        }
-    
         public MissingMemberException(String className, String memberName)
         {
             ClassName   = className;
diff --git a/src/mscorlib/src/System/MissingMethodException.cs b/src/mscorlib/src/System/MissingMethodException.cs
index 79434900a1..426711f953 100644
--- a/src/mscorlib/src/System/MissingMethodException.cs
+++ b/src/mscorlib/src/System/MissingMethodException.cs
@@ -18,7 +18,6 @@ namespace System {
     using System.Runtime.Serialization;
     using System.Runtime.CompilerServices;
     using System.Globalization;
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class MissingMethodException : MissingMemberException, ISerializable {
         public MissingMethodException() 
@@ -53,14 +52,6 @@ namespace System {
             }
         }
     
-        // Called from the EE
-        private MissingMethodException(String className, String methodName, byte[] signature)
-        {
-            ClassName   = className;
-            MemberName  = methodName;
-            Signature   = signature;
-        }
-    
         public MissingMethodException(String className, String methodName)
         {
             ClassName   = className;
diff --git a/src/mscorlib/src/System/MulticastNotSupportedException.cs b/src/mscorlib/src/System/MulticastNotSupportedException.cs
index ad8eeebb21..4fcaa9857d 100644
--- a/src/mscorlib/src/System/MulticastNotSupportedException.cs
+++ b/src/mscorlib/src/System/MulticastNotSupportedException.cs
@@ -7,31 +7,31 @@
 // This is thrown when you add multiple callbacks to a non-multicast delegate.
 ////////////////////////////////////////////////////////////////////////////////
 
-namespace System {
-    
-    using System;
-    using System.Runtime.Serialization;
-    [System.Runtime.InteropServices.ComVisible(true)]
+using System.Runtime.Serialization;
+
+namespace System
+{
     [Serializable]
-    public sealed class MulticastNotSupportedException : SystemException {
-        
-        public MulticastNotSupportedException() 
-            : base(Environment.GetResourceString("Arg_MulticastNotSupportedException")) {
-            SetErrorCode(__HResults.COR_E_MULTICASTNOTSUPPORTED);
-        }
-    
-        public MulticastNotSupportedException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_MULTICASTNOTSUPPORTED);
+    public sealed class MulticastNotSupportedException : SystemException
+    {
+        public MulticastNotSupportedException()
+            : base(SR.Arg_MulticastNotSupportedException)
+        {
+            HResult = __HResults.COR_E_MULTICASTNOTSUPPORTED;
         }
-        
-        public MulticastNotSupportedException(String message, Exception inner) 
-            : base(message, inner) {
-            SetErrorCode(__HResults.COR_E_MULTICASTNOTSUPPORTED);
+
+        public MulticastNotSupportedException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_MULTICASTNOTSUPPORTED;
         }
 
-        internal MulticastNotSupportedException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public MulticastNotSupportedException(String message, Exception inner)
+            : base(message, inner)
+        {
+            HResult = __HResults.COR_E_MULTICASTNOTSUPPORTED;
         }
 
+        internal MulticastNotSupportedException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
 }
diff --git a/src/mscorlib/src/System/NonSerializedAttribute.cs b/src/mscorlib/src/System/NonSerializedAttribute.cs
index c3cd9a540c..39f186212a 100644
--- a/src/mscorlib/src/System/NonSerializedAttribute.cs
+++ b/src/mscorlib/src/System/NonSerializedAttribute.cs
@@ -15,7 +15,6 @@ namespace System
     using System.Reflection;
 
     [AttributeUsage(AttributeTargets.Field, Inherited=false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class NonSerializedAttribute : Attribute 
     {
         internal static Attribute GetCustomAttribute(RuntimeFieldInfo field) 
diff --git a/src/mscorlib/src/System/NotFiniteNumberException.cs b/src/mscorlib/src/System/NotFiniteNumberException.cs
index 3a896ce548..68e8f88d81 100644
--- a/src/mscorlib/src/System/NotFiniteNumberException.cs
+++ b/src/mscorlib/src/System/NotFiniteNumberException.cs
@@ -2,68 +2,70 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-namespace System {
-    
-    using System;
-    using System.Runtime.Serialization;
-    using System.Security.Permissions;
-    using System.Diagnostics.Contracts;
+using System.Runtime.Serialization;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
+namespace System 
+{
     [Serializable]
-    public class NotFiniteNumberException : ArithmeticException {
+    public class NotFiniteNumberException : ArithmeticException 
+    {
         private double _offendingNumber;    
     
         public NotFiniteNumberException() 
-            : base(Environment.GetResourceString("Arg_NotFiniteNumberException")) {
+            : base(SR.Arg_NotFiniteNumberException) 
+        {
             _offendingNumber = 0;
-            SetErrorCode(__HResults.COR_E_NOTFINITENUMBER);
+            HResult = __HResults.COR_E_NOTFINITENUMBER;
         }
 
         public NotFiniteNumberException(double offendingNumber) 
-            : base() {
+            : base() 
+        {
             _offendingNumber = offendingNumber;
-            SetErrorCode(__HResults.COR_E_NOTFINITENUMBER);
+            HResult = __HResults.COR_E_NOTFINITENUMBER;
         }
 
         public NotFiniteNumberException(String message) 
-            : base(message) {
+            : base(message) 
+        {
             _offendingNumber = 0;
-            SetErrorCode(__HResults.COR_E_NOTFINITENUMBER);
+            HResult = __HResults.COR_E_NOTFINITENUMBER;
         }
 
         public NotFiniteNumberException(String message, double offendingNumber) 
-            : base(message) {
+            : base(message) 
+        {
             _offendingNumber = offendingNumber;
-            SetErrorCode(__HResults.COR_E_NOTFINITENUMBER);
+            HResult = __HResults.COR_E_NOTFINITENUMBER;
         }
 
         public NotFiniteNumberException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_NOTFINITENUMBER);
+            : base(message, innerException) 
+        {
+            HResult = __HResults.COR_E_NOTFINITENUMBER;
         }
         
         public NotFiniteNumberException(String message, double offendingNumber, Exception innerException) 
-            : base(message, innerException) {
+            : base(message, innerException) 
+        {
             _offendingNumber = offendingNumber;
-            SetErrorCode(__HResults.COR_E_NOTFINITENUMBER);
+            HResult = __HResults.COR_E_NOTFINITENUMBER;
         }
 
-        protected NotFiniteNumberException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        protected NotFiniteNumberException(SerializationInfo info, StreamingContext context) : base(info, context) 
+        {
             _offendingNumber = info.GetInt32("OffendingNumber");
         }
 
-        public double OffendingNumber {
-            get { return _offendingNumber; }
-        }
-
-        public override void GetObjectData(SerializationInfo info, StreamingContext context) {
-            if (info==null) {
-                throw new ArgumentNullException(nameof(info));
-            }
-            Contract.EndContractBlock();
+        public override void GetObjectData(SerializationInfo info, StreamingContext context) 
+        {
             base.GetObjectData(info, context);
             info.AddValue("OffendingNumber", _offendingNumber, typeof(Int32));
         }
+
+        public double OffendingNumber 
+        {
+            get { return _offendingNumber; }
+        }
     }
 }
diff --git a/src/mscorlib/src/System/NotImplementedException.cs b/src/mscorlib/src/System/NotImplementedException.cs
index d6c966805a..4d141eac8c 100644
--- a/src/mscorlib/src/System/NotImplementedException.cs
+++ b/src/mscorlib/src/System/NotImplementedException.cs
@@ -12,29 +12,29 @@
 **
 =============================================================================*/
 
-namespace System {
-    
-    using System;
-    using System.Runtime.Serialization;
+using System.Runtime.Serialization;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
+namespace System
+{
     [Serializable]
     public class NotImplementedException : SystemException
     {
-        public NotImplementedException() 
-            : base(Environment.GetResourceString("Arg_NotImplementedException")) {
-            SetErrorCode(__HResults.E_NOTIMPL);
+        public NotImplementedException()
+            : base(SR.Arg_NotImplementedException)
+        {
+            HResult = __HResults.E_NOTIMPL;
         }
-        public NotImplementedException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.E_NOTIMPL);
+        public NotImplementedException(String message)
+            : base(message)
+        {
+            HResult = __HResults.E_NOTIMPL;
         }
-        public NotImplementedException(String message, Exception inner) 
-            : base(message, inner) {
-            SetErrorCode(__HResults.E_NOTIMPL);
+        public NotImplementedException(String message, Exception inner)
+            : base(message, inner)
+        {
+            HResult = __HResults.E_NOTIMPL;
         }
 
-        protected NotImplementedException(SerializationInfo info, StreamingContext context) : base(info, context) {
-        }
+        protected NotImplementedException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
 }
diff --git a/src/mscorlib/src/System/NotSupportedException.cs b/src/mscorlib/src/System/NotSupportedException.cs
index ecef1d199a..21b2d54a46 100644
--- a/src/mscorlib/src/System/NotSupportedException.cs
+++ b/src/mscorlib/src/System/NotSupportedException.cs
@@ -11,31 +11,31 @@
 **
 =============================================================================*/
 
-namespace System {
-    
-    using System;
-    using System.Runtime.Serialization;
-    [System.Runtime.InteropServices.ComVisible(true)]
+using System.Runtime.Serialization;
+
+namespace System
+{
     [Serializable]
     public class NotSupportedException : SystemException
     {
-        public NotSupportedException() 
-            : base(Environment.GetResourceString("Arg_NotSupportedException")) {
-            SetErrorCode(__HResults.COR_E_NOTSUPPORTED);
-        }
-    
-        public NotSupportedException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_NOTSUPPORTED);
+        public NotSupportedException()
+            : base(SR.Arg_NotSupportedException)
+        {
+            HResult = __HResults.COR_E_NOTSUPPORTED;
         }
-        
-        public NotSupportedException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_NOTSUPPORTED);
+
+        public NotSupportedException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_NOTSUPPORTED;
         }
 
-        protected NotSupportedException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public NotSupportedException(String message, Exception innerException)
+            : base(message, innerException)
+        {
+            HResult = __HResults.COR_E_NOTSUPPORTED;
         }
 
+        protected NotSupportedException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
 }
diff --git a/src/mscorlib/src/System/NullReferenceException.cs b/src/mscorlib/src/System/NullReferenceException.cs
index d66ad9ca41..0aa5c6197a 100644
--- a/src/mscorlib/src/System/NullReferenceException.cs
+++ b/src/mscorlib/src/System/NullReferenceException.cs
@@ -11,30 +11,31 @@
 **
 =============================================================================*/
 
-namespace System {   
-    
-    using System;
-    using System.Runtime.Serialization;
-    [System.Runtime.InteropServices.ComVisible(true)]
+using System.Runtime.Serialization;
+
+namespace System
+{
     [Serializable]
-    public class NullReferenceException : SystemException {
-        public NullReferenceException() 
-            : base(Environment.GetResourceString("Arg_NullReferenceException")) {
-            SetErrorCode(__HResults.COR_E_NULLREFERENCE);
-        }
-    
-        public NullReferenceException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_NULLREFERENCE);
+    public class NullReferenceException : SystemException
+    {
+        public NullReferenceException()
+            : base(SR.Arg_NullReferenceException)
+        {
+            HResult = __HResults.COR_E_NULLREFERENCE;
         }
-        
-        public NullReferenceException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_NULLREFERENCE);
+
+        public NullReferenceException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_NULLREFERENCE;
         }
 
-        protected NullReferenceException(SerializationInfo info, StreamingContext context) : base(info, context) {}
+        public NullReferenceException(String message, Exception innerException)
+            : base(message, innerException)
+        {
+            HResult = __HResults.COR_E_NULLREFERENCE;
+        }
 
+        protected NullReferenceException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
-
 }
diff --git a/src/mscorlib/src/System/Nullable.cs b/src/mscorlib/src/System/Nullable.cs
index 8a22c8e65c..5ade2875c5 100644
--- a/src/mscorlib/src/System/Nullable.cs
+++ b/src/mscorlib/src/System/Nullable.cs
@@ -101,10 +101,8 @@ namespace System
         //   bool IEquatable<Nullable<T>>.Equals(Nullable<T> other)
                  }
         
-        [System.Runtime.InteropServices.ComVisible(true)]
     public static class Nullable
     {
-    [System.Runtime.InteropServices.ComVisible(true)]
         public static int Compare<T>(Nullable<T> n1, Nullable<T> n2) where T : struct
         {
             if (n1.HasValue) {
@@ -115,7 +113,6 @@ namespace System
                 return 0;
             }            
         
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static bool Equals<T>(Nullable<T> n1, Nullable<T> n2) where T : struct
         {
             if (n1.HasValue) {
diff --git a/src/mscorlib/src/System/Number.cs b/src/mscorlib/src/System/Number.cs
index 3412c02c31..66d05673a6 100644
--- a/src/mscorlib/src/System/Number.cs
+++ b/src/mscorlib/src/System/Number.cs
@@ -310,10 +310,6 @@ namespace System {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         internal unsafe static extern Boolean NumberBufferToDouble(byte* number, ref Double value);
 
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [System.Runtime.CompilerServices.FriendAccessAllowed]
-        internal static extern unsafe string FormatNumberBuffer(byte* number, string format, NumberFormatInfo info, char* allDigits);
-
         // Constants used by number parsing
         private const Int32 NumberMaxDigits = 50;
 
diff --git a/src/mscorlib/src/System/Object.cs b/src/mscorlib/src/System/Object.cs
index d8d9a0e36c..1f47d8cdef 100644
--- a/src/mscorlib/src/System/Object.cs
+++ b/src/mscorlib/src/System/Object.cs
@@ -37,7 +37,6 @@ namespace System
 public class Object
 {
     // Creates a new instance of an Object.
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     [System.Runtime.Versioning.NonVersionable]
     public Object()
     {            
@@ -73,7 +72,6 @@ public class Object
         return objA.Equals(objB);
     }
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     [System.Runtime.Versioning.NonVersionable]
     public static bool ReferenceEquals (Object objA, Object objB) {
         return objA == objB;
@@ -101,7 +99,6 @@ public class Object
 
     // Allow an object to free resources before the object is reclaimed by the GC.
     // 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     [System.Runtime.Versioning.NonVersionable]
     ~Object()
     {
diff --git a/src/mscorlib/src/System/ObjectDisposedException.cs b/src/mscorlib/src/System/ObjectDisposedException.cs
index d2eca37325..1f77b1f009 100644
--- a/src/mscorlib/src/System/ObjectDisposedException.cs
+++ b/src/mscorlib/src/System/ObjectDisposedException.cs
@@ -2,72 +2,81 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-namespace System {
-    using System;
-    using System.Runtime.Serialization;
-    using System.Globalization;
-    using System.Security.Permissions;
+using System.Globalization;
+using System.Runtime.Serialization;
 
+namespace System
+{
     /// <devdoc>
     ///    <para> The exception that is thrown when accessing an object that was
     ///       disposed.</para>
     /// </devdoc>
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
-    public class ObjectDisposedException : InvalidOperationException {
-        private String objectName;
+    public class ObjectDisposedException : InvalidOperationException
+    {
+        private String _objectName;
 
         // This constructor should only be called by the EE (COMPlusThrow)
-        private ObjectDisposedException() : 
-            this(null ,Environment.GetResourceString("ObjectDisposed_Generic")) {
+        private ObjectDisposedException() :
+            this(null, SR.ObjectDisposed_Generic)
+        {
         }
 
-        public ObjectDisposedException(String objectName) : 
-            this(objectName, Environment.GetResourceString("ObjectDisposed_Generic")) {
+        public ObjectDisposedException(String objectName) :
+            this(objectName, SR.ObjectDisposed_Generic)
+        {
         }
 
-        public ObjectDisposedException(String objectName, String message) : base(message) {
-            SetErrorCode(__HResults.COR_E_OBJECTDISPOSED);
-            this.objectName = objectName;
+        public ObjectDisposedException(String objectName, String message) : base(message)
+        {
+            HResult = __HResults.COR_E_OBJECTDISPOSED;
+            _objectName = objectName;
         }
 
-        public ObjectDisposedException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_OBJECTDISPOSED);
+        public ObjectDisposedException(String message, Exception innerException)
+            : base(message, innerException)
+        {
+            HResult = __HResults.COR_E_OBJECTDISPOSED;
+        }
+
+        protected ObjectDisposedException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+            _objectName = info.GetString("ObjectName");
+        }
+
+        public override void GetObjectData(SerializationInfo info, StreamingContext context)
+        {
+            base.GetObjectData(info, context);
+            info.AddValue("ObjectName",ObjectName,typeof(String));
         }
 
         /// <devdoc>
         ///    <para>Gets the text for the message for this exception.</para>
         /// </devdoc>
-        public override String Message {
-            get {
+        public override String Message
+        {
+            get
+            {
                 String name = ObjectName;
                 if (name == null || name.Length == 0)
                     return base.Message;
 
-                String objectDisposed = Environment.GetResourceString("ObjectDisposed_ObjectName_Name", name);
+                String objectDisposed = SR.Format(SR.ObjectDisposed_ObjectName_Name, name);
                 return base.Message + Environment.NewLine + objectDisposed;
             }
         }
 
-        public String ObjectName {
-            get {
-                if (objectName == null)
+        public String ObjectName
+        {
+            get
+            {
+                if ((_objectName == null)) // && !CompatibilitySwitches.IsAppEarlierThanWindowsPhone8)
                 {
                     return String.Empty;
                 }
-                return objectName; 
+                return _objectName;
             }
         }
-
-        protected ObjectDisposedException(SerializationInfo info, StreamingContext context) : base(info, context) {
-            objectName = info.GetString("ObjectName");
-        }
-
-        public override void GetObjectData(SerializationInfo info, StreamingContext context) {
-            base.GetObjectData(info, context);
-            info.AddValue("ObjectName",ObjectName,typeof(String));
-        }
-
     }
 }
diff --git a/src/mscorlib/src/System/ObsoleteAttribute.cs b/src/mscorlib/src/System/ObsoleteAttribute.cs
index 679e32a974..f183685998 100644
--- a/src/mscorlib/src/System/ObsoleteAttribute.cs
+++ b/src/mscorlib/src/System/ObsoleteAttribute.cs
@@ -10,51 +10,52 @@
 **
 ** 
 ===========================================================*/
-namespace System {
-    
-    using System;
-    using System.Runtime.Remoting;
+
+using System;
+
+namespace System
+{
     // This attribute is attached to members that are not to be used any longer.
     // Message is some human readable explanation of what to use
     // Error indicates if the compiler should treat usage of such a method as an
     //   error. (this would be used if the actual implementation of the obsolete 
     //   method's implementation had changed).
     // 
-[Serializable]
-[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum |
-        AttributeTargets.Interface | AttributeTargets.Constructor | AttributeTargets.Method| AttributeTargets.Property  | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Delegate
+    [Serializable]
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum |
+        AttributeTargets.Interface | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Delegate
         , Inherited = false)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class ObsoleteAttribute : Attribute
     {
         private String _message;
         private bool _error;
-        
-        public ObsoleteAttribute ()
+
+        public ObsoleteAttribute()
         {
             _message = null;
             _error = false;
         }
-    
-        public ObsoleteAttribute (String message)
+
+        public ObsoleteAttribute(String message)
         {
             _message = message;
             _error = false;
         }
-    
-        public ObsoleteAttribute (String message, bool error)
+
+        public ObsoleteAttribute(String message, bool error)
         {
             _message = message;
             _error = error;
         }
-    
-        public String Message {
-            get {return _message;}
+
+        public String Message
+        {
+            get { return _message; }
         }
-        
-        public bool IsError{
-            get {return _error;}
+
+        public bool IsError
+        {
+            get { return _error; }
         }
-        
     }
 }
diff --git a/src/mscorlib/src/System/OperatingSystem.cs b/src/mscorlib/src/System/OperatingSystem.cs
index a11d4bcce8..a388fc6e33 100644
--- a/src/mscorlib/src/System/OperatingSystem.cs
+++ b/src/mscorlib/src/System/OperatingSystem.cs
@@ -13,14 +13,12 @@
 namespace System {
     using System.Runtime.Serialization;
     using System.Globalization;
-    using System.Security.Permissions;
     using System.Runtime.InteropServices;
     using System.Diagnostics.Contracts;
 
 
-    [ComVisible(true)]
     [Serializable]
-    public sealed class OperatingSystem : ICloneable , ISerializable
+    internal sealed class OperatingSystem : ICloneable , ISerializable
     {
         private Version _version;
         private PlatformID _platform;
@@ -30,9 +28,6 @@ namespace System {
         private OperatingSystem()
         {
         }
-
-        public OperatingSystem(PlatformID platform, Version version) : this(platform, version, null) {
-        }
     
         internal OperatingSystem(PlatformID platform, Version version, string servicePack) {
             if( platform < PlatformID.Win32S || platform > PlatformID.MacOSX) {
@@ -82,20 +77,6 @@ namespace System {
             info.AddValue("_servicePack", _servicePack);
         }        
 
-        public PlatformID Platform {
-            get { return _platform; }
-        }
-        
-        public string ServicePack { 
-            get { 
-                if( _servicePack == null) {
-                    return string.Empty;
-                }
-
-                return _servicePack;
-            }
-        }    
-
         public Version Version {
             get { return _version; }
         }
diff --git a/src/mscorlib/src/System/OperationCanceledException.cs b/src/mscorlib/src/System/OperationCanceledException.cs
index 14781f5653..061201637a 100644
--- a/src/mscorlib/src/System/OperationCanceledException.cs
+++ b/src/mscorlib/src/System/OperationCanceledException.cs
@@ -18,7 +18,6 @@ using System.Threading;
 namespace System {
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class OperationCanceledException : SystemException
     {
         [NonSerialized] 
diff --git a/src/mscorlib/src/System/OutOfMemoryException.cs b/src/mscorlib/src/System/OutOfMemoryException.cs
index 9bea0b46d7..46d5195405 100644
--- a/src/mscorlib/src/System/OutOfMemoryException.cs
+++ b/src/mscorlib/src/System/OutOfMemoryException.cs
@@ -16,7 +16,6 @@ namespace System {
     using System;
     using System.Runtime.Serialization;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class OutOfMemoryException : SystemException {
         public OutOfMemoryException() 
diff --git a/src/mscorlib/src/System/OverflowException.cs b/src/mscorlib/src/System/OverflowException.cs
index ab717fb065..e28c688dd6 100644
--- a/src/mscorlib/src/System/OverflowException.cs
+++ b/src/mscorlib/src/System/OverflowException.cs
@@ -11,32 +11,31 @@
 **
 =============================================================================*/
 
-namespace System {
- 
-    
-    using System;
-    using System.Runtime.Serialization;
-    [System.Runtime.InteropServices.ComVisible(true)]
+using System.Runtime.Serialization;
+
+namespace System
+{
     [Serializable]
-    public class OverflowException : ArithmeticException {
-        public OverflowException() 
-            : base(Environment.GetResourceString("Arg_OverflowException")) {
-            SetErrorCode(__HResults.COR_E_OVERFLOW);
-        }
-    
-        public OverflowException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_OVERFLOW);
+    public class OverflowException : ArithmeticException
+    {
+        public OverflowException()
+            : base(SR.Arg_OverflowException)
+        {
+            HResult = __HResults.COR_E_OVERFLOW;
         }
-        
-        public OverflowException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_OVERFLOW);
+
+        public OverflowException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_OVERFLOW;
         }
 
-        protected OverflowException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public OverflowException(String message, Exception innerException)
+            : base(message, innerException)
+        {
+            HResult = __HResults.COR_E_OVERFLOW;
         }
 
+        protected OverflowException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
-
 }
diff --git a/src/mscorlib/src/System/ParamArrayAttribute.cs b/src/mscorlib/src/System/ParamArrayAttribute.cs
index 3a8e2e8302..d3c3d46d56 100644
--- a/src/mscorlib/src/System/ParamArrayAttribute.cs
+++ b/src/mscorlib/src/System/ParamArrayAttribute.cs
@@ -10,13 +10,12 @@
 **
 **
 =============================================================================*/
+
 namespace System
 {
-//This class contains only static members and does not need to be serializable 
-   [AttributeUsage (AttributeTargets.Parameter, Inherited=true, AllowMultiple=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
-   public sealed class ParamArrayAttribute : Attribute
-   {
-      public ParamArrayAttribute () {}  
-   }
+    [AttributeUsage(AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
+    public sealed class ParamArrayAttribute : Attribute
+    {
+        public ParamArrayAttribute() { }
+    }
 }
diff --git a/src/mscorlib/src/System/PlatformID.cs b/src/mscorlib/src/System/PlatformID.cs
index 57941996ee..16128079e2 100644
--- a/src/mscorlib/src/System/PlatformID.cs
+++ b/src/mscorlib/src/System/PlatformID.cs
@@ -13,8 +13,7 @@
 namespace System {
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public enum PlatformID
+    internal enum PlatformID
     {
         Win32S        = 0,
         Win32Windows  = 1,
diff --git a/src/mscorlib/src/System/PlatformNotSupportedException.cs b/src/mscorlib/src/System/PlatformNotSupportedException.cs
index 75d6d1d110..d2370b3924 100644
--- a/src/mscorlib/src/System/PlatformNotSupportedException.cs
+++ b/src/mscorlib/src/System/PlatformNotSupportedException.cs
@@ -11,32 +11,31 @@
 **
 =============================================================================*/
 
-namespace System {
-    
-    using System;
-    using System.Runtime.Serialization;
+using System.Runtime.Serialization;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
+namespace System
+{
     [Serializable]
     public class PlatformNotSupportedException : NotSupportedException
     {
-        public PlatformNotSupportedException() 
-            : base(Environment.GetResourceString("Arg_PlatformNotSupported")) {
-            SetErrorCode(__HResults.COR_E_PLATFORMNOTSUPPORTED);
+        public PlatformNotSupportedException()
+            : base(SR.Arg_PlatformNotSupported)
+        {
+            HResult = __HResults.COR_E_PLATFORMNOTSUPPORTED;
         }
-    
-        public PlatformNotSupportedException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_PLATFORMNOTSUPPORTED);
-        }
-        
-        public PlatformNotSupportedException(String message, Exception inner) 
-            : base(message, inner) {
-            SetErrorCode(__HResults.COR_E_PLATFORMNOTSUPPORTED);
+
+        public PlatformNotSupportedException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_PLATFORMNOTSUPPORTED;
         }
 
-        protected PlatformNotSupportedException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public PlatformNotSupportedException(String message, Exception inner)
+            : base(message, inner)
+        {
+            HResult = __HResults.COR_E_PLATFORMNOTSUPPORTED;
         }
 
+        protected PlatformNotSupportedException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
 }
diff --git a/src/mscorlib/src/System/Progress.cs b/src/mscorlib/src/System/Progress.cs
index 72c43c304d..755e7719fe 100644
--- a/src/mscorlib/src/System/Progress.cs
+++ b/src/mscorlib/src/System/Progress.cs
@@ -2,21 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-/*============================================================
-**
-** 
-** 
-**
-**
-** Purpose: Event-based implementation of IProgress<T>.
-**
-**
-===========================================================*/
-
 using System;
 using System.Threading;
 using System.Diagnostics;
-using System.Diagnostics.Contracts;
 
 namespace System
 {
@@ -34,22 +22,20 @@ namespace System
     public class Progress<T> : IProgress<T>
     {
         /// <summary>The synchronization context captured upon construction.  This will never be null.</summary>
-        private readonly SynchronizationContext m_synchronizationContext;
+        private readonly SynchronizationContext _synchronizationContext;
         /// <summary>The handler specified to the constructor.  This may be null.</summary>
-        private readonly Action<T> m_handler;
+        private readonly Action<T> _handler;
         /// <summary>A cached delegate used to post invocation to the synchronization context.</summary>
-        private readonly SendOrPostCallback m_invokeHandlers;
+        private readonly SendOrPostCallback _invokeHandlers;
 
         /// <summary>Initializes the <see cref="Progress{T}"/>.</summary>
         public Progress()
         {
-            // Capture the current synchronization context.  "current" is determined by CurrentNoFlow,
-            // which doesn't consider the sync ctx flown with an ExecutionContext, avoiding
-            // sync ctx reference identity issues where the sync ctx for one thread could be Current on another.
+            // Capture the current synchronization context.
             // If there is no current context, we use a default instance targeting the ThreadPool.
-            m_synchronizationContext = SynchronizationContext.CurrentNoFlow ?? ProgressStatics.DefaultContext;
-            Debug.Assert(m_synchronizationContext != null);
-            m_invokeHandlers = new SendOrPostCallback(InvokeHandlers);
+            _synchronizationContext = SynchronizationContext.Current ?? ProgressStatics.DefaultContext;
+            Debug.Assert(_synchronizationContext != null);
+            _invokeHandlers = new SendOrPostCallback(InvokeHandlers);
         }
 
         /// <summary>Initializes the <see cref="Progress{T}"/> with the specified callback.</summary>
@@ -64,7 +50,7 @@ namespace System
         public Progress(Action<T> handler) : this()
         {
             if (handler == null) throw new ArgumentNullException(nameof(handler));
-            m_handler = handler;
+            _handler = handler;
         }
 
         /// <summary>Raised for each reported progress value.</summary>
@@ -81,13 +67,13 @@ namespace System
             // If there's no handler, don't bother going through the sync context.
             // Inside the callback, we'll need to check again, in case 
             // an event handler is removed between now and then.
-            Action<T> handler = m_handler;
+            Action<T> handler = _handler;
             EventHandler<T> changedEvent = ProgressChanged;
             if (handler != null || changedEvent != null)
             {
                 // Post the processing to the sync context.
                 // (If T is a value type, it will get boxed here.)
-                m_synchronizationContext.Post(m_invokeHandlers, value);
+                _synchronizationContext.Post(_invokeHandlers, value);
             }
         }
 
@@ -101,7 +87,7 @@ namespace System
         {
             T value = (T)state;
 
-            Action<T> handler = m_handler;
+            Action<T> handler = _handler;
             EventHandler<T> changedEvent = ProgressChanged;
 
             if (handler != null) handler(value);
diff --git a/src/mscorlib/src/System/Random.cs b/src/mscorlib/src/System/Random.cs
index f5941d6718..db6da0ea8b 100644
--- a/src/mscorlib/src/System/Random.cs
+++ b/src/mscorlib/src/System/Random.cs
@@ -18,7 +18,6 @@ namespace System {
     using System.Globalization;
     using System.Diagnostics.Contracts;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class Random {
       //
diff --git a/src/mscorlib/src/System/RankException.cs b/src/mscorlib/src/System/RankException.cs
index 8639bba30e..612d0f086c 100644
--- a/src/mscorlib/src/System/RankException.cs
+++ b/src/mscorlib/src/System/RankException.cs
@@ -12,31 +12,31 @@
 **
 =============================================================================*/
 
-namespace System {
-    
-    using System;
-    using System.Runtime.Serialization;
-    [System.Runtime.InteropServices.ComVisible(true)]
+using System.Runtime.Serialization;
+
+namespace System
+{
     [Serializable]
     public class RankException : SystemException
     {
-        public RankException() 
-            : base(Environment.GetResourceString("Arg_RankException")) {
-            SetErrorCode(__HResults.COR_E_RANK);
-        }
-    
-        public RankException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_RANK);
+        public RankException()
+            : base(SR.Arg_RankException)
+        {
+            HResult = __HResults.COR_E_RANK;
         }
-        
-        public RankException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_RANK);
+
+        public RankException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_RANK;
         }
 
-        protected RankException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public RankException(String message, Exception innerException)
+            : base(message, innerException)
+        {
+            HResult = __HResults.COR_E_RANK;
         }
 
+        protected RankException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
 }
diff --git a/src/mscorlib/src/System/ReadOnlySpan.cs b/src/mscorlib/src/System/ReadOnlySpan.cs
index c7125ebf92..ccbca3c118 100644
--- a/src/mscorlib/src/System/ReadOnlySpan.cs
+++ b/src/mscorlib/src/System/ReadOnlySpan.cs
@@ -103,7 +103,7 @@ namespace System
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public unsafe ReadOnlySpan(void* pointer, int length)
         {
-            if (JitHelpers.ContainsReferences<T>())
+            if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
                 ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
             if (length < 0)
                 ThrowHelper.ThrowArgumentOutOfRangeException();
@@ -281,7 +281,7 @@ namespace System
         /// <exception cref="System.ArgumentOutOfRangeException">
         /// Thrown when the specified <paramref name="start"/> index is not in range (&lt;0 or &gt;=Length).
         /// </exception>
-        [MethodImpl(MethodImplOptions.NoOptimization)] // TODO-SPAN: Workaround for https://github.com/dotnet/coreclr/issues/7894
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ReadOnlySpan<T> Slice(int start)
         {
             if ((uint)start > (uint)_length)
@@ -298,7 +298,7 @@ namespace System
         /// <exception cref="System.ArgumentOutOfRangeException">
         /// Thrown when the specified <paramref name="start"/> or end index is not in range (&lt;0 or &gt;=Length).
         /// </exception>
-        [MethodImpl(MethodImplOptions.NoOptimization)] // TODO-SPAN: Workaround for https://github.com/dotnet/coreclr/issues/7894
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ReadOnlySpan<T> Slice(int start, int length)
         {
             if ((uint)start > (uint)_length || (uint)length > (uint)(_length - start))
@@ -327,62 +327,4 @@ namespace System
         /// </summary>
         public static ReadOnlySpan<T> Empty => default(ReadOnlySpan<T>);
     }
-
-    public static class ReadOnlySpanExtensions
-    {
-        /// <summary>
-        /// Creates a new readonly span over the portion of the target string.
-        /// </summary>
-        /// <param name="text">The target string.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown when <paramref name="text"/> is a null
-        /// reference (Nothing in Visual Basic).</exception>
-        public static ReadOnlySpan<char> Slice(this string text)
-        {
-            if (text == null)
-                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.text);
-
-            return new ReadOnlySpan<char>(ref text.GetFirstCharRef(), text.Length);
-        }
-
-        /// <summary>
-        /// Creates a new readonly span over the portion of the target string, beginning at 'start'.
-        /// </summary>
-        /// <param name="text">The target string.</param>
-        /// <param name="start">The index at which to begin this slice.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown when <paramref name="text"/> is a null
-        /// reference (Nothing in Visual Basic).</exception>
-        /// <exception cref="System.ArgumentOutOfRangeException">
-        /// Thrown when the specified <paramref name="start"/> index is not in range (&lt;0 or &gt;Length).
-        /// </exception>
-        public static ReadOnlySpan<char> Slice(this string text, int start)
-        {
-            if (text == null)
-                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.text);
-            if ((uint)start > (uint)text.Length)
-                ThrowHelper.ThrowArgumentOutOfRangeException();
-
-            return new ReadOnlySpan<char>(ref Unsafe.Add(ref text.GetFirstCharRef(), start), text.Length - start);
-        }
-
-        /// <summary>
-        /// Creates a new readonly span over the portion of the target string, beginning at <paramref name="start"/>, of given <paramref name="length"/>.
-        /// </summary>
-        /// <param name="text">The target string.</param>
-        /// <param name="start">The index at which to begin this slice.</param>
-        /// <param name="length">The number of items in the span.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown when <paramref name="text"/> is a null
-        /// reference (Nothing in Visual Basic).</exception>
-        /// <exception cref="System.ArgumentOutOfRangeException">
-        /// Thrown when the specified <paramref name="start"/> or end index is not in range (&lt;0 or &gt;&eq;Length).
-        /// </exception>
-        public static ReadOnlySpan<char> Slice(this string text, int start, int length)
-        {
-            if (text == null)
-                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.text);
-            if ((uint)start > (uint)text.Length || (uint)length > (uint)(text.Length - start))
-                ThrowHelper.ThrowArgumentOutOfRangeException();
-
-            return new ReadOnlySpan<char>(ref Unsafe.Add(ref text.GetFirstCharRef(), start), length);
-        }
-    }
 }
diff --git a/src/mscorlib/src/System/Reflection/AmbiguousMatchException.cs b/src/mscorlib/src/System/Reflection/AmbiguousMatchException.cs
index 6df371bd11..795a8714d1 100644
--- a/src/mscorlib/src/System/Reflection/AmbiguousMatchException.cs
+++ b/src/mscorlib/src/System/Reflection/AmbiguousMatchException.cs
@@ -18,7 +18,6 @@ namespace System.Reflection {
     using SystemException = System.SystemException;
     using System.Runtime.Serialization;
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class AmbiguousMatchException : SystemException
     {
         
diff --git a/src/mscorlib/src/System/Reflection/Assembly.cs b/src/mscorlib/src/System/Reflection/Assembly.cs
index f8cb3b648a..4bb1708ac0 100644
--- a/src/mscorlib/src/System/Reflection/Assembly.cs
+++ b/src/mscorlib/src/System/Reflection/Assembly.cs
@@ -22,15 +22,12 @@ namespace System.Reflection
     using CultureInfo = System.Globalization.CultureInfo;
     using System.Security;
     using System.Security.Policy;
-    using System.Security.Permissions;
     using System.IO;
     using StringBuilder = System.Text.StringBuilder;
     using System.Configuration.Assemblies;
     using StackCrawlMark = System.Threading.StackCrawlMark;
     using System.Runtime.InteropServices;
     using System.Runtime.CompilerServices;
-    using SecurityZone = System.Security.SecurityZone;
-    using IEvidenceFactory = System.Security.IEvidenceFactory;
     using System.Runtime.Serialization;
     using Microsoft.Win32;
     using System.Threading;
@@ -40,15 +37,11 @@ namespace System.Reflection
     using System.Runtime.Loader;
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public delegate Module ModuleResolveEventHandler(Object sender, ResolveEventArgs e);
 
 
     [Serializable]
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_Assembly))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public abstract class Assembly : _Assembly, IEvidenceFactory, ICustomAttributeProvider, ISerializable
+    public abstract class Assembly : ICustomAttributeProvider, ISerializable
     {
         protected Assembly() {}
 
@@ -109,27 +102,20 @@ namespace System.Reflection
         }
 
         // Locate an assembly for reflection by the name of the file containing the manifest.
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Assembly ReflectionOnlyLoadFrom(String assemblyFile)
         {
-            Contract.Ensures(Contract.Result<Assembly>() != null);
-
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-
-            return RuntimeAssembly.InternalLoadFrom(
-                assemblyFile,
-                null, //securityEvidence
-                null, //hashValue
-                AssemblyHashAlgorithm.None,
-                true,  //forIntrospection
-                false, //suppressSecurityChecks
-                ref stackMark);
+            if (assemblyFile == null)
+                throw new ArgumentNullException(nameof(assemblyFile));
+            if (assemblyFile.Length == 0)
+                throw new ArgumentException(Environment.GetResourceString("Format_StringZeroLength"));
+            throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReflectionOnlyLoad"));
         }
 
         // Evidence is protected in Assembly.Load()
         [Obsolete("This method is obsolete and will be removed in a future release of the .NET Framework. Please use an overload of LoadFrom which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        public static Assembly LoadFrom(String assemblyFile,
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
+        internal static Assembly LoadFrom(String assemblyFile,
                                         Evidence securityEvidence)
         {
             Contract.Ensures(Contract.Result<Assembly>() != null);
@@ -142,33 +128,10 @@ namespace System.Reflection
                 null, // hashValue
                 AssemblyHashAlgorithm.None,
                 false,// forIntrospection);
-                false,// suppressSecurityChecks
-                ref stackMark);
-        }
-
-        // Evidence is protected in Assembly.Load()
-        [Obsolete("This method is obsolete and will be removed in a future release of the .NET Framework. Please use an overload of LoadFrom which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        public static Assembly LoadFrom(String assemblyFile,
-                                        Evidence securityEvidence,
-                                        byte[] hashValue,
-                                        AssemblyHashAlgorithm hashAlgorithm)
-        {
-            Contract.Ensures(Contract.Result<Assembly>() != null);
-
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-
-            return RuntimeAssembly.InternalLoadFrom(
-                assemblyFile, 
-                securityEvidence, 
-                hashValue, 
-                hashAlgorithm, 
-                false,
-                false,
                 ref stackMark);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Assembly LoadFrom(String assemblyFile,
                                         byte[] hashValue,
                                         AssemblyHashAlgorithm hashAlgorithm)
@@ -183,7 +146,7 @@ namespace System.Reflection
 
         // Locate an assembly by the long form of the assembly name. 
         // eg. "Toolbox.dll, version=1.1.10.1220, locale=en, publickey=1234567890123456789012345678901234567890"
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Assembly Load(String assemblyString)
         {
             Contract.Ensures(Contract.Result<Assembly>() != null);
@@ -197,7 +160,7 @@ namespace System.Reflection
         // Calls Type.GetType for WinRT types.
         // Note: Type.GetType fails for assembly names that start with weird characters like '['. By calling it for managed types we would 
         // break AppCompat.
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         internal static Type GetType_Compat(String assemblyString, String typeName)
         {
             // Normally we would get the stackMark only in public APIs. This is internal API, but it is AppCompat replacement of public API 
@@ -218,7 +181,7 @@ namespace System.Reflection
 
                 assembly = RuntimeAssembly.InternalLoadAssemblyName(
                     assemblyName, null, null, ref stackMark,
-                    true /*thrownOnFileNotFound*/, false /*forIntrospection*/, false /*suppressSecurityChecks*/);
+                    true /*thrownOnFileNotFound*/, false /*forIntrospection*/);
             }
             return assembly.GetType(typeName, true /*throwOnError*/, false /*ignoreCase*/);
         }
@@ -226,29 +189,19 @@ namespace System.Reflection
         // Locate an assembly for reflection by the long form of the assembly name. 
         // eg. "Toolbox.dll, version=1.1.10.1220, locale=en, publickey=1234567890123456789012345678901234567890"
         //
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Assembly ReflectionOnlyLoad(String assemblyString)
         {
-            Contract.Ensures(Contract.Result<Assembly>() != null);
-
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return RuntimeAssembly.InternalLoad(assemblyString, null,  ref stackMark, true /*forIntrospection*/);
-        }
-    
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        [Obsolete("This method is obsolete and will be removed in a future release of the .NET Framework. Please use an overload of Load which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
-        public static Assembly Load(String assemblyString, Evidence assemblySecurity)
-        {
-            Contract.Ensures(Contract.Result<Assembly>() != null);
-            Contract.Ensures(!Contract.Result<Assembly>().ReflectionOnly);
-
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return RuntimeAssembly.InternalLoad(assemblyString, assemblySecurity, ref stackMark, false /*forIntrospection*/);
+            if (assemblyString == null)
+                throw new ArgumentNullException(nameof(assemblyString));
+            if (assemblyString.Length == 0)
+                throw new ArgumentException(Environment.GetResourceString("Format_StringZeroLength"));
+            throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReflectionOnlyLoad"));
         }
 
         // Locate an assembly by its name. The name can be strong or
         // weak. The assembly is loaded into the domain of the caller.
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Assembly Load(AssemblyName assemblyRef)
         {
             Contract.Ensures(Contract.Result<Assembly>() != null);
@@ -260,12 +213,12 @@ namespace System.Reflection
             }
 
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return RuntimeAssembly.InternalLoadAssemblyName(assemblyRef, null, null, ref stackMark, true /*thrownOnFileNotFound*/, false /*forIntrospection*/, false /*suppressSecurityChecks*/);
+            return RuntimeAssembly.InternalLoadAssemblyName(assemblyRef, null, null, ref stackMark, true /*thrownOnFileNotFound*/, false /*forIntrospection*/);
         }
 
         // Locate an assembly by its name. The name can be strong or
         // weak. The assembly is loaded into the domain of the caller.
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         internal static Assembly Load(AssemblyName assemblyRef, IntPtr ptrLoadContextBinder)
         {
             Contract.Ensures(Contract.Result<Assembly>() != null);
@@ -277,18 +230,7 @@ namespace System.Reflection
             }
 
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return RuntimeAssembly.InternalLoadAssemblyName(assemblyRef, null, null, ref stackMark, true /*thrownOnFileNotFound*/, false /*forIntrospection*/, false /*suppressSecurityChecks*/, ptrLoadContextBinder);
-        }
-
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        [Obsolete("This method is obsolete and will be removed in a future release of the .NET Framework. Please use an overload of Load which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
-        public static Assembly Load(AssemblyName assemblyRef, Evidence assemblySecurity)
-        {
-            Contract.Ensures(Contract.Result<Assembly>() != null);
-            Contract.Ensures(!Contract.Result<Assembly>().ReflectionOnly);
-
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return RuntimeAssembly.InternalLoadAssemblyName(assemblyRef, assemblySecurity, null, ref stackMark, true /*thrownOnFileNotFound*/, false /*forIntrospection*/, false /*suppressSecurityChecks*/);
+            return RuntimeAssembly.InternalLoadAssemblyName(assemblyRef, null, null, ref stackMark, true /*thrownOnFileNotFound*/, false /*forIntrospection*/, ptrLoadContextBinder);
         }
 
         [Obsolete("This method has been deprecated. Please use Assembly.Load() instead. http://go.microsoft.com/fwlink/?linkid=14202")]
@@ -302,7 +244,7 @@ namespace System.Reflection
         // Loads the assembly with a COFF based IMAGE containing
         // an emitted assembly. The assembly is loaded into the domain
         // of the caller.
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Assembly Load(byte[] rawAssembly)
         {
             Contract.Ensures(Contract.Result<Assembly>() != null);
@@ -316,28 +258,19 @@ namespace System.Reflection
         // Loads the assembly for reflection with a COFF based IMAGE containing
         // an emitted assembly. The assembly is loaded into the domain
         // of the caller.
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Assembly ReflectionOnlyLoad(byte[] rawAssembly)
         {
-            Contract.Ensures(Contract.Result<Assembly>() != null);
-
-            AppDomain.CheckReflectionOnlyLoadSupported();
-
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return RuntimeAssembly.nLoadImage(
-                rawAssembly,
-                null, // symbol store
-                null, // evidence
-                ref stackMark,
-                true,  // fIntrospection
-                SecurityContextSource.CurrentAssembly);
+            if (rawAssembly == null)
+                throw new ArgumentNullException(nameof(rawAssembly));
+            throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReflectionOnlyLoad"));
         }
 
         // Loads the assembly with a COFF based IMAGE containing
         // an emitted assembly. The assembly is loaded into the domain
         // of the caller. The second parameter is the raw bytes
         // representing the symbol store that matches the assembly.
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Assembly Load(byte[] rawAssembly,
                                     byte[] rawSymbolStore)
         {
@@ -354,33 +287,6 @@ namespace System.Reflection
             return alc.LoadFromStream(assemblyStream, symbolStream);
         }
 
-        // Load an assembly from a byte array, controlling where the grant set of this assembly is
-        // propigated from.
-        [MethodImpl(MethodImplOptions.NoInlining)]  // Due to the stack crawl mark
-        public static Assembly Load(byte[] rawAssembly,
-                                    byte[] rawSymbolStore,
-                                    SecurityContextSource securityContextSource)
-        {
-            Contract.Ensures(Contract.Result<Assembly>() != null);
-            Contract.Ensures(!Contract.Result<Assembly>().ReflectionOnly);
-
-            AppDomain.CheckLoadByteArraySupported();
-
-            if (securityContextSource < SecurityContextSource.CurrentAppDomain ||
-                securityContextSource > SecurityContextSource.CurrentAssembly)
-            {
-                throw new ArgumentOutOfRangeException(nameof(securityContextSource));
-            }
-
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return RuntimeAssembly.nLoadImage(rawAssembly,
-                                              rawSymbolStore,
-                                              null,             // evidence
-                                              ref stackMark,
-                                              false,            // fIntrospection
-                                              securityContextSource);
-        }
-
         private static Dictionary<string, Assembly> s_loadfile = new Dictionary<string, Assembly>();
 
         public static Assembly LoadFile(String path)
@@ -412,36 +318,17 @@ namespace System.Reflection
             return result;
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        public static Assembly Load(Stream assemblyStream, Stream pdbStream)
-        {
-            Contract.Ensures(Contract.Result<Assembly>() != null);
-            Contract.Ensures(!Contract.Result<Assembly>().ReflectionOnly);
-
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return RuntimeAssembly.InternalLoadFromStream(assemblyStream, pdbStream, ref stackMark);
-        }
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        public static Assembly Load(Stream assemblyStream)
-        {
-            Contract.Ensures(Contract.Result<Assembly>() != null);
-            Contract.Ensures(!Contract.Result<Assembly>().ReflectionOnly);
-
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return RuntimeAssembly.InternalLoadFromStream(assemblyStream, null, ref stackMark);
-        }
-
         /*
          * Get the assembly that the current code is running from.
          */
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable 
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod 
         public static Assembly GetExecutingAssembly()
         {
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             return RuntimeAssembly.GetExecutingAssembly(ref stackMark);
         }
        
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Assembly GetCallingAssembly()
         {
             // LookForMyCallersCaller is not guarantee to return the correct stack frame
@@ -634,7 +521,6 @@ namespace System.Reflection
             throw new NotImplementedException();
         }
 
-        [ComVisible(false)]
         public virtual Module ManifestModule
         {
             get
@@ -679,9 +565,6 @@ namespace System.Reflection
             throw new NotImplementedException();
         }
 
-        // To not break compatibility with the V1 _Assembly interface we need to make this
-        // new member ComVisible(false).
-        [ComVisible(false)]
         public virtual bool ReflectionOnly
         {
             get
@@ -831,9 +714,6 @@ namespace System.Reflection
             }
         }
 
-        // To not break compatibility with the V1 _Assembly interface we need to make this
-        // new member ComVisible(false).
-        [ComVisible(false)]
         public virtual String ImageRuntimeVersion
         {
             get
@@ -853,7 +733,6 @@ namespace System.Reflection
             }
         }
 
-        [ComVisible(false)]
         public virtual Int64 HostContext
         {
             get
@@ -880,15 +759,6 @@ namespace System.Reflection
 
     }
 
-    // Keep this in sync with LOADCTX_TYPE defined in fusionpriv.idl
-    internal enum LoadContext
-    {
-       DEFAULT,
-       LOADFROM,
-       UNKNOWN,
-       HOSTED,
-    }
-
     [Serializable]
     internal class RuntimeAssembly : Assembly
     {
@@ -910,7 +780,6 @@ namespace System.Reflection
         internal RuntimeAssembly() { throw new NotSupportedException(); }
 
 #region private data members
-        [method: System.Security.SecurityCritical]
         private event ModuleResolveEventHandler _ModuleResolve;
         private string m_fullname;
         private object m_syncRoot;   // Used to keep collectible types alive and as the syncroot for reflection.emit
@@ -992,7 +861,6 @@ namespace System.Reflection
         {
             get {
                 String codeBase = GetCodeBase(false);
-                VerifyCodeBaseDiscovery(codeBase);
                 return codeBase;
             }
         }
@@ -1010,7 +878,6 @@ namespace System.Reflection
             AssemblyName an = new AssemblyName();
 
             String codeBase = GetCodeBase(copiedName);
-            VerifyCodeBaseDiscovery(codeBase);
 
             an.Init(GetSimpleName(), 
                     GetPublicKey(),
@@ -1099,10 +966,6 @@ namespace System.Reflection
 
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
         [SuppressUnmanagedCodeSecurity]
-        internal extern static void GetForwardedTypes(RuntimeAssembly assembly, ObjectHandleOnStack retTypes);
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
         private extern static void GetExportedTypes(RuntimeAssembly assembly, ObjectHandleOnStack retTypes); 
         
         public override Type[] GetExportedTypes()
@@ -1130,14 +993,14 @@ namespace System.Reflection
         }
 
         // Load a resource based on the NameSpace of the type.
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public override Stream GetManifestResourceStream(Type type, String name)
         {
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             return GetManifestResourceStream(type, name, false, ref stackMark);
         }
     
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public override Stream GetManifestResourceStream(String name)
         {
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
@@ -1206,13 +1069,12 @@ namespace System.Reflection
             return CustomAttributeData.GetCustomAttributesInternal(this);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         internal static RuntimeAssembly InternalLoadFrom(String assemblyFile, 
                                                          Evidence securityEvidence,
                                                          byte[] hashValue, 
                                                          AssemblyHashAlgorithm hashAlgorithm,
                                                          bool forIntrospection,
-                                                         bool suppressSecurityChecks,
                                                          ref StackCrawlMark stackMark)
         {
             if (assemblyFile == null)
@@ -1224,7 +1086,7 @@ namespace System.Reflection
             an.CodeBase = assemblyFile;
             an.SetHashControl(hashValue, hashAlgorithm);
             // The stack mark is used for MDA filtering
-            return InternalLoadAssemblyName(an, securityEvidence, null, ref stackMark, true /*thrownOnFileNotFound*/, forIntrospection, suppressSecurityChecks);
+            return InternalLoadAssemblyName(an, securityEvidence, null, ref stackMark, true /*thrownOnFileNotFound*/, forIntrospection);
         }
 
         // Wrapper function to wrap the typical use of InternalLoad.
@@ -1236,7 +1098,7 @@ namespace System.Reflection
             return InternalLoad(assemblyString, assemblySecurity,  ref stackMark, IntPtr.Zero, forIntrospection);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         internal static RuntimeAssembly InternalLoad(String assemblyString,
                                                      Evidence assemblySecurity,
                                                      ref StackCrawlMark stackMark,
@@ -1253,7 +1115,7 @@ namespace System.Reflection
 
             return InternalLoadAssemblyName(an, assemblySecurity, null, ref stackMark, 
                                             pPrivHostBinder,
-                                            true  /*thrownOnFileNotFound*/, forIntrospection, false /* suppressSecurityChecks */);
+                                            true  /*thrownOnFileNotFound*/, forIntrospection);
         }
         
         // Creates AssemblyName. Fills assembly if AssemblyResolve event has been raised.
@@ -1289,10 +1151,9 @@ namespace System.Reflection
             ref StackCrawlMark stackMark,
             bool throwOnFileNotFound,
             bool forIntrospection,
-            bool suppressSecurityChecks,
             IntPtr ptrLoadContextBinder = default(IntPtr))
         {
-            return InternalLoadAssemblyName(assemblyRef, assemblySecurity, reqAssembly, ref stackMark, IntPtr.Zero, true /*throwOnError*/, forIntrospection, suppressSecurityChecks, ptrLoadContextBinder);
+            return InternalLoadAssemblyName(assemblyRef, assemblySecurity, reqAssembly, ref stackMark, IntPtr.Zero, true /*throwOnError*/, forIntrospection, ptrLoadContextBinder);
         }
 
         internal static RuntimeAssembly InternalLoadAssemblyName(
@@ -1303,7 +1164,6 @@ namespace System.Reflection
             IntPtr pPrivHostBinder,
             bool throwOnFileNotFound, 
             bool forIntrospection,
-            bool suppressSecurityChecks,
             IntPtr ptrLoadContextBinder = default(IntPtr))
         {
        
@@ -1323,34 +1183,11 @@ namespace System.Reflection
                 assemblyRef.ProcessorArchitecture = ProcessorArchitecture.None;
             }
 
-            if (assemblySecurity != null)
-            {
-                if (!suppressSecurityChecks)
-                {
-#pragma warning disable 618
-                    new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Demand();
-#pragma warning restore 618
-                }
-            }
-
             String codeBase = VerifyCodeBase(assemblyRef.CodeBase);
-            if (codeBase != null && !suppressSecurityChecks)
-            {
-                if (String.Compare( codeBase, 0, s_localFilePrefix, 0, 5, StringComparison.OrdinalIgnoreCase) != 0)
-                {
-                    // Of all the binders, Fusion is the only one that understands Web locations                 
-                     throw new ArgumentException(Environment.GetResourceString("Arg_InvalidFileName"), "assemblyRef.CodeBase");
-                }
-                else
-                {
-                    System.Security.Util.URLString urlString = new System.Security.Util.URLString( codeBase, true );
-                    new FileIOPermission( FileIOPermissionAccess.PathDiscovery | FileIOPermissionAccess.Read , urlString.GetFileName() ).Demand();
-                }
-            }
 
             return nLoad(assemblyRef, codeBase, assemblySecurity, reqAssembly, ref stackMark,
                 pPrivHostBinder,
-                throwOnFileNotFound, forIntrospection, suppressSecurityChecks, ptrLoadContextBinder);
+                throwOnFileNotFound, forIntrospection, ptrLoadContextBinder);
         }
 
         // These are the framework assemblies that does reflection invocation
@@ -1376,15 +1213,6 @@ namespace System.Reflection
             ASSEMBLY_FLAGS flags = Flags;
             return (flags & ASSEMBLY_FLAGS.ASSEMBLY_FLAGS_SAFE_REFLECTION) != 0;
         }
-
-        private bool IsDesignerBindingContext()
-        {
-            return RuntimeAssembly.nIsDesignerBindingContext(this);
-        }
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        private extern static bool nIsDesignerBindingContext(RuntimeAssembly assembly);
 #endif
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
@@ -1407,19 +1235,16 @@ namespace System.Reflection
                                              IntPtr pPrivHostBinder,
                                              bool throwOnFileNotFound,
                                              bool forIntrospection,
-                                             bool suppressSecurityChecks, IntPtr ptrLoadContextBinder = default(IntPtr))
+                                             IntPtr ptrLoadContextBinder = default(IntPtr))
         {
             return _nLoad(fileName, codeBase, assemblySecurity, locationHint, ref stackMark,
                 pPrivHostBinder,
-                throwOnFileNotFound, forIntrospection, suppressSecurityChecks, ptrLoadContextBinder);
+                throwOnFileNotFound, forIntrospection, true /* suppressSecurityChecks */, ptrLoadContextBinder);
         }
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         private static extern bool IsReflectionOnly(RuntimeAssembly assembly);
 
-        // To not break compatibility with the V1 _Assembly interface we need to make this
-        // new member ComVisible(false).
-        [ComVisible(false)]
         public override bool ReflectionOnly
         {
             get
@@ -1428,57 +1253,6 @@ namespace System.Reflection
             }
         }
 
-        // Loads the assembly with a COFF based IMAGE containing
-        // an emitted assembly. The assembly is loaded into the domain
-        // of the caller. Currently is implemented only for  UnmanagedMemoryStream
-        // (no derived classes since we are not calling Read())
-        internal static RuntimeAssembly InternalLoadFromStream(Stream assemblyStream, Stream pdbStream, ref StackCrawlMark stackMark)
-        {
-            if (assemblyStream  == null)
-                throw new ArgumentNullException(nameof(assemblyStream));
-
-            if (assemblyStream.GetType()!=typeof(UnmanagedMemoryStream))
-                throw new NotSupportedException();
-
-            if (pdbStream!= null && pdbStream.GetType()!=typeof(UnmanagedMemoryStream))
-                throw new NotSupportedException();
-
-            AppDomain.CheckLoadFromSupported();
-
-            UnmanagedMemoryStream umAssemblyStream = (UnmanagedMemoryStream)assemblyStream;
-            UnmanagedMemoryStream umPdbStream = (UnmanagedMemoryStream)pdbStream;
-            
-            unsafe
-            {
-                byte* umAssemblyStreamBuffer=umAssemblyStream.PositionPointer;
-                byte* umPdbStreamBuffer=(umPdbStream!=null)?umPdbStream.PositionPointer:null; 
-                long assemblyDataLength = umAssemblyStream.Length-umAssemblyStream.Position;
-                long pdbDataLength = (umPdbStream!=null)?(umPdbStream.Length-umPdbStream.Position):0;
-                
-                // use Seek() to benefit from boundary checking, the actual read is done using *StreamBuffer
-                umAssemblyStream.Seek(assemblyDataLength,SeekOrigin.Current);
-                
-                if(umPdbStream != null)
-                {
-                    umPdbStream.Seek(pdbDataLength,SeekOrigin.Current);                  
-                }
-                
-                BCLDebug.Assert(assemblyDataLength > 0L, "assemblyDataLength > 0L");
-    
-                RuntimeAssembly assembly = null;
-
-                nLoadFromUnmanagedArray(false, 
-                                                                 umAssemblyStreamBuffer, 
-                                                                 (ulong)assemblyDataLength, 
-                                                                 umPdbStreamBuffer,
-                                                                 (ulong)pdbDataLength, 
-                                                                 JitHelpers.GetStackCrawlMarkHandle(ref stackMark),
-                                                                 JitHelpers.GetObjectHandleOnStack(ref assembly));
-
-                return assembly;
-            }
-        }
-
         // Returns the module in this assembly with name 'name'
 
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
@@ -1558,7 +1332,7 @@ namespace System.Reflection
                                                           StringHandleOnStack retFileName,
                                                           StackCrawlMarkHandle stackMark);
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public override ManifestResourceInfo GetManifestResourceInfo(String resourceName)
         {
             RuntimeAssembly retAssembly = null;
@@ -1587,9 +1361,6 @@ namespace System.Reflection
 
                 GetLocation(GetNativeHandle(), JitHelpers.GetStringHandleOnStack(ref location));
 
-                if (location != null)
-                    new FileIOPermission( FileIOPermissionAccess.PathDiscovery, location ).Demand();
-
                 return location;
             }
         }
@@ -1598,9 +1369,6 @@ namespace System.Reflection
         [SuppressUnmanagedCodeSecurity]
         private extern static void GetImageRuntimeVersion(RuntimeAssembly assembly, StringHandleOnStack retString);
 
-        // To not break compatibility with the V1 _Assembly interface we need to make this
-        // new member ComVisible(false).
-        [ComVisible(false)]
         public override String ImageRuntimeVersion
         {
             get{
@@ -1610,10 +1378,6 @@ namespace System.Reflection
             }
         }
 
-
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        private extern static bool IsGlobalAssemblyCache(RuntimeAssembly assembly);
-
         public override bool GlobalAssemblyCache
         {
             get
@@ -1622,10 +1386,6 @@ namespace System.Reflection
             }
         }
 
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        private extern static Int64 GetHostContext(RuntimeAssembly assembly);
-
         public override Int64 HostContext
         {
             get
@@ -1707,7 +1467,7 @@ namespace System.Reflection
                 if (length > Int64.MaxValue)
                     throw new NotImplementedException(Environment.GetResourceString("NotImplemented_ResourcesLongerThan2^63"));
 
-                return new UnmanagedMemoryStream(pbInMemoryResource, (long)length, (long)length, FileAccess.Read, true);
+                return new UnmanagedMemoryStream(pbInMemoryResource, (long)length, (long)length, FileAccess.Read);
             }
 
             //Console.WriteLine("GetManifestResourceStream: Blob "+name+" not found...");
@@ -1755,15 +1515,6 @@ namespace System.Reflection
             }
         }
 
-        private void VerifyCodeBaseDiscovery(String codeBase)
-        {
-            if ((codeBase != null) &&
-                (String.Compare( codeBase, 0, s_localFilePrefix, 0, 5, StringComparison.OrdinalIgnoreCase) == 0)) {
-                System.Security.Util.URLString urlString = new System.Security.Util.URLString( codeBase, true );
-                new FileIOPermission( FileIOPermissionAccess.PathDiscovery, urlString.GetFileName() ).Demand();
-            }
-        }
-
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
         [SuppressUnmanagedCodeSecurity]
         private static extern void GetSimpleName(RuntimeAssembly assembly, StringHandleOnStack retSimpleName);
@@ -1795,19 +1546,6 @@ namespace System.Reflection
 
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
         [SuppressUnmanagedCodeSecurity]
-        private static extern void GetRawBytes(RuntimeAssembly assembly, ObjectHandleOnStack retRawBytes);
-
-        // Get the raw bytes of the assembly
-        internal byte[] GetRawBytes()
-        {
-            byte[] rawBytes = null;
-
-            GetRawBytes(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref rawBytes));
-            return rawBytes;
-        }
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
         private static extern void GetPublicKey(RuntimeAssembly assembly, ObjectHandleOnStack retPublicKey);
 
         internal byte[] GetPublicKey()
@@ -1819,50 +1557,6 @@ namespace System.Reflection
 
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
         [SuppressUnmanagedCodeSecurity]
-        private extern static void GetGrantSet(RuntimeAssembly assembly, ObjectHandleOnStack granted, ObjectHandleOnStack denied);
-
-        internal void GetGrantSet(out PermissionSet newGrant, out PermissionSet newDenied)
-        {
-            PermissionSet granted = null, denied = null;
-            GetGrantSet(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref granted), JitHelpers.GetObjectHandleOnStack(ref denied));
-            newGrant = granted; newDenied = denied;
-        }
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        [return: MarshalAs(UnmanagedType.Bool)]
-        private extern static bool IsAllSecurityCritical(RuntimeAssembly assembly);
-
-        // Is everything introduced by this assembly critical
-        internal bool IsAllSecurityCritical()
-        {
-            return IsAllSecurityCritical(GetNativeHandle());
-        }
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        [return: MarshalAs(UnmanagedType.Bool)]
-        private extern static bool IsAllSecuritySafeCritical(RuntimeAssembly assembly);
-
-        // Is everything introduced by this assembly safe critical
-        internal bool IsAllSecuritySafeCritical()
-        {
-            return IsAllSecuritySafeCritical(GetNativeHandle());
-        }
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        [return: MarshalAs(UnmanagedType.Bool)]
-        private extern static bool IsAllPublicAreaSecuritySafeCritical(RuntimeAssembly assembly);
-
-        // Is everything introduced by this assembly safe critical
-        internal bool IsAllPublicAreaSecuritySafeCritical()
-        {
-            return IsAllPublicAreaSecuritySafeCritical(GetNativeHandle());
-        }
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
         [return: MarshalAs(UnmanagedType.Bool)]
         private extern static bool IsAllSecurityTransparent(RuntimeAssembly assembly);
 
@@ -1890,7 +1584,7 @@ namespace System.Reflection
             return null;
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable  
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod  
         public override Assembly GetSatelliteAssembly(CultureInfo culture)
         {
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
@@ -1898,14 +1592,14 @@ namespace System.Reflection
         }
 
         // Useful for binding to a very specific version of a satellite assembly
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable  
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod  
         public override Assembly GetSatelliteAssembly(CultureInfo culture, Version version)
         {
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             return InternalGetSatelliteAssembly(culture, version, ref stackMark);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable  
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod  
         internal Assembly InternalGetSatelliteAssembly(CultureInfo culture,
                                                        Version version,
                                                        ref StackCrawlMark stackMark)
@@ -1919,7 +1613,7 @@ namespace System.Reflection
             return InternalGetSatelliteAssembly(name, culture, version, true, ref stackMark);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable  
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod  
         internal RuntimeAssembly InternalGetSatelliteAssembly(String name,
                                                               CultureInfo culture,
                                                               Version version,
@@ -1942,7 +1636,7 @@ namespace System.Reflection
 
             RuntimeAssembly retAssembly = nLoad(an, null, null, this,  ref stackMark, 
                                 IntPtr.Zero,
-                                throwOnFileNotFound, false, false);
+                                throwOnFileNotFound, false);
 
             if (retAssembly == this || (retAssembly == null && throwOnFileNotFound))
             {
@@ -1952,135 +1646,6 @@ namespace System.Reflection
             return retAssembly;
         }
 
-        // Helper method used by InternalGetSatelliteAssembly only. Not abstracted for use elsewhere.
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable  
-        private RuntimeAssembly InternalProbeForSatelliteAssemblyNextToParentAssembly(AssemblyName an,
-                                                                                      String name,
-                                                                                      String codeBase,
-                                                                                      CultureInfo culture,
-                                                                                      bool throwOnFileNotFound,
-                                                                                      bool useLoadFile,
-                                                                                      ref StackCrawlMark stackMark)
-        {
-            // if useLoadFile == false, we do LoadFrom binds
-
-            RuntimeAssembly retAssembly = null;
-            String location = null;
-
-            if (useLoadFile)
-                location = Location;
-            
-            FileNotFoundException dllNotFoundException = null;
-
-            StringBuilder assemblyFile = new StringBuilder(useLoadFile ? location : codeBase,
-                                                           0,
-                                                           useLoadFile ? location.LastIndexOf('\\') + 1 : codeBase.LastIndexOf('/') + 1,
-                                                           Path.MaxPath);
-            assemblyFile.Append(an.CultureInfo.Name);
-            assemblyFile.Append(useLoadFile ? '\\' : '/');
-            assemblyFile.Append(name);
-            assemblyFile.Append(".DLL");
-
-            string fileNameOrCodeBase = assemblyFile.ToString();
-
-            AssemblyName loadFromAsmName = null;
-
-            if (useLoadFile == false)
-            {
-                loadFromAsmName = new AssemblyName();
-                // set just the codebase - we want this to be a pure LoadFrom
-                loadFromAsmName.CodeBase = fileNameOrCodeBase;
-            }
-
-            try
-            {
-                try
-                {
-                    retAssembly = useLoadFile ? nLoadFile(fileNameOrCodeBase, null) :
-                                                nLoad(loadFromAsmName, fileNameOrCodeBase, null, this, ref stackMark,
-                                                IntPtr.Zero,
-                                                throwOnFileNotFound, false, false);
-                }
-                catch (FileNotFoundException)
-                {
-                    // Create our own exception since the one caught doesn't have a filename associated with it, making it less useful for debugging.
-                    dllNotFoundException = new FileNotFoundException(String.Format(culture,
-                                                                                   Environment.GetResourceString("IO.FileNotFound_FileName"),
-                                                                                   fileNameOrCodeBase),
-                                                                     fileNameOrCodeBase); // Save this exception so we can throw it if we also don't find the .EXE
-                    retAssembly = null;
-                }
-            
-                if (retAssembly == null)
-                {
-                    // LoadFile will always throw, but LoadFrom will only throw if throwOnFileNotFound is true.
-                    // If an exception was thrown, we must have a dllNotFoundException ready for throwing later.
-                    BCLDebug.Assert((useLoadFile == false && throwOnFileNotFound == false) || dllNotFoundException != null,
-                                   "(useLoadFile == false && throwOnFileNotFound == false) || dllNotFoundException != null");
-                
-                    assemblyFile.Remove(assemblyFile.Length - 4, 4);
-                    assemblyFile.Append(".EXE");
-                    fileNameOrCodeBase = assemblyFile.ToString();
-                    
-                    if (useLoadFile == false)
-                        loadFromAsmName.CodeBase = fileNameOrCodeBase;
-
-                    try
-                    {
-                        retAssembly = useLoadFile ? nLoadFile(fileNameOrCodeBase, null) :
-                                                    nLoad(loadFromAsmName, fileNameOrCodeBase,  null, this, ref stackMark,
-                                                          IntPtr.Zero,
-                                                          false /* do not throw on file not found */, false, false);
-                            
-                    }
-                    catch (FileNotFoundException)
-                    {
-                        retAssembly = null;
-                    }
-
-                    // It would be messy to have a FileNotFoundException that reports both .DLL and .EXE not found.
-                    // Using a .DLL extension for satellite assemblies is the more common scenario,
-                    // so just throw that exception.
-                    
-                    // In classic (i.e. non-AppX) mode, if binder logging is turned on, there will be separate  logs for
-                    // the .DLL and .EXE load attempts if the user is interested in digging deeper.
-                    
-                    if (retAssembly == null && throwOnFileNotFound)
-                        throw dllNotFoundException;
-                }
-            }
-            catch (DirectoryNotFoundException)
-            {
-                if (throwOnFileNotFound)
-                    throw;
-                retAssembly = null;
-            }
-            // No other exceptions should be caught here.
-
-            return retAssembly;
-        }
-
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        static internal extern RuntimeAssembly nLoadFile(String path, Evidence evidence);
-
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        static internal extern RuntimeAssembly nLoadImage(byte[] rawAssembly,
-                                                          byte[] rawSymbolStore,
-                                                          Evidence evidence,
-                                                          ref StackCrawlMark stackMark,
-                                                          bool fIntrospection,
-                                                          SecurityContextSource securityContextSource);
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        static internal extern unsafe void nLoadFromUnmanagedArray(bool fIntrospection, 
-                                                                            byte* assemblyContent, 
-                                                                            ulong assemblySize,
-                                                                            byte* pdbContent, 
-                                                                            ulong pdbSize,
-                                                                            StackCrawlMarkHandle stackMark,
-                                                                            ObjectHandleOnStack retAssembly);
-
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
         [SuppressUnmanagedCodeSecurity]
         private extern static void GetModules(RuntimeAssembly assembly, 
diff --git a/src/mscorlib/src/System/Reflection/AssemblyAttributes.cs b/src/mscorlib/src/System/Reflection/AssemblyAttributes.cs
index 4b550b48b4..1e6688d1f4 100644
--- a/src/mscorlib/src/System/Reflection/AssemblyAttributes.cs
+++ b/src/mscorlib/src/System/Reflection/AssemblyAttributes.cs
@@ -20,7 +20,6 @@ namespace System.Reflection {
     using System.Diagnostics.Contracts;
 
     [AttributeUsage (AttributeTargets.Assembly, Inherited=false)]  
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class AssemblyCopyrightAttribute : Attribute 
     {
         private String m_copyright;
@@ -38,7 +37,6 @@ namespace System.Reflection {
 
 
     [AttributeUsage (AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class AssemblyTrademarkAttribute : Attribute 
     {
         private String m_trademark;
@@ -56,7 +54,6 @@ namespace System.Reflection {
 
 
     [AttributeUsage (AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class AssemblyProductAttribute : Attribute 
     {
         private String m_product;
@@ -74,7 +71,6 @@ namespace System.Reflection {
 
 
     [AttributeUsage (AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class AssemblyCompanyAttribute : Attribute 
     {
         private String m_company; 
@@ -92,7 +88,6 @@ namespace System.Reflection {
 
 
     [AttributeUsage (AttributeTargets.Assembly, Inherited=false)]  
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class AssemblyDescriptionAttribute : Attribute 
     {
         private String m_description; 
@@ -110,7 +105,6 @@ namespace System.Reflection {
 
 
     [AttributeUsage (AttributeTargets.Assembly, Inherited=false)]  
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class AssemblyTitleAttribute : Attribute 
     {
         private String m_title;
@@ -128,7 +122,6 @@ namespace System.Reflection {
 
 
     [AttributeUsage (AttributeTargets.Assembly, Inherited=false)]  
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class AssemblyConfigurationAttribute : Attribute 
     {
         private String m_configuration; 
@@ -146,7 +139,6 @@ namespace System.Reflection {
 
 
     [AttributeUsage (AttributeTargets.Assembly, Inherited=false)]  
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class AssemblyDefaultAliasAttribute : Attribute 
     {
         private String m_defaultAlias;
@@ -164,7 +156,6 @@ namespace System.Reflection {
         
 
     [AttributeUsage (AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class AssemblyInformationalVersionAttribute : Attribute 
     {
         private String m_informationalVersion;
@@ -182,7 +173,6 @@ namespace System.Reflection {
     
 
     [AttributeUsage(AttributeTargets.Assembly, Inherited=false)]  
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class AssemblyFileVersionAttribute : Attribute 
     {
         private String _version;
@@ -202,7 +192,6 @@ namespace System.Reflection {
     
 
     [AttributeUsage (AttributeTargets.Assembly, Inherited=false)]  
-[System.Runtime.InteropServices.ComVisible(true)]
     public unsafe sealed class AssemblyCultureAttribute : Attribute 
     {
         private String m_culture; 
@@ -220,7 +209,6 @@ namespace System.Reflection {
 
 
     [AttributeUsage (AttributeTargets.Assembly, Inherited=false)]  
-[System.Runtime.InteropServices.ComVisible(true)]
     public unsafe sealed class AssemblyVersionAttribute : Attribute 
     {
         private String m_version;
@@ -238,7 +226,6 @@ namespace System.Reflection {
 
 
     [AttributeUsage (AttributeTargets.Assembly, Inherited=false)]  
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class AssemblyKeyFileAttribute : Attribute 
     {
         private String m_keyFile;
@@ -256,7 +243,6 @@ namespace System.Reflection {
 
 
     [AttributeUsage (AttributeTargets.Assembly, Inherited=false)]  
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class AssemblyDelaySignAttribute : Attribute 
     {
         private bool m_delaySign; 
@@ -274,7 +260,6 @@ namespace System.Reflection {
 
 
     [AttributeUsage(AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public unsafe sealed class AssemblyAlgorithmIdAttribute : Attribute
     {
         private uint m_algId;
@@ -299,7 +284,6 @@ namespace System.Reflection {
 
 
     [AttributeUsage(AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public unsafe sealed class AssemblyFlagsAttribute : Attribute
     {
         private AssemblyNameFlags m_flags;
@@ -384,7 +368,6 @@ namespace System.Reflection {
     }
 
     [AttributeUsage (AttributeTargets.Assembly, Inherited=false)]  
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class AssemblyKeyNameAttribute : Attribute 
     {
         private String m_keyName; 
diff --git a/src/mscorlib/src/System/Reflection/AssemblyName.cs b/src/mscorlib/src/System/Reflection/AssemblyName.cs
index 48eab33ee5..01be855646 100644
--- a/src/mscorlib/src/System/Reflection/AssemblyName.cs
+++ b/src/mscorlib/src/System/Reflection/AssemblyName.cs
@@ -20,17 +20,13 @@ namespace System.Reflection {
     using System.Runtime.CompilerServices;
     using CultureInfo = System.Globalization.CultureInfo;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     using System.Runtime.InteropServices;
     using System.Runtime.Versioning;
     using System.Diagnostics.Contracts;
     using System.Text;
 
     [Serializable]
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_AssemblyName))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class AssemblyName : _AssemblyName, ICloneable, ISerializable, IDeserializationCallback
+    public sealed class AssemblyName : ICloneable, ISerializable, IDeserializationCallback
     {
         //
         // READ ME
@@ -136,7 +132,6 @@ namespace System.Reflection {
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public AssemblyContentType ContentType
         {
             get
@@ -192,7 +187,6 @@ namespace System.Reflection {
             // Assembly.GetNameInternal() will not demand path discovery 
             //  permission, so do that first.
             string fullPath = Path.GetFullPath(assemblyFile);
-            new FileIOPermission( FileIOPermissionAccess.PathDiscovery, fullPath ).Demand();
             return nGetFileInformation(fullPath);
         }
     
diff --git a/src/mscorlib/src/System/Reflection/AssemblyNameFlags.cs b/src/mscorlib/src/System/Reflection/AssemblyNameFlags.cs
index 35a5370cc6..b86955efa5 100644
--- a/src/mscorlib/src/System/Reflection/AssemblyNameFlags.cs
+++ b/src/mscorlib/src/System/Reflection/AssemblyNameFlags.cs
@@ -19,7 +19,6 @@ namespace System.Reflection {
     using System;
     [Serializable]
     [FlagsAttribute()]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum AssemblyNameFlags
     {
         None                      = 0x0000,
@@ -35,7 +34,6 @@ namespace System.Reflection {
     }
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(false)]
     public enum AssemblyContentType
     {
         Default                 = 0x0000, 
@@ -43,7 +41,6 @@ namespace System.Reflection {
     }
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum ProcessorArchitecture
     {
         None = 0x0000,
diff --git a/src/mscorlib/src/System/Reflection/AssemblyNameProxy.cs b/src/mscorlib/src/System/Reflection/AssemblyNameProxy.cs
deleted file mode 100644
index 8c8fa8d286..0000000000
--- a/src/mscorlib/src/System/Reflection/AssemblyNameProxy.cs
+++ /dev/null
@@ -1,28 +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: Remotable version the AssemblyName
-**
-**
-===========================================================*/
-namespace System.Reflection {
-    using System;
-    using System.Runtime.Versioning;
-
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public class AssemblyNameProxy : MarshalByRefObject 
-    {
-        public AssemblyName GetAssemblyName(String assemblyFile)
-        {
-            return AssemblyName.GetAssemblyName(assemblyFile);
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Reflection/Binder.cs b/src/mscorlib/src/System/Reflection/Binder.cs
index d06899f6c6..bf4545fe81 100644
--- a/src/mscorlib/src/System/Reflection/Binder.cs
+++ b/src/mscorlib/src/System/Reflection/Binder.cs
@@ -16,8 +16,6 @@ namespace System.Reflection {
     using CultureInfo = System.Globalization.CultureInfo;
     
     [Serializable]
-    [ClassInterface(ClassInterfaceType.AutoDual)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public abstract class Binder
     {    
         // Given a set of methods that match the basic criteria, select a method to
diff --git a/src/mscorlib/src/System/Reflection/BindingFlags.cs b/src/mscorlib/src/System/Reflection/BindingFlags.cs
index 591dfbb249..ae0a6d68d3 100644
--- a/src/mscorlib/src/System/Reflection/BindingFlags.cs
+++ b/src/mscorlib/src/System/Reflection/BindingFlags.cs
@@ -17,7 +17,6 @@ namespace System.Reflection {
     using System;
     [Serializable]
     [Flags]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum BindingFlags
     {
 
diff --git a/src/mscorlib/src/System/Reflection/CallingConventions.cs b/src/mscorlib/src/System/Reflection/CallingConventions.cs
index 6ca11c9021..266dd55184 100644
--- a/src/mscorlib/src/System/Reflection/CallingConventions.cs
+++ b/src/mscorlib/src/System/Reflection/CallingConventions.cs
@@ -15,7 +15,6 @@ namespace System.Reflection {
     using System;
     [Serializable]
     [Flags]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum CallingConventions
     {
         //NOTE: If you change this please update COMMember.cpp.  These
diff --git a/src/mscorlib/src/System/Reflection/ComInterfaces.cs b/src/mscorlib/src/System/Reflection/ComInterfaces.cs
deleted file mode 100644
index 6e4b0cc19a..0000000000
--- a/src/mscorlib/src/System/Reflection/ComInterfaces.cs
+++ /dev/null
@@ -1,115 +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.
-
-namespace System.Runtime.InteropServices
-{
-    [GuidAttribute("BCA8B44D-AAD6-3A86-8AB7-03349F4F2DA2")]
-    [CLSCompliant(false)]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [TypeLibImportClassAttribute(typeof(System.Type))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _Type
-    {
-    }
-
-    [GuidAttribute("17156360-2f1a-384a-bc52-fde93c215c5b")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsDual)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.Assembly))]
-    [CLSCompliant(false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _Assembly
-    {
-    }
-
-    [GuidAttribute("f7102fa9-cabb-3a74-a6da-b4567ef1b079")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.MemberInfo))]
-    [CLSCompliant(false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _MemberInfo
-    {
-    }
-
-    [GuidAttribute("6240837A-707F-3181-8E98-A36AE086766B")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.MethodBase))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _MethodBase
-    {
-    }
-
-    [GuidAttribute("FFCC1B5D-ECB8-38DD-9B01-3DC8ABC2AA5F")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.MethodInfo))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _MethodInfo
-    {
-    }
-
-    [GuidAttribute("E9A19478-9646-3679-9B10-8411AE1FD57D")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.ConstructorInfo))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _ConstructorInfo
-    {
-    }
-
-    [GuidAttribute("8A7C1442-A9FB-366B-80D8-4939FFA6DBE0")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.FieldInfo))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _FieldInfo
-    {
-    }
-
-    [GuidAttribute("F59ED4E4-E68F-3218-BD77-061AA82824BF")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.PropertyInfo))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _PropertyInfo
-    {
-    }
-
-    [GuidAttribute("9DE59C64-D889-35A1-B897-587D74469E5B")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.EventInfo))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _EventInfo
-    {
-    }
-
-    [GuidAttribute("993634C4-E47A-32CC-BE08-85F567DC27D6")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.ParameterInfo))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _ParameterInfo
-    {
-    }
-
-    [GuidAttribute("D002E9BA-D9E3-3749-B1D3-D565A08B13E7")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.Module))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _Module
-    {
-    }
-
-    [GuidAttribute("B42B6AAC-317E-34D5-9FA9-093BB4160C50")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.AssemblyName))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _AssemblyName
-    {
-    }
-}
-
diff --git a/src/mscorlib/src/System/Reflection/ConstructorInfo.cs b/src/mscorlib/src/System/Reflection/ConstructorInfo.cs
index 3d927fc85c..c3198ae82d 100644
--- a/src/mscorlib/src/System/Reflection/ConstructorInfo.cs
+++ b/src/mscorlib/src/System/Reflection/ConstructorInfo.cs
@@ -16,23 +16,17 @@ namespace System.Reflection
     using System.Runtime.InteropServices;
     using System.Runtime.Serialization;
     using System.Security;
-    using System.Security.Permissions;
     using System.Threading;
     using MemberListType = System.RuntimeType.MemberListType;
     using RuntimeTypeCache = System.RuntimeType.RuntimeTypeCache;
     using System.Runtime.CompilerServices;
 
     [Serializable]
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_ConstructorInfo))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public abstract class ConstructorInfo : MethodBase, _ConstructorInfo
+    public abstract class ConstructorInfo : MethodBase
     {
         #region Static Members
-        [System.Runtime.InteropServices.ComVisible(true)]
         public readonly static String ConstructorName = ".ctor";
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public readonly static String TypeConstructorName = ".cctor";
         #endregion
 
@@ -73,7 +67,6 @@ namespace System.Reflection
         #endregion
 
         #region MemberInfo Overrides
-        [System.Runtime.InteropServices.ComVisible(true)]
         public override MemberTypes MemberType { get { return System.Reflection.MemberTypes.Constructor; } }
         #endregion
     
@@ -136,14 +129,6 @@ namespace System.Reflection
 
             return false;
         }
-
-        internal override bool IsDynamicallyInvokable
-        {
-            get
-            {
-                return !AppDomain.ProfileAPICheck || !IsNonW8PFrameworkAPI();
-            }
-        }
 #endif // FEATURE_APPX
 
         internal INVOCATION_FLAGS InvocationFlags
@@ -226,7 +211,6 @@ namespace System.Reflection
             }
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal override bool CacheEquals(object o)
         {
             RuntimeConstructorInfo m = o as RuntimeConstructorInfo;
@@ -271,20 +255,6 @@ namespace System.Reflection
         }
 
         internal BindingFlags BindingFlags { get { return m_bindingFlags; } }
-
-        // Differs from MethodHandle in that it will return a valid handle even for reflection only loaded types
-        internal RuntimeMethodHandle GetMethodHandle()
-        {
-            return new RuntimeMethodHandle(this);
-        }
-
-        internal bool IsOverloaded
-        { 
-            get 
-            { 
-                return m_reflectedTypeCache.GetConstructorList(MemberListType.CaseSensitive, Name).Length > 1;
-            }
-        }
         #endregion
 
         #region Object Overrides
@@ -344,7 +314,6 @@ namespace System.Reflection
         {
             get { return RuntimeMethodHandle.GetName(this); }
         }
-[System.Runtime.InteropServices.ComVisible(true)]
         public override MemberTypes MemberType { get { return MemberTypes.Constructor; } }
         
         public override Type DeclaringType 
@@ -488,7 +457,7 @@ namespace System.Reflection
 
         [DebuggerStepThroughAttribute]
         [Diagnostics.DebuggerHidden]
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public override Object Invoke(
             Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
         {
@@ -537,11 +506,7 @@ namespace System.Reflection
             }
             return RuntimeMethodHandle.InvokeMethod(obj, null, sig, false);
         }
-        
 
-#pragma warning disable 618
-        [ReflectionPermissionAttribute(SecurityAction.Demand, Flags = ReflectionPermissionFlag.MemberAccess)]
-#pragma warning restore 618
         public override MethodBody GetMethodBody()
         {
             MethodBody mb = RuntimeMethodHandle.GetMethodBody(this, ReflectedTypeInternal);
@@ -577,7 +542,7 @@ namespace System.Reflection
         #region ConstructorInfo Overrides
         [DebuggerStepThroughAttribute]
         [Diagnostics.DebuggerHidden]
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public override Object Invoke(BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
         {
             INVOCATION_FLAGS invocationFlags = InvocationFlags;
@@ -644,11 +609,6 @@ namespace System.Reflection
             // We don't need the return type for constructors.
             return FormatNameAndSig(true);
         }
-
-        internal void SerializationInvoke(Object target, SerializationInfo info, StreamingContext context)
-        {
-            RuntimeMethodHandle.SerializationInvoke(this, target, info, ref context);
-        }
        #endregion
     }
 }
diff --git a/src/mscorlib/src/System/Reflection/CustomAttribute.cs b/src/mscorlib/src/System/Reflection/CustomAttribute.cs
index e568a1702f..b71c7bbff3 100644
--- a/src/mscorlib/src/System/Reflection/CustomAttribute.cs
+++ b/src/mscorlib/src/System/Reflection/CustomAttribute.cs
@@ -14,7 +14,6 @@ using System.Diagnostics;
 using System.Diagnostics.Tracing;
 using System.Globalization;
 using System.Security;
-using System.Security.Permissions;
 using System.Runtime.ConstrainedExecution;
 using System.Runtime.Versioning;
 using System.Diagnostics.Contracts;
@@ -22,7 +21,6 @@ using System.Diagnostics.Contracts;
 namespace System.Reflection 
 {
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class CustomAttributeData
     {
         #region Public Static Members
@@ -515,10 +513,8 @@ namespace System.Reflection
         #region Public Members
         public Type AttributeType { get { return Constructor.DeclaringType; } }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public virtual ConstructorInfo Constructor { get { return m_ctor; } }
         
-        [System.Runtime.InteropServices.ComVisible(true)]
         public virtual IList<CustomAttributeTypedArgument> ConstructorArguments
         {
             get
@@ -576,7 +572,6 @@ namespace System.Reflection
     }
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public struct CustomAttributeNamedArgument
     {
         #region Public Static Members
@@ -666,7 +661,6 @@ namespace System.Reflection
     }
 
     [Serializable]
-    [ComVisible(true)]
     public struct CustomAttributeTypedArgument
     {
         #region Public Static Members
@@ -1106,24 +1100,6 @@ namespace System.Reflection
         #endregion
     }
 
-    // Note: This is a managed representation of a frame type defined in vm\frames.h; please ensure the layout remains
-    // synchronized.
-    [StructLayout(LayoutKind.Sequential)]
-    internal struct SecurityContextFrame
-    {
-        IntPtr m_GSCookie;      // This is actually at a negative offset in the real frame definition
-        IntPtr __VFN_table;     // This is the real start of the SecurityContextFrame
-        IntPtr m_Next;
-        IntPtr m_Assembly;
-
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        public extern void Push(RuntimeAssembly assembly);
-
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
-        public extern void Pop();
-    }
-
     [Serializable]
     [StructLayout(LayoutKind.Auto)]
     internal struct CustomAttributeType
@@ -1153,7 +1129,6 @@ namespace System.Reflection
         public CustomAttributeEncoding EncodedType { get { return m_encodedType; } }
         public CustomAttributeEncoding EncodedEnumType { get { return m_encodedEnumType; } }
         public CustomAttributeEncoding EncodedArrayType { get { return m_encodedArrayType; } }
-        [System.Runtime.InteropServices.ComVisible(true)]
         public string EnumName { get { return m_enumName; } }
         #endregion
     }
@@ -1621,16 +1596,6 @@ namespace System.Reflection
             object[] attributes = CreateAttributeArrayHelper(arrayType, car.Length);
             int cAttributes = 0;
 
-            // Custom attribute security checks are done with respect to the assembly *decorated* with the 
-            // custom attribute as opposed to the *caller of GetCustomAttributes*.
-            // Since this assembly might not be on the stack and the attribute ctor or property setters we're about to invoke may
-            // make security demands, we push a frame on the stack as a proxy for the decorated assembly (this frame will be picked
-            // up an interpreted by the security stackwalker).
-            // Once we push the frame it will be automatically popped in the event of an exception, so no need to use CERs or the
-            // like.
-            SecurityContextFrame frame = new SecurityContextFrame();
-            frame.Push(decoratedModule.GetRuntimeAssembly());
-
             // Optimization for the case where attributes decorate entities in the same assembly in which case 
             // we can cache the successful APTCA check between the decorated and the declared assembly.
             Assembly lastAptcaOkAssembly = null;
@@ -1780,10 +1745,6 @@ namespace System.Reflection
                 attributes[cAttributes++] = attribute;
             }
 
-            // The frame will be popped automatically if we take an exception any time after we pushed it. So no need of a catch or
-            // finally or CERs here.
-            frame.Pop();
-
             if (cAttributes == car.Length && pcaCount == 0)
                 return attributes;
 
@@ -2069,9 +2030,8 @@ namespace System.Reflection
 #region Internal Static
         internal static bool IsSecurityAttribute(RuntimeType type)
         {
-#pragma warning disable 618
-            return type == (RuntimeType)typeof(SecurityAttribute) || type.IsSubclassOf(typeof(SecurityAttribute));
-#pragma warning restore 618
+            // TODO: Cleanup
+            return false;
         }
 
         internal static Attribute[] GetCustomAttributes(RuntimeType type, RuntimeType caType, bool includeSecCa, out int count)
diff --git a/src/mscorlib/src/System/Reflection/CustomAttributeFormatException.cs b/src/mscorlib/src/System/Reflection/CustomAttributeFormatException.cs
index 3eb8b1f1ef..9aee911a6c 100644
--- a/src/mscorlib/src/System/Reflection/CustomAttributeFormatException.cs
+++ b/src/mscorlib/src/System/Reflection/CustomAttributeFormatException.cs
@@ -15,7 +15,6 @@ namespace System.Reflection {
     using ApplicationException = System.ApplicationException;
     using System.Runtime.Serialization;
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class CustomAttributeFormatException  : FormatException {
     
         public CustomAttributeFormatException()
diff --git a/src/mscorlib/src/System/Reflection/DefaultMemberAttribute.cs b/src/mscorlib/src/System/Reflection/DefaultMemberAttribute.cs
index 1fec75906a..4232fcd2a1 100644
--- a/src/mscorlib/src/System/Reflection/DefaultMemberAttribute.cs
+++ b/src/mscorlib/src/System/Reflection/DefaultMemberAttribute.cs
@@ -19,7 +19,6 @@ namespace System.Reflection {
 
 [Serializable]
     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class DefaultMemberAttribute : Attribute
     {
         // The name of the member
diff --git a/src/mscorlib/src/System/Reflection/Emit/AssemblyBuilder.cs b/src/mscorlib/src/System/Reflection/Emit/AssemblyBuilder.cs
index 95200157b4..3deef219de 100644
--- a/src/mscorlib/src/System/Reflection/Emit/AssemblyBuilder.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/AssemblyBuilder.cs
@@ -38,7 +38,6 @@ namespace System.Reflection.Emit
     using System.Runtime.Serialization;
     using System.Runtime.Versioning;
     using System.Security;
-    using System.Security.Permissions;
     using System.Security.Policy;
     using System.Threading;
 
@@ -156,10 +155,7 @@ namespace System.Reflection.Emit
 
     // AssemblyBuilder class.
     // deliberately not [serializable]
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_AssemblyBuilder))]
-    [ComVisible(true)]
-    public sealed class AssemblyBuilder : Assembly, _AssemblyBuilder
+    public sealed class AssemblyBuilder : Assembly
     {
         #region FCALL
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
@@ -221,11 +217,6 @@ namespace System.Reflection.Emit
             return InternalAssembly.GetNativeHandle();
         }
 
-        internal Version GetVersion()
-        {
-            return InternalAssembly.GetVersion();
-        }
-
 #if FEATURE_APPX
         internal bool ProfileAPICheck
         {
@@ -243,9 +234,6 @@ namespace System.Reflection.Emit
                                  AssemblyBuilderAccess access,
                                  String dir,
                                  Evidence evidence,
-                                 PermissionSet requiredPermissions,
-                                 PermissionSet optionalPermissions,
-                                 PermissionSet refusedPermissions,
                                  ref StackCrawlMark stackMark,
                                  IEnumerable<CustomAttributeBuilder> unsafeAssemblyAttributes,
                                  SecurityContextSource securityContextSource)
@@ -272,18 +260,6 @@ namespace System.Reflection.Emit
             // Clone the name in case the caller modifies it underneath us.
             name = (AssemblyName)name.Clone();
 
-            // If the caller is trusted they can supply identity
-            // evidence for the new assembly. Otherwise we copy the
-            // current grant and deny sets from the caller's assembly,
-            // inject them into the new assembly and mark policy as
-            // resolved. If/when the assembly is persisted and
-            // reloaded, the normal rules for gathering evidence will
-            // be used.
-            if (evidence != null)
-#pragma warning disable 618
-                new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Demand();
-#pragma warning restore 618
-
             // Scan the assembly level attributes for any attributes which modify how we create the
             // assembly. Currently, we look for any attribute which modifies the security transparency
             // of the assembly.
@@ -318,9 +294,6 @@ namespace System.Reflection.Emit
                                                                                         name,
                                                                                         evidence,
                                                                                         ref stackMark,
-                                                                                        requiredPermissions,
-                                                                                        optionalPermissions,
-                                                                                        refusedPermissions,
                                                                                         securityRulesBlob,
                                                                                         aptcaBlob,
                                                                                         access,
@@ -331,10 +304,6 @@ namespace System.Reflection.Emit
                                                      name.Name,
                                                      access,
                                                      dir);
-            m_assemblyData.AddPermissionRequests(requiredPermissions,
-                                                 optionalPermissions,
-                                                 refusedPermissions);
-
 #if FEATURE_APPX
             if (AppDomain.ProfileAPICheck)
             {
@@ -382,7 +351,7 @@ namespace System.Reflection.Emit
         * to have a strong name and a hash will be computed when the assembly
         * is saved.
         **********************************************/
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static AssemblyBuilder DefineDynamicAssembly(
             AssemblyName name,
             AssemblyBuilderAccess access)
@@ -391,10 +360,10 @@ namespace System.Reflection.Emit
 
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             return InternalDefineDynamicAssembly(name, access, null,
-                                                 null, null, null, null, ref stackMark, null, SecurityContextSource.CurrentAssembly);
+                                                 null, ref stackMark, null, SecurityContextSource.CurrentAssembly);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static AssemblyBuilder DefineDynamicAssembly(
             AssemblyName name,
             AssemblyBuilderAccess access,
@@ -405,7 +374,7 @@ namespace System.Reflection.Emit
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             return InternalDefineDynamicAssembly(name,
                                                  access,
-                                                 null, null, null, null, null,
+                                                 null, null,
                                                  ref stackMark,
                                                  assemblyAttributes, SecurityContextSource.CurrentAssembly);
         }
@@ -416,9 +385,6 @@ namespace System.Reflection.Emit
                                                               AssemblyName name,
                                                               Evidence identity,
                                                               ref StackCrawlMark stackMark,
-                                                              PermissionSet requiredPermissions,
-                                                              PermissionSet optionalPermissions,
-                                                              PermissionSet refusedPermissions,
                                                               byte[] securityRulesBlob,
                                                               byte[] aptcaBlob,
                                                               AssemblyBuilderAccess access,
@@ -432,9 +398,6 @@ namespace System.Reflection.Emit
             AssemblyBuilderAccess access,
             String dir,
             Evidence evidence,
-            PermissionSet requiredPermissions,
-            PermissionSet optionalPermissions,
-            PermissionSet refusedPermissions,
             ref StackCrawlMark stackMark,
             IEnumerable<CustomAttributeBuilder> unsafeAssemblyAttributes,
             SecurityContextSource securityContextSource)
@@ -447,9 +410,6 @@ namespace System.Reflection.Emit
                                            access,
                                            dir,
                                            evidence,
-                                           requiredPermissions,
-                                           optionalPermissions,
-                                           refusedPermissions,
                                            ref stackMark,
                                            unsafeAssemblyAttributes,
                                            securityContextSource);
@@ -465,7 +425,7 @@ namespace System.Reflection.Emit
         * a transient module.
         * 
         **********************************************/
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public ModuleBuilder DefineDynamicModule(
             String      name)
         {
@@ -475,7 +435,7 @@ namespace System.Reflection.Emit
             return DefineDynamicModuleInternal(name, false, ref stackMark);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public ModuleBuilder DefineDynamicModule(
             String      name,
             bool        emitSymbolInfo)         // specify if emit symbol info or not
@@ -530,12 +490,6 @@ namespace System.Reflection.Emit
             if (emitSymbolInfo)
             {
                 writer = SymWrapperCore.SymWriter.CreateSymWriter();
-                // Set the underlying writer for the managed writer
-                // that we're using.  Note that this function requires
-                // unmanaged code access.
-#pragma warning disable 618
-                new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Assert();
-#pragma warning restore 618
 
                 String fileName = "Unused"; // this symfile is never written to disk so filename does not matter.
                 
@@ -557,19 +511,8 @@ namespace System.Reflection.Emit
 
             return dynModule;
         } // DefineDynamicModuleInternalNoLock
-        #endregion
-
-        private Assembly LoadISymWrapper()
-        {
-            if (m_assemblyData.m_ISymWrapperAssembly != null)
-                return m_assemblyData.m_ISymWrapperAssembly;
 
-            Assembly assem = Assembly.Load("ISymWrapper, Version=" + ThisAssembly.Version +
-                ", Culture=neutral, PublicKeyToken=" + AssemblyRef.MicrosoftPublicKeyToken);
-
-            m_assemblyData.m_ISymWrapperAssembly = assem;
-            return assem;
-        }
+#endregion
 
         internal void CheckContext(params Type[][] typess)
         {
@@ -778,7 +721,7 @@ namespace System.Reflection.Emit
             return InternalAssembly.GetLoadedModules(getResourceModules);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public override Assembly GetSatelliteAssembly(CultureInfo culture)
         {
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
@@ -786,7 +729,7 @@ namespace System.Reflection.Emit
         }
 
         // Useful for binding to a very specific version of a satellite assembly
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public override Assembly GetSatelliteAssembly(CultureInfo culture, Version version)
         {
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
@@ -837,52 +780,11 @@ namespace System.Reflection.Emit
             }
             return null;
         }
-    
-        /**********************************************
-        *
-        * Setting the entry point if the assembly builder is building
-        * an exe.
-        *
-        **********************************************/
-        public void SetEntryPoint(
-            MethodInfo  entryMethod) 
-        {
-            SetEntryPoint(entryMethod, PEFileKinds.ConsoleApplication);
-        }
-        public void SetEntryPoint(
-            MethodInfo  entryMethod,        // entry method for the assembly. We use this to determine the entry module
-            PEFileKinds fileKind)           // file kind for the assembly.
-        {
-            lock(SyncRoot)
-            {
-                SetEntryPointNoLock(entryMethod, fileKind);
-            }
-        }
-
-        private void SetEntryPointNoLock(
-            MethodInfo  entryMethod,        // entry method for the assembly. We use this to determine the entry module
-            PEFileKinds fileKind)           // file kind for the assembly.
-        {
-
-            if (entryMethod == null)
-                throw new ArgumentNullException(nameof(entryMethod));
-            Contract.EndContractBlock();
-
-            BCLDebug.Log("DYNIL", "## DYNIL LOGGING: AssemblyBuilder.SetEntryPoint");
-
-            Module tmpModule = entryMethod.Module;
-            if (tmpModule == null || !InternalAssembly.Equals(tmpModule.Assembly))
-                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EntryMethodNotDefinedInAssembly"));
-
-            m_assemblyData.m_entryPointMethod = entryMethod;
-            m_assemblyData.m_peFileKind = fileKind;
-        }
 
 
         /**********************************************
         * Use this function if client decides to form the custom attribute blob themselves
         **********************************************/
-        [System.Runtime.InteropServices.ComVisible(true)]
         public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
         {
             if (con == null)
@@ -945,78 +847,6 @@ namespace System.Reflection.Emit
             }
         }
 
-
-        /**********************************************
-        *
-        * Saves the assembly to disk. Also saves all dynamic modules defined
-        * in this dynamic assembly. Assembly file name can be the same as one of 
-        * the module's name. If so, assembly info is stored within that module.
-        * Assembly file name can be different from all of the modules underneath. In
-        * this case, assembly is stored stand alone. 
-        *
-        **********************************************/
-
-        public void Save(String assemblyFileName)       // assembly file name
-        {
-            Save(assemblyFileName, System.Reflection.PortableExecutableKinds.ILOnly, System.Reflection.ImageFileMachine.I386);
-        }
-            
-        public void Save(String assemblyFileName, 
-            PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
-        {
-            lock(SyncRoot)
-            {
-                SaveNoLock(assemblyFileName, portableExecutableKind, imageFileMachine);
-            }
-        }
-
-        private void SaveNoLock(String assemblyFileName, 
-            PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
-        {
-            // AssemblyBuilderAccess.Save can never be set in CoreCLR
-            throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CantSaveTransientAssembly"));
-        }
-
-        internal bool IsPersistable()
-        {
-            {
-                return false;
-            }
-        }
-    
-        /**********************************************
-        *
-        * Internal helper to walk the nested type hierachy
-        *
-        **********************************************/
-        private int DefineNestedComType(Type type, int tkResolutionScope, int tkTypeDef)
-        {
-            Type        enclosingType = type.DeclaringType;
-            if (enclosingType == null)
-            {
-                // Use full type name for non-nested types.
-                return AddExportedTypeOnDisk(GetNativeHandle(), type.FullName, tkResolutionScope, tkTypeDef, type.Attributes);
-            }
-
-            tkResolutionScope = DefineNestedComType(enclosingType, tkResolutionScope, tkTypeDef);
-            // Use simple name for nested types.
-            return AddExportedTypeOnDisk(GetNativeHandle(), type.Name, tkResolutionScope, tkTypeDef, type.Attributes);
-        }
-
-        internal int DefineExportedTypeInMemory(Type type, int tkResolutionScope, int tkTypeDef)
-        {
-            Type enclosingType = type.DeclaringType;
-            if (enclosingType == null)
-            {
-                // Use full type name for non-nested types.
-                return AddExportedTypeInMemory(GetNativeHandle(), type.FullName, tkResolutionScope, tkTypeDef, type.Attributes);
-            }
-
-            tkResolutionScope = DefineExportedTypeInMemory(enclosingType, tkResolutionScope, tkTypeDef);
-            // Use simple name for nested types.
-            return AddExportedTypeInMemory(GetNativeHandle(), type.Name, tkResolutionScope, tkTypeDef, type.Attributes);
-        }
-
         /**********************************************
          * 
          * Private methods
@@ -1028,105 +858,5 @@ namespace System.Reflection.Emit
          * @internonly
          **********************************************/
         private AssemblyBuilder() {}
-
-        // Create a new module in which to emit code. This module will not contain the manifest.
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        static private extern void DefineDynamicModule(RuntimeAssembly containingAssembly,
-                                                       bool emitSymbolInfo,
-                                                       String name,
-                                                       String filename,
-                                                       StackCrawlMarkHandle stackMark,
-                                                       ref IntPtr pInternalSymWriter,
-                                                       ObjectHandleOnStack retModule,
-                                                       bool fIsTransient,
-                                                       out int tkFile);
-
-        private static Module DefineDynamicModule(RuntimeAssembly containingAssembly, 
-                                           bool emitSymbolInfo,
-                                           String name,
-                                           String filename,
-                                           ref StackCrawlMark stackMark,
-                                           ref IntPtr pInternalSymWriter,
-                                           bool fIsTransient,
-                                           out int tkFile)
-        {
-            RuntimeModule retModule = null;
-
-            DefineDynamicModule(containingAssembly.GetNativeHandle(),
-                                emitSymbolInfo,
-                                name,
-                                filename,
-                                JitHelpers.GetStackCrawlMarkHandle(ref stackMark),
-                                ref pInternalSymWriter,
-                                JitHelpers.GetObjectHandleOnStack(ref retModule),
-                                fIsTransient,
-                                out tkFile);
-
-            return retModule;
-        }
-
-        // The following functions are native helpers for creating on-disk manifest
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        static private extern void PrepareForSavingManifestToDisk(RuntimeAssembly assembly, RuntimeModule assemblyModule);  // module to contain assembly information if assembly is embedded
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        static private extern void SaveManifestToDisk(RuntimeAssembly assembly,
-                                                String strFileName, 
-                                                int entryPoint,
-                                                int fileKind,
-                                                int portableExecutableKind, 
-                                                int ImageFileMachine);
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        static private extern int AddFile(RuntimeAssembly assembly, String strFileName);
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        static private extern void SetFileHashValue(RuntimeAssembly assembly,
-                                                    int tkFile, 
-                                                    String strFullFileName);
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        static private extern int AddExportedTypeInMemory(RuntimeAssembly assembly,
-                                                          String strComTypeName,
-                                                          int tkAssemblyRef,
-                                                          int tkTypeDef,
-                                                          TypeAttributes flags);
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        static private extern int AddExportedTypeOnDisk(RuntimeAssembly assembly, 
-                                                        String strComTypeName, 
-                                                        int tkAssemblyRef, 
-                                                        int tkTypeDef, 
-                                                        TypeAttributes flags);
-
-        // Add an entry to assembly's manifestResource table for a stand alone resource.
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        static private extern void AddStandAloneResource(RuntimeAssembly assembly,
-                                                         String strName,
-                                                         String strFileName,
-                                                         String strFullFileName,
-                                                         int attribute);
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-#pragma warning disable 618
-        static private extern void AddDeclarativeSecurity(RuntimeAssembly assembly, SecurityAction action, byte[] blob, int length);
-#pragma warning restore 618
-
-        // Functions for defining unmanaged resources.
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        static private extern void CreateVersionInfoResource(String filename, String title, String iconFilename, String description,
-                                                             String copyright, String trademark, String company, String product,
-                                                             String productVersion, String fileVersion, int lcid, bool isDll,
-                                                             StringHandleOnStack retFileName);
     }
 }
diff --git a/src/mscorlib/src/System/Reflection/Emit/AssemblyBuilderAccess.cs b/src/mscorlib/src/System/Reflection/Emit/AssemblyBuilderAccess.cs
index 398f3d9c8a..b3d1711307 100644
--- a/src/mscorlib/src/System/Reflection/Emit/AssemblyBuilderAccess.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/AssemblyBuilderAccess.cs
@@ -10,7 +10,6 @@ using System;
 namespace System.Reflection.Emit 
 {
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Flags]
     public enum AssemblyBuilderAccess
     {
diff --git a/src/mscorlib/src/System/Reflection/Emit/AssemblyBuilderData.cs b/src/mscorlib/src/System/Reflection/Emit/AssemblyBuilderData.cs
index f0f83e7d2a..7ac9daeac0 100644
--- a/src/mscorlib/src/System/Reflection/Emit/AssemblyBuilderData.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/AssemblyBuilderData.cs
@@ -14,7 +14,6 @@ namespace System.Reflection.Emit {
     using System.Security;
     using System.Diagnostics;
     using CultureInfo = System.Globalization.CultureInfo;
-    using IResourceWriter = System.Resources.IResourceWriter;
     using System.IO;
     using System.Runtime.Versioning;
     using System.Diagnostics.SymbolStore;
@@ -52,12 +51,6 @@ namespace System.Reflection.Emit {
         {
             m_moduleBuilderList.Add(dynModule);
         }
-    
-        // Helper to add a resource information into the tracking list
-        internal void AddResWriter(ResWriterData resData)
-        {
-            m_resWriterList.Add(resData);
-        }
 
 
         // Helper to track CAs to persist onto disk
@@ -110,194 +103,6 @@ namespace System.Reflection.Emit {
             m_CACons[m_iCAs] = con;
             m_iCAs++;
         }
-
-        // Helper to calculate unmanaged version info from Assembly's custom attributes.
-        // If DefineUnmanagedVersionInfo is called, the parameter provided will override
-        // the CA's value.
-        //                      
-        internal void FillUnmanagedVersionInfo()
-        {
-            // Get the lcid set on the assembly name as default if available
-            // Note that if LCID is not avaible from neither AssemblyName or AssemblyCultureAttribute,
-            // it is default to -1 which is treated as language neutral. 
-            //
-            CultureInfo locale = m_assembly.GetLocale();
-#if FEATURE_USE_LCID            
-            if (locale != null)
-                m_nativeVersion.m_lcid = locale.LCID;
-#endif            
-                                                    
-            for (int i = 0; i < m_iCABuilder; i++)
-            {
-                // check for known attributes
-                Type conType = m_CABuilders[i].m_con.DeclaringType;
-                if (m_CABuilders[i].m_constructorArgs.Length == 0 || m_CABuilders[i].m_constructorArgs[0] == null)
-                    continue;
-
-                if (conType.Equals(typeof(System.Reflection.AssemblyCopyrightAttribute)))
-                {
-                        // assert that we should only have one argument for this CA and the type should
-                        // be a string.
-                        // 
-                    if (m_CABuilders[i].m_constructorArgs.Length != 1)
-                    {
-                        throw new ArgumentException(Environment.GetResourceString(
-                            "Argument_BadCAForUnmngRSC",
-                            m_CABuilders[i].m_con.ReflectedType.Name));
-                    }
-                    if (m_OverrideUnmanagedVersionInfo == false)
-                    {
-                        m_nativeVersion.m_strCopyright = m_CABuilders[i].m_constructorArgs[0].ToString();
-                    }
-                }
-                else if (conType.Equals(typeof(System.Reflection.AssemblyTrademarkAttribute))) 
-                {
-                        // assert that we should only have one argument for this CA and the type should
-                        // be a string.
-                        // 
-                    if (m_CABuilders[i].m_constructorArgs.Length != 1)
-                    {
-                        throw new ArgumentException(Environment.GetResourceString(
-                            "Argument_BadCAForUnmngRSC",
-                            m_CABuilders[i].m_con.ReflectedType.Name));
-                    }
-                    if (m_OverrideUnmanagedVersionInfo == false)
-                    {
-                        m_nativeVersion.m_strTrademark = m_CABuilders[i].m_constructorArgs[0].ToString();
-                    }
-                }
-                else if (conType.Equals(typeof(System.Reflection.AssemblyProductAttribute))) 
-                {
-                    if (m_OverrideUnmanagedVersionInfo == false)
-                    {
-                        // assert that we should only have one argument for this CA and the type should
-                        // be a string.
-                        // 
-                        m_nativeVersion.m_strProduct = m_CABuilders[i].m_constructorArgs[0].ToString();
-                    }
-                }
-                else if (conType.Equals(typeof(System.Reflection.AssemblyCompanyAttribute))) 
-                {
-                    if (m_CABuilders[i].m_constructorArgs.Length != 1)
-                    {
-                        throw new ArgumentException(Environment.GetResourceString(
-                            "Argument_BadCAForUnmngRSC",
-                            m_CABuilders[i].m_con.ReflectedType.Name));
-                    }
-                    if (m_OverrideUnmanagedVersionInfo == false)
-                    {
-                        // assert that we should only have one argument for this CA and the type should
-                        // be a string.
-                        // 
-                        m_nativeVersion.m_strCompany = m_CABuilders[i].m_constructorArgs[0].ToString();
-                    }
-                }
-                else if (conType.Equals(typeof(System.Reflection.AssemblyDescriptionAttribute))) 
-                {
-                    if (m_CABuilders[i].m_constructorArgs.Length != 1)
-                    {
-                        throw new ArgumentException(Environment.GetResourceString(
-                            "Argument_BadCAForUnmngRSC",
-                            m_CABuilders[i].m_con.ReflectedType.Name));
-                    }
-                    m_nativeVersion.m_strDescription = m_CABuilders[i].m_constructorArgs[0].ToString();
-                }
-                else if (conType.Equals(typeof(System.Reflection.AssemblyTitleAttribute))) 
-                {
-                    if (m_CABuilders[i].m_constructorArgs.Length != 1)
-                    {
-                        throw new ArgumentException(Environment.GetResourceString(
-                            "Argument_BadCAForUnmngRSC",
-                            m_CABuilders[i].m_con.ReflectedType.Name));
-                    }
-                    m_nativeVersion.m_strTitle = m_CABuilders[i].m_constructorArgs[0].ToString();
-                }
-                else if (conType.Equals(typeof(System.Reflection.AssemblyInformationalVersionAttribute))) 
-                {
-                    if (m_CABuilders[i].m_constructorArgs.Length != 1)
-                    {
-                        throw new ArgumentException(Environment.GetResourceString(
-                            "Argument_BadCAForUnmngRSC",
-                            m_CABuilders[i].m_con.ReflectedType.Name));
-                    }
-                    if (m_OverrideUnmanagedVersionInfo == false)
-                    {
-                        m_nativeVersion.m_strProductVersion = m_CABuilders[i].m_constructorArgs[0].ToString();
-                    }
-                }
-                else if (conType.Equals(typeof(System.Reflection.AssemblyCultureAttribute))) 
-                {
-                    // retrieve the LCID
-                    if (m_CABuilders[i].m_constructorArgs.Length != 1)
-                    {
-                        throw new ArgumentException(Environment.GetResourceString(
-                            "Argument_BadCAForUnmngRSC",
-                            m_CABuilders[i].m_con.ReflectedType.Name));
-                    }
-                    // CultureInfo attribute overrides the lcid from AssemblyName.                                      
-                    CultureInfo culture = new CultureInfo(m_CABuilders[i].m_constructorArgs[0].ToString());
-#if FEATURE_USE_LCID
-                    m_nativeVersion.m_lcid = culture.LCID;
-#endif
-                }
-                else if (conType.Equals(typeof(System.Reflection.AssemblyFileVersionAttribute))) 
-                {
-                    if (m_CABuilders[i].m_constructorArgs.Length != 1)
-                    {
-                        throw new ArgumentException(Environment.GetResourceString(
-                            "Argument_BadCAForUnmngRSC",
-                            m_CABuilders[i].m_con.ReflectedType.Name));
-                    }
-                    if (m_OverrideUnmanagedVersionInfo == false)
-                    {
-                        m_nativeVersion.m_strFileVersion = m_CABuilders[i].m_constructorArgs[0].ToString();
-                    }
-                }
-            }
-        }
-
-        
-        // Helper to ensure the resource name is unique underneath assemblyBuilder
-        internal void CheckResNameConflict(String strNewResName)
-        {
-            int         size = m_resWriterList.Count;
-            int         i;
-            for (i = 0; i < size; i++) 
-            {
-                ResWriterData resWriter = m_resWriterList[i];
-                if (resWriter.m_strName.Equals(strNewResName))
-                {
-                    // Cannot have two resources with the same name
-                    throw new ArgumentException(Environment.GetResourceString("Argument_DuplicateResourceName"));
-                }
-            }        
-        }
-
-    
-        // Helper to ensure the module name is unique underneath assemblyBuilder
-        internal void CheckNameConflict(String strNewModuleName)
-        {
-            int         size = m_moduleBuilderList.Count;
-            int         i;
-            for (i = 0; i < size; i++) 
-            {
-                ModuleBuilder moduleBuilder = m_moduleBuilderList[i];
-                if (moduleBuilder.m_moduleData.m_strModuleName.Equals(strNewModuleName))
-                {
-                    // Cannot have two dynamic modules with the same name
-                    throw new ArgumentException(Environment.GetResourceString("Argument_DuplicateModuleName"));
-                }
-            }
-
-            // Right now dynamic modules can only be added to dynamic assemblies in which
-            // all modules are dynamic. Otherwise we would also need to check the static modules 
-            // with this:
-            //  if (m_assembly.GetModule(strNewModuleName) != null)
-            //  {
-            //      // Cannot have two dynamic modules with the same name
-            //      throw new ArgumentException(Environment.GetResourceString("Argument_DuplicateModuleName"));
-            //  }
-        }
     
         // Helper to ensure the type name is unique underneath assemblyBuilder
         internal void CheckTypeNameConflict(String strTypeName, TypeBuilder enclosingType)
@@ -320,134 +125,6 @@ namespace System.Reflection.Emit {
             //      }
         }
         
-
-        // Helper to ensure the file name is unique underneath assemblyBuilder. This includes 
-        // modules and resources.
-        //  
-        //  
-        //  
-        internal void CheckFileNameConflict(String strFileName)
-        {
-            int         size = m_moduleBuilderList.Count;
-            int         i;
-            for (i = 0; i < size; i++) 
-            {
-                ModuleBuilder moduleBuilder = m_moduleBuilderList[i];
-                if (moduleBuilder.m_moduleData.m_strFileName != null)
-                {
-                    if (String.Compare(moduleBuilder.m_moduleData.m_strFileName, strFileName, StringComparison.OrdinalIgnoreCase) == 0)
-                    {
-                        // Cannot have two dynamic module with the same name
-                        throw new ArgumentException(Environment.GetResourceString("Argument_DuplicatedFileName"));
-                    }
-                }
-            }    
-            size = m_resWriterList.Count;
-            for (i = 0; i < size; i++) 
-            {
-                ResWriterData resWriter = m_resWriterList[i];
-                if (resWriter.m_strFileName != null)
-                {
-                    if (String.Compare(resWriter.m_strFileName, strFileName, StringComparison.OrdinalIgnoreCase) == 0)
-                    {
-                        // Cannot have two dynamic module with the same name
-                        throw new ArgumentException(Environment.GetResourceString("Argument_DuplicatedFileName"));
-                    }
-                }
-            }    
-
-        }
-    
-        // Helper to look up which module that assembly is supposed to be stored at
-        //  
-        // 
-        //  
-        internal ModuleBuilder FindModuleWithFileName(String strFileName)
-        {
-            int         size = m_moduleBuilderList.Count;
-            int         i;
-            for (i = 0; i < size; i++) 
-            {
-                ModuleBuilder moduleBuilder = m_moduleBuilderList[i];
-                if (moduleBuilder.m_moduleData.m_strFileName != null)
-                {
-                    if (String.Compare(moduleBuilder.m_moduleData.m_strFileName, strFileName, StringComparison.OrdinalIgnoreCase) == 0)
-                    {
-                        return moduleBuilder;
-                    }
-                }
-            } 
-            return null;       
-        }
-
-        // Helper to look up module by name.
-        //  
-        // 
-        //  
-        internal ModuleBuilder FindModuleWithName(String strName)
-        {
-            int         size = m_moduleBuilderList.Count;
-            int         i;
-            for (i = 0; i < size; i++) 
-            {
-                ModuleBuilder moduleBuilder = m_moduleBuilderList[i];
-                if (moduleBuilder.m_moduleData.m_strModuleName != null)
-                {
-                    if (String.Compare(moduleBuilder.m_moduleData.m_strModuleName, strName, StringComparison.OrdinalIgnoreCase) == 0)
-                        return moduleBuilder;
-                }
-            } 
-            return null;       
-        }
-
-        
-        // add type to public COMType tracking list
-        internal void AddPublicComType(Type type)
-        {
-            BCLDebug.Log("DYNIL","## DYNIL LOGGING: AssemblyBuilderData.AddPublicComType( " + type.FullName + " )"); 
-            if (m_isSaved == true)
-            {
-                // assembly has been saved before!
-                throw new InvalidOperationException(Environment.GetResourceString(
-                    "InvalidOperation_CannotAlterAssembly"));
-            }        
-            EnsurePublicComTypeCapacity();
-            m_publicComTypeList[m_iPublicComTypeCount] = type;
-            m_iPublicComTypeCount++;
-        }
-        
-        // add security permission requests
-        internal void AddPermissionRequests(
-            PermissionSet       required,
-            PermissionSet       optional,
-            PermissionSet       refused)
-        {
-            BCLDebug.Log("DYNIL","## DYNIL LOGGING: AssemblyBuilderData.AddPermissionRequests");
-            if (m_isSaved == true)
-            {
-                // assembly has been saved before!
-                throw new InvalidOperationException(Environment.GetResourceString(
-                    "InvalidOperation_CannotAlterAssembly"));
-            }        
-            m_RequiredPset = required;
-            m_OptionalPset = optional;
-            m_RefusedPset = refused;
-        }
-        
-        private void EnsurePublicComTypeCapacity()
-        {
-            if (m_publicComTypeList == null)
-            {
-                m_publicComTypeList = new Type[m_iInitialSize];
-            }
-            if (m_iPublicComTypeCount == m_publicComTypeList.Length)
-            {
-                Type[]  tempTypeList = new Type[m_iPublicComTypeCount * 2];
-                Array.Copy(m_publicComTypeList, 0, tempTypeList, 0, m_iPublicComTypeCount);
-                m_publicComTypeList = tempTypeList;            
-            }
-        }
-         
         internal List<ModuleBuilder>    m_moduleBuilderList;
         internal List<ResWriterData>    m_resWriterList;
         internal String                 m_strAssemblyName;
@@ -463,11 +140,6 @@ namespace System.Reflection.Emit {
 
         // hard coding the assembly def token
         internal const int              m_tkAssembly = 0x20000001;
-
-        // Security permission requests
-        internal PermissionSet          m_RequiredPset;
-        internal PermissionSet          m_OptionalPset;
-        internal PermissionSet          m_RefusedPset;
         
         // tracking AssemblyDef's CAs for persistence to disk
         internal CustomAttributeBuilder[] m_CABuilders;
@@ -497,24 +169,6 @@ namespace System.Reflection.Emit {
     **********************************************/
     internal class ResWriterData 
     {
-        internal ResWriterData(
-            IResourceWriter  resWriter,
-            Stream          memoryStream,
-            String          strName,
-            String          strFileName,
-            String          strFullFileName,
-            ResourceAttributes attribute)
-        {
-            m_resWriter = resWriter;
-            m_memoryStream = memoryStream;
-            m_strName = strName;
-            m_strFileName = strFileName;
-            m_strFullFileName = strFullFileName;
-            m_nextResWriter = null;
-            m_attribute = attribute;
-        }
-
-        internal IResourceWriter        m_resWriter;
         internal String                 m_strName;
         internal String                 m_strFileName;
         internal String                 m_strFullFileName;
diff --git a/src/mscorlib/src/System/Reflection/Emit/ComInterfaces.cs b/src/mscorlib/src/System/Reflection/Emit/ComInterfaces.cs
deleted file mode 100644
index daa0e2341f..0000000000
--- a/src/mscorlib/src/System/Reflection/Emit/ComInterfaces.cs
+++ /dev/null
@@ -1,133 +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.
-
-namespace System.Runtime.InteropServices
-{
-    [GuidAttribute("BEBB2505-8B54-3443-AEAD-142A16DD9CC7")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.Emit.AssemblyBuilder))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _AssemblyBuilder
-    {
-    }
-
-    [GuidAttribute("ED3E4384-D7E2-3FA7-8FFD-8940D330519A")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.Emit.ConstructorBuilder))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _ConstructorBuilder
-    {
-    }
-
-    [GuidAttribute("BE9ACCE8-AAFF-3B91-81AE-8211663F5CAD")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.Emit.CustomAttributeBuilder))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _CustomAttributeBuilder
-    {
-    }
-
-    [GuidAttribute("C7BD73DE-9F85-3290-88EE-090B8BDFE2DF")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.Emit.EnumBuilder))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _EnumBuilder
-    {
-    }
-
-    [GuidAttribute("AADABA99-895D-3D65-9760-B1F12621FAE8")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.Emit.EventBuilder))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _EventBuilder
-    {
-    }
-
-    [GuidAttribute("CE1A3BF5-975E-30CC-97C9-1EF70F8F3993")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.Emit.FieldBuilder))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _FieldBuilder
-    {
-    }
-
-    [GuidAttribute("A4924B27-6E3B-37F7-9B83-A4501955E6A7")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.Emit.ILGenerator))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _ILGenerator
-    {
-    }
-
-    [GuidAttribute("4E6350D1-A08B-3DEC-9A3E-C465F9AEEC0C")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.Emit.LocalBuilder))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _LocalBuilder
-    {
-    }
-
-    [GuidAttribute("007D8A14-FDF3-363E-9A0B-FEC0618260A2")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.Emit.MethodBuilder))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _MethodBuilder
-    {
-    }
-
-
-    [GuidAttribute("D05FFA9A-04AF-3519-8EE1-8D93AD73430B")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.Emit.ModuleBuilder))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _ModuleBuilder
-    {
-    }
-
-    [GuidAttribute("36329EBA-F97A-3565-BC07-0ED5C6EF19FC")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.Emit.ParameterBuilder))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _ParameterBuilder
-    {
-    }
-
-    [GuidAttribute("15F9A479-9397-3A63-ACBD-F51977FB0F02")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.Emit.PropertyBuilder))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _PropertyBuilder
-    {
-    }
-
-    [GuidAttribute("7D13DD37-5A04-393C-BBCA-A5FEA802893D")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.Emit.SignatureHelper))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _SignatureHelper
-    {
-    }
-
-    [GuidAttribute("7E5678EE-48B3-3F83-B076-C58543498A58")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Reflection.Emit.TypeBuilder))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _TypeBuilder
-    {
-    }
-}
diff --git a/src/mscorlib/src/System/Reflection/Emit/ConstructorBuilder.cs b/src/mscorlib/src/System/Reflection/Emit/ConstructorBuilder.cs
index ef76adcf80..3bc02860a1 100644
--- a/src/mscorlib/src/System/Reflection/Emit/ConstructorBuilder.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/ConstructorBuilder.cs
@@ -12,14 +12,10 @@ namespace System.Reflection.Emit
     using System.Collections.Generic;
     using System.Diagnostics.SymbolStore;
     using System.Security;
-    using System.Security.Permissions;
     using System.Runtime.InteropServices;
     using System.Diagnostics.Contracts;
     
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_ConstructorBuilder))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class ConstructorBuilder : ConstructorInfo, _ConstructorBuilder
+    public sealed class ConstructorBuilder : ConstructorInfo
     { 
         private readonly MethodBuilder m_methodBuilder;
         internal bool m_isDefaultConstructor;
@@ -65,11 +61,6 @@ namespace System.Reflection.Emit
         {
             return m_methodBuilder.GetTypeBuilder();
         }
-
-        internal ModuleBuilder GetModuleBuilder()
-        {
-            return GetTypeBuilder().GetModuleBuilder();
-        }
         #endregion
 
         #region Object Overrides
@@ -181,11 +172,6 @@ namespace System.Reflection.Emit
             return m_methodBuilder.DefineParameter(iSequence, attributes, strParamName);
         }
     
-        public void SetSymCustomAttribute(String name, byte[] data)
-        {
-            m_methodBuilder.SetSymCustomAttribute(name, data);
-        }
-    
         public ILGenerator GetILGenerator() 
         {
             if (m_isDefaultConstructor)
@@ -202,16 +188,6 @@ namespace System.Reflection.Emit
             return m_methodBuilder.GetILGenerator(streamSize);
         }
 
-        public void SetMethodBody(byte[] il, int maxStack, byte[] localSignature, IEnumerable<ExceptionHandler> exceptionHandlers, IEnumerable<int> tokenFixups)
-        {
-            if (m_isDefaultConstructor)
-            {
-                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_DefaultConstructorDefineBody"));
-            }
-
-            m_methodBuilder.SetMethodBody(il, maxStack, localSignature, exceptionHandlers, tokenFixups);
-        }
-
         public override CallingConventions CallingConvention 
         { 
             get 
@@ -227,13 +203,6 @@ namespace System.Reflection.Emit
         {
             return m_methodBuilder.GetModule();
         }
-    
-    
-        [Obsolete("This property has been deprecated. http://go.microsoft.com/fwlink/?linkid=14202")] //It always returns null.
-        public Type ReturnType
-        {
-            get { return GetReturnType(); }
-        }
         
         // This always returns null. Is that what we want?
         internal override Type GetReturnType() 
@@ -246,7 +215,6 @@ namespace System.Reflection.Emit
             get { return m_methodBuilder.Signature; }
         }
     
-        [System.Runtime.InteropServices.ComVisible(true)]
         public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
         {
             m_methodBuilder.SetCustomAttribute(con, binaryAttribute);
diff --git a/src/mscorlib/src/System/Reflection/Emit/CustomAttributeBuilder.cs b/src/mscorlib/src/System/Reflection/Emit/CustomAttributeBuilder.cs
index 545657a053..5d08ca08f0 100644
--- a/src/mscorlib/src/System/Reflection/Emit/CustomAttributeBuilder.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/CustomAttributeBuilder.cs
@@ -19,16 +19,12 @@ namespace System.Reflection.Emit {
     using System.Reflection;
     using System.IO;
     using System.Text;
-    using System.Security.Permissions;
     using System.Runtime.InteropServices;
     using System.Globalization;
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
     
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_CustomAttributeBuilder))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public class CustomAttributeBuilder : _CustomAttributeBuilder
+    public class CustomAttributeBuilder
     {
         // public constructor to form the custom attribute with constructor and constructor
         // parameters.
@@ -556,18 +552,6 @@ namespace System.Reflection.Emit {
         }
 
         //*************************************************
-        // Upon saving to disk, we need to create the memberRef token for the custom attribute's type
-        // first of all. So when we snap the in-memory module for on disk, this token will be there.
-        // We also need to enforce the use of MemberRef. Because MemberDef token might move. 
-        // This function has to be called before we snap the in-memory module for on disk (i.e. Presave on
-        // ModuleBuilder.
-        //*************************************************
-        internal int PrepareCreateCustomAttributeToDisk(ModuleBuilder mod)
-        {
-            return mod.InternalGetConstructorToken(m_con, true).Token;
-        }
-
-        //*************************************************
         // Call this function with toDisk=1, after on disk module has been snapped.
         //*************************************************
         internal void CreateCustomAttribute(ModuleBuilder mod, int tkOwner, int tkAttrib, bool toDisk)
diff --git a/src/mscorlib/src/System/Reflection/Emit/DynamicILGenerator.cs b/src/mscorlib/src/System/Reflection/Emit/DynamicILGenerator.cs
index 84994ae1e3..cb2667a104 100644
--- a/src/mscorlib/src/System/Reflection/Emit/DynamicILGenerator.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/DynamicILGenerator.cs
@@ -14,7 +14,6 @@ namespace System.Reflection.Emit
     using System.Reflection;
     using System.Collections;
     using System.Collections.Generic;
-    using System.Security.Permissions;
     using System.Threading;
     using System.Diagnostics;
     using System.Diagnostics.CodeAnalysis;
@@ -142,7 +141,6 @@ namespace System.Reflection.Emit
             PutInteger4(token);
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public override void Emit(OpCode opcode, ConstructorInfo con)
         {
             if (con == null)
@@ -267,43 +265,6 @@ namespace System.Reflection.Emit
             PutInteger4(token);
         }
 
-        public override void EmitCalli(OpCode opcode,
-                                       CallingConvention unmanagedCallConv,
-                                       Type returnType,
-                                       Type[] parameterTypes)
-        {
-            int stackchange = 0;
-            int cParams = 0;
-            int i;
-            SignatureHelper sig;
-
-            if (parameterTypes != null)
-                cParams = parameterTypes.Length;
-
-            sig = SignatureHelper.GetMethodSigHelper(unmanagedCallConv, returnType);
-
-            if (parameterTypes != null)
-                for (i = 0; i < cParams; i++)
-                    sig.AddArgument(parameterTypes[i]);
-
-            // If there is a non-void return type, push one.
-            if (returnType != typeof(void))
-                stackchange++;
-
-            // Pop off arguments if any.
-            if (parameterTypes != null)
-                stackchange -= cParams;
-
-            // Pop the native function pointer.
-            stackchange--;
-            UpdateStackSize(OpCodes.Calli, stackchange);
-
-            EnsureCapacity(7);
-            Emit(OpCodes.Calli);
-            int token = GetTokenForSig(sig.GetSignature(true));
-            PutInteger4(token);
-        }
-
         public override void EmitCall(OpCode opcode, MethodInfo methodInfo, Type[] optionalParameterTypes)
         {
             if (methodInfo == null)
@@ -379,19 +340,20 @@ namespace System.Reflection.Emit
         // Exception related generation
         //
         //
-        public override Label BeginExceptionBlock()
+        public override void BeginExceptFilterBlock()
         {
-            return base.BeginExceptionBlock();
-        }
+            // Begins an exception filter block. Emits a branch instruction to the end of the current exception block.
 
-        public override void EndExceptionBlock()
-        {
-            base.EndExceptionBlock();
-        }
+            if (CurrExcStackCount == 0)
+                throw new NotSupportedException(Environment.GetResourceString("Argument_NotInExceptionBlock"));
 
-        public override void BeginExceptFilterBlock()
-        {
-            throw new NotSupportedException(Environment.GetResourceString("InvalidOperation_NotAllowedInDynamicMethod"));
+            __ExceptionInfo current = CurrExcStack[CurrExcStackCount - 1];
+
+            Label endLabel = current.GetEndLabel();
+            Emit(OpCodes.Leave, endLabel);
+            UpdateStackSize(OpCodes.Nop, 1);
+
+            current.MarkFilterAddr(ILOffset);
         }
 
         public override void BeginCatchBlock(Type exceptionType)
@@ -412,6 +374,8 @@ namespace System.Reflection.Emit
                 }
 
                 this.Emit(OpCodes.Endfilter);
+
+                current.MarkCatchAddr(ILOffset, null);
             }
             else
             {
@@ -427,24 +391,14 @@ namespace System.Reflection.Emit
 
                 // if this is a catch block the exception will be pushed on the stack and we need to update the stack info
                 UpdateStackSize(OpCodes.Nop, 1);
-            }
-
-            current.MarkCatchAddr(ILOffset, exceptionType);
 
+                current.MarkCatchAddr(ILOffset, exceptionType);
 
-            // this is relying on too much implementation details of the base and so it's highly breaking
-            // Need to have a more integreted story for exceptions
-            current.m_filterAddr[current.m_currentCatch - 1] = GetTokenFor(rtType);
-        }
 
-        public override void BeginFaultBlock()
-        {
-            throw new NotSupportedException(Environment.GetResourceString("InvalidOperation_NotAllowedInDynamicMethod"));
-        }
-
-        public override void BeginFinallyBlock()
-        {
-            base.BeginFinallyBlock();
+                // this is relying on too much implementation details of the base and so it's highly breaking
+                // Need to have a more integrated story for exceptions
+                current.m_filterAddr[current.m_currentCatch - 1] = GetTokenFor(rtType);
+            }
         }
 
         //
@@ -970,8 +924,7 @@ namespace System.Reflection.Emit
     }
 
 
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public class DynamicILInfo
+    internal class DynamicILInfo
     {
         #region Private Data Members
         private DynamicMethod m_method;
@@ -983,18 +936,6 @@ namespace System.Reflection.Emit
         private int m_methodSignature;
         #endregion
 
-        #region Constructor
-        internal DynamicILInfo(DynamicScope scope, DynamicMethod method, byte[] methodSignature)
-        {
-            m_method = method;
-            m_scope = scope;
-            m_methodSignature = m_scope.GetTokenFor(methodSignature);
-            m_exceptions = EmptyArray<Byte>.Value;
-            m_code = EmptyArray<Byte>.Value;
-            m_localSignature = EmptyArray<Byte>.Value;
-        }
-        #endregion
-
         #region Internal Methods
         internal void GetCallableMethod(RuntimeModule module, DynamicMethod dm)
         {
@@ -1021,113 +962,8 @@ namespace System.Reflection.Emit
         public DynamicMethod DynamicMethod { get { return m_method; } }
         internal DynamicScope DynamicScope { get { return m_scope; } }
 
-        public void SetCode(byte[] code, int maxStackSize)
-        {
-            m_code = (code != null) ? (byte[])code.Clone() : EmptyArray<Byte>.Value;
-            m_maxStackSize = maxStackSize;
-        }
-
-        [CLSCompliant(false)]
-        public unsafe void SetCode(byte* code, int codeSize, int maxStackSize)
-        {
-            if (codeSize < 0)
-                throw new ArgumentOutOfRangeException(nameof(codeSize), Environment.GetResourceString("ArgumentOutOfRange_GenericPositive"));
-
-            if (codeSize > 0 && code == null)
-                throw new ArgumentNullException(nameof(code));
-            Contract.EndContractBlock();
-
-            m_code = new byte[codeSize];
-            for (int i = 0; i < codeSize; i++)
-            {
-                m_code[i] = *code;
-                code++;
-            }
-
-            m_maxStackSize = maxStackSize;
-        }
-
-        public void SetExceptions(byte[] exceptions)
-        {
-            m_exceptions = (exceptions != null) ? (byte[])exceptions.Clone() : EmptyArray<Byte>.Value;
-        }
-
-        [CLSCompliant(false)]
-        public unsafe void SetExceptions(byte* exceptions, int exceptionsSize)
-        {
-            if (exceptionsSize < 0)
-                throw new ArgumentOutOfRangeException(nameof(exceptionsSize), Environment.GetResourceString("ArgumentOutOfRange_GenericPositive"));
-
-            if (exceptionsSize > 0 && exceptions == null)
-                throw new ArgumentNullException(nameof(exceptions));
-            Contract.EndContractBlock();
-
-            m_exceptions = new byte[exceptionsSize];
-
-            for (int i = 0; i < exceptionsSize; i++)
-            {
-                m_exceptions[i] = *exceptions;
-                exceptions++;
-            }
-        }
-
-        public void SetLocalSignature(byte[] localSignature)
-        {
-            m_localSignature = (localSignature != null) ? (byte[])localSignature.Clone() : EmptyArray<Byte>.Value;
-        }
-
-        [CLSCompliant(false)]
-        public unsafe void SetLocalSignature(byte* localSignature, int signatureSize)
-        {
-            if (signatureSize < 0)
-                throw new ArgumentOutOfRangeException(nameof(signatureSize), Environment.GetResourceString("ArgumentOutOfRange_GenericPositive"));
-
-            if (signatureSize > 0 && localSignature == null)
-                throw new ArgumentNullException(nameof(localSignature));
-            Contract.EndContractBlock();
-
-            m_localSignature = new byte[signatureSize];
-            for (int i = 0; i < signatureSize; i++)
-            {
-                m_localSignature[i] = *localSignature;
-                localSignature++;
-            }
-        }
-        #endregion
-
-        #region Public Scope Methods
-        public int GetTokenFor(RuntimeMethodHandle method)
-        {
-            return DynamicScope.GetTokenFor(method);
-        }
-        public int GetTokenFor(DynamicMethod method)
-        {
-            return DynamicScope.GetTokenFor(method);
-        }
-        public int GetTokenFor(RuntimeMethodHandle method, RuntimeTypeHandle contextType)
-        {
-            return DynamicScope.GetTokenFor(method, contextType);
-        }
-        public int GetTokenFor(RuntimeFieldHandle field)
-        {
-            return DynamicScope.GetTokenFor(field);
-        }
-        public int GetTokenFor(RuntimeFieldHandle field, RuntimeTypeHandle contextType)
-        {
-            return DynamicScope.GetTokenFor(field, contextType);
-        }
-        public int GetTokenFor(RuntimeTypeHandle type)
-        {
-            return DynamicScope.GetTokenFor(type);
-        }
-        public int GetTokenFor(string literal)
-        {
-            return DynamicScope.GetTokenFor(literal);
-        }
-        public int GetTokenFor(byte[] signature)
-        {
-            return DynamicScope.GetTokenFor(signature);
-        }
+#endregion
+#region Public Scope Methods
         #endregion
     }
 
diff --git a/src/mscorlib/src/System/Reflection/Emit/DynamicMethod.cs b/src/mscorlib/src/System/Reflection/Emit/DynamicMethod.cs
index 7af6ff3df0..b7f76b90aa 100644
--- a/src/mscorlib/src/System/Reflection/Emit/DynamicMethod.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/DynamicMethod.cs
@@ -11,7 +11,6 @@ namespace System.Reflection.Emit
     using CultureInfo = System.Globalization.CultureInfo;
     using System.Reflection;
     using System.Security;
-    using System.Security.Permissions;
     using System.Threading;
     using System.Runtime.CompilerServices;
     using System.Runtime.Versioning;
@@ -19,7 +18,6 @@ namespace System.Reflection.Emit
     using System.Diagnostics.Contracts;
     using System.Runtime.InteropServices;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class DynamicMethod : MethodInfo
     {
         private RuntimeType[] m_parameterTypes;
@@ -67,7 +65,7 @@ namespace System.Reflection.Emit
 
         private DynamicMethod() { }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public DynamicMethod(string name,
                              Type returnType,
                              Type[] parameterTypes)
@@ -86,7 +84,7 @@ namespace System.Reflection.Emit
                 ref stackMark);  // transparentMethod
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public DynamicMethod(string name,
                              Type returnType,
                              Type[] parameterTypes,
@@ -106,7 +104,7 @@ namespace System.Reflection.Emit
                 ref stackMark);  // transparentMethod
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public DynamicMethod(string name, 
                              Type returnType, 
                              Type[] parameterTypes, 
@@ -125,7 +123,7 @@ namespace System.Reflection.Emit
                 ref stackMark);  // transparentMethod
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public DynamicMethod(string name, 
                              Type returnType, 
                              Type[] parameterTypes, 
@@ -145,7 +143,7 @@ namespace System.Reflection.Emit
                 ref stackMark); // transparentMethod
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public DynamicMethod(string name, 
                              MethodAttributes attributes, 
                              CallingConventions callingConvention, 
@@ -167,7 +165,7 @@ namespace System.Reflection.Emit
                 ref stackMark); // transparentMethod
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public DynamicMethod(string name, 
                              Type returnType, 
                              Type[] parameterTypes, 
@@ -186,7 +184,7 @@ namespace System.Reflection.Emit
                 ref stackMark); // transparentMethod
         }
         
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public DynamicMethod(string name, 
                              Type returnType, 
                              Type[] parameterTypes, 
@@ -206,7 +204,7 @@ namespace System.Reflection.Emit
                 ref stackMark); // transparentMethod
         }
         
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public DynamicMethod(string name, 
                              MethodAttributes attributes, 
                              CallingConventions callingConvention, 
@@ -249,7 +247,7 @@ namespace System.Reflection.Emit
 
         // We create a transparent assembly to host DynamicMethods. Since the assembly does not have any
         // non-public fields (or any fields at all), it is a safe anonymous assembly to host DynamicMethods
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         private static RuntimeModule GetDynamicMethodsModule()
         {
             if (s_anonymouslyHostedDynamicMethodsModule != null)
@@ -271,7 +269,7 @@ namespace System.Reflection.Emit
                 AssemblyBuilder assembly = AssemblyBuilder.InternalDefineDynamicAssembly(
                     assemblyName,
                     AssemblyBuilderAccess.Run,
-                    null, null, null, null, null,
+                    null, null,
                     ref stackMark,
                     assemblyAttributes,
                     SecurityContextSource.CurrentAssembly);
@@ -395,7 +393,6 @@ namespace System.Reflection.Emit
         // Delegate and method creation
         //
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public sealed override Delegate CreateDelegate(Type delegateType) {
             if (m_restrictedSkipVisibility)
             {
@@ -410,7 +407,6 @@ namespace System.Reflection.Emit
             return d;
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public sealed override Delegate CreateDelegate(Type delegateType, Object target) {
             if (m_restrictedSkipVisibility)
             {
@@ -588,30 +584,6 @@ namespace System.Reflection.Emit
             return null;
         }
 
-        public DynamicILInfo GetDynamicILInfo()
-        {
-#pragma warning disable 618
-            new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
-#pragma warning restore 618
-
-            if (m_DynamicILInfo != null)
-                return m_DynamicILInfo;
-
-            return GetDynamicILInfo(new DynamicScope());
-        }
-
-        internal DynamicILInfo GetDynamicILInfo(DynamicScope scope)
-        {
-            if (m_DynamicILInfo == null)
-            {
-                byte[] methodSignature = SignatureHelper.GetMethodSigHelper(
-                        null, CallingConvention, ReturnType, null, null, m_parameterTypes, null, null).GetSignature(true);
-                m_DynamicILInfo = new DynamicILInfo(scope, this, methodSignature);
-            }
-
-            return m_DynamicILInfo;
-        }
-
         public ILGenerator GetILGenerator() {
             return GetILGenerator(64);
         }
diff --git a/src/mscorlib/src/System/Reflection/Emit/EnumBuilder.cs b/src/mscorlib/src/System/Reflection/Emit/EnumBuilder.cs
index 82dc2828ca..96564d537b 100644
--- a/src/mscorlib/src/System/Reflection/Emit/EnumBuilder.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/EnumBuilder.cs
@@ -20,13 +20,8 @@ namespace System.Reflection.Emit {
     using System.Reflection;
     using System.Runtime.InteropServices;
     using CultureInfo = System.Globalization.CultureInfo;
-    using System.Security.Permissions;
 
-    
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_EnumBuilder))]
-[System.Runtime.InteropServices.ComVisible(true)]
-    sealed public class EnumBuilder : TypeInfo, _EnumBuilder
+    sealed public class EnumBuilder : TypeInfo
     {
         public override bool IsAssignableFrom(System.Reflection.TypeInfo typeInfo){
             if(typeInfo==null) return false;
@@ -137,7 +132,6 @@ namespace System.Reflection.Emit {
                             types, modifiers);
         }
         
-[System.Runtime.InteropServices.ComVisible(true)]
         public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
         {
             return m_typeBuilder.GetConstructors(bindingAttr);
@@ -218,7 +212,6 @@ namespace System.Reflection.Emit {
             return m_typeBuilder.GetMembers(bindingAttr);
         }
 
-[System.Runtime.InteropServices.ComVisible(true)]
         public override InterfaceMapping GetInterfaceMap(Type interfaceType)
         {
             return m_typeBuilder.GetInterfaceMap(interfaceType);
@@ -312,7 +305,6 @@ namespace System.Reflection.Emit {
 
        // Use this function if client decides to form the custom attribute blob themselves
 
-[System.Runtime.InteropServices.ComVisible(true)]
         public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
         {
              m_typeBuilder.SetCustomAttribute(con, binaryAttribute);
@@ -341,9 +333,6 @@ namespace System.Reflection.Emit {
         {
             return m_typeBuilder.IsDefined(attributeType, inherit);
         }
-
-
-        internal int MetadataTokenInternal { get { return m_typeBuilder.MetadataTokenInternal; } }
     
         /*****************************************************
          * 
diff --git a/src/mscorlib/src/System/Reflection/Emit/EventBuilder.cs b/src/mscorlib/src/System/Reflection/Emit/EventBuilder.cs
index 449b20824c..34c76b93d1 100644
--- a/src/mscorlib/src/System/Reflection/Emit/EventBuilder.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/EventBuilder.cs
@@ -16,7 +16,6 @@ namespace System.Reflection.Emit {
     
     using System;
     using System.Reflection;
-    using System.Security.Permissions;
     using System.Runtime.InteropServices;
     using System.Diagnostics.Contracts;
     
@@ -24,10 +23,7 @@ namespace System.Reflection.Emit {
     // A EventBuilder is always associated with a TypeBuilder.  The TypeBuilder.DefineEvent
     // method will return a new EventBuilder to a client.
     // 
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_EventBuilder))]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class EventBuilder : _EventBuilder
+    public sealed class EventBuilder
     { 
     
         // Make a private constructor so these cannot be constructed externally.
@@ -95,7 +91,6 @@ namespace System.Reflection.Emit {
     
         // Use this function if client decides to form the custom attribute blob themselves
 
-[System.Runtime.InteropServices.ComVisible(true)]
         public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
         {
             if (con == null)
diff --git a/src/mscorlib/src/System/Reflection/Emit/EventToken.cs b/src/mscorlib/src/System/Reflection/Emit/EventToken.cs
index 0642cec822..8ffdce9732 100644
--- a/src/mscorlib/src/System/Reflection/Emit/EventToken.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/EventToken.cs
@@ -16,9 +16,7 @@ namespace System.Reflection.Emit {
     
     using System;
     using System.Reflection;
-    using System.Security.Permissions;
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public struct EventToken
     {
         public static readonly EventToken Empty = new EventToken();
diff --git a/src/mscorlib/src/System/Reflection/Emit/FieldBuilder.cs b/src/mscorlib/src/System/Reflection/Emit/FieldBuilder.cs
index 595d60ada0..5953b67173 100644
--- a/src/mscorlib/src/System/Reflection/Emit/FieldBuilder.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/FieldBuilder.cs
@@ -10,13 +10,9 @@ namespace System.Reflection.Emit
     using System;
     using CultureInfo = System.Globalization.CultureInfo;
     using System.Reflection;
-    using System.Security.Permissions;
     using System.Diagnostics.Contracts;
     
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_FieldBuilder))]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class FieldBuilder : FieldInfo, _FieldBuilder
+    public sealed class FieldBuilder : FieldInfo
     {
         #region Private Data Members
         private int m_fieldTok;
@@ -71,8 +67,6 @@ namespace System.Reflection.Emit
         {
             ModuleBuilder.SetFieldRVAContent(m_typeBuilder.GetModuleBuilder().GetNativeHandle(), m_tkField.Token, data, size);
         }
-
-        internal TypeBuilder GetTypeBuilder() { return m_typeBuilder; }
         #endregion
 
         #region MemberInfo Overrides
@@ -185,20 +179,6 @@ namespace System.Reflection.Emit
             TypeBuilder.SetFieldLayoutOffset(m_typeBuilder.GetModuleBuilder().GetNativeHandle(), GetToken().Token, iOffset);
         }
 
-        [Obsolete("An alternate API is available: Emit the MarshalAs custom attribute instead. http://go.microsoft.com/fwlink/?linkid=14202")]
-        public void SetMarshal(UnmanagedMarshal unmanagedMarshal)
-        {
-            if (unmanagedMarshal == null)
-                throw new ArgumentNullException(nameof(unmanagedMarshal));
-            Contract.EndContractBlock();
-
-            m_typeBuilder.ThrowIfCreated();
-
-            byte[] ubMarshal = unmanagedMarshal.InternalGetBytes();
-
-            TypeBuilder.SetFieldMarshal(m_typeBuilder.GetModuleBuilder().GetNativeHandle(), GetToken().Token, ubMarshal, ubMarshal.Length);
-        }
-
         public void SetConstant(Object defaultValue) 
         {
             m_typeBuilder.ThrowIfCreated();  
@@ -207,7 +187,6 @@ namespace System.Reflection.Emit
         }
         
 
-[System.Runtime.InteropServices.ComVisible(true)]
         public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
         {
             if (con == null)
diff --git a/src/mscorlib/src/System/Reflection/Emit/FieldToken.cs b/src/mscorlib/src/System/Reflection/Emit/FieldToken.cs
index 42fd684e7c..add428f96e 100644
--- a/src/mscorlib/src/System/Reflection/Emit/FieldToken.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/FieldToken.cs
@@ -16,14 +16,12 @@ namespace System.Reflection.Emit {
     
     using System;
     using System.Reflection;
-    using System.Security.Permissions;
 
     // The FieldToken class is an opaque representation of the Token returned
     // by the Metadata to represent the field.  FieldTokens are generated by 
     // Module.GetFieldToken().  There are no meaningful accessors on this class,
     // but it can be passed to ILGenerator which understands it's internals.
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public struct FieldToken
     {
         public static readonly FieldToken Empty = new FieldToken();
diff --git a/src/mscorlib/src/System/Reflection/Emit/FlowControl.cs b/src/mscorlib/src/System/Reflection/Emit/FlowControl.cs
index 31bb564cf4..9e528b2551 100644
--- a/src/mscorlib/src/System/Reflection/Emit/FlowControl.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/FlowControl.cs
@@ -16,7 +16,6 @@ namespace System.Reflection.Emit {
 using System;
 
 [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
 public enum FlowControl
 {
 
diff --git a/src/mscorlib/src/System/Reflection/Emit/GenericTypeParameterBuilder.cs b/src/mscorlib/src/System/Reflection/Emit/GenericTypeParameterBuilder.cs
index 6987ea139d..894f57d49c 100644
--- a/src/mscorlib/src/System/Reflection/Emit/GenericTypeParameterBuilder.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/GenericTypeParameterBuilder.cs
@@ -13,7 +13,6 @@ namespace System.Reflection.Emit
     using System.Globalization;
     using System.Diagnostics.Contracts;
 
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class GenericTypeParameterBuilder: TypeInfo
     {
         public override bool IsAssignableFrom(System.Reflection.TypeInfo typeInfo){
@@ -118,7 +117,6 @@ namespace System.Reflection.Emit
 
         protected override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) { throw new NotSupportedException(); }
 
-[System.Runtime.InteropServices.ComVisible(true)]
         public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr) { throw new NotSupportedException(); }
 
         protected override MethodInfo GetMethodImpl(String name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) { throw new NotSupportedException(); }
@@ -147,7 +145,6 @@ namespace System.Reflection.Emit
 
         public override MemberInfo[] GetMember(String name, MemberTypes type, BindingFlags bindingAttr) { throw new NotSupportedException(); }
 
-[System.Runtime.InteropServices.ComVisible(true)]
         public override InterfaceMapping GetInterfaceMap(Type interfaceType) { throw new NotSupportedException(); }
 
         public override EventInfo[] GetEvents(BindingFlags bindingAttr) { throw new NotSupportedException(); }
@@ -198,7 +195,6 @@ namespace System.Reflection.Emit
 
         public override bool IsAssignableFrom(Type c) { throw new NotSupportedException(); }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         [Pure]
         public override bool IsSubclassOf(Type c) { throw new NotSupportedException(); }
         #endregion
@@ -228,7 +224,6 @@ namespace System.Reflection.Emit
             m_type.SetParent(baseTypeConstraint);
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public void SetInterfaceConstraints(params Type[] interfaceConstraints)
         {
             m_type.CheckContext(interfaceConstraints);
diff --git a/src/mscorlib/src/System/Reflection/Emit/ILGenerator.cs b/src/mscorlib/src/System/Reflection/Emit/ILGenerator.cs
index b7d7e3fa2c..2cee63ff2e 100644
--- a/src/mscorlib/src/System/Reflection/Emit/ILGenerator.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/ILGenerator.cs
@@ -10,15 +10,11 @@ namespace System.Reflection.Emit
     using System.Diagnostics.SymbolStore;
     using System.Runtime.InteropServices;
     using System.Reflection;
-    using System.Security.Permissions;
     using System.Globalization;
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
     
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_ILGenerator))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public class ILGenerator : _ILGenerator
+    public class ILGenerator
     {
         #region Const Members
         private const int defaultSize = 16;
@@ -540,51 +536,6 @@ namespace System.Reflection.Emit
             PutInteger4(modBuilder.GetSignatureToken(sig).Token);
         }
 
-        public virtual void EmitCalli(OpCode opcode, CallingConvention unmanagedCallConv, Type returnType, Type[] parameterTypes)
-        {
-            int             stackchange = 0;
-            int             cParams = 0;
-            int             i;
-            SignatureHelper sig;
-            
-            ModuleBuilder modBuilder = (ModuleBuilder) m_methodBuilder.Module;
-
-            if (parameterTypes != null)
-            {
-                cParams = parameterTypes.Length;
-            }
-            
-            sig = SignatureHelper.GetMethodSigHelper(
-                modBuilder, 
-                unmanagedCallConv, 
-                returnType);
-                            
-            if (parameterTypes != null)
-            {
-                for (i = 0; i < cParams; i++) 
-                {
-                    sig.AddArgument(parameterTypes[i]);
-                }
-            }
-                                  
-            // If there is a non-void return type, push one.
-            if (returnType != typeof(void))
-                stackchange++;
-                
-            // Pop off arguments if any.
-            if (parameterTypes != null)
-                stackchange -= cParams;
-                
-            // Pop the native function pointer.
-            stackchange--;
-            UpdateStackSize(OpCodes.Calli, stackchange);
-
-            EnsureCapacity(7);
-            Emit(OpCodes.Calli);
-            RecordTokenFixup();
-            PutInteger4(modBuilder.GetSignatureToken(sig).Token);
-        }
-
         public virtual void EmitCall(OpCode opcode, MethodInfo methodInfo, Type[] optionalParameterTypes)
         {
             if (methodInfo == null)
@@ -657,7 +608,6 @@ namespace System.Reflection.Emit
             PutInteger4(tempVal);
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public virtual void Emit(OpCode opcode, ConstructorInfo con)
         {
             if (con == null)
diff --git a/src/mscorlib/src/System/Reflection/Emit/ISymWrapperCore.cs b/src/mscorlib/src/System/Reflection/Emit/ISymWrapperCore.cs
index a737895829..e6f4622f0e 100644
--- a/src/mscorlib/src/System/Reflection/Emit/ISymWrapperCore.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/ISymWrapperCore.cs
@@ -166,23 +166,6 @@ namespace System.Reflection.Emit
             private SymWriter()
             {
             }
-
-            //=========================================================================================
-            // Public interface methods start here.
-            //=========================================================================================
-
-
-            //------------------------------------------------------------------------------
-            // Initialize() wrapper
-            //------------------------------------------------------------------------------
-            void ISymbolWriter.Initialize(IntPtr emitter, String filename, bool fFullBuild)
-            {
-                int hr = m_vtable.Initialize(m_pWriter, emitter, filename, (IntPtr)0, fFullBuild);
-                if (hr < 0)
-                {
-                    throw Marshal.GetExceptionForHR(hr);
-                }
-            }
             
             //------------------------------------------------------------------------------
             // DefineDocument() wrapper
@@ -207,18 +190,6 @@ namespace System.Reflection.Emit
             }
         
             //------------------------------------------------------------------------------
-            // SetUserEntryPoint() wrapper
-            //------------------------------------------------------------------------------
-            void ISymbolWriter.SetUserEntryPoint(SymbolToken entryMethod)
-            {
-                int hr = m_vtable.SetUserEntryPoint(m_pWriter, entryMethod.GetToken());
-                if (hr < 0)
-                {
-                    throw Marshal.GetExceptionForHR(hr);
-                }
-            }
-        
-            //------------------------------------------------------------------------------
             // OpenMethod() wrapper
             //------------------------------------------------------------------------------
             void ISymbolWriter.OpenMethod(SymbolToken method)
@@ -326,18 +297,6 @@ namespace System.Reflection.Emit
                     throw Marshal.GetExceptionForHR(hr);
                 }
             }
-        
-            //------------------------------------------------------------------------------
-            // SetScopeRange() wrapper
-            //------------------------------------------------------------------------------
-            void ISymbolWriter.SetScopeRange(int scopeID, int startOffset, int endOffset)
-            {
-                int hr = m_vtable.SetScopeRange(m_pWriter, scopeID, startOffset, endOffset);
-                if (hr < 0)
-                {
-                    throw Marshal.GetExceptionForHR(hr);
-                }
-            }
     
             //------------------------------------------------------------------------------
             // DefineLocalVariable() wrapper
@@ -368,62 +327,7 @@ namespace System.Reflection.Emit
                     throw Marshal.GetExceptionForHR(hr);
                 }
             }
-        
-            //------------------------------------------------------------------------------
-            // DefineParameter() wrapper
-            //------------------------------------------------------------------------------
-            void ISymbolWriter.DefineParameter(String name,
-                                               ParameterAttributes attributes,
-                                               int sequence,
-                                               SymAddressKind addrKind,
-                                               int addr1,
-                                               int addr2,
-                                               int addr3)
-            {
-                throw new NotSupportedException();  // Intentionally not supported to match desktop CLR
-            }
-        
-            //------------------------------------------------------------------------------
-            // DefineField() wrapper
-            //------------------------------------------------------------------------------
-            void ISymbolWriter.DefineField(SymbolToken parent,
-                                           String name,
-                                           FieldAttributes attributes,
-                                           byte[] signature,
-                                           SymAddressKind addrKind,
-                                           int addr1,
-                                           int addr2,
-                                           int addr3)
-            {
-                throw new NotSupportedException();  // Intentionally not supported to match desktop CLR
-            }
-        
-            //------------------------------------------------------------------------------
-            // DefineGlobalVariable() wrapper
-            //------------------------------------------------------------------------------
-            void ISymbolWriter.DefineGlobalVariable(String name,
-                                                    FieldAttributes attributes,
-                                                    byte[] signature,
-                                                    SymAddressKind addrKind,
-                                                    int addr1,
-                                                    int addr2,
-                                                    int addr3)
-            {
-                throw new NotSupportedException();  // Intentionally not supported to match desktop CLR
-            }
-        
-            //------------------------------------------------------------------------------
-            // Close() wrapper
-            //------------------------------------------------------------------------------
-            void ISymbolWriter.Close()
-            {
-                int hr = m_vtable.Close(m_pWriter);
-                if (hr < 0)
-                {
-                    throw Marshal.GetExceptionForHR(hr);
-                }
-            }
-        
+
             //------------------------------------------------------------------------------
             // SetSymAttribute() wrapper
             //------------------------------------------------------------------------------
@@ -437,30 +341,6 @@ namespace System.Reflection.Emit
             }
         
             //------------------------------------------------------------------------------
-            // OpenNamespace() wrapper
-            //------------------------------------------------------------------------------
-            void ISymbolWriter.OpenNamespace(String name)
-            {
-                int hr = m_vtable.OpenNamespace(m_pWriter, name);
-                if (hr < 0)
-                {
-                    throw Marshal.GetExceptionForHR(hr);
-                }
-            }
-        
-            //------------------------------------------------------------------------------
-            // CloseNamespace() wrapper
-            //------------------------------------------------------------------------------
-            void ISymbolWriter.CloseNamespace()
-            {
-                int hr = m_vtable.CloseNamespace(m_pWriter);
-                if (hr < 0)
-                {
-                    throw Marshal.GetExceptionForHR(hr);
-                }
-            }
-        
-            //------------------------------------------------------------------------------
             // UsingNamespace() wrapper
             //------------------------------------------------------------------------------
             void ISymbolWriter.UsingNamespace(String name)
@@ -471,27 +351,6 @@ namespace System.Reflection.Emit
                     throw Marshal.GetExceptionForHR(hr);
                 }
             }
-            
-            //------------------------------------------------------------------------------
-            // SetMethodSourceRange() wrapper
-            //------------------------------------------------------------------------------
-            void ISymbolWriter.SetMethodSourceRange(ISymbolDocumentWriter startDoc,
-                                                    int startLine,
-                                                    int startColumn,
-                                                    ISymbolDocumentWriter endDoc,
-                                                    int endLine,
-                                                    int endColumn)
-            {
-                throw new NotSupportedException();   // Intentionally not supported to match desktop CLR
-            }
-    
-            //------------------------------------------------------------------------------
-            // SetUnderlyingWriter() wrapper.
-            //------------------------------------------------------------------------------
-            void ISymbolWriter.SetUnderlyingWriter(IntPtr ppUnderlyingWriter)
-            {
-                throw new NotSupportedException();   // Intentionally not supported on Telesto as it's a very unsafe api
-            }
 
             //------------------------------------------------------------------------------
             // InternalSetUnderlyingWriter() wrapper.
diff --git a/src/mscorlib/src/System/Reflection/Emit/Label.cs b/src/mscorlib/src/System/Reflection/Emit/Label.cs
index dd248b62fe..c7b987ff10 100644
--- a/src/mscorlib/src/System/Reflection/Emit/Label.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/Label.cs
@@ -16,7 +16,6 @@
 namespace System.Reflection.Emit {
     using System;
     using System.Reflection;
-    using System.Security.Permissions;
     using System.Runtime.InteropServices;
 
     // The Label class is an opaque representation of a label used by the 
@@ -26,7 +25,6 @@ namespace System.Reflection.Emit {
     // Labels are created by using ILGenerator.CreateLabel and their position is set
     // by using ILGenerator.MarkLabel.
     [Serializable]
-    [ComVisible(true)]
     public struct Label {
     
         internal int m_label;
diff --git a/src/mscorlib/src/System/Reflection/Emit/LocalBuilder.cs b/src/mscorlib/src/System/Reflection/Emit/LocalBuilder.cs
index a34d5ebe5d..fe4c33160a 100644
--- a/src/mscorlib/src/System/Reflection/Emit/LocalBuilder.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/LocalBuilder.cs
@@ -4,15 +4,11 @@
 
 using System;
 using System.Reflection;
-using System.Security.Permissions;
 using System.Runtime.InteropServices;
 
 namespace System.Reflection.Emit 
 {
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_LocalBuilder))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class LocalBuilder : LocalVariableInfo, _LocalBuilder
+    public sealed class LocalBuilder : LocalVariableInfo
     { 
         #region Private Data Members
         private int m_localIndex;
diff --git a/src/mscorlib/src/System/Reflection/Emit/MethodBuilder.cs b/src/mscorlib/src/System/Reflection/Emit/MethodBuilder.cs
index 654e166a05..17c8ce074d 100644
--- a/src/mscorlib/src/System/Reflection/Emit/MethodBuilder.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/MethodBuilder.cs
@@ -14,15 +14,11 @@ namespace System.Reflection.Emit
     using System.Security;
     using System.Collections;
     using System.Collections.Generic;
-    using System.Security.Permissions;
     using System.Runtime.InteropServices;
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
 
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_MethodBuilder))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class MethodBuilder : MethodInfo, _MethodBuilder
+    public sealed class MethodBuilder : MethodInfo
     {
         #region Private Data Members
         // Identity
@@ -67,11 +63,6 @@ namespace System.Reflection.Emit
         #endregion
 
         #region Constructor
-        internal MethodBuilder(String name, MethodAttributes attributes, CallingConventions callingConvention,
-            Type returnType, Type[] parameterTypes, ModuleBuilder mod, TypeBuilder type, bool bIsGlobalMethod) 
-        {
-            Init(name, attributes, callingConvention, returnType, null, null, parameterTypes, null, null, mod, type, bIsGlobalMethod);
-        }
 
         internal MethodBuilder(String name, MethodAttributes attributes, CallingConventions callingConvention,
             Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers,
@@ -371,11 +362,6 @@ namespace System.Reflection.Emit
             }
         }
 
-        internal void SetToken(MethodToken token)
-        {
-            m_tkMethod = token;
-        }
-
         internal byte[] GetBody()
         {
             // Returns the il bytes of this method.
@@ -851,199 +837,13 @@ namespace System.Reflection.Emit
             return new ParameterBuilder(this, position, attributes, strParamName);
         }
 
-        [Obsolete("An alternate API is available: Emit the MarshalAs custom attribute instead. http://go.microsoft.com/fwlink/?linkid=14202")]
-        public void SetMarshal(UnmanagedMarshal unmanagedMarshal)
-        {
-            ThrowIfGeneric ();
-
-            // set Marshal info for the return type
-
-            m_containingType.ThrowIfCreated();
-            
-            if (m_retParam == null)
-            {
-                m_retParam = new ParameterBuilder(this, 0, 0, null);
-            }
-
-            m_retParam.SetMarshal(unmanagedMarshal);
-        }
-
         private List<SymCustomAttr> m_symCustomAttrs;
         private struct SymCustomAttr
         {
-            public SymCustomAttr(String name, byte[] data)
-            {
-                m_name = name;
-                m_data = data;
-            }
             public String m_name;
             public byte[] m_data;
         }
 
-        public void SetSymCustomAttribute(String name, byte[] data)           
-        {
-            // Note that this API is rarely used.  Support for custom attributes in PDB files was added in
-            // Whidbey and as of 8/2007 the only known user is the C# compiler.  There seems to be little
-            // value to this for Reflection.Emit users since they can always use metadata custom attributes.
-            // Some versions of the symbol writer used in the CLR will ignore these entirely.  This API has 
-            // been removed from the Silverlight API surface area, but we should also consider removing it
-            // from future desktop product versions as well.
-            
-            ThrowIfGeneric ();
-
-            // This is different from CustomAttribute. This is stored into the SymWriter.
-            m_containingType.ThrowIfCreated();
-
-            ModuleBuilder dynMod = (ModuleBuilder) m_module;
-            if ( dynMod.GetSymWriter() == null)
-            {
-                // Cannot SetSymCustomAttribute when it is not a debug module
-                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotADebugModule"));
-            }
-
-            if (m_symCustomAttrs == null)
-                m_symCustomAttrs = new List<SymCustomAttr>();
-
-            m_symCustomAttrs.Add(new SymCustomAttr(name, data));
-        }
-
-        public void SetMethodBody(byte[] il, int maxStack, byte[] localSignature, IEnumerable<ExceptionHandler> exceptionHandlers, IEnumerable<int> tokenFixups)
-        {
-            if (il == null)
-            {
-                throw new ArgumentNullException(nameof(il), Environment.GetResourceString("ArgumentNull_Array"));
-            }
-            if (maxStack < 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(maxStack), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            }
-            Contract.EndContractBlock();
-
-            if (m_bIsBaked)
-            {
-                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_MethodBaked"));
-            }
-
-            m_containingType.ThrowIfCreated();
-            ThrowIfGeneric();
-            
-            byte[] newLocalSignature = null;
-            ExceptionHandler[] newHandlers = null;
-            int[] newTokenFixups = null;
-
-            byte[] newIL = (byte[])il.Clone();
-
-            if (localSignature != null)
-            {
-                newLocalSignature = (byte[])localSignature.Clone();
-            }
-
-            if (exceptionHandlers != null)
-            {
-                newHandlers = ToArray(exceptionHandlers);
-                CheckExceptionHandlerRanges(newHandlers, newIL.Length);
-
-                // Note: Fixup entries for type tokens stored in ExceptionHandlers are added by the method body emitter.
-            }
-
-            if (tokenFixups != null)
-            {
-                newTokenFixups = ToArray(tokenFixups);
-                int maxTokenOffset = newIL.Length - 4;
-
-                for (int i = 0; i < newTokenFixups.Length; i++)
-                {
-                    // Check that fixups are within the range of this method's IL, otherwise some random memory might get "fixed up".
-                    if (newTokenFixups[i] < 0 || newTokenFixups[i] > maxTokenOffset)
-                    {
-                        throw new ArgumentOutOfRangeException("tokenFixups[" + i + "]", Environment.GetResourceString("ArgumentOutOfRange_Range", 0, maxTokenOffset));
-                    }
-                }
-            }
-
-            m_ubBody = newIL;
-            m_localSignature = newLocalSignature;
-            m_exceptions = newHandlers;
-            m_mdMethodFixups = newTokenFixups;
-            m_maxStack = maxStack;
-
-            // discard IL generator, all information stored in it is now irrelevant
-            m_ilGenerator = null;
-            m_bIsBaked = true;
-        }
-
-        private static T[] ToArray<T>(IEnumerable<T> sequence)
-        {
-            T[] array = sequence as T[];
-            if (array != null)
-            {
-                return (T[])array.Clone();
-            }
-
-            return new List<T>(sequence).ToArray();
-        }
-
-        private static void CheckExceptionHandlerRanges(ExceptionHandler[] exceptionHandlers, int maxOffset)
-        {
-            // Basic checks that the handler ranges are within the method body (ranges are end-exclusive).
-            // Doesn't verify that the ranges are otherwise correct - it is very well possible to emit invalid IL.
-            for (int i = 0; i < exceptionHandlers.Length; i++)
-            {
-                var handler = exceptionHandlers[i];
-                if (handler.m_filterOffset > maxOffset || handler.m_tryEndOffset > maxOffset || handler.m_handlerEndOffset > maxOffset)
-                {
-                    throw new ArgumentOutOfRangeException("exceptionHandlers[" + i + "]", Environment.GetResourceString("ArgumentOutOfRange_Range", 0, maxOffset));
-                }
-
-                // Type token might be 0 if the ExceptionHandler was created via a default constructor.
-                // Other tokens migth also be invalid. We only check nil tokens as the implementation (SectEH_Emit in corhlpr.cpp) requires it,
-                // and we can't check for valid tokens until the module is baked.
-                if (handler.Kind == ExceptionHandlingClauseOptions.Clause && handler.ExceptionTypeToken == 0)
-                {
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidTypeToken", handler.ExceptionTypeToken), "exceptionHandlers[" + i + "]");
-                }
-            }
-        }
-
-        /// <summary>
-        /// Obsolete.
-        /// </summary>
-        public void CreateMethodBody(byte[] il, int count)
-        {
-            ThrowIfGeneric();
-
-            // Note that when user calls this function, there are a few information that client is
-            // not able to supply: local signature, exception handlers, max stack size, a list of Token fixup, a list of RVA fixup
-
-            if (m_bIsBaked)
-            {
-                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_MethodBaked"));
-            }
-
-            m_containingType.ThrowIfCreated();
-
-            if (il != null && (count < 0 || count > il.Length))
-            {
-                throw new ArgumentOutOfRangeException(nameof(count), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-            }
-
-            if (il == null)
-            {
-                m_ubBody = null;
-                return;
-            }
-
-            m_ubBody = new byte[count];
-            Buffer.BlockCopy(il, 0, m_ubBody, 0, count);
-
-            m_localSignature = null;
-            m_exceptions = null;
-            m_mdMethodFixups = null;
-            m_maxStack = DefaultMaxStack;
-
-            m_bIsBaked = true;
-        }
-
         public void SetImplementationFlags(MethodImplAttributes attributes) 
         {
             ThrowIfGeneric ();
@@ -1113,7 +913,6 @@ namespace System.Reflection.Emit
         }
 
 
-[System.Runtime.InteropServices.ComVisible(true)]
         public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
         {
             if (con == null)
@@ -1314,8 +1113,7 @@ namespace System.Reflection.Emit
     /// Describes exception handler in a method body.
     /// </summary>
     [StructLayout(LayoutKind.Sequential)]
-    [ComVisible(false)]
-    public struct ExceptionHandler : IEquatable<ExceptionHandler>
+    internal struct ExceptionHandler : IEquatable<ExceptionHandler>
     {
         // Keep in sync with unmanged structure. 
         internal readonly int m_exceptionClass;
@@ -1326,118 +1124,7 @@ namespace System.Reflection.Emit
         internal readonly int m_handlerEndOffset;
         internal readonly ExceptionHandlingClauseOptions m_kind;
 
-        public int ExceptionTypeToken
-        {
-            get { return m_exceptionClass; }
-        }
-
-        public int TryOffset
-        {
-            get { return m_tryStartOffset; }
-        }
-
-        public int TryLength
-        {
-            get { return m_tryEndOffset - m_tryStartOffset; }
-        }
-
-        public int FilterOffset
-        {
-            get { return m_filterOffset; }
-        }
-
-        public int HandlerOffset
-        {
-            get { return m_handlerStartOffset; }
-        }
-
-        public int HandlerLength
-        {
-            get { return m_handlerEndOffset - m_handlerStartOffset; }
-        }
-
-        public ExceptionHandlingClauseOptions Kind
-        {
-            get { return m_kind; }
-        }
-
-        #region Constructors
-
-        /// <summary>
-        /// Creates a description of an exception handler.
-        /// </summary>
-        /// <param name="tryOffset">The offset of the first instruction protected by this handler.</param>
-        /// <param name="tryLength">The number of bytes protected by this handler.</param>
-        /// <param name="filterOffset">The filter code begins at the specified offset and ends at the first instruction of the handler block. Specify 0 if not applicable (this is not a filter handler).</param>
-        /// <param name="handlerOffset">The offset of the first instruction of this handler.</param>
-        /// <param name="handlerLength">The number of bytes of the handler.</param>
-        /// <param name="kind">The kind of handler, the handler might be a catch handler, filter handler, fault handler, or finally handler.</param>
-        /// <param name="exceptionTypeToken">The token of the exception type handled by this handler. Specify 0 if not applicable (this is finally handler).</param>
-        /// <exception cref="ArgumentOutOfRangeException">
-        /// Some of the instruction offset is negative, 
-        /// the end offset of specified range is less than its start offset,
-        /// or <paramref name="kind"/> has an invalid value.
-        /// </exception>
-        public ExceptionHandler(int tryOffset, int tryLength, int filterOffset, int handlerOffset, int handlerLength,
-            ExceptionHandlingClauseOptions kind, int exceptionTypeToken)
-        {
-            if (tryOffset < 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(tryOffset), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            }
-
-            if (tryLength < 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(tryLength), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            }
-
-            if (filterOffset < 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(filterOffset), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            }
-
-            if (handlerOffset < 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(handlerOffset), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            }
-
-            if (handlerLength < 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(handlerLength), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            }
-
-            if ((long)tryOffset + tryLength > Int32.MaxValue)
-            {
-                throw new ArgumentOutOfRangeException(nameof(tryLength), Environment.GetResourceString("ArgumentOutOfRange_Range", 0, Int32.MaxValue - tryOffset));
-            }
-
-            if ((long)handlerOffset + handlerLength > Int32.MaxValue)
-            {
-                throw new ArgumentOutOfRangeException(nameof(handlerLength), Environment.GetResourceString("ArgumentOutOfRange_Range", 0, Int32.MaxValue - handlerOffset));
-            }
-
-            // Other tokens migth also be invalid. We only check nil tokens as the implementation (SectEH_Emit in corhlpr.cpp) requires it,
-            // and we can't check for valid tokens until the module is baked.
-            if (kind == ExceptionHandlingClauseOptions.Clause && (exceptionTypeToken & 0x00FFFFFF) == 0)
-            {
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidTypeToken", exceptionTypeToken), nameof(exceptionTypeToken));
-            }
-
-            Contract.EndContractBlock();
-
-            if (!IsValidKind(kind))
-            {
-                throw new ArgumentOutOfRangeException(nameof(kind), Environment.GetResourceString("ArgumentOutOfRange_Enum"));
-            }
-            
-            m_tryStartOffset = tryOffset;
-            m_tryEndOffset = tryOffset + tryLength;
-            m_filterOffset = filterOffset;
-            m_handlerStartOffset = handlerOffset;
-            m_handlerEndOffset = handlerOffset + handlerLength;
-            m_kind = kind;
-            m_exceptionClass = exceptionTypeToken;
-        }
+#region Constructors
 
         internal ExceptionHandler(int tryStartOffset, int tryEndOffset, int filterOffset, int handlerStartOffset, int handlerEndOffset,
             int kind, int exceptionTypeToken)
diff --git a/src/mscorlib/src/System/Reflection/Emit/MethodBuilderInstantiation.cs b/src/mscorlib/src/System/Reflection/Emit/MethodBuilderInstantiation.cs
index 5b69b6e607..57ad1665c0 100644
--- a/src/mscorlib/src/System/Reflection/Emit/MethodBuilderInstantiation.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/MethodBuilderInstantiation.cs
@@ -53,7 +53,6 @@ namespace System.Reflection.Emit
         public override Object[] GetCustomAttributes(Type attributeType, bool inherit) { return m_method.GetCustomAttributes(attributeType, inherit); }
         public override bool IsDefined(Type attributeType, bool inherit) { return m_method.IsDefined(attributeType, inherit); }
         public override Module Module { get { return m_method.Module; } }
-        public new Type GetType() { return base.GetType(); }
         #endregion
 
         #region MethodBase Members
diff --git a/src/mscorlib/src/System/Reflection/Emit/MethodToken.cs b/src/mscorlib/src/System/Reflection/Emit/MethodToken.cs
index cc28e173d7..76b7279f30 100644
--- a/src/mscorlib/src/System/Reflection/Emit/MethodToken.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/MethodToken.cs
@@ -16,10 +16,8 @@ namespace System.Reflection.Emit {
     
     using System;
     using System.Reflection;
-    using System.Security.Permissions;
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public struct MethodToken
     {
         public static readonly MethodToken Empty = new MethodToken();
diff --git a/src/mscorlib/src/System/Reflection/Emit/ModuleBuilder.cs b/src/mscorlib/src/System/Reflection/Emit/ModuleBuilder.cs
index 1539c17530..30e6382550 100644
--- a/src/mscorlib/src/System/Reflection/Emit/ModuleBuilder.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/ModuleBuilder.cs
@@ -15,7 +15,6 @@ namespace System.Reflection.Emit
     using System.IO;
     using System.Resources;
     using System.Security;
-    using System.Security.Permissions;
     using System.Runtime.Serialization;
     using System.Text;
     using System.Threading;
@@ -50,10 +49,7 @@ namespace System.Reflection.Emit
     }
 
     // deliberately not [serializable]
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_ModuleBuilder))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public class ModuleBuilder : Module, _ModuleBuilder
+    public class ModuleBuilder : Module
     {
         #region FCalls
 
@@ -248,61 +244,8 @@ namespace System.Reflection.Emit
 
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
         [SuppressUnmanagedCodeSecurity]
-        private extern static void PreSavePEFile(RuntimeModule module, int portableExecutableKind, int imageFileMachine);
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        private extern static void SavePEFile(RuntimeModule module, String fileName, int entryPoint, int isExe, bool isManifestFile);
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        private extern static void AddResource(
-            RuntimeModule module, String strName, 
-            byte[] resBytes, int resByteCount, int tkFile, int attribute,
-            int portableExecutableKind, int imageFileMachine);
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        private extern static void SetModuleName(RuntimeModule module, String strModuleName);
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
         internal extern static void SetFieldRVAContent(RuntimeModule module, int fdToken, byte[] data, int length);
 
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        private extern static void DefineNativeResourceFile(RuntimeModule module, 
-                                                            String strFilename, 
-                                                            int portableExecutableKind, 
-                                                            int ImageFileMachine);
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        private extern static void DefineNativeResourceBytes(RuntimeModule module,
-                                                             byte[] pbResource, int cbResource, 
-                                                             int portableExecutableKind, 
-                                                             int imageFileMachine);
-
-        internal void DefineNativeResource(PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
-        {
-            string strResourceFileName = m_moduleData.m_strResourceFileName;
-            byte[] resourceBytes = m_moduleData.m_resourceBytes;
-
-            if (strResourceFileName != null)
-            {
-                DefineNativeResourceFile(GetNativeHandle(),
-                    strResourceFileName,
-                    (int)portableExecutableKind, (int)imageFileMachine);
-            }
-            else
-            if (resourceBytes != null)
-            {
-                DefineNativeResourceBytes(GetNativeHandle(),
-                    resourceBytes, resourceBytes.Length,
-                    (int)portableExecutableKind, (int)imageFileMachine);
-            }
-        }
-
         #endregion
 
         #region Internal Members
@@ -436,17 +379,6 @@ namespace System.Reflection.Emit
             m_TypeBuilderDict = new Dictionary<string, Type>();
         }
 
-        // This is a method for changing module and file name of the manifest module (created by default for 
-        // each assembly).
-        internal void ModifyModuleName(string name)
-        {
-            // Reset the names in the managed ModuleBuilderData
-            m_moduleData.ModifyModuleName(name);
-
-            // Reset the name in the underlying metadata
-            ModuleBuilder.SetModuleName(GetNativeHandle(), name);
-        }
-
         internal void SetSymWriter(ISymbolWriter writer)
         {
             m_iSymWriter = writer;
@@ -700,19 +632,16 @@ namespace System.Reflection.Emit
             return typeList;
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public override Type GetType(String className)
         {
             return GetType(className, false, false);
         }
         
-        [System.Runtime.InteropServices.ComVisible(true)]
         public override Type GetType(String className, bool ignoreCase)
         {
             return GetType(className, false, ignoreCase);
         }
         
-        [System.Runtime.InteropServices.ComVisible(true)]
         public override Type GetType(String className, bool throwOnError, bool ignoreCase)
         {
             lock(SyncRoot)
@@ -831,11 +760,6 @@ namespace System.Reflection.Emit
                     fullyQualifiedName = Path.Combine(ContainingAssemblyBuilder.m_assemblyData.m_strDir, fullyQualifiedName);
                     fullyQualifiedName = Path.GetFullPath(fullyQualifiedName);
                 }
-                
-                if (ContainingAssemblyBuilder.m_assemblyData.m_strDir != null && fullyQualifiedName != null) 
-                {
-                    new FileIOPermission( FileIOPermissionAccess.PathDiscovery, fullyQualifiedName ).Demand();
-                }
 
                 return fullyQualifiedName;
             }
@@ -1010,7 +934,6 @@ namespace System.Reflection.Emit
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public TypeBuilder DefineType(String name, TypeAttributes attr, Type parent, Type[] interfaces)
         {
             Contract.Ensures(Contract.Result<TypeBuilder>() != null);
@@ -1061,10 +984,16 @@ namespace System.Reflection.Emit
                 EnumBuilder enumBuilder = DefineEnumNoLock(name, visibility, underlyingType);
 
                 // This enum is not generic, nested, and cannot have any element type.
-                Debug.Assert(name == enumBuilder.FullName);
+
+                // We ought to be able to make the following assertions:
+                //
+                //  Debug.Assert(name == enumBuilder.FullName);
+                //  Debug.Assert(enumBuilder.m_typeBuilder == m_TypeBuilderDict[name]);
+                //
+                // but we can't because an embedded null ('\0') in the name will cause it to be truncated
+                // incorrectly.  Fixing that would be a breaking change.
 
                 // Replace the TypeBuilder object in m_TypeBuilderDict with this EnumBuilder object.
-                Debug.Assert(enumBuilder.m_typeBuilder == m_TypeBuilderDict[name]);
                 m_TypeBuilderDict[name] = enumBuilder;
 
                 return enumBuilder;
@@ -1470,41 +1399,6 @@ namespace System.Reflection.Emit
             return new MethodToken(mr);
         }
 
-        public MethodToken GetConstructorToken(ConstructorInfo constructor, IEnumerable<Type> optionalParameterTypes)
-        {
-            if (constructor == null)
-            {
-                throw new ArgumentNullException(nameof(constructor));
-            }
-
-            lock (SyncRoot)
-            {
-                // useMethodDef is not applicable - constructors aren't generic
-                return new MethodToken(GetMethodTokenInternal(constructor, optionalParameterTypes, false));
-            }
-        }
-
-        public MethodToken GetMethodToken(MethodInfo method, IEnumerable<Type> optionalParameterTypes)
-        {
-            if (method == null)
-            {
-                throw new ArgumentNullException(nameof(method));
-            }
-
-            // useMethodDef flag only affects the result if we pass in a generic method definition. 
-            // If the caller is looking for a token for an ldtoken/ldftn/ldvirtftn instruction and passes in a generic method definition info/builder, 
-            // we correclty return the MethodDef/Ref token of the generic definition that can be used with ldtoken/ldftn/ldvirtftn. 
-            //
-            // If the caller is looking for a token for a call/callvirt/jmp instruction and passes in a generic method definition info/builder,
-            // we also return the generic MethodDef/Ref token, which is indeed not acceptable for call/callvirt/jmp instruction.
-            // But the caller can always instantiate the info/builder and pass it in. Then we build the right MethodSpec.
-
-            lock (SyncRoot)
-            {
-                return new MethodToken(GetMethodTokenInternal(method, optionalParameterTypes, true));
-            }
-        }
-
         internal int GetMethodTokenInternal(MethodBase method, IEnumerable<Type> optionalParameterTypes, bool useMethodDef)
         {
             int tk = 0;
@@ -1631,7 +1525,6 @@ namespace System.Reflection.Emit
             return new SymbolMethod(this, token, arrayClass, methodName, callingConvention, returnType, parameterTypes);
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public MethodToken GetConstructorToken(ConstructorInfo con)
         {
             // Return a token for the ConstructorInfo relative to the Module. 
@@ -1781,7 +1674,6 @@ namespace System.Reflection.Emit
 
         #region Other
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
         {
             if (con == null)
@@ -1838,7 +1730,7 @@ namespace System.Reflection.Emit
         // For these reasons, we should consider making this API internal in Arrowhead
         // (as it is in Silverlight), and consider validating that we're within a call
         // to TypeBuilder.CreateType whenever this is used.
-        public ISymbolWriter GetSymWriter()
+        internal ISymbolWriter GetSymWriter()
         {
             return m_iSymWriter;
         }
@@ -1867,81 +1759,6 @@ namespace System.Reflection.Emit
             return m_iSymWriter.DefineDocument(url, language, languageVendor, documentType);
         }
     
-        public void SetUserEntryPoint(MethodInfo entryPoint)
-        {
-            lock(SyncRoot)
-            {
-                SetUserEntryPointNoLock(entryPoint);
-            }
-        }
-
-        private void SetUserEntryPointNoLock(MethodInfo entryPoint)
-        {
-            // Set the user entry point. Compiler may generate startup stub before calling user main.
-            // The startup stub will be the entry point. While the user "main" will be the user entry
-            // point so that debugger will not step into the compiler entry point.
-
-            if (entryPoint == null)
-            {
-                throw new ArgumentNullException(nameof(entryPoint));
-            }
-            Contract.EndContractBlock();
-        
-            if (m_iSymWriter == null)
-            {
-                // Cannot set entry point when it is not a debug module
-                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotADebugModule"));
-            }
-
-            if (entryPoint.DeclaringType != null)
-            {
-                if (!entryPoint.Module.Equals(this))
-                {
-                    // you cannot pass in a MethodInfo that is not contained by this ModuleBuilder
-                    throw new InvalidOperationException(Environment.GetResourceString("Argument_NotInTheSameModuleBuilder"));
-                }
-            }
-            else
-            {
-                // unfortunately this check is missing for global function passed in as RuntimeMethodInfo. 
-                // The problem is that Reflection does not 
-                // allow us to get the containing module giving a global function
-                MethodBuilder mb = entryPoint as MethodBuilder;
-                if (mb != null && mb.GetModuleBuilder() != this)
-                {
-                    // you cannot pass in a MethodInfo that is not contained by this ModuleBuilder
-                    throw new InvalidOperationException(Environment.GetResourceString("Argument_NotInTheSameModuleBuilder"));                    
-                }                    
-            }
-                
-            // get the metadata token value and create the SymbolStore's token value class
-            SymbolToken       tkMethod = new SymbolToken(GetMethodTokenInternal(entryPoint).Token);
-
-            // set the UserEntryPoint
-            m_iSymWriter.SetUserEntryPoint(tkMethod);
-        }
-    
-        public void SetSymCustomAttribute(String name, byte[] data)
-        {
-            lock(SyncRoot)
-            {
-                SetSymCustomAttributeNoLock(name, data);
-            }
-        }
-
-        private void SetSymCustomAttributeNoLock(String name, byte[] data)
-        {
-            if (m_iSymWriter == null)
-            {
-                // Cannot SetSymCustomAttribute when it is not a debug module
-                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotADebugModule"));
-            }
-
-            // This API has never worked.  It seems like we might want to call m_iSymWriter.SetSymAttribute,
-            // but we don't have a metadata token to associate the attribute with.  Instead 
-            // MethodBuilder.SetSymCustomAttribute could be used to associate a symbol attribute with a specific method.
-        }
-    
         [Pure]
         public bool IsTransient()
         {
diff --git a/src/mscorlib/src/System/Reflection/Emit/ModuleBuilderData.cs b/src/mscorlib/src/System/Reflection/Emit/ModuleBuilderData.cs
index 96e60d9a4e..4b6f8b4efe 100644
--- a/src/mscorlib/src/System/Reflection/Emit/ModuleBuilderData.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/ModuleBuilderData.cs
@@ -52,36 +52,6 @@ namespace System.Reflection.Emit
             }
         }
 
-        // This is a method for changing module and file name of the manifest module (created by default for 
-        // each assembly).
-        internal virtual void ModifyModuleName(String strModuleName)
-        {
-            Debug.Assert(m_strModuleName == AssemblyBuilder.MANIFEST_MODULE_NAME, "Changing names for non-manifest module");
-            InitNames(strModuleName, null /*strFileName*/);
-        }
-
-        internal int FileToken
-        {
-            get
-            {
-                // Before save, the scope of m_tkFile is the in-memory assembly manifest
-                // During save, the scope of m_tkFile is the on-disk assembly manifest
-                // For transient modules m_tkFile never change. 
-
-                // Theoretically no one should emit anything after a dynamic assembly has
-                // been saved. So m_tkFile shouldn't used when m_isSaved is true.
-                // But that was never completely enforced: you can still emit everything after 
-                // the assembly has been saved (except for public types in persistent modules).
-
-                return m_tkFile;
-            }
-
-            set
-            {
-                m_tkFile = value;
-            }
-        }
-
         internal String        m_strModuleName;     // scope name (can be different from file name)
         internal String        m_strFileName;
         internal bool          m_fGlobalBeenCreated;
@@ -93,8 +63,6 @@ namespace System.Reflection.Emit
 
         private int            m_tkFile;
         internal bool          m_isSaved;
-        [NonSerialized]
-        internal ResWriterData m_embeddedRes;
         internal const String MULTI_BYTE_VALUE_CLASS = "$ArrayType$";
         internal String        m_strResourceFileName;
         internal byte[]        m_resourceBytes;
diff --git a/src/mscorlib/src/System/Reflection/Emit/OpCodes.cs b/src/mscorlib/src/System/Reflection/Emit/OpCodes.cs
index 345694ec80..324fad9ceb 100644
--- a/src/mscorlib/src/System/Reflection/Emit/OpCodes.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/OpCodes.cs
@@ -13,7 +13,6 @@
 namespace System.Reflection.Emit {
 
 using System;
-using System.Security.Permissions;
 
 //
 // Internal enums for opcode values. Note that the value names are used to construct
@@ -250,7 +249,6 @@ internal enum OpCodeValues {
     // If you add more opcodes here, modify OpCode.Name to handle them correctly
 };
 
-[System.Runtime.InteropServices.ComVisible(true)]
 public class OpCodes {
 
 /// <summary>
@@ -1419,7 +1417,6 @@ public class OpCodes {
         (1 << OpCode.StackChangeShift)
     );
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public static readonly OpCode Castclass = new OpCode(OpCodeValues.Castclass,
         ((int)OperandType.InlineType) |
         ((int)FlowControl.Next << OpCode.FlowControlShift) |
diff --git a/src/mscorlib/src/System/Reflection/Emit/Opcode.cs b/src/mscorlib/src/System/Reflection/Emit/Opcode.cs
index d7bfacd568..74a9de16b6 100644
--- a/src/mscorlib/src/System/Reflection/Emit/Opcode.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/Opcode.cs
@@ -5,10 +5,8 @@
 namespace System.Reflection.Emit {
 using System;
 using System.Threading;
-using System.Security.Permissions;
 using System.Diagnostics.Contracts;
 
-[System.Runtime.InteropServices.ComVisible(true)]
 public struct OpCode
 {
     //
diff --git a/src/mscorlib/src/System/Reflection/Emit/OpcodeType.cs b/src/mscorlib/src/System/Reflection/Emit/OpcodeType.cs
index 3636cb7377..87dea058e5 100644
--- a/src/mscorlib/src/System/Reflection/Emit/OpcodeType.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/OpcodeType.cs
@@ -17,7 +17,6 @@ namespace System.Reflection.Emit {
 using System;
 
 [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
 public enum OpCodeType
 {
 
diff --git a/src/mscorlib/src/System/Reflection/Emit/OperandType.cs b/src/mscorlib/src/System/Reflection/Emit/OperandType.cs
index 808844a017..e972e8603d 100644
--- a/src/mscorlib/src/System/Reflection/Emit/OperandType.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/OperandType.cs
@@ -17,7 +17,6 @@ namespace System.Reflection.Emit {
 using System;
 
 [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
 public enum OperandType
 {
 
diff --git a/src/mscorlib/src/System/Reflection/Emit/PEFileKinds.cs b/src/mscorlib/src/System/Reflection/Emit/PEFileKinds.cs
index d9c9c0327c..531ff41dd7 100644
--- a/src/mscorlib/src/System/Reflection/Emit/PEFileKinds.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/PEFileKinds.cs
@@ -7,7 +7,6 @@ namespace System.Reflection.Emit {
     using System;
     // This Enum matchs the CorFieldAttr defined in CorHdr.h
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum PEFileKinds
     {
         Dll                = 0x0001,
diff --git a/src/mscorlib/src/System/Reflection/Emit/ParameterBuilder.cs b/src/mscorlib/src/System/Reflection/Emit/ParameterBuilder.cs
index 7909562baa..1b3babf595 100644
--- a/src/mscorlib/src/System/Reflection/Emit/ParameterBuilder.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/ParameterBuilder.cs
@@ -16,31 +16,10 @@ namespace System.Reflection.Emit {
     using System.Runtime.InteropServices;
     using System;
     using System.Reflection;
-    using System.Security.Permissions;
     using System.Diagnostics.Contracts;
 
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_ParameterBuilder))]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public class ParameterBuilder : _ParameterBuilder
+    public class ParameterBuilder
     {
-        // set ParamMarshal
-        [Obsolete("An alternate API is available: Emit the MarshalAs custom attribute instead. http://go.microsoft.com/fwlink/?linkid=14202")]
-        public virtual void SetMarshal(UnmanagedMarshal unmanagedMarshal)
-        {
-            if (unmanagedMarshal == null)
-            {
-                throw new ArgumentNullException(nameof(unmanagedMarshal));
-            }
-            Contract.EndContractBlock();
-            
-            byte []        ubMarshal = unmanagedMarshal.InternalGetBytes();
-            TypeBuilder.SetFieldMarshal(
-                m_methodBuilder.GetModuleBuilder().GetNativeHandle(),
-                m_pdToken.Token, 
-                ubMarshal, 
-                ubMarshal.Length);
-        }
     
         // Set the default value of the parameter
         public virtual void SetConstant(Object defaultValue) 
@@ -54,7 +33,6 @@ namespace System.Reflection.Emit {
         
         // Use this function if client decides to form the custom attribute blob themselves
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
         {
             if (con == null)
@@ -111,8 +89,6 @@ namespace System.Reflection.Emit {
         {
             return m_pdToken;
         } 
-
-        internal int MetadataTokenInternal { get { return m_pdToken.Token; } }
         
         public virtual String Name {
             get {return m_strParamName;}
diff --git a/src/mscorlib/src/System/Reflection/Emit/ParameterToken.cs b/src/mscorlib/src/System/Reflection/Emit/ParameterToken.cs
index a101c95058..a4a32a51fb 100644
--- a/src/mscorlib/src/System/Reflection/Emit/ParameterToken.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/ParameterToken.cs
@@ -16,12 +16,10 @@ namespace System.Reflection.Emit {
     
     using System;
     using System.Reflection;
-    using System.Security.Permissions;
 
     // The ParameterToken class is an opaque representation of the Token returned
     // by the Metadata to represent the parameter. 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public struct ParameterToken {
     
         public static readonly ParameterToken Empty = new ParameterToken();
diff --git a/src/mscorlib/src/System/Reflection/Emit/PropertyBuilder.cs b/src/mscorlib/src/System/Reflection/Emit/PropertyBuilder.cs
index e7442b4e02..7c4ed9dc0f 100644
--- a/src/mscorlib/src/System/Reflection/Emit/PropertyBuilder.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/PropertyBuilder.cs
@@ -17,7 +17,6 @@ namespace System.Reflection.Emit {
     using System;
     using System.Reflection;
     using CultureInfo = System.Globalization.CultureInfo;
-    using System.Security.Permissions;
     using System.Runtime.InteropServices;
     using System.Diagnostics.Contracts;
 
@@ -25,10 +24,7 @@ namespace System.Reflection.Emit {
     // A PropertyBuilder is always associated with a TypeBuilder.  The TypeBuilder.DefineProperty
     // method will return a new PropertyBuilder to a client.
     // 
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_PropertyBuilder))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class PropertyBuilder : PropertyInfo, _PropertyBuilder
+    public sealed class PropertyBuilder : PropertyInfo
     { 
     
         // Make a private constructor so these cannot be constructed externally.
@@ -84,14 +80,6 @@ namespace System.Reflection.Emit {
         {
             get {return m_prToken;}
         }
-
-        internal int MetadataTokenInternal
-        {
-            get 
-            {
-                return m_tkProperty;
-            }
-        }
         
         public override Module Module
         {
@@ -135,7 +123,6 @@ namespace System.Reflection.Emit {
     
         // Use this function if client decides to form the custom attribute blob themselves
 
-[System.Runtime.InteropServices.ComVisible(true)]
         public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
         {
             if (con == null)
diff --git a/src/mscorlib/src/System/Reflection/Emit/PropertyToken.cs b/src/mscorlib/src/System/Reflection/Emit/PropertyToken.cs
index d70cad057a..72ab983bb9 100644
--- a/src/mscorlib/src/System/Reflection/Emit/PropertyToken.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/PropertyToken.cs
@@ -16,10 +16,8 @@ namespace System.Reflection.Emit {
     
     using System;
     using System.Reflection;
-    using System.Security.Permissions;
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public struct PropertyToken {
     
         public static readonly PropertyToken Empty = new PropertyToken();
diff --git a/src/mscorlib/src/System/Reflection/Emit/SignatureHelper.cs b/src/mscorlib/src/System/Reflection/Emit/SignatureHelper.cs
index 5128576df9..b43abcb51c 100644
--- a/src/mscorlib/src/System/Reflection/Emit/SignatureHelper.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/SignatureHelper.cs
@@ -14,12 +14,8 @@ namespace System.Reflection.Emit
     using System.Runtime.CompilerServices;
     using System.Runtime.InteropServices;
     using System.Runtime.Versioning;
-    using System.Security.Permissions;
     
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_SignatureHelper))]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class SignatureHelper : _SignatureHelper
+    public sealed class SignatureHelper
     {
         #region Consts Fields
         private const int NO_SIZE_IN_SIG = -1;
@@ -518,36 +514,6 @@ namespace System.Reflection.Emit
             }            
             
         }
-
-        private void AddData(uint data)
-        {
-            if (m_currSig + 4 > m_signature.Length)
-            {
-                m_signature = ExpandArray(m_signature);
-            }
-
-            m_signature[m_currSig++] = (byte)((data)     & 0xFF);
-            m_signature[m_currSig++] = (byte)((data>>8)  & 0xFF);
-            m_signature[m_currSig++] = (byte)((data>>16) & 0xFF);
-            m_signature[m_currSig++] = (byte)((data>>24) & 0xFF);
-        }
-        
-        private void AddData(ulong data)
-        {
-            if (m_currSig + 8 > m_signature.Length)
-            {
-                m_signature = ExpandArray(m_signature);
-            }
-
-            m_signature[m_currSig++] = (byte)((data)     & 0xFF);
-            m_signature[m_currSig++] = (byte)((data>>8)  & 0xFF);
-            m_signature[m_currSig++] = (byte)((data>>16) & 0xFF);
-            m_signature[m_currSig++] = (byte)((data>>24) & 0xFF);
-            m_signature[m_currSig++] = (byte)((data>>32) & 0xFF);
-            m_signature[m_currSig++] = (byte)((data>>40) & 0xFF);
-            m_signature[m_currSig++] = (byte)((data>>48) & 0xFF);
-            m_signature[m_currSig++] = (byte)((data>>56) & 0xFF);
-        }
         
         private void AddElementType(CorElementType cvt)
         {
diff --git a/src/mscorlib/src/System/Reflection/Emit/SignatureToken.cs b/src/mscorlib/src/System/Reflection/Emit/SignatureToken.cs
index 0a87ac1398..5c908b89c7 100644
--- a/src/mscorlib/src/System/Reflection/Emit/SignatureToken.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/SignatureToken.cs
@@ -17,9 +17,7 @@ namespace System.Reflection.Emit {
     
     using System;
     using System.Reflection;
-    using System.Security.Permissions;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public struct SignatureToken {
     
         public static readonly SignatureToken Empty = new SignatureToken();
diff --git a/src/mscorlib/src/System/Reflection/Emit/StackBehaviour.cs b/src/mscorlib/src/System/Reflection/Emit/StackBehaviour.cs
index 2d2c35ef26..8a447d03fc 100644
--- a/src/mscorlib/src/System/Reflection/Emit/StackBehaviour.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/StackBehaviour.cs
@@ -17,7 +17,6 @@ namespace System.Reflection.Emit {
 using System;
 
 [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
 public enum StackBehaviour
 {
 
diff --git a/src/mscorlib/src/System/Reflection/Emit/StringToken.cs b/src/mscorlib/src/System/Reflection/Emit/StringToken.cs
index cb0e979a7a..852225697c 100644
--- a/src/mscorlib/src/System/Reflection/Emit/StringToken.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/StringToken.cs
@@ -16,10 +16,8 @@ namespace System.Reflection.Emit {
     
     using System;
     using System.Reflection;
-    using System.Security.Permissions;
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public struct StringToken {
     
         internal int m_string;
diff --git a/src/mscorlib/src/System/Reflection/Emit/SymbolType.cs b/src/mscorlib/src/System/Reflection/Emit/SymbolType.cs
index 84ece90982..205299125b 100644
--- a/src/mscorlib/src/System/Reflection/Emit/SymbolType.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/SymbolType.cs
@@ -419,7 +419,6 @@ namespace System.Reflection.Emit
             throw new NotSupportedException(Environment.GetResourceString("NotSupported_NonReflectedType"));      
         }
         
-[System.Runtime.InteropServices.ComVisible(true)]
         public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
         {
             throw new NotSupportedException(Environment.GetResourceString("NotSupported_NonReflectedType"));      
@@ -497,7 +496,6 @@ namespace System.Reflection.Emit
             throw new NotSupportedException(Environment.GetResourceString("NotSupported_NonReflectedType"));      
         }
 
-[System.Runtime.InteropServices.ComVisible(true)]
         public override InterfaceMapping GetInterfaceMap(Type interfaceType)
         {
             throw new NotSupportedException(Environment.GetResourceString("NotSupported_NonReflectedType"));      
diff --git a/src/mscorlib/src/System/Reflection/Emit/TypeBuilder.cs b/src/mscorlib/src/System/Reflection/Emit/TypeBuilder.cs
index 36809009a3..88502cb096 100644
--- a/src/mscorlib/src/System/Reflection/Emit/TypeBuilder.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/TypeBuilder.cs
@@ -9,7 +9,6 @@ namespace System.Reflection.Emit {
     using System;
     using System.Reflection;
     using System.Security;
-    using System.Security.Permissions;
     using System.Runtime.InteropServices;
     using System.Runtime.CompilerServices;
     using System.Collections.Generic;
@@ -21,7 +20,6 @@ namespace System.Reflection.Emit {
 
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum PackingSize
     {
         Unspecified                 = 0,
@@ -35,10 +33,7 @@ namespace System.Reflection.Emit {
         Size128                     = 128,
     }
 
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_TypeBuilder))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class TypeBuilder : TypeInfo, _TypeBuilder
+    public sealed class TypeBuilder : TypeInfo
     {
         public override bool IsAssignableFrom(System.Reflection.TypeInfo typeInfo){
             if(typeInfo==null) return false;            
@@ -227,10 +222,6 @@ namespace System.Reflection.Emit {
 
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
 		[SuppressUnmanagedCodeSecurity]
-        internal static extern void SetPInvokeData(RuntimeModule module, String DllName, String name, int token, int linkFlags);
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-		[SuppressUnmanagedCodeSecurity]
         internal static extern int DefineProperty(RuntimeModule module, int tkParent, String name, PropertyAttributes attributes,
             byte[] signature, int sigLength);
 
@@ -270,42 +261,10 @@ namespace System.Reflection.Emit {
 
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
 		[SuppressUnmanagedCodeSecurity]
-        internal static extern void SetFieldMarshal(RuntimeModule module, int tk, byte[] ubMarshal, int ubSize);
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-		[SuppressUnmanagedCodeSecurity]
         private static extern unsafe void SetConstantValue(RuntimeModule module, int tk, int corType, void* pValue);
-        #endregion
 
-        #region Internal\Private Static Members
-        private static bool IsPublicComType(Type type)
-        {
-            // Internal Helper to determine if a type should be added to ComType table.
-            // A top level type should be added if it is Public.
-            // A nested type should be added if the top most enclosing type is Public 
-            //      and all the enclosing types are NestedPublic
-
-            Type enclosingType = type.DeclaringType;
-            if (enclosingType != null)
-            {
-                if (IsPublicComType(enclosingType))
-                {
-                    if ((type.Attributes & TypeAttributes.VisibilityMask) == TypeAttributes.NestedPublic)
-                    {
-                        return true;
-                    }
-                }
-            }
-            else
-            {
-                if ((type.Attributes & TypeAttributes.VisibilityMask) == TypeAttributes.Public)
-                {
-                    return true;
-                }
-            }
-
-            return false;
-        }
+#endregion
+#region Internal\Private Static Members
 
         [Pure]
         internal static bool IsTypeEqual(Type t1, Type t2)
@@ -656,105 +615,8 @@ namespace System.Reflection.Emit {
             m_module.AddType(FullName, this);
         }
 
-        #endregion
-
-        #region Private Members
-        private MethodBuilder DefinePInvokeMethodHelperNoLock(
-            String name, String dllName, String importName, MethodAttributes attributes, CallingConventions callingConvention, 
-            Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers,
-            Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers,
-            CallingConvention nativeCallConv, CharSet nativeCharSet)
-        {
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-
-            if (name.Length == 0)
-                throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), nameof(name));
-
-            if (dllName == null)
-                throw new ArgumentNullException(nameof(dllName));
-
-            if (dllName.Length == 0)
-                throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), nameof(dllName));
-
-            if (importName == null)
-                throw new ArgumentNullException(nameof(importName));
-
-            if (importName.Length == 0)
-                throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), nameof(importName));
-
-            if ((attributes & MethodAttributes.Abstract) != 0)
-                throw new ArgumentException(Environment.GetResourceString("Argument_BadPInvokeMethod"));
-            Contract.EndContractBlock();
-
-            if ((m_iAttr & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Interface)
-                throw new ArgumentException(Environment.GetResourceString("Argument_BadPInvokeOnInterface"));
-
-            ThrowIfCreated();
-
-            attributes = attributes | MethodAttributes.PinvokeImpl;
-            MethodBuilder method = new MethodBuilder(name, attributes, callingConvention, 
-                returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers,
-                parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers,
-                m_module, this, false);
-
-            //The signature grabbing code has to be up here or the signature won't be finished
-            //and our equals check won't work.
-            int sigLength;
-            byte[] sigBytes = method.GetMethodSignature().InternalGetSignature(out sigLength);
-
-            if (m_listMethods.Contains(method))
-            {
-                throw new ArgumentException(Environment.GetResourceString("Argument_MethodRedefined"));
-            }
-            m_listMethods.Add(method);
-
-            MethodToken token = method.GetToken();
-            
-            int linkFlags = 0;
-            switch(nativeCallConv)
-            {
-                case CallingConvention.Winapi:
-                    linkFlags =(int)PInvokeMap.CallConvWinapi;
-                    break;
-                case CallingConvention.Cdecl:
-                    linkFlags =(int)PInvokeMap.CallConvCdecl;
-                    break;
-                case CallingConvention.StdCall:
-                    linkFlags =(int)PInvokeMap.CallConvStdcall;
-                    break;
-                case CallingConvention.ThisCall:
-                    linkFlags =(int)PInvokeMap.CallConvThiscall;
-                    break;
-                case CallingConvention.FastCall:
-                    linkFlags =(int)PInvokeMap.CallConvFastcall;
-                    break;
-            }
-            switch(nativeCharSet)
-            {
-                case CharSet.None:
-                    linkFlags |=(int)PInvokeMap.CharSetNotSpec;
-                    break;
-                case CharSet.Ansi:
-                    linkFlags |=(int)PInvokeMap.CharSetAnsi;
-                    break;
-                case CharSet.Unicode:
-                    linkFlags |=(int)PInvokeMap.CharSetUnicode;
-                    break;
-                case CharSet.Auto:
-                    linkFlags |=(int)PInvokeMap.CharSetAuto;
-                    break;
-            }
-            
-            SetPInvokeData(m_module.GetNativeHandle(),
-                dllName,
-                importName,
-                token.Token,
-                linkFlags);
-            method.SetToken(token);
-
-            return method;
-        }
+#endregion
+#region Private Members
 
         private FieldBuilder DefineDataHelper(String name, byte[] data, int size, FieldAttributes attributes)
         {
@@ -1028,7 +890,6 @@ namespace System.Reflection.Emit {
             return m_bakedRuntimeType.GetConstructor(bindingAttr, binder, callConvention, types, modifiers);
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
         {
             if (!IsCreated())
@@ -1166,7 +1027,6 @@ namespace System.Reflection.Emit {
             return m_bakedRuntimeType.GetMember(name, type, bindingAttr);
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public override InterfaceMapping GetInterfaceMap(Type interfaceType)
         {
             if (!IsCreated())
@@ -1297,7 +1157,6 @@ namespace System.Reflection.Emit {
             get { return false; }
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         [Pure]
         public override bool IsSubclassOf(Type c)
         {
@@ -1620,7 +1479,6 @@ namespace System.Reflection.Emit {
         #endregion
 
         #region Define Constructor
-        [System.Runtime.InteropServices.ComVisible(true)]
         public ConstructorBuilder DefineTypeInitializer()
         {
             lock(SyncRoot)
@@ -1642,7 +1500,6 @@ namespace System.Reflection.Emit {
             return constBuilder;
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public ConstructorBuilder DefineDefaultConstructor(MethodAttributes attributes)
         {
             if ((m_iAttr & TypeAttributes.Interface) == TypeAttributes.Interface)
@@ -1710,13 +1567,11 @@ namespace System.Reflection.Emit {
             return constBuilder;
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public ConstructorBuilder DefineConstructor(MethodAttributes attributes, CallingConventions callingConvention, Type[] parameterTypes)
         {
             return DefineConstructor(attributes, callingConvention, parameterTypes, null, null);
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public ConstructorBuilder DefineConstructor(MethodAttributes attributes, CallingConventions callingConvention, 
             Type[] parameterTypes, Type[][] requiredCustomModifiers, Type[][] optionalCustomModifiers)
         {
@@ -1773,7 +1628,6 @@ namespace System.Reflection.Emit {
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public TypeBuilder DefineNestedType(String name, TypeAttributes attr, Type parent, Type[] interfaces)
         {
             lock(SyncRoot)
@@ -2286,7 +2140,6 @@ namespace System.Reflection.Emit {
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public void AddInterfaceImplementation(Type interfaceType)
         {
             if (interfaceType == null)
@@ -2317,7 +2170,6 @@ public TypeToken TypeToken
         }
 
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
         {
             if (con == null)
diff --git a/src/mscorlib/src/System/Reflection/Emit/TypeBuilderInstantiation.cs b/src/mscorlib/src/System/Reflection/Emit/TypeBuilderInstantiation.cs
index 3bae585953..da5a56ba28 100644
--- a/src/mscorlib/src/System/Reflection/Emit/TypeBuilderInstantiation.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/TypeBuilderInstantiation.cs
@@ -168,7 +168,6 @@ namespace System.Reflection.Emit
         }
         protected override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) { throw new NotSupportedException(); }
         
-        [System.Runtime.InteropServices.ComVisible(true)]
         public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr) { throw new NotSupportedException(); }
         protected override MethodInfo GetMethodImpl(String name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) { throw new NotSupportedException(); }
         public override MethodInfo[] GetMethods(BindingFlags bindingAttr) { throw new NotSupportedException(); }
@@ -184,7 +183,6 @@ namespace System.Reflection.Emit
         public override Type GetNestedType(String name, BindingFlags bindingAttr) { throw new NotSupportedException(); }
         public override MemberInfo[] GetMember(String name, MemberTypes type, BindingFlags bindingAttr) { throw new NotSupportedException(); }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public override InterfaceMapping GetInterfaceMap(Type interfaceType) { throw new NotSupportedException(); }
         public override EventInfo[] GetEvents(BindingFlags bindingAttr) { throw new NotSupportedException(); }
         public override MemberInfo[] GetMembers(BindingFlags bindingAttr) { throw new NotSupportedException(); }
@@ -222,7 +220,6 @@ namespace System.Reflection.Emit
         public override Type MakeGenericType(params Type[] inst) { throw new InvalidOperationException(Environment.GetResourceString("Arg_NotGenericTypeDefinition")); }
         public override bool IsAssignableFrom(Type c) { throw new NotSupportedException(); }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         [Pure]
         public override bool IsSubclassOf(Type c)
         {
diff --git a/src/mscorlib/src/System/Reflection/Emit/TypeToken.cs b/src/mscorlib/src/System/Reflection/Emit/TypeToken.cs
index e4289a6cbd..4fa851c529 100644
--- a/src/mscorlib/src/System/Reflection/Emit/TypeToken.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/TypeToken.cs
@@ -17,10 +17,8 @@ namespace System.Reflection.Emit {
     using System;
     using System.Reflection;
     using System.Threading;
-    using System.Security.Permissions;
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public struct TypeToken {
     
         public static readonly TypeToken Empty = new TypeToken();
diff --git a/src/mscorlib/src/System/Reflection/Emit/UnmanagedMarshal.cs b/src/mscorlib/src/System/Reflection/Emit/UnmanagedMarshal.cs
deleted file mode 100644
index 28e95e2456..0000000000
--- a/src/mscorlib/src/System/Reflection/Emit/UnmanagedMarshal.cs
+++ /dev/null
@@ -1,183 +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.
-
-namespace System.Reflection.Emit
-{
-    using System.Runtime.InteropServices;
-    using System;
-    using System.Security.Permissions;
-
-    // This class is describing the fieldmarshal.
-    [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    [Obsolete("An alternate API is available: Emit the MarshalAs custom attribute instead. http://go.microsoft.com/fwlink/?linkid=14202")]
-    public sealed class UnmanagedMarshal
-    {
-        /******************************
-[System.Runtime.InteropServices.ComVisible(true)]
-        * public static constructors. You can only construct
-        * UnmanagedMarshal using these static constructors. 
-        ******************************/
-        public static UnmanagedMarshal DefineUnmanagedMarshal(UnmanagedType unmanagedType)
-        {
-            if (unmanagedType == UnmanagedType.ByValTStr ||
-                unmanagedType == UnmanagedType.SafeArray ||
-                unmanagedType == UnmanagedType.CustomMarshaler ||
-                unmanagedType == UnmanagedType.ByValArray ||
-                unmanagedType == UnmanagedType.LPArray)
-            {
-                // not a simple native marshal
-                throw new ArgumentException(Environment.GetResourceString("Argument_NotASimpleNativeType"));
-            }
-            return new UnmanagedMarshal(unmanagedType, Guid.Empty, 0, (UnmanagedType) 0);
-        }
-        public static UnmanagedMarshal DefineByValTStr(int elemCount)
-        {
-            return new UnmanagedMarshal(UnmanagedType.ByValTStr, Guid.Empty, elemCount, (UnmanagedType) 0);
-        }
-  
-        public static UnmanagedMarshal DefineSafeArray(UnmanagedType elemType)
-        {
-            return new UnmanagedMarshal(UnmanagedType.SafeArray, Guid.Empty, 0, elemType);
-        }
-
-        public static UnmanagedMarshal DefineByValArray(int elemCount)
-        {
-            return new UnmanagedMarshal(UnmanagedType.ByValArray, Guid.Empty, elemCount, (UnmanagedType) 0);
-        }
-    
-        public static UnmanagedMarshal DefineLPArray(UnmanagedType elemType)
-        {
-            return new UnmanagedMarshal(UnmanagedType.LPArray, Guid.Empty, 0, elemType);
-        }
-    
- 
-         
-         
-        
-
-        // accessor function for the native type
-        public UnmanagedType GetUnmanagedType 
-        {
-            get { return m_unmanagedType; }
-        }
-    
-        public Guid IIDGuid 
-        {
-            get 
-            { 
-                if (m_unmanagedType == UnmanagedType.CustomMarshaler) 
-                    return m_guid; 
-
-                // throw exception here. There is Guid only if CustomMarshaler
-                throw new ArgumentException(Environment.GetResourceString("Argument_NotACustomMarshaler"));
-            }
-        }
-        public int ElementCount 
-        {
-            get 
-            { 
-                if (m_unmanagedType != UnmanagedType.ByValArray &&
-                    m_unmanagedType != UnmanagedType.ByValTStr) 
-                {
-                    // throw exception here. There is NumElement only if NativeTypeFixedArray
-                    throw new ArgumentException(Environment.GetResourceString("Argument_NoUnmanagedElementCount"));
-                }
-                return m_numElem;
-            } 
-        }
-        public UnmanagedType BaseType 
-        {
-            get 
-            { 
-                if (m_unmanagedType != UnmanagedType.LPArray && m_unmanagedType != UnmanagedType.SafeArray) 
-                {
-                    // throw exception here. There is NestedUnmanagedType only if LPArray or SafeArray
-                    throw new ArgumentException(Environment.GetResourceString("Argument_NoNestedMarshal"));
-                }
-                return m_baseType;
-            } 
-        }
-    
-        private UnmanagedMarshal(UnmanagedType unmanagedType, Guid guid, int numElem, UnmanagedType type)
-        {
-            m_unmanagedType = unmanagedType;
-            m_guid = guid;
-            m_numElem = numElem;
-            m_baseType = type;
-        }
-    
-        /************************
-        *
-        * Data member
-        *
-        *************************/
-        internal UnmanagedType       m_unmanagedType;
-        internal Guid                m_guid;
-        internal int                 m_numElem;
-        internal UnmanagedType       m_baseType;
-    
-    
-        /************************
-        * this function return the byte representation of the marshal info.
-        *************************/
-        internal byte[] InternalGetBytes()
-        {
-            byte[] buf;
-            if (m_unmanagedType == UnmanagedType.SafeArray || m_unmanagedType == UnmanagedType.LPArray)
-            {
-    
-                // syntax for NativeTypeSafeArray is 
-                // <SafeArray | LPArray> <base type>
-                //
-                int     cBuf = 2;
-                buf = new byte[cBuf];
-                buf[0] = (byte) (m_unmanagedType);
-                buf[1] = (byte) (m_baseType);
-                return buf;
-            }
-            else
-            if (m_unmanagedType == UnmanagedType.ByValArray || 
-                    m_unmanagedType == UnmanagedType.ByValTStr) 
-            {
-                // <ByValArray | ByValTStr> <encoded integer>
-                //
-                int     cBuf;
-                int     iBuf = 0;
-    
-                if (m_numElem <= 0x7f)
-                    cBuf = 1;
-                else if (m_numElem <= 0x3FFF)
-                    cBuf = 2;
-                else
-                    cBuf = 4;
-    
-                // the total buffer size is the one byte + encoded integer size 
-                cBuf = cBuf + 1;
-                buf = new byte[cBuf];
-    
-                
-                buf[iBuf++] = (byte) (m_unmanagedType);
-                if (m_numElem <= 0x7F) 
-                {
-                    buf[iBuf++] = (byte)(m_numElem & 0xFF);
-                } else if (m_numElem <= 0x3FFF) 
-                {
-                    buf[iBuf++] = (byte)((m_numElem >> 8) | 0x80);
-                    buf[iBuf++] = (byte)(m_numElem & 0xFF);
-                } else if (m_numElem <= 0x1FFFFFFF) 
-                {
-                    buf[iBuf++] = (byte)((m_numElem >> 24) | 0xC0);
-                    buf[iBuf++] = (byte)((m_numElem >> 16) & 0xFF);
-                    buf[iBuf++] = (byte)((m_numElem >> 8)  & 0xFF);
-                    buf[iBuf++] = (byte)((m_numElem)     & 0xFF);
-                }            
-                return buf;
-            }
-            buf = new byte[1];
-            buf[0] = (byte) (m_unmanagedType);
-            return buf;
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Reflection/Emit/XXXOnTypeBuilderInstantiation.cs b/src/mscorlib/src/System/Reflection/Emit/XXXOnTypeBuilderInstantiation.cs
index aaaffc0df6..ca0faf31ca 100644
--- a/src/mscorlib/src/System/Reflection/Emit/XXXOnTypeBuilderInstantiation.cs
+++ b/src/mscorlib/src/System/Reflection/Emit/XXXOnTypeBuilderInstantiation.cs
@@ -51,23 +51,7 @@ namespace System.Reflection.Emit
         public override Object[] GetCustomAttributes(bool inherit) { return m_method.GetCustomAttributes(inherit); } 
         public override Object[] GetCustomAttributes(Type attributeType, bool inherit) { return m_method.GetCustomAttributes(attributeType, inherit); }
         public override bool IsDefined(Type attributeType, bool inherit) { return m_method.IsDefined(attributeType, inherit); }
-        internal int MetadataTokenInternal
-        {
-            get
-            {
-                MethodBuilder mb = m_method as MethodBuilder;
-
-                if (mb != null)
-                    return mb.MetadataTokenInternal;
-                else
-                {
-                    Debug.Assert(m_method is RuntimeMethodInfo);
-                    return m_method.MetadataToken;
-                }
-            }
-        }
         public override Module Module { get { return m_method.Module; } }              
-        public new Type GetType() { return base.GetType(); }
         #endregion
 
         #region MethodBase Members
@@ -164,7 +148,6 @@ namespace System.Reflection.Emit
             }
         }
         public override Module Module { get { return m_ctor.Module; } }              
-        public new Type GetType() { return base.GetType(); }
         #endregion
 
         #region MethodBase Members
@@ -265,7 +248,6 @@ namespace System.Reflection.Emit
             }
         }
         public override Module Module { get { return m_field.Module; } }              
-        public new Type GetType() { return base.GetType(); }
         #endregion
 
         #region Public Abstract\Virtual Members
diff --git a/src/mscorlib/src/System/Reflection/EventAttributes.cs b/src/mscorlib/src/System/Reflection/EventAttributes.cs
index c0285652ff..4cc08f62d3 100644
--- a/src/mscorlib/src/System/Reflection/EventAttributes.cs
+++ b/src/mscorlib/src/System/Reflection/EventAttributes.cs
@@ -16,7 +16,6 @@ namespace System.Reflection {
     using System;
     [Serializable]
     [Flags]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum EventAttributes {
         None              =   0x0000,
             
diff --git a/src/mscorlib/src/System/Reflection/EventInfo.cs b/src/mscorlib/src/System/Reflection/EventInfo.cs
index 0eabb9d03a..9b529c2960 100644
--- a/src/mscorlib/src/System/Reflection/EventInfo.cs
+++ b/src/mscorlib/src/System/Reflection/EventInfo.cs
@@ -13,14 +13,10 @@ namespace System.Reflection
     using System.Runtime.InteropServices;
     using System.Runtime.Serialization;
     using System.Runtime.ConstrainedExecution;
-    using System.Security.Permissions;
     using RuntimeTypeCache = System.RuntimeType.RuntimeTypeCache;
 
     [Serializable]
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_EventInfo))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public abstract class EventInfo : MemberInfo, _EventInfo
+    public abstract class EventInfo : MemberInfo
     {
         #region Constructor
         protected EventInfo() { }
@@ -236,7 +232,6 @@ namespace System.Reflection
         #endregion
 
         #region Internal Members
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal override bool CacheEquals(object o)
         {
             RuntimeEventInfo m = o as RuntimeEventInfo;
diff --git a/src/mscorlib/src/System/Reflection/FieldAttributes.cs b/src/mscorlib/src/System/Reflection/FieldAttributes.cs
index 48c90a1a38..e49a0a45b1 100644
--- a/src/mscorlib/src/System/Reflection/FieldAttributes.cs
+++ b/src/mscorlib/src/System/Reflection/FieldAttributes.cs
@@ -8,7 +8,6 @@ namespace System.Reflection
     // This Enum matchs the CorFieldAttr defined in CorHdr.h
     [Serializable]
     [Flags()]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum FieldAttributes
     {
         // member access mask - Use this mask to retrieve accessibility information.
diff --git a/src/mscorlib/src/System/Reflection/FieldInfo.cs b/src/mscorlib/src/System/Reflection/FieldInfo.cs
index e61207a686..7b6517c2bb 100644
--- a/src/mscorlib/src/System/Reflection/FieldInfo.cs
+++ b/src/mscorlib/src/System/Reflection/FieldInfo.cs
@@ -16,15 +16,11 @@ namespace System.Reflection
     using System.Runtime.ConstrainedExecution;
     using System.Runtime.InteropServices;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     using System.Threading;
     using RuntimeTypeCache = System.RuntimeType.RuntimeTypeCache;
 
     [Serializable]
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_FieldInfo))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public abstract class FieldInfo : MemberInfo, _FieldInfo
+    public abstract class FieldInfo : MemberInfo
     {
         #region Static Members
         public static FieldInfo GetFieldFromHandle(RuntimeFieldHandle handle)
@@ -43,7 +39,6 @@ namespace System.Reflection
             return f;            
         }           
         
-        [System.Runtime.InteropServices.ComVisible(false)]
         public static FieldInfo GetFieldFromHandle(RuntimeFieldHandle handle, RuntimeTypeHandle declaringType)
         {
             if (handle.IsNullHandle())
@@ -454,7 +449,6 @@ namespace System.Reflection
             }
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal override bool CacheEquals(object o)
         {
             RtFieldInfo m = o as RtFieldInfo;
@@ -757,7 +751,6 @@ namespace System.Reflection
         #endregion
 
         #region Internal Members
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal override bool CacheEquals(object o)
         {
             MdFieldInfo m = o as MdFieldInfo;
diff --git a/src/mscorlib/src/System/Reflection/ICustomAttributeProvider.cs b/src/mscorlib/src/System/Reflection/ICustomAttributeProvider.cs
index 1fd361c889..faea91a81e 100644
--- a/src/mscorlib/src/System/Reflection/ICustomAttributeProvider.cs
+++ b/src/mscorlib/src/System/Reflection/ICustomAttributeProvider.cs
@@ -15,7 +15,6 @@ namespace System.Reflection {
     using System;
 
     // Interface does not need to be marked with the serializable attribute
-[System.Runtime.InteropServices.ComVisible(true)]
     public interface ICustomAttributeProvider
     {
 
diff --git a/src/mscorlib/src/System/Reflection/IReflect.cs b/src/mscorlib/src/System/Reflection/IReflect.cs
index 92ce3412fc..1c3c57613b 100644
--- a/src/mscorlib/src/System/Reflection/IReflect.cs
+++ b/src/mscorlib/src/System/Reflection/IReflect.cs
@@ -20,7 +20,6 @@ namespace System.Reflection {
     
     // Interface does not need to be marked with the serializable attribute
     [Guid("AFBF15E5-C37C-11d2-B88E-00A0C9B471B8")]
-[System.Runtime.InteropServices.ComVisible(true)]
     public interface IReflect
     {
         // Return the requested method if it is implemented by the Reflection object.  The
diff --git a/src/mscorlib/src/System/Reflection/InterfaceMapping.cs b/src/mscorlib/src/System/Reflection/InterfaceMapping.cs
index 488ef4484d..bf994f7b47 100644
--- a/src/mscorlib/src/System/Reflection/InterfaceMapping.cs
+++ b/src/mscorlib/src/System/Reflection/InterfaceMapping.cs
@@ -13,15 +13,10 @@
 namespace System.Reflection {
     using System;
 
-[System.Runtime.InteropServices.ComVisible(true)]
     public struct InterfaceMapping {
-[System.Runtime.InteropServices.ComVisible(true)]
         public Type                TargetType;            // The type implementing the interface
-[System.Runtime.InteropServices.ComVisible(true)]
         public Type                InterfaceType;        // The type representing the interface
-[System.Runtime.InteropServices.ComVisible(true)]
         public MethodInfo[]        TargetMethods;        // The methods implementing the interface
-[System.Runtime.InteropServices.ComVisible(true)]
         public MethodInfo[]        InterfaceMethods;    // The methods defined on the interface
     }
 }
diff --git a/src/mscorlib/src/System/Reflection/InvalidFilterCriteriaException.cs b/src/mscorlib/src/System/Reflection/InvalidFilterCriteriaException.cs
index fa95e37ad5..8b8c06d9cf 100644
--- a/src/mscorlib/src/System/Reflection/InvalidFilterCriteriaException.cs
+++ b/src/mscorlib/src/System/Reflection/InvalidFilterCriteriaException.cs
@@ -18,7 +18,6 @@ namespace System.Reflection {
     using System.Runtime.Serialization;
     using ApplicationException = System.ApplicationException;
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class InvalidFilterCriteriaException : ApplicationException {
         public InvalidFilterCriteriaException()
             : base(Environment.GetResourceString("Arg_InvalidFilterCriteriaException")) {
diff --git a/src/mscorlib/src/System/Reflection/ManifestResourceInfo.cs b/src/mscorlib/src/System/Reflection/ManifestResourceInfo.cs
index a53d32abdb..91c7ceb2ea 100644
--- a/src/mscorlib/src/System/Reflection/ManifestResourceInfo.cs
+++ b/src/mscorlib/src/System/Reflection/ManifestResourceInfo.cs
@@ -16,7 +16,6 @@
 namespace System.Reflection {
     using System;
     
-[System.Runtime.InteropServices.ComVisible(true)]
     public class ManifestResourceInfo {
         private Assembly _containingAssembly;
         private String _containingFileName;
@@ -57,7 +56,6 @@ namespace System.Reflection {
     // Linked means not Embedded.
 [Serializable]
     [Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum ResourceLocation
     {
         Embedded = 0x1,
diff --git a/src/mscorlib/src/System/Reflection/MdImport.cs b/src/mscorlib/src/System/Reflection/MdImport.cs
index dc6b726205..b1d9c5eae8 100644
--- a/src/mscorlib/src/System/Reflection/MdImport.cs
+++ b/src/mscorlib/src/System/Reflection/MdImport.cs
@@ -9,7 +9,6 @@ using System.Reflection;
 using System.Globalization;
 using System.Threading;
 using System.Diagnostics;
-using System.Security.Permissions;
 using System.Collections;
 using System.Runtime.CompilerServices;
 using System.Security;
diff --git a/src/mscorlib/src/System/Reflection/MemberFilter.cs b/src/mscorlib/src/System/Reflection/MemberFilter.cs
index b476409d5d..56fc9c0804 100644
--- a/src/mscorlib/src/System/Reflection/MemberFilter.cs
+++ b/src/mscorlib/src/System/Reflection/MemberFilter.cs
@@ -14,6 +14,5 @@ namespace System.Reflection {
 
     // Define the delegate
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public delegate bool MemberFilter(MemberInfo m, Object filterCriteria);
 }
diff --git a/src/mscorlib/src/System/Reflection/MemberInfo.cs b/src/mscorlib/src/System/Reflection/MemberInfo.cs
index 96a89ad37b..5ecbfe06a1 100644
--- a/src/mscorlib/src/System/Reflection/MemberInfo.cs
+++ b/src/mscorlib/src/System/Reflection/MemberInfo.cs
@@ -11,13 +11,9 @@ namespace System.Reflection
     using System.Diagnostics.Contracts;
     using System.Runtime;
     using System.Runtime.InteropServices;
-    using System.Security.Permissions;
 
     [Serializable]
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_MemberInfo))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public abstract class MemberInfo : ICustomAttributeProvider, _MemberInfo
+    public abstract class MemberInfo : ICustomAttributeProvider
     {
         #region Constructor
         protected MemberInfo() { }
diff --git a/src/mscorlib/src/System/Reflection/MemberTypes.cs b/src/mscorlib/src/System/Reflection/MemberTypes.cs
index 352a80244e..95c41022f1 100644
--- a/src/mscorlib/src/System/Reflection/MemberTypes.cs
+++ b/src/mscorlib/src/System/Reflection/MemberTypes.cs
@@ -17,7 +17,6 @@ namespace System.Reflection {
     // This Enum matchs the CorTypeAttr defined in CorHdr.h
     [Serializable]
     [Flags()]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum MemberTypes
     {
         // The following are the known classes which extend MemberInfo
diff --git a/src/mscorlib/src/System/Reflection/MethodAttributes.cs b/src/mscorlib/src/System/Reflection/MethodAttributes.cs
index 92b637b9c0..7e4391cccd 100644
--- a/src/mscorlib/src/System/Reflection/MethodAttributes.cs
+++ b/src/mscorlib/src/System/Reflection/MethodAttributes.cs
@@ -10,7 +10,6 @@ namespace System.Reflection
     using System;
     [Serializable]
     [Flags]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum MethodAttributes
     {
         // NOTE: This Enum matchs the CorMethodAttr defined in CorHdr.h
diff --git a/src/mscorlib/src/System/Reflection/MethodBase.cs b/src/mscorlib/src/System/Reflection/MethodBase.cs
index 8c77411eac..0d3de972a4 100644
--- a/src/mscorlib/src/System/Reflection/MethodBase.cs
+++ b/src/mscorlib/src/System/Reflection/MethodBase.cs
@@ -11,7 +11,6 @@ namespace System.Reflection
     using System.Globalization;
     using System.Runtime.CompilerServices;
     using System.Runtime.InteropServices;
-    using System.Security.Permissions;
     using System.Text;
     using System.Threading;
 
@@ -48,10 +47,7 @@ namespace System.Reflection
     }
 
     [Serializable]
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_MethodBase))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public abstract class MethodBase : MemberInfo, _MethodBase
+    public abstract class MethodBase : MemberInfo
     {
         #region Static Members
         public static MethodBase GetMethodFromHandle(RuntimeMethodHandle handle)
@@ -70,7 +66,6 @@ namespace System.Reflection
             return m;
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public static MethodBase GetMethodFromHandle(RuntimeMethodHandle handle, RuntimeTypeHandle declaringType)
         {
             if (handle.IsNullHandle())
@@ -79,8 +74,7 @@ namespace System.Reflection
             return RuntimeType.GetMethodBase(declaringType.GetRuntimeType(), handle.GetMethodInfo());
         }
 
-        [System.Security.DynamicSecurityMethod] // Specify DynamicSecurityMethod attribute to prevent inlining of the caller.
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static MethodBase GetCurrentMethod()
         {
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
@@ -131,20 +125,6 @@ namespace System.Reflection
         private IntPtr GetMethodDesc() { return MethodHandle.Value; }
 
 #if FEATURE_APPX
-
-        // The C# dynamic and VB late bound binders need to call this API. Since we don't have time to make this
-        // public in Dev11, the C# and VB binders currently call this through a delegate. 
-        // When we make this API public (hopefully) in Dev12 we need to change the C# and VB binders to call this
-        // probably statically. The code is located in:
-        // C#: ndp\fx\src\CSharp\Microsoft\CSharp\SymbolTable.cs - Microsoft.CSharp.RuntimeBinder.SymbolTable..cctor
-        // VB: vb\runtime\msvbalib\helpers\Symbols.vb - Microsoft.VisualBasic.CompilerServices.Symbols..cctor
-        internal virtual bool IsDynamicallyInvokable
-        {
-            get
-            {
-                return true;
-            }
-        }
 #endif
         #endregion
 
@@ -172,7 +152,6 @@ namespace System.Reflection
 
         public virtual CallingConventions CallingConvention { get { return CallingConventions.Standard; } }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public virtual Type[] GetGenericArguments() { throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride")); }
         
         public virtual bool IsGenericMethodDefinition { get { return false; } }
@@ -227,7 +206,6 @@ namespace System.Reflection
 
         public bool IsSpecialName { get { return(Attributes & MethodAttributes.SpecialName) != 0; } }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public bool IsConstructor 
         {
             get 
@@ -239,9 +217,6 @@ namespace System.Reflection
             }
         }
 
-#pragma warning disable 618
-        [ReflectionPermissionAttribute(SecurityAction.Demand, Flags=ReflectionPermissionFlag.MemberAccess)]            
-#pragma warning restore 618
         public virtual MethodBody GetMethodBody()
         {
             throw new InvalidOperationException();
diff --git a/src/mscorlib/src/System/Reflection/MethodBody.cs b/src/mscorlib/src/System/Reflection/MethodBody.cs
index 4634623e26..7cbaeaf9b9 100644
--- a/src/mscorlib/src/System/Reflection/MethodBody.cs
+++ b/src/mscorlib/src/System/Reflection/MethodBody.cs
@@ -13,7 +13,6 @@ using System.Diagnostics.Contracts;
 namespace System.Reflection
 {   
     [Flags()]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum ExceptionHandlingClauseOptions: int
     {
         Clause = 0x0,
@@ -22,7 +21,6 @@ namespace System.Reflection
         Fault = 0x4,
     }
     
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class ExceptionHandlingClause
     {
         #region costructor
@@ -107,7 +105,6 @@ namespace System.Reflection
         #endregion
     }
     
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class MethodBody
     {
         #region costructor
@@ -135,7 +132,6 @@ namespace System.Reflection
         #endregion
     }   
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class LocalVariableInfo
     {
         #region Private Data Members
diff --git a/src/mscorlib/src/System/Reflection/MethodImplAttributes.cs b/src/mscorlib/src/System/Reflection/MethodImplAttributes.cs
index 0fa4d00f19..1bd6b9dbd1 100644
--- a/src/mscorlib/src/System/Reflection/MethodImplAttributes.cs
+++ b/src/mscorlib/src/System/Reflection/MethodImplAttributes.cs
@@ -10,7 +10,6 @@ namespace System.Reflection
     using System;
     // This Enum matchs the CorMethodImpl defined in CorHdr.h
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum MethodImplAttributes
     {
         // code impl mask
@@ -36,7 +35,6 @@ namespace System.Reflection
     
         Synchronized       =   0x0020,   // Method is single threaded through the body.
         NoInlining         =   0x0008,   // Method may not be inlined.
-        [System.Runtime.InteropServices.ComVisible(false)]
         AggressiveInlining =   0x0100,   // Method should be inlined if possible.
         NoOptimization     =   0x0040,   // Method may not be optimized.
 
diff --git a/src/mscorlib/src/System/Reflection/MethodInfo.cs b/src/mscorlib/src/System/Reflection/MethodInfo.cs
index 39387b1f8f..06c661a157 100644
--- a/src/mscorlib/src/System/Reflection/MethodInfo.cs
+++ b/src/mscorlib/src/System/Reflection/MethodInfo.cs
@@ -16,7 +16,6 @@ namespace System.Reflection
     using System.Runtime.ConstrainedExecution;
     using System.Runtime.Serialization;
     using System.Security;
-    using System.Security.Permissions;
     using System.Text;
     using System.Threading;
     using MemberListType = System.RuntimeType.MemberListType;
@@ -24,10 +23,7 @@ namespace System.Reflection
     using System.Runtime.CompilerServices;
 
     [Serializable]
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_MethodInfo))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public abstract class MethodInfo : MethodBase, _MethodInfo
+    public abstract class MethodInfo : MethodBase
     {
         #region Constructor
         protected MethodInfo() { }
@@ -74,10 +70,8 @@ namespace System.Reflection
 
         public abstract MethodInfo GetBaseDefinition();
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public override Type[] GetGenericArguments() { throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride")); }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public virtual MethodInfo GetGenericMethodDefinition() { throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride")); }
 
         public virtual MethodInfo MakeGenericMethod(params Type[] typeArguments) { throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride")); }
@@ -133,14 +127,6 @@ namespace System.Reflection
 
             return false;
         }
-
-        internal override bool IsDynamicallyInvokable
-        {
-            get
-            {
-                return !AppDomain.ProfileAPICheck || !IsNonW8PFrameworkAPI();
-            }
-        }
 #endif
 
         internal INVOCATION_FLAGS InvocationFlags
@@ -279,7 +265,6 @@ namespace System.Reflection
             return sbName.ToString();
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal override bool CacheEquals(object o) 
         { 
             RuntimeMethodInfo m = o as RuntimeMethodInfo;
@@ -303,12 +288,6 @@ namespace System.Reflection
 
         internal BindingFlags BindingFlags { get { return m_bindingFlags; } }
 
-        // Differs from MethodHandle in that it will return a valid handle even for reflection only loaded types
-        internal RuntimeMethodHandle GetMethodHandle()
-        {
-            return new RuntimeMethodHandle(this);
-        }
-
         internal RuntimeMethodInfo GetParentDefinition()
         {
             if (!IsVirtual || m_declaringType.IsInterface)
@@ -522,14 +501,6 @@ namespace System.Reflection
             return RuntimeMethodHandle.GetImplAttributes(this);
         }
 
-        internal bool IsOverloaded
-        {
-            get 
-            {
-                return m_reflectedTypeCache.GetMethodList(MemberListType.CaseSensitive, Name).Length > 1;
-            }
-        }
-
         public override RuntimeMethodHandle MethodHandle 
         { 
             get 
@@ -615,7 +586,7 @@ namespace System.Reflection
         
         [DebuggerStepThroughAttribute]
         [Diagnostics.DebuggerHidden]
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public override Object Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
         {
             object[] arguments = InvokeArgumentsCheck(obj, invokeAttr, binder, parameters, culture);
diff --git a/src/mscorlib/src/System/Reflection/Missing.cs b/src/mscorlib/src/System/Reflection/Missing.cs
index 24bf77bd4e..f62c5b538c 100644
--- a/src/mscorlib/src/System/Reflection/Missing.cs
+++ b/src/mscorlib/src/System/Reflection/Missing.cs
@@ -9,12 +9,10 @@ namespace System.Reflection
     using System;
     using System.Runtime.Remoting;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     using System.Diagnostics.Contracts;
 
     // This is not serializable because it is a reflection command.
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class Missing : ISerializable
     {
         public static readonly Missing Value = new Missing();
diff --git a/src/mscorlib/src/System/Reflection/Module.cs b/src/mscorlib/src/System/Reflection/Module.cs
index b6be38e434..bdf95fca26 100644
--- a/src/mscorlib/src/System/Reflection/Module.cs
+++ b/src/mscorlib/src/System/Reflection/Module.cs
@@ -17,7 +17,6 @@ namespace System.Reflection
     using System.Threading;
     using System.Runtime.CompilerServices;
     using System.Security;
-    using System.Security.Permissions;
     using System.IO;
     using System.Globalization;
     using System.Runtime.Versioning;
@@ -25,7 +24,6 @@ namespace System.Reflection
 
     [Serializable]
     [Flags] 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum PortableExecutableKinds 
     {
         NotAPortableExecutableImage = 0x0,
@@ -38,12 +36,10 @@ namespace System.Reflection
         
         Unmanaged32Bit              = 0x8,
 
-        [ComVisible(false)]
         Preferred32Bit              = 0x10,
     }
     
     [Serializable] 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum ImageFileMachine 
     {
         I386    = 0x014c,
@@ -56,10 +52,7 @@ namespace System.Reflection
     }
 
     [Serializable]
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_Module))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public abstract class Module : _Module, ISerializable, ICustomAttributeProvider
+    public abstract class Module : ISerializable, ICustomAttributeProvider
     {   
         #region Static Constructor
         static Module()
@@ -276,18 +269,15 @@ namespace System.Reflection
             throw new NotImplementedException();
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public virtual Type GetType(String className, bool ignoreCase)
         {
             return GetType(className, false, ignoreCase);
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public virtual Type GetType(String className) {
             return GetType(className, false, false);
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public virtual Type GetType(String className, bool throwOnError, bool ignoreCase)
         {
             throw new NotImplementedException();
@@ -983,7 +973,6 @@ namespace System.Reflection
             UnitySerializationHolder.GetUnitySerializationInfo(info, UnitySerializationHolder.ModuleUnity, this.ScopeName, this.GetRuntimeAssembly());
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public override Type GetType(String className, bool throwOnError, bool ignoreCase)
         {
             // throw on null strings regardless of the value of "throwOnError"
@@ -1008,22 +997,7 @@ namespace System.Reflection
         {
             get
             {
-                String fullyQualifiedName = GetFullyQualifiedName();
-                
-                if (fullyQualifiedName != null) {
-                    bool checkPermission = true;
-                    try {
-                        Path.GetFullPath(fullyQualifiedName);
-                    }
-                    catch(ArgumentException) {
-                        checkPermission = false;
-                    }
-                    if (checkPermission) {
-                        new FileIOPermission( FileIOPermissionAccess.PathDiscovery, fullyQualifiedName ).Demand();
-                    }
-                }
-
-                return fullyQualifiedName;
+                return GetFullyQualifiedName();
             }
         }
 
diff --git a/src/mscorlib/src/System/Reflection/ObfuscateAssemblyAttribute.cs b/src/mscorlib/src/System/Reflection/ObfuscateAssemblyAttribute.cs
index b852e5a4c2..787f37bced 100644
--- a/src/mscorlib/src/System/Reflection/ObfuscateAssemblyAttribute.cs
+++ b/src/mscorlib/src/System/Reflection/ObfuscateAssemblyAttribute.cs
@@ -11,7 +11,6 @@ using System.Reflection;
 namespace System.Reflection
 {
     [AttributeUsage (AttributeTargets.Assembly, AllowMultiple=false, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class ObfuscateAssemblyAttribute : Attribute
     {
         private bool m_assemblyIsPrivate;
diff --git a/src/mscorlib/src/System/Reflection/ObfuscationAttribute.cs b/src/mscorlib/src/System/Reflection/ObfuscationAttribute.cs
index 0b987ce06d..c7c7c18550 100644
--- a/src/mscorlib/src/System/Reflection/ObfuscationAttribute.cs
+++ b/src/mscorlib/src/System/Reflection/ObfuscationAttribute.cs
@@ -11,7 +11,6 @@ namespace System.Reflection
 {
     [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Enum | AttributeTargets.Delegate,
         AllowMultiple = true, Inherited = false)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class ObfuscationAttribute: Attribute
     {
         private bool m_strip = true;
diff --git a/src/mscorlib/src/System/Reflection/ParameterAttributes.cs b/src/mscorlib/src/System/Reflection/ParameterAttributes.cs
index 12f8145ddd..acae3a6ec1 100644
--- a/src/mscorlib/src/System/Reflection/ParameterAttributes.cs
+++ b/src/mscorlib/src/System/Reflection/ParameterAttributes.cs
@@ -16,7 +16,6 @@ namespace System.Reflection {
     // This Enum matchs the CorParamAttr defined in CorHdr.h
 [Serializable]
     [Flags]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum ParameterAttributes
     {
         None      =   0x0000,      // no flag is specified
diff --git a/src/mscorlib/src/System/Reflection/ParameterInfo.cs b/src/mscorlib/src/System/Reflection/ParameterInfo.cs
index 6592e5aa20..fad4402aff 100644
--- a/src/mscorlib/src/System/Reflection/ParameterInfo.cs
+++ b/src/mscorlib/src/System/Reflection/ParameterInfo.cs
@@ -13,15 +13,11 @@ namespace System.Reflection
     using System.Runtime.InteropServices;
     using System.Runtime.Serialization;
     using System.Runtime.CompilerServices;
-    using System.Security.Permissions;
     using System.Threading;
     using MdToken = System.Reflection.MetadataToken;
 
     [Serializable]
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_ParameterInfo))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public class ParameterInfo : _ParameterInfo, ICustomAttributeProvider, IObjectReference
+    public class ParameterInfo : ICustomAttributeProvider, IObjectReference
     {
         #region Legacy Protected Members
         protected String NameImpl; 
diff --git a/src/mscorlib/src/System/Reflection/ParameterModifier.cs b/src/mscorlib/src/System/Reflection/ParameterModifier.cs
index 97da1b9e00..a2bfeab934 100644
--- a/src/mscorlib/src/System/Reflection/ParameterModifier.cs
+++ b/src/mscorlib/src/System/Reflection/ParameterModifier.cs
@@ -7,7 +7,6 @@ namespace System.Reflection
     using System;
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public struct ParameterModifier 
     {
         #region Private Data Members
diff --git a/src/mscorlib/src/System/Reflection/Pointer.cs b/src/mscorlib/src/System/Reflection/Pointer.cs
index 95025b20ed..9f1a38366a 100644
--- a/src/mscorlib/src/System/Reflection/Pointer.cs
+++ b/src/mscorlib/src/System/Reflection/Pointer.cs
@@ -19,7 +19,6 @@ namespace System.Reflection {
 
     [CLSCompliant(false)]
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class Pointer : ISerializable
     {
         unsafe private void* _ptr;
diff --git a/src/mscorlib/src/System/Reflection/PropertyAttributes.cs b/src/mscorlib/src/System/Reflection/PropertyAttributes.cs
index d7c3d79b6a..4a5617ba5e 100644
--- a/src/mscorlib/src/System/Reflection/PropertyAttributes.cs
+++ b/src/mscorlib/src/System/Reflection/PropertyAttributes.cs
@@ -16,7 +16,6 @@ namespace System.Reflection {
     // This Enum matchs the CorPropertyAttr defined in CorHdr.h
 [Serializable]
 [Flags]  
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum PropertyAttributes
     {
         None            =   0x0000,
diff --git a/src/mscorlib/src/System/Reflection/PropertyInfo.cs b/src/mscorlib/src/System/Reflection/PropertyInfo.cs
index e31b378924..e8c2837785 100644
--- a/src/mscorlib/src/System/Reflection/PropertyInfo.cs
+++ b/src/mscorlib/src/System/Reflection/PropertyInfo.cs
@@ -15,15 +15,11 @@ namespace System.Reflection
     using System.Runtime.ConstrainedExecution;
     using System.Runtime.InteropServices;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     using System.Text;
     using RuntimeTypeCache = System.RuntimeType.RuntimeTypeCache;
 
     [Serializable]
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_PropertyInfo))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public abstract class PropertyInfo : MemberInfo, _PropertyInfo
+    public abstract class PropertyInfo : MemberInfo
     {
         #region Constructor
         protected PropertyInfo() { }
@@ -196,7 +192,6 @@ namespace System.Reflection
         #endregion
 
         #region Internal Members
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal override bool CacheEquals(object o)
         {
             RuntimePropertyInfo m = o as RuntimePropertyInfo;
diff --git a/src/mscorlib/src/System/Reflection/ReflectionTypeLoadException.cs b/src/mscorlib/src/System/Reflection/ReflectionTypeLoadException.cs
index 70681138c5..cccf060645 100644
--- a/src/mscorlib/src/System/Reflection/ReflectionTypeLoadException.cs
+++ b/src/mscorlib/src/System/Reflection/ReflectionTypeLoadException.cs
@@ -19,10 +19,8 @@ namespace System.Reflection {
     
     using System;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     using System.Diagnostics.Contracts;
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class ReflectionTypeLoadException : SystemException, ISerializable {
         private Type[] _classes;
         private Exception[] _exceptions;
@@ -33,11 +31,6 @@ namespace System.Reflection {
             SetErrorCode(__HResults.COR_E_REFLECTIONTYPELOAD);
         }
 
-        // private constructor.  This is called from inside the runtime.
-        private ReflectionTypeLoadException(String message) : base(message) {
-            SetErrorCode(__HResults.COR_E_REFLECTIONTYPELOAD);
-        }
-
         public ReflectionTypeLoadException(Type[] classes, Exception[] exceptions) : base(null)
         {
             _classes = classes;
diff --git a/src/mscorlib/src/System/Reflection/ResourceAttributes.cs b/src/mscorlib/src/System/Reflection/ResourceAttributes.cs
index 646572677f..5c419ebb2d 100644
--- a/src/mscorlib/src/System/Reflection/ResourceAttributes.cs
+++ b/src/mscorlib/src/System/Reflection/ResourceAttributes.cs
@@ -15,7 +15,6 @@ namespace System.Reflection {
     using System;
 [Serializable]
 [Flags]  
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum ResourceAttributes
     {
         Public          =   0x0001,
diff --git a/src/mscorlib/src/System/Reflection/StrongNameKeyPair.cs b/src/mscorlib/src/System/Reflection/StrongNameKeyPair.cs
index 8107cf4159..0121982489 100644
--- a/src/mscorlib/src/System/Reflection/StrongNameKeyPair.cs
+++ b/src/mscorlib/src/System/Reflection/StrongNameKeyPair.cs
@@ -22,13 +22,11 @@ namespace System.Reflection
     using System.Runtime.InteropServices;
     using System.Runtime.Serialization;
     using System.Security;
-    using System.Security.Permissions;
     using System.Runtime.Versioning;
     using Microsoft.Win32;
     using System.Diagnostics.Contracts;
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class StrongNameKeyPair : IDeserializationCallback, ISerializable 
     {
         private bool    _keyPairExported;
diff --git a/src/mscorlib/src/System/Reflection/TargetException.cs b/src/mscorlib/src/System/Reflection/TargetException.cs
index 9c56c121cc..dcbb38833e 100644
--- a/src/mscorlib/src/System/Reflection/TargetException.cs
+++ b/src/mscorlib/src/System/Reflection/TargetException.cs
@@ -18,7 +18,6 @@ namespace System.Reflection {
     using System;
     using System.Runtime.Serialization;
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class TargetException : ApplicationException {
         public TargetException() : base() {
             SetErrorCode(__HResults.COR_E_TARGET);
diff --git a/src/mscorlib/src/System/Reflection/TargetInvocationException.cs b/src/mscorlib/src/System/Reflection/TargetInvocationException.cs
index 4a32ed245d..7bbc93df2a 100644
--- a/src/mscorlib/src/System/Reflection/TargetInvocationException.cs
+++ b/src/mscorlib/src/System/Reflection/TargetInvocationException.cs
@@ -18,7 +18,6 @@ namespace System.Reflection {
     using System;
     using System.Runtime.Serialization;
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class TargetInvocationException : ApplicationException {
         // This exception is not creatable without specifying the
         //    inner exception.
diff --git a/src/mscorlib/src/System/Reflection/TargetParameterCountException.cs b/src/mscorlib/src/System/Reflection/TargetParameterCountException.cs
index 846732b449..7a07b20acd 100644
--- a/src/mscorlib/src/System/Reflection/TargetParameterCountException.cs
+++ b/src/mscorlib/src/System/Reflection/TargetParameterCountException.cs
@@ -18,7 +18,6 @@ namespace System.Reflection {
     using SystemException = System.SystemException;
     using System.Runtime.Serialization;
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class TargetParameterCountException : ApplicationException {
         public TargetParameterCountException()
             : base(Environment.GetResourceString("Arg_TargetParameterCountException")) {
diff --git a/src/mscorlib/src/System/Reflection/TypeAttributes.cs b/src/mscorlib/src/System/Reflection/TypeAttributes.cs
index 4fa6fb06ba..25aa113d2e 100644
--- a/src/mscorlib/src/System/Reflection/TypeAttributes.cs
+++ b/src/mscorlib/src/System/Reflection/TypeAttributes.cs
@@ -8,7 +8,6 @@ namespace System.Reflection {
     // This Enum matchs the CorTypeAttr defined in CorHdr.h
 [Serializable]
 [Flags] 
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum TypeAttributes
     {
         VisibilityMask    =   0x00000007,
@@ -43,7 +42,6 @@ namespace System.Reflection {
         Import            =   0x00001000,     // Class / interface is imported
         Serializable      =   0x00002000,     // The class is Serializable.
 
-        [ComVisible(false)]
         WindowsRuntime    =   0x00004000,     // Type is a Windows Runtime type.
 
         // Use tdStringFormatMask to retrieve string information for native interop
diff --git a/src/mscorlib/src/System/Reflection/TypeDelegator.cs b/src/mscorlib/src/System/Reflection/TypeDelegator.cs
index d715df8950..6a77a95853 100644
--- a/src/mscorlib/src/System/Reflection/TypeDelegator.cs
+++ b/src/mscorlib/src/System/Reflection/TypeDelegator.cs
@@ -14,7 +14,6 @@ namespace System.Reflection {
     using CultureInfo = System.Globalization.CultureInfo;
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public class TypeDelegator : TypeInfo
     {
         public override bool IsAssignableFrom(System.Reflection.TypeInfo typeInfo){
@@ -86,7 +85,6 @@ namespace System.Reflection {
             return typeImpl.GetConstructor(bindingAttr,binder,callConvention,types,modifiers);
         }
         
-[System.Runtime.InteropServices.ComVisible(true)]
         public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
         {
             return typeImpl.GetConstructors(bindingAttr);
@@ -251,7 +249,6 @@ namespace System.Reflection {
             return typeImpl.IsDefined(attributeType, inherit);
         }
 
-[System.Runtime.InteropServices.ComVisible(true)]
         public override InterfaceMapping GetInterfaceMap(Type interfaceType)
         {
             return typeImpl.GetInterfaceMap(interfaceType);
diff --git a/src/mscorlib/src/System/Reflection/TypeFilter.cs b/src/mscorlib/src/System/Reflection/TypeFilter.cs
index 560618ff79..4837a303a1 100644
--- a/src/mscorlib/src/System/Reflection/TypeFilter.cs
+++ b/src/mscorlib/src/System/Reflection/TypeFilter.cs
@@ -14,6 +14,5 @@ namespace System.Reflection {
 
     // Define the delegate
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public delegate bool TypeFilter(Type m, Object filterCriteria);
 }
diff --git a/src/mscorlib/src/System/Reflection/TypeInfo.cs b/src/mscorlib/src/System/Reflection/TypeInfo.cs
index 706fb0a61a..61d7bb27a9 100644
--- a/src/mscorlib/src/System/Reflection/TypeInfo.cs
+++ b/src/mscorlib/src/System/Reflection/TypeInfo.cs
@@ -22,7 +22,6 @@ namespace System.Reflection
 
     //all today's runtime Type derivations derive now from TypeInfo
     //we make TypeInfo implement IRCT - simplifies work
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public abstract class TypeInfo:Type,IReflectableType
     {
diff --git a/src/mscorlib/src/System/Resources/FileBasedResourceGroveler.cs b/src/mscorlib/src/System/Resources/FileBasedResourceGroveler.cs
index 76bf0008f9..c5e92165f1 100644
--- a/src/mscorlib/src/System/Resources/FileBasedResourceGroveler.cs
+++ b/src/mscorlib/src/System/Resources/FileBasedResourceGroveler.cs
@@ -47,36 +47,28 @@ namespace System.Resources {
             ResourceSet rs = null;
 
             // Don't use Assembly manifest, but grovel on disk for a file.
-            try
-            {
-                new System.Security.Permissions.FileIOPermission(System.Security.Permissions.PermissionState.Unrestricted).Assert();
 
-                // Create new ResourceSet, if a file exists on disk for it.
-                String tempFileName = _mediator.GetResourceFileName(culture);
-                fileName = FindResourceFile(culture, tempFileName);
-                if (fileName == null)
+            // Create new ResourceSet, if a file exists on disk for it.
+            String tempFileName = _mediator.GetResourceFileName(culture);
+            fileName = FindResourceFile(culture, tempFileName);
+            if (fileName == null)
+            {
+                if (tryParents)
                 {
-                    if (tryParents)
+                    // If we've hit top of the Culture tree, return.
+                    if (culture.HasInvariantCultureName)
                     {
-                        // If we've hit top of the Culture tree, return.
-                        if (culture.HasInvariantCultureName)
-                        {
-                            // We really don't think this should happen - we always
-                            // expect the neutral locale's resources to be present.
-                            throw new MissingManifestResourceException(Environment.GetResourceString("MissingManifestResource_NoNeutralDisk") + Environment.NewLine + "baseName: " + _mediator.BaseNameField + "  locationInfo: " + (_mediator.LocationInfo == null ? "<null>" : _mediator.LocationInfo.FullName) + "  fileName: " + _mediator.GetResourceFileName(culture));
-                        }
+                        // We really don't think this should happen - we always
+                        // expect the neutral locale's resources to be present.
+                        throw new MissingManifestResourceException(Environment.GetResourceString("MissingManifestResource_NoNeutralDisk") + Environment.NewLine + "baseName: " + _mediator.BaseNameField + "  locationInfo: " + (_mediator.LocationInfo == null ? "<null>" : _mediator.LocationInfo.FullName) + "  fileName: " + _mediator.GetResourceFileName(culture));
                     }
                 }
-                else
-                {
-                    rs = CreateResourceSet(fileName);
-                }
-                return rs;
             }
-            finally
+            else
             {
-                System.Security.CodeAccessPermission.RevertAssert();
+                rs = CreateResourceSet(fileName);
             }
+            return rs;
         }
 
         // Given a CultureInfo, it generates the path &; file name for 
diff --git a/src/mscorlib/src/System/Resources/IResourceReader.cs b/src/mscorlib/src/System/Resources/IResourceReader.cs
index 7ab25ec1a0..de8f9db18e 100644
--- a/src/mscorlib/src/System/Resources/IResourceReader.cs
+++ b/src/mscorlib/src/System/Resources/IResourceReader.cs
@@ -17,7 +17,6 @@ namespace System.Resources {
     using System.IO;
     using System.Collections;
     
-    [System.Runtime.InteropServices.ComVisible(true)]
     public interface IResourceReader : IEnumerable, IDisposable
     {
         // Interface does not need to be marked with the serializable attribute
diff --git a/src/mscorlib/src/System/Resources/IResourceWriter.cs b/src/mscorlib/src/System/Resources/IResourceWriter.cs
deleted file mode 100644
index ae41b84cd7..0000000000
--- a/src/mscorlib/src/System/Resources/IResourceWriter.cs
+++ /dev/null
@@ -1,45 +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: Default way to write strings to a COM+ resource 
-** file.
-**
-** 
-===========================================================*/
-namespace System.Resources {
-    using System;
-    using System.IO;
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface IResourceWriter : IDisposable
-    {
-        // Interface does not need to be marked with the serializable attribute
-        // Adds a string resource to the list of resources to be written to a file.
-        // They aren't written until WriteFile() is called.
-        // 
-        void AddResource(String name, String value);
-    
-        // Adds a resource to the list of resources to be written to a file.
-        // They aren't written until WriteFile() is called.
-        // 
-        void AddResource(String name, Object value);
-    
-        // Adds a named byte array as a resource to the list of resources to 
-        // be written to a file. They aren't written until WriteFile() is called.
-        // 
-        void AddResource(String name, byte[] value);
-    
-        // Closes the underlying resource file.
-        void Close();
-
-        // After calling AddResource, this writes all resources to the output
-        // stream.  This does NOT close the output stream.
-        void Generate();
-    }
-}
diff --git a/src/mscorlib/src/System/Resources/LooselyLinkedResourceReference.cs b/src/mscorlib/src/System/Resources/LooselyLinkedResourceReference.cs
index 15a076bc5c..9287ae4590 100644
--- a/src/mscorlib/src/System/Resources/LooselyLinkedResourceReference.cs
+++ b/src/mscorlib/src/System/Resources/LooselyLinkedResourceReference.cs
@@ -28,7 +28,6 @@ namespace System.Resources {
 
     [Serializable]
 
-[System.Runtime.InteropServices.ComVisible(true)]
     public struct LooselyLinkedResourceReference {
         private String _manifestResourceName;
         private String _typeName;
diff --git a/src/mscorlib/src/System/Resources/ManifestBasedResourceGroveler.cs b/src/mscorlib/src/System/Resources/ManifestBasedResourceGroveler.cs
index 78e961a7f9..39bd5062e4 100644
--- a/src/mscorlib/src/System/Resources/ManifestBasedResourceGroveler.cs
+++ b/src/mscorlib/src/System/Resources/ManifestBasedResourceGroveler.cs
@@ -52,7 +52,6 @@ namespace System.Resources {
             _mediator = mediator;
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable
         public ResourceSet GrovelForResourceSet(CultureInfo culture, Dictionary<String, ResourceSet> localResourceSets, bool tryParents, bool createIfNotExists, ref StackCrawlMark stackMark)
         {
             Debug.Assert(culture != null, "culture shouldn't be null; check caller");
@@ -362,7 +361,7 @@ namespace System.Resources {
         // case-insensitive lookup rules.  Yes, this is slow.  The metadata
         // dev lead refuses to make all assembly manifest resource lookups case-insensitive,
         // even optionally case-insensitive.        
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         private Stream CaseInsensitiveManifestResourceStreamLookup(RuntimeAssembly satellite, String name)
         {
             Contract.Requires(satellite != null, "satellite shouldn't be null; check caller");
@@ -412,7 +411,6 @@ namespace System.Resources {
             return satellite.GetManifestResourceStream(canonicalName, ref stackMark, canSkipSecurityCheck);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable
         private RuntimeAssembly GetSatelliteAssembly(CultureInfo lookForCulture, ref StackCrawlMark stackMark)
         {
             if (!_mediator.LookedForSatelliteContractVersion)
diff --git a/src/mscorlib/src/System/Resources/MissingManifestResourceException.cs b/src/mscorlib/src/System/Resources/MissingManifestResourceException.cs
index e616bfe68b..2e82f19c7b 100644
--- a/src/mscorlib/src/System/Resources/MissingManifestResourceException.cs
+++ b/src/mscorlib/src/System/Resources/MissingManifestResourceException.cs
@@ -18,7 +18,6 @@ using System.Runtime.Serialization;
 
 namespace System.Resources {
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class MissingManifestResourceException : SystemException
     {
         public MissingManifestResourceException() 
diff --git a/src/mscorlib/src/System/Resources/MissingSatelliteAssemblyException.cs b/src/mscorlib/src/System/Resources/MissingSatelliteAssemblyException.cs
index 3d59f856b1..fc676a8dd5 100644
--- a/src/mscorlib/src/System/Resources/MissingSatelliteAssemblyException.cs
+++ b/src/mscorlib/src/System/Resources/MissingSatelliteAssemblyException.cs
@@ -20,7 +20,6 @@ using System.Runtime.Serialization;
 
 namespace System.Resources {
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class MissingSatelliteAssemblyException : SystemException
     {
         private String _cultureName;
diff --git a/src/mscorlib/src/System/Resources/NeutralResourcesLanguageAttribute.cs b/src/mscorlib/src/System/Resources/NeutralResourcesLanguageAttribute.cs
index 6517a56b6a..a2ed6fbd57 100644
--- a/src/mscorlib/src/System/Resources/NeutralResourcesLanguageAttribute.cs
+++ b/src/mscorlib/src/System/Resources/NeutralResourcesLanguageAttribute.cs
@@ -26,7 +26,6 @@ namespace System.Resources {
     using System.Diagnostics.Contracts;
     
     [AttributeUsage(AttributeTargets.Assembly, AllowMultiple=false)]  
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class NeutralResourcesLanguageAttribute : Attribute 
     {
         private String _culture;
diff --git a/src/mscorlib/src/System/Resources/ResourceManager.cs b/src/mscorlib/src/System/Resources/ResourceManager.cs
index 5c521e1130..a672f45e22 100644
--- a/src/mscorlib/src/System/Resources/ResourceManager.cs
+++ b/src/mscorlib/src/System/Resources/ResourceManager.cs
@@ -23,7 +23,6 @@ namespace System.Resources {
     using System.Reflection;
     using System.Runtime.Serialization;
     using System.Security;
-    using System.Security.Permissions;
     using System.Threading;
     using System.Runtime.InteropServices;
     using System.Runtime.CompilerServices;
@@ -149,7 +148,6 @@ namespace System.Resources {
     //
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class ResourceManager
     {
 
@@ -162,7 +160,7 @@ namespace System.Resources {
         // Sets is a many-to-one table of CultureInfos mapped to ResourceSets.
         // Don't synchronize ResourceSets - too fine-grained a lock to be effective
         [Obsolete("call InternalGetResourceSet instead")]
-        protected Hashtable ResourceSets;
+        internal Hashtable ResourceSets;
         
 
         // don't serialize the cache of ResourceSets
@@ -251,7 +249,7 @@ namespace System.Resources {
         
         private static volatile bool s_IsAppXModel;
         
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         private void Init()
         {
             m_callingAssembly = (RuntimeAssembly)Assembly.GetCallingAssembly();
@@ -298,7 +296,7 @@ namespace System.Resources {
             resourceGroveler = new FileBasedResourceGroveler(mediator);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public ResourceManager(String baseName, Assembly assembly)
         {
             if (null==baseName)
@@ -329,7 +327,7 @@ namespace System.Resources {
             }
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public ResourceManager(String baseName, Assembly assembly, Type usingResourceSet)
         {
             if (null==baseName)
@@ -358,7 +356,7 @@ namespace System.Resources {
                 m_callingAssembly = null;
         }
         
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public ResourceManager(Type resourceSource)
         {
             if (null==resourceSource)
@@ -576,7 +574,7 @@ namespace System.Resources {
 
             return null;
         }
-        
+
         // Looks up a set of resources for a particular CultureInfo.  This is
         // not useful for most users of the ResourceManager - call 
         // GetString() or GetObject() instead.  
@@ -585,7 +583,7 @@ namespace System.Resources {
         // if it hasn't yet been loaded and if parent CultureInfos should be 
         // loaded as well for resource inheritance.
         //         
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public virtual ResourceSet GetResourceSet(CultureInfo culture, bool createIfNotExists, bool tryParents) {
             if (null==culture)
                 throw new ArgumentNullException(nameof(culture));
@@ -628,7 +626,7 @@ namespace System.Resources {
         // for getting a resource set lives.  Access to it is controlled by
         // threadsafe methods such as GetResourceSet, GetString, & GetObject.  
         // This will take a minimal number of locks.
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         protected virtual ResourceSet InternalGetResourceSet(CultureInfo culture, bool createIfNotExists, bool tryParents) 
         {
             Debug.Assert(culture != null, "culture != null");
@@ -1246,12 +1244,10 @@ namespace System.Resources {
             return null;
         }
 
-        [ComVisible(false)]
         public UnmanagedMemoryStream GetStream(String name) {
             return GetStream(name, (CultureInfo)null);
         }
         
-        [ComVisible(false)]
         public UnmanagedMemoryStream GetStream(String name, CultureInfo culture) {
             Object obj = GetObject(name, culture, false);
             UnmanagedMemoryStream ums = obj as UnmanagedMemoryStream;
diff --git a/src/mscorlib/src/System/Resources/ResourceReader.cs b/src/mscorlib/src/System/Resources/ResourceReader.cs
index 0bde286165..d752771020 100644
--- a/src/mscorlib/src/System/Resources/ResourceReader.cs
+++ b/src/mscorlib/src/System/Resources/ResourceReader.cs
@@ -21,7 +21,6 @@ namespace System.Resources {
     using System.Collections;
     using System.Collections.Generic;
     using System.Reflection;
-    using System.Security.Permissions;
     using System.Security;
     using System.Globalization;
     using System.Configuration.Assemblies;
@@ -68,7 +67,6 @@ namespace System.Resources {
     }
 
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class ResourceReader : IResourceReader
     {
         // A reasonable default buffer size for reading from files, especially
@@ -112,7 +110,7 @@ namespace System.Resources {
         public ResourceReader(String fileName)
         {
             _resCache = new Dictionary<String, ResourceLocator>(FastResourceComparer.Default);
-            _store = new BinaryReader(new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read, DefaultFileStreamBufferSize, FileOptions.RandomAccess, Path.GetFileName(fileName), false), Encoding.UTF8);
+            _store = new BinaryReader(new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read, DefaultFileStreamBufferSize, FileOptions.RandomAccess), Encoding.UTF8);
             BCLDebug.Log("RESMGRFILEFORMAT", "ResourceReader .ctor(String).  UnmanagedMemoryStream: "+(_ums!=null));
 
             try {
@@ -198,10 +196,6 @@ namespace System.Resources {
             // Unaligned, little endian format
             return buffer[0] | (buffer[1] << 8) | (buffer[2] << 16) | (buffer[3] << 24);
         }
-
-        private void SkipInt32() {
-            _store.BaseStream.Seek(4, SeekOrigin.Current);
-        }
             
 
         private void SkipString() {
@@ -711,7 +705,7 @@ namespace System.Resources {
                     // For the case that we've memory mapped in the .resources
                     // file, just return a Stream pointing to that block of memory.
                     unsafe {
-                        return new UnmanagedMemoryStream(_ums.PositionPointer, len, len, FileAccess.Read, true);
+                        return new UnmanagedMemoryStream(_ums.PositionPointer, len, len, FileAccess.Read);
                     }
                 }
                 
@@ -817,7 +811,7 @@ namespace System.Resources {
                 throw new BadImageFormatException(Environment.GetResourceString("BadImageFormat_ResourcesHeaderCorrupted"));
             }
             BCLDebug.Log("RESMGRFILEFORMAT", "ReadResources: Expecting " + _numResources + " resources.");
-#if _DEBUG      
+#if RESOURCE_FILE_FORMAT_DEBUG
             if (ResourceManager.DEBUG >= 4)
                 Console.WriteLine("ResourceReader::ReadResources - Reading in "+_numResources+" resources");
 #endif
@@ -837,7 +831,7 @@ namespace System.Resources {
                 SkipString();
             }
 
-#if _DEBUG
+#if RESOURCE_FILE_FORMAT_DEBUG
                 if (ResourceManager.DEBUG >= 5)
                     Console.WriteLine("ResourceReader::ReadResources - Reading in "+numTypes+" type table entries");
 #endif
diff --git a/src/mscorlib/src/System/Resources/ResourceSet.cs b/src/mscorlib/src/System/Resources/ResourceSet.cs
index 1b272fc6ff..8fd9346f91 100644
--- a/src/mscorlib/src/System/Resources/ResourceSet.cs
+++ b/src/mscorlib/src/System/Resources/ResourceSet.cs
@@ -17,7 +17,6 @@ namespace System.Resources {
     using System.Collections;
     using System.IO;
     using System.Globalization;
-    using System.Security.Permissions;
     using System.Runtime.InteropServices;
     using System.Reflection;
     using System.Runtime.Serialization;
@@ -31,7 +30,6 @@ namespace System.Resources {
     // stores them in a hash table.  Custom IResourceReaders can be used.
     // 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class ResourceSet : IDisposable, IEnumerable
     {
         [NonSerialized] protected IResourceReader Reader;
@@ -158,7 +156,6 @@ namespace System.Resources {
 #if LOOSELY_LINKED_RESOURCE_REFERENCE
         // Optional - used for resolving assembly manifest resource references.
         // This can safely be null.
-        [ComVisible(false)]
         public Assembly Assembly {
             get { return _assembly; }
             /*protected*/ set { _assembly = value; }
@@ -181,7 +178,6 @@ namespace System.Resources {
             return Type.GetType("System.Resources.ResourceWriter, System.Resources.Writer, Version=4.0.1.0, Culture=neutral, PublicKeyToken=" + AssemblyRef.MicrosoftPublicKeyToken, throwOnError: true);
         }
 
-        [ComVisible(false)]
         public virtual IDictionaryEnumerator GetEnumerator()
         {
             return GetEnumeratorHelper();
diff --git a/src/mscorlib/src/System/Resources/SatelliteContractVersionAttribute.cs b/src/mscorlib/src/System/Resources/SatelliteContractVersionAttribute.cs
index 327279062a..86e972efdd 100644
--- a/src/mscorlib/src/System/Resources/SatelliteContractVersionAttribute.cs
+++ b/src/mscorlib/src/System/Resources/SatelliteContractVersionAttribute.cs
@@ -19,7 +19,6 @@ namespace System.Resources {
     using System.Diagnostics.Contracts;
     
     [AttributeUsage(AttributeTargets.Assembly, AllowMultiple=false)]  
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class SatelliteContractVersionAttribute : Attribute 
     {
         private String _version;
diff --git a/src/mscorlib/src/System/Resources/UltimateResourceFallbackLocation.cs b/src/mscorlib/src/System/Resources/UltimateResourceFallbackLocation.cs
index 5785bfd357..aa4069a366 100644
--- a/src/mscorlib/src/System/Resources/UltimateResourceFallbackLocation.cs
+++ b/src/mscorlib/src/System/Resources/UltimateResourceFallbackLocation.cs
@@ -20,7 +20,6 @@ using System;
 namespace System.Resources {
 
 [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum UltimateResourceFallbackLocation
     {
         MainAssembly,
diff --git a/src/mscorlib/src/System/RtType.cs b/src/mscorlib/src/System/RtType.cs
index 168beefd4e..a24ee679d3 100644
--- a/src/mscorlib/src/System/RtType.cs
+++ b/src/mscorlib/src/System/RtType.cs
@@ -16,7 +16,6 @@ using System.Runtime.ConstrainedExecution;
 using System.Globalization;
 using System.Threading;
 using System.Diagnostics;
-using System.Security.Permissions;
 using System.Collections;
 using System.Collections.Generic;
 using System.Runtime;
@@ -343,7 +342,8 @@ namespace System
                             // no one should be looking for a member whose name is longer than 1024
                             if (cUtf8Name > MAXNAMELEN)
                             {
-                                fixed (byte* pUtf8Name = new byte[cUtf8Name])
+                                byte[] utf8Name = new byte[cUtf8Name];
+                                fixed (byte* pUtf8Name = &utf8Name[0])
                                 {
                                     list = GetListByName(pName, cNameLen, pUtf8Name, cUtf8Name, listType, cacheType);
                                 }
@@ -403,7 +403,6 @@ namespace System
                 // May replace the list with a new one if certain cache
                 // lookups succeed.  Also, may modify the contents of the list
                 // after merging these new data structures with cached ones.
-                [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
                 internal void Insert(ref T[] list, string name, MemberListType listType)
                 {
                     bool lockTaken = false;
@@ -481,7 +480,6 @@ namespace System
                 }
 
                 // Modifies the existing list.
-                [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
                 private void MergeWithGlobalList(T[] list)
                 {
                     T[] cachedMembers = m_allMembers;
@@ -967,29 +965,6 @@ namespace System
                     }
                 }
 
-                private static void AddElementTypes(Type template, IList<Type> types)
-                {   
-                    if (!template.HasElementType)
-                        return;
-                    
-                    AddElementTypes(template.GetElementType(), types);
-                    
-                    for (int i = 0; i < types.Count; i ++)
-                    {
-                        if (template.IsArray)
-                        {
-                            if (template.IsSzArray)
-                                types[i] = types[i].MakeArrayType();
-                            else 
-                                types[i] = types[i].MakeArrayType(template.GetArrayRank());
-                        }
-                        else if (template.IsPointer)
-                        {
-                            types[i] = types[i].MakePointerType();
-                        }
-                    }
-                }
-
                 private void AddSpecialInterface(ref ListBuilder<RuntimeType> list, Filter filter, RuntimeType iList, bool addSubInterface)
                 {
                     if (iList.IsAssignableFrom(ReflectedType))
@@ -1629,7 +1604,6 @@ namespace System
 
             internal bool IsGlobal 
             { 
-                [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
                 get { return m_isGlobal; } 
             }
 
@@ -2524,8 +2498,6 @@ namespace System
         private static readonly RuntimeType ObjectType = (RuntimeType)typeof(System.Object);
         private static readonly RuntimeType StringType = (RuntimeType)typeof(System.String);
         private static readonly RuntimeType DelegateType = (RuntimeType)typeof(System.Delegate);
-
-        private static Type[] s_SICtorParamTypes;
         #endregion
 
         #region Constructor
@@ -2533,7 +2505,6 @@ namespace System
         #endregion
 
         #region Private\Internal Members
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal override bool CacheEquals(object o)
         {
             RuntimeType m = o as RuntimeType;
@@ -2753,7 +2724,6 @@ namespace System
             return GetMethodCandidates(null, bindingAttr, CallingConventions.Any, null, false).ToArray();
         }
 
-[System.Runtime.InteropServices.ComVisible(true)]
         public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
         {
             return GetConstructorCandidates(null, bindingAttr, CallingConventions.Any, null, false).ToArray();
@@ -3246,7 +3216,6 @@ namespace System
             }
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal sealed override RuntimeTypeHandle GetTypeHandleInternal()
         {
             return new RuntimeTypeHandle(this);
@@ -3342,7 +3311,6 @@ namespace System
             return RuntimeTypeHandle.IsInstanceOfType(this, o);
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         [Pure]
         public override bool IsSubclassOf(Type type) 
         {
@@ -3582,11 +3550,6 @@ namespace System
 
 #endif // FEATURE_COMINTEROP
 
-        internal override bool HasProxyAttributeImpl() 
-        {
-            return RuntimeTypeHandle.HasProxyAttribute(this);
-        }
-
         internal bool IsDelegate()
         {
             return GetBaseType() == typeof(System.MulticastDelegate);
@@ -4784,33 +4747,6 @@ namespace System
                     throw new MissingMethodException(Environment.GetResourceString("MissingConstructor_Name", FullName));
                 }
 
-                // If we're creating a delegate, we're about to call a
-                // constructor taking an integer to represent a target
-                // method. Since this is very difficult (and expensive)
-                // to verify, we're just going to demand UnmanagedCode
-                // permission before allowing this. Partially trusted
-                // clients can instead use Delegate.CreateDelegate,
-                // which allows specification of the target method via
-                // name or MethodInfo.
-                //if (isDelegate)
-                if (RuntimeType.DelegateType.IsAssignableFrom(invokeMethod.DeclaringType))
-                {
-                    // In CoreCLR, CAS is not exposed externally. So what we really are looking
-                    // for is to see if the external caller of this API is transparent or not.
-                    // We get that information from the fact that a Demand will succeed only if
-                    // the external caller is not transparent. 
-                    try
-                    {
-#pragma warning disable 618
-                        new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
-#pragma warning restore 618
-                    }
-                    catch
-                    {
-                        throw new NotSupportedException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("NotSupported_DelegateCreationFromPT")));
-                    }
-                }
-
                 if (invokeMethod.GetParametersNoCopy().Length == 0)
                 {
                     if (args.Length != 0)
@@ -4868,17 +4804,8 @@ namespace System
             readonly ActivatorCacheEntry[] cache = new ActivatorCacheEntry[CACHE_SIZE];
 
             volatile ConstructorInfo     delegateCtorInfo;
-            volatile PermissionSet       delegateCreatePermissions;
 
             private void InitializeDelegateCreator() {
-                // No synchronization needed here. In the worst case we create extra garbage
-                PermissionSet ps = new PermissionSet(PermissionState.None);
-                ps.AddPermission(new ReflectionPermission(ReflectionPermissionFlag.MemberAccess));
-#pragma warning disable 618
-                ps.AddPermission(new SecurityPermission(SecurityPermissionFlag.UnmanagedCode));
-#pragma warning restore 618
-                delegateCreatePermissions = ps;
-
                 ConstructorInfo ctorInfo = typeof(CtorDelegate).GetConstructor(new Type[] {typeof(Object), typeof(IntPtr)});
                 delegateCtorInfo = ctorInfo; // this assignment should be last
             }
@@ -4891,7 +4818,6 @@ namespace System
                     
                     if (delegateCtorInfo == null)
                         InitializeDelegateCreator();
-                    delegateCreatePermissions.Assert();
 
                     // No synchronization needed here. In the worst case we create extra garbage
                     CtorDelegate ctor = (CtorDelegate)delegateCtorInfo.Invoke(new Object[] { null, RuntimeMethodHandle.GetFunctionPointer(ace.m_hCtorMethodHandle) });
@@ -5045,10 +4971,12 @@ namespace System
             return _CreateEnum(enumType, value);
         }
 
+#if FEATURE_COMINTEROP       
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         private extern Object InvokeDispMethod(
             String name, BindingFlags invokeAttr, Object target, Object[] args,
             bool[] byrefModifiers, int culture, String[] namedParameters);
+#endif // FEATURE_COMINTEROP        
 
 #if FEATURE_COMINTEROP_UNMANAGED_ACTIVATION
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/AccessedThroughPropertyAttribute.cs b/src/mscorlib/src/System/Runtime/CompilerServices/AccessedThroughPropertyAttribute.cs
index b0010fd7bd..34e66beade 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/AccessedThroughPropertyAttribute.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/AccessedThroughPropertyAttribute.cs
@@ -9,7 +9,6 @@ namespace System.Runtime.CompilerServices
     using System;
 
     [AttributeUsage(AttributeTargets.Field)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class AccessedThroughPropertyAttribute : Attribute
     {
         private readonly string propertyName;
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/AssemblyAttributesGoHere.cs b/src/mscorlib/src/System/Runtime/CompilerServices/AssemblyAttributesGoHere.cs
deleted file mode 100644
index c021353475..0000000000
--- a/src/mscorlib/src/System/Runtime/CompilerServices/AssemblyAttributesGoHere.cs
+++ /dev/null
@@ -1,43 +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.
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-namespace System.Runtime.CompilerServices {
-
-    using System;
-
-    // NOTE TO DEVELOPERS:  These classes are used by ALink (the assembly linker).
-    // They're used for metadata tokens for making multi-module assemblies.
-    // Do not randomly touch these classes.
-    [System.Runtime.CompilerServices.FriendAccessAllowed]    
-    internal sealed class AssemblyAttributesGoHere
-    {
-    
-        internal AssemblyAttributesGoHere()
-        {
-        }
-    }
-    [System.Runtime.CompilerServices.FriendAccessAllowed]
-    internal sealed class AssemblyAttributesGoHereS
-    {
-        internal AssemblyAttributesGoHereS()
-        {
-        }
-    }
-    [System.Runtime.CompilerServices.FriendAccessAllowed]
-    internal sealed class AssemblyAttributesGoHereM
-    {
-        internal AssemblyAttributesGoHereM()
-        {
-        }
-    }
-    [System.Runtime.CompilerServices.FriendAccessAllowed]
-    internal sealed class AssemblyAttributesGoHereSM
-    {
-        internal AssemblyAttributesGoHereSM()
-        {
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/AsyncMethodBuilder.cs b/src/mscorlib/src/System/Runtime/CompilerServices/AsyncMethodBuilder.cs
index 5952740640..7915e19352 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/AsyncMethodBuilder.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/AsyncMethodBuilder.cs
@@ -18,7 +18,6 @@ using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Contracts;
 using System.Runtime.ExceptionServices;
 using System.Security;
-using System.Security.Permissions;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -64,7 +63,7 @@ namespace System.Runtime.CompilerServices
             // See comment on AsyncMethodBuilderCore.Start
             // AsyncMethodBuilderCore.Start(ref stateMachine);
 
-            if (stateMachine == null) throw new ArgumentNullException(nameof(stateMachine));
+            if (stateMachine == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.stateMachine);
             Contract.EndContractBlock();
 
             // Run the MoveNext method within a copy-on-write ExecutionContext scope.
@@ -73,7 +72,6 @@ namespace System.Runtime.CompilerServices
 
             Thread currentThread = Thread.CurrentThread;
             ExecutionContextSwitcher ecs = default(ExecutionContextSwitcher);
-            RuntimeHelpers.PrepareConstrainedRegions();
             try
             {
                 ExecutionContext.EstablishCopyOnWriteScope(currentThread, ref ecs);
@@ -241,15 +239,8 @@ namespace System.Runtime.CompilerServices
             }
         }
 
-        // This property lazily instantiates the Task in a non-thread-safe manner.  
-        private Task Task 
-        {
-            get
-            {
-                if (m_task == null) m_task = new Task();
-                return m_task;
-            }
-        }
+        /// <summary>Lazily instantiate the Task in a non-thread-safe manner.</summary>
+        private Task Task => m_task ?? (m_task = new Task());
 
         /// <summary>
         /// Gets an object that may be used to uniquely identify this builder to the debugger.
@@ -296,7 +287,7 @@ namespace System.Runtime.CompilerServices
             // See comment on AsyncMethodBuilderCore.Start
             // AsyncMethodBuilderCore.Start(ref stateMachine);
 
-            if (stateMachine == null) throw new ArgumentNullException(nameof(stateMachine));
+            if (stateMachine == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.stateMachine);
             Contract.EndContractBlock();
 
             // Run the MoveNext method within a copy-on-write ExecutionContext scope.
@@ -305,7 +296,6 @@ namespace System.Runtime.CompilerServices
 
             Thread currentThread = Thread.CurrentThread;
             ExecutionContextSwitcher ecs = default(ExecutionContextSwitcher);
-            RuntimeHelpers.PrepareConstrainedRegions();
             try
             {
                 ExecutionContext.EstablishCopyOnWriteScope(currentThread, ref ecs);
@@ -359,7 +349,11 @@ namespace System.Runtime.CompilerServices
         /// <summary>Gets the <see cref="System.Threading.Tasks.Task"/> for this builder.</summary>
         /// <returns>The <see cref="System.Threading.Tasks.Task"/> representing the builder's asynchronous operation.</returns>
         /// <exception cref="System.InvalidOperationException">The builder is not initialized.</exception>
-        public Task Task { get { return m_builder.Task; } }
+        public Task Task
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return m_builder.Task; }
+        }
 
         /// <summary>
         /// Completes the <see cref="System.Threading.Tasks.Task"/> in the 
@@ -450,7 +444,7 @@ namespace System.Runtime.CompilerServices
             // See comment on AsyncMethodBuilderCore.Start
             // AsyncMethodBuilderCore.Start(ref stateMachine);
 
-            if (stateMachine == null) throw new ArgumentNullException(nameof(stateMachine));
+            if (stateMachine == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.stateMachine);
             Contract.EndContractBlock();
 
             // Run the MoveNext method within a copy-on-write ExecutionContext scope.
@@ -459,7 +453,6 @@ namespace System.Runtime.CompilerServices
 
             Thread currentThread = Thread.CurrentThread;
             ExecutionContextSwitcher ecs = default(ExecutionContextSwitcher);
-            RuntimeHelpers.PrepareConstrainedRegions();
             try
             {
                 ExecutionContext.EstablishCopyOnWriteScope(currentThread, ref ecs);
@@ -503,7 +496,7 @@ namespace System.Runtime.CompilerServices
                 {
                     // Force the Task to be initialized prior to the first suspending await so 
                     // that the original stack-based builder has a reference to the right Task.
-                    var builtTask = this.Task;
+                    Task builtTask = this.Task;
 
                     // Box the state machine, then tell the boxed instance to call back into its own builder,
                     // so we can cache the boxed reference. NOTE: The language compiler may choose to use
@@ -543,7 +536,7 @@ namespace System.Runtime.CompilerServices
                 {
                     // Force the Task to be initialized prior to the first suspending await so 
                     // that the original stack-based builder has a reference to the right Task.
-                    var builtTask = this.Task;
+                    Task<TResult> builtTask = this.Task;
 
                     // Box the state machine, then tell the boxed instance to call back into its own builder,
                     // so we can cache the boxed reference. NOTE: The language compiler may choose to use
@@ -564,15 +557,14 @@ namespace System.Runtime.CompilerServices
         /// <returns>The <see cref="System.Threading.Tasks.Task{TResult}"/> representing the builder's asynchronous operation.</returns>
         public Task<TResult> Task
         {
-            get
-            {
-                // Get and return the task. If there isn't one, first create one and store it.
-                var task = m_task;
-                if (task == null) { m_task = task = new Task<TResult>(); }
-                return task;
-            }
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return m_task ?? InitializeTask(); }
         }
 
+        /// <summary>Initializes the task, which must not yet be initialized.</summary>
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private Task<TResult> InitializeTask() => (m_task = new Task<TResult>());
+
         /// <summary>
         /// Completes the <see cref="System.Threading.Tasks.Task{TResult}"/> in the 
         /// <see cref="System.Threading.Tasks.TaskStatus">RanToCompletion</see> state with the specified result.
@@ -583,28 +575,49 @@ namespace System.Runtime.CompilerServices
         {
             // Get the currently stored task, which will be non-null if get_Task has already been accessed.
             // If there isn't one, get a task and store it.
-            var task = m_task;
-            if (task == null)
+            if (m_task == null)
             {
                 m_task = GetTaskForResult(result);
                 Debug.Assert(m_task != null, "GetTaskForResult should never return null");
             }
-            // Slow path: complete the existing task.
             else
             {
-                if (AsyncCausalityTracer.LoggingOn)
-                    AsyncCausalityTracer.TraceOperationCompletion(CausalityTraceLevel.Required, task.Id, AsyncCausalityStatus.Completed);
+                // Slow path: complete the existing task.
+                SetExistingTaskResult(result);
+            }
+        }
 
-                //only log if we have a real task that was previously created
-                if (System.Threading.Tasks.Task.s_asyncDebuggingEnabled)
-                {
-                    System.Threading.Tasks.Task.RemoveFromActiveTasks(task.Id);
-                }
+        /// <summary>Completes the already initialized task with the specified result.</summary>
+        /// <param name="result">The result to use to complete the task.</param>
+        private void SetExistingTaskResult(TResult result)
+        {
+            Debug.Assert(m_task != null, "Expected non-null task");
 
-                if (!task.TrySetResult(result))
-                {
-                    throw new InvalidOperationException(Environment.GetResourceString("TaskT_TransitionToFinal_AlreadyCompleted"));
-                }
+            if (AsyncCausalityTracer.LoggingOn || System.Threading.Tasks.Task.s_asyncDebuggingEnabled)
+            {
+                LogExistingTaskCompletion();
+            }
+
+            if (!m_task.TrySetResult(result))
+            {
+                ThrowHelper.ThrowInvalidOperationException(ExceptionResource.TaskT_TransitionToFinal_AlreadyCompleted);
+            }
+        }
+
+        /// <summary>Handles logging for the successful completion of an operation.</summary>
+        private void LogExistingTaskCompletion()
+        {
+            Debug.Assert(m_task != null);
+
+            if (AsyncCausalityTracer.LoggingOn)
+            {
+                AsyncCausalityTracer.TraceOperationCompletion(CausalityTraceLevel.Required, m_task.Id, AsyncCausalityStatus.Completed);
+            }
+
+            // only log if we have a real task that was previously created
+            if (System.Threading.Tasks.Task.s_asyncDebuggingEnabled)
+            {
+                System.Threading.Tasks.Task.RemoveFromActiveTasks(m_task.Id);
             }
         }
 
@@ -621,15 +634,14 @@ namespace System.Runtime.CompilerServices
 
             // Get the currently stored task, which will be non-null if get_Task has already been accessed.
             // If there isn't one, store the supplied completed task.
-            var task = m_task;
-            if (task == null)
+            if (m_task == null)
             {
                 m_task = completedTask;
             }
             else
             {
                 // Otherwise, complete the task that's there.
-                SetResult(default(TResult));
+                SetExistingTaskResult(default(TResult));
             }
         }
 
@@ -668,7 +680,7 @@ namespace System.Runtime.CompilerServices
 
             if (!successfullySet)
             {
-                throw new InvalidOperationException(Environment.GetResourceString("TaskT_TransitionToFinal_AlreadyCompleted"));
+                ThrowHelper.ThrowInvalidOperationException(ExceptionResource.TaskT_TransitionToFinal_AlreadyCompleted);
             }
         }
 
@@ -705,6 +717,7 @@ namespace System.Runtime.CompilerServices
         /// </summary>
         /// <param name="result">The result for which we need a task.</param>
         /// <returns>The completed task containing the result.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)] // method looks long, but for a given TResult it results in a relatively small amount of asm
         private Task<TResult> GetTaskForResult(TResult result)
         {
             Contract.Ensures(
@@ -847,9 +860,9 @@ namespace System.Runtime.CompilerServices
         /// <exception cref="System.InvalidOperationException">The builder is incorrectly initialized.</exception>
         public void SetStateMachine(IAsyncStateMachine stateMachine)
         {
-            if (stateMachine == null) throw new ArgumentNullException(nameof(stateMachine));
+            if (stateMachine == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.stateMachine);
             Contract.EndContractBlock();
-            if (m_stateMachine != null) throw new InvalidOperationException(Environment.GetResourceString("AsyncMethodBuilder_InstanceNotInitialized"));
+            if (m_stateMachine != null) ThrowHelper.ThrowInvalidOperationException(ExceptionResource.AsyncMethodBuilder_InstanceNotInitialized);
             m_stateMachine = stateMachine;
         }
 
@@ -876,12 +889,12 @@ namespace System.Runtime.CompilerServices
             Debugger.NotifyOfCrossThreadDependency();
 
             // The builder needs to flow ExecutionContext, so capture it.
-            var capturedContext = ExecutionContext.FastCapture(); // ok to use FastCapture as we haven't made any permission demands/asserts
+            var capturedContext = ExecutionContext.Capture();
 
             // If the ExecutionContext is the default context, try to use a cached delegate, creating one if necessary.
             Action action;
             MoveNextRunner runner;
-            if (capturedContext != null && capturedContext.IsPreAllocatedDefault)
+            if (capturedContext == ExecutionContext.Default)
             {
                 // Get the cached delegate, and if it's non-null, return it.
                 action = m_defaultContextAction;
@@ -1016,12 +1029,8 @@ namespace System.Runtime.CompilerServices
 
                 if (m_context != null)
                 {
-                    try
-                    {
-                        // Use the context and callback to invoke m_stateMachine.MoveNext.
-                        ExecutionContext.Run(m_context, InvokeMoveNextCallback, m_stateMachine, preserveSyncCtx: true);
-                    }
-                    finally { m_context.Dispose(); }
+                    // Use the context and callback to invoke m_stateMachine.MoveNext.
+                    ExecutionContext.Run(m_context, InvokeMoveNextCallback, m_stateMachine);
                 }
                 else
                 {
@@ -1046,24 +1055,11 @@ namespace System.Runtime.CompilerServices
             internal void RunWithDefaultContext()
             {
                 Debug.Assert(m_stateMachine != null, "The state machine must have been set before calling Run.");
-                ExecutionContext.Run(ExecutionContext.PreAllocatedDefault, InvokeMoveNextCallback, m_stateMachine, preserveSyncCtx: true);
+                ExecutionContext.Run(ExecutionContext.Default, InvokeMoveNextCallback, m_stateMachine);
             }
 
             /// <summary>Gets a delegate to the InvokeMoveNext method.</summary>
-            protected static ContextCallback InvokeMoveNextCallback
-            {
-                get { return s_invokeMoveNext ?? (s_invokeMoveNext = InvokeMoveNext); }
-            }
-
-            /// <summary>Cached delegate used with ExecutionContext.Run.</summary>
-            private static ContextCallback s_invokeMoveNext; // lazily-initialized due to SecurityCritical attribution
-
-            /// <summary>Invokes the MoveNext method on the supplied IAsyncStateMachine.</summary>
-            /// <param name="stateMachine">The IAsyncStateMachine machine instance.</param>
-            private static void InvokeMoveNext(object stateMachine)
-            {
-                ((IAsyncStateMachine)stateMachine).MoveNext();
-            }
+            protected static readonly ContextCallback InvokeMoveNextCallback = sm => ((IAsyncStateMachine)sm).MoveNext();
         }
 
         /// <summary>
@@ -1122,9 +1118,9 @@ namespace System.Runtime.CompilerServices
             return action;
         }
 
-    ///<summary>
-    /// Given an action, see if it is a contiunation wrapper and has a Task associated with it.  If so return it (null otherwise)
-    ///</summary>
+        ///<summary>
+        /// Given an action, see if it is a contiunation wrapper and has a Task associated with it.  If so return it (null otherwise)
+        ///</summary>
         internal static Task TryGetContinuationTask(Action action)
         {
             if (action != null) 
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/CompilationRelaxations.cs b/src/mscorlib/src/System/Runtime/CompilerServices/CompilationRelaxations.cs
index 5e4f19410b..c3679b610c 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/CompilationRelaxations.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/CompilationRelaxations.cs
@@ -13,7 +13,6 @@ namespace System.Runtime.CompilerServices
     /// IMPORTANT: Keep this in sync with corhdr.h
 [Serializable]
 [Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum CompilationRelaxations : int
     { 
         NoStringInterning       = 0x0008, // Start in 0x0008, we had other non public flags in this enum before,
@@ -23,7 +22,6 @@ namespace System.Runtime.CompilerServices
         
 [Serializable]
 [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Method)]  
-[System.Runtime.InteropServices.ComVisible(true)]
     public class CompilationRelaxationsAttribute : Attribute 
     {
         private int m_relaxations;      // The relaxations.
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/CompilerGlobalScopeAttribute.cs b/src/mscorlib/src/System/Runtime/CompilerServices/CompilerGlobalScopeAttribute.cs
index 65755f6baa..1cd830cfca 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/CompilerGlobalScopeAttribute.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/CompilerGlobalScopeAttribute.cs
@@ -18,7 +18,6 @@ namespace System.Runtime.CompilerServices
 {
     [Serializable]
     [AttributeUsage(AttributeTargets.Class)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class CompilerGlobalScopeAttribute : Attribute
     {
        public CompilerGlobalScopeAttribute () {}
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/ConditionalWeakTable.cs b/src/mscorlib/src/System/Runtime/CompilerServices/ConditionalWeakTable.cs
index b0e5b184d5..4b2648ba6f 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/ConditionalWeakTable.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/ConditionalWeakTable.cs
@@ -67,7 +67,6 @@ using System.Threading;
 namespace System.Runtime.CompilerServices
 {
     #region ConditionalWeakTable
-    [ComVisible(false)]
     public sealed class ConditionalWeakTable<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>
         where TKey : class
         where TValue : class
@@ -1065,7 +1064,6 @@ namespace System.Runtime.CompilerServices
     // This struct intentionally does no self-synchronization. It's up to the caller to
     // to use DependentHandles in a thread-safe way.
     //=========================================================================================
-    [ComVisible(false)]
     internal struct DependentHandle
     {
         #region Constructors
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/CustomConstantAttribute.cs b/src/mscorlib/src/System/Runtime/CompilerServices/CustomConstantAttribute.cs
index c912095bda..1a5dcfdc11 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/CustomConstantAttribute.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/CustomConstantAttribute.cs
@@ -9,7 +9,6 @@ namespace System.Runtime.CompilerServices
 {
     [Serializable]
     [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited=false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public abstract class CustomConstantAttribute : Attribute
     {
         public abstract Object Value { get; }
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/DateTimeConstantAttribute.cs b/src/mscorlib/src/System/Runtime/CompilerServices/DateTimeConstantAttribute.cs
index 4362aa84a1..148d916be1 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/DateTimeConstantAttribute.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/DateTimeConstantAttribute.cs
@@ -9,7 +9,6 @@ namespace System.Runtime.CompilerServices
 {
     [Serializable]
     [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited=false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class DateTimeConstantAttribute : CustomConstantAttribute
     {
         public DateTimeConstantAttribute(long ticks)
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/DecimalConstantAttribute.cs b/src/mscorlib/src/System/Runtime/CompilerServices/DecimalConstantAttribute.cs
index 7bfaa7aafd..f05191840d 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/DecimalConstantAttribute.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/DecimalConstantAttribute.cs
@@ -14,7 +14,6 @@ namespace System.Runtime.CompilerServices
 {
     [Serializable]
     [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited=false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class DecimalConstantAttribute : Attribute
     {
         [CLSCompliant(false)]
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/DecoratedNameAttribute.cs b/src/mscorlib/src/System/Runtime/CompilerServices/DecoratedNameAttribute.cs
deleted file mode 100644
index 75558d4e7e..0000000000
--- a/src/mscorlib/src/System/Runtime/CompilerServices/DecoratedNameAttribute.cs
+++ /dev/null
@@ -1,18 +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.
-
-using System;
-using System.Runtime.InteropServices;
-
-namespace System.Runtime.CompilerServices
-{
-    [AttributeUsage(AttributeTargets.All),
-     ComVisible(false)]
-    internal sealed class DecoratedNameAttribute : Attribute
-    {
-        public DecoratedNameAttribute(string decoratedName)
-        {}
-    }
-}
-
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/DiscardableAttribute.cs b/src/mscorlib/src/System/Runtime/CompilerServices/DiscardableAttribute.cs
index 303151f576..3fda4624d4 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/DiscardableAttribute.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/DiscardableAttribute.cs
@@ -9,7 +9,6 @@ namespace System.Runtime.CompilerServices {
     using System;
 
     // Custom attribute to indicating a TypeDef is a discardable attribute
-[System.Runtime.InteropServices.ComVisible(true)]
     public class DiscardableAttribute : Attribute
     {
         public DiscardableAttribute()
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/IndexerNameAttribute.cs b/src/mscorlib/src/System/Runtime/CompilerServices/IndexerNameAttribute.cs
index 0323fe0cf6..c32be6f3a2 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/IndexerNameAttribute.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/IndexerNameAttribute.cs
@@ -8,7 +8,6 @@ namespace System.Runtime.CompilerServices
 
 [Serializable]
 [AttributeUsage(AttributeTargets.Property, Inherited = true)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class IndexerNameAttribute: Attribute
     {
         public IndexerNameAttribute(String indexerName)
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/IsVolatile.cs b/src/mscorlib/src/System/Runtime/CompilerServices/IsVolatile.cs
index ea2fe032c6..5287e82b7b 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/IsVolatile.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/IsVolatile.cs
@@ -4,7 +4,6 @@
 
 namespace System.Runtime.CompilerServices 
 {
-[System.Runtime.InteropServices.ComVisible(true)]
     public static class IsVolatile 
     {
         // no instantiation, please!
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/MethodImplAttribute.cs b/src/mscorlib/src/System/Runtime/CompilerServices/MethodImplAttribute.cs
index d081d70070..b4991110f8 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/MethodImplAttribute.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/MethodImplAttribute.cs
@@ -12,7 +12,6 @@ namespace System.Runtime.CompilerServices {
     
     [Serializable]
     [Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum MethodImplOptions
     {
         Unmanaged          =   System.Reflection.MethodImplAttributes.Unmanaged,
@@ -21,14 +20,12 @@ namespace System.Runtime.CompilerServices {
         InternalCall       =   System.Reflection.MethodImplAttributes.InternalCall,
         Synchronized       =   System.Reflection.MethodImplAttributes.Synchronized,
         NoInlining         =   System.Reflection.MethodImplAttributes.NoInlining,
-        [System.Runtime.InteropServices.ComVisible(false)]
         AggressiveInlining =   System.Reflection.MethodImplAttributes.AggressiveInlining,
         NoOptimization     =   System.Reflection.MethodImplAttributes.NoOptimization,
         // **** If you add something, update internal MethodImplAttribute(MethodImplAttributes methodImplAttributes)! ****
     }
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum MethodCodeType
     {
         IL              =   System.Reflection.MethodImplAttributes.IL,
@@ -41,7 +38,6 @@ namespace System.Runtime.CompilerServices {
     // Custom attribute to specify additional method properties.
 [Serializable]
 [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor, Inherited = false)] 
-[System.Runtime.InteropServices.ComVisible(true)]
     sealed public class MethodImplAttribute : Attribute  
     {    
         internal MethodImplOptions  _val;
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/RuntimeHelpers.cs b/src/mscorlib/src/System/Runtime/CompilerServices/RuntimeHelpers.cs
index 926eb6c3cb..980c2fd469 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/RuntimeHelpers.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/RuntimeHelpers.cs
@@ -18,7 +18,6 @@ namespace System.Runtime.CompilerServices {
     using System.Runtime.InteropServices;
     using System.Runtime.ConstrainedExecution;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     using System.Threading;
     using System.Runtime.Versioning;
     using System.Diagnostics.Contracts;
@@ -131,7 +130,6 @@ namespace System.Runtime.CompilerServices {
         // Note: this method is not part of the CER support, and is not to be confused with ProbeForSufficientStack
         // below.
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static extern void EnsureSufficientExecutionStack();
 
         // This method ensures that there is sufficient stack to execute the average Framework function.
@@ -139,7 +137,6 @@ namespace System.Runtime.CompilerServices {
         // Note: this method is not part of the CER support, and is not to be confused with ProbeForSufficientStack
         // below.
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static extern bool TryEnsureSufficientExecutionStack();
 
         public static void ProbeForSufficientStack()
@@ -148,7 +145,6 @@ namespace System.Runtime.CompilerServices {
 
         // This method is a marker placed immediately before a try clause to mark the corresponding catch and finally blocks as
         // constrained. There's no code here other than the probe because most of the work is done at JIT time when we spot a call to this routine.
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static void PrepareConstrainedRegions()
         {
             ProbeForSufficientStack();
@@ -156,7 +152,6 @@ namespace System.Runtime.CompilerServices {
 
         // When we detect a CER with no calls, we can point the JIT to this non-probing version instead
         // as we don't need to probe.
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static void PrepareConstrainedRegionsNoOP()
         {
         }
@@ -168,11 +163,18 @@ namespace System.Runtime.CompilerServices {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         public static extern void ExecuteCodeWithGuaranteedCleanup(TryCode code, CleanupCode backoutCode, Object userData);
 
-        [PrePrepareMethod]
         internal static void ExecuteBackoutCodeHelper(Object backoutCode, Object userData, bool exceptionThrown)
         {
             ((CleanupCode)backoutCode)(userData, exceptionThrown);
         }
+
+        /// <returns>true if given type is reference type or value type that contains references</returns>
+        static public bool IsReferenceOrContainsReferences<T>()
+        {
+            // The body of this function will be replaced by the EE with unsafe code!!!
+            // See getILIntrinsicImplementation for how this happens.
+            throw new InvalidOperationException();
+        }
     }
 }
 
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/RuntimeWrappedException.cs b/src/mscorlib/src/System/Runtime/CompilerServices/RuntimeWrappedException.cs
index d2691df6b9..e3b2d2ce62 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/RuntimeWrappedException.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/RuntimeWrappedException.cs
@@ -15,7 +15,6 @@ namespace System.Runtime.CompilerServices {
     using System;
     using System.Runtime.Serialization;
     using System.Runtime.Remoting;
-    using System.Security.Permissions;
     using System.Diagnostics.Contracts;
         
     [Serializable]
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/TaskAwaiter.cs b/src/mscorlib/src/System/Runtime/CompilerServices/TaskAwaiter.cs
index 3799f00e23..f01900a5bf 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/TaskAwaiter.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/TaskAwaiter.cs
@@ -44,7 +44,6 @@ using System.Diagnostics.Contracts;
 using System.Security;
 using System.Threading;
 using System.Threading.Tasks;
-using System.Security.Permissions;
 using System.Diagnostics.Tracing;
 
 // NOTE: For performance reasons, initialization is not verified.  If a developer
@@ -198,21 +197,19 @@ namespace System.Runtime.CompilerServices
         /// <exception cref="System.ArgumentNullException">The <paramref name="continuation"/> argument is null (Nothing in Visual Basic).</exception>
         /// <exception cref="System.NullReferenceException">The awaiter was not properly initialized.</exception>
         /// <remarks>This method is intended for compiler user rather than use directly in code.</remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable         
         internal static void OnCompletedInternal(Task task, Action continuation, bool continueOnCapturedContext, bool flowExecutionContext)
         {
             if (continuation == null) throw new ArgumentNullException(nameof(continuation));
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
 
             // If TaskWait* ETW events are enabled, trace a beginning event for this await
             // and set up an ending event to be traced when the asynchronous await completes.
-            if ( TplEtwProvider.Log.IsEnabled() || Task.s_asyncDebuggingEnabled)
+            if (TplEtwProvider.Log.IsEnabled() || Task.s_asyncDebuggingEnabled)
             {
                 continuation = OutputWaitEtwEvents(task, continuation);
             }
 
             // Set the continuation onto the awaited task.
-            task.SetContinuationForAwait(continuation, continueOnCapturedContext, flowExecutionContext, ref stackMark);
+            task.SetContinuationForAwait(continuation, continueOnCapturedContext, flowExecutionContext);
         }
 
         /// <summary>
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/TypeForwardedToAttribute.cs b/src/mscorlib/src/System/Runtime/CompilerServices/TypeForwardedToAttribute.cs
index d9e067bd4c..147c103047 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/TypeForwardedToAttribute.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/TypeForwardedToAttribute.cs
@@ -26,18 +26,6 @@ namespace System.Runtime.CompilerServices
             }
         }
 
-        internal static TypeForwardedToAttribute[] GetCustomAttribute(RuntimeAssembly assembly)
-        {
-            Type[] types = null;
-            RuntimeAssembly.GetForwardedTypes(assembly.GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref types));
-
-            TypeForwardedToAttribute[] attributes = new TypeForwardedToAttribute[types.Length];
-            for (int i = 0; i < types.Length; ++i)
-                attributes[i] = new TypeForwardedToAttribute(types[i]);
-
-            return attributes;
-        }
-
     }
 }
 
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/Unsafe.cs b/src/mscorlib/src/System/Runtime/CompilerServices/Unsafe.cs
index b212f4555b..adfa015161 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/Unsafe.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/Unsafe.cs
@@ -76,5 +76,18 @@ namespace System.Runtime.CompilerServices
             // See getILIntrinsicImplementationForUnsafe for how this happens.  
             throw new InvalidOperationException();
         }
+
+        /// <summary>
+        /// Initializes a block of memory at the given location with a given initial value 
+        /// without assuming architecture dependent alignment of the address.
+        /// </summary>
+        [NonVersionable]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void InitBlockUnaligned(ref byte startAddress, byte value, uint byteCount)
+        {
+            // The body of this function will be replaced by the EE with unsafe code!!!
+            // See getILIntrinsicImplementationForUnsafe for how this happens.  
+            throw new InvalidOperationException();
+        }
     }
 }
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/YieldAwaitable.cs b/src/mscorlib/src/System/Runtime/CompilerServices/YieldAwaitable.cs
index 86789bf12d..92d1b4f95b 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/YieldAwaitable.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/YieldAwaitable.cs
@@ -28,7 +28,6 @@ using System.Diagnostics.Contracts;
 using System.Diagnostics.Tracing;
 using System.Threading;
 using System.Threading.Tasks;
-using System.Security.Permissions;
 
 namespace System.Runtime.CompilerServices
 {
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/jithelpers.cs b/src/mscorlib/src/System/Runtime/CompilerServices/jithelpers.cs
index 080e42f46f..8f847827aa 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/jithelpers.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/jithelpers.cs
@@ -223,14 +223,6 @@ namespace System.Runtime.CompilerServices {
             throw new InvalidOperationException();
         }
 
-        /// <returns>true if given type is reference type or value type that contains references</returns>
-        static internal bool ContainsReferences<T>()
-        {
-            // The body of this function will be replaced by the EE with unsafe code!!!
-            // See getILIntrinsicImplementation for how this happens.
-            throw new InvalidOperationException();
-        }
-
         static internal ref T GetArrayData<T>(T[] array)
         {
             // The body of this function will be replaced by the EE with unsafe code!!!
diff --git a/src/mscorlib/src/System/Runtime/ExceptionServices/ExceptionNotification.cs b/src/mscorlib/src/System/Runtime/ExceptionServices/ExceptionNotification.cs
index ca316ff55b..1b3e25b8b2 100644
--- a/src/mscorlib/src/System/Runtime/ExceptionServices/ExceptionNotification.cs
+++ b/src/mscorlib/src/System/Runtime/ExceptionServices/ExceptionNotification.cs
@@ -29,7 +29,6 @@ namespace System.Runtime.ExceptionServices {
         // Returns the exception object pertaining to the first chance exception
         public Exception Exception
         {
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
             get { return m_Exception; }
         }
 
diff --git a/src/mscorlib/src/System/Runtime/GcSettings.cs b/src/mscorlib/src/System/Runtime/GcSettings.cs
index 91997f5297..11143c5ee2 100644
--- a/src/mscorlib/src/System/Runtime/GcSettings.cs
+++ b/src/mscorlib/src/System/Runtime/GcSettings.cs
@@ -7,7 +7,6 @@ namespace System.Runtime {
     using System;
     using System.Runtime.CompilerServices;
     using System.Runtime.ConstrainedExecution;
-    using System.Security.Permissions;
     using System.Diagnostics.Contracts;
 
     // These settings are the same format as in clr\src\vm\gcpriv.h
@@ -37,17 +36,15 @@ namespace System.Runtime {
             Succeeded = 0,
             NoGCInProgress = 1 // NoGCRegion is in progress, can't change pause mode.
         };
-
+        
         public static GCLatencyMode LatencyMode
         {
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
             get 
             {
                 return (GCLatencyMode)(GC.GetGCLatencyMode());
             }
 
             // We don't want to allow this API when hosted.
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
             set 
             {
                 if ((value < GCLatencyMode.Batch) || (value > GCLatencyMode.SustainedLowLatency))
@@ -63,14 +60,12 @@ namespace System.Runtime {
 
         public static GCLargeObjectHeapCompactionMode LargeObjectHeapCompactionMode
         {
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
             get 
             {
                 return (GCLargeObjectHeapCompactionMode)(GC.GetLOHCompactionMode());
             }
 
             // We don't want to allow this API when hosted.
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
             set 
             {
                 if ((value < GCLargeObjectHeapCompactionMode.Default) || 
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/ArrayWithOffset.cs b/src/mscorlib/src/System/Runtime/InteropServices/ArrayWithOffset.cs
index 77db3a7f2c..fc15f4e1a7 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/ArrayWithOffset.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/ArrayWithOffset.cs
@@ -9,7 +9,6 @@ namespace System.Runtime.InteropServices {
     using System.Runtime.Versioning;
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public struct ArrayWithOffset
     {
         //private ArrayWithOffset()
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/Attributes.cs b/src/mscorlib/src/System/Runtime/InteropServices/Attributes.cs
index 65d0b0f505..b5bde22057 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/Attributes.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/Attributes.cs
@@ -12,7 +12,6 @@ namespace System.Runtime.InteropServices{
     using System.Diagnostics.Contracts;
 
     [AttributeUsage(AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class UnmanagedFunctionPointerAttribute : Attribute
     {
         CallingConvention m_callingConvention;
@@ -33,7 +32,6 @@ namespace System.Runtime.InteropServices{
     }
 
     [AttributeUsage(AttributeTargets.Interface | AttributeTargets.Enum | AttributeTargets.Struct | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(false)]
     public sealed class TypeIdentifierAttribute : Attribute
     {
         public TypeIdentifierAttribute() { }
@@ -57,7 +55,6 @@ namespace System.Runtime.InteropServices{
     }
 
     [AttributeUsage(AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Event, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class DispIdAttribute : Attribute
     {
         internal int _val;
@@ -69,19 +66,16 @@ namespace System.Runtime.InteropServices{
     }
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum ComInterfaceType
     {
         InterfaceIsDual = 0,
         InterfaceIsIUnknown = 1,
         InterfaceIsIDispatch = 2,
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         InterfaceIsIInspectable = 3,
     }
 
     [AttributeUsage(AttributeTargets.Interface, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class InterfaceTypeAttribute : Attribute
     {
         internal ComInterfaceType _val;
@@ -97,7 +91,6 @@ namespace System.Runtime.InteropServices{
     }
 
     [AttributeUsage(AttributeTargets.Class, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class ComDefaultInterfaceAttribute : Attribute
     {
         internal Type _val;
@@ -111,7 +104,6 @@ namespace System.Runtime.InteropServices{
     }
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum ClassInterfaceType
     {
         None = 0,
@@ -120,7 +112,6 @@ namespace System.Runtime.InteropServices{
     }
 
     [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class ClassInterfaceAttribute : Attribute
     {
         internal ClassInterfaceType _val;
@@ -137,7 +128,6 @@ namespace System.Runtime.InteropServices{
     }
 
     [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Interface | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Delegate | AttributeTargets.Enum | AttributeTargets.Field | AttributeTargets.Method | AttributeTargets.Property, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class ComVisibleAttribute : Attribute
     {
         internal bool _val;
@@ -148,20 +138,7 @@ namespace System.Runtime.InteropServices{
         public bool Value { get { return _val; } }
     }
 
-    [AttributeUsage(AttributeTargets.Interface, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class TypeLibImportClassAttribute : Attribute
-    {
-        internal String _importClassName;
-        public TypeLibImportClassAttribute(Type importClass)
-        {
-            _importClassName = importClass.ToString();
-        }
-        public String Value { get { return _importClassName; } }
-    }
-
-    [AttributeUsage(AttributeTargets.Method, Inherited = false)] 
-    [System.Runtime.InteropServices.ComVisible(true)]
+    [AttributeUsage(AttributeTargets.Method, Inherited = false)]
     public sealed class LCIDConversionAttribute : Attribute
     {
         internal int _val;
@@ -169,29 +146,10 @@ namespace System.Runtime.InteropServices{
         {
             _val = lcid;
         }
-        public int Value { get {return _val;} } 
-    }
-
-    [AttributeUsage(AttributeTargets.Method, Inherited = false)] 
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class ComRegisterFunctionAttribute : Attribute
-    {
-        public ComRegisterFunctionAttribute()
-        {
-        }
+        public int Value { get {return _val;} }
     }
 
-    [AttributeUsage(AttributeTargets.Method, Inherited = false)] 
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class ComUnregisterFunctionAttribute : Attribute
-    {
-        public ComUnregisterFunctionAttribute()
-        {
-        }
-    }
-
-    [AttributeUsage(AttributeTargets.Class, Inherited = false)] 
-    [System.Runtime.InteropServices.ComVisible(true)]
+    [AttributeUsage(AttributeTargets.Class, Inherited = false)]
     public sealed class ProgIdAttribute : Attribute
     {
         internal String _val;
@@ -199,50 +157,10 @@ namespace System.Runtime.InteropServices{
         {
             _val = progId;
         }
-        public String Value { get {return _val;} }  
-    }
-    
-    [AttributeUsage(AttributeTargets.Assembly, Inherited = false)] 
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class ImportedFromTypeLibAttribute : Attribute
-    {
-        internal String _val;
-        public ImportedFromTypeLibAttribute(String tlbFile)
-        {
-            _val = tlbFile;
-        }
         public String Value { get {return _val;} }
     }
 
-    [Obsolete("The IDispatchImplAttribute is deprecated.", false)]
-    [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public enum IDispatchImplType
-    {
-        SystemDefinedImpl   = 0,
-        InternalImpl        = 1,
-        CompatibleImpl      = 2,
-    }
-
-    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Assembly, Inherited = false)] 
-    [Obsolete("This attribute is deprecated and will be removed in a future version.", false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class IDispatchImplAttribute : Attribute
-    {
-        internal IDispatchImplType _val;
-        public IDispatchImplAttribute(IDispatchImplType implType)
-        {
-            _val = implType;
-        }
-        public IDispatchImplAttribute(short implType)
-        {
-            _val = (IDispatchImplType)implType;
-        }
-        public IDispatchImplType Value { get {return _val;} }   
-    }
-
     [AttributeUsage(AttributeTargets.Class, Inherited = true)] 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class ComSourceInterfacesAttribute : Attribute
     {
         internal String _val;
@@ -269,17 +187,7 @@ namespace System.Runtime.InteropServices{
         public String Value { get {return _val;} }  
     }    
 
-    [AttributeUsage(AttributeTargets.All, Inherited = false)] 
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class ComConversionLossAttribute : Attribute
-    {
-        public ComConversionLossAttribute()
-        {
-        }
-    }
-    
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum VarEnum
     {
         VT_EMPTY = 0,
@@ -329,7 +237,6 @@ namespace System.Runtime.InteropServices{
     }
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     // Note that this enum should remain in-sync with the CorNativeType enum in corhdr.h
     public enum UnmanagedType
     {
@@ -403,18 +310,14 @@ namespace System.Runtime.InteropServices{
 
         Error = 0x2d,
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         IInspectable     = 0x2e,
         
-        [System.Runtime.InteropServices.ComVisible(false)]
         HString          = 0x2f,        // Windows Runtime HSTRING
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         LPUTF8Str        = 0x30,        // UTF8 string
     }
 
     [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.ReturnValue, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public unsafe sealed class MarshalAsAttribute : Attribute
     {
         internal static Attribute GetCustomAttribute(RuntimeParameterInfo parameter)
@@ -513,15 +416,12 @@ namespace System.Runtime.InteropServices{
         public int SizeConst;                // constant C
 
         // Fields used with SubType = CustomMarshaler
-        [System.Runtime.InteropServices.ComVisible(true)]
         public String MarshalType;              // Name of marshaler class
-        [System.Runtime.InteropServices.ComVisible(true)]
         public Type MarshalTypeRef;           // Type of marshaler class
         public String MarshalCookie;            // cookie to pass to marshaler
     }
 
     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class ComImportAttribute : Attribute
     {
         internal static Attribute GetCustomAttribute(RuntimeType type)
@@ -543,7 +443,6 @@ namespace System.Runtime.InteropServices{
     }
 
     [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Interface | AttributeTargets.Class | AttributeTargets.Enum | AttributeTargets.Struct | AttributeTargets.Delegate, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class GuidAttribute : Attribute
     {
         internal String _val;
@@ -555,7 +454,6 @@ namespace System.Runtime.InteropServices{
     }
 
     [AttributeUsage(AttributeTargets.Method, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class PreserveSigAttribute : Attribute
     {
         internal static Attribute GetCustomAttribute(RuntimeMethodInfo method)
@@ -577,7 +475,6 @@ namespace System.Runtime.InteropServices{
     }
 
     [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class InAttribute : Attribute
     {
         internal static Attribute GetCustomAttribute(RuntimeParameterInfo parameter)
@@ -595,7 +492,6 @@ namespace System.Runtime.InteropServices{
     }
 
     [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class OutAttribute : Attribute
     {
         internal static Attribute GetCustomAttribute(RuntimeParameterInfo parameter)
@@ -613,7 +509,6 @@ namespace System.Runtime.InteropServices{
     }
 
     [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class OptionalAttribute : Attribute
     {
         internal static Attribute GetCustomAttribute(RuntimeParameterInfo parameter)
@@ -643,7 +538,6 @@ namespace System.Runtime.InteropServices{
     }
 
     [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Method, AllowMultiple = false)]
-    [System.Runtime.InteropServices.ComVisible(false)]
     public sealed class DefaultDllImportSearchPathsAttribute : Attribute
     {
         internal DllImportSearchPath _paths;
@@ -656,7 +550,6 @@ namespace System.Runtime.InteropServices{
     }
 
     [AttributeUsage(AttributeTargets.Method, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public unsafe sealed class DllImportAttribute : Attribute
     {
         internal static Attribute GetCustomAttribute(RuntimeMethodInfo method)
@@ -750,7 +643,6 @@ namespace System.Runtime.InteropServices{
     }
 
     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public unsafe sealed class StructLayoutAttribute : Attribute
     {
         private const int DEFAULT_PACKING_SIZE = 8;
@@ -822,7 +714,6 @@ namespace System.Runtime.InteropServices{
     }
 
     [AttributeUsage(AttributeTargets.Field, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public unsafe sealed class FieldOffsetAttribute : Attribute
     {
         internal static Attribute GetCustomAttribute(RuntimeFieldInfo field)
@@ -849,49 +740,7 @@ namespace System.Runtime.InteropServices{
         public int Value { get { return _val; } }
     }
 
-    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.ReturnValue, Inherited = false)] 
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class ComAliasNameAttribute : Attribute
-    {
-        internal String _val;
-        public ComAliasNameAttribute(String alias)
-        {
-            _val = alias;
-        }
-        public String Value { get {return _val;} }  
-    }    
-
-    [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Interface, Inherited = false)] 
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class AutomationProxyAttribute : Attribute
-    {
-        internal bool _val;
-        public AutomationProxyAttribute(bool val)
-        {
-            _val = val;
-        }
-        public bool Value { get {return _val;} }
-    }
-
-    [AttributeUsage(AttributeTargets.Assembly, Inherited = false, AllowMultiple = true)] 
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class PrimaryInteropAssemblyAttribute : Attribute
-    {
-        internal int _major;
-        internal int _minor;
-        
-        public PrimaryInteropAssemblyAttribute(int major, int minor)
-        {
-            _major = major;
-            _minor = minor;
-        }
-        
-        public int MajorVersion { get {return _major;} }
-        public int MinorVersion { get {return _minor;} }
-    }
-
     [AttributeUsage(AttributeTargets.Interface, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class CoClassAttribute : Attribute
     {
         internal Type _CoClass;
@@ -904,65 +753,7 @@ namespace System.Runtime.InteropServices{
         public Type CoClass { get { return _CoClass; } }
     }
 
-    [AttributeUsage(AttributeTargets.Interface, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class ComEventInterfaceAttribute : Attribute
-    {
-        internal Type _SourceInterface;
-        internal Type _EventProvider;
-        
-        public ComEventInterfaceAttribute(Type SourceInterface, Type EventProvider)
-        {
-            _SourceInterface = SourceInterface;
-            _EventProvider = EventProvider;
-        }
-
-        public Type SourceInterface { get {return _SourceInterface;} }       
-        public Type EventProvider { get {return _EventProvider;} }
-    }
-
-    [AttributeUsage(AttributeTargets.Assembly, Inherited = false)] 
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class TypeLibVersionAttribute : Attribute
-    {
-        internal int _major;
-        internal int _minor;
-        
-        public TypeLibVersionAttribute(int major, int minor)
-        {
-            _major = major;
-            _minor = minor;
-        }
-        
-        public int MajorVersion { get {return _major;} }
-        public int MinorVersion { get {return _minor;} }
-    }
-
-    [AttributeUsage(AttributeTargets.Assembly, Inherited = false)] 
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class ComCompatibleVersionAttribute : Attribute
-    {
-        internal int _major;
-        internal int _minor;
-        internal int _build;
-        internal int _revision;
-        
-        public ComCompatibleVersionAttribute(int major, int minor, int build, int revision)
-        {
-            _major = major;
-            _minor = minor;
-            _build = build;
-            _revision = revision;
-        }
-        
-        public int MajorVersion { get {return _major;} }
-        public int MinorVersion { get {return _minor;} }
-        public int BuildNumber { get {return _build;} }
-        public int RevisionNumber { get {return _revision;} }
-    }
-
     [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Interface | AttributeTargets.Class | AttributeTargets.Struct, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class BestFitMappingAttribute : Attribute
     {
         internal bool _bestFitMapping;
@@ -977,7 +768,6 @@ namespace System.Runtime.InteropServices{
     }
 
     [AttributeUsage(AttributeTargets.Module, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class DefaultCharSetAttribute : Attribute
     {
         internal CharSet _CharSet;
@@ -989,33 +779,5 @@ namespace System.Runtime.InteropServices{
 
         public CharSet CharSet { get { return _CharSet; } }
     }
-
-    [Obsolete("This attribute has been deprecated.  Application Domains no longer respect Activation Context boundaries in IDispatch calls.", false)]
-    [AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class SetWin32ContextInIDispatchAttribute : Attribute
-    {
-        public SetWin32ContextInIDispatchAttribute()
-        {
-        }
-    }
-
-    [AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
-    [System.Runtime.InteropServices.ComVisible(false)]
-    public sealed class ManagedToNativeComInteropStubAttribute : Attribute
-    {
-        internal Type _classType;
-        internal String _methodName;
-
-        public ManagedToNativeComInteropStubAttribute(Type classType, String methodName)
-        {
-            _classType = classType;
-            _methodName = methodName;
-        }
-
-        public Type ClassType { get { return _classType; } }
-        public String MethodName { get { return _methodName; } }
-    }    
-
 }
 
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/BStrWrapper.cs b/src/mscorlib/src/System/Runtime/InteropServices/BStrWrapper.cs
index 1673c913a6..d36f8cfa39 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/BStrWrapper.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/BStrWrapper.cs
@@ -15,10 +15,8 @@ namespace System.Runtime.InteropServices {
    
     using System;
     using System.Security;
-    using System.Security.Permissions;
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class BStrWrapper
     {
         public BStrWrapper(String value)
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/COMException.cs b/src/mscorlib/src/System/Runtime/InteropServices/COMException.cs
index fd500fdbce..87e6be6d4e 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/COMException.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/COMException.cs
@@ -21,7 +21,6 @@ namespace System.Runtime.InteropServices {
 
     // Exception for COM Interop errors where we don't recognize the HResult.
     // 
-    [ComVisible(true)]
     [Serializable]
     public class COMException : ExternalException {
         public COMException() 
@@ -46,18 +45,6 @@ namespace System.Runtime.InteropServices {
             SetErrorCode(errorCode);
         }
 
-        internal COMException(int hresult)
-            : base(Win32Native.GetMessage(hresult))
-        {
-            SetErrorCode(hresult);
-        }
-        
-        internal COMException(String message, int hresult, Exception inner)
-            : base(message, inner)
-        {
-            SetErrorCode(hresult);
-        }
-
         protected COMException(SerializationInfo info, StreamingContext context) : base(info, context) {
         }
 
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/CallingConvention.cs b/src/mscorlib/src/System/Runtime/InteropServices/CallingConvention.cs
index cf4eb48af0..2ef1cf496e 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/CallingConvention.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/CallingConvention.cs
@@ -9,7 +9,6 @@ namespace System.Runtime.InteropServices {
     using System;
     // Used for the CallingConvention named argument to the DllImport attribute
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum CallingConvention
     {
         Winapi          = 1,
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/CharSet.cs b/src/mscorlib/src/System/Runtime/InteropServices/CharSet.cs
index 3c0710a558..e60d676557 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/CharSet.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/CharSet.cs
@@ -13,7 +13,6 @@ namespace System.Runtime.InteropServices {
     // Generally you probably want to use Auto, which does the
     // right thing 99% of the time.
     [Serializable] 
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum CharSet
     {
         None = 1,        // User didn't specify how to marshal strings.
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/ComEventsMethod.cs b/src/mscorlib/src/System/Runtime/InteropServices/ComEventsMethod.cs
index 2da0c5eea3..c2f56b0580 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/ComEventsMethod.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/ComEventsMethod.cs
@@ -45,52 +45,6 @@ namespace System.Runtime.InteropServices {
                 get { return _d; }
                 set { _d = value; }
             }
-
-            public object Invoke(object[] args) {
-                if (_d == null)
-                    return null;
-
-                if (_once == false) {
-                    PreProcessSignature();
-                    _once = true;
-                }
-
-                if (_cachedTargetTypes != null && _expectedParamsCount == args.Length) {
-                    for (int i = 0; i < _expectedParamsCount; i++) {
-                        if (_cachedTargetTypes[i] != null) {
-                            args[i] = Enum.ToObject(_cachedTargetTypes[i], args[i]);
-                        }
-                    }
-                }
-
-                return _d.DynamicInvoke(args);
-            }
-
-            private void PreProcessSignature() {
-                ParameterInfo[] parameters = _d.Method.GetParameters();
-                _expectedParamsCount = parameters.Length;
-
-                Type[] enumTypes = new Type[_expectedParamsCount];
-
-                bool needToHandleCoercion = false;
-
-                for (int i = 0; i < _expectedParamsCount; i++) {
-                    ParameterInfo pi = parameters[i];
-                    // recognize only 'ref Enum' signatures and cache
-                    // both enum type and the underlying type.
-                    if (pi.ParameterType.IsByRef && 
-                        pi.ParameterType.HasElementType && 
-                        pi.ParameterType.GetElementType().IsEnum) {
-
-                        needToHandleCoercion = true;
-                        enumTypes[i] = pi.ParameterType.GetElementType();
-                    }
-                }
-
-                if (needToHandleCoercion == true) {
-                    _cachedTargetTypes = enumTypes;
-                }
-            }
         }
 
         #region private fields
@@ -145,15 +99,9 @@ namespace System.Runtime.InteropServices {
 
             return methods;
         }
- 
-        #endregion
 
-        
-        #region public properties / methods
-
-        internal int DispId {
-            get { return _dispid; }
-        }
+#endregion
+#region public properties / methods
 
         internal bool Empty {
             get { return _delegateWrappers == null || _delegateWrappers.Length == 0; }
@@ -225,22 +173,6 @@ namespace System.Runtime.InteropServices {
             _delegateWrappers = newDelegateWrappers;
         }
 
-        internal object Invoke(object[] args) {
-            BCLDebug.Assert(Empty == false, "event sink is executed but delegates list is empty");
-
-            // Issue: see code:ComEventsHelper#ComEventsRetValIssue
-            object result = null;
-            DelegateWrapper[] invocationList = _delegateWrappers;
-            foreach (DelegateWrapper wrapper in invocationList) {
-                if (wrapper == null || wrapper.Delegate == null)
-                    continue;
-
-                result = wrapper.Invoke(args);
-            }
-
-            return result;
-        }
-
         #endregion
     }
 }
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/ComMemberType.cs b/src/mscorlib/src/System/Runtime/InteropServices/ComMemberType.cs
index 3be2a56da5..c61d1b21be 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/ComMemberType.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/ComMemberType.cs
@@ -9,7 +9,6 @@ namespace System.Runtime.InteropServices {
     using System;
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum ComMemberType
     {
         Method              = 0,
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/CriticalHandle.cs b/src/mscorlib/src/System/Runtime/InteropServices/CriticalHandle.cs
index 700e059293..840270141b 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/CriticalHandle.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/CriticalHandle.cs
@@ -48,7 +48,6 @@
 using System;
 using System.Reflection;
 using System.Threading;
-using System.Security.Permissions;
 using System.Runtime.CompilerServices;
 using System.Runtime.Versioning;
 using System.Runtime.ConstrainedExecution;
@@ -150,7 +149,6 @@ public abstract class CriticalHandle : CriticalFinalizerObject, IDisposable
     private bool _isClosed;     // Set by SetHandleAsInvalid or Close/Dispose/finalization.
 
     // Creates a CriticalHandle class.  Users must then set the Handle property or allow P/Invoke marshaling to set it implicitly.
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     protected CriticalHandle(IntPtr invalidHandleValue)
     {
         handle = invalidHandleValue;
@@ -167,13 +165,11 @@ public abstract class CriticalHandle : CriticalFinalizerObject, IDisposable
     // Adding an empty default constructor for annotation purposes
     private CriticalHandle(){} 
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     ~CriticalHandle()
     {
         Dispose(false);
     }
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     private void Cleanup()
     {
         if (IsClosed)
@@ -197,10 +193,8 @@ public abstract class CriticalHandle : CriticalFinalizerObject, IDisposable
     }
 
     [MethodImplAttribute(MethodImplOptions.InternalCall)]
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     private extern void FireCustomerDebugProbe();
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     protected void SetHandle(IntPtr handle) {
         this.handle = handle;
     }
@@ -208,7 +202,6 @@ public abstract class CriticalHandle : CriticalFinalizerObject, IDisposable
     // Returns whether the handle has been explicitly marked as closed
     // (Close/Dispose) or invalid (SetHandleAsInvalid).
     public bool IsClosed {
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         get { return _isClosed; }
     }
 
@@ -217,22 +210,18 @@ public abstract class CriticalHandle : CriticalFinalizerObject, IDisposable
     // know what an invalid handle looks like, so this method is abstract and
     // must be provided by a derived type.
     public abstract bool IsInvalid {
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         get;
     }
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     public void Close() {
         Dispose(true);
     }
     
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     public void Dispose()
     {
         Dispose(true);
     }
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     protected virtual void Dispose(bool disposing)
     {
         Cleanup();
@@ -242,7 +231,6 @@ public abstract class CriticalHandle : CriticalFinalizerObject, IDisposable
     // your handle is invalid and you want to record that information.
     // An example is calling a syscall and getting back ERROR_INVALID_HANDLE.
     // This method will normally leak handles!
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     public void SetHandleAsInvalid()
     {
         _isClosed = true;
@@ -257,7 +245,6 @@ public abstract class CriticalHandle : CriticalFinalizerObject, IDisposable
     // The boolean returned should be true for success and false if a
     // catastrophic error occurred and you wish to trigger a diagnostic for
     // debugging purposes (the SafeHandleCriticalFailure MDA).
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     protected abstract bool ReleaseHandle();
 }
 
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/CurrencyWrapper.cs b/src/mscorlib/src/System/Runtime/InteropServices/CurrencyWrapper.cs
index 470e7b20dd..304419e5b0 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/CurrencyWrapper.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/CurrencyWrapper.cs
@@ -16,7 +16,6 @@ namespace System.Runtime.InteropServices {
     using System;
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class CurrencyWrapper
     {
         public CurrencyWrapper(Decimal obj)
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/DispatchWrapper.cs b/src/mscorlib/src/System/Runtime/InteropServices/DispatchWrapper.cs
index 47b7542caf..ccf25af0f9 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/DispatchWrapper.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/DispatchWrapper.cs
@@ -15,10 +15,8 @@ namespace System.Runtime.InteropServices {
    
     using System;
     using System.Security;
-    using System.Security.Permissions;
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class DispatchWrapper
     {
         public DispatchWrapper(Object obj)
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/ErrorWrapper.cs b/src/mscorlib/src/System/Runtime/InteropServices/ErrorWrapper.cs
index a9fa58f65f..da02893b1e 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/ErrorWrapper.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/ErrorWrapper.cs
@@ -14,10 +14,8 @@
 namespace System.Runtime.InteropServices {
    
     using System;
-    using System.Security.Permissions;
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class ErrorWrapper
     {
         public ErrorWrapper(int errorCode)
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/Expando/IExpando.cs b/src/mscorlib/src/System/Runtime/InteropServices/Expando/IExpando.cs
index 62b65d1aff..429ce13918 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/Expando/IExpando.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/Expando/IExpando.cs
@@ -17,22 +17,12 @@ namespace System.Runtime.InteropServices.Expando {
     using System.Reflection;
 
     [Guid("AFBF15E6-C37C-11d2-B88E-00A0C9B471B8")]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public interface IExpando : IReflect
+    internal interface IExpando : IReflect
     {
         // Add a new Field to the reflection object.  The field has
         // name as its name.
         FieldInfo AddField(String name);
 
-        // Add a new Property to the reflection object.  The property has
-        // name as its name.
-        PropertyInfo AddProperty(String name);
-
-        // Add a new Method to the reflection object.  The method has 
-        // name as its name and method is a delegate
-        // to the method.  
-        MethodInfo AddMethod(String name, Delegate method);
-
         // Removes the specified member.
         void RemoveMember(MemberInfo m);
     }
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/ExternalException.cs b/src/mscorlib/src/System/Runtime/InteropServices/ExternalException.cs
index 70a6dfe366..7e1f395e4e 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/ExternalException.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/ExternalException.cs
@@ -20,7 +20,6 @@ namespace System.Runtime.InteropServices {
     // Base exception for COM Interop errors &; Structured Exception Handler
     // exceptions.
     // 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class ExternalException : SystemException {
         public ExternalException() 
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/GcHandle.cs b/src/mscorlib/src/System/Runtime/InteropServices/GcHandle.cs
index 5530819c5f..598fee0618 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/GcHandle.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/GcHandle.cs
@@ -5,18 +5,20 @@
 namespace System.Runtime.InteropServices
 {    
     using System;
-    using System.Security.Permissions;
     using System.Runtime.CompilerServices;
     using System.Threading;
-    using System.Runtime.Versioning;
     using System.Diagnostics.Contracts;
+#if BIT64
+    using nint = System.Int64;
+#else
+    using nint = System.Int32;
+#endif
 
     // These are the types of handles used by the EE.  
     // IMPORTANT: These must match the definitions in ObjectHandle.h in the EE. 
     // IMPORTANT: If new values are added to the enum the GCHandle::MaxHandleType
     //            constant must be updated.
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public enum GCHandleType
     {
         Weak = 0,
@@ -40,7 +42,6 @@ namespace System.Runtime.InteropServices
     //
 
     [StructLayout(LayoutKind.Sequential)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public struct GCHandle
     {
         // IMPORTANT: This must be kept in sync with the GCHandleType enum.
@@ -60,20 +61,23 @@ namespace System.Runtime.InteropServices
         {
             // Make sure the type parameter is within the valid range for the enum.
             if ((uint)type > (uint)MaxHandleType)
-                throw new ArgumentOutOfRangeException(nameof(type), Environment.GetResourceString("ArgumentOutOfRange_Enum"));
+                ThrowArgumentOutOfRangeException_ArgumentOutOfRange_Enum();
             Contract.EndContractBlock();
 
-            m_handle = InternalAlloc(value, type);
+            IntPtr handle = InternalAlloc(value, type);
 
-            // Record if the handle is pinned.
             if (type == GCHandleType.Pinned)
-                SetIsPinned();
-        }  
+            {
+                // Record if the handle is pinned.
+                handle = (IntPtr)((nint)handle | 1);
+            }
+
+            m_handle = handle;
+        }
 
         // Used in the conversion functions below.
         internal GCHandle(IntPtr handle)
         {
-            InternalCheckDomain(handle);
             m_handle = handle;
         }
 
@@ -93,36 +97,21 @@ namespace System.Runtime.InteropServices
             return new GCHandle(value, type);
         }
 
-
         // Frees a GC handle.
         public void Free()
         {
-            // Copy the handle instance member to a local variable. This is required to prevent
-            // race conditions releasing the handle.
-            IntPtr handle = m_handle;
-
             // Free the handle if it hasn't already been freed.
-            if (handle != IntPtr.Zero && Interlocked.CompareExchange(ref m_handle, IntPtr.Zero, handle) == handle)
-            {
+            IntPtr handle = Interlocked.Exchange(ref m_handle, IntPtr.Zero);
+            ValidateHandle(handle);
 #if MDA_SUPPORTED
-                // If this handle was passed out to unmanaged code, we need to remove it
-                // from the cookie table.
-                // NOTE: the entry in the cookie table must be released before the
-                // internal handle is freed to prevent a race with reusing GC handles.
-                if (s_probeIsActive)
-                    s_cookieTable.RemoveHandleIfPresent(handle);
-#endif
-
-#if BIT64
-                InternalFree((IntPtr)(((long)handle) & ~1L));
-#else // BIT64 (32)
-                InternalFree((IntPtr)(((int)handle) & ~1));
+            // If this handle was passed out to unmanaged code, we need to remove it
+            // from the cookie table.
+            // NOTE: the entry in the cookie table must be released before the
+            // internal handle is freed to prevent a race with reusing GC handles.
+            if (s_probeIsActive)
+                s_cookieTable.RemoveHandleIfPresent(handle);
 #endif
-            }
-            else
-            {
-                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_HandleIsNotInitialized"));
-            }
+            InternalFree(GetHandleValue(handle));
         }
         
         // Target property - allows getting / updating of the handle's referent.
@@ -130,23 +119,17 @@ namespace System.Runtime.InteropServices
         {
             get
             {
-                // Check if the handle was never initialized or was freed.
-                if (m_handle == IntPtr.Zero)
-                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_HandleIsNotInitialized"));
-
+                ValidateHandle();
                 return InternalGet(GetHandleValue());
             }
     
             set
             {
-                // Check if the handle was never initialized or was freed.
-                if (m_handle == IntPtr.Zero)
-                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_HandleIsNotInitialized"));
-
+                ValidateHandle();
                 InternalSet(GetHandleValue(), value, IsPinned());
             }
         }
-        
+
         // Retrieve the address of an object in a Pinned handle.  This throws
         // an exception if the handle is any type other than Pinned.
         public IntPtr AddrOfPinnedObject()
@@ -154,9 +137,7 @@ namespace System.Runtime.InteropServices
             // Check if the handle was not a pinned handle.
             if (!IsPinned())
             {
-                // Check if the handle was never initialized for was freed.
-                if (m_handle == IntPtr.Zero)
-                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_HandleIsNotInitialized"));
+                ValidateHandle();
 
                 // You can only get the address of pinned handles.
                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_HandleIsNotPinned"));
@@ -167,30 +148,23 @@ namespace System.Runtime.InteropServices
         }
 
         // Determine whether this handle has been allocated or not.
-        public bool IsAllocated
-        {
-            get
-            {
-                return m_handle != IntPtr.Zero;
-            }
-        }
+        public bool IsAllocated => !m_handle.IsNull();
 
         // Used to create a GCHandle from an int.  This is intended to
         // be used with the reverse conversion.
         public static explicit operator GCHandle(IntPtr value)
         {
-            return FromIntPtr(value);
+            ValidateHandle(value);
+            return new GCHandle(value);
         }
 
         public static GCHandle FromIntPtr(IntPtr value)
         {
-            if (value == IntPtr.Zero)
-                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_HandleIsNotInitialized"));
+            ValidateHandle(value);
             Contract.EndContractBlock();
 
-            IntPtr handle = value;
-            
 #if MDA_SUPPORTED
+            IntPtr handle = value;
             if (s_probeIsActive)
             {
                 // Make sure this cookie matches up with a GCHandle we've passed out a cookie for.
@@ -201,10 +175,10 @@ namespace System.Runtime.InteropServices
                     Mda.FireInvalidGCHandleCookieProbe(value);
                     return new GCHandle(IntPtr.Zero);
                 }
+                return new GCHandle(handle);
             }
 #endif
-
-            return new GCHandle(handle);
+            return new GCHandle(value);
         }
 
         // Used to get the internal integer representation of the handle out.
@@ -256,29 +230,19 @@ namespace System.Runtime.InteropServices
 
         internal IntPtr GetHandleValue()
         {
-#if BIT64
-            return new IntPtr(((long)m_handle) & ~1L);
-#else // !BIT64 (32)
-            return new IntPtr(((int)m_handle) & ~1);
-#endif
+            return GetHandleValue(m_handle);
         }
 
-        internal bool IsPinned()
+        private static IntPtr GetHandleValue(IntPtr handle)
         {
-#if BIT64
-            return (((long)m_handle) & 1) != 0;
-#else // !BIT64 (32)
-            return (((int)m_handle) & 1) != 0;
-#endif
+            // Remove Pin flag
+            return new IntPtr((nint)handle & ~(nint)1);
         }
 
-        internal void SetIsPinned()
+        internal bool IsPinned()
         {
-#if BIT64
-            m_handle = new IntPtr(((long)m_handle) | 1L);
-#else // !BIT64 (32)
-            m_handle = new IntPtr(((int)m_handle) | 1);
-#endif
+            // Check Pin flag
+            return ((nint)m_handle & 1) != 0;
         }
 
         // Internal native calls that this implementation uses.
@@ -294,10 +258,6 @@ namespace System.Runtime.InteropServices
         internal static extern Object InternalCompareExchange(IntPtr handle, Object value, Object oldValue, bool isPinned);
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         internal static extern IntPtr InternalAddrOfPinnedObject(IntPtr handle);
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        internal static extern void InternalCheckDomain(IntPtr handle);
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        internal static extern GCHandleType InternalGetHandleType(IntPtr handle);
 
         // The actual integer handle value that the EE uses internally.
         private IntPtr m_handle;
@@ -307,5 +267,29 @@ namespace System.Runtime.InteropServices
         static private volatile GCHandleCookieTable s_cookieTable = null;
         static private volatile bool s_probeIsActive = false;
 #endif
+
+        private void ValidateHandle()
+        {
+            // Check if the handle was never initialized or was freed.
+            if (m_handle.IsNull())
+                ThrowInvalidOperationException_HandleIsNotInitialized();
+        }
+
+        private static void ValidateHandle(IntPtr handle)
+        {
+            // Check if the handle was never initialized or was freed.
+            if (handle.IsNull())
+                ThrowInvalidOperationException_HandleIsNotInitialized();
+        }
+
+        private static void ThrowArgumentOutOfRangeException_ArgumentOutOfRange_Enum()
+        {
+            throw ThrowHelper.GetArgumentOutOfRangeException(ExceptionArgument.type, ExceptionResource.ArgumentOutOfRange_Enum);
+        }
+
+        private static void ThrowInvalidOperationException_HandleIsNotInitialized()
+        {
+            throw ThrowHelper.GetInvalidOperationException(ExceptionResource.InvalidOperation_HandleIsNotInitialized);
+        }
     }
 }
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/HandleRef.cs b/src/mscorlib/src/System/Runtime/InteropServices/HandleRef.cs
index d76750fdd7..b1171025ee 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/HandleRef.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/HandleRef.cs
@@ -7,7 +7,6 @@ namespace System.Runtime.InteropServices
     
     using System;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public struct HandleRef
     {
 
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/ICustomAdapter.cs b/src/mscorlib/src/System/Runtime/InteropServices/ICustomAdapter.cs
index 00abf7b3bf..002c48a171 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/ICustomAdapter.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/ICustomAdapter.cs
@@ -15,7 +15,6 @@
 namespace System.Runtime.InteropServices {
     using System;
 
-[System.Runtime.InteropServices.ComVisible(true)]
     public interface ICustomAdapter
     {        
         [return:MarshalAs(UnmanagedType.IUnknown)] Object GetUnderlyingObject();
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/ICustomFactory.cs b/src/mscorlib/src/System/Runtime/InteropServices/ICustomFactory.cs
index 33d2556bd0..8e7af10b6e 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/ICustomFactory.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/ICustomFactory.cs
@@ -8,7 +8,6 @@ namespace System.Runtime.InteropServices {
 
     using System;
 
-[System.Runtime.InteropServices.ComVisible(true)]
     public interface ICustomFactory
     {
         MarshalByRefObject CreateInstance(Type serverType);
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/ICustomMarshaler.cs b/src/mscorlib/src/System/Runtime/InteropServices/ICustomMarshaler.cs
index 4db4acceeb..d9ed289145 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/ICustomMarshaler.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/ICustomMarshaler.cs
@@ -15,7 +15,6 @@
 namespace System.Runtime.InteropServices {
     using System;
 
-[System.Runtime.InteropServices.ComVisible(true)]
     public interface ICustomMarshaler
     {        
         Object MarshalNativeToManaged( IntPtr pNativeData );
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/ICustomQueryInterface.cs b/src/mscorlib/src/System/Runtime/InteropServices/ICustomQueryInterface.cs
index c7d7937895..5675b1f2d6 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/ICustomQueryInterface.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/ICustomQueryInterface.cs
@@ -19,7 +19,6 @@ namespace System.Runtime.InteropServices {
     // The enum of the return value of IQuerable.GetInterface
     //====================================================================
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(false)]
     public enum CustomQueryInterfaceResult
     {
         Handled                 = 0,
@@ -30,7 +29,6 @@ namespace System.Runtime.InteropServices {
     //====================================================================
     // The interface for customizing IQueryInterface
     //====================================================================
-    [System.Runtime.InteropServices.ComVisible(false)]
     public interface ICustomQueryInterface
     {
         CustomQueryInterfaceResult GetInterface([In]ref Guid iid, out IntPtr ppv);
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/IException.cs b/src/mscorlib/src/System/Runtime/InteropServices/IException.cs
index 2330365834..895aa54781 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/IException.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/IException.cs
@@ -17,13 +17,11 @@ namespace System.Runtime.InteropServices {
     using System;
     using System.Reflection;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     
     [GuidAttribute("b36b5c63-42ef-38bc-a07e-0b34c98f164a")]
     [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsDual)]
     [CLSCompliant(false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _Exception
+    internal interface _Exception
     {
         //
         // This method is intentionally included in CoreCLR to make Exception.get_InnerException "newslot virtual final".
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/ITypeLibConverter.cs b/src/mscorlib/src/System/Runtime/InteropServices/ITypeLibConverter.cs
index 1dccb66fc2..afa934caaf 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/ITypeLibConverter.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/ITypeLibConverter.cs
@@ -21,22 +21,4 @@ namespace System.Runtime.InteropServices {
     using System;
     using System.Reflection;
     using System.Reflection.Emit;
-
-    [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public enum ImporterEventKind
-    {
-        NOTIF_TYPECONVERTED = 0,
-        NOTIF_CONVERTWARNING = 1,
-        ERROR_REFTOINVALIDTYPELIB = 2,
-    }
-
-    [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public enum ExporterEventKind
-    {
-        NOTIF_TYPECONVERTED = 0,
-        NOTIF_CONVERTWARNING = 1,
-        ERROR_REFTOINVALIDASSEMBLY = 2
-    }
 }
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/InvalidComObjectException.cs b/src/mscorlib/src/System/Runtime/InteropServices/InvalidComObjectException.cs
index ac8258b872..760210bc28 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/InvalidComObjectException.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/InvalidComObjectException.cs
@@ -16,7 +16,6 @@ namespace System.Runtime.InteropServices {
     using System;
     using System.Runtime.Serialization;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class InvalidComObjectException : SystemException {
         public InvalidComObjectException() 
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/InvalidOleVariantTypeException.cs b/src/mscorlib/src/System/Runtime/InteropServices/InvalidOleVariantTypeException.cs
index 60c9aa67b4..4ca3da5619 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/InvalidOleVariantTypeException.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/InvalidOleVariantTypeException.cs
@@ -15,7 +15,6 @@ namespace System.Runtime.InteropServices {
     using System;
     using System.Runtime.Serialization;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class InvalidOleVariantTypeException : SystemException {
         public InvalidOleVariantTypeException() 
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/LayoutKind.cs b/src/mscorlib/src/System/Runtime/InteropServices/LayoutKind.cs
index 231779872e..f7def3a8e9 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/LayoutKind.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/LayoutKind.cs
@@ -7,7 +7,6 @@
 namespace System.Runtime.InteropServices {
     using System;
     // Used in the StructLayoutAttribute class
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public enum LayoutKind
     {
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/Marshal.cs b/src/mscorlib/src/System/Runtime/InteropServices/Marshal.cs
index e83305e579..3ed5265931 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/Marshal.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/Marshal.cs
@@ -19,7 +19,6 @@ namespace System.Runtime.InteropServices
     using System.Reflection;
     using System.Reflection.Emit;
     using System.Security;
-    using System.Security.Permissions;
     using System.Text;
     using System.Threading;
     using System.Runtime.Remoting;
@@ -76,7 +75,6 @@ namespace System.Runtime.InteropServices
 #endif
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         private static bool IsNotWin32Atom(IntPtr ptr)
         {
 #if FEATURE_PAL
@@ -213,7 +211,6 @@ namespace System.Runtime.InteropServices
         //====================================================================
         // SizeOf()
         //====================================================================
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static int SizeOf(Object structure)
         {
             if (structure == null)
@@ -253,7 +250,6 @@ namespace System.Runtime.InteropServices
         /// </summary>
         /// <typeparam name="T">Provide a value type to figure out its size</typeparam>
         /// <returns>The aligned size of T in bytes.</returns>
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         internal static uint AlignedSizeOf<T>() where T : struct
         {
             uint size = SizeOfType(typeof(T));
@@ -271,13 +267,11 @@ namespace System.Runtime.InteropServices
         // Type must be a value type with no object reference fields.  We only
         // assert this, due to the lack of a suitable generic constraint.
         [MethodImpl(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal static extern uint SizeOfType(Type type);
 
         // Type must be a value type with no object reference fields.  We only
         // assert this, due to the lack of a suitable generic constraint.
         [MethodImpl(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         private static extern uint AlignedSizeOfType(Type type);
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
@@ -470,7 +464,6 @@ namespace System.Runtime.InteropServices
             throw new PlatformNotSupportedException();
         }
  
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static unsafe int ReadInt32(IntPtr ptr, int ofs)
         {
             try
@@ -500,13 +493,11 @@ namespace System.Runtime.InteropServices
             }
         }
     
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static int ReadInt32(IntPtr ptr)
         {
             return ReadInt32(ptr,0);
         }
        
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static IntPtr ReadIntPtr([MarshalAs(UnmanagedType.AsAny),In] Object ptr, int ofs)
         {
             #if BIT64
@@ -516,7 +507,6 @@ namespace System.Runtime.InteropServices
             #endif
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static IntPtr ReadIntPtr(IntPtr ptr, int ofs)
         {
             #if BIT64
@@ -526,7 +516,6 @@ namespace System.Runtime.InteropServices
             #endif
         }
     
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static IntPtr ReadIntPtr(IntPtr ptr)
         {
             #if BIT64
@@ -574,7 +563,6 @@ namespace System.Runtime.InteropServices
             }
         }
     
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static long ReadInt64(IntPtr ptr)
         {
             return ReadInt64(ptr,0);
@@ -768,7 +756,6 @@ namespace System.Runtime.InteropServices
         // GetLastWin32Error
         //====================================================================
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static extern int GetLastWin32Error();
     
 
@@ -776,14 +763,12 @@ namespace System.Runtime.InteropServices
         // SetLastWin32Error
         //====================================================================
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal static extern void SetLastWin32Error(int error);
     
 
         //====================================================================
         // GetHRForLastWin32Error
         //====================================================================
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static int GetHRForLastWin32Error()
         {
             int dwLastError = GetLastWin32Error();
@@ -840,7 +825,6 @@ namespace System.Runtime.InteropServices
         // "fDeleteOld" is true, this routine will call DestroyStructure() first. 
         //====================================================================
         [MethodImplAttribute(MethodImplOptions.InternalCall), ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static extern void StructureToPtr(Object structure, IntPtr ptr, bool fDeleteOld);
 
         public static void StructureToPtr<T>(T structure, IntPtr ptr, bool fDeleteOld)
@@ -851,7 +835,6 @@ namespace System.Runtime.InteropServices
         //====================================================================
         // Marshals data from a native memory block to a preallocated structure class.
         //====================================================================
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static void PtrToStructure(IntPtr ptr, Object structure)
         {
             PtrToStructureHelper(ptr, structure, false);
@@ -866,8 +849,7 @@ namespace System.Runtime.InteropServices
         // Creates a new instance of "structuretype" and marshals data from a
         // native memory block to it.
         //====================================================================
-        [System.Runtime.InteropServices.ComVisible(true)]
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Object PtrToStructure(IntPtr ptr, Type structureType)
         {
             if (ptr == IntPtr.Zero) return null;
@@ -907,7 +889,6 @@ namespace System.Runtime.InteropServices
         // "structureclass" is used to provide layout information.
         //====================================================================
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [System.Runtime.InteropServices.ComVisible(true)]
         public static extern void DestroyStructure(IntPtr ptr, Type structuretype);
 
         public static void DestroyStructure<T>(IntPtr ptr)
@@ -989,7 +970,6 @@ namespace System.Runtime.InteropServices
         //====================================================================
         // Memory allocation and deallocation.
         //====================================================================
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static IntPtr AllocHGlobal(IntPtr cb)
         {
             // For backwards compatibility on 32 bit platforms, ensure we pass values between 
@@ -1013,13 +993,11 @@ namespace System.Runtime.InteropServices
             return pNewMem;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static IntPtr AllocHGlobal(int cb)
         {
             return AllocHGlobal((IntPtr)cb);
         }
         
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static void FreeHGlobal(IntPtr hglobal)
         {
             if (IsNotWin32Atom(hglobal)) {
@@ -1564,7 +1542,6 @@ namespace System.Runtime.InteropServices
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         public static extern int /* ULONG */ AddRef(IntPtr /* IUnknown */ pUnk );
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static extern int /* ULONG */ Release(IntPtr /* IUnknown */ pUnk );
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/MarshalDirectiveException.cs b/src/mscorlib/src/System/Runtime/InteropServices/MarshalDirectiveException.cs
index b916778019..ec1014ecf8 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/MarshalDirectiveException.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/MarshalDirectiveException.cs
@@ -16,7 +16,6 @@ namespace System.Runtime.InteropServices {
     using System;
     using System.Runtime.Serialization;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class MarshalDirectiveException : SystemException {
         public MarshalDirectiveException() 
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/NativeMethods.cs b/src/mscorlib/src/System/Runtime/InteropServices/NativeMethods.cs
index 650ea65697..818034ee34 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/NativeMethods.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/NativeMethods.cs
@@ -18,42 +18,11 @@ namespace System.Runtime.InteropServices {
 
         [
         System.Security.SuppressUnmanagedCodeSecurity,
-        DllImport("oleaut32.dll", PreserveSig = false),
-        System.Security.SecurityCritical
-        ]
-        internal static extern void VariantClear(IntPtr variant);
-
-        [
-        System.Security.SuppressUnmanagedCodeSecurity,
         ComImport,
         InterfaceType(ComInterfaceType.InterfaceIsIUnknown),
         Guid("00020400-0000-0000-C000-000000000046")
         ]
         internal interface IDispatch {
-
-            void GetTypeInfoCount(out uint pctinfo);
-
-            void GetTypeInfo(uint iTInfo, int lcid, out IntPtr info);
-
-            void GetIDsOfNames(
-                ref Guid iid,
-                [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPWStr, SizeParamIndex = 2)]
-                string[] names,
-                uint cNames,
-                int lcid,
-                [Out]
-                [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.I4, SizeParamIndex = 2)]
-                int[] rgDispId);
-
-            void Invoke(
-                int dispIdMember,
-                ref Guid riid,
-                int lcid,
-                ComTypes.INVOKEKIND wFlags,
-                ref ComTypes.DISPPARAMS pDispParams,
-                IntPtr pvarResult,
-                IntPtr pExcepInfo,
-                IntPtr puArgErr);
         }
     }
 }
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/NonPortable.cs b/src/mscorlib/src/System/Runtime/InteropServices/NonPortable.cs
index 0c8ae7649c..ae974460f7 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/NonPortable.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/NonPortable.cs
@@ -8,91 +8,76 @@ namespace System.Runtime.InteropServices
 {
     public  static partial class Marshal
     {
-        [System.Security.SecurityCritical]
         public static int GetHRForException(Exception e)
         {
             return (e != null) ? e.HResult : 0;
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static int AddRef(System.IntPtr pUnk)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static bool AreComObjectsAvailableForCleanup()
         { 
             return false;
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static System.IntPtr CreateAggregatedObject(System.IntPtr pOuter, object o)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static Object BindToMoniker(String monikerName)
         {
             throw new PlatformNotSupportedException();
         }
         
-        [System.Security.SecurityCriticalAttribute]
         public static void CleanupUnusedObjectsInCurrentContext()
         {
            return;
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static System.IntPtr CreateAggregatedObject<T>(System.IntPtr pOuter, T o)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static object CreateWrapperOfType(object o, System.Type t)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static TWrapper CreateWrapperOfType<T, TWrapper>(T o)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static void ChangeWrapperHandleStrength(Object otp, bool fIsWeak)
         {
             throw new PlatformNotSupportedException();
         }           
 
-        [System.Security.SecurityCriticalAttribute]
         public static int FinalReleaseComObject(object o)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static System.IntPtr GetComInterfaceForObject(object o, System.Type T)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static System.IntPtr GetComInterfaceForObject(object o, System.Type T, System.Runtime.InteropServices.CustomQueryInterfaceMode mode)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static System.IntPtr GetComInterfaceForObject<T, TInterface>(T o)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static System.IntPtr GetHINSTANCE(System.Reflection.Module m)
         {
             if (m == null)
@@ -102,61 +87,51 @@ namespace System.Runtime.InteropServices
             return (System.IntPtr) (-1);
         }           
 
-        [System.Security.SecurityCriticalAttribute]
         public static System.IntPtr GetIUnknownForObject(object o)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static void GetNativeVariantForObject(object obj, System.IntPtr pDstNativeVariant)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static void GetNativeVariantForObject<T>(T obj, System.IntPtr pDstNativeVariant)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static Object GetTypedObjectForIUnknown(System.IntPtr pUnk, System.Type t)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static object GetObjectForIUnknown(System.IntPtr pUnk)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static object GetObjectForNativeVariant(System.IntPtr pSrcNativeVariant)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static T GetObjectForNativeVariant<T>(System.IntPtr pSrcNativeVariant)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static object[] GetObjectsForNativeVariants(System.IntPtr aSrcNativeVariant, int cVars)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static T[] GetObjectsForNativeVariants<T>(System.IntPtr aSrcNativeVariant, int cVars)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static int GetStartComSlot(System.Type t)
         {
             throw new PlatformNotSupportedException();
@@ -167,13 +142,11 @@ namespace System.Runtime.InteropServices
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static string GetTypeInfoName(System.Runtime.InteropServices.ComTypes.ITypeInfo typeInfo)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static object GetUniqueObjectForIUnknown(System.IntPtr unknown)
         {
             throw new PlatformNotSupportedException();
@@ -184,25 +157,21 @@ namespace System.Runtime.InteropServices
             return false;
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static int QueryInterface(System.IntPtr pUnk, ref System.Guid iid, out System.IntPtr ppv)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static int Release(System.IntPtr pUnk)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static int ReleaseComObject(object o)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static void ZeroFreeBSTR(System.IntPtr s)
         {
             throw new PlatformNotSupportedException();
@@ -227,13 +196,11 @@ namespace System.Runtime.InteropServices
 
     public static class ComEventsHelper
     {
-        [System.Security.SecurityCriticalAttribute]
         public static void Combine(object rcw, System.Guid iid, int dispid, System.Delegate d)
         {
             throw new PlatformNotSupportedException();
         }
 
-        [System.Security.SecurityCriticalAttribute]
         public static System.Delegate Remove(object rcw, System.Guid iid, int dispid, System.Delegate d)
         {
             throw new PlatformNotSupportedException();
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/RuntimeEnvironment.cs b/src/mscorlib/src/System/Runtime/InteropServices/RuntimeEnvironment.cs
index 15aaf14afe..4ad0957900 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/RuntimeEnvironment.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/RuntimeEnvironment.cs
@@ -17,7 +17,6 @@ using System.IO;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Security;
-using System.Security.Permissions;
 using System.Reflection;
 using Microsoft.Win32;
 using System.Runtime.Versioning;
@@ -25,81 +24,14 @@ using StackCrawlMark = System.Threading.StackCrawlMark;
 
 namespace System.Runtime.InteropServices
 {
-    [System.Runtime.InteropServices.ComVisible(true)]
-    static public class RuntimeEnvironment {
+    static internal class RuntimeEnvironment {
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         internal static extern String GetModuleFileName();
 
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        internal static extern String GetDeveloperPath();
-
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        internal static extern String GetHostBindingFile();
-
-        public static bool FromGlobalAccessCache(Assembly a)
-        {
-            return a.GlobalAssemblyCache;
-        }
-
-        [MethodImpl (MethodImplOptions.NoInlining)]
         public static String GetSystemVersion()
         {
             return Assembly.GetExecutingAssembly().ImageRuntimeVersion;
         }
-
-        public static String GetRuntimeDirectory()
-        {
-            String dir = GetRuntimeDirectoryImpl();
-            new FileIOPermission(FileIOPermissionAccess.PathDiscovery, dir).Demand();
-            return dir;
-        }
-
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        internal static extern String GetRuntimeDirectoryImpl();
-        
-#if FEATURE_COMINTEROP
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        private static extern IntPtr GetRuntimeInterfaceImpl(
-            [In, MarshalAs(UnmanagedType.LPStruct)] Guid clsid,
-            [In, MarshalAs(UnmanagedType.LPStruct)] Guid riid);
-
-        //
-        // This function does the equivalent of calling GetInterface(clsid, riid) on the
-        // ICLRRuntimeInfo representing this runtime. See MetaHost.idl for a list of
-        // CLSIDs and IIDs supported by this method.
-        //
-        // Returns unmanaged pointer to requested interface on success. Throws
-        // COMException with failed HR if there is a QI failure.
-        //
-        [ComVisible(false)]
-        public static IntPtr GetRuntimeInterfaceAsIntPtr(Guid clsid, Guid riid)
-        {
-            return GetRuntimeInterfaceImpl(clsid, riid);
-        }
-
-        //
-        // This function does the equivalent of calling GetInterface(clsid, riid) on the
-        // ICLRRuntimeInfo representing this runtime. See MetaHost.idl for a list of
-        // CLSIDs and IIDs supported by this method.
-        //
-        // Returns an RCW to requested interface on success. Throws
-        // COMException with failed HR if there is a QI failure.
-        //
-        [ComVisible(false)]
-        public static object GetRuntimeInterfaceAsObject(Guid clsid, Guid riid)
-        {
-            IntPtr p = IntPtr.Zero;
-            try {
-                p = GetRuntimeInterfaceImpl(clsid, riid);
-                return Marshal.GetObjectForIUnknown(p);
-            } finally {
-                if(p != IntPtr.Zero) {
-                    Marshal.Release(p);
-                }
-            }
-        }
-#endif // FEATURE_COMINTEROP
     }
 }
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/SEHException.cs b/src/mscorlib/src/System/Runtime/InteropServices/SEHException.cs
index b418d914ed..72b98738ae 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/SEHException.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/SEHException.cs
@@ -17,7 +17,6 @@ namespace System.Runtime.InteropServices {
     using System.Runtime.Serialization;
     // Exception for Structured Exception Handler exceptions.
     // 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class SEHException : ExternalException {
         public SEHException() 
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/SafeArrayRankMismatchException.cs b/src/mscorlib/src/System/Runtime/InteropServices/SafeArrayRankMismatchException.cs
index 0f4caa21a1..12bf7e7e47 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/SafeArrayRankMismatchException.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/SafeArrayRankMismatchException.cs
@@ -15,7 +15,6 @@ namespace System.Runtime.InteropServices {
     using System;
     using System.Runtime.Serialization;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class SafeArrayRankMismatchException : SystemException {
         public SafeArrayRankMismatchException() 
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/SafeArrayTypeMismatchException.cs b/src/mscorlib/src/System/Runtime/InteropServices/SafeArrayTypeMismatchException.cs
index a5711c1ade..050772af2c 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/SafeArrayTypeMismatchException.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/SafeArrayTypeMismatchException.cs
@@ -16,7 +16,6 @@ namespace System.Runtime.InteropServices {
     using System;
     using System.Runtime.Serialization;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class SafeArrayTypeMismatchException : SystemException {
         public SafeArrayTypeMismatchException() 
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/SafeBuffer.cs b/src/mscorlib/src/System/Runtime/InteropServices/SafeBuffer.cs
index eba67ae74e..ee5c3d8e87 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/SafeBuffer.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/SafeBuffer.cs
@@ -69,7 +69,6 @@
 namespace System.Runtime.InteropServices
 {
 using System;
-using System.Security.Permissions;
 using System.Runtime.InteropServices;
 using System.Runtime.CompilerServices;
 using System.Runtime.ConstrainedExecution;
@@ -175,7 +174,6 @@ using System.Diagnostics.Contracts;
         /// the pointer from within the SafeBuffer.  You must set
         /// pointer to null before calling this method.</param>
         [CLSCompliant(false)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public void AcquirePointer(ref byte* pointer)
         {
             if (_numBytes == Uninitialized)
@@ -194,7 +192,6 @@ using System.Diagnostics.Contracts;
             }
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public void ReleasePointer()
         {
             if (_numBytes == Uninitialized)
@@ -212,7 +209,6 @@ using System.Diagnostics.Contracts;
         /// may have to consider alignment.</param>
         /// <returns>An instance of T read from memory.</returns>
         [CLSCompliant(false)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public T Read<T>(ulong byteOffset) where T : struct {
             if (_numBytes == Uninitialized)
                 throw NotInitialized();
@@ -240,7 +236,6 @@ using System.Diagnostics.Contracts;
         }
 
         [CLSCompliant(false)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public void ReadArray<T>(ulong byteOffset, T[] array, int index, int count)
             where T : struct
         {
@@ -287,7 +282,6 @@ using System.Diagnostics.Contracts;
         /// may have to consider alignment.</param>
         /// <param name="value">The value type to write to memory.</param>
         [CLSCompliant(false)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public void Write<T>(ulong byteOffset, T value) where T : struct {
             if (_numBytes == Uninitialized)
                 throw NotInitialized();
@@ -312,7 +306,6 @@ using System.Diagnostics.Contracts;
         }
 
         [CLSCompliant(false)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public void WriteArray<T>(ulong byteOffset, T[] array, int index, int count)
             where T : struct
         {
@@ -355,7 +348,6 @@ using System.Diagnostics.Contracts;
         /// </summary>
         [CLSCompliant(false)]
         public ulong ByteLength {
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
             get {
                 if (_numBytes == Uninitialized)
                     throw NotInitialized();
@@ -367,7 +359,6 @@ using System.Diagnostics.Contracts;
         /* No indexer.  The perf would be misleadingly bad.  People should use 
          * AcquirePointer and ReleasePointer instead.  */
         
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         private void SpaceCheck(byte* ptr, ulong sizeInBytes)
         {
             if ((ulong)_numBytes < sizeInBytes)
@@ -376,13 +367,11 @@ using System.Diagnostics.Contracts;
                 NotEnoughRoom();
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         private static void NotEnoughRoom()
         {
             throw new ArgumentException(Environment.GetResourceString("Arg_BufferTooSmall"));
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         private static InvalidOperationException NotInitialized()
         {
             Debug.Assert(false, "Uninitialized SafeBuffer!  Someone needs to call Initialize before using this instance!");
@@ -391,7 +380,6 @@ using System.Diagnostics.Contracts;
 
         // FCALL limitations mean we can't have generic FCALL methods.  However, we can pass 
         // TypedReferences to FCALL methods.
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal static void GenericPtrToStructure<T>(byte* ptr, out T structure, uint sizeofT) where T : struct
         {
             structure = default(T);  // Dummy assignment to silence the compiler
@@ -399,17 +387,14 @@ using System.Diagnostics.Contracts;
         }
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         private static extern void PtrToStructureNative(byte* ptr, /*out T*/ TypedReference structure, uint sizeofT);
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal static void GenericStructureToPtr<T>(ref T structure, byte* ptr, uint sizeofT) where T : struct
         {
             StructureToPtrNative(__makeref(structure), ptr, sizeofT);
         }
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         private static extern void StructureToPtrNative(/*ref T*/ TypedReference structure, byte* ptr, uint sizeofT);
     }
 }
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/SafeHandle.cs b/src/mscorlib/src/System/Runtime/InteropServices/SafeHandle.cs
index ed9910e4e4..591caa2877 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/SafeHandle.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/SafeHandle.cs
@@ -19,7 +19,6 @@ namespace System.Runtime.InteropServices {
 using System;
 using System.Reflection;
 using System.Threading;
-using System.Security.Permissions;
 using System.Runtime;
 using System.Runtime.CompilerServices;
 using System.IO;
@@ -154,7 +153,6 @@ public abstract class SafeHandle : CriticalFinalizerObject, IDisposable
     // Creates a SafeHandle class.  Users must then set the Handle property.
     // To prevent the SafeHandle from being freed, write a subclass that
     // doesn't define a finalizer.
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     protected SafeHandle(IntPtr invalidHandleValue, bool ownsHandle)
     {
         handle = invalidHandleValue;
@@ -190,11 +188,9 @@ public abstract class SafeHandle : CriticalFinalizerObject, IDisposable
         Dispose(false);
     }
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     [MethodImplAttribute(MethodImplOptions.InternalCall)]
     extern void InternalFinalize();
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     protected void SetHandle(IntPtr handle) {
         this.handle = handle;
     }
@@ -213,33 +209,27 @@ public abstract class SafeHandle : CriticalFinalizerObject, IDisposable
     //     any way, this can lead to a handle recycling security attack (i.e. an
     //     untrusted caller can query data on the handle you've just returned
     //     and get back information for an entirely unrelated resource).
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     public IntPtr DangerousGetHandle()
     {
         return handle;
     }
 
     public bool IsClosed {
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         get { return (_state & 1) == 1; }
     }
 
     public abstract bool IsInvalid {
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         get;
     }
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     public void Close() {
         Dispose(true);
     }
     
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     public void Dispose() {
         Dispose(true);
     }
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     protected virtual void Dispose(bool disposing)
     {
         if (disposing)
@@ -248,7 +238,6 @@ public abstract class SafeHandle : CriticalFinalizerObject, IDisposable
             InternalFinalize();
     }
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     [MethodImplAttribute(MethodImplOptions.InternalCall)]
     private extern void InternalDispose();
 
@@ -256,7 +245,6 @@ public abstract class SafeHandle : CriticalFinalizerObject, IDisposable
     // your handle is invalid and you want to record that information.
     // An example is calling a syscall and getting back ERROR_INVALID_HANDLE.
     // This method will normally leak handles!
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     [MethodImplAttribute(MethodImplOptions.InternalCall)]
     public extern void SetHandleAsInvalid();
 
@@ -268,7 +256,6 @@ public abstract class SafeHandle : CriticalFinalizerObject, IDisposable
     // The boolean returned should be true for success and false if the runtime
     // should fire a SafeHandleCriticalFailure MDA (CustomerDebugProbe) if that
     // MDA is enabled.
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     protected abstract bool ReleaseHandle();
 
     // Add a reason why this handle should not be relinquished (i.e. have
@@ -284,7 +271,6 @@ public abstract class SafeHandle : CriticalFinalizerObject, IDisposable
     // when the method is interrupted prior to processing by a thread abort or
     // when the handle has already been (or is in the process of being)
     // released.
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     [MethodImplAttribute(MethodImplOptions.InternalCall)]
     public extern void DangerousAddRef(ref bool success);
 
@@ -297,7 +283,6 @@ public abstract class SafeHandle : CriticalFinalizerObject, IDisposable
     // constitutes a potential security hole (via handle recycling) as well as a
     // correctness problem -- so don't ever expose Dangerous* calls out to
     // untrusted code.
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     [MethodImplAttribute(MethodImplOptions.InternalCall)]
     public extern void DangerousRelease();
 }
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/UnknownWrapper.cs b/src/mscorlib/src/System/Runtime/InteropServices/UnknownWrapper.cs
index 69ef2dcc06..1f70108a02 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/UnknownWrapper.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/UnknownWrapper.cs
@@ -16,7 +16,6 @@ namespace System.Runtime.InteropServices {
     using System;
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class UnknownWrapper
     {
         public UnknownWrapper(Object obj)
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/Attributes.cs b/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/Attributes.cs
index 80b24f5529..7fa2420530 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/Attributes.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/Attributes.cs
@@ -35,7 +35,7 @@ namespace System.Runtime.InteropServices.WindowsRuntime
     [System.Runtime.CompilerServices.FriendAccessAllowed]
     internal sealed class WindowsRuntimeImportAttribute : Attribute
     {
-        public WindowsRuntimeImportAttribute()
+        internal WindowsRuntimeImportAttribute()
         { }
     }
 
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/CLRIPropertyValueImpl.cs b/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/CLRIPropertyValueImpl.cs
index 702e0c9e52..b7dad17a6b 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/CLRIPropertyValueImpl.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/CLRIPropertyValueImpl.cs
@@ -148,15 +148,6 @@ namespace System.Runtime.InteropServices.WindowsRuntime
             return CoerceScalarValue<String>(PropertyType.String);
         }
 
-        [Pure]
-        public Object GetInspectable()
-        {
-            if (this.Type != PropertyType.Inspectable)
-                throw new InvalidCastException(Environment.GetResourceString("InvalidCast_WinRTIPropertyValueElement", this.Type, "Inspectable"), __HResults.TYPE_E_TYPEMISMATCH);
-            Contract.EndContractBlock();
-            return _data;
-        }
-
 
         [Pure]
         public Guid GetGuid()
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/ConstantSplittableMap.cs b/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/ConstantSplittableMap.cs
index a5abb4f23e..3a896ecbe3 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/ConstantSplittableMap.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/ConstantSplittableMap.cs
@@ -53,25 +53,6 @@ namespace System.Runtime.InteropServices.WindowsRuntime
             this.items = CreateKeyValueArray(data.Count, data.GetEnumerator());
         }
 
-        internal ConstantSplittableMap(IMapView<TKey, TValue> data)
-        {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
-
-            if (((UInt32)Int32.MaxValue) < data.Size)
-            {
-                Exception e = new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CollectionBackingDictionaryTooLarge"));
-                e.SetErrorCode(__HResults.E_BOUNDS);
-                throw e;
-            }
-
-            int size = (int)data.Size;
-
-            this.firstItemIndex = 0;
-            this.lastItemIndex = size - 1;
-            this.items = CreateKeyValueArray(size, data.GetEnumerator());
-        }
-
 
         private ConstantSplittableMap(KeyValuePair<TKey, TValue>[] items, Int32 firstItemIndex, Int32 lastItemIndex)
         {
@@ -94,22 +75,6 @@ namespace System.Runtime.InteropServices.WindowsRuntime
             return kvArray;
         }
 
-        private KeyValuePair<TKey, TValue>[] CreateKeyValueArray(Int32 count, IEnumerator<IKeyValuePair<TKey, TValue>> data)
-        {
-            KeyValuePair<TKey, TValue>[] kvArray = new KeyValuePair<TKey, TValue>[count];
-
-            Int32 i = 0;
-            while (data.MoveNext())
-            {
-                IKeyValuePair<TKey, TValue> current = data.Current;
-                kvArray[i++] = new KeyValuePair<TKey, TValue>(current.Key, current.Value);
-            }
-
-            Array.Sort(kvArray, keyValuePairComparator);
-
-            return kvArray;
-        }
-
 
         public int Count {
             get {
@@ -179,14 +144,7 @@ namespace System.Runtime.InteropServices.WindowsRuntime
             secondPartition = new ConstantSplittableMap<TKey, TValue>(items, pivot + 1, lastItemIndex);
         }
 
-        #region IReadOnlyDictionary members
-
-        public bool ContainsKey(TKey key)
-        {
-            KeyValuePair<TKey, TValue> searchKey = new KeyValuePair<TKey, TValue>(key, default(TValue));
-            int index = Array.BinarySearch(items, firstItemIndex, Count, searchKey, keyValuePairComparator);
-            return index >= 0;
-        }
+#region IReadOnlyDictionary members
 
         public bool TryGetValue(TKey key, out TValue value)
         {
@@ -203,24 +161,6 @@ namespace System.Runtime.InteropServices.WindowsRuntime
             return true;
         }
 
-        public TValue this[TKey key] {
-            get {
-                return Lookup(key);
-            }
-        }
-
-        public IEnumerable<TKey> Keys {
-            get {
-                throw new NotImplementedException("NYI");
-            }
-        }
-
-        public IEnumerable<TValue> Values {
-            get {
-                throw new NotImplementedException("NYI");
-            }
-        }
-
         #endregion IReadOnlyDictionary members
 
         #region IKeyValuePair Enumerator
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/IVector.cs b/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/IVector.cs
index a77ff005b9..6982911a13 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/IVector.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/IVector.cs
@@ -57,9 +57,6 @@ namespace System.Runtime.InteropServices.WindowsRuntime
         void Append(T value);
         void RemoveAtEnd();
         void Clear();
-        [Pure]
-        uint GetMany(uint startIndex, [Out] T[] items);
-        void ReplaceAll(T[] items);
     }
 
     [ComImport]
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/WindowsRuntimeBufferHelper.cs b/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/WindowsRuntimeBufferHelper.cs
index a786880fab..551ee65153 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/WindowsRuntimeBufferHelper.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/WindowsRuntimeBufferHelper.cs
@@ -21,12 +21,10 @@ internal static class WindowsRuntimeBufferHelper {
 
     [DllImport(JitHelpers.QCall)]
     [SuppressUnmanagedCodeSecurity]
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     private unsafe extern static void StoreOverlappedPtrInCCW(ObjectHandleOnStack windowsRuntimeBuffer, NativeOverlapped* overlapped);
 
 
     [FriendAccessAllowed]
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
     internal unsafe static void StoreOverlappedInCCW(Object windowsRuntimeBuffer, NativeOverlapped* overlapped) {
 
         StoreOverlappedPtrInCCW(JitHelpers.GetObjectHandleOnStack(ref windowsRuntimeBuffer), overlapped);
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/WindowsRuntimeMarshal.cs b/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/WindowsRuntimeMarshal.cs
index 242ff759a8..57655ec861 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/WindowsRuntimeMarshal.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/WindowsRuntimeMarshal.cs
@@ -135,12 +135,6 @@ namespace System.Runtime.InteropServices.WindowsRuntime
                 restTokens = null;
             }
 
-            internal EventRegistrationTokenList(EventRegistrationTokenList list)
-            {
-                firstToken = list.firstToken;
-                restTokens = list.restTokens;
-            }
-
             // Push a new token into this list
             // Returns true if you need to copy back this list into the dictionary (so that you 
             // don't lose change outside the dictionary). false otherwise.
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/WindowsRuntimeMetadata.cs b/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/WindowsRuntimeMetadata.cs
index 9ca959c528..f097c6a0db 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/WindowsRuntimeMetadata.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/WindowsRuntime/WindowsRuntimeMetadata.cs
@@ -16,94 +16,10 @@ namespace System.Runtime.InteropServices.WindowsRuntime
     using System.Runtime.InteropServices;
     using System.Security;
     
-    public static class WindowsRuntimeMetadata
+    internal static class WindowsRuntimeMetadata
     {
-        // Wrapper for Win8 API RoResolveNamespace with default Windows SDK path as installed .winmd files in %WINDIR%\system32\WinMetadata.
-        public static IEnumerable<string> ResolveNamespace(string namespaceName, IEnumerable<string> packageGraphFilePaths)
-        {
-            return ResolveNamespace(namespaceName, null, packageGraphFilePaths);
-        }
-
-        // Wrapper for Win8 API RoResolveNamespace.
-        public static IEnumerable<string> ResolveNamespace(string namespaceName, string windowsSdkFilePath, IEnumerable<string> packageGraphFilePaths)
-        {
-            if (namespaceName == null)
-                throw new ArgumentNullException(nameof(namespaceName));
-            Contract.EndContractBlock();
-
-            string[] packageGraphFilePathsArray = null;
-            if (packageGraphFilePaths != null)
-            {
-                List<string> packageGraphFilePathsList = new List<string>(packageGraphFilePaths);
-                packageGraphFilePathsArray = new string[packageGraphFilePathsList.Count];
-                
-                int index = 0;
-                foreach (string packageGraphFilePath in packageGraphFilePathsList)
-                {
-                    packageGraphFilePathsArray[index] = packageGraphFilePath;
-                    index++;
-                }
-            }
-            
-            string[] retFileNames = null;
-            nResolveNamespace(
-                namespaceName, 
-                windowsSdkFilePath, 
-                packageGraphFilePathsArray,
-                ((packageGraphFilePathsArray == null) ? 0 : packageGraphFilePathsArray.Length), 
-                JitHelpers.GetObjectHandleOnStack(ref retFileNames));
-            
-            return retFileNames;
-        }
-        
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        private extern static void nResolveNamespace(
-            string namespaceName, 
-            string windowsSdkFilePath, 
-            string[] packageGraphFilePaths, 
-            int cPackageGraphFilePaths, 
-            ObjectHandleOnStack retFileNames);
+        private static EventHandler<DesignerNamespaceResolveEventArgs> DesignerNamespaceResolve;
         
-#if FEATURE_REFLECTION_ONLY_LOAD
-        [method: System.Security.SecurityCritical]
-        public static event EventHandler<NamespaceResolveEventArgs> ReflectionOnlyNamespaceResolve;
-
-        internal static RuntimeAssembly[] OnReflectionOnlyNamespaceResolveEvent(AppDomain appDomain, RuntimeAssembly assembly, string namespaceName)
-        {
-            EventHandler<NamespaceResolveEventArgs> eventHandler = ReflectionOnlyNamespaceResolve;
-            if (eventHandler != null)
-            {
-                Delegate[] ds = eventHandler.GetInvocationList();
-                int len = ds.Length;
-                for (int i = 0; i < len; i++)
-                {
-                    NamespaceResolveEventArgs eventArgs = new NamespaceResolveEventArgs(namespaceName, assembly);
-                    
-                    ((EventHandler<NamespaceResolveEventArgs>)ds[i])(appDomain, eventArgs);
-                    
-                    Collection<Assembly> assembliesCollection = eventArgs.ResolvedAssemblies;
-                    if (assembliesCollection.Count > 0)
-                    {
-                        RuntimeAssembly[] retAssemblies = new RuntimeAssembly[assembliesCollection.Count];
-                        int retIndex = 0;
-                        foreach (Assembly asm in assembliesCollection)
-                        {
-                            retAssemblies[retIndex] = AppDomain.GetRuntimeAssembly(asm);
-                            retIndex++;
-                        }
-                        return retAssemblies;
-                    }
-                }
-            }
-            
-            return null;
-        }
-#endif //FEATURE_REFLECTION_ONLY
-
-        [method: System.Security.SecurityCritical]
-        public static event EventHandler<DesignerNamespaceResolveEventArgs> DesignerNamespaceResolve;
-
         internal static string[] OnDesignerNamespaceResolveEvent(AppDomain appDomain, string namespaceName)
         {
             EventHandler<DesignerNamespaceResolveEventArgs> eventHandler = DesignerNamespaceResolve;
@@ -142,7 +58,6 @@ namespace System.Runtime.InteropServices.WindowsRuntime
     }
     
 #if FEATURE_REFLECTION_ONLY_LOAD
-    [ComVisible(false)]
     public class NamespaceResolveEventArgs : EventArgs
     {
         private string _NamespaceName;
@@ -182,20 +97,11 @@ namespace System.Runtime.InteropServices.WindowsRuntime
     }
 #endif //FEATURE_REFLECTION_ONLY
 
-    [ComVisible(false)]
-    public class DesignerNamespaceResolveEventArgs : EventArgs
+    internal class DesignerNamespaceResolveEventArgs : EventArgs
     {
         private string _NamespaceName;
         private Collection<string> _ResolvedAssemblyFiles;
 
-        public string NamespaceName
-        {
-            get
-            {
-                return _NamespaceName;
-            }
-        }
-
         public Collection<string> ResolvedAssemblyFiles
         {
             get
diff --git a/src/mscorlib/src/System/Runtime/Loader/AssemblyLoadContext.cs b/src/mscorlib/src/System/Runtime/Loader/AssemblyLoadContext.cs
index 94af350029..2be8b13274 100644
--- a/src/mscorlib/src/System/Runtime/Loader/AssemblyLoadContext.cs
+++ b/src/mscorlib/src/System/Runtime/Loader/AssemblyLoadContext.cs
@@ -18,9 +18,6 @@ namespace System.Runtime.Loader
 {
     public abstract class AssemblyLoadContext
     {
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        private static extern bool OverrideDefaultAssemblyLoadContextForCurrentDomain(IntPtr ptrNativeAssemblyLoadContext);
 
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
         [SuppressUnmanagedCodeSecurity]
@@ -29,10 +26,6 @@ namespace System.Runtime.Loader
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
         [SuppressUnmanagedCodeSecurity]
         private static extern IntPtr InitializeAssemblyLoadContext(IntPtr ptrAssemblyLoadContext, bool fRepresentsTPALoadContext);
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        private static extern IntPtr LoadFromAssemblyName(IntPtr ptrNativeAssemblyLoadContext, bool fRepresentsTPALoadContext);
         
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
         [SuppressUnmanagedCodeSecurity]
@@ -351,28 +344,6 @@ namespace System.Runtime.Loader
                 return s_DefaultAssemblyLoadContext;
             }
         }
-
-        // This will be used to set the AssemblyLoadContext for DefaultContext, for the AppDomain,
-        // by a host. Once set, the runtime will invoke the LoadFromAssemblyName method against it to perform
-        // assembly loads for the DefaultContext.
-        //
-        // This method will throw if the Default AssemblyLoadContext is already set or the Binding model is already locked.
-        public static void InitializeDefaultContext(AssemblyLoadContext context)
-        {
-            if (context == null)
-            {
-                throw new ArgumentNullException(nameof(context));
-            }
-            
-            // Try to override the default assembly load context
-            if (!AssemblyLoadContext.OverrideDefaultAssemblyLoadContextForCurrentDomain(context.m_pNativeAssemblyLoadContext))
-            {
-                throw new InvalidOperationException(Environment.GetResourceString("AppDomain_BindingModelIsLocked"));
-            }
-            
-            // Update the managed side as well.
-            s_DefaultAssemblyLoadContext = context;
-        }
         
         // This call opens and closes the file, but does not add the
         // assembly to the domain.
diff --git a/src/mscorlib/src/System/Runtime/MemoryFailPoint.cs b/src/mscorlib/src/System/Runtime/MemoryFailPoint.cs
index bd87d9027c..84b8ba9e1e 100644
--- a/src/mscorlib/src/System/Runtime/MemoryFailPoint.cs
+++ b/src/mscorlib/src/System/Runtime/MemoryFailPoint.cs
@@ -20,7 +20,6 @@ using System.Runtime.InteropServices;
 using System.Threading;
 using System.Runtime.CompilerServices;
 using System.Runtime.ConstrainedExecution;
-using System.Security.Permissions;
 using System.Runtime.Versioning;
 using System.Diagnostics;
 using System.Diagnostics.Contracts;
@@ -394,7 +393,6 @@ namespace System.Runtime
             GC.SuppressFinalize(this);
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         private void Dispose(bool disposing)
         {
             // This is just bookkeeping to ensure multiple threads can really
@@ -472,10 +470,6 @@ namespace System.Runtime
                     _availPageFile >> 20, _totalFreeAddressSpace >> 20, 
                     _lastKnownFreeAddressSpace >> 20, _reservedMem);
             }
-
-            public String StackTrace {
-                get { return _stackTrace; }
-            }
         }
 #endif
     }
diff --git a/src/mscorlib/src/System/Runtime/ProfileOptimization.cs b/src/mscorlib/src/System/Runtime/ProfileOptimization.cs
deleted file mode 100644
index ca4227c011..0000000000
--- a/src/mscorlib/src/System/Runtime/ProfileOptimization.cs
+++ /dev/null
@@ -1,48 +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.
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-//
-//    This class defines entry point for multi-core JIT API
-//
-//
-namespace System.Runtime {
-
-    using System;
-    
-    using System.Reflection;
-
-    using System.Security;
-    using System.Security.Permissions;
-    
-    using System.Runtime;
-    using System.Runtime.InteropServices;
-    using System.Runtime.Versioning;
-    using System.Runtime.CompilerServices;
-
-
-    public static class ProfileOptimization
-    {
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        internal static extern void InternalSetProfileRoot(string directoryPath);
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        internal static extern void InternalStartProfile(string profile, IntPtr ptrNativeAssemblyLoadContext);
-
-        public static void SetProfileRoot(string directoryPath)
-        {
-            InternalSetProfileRoot(directoryPath);
-        }
-
-        public static void StartProfile(string profile)
-        {
-            InternalStartProfile(profile, IntPtr.Zero);
-        }
-    }
-
-}
-
diff --git a/src/mscorlib/src/System/Runtime/Reliability/CriticalFinalizerObject.cs b/src/mscorlib/src/System/Runtime/Reliability/CriticalFinalizerObject.cs
index eb5a186b65..6d6d6f3e77 100644
--- a/src/mscorlib/src/System/Runtime/Reliability/CriticalFinalizerObject.cs
+++ b/src/mscorlib/src/System/Runtime/Reliability/CriticalFinalizerObject.cs
@@ -17,20 +17,16 @@
 ===========================================================*/
 
 using System;
-using System.Security.Permissions;
 using System.Runtime.InteropServices;
 
 namespace System.Runtime.ConstrainedExecution
 {
-    [System.Runtime.InteropServices.ComVisible(true)]
     public abstract class CriticalFinalizerObject
     {
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         protected CriticalFinalizerObject()
         {
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         ~CriticalFinalizerObject()
         {
         }
diff --git a/src/mscorlib/src/System/Runtime/Reliability/PrePrepareMethodAttribute.cs b/src/mscorlib/src/System/Runtime/Reliability/PrePrepareMethodAttribute.cs
index d9774d636b..67c934d034 100644
--- a/src/mscorlib/src/System/Runtime/Reliability/PrePrepareMethodAttribute.cs
+++ b/src/mscorlib/src/System/Runtime/Reliability/PrePrepareMethodAttribute.cs
@@ -23,7 +23,7 @@ namespace System.Runtime.ConstrainedExecution
 
     [AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method, Inherited = false)]
 
-    public sealed class PrePrepareMethodAttribute : Attribute
+    internal sealed class PrePrepareMethodAttribute : Attribute
     {
         public PrePrepareMethodAttribute()
         {
diff --git a/src/mscorlib/src/System/Runtime/Reliability/ReliabilityContractAttribute.cs b/src/mscorlib/src/System/Runtime/Reliability/ReliabilityContractAttribute.cs
index 4a14e5733c..a889f1559c 100644
--- a/src/mscorlib/src/System/Runtime/Reliability/ReliabilityContractAttribute.cs
+++ b/src/mscorlib/src/System/Runtime/Reliability/ReliabilityContractAttribute.cs
@@ -20,13 +20,6 @@ namespace System.Runtime.ConstrainedExecution {
     using System.Runtime.InteropServices;
     using System;
 
-    // **************************************************************************************************************************
-    //
-    // Note that if you change either of the enums below or the constructors, fields or properties of the custom attribute itself
-    // you must also change the logic and definitions in vm\ConstrainedExecutionRegion.cpp to match.
-    //
-    // **************************************************************************************************************************
-
     [Serializable]
     public enum Consistency : int
     {
diff --git a/src/mscorlib/src/System/Runtime/Remoting/ObjectHandle.cs b/src/mscorlib/src/System/Runtime/Remoting/ObjectHandle.cs
index 5555670498..ed3444e15d 100644
--- a/src/mscorlib/src/System/Runtime/Remoting/ObjectHandle.cs
+++ b/src/mscorlib/src/System/Runtime/Remoting/ObjectHandle.cs
@@ -19,10 +19,7 @@ namespace System.Runtime.Remoting
     using System;
     using System.Runtime.InteropServices;
 
-    [ClassInterface(ClassInterfaceType.AutoDual)]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public class ObjectHandle: 
-        IObjectHandle 
+    public class ObjectHandle 
     {
         private Object WrappedObject;
         
@@ -30,12 +27,12 @@ namespace System.Runtime.Remoting
         {
         }
 
-        public ObjectHandle(Object o)
+        internal ObjectHandle(Object o)
         {
             WrappedObject = o;
         }
 
-        public Object Unwrap()
+        internal Object Unwrap()
         {
             return WrappedObject;
         }
diff --git a/src/mscorlib/src/System/Runtime/Serialization/FormatterConverter.cs b/src/mscorlib/src/System/Runtime/Serialization/FormatterConverter.cs
index b710ed0b3a..27f7ecf9d2 100644
--- a/src/mscorlib/src/System/Runtime/Serialization/FormatterConverter.cs
+++ b/src/mscorlib/src/System/Runtime/Serialization/FormatterConverter.cs
@@ -17,8 +17,7 @@ namespace System.Runtime.Serialization {
     using System.Globalization;
     using System.Diagnostics.Contracts;
 
-[System.Runtime.InteropServices.ComVisible(true)]
-    public class FormatterConverter : IFormatterConverter {
+    internal class FormatterConverter : IFormatterConverter {
 
         public FormatterConverter() {
         }
diff --git a/src/mscorlib/src/System/Runtime/Serialization/FormatterServices.cs b/src/mscorlib/src/System/Runtime/Serialization/FormatterServices.cs
index 4257b2c274..c3f9eb4452 100644
--- a/src/mscorlib/src/System/Runtime/Serialization/FormatterServices.cs
+++ b/src/mscorlib/src/System/Runtime/Serialization/FormatterServices.cs
@@ -18,7 +18,6 @@ namespace System.Runtime.Serialization {
     using System.Collections;
     using System.Collections.Generic;
     using System.Security;    
-    using System.Security.Permissions;
     using System.Runtime.Remoting;
     using System.Runtime.CompilerServices;
     using System.Runtime.Versioning;
@@ -29,7 +28,6 @@ namespace System.Runtime.Serialization {
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public static class FormatterServices {
     
         // Gets a new instance of the object.  The entire object is initalized to 0 and no 
@@ -52,173 +50,9 @@ namespace System.Runtime.Serialization {
             return nativeGetUninitializedObject((RuntimeType)type);
         }
     
-        public static Object GetSafeUninitializedObject(Type type) {
-             if ((object)type == null) {
-                throw new ArgumentNullException(nameof(type));
-            }
-             Contract.EndContractBlock();
-
-            if (!(type is RuntimeType)) {
-                throw new SerializationException(Environment.GetResourceString("Serialization_InvalidType", type.ToString()));
-            }
-
-            try {
-                return nativeGetSafeUninitializedObject((RuntimeType)type);
-            }
-            catch(SecurityException e) {
-                throw new SerializationException(Environment.GetResourceString("Serialization_Security",  type.FullName), e);
-            }
-        }
-
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        private static extern Object nativeGetSafeUninitializedObject(RuntimeType type);
-    
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         private static extern Object nativeGetUninitializedObject(RuntimeType type);
         private static Binder s_binder = Type.DefaultBinder;
-        internal static void SerializationSetValue(MemberInfo fi, Object target, Object value)
-        {
-            Contract.Requires(fi != null);
-
-            RtFieldInfo rtField = fi as RtFieldInfo;
-
-            if (rtField != null)
-            {
-                rtField.CheckConsistency(target);
-                rtField.UnsafeSetValue(target, value, BindingFlags.Default, s_binder, null);
-                return;
-            }
-
-            SerializationFieldInfo serField = fi as SerializationFieldInfo;
-            if (serField != null)
-            {
-                serField.InternalSetValue(target, value, BindingFlags.Default, s_binder, null);
-                return;
-            }
-
-            throw new ArgumentException(Environment.GetResourceString("Argument_InvalidFieldInfo"));
-        }
-
-        // Fill in the members of obj with the data contained in data.
-        // Returns the number of members populated.
-        //
-        public static Object PopulateObjectMembers(Object obj, MemberInfo[] members, Object[] data) {
-            if (obj==null) {
-                throw new ArgumentNullException(nameof(obj));
-            }
-
-            if (members==null) {
-                throw new ArgumentNullException(nameof(members));
-            }
-
-            if (data==null) {
-                throw new ArgumentNullException(nameof(data));
-            }
-
-            if (members.Length!=data.Length) {
-                throw new ArgumentException(Environment.GetResourceString("Argument_DataLengthDifferent"));
-            }
-            Contract.EndContractBlock();
-
-            MemberInfo mi;
-
-            BCLDebug.Trace("SER", "[PopulateObjectMembers]Enter.");
-
-            for (int i=0; i<members.Length; i++) {
-                mi = members[i];
-    
-                if (mi==null) {
-                    throw new ArgumentNullException(nameof(members), Environment.GetResourceString("ArgumentNull_NullMember", i));
-                }
-        
-                //If we find an empty, it means that the value was never set during deserialization.
-                //This is either a forward reference or a null.  In either case, this may break some of the
-                //invariants mantained by the setter, so we'll do nothing with it for right now.
-                if (data[i]!=null) {
-                    if (mi.MemberType==MemberTypes.Field) {
-                        SerializationSetValue(mi, obj, data[i]);
-                    } else {
-                        throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMemberInfo"));
-                    }
-
-                    BCLDebug.Trace("SER", "[PopulateObjectMembers]\tType:", obj.GetType(), "\tMember:", 
-                                   members[i].Name, " with member type: ", ((FieldInfo)members[i]).FieldType);
-                }
-                //Console.WriteLine("X");
-            }
-            
-            BCLDebug.Trace("SER", "[PopulateObjectMembers]Leave.");
-
-            return obj;
-        }
-    
-        // Extracts the data from obj.  members is the array of members which we wish to
-        // extract (must be FieldInfos or PropertyInfos).  For each supplied member, extract the matching value and
-        // return it in a Object[] of the same size.
-        //
-        public static Object[] GetObjectData(Object obj, MemberInfo[] members) {
-    
-            if (obj==null) {
-                throw new ArgumentNullException(nameof(obj));
-            }
-    
-            if (members==null) {
-                throw new ArgumentNullException(nameof(members));
-            }
-            Contract.EndContractBlock();
-            
-            int numberOfMembers = members.Length;
-    
-            Object[] data = new Object[numberOfMembers];
-            MemberInfo mi;
-    
-            for (int i=0; i<numberOfMembers; i++) {
-                mi=members[i];
-    
-                if (mi==null) {
-                    throw new ArgumentNullException(nameof(members), Environment.GetResourceString("ArgumentNull_NullMember", i));
-                }
-    
-                if (mi.MemberType==MemberTypes.Field) {
-                    Debug.Assert(mi is RuntimeFieldInfo || mi is SerializationFieldInfo,
-                                    "[FormatterServices.GetObjectData]mi is RuntimeFieldInfo || mi is SerializationFieldInfo.");
-
-                    RtFieldInfo rfi = mi as RtFieldInfo;
-                    if (rfi != null) {
-                        rfi.CheckConsistency(obj);
-                        data[i] = rfi.UnsafeGetValue(obj);
-                    } else {
-                        data[i] = ((SerializationFieldInfo)mi).InternalGetValue(obj);
-                    }
-                } else {
-                    throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMemberInfo"));
-                }
-            }
-    
-            return data;
-        }
-
-        [System.Runtime.InteropServices.ComVisible(false)]
-        public static ISerializationSurrogate GetSurrogateForCyclicalReference(ISerializationSurrogate innerSurrogate)
-        {
-            if (innerSurrogate == null)
-                throw new ArgumentNullException(nameof(innerSurrogate));
-            Contract.EndContractBlock();
-            return new SurrogateForCyclicalReference(innerSurrogate);
-        }
-
-        /*=============================GetTypeFromAssembly==============================
-        **Action:
-        **Returns:
-        **Arguments:
-        **Exceptions:
-        ==============================================================================*/
-        public static Type GetTypeFromAssembly(Assembly assem, String name) {
-            if (assem==null)
-                throw new ArgumentNullException(nameof(assem));
-            Contract.EndContractBlock();
-            return assem.GetType(name, false, false);
-        }
     
         /*============================LoadAssemblyFromString============================
         **Action: Loads an assembly from a given string.  The current assembly loading story
@@ -239,99 +73,6 @@ namespace System.Runtime.Serialization {
             Assembly found = Assembly.Load(assemblyName);
             return found;
         }
-
-        internal static Assembly LoadAssemblyFromStringNoThrow(String assemblyName) {
-            try {
-                return LoadAssemblyFromString(assemblyName);
-            }
-            catch (Exception e){
-                BCLDebug.Trace("SER", "[LoadAssemblyFromString]", e.ToString());
-            }
-            return null;
-        }
-
-        internal static string GetClrAssemblyName(Type type, out bool hasTypeForwardedFrom) {
-            if ((object)type == null) {
-                throw new ArgumentNullException(nameof(type));
-            }
-
-            object[] typeAttributes = type.GetCustomAttributes(typeof(TypeForwardedFromAttribute), false);
-            if (typeAttributes != null && typeAttributes.Length > 0) {
-                hasTypeForwardedFrom = true;
-                TypeForwardedFromAttribute typeForwardedFromAttribute = (TypeForwardedFromAttribute)typeAttributes[0];
-                return typeForwardedFromAttribute.AssemblyFullName;
-            }
-            else {
-                hasTypeForwardedFrom = false;
-                return type.Assembly.FullName;
-            }
-        }
-
-        internal static string GetClrTypeFullName(Type type) {
-            if (type.IsArray) {
-                return GetClrTypeFullNameForArray(type);
-            }
-            else {
-                return GetClrTypeFullNameForNonArrayTypes(type);
-            }
-        }
-
-        static string GetClrTypeFullNameForArray(Type type) {
-            int rank = type.GetArrayRank();
-            if (rank == 1)
-            {
-                return String.Format(CultureInfo.InvariantCulture, "{0}{1}", GetClrTypeFullName(type.GetElementType()), "[]");
-            }
-            else
-            {
-                StringBuilder builder = new StringBuilder(GetClrTypeFullName(type.GetElementType())).Append("[");
-                for (int commaIndex = 1; commaIndex < rank; commaIndex++)
-                {
-                    builder.Append(",");
-                }
-                builder.Append("]");
-                return builder.ToString();
-            }
-        }
-
-        static string GetClrTypeFullNameForNonArrayTypes(Type type) {
-            if (!type.IsGenericType) {
-                return type.FullName;
-            }
-
-            Type[] genericArguments = type.GetGenericArguments();
-            StringBuilder builder = new StringBuilder(type.GetGenericTypeDefinition().FullName).Append("[");
-            bool hasTypeForwardedFrom;
-
-            foreach (Type genericArgument in genericArguments) {
-                builder.Append("[").Append(GetClrTypeFullName(genericArgument)).Append(", ");
-                builder.Append(GetClrAssemblyName(genericArgument, out hasTypeForwardedFrom)).Append("],");
-            }
-
-            //remove the last comma and close typename for generic with a close bracket
-            return builder.Remove(builder.Length - 1, 1).Append("]").ToString();
-        }
-    }
-
-    internal sealed class SurrogateForCyclicalReference : ISerializationSurrogate
-    {
-        ISerializationSurrogate innerSurrogate;
-        internal SurrogateForCyclicalReference(ISerializationSurrogate innerSurrogate)
-        {
-            if (innerSurrogate == null)
-                throw new ArgumentNullException(nameof(innerSurrogate));
-            this.innerSurrogate = innerSurrogate;
-        }
-
-        public void GetObjectData(Object obj, SerializationInfo info, StreamingContext context)
-        {
-            innerSurrogate.GetObjectData(obj, info, context);
-        }
-        
-        public Object SetObjectData(Object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
-        {
-            return innerSurrogate.SetObjectData(obj, info, context, selector);
-        }
     }
 }
 
diff --git a/src/mscorlib/src/System/Runtime/Serialization/IDeserializationCallback.cs b/src/mscorlib/src/System/Runtime/Serialization/IDeserializationCallback.cs
index e2497e5d34..2911a4016e 100644
--- a/src/mscorlib/src/System/Runtime/Serialization/IDeserializationCallback.cs
+++ b/src/mscorlib/src/System/Runtime/Serialization/IDeserializationCallback.cs
@@ -16,7 +16,6 @@ namespace System.Runtime.Serialization {
     using System;
 
     // Interface does not need to be marked with the serializable attribute    
-    [System.Runtime.InteropServices.ComVisible(true)]
     public interface IDeserializationCallback {
         void OnDeserialization(Object sender);
     }
diff --git a/src/mscorlib/src/System/Runtime/Serialization/IFormatter.cs b/src/mscorlib/src/System/Runtime/Serialization/IFormatter.cs
deleted file mode 100644
index 8d91d95acf..0000000000
--- a/src/mscorlib/src/System/Runtime/Serialization/IFormatter.cs
+++ /dev/null
@@ -1,41 +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.
-
-/*============================================================
-**
-** Interface: IFormatter;
-**
-**
-** Purpose: The interface for all formatters.
-**
-**
-===========================================================*/
-namespace System.Runtime.Serialization {
-    using System.Runtime.Remoting;
-    using System;
-    using System.IO;
-
-[System.Runtime.InteropServices.ComVisible(true)]
-    public interface IFormatter {
-        Object Deserialize(Stream serializationStream);
-
-        void Serialize(Stream serializationStream, Object graph);
-
-
-        ISurrogateSelector SurrogateSelector {
-            get;
-            set;
-        }
-
-        SerializationBinder Binder {
-            get;
-            set;
-        }
-
-        StreamingContext Context {
-            get;
-            set;
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Runtime/Serialization/IFormatterConverter.cs b/src/mscorlib/src/System/Runtime/Serialization/IFormatterConverter.cs
index 182cc93412..0be0db9acd 100644
--- a/src/mscorlib/src/System/Runtime/Serialization/IFormatterConverter.cs
+++ b/src/mscorlib/src/System/Runtime/Serialization/IFormatterConverter.cs
@@ -17,7 +17,6 @@ namespace System.Runtime.Serialization {
     using System;
 
     [CLSCompliant(false)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public interface IFormatterConverter {
         Object Convert(Object value, Type type);
         Object Convert(Object value, TypeCode typeCode);
diff --git a/src/mscorlib/src/System/Runtime/Serialization/IObjectReference.cs b/src/mscorlib/src/System/Runtime/Serialization/IObjectReference.cs
index 42662a10f6..ef5ee6ade0 100644
--- a/src/mscorlib/src/System/Runtime/Serialization/IObjectReference.cs
+++ b/src/mscorlib/src/System/Runtime/Serialization/IObjectReference.cs
@@ -18,9 +18,7 @@
 namespace System.Runtime.Serialization {
 
     using System;
-    using System.Security.Permissions;
     // Interface does not need to be marked with the serializable attribute
-[System.Runtime.InteropServices.ComVisible(true)]
     public interface IObjectReference {
         Object GetRealObject(StreamingContext context);
     }
diff --git a/src/mscorlib/src/System/Runtime/Serialization/ISerializable.cs b/src/mscorlib/src/System/Runtime/Serialization/ISerializable.cs
index fc283d41f1..816aa0484b 100644
--- a/src/mscorlib/src/System/Runtime/Serialization/ISerializable.cs
+++ b/src/mscorlib/src/System/Runtime/Serialization/ISerializable.cs
@@ -16,11 +16,9 @@
 namespace System.Runtime.Serialization {
     using System.Runtime.Remoting;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     using System;
     using System.Reflection;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public interface ISerializable {
         void GetObjectData(SerializationInfo info, StreamingContext context);
     }
diff --git a/src/mscorlib/src/System/Runtime/Serialization/ISerializationSurrogate.cs b/src/mscorlib/src/System/Runtime/Serialization/ISerializationSurrogate.cs
deleted file mode 100644
index 226bbdcc75..0000000000
--- a/src/mscorlib/src/System/Runtime/Serialization/ISerializationSurrogate.cs
+++ /dev/null
@@ -1,34 +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.
-
-/*============================================================
-**
-** Interface: ISurrogate
-**
-**
-** Purpose: The interface implemented by an object which
-**          supports surrogates.
-**
-**
-===========================================================*/
-namespace System.Runtime.Serialization {
-    using System.Runtime.Remoting;
-    using System.Runtime.Serialization;
-    using System.Security.Permissions;
-    using System;
-    using System.Reflection;
-[System.Runtime.InteropServices.ComVisible(true)]
-    public interface ISerializationSurrogate {
-    // Interface does not need to be marked with the serializable attribute
-        // Returns a SerializationInfo completely populated with all of the data needed to reinstantiate the
-        // the object at the other end of serialization.  
-        //
-        void GetObjectData(Object obj, SerializationInfo info, StreamingContext context);
-    
-        // Reinflate the object using all of the information in data.  The information in
-        // members is used to find the particular field or property which needs to be set.
-        // 
-        Object SetObjectData(Object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector);
-    }
-}
diff --git a/src/mscorlib/src/System/Runtime/Serialization/ISurrogateSelector.cs b/src/mscorlib/src/System/Runtime/Serialization/ISurrogateSelector.cs
deleted file mode 100644
index 87b7845894..0000000000
--- a/src/mscorlib/src/System/Runtime/Serialization/ISurrogateSelector.cs
+++ /dev/null
@@ -1,34 +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.
-
-/*============================================================
-**
-** Interface: ISurrogateSelector
-**
-**
-** Purpose: A user-supplied class for doing the type to surrogate
-**          mapping.
-**
-**
-===========================================================*/
-namespace System.Runtime.Serialization {
-
-    using System.Runtime.Remoting;
-    using System.Security.Permissions;
-    using System;
-[System.Runtime.InteropServices.ComVisible(true)]
-    public interface ISurrogateSelector {
-        // Interface does not need to be marked with the serializable attribute
-        // Specifies the next ISurrogateSelector to be examined for surrogates if the current
-        // instance doesn't have a surrogate for the given type and assembly in the given context.
-        void ChainSelector(ISurrogateSelector selector);
-    
-        // Returns the appropriate surrogate for the given type in the given context.
-        ISerializationSurrogate GetSurrogate(Type type, StreamingContext context, out ISurrogateSelector selector);
-    
-    
-        // Return the next surrogate in the chain. Returns null if no more exist.
-        ISurrogateSelector GetNextSelector();
-    }
-}
diff --git a/src/mscorlib/src/System/Runtime/Serialization/MemberHolder.cs b/src/mscorlib/src/System/Runtime/Serialization/MemberHolder.cs
deleted file mode 100644
index 1303e40c27..0000000000
--- a/src/mscorlib/src/System/Runtime/Serialization/MemberHolder.cs
+++ /dev/null
@@ -1,51 +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: This is a lightweight class designed to hold the members 
-**          and StreamingContext for a particular class.
-**
-**
-============================================================*/
-namespace System.Runtime.Serialization {
-
-    using System.Runtime.Remoting;
-    using System;
-    using System.Reflection;
-    [Serializable]
-    internal class MemberHolder {
-// disable csharp compiler warning #0414: field assigned unused value
-#pragma warning disable 0414
-        internal MemberInfo[] members = null;
-#pragma warning restore 0414
-        internal Type memberType;
-        internal StreamingContext context;
-        
-        internal MemberHolder(Type type, StreamingContext ctx) {
-            memberType = type;
-            context = ctx;
-        }
-    
-        public override int GetHashCode() {
-            return memberType.GetHashCode();
-        }
-    
-        public override bool Equals(Object obj) {
-            if (!(obj is MemberHolder)) {
-                return false;
-            }
-            
-            MemberHolder temp = (MemberHolder)obj;
-    
-            if (Object.ReferenceEquals(temp.memberType, memberType) && temp.context.State == context.State) {
-                return true;
-            }
-            
-            return false;
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Runtime/Serialization/SafeSerializationManager.cs b/src/mscorlib/src/System/Runtime/Serialization/SafeSerializationManager.cs
index 4160979dc5..260e873bc7 100644
--- a/src/mscorlib/src/System/Runtime/Serialization/SafeSerializationManager.cs
+++ b/src/mscorlib/src/System/Runtime/Serialization/SafeSerializationManager.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// 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.
 using System;
@@ -211,10 +211,7 @@ namespace System.Runtime.Serialization
         private StreamingContext m_streamingContext;
         private List<object> m_serializedStates = new List<object>();
 
-        internal SafeSerializationEventArgs(StreamingContext streamingContext)
-        {
-            m_streamingContext = streamingContext;
-        }
+        internal SafeSerializationEventArgs() {}
 
         public void AddSerializedState(ISafeSerializationData serializedState)
         {
@@ -226,11 +223,6 @@ namespace System.Runtime.Serialization
             m_serializedStates.Add(serializedState);
         }
 
-        internal IList<object> SerializedStates
-        {
-            get { return m_serializedStates; }
-        }
-
         public StreamingContext StreamingContext
         {
             get { return m_streamingContext; }
diff --git a/src/mscorlib/src/System/Runtime/Serialization/SerializationAttributes.cs b/src/mscorlib/src/System/Runtime/Serialization/SerializationAttributes.cs
index 27c5751cc6..38abffa66e 100644
--- a/src/mscorlib/src/System/Runtime/Serialization/SerializationAttributes.cs
+++ b/src/mscorlib/src/System/Runtime/Serialization/SerializationAttributes.cs
@@ -17,7 +17,6 @@ namespace System.Runtime.Serialization
     using System.Reflection;
 
     [AttributeUsage(AttributeTargets.Field, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class OptionalFieldAttribute : Attribute 
     {
         int versionAdded = 1;
@@ -38,25 +37,21 @@ namespace System.Runtime.Serialization
     }
 
     [AttributeUsage(AttributeTargets.Method, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class OnSerializingAttribute : Attribute 
     {
     }
 
     [AttributeUsage(AttributeTargets.Method, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class OnSerializedAttribute : Attribute 
     {
     }
 
     [AttributeUsage(AttributeTargets.Method, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class OnDeserializingAttribute : Attribute 
     {
     }
 
     [AttributeUsage(AttributeTargets.Method, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class OnDeserializedAttribute : Attribute 
     {
     }
diff --git a/src/mscorlib/src/System/Runtime/Serialization/SerializationBinder.cs b/src/mscorlib/src/System/Runtime/Serialization/SerializationBinder.cs
deleted file mode 100644
index 7457991008..0000000000
--- a/src/mscorlib/src/System/Runtime/Serialization/SerializationBinder.cs
+++ /dev/null
@@ -1,29 +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.
-
-/*============================================================
-**
-** Interface: SerializationBinder
-**
-**
-** Purpose: The base class of serialization binders.
-**
-**
-===========================================================*/
-namespace System.Runtime.Serialization {
-    using System;
-
-    [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public abstract class SerializationBinder {
-
-        public virtual void BindToName(Type serializedType, out String assemblyName, out String typeName)
-        {
-            assemblyName = null;
-            typeName = null;
-        }
-
-        public abstract Type BindToType(String assemblyName, String typeName);
-    }
-}
diff --git a/src/mscorlib/src/System/Runtime/Serialization/SerializationException.cs b/src/mscorlib/src/System/Runtime/Serialization/SerializationException.cs
index b88ccfd706..e9cb79b7af 100644
--- a/src/mscorlib/src/System/Runtime/Serialization/SerializationException.cs
+++ b/src/mscorlib/src/System/Runtime/Serialization/SerializationException.cs
@@ -17,7 +17,6 @@ namespace System.Runtime.Serialization {
     using System;
     using System.Runtime.Serialization;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class SerializationException : SystemException {
         
diff --git a/src/mscorlib/src/System/Runtime/Serialization/SerializationFieldInfo.cs b/src/mscorlib/src/System/Runtime/Serialization/SerializationFieldInfo.cs
deleted file mode 100644
index 82536ce3b4..0000000000
--- a/src/mscorlib/src/System/Runtime/Serialization/SerializationFieldInfo.cs
+++ /dev/null
@@ -1,136 +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 methods of representing imaginary fields
-** which are unique to serialization.  In this case, what we're
-** representing is the private members of parent classes.  We
-** aggregate the RuntimeFieldInfo associated with this member 
-** and return a managled form of the name.  The name that we
-** return is .parentname.fieldname
-**
-**
-============================================================*/
-
-namespace System.Runtime.Serialization {
-
-    using System;
-    using System.Reflection;
-    using System.Globalization;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-    using System.Threading;
-
-    internal sealed class SerializationFieldInfo : FieldInfo {
-
-        internal const String FakeNameSeparatorString = "+";
-
-        private RuntimeFieldInfo m_field;
-        private String           m_serializationName;
-
-        public override Module Module { get { return m_field.Module; } }
-        public override int MetadataToken { get { return m_field.MetadataToken; } } 
-
-        internal SerializationFieldInfo(RuntimeFieldInfo field, String namePrefix) {
-            Debug.Assert(field!=null,      "[SerializationFieldInfo.ctor]field!=null");
-            Debug.Assert(namePrefix!=null, "[SerializationFieldInfo.ctor]namePrefix!=null");
-            
-            m_field = field;
-            m_serializationName = String.Concat(namePrefix, FakeNameSeparatorString, m_field.Name);
-        }
-
-        //
-        // MemberInfo methods
-        //
-        public override String Name {
-            get {
-                return m_serializationName;
-            }
-        }
-
-        public override Type DeclaringType {
-            get {
-                return m_field.DeclaringType;
-            }
-        }
-
-        public override Type ReflectedType {
-            get {
-                return m_field.ReflectedType;
-            }
-        }
-
-        public override Object[] GetCustomAttributes(bool inherit) {
-            return m_field.GetCustomAttributes(inherit);
-        }
-
-        public override Object[] GetCustomAttributes(Type attributeType, bool inherit) {
-            return m_field.GetCustomAttributes(attributeType, inherit);
-        }
-
-        public override bool IsDefined(Type attributeType, bool inherit) {
-            return m_field.IsDefined(attributeType, inherit);
-        }
-
-        //
-        // FieldInfo methods
-        //
-        public override Type FieldType {
-            get {
-                return m_field.FieldType;
-            }
-        }
-        
-        public override Object GetValue(Object obj) {
-            return m_field.GetValue(obj);
-        }
-
-        internal Object InternalGetValue(Object obj) {
-            RtFieldInfo field = m_field as RtFieldInfo;
-            if (field != null)
-            {
-                field.CheckConsistency(obj);
-                return field.UnsafeGetValue(obj);
-            }
-            else
-                return m_field.GetValue(obj);
-        }
-
-        public override void SetValue(Object obj, Object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture) {
-            m_field.SetValue(obj, value, invokeAttr, binder, culture);
-        }
-
-        internal void InternalSetValue(Object obj, Object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture) {
-            RtFieldInfo field = m_field as RtFieldInfo;
-            if (field != null)
-            {
-                field.CheckConsistency(obj);
-                field.UnsafeSetValue(obj, value, invokeAttr, binder, culture);
-            }
-            else
-                m_field.SetValue(obj, value, invokeAttr, binder, culture);
-        }
-
-        internal RuntimeFieldInfo FieldInfo {
-            get {
-                return m_field;
-            }
-        }
-
-        public override RuntimeFieldHandle FieldHandle {
-            get {
-                return m_field.FieldHandle;
-            }
-        }
-
-        public override FieldAttributes Attributes {
-            get {
-                return m_field.Attributes;
-            }
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Runtime/Serialization/SerializationInfo.cs b/src/mscorlib/src/System/Runtime/Serialization/SerializationInfo.cs
index 55909c85fd..45521f2397 100644
--- a/src/mscorlib/src/System/Runtime/Serialization/SerializationInfo.cs
+++ b/src/mscorlib/src/System/Runtime/Serialization/SerializationInfo.cs
@@ -24,7 +24,6 @@ namespace System.Runtime.Serialization
     using System.Security;
     using System.Runtime.CompilerServices;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class SerializationInfo
     {
         private const int defaultSize = 4;
@@ -146,49 +145,10 @@ namespace System.Runtime.Serialization
             }
         }
 
-        private static bool Compare(byte[] a, byte[] b)
-        {
-            // if either or both assemblies do not have public key token, we should demand, hence, returning false will force a demand
-            if (a == null || b == null || a.Length == 0 || b.Length == 0 || a.Length != b.Length)
-            {
-                return false;
-            }
-            else
-            {
-                for (int i = 0; i < a.Length; i++)
-                {
-                    if (a[i] != b[i]) return false;
-                }
-
-                return true;
-            }
-        }
-
         internal static void DemandForUnsafeAssemblyNameAssignments(string originalAssemblyName, string newAssemblyName)
         {
         }
 
-        internal static bool IsAssemblyNameAssignmentSafe(string originalAssemblyName, string newAssemblyName)
-        {
-            if (originalAssemblyName == newAssemblyName)
-            {
-                return true;
-            }
-
-            AssemblyName originalAssembly = new AssemblyName(originalAssemblyName);
-            AssemblyName newAssembly = new AssemblyName(newAssemblyName);
-
-            // mscorlib will get loaded by the runtime regardless of its string casing or its public key token,
-            // so setting the assembly name to mscorlib must always be protected by a demand
-            if (string.Equals(newAssembly.Name, s_mscorlibAssemblySimpleName, StringComparison.OrdinalIgnoreCase) ||
-                string.Equals(newAssembly.Name, s_mscorlibFileName, StringComparison.OrdinalIgnoreCase))
-            {
-                return false;
-            }
-
-            return Compare(originalAssembly.GetPublicKeyToken(), newAssembly.GetPublicKeyToken());
-        }
-
         public int MemberCount
         {
             get
@@ -467,7 +427,6 @@ namespace System.Runtime.Serialization
             return m_data[index];
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         private Object GetElementNoThrow(String name, out Type foundType)
         {
             int index = FindElement(name);
@@ -518,7 +477,6 @@ namespace System.Runtime.Serialization
             return m_converter.Convert(value, type);
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         internal Object GetValueNoThrow(String name, Type type)
         {
             Type foundType;
@@ -741,22 +699,5 @@ namespace System.Runtime.Serialization
             return m_converter.ToString(value);
         }
 
-        internal string[] MemberNames
-        {
-            get
-            {
-                return m_members;
-            }
-
-        }
-
-        internal object[] MemberValues
-        {
-            get
-            {
-                return m_data;
-            }
-        }
-
     }
 }
diff --git a/src/mscorlib/src/System/Runtime/Serialization/SerializationInfoEnumerator.cs b/src/mscorlib/src/System/Runtime/Serialization/SerializationInfoEnumerator.cs
index 32c65492e1..0858dfc19f 100644
--- a/src/mscorlib/src/System/Runtime/Serialization/SerializationInfoEnumerator.cs
+++ b/src/mscorlib/src/System/Runtime/Serialization/SerializationInfoEnumerator.cs
@@ -21,7 +21,6 @@ namespace System.Runtime.Serialization {
     //
     // The tuple returned by SerializationInfoEnumerator.Current.
     //
-[System.Runtime.InteropServices.ComVisible(true)]
     public struct SerializationEntry {
         private Type   m_type;
         private Object m_value;
@@ -57,7 +56,6 @@ namespace System.Runtime.Serialization {
     // This does not snapshot the values, it just keeps pointers to the 
     // member variables of the SerializationInfo that created it.
     //
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class SerializationInfoEnumerator : IEnumerator {
         String[] m_members;
         Object[] m_data;
diff --git a/src/mscorlib/src/System/Runtime/Serialization/StreamingContext.cs b/src/mscorlib/src/System/Runtime/Serialization/StreamingContext.cs
index ef4a096a51..c01a3edc4f 100644
--- a/src/mscorlib/src/System/Runtime/Serialization/StreamingContext.cs
+++ b/src/mscorlib/src/System/Runtime/Serialization/StreamingContext.cs
@@ -16,7 +16,6 @@ namespace System.Runtime.Serialization {
     using System.Runtime.Remoting;
     using System;
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public struct StreamingContext {
         internal Object m_additionalContext;
         internal StreamingContextStates m_state;
@@ -59,7 +58,6 @@ namespace System.Runtime.Serialization {
     // **********************************************************
 [Serializable]
 [Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum StreamingContextStates {
         CrossProcess=0x01,
         CrossMachine=0x02,
diff --git a/src/mscorlib/src/System/Runtime/Versioning/CompatibilitySwitch.cs b/src/mscorlib/src/System/Runtime/Versioning/CompatibilitySwitch.cs
index 6bf8f8cf45..3410f020be 100644
--- a/src/mscorlib/src/System/Runtime/Versioning/CompatibilitySwitch.cs
+++ b/src/mscorlib/src/System/Runtime/Versioning/CompatibilitySwitch.cs
@@ -7,7 +7,7 @@ using System.Runtime.CompilerServices;
 
 namespace System.Runtime.Versioning
 {
-    public static class CompatibilitySwitch
+    internal static class CompatibilitySwitch
     {
         /* This class contains 3 sets of api:
                 * 1. internal apis : These apis are supposed to be used by mscorlib.dll and other assemblies which use the <runtime> section in config 
@@ -19,38 +19,14 @@ namespace System.Runtime.Versioning
                 * 3. specialized apis: These apis are defined in order to retrieve a specific value defined in CLR Config. That value can have specific look-up rules
                 *                        for the order and location of the config sources used.
                 *                        
-                *     These apis are for internal use only for FX assmeblies. It has not been decided if they can be used by OOB components due to EULA restrictions
+                *     These apis are for internal use only for FX assemblies. It has not been decided if they can be used by OOB components due to EULA restrictions
                 */
-        public static bool IsEnabled(string compatibilitySwitchName)
-        {
-            return IsEnabledInternalCall(compatibilitySwitchName, true);
-        }
-
-        public static string GetValue(string compatibilitySwitchName)
-        {
-            // This is used by AppContext.TryGetSwitch to check switch overrides in the Windows Quirk DB
-            // If this method is updated to check other locations than the DB, please ensure compat with 
-            // the AppContext class.
-            return GetValueInternalCall(compatibilitySwitchName, true);
-        }
-
-        internal static bool IsEnabledInternal(string compatibilitySwitchName)
-        {
-            return IsEnabledInternalCall(compatibilitySwitchName, false);
-        }
-
         internal static string GetValueInternal(string compatibilitySwitchName)
         {
             return GetValueInternalCall(compatibilitySwitchName, false);
         }
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal static extern string GetAppContextOverridesInternalCall();
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool IsEnabledInternalCall(string compatibilitySwitchName, bool onlyDB);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern string GetValueInternalCall(string compatibilitySwitchName, bool onlyDB);
     }
 }
diff --git a/src/mscorlib/src/System/Runtime/Versioning/TargetFrameworkId.cs b/src/mscorlib/src/System/Runtime/Versioning/TargetFrameworkId.cs
deleted file mode 100644
index 0a5e668a92..0000000000
--- a/src/mscorlib/src/System/Runtime/Versioning/TargetFrameworkId.cs
+++ /dev/null
@@ -1,28 +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: Describe the target framework of the application or AppDomain.
-**
-===========================================================*/
-using System;
-using System.Runtime.CompilerServices;
-
-namespace System.Runtime.Versioning
-{
-    // What type of .NET Framework was this application compiled against?
-    [FriendAccessAllowed]
-    internal enum TargetFrameworkId
-    {
-        NotYetChecked = 0,
-        Unrecognized = 1, // Unknown type, such as a new SKU (like watches or cars)
-        Unspecified = 2, // The TargetFrameworkAttribute was created in v4.0.  And apps compiled outside VS will not have this attribute.
-        NetFramework = 3, // Desktop - Client or Server or ServerCore.
-        Portable = 4, // Portable Library v1   Note: We do not expect people to build executables against portable libraries!
-        NetCore = 5, // .NET Core = Windows 8 Immersive and Portable Library v2+
-        Silverlight = 6, // Silverlight but not the Phone
-        Phone = 7, // Windows Phone 7 or higher
-    }
-}
diff --git a/src/mscorlib/src/System/RuntimeArgumentHandle.cs b/src/mscorlib/src/System/RuntimeArgumentHandle.cs
index d1bc86b49a..3e13614930 100644
--- a/src/mscorlib/src/System/RuntimeArgumentHandle.cs
+++ b/src/mscorlib/src/System/RuntimeArgumentHandle.cs
@@ -13,7 +13,6 @@ namespace System {
     //  This corresponds to EE VARARGS cookie.
 
     // Cannot be serialized
-    [System.Runtime.InteropServices.ComVisible(true)]
     public struct RuntimeArgumentHandle
     {
         private IntPtr m_ptr;
diff --git a/src/mscorlib/src/System/RuntimeHandles.cs b/src/mscorlib/src/System/RuntimeHandles.cs
index 2938dd0d92..39c85ad4e2 100644
--- a/src/mscorlib/src/System/RuntimeHandles.cs
+++ b/src/mscorlib/src/System/RuntimeHandles.cs
@@ -19,13 +19,11 @@ namespace System
     using System.Text;
     using System.Globalization;
     using System.Security;
-    using System.Security.Permissions;
     using Microsoft.Win32.SafeHandles;
     using System.Diagnostics.Contracts;
     using StackCrawlMark = System.Threading.StackCrawlMark;
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public unsafe struct RuntimeTypeHandle : ISerializable
     {
         // Returns handle for interop with EE. The handle is guaranteed to be non-null.
@@ -89,14 +87,6 @@ namespace System
         public static bool operator !=(RuntimeTypeHandle left, object right) { return !left.Equals(right); }
 
         public static bool operator !=(object left, RuntimeTypeHandle right) { return !right.Equals(left); }
-
-        internal static RuntimeTypeHandle EmptyHandle
-        {
-            get
-            {
-                return new RuntimeTypeHandle(null);
-            }
-        }
         
 
         // This is the RuntimeType for the type
@@ -107,7 +97,6 @@ namespace System
             return m_type != null ? m_type.GetHashCode() : 0;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public override bool Equals(object obj)
         {
             if(!(obj is RuntimeTypeHandle))
@@ -117,7 +106,6 @@ namespace System
             return handle.m_type == m_type;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public bool Equals(RuntimeTypeHandle handle)
         {
             return handle.m_type == m_type;
@@ -139,11 +127,6 @@ namespace System
             m_type = type;
         }
 
-        internal bool IsNullHandle() 
-        {
-            return m_type == null; 
-        }
-
         internal static bool IsPrimitive(RuntimeType type)
         {
             CorElementType corElemType = GetCorElementType(type);
@@ -243,11 +226,9 @@ namespace System
         internal extern static RuntimeAssembly GetAssembly(RuntimeType type);
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal extern static RuntimeModule GetModule(RuntimeType type);
 
         [CLSCompliant(false)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public ModuleHandle GetModuleHandle()
         {
             return new ModuleHandle(RuntimeTypeHandle.GetModule(m_type));
@@ -376,9 +357,6 @@ namespace System
         internal extern static bool IsComObject(RuntimeType type, bool isGenericCOM); 
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        internal extern static bool IsContextful(RuntimeType type); 
-
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
         internal extern static bool IsInterface(RuntimeType type);
 
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
@@ -423,9 +401,6 @@ namespace System
         }
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        internal extern static bool HasProxyAttribute(RuntimeType type);
-
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
         internal extern static bool IsValueType(RuntimeType type);
 
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
@@ -503,11 +478,6 @@ namespace System
             return type;
         }
 
-        internal static Type GetTypeByName(string name, ref StackCrawlMark stackMark)
-        {
-            return GetTypeByName(name, false, false, false, ref stackMark, false);
-        }
-
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
         [SuppressUnmanagedCodeSecurity]
         private extern static void GetTypeByNameUsingCARules(string name, RuntimeModule scope, ObjectHandleOnStack type);
@@ -612,11 +582,6 @@ namespace System
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         internal extern static bool HasInstantiation(RuntimeType type);
 
-        internal bool HasInstantiation()
-        {
-            return HasInstantiation(GetTypeChecked());
-        }
-
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
         [SuppressUnmanagedCodeSecurity]
         private extern static void GetGenericTypeDefinition(RuntimeTypeHandle type, ObjectHandleOnStack retType);
@@ -637,11 +602,6 @@ namespace System
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         internal extern static bool IsGenericVariable(RuntimeType type);
 
-        internal bool IsGenericVariable()
-        {
-            return IsGenericVariable(GetTypeChecked());
-        }
-
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         private extern static int GetGenericVariableIndex(RuntimeType type);
 
@@ -806,7 +766,6 @@ namespace System
     }
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public unsafe struct RuntimeMethodHandle : ISerializable
     {
         // Returns handle for interop with EE. The handle is guaranteed to be non-null.
@@ -817,11 +776,6 @@ namespace System
             return method;
         }
 
-        internal static RuntimeMethodHandle EmptyHandle
-        {
-            get { return new RuntimeMethodHandle(); }
-        }
-
         private IRuntimeMethodInfo m_value;
         
         internal RuntimeMethodHandle(IRuntimeMethodInfo method)
@@ -883,7 +837,6 @@ namespace System
             return ValueType.GetHashCodeOfPtr(Value);
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public override bool Equals(object obj)
         {
             if (!(obj is RuntimeMethodHandle))
@@ -904,7 +857,6 @@ namespace System
             return !left.Equals(right);
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public bool Equals(RuntimeMethodHandle handle)
         {
             return handle.Value == Value;
@@ -1032,52 +984,6 @@ namespace System
 
 #endregion
 
-        [DebuggerStepThroughAttribute]
-        [Diagnostics.DebuggerHidden]
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]        
-        internal extern static void SerializationInvoke(IRuntimeMethodInfo method,
-            Object target, SerializationInfo info, ref StreamingContext context);
-
-        // This returns true if the token is SecurityTransparent: 
-        // just the token - does not consider including module/type etc.
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        internal static extern bool _IsTokenSecurityTransparent(RuntimeModule module, int metaDataToken);
-        
-        internal static bool IsTokenSecurityTransparent(Module module, int metaDataToken)
-        {
-            return _IsTokenSecurityTransparent(module.ModuleHandle.GetRuntimeModule(), metaDataToken);
-        }
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        [return: MarshalAs(UnmanagedType.Bool)]
-        private static extern bool _IsSecurityCritical(IRuntimeMethodInfo method);
-
-        internal static bool IsSecurityCritical(IRuntimeMethodInfo method)
-        {
-            return _IsSecurityCritical(method);
-        }
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        [return: MarshalAs(UnmanagedType.Bool)]
-        private static extern bool _IsSecuritySafeCritical(IRuntimeMethodInfo method);
-
-        internal static bool IsSecuritySafeCritical(IRuntimeMethodInfo method)
-        {
-            return _IsSecuritySafeCritical(method);
-        }
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        [return: MarshalAs(UnmanagedType.Bool)]
-        private static extern bool _IsSecurityTransparent(IRuntimeMethodInfo method);
-
-        internal static bool IsSecurityTransparent(IRuntimeMethodInfo method)
-        {
-            return _IsSecurityTransparent(method);
-        }
-
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
 		[SuppressUnmanagedCodeSecurity]
         private extern static void GetMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack types, bool fAsRuntimeTypeArray);
@@ -1170,17 +1076,6 @@ namespace System
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         internal extern static Resolver GetResolver(RuntimeMethodHandleInternal method);
 
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        private static extern void GetCallerType(StackCrawlMarkHandle stackMark, ObjectHandleOnStack retType);
-    
-        internal static RuntimeType GetCallerType(ref StackCrawlMark stackMark)
-        {
-            RuntimeType type = null;
-            GetCallerType(JitHelpers.GetStackCrawlMarkHandle(ref stackMark), JitHelpers.GetObjectHandleOnStack(ref type));
-            return type;
-        }
-
         [MethodImpl(MethodImplOptions.InternalCall)]
         internal extern static MethodBody GetMethodBody(IRuntimeMethodInfo method, RuntimeType declaringType);
 
@@ -1202,13 +1097,6 @@ namespace System
     // When in doubt, do not use. 
     internal struct RuntimeFieldHandleInternal
     {
-        internal static RuntimeFieldHandleInternal EmptyHandle
-        {
-            get
-            {
-                return new RuntimeFieldHandleInternal();
-            }
-        }
 
         internal bool IsNullHandle()
         {
@@ -1242,11 +1130,6 @@ namespace System
     [StructLayout(LayoutKind.Sequential)]
     internal class RuntimeFieldInfoStub : IRuntimeFieldInfo
     {
-        public RuntimeFieldInfoStub(IntPtr methodHandleValue, object keepalive)
-        {
-            m_keepalive = keepalive;
-            m_fieldHandle = new RuntimeFieldHandleInternal(methodHandleValue);
-        }
 
         // These unused variables are used to ensure that this class has the same layout as RuntimeFieldInfo
 #pragma warning disable 169
@@ -1268,7 +1151,6 @@ namespace System
     }
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public unsafe struct RuntimeFieldHandle : ISerializable
     {
         // Returns handle for interop with EE. The handle is guaranteed to be non-null.
@@ -1311,7 +1193,6 @@ namespace System
             return ValueType.GetHashCodeOfPtr(Value);
         }
         
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public override bool Equals(object obj)
         {
             if (!(obj is RuntimeFieldHandle))
@@ -1322,7 +1203,6 @@ namespace System
             return handle.Value == Value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public unsafe bool Equals(RuntimeFieldHandle handle)
         {
             return handle.Value == Value;
@@ -1367,7 +1247,7 @@ namespace System
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]        
         internal static extern Object GetValue(RtFieldInfo field, Object instance, RuntimeType fieldType, RuntimeType declaringType, ref bool domainInitialized);
-
+        
         [MethodImplAttribute(MethodImplOptions.InternalCall)]        
         internal static extern Object GetValueDirect(RtFieldInfo field, RuntimeType fieldType, void *pTypedRef, RuntimeType contextType);
         
@@ -1450,7 +1330,6 @@ namespace System
         }
     }
 
-[System.Runtime.InteropServices.ComVisible(true)]
     public unsafe struct ModuleHandle
     {
         // Returns handle for interop with EE. The handle is guaranteed to be non-null.
@@ -1480,18 +1359,12 @@ namespace System
         {
             return m_ptr;
         }
-
-        internal bool IsNullHandle() 
-        { 
-            return m_ptr == null; 
-        }
         
         public override int GetHashCode()
         {           
             return m_ptr != null ? m_ptr.GetHashCode() : 0;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public override bool Equals(object obj)
         {
             if (!(obj is ModuleHandle))
@@ -1502,7 +1375,6 @@ namespace System
             return handle.m_ptr == m_ptr;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public unsafe bool Equals(ModuleHandle handle)
         {
             return handle.m_ptr == m_ptr;
@@ -1667,17 +1539,6 @@ namespace System
 
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
         [SuppressUnmanagedCodeSecurity]
-        private extern static void GetAssembly(RuntimeModule handle, ObjectHandleOnStack retAssembly);
-
-        internal static RuntimeAssembly GetAssembly(RuntimeModule module)
-        {
-            RuntimeAssembly retAssembly = null;
-            GetAssembly(module.GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref retAssembly));
-            return retAssembly;
-        }
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
         internal extern static void GetModuleType(RuntimeModule handle, ObjectHandleOnStack type);
 
         internal static RuntimeType GetModuleType(RuntimeModule module)
diff --git a/src/mscorlib/src/System/SByte.cs b/src/mscorlib/src/System/SByte.cs
index da6ac5c88f..e738dfc546 100644
--- a/src/mscorlib/src/System/SByte.cs
+++ b/src/mscorlib/src/System/SByte.cs
@@ -19,7 +19,6 @@ namespace System {
     // A place holder class for signed bytes.
 [Serializable]
 [CLSCompliant(false), System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public struct SByte : IComparable, IFormattable, IConvertible
     , IComparable<SByte>, IEquatable<SByte>
     {
diff --git a/src/mscorlib/src/System/Security/AccessControl/Enums.cs b/src/mscorlib/src/System/Security/AccessControl/Enums.cs
deleted file mode 100644
index 20f5c5f91a..0000000000
--- a/src/mscorlib/src/System/Security/AccessControl/Enums.cs
+++ /dev/null
@@ -1,75 +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.
-
-using System.Runtime.InteropServices;
-
-namespace System.Security.AccessControl
-{
-    [Flags]
-    public enum InheritanceFlags
-    {
-        None                     = 0x00,
-        ContainerInherit         = 0x01,
-        ObjectInherit            = 0x02,
-    }
-
-    [Flags]
-    public enum PropagationFlags
-    {
-        None                     = 0x00,
-        NoPropagateInherit       = 0x01,
-        InheritOnly              = 0x02,
-    }
-
-    [Flags]
-    public enum AuditFlags
-    {
-        None                    = 0x00,
-        Success                 = 0x01,
-        Failure                 = 0x02,
-    }
-
-    [Flags]
-    public enum SecurityInfos
-    {
-        Owner                  = 0x00000001,
-        Group                  = 0x00000002,
-        DiscretionaryAcl       = 0x00000004,
-        SystemAcl              = 0x00000008,
-
-    }
-
-
-    public enum ResourceType
-    {
-        Unknown                = 0x00,
-        FileObject             = 0x01,
-        Service                = 0x02,
-        Printer                = 0x03,
-        RegistryKey            = 0x04,
-        LMShare                = 0x05,
-        KernelObject           = 0x06,
-        WindowObject           = 0x07,
-        DSObject               = 0x08,
-        DSObjectAll            = 0x09,
-        ProviderDefined        = 0x0A,
-        WmiGuidObject          = 0x0B,
-        RegistryWow6432Key     = 0x0C,
-    }
-
-    [Flags]
-    public enum AccessControlSections {
-        None = 0,
-        Audit = 0x1,
-        Access = 0x2,
-        Owner = 0x4,
-        Group = 0x8,
-        All = 0xF
-    }
-
-    [Flags]
-    public enum AccessControlActions {
-        None = 0
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Attributes.cs b/src/mscorlib/src/System/Security/Attributes.cs
index e4ebc53053..81a1147a4e 100644
--- a/src/mscorlib/src/System/Security/Attributes.cs
+++ b/src/mscorlib/src/System/Security/Attributes.cs
@@ -7,10 +7,13 @@ using  System.Runtime.InteropServices;
 namespace System.Security
 {
     // DynamicSecurityMethodAttribute:
-    //  Indicates that calling the target method requires space for a security
-    //  object to be allocated on the callers stack. This attribute is only ever
-    //  set on certain security methods defined within mscorlib.
-    [AttributeUsage(AttributeTargets.Method, AllowMultiple = true, Inherited = false )] 
+    //  All methods that use StackCrawlMark should be marked with this attribute. This attribute
+    //  disables inlining of the calling method to allow stackwalking to find the exact caller.
+    //
+    //  This attribute used to indicate that the target method requires space for a security object 
+    //  to be allocated on the callers stack. It is not used for this purpose anymore because of security 
+    //  stackwalks are not ever done in CoreCLR.
+    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor, AllowMultiple = true, Inherited = false )] 
     sealed internal class DynamicSecurityMethodAttribute : System.Attribute
     {
     }
@@ -19,7 +22,6 @@ namespace System.Security
     //  Indicates that the target P/Invoke method(s) should skip the per-call
     //  security checked for unmanaged code permission.
     [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = true, Inherited = false )] 
-    [System.Runtime.InteropServices.ComVisible(true)]
     sealed public class SuppressUnmanagedCodeSecurityAttribute : System.Attribute
     {
     }
@@ -27,7 +29,6 @@ namespace System.Security
     // UnverifiableCodeAttribute:
     //  Indicates that the target module contains unverifiable code.
     [AttributeUsage(AttributeTargets.Module, AllowMultiple = true, Inherited = false )] 
-[System.Runtime.InteropServices.ComVisible(true)]
     sealed public class UnverifiableCodeAttribute : System.Attribute
     {
     }
@@ -38,7 +39,6 @@ namespace System.Security
     //  For v.1, this is valid only on Assemblies, but could be expanded to 
     //  include Module, Method, class
     [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = false, Inherited = false )] 
-    [System.Runtime.InteropServices.ComVisible(true)]
     sealed public class AllowPartiallyTrustedCallersAttribute : System.Attribute
     {
         private PartialTrustVisibilityLevel _visibilityLevel;
diff --git a/src/mscorlib/src/System/Security/BuiltInPermissionSets.cs b/src/mscorlib/src/System/Security/BuiltInPermissionSets.cs
deleted file mode 100644
index 48539574af..0000000000
--- a/src/mscorlib/src/System/Security/BuiltInPermissionSets.cs
+++ /dev/null
@@ -1,255 +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.
-
-//
-// 
-
-using System;
-using System.Diagnostics;
-using System.Diagnostics.Contracts;
-using System.Security.Permissions;
-using Microsoft.Win32;
-
-namespace System.Security
-{
-    internal static class BuiltInPermissionSets
-    {
-        //
-        // Raw PermissionSet XML - the built in permission sets are expressed in XML form since they contain
-        // permissions from assemblies other than mscorlib.
-        //
-
-        private static readonly string s_everythingXml =
-            @"<PermissionSet class = ""System.Security.NamedPermissionSet""
-                             version = ""1""
-                             Name = ""Everything""
-                             Description = """ + Environment.GetResourceString("Policy_PS_Everything") + @"""
-                  <IPermission class = ""System.Data.OleDb.OleDbPermission, " + AssemblyRef.SystemData + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" />
-                  <IPermission class = ""System.Data.SqlClient.SqlClientPermission, " + AssemblyRef.SystemData + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" />
-                  <IPermission class = ""System.Diagnostics.PerformanceCounterPermission, " + AssemblyRef.System + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" />
-                  <IPermission class = ""System.Net.DnsPermission, " + AssemblyRef.System + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" />
-                  <IPermission class = ""System.Net.SocketPermission, " + AssemblyRef.System + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" />
-                  <IPermission class = ""System.Net.WebPermission, " + AssemblyRef.System + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" />
-                  <IPermission class = ""System.Security.Permissions.DataProtectionPermission, " + AssemblyRef.SystemSecurity + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" />
-                  <IPermission class = ""System.Security.Permissions.EnvironmentPermission, " + AssemblyRef.Mscorlib + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" />
-                  <IPermission class = ""System.Diagnostics.EventLogPermission, " + AssemblyRef.System + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" />
-                  <IPermission class = ""System.Security.Permissions.FileDialogPermission, " + AssemblyRef.Mscorlib + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" />
-                  <IPermission class = ""System.Security.Permissions.FileIOPermission, " + AssemblyRef.Mscorlib + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" /> 
-                  <IPermission class = ""System.Security.Permissions.IsolatedStorageFilePermission, " + AssemblyRef.Mscorlib + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" />
-                  <IPermission class = ""System.Security.Permissions.KeyContainerPermission, " + AssemblyRef.Mscorlib + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" />
-                  <IPermission class = ""System.Drawing.Printing.PrintingPermission, " + AssemblyRef.SystemDrawing + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" />
-                  <IPermission class = ""System.Security.Permissions.ReflectionPermission, " + AssemblyRef.Mscorlib + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" />
-                  <IPermission class = ""System.Security.Permissions.RegistryPermission, " + AssemblyRef.Mscorlib + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" />
-                  <IPermission class = ""System.Security.Permissions.SecurityPermission, " + AssemblyRef.Mscorlib + @"""
-                               version = ""1""
-                               Flags = ""Assertion, UnmanagedCode, Execution, ControlThread, ControlEvidence, ControlPolicy, ControlAppDomain, SerializationFormatter, ControlDomainPolicy, ControlPrincipal, RemotingConfiguration, Infrastructure, BindingRedirects"" />
-                  <IPermission class = ""System.Security.Permissions.UIPermission, " + AssemblyRef.Mscorlib + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" />
-                  <IPermission class = ""System.Security.Permissions.StorePermission, " + AssemblyRef.System + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" />
-                  <IPermission class = ""System.Security.Permissions.TypeDescriptorPermission, " + AssemblyRef.System + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" />
-               </PermissionSet>";
-
-        private static readonly string s_executionXml =
-            @"<PermissionSet class = ""System.Security.NamedPermissionSet""
-                             version = ""1""
-                             Name = ""Execution""
-                             Description = """ + Environment.GetResourceString("Policy_PS_Execution") + @""">
-                  <IPermission class = ""System.Security.Permissions.SecurityPermission, " + AssemblyRef.Mscorlib + @"""
-                               version = ""1""
-                               Flags = ""Execution"" />
-               </PermissionSet>";
-
-        private static readonly string s_fullTrustXml =
-            @"<PermissionSet class = ""System.Security.NamedPermissionSet"" 
-                             version = ""1"" 
-                             Unrestricted = ""true"" 
-                             Name = ""FullTrust"" 
-                             Description = """ + Environment.GetResourceString("Policy_PS_FullTrust") + @""" />";
-
-        private static readonly string s_internetXml =
-            @"<PermissionSet class = ""System.Security.NamedPermissionSet""
-                             version = ""1""
-                             Name = ""Internet""
-                             Description = """ + Environment.GetResourceString("Policy_PS_Internet") + @""">
-                  <IPermission class = ""System.Drawing.Printing.PrintingPermission, " + AssemblyRef.SystemDrawing + @"""
-                               version = ""1""
-                               Level = ""SafePrinting"" />
-                  <IPermission class = ""System.Security.Permissions.FileDialogPermission, " + AssemblyRef.Mscorlib + @"""
-                               version = ""1""
-                               Access = ""Open"" />
-                  <IPermission class = ""System.Security.Permissions.IsolatedStorageFilePermission, " + AssemblyRef.Mscorlib + @"""
-                               version = ""1""
-                               UserQuota = ""1024000""
-                               Allowed = ""ApplicationIsolationByUser"" />
-                  <IPermission class = ""System.Security.Permissions.SecurityPermission, " + AssemblyRef.Mscorlib + @"""
-                               version = ""1""
-                               Flags = ""Execution"" />
-                  <IPermission class = ""System.Security.Permissions.UIPermission, " + AssemblyRef.Mscorlib + @"""
-                               version = ""1""
-                               Window = ""SafeTopLevelWindows""
-                               Clipboard = ""OwnClipboard"" />
-               </PermissionSet>";
-
-        private static readonly string s_localIntranetXml =
-            @"<PermissionSet class = ""System.Security.NamedPermissionSet""
-                             version = ""1""
-                             Name = ""LocalIntranet""
-                             Description = """ + Environment.GetResourceString("Policy_PS_LocalIntranet") + @""" >
-                  <IPermission class = ""System.Drawing.Printing.PrintingPermission, " + AssemblyRef.SystemDrawing + @"""
-                              version = ""1""
-                              Level = ""DefaultPrinting"" />
-                  <IPermission class = ""System.Net.DnsPermission, " + AssemblyRef.System + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" />
-                  <IPermission class = ""System.Security.Permissions.EnvironmentPermission, " + AssemblyRef.Mscorlib + @"""
-                               version = ""1""
-                               Read = ""USERNAME"" />
-                  <IPermission class = ""System.Security.Permissions.FileDialogPermission, " + AssemblyRef.Mscorlib + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" />
-                  <IPermission class = ""System.Security.Permissions.IsolatedStorageFilePermission, " + AssemblyRef.Mscorlib + @"""
-                               version = ""1""
-                               Allowed = ""AssemblyIsolationByUser""
-                               UserQuota = ""9223372036854775807""
-                               Expiry = ""9223372036854775807""
-                               Permanent = ""true"" />
-                  <IPermission class = ""System.Security.Permissions.ReflectionPermission, " + AssemblyRef.Mscorlib + @"""
-                               version = ""1""
-                               Flags = ""ReflectionEmit, RestrictedMemberAccess"" />
-                  <IPermission class = ""System.Security.Permissions.SecurityPermission, " + AssemblyRef.Mscorlib + @"""
-                               version = ""1""
-                               Flags = ""Execution, Assertion, BindingRedirects "" />
-                  <IPermission class = ""System.Security.Permissions.TypeDescriptorPermission, " + AssemblyRef.System + @"""
-                               version = ""1""
-                               Flags = ""RestrictedRegistrationAccess"" />
-                  <IPermission class = ""System.Security.Permissions.UIPermission, " + AssemblyRef.Mscorlib + @"""
-                               version = ""1""
-                               Unrestricted = ""true"" />
-               </PermissionSet>";
-
-        private static readonly string s_nothingXml =
-            @"<PermissionSet class = ""System.Security.NamedPermissionSet""
-                             version = ""1""
-                             Name = ""Nothing""
-                             Description = """ + Environment.GetResourceString("Policy_PS_Nothing") + @""" />";
-
-        private static readonly string s_skipVerificationXml =
-            @"<PermissionSet class = ""System.Security.NamedPermissionSet""
-                             version = ""1""
-                             Name = ""SkipVerification""
-                             Description = """ + Environment.GetResourceString("Policy_PS_SkipVerification") + @""">
-                  <IPermission class = ""System.Security.Permissions.SecurityPermission, " + AssemblyRef.Mscorlib + @"""
-                               version = ""1""
-                               Flags = ""SkipVerification"" />
-               </PermissionSet>";
-
-        //
-        // Built in permission set objects
-        // 
-
-        private static NamedPermissionSet s_everything;
-        private static NamedPermissionSet s_execution;
-        private static NamedPermissionSet s_fullTrust;
-        private static NamedPermissionSet s_internet;
-        private static NamedPermissionSet s_localIntranet;
-        private static NamedPermissionSet s_nothing;
-        private static NamedPermissionSet s_skipVerification;
-
-        //
-        // Standard permission sets
-        //
-
-        internal static NamedPermissionSet Everything
-        {
-            get { return GetOrDeserializeExtendablePermissionSet(ref s_everything, s_everythingXml); }
-        }
-
-        internal static NamedPermissionSet Execution
-        {
-            get { return GetOrDeserializePermissionSet(ref s_execution, s_executionXml); }
-        }
-
-        internal static NamedPermissionSet FullTrust
-        {
-            get { return GetOrDeserializePermissionSet(ref s_fullTrust, s_fullTrustXml); }
-        }
-
-        internal static NamedPermissionSet Internet
-        {
-            get { return GetOrDeserializeExtendablePermissionSet(ref s_internet, s_internetXml); }
-        }
-
-        internal static NamedPermissionSet LocalIntranet
-        {
-            get { return GetOrDeserializeExtendablePermissionSet(ref s_localIntranet, s_localIntranetXml); }
-        }
-
-        internal static NamedPermissionSet Nothing
-        {
-            get { return GetOrDeserializePermissionSet(ref s_nothing, s_nothingXml); }
-        }
-
-        internal static NamedPermissionSet SkipVerification
-        {
-            get { return GetOrDeserializePermissionSet(ref s_skipVerification, s_skipVerificationXml); }
-        }
-
-        //
-        // Utility methods to construct the permission set objects from the well known XML and any permission
-        // set extensions if necessary
-        //
-
-        private static NamedPermissionSet GetOrDeserializeExtendablePermissionSet(
-            ref NamedPermissionSet permissionSet,
-            string permissionSetXml)
-        {
-            Contract.Requires(!String.IsNullOrEmpty(permissionSetXml));
-            return permissionSet.Copy() as NamedPermissionSet;
-        }
-
-        private static NamedPermissionSet GetOrDeserializePermissionSet(ref NamedPermissionSet permissionSet,
-                                                                        string permissionSetXml)
-        {
-            Debug.Assert(!String.IsNullOrEmpty(permissionSetXml));
-            return permissionSet.Copy() as NamedPermissionSet;
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/CodeAccessPermission.cs b/src/mscorlib/src/System/Security/CodeAccessPermission.cs
deleted file mode 100644
index 70504d902e..0000000000
--- a/src/mscorlib/src/System/Security/CodeAccessPermission.cs
+++ /dev/null
@@ -1,229 +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.
-
-namespace System.Security
-{
-    using System.IO;
-    using System.Threading;
-    using System.Security;
-    using System.Security.Util;
-    using System.Security.Permissions;
-    using System.Runtime.CompilerServices;
-    using System.Collections;
-    using System.Text;
-    using System;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-    using IUnrestrictedPermission = System.Security.Permissions.IUnrestrictedPermission;
-
-    [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    abstract public class CodeAccessPermission
-        : IPermission, ISecurityEncodable, IStackWalk
-    {
-        // Static methods for manipulation of stack
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        public static void RevertAssert()
-        {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            SecurityRuntime.RevertAssert(ref stackMark);
-        }
-
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        [Obsolete("Deny is obsolete and will be removed in a future release of the .NET Framework. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
-        public static void RevertDeny()
-        {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            SecurityRuntime.RevertDeny(ref stackMark);
-        }
-
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        public static void RevertPermitOnly()
-        {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            SecurityRuntime.RevertPermitOnly(ref stackMark);
-        }
-
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        public static void RevertAll()
-        {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            SecurityRuntime.RevertAll(ref stackMark);
-        }
-
-        //
-        // Standard implementation of IPermission methods for
-        // code-access permissions.
-        //
-
-        // Mark this method as requiring a security object on the caller's frame
-        // so the caller won't be inlined (which would mess up stack crawling).
-        [DynamicSecurityMethodAttribute()]
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        public void Demand()
-        {
-            if (!this.CheckDemand( null ))
-            {
-                StackCrawlMark stackMark = StackCrawlMark.LookForMyCallersCaller;
-                CodeAccessSecurityEngine.Check(this, ref stackMark);
-            }
-        }
-
-        [DynamicSecurityMethodAttribute()]
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        internal static void Demand(PermissionType permissionType)
-        {
-            //    The intent of the method is to be an internal mscorlib helper that Demands a specific permissiontype
-            //    without having to create objects.
-            //    The security annotation fxcop rule that flags all methods with a Demand() has logic
-            //    which checks for methods named Demand in types that implement IPermission or IStackWalk. 
-            Debug.Assert(new StackFrame().GetMethod().Name.Equals("Demand"), "This method needs to be named Demand");
-            
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCallersCaller;
-            CodeAccessSecurityEngine.SpecialDemand(permissionType, ref stackMark);
-        }
-
-        // Metadata for this method should be flaged with REQ_SQ so that
-        // EE can allocate space on the stack frame for FrameSecurityDescriptor
-
-        [DynamicSecurityMethodAttribute()]
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        public void Assert()
-        {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            CodeAccessSecurityEngine.Assert(this, ref stackMark);
-        }
-
-
-        [DynamicSecurityMethodAttribute()]
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable    
-        static internal void Assert(bool allPossible)
-        {
-            //    The intent of the method is to be an internal mscorlib helper that easily asserts for all possible permissions
-            //    without having to new a PermissionSet.
-            //    The security annotation fxcop rule that flags all methods with an Assert() has logic
-            //    which checks for methods named Assert in types that implement IPermission or IStackWalk. 
-            Debug.Assert(new StackFrame().GetMethod().Name.Equals("Assert"), "This method needs to be named Assert");
-            
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            SecurityRuntime.AssertAllPossible(ref stackMark);
-        }
-    
-        // Metadata for this method should be flaged with REQ_SQ so that
-        // EE can allocate space on the stack frame for FrameSecurityDescriptor
-
-        [DynamicSecurityMethodAttribute()]
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        [Obsolete("Deny is obsolete and will be removed in a future release of the .NET Framework. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
-        public void Deny()
-        {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            CodeAccessSecurityEngine.Deny(this, ref stackMark);
-        }
-        
-        // Metadata for this method should be flaged with REQ_SQ so that
-        // EE can allocate space on the stack frame for FrameSecurityDescriptor
-
-        [DynamicSecurityMethodAttribute()]
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        public void PermitOnly()
-        {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            CodeAccessSecurityEngine.PermitOnly(this, ref stackMark);
-        }
-
-        // IPermission interfaces
-
-        // We provide a default implementation of Union here.
-        // Any permission that doesn't provide its own representation 
-        // of Union will get this one and trigger CompoundPermission
-        // We can take care of simple cases here...
-
-        public virtual IPermission Union(IPermission other) {
-            // The other guy could be null
-            if (other == null) return(this.Copy());
-            
-            // otherwise we don't support it.
-            throw new NotSupportedException(Environment.GetResourceString( "NotSupported_SecurityPermissionUnion" ));
-        }
-
-        //
-        // HELPERS FOR IMPLEMENTING ABSTRACT METHODS
-        //
-
-        //
-        // Protected helper
-        //
-
-        internal bool VerifyType(IPermission perm)
-        {
-            // if perm is null, then obviously not of the same type
-            if ((perm == null) || (perm.GetType() != this.GetType())) {
-                return(false);
-            } else {
-                return(true);
-            }
-        }
-
-        // The IPermission Interface
-        public abstract IPermission Copy();
-        public abstract IPermission Intersect(IPermission target);
-        public abstract bool IsSubsetOf(IPermission target);
-
-        [System.Runtime.InteropServices.ComVisible(false)]
-        public override bool Equals(Object obj)
-        {
-            IPermission perm = obj as IPermission;
-            if(obj != null && perm == null)
-                return false;
-            try {
-                if(!this.IsSubsetOf(perm))
-                    return false;
-                if(perm != null && !perm.IsSubsetOf(this))
-                    return false;
-            }
-            catch (ArgumentException)
-            {
-                // Any argument exception implies inequality
-                // Note that we require a try/catch block here because we have to deal with
-                // custom permissions that may throw exceptions indiscriminately.
-                return false;
-            }
-            return true;
-        }
-
-        [System.Runtime.InteropServices.ComVisible(false)]
-        public override int GetHashCode()
-        {
-            // This implementation is only to silence a compiler warning.
-            return base.GetHashCode();
-        }
-
-
-        internal bool CheckDemand(CodeAccessPermission grant)
-        {
-            Debug.Assert( grant == null || grant.GetType().Equals( this.GetType() ), "CheckDemand not defined for permissions of different type" );
-            return IsSubsetOf( grant );
-        }
-
-        internal bool CheckPermitOnly(CodeAccessPermission permitted)
-        {
-            Debug.Assert( permitted == null || permitted.GetType().Equals( this.GetType() ), "CheckPermitOnly not defined for permissions of different type" );
-            return IsSubsetOf( permitted );
-        }
-
-        internal bool CheckDeny(CodeAccessPermission denied)
-        {
-            Debug.Assert( denied == null || denied.GetType().Equals( this.GetType() ), "CheckDeny not defined for permissions of different type" );
-            IPermission intersectPerm = Intersect(denied);
-            return (intersectPerm == null || intersectPerm.IsSubsetOf(null));
-        }
-
-        internal bool CheckAssert(CodeAccessPermission asserted)
-        {
-            Debug.Assert( asserted == null || asserted.GetType().Equals( this.GetType() ), "CheckPermitOnly not defined for permissions of different type" );
-            return IsSubsetOf( asserted );
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/CodeAccessSecurityEngine.cs b/src/mscorlib/src/System/Security/CodeAccessSecurityEngine.cs
deleted file mode 100644
index cd4b5fd184..0000000000
--- a/src/mscorlib/src/System/Security/CodeAccessSecurityEngine.cs
+++ /dev/null
@@ -1,352 +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.
-
-// 
-
-namespace System.Security {
-    using System;
-    using System.Threading;
-    using System.Security.Util;
-    using System.Collections;
-    using System.Runtime.CompilerServices;
-    using System.Security.Permissions;
-    using System.Reflection;
-    using System.Globalization;
-    using System.Security.Policy;
-    using System.Runtime.Versioning;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-
-    // Used in DemandInternal, to remember the result of previous demands
-    // KEEP IN SYNC WITH DEFINITIONS IN SECURITYPOLICY.H
-    [Serializable]
-    internal enum PermissionType
-    {
-        // special flags
-        SecurityUnmngdCodeAccess    = 0,
-        SecuritySkipVerification    = 1,
-        ReflectionTypeInfo          = 2,
-        SecurityAssert              = 3,
-        ReflectionMemberAccess      = 4,
-        SecuritySerialization       = 5,
-        ReflectionRestrictedMemberAccess    = 6,
-        FullTrust                   = 7,
-        SecurityBindingRedirects    = 8,
-
-        // special permissions
-        UIPermission                = 9,
-        EnvironmentPermission       = 10,
-        FileDialogPermission        = 11,
-        FileIOPermission            = 12,
-        ReflectionPermission        = 13,
-        SecurityPermission          = 14,
-
-        // additional special flags
-        SecurityControlEvidence     = 16,
-        SecurityControlPrincipal    = 17
-    }
-
-    internal static class CodeAccessSecurityEngine
-    {
-
-        internal static SecurityPermission AssertPermission; 
-        internal static PermissionToken AssertPermissionToken; 
-
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        internal static extern void SpecialDemand(PermissionType whatPermission, ref StackCrawlMark stackMark);
-
-        [System.Diagnostics.Conditional( "_DEBUG" )]
-        private static void DEBUG_OUT( String str )
-        {
-#if _DEBUG
-            if (debug)
-                Console.WriteLine( str );
-#endif
-        }
-
-#if _DEBUG
-        private static bool debug = false;
-        private const String file = "d:\\foo\\debug.txt";
-#endif
-
-        // static default constructor. This will be called before any of the static members are accessed.
-        static CodeAccessSecurityEngine()
-        {
-#pragma warning disable 618
-            AssertPermission = new SecurityPermission(SecurityPermissionFlag.Assertion);
-#pragma warning restore 618
-            AssertPermissionToken = PermissionToken.GetToken(AssertPermission);
-        }
-
-#pragma warning disable 618
-        private static void ThrowSecurityException(RuntimeAssembly asm, PermissionSet granted, PermissionSet refused, RuntimeMethodHandleInternal rmh, SecurityAction action, Object demand, IPermission permThatFailed)
-#pragma warning restore 618
-        {
-            AssemblyName asmName = null;
-            Evidence asmEvidence = null;
-            if (asm != null)
-            {
-                // Assert here because reflection will check grants and if we fail the check,
-                // there will be an infinite recursion that overflows the stack.
-                PermissionSet.s_fullTrust.Assert();
-                asmName = asm.GetName();
-            }
-            throw SecurityException.MakeSecurityException(asmName, asmEvidence, granted, refused, rmh, action, demand, permThatFailed);
-        }
-
-#pragma warning disable 618
-        private static void ThrowSecurityException(Object assemblyOrString, PermissionSet granted, PermissionSet refused, RuntimeMethodHandleInternal rmh, SecurityAction action, Object demand, IPermission permThatFailed)
-#pragma warning restore 618
-        {
-            Debug.Assert((assemblyOrString == null || assemblyOrString is RuntimeAssembly || assemblyOrString is String), "Must pass in an Assembly object or String object here");
-            
-            if (assemblyOrString == null || assemblyOrString is RuntimeAssembly)
-                ThrowSecurityException((RuntimeAssembly)assemblyOrString, granted, refused, rmh, action, demand, permThatFailed);
-            else
-            {
-                AssemblyName asmName = new AssemblyName((String)assemblyOrString);
-                throw SecurityException.MakeSecurityException(asmName, null, granted, refused, rmh, action, demand, permThatFailed);
-            }
-        }
-
-#pragma warning disable 618
-        internal static void CheckSetHelper(Object notUsed,
-                                           PermissionSet grants,
-                                           PermissionSet refused,
-                                           PermissionSet demands,
-                                           RuntimeMethodHandleInternal rmh,
-                                           RuntimeAssembly asm,
-                                           SecurityAction action)
-#pragma warning restore 618
-        {
-            // To reduce the amount of ifdef-code-churn, a dummy arg is used for the first parameter - instead of a CompressedStack object,
-            // we use a System.Object that should always be null. If we tried to change the signature of the function, there will need to be
-            // corresponding changes in VM (metasig.h, mscorlib.h, securitystackwalk.cpp, number of elements in the arg array, etc.)
-            Debug.Assert(notUsed == null, "Should not reach here with a non-null first arg which is the CompressedStack");
-
-            CheckSetHelper(grants, refused, demands, rmh, (Object)asm, action, true);
-        }
-
-
-#pragma warning disable 618
-        internal static bool CheckSetHelper(PermissionSet grants,
-                                           PermissionSet refused,
-                                           PermissionSet demands,
-                                           RuntimeMethodHandleInternal rmh,
-                                           Object assemblyOrString,
-                                           SecurityAction action,
-                                           bool throwException)
-#pragma warning restore 618
-        {
-            Debug.Assert(demands != null, "Should not reach here with a null demand set");
-
-            IPermission permThatFailed = null;
-            if (grants != null)
-                grants.CheckDecoded(demands);
-            if (refused != null)
-                refused.CheckDecoded(demands);
-
-            bool bThreadSecurity = SecurityManager._SetThreadSecurity(false);
-
-            try
-            {
-
-                // Check grant set
-                if (!demands.CheckDemand(grants, out permThatFailed))
-                {
-                    if (throwException)
-                        ThrowSecurityException(assemblyOrString, grants, refused, rmh, action, demands, permThatFailed);
-                    else
-                        return false;
-                }
-
-                // Check refused set
-                if (!demands.CheckDeny(refused, out permThatFailed))
-                {
-                    if (throwException)
-                        ThrowSecurityException(assemblyOrString, grants, refused, rmh, action, demands, permThatFailed);
-                    else
-                        return false;
-                }
-            }
-            catch (SecurityException)
-            {
-                throw;
-            }
-            catch (Exception)
-            {
-                // Any exception besides a security exception in this code means that
-                // a permission was unable to properly handle what we asked of it.
-                // We will define this to mean that the demand failed.
-                if (throwException)
-                    ThrowSecurityException(assemblyOrString, grants, refused, rmh, action, demands, permThatFailed);
-                else
-                    return false;
-            }
-            finally
-            {
-                if (bThreadSecurity)
-                    SecurityManager._SetThreadSecurity(true);
-            }
-            return true;
-        }
-#pragma warning disable 618
-        internal static void CheckHelper(Object notUsed,
-                                        PermissionSet grantedSet,
-                                        PermissionSet refusedSet,
-                                        CodeAccessPermission demand, 
-                                        PermissionToken permToken,
-                                        RuntimeMethodHandleInternal rmh,
-                                        RuntimeAssembly asm,
-                                        SecurityAction action)
-#pragma warning restore 618
-        {
-            // To reduce the amount of ifdef-code-churn, a dummy arg is used for the first parameter - instead of a CompressedStack object,
-            // we use a System.Object that should always be null. If we tried to change the signature of the function, there will need to be
-            // corresponding changes in VM (metasig.h, mscorlib.h, securitystackwalk.cpp, number of elements in the arg array, etc.)
-            Debug.Assert(notUsed == null, "Should not reach here with a non-null first arg which is the CompressedStack");
-            CheckHelper(grantedSet, refusedSet, demand, permToken, rmh, (Object)asm, action, true);
-        }
-#pragma warning disable 618
-        internal static bool CheckHelper(PermissionSet grantedSet,
-                                        PermissionSet refusedSet,
-                                        CodeAccessPermission demand, 
-                                        PermissionToken permToken,
-                                        RuntimeMethodHandleInternal rmh,
-                                        Object assemblyOrString,
-                                        SecurityAction action,
-                                        bool throwException)
-#pragma warning restore 618
-        {
-            // We should never get here with a null demand
-            Debug.Assert(demand != null, "Should not reach here with a null demand");
-
-            if (permToken == null)
-                permToken = PermissionToken.GetToken(demand);
-
-            if (grantedSet != null)
-                grantedSet.CheckDecoded(permToken.m_index);
-            if (refusedSet != null)
-                refusedSet.CheckDecoded(permToken.m_index);
-
-            // If PermissionSet is null, then module does not have Permissions... Fail check.
-
-            bool bThreadSecurity = SecurityManager._SetThreadSecurity(false);
-
-            try
-            {
-                if (grantedSet == null)
-                {
-                    if (throwException)
-                        ThrowSecurityException(assemblyOrString, grantedSet, refusedSet, rmh, action, demand, demand);
-                    else
-                        return false;
-                }
-                
-                else if (!grantedSet.IsUnrestricted())
-                {
-                    // If we aren't unrestricted, there is a refused set, or our permission is not of the unrestricted
-                    // variety, we need to do the proper callback.
-
-                    Debug.Assert(demand != null,"demand != null");
-
-                    // Find the permission of matching type in the permission set.
-
-                    CodeAccessPermission grantedPerm = 
-                                (CodeAccessPermission)grantedSet.GetPermission(permToken);
-
-                    // Make sure the demand has been granted
-                    if (!demand.CheckDemand( grantedPerm ))
-                    {
-                        if (throwException)
-                            ThrowSecurityException(assemblyOrString, grantedSet, refusedSet, rmh, action, demand, demand);
-                        else
-                            return false;
-                    }
-                }
-
-                // Make the sure the permission is not refused.
-
-                if (refusedSet != null)
-                {
-                    CodeAccessPermission refusedPerm = 
-                        (CodeAccessPermission)refusedSet.GetPermission(permToken);
-                    if (refusedPerm != null)
-                    {
-                        if (!refusedPerm.CheckDeny(demand))
-                        {
-        #if _DEBUG
-                            if (debug)
-                                DEBUG_OUT( "Permission found in refused set" );
-        #endif
-                                if (throwException)
-                                    ThrowSecurityException(assemblyOrString, grantedSet, refusedSet, rmh, action, demand, demand);
-                                else
-                                    return false;
-
-                        }
-                    }
-
-                    if (refusedSet.IsUnrestricted())
-                    {
-                        if (throwException)
-                            ThrowSecurityException(assemblyOrString, grantedSet, refusedSet, rmh, action, demand, demand);
-                        else
-                            return false;
-                    }
-                }
-            }
-            catch (SecurityException)
-            {
-                throw;
-            }
-            catch (Exception)
-            {
-                // Any exception besides a security exception in this code means that
-                // a permission was unable to properly handle what we asked of it.
-                // We will define this to mean that the demand failed.
-                if (throwException)
-                    ThrowSecurityException(assemblyOrString, grantedSet, refusedSet, rmh, action, demand, demand);
-                else
-                    return false;
-            }
-            finally
-            {
-                if (bThreadSecurity)
-                    SecurityManager._SetThreadSecurity(true);
-            }
-
-            DEBUG_OUT( "Check passed" );
-            return true;
-        }
-
-        internal static void Check(CodeAccessPermission cap, ref StackCrawlMark stackMark)
-        {
-        }
-
-
-        internal static void Check(PermissionSet permSet, ref StackCrawlMark stackMark)
-        {
-        }
-
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        internal static extern FrameSecurityDescriptor CheckNReturnSO(PermissionToken permToken, 
-                                                                    CodeAccessPermission demand, 
-                                                                    ref StackCrawlMark stackMark,
-                                                                    int create );
-
-        internal static void Assert(CodeAccessPermission cap, ref StackCrawlMark stackMark)
-        {
-        }
-
-        internal static void Deny(CodeAccessPermission cap, ref StackCrawlMark stackMark)
-        {
-        }
-        
-        internal static void PermitOnly(CodeAccessPermission cap, ref StackCrawlMark stackMark)
-        {
-        }
-
-    }
-}
diff --git a/src/mscorlib/src/System/Security/FrameSecurityDescriptor.cs b/src/mscorlib/src/System/Security/FrameSecurityDescriptor.cs
deleted file mode 100644
index 0b482c8316..0000000000
--- a/src/mscorlib/src/System/Security/FrameSecurityDescriptor.cs
+++ /dev/null
@@ -1,502 +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.
-
-namespace System.Security {
-    using System.Text;
-    using System.Runtime.CompilerServices;
-    using System.Threading;
-    using System;
-    using System.Collections;
-    using System.Security.Permissions;
-    using System.Globalization;
-    using System.Runtime.ConstrainedExecution;
-    using System.Runtime.Versioning;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-#if !FEATURE_PAL
-    using Microsoft.Win32.SafeHandles;
-#endif    
-     //FrameSecurityDescriptor.cs
-    //
-    // Internal use only.
-    // DO NOT DOCUMENT
-    //
-
-    [Serializable]
-    internal class FrameSecurityDescriptor
-    {
-    
-        /*    EE has native FrameSecurityDescriptorObject definition in object.h
-                Make sure to update that structure as well, if you make any changes here.
-        */
-        private PermissionSet       m_assertions;    // imperative asserts
-        private PermissionSet       m_denials;      // imperative denials
-        private PermissionSet       m_restriction;      // imperative permitonlys
-        private PermissionSet       m_DeclarativeAssertions;
-        private PermissionSet       m_DeclarativeDenials;
-        private PermissionSet       m_DeclarativeRestrictions;
-
-        private bool                m_AssertFT;
-        private bool                m_assertAllPossible;
-#pragma warning disable 169 
-        private bool                m_declSecComputed; // set from the VM to indicate that the declarative A/PO/D on this frame has been populated
-#pragma warning restore 169
-
- 
-
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        private static extern void IncrementOverridesCount();
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        private static extern void DecrementOverridesCount();
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        private static extern void IncrementAssertCount();
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        private static extern void DecrementAssertCount();
-
-
-        // Default constructor.
-        internal FrameSecurityDescriptor()
-        {
-            //m_flags = 0;
-        }
-        //-----------------------------------------------------------+
-        // H E L P E R
-        //-----------------------------------------------------------+
-        
-        private PermissionSet CreateSingletonSet(IPermission perm)
-        {
-            PermissionSet permSet = new PermissionSet(false);
-            permSet.AddPermission(perm.Copy());
-            return permSet;
-        }
-    
-        //-----------------------------------------------------------+
-        // A S S E R T
-        //-----------------------------------------------------------+
-
-        internal bool HasImperativeAsserts() 
-        {
-            // we store declarative actions in both fields, so check if they are different
-            return (m_assertions != null);
-        }
-        internal bool HasImperativeDenials() 
-        {
-            // we store declarative actions in both fields, so check if they are different
-            return (m_denials != null);
-        }
-        internal bool HasImperativeRestrictions() 
-        {
-            // we store declarative actions in both fields, so check if they are different
-            return (m_restriction != null);
-        }
-        internal void SetAssert(IPermission perm)
-        {            
-            m_assertions = CreateSingletonSet(perm);
-            IncrementAssertCount();
-        }
-        
-        internal void SetAssert(PermissionSet permSet)
-        {            
-            m_assertions = permSet.Copy();
-            m_AssertFT = m_AssertFT || m_assertions.IsUnrestricted();
-            IncrementAssertCount();
-        }
-        
-        internal PermissionSet GetAssertions(bool fDeclarative)
-        {
-            return (fDeclarative) ? m_DeclarativeAssertions : m_assertions;
-        }
-
-        internal void SetAssertAllPossible()
-        {
-            m_assertAllPossible = true;
-            IncrementAssertCount();
-        }
-
-        internal bool GetAssertAllPossible()
-        {
-            return m_assertAllPossible;
-        }
-        
-        //-----------------------------------------------------------+
-        // D E N Y
-        //-----------------------------------------------------------+
-    
-        internal void SetDeny(IPermission perm)
-        {
-            m_denials = CreateSingletonSet(perm);
-            IncrementOverridesCount();
-        }
-        
-        internal void SetDeny(PermissionSet permSet)
-        {
-            m_denials = permSet.Copy();
-            IncrementOverridesCount();
-        }
-    
-        internal PermissionSet GetDenials(bool fDeclarative)
-        {
-            return (fDeclarative) ? m_DeclarativeDenials: m_denials;
-        }
-
-        //-----------------------------------------------------------+
-        // R E S T R I C T
-        //-----------------------------------------------------------+
-    
-        internal void SetPermitOnly(IPermission perm)
-        {
-            m_restriction  = CreateSingletonSet(perm);
-            IncrementOverridesCount();
-        }
-        
-        internal void SetPermitOnly(PermissionSet permSet)
-        {
-            // permSet must not be null
-            m_restriction  = permSet.Copy();
-            IncrementOverridesCount();
-        }
-        
-        internal PermissionSet GetPermitOnly(bool fDeclarative)
-        {
-            
-            return (fDeclarative) ? m_DeclarativeRestrictions : m_restriction;
-        }
-
-        //-----------------------------------------------------------+
-        // R E V E R T
-        //-----------------------------------------------------------+
-    
-        internal void RevertAssert()
-        {
-            if (m_assertions != null)
-            {
-                m_assertions = null;
-                DecrementAssertCount();
-            }
-
-
-            if (m_DeclarativeAssertions != null)
-            {
-                m_AssertFT = m_DeclarativeAssertions.IsUnrestricted();
-            }
-            else
-            {
-                m_AssertFT = false;
-            }
-        }
-        
-        internal void RevertAssertAllPossible()
-        {
-            if (m_assertAllPossible)
-            {
-            m_assertAllPossible = false;
-                DecrementAssertCount();
-            }
-        }
-
-        internal void RevertDeny()
-        {
-            if (HasImperativeDenials())
-            {
-                DecrementOverridesCount();
-                m_denials = null;
-            }
-        }
-        
-        internal void RevertPermitOnly()
-        {
-            if (HasImperativeRestrictions())
-            {
-                DecrementOverridesCount();
-                m_restriction= null;;
-            }
-        }
-
-        internal void RevertAll()
-        {
-            RevertAssert();
-            RevertAssertAllPossible();
-            RevertDeny();
-            RevertPermitOnly();
-        }
-
-
-        //-----------------------------------------------------------+
-        // Demand Evaluation
-        //-----------------------------------------------------------+
-
- 
-        // This will get called when we hit a FSD while evaluating a demand on the call stack or compressedstack
-        internal bool CheckDemand(CodeAccessPermission demand, PermissionToken permToken, RuntimeMethodHandleInternal rmh)
-        {
-            // imperative security
-            bool fContinue = CheckDemand2(demand, permToken, rmh, false); 
-            if (fContinue == SecurityRuntime.StackContinue)
-            {
-                // declarative security
-                fContinue = CheckDemand2(demand, permToken, rmh, true);
-            }
-            return fContinue;
-        }
-        
-        internal bool CheckDemand2(CodeAccessPermission demand, PermissionToken permToken, RuntimeMethodHandleInternal rmh, bool fDeclarative)
-        {
-            PermissionSet permSet;
-            
-            // If the demand is null, there is no need to continue
-            Debug.Assert(demand != null && !demand.CheckDemand(null), "Empty demands should have been filtered out by this point");
-
-            // decode imperative
-            if (GetPermitOnly(fDeclarative) != null)
-                GetPermitOnly(fDeclarative).CheckDecoded(demand, permToken);
-    
-            if (GetDenials(fDeclarative) != null)
-                GetDenials(fDeclarative).CheckDecoded(demand, permToken);
-    
-            if (GetAssertions(fDeclarative) != null)
-                GetAssertions(fDeclarative).CheckDecoded(demand, permToken);
-            
-            // NOTE: See notes about exceptions and exception handling in FrameDescSetHelper 
-    
-            bool bThreadSecurity = SecurityManager._SetThreadSecurity(false);
-    
-            // Check Reduction
-            
-            try
-            {
-                permSet = GetPermitOnly(fDeclarative);
-                if (permSet != null)
-                {
-                    CodeAccessPermission perm = (CodeAccessPermission)permSet.GetPermission(demand);
-            
-                    // If the permit only set does not contain the demanded permission, throw a security exception
-                    if (perm == null)
-                    {
-                        if (!permSet.IsUnrestricted())
-                            throw new SecurityException(String.Format(CultureInfo.InvariantCulture, Environment.GetResourceString("Security_Generic"), demand.GetType().AssemblyQualifiedName), null, permSet, SecurityRuntime.GetMethodInfo(rmh), demand, demand);
-                    }
-                    else
-                    {
-                        bool bNeedToThrow = true;
-    
-                        try
-                        {
-                            bNeedToThrow = !demand.CheckPermitOnly(perm);
-                        }
-                        catch (ArgumentException)
-                        {
-                        }
-    
-                        if (bNeedToThrow)
-                            throw new SecurityException(String.Format(CultureInfo.InvariantCulture, Environment.GetResourceString("Security_Generic"), demand.GetType().AssemblyQualifiedName), null, permSet, SecurityRuntime.GetMethodInfo(rmh), demand, demand);
-                    }
-                }
-            
-                // Check Denials
-            
-                permSet = GetDenials(fDeclarative);
-                if (permSet != null)
-                {
-                    CodeAccessPermission perm = (CodeAccessPermission)permSet.GetPermission(demand);
-                    
-                    // If an unrestricted set was denied and the demand implements IUnrestricted
-                    if (permSet.IsUnrestricted())
-                        throw new SecurityException(String.Format(CultureInfo.InvariantCulture, Environment.GetResourceString("Security_Generic"), demand.GetType().AssemblyQualifiedName), permSet, null, SecurityRuntime.GetMethodInfo(rmh), demand, demand);
-    
-                    // If the deny set does contain the demanded permission, throw a security exception
-                    bool bNeedToThrow = true;
-                    try
-                    {
-                        bNeedToThrow = !demand.CheckDeny(perm);
-                    }
-                    catch (ArgumentException)
-                    {
-                    }
-                    if (bNeedToThrow)
-                        throw new SecurityException(String.Format(CultureInfo.InvariantCulture, Environment.GetResourceString("Security_Generic"), demand.GetType().AssemblyQualifiedName), permSet, null, SecurityRuntime.GetMethodInfo(rmh), demand, demand);
-                }
-    
-                if (GetAssertAllPossible())
-                {
-                    return SecurityRuntime.StackHalt;
-                }        
-    
-                permSet = GetAssertions(fDeclarative);
-                // Check Assertions
-                if (permSet != null)
-                {
-            
-                    CodeAccessPermission perm = (CodeAccessPermission)permSet.GetPermission(demand);
-                
-                    // If the assert set does contain the demanded permission, halt the stackwalk
-            
-                    try
-                    {
-                        if (permSet.IsUnrestricted() || demand.CheckAssert(perm))
-                        {
-                            return SecurityRuntime.StackHalt;
-                        }
-                    }
-                    catch (ArgumentException)
-                    {
-                    }
-                }
-                
-            }
-            finally
-            {
-                if (bThreadSecurity)
-                    SecurityManager._SetThreadSecurity(true);
-            }
-            
-            return SecurityRuntime.StackContinue;
-        }
-
-        internal bool CheckSetDemand(PermissionSet demandSet,
-                                                                   out PermissionSet alteredDemandSet,
-                                                                   RuntimeMethodHandleInternal rmh)
-        {
-            // imperative security
-            PermissionSet altPset1 = null, altPset2 = null;
-            bool fContinue = CheckSetDemand2(demandSet, out altPset1, rmh, false); 
-            if (altPset1 != null)
-            {
-                demandSet = altPset1;
-            }
-                
-            if (fContinue == SecurityRuntime.StackContinue)
-            {
-                // declarative security
-                fContinue = CheckSetDemand2(demandSet, out altPset2, rmh, true);
-            }
-            // Return the most recent altered set
-            // If both declarative and imperative asserts modified the demand set: return altPset2
-            // Else if imperative asserts modified the demand set: return altPset1
-            // else no alteration: return null
-            if (altPset2 != null)
-                alteredDemandSet = altPset2;
-            else if (altPset1 != null)
-                alteredDemandSet = altPset1;
-            else
-                alteredDemandSet = null;                
-            
-            return fContinue;
-        }
-        
-        internal bool CheckSetDemand2(PermissionSet demandSet,
-                                                                   out PermissionSet alteredDemandSet,
-                                                                   RuntimeMethodHandleInternal rmh, bool fDeclarative)
-        {
-            PermissionSet permSet;
-    
-            // In the common case we are not going to alter the demand set, so just to
-            // be safe we'll set it to null up front.
-            alteredDemandSet = null;
-    
-            // There's some oddness in here to deal with exceptions.  The general idea behind
-            // this is that we need some way of dealing with custom permissions that may not
-            // handle all possible scenarios of Union(), Intersect(), and IsSubsetOf() properly
-            // (they don't support it, throw null reference exceptions, etc.).
-            
-            // An empty demand always succeeds.
-            if (demandSet == null || demandSet.IsEmpty())
-                return SecurityRuntime.StackHalt;
-
-            if (GetPermitOnly(fDeclarative) != null)
-                GetPermitOnly(fDeclarative).CheckDecoded( demandSet );
-            if (GetDenials(fDeclarative) != null)
-                GetDenials(fDeclarative).CheckDecoded( demandSet );
-            if (GetAssertions(fDeclarative) != null)
-                GetAssertions(fDeclarative).CheckDecoded( demandSet );
-            
-         
-            bool bThreadSecurity = SecurityManager._SetThreadSecurity(false);
-    
-            try
-            {
-                // In the case of permit only, we define an exception to be failure of the check
-                // and therefore we throw a security exception.
-                
-                permSet = GetPermitOnly(fDeclarative);
-                if (permSet != null)
-                {
-                    IPermission permFailed = null;
-                    bool bNeedToThrow = true;
-    
-                    try
-                    {
-                        bNeedToThrow = !demandSet.CheckPermitOnly(permSet, out permFailed);
-                    }
-                    catch (ArgumentException)
-                    {
-                    }
-                    if (bNeedToThrow)
-                        throw new SecurityException(Environment.GetResourceString("Security_GenericNoType"), null, permSet, SecurityRuntime.GetMethodInfo(rmh), demandSet, permFailed);
-                }
-                
-                // In the case of denial, we define an exception to be failure of the check
-                // and therefore we throw a security exception.
-                
-                permSet = GetDenials(fDeclarative);
-    
-    
-                if (permSet != null)
-                {
-                    IPermission permFailed = null;
-    
-                    bool bNeedToThrow = true;
-    
-                    try
-                    {
-                        bNeedToThrow = !demandSet.CheckDeny(permSet, out permFailed);
-                    }
-                    catch (ArgumentException)
-                    {
-                    }
-    
-                    if (bNeedToThrow)
-                        throw new SecurityException(Environment.GetResourceString("Security_GenericNoType"), permSet, null, SecurityRuntime.GetMethodInfo(rmh), demandSet, permFailed);
-                }
-            
-                // The assert case is more complex.  Since asserts have the ability to "bleed through"
-                // (where part of a demand is handled by an assertion, but the rest is passed on to
-                // continue the stackwalk), we need to be more careful in handling the "failure" case.
-                // Therefore, if an exception is thrown in performing any operation, we make sure to keep
-                // that permission in the demand set thereby continuing the demand for that permission
-                // walking down the stack.
-                
-                if (GetAssertAllPossible())
-                {
-                    return SecurityRuntime.StackHalt;
-                }        
-            
-                permSet = GetAssertions(fDeclarative);
-                if (permSet != null)
-                {
-                    // If this frame asserts a superset of the demand set we're done
-                    
-                    if (demandSet.CheckAssertion( permSet ))
-                        return SecurityRuntime.StackHalt;
-                
-                    // Determine whether any of the demand set asserted.  We do this by
-                    // copying the demand set and removing anything in it that is asserted.
-                        
-                    if (!permSet.IsUnrestricted())
-                    {
-                        PermissionSet.RemoveAssertedPermissionSet(demandSet, permSet, out alteredDemandSet);
-                    }
-                }
-    
-                        }
-            finally
-            {
-                if (bThreadSecurity)
-                    SecurityManager._SetThreadSecurity(true);
-            }
-
-            return SecurityRuntime.StackContinue;
-        }
-    }
-
-}
diff --git a/src/mscorlib/src/System/Security/HostProtectionException.cs b/src/mscorlib/src/System/Security/HostProtectionException.cs
deleted file mode 100644
index b08fccd1b3..0000000000
--- a/src/mscorlib/src/System/Security/HostProtectionException.cs
+++ /dev/null
@@ -1,135 +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: Exception class for HostProtection
-**
-**
-=============================================================================*/
-
-namespace System.Security
-{
-    using System.Security;
-    using System;
-    using System.Runtime.Serialization;
-    using System.Security.Permissions;
-    using System.Reflection;
-    using System.Text;
-    using System.Diagnostics.Contracts;
-
-    [System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-    public class HostProtectionException : SystemException
-    {
-        private HostProtectionResource m_protected;
-        private HostProtectionResource m_demanded;
-
-        private const String ProtectedResourcesName = "ProtectedResources";
-        private const String DemandedResourcesName = "DemandedResources";
-
-        public HostProtectionException() : base()
-        {
-            m_protected = HostProtectionResource.None;
-            m_demanded = HostProtectionResource.None;
-        }
-
-        public HostProtectionException(string message) : base(message)
-        {
-            m_protected = HostProtectionResource.None;
-            m_demanded = HostProtectionResource.None;
-        }
-
-        public HostProtectionException(string message, Exception e) : base(message, e)
-        {
-            m_protected = HostProtectionResource.None;
-            m_demanded = HostProtectionResource.None;
-        }
-
-        protected HostProtectionException(SerializationInfo info, StreamingContext context) : base(info, context)
-        {
-            if (info==null)
-                throw new ArgumentNullException(nameof(info));
-            Contract.EndContractBlock();
-
-            m_protected = (HostProtectionResource)info.GetValue(ProtectedResourcesName, typeof(HostProtectionResource));
-            m_demanded = (HostProtectionResource)info.GetValue(DemandedResourcesName, typeof(HostProtectionResource));
-        }
-
-        public HostProtectionException(string message, HostProtectionResource protectedResources, HostProtectionResource demandedResources)
-            : base(message)
-        {
-            SetErrorCode(__HResults.COR_E_HOSTPROTECTION);
-            m_protected = protectedResources;
-            m_demanded = demandedResources;
-        }
-
-        // Called from the VM to create a HP Exception
-        private HostProtectionException(HostProtectionResource protectedResources, HostProtectionResource demandedResources)
-            : base(SecurityException.GetResString("HostProtection_HostProtection"))
-        {
-            SetErrorCode(__HResults.COR_E_HOSTPROTECTION);
-            m_protected = protectedResources;
-            m_demanded = demandedResources;
-        }
-
-
-        public HostProtectionResource ProtectedResources
-        {
-            get
-            {
-                return m_protected;
-            }
-        }
-
-        public HostProtectionResource DemandedResources
-        {
-            get
-            {
-                return m_demanded;
-            }
-        }
-
-        private String ToStringHelper(String resourceString, Object attr)
-        {
-            if (attr == null)
-                return String.Empty;
-            StringBuilder sb = new StringBuilder();
-            sb.Append(Environment.NewLine);
-            sb.Append(Environment.NewLine);
-            sb.Append(Environment.GetResourceString( resourceString ));
-            sb.Append(Environment.NewLine);
-            sb.Append(attr);
-            return sb.ToString();
-        }
-
-        public override String ToString() 
-        {
-            String protectedResStrValue = ToStringHelper("HostProtection_ProtectedResources", ProtectedResources);
-            StringBuilder sb = new StringBuilder();
-            sb.Append(base.ToString());
-
-            sb.Append(protectedResStrValue);
-            sb.Append(ToStringHelper("HostProtection_DemandedResources", DemandedResources));
-
-            return sb.ToString();
-
-        }
-
-        public override void GetObjectData(SerializationInfo info, StreamingContext context)
-        {
-            if (info==null)
-                throw new ArgumentNullException(nameof(info));
-            Contract.EndContractBlock();
-
-            base.GetObjectData( info, context );
-
-            info.AddValue(ProtectedResourcesName, ProtectedResources, typeof(HostProtectionResource));
-            info.AddValue(DemandedResourcesName, DemandedResources, typeof(HostProtectionResource));
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/HostSecurityManager.cs b/src/mscorlib/src/System/Security/HostSecurityManager.cs
deleted file mode 100644
index 53137983d3..0000000000
--- a/src/mscorlib/src/System/Security/HostSecurityManager.cs
+++ /dev/null
@@ -1,90 +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.
-
-// 
-
-//
-// A HostSecurityManager gives a hosting application the chance to 
-// participate in the security decisions in the AppDomain.
-//
-
-namespace System.Security
-{
-    using System.Collections;
-    using System.Reflection;
-    using System.Security;
-    using System.Security.Permissions;
-    using System.Security.Policy;
-    using System.Runtime.Versioning;
-    using System.Diagnostics.Contracts;
-
-
-    [Serializable]
-    [Flags]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public enum HostSecurityManagerOptions {
-        None                            = 0x0000,
-        HostAppDomainEvidence           = 0x0001,
-        [Obsolete("AppDomain policy levels are obsolete and will be removed in a future release of the .NET Framework. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
-        HostPolicyLevel                 = 0x0002,
-        HostAssemblyEvidence            = 0x0004,
-        HostDetermineApplicationTrust   = 0x0008,
-        HostResolvePolicy               = 0x0010,
-        AllFlags                        = 0x001F
-    }
-
-    [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public class HostSecurityManager {
-        public HostSecurityManager () {}
-
-        // The host can choose which events he wants to participate in. This property can be set when
-        // the host only cares about a subset of the capabilities exposed through the HostSecurityManager.
-        public virtual HostSecurityManagerOptions Flags {
-            get {
-                // We use AllFlags as the default.
-                return HostSecurityManagerOptions.AllFlags;
-            }
-        }
-
-        public virtual Evidence ProvideAppDomainEvidence (Evidence inputEvidence) {
-            // The default implementation does not modify the input evidence.
-            return inputEvidence;
-        }
-
-        public virtual Evidence ProvideAssemblyEvidence (Assembly loadedAssembly, Evidence inputEvidence) {
-            // The default implementation does not modify the input evidence.
-            return inputEvidence;
-        }
-
-        /// <summary>
-        ///     Determine what types of evidence the host might be able to supply for the AppDomain if requested
-        /// </summary>
-        /// <returns></returns>
-        public virtual Type[] GetHostSuppliedAppDomainEvidenceTypes() {
-            return null;
-        }
-
-        /// <summary>
-        ///     Determine what types of evidence the host might be able to supply for an assembly if requested
-        /// </summary>
-        public virtual Type[] GetHostSuppliedAssemblyEvidenceTypes(Assembly assembly) {
-            return null;
-        }
-
-        /// <summary>
-        ///     Ask the host to supply a specific type of evidence for the AppDomain
-        /// </summary>
-        public virtual EvidenceBase GenerateAppDomainEvidence(Type evidenceType) {
-            return null;
-        }
-
-        /// <summary>
-        ///     Ask the host to supply a specific type of evidence for an assembly
-        /// </summary>
-        public virtual EvidenceBase GenerateAssemblyEvidence(Type evidenceType, Assembly assembly) {
-            return null;
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/IEvidenceFactory.cs b/src/mscorlib/src/System/Security/IEvidenceFactory.cs
deleted file mode 100644
index 592ab533be..0000000000
--- a/src/mscorlib/src/System/Security/IEvidenceFactory.cs
+++ /dev/null
@@ -1,11 +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.
-
-namespace System.Security
-{
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface IEvidenceFactory
-    {
-    }
-}
diff --git a/src/mscorlib/src/System/Security/IPermission.cs b/src/mscorlib/src/System/Security/IPermission.cs
deleted file mode 100644
index 5477261fd7..0000000000
--- a/src/mscorlib/src/System/Security/IPermission.cs
+++ /dev/null
@@ -1,84 +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.
-
-// 
-//
-// Defines the interface that all Permission objects must support.
-// 
-
-namespace System.Security
-{
-
-[System.Runtime.InteropServices.ComVisible(true)]
-    public interface IPermission : ISecurityEncodable
-    {
-        // NOTE: The constants that used to be defined here were moved to 
-        // PermissionsEnum.cs due to CLS restrictions.
-
-        // The integrity of the security system depends on a means to
-        // copy objects so that references to sensitive objects are not
-        // exposed outside of the runtime. Thus, all permissions must
-        // implement Copy.
-        // 
-        // Makes an exact copy of the Permission.
-        IPermission Copy();
-
-        /*
-         * Methods to support the Installation, Registration, others... PolicyEngine
-         */
-    
-        // Policy decisions and runtime mechanisms (for example, Deny)
-        // require a means to retrieve shared state between two
-        // permissions. If there is no shared state between two
-        // instances, then the method should return null.
-        // 
-        // Could think of the method as GetCommonState,
-        // but leave it as Intersect to avoid gratuitous name changes.
-        // 
-        // Returns a new permission with the permission-defined intersection
-        // of the two permissions. The intersection is generally defined as
-        // privilege parameters that are included by both 'this' and 'target'.
-        // Returns null if 'target' is null or is of wrong type.
-        // 
-        IPermission Intersect(IPermission target);
-
-        // The runtime policy manager also requires a means of combining the
-        // state contained within two permissions of the same type in a logical OR
-        // construct.  (The Union of two permission of different type is not defined, 
-        // except when one of the two is a CompoundPermission of internal type equal
-        // to the type of the other permission.)
-        //
-
-        IPermission Union(IPermission target);
-
-        // IsSubsetOf defines a standard mechanism for determining
-        // relative safety between two permission demands of the same type.
-        // If one demand x demands no more than some other demand y, then
-        // x.IsSubsetOf(y) should return true. In this case, if the
-        // demand for y is satisfied, then it is possible to assume that
-        // the demand for x would also be satisfied under the same
-        // circumstances. On the other hand, if x demands something that y
-        // does not, then x.IsSubsetOf(y) should return false; the fact
-        // that x is satisfied by the current security context does not
-        // also imply that the demand for y will also be satisfied.
-        // 
-        // Returns true if 'this' Permission allows no more access than the
-        // argument.
-        // 
-        bool IsSubsetOf(IPermission target);
-
-        // The Demand method is the fundamental part of the IPermission
-        // interface from a component developer's perspective. The
-        // permission represents the demand that the developer wants
-        // satisfied, and Demand is the means to invoke the demand.
-        // For each type of permission, the mechanism to verify the
-        // demand will be different. However, to the developer, all
-        // permissions invoke that mechanism through the Demand interface.
-        // Mark this method as requiring a security object on the caller's frame
-        // so the caller won't be inlined (which would mess up stack crawling).
-        [DynamicSecurityMethodAttribute()]
-        void Demand();
-
-    }
-}
diff --git a/src/mscorlib/src/System/Security/ISecurityEncodable.cs b/src/mscorlib/src/System/Security/ISecurityEncodable.cs
deleted file mode 100644
index 689b3e4b5f..0000000000
--- a/src/mscorlib/src/System/Security/ISecurityEncodable.cs
+++ /dev/null
@@ -1,17 +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.
-
-// 
-//
-// All encodable security classes that support encoding need to
-// implement this interface
-//
-
-namespace System.Security
-{
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface ISecurityEncodable
-    {
-    }
-}
diff --git a/src/mscorlib/src/System/Security/ISecurityPolicyEncodable.cs b/src/mscorlib/src/System/Security/ISecurityPolicyEncodable.cs
deleted file mode 100644
index 567e41e891..0000000000
--- a/src/mscorlib/src/System/Security/ISecurityPolicyEncodable.cs
+++ /dev/null
@@ -1,17 +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.
-
-// 
-//
-// All encodable security classes that support encoding need to
-// implement this interface
-//
-
-namespace System.Security
-{
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface ISecurityPolicyEncodable
-    {
-    }
-}
diff --git a/src/mscorlib/src/System/Security/IStackWalk.cs b/src/mscorlib/src/System/Security/IStackWalk.cs
deleted file mode 100644
index 902fc35b61..0000000000
--- a/src/mscorlib/src/System/Security/IStackWalk.cs
+++ /dev/null
@@ -1,23 +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.
-
-namespace System.Security
-{
-
-[System.Runtime.InteropServices.ComVisible(true)]
-    public interface IStackWalk
-    {
-        [DynamicSecurityMethodAttribute()]
-        void Assert();
-        
-        [DynamicSecurityMethodAttribute()]
-        void Demand();
-        
-        [DynamicSecurityMethodAttribute()]
-        void Deny();
-        
-        [DynamicSecurityMethodAttribute()]
-        void PermitOnly();
-    }
-}
diff --git a/src/mscorlib/src/System/Security/NamedPermissionSet.cs b/src/mscorlib/src/System/Security/NamedPermissionSet.cs
deleted file mode 100644
index 1bc166fde8..0000000000
--- a/src/mscorlib/src/System/Security/NamedPermissionSet.cs
+++ /dev/null
@@ -1,75 +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.
-
-// 
-//
-//  Extends PermissionSet to allow an associated name and description
-//
-
-namespace System.Security
-{
-    using System;
-    using System.Security.Permissions;
-
-    [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class NamedPermissionSet : PermissionSet
-    {
-        internal static PermissionSet GetBuiltInSet(string name)
-        {
-            // Used by PermissionSetAttribute to create one of the built-in,
-            // immutable permission sets.
-            if (name == null)
-                return null;
-            else if (name.Equals("FullTrust"))
-                return CreateFullTrustSet();
-            else if (name.Equals("Nothing"))
-                return CreateNothingSet();
-            else if (name.Equals("Execution"))
-                return CreateExecutionSet();
-            else if (name.Equals("SkipVerification"))
-                return CreateSkipVerificationSet();
-            else if (name.Equals("Internet"))
-                return CreateInternetSet();
-            else
-                return null;
-        }
-
-        private static PermissionSet CreateFullTrustSet() {
-            return new PermissionSet(PermissionState.Unrestricted);
-        }
-
-        private static PermissionSet CreateNothingSet() {
-            return new PermissionSet(PermissionState.None);
-        }
-
-        private static PermissionSet CreateExecutionSet() {
-            PermissionSet permSet = new PermissionSet(PermissionState.None);
-#pragma warning disable 618
-            permSet.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution));
-#pragma warning restore 618
-            return permSet;
-        }
-
-        private static PermissionSet CreateSkipVerificationSet() {
-            PermissionSet permSet = new PermissionSet(PermissionState.None);
-#pragma warning disable 618
-            permSet.AddPermission(new SecurityPermission(SecurityPermissionFlag.SkipVerification));
-#pragma warning restore 618
-            return permSet;
-        }
-
-        private static PermissionSet CreateInternetSet() {
-            PermissionSet permSet = new PermissionSet(PermissionState.None);
-            permSet.AddPermission(new FileDialogPermission(FileDialogPermissionAccess.Open));
-#pragma warning disable 618
-            permSet.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution));
-#pragma warning restore 618
-            permSet.AddPermission(new UIPermission(UIPermissionWindow.SafeTopLevelWindows, UIPermissionClipboard.OwnClipboard));
-            return permSet;
-            
-
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/PermissionListSet.cs b/src/mscorlib/src/System/Security/PermissionListSet.cs
deleted file mode 100644
index 75bb07c039..0000000000
--- a/src/mscorlib/src/System/Security/PermissionListSet.cs
+++ /dev/null
@@ -1,349 +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: Holds state about A/G/R permissionsets in a callstack or appdomain
-**          (Replacement for PermissionListSet)
-**
-=============================================================================*/
-
-namespace System.Security
-{
-    using System.Globalization;
-    using System.Reflection;
-    using System.Runtime.InteropServices;
-    using System.Security;
-    using System.Security.Permissions;
-    using System.Threading;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-
-    [Serializable]
-    sealed internal class PermissionListSet
-    {
-        // Only internal (public) methods are creation methods and demand evaluation methods.
-        // Scroll down to the end to see them.
-        private PermissionSetTriple m_firstPermSetTriple;
-        private ArrayList m_permSetTriples;
-
-        internal PermissionListSet() {}
-
-        private void EnsureTriplesListCreated()
-        {
-            if (m_permSetTriples == null)
-            {
-                m_permSetTriples = new ArrayList();
-                if (m_firstPermSetTriple != null)
-                {
-                    m_permSetTriples.Add(m_firstPermSetTriple);
-                    m_firstPermSetTriple = null;
-                }
-            }
-        }
-
-
-        private void Terminate(PermissionSetTriple currentTriple)
-        {
-            UpdateTripleListAndCreateNewTriple(currentTriple, null);
-        }
-
-        private void Terminate(PermissionSetTriple currentTriple, PermissionListSet pls)
-        {
-            this.UpdatePermissions(currentTriple, pls);
-            this.UpdateTripleListAndCreateNewTriple(currentTriple, null);
-        }
-
-        private bool Update(PermissionSetTriple currentTriple, PermissionListSet pls)
-        {
-            return this.UpdatePermissions(currentTriple, pls);
-        }
-
-        private bool Update(PermissionSetTriple currentTriple, FrameSecurityDescriptor fsd)
-        {
-
-           // check imperative
-           bool fHalt = Update2(currentTriple, fsd, false);
-           if (!fHalt)            
-           {
-                // then declarative
-                fHalt = Update2(currentTriple, fsd, true);
-           }
-           return fHalt;
-        }
-
-
-        private bool Update2(PermissionSetTriple currentTriple, FrameSecurityDescriptor fsd, bool fDeclarative)
-        {
-            // Deny
-            PermissionSet deniedPset = fsd.GetDenials(fDeclarative);
-            if (deniedPset != null)
-            {
-                currentTriple.UpdateRefused(deniedPset);
-            }
-
-            // permit only
-            PermissionSet permitOnlyPset = fsd.GetPermitOnly(fDeclarative);
-            if (permitOnlyPset != null)
-            {
-                currentTriple.UpdateGrant(permitOnlyPset);
-            }
-
-            // Assert all possible
-            if (fsd.GetAssertAllPossible())
-            {
-                // If we have no grant set, it means that the only assembly we've seen on the stack so
-                // far is mscorlib. Since mscorlib will always be fully trusted, the grant set of the
-                // compressed stack is also FullTrust.
-                if (currentTriple.GrantSet == null)
-                    currentTriple.GrantSet = PermissionSet.s_fullTrust;
-
-                UpdateTripleListAndCreateNewTriple(currentTriple, m_permSetTriples);
-                currentTriple.GrantSet = PermissionSet.s_fullTrust;
-                currentTriple.UpdateAssert(fsd.GetAssertions(fDeclarative));
-                return true;
-            }
-                
-            // Assert
-            PermissionSet assertPset = fsd.GetAssertions(fDeclarative);
-            if (assertPset != null)
-            {
-                if (assertPset.IsUnrestricted())
-                {
-                    // If we have no grant set, it means that the only assembly we've seen on the stack so
-                    // far is mscorlib. Since mscorlib will always be fully trusted, the grant set of the
-                    // compressed stack is also FullTrust.
-                    if (currentTriple.GrantSet == null)
-                        currentTriple.GrantSet = PermissionSet.s_fullTrust;
-
-                    UpdateTripleListAndCreateNewTriple(currentTriple, m_permSetTriples);
-                    currentTriple.GrantSet = PermissionSet.s_fullTrust;
-                    currentTriple.UpdateAssert(assertPset);
-                    return true;
-                }
-
-                PermissionSetTriple retTriple = currentTriple.UpdateAssert(assertPset);
-                if (retTriple != null)
-                {
-                    EnsureTriplesListCreated();
-                    m_permSetTriples.Add(retTriple);
-                }
-            }
-
-            return false;
-        }
-        private void Update(PermissionSetTriple currentTriple, PermissionSet in_g, PermissionSet in_r)
-        {
-            currentTriple.UpdateGrant(in_g);
-            currentTriple.UpdateRefused(in_r);
-        }
-
-        // Called from the VM for HG CS construction        
-        private void Update(PermissionSet in_g)
-        {
-            if (m_firstPermSetTriple == null)
-                m_firstPermSetTriple = new PermissionSetTriple();
-            Update(m_firstPermSetTriple, in_g, null);
-        }
-        
-
-        private bool UpdatePermissions(PermissionSetTriple currentTriple, PermissionListSet pls)
-        {
-            if (pls != null)
-            {
-                if (pls.m_permSetTriples != null)
-                {
-                    // DCS has an AGR List. So we need to add the AGR List
-                    UpdateTripleListAndCreateNewTriple(currentTriple,pls.m_permSetTriples);
-                }
-                else
-                {
-                    // Common case: One AGR set
-                    
-                    PermissionSetTriple tmp_psTriple = pls.m_firstPermSetTriple;
-                    PermissionSetTriple retTriple;
-                    // First try and update currentTriple. Return value indicates if we can stop construction
-                    if (currentTriple.Update(tmp_psTriple, out retTriple))
-                        return true;
-                    // If we got a non-null retTriple, what it means is that compression failed,
-                    // and we now have 2 triples to deal with: retTriple and currentTriple.
-                    // retTriple has to be appended first. then currentTriple.
-                    if (retTriple != null)
-                    {
-                        EnsureTriplesListCreated();
-                        // we just created a new triple...add the previous one (returned) to the list
-                        m_permSetTriples.Add(retTriple);
-                    }
-                }
-            }
-            else
-            {
-                // pls can be null only outside the loop in CreateCompressedState
-                UpdateTripleListAndCreateNewTriple(currentTriple, null);
-            }
-            
-
-            return false;
-            
-        }
-
-
-        private void UpdateTripleListAndCreateNewTriple(PermissionSetTriple currentTriple, ArrayList tripleList)
-        {
-            if (!currentTriple.IsEmpty())
-            {
-                if (m_firstPermSetTriple == null && m_permSetTriples == null)
-                {
-                    m_firstPermSetTriple = new PermissionSetTriple(currentTriple);
-                }
-                else
-                {
-                    EnsureTriplesListCreated();
-                    m_permSetTriples.Add(new PermissionSetTriple(currentTriple));
-                }
-                currentTriple.Reset();
-            }
-            if (tripleList != null)
-            {
-                EnsureTriplesListCreated();
-                m_permSetTriples.AddRange(tripleList);
-            }
-        }
-
-        private static void UpdateArrayList(ArrayList current, ArrayList newList)
-        {
-            if (newList == null)
-                return;
-
-            for(int i=0;i < newList.Count; i++)
-            {
-                if (!current.Contains(newList[i]))
-                    current.Add(newList[i]);
-            }
-
-        }
-
-        // Private Demand evaluation functions - only called from the VM
-        internal bool CheckDemandNoThrow(CodeAccessPermission demand)
-        {
-            // AppDomain permissions - no asserts. So there should only be one triple to work with
-            Debug.Assert(m_permSetTriples == null && m_firstPermSetTriple != null, "More than one PermissionSetTriple encountered in AD PermissionListSet");
-            
-
-            
-            PermissionToken permToken = null;
-            if (demand != null)
-                permToken = PermissionToken.GetToken(demand);
-
-            return m_firstPermSetTriple.CheckDemandNoThrow(demand, permToken);
-                
-
-        }
-        internal bool CheckSetDemandNoThrow(PermissionSet pSet)
-        {
-            // AppDomain permissions - no asserts. So there should only be one triple to work with
-            Debug.Assert(m_permSetTriples == null && m_firstPermSetTriple != null, "More than one PermissionSetTriple encountered in AD PermissionListSet");
-
-            
-            return m_firstPermSetTriple.CheckSetDemandNoThrow(pSet);
-        }
-
-        // Demand evauation functions
-        internal bool CheckDemand(CodeAccessPermission demand, PermissionToken permToken, RuntimeMethodHandleInternal rmh)
-        {
-            bool bRet = SecurityRuntime.StackContinue;
-            if (m_permSetTriples != null)
-            {
-                for (int i=0; (i < m_permSetTriples.Count && bRet != SecurityRuntime.StackHalt) ; i++)
-                {
-                    PermissionSetTriple psTriple = (PermissionSetTriple)m_permSetTriples[i];
-                    bRet = psTriple.CheckDemand(demand, permToken, rmh);
-                }
-            }
-            else if (m_firstPermSetTriple != null)
-            {
-                bRet = m_firstPermSetTriple.CheckDemand(demand, permToken, rmh);
-            }
-
-            return bRet;
-        }
-
-        internal bool CheckSetDemand(PermissionSet pset , RuntimeMethodHandleInternal rmh)
-        {
-            PermissionSet unused;
-            CheckSetDemandWithModification(pset, out unused, rmh);
-            return SecurityRuntime.StackHalt; //  CS demand check always terminates the stackwalk    
-        }
-
-        internal bool CheckSetDemandWithModification(PermissionSet pset, out PermissionSet alteredDemandSet, RuntimeMethodHandleInternal rmh)
-        {
-            bool bRet = SecurityRuntime.StackContinue;
-            PermissionSet demandSet = pset;
-            alteredDemandSet = null;
-            if (m_permSetTriples != null)
-            {
-                for (int i=0; (i < m_permSetTriples.Count && bRet != SecurityRuntime.StackHalt) ; i++)
-                {
-                    PermissionSetTriple psTriple = (PermissionSetTriple)m_permSetTriples[i];
-                    bRet = psTriple.CheckSetDemand(demandSet, out alteredDemandSet, rmh);
-                    if (alteredDemandSet != null)
-                        demandSet = alteredDemandSet;
-                }
-            }
-            else if (m_firstPermSetTriple != null)
-            {
-                bRet = m_firstPermSetTriple.CheckSetDemand(demandSet, out alteredDemandSet, rmh);
-            }
-
-            return bRet;
-        }
-
-        /// <summary>
-        ///     Check to see if the PLS satisfies a demand for the special permissions encoded in flags
-        /// </summary>
-        /// <param name="flags">set of flags to check (See PermissionType)</param>
-        private bool CheckFlags(int flags)
-        {
-            Debug.Assert(flags != 0, "Invalid permission flag demand");
-
-            bool check = true;
-
-            if (m_permSetTriples != null)
-            {
-                for (int i = 0; i < m_permSetTriples.Count && check && flags != 0; i++)
-                {
-                    check &= ((PermissionSetTriple)m_permSetTriples[i]).CheckFlags(ref flags);
-                }
-            }
-            else if (m_firstPermSetTriple != null)
-            {
-                check = m_firstPermSetTriple.CheckFlags(ref flags);
-            }
-            
-            return check;
-        }
-
-        /// <summary>
-        ///     Demand which succeeds if either a set of special permissions or a permission set is granted
-        ///     to the call stack
-        /// </summary>
-        /// <param name="flags">set of flags to check (See PermissionType)</param>
-        /// <param name="grantSet">alternate permission set to check</param>
-        internal void DemandFlagsOrGrantSet(int flags, PermissionSet grantSet)
-        {
-            if (CheckFlags(flags))
-                return;
-
-            CheckSetDemand(grantSet, RuntimeMethodHandleInternal.EmptyHandle);
-        }
-
-    }
-
-}
diff --git a/src/mscorlib/src/System/Security/PermissionSet.cs b/src/mscorlib/src/System/Security/PermissionSet.cs
deleted file mode 100644
index 4b05969142..0000000000
--- a/src/mscorlib/src/System/Security/PermissionSet.cs
+++ /dev/null
@@ -1,1588 +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.
-
-// 
-
-namespace System.Security {
-    using System;
-    using System.Threading;
-    using System.Security.Util;
-    using System.Collections;
-    using System.IO;
-    using System.Security.Permissions;
-    using System.Runtime.CompilerServices;
-    using System.Security.Policy;
-    using BindingFlags = System.Reflection.BindingFlags;
-    using System.Runtime.Serialization;
-    using System.Text;
-    using System.Globalization;
-    using System.Runtime.Versioning;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-
-    [Serializable] 
-    internal enum SpecialPermissionSetFlag
-    {
-        // These also appear in clr/src/vm/permset.h
-        Regular = 0,
-        NoSet = 1,
-        EmptySet = 2,
-        SkipVerification = 3
-    }
-
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public class PermissionSet : ISecurityEncodable, ICollection, IStackWalk
-    {
-#if _DEBUG
-        internal static readonly bool debug;
-#endif
-
-        [System.Diagnostics.Conditional( "_DEBUG" )]
-        private static void DEBUG_WRITE(String str) {
-        #if _DEBUG
-            if (debug) Console.WriteLine(str);
-        #endif
-         }
-
-        [System.Diagnostics.Conditional( "_DEBUG" )]
-        private static void DEBUG_COND_WRITE(bool exp, String str)
-        {
-        #if _DEBUG
-            if (debug && (exp)) Console.WriteLine(str);
-        #endif
-        }
-
-        [System.Diagnostics.Conditional( "_DEBUG" )]
-        private static void DEBUG_PRINTSTACK(Exception e)
-        {
-        #if _DEBUG
-            if (debug) Console.WriteLine((e).StackTrace);
-        #endif
-        }
-    
-        // These members are accessed from EE using their hardcoded offset.
-        // Please update the PermissionSetObject in object.h if you make any changes 
-        // to the fields here. !dumpobj will show the field layout
-
-        // First the fields that are serialized x-appdomain (for perf reasons)
-        private bool m_Unrestricted;
-        [OptionalField(VersionAdded = 2)]
-        private bool m_allPermissionsDecoded = false;
-
-        [OptionalField(VersionAdded = 2)]
-        internal TokenBasedSet m_permSet = null;
-
-        // This is a workaround so that SQL can operate under default policy without actually
-        // granting permissions in assemblies that they disallow.
-
-        [OptionalField(VersionAdded = 2)]
-        private bool m_ignoreTypeLoadFailures = false;
-
-        // This field will be populated only for non X-AD scenarios where we create a XML-ised string of the PermissionSet
-        [OptionalField(VersionAdded = 2)]
-        private String m_serializedPermissionSet; 
-
-        [NonSerialized] private bool m_CheckedForNonCas;
-        [NonSerialized] private bool m_ContainsCas;
-        [NonSerialized] private bool m_ContainsNonCas;
-
-        // only used during non X-AD serialization to save the m_permSet value (which we dont want serialized)
-        [NonSerialized] private TokenBasedSet m_permSetSaved;         
-
-        // Following 4 fields are used only for serialization compat purposes: DO NOT USE THESE EVER!
-#pragma warning disable 169
-        private bool readableonly;    
-        private TokenBasedSet m_unrestrictedPermSet;
-        private TokenBasedSet m_normalPermSet;
-
-        [OptionalField(VersionAdded = 2)]
-        private bool m_canUnrestrictedOverride;
-#pragma warning restore 169
-        // END: Serialization-only fields
-
-        internal static readonly PermissionSet s_fullTrust = new PermissionSet( true );
-
-#if _DEBUG
-        [OnSerialized]
-        private void OnSerialized(StreamingContext context)
-        {
-            Debug.Assert(false, "PermissionSet does not support serialization on CoreCLR");
-        }
-#endif // _DEBUG
-
-        internal PermissionSet()
-        {
-            Reset();
-            m_Unrestricted = true;
-        }
-        
-        internal PermissionSet(bool fUnrestricted)
-            : this()
-        {
-            SetUnrestricted(fUnrestricted);
-        }
-        
-        public PermissionSet(PermissionState state)
-            : this()
-        {
-            if (state == PermissionState.Unrestricted)
-            {
-                SetUnrestricted( true );
-            }
-            else if (state == PermissionState.None)
-            {
-                SetUnrestricted( false );
-            }
-            else
-            {
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
-            }
-        }
-    
-        public PermissionSet(PermissionSet permSet)
-            : this()
-        {
-            if (permSet == null)
-            {
-                Reset();
-                return;
-            }
-
-            m_Unrestricted = permSet.m_Unrestricted;
-            m_CheckedForNonCas = permSet.m_CheckedForNonCas;
-            m_ContainsCas = permSet.m_ContainsCas;
-            m_ContainsNonCas = permSet.m_ContainsNonCas;
-            m_ignoreTypeLoadFailures = permSet.m_ignoreTypeLoadFailures;
-
-            if (permSet.m_permSet != null)
-            {
-                m_permSet = new TokenBasedSet(permSet.m_permSet);
-                
-                // now deep copy all permissions in set
-                for (int i = m_permSet.GetStartingIndex(); i <= m_permSet.GetMaxUsedIndex(); i++)
-                {
-                    Object obj = m_permSet.GetItem(i);
-                    IPermission perm = obj as IPermission;
-
-                    if (perm != null)
-                    {
-                        m_permSet.SetItem(i, perm.Copy());
-                    }
-                }
-            }
-        }
-
-        public virtual void CopyTo(Array array, int index)
-        {
-            if (array == null)
-                throw new ArgumentNullException( nameof(array) );
-            Contract.EndContractBlock();
-        
-            PermissionSetEnumeratorInternal enumerator = new PermissionSetEnumeratorInternal(this);
-            
-            while (enumerator.MoveNext())
-            {
-                array.SetValue(enumerator.Current , index++ );
-            }
-        }
-        
-        
-        // private constructor that doesn't create any token based sets
-        private PermissionSet( Object trash, Object junk )
-        {
-            m_Unrestricted = false;
-        }
-           
-        
-        // Returns an object appropriate for synchronizing access to this 
-        // Array.
-        public virtual Object SyncRoot
-        {  get { return this; } }   
-        
-        // Is this Array synchronized (i.e., thread-safe)?  If you want a synchronized
-        // collection, you can use SyncRoot as an object to synchronize your 
-        // collection with.  You could also call GetSynchronized() 
-        // to get a synchronized wrapper around the Array.
-        public virtual bool IsSynchronized
-        {  get { return false; } }  
-            
-        // Is this Collection ReadOnly?
-        public virtual bool IsReadOnly 
-        {  get {return false; } }   
-
-        // Reinitializes all state in PermissionSet - DO NOT null-out m_serializedPermissionSet
-        internal void Reset()
-        {
-            m_Unrestricted = false;
-            m_allPermissionsDecoded = true;
-            m_permSet = null;
-            
-            m_ignoreTypeLoadFailures = false;
-
-            m_CheckedForNonCas = false;
-            m_ContainsCas = false;
-            m_ContainsNonCas = false;
-            m_permSetSaved = null;
-
-
-        }
-
-        internal void CheckSet()
-        {
-            if (this.m_permSet == null)
-                this.m_permSet = new TokenBasedSet();
-        }
-
-        public bool IsEmpty()
-        {
-            if (m_Unrestricted)
-                return false;
-
-            if (m_permSet == null || m_permSet.FastIsEmpty())
-                return true;
-
-            PermissionSetEnumeratorInternal enumerator = new PermissionSetEnumeratorInternal(this);
-
-            while (enumerator.MoveNext())
-            {
-                IPermission perm = (IPermission)enumerator.Current;
-
-                if (!perm.IsSubsetOf( null ))
-                {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        internal bool FastIsEmpty()
-        {
-            if (m_Unrestricted)
-                return false;
-
-            if (m_permSet == null || m_permSet.FastIsEmpty())
-                return true;
-
-            return false;
-        }            
-    
-        public virtual int Count
-        {
-            get
-            {
-                int count = 0;
-
-                if (m_permSet != null)
-                    count += m_permSet.GetCount();
-
-                return count;
-            }
-        }
-
-        internal IPermission GetPermission(int index)
-        {
-            if (m_permSet == null)
-                return null;
-            Object obj = m_permSet.GetItem( index );
-            if (obj == null)
-                return null;
-            return obj as IPermission;
-        }
-
-        internal IPermission GetPermission(PermissionToken permToken)
-        {
-            if (permToken == null)
-                return null;
-                    
-            return GetPermission( permToken.m_index );
-        }
-
-        internal IPermission GetPermission( IPermission perm )
-        {
-            if (perm == null)
-                return null;
-
-            return GetPermission(PermissionToken.GetToken( perm ));
-        }
-
-        public IPermission SetPermission(IPermission perm)
-        {
-            return SetPermissionImpl(perm);
-        }
-
-        // SetPermission overwrites a permission in a permissionset.
-        protected virtual IPermission SetPermissionImpl(IPermission perm)
-        {
-            // can't get token if perm is null
-            if (perm == null)
-                return null;
-
-            PermissionToken permToken = PermissionToken.GetToken(perm);
-
-            if ((permToken.m_type & PermissionTokenType.IUnrestricted) != 0)
-            {
-                // SetPermission Makes the Permission "Restricted"
-                m_Unrestricted = false;
-            }
-
-            CheckSet();
-
-            IPermission currPerm = GetPermission( permToken.m_index );
-
-            m_CheckedForNonCas = false;
-
-            // Should we copy here?
-            m_permSet.SetItem( permToken.m_index, perm );
-            return perm;
-        }
-
-        public IPermission AddPermission(IPermission perm)
-        {
-            return AddPermissionImpl(perm);
-        }
-
-        protected virtual IPermission AddPermissionImpl(IPermission perm)
-        {
-            // can't get token if perm is null
-            if (perm == null)
-                return null;
-
-            m_CheckedForNonCas = false;
-
-            // If the permission set is unrestricted, then return an unrestricted instance
-            // of perm.
-
-            PermissionToken permToken = PermissionToken.GetToken(perm);
-
-            if (this.IsUnrestricted() && ((permToken.m_type & PermissionTokenType.IUnrestricted) != 0))
-            {
-                Type perm_type = perm.GetType();
-                Object[] objs = new Object[1];
-                objs[0] = PermissionState.Unrestricted;
-                return (IPermission) Activator.CreateInstance(perm_type, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public, null, objs, null );
-            }
-
-            CheckSet();
-            IPermission currPerm = GetPermission(permToken.m_index);
-
-            // If a Permission exists in this slot, then union it with perm
-            // Otherwise, just add perm.
-
-            if (currPerm != null) {
-                IPermission ip_union = currPerm.Union(perm);
-                m_permSet.SetItem( permToken.m_index, ip_union );
-                return ip_union;
-            } else {
-                // Should we copy here?
-                m_permSet.SetItem( permToken.m_index, perm );
-                return perm;
-            }
-                
-        }
-
-        private IPermission RemovePermission( int index )
-        {
-            IPermission perm = GetPermission(index);
-            if (perm == null)
-                return null;
-            return (IPermission)m_permSet.RemoveItem( index ); // this cast is safe because the call to GetPermission will guarantee it is an IPermission
-        }
-
-        // Make this internal soon.
-        internal void SetUnrestricted(bool unrestricted)
-        {
-            m_Unrestricted = unrestricted;
-            if (unrestricted)
-            {
-                // if this is to be an unrestricted permset, null the m_permSet member
-                m_permSet = null;
-            }
-        }
-
-        public bool IsUnrestricted()
-        {
-            return m_Unrestricted;
-        }
-
-        internal enum IsSubsetOfType
-        {
-            Normal,
-            CheckDemand,
-            CheckPermitOnly,
-            CheckAssertion,
-        }
-
-        internal bool IsSubsetOfHelper(PermissionSet target, IsSubsetOfType type, out IPermission firstPermThatFailed, bool ignoreNonCas)
-        {
-    #if _DEBUG
-            if (debug)     
-                DEBUG_WRITE("IsSubsetOf\n" +
-                            "Other:\n" +
-                            (target == null ? "<null>" : target.ToString()) +
-                            "\nMe:\n" +
-                            ToString());
-    #endif
-    
-            firstPermThatFailed = null;
-            if (target == null || target.FastIsEmpty())
-            {
-                if(this.IsEmpty())
-                    return true;
-                else
-                {
-                    firstPermThatFailed = GetFirstPerm();
-                    return false;
-                }
-            }
-            else if (this.IsUnrestricted() && !target.IsUnrestricted())
-                return false;
-            else if (this.m_permSet == null)
-                return true;
-            else
-            {
-                target.CheckSet();
-
-                for (int i = m_permSet.GetStartingIndex(); i <= this.m_permSet.GetMaxUsedIndex(); ++i)
-                {
-                    IPermission thisPerm = this.GetPermission(i);
-                    if (thisPerm == null || thisPerm.IsSubsetOf(null))
-                        continue;
-
-                    IPermission targetPerm = target.GetPermission(i);
-#if _DEBUG                    
-                    PermissionToken token = (PermissionToken)PermissionToken.s_tokenSet.GetItem( i );
-                    Debug.Assert(targetPerm == null || (token.m_type & PermissionTokenType.DontKnow) == 0, "Token not properly initialized");
-#endif
-
-                    if (target.m_Unrestricted)
-                        continue;
-
-                    // targetPerm can be null here, but that is fine since it thisPerm is a subset
-                    // of empty/null then we can continue in the loop.
-                    CodeAccessPermission cap = thisPerm as CodeAccessPermission;
-                    if(cap == null)
-                    {
-                        if (!ignoreNonCas && !thisPerm.IsSubsetOf( targetPerm ))
-                        {
-                            firstPermThatFailed = thisPerm;
-                            return false;
-                        }
-                    }
-                    else
-                    {
-                        firstPermThatFailed = thisPerm;
-                        switch(type)
-                        {
-                        case IsSubsetOfType.Normal:
-                            if (!thisPerm.IsSubsetOf( targetPerm ))
-                                return false;
-                            break;
-                        case IsSubsetOfType.CheckDemand:
-                            if (!cap.CheckDemand( (CodeAccessPermission)targetPerm ))
-                                return false;
-                            break;
-                        case IsSubsetOfType.CheckPermitOnly:
-                            if (!cap.CheckPermitOnly( (CodeAccessPermission)targetPerm ))
-                                return false;
-                            break;
-                        case IsSubsetOfType.CheckAssertion:
-                            if (!cap.CheckAssert( (CodeAccessPermission)targetPerm ))
-                                return false;
-                            break;
-                        }
-                        firstPermThatFailed = null;
-                    }
-                }
-            }
-
-            return true;
-        }
-
-        public bool IsSubsetOf(PermissionSet target)
-        {
-            IPermission perm;
-            return IsSubsetOfHelper(target, IsSubsetOfType.Normal, out perm, false);
-        }
-
-        internal bool CheckDemand(PermissionSet target, out IPermission firstPermThatFailed)
-        {
-            return IsSubsetOfHelper(target, IsSubsetOfType.CheckDemand, out firstPermThatFailed, true);
-        }
-
-        internal bool CheckPermitOnly(PermissionSet target, out IPermission firstPermThatFailed)
-        {
-            return IsSubsetOfHelper(target, IsSubsetOfType.CheckPermitOnly, out firstPermThatFailed, true);
-        }
-
-        internal bool CheckAssertion(PermissionSet target)
-        {
-            IPermission perm;
-            return IsSubsetOfHelper(target, IsSubsetOfType.CheckAssertion, out perm, true);
-        }
-        
-        internal bool CheckDeny(PermissionSet deniedSet, out IPermission firstPermThatFailed)
-        {
-            firstPermThatFailed = null;
-            if (deniedSet == null || deniedSet.FastIsEmpty() || this.FastIsEmpty())
-                return true;
-
-            if(this.m_Unrestricted && deniedSet.m_Unrestricted)
-                return false;
-
-            CodeAccessPermission permThis, permThat;
-            PermissionSetEnumeratorInternal enumThis = new PermissionSetEnumeratorInternal(this);
-
-            while (enumThis.MoveNext())
-            {
-                permThis = enumThis.Current as CodeAccessPermission;
-                if(permThis == null || permThis.IsSubsetOf(null))
-                    continue; // ignore non-CAS permissions in the grant set.
-                if (deniedSet.m_Unrestricted)
-                {
-                    firstPermThatFailed = permThis;
-                    return false;
-                }
-                permThat = (CodeAccessPermission)deniedSet.GetPermission(enumThis.GetCurrentIndex());
-                if (!permThis.CheckDeny(permThat))
-                {
-                    firstPermThatFailed = permThis;
-                    return false;
-                }
-            }
-            if(this.m_Unrestricted)
-            {
-                PermissionSetEnumeratorInternal enumThat = new PermissionSetEnumeratorInternal(deniedSet);
-                while (enumThat.MoveNext())
-                {
-                    if(enumThat.Current is IPermission)
-                        return false;
-                }
-            }
-            return true;
-        }
-
-        internal void CheckDecoded( CodeAccessPermission demandedPerm, PermissionToken tokenDemandedPerm )
-        {
-            Debug.Assert( demandedPerm != null, "Expected non-null value" );
-
-            if (this.m_allPermissionsDecoded || this.m_permSet == null)
-                return;
-
-            if (tokenDemandedPerm == null)
-                tokenDemandedPerm = PermissionToken.GetToken( demandedPerm );
-
-            Debug.Assert( tokenDemandedPerm != null, "Unable to find token for demanded permission" );
-        
-            CheckDecoded( tokenDemandedPerm.m_index );
-        }
-
-        internal void CheckDecoded( int index )
-        {
-            if (this.m_allPermissionsDecoded || this.m_permSet == null)
-                return;
-
-            GetPermission(index);
-        }
-
-        internal void CheckDecoded(PermissionSet demandedSet)
-        {
-            Debug.Assert(demandedSet != null, "Expected non-null value");
-
-            if (this.m_allPermissionsDecoded || this.m_permSet == null)
-                return;
-
-            PermissionSetEnumeratorInternal enumerator = demandedSet.GetEnumeratorInternal();
-
-            while (enumerator.MoveNext())
-            {
-                CheckDecoded(enumerator.GetCurrentIndex());
-            }
-        }
-
-        internal void InplaceIntersect( PermissionSet other )
-        {
-            Exception savedException = null;
-        
-            m_CheckedForNonCas = false;
-            
-            if (this == other)
-                return;
-            
-            if (other == null || other.FastIsEmpty())
-            {
-                // If the other is empty or null, make this empty.
-                Reset();
-                return;
-            }
-
-            if (this.FastIsEmpty())
-                return;
-
-            int maxMax = this.m_permSet == null ? -1 : this.m_permSet.GetMaxUsedIndex();
-            int otherMax = other.m_permSet == null ? -1 : other.m_permSet.GetMaxUsedIndex();
-
-            if (this.IsUnrestricted() && maxMax < otherMax)
-            {
-                maxMax = otherMax;
-                this.CheckSet();
-            }
-                
-            if (other.IsUnrestricted())
-            {
-                other.CheckSet();
-            }
-                
-            for (int i = 0; i <= maxMax; ++i)
-            {
-                Object thisObj = this.m_permSet.GetItem( i );
-                IPermission thisPerm = thisObj as IPermission;
-
-                Object otherObj = other.m_permSet.GetItem( i );
-                IPermission otherPerm = otherObj as IPermission;
-
-                if (thisObj == null && otherObj == null)
-                    continue;
-
-                if (thisObj == null)
-                {
-                    // There is no object in <this>, so intersection is empty except for IUnrestrictedPermissions
-                    if (this.IsUnrestricted())
-                    {
-                        {
-                            PermissionToken token = (PermissionToken)PermissionToken.s_tokenSet.GetItem( i );
-                            if ((token.m_type & PermissionTokenType.IUnrestricted) != 0)
-                            {
-                                this.m_permSet.SetItem( i, otherPerm.Copy() );
-                                Debug.Assert( PermissionToken.s_tokenSet.GetItem( i ) != null, "PermissionToken should already be assigned" );
-                            }
-                        }
-                    }
-                }
-                else if (otherObj == null)
-                {
-                    if (other.IsUnrestricted())
-                    {
-                        {
-                            PermissionToken token = (PermissionToken)PermissionToken.s_tokenSet.GetItem( i );
-                            if ((token.m_type & PermissionTokenType.IUnrestricted) == 0)
-                                this.m_permSet.SetItem( i, null );
-                        }
-                    }
-                    else
-                    {
-                        this.m_permSet.SetItem( i, null );
-                    }
-                }
-                else
-                {
-                    try
-                    {
-                        IPermission intersectPerm;
-                        if (thisPerm == null)
-                            intersectPerm = otherPerm;
-                        else if(otherPerm == null)
-                            intersectPerm = thisPerm;
-                        else
-                            intersectPerm = thisPerm.Intersect( otherPerm );
-                        this.m_permSet.SetItem( i, intersectPerm );
-                    }
-                    catch (Exception e)
-                    {
-                        if (savedException == null)
-                            savedException = e;
-                    }
-                }
-            }
-
-            this.m_Unrestricted = this.m_Unrestricted && other.m_Unrestricted;
-
-            if (savedException != null)
-                throw savedException;
-        }
-
-        public PermissionSet Intersect(PermissionSet other)
-        {
-            if (other == null || other.FastIsEmpty() || this.FastIsEmpty())
-            {
-                return null;
-            }
-
-            int thisMax = this.m_permSet == null ? -1 : this.m_permSet.GetMaxUsedIndex();
-            int otherMax = other.m_permSet == null ? -1 : other.m_permSet.GetMaxUsedIndex();
-            int minMax = thisMax < otherMax ? thisMax : otherMax;
-
-            if (this.IsUnrestricted() && minMax < otherMax)
-            {
-                minMax = otherMax;
-                this.CheckSet();
-            }
-
-            if (other.IsUnrestricted() && minMax < thisMax)
-            {
-                minMax = thisMax;
-                other.CheckSet();
-            }
-
-            PermissionSet pset = new PermissionSet( false );
-
-            if (minMax > -1)
-            {
-                pset.m_permSet = new TokenBasedSet();
-            }
-
-            for (int i = 0; i <= minMax; ++i)
-            {
-                Object thisObj = this.m_permSet.GetItem( i );
-                IPermission thisPerm = thisObj as IPermission;
-                Object otherObj = other.m_permSet.GetItem( i );
-                IPermission otherPerm = otherObj as IPermission;
-
-                if (thisObj == null && otherObj == null)
-                    continue;
-
-                if (thisObj == null)
-                {
-                    if (this.m_Unrestricted)
-                    {
-                        if (otherPerm != null)
-                        {
-                            PermissionToken token = (PermissionToken)PermissionToken.s_tokenSet.GetItem( i );
-                            if ((token.m_type & PermissionTokenType.IUnrestricted) != 0)
-                            {
-                                pset.m_permSet.SetItem( i, otherPerm.Copy() );
-                                Debug.Assert( PermissionToken.s_tokenSet.GetItem( i ) != null, "PermissionToken should already be assigned" );
-                            }
-                        }
-                    }
-                }
-                else if (otherObj == null)
-                {
-                    if (other.m_Unrestricted)
-                    {
-                        if (thisPerm != null)
-                        {
-                            PermissionToken token = (PermissionToken)PermissionToken.s_tokenSet.GetItem( i );
-                            if ((token.m_type & PermissionTokenType.IUnrestricted) != 0)
-                            {
-                                pset.m_permSet.SetItem( i, thisPerm.Copy() );
-                                Debug.Assert( PermissionToken.s_tokenSet.GetItem( i ) != null, "PermissionToken should already be assigned" );
-                            }
-                        }
-                    }
-                }
-                else
-                {
-                    IPermission intersectPerm;
-                    if (thisPerm == null)
-                        intersectPerm = otherPerm;
-                    else if(otherPerm == null)
-                        intersectPerm = thisPerm;
-                    else
-                        intersectPerm = thisPerm.Intersect( otherPerm );
-                    pset.m_permSet.SetItem( i, intersectPerm );
-                    Debug.Assert( intersectPerm == null || PermissionToken.s_tokenSet.GetItem( i ) != null, "PermissionToken should already be assigned" );
-                }
-            }
-
-            pset.m_Unrestricted = this.m_Unrestricted && other.m_Unrestricted;
-            if (pset.FastIsEmpty())
-                return null;
-            else
-                return pset;
-        }
-
-        internal void InplaceUnion( PermissionSet other )
-        {
-            // Unions the "other" PermissionSet into this one.  It can be optimized to do less copies than
-            // need be done by the traditional union (and we don't have to create a new PermissionSet).
-            
-            if (this == other)
-                return;
-            
-            // Quick out conditions, union doesn't change this PermissionSet
-            if (other == null || other.FastIsEmpty())
-                return;
-
-            m_CheckedForNonCas = false;
-
-            this.m_Unrestricted = this.m_Unrestricted || other.m_Unrestricted;
-
-            if (this.m_Unrestricted)
-            {
-                // if the result of Union is unrestricted permset, null the m_permSet member
-                this.m_permSet = null;
-                return;
-            }
-
-
-            // If we reach here, result of Union is not unrestricted
-            // We have to union "normal" permission no matter what now.
-            int maxMax = -1;            
-            if (other.m_permSet != null)
-            {
-                maxMax = other.m_permSet.GetMaxUsedIndex();
-                this.CheckSet();
-            }
-            // Save exceptions until the end
-            Exception savedException = null;
-
-            for (int i = 0; i <= maxMax; ++i)
-            {
-                Object thisObj = this.m_permSet.GetItem( i );
-                IPermission thisPerm = thisObj as IPermission;
-
-                Object otherObj = other.m_permSet.GetItem( i );
-                IPermission otherPerm = otherObj as IPermission;
-
-                if (thisObj == null && otherObj == null)
-                    continue;
-
-                if (thisObj == null)
-                {
-                    if (otherPerm != null)
-                    {
-                        PermissionToken token = (PermissionToken)PermissionToken.s_tokenSet.GetItem( i );
-                        if (((token.m_type & PermissionTokenType.IUnrestricted) == 0) || !this.m_Unrestricted)
-                        {
-                            this.m_permSet.SetItem( i, otherPerm.Copy() );
-                        }
-                    }
-                }
-                else if (otherObj == null)
-                {
-                    continue;
-                }
-                else
-                {
-                    try
-                    {
-                        IPermission unionPerm;
-                        if(thisPerm == null)
-                            unionPerm = otherPerm;
-                        else if(otherPerm == null)
-                            unionPerm = thisPerm;
-                        else
-                            unionPerm = thisPerm.Union( otherPerm );
-                        this.m_permSet.SetItem( i, unionPerm );
-                    }
-                    catch (Exception e)
-                    {
-                        if (savedException == null)
-                            savedException = e;
-                    }
-                }
-            }
-            
-            if (savedException != null)
-                throw savedException;
-        }
-
-        public PermissionSet Union(PermissionSet other)
-        {
-            // if other is null or empty, return a clone of myself
-            if (other == null || other.FastIsEmpty())
-            {
-                return this.Copy();
-            }
-            
-            if (this.FastIsEmpty())
-            {
-                return other.Copy();
-            }
-
-            int maxMax = -1;
-
-            PermissionSet pset = new PermissionSet();
-            pset.m_Unrestricted = this.m_Unrestricted || other.m_Unrestricted;
-            if (pset.m_Unrestricted)
-            {
-                // if the result of Union is unrestricted permset, just return
-                return pset;
-            }
-            
-            // degenerate case where we look at both this.m_permSet and other.m_permSet
-            this.CheckSet();
-            other.CheckSet();
-            maxMax = this.m_permSet.GetMaxUsedIndex() > other.m_permSet.GetMaxUsedIndex() ? this.m_permSet.GetMaxUsedIndex() : other.m_permSet.GetMaxUsedIndex();
-            pset.m_permSet = new TokenBasedSet();
-
-
-
-            for (int i = 0; i <= maxMax; ++i)
-            {
-                Object thisObj = this.m_permSet.GetItem( i );
-                IPermission thisPerm = thisObj as IPermission;
-
-                Object otherObj = other.m_permSet.GetItem( i );
-                IPermission otherPerm = otherObj as IPermission;
-
-                if (thisObj == null && otherObj == null)
-                    continue;
-
-                if (thisObj == null)
-                {
-                    if (otherPerm != null)
-                    {
-                        PermissionToken token = (PermissionToken)PermissionToken.s_tokenSet.GetItem( i );
-                        if (((token.m_type & PermissionTokenType.IUnrestricted) == 0) || !pset.m_Unrestricted)
-                        {
-                            pset.m_permSet.SetItem( i, otherPerm.Copy() );
-                            Debug.Assert( PermissionToken.s_tokenSet.GetItem( i ) != null, "PermissionToken should already be assigned" );
-                        }
-                    }
-                }
-                else if (otherObj == null)
-                {
-                    if (thisPerm != null)
-                    {
-                        PermissionToken token = (PermissionToken)PermissionToken.s_tokenSet.GetItem( i );
-                        if (((token.m_type & PermissionTokenType.IUnrestricted) == 0) || !pset.m_Unrestricted)
-                        {
-                            pset.m_permSet.SetItem( i, thisPerm.Copy() );
-                            Debug.Assert( PermissionToken.s_tokenSet.GetItem( i ) != null, "PermissionToken should already be assigned" );
-                        }
-                    }
-                }
-                else
-                {
-                    IPermission unionPerm;
-                    if(thisPerm == null)
-                        unionPerm = otherPerm;
-                    else if(otherPerm == null)
-                        unionPerm = thisPerm;
-                    else
-                        unionPerm = thisPerm.Union( otherPerm );
-                    pset.m_permSet.SetItem( i, unionPerm );
-                    Debug.Assert( unionPerm == null || PermissionToken.s_tokenSet.GetItem( i ) != null, "PermissionToken should already be assigned" );
-                }
-            }
-
-            return pset;
-        }
-
-        // Treating the current permission set as a grant set, and the input set as
-        // a set of permissions to be denied, try to cancel out as many permissions
-        // from both sets as possible. For a first cut, any granted permission that
-        // is a safe subset of the corresponding denied permission can result in
-        // that permission being removed from both sides.
-
-        internal void MergeDeniedSet(PermissionSet denied)
-        {
-            if (denied == null || denied.FastIsEmpty() || this.FastIsEmpty())
-                return;
-
-            m_CheckedForNonCas = false;
-
-            // Check for the unrestricted case: FastIsEmpty() will return false if the PSet is unrestricted, but has no items
-            if (this.m_permSet == null || denied.m_permSet == null)
-                return; //nothing can be removed
-
-            int maxIndex = denied.m_permSet.GetMaxUsedIndex() > this.m_permSet.GetMaxUsedIndex() ? this.m_permSet.GetMaxUsedIndex() : denied.m_permSet.GetMaxUsedIndex();
-            for (int i = 0; i <= maxIndex; ++i) {
-                IPermission deniedPerm = denied.m_permSet.GetItem(i) as IPermission;
-                if (deniedPerm == null)
-                    continue;
-
-                IPermission thisPerm = this.m_permSet.GetItem(i) as IPermission;
-
-                if (thisPerm == null && !this.m_Unrestricted) {
-                    denied.m_permSet.SetItem(i, null);
-                    continue;
-                }
-
-                if (thisPerm != null && deniedPerm != null) {
-                    if (thisPerm.IsSubsetOf(deniedPerm)) {
-                        this.m_permSet.SetItem(i, null);
-                        denied.m_permSet.SetItem(i, null);
-                    }
-                }
-            }
-        }
-
-        // Returns true if perm is contained in this
-        internal bool Contains(IPermission perm)
-        {
-            if (perm == null)
-                return true;
-            if (m_Unrestricted)
-                return true;
-            if (FastIsEmpty())
-                return false;
-
-            PermissionToken token = PermissionToken.GetToken(perm);
-            Object thisObj = this.m_permSet.GetItem( token.m_index );
-            if (thisObj == null)
-                return perm.IsSubsetOf( null );
-
-            IPermission thisPerm = GetPermission(token.m_index);
-            if (thisPerm != null)
-                return perm.IsSubsetOf( thisPerm );
-            else
-                return perm.IsSubsetOf( null );
-        }
-
-        [System.Runtime.InteropServices.ComVisible(false)]
-        public override bool Equals( Object obj )
-        {
-            // Note: this method is designed to accept both PermissionSet and NamedPermissionSets.
-            // It will compare them based on the values in the base type, thereby ignoring the
-            // name and description of the named permission set.
-
-            PermissionSet other = obj as PermissionSet;
-
-            if (other == null)
-                return false;
-
-            if (this.m_Unrestricted != other.m_Unrestricted)
-                return false;
-
-            CheckSet();
-            other.CheckSet();
-
-            DecodeAllPermissions();
-            other.DecodeAllPermissions();
-
-            int maxIndex = Math.Max( this.m_permSet.GetMaxUsedIndex(), other.m_permSet.GetMaxUsedIndex() );
-
-            for (int i = 0; i <= maxIndex; ++i)
-            {
-                IPermission thisPerm = (IPermission)this.m_permSet.GetItem( i );
-                IPermission otherPerm = (IPermission)other.m_permSet.GetItem( i );
-
-                if (thisPerm == null && otherPerm == null)
-                {
-                    continue;
-                }
-                else if (thisPerm == null)
-                {
-                    if (!otherPerm.IsSubsetOf( null ))
-                        return false;
-                }
-                else if (otherPerm == null)
-                {
-                    if (!thisPerm.IsSubsetOf( null ))
-                        return false;
-                }
-                else
-                {
-                    if (!thisPerm.Equals( otherPerm ))
-                        return false;
-                }
-            }
-
-            return true;
-        }
-
-        [System.Runtime.InteropServices.ComVisible(false)]
-        public override int GetHashCode()
-        {
-            int accumulator;
-
-            accumulator = this.m_Unrestricted ? -1 : 0;
-
-            if (this.m_permSet != null)
-            {
-                DecodeAllPermissions();
-
-                int maxIndex = this.m_permSet.GetMaxUsedIndex();
-
-                for (int i = m_permSet.GetStartingIndex(); i <= maxIndex; ++i)
-                {
-                    IPermission perm = (IPermission)this.m_permSet.GetItem( i );
-                    if (perm != null)
-                    {
-                        accumulator = accumulator ^ perm.GetHashCode();
-                    }
-                }
-            }
-
-            return accumulator;
-        }
-    
-        // Mark this method as requiring a security object on the caller's frame
-        // so the caller won't be inlined (which would mess up stack crawling).
-        [DynamicSecurityMethodAttribute()]
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        public void Demand()
-        {
-            if (this.FastIsEmpty())
-                return;  // demanding the empty set always passes.
-
-            ContainsNonCodeAccessPermissions();
-
-            if (m_ContainsCas)
-            {
-                StackCrawlMark stackMark = StackCrawlMark.LookForMyCallersCaller;
-                CodeAccessSecurityEngine.Check(GetCasOnlySet(), ref stackMark);
-            }
-            if (m_ContainsNonCas)
-            {
-                DemandNonCAS();
-            }
-        }
-
-        internal void DemandNonCAS()
-        {
-            ContainsNonCodeAccessPermissions();
-
-            if (m_ContainsNonCas)
-            {
-                if (this.m_permSet != null)
-                {
-                    CheckSet();
-                    for (int i = m_permSet.GetStartingIndex(); i <= this.m_permSet.GetMaxUsedIndex(); ++i)
-                    {
-                        IPermission currPerm = GetPermission(i);
-                        if (currPerm != null && !(currPerm is CodeAccessPermission))
-                            currPerm.Demand();
-                    }
-                }
-            }
-        }
-
-        // Metadata for this method should be flaged with REQ_SQ so that
-        // EE can allocate space on the stack frame for FrameSecurityDescriptor
-
-        [DynamicSecurityMethodAttribute()]
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        public void Assert() 
-        {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            SecurityRuntime.Assert(this, ref stackMark);
-        }
-    
-        // Metadata for this method should be flaged with REQ_SQ so that
-        // EE can allocate space on the stack frame for FrameSecurityDescriptor
-    
-        [DynamicSecurityMethodAttribute()]
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        [Obsolete("Deny is obsolete and will be removed in a future release of the .NET Framework. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
-        public void Deny()
-        {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            SecurityRuntime.Deny(this, ref stackMark);
-        }
-    
-        // Metadata for this method should be flaged with REQ_SQ so that
-        // EE can allocate space on the stack frame for FrameSecurityDescriptor
-    
-        [DynamicSecurityMethodAttribute()]
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        public void PermitOnly()
-        {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            SecurityRuntime.PermitOnly(this, ref stackMark);
-        }
-
-        internal IPermission GetFirstPerm()
-        {
-            IEnumerator enumerator = GetEnumerator();
-            if(!enumerator.MoveNext())
-                return null;
-            return enumerator.Current as IPermission;
-        }
-
-        // Returns a deep copy
-        public virtual PermissionSet Copy()
-        {
-            return new PermissionSet(this);
-        }
-
-        internal PermissionSet CopyWithNoIdentityPermissions()
-        {
-            // Explicitly make a new PermissionSet, rather than copying, since we may have a
-            // ReadOnlyPermissionSet which cannot have identity permissions removed from it in a true copy.
-            return new PermissionSet(this);
-        }
-
-        public IEnumerator GetEnumerator()
-        {
-            return GetEnumeratorImpl();
-        }
-
-        protected virtual IEnumerator GetEnumeratorImpl()
-        {
-            return new PermissionSetEnumerator(this);
-        }
-
-        internal PermissionSetEnumeratorInternal GetEnumeratorInternal()
-        {
-            return new PermissionSetEnumeratorInternal(this);
-        }
-
-        private void NormalizePermissionSet()
-        {
-            // This function guarantees that all the permissions are placed at
-            // the proper index within the token based sets.  This becomes necessary
-            // since these indices are dynamically allocated based on usage order.
-        
-            PermissionSet permSetTemp = new PermissionSet(false);
-            
-            permSetTemp.m_Unrestricted = this.m_Unrestricted;
-
-            // Move all the normal permissions to the new permission set
-
-            if (this.m_permSet != null)
-            {
-                for (int i = m_permSet.GetStartingIndex(); i <= this.m_permSet.GetMaxUsedIndex(); ++i)
-                {
-                    Object obj = this.m_permSet.GetItem(i);
-                    IPermission perm = obj as IPermission;
-                    if (perm != null)
-                        permSetTemp.SetPermission( perm );
-                }
-            }
-    
-            this.m_permSet = permSetTemp.m_permSet;
-        }
-
-        private void DecodeAllPermissions()
-        {
-            if (m_permSet == null)
-            {
-                m_allPermissionsDecoded = true;
-                return;
-            }
-
-            int maxIndex = m_permSet.GetMaxUsedIndex();
-            for (int i = 0; i <= maxIndex; ++i)
-            {
-                // GetPermission has the side-effect of decoding the permission in the slot
-                GetPermission(i);
-            }
-
-            m_allPermissionsDecoded = true;
-        }
-
-        internal void FilterHostProtectionPermissions(HostProtectionResource fullTrustOnly, HostProtectionResource inaccessible)
-        {
-            HostProtectionPermission.protectedResources = fullTrustOnly;
-            HostProtectionPermission hpp = (HostProtectionPermission)GetPermission(HostProtectionPermission.GetTokenIndex());
-            if(hpp == null)
-                return;
-
-            HostProtectionPermission newHpp = (HostProtectionPermission)hpp.Intersect(new HostProtectionPermission(fullTrustOnly));
-            if (newHpp == null)
-            {
-                RemovePermission(HostProtectionPermission.GetTokenIndex());
-            }
-            else if (newHpp.Resources != hpp.Resources)
-            {
-                SetPermission(newHpp);
-            }
-        }
-
-        // Determines whether the permission set contains any non-code access
-        // security permissions.
-        public bool ContainsNonCodeAccessPermissions()
-        {
-            if (m_CheckedForNonCas)
-                return m_ContainsNonCas;
-
-            lock (this)
-            {
-                if (m_CheckedForNonCas)
-                    return m_ContainsNonCas;
-
-                m_ContainsCas = false;
-                m_ContainsNonCas = false;
-
-                if (IsUnrestricted())
-                    m_ContainsCas = true;
-
-                if (this.m_permSet != null)
-                {
-                    PermissionSetEnumeratorInternal enumerator = new PermissionSetEnumeratorInternal(this);
-
-                    while (enumerator.MoveNext() && (!m_ContainsCas || !m_ContainsNonCas))
-                    {
-                        IPermission perm = enumerator.Current as IPermission;
-
-                        if (perm != null)
-                        {
-                            if (perm is CodeAccessPermission)
-                                m_ContainsCas = true;
-                            else
-                                m_ContainsNonCas = true;
-                        }
-                    }
-                }
-
-                m_CheckedForNonCas = true;
-            }
-
-            return m_ContainsNonCas;
-        }
-        
-        // Returns a permission set containing only CAS-permissions. If possible
-        // this is just the input set, otherwise a new set is allocated.
-        private PermissionSet GetCasOnlySet()
-        {
-            if (!m_ContainsNonCas)
-                return this;
-
-            if (IsUnrestricted())
-                return this;
-
-            PermissionSet pset = new PermissionSet(false);
-
-            PermissionSetEnumeratorInternal enumerator = new PermissionSetEnumeratorInternal(this);
-
-            while (enumerator.MoveNext())
-            {
-                IPermission perm = (IPermission)enumerator.Current;
-
-                if (perm is CodeAccessPermission)
-                    pset.AddPermission(perm);
-            }
-
-            pset.m_CheckedForNonCas = true;
-            pset.m_ContainsCas = !pset.IsEmpty();
-            pset.m_ContainsNonCas = false;
-
-            return pset;
-        }
-
-        // Internal routine used by CreateSerialized to add a permission to the set
-        private static void MergePermission(IPermission perm, bool separateCasFromNonCas, ref PermissionSet casPset, ref PermissionSet nonCasPset)
-        {
-            Debug.Assert(casPset == null || !casPset.IsReadOnly);
-            Debug.Assert(nonCasPset == null || !nonCasPset.IsReadOnly);
-
-            if (perm == null)
-                return;
-
-            if (!separateCasFromNonCas || perm is CodeAccessPermission)
-            {
-                if(casPset == null)
-                    casPset = new PermissionSet(false);
-                IPermission oldPerm = casPset.GetPermission(perm);
-                IPermission unionPerm = casPset.AddPermission(perm);
-                if (oldPerm != null && !oldPerm.IsSubsetOf( unionPerm ))
-                    throw new NotSupportedException( Environment.GetResourceString( "NotSupported_DeclarativeUnion" ) );
-            }
-            else
-            {
-                if(nonCasPset == null)
-                    nonCasPset = new PermissionSet(false);
-                IPermission oldPerm = nonCasPset.GetPermission(perm);
-                IPermission unionPerm = nonCasPset.AddPermission( perm );
-                if (oldPerm != null && !oldPerm.IsSubsetOf( unionPerm ))
-                    throw new NotSupportedException( Environment.GetResourceString( "NotSupported_DeclarativeUnion" ) );
-            }
-        }
-
-        // Converts an array of SecurityAttributes to a PermissionSet
-        private static byte[] CreateSerialized(Object[] attrs,
-                                               bool serialize,
-                                               ref byte[] nonCasBlob,
-                                               out PermissionSet casPset,
-                                               HostProtectionResource fullTrustOnlyResources,
-                                               bool allowEmptyPermissionSets)
-        {
-            // Create two new (empty) sets.
-            casPset = null;
-            PermissionSet nonCasPset = null;
-
-            // Most security attributes generate a single permission. The
-            // PermissionSetAttribute class generates an entire permission set we
-            // need to merge, however.
-            for (int i = 0; i < attrs.Length; i++)
-            {
-#pragma warning disable 618
-                Debug.Assert(i == 0 || ((SecurityAttribute)attrs[i]).m_action == ((SecurityAttribute)attrs[i - 1]).m_action, "Mixed SecurityActions");
-#pragma warning restore 618
-                if (attrs[i] is PermissionSetAttribute)
-                {
-                    PermissionSet pset = ((PermissionSetAttribute)attrs[i]).CreatePermissionSet();
-                    if (pset == null)
-                        throw new ArgumentException( Environment.GetResourceString( "Argument_UnableToGeneratePermissionSet" ) );
-
-                    PermissionSetEnumeratorInternal enumerator = new PermissionSetEnumeratorInternal(pset);
-
-                    while (enumerator.MoveNext())
-                    {
-                        IPermission perm = (IPermission)enumerator.Current;
-                        MergePermission(perm, serialize, ref casPset, ref nonCasPset);
-                    }
-
-                    if(casPset == null)
-                        casPset = new PermissionSet(false);
-                    if (pset.IsUnrestricted())
-                        casPset.SetUnrestricted(true);
-                }
-                else
-                {
-#pragma warning disable 618
-                    IPermission perm = ((SecurityAttribute)attrs[i]).CreatePermission();
-#pragma warning restore 618
-                    MergePermission(perm, serialize, ref casPset, ref nonCasPset);
-                }
-            }
-            Debug.Assert(serialize || nonCasPset == null, "We shouldn't separate nonCAS permissions unless fSerialize is true");
-
-            //
-            // Filter HostProtection permission.  In the VM, some optimizations are done based upon these
-            // declarative permission sets being NULL if they do not exist.  When filtering the permission
-            // set if we end up with an empty set, we can the permission set NULL rather than returning the
-            // empty set in order to enable those optimizations.
-            //
-            
-            if(casPset != null)
-            {
-                casPset.FilterHostProtectionPermissions(fullTrustOnlyResources, HostProtectionResource.None);
-                casPset.ContainsNonCodeAccessPermissions(); // make sure all declarative PermissionSets are checked for non-CAS so we can just check the flag from native code
-                if (allowEmptyPermissionSets && casPset.IsEmpty())
-                    casPset = null;
-            }
-            if(nonCasPset != null)
-            {
-                nonCasPset.FilterHostProtectionPermissions(fullTrustOnlyResources, HostProtectionResource.None);
-                nonCasPset.ContainsNonCodeAccessPermissions(); // make sure all declarative PermissionSets are checked for non-CAS so we can just check the flag from native code
-                if (allowEmptyPermissionSets && nonCasPset.IsEmpty())
-                    nonCasPset = null;
-            }
-
-            Debug.Assert(!serialize, "Cannot serialize permission sets on CoreCLR");
-            return null;
-        }
-
-
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        public static void RevertAssert()
-        {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            SecurityRuntime.RevertAssert(ref stackMark);
-        }
-
-        internal static PermissionSet RemoveRefusedPermissionSet(PermissionSet assertSet, PermissionSet refusedSet, out bool bFailedToCompress)
-        {
-            Debug.Assert((assertSet == null || !assertSet.IsUnrestricted()), "Cannot be unrestricted here");
-            PermissionSet retPs = null;
-            bFailedToCompress = false;
-            if (assertSet == null)
-                return null;
-            if (refusedSet != null)
-            {
-                if (refusedSet.IsUnrestricted())
-                    return null; // we're refusing everything...cannot assert anything now.
-
-                PermissionSetEnumeratorInternal enumerator = new PermissionSetEnumeratorInternal(refusedSet);
-                while (enumerator.MoveNext())
-                {
-                    CodeAccessPermission refusedPerm = (CodeAccessPermission)enumerator.Current;
-                    int i = enumerator.GetCurrentIndex();
-                    if (refusedPerm != null)
-                    {
-                        CodeAccessPermission perm
-                            = (CodeAccessPermission)assertSet.GetPermission(i);
-                        try
-                        {
-                            if (refusedPerm.Intersect(perm) != null)
-                            {
-                                if (refusedPerm.Equals(perm))
-                                {
-                                    if (retPs == null)
-                                        retPs = assertSet.Copy();
-                
-                                    retPs.RemovePermission(i);
-                                }
-                                else
-                                {
-                                    // Asserting a permission, part of which is already denied/refused
-                                    // cannot compress this assert
-                                    bFailedToCompress = true;
-                                    return assertSet;
-                                }
-                            }
-                        }
-                        catch (ArgumentException)
-                        {
-                            // Any exception during removing a refused set from assert set => we play it safe and not assert that perm
-                            if (retPs == null)
-                                retPs = assertSet.Copy();
-                            retPs.RemovePermission(i);
-                        }
-                    }
-                }
-            }
-            if (retPs != null)
-                return retPs;
-            return assertSet;
-        }  
-
-        internal static void RemoveAssertedPermissionSet(PermissionSet demandSet, PermissionSet assertSet, out PermissionSet alteredDemandSet)
-        {
-            Debug.Assert(!assertSet.IsUnrestricted(), "Cannot call this function if assertSet is unrestricted");
-            alteredDemandSet = null;
-            
-            PermissionSetEnumeratorInternal enumerator = new PermissionSetEnumeratorInternal(demandSet);
-            while (enumerator.MoveNext())
-            {
-                CodeAccessPermission demandDerm = (CodeAccessPermission)enumerator.Current;
-                int i = enumerator.GetCurrentIndex();
-                if (demandDerm != null)
-                {
-                    CodeAccessPermission assertPerm
-                        = (CodeAccessPermission)assertSet.GetPermission(i);
-                    try
-                    {
-                        if (demandDerm.CheckAssert(assertPerm))
-                        {
-                            if (alteredDemandSet == null)
-                                alteredDemandSet = demandSet.Copy();
-            
-                            alteredDemandSet.RemovePermission(i);
-                        }
-                    }
-                    catch (ArgumentException)
-                    {
-                    }
-                }
-            }
-            return;
-        }
-
-        internal static bool IsIntersectingAssertedPermissions(PermissionSet assertSet1, PermissionSet assertSet2)
-        {
-            bool isIntersecting = false;
-            if (assertSet1 != null && assertSet2 != null)
-            {
-                PermissionSetEnumeratorInternal enumerator = new PermissionSetEnumeratorInternal(assertSet2);
-                while (enumerator.MoveNext())
-                {
-                    CodeAccessPermission perm2 = (CodeAccessPermission)enumerator.Current;
-                    int i = enumerator.GetCurrentIndex();
-                    if (perm2 != null)
-                    {
-                        CodeAccessPermission perm1
-                            = (CodeAccessPermission)assertSet1.GetPermission(i);
-                        try
-                        {
-                            if (perm1 != null && !perm1.Equals(perm2))
-                            {
-                                isIntersecting = true; // Same type of permission, but with different flags or something - cannot union them
-                            }
-                        }
-                        catch (ArgumentException)
-                        {
-                            isIntersecting = true; //assume worst case
-                        }
-                    }
-                }
-            }
-            return isIntersecting;
-            
-        }
-
-        // This is a workaround so that SQL can operate under default policy without actually
-        // granting permissions in assemblies that they disallow. 
-
-        internal bool IgnoreTypeLoadFailures
-        {
-            set { m_ignoreTypeLoadFailures = value; }
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/PermissionSetEnumerator.cs b/src/mscorlib/src/System/Security/PermissionSetEnumerator.cs
deleted file mode 100644
index 7b234e9cf4..0000000000
--- a/src/mscorlib/src/System/Security/PermissionSetEnumerator.cs
+++ /dev/null
@@ -1,89 +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.
-
-// 
-
-namespace System.Security 
-{
-    //PermissionSetEnumerator.cs
-    
-    using System;
-    using System.Collections;
-    using TokenBasedSetEnumerator = System.Security.Util.TokenBasedSetEnumerator;
-    using TokenBasedSet = System.Security.Util.TokenBasedSet;
-    
-    internal class PermissionSetEnumerator : IEnumerator 
-    {
-        PermissionSetEnumeratorInternal enm;
-        
-        public Object Current
-        {
-            get
-            {
-                return enm.Current;
-            }
-        }
-
-        public bool MoveNext()
-        {
-            return enm.MoveNext();
-        }
-        
-        public void Reset()
-        {
-            enm.Reset();
-        }
-        
-        internal PermissionSetEnumerator(PermissionSet permSet)
-        {
-            enm = new PermissionSetEnumeratorInternal(permSet);
-        }
-    }
-    
-    internal struct PermissionSetEnumeratorInternal 
-    {
-        private PermissionSet m_permSet;
-        private TokenBasedSetEnumerator enm;
-        
-        public Object Current
-        {
-            get
-            {
-                return enm.Current;
-            }
-        }
-
-        internal PermissionSetEnumeratorInternal(PermissionSet permSet)
-        {
-            m_permSet = permSet;
-            enm = new TokenBasedSetEnumerator(permSet.m_permSet);
-        }
-
-        public int GetCurrentIndex()
-        {
-            return enm.Index;
-        }
-        
-        public void Reset()
-        {
-            enm.Reset();
-        }
-        
-        public bool MoveNext()
-        {
-            while (enm.MoveNext())
-            {
-                Object obj = enm.Current;
-                IPermission perm = obj as IPermission;
-                if (perm != null)
-                {
-                    enm.Current = perm;
-                    return true;
-                }
-            }
-            return false;
-        }
-    }
-}
-
diff --git a/src/mscorlib/src/System/Security/PermissionSetTriple.cs b/src/mscorlib/src/System/Security/PermissionSetTriple.cs
deleted file mode 100644
index 56eb22996e..0000000000
--- a/src/mscorlib/src/System/Security/PermissionSetTriple.cs
+++ /dev/null
@@ -1,270 +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: Container class for holding an AppDomain's Grantset and Refused sets.
-**          Also used for CompressedStacks which brings in the third PermissionSet.
-**          Hence, the name PermissionSetTriple. 
-**
-=============================================================================*/
-
-namespace System.Security
-{
-    using IEnumerator = System.Collections.IEnumerator;
-    using System.Security;
-    using System.Security.Permissions;
-    using System.Runtime.InteropServices;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-
-
-    [Serializable]
-    sealed internal class PermissionSetTriple
-    {
-        static private volatile PermissionToken s_zoneToken;
-        static private volatile PermissionToken s_urlToken;
-        internal PermissionSet AssertSet;
-        internal PermissionSet GrantSet;
-        internal PermissionSet RefusedSet;
-        internal PermissionSetTriple()
-        {
-            Reset();
-        }
-        internal PermissionSetTriple(PermissionSetTriple triple)
-        {
-            this.AssertSet = triple.AssertSet;
-            this.GrantSet = triple.GrantSet;
-            this.RefusedSet = triple.RefusedSet;
-        }
-        internal void Reset()
-        {
-            AssertSet = null;
-            GrantSet = null;
-            RefusedSet = null;
-        }
-        internal bool IsEmpty()
-        {
-            return (AssertSet == null && GrantSet == null && RefusedSet == null);
-        }
-
-        private PermissionToken ZoneToken
-        {
-            get
-            {
-                if (s_zoneToken == null)
-                    s_zoneToken =  PermissionToken.GetToken(typeof(ZoneIdentityPermission));
-                return s_zoneToken;
-            }
-        }            
-        private PermissionToken UrlToken
-        {
-            get
-            {
-                if (s_urlToken == null)
-                    s_urlToken =  PermissionToken.GetToken(typeof(UrlIdentityPermission));
-                return s_urlToken;
-            }
-        }            
-        internal bool Update(PermissionSetTriple psTriple, out PermissionSetTriple retTriple)
-        {
-            retTriple = null;
-            retTriple = UpdateAssert(psTriple.AssertSet);
-            // Special case: unrestricted assert. Note: dcs.Assert.IsUnrestricted => dcs.Grant.IsUnrestricted
-            if (psTriple.AssertSet != null && psTriple.AssertSet.IsUnrestricted())
-            {
-                return true; // stop construction
-            }
-            UpdateGrant(psTriple.GrantSet);
-            UpdateRefused(psTriple.RefusedSet);
-            return false;
-        }
-
-        internal PermissionSetTriple UpdateAssert(PermissionSet in_a)
-        {
-            PermissionSetTriple retTriple = null;
-            if (in_a != null)
-            {
-                Debug.Assert((!in_a.IsUnrestricted() || RefusedSet == null), "Cannot be unrestricted or refused must be null");
-                // if we're already asserting in_a, nothing to do
-                if (in_a.IsSubsetOf(AssertSet))
-                    return null;
-
-                PermissionSet retPs;
-                if (GrantSet != null)
-                    retPs = in_a.Intersect(GrantSet); // Restrict the assert to what we've already been granted
-                else
-                {
-                    GrantSet = new PermissionSet(true);
-                    retPs = in_a.Copy(); // Currently unrestricted Grant: assert the whole assert set
-                }
-                bool bFailedToCompress = false;
-                // removes anything that is already in the refused set from the assert set
-                if (RefusedSet != null)
-                {
-                    retPs = PermissionSet.RemoveRefusedPermissionSet(retPs, RefusedSet, out bFailedToCompress);
-                }
-                if (!bFailedToCompress)
-                    bFailedToCompress = PermissionSet.IsIntersectingAssertedPermissions(retPs, AssertSet);
-                if (bFailedToCompress)
-                {
-                    retTriple = new PermissionSetTriple(this);
-                    this.Reset();
-                    this.GrantSet = retTriple.GrantSet.Copy();
-                }
-
-                if (AssertSet == null)
-                    AssertSet = retPs;
-                else
-                    AssertSet.InplaceUnion(retPs);
-
-            }
-            return retTriple;
-        }
-        internal void UpdateGrant(PermissionSet in_g, out ZoneIdentityPermission z,out UrlIdentityPermission u)
-        {
-            z = null;
-            u = null;
-            if (in_g != null)
-            {
-                if (GrantSet == null)
-                    GrantSet = in_g.Copy();
-                else
-                    GrantSet.InplaceIntersect(in_g);
-                
-                z = (ZoneIdentityPermission)in_g.GetPermission(ZoneToken);
-                u = (UrlIdentityPermission)in_g.GetPermission(UrlToken);
-            }
-        }
-
-        internal void UpdateGrant(PermissionSet in_g)
-        {
-            if (in_g != null)
-            {
-                if (GrantSet == null)
-                    GrantSet = in_g.Copy();
-                else
-                    GrantSet.InplaceIntersect(in_g);
-            }
-        }
-        internal void UpdateRefused(PermissionSet in_r)
-        {
-            if (in_r != null)
-            {
-                if (RefusedSet == null)
-                    RefusedSet = in_r.Copy();
-                else
-                    RefusedSet.InplaceUnion(in_r);
-            }
-        } 
-
-        
-        static bool CheckAssert(PermissionSet pSet, CodeAccessPermission demand, PermissionToken permToken)
-        {
-            if (pSet != null)
-            {
-                pSet.CheckDecoded(demand, permToken);
-
-                CodeAccessPermission perm = (CodeAccessPermission)pSet.GetPermission(demand);
-            
-                // If the assert set does contain the demanded permission, halt the stackwalk
-
-                try
-                {
-                    if (pSet.IsUnrestricted() || demand.CheckAssert(perm))
-                    {
-                        return SecurityRuntime.StackHalt;
-                    }
-                }
-                catch (ArgumentException)
-                {
-                }
-            }
-            return SecurityRuntime.StackContinue;
-        }
-
-        static bool CheckAssert(PermissionSet assertPset, PermissionSet demandSet, out PermissionSet newDemandSet)
-        {
-            newDemandSet = null;
-            if (assertPset!= null)
-            {
-                assertPset.CheckDecoded(demandSet);
-                // If this frame asserts a superset of the demand set we're done
-
-                if (demandSet.CheckAssertion(assertPset))
-                    return SecurityRuntime.StackHalt;
-                PermissionSet.RemoveAssertedPermissionSet(demandSet, assertPset, out newDemandSet);
-            }
-            return SecurityRuntime.StackContinue;
-        }
-
-        
-        internal bool CheckDemand(CodeAccessPermission demand, PermissionToken permToken, RuntimeMethodHandleInternal rmh)
-        {
-            if (CheckAssert(AssertSet, demand, permToken) == SecurityRuntime.StackHalt)
-                return SecurityRuntime.StackHalt;
-
-#pragma warning disable 618
-            CodeAccessSecurityEngine.CheckHelper(GrantSet, RefusedSet, demand, permToken, rmh, null, SecurityAction.Demand, true);
-#pragma warning restore 618
-
-            return SecurityRuntime.StackContinue;
-        }
-        internal bool CheckSetDemand(PermissionSet demandSet , out PermissionSet alteredDemandset, RuntimeMethodHandleInternal rmh)
-        {
-            alteredDemandset = null;
-            
-            if (CheckAssert(AssertSet, demandSet, out alteredDemandset) == SecurityRuntime.StackHalt)
-                return SecurityRuntime.StackHalt;
-            if (alteredDemandset != null)
-                demandSet = alteredDemandset; // note that this does not modify demandSet external to this function.
-#pragma warning disable 618
-            CodeAccessSecurityEngine.CheckSetHelper(GrantSet, RefusedSet, demandSet, rmh, null, SecurityAction.Demand, true);
-#pragma warning restore 618
-
-            return SecurityRuntime.StackContinue;
-
-        }
-        
-        internal bool CheckDemandNoThrow(CodeAccessPermission demand, PermissionToken permToken)
-        {
-            Debug.Assert(AssertSet == null, "AssertSet not null");
-#pragma warning disable 618
-            return CodeAccessSecurityEngine.CheckHelper(GrantSet, RefusedSet, demand, permToken, RuntimeMethodHandleInternal.EmptyHandle, null, SecurityAction.Demand, false);
-#pragma warning restore 618
-        }
-        internal bool CheckSetDemandNoThrow(PermissionSet demandSet)
-        {
-            Debug.Assert(AssertSet == null, "AssertSet not null");
-
-#pragma warning disable 618
-            return CodeAccessSecurityEngine.CheckSetHelper(GrantSet, RefusedSet, demandSet, RuntimeMethodHandleInternal.EmptyHandle, null, SecurityAction.Demand, false);
-#pragma warning restore 618
-        }        
-        /// <summary>
-        ///     Check to see if the triple satisfies a demand for the permission represented by the flag.
-        /// </summary>
-        /// <remarks>
-        ///     If the triple asserts for one of the bits in the flags, it is zeroed out.
-        /// </remarks>
-        /// <param name="flags">set of flags to check (See PermissionType)</param>
-        internal bool CheckFlags(ref int flags)
-        {
-            if (AssertSet != null)
-            {
-                // remove any permissions which were asserted for
-                int assertFlags = SecurityManager.GetSpecialFlags(AssertSet, null);
-                if ((flags & assertFlags) != 0)
-                    flags = flags & ~assertFlags;
-            }
-
-            return (SecurityManager.GetSpecialFlags(GrantSet, RefusedSet) & flags) == flags;
-        }        
-    }
-}
-
-
diff --git a/src/mscorlib/src/System/Security/PermissionToken.cs b/src/mscorlib/src/System/Security/PermissionToken.cs
deleted file mode 100644
index 5c6a322c1c..0000000000
--- a/src/mscorlib/src/System/Security/PermissionToken.cs
+++ /dev/null
@@ -1,383 +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.
-
-namespace System.Security
-{
-    using System;
-    using System.Security.Util;
-    using System.Security.Permissions;
-    using System.Reflection;
-    using System.Collections;
-    using System.Threading;
-    using System.Globalization;
-    using System.Runtime.CompilerServices;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-
-    [Flags]
-    internal enum PermissionTokenType
-    {
-        Normal = 0x1,
-        IUnrestricted = 0x2,
-        DontKnow = 0x4,
-        BuiltIn = 0x8
-    }
-
-    [Serializable]
-    internal sealed class PermissionTokenKeyComparer : IEqualityComparer
-    {
-        private Comparer _caseSensitiveComparer;
-        private TextInfo _info;
-
-        public PermissionTokenKeyComparer()
-        {
-            _caseSensitiveComparer = new Comparer(CultureInfo.InvariantCulture);
-            _info = CultureInfo.InvariantCulture.TextInfo;
-        }
-
-        public int Compare(Object a, Object b)
-        {
-            String strA = a as String;
-            String strB = b as String;
-
-            // if it's not a string then we just call the object comparer
-            if (strA == null || strB == null)
-                return _caseSensitiveComparer.Compare(a, b);
-
-            int i = _caseSensitiveComparer.Compare(a,b);
-            if (i == 0)
-                return 0;
-
-            if (SecurityManager.IsSameType(strA, strB))
-                return 0;
-            
-            return i;
-        }
-
-        public new bool Equals( Object a, Object b )
-        {
-            if (a == b) return true;
-            if (a == null || b == null) return false;
-            return Compare( a, b ) == 0;
-        }
-
-        // The data structure consuming this will be responsible for dealing with null objects as keys.
-        public int GetHashCode(Object obj)
-        {            
-            if (obj == null) throw new ArgumentNullException(nameof(obj));
-            Contract.EndContractBlock();
-            
-            String str = obj as String;
-
-            if (str == null)
-                return obj.GetHashCode();
-
-            int iComma = str.IndexOf( ',' );
-            if (iComma == -1)
-                iComma = str.Length;
-
-            int accumulator = 0;
-            for (int i = 0; i < iComma; ++i)
-            {
-                accumulator = (accumulator << 7) ^ str[i] ^ (accumulator >> 25);
-            }
-
-            return accumulator;
-        }
-    }
-
-    [Serializable]
-    internal sealed class PermissionToken : ISecurityEncodable
-    {
-        private static readonly PermissionTokenFactory s_theTokenFactory;
-        private const string c_mscorlibName = System.CoreLib.Name;
-        internal int    m_index;
-        internal volatile PermissionTokenType m_type;
-        static internal TokenBasedSet s_tokenSet = new TokenBasedSet();
-
-        internal static bool IsMscorlibClassName (string className) {
-            Debug.Assert( c_mscorlibName == ((RuntimeAssembly)Assembly.GetExecutingAssembly()).GetSimpleName(),
-                System.CoreLib.Name+" name mismatch" );
-
-            // If the class name does not look like a fully qualified name, we cannot simply determine if it's 
-            // an mscorlib.dll type so we should return true so the type can be matched with the
-            // right index in the TokenBasedSet.
-            int index = className.IndexOf(',');
-            if (index == -1)
-                return true;
-
-            index = className.LastIndexOf(']');
-            if (index == -1)
-                index = 0;
-
-            // Search for the string 'mscorlib' in the classname. If we find it, we will conservatively assume it's an mscorlib.dll type and load it.
-            for (int i = index; i < className.Length; i++) {
-                if (className[i] == 's' || className[i] == 'S')
-                {
-                    if (String.Compare(className, i, c_mscorlibName, 0, c_mscorlibName.Length, StringComparison.OrdinalIgnoreCase) == 0)
-                        return true;
-                }
-            }
-            return false;
-        }
-
-        static PermissionToken()
-        {
-            s_theTokenFactory = new PermissionTokenFactory( 4 );
-        }
-
-        internal PermissionToken()
-        {
-        }
-
-        internal PermissionToken(int index, PermissionTokenType type, String strTypeName)
-        {
-            m_index = index;
-            m_type = type;
-        }
-
-        public static PermissionToken GetToken(Type cls)
-        {
-            if (cls == null)
-                return null;
-
-            return s_theTokenFactory.GetToken(cls, null);
-        }
-
-        public static PermissionToken GetToken(IPermission perm)
-        {
-            if (perm == null)
-                return null;
-
-            IBuiltInPermission ibPerm = perm as IBuiltInPermission;
-
-            if (ibPerm != null)
-                return s_theTokenFactory.BuiltInGetToken( ibPerm.GetTokenIndex(), perm, null );
-            else
-                return s_theTokenFactory.GetToken(perm.GetType(), perm);
-        }
-
-        public static PermissionToken FindTokenByIndex( int i )
-        {
-            return s_theTokenFactory.FindTokenByIndex( i );
-        }
-
-        public static bool IsTokenProperlyAssigned( IPermission perm, PermissionToken token )
-        {
-            PermissionToken heldToken = GetToken( perm );
-            if (heldToken.m_index != token.m_index)
-                return false;
-
-            if (token.m_type != heldToken.m_type)
-                return false;
-
-            if (perm.GetType().Module.Assembly == Assembly.GetExecutingAssembly() &&
-                heldToken.m_index >= BuiltInPermissionIndex.NUM_BUILTIN_NORMAL + BuiltInPermissionIndex.NUM_BUILTIN_UNRESTRICTED)
-                return false;
-
-            return true;
-        }
-    }
-
-    // Package access only
-    internal class PermissionTokenFactory
-    {
-        private volatile int       m_size;
-        private volatile int       m_index;
-        private volatile Hashtable m_tokenTable;    // Cache of tokens by class string name
-        private volatile Hashtable m_handleTable;   // Cache of tokens by type handle (IntPtr)
-        private volatile Hashtable m_indexTable;    // Cache of tokens by index
-
-
-        // We keep an array of tokens for our built-in permissions.
-        // This is ordered in terms of unrestricted perms first, normals
-        // second.  Of course, all the ordering is based on the individual
-        // permissions sticking to the deal, so we do some simple boundary
-        // checking but mainly leave it to faith.
-
-        private volatile PermissionToken[] m_builtIn;
-
-        private const String s_unrestrictedPermissionInferfaceName = "System.Security.Permissions.IUnrestrictedPermission";
-
-        internal PermissionTokenFactory( int size )
-        {
-            m_builtIn = new PermissionToken[BuiltInPermissionIndex.NUM_BUILTIN_NORMAL + BuiltInPermissionIndex.NUM_BUILTIN_UNRESTRICTED];
-
-            m_size = size;
-            m_index = BuiltInPermissionIndex.NUM_BUILTIN_NORMAL + BuiltInPermissionIndex.NUM_BUILTIN_UNRESTRICTED;
-            m_tokenTable = null;
-            m_handleTable = new Hashtable(size);
-            m_indexTable = new Hashtable(size);
-        }
-
-        internal PermissionToken FindTokenByIndex( int i )
-        {
-            PermissionToken token;
-
-            if (i < BuiltInPermissionIndex.NUM_BUILTIN_NORMAL + BuiltInPermissionIndex.NUM_BUILTIN_UNRESTRICTED)
-            {
-                token = BuiltInGetToken( i, null, null );
-            }
-            else
-            {
-                token = (PermissionToken)m_indexTable[i];
-            }
-
-            return token;
-        }
-
-        internal PermissionToken GetToken(Type cls, IPermission perm)
-        {
-            Debug.Assert( cls != null, "Must pass in valid type" );
-
-            IntPtr typePtr = cls.TypeHandle.Value;
-            object tok = m_handleTable[typePtr];
-            if (tok == null)
-            {
-                String typeStr = cls.AssemblyQualifiedName;
-                tok = m_tokenTable != null ? m_tokenTable[typeStr] : null; // Assumes asynchronous lookups are safe
-
-                if (tok == null)
-                {
-                    lock (this)
-                    {
-                        if (m_tokenTable != null)
-                        {
-                            tok = m_tokenTable[typeStr]; // Make sure it wasn't just added
-                        }
-                        else
-                            m_tokenTable = new Hashtable(m_size, 1.0f, new PermissionTokenKeyComparer());
-
-                        if (tok == null)
-                        {
-                            if (perm != null)
-                            {
-                                tok = new PermissionToken( m_index++, PermissionTokenType.IUnrestricted, typeStr );
-                            }
-                            else
-                            {
-                                if (cls.GetInterface(s_unrestrictedPermissionInferfaceName) != null)
-                                    tok = new PermissionToken( m_index++, PermissionTokenType.IUnrestricted, typeStr );
-                                else
-                                    tok = new PermissionToken( m_index++, PermissionTokenType.Normal, typeStr );
-                            }
-                            m_tokenTable.Add(typeStr, tok);
-                            m_indexTable.Add(m_index - 1, tok);
-                            PermissionToken.s_tokenSet.SetItem( ((PermissionToken)tok).m_index, tok );
-                        }
-
-                        if (!m_handleTable.Contains(typePtr))
-                            m_handleTable.Add( typePtr, tok );
-                    }
-                }
-                else
-                {
-                    lock (this)
-                    {
-                        if (!m_handleTable.Contains(typePtr))
-                            m_handleTable.Add( typePtr, tok );
-                    }
-                }
-            }
-
-            if ((((PermissionToken)tok).m_type & PermissionTokenType.DontKnow) != 0)
-            {
-                if (perm != null)
-                {
-                    Debug.Assert( !(perm is IBuiltInPermission), "This should not be called for built-ins" );
-                    ((PermissionToken)tok).m_type = PermissionTokenType.IUnrestricted;
-                }
-                else
-                {
-                    Debug.Assert( cls.GetInterface( "System.Security.Permissions.IBuiltInPermission" ) == null, "This shoudl not be called for built-ins" );
-                    if (cls.GetInterface(s_unrestrictedPermissionInferfaceName) != null)
-                        ((PermissionToken)tok).m_type = PermissionTokenType.IUnrestricted;
-                    else
-                        ((PermissionToken)tok).m_type = PermissionTokenType.Normal;
-                }
-            }
-
-            return (PermissionToken)tok;
-        }
-
-        internal PermissionToken GetToken(String typeStr)
-        {
-            Object tok = null;
-            tok = m_tokenTable != null ? m_tokenTable[typeStr] : null; // Assumes asynchronous lookups are safe
-            if (tok == null)
-            {
-                lock (this)
-                {
-                    if (m_tokenTable != null)
-                    {
-                        tok = m_tokenTable[typeStr]; // Make sure it wasn't just added
-                    }
-                    else
-                        m_tokenTable = new Hashtable(m_size, 1.0f, new PermissionTokenKeyComparer());
-                        
-                    if (tok == null)
-                    {
-                        tok = new PermissionToken( m_index++, PermissionTokenType.DontKnow, typeStr );
-                        m_tokenTable.Add(typeStr, tok);
-                        m_indexTable.Add(m_index - 1, tok);
-                        PermissionToken.s_tokenSet.SetItem(((PermissionToken)tok).m_index, tok);
-                    }
-                }
-            }
-
-            return (PermissionToken)tok;
-        }
-
-        internal PermissionToken BuiltInGetToken( int index, IPermission perm, Type cls )
-        {
-            PermissionToken token = Volatile.Read(ref m_builtIn[index]);
-
-            if (token == null)
-            {
-                lock (this)
-                {
-                    token = m_builtIn[index];
-
-                    if (token == null)
-                    {
-                        PermissionTokenType permType = PermissionTokenType.DontKnow;
-
-                        if (perm != null)
-                        {
-                            permType = PermissionTokenType.IUnrestricted;
-                        }
-                        else if (cls != null)
-                        {
-                            permType = PermissionTokenType.IUnrestricted;
-                        }
-
-                        token = new PermissionToken( index, permType | PermissionTokenType.BuiltIn, null );
-                        Volatile.Write(ref m_builtIn[index], token);
-                        PermissionToken.s_tokenSet.SetItem( token.m_index, token );
-                    }
-                }
-            }
-
-            if ((token.m_type & PermissionTokenType.DontKnow) != 0)
-            {
-                    token.m_type = PermissionTokenType.BuiltIn;
-
-                    if (perm != null)
-                    {
-                        token.m_type |= PermissionTokenType.IUnrestricted;
-                    }
-                    else if (cls != null)
-                    {
-                        token.m_type |= PermissionTokenType.IUnrestricted;
-                    }
-                    else
-                    {
-                        token.m_type |= PermissionTokenType.DontKnow;
-                    }
-            }
-
-            return token;
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Permissions/EnvironmentPermission.cs b/src/mscorlib/src/System/Security/Permissions/EnvironmentPermission.cs
deleted file mode 100644
index 567fe513c0..0000000000
--- a/src/mscorlib/src/System/Security/Permissions/EnvironmentPermission.cs
+++ /dev/null
@@ -1,347 +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.
-
-namespace System.Security.Permissions {
-    using System.Security;
-    using System;
-    using SecurityElement = System.Security.SecurityElement;
-    using System.Security.Util;
-    using System.IO;
-    using System.Globalization;
-    using System.Diagnostics.Contracts;
-
-    [Serializable]
-    [Flags]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public enum EnvironmentPermissionAccess
-    {
-        NoAccess = 0x00,
-        Read = 0x01,
-        Write = 0x02,
-        AllAccess = 0x03,
-    }
-    
-    [Serializable]
-    internal class EnvironmentStringExpressionSet : StringExpressionSet
-    {
-        public EnvironmentStringExpressionSet()
-            : base( true, null, false )
-        {
-        }
-        
-        public EnvironmentStringExpressionSet( String str )
-            : base( true, str, false )
-        {
-        }
-        
-        protected override StringExpressionSet CreateNewEmpty()
-        {
-            return new EnvironmentStringExpressionSet();
-        }
-
-        protected override bool StringSubsetString( String left, String right, bool ignoreCase )
-        {
-            return (ignoreCase?(String.Compare( left, right, StringComparison.OrdinalIgnoreCase) == 0):
-                (String.Compare( left, right, StringComparison.Ordinal) == 0));
-        }
-
-        protected override String ProcessWholeString( String str )
-        {
-            return str;
-        }
-
-        protected override String ProcessSingleString( String str )
-        {
-            return str;
-        }
-
-        public override string ToString()
-        {
-            // SafeCritical: we're not storing path information in the strings, so exposing them out is fine ...
-            // they're just the same strings that came in to the .ctor.
-            return base.UnsafeToString();
-        }
-    }
-    
-[System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-    sealed public class EnvironmentPermission : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission
-    {
-        private StringExpressionSet m_read;
-        private StringExpressionSet m_write;
-        private bool m_unrestricted;
-    
-        public EnvironmentPermission(PermissionState state)
-        {
-            if (state == PermissionState.Unrestricted)
-                m_unrestricted = true;
-            else if (state == PermissionState.None)
-                m_unrestricted = false;
-            else
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
-        }
-
-        public EnvironmentPermission( EnvironmentPermissionAccess flag, String pathList )
-        {
-            SetPathList( flag, pathList );
-        }
-        
-        public void SetPathList( EnvironmentPermissionAccess flag, String pathList )
-        {
-            VerifyFlag( flag );
-            
-            m_unrestricted = false;
-
-            if ((flag & EnvironmentPermissionAccess.Read) != 0)
-                m_read = null;
-            
-            if ((flag & EnvironmentPermissionAccess.Write) != 0)
-                m_write = null;
-            
-            AddPathList( flag, pathList );
-        }
-        
-        public void AddPathList( EnvironmentPermissionAccess flag, String pathList )
-        {
-            VerifyFlag( flag );
-            
-            if (FlagIsSet( flag, EnvironmentPermissionAccess.Read ))
-            {
-                if (m_read == null)
-                    m_read = new EnvironmentStringExpressionSet();
-                m_read.AddExpressions( pathList );
-            }
-            
-            if (FlagIsSet( flag, EnvironmentPermissionAccess.Write ))
-            {
-                if (m_write == null)
-                    m_write = new EnvironmentStringExpressionSet();
-                m_write.AddExpressions( pathList );
-            }
-    
-        }
-    
-        public String GetPathList( EnvironmentPermissionAccess flag )
-        {
-            VerifyFlag( flag );
-            ExclusiveFlag( flag );
-    
-            if (FlagIsSet( flag, EnvironmentPermissionAccess.Read ))
-            {
-                if (m_read == null)
-                {
-                    return "";
-                }
-                return m_read.ToString();
-            }
-            
-            if (FlagIsSet( flag, EnvironmentPermissionAccess.Write ))
-            {
-                if (m_write == null)
-                {
-                    return "";
-                }
-                return m_write.ToString();
-            }
-    
-            /* not reached */
-            
-            return "";
-        }     
-        
-            
-        private void VerifyFlag( EnvironmentPermissionAccess flag )
-        {
-            if ((flag & ~EnvironmentPermissionAccess.AllAccess) != 0)
-                throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)flag));
-            Contract.EndContractBlock();
-        }
-    
-        private void ExclusiveFlag( EnvironmentPermissionAccess flag )
-        {
-            if (flag == EnvironmentPermissionAccess.NoAccess)
-            {
-                throw new ArgumentException( Environment.GetResourceString("Arg_EnumNotSingleFlag") ); 
-            }
-    
-            if (((int)flag & ((int)flag-1)) != 0)
-            {
-                throw new ArgumentException( Environment.GetResourceString("Arg_EnumNotSingleFlag") );
-            }
-            Contract.EndContractBlock();
-        }
-        
-        
-        private bool FlagIsSet( EnvironmentPermissionAccess flag, EnvironmentPermissionAccess question )
-        {
-            return (flag & question) != 0;
-        }
-        
-        private bool IsEmpty()
-        {
-            return (!m_unrestricted &&
-                    (this.m_read == null || this.m_read.IsEmpty()) &&
-                    (this.m_write == null || this.m_write.IsEmpty()));
-        }
-        
-        //------------------------------------------------------
-        //
-        // CODEACCESSPERMISSION IMPLEMENTATION
-        //
-        //------------------------------------------------------
-        
-        public bool IsUnrestricted()
-        {
-            return m_unrestricted;
-        }
-        
-        //------------------------------------------------------
-        //
-        // IPERMISSION IMPLEMENTATION
-        //
-        //------------------------------------------------------
-        
-        public override bool IsSubsetOf(IPermission target)
-        {
-            if (target == null)
-            {
-                return this.IsEmpty();
-            }
-
-            try
-            {
-                EnvironmentPermission operand = (EnvironmentPermission)target;
-                if (operand.IsUnrestricted())
-                    return true;
-                else if (this.IsUnrestricted())
-                    return false;
-                else
-                    return ((this.m_read == null || this.m_read.IsSubsetOf( operand.m_read )) &&
-                            (this.m_write == null || this.m_write.IsSubsetOf( operand.m_write )));
-            }
-            catch (InvalidCastException)
-            {
-                throw new 
-                    ArgumentException(
-                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
-                                     );
-            }
-        }
-        
-        public override IPermission Intersect(IPermission target)
-        {
-            if (target == null)
-            {
-                return null;
-            }
-            else if (!VerifyType(target))
-            {
-                throw new 
-                    ArgumentException(
-                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
-                                     );
-            }
-            else if (this.IsUnrestricted())
-            {
-                return target.Copy();
-            }
-    
-            EnvironmentPermission operand = (EnvironmentPermission)target;
-    
-            if (operand.IsUnrestricted())
-            {
-                return this.Copy();
-            }
-            
-            StringExpressionSet intersectRead = this.m_read == null ? null : this.m_read.Intersect( operand.m_read );
-            StringExpressionSet intersectWrite = this.m_write == null ? null : this.m_write.Intersect( operand.m_write );
-            
-            if ((intersectRead == null || intersectRead.IsEmpty()) &&
-                (intersectWrite == null || intersectWrite.IsEmpty()))
-            {
-                return null;
-            }
-            
-            EnvironmentPermission intersectPermission = new EnvironmentPermission(PermissionState.None);
-            intersectPermission.m_unrestricted = false;
-            intersectPermission.m_read = intersectRead;
-            intersectPermission.m_write = intersectWrite;
-            
-            return intersectPermission;
-        }
-        
-        public override IPermission Union(IPermission other)
-        {
-            if (other == null)
-            {
-                return this.Copy();
-            }
-            else if (!VerifyType(other))
-            {
-                throw new 
-                    ArgumentException(
-                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
-                                     );
-            }
-    
-            EnvironmentPermission operand = (EnvironmentPermission)other;
-           
-            if (this.IsUnrestricted() || operand.IsUnrestricted())
-            {
-                return new EnvironmentPermission( PermissionState.Unrestricted );
-            }
-    
-            StringExpressionSet unionRead = this.m_read == null ? operand.m_read : this.m_read.Union( operand.m_read );
-            StringExpressionSet unionWrite = this.m_write == null ? operand.m_write : this.m_write.Union( operand.m_write );
-            
-            if ((unionRead == null || unionRead.IsEmpty()) &&
-                (unionWrite == null || unionWrite.IsEmpty()))
-            {
-                return null;
-            }
-            
-            EnvironmentPermission unionPermission = new EnvironmentPermission(PermissionState.None);
-            unionPermission.m_unrestricted = false;
-            unionPermission.m_read = unionRead;
-            unionPermission.m_write = unionWrite;
-            
-            return unionPermission;
-        }    
-        
-        public override IPermission Copy()
-        {
-            EnvironmentPermission copy = new EnvironmentPermission(PermissionState.None);
-            if (this.m_unrestricted)
-            {
-                copy.m_unrestricted = true;
-            }
-            else
-            {
-                copy.m_unrestricted = false;
-                if (this.m_read != null)
-                {
-                    copy.m_read = this.m_read.Copy();
-                }
-                if (this.m_write != null)
-                {
-                    copy.m_write = this.m_write.Copy();
-                }
-    
-            }
-            return copy;
-        }
-
-        /// <internalonly/>
-        int IBuiltInPermission.GetTokenIndex()
-        {
-            return EnvironmentPermission.GetTokenIndex();
-        }
-
-        internal static int GetTokenIndex()
-        {
-            return BuiltInPermissionIndex.EnvironmentPermissionIndex;
-        }
-    }
-
-}
diff --git a/src/mscorlib/src/System/Security/Permissions/FileDialogPermission.cs b/src/mscorlib/src/System/Security/Permissions/FileDialogPermission.cs
deleted file mode 100644
index 98a7d54c68..0000000000
--- a/src/mscorlib/src/System/Security/Permissions/FileDialogPermission.cs
+++ /dev/null
@@ -1,158 +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.
-
-namespace System.Security.Permissions {
-    using System;
-    using System.Text;
-    using System.Security;
-    using System.Security.Util;
-    using System.IO;
-    using System.Runtime.Serialization;
-    using System.Reflection;
-    using System.Collections;
-    using System.Globalization;
-    using System.Diagnostics.Contracts;
-
-[Serializable]
-[Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public enum FileDialogPermissionAccess {
-        None = 0x00,
-    
-        Open = 0x01,
-    
-        Save = 0x02,
-        
-        OpenSave = Open | Save
-    
-    }
-
-    [Serializable] 
-[System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class FileDialogPermission : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission {
-        FileDialogPermissionAccess access;
-
-        public FileDialogPermission(PermissionState state) {
-            if (state == PermissionState.Unrestricted) {
-                SetUnrestricted(true);
-            }
-            else if (state == PermissionState.None) {
-                SetUnrestricted(false);
-                Reset();
-            }
-            else {
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
-            }
-        }    
-
-        public FileDialogPermission(FileDialogPermissionAccess access) {
-            VerifyAccess(access);
-            this.access = access;
-        }
-
-        public FileDialogPermissionAccess Access {
-            get {
-                return access;
-            }
-
-            set {
-                VerifyAccess(value);
-                access = value;
-            }
-        }
-
-        public override IPermission Copy() {
-            return new FileDialogPermission(this.access);
-        }
-
-        /// <internalonly/>
-        int IBuiltInPermission.GetTokenIndex() {
-            return FileDialogPermission.GetTokenIndex();
-        }
-
-        internal static int GetTokenIndex() {
-            return BuiltInPermissionIndex.FileDialogPermissionIndex;
-        }
-
-        public override IPermission Intersect(IPermission target) {
-            if (target == null) {
-                return null;
-            }
-            else if (!VerifyType(target)) {
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-            }
-
-            FileDialogPermission operand = (FileDialogPermission)target;
-
-            FileDialogPermissionAccess intersectAccess = access & operand.Access;
-
-            if (intersectAccess == FileDialogPermissionAccess.None)
-                return null;
-            else
-                return new FileDialogPermission(intersectAccess);
-        }
-
-        public override bool IsSubsetOf(IPermission target) {
-            if (target == null) {
-                // Only safe subset if this is empty
-                return access == FileDialogPermissionAccess.None;
-            }
-
-            try {
-                FileDialogPermission operand = (FileDialogPermission)target;
-                if (operand.IsUnrestricted()) {
-                    return true;
-                }
-                else if (this.IsUnrestricted()) {
-                    return false;
-                }
-                else {
-                    int open = (int)(access & FileDialogPermissionAccess.Open);
-                    int save = (int)(access & FileDialogPermissionAccess.Save);
-                    int openTarget = (int)(operand.Access & FileDialogPermissionAccess.Open);
-                    int saveTarget = (int)(operand.Access & FileDialogPermissionAccess.Save);
-
-                    return open <= openTarget && save <= saveTarget;
-                }
-            }
-            catch (InvalidCastException) {
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-            }
-
-        }
-
-        public bool IsUnrestricted() {
-            return access == FileDialogPermissionAccess.OpenSave;
-        }
-
-        void Reset() {
-            access = FileDialogPermissionAccess.None;
-        }
-
-        void SetUnrestricted( bool unrestricted ) {
-            if (unrestricted) {
-                access = FileDialogPermissionAccess.OpenSave;
-            }
-        }
-
-        public override IPermission Union(IPermission target) {
-            if (target == null) {
-                return this.Copy();
-            }
-            else if (!VerifyType(target)) {
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-            }
-
-            FileDialogPermission operand = (FileDialogPermission)target;
-            return new FileDialogPermission(access | operand.Access);
-        }
-
-        static void VerifyAccess(FileDialogPermissionAccess access) {
-            if ((access & ~FileDialogPermissionAccess.OpenSave) != 0 ) {
-                throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)access));
-            }
-            Contract.EndContractBlock();
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Permissions/FileIOPermission.cs b/src/mscorlib/src/System/Security/Permissions/FileIOPermission.cs
deleted file mode 100644
index 341c26ac22..0000000000
--- a/src/mscorlib/src/System/Security/Permissions/FileIOPermission.cs
+++ /dev/null
@@ -1,1212 +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.
-
-namespace System.Security.Permissions
-{
-    using System;
-    using System.Runtime.CompilerServices;
-    using System.Runtime.InteropServices;
-    using System.Security.AccessControl;
-    using System.Security.Util;
-    using System.IO;
-    using System.Collections;
-    using System.Globalization;
-    using System.Runtime.Serialization;
-    using System.Runtime.Versioning;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-
-    [Serializable]
-    [Flags]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public enum FileIOPermissionAccess
-    {
-        NoAccess = 0x00,
-        Read = 0x01,
-        Write = 0x02,
-        Append = 0x04,
-        PathDiscovery = 0x08,
-        AllAccess = 0x0F,
-    }
-
-    [System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-    sealed public class FileIOPermission : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission
-    {
-        private FileIOAccess m_read;
-        private FileIOAccess m_write;
-        private FileIOAccess m_append;
-        private FileIOAccess m_pathDiscovery;
-        [OptionalField(VersionAdded = 2)]
-        private FileIOAccess m_viewAcl;
-        [OptionalField(VersionAdded = 2)]
-        private FileIOAccess m_changeAcl;
-        private bool m_unrestricted;
-        
-        public FileIOPermission(PermissionState state)
-        {
-            if (state == PermissionState.Unrestricted)
-            {
-                m_unrestricted = true;
-            }
-            else if (state == PermissionState.None)
-            {
-                m_unrestricted = false;
-            }
-            else
-            {
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
-            }
-        }
-        
-        public FileIOPermission( FileIOPermissionAccess access, String path )
-        {
-            VerifyAccess( access );
-        
-            String[] pathList = new String[] { path };
-            AddPathList( access, pathList, false, true, false );
-        }
-        
-        public FileIOPermission( FileIOPermissionAccess access, String[] pathList )
-        {
-            VerifyAccess( access );
-        
-            AddPathList( access, pathList, false, true, false );
-        }
-
-        internal FileIOPermission( FileIOPermissionAccess access, String[] pathList, bool checkForDuplicates, bool needFullPath )
-        {
-            VerifyAccess( access );
-        
-            AddPathList( access, pathList, checkForDuplicates, needFullPath, true );
-        }
-
-        public void SetPathList( FileIOPermissionAccess access, String path )
-        {
-            String[] pathList;
-            if(path == null)
-                pathList = new String[] {};
-            else
-                pathList = new String[] { path };
-            SetPathList( access, pathList, false );
-        }
-            
-        public void SetPathList( FileIOPermissionAccess access, String[] pathList )
-        {
-            SetPathList( access, pathList, true );
-        }
-
-        internal void SetPathList( FileIOPermissionAccess access, 
-            String[] pathList, bool checkForDuplicates )
-        {
-            SetPathList( access, AccessControlActions.None, pathList, checkForDuplicates );
-        }
-
-        internal void SetPathList( FileIOPermissionAccess access, AccessControlActions control, String[] pathList, bool checkForDuplicates )
-        {
-            VerifyAccess( access );
-            
-            if ((access & FileIOPermissionAccess.Read) != 0)
-                m_read = null;
-            
-            if ((access & FileIOPermissionAccess.Write) != 0)
-                m_write = null;
-    
-            if ((access & FileIOPermissionAccess.Append) != 0)
-                m_append = null;
-
-            if ((access & FileIOPermissionAccess.PathDiscovery) != 0)
-                m_pathDiscovery = null;
-
-            m_viewAcl = null;
-            m_changeAcl = null;
-            m_unrestricted = false;
-
-            AddPathList( access, pathList, checkForDuplicates, true, true );
-        }
-
-        public void AddPathList( FileIOPermissionAccess access, String path )
-        {
-            String[] pathList;
-            if(path == null)
-                pathList = new String[] {};
-            else
-                pathList = new String[] { path };
-            AddPathList( access, pathList, false, true, false );
-        }
-
-        public void AddPathList( FileIOPermissionAccess access, String[] pathList )
-        {
-            AddPathList( access, pathList, true, true, true );
-        }
-
-        internal void AddPathList( FileIOPermissionAccess access, String[] pathListOrig, bool checkForDuplicates, bool needFullPath, bool copyPathList )
-        {
-            AddPathList( access, AccessControlActions.None, pathListOrig, checkForDuplicates, needFullPath, copyPathList );
-        }
-
-        internal void AddPathList(FileIOPermissionAccess access, AccessControlActions control, String[] pathListOrig, bool checkForDuplicates, bool needFullPath, bool copyPathList)
-        {
-            if (pathListOrig == null)
-            {
-                throw new ArgumentNullException( "pathList" );    
-            }
-            if (pathListOrig.Length == 0)
-            {
-                throw new ArgumentException( Environment.GetResourceString("Argument_EmptyPath" ));    
-            }
-            Contract.EndContractBlock();
-
-            VerifyAccess(access);
-                
-            if (m_unrestricted)
-                return;
-
-            String[] pathList = pathListOrig;
-            if(copyPathList)
-            {
-                // Make a copy of pathList (in case its value changes after we check for illegal chars)
-                pathList = new String[pathListOrig.Length];
-                Array.Copy(pathListOrig, pathList, pathListOrig.Length);
-            }
-
-            ArrayList pathArrayList = StringExpressionSet.CreateListFromExpressions(pathList, needFullPath);
-
-            // If we need the full path the standard illegal characters will be checked in StringExpressionSet.
-            CheckIllegalCharacters(pathList, onlyCheckExtras: needFullPath);
-
-            // StringExpressionSet will do minor normalization, trimming spaces and replacing alternate
-            // directory separators. It will make an attemt to expand short file names and will check
-            // for standard colon placement.
-            //
-            // If needFullPath is true it will call NormalizePath- which performs short name expansion
-            // and does the normal validity checks.
-
-            if ((access & FileIOPermissionAccess.Read) != 0)
-            {
-                if (m_read == null)
-                {
-                    m_read = new FileIOAccess();
-                }
-                m_read.AddExpressions( pathArrayList, checkForDuplicates);
-            }
-            
-            if ((access & FileIOPermissionAccess.Write) != 0)
-            {
-                if (m_write == null)
-                {
-                    m_write = new FileIOAccess();
-                }
-                m_write.AddExpressions( pathArrayList, checkForDuplicates);
-            }
-    
-            if ((access & FileIOPermissionAccess.Append) != 0)
-            {
-                if (m_append == null)
-                {
-                    m_append = new FileIOAccess();
-                }
-                m_append.AddExpressions( pathArrayList, checkForDuplicates);
-            }
-
-            if ((access & FileIOPermissionAccess.PathDiscovery) != 0)
-            {
-                if (m_pathDiscovery == null)
-                {
-                    m_pathDiscovery = new FileIOAccess( true );
-                }
-                m_pathDiscovery.AddExpressions( pathArrayList, checkForDuplicates);
-            }
-        }
-
-        public String[] GetPathList( FileIOPermissionAccess access )
-        {
-            VerifyAccess( access );
-            ExclusiveAccess( access );
-    
-            if (AccessIsSet( access, FileIOPermissionAccess.Read ))
-            {
-                if (m_read == null)
-                {
-                    return null;
-                }
-                return m_read.ToStringArray();
-            }
-            
-            if (AccessIsSet( access, FileIOPermissionAccess.Write ))
-            {
-                if (m_write == null)
-                {
-                    return null;
-                }
-                return m_write.ToStringArray();
-            }
-    
-            if (AccessIsSet( access, FileIOPermissionAccess.Append ))
-            {
-                if (m_append == null)
-                {
-                    return null;
-                }
-                return m_append.ToStringArray();
-            }
-            
-            if (AccessIsSet( access, FileIOPermissionAccess.PathDiscovery ))
-            {
-                if (m_pathDiscovery == null)
-                {
-                    return null;
-                }
-                return m_pathDiscovery.ToStringArray();
-            }
-
-            // not reached
-            
-            return null;
-        }
-
-        public FileIOPermissionAccess AllLocalFiles
-        {
-            get
-            {
-                if (m_unrestricted)
-                    return FileIOPermissionAccess.AllAccess;
-            
-                FileIOPermissionAccess access = FileIOPermissionAccess.NoAccess;
-                
-                if (m_read != null && m_read.AllLocalFiles)
-                {
-                    access |= FileIOPermissionAccess.Read;
-                }
-                
-                if (m_write != null && m_write.AllLocalFiles)
-                {
-                    access |= FileIOPermissionAccess.Write;
-                }
-                
-                if (m_append != null && m_append.AllLocalFiles)
-                {
-                    access |= FileIOPermissionAccess.Append;
-                }
-
-                if (m_pathDiscovery != null && m_pathDiscovery.AllLocalFiles)
-                {
-                    access |= FileIOPermissionAccess.PathDiscovery;
-                }
-                
-                return access;
-            }
-            
-            set
-            {
-                if ((value & FileIOPermissionAccess.Read) != 0)
-                {
-                    if (m_read == null)
-                        m_read = new FileIOAccess();
-                        
-                    m_read.AllLocalFiles = true;
-                }
-                else
-                {
-                    if (m_read != null)
-                        m_read.AllLocalFiles = false;
-                }
-                
-                if ((value & FileIOPermissionAccess.Write) != 0)
-                {
-                    if (m_write == null)
-                        m_write = new FileIOAccess();
-                        
-                    m_write.AllLocalFiles = true;
-                }
-                else
-                {
-                    if (m_write != null)
-                        m_write.AllLocalFiles = false;
-                }
-                
-                if ((value & FileIOPermissionAccess.Append) != 0)
-                {
-                    if (m_append == null)
-                        m_append = new FileIOAccess();
-                        
-                    m_append.AllLocalFiles = true;
-                }
-                else
-                {
-                    if (m_append != null)
-                        m_append.AllLocalFiles = false;
-                }
-
-                if ((value & FileIOPermissionAccess.PathDiscovery) != 0)
-                {
-                    if (m_pathDiscovery == null)
-                        m_pathDiscovery = new FileIOAccess( true );
-                        
-                    m_pathDiscovery.AllLocalFiles = true;
-                }
-                else
-                {
-                    if (m_pathDiscovery != null)
-                        m_pathDiscovery.AllLocalFiles = false;
-                }
-
-            }
-        }
-        
-        public FileIOPermissionAccess AllFiles
-        {
-            get
-            {
-                if (m_unrestricted)
-                    return FileIOPermissionAccess.AllAccess;
-            
-                FileIOPermissionAccess access = FileIOPermissionAccess.NoAccess;
-                
-                if (m_read != null && m_read.AllFiles)
-                {
-                    access |= FileIOPermissionAccess.Read;
-                }
-                
-                if (m_write != null && m_write.AllFiles)
-                {
-                    access |= FileIOPermissionAccess.Write;
-                }
-                
-                if (m_append != null && m_append.AllFiles)
-                {
-                    access |= FileIOPermissionAccess.Append;
-                }
-                
-                if (m_pathDiscovery != null && m_pathDiscovery.AllFiles)
-                {
-                    access |= FileIOPermissionAccess.PathDiscovery;
-                }
-
-                return access;
-            }
-            
-            set
-            {
-                if (value == FileIOPermissionAccess.AllAccess)
-                {
-                    m_unrestricted = true;
-                    return;
-                }
-            
-                if ((value & FileIOPermissionAccess.Read) != 0)
-                {
-                    if (m_read == null)
-                        m_read = new FileIOAccess();
-                        
-                    m_read.AllFiles = true;
-                }
-                else
-                {
-                    if (m_read != null)
-                        m_read.AllFiles = false;
-                }
-                
-                if ((value & FileIOPermissionAccess.Write) != 0)
-                {
-                    if (m_write == null)
-                        m_write = new FileIOAccess();
-                        
-                    m_write.AllFiles = true;
-                }
-                else
-                {
-                    if (m_write != null)
-                        m_write.AllFiles = false;
-                }
-                
-                if ((value & FileIOPermissionAccess.Append) != 0)
-                {
-                    if (m_append == null)
-                        m_append = new FileIOAccess();
-                        
-                    m_append.AllFiles = true;
-                }
-                else
-                {
-                    if (m_append != null)
-                        m_append.AllFiles = false;
-                }
-
-                if ((value & FileIOPermissionAccess.PathDiscovery) != 0)
-                {
-                    if (m_pathDiscovery == null)
-                        m_pathDiscovery = new FileIOAccess( true );
-                        
-                    m_pathDiscovery.AllFiles = true;
-                }
-                else
-                {
-                    if (m_pathDiscovery != null)
-                        m_pathDiscovery.AllFiles = false;
-                }
-
-            }
-        }        
-        
-        [Pure]
-        private static void VerifyAccess( FileIOPermissionAccess access )
-        {
-            if ((access & ~FileIOPermissionAccess.AllAccess) != 0)
-                throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)access));
-        }
-        
-        [Pure]
-        private static void ExclusiveAccess( FileIOPermissionAccess access )
-        {
-            if (access == FileIOPermissionAccess.NoAccess)
-            {
-                throw new ArgumentException( Environment.GetResourceString("Arg_EnumNotSingleFlag") ); 
-            }
-    
-            if (((int) access & ((int)access-1)) != 0)
-            {
-                throw new ArgumentException( Environment.GetResourceString("Arg_EnumNotSingleFlag") ); 
-            }
-        }
-
-        private static void CheckIllegalCharacters(String[] str, bool onlyCheckExtras)
-        {
-#if !PLATFORM_UNIX
-            for (int i = 0; i < str.Length; ++i)
-            {
-                // FileIOPermission doesn't allow for normalizing across various volume names. This means "C:\" and
-                // "\\?\C:\" won't be considered correctly. In addition there are many other aliases for the volume
-                // besides "C:" such as (in one concrete example) "\\?\Harddisk0Partition2\", "\\?\HarddiskVolume6\",
-                // "\\?\Volume{d1655348-0000-0000-0000-f01500000000}\", etc.
-                //
-                // We'll continue to explicitly block extended syntax here by disallowing wildcards no matter where
-                // they occur in the string (e.g. \\?\ isn't ok)
-                if (CheckExtraPathCharacters(str[i]))
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPathChars"));
-
-                if (!onlyCheckExtras)
-                    PathInternal.CheckInvalidPathChars(str[i]);
-            }
-#else
-            // There are no "extras" on Unix
-            if (onlyCheckExtras)
-                return;
-
-            for (int i = 0; i < str.Length; ++i)
-            {
-                PathInternal.CheckInvalidPathChars(str[i]);
-            }
-#endif
-        }
-
-#if !PLATFORM_UNIX
-        /// <summary>
-        /// Check for ?,* and null, ignoring extended syntax.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private unsafe static bool CheckExtraPathCharacters(string path)
-        {
-            char currentChar;
-            for (int i = 0; i < path.Length; i++)
-            {
-                currentChar = path[i];
-
-                // We also check for null here as StringExpressionSet will trim it out. (Ensuring we still throw as we always have.)
-                if (currentChar == '*' || currentChar == '?' || currentChar == '\0') return true;
-            }
-            return false;
-        }
-#endif
-
-        private static bool AccessIsSet( FileIOPermissionAccess access, FileIOPermissionAccess question )
-        {
-            return (access & question) != 0;
-        }
-        
-        private bool IsEmpty()
-        {
-            return (!m_unrestricted &&
-                    (this.m_read == null || this.m_read.IsEmpty()) &&
-                    (this.m_write == null || this.m_write.IsEmpty()) &&
-                    (this.m_append == null || this.m_append.IsEmpty()) &&
-                    (this.m_pathDiscovery == null || this.m_pathDiscovery.IsEmpty()) &&
-                    (this.m_viewAcl == null || this.m_viewAcl.IsEmpty()) &&
-                    (this.m_changeAcl == null || this.m_changeAcl.IsEmpty()));
-        }
-        
-        //------------------------------------------------------
-        //
-        // CODEACCESSPERMISSION IMPLEMENTATION
-        //
-        //------------------------------------------------------
-        
-        public bool IsUnrestricted()
-        {
-            return m_unrestricted;
-        }
-        
-        //------------------------------------------------------
-        //
-        // IPERMISSION IMPLEMENTATION
-        //
-        //------------------------------------------------------
-        
-        public override bool IsSubsetOf(IPermission target)
-        {
-            if (target == null)
-            {
-                return this.IsEmpty();
-            }
-
-            FileIOPermission operand = target as FileIOPermission;
-            if (operand == null)
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-
-            if (operand.IsUnrestricted())
-                return true;
-            else if (this.IsUnrestricted())
-                return false;
-            else
-                return ((this.m_read == null || this.m_read.IsSubsetOf( operand.m_read )) &&
-                        (this.m_write == null || this.m_write.IsSubsetOf( operand.m_write )) &&
-                        (this.m_append == null || this.m_append.IsSubsetOf( operand.m_append )) &&
-                        (this.m_pathDiscovery == null || this.m_pathDiscovery.IsSubsetOf( operand.m_pathDiscovery )) &&
-                        (this.m_viewAcl == null || this.m_viewAcl.IsSubsetOf( operand.m_viewAcl )) &&
-                        (this.m_changeAcl == null || this.m_changeAcl.IsSubsetOf( operand.m_changeAcl )));
-        }
-      
-        public override IPermission Intersect(IPermission target)
-        {
-            if (target == null)
-            {
-                return null;
-            }
-
-            FileIOPermission operand = target as FileIOPermission;
-
-            if (operand == null)
-            {
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-            }
-            else if (this.IsUnrestricted())
-            {
-                return target.Copy();
-            }
-    
-            if (operand.IsUnrestricted())
-            {
-                return this.Copy();
-            }
-            
-            FileIOAccess intersectRead = this.m_read == null ? null : this.m_read.Intersect( operand.m_read );
-            FileIOAccess intersectWrite = this.m_write == null ? null : this.m_write.Intersect( operand.m_write );
-            FileIOAccess intersectAppend = this.m_append == null ? null : this.m_append.Intersect( operand.m_append );
-            FileIOAccess intersectPathDiscovery = this.m_pathDiscovery == null ? null : this.m_pathDiscovery.Intersect( operand.m_pathDiscovery );
-            FileIOAccess intersectViewAcl = this.m_viewAcl == null ? null : this.m_viewAcl.Intersect( operand.m_viewAcl );
-            FileIOAccess intersectChangeAcl = this.m_changeAcl == null ? null : this.m_changeAcl.Intersect( operand.m_changeAcl );
-
-            if ((intersectRead == null || intersectRead.IsEmpty()) &&
-                (intersectWrite == null || intersectWrite.IsEmpty()) &&
-                (intersectAppend == null || intersectAppend.IsEmpty()) &&
-                (intersectPathDiscovery == null || intersectPathDiscovery.IsEmpty()) &&
-                (intersectViewAcl == null || intersectViewAcl.IsEmpty()) &&
-                (intersectChangeAcl == null || intersectChangeAcl.IsEmpty()))
-            {
-                return null;
-            }
-            
-            FileIOPermission intersectPermission = new FileIOPermission(PermissionState.None);
-            intersectPermission.m_unrestricted = false;
-            intersectPermission.m_read = intersectRead;
-            intersectPermission.m_write = intersectWrite;
-            intersectPermission.m_append = intersectAppend;
-            intersectPermission.m_pathDiscovery = intersectPathDiscovery;
-            intersectPermission.m_viewAcl = intersectViewAcl;
-            intersectPermission.m_changeAcl = intersectChangeAcl;
-            
-            return intersectPermission;
-        }
-        
-        public override IPermission Union(IPermission other)
-        {
-            if (other == null)
-            {
-                return this.Copy();
-            }
-
-            FileIOPermission operand = other as FileIOPermission;
-
-            if (operand == null)
-            {
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-            }
-    
-            if (this.IsUnrestricted() || operand.IsUnrestricted())
-            {
-                return new FileIOPermission( PermissionState.Unrestricted );
-            }
-    
-            FileIOAccess unionRead = this.m_read == null ? operand.m_read : this.m_read.Union( operand.m_read );
-            FileIOAccess unionWrite = this.m_write == null ? operand.m_write : this.m_write.Union( operand.m_write );
-            FileIOAccess unionAppend = this.m_append == null ? operand.m_append : this.m_append.Union( operand.m_append );
-            FileIOAccess unionPathDiscovery = this.m_pathDiscovery == null ? operand.m_pathDiscovery : this.m_pathDiscovery.Union( operand.m_pathDiscovery );
-            FileIOAccess unionViewAcl = this.m_viewAcl == null ? operand.m_viewAcl : this.m_viewAcl.Union( operand.m_viewAcl );
-            FileIOAccess unionChangeAcl = this.m_changeAcl == null ? operand.m_changeAcl : this.m_changeAcl.Union( operand.m_changeAcl );
-            
-            if ((unionRead == null || unionRead.IsEmpty()) &&
-                (unionWrite == null || unionWrite.IsEmpty()) &&
-                (unionAppend == null || unionAppend.IsEmpty()) &&
-                (unionPathDiscovery == null || unionPathDiscovery.IsEmpty()) &&
-                (unionViewAcl == null || unionViewAcl.IsEmpty()) &&
-                (unionChangeAcl == null || unionChangeAcl.IsEmpty()))
-            {
-                return null;
-            }
-            
-            FileIOPermission unionPermission = new FileIOPermission(PermissionState.None);
-            unionPermission.m_unrestricted = false;
-            unionPermission.m_read = unionRead;
-            unionPermission.m_write = unionWrite;
-            unionPermission.m_append = unionAppend;
-            unionPermission.m_pathDiscovery = unionPathDiscovery;
-            unionPermission.m_viewAcl = unionViewAcl;
-            unionPermission.m_changeAcl = unionChangeAcl;
-
-            return unionPermission;    
-        }
-        
-        public override IPermission Copy()
-        {
-            FileIOPermission copy = new FileIOPermission(PermissionState.None);
-            if (this.m_unrestricted)
-            {
-                copy.m_unrestricted = true;
-            }
-            else
-            {
-                copy.m_unrestricted = false;
-                if (this.m_read != null)
-                {
-                    copy.m_read = this.m_read.Copy();
-                }
-                if (this.m_write != null)
-                {
-                    copy.m_write = this.m_write.Copy();
-                }
-                if (this.m_append != null)
-                {
-                    copy.m_append = this.m_append.Copy();
-                }
-                if (this.m_pathDiscovery != null)
-                {
-                    copy.m_pathDiscovery = this.m_pathDiscovery.Copy();
-                }
-                if (this.m_viewAcl != null)
-                {
-                    copy.m_viewAcl = this.m_viewAcl.Copy();
-                }
-                if (this.m_changeAcl != null)
-                {
-                    copy.m_changeAcl = this.m_changeAcl.Copy();
-                }
-            }
-            return copy;   
-        }
-
-        /// <internalonly/>
-        int IBuiltInPermission.GetTokenIndex()
-        {
-            return FileIOPermission.GetTokenIndex();
-        }
-
-        internal static int GetTokenIndex()
-        {
-            return BuiltInPermissionIndex.FileIOPermissionIndex;
-        }
-
-        [System.Runtime.InteropServices.ComVisible(false)]
-        public override bool Equals(Object obj)
-        {
-            FileIOPermission perm = obj as FileIOPermission;
-            if(perm == null)
-                return false;
-
-            if(m_unrestricted && perm.m_unrestricted)
-                return true;
-            if(m_unrestricted != perm.m_unrestricted)
-                return false;
-
-            if(m_read == null)
-            {
-                if(perm.m_read != null && !perm.m_read.IsEmpty())
-                    return false;
-            }
-            else if(!m_read.Equals(perm.m_read))
-                return false;
-
-            if(m_write == null)
-            {
-                if(perm.m_write != null && !perm.m_write.IsEmpty())
-                    return false; 
-            }
-            else if(!m_write.Equals(perm.m_write))
-                return false;
-
-            if(m_append == null)
-            {
-                if(perm.m_append != null && !perm.m_append.IsEmpty())
-                    return false; 
-            }
-            else if(!m_append.Equals(perm.m_append))
-                return false;
-
-            if(m_pathDiscovery == null)
-            {
-                if(perm.m_pathDiscovery != null && !perm.m_pathDiscovery.IsEmpty())
-                    return false; 
-            }
-            else if(!m_pathDiscovery.Equals(perm.m_pathDiscovery))
-                return false;
-
-            if(m_viewAcl == null)
-            {
-                if(perm.m_viewAcl != null && !perm.m_viewAcl.IsEmpty())
-                    return false; 
-            }
-            else if(!m_viewAcl.Equals(perm.m_viewAcl))
-                return false;
-
-            if(m_changeAcl == null)
-            {
-                if(perm.m_changeAcl != null && !perm.m_changeAcl.IsEmpty())
-                    return false; 
-            }
-            else if(!m_changeAcl.Equals(perm.m_changeAcl))
-                return false;
-
-            return true;
-        }
-
-        [System.Runtime.InteropServices.ComVisible(false)]
-        public override int GetHashCode()
-        {
-            // This implementation is only to silence a compiler warning.
-            return base.GetHashCode();
-        }
-
-        /// <summary>
-        /// Call this method if you don't need a the FileIOPermission for anything other than calling Demand() once.
-        /// 
-        /// This method tries to verify full access before allocating a FileIOPermission object.
-        /// If full access is there, then we still have to emulate the checks that creating the 
-        /// FileIOPermission object would have performed.
-        /// 
-        /// IMPORTANT: This method should only be used after calling GetFullPath on the path to verify
-        /// </summary>
-        internal static void QuickDemand(FileIOPermissionAccess access, string fullPath, bool checkForDuplicates = false, bool needFullPath = false)
-        {
-            EmulateFileIOPermissionChecks(fullPath);
-        }
-
-        /// <summary>
-        /// Call this method if you don't need a the FileIOPermission for anything other than calling Demand() once.
-        /// 
-        /// This method tries to verify full access before allocating a FileIOPermission object.
-        /// If full access is there, then we still have to emulate the checks that creating the 
-        /// FileIOPermission object would have performed.
-        /// 
-        /// IMPORTANT: This method should only be used after calling GetFullPath on the path to verify
-        /// 
-        /// </summary>
-        internal static void QuickDemand(FileIOPermissionAccess access, string[] fullPathList, bool checkForDuplicates = false, bool needFullPath = true)
-        {
-            foreach (string fullPath in fullPathList)
-            {
-                EmulateFileIOPermissionChecks(fullPath);
-            }
-        }
-
-        internal static void QuickDemand(PermissionState state)
-        {
-            // Should be a no-op without CAS
-        }
-
-        /// <summary>
-        /// Perform the additional path checks that would normally happen when creating a FileIOPermission object.
-        /// </summary>
-        /// <param name="fullPath">A path that has already gone through GetFullPath or Normalize</param>
-        internal static void EmulateFileIOPermissionChecks(string fullPath)
-        {
-            // Callers should have already made checks for invalid path format via normalization. This method will only make the
-            // additional checks needed to throw the same exceptions that would normally throw when using FileIOPermission.
-            // These checks are done via CheckIllegalCharacters() and StringExpressionSet in AddPathList() above.
-
-#if !PLATFORM_UNIX
-            // Checking for colon / invalid characters on device paths blocks legitimate access to objects such as named pipes.
-            if (!PathInternal.IsDevice(fullPath))
-            {
-                // GetFullPath already checks normal invalid path characters. We need to just check additional (wildcard) characters here.
-                // (By calling the standard helper we can allow extended paths \\?\ through when the support is enabled.)
-                if (PathInternal.HasWildCardCharacters(fullPath))
-                {
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPathChars"));
-                }
-
-                if (PathInternal.HasInvalidVolumeSeparator(fullPath))
-                {
-                    throw new NotSupportedException(Environment.GetResourceString("Argument_PathFormatNotSupported"));
-                }
-            }
-#endif // !PLATFORM_UNIX
-        }
-    }
-
-    [Serializable]
-    internal sealed class FileIOAccess
-    {
-        private bool m_ignoreCase = true;
-        
-        private StringExpressionSet m_set;
-        private bool m_allFiles;
-        private bool m_allLocalFiles;
-        private bool m_pathDiscovery;
-
-        private const String m_strAllFiles = "*AllFiles*";
-        private const String m_strAllLocalFiles = "*AllLocalFiles*";
-
-        public FileIOAccess()
-        {
-            m_set = new StringExpressionSet( m_ignoreCase, true );
-            m_allFiles = false;
-            m_allLocalFiles = false;
-            m_pathDiscovery = false;
-        }
-
-        public FileIOAccess( bool pathDiscovery )
-        {
-            m_set = new StringExpressionSet( m_ignoreCase, true );
-            m_allFiles = false;
-            m_allLocalFiles = false;
-            m_pathDiscovery = pathDiscovery;
-        }
-
-        public FileIOAccess( String value )
-        {
-            if (value == null)
-            {
-                m_set = new StringExpressionSet( m_ignoreCase, true );
-                m_allFiles = false;
-                m_allLocalFiles = false;
-            }
-            else if (value.Length >= m_strAllFiles.Length && String.Compare( m_strAllFiles, value, StringComparison.Ordinal) == 0)
-            {
-                m_set = new StringExpressionSet( m_ignoreCase, true );
-                m_allFiles = true;
-                m_allLocalFiles = false;
-            }
-            else if (value.Length >= m_strAllLocalFiles.Length && String.Compare( m_strAllLocalFiles, 0, value, 0, m_strAllLocalFiles.Length, StringComparison.Ordinal) == 0)
-            {
-                m_set = new StringExpressionSet( m_ignoreCase, value.Substring( m_strAllLocalFiles.Length ), true );
-                m_allFiles = false;
-                m_allLocalFiles = true;
-            }
-            else
-            {
-                m_set = new StringExpressionSet( m_ignoreCase, value, true );
-                m_allFiles = false;
-                m_allLocalFiles = false;
-            }
-            m_pathDiscovery = false;
-        }
-
-        public FileIOAccess( bool allFiles, bool allLocalFiles, bool pathDiscovery )
-        {
-            m_set = new StringExpressionSet( m_ignoreCase, true );
-            m_allFiles = allFiles;
-            m_allLocalFiles = allLocalFiles;
-            m_pathDiscovery = pathDiscovery;
-        }
-
-        public FileIOAccess( StringExpressionSet set, bool allFiles, bool allLocalFiles, bool pathDiscovery )
-        {
-            m_set = set;
-            m_set.SetThrowOnRelative( true );
-            m_allFiles = allFiles;
-            m_allLocalFiles = allLocalFiles;
-            m_pathDiscovery = pathDiscovery;
-        }
-
-        private FileIOAccess( FileIOAccess operand )
-        {
-            m_set = operand.m_set.Copy();
-            m_allFiles = operand.m_allFiles;
-            m_allLocalFiles = operand.m_allLocalFiles;
-            m_pathDiscovery = operand.m_pathDiscovery;
-        }
-
-        public void AddExpressions(ArrayList values, bool checkForDuplicates)
-        {
-            m_allFiles = false;
-            m_set.AddExpressions(values, checkForDuplicates);
-        }
-
-        public bool AllFiles
-        {
-            get
-            {
-                return m_allFiles;
-            }
-
-            set
-            {
-                m_allFiles = value;
-            }
-        }
-
-        public bool AllLocalFiles
-        {
-            get
-            {
-                return m_allLocalFiles;
-            }
-            
-            set
-            {
-                m_allLocalFiles = value;
-            }
-        }
-
-        public bool PathDiscovery
-        {
-            set
-            {
-                m_pathDiscovery = value;
-            }
-        }
-        
-        public bool IsEmpty()
-        {
-            return !m_allFiles && !m_allLocalFiles && (m_set == null || m_set.IsEmpty());
-        }
-        
-        public FileIOAccess Copy()
-        {
-            return new FileIOAccess( this );
-        }
-        
-        public FileIOAccess Union( FileIOAccess operand )
-        {
-            if (operand == null)
-            {
-                return this.IsEmpty() ? null : this.Copy();
-            }
-            
-            Debug.Assert( this.m_pathDiscovery == operand.m_pathDiscovery, "Path discovery settings must match" );
-
-            if (this.m_allFiles || operand.m_allFiles)
-            {
-                return new FileIOAccess( true, false, this.m_pathDiscovery );
-            }
-
-            return new FileIOAccess( this.m_set.Union( operand.m_set ), false, this.m_allLocalFiles || operand.m_allLocalFiles, this.m_pathDiscovery );
-        }
-        
-        public FileIOAccess Intersect( FileIOAccess operand )
-        {
-            if (operand == null)
-            {
-                return null;
-            }
-            
-            Debug.Assert( this.m_pathDiscovery == operand.m_pathDiscovery, "Path discovery settings must match" );
-
-            if (this.m_allFiles)
-            {
-                if (operand.m_allFiles)
-                {
-                    return new FileIOAccess( true, false, this.m_pathDiscovery );
-                }
-                else
-                {
-                    return new FileIOAccess( operand.m_set.Copy(), false, operand.m_allLocalFiles, this.m_pathDiscovery );
-                }
-            }
-            else if (operand.m_allFiles)
-            {
-                return new FileIOAccess( this.m_set.Copy(), false, this.m_allLocalFiles, this.m_pathDiscovery );
-            }
-
-            StringExpressionSet intersectionSet = new StringExpressionSet( m_ignoreCase, true );
-
-            if (this.m_allLocalFiles)
-            {
-                String[] expressions = operand.m_set.UnsafeToStringArray();
-                
-                if (expressions != null)
-                {
-                    for (int i = 0; i < expressions.Length; ++i)
-                    {
-                        String root = GetRoot( expressions[i] );
-                        if (root != null && IsLocalDrive( GetRoot( root ) ) )
-                        {
-                            intersectionSet.AddExpressions( new String[] { expressions[i] }, true, false );
-                        }
-                    }
-                }
-            }
-
-            if (operand.m_allLocalFiles)
-            {
-                String[] expressions = this.m_set.UnsafeToStringArray();
-
-                if (expressions != null)
-                {
-                    for (int i = 0; i < expressions.Length; ++i)
-                    {
-                        String root = GetRoot( expressions[i] );
-                        if (root != null && IsLocalDrive(GetRoot(root)))
-                        {
-                            intersectionSet.AddExpressions( new String[] { expressions[i] }, true, false );
-                        }
-                    }
-                }
-            }
-
-            String[] regularIntersection = this.m_set.Intersect( operand.m_set ).UnsafeToStringArray();
-
-            if (regularIntersection != null)
-                intersectionSet.AddExpressions( regularIntersection, !intersectionSet.IsEmpty(), false );
-
-            return new FileIOAccess( intersectionSet, false, this.m_allLocalFiles && operand.m_allLocalFiles, this.m_pathDiscovery );
-        }
-    
-        public bool IsSubsetOf( FileIOAccess operand )
-        {
-            if (operand == null)
-            {
-                return this.IsEmpty();
-            }
-            
-            if (operand.m_allFiles)
-            {
-                return true;
-            }
-            
-            Debug.Assert( this.m_pathDiscovery == operand.m_pathDiscovery, "Path discovery settings must match" );
-
-            if (!((m_pathDiscovery && this.m_set.IsSubsetOfPathDiscovery( operand.m_set )) || this.m_set.IsSubsetOf( operand.m_set )))
-            {
-                if (operand.m_allLocalFiles)
-                {
-                    String[] expressions = m_set.UnsafeToStringArray();
-                
-                    for (int i = 0; i < expressions.Length; ++i)
-                    {
-                        String root = GetRoot( expressions[i] );
-                        if (root == null || !IsLocalDrive(GetRoot(root)))
-                        {
-                            return false;
-                        }
-                    }
-                }
-                else
-                {
-                    return false;
-                }
-            }
-            
-            return true;
-        }
-
-        private static String GetRoot( String path )
-        {
-#if !PLATFORM_UNIX
-            String str = path.Substring( 0, 3 );
-            if (str.EndsWith( ":\\", StringComparison.Ordinal))
-#else
-            String str = path.Substring( 0, 1 );
-            if(str ==  "/")
-#endif // !PLATFORM_UNIX
-            {
-                return str;
-            }
-            else
-            {
-                return null;
-            }
-        }
-        
-        public override String ToString()
-        {
-            // SafeCritical: all string expression sets are constructed with the throwOnRelative bit set, so
-            // we're only exposing out the same paths that we took as input.
-            if (m_allFiles)
-            {
-                return m_strAllFiles;
-            }
-            else
-            {
-                if (m_allLocalFiles)
-                {
-                    String retstr = m_strAllLocalFiles;
-
-                    String tempStr = m_set.UnsafeToString();
-
-                    if (tempStr != null && tempStr.Length > 0)
-                        retstr += ";" + tempStr;
-
-                    return retstr;
-                }
-                else
-                {
-                    return m_set.UnsafeToString();
-                }
-            }
-        }
-
-        public String[] ToStringArray()
-        {
-            // SafeCritical: all string expression sets are constructed with the throwOnRelative bit set, so
-            // we're only exposing out the same paths that we took as input.
-            return m_set.UnsafeToStringArray();
-        }
-        
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        internal static extern bool IsLocalDrive(String path);
-
-        public override bool Equals(Object obj)
-        {
-            FileIOAccess operand = obj as FileIOAccess;
-            if(operand == null)
-                return (IsEmpty() && obj == null);
-            Debug.Assert( this.m_pathDiscovery == operand.m_pathDiscovery, "Path discovery settings must match" );
-            if(m_pathDiscovery)
-            {
-                if(this.m_allFiles && operand.m_allFiles)
-                    return true;
-                if(this.m_allLocalFiles == operand.m_allLocalFiles &&
-                    m_set.IsSubsetOf(operand.m_set) &&
-                    operand.m_set.IsSubsetOf(m_set)) // Watch Out: This calls StringExpressionSet.IsSubsetOf, unlike below
-                    return true;
-                return false;
-            }
-            else
-            {
-                if(!this.IsSubsetOf(operand)) // Watch Out: This calls FileIOAccess.IsSubsetOf, unlike above
-                    return false;
-                if(!operand.IsSubsetOf(this))
-                    return false;
-                return true;
-            }
-        }
-
-        public override int GetHashCode()
-        {
-            // This implementation is only to silence a compiler warning.
-            return base.GetHashCode();
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Permissions/GACIdentityPermission.cs b/src/mscorlib/src/System/Security/Permissions/GACIdentityPermission.cs
deleted file mode 100644
index f93f26daa9..0000000000
--- a/src/mscorlib/src/System/Security/Permissions/GACIdentityPermission.cs
+++ /dev/null
@@ -1,103 +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.
-
-namespace System.Security.Permissions
-{
-    using System;
-    using System.Globalization;
-
-    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Assembly, AllowMultiple = true, Inherited = false )]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-#pragma warning disable 618
-    sealed public class GacIdentityPermissionAttribute : CodeAccessSecurityAttribute
-#pragma warning restore 618
-    {
-#pragma warning disable 618
-        public GacIdentityPermissionAttribute( SecurityAction action )
-#pragma warning restore 618
-            : base( action )
-        {
-        }
-
-        public override IPermission CreatePermission()
-        {
-            return new GacIdentityPermission();
-        }
-    }
-
-
-    [System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-    sealed public class GacIdentityPermission : CodeAccessPermission, IBuiltInPermission
-    {
-        //------------------------------------------------------
-        //
-        // PUBLIC CONSTRUCTORS
-        //
-        //------------------------------------------------------
-
-        public GacIdentityPermission(PermissionState state)
-        {
-            if (state != PermissionState.Unrestricted && state != PermissionState.None)
-            {
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
-            }
-        }
-
-        public GacIdentityPermission()
-        {
-        }
-
-        //------------------------------------------------------
-        //
-        // IPERMISSION IMPLEMENTATION
-        //
-        //------------------------------------------------------
-
-
-        public override IPermission Copy()
-        {
-            return new GacIdentityPermission();
-        }
-
-        public override bool IsSubsetOf(IPermission target)
-        {
-            if (target == null)
-                return false;
-            if (!(target is GacIdentityPermission))
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-            return true;
-        }
-
-        public override IPermission Intersect(IPermission target)
-        {
-            if (target == null)
-                return null;
-            if (!(target is GacIdentityPermission))
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-            return this.Copy();
-        }
-
-        public override IPermission Union(IPermission target)
-        {
-            if (target == null)
-                return this.Copy();
-            if (!(target is GacIdentityPermission))
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-            return this.Copy();
-        }
-
-        /// <internalonly/>
-        int IBuiltInPermission.GetTokenIndex()
-        {
-            return GacIdentityPermission.GetTokenIndex();
-        }
-
-        internal static int GetTokenIndex()
-        {
-            return BuiltInPermissionIndex.GacIdentityPermissionIndex;
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Permissions/HostProtectionPermission.cs b/src/mscorlib/src/System/Security/Permissions/HostProtectionPermission.cs
deleted file mode 100644
index c4facbb67e..0000000000
--- a/src/mscorlib/src/System/Security/Permissions/HostProtectionPermission.cs
+++ /dev/null
@@ -1,265 +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.
-
-namespace System.Security.Permissions
-{
-    using System;
-    using System.IO;
-    using System.Security.Util;
-    using System.Text;
-    using System.Threading;
-    using System.Runtime.Remoting;
-    using System.Security;
-    using System.Runtime.Serialization;
-    using System.Reflection;
-    using System.Globalization;
-    using System.Diagnostics.Contracts;
-
-    // Keep this enum in sync with tools\ngen\ngen.cpp and inc\mscoree.idl
-
-[Serializable]
-    [Flags]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public enum HostProtectionResource
-    {
-        None                        = 0x0,
-        //--------------------------------
-        Synchronization             = 0x1,
-        SharedState                 = 0x2,
-        ExternalProcessMgmt         = 0x4,
-        SelfAffectingProcessMgmt    = 0x8,
-        ExternalThreading           = 0x10,
-        SelfAffectingThreading      = 0x20,
-        SecurityInfrastructure      = 0x40,
-        UI                          = 0x80,
-        MayLeakOnAbort              = 0x100,
-        //---------------------------------
-        All                         = 0x1ff,
-    }
-
-    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Assembly | AttributeTargets.Delegate, AllowMultiple = true, Inherited = false )] 
-    [System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-    // This needs to be in the asmmeta to enable SecAnnotate to successfully resolve and run the security rules. It gets marked
-    // as internal by BCLRewriter so we are simply marking it as FriendAccessAllowed so it stays in the asmmeta.
-    [System.Runtime.CompilerServices.FriendAccessAllowedAttribute]
-#pragma warning disable 618
-    sealed public class HostProtectionAttribute : CodeAccessSecurityAttribute
-#pragma warning restore 618
-    {
-        private HostProtectionResource m_resources = HostProtectionResource.None;
-
-        public HostProtectionAttribute()
-#pragma warning disable 618
-            : base( SecurityAction.LinkDemand )
-#pragma warning restore 618
-        {
-        }
-
-#pragma warning disable 618
-        public HostProtectionAttribute( SecurityAction action )
-#pragma warning restore 618
-            : base( action )
-        {
-#pragma warning disable 618
-            if (action != SecurityAction.LinkDemand)
-#pragma warning restore 618
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidFlag"));
-            Contract.EndContractBlock();
-        }
-
-        public HostProtectionResource Resources {
-            get { return m_resources; }
-            set { m_resources = value; }
-        }
-
-        public bool Synchronization {
-            get { return (m_resources & HostProtectionResource.Synchronization) != 0; }
-            set { m_resources = (value ? m_resources | HostProtectionResource.Synchronization : m_resources & ~HostProtectionResource.Synchronization); }
-        }
-
-        public bool SharedState {
-            get { return (m_resources & HostProtectionResource.SharedState) != 0; }
-            set { m_resources = (value ? m_resources | HostProtectionResource.SharedState : m_resources & ~HostProtectionResource.SharedState); }
-        }
-
-        public bool ExternalProcessMgmt {
-            get { return (m_resources & HostProtectionResource.ExternalProcessMgmt) != 0; }
-            set { m_resources = (value ? m_resources | HostProtectionResource.ExternalProcessMgmt : m_resources & ~HostProtectionResource.ExternalProcessMgmt); }
-        }
-
-        public bool SelfAffectingProcessMgmt {
-            get { return (m_resources & HostProtectionResource.SelfAffectingProcessMgmt) != 0; }
-            set { m_resources = (value ? m_resources | HostProtectionResource.SelfAffectingProcessMgmt : m_resources & ~HostProtectionResource.SelfAffectingProcessMgmt); }
-        }
-
-        public bool ExternalThreading {
-            get { return (m_resources & HostProtectionResource.ExternalThreading) != 0; }
-            set { m_resources = (value ? m_resources | HostProtectionResource.ExternalThreading : m_resources & ~HostProtectionResource.ExternalThreading); }
-        }
-
-        public bool SelfAffectingThreading {
-            get { return (m_resources & HostProtectionResource.SelfAffectingThreading) != 0; }
-            set { m_resources = (value ? m_resources | HostProtectionResource.SelfAffectingThreading : m_resources & ~HostProtectionResource.SelfAffectingThreading); }
-        }
-
-[System.Runtime.InteropServices.ComVisible(true)]
-        public bool SecurityInfrastructure {
-            get { return (m_resources & HostProtectionResource.SecurityInfrastructure) != 0; }
-            set { m_resources = (value ? m_resources | HostProtectionResource.SecurityInfrastructure : m_resources & ~HostProtectionResource.SecurityInfrastructure); }
-        }
-
-        public bool UI {
-            get { return (m_resources & HostProtectionResource.UI) != 0; }
-            set { m_resources = (value ? m_resources | HostProtectionResource.UI : m_resources & ~HostProtectionResource.UI); }
-        }
-
-        public bool MayLeakOnAbort {
-            get { return (m_resources & HostProtectionResource.MayLeakOnAbort) != 0; }
-            set { m_resources = (value ? m_resources | HostProtectionResource.MayLeakOnAbort : m_resources & ~HostProtectionResource.MayLeakOnAbort); }
-        }
-
-        public override IPermission CreatePermission()
-        {
-            if (m_unrestricted)
-            {
-                return new HostProtectionPermission( PermissionState.Unrestricted );
-            }
-            else
-            {
-                return new HostProtectionPermission( m_resources );
-            }
-        }
-    }
-
-    [Serializable]
-    sealed internal class HostProtectionPermission : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission
-    {
-        //------------------------------------------------------
-        //
-        // GLOBALS
-        //
-        //------------------------------------------------------
-
-        // This value is set by PermissionSet.FilterHostProtectionPermissions.  It is only used for
-        // constructing a HostProtectionException object.  Changing it will not affect HostProtection.
-        internal static volatile HostProtectionResource protectedResources = HostProtectionResource.None;
-
-        //------------------------------------------------------
-        //
-        // MEMBERS
-        //
-        //------------------------------------------------------
-        private HostProtectionResource m_resources;
-
-        //------------------------------------------------------
-        //
-        // CONSTRUCTORS
-        //
-        //------------------------------------------------------
-        public HostProtectionPermission(PermissionState state)
-        {
-            if (state == PermissionState.Unrestricted)
-                Resources = HostProtectionResource.All;
-            else if (state == PermissionState.None)
-                Resources = HostProtectionResource.None;
-            else
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
-        }
-
-        public HostProtectionPermission(HostProtectionResource resources)
-        {
-            Resources = resources;
-        }
-
-        //------------------------------------------------------
-        //
-        // IPermission interface implementation
-        //
-        //------------------------------------------------------
-        public bool IsUnrestricted()
-        {
-            return Resources == HostProtectionResource.All;
-        }
-
-        //------------------------------------------------------
-        //
-        // Properties
-        //
-        //------------------------------------------------------
-        public HostProtectionResource Resources
-        {
-            set
-            {
-                if(value < HostProtectionResource.None || value > HostProtectionResource.All)
-                    throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)value));
-                Contract.EndContractBlock();
-                m_resources = value;
-            }
-
-            get
-            {
-                return m_resources;
-            }
-        }
-
-        //------------------------------------------------------
-        //
-        // IPermission interface implementation
-        //
-        //------------------------------------------------------
-        public override bool IsSubsetOf(IPermission target)
-        {
-            if (target == null)
-                return m_resources == HostProtectionResource.None;
-            if(this.GetType() != target.GetType())
-                throw new ArgumentException( Environment.GetResourceString("Argument_WrongType", this.GetType().FullName) );
-            return ((uint)this.m_resources & (uint)((HostProtectionPermission)target).m_resources) == (uint)this.m_resources;
-        }
-
-        public override IPermission Union(IPermission target)
-        {
-            if (target == null)
-                return(this.Copy());
-            if(this.GetType() != target.GetType())
-                throw new ArgumentException( Environment.GetResourceString("Argument_WrongType", this.GetType().FullName) );
-            HostProtectionResource newResources = (HostProtectionResource)((uint)this.m_resources | (uint)((HostProtectionPermission)target).m_resources);
-            return new HostProtectionPermission(newResources);
-        }
-
-        public override IPermission Intersect(IPermission target)
-        {
-            if (target == null)
-                return null;
-            if(this.GetType() != target.GetType())
-                throw new ArgumentException( Environment.GetResourceString("Argument_WrongType", this.GetType().FullName) );
-            HostProtectionResource newResources = (HostProtectionResource)((uint)this.m_resources & (uint)((HostProtectionPermission)target).m_resources);
-            if(newResources == HostProtectionResource.None)
-                return null;
-            return new HostProtectionPermission(newResources);
-        }
-
-        public override IPermission Copy()
-        {
-            return new HostProtectionPermission(m_resources);
-        }
-
-        //------------------------------------------------------
-        //
-        // OBJECT OVERRIDES
-        //
-        //------------------------------------------------------
-
-        /// <internalonly/>
-        int IBuiltInPermission.GetTokenIndex()
-        {
-            return HostProtectionPermission.GetTokenIndex();
-        }
-
-        internal static int GetTokenIndex()
-        {
-            return BuiltInPermissionIndex.HostProtectionPermissionIndex;
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Permissions/IBuiltInPermission.cs b/src/mscorlib/src/System/Security/Permissions/IBuiltInPermission.cs
deleted file mode 100644
index 58b26bd9c4..0000000000
--- a/src/mscorlib/src/System/Security/Permissions/IBuiltInPermission.cs
+++ /dev/null
@@ -1,63 +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.
-
-namespace System.Security.Permissions
-{
-    internal interface IBuiltInPermission
-    {
-        int GetTokenIndex();
-    }
-
-    internal static class BuiltInPermissionIndex
-    {
-        internal const int NUM_BUILTIN_UNRESTRICTED = 10;
-        internal const int NUM_BUILTIN_NORMAL = 7;
-
-        // Unrestricted permissions
-
-        internal const int EnvironmentPermissionIndex = 0;
-        internal const int FileDialogPermissionIndex = 1;
-        internal const int FileIOPermissionIndex = 2;
-        internal const int IsolatedStorageFilePermissionIndex = 3;
-        internal const int ReflectionPermissionIndex = 4;
-        internal const int RegistryPermissionIndex = 5;
-        internal const int SecurityPermissionIndex = 6;
-        internal const int UIPermissionIndex = 7;
-        internal const int PrincipalPermissionIndex = 8;
-        internal const int HostProtectionPermissionIndex = 9;
-
-        // Normal permissions
-        internal const int PublisherIdentityPermissionIndex = 0 + NUM_BUILTIN_UNRESTRICTED;
-        internal const int SiteIdentityPermissionIndex = 1 + NUM_BUILTIN_UNRESTRICTED;
-        internal const int StrongNameIdentityPermissionIndex = 2 + NUM_BUILTIN_UNRESTRICTED;
-        internal const int UrlIdentityPermissionIndex = 3 + NUM_BUILTIN_UNRESTRICTED;
-        internal const int ZoneIdentityPermissionIndex = 4 + NUM_BUILTIN_UNRESTRICTED;
-        internal const int GacIdentityPermissionIndex = 5 + NUM_BUILTIN_UNRESTRICTED;
-        internal const int KeyContainerPermissionIndex = 6 + NUM_BUILTIN_UNRESTRICTED;
-    }
-
-    [Serializable]
-    internal enum BuiltInPermissionFlag
-    {
-        // Unrestricted permissions
-
-        EnvironmentPermission = 0x1,
-        FileDialogPermission = 0x2,
-        FileIOPermission = 0x4,
-        IsolatedStorageFilePermission = 0x8,
-        ReflectionPermission = 0x10,
-        RegistryPermission = 0x20,
-        SecurityPermission = 0x40,
-        UIPermission = 0x80,
-        PrincipalPermission = 0x100,
-
-        // Normal permissions
-        PublisherIdentityPermission = 0x200,
-        SiteIdentityPermission = 0x400,
-        StrongNameIdentityPermission = 0x800,
-        UrlIdentityPermission = 0x1000,
-        ZoneIdentityPermission = 0x2000,
-        KeyContainerPermission = 0x4000,
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Permissions/IUnrestrictedPermission.cs b/src/mscorlib/src/System/Security/Permissions/IUnrestrictedPermission.cs
deleted file mode 100644
index 782df8012c..0000000000
--- a/src/mscorlib/src/System/Security/Permissions/IUnrestrictedPermission.cs
+++ /dev/null
@@ -1,13 +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.
-
-namespace System.Security.Permissions {
-    
-    using System;
-[System.Runtime.InteropServices.ComVisible(true)]
-    public interface IUnrestrictedPermission
-    {
-        bool IsUnrestricted();
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Permissions/IsolatedStorageFilePermission.cs b/src/mscorlib/src/System/Security/Permissions/IsolatedStorageFilePermission.cs
deleted file mode 100644
index 42bc648c72..0000000000
--- a/src/mscorlib/src/System/Security/Permissions/IsolatedStorageFilePermission.cs
+++ /dev/null
@@ -1,163 +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 : This permission is used to controls/administer access to 
-//  IsolatedStorageFile
-//
-
-namespace System.Security.Permissions {
-
-    using System.Globalization;
-    
-    [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
-    sealed public class IsolatedStorageFilePermission : IsolatedStoragePermission, IBuiltInPermission
-    {
-        public IsolatedStorageFilePermission(PermissionState state)
-        : base(state) { }
-
-        internal IsolatedStorageFilePermission(IsolatedStorageContainment UsageAllowed, 
-            long ExpirationDays, bool PermanentData)
-        : base(UsageAllowed, ExpirationDays, PermanentData) { }
-
-        //------------------------------------------------------
-        //
-        // IPERMISSION IMPLEMENTATION
-        //
-        //------------------------------------------------------
-        
-        public override IPermission Union(IPermission target)
-        {
-            if (target == null)
-            {
-                return this.Copy();
-            }
-            else if (!VerifyType(target))
-            {
-                throw new 
-                    ArgumentException(
-                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
-                                     );
-            }
-            
-            IsolatedStorageFilePermission operand = (IsolatedStorageFilePermission)target;
-    
-            if (this.IsUnrestricted() || operand.IsUnrestricted()) 
-            {
-                return new IsolatedStorageFilePermission( PermissionState.Unrestricted );
-            }
-            else
-            {
-                IsolatedStorageFilePermission union;
-                union = new IsolatedStorageFilePermission( PermissionState.None );
-                union.m_userQuota = max(m_userQuota,operand.m_userQuota);   
-                union.m_machineQuota = max(m_machineQuota,operand.m_machineQuota);  
-                union.m_expirationDays = max(m_expirationDays,operand.m_expirationDays);    
-                union.m_permanentData = m_permanentData || operand.m_permanentData; 
-                union.m_allowed = (IsolatedStorageContainment)max((long)m_allowed,(long)operand.m_allowed); 
-                return union;
-            }
-        }   
-
-        public override bool IsSubsetOf(IPermission target)
-        {
-            if (target == null)
-            {
-                return ((m_userQuota == 0) &&
-                        (m_machineQuota == 0) &&
-                        (m_expirationDays == 0) &&
-                        (m_permanentData == false) &&
-                        (m_allowed == IsolatedStorageContainment.None));
-            }
-
-            try
-            {
-                IsolatedStorageFilePermission operand = (IsolatedStorageFilePermission)target;
-
-                if (operand.IsUnrestricted())
-                    return true;
-
-                return ((operand.m_userQuota >= m_userQuota) &&
-                        (operand.m_machineQuota >= m_machineQuota) &&
-                        (operand.m_expirationDays >= m_expirationDays) &&
-                        (operand.m_permanentData || !m_permanentData) &&
-                        (operand.m_allowed >= m_allowed));
-            }
-            catch (InvalidCastException)
-            {
-                throw new 
-                    ArgumentException(
-                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
-                                     );
-            }                
-
-        }
-        
-        public override IPermission Intersect(IPermission target)
-        {
-            if (target == null)
-                return null;
-            else if (!VerifyType(target))
-            {
-                throw new 
-                    ArgumentException(
-                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
-                                     );
-            }
-
-            IsolatedStorageFilePermission operand = (IsolatedStorageFilePermission)target;
-
-            if(operand.IsUnrestricted()) 
-                return Copy();
-            else if(IsUnrestricted())
-                return target.Copy();
-            
-            IsolatedStorageFilePermission intersection;
-            intersection = new IsolatedStorageFilePermission( PermissionState.None );
-            intersection.m_userQuota = min(m_userQuota,operand.m_userQuota);    
-            intersection.m_machineQuota = min(m_machineQuota,operand.m_machineQuota);   
-            intersection.m_expirationDays = min(m_expirationDays,operand.m_expirationDays); 
-            intersection.m_permanentData = m_permanentData && operand.m_permanentData;  
-            intersection.m_allowed = (IsolatedStorageContainment)min((long)m_allowed,(long)operand.m_allowed);  
-
-            if ((intersection.m_userQuota == 0) &&
-            (intersection.m_machineQuota == 0) &&
-            (intersection.m_expirationDays == 0) &&
-            (intersection.m_permanentData == false) &&
-            (intersection.m_allowed == IsolatedStorageContainment.None))
-                return null;
-
-            return intersection;
-        }
-      
-        public override IPermission Copy()
-        {
-            IsolatedStorageFilePermission copy ;
-            copy = new IsolatedStorageFilePermission(PermissionState.Unrestricted);
-            if(!IsUnrestricted()){
-                copy.m_userQuota = m_userQuota; 
-                copy.m_machineQuota = m_machineQuota;   
-                copy.m_expirationDays = m_expirationDays;   
-                copy.m_permanentData = m_permanentData; 
-                copy.m_allowed = m_allowed; 
-            }
-            return copy;
-        }
-
-
-        /// <internalonly/>
-        int IBuiltInPermission.GetTokenIndex()
-        {
-            return IsolatedStorageFilePermission.GetTokenIndex();
-        }
-
-        internal static int GetTokenIndex()
-        {
-            return BuiltInPermissionIndex.IsolatedStorageFilePermissionIndex;
-        }
-    }
-}
-
diff --git a/src/mscorlib/src/System/Security/Permissions/IsolatedStoragePermission.cs b/src/mscorlib/src/System/Security/Permissions/IsolatedStoragePermission.cs
deleted file mode 100644
index f54493fb37..0000000000
--- a/src/mscorlib/src/System/Security/Permissions/IsolatedStoragePermission.cs
+++ /dev/null
@@ -1,157 +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.
-
-// 
-
-namespace System.Security.Permissions {
-    
-    using System;
-    using System.IO;
-    using System.Security;
-    using System.Security.Util;
-    using System.Globalization;
-
-    [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public enum IsolatedStorageContainment {
-        None                                    = 0x00,
-        DomainIsolationByUser                   = 0x10,
-        ApplicationIsolationByUser              = 0x15,
-        AssemblyIsolationByUser                 = 0x20,
-        DomainIsolationByMachine                = 0x30,
-        AssemblyIsolationByMachine              = 0x40,
-        ApplicationIsolationByMachine          = 0x45,
-        DomainIsolationByRoamingUser            = 0x50,
-        AssemblyIsolationByRoamingUser          = 0x60,
-        ApplicationIsolationByRoamingUser          = 0x65,
-        AdministerIsolatedStorageByUser         = 0x70,
-        //AdministerIsolatedStorageByMachine    = 0x80,
-        UnrestrictedIsolatedStorage             = 0xF0
-    };
-
-    
-    [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    abstract public class IsolatedStoragePermission
-           : CodeAccessPermission, IUnrestrictedPermission
-    {
-
-        //------------------------------------------------------
-        //
-        // PRIVATE STATE DATA
-        //
-        //------------------------------------------------------
-        
-        /// <internalonly/>
-        internal long m_userQuota;
-        /// <internalonly/>
-        internal long m_machineQuota;
-        /// <internalonly/>
-        internal long m_expirationDays;
-        /// <internalonly/>
-        internal bool m_permanentData;
-        /// <internalonly/>
-        internal IsolatedStorageContainment m_allowed;
-    
-        //------------------------------------------------------
-        //
-        // CONSTRUCTORS
-        //
-        //------------------------------------------------------
-    
-        protected IsolatedStoragePermission(PermissionState state)
-        {
-            if (state == PermissionState.Unrestricted)
-            {
-                m_userQuota = Int64.MaxValue;
-                m_machineQuota = Int64.MaxValue;
-                m_expirationDays = Int64.MaxValue ;
-                m_permanentData = true;
-                m_allowed = IsolatedStorageContainment.UnrestrictedIsolatedStorage;
-            }
-            else if (state == PermissionState.None)
-            {
-                m_userQuota = 0;
-                m_machineQuota = 0;
-                m_expirationDays = 0;
-                m_permanentData = false;
-                m_allowed = IsolatedStorageContainment.None;
-            }
-            else
-            {
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
-            }
-        }
-    
-        internal IsolatedStoragePermission(IsolatedStorageContainment UsageAllowed, 
-            long ExpirationDays, bool PermanentData)
-
-        {
-                m_userQuota = 0;    // typical demand won't include quota
-                m_machineQuota = 0; // typical demand won't include quota
-                m_expirationDays = ExpirationDays;
-                m_permanentData = PermanentData;
-                m_allowed = UsageAllowed;
-        }
-    
-        internal IsolatedStoragePermission(IsolatedStorageContainment UsageAllowed, 
-            long ExpirationDays, bool PermanentData, long UserQuota)
-
-        {
-                m_machineQuota = 0;
-                m_userQuota = UserQuota;
-                m_expirationDays = ExpirationDays;
-                m_permanentData = PermanentData;
-                m_allowed = UsageAllowed;
-        }
-    
-        
-        //------------------------------------------------------
-        //
-        // PUBLIC ACCESSOR METHODS
-        //
-        //------------------------------------------------------
-        
-        // properties
-        public long UserQuota {
-            set{
-                m_userQuota = value;
-            }
-            get{
-                return m_userQuota;
-            }
-        }
-
-
-        public IsolatedStorageContainment UsageAllowed {
-            set{
-                m_allowed = value;
-            }
-            get{
-                return m_allowed;
-            }
-        }
-
-    
-        //------------------------------------------------------
-        //
-        // CODEACCESSPERMISSION IMPLEMENTATION
-        //
-        //------------------------------------------------------
-        
-        public bool IsUnrestricted()
-        {
-            return m_allowed == IsolatedStorageContainment.UnrestrictedIsolatedStorage;
-        }
-        
-    
-        //------------------------------------------------------
-        //
-        // INTERNAL METHODS
-        //
-        //------------------------------------------------------
-        internal static long min(long x,long y) {return x>y?y:x;}
-        internal static long max(long x,long y) {return x<y?y:x;}
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Permissions/PermissionAttributes.cs b/src/mscorlib/src/System/Security/Permissions/PermissionAttributes.cs
deleted file mode 100644
index e6fc2a4693..0000000000
--- a/src/mscorlib/src/System/Security/Permissions/PermissionAttributes.cs
+++ /dev/null
@@ -1,877 +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.
-
-namespace System.Security.Permissions
-{
-
-    using System.Security.Util;
-    using System.IO;
-    using System.Security.Policy;
-    using System.Text;
-    using System.Threading;
-    using System.Runtime.InteropServices;
-    using System.Runtime.Remoting;
-    using System.Runtime.Serialization;
-    using System.Runtime.Versioning;
-    using System.Diagnostics.Contracts;
-    
-    [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    // The csharp compiler requires these types to be public, but they are not used elsewhere.
-    [Obsolete("SecurityAction is no longer accessible to application code.")]
-    public enum SecurityAction
-    {
-        // Demand permission of all caller
-        Demand = 2,
-
-        // Assert permission so callers don't need
-        Assert = 3,
-
-        // Deny permissions so checks will fail
-        [Obsolete("Deny is obsolete and will be removed in a future release of the .NET Framework. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
-        Deny = 4,
-
-        // Reduce permissions so check will fail
-        PermitOnly = 5,
-
-        // Demand permission of caller
-        LinkDemand = 6,
-    
-        // Demand permission of a subclass
-        InheritanceDemand = 7,
-
-        // Request minimum permissions to run
-        [Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
-        RequestMinimum = 8,
-
-        // Request optional additional permissions
-        [Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
-        RequestOptional = 9,
-
-        // Refuse to be granted these permissions
-        [Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
-        RequestRefuse = 10,
-    }
-
-    [Serializable]
-    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Assembly, AllowMultiple = true, Inherited = false )] 
-    [System.Runtime.InteropServices.ComVisible(true)]
-    // The csharp compiler requires these types to be public, but they are not used elsewhere.
-    [Obsolete("SecurityAttribute is no longer accessible to application code.")]
-    public abstract class SecurityAttribute : System.Attribute
-    {
-        /// <internalonly/>
-        internal SecurityAction m_action;
-        /// <internalonly/>
-        internal bool m_unrestricted;
-
-        protected SecurityAttribute( SecurityAction action ) 
-        {
-            m_action = action;
-        }
-
-        public SecurityAction Action
-        {
-            get { return m_action; }
-            set { m_action = value; }
-        }
-
-        public bool Unrestricted
-        {
-            get { return m_unrestricted; }
-            set { m_unrestricted = value; }
-        }
-
-        abstract public IPermission CreatePermission();
-
-        internal static unsafe IntPtr FindSecurityAttributeTypeHandle(String typeName)
-        {
-            PermissionSet.s_fullTrust.Assert();
-            Type t = Type.GetType(typeName, false, false);
-            if(t == null)
-                return IntPtr.Zero;
-            IntPtr typeHandle = t.TypeHandle.Value;
-            return typeHandle;
-        }
-    }
-
-    [Serializable]
-    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Assembly, AllowMultiple = true, Inherited = false )] 
-    [System.Runtime.InteropServices.ComVisible(true)]
-    // The csharp compiler requires these types to be public, but they are not used elsewhere.
-    [Obsolete("CodeAccessSecurityAttribute is no longer accessible to application code.")]
-    public abstract class CodeAccessSecurityAttribute : SecurityAttribute
-    {
-        protected CodeAccessSecurityAttribute( SecurityAction action )
-            : base( action )
-        {
-        }
-    }
-
-    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Assembly, AllowMultiple = true, Inherited = false )] 
-[System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-#pragma warning disable 618
-    sealed public class EnvironmentPermissionAttribute : CodeAccessSecurityAttribute
-#pragma warning restore 618
-    {
-        private String m_read = null;
-        private String m_write = null;
-    
-#pragma warning disable 618
-        public EnvironmentPermissionAttribute( SecurityAction action )
-#pragma warning restore 618
-            : base( action )
-        {
-        }
-
-        public String Read {
-            get { return m_read; }
-            set { m_read = value; }
-        }
-    
-        public String Write {
-            get { return m_write; }
-            set { m_write = value; }
-        }
-
-        public String All {
-            get { throw new NotSupportedException( Environment.GetResourceString( "NotSupported_GetMethod" ) ); }
-            set { m_write = value; m_read = value; }
-        }
-
-        public override IPermission CreatePermission()
-        {
-            if (m_unrestricted)
-            {
-                return new EnvironmentPermission(PermissionState.Unrestricted);
-            }
-            else
-            {
-                EnvironmentPermission perm = new EnvironmentPermission(PermissionState.None);
-                if (m_read != null)
-                    perm.SetPathList( EnvironmentPermissionAccess.Read, m_read );
-                if (m_write != null)
-                    perm.SetPathList( EnvironmentPermissionAccess.Write, m_write );
-                return perm;
-            }
-        }
-    }
-
-    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Assembly, AllowMultiple = true, Inherited = false )] 
-[System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-#pragma warning disable 618
-    sealed public class FileDialogPermissionAttribute : CodeAccessSecurityAttribute
-#pragma warning restore 618
-    {
-        private FileDialogPermissionAccess m_access;
-
-#pragma warning disable 618
-        public FileDialogPermissionAttribute( SecurityAction action )
-#pragma warning restore 618
-            : base( action )
-        {
-        }
-
-        public bool Open
-        {
-            get { return (m_access & FileDialogPermissionAccess.Open) != 0; }
-            set { m_access = value ? m_access | FileDialogPermissionAccess.Open : m_access & ~FileDialogPermissionAccess.Open; }
-        }
-            
-        public bool Save
-        {
-            get { return (m_access & FileDialogPermissionAccess.Save) != 0; }
-            set { m_access = value ? m_access | FileDialogPermissionAccess.Save : m_access & ~FileDialogPermissionAccess.Save; }
-        }
-
-        public override IPermission CreatePermission()
-        {
-            if (m_unrestricted)
-            {
-                return new FileDialogPermission( PermissionState.Unrestricted );
-            }
-            else
-            {
-                return new FileDialogPermission( m_access );
-            }
-        }
-    }
-
-
-    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Assembly, AllowMultiple = true, Inherited = false )] 
-[System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-#pragma warning disable 618
-    sealed public class FileIOPermissionAttribute : CodeAccessSecurityAttribute
-#pragma warning restore 618
-    {
-        private String m_read = null;
-        private String m_write = null;
-        private String m_append = null;
-        private String m_pathDiscovery = null;
-        private String m_viewAccess = null;
-        private String m_changeAccess = null;
-        [OptionalField(VersionAdded = 2)] private FileIOPermissionAccess m_allLocalFiles = FileIOPermissionAccess.NoAccess;
-        [OptionalField(VersionAdded = 2)] private FileIOPermissionAccess m_allFiles = FileIOPermissionAccess.NoAccess;
-    
-#pragma warning disable 618
-        public FileIOPermissionAttribute( SecurityAction action )
-#pragma warning restore 618
-            : base( action )
-        {
-        }
-
-        public String Read {
-            get { return m_read; }
-            set { m_read = value; }
-        }
-    
-        public String Write {
-            get { return m_write; }
-            set { m_write = value; }
-        }
-
-        public String Append {
-            get { return m_append; }
-            set { m_append = value; }
-        }
-
-        public String PathDiscovery {
-            get { return m_pathDiscovery; }
-            set { m_pathDiscovery = value; }
-        }
-
-        public String ViewAccessControl {
-            get { return m_viewAccess; }
-            set { m_viewAccess = value; }
-        }
-
-        public String ChangeAccessControl {
-            get { return m_changeAccess; }
-            set { m_changeAccess = value; }
-        }
-
-        [Obsolete("Please use the ViewAndModify property instead.")]
-        public String All {
-            set { m_read = value; m_write = value; m_append = value; m_pathDiscovery = value; }
-            get { throw new NotSupportedException( Environment.GetResourceString( "NotSupported_GetMethod" ) ); }
-        }
-
-        // Read, Write, Append, PathDiscovery, but no ACL-related permissions
-        public String ViewAndModify {
-            get { throw new NotSupportedException( Environment.GetResourceString( "NotSupported_GetMethod" ) ); }
-            set { m_read = value; m_write = value; m_append = value; m_pathDiscovery = value; }
-        }
-
-        public FileIOPermissionAccess AllFiles {
-            get { return m_allFiles; }
-            set { m_allFiles = value; }
-        }
-
-        public FileIOPermissionAccess AllLocalFiles {
-            get { return m_allLocalFiles; }
-            set { m_allLocalFiles = value; }
-        }
-
-        public override IPermission CreatePermission()
-        {
-            if (m_unrestricted)
-            {
-                return new FileIOPermission(PermissionState.Unrestricted);
-            }
-            else
-            {
-                FileIOPermission perm = new FileIOPermission(PermissionState.None);
-                if (m_read != null)
-                    perm.SetPathList( FileIOPermissionAccess.Read, m_read );
-                if (m_write != null)
-                    perm.SetPathList( FileIOPermissionAccess.Write, m_write );
-                if (m_append != null)
-                    perm.SetPathList( FileIOPermissionAccess.Append, m_append );
-                if (m_pathDiscovery != null)
-                    perm.SetPathList( FileIOPermissionAccess.PathDiscovery, m_pathDiscovery );
-
-                perm.AllFiles = m_allFiles;
-                perm.AllLocalFiles = m_allLocalFiles;
-                return perm;
-            }
-        }
-    }
-
-    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Assembly, AllowMultiple = true, Inherited = false )] 
-    [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
-#pragma warning disable 618
-    public sealed class KeyContainerPermissionAttribute : CodeAccessSecurityAttribute {
-#pragma warning restore 618
-        KeyContainerPermissionFlags m_flags = KeyContainerPermissionFlags.NoFlags;
-        private string m_keyStore;
-        private string m_providerName;
-        private int m_providerType = -1;
-        private string m_keyContainerName;
-        private int m_keySpec = -1;
-
-#pragma warning disable 618
-        public KeyContainerPermissionAttribute(SecurityAction action) : base(action) {}
-#pragma warning restore 618
-
-        public string KeyStore {
-            get { return m_keyStore; }
-            set { m_keyStore = value; }
-        }
-
-        public string ProviderName {
-            get { return m_providerName; }
-            set { m_providerName = value; }
-        }
-
-        public int ProviderType {
-            get { return m_providerType; }
-            set { m_providerType = value; }
-        }
-
-        public string KeyContainerName {
-            get { return m_keyContainerName; }
-            set { m_keyContainerName = value; }
-        }
-
-        public int KeySpec {
-            get { return m_keySpec; }
-            set { m_keySpec = value; }
-        }
-
-        public KeyContainerPermissionFlags Flags {
-            get { return m_flags; }
-            set { m_flags = value; }
-        }
-
-        public override IPermission CreatePermission() {
-            if (m_unrestricted) {
-                return new KeyContainerPermission(PermissionState.Unrestricted);
-            } else {
-                if (KeyContainerPermissionAccessEntry.IsUnrestrictedEntry(m_keyStore, m_providerName, m_providerType, m_keyContainerName, m_keySpec))
-                    return new KeyContainerPermission(m_flags);
-
-                // create a KeyContainerPermission with a single access entry.
-                KeyContainerPermission cp = new KeyContainerPermission(KeyContainerPermissionFlags.NoFlags);
-                KeyContainerPermissionAccessEntry accessEntry = new KeyContainerPermissionAccessEntry(m_keyStore, m_providerName, m_providerType, m_keyContainerName, m_keySpec, m_flags);
-                cp.AccessEntries.Add(accessEntry);
-                return cp;
-            }
-        }
-    }
-
-    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Assembly, AllowMultiple = true, Inherited = false )] 
-[System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-#pragma warning disable 618
-    sealed public class ReflectionPermissionAttribute : CodeAccessSecurityAttribute
-#pragma warning restore 618
-    {
-        private ReflectionPermissionFlag m_flag = ReflectionPermissionFlag.NoFlags;
-
-#pragma warning disable 618
-        public ReflectionPermissionAttribute( SecurityAction action )
-#pragma warning restore 618
-            : base( action )
-        {
-        }
-
-        public ReflectionPermissionFlag Flags {
-            get { return m_flag; }
-            set { m_flag = value; }
-        }
-
-        [Obsolete("This API has been deprecated. http://go.microsoft.com/fwlink/?linkid=14202")]
-        public bool TypeInformation {
-#pragma warning disable 618
-            get { return (m_flag & ReflectionPermissionFlag.TypeInformation) != 0; }
-            set { m_flag = value ? m_flag | ReflectionPermissionFlag.TypeInformation : m_flag & ~ReflectionPermissionFlag.TypeInformation; }
-#pragma warning restore 618
-        }
-
-        public bool MemberAccess {
-            get { return (m_flag & ReflectionPermissionFlag.MemberAccess) != 0; }
-            set { m_flag = value ? m_flag | ReflectionPermissionFlag.MemberAccess : m_flag & ~ReflectionPermissionFlag.MemberAccess; }
-        }
-
-        [Obsolete("This permission is no longer used by the CLR.")]
-        public bool ReflectionEmit {
-#pragma warning disable 618
-            get { return (m_flag & ReflectionPermissionFlag.ReflectionEmit) != 0; }
-            set { m_flag = value ? m_flag | ReflectionPermissionFlag.ReflectionEmit : m_flag & ~ReflectionPermissionFlag.ReflectionEmit; }
-#pragma warning restore 618
-        }
-
-        public bool RestrictedMemberAccess
-        {
-            get { return (m_flag & ReflectionPermissionFlag.RestrictedMemberAccess) != 0; }
-            set { m_flag = value ? m_flag | ReflectionPermissionFlag.RestrictedMemberAccess : m_flag & ~ReflectionPermissionFlag.RestrictedMemberAccess; }
-        }
-
-        public override IPermission CreatePermission()
-        {
-            if (m_unrestricted)
-            {
-                return new ReflectionPermission( PermissionState.Unrestricted );
-            }
-            else
-            {
-                return new ReflectionPermission( m_flag );
-            }
-        }
-    }
-
-    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Assembly, AllowMultiple = true, Inherited = false )] 
-[System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-#pragma warning disable 618
-    sealed public class RegistryPermissionAttribute : CodeAccessSecurityAttribute
-#pragma warning restore 618
-    {
-        private String m_read = null;
-        private String m_write = null;
-        private String m_create = null;
-        private String m_viewAcl = null;
-        private String m_changeAcl = null;
-
-#pragma warning disable 618
-        public RegistryPermissionAttribute( SecurityAction action )
-#pragma warning restore 618
-            : base( action )
-        {
-        }
-
-        public String Read {
-            get { return m_read; }
-            set { m_read = value; }
-        }
-    
-        public String Write {
-            get { return m_write; }
-            set { m_write = value; }
-        }
-
-        public String Create {
-            get { return m_create; }
-            set { m_create = value; }
-        }
-
-        public String ViewAccessControl {
-            get { return m_viewAcl; }
-            set { m_viewAcl = value; }
-        }
-
-        public String ChangeAccessControl {
-            get { return m_changeAcl; }
-            set { m_changeAcl = value; }
-        }
-
-        // Read, Write, & Create, but no ACL's
-        public String ViewAndModify {
-            get { throw new NotSupportedException( Environment.GetResourceString( "NotSupported_GetMethod" ) ); }
-            set { m_read = value; m_write = value; m_create = value; }
-        }
-
-        [Obsolete("Please use the ViewAndModify property instead.")]
-        public String All {
-            get { throw new NotSupportedException( Environment.GetResourceString( "NotSupported_GetMethod" ) ); }
-            set { m_read = value; m_write = value; m_create = value; }
-        }
-
-        public override IPermission CreatePermission()
-        {
-            if (m_unrestricted)
-            {
-                return new RegistryPermission( PermissionState.Unrestricted );
-            }
-            else
-            {
-                RegistryPermission perm = new RegistryPermission(PermissionState.None);
-                if (m_read != null)
-                    perm.SetPathList( RegistryPermissionAccess.Read, m_read );
-                if (m_write != null)
-                    perm.SetPathList( RegistryPermissionAccess.Write, m_write );
-                if (m_create != null)
-                    perm.SetPathList( RegistryPermissionAccess.Create, m_create );
-                return perm;
-            }
-        }
-    }
-
-    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Assembly, AllowMultiple = true, Inherited = false )] 
-    [System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-    // The csharp compiler requires these types to be public, but they are not used elsewhere.
-    [Obsolete("SecurityPermissionAttribute is no longer accessible to application code.")]
-    sealed public class SecurityPermissionAttribute : CodeAccessSecurityAttribute
-    {
-        private SecurityPermissionFlag m_flag = SecurityPermissionFlag.NoFlags;
-    
-        public SecurityPermissionAttribute( SecurityAction action )
-            : base( action )
-        {
-        }
-
-        public SecurityPermissionFlag Flags {
-            get { return m_flag; }
-            set { m_flag = value; }
-        }
-
-        public bool Assertion {
-            get { return (m_flag & SecurityPermissionFlag.Assertion) != 0; }
-            set { m_flag = value ? m_flag | SecurityPermissionFlag.Assertion : m_flag & ~SecurityPermissionFlag.Assertion; }
-        }
-
-        public bool UnmanagedCode {
-            get { return (m_flag & SecurityPermissionFlag.UnmanagedCode) != 0; }
-            set { m_flag = value ? m_flag | SecurityPermissionFlag.UnmanagedCode : m_flag & ~SecurityPermissionFlag.UnmanagedCode; }
-        }
-
-        public bool SkipVerification {
-            get { return (m_flag & SecurityPermissionFlag.SkipVerification) != 0; }
-            set { m_flag = value ? m_flag | SecurityPermissionFlag.SkipVerification : m_flag & ~SecurityPermissionFlag.SkipVerification; }
-        }
-
-        public bool Execution {
-            get { return (m_flag & SecurityPermissionFlag.Execution) != 0; }
-            set { m_flag = value ? m_flag | SecurityPermissionFlag.Execution : m_flag & ~SecurityPermissionFlag.Execution; }
-        }
-
-        public bool ControlThread {
-            get { return (m_flag & SecurityPermissionFlag.ControlThread) != 0; }
-            set { m_flag = value ? m_flag | SecurityPermissionFlag.ControlThread : m_flag & ~SecurityPermissionFlag.ControlThread; }
-        }
-    
-        public bool ControlEvidence {
-            get { return (m_flag & SecurityPermissionFlag.ControlEvidence) != 0; }
-            set { m_flag = value ? m_flag | SecurityPermissionFlag.ControlEvidence : m_flag & ~SecurityPermissionFlag.ControlEvidence; }
-        }
-    
-        public bool ControlPolicy {
-            get { return (m_flag & SecurityPermissionFlag.ControlPolicy) != 0; }
-            set { m_flag = value ? m_flag | SecurityPermissionFlag.ControlPolicy : m_flag & ~SecurityPermissionFlag.ControlPolicy; }
-        }
-    
-        public bool SerializationFormatter {
-            get { return (m_flag & SecurityPermissionFlag.SerializationFormatter) != 0; }
-            set { m_flag = value ? m_flag | SecurityPermissionFlag.SerializationFormatter : m_flag & ~SecurityPermissionFlag.SerializationFormatter; }
-        }
-
-        public bool ControlDomainPolicy {
-            get { return (m_flag & SecurityPermissionFlag.ControlDomainPolicy) != 0; }
-            set { m_flag = value ? m_flag | SecurityPermissionFlag.ControlDomainPolicy : m_flag & ~SecurityPermissionFlag.ControlDomainPolicy; }
-        }
-    
-        public bool ControlPrincipal {
-            get { return (m_flag & SecurityPermissionFlag.ControlPrincipal) != 0; }
-            set { m_flag = value ? m_flag | SecurityPermissionFlag.ControlPrincipal : m_flag & ~SecurityPermissionFlag.ControlPrincipal; }
-        }
-
-        public bool ControlAppDomain {
-            get { return (m_flag & SecurityPermissionFlag.ControlAppDomain) != 0; }
-            set { m_flag = value ? m_flag | SecurityPermissionFlag.ControlAppDomain : m_flag & ~SecurityPermissionFlag.ControlAppDomain; }
-        } 
-
-        public bool RemotingConfiguration {
-            get { return (m_flag & SecurityPermissionFlag.RemotingConfiguration) != 0; }
-            set { m_flag = value ? m_flag | SecurityPermissionFlag.RemotingConfiguration : m_flag & ~SecurityPermissionFlag.RemotingConfiguration; }
-        }
-
-        [System.Runtime.InteropServices.ComVisible(true)]
-        public bool Infrastructure {
-            get { return (m_flag & SecurityPermissionFlag.Infrastructure) != 0; }
-            set { m_flag = value ? m_flag | SecurityPermissionFlag.Infrastructure : m_flag & ~SecurityPermissionFlag.Infrastructure; }
-        }
-    
-        public bool BindingRedirects {
-            get { return (m_flag & SecurityPermissionFlag.BindingRedirects) != 0; }
-            set { m_flag = value ? m_flag | SecurityPermissionFlag.BindingRedirects : m_flag & ~SecurityPermissionFlag.BindingRedirects; }
-        }
-
-        public override IPermission CreatePermission()
-        {
-            if (m_unrestricted)
-            {
-                return new SecurityPermission( PermissionState.Unrestricted );
-            }
-            else
-            {
-                return new SecurityPermission( m_flag );
-            }
-        }
-    }
-
-    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Assembly, AllowMultiple = true, Inherited = false )] 
-[System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-#pragma warning disable 618
-    sealed public class UIPermissionAttribute : CodeAccessSecurityAttribute
-#pragma warning restore 618
-    {
-        private UIPermissionWindow m_windowFlag = UIPermissionWindow.NoWindows;
-        private UIPermissionClipboard m_clipboardFlag = UIPermissionClipboard.NoClipboard;
-    
-#pragma warning disable 618
-        public UIPermissionAttribute( SecurityAction action )
-#pragma warning restore 618
-            : base( action )
-        {
-        }
-
-        public UIPermissionWindow Window {
-            get { return m_windowFlag; }
-            set { m_windowFlag = value; }
-        }
-
-        public UIPermissionClipboard Clipboard {
-            get { return m_clipboardFlag; }
-            set { m_clipboardFlag = value; }
-        }
-    
-        public override IPermission CreatePermission()
-        {
-            if (m_unrestricted)
-            {
-                return new UIPermission( PermissionState.Unrestricted );
-            }
-            else
-            {
-                return new UIPermission( m_windowFlag, m_clipboardFlag );
-            }
-        }
-    }
-
-    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Assembly, AllowMultiple = true, Inherited = false )] 
-[System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-#pragma warning disable 618
-    sealed public class ZoneIdentityPermissionAttribute : CodeAccessSecurityAttribute
-#pragma warning restore 618
-    {
-        private SecurityZone m_flag = SecurityZone.NoZone;
-    
-#pragma warning disable 618
-        public ZoneIdentityPermissionAttribute( SecurityAction action )
-#pragma warning restore 618
-            : base( action )
-        {
-        }
-
-        public SecurityZone Zone {
-            get { return m_flag; }
-            set { m_flag = value; }
-        }
-    
-        public override IPermission CreatePermission()
-        {
-            if (m_unrestricted)
-            {
-                return new ZoneIdentityPermission(PermissionState.Unrestricted);
-            }
-            else
-            {
-                return new ZoneIdentityPermission( m_flag );
-            }
-        }
-    }
-
-    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Assembly, AllowMultiple = true, Inherited = false )] 
-[System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-#pragma warning disable 618
-    sealed public class StrongNameIdentityPermissionAttribute : CodeAccessSecurityAttribute
-#pragma warning restore 618
-    {
-        private String m_name = null;
-        private String m_version = null;
-        private String m_blob = null;
-
-#pragma warning disable 618
-        public StrongNameIdentityPermissionAttribute( SecurityAction action )
-#pragma warning restore 618
-            : base( action )
-        {
-        }
-
-        public String Name
-        {
-            get { return m_name; }
-            set { m_name = value; }
-        }
-        
-        public String Version
-        {
-            get { return m_version; }
-            set { m_version = value; }
-        }
-        
-        public String PublicKey
-        {
-            get { return m_blob; }
-            set { m_blob = value; }
-        }
-
-        public override IPermission CreatePermission()
-        {
-            if (m_unrestricted)
-            {
-                return new StrongNameIdentityPermission( PermissionState.Unrestricted );
-            }
-            else
-            {
-                if (m_blob == null && m_name == null && m_version == null)
-                    return new StrongNameIdentityPermission( PermissionState.None );
-            
-                if (m_blob == null)
-                    throw new ArgumentException( Environment.GetResourceString("ArgumentNull_Key"));
-                    
-                StrongNamePublicKeyBlob blob = new StrongNamePublicKeyBlob( m_blob );
-                
-                if (m_version == null || m_version.Equals(String.Empty))
-                    return new StrongNameIdentityPermission( blob, m_name, null );
-                else    
-                    return new StrongNameIdentityPermission( blob, m_name, new Version( m_version ) );
-            }
-        }
-    }
-
-
-    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Assembly, AllowMultiple = true, Inherited = false )] 
-[System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-#pragma warning disable 618
-    sealed public class SiteIdentityPermissionAttribute : CodeAccessSecurityAttribute
-#pragma warning restore 618
-    {
-        private String m_site = null;
-    
-#pragma warning disable 618
-        public SiteIdentityPermissionAttribute( SecurityAction action )
-#pragma warning restore 618
-            : base( action )
-        {
-        }
-
-        public String Site {
-            get { return m_site; }
-            set { m_site = value; }
-        }
-    
-        public override IPermission CreatePermission()
-        {
-            if (m_unrestricted)
-            {
-                return new SiteIdentityPermission( PermissionState.Unrestricted );
-            }
-            else
-            {
-                if (m_site == null)
-                    return new SiteIdentityPermission( PermissionState.None );
-            
-                return new SiteIdentityPermission( m_site );
-            }
-        }
-    }
-
-    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Assembly, AllowMultiple = true, Inherited = false )] 
-[System.Runtime.InteropServices.ComVisible(true)]
-#pragma warning disable 618
-    [Serializable] sealed public class UrlIdentityPermissionAttribute : CodeAccessSecurityAttribute
-#pragma warning restore 618
-    {
-        private String m_url = null;
-    
-#pragma warning disable 618
-        public UrlIdentityPermissionAttribute( SecurityAction action )
-#pragma warning restore 618
-            : base( action )
-        {
-        }
-
-        public String Url {
-            get { return m_url; }
-            set { m_url = value; }
-        }
-    
-        public override IPermission CreatePermission()
-        {
-            if (m_unrestricted)
-            {
-                return new UrlIdentityPermission( PermissionState.Unrestricted );
-            }
-            else
-            {
-                if (m_url == null)
-                    return new UrlIdentityPermission( PermissionState.None );
-                    
-                return new UrlIdentityPermission( m_url );
-            }
-        }
-    }
-
-    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Assembly, AllowMultiple = true, Inherited = false )] 
-[System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-#pragma warning disable 618
-    sealed public class PermissionSetAttribute : CodeAccessSecurityAttribute
-#pragma warning restore 618
-    {
-        private String m_file;
-        private String m_name;
-        private bool m_unicode;
-        private String m_xml;
-        private String m_hex;
-
-#pragma warning disable 618
-        public PermissionSetAttribute( SecurityAction action )
-#pragma warning restore 618
-            : base( action )
-        {
-            m_unicode = false;
-        }
-
-        public String File {
-            get { return m_file; }
-            set { m_file = value; }
-        }
-    
-        public bool UnicodeEncoded {
-            get { return m_unicode; }
-            set { m_unicode = value; }
-        }
-        
-        public String Name {
-            get { return m_name; }
-            set { m_name = value; }
-        }
-        
-        public String XML {
-            get { return m_xml; }
-            set { m_xml = value; }
-        }       
-
-        public String Hex {
-            get { return m_hex; }
-            set { m_hex = value; }
-        }
-
-        public override IPermission CreatePermission()
-        {
-            return null;
-        }
-
-        public PermissionSet CreatePermissionSet()
-        {
-            if (m_unrestricted)
-                return new PermissionSet( PermissionState.Unrestricted );
-            else if (m_name != null)
-                return NamedPermissionSet.GetBuiltInSet( m_name );
-            else
-                return new PermissionSet( PermissionState.None );
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Permissions/PermissionState.cs b/src/mscorlib/src/System/Security/Permissions/PermissionState.cs
deleted file mode 100644
index ea0f1a0ac2..0000000000
--- a/src/mscorlib/src/System/Security/Permissions/PermissionState.cs
+++ /dev/null
@@ -1,21 +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.
-
-//
-//  The Runtime policy manager.  Maintains a set of IdentityMapper objects that map 
-//  inbound evidence to groups.  Resolves an identity into a set of permissions
-//
-
-namespace System.Security.Permissions {
-    
-    using System;
-    [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public enum PermissionState
-    {
-        Unrestricted = 1,
-        None = 0,
-    } 
-    
-}
diff --git a/src/mscorlib/src/System/Security/Permissions/ReflectionPermission.cs b/src/mscorlib/src/System/Security/Permissions/ReflectionPermission.cs
deleted file mode 100644
index 1c9dd7696c..0000000000
--- a/src/mscorlib/src/System/Security/Permissions/ReflectionPermission.cs
+++ /dev/null
@@ -1,274 +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.
-
-namespace System.Security.Permissions
-{
-    using System;
-    using System.IO;
-    using System.Security.Util;
-    using System.Text;
-    using System.Runtime.InteropServices;
-    using System.Runtime.Remoting;
-    using System.Security;
-    using System.Reflection;
-    using System.Globalization;
-    using System.Diagnostics.Contracts;
-
-    [ComVisible(true)]
-    [Flags]
-    [Serializable]
-    public enum ReflectionPermissionFlag
-    {
-        NoFlags = 0x00,
-        [Obsolete("This API has been deprecated. http://go.microsoft.com/fwlink/?linkid=14202")]
-        TypeInformation = 0x01,
-        MemberAccess = 0x02,
-        [Obsolete("This permission is no longer used by the CLR.")]
-        ReflectionEmit = 0x04,
-        [ComVisible(false)]
-        RestrictedMemberAccess = 0x08,
-        [Obsolete("This permission has been deprecated. Use PermissionState.Unrestricted to get full access.")]
-        AllFlags = 0x07
-    }
-
-    [ComVisible(true)]
-    [Serializable]
-    sealed public class ReflectionPermission
-           : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission
-    {
-        // ReflectionPermissionFlag.AllFlags doesn't contain the new value RestrictedMemberAccess,
-        // but we cannot change its value now because that will break apps that have that old value baked in. 
-        // We should use this const that truely contains "all" flags instead of ReflectionPermissionFlag.AllFlags.
-#pragma warning disable 618
-        internal const ReflectionPermissionFlag AllFlagsAndMore = ReflectionPermissionFlag.AllFlags | ReflectionPermissionFlag.RestrictedMemberAccess;
-#pragma warning restore 618
-
-        private ReflectionPermissionFlag m_flags;
-
-        //
-        // Public Constructors
-        //
-        
-        public ReflectionPermission(PermissionState state)
-        {
-            if (state == PermissionState.Unrestricted)
-            {
-                SetUnrestricted( true );
-            }
-            else if (state == PermissionState.None)
-            {
-                SetUnrestricted( false );
-            }
-            else
-            {
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
-            }
-        }    
-        
-         // Parameters:
-         //
-        public ReflectionPermission(ReflectionPermissionFlag flag)
-        {
-            VerifyAccess(flag);
-            
-            SetUnrestricted(false);
-            m_flags = flag;
-        }
-    
-        //------------------------------------------------------
-        //
-        // PRIVATE AND PROTECTED MODIFIERS 
-        //
-        //------------------------------------------------------
-        
-        
-        private void SetUnrestricted(bool unrestricted)
-        {
-            if (unrestricted)
-            {
-                m_flags = ReflectionPermission.AllFlagsAndMore;
-            }
-            else
-            {
-                Reset();
-            }
-        }
-        
-        
-        private void Reset()
-        {
-            m_flags = ReflectionPermissionFlag.NoFlags;
-        }    
-        
-     
-        public ReflectionPermissionFlag Flags
-        {
-            set
-            {
-                VerifyAccess(value);
-            
-                m_flags = value;
-            }
-            
-            get
-            {
-                return m_flags;
-            }
-        }
-        
-            
-    #if ZERO   // Do not remove this code, useful for debugging
-        public override String ToString()
-        {
-            StringBuilder sb = new StringBuilder();
-            sb.Append("ReflectionPermission(");
-            if (IsUnrestricted())
-            {
-                sb.Append("Unrestricted");
-            }
-            else
-            {
-                if (GetFlag(ReflectionPermissionFlag.TypeInformation))
-                    sb.Append("TypeInformation; ");
-                if (GetFlag(ReflectionPermissionFlag.MemberAccess))
-                    sb.Append("MemberAccess; ");
-#pragma warning disable 618
-                if (GetFlag(ReflectionPermissionFlag.ReflectionEmit))
-                    sb.Append("ReflectionEmit; ");
-#pragma warning restore 618
-            }
-            
-            sb.Append(")");
-            return sb.ToString();
-        }
-    #endif
-    
-    
-        //
-        // CodeAccessPermission implementation
-        //
-        
-        public bool IsUnrestricted()
-        {
-            return m_flags == ReflectionPermission.AllFlagsAndMore;
-        }
-        
-        //
-        // IPermission implementation
-        //
-        
-        public override IPermission Union(IPermission other)
-        {
-            if (other == null)
-            {
-                return this.Copy();
-            }
-            else if (!VerifyType(other))
-            {
-                throw new 
-                    ArgumentException(
-                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
-                                     );
-            }
-            
-            ReflectionPermission operand = (ReflectionPermission)other;
-    
-            if (this.IsUnrestricted() || operand.IsUnrestricted())
-            {
-                return new ReflectionPermission( PermissionState.Unrestricted );
-            }
-            else
-            {
-                ReflectionPermissionFlag flag_union = (ReflectionPermissionFlag)(m_flags | operand.m_flags);
-                return(new ReflectionPermission(flag_union));
-            }
-        }  
-        
-        
-        
-        public override bool IsSubsetOf(IPermission target)
-        {
-            if (target == null)
-            {
-                return m_flags == ReflectionPermissionFlag.NoFlags;
-            }
-
-            try
-            {
-                ReflectionPermission operand = (ReflectionPermission)target;
-                if (operand.IsUnrestricted())
-                    return true;
-                else if (this.IsUnrestricted())
-                    return false;
-                else
-                    return (((int)this.m_flags) & ~((int)operand.m_flags)) == 0;
-            }
-            catch (InvalidCastException)
-            {
-                throw new 
-                    ArgumentException(
-                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
-                                     );
-            }                
-
-        }
-        
-        public override IPermission Intersect(IPermission target)
-        {
-            if (target == null)
-                return null;
-            else if (!VerifyType(target))
-            {
-                throw new 
-                    ArgumentException(
-                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
-                                     );
-            }
-
-            ReflectionPermission operand = (ReflectionPermission)target;
-
-            ReflectionPermissionFlag newFlags = operand.m_flags & this.m_flags;
-            
-            if (newFlags == ReflectionPermissionFlag.NoFlags)
-                return null;
-            else
-                return new ReflectionPermission( newFlags );
-        }
-    
-        public override IPermission Copy()
-        {
-            if (this.IsUnrestricted())
-            {
-                return new ReflectionPermission(PermissionState.Unrestricted);
-            }
-            else
-            {
-                return new ReflectionPermission((ReflectionPermissionFlag)m_flags);
-            }
-        }
-        
-        
-        //
-        // IEncodable Interface 
-    
-        private
-        void VerifyAccess(ReflectionPermissionFlag type)
-        {
-            if ((type & ~ReflectionPermission.AllFlagsAndMore) != 0)
-                throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)type));
-            Contract.EndContractBlock();
-        }
-
-        /// <internalonly/>
-        int IBuiltInPermission.GetTokenIndex()
-        {
-            return ReflectionPermission.GetTokenIndex();
-        }
-
-        internal static int GetTokenIndex()
-        {
-            return BuiltInPermissionIndex.ReflectionPermissionIndex;
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Permissions/RegistryPermission.cs b/src/mscorlib/src/System/Security/Permissions/RegistryPermission.cs
deleted file mode 100644
index c0c51e94a2..0000000000
--- a/src/mscorlib/src/System/Security/Permissions/RegistryPermission.cs
+++ /dev/null
@@ -1,363 +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.
-
-namespace System.Security.Permissions
-{
-    using System;
-    using SecurityElement = System.Security.SecurityElement;
-    using System.Security.AccessControl;
-    using System.Security.Util;
-    using System.IO;
-    using System.Globalization;
-    using System.Runtime.Serialization;
-
-[Serializable]
-    [Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public enum RegistryPermissionAccess
-    {
-        NoAccess = 0x00,
-        Read = 0x01,
-        Write = 0x02,
-        Create = 0x04,
-        AllAccess = 0x07,
-    }
-    
-[System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-    sealed public class RegistryPermission : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission
-    {
-        private StringExpressionSet m_read;
-        private StringExpressionSet m_write;
-        private StringExpressionSet m_create;
-        [OptionalField(VersionAdded = 2)]
-        private StringExpressionSet m_viewAcl;
-        [OptionalField(VersionAdded = 2)]
-        private StringExpressionSet m_changeAcl;
-        private bool m_unrestricted;
-    
-
-        public RegistryPermission(PermissionState state)
-        {
-            if (state == PermissionState.Unrestricted)
-            {
-                m_unrestricted = true;
-            }
-            else if (state == PermissionState.None)
-            {
-                m_unrestricted = false;
-            }
-            else
-            {
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
-            }
-        }
-        
-        public RegistryPermission( RegistryPermissionAccess access, String pathList )
-        {
-            SetPathList( access, pathList );
-        }
-
-        public void SetPathList( RegistryPermissionAccess access, String pathList )
-        {
-            VerifyAccess( access );
-
-            m_unrestricted = false;
-
-            if ((access & RegistryPermissionAccess.Read) != 0)
-                m_read = null;
-            
-            if ((access & RegistryPermissionAccess.Write) != 0)
-                m_write = null;
-    
-            if ((access & RegistryPermissionAccess.Create) != 0)
-                m_create = null;
-            
-            AddPathList( access, pathList );
-        }
-
-        public void AddPathList( RegistryPermissionAccess access, String pathList )
-        {
-            AddPathList( access, AccessControlActions.None, pathList );
-        }
-
-        public void AddPathList( RegistryPermissionAccess access, AccessControlActions control, String pathList )
-        {
-            VerifyAccess( access );
-            
-            if ((access & RegistryPermissionAccess.Read) != 0)
-            {
-                if (m_read == null)
-                    m_read = new StringExpressionSet();
-                m_read.AddExpressions( pathList );
-            }
-            
-            if ((access & RegistryPermissionAccess.Write) != 0)
-            {
-                if (m_write == null)
-                    m_write = new StringExpressionSet();
-                m_write.AddExpressions( pathList );
-            }
-    
-            if ((access & RegistryPermissionAccess.Create) != 0)
-            {
-                if (m_create == null)
-                    m_create = new StringExpressionSet();
-                m_create.AddExpressions( pathList );
-            }
-        }
-    
-        public String GetPathList( RegistryPermissionAccess access )
-        {
-            // SafeCritical: these are registry paths, which means we're not leaking file system information here
-            VerifyAccess( access );
-            ExclusiveAccess( access );
-    
-            if ((access & RegistryPermissionAccess.Read) != 0)
-            {
-                if (m_read == null)
-                {
-                    return "";
-                }
-                return m_read.UnsafeToString();
-            }
-            
-            if ((access & RegistryPermissionAccess.Write) != 0)
-            {
-                if (m_write == null)
-                {
-                    return "";
-                }
-                return m_write.UnsafeToString();
-            }
-    
-            if ((access & RegistryPermissionAccess.Create) != 0)
-            {
-                if (m_create == null)
-                {
-                    return "";
-                }
-                return m_create.UnsafeToString();
-            }
-            
-            /* not reached */
-            
-            return "";
-        }     
-        
-        private void VerifyAccess( RegistryPermissionAccess access )
-        {
-            if ((access & ~RegistryPermissionAccess.AllAccess) != 0)
-                throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)access));
-        }
-        
-        private void ExclusiveAccess( RegistryPermissionAccess access )
-        {
-            if (access == RegistryPermissionAccess.NoAccess)
-            {
-                throw new ArgumentException( Environment.GetResourceString("Arg_EnumNotSingleFlag") ); 
-            }
-    
-            if (((int) access & ((int)access-1)) != 0)
-            {
-                throw new ArgumentException( Environment.GetResourceString("Arg_EnumNotSingleFlag") ); 
-            }
-        }
-        
-        private bool IsEmpty()
-        {
-            return (!m_unrestricted &&
-                    (this.m_read == null || this.m_read.IsEmpty()) &&
-                    (this.m_write == null || this.m_write.IsEmpty()) &&
-                    (this.m_create == null || this.m_create.IsEmpty()) &&
-                    (this.m_viewAcl == null || this.m_viewAcl.IsEmpty()) &&
-                    (this.m_changeAcl == null || this.m_changeAcl.IsEmpty()));
-        }
-        
-        //------------------------------------------------------
-        //
-        // CODEACCESSPERMISSION IMPLEMENTATION
-        //
-        //------------------------------------------------------
-        
-        public bool IsUnrestricted()
-        {
-            return m_unrestricted;
-        }
-        
-        //------------------------------------------------------
-        //
-        // IPERMISSION IMPLEMENTATION
-        //
-        //------------------------------------------------------
-        
-        public override bool IsSubsetOf(IPermission target)
-        {
-            if (target == null)
-            {
-                return this.IsEmpty();
-            }
-
-            RegistryPermission operand = target as RegistryPermission;
-            if (operand == null)
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-
-            if (operand.IsUnrestricted())
-                return true;
-            else if (this.IsUnrestricted())
-                return false;
-            else
-                return ((this.m_read == null || this.m_read.IsSubsetOf( operand.m_read )) &&
-                        (this.m_write == null || this.m_write.IsSubsetOf( operand.m_write )) &&
-                        (this.m_create == null || this.m_create.IsSubsetOf( operand.m_create )) &&
-                        (this.m_viewAcl == null || this.m_viewAcl.IsSubsetOf( operand.m_viewAcl )) &&
-                        (this.m_changeAcl == null || this.m_changeAcl.IsSubsetOf( operand.m_changeAcl )));
-        }
-        
-        public override IPermission Intersect(IPermission target)
-        {
-            if (target == null)
-            {
-                return null;
-            }
-            else if (!VerifyType(target))
-            {
-                throw new 
-                    ArgumentException(
-                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
-                                     );
-            }
-            else if (this.IsUnrestricted())
-            {
-                return target.Copy();
-            }
-            
-            RegistryPermission operand = (RegistryPermission)target;
-            if (operand.IsUnrestricted())
-            {
-                return this.Copy();
-            }
-            
-            
-            StringExpressionSet intersectRead = this.m_read == null ? null : this.m_read.Intersect( operand.m_read );
-            StringExpressionSet intersectWrite = this.m_write == null ? null : this.m_write.Intersect( operand.m_write );
-            StringExpressionSet intersectCreate = this.m_create == null ? null : this.m_create.Intersect( operand.m_create );
-            StringExpressionSet intersectViewAcl = this.m_viewAcl == null ? null : this.m_viewAcl.Intersect( operand.m_viewAcl );
-            StringExpressionSet intersectChangeAcl = this.m_changeAcl == null ? null : this.m_changeAcl.Intersect( operand.m_changeAcl );
-            
-            if ((intersectRead == null || intersectRead.IsEmpty()) &&
-                (intersectWrite == null || intersectWrite.IsEmpty()) &&
-                (intersectCreate == null || intersectCreate.IsEmpty()) &&
-                (intersectViewAcl == null || intersectViewAcl.IsEmpty()) &&
-                (intersectChangeAcl == null || intersectChangeAcl.IsEmpty()))
-            {
-                return null;
-            }
-            
-            RegistryPermission intersectPermission = new RegistryPermission(PermissionState.None);
-            intersectPermission.m_unrestricted = false;
-            intersectPermission.m_read = intersectRead;
-            intersectPermission.m_write = intersectWrite;
-            intersectPermission.m_create = intersectCreate;
-            intersectPermission.m_viewAcl = intersectViewAcl;
-            intersectPermission.m_changeAcl = intersectChangeAcl;
-            
-            return intersectPermission;
-        }
-        
-        public override IPermission Union(IPermission other)
-        {
-            if (other == null)
-            {
-                return this.Copy();
-            }
-            else if (!VerifyType(other))
-            {
-                throw new 
-                    ArgumentException(
-                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
-                                     );
-            }
-            
-            RegistryPermission operand = (RegistryPermission)other;
-            
-            if (this.IsUnrestricted() || operand.IsUnrestricted())
-            {
-                return new RegistryPermission( PermissionState.Unrestricted );
-            }
-    
-            StringExpressionSet unionRead = this.m_read == null ? operand.m_read : this.m_read.Union( operand.m_read );
-            StringExpressionSet unionWrite = this.m_write == null ? operand.m_write : this.m_write.Union( operand.m_write );
-            StringExpressionSet unionCreate = this.m_create == null ? operand.m_create : this.m_create.Union( operand.m_create );
-            StringExpressionSet unionViewAcl = this.m_viewAcl == null ? operand.m_viewAcl : this.m_viewAcl.Union( operand.m_viewAcl );
-            StringExpressionSet unionChangeAcl = this.m_changeAcl == null ? operand.m_changeAcl : this.m_changeAcl.Union( operand.m_changeAcl );
-            
-            if ((unionRead == null || unionRead.IsEmpty()) &&
-                (unionWrite == null || unionWrite.IsEmpty()) &&
-                (unionCreate == null || unionCreate.IsEmpty()) &&
-                (unionViewAcl == null || unionViewAcl.IsEmpty()) &&
-                (unionChangeAcl == null || unionChangeAcl.IsEmpty()))
-            {
-                return null;
-            }
-            
-            RegistryPermission unionPermission = new RegistryPermission(PermissionState.None);
-            unionPermission.m_unrestricted = false;
-            unionPermission.m_read = unionRead;
-            unionPermission.m_write = unionWrite;
-            unionPermission.m_create = unionCreate;
-            unionPermission.m_viewAcl = unionViewAcl;
-            unionPermission.m_changeAcl = unionChangeAcl;
-            
-            return unionPermission;
-        }
-            
-        
-        public override IPermission Copy()
-        {
-            RegistryPermission copy = new RegistryPermission(PermissionState.None);
-            if (this.m_unrestricted)
-            {
-                copy.m_unrestricted = true;
-            }
-            else
-            {
-                copy.m_unrestricted = false;
-                if (this.m_read != null)
-                {
-                    copy.m_read = this.m_read.Copy();
-                }
-                if (this.m_write != null)
-                {
-                    copy.m_write = this.m_write.Copy();
-                }
-                if (this.m_create != null)
-                {
-                    copy.m_create = this.m_create.Copy();
-                }
-                if (this.m_viewAcl != null)
-                {
-                    copy.m_viewAcl = this.m_viewAcl.Copy();
-                }
-                if (this.m_changeAcl != null)
-                {
-                    copy.m_changeAcl = this.m_changeAcl.Copy();
-                }
-            }
-            return copy;   
-        }
-
-        /// <internalonly/>
-        int IBuiltInPermission.GetTokenIndex()
-        {
-            return RegistryPermission.GetTokenIndex();
-        }
-
-        internal static int GetTokenIndex()
-        {
-            return BuiltInPermissionIndex.RegistryPermissionIndex;
-        }
-
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Permissions/SecurityPermission.cs b/src/mscorlib/src/System/Security/Permissions/SecurityPermission.cs
deleted file mode 100644
index cf3002989d..0000000000
--- a/src/mscorlib/src/System/Security/Permissions/SecurityPermission.cs
+++ /dev/null
@@ -1,270 +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.
-
-namespace System.Security.Permissions
-{
-    using System;
-    using System.IO;
-    using System.Security.Util;
-    using System.Text;
-    using System.Threading;
-    using System.Runtime.Remoting;
-    using System.Security;
-    using System.Runtime.Serialization;
-    using System.Reflection;
-    using System.Globalization;
-    using System.Diagnostics.Contracts;
-
-    [Serializable]
-    [Flags]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    // The csharp compiler requires these types to be public, but they are not used elsewhere.
-    [Obsolete("SecurityPermissionFlag is no longer accessible to application code.")]
-    public enum SecurityPermissionFlag
-    {
-        NoFlags = 0x00,
-        /* The following enum value is used in the EE (ASSERT_PERMISSION in security.cpp)
-         * Should this value change, make corresponding changes there
-         */ 
-        Assertion = 0x01,
-        UnmanagedCode = 0x02,       // Update vm\Security.h if you change this !
-        SkipVerification = 0x04,    // Update vm\Security.h if you change this !
-        Execution = 0x08,
-        ControlThread = 0x10,
-        ControlEvidence = 0x20,
-        ControlPolicy = 0x40,
-        SerializationFormatter = 0x80,
-        ControlDomainPolicy = 0x100,
-        ControlPrincipal = 0x200,
-        ControlAppDomain = 0x400,
-        RemotingConfiguration = 0x800,
-        Infrastructure = 0x1000,
-        BindingRedirects = 0x2000,
-        AllFlags = 0x3fff,
-    }
-
-[System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-    sealed public class SecurityPermission 
-           : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission
-    {
-#pragma warning disable 618
-        private SecurityPermissionFlag m_flags;
-#pragma warning restore 618
-        
-        //
-        // Public Constructors
-        //
-    
-        public SecurityPermission(PermissionState state)
-        {
-            if (state == PermissionState.Unrestricted)
-            {
-                SetUnrestricted( true );
-            }
-            else if (state == PermissionState.None)
-            {
-                SetUnrestricted( false );
-                Reset();
-            }
-            else
-            {
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
-            }
-        }
-        
-        
-        // SecurityPermission
-        //
-#pragma warning disable 618
-        public SecurityPermission(SecurityPermissionFlag flag)
-#pragma warning restore 618
-        {
-            VerifyAccess(flag);
-            
-            SetUnrestricted(false);
-            m_flags = flag;
-        }
-    
-    
-        //------------------------------------------------------
-        //
-        // PRIVATE AND PROTECTED MODIFIERS 
-        //
-        //------------------------------------------------------
-        
-        
-        private void SetUnrestricted(bool unrestricted)
-        {
-            if (unrestricted)
-            {
-#pragma warning disable 618
-                m_flags = SecurityPermissionFlag.AllFlags;
-#pragma warning restore 618
-            }
-        }
-    
-        private void Reset()
-        {
-#pragma warning disable 618
-            m_flags = SecurityPermissionFlag.NoFlags;
-#pragma warning restore 618
-        }
-        
-        
-#pragma warning disable 618
-        public SecurityPermissionFlag Flags
-#pragma warning restore 618
-        {
-            set
-            {
-                VerifyAccess(value);
-            
-                m_flags = value;
-            }
-            
-            get
-            {
-                return m_flags;
-            }
-        }
-        
-        //
-        // CodeAccessPermission methods
-        // 
-        
-       /*
-         * IPermission interface implementation
-         */
-         
-        public override bool IsSubsetOf(IPermission target)
-        {
-            if (target == null)
-            {
-                return m_flags == 0;
-            }
-        
-            SecurityPermission operand = target as SecurityPermission;
-            if (operand != null)
-            {
-                return (((int)this.m_flags) & ~((int)operand.m_flags)) == 0;
-            }
-            else
-            {
-                throw new 
-                    ArgumentException(
-                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
-                                     );
-            }
-
-        }
-        
-        public override IPermission Union(IPermission target) {
-            if (target == null) return(this.Copy());
-            if (!VerifyType(target)) {
-                throw new 
-                    ArgumentException(
-                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
-                                     );
-            }
-            SecurityPermission sp_target = (SecurityPermission) target;
-            if (sp_target.IsUnrestricted() || IsUnrestricted()) {
-                return(new SecurityPermission(PermissionState.Unrestricted));
-            }
-#pragma warning disable 618
-            SecurityPermissionFlag flag_union = (SecurityPermissionFlag)(m_flags | sp_target.m_flags);
-#pragma warning restore 618
-            return(new SecurityPermission(flag_union));
-        }
-    
-        public override IPermission Intersect(IPermission target)
-        {
-            if (target == null)
-                return null;
-            else if (!VerifyType(target))
-            {
-                throw new 
-                    ArgumentException(
-                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
-                                     );
-            }
-            
-            SecurityPermission operand = (SecurityPermission)target;
-#pragma warning disable 618
-            SecurityPermissionFlag isectFlags = SecurityPermissionFlag.NoFlags;
-#pragma warning restore 618
-           
-            if (operand.IsUnrestricted())
-            {
-                if (this.IsUnrestricted())
-                    return new SecurityPermission(PermissionState.Unrestricted);
-                else
-#pragma warning disable 618
-                    isectFlags = (SecurityPermissionFlag)this.m_flags;
-#pragma warning restore 618
-            }
-            else if (this.IsUnrestricted())
-            {
-#pragma warning disable 618
-                isectFlags = (SecurityPermissionFlag)operand.m_flags;
-#pragma warning restore 618
-            }
-            else
-            {
-#pragma warning disable 618
-                isectFlags = (SecurityPermissionFlag)m_flags & (SecurityPermissionFlag)operand.m_flags;
-#pragma warning restore 618
-            }
-            
-            if (isectFlags == 0)
-                return null;
-            else
-                return new SecurityPermission(isectFlags);
-        }
-    
-        public override IPermission Copy()
-        {
-            if (IsUnrestricted())
-                return new SecurityPermission(PermissionState.Unrestricted);
-            else
-#pragma warning disable 618
-                return new SecurityPermission((SecurityPermissionFlag)m_flags);
-#pragma warning restore 618
-        }
-    
-        public bool IsUnrestricted()
-        {
-#pragma warning disable 618
-            return m_flags == SecurityPermissionFlag.AllFlags;
-#pragma warning restore 618
-        }
-        
-        private
-#pragma warning disable 618
-        void VerifyAccess(SecurityPermissionFlag type)
-#pragma warning restore 618
-        {
-#pragma warning disable 618
-            if ((type & ~SecurityPermissionFlag.AllFlags) != 0)
-#pragma warning restore 618
-                throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)type));
-            Contract.EndContractBlock();
-        }
-
-        //
-        // Object Overrides
-        //
-
-        /// <internalonly/>
-        int IBuiltInPermission.GetTokenIndex()
-        {
-            return SecurityPermission.GetTokenIndex();
-        }
-
-        internal static int GetTokenIndex()
-        {
-            return BuiltInPermissionIndex.SecurityPermissionIndex;
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Permissions/SiteIdentityPermission.cs b/src/mscorlib/src/System/Security/Permissions/SiteIdentityPermission.cs
deleted file mode 100644
index 3b31d37483..0000000000
--- a/src/mscorlib/src/System/Security/Permissions/SiteIdentityPermission.cs
+++ /dev/null
@@ -1,248 +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.
-
-namespace System.Security.Permissions
-{
-    using System;
-    using SiteString = System.Security.Util.SiteString;
-    using System.Text;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Globalization;
-    using System.Runtime.Serialization;
-
-    [System.Runtime.InteropServices.ComVisible(true)]
-    sealed public class SiteIdentityPermission : CodeAccessPermission, IBuiltInPermission
-    {
-        //------------------------------------------------------
-        //
-        // PRIVATE STATE DATA
-        //
-        //------------------------------------------------------
-        [OptionalField(VersionAdded = 2)]
-        private bool m_unrestricted;
-        [OptionalField(VersionAdded = 2)]        
-        private SiteString[] m_sites;
-
-        //------------------------------------------------------
-        //
-        // PUBLIC CONSTRUCTORS
-        //
-        //------------------------------------------------------
-        
-       
-        public SiteIdentityPermission(PermissionState state)
-        {
-            if (state == PermissionState.Unrestricted)
-            {
-                m_unrestricted = true;
-            }
-            else if (state == PermissionState.None)
-            {
-                m_unrestricted = false;
-            }
-            else
-            {
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
-            }
-        }
-        
-        public SiteIdentityPermission( String site )
-        {
-            Site = site;
-        }
-        
-        //------------------------------------------------------
-        //
-        // PUBLIC ACCESSOR METHODS
-        //
-        //------------------------------------------------------
-
-        public String Site
-        {
-            set
-            {
-                m_unrestricted = false;
-                m_sites = new SiteString[1];
-                m_sites[0] = new SiteString( value );
-            }
-
-            get
-            {
-                if(m_sites == null)
-                    return "";
-                if(m_sites.Length == 1)
-                    return m_sites[0].ToString();
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_AmbiguousIdentity"));
-            }
-        } 
-
-        //------------------------------------------------------
-        //
-        // PRIVATE AND PROTECTED HELPERS FOR ACCESSORS AND CONSTRUCTORS
-        //
-        //------------------------------------------------------
-
-        //------------------------------------------------------
-        //
-        // CODEACCESSPERMISSION IMPLEMENTATION
-        //
-        //------------------------------------------------------
-
-        //------------------------------------------------------
-        //
-        // IPERMISSION IMPLEMENTATION
-        //
-        //------------------------------------------------------
-        public override IPermission Copy()
-        {
-            SiteIdentityPermission perm = new SiteIdentityPermission( PermissionState.None );
-            perm.m_unrestricted = this.m_unrestricted;
-            if (this.m_sites != null)
-            {
-                perm.m_sites = new SiteString[this.m_sites.Length];
-                int n;
-                for(n = 0; n < this.m_sites.Length; n++)
-                    perm.m_sites[n] = (SiteString)this.m_sites[n].Copy();
-            }
-            return perm;
-        }
-        
-        public override bool IsSubsetOf(IPermission target)
-        {
-            if (target == null)
-            {
-                if(m_unrestricted)
-                    return false;
-                if(m_sites == null)
-                    return true;
-                if(m_sites.Length == 0)
-                    return true;
-                return false;
-            }
-            SiteIdentityPermission that = target as SiteIdentityPermission;
-            if(that == null)
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-            if(that.m_unrestricted)
-                return true;
-            if(m_unrestricted)
-                return false;
-            if(this.m_sites != null)
-            {
-                foreach(SiteString ssThis in this.m_sites)
-                {
-                    bool bOK = false;
-                    if(that.m_sites != null)
-                    {
-                        foreach(SiteString ssThat in that.m_sites)
-                        {
-                            if(ssThis.IsSubsetOf(ssThat))
-                            {
-                                bOK = true;
-                                break;
-                            }
-                        }
-                    }
-                    if(!bOK)
-                        return false;           
-                }
-            }
-            return true;
-        }
-        
-        public override IPermission Intersect(IPermission target)
-        {
-            if (target == null)
-                return null;
-            SiteIdentityPermission that = target as SiteIdentityPermission;
-            if(that == null)
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-            if(this.m_unrestricted && that.m_unrestricted)
-            {
-                SiteIdentityPermission res = new SiteIdentityPermission(PermissionState.None);
-                res.m_unrestricted = true;
-                return res;
-            }
-            if(this.m_unrestricted)
-                return that.Copy();
-            if(that.m_unrestricted)
-                return this.Copy();
-            if(this.m_sites == null || that.m_sites == null || this.m_sites.Length == 0 || that.m_sites.Length == 0)
-                return null;
-            List<SiteString> alSites = new List<SiteString>();
-            foreach(SiteString ssThis in this.m_sites)
-            {
-                foreach(SiteString ssThat in that.m_sites)
-                {
-                    SiteString ssInt = (SiteString)ssThis.Intersect(ssThat);
-                    if(ssInt != null)
-                        alSites.Add(ssInt);
-                }
-            }
-            if(alSites.Count == 0)
-                return null;
-            SiteIdentityPermission result = new SiteIdentityPermission(PermissionState.None);
-            result.m_sites = alSites.ToArray();
-            return result;
-        }
-        
-        public override IPermission Union(IPermission target)
-        {
-            if (target == null)
-            {
-                if((this.m_sites == null || this.m_sites.Length == 0) && !this.m_unrestricted)
-                    return null;
-                return this.Copy();
-            }
-            SiteIdentityPermission that = target as SiteIdentityPermission;
-            if(that == null)
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-            if(this.m_unrestricted || that.m_unrestricted)
-            {
-                SiteIdentityPermission res = new SiteIdentityPermission(PermissionState.None);
-                res.m_unrestricted = true;
-                return res;
-            }
-            if (this.m_sites == null || this.m_sites.Length == 0)
-            {
-                if(that.m_sites == null || that.m_sites.Length == 0)
-                    return null;
-                return that.Copy();
-            }
-            if(that.m_sites == null || that.m_sites.Length == 0)
-                return this.Copy();
-            List<SiteString> alSites = new List<SiteString>();
-            foreach(SiteString ssThis in this.m_sites)
-                alSites.Add(ssThis);
-            foreach(SiteString ssThat in that.m_sites)
-            {
-                bool bDupe = false;
-                foreach(SiteString ss in alSites)
-                {
-                    if(ssThat.Equals(ss))
-                    {
-                        bDupe = true;
-                        break;
-                    }
-                }
-                if(!bDupe)
-                    alSites.Add(ssThat);
-            }
-            SiteIdentityPermission result = new SiteIdentityPermission(PermissionState.None);
-            result.m_sites = alSites.ToArray();
-            return result;
-        }
-
-        /// <internalonly/>
-        int IBuiltInPermission.GetTokenIndex()
-        {
-            return SiteIdentityPermission.GetTokenIndex();
-        }
-
-        internal static int GetTokenIndex()
-        {
-            return BuiltInPermissionIndex.SiteIdentityPermissionIndex;
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Permissions/StrongNameIdentityPermission.cs b/src/mscorlib/src/System/Security/Permissions/StrongNameIdentityPermission.cs
deleted file mode 100644
index f09d84de34..0000000000
--- a/src/mscorlib/src/System/Security/Permissions/StrongNameIdentityPermission.cs
+++ /dev/null
@@ -1,401 +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.
-
-namespace System.Security.Permissions
-{
-    using System;
-    using System.Security.Util;
-    using System.IO;
-    using String = System.String;
-    using Version = System.Version;
-    using System.Security.Policy;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Globalization;
-    using System.Diagnostics.Contracts;
-
-    // The only difference between this class and System.Security.Policy.StrongName is that this one
-    // allows m_name to be null.  We should merge this class with System.Security.Policy.StrongName
-    [Serializable]
-    sealed internal class StrongName2
-    {
-        public StrongNamePublicKeyBlob m_publicKeyBlob;
-        public String m_name;
-        public Version m_version;
-
-        public StrongName2(StrongNamePublicKeyBlob publicKeyBlob, String name, Version version)
-        {
-            m_publicKeyBlob = publicKeyBlob;
-            m_name = name;
-            m_version = version;
-        }
-
-        public StrongName2 Copy()
-        {
-            return new StrongName2(m_publicKeyBlob, m_name, m_version);
-        }
-
-        public bool IsSubsetOf(StrongName2 target)
-        {
-            // This StrongName2 is a subset of the target if it's public key blob is null no matter what
-            if (this.m_publicKeyBlob == null)
-                return true;
-
-            // Subsets are always false if the public key blobs do not match
-            if (!this.m_publicKeyBlob.Equals( target.m_publicKeyBlob ))
-                return false;
-
-            // We use null in strings to represent the "Anything" state.
-            // Therefore, the logic to detect an individual subset is:
-            //
-            // 1. If the this string is null ("Anything" is a subset of any other).
-            // 2. If the this string and target string are the same (equality is sufficient for a subset).
-            //
-            // The logic is reversed here to discover things that are not subsets.
-            if (this.m_name != null)
-            {
-                if (target.m_name == null || !System.Security.Policy.StrongName.CompareNames( target.m_name, this.m_name ))
-                    return false;
-            }
-
-            if ((Object) this.m_version != null)
-            {
-                if ((Object) target.m_version == null ||
-                    target.m_version.CompareTo( this.m_version ) != 0)
-                {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-        
-        public StrongName2 Intersect(StrongName2 target)
-        {
-            if (target.IsSubsetOf( this ))
-                return target.Copy();
-            else if (this.IsSubsetOf( target ))
-                return this.Copy();
-            else
-                return null;
-        }
-
-        public bool Equals(StrongName2 target)
-        {
-            if (!target.IsSubsetOf(this))
-                return false;
-            if (!this.IsSubsetOf(target))
-                return false;
-            return true;
-        }
-    }
-
-
-
-[System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-    sealed public class StrongNameIdentityPermission : CodeAccessPermission, IBuiltInPermission
-    {
-        //------------------------------------------------------
-        //
-        // PRIVATE STATE DATA
-        //
-        //------------------------------------------------------
-
-        private bool m_unrestricted;
-        private StrongName2[] m_strongNames;
-
-        //------------------------------------------------------
-        //
-        // PUBLIC CONSTRUCTORS
-        //
-        //------------------------------------------------------
-
-
-        public StrongNameIdentityPermission(PermissionState state)
-        {
-            if (state == PermissionState.Unrestricted)
-            {
-                m_unrestricted = true;
-            }
-            else if (state == PermissionState.None)
-            {
-                m_unrestricted = false;
-            }
-            else
-            {
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
-            }
-        }
-
-        public StrongNameIdentityPermission( StrongNamePublicKeyBlob blob, String name, Version version )
-        {
-            if (blob == null)
-                throw new ArgumentNullException( nameof(blob) );
-            if (name != null && name.Equals( "" ))
-                throw new ArgumentException( Environment.GetResourceString( "Argument_EmptyStrongName" ) );      
-            Contract.EndContractBlock();
-            m_unrestricted = false;
-            m_strongNames = new StrongName2[1];
-            m_strongNames[0] = new StrongName2(blob, name, version);
-        }
-
-
-        //------------------------------------------------------
-        //
-        // PUBLIC ACCESSOR METHODS
-        //
-        //------------------------------------------------------
-
-        public StrongNamePublicKeyBlob PublicKey
-        {
-            set
-            {
-                if (value == null)
-                    throw new ArgumentNullException( nameof(PublicKey) );
-                Contract.EndContractBlock();
-                m_unrestricted = false;
-                if(m_strongNames != null && m_strongNames.Length == 1)
-                    m_strongNames[0].m_publicKeyBlob = value;
-                else
-                {
-                    m_strongNames = new StrongName2[1];
-                    m_strongNames[0] = new StrongName2(value, "", new Version());                   
-                }
-            }
-
-            get
-            {
-                if(m_strongNames == null || m_strongNames.Length == 0)
-                    return null;
-                if(m_strongNames.Length > 1)
-                    throw new NotSupportedException(Environment.GetResourceString("NotSupported_AmbiguousIdentity"));
-                return m_strongNames[0].m_publicKeyBlob;
-            }
-        }
-
-        public String Name
-        {
-            set
-            {
-                if (value != null && value.Length == 0)
-                    throw new ArgumentException( Environment.GetResourceString("Argument_EmptyName" ));    
-                Contract.EndContractBlock();
-                m_unrestricted = false;
-                if(m_strongNames != null && m_strongNames.Length == 1)
-                    m_strongNames[0].m_name = value;
-                else
-                {
-                    m_strongNames = new StrongName2[1];
-                    m_strongNames[0] = new StrongName2(null, value, new Version());                 
-                }
-            }                    
-
-            get
-            {
-                if(m_strongNames == null || m_strongNames.Length == 0)
-                    return "";
-                if(m_strongNames.Length > 1)
-                    throw new NotSupportedException(Environment.GetResourceString("NotSupported_AmbiguousIdentity"));
-                return m_strongNames[0].m_name;
-            }
-        }
-
-        public Version Version
-        {
-            set
-            {
-                m_unrestricted = false;
-                if(m_strongNames != null && m_strongNames.Length == 1)
-                    m_strongNames[0].m_version = value;
-                else
-                {
-                    m_strongNames = new StrongName2[1];
-                    m_strongNames[0] = new StrongName2(null, "", value);
-                }
-            }
-            
-            get
-            {
-                if(m_strongNames == null || m_strongNames.Length == 0)
-                    return new Version();
-                if(m_strongNames.Length > 1)
-                    throw new NotSupportedException(Environment.GetResourceString("NotSupported_AmbiguousIdentity"));
-                return m_strongNames[0].m_version;
-            }
-        }
-
-        //------------------------------------------------------
-        //
-        // PRIVATE AND PROTECTED HELPERS FOR ACCESSORS AND CONSTRUCTORS
-        //
-        //------------------------------------------------------
-    
-        //------------------------------------------------------
-        //
-        // CODEACCESSPERMISSION IMPLEMENTATION
-        //
-        //------------------------------------------------------
-        
-        //------------------------------------------------------
-        //
-        // IPERMISSION IMPLEMENTATION
-        //
-        //------------------------------------------------------
-
-
-        public override IPermission Copy()
-        {
-            StrongNameIdentityPermission perm = new StrongNameIdentityPermission(PermissionState.None);
-            perm.m_unrestricted = this.m_unrestricted;
-            if(this.m_strongNames != null)
-            {
-                perm.m_strongNames = new StrongName2[this.m_strongNames.Length];
-                int n;
-                for(n = 0; n < this.m_strongNames.Length; n++)
-                    perm.m_strongNames[n] = this.m_strongNames[n].Copy();
-            }
-            return perm;
-        }
-
-        public override bool IsSubsetOf(IPermission target)
-        {
-            if (target == null)
-            {
-                if(m_unrestricted)
-                    return false;
-                if(m_strongNames == null)
-                    return true;
-                if(m_strongNames.Length == 0)
-                    return true;
-                return false;
-            }
-            StrongNameIdentityPermission that = target as StrongNameIdentityPermission;
-            if(that == null)
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-            if(that.m_unrestricted)
-                return true;
-            if(m_unrestricted)
-                return false;
-            if(this.m_strongNames != null)
-            {
-                foreach(StrongName2 snThis in m_strongNames)
-                {
-                    bool bOK = false;
-                    if(that.m_strongNames != null)
-                    {
-                        foreach(StrongName2 snThat in that.m_strongNames)
-                        {
-                            if(snThis.IsSubsetOf(snThat))
-                            {
-                                bOK = true;
-                                break;
-                            }
-                        }
-                    }
-                    if(!bOK)
-                        return false;           
-                }
-            }
-            return true;
-        }
-
-
-
-        public override IPermission Intersect(IPermission target)
-        {
-            if (target == null)
-                return null;
-            StrongNameIdentityPermission that = target as StrongNameIdentityPermission;
-            if(that == null)
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-            if(this.m_unrestricted && that.m_unrestricted)
-            {
-                StrongNameIdentityPermission res = new StrongNameIdentityPermission(PermissionState.None);
-                res.m_unrestricted = true;
-                return res;
-            }
-            if(this.m_unrestricted)
-                return that.Copy();
-            if(that.m_unrestricted)
-                return this.Copy();
-            if(this.m_strongNames == null || that.m_strongNames == null || this.m_strongNames.Length == 0 || that.m_strongNames.Length == 0)
-                return null;
-            List<StrongName2> alStrongNames = new List<StrongName2>();
-            foreach(StrongName2 snThis in this.m_strongNames)
-            {
-                foreach(StrongName2 snThat in that.m_strongNames)
-                {
-                    StrongName2 snInt = (StrongName2)snThis.Intersect(snThat);
-                    if(snInt != null)
-                        alStrongNames.Add(snInt);
-                }
-            }
-            if(alStrongNames.Count == 0)
-                return null;
-            StrongNameIdentityPermission result = new StrongNameIdentityPermission(PermissionState.None);
-            result.m_strongNames = alStrongNames.ToArray();
-            return result;
-        }
-
-        public override IPermission Union(IPermission target)
-        {
-            if (target == null)
-            {
-                if((this.m_strongNames == null || this.m_strongNames.Length == 0) && !this.m_unrestricted)
-                    return null;
-                return this.Copy();
-            }
-            StrongNameIdentityPermission that = target as StrongNameIdentityPermission;
-            if(that == null)
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-            if(this.m_unrestricted || that.m_unrestricted)
-            {
-                StrongNameIdentityPermission res = new StrongNameIdentityPermission(PermissionState.None);
-                res.m_unrestricted = true;
-                return res;
-            }
-            if (this.m_strongNames == null || this.m_strongNames.Length == 0)
-            {
-                if(that.m_strongNames == null || that.m_strongNames.Length == 0)
-                    return null;
-                return that.Copy();
-            }
-            if(that.m_strongNames == null || that.m_strongNames.Length == 0)
-                return this.Copy();
-            List<StrongName2> alStrongNames = new List<StrongName2>();
-            foreach(StrongName2 snThis in this.m_strongNames)
-                alStrongNames.Add(snThis);
-            foreach(StrongName2 snThat in that.m_strongNames)
-            {
-                bool bDupe = false;
-                foreach(StrongName2 sn in alStrongNames)
-                {
-                    if(snThat.Equals(sn))
-                    {
-                        bDupe = true;
-                        break;
-                    }
-                }
-                if(!bDupe)
-                    alStrongNames.Add(snThat);
-            }
-            StrongNameIdentityPermission result = new StrongNameIdentityPermission(PermissionState.None);
-            result.m_strongNames = alStrongNames.ToArray();
-            return result;
-        }
-
-        /// <internalonly/>
-        int IBuiltInPermission.GetTokenIndex()
-        {
-            return StrongNameIdentityPermission.GetTokenIndex();
-        }
-
-        internal static int GetTokenIndex()
-        {
-            return BuiltInPermissionIndex.StrongNameIdentityPermissionIndex;
-        }
-            
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Permissions/StrongNamePublicKeyBlob.cs b/src/mscorlib/src/System/Security/Permissions/StrongNamePublicKeyBlob.cs
deleted file mode 100644
index 823eaba938..0000000000
--- a/src/mscorlib/src/System/Security/Permissions/StrongNamePublicKeyBlob.cs
+++ /dev/null
@@ -1,94 +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.
-
-namespace System.Security.Permissions
-{
-    using System;
-    using System.Security.Util;
-    using System.Diagnostics.Contracts;
-
-    [System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable] sealed public class StrongNamePublicKeyBlob
-    {
-        internal byte[] PublicKey;
-        
-        internal StrongNamePublicKeyBlob()
-        {
-        }
-        
-        public StrongNamePublicKeyBlob( byte[] publicKey )
-        {
-            if (publicKey == null)
-                throw new ArgumentNullException( nameof(PublicKey) );
-            Contract.EndContractBlock();
-        
-            this.PublicKey = new byte[publicKey.Length];
-            Array.Copy( publicKey, 0, this.PublicKey, 0, publicKey.Length );
-        }
-        
-        internal StrongNamePublicKeyBlob( String publicKey )
-        {
-            this.PublicKey = Hex.DecodeHexString( publicKey );
-        }        
-        
-        private static bool CompareArrays( byte[] first, byte[] second )
-        {
-            if (first.Length != second.Length)
-            {
-                return false;
-            }
-            
-            int count = first.Length;
-            for (int i = 0; i < count; ++i)
-            {
-                if (first[i] != second[i])
-                    return false;
-            }
-            
-            return true;
-        }
-                
-        
-        internal bool Equals( StrongNamePublicKeyBlob blob )
-        {
-            if (blob == null)
-                return false;
-            else 
-                return CompareArrays( this.PublicKey, blob.PublicKey );
-        }
-
-        public override bool Equals( Object obj )
-        {
-            if (obj == null || !(obj is StrongNamePublicKeyBlob))
-                return false;
-
-            return this.Equals( (StrongNamePublicKeyBlob)obj );
-        }
-
-        static private int GetByteArrayHashCode( byte[] baData )
-        {
-            if (baData == null)
-                return 0;
-
-            int accumulator = 0;
-
-            for (int i = 0; i < baData.Length; ++i)
-            {
-                accumulator = (accumulator << 8) ^ (int)baData[i] ^ (accumulator >> 24);
-            }
-
-            return accumulator;
-        }
-
-        public override int GetHashCode()
-        {
-            return GetByteArrayHashCode( PublicKey );
-        }
-
-        public override String ToString()
-        {
-            return Hex.EncodeHexString( PublicKey );
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Permissions/UIPermission.cs b/src/mscorlib/src/System/Security/Permissions/UIPermission.cs
deleted file mode 100644
index 7768e97c53..0000000000
--- a/src/mscorlib/src/System/Security/Permissions/UIPermission.cs
+++ /dev/null
@@ -1,298 +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.
-
-namespace System.Security.Permissions
-{
-    using System;
-    using System.Security;
-    using System.Security.Util;
-    using System.IO;
-    using System.Runtime.Serialization;
-    using System.Reflection;
-    using System.Collections;
-    using System.Globalization;
-    using System.Diagnostics.Contracts;
-    
-    [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public enum UIPermissionWindow
-    {
-        // No window use allowed at all.
-        NoWindows = 0x0,
-    
-        // Only allow safe subwindow use (for embedded components).
-        SafeSubWindows = 0x01,
-    
-        // Safe top-level window use only (see specification for details).
-        SafeTopLevelWindows = 0x02,
-    
-        // All windows and all event may be used.
-        AllWindows = 0x03,
-    
-    }
-    
-    [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public enum UIPermissionClipboard
-    {
-        // No clipboard access is allowed.
-        NoClipboard = 0x0,
-    
-        // Paste from the same app domain only.
-        OwnClipboard = 0x1,
-    
-        // Any clipboard access is allowed.
-        AllClipboard = 0x2,
-    
-    }
-    
-    
-[System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-    sealed public class UIPermission 
-           : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission
-    {
-        //------------------------------------------------------
-        //
-        // PRIVATE STATE DATA
-        //
-        //------------------------------------------------------
-        
-        private UIPermissionWindow m_windowFlag;
-        private UIPermissionClipboard m_clipboardFlag;
-        
-        //------------------------------------------------------
-        //
-        // PUBLIC CONSTRUCTORS
-        //
-        //------------------------------------------------------
-    
-        public UIPermission(PermissionState state)
-        {
-            if (state == PermissionState.Unrestricted)
-            {
-                SetUnrestricted( true );
-            }
-            else if (state == PermissionState.None)
-            {
-                SetUnrestricted( false );
-                Reset();
-            }
-            else
-            {
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
-            }
-        }    
-        
-        public UIPermission(UIPermissionWindow windowFlag, UIPermissionClipboard clipboardFlag )
-        {
-            VerifyWindowFlag( windowFlag );
-            VerifyClipboardFlag( clipboardFlag );
-            
-            m_windowFlag = windowFlag;
-            m_clipboardFlag = clipboardFlag;
-        }
-    
-        public UIPermission(UIPermissionWindow windowFlag )
-        {
-            VerifyWindowFlag( windowFlag );
-            
-            m_windowFlag = windowFlag;
-        }
-    
-        public UIPermission(UIPermissionClipboard clipboardFlag )
-        {
-            VerifyClipboardFlag( clipboardFlag );
-            
-            m_clipboardFlag = clipboardFlag;
-        }
-        
-        
-        //------------------------------------------------------
-        //
-        // PUBLIC ACCESSOR METHODS
-        //
-        //------------------------------------------------------
-        
-        public UIPermissionWindow Window
-        {
-            set
-            {
-                VerifyWindowFlag(value);
-            
-                m_windowFlag = value;
-            }
-            
-            get
-            {
-                return m_windowFlag;
-            }
-        }
-        
-        public UIPermissionClipboard Clipboard
-        {
-            set
-            {
-                VerifyClipboardFlag(value);
-            
-                m_clipboardFlag = value;
-            }
-            
-            get
-            {
-                return m_clipboardFlag;
-            }
-        }
-    
-        //------------------------------------------------------
-        //
-        // PRIVATE AND PROTECTED HELPERS FOR ACCESSORS AND CONSTRUCTORS
-        //
-        //------------------------------------------------------
-        
-        private static void VerifyWindowFlag(UIPermissionWindow flag)
-        {
-            if (flag < UIPermissionWindow.NoWindows || flag > UIPermissionWindow.AllWindows)
-            {
-                throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)flag));
-            }
-            Contract.EndContractBlock();
-        }
-        
-        private static void VerifyClipboardFlag(UIPermissionClipboard flag)
-        {
-            if (flag < UIPermissionClipboard.NoClipboard || flag > UIPermissionClipboard.AllClipboard)
-            {
-                throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)flag));
-            }
-            Contract.EndContractBlock();
-        }
-        
-        private void Reset()
-        {
-            m_windowFlag = UIPermissionWindow.NoWindows;
-            m_clipboardFlag = UIPermissionClipboard.NoClipboard;
-        }
-        
-        private void SetUnrestricted( bool unrestricted )
-        {
-            if (unrestricted)
-            {
-                m_windowFlag = UIPermissionWindow.AllWindows;
-                m_clipboardFlag = UIPermissionClipboard.AllClipboard;
-            }
-        }
-
-        
-        //------------------------------------------------------
-        //
-        // CODEACCESSPERMISSION IMPLEMENTATION
-        //
-        //------------------------------------------------------
-        
-        public bool IsUnrestricted()
-        {
-            return m_windowFlag == UIPermissionWindow.AllWindows && m_clipboardFlag == UIPermissionClipboard.AllClipboard;
-        }
-        
-        //------------------------------------------------------
-        //
-        // IPERMISSION IMPLEMENTATION
-        //
-        //------------------------------------------------------
-        
-        public override bool IsSubsetOf(IPermission target)
-        {
-            if (target == null)
-            {
-                // Only safe subset if this is empty
-                return m_windowFlag == UIPermissionWindow.NoWindows && m_clipboardFlag == UIPermissionClipboard.NoClipboard;
-            }
-
-            try
-            {
-                UIPermission operand = (UIPermission)target;
-                if (operand.IsUnrestricted())
-                    return true;
-                else if (this.IsUnrestricted())
-                    return false;
-                else 
-                    return this.m_windowFlag <= operand.m_windowFlag && this.m_clipboardFlag <= operand.m_clipboardFlag;
-            }
-            catch (InvalidCastException)
-            {
-                throw new 
-                    ArgumentException(
-                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
-                                     );
-            }
-            
-        }
-        
-        public override IPermission Intersect(IPermission target)
-        {
-            if (target == null)
-            {
-                return null;
-            }
-            else if (!VerifyType(target))
-            {
-                throw new 
-                    ArgumentException(
-                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
-                                     );
-            }
-            
-            UIPermission operand = (UIPermission)target;
-            UIPermissionWindow isectWindowFlags = m_windowFlag < operand.m_windowFlag ? m_windowFlag : operand.m_windowFlag;
-            UIPermissionClipboard isectClipboardFlags = m_clipboardFlag < operand.m_clipboardFlag ? m_clipboardFlag : operand.m_clipboardFlag;
-            if (isectWindowFlags == UIPermissionWindow.NoWindows && isectClipboardFlags == UIPermissionClipboard.NoClipboard)
-                return null;
-            else
-                return new UIPermission(isectWindowFlags, isectClipboardFlags);
-        }
-        
-        public override IPermission Union(IPermission target)
-        {
-            if (target == null)
-            {
-                return this.Copy();
-            }
-            else if (!VerifyType(target))
-            {
-                throw new 
-                    ArgumentException(
-                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
-                                     );
-            }
-            
-            UIPermission operand = (UIPermission)target;
-            UIPermissionWindow isectWindowFlags = m_windowFlag > operand.m_windowFlag ? m_windowFlag : operand.m_windowFlag;
-            UIPermissionClipboard isectClipboardFlags = m_clipboardFlag > operand.m_clipboardFlag ? m_clipboardFlag : operand.m_clipboardFlag;
-            if (isectWindowFlags == UIPermissionWindow.NoWindows && isectClipboardFlags == UIPermissionClipboard.NoClipboard)
-                return null;
-            else
-                return new UIPermission(isectWindowFlags, isectClipboardFlags);
-        }        
-        
-        public override IPermission Copy()
-        {
-            return new UIPermission(this.m_windowFlag, this.m_clipboardFlag);
-        }
-
-        /// <internalonly/>
-        int IBuiltInPermission.GetTokenIndex()
-        {
-            return UIPermission.GetTokenIndex();
-        }
-
-        internal static int GetTokenIndex()
-        {
-            return BuiltInPermissionIndex.UIPermissionIndex;
-        }
-            
-    }
-
-
-}
diff --git a/src/mscorlib/src/System/Security/Permissions/URLIdentityPermission.cs b/src/mscorlib/src/System/Security/Permissions/URLIdentityPermission.cs
deleted file mode 100644
index bac7f7a0d9..0000000000
--- a/src/mscorlib/src/System/Security/Permissions/URLIdentityPermission.cs
+++ /dev/null
@@ -1,281 +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.
-
-namespace System.Security.Permissions
-{
-    using System;
-    using System.Security.Util;
-    using System.IO;
-    using System.Text;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Globalization;
-    using System.Runtime.Serialization;
-    using System.Diagnostics.Contracts;
-
-    [System.Runtime.InteropServices.ComVisible(true)]
-    sealed public class UrlIdentityPermission : CodeAccessPermission, IBuiltInPermission
-    {
-        //------------------------------------------------------
-        //
-        // PRIVATE STATE DATA
-        //
-        //------------------------------------------------------
-
-        [OptionalField(VersionAdded = 2)]
-        private bool m_unrestricted;
-        [OptionalField(VersionAdded = 2)]
-        private URLString[] m_urls;
-
-        //------------------------------------------------------
-        //
-        // PUBLIC CONSTRUCTORS
-        //
-        //------------------------------------------------------
-
-
-        public UrlIdentityPermission(PermissionState state)
-        {
-            if (state == PermissionState.Unrestricted)
-            {
-                m_unrestricted = true;
-            }
-            else if (state == PermissionState.None)
-            {
-                m_unrestricted = false;
-            }
-            else
-            {
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
-            }
-        }
-
-        public UrlIdentityPermission( String site )
-        {
-            if (site == null)
-                throw new ArgumentNullException( nameof(site) );
-            Contract.EndContractBlock();
-            Url = site;
-        }
-
-        internal UrlIdentityPermission( URLString site )
-        {
-            m_unrestricted = false;
-            m_urls = new URLString[1];
-            m_urls[0] = site;
-        }
-
-        // Internal function to append all the urls in m_urls to the input originList
-        internal void AppendOrigin(ArrayList originList)
-        {
-            if (m_urls == null)
-                originList.Add("");
-            else
-            {
-                int n;
-                for(n = 0; n < this.m_urls.Length; n++)        
-                    originList.Add(m_urls[n].ToString());
-            }
-        }
-
-        //------------------------------------------------------
-        //
-        // PUBLIC ACCESSOR METHODS
-        //
-        //------------------------------------------------------
-
-        public String Url
-        {
-            set
-            {
-                m_unrestricted = false;
-                if(value == null || value.Length == 0)
-                    m_urls = null;
-                else
-                {
-                    m_urls = new URLString[1];
-                    m_urls[0] = new URLString( value );
-                }
-            }
-
-            get
-            {
-                if(m_urls == null)
-                    return "";
-                if(m_urls.Length == 1)
-                    return m_urls[0].ToString();
-                throw new NotSupportedException(Environment.GetResourceString("NotSupported_AmbiguousIdentity"));
-            }
-        }
-
-        //------------------------------------------------------
-        //
-        // PRIVATE AND PROTECTED HELPERS FOR ACCESSORS AND CONSTRUCTORS
-        //
-        //------------------------------------------------------
-
-        //------------------------------------------------------
-        //
-        // CODEACCESSPERMISSION IMPLEMENTATION
-        //
-        //------------------------------------------------------
-
-        //------------------------------------------------------
-        //
-        // IPERMISSION IMPLEMENTATION
-        //
-        //------------------------------------------------------
-
-
-        public override IPermission Copy()
-        {
-            UrlIdentityPermission perm = new UrlIdentityPermission( PermissionState.None );
-            perm.m_unrestricted = this.m_unrestricted;
-            if (this.m_urls != null)
-            {
-                perm.m_urls = new URLString[this.m_urls.Length];
-                int n;
-                for(n = 0; n < this.m_urls.Length; n++)
-                    perm.m_urls[n] = (URLString)this.m_urls[n].Copy();
-            }
-            return perm;
-        }
-
-        public override bool IsSubsetOf(IPermission target)
-        {
-            if (target == null)
-            {
-                if(m_unrestricted)
-                    return false;
-                if(m_urls == null)
-                    return true;
-                if(m_urls.Length == 0)
-                    return true;
-                return false;
-            }
-            UrlIdentityPermission that = target as UrlIdentityPermission;
-            if(that == null)
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-            if(that.m_unrestricted)
-                return true;
-            if(m_unrestricted)
-                return false;
-            if(this.m_urls != null)
-            {
-                foreach(URLString usThis in this.m_urls)
-                {
-                    bool bOK = false;
-                    if(that.m_urls != null)
-                    {
-                        foreach(URLString usThat in that.m_urls)
-                        {
-                            if(usThis.IsSubsetOf(usThat))
-                            {
-                                bOK = true;
-                                break;
-                            }
-                        }
-                    }
-                    if(!bOK)
-                        return false;           
-                }
-            }
-            return true;
-        }
-
-        public override IPermission Intersect(IPermission target)
-        {
-            if (target == null)
-                return null;
-            UrlIdentityPermission that = target as UrlIdentityPermission;
-            if(that == null)
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-            if(this.m_unrestricted && that.m_unrestricted)
-            {
-                UrlIdentityPermission res = new UrlIdentityPermission(PermissionState.None);
-                res.m_unrestricted = true;
-                return res;
-            }
-            if(this.m_unrestricted)
-                return that.Copy();
-            if(that.m_unrestricted)
-                return this.Copy();
-            if(this.m_urls == null || that.m_urls == null || this.m_urls.Length == 0 || that.m_urls.Length == 0)
-                return null;
-            List<URLString> alUrls = new List<URLString>();
-            foreach(URLString usThis in this.m_urls)
-            {
-                foreach(URLString usThat in that.m_urls)
-                {
-                    URLString usInt = (URLString)usThis.Intersect(usThat);
-                    if(usInt != null)
-                        alUrls.Add(usInt);
-                }
-            }
-            if(alUrls.Count == 0)
-                return null;
-            UrlIdentityPermission result = new UrlIdentityPermission(PermissionState.None);
-            result.m_urls = alUrls.ToArray();
-            return result;
-        }
-
-        public override IPermission Union(IPermission target)
-        {
-            if (target == null)
-            {
-                if((this.m_urls == null || this.m_urls.Length == 0) && !this.m_unrestricted)
-                    return null;
-                return this.Copy();
-            }
-            UrlIdentityPermission that = target as UrlIdentityPermission;
-            if(that == null)
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-            if(this.m_unrestricted || that.m_unrestricted)
-            {
-                UrlIdentityPermission res = new UrlIdentityPermission(PermissionState.None);
-                res.m_unrestricted = true;
-                return res;
-            }
-            if (this.m_urls == null || this.m_urls.Length == 0)
-            {
-                if(that.m_urls == null || that.m_urls.Length == 0)
-                    return null;
-                return that.Copy();
-            }
-            if(that.m_urls == null || that.m_urls.Length == 0)
-                return this.Copy();
-            List<URLString> alUrls = new List<URLString>();
-            foreach(URLString usThis in this.m_urls)
-                alUrls.Add(usThis);
-            foreach(URLString usThat in that.m_urls)
-            {
-                bool bDupe = false;
-                foreach(URLString us in alUrls)
-                {
-                    if(usThat.Equals(us))
-                    {
-                        bDupe = true;
-                        break;
-                    }
-                }
-                if(!bDupe)
-                    alUrls.Add(usThat);
-            }
-            UrlIdentityPermission result = new UrlIdentityPermission(PermissionState.None);
-            result.m_urls = alUrls.ToArray();
-            return result;
-        }
-
-        /// <internalonly/>
-        int IBuiltInPermission.GetTokenIndex()
-        {
-            return UrlIdentityPermission.GetTokenIndex();
-        }
-
-        internal static int GetTokenIndex()
-        {
-            return BuiltInPermissionIndex.UrlIdentityPermissionIndex;
-        }        
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Permissions/ZoneIdentityPermission.cs b/src/mscorlib/src/System/Security/Permissions/ZoneIdentityPermission.cs
deleted file mode 100644
index 0a5d83e3e8..0000000000
--- a/src/mscorlib/src/System/Security/Permissions/ZoneIdentityPermission.cs
+++ /dev/null
@@ -1,205 +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.
-
-// 
-// 
-
-namespace System.Security.Permissions
-{
-    using System;
-    using System.Globalization;
-    using System.Runtime.Serialization;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Diagnostics.Contracts;
-
-    [System.Runtime.InteropServices.ComVisible(true)]
-    sealed public class ZoneIdentityPermission : CodeAccessPermission, IBuiltInPermission
-    {
-        //------------------------------------------------------
-        //
-        // PRIVATE STATE DATA
-        //
-        //------------------------------------------------------
-
-        // Zone            Enum       Flag
-        // -----           -----      -----
-        // NoZone          -1         0x00
-        // MyComputer       0         0x01  (1 << 0)
-        // Intranet         1         0x02  (1 << 1)
-        // Trusted          2         0x04  (1 << 2)
-        // Internet         3         0x08  (1 << 3)
-        // Untrusted        4         0x10  (1 << 4)
-
-        private const uint AllZones = 0x1f;
-        [OptionalField(VersionAdded = 2)]
-        private uint m_zones;
-
-        //------------------------------------------------------
-        //
-        // PUBLIC CONSTRUCTORS
-        //
-        //------------------------------------------------------
-
-        public ZoneIdentityPermission(PermissionState state)
-        {
-            if (state == PermissionState.Unrestricted)
-            {
-                m_zones = AllZones;
-            }
-            else if (state == PermissionState.None)
-            {
-                m_zones = 0;
-            }
-            else
-            {
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
-            }
-        }
-
-        public ZoneIdentityPermission( SecurityZone zone )
-        {
-            this.SecurityZone = zone;
-        }
-
-        internal ZoneIdentityPermission( uint zones )
-        {
-            m_zones = (zones & AllZones);
-        }
-
-        // Internal function to append all the Zone in this permission to the input ArrayList
-        internal void AppendZones(ArrayList zoneList)
-        {
-            int nEnum = 0;
-            uint nFlag;
-            for(nFlag = 1; nFlag < AllZones; nFlag <<= 1)
-            {
-                if((m_zones & nFlag) != 0)
-                {
-                    zoneList.Add((SecurityZone)nEnum);
-                }
-                nEnum++;
-            }
-        }
-
-        //------------------------------------------------------
-        //
-        // PUBLIC ACCESSOR METHODS
-        //
-        //------------------------------------------------------
-
-        public SecurityZone SecurityZone
-        {
-            set
-            {
-                VerifyZone( value );
-                if(value == SecurityZone.NoZone)
-                    m_zones = 0;
-                else
-                    m_zones = (uint)1 << (int)value;
-            }
-
-            get
-            {
-                SecurityZone z = SecurityZone.NoZone;
-                int nEnum = 0;
-                uint nFlag;
-                for(nFlag = 1; nFlag < AllZones; nFlag <<= 1)
-                {
-                    if((m_zones & nFlag) != 0)
-                    {
-                        if(z == SecurityZone.NoZone)
-                            z = (SecurityZone)nEnum;
-                        else
-                            return SecurityZone.NoZone;
-                    }
-                    nEnum++;
-                }
-                return z;
-            }
-        }
-
-        //------------------------------------------------------
-        //
-        // PRIVATE AND PROTECTED HELPERS FOR ACCESSORS AND CONSTRUCTORS
-        //
-        //------------------------------------------------------
-
-        private static void VerifyZone( SecurityZone zone )
-        {
-            if (zone < SecurityZone.NoZone || zone > SecurityZone.Untrusted)
-            {
-                throw new ArgumentException( Environment.GetResourceString("Argument_IllegalZone") );
-            }
-            Contract.EndContractBlock();
-        }
-
-
-        //------------------------------------------------------
-        //
-        // CODEACCESSPERMISSION IMPLEMENTATION
-        //
-        //------------------------------------------------------
-
-        //------------------------------------------------------
-        //
-        // IPERMISSION IMPLEMENTATION
-        //
-        //------------------------------------------------------
-
-
-        public override IPermission Copy()
-        {
-            return new ZoneIdentityPermission(this.m_zones);
-        }
-
-        public override bool IsSubsetOf(IPermission target)
-        {
-            if (target == null)
-                return this.m_zones == 0;
-
-            ZoneIdentityPermission that = target as ZoneIdentityPermission;
-            if (that == null)
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-            return (this.m_zones & that.m_zones) == this.m_zones;
-        }
-
-        public override IPermission Intersect(IPermission target)
-        {
-            if (target == null)
-                return null;
-
-            ZoneIdentityPermission that = target as ZoneIdentityPermission;
-            if (that == null)
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-            uint newZones = this.m_zones & that.m_zones;
-            if(newZones == 0)
-                return null;
-            return new ZoneIdentityPermission(newZones);
-        }
-
-        public override IPermission Union(IPermission target)
-        {
-            if (target == null)
-                return this.m_zones != 0 ? this.Copy() : null;
-
-            ZoneIdentityPermission that = target as ZoneIdentityPermission;
-            if (that == null)
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-            return new ZoneIdentityPermission(this.m_zones | that.m_zones);
-        }
-
-        /// <internalonly/>
-        int IBuiltInPermission.GetTokenIndex()
-        {
-            return ZoneIdentityPermission.GetTokenIndex();
-        }
-
-        internal static int GetTokenIndex()
-        {
-            return BuiltInPermissionIndex.ZoneIdentityPermissionIndex;
-        }
-
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Permissions/keycontainerpermission.cs b/src/mscorlib/src/System/Security/Permissions/keycontainerpermission.cs
deleted file mode 100644
index 910ebce2f3..0000000000
--- a/src/mscorlib/src/System/Security/Permissions/keycontainerpermission.cs
+++ /dev/null
@@ -1,621 +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.
-
-namespace System.Security.Permissions {
-    using System;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Security.Util;
-    using System.Globalization;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-
-[Serializable]
-    [Flags]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public enum KeyContainerPermissionFlags {
-        NoFlags     = 0x0000,
-
-        Create      = 0x0001,
-        Open        = 0x0002,
-        Delete      = 0x0004,
-
-        Import      = 0x0010,
-        Export      = 0x0020,
-
-        Sign        = 0x0100,
-        Decrypt     = 0x0200,
-
-        ViewAcl     = 0x1000,
-        ChangeAcl   = 0x2000,
-
-        AllFlags    = 0x3337
-    }
-
-    [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class KeyContainerPermissionAccessEntry {
-        private string m_keyStore;
-        private string m_providerName;
-        private int m_providerType;
-        private string m_keyContainerName;
-        private int m_keySpec;
-        private KeyContainerPermissionFlags m_flags;
-
-        internal KeyContainerPermissionAccessEntry(KeyContainerPermissionAccessEntry accessEntry) : 
-            this (accessEntry.KeyStore, accessEntry.ProviderName, accessEntry.ProviderType, accessEntry.KeyContainerName,
-                  accessEntry.KeySpec, accessEntry.Flags) {
-        }
-
-        public KeyContainerPermissionAccessEntry(string keyContainerName, KeyContainerPermissionFlags flags) : 
-            this (null, null, -1, keyContainerName, -1, flags) {
-        }
-
-
-        public KeyContainerPermissionAccessEntry(string keyStore, string providerName, int providerType, 
-                        string keyContainerName, int keySpec, KeyContainerPermissionFlags flags) {
-            m_providerName = (providerName == null ? "*" : providerName);
-            m_providerType = providerType;
-            m_keyContainerName = (keyContainerName == null ? "*" : keyContainerName);
-            m_keySpec = keySpec;
-            KeyStore = keyStore;
-            Flags = flags;
-        }
-
-        public string KeyStore {
-            get {
-                return m_keyStore;
-            }
-            set {
-                // Unrestricted entries are invalid; they should not be allowed.
-                if (IsUnrestrictedEntry(value, this.ProviderName, this.ProviderType, this.KeyContainerName, this.KeySpec))
-                    throw new ArgumentException(Environment.GetResourceString("Arg_InvalidAccessEntry"));
-
-                if (value == null) {
-                    m_keyStore = "*";
-                } else {
-                    if (value != "User" && value != "Machine" && value != "*")
-                        throw new ArgumentException(Environment.GetResourceString("Argument_InvalidKeyStore", value), nameof(value));
-                    m_keyStore = value;
-                }
-            }
-        }
-
-        public string ProviderName {
-            get {
-                return m_providerName;
-            }
-            set {
-                // Unrestricted entries are invalid; they should not be allowed.
-                if (IsUnrestrictedEntry(this.KeyStore, value, this.ProviderType, this.KeyContainerName, this.KeySpec))
-                    throw new ArgumentException(Environment.GetResourceString("Arg_InvalidAccessEntry"));
-
-                if (value == null)
-                    m_providerName = "*";
-                else
-                    m_providerName = value;
-            }
-        }
-
-        public int ProviderType {
-            get {
-                return m_providerType;
-            }
-            set {
-                // Unrestricted entries are invalid; they should not be allowed.
-                if (IsUnrestrictedEntry(this.KeyStore, this.ProviderName, value, this.KeyContainerName, this.KeySpec))
-                    throw new ArgumentException(Environment.GetResourceString("Arg_InvalidAccessEntry"));
-
-                m_providerType = value;
-            }
-        }
-
-        public string KeyContainerName {
-            get {
-                return m_keyContainerName;
-            }
-            set {
-                // Unrestricted entries are invalid; they should not be allowed.
-                if (IsUnrestrictedEntry(this.KeyStore, this.ProviderName, this.ProviderType, value, this.KeySpec))
-                    throw new ArgumentException(Environment.GetResourceString("Arg_InvalidAccessEntry"));
-
-                if (value == null)
-                    m_keyContainerName = "*";
-                else
-                    m_keyContainerName = value;
-            }
-        }
-
-        public int KeySpec {
-            get {
-                return m_keySpec;
-            }
-            set {
-                // Unrestricted entries are invalid; they should not be allowed.
-                if (IsUnrestrictedEntry(this.KeyStore, this.ProviderName, this.ProviderType, this.KeyContainerName, value))
-                    throw new ArgumentException(Environment.GetResourceString("Arg_InvalidAccessEntry"));
-
-                m_keySpec = value;
-            }
-        }
-
-        public KeyContainerPermissionFlags Flags {
-            get {
-                return m_flags;
-            }
-            set {
-                KeyContainerPermission.VerifyFlags(value);
-                m_flags = value;
-            }
-        }
-
-        public override bool Equals (Object o) {
-            KeyContainerPermissionAccessEntry accessEntry = o as KeyContainerPermissionAccessEntry;
-            if (accessEntry == null)
-                return false;
-
-            if (accessEntry.m_keyStore != m_keyStore) return false;
-            if (accessEntry.m_providerName != m_providerName) return false;
-            if (accessEntry.m_providerType != m_providerType) return false;
-            if (accessEntry.m_keyContainerName != m_keyContainerName) return false;
-            if (accessEntry.m_keySpec != m_keySpec) return false;
-
-            return true;
-        }
-
-        public override int GetHashCode () {
-            int hash = 0;
-
-            hash |= (this.m_keyStore.GetHashCode() & 0x000000FF) << 24;
-            hash |= (this.m_providerName.GetHashCode() & 0x000000FF) << 16;
-            hash |= (this.m_providerType & 0x0000000F) << 12;
-            hash |= (this.m_keyContainerName.GetHashCode() & 0x000000FF) << 4;
-            hash |= (this.m_keySpec & 0x0000000F);
-
-            return hash;
-        }
-
-        internal bool IsSubsetOf (KeyContainerPermissionAccessEntry target) {
-            if (target.m_keyStore != "*" && this.m_keyStore != target.m_keyStore)
-                return false;
-            if (target.m_providerName != "*" && this.m_providerName != target.m_providerName)
-                return false;
-            if (target.m_providerType != -1 && this.m_providerType != target.m_providerType)
-                return false;
-            if (target.m_keyContainerName != "*" && this.m_keyContainerName != target.m_keyContainerName)
-                return false;
-            if (target.m_keySpec != -1 && this.m_keySpec != target.m_keySpec)
-                return false;
-
-            return true;
-        }
-
-        internal static bool IsUnrestrictedEntry (string keyStore, string providerName, int providerType, 
-                        string keyContainerName, int keySpec) {
-            if (keyStore != "*" && keyStore != null) return false;
-            if (providerName != "*" && providerName != null) return false;
-            if (providerType != -1) return false;
-            if (keyContainerName != "*" && keyContainerName != null) return false;
-            if (keySpec != -1) return false;
-
-            return true;
-        }
-    }
-
-    [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class KeyContainerPermissionAccessEntryCollection : ICollection {
-        private ArrayList m_list;
-        private KeyContainerPermissionFlags m_globalFlags;
-
-        private KeyContainerPermissionAccessEntryCollection () {}
-        internal KeyContainerPermissionAccessEntryCollection (KeyContainerPermissionFlags globalFlags) {
-            m_list = new ArrayList();
-            m_globalFlags = globalFlags;
-        }
-
-        public KeyContainerPermissionAccessEntry this[int index] {
-            get {
-                if (index < 0)
-                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumNotStarted"));
-                if (index >= Count)
-                    throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-                Contract.EndContractBlock();
-
-                return (KeyContainerPermissionAccessEntry)m_list[index];
-            }
-        }
-
-        public int Count {
-            get {
-                return m_list.Count;
-            }
-        }
-
-        public int Add (KeyContainerPermissionAccessEntry accessEntry) {
-            if (accessEntry == null)
-                throw new ArgumentNullException(nameof(accessEntry));
-            Contract.EndContractBlock();
-
-            int index = m_list.IndexOf(accessEntry);
-            if (index == -1) {
-                if (accessEntry.Flags != m_globalFlags) {
-                    return m_list.Add(accessEntry);
-                }
-                else
-                    return -1;
-            } else {
-                // We pick up the intersection of the 2 flags. This is the secure choice 
-                // so we are opting for it.
-                ((KeyContainerPermissionAccessEntry)m_list[index]).Flags &= accessEntry.Flags;
-                return index;
-            }
-        }
-
-        public void Clear () {
-            m_list.Clear();
-        }
-
-        public int IndexOf (KeyContainerPermissionAccessEntry accessEntry) {
-            return m_list.IndexOf(accessEntry);
-        }
-
-        public void Remove (KeyContainerPermissionAccessEntry accessEntry) {
-            if (accessEntry == null)
-                throw new ArgumentNullException(nameof(accessEntry));
-            Contract.EndContractBlock();
-            m_list.Remove(accessEntry);
-        }
-
-        public KeyContainerPermissionAccessEntryEnumerator GetEnumerator () {
-            return new KeyContainerPermissionAccessEntryEnumerator(this);
-        }
-
-        /// <internalonly/>
-        IEnumerator IEnumerable.GetEnumerator () {
-            return new KeyContainerPermissionAccessEntryEnumerator(this);
-        }
-
-        /// <internalonly/>
-        void ICollection.CopyTo (Array array, int index) {
-            if (array == null)
-                throw new ArgumentNullException(nameof(array));
-            if (array.Rank != 1)
-                throw new ArgumentException(Environment.GetResourceString("Arg_RankMultiDimNotSupported"));
-            if (index < 0 || index >= array.Length)
-                throw new ArgumentOutOfRangeException(nameof(index), Environment.GetResourceString("ArgumentOutOfRange_Index"));
-            if (index + this.Count > array.Length)
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
-            Contract.EndContractBlock();
-
-            for (int i=0; i < this.Count; i++) {
-                array.SetValue(this[i], index);
-                index++;
-            }
-        }
-
-        public void CopyTo (KeyContainerPermissionAccessEntry[] array, int index) {
-            ((ICollection)this).CopyTo(array, index);
-        }
-
-        public bool IsSynchronized {
-            get {
-                return false;
-            }
-        }
-
-        public Object SyncRoot {
-            get {
-                return this;
-            }
-        }
-    }
-
-    [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class KeyContainerPermissionAccessEntryEnumerator : IEnumerator {
-        private KeyContainerPermissionAccessEntryCollection m_entries;
-        private int m_current;
-
-        private KeyContainerPermissionAccessEntryEnumerator () {}
-        internal KeyContainerPermissionAccessEntryEnumerator (KeyContainerPermissionAccessEntryCollection entries) {
-            m_entries = entries;
-            m_current = -1;
-        }
-
-        public KeyContainerPermissionAccessEntry Current {
-            get {
-                return m_entries[m_current];
-            }
-        }
-
-        /// <internalonly/>
-        Object IEnumerator.Current {
-            get {
-                return (Object) m_entries[m_current];
-            }
-        }
-
-        public bool MoveNext() {
-            if (m_current == ((int) m_entries.Count - 1))
-                return false;
-            m_current++;
-            return true;
-        }
-
-        public void Reset() {
-            m_current = -1;
-        }
-    }
-
-    [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class KeyContainerPermission : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission {
-        private KeyContainerPermissionFlags m_flags;
-        private KeyContainerPermissionAccessEntryCollection m_accessEntries;
-
-        public KeyContainerPermission (PermissionState state) {
-            if (state == PermissionState.Unrestricted)
-                m_flags = KeyContainerPermissionFlags.AllFlags;
-            else if (state == PermissionState.None)
-                m_flags = KeyContainerPermissionFlags.NoFlags;
-            else
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
-            m_accessEntries = new KeyContainerPermissionAccessEntryCollection(m_flags);
-         }
-
-        public KeyContainerPermission (KeyContainerPermissionFlags flags) {
-            VerifyFlags(flags);
-            m_flags = flags;
-            m_accessEntries = new KeyContainerPermissionAccessEntryCollection(m_flags);
-        }
-
-        public KeyContainerPermission (KeyContainerPermissionFlags flags, KeyContainerPermissionAccessEntry[] accessList) {
-            if (accessList == null) 
-                throw new ArgumentNullException(nameof(accessList));
-            Contract.EndContractBlock();
-
-            VerifyFlags(flags);
-            m_flags = flags;
-            m_accessEntries = new KeyContainerPermissionAccessEntryCollection(m_flags);
-            for (int index = 0; index < accessList.Length; index++) {
-                m_accessEntries.Add(accessList[index]);
-            }
-        }
-
-        public KeyContainerPermissionFlags Flags {
-            get {
-                return m_flags;
-            }
-        }
-
-        public KeyContainerPermissionAccessEntryCollection AccessEntries {
-            get {
-                return m_accessEntries;
-            }
-        }
-
-        public bool IsUnrestricted () {
-            if (m_flags != KeyContainerPermissionFlags.AllFlags)
-                return false;
-
-            foreach (KeyContainerPermissionAccessEntry accessEntry in AccessEntries) {
-                if ((accessEntry.Flags & KeyContainerPermissionFlags.AllFlags) != KeyContainerPermissionFlags.AllFlags)
-                    return false;
-            }
-
-            return true;
-        }
-
-        private bool IsEmpty () {
-            if (this.Flags == KeyContainerPermissionFlags.NoFlags) {
-                foreach (KeyContainerPermissionAccessEntry accessEntry in AccessEntries) {
-                    if (accessEntry.Flags != KeyContainerPermissionFlags.NoFlags)
-                        return false;
-                }
-                return true;
-            }
-            return false;
-        }
-
-        //
-        // IPermission implementation
-        //
-
-        public override bool IsSubsetOf (IPermission target) {
-            if (target == null) 
-                return IsEmpty();
-
-            if (!VerifyType(target))
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-
-            KeyContainerPermission operand = (KeyContainerPermission) target;
-
-            // since there are containers that are neither in the access list of the source, nor in the 
-            // access list of the target, the source flags must be a subset of the target flags.
-            if ((this.m_flags & operand.m_flags) != this.m_flags)
-                return false;
-
-            // Any entry in the source should have "applicable" flags in the destination that actually
-            // are less restrictive than the flags in the source.
-
-            foreach (KeyContainerPermissionAccessEntry accessEntry in AccessEntries) {
-                KeyContainerPermissionFlags targetFlags = GetApplicableFlags(accessEntry, operand);
-                if ((accessEntry.Flags & targetFlags) != accessEntry.Flags)
-                    return false;
-            }
-
-            // Any entry in the target should have "applicable" flags in the source that actually
-            // are more restrictive than the flags in the target.
-
-            foreach (KeyContainerPermissionAccessEntry accessEntry in operand.AccessEntries) {
-                KeyContainerPermissionFlags sourceFlags = GetApplicableFlags(accessEntry, this);
-                if ((sourceFlags & accessEntry.Flags) != sourceFlags)
-                    return false;
-            }
-
-            return true;
-        }
-
-        public override IPermission Intersect (IPermission target) {
-            if (target == null)
-                return null;
-
-            if (!VerifyType(target))
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
-
-            KeyContainerPermission operand = (KeyContainerPermission) target;
-            if (this.IsEmpty() || operand.IsEmpty())
-                return null;
-
-            KeyContainerPermissionFlags flags_intersect = operand.m_flags & this.m_flags;
-            KeyContainerPermission cp = new KeyContainerPermission(flags_intersect);
-            foreach (KeyContainerPermissionAccessEntry accessEntry in AccessEntries) {
-                cp.AddAccessEntryAndIntersect(accessEntry, operand);
-            }
-            foreach (KeyContainerPermissionAccessEntry accessEntry in operand.AccessEntries) {
-                cp.AddAccessEntryAndIntersect(accessEntry, this);
-            }
-            return cp.IsEmpty() ? null : cp;
-        }
-
-        public override IPermission Union (IPermission target) {
-            if (target == null)
-                return this.Copy();
-
-            if (!VerifyType(target))
-                throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));            
-
-            KeyContainerPermission operand = (KeyContainerPermission) target;    
-            if (this.IsUnrestricted() || operand.IsUnrestricted())
-                return new KeyContainerPermission(PermissionState.Unrestricted);
-
-            KeyContainerPermissionFlags flags_union = (KeyContainerPermissionFlags) (m_flags | operand.m_flags);
-            KeyContainerPermission cp = new KeyContainerPermission(flags_union);
-            foreach (KeyContainerPermissionAccessEntry accessEntry in AccessEntries) {
-                cp.AddAccessEntryAndUnion(accessEntry, operand);
-            }
-            foreach (KeyContainerPermissionAccessEntry accessEntry in operand.AccessEntries) {
-                cp.AddAccessEntryAndUnion(accessEntry, this);
-            }
-            return cp.IsEmpty() ? null : cp;
-        }
-
-        public override IPermission Copy () {
-            if (this.IsEmpty())
-                return null;
-
-            KeyContainerPermission cp = new KeyContainerPermission((KeyContainerPermissionFlags)m_flags);
-            foreach (KeyContainerPermissionAccessEntry accessEntry in AccessEntries) {
-                cp.AccessEntries.Add(accessEntry);
-            }
-            return cp;
-        }
-
-        /// <internalonly/>
-        int IBuiltInPermission.GetTokenIndex () {
-            return KeyContainerPermission.GetTokenIndex();
-        }
-
-        //
-        // private methods
-        //
-
-        private void AddAccessEntries(SecurityElement securityElement) {
-            if (securityElement.InternalChildren != null && securityElement.InternalChildren.Count != 0) {
-                IEnumerator elemEnumerator = securityElement.Children.GetEnumerator();
-                while (elemEnumerator.MoveNext()) {
-                    SecurityElement current = (SecurityElement) elemEnumerator.Current;
-                    if (current != null) {
-                        if (String.Equals(current.Tag, "AccessEntry")) {
-                            int iMax = current.m_lAttributes.Count;
-                            Debug.Assert(iMax % 2 == 0, "Odd number of strings means the attr/value pairs were not added correctly");
-                            string keyStore = null;
-                            string providerName = null;
-                            int providerType = -1;
-                            string keyContainerName = null;
-                            int keySpec = -1;
-                            KeyContainerPermissionFlags flags = KeyContainerPermissionFlags.NoFlags;
-                            for (int i = 0; i < iMax; i += 2) {
-                                String strAttrName = (String) current.m_lAttributes[i];
-                                String strAttrValue = (String) current.m_lAttributes[i+1]; 
-                                if (String.Equals(strAttrName, "KeyStore"))
-                                    keyStore = strAttrValue;
-                                if (String.Equals(strAttrName, "ProviderName"))
-                                    providerName = strAttrValue;
-                                else if (String.Equals(strAttrName, "ProviderType"))
-                                    providerType = Convert.ToInt32(strAttrValue, null);
-                                else if (String.Equals(strAttrName, "KeyContainerName"))
-                                    keyContainerName = strAttrValue;
-                                else if (String.Equals(strAttrName, "KeySpec"))
-                                    keySpec = Convert.ToInt32(strAttrValue, null);
-                                else if (String.Equals(strAttrName, "Flags")) {
-                                    flags = (KeyContainerPermissionFlags) Enum.Parse(typeof(KeyContainerPermissionFlags), strAttrValue);
-                                }
-                            }
-                            KeyContainerPermissionAccessEntry accessEntry = new KeyContainerPermissionAccessEntry(keyStore, providerName, providerType, keyContainerName, keySpec, flags);
-                            AccessEntries.Add(accessEntry);
-                        }
-                    }
-                }
-            }
-        }
-
-        private void AddAccessEntryAndUnion (KeyContainerPermissionAccessEntry accessEntry, KeyContainerPermission target) {
-            KeyContainerPermissionAccessEntry newAccessEntry = new KeyContainerPermissionAccessEntry(accessEntry);
-            newAccessEntry.Flags |= GetApplicableFlags(accessEntry, target);
-            AccessEntries.Add(newAccessEntry);
-        }
-
-        private void AddAccessEntryAndIntersect (KeyContainerPermissionAccessEntry accessEntry, KeyContainerPermission target) {
-            KeyContainerPermissionAccessEntry newAccessEntry = new KeyContainerPermissionAccessEntry(accessEntry);
-            newAccessEntry.Flags &= GetApplicableFlags(accessEntry, target);
-            AccessEntries.Add(newAccessEntry);
-        }
-
-        //
-        // private/internal static methods.
-        //
-
-        internal static void VerifyFlags (KeyContainerPermissionFlags flags) {
-            if ((flags & ~KeyContainerPermissionFlags.AllFlags) != 0)
-                throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)flags));
-            Contract.EndContractBlock();
-        }
-
-        private static KeyContainerPermissionFlags GetApplicableFlags (KeyContainerPermissionAccessEntry accessEntry, KeyContainerPermission target) {
-            KeyContainerPermissionFlags flags = KeyContainerPermissionFlags.NoFlags;
-            bool applyDefaultFlags = true;
-
-            // If the entry exists in the target, return the flag of the target entry.
-            int index = target.AccessEntries.IndexOf(accessEntry);
-            if (index != -1) {
-                flags = ((KeyContainerPermissionAccessEntry)target.AccessEntries[index]).Flags;
-                return flags;
-            }
-
-            // Intersect the flags in all the target entries that apply to the current access entry, 
-            foreach (KeyContainerPermissionAccessEntry targetAccessEntry in target.AccessEntries) {
-                if (accessEntry.IsSubsetOf(targetAccessEntry)) {
-                    if (applyDefaultFlags == false) {
-                        flags &= targetAccessEntry.Flags;
-                    } else {
-                        flags = targetAccessEntry.Flags;
-                        applyDefaultFlags = false;
-                    }
-                }
-            }
-
-            // If no target entry applies to the current entry, the default global flag applies.
-            if (applyDefaultFlags)
-                flags = target.Flags;
-
-            return flags;
-        }
-
-        private static int GetTokenIndex() {
-            return BuiltInPermissionIndex.KeyContainerPermissionIndex;
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Policy/ApplicationTrust.cs b/src/mscorlib/src/System/Security/Policy/ApplicationTrust.cs
deleted file mode 100644
index 712801a812..0000000000
--- a/src/mscorlib/src/System/Security/Policy/ApplicationTrust.cs
+++ /dev/null
@@ -1,122 +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.
-
-//
-// This class encapsulates security decisions about an application.
-//
-
-namespace System.Security.Policy
-{
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Globalization;
-    using System.IO;
-    using System.Runtime.InteropServices;
-    using System.Runtime.Versioning;
-    using System.Security.Permissions;
-    using System.Security.Util;
-    using System.Text;
-    using System.Threading;
-    using System.Diagnostics.Contracts;
-
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public enum ApplicationVersionMatch {
-        MatchExactVersion,
-        MatchAllVersions
-    }
-
-    [System.Runtime.InteropServices.ComVisible(true)]
-    [Serializable]
-    public sealed class ApplicationTrust : EvidenceBase, ISecurityEncodable
-    {
-        private PolicyStatement m_psDefaultGrant;
-        private IList<StrongName> m_fullTrustAssemblies;
-
-        // Permission special flags for the default grant set in this ApplicationTrust.  This should be
-        // updated in sync with any updates to the default grant set.
-        // 
-        // In the general case, these values cannot be trusted - we only store a reference to the
-        // DefaultGrantSet, and return the reference directly, which means that code can update the
-        // permission set without our knowledge.  That would lead to the flags getting out of sync with the
-        // grant set.
-        // 
-        // However, we only care about these flags when we're creating a homogenous AppDomain, and in that
-        // case we control the ApplicationTrust object end-to-end, and know that the permission set will not
-        // change after the flags are calculated.
-        [NonSerialized]
-        private int m_grantSetSpecialFlags;
-
-        public ApplicationTrust () : this (new PermissionSet(PermissionState.None))
-        {
-        }
-
-        internal ApplicationTrust (PermissionSet defaultGrantSet)
-        {
-            InitDefaultGrantSet(defaultGrantSet);
-
-            m_fullTrustAssemblies = new List<StrongName>().AsReadOnly();
-        }
-
-        public ApplicationTrust(PermissionSet defaultGrantSet, IEnumerable<StrongName> fullTrustAssemblies) {
-            if (fullTrustAssemblies == null) {
-                throw new ArgumentNullException(nameof(fullTrustAssemblies));
-            }
-
-            InitDefaultGrantSet(defaultGrantSet);
-
-            List<StrongName> fullTrustList = new List<StrongName>();
-            foreach (StrongName strongName in fullTrustAssemblies) {
-                if (strongName == null) {
-                    throw new ArgumentException(Environment.GetResourceString("Argument_NullFullTrustAssembly"), nameof(fullTrustAssemblies));
-                }
-
-                fullTrustList.Add(new StrongName(strongName.PublicKey, strongName.Name, strongName.Version));
-            }
-
-            m_fullTrustAssemblies = fullTrustList.AsReadOnly();
-        }
-
-        // Sets up the default grant set for all constructors. Extracted to avoid the cost of
-        // IEnumerable virtual dispatches on startup when there are no fullTrustAssemblies (CoreCLR)
-        private void InitDefaultGrantSet(PermissionSet defaultGrantSet) {
-            if (defaultGrantSet == null) {
-                throw new ArgumentNullException(nameof(defaultGrantSet));
-            }
-
-            // Creating a PolicyStatement copies the incoming permission set, so we don't have to worry
-            // about the PermissionSet parameter changing underneath us after we've calculated the
-            // permisison flags in the DefaultGrantSet setter.
-            DefaultGrantSet = new PolicyStatement(defaultGrantSet);
-        }
-
-        public PolicyStatement DefaultGrantSet {
-            get {
-                if (m_psDefaultGrant == null)
-                    return new PolicyStatement(new PermissionSet(PermissionState.None));
-                return m_psDefaultGrant;
-            }
-            set {
-                if (value == null) {
-                    m_psDefaultGrant = null;
-                    m_grantSetSpecialFlags = 0;
-                }
-                else {
-                    m_psDefaultGrant = value;
-                    m_grantSetSpecialFlags = SecurityManager.GetSpecialFlags(m_psDefaultGrant.PermissionSet, null);
-                }
-            }
-        }
-
-        public IList<StrongName> FullTrustAssemblies {
-            get {
-                return m_fullTrustAssemblies;
-            }
-        }
-
-        public override EvidenceBase Clone()
-        {
-            return base.Clone();
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Policy/Evidence.cs b/src/mscorlib/src/System/Security/Policy/Evidence.cs
deleted file mode 100644
index 7894736fa8..0000000000
--- a/src/mscorlib/src/System/Security/Policy/Evidence.cs
+++ /dev/null
@@ -1,31 +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.
-
-namespace System.Security.Policy
-{
-    using System.Runtime.InteropServices;
-
-    /// <summary>
-    ///     The Evidence class keeps track of information that can be used to make security decisions about
-    ///     an assembly or an AppDomain.  There are two types of evidence, one is supplied by the CLR or a
-    ///     host, the other supplied by the assembly itself.
-    ///     
-    ///     We keep a dictionary that maps each type of possbile evidence to an EvidenceTypeDescriptor which
-    ///     contains the evidence objects themselves if they exist as well as some extra metadata about that
-    ///     type of evidence.  This dictionary is fully populated with keys for host evidence at all times and
-    ///     for assembly evidence the first time the application evidence is touched.  This means that if a
-    ///     Type key does not exist in the dictionary, then that particular type of evidence will never be
-    ///     given to the assembly or AppDomain in question as host evidence.  The only exception is if the
-    ///     user later manually adds host evidence via the AddHostEvidence API.
-    ///     
-    ///     Assembly supplied evidence is created up front, however host supplied evidence may be lazily
-    ///     created.  In the lazy creation case, the Type will map to either an EvidenceTypeDescriptor that does
-    ///     not contain any evidence data or null.  As requests come in for that evidence, we'll populate the
-    ///     EvidenceTypeDescriptor appropriately.
-    /// </summary>
-    [ComVisible(true)]
-    public sealed class Evidence
-    {
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Policy/EvidenceBase.cs b/src/mscorlib/src/System/Security/Policy/EvidenceBase.cs
deleted file mode 100644
index 963edd4e2d..0000000000
--- a/src/mscorlib/src/System/Security/Policy/EvidenceBase.cs
+++ /dev/null
@@ -1,155 +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.
-
-// 
-
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Diagnostics.Contracts;
-using System.IO;
-using System.Runtime.InteropServices;
-using System.Security.Permissions;
-
-namespace System.Security.Policy
-{
-    /// <summary>
-    ///     Base class from which all objects to be used as Evidence must derive
-    /// </summary>
-    [ComVisible(true)]
-    [Serializable]
-    public abstract class EvidenceBase
-    {
-        protected EvidenceBase()
-        {
-        }
-
-        /// <remarks>
-        ///     Since legacy evidence objects would be cloned by being serialized, the default implementation
-        ///     of EvidenceBase will do the same.
-        /// </remarks>
-        public virtual EvidenceBase Clone()
-        {
-            throw new NotImplementedException();
-        }
-    }
-
-    /// <summary>
-    ///     Interface for types which wrap Whidbey evidence objects for compatibility with v4 evidence rules
-    /// </summary>
-    internal interface ILegacyEvidenceAdapter
-    {
-        object EvidenceObject { get; }
-        Type EvidenceType { get; }
-    }
-
-    /// <summary>
-    ///     Wrapper class to hold legacy evidence objects which do not derive from EvidenceBase, and allow
-    ///     them to be held in the Evidence collection which expects to maintain lists of EvidenceBase only
-    /// </summary>
-    [Serializable]
-    internal sealed class LegacyEvidenceWrapper : EvidenceBase, ILegacyEvidenceAdapter
-    {
-        private object m_legacyEvidence;
-
-        internal LegacyEvidenceWrapper(object legacyEvidence)
-        {
-            Debug.Assert(legacyEvidence != null);
-            Debug.Assert(legacyEvidence.GetType() != typeof(EvidenceBase), "Attempt to wrap an EvidenceBase in a LegacyEvidenceWrapper");
-            Debug.Assert(legacyEvidence.GetType().IsSerializable, "legacyEvidence.GetType().IsSerializable");
-
-            m_legacyEvidence = legacyEvidence;
-        }
-
-        public object EvidenceObject
-        {
-            get { return m_legacyEvidence; }
-        }
-
-        public Type EvidenceType
-        {
-            get { return m_legacyEvidence.GetType(); }
-        }
-
-        public override bool Equals(object obj)
-        {
-            return m_legacyEvidence.Equals(obj);
-        }
-
-        public override int GetHashCode()
-        {
-            return m_legacyEvidence.GetHashCode();
-        }
-
-        public override EvidenceBase Clone()
-        {
-            return base.Clone();
-        }
-    }
-
-    /// <summary>
-    ///     Pre-v4 versions of the runtime allow multiple pieces of evidence that all have the same type.
-    ///     This type wraps those evidence objects into a single type of list, allowing legacy code to continue
-    ///     to work with the Evidence collection that does not expect multiple evidences of the same type.
-    ///     
-    ///     This may not be limited to LegacyEvidenceWrappers, since it's valid for legacy code to add multiple
-    ///     objects of built-in evidence to an Evidence collection.  The built-in evidence now derives from
-    ///     EvienceObject, so when the legacy code runs on v4, it may end up attempting to add multiple
-    ///     Hash evidences for intsance.
-    /// </summary>
-    [Serializable]
-    internal sealed class LegacyEvidenceList : EvidenceBase, IEnumerable<EvidenceBase>, ILegacyEvidenceAdapter
-    {
-        private List<EvidenceBase> m_legacyEvidenceList = new List<EvidenceBase>();
-
-        public object EvidenceObject
-        {
-            get
-            {
-                // We'll choose the first item in the list to represent us if we're forced to return only
-                // one object. This can occur if multiple pieces of evidence are added via the legacy APIs,
-                // and then the new APIs are used to retrieve that evidence.
-                return m_legacyEvidenceList.Count > 0 ? m_legacyEvidenceList[0] : null;
-            }
-        }
-
-        public Type EvidenceType
-        {
-            get
-            {
-                Debug.Assert(m_legacyEvidenceList.Count > 0, "No items in LegacyEvidenceList, cannot tell what type they are");
-
-                ILegacyEvidenceAdapter adapter = m_legacyEvidenceList[0] as ILegacyEvidenceAdapter;
-                return adapter == null ? m_legacyEvidenceList[0].GetType() : adapter.EvidenceType;
-            }
-        }
-
-        public void Add(EvidenceBase evidence)
-        {
-            Debug.Assert(evidence != null);
-            Debug.Assert(m_legacyEvidenceList.Count == 0 || EvidenceType == evidence.GetType() || (evidence is LegacyEvidenceWrapper && (evidence as LegacyEvidenceWrapper).EvidenceType == EvidenceType),
-                            "LegacyEvidenceList must be homogeonous");
-            Debug.Assert(evidence.GetType() != typeof(LegacyEvidenceList),
-                            "Attempt to add a legacy evidence list to another legacy evidence list");
-
-            m_legacyEvidenceList.Add(evidence);
-        }
-
-        public IEnumerator<EvidenceBase> GetEnumerator()
-        {
-            return m_legacyEvidenceList.GetEnumerator();
-        }
-
-        IEnumerator System.Collections.IEnumerable.GetEnumerator()
-        {
-            return m_legacyEvidenceList.GetEnumerator();
-        }
-
-        public override EvidenceBase Clone()
-        {
-            return base.Clone();
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Policy/EvidenceTypeDescriptor.cs b/src/mscorlib/src/System/Security/Policy/EvidenceTypeDescriptor.cs
deleted file mode 100644
index 8deb145102..0000000000
--- a/src/mscorlib/src/System/Security/Policy/EvidenceTypeDescriptor.cs
+++ /dev/null
@@ -1,160 +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.
-using System;
-using System.Diagnostics;
-using System.Diagnostics.Contracts;
-using System.Runtime.Serialization;
-
-namespace System.Security.Policy
-{
-    /// <summary>
-    ///     Descriptor stored in the Evidence collection to detail the information we have about a type of
-    ///     evidence. This descriptor also stores any evidence that's been generated of the specific type.
-    /// </summary>
-    [Serializable]
-    internal sealed class EvidenceTypeDescriptor
-    {
-        [NonSerialized]
-        private bool m_hostCanGenerate;
-
-        [NonSerialized]
-        private bool m_generated;
-
-        private EvidenceBase m_hostEvidence;
-        private EvidenceBase m_assemblyEvidence;
-
-        // EvidenceTypeDescriptors are stored in Evidence indexed by the type they describe, so this
-        // information is redundant.  We keep it around in checked builds to help debugging, but we can drop
-        // it from retial builds.
-#if _DEBUG
-        [NonSerialized]
-        private Type m_evidenceType;
-#endif // _DEBUG
-
-        public EvidenceTypeDescriptor()
-        {
-        }
-
-        /// <summary>
-        ///     Make a deep copy of a type descriptor
-        /// </summary>
-        private EvidenceTypeDescriptor(EvidenceTypeDescriptor descriptor)
-        {
-            Debug.Assert(descriptor != null);
-
-            m_hostCanGenerate = descriptor.m_hostCanGenerate;
-
-            if (descriptor.m_assemblyEvidence != null)
-            {
-                m_assemblyEvidence = descriptor.m_assemblyEvidence.Clone() as EvidenceBase;
-            }
-            if (descriptor.m_hostEvidence != null)
-            {
-                m_hostEvidence = descriptor.m_hostEvidence.Clone() as EvidenceBase;
-            }
-
-#if _DEBUG
-            m_evidenceType = descriptor.m_evidenceType;
-#endif // _DEBUG
-        }
-
-        /// <summary>
-        ///     Evidence of this type supplied by the assembly
-        /// </summary>
-        public EvidenceBase AssemblyEvidence
-        {
-            get { return m_assemblyEvidence; }
-
-            set
-            {
-                Debug.Assert(value != null);
-#if _DEBUG
-                Debug.Assert(CheckEvidenceType(value), "Incorrect type of AssemblyEvidence set");
-#endif
-                m_assemblyEvidence = value;
-            }
-        }
-
-        /// <summary>
-        ///     Flag indicating that we've already attempted to generate this type of evidence
-        /// </summary>
-        public bool Generated
-        {
-            get { return m_generated; }
-
-            set
-            {
-                Debug.Assert(value, "Attempt to clear the Generated flag");
-                m_generated = value;
-            }
-        }
-
-        /// <summary>
-        ///     Has the HostSecurityManager has told us that it can potentially generate evidence of this type
-        /// </summary>
-        public bool HostCanGenerate
-        {
-            get { return m_hostCanGenerate; }
-
-            set
-            {
-                Debug.Assert(value, "Attempt to clear HostCanGenerate flag");
-                m_hostCanGenerate = value;
-            }
-        }
-
-        /// <summary>
-        ///     Evidence of this type supplied by the CLR or the host
-        /// </summary>
-        public EvidenceBase HostEvidence
-        {
-            get { return m_hostEvidence; }
-
-            set
-            {
-                Debug.Assert(value != null);
-#if _DEBUG
-                Debug.Assert(CheckEvidenceType(value), "Incorrect type of HostEvidence set");
-#endif
-                m_hostEvidence = value;
-            }
-        }
-
-#if _DEBUG
-        /// <summary>
-        ///     Verify that evidence being stored in this descriptor is of the correct type
-        /// </summary>
-        private bool CheckEvidenceType(EvidenceBase evidence)
-        {
-            Debug.Assert(evidence != null);
-
-            ILegacyEvidenceAdapter legacyAdapter = evidence as ILegacyEvidenceAdapter;
-            Type storedType = legacyAdapter == null ? evidence.GetType() : legacyAdapter.EvidenceType;
-
-            return m_evidenceType == null || m_evidenceType.IsAssignableFrom(storedType);
-        }
-#endif // _DEBUG
-
-        /// <summary>
-        ///     Make a deep copy of this descriptor
-        /// </summary>
-        public EvidenceTypeDescriptor Clone()
-        {
-            return new EvidenceTypeDescriptor(this);
-        }
-
-#if _DEBUG
-        /// <summary>
-        ///     Set the type that this evidence descriptor refers to.
-        /// </summary>
-        internal void SetEvidenceType(Type evidenceType)
-        {
-            Debug.Assert(evidenceType != null);
-            Debug.Assert(m_evidenceType == null, "Attempt to reset evidence type");
-
-            m_evidenceType = evidenceType;
-        }
-#endif // _DEBUG
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Policy/IDelayEvaluatedEvidence.cs b/src/mscorlib/src/System/Security/Policy/IDelayEvaluatedEvidence.cs
deleted file mode 100644
index 8f8c07c9e4..0000000000
--- a/src/mscorlib/src/System/Security/Policy/IDelayEvaluatedEvidence.cs
+++ /dev/null
@@ -1,34 +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.
-
-
-namespace System.Security.Policy {
-    /// <summary>
-    ///     Interface for evidence objects that support being "unverified".  For instance, StrongName
-    ///     evidence for a strong name signature which was not yet verified.  This interface is used to
-    ///     keep track of weather or not the evidence object was needed to compute a grant set.  If it was,
-    ///     then we can force verificaiton of the evidence object -- if not we can save time by not doing
-    ///     any verification on it.  (Since we didn't use it for policy resolution, it wouldn't have
-    ///     mattered if the evidence was not present in the first place).
-    /// </summary>
-    internal interface IDelayEvaluatedEvidence {
-        /// <summary>
-        ///     Is this evidence object verified yet?
-        /// </summary>
-        bool IsVerified 
-        { 
-            get; 
-        }
-
-        /// <summary>
-        ///     Was this evidence object used during the course of policy evaluation?
-        /// </summary>
-        bool WasUsed { get; }
-
-        /// <summary>
-        ///     Mark the object as used
-        /// </summary>
-        void MarkUsed();
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Policy/IIdentityPermissionFactory.cs b/src/mscorlib/src/System/Security/Policy/IIdentityPermissionFactory.cs
deleted file mode 100644
index a46f39602d..0000000000
--- a/src/mscorlib/src/System/Security/Policy/IIdentityPermissionFactory.cs
+++ /dev/null
@@ -1,20 +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.
-
-// 
-//
-//  All Identities will implement this interface.
-//
-
-namespace System.Security.Policy {
-    using System.Runtime.Remoting;
-    using System;
-    using System.Security.Util;
-[System.Runtime.InteropServices.ComVisible(true)]
-    public interface IIdentityPermissionFactory
-    {
-        IPermission CreateIdentityPermission( Evidence evidence );
-    }
-
-}
diff --git a/src/mscorlib/src/System/Security/Policy/IRuntimeEvidenceFactory.cs b/src/mscorlib/src/System/Security/Policy/IRuntimeEvidenceFactory.cs
deleted file mode 100644
index 98467fe367..0000000000
--- a/src/mscorlib/src/System/Security/Policy/IRuntimeEvidenceFactory.cs
+++ /dev/null
@@ -1,36 +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.
-
-// 
-
-using System;
-using System.Collections.Generic;
-
-namespace System.Security.Policy
-{
-    /// <summary>
-    ///     IRuntimeEvidenceFactory is implemented by runtime types which the CLR knows how to delay
-    ///     generate evidence for.  It is used by the Evidence class to get evidence on demand when we first
-    ///     need it.
-    /// </summary>
-    internal interface IRuntimeEvidenceFactory
-    {
-        /// <summary>
-        ///     Object which the evidence generated by this factory is used for
-        /// </summary>
-        IEvidenceFactory Target { get; }
-
-        /// <summary>
-        ///     Get the collection of evidence objects supplied by the factory itself, rather than by the
-        ///     runtime.
-        /// </summary>
-        IEnumerable<EvidenceBase> GetFactorySuppliedEvidence();
-
-        /// <summary>
-        ///     Generate a specific type of evidence for this object, returning null if the specified type of
-        ///     evidence cannot be generated.
-        /// </summary>
-        EvidenceBase GenerateEvidence(Type evidenceType);
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Policy/PolicyException.cs b/src/mscorlib/src/System/Security/Policy/PolicyException.cs
deleted file mode 100644
index 68e87f780d..0000000000
--- a/src/mscorlib/src/System/Security/Policy/PolicyException.cs
+++ /dev/null
@@ -1,50 +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.
-
-// 
-//
-//  Use this class to throw a PolicyException
-//
-
-namespace System.Security.Policy {
-    
-    using System;
-    using System.Runtime.Serialization;
-    [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public class PolicyException : SystemException
-    {
-        public PolicyException()
-        
-            : base(Environment.GetResourceString( "Policy_Default" )) {
-            HResult = __HResults.CORSEC_E_POLICY_EXCEPTION;
-        }
-    
-        public PolicyException(String message)
-        
-            : base(message) {
-            HResult = __HResults.CORSEC_E_POLICY_EXCEPTION;
-        }
-        
-        public PolicyException(String message, Exception exception)
-        
-            : base(message, exception) {
-            HResult = __HResults.CORSEC_E_POLICY_EXCEPTION;
-        }
-
-        protected PolicyException(SerializationInfo info, StreamingContext context) : base (info, context) {}
-
-        internal PolicyException(String message, int hresult) : base (message)
-        {
-            HResult = hresult;
-        }
-
-        internal PolicyException(String message, int hresult, Exception exception) : base (message, exception)
-        {
-            HResult = hresult;
-        }
-
-    }
-
-}
diff --git a/src/mscorlib/src/System/Security/Policy/PolicyStatement.cs b/src/mscorlib/src/System/Security/Policy/PolicyStatement.cs
deleted file mode 100644
index 9b58ece9f1..0000000000
--- a/src/mscorlib/src/System/Security/Policy/PolicyStatement.cs
+++ /dev/null
@@ -1,246 +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.
-
-//
-//  Represents the policy associated with some piece of evidence
-//
-using System.Diagnostics.Contracts;
-namespace System.Security.Policy {
-    
-    using System;
-    using System.Security;
-    using System.Security.Util;
-    using Math = System.Math;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Security.Permissions;
-    using System.Text;
-    using System.Globalization;
-[Serializable]
-    [Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public enum PolicyStatementAttribute
-    {
-        Nothing = 0x0,
-        Exclusive = 0x01,
-        LevelFinal = 0x02,
-        All = 0x03,
-    }
-    
-    [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    sealed public class PolicyStatement : ISecurityPolicyEncodable, ISecurityEncodable
-    {
-        // The PermissionSet associated with this policy
-        internal PermissionSet m_permSet;
-
-        // The bitfield of inheritance properties associated with this policy
-        internal PolicyStatementAttribute m_attributes;
-
-        internal PolicyStatement()
-        {
-            m_permSet = null;
-            m_attributes = PolicyStatementAttribute.Nothing;
-        }
-        
-        public PolicyStatement( PermissionSet permSet )
-            : this( permSet, PolicyStatementAttribute.Nothing )
-        {
-        }
-        
-        public PolicyStatement( PermissionSet permSet, PolicyStatementAttribute attributes )
-        {
-            if (permSet == null)
-            {
-                m_permSet = new PermissionSet( false );
-            }
-            else
-            {
-                m_permSet = permSet.Copy();
-            }
-            if (ValidProperties( attributes ))
-            {
-                m_attributes = attributes;
-            }
-        }
-        
-        private PolicyStatement( PermissionSet permSet, PolicyStatementAttribute attributes, bool copy )
-        {
-            if (permSet != null)
-            {
-                if (copy)
-                    m_permSet = permSet.Copy();
-                else
-                    m_permSet = permSet;
-            }
-            else
-            {
-                m_permSet = new PermissionSet( false );
-            }
-                
-            m_attributes = attributes;
-        }
-
-        public PermissionSet PermissionSet
-        {
-            get
-            {
-                lock (this)
-                {
-                    return m_permSet.Copy();
-                }
-            }
-            
-            set
-            {
-                lock (this)
-                {
-                    if (value == null)
-                    {
-                        m_permSet = new PermissionSet( false );
-                    }
-                    else
-                    {
-                        m_permSet = value.Copy();
-                    }
-                }
-            }
-        }
-        
-        internal void SetPermissionSetNoCopy( PermissionSet permSet )
-        {
-            m_permSet = permSet;
-        }
-        
-        internal PermissionSet GetPermissionSetNoCopy()
-        {
-            lock (this)
-            {
-                return m_permSet;
-            }
-        }
-        
-        public PolicyStatementAttribute Attributes
-        {
-            get
-            {
-                return m_attributes;
-            }
-            
-            set
-            {
-                if (ValidProperties( value ))
-                {
-                    m_attributes = value;
-                }
-            }
-        }
-
-        public PolicyStatement Copy()
-        {
-            // The PolicyStatement .ctor will copy the permission set
-            return new PolicyStatement(m_permSet, Attributes, true);
-        }
-
-        public String AttributeString
-        {
-            get
-            {
-                StringBuilder sb = new StringBuilder();
-            
-                bool first = true;
-            
-                if (GetFlag((int) PolicyStatementAttribute.Exclusive ))
-                {
-                    sb.Append( "Exclusive" );
-                    first = false;
-                }
-                if (GetFlag((int) PolicyStatementAttribute.LevelFinal ))
-                {
-                    if (!first)
-                        sb.Append( " " );
-                    sb.Append( "LevelFinal" );
-                }
-            
-                return sb.ToString();
-            }
-        }
-
-        private static bool ValidProperties( PolicyStatementAttribute attributes )
-        {
-            if ((attributes & ~(PolicyStatementAttribute.All)) == 0)
-            {
-                return true;
-            }
-            else
-            {
-                throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidFlag" ) );
-            }
-        }
-        
-        private bool GetFlag( int flag )
-        {
-            return (flag & (int)m_attributes) != 0;
-        }
-
-        /// <summary>
-        ///     Union a child policy statement into this policy statement
-        /// </summary>
-        internal void InplaceUnion(PolicyStatement childPolicy)
-        {
-            BCLDebug.Assert(childPolicy != null, "childPolicy != null");
-
-            if (((Attributes & childPolicy.Attributes) & PolicyStatementAttribute.Exclusive) == PolicyStatementAttribute.Exclusive)
-            {
-                throw new PolicyException(Environment.GetResourceString( "Policy_MultipleExclusive" ));
-            }
-
-            // We need to merge together our grant set and attributes.  The result of this merge is
-            // dependent upon if we're merging a child marked exclusive or not.  If the child is not
-            // exclusive, we need to union in its grant set and or in its attributes. However, if the child
-            // is exclusive then it is the only code group which should have an effect on the resulting
-            // grant set and therefore our grant should be ignored.
-            if ((childPolicy.Attributes & PolicyStatementAttribute.Exclusive) == PolicyStatementAttribute.Exclusive)
-            {
-                m_permSet = childPolicy.GetPermissionSetNoCopy();
-                Attributes = childPolicy.Attributes;
-            }
-            else
-            {
-                m_permSet.InplaceUnion(childPolicy.GetPermissionSetNoCopy());
-                Attributes = Attributes | childPolicy.Attributes;
-            }
-        }
-
-        [System.Runtime.InteropServices.ComVisible(false)]
-        public override bool Equals( Object obj )
-        {
-            PolicyStatement other = obj as PolicyStatement;
-
-            if (other == null)
-                return false;
-
-            if (this.m_attributes != other.m_attributes)
-                return false;
-
-            if (!Object.Equals( this.m_permSet, other.m_permSet ))
-                return false;
-
-            return true;
-        }
-
-        [System.Runtime.InteropServices.ComVisible(false)]
-        public override int GetHashCode()
-        {
-            int accumulator = (int)this.m_attributes;
-
-            if (m_permSet != null)
-                accumulator = accumulator ^ m_permSet.GetHashCode();
-
-            return accumulator;
-        }
-
-    }
-}
-
diff --git a/src/mscorlib/src/System/Security/Policy/Site.cs b/src/mscorlib/src/System/Security/Policy/Site.cs
deleted file mode 100644
index 14a95e1666..0000000000
--- a/src/mscorlib/src/System/Security/Policy/Site.cs
+++ /dev/null
@@ -1,105 +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.
-
-// 
-
-//
-//
-//  Site is an IIdentity representing internet sites.
-//
-
-using System;
-using System.Diagnostics;
-using System.Diagnostics.Contracts;
-using System.Globalization;
-using System.Security.Permissions;
-using System.Security.Util;
-
-namespace System.Security.Policy
-{
-    [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class Site : EvidenceBase, IIdentityPermissionFactory
-    {
-        private SiteString m_name;
-
-        public Site(String name)
-        {
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-            Contract.EndContractBlock();
-
-            m_name = new SiteString( name );
-        }
-
-        private Site(SiteString name)
-        {
-            Debug.Assert(name != null);
-            m_name = name;
-        }
-
-        public static Site CreateFromUrl( String url )
-        {
-            return new Site(ParseSiteFromUrl(url));
-        }
-
-        private static SiteString ParseSiteFromUrl( String name )
-        {
-            URLString urlString = new URLString( name );
-
-            if (String.Compare( urlString.Scheme, "file", StringComparison.OrdinalIgnoreCase) == 0)
-                throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidSite" ) );
-
-            return new SiteString( new URLString( name ).Host );
-        }
-
-        public String Name
-        {
-            get { return m_name.ToString(); }
-        }
-
-        internal SiteString GetSiteString()
-        {
-            return m_name;
-        }
-
-        public IPermission CreateIdentityPermission( Evidence evidence )
-        {
-            return new SiteIdentityPermission( Name );
-        }
-
-        public override bool Equals(Object o)
-        {
-            Site other = o as Site;
-            if (other == null)
-            {
-                return false;
-            }
-
-            return String.Equals(Name, other.Name, StringComparison.OrdinalIgnoreCase);
-        }
-
-        public override int GetHashCode()
-        {
-            return Name.GetHashCode();
-        }
-
-        public override EvidenceBase Clone()
-        {
-            return new Site(m_name);
-        }
-
-        public Object Copy()
-        {
-            return Clone();
-        }
-
-        // INormalizeForIsolatedStorage is not implemented for startup perf
-        // equivalent to INormalizeForIsolatedStorage.Normalize()
-        internal Object Normalize()
-        {
-            return m_name.ToString().ToUpper(CultureInfo.InvariantCulture);
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Policy/StrongName.cs b/src/mscorlib/src/System/Security/Policy/StrongName.cs
deleted file mode 100644
index 999b478ba7..0000000000
--- a/src/mscorlib/src/System/Security/Policy/StrongName.cs
+++ /dev/null
@@ -1,171 +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.
-
-// 
-
-//
-//
-// StrongName is an IIdentity representing strong names.
-//
-
-namespace System.Security.Policy {
-    using System.IO;
-    using System.Reflection;
-    using System.Security.Util;
-    using System.Security.Permissions;
-    using System.Diagnostics.Contracts;
-    using CultureInfo = System.Globalization.CultureInfo;
-
-    [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class StrongName : EvidenceBase, IIdentityPermissionFactory, IDelayEvaluatedEvidence
-    {
-        private StrongNamePublicKeyBlob m_publicKeyBlob;
-        private String m_name;
-        private Version m_version;
-
-        // Delay evaluated evidence is for policy resolution only, so it doesn't make sense to save that
-        // state away and then try to evaluate the strong name later.
-        [NonSerialized]
-        private RuntimeAssembly m_assembly = null;
-
-        [NonSerialized]
-        private bool m_wasUsed = false;
-
-        internal StrongName() {}
-
-        public StrongName( StrongNamePublicKeyBlob blob, String name, Version version ) : this(blob, name, version, null)
-        {
-        }
-
-        internal StrongName(StrongNamePublicKeyBlob blob, String name, Version version, Assembly assembly)
-        {
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-            if (String.IsNullOrEmpty(name))
-                throw new ArgumentException(Environment.GetResourceString("Argument_EmptyStrongName"));
-
-            if (blob == null)
-                throw new ArgumentNullException(nameof(blob));
-
-            if (version == null)
-                throw new ArgumentNullException(nameof(version));
-            Contract.EndContractBlock();
-
-            RuntimeAssembly rtAssembly = assembly as RuntimeAssembly;
-            if (assembly != null && rtAssembly == null)
-                throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeAssembly"), nameof(assembly));
-
-            m_publicKeyBlob = blob;
-            m_name = name;
-            m_version = version;
-            m_assembly = rtAssembly;
-        }
-
-        public StrongNamePublicKeyBlob PublicKey
-        {
-            get
-            {
-                return m_publicKeyBlob;
-            }
-        }
-
-        public String Name
-        {
-            get
-            {
-                return m_name;
-            }
-        }
-
-        public Version Version
-        {
-            get
-            {
-                return m_version;
-            }
-        }
-
-        bool IDelayEvaluatedEvidence.IsVerified
-        {
-            get
-            {
-                return true;
-            }
-        }
-
-        bool IDelayEvaluatedEvidence.WasUsed
-        {
-            get { return m_wasUsed; }
-        }
-
-        void IDelayEvaluatedEvidence.MarkUsed()
-        {
-            m_wasUsed = true;
-        }
-
-        internal static bool CompareNames( String asmName, String mcName )
-        {
-            if (mcName.Length > 0 && mcName[mcName.Length-1] == '*' && mcName.Length - 1 <= asmName.Length)
-                return String.Compare( mcName, 0, asmName, 0, mcName.Length - 1, StringComparison.OrdinalIgnoreCase) == 0;
-            else
-                return String.Compare( mcName, asmName, StringComparison.OrdinalIgnoreCase) == 0;
-        }
-
-        public IPermission CreateIdentityPermission( Evidence evidence )
-        {
-            return new StrongNameIdentityPermission( m_publicKeyBlob, m_name, m_version );
-        }
-
-        public override EvidenceBase Clone()
-        {
-            return new StrongName(m_publicKeyBlob, m_name, m_version);
-        }
-
-        public Object Copy()
-        {
-            return Clone();
-        }
-
-        public override bool Equals( Object o )
-        {
-            StrongName that = (o as StrongName);
-            return (that != null) &&
-                   Equals( this.m_publicKeyBlob, that.m_publicKeyBlob ) &&
-                   Equals( this.m_name, that.m_name ) &&
-                   Equals( this.m_version, that.m_version );
-        }
-
-        public override int GetHashCode()
-        {
-            if (m_publicKeyBlob != null)
-            {
-                return m_publicKeyBlob.GetHashCode();
-            }
-            else if (m_name != null || m_version != null)
-            {
-                return (m_name == null ? 0 : m_name.GetHashCode()) + (m_version == null ? 0 : m_version.GetHashCode());
-            }
-            else
-            {
-                return typeof( StrongName ).GetHashCode();
-            }
-        }
-
-        // INormalizeForIsolatedStorage is not implemented for startup perf
-        // equivalent to INormalizeForIsolatedStorage.Normalize()
-        internal Object Normalize()
-        {
-            MemoryStream ms = new MemoryStream();
-            BinaryWriter bw = new BinaryWriter(ms);
-
-            bw.Write(m_publicKeyBlob.PublicKey);
-            bw.Write(m_version.Major);
-            bw.Write(m_name);
-
-            ms.Position = 0;
-            return ms;
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Policy/URL.cs b/src/mscorlib/src/System/Security/Policy/URL.cs
deleted file mode 100644
index 3541124ac6..0000000000
--- a/src/mscorlib/src/System/Security/Policy/URL.cs
+++ /dev/null
@@ -1,98 +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.
-
-// 
-
-//
-//
-//  Url is an IIdentity representing url internet sites.
-//
-
-namespace System.Security.Policy {
-    using System.IO;
-    using System.Security.Util;
-    using UrlIdentityPermission = System.Security.Permissions.UrlIdentityPermission;
-    using System.Runtime.Serialization;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-
-    [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class Url : EvidenceBase, IIdentityPermissionFactory
-    {
-        private URLString m_url;
-
-        internal Url( String name, bool parsed )
-        {
-            if (name == null)
-                throw new ArgumentNullException( nameof(name) );
-            Contract.EndContractBlock();
-
-            m_url = new URLString( name, parsed );
-        }
-
-        public Url( String name )
-        {
-            if (name == null)
-                throw new ArgumentNullException( nameof(name) );
-            Contract.EndContractBlock();
-
-            m_url = new URLString( name );
-        }
-
-        private Url(Url url)
-        {
-            Debug.Assert(url != null);
-            m_url = url.m_url;
-        }
-
-        public String Value
-        {
-            get { return m_url.ToString(); }
-        }
-
-        internal URLString GetURLString()
-        {
-            return m_url;
-        }
-
-        public IPermission CreateIdentityPermission( Evidence evidence )
-        {
-            return new UrlIdentityPermission( m_url );
-        }
-
-        public override bool Equals(Object o)
-        {
-            Url other = o as Url;
-            if (other == null)
-            {
-                return false;
-            }
-
-            return other.m_url.Equals(m_url);
-        }
-
-        public override int GetHashCode()
-        {
-            return this.m_url.GetHashCode();
-        }
-
-        public override EvidenceBase Clone()
-        {
-            return new Url(this);
-        }
-
-        public Object Copy()
-        {
-            return Clone();
-        }
-
-        // INormalizeForIsolatedStorage is not implemented for startup perf
-        // equivalent to INormalizeForIsolatedStorage.Normalize()
-        internal Object Normalize()
-        {
-            return m_url.NormalizeUrl();
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Policy/Zone.cs b/src/mscorlib/src/System/Security/Policy/Zone.cs
deleted file mode 100644
index a9f5d84aeb..0000000000
--- a/src/mscorlib/src/System/Security/Policy/Zone.cs
+++ /dev/null
@@ -1,93 +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.
-
-// 
-
-//
-//
-//  Zone is an IIdentity representing Internet/Intranet/MyComputer etc.
-//
-
-namespace System.Security.Policy
-{
-    using System.Security.Util;
-    using ZoneIdentityPermission = System.Security.Permissions.ZoneIdentityPermission;
-    using System.Runtime.CompilerServices;
-    using System.Runtime.InteropServices;
-    using System.Runtime.Versioning;
-    using System.Runtime.Serialization;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-
-    [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class Zone : EvidenceBase, IIdentityPermissionFactory
-    {
-        private SecurityZone m_zone;
-
-        private static readonly String[] s_names =
-            {"MyComputer", "Intranet", "Trusted", "Internet", "Untrusted", "NoZone"};
-
-        public Zone(SecurityZone zone)
-        {
-            if (zone < SecurityZone.NoZone || zone > SecurityZone.Untrusted)
-                throw new ArgumentException( Environment.GetResourceString( "Argument_IllegalZone" ) );
-            Contract.EndContractBlock();
-
-            m_zone = zone;
-        }
-
-        private Zone(Zone zone)
-        {
-            Debug.Assert(zone != null);
-            m_zone = zone.m_zone;
-        }
-
-        public IPermission CreateIdentityPermission( Evidence evidence )
-        {
-            return new ZoneIdentityPermission( SecurityZone );
-        }
-
-        public SecurityZone SecurityZone
-        {
-            get
-            {
-                return m_zone;
-            }
-        }
-
-        public override bool Equals(Object o)
-        {
-            Zone other = o as Zone;
-            if (other == null)
-            {
-                return false;
-            }
-
-            return SecurityZone == other.SecurityZone;
-        }
-
-        public override int GetHashCode()
-        {
-            return (int)SecurityZone;
-        }
-
-        public override EvidenceBase Clone()
-        {
-            return new Zone(this);
-        }
-
-        public Object Copy()
-        {
-            return Clone();
-        }
-
-        // INormalizeForIsolatedStorage is not implemented for startup perf
-        // equivalent to INormalizeForIsolatedStorage.Normalize()
-        internal Object Normalize()
-        {
-            return s_names[(int)SecurityZone];
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Principal/IIdentity.cs b/src/mscorlib/src/System/Security/Principal/IIdentity.cs
deleted file mode 100644
index 2bda6c6e3d..0000000000
--- a/src/mscorlib/src/System/Security/Principal/IIdentity.cs
+++ /dev/null
@@ -1,29 +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.
-
-// 
-
-//
-//
-// All identities will implement this interface
-//
-
-namespace System.Security.Principal
-{
-    using System.Runtime.Remoting;
-    using System;
-    using System.Security.Util;
-
-[System.Runtime.InteropServices.ComVisible(true)]
-    public interface IIdentity {
-        // Access to the name string
-        string Name { get; }
-
-        // Access to Authentication 'type' info
-        string AuthenticationType { get; }
-
-        // Determine if this represents the unauthenticated identity
-        bool IsAuthenticated { get; }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Principal/IPrincipal.cs b/src/mscorlib/src/System/Security/Principal/IPrincipal.cs
deleted file mode 100644
index 449cfb50b2..0000000000
--- a/src/mscorlib/src/System/Security/Principal/IPrincipal.cs
+++ /dev/null
@@ -1,26 +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.
-
-// 
-
-//
-//
-// All roles will implement this interface
-//
-
-namespace System.Security.Principal
-{
-    using System.Runtime.Remoting;
-    using System;
-    using System.Security.Util;
-
-[System.Runtime.InteropServices.ComVisible(true)]
-    public interface IPrincipal {
-        // Retrieve the identity object
-        IIdentity Identity { get; }
-
-        // Perform a check for a specific role
-        bool IsInRole (string role);
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Principal/TokenImpersonationLevel.cs b/src/mscorlib/src/System/Security/Principal/TokenImpersonationLevel.cs
deleted file mode 100644
index 9eec46f774..0000000000
--- a/src/mscorlib/src/System/Security/Principal/TokenImpersonationLevel.cs
+++ /dev/null
@@ -1,15 +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.
-
-namespace System.Security.Principal
-{
-    public enum TokenImpersonationLevel
-    {
-        None            = 0,
-        Anonymous       = 1,
-        Identification  = 2,
-        Impersonation   = 3,
-        Delegation      = 4
-    }
-}
diff --git a/src/mscorlib/src/System/Security/SecurityContext.cs b/src/mscorlib/src/System/Security/SecurityContext.cs
deleted file mode 100644
index df949575d7..0000000000
--- a/src/mscorlib/src/System/Security/SecurityContext.cs
+++ /dev/null
@@ -1,45 +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: Capture security  context for a thread
-**
-** 
-===========================================================*/
-namespace System.Security
-{
-    using Microsoft.Win32;
-    using Microsoft.Win32.SafeHandles;
-    using System.Threading;
-    using System.Runtime.Remoting;
-    using System.Collections;
-    using System.Runtime.Serialization;
-    using System.Security.Permissions;
-    using System.Runtime.InteropServices;
-    using System.Runtime.CompilerServices;
-    using System.Runtime.ExceptionServices;
-    using System.Runtime.ConstrainedExecution;
-    using System.Runtime.Versioning;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-
-    // This enum must be kept in sync with the SecurityContextSource enum in the VM
-    public enum SecurityContextSource
-    {
-        CurrentAppDomain = 0,
-        CurrentAssembly
-    }
-
-    internal enum SecurityContextDisableFlow
-    {
-        Nothing = 0,
-        WI = 0x1,
-        All = 0x3FFF
-    }
-
-}
diff --git a/src/mscorlib/src/System/Security/SecurityElement.cs b/src/mscorlib/src/System/Security/SecurityElement.cs
deleted file mode 100644
index f57665b278..0000000000
--- a/src/mscorlib/src/System/Security/SecurityElement.cs
+++ /dev/null
@@ -1,875 +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.
-
-// 
-
-namespace System.Security
-{
-    using System;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Security.Util;
-    using System.Text;
-    using System.Globalization;
-    using System.IO;
-    using System.Security.Permissions;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-
-    internal enum SecurityElementType
-    {
-        Regular = 0,
-        Format = 1,
-        Comment = 2
-    }
-
-    
-    internal interface ISecurityElementFactory
-    {
-        SecurityElement CreateSecurityElement();
-
-        Object Copy();
-
-        String GetTag();
-
-        String Attribute( String attributeName );
-    }
-
-    [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
-    sealed public class SecurityElement : ISecurityElementFactory
-    {
-        internal String  m_strTag;
-        internal String  m_strText;
-        private ArrayList m_lChildren;
-        internal ArrayList m_lAttributes;
-        internal SecurityElementType m_type = SecurityElementType.Regular;
-        
-        private static readonly char[] s_tagIllegalCharacters = new char[] { ' ', '<', '>' };
-        private static readonly char[] s_textIllegalCharacters = new char[] { '<', '>' };
-        private static readonly char[] s_valueIllegalCharacters = new char[] { '<', '>', '\"' };
-        private const String s_strIndent = "   ";
-        
-        private const int c_AttributesTypical = 4 * 2;  // 4 attributes, times 2 strings per attribute
-        private const int c_ChildrenTypical = 1;  
-
-        private static readonly String[] s_escapeStringPairs = new String[]
-            {
-                // these must be all once character escape sequences or a new escaping algorithm is needed
-                "<", "&lt;",
-                ">", "&gt;",
-                "\"", "&quot;",
-                "\'", "&apos;",
-                "&", "&amp;"
-            };
-
-        private static readonly char[] s_escapeChars = new char[] { '<', '>', '\"', '\'', '&' };
-        
-        //-------------------------- Constructors ---------------------------
-        
-        internal SecurityElement()
-        {
-        }
-
-////// ISecurityElementFactory implementation
-
-        SecurityElement ISecurityElementFactory.CreateSecurityElement()
-        {
-            return this;
-        }
-
-        String ISecurityElementFactory.GetTag()
-        {
-            return ((SecurityElement)this).Tag;
-        }
-
-        Object ISecurityElementFactory.Copy()
-        {
-            return ((SecurityElement)this).Copy();
-        }
-
-        String ISecurityElementFactory.Attribute( String attributeName )
-        {
-            return ((SecurityElement)this).Attribute( attributeName );
-        }
-
-        public SecurityElement( String tag )
-        {
-            if (tag == null)
-                throw new ArgumentNullException( nameof(tag) );
-        
-            if (!IsValidTag( tag ))
-                throw new ArgumentException( String.Format( CultureInfo.CurrentCulture, Environment.GetResourceString( "Argument_InvalidElementTag" ), tag ) );
-            Contract.EndContractBlock();
-        
-            m_strTag = tag;
-            m_strText = null;
-        }
-
-        public SecurityElement( String tag, String text )
-        {
-            if (tag == null)
-                throw new ArgumentNullException( nameof(tag) );
-        
-            if (!IsValidTag( tag ))
-                throw new ArgumentException( String.Format( CultureInfo.CurrentCulture, Environment.GetResourceString( "Argument_InvalidElementTag" ), tag ) );
-
-            if (text != null && !IsValidText( text ))
-                throw new ArgumentException( String.Format( CultureInfo.CurrentCulture, Environment.GetResourceString( "Argument_InvalidElementText" ), text ) );
-            Contract.EndContractBlock();
-        
-            m_strTag = tag;
-            m_strText = text;
-        }
-    
-        //-------------------------- Properties -----------------------------
-
-        public String Tag
-        {
-            [Pure]
-            get
-            {
-                return m_strTag;
-            }
-            
-            set
-            {
-                if (value == null)
-                    throw new ArgumentNullException( nameof(Tag) );
-        
-                if (!IsValidTag( value ))
-                    throw new ArgumentException( String.Format( CultureInfo.CurrentCulture, Environment.GetResourceString( "Argument_InvalidElementTag" ), value ) );
-                Contract.EndContractBlock();
-            
-                m_strTag = value;
-            }
-        }
-
-        public Hashtable Attributes
-        {
-            get
-            {
-                if (m_lAttributes == null || m_lAttributes.Count == 0)
-                {
-                    return null;
-                }
-                else
-                {
-                    Hashtable hashtable = new Hashtable( m_lAttributes.Count/2 );
-                                        
-                    int iMax = m_lAttributes.Count;
-                    Debug.Assert( iMax % 2 == 0, "Odd number of strings means the attr/value pairs were not added correctly" );
-                          
-                    for (int i = 0; i < iMax; i += 2)
-                    {
-                        hashtable.Add( m_lAttributes[i], m_lAttributes[i+1]);
-                    }
-                                        
-                    return hashtable;
-                }
-            }
-            
-            set
-            {
-                if (value == null || value.Count == 0)
-                {
-                    m_lAttributes = null;
-                }
-                else
-                {
-                    ArrayList list = new ArrayList(value.Count);
-                    
-                    System.Collections.IDictionaryEnumerator enumerator = (System.Collections.IDictionaryEnumerator)value.GetEnumerator();
-                    
-                    while (enumerator.MoveNext())
-                    {
-                        String attrName = (String)enumerator.Key;
-                        String attrValue = (String)enumerator.Value;
-                    
-                        if (!IsValidAttributeName( attrName ))
-                            throw new ArgumentException( String.Format( CultureInfo.CurrentCulture, Environment.GetResourceString( "Argument_InvalidElementName" ), (String)enumerator.Current ) );
-                        
-                        if (!IsValidAttributeValue( attrValue ))
-                            throw new ArgumentException( String.Format( CultureInfo.CurrentCulture, Environment.GetResourceString( "Argument_InvalidElementValue" ), (String)enumerator.Value ) );
-                    
-                        list.Add(attrName);
-                        list.Add(attrValue);
-                    }
-                    
-                    m_lAttributes = list;
-                }
-            }
-        }
-
-        public String Text
-        {
-            get
-            {
-                return Unescape( m_strText );
-            }
-            
-            set
-            {
-                if (value == null)
-                {
-                    m_strText = null;
-                }
-                else
-                {
-                    if (!IsValidText( value ))
-                        throw new ArgumentException( String.Format( CultureInfo.CurrentCulture, Environment.GetResourceString( "Argument_InvalidElementTag" ), value ) );
-                        
-                    m_strText = value;
-                }
-            }
-        }
-
-        public ArrayList Children
-        {
-            get
-            {
-                ConvertSecurityElementFactories();
-                return m_lChildren;
-            }
-            
-            set
-            {
-                if (value != null)
-                {
-                    IEnumerator enumerator = value.GetEnumerator();
-                    
-                    while (enumerator.MoveNext())
-                    {
-                        if (enumerator.Current == null)
-                            throw new ArgumentException( Environment.GetResourceString( "ArgumentNull_Child" ) );
-                    }
-                }
-            
-                m_lChildren = value;
-            }
-        }
-
-        internal void ConvertSecurityElementFactories()
-        {
-            if (m_lChildren == null)
-                return;
-
-            for (int i = 0; i < m_lChildren.Count; ++i)
-            {
-                ISecurityElementFactory iseFactory = m_lChildren[i] as ISecurityElementFactory;
-                if (iseFactory != null && !(m_lChildren[i] is SecurityElement))
-                    m_lChildren[i] = iseFactory.CreateSecurityElement();
-            }
-        }
-
-        internal ArrayList InternalChildren
-        {
-            get
-            {
-                // Beware!  This array list can contain SecurityElements and other ISecurityElementFactories.
-                // If you want to get a consistent SecurityElement view, call get_Children.
-                return m_lChildren;
-            }
-        }  
-   
-        //-------------------------- Public Methods -----------------------------
-        
-        internal void AddAttributeSafe( String name, String value )
-        {
-            if (m_lAttributes == null)
-            {
-                m_lAttributes = new ArrayList( c_AttributesTypical  );
-            }
-            else
-            {
-                int iMax = m_lAttributes.Count;
-                Debug.Assert( iMax % 2 == 0, "Odd number of strings means the attr/value pairs were not added correctly" );
-                          
-                for (int i = 0; i < iMax; i += 2)
-                {
-                    String strAttrName = (String)m_lAttributes[i];
-                    
-                    if (String.Equals(strAttrName, name))
-                        throw new ArgumentException( Environment.GetResourceString( "Argument_AttributeNamesMustBeUnique" ) );
-                }
-            }
-        
-            m_lAttributes.Add(name);
-            m_lAttributes.Add(value);
-        }        
-        
-        public void AddAttribute( String name, String value )
-        {   
-            if (name == null)
-                throw new ArgumentNullException( nameof(name) );
-                
-            if (value == null)
-                throw new ArgumentNullException( nameof(value) );
-        
-            if (!IsValidAttributeName( name ))
-                throw new ArgumentException( String.Format( CultureInfo.CurrentCulture, Environment.GetResourceString( "Argument_InvalidElementName" ), name ) );
-                
-            if (!IsValidAttributeValue( value ))
-                throw new ArgumentException( String.Format( CultureInfo.CurrentCulture, Environment.GetResourceString( "Argument_InvalidElementValue" ), value ) );
-            Contract.EndContractBlock();
-        
-            AddAttributeSafe( name, value );
-        }
-
-        public void AddChild( SecurityElement child )
-        {   
-            if (child == null)
-                throw new ArgumentNullException( nameof(child) );
-            Contract.EndContractBlock();
-        
-            if (m_lChildren == null)
-                m_lChildren = new ArrayList( c_ChildrenTypical  );
-                
-            m_lChildren.Add( child );
-        }
-
-        internal void AddChild( ISecurityElementFactory child )
-        {
-            if (child == null)
-                throw new ArgumentNullException( nameof(child) );
-            Contract.EndContractBlock();
-        
-            if (m_lChildren == null)
-                m_lChildren = new ArrayList( c_ChildrenTypical  );
-             
-            m_lChildren.Add( child );
-        }            
-
-        internal void AddChildNoDuplicates( ISecurityElementFactory child )
-        {   
-            if (child == null)
-                throw new ArgumentNullException( nameof(child) );
-            Contract.EndContractBlock();
-        
-            if (m_lChildren == null)
-            {
-                m_lChildren = new ArrayList( c_ChildrenTypical  );
-                m_lChildren.Add( child );
-            }
-            else
-            {
-                for (int i = 0; i < m_lChildren.Count; ++i)
-                {
-                    if (m_lChildren[i] == child)
-                        return;
-                }
-                m_lChildren.Add( child );
-            }
-        }
-
-        public bool Equal( SecurityElement other )
-        {
-            if (other == null)
-                return false;
-        
-            // Check if the tags are the same
-            if (!String.Equals(m_strTag, other.m_strTag))
-                return false;
-
-            // Check if the text is the same
-            if (!String.Equals(m_strText, other.m_strText))
-                return false;
-
-            // Check if the attributes are the same and appear in the same
-            // order.
-            
-            // Maybe we can get away by only checking the number of attributes
-            if (m_lAttributes == null || other.m_lAttributes == null)
-            {
-                if (m_lAttributes != other.m_lAttributes)
-                    return false;
-            }
-            else 
-            {                
-                int iMax = m_lAttributes.Count;
-                Debug.Assert( iMax % 2 == 0, "Odd number of strings means the attr/value pairs were not added correctly" );
-
-                if (iMax != other.m_lAttributes.Count)
-                    return false;
-                          
-                for (int i = 0; i < iMax; i++)
-                {
-                    String lhs = (String)m_lAttributes[i];
-                    String rhs = (String)other.m_lAttributes[i];
-                    
-                    if (!String.Equals(lhs, rhs))
-                        return false;
-                }
-            }
-
-            // Finally we must check the child and make sure they are
-            // equal and in the same order
-            
-            // Maybe we can get away by only checking the number of children
-            if (m_lChildren == null || other.m_lChildren == null) 
-            {
-                if (m_lChildren != other.m_lChildren)
-                    return false;
-            } 
-            else 
-            {
-                if (m_lChildren.Count != other.m_lChildren.Count)
-                    return false;
-
-                this.ConvertSecurityElementFactories();
-                other.ConvertSecurityElementFactories();
-
-                // Okay, we'll need to go through each one of them
-                IEnumerator lhs = m_lChildren.GetEnumerator();
-                IEnumerator rhs = other.m_lChildren.GetEnumerator();
-
-                SecurityElement e1, e2;
-                while (lhs.MoveNext())
-                {
-                    rhs.MoveNext();
-                    e1 = (SecurityElement)lhs.Current;
-                    e2 = (SecurityElement)rhs.Current;       
-                    if (e1 == null || !e1.Equal(e2))                
-                        return false;
-                }
-            }
-            return true;
-        }
-
-        [System.Runtime.InteropServices.ComVisible(false)]
-        public SecurityElement Copy()
-        {
-            SecurityElement element = new SecurityElement( this.m_strTag, this.m_strText );
-            element.m_lChildren = this.m_lChildren == null ? null : new ArrayList( this.m_lChildren );
-            element.m_lAttributes = this.m_lAttributes == null ? null : new ArrayList(this.m_lAttributes);
-
-            return element;
-        }
-
-        [Pure]
-        public static bool IsValidTag( String tag )
-        {
-            if (tag == null)
-                return false;
-                
-            return tag.IndexOfAny( s_tagIllegalCharacters ) == -1;
-        }
-
-        [Pure]
-        public static bool IsValidText( String text )
-        {
-            if (text == null)
-                return false;
-                
-            return text.IndexOfAny( s_textIllegalCharacters ) == -1;
-        }
-
-        [Pure]
-        public static bool IsValidAttributeName( String name )
-        {
-            return IsValidTag( name );
-        }
-        
-        [Pure]
-        public static bool IsValidAttributeValue( String value )
-        {
-            if (value == null)
-                return false;
-                
-            return value.IndexOfAny( s_valueIllegalCharacters ) == -1;
-        }
-
-        private static String GetEscapeSequence( char c )
-        {
-            int iMax = s_escapeStringPairs.Length;
-            Debug.Assert( iMax % 2 == 0, "Odd number of strings means the attr/value pairs were not added correctly" );
-                          
-            for (int i = 0; i < iMax; i += 2)
-            {
-                String strEscSeq = s_escapeStringPairs[i];
-                String strEscValue = s_escapeStringPairs[i+1];
-
-                if (strEscSeq[0] == c)
-                    return strEscValue;
-            }
-
-            Debug.Assert( false, "Unable to find escape sequence for this character" );
-            return c.ToString();
-        }
-
-        public static String Escape( String str )
-        {
-            if (str == null)
-                return null;
-
-            StringBuilder sb = null;
-
-            int strLen = str.Length;
-            int index; // Pointer into the string that indicates the location of the current '&' character
-            int newIndex = 0; // Pointer into the string that indicates the start index of the "remaining" string (that still needs to be processed).
-
-
-            do
-            {
-                index = str.IndexOfAny( s_escapeChars, newIndex );
-
-                if (index == -1)
-                {
-                    if (sb == null)
-                        return str;
-                    else
-                    {
-                        sb.Append( str, newIndex, strLen - newIndex );
-                        return sb.ToString();
-                    }
-                }
-                else
-                {
-                    if (sb == null)
-                        sb = new StringBuilder();                    
-
-                    sb.Append( str, newIndex, index - newIndex );
-                    sb.Append( GetEscapeSequence( str[index] ) );
-
-                    newIndex = ( index + 1 );
-                }
-            }
-            while (true);
-            
-            // no normal exit is possible
-        }
-
-        private static String GetUnescapeSequence( String str, int index, out int newIndex )
-        {
-            int maxCompareLength = str.Length - index;
-
-            int iMax = s_escapeStringPairs.Length;
-            Debug.Assert( iMax % 2 == 0, "Odd number of strings means the attr/value pairs were not added correctly" );
-                          
-            for (int i = 0; i < iMax; i += 2)
-            {
-                String strEscSeq = s_escapeStringPairs[i];
-                String strEscValue = s_escapeStringPairs[i+1];
-                
-                int length = strEscValue.Length;
-
-                if (length <= maxCompareLength && String.Compare( strEscValue, 0, str, index, length, StringComparison.Ordinal) == 0)
-                {
-                    newIndex = index + strEscValue.Length;
-                    return strEscSeq;
-                }
-            }
-
-            newIndex = index + 1;
-            return str[index].ToString();
-        }
-            
-
-        private static String Unescape( String str )
-        {
-            if (str == null)
-                return null;
-
-            StringBuilder sb = null;
-
-            int strLen = str.Length;
-            int index; // Pointer into the string that indicates the location of the current '&' character
-            int newIndex = 0; // Pointer into the string that indicates the start index of the "remainging" string (that still needs to be processed).
-
-            do
-            {
-                index = str.IndexOf( '&', newIndex );
-
-                if (index == -1)
-                {
-                    if (sb == null)
-                        return str;
-                    else
-                    {
-                        sb.Append( str, newIndex, strLen - newIndex );
-                        return sb.ToString();
-                    }
-                }
-                else
-                {
-                    if (sb == null)
-                        sb = new StringBuilder();
-
-                    sb.Append(str,  newIndex, index - newIndex);
-                    sb.Append( GetUnescapeSequence( str, index, out newIndex ) ); // updates the newIndex too
-
-                }
-            }
-            while (true);
-
-            // C# reports a warning if I leave this in, but I still kinda want to just in case.
-            // Debug.Assert( false, "If you got here, the execution engine or compiler is really confused" );
-            // return str;
-        }
-
-        private delegate void ToStringHelperFunc( Object obj, String str );
-
-        private static void ToStringHelperStringBuilder( Object obj, String str )
-        {
-            ((StringBuilder)obj).Append( str );
-        }
-
-        public override String ToString ()
-        {
-            StringBuilder sb = new StringBuilder();
-
-            ToString( "", sb, new ToStringHelperFunc( ToStringHelperStringBuilder ) );
-
-            return sb.ToString();
-        }
-
-        private void ToString( String indent, Object obj, ToStringHelperFunc func )
-        {
-            // First add the indent
-            
-            // func( obj, indent );
-            
-            // Add in the opening bracket and the tag.
-            
-            func( obj, "<" );
-
-            switch (m_type)
-            {
-                case SecurityElementType.Format:
-                    func( obj, "?" );
-                    break;
-
-                case SecurityElementType.Comment:
-                    func( obj, "!" );
-                    break;
-
-                default:
-                    break;
-            }
-
-            func( obj, m_strTag );
-            
-            // If there are any attributes, plop those in.
-            
-            if (m_lAttributes != null && m_lAttributes.Count > 0)
-            {
-                func( obj, " " );
-
-                int iMax = m_lAttributes.Count;
-                Debug.Assert( iMax % 2 == 0, "Odd number of strings means the attr/value pairs were not added correctly" );
-                          
-                for (int i = 0; i < iMax; i += 2)
-                {
-                    String strAttrName = (String)m_lAttributes[i];
-                    String strAttrValue = (String)m_lAttributes[i+1];
-                    
-                    func( obj, strAttrName );
-                    func( obj, "=\"" );
-                    func( obj, strAttrValue );
-                    func( obj, "\"" );
-
-                    if (i != m_lAttributes.Count - 2)
-                    {
-                        if (m_type == SecurityElementType.Regular)
-                        {
-                            func( obj, Environment.NewLine );
-                        }
-                        else
-                        {
-                            func( obj, " " );
-                        }
-                    }
-                }
-            }
-         
-            if (m_strText == null && (m_lChildren == null || m_lChildren.Count == 0))
-            {
-                // If we are a single tag with no children, just add the end of tag text.
-    
-                switch (m_type)
-                {
-                    case SecurityElementType.Comment:
-                        func( obj, ">" );
-                        break;
-
-                    case SecurityElementType.Format:
-                        func( obj, " ?>" );
-                        break;
-
-                    default:
-                        func( obj, "/>" );
-                        break;
-                }
-                func( obj, Environment.NewLine );
-            }
-            else
-            {
-                // Close the current tag.
-            
-                func( obj, ">" );
-                
-                // Output the text
-                
-                func( obj, m_strText );
-                
-                // Output any children.
-                
-                if (m_lChildren != null)
-                {
-                    this.ConvertSecurityElementFactories();
-
-                    func( obj, Environment.NewLine );
-                
-                    // String childIndent = indent + s_strIndent;
-                
-                    for (int i = 0; i < m_lChildren.Count; ++i)                    
-                    {
-                        ((SecurityElement)m_lChildren[i]).ToString( "", obj, func );
-                    }
-
-                    // In the case where we have children, the close tag will not be on the same line as the
-                    // opening tag, so we need to indent.
-
-                    // func( obj, indent );
-                }
-                
-                // Output the closing tag
-                
-                func( obj, "</" );
-                func( obj, m_strTag );
-                func( obj, ">" );
-                func( obj, Environment.NewLine );
-            }
-        }
-                
-                
-
-        public String Attribute( String name )
-        {
-            if (name == null)
-                throw new ArgumentNullException( nameof(name) );
-            Contract.EndContractBlock();
-                
-            // Note: we don't check for validity here because an
-            // if an invalid name is passed we simply won't find it.
-        
-            if (m_lAttributes == null)
-                return null;
-                            
-            // Go through all the attribute and see if we know about
-            // the one we are asked for
-
-            int iMax = m_lAttributes.Count;
-            Debug.Assert( iMax % 2 == 0, "Odd number of strings means the attr/value pairs were not added correctly" );
-                          
-            for (int i = 0; i < iMax; i += 2)
-            {
-                String strAttrName = (String)m_lAttributes[i];
-                
-                if (String.Equals(strAttrName, name))
-                {
-                    String strAttrValue = (String)m_lAttributes[i+1];
-                    
-                    return Unescape(strAttrValue);
-                }
-            }
-
-            // In the case where we didn't find it, we are expected to
-            // return null
-            return null;
-        }
-
-        public SecurityElement SearchForChildByTag( String tag )
-        {
-            // Go through all the children and see if we can
-            // find the one are are asked for (matching tags)
-
-            if (tag == null)
-                throw new ArgumentNullException( nameof(tag) );
-            Contract.EndContractBlock();
-                
-            // Note: we don't check for a valid tag here because
-            // an invalid tag simply won't be found.    
-                
-            if (m_lChildren == null)
-                return null;
-
-            IEnumerator enumerator = m_lChildren.GetEnumerator();
-
-            while (enumerator.MoveNext())
-            {
-                SecurityElement current = (SecurityElement)enumerator.Current;
-            
-                if (current != null && String.Equals(current.Tag, tag))
-                    return current;
-            }
-            return null;
-        }
-
-        internal String SearchForTextOfLocalName(String strLocalName) 
-        {
-            // Search on each child in order and each
-            // child's child, depth-first
-            
-            if (strLocalName == null)
-                throw new ArgumentNullException( nameof(strLocalName) );
-            Contract.EndContractBlock();
-                
-            // Note: we don't check for a valid tag here because
-            // an invalid tag simply won't be found.    
-            
-            // First we check this.
-            
-            if (m_strTag == null) return null;            
-            if (m_strTag.Equals( strLocalName ) || m_strTag.EndsWith( ":" + strLocalName, StringComparison.Ordinal ))
-                return Unescape( m_strText );               
-            if (m_lChildren == null)
-                return null;
-
-            IEnumerator enumerator = m_lChildren.GetEnumerator();
-
-            while (enumerator.MoveNext())
-            {
-                String current = ((SecurityElement)enumerator.Current).SearchForTextOfLocalName( strLocalName );
-            
-                if (current != null)
-                    return current;
-            }
-            return null;            
-        }
-
-        public String SearchForTextOfTag( String tag )
-        {
-            // Search on each child in order and each
-            // child's child, depth-first
-            
-            if (tag == null)
-                throw new ArgumentNullException( nameof(tag) );
-            Contract.EndContractBlock();
-                
-            // Note: we don't check for a valid tag here because
-            // an invalid tag simply won't be found.    
-            
-            // First we check this.
-            
-            if (String.Equals(m_strTag, tag))
-                return Unescape( m_strText );              
-            if (m_lChildren == null)
-                return null;
-
-            IEnumerator enumerator = m_lChildren.GetEnumerator();
-
-            this.ConvertSecurityElementFactories();
-
-            while (enumerator.MoveNext())
-            {
-                String current = ((SecurityElement)enumerator.Current).SearchForTextOfTag( tag );
-            
-                if (current != null)
-                    return current;
-            }
-            return null;
-        } 
-    }                        
-}
diff --git a/src/mscorlib/src/System/Security/SecurityException.cs b/src/mscorlib/src/System/Security/SecurityException.cs
index b0ad145c6f..8811be82ff 100644
--- a/src/mscorlib/src/System/Security/SecurityException.cs
+++ b/src/mscorlib/src/System/Security/SecurityException.cs
@@ -18,27 +18,23 @@ namespace System.Security
     using System.Security;
     using System;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     using System.Reflection;
     using System.Text;
     using System.Security.Policy;
     using System.IO;
     using System.Globalization;
-    using System.Security.Util;
     using System.Diagnostics.Contracts;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class SecurityException : SystemException
     {
         internal static string GetResString(string sResourceName)
         {
-            PermissionSet.s_fullTrust.Assert();
             return Environment.GetResourceString(sResourceName);
         }
 
 #pragma warning disable 618
-        internal static Exception MakeSecurityException(AssemblyName asmName, Evidence asmEvidence, PermissionSet granted, PermissionSet refused, RuntimeMethodHandleInternal rmh, SecurityAction action, Object demand, IPermission permThatFailed)
+        internal static Exception MakeSecurityException(AssemblyName asmName, Evidence asmEvidence, RuntimeMethodHandleInternal rmh, Object demand)
 #pragma warning restore 618
         {
             return new SecurityException(GetResString("Arg_SecurityException"));
@@ -63,16 +59,6 @@ namespace System.Security
             SetErrorCode(System.__HResults.COR_E_SECURITY);
         }
 
-        internal SecurityException(PermissionSet grantedSetObj, PermissionSet refusedSetObj)
-            : this(){}
-#pragma warning disable 618
-        internal SecurityException(string message, AssemblyName assemblyName, PermissionSet grant, PermissionSet refused, MethodInfo method, SecurityAction action, Object demanded, IPermission permThatFailed, Evidence evidence)
-#pragma warning restore 618
-                    : this(){}
-
-        internal SecurityException(string message, Object deny, Object permitOnly, MethodInfo method, Object demanded, IPermission permThatFailed)
-                    : this(){}
-
         protected SecurityException(SerializationInfo info, StreamingContext context) : base(info, context)
         {
             if (info == null)
@@ -85,22 +71,6 @@ namespace System.Security
             return base.ToString();
         }
 
-        private bool CanAccessSensitiveInfo()
-        {
-            bool retVal = false;
-            try
-            {
-#pragma warning disable 618
-                new SecurityPermission(SecurityPermissionFlag.ControlEvidence | SecurityPermissionFlag.ControlPolicy).Demand();
-#pragma warning restore 618
-                retVal = true;
-            }
-            catch (SecurityException)
-            {
-            }
-            return retVal;
-        }
-
         public override void GetObjectData(SerializationInfo info, StreamingContext context)
         {
             if (info == null)
diff --git a/src/mscorlib/src/System/Security/SecurityManager.cs b/src/mscorlib/src/System/Security/SecurityManager.cs
deleted file mode 100644
index 933fe0be3d..0000000000
--- a/src/mscorlib/src/System/Security/SecurityManager.cs
+++ /dev/null
@@ -1,157 +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.
-
-//
-// The SecurityManager class provides a general purpose API for interacting
-// with the security system.
-//
-
-namespace System.Security
-{
-    using System;
-    using System.Security.Permissions;
-    using System.Runtime.InteropServices;
-    using System.Runtime.CompilerServices;
-
-    [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public enum PolicyLevelType
-    {
-        User = 0,
-        Machine = 1,
-        Enterprise = 2,
-        AppDomain = 3
-    }
-
-    [System.Runtime.InteropServices.ComVisible(true)]
-    static public class SecurityManager
-    {
-        private static int[][] s_BuiltInPermissionIndexMap = {
-            new int[] { BuiltInPermissionIndex.EnvironmentPermissionIndex, (int) PermissionType.EnvironmentPermission },
-            new int[] { BuiltInPermissionIndex.FileDialogPermissionIndex, (int) PermissionType.FileDialogPermission },
-            new int[] { BuiltInPermissionIndex.FileIOPermissionIndex, (int) PermissionType.FileIOPermission },
-            new int[] { BuiltInPermissionIndex.ReflectionPermissionIndex, (int) PermissionType.ReflectionPermission },
-            new int[] { BuiltInPermissionIndex.SecurityPermissionIndex, (int) PermissionType.SecurityPermission },
-            new int[] { BuiltInPermissionIndex.UIPermissionIndex, (int) PermissionType.UIPermission }
-        };
-
-        private static CodeAccessPermission[] s_UnrestrictedSpecialPermissionMap = {
-            new EnvironmentPermission(PermissionState.Unrestricted),
-            new FileDialogPermission(PermissionState.Unrestricted),
-            new FileIOPermission(PermissionState.Unrestricted),
-            new ReflectionPermission(PermissionState.Unrestricted),
-            new SecurityPermission(PermissionState.Unrestricted),
-            new UIPermission(PermissionState.Unrestricted)
-        };
-
-        internal static int GetSpecialFlags (PermissionSet grantSet, PermissionSet deniedSet) {
-            if ((grantSet != null && grantSet.IsUnrestricted()) && (deniedSet == null || deniedSet.IsEmpty())) {
-                return -1;
-            }
-            else {
-                SecurityPermission securityPermission = null;
-#pragma warning disable 618
-                SecurityPermissionFlag securityPermissionFlags = SecurityPermissionFlag.NoFlags;
-#pragma warning restore 618
-                ReflectionPermission reflectionPermission = null;
-                ReflectionPermissionFlag reflectionPermissionFlags = ReflectionPermissionFlag.NoFlags;
-
-                CodeAccessPermission[] specialPermissions = new CodeAccessPermission[6];
-                if (grantSet != null) {
-                    if (grantSet.IsUnrestricted()) {
-#pragma warning disable 618
-                        securityPermissionFlags = SecurityPermissionFlag.AllFlags;
-#pragma warning restore 618
-                        reflectionPermissionFlags = ReflectionPermission.AllFlagsAndMore;
-                        for (int i = 0; i < specialPermissions.Length; i++) {
-                            specialPermissions[i] = s_UnrestrictedSpecialPermissionMap[i];
-                        }
-                    }
-                    else {
-                        securityPermission = grantSet.GetPermission(BuiltInPermissionIndex.SecurityPermissionIndex) as SecurityPermission;
-                        if (securityPermission != null)
-                            securityPermissionFlags = securityPermission.Flags;
-                        reflectionPermission = grantSet.GetPermission(BuiltInPermissionIndex.ReflectionPermissionIndex) as ReflectionPermission;
-                        if (reflectionPermission != null)
-                            reflectionPermissionFlags = reflectionPermission.Flags;
-                        for (int i = 0; i < specialPermissions.Length; i++) {
-                            specialPermissions[i] = grantSet.GetPermission(s_BuiltInPermissionIndexMap[i][0]) as CodeAccessPermission;
-                        }
-                    }
-                }
-
-                if (deniedSet != null) {
-                    if (deniedSet.IsUnrestricted()) {
-#pragma warning disable 618
-                        securityPermissionFlags = SecurityPermissionFlag.NoFlags;
-#pragma warning restore 618
-                        reflectionPermissionFlags = ReflectionPermissionFlag.NoFlags;
-                        for (int i = 0; i < s_BuiltInPermissionIndexMap.Length; i++) {
-                            specialPermissions[i] = null;
-                        }
-                    }
-                    else {
-                        securityPermission = deniedSet.GetPermission(BuiltInPermissionIndex.SecurityPermissionIndex) as SecurityPermission;
-                        if (securityPermission != null)
-                            securityPermissionFlags &= ~securityPermission.Flags;
-                        reflectionPermission = deniedSet.GetPermission(BuiltInPermissionIndex.ReflectionPermissionIndex) as ReflectionPermission;
-                        if (reflectionPermission != null)
-                            reflectionPermissionFlags &= ~reflectionPermission.Flags;
-                        for (int i = 0; i < s_BuiltInPermissionIndexMap.Length; i++) {
-                            CodeAccessPermission deniedSpecialPermission = deniedSet.GetPermission(s_BuiltInPermissionIndexMap[i][0]) as CodeAccessPermission;
-                            if (deniedSpecialPermission != null && !deniedSpecialPermission.IsSubsetOf(null))
-                                specialPermissions[i] = null; // we don't care about the exact value here.
-                        }
-                    }
-                }
-                int flags = MapToSpecialFlags(securityPermissionFlags, reflectionPermissionFlags);
-                if (flags != -1) {
-                    for (int i = 0; i < specialPermissions.Length; i++) {
-                        if (specialPermissions[i] != null && ((IUnrestrictedPermission) specialPermissions[i]).IsUnrestricted())
-                            flags |= (1 << (int) s_BuiltInPermissionIndexMap[i][1]);
-                    }
-                }
-                return flags;
-            }
-        }
-
-#pragma warning disable 618
-        private static int MapToSpecialFlags (SecurityPermissionFlag securityPermissionFlags, ReflectionPermissionFlag reflectionPermissionFlags) {
-            int flags = 0;
-            if ((securityPermissionFlags & SecurityPermissionFlag.UnmanagedCode) == SecurityPermissionFlag.UnmanagedCode)
-                flags |= (1 << (int) PermissionType.SecurityUnmngdCodeAccess);
-            if ((securityPermissionFlags & SecurityPermissionFlag.SkipVerification) == SecurityPermissionFlag.SkipVerification)
-                flags |= (1 << (int) PermissionType.SecuritySkipVerification);
-            if ((securityPermissionFlags & SecurityPermissionFlag.Assertion) == SecurityPermissionFlag.Assertion)
-                flags |= (1 << (int) PermissionType.SecurityAssert);
-            if ((securityPermissionFlags & SecurityPermissionFlag.SerializationFormatter) == SecurityPermissionFlag.SerializationFormatter)
-                flags |= (1 << (int) PermissionType.SecuritySerialization);
-            if ((securityPermissionFlags & SecurityPermissionFlag.BindingRedirects) == SecurityPermissionFlag.BindingRedirects)
-                flags |= (1 << (int) PermissionType.SecurityBindingRedirects);
-            if ((securityPermissionFlags & SecurityPermissionFlag.ControlEvidence) == SecurityPermissionFlag.ControlEvidence)
-                flags |= (1 << (int) PermissionType.SecurityControlEvidence);
-            if ((securityPermissionFlags & SecurityPermissionFlag.ControlPrincipal) == SecurityPermissionFlag.ControlPrincipal)
-                flags |= (1 << (int) PermissionType.SecurityControlPrincipal);
-
-            if ((reflectionPermissionFlags & ReflectionPermissionFlag.RestrictedMemberAccess) == ReflectionPermissionFlag.RestrictedMemberAccess)
-                flags |= (1 << (int)PermissionType.ReflectionRestrictedMemberAccess);
-            if ((reflectionPermissionFlags & ReflectionPermissionFlag.MemberAccess) == ReflectionPermissionFlag.MemberAccess)
-                flags |= (1 << (int) PermissionType.ReflectionMemberAccess);
-
-            return flags;
-        }
-#pragma warning restore 618
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        internal static extern bool IsSameType(String strLeft, String strRight);
-
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        internal static extern bool _SetThreadSecurity(bool bThreadSecurity);
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        internal static extern void GetGrantedPermissions(ObjectHandleOnStack retGranted, ObjectHandleOnStack retDenied, StackCrawlMarkHandle stackMark);
-    }
-}
diff --git a/src/mscorlib/src/System/Security/SecurityRuntime.cs b/src/mscorlib/src/System/Security/SecurityRuntime.cs
deleted file mode 100644
index 76835ffb71..0000000000
--- a/src/mscorlib/src/System/Security/SecurityRuntime.cs
+++ /dev/null
@@ -1,121 +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.
-
-// 
-
-namespace System.Security
-{
-    using System;
-    using System.Globalization;
-    using System.Threading;
-    using System.Reflection;
-    using System.Collections;
-    using System.Runtime.CompilerServices;
-    using System.Security.Permissions;
-    using System.Runtime.Versioning;
-    using System.Diagnostics.Contracts;
-
-    internal class SecurityRuntime
-    {
-        private SecurityRuntime(){}
-
-        // Returns the security object for the caller of the method containing
-        // 'stackMark' on its frame.
-        //
-        // THE RETURNED OBJECT IS THE LIVE RUNTIME OBJECT. BE CAREFUL WITH IT!
-        //
-        // Internal only, do not doc.
-        // 
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        internal static extern 
-        FrameSecurityDescriptor GetSecurityObjectForFrame(ref StackCrawlMark stackMark,
-                                                          bool create);
-
-        // Constants used to return status to native
-        internal const bool StackContinue  = true;
-        internal const bool StackHalt      = false;
-
-        // this method is a big perf hit, so don't call unnecessarily
-        internal static MethodInfo GetMethodInfo(RuntimeMethodHandleInternal rmh)
-        {
-            if (rmh.IsNullHandle())
-                return null;
-
-#if _DEBUG
-            try
-            {
-#endif
-                // Assert here because reflection will check grants and if we fail the check,
-                // there will be an infinite recursion that overflows the stack.
-                PermissionSet.s_fullTrust.Assert();
-                return (System.RuntimeType.GetMethodBase(RuntimeMethodHandle.GetDeclaringType(rmh), rmh) as MethodInfo);
-#if _DEBUG
-            }
-            catch(Exception)
-            {
-                return null;
-            }
-#endif
-        }
-
-        private static bool FrameDescSetHelper(FrameSecurityDescriptor secDesc,
-                                               PermissionSet demandSet,
-                                               out PermissionSet alteredDemandSet,
-                                               RuntimeMethodHandleInternal rmh)
-        {
-            return secDesc.CheckSetDemand(demandSet, out alteredDemandSet, rmh);
-        }
-
-        private static bool FrameDescHelper(FrameSecurityDescriptor secDesc,
-                                               IPermission demandIn, 
-                                               PermissionToken permToken,
-                                               RuntimeMethodHandleInternal rmh)
-        {
-            return secDesc.CheckDemand((CodeAccessPermission) demandIn, permToken, rmh);
-        }
-
-
-        //
-        // API for PermissionSets
-        //
-
-        internal static void Assert(PermissionSet permSet, ref StackCrawlMark stackMark)
-        {
-        }
-
-        internal static void AssertAllPossible(ref StackCrawlMark stackMark)
-        {
-        }
-
-        internal static void Deny(PermissionSet permSet, ref StackCrawlMark stackMark)
-        {
-        }
-
-        internal static void PermitOnly(PermissionSet permSet, ref StackCrawlMark stackMark)
-        {
-        }
-
-        //
-        // Revert API
-        //
-
-        internal static void RevertAssert(ref StackCrawlMark stackMark)
-        {
-        }
-
-        internal static void RevertDeny(ref StackCrawlMark stackMark)
-        {
-        }
-        
-        internal static void RevertPermitOnly(ref StackCrawlMark stackMark)
-        {
-        }
-        
-        internal static void RevertAll(ref StackCrawlMark stackMark)
-        {
-        }
-    }
-}
-
-
diff --git a/src/mscorlib/src/System/Security/SecurityState.cs b/src/mscorlib/src/System/Security/SecurityState.cs
index 3c7f8bf49f..55dcce07c0 100644
--- a/src/mscorlib/src/System/Security/SecurityState.cs
+++ b/src/mscorlib/src/System/Security/SecurityState.cs
@@ -3,7 +3,6 @@
 // See the LICENSE file in the project root for more information.
 using System;
 using System.Security;
-using System.Security.Permissions;
 
 namespace System.Security
 {
diff --git a/src/mscorlib/src/System/Security/SecurityZone.cs b/src/mscorlib/src/System/Security/SecurityZone.cs
deleted file mode 100644
index a74b637846..0000000000
--- a/src/mscorlib/src/System/Security/SecurityZone.cs
+++ /dev/null
@@ -1,29 +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.
-
-// 
-//
-//  Enumeration of the zones code can come from
-//
-
-namespace System.Security
-{
-    using System;
-    using System.Runtime.InteropServices;
-
-    // The quick cache code depends on the values in this enumeration. Any change to this enumeration should
-    // be reflected in PolicyManager.GenerateQuickCache as well.
-    [ComVisible(true)]
-    [Serializable]
-    public enum SecurityZone
-    {
-        MyComputer   = 0,
-        Intranet     = 1,
-        Trusted      = 2,
-        Internet     = 3,
-        Untrusted    = 4,
-    
-        NoZone       = -1,  // No Zone Information
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Util/Config.cs b/src/mscorlib/src/System/Security/Util/Config.cs
deleted file mode 100644
index c2dbf6b8fe..0000000000
--- a/src/mscorlib/src/System/Security/Util/Config.cs
+++ /dev/null
@@ -1,80 +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.
-
-namespace System.Security.Util {
-    using System;
-    using System.Security.Util;
-    using System.Security.Policy;
-    using System.Security.Permissions;
-    using System.Collections;
-    using System.IO;
-    using System.Reflection;
-    using System.Globalization;
-    using System.Text;
-    using System.Threading;
-    using System.Runtime.CompilerServices;
-    using System.Runtime.InteropServices;
-    using System.Runtime.Versioning;
-
-    // Duplicated in vm\COMSecurityConfig.h
-[Serializable]
-[Flags]
-    internal enum QuickCacheEntryType
-    {
-        FullTrustZoneMyComputer = 0x1000000,
-        FullTrustZoneIntranet = 0x2000000,
-        FullTrustZoneInternet = 0x4000000,
-        FullTrustZoneTrusted = 0x8000000,
-        FullTrustZoneUntrusted = 0x10000000,
-        FullTrustAll = 0x20000000,
-    }
-
-    internal static class Config {
-        private static volatile string m_machineConfig;
-        private static volatile string m_userConfig;
-
-        private static void GetFileLocales()
-        {
-            if (m_machineConfig == null)
-            {
-                string machineConfig = null;
-                GetMachineDirectory(JitHelpers.GetStringHandleOnStack(ref machineConfig));
-                m_machineConfig = machineConfig;
-            }
-            if (m_userConfig == null)
-            {
-                string userConfig = null;
-                GetUserDirectory(JitHelpers.GetStringHandleOnStack(ref userConfig));
-                m_userConfig = userConfig;
-        }
-        }
-
-        internal static string MachineDirectory
-        {
-            get
-            {
-                GetFileLocales();
-                return m_machineConfig;
-            }
-        }
-
-        internal static string UserDirectory
-        {
-            get
-            {
-                GetFileLocales();
-                return m_userConfig;
-            }
-        }
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode), SuppressUnmanagedCodeSecurity]
-        private static extern void GetMachineDirectory(StringHandleOnStack retDirectory);
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode), SuppressUnmanagedCodeSecurity]
-        private static extern void GetUserDirectory(StringHandleOnStack retDirectory);
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode), SuppressUnmanagedCodeSecurity]
-        internal static extern bool WriteToEventLog(string message);
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Util/Hex.cs b/src/mscorlib/src/System/Security/Util/Hex.cs
deleted file mode 100644
index 4ca1cf678b..0000000000
--- a/src/mscorlib/src/System/Security/Util/Hex.cs
+++ /dev/null
@@ -1,126 +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.
-
-/*
- *
- * Operations to convert to and from Hex
- *
- */
-
-namespace System.Security.Util
-{
-    using System;
-    using System.Security;
-    using System.Diagnostics.Contracts;
-    internal static class Hex
-    {
-        // converts number to hex digit. Does not do any range checks.
-        static char HexDigit(int num) {
-            return (char)((num < 10) ? (num + '0') : (num + ('A' - 10)));
-        }
-        
-        public  static String EncodeHexString(byte[] sArray) 
-        {
-            String result = null;
-    
-            if(sArray != null) {
-                char[] hexOrder = new char[sArray.Length * 2];
-            
-                int digit;
-                for(int i = 0, j = 0; i < sArray.Length; i++) {
-                    digit = (int)((sArray[i] & 0xf0) >> 4);
-                    hexOrder[j++] = HexDigit(digit);
-                    digit = (int)(sArray[i] & 0x0f);
-                    hexOrder[j++] = HexDigit(digit);
-                }
-                result = new String(hexOrder);
-            }
-            return result;
-        }
-
-        internal static string EncodeHexStringFromInt(byte[] sArray) {
-            String result = null;
-            if(sArray != null) {
-                char[] hexOrder = new char[sArray.Length * 2];
-            
-                int i = sArray.Length;
-                int digit, j=0;
-                while (i-- > 0) {
-                    digit = (sArray[i] & 0xf0) >> 4;
-                    hexOrder[j++] = HexDigit(digit);
-                    digit = sArray[i] & 0x0f;
-                    hexOrder[j++] = HexDigit(digit);
-                }
-                result = new String(hexOrder);
-            }
-            return result;
-        }
-        
-        public static int ConvertHexDigit(Char val)
-        {
-            if (val <= '9' && val >= '0')
-                return (val - '0');
-            else if (val >= 'a' && val <= 'f')
-                return ((val - 'a') + 10);
-            else if (val >= 'A' && val <= 'F')
-                return ((val - 'A') + 10);
-            else
-                throw new ArgumentException( Environment.GetResourceString( "ArgumentOutOfRange_Index" ) );  
-        }
-
-        
-        public static byte[] DecodeHexString(String hexString)
-        {
-            if (hexString == null)
-                throw new ArgumentNullException( nameof(hexString) );
-            Contract.EndContractBlock();
-                    
-            bool spaceSkippingMode = false;    
-                    
-            int i = 0;
-            int length = hexString.Length;
-            
-            if ((length >= 2) &&
-                (hexString[0] == '0') &&
-                ( (hexString[1] == 'x') ||  (hexString[1] == 'X') ))
-            {
-                length = hexString.Length - 2;
-                i = 2;
-            }
-            
-            // Hex strings must always have 2N or (3N - 1) entries.
-            
-            if (length % 2 != 0 && length % 3 != 2)
-            {
-                throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidHexFormat" ) );
-            }                
-                
-            byte[] sArray;
-                
-            if (length >=3 && hexString[i + 2] == ' ')
-            {
-                spaceSkippingMode = true;
-                    
-                // Each hex digit will take three spaces, except the first (hence the plus 1).
-                sArray = new byte[length / 3 + 1];
-            }
-            else
-            {
-                // Each hex digit will take two spaces
-                sArray = new byte[length / 2];
-            }
-                
-            int digit;
-            int rawdigit;
-            for (int j = 0; i < hexString.Length; i += 2, j++) {
-                rawdigit = ConvertHexDigit(hexString[i]);
-                digit = ConvertHexDigit(hexString[i+1]);
-                sArray[j] = (byte) (digit | (rawdigit << 4));
-                if (spaceSkippingMode)
-                    i++;
-            }
-            return(sArray);    
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Util/StringExpressionSet.cs b/src/mscorlib/src/System/Security/Util/StringExpressionSet.cs
deleted file mode 100644
index cc7a15a761..0000000000
--- a/src/mscorlib/src/System/Security/Util/StringExpressionSet.cs
+++ /dev/null
@@ -1,751 +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.
-
-namespace System.Security.Util {    
-    using System.Text;
-    using System;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Runtime.CompilerServices;
-    using System.Runtime.InteropServices;
-    using System.Globalization;
-    using System.Runtime.Versioning;
-    using System.IO;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-
-    [Serializable]
-    internal class StringExpressionSet
-    {
-        // This field, as well as the expressions fields below are critical since they may contain
-        // canonicalized full path data potentially built out of relative data passed as input to the
-        // StringExpressionSet.  Full trust code using the string expression set needs to ensure that before
-        // exposing this data out to partial trust, they protect against this.  Possibilities include:
-        //
-        //  1. Using the throwOnRelative flag
-        //  2. Ensuring that the partial trust code has permission to see full path data
-        //  3. Not using this set for paths (eg EnvironmentStringExpressionSet)
-        //
-        protected ArrayList m_list;
-        protected bool m_ignoreCase;
-        protected String m_expressions;
-        protected String[] m_expressionsArray;
-
-        protected bool m_throwOnRelative;
-
-        private const char Separator = ';';
-#if !PLATFORM_UNIX
-        protected static readonly char m_directorySeparator = '\\';
-        protected static readonly char m_alternateDirectorySeparator = '/';
-#else
-        protected static readonly char m_directorySeparator = '/';
-        protected static readonly char m_alternateDirectorySeparator = '\\';
-#endif // !PLATFORM_UNIX
-        
-        public StringExpressionSet()
-            : this( true, null, false )
-        {
-        }
-        
-        public StringExpressionSet( String str )
-            : this( true, str, false )
-        {
-        }
-        
-        public StringExpressionSet( bool ignoreCase, bool throwOnRelative )
-            : this( ignoreCase, null, throwOnRelative )
-        {
-        }
-        
-        public StringExpressionSet( bool ignoreCase, String str, bool throwOnRelative )
-        {
-            m_list = null;
-            m_ignoreCase = ignoreCase;
-            m_throwOnRelative = throwOnRelative;
-            if (str == null)
-                m_expressions = null;
-            else
-            AddExpressions( str );
-        }
-
-        protected virtual StringExpressionSet CreateNewEmpty()
-        {
-            return new StringExpressionSet();
-        }
-        
-        public virtual StringExpressionSet Copy()
-        {
-            // SafeCritical: just copying this value around, not leaking it
-
-            StringExpressionSet copy = CreateNewEmpty();
-            if (this.m_list != null)
-                copy.m_list = new ArrayList(this.m_list);
-
-            copy.m_expressions = this.m_expressions;
-            copy.m_ignoreCase = this.m_ignoreCase;
-            copy.m_throwOnRelative = this.m_throwOnRelative;
-            return copy;
-        }
-        
-        public void SetThrowOnRelative( bool throwOnRelative )
-        {
-            this.m_throwOnRelative = throwOnRelative;
-        }
-
-        private static String StaticProcessWholeString( String str )
-        {
-            return str.Replace( m_alternateDirectorySeparator, m_directorySeparator );
-        }
-
-        private static String StaticProcessSingleString( String str )
-        {
-            return str.Trim(' ');
-        }
-
-        protected virtual String ProcessWholeString( String str )
-        {
-            return StaticProcessWholeString(str);
-        }
-
-        protected virtual String ProcessSingleString( String str )
-        {
-            return StaticProcessSingleString(str);
-        }
-        
-        public void AddExpressions( String str )
-        {
-            if (str == null)
-                throw new ArgumentNullException( nameof(str) );
-            Contract.EndContractBlock();
-            if (str.Length == 0)
-                return;
-
-            str = ProcessWholeString( str );
-
-            if (m_expressions == null)
-                m_expressions = str;
-            else
-                m_expressions = m_expressions + Separator + str;
-
-            m_expressionsArray = null;
-
-            // We have to parse the string and compute the list here.
-            // The logic in this class tries to delay this parsing but
-            // since operations like IsSubsetOf are called during 
-            // demand evaluation, it is not safe to delay this step
-            // as that would cause concurring threads to update the object
-            // at the same time. The CheckList operation should ideally be
-            // removed from this class, but for the sake of keeping the 
-            // changes to a minimum here, we simply make sure m_list 
-            // cannot be null by parsing m_expressions eagerly.
-
-            String[] arystr = Split( str );
-
-            if (m_list == null)
-                m_list = new ArrayList();
-
-            for (int index = 0; index < arystr.Length; ++index)
-            {
-                if (arystr[index] != null && !arystr[index].Equals( "" ))
-                {
-                    String temp = ProcessSingleString( arystr[index] );
-                    int indexOfNull = temp.IndexOf( '\0' );
-
-                    if (indexOfNull != -1)
-                        temp = temp.Substring( 0, indexOfNull );
-
-                    if (temp != null && !temp.Equals( "" ))
-                    {
-                        if (m_throwOnRelative)
-                        {
-                            if (PathInternal.IsPartiallyQualified(temp))
-                            {
-                                throw new ArgumentException( Environment.GetResourceString( "Argument_AbsolutePathRequired" ) );
-                            }
-
-                            temp = CanonicalizePath( temp );
-                        }
-
-                        m_list.Add( temp );
-                    }
-                }
-            }
-
-            Reduce();
-        }
-
-        public void AddExpressions( String[] str, bool checkForDuplicates, bool needFullPath )
-        {
-            AddExpressions(CreateListFromExpressions(str, needFullPath), checkForDuplicates);
-        }
-
-        public void AddExpressions( ArrayList exprArrayList, bool checkForDuplicates)
-        {
-            Debug.Assert( m_throwOnRelative, "This should only be called when throw on relative is set" );
-
-            m_expressionsArray = null;
-            m_expressions = null;
-
-            if (m_list != null)
-                m_list.AddRange(exprArrayList);
-            else
-                m_list = new ArrayList(exprArrayList);
-
-            if (checkForDuplicates)
-                Reduce();
-        }
-
-
-        internal static ArrayList CreateListFromExpressions(String[] str, bool needFullPath)
-        {
-            if (str == null)
-            {
-                throw new ArgumentNullException( nameof(str) );
-            }
-            Contract.EndContractBlock();
-            ArrayList retArrayList = new ArrayList();
-            for (int index = 0; index < str.Length; ++index)
-            {
-                if (str[index] == null)
-                    throw new ArgumentNullException( nameof(str) );
-
-                // Replace alternate directory separators
-                String oneString = StaticProcessWholeString( str[index] );
-
-                if (oneString != null && oneString.Length != 0)
-                {
-                    // Trim leading and trailing spaces
-                    String temp = StaticProcessSingleString( oneString);
-
-                    int indexOfNull = temp.IndexOf( '\0' );
-
-                    if (indexOfNull != -1)
-                        temp = temp.Substring( 0, indexOfNull );
-
-                    if (temp != null && temp.Length != 0)
-                    {
-                        if (PathInternal.IsPartiallyQualified(temp))
-                        {
-                            throw new ArgumentException(Environment.GetResourceString( "Argument_AbsolutePathRequired" ) );
-                        }
-
-                        temp = CanonicalizePath( temp, needFullPath );
-
-                        retArrayList.Add( temp );
-                    }
-                }
-            }
-
-            return retArrayList;
-        }
-        
-        protected void CheckList()
-        {
-            if (m_list == null && m_expressions != null)
-            {
-                CreateList();
-            }
-        }
-        
-        protected String[] Split( String expressions )
-        {
-            if (m_throwOnRelative)
-            {
-                List<String> tempList = new List<String>();
-
-                String[] quoteSplit = expressions.Split( '\"' );
-
-                for (int i = 0; i < quoteSplit.Length; ++i)
-                {
-                    if (i % 2 == 0)
-                    {
-                        String[] semiSplit = quoteSplit[i].Split( ';' );
-
-                        for (int j = 0; j < semiSplit.Length; ++j)
-                        {
-                            if (semiSplit[j] != null && !semiSplit[j].Equals( "" ))
-                                tempList.Add( semiSplit[j] );
-                        }
-                    }
-                    else
-                    {
-                        tempList.Add( quoteSplit[i] );
-                    }
-                }
-
-                String[] finalArray = new String[tempList.Count];
-
-                IEnumerator enumerator = tempList.GetEnumerator();
-
-                int index = 0;
-                while (enumerator.MoveNext())
-                {
-                    finalArray[index++] = (String)enumerator.Current;
-                }
-
-                return finalArray;
-            }
-            else
-            {
-                return expressions.Split(Separator);
-            }
-        }
-
-        
-        protected void CreateList()
-        {
-            String[] expressionsArray = Split( m_expressions );
-
-            m_list = new ArrayList();
-            
-            for (int index = 0; index < expressionsArray.Length; ++index)
-            {
-                if (expressionsArray[index] != null && !expressionsArray[index].Equals( "" ))
-                {
-                    String temp = ProcessSingleString( expressionsArray[index] );
-
-                    int indexOfNull = temp.IndexOf( '\0' );
-
-                    if (indexOfNull != -1)
-                        temp = temp.Substring( 0, indexOfNull );
-
-                    if (temp != null && !temp.Equals( "" ))
-                    {
-                        if (m_throwOnRelative)
-                        {
-                            if (PathInternal.IsPartiallyQualified(temp))
-                            {
-                                throw new ArgumentException( Environment.GetResourceString( "Argument_AbsolutePathRequired" ) );
-                            }
-
-                            temp = CanonicalizePath( temp );
-                        }
-                        
-                        m_list.Add( temp );
-                    }
-                }
-            }
-        }
-        
-        public bool IsEmpty()
-        {
-            // SafeCritical: we're just showing that the expressions are empty, the sensitive portion is their
-            // contents - not the existence of the contents
-            if (m_list == null)
-            {
-                return m_expressions == null;
-            }
-            else
-            {
-                return m_list.Count == 0;
-            }
-        }
-        
-        public bool IsSubsetOf( StringExpressionSet ses )
-        {
-            if (this.IsEmpty())
-                return true;
-            
-            if (ses == null || ses.IsEmpty())
-                return false;
-            
-            CheckList();
-            ses.CheckList();
-            
-            for (int index = 0; index < this.m_list.Count; ++index)
-            {
-                if (!StringSubsetStringExpression( (String)this.m_list[index], ses, m_ignoreCase ))
-                {
-                    return false;
-                }
-            }
-            return true;
-        }
-        
-        public bool IsSubsetOfPathDiscovery( StringExpressionSet ses )
-        {
-            if (this.IsEmpty())
-                return true;
-            
-            if (ses == null || ses.IsEmpty())
-                return false;
-            
-            CheckList();
-            ses.CheckList();
-            
-            for (int index = 0; index < this.m_list.Count; ++index)
-            {
-                if (!StringSubsetStringExpressionPathDiscovery( (String)this.m_list[index], ses, m_ignoreCase ))
-                {
-                    return false;
-                }
-            }
-            return true;
-        }
-
-        
-        public StringExpressionSet Union( StringExpressionSet ses )
-        {
-            // If either set is empty, the union represents a copy of the other.
-            
-            if (ses == null || ses.IsEmpty())
-                return this.Copy();
-    
-            if (this.IsEmpty())
-                return ses.Copy();
-            
-            CheckList();
-            ses.CheckList();
-            
-            // Perform the union
-            // note: insert smaller set into bigger set to reduce needed comparisons
-            
-            StringExpressionSet bigger = ses.m_list.Count > this.m_list.Count ? ses : this;
-            StringExpressionSet smaller = ses.m_list.Count <= this.m_list.Count ? ses : this;
-    
-            StringExpressionSet unionSet = bigger.Copy();
-            
-            unionSet.Reduce();
-            
-            for (int index = 0; index < smaller.m_list.Count; ++index)
-            {
-                unionSet.AddSingleExpressionNoDuplicates( (String)smaller.m_list[index] );
-            }
-            
-            unionSet.GenerateString();
-            
-            return unionSet;
-        }
-            
-        
-        public StringExpressionSet Intersect( StringExpressionSet ses )
-        {
-            // If either set is empty, the intersection is empty
-            
-            if (this.IsEmpty() || ses == null || ses.IsEmpty())
-                return CreateNewEmpty();
-            
-            CheckList();
-            ses.CheckList();
-            
-            // Do the intersection for real
-            
-            StringExpressionSet intersectSet = CreateNewEmpty();
-            
-            for (int this_index = 0; this_index < this.m_list.Count; ++this_index)
-            {
-                for (int ses_index = 0; ses_index < ses.m_list.Count; ++ses_index)
-                {
-                    if (StringSubsetString( (String)this.m_list[this_index], (String)ses.m_list[ses_index], m_ignoreCase ))
-                    {
-                        if (intersectSet.m_list == null)
-                        {
-                            intersectSet.m_list = new ArrayList();
-                        }
-                        intersectSet.AddSingleExpressionNoDuplicates( (String)this.m_list[this_index] );
-                    }
-                    else if (StringSubsetString( (String)ses.m_list[ses_index], (String)this.m_list[this_index], m_ignoreCase ))
-                    {
-                        if (intersectSet.m_list == null)
-                        {
-                            intersectSet.m_list = new ArrayList();
-                        }
-                        intersectSet.AddSingleExpressionNoDuplicates( (String)ses.m_list[ses_index] );
-                    }
-                }
-            }
-            
-            intersectSet.GenerateString();
-            
-            return intersectSet;
-        }
-        
-        protected void GenerateString()
-        {
-            // SafeCritical - moves critical data around, but doesn't expose it out
-            if (m_list != null)
-            {
-                StringBuilder sb = new StringBuilder();
-            
-                IEnumerator enumerator = this.m_list.GetEnumerator();
-                bool first = true;
-            
-                while (enumerator.MoveNext())
-                {
-                    if (!first)
-                        sb.Append(Separator);
-                    else
-                        first = false;
-                            
-                    String currentString = (String)enumerator.Current;
-                    if (currentString != null)
-                    {
-                        int indexOfSeparator = currentString.IndexOf(Separator);
-
-                        if (indexOfSeparator != -1)
-                            sb.Append( '\"' );
-
-                        sb.Append( currentString );
-
-                        if (indexOfSeparator != -1)
-                            sb.Append( '\"' );
-                    }
-                }
-            
-                m_expressions = sb.ToString();
-            }
-            else
-            {
-                m_expressions = null;
-            }
-        }            
-        
-        // We don't override ToString since that API must be either transparent or safe citical.  If the
-        // expressions contain paths that were canonicalized and expanded from the input that would cause
-        // information disclosure, so we instead only expose this out to trusted code that can ensure they
-        // either don't leak the information or required full path information.
-        public string UnsafeToString()
-        {
-            CheckList();
-        
-            Reduce();
-        
-            GenerateString();
-                            
-            return m_expressions;
-        }
-
-        public String[] UnsafeToStringArray()
-        {
-            if (m_expressionsArray == null && m_list != null)
-            {
-                m_expressionsArray = (String[])m_list.ToArray(typeof(String));
-            }
-
-            return m_expressionsArray;
-        }
-                
-        
-        //-------------------------------
-        // protected static helper functions
-        //-------------------------------
-        
-        private bool StringSubsetStringExpression( String left, StringExpressionSet right, bool ignoreCase )
-        {
-            for (int index = 0; index < right.m_list.Count; ++index)
-            {
-                if (StringSubsetString( left, (String)right.m_list[index], ignoreCase ))
-                {
-                    return true;
-                }
-            }
-            return false;
-        }
-        
-        private static bool StringSubsetStringExpressionPathDiscovery( String left, StringExpressionSet right, bool ignoreCase )
-        {
-            for (int index = 0; index < right.m_list.Count; ++index)
-            {
-                if (StringSubsetStringPathDiscovery( left, (String)right.m_list[index], ignoreCase ))
-                {
-                    return true;
-                }
-            }
-            return false;
-        }
-
-        
-        protected virtual bool StringSubsetString( String left, String right, bool ignoreCase )
-        {
-            StringComparison strComp = (ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
-            if (right == null || left == null || right.Length == 0 || left.Length == 0 ||
-                right.Length > left.Length)
-            {
-                return false;
-            }
-            else if (right.Length == left.Length)
-            {
-                // if they are equal in length, just do a normal compare
-                return String.Compare( right, left, strComp) == 0;
-            }
-            else if (left.Length - right.Length == 1 && left[left.Length-1] == m_directorySeparator)
-            {
-                return String.Compare( left, 0, right, 0, right.Length, strComp) == 0;
-            }
-            else if (right[right.Length-1] == m_directorySeparator)
-            {
-                // right is definitely a directory, just do a substring compare
-                return String.Compare( right, 0, left, 0, right.Length, strComp) == 0;
-            }
-            else if (left[right.Length] == m_directorySeparator)
-            {
-                // left is hinting at being a subdirectory on right, do substring compare to make find out
-                return String.Compare( right, 0, left, 0, right.Length, strComp) == 0;
-            }
-            else
-            {
-                return false;
-            }
-        }
-
-        protected static bool StringSubsetStringPathDiscovery( String left, String right, bool ignoreCase )
-        {
-            StringComparison strComp = (ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
-            if (right == null || left == null || right.Length == 0 || left.Length == 0)
-            {
-                return false;
-            }
-            else if (right.Length == left.Length)
-            {
-                // if they are equal in length, just do a normal compare
-                return String.Compare( right, left, strComp) == 0;
-            }
-            else
-            {
-                String shortString, longString;
-
-                if (right.Length < left.Length)
-                {
-                    shortString = right;
-                    longString = left;
-                }
-                else
-                {
-                    shortString = left;
-                    longString = right;
-                }
-
-                if (String.Compare( shortString, 0, longString, 0, shortString.Length, strComp) != 0)
-                {
-                    return false;
-                }
-
-#if !PLATFORM_UNIX
-                if (shortString.Length == 3 &&
-                    shortString.EndsWith( ":\\", StringComparison.Ordinal ) &&
-                    ((shortString[0] >= 'A' && shortString[0] <= 'Z') ||
-                    (shortString[0] >= 'a' && shortString[0] <= 'z')))
-#else
-                if (shortString.Length == 1 && shortString[0]== m_directorySeparator)
-#endif // !PLATFORM_UNIX
-                     return true;
-
-                return longString[shortString.Length] == m_directorySeparator;
-            }
-        }
-
-        
-        //-------------------------------
-        // protected helper functions
-        //-------------------------------
-        
-        protected void AddSingleExpressionNoDuplicates( String expression )
-        {
-            // SafeCritical: We're not exposing out the string sets, just allowing modification of them
-            int index = 0;
-            
-            m_expressionsArray = null;
-            m_expressions = null;
-
-            if (this.m_list == null)
-                this.m_list = new ArrayList();
-
-            while (index < this.m_list.Count)
-            {
-                if (StringSubsetString( (String)this.m_list[index], expression, m_ignoreCase ))
-                {
-                    this.m_list.RemoveAt( index );
-                }
-                else if (StringSubsetString( expression, (String)this.m_list[index], m_ignoreCase ))
-                {
-                    return;
-                }
-                else
-                {
-                    index++;
-                }
-            }
-            this.m_list.Add( expression );
-        }
-    
-        protected void Reduce()
-        {
-            CheckList();
-            
-            if (this.m_list == null)
-                return;
-            
-            int j;
-
-            for (int i = 0; i < this.m_list.Count - 1; i++)
-            {
-                j = i + 1;
-                
-                while (j < this.m_list.Count)
-                {
-                    if (StringSubsetString( (String)this.m_list[j], (String)this.m_list[i], m_ignoreCase ))
-                    {
-                        this.m_list.RemoveAt( j );
-                    }
-                    else if (StringSubsetString( (String)this.m_list[i], (String)this.m_list[j], m_ignoreCase ))
-                    {
-                        // write the value at j into position i, delete the value at position j and keep going.
-                        this.m_list[i] = this.m_list[j];
-                        this.m_list.RemoveAt( j );
-                        j = i + 1;
-                    }
-                    else
-                    {
-                        j++;
-                    }
-                }
-            }
-        }
-
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        internal static extern void GetLongPathName( String path, StringHandleOnStack retLongPath );
-
-        internal static String CanonicalizePath( String path )
-        {
-            return CanonicalizePath( path, true );
-        }
-
-        internal static string CanonicalizePath(string path, bool needFullPath)
-        {
-            if (needFullPath)
-            {
-                string newPath = Path.GetFullPath(path);
-                if (path.EndsWith(m_directorySeparator + ".", StringComparison.Ordinal))
-                {
-                    if (newPath.EndsWith(m_directorySeparator))
-                    {
-                        newPath += ".";
-                    }
-                    else
-                    {
-                        newPath += m_directorySeparator + ".";
-                    }
-                }
-                path = newPath;
-            }
-#if !PLATFORM_UNIX
-            else if (path.IndexOf('~') != -1)
-            {
-                // GetFullPathInternal() will expand 8.3 file names
-                string longPath = null;
-                GetLongPathName(path, JitHelpers.GetStringHandleOnStack(ref longPath));
-                path = (longPath != null) ? longPath : path;
-            }
-
-            // This blocks usage of alternate data streams and some extended syntax paths (\\?\C:\). Checking after
-            // normalization allows valid paths such as " C:\" to be considered ok (as it will become "C:\").
-            if (path.IndexOf(':', 2) != -1)
-                throw new NotSupportedException(Environment.GetResourceString("Argument_PathFormatNotSupported"));
-#endif // !PLATFORM_UNIX
-
-            return path;
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Util/TokenBasedSet.cs b/src/mscorlib/src/System/Security/Util/TokenBasedSet.cs
deleted file mode 100644
index 66bc5d65cc..0000000000
--- a/src/mscorlib/src/System/Security/Util/TokenBasedSet.cs
+++ /dev/null
@@ -1,440 +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.
-
-namespace System.Security.Util
-{
-    using System;
-    using System.Collections;
-    using System.Security.Permissions;
-    using System.Runtime.Serialization;
-    using System.Threading;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-    using System.Diagnostics.CodeAnalysis;
-
-    internal class TokenBasedSet
-    {
-
-
-        // Following 3 fields are used only for serialization compat purposes: DO NOT USE THESE EVER!
-#pragma warning disable 414        
-        private int      m_initSize = 24;
-        private int      m_increment = 8;
-#pragma warning restore 414        
-        private Object[] m_objSet;
-        //  END -> Serialization only fields
-
-        [OptionalField(VersionAdded = 2)]        
-        private volatile Object m_Obj;
-        [OptionalField(VersionAdded = 2)]        
-        private volatile Object[] m_Set;
-        
-        private int m_cElt;
-        private volatile int m_maxIndex;
-
-
-        [OnDeserialized]
-        private void OnDeserialized(StreamingContext ctx)
-        {
-            OnDeserializedInternal();
-        }
-        private void OnDeserializedInternal()
-        {
-            if (m_objSet != null) //v1.x case 
-            {
-                if (m_cElt == 1)
-                    m_Obj = m_objSet[m_maxIndex];
-                else
-                    m_Set = m_objSet;
-                m_objSet = null;
-            }
-            // Nothing to do for the v2.0 and beyond case
-        }
-
-        [OnSerializing]
-        private void OnSerializing(StreamingContext ctx)
-        {
-
-            if ((ctx.State & ~(StreamingContextStates.Clone|StreamingContextStates.CrossAppDomain)) != 0)
-            {
-                //Nothing special for the v2 and beyond case
-                
-                // for the v1.x case, we need to create m_objSet if necessary
-                if (m_cElt == 1)
-                {
-                    m_objSet = new Object[m_maxIndex+1];
-                    m_objSet[m_maxIndex] = m_Obj;
-                }
-                else if (m_cElt > 0)
-                {
-                    // Array case:
-                    m_objSet = m_Set;
-                }
-                
-            }
-        }   
-        [OnSerialized]
-        private void OnSerialized(StreamingContext ctx)
-        {
-            if ((ctx.State & ~(StreamingContextStates.Clone|StreamingContextStates.CrossAppDomain)) != 0)
-            {
-                m_objSet = null;
-                
-            }
-        }
-
-
-        internal bool MoveNext(ref TokenBasedSetEnumerator e)
-        {
-            switch (m_cElt)
-            {
-            case 0:
-                return false;
-
-            case 1:
-                if (e.Index == -1)
-                {
-                    e.Index = m_maxIndex;
-                    e.Current = m_Obj;
-                    return true;
-                }
-                else
-                {
-                    e.Index = (short)(m_maxIndex+1);
-                    e.Current = null;
-                    return false;
-                }
-
-            default:
-                while (++e.Index <= m_maxIndex)
-                {
-                    e.Current = Volatile.Read(ref m_Set[e.Index]);
-                    
-                    if (e.Current != null)
-                        return true;
-                }
-
-                e.Current = null;
-                return false;
-            }
-        }
-
-        internal TokenBasedSet()
-        {
-            Reset();
-        }
-
-        [SuppressMessage("Microsoft.Concurrency", "CA8001", Justification = "Reviewed for thread safety")]
-        internal TokenBasedSet(TokenBasedSet tbSet)
-        {
-            if (tbSet == null)
-            {
-                Reset();
-                return;
-            }
-
-            if (tbSet.m_cElt > 1)
-            {
-                Object[] aObj = tbSet.m_Set;
-                int aLen = aObj.Length;
-                
-                Object[] aNew = new Object[aLen];
-                System.Array.Copy(aObj, 0, aNew, 0, aLen);
-                
-                m_Set = aNew;
-            }
-            else
-            {
-                m_Obj = tbSet.m_Obj;
-            }
-
-            m_cElt      = tbSet.m_cElt;
-            m_maxIndex  = tbSet.m_maxIndex;
-        }
-
-        internal void Reset()
-        {
-            m_Obj = null;
-            m_Set = null;
-            m_cElt = 0;
-            m_maxIndex = -1;
-        }
-
-        internal void SetItem(int index, Object item)
-        {
-            Object[] aObj = null;
-
-            if (item == null)
-            {
-                RemoveItem(index);
-                return;
-            }
-
-            switch (m_cElt)
-            {
-            case 0:
-                // on the first item, we don't create an array, we merely remember it's index and value
-                // this this the 99% case
-                m_cElt = 1;
-                m_maxIndex = (short)index;
-                m_Obj = item;
-                break;
-
-            case 1:
-                // we have to decide if a 2nd item has indeed been added and create the array
-                // if it has
-                if (index == m_maxIndex)
-                {
-                    // replacing the one existing item
-                    m_Obj = item;
-                 }
-                else
-                {
-                    // adding a second distinct permission
-                    Object objSaved = m_Obj;
-                    int iMax = Math.Max(m_maxIndex, index);
-                    
-                    aObj = new Object[iMax+1];
-                    aObj[m_maxIndex] = objSaved;
-                    aObj[index] = item;
-                    m_maxIndex = (short)iMax;
-                    m_cElt = 2;
-                    m_Set = aObj;
-                    m_Obj = null;
-                }
-                break;
-
-            default:
-                // this is the general case code for when there is really an array
-
-                aObj = m_Set;
-
-                // we are now adding an item, check if we need to grow
-
-                if (index >= aObj.Length)
-                {
-                    Object[] newset = new Object[index+1];
-                    System.Array.Copy(aObj, 0, newset, 0, m_maxIndex+1);
-                    m_maxIndex = (short)index;
-                    newset[index] = item;
-                    m_Set = newset;
-                    m_cElt++;
-                }
-                else
-                {
-                    if (aObj[index] == null)
-                        m_cElt++;
-
-                    aObj[index] = item;
-
-                    if (index > m_maxIndex)
-                        m_maxIndex = (short)index;
-                }
-                break;
-            }
-        }
-
-        [SuppressMessage("Microsoft.Concurrency", "CA8001", Justification = "Reviewed for thread-safety")]
-        internal Object GetItem(int index)
-        {
-            switch (m_cElt)
-            {
-            case 0:
-                return null;
-
-            case 1:
-                if (index == m_maxIndex)
-                    return m_Obj;
-                else
-                    return null;
-            default:
-                if (index < m_Set.Length)
-                    return Volatile.Read(ref m_Set[index]);
-                else
-                    return null;
-            }
-        }
-
-        internal Object RemoveItem(int index)
-        {
-            Object ret = null;
-
-            switch (m_cElt)
-            {
-            case 0:
-                ret = null;
-                break;
-
-            case 1:
-                if (index != m_maxIndex)
-                {
-                    // removing a permission we don't have ignore it
-                    ret = null;
-                }
-                else 
-                {
-                    // removing the permission we have at the moment
-                    ret = m_Obj;
-                    Reset();
-                }
-                break;
-
-            default:
-                // this is the general case code for when there is really an array
-
-                // we are removing an item                
-                if (index < m_Set.Length && (ret = Volatile.Read(ref m_Set[index])) != null)
-                {
-                    // ok we really deleted something at this point
-
-                    Volatile.Write(ref m_Set[index], null);
-                    m_cElt--;
-
-                    if (index == m_maxIndex)
-                        ResetMaxIndex(m_Set);
-
-                    // collapse the array
-                    if (m_cElt == 1)
-                    {
-                        m_Obj = Volatile.Read(ref m_Set[m_maxIndex]);
-                        m_Set = null;
-                    }
-                }
-                break;
-            }
-
-            return ret;
-        }
-
-        private void ResetMaxIndex(Object[] aObj)
-        {
-            int i;
-
-            // Start at the end of the array, and
-            // scan backwards for the first non-null
-            // slot. That is the new maxIndex.
-            for (i = aObj.Length - 1; i >= 0; i--)
-            {
-                if (aObj[i] != null)
-                {
-                    m_maxIndex = (short)i;
-                    return;
-                }
-            }
-
-            m_maxIndex = -1;
-        }
-        internal int GetStartingIndex()
-        {
-            if (m_cElt <= 1)
-                return m_maxIndex;
-            return 0;
-        }
-        internal int GetCount()
-        {
-            return m_cElt;
-        }
-
-        internal int GetMaxUsedIndex()
-        {
-            return m_maxIndex;
-        }
-
-        internal bool FastIsEmpty()
-        {
-            return m_cElt == 0;
-        }
-
-        // Used to merge two distinct TokenBasedSets (used currently only in PermissionSet Deserialization)
-        internal TokenBasedSet SpecialUnion(TokenBasedSet other)
-        {
-            // This gets called from PermissionSet.OnDeserialized and it's possible that the TokenBasedSets have 
-            // not been subjected to VTS callbacks yet
-            OnDeserializedInternal();
-            TokenBasedSet unionSet = new TokenBasedSet();
-            int maxMax;
-            if (other != null)
-            {
-                other.OnDeserializedInternal();
-                maxMax = this.GetMaxUsedIndex() > other.GetMaxUsedIndex() ? this.GetMaxUsedIndex() : other.GetMaxUsedIndex();
-            }
-            else
-                maxMax = this.GetMaxUsedIndex();
-        
-            for (int i = 0; i <= maxMax; ++i)
-            {
-                Object thisObj = this.GetItem( i );
-                IPermission thisPerm = thisObj as IPermission;
-
-                Object otherObj = (other != null)?other.GetItem( i ):null;
-                IPermission otherPerm = otherObj as IPermission;
-
-                if (thisObj == null && otherObj == null)
-                    continue;
-
-                if (thisObj == null)
-                {
-                    PermissionToken token = PermissionToken.GetToken(otherPerm);
-
-                    if (token == null)
-                    {
-                        throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientState"));
-                    }
-                    
-                    unionSet.SetItem(token.m_index, otherPerm);
-                }
-                else if (otherObj == null)
-                {
-                    PermissionToken token = PermissionToken.GetToken(thisPerm);
-                    if (token == null)
-                    {
-                        throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientState"));
-                    }
-                    unionSet.SetItem( token.m_index, thisPerm);
-                }
-                else
-                {
-                    Debug.Assert( (thisObj == null || otherObj == null), "Permission cannot be in both TokenBasedSets" );
-                }
-            }
-            return unionSet;
-        }
-
-        internal void SpecialSplit(ref TokenBasedSet unrestrictedPermSet, ref TokenBasedSet normalPermSet, bool ignoreTypeLoadFailures)
-        {
-           int maxIndex = GetMaxUsedIndex();
-
-            for (int i = GetStartingIndex(); i <= maxIndex; ++i)
-            {
-                Object obj = GetItem( i );
-                if (obj != null)
-                {
-                    IPermission perm = obj as IPermission;
-                    PermissionToken token = PermissionToken.GetToken(perm);
-
-                    if (perm == null || token == null)
-                        continue;
-
-                    if (perm is IUnrestrictedPermission)
-                    {
-                        // Add to unrestrictedPermSet
-                        if (unrestrictedPermSet == null)
-                            unrestrictedPermSet = new TokenBasedSet();
-                        unrestrictedPermSet.SetItem(token.m_index, perm);
-                    }
-                    else
-                    {
-                        // Add to normalPermSet
-                        if (normalPermSet == null)
-                            normalPermSet = new TokenBasedSet();
-                        normalPermSet.SetItem(token.m_index, perm);
-                    }
-
-                }
-
-            }
-            
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Util/TokenBasedSetEnumerator.cs b/src/mscorlib/src/System/Security/Util/TokenBasedSetEnumerator.cs
deleted file mode 100644
index 9c868d3c53..0000000000
--- a/src/mscorlib/src/System/Security/Util/TokenBasedSetEnumerator.cs
+++ /dev/null
@@ -1,36 +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.
-
-namespace System.Security.Util 
-{
-    using System;
-    using System.Collections;
-
-    internal struct TokenBasedSetEnumerator
-    {
-        public Object Current;
-        public int Index;
-                
-        private TokenBasedSet _tb;
-                            
-        public bool MoveNext()
-        {
-            return _tb != null ? _tb.MoveNext(ref this) : false;
-        }
-                
-        public void Reset()
-        {
-            Index = -1;
-            Current = null;
-        }
-                            
-        public TokenBasedSetEnumerator(TokenBasedSet tb)
-        {
-            Index = -1;
-            Current = null;
-            _tb = tb;
-        }
-    }
-}
-
diff --git a/src/mscorlib/src/System/Security/Util/URLString.cs b/src/mscorlib/src/System/Security/Util/URLString.cs
index 5f53cbdfe3..4ec353876a 100644
--- a/src/mscorlib/src/System/Security/Util/URLString.cs
+++ b/src/mscorlib/src/System/Security/Util/URLString.cs
@@ -22,365 +22,8 @@ namespace System.Security.Util {
     using System.IO;
     using System.Diagnostics.Contracts;
 
-    internal sealed class URLString : SiteString
+    internal static class URLString
     {
-        private String m_protocol;
-        [OptionalField(VersionAdded = 2)]
-        private String m_userpass;
-        private SiteString m_siteString;
-        private int m_port;
-#if !PLATFORM_UNIX
-        private LocalSiteString m_localSite;
-#endif // !PLATFORM_UNIX
-        private DirectoryString m_directory;
-        
-        private const String m_defaultProtocol = "file";
-
-        [OptionalField(VersionAdded = 2)]
-        private bool m_parseDeferred;
-        [OptionalField(VersionAdded = 2)]
-        private String m_urlOriginal;
-        [OptionalField(VersionAdded = 2)]
-        private bool m_parsedOriginal;
-
-        [OptionalField(VersionAdded = 3)]
-        private bool m_isUncShare;
-
-        // legacy field from v1.x, not used in v2 and beyond. Retained purely for serialization compatibility.
-        private String m_fullurl;
-
-
-        [OnDeserialized]
-        public void OnDeserialized(StreamingContext ctx)
-        {
-
-            if (m_urlOriginal == null)
-            {
-                // pre-v2 deserialization. Need to fix-up fields here
-                m_parseDeferred = false;
-                m_parsedOriginal = false; // Dont care what this value is - never used
-                m_userpass = "";
-                m_urlOriginal = m_fullurl;
-                m_fullurl = null;
-            }
-        }
-        [OnSerializing]
-        private void OnSerializing(StreamingContext ctx)
-        {
-
-            if ((ctx.State & ~(StreamingContextStates.Clone|StreamingContextStates.CrossAppDomain)) != 0)
-            {
-                DoDeferredParse();
-                m_fullurl = m_urlOriginal;
-            }
-        }   
-        [OnSerialized]
-        private void OnSerialized(StreamingContext ctx)
-        {
-            if ((ctx.State & ~(StreamingContextStates.Clone|StreamingContextStates.CrossAppDomain)) != 0)
-            {
-                m_fullurl = null;
-            }
-        }
-        
-        public URLString()
-        {
-            m_protocol = "";
-            m_userpass = "";
-            m_siteString = new SiteString();
-            m_port = -1;
-#if !PLATFORM_UNIX
-            m_localSite = null;
-#endif // !PLATFORM_UNIX
-            m_directory = new DirectoryString();
-            m_parseDeferred = false;
-        }
-
-        private void DoDeferredParse()
-        {
-            if (m_parseDeferred)
-            {
-                ParseString(m_urlOriginal, m_parsedOriginal);
-                m_parseDeferred = false;
-            }
-        }
-
-        public URLString(string url) : this(url, false, false) {}
-        public URLString(string url, bool parsed) : this(url, parsed, false) {}
-
-        internal URLString(string url, bool parsed, bool doDeferredParsing)
-        {
-            m_port = -1;
-            m_userpass = "";
-            DoFastChecks(url);
-            m_urlOriginal = url;
-            m_parsedOriginal = parsed;
-            m_parseDeferred = true;
-            if (doDeferredParsing)
-                DoDeferredParse();
-        }
-
-        // Converts %XX and %uYYYY to the actual characters (I.e. Unesacpes any escape characters present in the URL)
-        private String UnescapeURL(String url)
-        {
-            StringBuilder intermediate = StringBuilderCache.Acquire(url.Length);
-            int Rindex = 0; // index into temp that gives the rest of the string to be processed
-            int index;
-            int braIndex = -1;
-            int ketIndex = -1;
-            braIndex = url.IndexOf('[',Rindex);
-            if (braIndex != -1)
-                ketIndex = url.IndexOf(']', braIndex);
-            
-            do
-                {
-                    index = url.IndexOf( '%', Rindex);
-
-                    if (index == -1)
-                    {
-                        intermediate = intermediate.Append(url, Rindex, (url.Length - Rindex));
-                        break;
-                    }
-                    // if we hit a '%' in the middle of an IPv6 address, dont process that
-                    if (index > braIndex && index < ketIndex)
-                    {
-                        intermediate = intermediate.Append(url, Rindex, (ketIndex - Rindex+1));
-                        Rindex = ketIndex+1;
-                        continue;
-                    }
-
-                    if (url.Length - index < 2) // Check that there is at least 1 char after the '%'
-                        throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
-
-                    if (url[index+1] == 'u' || url[index+1] == 'U')
-                    {
-                        if (url.Length - index < 6) // example: "%u004d" is 6 chars long
-                            throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
-
-                        // We have a unicode character specified in hex
-
-                        try
-                        {
-                            char c = (char)(Hex.ConvertHexDigit( url[index+2] ) << 12 |
-                                            Hex.ConvertHexDigit( url[index+3] ) << 8  |
-                                            Hex.ConvertHexDigit( url[index+4] ) << 4  |
-                                            Hex.ConvertHexDigit( url[index+5] ));
-                            intermediate = intermediate.Append(url, Rindex, index - Rindex);
-                            intermediate = intermediate.Append(c);
-                        }
-                        catch(ArgumentException) // Hex.ConvertHexDigit can throw an "out of range" ArgumentException
-                        {
-                            throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
-                        }
-                                        
-                        Rindex = index + 6 ; //update the 'seen' length
-                    }
-                    else
-                    {
-                        // we have a hex character.
-                                         
-                        if (url.Length - index < 3) // example: "%4d" is 3 chars long
-                             throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
-
-                        try 
-                        {
-                            char c = (char)(Hex.ConvertHexDigit( url[index+1] ) << 4 | Hex.ConvertHexDigit( url[index+2] ));
-
-                            intermediate = intermediate.Append(url, Rindex, index - Rindex);
-                            intermediate = intermediate.Append(c);
-                        }
-                        catch(ArgumentException) // Hex.ConvertHexDigit can throw an "out of range" ArgumentException
-                        {
-                            throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
-                        }
-                        
-                        Rindex = index + 3; // update the 'seen' length
-                    }  
-
-                } 
-            while (true);
-            return StringBuilderCache.GetStringAndRelease(intermediate);
-        }
-
-        // Helper Function for ParseString: 
-        // Search for the end of the protocol info and grab the actual protocol string
-        // ex. http://www.microsoft.com/complus would have a protocol string of http
-        private String ParseProtocol(String url)
-        {
-            String temp;
-            int index = url.IndexOf( ':' );
-                
-            if (index == 0)
-            {
-                throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
-            }
-            else if (index == -1)
-            {
-                m_protocol = m_defaultProtocol;
-                temp = url;
-            }
-            else if (url.Length > index + 1)
-            {
-                if (index == m_defaultProtocol.Length && 
-                    String.Compare(url, 0, m_defaultProtocol, 0, index, StringComparison.OrdinalIgnoreCase) == 0)
-                {
-                    m_protocol = m_defaultProtocol;
-                    temp = url.Substring( index + 1 );
-
-                    // Since an explicit file:// URL could be immediately followed by a host name, we will be
-                    // conservative and assume that it is on a share rather than a potentally relative local
-                    // URL.
-                    m_isUncShare = true;
-                }
-                else if (url[index+1] != '\\')
-                {
-#if !PLATFORM_UNIX
-                    if (url.Length > index + 2 &&
-                        url[index+1] == '/' &&
-                        url[index+2] == '/')
-#else
-                    if (url.Length > index + 1 &&
-                        url[index+1] == '/' ) // UNIX style "file:/home/me" is allowed, so account for that
-#endif  // !PLATFORM_UNIX
-                    {
-                        m_protocol = url.Substring( 0, index );
-
-                        for (int i = 0; i < m_protocol.Length; ++i)
-                        {
-                            char c = m_protocol[i];
-
-                            if ((c >= 'a' && c <= 'z') ||
-                                (c >= 'A' && c <= 'Z') ||
-                                (c >= '0' && c <= '9') ||
-                                (c == '+') ||
-                                (c == '.') ||
-                                (c == '-'))
-                            {
-                                continue;
-                            }
-                            else
-                            {
-                                throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
-                            }
-                        }
-#if !PLATFORM_UNIX
-                        temp = url.Substring( index + 3 );
-#else
-                        // In UNIX, we don't know how many characters we'll have to skip past.
-                        // Skip past \, /, and :
-                        //
-                        for ( int j=index ; j<url.Length ; j++ )
-                        {
-                            if ( url[j] != '\\' && url[j] != '/' && url[j] != ':' )
-                            {
-                                index = j;
-                                break;
-                            }
-                        }
-
-                        temp = url.Substring( index );
-#endif  // !PLATFORM_UNIX
-                     }
-                    else
-                    {
-                        throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
-                    }
-                }
-                else
-                {
-                    m_protocol = m_defaultProtocol;
-                    temp = url;
-                }
-            }
-            else
-            {
-                throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
-            }
-
-            return temp;
-        }
-
-        private String ParsePort(String url)
-        {
-            String temp = url;
-            char[] separators = new char[] { ':', '/' };
-            int Rindex = 0;
-            int userpassIndex = temp.IndexOf('@');
-            if (userpassIndex != -1) {
-                if (temp.IndexOf('/',0,userpassIndex) == -1) {
-                    // this is a user:pass type of string 
-                    m_userpass = temp.Substring(0,userpassIndex);
-                    Rindex = userpassIndex + 1;
-                }
-            }
-
-            int braIndex = -1;
-            int ketIndex = -1;
-            int portIndex = -1;
-            braIndex = url.IndexOf('[',Rindex);
-            if (braIndex != -1)
-                ketIndex = url.IndexOf(']', braIndex);
-            if (ketIndex != -1)
-            {
-                // IPv6 address...ignore the IPv6 block when searching for the port
-                portIndex = temp.IndexOfAny(separators,ketIndex);
-            }
-            else
-            {
-                portIndex = temp.IndexOfAny(separators,Rindex);
-            }
-
-            
-
-            if (portIndex != -1 && temp[portIndex] == ':')
-            {
-                // make sure it really is a port, and has a number after the :
-                if ( temp[portIndex+1] >= '0' && temp[portIndex+1] <= '9' )
-                {
-                    int tempIndex = temp.IndexOf( '/', Rindex);
-
-                    if (tempIndex == -1)
-                    {
-                        m_port = Int32.Parse( temp.Substring(portIndex + 1), CultureInfo.InvariantCulture );
-
-                        if (m_port < 0)
-                            throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
-
-                        temp = temp.Substring( Rindex, portIndex - Rindex );
-                    }
-                    else if (tempIndex > portIndex)
-                    {
-                        m_port = Int32.Parse( temp.Substring(portIndex + 1, tempIndex - portIndex - 1), CultureInfo.InvariantCulture );
-                        temp = temp.Substring( Rindex, portIndex - Rindex ) + temp.Substring( tempIndex );
-                    }
-                    else 
-                        throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
-                }
-                else
-                    throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
-            }
-            else {
-                // Chop of the user/pass portion if any
-                temp = temp.Substring(Rindex);
-            }
-                
-            return temp;
-        }
-
-        // This does three things:
-        // 1. It makes the following modifications to the start of the string:
-        //      a. \\?\ and \\?/ => <empty>
-        //      b. \\.\ and \\./ => <empty>
-        // 2. If isFileUrl is true, converts all slashes to front slashes and strips leading
-        //    front slashes. See comment by code.
-        // 3. Throws a PathTooLongException if the length of the resulting URL is >= MAX_PATH.
-        //    This is done to prevent security issues due to canonicalization truncations.
-        // Remove this method when the Path class supports "\\?\"
-        internal static string PreProcessForExtendedPathRemoval(string url, bool isFileUrl)
-        {
-            return PreProcessForExtendedPathRemoval(checkPathLength: true, url: url, isFileUrl: isFileUrl);
-        }
-
         internal static string PreProcessForExtendedPathRemoval(bool checkPathLength, string url, bool isFileUrl)
         {
             bool isUncShare = false;
@@ -414,7 +57,8 @@ namespace System.Security.Util {
                 }
                 else
                 {
-                    if (isFileUrl) {
+                    if (isFileUrl)
+                    {
                         // We need to handle an indefinite number of leading front slashes for file URLs since we could
                         // get something like:
                         //      file://\\?\
@@ -446,14 +90,14 @@ namespace System.Security.Util {
             {
                 int slashCount = 0;
                 bool seenFirstBackslash = false;
-                
+
                 while (slashCount < modifiedUrl.Length && (modifiedUrl[slashCount] == '/' || modifiedUrl[slashCount] == '\\'))
                 {
                     // Look for sets of consecutive backslashes. We can't just look for these at the start
                     // of the string, since file:// might come first.  Instead, once we see the first \, look
                     // for a second one following it.
                     if (!seenFirstBackslash && modifiedUrl[slashCount] == '\\')
-                {
+                    {
                         seenFirstBackslash = true;
                         if (slashCount + 1 < modifiedUrl.Length && modifiedUrl[slashCount + 1] == '\\')
                             isUncShare = true;
@@ -490,869 +134,5 @@ namespace System.Security.Util {
                 throw new PathTooLongException(Environment.GetResourceString("IO.PathTooLong"));
             }
         }
-
-        // Do any misc massaging of data in the URL
-        private String PreProcessURL(String url, bool isFileURL)
-        {
-
-#if !PLATFORM_UNIX
-            if (isFileURL) {
-                // Remove when the Path class supports "\\?\"
-                url = PreProcessForExtendedPathRemoval(url, true, ref m_isUncShare);
-            }
-            else {
-                url = url.Replace('\\', '/');
-            }
-            return url;
-#else
-            // Remove superfluous '/'
-            // For UNIX, the file path would look something like:
-            //      file:///home/johndoe/here
-            //      file:/home/johndoe/here
-            //      file:../johndoe/here
-            //      file:~/johndoe/here
-            String temp = url;
-            int  nbSlashes = 0;
-            while(nbSlashes<temp.Length && '/'==temp[nbSlashes])
-                nbSlashes++;  
-            
-            // if we get a path like file:///directory/name we need to convert 
-            // this to /directory/name.
-            if(nbSlashes > 2)
-               temp = temp.Substring(nbSlashes-1, temp.Length - (nbSlashes-1));
-            else if (2 == nbSlashes) /* it's a relative path */
-               temp = temp.Substring(nbSlashes, temp.Length - nbSlashes);
-            return temp;
-#endif // !PLATFORM_UNIX
-
-        }
-
-        private void ParseFileURL(String url)
-        {
-
-            String temp = url;
-#if !PLATFORM_UNIX
-            int index = temp.IndexOf( '/');
-
-            if (index != -1 &&
-                ((index == 2 &&
-                  temp[index-1] != ':' &&
-                  temp[index-1] != '|') ||
-                 index != 2) &&
-                index != temp.Length - 1)
-            {
-                // Also, if it is a UNC share, we want m_localSite to
-                // be of the form "computername/share", so if the first
-                // fileEnd character found is a slash, do some more parsing
-                // to find the proper end character.
-
-                int tempIndex = temp.IndexOf( '/', index+1);
-
-                if (tempIndex != -1)
-                    index = tempIndex;
-                else
-                    index = -1;
-            }
-
-            String localSite;
-            if (index == -1)
-                localSite = temp;
-            else
-                localSite = temp.Substring(0,index);
-
-            if (localSite.Length == 0)
-                throw new ArgumentException( Environment.GetResourceString( "Argument_InvalidUrl" ) );
-
-            int i;
-            bool spacesAllowed;
-
-            if (localSite[0] == '\\' && localSite[1] == '\\')
-            {
-                spacesAllowed = true;
-                i = 2;
-            }
-            else
-            {
-                i = 0;
-                spacesAllowed = false;
-            }
-
-            bool useSmallCharToUpper = true;
-
-            for (; i < localSite.Length; ++i)
-            {
-                char c = localSite[i];
-
-                if ((c >= 'A' && c <= 'Z') ||
-                    (c >= 'a' && c <= 'z') ||
-                    (c >= '0' && c <= '9') ||
-                    (c == '-') || (c == '/') ||
-                    (c == ':') || (c == '|') ||
-                    (c == '.') || (c == '*') ||
-                    (c == '$') || (spacesAllowed && c == ' '))
-                {
-                    continue;
-                }
-                else
-                {
-                    useSmallCharToUpper = false;
-                    break;
-                }
-            }
-
-            if (useSmallCharToUpper)
-                localSite = String.SmallCharToUpper( localSite );
-            else
-                localSite = localSite.ToUpper(CultureInfo.InvariantCulture);
-
-            m_localSite = new LocalSiteString( localSite );
-
-            if (index == -1)
-            {
-                if (localSite[localSite.Length-1] == '*')
-                    m_directory = new DirectoryString( "*", false );
-                else 
-                    m_directory = new DirectoryString();
-            }
-            else
-            {
-                String directoryString = temp.Substring( index + 1 );
-                if (directoryString.Length == 0)
-                {
-                    m_directory = new DirectoryString();
-                }
-                else
-                {
-                    m_directory = new DirectoryString( directoryString, true);
-                }
-            }
-#else // !PLATFORM_UNIX
-            m_directory = new DirectoryString( temp, true);
-#endif // !PLATFORM_UNIX
-
-            m_siteString = null;
-            return;
-        }
-
-        private void ParseNonFileURL(String url)
-        {
-            String temp = url;
-            int index = temp.IndexOf('/');
-
-            if (index == -1)
-            {
-#if !PLATFORM_UNIX
-                m_localSite = null;    // for drive letter
-#endif // !PLATFORM_UNIX
-                m_siteString = new SiteString( temp );
-                m_directory = new DirectoryString();
-            }
-            else
-            {
-#if !PLATFORM_UNIX
-                String site = temp.Substring( 0, index );
-                m_localSite = null;
-                m_siteString = new SiteString( site );
-
-                String directoryString = temp.Substring( index + 1 );
-
-                if (directoryString.Length == 0)
-                {
-                    m_directory = new DirectoryString();
-                }
-                else
-                {
-                    m_directory = new DirectoryString( directoryString, false );
-                }
-#else
-                String directoryString = temp.Substring( index + 1 );
-                String site = temp.Substring( 0, index );
-                m_directory = new DirectoryString( directoryString, false );
-                m_siteString = new SiteString( site );
-#endif //!PLATFORM_UNIX
-            }
-            return;
-        }
-
-        void DoFastChecks( String url )
-        {
-            if (url == null)
-            {
-                throw new ArgumentNullException( nameof(url) );
-            }
-            Contract.EndContractBlock();
-            
-            if (url.Length == 0)
-            {
-                throw new FormatException(Environment.GetResourceString("Format_StringZeroLength"));
-            }
-        }
-
-        // NOTE:
-        // 1. We support URLs that follow the common Internet scheme syntax
-        //     (<scheme>://user:pass@<host>:<port>/<url-path>) and all windows file URLs.
-        // 2.  In the general case we parse of the site and create a SiteString out of it
-        //      (which supports our wildcarding scheme).  In the case of files we don't support
-        //      wildcarding and furthermore SiteString doesn't like ':' and '|' which can appear
-        //      in file urls so we just keep that info in a separate string and set the
-        //      SiteString to null.
-        //
-        // ex. http://www.microsoft.com/complus  -> m_siteString = "www.microsoft.com" m_localSite = null
-        // ex. file:///c:/complus/mscorlib.dll  -> m_siteString = null m_localSite = "c:"
-        // ex. file:///c|/complus/mscorlib.dll  -> m_siteString = null m_localSite = "c:"
-        void ParseString( String url, bool parsed )
-        {
-            // If there are any escaped hex or unicode characters in the url, translate those
-            // into the proper character.
-
-            if (!parsed)
-            {
-                url = UnescapeURL(url);
-            }
-
-            // Identify the protocol and strip the protocol info from the string, if present.
-            String temp = ParseProtocol(url); 
-
-            bool fileProtocol = (String.Compare( m_protocol, "file", StringComparison.OrdinalIgnoreCase) == 0);
-            
-            // handle any special  preocessing...removing extra characters, etc.
-            temp = PreProcessURL(temp, fileProtocol);
-            
-            if (fileProtocol)
-            {
-                ParseFileURL(temp);
-            }
-            else 
-            {
-                // Check if there is a port number and parse that out.
-                temp = ParsePort(temp);
-                ParseNonFileURL(temp);
-                // Note: that we allow DNS and Netbios names for non-file protocols (since sitestring will check
-                // that the hostname satisfies these two protocols. DNS-only checking can theoretically be added
-                // here but that would break all the programs that use '_' (which is fairly common, yet illegal).
-                // If this needs to be done at any point, add a call to m_siteString.IsLegalDNSName().
-            }
-
-
-        }
-
-        public String Scheme
-        {
-            get
-            {
-                DoDeferredParse();
-
-                return m_protocol;
-            }
-        }
-
-        public String Host
-        {
-            get
-            {
-                DoDeferredParse();
-
-                if (m_siteString != null)
-                {
-                    return m_siteString.ToString();
-                }
-                else
-                {
-#if !PLATFORM_UNIX
-                    return m_localSite.ToString();
-#else
-                    return "";
-#endif // !PLATFORM_UNIX
-                }
-            }
-        }
-
-        public String Port 
-        {
-            get 
-            {
-                DoDeferredParse();
-
-                if (m_port == -1)
-                    return null;
-                else
-                    return m_port.ToString(CultureInfo.InvariantCulture);
-            }
-        }
-
-        public String Directory
-        {
-            get
-            {
-                DoDeferredParse();
-
-                return m_directory.ToString();
-            }
-        }
-
-        /// <summary>
-        ///     Make a best guess at determining if this is URL refers to a file with a relative path. Since
-        ///     this is a guess to help out users of UrlMembershipCondition who may accidentally supply a
-        ///     relative URL, we'd rather err on the side of absolute than relative. (We'd rather accept some
-        ///     meaningless membership conditions rather than reject meaningful ones).
-        /// 
-        ///     In order to be a relative file URL, the URL needs to have a protocol of file, and not be on a
-        ///     UNC share.
-        /// 
-        ///     If both of the above are true, then the heuristics we'll use to detect an absolute URL are:
-        ///         1. A host name which is:
-        ///              a. greater than one character and ends in a colon (representing the drive letter) OR
-        ///              b. ends with a * (so we match any file with the given prefix if any)
-        ///         2. Has a directory name (cannot be simply file://c:)
-        /// </summary>
-        public bool IsRelativeFileUrl
-        {
-            get
-            {
-                DoDeferredParse();
-
-                if (String.Equals(m_protocol, "file", StringComparison.OrdinalIgnoreCase) && !m_isUncShare)
-                {
-#if !PLATFORM_UNIX
-                    string host = m_localSite != null ? m_localSite.ToString() : null;
-                    // If the host name ends with the * character, treat this as an absolute URL since the *
-                    // could represent the rest of the full path.
-                    if (host.EndsWith('*'))
-                        return false;
-#endif // !PLATFORM_UNIX
-                    string directory = m_directory != null ? m_directory.ToString() : null;
-
-#if !PLATFORM_UNIX
-                    return host == null || host.Length < 2 || !host.EndsWith(':') ||
-                           String.IsNullOrEmpty(directory);
-#else
-                    return String.IsNullOrEmpty(directory);
-#endif // !PLATFORM_UNIX
-
-                }
-
-                // Since this is not a local URL, it cannot be relative
-                return false;
-            }
-        }
-
-        public String GetFileName()
-        {
-            DoDeferredParse();
-
-#if !PLATFORM_UNIX
-            if (String.Compare( m_protocol, "file", StringComparison.OrdinalIgnoreCase) != 0)
-                return null;
-         
-            String intermediateDirectory = this.Directory.Replace( '/', '\\' );
-
-            String directory = this.Host.Replace( '/', '\\' );
-
-            int directorySlashIndex = directory.IndexOf( '\\' );
-            if (directorySlashIndex == -1)
-            {
-                if (directory.Length != 2 ||
-                    !(directory[1] == ':' || directory[1] == '|'))
-                {
-                    directory = "\\\\" + directory;
-                }
-            }
-            else if (directorySlashIndex != 2 ||
-                     (directorySlashIndex == 2 && directory[1] != ':' && directory[1] != '|'))
-            {
-                directory = "\\\\" + directory;
-            }
-
-            directory += "\\" + intermediateDirectory;
-            
-            return directory;
-#else
-            // In Unix, directory contains the full pathname
-            // (this is what we get in Win32)
-            if (String.Compare( m_protocol, "file", StringComparison.OrdinalIgnoreCase ) != 0)
-                return null;
-
-            return this.Directory;
-#endif    // !PLATFORM_UNIX
-    }
-
-
-        public String GetDirectoryName()
-        {
-            DoDeferredParse();
-
-#if !PLATFORM_UNIX
-            if (String.Compare( m_protocol, "file", StringComparison.OrdinalIgnoreCase ) != 0)
-                return null;
-
-            String intermediateDirectory = this.Directory.Replace( '/', '\\' );
-
-            int slashIndex = 0;
-            for (int i = intermediateDirectory.Length; i > 0; i--)
-            {
-               if (intermediateDirectory[i-1] == '\\')
-               {
-                   slashIndex = i;
-                   break;
-               }
-            }
-
-            String directory = this.Host.Replace( '/', '\\' );
-
-            int directorySlashIndex = directory.IndexOf( '\\' );
-            if (directorySlashIndex == -1)
-            {
-                if (directory.Length != 2 ||
-                    !(directory[1] == ':' || directory[1] == '|'))
-                {
-                    directory = "\\\\" + directory;
-                }
-            }
-            else if (directorySlashIndex > 2 ||
-                    (directorySlashIndex == 2 && directory[1] != ':' && directory[1] != '|'))
-            {
-                directory = "\\\\" + directory;
-            }
-
-            directory += "\\";
-            
-            if (slashIndex > 0)
-            {
-                directory += intermediateDirectory.Substring( 0, slashIndex );
-            }
-
-            return directory;
-#else
-            if (String.Compare( m_protocol, "file", StringComparison.OrdinalIgnoreCase) != 0)
-                return null;
-            
-            String directory = this.Directory.ToString();
-            int slashIndex = 0;
-            for (int i = directory.Length; i > 0; i--)
-            {
-               if (directory[i-1] == '/')
-               {
-                   slashIndex = i;
-                   break;
-               }
-            }
-            
-            if (slashIndex > 0)
-            {
-                directory = directory.Substring( 0, slashIndex );
-            }
-
-            return directory;
-#endif // !PLATFORM_UNIX            
-        }
-
-        public override SiteString Copy()
-        {
-            return new URLString( m_urlOriginal, m_parsedOriginal );
-        }            
-        
-        public override bool IsSubsetOf( SiteString site )
-        {
-            if (site == null)
-            {
-                return false;
-            }
-            
-            URLString url = site as URLString;
-            
-            if (url == null)
-            {
-                return false;
-            }
-
-            DoDeferredParse();
-            url.DoDeferredParse();
-
-            URLString normalUrl1 = this.SpecialNormalizeUrl();
-            URLString normalUrl2 = url.SpecialNormalizeUrl();
-            
-            if (String.Compare( normalUrl1.m_protocol, normalUrl2.m_protocol, StringComparison.OrdinalIgnoreCase) == 0 &&
-                normalUrl1.m_directory.IsSubsetOf( normalUrl2.m_directory ))
-            {
-#if !PLATFORM_UNIX
-                if (normalUrl1.m_localSite != null)
-                {
-                    // We do a little extra processing in here for local files since we allow
-                    // both <drive_letter>: and <drive_letter>| forms of urls.
-                    
-                    return normalUrl1.m_localSite.IsSubsetOf( normalUrl2.m_localSite );
-                }
-                else
-#endif // !PLATFORM_UNIX
-                {
-                    if (normalUrl1.m_port != normalUrl2.m_port)
-                        return false;
-
-                    return normalUrl2.m_siteString != null && normalUrl1.m_siteString.IsSubsetOf( normalUrl2.m_siteString );
-                }
-            }
-            else
-            {
-                return false;
-            }
-        }
-        
-        public override String ToString()
-        {
-            return m_urlOriginal;
-        }
-        
-        public override bool Equals(Object o)
-        {
-            DoDeferredParse();
-
-            if (o == null || !(o is URLString))
-                return false;
-            else
-                return this.Equals( (URLString)o );
-        }
-
-        public override int GetHashCode()
-        {
-            DoDeferredParse();
-
-            TextInfo info = CultureInfo.InvariantCulture.TextInfo;
-            int accumulator = 0;
-
-            if (this.m_protocol != null)
-                accumulator = info.GetCaseInsensitiveHashCode( this.m_protocol );
-
-#if !PLATFORM_UNIX
-            if (this.m_localSite != null)
-            {
-                accumulator = accumulator ^ this.m_localSite.GetHashCode();
-            }
-            else
-            {
-                accumulator = accumulator ^ this.m_siteString.GetHashCode();
-            }
-            accumulator = accumulator ^ this.m_directory.GetHashCode();
-#else
-            accumulator = accumulator ^ info.GetCaseInsensitiveHashCode(this.m_urlOriginal);
-#endif // !PLATFORM_UNIX
-            
-
-
-            return accumulator;
-        }    
-        
-        public bool Equals( URLString url )
-        {
-            return CompareUrls( this, url );
-        }
-
-        public static bool CompareUrls( URLString url1, URLString url2 )
-        {
-            if (url1 == null && url2 == null)
-                return true;
-
-            if (url1 == null || url2 == null)
-                return false;
-
-            url1.DoDeferredParse();
-            url2.DoDeferredParse();
-
-            URLString normalUrl1 = url1.SpecialNormalizeUrl();
-            URLString normalUrl2 = url2.SpecialNormalizeUrl();
-
-            // Compare protocol (case insensitive)
-
-            if (String.Compare( normalUrl1.m_protocol, normalUrl2.m_protocol, StringComparison.OrdinalIgnoreCase) != 0)
-                return false;
-
-            // Do special processing for file urls
-
-            if (String.Compare( normalUrl1.m_protocol, "file", StringComparison.OrdinalIgnoreCase) == 0)
-            {
-#if !PLATFORM_UNIX
-                if (!normalUrl1.m_localSite.IsSubsetOf( normalUrl2.m_localSite ) ||
-                    !normalUrl2.m_localSite.IsSubsetOf( normalUrl1.m_localSite ))
-                     return false;
-#else
-                return url1.IsSubsetOf( url2 ) &&
-                       url2.IsSubsetOf( url1 );
-#endif // !PLATFORM_UNIX
-            }
-            else
-            {
-                if (String.Compare( normalUrl1.m_userpass, normalUrl2.m_userpass, StringComparison.Ordinal) != 0)
-                    return false;
-                
-                if (!normalUrl1.m_siteString.IsSubsetOf( normalUrl2.m_siteString ) ||
-                    !normalUrl2.m_siteString.IsSubsetOf( normalUrl1.m_siteString ))
-                    return false;
-
-                if (url1.m_port != url2.m_port)
-                    return false;
-            }
-
-            if (!normalUrl1.m_directory.IsSubsetOf( normalUrl2.m_directory ) ||
-                !normalUrl2.m_directory.IsSubsetOf( normalUrl1.m_directory ))
-                return false;
-
-            return true;
-        }
-
-        internal String NormalizeUrl()
-        {
-            DoDeferredParse();
-            StringBuilder builtUrl = StringBuilderCache.Acquire();
-
-            if (String.Compare( m_protocol, "file", StringComparison.OrdinalIgnoreCase) == 0)
-            {
-#if !PLATFORM_UNIX
-                builtUrl = builtUrl.AppendFormat("FILE:///{0}/{1}", m_localSite.ToString(), m_directory.ToString());
-#else
-                builtUrl = builtUrl.AppendFormat("FILE:///{0}", m_directory.ToString());
-#endif // !PLATFORM_UNIX
-            }
-            else
-            {
-                builtUrl = builtUrl.AppendFormat("{0}://{1}{2}", m_protocol, m_userpass, m_siteString.ToString());
-
-                if (m_port != -1)
-                    builtUrl = builtUrl.AppendFormat("{0}",m_port);
-
-                builtUrl = builtUrl.AppendFormat("/{0}", m_directory.ToString());
-            }
-
-            return StringBuilderCache.GetStringAndRelease(builtUrl).ToUpper(CultureInfo.InvariantCulture);
-        }
-        
-#if !PLATFORM_UNIX
-        internal URLString SpecialNormalizeUrl()
-        {
-            // Under WinXP, file protocol urls can be mapped to
-            // drives that aren't actually file protocol underneath
-            // due to drive mounting.  This code attempts to figure
-            // out what a drive is mounted to and create the
-            // url is maps to.
-
-            DoDeferredParse();
-            if (String.Compare( m_protocol, "file", StringComparison.OrdinalIgnoreCase) != 0)
-            {
-                return this;
-            }
-            else
-            {
-                String localSite = m_localSite.ToString();
-
-                if (localSite.Length == 2 &&
-                    (localSite[1] == '|' ||
-                     localSite[1] == ':'))
-                {
-                    String deviceName = null;
-                    GetDeviceName(localSite, JitHelpers.GetStringHandleOnStack(ref deviceName));
-
-                    if (deviceName != null)
-                    {
-                        if (deviceName.IndexOf( "://", StringComparison.Ordinal ) != -1)
-                        {
-                            URLString u = new URLString( deviceName + "/" + this.m_directory.ToString() );
-                            u.DoDeferredParse(); // Presumably the caller of SpecialNormalizeUrl wants a fully parsed URL
-                            return u;
-                        }
-                        else
-                        {
-                            URLString u = new URLString( "file://" + deviceName + "/" + this.m_directory.ToString() );
-                            u.DoDeferredParse();// Presumably the caller of SpecialNormalizeUrl wants a fully parsed URL
-                            return u;
-                        }
-                    }
-                    else
-                        return this;
-                }
-                else
-                {
-                    return this;
-                }
-            }
-        }
-                
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        private static extern void GetDeviceName( String driveLetter, StringHandleOnStack retDeviceName );
-
-#else
-        internal URLString SpecialNormalizeUrl()
-        {
-            return this;
-        }
-#endif // !PLATFORM_UNIX
-
-    }
-
-    
-    [Serializable]
-    internal class DirectoryString : SiteString
-    {
-        private bool m_checkForIllegalChars;
-
-        // From KB #Q177506, file/folder illegal characters are \ / : * ? " < > | 
-        protected static char[] m_illegalDirectoryCharacters = { '\\', ':', '*', '?', '"', '<', '>', '|' };
-        
-        public DirectoryString()
-        {
-            m_site = "";
-            m_separatedSite = new ArrayList();
-        }
-        
-        public DirectoryString( String directory, bool checkForIllegalChars )
-        {
-            m_site = directory;
-            m_checkForIllegalChars = checkForIllegalChars;
-            m_separatedSite = CreateSeparatedString(directory);
-        }
-
-        private ArrayList CreateSeparatedString(String directory)
-        {
-            if (directory == null || directory.Length == 0)
-            {
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidDirectoryOnUrl"));
-            }
-            Contract.EndContractBlock();
-
-            ArrayList list = new ArrayList();
-            String[] separatedArray = directory.Split('/');
-            
-            for (int index = 0; index < separatedArray.Length; ++index)
-            {
-                if (separatedArray[index] == null || separatedArray[index].Equals( "" ))
-                {
-                    // this case is fine, we just ignore it the extra separators.
-                }
-                else if (separatedArray[index].Equals( "*" ))
-                {
-                    if (index != separatedArray.Length-1)
-                    {
-                        throw new ArgumentException(Environment.GetResourceString("Argument_InvalidDirectoryOnUrl"));
-                    }
-                    list.Add( separatedArray[index] );
-                }
-                else if (m_checkForIllegalChars && separatedArray[index].IndexOfAny( m_illegalDirectoryCharacters ) != -1)
-                {
-                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidDirectoryOnUrl"));
-                }
-                else
-                {
-                    list.Add( separatedArray[index] );
-                }
-            }
-            
-            return list;
-        }
-        
-        public virtual bool IsSubsetOf( DirectoryString operand )
-        {
-            return this.IsSubsetOf( operand, true );
-        }
-
-        public virtual bool IsSubsetOf( DirectoryString operand, bool ignoreCase )
-        {
-            if (operand == null)
-            {
-                return false;
-            }
-            else if (operand.m_separatedSite.Count == 0)
-            {
-                return this.m_separatedSite.Count == 0 || this.m_separatedSite.Count > 0 && String.Compare((String)this.m_separatedSite[0], "*", StringComparison.Ordinal) == 0;
-            }
-            else if (this.m_separatedSite.Count == 0)
-            {
-                return String.Compare((String)operand.m_separatedSite[0], "*", StringComparison.Ordinal) == 0;
-            }
-            else
-            {
-                return base.IsSubsetOf( operand, ignoreCase );
-            }
-        }
-    }
-
-#if !PLATFORM_UNIX
-    [Serializable]
-    internal class LocalSiteString : SiteString
-    {
-        public LocalSiteString( String site )
-        {
-            m_site = site.Replace( '|', ':');
-
-            if (m_site.Length > 2 && m_site.IndexOf( ':' ) != -1)
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidDirectoryOnUrl"));
-
-            m_separatedSite = CreateSeparatedString(m_site);
-        }
-
-        private ArrayList CreateSeparatedString(String directory)
-        {
-            if (directory == null || directory.Length == 0)
-            {
-                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidDirectoryOnUrl"));
-            }
-            Contract.EndContractBlock();
-
-            ArrayList list = new ArrayList();
-            String[] separatedArray = directory.Split('/');
-            
-            for (int index = 0; index < separatedArray.Length; ++index)
-            {
-                if (separatedArray[index] == null || separatedArray[index].Equals( "" ))
-                {
-                    if (index < 2 &&
-                        directory[index] == '/')
-                    {
-                        list.Add( "//" );
-                    }
-                    else if (index != separatedArray.Length-1)
-                    {
-                        throw new ArgumentException(Environment.GetResourceString("Argument_InvalidDirectoryOnUrl"));
-                    }
-                }
-                else if (separatedArray[index].Equals( "*" ))
-                {
-                    if (index != separatedArray.Length-1)
-                    {
-                        throw new ArgumentException(Environment.GetResourceString("Argument_InvalidDirectoryOnUrl"));
-                    }
-                    list.Add( separatedArray[index] );
-                }
-                else
-                {
-                    list.Add( separatedArray[index] );
-                }
-            }
-            
-            return list;
-        }
-        
-        public virtual bool IsSubsetOf( LocalSiteString operand )
-        {
-            return this.IsSubsetOf( operand, true );
-        }
-
-        public virtual bool IsSubsetOf( LocalSiteString operand, bool ignoreCase )
-        {
-            if (operand == null)
-            {
-                return false;
-            }
-            else if (operand.m_separatedSite.Count == 0)
-            {
-                return this.m_separatedSite.Count == 0 || this.m_separatedSite.Count > 0 && String.Compare((String)this.m_separatedSite[0], "*", StringComparison.Ordinal) == 0;
-            }
-            else if (this.m_separatedSite.Count == 0)
-            {
-                return String.Compare((String)operand.m_separatedSite[0], "*", StringComparison.Ordinal) == 0;
-            }
-            else
-            {
-                return base.IsSubsetOf( operand, ignoreCase );
-            }
-        }
     }
-#endif // !PLATFORM_UNIX
 }
diff --git a/src/mscorlib/src/System/Security/Util/XMLUtil.cs b/src/mscorlib/src/System/Security/Util/XMLUtil.cs
deleted file mode 100644
index 3a1aaa3b09..0000000000
--- a/src/mscorlib/src/System/Security/Util/XMLUtil.cs
+++ /dev/null
@@ -1,435 +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:  Helpers for XML input & output
-**
-===========================================================*/
-namespace System.Security.Util  {
-    
-    using System;
-    using System.Security;
-    using System.Security.Permissions;
-    using System.Security.Policy;
-    using System.Runtime.InteropServices;
-    using System.Runtime.Remoting;
-    using System.IO;
-    using System.Text;
-    using System.Runtime.CompilerServices;
-    using PermissionState = System.Security.Permissions.PermissionState;
-    using BindingFlags = System.Reflection.BindingFlags;
-    using Assembly = System.Reflection.Assembly;
-    using System.Threading;
-    using System.Globalization;
-    using System.Reflection;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-
-    internal static class XMLUtil
-    {
-        //
-        // Warning: Element constructors have side-effects on their
-        //          third argument.
-        //
-        
-        private const String BuiltInPermission = "System.Security.Permissions.";
-
-        public static SecurityElement
-        NewPermissionElement (IPermission ip)
-        {
-            return NewPermissionElement (ip.GetType ().FullName) ;
-        }
-        
-        public static SecurityElement
-        NewPermissionElement (String name)
-        {
-            SecurityElement ecr = new SecurityElement( "Permission" );
-            ecr.AddAttribute( "class", name );
-            return ecr;
-        }
-        
-        public static void
-        AddClassAttribute( SecurityElement element, Type type, String typename )
-        {
-            // Replace any quotes with apostrophes so that we can include quoted materials
-            // within classnames.  Notably the assembly name member 'loc' uses a quoted string.
-        
-            // NOTE: this makes assumptions as to what reflection is expecting for a type string
-            // it will need to be updated if reflection changes what it wants.
-        
-            if ( typename == null )
-                typename = type.FullName;
-            Debug.Assert( type.FullName.Equals( typename ), "Incorrect class name passed! Was : " + typename + " Shoule be: " + type.FullName);
-            element.AddAttribute( "class", typename + ", " + type.Module.Assembly.FullName.Replace( '\"', '\'' ) );
-        }
-        
-        internal static bool ParseElementForAssemblyIdentification(SecurityElement el,
-                                                                   out String className,
-                                                                   out String assemblyName, // for example "WindowsBase"
-                                                                   out String assemblyVersion)
-        {
-
-            className = null;
-            assemblyName = null;
-            assemblyVersion = null;
-            
-            String fullClassName = el.Attribute( "class" );
-            
-            if (fullClassName == null)
-            {
-                return false;
-            }
-            if (fullClassName.IndexOf('\'') >= 0)
-            {
-                fullClassName = fullClassName.Replace( '\'', '\"' );
-            }
-
-            int commaIndex = fullClassName.IndexOf( ',' );
-            int namespaceClassNameLength;
-            
-            // If the classname is tagged with assembly information, find where
-            // the assembly information begins.
-            
-            if (commaIndex == -1)
-            {
-                return false;
-            }
-
-            namespaceClassNameLength = commaIndex;
-            className = fullClassName.Substring(0, namespaceClassNameLength);
-            String assemblyFullName = fullClassName.Substring(commaIndex + 1);
-            AssemblyName an = new AssemblyName(assemblyFullName);
-            assemblyName = an.Name;
-            assemblyVersion = an.Version.ToString();
-            return true;
-        }
-        private static bool
-        ParseElementForObjectCreation( SecurityElement el,
-                                       String requiredNamespace,
-                                       out String className,
-                                       out int classNameStart,
-                                       out int classNameLength )
-        {
-            className = null;
-            classNameStart = 0;
-            classNameLength = 0;
-            
-            int requiredNamespaceLength = requiredNamespace.Length;
-
-            String fullClassName = el.Attribute( "class" );
-            
-            if (fullClassName == null)
-            {
-                throw new ArgumentException( Environment.GetResourceString( "Argument_NoClass" ) );
-            }
-            
-            if (fullClassName.IndexOf('\'') >= 0)
-            {
-                fullClassName = fullClassName.Replace( '\'', '\"' );
-            }
-            
-            if (!PermissionToken.IsMscorlibClassName( fullClassName ))
-            {
-                return false;
-            }
-
-            int commaIndex = fullClassName.IndexOf( ',' );
-            int namespaceClassNameLength;
-            
-            // If the classname is tagged with assembly information, find where
-            // the assembly information begins.
-            
-            if (commaIndex == -1)
-            {
-                namespaceClassNameLength = fullClassName.Length;
-            }
-            else
-            {
-                namespaceClassNameLength = commaIndex;
-            }
-
-            // Only if the length of the class name is greater than the namespace info
-            // on our requiredNamespace do we continue
-            // with our check.
-            
-            if (namespaceClassNameLength > requiredNamespaceLength)
-            {
-                // Make sure we are in the required namespace.
-                if (fullClassName.StartsWith(requiredNamespace, StringComparison.Ordinal))
-                {
-                    className = fullClassName;
-                    classNameLength = namespaceClassNameLength - requiredNamespaceLength;
-                    classNameStart = requiredNamespaceLength;
-                    return true;
-                }
-            }
-            
-            return false;
-        }
-
-        public static IPermission
-        CreatePermission (SecurityElement el, PermissionState permState, bool ignoreTypeLoadFailures)
-        {
-            if (el == null || !(el.Tag.Equals("Permission") || el.Tag.Equals("IPermission")) )
-                throw new ArgumentException( String.Format( null, Environment.GetResourceString( "Argument_WrongElementType" ), "<Permission>" ) ) ;
-            Contract.EndContractBlock();
-    
-            String className;
-            int classNameLength;
-            int classNameStart;
-            
-            if (!ParseElementForObjectCreation( el,
-                                                BuiltInPermission,
-                                                out className,
-                                                out classNameStart,
-                                                out classNameLength ))
-            {
-                goto USEREFLECTION;
-            }
-                                              
-            // We have a built in permission, figure out which it is.
-                    
-            // UIPermission
-            // FileIOPermission
-            // SecurityPermission
-            // PrincipalPermission
-            // ReflectionPermission
-            // FileDialogPermission
-            // EnvironmentPermission
-            // GacIdentityPermission
-            // UrlIdentityPermission
-            // SiteIdentityPermission
-            // ZoneIdentityPermission
-            // KeyContainerPermission
-            // UnsafeForHostPermission
-            // HostProtectionPermission
-            // StrongNameIdentityPermission
-            // RegistryPermission
-            // PublisherIdentityPermission
-
-            switch (classNameLength)
-            {
-                case 12:
-                    // UIPermission
-                    if (String.Compare(className, classNameStart, "UIPermission", 0, classNameLength, StringComparison.Ordinal) == 0)
-                        return new UIPermission( permState );
-                    else
-                        goto USEREFLECTION;
-                                
-                case 16:
-                    // FileIOPermission
-                    if (String.Compare(className, classNameStart, "FileIOPermission", 0, classNameLength, StringComparison.Ordinal) == 0)
-                        return new FileIOPermission( permState );
-                    else
-                        goto USEREFLECTION;
-                            
-                case 18:
-                    // RegistryPermission
-                    // SecurityPermission
-                    if (className[classNameStart] == 'R')
-                    {
-                        if (String.Compare(className, classNameStart, "RegistryPermission", 0, classNameLength, StringComparison.Ordinal) == 0)
-                            return new RegistryPermission( permState );
-                        else
-                            goto USEREFLECTION;
-                    }
-                    else
-                    {
-                        if (String.Compare(className, classNameStart, "SecurityPermission", 0, classNameLength, StringComparison.Ordinal) == 0)
-                            return new SecurityPermission( permState );
-                        else
-                            goto USEREFLECTION;
-                    }
-                case 20:
-                    // ReflectionPermission
-                    // FileDialogPermission
-                    if (className[classNameStart] == 'R')
-                    {
-                        if (String.Compare(className, classNameStart, "ReflectionPermission", 0, classNameLength, StringComparison.Ordinal) == 0)
-                            return new ReflectionPermission( permState );
-                        else
-                            goto USEREFLECTION;
-                    }
-                    else
-                    {
-                        if (String.Compare(className, classNameStart, "FileDialogPermission", 0, classNameLength, StringComparison.Ordinal) == 0)
-                            return new FileDialogPermission( permState );
-                        else
-                            goto USEREFLECTION;
-                    }
-
-                case 21:
-                    // EnvironmentPermission
-                    // UrlIdentityPermission
-                    // GacIdentityPermission
-                    if (className[classNameStart] == 'E')
-                    {
-                        if (String.Compare(className, classNameStart, "EnvironmentPermission", 0, classNameLength, StringComparison.Ordinal) == 0)
-                            return new EnvironmentPermission( permState );
-                        else
-                            goto USEREFLECTION;
-                    }
-                    else if (className[classNameStart] == 'U')
-                    {
-                        if (String.Compare(className, classNameStart, "UrlIdentityPermission", 0, classNameLength, StringComparison.Ordinal) == 0)
-                            return new UrlIdentityPermission( permState );
-                        else
-                            goto USEREFLECTION;
-                    }
-                    else
-                    {
-                        if (String.Compare(className, classNameStart, "GacIdentityPermission", 0, classNameLength, StringComparison.Ordinal) == 0)
-                            return new GacIdentityPermission( permState );
-                        else
-                            goto USEREFLECTION;
-                    }
-                case 22:
-                    // SiteIdentityPermission
-                    // ZoneIdentityPermission
-                    // KeyContainerPermission
-                    if (className[classNameStart] == 'S')
-                    {
-                        if (String.Compare(className, classNameStart, "SiteIdentityPermission", 0, classNameLength, StringComparison.Ordinal) == 0)
-                            return new SiteIdentityPermission( permState );
-                        else
-                            goto USEREFLECTION;
-                    }
-                    else if (className[classNameStart] == 'Z')
-                    {
-                        if (String.Compare(className, classNameStart, "ZoneIdentityPermission", 0, classNameLength, StringComparison.Ordinal) == 0)
-                            return new ZoneIdentityPermission( permState );
-                        else
-                            goto USEREFLECTION;
-                    }
-                    else
-                    {
-                        if (String.Compare(className, classNameStart, "KeyContainerPermission", 0, classNameLength, StringComparison.Ordinal) == 0)
-                            return new KeyContainerPermission( permState );
-                        else
-                            goto USEREFLECTION;
-                    }
-                case 24:
-                    // HostProtectionPermission
-                    if (String.Compare(className, classNameStart, "HostProtectionPermission", 0, classNameLength, StringComparison.Ordinal) == 0)
-                        return new HostProtectionPermission( permState );
-                    else
-                        goto USEREFLECTION;
-                case 28:
-                    // StrongNameIdentityPermission
-                    if (String.Compare(className, classNameStart, "StrongNameIdentityPermission", 0, classNameLength, StringComparison.Ordinal) == 0)
-                        return new StrongNameIdentityPermission( permState );
-                    else
-                        goto USEREFLECTION;
-                default:
-                    goto USEREFLECTION;
-            }
-
-USEREFLECTION:
-
-            Object[] objs = new Object[1];
-            objs[0] = permState;
-
-            Type permClass = null;
-            IPermission perm = null;
-
-            new ReflectionPermission(ReflectionPermissionFlag.MemberAccess).Assert();
-            permClass = GetClassFromElement(el, ignoreTypeLoadFailures);
-            if (permClass == null)
-                return null;
-            if (!(typeof(IPermission).IsAssignableFrom(permClass)))
-                throw new ArgumentException( Environment.GetResourceString("Argument_NotAPermissionType") );
-
-            perm = (IPermission) Activator.CreateInstance(permClass, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public, null, objs, null );
-
-            return perm;
-        }
-
-        internal static Type
-        GetClassFromElement (SecurityElement el, bool ignoreTypeLoadFailures)
-        {
-            String className = el.Attribute( "class" );
-
-            if (className == null)
-            {
-                if (ignoreTypeLoadFailures)
-                    return null;
-                else
-                    throw new ArgumentException( String.Format( null, Environment.GetResourceString("Argument_InvalidXMLMissingAttr"), "class") );
-            }
-
-            if (ignoreTypeLoadFailures)
-            {
-                try
-                {
-                    return Type.GetType(className, false, false);
-                }
-                catch (SecurityException)
-                {
-                    return null;
-                }
-            }
-            else
-                return Type.GetType(className, true, false);
-        }
-
-        public static bool
-        IsPermissionElement (IPermission ip,
-                             SecurityElement el)
-        {
-            if (!el.Tag.Equals ("Permission") && !el.Tag.Equals ("IPermission"))
-                return false;
-                
-            return true;
-        }
-        
-        public static bool
-        IsUnrestricted (SecurityElement el)
-        {
-            String sUnrestricted = el.Attribute( "Unrestricted" );
-            
-            if (sUnrestricted == null)
-                return false;
-
-            return sUnrestricted.Equals( "true" ) || sUnrestricted.Equals( "TRUE" ) || sUnrestricted.Equals( "True" );
-        }
-
-
-        public static String BitFieldEnumToString( Type type, Object value )
-        {
-            int iValue = (int)value;
-
-            if (iValue == 0)
-                return Enum.GetName( type, 0 );
-
-            StringBuilder result = StringBuilderCache.Acquire();
-            bool first = true;
-            int flag = 0x1;
-
-            for (int i = 1; i < 32; ++i)
-            {
-                if ((flag & iValue) != 0)
-                {
-                    String sFlag = Enum.GetName( type, flag );
-
-                    if (sFlag == null)
-                        continue;
-
-                    if (!first)
-                    {
-                        result.Append( ", " );
-                    }
-
-                    result.Append( sFlag );
-                    first = false;
-                }
-
-                flag = flag << 1;
-            }
-            
-            return StringBuilderCache.GetStringAndRelease(result);
-        } 
-    }
-}
diff --git a/src/mscorlib/src/System/Security/Util/sitestring.cs b/src/mscorlib/src/System/Security/Util/sitestring.cs
deleted file mode 100644
index 968e394cd1..0000000000
--- a/src/mscorlib/src/System/Security/Util/sitestring.cs
+++ /dev/null
@@ -1,287 +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.
-
-namespace System.Security.Util {
-    using System;
-    using System.Collections;
-    using System.Globalization;
-    using System.Diagnostics.Contracts;
-
-    [Serializable]
-    internal class SiteString
-    {
-        protected String m_site;
-        protected ArrayList m_separatedSite;
-
-        protected internal SiteString()
-        {
-            // Only call this in derived classes when you know what you're doing.
-        }
-        
-        public SiteString( String site )
-        {
-            m_separatedSite = CreateSeparatedSite( site );
-            m_site = site;
-        }
-
-        private SiteString(String site, ArrayList separatedSite)
-        {
-            m_separatedSite = separatedSite;
-            m_site = site;
-        }
-
-        private static ArrayList CreateSeparatedSite(String site)
-        {
-            if (site == null || site.Length == 0)
-            {
-                throw new ArgumentException( Environment.GetResourceString("Argument_InvalidSite" ));
-            }
-            Contract.EndContractBlock();
-
-            ArrayList list = new ArrayList();
-            int braIndex = -1;
-            int ketIndex = -1;
-            braIndex = site.IndexOf('[');
-            if (braIndex == 0)
-                ketIndex = site.IndexOf(']', braIndex+1);
-
-            if (ketIndex != -1)
-            {
-                // Found an IPv6 address. Special case that
-                String ipv6Addr = site.Substring(braIndex+1, ketIndex-braIndex-1);
-                list.Add(ipv6Addr);
-                return list;
-            }
-
-            // Regular hostnames or IPv4 addresses
-            // We dont need to do this for IPv4 addresses, but it's easier to do it anyway
-            String[] separatedArray = site.Split('.');
-            
-            for (int index = separatedArray.Length-1; index > -1; --index)
-            {
-                if (separatedArray[index] == null)
-                {
-                    throw new ArgumentException( Environment.GetResourceString("Argument_InvalidSite" ));
-                }
-                else if (separatedArray[index].Equals( "" )) 
-                {
-                    if (index != separatedArray.Length-1) 
-                    {
-                        throw new ArgumentException( Environment.GetResourceString("Argument_InvalidSite" ));
-                    }
-                }
-                else if (separatedArray[index].Equals( "*" ))
-                {
-                    if (index != 0)
-                    {
-                        throw new ArgumentException( Environment.GetResourceString("Argument_InvalidSite" ));
-                    }
-                    list.Add( separatedArray[index] );
-                }
-                else if (!AllLegalCharacters( separatedArray[index] ))
-                {
-                    throw new ArgumentException( Environment.GetResourceString("Argument_InvalidSite" ));
-                }
-                else
-                {
-                    list.Add( separatedArray[index] );
-                }
-            }
-            
-            return list;
-        }
-
-        // KB# Q188997 - http://support.microsoft.com/default.aspx?scid=KB;EN-US;Q188997& gives the list of allowed characters in
-        // a NETBIOS name. DNS names are a subset of that (alphanumeric or '-').
-        private static bool AllLegalCharacters( String str )
-        {
-            for (int i = 0; i < str.Length; ++i)
-            {
-                char c = str[i];
-
-                if (IsLegalDNSChar(c) ||
-                    IsNetbiosSplChar(c))
-                {
-                    continue;
-                }
-                else
-                {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        private static bool IsLegalDNSChar(char c)
-        {
-            if ((c >= 'a' && c <= 'z') ||
-                (c >= 'A' && c <= 'Z') ||
-                (c >= '0' && c <= '9') ||
-                (c == '-'))
-                return true;
-            else
-                return false;
-        }
-        private static bool IsNetbiosSplChar(char c)
-        {
-            //  ! @ # $ % ^ & ( ) - _ ' { } . ~ are OK
-            switch (c) {
-                case '-':
-                case '_':
-                case '@':
-                case '!':
-                case '#':
-                case '$':
-                case '%':
-                case '^':
-                case '&':
-                case '(':
-                case ')':
-                case '\'':
-                case '{':
-                case '}':
-                case '.':
-                case '~':
-                    return true;
-                default:
-                    return false;
-            }
-        }
-
-        public override String ToString()
-        {
-            return m_site;
-        }
-        
-        public override bool Equals(Object o)
-        {
-            if (o == null || !(o is SiteString))
-                return false;
-            else
-                return this.Equals( (SiteString)o, true );
-        }
-
-        public override int GetHashCode()
-        {
-            TextInfo info = CultureInfo.InvariantCulture.TextInfo;
-
-            return info.GetCaseInsensitiveHashCode( this.m_site );
-        }
-
-        internal bool Equals( SiteString ss, bool ignoreCase )
-        {
-            if (this.m_site == null)
-                return ss.m_site == null;
-            if (ss.m_site == null)
-                return false;
-            return this.IsSubsetOf(ss, ignoreCase) && ss.IsSubsetOf(this, ignoreCase);
-        }
-            
-        
-        public virtual SiteString Copy()
-        {
-            return new SiteString( m_site, m_separatedSite );
-        }
-
-        public virtual bool IsSubsetOf( SiteString operand )
-        {
-            return this.IsSubsetOf( operand, true );
-        }
-
-        public virtual bool IsSubsetOf( SiteString operand, bool ignoreCase )
-        {
-            StringComparison strComp = (ignoreCase? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
-            if (operand == null)
-            {
-                return false;
-            }
-            else if (this.m_separatedSite.Count == operand.m_separatedSite.Count &&
-                     this.m_separatedSite.Count == 0)
-            {
-                return true;
-            }
-            else if (this.m_separatedSite.Count < operand.m_separatedSite.Count - 1)
-            {
-                return false;
-            }
-            else if (this.m_separatedSite.Count > operand.m_separatedSite.Count &&
-                     operand.m_separatedSite.Count > 0 &&
-                     !operand.m_separatedSite[operand.m_separatedSite.Count - 1].Equals("*"))
-            {
-                return false;
-            }
-            else if (String.Compare( this.m_site, operand.m_site, strComp) == 0)
-            {
-                return true;
-            }
-
-            for (int index = 0; index < operand.m_separatedSite.Count - 1; ++index)
-            {
-                if (String.Compare((String)this.m_separatedSite[index], (String)operand.m_separatedSite[index], strComp) != 0)
-                {
-                    return false;
-                }
-            }
-
-            if (this.m_separatedSite.Count < operand.m_separatedSite.Count)
-            {
-                return operand.m_separatedSite[operand.m_separatedSite.Count - 1].Equals("*");
-            }
-            else if (this.m_separatedSite.Count == operand.m_separatedSite.Count)
-            {
-                // last item must be the same or operand must have a * in its last item
-                return (String.Compare((String)this.m_separatedSite[this.m_separatedSite.Count - 1],
-                                                    (String)operand.m_separatedSite[this.m_separatedSite.Count - 1], 
-                                                    strComp ) == 0 ||
-                           operand.m_separatedSite[operand.m_separatedSite.Count - 1].Equals("*"));
-                    
-            }
-            else 
-                return true;
-        }
-                
-        
-    
-        public virtual SiteString Intersect( SiteString operand )
-        {
-            if (operand == null)
-            {
-                return null;
-            }
-            else if (this.IsSubsetOf( operand ))
-            {
-                return this.Copy();
-            }
-            else if (operand.IsSubsetOf( this ))
-            {
-                return operand.Copy();
-            }
-            else
-            {
-                return null;
-            }
-        }
-        
-        public virtual SiteString Union( SiteString operand )
-        {
-            if (operand == null)
-            {
-                return this;
-            }
-            else if (this.IsSubsetOf( operand ))
-            {
-                return operand.Copy();
-            }
-            else if (operand.IsSubsetOf( this ))
-            {
-                return this.Copy();
-            }
-            else
-            {
-                return null;
-            }
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Security/VerificationException.cs b/src/mscorlib/src/System/Security/VerificationException.cs
index b0823cac01..5defbd6603 100644
--- a/src/mscorlib/src/System/Security/VerificationException.cs
+++ b/src/mscorlib/src/System/Security/VerificationException.cs
@@ -9,7 +9,6 @@ namespace System.Security {
     using System;
     using System.Runtime.Serialization;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class VerificationException : SystemException {
         public VerificationException() 
diff --git a/src/mscorlib/src/System/SerializableAttribute.cs b/src/mscorlib/src/System/SerializableAttribute.cs
index bceca6800a..1c99654eec 100644
--- a/src/mscorlib/src/System/SerializableAttribute.cs
+++ b/src/mscorlib/src/System/SerializableAttribute.cs
@@ -16,7 +16,6 @@ namespace System {
     using System.Reflection;
 
     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Delegate, Inherited = false)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class SerializableAttribute : Attribute 
     {
         internal static Attribute GetCustomAttribute(RuntimeType type) 
diff --git a/src/mscorlib/src/System/SharedStatics.cs b/src/mscorlib/src/System/SharedStatics.cs
index cbc5c354a1..d9364335f5 100644
--- a/src/mscorlib/src/System/SharedStatics.cs
+++ b/src/mscorlib/src/System/SharedStatics.cs
@@ -16,7 +16,6 @@ namespace System
     using System.Threading;
     using System.Runtime.Remoting;
     using System.Security;
-    using System.Security.Util;
     using System.Runtime.CompilerServices;
     using System.Runtime.ConstrainedExecution;
     using System.Diagnostics;
@@ -36,40 +35,9 @@ namespace System
         }
 
         private volatile String _Remoting_Identity_IDGuid;
-        public static String Remoting_Identity_IDGuid 
-        { 
-            get 
-            {
-                if (_sharedStatics._Remoting_Identity_IDGuid == null)
-                {
-                    bool tookLock = false;
-                    RuntimeHelpers.PrepareConstrainedRegions();
-                    try {
-                        Monitor.Enter(_sharedStatics, ref tookLock);
-
-                        if (_sharedStatics._Remoting_Identity_IDGuid == null)
-                        {
-                            _sharedStatics._Remoting_Identity_IDGuid = Guid.NewGuid().ToString().Replace('-', '_');
-                        }
-                    }
-                    finally {
-                        if (tookLock)
-                            Monitor.Exit(_sharedStatics);
-                    }
-                }
-
-                Debug.Assert(_sharedStatics._Remoting_Identity_IDGuid != null,
-                                "_sharedStatics._Remoting_Identity_IDGuid != null");
-                return _sharedStatics._Remoting_Identity_IDGuid;
-            } 
-        }
 
         // Note this may not need to be process-wide.
         private int _Remoting_Identity_IDSeqNum;
-        internal static int Remoting_Identity_GetNextSeqNum()
-        {
-            return Interlocked.Increment(ref _sharedStatics._Remoting_Identity_IDSeqNum);
-        }
 
 
         // This is the total amount of memory currently "reserved" via
@@ -77,7 +45,6 @@ namespace System
         // Stored as a long because we need to use Interlocked.Add.
         private long _memFailPointReservedMemory;
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal static long AddMemoryFailPointReservation(long size)
         {
             // Size can legitimately be negative - see Dispose.
diff --git a/src/mscorlib/src/System/Single.cs b/src/mscorlib/src/System/Single.cs
index 481c088617..657d7aef32 100644
--- a/src/mscorlib/src/System/Single.cs
+++ b/src/mscorlib/src/System/Single.cs
@@ -21,7 +21,6 @@ namespace System {
 
 [Serializable]
 [System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public struct Single : IComparable, IFormattable, IConvertible
         , IComparable<Single>, IEquatable<Single> 
     {
@@ -58,7 +57,6 @@ namespace System {
         }
 
         [Pure]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public unsafe static bool IsNaN(float f) {
             return (*(int*)(&f) & 0x7FFFFFFF) > 0x7F800000;
diff --git a/src/mscorlib/src/System/Span.cs b/src/mscorlib/src/System/Span.cs
index 19e21c0bad..b0d5771c10 100644
--- a/src/mscorlib/src/System/Span.cs
+++ b/src/mscorlib/src/System/Span.cs
@@ -80,6 +80,7 @@ namespace System
         /// <exception cref="System.ArgumentOutOfRangeException">
         /// Thrown when the specified <paramref name="start"/> or end index is not in the range (&lt;0 or &gt;=Length).
         /// </exception>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Span(T[] array, int start, int length)
         {
             if (array == null)
@@ -108,9 +109,10 @@ namespace System
         /// Thrown when the specified <paramref name="length"/> is negative.
         /// </exception>
         [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public unsafe Span(void* pointer, int length)
         {
-            if (JitHelpers.ContainsReferences<T>())
+            if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
                 ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
             if (length < 0)
                 ThrowHelper.ThrowArgumentOutOfRangeException();
@@ -227,6 +229,69 @@ namespace System
         }
 
         /// <summary>
+        /// Clears the contents of this span.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Clear()
+        {
+            // TODO: Optimize - https://github.com/dotnet/coreclr/issues/9161
+            for (int i = 0; i < _length; i++)
+            {
+                this[i] = default(T);
+            }
+        }
+
+        /// <summary>
+        /// Fills the contents of this span with the given value.
+        /// </summary>
+        public void Fill(T value)
+        {
+            int length = _length;
+
+            if (length == 0)
+                return;
+
+            if (Unsafe.SizeOf<T>() == 1)
+            {
+                byte fill = Unsafe.As<T, byte>(ref value);
+                ref byte r = ref Unsafe.As<T, byte>(ref _pointer.Value);
+                Unsafe.InitBlockUnaligned(ref r, fill, (uint)length);
+            }
+            else
+            {
+                ref T r = ref DangerousGetPinnableReference();
+
+                // TODO: Create block fill for value types of power of two sizes e.g. 2,4,8,16
+
+                // Simple loop unrolling
+                int i = 0;
+                for (; i < (length & ~7); i += 8)
+                {
+                    Unsafe.Add<T>(ref r, i + 0) = value;
+                    Unsafe.Add<T>(ref r, i + 1) = value;
+                    Unsafe.Add<T>(ref r, i + 2) = value;
+                    Unsafe.Add<T>(ref r, i + 3) = value;
+                    Unsafe.Add<T>(ref r, i + 4) = value;
+                    Unsafe.Add<T>(ref r, i + 5) = value;
+                    Unsafe.Add<T>(ref r, i + 6) = value;
+                    Unsafe.Add<T>(ref r, i + 7) = value;
+                }
+                if (i < (length & ~3))
+                {
+                    Unsafe.Add<T>(ref r, i + 0) = value;
+                    Unsafe.Add<T>(ref r, i + 1) = value;
+                    Unsafe.Add<T>(ref r, i + 2) = value;
+                    Unsafe.Add<T>(ref r, i + 3) = value;
+                    i += 4;
+                }
+                for (; i < length; i++)
+                {
+                    Unsafe.Add<T>(ref r, i) = value;
+                }
+            }
+        }
+
+        /// <summary>
         /// Copies the contents of this span into destination span. If the source
         /// and destinations overlap, this method behaves as if the original values in
         /// a temporary location before the destination is overwritten.
@@ -325,7 +390,7 @@ namespace System
         /// <exception cref="System.ArgumentOutOfRangeException">
         /// Thrown when the specified <paramref name="start"/> index is not in range (&lt;0 or &gt;=Length).
         /// </exception>
-        [MethodImpl(MethodImplOptions.NoOptimization)] // TODO-SPAN: Workaround for https://github.com/dotnet/coreclr/issues/7894
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Span<T> Slice(int start)
         {
             if ((uint)start > (uint)_length)
@@ -342,7 +407,7 @@ namespace System
         /// <exception cref="System.ArgumentOutOfRangeException">
         /// Thrown when the specified <paramref name="start"/> or end index is not in range (&lt;0 or &gt;=Length).
         /// </exception>
-        [MethodImpl(MethodImplOptions.NoOptimization)] // TODO-SPAN: Workaround for https://github.com/dotnet/coreclr/issues/7894
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Span<T> Slice(int start, int length)
         {
             if ((uint)start > (uint)_length || (uint)length > (uint)(_length - start))
@@ -356,6 +421,7 @@ namespace System
         /// allocates, so should generally be avoided, however it is sometimes
         /// necessary to bridge the gap with APIs written in terms of arrays.
         /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public T[] ToArray()
         {
             if (_length == 0)
@@ -372,7 +438,7 @@ namespace System
         public static Span<T> Empty => default(Span<T>);
     }
 
-    public static class SpanExtensions
+    public static class Span
     {
         /// <summary>
         /// Casts a Span of one primitive type <typeparamref name="T"/> to Span of bytes.
@@ -385,7 +451,7 @@ namespace System
         public static Span<byte> AsBytes<T>(this Span<T> source)
             where T : struct
         {
-            if (JitHelpers.ContainsReferences<T>())
+            if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
                 ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
 
             return new Span<byte>(
@@ -404,7 +470,7 @@ namespace System
         public static ReadOnlySpan<byte> AsBytes<T>(this ReadOnlySpan<T> source)
             where T : struct
         {
-            if (JitHelpers.ContainsReferences<T>())
+            if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
                 ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
 
             return new ReadOnlySpan<byte>(
@@ -427,9 +493,9 @@ namespace System
             where TFrom : struct
             where TTo : struct
         {
-            if (JitHelpers.ContainsReferences<TFrom>())
+            if (RuntimeHelpers.IsReferenceOrContainsReferences<TFrom>())
                 ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(TFrom));
-            if (JitHelpers.ContainsReferences<TTo>())
+            if (RuntimeHelpers.IsReferenceOrContainsReferences<TTo>())
                 ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(TTo));
 
             return new Span<TTo>(
@@ -452,15 +518,73 @@ namespace System
             where TFrom : struct
             where TTo : struct
         {
-            if (JitHelpers.ContainsReferences<TFrom>())
+            if (RuntimeHelpers.IsReferenceOrContainsReferences<TFrom>())
                 ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(TFrom));
-            if (JitHelpers.ContainsReferences<TTo>())
+            if (RuntimeHelpers.IsReferenceOrContainsReferences<TTo>())
                 ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(TTo));
 
             return new ReadOnlySpan<TTo>(
                 ref Unsafe.As<TFrom, TTo>(ref source.DangerousGetPinnableReference()),
                 checked((int)((long)source.Length * Unsafe.SizeOf<TFrom>() / Unsafe.SizeOf<TTo>())));
         }
+
+        /// <summary>
+        /// Creates a new readonly span over the portion of the target string.
+        /// </summary>
+        /// <param name="text">The target string.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown when <paramref name="text"/> is a null
+        /// reference (Nothing in Visual Basic).</exception>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ReadOnlySpan<char> Slice(this string text)
+        {
+            if (text == null)
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.text);
+
+            return new ReadOnlySpan<char>(ref text.GetFirstCharRef(), text.Length);
+        }
+
+        /// <summary>
+        /// Creates a new readonly span over the portion of the target string, beginning at 'start'.
+        /// </summary>
+        /// <param name="text">The target string.</param>
+        /// <param name="start">The index at which to begin this slice.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown when <paramref name="text"/> is a null
+        /// reference (Nothing in Visual Basic).</exception>
+        /// <exception cref="System.ArgumentOutOfRangeException">
+        /// Thrown when the specified <paramref name="start"/> index is not in range (&lt;0 or &gt;Length).
+        /// </exception>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ReadOnlySpan<char> Slice(this string text, int start)
+        {
+            if (text == null)
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.text);
+            if ((uint)start > (uint)text.Length)
+                ThrowHelper.ThrowArgumentOutOfRangeException();
+
+            return new ReadOnlySpan<char>(ref Unsafe.Add(ref text.GetFirstCharRef(), start), text.Length - start);
+        }
+
+        /// <summary>
+        /// Creates a new readonly span over the portion of the target string, beginning at <paramref name="start"/>, of given <paramref name="length"/>.
+        /// </summary>
+        /// <param name="text">The target string.</param>
+        /// <param name="start">The index at which to begin this slice.</param>
+        /// <param name="length">The number of items in the span.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown when <paramref name="text"/> is a null
+        /// reference (Nothing in Visual Basic).</exception>
+        /// <exception cref="System.ArgumentOutOfRangeException">
+        /// Thrown when the specified <paramref name="start"/> or end index is not in range (&lt;0 or &gt;&eq;Length).
+        /// </exception>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ReadOnlySpan<char> Slice(this string text, int start, int length)
+        {
+            if (text == null)
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.text);
+            if ((uint)start > (uint)text.Length || (uint)length > (uint)(text.Length - start))
+                ThrowHelper.ThrowArgumentOutOfRangeException();
+
+            return new ReadOnlySpan<char>(ref Unsafe.Add(ref text.GetFirstCharRef(), start), length);
+        }
     }
 
     internal static class SpanHelper
@@ -473,7 +597,7 @@ namespace System
             if (Unsafe.AreSame(ref destination, ref source))
                 return;
 
-            if (!JitHelpers.ContainsReferences<T>())
+            if (!RuntimeHelpers.IsReferenceOrContainsReferences<T>())
             {
                 fixed (byte* pDestination = &Unsafe.As<T, byte>(ref destination))
                 {
diff --git a/src/mscorlib/src/System/StackOverflowException.cs b/src/mscorlib/src/System/StackOverflowException.cs
index 4a20527f61..0a875e7373 100644
--- a/src/mscorlib/src/System/StackOverflowException.cs
+++ b/src/mscorlib/src/System/StackOverflowException.cs
@@ -11,30 +11,31 @@
 **
 =============================================================================*/
 
-namespace System {
-    
-    using System;
-    using System.Runtime.Serialization;
-    [System.Runtime.InteropServices.ComVisible(true)]
+using System.Runtime.Serialization;
+
+namespace System
+{
     [Serializable]
-    public sealed class StackOverflowException : SystemException {
-        public StackOverflowException() 
-            : base(Environment.GetResourceString("Arg_StackOverflowException")) {
-            SetErrorCode(__HResults.COR_E_STACKOVERFLOW);
-        }
-    
-        public StackOverflowException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_STACKOVERFLOW);
+    public sealed class StackOverflowException : SystemException
+    {
+        public StackOverflowException()
+            : base(SR.Arg_StackOverflowException)
+        {
+            HResult = __HResults.COR_E_STACKOVERFLOW;
         }
-        
-        public StackOverflowException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_STACKOVERFLOW);
+
+        public StackOverflowException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_STACKOVERFLOW;
         }
 
-        internal StackOverflowException(SerializationInfo info, StreamingContext context) : base (info, context) {
+        public StackOverflowException(String message, Exception innerException)
+            : base(message, innerException)
+        {
+            HResult = __HResults.COR_E_STACKOVERFLOW;
         }
-        
+
+        internal StackOverflowException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
 }
diff --git a/src/mscorlib/src/System/String.Comparison.cs b/src/mscorlib/src/System/String.Comparison.cs
index 07f2f9de22..2ac1d78997 100644
--- a/src/mscorlib/src/System/String.Comparison.cs
+++ b/src/mscorlib/src/System/String.Comparison.cs
@@ -73,7 +73,6 @@ namespace System
         // Search/Query methods
         //
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         private unsafe static bool EqualsHelper(String strA, String strB)
         {
             Contract.Requires(strA != null);
@@ -134,7 +133,6 @@ namespace System
             }
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         private unsafe static bool StartsWithOrdinalHelper(String str, String startsWith)
         {
             Contract.Requires(str != null);
@@ -716,7 +714,6 @@ namespace System
         }
 
         [Pure]
-        [ComVisible(false)]
         public Boolean EndsWith(String value, StringComparison comparisonType) {
             if( (Object)value == null) {
                 throw new ArgumentNullException(nameof(value));                                
@@ -793,7 +790,6 @@ namespace System
         }
 
         // Determines whether two strings match.
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public override bool Equals(Object obj)
         {
             if (this == null)                        // this is necessary to guard against reverse-pinvokes and
@@ -814,7 +810,6 @@ namespace System
 
         // Determines whether two strings match.
         [Pure]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public bool Equals(String value)
         {
             if (this == null)                        // this is necessary to guard against reverse-pinvokes and
@@ -984,7 +979,6 @@ namespace System
 
         // Gets a hash code for this string.  If strings A and B are such that A.Equals(B), then
         // they will return the same hash code.
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public override int GetHashCode()
         {
 #if FEATURE_RANDOMIZED_STRING_HASHING
@@ -999,12 +993,10 @@ namespace System
 
         // Gets a hash code for this string and this comparison. If strings A and B and comparition C are such
         // that String.Equals(A, B, C), then they will return the same hash code with this comparison C.
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public int GetHashCode(StringComparison comparisonType) => StringComparer.FromComparison(comparisonType).GetHashCode(this);
 
         // Use this if and only if you need the hashcode to not change across app domains (e.g. you have an app domain agile
         // hash table).
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         internal int GetLegacyNonRandomizedHashCode() {
             unsafe {
                 fixed (char* src = &m_firstChar) {
@@ -1069,7 +1061,6 @@ namespace System
         }
 
         [Pure]
-        [ComVisible(false)]
         public Boolean StartsWith(String value, StringComparison comparisonType) {
             if( (Object)value == null) {
                 throw new ArgumentNullException(nameof(value));                                
diff --git a/src/mscorlib/src/System/String.Manipulation.cs b/src/mscorlib/src/System/String.Manipulation.cs
index 7b51abfbcf..e06141d669 100644
--- a/src/mscorlib/src/System/String.Manipulation.cs
+++ b/src/mscorlib/src/System/String.Manipulation.cs
@@ -172,7 +172,6 @@ namespace System
             return result;
         }
 
-        [ComVisible(false)]
         public static string Concat<T>(IEnumerable<T> values)
         {
             if (values == null)
@@ -223,7 +222,6 @@ namespace System
         }
 
 
-        [ComVisible(false)]
         public static string Concat(IEnumerable<string> values)
         {
             if (values == null)
@@ -571,7 +569,6 @@ namespace System
             return Join(separator, value, 0, value.Length);
         }
 
-        [ComVisible(false)]
         public unsafe static string Join(string separator, params object[] values)
         {
             separator = separator ?? string.Empty;
@@ -582,7 +579,6 @@ namespace System
             }
         }
 
-        [ComVisible(false)]
         public unsafe static string Join<T>(string separator, IEnumerable<T> values)
         {
             separator = separator ?? string.Empty;
@@ -593,7 +589,6 @@ namespace System
             }
         }
 
-        [ComVisible(false)]
         public static string Join(string separator, IEnumerable<string> values)
         {
             if (values == null)
@@ -1039,16 +1034,14 @@ namespace System
             return ReplaceInternal(oldValue, newValue);
         }
 
-        [ComVisible(false)]
-        public String[] Split(char separator, StringSplitOptions options = StringSplitOptions.None) {
+        public unsafe String[] Split(char separator, StringSplitOptions options = StringSplitOptions.None) {
             Contract.Ensures(Contract.Result<String[]>() != null);
-            return SplitInternal(separator, Int32.MaxValue, options);
+            return SplitInternal(&separator, 1, int.MaxValue, options);
         }
 
-        [ComVisible(false)]
-        public String[] Split(char separator, int count, StringSplitOptions options = StringSplitOptions.None) {
+        public unsafe String[] Split(char separator, int count, StringSplitOptions options = StringSplitOptions.None) {
             Contract.Ensures(Contract.Result<String[]>() != null);
-            return SplitInternal(separator, count, options);
+            return SplitInternal(&separator, 1, count, options);
         }
 
         // Creates an array of strings by splitting this string at each
@@ -1081,24 +1074,17 @@ namespace System
             return SplitInternal(separator, count, StringSplitOptions.None);
         }
 
-        [ComVisible(false)]
         public String[] Split(char[] separator, StringSplitOptions options) {
             Contract.Ensures(Contract.Result<String[]>() != null);
             return SplitInternal(separator, Int32.MaxValue, options);
         }
 
-        [ComVisible(false)]
         public String[] Split(char[] separator, int count, StringSplitOptions options)
         {
             Contract.Ensures(Contract.Result<String[]>() != null);
             return SplitInternal(separator, count, options);
         }
 
-        private unsafe String[] SplitInternal(char separator, int count, StringSplitOptions options)
-        {
-            return SplitInternal(&separator, 1, count, options);
-        }
-
         private unsafe String[] SplitInternal(char[] separator, int count, StringSplitOptions options)
         {
             fixed (char* pSeparators = separator)
@@ -1149,25 +1135,21 @@ namespace System
             }
         }
 
-        [ComVisible(false)]
         public String[] Split(String separator, StringSplitOptions options = StringSplitOptions.None) {
             Contract.Ensures(Contract.Result<String[]>() != null);
             return SplitInternal(separator ?? String.Empty, null, Int32.MaxValue, options);
         }
 
-        [ComVisible(false)]
         public String[] Split(String separator, Int32 count, StringSplitOptions options = StringSplitOptions.None) {
             Contract.Ensures(Contract.Result<String[]>() != null);
             return SplitInternal(separator ?? String.Empty, null, count, options);
         }
 
-        [ComVisible(false)]
         public String [] Split(String[] separator, StringSplitOptions options) {
             Contract.Ensures(Contract.Result<String[]>() != null);
             return SplitInternal(null, separator, Int32.MaxValue, options);
         }
 
-        [ComVisible(false)]
         public String[] Split(String[] separator, Int32 count, StringSplitOptions options) {
             Contract.Ensures(Contract.Result<String[]>() != null);
             return SplitInternal(null, separator, count, options);
@@ -1556,7 +1538,7 @@ namespace System
             {
                 return TrimWhiteSpaceHelper(TrimType.Both);
             }
-            fixed (char* pTrimChars = trimChars)
+            fixed (char* pTrimChars = &trimChars[0])
             {
                 return TrimHelper(pTrimChars, trimChars.Length, TrimType.Both);
             }
@@ -1575,7 +1557,7 @@ namespace System
             {
                 return TrimWhiteSpaceHelper(TrimType.Head);
             }
-            fixed (char* pTrimChars = trimChars)
+            fixed (char* pTrimChars = &trimChars[0])
             {
                 return TrimHelper(pTrimChars, trimChars.Length, TrimType.Head);
             }
@@ -1594,7 +1576,7 @@ namespace System
             {
                 return TrimWhiteSpaceHelper(TrimType.Tail);
             }
-            fixed (char* pTrimChars = trimChars)
+            fixed (char* pTrimChars = &trimChars[0])
             {
                 return TrimHelper(pTrimChars, trimChars.Length, TrimType.Tail);
             }
diff --git a/src/mscorlib/src/System/String.cs b/src/mscorlib/src/System/String.cs
index 5a8e167b04..175e396633 100644
--- a/src/mscorlib/src/System/String.cs
+++ b/src/mscorlib/src/System/String.cs
@@ -37,7 +37,6 @@ namespace System {
     // implemented as a part of String.  As with arrays, character positions
     // (indices) are zero-based.
     
-    [ComVisible(true)]
     [Serializable]
     public sealed partial class String : IComparable, ICloneable, IConvertible, IEnumerable
         , IComparable<String>, IEnumerable<char>, IEquatable<String>
@@ -787,12 +786,14 @@ namespace System {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         internal extern bool IsAscii();
 
+#if FEATURE_COMINTEROP
         // Set extra byte for odd-sized strings that came from interop as BSTR.
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         internal extern void SetTrailByte(byte data);
         // Try to retrieve the extra byte - returns false if not present.
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         internal extern bool TryGetTrailByte(out byte data);
+#endif        
 
         public CharEnumerator GetEnumerator() {
             Contract.Ensures(Contract.Result<CharEnumerator>() != null);
diff --git a/src/mscorlib/src/System/StringComparer.cs b/src/mscorlib/src/System/StringComparer.cs
index 02e8d71d0e..cf65c48c2b 100644
--- a/src/mscorlib/src/System/StringComparer.cs
+++ b/src/mscorlib/src/System/StringComparer.cs
@@ -13,7 +13,6 @@ namespace System {
 
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public abstract class StringComparer : IComparer, IEqualityComparer, IComparer<string>, IEqualityComparer<string>{
         private static readonly StringComparer _invariantCulture = new CultureAwareComparer(CultureInfo.InvariantCulture, false);        
         private static readonly StringComparer _invariantCultureIgnoreCase = new CultureAwareComparer(CultureInfo.InvariantCulture, true);      
@@ -162,11 +161,6 @@ namespace System {
                _ignoreCase = ignoreCase;
         }
 
-        internal CultureAwareComparer(CompareInfo compareInfo, bool ignoreCase) {
-               _compareInfo = compareInfo;
-               _ignoreCase = ignoreCase;
-        }
-
         public override int Compare(string x, string y) {
             if (Object.ReferenceEquals(x, y)) return 0;
             if (x == null) return -1;
@@ -211,9 +205,6 @@ namespace System {
         }
 
 #if FEATURE_RANDOMIZED_STRING_HASHING           
-        IEqualityComparer IWellKnownStringEqualityComparer.GetRandomizedEqualityComparer() {
-            return new CultureAwareRandomizedComparer(_compareInfo, _ignoreCase);
-        }
 
         IEqualityComparer IWellKnownStringEqualityComparer.GetEqualityComparerForSerialization() {
             return this;
@@ -222,77 +213,6 @@ namespace System {
 
     }
 
-#if FEATURE_RANDOMIZED_STRING_HASHING
-    internal sealed class CultureAwareRandomizedComparer : StringComparer, IWellKnownStringEqualityComparer {
-
-        private CompareInfo _compareInfo;    
-        private bool        _ignoreCase;
-        private long        _entropy;
-
-        internal CultureAwareRandomizedComparer(CompareInfo compareInfo, bool ignoreCase) {
-               _compareInfo = compareInfo;
-               _ignoreCase = ignoreCase;
-               _entropy = HashHelpers.GetEntropy();
-        }
-
-        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, _ignoreCase? CompareOptions.IgnoreCase :  CompareOptions.None);
-        }
-                
-        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, _ignoreCase? CompareOptions.IgnoreCase :  CompareOptions.None) == 0);
-        }               
-                
-        public override int GetHashCode(string obj) {
-            if( obj == null) {
-                throw new ArgumentNullException(nameof(obj));
-            }
-            Contract.EndContractBlock();
-
-            CompareOptions options = CompareOptions.None;
-
-            if( _ignoreCase) {
-                options |= CompareOptions.IgnoreCase;
-            }
-
-#if FEATURE_COREFX_GLOBALIZATION
-            return _compareInfo.GetHashCodeOfStringCore(obj, options, true, _entropy);
-#else
-            return _compareInfo.GetHashCodeOfString(obj, options, true, _entropy);
-#endif
-        }       
-
-        // Equals method for the comparer itself. 
-        public override bool Equals(Object obj){
-            CultureAwareRandomizedComparer comparer = obj as CultureAwareRandomizedComparer;
-            if( comparer == null) {
-                return false;
-            }
-            return (this._ignoreCase == comparer._ignoreCase) && (this._compareInfo.Equals(comparer._compareInfo)) && (this._entropy == comparer._entropy);
-        }
-
-        public override int GetHashCode() {
-            int hashCode = _compareInfo.GetHashCode() ;
-            return ((_ignoreCase ? (~hashCode) : hashCode) ^ ((int) (_entropy & 0x7FFFFFFF)));
-        }
-
-        IEqualityComparer IWellKnownStringEqualityComparer.GetRandomizedEqualityComparer() {
-            return new CultureAwareRandomizedComparer(_compareInfo, _ignoreCase);
-        }
-
-        // We want to serialize the old comparer.
-        IEqualityComparer IWellKnownStringEqualityComparer.GetEqualityComparerForSerialization() {
-            return new CultureAwareComparer(_compareInfo, _ignoreCase);
-        }
-    }
-#endif
-
     // Provide x more optimal implementation of ordinal comparison.
     [Serializable]
     internal sealed class OrdinalComparer : StringComparer 
@@ -360,9 +280,6 @@ namespace System {
         }
 
 #if FEATURE_RANDOMIZED_STRING_HASHING           
-        IEqualityComparer IWellKnownStringEqualityComparer.GetRandomizedEqualityComparer() {
-            return new OrdinalRandomizedComparer(_ignoreCase);
-        }
 
         IEqualityComparer IWellKnownStringEqualityComparer.GetEqualityComparerForSerialization() {
             return this;
@@ -371,89 +288,11 @@ namespace System {
                                 
     }
 
-
 #if FEATURE_RANDOMIZED_STRING_HASHING           
-    internal sealed class OrdinalRandomizedComparer : StringComparer, IWellKnownStringEqualityComparer {
-        private bool            _ignoreCase;
-        private long            _entropy;
-       
-        internal OrdinalRandomizedComparer(bool ignoreCase) {
-               _ignoreCase = ignoreCase;
-               _entropy = HashHelpers.GetEntropy();
-        }
-
-        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;
-            
-            if( _ignoreCase) {
-                return String.Compare(x, y, StringComparison.OrdinalIgnoreCase);
-            }
-                    
-            return String.CompareOrdinal(x, y);                                
-        }
-                
-        public override bool Equals(string x, string y) {
-            if (Object.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) {
-                throw new ArgumentNullException(nameof(obj));
-            }
-            Contract.EndContractBlock();
-
-            if( _ignoreCase) {
-#if FEATURE_COREFX_GLOBALIZATION
-                return CultureInfo.InvariantCulture.CompareInfo.GetHashCodeOfStringCore(obj, CompareOptions.IgnoreCase, true, _entropy);
-#else
-                return TextInfo.GetHashCodeOrdinalIgnoreCase(obj, true, _entropy);
-#endif
-            }
-                        
-            return String.InternalMarvin32HashString(obj, obj.Length, _entropy);
-        }       
-
-        // Equals method for the comparer itself. 
-        public override bool Equals(Object obj){
-            OrdinalRandomizedComparer comparer = obj as OrdinalRandomizedComparer;
-            if( comparer == null) {
-                return false;
-            }
-            return (this._ignoreCase == comparer._ignoreCase) && (this._entropy == comparer._entropy);
-        }
-
-        public override int GetHashCode() {
-            string name = "OrdinalRandomizedComparer";
-            int hashCode = name.GetHashCode();
-            return ((_ignoreCase ? (~hashCode) : hashCode) ^ ((int) (_entropy & 0x7FFFFFFF)));
-        }
-
-        IEqualityComparer IWellKnownStringEqualityComparer.GetRandomizedEqualityComparer() {
-            return new OrdinalRandomizedComparer(_ignoreCase);
-        }
-
-        // We want to serialize the old comparer.
-        IEqualityComparer IWellKnownStringEqualityComparer.GetEqualityComparerForSerialization() {
-            return new OrdinalComparer(_ignoreCase);
-        }                                
-    }
 
     // This interface is implemented by string comparers in the framework that can opt into
     // randomized hashing behaviors. 
     internal interface IWellKnownStringEqualityComparer {
-        // Get an IEqualityComparer that has the same equality comparision rules as "this" but uses Randomized Hashing.
-        IEqualityComparer GetRandomizedEqualityComparer();
         // Get an IEqaulityComparer that can be serailzied (e.g., it exists in older versions). 
         IEqualityComparer GetEqualityComparerForSerialization();
     }
diff --git a/src/mscorlib/src/System/StringComparison.cs b/src/mscorlib/src/System/StringComparison.cs
index aa83e396b6..c654f7200f 100644
--- a/src/mscorlib/src/System/StringComparison.cs
+++ b/src/mscorlib/src/System/StringComparison.cs
@@ -13,11 +13,12 @@
 **
 ** 
 ===========================================================*/
-namespace System{
-    
+
+namespace System
+{
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public enum StringComparison {
+    public enum StringComparison
+    {
         CurrentCulture = 0,
         CurrentCultureIgnoreCase = 1,
         InvariantCulture = 2,
diff --git a/src/mscorlib/src/System/StringSplitOptions.cs b/src/mscorlib/src/System/StringSplitOptions.cs
index ae95aae9f8..43b626a010 100644
--- a/src/mscorlib/src/System/StringSplitOptions.cs
+++ b/src/mscorlib/src/System/StringSplitOptions.cs
@@ -2,15 +2,12 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System.Runtime.InteropServices;
-
 namespace System
 {
-    [ComVisible(false)]
     [Flags]
     public enum StringSplitOptions
     {
         None = 0,
         RemoveEmptyEntries = 1
     }
-}
+}
\ No newline at end of file
diff --git a/src/mscorlib/src/System/StubHelpers.cs b/src/mscorlib/src/System/StubHelpers.cs
index 26a227628a..2d5926b923 100644
--- a/src/mscorlib/src/System/StubHelpers.cs
+++ b/src/mscorlib/src/System/StubHelpers.cs
@@ -19,7 +19,6 @@ namespace  System.StubHelpers {
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class AnsiCharMarshaler
     {
         // The length of the returned array is an approximation based on the length of the input string and the system
@@ -27,7 +26,8 @@ namespace  System.StubHelpers {
         unsafe static internal byte[] DoAnsiConversion(string str, bool fBestFit, bool fThrowOnUnmappableChar, out int cbLength)
         {
             byte[] buffer = new byte[(str.Length + 1) * Marshal.SystemMaxDBCSCharSize];
-            fixed (byte *bufferPtr = buffer)
+            BCLDebug.Assert(buffer.Length != 0);
+            fixed (byte *bufferPtr = &buffer[0])
             {
                 cbLength = str.ConvertToAnsi(bufferPtr, buffer.Length, fBestFit, fThrowOnUnmappableChar);
             }
@@ -53,7 +53,6 @@ namespace  System.StubHelpers {
         }
     }  // class AnsiCharMarshaler
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class CSTRMarshaler
     {
         static internal unsafe IntPtr ConvertToNative(int flags, string strManaged, IntPtr pNativeBuffer)
@@ -121,7 +120,6 @@ namespace  System.StubHelpers {
         }
     }  // class CSTRMarshaler
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class UTF8Marshaler
     {
         const int MAX_UTF8_CHAR_SIZE = 3;
@@ -178,7 +176,6 @@ namespace  System.StubHelpers {
         }
     }
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class UTF8BufferMarshaler
     {
         static internal unsafe IntPtr ConvertToNative(StringBuilder sb, IntPtr pNativeBuffer, int flags)
@@ -218,7 +215,7 @@ namespace  System.StubHelpers {
             // null argument.
             char[] cCharBuffer = new char[numChar + 1];
             cCharBuffer[numChar] = '\0';
-            fixed (char* pBuffer = cCharBuffer)
+            fixed (char* pBuffer = &cCharBuffer[0])
             {
                 numChar = Encoding.UTF8.GetChars((byte*)pNative, nbBytes, pBuffer, numChar);
                 // replace string builder internal buffer
@@ -229,7 +226,6 @@ namespace  System.StubHelpers {
 
 #if FEATURE_COMINTEROP
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class BSTRMarshaler
     {
         static internal unsafe IntPtr ConvertToNative(string strManaged, IntPtr pNativeBuffer)
@@ -357,7 +353,6 @@ namespace  System.StubHelpers {
 #endif // FEATURE_COMINTEROP
 
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class VBByValStrMarshaler
     {
         static internal unsafe IntPtr ConvertToNative(string strManaged, bool fBestFit, bool fThrowOnUnmappableChar, ref int cch)
@@ -423,7 +418,6 @@ namespace  System.StubHelpers {
 
 #if FEATURE_COMINTEROP
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class AnsiBSTRMarshaler
     {
         static internal unsafe IntPtr ConvertToNative(int flags, string strManaged)
@@ -475,7 +469,6 @@ namespace  System.StubHelpers {
 #endif // FEATURE_COMINTEROP
 
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class WSTRBufferMarshaler
     {
         static internal IntPtr ConvertToNative(string strManaged)
@@ -506,7 +499,6 @@ namespace  System.StubHelpers {
         public Int64 UniversalTime;
     };
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class DateTimeOffsetMarshaler {
 
         // Numer of ticks counted between 0001-01-01, 00:00:00 and 1601-01-01, 00:00:00.
@@ -534,7 +526,6 @@ namespace  System.StubHelpers {
 
 
 #if FEATURE_COMINTEROP
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class HStringMarshaler
     {
         // Slow-path, which requires making a copy of the managed string into the resulting HSTRING
@@ -597,7 +588,6 @@ namespace  System.StubHelpers {
         }
     }  // class HStringMarshaler
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class ObjectMarshaler
     {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
@@ -612,7 +602,6 @@ namespace  System.StubHelpers {
 
 #endif // FEATURE_COMINTEROP
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class ValueClassMarshaler
     {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
@@ -625,7 +614,6 @@ namespace  System.StubHelpers {
         static internal extern void ClearNative(IntPtr dst, IntPtr pMT);
     }  // class ValueClassMarshaler
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class DateMarshaler
     {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
@@ -637,7 +625,6 @@ namespace  System.StubHelpers {
     }  // class DateMarshaler
 
 #if FEATURE_COMINTEROP
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     [FriendAccessAllowed]
     internal static class InterfaceMarshaler
     {
@@ -657,7 +644,6 @@ namespace  System.StubHelpers {
 #endif // FEATURE_COMINTEROP
 
 #if FEATURE_COMINTEROP
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class UriMarshaler
     {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
@@ -713,7 +699,6 @@ namespace  System.StubHelpers {
     }
 #endif // FEATURE_COMINTEROP
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class MngdNativeArrayMarshaler
     {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
@@ -740,7 +725,6 @@ namespace  System.StubHelpers {
     }  // class MngdNativeArrayMarshaler
 
 #if FEATURE_COMINTEROP
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class MngdSafeArrayMarshaler
     {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
@@ -762,7 +746,6 @@ namespace  System.StubHelpers {
         static internal extern void ClearNative(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);
     }  // class MngdSafeArrayMarshaler
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class MngdHiddenLengthArrayMarshaler
     {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
@@ -923,7 +906,6 @@ namespace  System.StubHelpers {
 
 #endif // FEATURE_COMINTEROP
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class MngdRefCustomMarshaler
     {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
@@ -942,7 +924,6 @@ namespace  System.StubHelpers {
         static internal extern void ClearManaged(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);
     }  // class MngdRefCustomMarshaler
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal struct AsAnyMarshaler
     {
         private const ushort VTHACK_ANSICHAR = 253;
@@ -1282,7 +1263,6 @@ namespace  System.StubHelpers {
     }  // struct AsAnyMarshaler
 
 #if FEATURE_COMINTEROP
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class NullableMarshaler
     {    
         static internal IntPtr ConvertToNative<T>(ref Nullable<T> pManaged) where T : struct
@@ -1344,7 +1324,6 @@ namespace  System.StubHelpers {
         internal static extern System.Type GetTypeFromWinRTTypeName(string typeName, out bool isPrimitive);
     }
     
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class SystemTypeMarshaler
     {   
         internal static unsafe void ConvertToNative(System.Type managedType, TypeNameNative *pNativeType)
@@ -1431,7 +1410,6 @@ namespace  System.StubHelpers {
     }  // class SystemTypeMarshaler
 
     // For converting WinRT's Windows.Foundation.HResult into System.Exception and vice versa.
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class HResultExceptionMarshaler
     {
         static internal unsafe int ConvertToNative(Exception ex)
@@ -1469,7 +1447,6 @@ namespace  System.StubHelpers {
         }
     }  // class HResultExceptionMarshaler
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal static class KeyValuePairMarshaler
     {    
         internal static IntPtr ConvertToNative<K, V>([In] ref KeyValuePair<K, V> pair)
@@ -1534,7 +1511,6 @@ namespace  System.StubHelpers {
         public bool m_owned;
     }  // class CleanupWorkListElement
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     internal sealed class CleanupWorkList
     {
         private List<CleanupWorkListElement> m_list = new List<CleanupWorkListElement>();
@@ -1545,7 +1521,6 @@ namespace  System.StubHelpers {
             m_list.Add(elem);
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public void Destroy()
         {
             for (int i = m_list.Count - 1; i >= 0; i--)
@@ -1556,7 +1531,6 @@ namespace  System.StubHelpers {
         }
     }  // class CleanupWorkList
 
-    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
     [SuppressUnmanagedCodeSecurityAttribute()]
     internal static class StubHelpers
     {
@@ -1593,7 +1567,6 @@ namespace  System.StubHelpers {
             return SafeHandleAddRef(handle, ref element.m_owned);
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         static internal void DestroyCleanupList(ref CleanupWorkList pCleanupWorkList)
         {
             if (pCleanupWorkList != null)
@@ -1655,7 +1628,6 @@ namespace  System.StubHelpers {
         }
 
         // Releases the SH (to be called from finally block).
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         static internal void SafeHandleRelease(SafeHandle pHandle)
         {
             if (pHandle == null)
diff --git a/src/mscorlib/src/System/SystemException.cs b/src/mscorlib/src/System/SystemException.cs
index 8a54124e3e..f4779a2cd4 100644
--- a/src/mscorlib/src/System/SystemException.cs
+++ b/src/mscorlib/src/System/SystemException.cs
@@ -2,30 +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.
 
-namespace System {
- 
-    using System;
-    using System.Runtime.Serialization;
+using System.Runtime.Serialization;
+
+namespace System
+{
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class SystemException : Exception
     {
-        public SystemException() 
-            : base(Environment.GetResourceString("Arg_SystemException")) {
-            SetErrorCode(__HResults.COR_E_SYSTEM);
-        }
-        
-        public SystemException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_SYSTEM);
+        public SystemException()
+            : base(SR.Arg_SystemException)
+        {
+            HResult = __HResults.COR_E_SYSTEM;
         }
-        
-        public SystemException(String message, Exception innerException) 
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_SYSTEM);
+
+        public SystemException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_SYSTEM;
         }
 
-        protected SystemException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public SystemException(String message, Exception innerException)
+            : base(message, innerException)
+        {
+            HResult = __HResults.COR_E_SYSTEM;
         }
+
+        protected SystemException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
 }
diff --git a/src/mscorlib/src/System/Text/ASCIIEncoding.cs b/src/mscorlib/src/System/Text/ASCIIEncoding.cs
index fc7589f2d8..07b7f3e890 100644
--- a/src/mscorlib/src/System/Text/ASCIIEncoding.cs
+++ b/src/mscorlib/src/System/Text/ASCIIEncoding.cs
@@ -6,7 +6,6 @@ namespace System.Text
 {
     using System;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
 
@@ -22,7 +21,6 @@ namespace System.Text
     //
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public class ASCIIEncoding : Encoding
     {
         // Used by Encoding.ASCII for lazy initialization
@@ -72,7 +70,6 @@ namespace System.Text
         }
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override unsafe int GetByteCount(char* chars, int count)
         {
             return EncodingForwarder.GetByteCount(this, chars, count);
@@ -100,7 +97,6 @@ namespace System.Text
         }
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override unsafe int GetBytes(char* chars, int charCount, byte* bytes, int byteCount)
         {
             return EncodingForwarder.GetBytes(this, chars, charCount, bytes, byteCount);
@@ -115,7 +111,6 @@ namespace System.Text
         }
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override unsafe int GetCharCount(byte* bytes, int count)
         {
             return EncodingForwarder.GetCharCount(this, bytes, count);
@@ -128,7 +123,6 @@ namespace System.Text
         }
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
         {
             return EncodingForwarder.GetChars(this, bytes, byteCount, chars, charCount);
@@ -741,7 +735,6 @@ namespace System.Text
 
         // True if and only if the encoding only uses single byte code points.  (Ie, ASCII, 1252, etc)
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override bool IsSingleByte
         {
             get
@@ -750,14 +743,12 @@ namespace System.Text
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override Decoder GetDecoder()
         {
             return new DecoderNLS(this);
         }
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override Encoder GetEncoder()
         {
             return new EncoderNLS(this);
diff --git a/src/mscorlib/src/System/Text/CodePageEncoding.cs b/src/mscorlib/src/System/Text/CodePageEncoding.cs
deleted file mode 100644
index 7805c6580a..0000000000
--- a/src/mscorlib/src/System/Text/CodePageEncoding.cs
+++ /dev/null
@@ -1,136 +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.
-
-
-// WARNING:
-//
-// This is just an IObjectReference proxy for the Code Page Encodings.
-namespace System.Text
-{
-    using System;
-    using System.Runtime.Serialization;
-    using System.Security.Permissions;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-
-    /*=================================CodePageEncoding==================================
-    ** This class is here only to deserialize the Code Page classes from Everett (V1.1) into
-    ** Appropriate Whidbey (V2.0) objects.  We also serialize the Whidbey classes
-    ** using this proxy since we pretty much need one anyway and that solves Whidbey
-    ** to Everett compatibility as well.
-    ==============================================================================*/
-
-    [Serializable]
-    internal sealed class CodePageEncoding : IObjectReference, ISerializable
-    {
-        // Temp stuff
-        [NonSerialized]
-        private int m_codePage;
-        [NonSerialized]
-        private bool m_isReadOnly;
-        [NonSerialized]
-        private bool m_deserializedFromEverett = false;
-
-        [NonSerialized]
-        private EncoderFallback encoderFallback = null;
-        [NonSerialized]
-        private DecoderFallback decoderFallback = null;
-
-        // Might need this when GetRealObjecting
-        [NonSerialized]
-        private Encoding realEncoding = null;
-
-        // Constructor called by serialization.
-        internal CodePageEncoding(SerializationInfo info, StreamingContext context)
-        {
-            // Any info?
-            if (info==null) throw new ArgumentNullException(nameof(info));
-            Contract.EndContractBlock();
-
-            // All versions have a code page
-            this.m_codePage = (int)info.GetValue("m_codePage", typeof(int));
-
-            // See if we have a code page
-            try
-            {
-                //
-                // Try Whidbey V2.0 Fields
-                //
-                this.m_isReadOnly = (bool)info.GetValue("m_isReadOnly", typeof(bool));
-
-                this.encoderFallback = (EncoderFallback)info.GetValue("encoderFallback", typeof(EncoderFallback));
-                this.decoderFallback = (DecoderFallback)info.GetValue("decoderFallback", typeof(DecoderFallback));
-            }
-            catch (SerializationException)
-            {
-                //
-                // Didn't have Whidbey things, must be Everett
-                //
-                this.m_deserializedFromEverett = true;
-
-                // May as well be read only
-                this.m_isReadOnly = true;
-            }
-        }
-
-        // Just get it from GetEncoding
-        public Object GetRealObject(StreamingContext context)
-        {
-            // Get our encoding (Note: This has default fallbacks for readonly and everett cases)
-            this.realEncoding = Encoding.GetEncoding(this.m_codePage);
-
-            // If its read only then it uses default fallbacks, otherwise pick up the new ones
-            // Otherwise we want to leave the new one read only
-            if (!this.m_deserializedFromEverett && !this.m_isReadOnly)
-            {
-                this.realEncoding = (Encoding)this.realEncoding.Clone();
-                this.realEncoding.EncoderFallback = this.encoderFallback;
-                this.realEncoding.DecoderFallback = this.decoderFallback;
-            }
-
-            return this.realEncoding;
-        }
-
-        // ISerializable implementation
-        void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
-        {
-            // We cannot ever call this.
-            Debug.Assert(false, "Didn't expect to make it to CodePageEncoding ISerializable.GetObjectData");
-            throw new ArgumentException(Environment.GetResourceString("Arg_ExecutionEngineException"));
-        }
-
-        // Same problem with the Decoder, this only happens with Everett Decoders
-        [Serializable]
-        internal sealed class Decoder : IObjectReference, ISerializable
-        {
-            // Might need this when GetRealObjecting
-            [NonSerialized]
-            private Encoding realEncoding = null;
-
-            // Constructor called by serialization, have to handle deserializing from Everett
-            internal Decoder(SerializationInfo info, StreamingContext context)
-            {
-                // Any info?
-                if (info==null) throw new ArgumentNullException(nameof(info));
-                Contract.EndContractBlock();
-
-                this.realEncoding = (Encoding)info.GetValue("encoding", typeof(Encoding));
-            }
-
-            // Just get it from GetDecider
-            public Object GetRealObject(StreamingContext context)
-            {
-                return this.realEncoding.GetDecoder();
-            }
-
-            // ISerializable implementation, get data for this object
-            void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
-            {
-                // We cannot ever call this.
-                Debug.Assert(false, "Didn't expect to make it to CodePageEncoding.Decoder.GetObjectData");
-                throw new ArgumentException(Environment.GetResourceString("Arg_ExecutionEngineException"));
-            }
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Text/Decoder.cs b/src/mscorlib/src/System/Text/Decoder.cs
index 0ebbacddcf..a9fea82a39 100644
--- a/src/mscorlib/src/System/Text/Decoder.cs
+++ b/src/mscorlib/src/System/Text/Decoder.cs
@@ -20,7 +20,6 @@ namespace System.Text
     // class are typically obtained through calls to the GetDecoder method
     // of Encoding objects.
     //
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public abstract class Decoder
     {
@@ -39,7 +38,6 @@ namespace System.Text
             // We don't call default reset because default reset probably isn't good if we aren't initialized.
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public DecoderFallback Fallback
         {
             get
@@ -65,7 +63,6 @@ namespace System.Text
 
         // Note: we don't test for threading here because async access to Encoders and Decoders
         // doesn't work anyway.
-        [System.Runtime.InteropServices.ComVisible(false)]
         public DecoderFallbackBuffer FallbackBuffer
         {
             get
@@ -99,7 +96,6 @@ namespace System.Text
         //
         // Virtual implimentation has to call GetChars with flush and a big enough buffer to clear a 0 byte string
         // We avoid GetMaxCharCount() because a) we can't call the base encoder and b) it might be really big.
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual void Reset()
         {
             byte[] byteTemp = Array.Empty<byte>();
@@ -117,7 +113,6 @@ namespace System.Text
         //
         public abstract int GetCharCount(byte[] bytes, int index, int count);
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual int GetCharCount(byte[] bytes, int index, int count, bool flush)
         {
             return GetCharCount(bytes, index, count);
@@ -126,7 +121,6 @@ namespace System.Text
         // We expect this to be the workhorse for NLS Encodings, but for existing
         // ones we need a working (if slow) default implimentation)
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual unsafe int GetCharCount(byte* bytes, int count, bool flush)
         {
             // Validate input parameters
@@ -190,7 +184,6 @@ namespace System.Text
         // could easily overflow our output buffer.  Therefore we do an extra test
         // when we copy the buffer so that we don't overflow charCount either.
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual unsafe int GetChars(byte* bytes, int byteCount,
                                               char* chars, int charCount, bool flush)
         {
@@ -248,7 +241,6 @@ namespace System.Text
         // Note that if all of the input bytes are not consumed, then we'll do a /2, which means
         // that its likely that we didn't consume as many bytes as we could have.  For some
         // applications this could be slow.  (Like trying to exactly fill an output buffer from a bigger stream)
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual void Convert(byte[] bytes, int byteIndex, int byteCount,
                                       char[] chars, int charIndex, int charCount, bool flush,
                                       out int bytesUsed, out int charsUsed, out bool completed)
@@ -306,7 +298,6 @@ namespace System.Text
         // that its likely that we didn't consume as many bytes as we could have.  For some
         // applications this could be slow.  (Like trying to exactly fill an output buffer from a bigger stream)
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual unsafe void Convert(byte* bytes, int byteCount,
                                              char* chars, int charCount, bool flush,
                                              out int bytesUsed, out int charsUsed, out bool completed)
diff --git a/src/mscorlib/src/System/Text/DecoderFallback.cs b/src/mscorlib/src/System/Text/DecoderFallback.cs
index 42483a724d..bfd4a2852d 100644
--- a/src/mscorlib/src/System/Text/DecoderFallback.cs
+++ b/src/mscorlib/src/System/Text/DecoderFallback.cs
@@ -75,14 +75,6 @@ namespace System.Text
         // Maximum number of characters that this instance of this fallback could return
 
         public abstract int MaxCharCount { get; }
-
-        internal bool IsMicrosoftBestFitFallback
-        {
-            get
-            {
-                return bIsMicrosoftBestFitFallback;
-            }
-        }
     }
 
 
diff --git a/src/mscorlib/src/System/Text/DecoderNLS.cs b/src/mscorlib/src/System/Text/DecoderNLS.cs
index e44c43adef..79474f8d8c 100644
--- a/src/mscorlib/src/System/Text/DecoderNLS.cs
+++ b/src/mscorlib/src/System/Text/DecoderNLS.cs
@@ -5,7 +5,6 @@
 namespace System.Text
 {
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     using System.Text;
     using System;
     using System.Diagnostics.Contracts;
@@ -98,7 +97,7 @@ namespace System.Text
                 bytes = new byte[1];
 
             // Just call pointer version
-            fixed (byte* pBytes = bytes)
+            fixed (byte* pBytes = &bytes[0])
                 return GetCharCount(pBytes + index, count, flush);
         }
 
@@ -159,8 +158,8 @@ namespace System.Text
                 chars = new char[1];
 
             // Just call pointer version
-            fixed (byte* pBytes = bytes)
-                fixed (char* pChars = chars)
+            fixed (byte* pBytes = &bytes[0])
+                fixed (char* pChars = &chars[0])
                     // Remember that charCount is # to decode, not size of array
                     return GetChars(pBytes + byteIndex, byteCount,
                                     pChars + charIndex, charCount, flush);
@@ -223,9 +222,9 @@ namespace System.Text
                 chars = new char[1];
 
             // Just call the pointer version (public overrides can't do this)
-            fixed (byte* pBytes = bytes)
+            fixed (byte* pBytes = &bytes[0])
             {
-                fixed (char* pChars = chars)
+                fixed (char* pChars = &chars[0])
                 {
                     Convert(pBytes + byteIndex, byteCount, pChars + charIndex, charCount, flush,
                         out bytesUsed, out charsUsed, out completed);
diff --git a/src/mscorlib/src/System/Text/Encoder.cs b/src/mscorlib/src/System/Text/Encoder.cs
index b9d4581276..f766f98142 100644
--- a/src/mscorlib/src/System/Text/Encoder.cs
+++ b/src/mscorlib/src/System/Text/Encoder.cs
@@ -20,7 +20,6 @@ namespace System.Text
     // class are typically obtained through calls to the GetEncoder method
     // of Encoding objects.
     //
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public abstract class Encoder
     {
@@ -39,7 +38,6 @@ namespace System.Text
             // We don't call default reset because default reset probably isn't good if we aren't initialized.
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public EncoderFallback Fallback
         {
             get
@@ -65,7 +63,6 @@ namespace System.Text
 
         // Note: we don't test for threading here because async access to Encoders and Decoders
         // doesn't work anyway.
-        [System.Runtime.InteropServices.ComVisible(false)]
         public EncoderFallbackBuffer FallbackBuffer
         {
             get
@@ -99,7 +96,6 @@ namespace System.Text
         //
         // Virtual implimentation has to call GetBytes with flush and a big enough buffer to clear a 0 char string
         // We avoid GetMaxByteCount() because a) we can't call the base encoder and b) it might be really big.
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual void Reset()
         {
             char[] charTemp = {};
@@ -122,7 +118,6 @@ namespace System.Text
         // unfortunately for existing overrides, it has to call the [] version,
         // which is really slow, so avoid this method if you might be calling external encodings.
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual unsafe int GetByteCount(char* chars, int count, bool flush)
         {
             // Validate input parameters
@@ -183,7 +178,6 @@ namespace System.Text
         // could easily overflow our output buffer.  Therefore we do an extra test
         // when we copy the buffer so that we don't overflow byteCount either.
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual unsafe int GetBytes(char* chars, int charCount,
                                               byte* bytes, int byteCount, bool flush)
         {
@@ -240,7 +234,6 @@ namespace System.Text
         // Note that if all of the input chars are not consumed, then we'll do a /2, which means
         // that its likely that we didn't consume as many chars as we could have.  For some
         // applications this could be slow.  (Like trying to exactly fill an output buffer from a bigger stream)
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual void Convert(char[] chars, int charIndex, int charCount,
                                       byte[] bytes, int byteIndex, int byteCount, bool flush,
                                       out int charsUsed, out int bytesUsed, out bool completed)
@@ -299,7 +292,6 @@ namespace System.Text
         // that its likely that we didn't consume as many chars as we could have.  For some
         // applications this could be slow.  (Like trying to exactly fill an output buffer from a bigger stream)
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual unsafe void Convert(char* chars, int charCount,
                                              byte* bytes, int byteCount, bool flush,
                                              out int charsUsed, out int bytesUsed, out bool completed)
diff --git a/src/mscorlib/src/System/Text/EncoderNLS.cs b/src/mscorlib/src/System/Text/EncoderNLS.cs
index 2add017d68..95901e01f4 100644
--- a/src/mscorlib/src/System/Text/EncoderNLS.cs
+++ b/src/mscorlib/src/System/Text/EncoderNLS.cs
@@ -5,7 +5,6 @@
 namespace System.Text
 {
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     using System.Text;
     using System;
     using System.Diagnostics.Contracts;
@@ -98,7 +97,7 @@ namespace System.Text
 
             // Just call the pointer version
             int result = -1;
-            fixed (char* pChars = chars)
+            fixed (char* pChars = &chars[0])
             {
                 result = GetByteCount(pChars + index, count, flush);
             }
@@ -151,8 +150,8 @@ namespace System.Text
                 bytes = new byte[1];
 
             // Just call pointer version
-            fixed (char* pChars = chars)
-                fixed (byte* pBytes = bytes)
+            fixed (char* pChars = &chars[0])
+                fixed (byte* pBytes = &bytes[0])
 
                     // Remember that charCount is # to decode, not size of array.
                     return GetBytes(pChars + charIndex, charCount,
@@ -212,9 +211,9 @@ namespace System.Text
                 bytes = new byte[1];
 
             // Just call the pointer version (can't do this for non-msft encoders)
-            fixed (char* pChars = chars)
+            fixed (char* pChars = &chars[0])
             {
-                fixed (byte* pBytes = bytes)
+                fixed (byte* pBytes = &bytes[0])
                 {
                     Convert(pChars + charIndex, charCount, pBytes + byteIndex, byteCount, flush,
                         out charsUsed, out bytesUsed, out completed);
diff --git a/src/mscorlib/src/System/Text/Encoding.cs b/src/mscorlib/src/System/Text/Encoding.cs
index dece2e9e71..8cb01e41fa 100644
--- a/src/mscorlib/src/System/Text/Encoding.cs
+++ b/src/mscorlib/src/System/Text/Encoding.cs
@@ -12,7 +12,6 @@ namespace System.Text
     using System.Runtime.Serialization;
     using System.Globalization;
     using System.Security;
-    using System.Security.Permissions;
     using System.Threading;
     using System.Text;
     using System.Diagnostics;
@@ -83,7 +82,6 @@ namespace System.Text
     // generally executes faster.
     //
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public abstract class Encoding : ICloneable
     {
@@ -627,7 +625,6 @@ namespace System.Text
 
         // True if and only if the encoding only uses single byte code points.  (Ie, ASCII, 1252, etc)
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual bool IsSingleByte
         {
             get
@@ -637,7 +634,6 @@ namespace System.Text
         }
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public EncoderFallback EncoderFallback
         {
             get
@@ -659,7 +655,6 @@ namespace System.Text
         }
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public DecoderFallback DecoderFallback
         {
             get
@@ -681,7 +676,6 @@ namespace System.Text
         }
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual Object Clone()
         {
             Encoding newEncoding = (Encoding)this.MemberwiseClone();
@@ -692,7 +686,6 @@ namespace System.Text
         }
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public bool IsReadOnly
         {
             get
@@ -781,7 +774,6 @@ namespace System.Text
         // a 3rd party encoding.
         [Pure]
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual unsafe int GetByteCount(char* chars, int count)
         {
             // Validate input parameters
@@ -943,7 +935,6 @@ namespace System.Text
         // when we copy the buffer so that we don't overflow byteCount either.
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual unsafe int GetBytes(char* chars, int charCount,
                                               byte* bytes, int byteCount)
         {
@@ -1012,7 +1003,6 @@ namespace System.Text
         // ones we need a working (if slow) default implimentation)
         [Pure]
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual unsafe int GetCharCount(byte* bytes, int count)
         {
             // Validate input parameters
@@ -1099,7 +1089,6 @@ namespace System.Text
         // when we copy the buffer so that we don't overflow charCount either.
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual unsafe int GetChars(byte* bytes, int byteCount,
                                               char* chars, int charCount)
         {
@@ -1154,7 +1143,6 @@ namespace System.Text
 
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public unsafe string GetString(byte* bytes, int byteCount)
         {
             if (bytes == null)
@@ -1183,14 +1171,12 @@ namespace System.Text
         // IsAlwaysNormalized
         // Returns true if the encoding is always normalized for the specified encoding form
         [Pure]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public bool IsAlwaysNormalized()
         {
             return this.IsAlwaysNormalized(NormalizationForm.FormC);
         }
 
         [Pure]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public virtual bool IsAlwaysNormalized(NormalizationForm form)
         {
             // Assume false unless the encoding knows otherwise
@@ -1728,20 +1714,6 @@ namespace System.Text
                 return AddChar(ch,1);
             }
 
-
-            internal unsafe bool AddChar(char ch1, char ch2, int numBytes)
-            {
-                // Need room for 2 chars
-                if (chars >= charEnd - 1)
-                {
-                    // Throw maybe
-                    bytes-=numBytes;                                        // Didn't encode these bytes
-                    enc.ThrowCharsOverflow(decoder, bytes <= byteStart);    // Throw?
-                    return false;                                           // No throw, but no store either
-                }
-                return AddChar(ch1, numBytes) && AddChar(ch2, numBytes);
-            }
-
             internal unsafe void AdjustBytes(int count)
             {
                 bytes += count;
@@ -1755,12 +1727,6 @@ namespace System.Text
                 }
             }
 
-            // Do we have count more bytes?
-            internal unsafe bool EvenMoreData(int count)
-            {
-                return (bytes <= byteEnd - count);
-            }
-
             // GetNextByte shouldn't be called unless the caller's already checked more data or even more data,
             // but we'll double check just to make sure.
             internal unsafe byte GetNextByte()
@@ -1788,24 +1754,6 @@ namespace System.Text
                 return Fallback(byteBuffer);
             }
 
-            internal unsafe bool Fallback(byte byte1, byte byte2)
-            {
-                // Build our buffer
-                byte[] byteBuffer = new byte[] { byte1, byte2 };
-
-                // Do the fallback and add the data.
-                return Fallback(byteBuffer);
-            }
-
-            internal unsafe bool Fallback(byte byte1, byte byte2, byte byte3, byte byte4)
-            {
-                // Build our buffer
-                byte[] byteBuffer = new byte[] { byte1, byte2, byte3, byte4 };
-
-                // Do the fallback and add the data.
-                return Fallback(byteBuffer);
-            }
-
             internal unsafe bool Fallback(byte[] byteBuffer)
             {
                 // Do the fallback and add the data.
@@ -1913,26 +1861,6 @@ namespace System.Text
                 return (AddByte(b1, 1 + moreBytesExpected) && AddByte(b2, moreBytesExpected));
             }
 
-            internal unsafe bool AddByte(byte b1, byte b2, byte b3)
-            {
-                return AddByte(b1, b2, b3, (int)0);
-            }
-
-            internal unsafe bool AddByte(byte b1, byte b2, byte b3, int moreBytesExpected)
-            {
-                return (AddByte(b1, 2 + moreBytesExpected) &&
-                        AddByte(b2, 1 + moreBytesExpected) &&
-                        AddByte(b3, moreBytesExpected));
-            }
-
-            internal unsafe bool AddByte(byte b1, byte b2, byte b3, byte b4)
-            {
-                return (AddByte(b1, 3) &&
-                        AddByte(b2, 2) &&
-                        AddByte(b3, 1) &&
-                        AddByte(b4, 0));
-            }
-
             internal unsafe void MovePrevious(bool bThrow)
             {
                 if (fallbackBuffer.bFallingBack)
@@ -1950,12 +1878,6 @@ namespace System.Text
                     enc.ThrowBytesOverflow(encoder, bytes == byteStart);    // Throw? (and reset fallback if not converting)
             }
 
-            internal unsafe bool Fallback(char charFallback)
-            {
-                // Do the fallback
-                return fallbackBuffer.InternalFallback(charFallback, ref chars);
-            }
-
             internal unsafe bool MoreData
             {
                 get
diff --git a/src/mscorlib/src/System/Text/EncodingForwarder.cs b/src/mscorlib/src/System/Text/EncodingForwarder.cs
index 9a8dd26627..50ccbd9333 100644
--- a/src/mscorlib/src/System/Text/EncodingForwarder.cs
+++ b/src/mscorlib/src/System/Text/EncodingForwarder.cs
@@ -130,7 +130,7 @@ namespace System.Text
             if (bytes.Length == 0)
                 bytes = new byte[1];
             
-            fixed (char* pChars = s) fixed (byte* pBytes = bytes)
+            fixed (char* pChars = s) fixed (byte* pBytes = &bytes[0])
             {
                 return encoding.GetBytes(pChars + charIndex, charCount, pBytes + byteIndex, byteCount, encoder: null);
             }
@@ -170,7 +170,7 @@ namespace System.Text
                 bytes = new byte[1];
             
             // Just call the (internal) pointer version
-            fixed (char* pChars = chars) fixed (byte* pBytes = bytes)
+            fixed (char* pChars = chars) fixed (byte* pBytes = &bytes[0])
             {
                 return encoding.GetBytes(pChars + charIndex, charCount, pBytes + byteIndex, byteCount, encoder: null);
             }
@@ -266,7 +266,7 @@ namespace System.Text
             if (chars.Length == 0)
                 chars = new char[1];
 
-            fixed (byte* pBytes = bytes) fixed (char* pChars = chars)
+            fixed (byte* pBytes = bytes) fixed (char* pChars = &chars[0])
             {
                 return encoding.GetChars(pBytes + byteIndex, byteCount, pChars + charIndex, charCount, decoder: null);
             }
diff --git a/src/mscorlib/src/System/Text/EncodingNLS.cs b/src/mscorlib/src/System/Text/EncodingNLS.cs
index fbddf37e88..cb6ed8a52c 100644
--- a/src/mscorlib/src/System/Text/EncodingNLS.cs
+++ b/src/mscorlib/src/System/Text/EncodingNLS.cs
@@ -15,7 +15,6 @@ namespace System.Text
     
     // This class overrides Encoding with the things we need for our NLS Encodings
     
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     internal abstract class EncodingNLS : Encoding
     {    
diff --git a/src/mscorlib/src/System/Text/EncodingProvider.cs b/src/mscorlib/src/System/Text/EncodingProvider.cs
index a7f745a753..734d1ac761 100644
--- a/src/mscorlib/src/System/Text/EncodingProvider.cs
+++ b/src/mscorlib/src/System/Text/EncodingProvider.cs
@@ -8,7 +8,6 @@ namespace System.Text
     using System.Collections;
     using System.Collections.Generic;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public abstract class EncodingProvider
     {
         public EncodingProvider() { }
diff --git a/src/mscorlib/src/System/Text/ISCIIEncoding.cs b/src/mscorlib/src/System/Text/ISCIIEncoding.cs
deleted file mode 100644
index 751b8217c0..0000000000
--- a/src/mscorlib/src/System/Text/ISCIIEncoding.cs
+++ /dev/null
@@ -1,2621 +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.
-
-// ISCIIEncoding
-//
-//  Ported from windows c_iscii.  If you find bugs here, there're likely similar
-//  bugs in the windows version
-namespace System.Text
-{
-    using System;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-    using System.Globalization;
-    using System.Runtime.Serialization;
-    using System.Security.Permissions;
-
-    // Encodes text into and out of the ISCII encodings.
-    // ISCII contains characters to encode indic scripts by mapping indic scripts
-    // to the same code page.  This works because they are all related scripts.
-    // ISCII provides a "font" selection method to switch between the appropriate
-    // fonts to display the other scripts.  All ISCII characters are above the
-    // ASCII range to provide ASCII compatibility.
-    //
-    // IsAlwaysNormalized() isn't overridden
-    // We don't override IsAlwaysNormalized() because it is false for all forms (like base implimentation)
-    //      Forms C & KC have things like 0933 + 093C == composed 0934, so they aren't normalized
-    //      Forms D & KD have things like 0934, which decomposes to 0933 + 093C, so not normal.
-    //      Form IDNA has the above problems plus case mapping, so false (like most encodings)
-    //
-
-    [Serializable]
-    internal class ISCIIEncoding : EncodingNLS, ISerializable
-    {
-        // Constants
-        private const int CodeDefault       = 0;    // 0x40       Default
-        private const int CodeRoman         = 1;    // 0x41       Roman Transliteration (not supported)
-        private const int CodeDevanagari    = 2;    // 0x42 57002
-        private const int CodeBengali       = 3;    // 0x43 57003
-        private const int CodeTamil         = 4;    // 0x44 57004
-        private const int CodeTelugu        = 5;    // 0x45 57005
-        private const int CodeAssamese      = 6;    // 0x46 57006 Assamese (Bengali)
-        private const int CodeOriya         = 7;    // 0x47 57007
-        private const int CodeKannada       = 8;    // 0x48 57008
-        private const int CodeMalayalam     = 9;    // 0x49 57009
-        private const int CodeGujarati      = 10;   // 0x4a 57010
-        private const int CodePunjabi       = 11;   // 0x4b 57011 Punjabi (Gurmukhi)
-
-        // Ranges
-        private const int MultiByteBegin    = 0xa0;     // Beginning of MultiByte space in ISCII
-        private const int IndicBegin        = 0x0901;   // Beginining of Unicode Indic script code points
-        private const int IndicEnd          = 0x0d6f;   // End of Unicode Indic Script code points
-
-        // ISCII Control Values
-        private const byte ControlATR       = 0xef;     // Attribute (ATR) code
-        private const byte ControlCodePageStart = 0x40;  // Start of code page range
-
-        // Interesting ISCII characters
-        private const byte Virama           = 0xe8;
-        private const byte Nukta            = 0xe9;
-        private const byte DevenagariExt    = 0xf0;
-
-        // Interesting Unicode characters
-        private const char ZWNJ             = (char)0x200c;
-        private const char ZWJ              = (char)0x200d;
-
-        // Code Page
-        private int defaultCodePage;
-
-        public ISCIIEncoding(int codePage) : base(codePage)
-        {
-            // Set our code page (subtracting windows code page # offset)
-            defaultCodePage = codePage - 57000;
-
-            // Legal windows code pages are between Devanagari and Punjabi
-            Debug.Assert(defaultCodePage >= CodeDevanagari && defaultCodePage <= CodePunjabi,
-                "[ISCIIEncoding] Code page (" + codePage + " isn't supported by ISCIIEncoding!");
-
-            // This shouldn't really be possible
-            if (defaultCodePage < CodeDevanagari || defaultCodePage > CodePunjabi)
-                throw new ArgumentException(Environment.GetResourceString(
-                       "Argument_CodepageNotSupported", codePage), nameof(codePage));
-        }
-
-        // Constructor called by serialization.
-        internal ISCIIEncoding(SerializationInfo info, StreamingContext context) : base(0)
-        {
-            // Actually this can't ever get called, MLangCodePageEncoding is our proxy
-            // (In Everett this was done by MLang)
-            Debug.Assert(false, "Didn't expect to make it to ISCIIEncoding serialization constructor");
-            throw new ArgumentException(Environment.GetResourceString("Arg_ExecutionEngineException"));
-        }
-
-        // ISerializable implementation
-        void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
-        {
-            // Make sure to get the base stuff too This throws if info is null
-            SerializeEncoding(info, context);
-            Debug.Assert(info!=null, "[ISCIIEncoding.GetObjectData] Expected null info to throw");
-
-            // Just need Everett MLangCodePageEncoding maxCharSize
-            info.AddValue("m_maxByteSize", 2);
-
-            // Always have this as our helper
-            info.SetType(typeof(MLangCodePageEncoding));
-        }
-
-        // Our MaxByteCount is 4 times the input size.  That could be because
-        // the first input character could be in the wrong code page ("font") and
-        // then that character could also be encoded in 2 code points
-        public override int GetMaxByteCount(int charCount)
-        {
-            if (charCount < 0)
-               throw new ArgumentOutOfRangeException(nameof(charCount),
-                    Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            Contract.EndContractBlock();
-
-            // Characters would be # of characters + 1 in case high surrogate is ? * max fallback
-            long byteCount = (long)charCount + 1;
-
-            if (EncoderFallback.MaxCharCount > 1)
-                byteCount *= EncoderFallback.MaxCharCount;
-
-            // 4 Time input because 1st input could require code page change and also that char could require 2 code points
-            byteCount *= 4;
-
-            if (byteCount > 0x7fffffff)
-                throw new ArgumentOutOfRangeException(nameof(charCount), Environment.GetResourceString("ArgumentOutOfRange_GetByteCountOverflow"));
-
-            return (int)byteCount;
-        }
-
-        // Our MaxCharCount is the same as the byteCount.  There are a few sequences
-        // where 2 (or more) bytes could become 2 chars, but thats still 1 to 1.
-        public override int GetMaxCharCount(int byteCount)
-        {
-            if (byteCount < 0)
-               throw new ArgumentOutOfRangeException(nameof(byteCount),
-                    Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
-            Contract.EndContractBlock();
-
-            // Our MaxCharCount is the same as the byteCount.  There are a few sequences
-            // where 2 (or more) bytes could become 2 chars, but thats still 1 to 1.
-            // Also could have 1 in decoder if we're waiting to see if next char's a nukta.
-            long charCount = ((long)byteCount + 1);
-
-            // Some code points are undefined so we could fall back.
-            if (DecoderFallback.MaxCharCount > 1)
-                charCount *= DecoderFallback.MaxCharCount;
-
-            if (charCount > 0x7fffffff)
-                throw new ArgumentOutOfRangeException(nameof(byteCount), Environment.GetResourceString("ArgumentOutOfRange_GetCharCountOverflow"));
-
-            return (int)charCount;
-        }
-
-        // Our workhorse version
-        internal override unsafe int GetByteCount(char* chars, int count, EncoderNLS baseEncoder)
-        {
-            // Use null pointer to ask GetBytes for count
-            return GetBytes(chars, count, null, 0, baseEncoder);
-        }
-
-        // Workhorse
-        internal override unsafe int GetBytes(char *chars, int charCount,
-                                                byte* bytes, int byteCount, EncoderNLS baseEncoder)
-        {
-            // Allow null bytes for counting
-            Debug.Assert(chars != null, "[ISCIIEncoding.GetBytes]chars!=null");
-//            Debug.Assert(bytes != null, "[ISCIIEncoding.GetBytes]bytes!=null");
-            Debug.Assert(charCount >=0, "[ISCIIEncoding.GetBytes]charCount >=0");
-            Debug.Assert(byteCount >=0, "[ISCIIEncoding.GetBytes]byteCount >=0");
-
-            // Need the ISCII Encoder
-            ISCIIEncoder encoder = (ISCIIEncoder) baseEncoder;
-
-            // prepare our helpers
-            Encoding.EncodingByteBuffer buffer = new Encoding.EncodingByteBuffer(
-                this, encoder, bytes, byteCount, chars, charCount);
-
-            int   currentCodePage = this.defaultCodePage;
-            bool  bLastVirama = false;
-
-            // Use encoder info if available
-            if (encoder != null)
-            {
-                // Remember our old state
-                currentCodePage = encoder.currentCodePage;
-                bLastVirama = encoder.bLastVirama;
-
-                // If we have a high surrogate left over, then fall it back
-                if (encoder.charLeftOver > 0)
-                {
-                    buffer.Fallback(encoder.charLeftOver);
-                    bLastVirama = false;        // Redundant
-                }
-            }
-
-            while (buffer.MoreData)
-            {
-                // Get our data
-                char ch = buffer.GetNextChar();
-
-                // See if its a Multi Byte Character
-                if (ch < MultiByteBegin)
-                {
-                    // Its a boring low character, add it.
-                    if (!buffer.AddByte((byte)ch))
-                        break;
-                    bLastVirama = false;
-                    continue;
-                }
-
-                // See if its outside of the Indic script Range range
-                if ((ch < IndicBegin) || (ch > IndicEnd))
-                {
-                    // See if its a ZWJ or ZWNJ and if we has bLastVirama;
-                    if (bLastVirama && (ch == ZWNJ || ch == ZWJ))
-                    {
-                        // It was a bLastVirama and ZWNJ || ZWJ
-                        if (ch == ZWNJ)
-                        {
-                            if (!buffer.AddByte(Virama))
-                                break;
-                        }
-                        else // ZWJ
-                        {
-                            if (!buffer.AddByte(Nukta))
-                                break;
-                        }
-
-                        // bLastVirama now counts as false
-                        bLastVirama = false;
-                        continue;
-                    }
-
-                    // Have to do our fallback
-                    //
-                    // Note that this will fallback 2 chars if this is a high surrogate.
-                    // Throws if recursive (knows because we called InternalGetNextChar)
-                    buffer.Fallback(ch);
-                    bLastVirama = false;
-                    continue;
-                }
-
-                // Its in the Unicode Indic script range
-                int indicInfo = UnicodeToIndicChar[ch - IndicBegin];
-                byte byteIndic = (byte)indicInfo;
-                int indicScript = (0x000f & (indicInfo >> 8));
-                int indicTwoBytes = (0xf000 & indicInfo);
-
-                // If IndicInfo is 0 then have to do fallback
-                if (indicInfo == 0)
-                {
-                    // Its some Unicode character we don't have indic for.
-                    // Have to do our fallback
-                    // Add Fallback Count
-                    // Note that chars was preincremented, and GetEncoderFallbackString might add an extra
-                    // if chars != charEnd and there's a surrogate.
-                    // Throws if recursive (knows because we called InternalGetNextChar)
-                    buffer.Fallback(ch);
-
-                    bLastVirama = false;
-                    continue;
-                }
-
-                // See if our code page ("font" in ISCII spec) has to change
-                // (This if doesn't add character, just changes character set)
-                Debug.Assert(indicScript!=0, "[ISCIIEncoding.GetBytes]expected an indic script value");
-                if (indicScript != currentCodePage)
-                {
-                    // It changed, spit out the ATR
-                    if (!buffer.AddByte(ControlATR, (byte)(indicScript | ControlCodePageStart)))
-                        break;
-
-                    // Now spit out the new code page (& remember it) (do this afterwards in case AddByte failed)
-                    currentCodePage = indicScript;
-
-                    // We only know how to map from Unicode to pages from Devanagari to Punjabi (2 to 11)
-                    Debug.Assert(currentCodePage >= CodeDevanagari && currentCodePage <= CodePunjabi,
-                        "[ISCIIEncoding.GetBytes]Code page (" + currentCodePage + " shouldn't appear in ISCII from Unicode table!");
-                }
-
-                // Safe to add our byte now
-                if (!buffer.AddByte(byteIndic, indicTwoBytes != 0 ? 1:0))
-                    break;
-
-                // Remember if this one was a Virama
-                bLastVirama = (byteIndic == Virama);
-
-                // Some characters need extra bytes
-                if (indicTwoBytes != 0)
-                {
-                    // This one needs another byte
-                    Debug.Assert((indicTwoBytes >> 12) > 0 && (indicTwoBytes >> 12) <= 3,
-                        "[ISCIIEncoding.GetBytes]Expected indicTwoBytes from 1-3, not " + (indicTwoBytes >> 12));
-
-                    // Already did buffer checking, but...
-                    if (!buffer.AddByte(SecondIndicByte[indicTwoBytes >> 12]))
-                        break;
-                }
-            }
-
-            // May need to switch back to our default code page
-            if (currentCodePage != defaultCodePage && (encoder == null || encoder.MustFlush))
-            {
-                // It changed, spit out the ATR
-                if (buffer.AddByte(ControlATR, (byte)(defaultCodePage | ControlCodePageStart)))
-                    currentCodePage = defaultCodePage;
-                else
-                    // If not successful, convert will maintain state for next time, also
-                    // AddByte will have decremented our char count, however we need it to remain the same
-                    buffer.GetNextChar();
-                bLastVirama = false;
-            }
-
-            // Make sure we remember our state if necessary
-            // Note that we don't care about flush because Virama and code page
-            // changes are legal at the end.
-            // Don't set encoder if we're just counting
-            if (encoder != null && bytes != null)
-            {
-                // Clear Encoder if necessary.
-                if (!buffer.fallbackBuffer.bUsedEncoder)
-                {
-                    encoder.charLeftOver = (char)0;
-                }
-
-                // Remember our code page/virama state
-                encoder.currentCodePage = currentCodePage;
-                encoder.bLastVirama = bLastVirama;
-
-                // How many chars were used?
-                encoder.m_charsUsed = buffer.CharsUsed;
-            }
-
-            // Return our length
-            return buffer.Count;
-       }
-
-        // Workhorse
-        internal override unsafe int GetCharCount(byte* bytes, int count, DecoderNLS baseDecoder)
-        {
-            // Just call GetChars with null chars saying we want count
-            return GetChars(bytes, count, null, 0, baseDecoder);
-        }
-
-        // For decoding, the following interesting rules apply:
-        // Virama followed by another Virama or Nukta becomes Virama + ZWNJ or Virama + ZWJ
-        // ATR is followed by a byte to switch code pages ("fonts")
-        // Devenagari F0, B8 -> \u0952
-        // Devenagari F0, BF -> \u0970
-        // Some characters followed by E9 become a different character instead.
-        internal override unsafe int GetChars(byte* bytes, int byteCount,
-                                                char* chars, int charCount, DecoderNLS baseDecoder)
-        {
-            // Just need to ASSERT, this is called by something else internal that checked parameters already
-            // Allow null chars for counting
-            Debug.Assert(bytes != null, "[ISCIIEncoding.GetChars]bytes is null");
-            Debug.Assert(byteCount >= 0, "[ISCIIEncoding.GetChars]byteCount is negative");
-//            Debug.Assert(chars != null, "[ISCIIEncoding.GetChars]chars is null");
-            Debug.Assert(charCount >= 0, "[ISCIIEncoding.GetChars]charCount is negative");
-
-            // Need the ISCII Decoder
-            ISCIIDecoder decoder = (ISCIIDecoder) baseDecoder;
-
-            // Get our info.
-            Encoding.EncodingCharBuffer buffer = new Encoding.EncodingCharBuffer(
-                this, decoder, chars, charCount, bytes, byteCount);
-
-            int  currentCodePage = this.defaultCodePage;
-            bool bLastATR = false;
-            bool bLastVirama = false;
-            bool bLastDevenagariStressAbbr = false;
-            char cLastCharForNextNukta = '\0';
-            char cLastCharForNoNextNukta = '\0';
-
-            // See if there's anything in our decoder
-            if (decoder != null)
-            {
-                currentCodePage = decoder.currentCodePage;
-                bLastATR = decoder.bLastATR;
-                bLastVirama = decoder.bLastVirama;
-                bLastDevenagariStressAbbr = decoder.bLastDevenagariStressAbbr;
-                cLastCharForNextNukta = decoder.cLastCharForNextNukta;
-                cLastCharForNoNextNukta = decoder.cLastCharForNoNextNukta;
-            }
-
-            bool bLastSpecial = bLastVirama | bLastATR | bLastDevenagariStressAbbr |
-                (cLastCharForNextNukta != '\0');
-
-            // Get our current code page index (some code pages are dups)
-            int currentCodePageIndex = -1;
-            Debug.Assert(currentCodePage >= CodeDevanagari && currentCodePage <= CodePunjabi,
-                "[ISCIIEncoding.GetChars]Decoder code page must be >= Devanagari and <= Punjabi, not " + currentCodePage);
-
-            if (currentCodePage >= CodeDevanagari && currentCodePage <= CodePunjabi)
-            {
-                currentCodePageIndex = IndicMappingIndex[currentCodePage];
-            }
-
-            // Loop through our input
-            while (buffer.MoreData)
-            {
-                byte b = buffer.GetNextByte();
-
-                // See if last one was special
-                if (bLastSpecial)
-                {
-                    // Now it won't be
-                    bLastSpecial = false;
-
-                    // One and only one of our flags should be set
-                    Debug.Assert(((bLastVirama ? 1 : 0) + (bLastATR ? 1 : 0) +
-                               (bLastDevenagariStressAbbr ? 1 : 0) +
-                               ((cLastCharForNextNukta > 0) ? 1 : 0)) == 1,
-                        String.Format(CultureInfo.InvariantCulture,
-                            "[ISCIIEncoding.GetChars]Special cases require 1 and only 1 special case flag: LastATR {0} Dev. {1} Nukta {2}",
-                            bLastATR, bLastDevenagariStressAbbr, cLastCharForNextNukta));
-                    // If the last one was an ATR, then we'll have to do ATR stuff
-                    if (bLastATR)
-                    {
-                        // We only support Devanagari - Punjabi
-                        if (b >= (0x40 | CodeDevanagari) && b <= (0x40 | CodePunjabi))
-                        {
-                            // Remember the code page
-                            currentCodePage = b & 0xf;
-                            currentCodePageIndex = IndicMappingIndex[currentCodePage];
-                            // No longer last ATR
-                            bLastATR = false;
-                            continue;
-                        }
-
-                        // Change back to default?
-                        if (b == 0x40)
-                        {
-                            currentCodePage = this.defaultCodePage;
-                            currentCodePageIndex = -1;
-
-                            if (currentCodePage >= CodeDevanagari && currentCodePage <= CodePunjabi)
-                            {
-                                currentCodePageIndex = IndicMappingIndex[currentCodePage];
-                            }
-                            // No longer last ATR
-                            bLastATR = false;
-                            continue;
-                        }
-
-                        // We don't support Roman
-                        if (b == 0x41)
-                        {
-                            currentCodePage = this.defaultCodePage;
-                            currentCodePageIndex = -1;
-
-                            if (currentCodePage >= CodeDevanagari && currentCodePage <= CodePunjabi)
-                            {
-                                currentCodePageIndex = IndicMappingIndex[currentCodePage];
-                            }
-
-                            // Even though we don't know how to support Roman, windows didn't add a ? so we don't either.
-                            // No longer last ATR
-                            bLastATR = false;
-                            continue;
-                        }
-
-                        // Other code pages & ATR codes not supported, fallback the ATR
-                        // If fails, decrements the buffer, which is OK, we remember ATR state.
-                        if (!buffer.Fallback(ControlATR))
-                            break;
-
-                        // No longer last ATR (fell back)
-                        bLastATR = false;
-
-                        // we know we can't have any of these other modes
-                        Debug.Assert(bLastVirama == false, "[ISCIIEncoding.GetChars] Expected no bLastVirama in bLastATR mode");
-                        Debug.Assert(bLastDevenagariStressAbbr == false, "[ISCIIEncoding.GetChars] Expected no bLastDevenagariStressAbbr in bLastATR mode");
-                        Debug.Assert(cLastCharForNextNukta == (char)0, "[ISCIIEncoding.GetChars] Expected no cLastCharForNextNukta in bLastATR mode");
-                        Debug.Assert(cLastCharForNoNextNukta == (char)0, "[ISCIIEncoding.GetChars] Expected no cLastCharForNoNextNukta in bLastATR mode");
-
-                        // Keep processing this byte
-                    }
-                    else if (bLastVirama)
-                    {
-                        // If last was Virama, then we might need ZWNJ or ZWJ instead
-                        if (b == Virama)
-                        {
-                            // If no room, then stop
-                            if (!buffer.AddChar(ZWNJ))
-                                break;
-                            bLastVirama = false;
-                            continue;
-                        }
-                        if (b == Nukta)
-                        {
-                            // If no room, then stop
-                            if (!buffer.AddChar(ZWJ))
-                                break;
-                            bLastVirama = false;
-                            continue;
-                        }
-
-                        // No longer in this mode, fall through to handle character
-                        // (Virama itself was added when flag was set last iteration)
-                        bLastVirama = false;
-
-                        // We know we can't have any of these other modes
-                        Debug.Assert(bLastATR == false, "[ISCIIEncoding.GetChars] Expected no bLastATR in bLastVirama mode");
-                        Debug.Assert(bLastDevenagariStressAbbr == false, "[ISCIIEncoding.GetChars] Expected no bLastDevenagariStressAbbr in bLastVirama mode");
-                        Debug.Assert(cLastCharForNextNukta == (char)0, "[ISCIIEncoding.GetChars] Expected no cLastCharForNextNukta in bLastVirama mode");
-                        Debug.Assert(cLastCharForNoNextNukta == (char)0, "[ISCIIEncoding.GetChars] Expected no cLastCharForNoNextNukta in bLastVirama mode");
-                    }
-                    else if (bLastDevenagariStressAbbr)
-                    {
-                        // Last byte was an 0xf0 (ext).
-                        // If current is b8 or bf, then we have 952 or 970.  Otherwise fallback
-                        if (b == 0xb8)
-                        {
-                            // It was a 0xb8
-                            if (!buffer.AddChar('\x0952'))         // Devanagari stress sign anudatta
-                                break;
-                            bLastDevenagariStressAbbr = false;
-                            continue;
-                        }
-
-                        if (b == 0xbf)
-                        {
-                            // It was a 0xbf
-                            if (!buffer.AddChar('\x0970'))         // Devanagari abbr. sign
-                                break;
-                            bLastDevenagariStressAbbr = false;
-                            continue;
-                        }
-
-                        // Wasn't an expected pattern, do fallback for f0 (ext)
-                        // if fails, fallback will back up our buffer
-                        if (!buffer.Fallback(DevenagariExt))
-                            break;
-                        
-                        // Keep processing this byte (turn off mode)
-                        // (last character was added when mode was set)
-                        bLastDevenagariStressAbbr = false;
-
-                        Debug.Assert(bLastATR == false, "[ISCIIEncoding.GetChars] Expected no bLastATR in bLastDevenagariStressAbbr mode");
-                        Debug.Assert(bLastVirama == false, "[ISCIIEncoding.GetChars] Expected no bLastVirama in bLastDevenagariStressAbbr mode");
-                        Debug.Assert(cLastCharForNextNukta == (char)0, "[ISCIIEncoding.GetChars] Expected no cLastCharForNextNukta in bLastDevenagariStressAbbr mode");
-                        Debug.Assert(cLastCharForNoNextNukta == (char)0, "[ISCIIEncoding.GetChars] Expected no cLastCharForNoNextNukta in bLastDevenagariStressAbbr mode");                        
-                    }
-                    else
-                    {
-                        // We were checking for next char being a nukta
-                        Debug.Assert(cLastCharForNextNukta > 0 && cLastCharForNoNextNukta > 0,
-                            "[ISCIIEncoding.GetChars]No other special case found, but cLastCharFor(No)NextNukta variable(s) aren't set.");
-
-                        // We'll either add combined char or last char
-                        if (b == Nukta)
-                        {
-                            // We combine nukta with previous char
-                            if (!buffer.AddChar(cLastCharForNextNukta))
-                                break;
-
-                            // Done already
-                            cLastCharForNextNukta = cLastCharForNoNextNukta = '\0';
-                            continue;
-                        }
-
-                        // No Nukta, just add last character and keep processing current byte
-                        if (!buffer.AddChar(cLastCharForNoNextNukta))
-                            break;
-
-                        // Keep processing this byte, turn off mode.
-                        cLastCharForNextNukta = cLastCharForNoNextNukta = '\0';
-                        
-                        Debug.Assert(bLastATR == false, "[ISCIIEncoding.GetChars] Expected no bLastATR in cLastCharForNextNukta mode");
-                        Debug.Assert(bLastVirama == false, "[ISCIIEncoding.GetChars] Expected no bLastVirama in cLastCharForNextNukta mode");
-                        Debug.Assert(bLastDevenagariStressAbbr == false, "[ISCIIEncoding.GetChars] Expected no bLastDevenagariStressAbbr in cLastCharForNextNukta mode");                        
-                    }
-                }
-
-                // Now bLastSpecial should be false and all flags false.
-                Debug.Assert (!bLastSpecial && !bLastDevenagariStressAbbr && !bLastVirama && !bLastATR &&
-                          cLastCharForNextNukta == '\0',
-                          "[ISCIIEncoding.GetChars]No special state for last code point should exist at this point.");
-
-                // If its a simple byte, just add it
-                if (b < MultiByteBegin)
-                {
-                    if (!buffer.AddChar((char)b))
-                        break;
-                    continue;
-                }
-
-                // See if its an ATR marker
-                if (b == ControlATR)
-                {
-                    bLastATR = bLastSpecial = true;
-                    continue;
-                }
-
-                Debug.Assert (currentCodePageIndex != -1, "[ISCIIEncoding.GetChars]Expected valid currentCodePageIndex != -1");
-                char ch = IndicMapping[currentCodePageIndex, 0, b - MultiByteBegin];
-                char cAlt = IndicMapping[currentCodePageIndex, 1, b - MultiByteBegin];
-
-                // If no 2nd char, just add it, also lonely Nuktas get added as well.
-                if (cAlt == 0 || b == Nukta)
-                {
-                    // If it was an unknown character do fallback
-
-                    // ? if not known.
-                    if (ch == 0)
-                    {
-                        // Fallback the unknown byte
-                        if (!buffer.Fallback(b))
-                            break;
-                    }
-                    else
-                    {
-                        // Add the known character
-                        if (!buffer.AddChar(ch))
-                            break;
-                    }
-                    continue;
-                }
-
-                // if b == Virama set last Virama so we can do ZWJ or ZWNJ next time if needed.
-                if (b == Virama)
-                {
-                    // Add Virama
-                    if (!buffer.AddChar(ch))
-                        break;
-                    bLastVirama = bLastSpecial = true;
-                    continue;
-                }
-
-                // See if its one that changes with a Nukta
-                if ((cAlt & 0xF000) == 0)
-                {
-                    // It could change if next char is a nukta
-                    bLastSpecial = true;
-                    cLastCharForNextNukta = cAlt;
-                    cLastCharForNoNextNukta = ch;
-                    continue;
-                }
-
-                // We must be the Devenagari special case for F0, B8 & F0, BF
-                Debug.Assert(currentCodePage == CodeDevanagari && b == DevenagariExt,
-                    String.Format(CultureInfo.InvariantCulture,
-                        "[ISCIIEncoding.GetChars] Devenagari special case must {0} not {1} or in Devanagari code page {2} not {3}.",
-                        DevenagariExt, b, CodeDevanagari, currentCodePage));
-                bLastDevenagariStressAbbr = bLastSpecial = true;
-
-            }
-
-            // If we don't have a decoder, or if we had to flush, then we need to get rid
-            // of last ATR, LastNoNextNukta and LastDevenagariExt.
-            if (decoder == null || decoder.MustFlush)
-            {
-                // If these fail (because of Convert with insufficient buffer), then they'll turn off MustFlush as well.
-                if (bLastATR)
-                {
-                    // Have to add ATR fallback
-                    if (buffer.Fallback(ControlATR))
-                        bLastATR = false;
-                    else
-                        // If not successful, convert will maintain state for next time, also
-                        // AddChar will have decremented our byte count, however we need it to remain the same
-                        buffer.GetNextByte();
-                }
-                else if (bLastDevenagariStressAbbr)
-                {
-                    // Have to do fallback for DevenagariExt
-                    if (buffer.Fallback(DevenagariExt))
-                        bLastDevenagariStressAbbr = false;
-                    else
-                        // If not successful, convert will maintain state for next time, also
-                        // AddChar will have decremented our byte count, however we need it to remain the same
-                        buffer.GetNextByte();
-                }
-                else if (cLastCharForNoNextNukta != '\0')
-                {
-                    // Have to add our last char because there was no next nukta
-                    if (buffer.AddChar(cLastCharForNoNextNukta))
-                        cLastCharForNoNextNukta = cLastCharForNextNukta = '\0';
-                    else
-                        // If not successful, convert will maintain state for next time, also
-                        // AddChar will have decremented our byte count, however we need it to remain the same
-                        buffer.GetNextByte();
-                }
-                // LastVirama is unimportant for flushing decoder.
-            }
-
-            // Remember any left over stuff
-            // (only remember if we aren't counting)
-            if (decoder != null && chars != null)
-            {
-                // If not flushing or have state (from convert) then need to remember state
-                if (!decoder.MustFlush ||
-                    cLastCharForNoNextNukta != '\0' || bLastATR || bLastDevenagariStressAbbr)
-                {
-                    // Either not flushing or had state (from convert)
-                    Debug.Assert(!decoder.MustFlush || !decoder.m_throwOnOverflow,
-                        "[ISCIIEncoding.GetChars]Expected no state or not converting or not flushing");
-                    decoder.currentCodePage = currentCodePage;
-                    decoder.bLastVirama = bLastVirama;
-                    decoder.bLastATR = bLastATR;
-                    decoder.bLastDevenagariStressAbbr = bLastDevenagariStressAbbr;
-                    decoder.cLastCharForNextNukta = cLastCharForNextNukta;
-                    decoder.cLastCharForNoNextNukta = cLastCharForNoNextNukta;
-                }
-                else
-                {
-                    decoder.currentCodePage = this.defaultCodePage;
-                    decoder.bLastVirama = false;
-                    decoder.bLastATR = false;
-                    decoder.bLastDevenagariStressAbbr = false;
-                    decoder.cLastCharForNextNukta = '\0';
-                    decoder.cLastCharForNoNextNukta = '\0';
-                }
-                decoder.m_bytesUsed = buffer.BytesUsed;
-            }
-            // Otherwise we already did fallback and added extra things
-
-            // Return the # of characters we found
-            return buffer.Count;
-        }
-
-        public override Decoder GetDecoder()
-        {
-            return new ISCIIDecoder(this);
-        }
-
-        public override Encoder GetEncoder()
-        {
-            return new ISCIIEncoder(this);
-        }
-
-        public override int GetHashCode()
-        {
-            //Not great distribution, but this is relatively unlikely to be used as the key in a hashtable.
-            return defaultCodePage + this.EncoderFallback.GetHashCode() + this.DecoderFallback.GetHashCode();
-        }
-
-        [Serializable]
-        internal class ISCIIEncoder : EncoderNLS
-        {
-            // Need to remember the default code page (for HasState)
-            internal int    defaultCodePage = 0;
-            
-            // Need a place for the current code page
-            internal int    currentCodePage = 0;
-
-            // Was the last character a virama?  (Because ZWJ and ZWNJ are different then)
-            internal bool   bLastVirama = false;
-
-            public ISCIIEncoder(Encoding encoding) : base(encoding)
-            {
-                this.currentCodePage = this.defaultCodePage = encoding.CodePage - 57000;
-
-                // base calls reset
-            }
-
-            // Warning: If you're decoding mixed encoding files or something, this could be confusing
-            //          We don't always force back to base encoding mapping, so if you reset where do you restart?
-            public override void Reset()
-            {
-                bLastVirama = false;
-                charLeftOver = (char)0;
-                if (m_fallbackBuffer != null)
-                    m_fallbackBuffer.Reset();                
-            }
-
-            // Anything left in our encoder?
-            // Encoder not only has to get rid of left over characters, but it has to switch back to the current code page.
-            internal override bool HasState
-            {
-                get
-                {
-                    return (this.charLeftOver != (char)0 || this.currentCodePage != this.defaultCodePage);
-                }
-            }
-        }
-
-        [Serializable]
-        internal class ISCIIDecoder : DecoderNLS
-        {
-            // Need a place to store any our current code page and last ATR flag
-            internal int currentCodePage = 0;
-            internal bool bLastATR = false;
-            internal bool bLastVirama = false;
-            internal bool bLastDevenagariStressAbbr = false;
-            internal char cLastCharForNextNukta = '\0';
-            internal char cLastCharForNoNextNukta = '\0';
-
-            public ISCIIDecoder(Encoding encoding) : base(encoding)
-            {
-                this.currentCodePage = encoding.CodePage - 57000;
-
-                // base calls reset
-            }
-
-            // Warning: If you're decoding mixed encoding files or something, this could be confusing
-            //          We don't always force back to base encoding mapping, so if you reset where do you restart?
-            public override void Reset()
-            {
-                bLastATR = false;
-                bLastVirama = false;
-                bLastDevenagariStressAbbr = false;
-                cLastCharForNextNukta = '\0';
-                cLastCharForNoNextNukta = '\0';
-                if (m_fallbackBuffer != null)
-                    m_fallbackBuffer.Reset();
-            }
-
-            // Anything left in our decoder?
-            internal override bool HasState
-            {
-                get
-                {
-                    return (this.cLastCharForNextNukta != '\0' || this.cLastCharForNoNextNukta != '\0' ||
-                            this.bLastATR || this.bLastDevenagariStressAbbr);
-                }
-            }
-        }
-
-        //
-        // ISCII Tables
-        //
-        // From Windows ISCII\tables.c
-        //
-
-        ////////////////////////////////////////////////////////////////////////////
-        //
-        //  Char to Byte
-        //
-        //  0xXYZZ  Where Y is the code page "font" part and ZZ is the byte character
-        //          The high X bits also reference the SecondIndicByte table if an
-        //          extra byte is needed.
-        //  0x0000  For undefined characters
-        //
-        //  This is valid for values IndicBegin to IndicEnd
-        //
-        // WARNING: When this was copied from windows, the ? characters (0x003F) were
-        // searched/replaced with 0x0000.
-        //
-        ////////////////////////////////////////////////////////////////////////////
-
-        static int[] UnicodeToIndicChar =
-        {
-            0x02a1,  // U+0901 : Devanagari Sign Candrabindu
-            0x02a2,  // U+0902 : Devanagari Sign Anusvara
-            0x02a3,  // U+0903 : Devanagari Sign Visarga
-            0x0000,  // U+0904 : Undefined
-            0x02a4,  // U+0905 : Devanagari Letter A
-            0x02a5,  // U+0906 : Devanagari Letter Aa
-            0x02a6,  // U+0907 : Devanagari Letter I
-            0x02a7,  // U+0908 : Devanagari Letter Ii
-            0x02a8,  // U+0909 : Devanagari Letter U
-            0x02a9,  // U+090a : Devanagari Letter Uu
-            0x02aa,  // U+090b : Devanagari Letter Vocalic R
-            0x12a6,  // U+090c : Devanagari Letter Vocalic L
-            0x02ae,  // U+090d : Devanagari Letter Candra E
-            0x02ab,  // U+090e : Devanagari Letter Short E
-            0x02ac,  // U+090f : Devanagari Letter E
-            0x02ad,  // U+0910 : Devanagari Letter Ai
-            0x02b2,  // U+0911 : Devanagari Letter Candra O
-            0x02af,  // U+0912 : Devanagari Letter Short O
-            0x02b0,  // U+0913 : Devanagari Letter O
-            0x02b1,  // U+0914 : Devanagari Letter Au
-            0x02b3,  // U+0915 : Devanagari Letter Ka
-            0x02b4,  // U+0916 : Devanagari Letter Kha
-            0x02b5,  // U+0917 : Devanagari Letter Ga
-            0x02b6,  // U+0918 : Devanagari Letter Gha
-            0x02b7,  // U+0919 : Devanagari Letter Nga
-            0x02b8,  // U+091a : Devanagari Letter Ca
-            0x02b9,  // U+091b : Devanagari Letter Cha
-            0x02ba,  // U+091c : Devanagari Letter Ja
-            0x02bb,  // U+091d : Devanagari Letter Jha
-            0x02bc,  // U+091e : Devanagari Letter Nya
-            0x02bd,  // U+091f : Devanagari Letter Tta
-            0x02be,  // U+0920 : Devanagari Letter Ttha
-            0x02bf,  // U+0921 : Devanagari Letter Dda
-            0x02c0,  // U+0922 : Devanagari Letter Ddha
-            0x02c1,  // U+0923 : Devanagari Letter Nna
-            0x02c2,  // U+0924 : Devanagari Letter Ta
-            0x02c3,  // U+0925 : Devanagari Letter Tha
-            0x02c4,  // U+0926 : Devanagari Letter Da
-            0x02c5,  // U+0927 : Devanagari Letter Dha
-            0x02c6,  // U+0928 : Devanagari Letter Na
-            0x02c7,  // U+0929 : Devanagari Letter Nnna
-            0x02c8,  // U+092a : Devanagari Letter Pa
-            0x02c9,  // U+092b : Devanagari Letter Pha
-            0x02ca,  // U+092c : Devanagari Letter Ba
-            0x02cb,  // U+092d : Devanagari Letter Bha
-            0x02cc,  // U+092e : Devanagari Letter Ma
-            0x02cd,  // U+092f : Devanagari Letter Ya
-            0x02cf,  // U+0930 : Devanagari Letter Ra
-            0x02d0,  // U+0931 : Devanagari Letter Rra
-            0x02d1,  // U+0932 : Devanagari Letter La
-            0x02d2,  // U+0933 : Devanagari Letter Lla
-            0x02d3,  // U+0934 : Devanagari Letter Llla
-            0x02d4,  // U+0935 : Devanagari Letter Va
-            0x02d5,  // U+0936 : Devanagari Letter Sha
-            0x02d6,  // U+0937 : Devanagari Letter Ssa
-            0x02d7,  // U+0938 : Devanagari Letter Sa
-            0x02d8,  // U+0939 : Devanagari Letter Ha
-            0x0000,  // U+093a : Undefined
-            0x0000,  // U+093b : Undefined
-            0x02e9,  // U+093c : Devanagari Sign Nukta
-            0x12ea,  // U+093d : Devanagari Sign Avagraha
-            0x02da,  // U+093e : Devanagari Vowel Sign Aa
-            0x02db,  // U+093f : Devanagari Vowel Sign I
-            0x02dc,  // U+0940 : Devanagari Vowel Sign Ii
-            0x02dd,  // U+0941 : Devanagari Vowel Sign U
-            0x02de,  // U+0942 : Devanagari Vowel Sign Uu
-            0x02df,  // U+0943 : Devanagari Vowel Sign Vocalic R
-            0x12df,  // U+0944 : Devanagari Vowel Sign Vocalic Rr
-            0x02e3,  // U+0945 : Devanagari Vowel Sign Candra E
-            0x02e0,  // U+0946 : Devanagari Vowel Sign Short E
-            0x02e1,  // U+0947 : Devanagari Vowel Sign E
-            0x02e2,  // U+0948 : Devanagari Vowel Sign Ai
-            0x02e7,  // U+0949 : Devanagari Vowel Sign Candra O
-            0x02e4,  // U+094a : Devanagari Vowel Sign Short O
-            0x02e5,  // U+094b : Devanagari Vowel Sign O
-            0x02e6,  // U+094c : Devanagari Vowel Sign Au
-            0x02e8,  // U+094d : Devanagari Sign Virama
-            0x0000,  // U+094e : Undefined
-            0x0000,  // U+094f : Undefined
-            0x12a1,  // U+0950 : Devanagari Om
-            0x0000,  // U+0951 : Devanagari Stress Sign Udatta
-            0x22f0,  // U+0952 : Devanagari Stress Sign Anudatta
-            0x0000,  // U+0953 : Devanagari Grave Accent
-            0x0000,  // U+0954 : Devanagari Acute Accent
-            0x0000,  // U+0955 : Undefined
-            0x0000,  // U+0956 : Undefined
-            0x0000,  // U+0957 : Undefined
-            0x12b3,  // U+0958 : Devanagari Letter Qa
-            0x12b4,  // U+0959 : Devanagari Letter Khha
-            0x12b5,  // U+095a : Devanagari Letter Ghha
-            0x12ba,  // U+095b : Devanagari Letter Za
-            0x12bf,  // U+095c : Devanagari Letter Dddha
-            0x12c0,  // U+095d : Devanagari Letter Rha
-            0x12c9,  // U+095e : Devanagari Letter Fa
-            0x02ce,  // U+095f : Devanagari Letter Yya
-            0x12aa,  // U+0960 : Devanagari Letter Vocalic Rr
-            0x12a7,  // U+0961 : Devanagari Letter Vocalic Ll
-            0x12db,  // U+0962 : Devanagari Vowel Sign Vocalic L
-            0x12dc,  // U+0963 : Devanagari Vowel Sign Vocalic Ll
-            0x02ea,  // U+0964 : Devanagari Danda
-            0x0000,  // U+0965 : Devanagari Double Danda
-            0x02f1,  // U+0966 : Devanagari Digit Zero
-            0x02f2,  // U+0967 : Devanagari Digit One
-            0x02f3,  // U+0968 : Devanagari Digit Two
-            0x02f4,  // U+0969 : Devanagari Digit Three
-            0x02f5,  // U+096a : Devanagari Digit Four
-            0x02f6,  // U+096b : Devanagari Digit Five
-            0x02f7,  // U+096c : Devanagari Digit Six
-            0x02f8,  // U+096d : Devanagari Digit Seven
-            0x02f9,  // U+096e : Devanagari Digit Eight
-            0x02fa,  // U+096f : Devanagari Digit Nine
-            0x32f0,  // U+0970 : Devanagari Abbreviation Sign
-            0x0000,  // U+0971 : Undefined
-            0x0000,  // U+0972 : Undefined
-            0x0000,  // U+0973 : Undefined
-            0x0000,  // U+0974 : Undefined
-            0x0000,  // U+0975 : Undefined
-            0x0000,  // U+0976 : Undefined
-            0x0000,  // U+0977 : Undefined
-            0x0000,  // U+0978 : Undefined
-            0x0000,  // U+0979 : Undefined
-            0x0000,  // U+097a : Undefined
-            0x0000,  // U+097b : Undefined
-            0x0000,  // U+097c : Undefined
-            0x0000,  // U+097d : Undefined
-            0x0000,  // U+097e : Undefined
-            0x0000,  // U+097f : Undefined
-            0x0000,  // U+0980 : Undefined
-            0x03a1,  // U+0981 : Bengali Sign Candrabindu
-            0x03a2,  // U+0982 : Bengali Sign Anusvara
-            0x03a3,  // U+0983 : Bengali Sign Visarga
-            0x0000,  // U+0984 : Undefined
-            0x03a4,  // U+0985 : Bengali Letter A
-            0x03a5,  // U+0986 : Bengali Letter Aa
-            0x03a6,  // U+0987 : Bengali Letter I
-            0x03a7,  // U+0988 : Bengali Letter Ii
-            0x03a8,  // U+0989 : Bengali Letter U
-            0x03a9,  // U+098a : Bengali Letter Uu
-            0x03aa,  // U+098b : Bengali Letter Vocalic R
-            0x13a6,  // U+098c : Bengali Letter Vocalic L
-            0x0000,  // U+098d : Undefined
-            0x0000,  // U+098e : Undefined
-            0x03ab,  // U+098f : Bengali Letter E
-            0x03ad,  // U+0990 : Bengali Letter Ai
-            0x0000,  // U+0991 : Undefined
-            0x0000,  // U+0992 : Undefined
-            0x03af,  // U+0993 : Bengali Letter O
-            0x03b1,  // U+0994 : Bengali Letter Au
-            0x03b3,  // U+0995 : Bengali Letter Ka
-            0x03b4,  // U+0996 : Bengali Letter Kha
-            0x03b5,  // U+0997 : Bengali Letter Ga
-            0x03b6,  // U+0998 : Bengali Letter Gha
-            0x03b7,  // U+0999 : Bengali Letter Nga
-            0x03b8,  // U+099a : Bengali Letter Ca
-            0x03b9,  // U+099b : Bengali Letter Cha
-            0x03ba,  // U+099c : Bengali Letter Ja
-            0x03bb,  // U+099d : Bengali Letter Jha
-            0x03bc,  // U+099e : Bengali Letter Nya
-            0x03bd,  // U+099f : Bengali Letter Tta
-            0x03be,  // U+09a0 : Bengali Letter Ttha
-            0x03bf,  // U+09a1 : Bengali Letter Dda
-            0x03c0,  // U+09a2 : Bengali Letter Ddha
-            0x03c1,  // U+09a3 : Bengali Letter Nna
-            0x03c2,  // U+09a4 : Bengali Letter Ta
-            0x03c3,  // U+09a5 : Bengali Letter Tha
-            0x03c4,  // U+09a6 : Bengali Letter Da
-            0x03c5,  // U+09a7 : Bengali Letter Dha
-            0x03c6,  // U+09a8 : Bengali Letter Na
-            0x0000,  // U+09a9 : Undefined
-            0x03c8,  // U+09aa : Bengali Letter Pa
-            0x03c9,  // U+09ab : Bengali Letter Pha
-            0x03ca,  // U+09ac : Bengali Letter Ba
-            0x03cb,  // U+09ad : Bengali Letter Bha
-            0x03cc,  // U+09ae : Bengali Letter Ma
-            0x03cd,  // U+09af : Bengali Letter Ya
-            0x03cf,  // U+09b0 : Bengali Letter Ra
-            0x0000,  // U+09b1 : Undefined
-            0x03d1,  // U+09b2 : Bengali Letter La
-            0x0000,  // U+09b3 : Undefined
-            0x0000,  // U+09b4 : Undefined
-            0x0000,  // U+09b5 : Undefined
-            0x03d5,  // U+09b6 : Bengali Letter Sha
-            0x03d6,  // U+09b7 : Bengali Letter Ssa
-            0x03d7,  // U+09b8 : Bengali Letter Sa
-            0x03d8,  // U+09b9 : Bengali Letter Ha
-            0x0000,  // U+09ba : Undefined
-            0x0000,  // U+09bb : Undefined
-            0x03e9,  // U+09bc : Bengali Sign Nukta
-            0x0000,  // U+09bd : Undefined
-            0x03da,  // U+09be : Bengali Vowel Sign Aa
-            0x03db,  // U+09bf : Bengali Vowel Sign I
-            0x03dc,  // U+09c0 : Bengali Vowel Sign Ii
-            0x03dd,  // U+09c1 : Bengali Vowel Sign U
-            0x03de,  // U+09c2 : Bengali Vowel Sign Uu
-            0x03df,  // U+09c3 : Bengali Vowel Sign Vocalic R
-            0x13df,  // U+09c4 : Bengali Vowel Sign Vocalic Rr
-            0x0000,  // U+09c5 : Undefined
-            0x0000,  // U+09c6 : Undefined
-            0x03e0,  // U+09c7 : Bengali Vowel Sign E
-            0x03e2,  // U+09c8 : Bengali Vowel Sign Ai
-            0x0000,  // U+09c9 : Undefined
-            0x0000,  // U+09ca : Undefined
-            0x03e4,  // U+09cb : Bengali Vowel Sign O
-            0x03e6,  // U+09cc : Bengali Vowel Sign Au
-            0x03e8,  // U+09cd : Bengali Sign Virama
-            0x0000,  // U+09ce : Undefined
-            0x0000,  // U+09cf : Undefined
-            0x0000,  // U+09d0 : Undefined
-            0x0000,  // U+09d1 : Undefined
-            0x0000,  // U+09d2 : Undefined
-            0x0000,  // U+09d3 : Undefined
-            0x0000,  // U+09d4 : Undefined
-            0x0000,  // U+09d5 : Undefined
-            0x0000,  // U+09d6 : Undefined
-            0x0000,  // U+09d7 : Bengali Au Length Mark
-            0x0000,  // U+09d8 : Undefined
-            0x0000,  // U+09d9 : Undefined
-            0x0000,  // U+09da : Undefined
-            0x0000,  // U+09db : Undefined
-            0x13bf,  // U+09dc : Bengali Letter Rra
-            0x13c0,  // U+09dd : Bengali Letter Rha
-            0x0000,  // U+09de : Undefined
-            0x03ce,  // U+09df : Bengali Letter Yya
-            0x13aa,  // U+09e0 : Bengali Letter Vocalic Rr
-            0x13a7,  // U+09e1 : Bengali Letter Vocalic Ll
-            0x13db,  // U+09e2 : Bengali Vowel Sign Vocalic L
-            0x13dc,  // U+09e3 : Bengali Vowel Sign Vocalic Ll
-            0x0000,  // U+09e4 : Undefined
-            0x0000,  // U+09e5 : Undefined
-            0x03f1,  // U+09e6 : Bengali Digit Zero
-            0x03f2,  // U+09e7 : Bengali Digit One
-            0x03f3,  // U+09e8 : Bengali Digit Two
-            0x03f4,  // U+09e9 : Bengali Digit Three
-            0x03f5,  // U+09ea : Bengali Digit Four
-            0x03f6,  // U+09eb : Bengali Digit Five
-            0x03f7,  // U+09ec : Bengali Digit Six
-            0x03f8,  // U+09ed : Bengali Digit Seven
-            0x03f9,  // U+09ee : Bengali Digit Eight
-            0x03fa,  // U+09ef : Bengali Digit Nine
-            0x0000,  // U+09f0 : Bengali Letter Ra With Middle Diagonal
-            0x0000,  // U+09f1 : Bengali Letter Ra With Lower Diagonal
-            0x0000,  // U+09f2 : Bengali Rupee Mark
-            0x0000,  // U+09f3 : Bengali Rupee Sign
-            0x0000,  // U+09f4 : Bengali Currency Numerator One
-            0x0000,  // U+09f5 : Bengali Currency Numerator Two
-            0x0000,  // U+09f6 : Bengali Currency Numerator Three
-            0x0000,  // U+09f7 : Bengali Currency Numerator Four
-            0x0000,  // U+09f8 : Bengali Currency Numerator One Less Than The Denominator
-            0x0000,  // U+09f9 : Bengali Currency Denominator Sixteen
-            0x0000,  // U+09fa : Bengali Isshar
-            0x0000,  // U+09fb : Undefined
-            0x0000,  // U+09fc : Undefined
-            0x0000,  // U+09fd : Undefined
-            0x0000,  // U+09fe : Undefined
-            0x0000,  // U+09ff : Undefined
-            0x0000,  // U+0a00 : Undefined
-            0x0000,  // U+0a01 : Undefined
-            0x0ba2,  // U+0a02 : Gurmukhi Sign Bindi
-            0x0000,  // U+0a03 : Undefined
-            0x0000,  // U+0a04 : Undefined
-            0x0ba4,  // U+0a05 : Gurmukhi Letter A
-            0x0ba5,  // U+0a06 : Gurmukhi Letter Aa
-            0x0ba6,  // U+0a07 : Gurmukhi Letter I
-            0x0ba7,  // U+0a08 : Gurmukhi Letter Ii
-            0x0ba8,  // U+0a09 : Gurmukhi Letter U
-            0x0ba9,  // U+0a0a : Gurmukhi Letter Uu
-            0x0000,  // U+0a0b : Undefined
-            0x0000,  // U+0a0c : Undefined
-            0x0000,  // U+0a0d : Undefined
-            0x0000,  // U+0a0e : Undefined
-            0x0bab,  // U+0a0f : Gurmukhi Letter Ee
-            0x0bad,  // U+0a10 : Gurmukhi Letter Ai
-            0x0000,  // U+0a11 : Undefined
-            0x0000,  // U+0a12 : Undefined
-            0x0bb0,  // U+0a13 : Gurmukhi Letter Oo
-            0x0bb1,  // U+0a14 : Gurmukhi Letter Au
-            0x0bb3,  // U+0a15 : Gurmukhi Letter Ka
-            0x0bb4,  // U+0a16 : Gurmukhi Letter Kha
-            0x0bb5,  // U+0a17 : Gurmukhi Letter Ga
-            0x0bb6,  // U+0a18 : Gurmukhi Letter Gha
-            0x0bb7,  // U+0a19 : Gurmukhi Letter Nga
-            0x0bb8,  // U+0a1a : Gurmukhi Letter Ca
-            0x0bb9,  // U+0a1b : Gurmukhi Letter Cha
-            0x0bba,  // U+0a1c : Gurmukhi Letter Ja
-            0x0bbb,  // U+0a1d : Gurmukhi Letter Jha
-            0x0bbc,  // U+0a1e : Gurmukhi Letter Nya
-            0x0bbd,  // U+0a1f : Gurmukhi Letter Tta
-            0x0bbe,  // U+0a20 : Gurmukhi Letter Ttha
-            0x0bbf,  // U+0a21 : Gurmukhi Letter Dda
-            0x0bc0,  // U+0a22 : Gurmukhi Letter Ddha
-            0x0bc1,  // U+0a23 : Gurmukhi Letter Nna
-            0x0bc2,  // U+0a24 : Gurmukhi Letter Ta
-            0x0bc3,  // U+0a25 : Gurmukhi Letter Tha
-            0x0bc4,  // U+0a26 : Gurmukhi Letter Da
-            0x0bc5,  // U+0a27 : Gurmukhi Letter Dha
-            0x0bc6,  // U+0a28 : Gurmukhi Letter Na
-            0x0000,  // U+0a29 : Undefined
-            0x0bc8,  // U+0a2a : Gurmukhi Letter Pa
-            0x0bc9,  // U+0a2b : Gurmukhi Letter Pha
-            0x0bca,  // U+0a2c : Gurmukhi Letter Ba
-            0x0bcb,  // U+0a2d : Gurmukhi Letter Bha
-            0x0bcc,  // U+0a2e : Gurmukhi Letter Ma
-            0x0bcd,  // U+0a2f : Gurmukhi Letter Ya
-            0x0bcf,  // U+0a30 : Gurmukhi Letter Ra
-            0x0000,  // U+0a31 : Undefined
-            0x0bd1,  // U+0a32 : Gurmukhi Letter La
-            0x0bd2,  // U+0a33 : Gurmukhi Letter Lla
-            0x0000,  // U+0a34 : Undefined
-            0x0bd4,  // U+0a35 : Gurmukhi Letter Va
-            0x0bd5,  // U+0a36 : Gurmukhi Letter Sha
-            0x0000,  // U+0a37 : Undefined
-            0x0bd7,  // U+0a38 : Gurmukhi Letter Sa
-            0x0bd8,  // U+0a39 : Gurmukhi Letter Ha
-            0x0000,  // U+0a3a : Undefined
-            0x0000,  // U+0a3b : Undefined
-            0x0be9,  // U+0a3c : Gurmukhi Sign Nukta
-            0x0000,  // U+0a3d : Undefined
-            0x0bda,  // U+0a3e : Gurmukhi Vowel Sign Aa
-            0x0bdb,  // U+0a3f : Gurmukhi Vowel Sign I
-            0x0bdc,  // U+0a40 : Gurmukhi Vowel Sign Ii
-            0x0bdd,  // U+0a41 : Gurmukhi Vowel Sign U
-            0x0bde,  // U+0a42 : Gurmukhi Vowel Sign Uu
-            0x0000,  // U+0a43 : Undefined
-            0x0000,  // U+0a44 : Undefined
-            0x0000,  // U+0a45 : Undefined
-            0x0000,  // U+0a46 : Undefined
-            0x0be0,  // U+0a47 : Gurmukhi Vowel Sign Ee
-            0x0be2,  // U+0a48 : Gurmukhi Vowel Sign Ai
-            0x0000,  // U+0a49 : Undefined
-            0x0000,  // U+0a4a : Undefined
-            0x0be4,  // U+0a4b : Gurmukhi Vowel Sign Oo
-            0x0be6,  // U+0a4c : Gurmukhi Vowel Sign Au
-            0x0be8,  // U+0a4d : Gurmukhi Sign Virama
-            0x0000,  // U+0a4e : Undefined
-            0x0000,  // U+0a4f : Undefined
-            0x0000,  // U+0a50 : Undefined
-            0x0000,  // U+0a51 : Undefined
-            0x0000,  // U+0a52 : Undefined
-            0x0000,  // U+0a53 : Undefined
-            0x0000,  // U+0a54 : Undefined
-            0x0000,  // U+0a55 : Undefined
-            0x0000,  // U+0a56 : Undefined
-            0x0000,  // U+0a57 : Undefined
-            0x0000,  // U+0a58 : Undefined
-            0x1bb4,  // U+0a59 : Gurmukhi Letter Khha
-            0x1bb5,  // U+0a5a : Gurmukhi Letter Ghha
-            0x1bba,  // U+0a5b : Gurmukhi Letter Za
-            0x1bc0,  // U+0a5c : Gurmukhi Letter Rra
-            0x0000,  // U+0a5d : Undefined
-            0x1bc9,  // U+0a5e : Gurmukhi Letter Fa
-            0x0000,  // U+0a5f : Undefined
-            0x0000,  // U+0a60 : Undefined
-            0x0000,  // U+0a61 : Undefined
-            0x0000,  // U+0a62 : Undefined
-            0x0000,  // U+0a63 : Undefined
-            0x0000,  // U+0a64 : Undefined
-            0x0000,  // U+0a65 : Undefined
-            0x0bf1,  // U+0a66 : Gurmukhi Digit Zero
-            0x0bf2,  // U+0a67 : Gurmukhi Digit One
-            0x0bf3,  // U+0a68 : Gurmukhi Digit Two
-            0x0bf4,  // U+0a69 : Gurmukhi Digit Three
-            0x0bf5,  // U+0a6a : Gurmukhi Digit Four
-            0x0bf6,  // U+0a6b : Gurmukhi Digit Five
-            0x0bf7,  // U+0a6c : Gurmukhi Digit Six
-            0x0bf8,  // U+0a6d : Gurmukhi Digit Seven
-            0x0bf9,  // U+0a6e : Gurmukhi Digit Eight
-            0x0bfa,  // U+0a6f : Gurmukhi Digit Nine
-            0x0000,  // U+0a70 : Gurmukhi Tippi
-            0x0000,  // U+0a71 : Gurmukhi Addak
-            0x0000,  // U+0a72 : Gurmukhi Iri
-            0x0000,  // U+0a73 : Gurmukhi Ura
-            0x0000,  // U+0a74 : Gurmukhi Ek Onkar
-            0x0000,  // U+0a75 : Undefined
-            0x0000,  // U+0a76 : Undefined
-            0x0000,  // U+0a77 : Undefined
-            0x0000,  // U+0a78 : Undefined
-            0x0000,  // U+0a79 : Undefined
-            0x0000,  // U+0a7a : Undefined
-            0x0000,  // U+0a7b : Undefined
-            0x0000,  // U+0a7c : Undefined
-            0x0000,  // U+0a7d : Undefined
-            0x0000,  // U+0a7e : Undefined
-            0x0000,  // U+0a7f : Undefined
-            0x0000,  // U+0a80 : Undefined
-            0x0aa1,  // U+0a81 : Gujarati Sign Candrabindu
-            0x0aa2,  // U+0a82 : Gujarati Sign Anusvara
-            0x0aa3,  // U+0a83 : Gujarati Sign Visarga
-            0x0000,  // U+0a84 : Undefined
-            0x0aa4,  // U+0a85 : Gujarati Letter A
-            0x0aa5,  // U+0a86 : Gujarati Letter Aa
-            0x0aa6,  // U+0a87 : Gujarati Letter I
-            0x0aa7,  // U+0a88 : Gujarati Letter Ii
-            0x0aa8,  // U+0a89 : Gujarati Letter U
-            0x0aa9,  // U+0a8a : Gujarati Letter Uu
-            0x0aaa,  // U+0a8b : Gujarati Letter Vocalic R
-            0x0000,  // U+0a8c : Undefined
-            0x0aae,  // U+0a8d : Gujarati Vowel Candra E
-            0x0000,  // U+0a8e : Undefined
-            0x0aab,  // U+0a8f : Gujarati Letter E
-            0x0aad,  // U+0a90 : Gujarati Letter Ai
-            0x0ab2,  // U+0a91 : Gujarati Vowel Candra O
-            0x0000,  // U+0a92 : Undefined
-            0x0ab0,  // U+0a93 : Gujarati Letter O
-            0x0ab1,  // U+0a94 : Gujarati Letter Au
-            0x0ab3,  // U+0a95 : Gujarati Letter Ka
-            0x0ab4,  // U+0a96 : Gujarati Letter Kha
-            0x0ab5,  // U+0a97 : Gujarati Letter Ga
-            0x0ab6,  // U+0a98 : Gujarati Letter Gha
-            0x0ab7,  // U+0a99 : Gujarati Letter Nga
-            0x0ab8,  // U+0a9a : Gujarati Letter Ca
-            0x0ab9,  // U+0a9b : Gujarati Letter Cha
-            0x0aba,  // U+0a9c : Gujarati Letter Ja
-            0x0abb,  // U+0a9d : Gujarati Letter Jha
-            0x0abc,  // U+0a9e : Gujarati Letter Nya
-            0x0abd,  // U+0a9f : Gujarati Letter Tta
-            0x0abe,  // U+0aa0 : Gujarati Letter Ttha
-            0x0abf,  // U+0aa1 : Gujarati Letter Dda
-            0x0ac0,  // U+0aa2 : Gujarati Letter Ddha
-            0x0ac1,  // U+0aa3 : Gujarati Letter Nna
-            0x0ac2,  // U+0aa4 : Gujarati Letter Ta
-            0x0ac3,  // U+0aa5 : Gujarati Letter Tha
-            0x0ac4,  // U+0aa6 : Gujarati Letter Da
-            0x0ac5,  // U+0aa7 : Gujarati Letter Dha
-            0x0ac6,  // U+0aa8 : Gujarati Letter Na
-            0x0000,  // U+0aa9 : Undefined
-            0x0ac8,  // U+0aaa : Gujarati Letter Pa
-            0x0ac9,  // U+0aab : Gujarati Letter Pha
-            0x0aca,  // U+0aac : Gujarati Letter Ba
-            0x0acb,  // U+0aad : Gujarati Letter Bha
-            0x0acc,  // U+0aae : Gujarati Letter Ma
-            0x0acd,  // U+0aaf : Gujarati Letter Ya
-            0x0acf,  // U+0ab0 : Gujarati Letter Ra
-            0x0000,  // U+0ab1 : Undefined
-            0x0ad1,  // U+0ab2 : Gujarati Letter La
-            0x0ad2,  // U+0ab3 : Gujarati Letter Lla
-            0x0000,  // U+0ab4 : Undefined
-            0x0ad4,  // U+0ab5 : Gujarati Letter Va
-            0x0ad5,  // U+0ab6 : Gujarati Letter Sha
-            0x0ad6,  // U+0ab7 : Gujarati Letter Ssa
-            0x0ad7,  // U+0ab8 : Gujarati Letter Sa
-            0x0ad8,  // U+0ab9 : Gujarati Letter Ha
-            0x0000,  // U+0aba : Undefined
-            0x0000,  // U+0abb : Undefined
-            0x0ae9,  // U+0abc : Gujarati Sign Nukta
-            0x1aea,  // U+0abd : Gujarati Sign Avagraha
-            0x0ada,  // U+0abe : Gujarati Vowel Sign Aa
-            0x0adb,  // U+0abf : Gujarati Vowel Sign I
-            0x0adc,  // U+0ac0 : Gujarati Vowel Sign Ii
-            0x0add,  // U+0ac1 : Gujarati Vowel Sign U
-            0x0ade,  // U+0ac2 : Gujarati Vowel Sign Uu
-            0x0adf,  // U+0ac3 : Gujarati Vowel Sign Vocalic R
-            0x1adf,  // U+0ac4 : Gujarati Vowel Sign Vocalic Rr
-            0x0ae3,  // U+0ac5 : Gujarati Vowel Sign Candra E
-            0x0000,  // U+0ac6 : Undefined
-            0x0ae0,  // U+0ac7 : Gujarati Vowel Sign E
-            0x0ae2,  // U+0ac8 : Gujarati Vowel Sign Ai
-            0x0ae7,  // U+0ac9 : Gujarati Vowel Sign Candra O
-            0x0000,  // U+0aca : Undefined
-            0x0ae4,  // U+0acb : Gujarati Vowel Sign O
-            0x0ae6,  // U+0acc : Gujarati Vowel Sign Au
-            0x0ae8,  // U+0acd : Gujarati Sign Virama
-            0x0000,  // U+0ace : Undefined
-            0x0000,  // U+0acf : Undefined
-            0x1aa1,  // U+0ad0 : Gujarati Om
-            0x0000,  // U+0ad1 : Undefined
-            0x0000,  // U+0ad2 : Undefined
-            0x0000,  // U+0ad3 : Undefined
-            0x0000,  // U+0ad4 : Undefined
-            0x0000,  // U+0ad5 : Undefined
-            0x0000,  // U+0ad6 : Undefined
-            0x0000,  // U+0ad7 : Undefined
-            0x0000,  // U+0ad8 : Undefined
-            0x0000,  // U+0ad9 : Undefined
-            0x0000,  // U+0ada : Undefined
-            0x0000,  // U+0adb : Undefined
-            0x0000,  // U+0adc : Undefined
-            0x0000,  // U+0add : Undefined
-            0x0000,  // U+0ade : Undefined
-            0x0000,  // U+0adf : Undefined
-            0x1aaa,  // U+0ae0 : Gujarati Letter Vocalic Rr
-            0x0000,  // U+0ae1 : Undefined
-            0x0000,  // U+0ae2 : Undefined
-            0x0000,  // U+0ae3 : Undefined
-            0x0000,  // U+0ae4 : Undefined
-            0x0000,  // U+0ae5 : Undefined
-            0x0af1,  // U+0ae6 : Gujarati Digit Zero
-            0x0af2,  // U+0ae7 : Gujarati Digit One
-            0x0af3,  // U+0ae8 : Gujarati Digit Two
-            0x0af4,  // U+0ae9 : Gujarati Digit Three
-            0x0af5,  // U+0aea : Gujarati Digit Four
-            0x0af6,  // U+0aeb : Gujarati Digit Five
-            0x0af7,  // U+0aec : Gujarati Digit Six
-            0x0af8,  // U+0aed : Gujarati Digit Seven
-            0x0af9,  // U+0aee : Gujarati Digit Eight
-            0x0afa,  // U+0aef : Gujarati Digit Nine
-            0x0000,  // U+0af0 : Undefined
-            0x0000,  // U+0af1 : Undefined
-            0x0000,  // U+0af2 : Undefined
-            0x0000,  // U+0af3 : Undefined
-            0x0000,  // U+0af4 : Undefined
-            0x0000,  // U+0af5 : Undefined
-            0x0000,  // U+0af6 : Undefined
-            0x0000,  // U+0af7 : Undefined
-            0x0000,  // U+0af8 : Undefined
-            0x0000,  // U+0af9 : Undefined
-            0x0000,  // U+0afa : Undefined
-            0x0000,  // U+0afb : Undefined
-            0x0000,  // U+0afc : Undefined
-            0x0000,  // U+0afd : Undefined
-            0x0000,  // U+0afe : Undefined
-            0x0000,  // U+0aff : Undefined
-            0x0000,  // U+0b00 : Undefined
-            0x07a1,  // U+0b01 : Oriya Sign Candrabindu
-            0x07a2,  // U+0b02 : Oriya Sign Anusvara
-            0x07a3,  // U+0b03 : Oriya Sign Visarga
-            0x0000,  // U+0b04 : Undefined
-            0x07a4,  // U+0b05 : Oriya Letter A
-            0x07a5,  // U+0b06 : Oriya Letter Aa
-            0x07a6,  // U+0b07 : Oriya Letter I
-            0x07a7,  // U+0b08 : Oriya Letter Ii
-            0x07a8,  // U+0b09 : Oriya Letter U
-            0x07a9,  // U+0b0a : Oriya Letter Uu
-            0x07aa,  // U+0b0b : Oriya Letter Vocalic R
-            0x17a6,  // U+0b0c : Oriya Letter Vocalic L
-            0x0000,  // U+0b0d : Undefined
-            0x0000,  // U+0b0e : Undefined
-            0x07ab,  // U+0b0f : Oriya Letter E
-            0x07ad,  // U+0b10 : Oriya Letter Ai
-            0x0000,  // U+0b11 : Undefined
-            0x0000,  // U+0b12 : Undefined
-            0x07b0,  // U+0b13 : Oriya Letter O
-            0x07b1,  // U+0b14 : Oriya Letter Au
-            0x07b3,  // U+0b15 : Oriya Letter Ka
-            0x07b4,  // U+0b16 : Oriya Letter Kha
-            0x07b5,  // U+0b17 : Oriya Letter Ga
-            0x07b6,  // U+0b18 : Oriya Letter Gha
-            0x07b7,  // U+0b19 : Oriya Letter Nga
-            0x07b8,  // U+0b1a : Oriya Letter Ca
-            0x07b9,  // U+0b1b : Oriya Letter Cha
-            0x07ba,  // U+0b1c : Oriya Letter Ja
-            0x07bb,  // U+0b1d : Oriya Letter Jha
-            0x07bc,  // U+0b1e : Oriya Letter Nya
-            0x07bd,  // U+0b1f : Oriya Letter Tta
-            0x07be,  // U+0b20 : Oriya Letter Ttha
-            0x07bf,  // U+0b21 : Oriya Letter Dda
-            0x07c0,  // U+0b22 : Oriya Letter Ddha
-            0x07c1,  // U+0b23 : Oriya Letter Nna
-            0x07c2,  // U+0b24 : Oriya Letter Ta
-            0x07c3,  // U+0b25 : Oriya Letter Tha
-            0x07c4,  // U+0b26 : Oriya Letter Da
-            0x07c5,  // U+0b27 : Oriya Letter Dha
-            0x07c6,  // U+0b28 : Oriya Letter Na
-            0x0000,  // U+0b29 : Undefined
-            0x07c8,  // U+0b2a : Oriya Letter Pa
-            0x07c9,  // U+0b2b : Oriya Letter Pha
-            0x07ca,  // U+0b2c : Oriya Letter Ba
-            0x07cb,  // U+0b2d : Oriya Letter Bha
-            0x07cc,  // U+0b2e : Oriya Letter Ma
-            0x07cd,  // U+0b2f : Oriya Letter Ya
-            0x07cf,  // U+0b30 : Oriya Letter Ra
-            0x0000,  // U+0b31 : Undefined
-            0x07d1,  // U+0b32 : Oriya Letter La
-            0x07d2,  // U+0b33 : Oriya Letter Lla
-            0x0000,  // U+0b34 : Undefined
-            0x0000,  // U+0b35 : Undefined
-            0x07d5,  // U+0b36 : Oriya Letter Sha
-            0x07d6,  // U+0b37 : Oriya Letter Ssa
-            0x07d7,  // U+0b38 : Oriya Letter Sa
-            0x07d8,  // U+0b39 : Oriya Letter Ha
-            0x0000,  // U+0b3a : Undefined
-            0x0000,  // U+0b3b : Undefined
-            0x07e9,  // U+0b3c : Oriya Sign Nukta
-            0x17ea,  // U+0b3d : Oriya Sign Avagraha
-            0x07da,  // U+0b3e : Oriya Vowel Sign Aa
-            0x07db,  // U+0b3f : Oriya Vowel Sign I
-            0x07dc,  // U+0b40 : Oriya Vowel Sign Ii
-            0x07dd,  // U+0b41 : Oriya Vowel Sign U
-            0x07de,  // U+0b42 : Oriya Vowel Sign Uu
-            0x07df,  // U+0b43 : Oriya Vowel Sign Vocalic R
-            0x0000,  // U+0b44 : Undefined
-            0x0000,  // U+0b45 : Undefined
-            0x0000,  // U+0b46 : Undefined
-            0x07e0,  // U+0b47 : Oriya Vowel Sign E
-            0x07e2,  // U+0b48 : Oriya Vowel Sign Ai
-            0x0000,  // U+0b49 : Undefined
-            0x0000,  // U+0b4a : Undefined
-            0x07e4,  // U+0b4b : Oriya Vowel Sign O
-            0x07e6,  // U+0b4c : Oriya Vowel Sign Au
-            0x07e8,  // U+0b4d : Oriya Sign Virama
-            0x0000,  // U+0b4e : Undefined
-            0x0000,  // U+0b4f : Undefined
-            0x0000,  // U+0b50 : Undefined
-            0x0000,  // U+0b51 : Undefined
-            0x0000,  // U+0b52 : Undefined
-            0x0000,  // U+0b53 : Undefined
-            0x0000,  // U+0b54 : Undefined
-            0x0000,  // U+0b55 : Undefined
-            0x0000,  // U+0b56 : Oriya Ai Length Mark
-            0x0000,  // U+0b57 : Oriya Au Length Mark
-            0x0000,  // U+0b58 : Undefined
-            0x0000,  // U+0b59 : Undefined
-            0x0000,  // U+0b5a : Undefined
-            0x0000,  // U+0b5b : Undefined
-            0x17bf,  // U+0b5c : Oriya Letter Rra
-            0x17c0,  // U+0b5d : Oriya Letter Rha
-            0x0000,  // U+0b5e : Undefined
-            0x07ce,  // U+0b5f : Oriya Letter Yya
-            0x17aa,  // U+0b60 : Oriya Letter Vocalic Rr
-            0x17a7,  // U+0b61 : Oriya Letter Vocalic Ll
-            0x0000,  // U+0b62 : Undefined
-            0x0000,  // U+0b63 : Undefined
-            0x0000,  // U+0b64 : Undefined
-            0x0000,  // U+0b65 : Undefined
-            0x07f1,  // U+0b66 : Oriya Digit Zero
-            0x07f2,  // U+0b67 : Oriya Digit One
-            0x07f3,  // U+0b68 : Oriya Digit Two
-            0x07f4,  // U+0b69 : Oriya Digit Three
-            0x07f5,  // U+0b6a : Oriya Digit Four
-            0x07f6,  // U+0b6b : Oriya Digit Five
-            0x07f7,  // U+0b6c : Oriya Digit Six
-            0x07f8,  // U+0b6d : Oriya Digit Seven
-            0x07f9,  // U+0b6e : Oriya Digit Eight
-            0x07fa,  // U+0b6f : Oriya Digit Nine
-            0x0000,  // U+0b70 : Oriya Isshar
-            0x0000,  // U+0b71 : Undefined
-            0x0000,  // U+0b72 : Undefined
-            0x0000,  // U+0b73 : Undefined
-            0x0000,  // U+0b74 : Undefined
-            0x0000,  // U+0b75 : Undefined
-            0x0000,  // U+0b76 : Undefined
-            0x0000,  // U+0b77 : Undefined
-            0x0000,  // U+0b78 : Undefined
-            0x0000,  // U+0b79 : Undefined
-            0x0000,  // U+0b7a : Undefined
-            0x0000,  // U+0b7b : Undefined
-            0x0000,  // U+0b7c : Undefined
-            0x0000,  // U+0b7d : Undefined
-            0x0000,  // U+0b7e : Undefined
-            0x0000,  // U+0b7f : Undefined
-            0x0000,  // U+0b80 : Undefined
-            0x0000,  // U+0b81 : Undefined
-            0x04a2,  // U+0b82 : Tamil Sign Anusvara
-            0x04a3,  // U+0b83 : Tamil Sign Visarga
-            0x0000,  // U+0b84 : Undefined
-            0x04a4,  // U+0b85 : Tamil Letter A
-            0x04a5,  // U+0b86 : Tamil Letter Aa
-            0x04a6,  // U+0b87 : Tamil Letter I
-            0x04a7,  // U+0b88 : Tamil Letter Ii
-            0x04a8,  // U+0b89 : Tamil Letter U
-            0x04a9,  // U+0b8a : Tamil Letter Uu
-            0x0000,  // U+0b8b : Undefined
-            0x0000,  // U+0b8c : Undefined
-            0x0000,  // U+0b8d : Undefined
-            0x0000,  // U+0b8e : Tamil Letter E
-            0x04ab,  // U+0b8f : Tamil Letter Ee
-            0x04ad,  // U+0b90 : Tamil Letter Ai
-            0x0000,  // U+0b91 : Undefined
-            0x04af,  // U+0b92 : Tamil Letter O
-            0x04b0,  // U+0b93 : Tamil Letter Oo
-            0x04b1,  // U+0b94 : Tamil Letter Au
-            0x04b3,  // U+0b95 : Tamil Letter Ka
-            0x0000,  // U+0b96 : Undefined
-            0x0000,  // U+0b97 : Undefined
-            0x0000,  // U+0b98 : Undefined
-            0x04b7,  // U+0b99 : Tamil Letter Nga
-            0x04b8,  // U+0b9a : Tamil Letter Ca
-            0x0000,  // U+0b9b : Undefined
-            0x04ba,  // U+0b9c : Tamil Letter Ja
-            0x0000,  // U+0b9d : Undefined
-            0x04bc,  // U+0b9e : Tamil Letter Nya
-            0x04bd,  // U+0b9f : Tamil Letter Tta
-            0x0000,  // U+0ba0 : Undefined
-            0x0000,  // U+0ba1 : Undefined
-            0x0000,  // U+0ba2 : Undefined
-            0x04c1,  // U+0ba3 : Tamil Letter Nna
-            0x04c2,  // U+0ba4 : Tamil Letter Ta
-            0x0000,  // U+0ba5 : Undefined
-            0x0000,  // U+0ba6 : Undefined
-            0x0000,  // U+0ba7 : Undefined
-            0x04c6,  // U+0ba8 : Tamil Letter Na
-            0x04c7,  // U+0ba9 : Tamil Letter Nnna
-            0x04c8,  // U+0baa : Tamil Letter Pa
-            0x0000,  // U+0bab : Undefined
-            0x0000,  // U+0bac : Undefined
-            0x0000,  // U+0bad : Undefined
-            0x04cc,  // U+0bae : Tamil Letter Ma
-            0x04cd,  // U+0baf : Tamil Letter Ya
-            0x04cf,  // U+0bb0 : Tamil Letter Ra
-            0x04d0,  // U+0bb1 : Tamil Letter Rra
-            0x04d1,  // U+0bb2 : Tamil Letter La
-            0x04d2,  // U+0bb3 : Tamil Letter Lla
-            0x04d3,  // U+0bb4 : Tamil Letter Llla
-            0x04d4,  // U+0bb5 : Tamil Letter Va
-            0x0000,  // U+0bb6 : Undefined
-            0x04d5,  // U+0bb7 : Tamil Letter Ssa
-            0x04d7,  // U+0bb8 : Tamil Letter Sa
-            0x04d8,  // U+0bb9 : Tamil Letter Ha
-            0x0000,  // U+0bba : Undefined
-            0x0000,  // U+0bbb : Undefined
-            0x0000,  // U+0bbc : Undefined
-            0x0000,  // U+0bbd : Undefined
-            0x04da,  // U+0bbe : Tamil Vowel Sign Aa
-            0x04db,  // U+0bbf : Tamil Vowel Sign I
-            0x04dc,  // U+0bc0 : Tamil Vowel Sign Ii
-            0x04dd,  // U+0bc1 : Tamil Vowel Sign U
-            0x04de,  // U+0bc2 : Tamil Vowel Sign Uu
-            0x0000,  // U+0bc3 : Undefined
-            0x0000,  // U+0bc4 : Undefined
-            0x0000,  // U+0bc5 : Undefined
-            0x04e0,  // U+0bc6 : Tamil Vowel Sign E
-            0x04e1,  // U+0bc7 : Tamil Vowel Sign Ee
-            0x04e2,  // U+0bc8 : Tamil Vowel Sign Ai
-            0x0000,  // U+0bc9 : Undefined
-            0x04e4,  // U+0bca : Tamil Vowel Sign O
-            0x04e5,  // U+0bcb : Tamil Vowel Sign Oo
-            0x04e6,  // U+0bcc : Tamil Vowel Sign Au
-            0x04e8,  // U+0bcd : Tamil Sign Virama
-            0x0000,  // U+0bce : Undefined
-            0x0000,  // U+0bcf : Undefined
-            0x0000,  // U+0bd0 : Undefined
-            0x0000,  // U+0bd1 : Undefined
-            0x0000,  // U+0bd2 : Undefined
-            0x0000,  // U+0bd3 : Undefined
-            0x0000,  // U+0bd4 : Undefined
-            0x0000,  // U+0bd5 : Undefined
-            0x0000,  // U+0bd6 : Undefined
-            0x0000,  // U+0bd7 : Tamil Au Length Mark
-            0x0000,  // U+0bd8 : Undefined
-            0x0000,  // U+0bd9 : Undefined
-            0x0000,  // U+0bda : Undefined
-            0x0000,  // U+0bdb : Undefined
-            0x0000,  // U+0bdc : Undefined
-            0x0000,  // U+0bdd : Undefined
-            0x0000,  // U+0bde : Undefined
-            0x0000,  // U+0bdf : Undefined
-            0x0000,  // U+0be0 : Undefined
-            0x0000,  // U+0be1 : Undefined
-            0x0000,  // U+0be2 : Undefined
-            0x0000,  // U+0be3 : Undefined
-            0x0000,  // U+0be4 : Undefined
-            0x0000,  // U+0be5 : Undefined
-            0x0000,  // U+0be6 : Undefined
-            0x04f2,  // U+0be7 : Tamil Digit One
-            0x04f3,  // U+0be8 : Tamil Digit Two
-            0x04f4,  // U+0be9 : Tamil Digit Three
-            0x04f5,  // U+0bea : Tamil Digit Four
-            0x04f6,  // U+0beb : Tamil Digit Five
-            0x04f7,  // U+0bec : Tamil Digit Six
-            0x04f8,  // U+0bed : Tamil Digit Seven
-            0x04f9,  // U+0bee : Tamil Digit Eight
-            0x04fa,  // U+0bef : Tamil Digit Nine
-            0x0000,  // U+0bf0 : Tamil Number Ten
-            0x0000,  // U+0bf1 : Tamil Number One Hundred
-            0x0000,  // U+0bf2 : Tamil Number One Thousand
-            0x0000,  // U+0bf3 : Undefined
-            0x0000,  // U+0bf4 : Undefined
-            0x0000,  // U+0bf5 : Undefined
-            0x0000,  // U+0bf6 : Undefined
-            0x0000,  // U+0bf7 : Undefined
-            0x0000,  // U+0bf8 : Undefined
-            0x0000,  // U+0bf9 : Undefined
-            0x0000,  // U+0bfa : Undefined
-            0x0000,  // U+0bfb : Undefined
-            0x0000,  // U+0bfc : Undefined
-            0x0000,  // U+0bfd : Undefined
-            0x0000,  // U+0bfe : Undefined
-            0x0000,  // U+0bff : Undefined
-            0x0000,  // U+0c00 : Undefined
-            0x05a1,  // U+0c01 : Telugu Sign Candrabindu
-            0x05a2,  // U+0c02 : Telugu Sign Anusvara
-            0x05a3,  // U+0c03 : Telugu Sign Visarga
-            0x0000,  // U+0c04 : Undefined
-            0x05a4,  // U+0c05 : Telugu Letter A
-            0x05a5,  // U+0c06 : Telugu Letter Aa
-            0x05a6,  // U+0c07 : Telugu Letter I
-            0x05a7,  // U+0c08 : Telugu Letter Ii
-            0x05a8,  // U+0c09 : Telugu Letter U
-            0x05a9,  // U+0c0a : Telugu Letter Uu
-            0x05aa,  // U+0c0b : Telugu Letter Vocalic R
-            0x15a6,  // U+0c0c : Telugu Letter Vocalic L
-            0x0000,  // U+0c0d : Undefined
-            0x05ab,  // U+0c0e : Telugu Letter E
-            0x05ac,  // U+0c0f : Telugu Letter Ee
-            0x05ad,  // U+0c10 : Telugu Letter Ai
-            0x0000,  // U+0c11 : Undefined
-            0x05af,  // U+0c12 : Telugu Letter O
-            0x05b0,  // U+0c13 : Telugu Letter Oo
-            0x05b1,  // U+0c14 : Telugu Letter Au
-            0x05b3,  // U+0c15 : Telugu Letter Ka
-            0x05b4,  // U+0c16 : Telugu Letter Kha
-            0x05b5,  // U+0c17 : Telugu Letter Ga
-            0x05b6,  // U+0c18 : Telugu Letter Gha
-            0x05b7,  // U+0c19 : Telugu Letter Nga
-            0x05b8,  // U+0c1a : Telugu Letter Ca
-            0x05b9,  // U+0c1b : Telugu Letter Cha
-            0x05ba,  // U+0c1c : Telugu Letter Ja
-            0x05bb,  // U+0c1d : Telugu Letter Jha
-            0x05bc,  // U+0c1e : Telugu Letter Nya
-            0x05bd,  // U+0c1f : Telugu Letter Tta
-            0x05be,  // U+0c20 : Telugu Letter Ttha
-            0x05bf,  // U+0c21 : Telugu Letter Dda
-            0x05c0,  // U+0c22 : Telugu Letter Ddha
-            0x05c1,  // U+0c23 : Telugu Letter Nna
-            0x05c2,  // U+0c24 : Telugu Letter Ta
-            0x05c3,  // U+0c25 : Telugu Letter Tha
-            0x05c4,  // U+0c26 : Telugu Letter Da
-            0x05c5,  // U+0c27 : Telugu Letter Dha
-            0x05c6,  // U+0c28 : Telugu Letter Na
-            0x0000,  // U+0c29 : Undefined
-            0x05c8,  // U+0c2a : Telugu Letter Pa
-            0x05c9,  // U+0c2b : Telugu Letter Pha
-            0x05ca,  // U+0c2c : Telugu Letter Ba
-            0x05cb,  // U+0c2d : Telugu Letter Bha
-            0x05cc,  // U+0c2e : Telugu Letter Ma
-            0x05cd,  // U+0c2f : Telugu Letter Ya
-            0x05cf,  // U+0c30 : Telugu Letter Ra
-            0x05d0,  // U+0c31 : Telugu Letter Rra
-            0x05d1,  // U+0c32 : Telugu Letter La
-            0x05d2,  // U+0c33 : Telugu Letter Lla
-            0x0000,  // U+0c34 : Undefined
-            0x05d4,  // U+0c35 : Telugu Letter Va
-            0x05d5,  // U+0c36 : Telugu Letter Sha
-            0x05d6,  // U+0c37 : Telugu Letter Ssa
-            0x05d7,  // U+0c38 : Telugu Letter Sa
-            0x05d8,  // U+0c39 : Telugu Letter Ha
-            0x0000,  // U+0c3a : Undefined
-            0x0000,  // U+0c3b : Undefined
-            0x0000,  // U+0c3c : Undefined
-            0x0000,  // U+0c3d : Undefined
-            0x05da,  // U+0c3e : Telugu Vowel Sign Aa
-            0x05db,  // U+0c3f : Telugu Vowel Sign I
-            0x05dc,  // U+0c40 : Telugu Vowel Sign Ii
-            0x05dd,  // U+0c41 : Telugu Vowel Sign U
-            0x05de,  // U+0c42 : Telugu Vowel Sign Uu
-            0x05df,  // U+0c43 : Telugu Vowel Sign Vocalic R
-            0x15df,  // U+0c44 : Telugu Vowel Sign Vocalic Rr
-            0x0000,  // U+0c45 : Undefined
-            0x05e0,  // U+0c46 : Telugu Vowel Sign E
-            0x05e1,  // U+0c47 : Telugu Vowel Sign Ee
-            0x05e2,  // U+0c48 : Telugu Vowel Sign Ai
-            0x0000,  // U+0c49 : Undefined
-            0x05e4,  // U+0c4a : Telugu Vowel Sign O
-            0x05e5,  // U+0c4b : Telugu Vowel Sign Oo
-            0x05e6,  // U+0c4c : Telugu Vowel Sign Au
-            0x05e8,  // U+0c4d : Telugu Sign Virama
-            0x0000,  // U+0c4e : Undefined
-            0x0000,  // U+0c4f : Undefined
-            0x0000,  // U+0c50 : Undefined
-            0x0000,  // U+0c51 : Undefined
-            0x0000,  // U+0c52 : Undefined
-            0x0000,  // U+0c53 : Undefined
-            0x0000,  // U+0c54 : Undefined
-            0x0000,  // U+0c55 : Telugu Length Mark
-            0x0000,  // U+0c56 : Telugu Ai Length Mark
-            0x0000,  // U+0c57 : Undefined
-            0x0000,  // U+0c58 : Undefined
-            0x0000,  // U+0c59 : Undefined
-            0x0000,  // U+0c5a : Undefined
-            0x0000,  // U+0c5b : Undefined
-            0x0000,  // U+0c5c : Undefined
-            0x0000,  // U+0c5d : Undefined
-            0x0000,  // U+0c5e : Undefined
-            0x0000,  // U+0c5f : Undefined
-            0x15aa,  // U+0c60 : Telugu Letter Vocalic Rr
-            0x15a7,  // U+0c61 : Telugu Letter Vocalic Ll
-            0x0000,  // U+0c62 : Undefined
-            0x0000,  // U+0c63 : Undefined
-            0x0000,  // U+0c64 : Undefined
-            0x0000,  // U+0c65 : Undefined
-            0x05f1,  // U+0c66 : Telugu Digit Zero
-            0x05f2,  // U+0c67 : Telugu Digit One
-            0x05f3,  // U+0c68 : Telugu Digit Two
-            0x05f4,  // U+0c69 : Telugu Digit Three
-            0x05f5,  // U+0c6a : Telugu Digit Four
-            0x05f6,  // U+0c6b : Telugu Digit Five
-            0x05f7,  // U+0c6c : Telugu Digit Six
-            0x05f8,  // U+0c6d : Telugu Digit Seven
-            0x05f9,  // U+0c6e : Telugu Digit Eight
-            0x05fa,  // U+0c6f : Telugu Digit Nine
-            0x0000,  // U+0c70 : Undefined
-            0x0000,  // U+0c71 : Undefined
-            0x0000,  // U+0c72 : Undefined
-            0x0000,  // U+0c73 : Undefined
-            0x0000,  // U+0c74 : Undefined
-            0x0000,  // U+0c75 : Undefined
-            0x0000,  // U+0c76 : Undefined
-            0x0000,  // U+0c77 : Undefined
-            0x0000,  // U+0c78 : Undefined
-            0x0000,  // U+0c79 : Undefined
-            0x0000,  // U+0c7a : Undefined
-            0x0000,  // U+0c7b : Undefined
-            0x0000,  // U+0c7c : Undefined
-            0x0000,  // U+0c7d : Undefined
-            0x0000,  // U+0c7e : Undefined
-            0x0000,  // U+0c7f : Undefined
-            0x0000,  // U+0c80 : Undefined
-            0x0000,  // U+0c81 : Undefined
-            0x08a2,  // U+0c82 : Kannada Sign Anusvara
-            0x08a3,  // U+0c83 : Kannada Sign Visarga
-            0x0000,  // U+0c84 : Undefined
-            0x08a4,  // U+0c85 : Kannada Letter A
-            0x08a5,  // U+0c86 : Kannada Letter Aa
-            0x08a6,  // U+0c87 : Kannada Letter I
-            0x08a7,  // U+0c88 : Kannada Letter Ii
-            0x08a8,  // U+0c89 : Kannada Letter U
-            0x08a9,  // U+0c8a : Kannada Letter Uu
-            0x08aa,  // U+0c8b : Kannada Letter Vocalic R
-            0x18a6,  // U+0c8c : Kannada Letter Vocalic L
-            0x0000,  // U+0c8d : Undefined
-            0x08ab,  // U+0c8e : Kannada Letter E
-            0x08ac,  // U+0c8f : Kannada Letter Ee
-            0x08ad,  // U+0c90 : Kannada Letter Ai
-            0x0000,  // U+0c91 : Undefined
-            0x08af,  // U+0c92 : Kannada Letter O
-            0x08b0,  // U+0c93 : Kannada Letter Oo
-            0x08b1,  // U+0c94 : Kannada Letter Au
-            0x08b3,  // U+0c95 : Kannada Letter Ka
-            0x08b4,  // U+0c96 : Kannada Letter Kha
-            0x08b5,  // U+0c97 : Kannada Letter Ga
-            0x08b6,  // U+0c98 : Kannada Letter Gha
-            0x08b7,  // U+0c99 : Kannada Letter Nga
-            0x08b8,  // U+0c9a : Kannada Letter Ca
-            0x08b9,  // U+0c9b : Kannada Letter Cha
-            0x08ba,  // U+0c9c : Kannada Letter Ja
-            0x08bb,  // U+0c9d : Kannada Letter Jha
-            0x08bc,  // U+0c9e : Kannada Letter Nya
-            0x08bd,  // U+0c9f : Kannada Letter Tta
-            0x08be,  // U+0ca0 : Kannada Letter Ttha
-            0x08bf,  // U+0ca1 : Kannada Letter Dda
-            0x08c0,  // U+0ca2 : Kannada Letter Ddha
-            0x08c1,  // U+0ca3 : Kannada Letter Nna
-            0x08c2,  // U+0ca4 : Kannada Letter Ta
-            0x08c3,  // U+0ca5 : Kannada Letter Tha
-            0x08c4,  // U+0ca6 : Kannada Letter Da
-            0x08c5,  // U+0ca7 : Kannada Letter Dha
-            0x08c6,  // U+0ca8 : Kannada Letter Na
-            0x0000,  // U+0ca9 : Undefined
-            0x08c8,  // U+0caa : Kannada Letter Pa
-            0x08c9,  // U+0cab : Kannada Letter Pha
-            0x08ca,  // U+0cac : Kannada Letter Ba
-            0x08cb,  // U+0cad : Kannada Letter Bha
-            0x08cc,  // U+0cae : Kannada Letter Ma
-            0x08cd,  // U+0caf : Kannada Letter Ya
-            0x08cf,  // U+0cb0 : Kannada Letter Ra
-            0x08d0,  // U+0cb1 : Kannada Letter Rra
-            0x08d1,  // U+0cb2 : Kannada Letter La
-            0x08d2,  // U+0cb3 : Kannada Letter Lla
-            0x0000,  // U+0cb4 : Undefined
-            0x08d4,  // U+0cb5 : Kannada Letter Va
-            0x08d5,  // U+0cb6 : Kannada Letter Sha
-            0x08d6,  // U+0cb7 : Kannada Letter Ssa
-            0x08d7,  // U+0cb8 : Kannada Letter Sa
-            0x08d8,  // U+0cb9 : Kannada Letter Ha
-            0x0000,  // U+0cba : Undefined
-            0x0000,  // U+0cbb : Undefined
-            0x0000,  // U+0cbc : Undefined
-            0x0000,  // U+0cbd : Undefined
-            0x08da,  // U+0cbe : Kannada Vowel Sign Aa
-            0x08db,  // U+0cbf : Kannada Vowel Sign I
-            0x08dc,  // U+0cc0 : Kannada Vowel Sign Ii
-            0x08dd,  // U+0cc1 : Kannada Vowel Sign U
-            0x08de,  // U+0cc2 : Kannada Vowel Sign Uu
-            0x08df,  // U+0cc3 : Kannada Vowel Sign Vocalic R
-            0x18df,  // U+0cc4 : Kannada Vowel Sign Vocalic Rr
-            0x0000,  // U+0cc5 : Undefined
-            0x08e0,  // U+0cc6 : Kannada Vowel Sign E
-            0x08e1,  // U+0cc7 : Kannada Vowel Sign Ee
-            0x08e2,  // U+0cc8 : Kannada Vowel Sign Ai
-            0x0000,  // U+0cc9 : Undefined
-            0x08e4,  // U+0cca : Kannada Vowel Sign O
-            0x08e5,  // U+0ccb : Kannada Vowel Sign Oo
-            0x08e6,  // U+0ccc : Kannada Vowel Sign Au
-            0x08e8,  // U+0ccd : Kannada Sign Virama
-            0x0000,  // U+0cce : Undefined
-            0x0000,  // U+0ccf : Undefined
-            0x0000,  // U+0cd0 : Undefined
-            0x0000,  // U+0cd1 : Undefined
-            0x0000,  // U+0cd2 : Undefined
-            0x0000,  // U+0cd3 : Undefined
-            0x0000,  // U+0cd4 : Undefined
-            0x0000,  // U+0cd5 : Kannada Length Mark
-            0x0000,  // U+0cd6 : Kannada Ai Length Mark
-            0x0000,  // U+0cd7 : Undefined
-            0x0000,  // U+0cd8 : Undefined
-            0x0000,  // U+0cd9 : Undefined
-            0x0000,  // U+0cda : Undefined
-            0x0000,  // U+0cdb : Undefined
-            0x0000,  // U+0cdc : Undefined
-            0x0000,  // U+0cdd : Undefined
-            0x18c9,  // U+0cde : Kannada Letter Fa
-            0x0000,  // U+0cdf : Undefined
-            0x18aa,  // U+0ce0 : Kannada Letter Vocalic Rr
-            0x18a7,  // U+0ce1 : Kannada Letter Vocalic Ll
-            0x0000,  // U+0ce2 : Undefined
-            0x0000,  // U+0ce3 : Undefined
-            0x0000,  // U+0ce4 : Undefined
-            0x0000,  // U+0ce5 : Undefined
-            0x08f1,  // U+0ce6 : Kannada Digit Zero
-            0x08f2,  // U+0ce7 : Kannada Digit One
-            0x08f3,  // U+0ce8 : Kannada Digit Two
-            0x08f4,  // U+0ce9 : Kannada Digit Three
-            0x08f5,  // U+0cea : Kannada Digit Four
-            0x08f6,  // U+0ceb : Kannada Digit Five
-            0x08f7,  // U+0cec : Kannada Digit Six
-            0x08f8,  // U+0ced : Kannada Digit Seven
-            0x08f9,  // U+0cee : Kannada Digit Eight
-            0x08fa,  // U+0cef : Kannada Digit Nine
-            0x0000,  // U+0cf0 : Undefined
-            0x0000,  // U+0cf1 : Undefined
-            0x0000,  // U+0cf2 : Undefined
-            0x0000,  // U+0cf3 : Undefined
-            0x0000,  // U+0cf4 : Undefined
-            0x0000,  // U+0cf5 : Undefined
-            0x0000,  // U+0cf6 : Undefined
-            0x0000,  // U+0cf7 : Undefined
-            0x0000,  // U+0cf8 : Undefined
-            0x0000,  // U+0cf9 : Undefined
-            0x0000,  // U+0cfa : Undefined
-            0x0000,  // U+0cfb : Undefined
-            0x0000,  // U+0cfc : Undefined
-            0x0000,  // U+0cfd : Undefined
-            0x0000,  // U+0cfe : Undefined
-            0x0000,  // U+0cff : Undefined
-            0x0000,  // U+0d00 : Undefined
-            0x0000,  // U+0d01 : Undefined
-            0x09a2,  // U+0d02 : Malayalam Sign Anusvara
-            0x09a3,  // U+0d03 : Malayalam Sign Visarga
-            0x0000,  // U+0d04 : Undefined
-            0x09a4,  // U+0d05 : Malayalam Letter A
-            0x09a5,  // U+0d06 : Malayalam Letter Aa
-            0x09a6,  // U+0d07 : Malayalam Letter I
-            0x09a7,  // U+0d08 : Malayalam Letter Ii
-            0x09a8,  // U+0d09 : Malayalam Letter U
-            0x09a9,  // U+0d0a : Malayalam Letter Uu
-            0x09aa,  // U+0d0b : Malayalam Letter Vocalic R
-            0x19a6,  // U+0d0c : Malayalam Letter Vocalic L
-            0x0000,  // U+0d0d : Undefined
-            0x09ab,  // U+0d0e : Malayalam Letter E
-            0x09ac,  // U+0d0f : Malayalam Letter Ee
-            0x09ad,  // U+0d10 : Malayalam Letter Ai
-            0x0000,  // U+0d11 : Undefined
-            0x09af,  // U+0d12 : Malayalam Letter O
-            0x09b0,  // U+0d13 : Malayalam Letter Oo
-            0x09b1,  // U+0d14 : Malayalam Letter Au
-            0x09b3,  // U+0d15 : Malayalam Letter Ka
-            0x09b4,  // U+0d16 : Malayalam Letter Kha
-            0x09b5,  // U+0d17 : Malayalam Letter Ga
-            0x09b6,  // U+0d18 : Malayalam Letter Gha
-            0x09b7,  // U+0d19 : Malayalam Letter Nga
-            0x09b8,  // U+0d1a : Malayalam Letter Ca
-            0x09b9,  // U+0d1b : Malayalam Letter Cha
-            0x09ba,  // U+0d1c : Malayalam Letter Ja
-            0x09bb,  // U+0d1d : Malayalam Letter Jha
-            0x09bc,  // U+0d1e : Malayalam Letter Nya
-            0x09bd,  // U+0d1f : Malayalam Letter Tta
-            0x09be,  // U+0d20 : Malayalam Letter Ttha
-            0x09bf,  // U+0d21 : Malayalam Letter Dda
-            0x09c0,  // U+0d22 : Malayalam Letter Ddha
-            0x09c1,  // U+0d23 : Malayalam Letter Nna
-            0x09c2,  // U+0d24 : Malayalam Letter Ta
-            0x09c3,  // U+0d25 : Malayalam Letter Tha
-            0x09c4,  // U+0d26 : Malayalam Letter Da
-            0x09c5,  // U+0d27 : Malayalam Letter Dha
-            0x09c6,  // U+0d28 : Malayalam Letter Na
-            0x0000,  // U+0d29 : Undefined
-            0x09c8,  // U+0d2a : Malayalam Letter Pa
-            0x09c9,  // U+0d2b : Malayalam Letter Pha
-            0x09ca,  // U+0d2c : Malayalam Letter Ba
-            0x09cb,  // U+0d2d : Malayalam Letter Bha
-            0x09cc,  // U+0d2e : Malayalam Letter Ma
-            0x09cd,  // U+0d2f : Malayalam Letter Ya
-            0x09cf,  // U+0d30 : Malayalam Letter Ra
-            0x09d0,  // U+0d31 : Malayalam Letter Rra
-            0x09d1,  // U+0d32 : Malayalam Letter La
-            0x09d2,  // U+0d33 : Malayalam Letter Lla
-            0x09d3,  // U+0d34 : Malayalam Letter Llla
-            0x09d4,  // U+0d35 : Malayalam Letter Va
-            0x09d5,  // U+0d36 : Malayalam Letter Sha
-            0x09d6,  // U+0d37 : Malayalam Letter Ssa
-            0x09d7,  // U+0d38 : Malayalam Letter Sa
-            0x09d8,  // U+0d39 : Malayalam Letter Ha
-            0x0000,  // U+0d3a : Undefined
-            0x0000,  // U+0d3b : Undefined
-            0x0000,  // U+0d3c : Undefined
-            0x0000,  // U+0d3d : Undefined
-            0x09da,  // U+0d3e : Malayalam Vowel Sign Aa
-            0x09db,  // U+0d3f : Malayalam Vowel Sign I
-            0x09dc,  // U+0d40 : Malayalam Vowel Sign Ii
-            0x09dd,  // U+0d41 : Malayalam Vowel Sign U
-            0x09de,  // U+0d42 : Malayalam Vowel Sign Uu
-            0x09df,  // U+0d43 : Malayalam Vowel Sign Vocalic R
-            0x0000,  // U+0d44 : Undefined
-            0x0000,  // U+0d45 : Undefined
-            0x09e0,  // U+0d46 : Malayalam Vowel Sign E
-            0x09e1,  // U+0d47 : Malayalam Vowel Sign Ee
-            0x09e2,  // U+0d48 : Malayalam Vowel Sign Ai
-            0x0000,  // U+0d49 : Undefined
-            0x09e4,  // U+0d4a : Malayalam Vowel Sign O
-            0x09e5,  // U+0d4b : Malayalam Vowel Sign Oo
-            0x09e6,  // U+0d4c : Malayalam Vowel Sign Au
-            0x09e8,  // U+0d4d : Malayalam Sign Virama
-            0x0000,  // U+0d4e : Undefined
-            0x0000,  // U+0d4f : Undefined
-            0x0000,  // U+0d50 : Undefined
-            0x0000,  // U+0d51 : Undefined
-            0x0000,  // U+0d52 : Undefined
-            0x0000,  // U+0d53 : Undefined
-            0x0000,  // U+0d54 : Undefined
-            0x0000,  // U+0d55 : Undefined
-            0x0000,  // U+0d56 : Undefined
-            0x0000,  // U+0d57 : Malayalam Au Length Mark
-            0x0000,  // U+0d58 : Undefined
-            0x0000,  // U+0d59 : Undefined
-            0x0000,  // U+0d5a : Undefined
-            0x0000,  // U+0d5b : Undefined
-            0x0000,  // U+0d5c : Undefined
-            0x0000,  // U+0d5d : Undefined
-            0x0000,  // U+0d5e : Undefined
-            0x0000,  // U+0d5f : Undefined
-            0x19aa,  // U+0d60 : Malayalam Letter Vocalic Rr
-            0x19a7,  // U+0d61 : Malayalam Letter Vocalic Ll
-            0x0000,  // U+0d62 : Undefined
-            0x0000,  // U+0d63 : Undefined
-            0x0000,  // U+0d64 : Undefined
-            0x0000,  // U+0d65 : Undefined
-            0x09f1,  // U+0d66 : Malayalam Digit Zero
-            0x09f2,  // U+0d67 : Malayalam Digit One
-            0x09f3,  // U+0d68 : Malayalam Digit Two
-            0x09f4,  // U+0d69 : Malayalam Digit Three
-            0x09f5,  // U+0d6a : Malayalam Digit Four
-            0x09f6,  // U+0d6b : Malayalam Digit Five
-            0x09f7,  // U+0d6c : Malayalam Digit Six
-            0x09f8,  // U+0d6d : Malayalam Digit Seven
-            0x09f9,  // U+0d6e : Malayalam Digit Eight
-            0x09fa   // U+0d6f : Malayalam Digit Nine
-        };
-
-        ////////////////////////////////////////////////////////////////////////////
-        // SecondIndicByte
-        //
-        // This is used if the UnicodeToIndic table 4 high bits are set, this is
-        // the value of the second Indic byte when applicable.
-        ////////////////////////////////////////////////////////////////////////////
-        static byte[] SecondIndicByte =
-        {
-            0x00,
-            0xe9,
-            0xb8,             // U+0952 == 0xf0_0xb8
-            0xbf              // U+0970 == 0xf0_0xbf
-        };
-
-        ////////////////////////////////////////////////////////////////////////////
-        // IndicMapping
-        //
-        // This table maps the 10 indic code pages to their unicode counterparts.
-        // There are 0x60 characters in each table.  The tables are in pairs of 2
-        // (1st char, 2nd char) and there are 10 tables (1 for each code page "font")
-        ////////////////////////////////////////////////////////////////////////////
-        static int[] IndicMappingIndex =
-        {
-            -1,       //  0 DEF 0X40 Default        // Not a real code page
-            -1,       //  1 RMN 0X41 Roman          // Transliteration not supported
-            0,        //  2 DEV 0X42 Devanagari
-            1,        //  3 BNG 0X43 Bengali
-            2,        //  4 TML 0X44 Tamil
-            3,        //  5 TLG 0X45 Telugu
-            1,        //  6 ASM 0X46 Assamese (Bengali) - Reuses table 1
-            4,        //  7 ORI 0X47 Oriya
-            5,        //  8 KND 0X48 Kannada
-            6,        //  9 MLM 0X49 Malayalam
-            7,        // 10 GJR 0X4A Gujarati
-            8         // 11 PNJ 0X4B Punjabi (Gurmukhi)
-        };
-
-        ////////////////////////////////////////////////////////////////////////////
-        // IndicMapping
-        //
-        // This table contains 9 tables for the 10 indic code pages to their unicode counterparts.
-        // There are 0x60 characters in each table.  The tables are in pairs of 2
-        // (1st char, 2nd char) and there are 10 tables (1 for each code page "font")
-        //
-        // The first index is the table index (from the IndicMappingIndex table),
-        // the 2nd the byte index, the third the character index.
-        //
-        // For byte 0 a 0x0000 value indicates an unknown character
-        // For byte 1 a 0 value indicates no special attributes.
-        // For byte 1, 200C & 200D are Virama, Nukta special cases
-        // For byte 1, B8BF is Devanagari stress & abbreviation sign special cases
-        //
-        // WARNING: When copying these from windows, ? 0x003F were changed to 0x0000.
-        //
-        ////////////////////////////////////////////////////////////////////////////
-        // char[codePageMapIndex][byte][character]
-        static char[,,] IndicMapping =
-        {
-            {
-                ////////////////////////////////////////////////////////////////////////////
-                //
-                //  Devanagari  Table 0, Code Page (2, 0x42, 57002)
-                //
-                ////////////////////////////////////////////////////////////////////////////
-
-                // Default Unicode Char
-                {
-                //       a0,       a1,       a2,       a3,       a4,       a5,       a6,       a7,
-                   '\x0000', '\x0901', '\x0902', '\x0903', '\x0905', '\x0906', '\x0907', '\x0908',
-                //       a8,       a9,       aa,       ab,       ac,       ad,       ae,       af,
-                   '\x0909', '\x090a', '\x090b', '\x090e', '\x090f', '\x0910', '\x090d', '\x0912',
-                //       b0,       b1,       b2,       b3,       b4,       b5,       b6,       b7,
-                   '\x0913', '\x0914', '\x0911', '\x0915', '\x0916', '\x0917', '\x0918', '\x0919',
-                //       b8,       b9,       ba,       bb,       bc,       bd,       be,       bf,
-                   '\x091a', '\x091b', '\x091c', '\x091d', '\x091e', '\x091f', '\x0920', '\x0921',
-                //       c0,       c1,       c2,       c3,       c4,       c5,       c6,       c7,
-                   '\x0922', '\x0923', '\x0924', '\x0925', '\x0926', '\x0927', '\x0928', '\x0929',
-                //       c8,       c9,       ca,       cb,       cc,       cd,       ce,       cf,
-                   '\x092a', '\x092b', '\x092c', '\x092d', '\x092e', '\x092f', '\x095f', '\x0930',
-                //       d0,       d1,       d2,       d3,       d4,       d5,       d6,       d7,
-                   '\x0931', '\x0932', '\x0933', '\x0934', '\x0935', '\x0936', '\x0937', '\x0938',
-                //       d8,       d9,       da,       db,       dc,       dd,       de,       df,
-                   '\x0939', '\x0000', '\x093e', '\x093f', '\x0940', '\x0941', '\x0942', '\x0943',
-                //       e0,       e1,       e2,       e3,       e4,       e5,       e6,       e7,
-                   '\x0946', '\x0947', '\x0948', '\x0945', '\x094a', '\x094b', '\x094c', '\x0949',
-                //       e8,       e9,       ea,       eb,       ec,       ed,       ee,       ef,
-                   '\x094d', '\x093c', '\x0964', '\x0000', '\x0000', '\x0000', '\x0000', '\x0000',
-                //       f0,       f1,       f2,       f3,       f4,       f5,       f6,       f7,
-                   '\x0000', '\x0966', '\x0967', '\x0968', '\x0969', '\x096a', '\x096b', '\x096c',
-                //       f8,       f9,       fa,       fb,       fc,       fd,       fe,       ff
-                   '\x096d', '\x096e', '\x096f', '\x0000', '\x0000', '\x0000', '\x0000', '\x0000'
-                },
-
-                // Alternate Unicode Char & Flags
-                {
-                //       a0,       a1,       a2,       a3,       a4,       a5,       a6,       a7,
-                      '\x0', '\x0950',    '\x0',    '\x0',    '\x0',    '\x0', '\x090c', '\x0961',
-                //       a8,       a9,       aa,       ab,       ac,       ad,       ae,       af,
-                      '\x0',    '\x0', '\x0960',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       b0,       b1,       b2,       b3,       b4,       b5,       b6,       b7,
-                      '\x0',    '\x0',    '\x0', '\x0958', '\x0959', '\x095a',    '\x0',    '\x0',
-                //       b8,       b9,       ba,       bb,       bc,       bd,       be,       bf,
-                      '\x0',    '\x0', '\x095b',    '\x0',    '\x0',    '\x0',    '\x0', '\x095c',
-                //       c0,       c1,       c2,       c3,       c4,       c5,       c6,       c7,
-                   '\x095d',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       c8,       c9,       ca,       cb,       cc,       cd,       ce,       cf,
-                      '\x0', '\x095e',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       d0,       d1,       d2,       d3,       d4,       d5,       d6,       d7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       d8,       d9,       da,       db,       dc,       dd,       de,       df,
-                      '\x0',    '\x0',    '\x0', '\x0962', '\x0963',    '\x0',    '\x0', '\x0944',
-                //       e0,       e1,       e2,       e3,       e4,       e5,       e6,       e7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       e8,       e9,       ea,       eb,       ec,       ed,       ee,       ef,
-                   '\x200C', '\x200D', '\x093d',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       f0,       f1,       f2,       f3,       f4,       f5,       f6,       f7,
-                   '\xB8BF',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       f8,       f9,       fa,       fb,       fc,       fd,       fe,       ff
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0'
-                }
-            },
-
-            {
-                ////////////////////////////////////////////////////////////////////////////
-                //
-                //  Bengali & Assemese Table 1', Code Pages   (3, '43', 57003 & 6', '46', 57006)
-                //
-                ////////////////////////////////////////////////////////////////////////////
-
-                // Default Unicode Char
-                {
-                //       a0,       a1,       a2,       a3,       a4,       a5,       a6,       a7,
-                   '\x0000', '\x0981', '\x0982', '\x0983', '\x0985', '\x0986', '\x0987', '\x0988',
-                //       a8,       a9,       aa,       ab,       ac,       ad,       ae,       af,
-                   '\x0989', '\x098a', '\x098b', '\x098f', '\x098f', '\x0990', '\x0990', '\x0993',
-                //       b0,       b1,       b2,       b3,       b4,       b5,       b6,       b7,
-                   '\x0993', '\x0994', '\x0994', '\x0995', '\x0996', '\x0997', '\x0998', '\x0999',
-                //       b8,       b9,       ba,       bb,       bc,       bd,       be,       bf,
-                   '\x099a', '\x099b', '\x099c', '\x099d', '\x099e', '\x099f', '\x09a0', '\x09a1',
-                //       c0,       c1,       c2,       c3,       c4,       c5,       c6,       c7,
-                   '\x09a2', '\x09a3', '\x09a4', '\x09a5', '\x09a6', '\x09a7', '\x09a8', '\x09a8',
-                //       c8,       c9,       ca,       cb,       cc,       cd,       ce,       cf,
-                   '\x09aa', '\x09ab', '\x09ac', '\x09ad', '\x09ae', '\x09af', '\x09df', '\x09b0',
-                //       d0,       d1,       d2,       d3,       d4,       d5,       d6,       d7,
-                   '\x09b0', '\x09b2', '\x09b2', '\x09b2', '\x09ac', '\x09b6', '\x09b7', '\x09b8',
-                //       d8,       d9,       da,       db,       dc,       dd,       de,       df,
-                   '\x09b9', '\x0000', '\x09be', '\x09bf', '\x09c0', '\x09c1', '\x09c2', '\x09c3',
-                //       e0,       e1,       e2,       e3,       e4,       e5,       e6,       e7,
-                   '\x09c7', '\x09c7', '\x09c8', '\x09c8', '\x09cb', '\x09cb', '\x09cc', '\x09cc',
-                //       e8,       e9,       ea,       eb,       ec,       ed,       ee,       ef,
-                   '\x09cd', '\x09bc', '\x002e', '\x0000', '\x0000', '\x0000', '\x0000', '\x0000',
-                //       f0,       f1,       f2,       f3,       f4,       f5,       f6,       f7,
-                   '\x0000', '\x09e6', '\x09e7', '\x09e8', '\x09e9', '\x09ea', '\x09eb', '\x09ec',
-                //       f8,       f9,       fa,       fb,       fc,       fd,       fe,       ff
-                   '\x09ed', '\x09ee', '\x09ef', '\x0000', '\x0000', '\x0000', '\x0000', '\x0000'
-                },
-
-                // Alternate Unicode Char & Flags
-                {
-                    //       a0,       a1,       a2,       a3,       a4,       a5,       a6,       a7,
-                          '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0', '\x098c', '\x09e1',
-                    //       a8,       a9,       aa,       ab,       ac,       ad,       ae,       af,
-                          '\x0',    '\x0', '\x09e0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                    //       b0,       b1,       b2,       b3,       b4,       b5,       b6,       b7,
-                          '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                    //       b8,       b9,       ba,       bb,       bc,       bd,       be,       bf,
-                          '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0', '\x09dc',
-                    //       c0,       c1,       c2,       c3,       c4,       c5,       c6,       c7,
-                       '\x09dd',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                    //       c8,       c9,       ca,       cb,       cc,       cd,       ce,       cf,
-                          '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                    //       d0,       d1,       d2,       d3,       d4,       d5,       d6,       d7,
-                          '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                    //       d8,       d9,       da,       db,       dc,       dd,       de,       df,
-                          '\x0',    '\x0',    '\x0', '\x09e2', '\x09e3',    '\x0',    '\x0', '\x09c4',
-                    //       e0,       e1,       e2,       e3,       e4,       e5,       e6,       e7,
-                          '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                    //       e8,       e9,       ea,       eb,       ec,       ed,       ee,       ef,
-                       '\x200C', '\x200D',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                    //       f0,       f1,       f2,       f3,       f4,       f5,       f6,       f7,
-                          '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                    //       f8,       f9,       fa,       fb,       fc,       fd,       fe,       ff
-                          '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0'
-                }
-            },
-
-            {
-                ////////////////////////////////////////////////////////////////////////////
-                //
-                //  Tamil   Table 2', Code Page   (4, '44', 57004)
-                //
-                ////////////////////////////////////////////////////////////////////////////
-
-                // Default Unicode Char
-                {
-                //       a0,       a1,       a2,       a3,       a4,       a5,       a6,       a7,
-                   '\x0000', '\x0000', '\x0b82', '\x0b83', '\x0b85', '\x0b86', '\x0b87', '\x0b88',
-                //       a8,       a9,       aa,       ab,       ac,       ad,       ae,       af,
-                   '\x0b89', '\x0b8a', '\x0000', '\x0b8f', '\x0b8f', '\x0b90', '\x0b90', '\x0b92',
-                //       b0,       b1,       b2,       b3,       b4,       b5,       b6,       b7,
-                   '\x0b93', '\x0b94', '\x0b94', '\x0b95', '\x0b95', '\x0b95', '\x0b95', '\x0b99',
-                //       b8,       b9,       ba,       bb,       bc,       bd,       be,       bf,
-                   '\x0b9a', '\x0b9a', '\x0b9c', '\x0b9c', '\x0b9e', '\x0b9f', '\x0b9f', '\x0b9f',
-                //       c0,       c1,       c2,       c3,       c4,       c5,       c6,       c7,
-                   '\x0b9f', '\x0ba3', '\x0ba4', '\x0ba4', '\x0ba4', '\x0ba4', '\x0ba8', '\x0ba9',
-                //       c8,       c9,       ca,       cb,       cc,       cd,       ce,       cf,
-                   '\x0baa', '\x0baa', '\x0baa', '\x0baa', '\x0bae', '\x0baf', '\x0baf', '\x0bb0',
-                //       d0,       d1,       d2,       d3,       d4,       d5,       d6,       d7,
-                   '\x0bb1', '\x0bb2', '\x0bb3', '\x0bb4', '\x0bb5', '\x0bb7', '\x0bb7', '\x0bb8',
-                //       d8,       d9,       da,       db,       dc,       dd,       de,       df,
-                   '\x0bb9', '\x0000', '\x0bbe', '\x0bbf', '\x0bc0', '\x0bc1', '\x0bc2', '\x0000',
-                //       e0,       e1,       e2,       e3,       e4,       e5,       e6,       e7,
-                   '\x0bc6', '\x0bc7', '\x0bc8', '\x0bc8', '\x0bca', '\x0bcb', '\x0bcc', '\x0bcc',
-                //       e8,       e9,       ea,       eb,       ec,       ed,       ee,       ef,
-                   '\x0bcd', '\x0000', '\x002e', '\x0000', '\x0000', '\x0000', '\x0000', '\x0000',
-                //       f0,       f1,       f2,       f3,       f4,       f5,       f6,       f7,
-                   '\x0000', '\x0030', '\x0be7', '\x0be8', '\x0be9', '\x0bea', '\x0beb', '\x0bec',
-                //       f8,       f9,       fa,       fb,       fc,       fd,       fe,       ff
-                   '\x0bed', '\x0bee', '\x0bef', '\x0000', '\x0000', '\x0000', '\x0000', '\x0000'
-                },
-
-                // Alternate Unicode Char & Flags
-                {
-                //       a0,       a1,       a2,       a3,       a4,       a5,       a6,       a7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       a8,       a9,       aa,       ab,       ac,       ad,       ae,       af,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       b0,       b1,       b2,       b3,       b4,       b5,       b6,       b7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       b8,       b9,       ba,       bb,       bc,       bd,       be,       bf,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       c0,       c1,       c2,       c3,       c4,       c5,       c6,       c7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       c8,       c9,       ca,       cb,       cc,       cd,       ce,       cf,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       d0,       d1,       d2,       d3,       d4,       d5,       d6,       d7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       d8,       d9,       da,       db,       dc,       dd,       de,       df,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       e0,       e1,       e2,       e3,       e4,       e5,       e6,       e7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       e8,       e9,       ea,       eb,       ec,       ed,       ee,       ef,
-                   '\x200C', '\x200D',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       f0,       f1,       f2,       f3,       f4,       f5,       f6,       f7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       f8,       f9,       fa,       fb,       fc,       fd,       fe,       ff
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0'
-                }
-            },
-
-            {
-                ////////////////////////////////////////////////////////////////////////////
-                //
-                //  Telugu    Table 3', Code Page   (5, '45', 57005)
-                //
-                ////////////////////////////////////////////////////////////////////////////
-
-                // Default Unicode Char
-                {
-                //       a0,       a1,       a2,       a3,       a4,       a5,       a6,       a7,
-                   '\x0000', '\x0c01', '\x0c02', '\x0c03', '\x0c05', '\x0c06', '\x0c07', '\x0c08',
-                //       a8,       a9,       aa,       ab,       ac,       ad,       ae,       af,
-                   '\x0c09', '\x0c0a', '\x0c0b', '\x0c0e', '\x0c0f', '\x0c10', '\x0c10', '\x0c12',
-                //       b0,       b1,       b2,       b3,       b4,       b5,       b6,       b7,
-                   '\x0c13', '\x0c14', '\x0c14', '\x0c15', '\x0c16', '\x0c17', '\x0c18', '\x0c19',
-                //       b8,       b9,       ba,       bb,       bc,       bd,       be,       bf,
-                   '\x0c1a', '\x0c1b', '\x0c1c', '\x0c1d', '\x0c1e', '\x0c1f', '\x0c20', '\x0c21',
-                //       c0,       c1,       c2,       c3,       c4,       c5,       c6,       c7,
-                   '\x0c22', '\x0c23', '\x0c24', '\x0c25', '\x0c26', '\x0c27', '\x0c28', '\x0c28',
-                //       c8,       c9,       ca,       cb,       cc,       cd,       ce,       cf,
-                   '\x0c2a', '\x0c2b', '\x0c2c', '\x0c2d', '\x0c2e', '\x0c2f', '\x0c2f', '\x0c30',
-                //       d0,       d1,       d2,       d3,       d4,       d5,       d6,       d7,
-                   '\x0c31', '\x0c32', '\x0c33', '\x0c33', '\x0c35', '\x0c36', '\x0c37', '\x0c38',
-                //       d8,       d9,       da,       db,       dc,       dd,       de,       df,
-                   '\x0c39', '\x0000', '\x0c3e', '\x0c3f', '\x0c40', '\x0c41', '\x0c42', '\x0c43',
-                //       e0,       e1,       e2,       e3,       e4,       e5,       e6,       e7,
-                   '\x0c46', '\x0c47', '\x0c48', '\x0c48', '\x0c4a', '\x0c4b', '\x0c4c', '\x0c4c',
-                //       e8,       e9,       ea,       eb,       ec,       ed,       ee,       ef,
-                   '\x0c4d', '\x0000', '\x002e', '\x0000', '\x0000', '\x0000', '\x0000', '\x0000',
-                //       f0,       f1,       f2,       f3,       f4,       f5,       f6,       f7,
-                   '\x0000', '\x0c66', '\x0c67', '\x0c68', '\x0c69', '\x0c6a', '\x0c6b', '\x0c6c',
-                //       f8,       f9,       fa,       fb,       fc,       fd,       fe,       ff
-                   '\x0c6d', '\x0c6e', '\x0c6f', '\x0000', '\x0000', '\x0000', '\x0000', '\x0000'
-                },
-
-                // Alternate Unicode Char & Flags
-                {
-                //       a0,       a1,       a2,       a3,       a4,       a5,       a6,       a7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0', '\x0c0c', '\x0c61',
-                //       a8,       a9,       aa,       ab,       ac,       ad,       ae,       af,
-                      '\x0',    '\x0', '\x0c60',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       b0,       b1,       b2,       b3,       b4,       b5,       b6,       b7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       b8,       b9,       ba,       bb,       bc,       bd,       be,       bf,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       c0,       c1,       c2,       c3,       c4,       c5,       c6,       c7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       c8,       c9,       ca,       cb,       cc,       cd,       ce,       cf,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       d0,       d1,       d2,       d3,       d4,       d5,       d6,       d7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       d8,       d9,       da,       db,       dc,       dd,       de,       df,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0', '\x0c44',
-                //       e0,       e1,       e2,       e3,       e4,       e5,       e6,       e7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       e8,       e9,       ea,       eb,       ec,       ed,       ee,       ef,
-                   '\x200C', '\x200D',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       f0,       f1,       f2,       f3,       f4,       f5,       f6,       f7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       f8,       f9,       fa,       fb,       fc,       fd,       fe,       ff
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0'
-                }
-            },
-
-            {
-                ////////////////////////////////////////////////////////////////////////////
-                //
-                //  Oriya   Table 4', Code Page   (7, '47', 57007)
-                //
-                ////////////////////////////////////////////////////////////////////////////
-
-                // Default Unicode Char
-                {
-                //       a0,       a1,       a2,       a3,       a4,       a5,       a6,       a7,
-                   '\x0000', '\x0b01', '\x0b02', '\x0b03', '\x0b05', '\x0b06', '\x0b07', '\x0b08',
-                //       a8,       a9,       aa,       ab,       ac,       ad,       ae,       af,
-                   '\x0b09', '\x0b0a', '\x0b0b', '\x0b0f', '\x0b0f', '\x0b10', '\x0b10', '\x0b10',
-                //       b0,       b1,       b2,       b3,       b4,       b5,       b6,       b7,
-                   '\x0b13', '\x0b14', '\x0b14', '\x0b15', '\x0b16', '\x0b17', '\x0b18', '\x0b19',
-                //       b8,       b9,       ba,       bb,       bc,       bd,       be,       bf,
-                   '\x0b1a', '\x0b1b', '\x0b1c', '\x0b1d', '\x0b1e', '\x0b1f', '\x0b20', '\x0b21',
-                //       c0,       c1,       c2,       c3,       c4,       c5,       c6,       c7,
-                   '\x0b22', '\x0b23', '\x0b24', '\x0b25', '\x0b26', '\x0b27', '\x0b28', '\x0b28',
-                //       c8,       c9,       ca,       cb,       cc,       cd,       ce,       cf,
-                   '\x0b2a', '\x0b2b', '\x0b2c', '\x0b2d', '\x0b2e', '\x0b2f', '\x0b5f', '\x0b30',
-                //       d0,       d1,       d2,       d3,       d4,       d5,       d6,       d7,
-                   '\x0b30', '\x0b32', '\x0b33', '\x0b33', '\x0b2c', '\x0b36', '\x0b37', '\x0b38',
-                //       d8,       d9,       da,       db,       dc,       dd,       de,       df,
-                   '\x0b39', '\x0000', '\x0b3e', '\x0b3f', '\x0b40', '\x0b41', '\x0b42', '\x0b43',
-                //       e0,       e1,       e2,       e3,       e4,       e5,       e6,       e7,
-                   '\x0b47', '\x0b47', '\x0b48', '\x0b48', '\x0b4b', '\x0b4b', '\x0b4c', '\x0b4c',
-                //       e8,       e9,       ea,       eb,       ec,       ed,       ee,       ef,
-                   '\x0b4d', '\x0b3c', '\x002e', '\x0000', '\x0000', '\x0000', '\x0000', '\x0000',
-                //       f0,       f1,       f2,       f3,       f4,       f5,       f6,       f7,
-                   '\x0000', '\x0b66', '\x0b67', '\x0b68', '\x0b69', '\x0b6a', '\x0b6b', '\x0b6c',
-                //       f8,       f9,       fa,       fb,       fc,       fd,       fe,       ff
-                   '\x0b6d', '\x0b6e', '\x0b6f', '\x0000', '\x0000', '\x0000', '\x0000', '\x0000'
-                },
-
-                // Alternate Unicode Char & Flags
-                {
-                //       a0,       a1,       a2,       a3,       a4,       a5,       a6,       a7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0', '\x0c0c', '\x0c61',
-                //       a8,       a9,       aa,       ab,       ac,       ad,       ae,       af,
-                      '\x0',    '\x0', '\x0c60',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       b0,       b1,       b2,       b3,       b4,       b5,       b6,       b7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       b8,       b9,       ba,       bb,       bc,       bd,       be,       bf,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0', '\x0b5c',
-                //       c0,       c1,       c2,       c3,       c4,       c5,       c6,       c7,
-                   '\x0b5d',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       c8,       c9,       ca,       cb,       cc,       cd,       ce,       cf,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       d0,       d1,       d2,       d3,       d4,       d5,       d6,       d7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       d8,       d9,       da,       db,       dc,       dd,       de,       df,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0', '\x0c44',
-                //       e0,       e1,       e2,       e3,       e4,       e5,       e6,       e7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       e8,       e9,       ea,       eb,       ec,       ed,       ee,       ef,
-                   '\x200C', '\x200D', '\x0b3d',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       f0,       f1,       f2,       f3,       f4,       f5,       f6,       f7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       f8,       f9,       fa,       fb,       fc,       fd,       fe,       ff
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0'
-                }
-            },
-
-            {
-                ////////////////////////////////////////////////////////////////////////////
-                //
-                //  Kannada     Table 5', Code Page   (8, '48', 57008)
-                //
-                ////////////////////////////////////////////////////////////////////////////
-
-                // Default Unicode Char
-                {
-                //       a0,       a1,       a2,       a3,       a4,       a5,       a6,       a7,
-                   '\x0000', '\x0000', '\x0c82', '\x0c83', '\x0c85', '\x0c86', '\x0c87', '\x0c88',
-                //       a8,       a9,       aa,       ab,       ac,       ad,       ae,       af,
-                   '\x0c89', '\x0c8a', '\x0c8b', '\x0c8e', '\x0c8f', '\x0c90', '\x0c90', '\x0c92',
-                //       b0,       b1,       b2,       b3,       b4,       b5,       b6,       b7,
-                   '\x0c93', '\x0c94', '\x0c94', '\x0c95', '\x0c96', '\x0c97', '\x0c98', '\x0c99',
-                //       b8,       b9,       ba,       bb,       bc,       bd,       be,       bf,
-                   '\x0c9a', '\x0c9b', '\x0c9c', '\x0c9d', '\x0c9e', '\x0c9f', '\x0ca0', '\x0ca1',
-                //       c0,       c1,       c2,       c3,       c4,       c5,       c6,       c7,
-                   '\x0ca2', '\x0ca3', '\x0ca4', '\x0ca5', '\x0ca6', '\x0ca7', '\x0ca8', '\x0ca8',
-                //       c8,       c9,       ca,       cb,       cc,       cd,       ce,       cf,
-                   '\x0caa', '\x0cab', '\x0cac', '\x0cad', '\x0cae', '\x0caf', '\x0caf', '\x0cb0',
-                //       d0,       d1,       d2,       d3,       d4,       d5,       d6,       d7,
-                   '\x0cb1', '\x0cb2', '\x0cb3', '\x0cb3', '\x0cb5', '\x0cb6', '\x0cb7', '\x0cb8',
-                //       d8,       d9,       da,       db,       dc,       dd,       de,       df,
-                   '\x0cb9', '\x0000', '\x0cbe', '\x0cbf', '\x0cc0', '\x0cc1', '\x0cc2', '\x0cc3',
-                //       e0,       e1,       e2,       e3,       e4,       e5,       e6,       e7,
-                   '\x0cc6', '\x0cc7', '\x0cc8', '\x0cc8', '\x0cca', '\x0ccb', '\x0ccc', '\x0ccc',
-                //       e8,       e9,       ea,       eb,       ec,       ed,       ee,       ef,
-                   '\x0ccd', '\x0000', '\x002e', '\x0000', '\x0000', '\x0000', '\x0000', '\x0000',
-                //       f0,       f1,       f2,       f3,       f4,       f5,       f6,       f7,
-                   '\x0000', '\x0ce6', '\x0ce7', '\x0ce8', '\x0ce9', '\x0cea', '\x0ceb', '\x0cec',
-                //       f8,       f9,       fa,       fb,       fc,       fd,       fe,       ff
-                   '\x0ced', '\x0cee', '\x0cef', '\x0000', '\x0000', '\x0000', '\x0000', '\x0000'
-                },
-
-                // Alternate Unicode Char & Flags
-                {
-                //       a0,       a1,       a2,       a3,       a4,       a5,       a6,       a7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0', '\x0c8c', '\x0ce1',
-                //       a8,       a9,       aa,       ab,       ac,       ad,       ae,       af,
-                      '\x0',    '\x0', '\x0ce0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       b0,       b1,       b2,       b3,       b4,       b5,       b6,       b7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       b8,       b9,       ba,       bb,       bc,       bd,       be,       bf,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       c0,       c1,       c2,       c3,       c4,       c5,       c6,       c7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       c8,       c9,       ca,       cb,       cc,       cd,       ce,       cf,
-                      '\x0', '\x0cde',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       d0,       d1,       d2,       d3,       d4,       d5,       d6,       d7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       d8,       d9,       da,       db,       dc,       dd,       de,       df,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0', '\x0cc4',
-                //       e0,       e1,       e2,       e3,       e4,       e5,       e6,       e7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       e8,       e9,       ea,       eb,       ec,       ed,       ee,       ef,
-                   '\x200C', '\x200D',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       f0,       f1,       f2,       f3,       f4,       f5,       f6,       f7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       f8,       f9,       fa,       fb,       fc,       fd,       fe,       ff
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0'
-                }
-            },
-
-            {
-                ////////////////////////////////////////////////////////////////////////////
-                //
-                //  Malayalam    Table 6', Code Page   (9, '49', 57009)
-                //
-                ////////////////////////////////////////////////////////////////////////////
-
-                // Default Unicode Char
-                {
-                //       a0,       a1,       a2,       a3,       a4,       a5,       a6,       a7,
-                   '\x0000', '\x0000', '\x0d02', '\x0d03', '\x0d05', '\x0d06', '\x0d07', '\x0d08',
-                //       a8,       a9,       aa,       ab,       ac,       ad,       ae,       af,
-                   '\x0d09', '\x0d0a', '\x0d0b', '\x0d0e', '\x0d0f', '\x0d10', '\x0d10', '\x0d12',
-                //       b0,       b1,       b2,       b3,       b4,       b5,       b6,       b7,
-                   '\x0d13', '\x0d14', '\x0d14', '\x0d15', '\x0d16', '\x0d17', '\x0d18', '\x0d19',
-                //       b8,       b9,       ba,       bb,       bc,       bd,       be,       bf,
-                   '\x0d1a', '\x0d1b', '\x0d1c', '\x0d1d', '\x0d1e', '\x0d1f', '\x0d20', '\x0d21',
-                //       c0,       c1,       c2,       c3,       c4,       c5,       c6,       c7,
-                   '\x0d22', '\x0d23', '\x0d24', '\x0d25', '\x0d26', '\x0d27', '\x0d28', '\x0d28',
-                //       c8,       c9,       ca,       cb,       cc,       cd,       ce,       cf,
-                   '\x0d2a', '\x0d2b', '\x0d2c', '\x0d2d', '\x0d2e', '\x0d2f', '\x0d2f', '\x0d30',
-                //       d0,       d1,       d2,       d3,       d4,       d5,       d6,       d7,
-                   '\x0d31', '\x0d32', '\x0d33', '\x0d34', '\x0d35', '\x0d36', '\x0d37', '\x0d38',
-                //       d8,       d9,       da,       db,       dc,       dd,       de,       df,
-                   '\x0d39', '\x0000', '\x0d3e', '\x0d3f', '\x0d40', '\x0d41', '\x0d42', '\x0d43',
-                //       e0,       e1,       e2,       e3,       e4,       e5,       e6,       e7,
-                   '\x0d46', '\x0d47', '\x0d48', '\x0d48', '\x0d4a', '\x0d4b', '\x0d4c', '\x0d4c',
-                //       e8,       e9,       ea,       eb,       ec,       ed,       ee,       ef,
-                   '\x0d4d', '\x0000', '\x002e', '\x0000', '\x0000', '\x0000', '\x0000', '\x0000',
-                //       f0,       f1,       f2,       f3,       f4,       f5,       f6,       f7,
-                   '\x0000', '\x0d66', '\x0d67', '\x0d68', '\x0d69', '\x0d6a', '\x0d6b', '\x0d6c',
-                //       f8,       f9,       fa,       fb,       fc,       fd,       fe,       ff
-                   '\x0d6d', '\x0d6e', '\x0d6f', '\x0000', '\x0000', '\x0000', '\x0000', '\x0000'
-                },
-
-                // Alternate Unicode Char & Flags
-                {
-                //       a0,       a1,       a2,       a3,       a4,       a5,       a6,       a7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0', '\x0d0c', '\x0d61',
-                //       a8,       a9,       aa,       ab,       ac,       ad,       ae,       af,
-                      '\x0',    '\x0', '\x0d60',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       b0,       b1,       b2,       b3,       b4,       b5,       b6,       b7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       b8,       b9,       ba,       bb,       bc,       bd,       be,       bf,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       c0,       c1,       c2,       c3,       c4,       c5,       c6,       c7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       c8,       c9,       ca,       cb,       cc,       cd,       ce,       cf,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       d0,       d1,       d2,       d3,       d4,       d5,       d6,       d7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       d8,       d9,       da,       db,       dc,       dd,       de,       df,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       e0,       e1,       e2,       e3,       e4,       e5,       e6,       e7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       e8,       e9,       ea,       eb,       ec,       ed,       ee,       ef,
-                   '\x200C', '\x200D',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       f0,       f1,       f2,       f3,       f4,       f5,       f6,       f7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       f8,       f9,       fa,       fb,       fc,       fd,       fe,       ff
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0'
-                }
-            },
-
-            {
-                ////////////////////////////////////////////////////////////////////////////
-                //
-                //  Gujarati   Table 7', Code Page (10', '4a', 57010)
-                //
-                ////////////////////////////////////////////////////////////////////////////
-
-                // Default Unicode Char
-                {
-                //       a0,       a1,       a2,       a3,       a4,       a5,       a6,       a7,
-                   '\x0000', '\x0a81', '\x0a82', '\x0a83', '\x0a85', '\x0a86', '\x0a87', '\x0a88',
-                //       a8,       a9,       aa,       ab,       ac,       ad,       ae,       af,
-                   '\x0a89', '\x0a8a', '\x0a8b', '\x0a8f', '\x0a8f', '\x0a90', '\x0a8d', '\x0a8d',
-                //       b0,       b1,       b2,       b3,       b4,       b5,       b6,       b7,
-                   '\x0a93', '\x0a94', '\x0a91', '\x0a95', '\x0a96', '\x0a97', '\x0a98', '\x0a99',
-                //       b8,       b9,       ba,       bb,       bc,       bd,       be,       bf,
-                   '\x0a9a', '\x0a9b', '\x0a9c', '\x0a9d', '\x0a9e', '\x0a9f', '\x0aa0', '\x0aa1',
-                //       c0,       c1,       c2,       c3,       c4,       c5,       c6,       c7,
-                   '\x0aa2', '\x0aa3', '\x0aa4', '\x0aa5', '\x0aa6', '\x0aa7', '\x0aa8', '\x0aa8',
-                //       c8,       c9,       ca,       cb,       cc,       cd,       ce,       cf,
-                   '\x0aaa', '\x0aab', '\x0aac', '\x0aad', '\x0aae', '\x0aaf', '\x0aaf', '\x0ab0',
-                //       d0,       d1,       d2,       d3,       d4,       d5,       d6,       d7,
-                   '\x0ab0', '\x0ab2', '\x0ab3', '\x0ab3', '\x0ab5', '\x0ab6', '\x0ab7', '\x0ab8',
-                //       d8,       d9,       da,       db,       dc,       dd,       de,       df,
-                   '\x0ab9', '\x0000', '\x0abe', '\x0abf', '\x0ac0', '\x0ac1', '\x0ac2', '\x0ac3',
-                //       e0,       e1,       e2,       e3,       e4,       e5,       e6,       e7,
-                   '\x0ac7', '\x0ac7', '\x0ac8', '\x0ac5', '\x0acb', '\x0acb', '\x0acc', '\x0ac9',
-                //       e8,       e9,       ea,       eb,       ec,       ed,       ee,       ef,
-                   '\x0acd', '\x0abc', '\x002e', '\x0000', '\x0000', '\x0000', '\x0000', '\x0000',
-                //       f0,       f1,       f2,       f3,       f4,       f5,       f6,       f7,
-                   '\x0000', '\x0ae6', '\x0ae7', '\x0ae8', '\x0ae9', '\x0aea', '\x0aeb', '\x0aec',
-                //       f8,       f9,       fa,       fb,       fc,       fd,       fe,       ff
-                   '\x0aed', '\x0aee', '\x0aef', '\x0000', '\x0000', '\x0000', '\x0000', '\x0000'
-                },
-
-                // Alternate Unicode Char & Flags
-                {
-                //       a0,       a1,       a2,       a3,       a4,       a5,       a6,       a7,
-                      '\x0', '\x0ad0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       a8,       a9,       aa,       ab,       ac,       ad,       ae,       af,
-                      '\x0',    '\x0', '\x0ae0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       b0,       b1,       b2,       b3,       b4,       b5,       b6,       b7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       b8,       b9,       ba,       bb,       bc,       bd,       be,       bf,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       c0,       c1,       c2,       c3,       c4,       c5,       c6,       c7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       c8,       c9,       ca,       cb,       cc,       cd,       ce,       cf,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       d0,       d1,       d2,       d3,       d4,       d5,       d6,       d7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       d8,       d9,       da,       db,       dc,       dd,       de,       df,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0', '\x0ac4',
-                //       e0,       e1,       e2,       e3,       e4,       e5,       e6,       e7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       e8,       e9,       ea,       eb,       ec,       ed,       ee,       ef,
-                   '\x200C', '\x200D', '\x0abd',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       f0,       f1,       f2,       f3,       f4,       f5,       f6,       f7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       f8,       f9,       fa,       fb,       fc,       fd,       fe,       ff
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0'
-                }
-            },
-
-            {
-                ////////////////////////////////////////////////////////////////////////////
-                //
-                //  Punjabi (Gurmukhi)    Table 8', Code Page (11', '4b', 57011)
-                //
-                ////////////////////////////////////////////////////////////////////////////
-
-                // Default Unicode Char
-                {
-                //       a0,       a1,       a2,       a3,       a4,       a5,       a6,       a7,
-                   '\x0000', '\x0000', '\x0a02', '\x0000', '\x0a05', '\x0a06', '\x0a07', '\x0a08',
-                //       a8,       a9,       aa,       ab,       ac,       ad,       ae,       af,
-                   '\x0a09', '\x0a0a', '\x0000', '\x0a0f', '\x0a0f', '\x0a10', '\x0a10', '\x0a10',
-                //       b0,       b1,       b2,       b3,       b4,       b5,       b6,       b7,
-                   '\x0a13', '\x0a14', '\x0a14', '\x0a15', '\x0a16', '\x0a17', '\x0a18', '\x0a19',
-                //       b8,       b9,       ba,       bb,       bc,       bd,       be,       bf,
-                   '\x0a1a', '\x0a1b', '\x0a1c', '\x0a1d', '\x0a1e', '\x0a1f', '\x0a20', '\x0a21',
-                //       c0,       c1,       c2,       c3,       c4,       c5,       c6,       c7,
-                   '\x0a22', '\x0a23', '\x0a24', '\x0a25', '\x0a26', '\x0a27', '\x0a28', '\x0a28',
-                //       c8,       c9,       ca,       cb,       cc,       cd,       ce,       cf,
-                   '\x0a2a', '\x0a2b', '\x0a2c', '\x0a2d', '\x0a2e', '\x0a2f', '\x0a2f', '\x0a30',
-                //       d0,       d1,       d2,       d3,       d4,       d5,       d6,       d7,
-                   '\x0a30', '\x0a32', '\x0a33', '\x0a33', '\x0a35', '\x0a36', '\x0a36', '\x0a38',
-                //       d8,       d9,       da,       db,       dc,       dd,       de,       df,
-                   '\x0a39', '\x0000', '\x0a3e', '\x0a3f', '\x0a40', '\x0a41', '\x0a42', '\x0000',
-                //       e0,       e1,       e2,       e3,       e4,       e5,       e6,       e7,
-                   '\x0a47', '\x0a47', '\x0a48', '\x0a48', '\x0a4b', '\x0a4b', '\x0a4c', '\x0a4c',
-                //       e8,       e9,       ea,       eb,       ec,       ed,       ee,       ef,
-                   '\x0a4d', '\x0a3c', '\x002e', '\x0000', '\x0000', '\x0000', '\x0000', '\x0000',
-                //       f0,       f1,       f2,       f3,       f4,       f5,       f6,       f7,
-                   '\x0000', '\x0a66', '\x0a67', '\x0a68', '\x0a69', '\x0a6a', '\x0a6b', '\x0a6c',
-                //       f8,       f9,       fa,       fb,       fc,       fd,       fe,       ff
-                   '\x0a6d', '\x0a6e', '\x0a6f', '\x0000', '\x0000', '\x0000', '\x0000', '\x0000'
-                },
-
-                // Alternate Unicode Char & Flags
-                {
-                //       a0,       a1,       a2,       a3,       a4,       a5,       a6,       a7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       a8,       a9,       aa,       ab,       ac,       ad,       ae,       af,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       b0,       b1,       b2,       b3,       b4,       b5,       b6,       b7,
-                      '\x0',    '\x0',    '\x0',    '\x0', '\x0a59', '\x0a5a',    '\x0',    '\x0',
-                //       b8,       b9,       ba,       bb,       bc,       bd,       be,       bf,
-                      '\x0',    '\x0', '\x0a5b',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       c0,       c1,       c2,       c3,       c4,       c5,       c6,       c7,
-                   '\x0a5c',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       c8,       c9,       ca,       cb,       cc,       cd,       ce,       cf,
-                      '\x0', '\x0a5e',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       d0,       d1,       d2,       d3,       d4,       d5,       d6,       d7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       d8,       d9,       da,       db,       dc,       dd,       de,       df,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       e0,       e1,       e2,       e3,       e4,       e5,       e6,       e7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       e8,       e9,       ea,       eb,       ec,       ed,       ee,       ef,
-                   '\x200C', '\x200D',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       f0,       f1,       f2,       f3,       f4,       f5,       f6,       f7,
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',
-                //       f8,       f9,       fa,       fb,       fc,       fd,       fe,       ff
-                      '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0',    '\x0'
-                }
-            }
-        };
-    }
-
-}
diff --git a/src/mscorlib/src/System/Text/Latin1Encoding.cs b/src/mscorlib/src/System/Text/Latin1Encoding.cs
index 8fe8f898b2..26009bf6c0 100644
--- a/src/mscorlib/src/System/Text/Latin1Encoding.cs
+++ b/src/mscorlib/src/System/Text/Latin1Encoding.cs
@@ -13,7 +13,6 @@ namespace System.Text
     using System.Collections;
     using System.Runtime.CompilerServices;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
 
 
     //
diff --git a/src/mscorlib/src/System/Text/MLangCodePageEncoding.cs b/src/mscorlib/src/System/Text/MLangCodePageEncoding.cs
deleted file mode 100644
index a82db91b98..0000000000
--- a/src/mscorlib/src/System/Text/MLangCodePageEncoding.cs
+++ /dev/null
@@ -1,172 +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.
-
-
-// WARNING:
-//
-// This is just an IObjectReference proxy for the former MLang Encodings (V1.1)
-// We keep the old name now even for the Whidbey V2.0 IObjectReference because it also
-// works with the Everett V1.1 version.
-namespace System.Text
-{
-    using System;
-    using System.Runtime.Serialization;
-    using System.Security.Permissions;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-
-    /*=================================MLangCodePageEncoding==================================
-    ** This class is here only to deserialize the MLang classes from Everett (V1.1) into
-    ** Appropriate Whidbey (V2.0) objects.  We also serialize the Whidbey classes
-    ** using this proxy since we pretty much need one anyway and that solves Whidbey
-    ** to Everett compatibility as well.
-    ==============================================================================*/
-
-    [Serializable]
-    internal sealed class MLangCodePageEncoding : IObjectReference, ISerializable
-    {
-        // Temp stuff
-        [NonSerialized]
-        private int m_codePage;
-        [NonSerialized]
-        private bool m_isReadOnly;
-        [NonSerialized]
-        private bool m_deserializedFromEverett = false;
-
-        [NonSerialized]
-        private EncoderFallback encoderFallback = null;
-        [NonSerialized]
-        private DecoderFallback decoderFallback = null;
-
-        // Might need this when GetRealObjecting
-        [NonSerialized]
-        private Encoding realEncoding = null;
-
-        // Constructor called by serialization.
-        internal MLangCodePageEncoding(SerializationInfo info, StreamingContext context)
-        {
-            // Any info?
-            if (info==null) throw new ArgumentNullException(nameof(info));
-            Contract.EndContractBlock();
-
-            // All versions have a code page
-            this.m_codePage = (int)info.GetValue("m_codePage", typeof(int));
-
-            // See if we have a code page
-            try
-            {
-                //
-                // Try Whidbey V2.0 Fields
-                //
-                this.m_isReadOnly = (bool)info.GetValue("m_isReadOnly", typeof(bool));
-
-                this.encoderFallback = (EncoderFallback)info.GetValue("encoderFallback", typeof(EncoderFallback));
-                this.decoderFallback = (DecoderFallback)info.GetValue("decoderFallback", typeof(DecoderFallback));
-            }
-            catch (SerializationException)
-            {
-                //
-                // Didn't have Whidbey things, must be Everett
-                //
-                this.m_deserializedFromEverett = true;
-
-                // May as well be read only
-                this.m_isReadOnly = true;
-            }
-        }
-
-        // Just get it from GetEncoding
-        public Object GetRealObject(StreamingContext context)
-        {
-            // Get our encoding (Note: This has default fallbacks for readonly and everett cases)
-            this.realEncoding = Encoding.GetEncoding(this.m_codePage);
-
-            // If its read only then it uses default fallbacks, otherwise pick up the new ones
-            // Otherwise we want to leave the new one read only
-            if (!this.m_deserializedFromEverett && !this.m_isReadOnly)
-            {
-                this.realEncoding = (Encoding)this.realEncoding.Clone();
-                this.realEncoding.EncoderFallback = this.encoderFallback;
-                this.realEncoding.DecoderFallback = this.decoderFallback;
-            }
-
-            return this.realEncoding;
-        }
-
-        // ISerializable implementation
-        void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
-        {
-            // We cannot ever call this.
-            Debug.Assert(false, "Didn't expect to make it to MLangCodePageEncoding ISerializable.GetObjectData");
-            throw new ArgumentException(Environment.GetResourceString("Arg_ExecutionEngineException"));        
-        }
-
-// Same problem with the Encoder, this only happens with Everett Encoders
-        [Serializable]
-        internal sealed class MLangEncoder : IObjectReference, ISerializable
-        {
-            // Might need this when GetRealObjecting
-            [NonSerialized]
-            private Encoding realEncoding = null;
-
-            // Constructor called by serialization, have to handle deserializing from Everett
-            internal MLangEncoder(SerializationInfo info, StreamingContext context)
-            {
-                // Any info?
-                if (info==null) throw new ArgumentNullException(nameof(info));
-                Contract.EndContractBlock();
-
-                this.realEncoding = (Encoding)info.GetValue("m_encoding", typeof(Encoding));
-            }
-
-            // Just get it from GetEncoder
-            public Object GetRealObject(StreamingContext context)
-            {
-                return this.realEncoding.GetEncoder();
-            }
-
-            // ISerializable implementation, get data for this object
-            void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
-            {
-                // We cannot ever call this.
-                Debug.Assert(false, "Didn't expect to make it to MLangCodePageEncoding.MLangEncoder.GetObjectData");
-                throw new ArgumentException(Environment.GetResourceString("Arg_ExecutionEngineException"));
-            }
-        }
-
-
-        // Same problem with the Decoder, this only happens with Everett Decoders
-        [Serializable]
-        internal sealed class MLangDecoder : IObjectReference, ISerializable
-        {
-            // Might need this when GetRealObjecting
-            [NonSerialized]
-            private Encoding realEncoding = null;
-
-            // Constructor called by serialization, have to handle deserializing from Everett
-            internal MLangDecoder(SerializationInfo info, StreamingContext context)
-            {
-                // Any info?
-                if (info==null) throw new ArgumentNullException(nameof(info));
-                Contract.EndContractBlock();
-
-                this.realEncoding = (Encoding)info.GetValue("m_encoding", typeof(Encoding));
-            }
-
-            // Just get it from GetDecoder
-            public Object GetRealObject(StreamingContext context)
-            {
-                return this.realEncoding.GetDecoder();
-            }
-
-            // ISerializable implementation, get data for this object
-            void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
-            {
-                // We cannot ever call this.
-                Debug.Assert(false, "Didn't expect to make it to MLangCodePageEncoding.MLangDecoder.GetObjectData");
-                throw new ArgumentException(Environment.GetResourceString("Arg_ExecutionEngineException"));
-            }
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Text/Normalization.cs b/src/mscorlib/src/System/Text/Normalization.cs
index 4ed921f7fd..c81149d59a 100644
--- a/src/mscorlib/src/System/Text/Normalization.cs
+++ b/src/mscorlib/src/System/Text/Normalization.cs
@@ -5,7 +5,6 @@
 namespace System.Text
 {
     // This is the enumeration for Normalization Forms
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum NormalizationForm
     {
         FormC    = 1,
diff --git a/src/mscorlib/src/System/Text/StringBuilder.cs b/src/mscorlib/src/System/Text/StringBuilder.cs
index 9d221ceafa..72247c333e 100644
--- a/src/mscorlib/src/System/Text/StringBuilder.cs
+++ b/src/mscorlib/src/System/Text/StringBuilder.cs
@@ -41,7 +41,6 @@ namespace System.Text {
     // Console.WriteLine(sb1);
     // Console.WriteLine(sb2);
     // 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public sealed class StringBuilder : ISerializable
     {
@@ -715,20 +714,17 @@ namespace System.Text {
             }
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public StringBuilder AppendLine() {
             Contract.Ensures(Contract.Result<StringBuilder>() != null);
             return Append(Environment.NewLine);
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public StringBuilder AppendLine(string value) {
             Contract.Ensures(Contract.Result<StringBuilder>() != null);
             Append(value);
             return Append(Environment.NewLine);
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count) {
             if (destination == null) {
                 throw new ArgumentNullException(nameof(destination));
diff --git a/src/mscorlib/src/System/Text/SurrogateEncoder.cs b/src/mscorlib/src/System/Text/SurrogateEncoder.cs
deleted file mode 100644
index bbfa180f29..0000000000
--- a/src/mscorlib/src/System/Text/SurrogateEncoder.cs
+++ /dev/null
@@ -1,57 +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.
-
-
-// WARNING:
-//
-// This is just an IObjectReference proxy for the former V1.1 Surrogate Encoder
-// All this does is make an encoder of the correct type, it DOES NOT maintain state.
-namespace System.Text
-{
-    using System;
-    using System.Runtime.Serialization;
-    using System.Security.Permissions;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-
-    /*=================================SurrogateEncoder==================================
-    ** This class is here only to deserialize the SurrogateEncoder class from Everett (V1.1) into
-    ** Appropriate Whidbey (V2.0) objects.
-    ==============================================================================*/
-
-    [Serializable]
-    internal sealed class SurrogateEncoder : IObjectReference, ISerializable
-    {
-        // Might need this when GetRealObjecting
-        [NonSerialized]
-        private Encoding realEncoding = null;
-
-        // Constructor called by serialization.
-        internal SurrogateEncoder(SerializationInfo info, StreamingContext context)
-        {
-            // Any info?
-            if (info==null) throw new ArgumentNullException(nameof(info));
-            Contract.EndContractBlock();
-
-            // All versions have a code page
-            this.realEncoding = (Encoding)info.GetValue("m_encoding", typeof(Encoding));
-        }
-
-        // Just get it from GetEncoding
-        public Object GetRealObject(StreamingContext context)
-        {
-            // Need to get our Encoding's Encoder
-            return this.realEncoding.GetEncoder();
-        }
-
-        // ISerializable implementation
-        void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
-        {
-            // We cannot ever call this.
-            Debug.Assert(false, "Didn't expect to make it to SurrogateEncoder.GetObjectData");
-            throw new ArgumentException(Environment.GetResourceString("Arg_ExecutionEngineException"));
-        }
-    }
-}
-
diff --git a/src/mscorlib/src/System/Text/UTF7Encoding.cs b/src/mscorlib/src/System/Text/UTF7Encoding.cs
index 624ca735f6..9418d2e768 100644
--- a/src/mscorlib/src/System/Text/UTF7Encoding.cs
+++ b/src/mscorlib/src/System/Text/UTF7Encoding.cs
@@ -10,13 +10,11 @@ namespace System.Text
 {
     using System;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
 
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class UTF7Encoding : Encoding
     {
         private const String base64Chars =
@@ -127,7 +125,6 @@ namespace System.Text
 
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override bool Equals(Object value)
         {
             UTF7Encoding that = value as UTF7Encoding;
@@ -142,7 +139,6 @@ namespace System.Text
 
         // Compared to all the other encodings, variations of UTF7 are unlikely
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetHashCode()
         {
             return this.CodePage + this.EncoderFallback.GetHashCode() + this.DecoderFallback.GetHashCode();
@@ -170,20 +166,17 @@ namespace System.Text
             return EncodingForwarder.GetByteCount(this, chars, index, count);
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetByteCount(String s)
         {
             return EncodingForwarder.GetByteCount(this, s);
         }
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override unsafe int GetByteCount(char* chars, int count)
         {
             return EncodingForwarder.GetByteCount(this, chars, count);
         }
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override int GetBytes(String s, int charIndex, int charCount,
                                               byte[] bytes, int byteIndex)
         {
@@ -206,7 +199,6 @@ namespace System.Text
         }
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override unsafe int GetBytes(char* chars, int charCount, byte* bytes, int byteCount)
         {
             return EncodingForwarder.GetBytes(this, chars, charCount, bytes, byteCount);
@@ -221,7 +213,6 @@ namespace System.Text
         }
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override unsafe int GetCharCount(byte* bytes, int count)
         {
             return EncodingForwarder.GetCharCount(this, bytes, count);
@@ -234,7 +225,6 @@ namespace System.Text
         }
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
         {
             return EncodingForwarder.GetChars(this, bytes, byteCount, chars, charCount);
@@ -243,7 +233,6 @@ namespace System.Text
         // Returns a string containing the decoded representation of a range of
         // bytes in a byte array.
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override String GetString(byte[] bytes, int index, int count)
         {
             return EncodingForwarder.GetString(this, bytes, index, count);
diff --git a/src/mscorlib/src/System/Text/UTF8Encoding.cs b/src/mscorlib/src/System/Text/UTF8Encoding.cs
index ba19649b56..191bbfef56 100644
--- a/src/mscorlib/src/System/Text/UTF8Encoding.cs
+++ b/src/mscorlib/src/System/Text/UTF8Encoding.cs
@@ -20,7 +20,6 @@ namespace System.Text
     using System;
     using System.Globalization;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
 
@@ -37,7 +36,6 @@ namespace System.Text
     // switch the byte orderings.
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public class UTF8Encoding : Encoding
     {
         /*
@@ -131,7 +129,6 @@ namespace System.Text
         }
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override unsafe int GetByteCount(char* chars, int count)
         {
             return EncodingForwarder.GetByteCount(this, chars, count);
@@ -159,7 +156,6 @@ namespace System.Text
         }
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override unsafe int GetBytes(char* chars, int charCount, byte* bytes, int byteCount)
         {
             return EncodingForwarder.GetBytes(this, chars, charCount, bytes, byteCount);
@@ -174,7 +170,6 @@ namespace System.Text
         }
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override unsafe int GetCharCount(byte* bytes, int count)
         {
             return EncodingForwarder.GetCharCount(this, bytes, count);
@@ -187,7 +182,6 @@ namespace System.Text
         }
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
         {
             return EncodingForwarder.GetChars(this, bytes, byteCount, chars, charCount);
@@ -196,7 +190,6 @@ namespace System.Text
         // Returns a string containing the decoded representation of a range of
         // bytes in a byte array.
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override String GetString(byte[] bytes, int index, int count)
         {
             return EncodingForwarder.GetString(this, bytes, index, count);
diff --git a/src/mscorlib/src/System/Text/UnicodeEncoding.cs b/src/mscorlib/src/System/Text/UnicodeEncoding.cs
index 25255c3230..d8ef18ab05 100644
--- a/src/mscorlib/src/System/Text/UnicodeEncoding.cs
+++ b/src/mscorlib/src/System/Text/UnicodeEncoding.cs
@@ -11,13 +11,11 @@ namespace System.Text
     using System;
     using System.Globalization;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
 
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class UnicodeEncoding : Encoding
     {
         // Used by Encoding.BigEndianUnicode/Unicode for lazy initialization
@@ -111,7 +109,6 @@ namespace System.Text
         }
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override unsafe int GetByteCount(char* chars, int count)
         {
             return EncodingForwarder.GetByteCount(this, chars, count);
@@ -139,7 +136,6 @@ namespace System.Text
         }
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override unsafe int GetBytes(char* chars, int charCount, byte* bytes, int byteCount)
         {
             return EncodingForwarder.GetBytes(this, chars, charCount, bytes, byteCount);
@@ -154,7 +150,6 @@ namespace System.Text
         }
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override unsafe int GetCharCount(byte* bytes, int count)
         {
             return EncodingForwarder.GetCharCount(this, bytes, count);
@@ -167,7 +162,6 @@ namespace System.Text
         }
 
         [CLSCompliant(false)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
         {
             return EncodingForwarder.GetChars(this, bytes, byteCount, chars, charCount);
@@ -176,7 +170,6 @@ namespace System.Text
         // Returns a string containing the decoded representation of a range of
         // bytes in a byte array.
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override String GetString(byte[] bytes, int index, int count)
         {
             return EncodingForwarder.GetString(this, bytes, index, count);
@@ -1659,7 +1652,6 @@ namespace System.Text
         }
 
 
-        [System.Runtime.InteropServices.ComVisible(false)]
         public override System.Text.Encoder GetEncoder()
         {
             return new EncoderNLS(this);
diff --git a/src/mscorlib/src/System/ThreadAttributes.cs b/src/mscorlib/src/System/ThreadAttributes.cs
index bbd859c3af..6248736107 100644
--- a/src/mscorlib/src/System/ThreadAttributes.cs
+++ b/src/mscorlib/src/System/ThreadAttributes.cs
@@ -4,16 +4,13 @@
 
 /*=============================================================================
 **
-**
-**
 ** Purpose: For Threads-related custom attributes.
 **
-**
 =============================================================================*/
 
-namespace System {
-    [AttributeUsage (AttributeTargets.Method)]  
-[System.Runtime.InteropServices.ComVisible(true)]
+namespace System
+{
+    [AttributeUsage(AttributeTargets.Method)]
     public sealed class STAThreadAttribute : Attribute
     {
         public STAThreadAttribute()
@@ -21,8 +18,7 @@ namespace System {
         }
     }
 
-    [AttributeUsage (AttributeTargets.Method)]  
-[System.Runtime.InteropServices.ComVisible(true)]
+    [AttributeUsage(AttributeTargets.Method)]
     public sealed class MTAThreadAttribute : Attribute
     {
         public MTAThreadAttribute()
diff --git a/src/mscorlib/src/System/ThreadStaticAttribute.cs b/src/mscorlib/src/System/ThreadStaticAttribute.cs
index 58842eef0b..3755e65a7b 100644
--- a/src/mscorlib/src/System/ThreadStaticAttribute.cs
+++ b/src/mscorlib/src/System/ThreadStaticAttribute.cs
@@ -12,14 +12,14 @@
 **
 **
 ===========================================================*/
-namespace System {
-    
-    using System;
 
-[Serializable]
+using System;
+
+namespace System
+{
+    [Serializable]
     [AttributeUsage(AttributeTargets.Field, Inherited = false)]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public class  ThreadStaticAttribute : Attribute
+    public class ThreadStaticAttribute : Attribute
     {
         public ThreadStaticAttribute()
         {
diff --git a/src/mscorlib/src/System/Threading/ApartmentState.cs b/src/mscorlib/src/System/Threading/ApartmentState.cs
index 844f85e9e7..1edf0af98a 100644
--- a/src/mscorlib/src/System/Threading/ApartmentState.cs
+++ b/src/mscorlib/src/System/Threading/ApartmentState.cs
@@ -15,7 +15,6 @@
 namespace System.Threading {
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum ApartmentState
     {   
         /*=========================================================================
diff --git a/src/mscorlib/src/System/Threading/AsyncLocal.cs b/src/mscorlib/src/System/Threading/AsyncLocal.cs
index 6ed1545ac7..8c4319bd2c 100644
--- a/src/mscorlib/src/System/Threading/AsyncLocal.cs
+++ b/src/mscorlib/src/System/Threading/AsyncLocal.cs
@@ -127,8 +127,6 @@ namespace System.Threading
     {
         public static IAsyncLocalValueMap Empty { get; } = new EmptyAsyncLocalValueMap();
 
-        public static IAsyncLocalValueMap Create(IAsyncLocal key, object value) => new OneElementAsyncLocalValueMap(key, value);
-
         // Instance without any key/value pairs.  Used as a singleton/
         private sealed class EmptyAsyncLocalValueMap : IAsyncLocalValueMap
         {
diff --git a/src/mscorlib/src/System/Threading/AutoResetEvent.cs b/src/mscorlib/src/System/Threading/AutoResetEvent.cs
index 78a6fa1234..fc6b2301ca 100644
--- a/src/mscorlib/src/System/Threading/AutoResetEvent.cs
+++ b/src/mscorlib/src/System/Threading/AutoResetEvent.cs
@@ -14,10 +14,8 @@
 namespace System.Threading {
     
     using System;
-    using System.Security.Permissions;
     using System.Runtime.InteropServices;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class AutoResetEvent : EventWaitHandle
     {
         public AutoResetEvent(bool initialState) : base(initialState,EventResetMode.AutoReset){ }
diff --git a/src/mscorlib/src/System/Threading/CancellationToken.cs b/src/mscorlib/src/System/Threading/CancellationToken.cs
index 5b78f20900..b68ba4c046 100644
--- a/src/mscorlib/src/System/Threading/CancellationToken.cs
+++ b/src/mscorlib/src/System/Threading/CancellationToken.cs
@@ -9,7 +9,6 @@
 
 using System;
 using System.Runtime.InteropServices;
-using System.Security.Permissions;
 using System.Diagnostics;
 using System.Diagnostics.Contracts;
 using System.Runtime;
@@ -38,7 +37,6 @@ namespace System.Threading
     /// All members of this struct are thread-safe and may be used concurrently from multiple threads.
     /// </para>
     /// </remarks>
-    [ComVisible(false)]
     [DebuggerDisplay("IsCancellationRequested = {IsCancellationRequested}")]
     public struct CancellationToken
     {
@@ -317,11 +315,8 @@ namespace System.Threading
         }
 
         // the real work..
-        [MethodImpl(MethodImplOptions.NoInlining)]
         private CancellationTokenRegistration Register(Action<Object> callback, Object state, bool useSynchronizationContext, bool useExecutionContext)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-
             if (callback == null)
                 throw new ArgumentNullException(nameof(callback));
 
@@ -341,8 +336,7 @@ namespace System.Threading
                 if (useSynchronizationContext)
                     capturedSyncContext = SynchronizationContext.Current;
                 if (useExecutionContext)
-                    capturedExecutionContext = ExecutionContext.Capture(
-                        ref stackMark, ExecutionContext.CaptureOptions.OptimizeDefaultCase); // ideally we'd also use IgnoreSyncCtx, but that could break compat
+                    capturedExecutionContext = ExecutionContext.Capture();
             }
 
             // Register the callback with the source.
diff --git a/src/mscorlib/src/System/Threading/CancellationTokenRegistration.cs b/src/mscorlib/src/System/Threading/CancellationTokenRegistration.cs
index ac27fe30e6..89e98fa3c8 100644
--- a/src/mscorlib/src/System/Threading/CancellationTokenRegistration.cs
+++ b/src/mscorlib/src/System/Threading/CancellationTokenRegistration.cs
@@ -6,7 +6,6 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 using System.Diagnostics.Contracts;
-using System.Security.Permissions;
 using System.Runtime.CompilerServices;
 
 namespace System.Threading
diff --git a/src/mscorlib/src/System/Threading/CancellationTokenSource.cs b/src/mscorlib/src/System/Threading/CancellationTokenSource.cs
index 2caa4f265a..1e70d6f30f 100644
--- a/src/mscorlib/src/System/Threading/CancellationTokenSource.cs
+++ b/src/mscorlib/src/System/Threading/CancellationTokenSource.cs
@@ -10,7 +10,6 @@ using System;
 using System.Security;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
-using System.Security.Permissions;
 using System.Diagnostics;
 using System.Diagnostics.Contracts;
 using System.Runtime;
@@ -35,7 +34,6 @@ namespace System.Threading
     /// concurrently from multiple threads.
     /// </para>
     /// </remarks>
-    [ComVisible(false)]
 
     public class CancellationTokenSource : IDisposable
     {
diff --git a/src/mscorlib/src/System/Threading/CountdownEvent.cs b/src/mscorlib/src/System/Threading/CountdownEvent.cs
index d86a2ccfb8..af055e347e 100644
--- a/src/mscorlib/src/System/Threading/CountdownEvent.cs
+++ b/src/mscorlib/src/System/Threading/CountdownEvent.cs
@@ -11,7 +11,6 @@
 // =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 
 using System;
-using System.Security.Permissions;
 using System.Runtime.InteropServices;
 using System.Threading;
 using System.Diagnostics;
@@ -30,7 +29,6 @@ namespace System.Threading
     /// completed, and Reset, which should only be used when no other threads are
     /// accessing the event.
     /// </remarks>
-    [ComVisible(false)]
     [DebuggerDisplay("Initial Count={InitialCount}, Current Count={CurrentCount}")]
     public class CountdownEvent : IDisposable
     {
diff --git a/src/mscorlib/src/System/Threading/EventWaitHandle.cs b/src/mscorlib/src/System/Threading/EventWaitHandle.cs
index 4b1611c6aa..0268948a5c 100644
--- a/src/mscorlib/src/System/Threading/EventWaitHandle.cs
+++ b/src/mscorlib/src/System/Threading/EventWaitHandle.cs
@@ -15,10 +15,10 @@
 
 namespace System.Security.AccessControl
 {
-    public class EventWaitHandleSecurity
+    internal class EventWaitHandleSecurity
     {
     }
-    public enum EventWaitHandleRights
+    internal enum EventWaitHandleRights
     {
     }
 }
@@ -28,7 +28,6 @@ namespace System.Threading
     using System;
     using System.Threading;
     using System.Runtime.CompilerServices;
-    using System.Security.Permissions;
     using System.IO;
     using Microsoft.Win32;
     using Microsoft.Win32.SafeHandles;
@@ -89,7 +88,7 @@ namespace System.Threading
         {
         }
 
-        public unsafe EventWaitHandle(bool initialState, EventResetMode mode, string name, out bool createdNew, EventWaitHandleSecurity eventSecurity)
+        internal unsafe EventWaitHandle(bool initialState, EventResetMode mode, string name, out bool createdNew, EventWaitHandleSecurity eventSecurity)
         {
             if(name != null)
             {
@@ -146,7 +145,7 @@ namespace System.Threading
             return OpenExisting(name, (EventWaitHandleRights)0);
         }
 
-        public static EventWaitHandle OpenExisting(string name, EventWaitHandleRights rights)
+        internal static EventWaitHandle OpenExisting(string name, EventWaitHandleRights rights)
         {
             EventWaitHandle result;
             switch (OpenExistingWorker(name, rights, out result))
@@ -171,11 +170,6 @@ namespace System.Threading
             return OpenExistingWorker(name, (EventWaitHandleRights)0, out result) == OpenExistingResult.Success;
         }
 
-        public static bool TryOpenExisting(string name, EventWaitHandleRights rights, out EventWaitHandle result)
-        {
-            return OpenExistingWorker(name, rights, out result) == OpenExistingResult.Success;
-        }
-
         private static OpenExistingResult OpenExistingWorker(string name, EventWaitHandleRights rights, out EventWaitHandle result)
         {
 #if PLATFORM_UNIX
diff --git a/src/mscorlib/src/System/Threading/ExecutionContext.cs b/src/mscorlib/src/System/Threading/ExecutionContext.cs
index 5ea9942f65..47a55a3bb9 100644
--- a/src/mscorlib/src/System/Threading/ExecutionContext.cs
+++ b/src/mscorlib/src/System/Threading/ExecutionContext.cs
@@ -19,7 +19,6 @@ namespace System.Threading
     using System.Reflection;
     using System.Runtime.ExceptionServices;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     using System.Runtime.InteropServices;
     using System.Runtime.CompilerServices;
     using System.Runtime.ConstrainedExecution;
@@ -27,7 +26,6 @@ namespace System.Threading
     using System.Diagnostics.Contracts;
     using System.Diagnostics.CodeAnalysis;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public delegate void ContextCallback(Object state);
 
     internal struct ExecutionContextSwitcher
@@ -55,7 +53,7 @@ namespace System.Threading
     [Serializable]
     public sealed class ExecutionContext : IDisposable, ISerializable
     {
-        private static readonly ExecutionContext Default = new ExecutionContext();
+        internal static readonly ExecutionContext Default = new ExecutionContext();
 
         private readonly IAsyncLocalValueMap m_localValues;
         private readonly IAsyncLocal[] m_localChangeNotifications;
@@ -93,16 +91,10 @@ namespace System.Threading
         public static ExecutionContext Capture()
         {
             ExecutionContext executionContext = Thread.CurrentThread.ExecutionContext;
-            if (executionContext == null)
-            {
-                return Default;
-            }
-            if (executionContext.m_isFlowSuppressed)
-            {
-                // Prevent ExecutionContext.Run on a suppressed-flow context for desktop framework compatibility
-                return null;
-            }
-            return executionContext;
+            return
+                executionContext == null ? Default :
+                executionContext.m_isFlowSuppressed ? null :
+                executionContext;
         }
 
         private ExecutionContext ShallowClone(bool isFlowSuppressed)
@@ -301,38 +293,6 @@ namespace System.Threading
             }
         }
 
-    #region Wrappers for CLR compat, to avoid ifdefs all over the BCL
-
-        [Flags]
-        internal enum CaptureOptions
-        {
-            None = 0x00,
-            IgnoreSyncCtx = 0x01,
-            OptimizeDefaultCase = 0x02,
-        }
-
-        internal static ExecutionContext Capture(ref StackCrawlMark stackMark, CaptureOptions captureOptions)
-        {
-            return Capture();
-        }
-
-        [FriendAccessAllowed]
-        internal static ExecutionContext FastCapture()
-        {
-            return Capture();
-        }
-
-        [FriendAccessAllowed]
-        internal static void Run(ExecutionContext executionContext, ContextCallback callback, Object state, bool preserveSyncCtx)
-        {
-            Run(executionContext, callback, state);
-        }
-
-        internal bool IsDefaultFTContext(bool ignoreSyncCtx)
-        {
-            return this == Default;
-        }
-
         public ExecutionContext CreateCopy()
         {
             return this; // since CoreCLR's ExecutionContext is immutable, we don't need to create copies.
@@ -342,18 +302,6 @@ namespace System.Threading
         {
             // For CLR compat only
         }
-
-        internal static ExecutionContext PreAllocatedDefault
-        {
-            get { return ExecutionContext.Default; }
-        }
-
-        internal bool IsPreAllocatedDefault
-        {
-            get { return this == ExecutionContext.Default; }
-        }
-
-    #endregion
     }
 
     public struct AsyncFlowControl : IDisposable
diff --git a/src/mscorlib/src/System/Threading/IObjectHandle.cs b/src/mscorlib/src/System/Threading/IObjectHandle.cs
deleted file mode 100644
index 464f06e52d..0000000000
--- a/src/mscorlib/src/System/Threading/IObjectHandle.cs
+++ /dev/null
@@ -1,31 +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.
-
-/*============================================================
-**
-**
-**
-** IObjectHandle defines the interface for unwrapping objects.
-** Objects that are marshal by value object can be returned through 
-** an indirection allowing the caller to control when the
-** object is loaded into their domain. The caller can unwrap
-** the object from the indirection through this interface.
-**
-** 
-===========================================================*/
-namespace System.Runtime.Remoting {
-
-    using System;
-    using System.Runtime.InteropServices;
-
-    [ InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown),
-      GuidAttribute("C460E2B4-E199-412a-8456-84DC3E4838C3") ]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface IObjectHandle {
-        // Unwrap the object. Implementers of this interface
-        // typically have an indirect referece to another object.
-        Object Unwrap();
-    }
-}
-
diff --git a/src/mscorlib/src/System/Threading/Interlocked.cs b/src/mscorlib/src/System/Threading/Interlocked.cs
index 8a0b527fc0..131d51a65b 100644
--- a/src/mscorlib/src/System/Threading/Interlocked.cs
+++ b/src/mscorlib/src/System/Threading/Interlocked.cs
@@ -6,7 +6,6 @@
 namespace System.Threading
 {
     using System;
-    using System.Security.Permissions;
     using System.Runtime.CompilerServices;
     using System.Runtime.ConstrainedExecution;
     using System.Runtime.Versioning;
@@ -25,13 +24,11 @@ namespace System.Threading
          *                        long
          *****************************/
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static int Increment(ref int location)
         {
             return Add(ref location, 1);
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static long Increment(ref long location)
         {
             return Add(ref location, 1);
@@ -43,7 +40,6 @@ namespace System.Threading
          *                        long
          *****************************/
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static int Decrement(ref int location)
         {
             return Add(ref location, -1);
@@ -65,7 +61,6 @@ namespace System.Threading
          *****************************/
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static extern int Exchange(ref int location1, int value);
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
@@ -78,15 +73,11 @@ namespace System.Threading
         public static extern double Exchange(ref double location1, double value);
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static extern Object Exchange(ref Object location1, Object value);
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static extern IntPtr Exchange(ref IntPtr location1, IntPtr value);
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public static T Exchange<T>(ref T location1, T value) where T : class
         {
             _Exchange(__makeref(location1), __makeref(value));
@@ -98,7 +89,6 @@ namespace System.Threading
         }
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         private static extern void _Exchange(TypedReference location1, TypedReference value);
 
         /******************************
@@ -112,7 +102,6 @@ namespace System.Threading
          *****************************/
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static extern int CompareExchange(ref int location1, int value, int comparand);    
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
@@ -125,11 +114,9 @@ namespace System.Threading
         public static extern double CompareExchange(ref double location1, double value, double comparand);    
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static extern Object CompareExchange(ref Object location1, Object value, Object comparand);
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static extern IntPtr CompareExchange(ref IntPtr location1, IntPtr value, IntPtr comparand);
 
         /*****************************************************************
@@ -156,8 +143,6 @@ namespace System.Threading
          * for details.
          *****************************************************************/
         
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
-        [System.Runtime.InteropServices.ComVisible(false)]
         public static T CompareExchange<T>(ref T location1, T value, T comparand) where T : class
         {
             // _CompareExchange() passes back the value read from location1 via local named 'value'
@@ -166,12 +151,10 @@ namespace System.Threading
         }
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         private static extern void _CompareExchange(TypedReference location1, TypedReference value, Object comparand);
 
         // BCL-internal overload that returns success via a ref bool param, useful for reliable spin locks.
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal static extern int CompareExchange(ref int location1, int value, int comparand, ref bool succeeded);
 
         /******************************
@@ -181,19 +164,16 @@ namespace System.Threading
          *****************************/
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         internal static extern int ExchangeAdd(ref int location1, int value);
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         internal static extern long ExchangeAdd(ref long location1, long value);
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static int Add(ref int location1, int value) 
         {
             return ExchangeAdd(ref location1, value) + value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static long Add(ref long location1, long value) 
         {
             return ExchangeAdd(ref location1, value) + value;
diff --git a/src/mscorlib/src/System/Threading/LazyInitializer.cs b/src/mscorlib/src/System/Threading/LazyInitializer.cs
index 238cc89dbd..af32673d03 100644
--- a/src/mscorlib/src/System/Threading/LazyInitializer.cs
+++ b/src/mscorlib/src/System/Threading/LazyInitializer.cs
@@ -11,7 +11,6 @@
 // =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 
 
-using System.Security.Permissions;
 using System.Diagnostics;
 using System.Diagnostics.Contracts;
 namespace System.Threading
diff --git a/src/mscorlib/src/System/Threading/LockCookie.cs b/src/mscorlib/src/System/Threading/LockCookie.cs
deleted file mode 100644
index c1fbfd828e..0000000000
--- a/src/mscorlib/src/System/Threading/LockCookie.cs
+++ /dev/null
@@ -1,57 +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: Defines the lock that implements 
-**          single-writer/multiple-reader semantics
-**
-**
-===========================================================*/
-
-namespace System.Threading {
-
-    using System;
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public struct LockCookie
-    {
-        private int _dwFlags;
-        private int _dwWriterSeqNum;
-        private int _wReaderAndWriterLevel;
-        private int _dwThreadID;
-
-        public override int GetHashCode()
-        {
-            return _dwFlags + _dwWriterSeqNum + _wReaderAndWriterLevel + _dwThreadID;
-        }
-        
-        public override bool Equals(Object obj)
-        {
-            if (obj is LockCookie)
-                return Equals((LockCookie)obj);
-            else
-                return false;
-        }
-        
-        public bool Equals(LockCookie obj)
-        {
-            return obj._dwFlags == _dwFlags && obj._dwWriterSeqNum == _dwWriterSeqNum &&
-                obj._wReaderAndWriterLevel == _wReaderAndWriterLevel && obj._dwThreadID == _dwThreadID;
-        }
-        
-        public static bool operator ==(LockCookie a, LockCookie b)
-        {
-            return a.Equals(b);
-        }
-        
-        public static bool operator !=(LockCookie a, LockCookie b)
-        {
-            return !(a == b);
-        }
-    }
-}
-
diff --git a/src/mscorlib/src/System/Threading/LockRecursionException.cs b/src/mscorlib/src/System/Threading/LockRecursionException.cs
index ab95e70c7e..40f04b00b4 100644
--- a/src/mscorlib/src/System/Threading/LockRecursionException.cs
+++ b/src/mscorlib/src/System/Threading/LockRecursionException.cs
@@ -19,7 +19,6 @@ namespace System.Threading
     using System.Runtime.CompilerServices;
 
     [Serializable]
-    [System.Security.Permissions.HostProtection(MayLeakOnAbort = true)]
     public class LockRecursionException : System.Exception
     {
         public LockRecursionException() { }
diff --git a/src/mscorlib/src/System/Threading/ManualResetEvent.cs b/src/mscorlib/src/System/Threading/ManualResetEvent.cs
index 00041567df..a8e012fb43 100644
--- a/src/mscorlib/src/System/Threading/ManualResetEvent.cs
+++ b/src/mscorlib/src/System/Threading/ManualResetEvent.cs
@@ -14,10 +14,8 @@
 namespace System.Threading {
     
     using System;
-    using System.Security.Permissions;
     using System.Runtime.InteropServices;
 
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class ManualResetEvent : EventWaitHandle
     {        
         public ManualResetEvent(bool initialState) : base(initialState,EventResetMode.ManualReset){}
diff --git a/src/mscorlib/src/System/Threading/ManualResetEventSlim.cs b/src/mscorlib/src/System/Threading/ManualResetEventSlim.cs
index 509af5bfa0..2d57b4102b 100644
--- a/src/mscorlib/src/System/Threading/ManualResetEventSlim.cs
+++ b/src/mscorlib/src/System/Threading/ManualResetEventSlim.cs
@@ -13,7 +13,6 @@
 // =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 
 using System;
-using System.Security.Permissions;
 using System.Threading;
 using System.Runtime.InteropServices;
 using System.Diagnostics;
@@ -45,7 +44,6 @@ namespace System.Threading
     /// completed, and Reset, which should only be used when no other threads are
     /// accessing the event.
     /// </remarks>
-    [ComVisible(false)]
     [DebuggerDisplay("Set = {IsSet}")]
     public class ManualResetEventSlim : IDisposable
     {
diff --git a/src/mscorlib/src/System/Threading/Monitor.cs b/src/mscorlib/src/System/Threading/Monitor.cs
index 94dec13d05..fdbc384243 100644
--- a/src/mscorlib/src/System/Threading/Monitor.cs
+++ b/src/mscorlib/src/System/Threading/Monitor.cs
@@ -17,7 +17,6 @@
 namespace System.Threading {
 
     using System;
-    using System.Security.Permissions;
     using System.Runtime;
     using System.Runtime.Remoting;
     using System.Threading;
@@ -27,7 +26,6 @@ namespace System.Threading {
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public static class Monitor 
     {
         /*=========================================================================
@@ -76,7 +74,6 @@ namespace System.Threading {
         **             own the lock.
         =========================================================================*/
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static extern void Exit(Object obj);
     
         /*=========================================================================
diff --git a/src/mscorlib/src/System/Threading/Mutex.cs b/src/mscorlib/src/System/Threading/Mutex.cs
index 31897abc21..dcb821307a 100644
--- a/src/mscorlib/src/System/Threading/Mutex.cs
+++ b/src/mscorlib/src/System/Threading/Mutex.cs
@@ -16,7 +16,6 @@ namespace System.Threading
     using System;
     using System.Threading;
     using System.Runtime.CompilerServices;
-    using System.Security.Permissions;
     using System.IO;
     using Microsoft.Win32;
     using Microsoft.Win32.SafeHandles;
@@ -27,23 +26,20 @@ namespace System.Threading
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
 
-    [ComVisible(true)]
     public sealed class Mutex : WaitHandle
     {
         static bool dummyBool;
 
-        public class MutexSecurity
+        internal class MutexSecurity
         {
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public Mutex(bool initiallyOwned, String name, out bool createdNew)
             : this(initiallyOwned, name, out createdNew, (MutexSecurity)null)
         {
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
-        public unsafe Mutex(bool initiallyOwned, String name, out bool createdNew, MutexSecurity mutexSecurity)
+        internal unsafe Mutex(bool initiallyOwned, String name, out bool createdNew, MutexSecurity mutexSecurity)
         {
             if (name == string.Empty)
             {
@@ -62,26 +58,6 @@ namespace System.Threading
             CreateMutexWithGuaranteedCleanup(initiallyOwned, name, out createdNew, secAttrs);
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
-        internal Mutex(bool initiallyOwned, String name, out bool createdNew, Win32Native.SECURITY_ATTRIBUTES secAttrs) 
-        {
-            if (name == string.Empty)
-            {
-                // Empty name is treated as an unnamed mutex. Set to null, and we will check for null from now on.
-                name = null;
-            }
-#if !PLATFORM_UNIX
-            if (name != null && System.IO.Path.MaxPath < name.Length)
-            {
-                throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong", Path.MaxPath), nameof(name));
-            }
-#endif
-            Contract.EndContractBlock();
-
-            CreateMutexWithGuaranteedCleanup(initiallyOwned, name, out createdNew, secAttrs);
-        }
-
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         internal void CreateMutexWithGuaranteedCleanup(bool initiallyOwned, String name, out bool createdNew, Win32Native.SECURITY_ATTRIBUTES secAttrs)
         {
             RuntimeHelpers.CleanupCode cleanupCode = new RuntimeHelpers.CleanupCode(MutexCleanupCode);
@@ -104,7 +80,6 @@ namespace System.Threading
             Win32Native.SECURITY_ATTRIBUTES m_secAttrs;
             Mutex m_mutex;
 
-            [PrePrepareMethod]
             internal MutexTryCodeHelper(bool initiallyOwned,MutexCleanupInfo cleanupInfo, String name, Win32Native.SECURITY_ATTRIBUTES secAttrs, Mutex mutex)
             {
                 Debug.Assert(name == null || name.Length != 0);
@@ -116,7 +91,6 @@ namespace System.Threading
                 m_mutex = mutex;
             }
 
-            [PrePrepareMethod]
             internal void MutexTryCode(object userData)
             {  
                 SafeWaitHandle mutexHandle = null;
@@ -170,7 +144,6 @@ namespace System.Threading
             }
         }
 
-        [PrePrepareMethod]
         private void MutexCleanupCode(Object userData, bool exceptionThrown)
         {
             MutexCleanupInfo cleanupInfo = (MutexCleanupInfo) userData;
@@ -198,21 +171,17 @@ namespace System.Threading
             }
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public Mutex(bool initiallyOwned, String name) : this(initiallyOwned, name, out dummyBool) {
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public Mutex(bool initiallyOwned) : this(initiallyOwned, null, out dummyBool)
         {
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public Mutex() : this(false, null, out dummyBool)
         {
         }
         
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         private Mutex(SafeWaitHandle handle)
         {
             SetHandleInternal(handle);
@@ -224,11 +193,11 @@ namespace System.Threading
             return OpenExisting(name, (MutexRights) 0);
         }
 
-        public enum MutexRights
+        internal enum MutexRights
         {
         }
 
-        public static Mutex OpenExisting(string name, MutexRights rights)
+        internal static Mutex OpenExisting(string name, MutexRights rights)
         {
             Mutex result;
             switch (OpenExistingWorker(name, rights, out result))
@@ -253,11 +222,6 @@ namespace System.Threading
             return OpenExistingWorker(name, (MutexRights)0, out result) == OpenExistingResult.Success;
         }
 
-        public static bool TryOpenExisting(string name, MutexRights rights, out Mutex result)
-        {
-            return OpenExistingWorker(name, rights, out result) == OpenExistingResult.Success;
-        }
-
         private static OpenExistingResult OpenExistingWorker(string name, MutexRights rights, out Mutex result)
         {
             if (name == null)
@@ -316,7 +280,6 @@ namespace System.Threading
         // Note: To call ReleaseMutex, you must have an ACL granting you
         // MUTEX_MODIFY_STATE rights (0x0001).  The other interesting value
         // in a Mutex's ACL is MUTEX_ALL_ACCESS (0x1F0001).
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public void ReleaseMutex()
         {
             if (Win32Native.ReleaseMutex(safeWaitHandle))
@@ -328,7 +291,6 @@ namespace System.Threading
             }
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         static int CreateMutexHandle(bool initiallyOwned, String name, Win32Native.SECURITY_ATTRIBUTES securityAttribute, out SafeWaitHandle mutexHandle)
         {
             int errorCode;
diff --git a/src/mscorlib/src/System/Threading/Overlapped.cs b/src/mscorlib/src/System/Threading/Overlapped.cs
index 2b192c7b3a..d3caff5e74 100644
--- a/src/mscorlib/src/System/Threading/Overlapped.cs
+++ b/src/mscorlib/src/System/Threading/Overlapped.cs
@@ -31,7 +31,6 @@ namespace System.Threading
     using System.Runtime.CompilerServices;
     using System.Runtime.Versioning;
     using System.Security;
-    using System.Security.Permissions;
     using System.Runtime.ConstrainedExecution;
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
@@ -44,7 +43,6 @@ namespace System.Threading
     // The first five matches OVERLAPPED structure.
     // The remaining are reserved at the end
     [System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public struct NativeOverlapped
     {
         public IntPtr  InternalLow;
@@ -71,13 +69,11 @@ namespace System.Threading
         {
         }
 
-        internal _IOCompletionCallback(IOCompletionCallback ioCompletionCallback, ref StackCrawlMark stackMark)
+        internal _IOCompletionCallback(IOCompletionCallback ioCompletionCallback)
         {
             _ioCompletionCallback = ioCompletionCallback;
             // clone the exection context
-            _executionContext = ExecutionContext.Capture(
-                ref stackMark, 
-                ExecutionContext.CaptureOptions.IgnoreSyncCtx | ExecutionContext.CaptureOptions.OptimizeDefaultCase);
+            _executionContext = ExecutionContext.Capture();
         }
         // Context callback: same sig for SendOrPostCallback and ContextCallback
         static internal ContextCallback _ccb = new ContextCallback(IOCompletionCallback_Context);
@@ -103,26 +99,23 @@ namespace System.Threading
                 overlapped = OverlappedData.GetOverlappedFromNative(pOVERLAP).m_overlapped;
                 helper  = overlapped.iocbHelper;
 
-            if (helper == null || helper._executionContext == null || helper._executionContext.IsDefaultFTContext(true))
-            {
-                // We got here because of UnsafePack (or) Pack with EC flow supressed
-                IOCompletionCallback callback = overlapped.UserCallback;
-                callback( errorCode,  numBytes,  pOVERLAP);
-            }
-            else
-            {
-                // We got here because of Pack
-                helper._errorCode = errorCode;
-                helper._numBytes = numBytes;
-                helper._pOVERLAP = pOVERLAP;
-                    using (ExecutionContext executionContext = helper._executionContext.CreateCopy())
-                    ExecutionContext.Run(executionContext, _ccb, helper, true);
-            }                    
-
-                    //Quickly check the VM again, to see if a packet has arrived.
-
+                if (helper == null || helper._executionContext == null || helper._executionContext == ExecutionContext.Default)
+                {
+                    // We got here because of UnsafePack (or) Pack with EC flow supressed
+                    IOCompletionCallback callback = overlapped.UserCallback;
+                    callback( errorCode,  numBytes,  pOVERLAP);
+                }
+                else
+                {
+                    // We got here because of Pack
+                    helper._errorCode = errorCode;
+                    helper._numBytes = numBytes;
+                    helper._pOVERLAP = pOVERLAP;
+                    ExecutionContext.Run(helper._executionContext, _ccb, helper);
+                }                    
+
+                //Quickly check the VM again, to see if a packet has arrived.
                 OverlappedData.CheckVMForIOPacket(out pOVERLAP, out errorCode, out numBytes);
-
             } while (pOVERLAP != null);
 
         }
@@ -174,17 +167,15 @@ namespace System.Threading
             m_nativeOverlapped.InternalHigh = (IntPtr)0;
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
         unsafe internal NativeOverlapped* Pack(IOCompletionCallback iocb, Object userData)
         {
             if (!m_pinSelf.IsNull()) {
                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_Overlapped_Pack"));
             }
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
 
             if (iocb != null)
             {
-                m_iocbHelper = new _IOCompletionCallback(iocb, ref stackMark);
+                m_iocbHelper = new _IOCompletionCallback(iocb);
                 m_iocb = iocb;
             }
             else
@@ -229,7 +220,6 @@ namespace System.Threading
             return AllocateNativeOverlapped();
         }
 
-        [ComVisible(false)]
         internal IntPtr UserHandle
         {
             get { return m_nativeOverlapped.EventHandle; }
@@ -255,7 +245,6 @@ namespace System.Threading
     #region class Overlapped
 
     /// <internalonly/>
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class Overlapped
     {
         private OverlappedData m_overlappedData;
@@ -307,7 +296,6 @@ namespace System.Threading
             set { m_overlappedData.UserHandle = new IntPtr(value); }
         }
 
-        [ComVisible(false)]
         public IntPtr EventHandleIntPtr
         {
             get { return m_overlappedData.UserHandle; }
@@ -336,7 +324,7 @@ namespace System.Threading
             return Pack (iocb, null);
         }
 
-        [CLSCompliant(false),ComVisible(false)]
+        [CLSCompliant(false)]
         unsafe public NativeOverlapped* Pack(IOCompletionCallback iocb, Object userData)
         {
             return m_overlappedData.Pack(iocb, userData);
@@ -349,7 +337,7 @@ namespace System.Threading
             return UnsafePack (iocb, null);
         }
 
-        [CLSCompliant(false), ComVisible(false)]
+        [CLSCompliant(false)]
         unsafe public NativeOverlapped* UnsafePack(IOCompletionCallback iocb, Object userData)
         {            
             return m_overlappedData.UnsafePack(iocb, userData);
diff --git a/src/mscorlib/src/System/Threading/ParameterizedThreadStart.cs b/src/mscorlib/src/System/Threading/ParameterizedThreadStart.cs
index 45d24fef49..32b63153c4 100644
--- a/src/mscorlib/src/System/Threading/ParameterizedThreadStart.cs
+++ b/src/mscorlib/src/System/Threading/ParameterizedThreadStart.cs
@@ -15,7 +15,6 @@
 
 
 namespace System.Threading {
-    using System.Security.Permissions;
     using System.Threading;
     using System.Runtime.InteropServices;
 
diff --git a/src/mscorlib/src/System/Threading/SemaphoreSlim.cs b/src/mscorlib/src/System/Threading/SemaphoreSlim.cs
index 29b8f79a5b..c3b43d9585 100644
--- a/src/mscorlib/src/System/Threading/SemaphoreSlim.cs
+++ b/src/mscorlib/src/System/Threading/SemaphoreSlim.cs
@@ -16,7 +16,6 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Security;
-using System.Security.Permissions;
 using System.Runtime.InteropServices;
 using System.Diagnostics.Contracts;
 using System.Threading.Tasks;
@@ -39,7 +38,6 @@ namespace System.Threading
     /// completed.
     /// </para>
     /// </remarks>
-    [ComVisible(false)]
     [DebuggerDisplay("Current Count = {m_currentCount}")]
     public class SemaphoreSlim : IDisposable
     {
diff --git a/src/mscorlib/src/System/Threading/SpinLock.cs b/src/mscorlib/src/System/Threading/SpinLock.cs
index 1d90890d6e..eee73ce2bf 100644
--- a/src/mscorlib/src/System/Threading/SpinLock.cs
+++ b/src/mscorlib/src/System/Threading/SpinLock.cs
@@ -9,19 +9,14 @@
 // repeatedly checking until the lock becomes available. As the thread remains active performing a non-useful task,
 // the use of such a lock is a kind of busy waiting and consumes CPU resources without performing real work. 
 //
-//
 // =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-using System;
-using System.Security.Permissions;
+
+using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Runtime.CompilerServices;
-using System.Runtime.ConstrainedExecution;
-using System.Diagnostics;
-using System.Diagnostics.Contracts;
 
 namespace System.Threading
 {
-
     /// <summary>
     /// Provides a mutual exclusion lock primitive where a thread trying to acquire the lock waits in a loop
     /// repeatedly checking until the lock becomes available.
@@ -54,7 +49,6 @@ namespace System.Threading
     /// concurrently.
     /// </para>
     /// </remarks>
-    [ComVisible(false)]
     [DebuggerTypeProxy(typeof(SystemThreading_SpinLockDebugView))]
     [DebuggerDisplay("IsHeld = {IsHeld}")]
     public struct SpinLock
@@ -106,6 +100,14 @@ namespace System.Threading
         // The waiters count is calculated by m_owner & WAITERS_MASK 01111....110
         private static int MAXIMUM_WAITERS = WAITERS_MASK;
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private int CompareExchange(ref int location, int value, int comparand, ref bool success)
+        {
+            int result = Interlocked.CompareExchange(ref location, value, comparand);
+            success = (result == comparand);
+            return result;
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="T:System.Threading.SpinLock"/>
         /// structure with the option to track thread IDs to improve debugging.
@@ -158,9 +160,8 @@ namespace System.Threading
             int observedOwner = m_owner;
             if (lockTaken || //invalid parameter
                 (observedOwner & ID_DISABLED_AND_ANONYMOUS_OWNED) != LOCK_ID_DISABLE_MASK || //thread tracking is enabled or the lock is already acquired
-                Interlocked.CompareExchange(ref m_owner, observedOwner | LOCK_ANONYMOUS_OWNED, observedOwner, ref lockTaken) != observedOwner) //acquiring the lock failed
+                CompareExchange(ref m_owner, observedOwner | LOCK_ANONYMOUS_OWNED, observedOwner, ref lockTaken) != observedOwner) //acquiring the lock failed
                 ContinueTryEnter(Timeout.Infinite, ref lockTaken); // Then try the slow path if any of the above conditions is met
-
         }
 
         /// <summary>
@@ -183,7 +184,22 @@ namespace System.Threading
         /// </exception>
         public void TryEnter(ref bool lockTaken)
         {
-            TryEnter(0, ref lockTaken);
+            int observedOwner = m_owner;
+            if (((observedOwner & LOCK_ID_DISABLE_MASK) == 0) | lockTaken)
+            {
+                // Thread tracking enabled or invalid arg. Take slow path.
+                ContinueTryEnter(0, ref lockTaken);
+            }
+            else if ((observedOwner & LOCK_ANONYMOUS_OWNED) != 0)
+            {
+                // Lock already held by someone
+                lockTaken = false;
+            }
+            else
+            {
+                // Lock wasn't held; try to acquire it.
+                CompareExchange(ref m_owner, observedOwner | LOCK_ANONYMOUS_OWNED, observedOwner, ref lockTaken);
+            }
         }
 
         /// <summary>
@@ -219,7 +235,7 @@ namespace System.Threading
             if (totalMilliseconds < -1 || totalMilliseconds > int.MaxValue)
             {
                 throw new System.ArgumentOutOfRangeException(
-                    nameof(timeout), timeout, Environment.GetResourceString("SpinLock_TryEnter_ArgumentOutOfRange"));
+                    nameof(timeout), timeout, SR.SpinLock_TryEnter_ArgumentOutOfRange);
             }
 
             // Call reliable enter with the int-based timeout milliseconds
@@ -254,7 +270,7 @@ namespace System.Threading
             if (millisecondsTimeout < -1 || //invalid parameter
                 lockTaken || //invalid parameter
                 (observedOwner & ID_DISABLED_AND_ANONYMOUS_OWNED) != LOCK_ID_DISABLE_MASK ||  //thread tracking is enabled or the lock is already acquired
-                Interlocked.CompareExchange(ref m_owner, observedOwner | LOCK_ANONYMOUS_OWNED, observedOwner, ref lockTaken) != observedOwner) // acquiring the lock failed
+                CompareExchange(ref m_owner, observedOwner | LOCK_ANONYMOUS_OWNED, observedOwner, ref lockTaken) != observedOwner) // acquiring the lock failed
                 ContinueTryEnter(millisecondsTimeout, ref lockTaken); // The call the slow pth
         }
 
@@ -271,13 +287,13 @@ namespace System.Threading
             if (lockTaken)
             {
                 lockTaken = false;
-                throw new System.ArgumentException(Environment.GetResourceString("SpinLock_TryReliableEnter_ArgumentException"));
+                throw new System.ArgumentException(SR.SpinLock_TryReliableEnter_ArgumentException);
             }
 
             if (millisecondsTimeout < -1)
             {
                 throw new ArgumentOutOfRangeException(
-                    nameof(millisecondsTimeout), millisecondsTimeout, Environment.GetResourceString("SpinLock_TryEnter_ArgumentOutOfRange"));
+                    nameof(millisecondsTimeout), millisecondsTimeout, SR.SpinLock_TryEnter_ArgumentOutOfRange);
             }
 
             uint startTime = 0;
@@ -311,7 +327,7 @@ namespace System.Threading
             observedOwner = m_owner;
             if ((observedOwner & LOCK_ANONYMOUS_OWNED) == LOCK_UNOWNED)
             {
-                if (Interlocked.CompareExchange(ref m_owner, observedOwner | 1, observedOwner, ref lockTaken) == observedOwner)
+                if (CompareExchange(ref m_owner, observedOwner | 1, observedOwner, ref lockTaken) == observedOwner)
                 {
                     // Aquired lock
                     return;
@@ -331,7 +347,7 @@ namespace System.Threading
             else //failed to acquire the lock,then try to update the waiters. If the waiters count reached the maximum, jsut break the loop to avoid overflow
             {
                 if ((observedOwner & WAITERS_MASK) != MAXIMUM_WAITERS)
-                    turn = (Interlocked.Add(ref m_owner, 2) & WAITERS_MASK) >> 1 ;
+                    turn = (Interlocked.Add(ref m_owner, 2) & WAITERS_MASK) >> 1;
             }
 
             //***Step 2. Spinning
@@ -353,7 +369,7 @@ namespace System.Threading
                             : (observedOwner - 2) | 1; // otherwise decrement the waiters and set the lock bit
                         Debug.Assert((newOwner & WAITERS_MASK) >= 0);
 
-                        if (Interlocked.CompareExchange(ref m_owner, newOwner, observedOwner, ref lockTaken) == observedOwner)
+                        if (CompareExchange(ref m_owner, newOwner, observedOwner, ref lockTaken) == observedOwner)
                         {
                             return;
                         }
@@ -381,7 +397,7 @@ namespace System.Threading
                            : (observedOwner - 2) | 1; // otherwise decrement the waiters and set the lock bit
                     Debug.Assert((newOwner & WAITERS_MASK) >= 0);
 
-                    if (Interlocked.CompareExchange(ref m_owner, newOwner, observedOwner, ref lockTaken) == observedOwner)
+                    if (CompareExchange(ref m_owner, newOwner, observedOwner, ref lockTaken) == observedOwner)
                     {
                         return;
                     }
@@ -431,7 +447,6 @@ namespace System.Threading
                 }
                 spinner.SpinOnce();
             }
-
         }
 
         /// <summary>
@@ -444,11 +459,11 @@ namespace System.Threading
             int lockUnowned = 0;
             // We are using thread IDs to mark ownership. Snap the thread ID and check for recursion.
             // We also must or the ID enablement bit, to ensure we propagate when we CAS it in.
-            int m_newOwner = Thread.CurrentThread.ManagedThreadId;
+            int m_newOwner = Environment.CurrentManagedThreadId;
             if (m_owner == m_newOwner)
             {
                 // We don't allow lock recursion.
-                throw new LockRecursionException(Environment.GetResourceString("SpinLock_TryEnter_LockRecursionException"));
+                throw new LockRecursionException(SR.SpinLock_TryEnter_LockRecursionException);
             }
 
 
@@ -457,7 +472,6 @@ namespace System.Threading
             // Loop until the lock has been successfully acquired or, if specified, the timeout expires.
             do
             {
-
                 // We failed to get the lock, either from the fast route or the last iteration
                 // and the timeout hasn't expired; spin once and try again.
                 spinner.SpinOnce();
@@ -466,7 +480,7 @@ namespace System.Threading
 
                 if (m_owner == lockUnowned)
                 {
-                    if (Interlocked.CompareExchange(ref m_owner, m_newOwner, lockUnowned, ref lockTaken) == lockUnowned)
+                    if (CompareExchange(ref m_owner, m_newOwner, lockUnowned, ref lockTaken) == lockUnowned)
                     {
                         return;
                     }
@@ -491,7 +505,6 @@ namespace System.Threading
         /// <exception cref="SynchronizationLockException">
         /// Thread ownership tracking is enabled, and the current thread is not the owner of this lock.
         /// </exception>
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public void Exit()
         {
             //This is the fast path for the thread tracking is disabled, otherwise go to the slow path
@@ -517,15 +530,14 @@ namespace System.Threading
         /// <exception cref="SynchronizationLockException">
         /// Thread ownership tracking is enabled, and the current thread is not the owner of this lock.
         /// </exception>
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public void Exit(bool useMemoryBarrier)
         {
             // This is the fast path for the thread tracking is diabled and not to use memory barrier, otherwise go to the slow path
             // The reason not to add else statement if the usememorybarrier is that it will add more barnching in the code and will prevent
-            // method inlining, so this is optimized for useMemoryBarrier=false and Exit() overload optimized for useMemoryBarrier=true
-            if ((m_owner & LOCK_ID_DISABLE_MASK) != 0 && !useMemoryBarrier)
+            // method inlining, so this is optimized for useMemoryBarrier=false and Exit() overload optimized for useMemoryBarrier=true.
+            int tmpOwner = m_owner;
+            if ((tmpOwner & LOCK_ID_DISABLE_MASK) != 0 & !useMemoryBarrier)
             {
-                int tmpOwner = m_owner;
                 m_owner = tmpOwner & (~LOCK_ANONYMOUS_OWNED);
             }
             else
@@ -545,7 +557,7 @@ namespace System.Threading
             if (threadTrackingEnabled && !IsHeldByCurrentThread)
             {
                 throw new System.Threading.SynchronizationLockException(
-                    Environment.GetResourceString("SpinLock_Exit_SynchronizationLockException"));
+                    SR.SpinLock_Exit_SynchronizationLockException);
             }
 
             if (useMemoryBarrier)
@@ -554,7 +566,6 @@ namespace System.Threading
                     Interlocked.Exchange(ref m_owner, LOCK_UNOWNED);
                 else
                     Interlocked.Decrement(ref m_owner);
-
             }
             else
             {
@@ -565,9 +576,7 @@ namespace System.Threading
                     int tmpOwner = m_owner;
                     m_owner = tmpOwner & (~LOCK_ANONYMOUS_OWNED);
                 }
-
             }
-
         }
 
         /// <summary>
@@ -575,7 +584,6 @@ namespace System.Threading
         /// </summary>
         public bool IsHeld
         {
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
             get
             {
                 if (IsThreadOwnerTrackingEnabled)
@@ -601,21 +609,19 @@ namespace System.Threading
         /// </exception>
         public bool IsHeldByCurrentThread
         {
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
             get
             {
                 if (!IsThreadOwnerTrackingEnabled)
                 {
-                    throw new InvalidOperationException(Environment.GetResourceString("SpinLock_IsHeldByCurrentThread"));
+                    throw new InvalidOperationException(SR.SpinLock_IsHeldByCurrentThread);
                 }
-                return ((m_owner & (~LOCK_ID_DISABLE_MASK)) == Thread.CurrentThread.ManagedThreadId);
+                return ((m_owner & (~LOCK_ID_DISABLE_MASK)) == Environment.CurrentManagedThreadId);
             }
         }
 
         /// <summary>Gets whether thread ownership tracking is enabled for this instance.</summary>
         public bool IsThreadOwnerTrackingEnabled
         {
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
             get { return (m_owner & LOCK_ID_DISABLE_MASK) == 0; }
         }
 
diff --git a/src/mscorlib/src/System/Threading/SpinWait.cs b/src/mscorlib/src/System/Threading/SpinWait.cs
index 1b31407e0f..8431f6564f 100644
--- a/src/mscorlib/src/System/Threading/SpinWait.cs
+++ b/src/mscorlib/src/System/Threading/SpinWait.cs
@@ -12,7 +12,6 @@
 
 using System;
 using System.Runtime.ConstrainedExecution;
-using System.Security.Permissions;
 using System.Threading;
 using System.Diagnostics;
 using System.Diagnostics.Contracts;
diff --git a/src/mscorlib/src/System/Threading/SynchronizationContext.cs b/src/mscorlib/src/System/Threading/SynchronizationContext.cs
index 19f32eebcb..f4b3c79409 100644
--- a/src/mscorlib/src/System/Threading/SynchronizationContext.cs
+++ b/src/mscorlib/src/System/Threading/SynchronizationContext.cs
@@ -13,7 +13,6 @@
 namespace System.Threading
 {    
     using Microsoft.Win32.SafeHandles;
-    using System.Security.Permissions;
     using System.Runtime.InteropServices;
     using System.Runtime.CompilerServices;
     using System.Runtime.ExceptionServices;
@@ -131,7 +130,6 @@ namespace System.Threading
 
         // Method called when the CLR does a wait operation
         [CLSCompliant(false)]
-        [PrePrepareMethod]
         public virtual int Wait(IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout)
         {
             return WaitHelper(waitHandles, waitAll, millisecondsTimeout);
@@ -139,8 +137,6 @@ namespace System.Threading
 
         // Method that can be called by Wait overrides
         [CLSCompliant(false)]
-        [PrePrepareMethod]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         protected static int WaitHelper(IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout)
         {
             if (waitHandles == null)
@@ -155,9 +151,7 @@ namespace System.Threading
         // Static helper to which the above method can delegate to in order to get the default
         // COM behavior.
         [CLSCompliant(false)]
-        [PrePrepareMethod]
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         private static extern int WaitHelperNative(IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout);
 
         public static void SetSynchronizationContext(SynchronizationContext syncContext)
@@ -165,11 +159,6 @@ namespace System.Threading
             Thread.CurrentThread.SynchronizationContext = syncContext;
         }
 
-        public static void SetThreadStaticContext(SynchronizationContext syncContext)
-        {
-            Thread.CurrentThread.SynchronizationContext = syncContext;
-        }
-
         public static SynchronizationContext Current 
         {
             get      
diff --git a/src/mscorlib/src/System/Threading/SynchronizationLockException.cs b/src/mscorlib/src/System/Threading/SynchronizationLockException.cs
index 0610a6063d..de42c1f232 100644
--- a/src/mscorlib/src/System/Threading/SynchronizationLockException.cs
+++ b/src/mscorlib/src/System/Threading/SynchronizationLockException.cs
@@ -17,7 +17,6 @@ namespace System.Threading {
 
     using System;
     using System.Runtime.Serialization;
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class SynchronizationLockException : SystemException {
         public SynchronizationLockException() 
diff --git a/src/mscorlib/src/System/Threading/Tasks/ConcurrentExclusiveSchedulerPair.cs b/src/mscorlib/src/System/Threading/Tasks/ConcurrentExclusiveSchedulerPair.cs
index c7a96b0394..a87406a493 100644
--- a/src/mscorlib/src/System/Threading/Tasks/ConcurrentExclusiveSchedulerPair.cs
+++ b/src/mscorlib/src/System/Threading/Tasks/ConcurrentExclusiveSchedulerPair.cs
@@ -20,7 +20,6 @@ using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Contracts;
 using System.Security;
-using System.Security.Permissions;
 
 namespace System.Threading.Tasks
 {
diff --git a/src/mscorlib/src/System/Threading/Tasks/FutureFactory.cs b/src/mscorlib/src/System/Threading/Tasks/FutureFactory.cs
index c98e219e86..137afa11f5 100644
--- a/src/mscorlib/src/System/Threading/Tasks/FutureFactory.cs
+++ b/src/mscorlib/src/System/Threading/Tasks/FutureFactory.cs
@@ -12,7 +12,6 @@
 
 using System;
 using System.Security;
-using System.Security.Permissions;
 using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Diagnostics;
@@ -277,13 +276,11 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> StartNew(Func<TResult> function)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             Task currTask = Task.InternalCurrent;
             return Task<TResult>.StartNew(currTask, function, m_defaultCancellationToken,
-                m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask), ref stackMark);
+                m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask));
         }
 
         /// <summary>
@@ -306,13 +303,11 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> StartNew(Func<TResult> function, CancellationToken cancellationToken)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             Task currTask = Task.InternalCurrent;
             return Task<TResult>.StartNew(currTask, function, cancellationToken,
-                m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask), ref stackMark);
+                m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask));
         }
 
         /// <summary>
@@ -337,13 +332,11 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> StartNew(Func<TResult> function, TaskCreationOptions creationOptions)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             Task currTask = Task.InternalCurrent;
             return Task<TResult>.StartNew(currTask, function, m_defaultCancellationToken,
-                creationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask), ref stackMark);
+                creationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask));
         }
 
         /// <summary>
@@ -379,13 +372,11 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> StartNew(Func<TResult> function, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             return Task<TResult>.StartNew(
                 Task.InternalCurrentIfAttached(creationOptions), function, cancellationToken,
-                creationOptions, InternalTaskOptions.None, scheduler, ref stackMark);
+                creationOptions, InternalTaskOptions.None, scheduler);
         }
 
         /// <summary>
@@ -406,13 +397,11 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> StartNew(Func<Object, TResult> function, Object state)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             Task currTask = Task.InternalCurrent;
             return Task<TResult>.StartNew(currTask, function, state, m_defaultCancellationToken,
-                m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask), ref stackMark);
+                m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask));
         }
 
         /// <summary>
@@ -437,13 +426,11 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> StartNew(Func<Object, TResult> function, Object state, CancellationToken cancellationToken)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             Task currTask = Task.InternalCurrent;
             return Task<TResult>.StartNew(currTask, function, state, cancellationToken,
-                m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask), ref stackMark);
+                m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask));
         }
 
         /// <summary>
@@ -470,13 +457,11 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> StartNew(Func<Object, TResult> function, Object state, TaskCreationOptions creationOptions)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             Task currTask = Task.InternalCurrent;
             return Task<TResult>.StartNew(currTask, function, state, m_defaultCancellationToken,
-                creationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask), ref stackMark);
+                creationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask));
         }
 
         /// <summary>
@@ -514,12 +499,10 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> StartNew(Func<Object, TResult> function, Object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             return Task<TResult>.StartNew(Task.InternalCurrentIfAttached(creationOptions), function, state, cancellationToken,
-                creationOptions, InternalTaskOptions.None, scheduler, ref stackMark);
+                creationOptions, InternalTaskOptions.None, scheduler);
         }
 
         //
@@ -604,11 +587,9 @@ namespace System.Threading.Tasks
         /// <paramref name="endMethod"/> argument is null.</exception>
         /// <returns>A <see cref="T:System.Threading.Tasks.Task{TResult}">Task</see> that represents the
         /// asynchronous operation.</returns>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> FromAsync(IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return FromAsyncImpl(asyncResult, endMethod, null, m_defaultCreationOptions, DefaultScheduler, ref stackMark);
+            return FromAsyncImpl(asyncResult, endMethod, null, m_defaultCreationOptions, DefaultScheduler);
         }
 
         /// <summary>
@@ -630,14 +611,12 @@ namespace System.Threading.Tasks
         /// value.</exception>
         /// <returns>A <see cref="T:System.Threading.Tasks.Task{TResult}">Task</see> that represents the
         /// asynchronous operation.</returns>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> FromAsync(
             IAsyncResult asyncResult,
             Func<IAsyncResult, TResult> endMethod,
             TaskCreationOptions creationOptions)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return FromAsyncImpl(asyncResult, endMethod, null, creationOptions, DefaultScheduler, ref stackMark);
+            return FromAsyncImpl(asyncResult, endMethod, null, creationOptions, DefaultScheduler);
         }
 
 
@@ -665,27 +644,23 @@ namespace System.Threading.Tasks
         /// value.</exception>
         /// <returns>A <see cref="T:System.Threading.Tasks.Task{TResult}">Task</see> that represents the
         /// asynchronous operation.</returns>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> FromAsync(
             IAsyncResult asyncResult,
             Func<IAsyncResult, TResult> endMethod,
             TaskCreationOptions creationOptions,
             TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return FromAsyncImpl(asyncResult, endMethod, null, creationOptions, scheduler, ref stackMark);
+            return FromAsyncImpl(asyncResult, endMethod, null, creationOptions, scheduler);
         }
 
-        // internal overload that supports StackCrawlMark
-        // We also need this logic broken out into a static method so that the similar TaskFactory.FromAsync()
+        // We need this logic broken out into a static method so that the similar TaskFactory.FromAsync()
         // method can access the logic w/o declaring a TaskFactory<TResult> instance.
         internal static Task<TResult> FromAsyncImpl(
             IAsyncResult asyncResult,
             Func<IAsyncResult, TResult> endFunction,
             Action<IAsyncResult> endAction,
             TaskCreationOptions creationOptions,
-            TaskScheduler scheduler,
-            ref StackCrawlMark stackMark)
+            TaskScheduler scheduler)
         {
             if (asyncResult == null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.asyncResult);
@@ -714,12 +689,12 @@ namespace System.Threading.Tasks
             // Just specify this task as detached. No matter what happens, we want endMethod 
             // to be called -- even if the parent is canceled.  So we don't want to flow 
             // RespectParentCancellation.
-            Task t = new Task(delegate
+            Task t = new Task(new Action<object>(delegate
             {
                 FromAsyncCoreLogic(asyncResult, endFunction, endAction, promise, requiresSynchronization:true);
-            },
+            }),
                 (object)null, null,
-                default(CancellationToken), TaskCreationOptions.None, InternalTaskOptions.None, null, ref stackMark);
+                default(CancellationToken), TaskCreationOptions.None, InternalTaskOptions.None, null);
 
             if (AsyncCausalityTracer.LoggingOn)
                 AsyncCausalityTracer.TraceOperationCreation(CausalityTraceLevel.Verbose, t.Id, "TaskFactory.FromAsync Callback", 0);
@@ -1428,14 +1403,12 @@ namespace System.Threading.Tasks
         /// <paramref name="tasks"/> array contains a null value.</exception>
         /// <exception cref="T:System.ArgumentException">The exception that is thrown when the 
         /// <paramref name="tasks"/> array is empty.</exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAll(Task[] tasks, Func<Task[], TResult> continuationFunction)
         {
             if (continuationFunction == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWhenAllImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return ContinueWhenAllImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -1459,14 +1432,12 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAll(Task[] tasks, Func<Task[], TResult> continuationFunction, CancellationToken cancellationToken)
         {
             if (continuationFunction == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWhenAllImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler, ref stackMark);
+            return ContinueWhenAllImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -1496,14 +1467,12 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAll.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAll(Task[] tasks, Func<Task[], TResult> continuationFunction, TaskContinuationOptions continuationOptions)
         {
             if (continuationFunction == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWhenAllImpl(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return ContinueWhenAllImpl(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -1543,15 +1512,13 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAll.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAll(Task[] tasks, Func<Task[], TResult> continuationFunction,
             CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
         {
             if (continuationFunction == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWhenAllImpl(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler, ref stackMark);
+            return ContinueWhenAllImpl(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler);
         }
 
         /// <summary>
@@ -1571,14 +1538,12 @@ namespace System.Threading.Tasks
         /// <paramref name="tasks"/> array contains a null value.</exception>
         /// <exception cref="T:System.ArgumentException">The exception that is thrown when the
         /// <paramref name="tasks"/> array is empty.</exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction)
         {
             if (continuationFunction == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWhenAllImpl<TAntecedentResult>(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return ContinueWhenAllImpl<TAntecedentResult>(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -1603,15 +1568,13 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction,
             CancellationToken cancellationToken)
         {
             if (continuationFunction == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWhenAllImpl<TAntecedentResult>(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler, ref stackMark);
+            return ContinueWhenAllImpl<TAntecedentResult>(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -1642,15 +1605,13 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAll.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction,
             TaskContinuationOptions continuationOptions)
         {
             if (continuationFunction == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWhenAllImpl<TAntecedentResult>(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return ContinueWhenAllImpl<TAntecedentResult>(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -1691,15 +1652,13 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAll.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction,
             CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
         {
             if (continuationFunction == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWhenAllImpl<TAntecedentResult>(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler, ref stackMark);
+            return ContinueWhenAllImpl<TAntecedentResult>(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler);
         }
 
    
@@ -1707,7 +1666,7 @@ namespace System.Threading.Tasks
         // Note: if you make any changes to this method, please do the same to the non-generic version too. 
         internal static Task<TResult> ContinueWhenAllImpl<TAntecedentResult>(Task<TAntecedentResult>[] tasks,
             Func<Task<TAntecedentResult>[], TResult> continuationFunction, Action<Task<TAntecedentResult>[]> continuationAction,
-            TaskContinuationOptions continuationOptions, CancellationToken cancellationToken, TaskScheduler scheduler, ref StackCrawlMark stackMark)
+            TaskContinuationOptions continuationOptions, CancellationToken cancellationToken, TaskScheduler scheduler)
         {
             // check arguments
             TaskFactory.CheckMultiTaskContinuationOptions(continuationOptions);
@@ -1737,7 +1696,7 @@ namespace System.Threading.Tasks
                 return starter.ContinueWith<TResult>(
                    // use a cached delegate
                    GenericDelegateCache<TAntecedentResult, TResult>.CWAllFuncDelegate,
-                   continuationFunction, scheduler, cancellationToken, continuationOptions, ref stackMark);
+                   continuationFunction, scheduler, cancellationToken, continuationOptions);
             }
             else
             {
@@ -1746,7 +1705,7 @@ namespace System.Threading.Tasks
                 return starter.ContinueWith<TResult>(
                    // use a cached delegate
                    GenericDelegateCache<TAntecedentResult, TResult>.CWAllActionDelegate,
-                   continuationAction, scheduler, cancellationToken, continuationOptions, ref stackMark);
+                   continuationAction, scheduler, cancellationToken, continuationOptions);
             }
         }
 
@@ -1754,7 +1713,7 @@ namespace System.Threading.Tasks
         // Note: if you make any changes to this method, please do the same to the generic version too. 
         internal static Task<TResult> ContinueWhenAllImpl(Task[] tasks,
             Func<Task[], TResult> continuationFunction, Action<Task[]> continuationAction,
-            TaskContinuationOptions continuationOptions, CancellationToken cancellationToken, TaskScheduler scheduler, ref StackCrawlMark stackMark)
+            TaskContinuationOptions continuationOptions, CancellationToken cancellationToken, TaskScheduler scheduler)
         {
             // check arguments
             TaskFactory.CheckMultiTaskContinuationOptions(continuationOptions);
@@ -1790,7 +1749,7 @@ namespace System.Threading.Tasks
                         completedTasks.NotifyDebuggerOfWaitCompletionIfNecessary();
                         return ((Func<Task[], TResult>)state)(completedTasks.Result); 
                     },
-                    continuationFunction, scheduler, cancellationToken, continuationOptions, ref stackMark);
+                    continuationFunction, scheduler, cancellationToken, continuationOptions);
             }
             else
             {
@@ -1804,7 +1763,7 @@ namespace System.Threading.Tasks
                        completedTasks.NotifyDebuggerOfWaitCompletionIfNecessary();
                        ((Action<Task[]>)state)(completedTasks.Result); return default(TResult); 
                    },
-                   continuationAction, scheduler, cancellationToken, continuationOptions, ref stackMark);
+                   continuationAction, scheduler, cancellationToken, continuationOptions);
             }
         }
 
@@ -1828,14 +1787,12 @@ namespace System.Threading.Tasks
         /// <paramref name="tasks"/> array contains a null value.</exception>
         /// <exception cref="T:System.ArgumentException">The exception that is thrown when the
         /// <paramref name="tasks"/> array is empty.</exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAny(Task[] tasks, Func<Task, TResult> continuationFunction)
         {
             if (continuationFunction == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWhenAnyImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return ContinueWhenAnyImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -1859,14 +1816,12 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAny(Task[] tasks, Func<Task, TResult> continuationFunction, CancellationToken cancellationToken)
         {
             if (continuationFunction == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWhenAnyImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler, ref stackMark);
+            return ContinueWhenAnyImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -1896,14 +1851,12 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAny.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAny(Task[] tasks, Func<Task, TResult> continuationFunction, TaskContinuationOptions continuationOptions)
         {
             if (continuationFunction == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWhenAnyImpl(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return ContinueWhenAnyImpl(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -1943,15 +1896,13 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAny.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAny(Task[] tasks, Func<Task, TResult> continuationFunction,
             CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
         {
             if (continuationFunction == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWhenAnyImpl(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler, ref stackMark);
+            return ContinueWhenAnyImpl(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler);
         }
 
         /// <summary>
@@ -1971,14 +1922,12 @@ namespace System.Threading.Tasks
         /// <paramref name="tasks"/> array contains a null value.</exception>
         /// <exception cref="T:System.ArgumentException">The exception that is thrown when the
         /// <paramref name="tasks"/> array is empty.</exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction)
         {
             if (continuationFunction == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWhenAnyImpl<TAntecedentResult>(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return ContinueWhenAnyImpl<TAntecedentResult>(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -2003,15 +1952,13 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction,
             CancellationToken cancellationToken)
         {
             if (continuationFunction == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWhenAnyImpl<TAntecedentResult>(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler, ref stackMark);
+            return ContinueWhenAnyImpl<TAntecedentResult>(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -2042,15 +1989,13 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAny.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction,
             TaskContinuationOptions continuationOptions)
         {
             if (continuationFunction == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWhenAnyImpl<TAntecedentResult>(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return ContinueWhenAnyImpl<TAntecedentResult>(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -2091,22 +2036,20 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAny.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction,
             CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
         {
             if (continuationFunction == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWhenAnyImpl<TAntecedentResult>(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler, ref stackMark);
+            return ContinueWhenAnyImpl<TAntecedentResult>(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler);
         }
 
         // Core implementation of ContinueWhenAny, non-generic version
         // Note: if you make any changes to this method, be sure to do the same to the generic version 
         internal static Task<TResult> ContinueWhenAnyImpl(Task[] tasks,
             Func<Task, TResult> continuationFunction, Action<Task> continuationAction,
-            TaskContinuationOptions continuationOptions, CancellationToken cancellationToken, TaskScheduler scheduler, ref StackCrawlMark stackMark)
+            TaskContinuationOptions continuationOptions, CancellationToken cancellationToken, TaskScheduler scheduler)
         {
             // check arguments
             TaskFactory.CheckMultiTaskContinuationOptions(continuationOptions);
@@ -2136,7 +2079,7 @@ namespace System.Threading.Tasks
                     //the following delegate avoids closure capture as much as possible
                     //completedTask.Result is the winning task; state == continuationAction
                      (completedTask, state) => { return ((Func<Task, TResult>)state)(completedTask.Result); },
-                     continuationFunction, scheduler, cancellationToken, continuationOptions, ref stackMark);
+                     continuationFunction, scheduler, cancellationToken, continuationOptions);
             }
             else
             {
@@ -2145,7 +2088,7 @@ namespace System.Threading.Tasks
                     //the following delegate avoids closure capture as much as possible
                     //completedTask.Result is the winning task; state == continuationAction
                     (completedTask, state) => { ((Action<Task>)state)(completedTask.Result); return default(TResult); },
-                    continuationAction, scheduler, cancellationToken, continuationOptions, ref stackMark);
+                    continuationAction, scheduler, cancellationToken, continuationOptions);
             }
         }
 
@@ -2154,7 +2097,7 @@ namespace System.Threading.Tasks
         // Note: if you make any changes to this method, be sure to do the same to the non-generic version 
         internal static Task<TResult> ContinueWhenAnyImpl<TAntecedentResult>(Task<TAntecedentResult>[] tasks,
             Func<Task<TAntecedentResult>, TResult> continuationFunction, Action<Task<TAntecedentResult>> continuationAction,
-            TaskContinuationOptions continuationOptions, CancellationToken cancellationToken, TaskScheduler scheduler, ref StackCrawlMark stackMark)
+            TaskContinuationOptions continuationOptions, CancellationToken cancellationToken, TaskScheduler scheduler)
         {
             // check arguments
             TaskFactory.CheckMultiTaskContinuationOptions(continuationOptions);
@@ -2182,7 +2125,7 @@ namespace System.Threading.Tasks
                 return starter.ContinueWith<TResult>(
                     // Use a cached delegate
                     GenericDelegateCache<TAntecedentResult, TResult>.CWAnyFuncDelegate,
-                    continuationFunction, scheduler, cancellationToken, continuationOptions, ref stackMark);
+                    continuationFunction, scheduler, cancellationToken, continuationOptions);
             }
             else
             {
@@ -2190,7 +2133,7 @@ namespace System.Threading.Tasks
                 return starter.ContinueWith<TResult>(
                     // Use a cached delegate
                     GenericDelegateCache<TAntecedentResult,TResult>.CWAnyActionDelegate,
-                    continuationAction, scheduler, cancellationToken, continuationOptions, ref stackMark);
+                    continuationAction, scheduler, cancellationToken, continuationOptions);
             }
         }
     }
diff --git a/src/mscorlib/src/System/Threading/Tasks/IAsyncCausalityTracerStatics.cs b/src/mscorlib/src/System/Threading/Tasks/IAsyncCausalityTracerStatics.cs
index b8155d017e..32efd771a0 100644
--- a/src/mscorlib/src/System/Threading/Tasks/IAsyncCausalityTracerStatics.cs
+++ b/src/mscorlib/src/System/Threading/Tasks/IAsyncCausalityTracerStatics.cs
@@ -19,16 +19,16 @@ namespace Windows.Foundation.Diagnostics
     [Guid("50850B26-267E-451B-A890-AB6A370245EE")]
     [WindowsRuntimeImport]
     internal interface IAsyncCausalityTracerStatics
-	{
-		void TraceOperationCreation(CausalityTraceLevel traceLevel, CausalitySource source, Guid platformId, ulong operationId, string operationName, ulong relatedContext);
-		void TraceOperationCompletion(CausalityTraceLevel traceLevel, CausalitySource source, Guid platformId, ulong operationId, AsyncCausalityStatus status);
-		void TraceOperationRelation(CausalityTraceLevel traceLevel, CausalitySource source, Guid platformId, ulong operationId, CausalityRelation relation);
-		void TraceSynchronousWorkStart(CausalityTraceLevel traceLevel, CausalitySource source, Guid platformId, ulong operationId, CausalitySynchronousWork work);
-		void TraceSynchronousWorkCompletion(CausalityTraceLevel traceLevel, CausalitySource source, CausalitySynchronousWork work);
+    {
+        void TraceOperationCreation(CausalityTraceLevel traceLevel, CausalitySource source, Guid platformId, ulong operationId, string operationName, ulong relatedContext);
+        void TraceOperationCompletion(CausalityTraceLevel traceLevel, CausalitySource source, Guid platformId, ulong operationId, AsyncCausalityStatus status);
+        void TraceOperationRelation(CausalityTraceLevel traceLevel, CausalitySource source, Guid platformId, ulong operationId, CausalityRelation relation);
+        void TraceSynchronousWorkStart(CausalityTraceLevel traceLevel, CausalitySource source, Guid platformId, ulong operationId, CausalitySynchronousWork work);
+        void TraceSynchronousWorkCompletion(CausalityTraceLevel traceLevel, CausalitySource source, CausalitySynchronousWork work);
         //These next 2 functions could've been represented as an event except that the EventRegistrationToken wasn't being propagated to WinRT
         EventRegistrationToken add_TracingStatusChanged(System.EventHandler<TracingStatusChangedEventArgs> eventHandler);
         void remove_TracingStatusChanged(EventRegistrationToken token);
-	}
+    }
 
     [ComImport]
     [Guid("410B7711-FF3B-477F-9C9A-D2EFDA302DC3")]
diff --git a/src/mscorlib/src/System/Threading/Tasks/ProducerConsumerQueues.cs b/src/mscorlib/src/System/Threading/Tasks/ProducerConsumerQueues.cs
index 6b9dfbbe37..545bf9a5e5 100644
--- a/src/mscorlib/src/System/Threading/Tasks/ProducerConsumerQueues.cs
+++ b/src/mscorlib/src/System/Threading/Tasks/ProducerConsumerQueues.cs
@@ -52,11 +52,6 @@ namespace System.Threading.Tasks
         /// <summary>Gets the number of items in the collection.</summary>
         /// <remarks>In many implementations, this method will not be thread-safe.</remarks>
         int Count { get; }
-
-        /// <summary>A thread-safe way to get the number of items in the collection. May synchronize access by locking the provided synchronization object.</summary>
-        /// <param name="syncObj">The sync object used to lock</param>
-        /// <returns>The collection count</returns>
-        int GetCountSafe(object syncObj);
     }
 
     /// <summary>
@@ -80,10 +75,6 @@ namespace System.Threading.Tasks
 
         /// <summary>Gets the number of items in the collection.</summary>
         int IProducerConsumerQueue<T>.Count { get { return base.Count; } }
-
-        /// <summary>A thread-safe way to get the number of items in the collection. May synchronize access by locking the provided synchronization object.</summary>
-        /// <remarks>ConcurrentQueue.Count is thread safe, no need to acquire the lock.</remarks>
-        int IProducerConsumerQueue<T>.GetCountSafe(object syncObj) { return base.Count; }
     }
 
     /// <summary>
@@ -260,143 +251,6 @@ namespace System.Threading.Tasks
             return true;
         }
 
-        /// <summary>Attempts to peek at an item in the queue.</summary>
-        /// <param name="result">The peeked item.</param>
-        /// <returns>true if an item could be peeked; otherwise, false.</returns>
-        public bool TryPeek(out T result)
-        {
-            Segment segment = m_head;
-            var array = segment.m_array;
-            int first = segment.m_state.m_first; // local copy to avoid multiple volatile reads
-
-            // Fast path: there's obviously data available in the current segment
-            if (first != segment.m_state.m_lastCopy)
-            {
-                result = array[first];
-                return true;
-            }
-            // Slow path: there may not be data available in the current segment
-            else return TryPeekSlow(ref segment, ref array, out result);
-        }
-
-        /// <summary>Attempts to peek at an item in the queue.</summary>
-        /// <param name="array">The array from which the item is peeked.</param>
-        /// <param name="segment">The segment from which the item is peeked.</param>
-        /// <param name="result">The peeked item.</param>
-        /// <returns>true if an item could be peeked; otherwise, false.</returns>
-        private bool TryPeekSlow(ref Segment segment, ref T[] array, out T result)
-        {
-            Contract.Requires(segment != null, "Expected a non-null segment.");
-            Contract.Requires(array != null, "Expected a non-null item array.");
-
-            if (segment.m_state.m_last != segment.m_state.m_lastCopy)
-            {
-                segment.m_state.m_lastCopy = segment.m_state.m_last;
-                return TryPeek(out result); // will only recur once for this peek operation
-            }
-
-            if (segment.m_next != null && segment.m_state.m_first == segment.m_state.m_last)
-            {
-                segment = segment.m_next;
-                array = segment.m_array;
-                m_head = segment;
-            }
-
-            var first = segment.m_state.m_first; // local copy to avoid extraneous volatile reads
-
-            if (first == segment.m_state.m_last)
-            {
-                result = default(T);
-                return false;
-            }
-
-            result = array[first];
-            return true;
-        }
-
-        /// <summary>Attempts to dequeue an item from the queue.</summary>
-        /// <param name="predicate">The predicate that must return true for the item to be dequeued.  If null, all items implicitly return true.</param>
-        /// <param name="result">The dequeued item.</param>
-        /// <returns>true if an item could be dequeued; otherwise, false.</returns>
-        public bool TryDequeueIf(Predicate<T> predicate, out T result)
-        {
-            Segment segment = m_head;
-            var array = segment.m_array;
-            int first = segment.m_state.m_first; // local copy to avoid multiple volatile reads
-
-            // Fast path: there's obviously data available in the current segment
-            if (first != segment.m_state.m_lastCopy)
-            {
-                result = array[first];
-                if (predicate == null || predicate(result))
-                {
-                    array[first] = default(T); // Clear the slot to release the element
-                    segment.m_state.m_first = (first + 1) & (array.Length - 1);
-                    return true;
-                }
-                else
-                {
-                    result = default(T);
-                    return false;
-                }
-            }
-            // Slow path: there may not be data available in the current segment
-            else return TryDequeueIfSlow(predicate, ref segment, ref array, out result);
-        }
-
-        /// <summary>Attempts to dequeue an item from the queue.</summary>
-        /// <param name="predicate">The predicate that must return true for the item to be dequeued.  If null, all items implicitly return true.</param>
-        /// <param name="array">The array from which the item was dequeued.</param>
-        /// <param name="segment">The segment from which the item was dequeued.</param>
-        /// <param name="result">The dequeued item.</param>
-        /// <returns>true if an item could be dequeued; otherwise, false.</returns>
-        private bool TryDequeueIfSlow(Predicate<T> predicate, ref Segment segment, ref T[] array, out T result)
-        {
-            Contract.Requires(segment != null, "Expected a non-null segment.");
-            Contract.Requires(array != null, "Expected a non-null item array.");
-
-            if (segment.m_state.m_last != segment.m_state.m_lastCopy)
-            {
-                segment.m_state.m_lastCopy = segment.m_state.m_last;
-                return TryDequeueIf(predicate, out result); // will only recur once for this dequeue operation
-            }
-
-            if (segment.m_next != null && segment.m_state.m_first == segment.m_state.m_last)
-            {
-                segment = segment.m_next;
-                array = segment.m_array;
-                m_head = segment;
-            }
-
-            var first = segment.m_state.m_first; // local copy to avoid extraneous volatile reads
-
-            if (first == segment.m_state.m_last)
-            {
-                result = default(T);
-                return false;
-            }
-
-            result = array[first];
-            if (predicate == null || predicate(result))
-            {
-                array[first] = default(T); // Clear the slot to release the element
-                segment.m_state.m_first = (first + 1) & (segment.m_array.Length - 1);
-                segment.m_state.m_lastCopy = segment.m_state.m_last; // Refresh m_lastCopy to ensure that m_first has not passed m_lastCopy
-                return true;
-            }
-            else
-            {
-                result = default(T);
-                return false;
-            }
-        }
-
-        public void Clear()
-        {
-            T ignored;
-            while (TryDequeue(out ignored)) ;
-        }
-
         /// <summary>Gets whether the collection is currently empty.</summary>
         /// <remarks>WARNING: This should not be used concurrently without further vetting.</remarks>
         public bool IsEmpty
@@ -452,17 +306,6 @@ namespace System.Threading.Tasks
             }
         }
 
-        /// <summary>A thread-safe way to get the number of items in the collection. May synchronize access by locking the provided synchronization object.</summary>
-        /// <remarks>The Count is not thread safe, so we need to acquire the lock.</remarks>
-        int IProducerConsumerQueue<T>.GetCountSafe(object syncObj)
-        {
-            Debug.Assert(syncObj != null, "The syncObj parameter is null.");
-            lock (syncObj)
-            {
-                return Count;
-            }
-        }
-
         /// <summary>A segment in the queue containing one or more items.</summary>
         [StructLayout(LayoutKind.Sequential)] 
         private sealed class Segment
@@ -520,23 +363,9 @@ namespace System.Threading.Tasks
                 Contract.Requires(queue != null, "Expected a non-null queue.");
                 m_queue = queue;
             }
-
-            /// <summary>Gets the contents of the list.</summary>
-            [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
-            public T[] Items
-            {
-                get
-                {
-                    List<T> list = new List<T>();
-                    foreach (T item in m_queue)
-                        list.Add(item);
-                    return list.ToArray();
-                }
-            }
         }
     }
 
-
     /// <summary>A placeholder class for common padding constants and eventually routines.</summary>
     static class PaddingHelpers
     {
diff --git a/src/mscorlib/src/System/Threading/Tasks/TPLETWProvider.cs b/src/mscorlib/src/System/Threading/Tasks/TPLETWProvider.cs
index ef0d4b0e10..12cc1daa63 100644
--- a/src/mscorlib/src/System/Threading/Tasks/TPLETWProvider.cs
+++ b/src/mscorlib/src/System/Threading/Tasks/TPLETWProvider.cs
@@ -14,7 +14,6 @@ using System;
 using System.Collections.Generic;
 using System.Text;
 using System.Security;
-using System.Security.Permissions;
 using System.Runtime.CompilerServices;
 
 namespace System.Threading.Tasks
@@ -61,17 +60,6 @@ namespace System.Threading.Tasks
         /// <summary>Prevent external instantiation.  All logging should go through the Log instance.</summary>
         private TplEtwProvider() { }
 
-        /// <summary>Type of a fork/join operation.</summary>
-        public enum ForkJoinOperationType
-        {
-            /// <summary>Parallel.Invoke.</summary>
-            ParallelInvoke=1,
-            /// <summary>Parallel.For.</summary>
-            ParallelFor=2,
-            /// <summary>Parallel.ForEach.</summary>
-            ParallelForEach=3
-        }
-
         /// <summary>Configured behavior of a task wait operation.</summary>
         public enum TaskWaitBehavior : int
         {
@@ -203,195 +191,6 @@ namespace System.Threading.Tasks
         
         //-----------------------------------------------------------------------------------
         //        
-        // Parallel Events
-        //
-
-        #region ParallelLoopBegin
-        /// <summary>
-        /// Denotes the entry point for a Parallel.For or Parallel.ForEach loop
-        /// </summary>
-        /// <param name="OriginatingTaskSchedulerID">The scheduler ID.</param>
-        /// <param name="OriginatingTaskID">The task ID.</param>
-        /// <param name="ForkJoinContextID">The loop ID.</param>
-        /// <param name="OperationType">The kind of fork/join operation.</param>
-        /// <param name="InclusiveFrom">The lower bound of the loop.</param>
-        /// <param name="ExclusiveTo">The upper bound of the loop.</param>
-        [Event(PARALLELLOOPBEGIN_ID, Level = EventLevel.Informational, ActivityOptions=EventActivityOptions.Recursive, 
-         Task = TplEtwProvider.Tasks.Loop, Opcode = EventOpcode.Start)]        
-        public void ParallelLoopBegin(
-            int OriginatingTaskSchedulerID, int OriginatingTaskID,      // PFX_COMMON_EVENT_HEADER
-            int ForkJoinContextID, ForkJoinOperationType OperationType, // PFX_FORKJOIN_COMMON_EVENT_HEADER
-            long InclusiveFrom, long ExclusiveTo)
-        {
-            if (IsEnabled() && IsEnabled(EventLevel.Informational, Keywords.Parallel))
-            {
-                // There is no explicit WriteEvent() overload matching this event's fields. Therefore calling
-                // WriteEvent() would hit the "params" overload, which leads to an object allocation every time 
-                // this event is fired. To prevent that problem we will call WriteEventCore(), which works with 
-                // a stack based EventData array populated with the event fields.
-                unsafe
-                {
-                    EventData* eventPayload = stackalloc EventData[6];
-
-                    eventPayload[0].Size = sizeof(int);
-                    eventPayload[0].DataPointer = ((IntPtr) (&OriginatingTaskSchedulerID));
-                    eventPayload[1].Size = sizeof(int);
-                    eventPayload[1].DataPointer = ((IntPtr) (&OriginatingTaskID));
-                    eventPayload[2].Size = sizeof(int);
-                    eventPayload[2].DataPointer = ((IntPtr) (&ForkJoinContextID));
-                    eventPayload[3].Size = sizeof(int);
-                    eventPayload[3].DataPointer = ((IntPtr) (&OperationType));
-                    eventPayload[4].Size = sizeof(long);
-                    eventPayload[4].DataPointer = ((IntPtr) (&InclusiveFrom));
-                    eventPayload[5].Size = sizeof(long);
-                    eventPayload[5].DataPointer = ((IntPtr) (&ExclusiveTo));
-
-                    WriteEventCore(PARALLELLOOPBEGIN_ID, 6, eventPayload);
-                }
-            }
-        }
-        #endregion
-
-        #region ParallelLoopEnd
-        /// <summary>
-        /// Denotes the end of a Parallel.For or Parallel.ForEach loop.
-        /// </summary>
-        /// <param name="OriginatingTaskSchedulerID">The scheduler ID.</param>
-        /// <param name="OriginatingTaskID">The task ID.</param>
-        /// <param name="ForkJoinContextID">The loop ID.</param>
-        /// <param name="TotalIterations">the total number of iterations processed.</param>
-        [Event(PARALLELLOOPEND_ID, Level = EventLevel.Informational, Task = TplEtwProvider.Tasks.Loop, Opcode = EventOpcode.Stop)]
-        public void ParallelLoopEnd(
-            int OriginatingTaskSchedulerID, int OriginatingTaskID,  // PFX_COMMON_EVENT_HEADER
-            int ForkJoinContextID, long TotalIterations)
-        {
-            if (IsEnabled() && IsEnabled(EventLevel.Informational, Keywords.Parallel))
-            {
-                // There is no explicit WriteEvent() overload matching this event's fields.
-                // Therefore calling WriteEvent() would hit the "params" overload, which leads to an object allocation every time this event is fired.
-                // To prevent that problem we will call WriteEventCore(), which works with a stack based EventData array populated with the event fields
-                unsafe
-                {
-                    EventData* eventPayload = stackalloc EventData[4];
-
-                    eventPayload[0].Size = sizeof(int);
-                    eventPayload[0].DataPointer = ((IntPtr) (&OriginatingTaskSchedulerID));
-                    eventPayload[1].Size = sizeof(int);
-                    eventPayload[1].DataPointer = ((IntPtr) (&OriginatingTaskID));
-                    eventPayload[2].Size = sizeof(int);
-                    eventPayload[2].DataPointer = ((IntPtr) (&ForkJoinContextID));
-                    eventPayload[3].Size = sizeof(long);
-                    eventPayload[3].DataPointer = ((IntPtr) (&TotalIterations));
-
-                    WriteEventCore(PARALLELLOOPEND_ID, 4, eventPayload);
-                }
-            }
-        }
-        #endregion
-
-        #region ParallelInvokeBegin
-        /// <summary>Denotes the entry point for a Parallel.Invoke call.</summary>
-        /// <param name="OriginatingTaskSchedulerID">The scheduler ID.</param>
-        /// <param name="OriginatingTaskID">The task ID.</param>
-        /// <param name="ForkJoinContextID">The invoke ID.</param>
-        /// <param name="OperationType">The kind of fork/join operation.</param>
-        /// <param name="ActionCount">The number of actions being invoked.</param>
-        [Event(PARALLELINVOKEBEGIN_ID, Level = EventLevel.Informational, ActivityOptions=EventActivityOptions.Recursive, 
-         Task = TplEtwProvider.Tasks.Invoke, Opcode = EventOpcode.Start)]
-        public void ParallelInvokeBegin(
-            int OriginatingTaskSchedulerID, int OriginatingTaskID,      // PFX_COMMON_EVENT_HEADER
-            int ForkJoinContextID, ForkJoinOperationType OperationType, // PFX_FORKJOIN_COMMON_EVENT_HEADER
-            int ActionCount)
-        {
-            if (IsEnabled() && IsEnabled(EventLevel.Informational, Keywords.Parallel))
-            {
-                // There is no explicit WriteEvent() overload matching this event's fields.
-                // Therefore calling WriteEvent() would hit the "params" overload, which leads to an object allocation every time this event is fired.
-                // To prevent that problem we will call WriteEventCore(), which works with a stack based EventData array populated with the event fields
-                unsafe
-                {
-                    EventData* eventPayload = stackalloc EventData[5];
-
-                    eventPayload[0].Size = sizeof(int);
-                    eventPayload[0].DataPointer = ((IntPtr) (&OriginatingTaskSchedulerID));
-                    eventPayload[1].Size = sizeof(int);
-                    eventPayload[1].DataPointer = ((IntPtr) (&OriginatingTaskID));
-                    eventPayload[2].Size = sizeof(int);
-                    eventPayload[2].DataPointer = ((IntPtr) (&ForkJoinContextID));
-                    eventPayload[3].Size = sizeof(int);
-                    eventPayload[3].DataPointer = ((IntPtr) (&OperationType));
-                    eventPayload[4].Size = sizeof(int);
-                    eventPayload[4].DataPointer = ((IntPtr) (&ActionCount));
-
-                    WriteEventCore(PARALLELINVOKEBEGIN_ID, 5, eventPayload);
-                }
-            }            
-        }
-        #endregion
-
-        #region ParallelInvokeEnd
-        /// <summary>
-        /// Denotes the exit point for a Parallel.Invoke call. 
-        /// </summary>
-        /// <param name="OriginatingTaskSchedulerID">The scheduler ID.</param>
-        /// <param name="OriginatingTaskID">The task ID.</param>
-        /// <param name="ForkJoinContextID">The invoke ID.</param>
-        [Event(PARALLELINVOKEEND_ID, Level = EventLevel.Informational, Task = TplEtwProvider.Tasks.Invoke, Opcode = EventOpcode.Stop)]
-        public void ParallelInvokeEnd(
-            int OriginatingTaskSchedulerID, int OriginatingTaskID,  // PFX_COMMON_EVENT_HEADER
-            int ForkJoinContextID)
-        {
-            if (IsEnabled() && IsEnabled(EventLevel.Informational, Keywords.Parallel))
-            {
-                WriteEvent(PARALLELINVOKEEND_ID, OriginatingTaskSchedulerID, OriginatingTaskID, ForkJoinContextID);
-            }
-        }
-        #endregion
-
-        #region ParallelFork
-        /// <summary>
-        /// Denotes the start of an individual task that's part of a fork/join context. 
-        /// Before this event is fired, the start of the new fork/join context will be marked 
-        /// with another event that declares a unique context ID. 
-        /// </summary>
-        /// <param name="OriginatingTaskSchedulerID">The scheduler ID.</param>
-        /// <param name="OriginatingTaskID">The task ID.</param>
-        /// <param name="ForkJoinContextID">The invoke ID.</param>
-        [Event(PARALLELFORK_ID, Level = EventLevel.Verbose, ActivityOptions=EventActivityOptions.Recursive, 
-         Task = TplEtwProvider.Tasks.ForkJoin, Opcode = EventOpcode.Start)]
-        public void ParallelFork(
-            int OriginatingTaskSchedulerID, int OriginatingTaskID,  // PFX_COMMON_EVENT_HEADER
-            int ForkJoinContextID)
-        {
-            if (IsEnabled() && IsEnabled(EventLevel.Verbose, Keywords.Parallel))
-            {
-                WriteEvent(PARALLELFORK_ID, OriginatingTaskSchedulerID, OriginatingTaskID, ForkJoinContextID);
-            }
-        }
-        #endregion
-
-        #region ParallelJoin
-        /// <summary>
-        /// Denotes the end of an individual task that's part of a fork/join context. 
-        /// This should match a previous ParallelFork event with a matching "OriginatingTaskID"
-        /// </summary>
-        /// <param name="OriginatingTaskSchedulerID">The scheduler ID.</param>
-        /// <param name="OriginatingTaskID">The task ID.</param>
-        /// <param name="ForkJoinContextID">The invoke ID.</param>
-        [Event(PARALLELJOIN_ID, Level = EventLevel.Verbose, Task = TplEtwProvider.Tasks.ForkJoin, Opcode = EventOpcode.Stop)]
-        public void ParallelJoin(
-            int OriginatingTaskSchedulerID, int OriginatingTaskID,  // PFX_COMMON_EVENT_HEADER
-            int ForkJoinContextID)
-        {
-            if (IsEnabled() && IsEnabled(EventLevel.Verbose, Keywords.Parallel))
-            {
-                WriteEvent(PARALLELJOIN_ID, OriginatingTaskSchedulerID, OriginatingTaskID, ForkJoinContextID);
-            }
-        }
-        #endregion
-
-        //-----------------------------------------------------------------------------------
-        //        
         // Task Events
         //
         
@@ -690,7 +489,7 @@ namespace System.Threading.Tasks
             }                
         }
 
-        [NonEvent, System.Security.SecuritySafeCritical]
+        [NonEvent]
         unsafe public void RunningContinuation(int TaskID, object Object) { RunningContinuation(TaskID, (long) *((void**) JitHelpers.UnsafeCastToStackPointer(ref Object))); }
         [Event(20, Keywords = Keywords.Debug)]
         private void RunningContinuation(int TaskID, long Object) 
@@ -699,7 +498,7 @@ namespace System.Threading.Tasks
                 WriteEvent(20, TaskID, Object); 
         }
 
-        [NonEvent, System.Security.SecuritySafeCritical]
+        [NonEvent]
         unsafe public void RunningContinuationList(int TaskID, int Index, object Object) { RunningContinuationList(TaskID, Index, (long) *((void**) JitHelpers.UnsafeCastToStackPointer(ref Object))); }
 
         [Event(21, Keywords = Keywords.Debug)]
@@ -709,9 +508,6 @@ namespace System.Threading.Tasks
                 WriteEvent(21, TaskID, Index, Object); 
         } 
 
-        [Event(22, Keywords = Keywords.Debug)]
-        public void DebugMessage(string Message) { WriteEvent(22, Message); } 
-
         [Event(23, Keywords = Keywords.Debug)]
         public void DebugFacilityMessage(string Facility, string Message) { WriteEvent(23, Facility, Message); } 
 
diff --git a/src/mscorlib/src/System/Threading/Tasks/Task.cs b/src/mscorlib/src/System/Threading/Tasks/Task.cs
index af3b7cf5cd..c7de16c145 100644
--- a/src/mscorlib/src/System/Threading/Tasks/Task.cs
+++ b/src/mscorlib/src/System/Threading/Tasks/Task.cs
@@ -18,7 +18,6 @@ using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.ExceptionServices;
 using System.Security;
-using System.Security.Permissions;
 using System.Threading;
 using System.Diagnostics;
 using System.Diagnostics.Contracts;
@@ -364,12 +363,9 @@ namespace System.Threading.Tasks
         /// </summary>
         /// <param name="action">The delegate that represents the code to execute in the Task.</param>
         /// <exception cref="T:System.ArgumentNullException">The <paramref name="action"/> argument is null.</exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task(Action action)
             : this(action, null, null, default(CancellationToken), TaskCreationOptions.None, InternalTaskOptions.None, null)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            PossiblyCaptureContext(ref stackMark);
         }
 
         /// <summary>
@@ -382,12 +378,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task(Action action, CancellationToken cancellationToken)
             : this(action, null, null, cancellationToken, TaskCreationOptions.None, InternalTaskOptions.None, null)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            PossiblyCaptureContext(ref stackMark);
         }
 
         /// <summary>
@@ -405,12 +398,9 @@ namespace System.Threading.Tasks
         /// The <paramref name="creationOptions"/> argument specifies an invalid value for <see
         /// cref="T:System.Threading.Tasks.TaskCreationOptions"/>.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task(Action action, TaskCreationOptions creationOptions)
             : this(action, null, Task.InternalCurrentIfAttached(creationOptions), default(CancellationToken), creationOptions, InternalTaskOptions.None, null)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            PossiblyCaptureContext(ref stackMark);
         }
 
         /// <summary>
@@ -432,12 +422,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task(Action action, CancellationToken cancellationToken, TaskCreationOptions creationOptions)
             : this(action, null, Task.InternalCurrentIfAttached(creationOptions), cancellationToken, creationOptions, InternalTaskOptions.None, null)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            PossiblyCaptureContext(ref stackMark);
         }
 
 
@@ -449,12 +436,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ArgumentNullException">
         /// The <paramref name="action"/> argument is null.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task(Action<object> action, object state)
             : this(action, state, null, default(CancellationToken), TaskCreationOptions.None, InternalTaskOptions.None, null)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            PossiblyCaptureContext(ref stackMark);
         }
 
         /// <summary>
@@ -469,12 +453,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task(Action<object> action, object state, CancellationToken cancellationToken)
             : this(action, state, null, cancellationToken, TaskCreationOptions.None, InternalTaskOptions.None, null)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            PossiblyCaptureContext(ref stackMark);
         }
 
         /// <summary>
@@ -493,12 +474,9 @@ namespace System.Threading.Tasks
         /// The <paramref name="creationOptions"/> argument specifies an invalid value for <see
         /// cref="T:System.Threading.Tasks.TaskCreationOptions"/>.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task(Action<object> action, object state, TaskCreationOptions creationOptions)
             : this(action, state, Task.InternalCurrentIfAttached(creationOptions), default(CancellationToken), creationOptions, InternalTaskOptions.None, null)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            PossiblyCaptureContext(ref stackMark);
         }
 
         /// <summary>
@@ -521,19 +499,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task(Action<object> action, object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions)
             : this(action, state, Task.InternalCurrentIfAttached(creationOptions), cancellationToken, creationOptions, InternalTaskOptions.None, null)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            PossiblyCaptureContext(ref stackMark);
-        }
-
-        internal Task(Action<object> action, object state, Task parent, CancellationToken cancellationToken,
-            TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler, ref StackCrawlMark stackMark)
-            : this(action, state, parent, cancellationToken, creationOptions, internalOptions, scheduler)
-        {
-            PossiblyCaptureContext(ref stackMark);
         }
 
         /// <summary>
@@ -556,10 +524,8 @@ namespace System.Threading.Tasks
             }
             Contract.EndContractBlock();
 
-            // Keep a link to your parent if: (A) You are attached, or (B) you are self-replicating.
-            if (parent != null &&
-                ((creationOptions & TaskCreationOptions.AttachedToParent) != 0 ||
-                 (internalOptions & InternalTaskOptions.SelfReplicating) != 0))
+            // Keep a link to the parent if attached
+            if (parent != null && (creationOptions & TaskCreationOptions.AttachedToParent) != 0)
             {
                 EnsureContingentPropertiesInitializedUnsafe().m_parent = parent;
             }
@@ -585,6 +551,10 @@ namespace System.Threading.Tasks
             m_stateObject = state;
             m_taskScheduler = scheduler;
 
+            Debug.Assert(m_contingentProperties == null || m_contingentProperties.m_capturedContext == null,
+                "Captured an ExecutionContext when one was already captured.");
+            CapturedContext = ExecutionContext.Capture();
+
             // Check for validity of options
             if ((creationOptions &
                     ~(TaskCreationOptions.AttachedToParent |
@@ -601,55 +571,43 @@ namespace System.Threading.Tasks
             // Check the validity of internalOptions
             int illegalInternalOptions = 
                     (int) (internalOptions &
-                            ~(InternalTaskOptions.SelfReplicating |
-                              InternalTaskOptions.ChildReplica |
-                              InternalTaskOptions.PromiseTask |
+                            ~(InternalTaskOptions.PromiseTask |
                               InternalTaskOptions.ContinuationTask |
                               InternalTaskOptions.LazyCancellation |
                               InternalTaskOptions.QueuedByRuntime));
             Debug.Assert(illegalInternalOptions == 0, "TaskConstructorCore: Illegal internal options");
 #endif
 
-            // Throw exception if the user specifies both LongRunning and SelfReplicating
-            if (((creationOptions & TaskCreationOptions.LongRunning) != 0) &&
-                ((internalOptions & InternalTaskOptions.SelfReplicating) != 0))
-            {
-                ThrowHelper.ThrowInvalidOperationException(ExceptionResource.Task_ctor_LRandSR);
-            }
-
             // Assign options to m_stateAndOptionsFlag.
             Debug.Assert(m_stateFlags == 0, "TaskConstructorCore: non-zero m_stateFlags");
             Debug.Assert((((int)creationOptions) | OptionsMask) == OptionsMask, "TaskConstructorCore: options take too many bits");
-            var tmpFlags = (int)creationOptions | (int)internalOptions;
-            if ((m_action == null) || ((internalOptions & InternalTaskOptions.ContinuationTask) != 0))
-            {
-                // For continuation tasks or TaskCompletionSource.Tasks, begin life in the 
-                // WaitingForActivation state rather than the Created state.
-                tmpFlags |= TASK_STATE_WAITINGFORACTIVATION;
-            }
-            m_stateFlags = tmpFlags; // one write to the volatile m_stateFlags instead of two when setting the above options
+            int tmpFlags = (int)creationOptions | (int)internalOptions; // one write to the volatile m_stateFlags instead of two when setting the above options
+            m_stateFlags = m_action == null || (internalOptions & InternalTaskOptions.ContinuationTask) != 0 ?
+                tmpFlags | TASK_STATE_WAITINGFORACTIVATION :
+                tmpFlags;
 
             // Now is the time to add the new task to the children list 
             // of the creating task if the options call for it.
             // We can safely call the creator task's AddNewChild() method to register it, 
             // because at this point we are already on its thread of execution.
 
-            Task parent = m_contingentProperties?.m_parent;
-            if (parent != null
-                && ((creationOptions & TaskCreationOptions.AttachedToParent) != 0)
-                && ((parent.CreationOptions & TaskCreationOptions.DenyChildAttach) == 0)
-                )
+            ContingentProperties props = m_contingentProperties;
+            if (props != null)
             {
-                parent.AddNewChild();
+                Task parent = props.m_parent;
+                if (parent != null
+                    && ((creationOptions & TaskCreationOptions.AttachedToParent) != 0)
+                    && ((parent.CreationOptions & TaskCreationOptions.DenyChildAttach) == 0))
+                {
+                    parent.AddNewChild();
+                }
             }
 
             // if we have a non-null cancellationToken, allocate the contingent properties to save it
             // we need to do this as the very last thing in the construction path, because the CT registration could modify m_stateFlags
             if (cancellationToken.CanBeCanceled)
             {
-                Debug.Assert((internalOptions &
-                    (InternalTaskOptions.ChildReplica | InternalTaskOptions.SelfReplicating | InternalTaskOptions.ContinuationTask)) == 0,
-                    "TaskConstructorCore: Did not expect to see cancelable token for replica/replicating or continuation task.");
+                Debug.Assert((internalOptions & InternalTaskOptions.ContinuationTask) == 0, "TaskConstructorCore: Did not expect to see cancelable token for continuation task.");
 
                 AssignCancellationToken(cancellationToken, null, null);
             }
@@ -756,33 +714,8 @@ namespace System.Threading.Tasks
             }
         }
 
-
-        /// <summary>
-        /// Captures the ExecutionContext so long as flow isn't suppressed.
-        /// </summary>
-        /// <param name="stackMark">A stack crawl mark pointing to the frame of the caller.</param>
-
-        internal void PossiblyCaptureContext(ref StackCrawlMark stackMark)
-        {
-            Debug.Assert(m_contingentProperties == null || m_contingentProperties.m_capturedContext == null,
-                "Captured an ExecutionContext when one was already captured.");
-
-            // In the legacy .NET 3.5 build, we don't have the optimized overload of Capture()
-            // available, so we call the parameterless overload.
-            CapturedContext = ExecutionContext.Capture(
-                ref stackMark,
-                ExecutionContext.CaptureOptions.IgnoreSyncCtx | ExecutionContext.CaptureOptions.OptimizeDefaultCase);
-        }
-
         // Internal property to process TaskCreationOptions access and mutation.
-        internal TaskCreationOptions Options
-        {
-            get
-            {
-                int stateFlags = m_stateFlags; // "cast away" volatility to enable inlining of OptionsMethod
-                return OptionsMethod(stateFlags);
-            }
-        }
+        internal TaskCreationOptions Options => OptionsMethod(m_stateFlags);
 
         // Similar to Options property, but allows for the use of a cached flags value rather than
         // a read of the volatile m_stateFlags field.
@@ -796,11 +729,16 @@ namespace System.Threading.Tasks
         // no illegalBits are set.  Returns true on success, false on failure.
         internal bool AtomicStateUpdate(int newBits, int illegalBits)
         {
-            // This could be implemented in terms of:
-            //     internal bool AtomicStateUpdate(int newBits, int illegalBits, ref int oldFlags);
-            // but for high-throughput perf, that delegation's cost is noticeable.
+            int oldFlags = m_stateFlags;
+            return
+                (oldFlags & illegalBits) == 0 &&
+                (Interlocked.CompareExchange(ref m_stateFlags, oldFlags | newBits, oldFlags) == oldFlags ||
+                 AtomicStateUpdateSlow(newBits, illegalBits));
+        }
 
-            SpinWait sw = new SpinWait();
+        private bool AtomicStateUpdateSlow(int newBits, int illegalBits)
+        {
+            var sw = new SpinWait();
             do
             {
                 int oldFlags = m_stateFlags;
@@ -959,7 +897,6 @@ namespace System.Threading.Tasks
             return AtomicStateUpdate(TASK_STATE_STARTED, TASK_STATE_CANCELED | TASK_STATE_STARTED);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal bool FireTaskScheduledIfNeeded(TaskScheduler ts)
         {
             var etwLog = TplEtwProvider.Log;
@@ -988,16 +925,14 @@ namespace System.Threading.Tasks
         /// </summary>
         internal void AddNewChild()
         {
-            Debug.Assert(Task.InternalCurrent == this || this.IsSelfReplicatingRoot, "Task.AddNewChild(): Called from an external context");
+            Debug.Assert(Task.InternalCurrent == this, "Task.AddNewChild(): Called from an external context");
 
             var props = EnsureContingentPropertiesInitialized();
 
-            if (props.m_completionCountdown == 1 && !IsSelfReplicatingRoot)
+            if (props.m_completionCountdown == 1)
             {
                 // A count of 1 indicates so far there was only the parent, and this is the first child task
                 // Single kid => no fuss about who else is accessing the count. Let's save ourselves 100 cycles
-                // We exclude self replicating root tasks from this optimization, because further child creation can take place on 
-                // other cores and with bad enough timing this write may not be visible to them.
                 props.m_completionCountdown++;
             }
             else
@@ -1263,7 +1198,7 @@ namespace System.Threading.Tasks
         // Implicitly converts action to object and handles the meat of the StartNew() logic.
         internal static Task InternalStartNew(
             Task creatingTask, Delegate action, object state, CancellationToken cancellationToken, TaskScheduler scheduler,
-            TaskCreationOptions options, InternalTaskOptions internalOptions, ref StackCrawlMark stackMark)
+            TaskCreationOptions options, InternalTaskOptions internalOptions)
         {
             // Validate arguments.
             if (scheduler == null)
@@ -1275,7 +1210,6 @@ namespace System.Threading.Tasks
             // Create and schedule the task. This throws an InvalidOperationException if already shut down.
             // Here we add the InternalTaskOptions.QueuedByRuntime to the internalOptions, so that TaskConstructorCore can skip the cancellation token registration
             Task t = new Task(action, state, creatingTask, cancellationToken, options, internalOptions | InternalTaskOptions.QueuedByRuntime, scheduler);
-            t.PossiblyCaptureContext(ref stackMark);
 
             t.ScheduleAndStart(false);
             return t;
@@ -1649,35 +1583,6 @@ namespace System.Threading.Tasks
             }
         }
 
-        /// <summary>
-        /// Determines whether this is the root task of a self replicating group.
-        /// </summary>
-        internal bool IsSelfReplicatingRoot
-        {
-            get
-            {
-                // Return true if self-replicating bit is set and child replica bit is not set
-                return (Options & (TaskCreationOptions)(InternalTaskOptions.SelfReplicating | InternalTaskOptions.ChildReplica))
-                    == (TaskCreationOptions)InternalTaskOptions.SelfReplicating;
-            }
-        }
-
-        /// <summary>
-        /// Determines whether the task is a replica itself.
-        /// </summary>
-        internal bool IsChildReplica
-        {
-            get { return (Options & (TaskCreationOptions)InternalTaskOptions.ChildReplica) != 0; }
-        }
-
-        internal int ActiveChildCount
-        {
-            get
-            {
-                var props = Volatile.Read(ref m_contingentProperties);
-                return props != null ? props.m_completionCountdown - 1 : 0;
-            }
-        }
 
         /// <summary>
         /// The property formerly known as IsFaulted.
@@ -1723,7 +1628,7 @@ namespace System.Threading.Tasks
                 }
                 else
                 {
-                    return m_contingentProperties?.m_capturedContext ?? ExecutionContext.PreAllocatedDefault;
+                    return m_contingentProperties?.m_capturedContext ?? ExecutionContext.Default;
                 }
             }
             set
@@ -1733,7 +1638,7 @@ namespace System.Threading.Tasks
                 {
                     m_stateFlags |= TASK_STATE_EXECUTIONCONTEXT_IS_NULL;
                 }
-                else if (!value.IsPreAllocatedDefault) // not the default context, then inflate the contingent properties and set it
+                else if (value != ExecutionContext.Default) // not the default context, then inflate the contingent properties and set it
                 {
                     EnsureContingentPropertiesInitializedUnsafe().m_capturedContext = value;
                 }
@@ -1741,32 +1646,6 @@ namespace System.Threading.Tasks
             }
         }
 
-        /// <summary>
-        /// Static helper function to copy specific ExecutionContext
-        /// </summary>
-        /// <param name="capturedContext">The captured context</param>
-        /// <returns>The copied context, null if the capturedContext is null</returns>
-        private static ExecutionContext CopyExecutionContext(ExecutionContext capturedContext)
-        {
-            if (capturedContext == null)
-                return null;
-            if (capturedContext.IsPreAllocatedDefault)
-                return ExecutionContext.PreAllocatedDefault;
-
-            return capturedContext.CreateCopy();
-        }
-
-
-#if DEBUG
-        /// <summary>
-        /// Retrieves an identifier for the task.
-        /// </summary>
-        internal int InternalId
-        {
-            get { return GetHashCode(); }
-        }
-#endif
-
         /////////////
         // methods
 
@@ -1906,7 +1785,7 @@ namespace System.Threading.Tasks
             catch (ThreadAbortException tae)
             {
                 AddException(tae);
-                FinishThreadAbortedTask(true, false);
+                FinishThreadAbortedTask(delegateRan:false);
             }
             catch (Exception e)
             {
@@ -1916,10 +1795,10 @@ namespace System.Threading.Tasks
                 AddException(tse);
                 Finish(false);
 
-                // Now we need to mark ourselves as "handled" to avoid crashing the finalizer thread if we are called from StartNew()
-                // or from the self replicating logic, because in both cases the exception is either propagated outside directly, or added
-                // to an enclosing parent. However we won't do this for continuation tasks, because in that case we internally eat the exception
-                // and therefore we need to make sure the user does later observe it explicitly or see it on the finalizer.
+                // Now we need to mark ourselves as "handled" to avoid crashing the finalizer thread if we are called from StartNew(),
+                // because the exception is either propagated outside directly, or added to an enclosing parent. However we won't do this for
+                // continuation tasks, because in that case we internally eat the exception and therefore we need to make sure the user does
+                // later observe it explicitly or see it on the finalizer.
 
                 if ((Options & (TaskCreationOptions)InternalTaskOptions.ContinuationTask) == 0)
                 {
@@ -2158,34 +2037,45 @@ namespace System.Threading.Tasks
         /// <summary>
         /// Signals completion of this particular task.
         ///
-        /// The bUserDelegateExecuted parameter indicates whether this Finish() call comes following the
+        /// The userDelegateExecute parameter indicates whether this Finish() call comes following the
         /// full execution of the user delegate. 
         /// 
-        /// If bUserDelegateExecuted is false, it mean user delegate wasn't invoked at all (either due to
+        /// If userDelegateExecute is false, it mean user delegate wasn't invoked at all (either due to
         /// a cancellation request, or because this task is a promise style Task). In this case, the steps
         /// involving child tasks (i.e. WaitForChildren) will be skipped.
         /// 
         /// </summary>
-        internal void Finish(bool bUserDelegateExecuted)
+        internal void Finish(bool userDelegateExecute)
+        {
+            if (m_contingentProperties == null)
+            {
+                FinishStageTwo();
+            }
+            else
+            {
+                FinishSlow(userDelegateExecute);
+            }
+        }
+
+        private void FinishSlow(bool userDelegateExecute)
         {
-            if (!bUserDelegateExecuted)
+            Debug.Assert(userDelegateExecute || m_contingentProperties != null);
+
+            if (!userDelegateExecute)
             {
                 // delegate didn't execute => no children. We can safely call the remaining finish stages
                 FinishStageTwo();
             }
             else
             {
-                var props = Volatile.Read(ref m_contingentProperties);
+                ContingentProperties props = m_contingentProperties;
 
-                if (props == null || // no contingent properties means no children, so it's safe to complete ourselves
-                    (props.m_completionCountdown == 1 && !IsSelfReplicatingRoot) ||
-                    // Count of 1 => either all children finished, or there were none. Safe to complete ourselves 
-                    // without paying the price of an Interlocked.Decrement.
-                    // However we need to exclude self replicating root tasks from this optimization, because
-                    // they can have children joining in, or finishing even after the root task delegate is done.
+                // Count of 1 => either all children finished, or there were none. Safe to complete ourselves 
+                // without paying the price of an Interlocked.Decrement.
+                if ((props.m_completionCountdown == 1) ||
                     Interlocked.Decrement(ref props.m_completionCountdown) == 0) // Reaching this sub clause means there may be remaining active children,
-                // and we could be racing with one of them to call FinishStageTwo().
-                // So whoever does the final Interlocked.Dec is responsible to finish.
+                                                                                 // and we could be racing with one of them to call FinishStageTwo().
+                                                                                 // So whoever does the final Interlocked.Dec is responsible to finish.
                 {
                     FinishStageTwo();
                 }
@@ -2205,8 +2095,7 @@ namespace System.Threading.Tasks
 
                 // Now is the time to prune exceptional children. We'll walk the list and removes the ones whose exceptions we might have observed after they threw.
                 // we use a local variable for exceptional children here because some other thread may be nulling out m_contingentProperties.m_exceptionalChildren 
-                List<Task> exceptionalChildren = props != null ? props.m_exceptionalChildren : null;
-
+                List<Task> exceptionalChildren = props.m_exceptionalChildren;
                 if (exceptionalChildren != null)
                 {
                     lock (exceptionalChildren)
@@ -2225,12 +2114,17 @@ namespace System.Threading.Tasks
         /// It can happen i) either on the thread that originally executed this task (if no children were spawned, or they all completed by the time this task's delegate quit)
         ///              ii) or on the thread that executed the last child.
         /// </summary>
-        internal void FinishStageTwo()
+        private void FinishStageTwo()
         {
-            AddExceptionsFromChildren();
-
             // At this point, the task is done executing and waiting for its children,
             // we can transition our task to a completion state.  
+
+            ContingentProperties cp = Volatile.Read(ref m_contingentProperties);
+            if (cp != null)
+            {
+                AddExceptionsFromChildren(cp);
+            }
+
             int completionState;
             if (ExceptionRecorded)
             {
@@ -2279,7 +2173,7 @@ namespace System.Threading.Tasks
 
             // Set the completion event if it's been lazy allocated.
             // And if we made a cancellation registration, it's now unnecessary.
-            var cp = Volatile.Read(ref m_contingentProperties);
+            cp = Volatile.Read(ref m_contingentProperties); // need to re-read after updating state
             if (cp != null)
             {
                 cp.SetCompleted();
@@ -2306,6 +2200,17 @@ namespace System.Threading.Tasks
             m_action = null;
 
             // Notify parent if this was an attached task
+            if (m_contingentProperties != null)
+            {
+                NotifyParentIfPotentiallyAttachedTask();
+            }
+
+            // Activate continuations (if any).
+            FinishContinuations();
+        }
+
+        internal void NotifyParentIfPotentiallyAttachedTask()
+        {
             Task parent = m_contingentProperties?.m_parent;
             if (parent != null
                  && ((parent.CreationOptions & TaskCreationOptions.DenyChildAttach) == 0)
@@ -2313,9 +2218,6 @@ namespace System.Threading.Tasks
             {
                 parent.ProcessChildCompletion(this);
             }
-
-            // Activate continuations (if any).
-            FinishContinuations();
         }
 
         /// <summary>
@@ -2367,14 +2269,15 @@ namespace System.Threading.Tasks
         /// This is to be called just before the task does its final state transition. 
         /// It traverses the list of exceptional children, and appends their aggregate exceptions into this one's exception list
         /// </summary>
-        internal void AddExceptionsFromChildren()
+        internal void AddExceptionsFromChildren(ContingentProperties props)
         {
+            Debug.Assert(props != null);
+
             // In rare occurences during AppDomainUnload() processing, it is possible for this method to be called
             // simultaneously on the same task from two different contexts.  This can result in m_exceptionalChildren
             // being nulled out while it is being processed, which could lead to a NullReferenceException.  To
             // protect ourselves, we'll cache m_exceptionalChildren in a local variable.
-            var props = Volatile.Read(ref m_contingentProperties);
-            List<Task> exceptionalChildren = props?.m_exceptionalChildren;
+            List<Task> exceptionalChildren = props.m_exceptionalChildren;
 
             if (exceptionalChildren != null)
             {
@@ -2410,19 +2313,13 @@ namespace System.Threading.Tasks
         /// This makes a note in the state flags so that we avoid any costly synchronous operations in the finish codepath
         /// such as inlined continuations
         /// </summary>
-        /// <param name="bTAEAddedToExceptionHolder">
-        /// Indicates whether the ThreadAbortException was added to this task's exception holder. 
-        /// This should always be true except for the case of non-root self replicating task copies.
-        /// </param>
         /// <param name="delegateRan">Whether the delegate was executed.</param>
-        internal void FinishThreadAbortedTask(bool bTAEAddedToExceptionHolder, bool delegateRan)
+        internal void FinishThreadAbortedTask(bool delegateRan)
         {
-            Debug.Assert(!bTAEAddedToExceptionHolder || m_contingentProperties?.m_exceptionsHolder != null,
-                            "FinishThreadAbortedTask() called on a task whose exception holder wasn't initialized");
+            Debug.Assert(m_contingentProperties?.m_exceptionsHolder != null,
+                "FinishThreadAbortedTask() called on a task whose exception holder wasn't initialized");
 
-            // this will only be false for non-root self replicating task copies, because all of their exceptions go to the root task.
-            if (bTAEAddedToExceptionHolder)
-                m_contingentProperties.m_exceptionsHolder.MarkAsHandled(false);
+            m_contingentProperties.m_exceptionsHolder.MarkAsHandled(false);
 
             // If this method has already been called for this task, or if this task has already completed, then
             // return before actually calling Finish().
@@ -2433,220 +2330,6 @@ namespace System.Threading.Tasks
             }
 
             Finish(delegateRan);
-
-        }
-
-
-        /// <summary>
-        /// Executes the task. This method will only be called once, and handles bookeeping associated with
-        /// self-replicating tasks, in addition to performing necessary exception marshaling.
-        /// </summary>
-        private void Execute()
-        {
-            if (IsSelfReplicatingRoot)
-            {
-                ExecuteSelfReplicating(this);
-            }
-            else
-            {
-                try
-                {
-                    InnerInvoke();
-                }
-                catch (ThreadAbortException tae)
-                {
-                    // Don't record the TAE or call FinishThreadAbortedTask for a child replica task --
-                    // it's already been done downstream.
-                    if (!IsChildReplica)
-                    {
-                        // Record this exception in the task's exception list
-                        HandleException(tae);
-
-                        // This is a ThreadAbortException and it will be rethrown from this catch clause, causing us to 
-                        // skip the regular Finish codepath. In order not to leave the task unfinished, we now call 
-                        // FinishThreadAbortedTask here.
-                        FinishThreadAbortedTask(true, true);
-                    }
-                }
-                catch (Exception exn)
-                {
-                    // Record this exception in the task's exception list
-                    HandleException(exn);
-                }
-            }
-        }
-
-        // Allows (internal) deriving classes to support limited replication.
-        // (By default, replication is basically unlimited).
-        internal virtual bool ShouldReplicate()
-        {
-            return true;
-        }
-
-        // Allows (internal) deriving classes to instantiate the task replica as a Task super class of their choice
-        // (By default, we create a regular Task instance)
-        internal virtual Task CreateReplicaTask(Action<object> taskReplicaDelegate, Object stateObject, Task parentTask, TaskScheduler taskScheduler,
-                                            TaskCreationOptions creationOptionsForReplica, InternalTaskOptions internalOptionsForReplica)
-        {
-            return new Task(taskReplicaDelegate, stateObject, parentTask, default(CancellationToken),
-                            creationOptionsForReplica, internalOptionsForReplica, parentTask.ExecutingTaskScheduler);
-        }
-
-        // Allows internal deriving classes to support replicas that exit prematurely and want to pass on state to the next replica
-        internal virtual Object SavedStateForNextReplica
-        {
-            get { return null; }
-
-            set { /*do nothing*/ }
-        }
-
-        // Allows internal deriving classes to support replicas that exit prematurely and want to pass on state to the next replica
-        internal virtual Object SavedStateFromPreviousReplica
-        {
-            get { return null; }
-
-            set { /*do nothing*/ }
-        }
-
-        // Allows internal deriving classes to support replicas that exit prematurely and want to hand over the child replica that they
-        // had queued, so that the replacement replica can work with that child task instead of queuing up yet another one
-        internal virtual Task HandedOverChildReplica
-        {
-            get { return null; }
-
-            set { /* do nothing*/ }
-        }
-
-        private static void ExecuteSelfReplicating(Task root)
-        {
-            TaskCreationOptions creationOptionsForReplicas = root.CreationOptions | TaskCreationOptions.AttachedToParent;
-            InternalTaskOptions internalOptionsForReplicas =
-                InternalTaskOptions.ChildReplica |  // child replica flag disables self replication for the replicas themselves.
-                InternalTaskOptions.SelfReplicating |  // we still want to identify this as part of a self replicating group
-                InternalTaskOptions.QueuedByRuntime;   // we queue and cancel these tasks internally, so don't allow CT registration to take place
-
-
-            // Important Note: The child replicas we launch from here will be attached the root replica (by virtue of the root.CreateReplicaTask call)
-            // because we need the root task to receive all their exceptions, and to block until all of them return
-
-
-            // This variable is captured in a closure and shared among all replicas.
-            bool replicasAreQuitting = false;
-
-            // Set up a delegate that will form the body of the root and all recursively created replicas.
-            Action<object> taskReplicaDelegate = null;
-            taskReplicaDelegate = delegate
-            {
-                Task currentTask = Task.InternalCurrent;
-
-
-                // Check if a child task has been handed over by a prematurely quiting replica that we might be a replacement for.
-                Task childTask = currentTask.HandedOverChildReplica;
-
-                if (childTask == null)
-                {
-                    // Apparently we are not a replacement task. This means we need to queue up a child task for replication to progress
-
-                    // Down-counts a counter in the root task.
-                    if (!root.ShouldReplicate()) return;
-
-                    // If any of the replicas have quit, we will do so ourselves.
-                    if (Volatile.Read(ref replicasAreQuitting))
-                    {
-                        return;
-                    }
-
-                    // Propagate a copy of the context from the root task. It may be null if flow was suppressed.
-                    ExecutionContext creatorContext = root.CapturedContext;
-
-
-                    childTask = root.CreateReplicaTask(taskReplicaDelegate, root.m_stateObject, root, root.ExecutingTaskScheduler,
-                                                       creationOptionsForReplicas, internalOptionsForReplicas);
-
-                    childTask.CapturedContext = CopyExecutionContext(creatorContext);
-
-                    childTask.ScheduleAndStart(false);
-                }
-
-
-
-                // Finally invoke the meat of the task.
-                // Note that we are directly calling root.InnerInvoke() even though we are currently be in the action delegate of a child replica 
-                // This is because the actual work was passed down in that delegate, and the action delegate of the child replica simply contains this
-                // replication control logic.
-                try
-                {
-                    // passing in currentTask only so that the parallel debugger can find it
-                    root.InnerInvokeWithArg(currentTask);
-                }
-                catch (Exception exn)
-                {
-                    // Record this exception in the root task's exception list
-                    root.HandleException(exn);
-
-                    if (exn is ThreadAbortException)
-                    {
-                        // If this is a ThreadAbortException it will escape this catch clause, causing us to skip the regular Finish codepath
-                        // In order not to leave the task unfinished, we now call FinishThreadAbortedTask here
-                        currentTask.FinishThreadAbortedTask(false, true);
-                    }
-                }
-
-                Object savedState = currentTask.SavedStateForNextReplica;
-
-                // check for premature exit
-                if (savedState != null)
-                {
-                    // the replica decided to exit early
-                    // we need to queue up a replacement, attach the saved state, and yield the thread right away
-
-                    Task replacementReplica = root.CreateReplicaTask(taskReplicaDelegate, root.m_stateObject, root, root.ExecutingTaskScheduler,
-                                                                    creationOptionsForReplicas, internalOptionsForReplicas);
-
-                    // Propagate a copy of the context from the root task to the replacement task
-                    ExecutionContext creatorContext = root.CapturedContext;
-                    replacementReplica.CapturedContext = CopyExecutionContext(creatorContext);
-
-                    replacementReplica.HandedOverChildReplica = childTask;
-                    replacementReplica.SavedStateFromPreviousReplica = savedState;
-
-                    replacementReplica.ScheduleAndStart(false);
-                }
-                else
-                {
-                    // The replica finished normally, which means it can't find more work to grab. 
-                    // Time to mark replicas quitting
-
-                    replicasAreQuitting = true;
-
-                    // InternalCancel() could conceivably throw in the underlying scheduler's TryDequeue() method.
-                    // If it does, then make sure that we record it.
-                    try
-                    {
-                        childTask.InternalCancel(true);
-                    }
-                    catch (Exception e)
-                    {
-                        // Apparently TryDequeue threw an exception.  Before propagating that exception, InternalCancel should have
-                        // attempted an atomic state transition and a call to CancellationCleanupLogic() on this task. So we know
-                        // the task was properly cleaned up if it was possible. 
-                        //
-                        // Now all we need to do is to Record the exception in the root task.
-
-                        root.HandleException(e);
-                    }
-
-                    // No specific action needed if the child could not be canceled
-                    // because we attached it to the root task, which should therefore be receiving any exceptions from the child,
-                    // and root.wait will not return before this child finishes anyway.
-
-                }
-            };
-
-            //
-            // Now we execute as the root task
-            //
-            taskReplicaDelegate(null);
         }
 
         /// <summary>
@@ -2655,7 +2338,7 @@ namespace System.Threading.Tasks
         /// </summary>
         void IThreadPoolWorkItem.ExecuteWorkItem()
         {
-            ExecuteEntry(false);
+            ExecuteEntryUnsafe();
         }
 
         /// <summary>
@@ -2669,46 +2352,58 @@ namespace System.Threading.Tasks
             if (!IsCompleted)
             {
                 HandleException(tae);
-                FinishThreadAbortedTask(true, false);
+                FinishThreadAbortedTask(delegateRan:false);
             }
         }
 
         /// <summary>
         /// Outermost entry function to execute this task. Handles all aspects of executing a task on the caller thread.
-        /// Currently this is called by IThreadPoolWorkItem.ExecuteWorkItem(), and TaskManager.TryExecuteInline. 
-        /// 
         /// </summary>
-        /// <param name="bPreventDoubleExecution"> Performs atomic updates to prevent double execution. Should only be set to true
-        /// in codepaths servicing user provided TaskSchedulers. The ConcRT or ThreadPool schedulers don't need this. </param>
-        internal bool ExecuteEntry(bool bPreventDoubleExecution)
+        internal bool ExecuteEntry()
         {
-            if (bPreventDoubleExecution || ((Options & (TaskCreationOptions)InternalTaskOptions.SelfReplicating) != 0))
+            // Do atomic state transition from queued to invoked. If we observe a task that's already invoked,
+            // we will return false so that TaskScheduler.ExecuteTask can throw an exception back to the custom scheduler.
+            // However we don't want this exception to be throw if the task was already canceled, because it's a
+            // legitimate scenario for custom schedulers to dequeue a task and mark it as canceled (example: throttling scheduler)
+            int previousState = 0;
+            if (!AtomicStateUpdate(TASK_STATE_DELEGATE_INVOKED,
+                                    TASK_STATE_DELEGATE_INVOKED | TASK_STATE_COMPLETED_MASK,
+                                    ref previousState) && (previousState & TASK_STATE_CANCELED) == 0)
             {
-                int previousState = 0;
+                // This task has already been invoked.  Don't invoke it again.
+                return false;
+            }
 
-                // Do atomic state transition from queued to invoked. If we observe a task that's already invoked,
-                // we will return false so that TaskScheduler.ExecuteTask can throw an exception back to the custom scheduler.
-                // However we don't want this exception to be throw if the task was already canceled, because it's a
-                // legitimate scenario for custom schedulers to dequeue a task and mark it as canceled (example: throttling scheduler)
-                if (!AtomicStateUpdate(TASK_STATE_DELEGATE_INVOKED,
-                                       TASK_STATE_DELEGATE_INVOKED | TASK_STATE_COMPLETED_MASK,
-                                       ref previousState) && (previousState & TASK_STATE_CANCELED) == 0)
-                {
-                    // This task has already been invoked.  Don't invoke it again.
-                    return false;
-                }
+            if (!IsCancellationRequested & !IsCanceled)
+            {
+                ExecuteWithThreadLocal(ref t_currentTask);
             }
             else
             {
-                // Remember that we started running the task delegate.
-                m_stateFlags |= TASK_STATE_DELEGATE_INVOKED;
+                ExecuteEntryCancellationRequestedOrCanceled();
             }
 
-            if (!IsCancellationRequested && !IsCanceled)
+            return true;
+        }
+
+        internal void ExecuteEntryUnsafe() // used instead of ExecuteEntry() when we don't have to worry about double-execution prevent
+        {
+            // Remember that we started running the task delegate.
+            m_stateFlags |= TASK_STATE_DELEGATE_INVOKED;
+
+            if (!IsCancellationRequested & !IsCanceled)
             {
                 ExecuteWithThreadLocal(ref t_currentTask);
             }
-            else if (!IsCanceled)
+            else
+            {
+                ExecuteEntryCancellationRequestedOrCanceled();
+            }
+        }
+
+        internal void ExecuteEntryCancellationRequestedOrCanceled()
+        {
+            if (!IsCanceled)
             {
                 int prevState = Interlocked.Exchange(ref m_stateFlags, m_stateFlags | TASK_STATE_CANCELED);
                 if ((prevState & TASK_STATE_CANCELED) == 0)
@@ -2716,8 +2411,6 @@ namespace System.Threading.Tasks
                     CancellationCleanupLogic();
                 }
             }
-
-            return true;
         }
 
         // A trick so we can refer to the TLS slot with a byref.
@@ -2741,38 +2434,44 @@ namespace System.Threading.Tasks
                     etwLog.TaskStarted(TaskScheduler.Current.Id, 0, this.Id);
             }
 
-            if (AsyncCausalityTracer.LoggingOn)
+            bool loggingOn = AsyncCausalityTracer.LoggingOn;
+            if (loggingOn)
                 AsyncCausalityTracer.TraceSynchronousWorkStart(CausalityTraceLevel.Required, this.Id, CausalitySynchronousWork.Execution);
 
-
             try
             {
                 // place the current task into TLS.
                 currentTaskSlot = this;
 
-                ExecutionContext ec = CapturedContext;
-                if (ec == null)
+                // Execute the task body
+                try
                 {
-                    // No context, just run the task directly.
-                    Execute();
+                    ExecutionContext ec = CapturedContext;
+                    if (ec == null)
+                    {
+                        // No context, just run the task directly.
+                        InnerInvoke();
+                    }
+                    else
+                    {
+                        // Invoke it under the captured ExecutionContext
+                        ExecutionContext.Run(ec, s_ecCallback, this);
+                    }
                 }
-                else
+                catch (Exception exn)
                 {
-                    if (IsSelfReplicatingRoot || IsChildReplica)
+                    // Record this exception in the task's exception list
+                    HandleException(exn);
+                    if (exn is ThreadAbortException)
                     {
-                        CapturedContext = CopyExecutionContext(ec);
+                        // This is a ThreadAbortException and it will be rethrown from this catch clause, causing us to 
+                        // skip the regular Finish codepath. In order not to leave the task unfinished, we now call 
+                        // FinishThreadAbortedTask here.
+                        FinishThreadAbortedTask(delegateRan: true);
                     }
-
-                    // Run the task.  We need a simple shim that converts the
-                    // object back into a Task object, so that we can Execute it.
-
-                    // Lazily initialize the callback delegate; benign race condition
-                    var callback = s_ecCallback;
-                    if (callback == null) s_ecCallback = callback = new ContextCallback(ExecutionContextCallback);
-                    ExecutionContext.Run(ec, callback, this, true);
                 }
 
-                if (AsyncCausalityTracer.LoggingOn)
+                if (loggingOn)
                     AsyncCausalityTracer.TraceSynchronousWorkCompletion(CausalityTraceLevel.Required, CausalitySynchronousWork.Execution);
 
                 Finish(true);
@@ -2796,16 +2495,7 @@ namespace System.Threading.Tasks
             }
         }
 
-        // Cached callback delegate that's lazily initialized due to ContextCallback being SecurityCritical
-        private static ContextCallback s_ecCallback;
-
-        private static void ExecutionContextCallback(object obj)
-        {
-            Task task = obj as Task;
-            Debug.Assert(task != null, "expected a task object");
-            task.Execute();
-        }
-
+        private static readonly ContextCallback s_ecCallback = obj => ((Task)obj).InnerInvoke();
 
         /// <summary>
         /// The actual code which invokes the body of the task. This can be overriden in derived types.
@@ -2830,21 +2520,6 @@ namespace System.Threading.Tasks
         }
 
         /// <summary>
-        /// Alternate InnerInvoke prototype to be called from ExecuteSelfReplicating() so that
-        /// the Parallel Debugger can discover the actual task being invoked. 
-        /// Details: Here, InnerInvoke is actually being called on the rootTask object while we are actually executing the
-        /// childTask. And the debugger needs to discover the childTask, so we pass that down as an argument.
-        /// The NoOptimization and NoInlining flags ensure that the childTask pointer is retained, and that this
-        /// function appears on the callstack.
-        /// </summary>
-        /// <param name="childTask"></param>
-        [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
-        internal void InnerInvokeWithArg(Task childTask)
-        {
-            InnerInvoke();
-        }
-
-        /// <summary>
         /// Performs whatever handling is necessary for an unhandled exception. Normally
         /// this just entails adding the exception to the holder object. 
         /// </summary>
@@ -2903,10 +2578,9 @@ namespace System.Threading.Tasks
         /// true to attempt to marshal the continuation back to the original context captured; otherwise, false.
         /// </param>
         /// <param name="flowExecutionContext">Whether to flow ExecutionContext across the await.</param>
-        /// <param name="stackMark">A stack crawl mark tied to execution context.</param>
         /// <exception cref="System.InvalidOperationException">The awaiter was not properly initialized.</exception>
         internal void SetContinuationForAwait(
-            Action continuationAction, bool continueOnCapturedContext, bool flowExecutionContext, ref StackCrawlMark stackMark)
+            Action continuationAction, bool continueOnCapturedContext, bool flowExecutionContext)
         {
             Contract.Requires(continuationAction != null);
 
@@ -2927,7 +2601,7 @@ namespace System.Threading.Tasks
                 var syncCtx = SynchronizationContext.CurrentNoFlow;
                 if (syncCtx != null && syncCtx.GetType() != typeof(SynchronizationContext))
                 {
-                    tc = new SynchronizationContextAwaitTaskContinuation(syncCtx, continuationAction, flowExecutionContext, ref stackMark);
+                    tc = new SynchronizationContextAwaitTaskContinuation(syncCtx, continuationAction, flowExecutionContext);
                 }
                 else
                 {
@@ -2936,7 +2610,7 @@ namespace System.Threading.Tasks
                     var scheduler = TaskScheduler.InternalCurrent;
                     if (scheduler != null && scheduler != TaskScheduler.Default)
                     {
-                        tc = new TaskSchedulerAwaitTaskContinuation(scheduler, continuationAction, flowExecutionContext, ref stackMark);
+                        tc = new TaskSchedulerAwaitTaskContinuation(scheduler, continuationAction, flowExecutionContext);
                     }
                 }
             }
@@ -2948,7 +2622,7 @@ namespace System.Threading.Tasks
                 // ExecutionContext, we need to capture it and wrap it in an AwaitTaskContinuation.
                 // Otherwise, we're targeting the default scheduler and we don't need to flow ExecutionContext, so
                 // we don't actually need a continuation object.  We can just store/queue the action itself.
-                tc = new AwaitTaskContinuation(continuationAction, flowExecutionContext: true, stackMark: ref stackMark);
+                tc = new AwaitTaskContinuation(continuationAction, flowExecutionContext: true);
             }
 
             // Now register the continuation, and if we couldn't register it because the task is already completing,
@@ -3363,7 +3037,7 @@ namespace System.Threading.Tasks
                     }
                 }
 
-                bool bRequiresAtomicStartTransition = (ts != null && ts.RequiresAtomicStartTransition) || ((Options & (TaskCreationOptions)InternalTaskOptions.SelfReplicating) != 0);
+                bool bRequiresAtomicStartTransition = ts != null && ts.RequiresAtomicStartTransition;
 
                 if (!bPopSucceeded && bCancelNonExecutingOnly && bRequiresAtomicStartTransition)
                 {
@@ -3536,7 +3210,18 @@ namespace System.Threading.Tasks
         {
             // Atomically store the fact that this task is completing.  From this point on, the adding of continuations will
             // result in the continuations being run/launched directly rather than being added to the continuation list.
+            // Then if we grabbed any continuations, run them.
             object continuationObject = Interlocked.Exchange(ref m_continuationObject, s_taskCompletionSentinel);
+            if (continuationObject != null)
+            {
+                RunContinuations(continuationObject);
+            }
+        }
+
+        private void RunContinuations(object continuationObject) // separated out of FinishContinuations to enable it to be inlined
+        {
+            Debug.Assert(continuationObject != null);
+
             TplEtwProvider etw = TplEtwProvider.Log;
             bool tplEtwProviderLoggingEnabled = etw.IsEnabled();
             if (tplEtwProviderLoggingEnabled)
@@ -3544,136 +3229,125 @@ namespace System.Threading.Tasks
                 etw.RunningContinuation(Id, continuationObject);
             }
 
-            // If continuationObject == null, then we don't have any continuations to process
-            if (continuationObject != null)
-            {
-
-                if (AsyncCausalityTracer.LoggingOn)
-                    AsyncCausalityTracer.TraceSynchronousWorkStart(CausalityTraceLevel.Required, this.Id, CausalitySynchronousWork.CompletionNotification);
+            if (AsyncCausalityTracer.LoggingOn)
+                AsyncCausalityTracer.TraceSynchronousWorkStart(CausalityTraceLevel.Required, this.Id, CausalitySynchronousWork.CompletionNotification);
 
-                // Skip synchronous execution of continuations if this task's thread was aborted
-                bool bCanInlineContinuations = !(((m_stateFlags & TASK_STATE_THREAD_WAS_ABORTED) != 0) ||
-                                                  (Thread.CurrentThread.ThreadState == ThreadState.AbortRequested) ||
-                                                  ((m_stateFlags & (int)TaskCreationOptions.RunContinuationsAsynchronously) != 0));
+            // Skip synchronous execution of continuations if this task's thread was aborted
+            bool bCanInlineContinuations = !(((m_stateFlags & TASK_STATE_THREAD_WAS_ABORTED) != 0) ||
+                                              (Thread.CurrentThread.ThreadState == ThreadState.AbortRequested) ||
+                                              ((m_stateFlags & (int)TaskCreationOptions.RunContinuationsAsynchronously) != 0));
 
-                // Handle the single-Action case
-                Action singleAction = continuationObject as Action;
-                if (singleAction != null)
-                {
-                    AwaitTaskContinuation.RunOrScheduleAction(singleAction, bCanInlineContinuations, ref t_currentTask);
-                    LogFinishCompletionNotification();
-                    return;
-                }
+            // Handle the single-Action case
+            Action singleAction = continuationObject as Action;
+            if (singleAction != null)
+            {
+                AwaitTaskContinuation.RunOrScheduleAction(singleAction, bCanInlineContinuations, ref t_currentTask);
+                LogFinishCompletionNotification();
+                return;
+            }
 
-                // Handle the single-ITaskCompletionAction case
-                ITaskCompletionAction singleTaskCompletionAction = continuationObject as ITaskCompletionAction;
-                if (singleTaskCompletionAction != null)
+            // Handle the single-ITaskCompletionAction case
+            ITaskCompletionAction singleTaskCompletionAction = continuationObject as ITaskCompletionAction;
+            if (singleTaskCompletionAction != null)
+            {
+                if (bCanInlineContinuations || !singleTaskCompletionAction.InvokeMayRunArbitraryCode)
                 {
-                    if (bCanInlineContinuations || !singleTaskCompletionAction.InvokeMayRunArbitraryCode)
-                    {
-                        singleTaskCompletionAction.Invoke(this);
-                    }
-                    else
-                    {
-                        ThreadPool.UnsafeQueueCustomWorkItem(new CompletionActionInvoker(singleTaskCompletionAction, this), forceGlobal: false);
-                    }
-                    LogFinishCompletionNotification();
-                    return;
+                    singleTaskCompletionAction.Invoke(this);
                 }
-
-                // Handle the single-TaskContinuation case
-                TaskContinuation singleTaskContinuation = continuationObject as TaskContinuation;
-                if (singleTaskContinuation != null)
+                else
                 {
-                    singleTaskContinuation.Run(this, bCanInlineContinuations);
-                    LogFinishCompletionNotification();
-                    return;
+                    ThreadPool.UnsafeQueueCustomWorkItem(new CompletionActionInvoker(singleTaskCompletionAction, this), forceGlobal: false);
                 }
+                LogFinishCompletionNotification();
+                return;
+            }
 
-                // Not a single; attempt to cast as list
-                List<object> continuations = continuationObject as List<object>;
+            // Handle the single-TaskContinuation case
+            TaskContinuation singleTaskContinuation = continuationObject as TaskContinuation;
+            if (singleTaskContinuation != null)
+            {
+                singleTaskContinuation.Run(this, bCanInlineContinuations);
+                LogFinishCompletionNotification();
+                return;
+            }
 
-                if (continuations == null)
-                {
-                    LogFinishCompletionNotification();
-                    return;  // Not a single or a list; just return
-                }
+            // Not a single; it must be a list.
+            List<object> continuations = (List<object>)continuationObject;
 
-                //
-                // Begin processing of continuation list
-                //
+            //
+            // Begin processing of continuation list
+            //
 
-                // Wait for any concurrent adds or removes to be retired
-                lock (continuations) { }
-                int continuationCount = continuations.Count;
+            // Wait for any concurrent adds or removes to be retired
+            lock (continuations) { }
+            int continuationCount = continuations.Count;
 
-                // Fire the asynchronous continuations first ...
-                for (int i = 0; i < continuationCount; i++)
+            // Fire the asynchronous continuations first ...
+            for (int i = 0; i < continuationCount; i++)
+            {
+                // Synchronous continuation tasks will have the ExecuteSynchronously option,
+                // and we're looking for asynchronous tasks...
+                var tc = continuations[i] as StandardTaskContinuation;
+                if (tc != null && (tc.m_options & TaskContinuationOptions.ExecuteSynchronously) == 0)
                 {
-                    // Synchronous continuation tasks will have the ExecuteSynchronously option,
-                    // and we're looking for asynchronous tasks...
-                    var tc = continuations[i] as StandardTaskContinuation;
-                    if (tc != null && (tc.m_options & TaskContinuationOptions.ExecuteSynchronously) == 0)
+                    if (tplEtwProviderLoggingEnabled)
                     {
-                        if (tplEtwProviderLoggingEnabled)
-                        {
-                            etw.RunningContinuationList(Id, i, tc);
-                        }
-                        continuations[i] = null; // so that we can skip this later
-                        tc.Run(this, bCanInlineContinuations);
+                        etw.RunningContinuationList(Id, i, tc);
                     }
+                    continuations[i] = null; // so that we can skip this later
+                    tc.Run(this, bCanInlineContinuations);
                 }
+            }
 
-                // ... and then fire the synchronous continuations (if there are any).
-                // This includes ITaskCompletionAction, AwaitTaskContinuations, and
-                // Action delegates, which are all by default implicitly synchronous.
-                for (int i = 0; i < continuationCount; i++)
+            // ... and then fire the synchronous continuations (if there are any).
+            // This includes ITaskCompletionAction, AwaitTaskContinuations, and
+            // Action delegates, which are all by default implicitly synchronous.
+            for (int i = 0; i < continuationCount; i++)
+            {
+                object currentContinuation = continuations[i];
+                if (currentContinuation == null) continue;
+                continuations[i] = null; // to enable free'ing up memory earlier
+                if (tplEtwProviderLoggingEnabled)
                 {
-                    object currentContinuation = continuations[i];
-                    if (currentContinuation == null) continue;
-                    continuations[i] = null; // to enable free'ing up memory earlier
-                    if (tplEtwProviderLoggingEnabled)
-                    {
-                        etw.RunningContinuationList(Id, i, currentContinuation);
-                    }
+                    etw.RunningContinuationList(Id, i, currentContinuation);
+                }
 
-                    // If the continuation is an Action delegate, it came from an await continuation,
-                    // and we should use AwaitTaskContinuation to run it.
-                    Action ad = currentContinuation as Action;
-                    if (ad != null)
+                // If the continuation is an Action delegate, it came from an await continuation,
+                // and we should use AwaitTaskContinuation to run it.
+                Action ad = currentContinuation as Action;
+                if (ad != null)
+                {
+                    AwaitTaskContinuation.RunOrScheduleAction(ad, bCanInlineContinuations, ref t_currentTask);
+                }
+                else
+                {
+                    // If it's a TaskContinuation object of some kind, invoke it.
+                    TaskContinuation tc = currentContinuation as TaskContinuation;
+                    if (tc != null)
                     {
-                        AwaitTaskContinuation.RunOrScheduleAction(ad, bCanInlineContinuations, ref t_currentTask);
+                        // We know that this is a synchronous continuation because the
+                        // asynchronous ones have been weeded out
+                        tc.Run(this, bCanInlineContinuations);
                     }
+                    // Otherwise, it must be an ITaskCompletionAction, so invoke it.
                     else
                     {
-                        // If it's a TaskContinuation object of some kind, invoke it.
-                        TaskContinuation tc = currentContinuation as TaskContinuation;
-                        if (tc != null)
+                        Debug.Assert(currentContinuation is ITaskCompletionAction, "Expected continuation element to be Action, TaskContinuation, or ITaskContinuationAction");
+                        var action = (ITaskCompletionAction)currentContinuation;
+
+                        if (bCanInlineContinuations || !action.InvokeMayRunArbitraryCode)
                         {
-                            // We know that this is a synchronous continuation because the
-                            // asynchronous ones have been weeded out
-                            tc.Run(this, bCanInlineContinuations);
+                            action.Invoke(this);
                         }
-                        // Otherwise, it must be an ITaskCompletionAction, so invoke it.
                         else
                         {
-                            Debug.Assert(currentContinuation is ITaskCompletionAction, "Expected continuation element to be Action, TaskContinuation, or ITaskContinuationAction");
-                            var action = (ITaskCompletionAction)currentContinuation;
-
-                            if (bCanInlineContinuations || !action.InvokeMayRunArbitraryCode)
-                            {
-                                action.Invoke(this);
-                            }
-                            else
-                            {
-                                ThreadPool.UnsafeQueueCustomWorkItem(new CompletionActionInvoker(action, this), forceGlobal: false);
-                            }
+                            ThreadPool.UnsafeQueueCustomWorkItem(new CompletionActionInvoker(action, this), forceGlobal: false);
                         }
                     }
                 }
-
-                LogFinishCompletionNotification();
             }
+
+            LogFinishCompletionNotification();
         }
 
         private void LogFinishCompletionNotification()
@@ -3701,11 +3375,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ArgumentNullException">
         /// The <paramref name="continuationAction"/> argument is null.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWith(Action<Task> continuationAction)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith(continuationAction, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith(continuationAction, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None);
         }
 
         /// <summary>
@@ -3728,11 +3400,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWith(Action<Task> continuationAction, CancellationToken cancellationToken)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith(continuationAction, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith(continuationAction, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None);
         }
 
         /// <summary>
@@ -3757,11 +3427,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ArgumentNullException">
         /// The <paramref name="scheduler"/> argument is null.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWith(Action<Task> continuationAction, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith(continuationAction, scheduler, default(CancellationToken), TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith(continuationAction, scheduler, default(CancellationToken), TaskContinuationOptions.None);
         }
 
         /// <summary>
@@ -3792,11 +3460,9 @@ namespace System.Threading.Tasks
         /// The <paramref name="continuationOptions"/> argument specifies an invalid value for <see
         /// cref="T:System.Threading.Tasks.TaskContinuationOptions">TaskContinuationOptions</see>.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWith(Action<Task> continuationAction, TaskContinuationOptions continuationOptions)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith(continuationAction, TaskScheduler.Current, default(CancellationToken), continuationOptions, ref stackMark);
+            return ContinueWith(continuationAction, TaskScheduler.Current, default(CancellationToken), continuationOptions);
         }
 
         /// <summary>
@@ -3837,17 +3503,15 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWith(Action<Task> continuationAction, CancellationToken cancellationToken,
                                  TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith(continuationAction, scheduler, cancellationToken, continuationOptions, ref stackMark);
+            return ContinueWith(continuationAction, scheduler, cancellationToken, continuationOptions);
         }
 
         // Same as the above overload, just with a stack mark parameter.
         private Task ContinueWith(Action<Task> continuationAction, TaskScheduler scheduler,
-            CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, ref StackCrawlMark stackMark)
+            CancellationToken cancellationToken, TaskContinuationOptions continuationOptions)
         {
             // Throw on continuation with null action
             if (continuationAction == null)
@@ -3868,8 +3532,7 @@ namespace System.Threading.Tasks
 
             Task continuationTask = new ContinuationTaskFromTask(
                 this, continuationAction, null,
-                creationOptions, internalOptions,
-                ref stackMark
+                creationOptions, internalOptions
             );
 
             // Register the continuation.  If synchronous execution is requested, this may
@@ -3899,11 +3562,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ArgumentNullException">
         /// The <paramref name="continuationAction"/> argument is null.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWith(Action<Task, Object> continuationAction, Object state)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith(continuationAction, state, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith(continuationAction, state, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None);
         }
 
         /// <summary>
@@ -3927,11 +3588,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWith(Action<Task, Object> continuationAction, Object state, CancellationToken cancellationToken)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith(continuationAction, state, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith(continuationAction, state, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None);
         }
 
         /// <summary>
@@ -3957,11 +3616,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ArgumentNullException">
         /// The <paramref name="scheduler"/> argument is null.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWith(Action<Task, Object> continuationAction, Object state, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith(continuationAction, state, scheduler, default(CancellationToken), TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith(continuationAction, state, scheduler, default(CancellationToken), TaskContinuationOptions.None);
         }
 
         /// <summary>
@@ -3993,11 +3650,9 @@ namespace System.Threading.Tasks
         /// The <paramref name="continuationOptions"/> argument specifies an invalid value for <see
         /// cref="T:System.Threading.Tasks.TaskContinuationOptions">TaskContinuationOptions</see>.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWith(Action<Task, Object> continuationAction, Object state, TaskContinuationOptions continuationOptions)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith(continuationAction, state, TaskScheduler.Current, default(CancellationToken), continuationOptions, ref stackMark);
+            return ContinueWith(continuationAction, state, TaskScheduler.Current, default(CancellationToken), continuationOptions);
         }
 
         /// <summary>
@@ -4039,17 +3694,15 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable
         public Task ContinueWith(Action<Task, Object> continuationAction, Object state, CancellationToken cancellationToken,
                                  TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith(continuationAction, state, scheduler, cancellationToken, continuationOptions, ref stackMark);
+            return ContinueWith(continuationAction, state, scheduler, cancellationToken, continuationOptions);
         }
 
         // Same as the above overload, just with a stack mark parameter.
         private Task ContinueWith(Action<Task, Object> continuationAction, Object state, TaskScheduler scheduler,
-            CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, ref StackCrawlMark stackMark)
+            CancellationToken cancellationToken, TaskContinuationOptions continuationOptions)
         {
             // Throw on continuation with null action
             if (continuationAction == null)
@@ -4070,8 +3723,7 @@ namespace System.Threading.Tasks
 
             Task continuationTask = new ContinuationTaskFromTask(
                 this, continuationAction, state,
-                creationOptions, internalOptions,
-                ref stackMark
+                creationOptions, internalOptions
             );
 
             // Register the continuation.  If synchronous execution is requested, this may
@@ -4104,12 +3756,10 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ArgumentNullException">
         /// The <paramref name="continuationFunction"/> argument is null.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWith<TResult>(Func<Task, TResult> continuationFunction)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             return ContinueWith<TResult>(continuationFunction, TaskScheduler.Current, default(CancellationToken),
-                TaskContinuationOptions.None, ref stackMark);
+                TaskContinuationOptions.None);
         }
 
 
@@ -4136,11 +3786,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWith<TResult>(Func<Task, TResult> continuationFunction, CancellationToken cancellationToken)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith<TResult>(continuationFunction, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith<TResult>(continuationFunction, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None);
         }
 
         /// <summary>
@@ -4168,11 +3816,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ArgumentNullException">
         /// The <paramref name="scheduler"/> argument is null.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWith<TResult>(Func<Task, TResult> continuationFunction, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith<TResult>(continuationFunction, scheduler, default(CancellationToken), TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith<TResult>(continuationFunction, scheduler, default(CancellationToken), TaskContinuationOptions.None);
         }
 
         /// <summary>
@@ -4206,11 +3852,9 @@ namespace System.Threading.Tasks
         /// The <paramref name="continuationOptions"/> argument specifies an invalid value for <see
         /// cref="T:System.Threading.Tasks.TaskContinuationOptions">TaskContinuationOptions</see>.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWith<TResult>(Func<Task, TResult> continuationFunction, TaskContinuationOptions continuationOptions)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith<TResult>(continuationFunction, TaskScheduler.Current, default(CancellationToken), continuationOptions, ref stackMark);
+            return ContinueWith<TResult>(continuationFunction, TaskScheduler.Current, default(CancellationToken), continuationOptions);
         }
 
         /// <summary>
@@ -4254,17 +3898,15 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWith<TResult>(Func<Task, TResult> continuationFunction, CancellationToken cancellationToken,
                                                    TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith<TResult>(continuationFunction, scheduler, cancellationToken, continuationOptions, ref stackMark);
+            return ContinueWith<TResult>(continuationFunction, scheduler, cancellationToken, continuationOptions);
         }
 
         // Same as the above overload, just with a stack mark parameter.
         private Task<TResult> ContinueWith<TResult>(Func<Task, TResult> continuationFunction, TaskScheduler scheduler,
-            CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, ref StackCrawlMark stackMark)
+            CancellationToken cancellationToken, TaskContinuationOptions continuationOptions)
         {
             // Throw on continuation with null function
             if (continuationFunction == null)
@@ -4285,8 +3927,7 @@ namespace System.Threading.Tasks
 
             Task<TResult> continuationTask = new ContinuationResultTaskFromTask<TResult>(
                 this, continuationFunction, null,
-                creationOptions, internalOptions,
-                ref stackMark
+                creationOptions, internalOptions
             );
 
             // Register the continuation.  If synchronous execution is requested, this may
@@ -4319,12 +3960,10 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ArgumentNullException">
         /// The <paramref name="continuationFunction"/> argument is null.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWith<TResult>(Func<Task, Object, TResult> continuationFunction, Object state)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             return ContinueWith<TResult>(continuationFunction, state, TaskScheduler.Current, default(CancellationToken),
-                TaskContinuationOptions.None, ref stackMark);
+                TaskContinuationOptions.None);
         }
 
 
@@ -4352,11 +3991,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWith<TResult>(Func<Task, Object, TResult> continuationFunction, Object state, CancellationToken cancellationToken)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith<TResult>(continuationFunction, state, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith<TResult>(continuationFunction, state, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None);
         }
 
         /// <summary>
@@ -4385,11 +4022,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ArgumentNullException">
         /// The <paramref name="scheduler"/> argument is null.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWith<TResult>(Func<Task, Object, TResult> continuationFunction, Object state, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith<TResult>(continuationFunction, state, scheduler, default(CancellationToken), TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith<TResult>(continuationFunction, state, scheduler, default(CancellationToken), TaskContinuationOptions.None);
         }
 
         /// <summary>
@@ -4424,11 +4059,9 @@ namespace System.Threading.Tasks
         /// The <paramref name="continuationOptions"/> argument specifies an invalid value for <see
         /// cref="T:System.Threading.Tasks.TaskContinuationOptions">TaskContinuationOptions</see>.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWith<TResult>(Func<Task, Object, TResult> continuationFunction, Object state, TaskContinuationOptions continuationOptions)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith<TResult>(continuationFunction, state, TaskScheduler.Current, default(CancellationToken), continuationOptions, ref stackMark);
+            return ContinueWith<TResult>(continuationFunction, state, TaskScheduler.Current, default(CancellationToken), continuationOptions);
         }
 
         /// <summary>
@@ -4473,17 +4106,15 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWith<TResult>(Func<Task, Object, TResult> continuationFunction, Object state, CancellationToken cancellationToken,
                                                    TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith<TResult>(continuationFunction, state, scheduler, cancellationToken, continuationOptions, ref stackMark);
+            return ContinueWith<TResult>(continuationFunction, state, scheduler, cancellationToken, continuationOptions);
         }
 
         // Same as the above overload, just with a stack mark parameter.
         private Task<TResult> ContinueWith<TResult>(Func<Task, Object, TResult> continuationFunction, Object state, TaskScheduler scheduler,
-            CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, ref StackCrawlMark stackMark)
+            CancellationToken cancellationToken, TaskContinuationOptions continuationOptions)
         {
             // Throw on continuation with null function
             if (continuationFunction == null)
@@ -4504,8 +4135,7 @@ namespace System.Threading.Tasks
 
             Task<TResult> continuationTask = new ContinuationResultTaskFromTask<TResult>(
                 this, continuationFunction, state,
-                creationOptions, internalOptions,
-                ref stackMark
+                creationOptions, internalOptions
             );
 
             // Register the continuation.  If synchronous execution is requested, this may
@@ -4529,12 +4159,12 @@ namespace System.Threading.Tasks
             out InternalTaskOptions internalOptions)
         {
             // This is used a couple of times below
-            TaskContinuationOptions NotOnAnything =
+            const TaskContinuationOptions NotOnAnything =
                 TaskContinuationOptions.NotOnCanceled |
                 TaskContinuationOptions.NotOnFaulted |
                 TaskContinuationOptions.NotOnRanToCompletion;
 
-            TaskContinuationOptions creationOptionsMask =
+            const TaskContinuationOptions CreationOptionsMask =
                 TaskContinuationOptions.PreferFairness |
                 TaskContinuationOptions.LongRunning |
                 TaskContinuationOptions.DenyChildAttach |
@@ -4543,15 +4173,15 @@ namespace System.Threading.Tasks
                 TaskContinuationOptions.RunContinuationsAsynchronously;
 
             // Check that LongRunning and ExecuteSynchronously are not specified together
-            TaskContinuationOptions illegalMask = TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.LongRunning;
-            if ((continuationOptions & illegalMask) == illegalMask)
+            const TaskContinuationOptions IllegalMask = TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.LongRunning;
+            if ((continuationOptions & IllegalMask) == IllegalMask)
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.continuationOptions, ExceptionResource.Task_ContinueWith_ESandLR);
             }
 
             // Check that no illegal options were specified
             if ((continuationOptions &
-                ~(creationOptionsMask | NotOnAnything | 
+                ~(CreationOptionsMask | NotOnAnything | 
                     TaskContinuationOptions.LazyCancellation | TaskContinuationOptions.ExecuteSynchronously)) != 0)
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.continuationOptions);
@@ -4564,14 +4194,12 @@ namespace System.Threading.Tasks
             }
 
             // This passes over all but LazyCancellation, which has no representation in TaskCreationOptions
-            creationOptions = (TaskCreationOptions)(continuationOptions & creationOptionsMask);
+            creationOptions = (TaskCreationOptions)(continuationOptions & CreationOptionsMask);
 
-            // internalOptions has at least ContinuationTask ...
-            internalOptions = InternalTaskOptions.ContinuationTask;
-
-            // ... and possibly LazyCancellation
-            if ((continuationOptions & TaskContinuationOptions.LazyCancellation) != 0)
-                internalOptions |= InternalTaskOptions.LazyCancellation;
+            // internalOptions has at least ContinuationTask and possibly LazyCancellation
+            internalOptions = (continuationOptions & TaskContinuationOptions.LazyCancellation) != 0 ?
+                InternalTaskOptions.ContinuationTask | InternalTaskOptions.LazyCancellation :
+                InternalTaskOptions.ContinuationTask;
         }
 
 
@@ -5193,49 +4821,6 @@ namespace System.Threading.Tasks
         }
 
         /// <summary>
-        /// Internal WaitAll implementation which is meant to be used with small number of tasks,
-        /// optimized for Parallel.Invoke and other structured primitives.
-        /// </summary>
-        internal static void FastWaitAll(Task[] tasks)
-        {
-            Contract.Requires(tasks != null);
-
-            List<Exception> exceptions = null;
-
-            // Collects incomplete tasks in "waitedOnTaskList" and their cooperative events in "cooperativeEventList"
-            for (int i = tasks.Length - 1; i >= 0; i--)
-            {
-                if (!tasks[i].IsCompleted)
-                {
-                    // Just attempting to inline here... result doesn't matter.
-                    // We'll do a second pass to do actual wait on each task, and to aggregate their exceptions.
-                    // If the task is inlined here, it will register as IsCompleted in the second pass
-                    // and will just give us the exception.
-                    tasks[i].WrappedTryRunInline();
-                }
-            }
-
-            // Wait on the tasks.
-            for (int i = tasks.Length - 1; i >= 0; i--)
-            {
-                var task = tasks[i];
-                task.SpinThenBlockingWait(Timeout.Infinite, default(CancellationToken));
-                AddExceptionsForCompletedTask(ref exceptions, task);
-
-                // Note that unlike other wait code paths, we do not check
-                // task.NotifyDebuggerOfWaitCompletionIfNecessary() here, because this method is currently
-                // only used from contexts where the tasks couldn't have that bit set, namely
-                // Parallel.Invoke.  If that ever changes, such checks should be added here.
-            }
-
-            // If one or more threw exceptions, aggregate them.
-            if (exceptions != null)
-            {
-                ThrowHelper.ThrowAggregateException(exceptions);
-            }
-        }
-
-        /// <summary>
         /// This internal function is only meant to be called by WaitAll()
         /// If the completed task is canceled or it has other exceptions, here we will add those
         /// into the passed in exception list (which will be lazily initialized here).
@@ -5568,12 +5153,10 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ArgumentNullException">
         /// The <paramref name="action"/> parameter was null.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public static Task Run(Action action)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             return Task.InternalStartNew(null, action, null, default(CancellationToken), TaskScheduler.Default,
-                TaskCreationOptions.DenyChildAttach, InternalTaskOptions.None, ref stackMark);
+                TaskCreationOptions.DenyChildAttach, InternalTaskOptions.None);
         }
 
         /// <summary>
@@ -5588,12 +5171,10 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">
         /// The <see cref="T:System.CancellationTokenSource"/> associated with <paramref name="cancellationToken"/> was disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public static Task Run(Action action, CancellationToken cancellationToken)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             return Task.InternalStartNew(null, action, null, cancellationToken, TaskScheduler.Default,
-                TaskCreationOptions.DenyChildAttach, InternalTaskOptions.None, ref stackMark);
+                TaskCreationOptions.DenyChildAttach, InternalTaskOptions.None);
         }
 
         /// <summary>
@@ -5604,12 +5185,10 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ArgumentNullException">
         /// The <paramref name="function"/> parameter was null.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public static Task<TResult> Run<TResult>(Func<TResult> function)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             return Task<TResult>.StartNew(null, function, default(CancellationToken),
-                TaskCreationOptions.DenyChildAttach, InternalTaskOptions.None, TaskScheduler.Default, ref stackMark);
+                TaskCreationOptions.DenyChildAttach, InternalTaskOptions.None, TaskScheduler.Default);
         }
 
         /// <summary>
@@ -5624,12 +5203,10 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">
         /// The <see cref="T:System.CancellationTokenSource"/> associated with <paramref name="cancellationToken"/> was disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public static Task<TResult> Run<TResult>(Func<TResult> function, CancellationToken cancellationToken)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             return Task<TResult>.StartNew(null, function, cancellationToken,
-                TaskCreationOptions.DenyChildAttach, InternalTaskOptions.None, TaskScheduler.Default, ref stackMark);
+                TaskCreationOptions.DenyChildAttach, InternalTaskOptions.None, TaskScheduler.Default);
         }
 
         /// <summary>
@@ -6746,10 +6323,8 @@ namespace System.Threading.Tasks
         /// <summary>Used to filter out internal vs. public task creation options.</summary>
         InternalOptionsMask = 0x0000FF00,
 
-        ChildReplica = 0x0100,
         ContinuationTask = 0x0200,
         PromiseTask = 0x0400,
-        SelfReplicating = 0x0800,
 
         /// <summary>
         /// Store the presence of TaskContinuationOptions.LazyCancellation, since it does not directly
diff --git a/src/mscorlib/src/System/Threading/Tasks/TaskCompletionSource.cs b/src/mscorlib/src/System/Threading/Tasks/TaskCompletionSource.cs
index 320f704f09..017de0e485 100644
--- a/src/mscorlib/src/System/Threading/Tasks/TaskCompletionSource.cs
+++ b/src/mscorlib/src/System/Threading/Tasks/TaskCompletionSource.cs
@@ -17,7 +17,6 @@ using System.Diagnostics.Contracts;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Runtime.ExceptionServices;
-using System.Security.Permissions;
 using System.Threading;
 
 // Disable the "reference to volatile field not treated as volatile" error.
@@ -203,22 +202,6 @@ namespace System.Threading.Tasks
             return rval;
         }
 
-        /// <summary>Attempts to transition the underlying task to the faulted state.</summary>
-        /// <param name="exceptions">The collection of exception dispatch infos to bind to this task.</param>
-        /// <returns>True if the operation was successful; otherwise, false.</returns>
-        /// <remarks>Unlike the public methods, this method doesn't currently validate that its arguments are correct.</remarks>
-        internal bool TrySetException(IEnumerable<ExceptionDispatchInfo> exceptions)
-        {
-            Debug.Assert(exceptions != null);
-#if DEBUG
-            foreach(var edi in exceptions) Debug.Assert(edi != null, "Contents must be non-null");
-#endif
-
-            bool rval = m_task.TrySetException(exceptions);
-            if (!rval && !m_task.IsCompleted) SpinUntilCompleted();
-            return rval;
-        }
-
         /// <summary>
         /// Transitions the underlying
         /// <see cref="T:System.Threading.Tasks.Task{TResult}"/> into the 
@@ -293,7 +276,7 @@ namespace System.Threading.Tasks
         public bool TrySetResult(TResult result)
         {
             bool rval = m_task.TrySetResult(result);
-            if (!rval && !m_task.IsCompleted) SpinUntilCompleted();
+            if (!rval) SpinUntilCompleted();
             return rval;
         }
 
diff --git a/src/mscorlib/src/System/Threading/Tasks/TaskContinuation.cs b/src/mscorlib/src/System/Threading/Tasks/TaskContinuation.cs
index 70b9418dbf..3c6ccd8dd4 100644
--- a/src/mscorlib/src/System/Threading/Tasks/TaskContinuation.cs
+++ b/src/mscorlib/src/System/Threading/Tasks/TaskContinuation.cs
@@ -29,13 +29,12 @@ namespace System.Threading.Tasks
         private Task m_antecedent;
 
         public ContinuationTaskFromTask(
-            Task antecedent, Delegate action, object state, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, ref StackCrawlMark stackMark) :
+            Task antecedent, Delegate action, object state, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions) :
             base(action, state, Task.InternalCurrentIfAttached(creationOptions), default(CancellationToken), creationOptions, internalOptions, null)
         {
             Contract.Requires(action is Action<Task> || action is Action<Task, object>, 
                 "Invalid delegate type in ContinuationTaskFromTask");
             m_antecedent = antecedent;
-            PossiblyCaptureContext(ref stackMark);
         }
 
         /// <summary>
@@ -77,13 +76,12 @@ namespace System.Threading.Tasks
         private Task m_antecedent;
 
         public ContinuationResultTaskFromTask(
-            Task antecedent, Delegate function, object state, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, ref StackCrawlMark stackMark) :
+            Task antecedent, Delegate function, object state, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions) :
             base(function, state, Task.InternalCurrentIfAttached(creationOptions), default(CancellationToken), creationOptions, internalOptions, null)
         {
             Contract.Requires(function is Func<Task, TResult> || function is Func<Task, object, TResult>, 
                 "Invalid delegate type in ContinuationResultTaskFromTask");
             m_antecedent = antecedent;
-            PossiblyCaptureContext(ref stackMark);
         }
 
         /// <summary>
@@ -125,13 +123,12 @@ namespace System.Threading.Tasks
         private Task<TAntecedentResult> m_antecedent;
 
         public ContinuationTaskFromResultTask(
-            Task<TAntecedentResult> antecedent, Delegate action, object state, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, ref StackCrawlMark stackMark) :
+            Task<TAntecedentResult> antecedent, Delegate action, object state, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions) :
             base(action, state, Task.InternalCurrentIfAttached(creationOptions), default(CancellationToken), creationOptions, internalOptions, null)
         {
             Contract.Requires(action is Action<Task<TAntecedentResult>> || action is Action<Task<TAntecedentResult>, object>, 
                 "Invalid delegate type in ContinuationTaskFromResultTask");
             m_antecedent = antecedent;
-            PossiblyCaptureContext(ref stackMark);
         }
 
         /// <summary>
@@ -173,13 +170,12 @@ namespace System.Threading.Tasks
         private Task<TAntecedentResult> m_antecedent;
 
         public ContinuationResultTaskFromResultTask(
-            Task<TAntecedentResult> antecedent, Delegate function, object state, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, ref StackCrawlMark stackMark) :
+            Task<TAntecedentResult> antecedent, Delegate function, object state, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions) :
             base(function, state, Task.InternalCurrentIfAttached(creationOptions), default(CancellationToken), creationOptions, internalOptions, null)
         {
             Contract.Requires(function is Func<Task<TAntecedentResult>, TResult> || function is Func<Task<TAntecedentResult>, object, TResult>,
                 "Invalid delegate type in ContinuationResultTaskFromResultTask");
             m_antecedent = antecedent;
-            PossiblyCaptureContext(ref stackMark);
         }
 
         /// <summary>
@@ -392,10 +388,9 @@ namespace System.Threading.Tasks
         /// <param name="context">The synchronization context with which to invoke the action.  Must not be null.</param>
         /// <param name="action">The action to invoke. Must not be null.</param>
         /// <param name="flowExecutionContext">Whether to capture and restore ExecutionContext.</param>
-        /// <param name="stackMark">The captured stack mark.</param>
         internal SynchronizationContextAwaitTaskContinuation(
-            SynchronizationContext context, Action action, bool flowExecutionContext, ref StackCrawlMark stackMark) :
-            base(action, flowExecutionContext, ref stackMark)
+            SynchronizationContext context, Action action, bool flowExecutionContext) :
+            base(action, flowExecutionContext)
         {
             Debug.Assert(context != null);
             m_syncContext = context;
@@ -479,10 +474,9 @@ namespace System.Threading.Tasks
         /// <param name="scheduler">The task scheduler with which to invoke the action.  Must not be null.</param>
         /// <param name="action">The action to invoke. Must not be null.</param>
         /// <param name="flowExecutionContext">Whether to capture and restore ExecutionContext.</param>
-        /// <param name="stackMark">The captured stack mark.</param>
         internal TaskSchedulerAwaitTaskContinuation(
-            TaskScheduler scheduler, Action action, bool flowExecutionContext, ref StackCrawlMark stackMark) :
-            base(action, flowExecutionContext, ref stackMark)
+            TaskScheduler scheduler, Action action, bool flowExecutionContext) :
+            base(action, flowExecutionContext)
         {
             Debug.Assert(scheduler != null);
             m_scheduler = scheduler;
@@ -543,29 +537,13 @@ namespace System.Threading.Tasks
         /// <summary>Initializes the continuation.</summary>
         /// <param name="action">The action to invoke. Must not be null.</param>
         /// <param name="flowExecutionContext">Whether to capture and restore ExecutionContext.</param>
-        /// <param name="stackMark">The captured stack mark with which to construct an ExecutionContext.</param>
-        internal AwaitTaskContinuation(Action action, bool flowExecutionContext, ref StackCrawlMark stackMark)
-        {
-            Contract.Requires(action != null);
-            m_action = action;
-            if (flowExecutionContext)
-            {
-                m_capturedContext = ExecutionContext.Capture(
-                    ref stackMark, 
-                    ExecutionContext.CaptureOptions.IgnoreSyncCtx | ExecutionContext.CaptureOptions.OptimizeDefaultCase);
-            }
-        }
-
-        /// <summary>Initializes the continuation.</summary>
-        /// <param name="action">The action to invoke. Must not be null.</param>
-        /// <param name="flowExecutionContext">Whether to capture and restore ExecutionContext.</param>
         internal AwaitTaskContinuation(Action action, bool flowExecutionContext)
         {
             Contract.Requires(action != null);
             m_action = action;
             if (flowExecutionContext)
             {
-                m_capturedContext = ExecutionContext.FastCapture();
+                m_capturedContext = ExecutionContext.Capture();
             }
         }
 
@@ -670,11 +648,7 @@ namespace System.Threading.Tasks
                     // If there is an execution context, get the cached delegate and run the action under the context.
                 else
                 {
-                    try
-                    {
-                        ExecutionContext.Run(m_capturedContext, GetInvokeActionCallback(), m_action, true);
-                    }
-                    finally { m_capturedContext.Dispose(); }
+                    ExecutionContext.Run(m_capturedContext, GetInvokeActionCallback(), m_action);
                 }
             }
             finally
@@ -689,8 +663,7 @@ namespace System.Threading.Tasks
         void IThreadPoolWorkItem.ExecuteWorkItem()
         {
             // inline the fast path
-            if (m_capturedContext == null && !TplEtwProvider.Log.IsEnabled()
-            )
+            if (m_capturedContext == null && !TplEtwProvider.Log.IsEnabled())
             {
                 m_action();
             }
@@ -739,7 +712,7 @@ namespace System.Threading.Tasks
                 // If there's no captured context, just run the callback directly.
                 if (m_capturedContext == null) callback(state);
                 // Otherwise, use the captured context to do so.
-                else ExecutionContext.Run(m_capturedContext, callback, state, true);
+                else ExecutionContext.Run(m_capturedContext, callback, state);
             }
             catch (Exception exc) // we explicitly do not request handling of dangerous exceptions like AVs
             {
@@ -749,9 +722,6 @@ namespace System.Threading.Tasks
             {
                 // Restore the current task information
                 if (prevCurrentTask != null) currentTask = prevCurrentTask;
-
-                // Clean up after the execution context, which is only usable once.
-                if (m_capturedContext != null) m_capturedContext.Dispose();
             }
         }
 
diff --git a/src/mscorlib/src/System/Threading/Tasks/TaskExceptionHolder.cs b/src/mscorlib/src/System/Threading/Tasks/TaskExceptionHolder.cs
index 45817dab23..ee1112a93f 100644
--- a/src/mscorlib/src/System/Threading/Tasks/TaskExceptionHolder.cs
+++ b/src/mscorlib/src/System/Threading/Tasks/TaskExceptionHolder.cs
@@ -149,23 +149,6 @@ namespace System.Threading.Tasks
         /// Add an exception to the holder.  This will ensure the holder is
         /// in the proper state (handled/unhandled) depending on the list's contents.
         /// </summary>
-        /// <param name="exceptionObject">
-        /// An exception object (either an Exception, an ExceptionDispatchInfo,
-        /// an IEnumerable{Exception}, or an IEnumerable{ExceptionDispatchInfo}) 
-        /// to add to the list.
-        /// </param>
-        /// <remarks>
-        /// Must be called under lock.
-        /// </remarks>
-        internal void Add(object exceptionObject)
-        {
-            Add(exceptionObject, representsCancellation: false);
-        }
-
-        /// <summary>
-        /// Add an exception to the holder.  This will ensure the holder is
-        /// in the proper state (handled/unhandled) depending on the list's contents.
-        /// </summary>
         /// <param name="representsCancellation">
         /// Whether the exception represents a cancellation request (true) or a fault (false).
         /// </param>
diff --git a/src/mscorlib/src/System/Threading/Tasks/TaskFactory.cs b/src/mscorlib/src/System/Threading/Tasks/TaskFactory.cs
index aa4c2df74b..ed9b798902 100644
--- a/src/mscorlib/src/System/Threading/Tasks/TaskFactory.cs
+++ b/src/mscorlib/src/System/Threading/Tasks/TaskFactory.cs
@@ -15,7 +15,6 @@
 using System;
 using System.Collections.Generic;
 using System.Security;
-using System.Security.Permissions;
 using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Diagnostics;
@@ -41,30 +40,20 @@ namespace System.Threading.Tasks
     public class TaskFactory
     {
         // member variables
-        private CancellationToken m_defaultCancellationToken;
-        private TaskScheduler m_defaultScheduler;
-        private TaskCreationOptions m_defaultCreationOptions;
-        private TaskContinuationOptions m_defaultContinuationOptions;
+        private readonly CancellationToken m_defaultCancellationToken;
+        private readonly TaskScheduler m_defaultScheduler;
+        private readonly TaskCreationOptions m_defaultCreationOptions;
+        private readonly TaskContinuationOptions m_defaultContinuationOptions;
 
-
-        private TaskScheduler DefaultScheduler
-        {
-            get
-            {
-                if (m_defaultScheduler == null) return TaskScheduler.Current;
-                else return m_defaultScheduler;
-            }
-        }
+        private TaskScheduler DefaultScheduler => m_defaultScheduler ?? TaskScheduler.Current;
 
         // sister method to above property -- avoids a TLS lookup
         private TaskScheduler GetDefaultScheduler(Task currTask)
         {
-            if (m_defaultScheduler != null) return m_defaultScheduler;
-            else if ((currTask != null)
-                && ((currTask.CreationOptions & TaskCreationOptions.HideScheduler) == 0)
-                )
-                return currTask.ExecutingTaskScheduler;
-            else return TaskScheduler.Default;
+            return
+                m_defaultScheduler ??
+                (currTask != null && (currTask.CreationOptions & TaskCreationOptions.HideScheduler) == 0 ? currTask.ExecutingTaskScheduler :
+                 TaskScheduler.Default);
         }
 
         /* Constructors */
@@ -225,7 +214,7 @@ namespace System.Threading.Tasks
                       TaskCreationOptions.PreferFairness |
                       TaskCreationOptions.RunContinuationsAsynchronously)) != 0)
             {
-                throw new ArgumentOutOfRangeException(nameof(creationOptions));
+                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.creationOptions);
             }
             Contract.EndContractBlock();
         }
@@ -293,13 +282,11 @@ namespace System.Threading.Tasks
         /// unless creation and scheduling must be separated, StartNew is the recommended
         /// approach for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task StartNew(Action action)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             Task currTask = Task.InternalCurrent;
             return Task.InternalStartNew(currTask, action, null, m_defaultCancellationToken, GetDefaultScheduler(currTask),
-                m_defaultCreationOptions, InternalTaskOptions.None, ref stackMark);
+                m_defaultCreationOptions, InternalTaskOptions.None);
         }
 
         /// <summary>
@@ -320,13 +307,11 @@ namespace System.Threading.Tasks
         /// unless creation and scheduling must be separated, StartNew is the recommended
         /// approach for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task StartNew(Action action, CancellationToken cancellationToken)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             Task currTask = Task.InternalCurrent;
             return Task.InternalStartNew(currTask, action, null, cancellationToken, GetDefaultScheduler(currTask),
-                m_defaultCreationOptions, InternalTaskOptions.None, ref stackMark);
+                m_defaultCreationOptions, InternalTaskOptions.None);
         }
 
         /// <summary>
@@ -350,13 +335,11 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task StartNew(Action action, TaskCreationOptions creationOptions)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             Task currTask = Task.InternalCurrent;
             return Task.InternalStartNew(currTask, action, null, m_defaultCancellationToken, GetDefaultScheduler(currTask), creationOptions,
-                InternalTaskOptions.None, ref stackMark);
+                InternalTaskOptions.None);
         }
 
         /// <summary>
@@ -391,22 +374,11 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task StartNew(Action action, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             return Task.InternalStartNew(
                 Task.InternalCurrentIfAttached(creationOptions), action, null, cancellationToken, scheduler, creationOptions,
-                InternalTaskOptions.None, ref stackMark);
-        }
-
-        // Internal version includes InternalTaskOptions for Parallel.Invoke() support.
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
-        internal Task StartNew(Action action, CancellationToken cancellationToken, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler)
-        {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return Task.InternalStartNew(
-                Task.InternalCurrentIfAttached(creationOptions), action, null, cancellationToken, scheduler, creationOptions, internalOptions, ref stackMark);
+                InternalTaskOptions.None);
         }
 
 
@@ -427,13 +399,11 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task StartNew(Action<Object> action, Object state)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             Task currTask = Task.InternalCurrent;
             return Task.InternalStartNew(currTask, action, state, m_defaultCancellationToken, GetDefaultScheduler(currTask),
-                m_defaultCreationOptions, InternalTaskOptions.None, ref stackMark);
+                m_defaultCreationOptions, InternalTaskOptions.None);
         }
 
 
@@ -458,13 +428,11 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task StartNew(Action<Object> action, Object state, CancellationToken cancellationToken)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             Task currTask = Task.InternalCurrent;
             return Task.InternalStartNew(currTask, action, state, cancellationToken, GetDefaultScheduler(currTask),
-                m_defaultCreationOptions, InternalTaskOptions.None, ref stackMark);
+                m_defaultCreationOptions, InternalTaskOptions.None);
         }
 
         /// <summary>
@@ -490,13 +458,11 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task StartNew(Action<Object> action, Object state, TaskCreationOptions creationOptions)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             Task currTask = Task.InternalCurrent;
             return Task.InternalStartNew(currTask, action, state, m_defaultCancellationToken, GetDefaultScheduler(currTask),
-                creationOptions, InternalTaskOptions.None, ref stackMark);
+                creationOptions, InternalTaskOptions.None);
         }
 
         /// <summary>
@@ -533,14 +499,12 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task StartNew(Action<Object> action, Object state, CancellationToken cancellationToken,
                             TaskCreationOptions creationOptions, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             return Task.InternalStartNew(
                 Task.InternalCurrentIfAttached(creationOptions), action, state, cancellationToken, scheduler,
-                creationOptions, InternalTaskOptions.None, ref stackMark);
+                creationOptions, InternalTaskOptions.None);
         }
 
         /// <summary>
@@ -562,13 +526,11 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> StartNew<TResult>(Func<TResult> function)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             Task currTask = Task.InternalCurrent;
             return Task<TResult>.StartNew(currTask, function, m_defaultCancellationToken,
-                m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask), ref stackMark);
+                m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask));
         }
 
 
@@ -595,13 +557,11 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> StartNew<TResult>(Func<TResult> function, CancellationToken cancellationToken)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             Task currTask = Task.InternalCurrent;
             return Task<TResult>.StartNew(currTask, function, cancellationToken,
-                m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask), ref stackMark);
+                m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask));
         }
 
         /// <summary>
@@ -629,13 +589,11 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> StartNew<TResult>(Func<TResult> function, TaskCreationOptions creationOptions)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             Task currTask = Task.InternalCurrent;
             return Task<TResult>.StartNew(currTask, function, m_defaultCancellationToken,
-                creationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask), ref stackMark);
+                creationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask));
         }
 
         /// <summary>
@@ -674,13 +632,11 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> StartNew<TResult>(Func<TResult> function, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             return Task<TResult>.StartNew(
                 Task.InternalCurrentIfAttached(creationOptions), function, cancellationToken,
-                creationOptions, InternalTaskOptions.None, scheduler, ref stackMark);
+                creationOptions, InternalTaskOptions.None, scheduler);
         }
 
         /// <summary>
@@ -704,13 +660,11 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> StartNew<TResult>(Func<Object, TResult> function, Object state)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             Task currTask = Task.InternalCurrent;
             return Task<TResult>.StartNew(currTask, function, state, m_defaultCancellationToken,
-                m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask), ref stackMark);
+                m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask));
         }
 
 
@@ -739,13 +693,11 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> StartNew<TResult>(Func<Object, TResult> function, Object state, CancellationToken cancellationToken)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             Task currTask = Task.InternalCurrent;
             return Task<TResult>.StartNew(currTask, function, state, cancellationToken,
-                m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask), ref stackMark);
+                m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask));
         }
 
         /// <summary>
@@ -775,13 +727,11 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> StartNew<TResult>(Func<Object, TResult> function, Object state, TaskCreationOptions creationOptions)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             Task currTask = Task.InternalCurrent;
             return Task<TResult>.StartNew(currTask, function, state, m_defaultCancellationToken,
-                creationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask), ref stackMark);
+                creationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask));
         }
 
         /// <summary>
@@ -822,14 +772,12 @@ namespace System.Threading.Tasks
         /// However, unless creation and scheduling must be separated, StartNew is the recommended approach
         /// for both simplicity and performance.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> StartNew<TResult>(Func<Object, TResult> function, Object state, CancellationToken cancellationToken,
             TaskCreationOptions creationOptions, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             return Task<TResult>.StartNew(
                 Task.InternalCurrentIfAttached(creationOptions), function, state, cancellationToken,
-                creationOptions, InternalTaskOptions.None, scheduler, ref stackMark);
+                creationOptions, InternalTaskOptions.None, scheduler);
         }
 
         //
@@ -850,13 +798,11 @@ namespace System.Threading.Tasks
         /// <paramref name="endMethod"/> argument is null.</exception>
         /// <returns>A <see cref="T:System.Threading.Tasks.Task">Task</see> that represents the asynchronous
         /// operation.</returns>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task FromAsync(
             IAsyncResult asyncResult,
             Action<IAsyncResult> endMethod)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return FromAsync(asyncResult, endMethod, m_defaultCreationOptions, DefaultScheduler, ref stackMark);
+            return FromAsync(asyncResult, endMethod, m_defaultCreationOptions, DefaultScheduler);
         }
 
         /// <summary>
@@ -878,14 +824,12 @@ namespace System.Threading.Tasks
         /// value.</exception>
         /// <returns>A <see cref="T:System.Threading.Tasks.Task">Task</see> that represents the asynchronous
         /// operation.</returns>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task FromAsync(
             IAsyncResult asyncResult,
             Action<IAsyncResult> endMethod,
             TaskCreationOptions creationOptions)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return FromAsync(asyncResult, endMethod, creationOptions, DefaultScheduler, ref stackMark);
+            return FromAsync(asyncResult, endMethod, creationOptions, DefaultScheduler);
         }
 
         /// <summary>
@@ -911,26 +855,13 @@ namespace System.Threading.Tasks
         /// value.</exception>
         /// <returns>A <see cref="T:System.Threading.Tasks.Task">Task</see> that represents the asynchronous
         /// operation.</returns>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task FromAsync(
             IAsyncResult asyncResult,
             Action<IAsyncResult> endMethod,
             TaskCreationOptions creationOptions,
             TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return FromAsync(asyncResult, endMethod, creationOptions, scheduler, ref stackMark);
-        }
-
-        // private version that supports StackCrawlMark.
-        private Task FromAsync(
-            IAsyncResult asyncResult,
-            Action<IAsyncResult> endMethod,
-            TaskCreationOptions creationOptions,
-            TaskScheduler scheduler,
-            ref StackCrawlMark stackMark)
-        {
-            return TaskFactory<VoidTaskResult>.FromAsyncImpl(asyncResult, null, endMethod, creationOptions, scheduler, ref stackMark);
+            return TaskFactory<VoidTaskResult>.FromAsyncImpl(asyncResult, null, endMethod, creationOptions, scheduler);
         }
 
         /// <summary>
@@ -1228,12 +1159,10 @@ namespace System.Threading.Tasks
         /// <paramref name="endMethod"/> argument is null.</exception>
         /// <returns>A <see cref="T:System.Threading.Tasks.Task{TResult}">Task</see> that represents the
         /// asynchronous operation.</returns>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> FromAsync<TResult>(
             IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<TResult>.FromAsyncImpl(asyncResult, endMethod, null, m_defaultCreationOptions, DefaultScheduler, ref stackMark);
+            return TaskFactory<TResult>.FromAsyncImpl(asyncResult, endMethod, null, m_defaultCreationOptions, DefaultScheduler);
         }
 
         /// <summary>
@@ -1258,12 +1187,10 @@ namespace System.Threading.Tasks
         /// value.</exception>
         /// <returns>A <see cref="T:System.Threading.Tasks.Task{TResult}">Task</see> that represents the
         /// asynchronous operation.</returns>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> FromAsync<TResult>(
             IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod, TaskCreationOptions creationOptions)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<TResult>.FromAsyncImpl(asyncResult, endMethod, null, creationOptions, DefaultScheduler, ref stackMark);
+            return TaskFactory<TResult>.FromAsyncImpl(asyncResult, endMethod, null, creationOptions, DefaultScheduler);
         }
 
         /// <summary>
@@ -1292,12 +1219,10 @@ namespace System.Threading.Tasks
         /// value.</exception>
         /// <returns>A <see cref="T:System.Threading.Tasks.Task{TResult}">Task</see> that represents the
         /// asynchronous operation.</returns>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> FromAsync<TResult>(
             IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod, TaskCreationOptions creationOptions, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<TResult>.FromAsyncImpl(asyncResult, endMethod, null, creationOptions, scheduler, ref stackMark);
+            return TaskFactory<TResult>.FromAsyncImpl(asyncResult, endMethod, null, creationOptions, scheduler);
         }
 
         /// <summary>
@@ -1606,7 +1531,7 @@ namespace System.Threading.Tasks
                       TaskCreationOptions.PreferFairness |
                       TaskCreationOptions.LongRunning)) != 0)
             {
-                throw new ArgumentOutOfRangeException(nameof(creationOptions));
+                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.creationOptions);
             }
         }
 
@@ -1798,14 +1723,12 @@ namespace System.Threading.Tasks
         /// <paramref name="tasks"/> array contains a null value.</exception>
         /// <exception cref="T:System.ArgumentException">The exception that is thrown when the 
         /// <paramref name="tasks"/> array is empty.</exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWhenAll(Task[] tasks, Action<Task[]> continuationAction)
         {
             if (continuationAction == null) throw new ArgumentNullException(nameof(continuationAction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl(tasks, null, continuationAction, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl(tasks, null, continuationAction, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
 
@@ -1830,14 +1753,12 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWhenAll(Task[] tasks, Action<Task[]> continuationAction, CancellationToken cancellationToken)
         {
             if (continuationAction == null) throw new ArgumentNullException(nameof(continuationAction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl(tasks, null, continuationAction, m_defaultContinuationOptions, cancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl(tasks, null, continuationAction, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -1867,14 +1788,12 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAll.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWhenAll(Task[] tasks, Action<Task[]> continuationAction, TaskContinuationOptions continuationOptions)
         {
             if (continuationAction == null) throw new ArgumentNullException(nameof(continuationAction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl(tasks, null, continuationAction, continuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl(tasks, null, continuationAction, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -1914,15 +1833,13 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAll.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWhenAll(Task[] tasks, Action<Task[]> continuationAction, CancellationToken cancellationToken,
             TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
         {
             if (continuationAction == null) throw new ArgumentNullException(nameof(continuationAction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl(tasks, null, continuationAction, continuationOptions, cancellationToken, scheduler, ref stackMark);
+            return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl(tasks, null, continuationAction, continuationOptions, cancellationToken, scheduler);
         }
 
         /// <summary>
@@ -1942,14 +1859,12 @@ namespace System.Threading.Tasks
         /// <paramref name="tasks"/> array contains a null value.</exception>
         /// <exception cref="T:System.ArgumentException">The exception that is thrown when the 
         /// <paramref name="tasks"/> array is empty.</exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>[]> continuationAction)
         {
             if (continuationAction == null) throw new ArgumentNullException(nameof(continuationAction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl<TAntecedentResult>(tasks, null, continuationAction, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl<TAntecedentResult>(tasks, null, continuationAction, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
 
@@ -1975,15 +1890,13 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>[]> continuationAction,
             CancellationToken cancellationToken)
         {
             if (continuationAction == null) throw new ArgumentNullException(nameof(continuationAction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl<TAntecedentResult>(tasks, null, continuationAction, m_defaultContinuationOptions, cancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl<TAntecedentResult>(tasks, null, continuationAction, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -2014,15 +1927,13 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAll.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>[]> continuationAction,
             TaskContinuationOptions continuationOptions)
         {
             if (continuationAction == null) throw new ArgumentNullException(nameof(continuationAction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl<TAntecedentResult>(tasks, null, continuationAction, continuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl<TAntecedentResult>(tasks, null, continuationAction, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -2063,15 +1974,13 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAll.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>[]> continuationAction,
             CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
         {
             if (continuationAction == null) throw new ArgumentNullException(nameof(continuationAction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl<TAntecedentResult>(tasks, null, continuationAction, continuationOptions, cancellationToken, scheduler, ref stackMark);
+            return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl<TAntecedentResult>(tasks, null, continuationAction, continuationOptions, cancellationToken, scheduler);
         }
 
         /// <summary>
@@ -2094,14 +2003,12 @@ namespace System.Threading.Tasks
         /// <paramref name="tasks"/> array contains a null value.</exception>
         /// <exception cref="T:System.ArgumentException">The exception that is thrown when the
         /// <paramref name="tasks"/> array is empty.</exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAll<TResult>(Task[] tasks, Func<Task[], TResult> continuationFunction)
         {
             if (continuationFunction == null) throw new ArgumentNullException(nameof(continuationFunction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<TResult>.ContinueWhenAllImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<TResult>.ContinueWhenAllImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
 
@@ -2130,14 +2037,12 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAll<TResult>(Task[] tasks, Func<Task[], TResult> continuationFunction, CancellationToken cancellationToken)
         {
             if (continuationFunction == null) throw new ArgumentNullException(nameof(continuationFunction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<TResult>.ContinueWhenAllImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<TResult>.ContinueWhenAllImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -2171,14 +2076,12 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAll.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAll<TResult>(Task[] tasks, Func<Task[], TResult> continuationFunction, TaskContinuationOptions continuationOptions)
         {
             if (continuationFunction == null) throw new ArgumentNullException(nameof(continuationFunction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<TResult>.ContinueWhenAllImpl(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<TResult>.ContinueWhenAllImpl(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -2222,15 +2125,13 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAll.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAll<TResult>(Task[] tasks, Func<Task[], TResult> continuationFunction, CancellationToken cancellationToken,
             TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
         {
             if (continuationFunction == null) throw new ArgumentNullException(nameof(continuationFunction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<TResult>.ContinueWhenAllImpl(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler, ref stackMark);
+            return TaskFactory<TResult>.ContinueWhenAllImpl(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler);
         }
 
 
@@ -2255,14 +2156,12 @@ namespace System.Threading.Tasks
         /// <paramref name="tasks"/> array contains a null value.</exception>
         /// <exception cref="T:System.ArgumentException">The exception that is thrown when the
         /// <paramref name="tasks"/> array is empty.</exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAll<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction)
         {
             if (continuationFunction == null) throw new ArgumentNullException(nameof(continuationFunction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<TResult>.ContinueWhenAllImpl<TAntecedentResult>(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<TResult>.ContinueWhenAllImpl<TAntecedentResult>(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -2291,15 +2190,13 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAll<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction,
             CancellationToken cancellationToken)
         {
             if (continuationFunction == null) throw new ArgumentNullException(nameof(continuationFunction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<TResult>.ContinueWhenAllImpl<TAntecedentResult>(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<TResult>.ContinueWhenAllImpl<TAntecedentResult>(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -2334,15 +2231,13 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAll.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAll<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction,
             TaskContinuationOptions continuationOptions)
         {
             if (continuationFunction == null) throw new ArgumentNullException(nameof(continuationFunction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<TResult>.ContinueWhenAllImpl<TAntecedentResult>(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<TResult>.ContinueWhenAllImpl<TAntecedentResult>(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -2387,15 +2282,13 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAll.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAll<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction,
             CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
         {
             if (continuationFunction == null) throw new ArgumentNullException(nameof(continuationFunction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<TResult>.ContinueWhenAllImpl<TAntecedentResult>(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler, ref stackMark);
+            return TaskFactory<TResult>.ContinueWhenAllImpl<TAntecedentResult>(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler);
         }
 
         //
@@ -2434,7 +2327,8 @@ namespace System.Threading.Tasks
 
             public void Invoke(Task completingTask)
             {
-                if (Interlocked.CompareExchange(ref m_firstTaskAlreadyCompleted, 1, 0) == 0)
+                if (m_firstTaskAlreadyCompleted == 0 &&
+                    Interlocked.Exchange(ref m_firstTaskAlreadyCompleted, 1) == 0)
                 {
                     if (AsyncCausalityTracer.LoggingOn)
                     {
@@ -2505,7 +2399,23 @@ namespace System.Threading.Tasks
                     checkArgsOnly = true;
                 }
                 // Otherwise, add the completion action and keep going.
-                else task.AddCompletionAction(promise);
+                else
+                {
+                    task.AddCompletionAction(promise);
+                    if (promise.IsCompleted)
+                    {
+                        // One of the previous tasks that already had its continuation registered may have
+                        // raced to complete with our adding the continuation to this task.  The completion
+                        // routine would have gone through and removed the continuation from all of the tasks
+                        // with which it was already registered, but if the race causes this continuation to
+                        // be added after that, it'll never be removed.  As such, after adding the continuation,
+                        // we check to see whether the promise has already completed, and if it has, we try to
+                        // manually remove the continuation from this task.  If it was already removed, it'll be
+                        // a nop, and if we race to remove it, the synchronization in RemoveContinuation will
+                        // keep things consistent.
+                        task.RemoveContinuation(promise);
+                    }
+                }
             }
 
             return promise;
@@ -2528,14 +2438,12 @@ namespace System.Threading.Tasks
         /// <paramref name="tasks"/> array contains a null value.</exception>
         /// <exception cref="T:System.ArgumentException">The exception that is thrown when the
         /// <paramref name="tasks"/> array is empty.</exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWhenAny(Task[] tasks, Action<Task> continuationAction)
         {
             if (continuationAction == null) throw new ArgumentNullException(nameof(continuationAction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl(tasks, null, continuationAction, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl(tasks, null, continuationAction, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -2559,14 +2467,12 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWhenAny(Task[] tasks, Action<Task> continuationAction, CancellationToken cancellationToken)
         {
             if (continuationAction == null) throw new ArgumentNullException(nameof(continuationAction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl(tasks, null, continuationAction, m_defaultContinuationOptions, cancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl(tasks, null, continuationAction, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -2596,14 +2502,12 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAny.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWhenAny(Task[] tasks, Action<Task> continuationAction, TaskContinuationOptions continuationOptions)
         {
             if (continuationAction == null) throw new ArgumentNullException(nameof(continuationAction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl(tasks, null, continuationAction, continuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl(tasks, null, continuationAction, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -2643,15 +2547,13 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAny.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWhenAny(Task[] tasks, Action<Task> continuationAction, CancellationToken cancellationToken,
             TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
         {
             if (continuationAction == null) throw new ArgumentNullException(nameof(continuationAction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl(tasks, null, continuationAction, continuationOptions, cancellationToken, scheduler, ref stackMark);
+            return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl(tasks, null, continuationAction, continuationOptions, cancellationToken, scheduler);
         }
 
 
@@ -2675,14 +2577,12 @@ namespace System.Threading.Tasks
         /// <paramref name="tasks"/> array contains a null value.</exception>
         /// <exception cref="T:System.ArgumentException">The exception that is thrown when the
         /// <paramref name="tasks"/> array is empty.</exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAny<TResult>(Task[] tasks, Func<Task, TResult> continuationFunction)
         {
             if (continuationFunction == null) throw new ArgumentNullException(nameof(continuationFunction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<TResult>.ContinueWhenAnyImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<TResult>.ContinueWhenAnyImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -2710,14 +2610,12 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAny<TResult>(Task[] tasks, Func<Task, TResult> continuationFunction, CancellationToken cancellationToken)
         {
             if (continuationFunction == null) throw new ArgumentNullException(nameof(continuationFunction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<TResult>.ContinueWhenAnyImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<TResult>.ContinueWhenAnyImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -2751,14 +2649,12 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAny.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAny<TResult>(Task[] tasks, Func<Task, TResult> continuationFunction, TaskContinuationOptions continuationOptions)
         {
             if (continuationFunction == null) throw new ArgumentNullException(nameof(continuationFunction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<TResult>.ContinueWhenAnyImpl(tasks, continuationFunction, null,continuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<TResult>.ContinueWhenAnyImpl(tasks, continuationFunction, null,continuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -2802,15 +2698,13 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAny.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAny<TResult>(Task[] tasks, Func<Task, TResult> continuationFunction, CancellationToken cancellationToken,
             TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
         {
             if (continuationFunction == null) throw new ArgumentNullException(nameof(continuationFunction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<TResult>.ContinueWhenAnyImpl(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler, ref stackMark);
+            return TaskFactory<TResult>.ContinueWhenAnyImpl(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler);
         }
 
         /// <summary>
@@ -2834,12 +2728,10 @@ namespace System.Threading.Tasks
         /// <paramref name="tasks"/> array contains a null value.</exception>
         /// <exception cref="T:System.ArgumentException">The exception that is thrown when the
         /// <paramref name="tasks"/> array is empty.</exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAny<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             if (continuationFunction == null) throw new ArgumentNullException(nameof(continuationFunction));
-            return TaskFactory<TResult>.ContinueWhenAnyImpl<TAntecedentResult>(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<TResult>.ContinueWhenAnyImpl<TAntecedentResult>(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -2868,15 +2760,13 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAny<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction,
             CancellationToken cancellationToken)
         {
             if (continuationFunction == null) throw new ArgumentNullException(nameof(continuationFunction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<TResult>.ContinueWhenAnyImpl<TAntecedentResult>(tasks, continuationFunction, null,  m_defaultContinuationOptions, cancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<TResult>.ContinueWhenAnyImpl<TAntecedentResult>(tasks, continuationFunction, null,  m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -2911,15 +2801,13 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAny.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAny<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction,
             TaskContinuationOptions continuationOptions)
         {
             if (continuationFunction == null) throw new ArgumentNullException(nameof(continuationFunction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<TResult>.ContinueWhenAnyImpl<TAntecedentResult>(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<TResult>.ContinueWhenAnyImpl<TAntecedentResult>(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -2964,15 +2852,13 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAny.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TResult> ContinueWhenAny<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction,
             CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
         {
             if (continuationFunction == null) throw new ArgumentNullException(nameof(continuationFunction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<TResult>.ContinueWhenAnyImpl<TAntecedentResult>(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler, ref stackMark);
+            return TaskFactory<TResult>.ContinueWhenAnyImpl<TAntecedentResult>(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler);
         }
 
 
@@ -2993,14 +2879,12 @@ namespace System.Threading.Tasks
         /// <paramref name="tasks"/> array contains a null value.</exception>
         /// <exception cref="T:System.ArgumentException">The exception that is thrown when the
         /// <paramref name="tasks"/> array is empty.</exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>> continuationAction)
         {
             if (continuationAction == null) throw new ArgumentNullException(nameof(continuationAction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl<TAntecedentResult>(tasks, null, continuationAction, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl<TAntecedentResult>(tasks, null, continuationAction, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -3025,15 +2909,13 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>> continuationAction,
             CancellationToken cancellationToken)
         {
             if (continuationAction == null) throw new ArgumentNullException(nameof(continuationAction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl<TAntecedentResult>(tasks, null, continuationAction, m_defaultContinuationOptions, cancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl<TAntecedentResult>(tasks, null, continuationAction, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -3064,15 +2946,13 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAny.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>> continuationAction,
             TaskContinuationOptions continuationOptions)
         {
             if (continuationAction == null) throw new ArgumentNullException(nameof(continuationAction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl<TAntecedentResult>(tasks, null, continuationAction, continuationOptions, m_defaultCancellationToken, DefaultScheduler, ref stackMark);
+            return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl<TAntecedentResult>(tasks, null, continuationAction, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
         }
 
         /// <summary>
@@ -3113,15 +2993,13 @@ namespace System.Threading.Tasks
         /// which constrain for which <see cref="System.Threading.Tasks.TaskStatus">TaskStatus</see> states a continuation 
         /// will be executed, are illegal with ContinueWhenAny.
         /// </remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>> continuationAction,
             CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
         {
             if (continuationAction == null) throw new ArgumentNullException(nameof(continuationAction));
             Contract.EndContractBlock();
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl<TAntecedentResult>(tasks, null, continuationAction, continuationOptions, cancellationToken, scheduler, ref stackMark);
+            return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl<TAntecedentResult>(tasks, null, continuationAction, continuationOptions, cancellationToken, scheduler);
         }
 
         // Check task array and return a defensive copy.
diff --git a/src/mscorlib/src/System/Threading/Tasks/TaskScheduler.cs b/src/mscorlib/src/System/Threading/Tasks/TaskScheduler.cs
index fad3fc06c5..7cdf1964ac 100644
--- a/src/mscorlib/src/System/Threading/Tasks/TaskScheduler.cs
+++ b/src/mscorlib/src/System/Threading/Tasks/TaskScheduler.cs
@@ -16,7 +16,6 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.Threading;
 using System.Security;
-using System.Security.Permissions;
 using System.Collections.Concurrent;
 using System.Diagnostics.Contracts;
 using System.Diagnostics;
@@ -204,7 +203,10 @@ namespace System.Threading.Tasks
             bool bInlined = false;
             try
             {
-                task.FireTaskScheduledIfNeeded(this);
+                if (TplEtwProvider.Log.IsEnabled())
+                {
+                    task.FireTaskScheduledIfNeeded(this);
+                }
                 bInlined = TryExecuteTaskInline(task, taskWasPreviouslyQueued);
             }
             finally
@@ -257,7 +259,10 @@ namespace System.Threading.Tasks
         {
             Contract.Requires(task != null);
 
-            task.FireTaskScheduledIfNeeded(this);
+            if (TplEtwProvider.Log.IsEnabled())
+            {
+                task.FireTaskScheduledIfNeeded(this);
+            }
 
             this.QueueTask(task);
         }
@@ -441,7 +446,7 @@ namespace System.Threading.Tasks
                 throw new InvalidOperationException(Environment.GetResourceString("TaskScheduler_ExecuteTask_WrongTaskScheduler"));
             }
 
-            return task.ExecuteEntry(true);
+            return task.ExecuteEntry();
         }
 
         ////////////////////////////////////////////////////////////
@@ -685,16 +690,7 @@ namespace System.Threading.Tasks
         }
 
         // preallocated SendOrPostCallback delegate
-        private static SendOrPostCallback s_postCallback = new SendOrPostCallback(PostCallback);
-
-        // this is where the actual task invocation occures
-        private static void PostCallback(object obj)
-        {
-            Task task = (Task) obj;
-
-            // calling ExecuteEntry with double execute check enabled because a user implemented SynchronizationContext could be buggy
-            task.ExecuteEntry(true);
-        }
+        private static readonly SendOrPostCallback s_postCallback = s => ((Task)s).ExecuteEntry(); // with double-execute check because SC could be buggy
     }
 
     /// <summary>
diff --git a/src/mscorlib/src/System/Threading/Tasks/ThreadPoolTaskScheduler.cs b/src/mscorlib/src/System/Threading/Tasks/ThreadPoolTaskScheduler.cs
index 5c6ca9bb76..a1852f8bfb 100644
--- a/src/mscorlib/src/System/Threading/Tasks/ThreadPoolTaskScheduler.cs
+++ b/src/mscorlib/src/System/Threading/Tasks/ThreadPoolTaskScheduler.cs
@@ -34,15 +34,7 @@ namespace System.Threading.Tasks
         }
 
         // static delegate for threads allocated to handle LongRunning tasks.
-        private static readonly ParameterizedThreadStart s_longRunningThreadWork = new ParameterizedThreadStart(LongRunningThreadWork);
-
-        private static void LongRunningThreadWork(object obj)
-        {
-            Contract.Requires(obj != null, "TaskScheduler.LongRunningThreadWork: obj is null");
-            Task t = obj as Task;
-            Debug.Assert(t != null, "TaskScheduler.LongRunningThreadWork: t is null");
-            t.ExecuteEntry(false);
-        }
+        private static readonly ParameterizedThreadStart s_longRunningThreadWork = s => ((Task)s).ExecuteEntryUnsafe();
 
         /// <summary>
         /// Schedules a task to the ThreadPool.
@@ -68,7 +60,7 @@ namespace System.Threading.Tasks
         /// <summary>
         /// This internal function will do this:
         ///   (1) If the task had previously been queued, attempt to pop it and return false if that fails.
-        ///   (2) Propagate the return value from Task.ExecuteEntry() back to the caller.
+        ///   (2) Return whether the task is executed
         /// 
         /// IMPORTANT NOTE: TryExecuteTaskInline will NOT throw task exceptions itself. Any wait code path using this function needs
         /// to account for exceptions that need to be propagated, and throw themselves accordingly.
@@ -79,19 +71,17 @@ namespace System.Threading.Tasks
             if (taskWasPreviouslyQueued && !ThreadPool.TryPopCustomWorkItem(task))
                 return false;
 
-            // Propagate the return value of Task.ExecuteEntry()
-            bool rval = false;
             try
             {
-                rval = task.ExecuteEntry(false); // handles switching Task.Current etc.
+                task.ExecuteEntryUnsafe(); // handles switching Task.Current etc.
             }
             finally
             {
                 //   Only call NWIP() if task was previously queued
-                if(taskWasPreviouslyQueued) NotifyWorkItemProgress();
+                if (taskWasPreviouslyQueued) NotifyWorkItemProgress();
             }
 
-            return rval;
+            return true;
         }
 
         protected internal override bool TryDequeue(Task task)
diff --git a/src/mscorlib/src/System/Threading/Tasks/future.cs b/src/mscorlib/src/System/Threading/Tasks/future.cs
index 0c3fec89b7..9fed97e629 100644
--- a/src/mscorlib/src/System/Threading/Tasks/future.cs
+++ b/src/mscorlib/src/System/Threading/Tasks/future.cs
@@ -16,7 +16,6 @@ using System.Runtime;
 using System.Runtime.CompilerServices;
 using System.Runtime.ExceptionServices;
 using System.Security;
-using System.Security.Permissions;
 using System.Threading;
 using System.Diagnostics;
 using System.Diagnostics.Contracts;
@@ -128,13 +127,10 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ArgumentException">
         /// The <paramref name="function"/> argument is null.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task(Func<TResult> function)
             : this(function, null, default(CancellationToken),
                 TaskCreationOptions.None, InternalTaskOptions.None, null)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            PossiblyCaptureContext(ref stackMark);
         }
 
 
@@ -152,13 +148,10 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task(Func<TResult> function, CancellationToken cancellationToken)
             : this(function, null, cancellationToken,
                 TaskCreationOptions.None, InternalTaskOptions.None, null)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            PossiblyCaptureContext(ref stackMark);
         }
 
         /// <summary>
@@ -179,12 +172,9 @@ namespace System.Threading.Tasks
         /// The <paramref name="creationOptions"/> argument specifies an invalid value for <see
         /// cref="T:System.Threading.Tasks.TaskCreationOptions"/>.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task(Func<TResult> function, TaskCreationOptions creationOptions)
             : this(function, Task.InternalCurrentIfAttached(creationOptions), default(CancellationToken), creationOptions, InternalTaskOptions.None, null)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            PossiblyCaptureContext(ref stackMark);
         }
 
         /// <summary>
@@ -209,12 +199,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task(Func<TResult> function, CancellationToken cancellationToken, TaskCreationOptions creationOptions)
             : this(function, Task.InternalCurrentIfAttached(creationOptions), cancellationToken, creationOptions, InternalTaskOptions.None, null)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            PossiblyCaptureContext(ref stackMark);
         }
 
         /// <summary>
@@ -228,13 +215,10 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ArgumentException">
         /// The <paramref name="function"/> argument is null.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task(Func<object, TResult> function, object state)
             : this(function, state, null, default(CancellationToken),
                 TaskCreationOptions.None, InternalTaskOptions.None, null)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            PossiblyCaptureContext(ref stackMark);
         }
 
         /// <summary>
@@ -252,13 +236,10 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task(Func<object, TResult> function, object state, CancellationToken cancellationToken)
             : this(function, state, null, cancellationToken,
                     TaskCreationOptions.None, InternalTaskOptions.None, null)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            PossiblyCaptureContext(ref stackMark);
         }
 
         /// <summary>
@@ -280,13 +261,10 @@ namespace System.Threading.Tasks
         /// The <paramref name="creationOptions"/> argument specifies an invalid value for <see
         /// cref="T:System.Threading.Tasks.TaskCreationOptions"/>.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task(Func<object, TResult> function, object state, TaskCreationOptions creationOptions)
             : this(function, state, Task.InternalCurrentIfAttached(creationOptions), default(CancellationToken),
                     creationOptions, InternalTaskOptions.None, null)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            PossiblyCaptureContext(ref stackMark);
         }
 
 
@@ -313,23 +291,10 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task(Func<object, TResult> function, object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions)
             : this(function, state, Task.InternalCurrentIfAttached(creationOptions), cancellationToken,
                     creationOptions, InternalTaskOptions.None, null)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            PossiblyCaptureContext(ref stackMark);
-        }
-
-        internal Task(
-            Func<TResult> valueSelector, Task parent, CancellationToken cancellationToken,
-            TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler,
-            ref StackCrawlMark stackMark) :
-            this(valueSelector, parent, cancellationToken,
-                    creationOptions, internalOptions, scheduler)
-        {
-            PossiblyCaptureContext(ref stackMark);
         }
 
         /// <summary>
@@ -341,24 +306,10 @@ namespace System.Threading.Tasks
         /// <param name="cancellationToken">The CancellationToken for the task.</param>
         /// <param name="creationOptions">Options to control the future's behavior.</param>
         /// <param name="internalOptions">Internal options to control the future's behavior.</param>
-        /// <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="creationOptions"/> argument specifies
-        /// a SelfReplicating <see cref="Task{TResult}"/>, which is illegal."/>.</exception>
         internal Task(Func<TResult> valueSelector, Task parent, CancellationToken cancellationToken,
             TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler) :
             base(valueSelector, null, parent, cancellationToken, creationOptions, internalOptions, scheduler)
         {
-            if ((internalOptions & InternalTaskOptions.SelfReplicating) != 0)
-            {
-                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.creationOptions, ExceptionResource.TaskT_ctor_SelfReplicating);
-            }
-        }
-
-        internal Task(
-            Func<object, TResult> valueSelector, object state, Task parent, CancellationToken cancellationToken,
-            TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler, ref StackCrawlMark stackMark) :
-            this(valueSelector, state, parent, cancellationToken, creationOptions, internalOptions, scheduler)
-        {
-            PossiblyCaptureContext(ref stackMark);
         }
 
         /// <summary>
@@ -371,22 +322,16 @@ namespace System.Threading.Tasks
         /// <param name="scheduler">The task scheduler which will be used to execute the future.</param>
         /// <param name="creationOptions">Options to control the future's behavior.</param>
         /// <param name="internalOptions">Internal options to control the future's behavior.</param>
-        /// <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="creationOptions"/> argument specifies
-        /// a SelfReplicating <see cref="Task{TResult}"/>, which is illegal."/>.</exception>
         internal Task(Delegate valueSelector, object state, Task parent, CancellationToken cancellationToken,
             TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler) :
             base(valueSelector, state, parent, cancellationToken, creationOptions, internalOptions, scheduler)
         {
-            if ((internalOptions & InternalTaskOptions.SelfReplicating) != 0)
-            {
-                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.creationOptions, ExceptionResource.TaskT_ctor_SelfReplicating);
-            }
         }
 
 
         // Internal method used by TaskFactory<TResult>.StartNew() methods
         internal static Task<TResult> StartNew(Task parent, Func<TResult> function, CancellationToken cancellationToken,
-            TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler, ref StackCrawlMark stackMark)
+            TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler)
         {
             if (function == null)
             {
@@ -396,13 +341,9 @@ namespace System.Threading.Tasks
             {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.scheduler);
             }
-            if ((internalOptions & InternalTaskOptions.SelfReplicating) != 0)
-            {
-                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.creationOptions, ExceptionResource.TaskT_ctor_SelfReplicating);
-            }
 
             // Create and schedule the future.
-            Task<TResult> f = new Task<TResult>(function, parent, cancellationToken, creationOptions, internalOptions | InternalTaskOptions.QueuedByRuntime, scheduler, ref stackMark);
+            Task<TResult> f = new Task<TResult>(function, parent, cancellationToken, creationOptions, internalOptions | InternalTaskOptions.QueuedByRuntime, scheduler);
 
             f.ScheduleAndStart(false);
             return f;
@@ -410,7 +351,7 @@ namespace System.Threading.Tasks
 
         // Internal method used by TaskFactory<TResult>.StartNew() methods
         internal static Task<TResult> StartNew(Task parent, Func<object, TResult> function, object state, CancellationToken cancellationToken,
-            TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler, ref StackCrawlMark stackMark)
+            TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler)
         {
             if (function == null)
             {
@@ -420,13 +361,9 @@ namespace System.Threading.Tasks
             {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.scheduler);
             }
-            if ((internalOptions & InternalTaskOptions.SelfReplicating) != 0)
-            {
-                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.creationOptions, ExceptionResource.TaskT_ctor_SelfReplicating);
-            }
 
             // Create and schedule the future.
-            Task<TResult> f = new Task<TResult>(function, state, parent, cancellationToken, creationOptions, internalOptions | InternalTaskOptions.QueuedByRuntime, scheduler, ref stackMark);
+            Task<TResult> f = new Task<TResult>(function, state, parent, cancellationToken, creationOptions, internalOptions | InternalTaskOptions.QueuedByRuntime, scheduler);
 
             f.ScheduleAndStart(false);
             return f;
@@ -455,7 +392,6 @@ namespace System.Threading.Tasks
         // internal helper function breaks out logic used by TaskCompletionSource
         internal bool TrySetResult(TResult result)
         {
-            if (IsCompleted) return false;
             Debug.Assert(m_action == null, "Task<T>.TrySetResult(): non-null m_action");
 
             // "Reserve" the completion for this task, while making sure that: (1) No prior reservation
@@ -476,12 +412,13 @@ namespace System.Threading.Tasks
                 // and which can be summarized more concisely with the following snippet from
                 // FinishStageTwo, omitting everything that doesn't pertain to TrySetResult.
                 Interlocked.Exchange(ref m_stateFlags, m_stateFlags | TASK_STATE_RAN_TO_COMPLETION);
-                
-                var cp = m_contingentProperties;
-                if (cp != null) cp.SetCompleted();
-
-                FinishStageThree();
-
+                ContingentProperties props = m_contingentProperties;
+                if (props != null)
+                {
+                    NotifyParentIfPotentiallyAttachedTask();
+                    props.SetCompleted();
+                }
+                FinishContinuations();
                 return true;
             }
 
@@ -726,11 +663,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ArgumentNullException">
         /// The <paramref name="continuationAction"/> argument is null.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWith(Action<Task<TResult>> continuationAction)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith(continuationAction, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith(continuationAction, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None);
         }
 
 
@@ -754,11 +689,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWith(Action<Task<TResult>> continuationAction, CancellationToken cancellationToken)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith(continuationAction, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith(continuationAction, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None);
         }
 
 
@@ -784,11 +717,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ArgumentNullException">
         /// The <paramref name="scheduler"/> argument is null.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWith(Action<Task<TResult>> continuationAction, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith(continuationAction, scheduler, default(CancellationToken), TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith(continuationAction, scheduler, default(CancellationToken), TaskContinuationOptions.None);
         }
 
         /// <summary>
@@ -819,11 +750,9 @@ namespace System.Threading.Tasks
         /// The <paramref name="continuationOptions"/> argument specifies an invalid value for <see
         /// cref="T:System.Threading.Tasks.TaskContinuationOptions">TaskContinuationOptions</see>.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWith(Action<Task<TResult>> continuationAction, TaskContinuationOptions continuationOptions)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith(continuationAction, TaskScheduler.Current, default(CancellationToken), continuationOptions, ref stackMark);
+            return ContinueWith(continuationAction, TaskScheduler.Current, default(CancellationToken), continuationOptions);
         }
 
         /// <summary>
@@ -864,17 +793,15 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWith(Action<Task<TResult>> continuationAction, CancellationToken cancellationToken,
                                  TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith(continuationAction, scheduler, cancellationToken, continuationOptions, ref stackMark);
+            return ContinueWith(continuationAction, scheduler, cancellationToken, continuationOptions);
         }
 
         // Same as the above overload, only with a stack mark.
         internal Task ContinueWith(Action<Task<TResult>> continuationAction, TaskScheduler scheduler, CancellationToken cancellationToken,
-                                   TaskContinuationOptions continuationOptions, ref StackCrawlMark stackMark)
+                                   TaskContinuationOptions continuationOptions)
         {
             if (continuationAction == null)
             {
@@ -895,8 +822,7 @@ namespace System.Threading.Tasks
 
             Task continuationTask = new ContinuationTaskFromResultTask<TResult>(
                 this, continuationAction, null,
-                creationOptions, internalOptions,
-                ref stackMark
+                creationOptions, internalOptions
             );
 
             // Register the continuation.  If synchronous execution is requested, this may
@@ -926,11 +852,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ArgumentNullException">
         /// The <paramref name="continuationAction"/> argument is null.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWith(Action<Task<TResult>, Object> continuationAction, Object state)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith(continuationAction, state, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith(continuationAction, state, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None);
         }
 
 
@@ -955,11 +879,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWith(Action<Task<TResult>, Object> continuationAction, Object state,CancellationToken cancellationToken)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith(continuationAction, state, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith(continuationAction, state, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None);
         }
 
 
@@ -986,11 +908,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ArgumentNullException">
         /// The <paramref name="scheduler"/> argument is null.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWith(Action<Task<TResult>, Object> continuationAction, Object state, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith(continuationAction, state, scheduler, default(CancellationToken), TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith(continuationAction, state, scheduler, default(CancellationToken), TaskContinuationOptions.None);
         }
 
         /// <summary>
@@ -1022,11 +942,9 @@ namespace System.Threading.Tasks
         /// The <paramref name="continuationOptions"/> argument specifies an invalid value for <see
         /// cref="T:System.Threading.Tasks.TaskContinuationOptions">TaskContinuationOptions</see>.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWith(Action<Task<TResult>, Object> continuationAction, Object state,TaskContinuationOptions continuationOptions)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith(continuationAction, state, TaskScheduler.Current, default(CancellationToken), continuationOptions, ref stackMark);
+            return ContinueWith(continuationAction, state, TaskScheduler.Current, default(CancellationToken), continuationOptions);
         }
 
         /// <summary>
@@ -1068,17 +986,15 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task ContinueWith(Action<Task<TResult>, Object> continuationAction, Object state, CancellationToken cancellationToken,
                                  TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith(continuationAction, state, scheduler, cancellationToken, continuationOptions, ref stackMark);
+            return ContinueWith(continuationAction, state, scheduler, cancellationToken, continuationOptions);
         }
 
         // Same as the above overload, only with a stack mark.
         internal Task ContinueWith(Action<Task<TResult>, Object> continuationAction, Object state, TaskScheduler scheduler, CancellationToken cancellationToken,
-                                   TaskContinuationOptions continuationOptions, ref StackCrawlMark stackMark)
+                                   TaskContinuationOptions continuationOptions)
         {
             if (continuationAction == null)
             {
@@ -1099,8 +1015,7 @@ namespace System.Threading.Tasks
 
             Task continuationTask = new ContinuationTaskFromResultTask<TResult>(
                 this, continuationAction, state, 
-                creationOptions, internalOptions,
-                ref stackMark
+                creationOptions, internalOptions
             );
 
             // Register the continuation.  If synchronous execution is requested, this may
@@ -1133,11 +1048,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ArgumentNullException">
         /// The <paramref name="continuationFunction"/> argument is null.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, TNewResult> continuationFunction)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith<TNewResult>(continuationFunction, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith<TNewResult>(continuationFunction, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None);
         }
 
 
@@ -1164,11 +1077,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, TNewResult> continuationFunction, CancellationToken cancellationToken)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith<TNewResult>(continuationFunction, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith<TNewResult>(continuationFunction, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None);
         }
 
         /// <summary>
@@ -1196,11 +1107,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ArgumentNullException">
         /// The <paramref name="scheduler"/> argument is null.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, TNewResult> continuationFunction, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith<TNewResult>(continuationFunction, scheduler, default(CancellationToken), TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith<TNewResult>(continuationFunction, scheduler, default(CancellationToken), TaskContinuationOptions.None);
         }
 
         /// <summary>
@@ -1240,11 +1149,9 @@ namespace System.Threading.Tasks
         /// The <paramref name="continuationOptions"/> argument specifies an invalid value for <see
         /// cref="T:System.Threading.Tasks.TaskContinuationOptions">TaskContinuationOptions</see>.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, TNewResult> continuationFunction, TaskContinuationOptions continuationOptions)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith<TNewResult>(continuationFunction, TaskScheduler.Current, default(CancellationToken), continuationOptions, ref stackMark);
+            return ContinueWith<TNewResult>(continuationFunction, TaskScheduler.Current, default(CancellationToken), continuationOptions);
         }
 
         /// <summary>
@@ -1295,17 +1202,15 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, TNewResult> continuationFunction, CancellationToken cancellationToken,
             TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith<TNewResult>(continuationFunction, scheduler, cancellationToken, continuationOptions, ref stackMark);
+            return ContinueWith<TNewResult>(continuationFunction, scheduler, cancellationToken, continuationOptions);
         }
 
         // Same as the above overload, just with a stack mark.
         internal Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, TNewResult> continuationFunction, TaskScheduler scheduler,
-            CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, ref StackCrawlMark stackMark)
+            CancellationToken cancellationToken, TaskContinuationOptions continuationOptions)
         {
             if (continuationFunction == null)
             {
@@ -1326,8 +1231,7 @@ namespace System.Threading.Tasks
 
             Task<TNewResult> continuationFuture = new ContinuationResultTaskFromResultTask<TResult,TNewResult>(
                 this, continuationFunction, null,
-                creationOptions, internalOptions,
-                ref stackMark
+                creationOptions, internalOptions
             );
 
             // Register the continuation.  If synchronous execution is requested, this may
@@ -1360,11 +1264,9 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ArgumentNullException">
         /// The <paramref name="continuationFunction"/> argument is null.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, Object, TNewResult> continuationFunction, Object state)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith<TNewResult>(continuationFunction, state, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith<TNewResult>(continuationFunction, state, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None);
         }
 
 
@@ -1392,12 +1294,10 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, Object, TNewResult> continuationFunction, Object state,
             CancellationToken cancellationToken)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith<TNewResult>(continuationFunction, state, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith<TNewResult>(continuationFunction, state, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None);
         }
 
         /// <summary>
@@ -1426,12 +1326,10 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ArgumentNullException">
         /// The <paramref name="scheduler"/> argument is null.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, Object, TNewResult> continuationFunction, Object state,
             TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith<TNewResult>(continuationFunction, state, scheduler, default(CancellationToken), TaskContinuationOptions.None, ref stackMark);
+            return ContinueWith<TNewResult>(continuationFunction, state, scheduler, default(CancellationToken), TaskContinuationOptions.None);
         }
 
         /// <summary>
@@ -1472,12 +1370,10 @@ namespace System.Threading.Tasks
         /// The <paramref name="continuationOptions"/> argument specifies an invalid value for <see
         /// cref="T:System.Threading.Tasks.TaskContinuationOptions">TaskContinuationOptions</see>.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, Object, TNewResult> continuationFunction, Object state,
             TaskContinuationOptions continuationOptions)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith<TNewResult>(continuationFunction, state, TaskScheduler.Current, default(CancellationToken), continuationOptions, ref stackMark);
+            return ContinueWith<TNewResult>(continuationFunction, state, TaskScheduler.Current, default(CancellationToken), continuationOptions);
         }
 
         /// <summary>
@@ -1529,17 +1425,15 @@ namespace System.Threading.Tasks
         /// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
         /// has already been disposed.
         /// </exception>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable            
         public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, Object, TNewResult> continuationFunction, Object state,
             CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return ContinueWith<TNewResult>(continuationFunction, state, scheduler, cancellationToken, continuationOptions, ref stackMark);
+            return ContinueWith<TNewResult>(continuationFunction, state, scheduler, cancellationToken, continuationOptions);
         }
 
         // Same as the above overload, just with a stack mark.
         internal Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, Object, TNewResult> continuationFunction, Object state,
-            TaskScheduler scheduler, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, ref StackCrawlMark stackMark)
+            TaskScheduler scheduler, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions)
         {
             if (continuationFunction == null)
             {
@@ -1560,8 +1454,7 @@ namespace System.Threading.Tasks
 
             Task<TNewResult> continuationFuture = new ContinuationResultTaskFromResultTask<TResult,TNewResult>(
                 this, continuationFunction, state,
-                creationOptions, internalOptions,
-                ref stackMark
+                creationOptions, internalOptions
             );
 
             // Register the continuation.  If synchronous execution is requested, this may
diff --git a/src/mscorlib/src/System/Threading/Thread.cs b/src/mscorlib/src/System/Threading/Thread.cs
index 339869dc85..6211a09328 100644
--- a/src/mscorlib/src/System/Threading/Thread.cs
+++ b/src/mscorlib/src/System/Threading/Thread.cs
@@ -19,8 +19,6 @@ namespace System.Threading {
     using System.Runtime;
     using System.Runtime.InteropServices;
     using System;
-    using System.Security.Permissions;
-    using System.Security.Principal;
     using System.Globalization;
     using System.Collections.Generic;
     using System.Runtime.Serialization;
@@ -103,11 +101,7 @@ namespace System.Threading {
         }
     }
 
-    // deliberately not [serializable]
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_Thread))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class Thread : RuntimeThread, _Thread
+    public sealed class Thread : RuntimeThread
     {
         /*=========================================================================
         ** Data accessed from managed code that needs to be defined in
@@ -145,18 +139,6 @@ namespace System.Threading {
         private bool m_ForbidExecutionContextMutation;
 #endif
 
-        /*=========================================================================
-        ** This manager is responsible for storing the global data that is
-        ** shared amongst all the thread local stores.
-        =========================================================================*/
-        static private LocalDataStoreMgr s_LocalDataStoreMgr;
-
-        /*=========================================================================
-        ** Thread-local data store
-        =========================================================================*/
-        [ThreadStatic]
-        static private LocalDataStoreHolder s_LocalDataStore;
-
         // Do not move! Order of above fields needs to be preserved for alignment
         // with native code
         // See code:#threadCultureInfo
@@ -195,7 +177,7 @@ namespace System.Threading {
             SetStartHelper((Delegate)start,0);  //0 will setup Thread with default stackSize
         }
 
-        public Thread(ThreadStart start, int maxStackSize) {
+        internal Thread(ThreadStart start, int maxStackSize) {
             if (start == null) {
                 throw new ArgumentNullException(nameof(start));
             }
@@ -212,7 +194,7 @@ namespace System.Threading {
             SetStartHelper((Delegate)start, 0);
         }
 
-        public Thread(ParameterizedThreadStart start, int maxStackSize) {
+        internal Thread(ParameterizedThreadStart start, int maxStackSize) {
             if (start == null) {
                 throw new ArgumentNullException(nameof(start));
             }
@@ -222,7 +204,6 @@ namespace System.Threading {
             SetStartHelper((Delegate)start, maxStackSize);
         }
 
-        [ComVisible(false)]
         public override int GetHashCode()
         {
             return m_ManagedThreadId;
@@ -230,7 +211,6 @@ namespace System.Threading {
 
         extern public new int ManagedThreadId
         {
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
             [MethodImplAttribute(MethodImplOptions.InternalCall)]
             get;
         }
@@ -257,14 +237,14 @@ namespace System.Threading {
         **
         ** Exceptions: ThreadStateException if the thread has already been started.
         =========================================================================*/
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public new void Start()
         {
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             Start(ref stackMark);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public new void Start(object parameter)
         {
             //In the case of a null delegate (second call to start on same thread)
@@ -296,14 +276,11 @@ namespace System.Threading {
                 // If we reach here with a null delegate, something is broken. But we'll let the StartInternal method take care of
                 // reporting an error. Just make sure we dont try to dereference a null delegate.
                 ThreadHelper t = (ThreadHelper)(m_Delegate.Target);
-                ExecutionContext ec = ExecutionContext.Capture(
-                    ref stackMark,
-                    ExecutionContext.CaptureOptions.IgnoreSyncCtx);
+                ExecutionContext ec = ExecutionContext.Capture();
                 t.SetExecutionContextHelper(ec);
             }
 
-            IPrincipal principal = null;
-            StartInternal(principal, ref stackMark);
+            StartInternal(ref stackMark);
         }
 
         internal ExecutionContext ExecutionContext
@@ -319,7 +296,7 @@ namespace System.Threading {
         }
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        private extern void StartInternal(IPrincipal principal, ref StackCrawlMark stackMark);
+        private extern void StartInternal(ref StackCrawlMark stackMark);
 
 
         // Helper method to get a logical thread ID for StringBuilder (for
@@ -329,43 +306,6 @@ namespace System.Threading {
         internal extern static IntPtr InternalGetCurrentThread();
 
         /*=========================================================================
-        ** Raises a ThreadAbortException in the thread, which usually
-        ** results in the thread's death. The ThreadAbortException is a special
-        ** exception that is not catchable. The finally clauses of all try
-        ** statements will be executed before the thread dies. This includes the
-        ** finally that a thread might be executing at the moment the Abort is raised.
-        ** The thread is not stopped immediately--you must Join on the
-        ** thread to guarantee it has stopped.
-        ** It is possible for a thread to do an unbounded amount of computation in
-        ** the finally's and thus indefinitely delay the threads death.
-        ** If Abort() is called on a thread that has not been started, the thread
-        ** will abort when Start() is called.
-        ** If Abort is called twice on the same thread, a DuplicateThreadAbort
-        ** exception is thrown.
-        =========================================================================*/
-#pragma warning disable 618
-        [SecurityPermissionAttribute(SecurityAction.Demand, ControlThread = true)]
-#pragma warning restore 618
-        public void Abort()
-        {
-            AbortInternal();
-        }
-
-        // Internal helper (since we can't place security demands on
-        // ecalls/fcalls).
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        private extern void AbortInternal();
-
-        public bool Join(TimeSpan timeout)
-        {
-            long tm = (long)timeout.TotalMilliseconds;
-            if (tm < -1 || tm > (long) Int32.MaxValue)
-                throw new ArgumentOutOfRangeException(nameof(timeout), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
-
-            return Join((int)tm);
-        }
-
-        /*=========================================================================
         ** Suspends the current thread for timeout milliseconds. If timeout == 0,
         ** forces the thread to give up the remainer of its timeslice.  If timeout
         ** == Timeout.Infinite, no timeout will occur.
@@ -398,10 +338,8 @@ namespace System.Threading {
            a explict busy loop because the hardware can be informed that it is busy waiting. */
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         private static extern void SpinWaitInternal(int iterations);
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static new void SpinWait(int iterations)
         {
             SpinWaitInternal(iterations);
@@ -409,17 +347,14 @@ namespace System.Threading {
 
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
         [SuppressUnmanagedCodeSecurity]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         private static extern bool YieldInternal();
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
-        public static new bool Yield()
+        internal static new bool Yield()
         {
             return YieldInternal();
         }
         
         public static new Thread CurrentThread {
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
             get {
                 Contract.Ensures(Contract.Result<Thread>() != null);
                 return GetCurrentThreadNative();
@@ -430,8 +365,7 @@ namespace System.Threading {
 
         private void SetStartHelper(Delegate start, int maxStackSize)
         {
-            // We only support default stacks in CoreCLR
-            Debug.Assert(maxStackSize == 0);
+            Debug.Assert(maxStackSize >= 0);
 
             ThreadHelper threadStartCallBack = new ThreadHelper(start);
             if(start is ThreadStart)
@@ -444,10 +378,6 @@ namespace System.Threading {
             }                
         }
 
-        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
-        [SuppressUnmanagedCodeSecurity]
-        private static extern ulong GetProcessDefaultStackSize();
-
         /*=========================================================================
         ** PRIVATE Sets the IThreadable interface for the thread. Assumes that
         ** start != null.
@@ -458,122 +388,21 @@ namespace System.Threading {
         /*=========================================================================
         ** Clean up the thread when it goes away.
         =========================================================================*/
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         ~Thread()
         {
             // Delegate to the unmanaged portion.
             InternalFinalize();
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         private extern void InternalFinalize();
 
 #if FEATURE_COMINTEROP_APARTMENT_SUPPORT
-        /*=========================================================================
-        ** An unstarted thread can be marked to indicate that it will host a
-        ** single-threaded or multi-threaded apartment.
-        **
-        ** Exceptions: ArgumentException if state is not a valid apartment state
-        **             (ApartmentSTA or ApartmentMTA).
-        =========================================================================*/
-        [Obsolete("The ApartmentState property has been deprecated.  Use GetApartmentState, SetApartmentState or TrySetApartmentState instead.", false)]
-        public ApartmentState ApartmentState
-        {
-            get
-            {
-                return (ApartmentState)GetApartmentStateNative();
-            }
-
-            set
-            {
-                SetApartmentStateNative((int)value, true);
-            }
-        }
-
-        public void SetApartmentState(ApartmentState state)
-        {
-            bool result = SetApartmentStateHelper(state, true);
-            if (!result)
-                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_ApartmentStateSwitchFailed"));
-        }
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         private extern void StartupSetApartmentStateInternal();
 #endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT
 
-        /*=========================================================================
-        ** Allocates an un-named data slot. The slot is allocated on ALL the
-        ** threads.
-        =========================================================================*/
-        public static LocalDataStoreSlot AllocateDataSlot()
-        {
-            return LocalDataStoreManager.AllocateDataSlot();
-        }
-
-        /*=========================================================================
-        ** Allocates a named data slot. The slot is allocated on ALL the
-        ** threads.  Named data slots are "public" and can be manipulated by
-        ** anyone.
-        =========================================================================*/
-        public static LocalDataStoreSlot AllocateNamedDataSlot(String name)
-        {
-            return LocalDataStoreManager.AllocateNamedDataSlot(name);
-        }
-
-        /*=========================================================================
-        ** Looks up a named data slot. If the name has not been used, a new slot is
-        ** allocated.  Named data slots are "public" and can be manipulated by
-        ** anyone.
-        =========================================================================*/
-        public static LocalDataStoreSlot GetNamedDataSlot(String name)
-        {
-            return LocalDataStoreManager.GetNamedDataSlot(name);
-        }
-
-        /*=========================================================================
-        ** Frees a named data slot. The slot is allocated on ALL the
-        ** threads.  Named data slots are "public" and can be manipulated by
-        ** anyone.
-        =========================================================================*/
-        public static void FreeNamedDataSlot(String name)
-        {
-            LocalDataStoreManager.FreeNamedDataSlot(name);
-        }
-
-        /*=========================================================================
-        ** Retrieves the value from the specified slot on the current thread, for that thread's current domain.
-        =========================================================================*/
-        public static Object GetData(LocalDataStoreSlot slot)
-        {
-            LocalDataStoreHolder dls = s_LocalDataStore;
-            if (dls == null)
-            {
-                // Make sure to validate the slot even if we take the quick path
-                LocalDataStoreManager.ValidateSlot(slot);
-                return null;
-            }
-
-            return dls.Store.GetData(slot);
-        }
-
-        /*=========================================================================
-        ** Sets the data in the specified slot on the currently running thread, for that thread's current domain.
-        =========================================================================*/
-        public static void SetData(LocalDataStoreSlot slot, Object data)
-        {
-            LocalDataStoreHolder dls = s_LocalDataStore;
-
-            // Create new DLS if one hasn't been created for this domain for this thread
-            if (dls == null) {
-                dls = LocalDataStoreManager.CreateLocalDataStore();
-                s_LocalDataStore = dls;
-            }
-
-            dls.Store.SetData(slot, data);
-        }
-
-
         // #threadCultureInfo
         //
         // Background:
@@ -762,7 +591,7 @@ namespace System.Threading {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         private static extern AppDomain GetFastDomainInternal();
 
-        public static AppDomain GetDomain()
+        internal static AppDomain GetDomain()
         {
             Contract.Ensures(Contract.Result<AppDomain>() != null);
 
@@ -779,7 +608,7 @@ namespace System.Threading {
         /*
          *  This returns a unique id to identify an appdomain.
          */
-        public static int GetDomainID()
+        internal static int GetDomainID()
         {
             return GetDomain().GetId();
         }
@@ -806,56 +635,9 @@ namespace System.Threading {
         [SuppressUnmanagedCodeSecurity]
         private static extern void InformThreadNameChange(ThreadHandle t, String name, int len);
 
-        internal Object AbortReason {
-            get {
-                object result = null;
-                try
-                {
-                    result = GetAbortReason();
-                }
-                catch (Exception e)
-                {
-                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_ExceptionStateCrossAppDomain"), e);
-                }
-                return result;
-            }
-            set { SetAbortReason(value); }
-        }
-
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         public static extern void MemoryBarrier();
 
-        private static LocalDataStoreMgr LocalDataStoreManager
-        {
-            get 
-            {
-                if (s_LocalDataStoreMgr == null)
-                {
-                    Interlocked.CompareExchange(ref s_LocalDataStoreMgr, new LocalDataStoreMgr(), null);    
-                }
-
-                return s_LocalDataStoreMgr;
-            }
-        }
-
-        // Helper function to set the AbortReason for a thread abort.
-        //  Checks that they're not alredy set, and then atomically updates
-        //  the reason info (object + ADID).
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        internal extern void SetAbortReason(Object o);
-    
-        // Helper function to retrieve the AbortReason from a thread
-        //  abort.  Will perform cross-AppDomain marshalling if the object
-        //  lives in a different AppDomain from the requester.
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        internal extern Object GetAbortReason();
-    
-        // Helper function to clear the AbortReason.  Takes care of
-        //  AppDomain related cleanup if required.
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        internal extern void ClearAbortReason();
-
-
     } // End of class Thread
 
     // declaring a local var of this enum type and passing it by ref into a function that needs to do a
diff --git a/src/mscorlib/src/System/Threading/ThreadAbortException.cs b/src/mscorlib/src/System/Threading/ThreadAbortException.cs
index 09ad4e1bd6..25925048bf 100644
--- a/src/mscorlib/src/System/Threading/ThreadAbortException.cs
+++ b/src/mscorlib/src/System/Threading/ThreadAbortException.cs
@@ -21,7 +21,6 @@ namespace System.Threading
     using System.Runtime.Serialization;
     using System.Runtime.CompilerServices;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public sealed class ThreadAbortException : SystemException 
     {
@@ -36,10 +35,5 @@ namespace System.Threading
             : base(info, context) 
         {
         }
-   
-        public Object ExceptionState 
-        {
-            get {return Thread.CurrentThread.AbortReason;}
-        }
     }
 }
diff --git a/src/mscorlib/src/System/Threading/ThreadInterruptedException.cs b/src/mscorlib/src/System/Threading/ThreadInterruptedException.cs
index 0056611955..71c09649e2 100644
--- a/src/mscorlib/src/System/Threading/ThreadInterruptedException.cs
+++ b/src/mscorlib/src/System/Threading/ThreadInterruptedException.cs
@@ -17,7 +17,6 @@ namespace System.Threading {
     using System;
     using System.Runtime.Serialization;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class ThreadInterruptedException : SystemException {
         public ThreadInterruptedException() 
diff --git a/src/mscorlib/src/System/Threading/ThreadLocal.cs b/src/mscorlib/src/System/Threading/ThreadLocal.cs
index 2b996cb34d..eedf6d0c81 100644
--- a/src/mscorlib/src/System/Threading/ThreadLocal.cs
+++ b/src/mscorlib/src/System/Threading/ThreadLocal.cs
@@ -16,7 +16,6 @@
 // =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 
 using System.Collections.Generic;
-using System.Security.Permissions;
 using System.Diagnostics;
 using System.Diagnostics.Contracts;
 
diff --git a/src/mscorlib/src/System/Threading/ThreadPool.cs b/src/mscorlib/src/System/Threading/ThreadPool.cs
index 451b15d22f..ccd528d620 100644
--- a/src/mscorlib/src/System/Threading/ThreadPool.cs
+++ b/src/mscorlib/src/System/Threading/ThreadPool.cs
@@ -11,36 +11,20 @@
 **
 =============================================================================*/
 
-#pragma warning disable 0420
-
-/*
- * Below you'll notice two sets of APIs that are separated by the
- * use of 'Unsafe' in their names.  The unsafe versions are called
- * that because they do not propagate the calling stack onto the
- * worker thread.  This allows code to lose the calling stack and 
- * thereby elevate its security privileges.  Note that this operation
- * is much akin to the combined ability to control security policy
- * and control security evidence.  With these privileges, a person 
- * can gain the right to load assemblies that are fully trusted which
- * then assert full trust and can call any code they want regardless
- * of the previous stack information.
- */
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.Contracts;
+using System.Diagnostics.Tracing;
+using System.Runtime.CompilerServices;
+using System.Runtime.ConstrainedExecution;
+using System.Runtime.InteropServices;
+using System.Security;
+using Microsoft.Win32;
 
 namespace System.Threading
 {
-    using System.Security;
-    using System.Security.Permissions;
-    using System;
-    using Microsoft.Win32;
-    using System.Runtime.CompilerServices;
-    using System.Runtime.ConstrainedExecution;
-    using System.Runtime.InteropServices;
-    using System.Collections.Generic;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-    using System.Diagnostics.CodeAnalysis;
-    using System.Diagnostics.Tracing;
-
     internal static class ThreadPoolGlobals
     {
         //Per-appDomain quantum (in ms) for which the thread keeps processing
@@ -55,78 +39,76 @@ namespace System.Threading
         public static bool enableWorkerTracking;
 
         public static readonly ThreadPoolWorkQueue workQueue = new ThreadPoolWorkQueue();
-
-        static ThreadPoolGlobals()
-        {
-        }
     }
 
     internal sealed class ThreadPoolWorkQueue
     {
-        // Simple sparsely populated array to allow lock-free reading.
-        internal class SparseArray<T> where T : class
+        internal static class WorkStealingQueueList
         {
-            private volatile T[] m_array;
+            private static volatile WorkStealingQueue[] _queues = new WorkStealingQueue[0];
 
-            internal SparseArray(int initialSize)
-            {
-                m_array = new T[initialSize];
-            }
+            public static WorkStealingQueue[] Queues => _queues;
 
-            internal T[] Current
-            {
-                get { return m_array; }
-            }
-
-            internal int Add(T e)
+            public static void Add(WorkStealingQueue queue)
             {
+                Debug.Assert(queue != null);
                 while (true)
                 {
-                    T[] array = m_array;
-                    lock (array)
+                    WorkStealingQueue[] oldQueues = _queues;
+                    Debug.Assert(Array.IndexOf(oldQueues, queue) == -1);
+
+                    var newQueues = new WorkStealingQueue[oldQueues.Length + 1];
+                    Array.Copy(oldQueues, 0, newQueues, 0, oldQueues.Length);
+                    newQueues[newQueues.Length - 1] = queue;
+                    if (Interlocked.CompareExchange(ref _queues, newQueues, oldQueues) == oldQueues)
                     {
-                        for (int i = 0; i < array.Length; i++)
-                        {
-                            if (array[i] == null)
-                            {
-                                Volatile.Write(ref array[i], e);
-                                return i;
-                            }
-                            else if (i == array.Length - 1)
-                            {
-                                // Must resize. If there was a race condition, we start over again.
-                                if (array != m_array)
-                                    continue;
-
-                                T[] newArray = new T[array.Length * 2];
-                                Array.Copy(array, newArray, i + 1);
-                                newArray[i + 1] = e;
-                                m_array = newArray;
-                                return i + 1;
-                            }
-                        }
+                        break;
                     }
                 }
             }
 
-            internal void Remove(T e)
+            public static void Remove(WorkStealingQueue queue)
             {
-                T[] array = m_array;
-                lock (array)
+                Debug.Assert(queue != null);
+                while (true)
                 {
-                    for (int i = 0; i < m_array.Length; i++)
+                    WorkStealingQueue[] oldQueues = _queues;
+                    if (oldQueues.Length == 0)
                     {
-                        if (m_array[i] == e)
-                        {
-                            Volatile.Write(ref m_array[i], null);
-                            break;
-                        }
+                        return;
+                    }
+
+                    int pos = Array.IndexOf(oldQueues, queue);
+                    if (pos == -1)
+                    {
+                        Debug.Fail("Should have found the queue");
+                        return;
+                    }
+
+                    var newQueues = new WorkStealingQueue[oldQueues.Length - 1];
+                    if (pos == 0)
+                    {
+                        Array.Copy(oldQueues, 1, newQueues, 0, newQueues.Length);
+                    }
+                    else if (pos == oldQueues.Length - 1)
+                    {
+                        Array.Copy(oldQueues, 0, newQueues, 0, newQueues.Length);
+                    }
+                    else
+                    {
+                        Array.Copy(oldQueues, 0, newQueues, 0, pos);
+                        Array.Copy(oldQueues, pos + 1, newQueues, pos, newQueues.Length - pos);
+                    }
+
+                    if (Interlocked.CompareExchange(ref _queues, newQueues, oldQueues) == oldQueues)
+                    {
+                        break;
                     }
                 }
             }
         }
 
-        internal class WorkStealingQueue
+        internal sealed class WorkStealingQueue
         {
             private const int INITIAL_SIZE = 32;
             internal volatile IThreadPoolWorkItem[] m_array = new IThreadPoolWorkItem[INITIAL_SIZE];
@@ -142,7 +124,7 @@ namespace System.Threading
             private volatile int m_headIndex = START_INDEX;
             private volatile int m_tailIndex = START_INDEX;
 
-            private SpinLock m_foreignLock = new SpinLock(false);
+            private SpinLock m_foreignLock = new SpinLock(enableThreadOwnerTracking:false);
 
             public void LocalPush(IThreadPoolWorkItem obj)
             {
@@ -176,7 +158,7 @@ namespace System.Threading
                     finally
                     {
                         if (lockTaken)
-                            m_foreignLock.Exit(true);
+                            m_foreignLock.Exit(useMemoryBarrier:true);
                     }
                 }
 
@@ -201,7 +183,7 @@ namespace System.Threading
                         if (count >= m_mask)
                         {
                             // We're full; expand the queue by doubling its size.
-                            IThreadPoolWorkItem[] newArray = new IThreadPoolWorkItem[m_array.Length << 1];
+                            var newArray = new IThreadPoolWorkItem[m_array.Length << 1];
                             for (int i = 0; i < m_array.Length; i++)
                                 newArray[i] = m_array[(i + head) & m_mask];
 
@@ -218,7 +200,7 @@ namespace System.Threading
                     finally
                     {
                         if (lockTaken)
-                            m_foreignLock.Exit(false);
+                            m_foreignLock.Exit(useMemoryBarrier:false);
                     }
                 }
             }
@@ -229,13 +211,9 @@ namespace System.Threading
                 // Fast path: check the tail. If equal, we can skip the lock.
                 if (m_array[(m_tailIndex - 1) & m_mask] == obj)
                 {
-                    IThreadPoolWorkItem unused;
-                    if (LocalPop(out unused))
-                    {
-                        Debug.Assert(unused == obj);
-                        return true;
-                    }
-                    return false;
+                    IThreadPoolWorkItem unused = LocalPop();
+                    Debug.Assert(unused == null || unused == obj);
+                    return unused != null;
                 }
 
                 // Else, do an O(N) search for the work item. The theory of work stealing and our
@@ -276,7 +254,7 @@ namespace System.Threading
                         finally
                         {
                             if (lockTaken)
-                                m_foreignLock.Exit(false);
+                                m_foreignLock.Exit(useMemoryBarrier:false);
                         }
                     }
                 }
@@ -284,19 +262,20 @@ namespace System.Threading
                 return false;
             }
 
+            public IThreadPoolWorkItem LocalPop() => m_headIndex < m_tailIndex ? LocalPopCore() : null;
+
             [SuppressMessage("Microsoft.Concurrency", "CA8001", Justification = "Reviewed for thread safety")]
-            public bool LocalPop(out IThreadPoolWorkItem obj)
+            private IThreadPoolWorkItem LocalPopCore()
             {
                 while (true)
                 {
-                    // Decrement the tail using a fence to ensure subsequent read doesn't come before.
                     int tail = m_tailIndex;
                     if (m_headIndex >= tail)
                     {
-                        obj = null;
-                        return false;
+                        return null;
                     }
 
+                    // Decrement the tail using a fence to ensure subsequent read doesn't come before.
                     tail -= 1;
                     Interlocked.Exchange(ref m_tailIndex, tail);
 
@@ -304,13 +283,13 @@ namespace System.Threading
                     if (m_headIndex <= tail)
                     {
                         int idx = tail & m_mask;
-                        obj = Volatile.Read(ref m_array[idx]);
+                        IThreadPoolWorkItem obj = Volatile.Read(ref m_array[idx]);
 
                         // Check for nulls in the array.
                         if (obj == null) continue;
 
                         m_array[idx] = null;
-                        return true;
+                        return obj;
                     }
                     else
                     {
@@ -324,241 +303,93 @@ namespace System.Threading
                             {
                                 // Element still available. Take it.
                                 int idx = tail & m_mask;
-                                obj = Volatile.Read(ref m_array[idx]);
+                                IThreadPoolWorkItem obj = Volatile.Read(ref m_array[idx]);
 
                                 // Check for nulls in the array.
                                 if (obj == null) continue;
 
                                 m_array[idx] = null;
-                                return true;
+                                return obj;
                             }
                             else
                             {
                                 // If we encountered a race condition and element was stolen, restore the tail.
                                 m_tailIndex = tail + 1;
-                                obj = null;
-                                return false;
+                                return null;
                             }
                         }
                         finally
                         {
                             if (lockTaken)
-                                m_foreignLock.Exit(false);
+                                m_foreignLock.Exit(useMemoryBarrier:false);
                         }
                     }
                 }
             }
 
-            public bool TrySteal(out IThreadPoolWorkItem obj, ref bool missedSteal)
-            {
-                return TrySteal(out obj, ref missedSteal, 0); // no blocking by default.
-            }
+            public bool CanSteal => m_headIndex < m_tailIndex;
 
-            private bool TrySteal(out IThreadPoolWorkItem obj, ref bool missedSteal, int millisecondsTimeout)
+            public IThreadPoolWorkItem TrySteal(ref bool missedSteal)
             {
-                obj = null;
-
                 while (true)
                 {
-                    if (m_headIndex >= m_tailIndex)
-                        return false;
-
-                    bool taken = false;
-                    try
+                    if (CanSteal)
                     {
-                        m_foreignLock.TryEnter(millisecondsTimeout, ref taken);
-                        if (taken)
+                        bool taken = false;
+                        try
                         {
-                            // Increment head, and ensure read of tail doesn't move before it (fence).
-                            int head = m_headIndex;
-                            Interlocked.Exchange(ref m_headIndex, head + 1);
-
-                            if (head < m_tailIndex)
+                            m_foreignLock.TryEnter(ref taken);
+                            if (taken)
                             {
-                                int idx = head & m_mask;
-                                obj = Volatile.Read(ref m_array[idx]);
+                                // Increment head, and ensure read of tail doesn't move before it (fence).
+                                int head = m_headIndex;
+                                Interlocked.Exchange(ref m_headIndex, head + 1);
 
-                                // Check for nulls in the array.
-                                if (obj == null) continue;
+                                if (head < m_tailIndex)
+                                {
+                                    int idx = head & m_mask;
+                                    IThreadPoolWorkItem obj = Volatile.Read(ref m_array[idx]);
 
-                                m_array[idx] = null;
-                                return true;
-                            }
-                            else
-                            {
-                                // Failed, restore head.
-                                m_headIndex = head;
-                                obj = null;
-                                missedSteal = true;
+                                    // Check for nulls in the array.
+                                    if (obj == null) continue;
+
+                                    m_array[idx] = null;
+                                    return obj;
+                                }
+                                else
+                                {
+                                    // Failed, restore head.
+                                    m_headIndex = head;
+                                }
                             }
                         }
-                        else
+                        finally
                         {
-                            missedSteal = true;
+                            if (taken)
+                                m_foreignLock.Exit(useMemoryBarrier:false);
                         }
-                    }
-                    finally
-                    {
-                        if (taken)
-                            m_foreignLock.Exit(false);
-                    }
-
-                    return false;
-                }
-            }
-        }
-
-        internal class QueueSegment
-        {
-            // Holds a segment of the queue.  Enqueues/Dequeues start at element 0, and work their way up.
-            internal readonly IThreadPoolWorkItem[] nodes;
-            private const int QueueSegmentLength = 256;
-
-            // Holds the indexes of the lowest and highest valid elements of the nodes array.
-            // The low index is in the lower 16 bits, high index is in the upper 16 bits.
-            // Use GetIndexes and CompareExchangeIndexes to manipulate this.
-            private volatile int indexes;
-
-            // The next segment in the queue.
-            public volatile QueueSegment Next;
-
-
-            const int SixteenBits = 0xffff;
-
-            void GetIndexes(out int upper, out int lower)
-            {
-                int i = indexes;
-                upper = (i >> 16) & SixteenBits;
-                lower = i & SixteenBits;
-
-                Debug.Assert(upper >= lower);
-                Debug.Assert(upper <= nodes.Length);
-                Debug.Assert(lower <= nodes.Length);
-                Debug.Assert(upper >= 0);
-                Debug.Assert(lower >= 0);
-            }
 
-            bool CompareExchangeIndexes(ref int prevUpper, int newUpper, ref int prevLower, int newLower)
-            {
-                Debug.Assert(newUpper >= newLower);
-                Debug.Assert(newUpper <= nodes.Length);
-                Debug.Assert(newLower <= nodes.Length);
-                Debug.Assert(newUpper >= 0);
-                Debug.Assert(newLower >= 0);
-                Debug.Assert(newUpper >= prevUpper);
-                Debug.Assert(newLower >= prevLower);
-                Debug.Assert(newUpper == prevUpper ^ newLower == prevLower);
-
-                int oldIndexes = (prevUpper << 16) | (prevLower & SixteenBits);
-                int newIndexes = (newUpper << 16) | (newLower & SixteenBits);
-                int prevIndexes = Interlocked.CompareExchange(ref indexes, newIndexes, oldIndexes);
-                prevUpper = (prevIndexes >> 16) & SixteenBits;
-                prevLower = prevIndexes & SixteenBits;
-                return prevIndexes == oldIndexes;
-            }
-
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
-            public QueueSegment()
-            {
-                Debug.Assert(QueueSegmentLength <= SixteenBits);
-                nodes = new IThreadPoolWorkItem[QueueSegmentLength];
-            }
-
-
-            public bool IsUsedUp()
-            {
-                int upper, lower;
-                GetIndexes(out upper, out lower);
-                return (upper == nodes.Length) && 
-                       (lower == nodes.Length);
-            }
-
-            public bool TryEnqueue(IThreadPoolWorkItem node)
-            {
-                //
-                // If there's room in this segment, atomically increment the upper count (to reserve
-                // space for this node), then store the node.
-                // Note that this leaves a window where it will look like there is data in that
-                // array slot, but it hasn't been written yet.  This is taken care of in TryDequeue
-                // with a busy-wait loop, waiting for the element to become non-null.  This implies
-                // that we can never store null nodes in this data structure.
-                //
-                Debug.Assert(null != node);
-
-                int upper, lower;
-                GetIndexes(out upper, out lower);
-
-                while (true)
-                {
-                    if (upper == nodes.Length)
-                        return false;
-
-                    if (CompareExchangeIndexes(ref upper, upper + 1, ref lower, lower))
-                    {
-                        Debug.Assert(Volatile.Read(ref nodes[upper]) == null);
-                        Volatile.Write(ref nodes[upper], node);
-                        return true;
+                        missedSteal = true;
                     }
-                }
-            }
-
-            [SuppressMessage("Microsoft.Concurrency", "CA8001", Justification = "Reviewed for thread safety")]
-            public bool TryDequeue(out IThreadPoolWorkItem node)
-            {
-                //
-                // If there are nodes in this segment, increment the lower count, then take the
-                // element we find there.
-                //
-                int upper, lower;
-                GetIndexes(out upper, out lower);
-
-                while(true)
-                {
-                    if (lower == upper)
-                    {
-                        node = null;
-                        return false;
-                    }
-
-                    if (CompareExchangeIndexes(ref upper, upper, ref lower, lower + 1))
-                    {
-                        // It's possible that a concurrent call to Enqueue hasn't yet
-                        // written the node reference to the array.  We need to spin until
-                        // it shows up.
-                        SpinWait spinner = new SpinWait();
-                        while ((node = Volatile.Read(ref nodes[lower])) == null)
-                            spinner.SpinOnce();
-
-                        // Null-out the reference so the object can be GC'd earlier.
-                        nodes[lower] = null;
 
-                        return true;
-                    }
+                    return null;
                 }
             }
         }
 
-        // The head and tail of the queue.  We enqueue to the head, and dequeue from the tail.
-        internal volatile QueueSegment queueHead;
-        internal volatile QueueSegment queueTail;
         internal bool loggingEnabled;
-
-        internal static readonly SparseArray<WorkStealingQueue> allThreadQueues = new SparseArray<WorkStealingQueue>(16);
+        internal readonly ConcurrentQueue<IThreadPoolWorkItem> workItems = new ConcurrentQueue<IThreadPoolWorkItem>();
 
         private volatile int numOutstandingThreadRequests = 0;
       
         public ThreadPoolWorkQueue()
         {
-            queueTail = queueHead = new QueueSegment();
             loggingEnabled = FrameworkEventSource.Log.IsEnabled(EventLevel.Verbose, FrameworkEventSource.Keywords.ThreadPool|FrameworkEventSource.Keywords.ThreadTransfer);
         }
 
-        public ThreadPoolWorkQueueThreadLocals EnsureCurrentThreadHasQueue()
-        {
-            if (null == ThreadPoolWorkQueueThreadLocals.threadLocals)
-                ThreadPoolWorkQueueThreadLocals.threadLocals = new ThreadPoolWorkQueueThreadLocals(this);
-            return ThreadPoolWorkQueueThreadLocals.threadLocals;
-        }
+        public ThreadPoolWorkQueueThreadLocals EnsureCurrentThreadHasQueue() =>
+            ThreadPoolWorkQueueThreadLocals.threadLocals ??
+            (ThreadPoolWorkQueueThreadLocals.threadLocals = new ThreadPoolWorkQueueThreadLocals(this));
 
         internal void EnsureThreadRequested()
         {
@@ -602,12 +433,12 @@ namespace System.Threading
 
         public void Enqueue(IThreadPoolWorkItem callback, bool forceGlobal)
         {
+            if (loggingEnabled)
+                System.Diagnostics.Tracing.FrameworkEventSource.Log.ThreadPoolEnqueueWorkObject(callback);
+
             ThreadPoolWorkQueueThreadLocals tl = null;
             if (!forceGlobal)
                 tl = ThreadPoolWorkQueueThreadLocals.threadLocals;
-
-            if (loggingEnabled)
-                System.Diagnostics.Tracing.FrameworkEventSource.Log.ThreadPoolEnqueueWorkObject(callback);
             
             if (null != tl)
             {
@@ -615,18 +446,7 @@ namespace System.Threading
             }
             else
             {
-                QueueSegment head = queueHead;
-
-                while (!head.TryEnqueue(callback))
-                {
-                    Interlocked.CompareExchange(ref head.Next, new QueueSegment(), null);
-
-                    while (head.Next != null)
-                    {
-                        Interlocked.CompareExchange(ref queueHead, head.Next, head);
-                        head = queueHead;
-                    }
-                }
+                workItems.Enqueue(callback);
             }
 
             EnsureThreadRequested();
@@ -635,67 +455,43 @@ namespace System.Threading
         internal bool LocalFindAndPop(IThreadPoolWorkItem callback)
         {
             ThreadPoolWorkQueueThreadLocals tl = ThreadPoolWorkQueueThreadLocals.threadLocals;
-            if (null == tl)
-                return false;
-
-            return tl.workStealingQueue.LocalFindAndPop(callback);
+            return tl != null && tl.workStealingQueue.LocalFindAndPop(callback);
         }
 
-        public void Dequeue(ThreadPoolWorkQueueThreadLocals tl, out IThreadPoolWorkItem callback, out bool missedSteal)
+        public IThreadPoolWorkItem Dequeue(ThreadPoolWorkQueueThreadLocals tl, ref bool missedSteal)
         {
-            callback = null;
-            missedSteal = false;
-            WorkStealingQueue wsq = tl.workStealingQueue;
-
-            if (wsq.LocalPop(out callback))
-                Debug.Assert(null != callback);
-
-            if (null == callback)
-            {
-                QueueSegment tail = queueTail;
-                while (true)
-                {
-                    if (tail.TryDequeue(out callback))
-                    {
-                        Debug.Assert(null != callback);
-                        break;
-                    }
-
-                    if (null == tail.Next || !tail.IsUsedUp())
-                    {
-                        break;
-                    }
-                    else
-                    {
-                        Interlocked.CompareExchange(ref queueTail, tail.Next, tail);
-                        tail = queueTail;
-                    }
-                }
-            }
+            WorkStealingQueue localWsq = tl.workStealingQueue;
+            IThreadPoolWorkItem callback;
 
-            if (null == callback)
+            if ((callback = localWsq.LocalPop()) == null && // first try the local queue
+                !workItems.TryDequeue(out callback)) // then try the global queue
             {
-                WorkStealingQueue[] otherQueues = allThreadQueues.Current;
-                int c = otherQueues.Length;
+                // finally try to steal from another thread's local queue
+                WorkStealingQueue[] queues = WorkStealingQueueList.Queues;
+                int c = queues.Length;
+                Debug.Assert(c > 0, "There must at least be a queue for this thread.");
                 int maxIndex = c - 1;
                 int i = tl.random.Next(c);
                 while (c > 0)
                 {
                     i = (i < maxIndex) ? i + 1 : 0;
-                    WorkStealingQueue otherQueue = Volatile.Read(ref otherQueues[i]);
-                    if (otherQueue != null &&
-                        otherQueue != wsq &&
-                        otherQueue.TrySteal(out callback, ref missedSteal))
+                    WorkStealingQueue otherQueue = queues[i];
+                    if (otherQueue != localWsq && otherQueue.CanSteal)
                     {
-                        Debug.Assert(null != callback);
-                        break;
+                        callback = otherQueue.TrySteal(ref missedSteal);
+                        if (callback != null)
+                        {
+                            break;
+                        }
                     }
                     c--;
                 }
             }
+
+            return callback;
         }
 
-        static internal bool Dispatch()
+        internal static bool Dispatch()
         {
             var workQueue = ThreadPoolGlobals.workQueue;
             //
@@ -735,85 +531,66 @@ namespace System.Threading
                 //
                 while ((Environment.TickCount - quantumStartTime) < ThreadPoolGlobals.TP_QUANTUM)
                 {
-                    //
-                    // Dequeue and EnsureThreadRequested must be protected from ThreadAbortException.  
-                    // These are fast, so this will not delay aborts/AD-unloads for very long.
-                    //
-                    try { }
-                    finally
-                    {
-                        bool missedSteal = false;
-                        workQueue.Dequeue(tl, out workItem, out missedSteal);
-
-                        if (workItem == null)
-                        {
-                            //
-                            // No work.  We're going to return to the VM once we leave this protected region.
-                            // If we missed a steal, though, there may be more work in the queue.
-                            // Instead of looping around and trying again, we'll just request another thread.  This way
-                            // we won't starve other AppDomains while we spin trying to get locks, and hopefully the thread
-                            // that owns the contended work-stealing queue will pick up its own workitems in the meantime, 
-                            // which will be more efficient than this thread doing it anyway.
-                            //
-                            needAnotherThread = missedSteal;
-                        }
-                        else
-                        {
-                            //
-                            // If we found work, there may be more work.  Ask for another thread so that the other work can be processed
-                            // in parallel.  Note that this will only ask for a max of #procs threads, so it's safe to call it for every dequeue.
-                            //
-                            workQueue.EnsureThreadRequested();
-                        }
-                    }
+                    bool missedSteal = false;
+                    workItem = workQueue.Dequeue(tl, ref missedSteal);
 
                     if (workItem == null)
                     {
+                        //
+                        // No work.  We're going to return to the VM once we leave this protected region.
+                        // If we missed a steal, though, there may be more work in the queue.
+                        // Instead of looping around and trying again, we'll just request another thread.  This way
+                        // we won't starve other AppDomains while we spin trying to get locks, and hopefully the thread
+                        // that owns the contended work-stealing queue will pick up its own workitems in the meantime, 
+                        // which will be more efficient than this thread doing it anyway.
+                        //
+                        needAnotherThread = missedSteal;
+
                         // Tell the VM we're returning normally, not because Hill Climbing asked us to return.
                         return true;
                     }
-                    else
-                    {
-                        if (workQueue.loggingEnabled)
-                            System.Diagnostics.Tracing.FrameworkEventSource.Log.ThreadPoolDequeueWorkObject(workItem);
 
-                        //
-                        // Execute the workitem outside of any finally blocks, so that it can be aborted if needed.
-                        //
-                        if (ThreadPoolGlobals.enableWorkerTracking)
+                    if (workQueue.loggingEnabled)
+                        System.Diagnostics.Tracing.FrameworkEventSource.Log.ThreadPoolDequeueWorkObject(workItem);
+
+                    //
+                    // If we found work, there may be more work.  Ask for another thread so that the other work can be processed
+                    // in parallel.  Note that this will only ask for a max of #procs threads, so it's safe to call it for every dequeue.
+                    //
+                    workQueue.EnsureThreadRequested();
+
+                    //
+                    // Execute the workitem outside of any finally blocks, so that it can be aborted if needed.
+                    //
+                    if (ThreadPoolGlobals.enableWorkerTracking)
+                    {
+                        bool reportedStatus = false;
+                        try
                         {
-                            bool reportedStatus = false;
-                            try
-                            {
-                                try { }
-                                finally
-                                {
-                                    ThreadPool.ReportThreadStatus(true);
-                                    reportedStatus = true;
-                                }
-                                workItem.ExecuteWorkItem();
-                                workItem = null;
-                            }
-                            finally
-                            {
-                                if (reportedStatus)
-                                    ThreadPool.ReportThreadStatus(false);
-                            }
+                            ThreadPool.ReportThreadStatus(isWorking: true);
+                            reportedStatus = true;
+                            workItem.ExecuteWorkItem();
                         }
-                        else
+                        finally
                         {
-                            workItem.ExecuteWorkItem();
-                            workItem = null;
+                            if (reportedStatus)
+                                ThreadPool.ReportThreadStatus(isWorking: false);
                         }
-
-                        // 
-                        // Notify the VM that we executed this workitem.  This is also our opportunity to ask whether Hill Climbing wants
-                        // us to return the thread to the pool or not.
-                        //
-                        if (!ThreadPool.NotifyWorkItemComplete())
-                            return false;
                     }
+                    else
+                    {
+                        workItem.ExecuteWorkItem();
+                    }
+                    workItem = null;
+
+                    // 
+                    // Notify the VM that we executed this workitem.  This is also our opportunity to ask whether Hill Climbing wants
+                    // us to return the thread to the pool or not.
+                    //
+                    if (!ThreadPool.NotifyWorkItemComplete())
+                        return false;
                 }
+
                 // If we get here, it's because our quantum expired.  Tell the VM we're returning normally.
                 return true;
             }
@@ -825,8 +602,7 @@ namespace System.Threading
                 // it was executed or not (in debug builds only).  Task uses this to communicate the ThreadAbortException to anyone
                 // who waits for the task to complete.
                 //
-                if (workItem != null)
-                    workItem.MarkAborted(tae);
+                workItem?.MarkAborted(tae);
                 
                 //
                 // In this case, the VM is going to request another thread on our behalf.  No need to do it twice.
@@ -845,11 +621,36 @@ namespace System.Threading
             }
 
             // we can never reach this point, but the C# compiler doesn't know that, because it doesn't know the ThreadAbortException will be reraised above.
-            Debug.Assert(false);
+            Debug.Fail("Should never reach this point");
             return true;
         }
     }
 
+    // Simple random number generator. We don't need great randomness, we just need a little and for it to be fast.
+    internal struct FastRandom // xorshift prng
+    {
+        private uint _w, _x, _y, _z;
+
+        public FastRandom(int seed)
+        {
+            _x = (uint)seed;
+            _w = 88675123;
+            _y = 362436069;
+            _z = 521288629;
+        }
+
+        public int Next(int maxValue)
+        {
+            Debug.Assert(maxValue > 0);
+
+            uint t = _x ^ (_x << 11);
+            _x = _y; _y = _z; _z = _w;
+            _w = _w ^ (_w >> 19) ^ (t ^ (t >> 8));
+
+            return (int)(_w % (uint)maxValue);
+        }
+    }
+
     // Holds a WorkStealingQueue, and remmoves it from the list when this object is no longer referened.
     internal sealed class ThreadPoolWorkQueueThreadLocals
     {
@@ -858,13 +659,13 @@ namespace System.Threading
 
         public readonly ThreadPoolWorkQueue workQueue;
         public readonly ThreadPoolWorkQueue.WorkStealingQueue workStealingQueue;
-        public readonly Random random = new Random(Thread.CurrentThread.ManagedThreadId);
+        public FastRandom random = new FastRandom(Thread.CurrentThread.ManagedThreadId); // mutable struct, do not copy or make readonly
 
         public ThreadPoolWorkQueueThreadLocals(ThreadPoolWorkQueue tpq)
         {
             workQueue = tpq;
             workStealingQueue = new ThreadPoolWorkQueue.WorkStealingQueue();
-            ThreadPoolWorkQueue.allThreadQueues.Add(workStealingQueue);
+            ThreadPoolWorkQueue.WorkStealingQueueList.Add(workStealingQueue);
         }
 
         private void CleanUp()
@@ -873,28 +674,15 @@ namespace System.Threading
             {
                 if (null != workQueue)
                 {
-                    bool done = false;
-                    while (!done)
+                    IThreadPoolWorkItem cb;
+                    while ((cb = workStealingQueue.LocalPop()) != null)
                     {
-                        // Ensure that we won't be aborted between LocalPop and Enqueue.
-                        try { }
-                        finally
-                        {
-                            IThreadPoolWorkItem cb = null;
-                            if (workStealingQueue.LocalPop(out cb))
-                            {
-                                Debug.Assert(null != cb);
-                                workQueue.Enqueue(cb, true);
-                            }
-                            else
-                            {
-                                done = true;
-                            }
-                        }
+                        Debug.Assert(null != cb);
+                        workQueue.Enqueue(cb, forceGlobal: true);
                     }
                 }
 
-                ThreadPoolWorkQueue.allThreadQueues.Remove(workStealingQueue);
+                ThreadPoolWorkQueue.WorkStealingQueueList.Remove(workStealingQueue);
             }
         }
 
@@ -912,34 +700,19 @@ namespace System.Threading
 
     internal sealed class RegisteredWaitHandleSafe : CriticalFinalizerObject
     {
-        private static IntPtr InvalidHandle
-        {
-            get
-            {
-                return Win32Native.INVALID_HANDLE_VALUE;
-            }
-        }
-        private IntPtr registeredWaitHandle;
+        private static IntPtr InvalidHandle => Win32Native.INVALID_HANDLE_VALUE;
+        private IntPtr registeredWaitHandle = InvalidHandle;
         private WaitHandle m_internalWaitObject;
         private bool bReleaseNeeded = false;
         private volatile int m_lock = 0;
 
-        internal RegisteredWaitHandleSafe()
-        {
-            registeredWaitHandle = InvalidHandle;
-        }
-
-        internal IntPtr GetHandle()
-        {
-           return registeredWaitHandle;
-        }
+        internal IntPtr GetHandle() => registeredWaitHandle;
     
         internal void SetHandle(IntPtr handle)
         {
             registeredWaitHandle = handle;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         internal void SetWaitObject(WaitHandle waitObject)
         {
             // needed for DangerousAddRef
@@ -957,7 +730,6 @@ namespace System.Threading
             }
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         internal bool Unregister(
              WaitHandle     waitObject          // object to be notified when all callbacks to delegates have completed
              )
@@ -1009,10 +781,8 @@ namespace System.Threading
             return result;
         }
 
-        private bool ValidHandle()
-        {
-            return (registeredWaitHandle != InvalidHandle && registeredWaitHandle != IntPtr.Zero);
-        }
+        private bool ValidHandle() =>
+            registeredWaitHandle != InvalidHandle && registeredWaitHandle != IntPtr.Zero;
 
         ~RegisteredWaitHandleSafe()
         {
@@ -1071,9 +841,8 @@ namespace System.Threading
         private static extern bool UnregisterWaitNative(IntPtr handle, SafeHandle waitObject);
     }
 
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class RegisteredWaitHandle : MarshalByRefObject {
-        private RegisteredWaitHandleSafe internalRegisteredWait;
+        private readonly RegisteredWaitHandleSafe internalRegisteredWait;
     
         internal RegisteredWaitHandle()
         {
@@ -1090,8 +859,6 @@ namespace System.Threading
            internalRegisteredWait.SetWaitObject(waitObject);
         }
 
-    
-[System.Runtime.InteropServices.ComVisible(true)]
         // This is the only public method on this class
         public bool Unregister(
              WaitHandle     waitObject          // object to be notified when all callbacks to delegates have completed
@@ -1101,10 +868,8 @@ namespace System.Threading
         }
     }
     
-    [System.Runtime.InteropServices.ComVisible(true)]
     public delegate void WaitCallback(Object state);
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public delegate void WaitOrTimerCallback(Object state, bool timedOut);  // signalled or timed out
 
     //
@@ -1115,10 +880,7 @@ namespace System.Threading
     //
     internal static class _ThreadPoolWaitCallback
     {
-        static internal bool PerformWaitCallback()
-        {
-            return ThreadPoolWorkQueue.Dispatch();
-        }
+        internal static bool PerformWaitCallback() => ThreadPoolWorkQueue.Dispatch();
     }
 
     //
@@ -1138,11 +900,9 @@ namespace System.Threading
 
     internal sealed class QueueUserWorkItemCallback : IThreadPoolWorkItem
     {
-        static QueueUserWorkItemCallback() {}
-
         private WaitCallback callback;
-        private ExecutionContext context;
-        private Object state;
+        private readonly ExecutionContext context;
+        private readonly Object state;
 
 #if DEBUG
         volatile int executed;
@@ -1173,7 +933,7 @@ namespace System.Threading
         void IThreadPoolWorkItem.ExecuteWorkItem()
         {
 #if DEBUG
-            MarkExecuted(false);
+            MarkExecuted(aborted:false);
 #endif
             // call directly if it is an unsafe call OR EC flow is suppressed
             if (context == null)
@@ -1184,7 +944,7 @@ namespace System.Threading
             }
             else
             {
-                ExecutionContext.Run(context, ccb, this, true);
+                ExecutionContext.Run(context, ccb, this);
             }
         }
 
@@ -1193,16 +953,16 @@ namespace System.Threading
 #if DEBUG
             // this workitem didn't execute because we got a ThreadAbortException prior to the call to ExecuteWorkItem.  
             // This counts as being executed for our purposes.
-            MarkExecuted(true);
+            MarkExecuted(aborted:true);
 #endif
         }
 
-        static internal ContextCallback ccb = new ContextCallback(WaitCallback_Context);
+        internal static readonly ContextCallback ccb = new ContextCallback(WaitCallback_Context);
 
-        static private void WaitCallback_Context(Object state)
+        private static void WaitCallback_Context(Object state)
         {
             QueueUserWorkItemCallback obj = (QueueUserWorkItemCallback)state;
-            WaitCallback wc = obj.callback as WaitCallback;
+            WaitCallback wc = obj.callback;
             Debug.Assert(null != wc);
             wc(obj.state);
         }
@@ -1210,10 +970,8 @@ namespace System.Threading
 
     internal sealed class QueueUserWorkItemCallbackDefaultContext : IThreadPoolWorkItem
     {
-        static QueueUserWorkItemCallbackDefaultContext() { }
-
         private WaitCallback callback;
-        private Object state;
+        private readonly Object state;
 
 #if DEBUG
         private volatile int executed;
@@ -1243,9 +1001,9 @@ namespace System.Threading
         void IThreadPoolWorkItem.ExecuteWorkItem()
         {
 #if DEBUG
-            MarkExecuted(false);
+            MarkExecuted(aborted:false);
 #endif
-            ExecutionContext.Run(ExecutionContext.PreAllocatedDefault, ccb, this, true);
+            ExecutionContext.Run(ExecutionContext.Default, ccb, this);
         }
 
         void IThreadPoolWorkItem.MarkAborted(ThreadAbortException tae)
@@ -1253,16 +1011,16 @@ namespace System.Threading
 #if DEBUG
             // this workitem didn't execute because we got a ThreadAbortException prior to the call to ExecuteWorkItem.  
             // This counts as being executed for our purposes.
-            MarkExecuted(true);
+            MarkExecuted(aborted:true);
 #endif
         }
 
-        static internal ContextCallback ccb = new ContextCallback(WaitCallback_Context);
+        internal static readonly ContextCallback ccb = new ContextCallback(WaitCallback_Context);
 
-        static private void WaitCallback_Context(Object state)
+        private static void WaitCallback_Context(Object state)
         {
             QueueUserWorkItemCallbackDefaultContext obj = (QueueUserWorkItemCallbackDefaultContext)state;
-            WaitCallback wc = obj.callback as WaitCallback;
+            WaitCallback wc = obj.callback;
             Debug.Assert(null != wc);
             obj.callback = null;
             wc(obj.state);
@@ -1271,46 +1029,38 @@ namespace System.Threading
 
     internal class _ThreadPoolWaitOrTimerCallback
     {
-        static _ThreadPoolWaitOrTimerCallback() {}
-
         WaitOrTimerCallback _waitOrTimerCallback;
         ExecutionContext _executionContext;
         Object _state;
-        static private ContextCallback _ccbt = new ContextCallback(WaitOrTimerCallback_Context_t);
-        static private ContextCallback _ccbf = new ContextCallback(WaitOrTimerCallback_Context_f);
+        private static readonly ContextCallback _ccbt = new ContextCallback(WaitOrTimerCallback_Context_t);
+        private static readonly ContextCallback _ccbf = new ContextCallback(WaitOrTimerCallback_Context_f);
 
-        internal _ThreadPoolWaitOrTimerCallback(WaitOrTimerCallback waitOrTimerCallback, Object state, bool compressStack, ref StackCrawlMark stackMark)
+        internal _ThreadPoolWaitOrTimerCallback(WaitOrTimerCallback waitOrTimerCallback, Object state, bool compressStack)
         {
             _waitOrTimerCallback = waitOrTimerCallback;
             _state = state;
 
-            if (compressStack && !ExecutionContext.IsFlowSuppressed())
+            if (compressStack)
             {
                 // capture the exection context
-                _executionContext = ExecutionContext.Capture(
-                    ref stackMark,
-                    ExecutionContext.CaptureOptions.IgnoreSyncCtx | ExecutionContext.CaptureOptions.OptimizeDefaultCase);
+                _executionContext = ExecutionContext.Capture();
             }
         }
         
-        static private void WaitOrTimerCallback_Context_t(Object state)
-        {
-            WaitOrTimerCallback_Context(state, true);
-        }
+        private static void WaitOrTimerCallback_Context_t(Object state) =>
+            WaitOrTimerCallback_Context(state, timedOut:true);
 
-        static private void WaitOrTimerCallback_Context_f(Object state)
-        {
-            WaitOrTimerCallback_Context(state, false);
-        }
+        private static void WaitOrTimerCallback_Context_f(Object state) =>
+            WaitOrTimerCallback_Context(state, timedOut:false);
 
-        static private void WaitOrTimerCallback_Context(Object state, bool timedOut)
+        private static void WaitOrTimerCallback_Context(Object state, bool timedOut)
         {
             _ThreadPoolWaitOrTimerCallback helper = (_ThreadPoolWaitOrTimerCallback)state;
             helper._waitOrTimerCallback(helper._state, timedOut);
         }
             
         // call back helper
-        static internal void PerformWaitOrTimerCallback(Object state, bool timedOut)
+        internal static void PerformWaitOrTimerCallback(Object state, bool timedOut)
         {
             _ThreadPoolWaitOrTimerCallback helper = (_ThreadPoolWaitOrTimerCallback)state; 
             Debug.Assert(helper != null, "Null state passed to PerformWaitOrTimerCallback!");
@@ -1322,20 +1072,13 @@ namespace System.Threading
             }
             else
             {
-                using (ExecutionContext executionContext = helper._executionContext.CreateCopy())
-                {
-                if (timedOut)
-                        ExecutionContext.Run(executionContext, _ccbt, helper, true);
-                else
-                        ExecutionContext.Run(executionContext, _ccbf, helper, true);
-                }
+                ExecutionContext.Run(helper._executionContext, timedOut ? _ccbt : _ccbf, helper);
             }
         }    
 
     }
 
     [CLSCompliant(false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     unsafe public delegate void IOCompletionCallback(uint errorCode, // Error code
                                        uint numBytes, // No. of bytes transferred 
                                        NativeOverlapped* pOVERLAP // ptr to OVERLAP structure
@@ -1343,7 +1086,6 @@ namespace System.Threading
 
     public static class ThreadPool
     {
-
         public static bool SetMaxThreads(int workerThreads, int completionPortThreads)
         {
             return SetMaxThreadsNative(workerThreads, completionPortThreads);
@@ -1370,7 +1112,7 @@ namespace System.Threading
         }
 
         [CLSCompliant(false)]
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable            
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod            
         public static RegisteredWaitHandle RegisterWaitForSingleObject(  // throws RegisterWaitException
              WaitHandle             waitObject,
              WaitOrTimerCallback    callBack,
@@ -1384,7 +1126,7 @@ namespace System.Threading
         }
 
         [CLSCompliant(false)]
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(  // throws RegisterWaitException
              WaitHandle             waitObject,
              WaitOrTimerCallback    callBack,
@@ -1412,7 +1154,7 @@ namespace System.Threading
 
             if (callBack != null)
             {
-                _ThreadPoolWaitOrTimerCallback callBackHelper = new _ThreadPoolWaitOrTimerCallback(callBack, state, compressStack, ref stackMark);
+                _ThreadPoolWaitOrTimerCallback callBackHelper = new _ThreadPoolWaitOrTimerCallback(callBack, state, compressStack);
                 state = (Object)callBackHelper;
                 // call SetWaitObject before native call so that waitObject won't be closed before threadpoolmgr registration
                 // this could occur if callback were to fire before SetWaitObject does its addref
@@ -1434,7 +1176,7 @@ namespace System.Threading
         }
 
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static RegisteredWaitHandle RegisterWaitForSingleObject(  // throws RegisterWaitException
              WaitHandle             waitObject,
              WaitOrTimerCallback    callBack,
@@ -1450,7 +1192,7 @@ namespace System.Threading
             return RegisterWaitForSingleObject(waitObject,callBack,state,(UInt32)millisecondsTimeOutInterval,executeOnlyOnce,ref stackMark,true);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable            
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod            
         public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(  // throws RegisterWaitException
              WaitHandle             waitObject,
              WaitOrTimerCallback    callBack,
@@ -1466,7 +1208,7 @@ namespace System.Threading
             return RegisterWaitForSingleObject(waitObject,callBack,state,(UInt32)millisecondsTimeOutInterval,executeOnlyOnce,ref stackMark,false);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static RegisteredWaitHandle RegisterWaitForSingleObject(  // throws RegisterWaitException
             WaitHandle          waitObject,
             WaitOrTimerCallback callBack,
@@ -1482,7 +1224,7 @@ namespace System.Threading
             return RegisterWaitForSingleObject(waitObject,callBack,state,(UInt32)millisecondsTimeOutInterval,executeOnlyOnce,ref stackMark,true);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(  // throws RegisterWaitException
             WaitHandle          waitObject,
             WaitOrTimerCallback callBack,
@@ -1498,7 +1240,7 @@ namespace System.Threading
             return RegisterWaitForSingleObject(waitObject,callBack,state,(UInt32)millisecondsTimeOutInterval,executeOnlyOnce,ref stackMark,false);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static RegisteredWaitHandle RegisterWaitForSingleObject(
                           WaitHandle            waitObject,
                           WaitOrTimerCallback   callBack,
@@ -1516,7 +1258,7 @@ namespace System.Threading
             return RegisterWaitForSingleObject(waitObject,callBack,state,(UInt32)tm,executeOnlyOnce,ref stackMark,true);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(
                           WaitHandle            waitObject,
                           WaitOrTimerCallback   callBack,
@@ -1533,141 +1275,84 @@ namespace System.Threading
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             return RegisterWaitForSingleObject(waitObject,callBack,state,(UInt32)tm,executeOnlyOnce,ref stackMark,false);
         }
-            
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable    
-        public static bool QueueUserWorkItem(           
-             WaitCallback           callBack,     // NOTE: we do not expose options that allow the callback to be queued as an APC
-             Object                 state
-             )
-        {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return QueueUserWorkItemHelper(callBack,state,ref stackMark,true);
-        }
-        
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        public static bool QueueUserWorkItem(           
-             WaitCallback           callBack     // NOTE: we do not expose options that allow the callback to be queued as an APC
-             )
-        {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return QueueUserWorkItemHelper(callBack,null,ref stackMark,true);
-        }
-    
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
-        public static bool UnsafeQueueUserWorkItem(
-             WaitCallback           callBack,     // NOTE: we do not expose options that allow the callback to be queued as an APC
-             Object                 state
-             )
-        {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return QueueUserWorkItemHelper(callBack,state,ref stackMark,false);
-        }
 
-        //ThreadPool has per-appdomain managed queue of work-items. The VM is
-        //responsible for just scheduling threads into appdomains. After that
-        //work-items are dispatched from the managed queue.
-        private static bool QueueUserWorkItemHelper(WaitCallback callBack, Object state, ref StackCrawlMark stackMark, bool compressStack )
-        {
-            bool success =  true;
+        public static bool QueueUserWorkItem(WaitCallback callBack) =>
+            QueueUserWorkItem(callBack, null);
 
-            if (callBack != null)
+        public static bool QueueUserWorkItem(WaitCallback callBack, object state)
+        {
+            if (callBack == null)
             {
-                        //The thread pool maintains a per-appdomain managed work queue.
-                //New thread pool entries are added in the managed queue.
-                //The VM is responsible for the actual growing/shrinking of 
-                //threads. 
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.callBack);
+            }
 
-                EnsureVMInitialized();
+            EnsureVMInitialized();
 
-                //
-                // If we are able to create the workitem, we need to get it in the queue without being interrupted
-                // by a ThreadAbortException.
-                //
-                try { }
-                finally
-                {
-                    ExecutionContext context = compressStack && !ExecutionContext.IsFlowSuppressed() ?
-                        ExecutionContext.Capture(ref stackMark, ExecutionContext.CaptureOptions.IgnoreSyncCtx | ExecutionContext.CaptureOptions.OptimizeDefaultCase) :
-                        null;
+            ExecutionContext context = ExecutionContext.Capture();
 
-                    IThreadPoolWorkItem tpcallBack = context == ExecutionContext.PreAllocatedDefault ?
-                                 new QueueUserWorkItemCallbackDefaultContext(callBack, state) :
-                                 (IThreadPoolWorkItem)new QueueUserWorkItemCallback(callBack, state, context);
+            IThreadPoolWorkItem tpcallBack = context == ExecutionContext.Default ?
+                new QueueUserWorkItemCallbackDefaultContext(callBack, state) :
+                (IThreadPoolWorkItem)new QueueUserWorkItemCallback(callBack, state, context);
 
-                    ThreadPoolGlobals.workQueue.Enqueue(tpcallBack, true);
-                    success = true;
-                }
-            }
-            else
+            ThreadPoolGlobals.workQueue.Enqueue(tpcallBack, forceGlobal: true);
+
+            return true;
+        }
+
+        public static bool UnsafeQueueUserWorkItem(WaitCallback callBack, Object state)
+        {
+            if (callBack == null)
             {
-                throw new ArgumentNullException(nameof(WaitCallback));
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.callBack);
             }
-            return success;
+
+            EnsureVMInitialized();
+
+            IThreadPoolWorkItem tpcallBack = new QueueUserWorkItemCallback(callBack, state, null);
+
+            ThreadPoolGlobals.workQueue.Enqueue(tpcallBack, forceGlobal: true);
+
+            return true;
         }
 
         internal static void UnsafeQueueCustomWorkItem(IThreadPoolWorkItem workItem, bool forceGlobal)
         {
             Debug.Assert(null != workItem);
             EnsureVMInitialized();
-
-            //
-            // Enqueue needs to be protected from ThreadAbort
-            //
-            try { }
-            finally
-            {
-                ThreadPoolGlobals.workQueue.Enqueue(workItem, forceGlobal);
-            }
+            ThreadPoolGlobals.workQueue.Enqueue(workItem, forceGlobal);
         }
 
         // This method tries to take the target callback out of the current thread's queue.
         internal static bool TryPopCustomWorkItem(IThreadPoolWorkItem workItem)
         {
             Debug.Assert(null != workItem);
-            if (!ThreadPoolGlobals.vmTpInitialized)
-                return false; //Not initialized, so there's no way this workitem was ever queued.
-            return ThreadPoolGlobals.workQueue.LocalFindAndPop(workItem);
+            return
+                ThreadPoolGlobals.vmTpInitialized && // if not initialized, so there's no way this workitem was ever queued.
+                ThreadPoolGlobals.workQueue.LocalFindAndPop(workItem);
         }
 
         // Get all workitems.  Called by TaskScheduler in its debugger hooks.
         internal static IEnumerable<IThreadPoolWorkItem> GetQueuedWorkItems()
         {
-            return EnumerateQueuedWorkItems(ThreadPoolWorkQueue.allThreadQueues.Current, ThreadPoolGlobals.workQueue.queueTail);
-        }
-
-        internal static IEnumerable<IThreadPoolWorkItem> EnumerateQueuedWorkItems(ThreadPoolWorkQueue.WorkStealingQueue[] wsQueues, ThreadPoolWorkQueue.QueueSegment globalQueueTail)
-        {
-            if (wsQueues != null)
+            // Enumerate global queue
+            foreach (IThreadPoolWorkItem workItem in ThreadPoolGlobals.workQueue.workItems)
             {
-                // First, enumerate all workitems in thread-local queues.
-                foreach (ThreadPoolWorkQueue.WorkStealingQueue wsq in wsQueues)
-                {
-                    if (wsq != null && wsq.m_array != null)
-                    {
-                        IThreadPoolWorkItem[] items = wsq.m_array;
-                        for (int i = 0; i < items.Length; i++)
-                        {
-                            IThreadPoolWorkItem item = items[i];
-                            if (item != null)
-                                yield return item;
-                        }
-                    }
-                }
+                yield return workItem;
             }
 
-            if (globalQueueTail != null)
+            // Enumerate each local queue
+            foreach (ThreadPoolWorkQueue.WorkStealingQueue wsq in ThreadPoolWorkQueue.WorkStealingQueueList.Queues)
             {
-                // Now the global queue
-                for (ThreadPoolWorkQueue.QueueSegment segment = globalQueueTail;
-                    segment != null;
-                    segment = segment.Next)
+                if (wsq != null && wsq.m_array != null)
                 {
-                    IThreadPoolWorkItem[] items = segment.nodes;
+                    IThreadPoolWorkItem[] items = wsq.m_array;
                     for (int i = 0; i < items.Length; i++)
                     {
                         IThreadPoolWorkItem item = items[i];
                         if (item != null)
+                        {
                             yield return item;
+                        }
                     }
                 }
             }
@@ -1675,13 +1360,20 @@ namespace System.Threading
 
         internal static IEnumerable<IThreadPoolWorkItem> GetLocallyQueuedWorkItems()
         {
-            return EnumerateQueuedWorkItems(new ThreadPoolWorkQueue.WorkStealingQueue[] { ThreadPoolWorkQueueThreadLocals.threadLocals.workStealingQueue }, null);
+            ThreadPoolWorkQueue.WorkStealingQueue wsq = ThreadPoolWorkQueueThreadLocals.threadLocals.workStealingQueue;
+            if (wsq != null && wsq.m_array != null)
+            {
+                IThreadPoolWorkItem[] items = wsq.m_array;
+                for (int i = 0; i < items.Length; i++)
+                {
+                    IThreadPoolWorkItem item = items[i];
+                    if (item != null)
+                        yield return item;
+                }
+            }
         }
 
-        internal static IEnumerable<IThreadPoolWorkItem> GetGloballyQueuedWorkItems()
-        {
-            return EnumerateQueuedWorkItems(null, ThreadPoolGlobals.workQueue.queueTail);
-        }
+        internal static IEnumerable<IThreadPoolWorkItem> GetGloballyQueuedWorkItems() => ThreadPoolGlobals.workQueue.workItems;
 
         private static object[] ToObjectArray(IEnumerable<IThreadPoolWorkItem> workitems)
         {
@@ -1705,20 +1397,14 @@ namespace System.Threading
 
         // This is the method the debugger will actually call, if it ends up calling
         // into ThreadPool directly.  Tests can use this to simulate a debugger, as well.
-        internal static object[] GetQueuedWorkItemsForDebugger()
-        {
-            return ToObjectArray(GetQueuedWorkItems());
-        }
+        internal static object[] GetQueuedWorkItemsForDebugger() =>
+            ToObjectArray(GetQueuedWorkItems());
 
-        internal static object[] GetGloballyQueuedWorkItemsForDebugger()
-        {
-            return ToObjectArray(GetGloballyQueuedWorkItems());
-        }
+        internal static object[] GetGloballyQueuedWorkItemsForDebugger() =>
+            ToObjectArray(GetGloballyQueuedWorkItems());
 
-        internal static object[] GetLocallyQueuedWorkItemsForDebugger()
-        {
-            return ToObjectArray(GetLocallyQueuedWorkItems());
-        }
+        internal static object[] GetLocallyQueuedWorkItemsForDebugger() =>
+            ToObjectArray(GetLocallyQueuedWorkItems());
 
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
         [SuppressUnmanagedCodeSecurity]
@@ -1728,19 +1414,26 @@ namespace System.Threading
         unsafe private static extern bool PostQueuedCompletionStatus(NativeOverlapped* overlapped);
 
         [CLSCompliant(false)]
-        unsafe public static bool UnsafeQueueNativeOverlapped(NativeOverlapped* overlapped)
-        {
-            return PostQueuedCompletionStatus(overlapped);
-        }
+        unsafe public static bool UnsafeQueueNativeOverlapped(NativeOverlapped* overlapped) =>
+            PostQueuedCompletionStatus(overlapped);
 
+        // The thread pool maintains a per-appdomain managed work queue.
+        // New thread pool entries are added in the managed queue.
+        // The VM is responsible for the actual growing/shrinking of 
+        // threads. 
         private static void EnsureVMInitialized()
         {
             if (!ThreadPoolGlobals.vmTpInitialized)
             {
-                ThreadPool.InitializeVMTp(ref ThreadPoolGlobals.enableWorkerTracking);
-                ThreadPoolGlobals.vmTpInitialized = true;
+                EnsureVMInitializedCore(); // separate out to help with inlining
             }
         }
+        
+        private static void EnsureVMInitializedCore()
+        {
+            ThreadPool.InitializeVMTp(ref ThreadPoolGlobals.enableWorkerTracking);
+            ThreadPoolGlobals.vmTpInitialized = true;
+        }
 
         // Native methods: 
     
@@ -1795,9 +1488,7 @@ namespace System.Threading
 
 
         [Obsolete("ThreadPool.BindHandle(IntPtr) has been deprecated.  Please use ThreadPool.BindHandle(SafeHandle) instead.", false)]
-        public static bool BindHandle(
-             IntPtr osHandle
-             )
+        public static bool BindHandle(IntPtr osHandle)
         {
             return BindIOCompletionCallbackNative(osHandle);
         }
@@ -1822,7 +1513,6 @@ namespace System.Threading
         }
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         private static extern bool BindIOCompletionCallbackNative(IntPtr fileHandle);
     }
 }
diff --git a/src/mscorlib/src/System/Threading/ThreadPriority.cs b/src/mscorlib/src/System/Threading/ThreadPriority.cs
index c56156eb89..6303c2fd94 100644
--- a/src/mscorlib/src/System/Threading/ThreadPriority.cs
+++ b/src/mscorlib/src/System/Threading/ThreadPriority.cs
@@ -16,7 +16,6 @@ namespace System.Threading {
     using System.Threading;
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum ThreadPriority
     {   
         /*=========================================================================
diff --git a/src/mscorlib/src/System/Threading/ThreadStart.cs b/src/mscorlib/src/System/Threading/ThreadStart.cs
index b968117195..e4beddcd75 100644
--- a/src/mscorlib/src/System/Threading/ThreadStart.cs
+++ b/src/mscorlib/src/System/Threading/ThreadStart.cs
@@ -14,12 +14,10 @@
 =============================================================================*/
 
 namespace System.Threading {
-    using System.Security.Permissions;
     using System.Threading;
 
     // Define the delegate
     // NOTE: If you change the signature here, there is code in COMSynchronization
     //  that invokes this delegate in native.
-[System.Runtime.InteropServices.ComVisible(true)]
     public delegate void ThreadStart();
 }
diff --git a/src/mscorlib/src/System/Threading/ThreadState.cs b/src/mscorlib/src/System/Threading/ThreadState.cs
index 007e1bf6e9..2d953f384a 100644
--- a/src/mscorlib/src/System/Threading/ThreadState.cs
+++ b/src/mscorlib/src/System/Threading/ThreadState.cs
@@ -16,7 +16,6 @@ namespace System.Threading {
 
 [Serializable]
 [Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum ThreadState
     {   
         /*=========================================================================
diff --git a/src/mscorlib/src/System/Threading/ThreadStateException.cs b/src/mscorlib/src/System/Threading/ThreadStateException.cs
index 535dffcdbf..97c03ce06c 100644
--- a/src/mscorlib/src/System/Threading/ThreadStateException.cs
+++ b/src/mscorlib/src/System/Threading/ThreadStateException.cs
@@ -16,7 +16,6 @@
 namespace System.Threading {
     using System;
     using System.Runtime.Serialization;
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class ThreadStateException : SystemException {
         public ThreadStateException() 
diff --git a/src/mscorlib/src/System/Threading/Timeout.cs b/src/mscorlib/src/System/Threading/Timeout.cs
index 99e24159b2..80bdbccf4e 100644
--- a/src/mscorlib/src/System/Threading/Timeout.cs
+++ b/src/mscorlib/src/System/Threading/Timeout.cs
@@ -8,10 +8,8 @@ namespace System.Threading {
     // A constant used by methods that take a timeout (Object.Wait, Thread.Sleep
     // etc) to indicate that no timeout should occur.
     //
-    [System.Runtime.InteropServices.ComVisible(true)]
     public static class Timeout
     {
-        [System.Runtime.InteropServices.ComVisible(false)]
         public static readonly TimeSpan InfiniteTimeSpan = new TimeSpan(0, 0, 0, 0, Timeout.Infinite);
 
         public const int Infinite = -1;
diff --git a/src/mscorlib/src/System/Threading/Timer.cs b/src/mscorlib/src/System/Threading/Timer.cs
index 5bfefccad2..93d2922799 100644
--- a/src/mscorlib/src/System/Threading/Timer.cs
+++ b/src/mscorlib/src/System/Threading/Timer.cs
@@ -8,7 +8,6 @@ namespace System.Threading
 {
     using System;
     using System.Security;
-    using System.Security.Permissions;
     using Microsoft.Win32;
     using System.Runtime.CompilerServices;
     using System.Runtime.InteropServices;
@@ -21,7 +20,6 @@ namespace System.Threading
 
 
         
-    [System.Runtime.InteropServices.ComVisible(true)]
     public delegate void TimerCallback(Object state);
 
     //
@@ -109,7 +107,6 @@ namespace System.Threading
             {
             }
 
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
             protected override bool ReleaseHandle()
             {
                 return DeleteAppDomainTimer(handle);
@@ -206,7 +203,6 @@ namespace System.Threading
 
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
         [SuppressUnmanagedCodeSecurity]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         static extern bool DeleteAppDomainTimer(IntPtr handle);
 
         #endregion
@@ -221,83 +217,6 @@ namespace System.Threading
 
         volatile int m_pauseTicks = 0; // Time when Pause was called
 
-        internal void Pause()
-        {
-            lock(this)
-            {
-                // Delete the native timer so that no timers are fired in the Pause zone
-                if(m_appDomainTimer != null && !m_appDomainTimer.IsInvalid)
-                {
-                    m_appDomainTimer.Dispose();
-                    m_appDomainTimer = null;
-                    m_isAppDomainTimerScheduled = false;
-                    m_pauseTicks = TickCount;
-                }
-            }
-        }
-
-        internal void Resume()
-        {
-            //
-            // Update timers to adjust their due-time to accomodate Pause/Resume
-            //
-            lock (this)
-            {
-                // prevent ThreadAbort while updating state
-                try { }
-                finally
-                {
-                    int pauseTicks = m_pauseTicks;
-                    m_pauseTicks = 0; // Set this to 0 so that now timers can be scheduled
-
-                    int resumedTicks = TickCount;
-                    int pauseDuration = resumedTicks - pauseTicks;
-
-                    bool haveTimerToSchedule = false;
-                    uint nextAppDomainTimerDuration = uint.MaxValue;      
-            
-                    TimerQueueTimer timer = m_timers;
-                    while (timer != null)
-                    {
-                        Debug.Assert(timer.m_dueTime != Timeout.UnsignedInfinite);
-                        Debug.Assert(resumedTicks >= timer.m_startTicks);
-
-                        uint elapsed; // How much of the timer dueTime has already elapsed
-
-                        // Timers started before the paused event has to be sufficiently delayed to accomodate 
-                        // for the Pause time. However, timers started after the Paused event shouldnt be adjusted. 
-                        // E.g. ones created by the app in its Activated event should fire when it was designated.
-                        // The Resumed event which is where this routine is executing is after this Activated and hence 
-                        // shouldn't delay this timer
-
-                        if(timer.m_startTicks <= pauseTicks)
-                            elapsed = (uint)(pauseTicks - timer.m_startTicks);
-                        else
-                            elapsed = (uint)(resumedTicks - timer.m_startTicks);
-
-                        // Handling the corner cases where a Timer was already due by the time Resume is happening,
-                        // We shouldn't delay those timers. 
-                        // Example is a timer started in App's Activated event with a very small duration
-                        timer.m_dueTime = (timer.m_dueTime > elapsed) ? timer.m_dueTime - elapsed : 0;;
-                        timer.m_startTicks = resumedTicks; // re-baseline
-
-                        if (timer.m_dueTime < nextAppDomainTimerDuration)
-                        {
-                            haveTimerToSchedule = true;
-                            nextAppDomainTimerDuration = timer.m_dueTime;
-                        }
-
-                        timer = timer.m_next;
-                    }
-                    
-                    if (haveTimerToSchedule)
-                    {
-                        EnsureAppDomainTimerFiresBy(nextAppDomainTimerDuration);
-                    }
-                }
-            }
-        }
-
 
         //
         // Fire any timers that have expired, and update the native timer to schedule the rest of them.
@@ -512,19 +431,13 @@ namespace System.Threading
         volatile WaitHandle m_notifyWhenNoCallbacksRunning;
 
 
-        internal TimerQueueTimer(TimerCallback timerCallback, object state, uint dueTime, uint period, ref StackCrawlMark stackMark)
+        internal TimerQueueTimer(TimerCallback timerCallback, object state, uint dueTime, uint period)
         {
             m_timerCallback = timerCallback;
             m_state = state;
             m_dueTime = Timeout.UnsignedInfinite;
             m_period = Timeout.UnsignedInfinite;
-
-            if (!ExecutionContext.IsFlowSuppressed())
-            {
-                m_executionContext = ExecutionContext.Capture(
-                    ref stackMark,
-                    ExecutionContext.CaptureOptions.IgnoreSyncCtx | ExecutionContext.CaptureOptions.OptimizeDefaultCase);
-            }
+            m_executionContext = ExecutionContext.Capture();
 
             //
             // After the following statement, the timer may fire.  No more manipulation of timer state outside of
@@ -678,29 +591,15 @@ namespace System.Threading
             }
             else
             {
-                using (ExecutionContext executionContext = 
-                    m_executionContext.IsPreAllocatedDefault ? m_executionContext : m_executionContext.CreateCopy())
-                {
-                    ContextCallback callback = s_callCallbackInContext;
-                    if (callback == null)
-                        s_callCallbackInContext = callback = new ContextCallback(CallCallbackInContext);
-                    
-                    ExecutionContext.Run(
-                        executionContext,
-                        callback,
-                        this,  // state
-                        true); // ignoreSyncCtx
-                }
+                ExecutionContext.Run(m_executionContext, s_callCallbackInContext, this);
             }
         }
 
-        private static ContextCallback s_callCallbackInContext;
-
-        private static void CallCallbackInContext(object state)
+        private static readonly ContextCallback s_callCallbackInContext = state =>
         {
             TimerQueueTimer t = (TimerQueueTimer)state;
             t.m_timerCallback(t.m_state);
-        }
+        };
     }
 
     //
@@ -756,14 +655,12 @@ namespace System.Threading
     }
 
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class Timer : MarshalByRefObject, IDisposable
     {
         private const UInt32 MAX_SUPPORTED_TIMEOUT = (uint)0xfffffffe;
 
         private TimerHolder m_timer;
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
         public Timer(TimerCallback callback, 
                      Object        state,  
                      int           dueTime,
@@ -774,12 +671,10 @@ namespace System.Threading
             if (period < -1 )
                 throw new ArgumentOutOfRangeException(nameof(period), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
             Contract.EndContractBlock();
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
 
-            TimerSetup(callback,state,(UInt32)dueTime,(UInt32)period,ref stackMark);
+            TimerSetup(callback,state,(UInt32)dueTime,(UInt32)period);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
         public Timer(TimerCallback callback, 
                      Object        state,  
                      TimeSpan      dueTime,
@@ -797,22 +692,18 @@ namespace System.Threading
             if (periodTm > MAX_SUPPORTED_TIMEOUT)
                 throw new ArgumentOutOfRangeException(nameof(periodTm),Environment.GetResourceString("ArgumentOutOfRange_PeriodTooLarge"));
 
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            TimerSetup(callback,state,(UInt32)dueTm,(UInt32)periodTm,ref stackMark);
+            TimerSetup(callback,state,(UInt32)dueTm,(UInt32)periodTm);
         }
 
         [CLSCompliant(false)]
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
         public Timer(TimerCallback callback, 
                      Object        state,  
                      UInt32        dueTime,
                      UInt32        period)
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            TimerSetup(callback,state,dueTime,period,ref stackMark);
+            TimerSetup(callback,state,dueTime,period);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable                                        
         public Timer(TimerCallback callback, 
                      Object        state,  
                      long          dueTime,
@@ -827,11 +718,9 @@ namespace System.Threading
             if (period > MAX_SUPPORTED_TIMEOUT)
                 throw new ArgumentOutOfRangeException(nameof(period),Environment.GetResourceString("ArgumentOutOfRange_PeriodTooLarge"));
             Contract.EndContractBlock();
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            TimerSetup(callback,state,(UInt32) dueTime, (UInt32) period,ref stackMark);
+            TimerSetup(callback,state,(UInt32) dueTime, (UInt32) period);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
         public Timer(TimerCallback callback)
         {
             int dueTime = -1;    // we want timer to be registered, but not activated.  Requires caller to call
@@ -839,31 +728,19 @@ namespace System.Threading
                                 // for a timer to be fired before the returned value is assigned to the variable,
                                 // potentially causing the callback to reference a bogus value (if passing the timer to the callback). 
             
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            TimerSetup(callback, this, (UInt32)dueTime, (UInt32)period, ref stackMark);
+            TimerSetup(callback, this, (UInt32)dueTime, (UInt32)period);
         }
 
         private void TimerSetup(TimerCallback callback,
                                 Object state, 
                                 UInt32 dueTime,
-                                UInt32 period,
-                                ref StackCrawlMark stackMark)
+                                UInt32 period)
         {
             if (callback == null)
                 throw new ArgumentNullException(nameof(TimerCallback));
             Contract.EndContractBlock();
 
-            m_timer = new TimerHolder(new TimerQueueTimer(callback, state, dueTime, period, ref stackMark));
-        }
-
-        internal static void Pause()
-        {
-            TimerQueue.Instance.Pause();
-        }
-
-        internal static void Resume()
-        {
-            TimerQueue.Instance.Resume();
+            m_timer = new TimerHolder(new TimerQueueTimer(callback, state, dueTime, period));
         }
      
         public bool Change(int dueTime, int period)
diff --git a/src/mscorlib/src/System/Threading/Volatile.cs b/src/mscorlib/src/System/Threading/Volatile.cs
index 3894b435fa..c94a69ab7b 100644
--- a/src/mscorlib/src/System/Threading/Volatile.cs
+++ b/src/mscorlib/src/System/Threading/Volatile.cs
@@ -26,7 +26,6 @@ namespace System.Threading
     //
     public static class Volatile
     {
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public static bool Read(ref bool location)
         {
@@ -38,7 +37,6 @@ namespace System.Threading
             return value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [CLSCompliant(false)]
         [System.Runtime.Versioning.NonVersionable]
         public static sbyte Read(ref sbyte location)
@@ -51,7 +49,6 @@ namespace System.Threading
             return value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public static byte Read(ref byte location)
         {
@@ -63,7 +60,6 @@ namespace System.Threading
             return value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public static short Read(ref short location)
         {
@@ -75,7 +71,6 @@ namespace System.Threading
             return value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [CLSCompliant(false)]
         [System.Runtime.Versioning.NonVersionable]
         public static ushort Read(ref ushort location)
@@ -88,7 +83,6 @@ namespace System.Threading
             return value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public static int Read(ref int location)
         {
@@ -100,7 +94,6 @@ namespace System.Threading
             return value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [CLSCompliant(false)]
         [System.Runtime.Versioning.NonVersionable]
         public static uint Read(ref uint location)
@@ -114,7 +107,6 @@ namespace System.Threading
         }
 
 #if BIT64
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public static long Read(ref long location)
         {
@@ -126,7 +118,6 @@ namespace System.Threading
             return value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [CLSCompliant(false)]
         [System.Runtime.Versioning.NonVersionable]
         public static ulong Read(ref ulong location)
@@ -139,7 +130,6 @@ namespace System.Threading
             return value;
         }
 #else
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static long Read(ref long location)
         {
             //
@@ -151,7 +141,6 @@ namespace System.Threading
             return Interlocked.CompareExchange(ref location, 0, 0);
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [CLSCompliant(false)]
         public static ulong Read(ref ulong location)
         {
@@ -169,7 +158,6 @@ namespace System.Threading
         }
 #endif
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public static IntPtr Read(ref IntPtr location)
         {
@@ -181,7 +169,6 @@ namespace System.Threading
             return value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [CLSCompliant(false)]
         [System.Runtime.Versioning.NonVersionable]
         public static UIntPtr Read(ref UIntPtr location)
@@ -194,7 +181,6 @@ namespace System.Threading
             return value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public static float Read(ref float location)
         {
@@ -206,7 +192,6 @@ namespace System.Threading
             return value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public static double Read(ref double location)
         {
@@ -219,7 +204,6 @@ namespace System.Threading
             return Interlocked.CompareExchange(ref location, 0, 0);
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public static T Read<T>(ref T location) where T : class
         {
@@ -234,7 +218,6 @@ namespace System.Threading
 
 
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public static void Write(ref bool location, bool value)
         {
@@ -245,7 +228,6 @@ namespace System.Threading
             location = value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [CLSCompliant(false)]
         [System.Runtime.Versioning.NonVersionable]
         public static void Write(ref sbyte location, sbyte value)
@@ -257,7 +239,6 @@ namespace System.Threading
             location = value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public static void Write(ref byte location, byte value)
         {
@@ -268,7 +249,6 @@ namespace System.Threading
             location = value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public static void Write(ref short location, short value)
         {
@@ -279,7 +259,6 @@ namespace System.Threading
             location = value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [CLSCompliant(false)]
         [System.Runtime.Versioning.NonVersionable]
         public static void Write(ref ushort location, ushort value)
@@ -291,7 +270,6 @@ namespace System.Threading
             location = value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public static void Write(ref int location, int value)
         {
@@ -302,7 +280,6 @@ namespace System.Threading
             location = value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [CLSCompliant(false)]
         [System.Runtime.Versioning.NonVersionable]
         public static void Write(ref uint location, uint value)
@@ -315,7 +292,6 @@ namespace System.Threading
         }
 
 #if BIT64
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public static void Write(ref long location, long value)
         {
@@ -326,7 +302,6 @@ namespace System.Threading
             location = value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [CLSCompliant(false)]
         [System.Runtime.Versioning.NonVersionable]
         public static void Write(ref ulong location, ulong value)
@@ -338,7 +313,6 @@ namespace System.Threading
             location = value;
         }
 #else
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static void Write(ref long location, long value)
         {
             //
@@ -350,7 +324,6 @@ namespace System.Threading
             Interlocked.Exchange(ref location, value);
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [CLSCompliant(false)]
         public static void Write(ref ulong location, ulong value)
         {
@@ -374,7 +347,6 @@ namespace System.Threading
         }
 #endif
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public static void Write(ref IntPtr location, IntPtr value)
         {
@@ -385,7 +357,6 @@ namespace System.Threading
             location = value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [CLSCompliant(false)]
         [System.Runtime.Versioning.NonVersionable]
         public static void Write(ref UIntPtr location, UIntPtr value)
@@ -397,7 +368,6 @@ namespace System.Threading
             location = value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public static void Write(ref float location, float value)
         {
@@ -408,7 +378,6 @@ namespace System.Threading
             location = value;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public static void Write(ref double location, double value)
         {
@@ -421,7 +390,6 @@ namespace System.Threading
             Interlocked.Exchange(ref location, value);
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         [System.Runtime.Versioning.NonVersionable]
         public static void Write<T>(ref T location, T value) where T : class
         {
diff --git a/src/mscorlib/src/System/Threading/WaitHandle.cs b/src/mscorlib/src/System/Threading/WaitHandle.cs
index 7638c8b35b..d4dcd710be 100644
--- a/src/mscorlib/src/System/Threading/WaitHandle.cs
+++ b/src/mscorlib/src/System/Threading/WaitHandle.cs
@@ -17,7 +17,6 @@ namespace System.Threading
     using System.Threading;
     using System.Runtime.Remoting;
     using System;
-    using System.Security.Permissions;
     using System.Runtime.CompilerServices;
     using System.Runtime.InteropServices;
     using Microsoft.Win32.SafeHandles;
@@ -27,7 +26,6 @@ namespace System.Threading
     using System.Diagnostics.CodeAnalysis;
     using Win32Native = Microsoft.Win32.Win32Native;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public abstract class WaitHandle : MarshalByRefObject, IDisposable {
         public const int WaitTimeout = 0x102;                    
 
@@ -102,7 +100,6 @@ namespace System.Threading
 
         public SafeWaitHandle SafeWaitHandle 
         {
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
             get
             {
                 if (safeWaitHandle == null)
@@ -112,7 +109,6 @@ namespace System.Threading
                 return safeWaitHandle;
             }
 
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
             set
             {
                  // Set safeWaitHandle and waitHandle in a CER so we won't take
@@ -245,7 +241,6 @@ namespace System.Threading
         ========================================================================*/
         
         [MethodImplAttribute(MethodImplOptions.InternalCall)] 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         private static extern int WaitMultiple(WaitHandle[] waitHandles, int millisecondsTimeout, bool exitContext, bool WaitAll);
 
         public static bool WaitAll(WaitHandle[] waitHandles, int millisecondsTimeout, bool exitContext)
@@ -350,7 +345,6 @@ namespace System.Threading
         ** (if in a synchronized context) is exited before the wait and reacquired 
         ========================================================================*/
         
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static int WaitAny(WaitHandle[] waitHandles, int millisecondsTimeout, bool exitContext)
         {
             if (waitHandles==null)
@@ -406,7 +400,6 @@ namespace System.Threading
                 return ret;
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static int WaitAny(
                                     WaitHandle[] waitHandles, 
                                     TimeSpan timeout,
@@ -419,7 +412,6 @@ namespace System.Threading
             }
             return WaitAny(waitHandles,(int)tm, exitContext);
         }
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static int WaitAny(WaitHandle[] waitHandles, TimeSpan timeout)
         {
             return WaitAny(waitHandles, timeout, true); 
@@ -429,13 +421,11 @@ namespace System.Threading
         /*========================================================================
         ** Shorthand for WaitAny with timeout = Timeout.Infinite and exitContext = true
         ========================================================================*/
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static int WaitAny(WaitHandle[] waitHandles)
         {
             return WaitAny(waitHandles, Timeout.Infinite, true);
         }
 
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static int WaitAny(WaitHandle[] waitHandles, int millisecondsTimeout)
         {
             return WaitAny(waitHandles, millisecondsTimeout, true); 
@@ -446,10 +436,11 @@ namespace System.Threading
         ==  SignalAndWait
         ==
         ==================================================*/
-
+#if !PLATFORM_UNIX
         [MethodImplAttribute(MethodImplOptions.InternalCall)] 
         private static extern int SignalAndWaitOne(SafeWaitHandle waitHandleToSignal,SafeWaitHandle waitHandleToWaitOn, int millisecondsTimeout,
                                             bool hasThreadAffinity,  bool exitContext);
+#endif // !PLATFORM_UNIX        
 
         public static bool SignalAndWait(
                                         WaitHandle toSignal,
diff --git a/src/mscorlib/src/System/ThrowHelper.cs b/src/mscorlib/src/System/ThrowHelper.cs
index f487bf6b45..99f074d599 100644
--- a/src/mscorlib/src/System/ThrowHelper.cs
+++ b/src/mscorlib/src/System/ThrowHelper.cs
@@ -39,7 +39,6 @@ namespace System {
     using Collections.Generic;
     using System.Runtime.CompilerServices;
     using System.Runtime.Serialization;
-    using System.Diagnostics;
     using System.Diagnostics.Contracts;
 
     [Pure]
@@ -125,8 +124,12 @@ namespace System {
             throw GetArgumentException(resource, argument);
         }
 
+        private static ArgumentNullException GetArgumentNullException(ExceptionArgument argument) {
+            return new ArgumentNullException(GetArgumentName(argument));
+        }
+
         internal static void ThrowArgumentNullException(ExceptionArgument argument) {
-            throw new ArgumentNullException(GetArgumentName(argument));
+            throw GetArgumentNullException(argument);
         }
 
         internal static void ThrowArgumentNullException(ExceptionResource resource) {
@@ -209,11 +212,27 @@ namespace System {
             throw GetInvalidOperationException(ExceptionResource.InvalidOperation_EnumOpCantHappen);
         }
 
+        internal static void ThrowArraySegmentCtorValidationFailedExceptions(Array array, int offset, int count) {
+            throw GetArraySegmentCtorValidationFailedException(array, offset, count);
+        }
+
+        private static Exception GetArraySegmentCtorValidationFailedException(Array array, int offset, int count) {
+            if (array == null)
+                return GetArgumentNullException(ExceptionArgument.array);
+            if (offset < 0)
+                return GetArgumentOutOfRangeException(ExceptionArgument.offset, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
+            if (count < 0)
+                return GetArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
+
+            Debug.Assert(array.Length - offset < count);
+            return GetArgumentException(ExceptionResource.Argument_InvalidOffLen);
+        }
+
         private static ArgumentException GetArgumentException(ExceptionResource resource) {
             return new ArgumentException(GetResourceString(resource));
         }
 
-        private static InvalidOperationException GetInvalidOperationException(ExceptionResource resource) {
+        internal static InvalidOperationException GetInvalidOperationException(ExceptionResource resource) {
             return new InvalidOperationException(GetResourceString(resource));
         }
 
@@ -225,7 +244,7 @@ namespace System {
             return new ArgumentException(Environment.GetResourceString("Arg_WrongType", value, targetType), nameof(value));
         }
 
-        private static ArgumentOutOfRangeException GetArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource) {
+        internal static ArgumentOutOfRangeException GetArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource) {
             return new ArgumentOutOfRangeException(GetArgumentName(argument), GetResourceString(resource));
         }
 
@@ -248,18 +267,8 @@ namespace System {
         }
 
         // This function will convert an ExceptionArgument enum value to the argument name string.
-        private static string GetArgumentName(ExceptionArgument argument) {
-            // This is indirected through a second NoInlining function it has a special meaning
-            // in System.Private.CoreLib of indicatating it takes a StackMark which cause 
-            // the caller to also be not inlined; so we can't mark it directly.
-            // So is the effect of marking this function as non-inlining in a regular situation.
-            return GetArgumentNameInner(argument);
-        }
-
-        // This function will convert an ExceptionArgument enum value to the argument name string.
-        // Second function in chain so as to not propergate the non-inlining to outside caller
         [MethodImpl(MethodImplOptions.NoInlining)]
-        private static string GetArgumentNameInner(ExceptionArgument argument) {
+        private static string GetArgumentName(ExceptionArgument argument) {
             Debug.Assert(Enum.IsDefined(typeof(ExceptionArgument), argument),
                 "The enum value is not defined, please check the ExceptionArgument Enum.");
 
@@ -267,18 +276,8 @@ namespace System {
         }
 
         // This function will convert an ExceptionResource enum value to the resource string.
-        private static string GetResourceString(ExceptionResource resource) {
-            // This is indirected through a second NoInlining function it has a special meaning
-            // in System.Private.CoreLib of indicatating it takes a StackMark which cause 
-            // the caller to also be not inlined; so we can't mark it directly.
-            // So is the effect of marking this function as non-inlining in a regular situation.
-            return GetResourceStringInner(resource);
-        }
-
-        // This function will convert an ExceptionResource enum value to the resource string.
-        // Second function in chain so as to not propergate the non-inlining to outside caller
         [MethodImpl(MethodImplOptions.NoInlining)]
-        private static string GetResourceStringInner(ExceptionResource resource) {
+        private static string GetResourceString(ExceptionResource resource) {
             Debug.Assert(Enum.IsDefined(typeof(ExceptionResource), resource),
                 "The enum value is not defined, please check the ExceptionResource Enum.");
 
@@ -361,7 +360,9 @@ namespace System {
         updateValueFactory,
         concurrencyLevel,
         text,
-
+        callBack,
+        type,
+        stateMachine,
     }
 
     //
@@ -451,7 +452,6 @@ namespace System {
         Task_ContinueWith_NotOnAnything,
         Task_ContinueWith_ESandLR,
         TaskT_TransitionToFinal_AlreadyCompleted,
-        TaskT_ctor_SelfReplicating,
         TaskCompletionSourceT_TrySetException_NullException,
         TaskCompletionSourceT_TrySetException_NoExceptions,
         InvalidOperation_WrongAsyncResultOrEndCalledMultiple,
@@ -466,7 +466,9 @@ namespace System {
         ConcurrentDictionary_ArrayNotLargeEnough,
         ConcurrentDictionary_ArrayIncorrectType,
         ConcurrentCollection_SyncRoot_NotSupported,
-
+        ArgumentOutOfRange_Enum,
+        InvalidOperation_HandleIsNotInitialized,
+        AsyncMethodBuilder_InstanceNotInitialized,
     }
 }
 
diff --git a/src/mscorlib/src/System/TimeSpan.cs b/src/mscorlib/src/System/TimeSpan.cs
index a594da20e7..7b71b48fed 100644
--- a/src/mscorlib/src/System/TimeSpan.cs
+++ b/src/mscorlib/src/System/TimeSpan.cs
@@ -28,7 +28,6 @@ namespace System {
     // details of this type should change, or new fields added, we need to remember to add
     // an appropriate custom ILMarshaler to keep WInRT interop scenarios enabled.
     //
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable] public struct TimeSpan : IComparable
         , IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
     {
diff --git a/src/mscorlib/src/System/TimeZone.cs b/src/mscorlib/src/System/TimeZone.cs
index c0a369fd3c..8ede49293e 100644
--- a/src/mscorlib/src/System/TimeZone.cs
+++ b/src/mscorlib/src/System/TimeZone.cs
@@ -26,7 +26,6 @@ namespace System {
     using System.Globalization;
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Obsolete("System.TimeZone has been deprecated.  Please investigate the use of System.TimeZoneInfo instead.")]
     public abstract class TimeZone {
         private static volatile TimeZone currentTimeZone = null;
diff --git a/src/mscorlib/src/System/TimeZoneInfo.Win32.cs b/src/mscorlib/src/System/TimeZoneInfo.Win32.cs
index 057ea91115..79ee535505 100644
--- a/src/mscorlib/src/System/TimeZoneInfo.Win32.cs
+++ b/src/mscorlib/src/System/TimeZoneInfo.Win32.cs
@@ -794,7 +794,7 @@ namespace System
             int resourceId;
 
             // get the path to Windows\System32
-            string system32 = Environment.UnsafeGetFolderPath(Environment.SpecialFolder.System);
+            string system32 = Environment.SystemDirectory;
 
             // trim the string "@tzres.dll" => "tzres.dll"
             string tzresDll = resources[0].TrimStart('@');
diff --git a/src/mscorlib/src/System/TimeZoneNotFoundException.cs b/src/mscorlib/src/System/TimeZoneNotFoundException.cs
index cabcc150f6..ee21c2524f 100644
--- a/src/mscorlib/src/System/TimeZoneNotFoundException.cs
+++ b/src/mscorlib/src/System/TimeZoneNotFoundException.cs
@@ -2,22 +2,27 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-namespace System {
-   using  System.Runtime.Serialization;
-   using  System.Runtime.CompilerServices;
+using System.Runtime.Serialization;
 
-   [Serializable]
-   [System.Security.Permissions.HostProtection(MayLeakOnAbort = true)]
-   public class TimeZoneNotFoundException : Exception {
-       public TimeZoneNotFoundException(String message)
-           : base(message) { }
+namespace System
+{
+    [Serializable]
+    public class TimeZoneNotFoundException : Exception
+    {
+        public TimeZoneNotFoundException()
+        {
+        }
 
-       public TimeZoneNotFoundException(String message, Exception innerException)
-           : base(message, innerException) { }
+        public TimeZoneNotFoundException(String message)
+            : base(message)
+        {
+        }
 
-       protected TimeZoneNotFoundException(SerializationInfo info, StreamingContext context)
-           : base(info, context) { }
+        public TimeZoneNotFoundException(String message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
 
-       public TimeZoneNotFoundException() { }
-   }
+        protected TimeZoneNotFoundException(SerializationInfo info, StreamingContext context) : base(info, context) { }
+    }
 }
diff --git a/src/mscorlib/src/System/TimeoutException.cs b/src/mscorlib/src/System/TimeoutException.cs
index 0b45f62fbd..32775a1c56 100644
--- a/src/mscorlib/src/System/TimeoutException.cs
+++ b/src/mscorlib/src/System/TimeoutException.cs
@@ -11,35 +11,31 @@
 **
 =============================================================================*/
 
-namespace System 
-{
-    using System.Runtime.Serialization;
+using System.Runtime.Serialization;
 
+namespace System
+{
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public class TimeoutException : SystemException {
-        
-        public TimeoutException() 
-            : base(Environment.GetResourceString("Arg_TimeoutException")) {
-            SetErrorCode(__HResults.COR_E_TIMEOUT);
+    public class TimeoutException : SystemException
+    {
+        public TimeoutException()
+            : base(SR.Arg_TimeoutException)
+        {
+            HResult = __HResults.COR_E_TIMEOUT;
         }
-    
-        public TimeoutException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_TIMEOUT);
+
+        public TimeoutException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_TIMEOUT;
         }
-        
+
         public TimeoutException(String message, Exception innerException)
-            : base(message, innerException) {
-            SetErrorCode(__HResults.COR_E_TIMEOUT);
-        }
-    
-        //
-        //This constructor is required for serialization.
-        //
-        protected TimeoutException(SerializationInfo info, StreamingContext context) 
-            : base(info, context) {
+            : base(message, innerException)
+        {
+            HResult = __HResults.COR_E_TIMEOUT;
         }
+
+        protected TimeoutException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
 }
-
diff --git a/src/mscorlib/src/System/TupleExtensions.cs b/src/mscorlib/src/System/TupleExtensions.cs
index 27a8760e5c..b63cb41213 100644
--- a/src/mscorlib/src/System/TupleExtensions.cs
+++ b/src/mscorlib/src/System/TupleExtensions.cs
@@ -3,7 +3,6 @@
 // See the LICENSE file in the project root for more information.
 
 using System.ComponentModel;
-
 using System.Runtime.CompilerServices;
 
 namespace System
diff --git a/src/mscorlib/src/System/Type.cs b/src/mscorlib/src/System/Type.cs
index 2d30c4c7f2..192760830b 100644
--- a/src/mscorlib/src/System/Type.cs
+++ b/src/mscorlib/src/System/Type.cs
@@ -19,7 +19,6 @@ namespace System
     using System.Runtime.InteropServices;
     using System.Runtime.CompilerServices;
     using System.Security;
-    using System.Security.Permissions;
     using System.Collections;
     using System.Collections.Generic;
     using System.Runtime.Versioning;
@@ -29,10 +28,7 @@ namespace System
     using DebuggerStepThroughAttribute = System.Diagnostics.DebuggerStepThroughAttribute;
 
     [Serializable]
-    [ClassInterface(ClassInterfaceType.None)]
-    [ComDefaultInterface(typeof(_Type))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public abstract class Type : MemberInfo, _Type, IReflect
+    public abstract class Type : MemberInfo, IReflect
     {
         //
         // System.Type is appdomain agile type. Appdomain agile types cannot have precise static constructors. Make
@@ -81,25 +77,25 @@ namespace System
         // case-sensitive by default).
         ////  
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Type GetType(String typeName, bool throwOnError, bool ignoreCase) {
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             return RuntimeType.GetType(typeName, throwOnError, ignoreCase, false, ref stackMark);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Type GetType(String typeName, bool throwOnError) {
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             return RuntimeType.GetType(typeName, throwOnError, false, false, ref stackMark);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Type GetType(String typeName) {
             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
             return RuntimeType.GetType(typeName, false, false, false, ref stackMark);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Type GetType(
             string typeName,
             Func<AssemblyName, Assembly> assemblyResolver,
@@ -109,7 +105,7 @@ namespace System
             return TypeNameParser.GetType(typeName, assemblyResolver, typeResolver, false, false, ref stackMark);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Type GetType(
             string typeName,
             Func<AssemblyName, Assembly> assemblyResolver,
@@ -120,7 +116,7 @@ namespace System
             return TypeNameParser.GetType(typeName, assemblyResolver, typeResolver, throwOnError, false, ref stackMark);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Type GetType(
             string typeName,
             Func<AssemblyName, Assembly> assemblyResolver,
@@ -132,11 +128,14 @@ namespace System
             return TypeNameParser.GetType(typeName, assemblyResolver, typeResolver, throwOnError, ignoreCase, ref stackMark);
         }
 
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
         public static Type ReflectionOnlyGetType(String typeName, bool throwIfNotFound, bool ignoreCase) 
         {
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
-            return RuntimeType.GetType(typeName, throwIfNotFound, ignoreCase, true /*reflectionOnly*/, ref stackMark);
+            if (typeName == null)
+                throw new ArgumentNullException(nameof(typeName));
+            if (typeName.Length == 0 && throwIfNotFound)
+                throw new TypeLoadException(Environment.GetResourceString("Arg_TypeLoadNullStr"));
+            throw new NotSupportedException(Environment.GetResourceString("NotSupported_ReflectionOnlyGetType"));
         }
 
         public virtual Type MakePointerType() { throw new NotSupportedException(); }
@@ -297,7 +296,6 @@ namespace System
 
 
         // Module Property associated with a class.
-        // _Type.Module
         public new abstract Module Module { get; }
 
         // Assembly Property associated with a class.
@@ -376,7 +374,6 @@ namespace System
         // This method will search for the specified constructor.  For constructors,
         //  unlike everything else, the default is to not look for static methods.  The
         //  reason is that we don't typically expose the class initializer.
-        [System.Runtime.InteropServices.ComVisible(true)]
         public ConstructorInfo GetConstructor(BindingFlags bindingAttr,
                                               Binder binder,
                                               CallingConventions callConvention, 
@@ -393,7 +390,6 @@ namespace System
             return GetConstructorImpl(bindingAttr, binder, callConvention, types, modifiers);
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public ConstructorInfo GetConstructor(BindingFlags bindingAttr, Binder binder, Type[] types, ParameterModifier[] modifiers)
         {
             if (types == null)
@@ -405,7 +401,6 @@ namespace System
             return GetConstructorImpl(bindingAttr, binder, CallingConventions.Any, types, modifiers);
         }
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public ConstructorInfo GetConstructor(Type[] types)
         {
             // The arguments are checked in the called version of GetConstructor.
@@ -422,15 +417,12 @@ namespace System
         // This routine will return an array of all constructors supported by the class.
         //  Unlike everything else, the default is to not look for static methods.  The
         //  reason is that we don't typically expose the class initializer.
-        [System.Runtime.InteropServices.ComVisible(true)]
         public ConstructorInfo[] GetConstructors() {
             return GetConstructors(BindingFlags.Public | BindingFlags.Instance);
         }
  
-        [System.Runtime.InteropServices.ComVisible(true)]
         abstract public ConstructorInfo[] GetConstructors(BindingFlags bindingAttr);
 
-        [System.Runtime.InteropServices.ComVisible(true)]
         public ConstructorInfo TypeInitializer {
             get {
                 return GetConstructorImpl(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic,
@@ -676,16 +668,6 @@ namespace System
             return GetPropertyImpl(name,Type.DefaultLookup,null,returnType,null,null);
         }
 
-        internal PropertyInfo GetProperty(String name, BindingFlags bindingAttr, Type returnType)
-        {
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-            if (returnType == null)
-                throw new ArgumentNullException(nameof(returnType));
-            Contract.EndContractBlock();
-            return GetPropertyImpl(name, bindingAttr, null, returnType, null, null);
-        }
-
         public PropertyInfo GetProperty(String name)
         {
             if (name == null)
@@ -1229,11 +1211,6 @@ namespace System
              [Pure]
              get {return IsMarshalByRefImpl();}
          }
-
-         internal bool HasProxyAttribute {
-             [Pure]
-            get {return HasProxyAttributeImpl();}
-        }
                        
         // Protected routine to determine if this class represents a value class
         // The default implementation of IsValueTypeImpl never returns true for non-runtime types.
@@ -1297,12 +1274,6 @@ namespace System
             return false;
         }
 
-        internal virtual bool HasProxyAttributeImpl()
-        {
-            // We will override this in RuntimeType
-            return false;
-        }
-
         [Pure]
         abstract public Type GetElementType();
 
@@ -1599,7 +1570,6 @@ namespace System
         // else returns false.  If this class and c are the same class false is
         // returned.
         // 
-        [System.Runtime.InteropServices.ComVisible(true)]
         [Pure]
         public virtual bool IsSubclassOf(Type c)
         {
@@ -1746,7 +1716,6 @@ namespace System
             return Equals(o as Type);
         }
 
-        // _Type.Equals(Type)
         [Pure]
         public virtual bool Equals(Type o)
         {
@@ -1777,14 +1746,12 @@ namespace System
         // This method will return an interface mapping for the interface
         //  requested.  It will throw an argument exception if the Type doesn't
         //  implemenet the interface.
-        [System.Runtime.InteropServices.ComVisible(true)]
         public virtual InterfaceMapping GetInterfaceMap(Type interfaceType)
         {
             throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride"));
         }
 
         // this method is required so Object.GetType is not made virtual by the compiler 
-        // _Type.GetType()
         public new Type GetType()
         {
             return base.GetType();
diff --git a/src/mscorlib/src/System/TypeAccessException.cs b/src/mscorlib/src/System/TypeAccessException.cs
index 5ddc9a7538..32afbdfeb8 100644
--- a/src/mscorlib/src/System/TypeAccessException.cs
+++ b/src/mscorlib/src/System/TypeAccessException.cs
@@ -2,9 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-
 using System.Runtime.Serialization;
-using System.Security;
 
 namespace System
 {
@@ -14,27 +12,23 @@ namespace System
     public class TypeAccessException : TypeLoadException
     {
         public TypeAccessException()
-            : base(Environment.GetResourceString("Arg_TypeAccessException"))
+            : base(SR.Arg_TypeAccessException)
         {
-            SetErrorCode(__HResults.COR_E_TYPEACCESS);
+            HResult = __HResults.COR_E_TYPEACCESS;
         }
 
-        public TypeAccessException(string message) 
+        public TypeAccessException(string message)
             : base(message)
         {
-            SetErrorCode(__HResults.COR_E_TYPEACCESS);
+            HResult = __HResults.COR_E_TYPEACCESS;
         }
-    
-        public TypeAccessException(string message, Exception inner) 
+
+        public TypeAccessException(string message, Exception inner)
             : base(message, inner)
         {
-            SetErrorCode(__HResults.COR_E_TYPEACCESS);
+            HResult = __HResults.COR_E_TYPEACCESS;
         }
-    
-        protected TypeAccessException(SerializationInfo info, StreamingContext context)
-            : base(info, context)
-        {
-            SetErrorCode(__HResults.COR_E_TYPEACCESS);
-        }    
+
+        protected TypeAccessException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
 }
diff --git a/src/mscorlib/src/System/TypeCode.cs b/src/mscorlib/src/System/TypeCode.cs
index bf71c2fd5b..293eb1f1aa 100644
--- a/src/mscorlib/src/System/TypeCode.cs
+++ b/src/mscorlib/src/System/TypeCode.cs
@@ -20,10 +20,12 @@
 // These types of values are instead represented as classes. When the type code
 // of an object is TypeCode.Object, a further instance-of check can be used to
 // determine if the object is one of these values.
-namespace System {
+
+namespace System
+{
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public enum TypeCode {
+    public enum TypeCode
+    {
         Empty = 0,          // Null reference
         Object = 1,         // Instance that isn't a value
         DBNull = 2,         // Database null value
@@ -44,5 +46,3 @@ namespace System {
         String = 18,        // Unicode character string
     }
 }
-
-
diff --git a/src/mscorlib/src/System/TypeInitializationException.cs b/src/mscorlib/src/System/TypeInitializationException.cs
index bcc1c3e968..9191028346 100644
--- a/src/mscorlib/src/System/TypeInitializationException.cs
+++ b/src/mscorlib/src/System/TypeInitializationException.cs
@@ -13,53 +13,67 @@
 **
 **
 =============================================================================*/
-using System;
-using System.Runtime.Serialization;
+
 using System.Globalization;
-using System.Security.Permissions;
+using System.Runtime.Serialization;
 
-namespace System {
+namespace System
+{
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class TypeInitializationException : SystemException {
+    public sealed class TypeInitializationException : SystemException
+    {
         private String _typeName;
 
         // This exception is not creatable without specifying the
         //    inner exception.
         private TypeInitializationException()
-            : base(Environment.GetResourceString("TypeInitialization_Default")) {
-            SetErrorCode(__HResults.COR_E_TYPEINITIALIZATION);
+            : base(SR.TypeInitialization_Default)
+        {
+            HResult = __HResults.COR_E_TYPEINITIALIZATION;
+        }
+
+
+        public TypeInitializationException(String fullTypeName, Exception innerException)
+            : this(fullTypeName, SR.Format(SR.TypeInitialization_Type, fullTypeName), innerException)
+        {
         }
 
         // This is called from within the runtime.  I believe this is necessary
         // for Interop only, though it's not particularly useful.
-        private TypeInitializationException(String message) : base(message) {
-            SetErrorCode(__HResults.COR_E_TYPEINITIALIZATION);
+        internal TypeInitializationException(String message) : base(message)
+        {
+            HResult = __HResults.COR_E_TYPEINITIALIZATION;
         }
-        
-        public TypeInitializationException(String fullTypeName, Exception innerException) : base(Environment.GetResourceString("TypeInitialization_Type", fullTypeName), innerException) {
+
+        internal TypeInitializationException(String fullTypeName, String message, Exception innerException)
+            : base(message, innerException)
+        {
             _typeName = fullTypeName;
-            SetErrorCode(__HResults.COR_E_TYPEINITIALIZATION);
+            HResult = __HResults.COR_E_TYPEINITIALIZATION;
         }
 
-        internal TypeInitializationException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        internal TypeInitializationException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
             _typeName = info.GetString("TypeName");
         }
 
+        public override void GetObjectData(SerializationInfo info, StreamingContext context)
+        {
+            base.GetObjectData(info, context);
+            info.AddValue("TypeName", TypeName, typeof(String));
+        }
+
         public String TypeName
         {
-            get {
-                if (_typeName == null) {
+            get
+            {
+                if (_typeName == null)
+                {
                     return String.Empty;
                 }
                 return _typeName;
             }
         }
-
-        public override void GetObjectData(SerializationInfo info, StreamingContext context) {
-            base.GetObjectData(info, context);
-            info.AddValue("TypeName",TypeName,typeof(String));
-        }
-
     }
 }
diff --git a/src/mscorlib/src/System/TypeLoadException.cs b/src/mscorlib/src/System/TypeLoadException.cs
index d73a97f9c5..7bc3a1bcce 100644
--- a/src/mscorlib/src/System/TypeLoadException.cs
+++ b/src/mscorlib/src/System/TypeLoadException.cs
@@ -20,11 +20,9 @@ namespace System {
     using System.Runtime.CompilerServices;
     using System.Runtime.Versioning;
     using System.Security;
-    using System.Security.Permissions;
     using System.Diagnostics.Contracts;
 
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class TypeLoadException : SystemException, ISerializable {
 
         public TypeLoadException() 
diff --git a/src/mscorlib/src/System/TypeUnloadedException.cs b/src/mscorlib/src/System/TypeUnloadedException.cs
index 511314d329..f05d673a74 100644
--- a/src/mscorlib/src/System/TypeUnloadedException.cs
+++ b/src/mscorlib/src/System/TypeUnloadedException.cs
@@ -15,7 +15,6 @@ namespace System {
     
     using System.Runtime.Serialization;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class TypeUnloadedException : SystemException {
         public TypeUnloadedException() 
diff --git a/src/mscorlib/src/System/TypedReference.cs b/src/mscorlib/src/System/TypedReference.cs
index b65652e590..5e8f3c4c04 100644
--- a/src/mscorlib/src/System/TypedReference.cs
+++ b/src/mscorlib/src/System/TypedReference.cs
@@ -11,12 +11,10 @@ namespace System {
     using System.Runtime.CompilerServices;
     using CultureInfo = System.Globalization.CultureInfo;
     using FieldInfo = System.Reflection.FieldInfo;
-    using System.Security.Permissions;
     using System.Runtime.Versioning;
     using System.Diagnostics.Contracts;
 
     [CLSCompliant(false)] 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [System.Runtime.Versioning.NonVersionable] // This only applies to field layout
     public struct TypedReference
     {
diff --git a/src/mscorlib/src/System/UInt16.cs b/src/mscorlib/src/System/UInt16.cs
index 399ef02d7d..5cd1a65b70 100644
--- a/src/mscorlib/src/System/UInt16.cs
+++ b/src/mscorlib/src/System/UInt16.cs
@@ -19,7 +19,6 @@ namespace System {
     // Wrapper for unsigned 16 bit integers.
 [Serializable]
 [CLSCompliant(false), System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)] 
-[System.Runtime.InteropServices.ComVisible(true)]
     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 f3d60092f7..fc3f10f96f 100644
--- a/src/mscorlib/src/System/UInt32.cs
+++ b/src/mscorlib/src/System/UInt32.cs
@@ -21,7 +21,6 @@ namespace System {
     // * Wrapper for unsigned 32 bit integers.
     [Serializable]
     [CLSCompliant(false), System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)] 
-    [System.Runtime.InteropServices.ComVisible(true)]
     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 b55cd7ce6a..3b64f056e9 100644
--- a/src/mscorlib/src/System/UInt64.cs
+++ b/src/mscorlib/src/System/UInt64.cs
@@ -19,7 +19,6 @@ namespace System {
     // Wrapper for unsigned 64 bit integers.
 [Serializable]
 [CLSCompliant(false), System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
-[System.Runtime.InteropServices.ComVisible(true)]
     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 eab424fc69..d0f988dbb8 100644
--- a/src/mscorlib/src/System/UIntPtr.cs
+++ b/src/mscorlib/src/System/UIntPtr.cs
@@ -21,7 +21,6 @@ namespace System {
 
     [Serializable]
     [CLSCompliant(false)] 
-    [System.Runtime.InteropServices.ComVisible(true)]
     public struct UIntPtr : IEquatable<UIntPtr>, ISerializable
     {
         unsafe private void* m_value;
diff --git a/src/mscorlib/src/System/UnauthorizedAccessException.cs b/src/mscorlib/src/System/UnauthorizedAccessException.cs
index 07e95d547c..997358826f 100644
--- a/src/mscorlib/src/System/UnauthorizedAccessException.cs
+++ b/src/mscorlib/src/System/UnauthorizedAccessException.cs
@@ -13,31 +13,33 @@
 ** 
 ===========================================================*/
 
-using System;
 using System.Runtime.Serialization;
 
-namespace System {
+namespace System
+{
     // The UnauthorizedAccessException is thrown when access errors 
     // occur from IO or other OS methods.  
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public class UnauthorizedAccessException : SystemException {
-        public UnauthorizedAccessException() 
-            : base(Environment.GetResourceString("Arg_UnauthorizedAccessException")) {
-            SetErrorCode(__HResults.COR_E_UNAUTHORIZEDACCESS);
+    public class UnauthorizedAccessException : SystemException
+    {
+        public UnauthorizedAccessException()
+            : base(SR.Arg_UnauthorizedAccessException)
+        {
+            HResult = __HResults.COR_E_UNAUTHORIZEDACCESS;
         }
-        
-        public UnauthorizedAccessException(String message) 
-            : base(message) {
-            SetErrorCode(__HResults.COR_E_UNAUTHORIZEDACCESS);
-        }
-        
-        public UnauthorizedAccessException(String message, Exception inner) 
-            : base(message, inner) {
-            SetErrorCode(__HResults.COR_E_UNAUTHORIZEDACCESS);
+
+        public UnauthorizedAccessException(String message)
+            : base(message)
+        {
+            HResult = __HResults.COR_E_UNAUTHORIZEDACCESS;
         }
 
-        protected UnauthorizedAccessException(SerializationInfo info, StreamingContext context) : base(info, context) {
+        public UnauthorizedAccessException(String message, Exception inner)
+            : base(message, inner)
+        {
+            HResult = __HResults.COR_E_UNAUTHORIZEDACCESS;
         }
+
+        protected UnauthorizedAccessException(SerializationInfo info, StreamingContext context) : base(info, context) { }
     }
 }
diff --git a/src/mscorlib/src/System/UnhandledExceptionEventArgs.cs b/src/mscorlib/src/System/UnhandledExceptionEventArgs.cs
index e155ffc68e..d33830181c 100644
--- a/src/mscorlib/src/System/UnhandledExceptionEventArgs.cs
+++ b/src/mscorlib/src/System/UnhandledExceptionEventArgs.cs
@@ -2,28 +2,28 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-namespace System {
-    
-    using System;
-    using System.Runtime.ConstrainedExecution;
-    
+namespace System
+{
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
-    public class UnhandledExceptionEventArgs : EventArgs {
-        private Object _Exception;
-        private bool _IsTerminating;
+    public class UnhandledExceptionEventArgs : EventArgs
+    {
+        private Object _exception;
+        private bool _isTerminating;
 
-        public UnhandledExceptionEventArgs(Object exception, bool isTerminating) {
-            _Exception = exception;
-            _IsTerminating = isTerminating;
+        public UnhandledExceptionEventArgs(Object exception, bool isTerminating)
+        {
+            _exception = exception;
+            _isTerminating = isTerminating;
         }
-        public Object ExceptionObject { 
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
-            get { return _Exception; }
+
+        public Object ExceptionObject
+        {
+            get { return _exception; }
         }
-        public bool IsTerminating {
-            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
-            get { return _IsTerminating; }
+
+        public bool IsTerminating
+        {
+            get { return _isTerminating; }
         }
     }
 }
diff --git a/src/mscorlib/src/System/UnhandledExceptionEventHandler.cs b/src/mscorlib/src/System/UnhandledExceptionEventHandler.cs
index 8c2798230c..b99414c189 100644
--- a/src/mscorlib/src/System/UnhandledExceptionEventHandler.cs
+++ b/src/mscorlib/src/System/UnhandledExceptionEventHandler.cs
@@ -2,10 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-namespace System {
-   
-    using System;
+namespace System
+{
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public delegate void UnhandledExceptionEventHandler(Object sender, UnhandledExceptionEventArgs e);
 }
diff --git a/src/mscorlib/src/System/ValueTuple.cs b/src/mscorlib/src/System/ValueTuple.cs
index 8476122cd1..0f0863a2ed 100644
--- a/src/mscorlib/src/System/ValueTuple.cs
+++ b/src/mscorlib/src/System/ValueTuple.cs
@@ -28,6 +28,7 @@ namespace System
     /// - they are mutable rather than readonly, and
     /// - their members (such as Item1, Item2, etc) are fields rather than properties.
     /// </summary>
+    [Serializable]
     public struct ValueTuple
         : IEquatable<ValueTuple>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<ValueTuple>, IValueTupleInternal, ITuple
     {
@@ -296,6 +297,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]
     public struct ValueTuple<T1>
         : IEquatable<ValueTuple<T1>>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<ValueTuple<T1>>, IValueTupleInternal, ITuple
     {
@@ -460,6 +462,7 @@ namespace System
     /// </summary>
     /// <typeparam name="T1">The type of the tuple's first component.</typeparam>
     /// <typeparam name="T2">The type of the tuple's second component.</typeparam>
+    [Serializable]
     [StructLayout(LayoutKind.Auto)]
     public struct ValueTuple<T1, T2>
         : IEquatable<ValueTuple<T1, T2>>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<ValueTuple<T1, T2>>, IValueTupleInternal, ITuple
@@ -669,6 +672,7 @@ namespace System
     /// <typeparam name="T1">The type of the tuple's first component.</typeparam>
     /// <typeparam name="T2">The type of the tuple's second component.</typeparam>
     /// <typeparam name="T3">The type of the tuple's third component.</typeparam>
+    [Serializable]
     [StructLayout(LayoutKind.Auto)]
     public struct ValueTuple<T1, T2, T3>
         : IEquatable<ValueTuple<T1, T2, T3>>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<ValueTuple<T1, T2, T3>>, IValueTupleInternal, ITuple
@@ -876,6 +880,7 @@ namespace System
     /// <typeparam name="T2">The type of the tuple's second component.</typeparam>
     /// <typeparam name="T3">The type of the tuple's third component.</typeparam>
     /// <typeparam name="T4">The type of the tuple's fourth component.</typeparam>
+    [Serializable]
     [StructLayout(LayoutKind.Auto)]
     public struct ValueTuple<T1, T2, T3, T4>
         : IEquatable<ValueTuple<T1, T2, T3, T4>>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<ValueTuple<T1, T2, T3, T4>>, IValueTupleInternal, ITuple
@@ -1102,6 +1107,7 @@ namespace System
     /// <typeparam name="T3">The type of the tuple's third component.</typeparam>
     /// <typeparam name="T4">The type of the tuple's fourth component.</typeparam>
     /// <typeparam name="T5">The type of the tuple's fifth component.</typeparam>
+    [Serializable]
     [StructLayout(LayoutKind.Auto)]
     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
@@ -1347,6 +1353,7 @@ namespace System
     /// <typeparam name="T4">The type of the tuple's fourth component.</typeparam>
     /// <typeparam name="T5">The type of the tuple's fifth component.</typeparam>
     /// <typeparam name="T6">The type of the tuple's sixth component.</typeparam>
+    [Serializable]
     [StructLayout(LayoutKind.Auto)]
     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
@@ -1611,6 +1618,7 @@ namespace System
     /// <typeparam name="T5">The type of the tuple's fifth component.</typeparam>
     /// <typeparam name="T6">The type of the tuple's sixth component.</typeparam>
     /// <typeparam name="T7">The type of the tuple's seventh component.</typeparam>
+    [Serializable]
     [StructLayout(LayoutKind.Auto)]
     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
@@ -1894,6 +1902,7 @@ namespace System
     /// <typeparam name="T6">The type of the tuple's sixth component.</typeparam>
     /// <typeparam name="T7">The type of the tuple's seventh component.</typeparam>
     /// <typeparam name="TRest">The type of the tuple's eighth component.</typeparam>
+    [Serializable]
     [StructLayout(LayoutKind.Auto)]
     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
diff --git a/src/mscorlib/src/System/ValueType.cs b/src/mscorlib/src/System/ValueType.cs
index 102a0d2b92..06a64e397c 100644
--- a/src/mscorlib/src/System/ValueType.cs
+++ b/src/mscorlib/src/System/ValueType.cs
@@ -17,7 +17,6 @@ namespace System {
     using System.Runtime.Versioning;
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public abstract class ValueType {
 
         public override bool Equals (Object obj) {
diff --git a/src/mscorlib/src/System/Variant.cs b/src/mscorlib/src/System/Variant.cs
index 2a9593cf42..509650b8fc 100644
--- a/src/mscorlib/src/System/Variant.cs
+++ b/src/mscorlib/src/System/Variant.cs
@@ -334,21 +334,6 @@ namespace System {
                 m_flags |= ((int)vt << VTBitShift);
         }
 
-
-        unsafe public Variant(void* voidPointer,Type pointerType) {
-            if (pointerType == null)
-                throw new ArgumentNullException(nameof(pointerType));
-            if (!pointerType.IsPointer)
-                throw new ArgumentException(Environment.GetResourceString("Arg_MustBePointer"),nameof(pointerType));
-            Contract.EndContractBlock();
-
-            m_objref = pointerType;
-            m_flags=CV_PTR;
-            m_data1=(int)voidPointer;
-            m_data2=0;
-
-        }
-
         //This is a family-only accessor for the CVType.
         //This is never to be exposed externally.
         internal int CVType {
diff --git a/src/mscorlib/src/System/Version.cs b/src/mscorlib/src/System/Version.cs
index 501571f78b..7c58d3c0c4 100644
--- a/src/mscorlib/src/System/Version.cs
+++ b/src/mscorlib/src/System/Version.cs
@@ -25,7 +25,6 @@ namespace System {
     // specified component.
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class Version : ICloneable, IComparable
         , IComparable<Version>, IEquatable<Version>
     {
diff --git a/src/mscorlib/src/System/Void.cs b/src/mscorlib/src/System/Void.cs
index 51df8781aa..5c20f634fc 100644
--- a/src/mscorlib/src/System/Void.cs
+++ b/src/mscorlib/src/System/Void.cs
@@ -7,12 +7,11 @@
 //    This class represents the void return type
 ////////////////////////////////////////////////////////////////////////////////
 
-namespace System {
-   
-    using System;
+namespace System
+{
+    // This class represents the void return type
     [Serializable]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public struct Void 
+    public struct Void
     {
     }
 }
diff --git a/src/mscorlib/src/System/WeakReference.cs b/src/mscorlib/src/System/WeakReference.cs
index d5648527f0..6600d15855 100644
--- a/src/mscorlib/src/System/WeakReference.cs
+++ b/src/mscorlib/src/System/WeakReference.cs
@@ -13,13 +13,11 @@ namespace System {
     using System;
     using System.Runtime.Serialization;
     using System.Security;
-    using System.Security.Permissions;
     using System.Runtime.CompilerServices;
     using System.Runtime.Versioning;
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
 
-    [System.Runtime.InteropServices.ComVisible(true)]
     [Serializable]
     public class WeakReference : ISerializable 
     {
diff --git a/src/mscorlib/src/System/_LocalDataStore.cs b/src/mscorlib/src/System/_LocalDataStore.cs
deleted file mode 100644
index a1fa488076..0000000000
--- a/src/mscorlib/src/System/_LocalDataStore.cs
+++ /dev/null
@@ -1,244 +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: Class that stores local data. This class is used in cooperation
-**          with the _LocalDataStoreMgr class.
-**
-**
-=============================================================================*/
-
-namespace System {
-    
-    using System;
-    using System.Threading;
-    using System.Runtime.CompilerServices;
-    using System.Diagnostics;
-    using System.Diagnostics.Contracts;
-
-    // Helper class to aid removal of LocalDataStore from the LocalDataStoreMgr
-    // LocalDataStoreMgr does not holds references to LocalDataStoreHolder. It holds
-    // references to LocalDataStore only. LocalDataStoreHolder finalizer will run once
-    // the only outstanding reference to the store is in LocalDataStoreMgr.
-    sealed internal class LocalDataStoreHolder
-    {
-        private LocalDataStore m_Store;
-
-        public LocalDataStoreHolder(LocalDataStore store)
-        {
-            m_Store = store;
-        }
-
-        ~LocalDataStoreHolder()
-        {
-            LocalDataStore store = m_Store;
-            if (store == null)
-                return;
-
-            store.Dispose();
-        }
-
-        public LocalDataStore Store
-        {
-            get
-            {
-                return m_Store;
-            }
-        }
-    }
-
-    sealed internal class LocalDataStoreElement
-    {
-        private Object m_value;
-        private long m_cookie;  // This is immutable cookie of the slot used to verify that 
-                                // the value is indeed indeed owned by the slot. Necessary 
-                                // to avoid resurection holes.
-
-        public LocalDataStoreElement(long cookie)
-        {
-            m_cookie = cookie;
-        }
-
-        public Object Value
-        {
-            get
-            {
-                return m_value;
-            }
-            set
-            {
-                m_value = value;
-            }
-        }
-
-        public long Cookie
-        {
-            get
-            {
-                return m_cookie;
-            }
-        }
-    }
-
-    // This class will not be marked serializable
-    sealed internal class LocalDataStore
-    {
-        private LocalDataStoreElement[] m_DataTable;
-        private LocalDataStoreMgr m_Manager;
-
-        /*=========================================================================
-        ** Initialize the data store.
-        =========================================================================*/
-        public LocalDataStore(LocalDataStoreMgr mgr, int InitialCapacity)
-        {
-            // Store the manager of the local data store.       
-            m_Manager = mgr;
-
-            // Allocate the array that will contain the data.
-            m_DataTable = new LocalDataStoreElement[InitialCapacity];
-        }
-
-        /*=========================================================================
-        ** Delete this store from its manager
-        =========================================================================*/
-        internal void Dispose()
-        {
-            m_Manager.DeleteLocalDataStore(this);
-        }
-
-        /*=========================================================================
-        ** Retrieves the value from the specified slot.
-        =========================================================================*/
-        public Object GetData(LocalDataStoreSlot slot)
-        {
-            // Validate the slot.
-            m_Manager.ValidateSlot(slot);
-
-            // Cache the slot index to avoid synchronization issues.
-            int slotIdx = slot.Slot;
-
-            if (slotIdx >= 0)
-            {
-                // Delay expansion of m_DataTable if we can
-                if (slotIdx >= m_DataTable.Length)
-                    return null;         
-                
-                // Retrieve the data from the given slot.
-                LocalDataStoreElement element = m_DataTable[slotIdx];
-
-          //Initially we prepopulate the elements to be null.     
-          if (element == null)
-              return null;
-
-                // Check that the element is owned by this slot by comparing cookies.
-                // This is necesary to avoid resurection race conditions.
-                if (element.Cookie == slot.Cookie)
-                    return element.Value;
-
-                // Fall thru and throw exception
-            }
-                
-            throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_SlotHasBeenFreed"));
-        }
-    
-        /*=========================================================================
-        ** Sets the data in the specified slot.
-        =========================================================================*/
-        public void SetData(LocalDataStoreSlot slot, Object data)
-        {
-            // Validate the slot.
-            m_Manager.ValidateSlot(slot);
-
-            // Cache the slot index to avoid synchronization issues.
-            int slotIdx = slot.Slot;
-
-            if (slotIdx >= 0)
-            {
-                LocalDataStoreElement element = (slotIdx < m_DataTable.Length) ? m_DataTable[slotIdx] : null;
-                if (element == null)
-                {
-                    element = PopulateElement(slot);
-                }
-
-                // Check that the element is owned by this slot by comparing cookies.
-                // This is necesary to avoid resurection race conditions.
-                if (element.Cookie == slot.Cookie)
-                {
-                    // Set the data on the given slot.
-                    element.Value = data;
-                    return;
-                }
-
-                // Fall thru and throw exception
-            }
-
-            throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_SlotHasBeenFreed"));
-        }
-
-        /*=========================================================================
-        ** This method does clears the unused slot.
-         * Assumes lock on m_Manager is taken
-        =========================================================================*/
-        internal void FreeData(int slot, long cookie)
-        {
-            // We try to delay allocate the dataTable (in cases like the manager clearing a
-            // just-freed slot in all stores
-            if (slot >= m_DataTable.Length)
-                return;
-
-            LocalDataStoreElement element = m_DataTable[slot];
-            if (element != null && element.Cookie == cookie)
-                m_DataTable[slot] = null;
-        }
-
-        /*=========================================================================
-        ** Method used to expand the capacity of the local data store.
-        =========================================================================*/
-        private LocalDataStoreElement PopulateElement(LocalDataStoreSlot slot)
-        {
-            bool tookLock = false;
-            RuntimeHelpers.PrepareConstrainedRegions();
-            try {
-                Monitor.Enter(m_Manager, ref tookLock);
-
-                // Make sure that the slot was not freed in the meantime
-                int slotIdx = slot.Slot;
-                if (slotIdx < 0)
-                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_SlotHasBeenFreed"));
-
-                if (slotIdx >= m_DataTable.Length)
-                {
-                    int capacity = m_Manager.GetSlotTableLength();
-
-                    // Validate that the specified capacity is larger than the current one.
-                    Debug.Assert(capacity >= m_DataTable.Length, "LocalDataStore corrupted: capacity >= m_DataTable.Length");
-
-                    // Allocate the new data table.
-                    LocalDataStoreElement[] NewDataTable = new LocalDataStoreElement[capacity];
-
-                    // Copy all the objects into the new table.
-                    Array.Copy(m_DataTable, NewDataTable, m_DataTable.Length);
-
-                    // Save the new table.
-                    m_DataTable = NewDataTable;
-                }
-
-                // Validate that there is enough space in the local data store now
-                Debug.Assert(slotIdx < m_DataTable.Length, "LocalDataStore corrupted: slotIdx < m_DataTable.Length");
-
-                if (m_DataTable[slotIdx] == null)
-                    m_DataTable[slotIdx] = new LocalDataStoreElement(slot.Cookie);
-
-                return m_DataTable[slotIdx];
-            }
-            finally {
-                if (tookLock)
-                    Monitor.Exit(m_Manager);
-            }
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/_LocalDataStoreMgr.cs b/src/mscorlib/src/System/_LocalDataStoreMgr.cs
deleted file mode 100644
index 8f60d6f754..0000000000
--- a/src/mscorlib/src/System/_LocalDataStoreMgr.cs
+++ /dev/null
@@ -1,332 +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: Class that manages stores of local data. This class is used in 
-**          cooperation with the LocalDataStore class.
-**
-**
-=============================================================================*/
-namespace System {
-    
-    using System;
-    using System.Collections.Generic;
-    using System.Threading;
-    using System.Runtime.CompilerServices;
-    using System.Diagnostics.Contracts;
-
-    // This class is an encapsulation of a slot so that it is managed in a secure fashion.
-    // It is constructed by the LocalDataStoreManager, holds the slot and the manager
-    // and cleans up when it is finalized.
-    // This class will not be marked serializable
-[System.Runtime.InteropServices.ComVisible(true)]
-    public sealed class LocalDataStoreSlot
-    {
-        private LocalDataStoreMgr m_mgr;
-        private int m_slot;
-        private long m_cookie;
-
-        // Construct the object to encapsulate the slot.
-        internal LocalDataStoreSlot(LocalDataStoreMgr mgr, int slot, long cookie)
-        {
-            m_mgr = mgr;
-            m_slot = slot;
-            m_cookie = cookie;
-        }
-
-        // Accessors for the two fields of this class.
-        internal LocalDataStoreMgr Manager
-        {
-            get
-            {
-                return m_mgr;
-            }
-        }
-        internal int Slot
-        {
-            get
-            {
-                return m_slot;
-            }
-        }
-        internal long Cookie
-        {
-            get
-            {
-                return m_cookie;
-            }
-        }
-
-        // Release the slot reserved by this object when this object goes away.
-        ~LocalDataStoreSlot()
-        {
-            LocalDataStoreMgr mgr = m_mgr;
-            if (mgr == null)
-                return;
-
-            int slot = m_slot;
-
-            // Mark the slot as free.
-            m_slot = -1;
-
-            mgr.FreeDataSlot(slot, m_cookie);
-        }
-    }
-
-    // This class will not be marked serializable
-    sealed internal class LocalDataStoreMgr
-    {
-        private const int InitialSlotTableSize            = 64;
-        private const int SlotTableDoubleThreshold        = 512;
-        private const int LargeSlotTableSizeIncrease    = 128;
-    
-        /*=========================================================================
-        ** Create a data store to be managed by this manager and add it to the
-        ** list. The initial size of the new store matches the number of slots
-        ** allocated in this manager.
-        =========================================================================*/
-        public LocalDataStoreHolder CreateLocalDataStore()
-        {
-            // Create a new local data store.
-            LocalDataStore store = new LocalDataStore(this, m_SlotInfoTable.Length);
-            LocalDataStoreHolder holder = new LocalDataStoreHolder(store);
-
-            bool tookLock = false;
-            RuntimeHelpers.PrepareConstrainedRegions();
-            try
-            {
-                Monitor.Enter(this, ref tookLock);
-                // Add the store to the array list and return it.
-                m_ManagedLocalDataStores.Add(store);
-            }
-            finally
-            {
-                if (tookLock)
-                    Monitor.Exit(this);
-            }
-            return holder;
-        }
-
-        /*=========================================================================
-         * Remove the specified store from the list of managed stores..
-        =========================================================================*/
-        public void DeleteLocalDataStore(LocalDataStore store)
-        {
-            bool tookLock = false;
-            RuntimeHelpers.PrepareConstrainedRegions();
-            try
-            {
-                Monitor.Enter(this, ref tookLock);
-                // Remove the store to the array list and return it.
-                m_ManagedLocalDataStores.Remove(store);
-            }
-            finally
-            {
-                if (tookLock)
-                    Monitor.Exit(this);
-            }
-        }
-
-        /*=========================================================================
-        ** Allocates a data slot by finding an available index and wrapping it
-        ** an object to prevent clients from manipulating it directly, allowing us
-        ** to make assumptions its integrity.
-        =========================================================================*/
-        public LocalDataStoreSlot AllocateDataSlot()
-        {
-            bool tookLock = false;
-            RuntimeHelpers.PrepareConstrainedRegions();
-            try
-            {
-                Monitor.Enter(this, ref tookLock);
-                LocalDataStoreSlot slot;
-
-                int slotTableSize = m_SlotInfoTable.Length;
-
-                // In case FreeDataSlot has moved the pointer back, the next slot may not be available.
-                // Find the first actually available slot.
-                int availableSlot = m_FirstAvailableSlot;
-                while (availableSlot < slotTableSize)
-                {
-                    if (!m_SlotInfoTable[availableSlot])
-                        break;
-                    availableSlot++;
-                }
-
-                // Check if there are any slots left.
-                if (availableSlot >= slotTableSize)
-                {
-                    // The table is full so we need to increase its size.
-                    int newSlotTableSize;
-                    if (slotTableSize < SlotTableDoubleThreshold)
-                    {
-                        // The table is still relatively small so double it.
-                        newSlotTableSize = slotTableSize * 2;
-                    }
-                    else
-                    {
-                        // The table is relatively large so simply increase its size by a given amount.
-                        newSlotTableSize = slotTableSize + LargeSlotTableSizeIncrease;
-                    }
-
-                    // Allocate the new slot info table.
-                    bool[] newSlotInfoTable = new bool[newSlotTableSize];
-
-                    // Copy the old array into the new one.
-                    Array.Copy(m_SlotInfoTable, newSlotInfoTable, slotTableSize);
-                    m_SlotInfoTable = newSlotInfoTable;
-                }
-
-                // availableSlot is the index of the empty slot.
-                m_SlotInfoTable[availableSlot] = true;
-
-                // We do not need to worry about overflowing m_CookieGenerator. It would take centuries
-                // of intensive slot allocations on current machines to get the 2^64 counter to overflow.
-                // We will perform the increment with overflow check just to play it on the safe side.
-                slot = new LocalDataStoreSlot(this, availableSlot, checked(m_CookieGenerator++));
-
-                // Save the new "first available slot".hint
-                m_FirstAvailableSlot = availableSlot + 1;
-
-                // Return the selected slot
-                return slot;
-            }
-            finally
-            {
-                if (tookLock)
-                    Monitor.Exit(this);
-            }
-        }
-        
-        /*=========================================================================
-        ** Allocate a slot and associate a name with it.
-        =========================================================================*/
-        public LocalDataStoreSlot AllocateNamedDataSlot(String name)
-        {
-            bool tookLock = false;
-            RuntimeHelpers.PrepareConstrainedRegions();
-            try
-            {
-                Monitor.Enter(this, ref tookLock);
-                // Allocate a normal data slot.
-                LocalDataStoreSlot slot = AllocateDataSlot();
-
-                // Insert the association between the name and the data slot number
-                // in the hash table.
-                m_KeyToSlotMap.Add(name, slot);
-                return slot;
-            }
-            finally
-            {
-                if (tookLock)
-                    Monitor.Exit(this);
-            }
-        }
-
-        /*=========================================================================
-        ** Retrieve the slot associated with a name, allocating it if no such
-        ** association has been defined.
-        =========================================================================*/
-        public LocalDataStoreSlot GetNamedDataSlot(String name)
-        {
-            bool tookLock = false;
-            RuntimeHelpers.PrepareConstrainedRegions();
-            try
-            {
-                Monitor.Enter(this, ref tookLock);
-                // Lookup in the hashtable to try find a slot for the name.
-                LocalDataStoreSlot slot = m_KeyToSlotMap.GetValueOrDefault(name);
-
-                // If the name is not yet in the hashtable then add it.
-                if (null == slot)
-                    return AllocateNamedDataSlot(name);
-
-                // The name was in the hashtable so return the associated slot.
-                return slot;
-            }
-            finally
-            {
-                if (tookLock)
-                    Monitor.Exit(this);
-            }
-        }
-
-        /*=========================================================================
-        ** Eliminate the association of a name with a slot.  The actual slot will
-        ** be reclaimed when the finalizer for the slot object runs.
-        =========================================================================*/
-        public void FreeNamedDataSlot(String name)
-        {
-            bool tookLock = false;
-            RuntimeHelpers.PrepareConstrainedRegions();
-            try
-            {
-                Monitor.Enter(this, ref tookLock);
-                // Remove the name slot association from the hashtable.
-                m_KeyToSlotMap.Remove(name);
-            }
-            finally
-            {
-                if (tookLock)
-                    Monitor.Exit(this);
-            }
-        }
-
-        /*=========================================================================
-        ** Free's a previously allocated data slot on ALL the managed data stores.
-        =========================================================================*/
-        internal void FreeDataSlot(int slot, long cookie)
-        {
-            bool tookLock = false;
-            RuntimeHelpers.PrepareConstrainedRegions();
-            try
-            {
-                Monitor.Enter(this, ref tookLock);
-                // Go thru all the managed stores and set the data on the specified slot to 0.
-                for (int i = 0; i < m_ManagedLocalDataStores.Count; i++)
-                {
-                    ((LocalDataStore)m_ManagedLocalDataStores[i]).FreeData(slot, cookie);
-                }
-
-                // Mark the slot as being no longer occupied. 
-                m_SlotInfoTable[slot] = false;
-                if (slot < m_FirstAvailableSlot)
-                    m_FirstAvailableSlot = slot;
-            }
-            finally
-            {
-                if (tookLock)
-                    Monitor.Exit(this);
-            }
-        }
-
-        /*=========================================================================
-        ** Check that this is a valid slot for this store
-        =========================================================================*/
-        public void ValidateSlot(LocalDataStoreSlot slot)
-        {
-            // Make sure the slot was allocated for this store.
-            if (slot == null || slot.Manager != this)
-                throw new ArgumentException(Environment.GetResourceString("Argument_ALSInvalidSlot"));
-            Contract.EndContractBlock();
-        }
-
-        /*=========================================================================
-        ** Return the number of allocated slots in this manager.
-        =========================================================================*/
-        internal int GetSlotTableLength()
-        {
-            return m_SlotInfoTable.Length;
-        }
-
-        private bool[] m_SlotInfoTable = new bool[InitialSlotTableSize];
-        private int m_FirstAvailableSlot;
-        private List<LocalDataStore> m_ManagedLocalDataStores = new List<LocalDataStore>();
-        private Dictionary<String, LocalDataStoreSlot> m_KeyToSlotMap = new Dictionary<String, LocalDataStoreSlot>();
-        private long m_CookieGenerator;
-    }
-}
diff --git a/src/mscorlib/src/System/__ComObject.cs b/src/mscorlib/src/System/__ComObject.cs
index 9f9bac6084..86800a51f8 100644
--- a/src/mscorlib/src/System/__ComObject.cs
+++ b/src/mscorlib/src/System/__ComObject.cs
@@ -21,7 +21,6 @@ namespace System
     using System.Runtime.InteropServices.WindowsRuntime;
     using System.Runtime.CompilerServices;
     using System.Reflection;
-    using System.Security.Permissions;
 
     internal class __ComObject : MarshalByRefObject
     {
@@ -58,12 +57,6 @@ namespace System
                 
             return base.ToString();
         }
-        
-        internal IntPtr GetIUnknown(out bool fIsURTAggregated)
-        {
-            fIsURTAggregated = !GetType().IsDefined(typeof(ComImportAttribute), false);
-            return System.Runtime.InteropServices.Marshal.GetIUnknownForObject(this);
-        }
 
         //====================================================================
         // This method retrieves the data associated with the specified
diff --git a/src/mscorlib/src/System/cominterfaces.cs b/src/mscorlib/src/System/cominterfaces.cs
deleted file mode 100644
index a83943d586..0000000000
--- a/src/mscorlib/src/System/cominterfaces.cs
+++ /dev/null
@@ -1,40 +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.
-
-namespace System.Runtime.InteropServices
-{
-    [GuidAttribute("03973551-57A1-3900-A2B5-9083E3FF2943")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Activator))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _Activator
-    {
-        void GetTypeInfoCount(out uint pcTInfo);
-
-        void GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo);
-
-        void GetIDsOfNames([In] ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId);
-
-        void Invoke(uint dispIdMember, [In] ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr);
-    }
-
-    [GuidAttribute("917B14D0-2D9E-38B8-92A9-381ACF52F7C0")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Attribute))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _Attribute
-    {
-    }
-
-    [GuidAttribute("C281C7F1-4AA9-3517-961A-463CFED57E75")]
-    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
-    [CLSCompliant(false)]
-    [TypeLibImportClassAttribute(typeof(System.Threading.Thread))]
-    [System.Runtime.InteropServices.ComVisible(true)]
-    public interface _Thread
-    {
-    }
-}
diff --git a/src/mscorlib/src/mscorlib.Friends.cs b/src/mscorlib/src/mscorlib.Friends.cs
index e55d043c6c..0e57812638 100644
--- a/src/mscorlib/src/mscorlib.Friends.cs
+++ b/src/mscorlib/src/mscorlib.Friends.cs
@@ -10,14 +10,8 @@ using System.Runtime.CompilerServices;
 // AssemblyAttributes.cspp model for the other build types at a future point in time.
 
 // Depends on things like SuppressUnmanagedCodeAttribute and WindowsRuntimeImportAttribute
-[assembly: InternalsVisibleTo("System.Runtime.WindowsRuntime, PublicKey=" + _InternalsVisibleToKeys.EcmaPublicKeyFull, AllInternalsVisible=false)]
+[assembly: InternalsVisibleTo("System.Runtime.WindowsRuntime, PublicKey=00000000000000000400000000000000", AllInternalsVisible=false)]
 
 // Depends on WindowsRuntimeImportAttribute
-[assembly: InternalsVisibleTo("System.Runtime.WindowsRuntime.UI.Xaml, PublicKey=" + _InternalsVisibleToKeys.EcmaPublicKeyFull, AllInternalsVisible=false)]
-
-internal class _InternalsVisibleToKeys
-{
-  // Token = b77a5c561934e089
-  internal const string EcmaPublicKeyFull = "00000000000000000400000000000000";
-}
+[assembly: InternalsVisibleTo("System.Runtime.WindowsRuntime.UI.Xaml, PublicKey=00000000000000000400000000000000", AllInternalsVisible=false)]
 
diff --git a/src/pal/inc/mbusafecrt.h b/src/pal/inc/mbusafecrt.h
index 8cf050f419..f030b7ded2 100644
--- a/src/pal/inc/mbusafecrt.h
+++ b/src/pal/inc/mbusafecrt.h
@@ -56,7 +56,7 @@ extern WCHAR* wcstok_s( WCHAR* inString, const WCHAR* inControl, WCHAR** ioConte
 // strnlen is not required unless the source string is completely untrusted (e.g. anonymous input on a website)
 #ifndef SUPPRESS_STRNLEN
     extern size_t PAL_strnlen( const char* inString, size_t inMaxSize );
-    extern size_t wcsnlen( const WCHAR* inString, size_t inMaxSize );
+    extern size_t PAL_wcsnlen( const WCHAR* inString, size_t inMaxSize );
 #endif
 
 extern errno_t _itoa_s( int inValue, char* outBuffer, size_t inDestBufferSize, int inRadix );
diff --git a/src/pal/inc/pal.h b/src/pal/inc/pal.h
index fdcec58c24..d0b78e942f 100644
--- a/src/pal/inc/pal.h
+++ b/src/pal/inc/pal.h
@@ -1795,10 +1795,17 @@ typedef struct _CONTEXT {
 
 typedef struct _KNONVOLATILE_CONTEXT_POINTERS {
 
-    // TODO WIP x86/Linux, need to fix this.
-    PDWORD Ebx;
-    PDWORD Esi;
+    // The ordering of these fields should be aligned with that
+    // of corresponding fields in CONTEXT
+    //
+    // (See FillRegDisplay in inc/regdisp.h for details)
     PDWORD Edi;
+    PDWORD Esi;
+    PDWORD Ebx;
+    PDWORD Edx;
+    PDWORD Ecx;
+    PDWORD Eax;
+
     PDWORD Ebp;
 
 } KNONVOLATILE_CONTEXT_POINTERS, *PKNONVOLATILE_CONTEXT_POINTERS;
@@ -4954,6 +4961,7 @@ CoCreateGuid(OUT GUID * pguid);
 #define _wcstoui64    PAL__wcstoui64
 #define _flushall     PAL__flushall
 #define strnlen       PAL_strnlen
+#define wcsnlen       PAL_wcsnlen
 
 #ifdef _AMD64_ 
 #define _mm_getcsr    PAL__mm_getcsr
diff --git a/src/pal/inc/rt/sal.h b/src/pal/inc/rt/sal.h
index 0e3eaaa388..07468645a5 100644
--- a/src/pal/inc/rt/sal.h
+++ b/src/pal/inc/rt/sal.h
@@ -2861,7 +2861,7 @@ of each annotation, see the advanced annotations section.
 #define __success(expr)                      _Success_(expr)
 #define __nullterminated                     _Null_terminated_
 #define __nullnullterminated
-#define __reserved                           _SAL1_Source_(__reserved, (), _Reserved_)
+#define __clr_reserved                       _SAL1_Source_(__reserved, (), _Reserved_)
 #define __checkReturn                        _SAL1_Source_(__checkReturn, (), _Check_return_)
 #define __typefix(ctype)                     _SAL1_Source_(__typefix, (ctype), __inner_typefix(ctype))
 #define __override                           __inner_override
diff --git a/src/pal/inc/rt/specstrings_strict.h b/src/pal/inc/rt/specstrings_strict.h
index 514106eedf..08d323c589 100644
--- a/src/pal/inc/rt/specstrings_strict.h
+++ b/src/pal/inc/rt/specstrings_strict.h
@@ -626,7 +626,7 @@
 #define __in_awcount(expr,size)  __allowed(on_parameter)   
 #define __nullterminated         _SAL_VERSION_CHECK(__nullterminated)
 #define __nullnullterminated     _SAL_VERSION_CHECK(__nullnullterminated)
-#define __reserved               _SAL_VERSION_CHECK(__reserved)
+#define __clr_reserved           _SAL_VERSION_CHECK(__reserved)
 #define __checkReturn            _SAL_VERSION_CHECK(__checkReturn)
 #define __typefix(ctype)         __allowed(on_parameter_or_return) 
 #define __override               __allowed(on_function) 
diff --git a/src/pal/inc/rt/specstrings_undef.h b/src/pal/inc/rt/specstrings_undef.h
index b462dc2e25..69fc01c15d 100644
--- a/src/pal/inc/rt/specstrings_undef.h
+++ b/src/pal/inc/rt/specstrings_undef.h
@@ -445,7 +445,7 @@
 #undef __readableTo
 #undef __readonly
 #undef __refparam
-#undef __reserved
+#undef __clr_reserved
 #undef __rpc_entry
 #undef __source_code_content
 #undef __struct_bcount
diff --git a/src/pal/prebuilt/inc/asm_version.h b/src/pal/prebuilt/inc/asm_version.h
index 977c8dd188..44e09c0e8e 100644
--- a/src/pal/prebuilt/inc/asm_version.h
+++ b/src/pal/prebuilt/inc/asm_version.h
@@ -1,7 +1,7 @@
 // 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.
-#if defined(SILVERLIGHT) || defined(FEATURE_CORECLR)
+#if defined(SILVERLIGHT)
 #if defined(FEATURE_CORESYSTEM)
 #define asm_rmj              4
 #define asm_rmm              0
diff --git a/src/pal/prebuilt/inc/fusionpriv.h b/src/pal/prebuilt/inc/fusionpriv.h
deleted file mode 100644
index b0bca9e1f4..0000000000
--- a/src/pal/prebuilt/inc/fusionpriv.h
+++ /dev/null
@@ -1,2919 +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.
-
-
-
-/* this ALWAYS GENERATED file contains the definitions for the interfaces */
-
-
- /* File created by MIDL compiler version 8.00.0603 */
-/* @@MIDL_FILE_HEADING(  ) */
-
-#pragma warning( disable: 4049 )  /* more than 64k source lines */
-
-
-/* verify that the <rpcndr.h> version is high enough to compile this file*/
-#ifndef __REQUIRED_RPCNDR_H_VERSION__
-#define __REQUIRED_RPCNDR_H_VERSION__ 475
-#endif
-
-#include "rpc.h"
-#include "rpcndr.h"
-
-#ifndef __RPCNDR_H_VERSION__
-#error this stub requires an updated version of <rpcndr.h>
-#endif // __RPCNDR_H_VERSION__
-
-#ifndef COM_NO_WINDOWS_H
-#include "windows.h"
-#include "ole2.h"
-#endif /*COM_NO_WINDOWS_H*/
-
-#ifndef __fusionpriv_h__
-#define __fusionpriv_h__
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-#pragma once
-#endif
-
-/* Forward Declarations */ 
-
-#ifndef __IHistoryAssembly_FWD_DEFINED__
-#define __IHistoryAssembly_FWD_DEFINED__
-typedef interface IHistoryAssembly IHistoryAssembly;
-
-#endif 	/* __IHistoryAssembly_FWD_DEFINED__ */
-
-
-#ifndef __IHistoryReader_FWD_DEFINED__
-#define __IHistoryReader_FWD_DEFINED__
-typedef interface IHistoryReader IHistoryReader;
-
-#endif 	/* __IHistoryReader_FWD_DEFINED__ */
-
-
-#ifndef __IFusionBindLog_FWD_DEFINED__
-#define __IFusionBindLog_FWD_DEFINED__
-typedef interface IFusionBindLog IFusionBindLog;
-
-#endif 	/* __IFusionBindLog_FWD_DEFINED__ */
-
-
-#ifndef __IAssemblyManifestImport_FWD_DEFINED__
-#define __IAssemblyManifestImport_FWD_DEFINED__
-typedef interface IAssemblyManifestImport IAssemblyManifestImport;
-
-#endif 	/* __IAssemblyManifestImport_FWD_DEFINED__ */
-
-
-#ifndef __IApplicationContext_FWD_DEFINED__
-#define __IApplicationContext_FWD_DEFINED__
-typedef interface IApplicationContext IApplicationContext;
-
-#endif 	/* __IApplicationContext_FWD_DEFINED__ */
-
-
-#ifndef __IAssemblyNameBinder_FWD_DEFINED__
-#define __IAssemblyNameBinder_FWD_DEFINED__
-typedef interface IAssemblyNameBinder IAssemblyNameBinder;
-
-#endif 	/* __IAssemblyNameBinder_FWD_DEFINED__ */
-
-
-#ifndef __IAssembly_FWD_DEFINED__
-#define __IAssembly_FWD_DEFINED__
-typedef interface IAssembly IAssembly;
-
-#endif 	/* __IAssembly_FWD_DEFINED__ */
-
-
-#ifndef __IAssemblyBindingClosureEnumerator_FWD_DEFINED__
-#define __IAssemblyBindingClosureEnumerator_FWD_DEFINED__
-typedef interface IAssemblyBindingClosureEnumerator IAssemblyBindingClosureEnumerator;
-
-#endif 	/* __IAssemblyBindingClosureEnumerator_FWD_DEFINED__ */
-
-
-#ifndef __IAssemblyBindingClosure_FWD_DEFINED__
-#define __IAssemblyBindingClosure_FWD_DEFINED__
-typedef interface IAssemblyBindingClosure IAssemblyBindingClosure;
-
-#endif 	/* __IAssemblyBindingClosure_FWD_DEFINED__ */
-
-
-#ifndef __IAssemblyBindSink_FWD_DEFINED__
-#define __IAssemblyBindSink_FWD_DEFINED__
-typedef interface IAssemblyBindSink IAssemblyBindSink;
-
-#endif 	/* __IAssemblyBindSink_FWD_DEFINED__ */
-
-
-#ifndef __IAssemblyBinding_FWD_DEFINED__
-#define __IAssemblyBinding_FWD_DEFINED__
-typedef interface IAssemblyBinding IAssemblyBinding;
-
-#endif 	/* __IAssemblyBinding_FWD_DEFINED__ */
-
-
-#ifndef __IAssemblyModuleImport_FWD_DEFINED__
-#define __IAssemblyModuleImport_FWD_DEFINED__
-typedef interface IAssemblyModuleImport IAssemblyModuleImport;
-
-#endif 	/* __IAssemblyModuleImport_FWD_DEFINED__ */
-
-
-#ifndef __IAssemblyScavenger_FWD_DEFINED__
-#define __IAssemblyScavenger_FWD_DEFINED__
-typedef interface IAssemblyScavenger IAssemblyScavenger;
-
-#endif 	/* __IAssemblyScavenger_FWD_DEFINED__ */
-
-
-#ifndef __ICodebaseList_FWD_DEFINED__
-#define __ICodebaseList_FWD_DEFINED__
-typedef interface ICodebaseList ICodebaseList;
-
-#endif 	/* __ICodebaseList_FWD_DEFINED__ */
-
-
-#ifndef __IDownloadMgr_FWD_DEFINED__
-#define __IDownloadMgr_FWD_DEFINED__
-typedef interface IDownloadMgr IDownloadMgr;
-
-#endif 	/* __IDownloadMgr_FWD_DEFINED__ */
-
-
-#ifndef __IHostAssembly_FWD_DEFINED__
-#define __IHostAssembly_FWD_DEFINED__
-typedef interface IHostAssembly IHostAssembly;
-
-#endif 	/* __IHostAssembly_FWD_DEFINED__ */
-
-
-#ifndef __IHostAssemblyModuleImport_FWD_DEFINED__
-#define __IHostAssemblyModuleImport_FWD_DEFINED__
-typedef interface IHostAssemblyModuleImport IHostAssemblyModuleImport;
-
-#endif 	/* __IHostAssemblyModuleImport_FWD_DEFINED__ */
-
-
-/* header files for imported files */
-#include "objidl.h"
-#include "oleidl.h"
-#include "fusion.h"
-
-#ifdef __cplusplus
-extern "C"{
-#endif 
-
-
-/* interface __MIDL_itf_fusionpriv_0000_0000 */
-/* [local] */ 
-
-//=--------------------------------------------------------------------------=
-// fusionpriv.h
-//=--------------------------------------------------------------------------=
-
-//
-// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
-// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
-// PARTICULAR PURPOSE.
-//=--------------------------------------------------------------------------=
-
-#ifdef _MSC_VER
-#pragma comment(lib,"uuid.lib")
-#endif
-
-//---------------------------------------------------------------------------=
-// Fusion Interfaces.
-
-#if defined(_CLR_BLD) && !defined(FEATURE_FUSION)
-#error FEATURE_FUSION is not enabled, please do not include fusionpriv.h
-#endif
-#ifdef _MSC_VER
-#pragma once
-#endif
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-struct IMetaDataAssemblyImport;
-
-EXTERN_C const IID IID_IApplicationContext;       
-EXTERN_C const IID IID_IAssembly;           
-EXTERN_C const IID IID_IAssemblyBindSink;   
-EXTERN_C const IID IID_IAssemblyBinding;   
-EXTERN_C const IID IID_IAssemblyManifestImport;
-EXTERN_C const IID IID_IAssemblyModuleImport;  
-EXTERN_C const IID IID_IHistoryAssembly;      
-EXTERN_C const IID IID_IHistoryReader;      
-EXTERN_C const IID IID_IMetaDataAssemblyImportControl;      
-EXTERN_C const IID IID_IAssemblyScavenger;  
-EXTERN_C const IID IID_IHostAssembly; 
-EXTERN_C const IID IID_IHostAssemblyModuleImport; 
-typedef /* [public] */ 
-enum __MIDL___MIDL_itf_fusionpriv_0000_0000_0001
-    {
-        ASM_BINDF_NONE	= 0,
-        ASM_BINDF_FORCE_CACHE_INSTALL	= 0x1,
-        ASM_BINDF_RFS_INTEGRITY_CHECK	= 0x2,
-        ASM_BINDF_RFS_MODULE_CHECK	= 0x4,
-        ASM_BINDF_BINPATH_PROBE_ONLY	= 0x8,
-        ASM_BINDF_PARENT_ASM_HINT	= 0x20,
-        ASM_BINDF_DISALLOW_APPLYPUBLISHERPOLICY	= 0x40,
-        ASM_BINDF_DISALLOW_APPBINDINGREDIRECTS	= 0x80,
-        ASM_BINDF_DISABLE_FX_UNIFICATION	= 0x100,
-        ASM_BINDF_DO_NOT_PROBE_NATIVE_IMAGE	= 0x200,
-        ASM_BINDF_DISABLE_DOWNLOAD	= 0x400,
-        ASM_BINDF_INSPECTION_ONLY	= 0x800,
-        ASM_BINDF_DISALLOW_APP_BASE_PROBING	= 0x1000,
-        ASM_BINDF_SUPPRESS_SECURITY_CHECKS	= 0x2000
-    } 	ASM_BIND_FLAGS;
-
-typedef 
-enum tagDEVOVERRIDEMODE
-    {
-        DEVOVERRIDE_LOCAL	= 0x1,
-        DEVOVERRIDE_GLOBAL	= 0x2
-    } 	DEVOVERRIDEMODE;
-
-typedef 
-enum tagWALK_LEVEL
-    {
-        LEVEL_STARTING	= 0,
-        LEVEL_WINRTCHECK	= ( LEVEL_STARTING + 1 ) ,
-        LEVEL_GACCHECK	= ( LEVEL_WINRTCHECK + 1 ) ,
-        LEVEL_COMPLETE	= ( LEVEL_GACCHECK + 1 ) ,
-        LEVEL_FXPREDICTED	= ( LEVEL_COMPLETE + 1 ) ,
-        LEVEL_FXPROBED	= ( LEVEL_FXPREDICTED + 1 ) 
-    } 	WALK_LEVEL;
-
-
-
-extern RPC_IF_HANDLE __MIDL_itf_fusionpriv_0000_0000_v0_0_c_ifspec;
-extern RPC_IF_HANDLE __MIDL_itf_fusionpriv_0000_0000_v0_0_s_ifspec;
-
-#ifndef __IHistoryAssembly_INTERFACE_DEFINED__
-#define __IHistoryAssembly_INTERFACE_DEFINED__
-
-/* interface IHistoryAssembly */
-/* [unique][uuid][object][local] */ 
-
-
-EXTERN_C const IID IID_IHistoryAssembly;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("e6096a07-e188-4a49-8d50-2a0172a0d205")
-    IHistoryAssembly : public IUnknown
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE GetAssemblyName( 
-            /* [annotation][out] */ 
-            __out  LPWSTR wzAsmName,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetPublicKeyToken( 
-            /* [annotation][out] */ 
-            __out  LPWSTR wzPublicKeyToken,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetCulture( 
-            /* [annotation][out] */ 
-            __out  LPWSTR wzCulture,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetReferenceVersion( 
-            /* [annotation][out] */ 
-            __out  LPWSTR wzVerRef,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetActivationDate( 
-            /* [annotation][out] */ 
-            __out  LPWSTR wzActivationDate,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetAppCfgVersion( 
-            /* [annotation][out] */ 
-            __out  LPWSTR pwzVerAppCfg,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetPublisherCfgVersion( 
-            /* [annotation][out] */ 
-            __out  LPWSTR pwzVerPublisherCfg,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetAdminCfgVersion( 
-            /* [annotation][out] */ 
-            __out  LPWSTR pwzAdminCfg,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct IHistoryAssemblyVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            IHistoryAssembly * This,
-            /* [in] */ REFIID riid,
-            /* [annotation][iid_is][out] */ 
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            IHistoryAssembly * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            IHistoryAssembly * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetAssemblyName )( 
-            IHistoryAssembly * This,
-            /* [annotation][out] */ 
-            __out  LPWSTR wzAsmName,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetPublicKeyToken )( 
-            IHistoryAssembly * This,
-            /* [annotation][out] */ 
-            __out  LPWSTR wzPublicKeyToken,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetCulture )( 
-            IHistoryAssembly * This,
-            /* [annotation][out] */ 
-            __out  LPWSTR wzCulture,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetReferenceVersion )( 
-            IHistoryAssembly * This,
-            /* [annotation][out] */ 
-            __out  LPWSTR wzVerRef,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetActivationDate )( 
-            IHistoryAssembly * This,
-            /* [annotation][out] */ 
-            __out  LPWSTR wzActivationDate,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetAppCfgVersion )( 
-            IHistoryAssembly * This,
-            /* [annotation][out] */ 
-            __out  LPWSTR pwzVerAppCfg,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetPublisherCfgVersion )( 
-            IHistoryAssembly * This,
-            /* [annotation][out] */ 
-            __out  LPWSTR pwzVerPublisherCfg,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetAdminCfgVersion )( 
-            IHistoryAssembly * This,
-            /* [annotation][out] */ 
-            __out  LPWSTR pwzAdminCfg,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize);
-        
-        END_INTERFACE
-    } IHistoryAssemblyVtbl;
-
-    interface IHistoryAssembly
-    {
-        CONST_VTBL struct IHistoryAssemblyVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define IHistoryAssembly_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define IHistoryAssembly_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define IHistoryAssembly_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define IHistoryAssembly_GetAssemblyName(This,wzAsmName,pdwSize)	\
-    ( (This)->lpVtbl -> GetAssemblyName(This,wzAsmName,pdwSize) ) 
-
-#define IHistoryAssembly_GetPublicKeyToken(This,wzPublicKeyToken,pdwSize)	\
-    ( (This)->lpVtbl -> GetPublicKeyToken(This,wzPublicKeyToken,pdwSize) ) 
-
-#define IHistoryAssembly_GetCulture(This,wzCulture,pdwSize)	\
-    ( (This)->lpVtbl -> GetCulture(This,wzCulture,pdwSize) ) 
-
-#define IHistoryAssembly_GetReferenceVersion(This,wzVerRef,pdwSize)	\
-    ( (This)->lpVtbl -> GetReferenceVersion(This,wzVerRef,pdwSize) ) 
-
-#define IHistoryAssembly_GetActivationDate(This,wzActivationDate,pdwSize)	\
-    ( (This)->lpVtbl -> GetActivationDate(This,wzActivationDate,pdwSize) ) 
-
-#define IHistoryAssembly_GetAppCfgVersion(This,pwzVerAppCfg,pdwSize)	\
-    ( (This)->lpVtbl -> GetAppCfgVersion(This,pwzVerAppCfg,pdwSize) ) 
-
-#define IHistoryAssembly_GetPublisherCfgVersion(This,pwzVerPublisherCfg,pdwSize)	\
-    ( (This)->lpVtbl -> GetPublisherCfgVersion(This,pwzVerPublisherCfg,pdwSize) ) 
-
-#define IHistoryAssembly_GetAdminCfgVersion(This,pwzAdminCfg,pdwSize)	\
-    ( (This)->lpVtbl -> GetAdminCfgVersion(This,pwzAdminCfg,pdwSize) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __IHistoryAssembly_INTERFACE_DEFINED__ */
-
-
-#ifndef __IHistoryReader_INTERFACE_DEFINED__
-#define __IHistoryReader_INTERFACE_DEFINED__
-
-/* interface IHistoryReader */
-/* [unique][uuid][object][local] */ 
-
-
-EXTERN_C const IID IID_IHistoryReader;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("1d23df4d-a1e2-4b8b-93d6-6ea3dc285a54")
-    IHistoryReader : public IUnknown
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE GetFilePath( 
-            /* [annotation][out] */ 
-            __out  LPWSTR wzFilePath,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetApplicationName( 
-            /* [annotation][out] */ 
-            __out  LPWSTR wzAppName,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetEXEModulePath( 
-            /* [annotation][out] */ 
-            __out  LPWSTR wzExePath,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetNumActivations( 
-            /* [out] */ DWORD *pdwNumActivations) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetActivationDate( 
-            /* [in] */ DWORD dwIdx,
-            /* [out] */ FILETIME *pftDate) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetRunTimeVersion( 
-            /* [in] */ FILETIME *pftActivationDate,
-            /* [annotation][out] */ 
-            __out  LPWSTR wzRunTimeVersion,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetNumAssemblies( 
-            /* [in] */ FILETIME *pftActivationDate,
-            /* [out] */ DWORD *pdwNumAsms) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetHistoryAssembly( 
-            /* [in] */ FILETIME *pftActivationDate,
-            /* [in] */ DWORD dwIdx,
-            /* [out] */ IHistoryAssembly **ppHistAsm) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct IHistoryReaderVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            IHistoryReader * This,
-            /* [in] */ REFIID riid,
-            /* [annotation][iid_is][out] */ 
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            IHistoryReader * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            IHistoryReader * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetFilePath )( 
-            IHistoryReader * This,
-            /* [annotation][out] */ 
-            __out  LPWSTR wzFilePath,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetApplicationName )( 
-            IHistoryReader * This,
-            /* [annotation][out] */ 
-            __out  LPWSTR wzAppName,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetEXEModulePath )( 
-            IHistoryReader * This,
-            /* [annotation][out] */ 
-            __out  LPWSTR wzExePath,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetNumActivations )( 
-            IHistoryReader * This,
-            /* [out] */ DWORD *pdwNumActivations);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetActivationDate )( 
-            IHistoryReader * This,
-            /* [in] */ DWORD dwIdx,
-            /* [out] */ FILETIME *pftDate);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetRunTimeVersion )( 
-            IHistoryReader * This,
-            /* [in] */ FILETIME *pftActivationDate,
-            /* [annotation][out] */ 
-            __out  LPWSTR wzRunTimeVersion,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pdwSize);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetNumAssemblies )( 
-            IHistoryReader * This,
-            /* [in] */ FILETIME *pftActivationDate,
-            /* [out] */ DWORD *pdwNumAsms);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetHistoryAssembly )( 
-            IHistoryReader * This,
-            /* [in] */ FILETIME *pftActivationDate,
-            /* [in] */ DWORD dwIdx,
-            /* [out] */ IHistoryAssembly **ppHistAsm);
-        
-        END_INTERFACE
-    } IHistoryReaderVtbl;
-
-    interface IHistoryReader
-    {
-        CONST_VTBL struct IHistoryReaderVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define IHistoryReader_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define IHistoryReader_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define IHistoryReader_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define IHistoryReader_GetFilePath(This,wzFilePath,pdwSize)	\
-    ( (This)->lpVtbl -> GetFilePath(This,wzFilePath,pdwSize) ) 
-
-#define IHistoryReader_GetApplicationName(This,wzAppName,pdwSize)	\
-    ( (This)->lpVtbl -> GetApplicationName(This,wzAppName,pdwSize) ) 
-
-#define IHistoryReader_GetEXEModulePath(This,wzExePath,pdwSize)	\
-    ( (This)->lpVtbl -> GetEXEModulePath(This,wzExePath,pdwSize) ) 
-
-#define IHistoryReader_GetNumActivations(This,pdwNumActivations)	\
-    ( (This)->lpVtbl -> GetNumActivations(This,pdwNumActivations) ) 
-
-#define IHistoryReader_GetActivationDate(This,dwIdx,pftDate)	\
-    ( (This)->lpVtbl -> GetActivationDate(This,dwIdx,pftDate) ) 
-
-#define IHistoryReader_GetRunTimeVersion(This,pftActivationDate,wzRunTimeVersion,pdwSize)	\
-    ( (This)->lpVtbl -> GetRunTimeVersion(This,pftActivationDate,wzRunTimeVersion,pdwSize) ) 
-
-#define IHistoryReader_GetNumAssemblies(This,pftActivationDate,pdwNumAsms)	\
-    ( (This)->lpVtbl -> GetNumAssemblies(This,pftActivationDate,pdwNumAsms) ) 
-
-#define IHistoryReader_GetHistoryAssembly(This,pftActivationDate,dwIdx,ppHistAsm)	\
-    ( (This)->lpVtbl -> GetHistoryAssembly(This,pftActivationDate,dwIdx,ppHistAsm) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __IHistoryReader_INTERFACE_DEFINED__ */
-
-
-/* interface __MIDL_itf_fusionpriv_0000_0002 */
-/* [local] */ 
-
-typedef /* [public][public][public] */ 
-enum __MIDL___MIDL_itf_fusionpriv_0000_0002_0001
-    {
-        LOADCTX_TYPE_DEFAULT	= 0,
-        LOADCTX_TYPE_LOADFROM	= ( LOADCTX_TYPE_DEFAULT + 1 ) ,
-        LOADCTX_TYPE_UNKNOWN	= ( LOADCTX_TYPE_LOADFROM + 1 ) ,
-        LOADCTX_TYPE_HOSTED	= ( LOADCTX_TYPE_UNKNOWN + 1 ) 
-    } 	LOADCTX_TYPE;
-
-#define FUSION_BIND_LOG_CATEGORY_DEFAULT       0
-#define FUSION_BIND_LOG_CATEGORY_NGEN          1
-#define FUSION_BIND_LOG_CATEGORY_MAX           2
-
-
-extern RPC_IF_HANDLE __MIDL_itf_fusionpriv_0000_0002_v0_0_c_ifspec;
-extern RPC_IF_HANDLE __MIDL_itf_fusionpriv_0000_0002_v0_0_s_ifspec;
-
-#ifndef __IFusionBindLog_INTERFACE_DEFINED__
-#define __IFusionBindLog_INTERFACE_DEFINED__
-
-/* interface IFusionBindLog */
-/* [unique][uuid][object][local] */ 
-
-
-EXTERN_C const IID IID_IFusionBindLog;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("67E9F87D-8B8A-4a90-9D3E-85ED5B2DCC83")
-    IFusionBindLog : public IUnknown
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE SetResultCode( 
-            /* [in] */ DWORD dwLogCategory,
-            /* [in] */ HRESULT hr) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetResultCode( 
-            /* [in] */ DWORD dwLogCategory,
-            /* [out] */ HRESULT *pHr) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetBindLog( 
-            /* [in] */ DWORD dwDetailLevel,
-            /* [in] */ DWORD dwLogCategory,
-            /* [annotation][out] */ 
-            __out_opt  LPWSTR pwzDebugLog,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pcbDebugLog) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE LogMessage( 
-            /* [in] */ DWORD dwDetailLevel,
-            /* [in] */ DWORD dwLogCategory,
-            /* [in] */ LPCWSTR pwzDebugLog) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE Flush( 
-            /* [in] */ DWORD dwDetailLevel,
-            /* [in] */ DWORD dwLogCategory) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetBindingID( 
-            /* [out] */ ULONGLONG *pullBindingID) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE ETWTraceLogMessage( 
-            /* [in] */ DWORD dwETWLogCategory,
-            /* [in] */ IAssemblyName *pAsm) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct IFusionBindLogVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            IFusionBindLog * This,
-            /* [in] */ REFIID riid,
-            /* [annotation][iid_is][out] */ 
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            IFusionBindLog * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            IFusionBindLog * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetResultCode )( 
-            IFusionBindLog * This,
-            /* [in] */ DWORD dwLogCategory,
-            /* [in] */ HRESULT hr);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetResultCode )( 
-            IFusionBindLog * This,
-            /* [in] */ DWORD dwLogCategory,
-            /* [out] */ HRESULT *pHr);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetBindLog )( 
-            IFusionBindLog * This,
-            /* [in] */ DWORD dwDetailLevel,
-            /* [in] */ DWORD dwLogCategory,
-            /* [annotation][out] */ 
-            __out_opt  LPWSTR pwzDebugLog,
-            /* [annotation][out][in] */ 
-            __inout  DWORD *pcbDebugLog);
-        
-        HRESULT ( STDMETHODCALLTYPE *LogMessage )( 
-            IFusionBindLog * This,
-            /* [in] */ DWORD dwDetailLevel,
-            /* [in] */ DWORD dwLogCategory,
-            /* [in] */ LPCWSTR pwzDebugLog);
-        
-        HRESULT ( STDMETHODCALLTYPE *Flush )( 
-            IFusionBindLog * This,
-            /* [in] */ DWORD dwDetailLevel,
-            /* [in] */ DWORD dwLogCategory);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetBindingID )( 
-            IFusionBindLog * This,
-            /* [out] */ ULONGLONG *pullBindingID);
-        
-        HRESULT ( STDMETHODCALLTYPE *ETWTraceLogMessage )( 
-            IFusionBindLog * This,
-            /* [in] */ DWORD dwETWLogCategory,
-            /* [in] */ IAssemblyName *pAsm);
-        
-        END_INTERFACE
-    } IFusionBindLogVtbl;
-
-    interface IFusionBindLog
-    {
-        CONST_VTBL struct IFusionBindLogVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define IFusionBindLog_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define IFusionBindLog_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define IFusionBindLog_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define IFusionBindLog_SetResultCode(This,dwLogCategory,hr)	\
-    ( (This)->lpVtbl -> SetResultCode(This,dwLogCategory,hr) ) 
-
-#define IFusionBindLog_GetResultCode(This,dwLogCategory,pHr)	\
-    ( (This)->lpVtbl -> GetResultCode(This,dwLogCategory,pHr) ) 
-
-#define IFusionBindLog_GetBindLog(This,dwDetailLevel,dwLogCategory,pwzDebugLog,pcbDebugLog)	\
-    ( (This)->lpVtbl -> GetBindLog(This,dwDetailLevel,dwLogCategory,pwzDebugLog,pcbDebugLog) ) 
-
-#define IFusionBindLog_LogMessage(This,dwDetailLevel,dwLogCategory,pwzDebugLog)	\
-    ( (This)->lpVtbl -> LogMessage(This,dwDetailLevel,dwLogCategory,pwzDebugLog) ) 
-
-#define IFusionBindLog_Flush(This,dwDetailLevel,dwLogCategory)	\
-    ( (This)->lpVtbl -> Flush(This,dwDetailLevel,dwLogCategory) ) 
-
-#define IFusionBindLog_GetBindingID(This,pullBindingID)	\
-    ( (This)->lpVtbl -> GetBindingID(This,pullBindingID) ) 
-
-#define IFusionBindLog_ETWTraceLogMessage(This,dwETWLogCategory,pAsm)	\
-    ( (This)->lpVtbl -> ETWTraceLogMessage(This,dwETWLogCategory,pAsm) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __IFusionBindLog_INTERFACE_DEFINED__ */
-
-
-#ifndef __IAssemblyManifestImport_INTERFACE_DEFINED__
-#define __IAssemblyManifestImport_INTERFACE_DEFINED__
-
-/* interface IAssemblyManifestImport */
-/* [unique][uuid][object][local] */ 
-
-typedef /* [unique] */ IAssemblyManifestImport *LPASSEMBLY_MANIFEST_IMPORT;
-
-
-EXTERN_C const IID IID_IAssemblyManifestImport;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("de9a68ba-0fa2-11d3-94aa-00c04fc308ff")
-    IAssemblyManifestImport : public IUnknown
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE GetAssemblyNameDef( 
-            /* [out] */ IAssemblyName **ppAssemblyName) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetNextAssemblyNameRef( 
-            /* [in] */ DWORD nIndex,
-            /* [out] */ IAssemblyName **ppAssemblyName) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetNextAssemblyModule( 
-            /* [in] */ DWORD nIndex,
-            /* [out] */ IAssemblyModuleImport **ppImport) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetModuleByName( 
-            /* [in] */ LPCOLESTR szModuleName,
-            /* [out] */ IAssemblyModuleImport **ppModImport) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetManifestModulePath( 
-            /* [annotation][size_is][out] */ 
-            __out_ecount_full(*pccModulePath)  LPOLESTR szModulePath,
-            /* [out][in] */ LPDWORD pccModulePath) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetInternalMDImport( 
-            /* [out] */ IMetaDataAssemblyImport **ppMDImport) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE LoadDataFromMDImport( 
-            /* [in] */ IMetaDataAssemblyImport *ppMDImport) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct IAssemblyManifestImportVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            IAssemblyManifestImport * This,
-            /* [in] */ REFIID riid,
-            /* [annotation][iid_is][out] */ 
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            IAssemblyManifestImport * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            IAssemblyManifestImport * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetAssemblyNameDef )( 
-            IAssemblyManifestImport * This,
-            /* [out] */ IAssemblyName **ppAssemblyName);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetNextAssemblyNameRef )( 
-            IAssemblyManifestImport * This,
-            /* [in] */ DWORD nIndex,
-            /* [out] */ IAssemblyName **ppAssemblyName);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetNextAssemblyModule )( 
-            IAssemblyManifestImport * This,
-            /* [in] */ DWORD nIndex,
-            /* [out] */ IAssemblyModuleImport **ppImport);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetModuleByName )( 
-            IAssemblyManifestImport * This,
-            /* [in] */ LPCOLESTR szModuleName,
-            /* [out] */ IAssemblyModuleImport **ppModImport);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetManifestModulePath )( 
-            IAssemblyManifestImport * This,
-            /* [annotation][size_is][out] */ 
-            __out_ecount_full(*pccModulePath)  LPOLESTR szModulePath,
-            /* [out][in] */ LPDWORD pccModulePath);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetInternalMDImport )( 
-            IAssemblyManifestImport * This,
-            /* [out] */ IMetaDataAssemblyImport **ppMDImport);
-        
-        HRESULT ( STDMETHODCALLTYPE *LoadDataFromMDImport )( 
-            IAssemblyManifestImport * This,
-            /* [in] */ IMetaDataAssemblyImport *ppMDImport);
-        
-        END_INTERFACE
-    } IAssemblyManifestImportVtbl;
-
-    interface IAssemblyManifestImport
-    {
-        CONST_VTBL struct IAssemblyManifestImportVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define IAssemblyManifestImport_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define IAssemblyManifestImport_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define IAssemblyManifestImport_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define IAssemblyManifestImport_GetAssemblyNameDef(This,ppAssemblyName)	\
-    ( (This)->lpVtbl -> GetAssemblyNameDef(This,ppAssemblyName) ) 
-
-#define IAssemblyManifestImport_GetNextAssemblyNameRef(This,nIndex,ppAssemblyName)	\
-    ( (This)->lpVtbl -> GetNextAssemblyNameRef(This,nIndex,ppAssemblyName) ) 
-
-#define IAssemblyManifestImport_GetNextAssemblyModule(This,nIndex,ppImport)	\
-    ( (This)->lpVtbl -> GetNextAssemblyModule(This,nIndex,ppImport) ) 
-
-#define IAssemblyManifestImport_GetModuleByName(This,szModuleName,ppModImport)	\
-    ( (This)->lpVtbl -> GetModuleByName(This,szModuleName,ppModImport) ) 
-
-#define IAssemblyManifestImport_GetManifestModulePath(This,szModulePath,pccModulePath)	\
-    ( (This)->lpVtbl -> GetManifestModulePath(This,szModulePath,pccModulePath) ) 
-
-#define IAssemblyManifestImport_GetInternalMDImport(This,ppMDImport)	\
-    ( (This)->lpVtbl -> GetInternalMDImport(This,ppMDImport) ) 
-
-#define IAssemblyManifestImport_LoadDataFromMDImport(This,ppMDImport)	\
-    ( (This)->lpVtbl -> LoadDataFromMDImport(This,ppMDImport) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __IAssemblyManifestImport_INTERFACE_DEFINED__ */
-
-
-#ifndef __IApplicationContext_INTERFACE_DEFINED__
-#define __IApplicationContext_INTERFACE_DEFINED__
-
-/* interface IApplicationContext */
-/* [unique][uuid][object][local] */ 
-
-// App context configuration variables
-#define ACTAG_APP_BASE_URL            L"APPBASE"
-#define ACTAG_MACHINE_CONFIG          L"MACHINE_CONFIG"
-#define ACTAG_APP_PRIVATE_BINPATH     L"PRIVATE_BINPATH"
-#define ACTAG_APP_SHARED_BINPATH      L"SHARED_BINPATH"
-#define ACTAG_APP_SNAPSHOT_ID         L"SNAPSHOT_ID"
-#define ACTAG_APP_CONFIG_FILE         L"APP_CONFIG_FILE"
-#define ACTAG_APP_ID                  L"APPLICATION_ID"
-#define ACTAG_APP_SHADOW_COPY_DIRS    L"SHADOW_COPY_DIRS"
-#define ACTAG_APP_DYNAMIC_BASE        L"DYNAMIC_BASE"
-#define ACTAG_APP_CACHE_BASE          L"CACHE_BASE"
-#define ACTAG_APP_NAME                L"APP_NAME"
-#define ACTAG_DEV_PATH                L"DEV_PATH"
-#define ACTAG_HOST_CONFIG_FILE        L"HOST_CONFIG"
-#define ACTAG_SXS_ACTIVATION_CONTEXT  L"SXS"
-#define ACTAG_APP_CFG_LOCAL_FILEPATH  L"APP_CFG_LOCAL_FILEPATH"
-#define ACTAG_ZAP_STRING              L"ZAP_STRING"
-#define ACTAG_ZAP_CONFIG_FLAGS        L"ZAP_CONFIG_FLAGS"
-#define ACTAG_APP_DOMAIN_ID           L"APPDOMAIN_ID"
-#define ACTAG_APP_CONFIG_BLOB         L"APP_CONFIG_BLOB"
-#define ACTAG_FX_ONLY                 L"FX_ONLY"
-// App context flag overrides
-#define ACTAG_FORCE_CACHE_INSTALL     L"FORCE_CACHE_INSTALL"
-#define ACTAG_RFS_INTEGRITY_CHECK     L"RFS_INTEGRITY_CHECK"
-#define ACTAG_RFS_MODULE_CHECK        L"RFS_MODULE_CHECK"
-#define ACTAG_BINPATH_PROBE_ONLY      L"BINPATH_PROBE_ONLY"
-#define ACTAG_DISALLOW_APPLYPUBLISHERPOLICY  L"DISALLOW_APP"
-#define ACTAG_DISALLOW_APP_BINDING_REDIRECTS  L"DISALLOW_APP_REDIRECTS"
-#define ACTAG_DISALLOW_APP_BASE_PROBING L"DISALLOW_APP_BASE_PROBING"
-#define ACTAG_CODE_DOWNLOAD_DISABLED  L"CODE_DOWNLOAD_DISABLED"
-#define ACTAG_DISABLE_FX_ASM_UNIFICATION  L"DISABLE_FX_ASM_UNIFICATION"
-typedef /* [unique] */ IApplicationContext *LPAPPLICATIONCONTEXT;
-
-typedef /* [public] */ 
-enum __MIDL_IApplicationContext_0001
-    {
-        APP_CTX_FLAGS_INTERFACE	= 0x1
-    } 	APP_FLAGS;
-
-
-EXTERN_C const IID IID_IApplicationContext;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("7c23ff90-33af-11d3-95da-00a024a85b51")
-    IApplicationContext : public IUnknown
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE SetContextNameObject( 
-            /* [in] */ LPASSEMBLYNAME pName) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetContextNameObject( 
-            /* [out] */ LPASSEMBLYNAME *ppName) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE Set( 
-            /* [in] */ LPCOLESTR szName,
-            /* [in] */ LPVOID pvValue,
-            /* [in] */ DWORD cbValue,
-            /* [in] */ DWORD dwFlags) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE Get( 
-            /* [in] */ LPCOLESTR szName,
-            /* [out] */ LPVOID pvValue,
-            /* [out][in] */ LPDWORD pcbValue,
-            /* [in] */ DWORD dwFlags) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetDynamicDirectory( 
-            /* [annotation][out] */ 
-            __out_ecount_opt(*pdwSize)  LPWSTR wzDynamicDir,
-            /* [out][in] */ LPDWORD pdwSize) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetAppCacheDirectory( 
-            /* [annotation][out] */ 
-            __out_ecount_opt(*pdwSize)  LPWSTR wzAppCacheDir,
-            /* [out][in] */ LPDWORD pdwSize) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE RegisterKnownAssembly( 
-            /* [in] */ IAssemblyName *pName,
-            /* [in] */ LPCWSTR pwzAsmURL,
-            /* [out] */ IAssembly **ppAsmOut) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE PrefetchAppConfigFile( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetAssemblyBindingClosure( 
-            /* [in] */ IUnknown *pUnk,
-            /* [in] */ LPCWSTR pwzNativeImagePath,
-            /* [out] */ IAssemblyBindingClosure **ppAsmClosure) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct IApplicationContextVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            IApplicationContext * This,
-            /* [in] */ REFIID riid,
-            /* [annotation][iid_is][out] */ 
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            IApplicationContext * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            IApplicationContext * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetContextNameObject )( 
-            IApplicationContext * This,
-            /* [in] */ LPASSEMBLYNAME pName);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetContextNameObject )( 
-            IApplicationContext * This,
-            /* [out] */ LPASSEMBLYNAME *ppName);
-        
-        HRESULT ( STDMETHODCALLTYPE *Set )( 
-            IApplicationContext * This,
-            /* [in] */ LPCOLESTR szName,
-            /* [in] */ LPVOID pvValue,
-            /* [in] */ DWORD cbValue,
-            /* [in] */ DWORD dwFlags);
-        
-        HRESULT ( STDMETHODCALLTYPE *Get )( 
-            IApplicationContext * This,
-            /* [in] */ LPCOLESTR szName,
-            /* [out] */ LPVOID pvValue,
-            /* [out][in] */ LPDWORD pcbValue,
-            /* [in] */ DWORD dwFlags);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetDynamicDirectory )( 
-            IApplicationContext * This,
-            /* [annotation][out] */ 
-            __out_ecount_opt(*pdwSize)  LPWSTR wzDynamicDir,
-            /* [out][in] */ LPDWORD pdwSize);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetAppCacheDirectory )( 
-            IApplicationContext * This,
-            /* [annotation][out] */ 
-            __out_ecount_opt(*pdwSize)  LPWSTR wzAppCacheDir,
-            /* [out][in] */ LPDWORD pdwSize);
-        
-        HRESULT ( STDMETHODCALLTYPE *RegisterKnownAssembly )( 
-            IApplicationContext * This,
-            /* [in] */ IAssemblyName *pName,
-            /* [in] */ LPCWSTR pwzAsmURL,
-            /* [out] */ IAssembly **ppAsmOut);
-        
-        HRESULT ( STDMETHODCALLTYPE *PrefetchAppConfigFile )( 
-            IApplicationContext * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetAssemblyBindingClosure )( 
-            IApplicationContext * This,
-            /* [in] */ IUnknown *pUnk,
-            /* [in] */ LPCWSTR pwzNativeImagePath,
-            /* [out] */ IAssemblyBindingClosure **ppAsmClosure);
-        
-        END_INTERFACE
-    } IApplicationContextVtbl;
-
-    interface IApplicationContext
-    {
-        CONST_VTBL struct IApplicationContextVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define IApplicationContext_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define IApplicationContext_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define IApplicationContext_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define IApplicationContext_SetContextNameObject(This,pName)	\
-    ( (This)->lpVtbl -> SetContextNameObject(This,pName) ) 
-
-#define IApplicationContext_GetContextNameObject(This,ppName)	\
-    ( (This)->lpVtbl -> GetContextNameObject(This,ppName) ) 
-
-#define IApplicationContext_Set(This,szName,pvValue,cbValue,dwFlags)	\
-    ( (This)->lpVtbl -> Set(This,szName,pvValue,cbValue,dwFlags) ) 
-
-#define IApplicationContext_Get(This,szName,pvValue,pcbValue,dwFlags)	\
-    ( (This)->lpVtbl -> Get(This,szName,pvValue,pcbValue,dwFlags) ) 
-
-#define IApplicationContext_GetDynamicDirectory(This,wzDynamicDir,pdwSize)	\
-    ( (This)->lpVtbl -> GetDynamicDirectory(This,wzDynamicDir,pdwSize) ) 
-
-#define IApplicationContext_GetAppCacheDirectory(This,wzAppCacheDir,pdwSize)	\
-    ( (This)->lpVtbl -> GetAppCacheDirectory(This,wzAppCacheDir,pdwSize) ) 
-
-#define IApplicationContext_RegisterKnownAssembly(This,pName,pwzAsmURL,ppAsmOut)	\
-    ( (This)->lpVtbl -> RegisterKnownAssembly(This,pName,pwzAsmURL,ppAsmOut) ) 
-
-#define IApplicationContext_PrefetchAppConfigFile(This)	\
-    ( (This)->lpVtbl -> PrefetchAppConfigFile(This) ) 
-
-#define IApplicationContext_GetAssemblyBindingClosure(This,pUnk,pwzNativeImagePath,ppAsmClosure)	\
-    ( (This)->lpVtbl -> GetAssemblyBindingClosure(This,pUnk,pwzNativeImagePath,ppAsmClosure) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __IApplicationContext_INTERFACE_DEFINED__ */
-
-
-#ifndef __IAssemblyNameBinder_INTERFACE_DEFINED__
-#define __IAssemblyNameBinder_INTERFACE_DEFINED__
-
-/* interface IAssemblyNameBinder */
-/* [unique][uuid][object][local] */ 
-
-
-EXTERN_C const IID IID_IAssemblyNameBinder;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("56972d9d-0f6c-47de-a038-e82d5de3a777")
-    IAssemblyNameBinder : public IUnknown
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE BindToObject( 
-            /* [in] */ REFIID refIID,
-            /* [in] */ IUnknown *pUnkSink,
-            /* [in] */ IUnknown *pUnkContext,
-            /* [in] */ LPCOLESTR szCodeBase,
-            /* [in] */ LONGLONG llFlags,
-            /* [in] */ LPVOID pParentAssembly,
-            /* [in] */ DWORD cbReserved,
-            /* [out] */ LPVOID *ppv,
-            /* [out] */ LPVOID *ppvNI) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct IAssemblyNameBinderVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            IAssemblyNameBinder * This,
-            /* [in] */ REFIID riid,
-            /* [annotation][iid_is][out] */ 
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            IAssemblyNameBinder * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            IAssemblyNameBinder * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *BindToObject )( 
-            IAssemblyNameBinder * This,
-            /* [in] */ REFIID refIID,
-            /* [in] */ IUnknown *pUnkSink,
-            /* [in] */ IUnknown *pUnkContext,
-            /* [in] */ LPCOLESTR szCodeBase,
-            /* [in] */ LONGLONG llFlags,
-            /* [in] */ LPVOID pParentAssembly,
-            /* [in] */ DWORD cbReserved,
-            /* [out] */ LPVOID *ppv,
-            /* [out] */ LPVOID *ppvNI);
-        
-        END_INTERFACE
-    } IAssemblyNameBinderVtbl;
-
-    interface IAssemblyNameBinder
-    {
-        CONST_VTBL struct IAssemblyNameBinderVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define IAssemblyNameBinder_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define IAssemblyNameBinder_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define IAssemblyNameBinder_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define IAssemblyNameBinder_BindToObject(This,refIID,pUnkSink,pUnkContext,szCodeBase,llFlags,pParentAssembly,cbReserved,ppv,ppvNI)	\
-    ( (This)->lpVtbl -> BindToObject(This,refIID,pUnkSink,pUnkContext,szCodeBase,llFlags,pParentAssembly,cbReserved,ppv,ppvNI) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __IAssemblyNameBinder_INTERFACE_DEFINED__ */
-
-
-#ifndef __IAssembly_INTERFACE_DEFINED__
-#define __IAssembly_INTERFACE_DEFINED__
-
-/* interface IAssembly */
-/* [unique][uuid][object][local] */ 
-
-typedef /* [unique] */ IAssembly *LPASSEMBLY;
-
-#define ASMLOC_LOCATION_MASK          0x0000001B
-#define ASMLOC_UNKNOWN                0x00000000
-#define ASMLOC_GAC                    0x00000001
-#define ASMLOC_DOWNLOAD_CACHE         0x00000002
-#define ASMLOC_RUN_FROM_SOURCE        0x00000003
-#define ASMLOC_CODEBASE_HINT          0x00000004
-#define ASMLOC_ZAP                    0x00000008
-#define ASMLOC_DEV_OVERRIDE           0x00000010
-
-EXTERN_C const IID IID_IAssembly;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("ff08d7d4-04c2-11d3-94aa-00c04fc308ff")
-    IAssembly : public IUnknown
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE GetAssemblyNameDef( 
-            /* [out] */ IAssemblyName **ppAssemblyName) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetNextAssemblyNameRef( 
-            /* [in] */ DWORD nIndex,
-            /* [out] */ IAssemblyName **ppAssemblyName) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetNextAssemblyModule( 
-            /* [in] */ DWORD nIndex,
-            /* [out] */ IAssemblyModuleImport **ppModImport) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetModuleByName( 
-            /* [in] */ LPCOLESTR szModuleName,
-            /* [out] */ IAssemblyModuleImport **ppModImport) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetManifestModulePath( 
-            /* [annotation][size_is][out] */ 
-            __out_ecount_full_opt(*pccModulePath)  LPOLESTR szModulePath,
-            /* [out][in] */ LPDWORD pccModulePath) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetAssemblyPath( 
-            /* [annotation][size_is][out] */ 
-            __out_ecount_full_opt(*lpcwBuffer)  LPOLESTR pStr,
-            /* [out][in] */ LPDWORD lpcwBuffer) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetAssemblyLocation( 
-            /* [out] */ DWORD *pdwAsmLocation) = 0;
-        
-        virtual LOADCTX_TYPE STDMETHODCALLTYPE GetFusionLoadContext( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetNextHardBoundDependency( 
-            /* [in] */ DWORD dwIndex,
-            /* [out] */ IAssembly **ppILAsm,
-            /* [out] */ IAssembly **ppNIAsm) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct IAssemblyVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            IAssembly * This,
-            /* [in] */ REFIID riid,
-            /* [annotation][iid_is][out] */ 
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            IAssembly * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            IAssembly * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetAssemblyNameDef )( 
-            IAssembly * This,
-            /* [out] */ IAssemblyName **ppAssemblyName);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetNextAssemblyNameRef )( 
-            IAssembly * This,
-            /* [in] */ DWORD nIndex,
-            /* [out] */ IAssemblyName **ppAssemblyName);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetNextAssemblyModule )( 
-            IAssembly * This,
-            /* [in] */ DWORD nIndex,
-            /* [out] */ IAssemblyModuleImport **ppModImport);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetModuleByName )( 
-            IAssembly * This,
-            /* [in] */ LPCOLESTR szModuleName,
-            /* [out] */ IAssemblyModuleImport **ppModImport);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetManifestModulePath )( 
-            IAssembly * This,
-            /* [annotation][size_is][out] */ 
-            __out_ecount_full_opt(*pccModulePath)  LPOLESTR szModulePath,
-            /* [out][in] */ LPDWORD pccModulePath);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetAssemblyPath )( 
-            IAssembly * This,
-            /* [annotation][size_is][out] */ 
-            __out_ecount_full_opt(*lpcwBuffer)  LPOLESTR pStr,
-            /* [out][in] */ LPDWORD lpcwBuffer);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetAssemblyLocation )( 
-            IAssembly * This,
-            /* [out] */ DWORD *pdwAsmLocation);
-        
-        LOADCTX_TYPE ( STDMETHODCALLTYPE *GetFusionLoadContext )( 
-            IAssembly * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetNextHardBoundDependency )( 
-            IAssembly * This,
-            /* [in] */ DWORD dwIndex,
-            /* [out] */ IAssembly **ppILAsm,
-            /* [out] */ IAssembly **ppNIAsm);
-        
-        END_INTERFACE
-    } IAssemblyVtbl;
-
-    interface IAssembly
-    {
-        CONST_VTBL struct IAssemblyVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define IAssembly_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define IAssembly_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define IAssembly_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define IAssembly_GetAssemblyNameDef(This,ppAssemblyName)	\
-    ( (This)->lpVtbl -> GetAssemblyNameDef(This,ppAssemblyName) ) 
-
-#define IAssembly_GetNextAssemblyNameRef(This,nIndex,ppAssemblyName)	\
-    ( (This)->lpVtbl -> GetNextAssemblyNameRef(This,nIndex,ppAssemblyName) ) 
-
-#define IAssembly_GetNextAssemblyModule(This,nIndex,ppModImport)	\
-    ( (This)->lpVtbl -> GetNextAssemblyModule(This,nIndex,ppModImport) ) 
-
-#define IAssembly_GetModuleByName(This,szModuleName,ppModImport)	\
-    ( (This)->lpVtbl -> GetModuleByName(This,szModuleName,ppModImport) ) 
-
-#define IAssembly_GetManifestModulePath(This,szModulePath,pccModulePath)	\
-    ( (This)->lpVtbl -> GetManifestModulePath(This,szModulePath,pccModulePath) ) 
-
-#define IAssembly_GetAssemblyPath(This,pStr,lpcwBuffer)	\
-    ( (This)->lpVtbl -> GetAssemblyPath(This,pStr,lpcwBuffer) ) 
-
-#define IAssembly_GetAssemblyLocation(This,pdwAsmLocation)	\
-    ( (This)->lpVtbl -> GetAssemblyLocation(This,pdwAsmLocation) ) 
-
-#define IAssembly_GetFusionLoadContext(This)	\
-    ( (This)->lpVtbl -> GetFusionLoadContext(This) ) 
-
-#define IAssembly_GetNextHardBoundDependency(This,dwIndex,ppILAsm,ppNIAsm)	\
-    ( (This)->lpVtbl -> GetNextHardBoundDependency(This,dwIndex,ppILAsm,ppNIAsm) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __IAssembly_INTERFACE_DEFINED__ */
-
-
-#ifndef __IAssemblyBindingClosureEnumerator_INTERFACE_DEFINED__
-#define __IAssemblyBindingClosureEnumerator_INTERFACE_DEFINED__
-
-/* interface IAssemblyBindingClosureEnumerator */
-/* [unique][uuid][object][local] */ 
-
-
-EXTERN_C const IID IID_IAssemblyBindingClosureEnumerator;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("b3f1e4ed-cb09-4b85-9a1b-6809582f1ebc")
-    IAssemblyBindingClosureEnumerator : public IUnknown
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE GetNextAssemblyPath( 
-            /* [out] */ LPCOLESTR *ppPath,
-            /* [out] */ LPCOLESTR *ppniPath) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct IAssemblyBindingClosureEnumeratorVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            IAssemblyBindingClosureEnumerator * This,
-            /* [in] */ REFIID riid,
-            /* [annotation][iid_is][out] */ 
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            IAssemblyBindingClosureEnumerator * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            IAssemblyBindingClosureEnumerator * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetNextAssemblyPath )( 
-            IAssemblyBindingClosureEnumerator * This,
-            /* [out] */ LPCOLESTR *ppPath,
-            /* [out] */ LPCOLESTR *ppniPath);
-        
-        END_INTERFACE
-    } IAssemblyBindingClosureEnumeratorVtbl;
-
-    interface IAssemblyBindingClosureEnumerator
-    {
-        CONST_VTBL struct IAssemblyBindingClosureEnumeratorVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define IAssemblyBindingClosureEnumerator_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define IAssemblyBindingClosureEnumerator_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define IAssemblyBindingClosureEnumerator_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define IAssemblyBindingClosureEnumerator_GetNextAssemblyPath(This,ppPath,ppniPath)	\
-    ( (This)->lpVtbl -> GetNextAssemblyPath(This,ppPath,ppniPath) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __IAssemblyBindingClosureEnumerator_INTERFACE_DEFINED__ */
-
-
-#ifndef __IAssemblyBindingClosure_INTERFACE_DEFINED__
-#define __IAssemblyBindingClosure_INTERFACE_DEFINED__
-
-/* interface IAssemblyBindingClosure */
-/* [unique][uuid][object][local] */ 
-
-
-EXTERN_C const IID IID_IAssemblyBindingClosure;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("415c226a-e513-41ba-9651-9c48e97aa5de")
-    IAssemblyBindingClosure : public IUnknown
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE IsAllAssembliesInGAC( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE IsEqual( 
-            /* [in] */ IAssemblyBindingClosure *pAssemblyClosure) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetNextFailureAssembly( 
-            /* [in] */ DWORD dwIndex,
-            /* [out] */ IAssemblyName **ppName,
-            /* [out] */ HRESULT *pHResult) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE EnsureWalked( 
-            /* [in] */ IUnknown *pStartingAssembly,
-            /* [in] */ IApplicationContext *pAppCtx,
-            /* [in] */ WALK_LEVEL level) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE EnumerateAssemblies( 
-            /* [out] */ IAssemblyBindingClosureEnumerator **ppEnumerator) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE HasBeenWalked( 
-            /* [in] */ WALK_LEVEL level) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE MayHaveUnknownDependencies( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE AddProfilerAssemblyReference( 
-            /* [in] */ LPVOID pbPublicKeyOrToken,
-            /* [in] */ ULONG cbPublicKeyOrToken,
-            /* [in] */ LPCWSTR szName,
-            /* [in] */ LPVOID pMetaData,
-            /* [in] */ void *pbHashValue,
-            /* [in] */ ULONG cbHashValue,
-            /* [in] */ DWORD dwAssemblyRefFlags,
-            /* [in] */ struct AssemblyReferenceClosureWalkContextForProfAPI *pContext) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct IAssemblyBindingClosureVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            IAssemblyBindingClosure * This,
-            /* [in] */ REFIID riid,
-            /* [annotation][iid_is][out] */ 
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            IAssemblyBindingClosure * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            IAssemblyBindingClosure * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *IsAllAssembliesInGAC )( 
-            IAssemblyBindingClosure * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *IsEqual )( 
-            IAssemblyBindingClosure * This,
-            /* [in] */ IAssemblyBindingClosure *pAssemblyClosure);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetNextFailureAssembly )( 
-            IAssemblyBindingClosure * This,
-            /* [in] */ DWORD dwIndex,
-            /* [out] */ IAssemblyName **ppName,
-            /* [out] */ HRESULT *pHResult);
-        
-        HRESULT ( STDMETHODCALLTYPE *EnsureWalked )( 
-            IAssemblyBindingClosure * This,
-            /* [in] */ IUnknown *pStartingAssembly,
-            /* [in] */ IApplicationContext *pAppCtx,
-            /* [in] */ WALK_LEVEL level);
-        
-        HRESULT ( STDMETHODCALLTYPE *EnumerateAssemblies )( 
-            IAssemblyBindingClosure * This,
-            /* [out] */ IAssemblyBindingClosureEnumerator **ppEnumerator);
-        
-        HRESULT ( STDMETHODCALLTYPE *HasBeenWalked )( 
-            IAssemblyBindingClosure * This,
-            /* [in] */ WALK_LEVEL level);
-        
-        HRESULT ( STDMETHODCALLTYPE *MayHaveUnknownDependencies )( 
-            IAssemblyBindingClosure * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *AddProfilerAssemblyReference )( 
-            IAssemblyBindingClosure * This,
-            /* [in] */ LPVOID pbPublicKeyOrToken,
-            /* [in] */ ULONG cbPublicKeyOrToken,
-            /* [in] */ LPCWSTR szName,
-            /* [in] */ LPVOID pMetaData,
-            /* [in] */ void *pbHashValue,
-            /* [in] */ ULONG cbHashValue,
-            /* [in] */ DWORD dwAssemblyRefFlags,
-            /* [in] */ struct AssemblyReferenceClosureWalkContextForProfAPI *pContext);
-        
-        END_INTERFACE
-    } IAssemblyBindingClosureVtbl;
-
-    interface IAssemblyBindingClosure
-    {
-        CONST_VTBL struct IAssemblyBindingClosureVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define IAssemblyBindingClosure_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define IAssemblyBindingClosure_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define IAssemblyBindingClosure_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define IAssemblyBindingClosure_IsAllAssembliesInGAC(This)	\
-    ( (This)->lpVtbl -> IsAllAssembliesInGAC(This) ) 
-
-#define IAssemblyBindingClosure_IsEqual(This,pAssemblyClosure)	\
-    ( (This)->lpVtbl -> IsEqual(This,pAssemblyClosure) ) 
-
-#define IAssemblyBindingClosure_GetNextFailureAssembly(This,dwIndex,ppName,pHResult)	\
-    ( (This)->lpVtbl -> GetNextFailureAssembly(This,dwIndex,ppName,pHResult) ) 
-
-#define IAssemblyBindingClosure_EnsureWalked(This,pStartingAssembly,pAppCtx,level)	\
-    ( (This)->lpVtbl -> EnsureWalked(This,pStartingAssembly,pAppCtx,level) ) 
-
-#define IAssemblyBindingClosure_EnumerateAssemblies(This,ppEnumerator)	\
-    ( (This)->lpVtbl -> EnumerateAssemblies(This,ppEnumerator) ) 
-
-#define IAssemblyBindingClosure_HasBeenWalked(This,level)	\
-    ( (This)->lpVtbl -> HasBeenWalked(This,level) ) 
-
-#define IAssemblyBindingClosure_MayHaveUnknownDependencies(This)	\
-    ( (This)->lpVtbl -> MayHaveUnknownDependencies(This) ) 
-
-#define IAssemblyBindingClosure_AddProfilerAssemblyReference(This,pbPublicKeyOrToken,cbPublicKeyOrToken,szName,pMetaData,pbHashValue,cbHashValue,dwAssemblyRefFlags,pContext)	\
-    ( (This)->lpVtbl -> AddProfilerAssemblyReference(This,pbPublicKeyOrToken,cbPublicKeyOrToken,szName,pMetaData,pbHashValue,cbHashValue,dwAssemblyRefFlags,pContext) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __IAssemblyBindingClosure_INTERFACE_DEFINED__ */
-
-
-#ifndef __IAssemblyBindSink_INTERFACE_DEFINED__
-#define __IAssemblyBindSink_INTERFACE_DEFINED__
-
-/* interface IAssemblyBindSink */
-/* [unique][uuid][object][local] */ 
-
-typedef /* [unique] */ IAssemblyBindSink *LPASSEMBLY_BIND_SINK;
-
-typedef struct _tagFusionBindInfo
-    {
-    IFusionBindLog *pdbglog;
-    IAssemblyName *pNamePolicy;
-    DWORD dwPoliciesApplied;
-    } 	FusionBindInfo;
-
-typedef /* [public] */ 
-enum __MIDL_IAssemblyBindSink_0001
-    {
-        ASM_NOTIFICATION_START	= 0,
-        ASM_NOTIFICATION_PROGRESS	= ( ASM_NOTIFICATION_START + 1 ) ,
-        ASM_NOTIFICATION_SUSPEND	= ( ASM_NOTIFICATION_PROGRESS + 1 ) ,
-        ASM_NOTIFICATION_ATTEMPT_NEXT_CODEBASE	= ( ASM_NOTIFICATION_SUSPEND + 1 ) ,
-        ASM_NOTIFICATION_BIND_INFO	= ( ASM_NOTIFICATION_ATTEMPT_NEXT_CODEBASE + 1 ) ,
-        ASM_NOTIFICATION_DONE	= ( ASM_NOTIFICATION_BIND_INFO + 1 ) ,
-        ASM_NOTIFICATION_NATIVE_IMAGE_DONE	= ( ASM_NOTIFICATION_DONE + 1 ) 
-    } 	ASM_NOTIFICATION;
-
-
-EXTERN_C const IID IID_IAssemblyBindSink;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("af0bc960-0b9a-11d3-95ca-00a024a85b51")
-    IAssemblyBindSink : public IUnknown
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE OnProgress( 
-            /* [in] */ DWORD dwNotification,
-            /* [in] */ HRESULT hrNotification,
-            /* [in] */ LPCWSTR szNotification,
-            /* [in] */ DWORD dwProgress,
-            /* [in] */ DWORD dwProgressMax,
-            /* [in] */ LPVOID pvBindInfo,
-            /* [in] */ IUnknown *pUnk) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct IAssemblyBindSinkVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            IAssemblyBindSink * This,
-            /* [in] */ REFIID riid,
-            /* [annotation][iid_is][out] */ 
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            IAssemblyBindSink * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            IAssemblyBindSink * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *OnProgress )( 
-            IAssemblyBindSink * This,
-            /* [in] */ DWORD dwNotification,
-            /* [in] */ HRESULT hrNotification,
-            /* [in] */ LPCWSTR szNotification,
-            /* [in] */ DWORD dwProgress,
-            /* [in] */ DWORD dwProgressMax,
-            /* [in] */ LPVOID pvBindInfo,
-            /* [in] */ IUnknown *pUnk);
-        
-        END_INTERFACE
-    } IAssemblyBindSinkVtbl;
-
-    interface IAssemblyBindSink
-    {
-        CONST_VTBL struct IAssemblyBindSinkVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define IAssemblyBindSink_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define IAssemblyBindSink_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define IAssemblyBindSink_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define IAssemblyBindSink_OnProgress(This,dwNotification,hrNotification,szNotification,dwProgress,dwProgressMax,pvBindInfo,pUnk)	\
-    ( (This)->lpVtbl -> OnProgress(This,dwNotification,hrNotification,szNotification,dwProgress,dwProgressMax,pvBindInfo,pUnk) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __IAssemblyBindSink_INTERFACE_DEFINED__ */
-
-
-#ifndef __IAssemblyBinding_INTERFACE_DEFINED__
-#define __IAssemblyBinding_INTERFACE_DEFINED__
-
-/* interface IAssemblyBinding */
-/* [unique][uuid][object][local] */ 
-
-typedef /* [unique] */ IAssemblyBinding *LPASSEMBLY_BINDINDING;
-
-
-EXTERN_C const IID IID_IAssemblyBinding;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("cfe52a80-12bd-11d3-95ca-00a024a85b51")
-    IAssemblyBinding : public IUnknown
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE Control( 
-            /* [in] */ HRESULT hrControl) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE DoDefaultUI( 
-            /* [in] */ HWND hWnd,
-            /* [in] */ DWORD dwFlags) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct IAssemblyBindingVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            IAssemblyBinding * This,
-            /* [in] */ REFIID riid,
-            /* [annotation][iid_is][out] */ 
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            IAssemblyBinding * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            IAssemblyBinding * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *Control )( 
-            IAssemblyBinding * This,
-            /* [in] */ HRESULT hrControl);
-        
-        HRESULT ( STDMETHODCALLTYPE *DoDefaultUI )( 
-            IAssemblyBinding * This,
-            /* [in] */ HWND hWnd,
-            /* [in] */ DWORD dwFlags);
-        
-        END_INTERFACE
-    } IAssemblyBindingVtbl;
-
-    interface IAssemblyBinding
-    {
-        CONST_VTBL struct IAssemblyBindingVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define IAssemblyBinding_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define IAssemblyBinding_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define IAssemblyBinding_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define IAssemblyBinding_Control(This,hrControl)	\
-    ( (This)->lpVtbl -> Control(This,hrControl) ) 
-
-#define IAssemblyBinding_DoDefaultUI(This,hWnd,dwFlags)	\
-    ( (This)->lpVtbl -> DoDefaultUI(This,hWnd,dwFlags) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __IAssemblyBinding_INTERFACE_DEFINED__ */
-
-
-#ifndef __IAssemblyModuleImport_INTERFACE_DEFINED__
-#define __IAssemblyModuleImport_INTERFACE_DEFINED__
-
-/* interface IAssemblyModuleImport */
-/* [unique][uuid][object][local] */ 
-
-typedef /* [unique] */ IAssemblyModuleImport *LPASSEMBLY_MODULE_IMPORT;
-
-
-EXTERN_C const IID IID_IAssemblyModuleImport;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("da0cd4b0-1117-11d3-95ca-00a024a85b51")
-    IAssemblyModuleImport : public IStream
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE GetModuleName( 
-            /* [annotation][size_is][out] */ 
-            __out_ecount_full_opt(*pccModuleName)  LPOLESTR szModuleName,
-            /* [out][in] */ LPDWORD pccModuleName) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetHashAlgId( 
-            /* [out] */ LPDWORD pdwHashAlgId) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetHashValue( 
-            /* [size_is][out] */ BYTE *pbHashValue,
-            /* [out][in] */ LPDWORD pcbHashValue) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetFlags( 
-            /* [out] */ LPDWORD pdwFlags) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetModulePath( 
-            /* [annotation][size_is][out] */ 
-            __out_ecount_full_opt(*pccModulePath)  LPOLESTR szModulePath,
-            /* [out][in] */ LPDWORD pccModulePath) = 0;
-        
-        virtual BOOL STDMETHODCALLTYPE IsAvailable( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE BindToObject( 
-            /* [in] */ IAssemblyBindSink *pBindSink,
-            /* [in] */ IApplicationContext *pAppCtx,
-            /* [in] */ LONGLONG llFlags,
-            /* [out] */ LPVOID *ppv) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct IAssemblyModuleImportVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            IAssemblyModuleImport * This,
-            /* [in] */ REFIID riid,
-            /* [annotation][iid_is][out] */ 
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            IAssemblyModuleImport * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            IAssemblyModuleImport * This);
-        
-        /* [local] */ HRESULT ( STDMETHODCALLTYPE *Read )( 
-            IAssemblyModuleImport * This,
-            /* [annotation] */ 
-            _Out_writes_bytes_to_(cb, *pcbRead)  void *pv,
-            /* [annotation][in] */ 
-            _In_  ULONG cb,
-            /* [annotation] */ 
-            _Out_opt_  ULONG *pcbRead);
-        
-        /* [local] */ HRESULT ( STDMETHODCALLTYPE *Write )( 
-            IAssemblyModuleImport * This,
-            /* [annotation] */ 
-            _In_reads_bytes_(cb)  const void *pv,
-            /* [annotation][in] */ 
-            _In_  ULONG cb,
-            /* [annotation] */ 
-            _Out_opt_  ULONG *pcbWritten);
-        
-        /* [local] */ HRESULT ( STDMETHODCALLTYPE *Seek )( 
-            IAssemblyModuleImport * This,
-            /* [in] */ LARGE_INTEGER dlibMove,
-            /* [in] */ DWORD dwOrigin,
-            /* [annotation] */ 
-            _Out_opt_  ULARGE_INTEGER *plibNewPosition);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetSize )( 
-            IAssemblyModuleImport * This,
-            /* [in] */ ULARGE_INTEGER libNewSize);
-        
-        /* [local] */ HRESULT ( STDMETHODCALLTYPE *CopyTo )( 
-            IAssemblyModuleImport * This,
-            /* [annotation][unique][in] */ 
-            _In_  IStream *pstm,
-            /* [in] */ ULARGE_INTEGER cb,
-            /* [annotation] */ 
-            _Out_opt_  ULARGE_INTEGER *pcbRead,
-            /* [annotation] */ 
-            _Out_opt_  ULARGE_INTEGER *pcbWritten);
-        
-        HRESULT ( STDMETHODCALLTYPE *Commit )( 
-            IAssemblyModuleImport * This,
-            /* [in] */ DWORD grfCommitFlags);
-        
-        HRESULT ( STDMETHODCALLTYPE *Revert )( 
-            IAssemblyModuleImport * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *LockRegion )( 
-            IAssemblyModuleImport * This,
-            /* [in] */ ULARGE_INTEGER libOffset,
-            /* [in] */ ULARGE_INTEGER cb,
-            /* [in] */ DWORD dwLockType);
-        
-        HRESULT ( STDMETHODCALLTYPE *UnlockRegion )( 
-            IAssemblyModuleImport * This,
-            /* [in] */ ULARGE_INTEGER libOffset,
-            /* [in] */ ULARGE_INTEGER cb,
-            /* [in] */ DWORD dwLockType);
-        
-        HRESULT ( STDMETHODCALLTYPE *Stat )( 
-            IAssemblyModuleImport * This,
-            /* [out] */ STATSTG *pstatstg,
-            /* [in] */ DWORD grfStatFlag);
-        
-        HRESULT ( STDMETHODCALLTYPE *Clone )( 
-            IAssemblyModuleImport * This,
-            /* [out] */ IStream **ppstm);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetModuleName )( 
-            IAssemblyModuleImport * This,
-            /* [annotation][size_is][out] */ 
-            __out_ecount_full_opt(*pccModuleName)  LPOLESTR szModuleName,
-            /* [out][in] */ LPDWORD pccModuleName);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetHashAlgId )( 
-            IAssemblyModuleImport * This,
-            /* [out] */ LPDWORD pdwHashAlgId);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetHashValue )( 
-            IAssemblyModuleImport * This,
-            /* [size_is][out] */ BYTE *pbHashValue,
-            /* [out][in] */ LPDWORD pcbHashValue);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetFlags )( 
-            IAssemblyModuleImport * This,
-            /* [out] */ LPDWORD pdwFlags);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetModulePath )( 
-            IAssemblyModuleImport * This,
-            /* [annotation][size_is][out] */ 
-            __out_ecount_full_opt(*pccModulePath)  LPOLESTR szModulePath,
-            /* [out][in] */ LPDWORD pccModulePath);
-        
-        BOOL ( STDMETHODCALLTYPE *IsAvailable )( 
-            IAssemblyModuleImport * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *BindToObject )( 
-            IAssemblyModuleImport * This,
-            /* [in] */ IAssemblyBindSink *pBindSink,
-            /* [in] */ IApplicationContext *pAppCtx,
-            /* [in] */ LONGLONG llFlags,
-            /* [out] */ LPVOID *ppv);
-        
-        END_INTERFACE
-    } IAssemblyModuleImportVtbl;
-
-    interface IAssemblyModuleImport
-    {
-        CONST_VTBL struct IAssemblyModuleImportVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define IAssemblyModuleImport_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define IAssemblyModuleImport_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define IAssemblyModuleImport_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define IAssemblyModuleImport_Read(This,pv,cb,pcbRead)	\
-    ( (This)->lpVtbl -> Read(This,pv,cb,pcbRead) ) 
-
-#define IAssemblyModuleImport_Write(This,pv,cb,pcbWritten)	\
-    ( (This)->lpVtbl -> Write(This,pv,cb,pcbWritten) ) 
-
-
-#define IAssemblyModuleImport_Seek(This,dlibMove,dwOrigin,plibNewPosition)	\
-    ( (This)->lpVtbl -> Seek(This,dlibMove,dwOrigin,plibNewPosition) ) 
-
-#define IAssemblyModuleImport_SetSize(This,libNewSize)	\
-    ( (This)->lpVtbl -> SetSize(This,libNewSize) ) 
-
-#define IAssemblyModuleImport_CopyTo(This,pstm,cb,pcbRead,pcbWritten)	\
-    ( (This)->lpVtbl -> CopyTo(This,pstm,cb,pcbRead,pcbWritten) ) 
-
-#define IAssemblyModuleImport_Commit(This,grfCommitFlags)	\
-    ( (This)->lpVtbl -> Commit(This,grfCommitFlags) ) 
-
-#define IAssemblyModuleImport_Revert(This)	\
-    ( (This)->lpVtbl -> Revert(This) ) 
-
-#define IAssemblyModuleImport_LockRegion(This,libOffset,cb,dwLockType)	\
-    ( (This)->lpVtbl -> LockRegion(This,libOffset,cb,dwLockType) ) 
-
-#define IAssemblyModuleImport_UnlockRegion(This,libOffset,cb,dwLockType)	\
-    ( (This)->lpVtbl -> UnlockRegion(This,libOffset,cb,dwLockType) ) 
-
-#define IAssemblyModuleImport_Stat(This,pstatstg,grfStatFlag)	\
-    ( (This)->lpVtbl -> Stat(This,pstatstg,grfStatFlag) ) 
-
-#define IAssemblyModuleImport_Clone(This,ppstm)	\
-    ( (This)->lpVtbl -> Clone(This,ppstm) ) 
-
-
-#define IAssemblyModuleImport_GetModuleName(This,szModuleName,pccModuleName)	\
-    ( (This)->lpVtbl -> GetModuleName(This,szModuleName,pccModuleName) ) 
-
-#define IAssemblyModuleImport_GetHashAlgId(This,pdwHashAlgId)	\
-    ( (This)->lpVtbl -> GetHashAlgId(This,pdwHashAlgId) ) 
-
-#define IAssemblyModuleImport_GetHashValue(This,pbHashValue,pcbHashValue)	\
-    ( (This)->lpVtbl -> GetHashValue(This,pbHashValue,pcbHashValue) ) 
-
-#define IAssemblyModuleImport_GetFlags(This,pdwFlags)	\
-    ( (This)->lpVtbl -> GetFlags(This,pdwFlags) ) 
-
-#define IAssemblyModuleImport_GetModulePath(This,szModulePath,pccModulePath)	\
-    ( (This)->lpVtbl -> GetModulePath(This,szModulePath,pccModulePath) ) 
-
-#define IAssemblyModuleImport_IsAvailable(This)	\
-    ( (This)->lpVtbl -> IsAvailable(This) ) 
-
-#define IAssemblyModuleImport_BindToObject(This,pBindSink,pAppCtx,llFlags,ppv)	\
-    ( (This)->lpVtbl -> BindToObject(This,pBindSink,pAppCtx,llFlags,ppv) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __IAssemblyModuleImport_INTERFACE_DEFINED__ */
-
-
-#ifndef __IAssemblyScavenger_INTERFACE_DEFINED__
-#define __IAssemblyScavenger_INTERFACE_DEFINED__
-
-/* interface IAssemblyScavenger */
-/* [unique][uuid][object][local] */ 
-
-
-EXTERN_C const IID IID_IAssemblyScavenger;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("21b8916c-f28e-11d2-a473-00ccff8ef448")
-    IAssemblyScavenger : public IUnknown
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE ScavengeAssemblyCache( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetCacheDiskQuotas( 
-            /* [out] */ DWORD *pdwZapQuotaInGAC,
-            /* [out] */ DWORD *pdwDownloadQuotaAdmin,
-            /* [out] */ DWORD *pdwDownloadQuotaUser) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE SetCacheDiskQuotas( 
-            /* [in] */ DWORD dwZapQuotaInGAC,
-            /* [in] */ DWORD dwDownloadQuotaAdmin,
-            /* [in] */ DWORD dwDownloadQuotaUser) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetCurrentCacheUsage( 
-            /* [out] */ DWORD *dwZapUsage,
-            /* [out] */ DWORD *dwDownloadUsage) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct IAssemblyScavengerVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            IAssemblyScavenger * This,
-            /* [in] */ REFIID riid,
-            /* [annotation][iid_is][out] */ 
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            IAssemblyScavenger * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            IAssemblyScavenger * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *ScavengeAssemblyCache )( 
-            IAssemblyScavenger * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetCacheDiskQuotas )( 
-            IAssemblyScavenger * This,
-            /* [out] */ DWORD *pdwZapQuotaInGAC,
-            /* [out] */ DWORD *pdwDownloadQuotaAdmin,
-            /* [out] */ DWORD *pdwDownloadQuotaUser);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetCacheDiskQuotas )( 
-            IAssemblyScavenger * This,
-            /* [in] */ DWORD dwZapQuotaInGAC,
-            /* [in] */ DWORD dwDownloadQuotaAdmin,
-            /* [in] */ DWORD dwDownloadQuotaUser);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetCurrentCacheUsage )( 
-            IAssemblyScavenger * This,
-            /* [out] */ DWORD *dwZapUsage,
-            /* [out] */ DWORD *dwDownloadUsage);
-        
-        END_INTERFACE
-    } IAssemblyScavengerVtbl;
-
-    interface IAssemblyScavenger
-    {
-        CONST_VTBL struct IAssemblyScavengerVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define IAssemblyScavenger_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define IAssemblyScavenger_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define IAssemblyScavenger_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define IAssemblyScavenger_ScavengeAssemblyCache(This)	\
-    ( (This)->lpVtbl -> ScavengeAssemblyCache(This) ) 
-
-#define IAssemblyScavenger_GetCacheDiskQuotas(This,pdwZapQuotaInGAC,pdwDownloadQuotaAdmin,pdwDownloadQuotaUser)	\
-    ( (This)->lpVtbl -> GetCacheDiskQuotas(This,pdwZapQuotaInGAC,pdwDownloadQuotaAdmin,pdwDownloadQuotaUser) ) 
-
-#define IAssemblyScavenger_SetCacheDiskQuotas(This,dwZapQuotaInGAC,dwDownloadQuotaAdmin,dwDownloadQuotaUser)	\
-    ( (This)->lpVtbl -> SetCacheDiskQuotas(This,dwZapQuotaInGAC,dwDownloadQuotaAdmin,dwDownloadQuotaUser) ) 
-
-#define IAssemblyScavenger_GetCurrentCacheUsage(This,dwZapUsage,dwDownloadUsage)	\
-    ( (This)->lpVtbl -> GetCurrentCacheUsage(This,dwZapUsage,dwDownloadUsage) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __IAssemblyScavenger_INTERFACE_DEFINED__ */
-
-
-#ifndef __ICodebaseList_INTERFACE_DEFINED__
-#define __ICodebaseList_INTERFACE_DEFINED__
-
-/* interface ICodebaseList */
-/* [unique][uuid][object][local] */ 
-
-
-EXTERN_C const IID IID_ICodebaseList;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("D8FB9BD6-3969-11d3-B4AF-00C04F8ECB26")
-    ICodebaseList : public IUnknown
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE AddCodebase( 
-            /* [in] */ LPCWSTR wzCodebase,
-            /* [in] */ DWORD dwFlags) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE RemoveCodebase( 
-            /* [in] */ DWORD dwIndex) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE RemoveAll( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetCount( 
-            /* [out] */ DWORD *pdwCount) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetCodebase( 
-            /* [in] */ DWORD dwIndex,
-            /* [out] */ DWORD *pdwFlags,
-            /* [annotation][out] */ 
-            __out_ecount_opt(*pcbCodebase)  LPWSTR wzCodebase,
-            /* [out][in] */ DWORD *pcbCodebase) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct ICodebaseListVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            ICodebaseList * This,
-            /* [in] */ REFIID riid,
-            /* [annotation][iid_is][out] */ 
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            ICodebaseList * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            ICodebaseList * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *AddCodebase )( 
-            ICodebaseList * This,
-            /* [in] */ LPCWSTR wzCodebase,
-            /* [in] */ DWORD dwFlags);
-        
-        HRESULT ( STDMETHODCALLTYPE *RemoveCodebase )( 
-            ICodebaseList * This,
-            /* [in] */ DWORD dwIndex);
-        
-        HRESULT ( STDMETHODCALLTYPE *RemoveAll )( 
-            ICodebaseList * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetCount )( 
-            ICodebaseList * This,
-            /* [out] */ DWORD *pdwCount);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetCodebase )( 
-            ICodebaseList * This,
-            /* [in] */ DWORD dwIndex,
-            /* [out] */ DWORD *pdwFlags,
-            /* [annotation][out] */ 
-            __out_ecount_opt(*pcbCodebase)  LPWSTR wzCodebase,
-            /* [out][in] */ DWORD *pcbCodebase);
-        
-        END_INTERFACE
-    } ICodebaseListVtbl;
-
-    interface ICodebaseList
-    {
-        CONST_VTBL struct ICodebaseListVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define ICodebaseList_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define ICodebaseList_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define ICodebaseList_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define ICodebaseList_AddCodebase(This,wzCodebase,dwFlags)	\
-    ( (This)->lpVtbl -> AddCodebase(This,wzCodebase,dwFlags) ) 
-
-#define ICodebaseList_RemoveCodebase(This,dwIndex)	\
-    ( (This)->lpVtbl -> RemoveCodebase(This,dwIndex) ) 
-
-#define ICodebaseList_RemoveAll(This)	\
-    ( (This)->lpVtbl -> RemoveAll(This) ) 
-
-#define ICodebaseList_GetCount(This,pdwCount)	\
-    ( (This)->lpVtbl -> GetCount(This,pdwCount) ) 
-
-#define ICodebaseList_GetCodebase(This,dwIndex,pdwFlags,wzCodebase,pcbCodebase)	\
-    ( (This)->lpVtbl -> GetCodebase(This,dwIndex,pdwFlags,wzCodebase,pcbCodebase) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __ICodebaseList_INTERFACE_DEFINED__ */
-
-
-#ifndef __IDownloadMgr_INTERFACE_DEFINED__
-#define __IDownloadMgr_INTERFACE_DEFINED__
-
-/* interface IDownloadMgr */
-/* [unique][uuid][object][local] */ 
-
-
-EXTERN_C const IID IID_IDownloadMgr;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("0A6F16F8-ACD7-11d3-B4ED-00C04F8ECB26")
-    IDownloadMgr : public IUnknown
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE PreDownloadCheck( 
-            /* [out] */ void **ppv,
-            /* [out] */ void **ppvNI) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE DoSetup( 
-            /* [in] */ LPCWSTR wzSourceUrl,
-            /* [in] */ LPCWSTR wzFilePath,
-            /* [in] */ const FILETIME *pftLastMod,
-            /* [out] */ IUnknown **ppUnk,
-            /* [out] */ IUnknown **ppAsmNI) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE ProbeFailed( 
-            /* [out] */ IUnknown **ppUnk) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE IsDuplicate( 
-            /* [out] */ IDownloadMgr *ppDLMgr) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE LogResult( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE DownloadEnabled( 
-            /* [out] */ BOOL *pbEnabled) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetBindInfo( 
-            /* [out] */ FusionBindInfo *pBindInfo) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE CacheBindingResult( 
-            /* [in] */ HRESULT hrResult) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct IDownloadMgrVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            IDownloadMgr * This,
-            /* [in] */ REFIID riid,
-            /* [annotation][iid_is][out] */ 
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            IDownloadMgr * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            IDownloadMgr * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *PreDownloadCheck )( 
-            IDownloadMgr * This,
-            /* [out] */ void **ppv,
-            /* [out] */ void **ppvNI);
-        
-        HRESULT ( STDMETHODCALLTYPE *DoSetup )( 
-            IDownloadMgr * This,
-            /* [in] */ LPCWSTR wzSourceUrl,
-            /* [in] */ LPCWSTR wzFilePath,
-            /* [in] */ const FILETIME *pftLastMod,
-            /* [out] */ IUnknown **ppUnk,
-            /* [out] */ IUnknown **ppAsmNI);
-        
-        HRESULT ( STDMETHODCALLTYPE *ProbeFailed )( 
-            IDownloadMgr * This,
-            /* [out] */ IUnknown **ppUnk);
-        
-        HRESULT ( STDMETHODCALLTYPE *IsDuplicate )( 
-            IDownloadMgr * This,
-            /* [out] */ IDownloadMgr *ppDLMgr);
-        
-        HRESULT ( STDMETHODCALLTYPE *LogResult )( 
-            IDownloadMgr * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *DownloadEnabled )( 
-            IDownloadMgr * This,
-            /* [out] */ BOOL *pbEnabled);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetBindInfo )( 
-            IDownloadMgr * This,
-            /* [out] */ FusionBindInfo *pBindInfo);
-        
-        HRESULT ( STDMETHODCALLTYPE *CacheBindingResult )( 
-            IDownloadMgr * This,
-            /* [in] */ HRESULT hrResult);
-        
-        END_INTERFACE
-    } IDownloadMgrVtbl;
-
-    interface IDownloadMgr
-    {
-        CONST_VTBL struct IDownloadMgrVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define IDownloadMgr_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define IDownloadMgr_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define IDownloadMgr_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define IDownloadMgr_PreDownloadCheck(This,ppv,ppvNI)	\
-    ( (This)->lpVtbl -> PreDownloadCheck(This,ppv,ppvNI) ) 
-
-#define IDownloadMgr_DoSetup(This,wzSourceUrl,wzFilePath,pftLastMod,ppUnk,ppAsmNI)	\
-    ( (This)->lpVtbl -> DoSetup(This,wzSourceUrl,wzFilePath,pftLastMod,ppUnk,ppAsmNI) ) 
-
-#define IDownloadMgr_ProbeFailed(This,ppUnk)	\
-    ( (This)->lpVtbl -> ProbeFailed(This,ppUnk) ) 
-
-#define IDownloadMgr_IsDuplicate(This,ppDLMgr)	\
-    ( (This)->lpVtbl -> IsDuplicate(This,ppDLMgr) ) 
-
-#define IDownloadMgr_LogResult(This)	\
-    ( (This)->lpVtbl -> LogResult(This) ) 
-
-#define IDownloadMgr_DownloadEnabled(This,pbEnabled)	\
-    ( (This)->lpVtbl -> DownloadEnabled(This,pbEnabled) ) 
-
-#define IDownloadMgr_GetBindInfo(This,pBindInfo)	\
-    ( (This)->lpVtbl -> GetBindInfo(This,pBindInfo) ) 
-
-#define IDownloadMgr_CacheBindingResult(This,hrResult)	\
-    ( (This)->lpVtbl -> CacheBindingResult(This,hrResult) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __IDownloadMgr_INTERFACE_DEFINED__ */
-
-
-#ifndef __IHostAssembly_INTERFACE_DEFINED__
-#define __IHostAssembly_INTERFACE_DEFINED__
-
-/* interface IHostAssembly */
-/* [unique][uuid][object][local] */ 
-
-typedef /* [unique] */ IHostAssembly *LPHOSTASSEMBLY;
-
-
-EXTERN_C const IID IID_IHostAssembly;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("711f7c2d-8234-4505-b02f-7554f46cbf29")
-    IHostAssembly : public IUnknown
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE GetAssemblyNameDef( 
-            /* [out] */ IAssemblyName **ppAssemblyName) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetNextAssemblyNameRef( 
-            /* [in] */ DWORD nIndex,
-            /* [out] */ IAssemblyName **ppAssemblyName) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetNextAssemblyModule( 
-            /* [in] */ DWORD nIndex,
-            /* [out] */ IHostAssemblyModuleImport **ppModImport) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetModuleByName( 
-            /* [in] */ LPCOLESTR szModuleName,
-            /* [out] */ IHostAssemblyModuleImport **ppModImport) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetAssemblyStream( 
-            /* [out] */ IStream **ppStreamAsm) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetAssemblyId( 
-            /* [out] */ UINT64 *pAssemblyId) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetAssemblyDebugStream( 
-            /* [out] */ IStream **ppDebugStream) = 0;
-        
-        virtual LOADCTX_TYPE STDMETHODCALLTYPE GetFusionLoadContext( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetAssemblyContext( 
-            /* [out] */ UINT64 *pdwAssemblyContext) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct IHostAssemblyVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            IHostAssembly * This,
-            /* [in] */ REFIID riid,
-            /* [annotation][iid_is][out] */ 
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            IHostAssembly * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            IHostAssembly * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetAssemblyNameDef )( 
-            IHostAssembly * This,
-            /* [out] */ IAssemblyName **ppAssemblyName);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetNextAssemblyNameRef )( 
-            IHostAssembly * This,
-            /* [in] */ DWORD nIndex,
-            /* [out] */ IAssemblyName **ppAssemblyName);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetNextAssemblyModule )( 
-            IHostAssembly * This,
-            /* [in] */ DWORD nIndex,
-            /* [out] */ IHostAssemblyModuleImport **ppModImport);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetModuleByName )( 
-            IHostAssembly * This,
-            /* [in] */ LPCOLESTR szModuleName,
-            /* [out] */ IHostAssemblyModuleImport **ppModImport);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetAssemblyStream )( 
-            IHostAssembly * This,
-            /* [out] */ IStream **ppStreamAsm);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetAssemblyId )( 
-            IHostAssembly * This,
-            /* [out] */ UINT64 *pAssemblyId);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetAssemblyDebugStream )( 
-            IHostAssembly * This,
-            /* [out] */ IStream **ppDebugStream);
-        
-        LOADCTX_TYPE ( STDMETHODCALLTYPE *GetFusionLoadContext )( 
-            IHostAssembly * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetAssemblyContext )( 
-            IHostAssembly * This,
-            /* [out] */ UINT64 *pdwAssemblyContext);
-        
-        END_INTERFACE
-    } IHostAssemblyVtbl;
-
-    interface IHostAssembly
-    {
-        CONST_VTBL struct IHostAssemblyVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define IHostAssembly_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define IHostAssembly_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define IHostAssembly_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define IHostAssembly_GetAssemblyNameDef(This,ppAssemblyName)	\
-    ( (This)->lpVtbl -> GetAssemblyNameDef(This,ppAssemblyName) ) 
-
-#define IHostAssembly_GetNextAssemblyNameRef(This,nIndex,ppAssemblyName)	\
-    ( (This)->lpVtbl -> GetNextAssemblyNameRef(This,nIndex,ppAssemblyName) ) 
-
-#define IHostAssembly_GetNextAssemblyModule(This,nIndex,ppModImport)	\
-    ( (This)->lpVtbl -> GetNextAssemblyModule(This,nIndex,ppModImport) ) 
-
-#define IHostAssembly_GetModuleByName(This,szModuleName,ppModImport)	\
-    ( (This)->lpVtbl -> GetModuleByName(This,szModuleName,ppModImport) ) 
-
-#define IHostAssembly_GetAssemblyStream(This,ppStreamAsm)	\
-    ( (This)->lpVtbl -> GetAssemblyStream(This,ppStreamAsm) ) 
-
-#define IHostAssembly_GetAssemblyId(This,pAssemblyId)	\
-    ( (This)->lpVtbl -> GetAssemblyId(This,pAssemblyId) ) 
-
-#define IHostAssembly_GetAssemblyDebugStream(This,ppDebugStream)	\
-    ( (This)->lpVtbl -> GetAssemblyDebugStream(This,ppDebugStream) ) 
-
-#define IHostAssembly_GetFusionLoadContext(This)	\
-    ( (This)->lpVtbl -> GetFusionLoadContext(This) ) 
-
-#define IHostAssembly_GetAssemblyContext(This,pdwAssemblyContext)	\
-    ( (This)->lpVtbl -> GetAssemblyContext(This,pdwAssemblyContext) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __IHostAssembly_INTERFACE_DEFINED__ */
-
-
-#ifndef __IHostAssemblyModuleImport_INTERFACE_DEFINED__
-#define __IHostAssemblyModuleImport_INTERFACE_DEFINED__
-
-/* interface IHostAssemblyModuleImport */
-/* [unique][uuid][object][local] */ 
-
-typedef /* [unique] */ IHostAssemblyModuleImport *LPHOSTASSEMBLY_MODULE_IMPORT;
-
-
-EXTERN_C const IID IID_IHostAssemblyModuleImport;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("b6f2729d-6c0f-4944-b692-e5a2ce2c6e7a")
-    IHostAssemblyModuleImport : public IUnknown
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE GetModuleName( 
-            /* [annotation][size_is][out] */ 
-            __out_ecount_full(*pccModuleName)  LPOLESTR szModuleName,
-            /* [out][in] */ LPDWORD pccModuleName) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetModuleStream( 
-            /* [out] */ IStream **ppStreamModule) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetModuleId( 
-            /* [out] */ DWORD *pdwModuleId) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetModuleDebugStream( 
-            /* [out] */ IStream **ppDebugStream) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct IHostAssemblyModuleImportVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            IHostAssemblyModuleImport * This,
-            /* [in] */ REFIID riid,
-            /* [annotation][iid_is][out] */ 
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            IHostAssemblyModuleImport * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            IHostAssemblyModuleImport * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetModuleName )( 
-            IHostAssemblyModuleImport * This,
-            /* [annotation][size_is][out] */ 
-            __out_ecount_full(*pccModuleName)  LPOLESTR szModuleName,
-            /* [out][in] */ LPDWORD pccModuleName);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetModuleStream )( 
-            IHostAssemblyModuleImport * This,
-            /* [out] */ IStream **ppStreamModule);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetModuleId )( 
-            IHostAssemblyModuleImport * This,
-            /* [out] */ DWORD *pdwModuleId);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetModuleDebugStream )( 
-            IHostAssemblyModuleImport * This,
-            /* [out] */ IStream **ppDebugStream);
-        
-        END_INTERFACE
-    } IHostAssemblyModuleImportVtbl;
-
-    interface IHostAssemblyModuleImport
-    {
-        CONST_VTBL struct IHostAssemblyModuleImportVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define IHostAssemblyModuleImport_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define IHostAssemblyModuleImport_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define IHostAssemblyModuleImport_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define IHostAssemblyModuleImport_GetModuleName(This,szModuleName,pccModuleName)	\
-    ( (This)->lpVtbl -> GetModuleName(This,szModuleName,pccModuleName) ) 
-
-#define IHostAssemblyModuleImport_GetModuleStream(This,ppStreamModule)	\
-    ( (This)->lpVtbl -> GetModuleStream(This,ppStreamModule) ) 
-
-#define IHostAssemblyModuleImport_GetModuleId(This,pdwModuleId)	\
-    ( (This)->lpVtbl -> GetModuleId(This,pdwModuleId) ) 
-
-#define IHostAssemblyModuleImport_GetModuleDebugStream(This,ppDebugStream)	\
-    ( (This)->lpVtbl -> GetModuleDebugStream(This,ppDebugStream) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __IHostAssemblyModuleImport_INTERFACE_DEFINED__ */
-
-
-/* interface __MIDL_itf_fusionpriv_0000_0017 */
-/* [local] */ 
-
-STDAPI CreateHistoryReader(LPCWSTR wzFilePath, IHistoryReader **ppHistReader);
-STDAPI LookupHistoryAssembly(LPCWSTR pwzFilePath, FILETIME *pftActivationDate, LPCWSTR pwzAsmName, LPCWSTR pwzPublicKeyToken, LPCWSTR wzCulture, LPCWSTR pwzVerRef, IHistoryAssembly **pHistAsm);
-STDAPI GetHistoryFileDirectory(__out_ecount_opt(*pdwSize) LPWSTR wzDir, DWORD *pdwSize);
-STDAPI PreBindAssembly(IApplicationContext *pAppCtx, IAssemblyName *pName, IAssembly *pAsmParent, IAssemblyName **ppNamePostPolicy, LPVOID pvReserved); 
-STDAPI CreateApplicationContext(IAssemblyName *pName, LPAPPLICATIONCONTEXT *ppCtx);             
-STDAPI IsRetargetableAssembly(IAssemblyName *pName, BOOL *pbIsRetargetable);             
-STDAPI IsOptionallyRetargetableAssembly(IAssemblyName *pName, BOOL *pbIsRetargetable);             
-#define EXPLICITBIND_FLAGS_NON_BINDABLE          0x0
-#define EXPLICITBIND_FLAGS_EXE                   0x1
-
-
-extern RPC_IF_HANDLE __MIDL_itf_fusionpriv_0000_0017_v0_0_c_ifspec;
-extern RPC_IF_HANDLE __MIDL_itf_fusionpriv_0000_0017_v0_0_s_ifspec;
-
-/* Additional Prototypes for ALL interfaces */
-
-/* end of Additional Prototypes */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
-
diff --git a/src/pal/src/CMakeLists.txt b/src/pal/src/CMakeLists.txt
index f5f3d40c97..16c9d8bd6f 100644
--- a/src/pal/src/CMakeLists.txt
+++ b/src/pal/src/CMakeLists.txt
@@ -281,31 +281,73 @@ if(CMAKE_SYSTEM_NAME STREQUAL Linux)
     find_library(UNWIND_ARCH NAMES unwind-arm)
   endif()
 
+  if(PAL_CMAKE_PLATFORM_ARCH_ARM64)
+    find_library(UNWIND_ARCH NAMES unwind-aarch64)
+  endif()
+
   if(PAL_CMAKE_PLATFORM_ARCH_AMD64)
     find_library(UNWIND_ARCH NAMES unwind-x86_64)
   endif()
 
-  if(CLR_CMAKE_PLATFORM_ALPINE_LINUX)
+  if(CLR_CMAKE_PLATFORM_ALPINE_LINUX OR CLR_CMAKE_PLATFORM_ANDROID)
     find_library(INTL intl)
   endif()
 
-  find_library(UNWIND NAMES unwind)
+  # On Android, we don't need to link with gcc_s, pthread and rt
+  if(NOT CLR_CMAKE_PLATFORM_ANDROID)
+    target_link_libraries(coreclrpal
+      gcc_s
+      pthread
+      rt
+    )
+  endif()
+
+  if(CLR_CMAKE_PLATFORM_ANDROID)
+    target_link_libraries(coreclrpal
+      gnustl_shared
+      android-support
+      android-glob)
+  endif()
+
+  if(NOT CLR_CMAKE_PLATFORM_ANDROID)
+    find_library(UNWIND NAMES unwind)
+
+    if(UNWIND STREQUAL UNWIND-NOTFOUND)
+      message(FATAL_ERROR "Cannot find libunwind. Try installing libunwind8-dev and libunwind8.")
+    endif(UNWIND STREQUAL UNWIND-NOTFOUND)
+
+    target_link_libraries(coreclrpal ${UNWIND})
+  endif()
+
+  if(CLR_MAKE_PLATFORM_ANDROID)
+    find_library(ANDROID_SUPPORT NAMES android-support)
+    find_library(ANDROID_GLOB NAMES android-glob)
+    find_library(INTL NAMES intl)
+
+    if(UNWIND_ARCH STREQUAL UNWIND_ARCH-NOTFOUND)
+      message(FATAL_ERROR "Cannot find libunwind.")
+    endif()
+
+    if(ANDROID_SUPPORT STREQUAL ANDROID_SUPPORT-NOTFOUND)
+      message(FATAL_ERROR "Cannot find android-support.")
+    endif()
+
+    if(ANDROID_GLOB STREQUAL ANDROID_GLOB-NOTFOUND)
+      message(FATAL_ERROR "Cannot find android-glob.")
+    endif()
+
+    if(INTL STREQUAL INTL-NOTFOUND)
+      message(FATAL_ERROR "Cannot find libintl.")
+    endif()
+  endif()
+
   find_library(UNWIND_GENERIC NAMES unwind-generic)
 
   target_link_libraries(coreclrpal
-    gcc_s
-    pthread
-    rt
     dl
     uuid
   )
 
-  if(UNWIND STREQUAL UNWIND-NOTFOUND)
-    message(FATAL_ERROR "Cannot find libunwind. Try installing libunwind8-dev and libunwind8.")
-  endif(UNWIND STREQUAL UNWIND-NOTFOUND)
-
-  target_link_libraries(coreclrpal ${UNWIND})
-
   if(NOT UNWIND_GENERIC STREQUAL UNWIND_GENERIC-NOTFOUND)
     target_link_libraries(coreclrpal ${UNWIND_GENERIC})
   endif(NOT UNWIND_GENERIC STREQUAL UNWIND_GENERIC-NOTFOUND)
diff --git a/src/pal/src/config.h.in b/src/pal/src/config.h.in
index 4d21fb70e4..77d7bfaf5a 100644
--- a/src/pal/src/config.h.in
+++ b/src/pal/src/config.h.in
@@ -51,6 +51,7 @@
 #cmakedefine01 HAVE_MACH_EXCEPTIONS
 #cmakedefine01 HAVE_VM_ALLOCATE
 #cmakedefine01 HAVE_VM_READ
+#cmakedefine01 HAVE_SEMAPHORE_H
 #cmakedefine01 HAS_SYSV_SEMAPHORES
 #cmakedefine01 HAS_PTHREAD_MUTEXES
 #cmakedefine01 HAVE_TTRACE
diff --git a/src/pal/src/configure.cmake b/src/pal/src/configure.cmake
index a53e0db51e..4f2bc5739b 100644
--- a/src/pal/src/configure.cmake
+++ b/src/pal/src/configure.cmake
@@ -33,6 +33,7 @@ check_include_files(sys/lwp.h HAVE_SYS_LWP_H)
 check_include_files(lwp.h HAVE_LWP_H)
 check_include_files(libunwind.h HAVE_LIBUNWIND_H)
 check_include_files(runetype.h HAVE_RUNETYPE_H)
+check_include_files(semaphore.h HAVE_SEMAPHORE_H)
 
 if(NOT CMAKE_SYSTEM_NAME STREQUAL FreeBSD AND NOT CMAKE_SYSTEM_NAME STREQUAL NetBSD)
   set(CMAKE_REQUIRED_FLAGS "-ldl")
@@ -48,15 +49,26 @@ check_include_files(gnu/lib-names.h HAVE_GNU_LIBNAMES_H)
 
 check_function_exists(kqueue HAVE_KQUEUE)
 check_function_exists(getpwuid_r HAVE_GETPWUID_R)
-check_library_exists(pthread pthread_suspend "" HAVE_PTHREAD_SUSPEND)
-check_library_exists(pthread pthread_suspend_np "" HAVE_PTHREAD_SUSPEND_NP)
-check_library_exists(pthread pthread_continue "" HAVE_PTHREAD_CONTINUE)
-check_library_exists(pthread pthread_continue_np "" HAVE_PTHREAD_CONTINUE_NP)
-check_library_exists(pthread pthread_resume_np "" HAVE_PTHREAD_RESUME_NP)
-check_library_exists(pthread pthread_attr_get_np "" HAVE_PTHREAD_ATTR_GET_NP)
-check_library_exists(pthread pthread_getattr_np "" HAVE_PTHREAD_GETATTR_NP)
-check_library_exists(pthread pthread_getcpuclockid "" HAVE_PTHREAD_GETCPUCLOCKID)
-check_library_exists(pthread pthread_sigqueue "" HAVE_PTHREAD_SIGQUEUE)
+
+check_library_exists(pthread pthread_create "" HAVE_LIBPTHREAD)
+check_library_exists(c pthread_create "" HAVE_PTHREAD_IN_LIBC)
+
+if (HAVE_LIBPTHREAD)
+  set(PTHREAD_LIBRARY pthread)
+elseif (HAVE_PTHREAD_IN_LIBC)
+  set(PTHREAD_LIBRARY c)
+endif()
+
+check_library_exists(${PTHREAD_LIBRARY} pthread_suspend "" HAVE_PTHREAD_SUSPEND)
+check_library_exists(${PTHREAD_LIBRARY} pthread_suspend_np "" HAVE_PTHREAD_SUSPEND_NP)
+check_library_exists(${PTHREAD_LIBRARY} pthread_continue "" HAVE_PTHREAD_CONTINUE)
+check_library_exists(${PTHREAD_LIBRARY} pthread_continue_np "" HAVE_PTHREAD_CONTINUE_NP)
+check_library_exists(${PTHREAD_LIBRARY} pthread_resume_np "" HAVE_PTHREAD_RESUME_NP)
+check_library_exists(${PTHREAD_LIBRARY} pthread_attr_get_np "" HAVE_PTHREAD_ATTR_GET_NP)
+check_library_exists(${PTHREAD_LIBRARY} pthread_getattr_np "" HAVE_PTHREAD_GETATTR_NP)
+check_library_exists(${PTHREAD_LIBRARY} pthread_getcpuclockid "" HAVE_PTHREAD_GETCPUCLOCKID)
+check_library_exists(${PTHREAD_LIBRARY} pthread_sigqueue "" HAVE_PTHREAD_SIGQUEUE)
+
 check_function_exists(sigreturn HAVE_SIGRETURN)
 check_function_exists(_thread_sys_sigreturn HAVE__THREAD_SYS_SIGRETURN)
 set(CMAKE_REQUIRED_LIBRARIES m)
@@ -874,7 +886,8 @@ int main(void)
   unlink(szFileName);
   exit(ret);
 }" UNGETC_NOT_RETURN_EOF)
-set(CMAKE_REQUIRED_LIBRARIES pthread)
+
+set(CMAKE_REQUIRED_LIBRARIES ${PTHREAD_LIBRARY})
 check_cxx_source_runs("
 #include <stdlib.h>
 #include <errno.h>
diff --git a/src/pal/src/cruntime/file.cpp b/src/pal/src/cruntime/file.cpp
index 5fe2b671f3..0eb2cea151 100644
--- a/src/pal/src/cruntime/file.cpp
+++ b/src/pal/src/cruntime/file.cpp
@@ -196,45 +196,6 @@ static BOOL WriteOnlyMode(FILE* pFile)
 
 /*++
 Function:
-  _getw
-
-Gets an integer from a stream.
-
-Return Value
-
-_getw returns the integer value read. A return value of EOF indicates
-either an error or end of file. However, because the EOF value is also
-a legitimate integer value, use feof or ferror to verify an
-end-of-file or error condition.
-
-Parameter
-
-file  Pointer to FILE structure
-
---*/
-int
-__cdecl
-_getw(PAL_FILE *f)
-{
-    INT ret = 0;
-    
-    PERF_ENTRY(_getw);
-    ENTRY("_getw (f=%p)\n", f);
-
-    _ASSERTE(f != NULL);
-
-    CLEARERR(f);
-    
-    ret = getw( f->bsdFilePtr );
-    LOGEXIT( "returning %d\n", ret );
-    PERF_EXIT(_getw);
-    
-    return ret;
-}
-
-
-/*++
-Function:
   _fdopen
 
 see MSDN
@@ -448,45 +409,6 @@ _wfsopen(
 }
 
 /*++
-Function:
-  _putw
-
-Writes an integer to a stream.
-
-Return Value
-
-_putw returns the value written. A return value of EOF may indicate an
-error. Because EOF is also a legitimate integer value, use ferror to
-verify an error.
-
-Parameters
-
-c     Binary integer to be output
-file  Pointer to FILE structure
-
---*/
-int
-__cdecl
-_putw(int c, PAL_FILE *f)
-{
-    INT ret = 0;
-
-    PERF_ENTRY(_putw);
-    ENTRY("_putw (c=0x%x, f=%p)\n", c, f);
-
-    _ASSERTE(f != NULL);
-
-    CLEARERR(f);
- 
-    ret = putw(c,  f->bsdFilePtr );
-    LOGEXIT( "returning %d\n", ret );
-    PERF_EXIT(_putw);
-
-    return ret;
-}
-
-
-/*++
 Function
     PAL_get_stdout.
 
diff --git a/src/pal/src/debug/debug.cpp b/src/pal/src/debug/debug.cpp
index 2fd0442b07..2eaaec9f1f 100644
--- a/src/pal/src/debug/debug.cpp
+++ b/src/pal/src/debug/debug.cpp
@@ -543,31 +543,6 @@ SetThreadContext(
     return ret;
 }
 
-__attribute__((noinline))
-__attribute__((optnone))
-void 
-ProbeMemory(volatile PBYTE pbBuffer, DWORD cbBuffer, bool fWriteAccess)
-{
-    // Need an throw in this function to fool the C++ runtime into handling the 
-    // possible h/w exception below.
-    if (pbBuffer == NULL)
-    {
-        throw PAL_SEHException();
-    }
-
-    // Simple one byte at a time probing
-    while (cbBuffer > 0)
-    {
-        volatile BYTE read = *pbBuffer;
-        if (fWriteAccess)
-        {
-            *pbBuffer = read;
-        }
-        ++pbBuffer;
-        --cbBuffer;
-    }
-}
-
 /*++
 Function:
   PAL_ProbeMemory
@@ -589,18 +564,58 @@ PAL_ProbeMemory(
     DWORD cbBuffer,
     BOOL fWriteAccess)
 {
-    try
-    {
-        // Need to explicit h/w exception holder so to catch them in ProbeMemory
-        CatchHardwareExceptionHolder __catchHardwareException;
+    int fds[2];
 
-        ProbeMemory((PBYTE)pBuffer, cbBuffer, fWriteAccess);
-    }
-    catch(...)
+    if (pipe(fds) != 0)
     {
+        ASSERT("pipe failed: errno is %d (%s)\n", errno, strerror(errno));
         return FALSE;
     }
-    return TRUE;
+
+    fcntl(fds[0], O_NONBLOCK);
+    fcntl(fds[1], O_NONBLOCK);
+
+    PVOID pEnd = (PBYTE)pBuffer + cbBuffer;
+    BOOL result = TRUE;
+
+    // Validate the first byte in the buffer, then validate the first byte on each page after that.
+    while (pBuffer < pEnd)
+    {
+        int written = write(fds[1], pBuffer, 1);
+        if (written == -1)
+        {
+            if (errno != EFAULT)
+            {
+                ASSERT("write failed: errno is %d (%s)\n", errno, strerror(errno));
+            }
+            result = FALSE;
+            break;
+        }
+        else
+        {
+            if (fWriteAccess)
+            {
+                int rd = read(fds[0], pBuffer, 1);
+                if (rd == -1)
+                {
+                    if (errno != EFAULT)
+                    {
+                        ASSERT("read failed: errno is %d (%s)\n", errno, strerror(errno));
+                    }
+                    result = FALSE;
+                    break;
+                }
+            }
+        }
+
+        // Round to the beginning of the next page
+        pBuffer = (PVOID)(((SIZE_T)pBuffer & ~VIRTUAL_PAGE_MASK) + VIRTUAL_PAGE_SIZE);
+    }
+
+    close(fds[0]);
+    close(fds[1]);
+
+    return result;
 }
 
 } // extern "C"
diff --git a/src/pal/src/file/file.cpp b/src/pal/src/file/file.cpp
index 5d8d24128c..d70e62bd52 100644
--- a/src/pal/src/file/file.cpp
+++ b/src/pal/src/file/file.cpp
@@ -18,6 +18,9 @@ Abstract:
 
 --*/
 
+#include "pal/dbgmsg.h"
+SET_DEFAULT_DEBUG_CHANNEL(FILE); // some headers have code with asserts, so do this first
+
 #include "pal/thread.hpp"
 #include "pal/file.hpp"
 #include "shmfilelockmgr.hpp"
@@ -25,7 +28,6 @@ Abstract:
 #include "pal/stackstring.hpp"
 
 #include "pal/palinternal.h"
-#include "pal/dbgmsg.h"
 #include "pal/file.h"
 #include "pal/filetime.h"
 #include "pal/utils.h"
@@ -42,8 +44,6 @@ Abstract:
 
 using namespace CorUnix;
 
-SET_DEFAULT_DEBUG_CHANNEL(FILE);
-
 int MaxWCharToAcpLengthFactor = 3;
 
 PAL_ERROR
diff --git a/src/pal/src/file/path.cpp b/src/pal/src/file/path.cpp
index c4ef31be32..d998b72b2e 100644
--- a/src/pal/src/file/path.cpp
+++ b/src/pal/src/file/path.cpp
@@ -494,8 +494,8 @@ GetTempPathA(
     }
     else /* env var not found or was empty */
     {
-        /* no luck, use /tmp/ */
-        const char *defaultDir = "/tmp/";
+        /* no luck, use /tmp/ or /data/local/tmp on Android */
+        const char *defaultDir = TEMP_DIRECTORY_PATH;
         int defaultDirLen = strlen(defaultDir);
         if (defaultDirLen < nBufferLength)
         {
diff --git a/src/pal/src/include/pal/palinternal.h b/src/pal/src/include/pal/palinternal.h
index dbf288c127..48e2f3c683 100644
--- a/src/pal/src/include/pal/palinternal.h
+++ b/src/pal/src/include/pal/palinternal.h
@@ -358,6 +358,7 @@ function_name() to call the system's implementation
 #undef memchr
 #undef strlen
 #undef strnlen
+#undef wcsnlen
 #undef stricmp
 #undef strstr
 #undef strcmp
@@ -606,6 +607,14 @@ function_name() to call the system's implementation
 #undef assert
 #define assert (Use__ASSERTE_instead_of_assert) assert
 
+#ifndef __ANDROID__
+#define TEMP_DIRECTORY_PATH "/tmp/"
+#else
+// On Android, "/tmp/" doesn't exist; temporary files should go to
+// /data/local/tmp/
+#define TEMP_DIRECTORY_PATH "/data/local/tmp/"
+#endif
+
 #define PROCESS_PIPE_NAME_PREFIX ".dotnet-pal-processpipe"
 
 #ifdef __cplusplus
diff --git a/src/pal/src/include/pal/sharedmemory.h b/src/pal/src/include/pal/sharedmemory.h
index 45cc4b2c8d..2e0d9d2a79 100644
--- a/src/pal/src/include/pal/sharedmemory.h
+++ b/src/pal/src/include/pal/sharedmemory.h
@@ -15,30 +15,33 @@
 #define _countof(a) (sizeof(a) / sizeof(a[0]))
 #endif // !_countof
 
+// The temporary folder is used for storing shared memory files and their lock files.
+// The location of the temporary folder varies (e.g. /data/local/tmp on Android)
+// and is set in TEMP_DIRECTORY_PATH. TEMP_DIRECTORY_PATH ends with '/'
 // - Global shared memory files go in:
-//     /tmp/.dotnet/shm/global/<fileName>
+//     {tmp}/.dotnet/shm/global/<fileName>
 // - Session-scoped shared memory files go in:
-//     /tmp/.dotnet/shm/session<sessionId>/<fileName>
+//     {tmp}/.dotnet/shm/session<sessionId>/<fileName>
 // - Lock files associated with global shared memory files go in:
-//     /tmp/.dotnet/lockfiles/global/<fileName>
+//     {tmp}/.dotnet/lockfiles/global/<fileName>
 // - Lock files associated with session-scoped shared memory files go in:
-//     /tmp/.dotnet/lockfiles/session<sessionId>/<fileName>
+//     {tmp}/.dotnet/lockfiles/session<sessionId>/<fileName>
 
 #define SHARED_MEMORY_MAX_FILE_NAME_CHAR_COUNT (_MAX_FNAME - 1)
 #define SHARED_MEMORY_MAX_NAME_CHAR_COUNT (_countof("Global\\") - 1 + SHARED_MEMORY_MAX_FILE_NAME_CHAR_COUNT)
 
-#define SHARED_MEMORY_TEMP_DIRECTORY_PATH "/tmp"
-#define SHARED_MEMORY_RUNTIME_TEMP_DIRECTORY_PATH "/tmp/.dotnet"
+#define SHARED_MEMORY_TEMP_DIRECTORY_PATH TEMP_DIRECTORY_PATH
+#define SHARED_MEMORY_RUNTIME_TEMP_DIRECTORY_PATH TEMP_DIRECTORY_PATH ".dotnet"
 
-#define SHARED_MEMORY_SHARED_MEMORY_DIRECTORY_PATH "/tmp/.dotnet/shm"
-#define SHARED_MEMORY_LOCK_FILES_DIRECTORY_PATH "/tmp/.dotnet/lockfiles"
+#define SHARED_MEMORY_SHARED_MEMORY_DIRECTORY_PATH TEMP_DIRECTORY_PATH ".dotnet/shm"
+#define SHARED_MEMORY_LOCK_FILES_DIRECTORY_PATH TEMP_DIRECTORY_PATH ".dotnet/lockfiles"
 static_assert_no_msg(_countof(SHARED_MEMORY_LOCK_FILES_DIRECTORY_PATH) >= _countof(SHARED_MEMORY_SHARED_MEMORY_DIRECTORY_PATH));
 
 #define SHARED_MEMORY_GLOBAL_DIRECTORY_NAME "global"
 #define SHARED_MEMORY_SESSION_DIRECTORY_NAME_PREFIX "session"
 static_assert_no_msg(_countof(SHARED_MEMORY_SESSION_DIRECTORY_NAME_PREFIX) >= _countof(SHARED_MEMORY_GLOBAL_DIRECTORY_NAME));
 
-#define SHARED_MEMORY_UNIQUE_TEMP_NAME_TEMPLATE "/tmp/.coreclr.XXXXXX"
+#define SHARED_MEMORY_UNIQUE_TEMP_NAME_TEMPLATE TEMP_DIRECTORY_PATH ".coreclr.XXXXXX"
 
 #define SHARED_MEMORY_MAX_SESSION_ID_CHAR_COUNT (10)
 
diff --git a/src/pal/src/include/pal/thread.hpp b/src/pal/src/include/pal/thread.hpp
index e6dacd2136..ddacfb9039 100644
--- a/src/pal/src/include/pal/thread.hpp
+++ b/src/pal/src/include/pal/thread.hpp
@@ -94,11 +94,6 @@ namespace CorUnix
         );
 
     PAL_ERROR
-    InitializeGlobalThreadData(
-        void
-        );
-
-    PAL_ERROR
     CreateThreadData(
         CPalThread **ppThread
         );
@@ -243,12 +238,6 @@ namespace CorUnix
 
         friend
             PAL_ERROR
-            InitializeGlobalThreadData(
-                void
-                );
-
-        friend
-            PAL_ERROR
             CreateThreadData(
                 CPalThread **ppThread
                 );
@@ -338,13 +327,6 @@ namespace CorUnix
         // Limit address of the stack of this thread
         void* m_stackLimit;
 
-        // The default stack size of a newly created thread (currently 256KB)
-        // when the dwStackSize paramter of PAL_CreateThread()
-        // is zero. This value can be set by setting the
-        // environment variable PAL_THREAD_DEFAULT_STACK_SIZE
-        // (the value should be in bytes and in hex).
-        static DWORD s_dwDefaultThreadStackSize; 
-
         //
         // The thread entry routine (called from InternalCreateThread)
         //
diff --git a/src/pal/src/include/pal/threadsusp.hpp b/src/pal/src/include/pal/threadsusp.hpp
index e1e85e265c..dfd65d0f8b 100644
--- a/src/pal/src/include/pal/threadsusp.hpp
+++ b/src/pal/src/include/pal/threadsusp.hpp
@@ -55,6 +55,8 @@ Abstract:
 
 #if HAVE_SYS_SEMAPHORE_H
 #include <sys/semaphore.h>
+#elif HAVE_SEMAPHORE_H
+#include <semaphore.h>
 #endif // HAVE_SYS_SEMAPHORE_H
 
 #elif HAS_PTHREAD_MUTEXES && HAVE_MACH_EXCEPTIONS
diff --git a/src/pal/src/include/pal/utils.h b/src/pal/src/include/pal/utils.h
index 3ddad4ae2f..f381d957ab 100644
--- a/src/pal/src/include/pal/utils.h
+++ b/src/pal/src/include/pal/utils.h
@@ -20,10 +20,66 @@ Abstract:
 #ifndef _PAL_UTILS_H_
 #define _PAL_UTILS_H_
 
+#include <stdint.h>
+
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Alignment helpers (copied for PAL use from stdmacros.h)
+
+inline size_t ALIGN_UP(size_t val, size_t alignment)
+{
+    // alignment must be a power of 2 for this implementation to work (need modulo otherwise)
+    _ASSERTE(0 == (alignment & (alignment - 1)));
+    size_t result = (val + (alignment - 1)) & ~(alignment - 1);
+    _ASSERTE(result >= val);      // check for overflow
+    return result;
+}
+
+inline void* ALIGN_UP(void* val, size_t alignment)
+{
+    return (void*)ALIGN_UP((size_t)val, alignment);
+}
+
+inline uint8_t* ALIGN_UP(uint8_t* val, size_t alignment)
+{
+    return (uint8_t*)ALIGN_UP((size_t)val, alignment);
+}
+
+inline size_t ALIGN_DOWN(size_t val, size_t alignment)
+{
+    // alignment must be a power of 2 for this implementation to work (need modulo otherwise)
+    _ASSERTE(0 == (alignment & (alignment - 1)));
+    size_t result = val & ~(alignment - 1);
+    return result;
+}
+
+inline void* ALIGN_DOWN(void* val, size_t alignment)
+{
+    return (void*)ALIGN_DOWN((size_t)val, alignment);
+}
+
+inline uint8_t* ALIGN_DOWN(uint8_t* val, size_t alignment)
+{
+    return (uint8_t*)ALIGN_DOWN((size_t)val, alignment);
+}
+
+inline BOOL IS_ALIGNED(size_t val, size_t alignment)
+{
+    // alignment must be a power of 2 for this implementation to work (need modulo otherwise)
+    _ASSERTE(0 == (alignment & (alignment - 1)));
+    return 0 == (val & (alignment - 1));
+}
+
+inline BOOL IS_ALIGNED(const void* val, size_t alignment)
+{
+    return IS_ALIGNED((size_t)val, alignment);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
 #ifdef __cplusplus
 extern "C"
 {
diff --git a/src/pal/src/init/pal.cpp b/src/pal/src/init/pal.cpp
index 0bda27644e..e6db7dca2e 100644
--- a/src/pal/src/init/pal.cpp
+++ b/src/pal/src/init/pal.cpp
@@ -18,6 +18,9 @@ Abstract:
 
 --*/
 
+#include "pal/dbgmsg.h"
+SET_DEFAULT_DEBUG_CHANNEL(PAL); // some headers have code with asserts, so do this first
+
 #include "pal/thread.hpp"
 #include "pal/synchobjects.hpp"
 #include "pal/procobj.hpp"
@@ -27,7 +30,6 @@ Abstract:
 #include "../objmgr/shmobjectmanager.hpp"
 #include "pal/seh.hpp"
 #include "pal/palinternal.h"
-#include "pal/dbgmsg.h"
 #include "pal/sharedmemory.h"
 #include "pal/shmemory.h"
 #include "pal/process.h"
@@ -90,8 +92,6 @@ using namespace CorUnix;
 extern "C" BOOL CRTInitStdStreams( void );
 
 
-SET_DEFAULT_DEBUG_CHANNEL(PAL);
-
 Volatile<INT> init_count = 0;
 Volatile<BOOL> shutdown_intent = 0;
 Volatile<LONG> g_coreclrInitialized = 0;
@@ -314,17 +314,6 @@ Initialize(
 #endif // HAVE_MACH_EXCEPTIONS
 
         //
-        // Initialize global thread data
-        //
-
-        palError = InitializeGlobalThreadData();
-        if (NO_ERROR != palError)
-        {
-            ERROR("Unable to initialize thread data\n");
-            goto CLEANUP1;
-        }
-
-        //
         // Allocate the initial thread data
         //
 
diff --git a/src/pal/src/loader/module.cpp b/src/pal/src/loader/module.cpp
index a4fc4949e4..63a65ffb61 100644
--- a/src/pal/src/loader/module.cpp
+++ b/src/pal/src/loader/module.cpp
@@ -18,11 +18,13 @@ Abstract:
 
 --*/
 
+#include "pal/dbgmsg.h"
+SET_DEFAULT_DEBUG_CHANNEL(LOADER); // some headers have code with asserts, so do this first
+
 #include "pal/thread.hpp"
 #include "pal/malloc.hpp"
 #include "pal/file.hpp"
 #include "pal/palinternal.h"
-#include "pal/dbgmsg.h"
 #include "pal/module.h"
 #include "pal/cs.hpp"
 #include "pal/process.h"
@@ -60,8 +62,6 @@ Abstract:
 
 using namespace CorUnix;
 
-SET_DEFAULT_DEBUG_CHANNEL(LOADER);
-
 // In safemath.h, Template SafeInt uses macro _ASSERTE, which need to use variable
 // defdbgchan defined by SET_DEFAULT_DEBUG_CHANNEL. Therefore, the include statement
 // should be placed after the SET_DEFAULT_DEBUG_CHANNEL(LOADER)
diff --git a/src/pal/src/misc/dbgmsg.cpp b/src/pal/src/misc/dbgmsg.cpp
index d6f173f160..5eb5ebf9ba 100644
--- a/src/pal/src/misc/dbgmsg.cpp
+++ b/src/pal/src/misc/dbgmsg.cpp
@@ -50,11 +50,7 @@ using namespace CorUnix;
 /* append mode file I/O is safer */
 #define _PAL_APPEND_DBG_OUTPUT_
 
-#if defined(_PAL_APPEND_DBG_OUTPUT_)
 static const char FOPEN_FLAGS[] = "at";
-#else
-static const char FOPEN_FLAGS[] = "wt";
-#endif
 
 /* number of ENTRY nesting levels to indicate with a '.' */
 #define MAX_NESTING 50
diff --git a/src/pal/src/misc/utils.cpp b/src/pal/src/misc/utils.cpp
index 1e333d19ac..f0ff63439f 100644
--- a/src/pal/src/misc/utils.cpp
+++ b/src/pal/src/misc/utils.cpp
@@ -18,21 +18,21 @@ Abstract:
 
 --*/
 
+#include "pal/dbgmsg.h"
+SET_DEFAULT_DEBUG_CHANNEL(MISC); // some headers have code with asserts, so do this first
+
 #include "pal/palinternal.h"
 #if HAVE_VM_ALLOCATE
 #include <mach/message.h>
 #endif //HAVE_VM_ALLOCATE
 
 #include "pal/utils.h"
-#include "pal/dbgmsg.h"
 #include "pal/file.h"
 
 #include <errno.h>
 #include <string.h>
 
 
-SET_DEFAULT_DEBUG_CHANNEL(MISC);
-
 // In safemath.h, Template SafeInt uses macro _ASSERTE, which need to use variable
 // defdbgchan defined by SET_DEFAULT_DEBUG_CHANNEL. Therefore, the include statement
 // should be placed after the SET_DEFAULT_DEBUG_CHANNEL(MISC)
diff --git a/src/pal/src/safecrt/sscanf_s.cpp b/src/pal/src/safecrt/sscanf_s.cpp
index 4f548bccc6..7a481b580f 100644
--- a/src/pal/src/safecrt/sscanf_s.cpp
+++ b/src/pal/src/safecrt/sscanf_s.cpp
@@ -21,7 +21,7 @@
 
 typedef int (*INPUTFN)(miniFILE *, const unsigned char*, va_list);
 typedef int (*WINPUTFN)(miniFILE *, const wchar_t*, va_list);
-
+extern size_t PAL_wcsnlen(const WCHAR* inString, size_t inMaxSize);
 
 /***
 *static int v[nw]scan_fn([w]inputfn, string, [count], format, ...)
@@ -115,7 +115,7 @@ static int __cdecl vwscan_fn (
         miniFILE str;
         miniFILE *infile = &str;
         int retval;
-        size_t count = wcsnlen(string, INT_MAX);
+        size_t count = PAL_wcsnlen(string, INT_MAX);
 
         _VALIDATE_RETURN( (string != NULL), EINVAL, EOF);
         _VALIDATE_RETURN( (format != NULL), EINVAL, EOF);
@@ -149,7 +149,7 @@ static int __cdecl vnwscan_fn (
         miniFILE str;
         miniFILE *infile = &str;
         int retval;
-        size_t length = wcsnlen(string, INT_MAX);
+        size_t length = PAL_wcsnlen(string, INT_MAX);
 
         _VALIDATE_RETURN( (string != NULL), EINVAL, EOF);
         _VALIDATE_RETURN( (format != NULL), EINVAL, EOF);
diff --git a/src/pal/src/safecrt/wcslen_s.cpp b/src/pal/src/safecrt/wcslen_s.cpp
index 4fd5371035..0688148b5d 100644
--- a/src/pal/src/safecrt/wcslen_s.cpp
+++ b/src/pal/src/safecrt/wcslen_s.cpp
@@ -42,7 +42,7 @@
 *
 *******************************************************************************/
 
-size_t __cdecl wcsnlen(const wchar_t *wcs, size_t maxsize)
+size_t __cdecl PAL_wcsnlen(const wchar_t *wcs, size_t maxsize)
 {
     size_t n;
 
diff --git a/src/pal/src/thread/process.cpp b/src/pal/src/thread/process.cpp
index d663eed7c8..ae069aec86 100644
--- a/src/pal/src/thread/process.cpp
+++ b/src/pal/src/thread/process.cpp
@@ -18,6 +18,9 @@ Abstract:
 
 --*/
 
+#include "pal/dbgmsg.h"
+SET_DEFAULT_DEBUG_CHANNEL(PROCESS); // some headers have code with asserts, so do this first
+
 #include "pal/procobj.hpp"
 #include "pal/thread.hpp"
 #include "pal/file.hpp"
@@ -29,7 +32,6 @@ Abstract:
 #include "pal/init.h"
 #include "pal/critsect.h"
 #include "pal/debug.h"
-#include "pal/dbgmsg.h"
 #include "pal/utils.h"
 #include "pal/environ.h"
 #include "pal/virtual.h"
@@ -67,8 +69,6 @@ Abstract:
 
 using namespace CorUnix;
 
-SET_DEFAULT_DEBUG_CHANNEL(PROCESS);
-
 CObjectType CorUnix::otProcess(
                 otiProcess,
                 NULL,
@@ -1453,7 +1453,7 @@ static uint64_t HashSemaphoreName(uint64_t a, uint64_t b)
 #define HashSemaphoreName(a,b) a,b
 #endif
 
-static const char* PipeNameFormat = "/tmp/clr-debug-pipe-%d-%llu-%s";
+static const char* PipeNameFormat = TEMP_DIRECTORY_PATH "clr-debug-pipe-%d-%llu-%s";
 
 class PAL_RuntimeStartupHelper
 {
diff --git a/src/pal/src/thread/thread.cpp b/src/pal/src/thread/thread.cpp
index 566ef855b4..53283320c5 100644
--- a/src/pal/src/thread/thread.cpp
+++ b/src/pal/src/thread/thread.cpp
@@ -34,6 +34,8 @@ SET_DEFAULT_DEBUG_CHANNEL(THREAD); // some headers have code with asserts, so do
 #include "pal/module.h"
 #include "pal/environ.h"
 #include "pal/init.h"
+#include "pal/utils.h"
+#include "pal/virtual.h"
 
 #if defined(__NetBSD__) && !HAVE_PTHREAD_GETCPUCLOCKID
 #include <sys/cdefs.h>
@@ -77,13 +79,6 @@ using namespace CorUnix;
 
 /* ------------------- Definitions ------------------------------*/
 
-// The default stack size of a newly created thread (currently 256KB)
-// when the dwStackSize parameter of PAL_CreateThread()
-// is zero. This value can be set by setting the
-// environment variable PAL_THREAD_DEFAULT_STACK_SIZE
-// (the value should be in bytes and in hex).
-DWORD CPalThread::s_dwDefaultThreadStackSize = 256*1024; 
-
 /* list of free CPalThread objects */
 static Volatile<CPalThread*> free_threads_list = NULL;
 
@@ -528,6 +523,7 @@ CorUnix::InternalCreateThread(
 #endif  // PTHREAD_CREATE_MODIFIES_ERRNO
     BOOL fHoldingProcessLock = FALSE;
     int iError = 0;
+    size_t alignedStackSize;
 
     if (0 != terminator)
     {
@@ -573,7 +569,24 @@ CorUnix::InternalCreateThread(
         palError = ERROR_INVALID_PARAMETER;
         goto EXIT;
     }
-    
+
+    alignedStackSize = dwStackSize;
+    if (alignedStackSize != 0)
+    {
+        // Some systems require the stack size to be aligned to the page size
+        if (sizeof(alignedStackSize) <= sizeof(dwStackSize) && alignedStackSize + (VIRTUAL_PAGE_SIZE - 1) < alignedStackSize)
+        {
+            // When coming here from the public API surface, the incoming value is originally a nonnegative signed int32, so
+            // this shouldn't happen
+            ASSERT(
+                "Couldn't align the requested stack size (%Iu) to the page size because the stack size was too large\n",
+                alignedStackSize);
+            palError = ERROR_INVALID_PARAMETER;
+            goto EXIT;
+        }
+        alignedStackSize = ALIGN_UP(alignedStackSize, VIRTUAL_PAGE_SIZE);
+    }
+
     // Ignore the STACK_SIZE_PARAM_IS_A_RESERVATION flag
     dwCreationFlags &= ~STACK_SIZE_PARAM_IS_A_RESERVATION;
     
@@ -616,42 +629,34 @@ CorUnix::InternalCreateThread(
     fAttributesInitialized = TRUE;
 
     /* adjust the stack size if necessary */
-    if (0 != pthread_attr_getstacksize(&pthreadAttr, &pthreadStackSize))
+    if (alignedStackSize != 0)
     {
-        ERROR("couldn't set thread stack size\n");
-        palError = ERROR_INTERNAL_ERROR;
-        goto EXIT;        
-    }
-
-    TRACE("default pthread stack size is %d, caller requested %d (default is %d)\n",
-          pthreadStackSize, dwStackSize, CPalThread::s_dwDefaultThreadStackSize);
-
-    if (0 == dwStackSize)
-    {
-        dwStackSize = CPalThread::s_dwDefaultThreadStackSize;
-    }
-
 #ifdef PTHREAD_STACK_MIN
-    if (PTHREAD_STACK_MIN > pthreadStackSize)
-    {
-        WARN("default stack size is reported as %d, but PTHREAD_STACK_MIN is "
-             "%d\n", pthreadStackSize, PTHREAD_STACK_MIN);
-    }
-#endif
-    
-    if (pthreadStackSize < dwStackSize)
-    {
-        TRACE("setting thread stack size to %d\n", dwStackSize);
-        if (0 != pthread_attr_setstacksize(&pthreadAttr, dwStackSize))
+        const size_t MinStackSize = PTHREAD_STACK_MIN;
+#else // !PTHREAD_STACK_MIN
+        const size_t MinStackSize = 64 * 1024; // this value is typically accepted by pthread_attr_setstacksize()
+#endif // PTHREAD_STACK_MIN
+        _ASSERTE(IS_ALIGNED(MinStackSize, VIRTUAL_PAGE_SIZE));
+        if (alignedStackSize < MinStackSize)
         {
-            ERROR("couldn't set pthread stack size to %d\n", dwStackSize);
+            // Adjust the stack size to a minimum value that is likely to be accepted by pthread_attr_setstacksize(). If this
+            // function fails, typically the caller will end up throwing OutOfMemoryException under the assumption that the
+            // requested stack size is too large or the system does not have sufficient memory to create a thread. Try to
+            // prevent failing just just because the stack size value is too low.
+            alignedStackSize = MinStackSize;
+        }
+
+        TRACE("setting thread stack size to %Iu\n", alignedStackSize);
+        if (0 != pthread_attr_setstacksize(&pthreadAttr, alignedStackSize))
+        {
+            ERROR("couldn't set pthread stack size to %Iu\n", alignedStackSize);
             palError = ERROR_INTERNAL_ERROR;
             goto EXIT;
         }
     }
     else
     {
-        TRACE("using the system default thread stack size of %d\n", pthreadStackSize);
+        TRACE("using the system default thread stack size\n");
     }
 
 #if HAVE_THREAD_SELF || HAVE__LWP_SELF
@@ -1755,39 +1760,6 @@ fail:
     return NULL;
 }
 
-
-#define PAL_THREAD_DEFAULT_STACK_SIZE "PAL_THREAD_DEFAULT_STACK_SIZE"
-
-PAL_ERROR
-CorUnix::InitializeGlobalThreadData(
-    void
-    )
-{
-    PAL_ERROR palError = NO_ERROR;
-    char *pszStackSize = NULL;
-
-    //
-    // Read in the environment to see whether we need to change the default
-    // thread stack size.
-    //
-    pszStackSize = EnvironGetenv(PAL_THREAD_DEFAULT_STACK_SIZE);
-    if (NULL != pszStackSize)
-    {
-        // Environment variable exists
-        char *pszEnd;
-        DWORD dw = PAL_strtoul(pszStackSize, &pszEnd, 16); // treat it as hex
-        if ( (pszStackSize != pszEnd) && (0 != dw) )
-        {
-            CPalThread::s_dwDefaultThreadStackSize = dw;
-        }
-
-        free(pszStackSize);
-    }
-
-    return palError;
-}
-
-
 /*++
 Function:
     CreateThreadData
diff --git a/src/pal/tests/palsuite/CMakeLists.txt b/src/pal/tests/palsuite/CMakeLists.txt
index 235b695961..0ea8969bab 100644
--- a/src/pal/tests/palsuite/CMakeLists.txt
+++ b/src/pal/tests/palsuite/CMakeLists.txt
@@ -4,6 +4,16 @@ project(PALTESTSUITE)
 
 include_directories(${PALTESTSUITE_SOURCE_DIR}/common)
 
+# All test will link against these libraries:
+# pthread and m are part of the Android C library (bionic),
+# so we don't need to link them seperately
+if(NOT CLR_CMAKE_PLATFORM_ANDROID)
+  list(APPEND COMMON_TEST_LIBRARIES pthread)
+  list(APPEND COMMON_TEST_LIBRARIES m)
+endif()
+
+list(APPEND COMMON_TEST_LIBRARIES coreclrpal)
+
 add_compile_options(-Wno-incompatible-pointer-types-discards-qualifiers)
 add_compile_options(-Wno-int-to-void-pointer-cast)
 
diff --git a/src/pal/tests/palsuite/c_runtime/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/CMakeLists.txt
index 8225ed2dd4..7a6b2cd919 100644
--- a/src/pal/tests/palsuite/c_runtime/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/CMakeLists.txt
@@ -148,7 +148,6 @@ add_subdirectory(_fullpath)
 # TODO: make this test compile
 # add_subdirectory(_gcvt)
 
-add_subdirectory(_getw)
 add_subdirectory(_isnan)
 add_subdirectory(_isnanf)
 add_subdirectory(_itow)
@@ -157,7 +156,6 @@ add_subdirectory(_mbsinc)
 add_subdirectory(_mbsninc)
 add_subdirectory(_open_osfhandle)
 add_subdirectory(_putenv)
-add_subdirectory(_putw)
 add_subdirectory(_rotl)
 add_subdirectory(_rotr)
 add_subdirectory(_snprintf_s)
diff --git a/src/pal/tests/palsuite/c_runtime/__iscsym/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/__iscsym/test1/CMakeLists.txt
index b4421e77a1..4dd4cf13f0 100644
--- a/src/pal/tests/palsuite/c_runtime/__iscsym/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/__iscsym/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_iscsym_test1
 add_dependencies(paltest_iscsym_test1 coreclrpal)
 
 target_link_libraries(paltest_iscsym_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_alloca/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_alloca/test1/CMakeLists.txt
index 434633be20..97a351c802 100644
--- a/src/pal/tests/palsuite/c_runtime/_alloca/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_alloca/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_alloca_test1
 add_dependencies(paltest_alloca_test1 coreclrpal)
 
 target_link_libraries(paltest_alloca_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_ecvt/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_ecvt/test1/CMakeLists.txt
index e78a802723..152271cf59 100644
--- a/src/pal/tests/palsuite/c_runtime/_ecvt/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_ecvt/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_ecvt_test1
 add_dependencies(paltest_ecvt_test1 coreclrpal)
 
 target_link_libraries(paltest_ecvt_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_fdopen/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_fdopen/test1/CMakeLists.txt
index 60b036f44d..a389b8330a 100644
--- a/src/pal/tests/palsuite/c_runtime/_fdopen/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_fdopen/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fdopen_test1
 add_dependencies(paltest_fdopen_test1 coreclrpal)
 
 target_link_libraries(paltest_fdopen_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_finite/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_finite/test1/CMakeLists.txt
index ac2f25d85a..a376d45be8 100644
--- a/src/pal/tests/palsuite/c_runtime/_finite/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_finite/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_finite_test1
 add_dependencies(paltest_finite_test1 coreclrpal)
 
 target_link_libraries(paltest_finite_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_finitef/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_finitef/test1/CMakeLists.txt
index 9ef630fbb2..a9785e0620 100644
--- a/src/pal/tests/palsuite/c_runtime/_finitef/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_finitef/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_finitef_test1
 add_dependencies(paltest_finitef_test1 coreclrpal)
 
 target_link_libraries(paltest_finitef_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_fullpath/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_fullpath/test1/CMakeLists.txt
index 0c9029f6e2..2915738103 100644
--- a/src/pal/tests/palsuite/c_runtime/_fullpath/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_fullpath/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fullpath_test1
 add_dependencies(paltest_fullpath_test1 coreclrpal)
 
 target_link_libraries(paltest_fullpath_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_gcvt/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_gcvt/test1/CMakeLists.txt
index 47dcb95754..25c652dfcb 100644
--- a/src/pal/tests/palsuite/c_runtime/_gcvt/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_gcvt/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_gcvt_test1
 add_dependencies(paltest_gcvt_test1 coreclrpal)
 
 target_link_libraries(paltest_gcvt_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_gcvt/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_gcvt/test2/CMakeLists.txt
index 5b0f5608f3..b77bff9cdd 100644
--- a/src/pal/tests/palsuite/c_runtime/_gcvt/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_gcvt/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_gcvt_test2
 add_dependencies(paltest_gcvt_test2 coreclrpal)
 
 target_link_libraries(paltest_gcvt_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_getw/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_getw/CMakeLists.txt
deleted file mode 100644
index f6aa0cb2d9..0000000000
--- a/src/pal/tests/palsuite/c_runtime/_getw/CMakeLists.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-cmake_minimum_required(VERSION 2.8.12.2)
-
-add_subdirectory(test1)
-
diff --git a/src/pal/tests/palsuite/c_runtime/_getw/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_getw/test1/CMakeLists.txt
deleted file mode 100644
index 4f763bed6b..0000000000
--- a/src/pal/tests/palsuite/c_runtime/_getw/test1/CMakeLists.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-cmake_minimum_required(VERSION 2.8.12.2)
-
-set(CMAKE_INCLUDE_CURRENT_DIR ON)
-
-set(SOURCES
-  test1.cpp
-)
-
-add_executable(paltest_getw_test1
-  ${SOURCES}
-)
-
-add_dependencies(paltest_getw_test1 coreclrpal)
-
-target_link_libraries(paltest_getw_test1
-  pthread
-  m
-  coreclrpal
-)
diff --git a/src/pal/tests/palsuite/c_runtime/_getw/test1/test.dat b/src/pal/tests/palsuite/c_runtime/_getw/test1/test.dat
deleted file mode 100644
index b20eae054c..0000000000
--- a/src/pal/tests/palsuite/c_runtime/_getw/test1/test.dat
+++ /dev/null
diff --git a/src/pal/tests/palsuite/c_runtime/_getw/test1/test1.cpp b/src/pal/tests/palsuite/c_runtime/_getw/test1/test1.cpp
deleted file mode 100644
index 34ce4ee7de..0000000000
--- a/src/pal/tests/palsuite/c_runtime/_getw/test1/test1.cpp
+++ /dev/null
@@ -1,96 +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.
-
-/*============================================================================
-**
-** Source:  test1.c
-**
-** Purpose: Several integers are read from a previously written file
-**          using _getw.  The test passes if the values read match those known to
-**          be in the file.
-**
-**
-**==========================================================================*/
-
-#include <palsuite.h>
-
-/*Tests _getw using a previously written data file */
-int __cdecl main(int argc, char **argv)
-{
-    const int testValues[] =
-    {
-        0,
-        1,
-        -1,
-        0x7FFFFFFF,            /* largest positive integer on 32 bit systems */
-        0x80000000,            /* largest negative integer on 32 bit systems */
-        0xFFFFFFFF,
-        0xFFFFAAAA
-    };
-
-    int i = 0;
-    int input = 0;
-
-    const char filename[] = "test.dat";
-
-
-    FILE *fp = NULL;
-
-    /*
-     * Initialize the PAL and return FAIL if this fails
-     */
-    if (0 != (PAL_Initialize(argc, argv)))
-    {
-        return FAIL;
-    }
-
-    /* write the file that we will use to test */
-
-
-    /*
-      Don't uncomment this code, it was used to create the data file
-      initially on windows, but if it is run on all test platforms, the
-      tests will always pass.
-
-      fp = fopen(filename, "w");
-      if (fp == NULL)
-      {
-      Fail("Unable to open file for write.\n");
-      }
-      for (i = 0; i < sizeof(testValues) / sizeof(testValues[0]); i++)
-      {
-      _putw(testValues[i], fp);
-      }
-
-      if (fclose(fp) != 0)
-      {
-      Fail("Error closing file after writing to it with _putw.\n");
-      }
-    */
-
-
-    /*Now read values back from the file and see if they match.*/
-    fp = fopen(filename, "r");
-    if (fp == NULL)
-    {
-        Fail ("Unable to open file for read.\n");
-    }
-    for (i = 0; i < sizeof(testValues) / sizeof(testValues[0]); i++)
-    {
-        input = _getw(fp);
-        if (VAL32(input) != testValues[i])
-        {
-            Fail ("_getw did not get the expected values when reading "
-                    "from a file.\n");
-        }
-    }
-
-    if (fclose(fp) != 0)
-    {
-        Fail ("Error closing file after reading from it with _getw\n");
-    }
-    PAL_Terminate();
-    return PASS;
-}
-
diff --git a/src/pal/tests/palsuite/c_runtime/_getw/test1/testinfo.dat b/src/pal/tests/palsuite/c_runtime/_getw/test1/testinfo.dat
deleted file mode 100644
index 4044dadbcc..0000000000
--- a/src/pal/tests/palsuite/c_runtime/_getw/test1/testinfo.dat
+++ /dev/null
@@ -1,15 +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.
-
-Version = 1.0
-Section = C Runtime
-Function = _getw
-Name = Positive Test for _getw
-TYPE = DEFAULT
-EXE1 = test1
-Description
-=Several integers are read from a previously written file
-=using _getw.  The test passes if the values read match those known to
-=be in the file.
-
diff --git a/src/pal/tests/palsuite/c_runtime/_isnan/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_isnan/test1/CMakeLists.txt
index 106ccb93d7..8c949ed001 100644
--- a/src/pal/tests/palsuite/c_runtime/_isnan/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_isnan/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_isnan_test1
 add_dependencies(paltest_isnan_test1 coreclrpal)
 
 target_link_libraries(paltest_isnan_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_isnanf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_isnanf/test1/CMakeLists.txt
index a8d42aa975..485c30ec3f 100644
--- a/src/pal/tests/palsuite/c_runtime/_isnanf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_isnanf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_isnanf_test1
 add_dependencies(paltest_isnanf_test1 coreclrpal)
 
 target_link_libraries(paltest_isnanf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_itow/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_itow/test1/CMakeLists.txt
index 2c5d57bd34..bbeeb484e0 100644
--- a/src/pal/tests/palsuite/c_runtime/_itow/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_itow/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_itow_test1
 add_dependencies(paltest_itow_test1 coreclrpal)
 
 target_link_libraries(paltest_itow_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_mbsdec/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_mbsdec/test1/CMakeLists.txt
index b016f27982..96319ac3b0 100644
--- a/src/pal/tests/palsuite/c_runtime/_mbsdec/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_mbsdec/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_mbsdec_test1
 add_dependencies(paltest_mbsdec_test1 coreclrpal)
 
 target_link_libraries(paltest_mbsdec_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_mbsinc/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_mbsinc/test1/CMakeLists.txt
index c7325b9513..7e3a015e5f 100644
--- a/src/pal/tests/palsuite/c_runtime/_mbsinc/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_mbsinc/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_mbsinc_test1
 add_dependencies(paltest_mbsinc_test1 coreclrpal)
 
 target_link_libraries(paltest_mbsinc_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_mbsninc/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_mbsninc/test1/CMakeLists.txt
index 81c6c23a53..26a44c9010 100644
--- a/src/pal/tests/palsuite/c_runtime/_mbsninc/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_mbsninc/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_mbsninc_test1
 add_dependencies(paltest_mbsninc_test1 coreclrpal)
 
 target_link_libraries(paltest_mbsninc_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_open_osfhandle/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_open_osfhandle/test1/CMakeLists.txt
index f4fedb61ae..503a6d928c 100644
--- a/src/pal/tests/palsuite/c_runtime/_open_osfhandle/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_open_osfhandle/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_open_osfhandle_test1
 add_dependencies(paltest_open_osfhandle_test1 coreclrpal)
 
 target_link_libraries(paltest_open_osfhandle_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_open_osfhandle/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_open_osfhandle/test2/CMakeLists.txt
index 6086868de2..e37cec2db3 100644
--- a/src/pal/tests/palsuite/c_runtime/_open_osfhandle/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_open_osfhandle/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_open_osfhandle_test2
 add_dependencies(paltest_open_osfhandle_test2 coreclrpal)
 
 target_link_libraries(paltest_open_osfhandle_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_putenv/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_putenv/test1/CMakeLists.txt
index 9096bc1033..e49d53f82a 100644
--- a/src/pal/tests/palsuite/c_runtime/_putenv/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_putenv/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_putenv_test1
 add_dependencies(paltest_putenv_test1 coreclrpal)
 
 target_link_libraries(paltest_putenv_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_putenv/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_putenv/test2/CMakeLists.txt
index ad99eba373..6c6d139b77 100644
--- a/src/pal/tests/palsuite/c_runtime/_putenv/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_putenv/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_putenv_test2
 add_dependencies(paltest_putenv_test2 coreclrpal)
 
 target_link_libraries(paltest_putenv_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_putenv/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_putenv/test3/CMakeLists.txt
index fc97b951b3..2d98fd18ec 100644
--- a/src/pal/tests/palsuite/c_runtime/_putenv/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_putenv/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_putenv_test3
 add_dependencies(paltest_putenv_test3 coreclrpal)
 
 target_link_libraries(paltest_putenv_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_putenv/test4/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_putenv/test4/CMakeLists.txt
index 3881626d01..9bcd973558 100644
--- a/src/pal/tests/palsuite/c_runtime/_putenv/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_putenv/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_putenv_test4
 add_dependencies(paltest_putenv_test4 coreclrpal)
 
 target_link_libraries(paltest_putenv_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_putw/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_putw/CMakeLists.txt
deleted file mode 100644
index f6aa0cb2d9..0000000000
--- a/src/pal/tests/palsuite/c_runtime/_putw/CMakeLists.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-cmake_minimum_required(VERSION 2.8.12.2)
-
-add_subdirectory(test1)
-
diff --git a/src/pal/tests/palsuite/c_runtime/_putw/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_putw/test1/CMakeLists.txt
deleted file mode 100644
index 78833d4e13..0000000000
--- a/src/pal/tests/palsuite/c_runtime/_putw/test1/CMakeLists.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-cmake_minimum_required(VERSION 2.8.12.2)
-
-set(CMAKE_INCLUDE_CURRENT_DIR ON)
-
-set(SOURCES
-  test1.cpp
-)
-
-add_executable(paltest_putw_test1
-  ${SOURCES}
-)
-
-add_dependencies(paltest_putw_test1 coreclrpal)
-
-target_link_libraries(paltest_putw_test1
-  pthread
-  m
-  coreclrpal
-)
diff --git a/src/pal/tests/palsuite/c_runtime/_putw/test1/test1.cpp b/src/pal/tests/palsuite/c_runtime/_putw/test1/test1.cpp
deleted file mode 100644
index 02b7cc7a49..0000000000
--- a/src/pal/tests/palsuite/c_runtime/_putw/test1/test1.cpp
+++ /dev/null
@@ -1,112 +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.
-
-/*============================================================================
-**
-** Source:  test1.c
-**
-** Purpose: Writes a series of integers to a file, test.dat,
-**          then verifies the results.
-**
-** Dependency: fopen(...)
-**             fclose(...)
-**             CloseHandle(...) 
-**             DeleteFileA(...)
-**             _getw(...)
-**
-**
-**
-**==========================================================================*/
-
-
-#include <palsuite.h>
-
-const char testFileName[] = "test.dat";
-
-static void Cleanup(HANDLE hFile)
-{
-    if (fclose((PAL_FILE*)hFile))
-    {
-        Trace("_putw: ERROR -> Unable to close file \"%s\".\n", 
-            testFileName);
-    }
-    if (!DeleteFileA(testFileName))
-    {
-        Trace("_putw: ERROR -> Unable to delete file \"%s\". ", 
-            "GetLastError returned %u.\n", 
-            testFileName,
-            GetLastError());
-    }
-}
-
-
-int __cdecl main(int argc, char **argv)
-{
-
-    FILE * pfTest = NULL;
-    int  testArray[] = {0,1,-1,0x7FFFFFFF,0x80000000,0xFFFFFFFF,0xFFFFAAAA};
-    int  i = 0;
-    int  retValue = 0;
-
-    /*
-     *  Initialize the PAL and return FAIL if this fails
-     */
-    if (0 != (PAL_Initialize(argc, argv)))
-    {
-        return FAIL;
-    }
-
-    /*write the file that we will use to test */
-    pfTest = fopen(testFileName, "w");
-    if (pfTest == NULL)
-    {
-        Fail ("Unable to write test file.\n");
-    }
-
-    for (i = 0; i < sizeof(testArray)/sizeof(int) ; i++)
-    {
-        _putw(testArray[i], pfTest);
-
-        if( ferror( pfTest ) )        
-    {
-            Cleanup(pfTest);
-            Fail( "Error:in _putw -> error has occurred in the "
-                "stream while writing to the file: \"test.dat\"\n");
-        }
-      
-    }
-
-    if (fclose(pfTest) != 0)
-    {
-        Cleanup(pfTest);
-        Fail ("Error closing file after writing with _putw(..).\n");
-    }
-
-    /*open the new test file and compare*/
-    pfTest = fopen(testFileName, "r");
-    if (pfTest == NULL)
-    {
-        Fail ("Error opening \"%s\", which is odd, since I just finished "
-                "creating that file.\n", testFileName);
-    }
-    retValue =_getw( pfTest );
-    i = 0;
-    while(retValue != EOF)
-    {
-        if(retValue != testArray[i])
-        {
-            Cleanup(pfTest);
-            Fail ("Integers written by _putw are not in the correct format\n",
-                testFileName);
-        }
-        retValue = _getw( pfTest );
-        i++ ;
-    }
-
-    Cleanup(pfTest);  
-    PAL_Terminate();
-    return PASS;
-}
-
-
diff --git a/src/pal/tests/palsuite/c_runtime/_putw/test1/testinfo.dat b/src/pal/tests/palsuite/c_runtime/_putw/test1/testinfo.dat
deleted file mode 100644
index 3007b82407..0000000000
--- a/src/pal/tests/palsuite/c_runtime/_putw/test1/testinfo.dat
+++ /dev/null
@@ -1,13 +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.
-
-Version = 1.0
-Section = C Runtime
-Function = _putw
-Name = Positive test for _putw
-TYPE = DEFAULT
-EXE1 = test1
-Description
-= Several integers are written to a new file using _putw.  This file is
-= closed, reopened and read from to verify the writes were successful.
diff --git a/src/pal/tests/palsuite/c_runtime/_rotl/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_rotl/test1/CMakeLists.txt
index bafaa23732..8aed25d776 100644
--- a/src/pal/tests/palsuite/c_runtime/_rotl/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_rotl/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_rotl_test1
 add_dependencies(paltest_rotl_test1 coreclrpal)
 
 target_link_libraries(paltest_rotl_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_rotr/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_rotr/test1/CMakeLists.txt
index c0c76feb36..ff84c62fb1 100644
--- a/src/pal/tests/palsuite/c_runtime/_rotr/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_rotr/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_rotr_test1
 add_dependencies(paltest_rotr_test1 coreclrpal)
 
 target_link_libraries(paltest_rotr_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test1/CMakeLists.txt
index 9e4c671ec8..7ec4817f61 100644
--- a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snprintf_test1
 add_dependencies(paltest_snprintf_test1 coreclrpal)
 
 target_link_libraries(paltest_snprintf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test10/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test10/CMakeLists.txt
index 57e7fb16d3..8a61bc45e6 100644
--- a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test10/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test10/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snprintf_test10
 add_dependencies(paltest_snprintf_test10 coreclrpal)
 
 target_link_libraries(paltest_snprintf_test10
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test11/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test11/CMakeLists.txt
index 4fc179c5a8..5fe253463f 100644
--- a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test11/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test11/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snprintf_test11
 add_dependencies(paltest_snprintf_test11 coreclrpal)
 
 target_link_libraries(paltest_snprintf_test11
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test12/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test12/CMakeLists.txt
index a35609eb57..9eade54151 100644
--- a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test12/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test12/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snprintf_test12
 add_dependencies(paltest_snprintf_test12 coreclrpal)
 
 target_link_libraries(paltest_snprintf_test12
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test13/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test13/CMakeLists.txt
index 3bf986e851..1e31d2c94c 100644
--- a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test13/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test13/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snprintf_test13
 add_dependencies(paltest_snprintf_test13 coreclrpal)
 
 target_link_libraries(paltest_snprintf_test13
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test14/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test14/CMakeLists.txt
index 985303ecf8..1af6846df8 100644
--- a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test14/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test14/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snprintf_test14
 add_dependencies(paltest_snprintf_test14 coreclrpal)
 
 target_link_libraries(paltest_snprintf_test14
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test15/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test15/CMakeLists.txt
index c7f5796089..8287fd37d6 100644
--- a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test15/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test15/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snprintf_test15
 add_dependencies(paltest_snprintf_test15 coreclrpal)
 
 target_link_libraries(paltest_snprintf_test15
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test16/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test16/CMakeLists.txt
index 9a224bc23b..b45696e78d 100644
--- a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test16/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test16/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snprintf_test16
 add_dependencies(paltest_snprintf_test16 coreclrpal)
 
 target_link_libraries(paltest_snprintf_test16
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test17/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test17/CMakeLists.txt
index 3a8a349c84..60d34ebb4c 100644
--- a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test17/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test17/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snprintf_test17
 add_dependencies(paltest_snprintf_test17 coreclrpal)
 
 target_link_libraries(paltest_snprintf_test17
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test18/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test18/CMakeLists.txt
index 96e39e8f41..2bd5200e68 100644
--- a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test18/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test18/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snprintf_test18
 add_dependencies(paltest_snprintf_test18 coreclrpal)
 
 target_link_libraries(paltest_snprintf_test18
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test19/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test19/CMakeLists.txt
index be3570f163..1d9e283eb0 100644
--- a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test19/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test19/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snprintf_test19
 add_dependencies(paltest_snprintf_test19 coreclrpal)
 
 target_link_libraries(paltest_snprintf_test19
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test2/CMakeLists.txt
index 11d18e61c3..134aeaadd9 100644
--- a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snprintf_test2
 add_dependencies(paltest_snprintf_test2 coreclrpal)
 
 target_link_libraries(paltest_snprintf_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test3/CMakeLists.txt
index b8d4178962..198f725a0c 100644
--- a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snprintf_test3
 add_dependencies(paltest_snprintf_test3 coreclrpal)
 
 target_link_libraries(paltest_snprintf_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test4/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test4/CMakeLists.txt
index 568b7122de..81c3c1a0fe 100644
--- a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snprintf_test4
 add_dependencies(paltest_snprintf_test4 coreclrpal)
 
 target_link_libraries(paltest_snprintf_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test6/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test6/CMakeLists.txt
index 820cc66d55..08ead969f1 100644
--- a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snprintf_test6
 add_dependencies(paltest_snprintf_test6 coreclrpal)
 
 target_link_libraries(paltest_snprintf_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test7/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test7/CMakeLists.txt
index a2af7c4a8c..71564eacf6 100644
--- a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snprintf_test7
 add_dependencies(paltest_snprintf_test7 coreclrpal)
 
 target_link_libraries(paltest_snprintf_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test8/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test8/CMakeLists.txt
index 53545c5dbf..377883308b 100644
--- a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test8/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test8/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snprintf_test8
 add_dependencies(paltest_snprintf_test8 coreclrpal)
 
 target_link_libraries(paltest_snprintf_test8
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test9/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test9/CMakeLists.txt
index 33ca9db7a8..90a5403de7 100644
--- a/src/pal/tests/palsuite/c_runtime/_snprintf_s/test9/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snprintf_s/test9/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snprintf_test9
 add_dependencies(paltest_snprintf_test9 coreclrpal)
 
 target_link_libraries(paltest_snprintf_test9
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test1/CMakeLists.txt
index eac86f30e4..89496c562a 100644
--- a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snwprintf_test1
 add_dependencies(paltest_snwprintf_test1 coreclrpal)
 
 target_link_libraries(paltest_snwprintf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test10/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test10/CMakeLists.txt
index 82ee739587..60703fa163 100644
--- a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test10/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test10/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snwprintf_test10
 add_dependencies(paltest_snwprintf_test10 coreclrpal)
 
 target_link_libraries(paltest_snwprintf_test10
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test11/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test11/CMakeLists.txt
index f7d7845571..c305c62f31 100644
--- a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test11/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test11/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snwprintf_test11
 add_dependencies(paltest_snwprintf_test11 coreclrpal)
 
 target_link_libraries(paltest_snwprintf_test11
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test12/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test12/CMakeLists.txt
index 5b926fb548..9532e67932 100644
--- a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test12/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test12/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snwprintf_test12
 add_dependencies(paltest_snwprintf_test12 coreclrpal)
 
 target_link_libraries(paltest_snwprintf_test12
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test13/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test13/CMakeLists.txt
index 52a3c75a15..f1088003e7 100644
--- a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test13/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test13/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snwprintf_test13
 add_dependencies(paltest_snwprintf_test13 coreclrpal)
 
 target_link_libraries(paltest_snwprintf_test13
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test14/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test14/CMakeLists.txt
index d557a30b42..79a04329ca 100644
--- a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test14/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test14/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snwprintf_test14
 add_dependencies(paltest_snwprintf_test14 coreclrpal)
 
 target_link_libraries(paltest_snwprintf_test14
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test15/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test15/CMakeLists.txt
index 2e5ee362fc..c29ec7d925 100644
--- a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test15/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test15/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snwprintf_test15
 add_dependencies(paltest_snwprintf_test15 coreclrpal)
 
 target_link_libraries(paltest_snwprintf_test15
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test16/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test16/CMakeLists.txt
index f4ce409dcb..d42726644a 100644
--- a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test16/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test16/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snwprintf_test16
 add_dependencies(paltest_snwprintf_test16 coreclrpal)
 
 target_link_libraries(paltest_snwprintf_test16
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test17/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test17/CMakeLists.txt
index 159e15dafe..37fb79012c 100644
--- a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test17/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test17/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snwprintf_test17
 add_dependencies(paltest_snwprintf_test17 coreclrpal)
 
 target_link_libraries(paltest_snwprintf_test17
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test18/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test18/CMakeLists.txt
index 5964e849a4..a880738a9c 100644
--- a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test18/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test18/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snwprintf_test18
 add_dependencies(paltest_snwprintf_test18 coreclrpal)
 
 target_link_libraries(paltest_snwprintf_test18
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test19/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test19/CMakeLists.txt
index 5d84847ec1..cb16e1e15b 100644
--- a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test19/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test19/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snwprintf_test19
 add_dependencies(paltest_snwprintf_test19 coreclrpal)
 
 target_link_libraries(paltest_snwprintf_test19
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test2/CMakeLists.txt
index ea33d48bd5..4307aa71c4 100644
--- a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snwprintf_test2
 add_dependencies(paltest_snwprintf_test2 coreclrpal)
 
 target_link_libraries(paltest_snwprintf_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test3/CMakeLists.txt
index 5095b1a12e..c5278f4879 100644
--- a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snwprintf_test3
 add_dependencies(paltest_snwprintf_test3 coreclrpal)
 
 target_link_libraries(paltest_snwprintf_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test4/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test4/CMakeLists.txt
index 9cf81ea1bd..26229d719a 100644
--- a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snwprintf_test4
 add_dependencies(paltest_snwprintf_test4 coreclrpal)
 
 target_link_libraries(paltest_snwprintf_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test6/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test6/CMakeLists.txt
index 4996c7716f..542e943f89 100644
--- a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snwprintf_test6
 add_dependencies(paltest_snwprintf_test6 coreclrpal)
 
 target_link_libraries(paltest_snwprintf_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test7/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test7/CMakeLists.txt
index 0e55fbf4d7..0905c5d08b 100644
--- a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snwprintf_test7
 add_dependencies(paltest_snwprintf_test7 coreclrpal)
 
 target_link_libraries(paltest_snwprintf_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test8/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test8/CMakeLists.txt
index 8f7fbda5a0..a31a7f9f8f 100644
--- a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test8/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test8/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snwprintf_test8
 add_dependencies(paltest_snwprintf_test8 coreclrpal)
 
 target_link_libraries(paltest_snwprintf_test8
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test9/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test9/CMakeLists.txt
index f769c9eaa5..90157fdd03 100644
--- a/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test9/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_snwprintf_s/test9/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_snwprintf_test9
 add_dependencies(paltest_snwprintf_test9 coreclrpal)
 
 target_link_libraries(paltest_snwprintf_test9
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_stricmp/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_stricmp/test1/CMakeLists.txt
index 03aa3a523e..a0380a4404 100644
--- a/src/pal/tests/palsuite/c_runtime/_stricmp/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_stricmp/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_stricmp_test1
 add_dependencies(paltest_stricmp_test1 coreclrpal)
 
 target_link_libraries(paltest_stricmp_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_strlwr/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_strlwr/test1/CMakeLists.txt
index ca26961b3c..bef0a7ed60 100644
--- a/src/pal/tests/palsuite/c_runtime/_strlwr/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_strlwr/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_strlwr_test1
 add_dependencies(paltest_strlwr_test1 coreclrpal)
 
 target_link_libraries(paltest_strlwr_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_strnicmp/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_strnicmp/test1/CMakeLists.txt
index 03f9992198..2429339a6d 100644
--- a/src/pal/tests/palsuite/c_runtime/_strnicmp/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_strnicmp/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_strnicmp_test1
 add_dependencies(paltest_strnicmp_test1 coreclrpal)
 
 target_link_libraries(paltest_strnicmp_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test1/CMakeLists.txt
index 489b7bf566..ee97f2bf16 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnprintf_test1
 add_dependencies(paltest_vsnprintf_test1 coreclrpal)
 
 target_link_libraries(paltest_vsnprintf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test10/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test10/CMakeLists.txt
index bc35dbd0c2..ad067ccd7d 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test10/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test10/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnprintf_test10
 add_dependencies(paltest_vsnprintf_test10 coreclrpal)
 
 target_link_libraries(paltest_vsnprintf_test10
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test11/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test11/CMakeLists.txt
index bf3dd9a534..9fb2b903de 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test11/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test11/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnprintf_test11
 add_dependencies(paltest_vsnprintf_test11 coreclrpal)
 
 target_link_libraries(paltest_vsnprintf_test11
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test12/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test12/CMakeLists.txt
index 9fceeaf7a5..f78711cfdf 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test12/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test12/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnprintf_test12
 add_dependencies(paltest_vsnprintf_test12 coreclrpal)
 
 target_link_libraries(paltest_vsnprintf_test12
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test13/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test13/CMakeLists.txt
index 7e805f6ad4..b37300c6d7 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test13/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test13/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnprintf_test13
 add_dependencies(paltest_vsnprintf_test13 coreclrpal)
 
 target_link_libraries(paltest_vsnprintf_test13
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test14/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test14/CMakeLists.txt
index 6e4566b577..97098d48c7 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test14/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test14/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnprintf_test14
 add_dependencies(paltest_vsnprintf_test14 coreclrpal)
 
 target_link_libraries(paltest_vsnprintf_test14
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test15/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test15/CMakeLists.txt
index d9039b39b7..95e5a475f9 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test15/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test15/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnprintf_test15
 add_dependencies(paltest_vsnprintf_test15 coreclrpal)
 
 target_link_libraries(paltest_vsnprintf_test15
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test16/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test16/CMakeLists.txt
index b298df318b..1fd88667d8 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test16/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test16/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnprintf_test16
 add_dependencies(paltest_vsnprintf_test16 coreclrpal)
 
 target_link_libraries(paltest_vsnprintf_test16
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test17/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test17/CMakeLists.txt
index b195f334d3..ffd52caa65 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test17/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test17/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnprintf_test17
 add_dependencies(paltest_vsnprintf_test17 coreclrpal)
 
 target_link_libraries(paltest_vsnprintf_test17
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test18/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test18/CMakeLists.txt
index f0f6d1124e..1bd8e3bc5a 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test18/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test18/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnprintf_test18
 add_dependencies(paltest_vsnprintf_test18 coreclrpal)
 
 target_link_libraries(paltest_vsnprintf_test18
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test19/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test19/CMakeLists.txt
index 44b38902ef..3848c130b0 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test19/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test19/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnprintf_test19
 add_dependencies(paltest_vsnprintf_test19 coreclrpal)
 
 target_link_libraries(paltest_vsnprintf_test19
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test2/CMakeLists.txt
index 1d3910e70c..5bdf0acff3 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnprintf_test2
 add_dependencies(paltest_vsnprintf_test2 coreclrpal)
 
 target_link_libraries(paltest_vsnprintf_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test3/CMakeLists.txt
index 62d765ec5f..7268cf17f7 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnprintf_test3
 add_dependencies(paltest_vsnprintf_test3 coreclrpal)
 
 target_link_libraries(paltest_vsnprintf_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test4/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test4/CMakeLists.txt
index 5662bd57ad..f2419479fd 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnprintf_test4
 add_dependencies(paltest_vsnprintf_test4 coreclrpal)
 
 target_link_libraries(paltest_vsnprintf_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test6/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test6/CMakeLists.txt
index d80d433c22..3c6b43fe20 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnprintf_test6
 add_dependencies(paltest_vsnprintf_test6 coreclrpal)
 
 target_link_libraries(paltest_vsnprintf_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test7/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test7/CMakeLists.txt
index a1dc0a7c2c..6708b39001 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnprintf_test7
 add_dependencies(paltest_vsnprintf_test7 coreclrpal)
 
 target_link_libraries(paltest_vsnprintf_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test8/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test8/CMakeLists.txt
index 1ca4732492..8a396fdcf2 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test8/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test8/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnprintf_test8
 add_dependencies(paltest_vsnprintf_test8 coreclrpal)
 
 target_link_libraries(paltest_vsnprintf_test8
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test9/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test9/CMakeLists.txt
index 583971fe5a..136856b649 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test9/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnprintf_s/test9/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnprintf_test9
 add_dependencies(paltest_vsnprintf_test9 coreclrpal)
 
 target_link_libraries(paltest_vsnprintf_test9
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test1/CMakeLists.txt
index d1245168f3..0138111408 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnwprintf_test1
 add_dependencies(paltest_vsnwprintf_test1 coreclrpal)
 
 target_link_libraries(paltest_vsnwprintf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test10/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test10/CMakeLists.txt
index 6367964f1d..e669b1e47c 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test10/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test10/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnwprintf_test10
 add_dependencies(paltest_vsnwprintf_test10 coreclrpal)
 
 target_link_libraries(paltest_vsnwprintf_test10
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test11/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test11/CMakeLists.txt
index b45fd0ed1e..acb914b93e 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test11/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test11/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnwprintf_test11
 add_dependencies(paltest_vsnwprintf_test11 coreclrpal)
 
 target_link_libraries(paltest_vsnwprintf_test11
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test12/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test12/CMakeLists.txt
index 2a15b198c0..0d83d5be91 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test12/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test12/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnwprintf_test12
 add_dependencies(paltest_vsnwprintf_test12 coreclrpal)
 
 target_link_libraries(paltest_vsnwprintf_test12
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test13/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test13/CMakeLists.txt
index 01ab97cc62..27f37405f4 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test13/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test13/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnwprintf_test13
 add_dependencies(paltest_vsnwprintf_test13 coreclrpal)
 
 target_link_libraries(paltest_vsnwprintf_test13
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test14/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test14/CMakeLists.txt
index c6c990312f..6e0a35e8b5 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test14/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test14/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnwprintf_test14
 add_dependencies(paltest_vsnwprintf_test14 coreclrpal)
 
 target_link_libraries(paltest_vsnwprintf_test14
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test15/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test15/CMakeLists.txt
index e1a32b1825..f13b1f28bb 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test15/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test15/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnwprintf_test15
 add_dependencies(paltest_vsnwprintf_test15 coreclrpal)
 
 target_link_libraries(paltest_vsnwprintf_test15
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test16/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test16/CMakeLists.txt
index 9e2b25b308..2b45d4c77e 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test16/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test16/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnwprintf_test16
 add_dependencies(paltest_vsnwprintf_test16 coreclrpal)
 
 target_link_libraries(paltest_vsnwprintf_test16
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test17/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test17/CMakeLists.txt
index 2d8ba31a08..a4cc151d5e 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test17/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test17/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnwprintf_test17
 add_dependencies(paltest_vsnwprintf_test17 coreclrpal)
 
 target_link_libraries(paltest_vsnwprintf_test17
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test18/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test18/CMakeLists.txt
index 503856c2f3..9bf17f3e33 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test18/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test18/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnwprintf_test18
 add_dependencies(paltest_vsnwprintf_test18 coreclrpal)
 
 target_link_libraries(paltest_vsnwprintf_test18
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test19/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test19/CMakeLists.txt
index 68485eff12..7f95eb1429 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test19/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test19/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnwprintf_test19
 add_dependencies(paltest_vsnwprintf_test19 coreclrpal)
 
 target_link_libraries(paltest_vsnwprintf_test19
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test2/CMakeLists.txt
index a512be6e47..27231e9de6 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnwprintf_test2
 add_dependencies(paltest_vsnwprintf_test2 coreclrpal)
 
 target_link_libraries(paltest_vsnwprintf_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test3/CMakeLists.txt
index 7991c25afc..205e5a5272 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnwprintf_test3
 add_dependencies(paltest_vsnwprintf_test3 coreclrpal)
 
 target_link_libraries(paltest_vsnwprintf_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test4/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test4/CMakeLists.txt
index 18f5d02df2..fd2666e974 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnwprintf_test4
 add_dependencies(paltest_vsnwprintf_test4 coreclrpal)
 
 target_link_libraries(paltest_vsnwprintf_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test6/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test6/CMakeLists.txt
index c431da4a00..1ff12213f7 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnwprintf_test6
 add_dependencies(paltest_vsnwprintf_test6 coreclrpal)
 
 target_link_libraries(paltest_vsnwprintf_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test7/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test7/CMakeLists.txt
index 5759b836b5..fe46de483d 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnwprintf_test7
 add_dependencies(paltest_vsnwprintf_test7 coreclrpal)
 
 target_link_libraries(paltest_vsnwprintf_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test8/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test8/CMakeLists.txt
index 5e8a6284a5..7ce0aa81ab 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test8/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test8/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnwprintf_test8
 add_dependencies(paltest_vsnwprintf_test8 coreclrpal)
 
 target_link_libraries(paltest_vsnwprintf_test8
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test9/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test9/CMakeLists.txt
index 323365dcd9..69a9de3a54 100644
--- a/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test9/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test9/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsnwprintf_test9
 add_dependencies(paltest_vsnwprintf_test9 coreclrpal)
 
 target_link_libraries(paltest_vsnwprintf_test9
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_wcsicmp/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_wcsicmp/test1/CMakeLists.txt
index 023b777cab..1a70e342c6 100644
--- a/src/pal/tests/palsuite/c_runtime/_wcsicmp/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_wcsicmp/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcsicmp_test1
 add_dependencies(paltest_wcsicmp_test1 coreclrpal)
 
 target_link_libraries(paltest_wcsicmp_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_wcslwr/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_wcslwr/test1/CMakeLists.txt
index b9df132d29..b10e14ceb7 100644
--- a/src/pal/tests/palsuite/c_runtime/_wcslwr/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_wcslwr/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcslwr_test1
 add_dependencies(paltest_wcslwr_test1 coreclrpal)
 
 target_link_libraries(paltest_wcslwr_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_wcsnicmp/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_wcsnicmp/test1/CMakeLists.txt
index ea22daa477..3fa3b3842d 100644
--- a/src/pal/tests/palsuite/c_runtime/_wcsnicmp/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_wcsnicmp/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcsnicmp_test1
 add_dependencies(paltest_wcsnicmp_test1 coreclrpal)
 
 target_link_libraries(paltest_wcsnicmp_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_wfopen/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_wfopen/test1/CMakeLists.txt
index f7aa22d5b2..35498c0ecc 100644
--- a/src/pal/tests/palsuite/c_runtime/_wfopen/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_wfopen/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wfopen_test1
 add_dependencies(paltest_wfopen_test1 coreclrpal)
 
 target_link_libraries(paltest_wfopen_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_wfopen/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_wfopen/test2/CMakeLists.txt
index 3159889f0a..5a049441b7 100644
--- a/src/pal/tests/palsuite/c_runtime/_wfopen/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_wfopen/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wfopen_test2
 add_dependencies(paltest_wfopen_test2 coreclrpal)
 
 target_link_libraries(paltest_wfopen_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_wfopen/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_wfopen/test3/CMakeLists.txt
index 06d0941471..1a1656ebf7 100644
--- a/src/pal/tests/palsuite/c_runtime/_wfopen/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_wfopen/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wfopen_test3
 add_dependencies(paltest_wfopen_test3 coreclrpal)
 
 target_link_libraries(paltest_wfopen_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_wfopen/test4/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_wfopen/test4/CMakeLists.txt
index 8253d75d8d..bc56cd9507 100644
--- a/src/pal/tests/palsuite/c_runtime/_wfopen/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_wfopen/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wfopen_test4
 add_dependencies(paltest_wfopen_test4 coreclrpal)
 
 target_link_libraries(paltest_wfopen_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_wfopen/test5/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_wfopen/test5/CMakeLists.txt
index 8b3d064ec6..42caa20594 100644
--- a/src/pal/tests/palsuite/c_runtime/_wfopen/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_wfopen/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wfopen_test5
 add_dependencies(paltest_wfopen_test5 coreclrpal)
 
 target_link_libraries(paltest_wfopen_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_wfopen/test6/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_wfopen/test6/CMakeLists.txt
index bf1eaeca27..c2fb9e7b8b 100644
--- a/src/pal/tests/palsuite/c_runtime/_wfopen/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_wfopen/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wfopen_test6
 add_dependencies(paltest_wfopen_test6 coreclrpal)
 
 target_link_libraries(paltest_wfopen_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_wfopen/test7/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_wfopen/test7/CMakeLists.txt
index 5d04528a21..13f7b00a20 100644
--- a/src/pal/tests/palsuite/c_runtime/_wfopen/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_wfopen/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wfopen_test7
 add_dependencies(paltest_wfopen_test7 coreclrpal)
 
 target_link_libraries(paltest_wfopen_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/_wtoi/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/_wtoi/test1/CMakeLists.txt
index ed02fec3af..b04d4abbe6 100644
--- a/src/pal/tests/palsuite/c_runtime/_wtoi/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/_wtoi/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wtoi_test1
 add_dependencies(paltest_wtoi_test1 coreclrpal)
 
 target_link_libraries(paltest_wtoi_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/abs/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/abs/test1/CMakeLists.txt
index b01d97ff2f..c09c03939c 100644
--- a/src/pal/tests/palsuite/c_runtime/abs/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/abs/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_abs_test1
 add_dependencies(paltest_abs_test1 coreclrpal)
 
 target_link_libraries(paltest_abs_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/acos/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/acos/test1/CMakeLists.txt
index 5bd3ae06e8..7f473d072d 100644
--- a/src/pal/tests/palsuite/c_runtime/acos/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/acos/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_acos_test1
 add_dependencies(paltest_acos_test1 coreclrpal)
 
 target_link_libraries(paltest_acos_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/acosf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/acosf/test1/CMakeLists.txt
index 2643647438..095be954de 100644
--- a/src/pal/tests/palsuite/c_runtime/acosf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/acosf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_acosf_test1
 add_dependencies(paltest_acosf_test1 coreclrpal)
 
 target_link_libraries(paltest_acosf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/asin/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/asin/test1/CMakeLists.txt
index 510b543a59..3537fe6efe 100644
--- a/src/pal/tests/palsuite/c_runtime/asin/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/asin/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_asin_test1
 add_dependencies(paltest_asin_test1 coreclrpal)
 
 target_link_libraries(paltest_asin_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/asinf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/asinf/test1/CMakeLists.txt
index b167bd8715..46661a745a 100644
--- a/src/pal/tests/palsuite/c_runtime/asinf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/asinf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_asinf_test1
 add_dependencies(paltest_asinf_test1 coreclrpal)
 
 target_link_libraries(paltest_asinf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/atan/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/atan/test1/CMakeLists.txt
index ace64e48bc..ef6cca78d2 100644
--- a/src/pal/tests/palsuite/c_runtime/atan/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/atan/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_atan_test1
 add_dependencies(paltest_atan_test1 coreclrpal)
 
 target_link_libraries(paltest_atan_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/atan2/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/atan2/test1/CMakeLists.txt
index cafa09f7fe..4246b3730a 100644
--- a/src/pal/tests/palsuite/c_runtime/atan2/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/atan2/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_atan2_test1
 add_dependencies(paltest_atan2_test1 coreclrpal)
 
 target_link_libraries(paltest_atan2_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/atan2f/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/atan2f/test1/CMakeLists.txt
index d71a61b17b..d70946ea8c 100644
--- a/src/pal/tests/palsuite/c_runtime/atan2f/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/atan2f/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_atan2f_test1
 add_dependencies(paltest_atan2f_test1 coreclrpal)
 
 target_link_libraries(paltest_atan2f_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/atanf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/atanf/test1/CMakeLists.txt
index b71b1cf40c..2a08f6d739 100644
--- a/src/pal/tests/palsuite/c_runtime/atanf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/atanf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_atanf_test1
 add_dependencies(paltest_atanf_test1 coreclrpal)
 
 target_link_libraries(paltest_atanf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/atof/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/atof/test1/CMakeLists.txt
index 12e584b9a0..4917e424dc 100644
--- a/src/pal/tests/palsuite/c_runtime/atof/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/atof/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_atof_test1
 add_dependencies(paltest_atof_test1 coreclrpal)
 
 target_link_libraries(paltest_atof_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/atoi/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/atoi/test1/CMakeLists.txt
index 225052213f..d545811b9a 100644
--- a/src/pal/tests/palsuite/c_runtime/atoi/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/atoi/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_atoi_test1
 add_dependencies(paltest_atoi_test1 coreclrpal)
 
 target_link_libraries(paltest_atoi_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/atol/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/atol/test1/CMakeLists.txt
index 29643aae6b..0335137eb6 100644
--- a/src/pal/tests/palsuite/c_runtime/atol/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/atol/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_atol_test1
 add_dependencies(paltest_atol_test1 coreclrpal)
 
 target_link_libraries(paltest_atol_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/bsearch/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/bsearch/test1/CMakeLists.txt
index c5aab7b84d..a1242e6a37 100644
--- a/src/pal/tests/palsuite/c_runtime/bsearch/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/bsearch/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_bsearch_test1
 add_dependencies(paltest_bsearch_test1 coreclrpal)
 
 target_link_libraries(paltest_bsearch_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/bsearch/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/bsearch/test2/CMakeLists.txt
index 7ad33b12e5..167b8aac69 100644
--- a/src/pal/tests/palsuite/c_runtime/bsearch/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/bsearch/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_bsearch_test2
 add_dependencies(paltest_bsearch_test2 coreclrpal)
 
 target_link_libraries(paltest_bsearch_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/ceil/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/ceil/test1/CMakeLists.txt
index f834914545..c1473daa9d 100644
--- a/src/pal/tests/palsuite/c_runtime/ceil/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/ceil/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_ceil_test1
 add_dependencies(paltest_ceil_test1 coreclrpal)
 
 target_link_libraries(paltest_ceil_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/ceilf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/ceilf/test1/CMakeLists.txt
index 64f14cda9a..b1fbe07100 100644
--- a/src/pal/tests/palsuite/c_runtime/ceilf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/ceilf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_ceilf_test1
 add_dependencies(paltest_ceilf_test1 coreclrpal)
 
 target_link_libraries(paltest_ceilf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/cos/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/cos/test1/CMakeLists.txt
index 536664c128..936a876c3f 100644
--- a/src/pal/tests/palsuite/c_runtime/cos/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/cos/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_cos_test1
 add_dependencies(paltest_cos_test1 coreclrpal)
 
 target_link_libraries(paltest_cos_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/cosf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/cosf/test1/CMakeLists.txt
index b3a18ea271..db4efe4ac7 100644
--- a/src/pal/tests/palsuite/c_runtime/cosf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/cosf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_cosf_test1
 add_dependencies(paltest_cosf_test1 coreclrpal)
 
 target_link_libraries(paltest_cosf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/cosh/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/cosh/test1/CMakeLists.txt
index e1fff0e9f1..ec8038a160 100644
--- a/src/pal/tests/palsuite/c_runtime/cosh/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/cosh/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_cosh_test1
 add_dependencies(paltest_cosh_test1 coreclrpal)
 
 target_link_libraries(paltest_cosh_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/coshf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/coshf/test1/CMakeLists.txt
index 92fcfdea6d..3b873eec94 100644
--- a/src/pal/tests/palsuite/c_runtime/coshf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/coshf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_coshf_test1
 add_dependencies(paltest_coshf_test1 coreclrpal)
 
 target_link_libraries(paltest_coshf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/ctime/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/ctime/test1/CMakeLists.txt
index 3eeffb0e39..b7d1b99b2f 100644
--- a/src/pal/tests/palsuite/c_runtime/ctime/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/ctime/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_ctime_test1
 add_dependencies(paltest_ctime_test1 coreclrpal)
 
 target_link_libraries(paltest_ctime_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/errno/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/errno/test1/CMakeLists.txt
index 91b8d094b1..8c27c78d6d 100644
--- a/src/pal/tests/palsuite/c_runtime/errno/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/errno/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_errno_test1
 add_dependencies(paltest_errno_test1 coreclrpal)
 
 target_link_libraries(paltest_errno_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/errno/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/errno/test2/CMakeLists.txt
index ab7c4a27f2..e66c359207 100644
--- a/src/pal/tests/palsuite/c_runtime/errno/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/errno/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_errno_test2
 add_dependencies(paltest_errno_test2 coreclrpal)
 
 target_link_libraries(paltest_errno_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/exit/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/exit/test1/CMakeLists.txt
index bb2cbccb9b..3f34da6fd2 100644
--- a/src/pal/tests/palsuite/c_runtime/exit/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/exit/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_exit_test1
 add_dependencies(paltest_exit_test1 coreclrpal)
 
 target_link_libraries(paltest_exit_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/exit/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/exit/test2/CMakeLists.txt
index 8a74e75ed5..5327b57896 100644
--- a/src/pal/tests/palsuite/c_runtime/exit/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/exit/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_exit_test2
 add_dependencies(paltest_exit_test2 coreclrpal)
 
 target_link_libraries(paltest_exit_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/exp/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/exp/test1/CMakeLists.txt
index 3377ed22f2..a28565835b 100644
--- a/src/pal/tests/palsuite/c_runtime/exp/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/exp/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_exp_test1
 add_dependencies(paltest_exp_test1 coreclrpal)
 
 target_link_libraries(paltest_exp_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/expf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/expf/test1/CMakeLists.txt
index fb12b65c2f..5ff0d09d81 100644
--- a/src/pal/tests/palsuite/c_runtime/expf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/expf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_expf_test1
 add_dependencies(paltest_expf_test1 coreclrpal)
 
 target_link_libraries(paltest_expf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fabs/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fabs/test1/CMakeLists.txt
index fa01a34dd9..9dab6796f2 100644
--- a/src/pal/tests/palsuite/c_runtime/fabs/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fabs/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fabs_test1
 add_dependencies(paltest_fabs_test1 coreclrpal)
 
 target_link_libraries(paltest_fabs_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fabsf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fabsf/test1/CMakeLists.txt
index a1823e25e5..dc46a2335d 100644
--- a/src/pal/tests/palsuite/c_runtime/fabsf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fabsf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fabsf_test1
 add_dependencies(paltest_fabsf_test1 coreclrpal)
 
 target_link_libraries(paltest_fabsf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fclose/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fclose/test1/CMakeLists.txt
index 64cfef0e18..5fe80e02bc 100644
--- a/src/pal/tests/palsuite/c_runtime/fclose/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fclose/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fclose_test1
 add_dependencies(paltest_fclose_test1 coreclrpal)
 
 target_link_libraries(paltest_fclose_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fclose/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fclose/test2/CMakeLists.txt
index 3b5538608f..efe4c85207 100644
--- a/src/pal/tests/palsuite/c_runtime/fclose/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fclose/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fclose_test2
 add_dependencies(paltest_fclose_test2 coreclrpal)
 
 target_link_libraries(paltest_fclose_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/feof/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/feof/test1/CMakeLists.txt
index 9f689503e6..e870038450 100644
--- a/src/pal/tests/palsuite/c_runtime/feof/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/feof/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_feof_test1
 add_dependencies(paltest_feof_test1 coreclrpal)
 
 target_link_libraries(paltest_feof_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/ferror/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/ferror/test1/CMakeLists.txt
index cd1fe52381..e8a282f6be 100644
--- a/src/pal/tests/palsuite/c_runtime/ferror/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/ferror/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_ferror_test1
 add_dependencies(paltest_ferror_test1 coreclrpal)
 
 target_link_libraries(paltest_ferror_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/ferror/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/ferror/test2/CMakeLists.txt
index 05bd7fd2f1..deb3f1f927 100644
--- a/src/pal/tests/palsuite/c_runtime/ferror/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/ferror/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_ferror_test2
 add_dependencies(paltest_ferror_test2 coreclrpal)
 
 target_link_libraries(paltest_ferror_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fflush/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fflush/test1/CMakeLists.txt
index 58c7c5a3a4..ef13ca4194 100644
--- a/src/pal/tests/palsuite/c_runtime/fflush/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fflush/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fflush_test1
 add_dependencies(paltest_fflush_test1 coreclrpal)
 
 target_link_libraries(paltest_fflush_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fgets/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fgets/test1/CMakeLists.txt
index d327d6882a..40f9c65879 100644
--- a/src/pal/tests/palsuite/c_runtime/fgets/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fgets/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fgets_test1
 add_dependencies(paltest_fgets_test1 coreclrpal)
 
 target_link_libraries(paltest_fgets_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fgets/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fgets/test2/CMakeLists.txt
index 23bcdef686..a2d2563df5 100644
--- a/src/pal/tests/palsuite/c_runtime/fgets/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fgets/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fgets_test2
 add_dependencies(paltest_fgets_test2 coreclrpal)
 
 target_link_libraries(paltest_fgets_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fgets/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fgets/test3/CMakeLists.txt
index 0833ad0130..37398b8349 100644
--- a/src/pal/tests/palsuite/c_runtime/fgets/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fgets/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fgets_test3
 add_dependencies(paltest_fgets_test3 coreclrpal)
 
 target_link_libraries(paltest_fgets_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/floor/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/floor/test1/CMakeLists.txt
index 3222ed8ba3..4324626b87 100644
--- a/src/pal/tests/palsuite/c_runtime/floor/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/floor/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_floor_test1
 add_dependencies(paltest_floor_test1 coreclrpal)
 
 target_link_libraries(paltest_floor_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/floorf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/floorf/test1/CMakeLists.txt
index f6e24adcd9..8834f4dfa2 100644
--- a/src/pal/tests/palsuite/c_runtime/floorf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/floorf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_floorf_test1
 add_dependencies(paltest_floorf_test1 coreclrpal)
 
 target_link_libraries(paltest_floorf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fmod/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fmod/test1/CMakeLists.txt
index 33fbfb2653..22bcd3a00d 100644
--- a/src/pal/tests/palsuite/c_runtime/fmod/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fmod/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fmod_test1
 add_dependencies(paltest_fmod_test1 coreclrpal)
 
 target_link_libraries(paltest_fmod_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fmodf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fmodf/test1/CMakeLists.txt
index 487b3adda4..861f3d7219 100644
--- a/src/pal/tests/palsuite/c_runtime/fmodf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fmodf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fmodf_test1
 add_dependencies(paltest_fmodf_test1 coreclrpal)
 
 target_link_libraries(paltest_fmodf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fopen/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fopen/test1/CMakeLists.txt
index 7603fc623e..955979a6a3 100644
--- a/src/pal/tests/palsuite/c_runtime/fopen/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fopen/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fopen_test1
 add_dependencies(paltest_fopen_test1 coreclrpal)
 
 target_link_libraries(paltest_fopen_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fopen/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fopen/test2/CMakeLists.txt
index b8569921de..3738f86fa8 100644
--- a/src/pal/tests/palsuite/c_runtime/fopen/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fopen/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fopen_test2
 add_dependencies(paltest_fopen_test2 coreclrpal)
 
 target_link_libraries(paltest_fopen_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fopen/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fopen/test3/CMakeLists.txt
index 5b28caf4ba..88df51d41f 100644
--- a/src/pal/tests/palsuite/c_runtime/fopen/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fopen/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fopen_test3
 add_dependencies(paltest_fopen_test3 coreclrpal)
 
 target_link_libraries(paltest_fopen_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fopen/test4/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fopen/test4/CMakeLists.txt
index db5779f282..f31c5d1e5d 100644
--- a/src/pal/tests/palsuite/c_runtime/fopen/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fopen/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fopen_test4
 add_dependencies(paltest_fopen_test4 coreclrpal)
 
 target_link_libraries(paltest_fopen_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fopen/test5/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fopen/test5/CMakeLists.txt
index 6341e4a7d2..975351d39a 100644
--- a/src/pal/tests/palsuite/c_runtime/fopen/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fopen/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fopen_test5
 add_dependencies(paltest_fopen_test5 coreclrpal)
 
 target_link_libraries(paltest_fopen_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fopen/test6/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fopen/test6/CMakeLists.txt
index 39cf9158bb..1e235856bb 100644
--- a/src/pal/tests/palsuite/c_runtime/fopen/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fopen/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fopen_test6
 add_dependencies(paltest_fopen_test6 coreclrpal)
 
 target_link_libraries(paltest_fopen_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fopen/test7/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fopen/test7/CMakeLists.txt
index ee22e347d6..dd81aa9289 100644
--- a/src/pal/tests/palsuite/c_runtime/fopen/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fopen/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fopen_test7
 add_dependencies(paltest_fopen_test7 coreclrpal)
 
 target_link_libraries(paltest_fopen_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fprintf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fprintf/test1/CMakeLists.txt
index 60ffd49cf5..277cee42ab 100644
--- a/src/pal/tests/palsuite/c_runtime/fprintf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fprintf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fprintf_test1
 add_dependencies(paltest_fprintf_test1 coreclrpal)
 
 target_link_libraries(paltest_fprintf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fprintf/test10/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fprintf/test10/CMakeLists.txt
index 3fb57c217c..7f9dd41db3 100644
--- a/src/pal/tests/palsuite/c_runtime/fprintf/test10/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fprintf/test10/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fprintf_test10
 add_dependencies(paltest_fprintf_test10 coreclrpal)
 
 target_link_libraries(paltest_fprintf_test10
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fprintf/test11/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fprintf/test11/CMakeLists.txt
index d325ce225e..a5365b4fc4 100644
--- a/src/pal/tests/palsuite/c_runtime/fprintf/test11/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fprintf/test11/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fprintf_test11
 add_dependencies(paltest_fprintf_test11 coreclrpal)
 
 target_link_libraries(paltest_fprintf_test11
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fprintf/test12/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fprintf/test12/CMakeLists.txt
index 8bd3970e80..40425217e2 100644
--- a/src/pal/tests/palsuite/c_runtime/fprintf/test12/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fprintf/test12/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fprintf_test12
 add_dependencies(paltest_fprintf_test12 coreclrpal)
 
 target_link_libraries(paltest_fprintf_test12
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fprintf/test13/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fprintf/test13/CMakeLists.txt
index 702058b797..47ba3cb5ba 100644
--- a/src/pal/tests/palsuite/c_runtime/fprintf/test13/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fprintf/test13/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fprintf_test13
 add_dependencies(paltest_fprintf_test13 coreclrpal)
 
 target_link_libraries(paltest_fprintf_test13
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fprintf/test14/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fprintf/test14/CMakeLists.txt
index b92ede7c87..dc3186c743 100644
--- a/src/pal/tests/palsuite/c_runtime/fprintf/test14/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fprintf/test14/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fprintf_test14
 add_dependencies(paltest_fprintf_test14 coreclrpal)
 
 target_link_libraries(paltest_fprintf_test14
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fprintf/test15/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fprintf/test15/CMakeLists.txt
index 20f1e42aab..91718eeed8 100644
--- a/src/pal/tests/palsuite/c_runtime/fprintf/test15/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fprintf/test15/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fprintf_test15
 add_dependencies(paltest_fprintf_test15 coreclrpal)
 
 target_link_libraries(paltest_fprintf_test15
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fprintf/test16/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fprintf/test16/CMakeLists.txt
index 8d72421210..26dc1f8f59 100644
--- a/src/pal/tests/palsuite/c_runtime/fprintf/test16/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fprintf/test16/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fprintf_test16
 add_dependencies(paltest_fprintf_test16 coreclrpal)
 
 target_link_libraries(paltest_fprintf_test16
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fprintf/test17/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fprintf/test17/CMakeLists.txt
index 82d1f84f31..9493f54962 100644
--- a/src/pal/tests/palsuite/c_runtime/fprintf/test17/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fprintf/test17/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fprintf_test17
 add_dependencies(paltest_fprintf_test17 coreclrpal)
 
 target_link_libraries(paltest_fprintf_test17
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fprintf/test18/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fprintf/test18/CMakeLists.txt
index 1ca54e42b7..21a2e87887 100644
--- a/src/pal/tests/palsuite/c_runtime/fprintf/test18/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fprintf/test18/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fprintf_test18
 add_dependencies(paltest_fprintf_test18 coreclrpal)
 
 target_link_libraries(paltest_fprintf_test18
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fprintf/test19/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fprintf/test19/CMakeLists.txt
index 2c66239801..419d180fcf 100644
--- a/src/pal/tests/palsuite/c_runtime/fprintf/test19/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fprintf/test19/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fprintf_test19
 add_dependencies(paltest_fprintf_test19 coreclrpal)
 
 target_link_libraries(paltest_fprintf_test19
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fprintf/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fprintf/test2/CMakeLists.txt
index ae1d9dc64d..88bd04c75f 100644
--- a/src/pal/tests/palsuite/c_runtime/fprintf/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fprintf/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fprintf_test2
 add_dependencies(paltest_fprintf_test2 coreclrpal)
 
 target_link_libraries(paltest_fprintf_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fprintf/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fprintf/test3/CMakeLists.txt
index 4b10c4c407..42d3977e05 100644
--- a/src/pal/tests/palsuite/c_runtime/fprintf/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fprintf/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fprintf_test3
 add_dependencies(paltest_fprintf_test3 coreclrpal)
 
 target_link_libraries(paltest_fprintf_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fprintf/test4/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fprintf/test4/CMakeLists.txt
index 292bdb6625..7e6cc18f18 100644
--- a/src/pal/tests/palsuite/c_runtime/fprintf/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fprintf/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fprintf_test4
 add_dependencies(paltest_fprintf_test4 coreclrpal)
 
 target_link_libraries(paltest_fprintf_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fprintf/test5/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fprintf/test5/CMakeLists.txt
index 370ed3329a..6cea5197a0 100644
--- a/src/pal/tests/palsuite/c_runtime/fprintf/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fprintf/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fprintf_test5
 add_dependencies(paltest_fprintf_test5 coreclrpal)
 
 target_link_libraries(paltest_fprintf_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fprintf/test6/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fprintf/test6/CMakeLists.txt
index bd1cbda924..9e3cf01393 100644
--- a/src/pal/tests/palsuite/c_runtime/fprintf/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fprintf/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fprintf_test6
 add_dependencies(paltest_fprintf_test6 coreclrpal)
 
 target_link_libraries(paltest_fprintf_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fprintf/test7/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fprintf/test7/CMakeLists.txt
index 38429e7900..92dd50ab34 100644
--- a/src/pal/tests/palsuite/c_runtime/fprintf/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fprintf/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fprintf_test7
 add_dependencies(paltest_fprintf_test7 coreclrpal)
 
 target_link_libraries(paltest_fprintf_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fprintf/test8/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fprintf/test8/CMakeLists.txt
index 990eca26b0..9aa9af8211 100644
--- a/src/pal/tests/palsuite/c_runtime/fprintf/test8/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fprintf/test8/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fprintf_test8
 add_dependencies(paltest_fprintf_test8 coreclrpal)
 
 target_link_libraries(paltest_fprintf_test8
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fprintf/test9/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fprintf/test9/CMakeLists.txt
index 715d38a431..6a7bb4de3d 100644
--- a/src/pal/tests/palsuite/c_runtime/fprintf/test9/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fprintf/test9/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fprintf_test9
 add_dependencies(paltest_fprintf_test9 coreclrpal)
 
 target_link_libraries(paltest_fprintf_test9
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fputs/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fputs/test1/CMakeLists.txt
index d0f1aca0e6..1e0fbcb60b 100644
--- a/src/pal/tests/palsuite/c_runtime/fputs/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fputs/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fputs_test1
 add_dependencies(paltest_fputs_test1 coreclrpal)
 
 target_link_libraries(paltest_fputs_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fputs/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fputs/test2/CMakeLists.txt
index 9242ea16e5..074500bb24 100644
--- a/src/pal/tests/palsuite/c_runtime/fputs/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fputs/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fputs_test2
 add_dependencies(paltest_fputs_test2 coreclrpal)
 
 target_link_libraries(paltest_fputs_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fread/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fread/test1/CMakeLists.txt
index 1bd84b5c62..71204c0796 100644
--- a/src/pal/tests/palsuite/c_runtime/fread/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fread/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fread_test1
 add_dependencies(paltest_fread_test1 coreclrpal)
 
 target_link_libraries(paltest_fread_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fread/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fread/test2/CMakeLists.txt
index 93e0394832..1bae93e439 100644
--- a/src/pal/tests/palsuite/c_runtime/fread/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fread/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fread_test2
 add_dependencies(paltest_fread_test2 coreclrpal)
 
 target_link_libraries(paltest_fread_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fread/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fread/test3/CMakeLists.txt
index 285608bc3d..a678e2e110 100644
--- a/src/pal/tests/palsuite/c_runtime/fread/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fread/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fread_test3
 add_dependencies(paltest_fread_test3 coreclrpal)
 
 target_link_libraries(paltest_fread_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/free/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/free/test1/CMakeLists.txt
index 92ee9896c7..66c0b568d0 100644
--- a/src/pal/tests/palsuite/c_runtime/free/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/free/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_free_test1
 add_dependencies(paltest_free_test1 coreclrpal)
 
 target_link_libraries(paltest_free_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fseek/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fseek/test1/CMakeLists.txt
index 59ee8b4563..906a935f1c 100644
--- a/src/pal/tests/palsuite/c_runtime/fseek/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fseek/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fseek_test1
 add_dependencies(paltest_fseek_test1 coreclrpal)
 
 target_link_libraries(paltest_fseek_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/ftell/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/ftell/test1/CMakeLists.txt
index a1f350d0c2..e7900f65aa 100644
--- a/src/pal/tests/palsuite/c_runtime/ftell/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/ftell/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_ftell_test1
 add_dependencies(paltest_ftell_test1 coreclrpal)
 
 target_link_libraries(paltest_ftell_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fwprintf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fwprintf/test1/CMakeLists.txt
index 519860b877..4c5835667c 100644
--- a/src/pal/tests/palsuite/c_runtime/fwprintf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fwprintf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fwprintf_test1
 add_dependencies(paltest_fwprintf_test1 coreclrpal)
 
 target_link_libraries(paltest_fwprintf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fwprintf/test10/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fwprintf/test10/CMakeLists.txt
index e604e03dff..994cd5e271 100644
--- a/src/pal/tests/palsuite/c_runtime/fwprintf/test10/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fwprintf/test10/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fwprintf_test10
 add_dependencies(paltest_fwprintf_test10 coreclrpal)
 
 target_link_libraries(paltest_fwprintf_test10
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fwprintf/test11/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fwprintf/test11/CMakeLists.txt
index 18be522823..a2bc58527e 100644
--- a/src/pal/tests/palsuite/c_runtime/fwprintf/test11/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fwprintf/test11/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fwprintf_test11
 add_dependencies(paltest_fwprintf_test11 coreclrpal)
 
 target_link_libraries(paltest_fwprintf_test11
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fwprintf/test12/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fwprintf/test12/CMakeLists.txt
index 6ea739b28f..33006f439f 100644
--- a/src/pal/tests/palsuite/c_runtime/fwprintf/test12/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fwprintf/test12/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fwprintf_test12
 add_dependencies(paltest_fwprintf_test12 coreclrpal)
 
 target_link_libraries(paltest_fwprintf_test12
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fwprintf/test13/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fwprintf/test13/CMakeLists.txt
index 8505ccbd82..fef3d08d51 100644
--- a/src/pal/tests/palsuite/c_runtime/fwprintf/test13/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fwprintf/test13/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fwprintf_test13
 add_dependencies(paltest_fwprintf_test13 coreclrpal)
 
 target_link_libraries(paltest_fwprintf_test13
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fwprintf/test14/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fwprintf/test14/CMakeLists.txt
index 548e60fdb8..6e37e4fb81 100644
--- a/src/pal/tests/palsuite/c_runtime/fwprintf/test14/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fwprintf/test14/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fwprintf_test14
 add_dependencies(paltest_fwprintf_test14 coreclrpal)
 
 target_link_libraries(paltest_fwprintf_test14
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fwprintf/test15/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fwprintf/test15/CMakeLists.txt
index c5b53461a7..5f1513d645 100644
--- a/src/pal/tests/palsuite/c_runtime/fwprintf/test15/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fwprintf/test15/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fwprintf_test15
 add_dependencies(paltest_fwprintf_test15 coreclrpal)
 
 target_link_libraries(paltest_fwprintf_test15
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fwprintf/test16/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fwprintf/test16/CMakeLists.txt
index 51af0a0d60..f77b355304 100644
--- a/src/pal/tests/palsuite/c_runtime/fwprintf/test16/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fwprintf/test16/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fwprintf_test16
 add_dependencies(paltest_fwprintf_test16 coreclrpal)
 
 target_link_libraries(paltest_fwprintf_test16
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fwprintf/test17/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fwprintf/test17/CMakeLists.txt
index 9ed8a390e7..5a4a58e7d3 100644
--- a/src/pal/tests/palsuite/c_runtime/fwprintf/test17/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fwprintf/test17/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fwprintf_test17
 add_dependencies(paltest_fwprintf_test17 coreclrpal)
 
 target_link_libraries(paltest_fwprintf_test17
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fwprintf/test18/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fwprintf/test18/CMakeLists.txt
index 3e3ba4efc7..9839b9fb35 100644
--- a/src/pal/tests/palsuite/c_runtime/fwprintf/test18/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fwprintf/test18/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fwprintf_test18
 add_dependencies(paltest_fwprintf_test18 coreclrpal)
 
 target_link_libraries(paltest_fwprintf_test18
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fwprintf/test19/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fwprintf/test19/CMakeLists.txt
index fbb7370ba3..e7ac859f18 100644
--- a/src/pal/tests/palsuite/c_runtime/fwprintf/test19/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fwprintf/test19/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fwprintf_test19
 add_dependencies(paltest_fwprintf_test19 coreclrpal)
 
 target_link_libraries(paltest_fwprintf_test19
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fwprintf/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fwprintf/test2/CMakeLists.txt
index e65a396862..e589a068c0 100644
--- a/src/pal/tests/palsuite/c_runtime/fwprintf/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fwprintf/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fwprintf_test2
 add_dependencies(paltest_fwprintf_test2 coreclrpal)
 
 target_link_libraries(paltest_fwprintf_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fwprintf/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fwprintf/test3/CMakeLists.txt
index 53c46369de..f583d40ace 100644
--- a/src/pal/tests/palsuite/c_runtime/fwprintf/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fwprintf/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fwprintf_test3
 add_dependencies(paltest_fwprintf_test3 coreclrpal)
 
 target_link_libraries(paltest_fwprintf_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fwprintf/test4/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fwprintf/test4/CMakeLists.txt
index 9dbb46283e..166938445b 100644
--- a/src/pal/tests/palsuite/c_runtime/fwprintf/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fwprintf/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fwprintf_test4
 add_dependencies(paltest_fwprintf_test4 coreclrpal)
 
 target_link_libraries(paltest_fwprintf_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fwprintf/test5/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fwprintf/test5/CMakeLists.txt
index 4e72e3ca88..4611c7fbc4 100644
--- a/src/pal/tests/palsuite/c_runtime/fwprintf/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fwprintf/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fwprintf_test5
 add_dependencies(paltest_fwprintf_test5 coreclrpal)
 
 target_link_libraries(paltest_fwprintf_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fwprintf/test6/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fwprintf/test6/CMakeLists.txt
index d57f07fafa..f692baaf11 100644
--- a/src/pal/tests/palsuite/c_runtime/fwprintf/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fwprintf/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fwprintf_test6
 add_dependencies(paltest_fwprintf_test6 coreclrpal)
 
 target_link_libraries(paltest_fwprintf_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fwprintf/test7/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fwprintf/test7/CMakeLists.txt
index 314ca353e5..18b6673c8b 100644
--- a/src/pal/tests/palsuite/c_runtime/fwprintf/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fwprintf/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fwprintf_test7
 add_dependencies(paltest_fwprintf_test7 coreclrpal)
 
 target_link_libraries(paltest_fwprintf_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fwprintf/test8/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fwprintf/test8/CMakeLists.txt
index e818df2eb2..dfb8814bdc 100644
--- a/src/pal/tests/palsuite/c_runtime/fwprintf/test8/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fwprintf/test8/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fwprintf_test8
 add_dependencies(paltest_fwprintf_test8 coreclrpal)
 
 target_link_libraries(paltest_fwprintf_test8
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fwprintf/test9/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fwprintf/test9/CMakeLists.txt
index 28b6b86921..3e08677734 100644
--- a/src/pal/tests/palsuite/c_runtime/fwprintf/test9/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fwprintf/test9/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fwprintf_test9
 add_dependencies(paltest_fwprintf_test9 coreclrpal)
 
 target_link_libraries(paltest_fwprintf_test9
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/fwrite/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/fwrite/test1/CMakeLists.txt
index 5c8b7449f2..084c1fc415 100644
--- a/src/pal/tests/palsuite/c_runtime/fwrite/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/fwrite/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_fwrite_test1
 add_dependencies(paltest_fwrite_test1 coreclrpal)
 
 target_link_libraries(paltest_fwrite_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/getc/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/getc/test1/CMakeLists.txt
index 68ecaa9abb..92f6f31e17 100644
--- a/src/pal/tests/palsuite/c_runtime/getc/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/getc/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getc_test1
 add_dependencies(paltest_getc_test1 coreclrpal)
 
 target_link_libraries(paltest_getc_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/getenv/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/getenv/test1/CMakeLists.txt
index 9c52c2890e..8cb87b1190 100644
--- a/src/pal/tests/palsuite/c_runtime/getenv/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/getenv/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getenv_test1
 add_dependencies(paltest_getenv_test1 coreclrpal)
 
 target_link_libraries(paltest_getenv_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/getenv/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/getenv/test2/CMakeLists.txt
index 971a836239..de8bc27cdc 100644
--- a/src/pal/tests/palsuite/c_runtime/getenv/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/getenv/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getenv_test2
 add_dependencies(paltest_getenv_test2 coreclrpal)
 
 target_link_libraries(paltest_getenv_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/getenv/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/getenv/test3/CMakeLists.txt
index 620ccd1003..48d3b117d6 100644
--- a/src/pal/tests/palsuite/c_runtime/getenv/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/getenv/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getenv_test3
 add_dependencies(paltest_getenv_test3 coreclrpal)
 
 target_link_libraries(paltest_getenv_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/isalnum/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/isalnum/test1/CMakeLists.txt
index af65f32cbf..033f58d912 100644
--- a/src/pal/tests/palsuite/c_runtime/isalnum/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/isalnum/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_isalnum_test1
 add_dependencies(paltest_isalnum_test1 coreclrpal)
 
 target_link_libraries(paltest_isalnum_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/isalpha/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/isalpha/test1/CMakeLists.txt
index 82f19ad383..8033ae07f0 100644
--- a/src/pal/tests/palsuite/c_runtime/isalpha/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/isalpha/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_isalpha_test1
 add_dependencies(paltest_isalpha_test1 coreclrpal)
 
 target_link_libraries(paltest_isalpha_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/isdigit/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/isdigit/test1/CMakeLists.txt
index b96b7aa706..8f74b2d0cd 100644
--- a/src/pal/tests/palsuite/c_runtime/isdigit/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/isdigit/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_isdigit_test1
 add_dependencies(paltest_isdigit_test1 coreclrpal)
 
 target_link_libraries(paltest_isdigit_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/islower/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/islower/test1/CMakeLists.txt
index d071d4bb65..a02dc70887 100644
--- a/src/pal/tests/palsuite/c_runtime/islower/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/islower/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_islower_test1
 add_dependencies(paltest_islower_test1 coreclrpal)
 
 target_link_libraries(paltest_islower_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/isprint/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/isprint/test1/CMakeLists.txt
index 91410a02ab..6e47a8f69d 100644
--- a/src/pal/tests/palsuite/c_runtime/isprint/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/isprint/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_isprint_test1
 add_dependencies(paltest_isprint_test1 coreclrpal)
 
 target_link_libraries(paltest_isprint_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/isprint/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/isprint/test2/CMakeLists.txt
index 53ad94273c..bcecac10f7 100644
--- a/src/pal/tests/palsuite/c_runtime/isprint/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/isprint/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_isprint_test2
 add_dependencies(paltest_isprint_test2 coreclrpal)
 
 target_link_libraries(paltest_isprint_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/isspace/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/isspace/test1/CMakeLists.txt
index c3cc525145..ee6c8f3ef3 100644
--- a/src/pal/tests/palsuite/c_runtime/isspace/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/isspace/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_isspace_test1
 add_dependencies(paltest_isspace_test1 coreclrpal)
 
 target_link_libraries(paltest_isspace_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/isupper/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/isupper/test1/CMakeLists.txt
index e1cfa6609d..96742792cb 100644
--- a/src/pal/tests/palsuite/c_runtime/isupper/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/isupper/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_isupper_test1
 add_dependencies(paltest_isupper_test1 coreclrpal)
 
 target_link_libraries(paltest_isupper_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/iswdigit/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/iswdigit/test1/CMakeLists.txt
index 4074abbe76..723a26a5b2 100644
--- a/src/pal/tests/palsuite/c_runtime/iswdigit/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/iswdigit/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_iswdigit_test1
 add_dependencies(paltest_iswdigit_test1 coreclrpal)
 
 target_link_libraries(paltest_iswdigit_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/iswprint/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/iswprint/test1/CMakeLists.txt
index d21c232133..50c6f741f9 100644
--- a/src/pal/tests/palsuite/c_runtime/iswprint/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/iswprint/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_iswprint_test1
 add_dependencies(paltest_iswprint_test1 coreclrpal)
 
 target_link_libraries(paltest_iswprint_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/iswspace/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/iswspace/test1/CMakeLists.txt
index 1f9a54fb17..02f6acd72d 100644
--- a/src/pal/tests/palsuite/c_runtime/iswspace/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/iswspace/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_iswspace_test1
 add_dependencies(paltest_iswspace_test1 coreclrpal)
 
 target_link_libraries(paltest_iswspace_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/iswupper/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/iswupper/test1/CMakeLists.txt
index 1da5fbaa75..301bd145d5 100644
--- a/src/pal/tests/palsuite/c_runtime/iswupper/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/iswupper/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_iswupper_test1
 add_dependencies(paltest_iswupper_test1 coreclrpal)
 
 target_link_libraries(paltest_iswupper_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/iswxdigit/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/iswxdigit/test1/CMakeLists.txt
index ae55976128..6809f5a2d1 100644
--- a/src/pal/tests/palsuite/c_runtime/iswxdigit/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/iswxdigit/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_iswxdigit_test1
 add_dependencies(paltest_iswxdigit_test1 coreclrpal)
 
 target_link_libraries(paltest_iswxdigit_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/isxdigit/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/isxdigit/test1/CMakeLists.txt
index 4fd46c93d8..cfb0e91e93 100644
--- a/src/pal/tests/palsuite/c_runtime/isxdigit/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/isxdigit/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_isxdigit_test1
 add_dependencies(paltest_isxdigit_test1 coreclrpal)
 
 target_link_libraries(paltest_isxdigit_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/labs/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/labs/test1/CMakeLists.txt
index 2ffb3cd641..70d1b5ee64 100644
--- a/src/pal/tests/palsuite/c_runtime/labs/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/labs/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_labs_test1
 add_dependencies(paltest_labs_test1 coreclrpal)
 
 target_link_libraries(paltest_labs_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/llabs/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/llabs/test1/CMakeLists.txt
index 3adc3cc737..2885109b55 100644
--- a/src/pal/tests/palsuite/c_runtime/llabs/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/llabs/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_llabs_test1
 add_dependencies(paltest_llabs_test1 coreclrpal)
 
 target_link_libraries(paltest_llabs_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/localtime/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/localtime/test1/CMakeLists.txt
index 698699f821..55b42585c1 100644
--- a/src/pal/tests/palsuite/c_runtime/localtime/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/localtime/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_localtime_test1
 add_dependencies(paltest_localtime_test1 coreclrpal)
 
 target_link_libraries(paltest_localtime_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/log/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/log/test1/CMakeLists.txt
index c8f991b997..15a45edb6a 100644
--- a/src/pal/tests/palsuite/c_runtime/log/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/log/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_log_test1
 add_dependencies(paltest_log_test1 coreclrpal)
 
 target_link_libraries(paltest_log_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/log10/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/log10/test1/CMakeLists.txt
index 31025fbd04..17c87301e2 100644
--- a/src/pal/tests/palsuite/c_runtime/log10/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/log10/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_log10_test1
 add_dependencies(paltest_log10_test1 coreclrpal)
 
 target_link_libraries(paltest_log10_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/log10f/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/log10f/test1/CMakeLists.txt
index b2c0835451..6f3358b865 100644
--- a/src/pal/tests/palsuite/c_runtime/log10f/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/log10f/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_log10f_test1
 add_dependencies(paltest_log10f_test1 coreclrpal)
 
 target_link_libraries(paltest_log10f_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/logf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/logf/test1/CMakeLists.txt
index 550f572bc7..2dcfdefde5 100644
--- a/src/pal/tests/palsuite/c_runtime/logf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/logf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_logf_test1
 add_dependencies(paltest_logf_test1 coreclrpal)
 
 target_link_libraries(paltest_logf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/malloc/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/malloc/test1/CMakeLists.txt
index f475730973..b08685d165 100644
--- a/src/pal/tests/palsuite/c_runtime/malloc/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/malloc/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_malloc_test1
 add_dependencies(paltest_malloc_test1 coreclrpal)
 
 target_link_libraries(paltest_malloc_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/malloc/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/malloc/test2/CMakeLists.txt
index 663e104d0e..1b72ab8e62 100644
--- a/src/pal/tests/palsuite/c_runtime/malloc/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/malloc/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_malloc_test2
 add_dependencies(paltest_malloc_test2 coreclrpal)
 
 target_link_libraries(paltest_malloc_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/memchr/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/memchr/test1/CMakeLists.txt
index 959fd2a3bc..1f6fc08568 100644
--- a/src/pal/tests/palsuite/c_runtime/memchr/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/memchr/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_memchr_test1
 add_dependencies(paltest_memchr_test1 coreclrpal)
 
 target_link_libraries(paltest_memchr_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/memcmp/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/memcmp/test1/CMakeLists.txt
index 43d8fdd7f7..24aa40a56b 100644
--- a/src/pal/tests/palsuite/c_runtime/memcmp/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/memcmp/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_memcmp_test1
 add_dependencies(paltest_memcmp_test1 coreclrpal)
 
 target_link_libraries(paltest_memcmp_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/memcpy/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/memcpy/test1/CMakeLists.txt
index 14db0df60e..982433f7e2 100644
--- a/src/pal/tests/palsuite/c_runtime/memcpy/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/memcpy/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_memcpy_test1
 add_dependencies(paltest_memcpy_test1 coreclrpal)
 
 target_link_libraries(paltest_memcpy_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/memmove/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/memmove/test1/CMakeLists.txt
index db6f65e48b..9794085914 100644
--- a/src/pal/tests/palsuite/c_runtime/memmove/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/memmove/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_memmove_test1
 add_dependencies(paltest_memmove_test1 coreclrpal)
 
 target_link_libraries(paltest_memmove_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/memset/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/memset/test1/CMakeLists.txt
index bc3d6251cb..3f3c5614e0 100644
--- a/src/pal/tests/palsuite/c_runtime/memset/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/memset/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_memset_test1
 add_dependencies(paltest_memset_test1 coreclrpal)
 
 target_link_libraries(paltest_memset_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/modf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/modf/test1/CMakeLists.txt
index 3fe7bc7c46..303ce629d1 100644
--- a/src/pal/tests/palsuite/c_runtime/modf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/modf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_modf_test1
 add_dependencies(paltest_modf_test1 coreclrpal)
 
 target_link_libraries(paltest_modf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/modff/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/modff/test1/CMakeLists.txt
index 10e5e99267..b3831c8e6d 100644
--- a/src/pal/tests/palsuite/c_runtime/modff/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/modff/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_modff_test1
 add_dependencies(paltest_modff_test1 coreclrpal)
 
 target_link_libraries(paltest_modff_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/pow/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/pow/test1/CMakeLists.txt
index f94210d5b7..339b7a3ee5 100644
--- a/src/pal/tests/palsuite/c_runtime/pow/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/pow/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pow_test1
 add_dependencies(paltest_pow_test1 coreclrpal)
 
 target_link_libraries(paltest_pow_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/powf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/powf/test1/CMakeLists.txt
index 8ea040f9a4..2b8e2bcff8 100644
--- a/src/pal/tests/palsuite/c_runtime/powf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/powf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_powf_test1
 add_dependencies(paltest_powf_test1 coreclrpal)
 
 target_link_libraries(paltest_powf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/printf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/printf/test1/CMakeLists.txt
index 2dace14f90..0938d8fb7d 100644
--- a/src/pal/tests/palsuite/c_runtime/printf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/printf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_printf_test1
 add_dependencies(paltest_printf_test1 coreclrpal)
 
 target_link_libraries(paltest_printf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/printf/test10/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/printf/test10/CMakeLists.txt
index 75e30c8599..f2a284b2a9 100644
--- a/src/pal/tests/palsuite/c_runtime/printf/test10/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/printf/test10/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_printf_test10
 add_dependencies(paltest_printf_test10 coreclrpal)
 
 target_link_libraries(paltest_printf_test10
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/printf/test11/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/printf/test11/CMakeLists.txt
index 4ee12dc21d..8eb44b5e43 100644
--- a/src/pal/tests/palsuite/c_runtime/printf/test11/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/printf/test11/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_printf_test11
 add_dependencies(paltest_printf_test11 coreclrpal)
 
 target_link_libraries(paltest_printf_test11
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/printf/test12/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/printf/test12/CMakeLists.txt
index 3b2e39d640..17c4a53812 100644
--- a/src/pal/tests/palsuite/c_runtime/printf/test12/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/printf/test12/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_printf_test12
 add_dependencies(paltest_printf_test12 coreclrpal)
 
 target_link_libraries(paltest_printf_test12
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/printf/test13/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/printf/test13/CMakeLists.txt
index b6af021d48..13b0f63188 100644
--- a/src/pal/tests/palsuite/c_runtime/printf/test13/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/printf/test13/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_printf_test13
 add_dependencies(paltest_printf_test13 coreclrpal)
 
 target_link_libraries(paltest_printf_test13
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/printf/test14/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/printf/test14/CMakeLists.txt
index 5a6cf8a180..22fd9ab76e 100644
--- a/src/pal/tests/palsuite/c_runtime/printf/test14/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/printf/test14/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_printf_test14
 add_dependencies(paltest_printf_test14 coreclrpal)
 
 target_link_libraries(paltest_printf_test14
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/printf/test15/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/printf/test15/CMakeLists.txt
index b1466a387d..cc350a5e5d 100644
--- a/src/pal/tests/palsuite/c_runtime/printf/test15/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/printf/test15/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_printf_test15
 add_dependencies(paltest_printf_test15 coreclrpal)
 
 target_link_libraries(paltest_printf_test15
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/printf/test16/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/printf/test16/CMakeLists.txt
index c81da10ec9..a61b5a0bd6 100644
--- a/src/pal/tests/palsuite/c_runtime/printf/test16/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/printf/test16/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_printf_test16
 add_dependencies(paltest_printf_test16 coreclrpal)
 
 target_link_libraries(paltest_printf_test16
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/printf/test17/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/printf/test17/CMakeLists.txt
index 9d40e54ca6..f8c1754d87 100644
--- a/src/pal/tests/palsuite/c_runtime/printf/test17/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/printf/test17/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_printf_test17
 add_dependencies(paltest_printf_test17 coreclrpal)
 
 target_link_libraries(paltest_printf_test17
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/printf/test18/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/printf/test18/CMakeLists.txt
index 6ab11f4be1..c83c096e97 100644
--- a/src/pal/tests/palsuite/c_runtime/printf/test18/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/printf/test18/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_printf_test18
 add_dependencies(paltest_printf_test18 coreclrpal)
 
 target_link_libraries(paltest_printf_test18
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/printf/test19/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/printf/test19/CMakeLists.txt
index f022938e32..4d3fe5f794 100644
--- a/src/pal/tests/palsuite/c_runtime/printf/test19/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/printf/test19/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_printf_test19
 add_dependencies(paltest_printf_test19 coreclrpal)
 
 target_link_libraries(paltest_printf_test19
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/printf/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/printf/test2/CMakeLists.txt
index e92b6b09f3..d45c7727c9 100644
--- a/src/pal/tests/palsuite/c_runtime/printf/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/printf/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_printf_test2
 add_dependencies(paltest_printf_test2 coreclrpal)
 
 target_link_libraries(paltest_printf_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/printf/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/printf/test3/CMakeLists.txt
index fcfd779a0c..b6d9ce2e63 100644
--- a/src/pal/tests/palsuite/c_runtime/printf/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/printf/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_printf_test3
 add_dependencies(paltest_printf_test3 coreclrpal)
 
 target_link_libraries(paltest_printf_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/printf/test4/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/printf/test4/CMakeLists.txt
index 7311bbea69..621c103cc7 100644
--- a/src/pal/tests/palsuite/c_runtime/printf/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/printf/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_printf_test4
 add_dependencies(paltest_printf_test4 coreclrpal)
 
 target_link_libraries(paltest_printf_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/printf/test5/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/printf/test5/CMakeLists.txt
index bfe185c44f..73e8b7dbff 100644
--- a/src/pal/tests/palsuite/c_runtime/printf/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/printf/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_printf_test5
 add_dependencies(paltest_printf_test5 coreclrpal)
 
 target_link_libraries(paltest_printf_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/printf/test6/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/printf/test6/CMakeLists.txt
index 842ebfedc6..07639c6330 100644
--- a/src/pal/tests/palsuite/c_runtime/printf/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/printf/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_printf_test6
 add_dependencies(paltest_printf_test6 coreclrpal)
 
 target_link_libraries(paltest_printf_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/printf/test7/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/printf/test7/CMakeLists.txt
index 16e39198ba..72bc2858b2 100644
--- a/src/pal/tests/palsuite/c_runtime/printf/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/printf/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_printf_test7
 add_dependencies(paltest_printf_test7 coreclrpal)
 
 target_link_libraries(paltest_printf_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/printf/test8/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/printf/test8/CMakeLists.txt
index 4a40fee6d9..78ce601cac 100644
--- a/src/pal/tests/palsuite/c_runtime/printf/test8/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/printf/test8/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_printf_test8
 add_dependencies(paltest_printf_test8 coreclrpal)
 
 target_link_libraries(paltest_printf_test8
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/printf/test9/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/printf/test9/CMakeLists.txt
index df8f75d2fd..dfc2a8316c 100644
--- a/src/pal/tests/palsuite/c_runtime/printf/test9/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/printf/test9/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_printf_test9
 add_dependencies(paltest_printf_test9 coreclrpal)
 
 target_link_libraries(paltest_printf_test9
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/qsort/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/qsort/test1/CMakeLists.txt
index ff215b8dc6..f41f4099f4 100644
--- a/src/pal/tests/palsuite/c_runtime/qsort/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/qsort/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_qsort_test1
 add_dependencies(paltest_qsort_test1 coreclrpal)
 
 target_link_libraries(paltest_qsort_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/qsort/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/qsort/test2/CMakeLists.txt
index cdd9642779..16e5c44220 100644
--- a/src/pal/tests/palsuite/c_runtime/qsort/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/qsort/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_qsort_test2
 add_dependencies(paltest_qsort_test2 coreclrpal)
 
 target_link_libraries(paltest_qsort_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/rand_srand/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/rand_srand/test1/CMakeLists.txt
index 6728f402ff..0afb6504c4 100644
--- a/src/pal/tests/palsuite/c_runtime/rand_srand/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/rand_srand/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_rand_srand_test1
 add_dependencies(paltest_rand_srand_test1 coreclrpal)
 
 target_link_libraries(paltest_rand_srand_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/realloc/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/realloc/test1/CMakeLists.txt
index 62830a0fe8..0c263d5b5b 100644
--- a/src/pal/tests/palsuite/c_runtime/realloc/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/realloc/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_realloc_test1
 add_dependencies(paltest_realloc_test1 coreclrpal)
 
 target_link_libraries(paltest_realloc_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sin/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sin/test1/CMakeLists.txt
index 74a0e78f52..c46aaeccb8 100644
--- a/src/pal/tests/palsuite/c_runtime/sin/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sin/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sin_test1
 add_dependencies(paltest_sin_test1 coreclrpal)
 
 target_link_libraries(paltest_sin_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sinf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sinf/test1/CMakeLists.txt
index 0651b43d1d..9e03130464 100644
--- a/src/pal/tests/palsuite/c_runtime/sinf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sinf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sinf_test1
 add_dependencies(paltest_sinf_test1 coreclrpal)
 
 target_link_libraries(paltest_sinf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sinh/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sinh/test1/CMakeLists.txt
index b0101ba808..1c99bfa890 100644
--- a/src/pal/tests/palsuite/c_runtime/sinh/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sinh/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sinh_test1
 add_dependencies(paltest_sinh_test1 coreclrpal)
 
 target_link_libraries(paltest_sinh_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sinhf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sinhf/test1/CMakeLists.txt
index 72cce43460..60208d4e1c 100644
--- a/src/pal/tests/palsuite/c_runtime/sinhf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sinhf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sinhf_test1
 add_dependencies(paltest_sinhf_test1 coreclrpal)
 
 target_link_libraries(paltest_sinhf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sprintf_s/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sprintf_s/test1/CMakeLists.txt
index ee0d90fe7f..5de43c73ac 100644
--- a/src/pal/tests/palsuite/c_runtime/sprintf_s/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sprintf_s/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sprintf_test1
 add_dependencies(paltest_sprintf_test1 coreclrpal)
 
 target_link_libraries(paltest_sprintf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sprintf_s/test10/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sprintf_s/test10/CMakeLists.txt
index 1efad19dee..54bc9c08dd 100644
--- a/src/pal/tests/palsuite/c_runtime/sprintf_s/test10/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sprintf_s/test10/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sprintf_test10
 add_dependencies(paltest_sprintf_test10 coreclrpal)
 
 target_link_libraries(paltest_sprintf_test10
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sprintf_s/test11/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sprintf_s/test11/CMakeLists.txt
index f2f4da694c..6eac95623b 100644
--- a/src/pal/tests/palsuite/c_runtime/sprintf_s/test11/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sprintf_s/test11/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sprintf_test11
 add_dependencies(paltest_sprintf_test11 coreclrpal)
 
 target_link_libraries(paltest_sprintf_test11
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sprintf_s/test12/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sprintf_s/test12/CMakeLists.txt
index 361e91f9ae..a49975993f 100644
--- a/src/pal/tests/palsuite/c_runtime/sprintf_s/test12/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sprintf_s/test12/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sprintf_test12
 add_dependencies(paltest_sprintf_test12 coreclrpal)
 
 target_link_libraries(paltest_sprintf_test12
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sprintf_s/test13/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sprintf_s/test13/CMakeLists.txt
index d08e13b2ba..4d66713fb8 100644
--- a/src/pal/tests/palsuite/c_runtime/sprintf_s/test13/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sprintf_s/test13/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sprintf_test13
 add_dependencies(paltest_sprintf_test13 coreclrpal)
 
 target_link_libraries(paltest_sprintf_test13
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sprintf_s/test14/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sprintf_s/test14/CMakeLists.txt
index 60ac2922d7..ce41b8a95c 100644
--- a/src/pal/tests/palsuite/c_runtime/sprintf_s/test14/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sprintf_s/test14/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sprintf_test14
 add_dependencies(paltest_sprintf_test14 coreclrpal)
 
 target_link_libraries(paltest_sprintf_test14
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sprintf_s/test15/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sprintf_s/test15/CMakeLists.txt
index 57bba40e6c..d20c4d07e9 100644
--- a/src/pal/tests/palsuite/c_runtime/sprintf_s/test15/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sprintf_s/test15/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sprintf_test15
 add_dependencies(paltest_sprintf_test15 coreclrpal)
 
 target_link_libraries(paltest_sprintf_test15
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sprintf_s/test16/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sprintf_s/test16/CMakeLists.txt
index fc93e1a67d..2ca1ffd2ef 100644
--- a/src/pal/tests/palsuite/c_runtime/sprintf_s/test16/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sprintf_s/test16/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sprintf_test16
 add_dependencies(paltest_sprintf_test16 coreclrpal)
 
 target_link_libraries(paltest_sprintf_test16
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sprintf_s/test17/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sprintf_s/test17/CMakeLists.txt
index dc5ff2bb30..0c17cbfc34 100644
--- a/src/pal/tests/palsuite/c_runtime/sprintf_s/test17/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sprintf_s/test17/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sprintf_test17
 add_dependencies(paltest_sprintf_test17 coreclrpal)
 
 target_link_libraries(paltest_sprintf_test17
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sprintf_s/test18/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sprintf_s/test18/CMakeLists.txt
index f6e1b09efa..afc3e8f01c 100644
--- a/src/pal/tests/palsuite/c_runtime/sprintf_s/test18/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sprintf_s/test18/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sprintf_test18
 add_dependencies(paltest_sprintf_test18 coreclrpal)
 
 target_link_libraries(paltest_sprintf_test18
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sprintf_s/test19/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sprintf_s/test19/CMakeLists.txt
index 757288b694..7553aede95 100644
--- a/src/pal/tests/palsuite/c_runtime/sprintf_s/test19/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sprintf_s/test19/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sprintf_test19
 add_dependencies(paltest_sprintf_test19 coreclrpal)
 
 target_link_libraries(paltest_sprintf_test19
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sprintf_s/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sprintf_s/test2/CMakeLists.txt
index d569263da4..a4b0b007bc 100644
--- a/src/pal/tests/palsuite/c_runtime/sprintf_s/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sprintf_s/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sprintf_test2
 add_dependencies(paltest_sprintf_test2 coreclrpal)
 
 target_link_libraries(paltest_sprintf_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sprintf_s/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sprintf_s/test3/CMakeLists.txt
index 518c3f847a..825c79c03b 100644
--- a/src/pal/tests/palsuite/c_runtime/sprintf_s/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sprintf_s/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sprintf_test3
 add_dependencies(paltest_sprintf_test3 coreclrpal)
 
 target_link_libraries(paltest_sprintf_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sprintf_s/test4/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sprintf_s/test4/CMakeLists.txt
index 260def44aa..0bde37c239 100644
--- a/src/pal/tests/palsuite/c_runtime/sprintf_s/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sprintf_s/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sprintf_test4
 add_dependencies(paltest_sprintf_test4 coreclrpal)
 
 target_link_libraries(paltest_sprintf_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sprintf_s/test6/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sprintf_s/test6/CMakeLists.txt
index fce1f204fd..495c256b4d 100644
--- a/src/pal/tests/palsuite/c_runtime/sprintf_s/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sprintf_s/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sprintf_test6
 add_dependencies(paltest_sprintf_test6 coreclrpal)
 
 target_link_libraries(paltest_sprintf_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sprintf_s/test7/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sprintf_s/test7/CMakeLists.txt
index 72a831ec89..2fabe0b659 100644
--- a/src/pal/tests/palsuite/c_runtime/sprintf_s/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sprintf_s/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sprintf_test7
 add_dependencies(paltest_sprintf_test7 coreclrpal)
 
 target_link_libraries(paltest_sprintf_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sprintf_s/test8/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sprintf_s/test8/CMakeLists.txt
index c9522c1c9d..cb67e89df6 100644
--- a/src/pal/tests/palsuite/c_runtime/sprintf_s/test8/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sprintf_s/test8/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sprintf_test8
 add_dependencies(paltest_sprintf_test8 coreclrpal)
 
 target_link_libraries(paltest_sprintf_test8
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sprintf_s/test9/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sprintf_s/test9/CMakeLists.txt
index e76fed4784..005a23d4e6 100644
--- a/src/pal/tests/palsuite/c_runtime/sprintf_s/test9/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sprintf_s/test9/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sprintf_test9
 add_dependencies(paltest_sprintf_test9 coreclrpal)
 
 target_link_libraries(paltest_sprintf_test9
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sqrt/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sqrt/test1/CMakeLists.txt
index d4aefe6ca8..4680e2359b 100644
--- a/src/pal/tests/palsuite/c_runtime/sqrt/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sqrt/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sqrt_test1
 add_dependencies(paltest_sqrt_test1 coreclrpal)
 
 target_link_libraries(paltest_sqrt_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sqrtf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sqrtf/test1/CMakeLists.txt
index 96b6ffa998..51b76aeacd 100644
--- a/src/pal/tests/palsuite/c_runtime/sqrtf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sqrtf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sqrtf_test1
 add_dependencies(paltest_sqrtf_test1 coreclrpal)
 
 target_link_libraries(paltest_sqrtf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sscanf_s/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sscanf_s/test1/CMakeLists.txt
index 97b8f570e3..82a0e703bd 100644
--- a/src/pal/tests/palsuite/c_runtime/sscanf_s/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sscanf_s/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sscanf_test1
 add_dependencies(paltest_sscanf_test1 coreclrpal)
 
 target_link_libraries(paltest_sscanf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sscanf_s/test10/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sscanf_s/test10/CMakeLists.txt
index afda216c6b..c85e1b031f 100644
--- a/src/pal/tests/palsuite/c_runtime/sscanf_s/test10/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sscanf_s/test10/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sscanf_test10
 add_dependencies(paltest_sscanf_test10 coreclrpal)
 
 target_link_libraries(paltest_sscanf_test10
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sscanf_s/test11/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sscanf_s/test11/CMakeLists.txt
index c8f98aeeef..2c7f0e29e9 100644
--- a/src/pal/tests/palsuite/c_runtime/sscanf_s/test11/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sscanf_s/test11/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sscanf_test11
 add_dependencies(paltest_sscanf_test11 coreclrpal)
 
 target_link_libraries(paltest_sscanf_test11
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sscanf_s/test12/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sscanf_s/test12/CMakeLists.txt
index 0ecedc3285..af2355643e 100644
--- a/src/pal/tests/palsuite/c_runtime/sscanf_s/test12/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sscanf_s/test12/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sscanf_test12
 add_dependencies(paltest_sscanf_test12 coreclrpal)
 
 target_link_libraries(paltest_sscanf_test12
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sscanf_s/test13/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sscanf_s/test13/CMakeLists.txt
index 4566ec3338..7f9b3a1658 100644
--- a/src/pal/tests/palsuite/c_runtime/sscanf_s/test13/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sscanf_s/test13/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sscanf_test13
 add_dependencies(paltest_sscanf_test13 coreclrpal)
 
 target_link_libraries(paltest_sscanf_test13
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sscanf_s/test14/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sscanf_s/test14/CMakeLists.txt
index 557acf5bf8..c195b12ca7 100644
--- a/src/pal/tests/palsuite/c_runtime/sscanf_s/test14/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sscanf_s/test14/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sscanf_test14
 add_dependencies(paltest_sscanf_test14 coreclrpal)
 
 target_link_libraries(paltest_sscanf_test14
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sscanf_s/test15/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sscanf_s/test15/CMakeLists.txt
index efde5c4a21..0c8967d821 100644
--- a/src/pal/tests/palsuite/c_runtime/sscanf_s/test15/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sscanf_s/test15/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sscanf_test15
 add_dependencies(paltest_sscanf_test15 coreclrpal)
 
 target_link_libraries(paltest_sscanf_test15
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sscanf_s/test16/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sscanf_s/test16/CMakeLists.txt
index 6757b0d78a..10a6cc8a4e 100644
--- a/src/pal/tests/palsuite/c_runtime/sscanf_s/test16/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sscanf_s/test16/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sscanf_test16
 add_dependencies(paltest_sscanf_test16 coreclrpal)
 
 target_link_libraries(paltest_sscanf_test16
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sscanf_s/test17/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sscanf_s/test17/CMakeLists.txt
index 8ea4d5e3f6..84832a848f 100644
--- a/src/pal/tests/palsuite/c_runtime/sscanf_s/test17/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sscanf_s/test17/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sscanf_test17
 add_dependencies(paltest_sscanf_test17 coreclrpal)
 
 target_link_libraries(paltest_sscanf_test17
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sscanf_s/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sscanf_s/test2/CMakeLists.txt
index 4e36223a1d..a79492bf4f 100644
--- a/src/pal/tests/palsuite/c_runtime/sscanf_s/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sscanf_s/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sscanf_test2
 add_dependencies(paltest_sscanf_test2 coreclrpal)
 
 target_link_libraries(paltest_sscanf_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sscanf_s/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sscanf_s/test3/CMakeLists.txt
index 053a96ca0f..ba1a5286a4 100644
--- a/src/pal/tests/palsuite/c_runtime/sscanf_s/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sscanf_s/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sscanf_test3
 add_dependencies(paltest_sscanf_test3 coreclrpal)
 
 target_link_libraries(paltest_sscanf_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sscanf_s/test4/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sscanf_s/test4/CMakeLists.txt
index ae04bfef57..456fce018f 100644
--- a/src/pal/tests/palsuite/c_runtime/sscanf_s/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sscanf_s/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sscanf_test4
 add_dependencies(paltest_sscanf_test4 coreclrpal)
 
 target_link_libraries(paltest_sscanf_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sscanf_s/test5/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sscanf_s/test5/CMakeLists.txt
index 33dcaffec3..b4075037a4 100644
--- a/src/pal/tests/palsuite/c_runtime/sscanf_s/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sscanf_s/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sscanf_test5
 add_dependencies(paltest_sscanf_test5 coreclrpal)
 
 target_link_libraries(paltest_sscanf_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sscanf_s/test6/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sscanf_s/test6/CMakeLists.txt
index 1dd23c3cb1..f9815123d7 100644
--- a/src/pal/tests/palsuite/c_runtime/sscanf_s/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sscanf_s/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sscanf_test6
 add_dependencies(paltest_sscanf_test6 coreclrpal)
 
 target_link_libraries(paltest_sscanf_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sscanf_s/test7/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sscanf_s/test7/CMakeLists.txt
index 015a27b776..ba2913626e 100644
--- a/src/pal/tests/palsuite/c_runtime/sscanf_s/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sscanf_s/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sscanf_test7
 add_dependencies(paltest_sscanf_test7 coreclrpal)
 
 target_link_libraries(paltest_sscanf_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sscanf_s/test8/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sscanf_s/test8/CMakeLists.txt
index aa41ab42a6..2437679c04 100644
--- a/src/pal/tests/palsuite/c_runtime/sscanf_s/test8/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sscanf_s/test8/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sscanf_test8
 add_dependencies(paltest_sscanf_test8 coreclrpal)
 
 target_link_libraries(paltest_sscanf_test8
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/sscanf_s/test9/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/sscanf_s/test9/CMakeLists.txt
index b631fd40ea..a3df87279f 100644
--- a/src/pal/tests/palsuite/c_runtime/sscanf_s/test9/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/sscanf_s/test9/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sscanf_test9
 add_dependencies(paltest_sscanf_test9 coreclrpal)
 
 target_link_libraries(paltest_sscanf_test9
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/strcat/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/strcat/test1/CMakeLists.txt
index fd62627db6..29d25f10e6 100644
--- a/src/pal/tests/palsuite/c_runtime/strcat/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/strcat/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_strcat_test1
 add_dependencies(paltest_strcat_test1 coreclrpal)
 
 target_link_libraries(paltest_strcat_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/strchr/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/strchr/test1/CMakeLists.txt
index f3ffe3bc15..507d2e040f 100644
--- a/src/pal/tests/palsuite/c_runtime/strchr/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/strchr/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_strchr_test1
 add_dependencies(paltest_strchr_test1 coreclrpal)
 
 target_link_libraries(paltest_strchr_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/strcmp/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/strcmp/test1/CMakeLists.txt
index 3b0f89c2a5..6a0e9f13f6 100644
--- a/src/pal/tests/palsuite/c_runtime/strcmp/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/strcmp/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_strcmp_test1
 add_dependencies(paltest_strcmp_test1 coreclrpal)
 
 target_link_libraries(paltest_strcmp_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/strcpy/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/strcpy/test1/CMakeLists.txt
index 4369d37a40..cecb086030 100644
--- a/src/pal/tests/palsuite/c_runtime/strcpy/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/strcpy/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_strcpy_test1
 add_dependencies(paltest_strcpy_test1 coreclrpal)
 
 target_link_libraries(paltest_strcpy_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/strcspn/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/strcspn/test1/CMakeLists.txt
index 717e18f0e9..4b1ea67893 100644
--- a/src/pal/tests/palsuite/c_runtime/strcspn/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/strcspn/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_strcspn_test1
 add_dependencies(paltest_strcspn_test1 coreclrpal)
 
 target_link_libraries(paltest_strcspn_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/strlen/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/strlen/test1/CMakeLists.txt
index 4afeb598aa..42cecf4aaf 100644
--- a/src/pal/tests/palsuite/c_runtime/strlen/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/strlen/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_strlen_test1
 add_dependencies(paltest_strlen_test1 coreclrpal)
 
 target_link_libraries(paltest_strlen_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/strncat/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/strncat/test1/CMakeLists.txt
index f8080ecdc2..bf2363387c 100644
--- a/src/pal/tests/palsuite/c_runtime/strncat/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/strncat/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_strncat_test1
 add_dependencies(paltest_strncat_test1 coreclrpal)
 
 target_link_libraries(paltest_strncat_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/strncmp/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/strncmp/test1/CMakeLists.txt
index 34b53e294d..b76ff5eeab 100644
--- a/src/pal/tests/palsuite/c_runtime/strncmp/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/strncmp/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_strncmp_test1
 add_dependencies(paltest_strncmp_test1 coreclrpal)
 
 target_link_libraries(paltest_strncmp_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/strncpy/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/strncpy/test1/CMakeLists.txt
index fb737c8c59..9b8ed3ff83 100644
--- a/src/pal/tests/palsuite/c_runtime/strncpy/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/strncpy/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_strncpy_test1
 add_dependencies(paltest_strncpy_test1 coreclrpal)
 
 target_link_libraries(paltest_strncpy_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/strpbrk/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/strpbrk/test1/CMakeLists.txt
index 9e76436e01..239b36c946 100644
--- a/src/pal/tests/palsuite/c_runtime/strpbrk/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/strpbrk/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_strpbrk_test1
 add_dependencies(paltest_strpbrk_test1 coreclrpal)
 
 target_link_libraries(paltest_strpbrk_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/strrchr/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/strrchr/test1/CMakeLists.txt
index bb6916038d..19bdd4e1d0 100644
--- a/src/pal/tests/palsuite/c_runtime/strrchr/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/strrchr/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_strrchr_test1
 add_dependencies(paltest_strrchr_test1 coreclrpal)
 
 target_link_libraries(paltest_strrchr_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/strspn/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/strspn/test1/CMakeLists.txt
index c72fd0fa9a..324690034d 100644
--- a/src/pal/tests/palsuite/c_runtime/strspn/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/strspn/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_strspn_test1
 add_dependencies(paltest_strspn_test1 coreclrpal)
 
 target_link_libraries(paltest_strspn_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/strstr/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/strstr/test1/CMakeLists.txt
index 004b9a5658..b8fe41809f 100644
--- a/src/pal/tests/palsuite/c_runtime/strstr/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/strstr/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_strstr_test1
 add_dependencies(paltest_strstr_test1 coreclrpal)
 
 target_link_libraries(paltest_strstr_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/strtod/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/strtod/test1/CMakeLists.txt
index 09884f32e6..1a2df225bd 100644
--- a/src/pal/tests/palsuite/c_runtime/strtod/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/strtod/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_strtod_test1
 add_dependencies(paltest_strtod_test1 coreclrpal)
 
 target_link_libraries(paltest_strtod_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/strtod/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/strtod/test2/CMakeLists.txt
index 8729cc5a1c..581e4de3e7 100644
--- a/src/pal/tests/palsuite/c_runtime/strtod/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/strtod/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_strtod_test2
 add_dependencies(paltest_strtod_test2 coreclrpal)
 
 target_link_libraries(paltest_strtod_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/strtok/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/strtok/test1/CMakeLists.txt
index 422c4e96b5..098a6640f1 100644
--- a/src/pal/tests/palsuite/c_runtime/strtok/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/strtok/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_strtok_test1
 add_dependencies(paltest_strtok_test1 coreclrpal)
 
 target_link_libraries(paltest_strtok_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/strtoul/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/strtoul/test1/CMakeLists.txt
index 009e85fb11..bdf4497cae 100644
--- a/src/pal/tests/palsuite/c_runtime/strtoul/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/strtoul/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_strtoul_test1
 add_dependencies(paltest_strtoul_test1 coreclrpal)
 
 target_link_libraries(paltest_strtoul_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swprintf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swprintf/test1/CMakeLists.txt
index c9be8c3347..f89cfb6fd6 100644
--- a/src/pal/tests/palsuite/c_runtime/swprintf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swprintf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swprintf_test1
 add_dependencies(paltest_swprintf_test1 coreclrpal)
 
 target_link_libraries(paltest_swprintf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swprintf/test10/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swprintf/test10/CMakeLists.txt
index 222108393b..70581d16a9 100644
--- a/src/pal/tests/palsuite/c_runtime/swprintf/test10/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swprintf/test10/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swprintf_test10
 add_dependencies(paltest_swprintf_test10 coreclrpal)
 
 target_link_libraries(paltest_swprintf_test10
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swprintf/test11/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swprintf/test11/CMakeLists.txt
index 96222a5b2a..4d51917540 100644
--- a/src/pal/tests/palsuite/c_runtime/swprintf/test11/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swprintf/test11/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swprintf_test11
 add_dependencies(paltest_swprintf_test11 coreclrpal)
 
 target_link_libraries(paltest_swprintf_test11
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swprintf/test12/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swprintf/test12/CMakeLists.txt
index 1ffe620fed..57cce1679a 100644
--- a/src/pal/tests/palsuite/c_runtime/swprintf/test12/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swprintf/test12/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swprintf_test12
 add_dependencies(paltest_swprintf_test12 coreclrpal)
 
 target_link_libraries(paltest_swprintf_test12
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swprintf/test13/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swprintf/test13/CMakeLists.txt
index 8699589ec9..5b6c635858 100644
--- a/src/pal/tests/palsuite/c_runtime/swprintf/test13/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swprintf/test13/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swprintf_test13
 add_dependencies(paltest_swprintf_test13 coreclrpal)
 
 target_link_libraries(paltest_swprintf_test13
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swprintf/test14/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swprintf/test14/CMakeLists.txt
index 2a4b84805c..88334d67a5 100644
--- a/src/pal/tests/palsuite/c_runtime/swprintf/test14/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swprintf/test14/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swprintf_test14
 add_dependencies(paltest_swprintf_test14 coreclrpal)
 
 target_link_libraries(paltest_swprintf_test14
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swprintf/test15/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swprintf/test15/CMakeLists.txt
index 22382bce5f..5387060b2d 100644
--- a/src/pal/tests/palsuite/c_runtime/swprintf/test15/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swprintf/test15/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swprintf_test15
 add_dependencies(paltest_swprintf_test15 coreclrpal)
 
 target_link_libraries(paltest_swprintf_test15
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swprintf/test16/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swprintf/test16/CMakeLists.txt
index 462f0806cd..4f66beaa24 100644
--- a/src/pal/tests/palsuite/c_runtime/swprintf/test16/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swprintf/test16/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swprintf_test16
 add_dependencies(paltest_swprintf_test16 coreclrpal)
 
 target_link_libraries(paltest_swprintf_test16
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swprintf/test17/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swprintf/test17/CMakeLists.txt
index c5b4d44593..ace16a18f1 100644
--- a/src/pal/tests/palsuite/c_runtime/swprintf/test17/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swprintf/test17/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swprintf_test17
 add_dependencies(paltest_swprintf_test17 coreclrpal)
 
 target_link_libraries(paltest_swprintf_test17
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swprintf/test18/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swprintf/test18/CMakeLists.txt
index 6cdf576966..ddce256260 100644
--- a/src/pal/tests/palsuite/c_runtime/swprintf/test18/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swprintf/test18/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swprintf_test18
 add_dependencies(paltest_swprintf_test18 coreclrpal)
 
 target_link_libraries(paltest_swprintf_test18
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swprintf/test19/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swprintf/test19/CMakeLists.txt
index 334b7b4fa1..8d48ce438c 100644
--- a/src/pal/tests/palsuite/c_runtime/swprintf/test19/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swprintf/test19/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swprintf_test19
 add_dependencies(paltest_swprintf_test19 coreclrpal)
 
 target_link_libraries(paltest_swprintf_test19
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swprintf/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swprintf/test2/CMakeLists.txt
index af2b13e4c7..fcf7136797 100644
--- a/src/pal/tests/palsuite/c_runtime/swprintf/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swprintf/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swprintf_test2
 add_dependencies(paltest_swprintf_test2 coreclrpal)
 
 target_link_libraries(paltest_swprintf_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swprintf/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swprintf/test3/CMakeLists.txt
index 14b81f4ac8..cc79c2d1d1 100644
--- a/src/pal/tests/palsuite/c_runtime/swprintf/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swprintf/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swprintf_test3
 add_dependencies(paltest_swprintf_test3 coreclrpal)
 
 target_link_libraries(paltest_swprintf_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swprintf/test4/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swprintf/test4/CMakeLists.txt
index e153e6b02f..c5d92462a6 100644
--- a/src/pal/tests/palsuite/c_runtime/swprintf/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swprintf/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swprintf_test4
 add_dependencies(paltest_swprintf_test4 coreclrpal)
 
 target_link_libraries(paltest_swprintf_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swprintf/test6/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swprintf/test6/CMakeLists.txt
index 806211a992..044029dd62 100644
--- a/src/pal/tests/palsuite/c_runtime/swprintf/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swprintf/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swprintf_test6
 add_dependencies(paltest_swprintf_test6 coreclrpal)
 
 target_link_libraries(paltest_swprintf_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swprintf/test7/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swprintf/test7/CMakeLists.txt
index cf563799d9..3ee7139ec7 100644
--- a/src/pal/tests/palsuite/c_runtime/swprintf/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swprintf/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swprintf_test7
 add_dependencies(paltest_swprintf_test7 coreclrpal)
 
 target_link_libraries(paltest_swprintf_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swprintf/test8/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swprintf/test8/CMakeLists.txt
index e8fcf66157..55ac85c164 100644
--- a/src/pal/tests/palsuite/c_runtime/swprintf/test8/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swprintf/test8/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swprintf_test8
 add_dependencies(paltest_swprintf_test8 coreclrpal)
 
 target_link_libraries(paltest_swprintf_test8
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swprintf/test9/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swprintf/test9/CMakeLists.txt
index c616348766..7d7f524f65 100644
--- a/src/pal/tests/palsuite/c_runtime/swprintf/test9/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swprintf/test9/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swprintf_test9
 add_dependencies(paltest_swprintf_test9 coreclrpal)
 
 target_link_libraries(paltest_swprintf_test9
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swscanf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swscanf/test1/CMakeLists.txt
index 44b8939248..ae2366e812 100644
--- a/src/pal/tests/palsuite/c_runtime/swscanf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swscanf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swscanf_test1
 add_dependencies(paltest_swscanf_test1 coreclrpal)
 
 target_link_libraries(paltest_swscanf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swscanf/test10/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swscanf/test10/CMakeLists.txt
index 27d42114a9..313b4f4693 100644
--- a/src/pal/tests/palsuite/c_runtime/swscanf/test10/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swscanf/test10/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swscanf_test10
 add_dependencies(paltest_swscanf_test10 coreclrpal)
 
 target_link_libraries(paltest_swscanf_test10
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swscanf/test11/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swscanf/test11/CMakeLists.txt
index 1ca9224ec0..79703e598a 100644
--- a/src/pal/tests/palsuite/c_runtime/swscanf/test11/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swscanf/test11/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swscanf_test11
 add_dependencies(paltest_swscanf_test11 coreclrpal)
 
 target_link_libraries(paltest_swscanf_test11
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swscanf/test12/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swscanf/test12/CMakeLists.txt
index 44d70f47ae..8c6754f442 100644
--- a/src/pal/tests/palsuite/c_runtime/swscanf/test12/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swscanf/test12/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swscanf_test12
 add_dependencies(paltest_swscanf_test12 coreclrpal)
 
 target_link_libraries(paltest_swscanf_test12
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swscanf/test13/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swscanf/test13/CMakeLists.txt
index add0cbfe18..8072390bde 100644
--- a/src/pal/tests/palsuite/c_runtime/swscanf/test13/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swscanf/test13/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swscanf_test13
 add_dependencies(paltest_swscanf_test13 coreclrpal)
 
 target_link_libraries(paltest_swscanf_test13
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swscanf/test14/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swscanf/test14/CMakeLists.txt
index 126e087b1c..723b68f449 100644
--- a/src/pal/tests/palsuite/c_runtime/swscanf/test14/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swscanf/test14/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swscanf_test14
 add_dependencies(paltest_swscanf_test14 coreclrpal)
 
 target_link_libraries(paltest_swscanf_test14
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swscanf/test15/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swscanf/test15/CMakeLists.txt
index 7c2da2bdf8..e0b7fd8d28 100644
--- a/src/pal/tests/palsuite/c_runtime/swscanf/test15/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swscanf/test15/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swscanf_test15
 add_dependencies(paltest_swscanf_test15 coreclrpal)
 
 target_link_libraries(paltest_swscanf_test15
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swscanf/test16/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swscanf/test16/CMakeLists.txt
index ba28c4dc2f..a593fd119e 100644
--- a/src/pal/tests/palsuite/c_runtime/swscanf/test16/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swscanf/test16/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swscanf_test16
 add_dependencies(paltest_swscanf_test16 coreclrpal)
 
 target_link_libraries(paltest_swscanf_test16
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swscanf/test17/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swscanf/test17/CMakeLists.txt
index 225ce868ed..890d9a4e6e 100644
--- a/src/pal/tests/palsuite/c_runtime/swscanf/test17/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swscanf/test17/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swscanf_test17
 add_dependencies(paltest_swscanf_test17 coreclrpal)
 
 target_link_libraries(paltest_swscanf_test17
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swscanf/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swscanf/test2/CMakeLists.txt
index 15411ecf21..e6d17b3855 100644
--- a/src/pal/tests/palsuite/c_runtime/swscanf/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swscanf/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swscanf_test2
 add_dependencies(paltest_swscanf_test2 coreclrpal)
 
 target_link_libraries(paltest_swscanf_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swscanf/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swscanf/test3/CMakeLists.txt
index 927026107a..72be68114b 100644
--- a/src/pal/tests/palsuite/c_runtime/swscanf/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swscanf/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swscanf_test3
 add_dependencies(paltest_swscanf_test3 coreclrpal)
 
 target_link_libraries(paltest_swscanf_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swscanf/test4/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swscanf/test4/CMakeLists.txt
index eec701645b..3581ec1413 100644
--- a/src/pal/tests/palsuite/c_runtime/swscanf/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swscanf/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swscanf_test4
 add_dependencies(paltest_swscanf_test4 coreclrpal)
 
 target_link_libraries(paltest_swscanf_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swscanf/test5/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swscanf/test5/CMakeLists.txt
index 3f022db16c..8ade17ac6e 100644
--- a/src/pal/tests/palsuite/c_runtime/swscanf/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swscanf/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swscanf_test5
 add_dependencies(paltest_swscanf_test5 coreclrpal)
 
 target_link_libraries(paltest_swscanf_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swscanf/test6/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swscanf/test6/CMakeLists.txt
index c55666d95c..d43cc30a7f 100644
--- a/src/pal/tests/palsuite/c_runtime/swscanf/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swscanf/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swscanf_test6
 add_dependencies(paltest_swscanf_test6 coreclrpal)
 
 target_link_libraries(paltest_swscanf_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swscanf/test7/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swscanf/test7/CMakeLists.txt
index adb0abe80d..3ac9f9d630 100644
--- a/src/pal/tests/palsuite/c_runtime/swscanf/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swscanf/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swscanf_test7
 add_dependencies(paltest_swscanf_test7 coreclrpal)
 
 target_link_libraries(paltest_swscanf_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swscanf/test8/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swscanf/test8/CMakeLists.txt
index a69c552337..4e312edc17 100644
--- a/src/pal/tests/palsuite/c_runtime/swscanf/test8/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swscanf/test8/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swscanf_test8
 add_dependencies(paltest_swscanf_test8 coreclrpal)
 
 target_link_libraries(paltest_swscanf_test8
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/swscanf/test9/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/swscanf/test9/CMakeLists.txt
index 70a9fe2064..ca21283476 100644
--- a/src/pal/tests/palsuite/c_runtime/swscanf/test9/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/swscanf/test9/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_swscanf_test9
 add_dependencies(paltest_swscanf_test9 coreclrpal)
 
 target_link_libraries(paltest_swscanf_test9
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/tan/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/tan/test1/CMakeLists.txt
index cea661f2bb..64b90265b2 100644
--- a/src/pal/tests/palsuite/c_runtime/tan/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/tan/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_tan_test1
 add_dependencies(paltest_tan_test1 coreclrpal)
 
 target_link_libraries(paltest_tan_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/tanf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/tanf/test1/CMakeLists.txt
index cd588ea23e..6883041a22 100644
--- a/src/pal/tests/palsuite/c_runtime/tanf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/tanf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_tanf_test1
 add_dependencies(paltest_tanf_test1 coreclrpal)
 
 target_link_libraries(paltest_tanf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/tanh/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/tanh/test1/CMakeLists.txt
index 9fe926d441..f8cb99c264 100644
--- a/src/pal/tests/palsuite/c_runtime/tanh/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/tanh/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_tanh_test1
 add_dependencies(paltest_tanh_test1 coreclrpal)
 
 target_link_libraries(paltest_tanh_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/tanhf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/tanhf/test1/CMakeLists.txt
index fd0af2a46f..83e2612fa8 100644
--- a/src/pal/tests/palsuite/c_runtime/tanhf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/tanhf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_tanhf_test1
 add_dependencies(paltest_tanhf_test1 coreclrpal)
 
 target_link_libraries(paltest_tanhf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/time/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/time/test1/CMakeLists.txt
index 64df144557..d3605e8c71 100644
--- a/src/pal/tests/palsuite/c_runtime/time/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/time/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_time_test1
 add_dependencies(paltest_time_test1 coreclrpal)
 
 target_link_libraries(paltest_time_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/tolower/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/tolower/test1/CMakeLists.txt
index 214a509010..90a3b98825 100644
--- a/src/pal/tests/palsuite/c_runtime/tolower/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/tolower/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_tolower_test1
 add_dependencies(paltest_tolower_test1 coreclrpal)
 
 target_link_libraries(paltest_tolower_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/toupper/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/toupper/test1/CMakeLists.txt
index 3dd536c590..2d64731183 100644
--- a/src/pal/tests/palsuite/c_runtime/toupper/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/toupper/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_toupper_test1
 add_dependencies(paltest_toupper_test1 coreclrpal)
 
 target_link_libraries(paltest_toupper_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/towlower/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/towlower/test1/CMakeLists.txt
index 77a46344d4..e5da389dee 100644
--- a/src/pal/tests/palsuite/c_runtime/towlower/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/towlower/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_towlower_test1
 add_dependencies(paltest_towlower_test1 coreclrpal)
 
 target_link_libraries(paltest_towlower_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/towupper/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/towupper/test1/CMakeLists.txt
index 6a2f813cc9..a09dca8f84 100644
--- a/src/pal/tests/palsuite/c_runtime/towupper/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/towupper/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_towupper_test1
 add_dependencies(paltest_towupper_test1 coreclrpal)
 
 target_link_libraries(paltest_towupper_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/ungetc/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/ungetc/test1/CMakeLists.txt
index 0286f99b77..9db3fce592 100644
--- a/src/pal/tests/palsuite/c_runtime/ungetc/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/ungetc/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_ungetc_test1
 add_dependencies(paltest_ungetc_test1 coreclrpal)
 
 target_link_libraries(paltest_ungetc_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/ungetc/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/ungetc/test2/CMakeLists.txt
index 0710074bd0..f4a2c733de 100644
--- a/src/pal/tests/palsuite/c_runtime/ungetc/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/ungetc/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_ungetc_test2
 add_dependencies(paltest_ungetc_test2 coreclrpal)
 
 target_link_libraries(paltest_ungetc_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vfprintf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vfprintf/test1/CMakeLists.txt
index fcff4a2074..138615a400 100644
--- a/src/pal/tests/palsuite/c_runtime/vfprintf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vfprintf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vfprintf_test1
 add_dependencies(paltest_vfprintf_test1 coreclrpal)
 
 target_link_libraries(paltest_vfprintf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vfprintf/test10/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vfprintf/test10/CMakeLists.txt
index 97c7b167ab..824d1466aa 100644
--- a/src/pal/tests/palsuite/c_runtime/vfprintf/test10/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vfprintf/test10/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vfprintf_test10
 add_dependencies(paltest_vfprintf_test10 coreclrpal)
 
 target_link_libraries(paltest_vfprintf_test10
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vfprintf/test11/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vfprintf/test11/CMakeLists.txt
index 9250eb957d..492e8502a5 100644
--- a/src/pal/tests/palsuite/c_runtime/vfprintf/test11/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vfprintf/test11/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vfprintf_test11
 add_dependencies(paltest_vfprintf_test11 coreclrpal)
 
 target_link_libraries(paltest_vfprintf_test11
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vfprintf/test12/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vfprintf/test12/CMakeLists.txt
index 53d3488b4a..5837e1f2ba 100644
--- a/src/pal/tests/palsuite/c_runtime/vfprintf/test12/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vfprintf/test12/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vfprintf_test12
 add_dependencies(paltest_vfprintf_test12 coreclrpal)
 
 target_link_libraries(paltest_vfprintf_test12
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vfprintf/test13/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vfprintf/test13/CMakeLists.txt
index c35813b420..2a9ec0b6b5 100644
--- a/src/pal/tests/palsuite/c_runtime/vfprintf/test13/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vfprintf/test13/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vfprintf_test13
 add_dependencies(paltest_vfprintf_test13 coreclrpal)
 
 target_link_libraries(paltest_vfprintf_test13
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vfprintf/test14/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vfprintf/test14/CMakeLists.txt
index bd91f509b5..21c90bf7a6 100644
--- a/src/pal/tests/palsuite/c_runtime/vfprintf/test14/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vfprintf/test14/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vfprintf_test14
 add_dependencies(paltest_vfprintf_test14 coreclrpal)
 
 target_link_libraries(paltest_vfprintf_test14
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vfprintf/test15/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vfprintf/test15/CMakeLists.txt
index 30003b82f8..7ec560b77e 100644
--- a/src/pal/tests/palsuite/c_runtime/vfprintf/test15/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vfprintf/test15/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vfprintf_test15
 add_dependencies(paltest_vfprintf_test15 coreclrpal)
 
 target_link_libraries(paltest_vfprintf_test15
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vfprintf/test16/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vfprintf/test16/CMakeLists.txt
index a287f120a0..8dac2ede06 100644
--- a/src/pal/tests/palsuite/c_runtime/vfprintf/test16/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vfprintf/test16/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vfprintf_test16
 add_dependencies(paltest_vfprintf_test16 coreclrpal)
 
 target_link_libraries(paltest_vfprintf_test16
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vfprintf/test17/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vfprintf/test17/CMakeLists.txt
index cf1afd9d2d..1708518678 100644
--- a/src/pal/tests/palsuite/c_runtime/vfprintf/test17/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vfprintf/test17/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vfprintf_test17
 add_dependencies(paltest_vfprintf_test17 coreclrpal)
 
 target_link_libraries(paltest_vfprintf_test17
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vfprintf/test18/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vfprintf/test18/CMakeLists.txt
index 143eade9b3..7c40561abf 100644
--- a/src/pal/tests/palsuite/c_runtime/vfprintf/test18/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vfprintf/test18/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vfprintf_test18
 add_dependencies(paltest_vfprintf_test18 coreclrpal)
 
 target_link_libraries(paltest_vfprintf_test18
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vfprintf/test19/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vfprintf/test19/CMakeLists.txt
index 452d929b7d..2a985eb433 100644
--- a/src/pal/tests/palsuite/c_runtime/vfprintf/test19/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vfprintf/test19/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vfprintf_test19
 add_dependencies(paltest_vfprintf_test19 coreclrpal)
 
 target_link_libraries(paltest_vfprintf_test19
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vfprintf/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vfprintf/test2/CMakeLists.txt
index b18fb712c6..c374fa6e22 100644
--- a/src/pal/tests/palsuite/c_runtime/vfprintf/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vfprintf/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vfprintf_test2
 add_dependencies(paltest_vfprintf_test2 coreclrpal)
 
 target_link_libraries(paltest_vfprintf_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vfprintf/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vfprintf/test3/CMakeLists.txt
index a8f7eb1991..a618fc9b74 100644
--- a/src/pal/tests/palsuite/c_runtime/vfprintf/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vfprintf/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vfprintf_test3
 add_dependencies(paltest_vfprintf_test3 coreclrpal)
 
 target_link_libraries(paltest_vfprintf_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vfprintf/test4/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vfprintf/test4/CMakeLists.txt
index 60c31693a5..941bade25e 100644
--- a/src/pal/tests/palsuite/c_runtime/vfprintf/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vfprintf/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vfprintf_test4
 add_dependencies(paltest_vfprintf_test4 coreclrpal)
 
 target_link_libraries(paltest_vfprintf_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vfprintf/test5/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vfprintf/test5/CMakeLists.txt
index 5f516fec6a..6089352834 100644
--- a/src/pal/tests/palsuite/c_runtime/vfprintf/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vfprintf/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vfprintf_test5
 add_dependencies(paltest_vfprintf_test5 coreclrpal)
 
 target_link_libraries(paltest_vfprintf_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vfprintf/test6/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vfprintf/test6/CMakeLists.txt
index 7f0cc710af..77c2bb17d5 100644
--- a/src/pal/tests/palsuite/c_runtime/vfprintf/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vfprintf/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vfprintf_test6
 add_dependencies(paltest_vfprintf_test6 coreclrpal)
 
 target_link_libraries(paltest_vfprintf_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vfprintf/test7/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vfprintf/test7/CMakeLists.txt
index a2cd9a2e8f..de00105386 100644
--- a/src/pal/tests/palsuite/c_runtime/vfprintf/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vfprintf/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vfprintf_test7
 add_dependencies(paltest_vfprintf_test7 coreclrpal)
 
 target_link_libraries(paltest_vfprintf_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vfprintf/test8/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vfprintf/test8/CMakeLists.txt
index a7b20ee43e..3129aeb185 100644
--- a/src/pal/tests/palsuite/c_runtime/vfprintf/test8/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vfprintf/test8/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vfprintf_test8
 add_dependencies(paltest_vfprintf_test8 coreclrpal)
 
 target_link_libraries(paltest_vfprintf_test8
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vfprintf/test9/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vfprintf/test9/CMakeLists.txt
index 242b635f93..9cfaa584e8 100644
--- a/src/pal/tests/palsuite/c_runtime/vfprintf/test9/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vfprintf/test9/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vfprintf_test9
 add_dependencies(paltest_vfprintf_test9 coreclrpal)
 
 target_link_libraries(paltest_vfprintf_test9
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vprintf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vprintf/test1/CMakeLists.txt
index 9d866e16a2..db1d273da9 100644
--- a/src/pal/tests/palsuite/c_runtime/vprintf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vprintf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vprintf_test1
 add_dependencies(paltest_vprintf_test1 coreclrpal)
 
 target_link_libraries(paltest_vprintf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vprintf/test10/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vprintf/test10/CMakeLists.txt
index 4ed04b46c6..89cd486f13 100644
--- a/src/pal/tests/palsuite/c_runtime/vprintf/test10/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vprintf/test10/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vprintf_test10
 add_dependencies(paltest_vprintf_test10 coreclrpal)
 
 target_link_libraries(paltest_vprintf_test10
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vprintf/test11/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vprintf/test11/CMakeLists.txt
index 5dc3c6dc69..a91ea25b7b 100644
--- a/src/pal/tests/palsuite/c_runtime/vprintf/test11/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vprintf/test11/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vprintf_test11
 add_dependencies(paltest_vprintf_test11 coreclrpal)
 
 target_link_libraries(paltest_vprintf_test11
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vprintf/test12/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vprintf/test12/CMakeLists.txt
index a8104296c4..0e3c5c9d0d 100644
--- a/src/pal/tests/palsuite/c_runtime/vprintf/test12/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vprintf/test12/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vprintf_test12
 add_dependencies(paltest_vprintf_test12 coreclrpal)
 
 target_link_libraries(paltest_vprintf_test12
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vprintf/test13/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vprintf/test13/CMakeLists.txt
index df98081ed7..877387f730 100644
--- a/src/pal/tests/palsuite/c_runtime/vprintf/test13/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vprintf/test13/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vprintf_test13
 add_dependencies(paltest_vprintf_test13 coreclrpal)
 
 target_link_libraries(paltest_vprintf_test13
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vprintf/test14/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vprintf/test14/CMakeLists.txt
index b903d4e241..8dcc4c97fe 100644
--- a/src/pal/tests/palsuite/c_runtime/vprintf/test14/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vprintf/test14/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vprintf_test14
 add_dependencies(paltest_vprintf_test14 coreclrpal)
 
 target_link_libraries(paltest_vprintf_test14
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vprintf/test15/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vprintf/test15/CMakeLists.txt
index 659ed9cb44..7c050494ff 100644
--- a/src/pal/tests/palsuite/c_runtime/vprintf/test15/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vprintf/test15/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vprintf_test15
 add_dependencies(paltest_vprintf_test15 coreclrpal)
 
 target_link_libraries(paltest_vprintf_test15
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vprintf/test16/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vprintf/test16/CMakeLists.txt
index b2f7fe8b78..2280f66960 100644
--- a/src/pal/tests/palsuite/c_runtime/vprintf/test16/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vprintf/test16/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vprintf_test16
 add_dependencies(paltest_vprintf_test16 coreclrpal)
 
 target_link_libraries(paltest_vprintf_test16
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vprintf/test17/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vprintf/test17/CMakeLists.txt
index 76cfc9ad06..99c3adf0a6 100644
--- a/src/pal/tests/palsuite/c_runtime/vprintf/test17/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vprintf/test17/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vprintf_test17
 add_dependencies(paltest_vprintf_test17 coreclrpal)
 
 target_link_libraries(paltest_vprintf_test17
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vprintf/test18/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vprintf/test18/CMakeLists.txt
index 633fb7ee51..88c81e3a91 100644
--- a/src/pal/tests/palsuite/c_runtime/vprintf/test18/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vprintf/test18/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vprintf_test18
 add_dependencies(paltest_vprintf_test18 coreclrpal)
 
 target_link_libraries(paltest_vprintf_test18
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vprintf/test19/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vprintf/test19/CMakeLists.txt
index 1a6256ad0b..59da1ea113 100644
--- a/src/pal/tests/palsuite/c_runtime/vprintf/test19/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vprintf/test19/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vprintf_test19
 add_dependencies(paltest_vprintf_test19 coreclrpal)
 
 target_link_libraries(paltest_vprintf_test19
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vprintf/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vprintf/test2/CMakeLists.txt
index 41e2073477..c89c81e0ee 100644
--- a/src/pal/tests/palsuite/c_runtime/vprintf/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vprintf/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vprintf_test2
 add_dependencies(paltest_vprintf_test2 coreclrpal)
 
 target_link_libraries(paltest_vprintf_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vprintf/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vprintf/test3/CMakeLists.txt
index 8570666b11..0e69b53718 100644
--- a/src/pal/tests/palsuite/c_runtime/vprintf/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vprintf/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vprintf_test3
 add_dependencies(paltest_vprintf_test3 coreclrpal)
 
 target_link_libraries(paltest_vprintf_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vprintf/test4/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vprintf/test4/CMakeLists.txt
index 06b582b5ee..a06c2b7570 100644
--- a/src/pal/tests/palsuite/c_runtime/vprintf/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vprintf/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vprintf_test4
 add_dependencies(paltest_vprintf_test4 coreclrpal)
 
 target_link_libraries(paltest_vprintf_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vprintf/test5/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vprintf/test5/CMakeLists.txt
index 3a1828a28c..0124cc3b36 100644
--- a/src/pal/tests/palsuite/c_runtime/vprintf/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vprintf/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vprintf_test5
 add_dependencies(paltest_vprintf_test5 coreclrpal)
 
 target_link_libraries(paltest_vprintf_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vprintf/test6/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vprintf/test6/CMakeLists.txt
index 2dac7703e6..b25f46d6c8 100644
--- a/src/pal/tests/palsuite/c_runtime/vprintf/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vprintf/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vprintf_test6
 add_dependencies(paltest_vprintf_test6 coreclrpal)
 
 target_link_libraries(paltest_vprintf_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vprintf/test7/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vprintf/test7/CMakeLists.txt
index 5a520045a9..b24e241cb2 100644
--- a/src/pal/tests/palsuite/c_runtime/vprintf/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vprintf/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vprintf_test7
 add_dependencies(paltest_vprintf_test7 coreclrpal)
 
 target_link_libraries(paltest_vprintf_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vprintf/test8/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vprintf/test8/CMakeLists.txt
index 18e4e3a0c9..d7b4b0150e 100644
--- a/src/pal/tests/palsuite/c_runtime/vprintf/test8/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vprintf/test8/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vprintf_test8
 add_dependencies(paltest_vprintf_test8 coreclrpal)
 
 target_link_libraries(paltest_vprintf_test8
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vprintf/test9/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vprintf/test9/CMakeLists.txt
index 8bcbe81f51..b9fd6106b8 100644
--- a/src/pal/tests/palsuite/c_runtime/vprintf/test9/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vprintf/test9/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vprintf_test9
 add_dependencies(paltest_vprintf_test9 coreclrpal)
 
 target_link_libraries(paltest_vprintf_test9
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vsprintf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vsprintf/test1/CMakeLists.txt
index 6861157c1b..34d8ad9f9b 100644
--- a/src/pal/tests/palsuite/c_runtime/vsprintf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vsprintf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsprintf_test1
 add_dependencies(paltest_vsprintf_test1 coreclrpal)
 
 target_link_libraries(paltest_vsprintf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vsprintf/test10/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vsprintf/test10/CMakeLists.txt
index 6f535a5098..3b0477a2c6 100644
--- a/src/pal/tests/palsuite/c_runtime/vsprintf/test10/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vsprintf/test10/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsprintf_test10
 add_dependencies(paltest_vsprintf_test10 coreclrpal)
 
 target_link_libraries(paltest_vsprintf_test10
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vsprintf/test11/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vsprintf/test11/CMakeLists.txt
index 3fa628f77d..723fa6b7f2 100644
--- a/src/pal/tests/palsuite/c_runtime/vsprintf/test11/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vsprintf/test11/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsprintf_test11
 add_dependencies(paltest_vsprintf_test11 coreclrpal)
 
 target_link_libraries(paltest_vsprintf_test11
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vsprintf/test12/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vsprintf/test12/CMakeLists.txt
index f34f76abc5..b58d47edd7 100644
--- a/src/pal/tests/palsuite/c_runtime/vsprintf/test12/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vsprintf/test12/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsprintf_test12
 add_dependencies(paltest_vsprintf_test12 coreclrpal)
 
 target_link_libraries(paltest_vsprintf_test12
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vsprintf/test13/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vsprintf/test13/CMakeLists.txt
index df23693f10..33ea479374 100644
--- a/src/pal/tests/palsuite/c_runtime/vsprintf/test13/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vsprintf/test13/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsprintf_test13
 add_dependencies(paltest_vsprintf_test13 coreclrpal)
 
 target_link_libraries(paltest_vsprintf_test13
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vsprintf/test14/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vsprintf/test14/CMakeLists.txt
index 394b5ab97c..b1a078498b 100644
--- a/src/pal/tests/palsuite/c_runtime/vsprintf/test14/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vsprintf/test14/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsprintf_test14
 add_dependencies(paltest_vsprintf_test14 coreclrpal)
 
 target_link_libraries(paltest_vsprintf_test14
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vsprintf/test15/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vsprintf/test15/CMakeLists.txt
index 4793b45663..b6642eddba 100644
--- a/src/pal/tests/palsuite/c_runtime/vsprintf/test15/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vsprintf/test15/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsprintf_test15
 add_dependencies(paltest_vsprintf_test15 coreclrpal)
 
 target_link_libraries(paltest_vsprintf_test15
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vsprintf/test16/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vsprintf/test16/CMakeLists.txt
index 6a0a52ddf7..c587798c62 100644
--- a/src/pal/tests/palsuite/c_runtime/vsprintf/test16/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vsprintf/test16/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsprintf_test16
 add_dependencies(paltest_vsprintf_test16 coreclrpal)
 
 target_link_libraries(paltest_vsprintf_test16
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vsprintf/test17/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vsprintf/test17/CMakeLists.txt
index 4e220dab77..edc5b334d1 100644
--- a/src/pal/tests/palsuite/c_runtime/vsprintf/test17/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vsprintf/test17/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsprintf_test17
 add_dependencies(paltest_vsprintf_test17 coreclrpal)
 
 target_link_libraries(paltest_vsprintf_test17
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vsprintf/test18/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vsprintf/test18/CMakeLists.txt
index 4dd68c2987..c9f20d5d52 100644
--- a/src/pal/tests/palsuite/c_runtime/vsprintf/test18/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vsprintf/test18/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsprintf_test18
 add_dependencies(paltest_vsprintf_test18 coreclrpal)
 
 target_link_libraries(paltest_vsprintf_test18
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vsprintf/test19/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vsprintf/test19/CMakeLists.txt
index 3156a59a15..886f867de0 100644
--- a/src/pal/tests/palsuite/c_runtime/vsprintf/test19/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vsprintf/test19/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsprintf_test19
 add_dependencies(paltest_vsprintf_test19 coreclrpal)
 
 target_link_libraries(paltest_vsprintf_test19
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vsprintf/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vsprintf/test2/CMakeLists.txt
index 210224f0f1..c9fca91c19 100644
--- a/src/pal/tests/palsuite/c_runtime/vsprintf/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vsprintf/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsprintf_test2
 add_dependencies(paltest_vsprintf_test2 coreclrpal)
 
 target_link_libraries(paltest_vsprintf_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vsprintf/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vsprintf/test3/CMakeLists.txt
index 5581051f9f..7e45989685 100644
--- a/src/pal/tests/palsuite/c_runtime/vsprintf/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vsprintf/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsprintf_test3
 add_dependencies(paltest_vsprintf_test3 coreclrpal)
 
 target_link_libraries(paltest_vsprintf_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vsprintf/test4/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vsprintf/test4/CMakeLists.txt
index 88817fcffb..9571f586c3 100644
--- a/src/pal/tests/palsuite/c_runtime/vsprintf/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vsprintf/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsprintf_test4
 add_dependencies(paltest_vsprintf_test4 coreclrpal)
 
 target_link_libraries(paltest_vsprintf_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vsprintf/test6/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vsprintf/test6/CMakeLists.txt
index 606fe3b965..7dc7e1d621 100644
--- a/src/pal/tests/palsuite/c_runtime/vsprintf/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vsprintf/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsprintf_test6
 add_dependencies(paltest_vsprintf_test6 coreclrpal)
 
 target_link_libraries(paltest_vsprintf_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vsprintf/test7/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vsprintf/test7/CMakeLists.txt
index 2dee276968..7b05fbeb51 100644
--- a/src/pal/tests/palsuite/c_runtime/vsprintf/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vsprintf/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsprintf_test7
 add_dependencies(paltest_vsprintf_test7 coreclrpal)
 
 target_link_libraries(paltest_vsprintf_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vsprintf/test8/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vsprintf/test8/CMakeLists.txt
index 8dac76fc3a..36231aa954 100644
--- a/src/pal/tests/palsuite/c_runtime/vsprintf/test8/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vsprintf/test8/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsprintf_test8
 add_dependencies(paltest_vsprintf_test8 coreclrpal)
 
 target_link_libraries(paltest_vsprintf_test8
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vsprintf/test9/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vsprintf/test9/CMakeLists.txt
index 95f0faad87..ca74546b0e 100644
--- a/src/pal/tests/palsuite/c_runtime/vsprintf/test9/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vsprintf/test9/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vsprintf_test9
 add_dependencies(paltest_vsprintf_test9 coreclrpal)
 
 target_link_libraries(paltest_vsprintf_test9
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vswprintf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vswprintf/test1/CMakeLists.txt
index 1d6233744a..6b23e50345 100644
--- a/src/pal/tests/palsuite/c_runtime/vswprintf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vswprintf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vswprintf_test1
 add_dependencies(paltest_vswprintf_test1 coreclrpal)
 
 target_link_libraries(paltest_vswprintf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vswprintf/test10/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vswprintf/test10/CMakeLists.txt
index e5301427eb..4e6171ec61 100644
--- a/src/pal/tests/palsuite/c_runtime/vswprintf/test10/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vswprintf/test10/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vswprintf_test10
 add_dependencies(paltest_vswprintf_test10 coreclrpal)
 
 target_link_libraries(paltest_vswprintf_test10
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vswprintf/test11/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vswprintf/test11/CMakeLists.txt
index 1cfadb9300..9e37b63b1f 100644
--- a/src/pal/tests/palsuite/c_runtime/vswprintf/test11/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vswprintf/test11/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vswprintf_test11
 add_dependencies(paltest_vswprintf_test11 coreclrpal)
 
 target_link_libraries(paltest_vswprintf_test11
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vswprintf/test12/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vswprintf/test12/CMakeLists.txt
index f5a582a970..2747ebf468 100644
--- a/src/pal/tests/palsuite/c_runtime/vswprintf/test12/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vswprintf/test12/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vswprintf_test12
 add_dependencies(paltest_vswprintf_test12 coreclrpal)
 
 target_link_libraries(paltest_vswprintf_test12
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vswprintf/test13/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vswprintf/test13/CMakeLists.txt
index 5571d7336f..4c96d3fecc 100644
--- a/src/pal/tests/palsuite/c_runtime/vswprintf/test13/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vswprintf/test13/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vswprintf_test13
 add_dependencies(paltest_vswprintf_test13 coreclrpal)
 
 target_link_libraries(paltest_vswprintf_test13
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vswprintf/test14/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vswprintf/test14/CMakeLists.txt
index 234029ead4..62a9efc660 100644
--- a/src/pal/tests/palsuite/c_runtime/vswprintf/test14/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vswprintf/test14/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vswprintf_test14
 add_dependencies(paltest_vswprintf_test14 coreclrpal)
 
 target_link_libraries(paltest_vswprintf_test14
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vswprintf/test15/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vswprintf/test15/CMakeLists.txt
index b705268bc7..2142c53044 100644
--- a/src/pal/tests/palsuite/c_runtime/vswprintf/test15/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vswprintf/test15/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vswprintf_test15
 add_dependencies(paltest_vswprintf_test15 coreclrpal)
 
 target_link_libraries(paltest_vswprintf_test15
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vswprintf/test16/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vswprintf/test16/CMakeLists.txt
index da296bcf32..44fd1145b9 100644
--- a/src/pal/tests/palsuite/c_runtime/vswprintf/test16/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vswprintf/test16/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vswprintf_test16
 add_dependencies(paltest_vswprintf_test16 coreclrpal)
 
 target_link_libraries(paltest_vswprintf_test16
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vswprintf/test17/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vswprintf/test17/CMakeLists.txt
index 02234c1672..2d1d8cd85e 100644
--- a/src/pal/tests/palsuite/c_runtime/vswprintf/test17/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vswprintf/test17/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vswprintf_test17
 add_dependencies(paltest_vswprintf_test17 coreclrpal)
 
 target_link_libraries(paltest_vswprintf_test17
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vswprintf/test18/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vswprintf/test18/CMakeLists.txt
index 0c0e5b566b..d561baef83 100644
--- a/src/pal/tests/palsuite/c_runtime/vswprintf/test18/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vswprintf/test18/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vswprintf_test18
 add_dependencies(paltest_vswprintf_test18 coreclrpal)
 
 target_link_libraries(paltest_vswprintf_test18
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vswprintf/test19/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vswprintf/test19/CMakeLists.txt
index 066db8ab84..e2e6001cce 100644
--- a/src/pal/tests/palsuite/c_runtime/vswprintf/test19/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vswprintf/test19/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vswprintf_test19
 add_dependencies(paltest_vswprintf_test19 coreclrpal)
 
 target_link_libraries(paltest_vswprintf_test19
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vswprintf/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vswprintf/test2/CMakeLists.txt
index abfceca9e2..b1dee38b4a 100644
--- a/src/pal/tests/palsuite/c_runtime/vswprintf/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vswprintf/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vswprintf_test2
 add_dependencies(paltest_vswprintf_test2 coreclrpal)
 
 target_link_libraries(paltest_vswprintf_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vswprintf/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vswprintf/test3/CMakeLists.txt
index 7f4798dbc5..4d49a107b8 100644
--- a/src/pal/tests/palsuite/c_runtime/vswprintf/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vswprintf/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vswprintf_test3
 add_dependencies(paltest_vswprintf_test3 coreclrpal)
 
 target_link_libraries(paltest_vswprintf_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vswprintf/test4/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vswprintf/test4/CMakeLists.txt
index 05701ac179..d38b9cd824 100644
--- a/src/pal/tests/palsuite/c_runtime/vswprintf/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vswprintf/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vswprintf_test4
 add_dependencies(paltest_vswprintf_test4 coreclrpal)
 
 target_link_libraries(paltest_vswprintf_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vswprintf/test6/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vswprintf/test6/CMakeLists.txt
index bfbb17ccef..0caa96ed78 100644
--- a/src/pal/tests/palsuite/c_runtime/vswprintf/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vswprintf/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vswprintf_test6
 add_dependencies(paltest_vswprintf_test6 coreclrpal)
 
 target_link_libraries(paltest_vswprintf_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vswprintf/test7/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vswprintf/test7/CMakeLists.txt
index 8b980586bc..3244576813 100644
--- a/src/pal/tests/palsuite/c_runtime/vswprintf/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vswprintf/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vswprintf_test7
 add_dependencies(paltest_vswprintf_test7 coreclrpal)
 
 target_link_libraries(paltest_vswprintf_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vswprintf/test8/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vswprintf/test8/CMakeLists.txt
index 07ba473844..f972c00067 100644
--- a/src/pal/tests/palsuite/c_runtime/vswprintf/test8/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vswprintf/test8/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vswprintf_test8
 add_dependencies(paltest_vswprintf_test8 coreclrpal)
 
 target_link_libraries(paltest_vswprintf_test8
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/vswprintf/test9/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/vswprintf/test9/CMakeLists.txt
index 11c77787e9..ee9c04d7ee 100644
--- a/src/pal/tests/palsuite/c_runtime/vswprintf/test9/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/vswprintf/test9/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_vswprintf_test9
 add_dependencies(paltest_vswprintf_test9 coreclrpal)
 
 target_link_libraries(paltest_vswprintf_test9
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcscat/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcscat/test1/CMakeLists.txt
index 815c585de4..8ee3b694b2 100644
--- a/src/pal/tests/palsuite/c_runtime/wcscat/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcscat/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcscat_test1
 add_dependencies(paltest_wcscat_test1 coreclrpal)
 
 target_link_libraries(paltest_wcscat_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcschr/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcschr/test1/CMakeLists.txt
index 9cf0a918a0..f054ae7956 100644
--- a/src/pal/tests/palsuite/c_runtime/wcschr/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcschr/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcschr_test1
 add_dependencies(paltest_wcschr_test1 coreclrpal)
 
 target_link_libraries(paltest_wcschr_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcscmp/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcscmp/test1/CMakeLists.txt
index 98c05352f3..8f97a6386b 100644
--- a/src/pal/tests/palsuite/c_runtime/wcscmp/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcscmp/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcscmp_test1
 add_dependencies(paltest_wcscmp_test1 coreclrpal)
 
 target_link_libraries(paltest_wcscmp_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcscpy/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcscpy/test1/CMakeLists.txt
index 872b2dec5e..c7fdcb8372 100644
--- a/src/pal/tests/palsuite/c_runtime/wcscpy/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcscpy/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcscpy_test1
 add_dependencies(paltest_wcscpy_test1 coreclrpal)
 
 target_link_libraries(paltest_wcscpy_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcslen/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcslen/test1/CMakeLists.txt
index b641a830f5..e68496d34a 100644
--- a/src/pal/tests/palsuite/c_runtime/wcslen/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcslen/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcslen_test1
 add_dependencies(paltest_wcslen_test1 coreclrpal)
 
 target_link_libraries(paltest_wcslen_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcsncat/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcsncat/test1/CMakeLists.txt
index e90e2b7bc4..8eba7a7c86 100644
--- a/src/pal/tests/palsuite/c_runtime/wcsncat/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcsncat/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcsncat_test1
 add_dependencies(paltest_wcsncat_test1 coreclrpal)
 
 target_link_libraries(paltest_wcsncat_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcsncmp/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcsncmp/test1/CMakeLists.txt
index f5511a86c6..4fc8155853 100644
--- a/src/pal/tests/palsuite/c_runtime/wcsncmp/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcsncmp/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcsncmp_test1
 add_dependencies(paltest_wcsncmp_test1 coreclrpal)
 
 target_link_libraries(paltest_wcsncmp_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcsncpy/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcsncpy/test1/CMakeLists.txt
index a7254a709c..d157bf29e9 100644
--- a/src/pal/tests/palsuite/c_runtime/wcsncpy/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcsncpy/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcsncpy_test1
 add_dependencies(paltest_wcsncpy_test1 coreclrpal)
 
 target_link_libraries(paltest_wcsncpy_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcspbrk/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcspbrk/test1/CMakeLists.txt
index 14c1fe83a4..2a9434442b 100644
--- a/src/pal/tests/palsuite/c_runtime/wcspbrk/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcspbrk/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcspbrk_test1
 add_dependencies(paltest_wcspbrk_test1 coreclrpal)
 
 target_link_libraries(paltest_wcspbrk_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcsrchr/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcsrchr/test1/CMakeLists.txt
index abdd6d56d2..3d808e1e71 100644
--- a/src/pal/tests/palsuite/c_runtime/wcsrchr/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcsrchr/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcsrchr_test1
 add_dependencies(paltest_wcsrchr_test1 coreclrpal)
 
 target_link_libraries(paltest_wcsrchr_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcsstr/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcsstr/test1/CMakeLists.txt
index 0e1e0b47b0..bc09f75983 100644
--- a/src/pal/tests/palsuite/c_runtime/wcsstr/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcsstr/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcsstr_test1
 add_dependencies(paltest_wcsstr_test1 coreclrpal)
 
 target_link_libraries(paltest_wcsstr_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcstod/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcstod/test1/CMakeLists.txt
index cca01ca964..2370ee8aad 100644
--- a/src/pal/tests/palsuite/c_runtime/wcstod/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcstod/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcstod_test1
 add_dependencies(paltest_wcstod_test1 coreclrpal)
 
 target_link_libraries(paltest_wcstod_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcstod/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcstod/test2/CMakeLists.txt
index ae7450891e..1251c2c9c0 100644
--- a/src/pal/tests/palsuite/c_runtime/wcstod/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcstod/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcstod_test2
 add_dependencies(paltest_wcstod_test2 coreclrpal)
 
 target_link_libraries(paltest_wcstod_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcstok/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcstok/test1/CMakeLists.txt
index 6b5bed9552..0f63a7bf6d 100644
--- a/src/pal/tests/palsuite/c_runtime/wcstok/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcstok/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcstok_test1
 add_dependencies(paltest_wcstok_test1 coreclrpal)
 
 target_link_libraries(paltest_wcstok_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcstol/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcstol/test1/CMakeLists.txt
index f76018fca3..fc81ee402a 100644
--- a/src/pal/tests/palsuite/c_runtime/wcstol/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcstol/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcstol_test1
 add_dependencies(paltest_wcstol_test1 coreclrpal)
 
 target_link_libraries(paltest_wcstol_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcstol/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcstol/test2/CMakeLists.txt
index 8dc2ab6b65..4f7ad53723 100644
--- a/src/pal/tests/palsuite/c_runtime/wcstol/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcstol/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcstol_test2
 add_dependencies(paltest_wcstol_test2 coreclrpal)
 
 target_link_libraries(paltest_wcstol_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcstol/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcstol/test3/CMakeLists.txt
index 310f97d6dc..df2d5ef607 100644
--- a/src/pal/tests/palsuite/c_runtime/wcstol/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcstol/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcstol_test3
 add_dependencies(paltest_wcstol_test3 coreclrpal)
 
 target_link_libraries(paltest_wcstol_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcstol/test4/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcstol/test4/CMakeLists.txt
index 23928aa704..9af9af8be0 100644
--- a/src/pal/tests/palsuite/c_runtime/wcstol/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcstol/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcstol_test4
 add_dependencies(paltest_wcstol_test4 coreclrpal)
 
 target_link_libraries(paltest_wcstol_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcstol/test5/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcstol/test5/CMakeLists.txt
index 16c709ffa0..6134216d5b 100644
--- a/src/pal/tests/palsuite/c_runtime/wcstol/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcstol/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcstol_test5
 add_dependencies(paltest_wcstol_test5 coreclrpal)
 
 target_link_libraries(paltest_wcstol_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcstol/test6/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcstol/test6/CMakeLists.txt
index 80ccaf609b..ae7efe8d42 100644
--- a/src/pal/tests/palsuite/c_runtime/wcstol/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcstol/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcstol_test6
 add_dependencies(paltest_wcstol_test6 coreclrpal)
 
 target_link_libraries(paltest_wcstol_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcstoul/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcstoul/test1/CMakeLists.txt
index 58f002ab32..bcdcd7cc7a 100644
--- a/src/pal/tests/palsuite/c_runtime/wcstoul/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcstoul/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcstoul_test1
 add_dependencies(paltest_wcstoul_test1 coreclrpal)
 
 target_link_libraries(paltest_wcstoul_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcstoul/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcstoul/test2/CMakeLists.txt
index 2c8d012310..4259cef224 100644
--- a/src/pal/tests/palsuite/c_runtime/wcstoul/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcstoul/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcstoul_test2
 add_dependencies(paltest_wcstoul_test2 coreclrpal)
 
 target_link_libraries(paltest_wcstoul_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcstoul/test3/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcstoul/test3/CMakeLists.txt
index 353df07f52..758c437260 100644
--- a/src/pal/tests/palsuite/c_runtime/wcstoul/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcstoul/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcstoul_test3
 add_dependencies(paltest_wcstoul_test3 coreclrpal)
 
 target_link_libraries(paltest_wcstoul_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcstoul/test4/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcstoul/test4/CMakeLists.txt
index e1e7d55420..151d372d14 100644
--- a/src/pal/tests/palsuite/c_runtime/wcstoul/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcstoul/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcstoul_test4
 add_dependencies(paltest_wcstoul_test4 coreclrpal)
 
 target_link_libraries(paltest_wcstoul_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcstoul/test5/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcstoul/test5/CMakeLists.txt
index 9e83c6074c..97b1e91e61 100644
--- a/src/pal/tests/palsuite/c_runtime/wcstoul/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcstoul/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcstoul_test5
 add_dependencies(paltest_wcstoul_test5 coreclrpal)
 
 target_link_libraries(paltest_wcstoul_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wcstoul/test6/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wcstoul/test6/CMakeLists.txt
index 8352d0cbbe..b678e2ae0c 100644
--- a/src/pal/tests/palsuite/c_runtime/wcstoul/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wcstoul/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wcstoul_test6
 add_dependencies(paltest_wcstoul_test6 coreclrpal)
 
 target_link_libraries(paltest_wcstoul_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wprintf/test1/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wprintf/test1/CMakeLists.txt
index f95fc12ea1..8d3ab28cac 100644
--- a/src/pal/tests/palsuite/c_runtime/wprintf/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wprintf/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wprintf_test1
 add_dependencies(paltest_wprintf_test1 coreclrpal)
 
 target_link_libraries(paltest_wprintf_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/c_runtime/wprintf/test2/CMakeLists.txt b/src/pal/tests/palsuite/c_runtime/wprintf/test2/CMakeLists.txt
index 325e8046d5..3119489709 100644
--- a/src/pal/tests/palsuite/c_runtime/wprintf/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/c_runtime/wprintf/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_wprintf_test2
 add_dependencies(paltest_wprintf_test2 coreclrpal)
 
 target_link_libraries(paltest_wprintf_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/composite/object_management/event/nonshared/CMakeLists.txt b/src/pal/tests/palsuite/composite/object_management/event/nonshared/CMakeLists.txt
index b336c03d37..276d9a47ce 100644
--- a/src/pal/tests/palsuite/composite/object_management/event/nonshared/CMakeLists.txt
+++ b/src/pal/tests/palsuite/composite/object_management/event/nonshared/CMakeLists.txt
@@ -14,8 +14,6 @@ add_executable(paltest_event_nonshared
 add_dependencies(paltest_event_nonshared coreclrpal)
 
 target_link_libraries(paltest_event_nonshared
-  pthread
+  ${COMMON_TEST_LIBRARIES}
   rt
-  m
-  coreclrpal
 )
diff --git a/src/pal/tests/palsuite/composite/object_management/event/shared/CMakeLists.txt b/src/pal/tests/palsuite/composite/object_management/event/shared/CMakeLists.txt
index 86188796bd..92ad5b0c1b 100644
--- a/src/pal/tests/palsuite/composite/object_management/event/shared/CMakeLists.txt
+++ b/src/pal/tests/palsuite/composite/object_management/event/shared/CMakeLists.txt
@@ -14,8 +14,6 @@ add_executable(paltest_event_shared
 add_dependencies(paltest_event_shared coreclrpal)
 
 target_link_libraries(paltest_event_shared
-  pthread
+  ${COMMON_TEST_LIBRARIES}
   rt
-  m
-  coreclrpal
 )
diff --git a/src/pal/tests/palsuite/composite/object_management/mutex/nonshared/CMakeLists.txt b/src/pal/tests/palsuite/composite/object_management/mutex/nonshared/CMakeLists.txt
index 03d5efac27..8ddce815dc 100644
--- a/src/pal/tests/palsuite/composite/object_management/mutex/nonshared/CMakeLists.txt
+++ b/src/pal/tests/palsuite/composite/object_management/mutex/nonshared/CMakeLists.txt
@@ -14,8 +14,6 @@ add_executable(paltest_mutex_nonshared
 add_dependencies(paltest_mutex_nonshared coreclrpal)
 
 target_link_libraries(paltest_mutex_nonshared
-  pthread
+  ${COMMON_TEST_LIBRARIES}
   rt
-  m
-  coreclrpal
 )
diff --git a/src/pal/tests/palsuite/composite/object_management/mutex/shared/CMakeLists.txt b/src/pal/tests/palsuite/composite/object_management/mutex/shared/CMakeLists.txt
index d4b50cd66e..0436f263fd 100644
--- a/src/pal/tests/palsuite/composite/object_management/mutex/shared/CMakeLists.txt
+++ b/src/pal/tests/palsuite/composite/object_management/mutex/shared/CMakeLists.txt
@@ -14,8 +14,6 @@ add_executable(paltest_mutex_shared
 add_dependencies(paltest_mutex_shared coreclrpal)
 
 target_link_libraries(paltest_mutex_shared
-  pthread
+  ${COMMON_TEST_LIBRARIES}
   rt
-  m
-  coreclrpal
 )
diff --git a/src/pal/tests/palsuite/composite/object_management/semaphore/nonshared/CMakeLists.txt b/src/pal/tests/palsuite/composite/object_management/semaphore/nonshared/CMakeLists.txt
index 9ed4535d39..f17c6737bc 100644
--- a/src/pal/tests/palsuite/composite/object_management/semaphore/nonshared/CMakeLists.txt
+++ b/src/pal/tests/palsuite/composite/object_management/semaphore/nonshared/CMakeLists.txt
@@ -14,8 +14,6 @@ add_executable(paltest_semaphore_nonshared
 add_dependencies(paltest_semaphore_nonshared coreclrpal)
 
 target_link_libraries(paltest_semaphore_nonshared
-  pthread
+  ${COMMON_TEST_LIBRARIES}
   rt
-  m
-  coreclrpal
 )
diff --git a/src/pal/tests/palsuite/composite/object_management/semaphore/shared/CMakeLists.txt b/src/pal/tests/palsuite/composite/object_management/semaphore/shared/CMakeLists.txt
index 5c7f93290f..24327bea4c 100644
--- a/src/pal/tests/palsuite/composite/object_management/semaphore/shared/CMakeLists.txt
+++ b/src/pal/tests/palsuite/composite/object_management/semaphore/shared/CMakeLists.txt
@@ -14,8 +14,6 @@ add_executable(paltest_semaphore_shared
 add_dependencies(paltest_semaphore_shared coreclrpal)
 
 target_link_libraries(paltest_semaphore_shared
-  pthread
+  ${COMMON_TEST_LIBRARIES}
   rt
-  m
-  coreclrpal
 )
diff --git a/src/pal/tests/palsuite/composite/synchronization/criticalsection/CMakeLists.txt b/src/pal/tests/palsuite/composite/synchronization/criticalsection/CMakeLists.txt
index fc357ed258..e6b6b0c805 100644
--- a/src/pal/tests/palsuite/composite/synchronization/criticalsection/CMakeLists.txt
+++ b/src/pal/tests/palsuite/composite/synchronization/criticalsection/CMakeLists.txt
@@ -14,7 +14,5 @@ add_executable(paltest_synchronization_criticalsection
 add_dependencies(paltest_synchronization_criticalsection coreclrpal)
 
 target_link_libraries(paltest_synchronization_criticalsection
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/composite/synchronization/nativecriticalsection/CMakeLists.txt b/src/pal/tests/palsuite/composite/synchronization/nativecriticalsection/CMakeLists.txt
index 9a02993916..5a2a503137 100644
--- a/src/pal/tests/palsuite/composite/synchronization/nativecriticalsection/CMakeLists.txt
+++ b/src/pal/tests/palsuite/composite/synchronization/nativecriticalsection/CMakeLists.txt
@@ -15,7 +15,5 @@ add_executable(paltest_synchronization_nativecriticalsection
 add_dependencies(paltest_synchronization_nativecriticalsection coreclrpal)
 
 target_link_libraries(paltest_synchronization_nativecriticalsection
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/composite/synchronization/nativecs_interlocked/CMakeLists.txt b/src/pal/tests/palsuite/composite/synchronization/nativecs_interlocked/CMakeLists.txt
index 717bdd6b20..b942096363 100644
--- a/src/pal/tests/palsuite/composite/synchronization/nativecs_interlocked/CMakeLists.txt
+++ b/src/pal/tests/palsuite/composite/synchronization/nativecs_interlocked/CMakeLists.txt
@@ -16,7 +16,5 @@ add_executable(paltest_synchronization_nativecs_interlocked
 add_dependencies(paltest_synchronization_nativecs_interlocked coreclrpal)
 
 target_link_libraries(paltest_synchronization_nativecs_interlocked
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/composite/threading/threadsuspension/CMakeLists.txt b/src/pal/tests/palsuite/composite/threading/threadsuspension/CMakeLists.txt
index d396d2fc49..a01fbd6552 100644
--- a/src/pal/tests/palsuite/composite/threading/threadsuspension/CMakeLists.txt
+++ b/src/pal/tests/palsuite/composite/threading/threadsuspension/CMakeLists.txt
@@ -14,7 +14,5 @@ add_executable(paltest_threading_threadsuspension
 add_dependencies(paltest_threading_threadsuspension coreclrpal)
 
 target_link_libraries(paltest_threading_threadsuspension
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/composite/threading/threadsuspension_switchthread/CMakeLists.txt b/src/pal/tests/palsuite/composite/threading/threadsuspension_switchthread/CMakeLists.txt
index 2c880921fe..c3fb807148 100644
--- a/src/pal/tests/palsuite/composite/threading/threadsuspension_switchthread/CMakeLists.txt
+++ b/src/pal/tests/palsuite/composite/threading/threadsuspension_switchthread/CMakeLists.txt
@@ -14,7 +14,5 @@ add_executable(paltest_threading_threadsuspension_switchthread
 add_dependencies(paltest_threading_threadsuspension_switchthread coreclrpal)
 
 target_link_libraries(paltest_threading_threadsuspension_switchthread
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/composite/wfmo/CMakeLists.txt b/src/pal/tests/palsuite/composite/wfmo/CMakeLists.txt
index 5e103102af..3f497d76c2 100644
--- a/src/pal/tests/palsuite/composite/wfmo/CMakeLists.txt
+++ b/src/pal/tests/palsuite/composite/wfmo/CMakeLists.txt
@@ -14,8 +14,6 @@ add_executable(paltest_composite_wfmo
 add_dependencies(paltest_composite_wfmo coreclrpal)
 
 target_link_libraries(paltest_composite_wfmo
-  pthread
+  ${COMMON_TEST_LIBRARIES}
   rt
-  m
-  coreclrpal
 )
diff --git a/src/pal/tests/palsuite/debug_api/DebugBreak/test1/CMakeLists.txt b/src/pal/tests/palsuite/debug_api/DebugBreak/test1/CMakeLists.txt
index 1b2ae538cc..5eba74f9f0 100644
--- a/src/pal/tests/palsuite/debug_api/DebugBreak/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/debug_api/DebugBreak/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_debugbreak_test1
 add_dependencies(paltest_debugbreak_test1 coreclrpal)
 
 target_link_libraries(paltest_debugbreak_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/debug_api/OutputDebugStringA/test1/CMakeLists.txt b/src/pal/tests/palsuite/debug_api/OutputDebugStringA/test1/CMakeLists.txt
index 3000734afe..46a870c111 100644
--- a/src/pal/tests/palsuite/debug_api/OutputDebugStringA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/debug_api/OutputDebugStringA/test1/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_outputdebugstringa_test1
 add_dependencies(paltest_outputdebugstringa_test1 coreclrpal)
 
 target_link_libraries(paltest_outputdebugstringa_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,9 +28,7 @@ add_executable(paltest_outputdebugstringa_test1_helper
 add_dependencies(paltest_outputdebugstringa_test1_helper coreclrpal)
 
 target_link_libraries(paltest_outputdebugstringa_test1_helper
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
diff --git a/src/pal/tests/palsuite/debug_api/OutputDebugStringW/test1/CMakeLists.txt b/src/pal/tests/palsuite/debug_api/OutputDebugStringW/test1/CMakeLists.txt
index 4a93f0e394..802de0ee9a 100644
--- a/src/pal/tests/palsuite/debug_api/OutputDebugStringW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/debug_api/OutputDebugStringW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_outputdebugstringw_test1
 add_dependencies(paltest_outputdebugstringw_test1 coreclrpal)
 
 target_link_libraries(paltest_outputdebugstringw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/debug_api/WriteProcessMemory/test1/CMakeLists.txt b/src/pal/tests/palsuite/debug_api/WriteProcessMemory/test1/CMakeLists.txt
index afd581fb92..af19587ffa 100644
--- a/src/pal/tests/palsuite/debug_api/WriteProcessMemory/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/debug_api/WriteProcessMemory/test1/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_writeprocessmemory_test1
 add_dependencies(paltest_writeprocessmemory_test1 coreclrpal)
 
 target_link_libraries(paltest_writeprocessmemory_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_writeprocessmemory_test1_helper
 add_dependencies(paltest_writeprocessmemory_test1_helper coreclrpal)
 
 target_link_libraries(paltest_writeprocessmemory_test1_helper
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/debug_api/WriteProcessMemory/test3/CMakeLists.txt b/src/pal/tests/palsuite/debug_api/WriteProcessMemory/test3/CMakeLists.txt
index 3a5067c926..d6e11a683a 100644
--- a/src/pal/tests/palsuite/debug_api/WriteProcessMemory/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/debug_api/WriteProcessMemory/test3/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_writeprocessmemory_test3
 add_dependencies(paltest_writeprocessmemory_test3 coreclrpal)
 
 target_link_libraries(paltest_writeprocessmemory_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_writeprocessmemory_test3_helper
 add_dependencies(paltest_writeprocessmemory_test3_helper coreclrpal)
 
 target_link_libraries(paltest_writeprocessmemory_test3_helper
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/debug_api/WriteProcessMemory/test4/CMakeLists.txt b/src/pal/tests/palsuite/debug_api/WriteProcessMemory/test4/CMakeLists.txt
index 7cba09038a..9eec2bd78d 100644
--- a/src/pal/tests/palsuite/debug_api/WriteProcessMemory/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/debug_api/WriteProcessMemory/test4/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_writeprocessmemory_test4
 add_dependencies(paltest_writeprocessmemory_test4 coreclrpal)
 
 target_link_libraries(paltest_writeprocessmemory_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_writeprocessmemory_test4_helper
 add_dependencies(paltest_writeprocessmemory_test4_helper coreclrpal)
 
 target_link_libraries(paltest_writeprocessmemory_test4_helper
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER/test1/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER/test1/CMakeLists.txt
index 4e30869d85..336eafd718 100644
--- a/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_except_filter_test1
 add_dependencies(paltest_pal_except_filter_test1 coreclrpal)
 
 target_link_libraries(paltest_pal_except_filter_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER/test2/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER/test2/CMakeLists.txt
index 3f979c08db..e9c57b44c3 100644
--- a/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_except_filter_test2
 add_dependencies(paltest_pal_except_filter_test2 coreclrpal)
 
 target_link_libraries(paltest_pal_except_filter_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER/test3/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER/test3/CMakeLists.txt
index 2bdf44e058..45286ac198 100644
--- a/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_except_filter_test3
 add_dependencies(paltest_pal_except_filter_test3 coreclrpal)
 
 target_link_libraries(paltest_pal_except_filter_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER_EX/test1/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER_EX/test1/CMakeLists.txt
index cf0a5e7c6d..be9ab1aa61 100644
--- a/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER_EX/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER_EX/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_except_filter_ex_test1
 add_dependencies(paltest_pal_except_filter_ex_test1 coreclrpal)
 
 target_link_libraries(paltest_pal_except_filter_ex_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER_EX/test2/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER_EX/test2/CMakeLists.txt
index a3f82c26b9..4d90c711cd 100644
--- a/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER_EX/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER_EX/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_except_filter_ex_test2
 add_dependencies(paltest_pal_except_filter_ex_test2 coreclrpal)
 
 target_link_libraries(paltest_pal_except_filter_ex_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER_EX/test3/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER_EX/test3/CMakeLists.txt
index 532b29a9a1..6a52145151 100644
--- a/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER_EX/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/PAL_EXCEPT_FILTER_EX/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_except_filter_ex_test3
 add_dependencies(paltest_pal_except_filter_ex_test3 coreclrpal)
 
 target_link_libraries(paltest_pal_except_filter_ex_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/PAL_TRY_EXCEPT/test1/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/PAL_TRY_EXCEPT/test1/CMakeLists.txt
index b478de63e4..ad208751fc 100644
--- a/src/pal/tests/palsuite/exception_handling/PAL_TRY_EXCEPT/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/PAL_TRY_EXCEPT/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_try_except_test1
 add_dependencies(paltest_pal_try_except_test1 coreclrpal)
 
 target_link_libraries(paltest_pal_try_except_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/PAL_TRY_EXCEPT/test2/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/PAL_TRY_EXCEPT/test2/CMakeLists.txt
index 0e344a9320..da34fb23fa 100644
--- a/src/pal/tests/palsuite/exception_handling/PAL_TRY_EXCEPT/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/PAL_TRY_EXCEPT/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_try_except_test2
 add_dependencies(paltest_pal_try_except_test2 coreclrpal)
 
 target_link_libraries(paltest_pal_try_except_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/PAL_TRY_EXCEPT_EX/test1/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/PAL_TRY_EXCEPT_EX/test1/CMakeLists.txt
index cced8a11be..2ab8a25675 100644
--- a/src/pal/tests/palsuite/exception_handling/PAL_TRY_EXCEPT_EX/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/PAL_TRY_EXCEPT_EX/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_try_except_ex_test1
 add_dependencies(paltest_pal_try_except_ex_test1 coreclrpal)
 
 target_link_libraries(paltest_pal_try_except_ex_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/PAL_TRY_EXCEPT_EX/test2/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/PAL_TRY_EXCEPT_EX/test2/CMakeLists.txt
index c3549b5d87..80d90dd9b1 100644
--- a/src/pal/tests/palsuite/exception_handling/PAL_TRY_EXCEPT_EX/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/PAL_TRY_EXCEPT_EX/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_try_except_ex_test2
 add_dependencies(paltest_pal_try_except_ex_test2 coreclrpal)
 
 target_link_libraries(paltest_pal_try_except_ex_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/PAL_TRY_EXCEPT_EX/test3/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/PAL_TRY_EXCEPT_EX/test3/CMakeLists.txt
index 34790da3d3..d9507b046b 100644
--- a/src/pal/tests/palsuite/exception_handling/PAL_TRY_EXCEPT_EX/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/PAL_TRY_EXCEPT_EX/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_try_except_ex_test3
 add_dependencies(paltest_pal_try_except_ex_test3 coreclrpal)
 
 target_link_libraries(paltest_pal_try_except_ex_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/PAL_TRY_LEAVE_FINALLY/test1/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/PAL_TRY_LEAVE_FINALLY/test1/CMakeLists.txt
index f004db1658..6b34c1d629 100644
--- a/src/pal/tests/palsuite/exception_handling/PAL_TRY_LEAVE_FINALLY/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/PAL_TRY_LEAVE_FINALLY/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_try_leave_finally_test1
 add_dependencies(paltest_pal_try_leave_finally_test1 coreclrpal)
 
 target_link_libraries(paltest_pal_try_leave_finally_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/RaiseException/test1/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/RaiseException/test1/CMakeLists.txt
index 2fba7dd9b3..dcc47db93f 100644
--- a/src/pal/tests/palsuite/exception_handling/RaiseException/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/RaiseException/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_raiseexception_test1
 add_dependencies(paltest_raiseexception_test1 coreclrpal)
 
 target_link_libraries(paltest_raiseexception_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/RaiseException/test2/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/RaiseException/test2/CMakeLists.txt
index 7fc9f5f12c..5c9ba2ceee 100644
--- a/src/pal/tests/palsuite/exception_handling/RaiseException/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/RaiseException/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_raiseexception_test2
 add_dependencies(paltest_raiseexception_test2 coreclrpal)
 
 target_link_libraries(paltest_raiseexception_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/RaiseException/test3/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/RaiseException/test3/CMakeLists.txt
index 72e5427b69..a16f832a4a 100644
--- a/src/pal/tests/palsuite/exception_handling/RaiseException/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/RaiseException/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_raiseexception_test3
 add_dependencies(paltest_raiseexception_test3 coreclrpal)
 
 target_link_libraries(paltest_raiseexception_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/SetUnhandledExceptionFilter/test1/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/SetUnhandledExceptionFilter/test1/CMakeLists.txt
index 068427303f..bff5e893e5 100644
--- a/src/pal/tests/palsuite/exception_handling/SetUnhandledExceptionFilter/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/SetUnhandledExceptionFilter/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setunhandledexceptionfilter_test1
 add_dependencies(paltest_setunhandledexceptionfilter_test1 coreclrpal)
 
 target_link_libraries(paltest_setunhandledexceptionfilter_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/pal_except/test1/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/pal_except/test1/CMakeLists.txt
index b219238ef4..a34f673304 100644
--- a/src/pal/tests/palsuite/exception_handling/pal_except/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/pal_except/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_except_test1
 add_dependencies(paltest_pal_except_test1 coreclrpal)
 
 target_link_libraries(paltest_pal_except_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/pal_except/test2/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/pal_except/test2/CMakeLists.txt
index 27a725353b..a40910eca5 100644
--- a/src/pal/tests/palsuite/exception_handling/pal_except/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/pal_except/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_except_test2
 add_dependencies(paltest_pal_except_test2 coreclrpal)
 
 target_link_libraries(paltest_pal_except_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/pal_except/test3/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/pal_except/test3/CMakeLists.txt
index 680341a782..6f9e100fb8 100644
--- a/src/pal/tests/palsuite/exception_handling/pal_except/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/pal_except/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_except_test3
 add_dependencies(paltest_pal_except_test3 coreclrpal)
 
 target_link_libraries(paltest_pal_except_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/pal_except/test4/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/pal_except/test4/CMakeLists.txt
index 98eb7bfb23..fb51d9890f 100644
--- a/src/pal/tests/palsuite/exception_handling/pal_except/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/pal_except/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_except_test4
 add_dependencies(paltest_pal_except_test4 coreclrpal)
 
 target_link_libraries(paltest_pal_except_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/pal_except/test5/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/pal_except/test5/CMakeLists.txt
index 9a39e32cce..4ec8c69957 100644
--- a/src/pal/tests/palsuite/exception_handling/pal_except/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/pal_except/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_except_test5
 add_dependencies(paltest_pal_except_test5 coreclrpal)
 
 target_link_libraries(paltest_pal_except_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/pal_except/test6/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/pal_except/test6/CMakeLists.txt
index d009128871..bc1742c178 100644
--- a/src/pal/tests/palsuite/exception_handling/pal_except/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/pal_except/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_except_test6
 add_dependencies(paltest_pal_except_test6 coreclrpal)
 
 target_link_libraries(paltest_pal_except_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/pal_except/test7/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/pal_except/test7/CMakeLists.txt
index 33fee62cc2..7cb6be8d94 100644
--- a/src/pal/tests/palsuite/exception_handling/pal_except/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/pal_except/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_except_test7
 add_dependencies(paltest_pal_except_test7 coreclrpal)
 
 target_link_libraries(paltest_pal_except_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/pal_finally/test1/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/pal_finally/test1/CMakeLists.txt
index 67cc6c0b92..fe1cbbe0b6 100644
--- a/src/pal/tests/palsuite/exception_handling/pal_finally/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/pal_finally/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_finally_test1
 add_dependencies(paltest_pal_finally_test1 coreclrpal)
 
 target_link_libraries(paltest_pal_finally_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/exception_handling/pal_sxs/test1/CMakeLists.txt b/src/pal/tests/palsuite/exception_handling/pal_sxs/test1/CMakeLists.txt
index b0458db998..4a3abc2d64 100644
--- a/src/pal/tests/palsuite/exception_handling/pal_sxs/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/exception_handling/pal_sxs/test1/CMakeLists.txt
@@ -43,7 +43,7 @@ add_dependencies(paltest_pal_sxs_test1_dll1
 )
 
 target_link_libraries(paltest_pal_sxs_test1_dll1
-    pthread
+    ${COMMON_TEST_LIBRARIES}
     m
     coreclrpal
 )
@@ -71,13 +71,10 @@ set_property(TARGET paltest_pal_sxs_test1_dll2 APPEND_STRING PROPERTY LINK_DEPEN
 
 add_dependencies(paltest_pal_sxs_test1_dll2
    dlltest2_exports
-   coreclrpal
 )
 
 target_link_libraries(paltest_pal_sxs_test1_dll2
-   pthread
-   m
-   coreclrpal
+   ${COMMON_TEST_LIBRARIES}
 )
 
 # Main program
diff --git a/src/pal/tests/palsuite/file_io/AreFileApisANSI/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/AreFileApisANSI/test1/CMakeLists.txt
index e624bef462..ac76e5dc12 100644
--- a/src/pal/tests/palsuite/file_io/AreFileApisANSI/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/AreFileApisANSI/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_arefileapisansi_test1
 add_dependencies(paltest_arefileapisansi_test1 coreclrpal)
 
 target_link_libraries(paltest_arefileapisansi_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/CompareFileTime/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/CompareFileTime/test1/CMakeLists.txt
index fa96a44cdd..4883aee387 100644
--- a/src/pal/tests/palsuite/file_io/CompareFileTime/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/CompareFileTime/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_comparefiletime_test1
 add_dependencies(paltest_comparefiletime_test1 coreclrpal)
 
 target_link_libraries(paltest_comparefiletime_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/CopyFileA/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/CopyFileA/test1/CMakeLists.txt
index 13abbc0979..0890ebe2e7 100644
--- a/src/pal/tests/palsuite/file_io/CopyFileA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/CopyFileA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_copyfilea_test1
 add_dependencies(paltest_copyfilea_test1 coreclrpal)
 
 target_link_libraries(paltest_copyfilea_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/CopyFileA/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/CopyFileA/test2/CMakeLists.txt
index cd0d8bc6cf..8844af3f8f 100644
--- a/src/pal/tests/palsuite/file_io/CopyFileA/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/CopyFileA/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_copyfilea_test2
 add_dependencies(paltest_copyfilea_test2 coreclrpal)
 
 target_link_libraries(paltest_copyfilea_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/CopyFileA/test3/CMakeLists.txt b/src/pal/tests/palsuite/file_io/CopyFileA/test3/CMakeLists.txt
index 0bb41b8d8f..3fbdc3e187 100644
--- a/src/pal/tests/palsuite/file_io/CopyFileA/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/CopyFileA/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_copyfilea_test3
 add_dependencies(paltest_copyfilea_test3 coreclrpal)
 
 target_link_libraries(paltest_copyfilea_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/CopyFileA/test4/CMakeLists.txt b/src/pal/tests/palsuite/file_io/CopyFileA/test4/CMakeLists.txt
index 12f85d1747..0bb3a32770 100644
--- a/src/pal/tests/palsuite/file_io/CopyFileA/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/CopyFileA/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_copyfilea_test4
 add_dependencies(paltest_copyfilea_test4 coreclrpal)
 
 target_link_libraries(paltest_copyfilea_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/CopyFileW/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/CopyFileW/test1/CMakeLists.txt
index 20c8141d90..70ff478e35 100644
--- a/src/pal/tests/palsuite/file_io/CopyFileW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/CopyFileW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_copyfilew_test1
 add_dependencies(paltest_copyfilew_test1 coreclrpal)
 
 target_link_libraries(paltest_copyfilew_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/CopyFileW/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/CopyFileW/test2/CMakeLists.txt
index 4201bdca88..beebf1b86c 100644
--- a/src/pal/tests/palsuite/file_io/CopyFileW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/CopyFileW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_copyfilew_test2
 add_dependencies(paltest_copyfilew_test2 coreclrpal)
 
 target_link_libraries(paltest_copyfilew_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/CopyFileW/test3/CMakeLists.txt b/src/pal/tests/palsuite/file_io/CopyFileW/test3/CMakeLists.txt
index d0fd94c990..9e18a308e8 100644
--- a/src/pal/tests/palsuite/file_io/CopyFileW/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/CopyFileW/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_copyfilew_test3
 add_dependencies(paltest_copyfilew_test3 coreclrpal)
 
 target_link_libraries(paltest_copyfilew_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/CreateDirectoryA/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/CreateDirectoryA/test1/CMakeLists.txt
index 1dc87fa34b..57ac440265 100644
--- a/src/pal/tests/palsuite/file_io/CreateDirectoryA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/CreateDirectoryA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createdirectorya_test1
 add_dependencies(paltest_createdirectorya_test1 coreclrpal)
 
 target_link_libraries(paltest_createdirectorya_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/CreateDirectoryA/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/CreateDirectoryA/test2/CMakeLists.txt
index 3ee8abbcc2..b764145856 100644
--- a/src/pal/tests/palsuite/file_io/CreateDirectoryA/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/CreateDirectoryA/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createdirectorya_test2
 add_dependencies(paltest_createdirectorya_test2 coreclrpal)
 
 target_link_libraries(paltest_createdirectorya_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/CreateDirectoryW/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/CreateDirectoryW/test1/CMakeLists.txt
index f8cb584cc6..1fd09ea82d 100644
--- a/src/pal/tests/palsuite/file_io/CreateDirectoryW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/CreateDirectoryW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createdirectoryw_test1
 add_dependencies(paltest_createdirectoryw_test1 coreclrpal)
 
 target_link_libraries(paltest_createdirectoryw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/CreateDirectoryW/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/CreateDirectoryW/test2/CMakeLists.txt
index f8614ca5a6..2dcfe6d49e 100644
--- a/src/pal/tests/palsuite/file_io/CreateDirectoryW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/CreateDirectoryW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createdirectoryw_test2
 add_dependencies(paltest_createdirectoryw_test2 coreclrpal)
 
 target_link_libraries(paltest_createdirectoryw_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/CreateFileA/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/CreateFileA/test1/CMakeLists.txt
index edacdbd621..dec8c30559 100644
--- a/src/pal/tests/palsuite/file_io/CreateFileA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/CreateFileA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createfilea_test1
 add_dependencies(paltest_createfilea_test1 coreclrpal)
 
 target_link_libraries(paltest_createfilea_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/CreateFileW/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/CreateFileW/test1/CMakeLists.txt
index 820e169a37..d437410a1b 100644
--- a/src/pal/tests/palsuite/file_io/CreateFileW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/CreateFileW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createfilew_test1
 add_dependencies(paltest_createfilew_test1 coreclrpal)
 
 target_link_libraries(paltest_createfilew_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/DeleteFileA/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/DeleteFileA/test1/CMakeLists.txt
index b979c206b2..a07a00076d 100644
--- a/src/pal/tests/palsuite/file_io/DeleteFileA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/DeleteFileA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_deletefilea_test1
 add_dependencies(paltest_deletefilea_test1 coreclrpal)
 
 target_link_libraries(paltest_deletefilea_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/DeleteFileW/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/DeleteFileW/test1/CMakeLists.txt
index eada6145b9..7aff64ccff 100644
--- a/src/pal/tests/palsuite/file_io/DeleteFileW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/DeleteFileW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_deletefilew_test1
 add_dependencies(paltest_deletefilew_test1 coreclrpal)
 
 target_link_libraries(paltest_deletefilew_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/FILECanonicalizePath/CMakeLists.txt b/src/pal/tests/palsuite/file_io/FILECanonicalizePath/CMakeLists.txt
index 7045983629..7c6629d243 100644
--- a/src/pal/tests/palsuite/file_io/FILECanonicalizePath/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/FILECanonicalizePath/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_filecanonicalizepath_test1
 add_dependencies(paltest_filecanonicalizepath_test1 coreclrpal)
 
 target_link_libraries(paltest_filecanonicalizepath_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/FileTimeToDosDateTime/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/FileTimeToDosDateTime/test1/CMakeLists.txt
index 6ec6a98b3f..9d5c678be3 100644
--- a/src/pal/tests/palsuite/file_io/FileTimeToDosDateTime/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/FileTimeToDosDateTime/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_filetimetodosdatetime_test1
 add_dependencies(paltest_filetimetodosdatetime_test1 coreclrpal)
 
 target_link_libraries(paltest_filetimetodosdatetime_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/FindClose/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/FindClose/test1/CMakeLists.txt
index d97c69e6ee..d5a92fa405 100644
--- a/src/pal/tests/palsuite/file_io/FindClose/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/FindClose/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_findclose_test1
 add_dependencies(paltest_findclose_test1 coreclrpal)
 
 target_link_libraries(paltest_findclose_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/FindFirstFileA/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/FindFirstFileA/test1/CMakeLists.txt
index aeac94d42f..c485edbbac 100644
--- a/src/pal/tests/palsuite/file_io/FindFirstFileA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/FindFirstFileA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_findfirstfilea_test1
 add_dependencies(paltest_findfirstfilea_test1 coreclrpal)
 
 target_link_libraries(paltest_findfirstfilea_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/FindFirstFileW/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/FindFirstFileW/test1/CMakeLists.txt
index 2a6ea2b7a4..191e42d5c3 100644
--- a/src/pal/tests/palsuite/file_io/FindFirstFileW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/FindFirstFileW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_findfirstfilew_test1
 add_dependencies(paltest_findfirstfilew_test1 coreclrpal)
 
 target_link_libraries(paltest_findfirstfilew_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/FindNextFileA/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/FindNextFileA/test1/CMakeLists.txt
index 6e97b7aaad..4dcaa99982 100644
--- a/src/pal/tests/palsuite/file_io/FindNextFileA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/FindNextFileA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_findnextfilea_test1
 add_dependencies(paltest_findnextfilea_test1 coreclrpal)
 
 target_link_libraries(paltest_findnextfilea_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/FindNextFileA/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/FindNextFileA/test2/CMakeLists.txt
index e037bd3aa0..d5871a400f 100644
--- a/src/pal/tests/palsuite/file_io/FindNextFileA/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/FindNextFileA/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_findnextfilea_test2
 add_dependencies(paltest_findnextfilea_test2 coreclrpal)
 
 target_link_libraries(paltest_findnextfilea_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/FindNextFileW/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/FindNextFileW/test1/CMakeLists.txt
index a7c3e7ea02..62bf2f860b 100644
--- a/src/pal/tests/palsuite/file_io/FindNextFileW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/FindNextFileW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_findnextfilew_test1
 add_dependencies(paltest_findnextfilew_test1 coreclrpal)
 
 target_link_libraries(paltest_findnextfilew_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/FindNextFileW/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/FindNextFileW/test2/CMakeLists.txt
index 7b4c3c9597..2b9a43f8f4 100644
--- a/src/pal/tests/palsuite/file_io/FindNextFileW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/FindNextFileW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_findnextfilew_test2
 add_dependencies(paltest_findnextfilew_test2 coreclrpal)
 
 target_link_libraries(paltest_findnextfilew_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/FlushFileBuffers/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/FlushFileBuffers/test1/CMakeLists.txt
index 6c24ac76d1..433e89bbf4 100644
--- a/src/pal/tests/palsuite/file_io/FlushFileBuffers/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/FlushFileBuffers/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_flushfilebuffers_test1
 add_dependencies(paltest_flushfilebuffers_test1 coreclrpal)
 
 target_link_libraries(paltest_flushfilebuffers_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetConsoleCP/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetConsoleCP/test1/CMakeLists.txt
index 64ab6ea945..7753cadea4 100644
--- a/src/pal/tests/palsuite/file_io/GetConsoleCP/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetConsoleCP/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getconsolecp_test1
 add_dependencies(paltest_getconsolecp_test1 coreclrpal)
 
 target_link_libraries(paltest_getconsolecp_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetConsoleOutputCP/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetConsoleOutputCP/test1/CMakeLists.txt
index 756f87b382..5784789af7 100644
--- a/src/pal/tests/palsuite/file_io/GetConsoleOutputCP/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetConsoleOutputCP/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getconsoleoutputcp_test1
 add_dependencies(paltest_getconsoleoutputcp_test1 coreclrpal)
 
 target_link_libraries(paltest_getconsoleoutputcp_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetCurrentDirectoryA/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetCurrentDirectoryA/test1/CMakeLists.txt
index 28efc6897f..dad46b6f6b 100644
--- a/src/pal/tests/palsuite/file_io/GetCurrentDirectoryA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetCurrentDirectoryA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getcurrentdirectorya_test1
 add_dependencies(paltest_getcurrentdirectorya_test1 coreclrpal)
 
 target_link_libraries(paltest_getcurrentdirectorya_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetCurrentDirectoryW/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetCurrentDirectoryW/test1/CMakeLists.txt
index ee07f5e0d1..96b148c1b1 100644
--- a/src/pal/tests/palsuite/file_io/GetCurrentDirectoryW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetCurrentDirectoryW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getcurrentdirectoryw_test1
 add_dependencies(paltest_getcurrentdirectoryw_test1 coreclrpal)
 
 target_link_libraries(paltest_getcurrentdirectoryw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetDiskFreeSpaceW/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetDiskFreeSpaceW/test1/CMakeLists.txt
index 7de0b275f6..e0238707e5 100644
--- a/src/pal/tests/palsuite/file_io/GetDiskFreeSpaceW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetDiskFreeSpaceW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getdiskfreespacew_test1
 add_dependencies(paltest_getdiskfreespacew_test1 coreclrpal)
 
 target_link_libraries(paltest_getdiskfreespacew_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetDiskFreeSpaceW/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetDiskFreeSpaceW/test2/CMakeLists.txt
index 7bcbf55c42..fb6a08789b 100644
--- a/src/pal/tests/palsuite/file_io/GetDiskFreeSpaceW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetDiskFreeSpaceW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getdiskfreespacew_test2
 add_dependencies(paltest_getdiskfreespacew_test2 coreclrpal)
 
 target_link_libraries(paltest_getdiskfreespacew_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetFileAttributesA/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFileAttributesA/test1/CMakeLists.txt
index 414df7f6b5..fa2182242e 100644
--- a/src/pal/tests/palsuite/file_io/GetFileAttributesA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFileAttributesA/test1/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_getfileattributesa_test1
 add_dependencies(paltest_getfileattributesa_test1 coreclrpal)
 
 target_link_libraries(paltest_getfileattributesa_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 add_subdirectory(.hidden_directory)
 add_subdirectory(.hidden_ro_directory)
diff --git a/src/pal/tests/palsuite/file_io/GetFileAttributesExW/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFileAttributesExW/test1/CMakeLists.txt
index 6ea24d9d32..41f08e15d9 100644
--- a/src/pal/tests/palsuite/file_io/GetFileAttributesExW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFileAttributesExW/test1/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_getfileattributesexw_test1
 add_dependencies(paltest_getfileattributesexw_test1 coreclrpal)
 
 target_link_libraries(paltest_getfileattributesexw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 add_subdirectory(.hidden_directory)
 add_subdirectory(normal_test_directory)
diff --git a/src/pal/tests/palsuite/file_io/GetFileAttributesExW/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFileAttributesExW/test2/CMakeLists.txt
index 0faa3bd11e..193b4a5144 100644
--- a/src/pal/tests/palsuite/file_io/GetFileAttributesExW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFileAttributesExW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getfileattributesexw_test2
 add_dependencies(paltest_getfileattributesexw_test2 coreclrpal)
 
 target_link_libraries(paltest_getfileattributesexw_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetFileAttributesW/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFileAttributesW/test1/CMakeLists.txt
index bc82f3678e..d64a455a8e 100644
--- a/src/pal/tests/palsuite/file_io/GetFileAttributesW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFileAttributesW/test1/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_getfileattributesw_test1
 add_dependencies(paltest_getfileattributesw_test1 coreclrpal)
 
 target_link_libraries(paltest_getfileattributesw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 add_subdirectory(.hidden_directory)
 add_subdirectory(.hidden_ro_directory)
diff --git a/src/pal/tests/palsuite/file_io/GetFileSize/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFileSize/test1/CMakeLists.txt
index f192ba7400..1220041887 100644
--- a/src/pal/tests/palsuite/file_io/GetFileSize/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFileSize/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getfilesize_test1
 add_dependencies(paltest_getfilesize_test1 coreclrpal)
 
 target_link_libraries(paltest_getfilesize_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetFileSizeEx/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFileSizeEx/test1/CMakeLists.txt
index 33a7e2f557..51e7412bdf 100644
--- a/src/pal/tests/palsuite/file_io/GetFileSizeEx/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFileSizeEx/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getfilesizeex_test1
 add_dependencies(paltest_getfilesizeex_test1 coreclrpal)
 
 target_link_libraries(paltest_getfilesizeex_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetFileTime/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFileTime/test1/CMakeLists.txt
index b95267ab5b..3c95a5d992 100644
--- a/src/pal/tests/palsuite/file_io/GetFileTime/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFileTime/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getfiletime_test1
 add_dependencies(paltest_getfiletime_test1 coreclrpal)
 
 target_link_libraries(paltest_getfiletime_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetFileTime/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFileTime/test2/CMakeLists.txt
index fe02e27bbe..329d8c6553 100644
--- a/src/pal/tests/palsuite/file_io/GetFileTime/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFileTime/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getfiletime_test2
 add_dependencies(paltest_getfiletime_test2 coreclrpal)
 
 target_link_libraries(paltest_getfiletime_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetFileTime/test3/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFileTime/test3/CMakeLists.txt
index bb88966e68..d154a8810b 100644
--- a/src/pal/tests/palsuite/file_io/GetFileTime/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFileTime/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getfiletime_test3
 add_dependencies(paltest_getfiletime_test3 coreclrpal)
 
 target_link_libraries(paltest_getfiletime_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetFileTime/test4/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFileTime/test4/CMakeLists.txt
index e43e7f99a8..416db15a06 100644
--- a/src/pal/tests/palsuite/file_io/GetFileTime/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFileTime/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getfiletime_test4
 add_dependencies(paltest_getfiletime_test4 coreclrpal)
 
 target_link_libraries(paltest_getfiletime_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetFileTime/test5/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFileTime/test5/CMakeLists.txt
index 4af995d207..4072a52fbc 100644
--- a/src/pal/tests/palsuite/file_io/GetFileTime/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFileTime/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getfiletime_test5
 add_dependencies(paltest_getfiletime_test5 coreclrpal)
 
 target_link_libraries(paltest_getfiletime_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetFileTime/test6/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFileTime/test6/CMakeLists.txt
index 87c448b2a6..83d652461b 100644
--- a/src/pal/tests/palsuite/file_io/GetFileTime/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFileTime/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getfiletime_test6
 add_dependencies(paltest_getfiletime_test6 coreclrpal)
 
 target_link_libraries(paltest_getfiletime_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetFileTime/test7/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFileTime/test7/CMakeLists.txt
index cd5cde4d9e..34a08db686 100644
--- a/src/pal/tests/palsuite/file_io/GetFileTime/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFileTime/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getfiletime_test7
 add_dependencies(paltest_getfiletime_test7 coreclrpal)
 
 target_link_libraries(paltest_getfiletime_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetFileType/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFileType/test1/CMakeLists.txt
index cfaba2e738..c0acc6e484 100644
--- a/src/pal/tests/palsuite/file_io/GetFileType/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFileType/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getfiletype_test1
 add_dependencies(paltest_getfiletype_test1 coreclrpal)
 
 target_link_libraries(paltest_getfiletype_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetFileType/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFileType/test2/CMakeLists.txt
index 07dae0b04a..1f2ee78f75 100644
--- a/src/pal/tests/palsuite/file_io/GetFileType/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFileType/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getfiletype_test2
 add_dependencies(paltest_getfiletype_test2 coreclrpal)
 
 target_link_libraries(paltest_getfiletype_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetFileType/test3/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFileType/test3/CMakeLists.txt
index 9353c85771..ed70e6c96c 100644
--- a/src/pal/tests/palsuite/file_io/GetFileType/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFileType/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getfiletype_test3
 add_dependencies(paltest_getfiletype_test3 coreclrpal)
 
 target_link_libraries(paltest_getfiletype_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetFullPathNameA/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFullPathNameA/test1/CMakeLists.txt
index 6198392000..4370c1b155 100644
--- a/src/pal/tests/palsuite/file_io/GetFullPathNameA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFullPathNameA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getfullpathnamea_test1
 add_dependencies(paltest_getfullpathnamea_test1 coreclrpal)
 
 target_link_libraries(paltest_getfullpathnamea_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetFullPathNameA/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFullPathNameA/test2/CMakeLists.txt
index 3449f2d80b..157ca6946e 100644
--- a/src/pal/tests/palsuite/file_io/GetFullPathNameA/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFullPathNameA/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getfullpathnamea_test2
 add_dependencies(paltest_getfullpathnamea_test2 coreclrpal)
 
 target_link_libraries(paltest_getfullpathnamea_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetFullPathNameA/test3/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFullPathNameA/test3/CMakeLists.txt
index 9d8d242e26..74c96185c6 100644
--- a/src/pal/tests/palsuite/file_io/GetFullPathNameA/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFullPathNameA/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getfullpathnamea_test3
 add_dependencies(paltest_getfullpathnamea_test3 coreclrpal)
 
 target_link_libraries(paltest_getfullpathnamea_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetFullPathNameA/test4/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFullPathNameA/test4/CMakeLists.txt
index abf2bacd1c..bda34bdc25 100644
--- a/src/pal/tests/palsuite/file_io/GetFullPathNameA/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFullPathNameA/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getfullpathnamea_test4
 add_dependencies(paltest_getfullpathnamea_test4 coreclrpal)
 
 target_link_libraries(paltest_getfullpathnamea_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetFullPathNameW/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFullPathNameW/test1/CMakeLists.txt
index d455ca1193..5242015025 100644
--- a/src/pal/tests/palsuite/file_io/GetFullPathNameW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFullPathNameW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getfullpathnamew_test1
 add_dependencies(paltest_getfullpathnamew_test1 coreclrpal)
 
 target_link_libraries(paltest_getfullpathnamew_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetFullPathNameW/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFullPathNameW/test2/CMakeLists.txt
index d974e940a7..33e04d1a3e 100644
--- a/src/pal/tests/palsuite/file_io/GetFullPathNameW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFullPathNameW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getfullpathnamew_test2
 add_dependencies(paltest_getfullpathnamew_test2 coreclrpal)
 
 target_link_libraries(paltest_getfullpathnamew_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetFullPathNameW/test3/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFullPathNameW/test3/CMakeLists.txt
index 09439a6372..eaf63760f5 100644
--- a/src/pal/tests/palsuite/file_io/GetFullPathNameW/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFullPathNameW/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getfullpathnamew_test3
 add_dependencies(paltest_getfullpathnamew_test3 coreclrpal)
 
 target_link_libraries(paltest_getfullpathnamew_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetFullPathNameW/test4/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetFullPathNameW/test4/CMakeLists.txt
index 11ed9583b6..6398e9207d 100644
--- a/src/pal/tests/palsuite/file_io/GetFullPathNameW/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetFullPathNameW/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getfullpathnamew_test4
 add_dependencies(paltest_getfullpathnamew_test4 coreclrpal)
 
 target_link_libraries(paltest_getfullpathnamew_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetLongPathNameW/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetLongPathNameW/test1/CMakeLists.txt
index 3b9f0b118a..ec5b70bff7 100644
--- a/src/pal/tests/palsuite/file_io/GetLongPathNameW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetLongPathNameW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getlongpathnamew_test1
 add_dependencies(paltest_getlongpathnamew_test1 coreclrpal)
 
 target_link_libraries(paltest_getlongpathnamew_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetLongPathNameW/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetLongPathNameW/test2/CMakeLists.txt
index b92e431095..8d7c40b3b4 100644
--- a/src/pal/tests/palsuite/file_io/GetLongPathNameW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetLongPathNameW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getlongpathnamew_test2
 add_dependencies(paltest_getlongpathnamew_test2 coreclrpal)
 
 target_link_libraries(paltest_getlongpathnamew_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetStdHandle/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetStdHandle/test1/CMakeLists.txt
index eaa1721b7e..7a299015b2 100644
--- a/src/pal/tests/palsuite/file_io/GetStdHandle/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetStdHandle/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getstdhandle_test1
 add_dependencies(paltest_getstdhandle_test1 coreclrpal)
 
 target_link_libraries(paltest_getstdhandle_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetStdHandle/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetStdHandle/test2/CMakeLists.txt
index ef45aa0dec..5a4d2ba15d 100644
--- a/src/pal/tests/palsuite/file_io/GetStdHandle/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetStdHandle/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getstdhandle_test2
 add_dependencies(paltest_getstdhandle_test2 coreclrpal)
 
 target_link_libraries(paltest_getstdhandle_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetSystemTime/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetSystemTime/test1/CMakeLists.txt
index 4367e880f7..7135abf621 100644
--- a/src/pal/tests/palsuite/file_io/GetSystemTime/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetSystemTime/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getsystemtime_test1
 add_dependencies(paltest_getsystemtime_test1 coreclrpal)
 
 target_link_libraries(paltest_getsystemtime_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetSystemTimeAsFileTime/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetSystemTimeAsFileTime/test1/CMakeLists.txt
index d149383732..d7421b91c0 100644
--- a/src/pal/tests/palsuite/file_io/GetSystemTimeAsFileTime/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetSystemTimeAsFileTime/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getsystemtimeasfiletime_test1
 add_dependencies(paltest_getsystemtimeasfiletime_test1 coreclrpal)
 
 target_link_libraries(paltest_getsystemtimeasfiletime_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetTempFileNameA/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetTempFileNameA/test1/CMakeLists.txt
index 4ed0ccb537..38fdb4977d 100644
--- a/src/pal/tests/palsuite/file_io/GetTempFileNameA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetTempFileNameA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_gettempfilenamea_test1
 add_dependencies(paltest_gettempfilenamea_test1 coreclrpal)
 
 target_link_libraries(paltest_gettempfilenamea_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetTempFileNameA/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetTempFileNameA/test2/CMakeLists.txt
index 9d9b6461cd..1c302acd95 100644
--- a/src/pal/tests/palsuite/file_io/GetTempFileNameA/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetTempFileNameA/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_gettempfilenamea_test2
 add_dependencies(paltest_gettempfilenamea_test2 coreclrpal)
 
 target_link_libraries(paltest_gettempfilenamea_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetTempFileNameA/test3/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetTempFileNameA/test3/CMakeLists.txt
index 446f3cf837..ec18937e01 100644
--- a/src/pal/tests/palsuite/file_io/GetTempFileNameA/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetTempFileNameA/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_gettempfilenamea_test3
 add_dependencies(paltest_gettempfilenamea_test3 coreclrpal)
 
 target_link_libraries(paltest_gettempfilenamea_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetTempFileNameW/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetTempFileNameW/test1/CMakeLists.txt
index 6919cf66cd..96ad10bb36 100644
--- a/src/pal/tests/palsuite/file_io/GetTempFileNameW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetTempFileNameW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_gettempfilenamew_test1
 add_dependencies(paltest_gettempfilenamew_test1 coreclrpal)
 
 target_link_libraries(paltest_gettempfilenamew_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetTempFileNameW/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetTempFileNameW/test2/CMakeLists.txt
index d077463390..bc97c2bc48 100644
--- a/src/pal/tests/palsuite/file_io/GetTempFileNameW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetTempFileNameW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_gettempfilenamew_test2
 add_dependencies(paltest_gettempfilenamew_test2 coreclrpal)
 
 target_link_libraries(paltest_gettempfilenamew_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetTempFileNameW/test3/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetTempFileNameW/test3/CMakeLists.txt
index 3aa0f4a044..50794c3e33 100644
--- a/src/pal/tests/palsuite/file_io/GetTempFileNameW/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetTempFileNameW/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_gettempfilenamew_test3
 add_dependencies(paltest_gettempfilenamew_test3 coreclrpal)
 
 target_link_libraries(paltest_gettempfilenamew_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/GetTempPathW/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/GetTempPathW/test1/CMakeLists.txt
index 04b240997a..093c8803d5 100644
--- a/src/pal/tests/palsuite/file_io/GetTempPathW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/GetTempPathW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_gettemppathw_test1
 add_dependencies(paltest_gettemppathw_test1 coreclrpal)
 
 target_link_libraries(paltest_gettemppathw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/MoveFileA/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/MoveFileA/test1/CMakeLists.txt
index b096a04653..b8f445b1e7 100644
--- a/src/pal/tests/palsuite/file_io/MoveFileA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/MoveFileA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_movefilea_test1
 add_dependencies(paltest_movefilea_test1 coreclrpal)
 
 target_link_libraries(paltest_movefilea_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/MoveFileExA/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/MoveFileExA/test1/CMakeLists.txt
index ef2471738c..ac5ea7463b 100644
--- a/src/pal/tests/palsuite/file_io/MoveFileExA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/MoveFileExA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_movefileexa_test1
 add_dependencies(paltest_movefileexa_test1 coreclrpal)
 
 target_link_libraries(paltest_movefileexa_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/MoveFileExW/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/MoveFileExW/test1/CMakeLists.txt
index ca6b35e3ac..bbe3d5aa3f 100644
--- a/src/pal/tests/palsuite/file_io/MoveFileExW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/MoveFileExW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_movefileexw_test1
 add_dependencies(paltest_movefileexw_test1 coreclrpal)
 
 target_link_libraries(paltest_movefileexw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/MoveFileW/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/MoveFileW/test1/CMakeLists.txt
index 4519746e7b..03b7ab907c 100644
--- a/src/pal/tests/palsuite/file_io/MoveFileW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/MoveFileW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_movefilew_test1
 add_dependencies(paltest_movefilew_test1 coreclrpal)
 
 target_link_libraries(paltest_movefilew_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/ReadFile/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/ReadFile/test1/CMakeLists.txt
index 0aceb3708e..8fe1f1d2ed 100644
--- a/src/pal/tests/palsuite/file_io/ReadFile/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/ReadFile/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_readfile_test1
 add_dependencies(paltest_readfile_test1 coreclrpal)
 
 target_link_libraries(paltest_readfile_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/ReadFile/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/ReadFile/test2/CMakeLists.txt
index f28ac117a2..2113d67622 100644
--- a/src/pal/tests/palsuite/file_io/ReadFile/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/ReadFile/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_readfile_test2
 add_dependencies(paltest_readfile_test2 coreclrpal)
 
 target_link_libraries(paltest_readfile_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/ReadFile/test3/CMakeLists.txt b/src/pal/tests/palsuite/file_io/ReadFile/test3/CMakeLists.txt
index 26cb675c40..d76a726742 100644
--- a/src/pal/tests/palsuite/file_io/ReadFile/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/ReadFile/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_readfile_test3
 add_dependencies(paltest_readfile_test3 coreclrpal)
 
 target_link_libraries(paltest_readfile_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/ReadFile/test4/CMakeLists.txt b/src/pal/tests/palsuite/file_io/ReadFile/test4/CMakeLists.txt
index bbf12777b6..2550a21173 100644
--- a/src/pal/tests/palsuite/file_io/ReadFile/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/ReadFile/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_readfile_test4
 add_dependencies(paltest_readfile_test4 coreclrpal)
 
 target_link_libraries(paltest_readfile_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/RemoveDirectoryA/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/RemoveDirectoryA/test1/CMakeLists.txt
index 7a8d1c9d57..31a57791b7 100644
--- a/src/pal/tests/palsuite/file_io/RemoveDirectoryA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/RemoveDirectoryA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_removedirectorya_test1
 add_dependencies(paltest_removedirectorya_test1 coreclrpal)
 
 target_link_libraries(paltest_removedirectorya_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/RemoveDirectoryW/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/RemoveDirectoryW/test1/CMakeLists.txt
index 6223bc6197..f995a0e1c5 100644
--- a/src/pal/tests/palsuite/file_io/RemoveDirectoryW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/RemoveDirectoryW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_removedirectoryw_test1
 add_dependencies(paltest_removedirectoryw_test1 coreclrpal)
 
 target_link_libraries(paltest_removedirectoryw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SearchPathA/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SearchPathA/test1/CMakeLists.txt
index c020a86b61..8de22aebdc 100644
--- a/src/pal/tests/palsuite/file_io/SearchPathA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SearchPathA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_searchpatha_test1
 add_dependencies(paltest_searchpatha_test1 coreclrpal)
 
 target_link_libraries(paltest_searchpatha_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SearchPathW/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SearchPathW/test1/CMakeLists.txt
index a77d875505..d7539a8ac8 100644
--- a/src/pal/tests/palsuite/file_io/SearchPathW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SearchPathW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_searchpathw_test1
 add_dependencies(paltest_searchpathw_test1 coreclrpal)
 
 target_link_libraries(paltest_searchpathw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetCurrentDirectoryA/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetCurrentDirectoryA/test1/CMakeLists.txt
index 5d0da64ba7..e6fb80f04e 100644
--- a/src/pal/tests/palsuite/file_io/SetCurrentDirectoryA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetCurrentDirectoryA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setcurrentdirectorya_test1
 add_dependencies(paltest_setcurrentdirectorya_test1 coreclrpal)
 
 target_link_libraries(paltest_setcurrentdirectorya_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetCurrentDirectoryA/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetCurrentDirectoryA/test2/CMakeLists.txt
index 243e80b9a4..587ea20cf8 100644
--- a/src/pal/tests/palsuite/file_io/SetCurrentDirectoryA/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetCurrentDirectoryA/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setcurrentdirectorya_test2
 add_dependencies(paltest_setcurrentdirectorya_test2 coreclrpal)
 
 target_link_libraries(paltest_setcurrentdirectorya_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetCurrentDirectoryA/test3/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetCurrentDirectoryA/test3/CMakeLists.txt
index 8560ff0187..7e2f3ada33 100644
--- a/src/pal/tests/palsuite/file_io/SetCurrentDirectoryA/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetCurrentDirectoryA/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setcurrentdirectorya_test3
 add_dependencies(paltest_setcurrentdirectorya_test3 coreclrpal)
 
 target_link_libraries(paltest_setcurrentdirectorya_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetCurrentDirectoryW/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetCurrentDirectoryW/test1/CMakeLists.txt
index 9149221008..a68f87b5a0 100644
--- a/src/pal/tests/palsuite/file_io/SetCurrentDirectoryW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetCurrentDirectoryW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setcurrentdirectoryw_test1
 add_dependencies(paltest_setcurrentdirectoryw_test1 coreclrpal)
 
 target_link_libraries(paltest_setcurrentdirectoryw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetCurrentDirectoryW/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetCurrentDirectoryW/test2/CMakeLists.txt
index 455ddc828d..9cc5ba1a55 100644
--- a/src/pal/tests/palsuite/file_io/SetCurrentDirectoryW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetCurrentDirectoryW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setcurrentdirectoryw_test2
 add_dependencies(paltest_setcurrentdirectoryw_test2 coreclrpal)
 
 target_link_libraries(paltest_setcurrentdirectoryw_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetCurrentDirectoryW/test3/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetCurrentDirectoryW/test3/CMakeLists.txt
index 1cb1150a61..06da5a8106 100644
--- a/src/pal/tests/palsuite/file_io/SetCurrentDirectoryW/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetCurrentDirectoryW/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setcurrentdirectoryw_test3
 add_dependencies(paltest_setcurrentdirectoryw_test3 coreclrpal)
 
 target_link_libraries(paltest_setcurrentdirectoryw_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetEndOfFile/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetEndOfFile/test1/CMakeLists.txt
index 3c0fdeec22..5d9e8c0615 100644
--- a/src/pal/tests/palsuite/file_io/SetEndOfFile/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetEndOfFile/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setendoffile_test1
 add_dependencies(paltest_setendoffile_test1 coreclrpal)
 
 target_link_libraries(paltest_setendoffile_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetEndOfFile/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetEndOfFile/test2/CMakeLists.txt
index 57afdad2fd..47aa96c18a 100644
--- a/src/pal/tests/palsuite/file_io/SetEndOfFile/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetEndOfFile/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setendoffile_test2
 add_dependencies(paltest_setendoffile_test2 coreclrpal)
 
 target_link_libraries(paltest_setendoffile_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetEndOfFile/test3/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetEndOfFile/test3/CMakeLists.txt
index 01575ce09b..87a2a47a61 100644
--- a/src/pal/tests/palsuite/file_io/SetEndOfFile/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetEndOfFile/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setendoffile_test3
 add_dependencies(paltest_setendoffile_test3 coreclrpal)
 
 target_link_libraries(paltest_setendoffile_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetEndOfFile/test4/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetEndOfFile/test4/CMakeLists.txt
index 1dc4f68aef..ca5f00fe2b 100644
--- a/src/pal/tests/palsuite/file_io/SetEndOfFile/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetEndOfFile/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setendoffile_test4
 add_dependencies(paltest_setendoffile_test4 coreclrpal)
 
 target_link_libraries(paltest_setendoffile_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetEndOfFile/test5/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetEndOfFile/test5/CMakeLists.txt
index 19f87a28af..390ee11f40 100644
--- a/src/pal/tests/palsuite/file_io/SetEndOfFile/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetEndOfFile/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setendoffile_test5
 add_dependencies(paltest_setendoffile_test5 coreclrpal)
 
 target_link_libraries(paltest_setendoffile_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetFileAttributesA/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetFileAttributesA/test1/CMakeLists.txt
index 638dd5c425..b287ceca67 100644
--- a/src/pal/tests/palsuite/file_io/SetFileAttributesA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetFileAttributesA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setfileattributesa_test1
 add_dependencies(paltest_setfileattributesa_test1 coreclrpal)
 
 target_link_libraries(paltest_setfileattributesa_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetFileAttributesA/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetFileAttributesA/test2/CMakeLists.txt
index 51bee5af39..ace67dcbd1 100644
--- a/src/pal/tests/palsuite/file_io/SetFileAttributesA/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetFileAttributesA/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setfileattributesa_test2
 add_dependencies(paltest_setfileattributesa_test2 coreclrpal)
 
 target_link_libraries(paltest_setfileattributesa_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetFileAttributesA/test3/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetFileAttributesA/test3/CMakeLists.txt
index 4597e1d22c..eb054ac918 100644
--- a/src/pal/tests/palsuite/file_io/SetFileAttributesA/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetFileAttributesA/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setfileattributesa_test3
 add_dependencies(paltest_setfileattributesa_test3 coreclrpal)
 
 target_link_libraries(paltest_setfileattributesa_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetFileAttributesA/test4/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetFileAttributesA/test4/CMakeLists.txt
index 1807027123..d20ea5dc04 100644
--- a/src/pal/tests/palsuite/file_io/SetFileAttributesA/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetFileAttributesA/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setfileattributesa_test4
 add_dependencies(paltest_setfileattributesa_test4 coreclrpal)
 
 target_link_libraries(paltest_setfileattributesa_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetFileAttributesW/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetFileAttributesW/test1/CMakeLists.txt
index 825554da74..4d867c1a58 100644
--- a/src/pal/tests/palsuite/file_io/SetFileAttributesW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetFileAttributesW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setfileattributesw_test1
 add_dependencies(paltest_setfileattributesw_test1 coreclrpal)
 
 target_link_libraries(paltest_setfileattributesw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetFileAttributesW/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetFileAttributesW/test2/CMakeLists.txt
index fda1cec1d7..df1bbfad04 100644
--- a/src/pal/tests/palsuite/file_io/SetFileAttributesW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetFileAttributesW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setfileattributesw_test2
 add_dependencies(paltest_setfileattributesw_test2 coreclrpal)
 
 target_link_libraries(paltest_setfileattributesw_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetFileAttributesW/test3/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetFileAttributesW/test3/CMakeLists.txt
index 1757f88bfe..f4cd725b71 100644
--- a/src/pal/tests/palsuite/file_io/SetFileAttributesW/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetFileAttributesW/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setfileattributesw_test3
 add_dependencies(paltest_setfileattributesw_test3 coreclrpal)
 
 target_link_libraries(paltest_setfileattributesw_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetFileAttributesW/test4/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetFileAttributesW/test4/CMakeLists.txt
index d1cfcdd07d..986954b7d8 100644
--- a/src/pal/tests/palsuite/file_io/SetFileAttributesW/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetFileAttributesW/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setfileattributesw_test4
 add_dependencies(paltest_setfileattributesw_test4 coreclrpal)
 
 target_link_libraries(paltest_setfileattributesw_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetFilePointer/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetFilePointer/test1/CMakeLists.txt
index bb09a981e9..c0594aac1a 100644
--- a/src/pal/tests/palsuite/file_io/SetFilePointer/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetFilePointer/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setfilepointer_test1
 add_dependencies(paltest_setfilepointer_test1 coreclrpal)
 
 target_link_libraries(paltest_setfilepointer_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetFilePointer/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetFilePointer/test2/CMakeLists.txt
index 2e76f00c99..4299b808d7 100644
--- a/src/pal/tests/palsuite/file_io/SetFilePointer/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetFilePointer/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setfilepointer_test2
 add_dependencies(paltest_setfilepointer_test2 coreclrpal)
 
 target_link_libraries(paltest_setfilepointer_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetFilePointer/test3/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetFilePointer/test3/CMakeLists.txt
index bcc3faca09..04589ea0d7 100644
--- a/src/pal/tests/palsuite/file_io/SetFilePointer/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetFilePointer/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setfilepointer_test3
 add_dependencies(paltest_setfilepointer_test3 coreclrpal)
 
 target_link_libraries(paltest_setfilepointer_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetFilePointer/test4/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetFilePointer/test4/CMakeLists.txt
index 3fcc4066f2..6fc8116808 100644
--- a/src/pal/tests/palsuite/file_io/SetFilePointer/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetFilePointer/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setfilepointer_test4
 add_dependencies(paltest_setfilepointer_test4 coreclrpal)
 
 target_link_libraries(paltest_setfilepointer_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetFilePointer/test5/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetFilePointer/test5/CMakeLists.txt
index 3012009e4f..7584349035 100644
--- a/src/pal/tests/palsuite/file_io/SetFilePointer/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetFilePointer/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setfilepointer_test5
 add_dependencies(paltest_setfilepointer_test5 coreclrpal)
 
 target_link_libraries(paltest_setfilepointer_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetFilePointer/test6/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetFilePointer/test6/CMakeLists.txt
index a376acbe28..3e9f6496cc 100644
--- a/src/pal/tests/palsuite/file_io/SetFilePointer/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetFilePointer/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setfilepointer_test6
 add_dependencies(paltest_setfilepointer_test6 coreclrpal)
 
 target_link_libraries(paltest_setfilepointer_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetFilePointer/test7/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetFilePointer/test7/CMakeLists.txt
index 2b5c0bbb45..14f4910e3b 100644
--- a/src/pal/tests/palsuite/file_io/SetFilePointer/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetFilePointer/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setfilepointer_test7
 add_dependencies(paltest_setfilepointer_test7 coreclrpal)
 
 target_link_libraries(paltest_setfilepointer_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetFileTime/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetFileTime/test1/CMakeLists.txt
index b94bd05d76..e9d8dce966 100644
--- a/src/pal/tests/palsuite/file_io/SetFileTime/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetFileTime/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setfiletime_test1
 add_dependencies(paltest_setfiletime_test1 coreclrpal)
 
 target_link_libraries(paltest_setfiletime_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetFileTime/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetFileTime/test2/CMakeLists.txt
index 5478aa3703..12ec26c9f8 100644
--- a/src/pal/tests/palsuite/file_io/SetFileTime/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetFileTime/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setfiletime_test2
 add_dependencies(paltest_setfiletime_test2 coreclrpal)
 
 target_link_libraries(paltest_setfiletime_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetFileTime/test3/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetFileTime/test3/CMakeLists.txt
index 26e178a328..ca0ed659f5 100644
--- a/src/pal/tests/palsuite/file_io/SetFileTime/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetFileTime/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setfiletime_test3
 add_dependencies(paltest_setfiletime_test3 coreclrpal)
 
 target_link_libraries(paltest_setfiletime_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/SetFileTime/test4/CMakeLists.txt b/src/pal/tests/palsuite/file_io/SetFileTime/test4/CMakeLists.txt
index b85a92bf63..432ebe594f 100644
--- a/src/pal/tests/palsuite/file_io/SetFileTime/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/SetFileTime/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setfiletime_test4
 add_dependencies(paltest_setfiletime_test4 coreclrpal)
 
 target_link_libraries(paltest_setfiletime_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/WriteFile/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/WriteFile/test1/CMakeLists.txt
index 3d5a735a83..da7bbf7645 100644
--- a/src/pal/tests/palsuite/file_io/WriteFile/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/WriteFile/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_writefile_test1
 add_dependencies(paltest_writefile_test1 coreclrpal)
 
 target_link_libraries(paltest_writefile_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/WriteFile/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/WriteFile/test2/CMakeLists.txt
index 3d7d18826a..86530dea7d 100644
--- a/src/pal/tests/palsuite/file_io/WriteFile/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/WriteFile/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_writefile_test2
 add_dependencies(paltest_writefile_test2 coreclrpal)
 
 target_link_libraries(paltest_writefile_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/WriteFile/test3/CMakeLists.txt b/src/pal/tests/palsuite/file_io/WriteFile/test3/CMakeLists.txt
index bffcf35482..143f537ad9 100644
--- a/src/pal/tests/palsuite/file_io/WriteFile/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/WriteFile/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_writefile_test3
 add_dependencies(paltest_writefile_test3 coreclrpal)
 
 target_link_libraries(paltest_writefile_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/WriteFile/test4/CMakeLists.txt b/src/pal/tests/palsuite/file_io/WriteFile/test4/CMakeLists.txt
index 402a61ac2c..b8e26ee57e 100644
--- a/src/pal/tests/palsuite/file_io/WriteFile/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/WriteFile/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_writefile_test4
 add_dependencies(paltest_writefile_test4 coreclrpal)
 
 target_link_libraries(paltest_writefile_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/WriteFile/test5/CMakeLists.txt b/src/pal/tests/palsuite/file_io/WriteFile/test5/CMakeLists.txt
index f1f5037f98..69d7034b89 100644
--- a/src/pal/tests/palsuite/file_io/WriteFile/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/WriteFile/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_writefile_test5
 add_dependencies(paltest_writefile_test5 coreclrpal)
 
 target_link_libraries(paltest_writefile_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/errorpathnotfound/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/errorpathnotfound/test1/CMakeLists.txt
index 4c4f6416ce..14bed34639 100644
--- a/src/pal/tests/palsuite/file_io/errorpathnotfound/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/errorpathnotfound/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_errorpathnotfound_test1
 add_dependencies(paltest_errorpathnotfound_test1 coreclrpal)
 
 target_link_libraries(paltest_errorpathnotfound_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/errorpathnotfound/test2/CMakeLists.txt b/src/pal/tests/palsuite/file_io/errorpathnotfound/test2/CMakeLists.txt
index 284933f950..abbf494f07 100644
--- a/src/pal/tests/palsuite/file_io/errorpathnotfound/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/errorpathnotfound/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_errorpathnotfound_test2
 add_dependencies(paltest_errorpathnotfound_test2 coreclrpal)
 
 target_link_libraries(paltest_errorpathnotfound_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/errorpathnotfound/test3/CMakeLists.txt b/src/pal/tests/palsuite/file_io/errorpathnotfound/test3/CMakeLists.txt
index b418c9dbdb..a0e7dd60ef 100644
--- a/src/pal/tests/palsuite/file_io/errorpathnotfound/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/errorpathnotfound/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_errorpathnotfound_test3
 add_dependencies(paltest_errorpathnotfound_test3 coreclrpal)
 
 target_link_libraries(paltest_errorpathnotfound_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/errorpathnotfound/test4/CMakeLists.txt b/src/pal/tests/palsuite/file_io/errorpathnotfound/test4/CMakeLists.txt
index e0322dd8e4..00621296d0 100644
--- a/src/pal/tests/palsuite/file_io/errorpathnotfound/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/errorpathnotfound/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_errorpathnotfound_test4
 add_dependencies(paltest_errorpathnotfound_test4 coreclrpal)
 
 target_link_libraries(paltest_errorpathnotfound_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/file_io/gettemppatha/test1/CMakeLists.txt b/src/pal/tests/palsuite/file_io/gettemppatha/test1/CMakeLists.txt
index 9869c9c70f..9465bf2a4e 100644
--- a/src/pal/tests/palsuite/file_io/gettemppatha/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/file_io/gettemppatha/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_gettemppatha_test1
 add_dependencies(paltest_gettemppatha_test1 coreclrpal)
 
 target_link_libraries(paltest_gettemppatha_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test1/CMakeLists.txt
index c38015ea21..c098dad907 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createfilemappinga_test1
 add_dependencies(paltest_createfilemappinga_test1 coreclrpal)
 
 target_link_libraries(paltest_createfilemappinga_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test3/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test3/CMakeLists.txt
index fc152c8161..4e57246487 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createfilemappinga_test3
 add_dependencies(paltest_createfilemappinga_test3 coreclrpal)
 
 target_link_libraries(paltest_createfilemappinga_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test4/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test4/CMakeLists.txt
index bbb4deaa8b..d5d5c80213 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createfilemappinga_test4
 add_dependencies(paltest_createfilemappinga_test4 coreclrpal)
 
 target_link_libraries(paltest_createfilemappinga_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test5/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test5/CMakeLists.txt
index b80aa21a42..96cd09f95c 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createfilemappinga_test5
 add_dependencies(paltest_createfilemappinga_test5 coreclrpal)
 
 target_link_libraries(paltest_createfilemappinga_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test6/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test6/CMakeLists.txt
index 414127aa35..383eb6e623 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createfilemappinga_test6
 add_dependencies(paltest_createfilemappinga_test6 coreclrpal)
 
 target_link_libraries(paltest_createfilemappinga_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test7/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test7/CMakeLists.txt
index e40a5ad486..8f8a2a454c 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createfilemappinga_test7
 add_dependencies(paltest_createfilemappinga_test7 coreclrpal)
 
 target_link_libraries(paltest_createfilemappinga_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test8/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test8/CMakeLists.txt
index d2e2007545..5246d0d5fe 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test8/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test8/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createfilemappinga_test8
 add_dependencies(paltest_createfilemappinga_test8 coreclrpal)
 
 target_link_libraries(paltest_createfilemappinga_test8
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test9/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test9/CMakeLists.txt
index 3017dc4aa4..b0a8017011 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test9/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingA/test9/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createfilemappinga_test9
 add_dependencies(paltest_createfilemappinga_test9 coreclrpal)
 
 target_link_libraries(paltest_createfilemappinga_test9
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/CreateFileMapping_neg1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/CreateFileMapping_neg1/CMakeLists.txt
index 2d24eca8c8..7cafe0971c 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/CreateFileMapping_neg1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/CreateFileMapping_neg1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createfilemappingw_createfilemapping_neg1
 add_dependencies(paltest_createfilemappingw_createfilemapping_neg1 coreclrpal)
 
 target_link_libraries(paltest_createfilemappingw_createfilemapping_neg1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test1/CMakeLists.txt
index a2fbfa39af..661fd5d3b5 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createfilemappingw_test1
 add_dependencies(paltest_createfilemappingw_test1 coreclrpal)
 
 target_link_libraries(paltest_createfilemappingw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test2/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test2/CMakeLists.txt
index 8552cc910f..7fac43a4a5 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createfilemappingw_test2
 add_dependencies(paltest_createfilemappingw_test2 coreclrpal)
 
 target_link_libraries(paltest_createfilemappingw_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test3/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test3/CMakeLists.txt
index 97fd712350..1e95960679 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createfilemappingw_test3
 add_dependencies(paltest_createfilemappingw_test3 coreclrpal)
 
 target_link_libraries(paltest_createfilemappingw_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test4/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test4/CMakeLists.txt
index 81f248e335..955678e45e 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createfilemappingw_test4
 add_dependencies(paltest_createfilemappingw_test4 coreclrpal)
 
 target_link_libraries(paltest_createfilemappingw_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test5/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test5/CMakeLists.txt
index df25e29a4f..6201940df0 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createfilemappingw_test5
 add_dependencies(paltest_createfilemappingw_test5 coreclrpal)
 
 target_link_libraries(paltest_createfilemappingw_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test6/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test6/CMakeLists.txt
index 852c508020..4f8d838687 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createfilemappingw_test6
 add_dependencies(paltest_createfilemappingw_test6 coreclrpal)
 
 target_link_libraries(paltest_createfilemappingw_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test7/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test7/CMakeLists.txt
index 68be449aec..154f755721 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createfilemappingw_test7
 add_dependencies(paltest_createfilemappingw_test7 coreclrpal)
 
 target_link_libraries(paltest_createfilemappingw_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test8/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test8/CMakeLists.txt
index 406331072c..bb9e1cedcc 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test8/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test8/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createfilemappingw_test8
 add_dependencies(paltest_createfilemappingw_test8 coreclrpal)
 
 target_link_libraries(paltest_createfilemappingw_test8
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test9/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test9/CMakeLists.txt
index 6d15fea1e6..241e9f02b3 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test9/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/CreateFileMappingW/test9/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createfilemappingw_test9
 add_dependencies(paltest_createfilemappingw_test9 coreclrpal)
 
 target_link_libraries(paltest_createfilemappingw_test9
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/FreeLibrary/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/FreeLibrary/test1/CMakeLists.txt
index beaee835c8..4a8b6daeb5 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/FreeLibrary/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/FreeLibrary/test1/CMakeLists.txt
@@ -14,7 +14,5 @@ add_executable(paltest_freelibrary_test1
 add_dependencies(paltest_freelibrary_test1 coreclrpal)
 
 target_link_libraries(paltest_freelibrary_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/FreeLibrary/test2/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/FreeLibrary/test2/CMakeLists.txt
index 0a5e700ba4..aa57e09265 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/FreeLibrary/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/FreeLibrary/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_freelibrary_test2
 add_dependencies(paltest_freelibrary_test2 coreclrpal)
 
 target_link_libraries(paltest_freelibrary_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/FreeLibraryAndExitThread/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/FreeLibraryAndExitThread/test1/CMakeLists.txt
index 03bfe06eb3..338aaf774c 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/FreeLibraryAndExitThread/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/FreeLibraryAndExitThread/test1/CMakeLists.txt
@@ -14,7 +14,5 @@ add_executable(paltest_freelibraryandexitthread_test1
 add_dependencies(paltest_freelibraryandexitthread_test1 coreclrpal)
 
 target_link_libraries(paltest_freelibraryandexitthread_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/GetModuleFileNameA/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/GetModuleFileNameA/test1/CMakeLists.txt
index 9b7a610f0c..27eaec18dc 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/GetModuleFileNameA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/GetModuleFileNameA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getmodulefilenamea_test1
 add_dependencies(paltest_getmodulefilenamea_test1 coreclrpal)
 
 target_link_libraries(paltest_getmodulefilenamea_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/GetModuleFileNameA/test2/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/GetModuleFileNameA/test2/CMakeLists.txt
index 1909be4b42..e908eaf008 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/GetModuleFileNameA/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/GetModuleFileNameA/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getmodulefilenamea_test2
 add_dependencies(paltest_getmodulefilenamea_test2 coreclrpal)
 
 target_link_libraries(paltest_getmodulefilenamea_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/GetModuleFileNameW/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/GetModuleFileNameW/test1/CMakeLists.txt
index f3d92b15c9..6afc44e23f 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/GetModuleFileNameW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/GetModuleFileNameW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getmodulefilenamew_test1
 add_dependencies(paltest_getmodulefilenamew_test1 coreclrpal)
 
 target_link_libraries(paltest_getmodulefilenamew_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/GetModuleFileNameW/test2/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/GetModuleFileNameW/test2/CMakeLists.txt
index 7b23e92772..50a4dd8c10 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/GetModuleFileNameW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/GetModuleFileNameW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getmodulefilenamew_test2
 add_dependencies(paltest_getmodulefilenamew_test2 coreclrpal)
 
 target_link_libraries(paltest_getmodulefilenamew_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/GetProcAddress/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/GetProcAddress/test1/CMakeLists.txt
index 3dedba3cce..a9a985fb03 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/GetProcAddress/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/GetProcAddress/test1/CMakeLists.txt
@@ -14,7 +14,5 @@ add_executable(paltest_getprocaddress_test1
 add_dependencies(paltest_getprocaddress_test1 coreclrpal)
 
 target_link_libraries(paltest_getprocaddress_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/GetProcAddress/test2/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/GetProcAddress/test2/CMakeLists.txt
index 983c16f12f..0069161250 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/GetProcAddress/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/GetProcAddress/test2/CMakeLists.txt
@@ -14,7 +14,5 @@ add_executable(paltest_getprocaddress_test2
 add_dependencies(paltest_getprocaddress_test2 coreclrpal)
 
 target_link_libraries(paltest_getprocaddress_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/GetProcessHeap/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/GetProcessHeap/test1/CMakeLists.txt
index 3e9c725f95..d312ae95ee 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/GetProcessHeap/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/GetProcessHeap/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getprocessheap_test1
 add_dependencies(paltest_getprocessheap_test1 coreclrpal)
 
 target_link_libraries(paltest_getprocessheap_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/HeapAlloc/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/HeapAlloc/test1/CMakeLists.txt
index b9ce32b35e..69ee8bbe8f 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/HeapAlloc/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/HeapAlloc/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_heapalloc_test1
 add_dependencies(paltest_heapalloc_test1 coreclrpal)
 
 target_link_libraries(paltest_heapalloc_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/HeapAlloc/test2/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/HeapAlloc/test2/CMakeLists.txt
index 1b9655ddba..f8084adf3c 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/HeapAlloc/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/HeapAlloc/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_heapalloc_test2
 add_dependencies(paltest_heapalloc_test2 coreclrpal)
 
 target_link_libraries(paltest_heapalloc_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/HeapAlloc/test3/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/HeapAlloc/test3/CMakeLists.txt
index 1c3845c6e9..81bd6def24 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/HeapAlloc/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/HeapAlloc/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_heapalloc_test3
 add_dependencies(paltest_heapalloc_test3 coreclrpal)
 
 target_link_libraries(paltest_heapalloc_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/HeapFree/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/HeapFree/test1/CMakeLists.txt
index 004912256c..3f61a2f215 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/HeapFree/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/HeapFree/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_heapfree_test1
 add_dependencies(paltest_heapfree_test1 coreclrpal)
 
 target_link_libraries(paltest_heapfree_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/HeapReAlloc/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/HeapReAlloc/test1/CMakeLists.txt
index 17e0127435..acdb24e9ed 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/HeapReAlloc/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/HeapReAlloc/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_heaprealloc_test1
 add_dependencies(paltest_heaprealloc_test1 coreclrpal)
 
 target_link_libraries(paltest_heaprealloc_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/HeapReAlloc/test2/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/HeapReAlloc/test2/CMakeLists.txt
index a9239354ba..c2ce80b40d 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/HeapReAlloc/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/HeapReAlloc/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_heaprealloc_test2
 add_dependencies(paltest_heaprealloc_test2 coreclrpal)
 
 target_link_libraries(paltest_heaprealloc_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/HeapReAlloc/test3/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/HeapReAlloc/test3/CMakeLists.txt
index 2d82b6efdd..7982b05c68 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/HeapReAlloc/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/HeapReAlloc/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_heaprealloc_test3
 add_dependencies(paltest_heaprealloc_test3 coreclrpal)
 
 target_link_libraries(paltest_heaprealloc_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/HeapReAlloc/test4/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/HeapReAlloc/test4/CMakeLists.txt
index 129d8a47cd..f178dacca7 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/HeapReAlloc/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/HeapReAlloc/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_heaprealloc_test4
 add_dependencies(paltest_heaprealloc_test4 coreclrpal)
 
 target_link_libraries(paltest_heaprealloc_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/HeapReAlloc/test5/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/HeapReAlloc/test5/CMakeLists.txt
index ed3d390625..2a493525a1 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/HeapReAlloc/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/HeapReAlloc/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_heaprealloc_test5
 add_dependencies(paltest_heaprealloc_test5 coreclrpal)
 
 target_link_libraries(paltest_heaprealloc_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/LocalAlloc/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/LocalAlloc/test1/CMakeLists.txt
index f74e442d76..07d0c01c05 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/LocalAlloc/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/LocalAlloc/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_localalloc_test1
 add_dependencies(paltest_localalloc_test1 coreclrpal)
 
 target_link_libraries(paltest_localalloc_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/LocalFree/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/LocalFree/test1/CMakeLists.txt
index d92939c7cc..5e7aac4f57 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/LocalFree/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/LocalFree/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_localfree_test1
 add_dependencies(paltest_localfree_test1 coreclrpal)
 
 target_link_libraries(paltest_localfree_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/LocalFree/test2/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/LocalFree/test2/CMakeLists.txt
index e087b08ad7..1f04c7ab2d 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/LocalFree/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/LocalFree/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_localfree_test2
 add_dependencies(paltest_localfree_test2 coreclrpal)
 
 target_link_libraries(paltest_localfree_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test1/CMakeLists.txt
index 1d08065b2a..a9b8869c37 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test1/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_lockfile_test1
 add_dependencies(paltest_lockfile_test1 coreclrpal)
 
 target_link_libraries(paltest_lockfile_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_lockfile_test1_helper
 add_dependencies(paltest_lockfile_test1_helper coreclrpal)
 
 target_link_libraries(paltest_lockfile_test1_helper
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
\ No newline at end of file
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test2/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test2/CMakeLists.txt
index ca5e5faed4..42e88c5999 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_lockfile_test2
 add_dependencies(paltest_lockfile_test2 coreclrpal)
 
 target_link_libraries(paltest_lockfile_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test3/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test3/CMakeLists.txt
index 117c715084..299e8cf76c 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test3/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_lockfile_test3
 add_dependencies(paltest_lockfile_test3 coreclrpal)
 
 target_link_libraries(paltest_lockfile_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_lockfile_test3_helper
 add_dependencies(paltest_lockfile_test3_helper coreclrpal)
 
 target_link_libraries(paltest_lockfile_test3_helper
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test4/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test4/CMakeLists.txt
index aee1b1a0be..55cf9c64f7 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_lockfile_test4
 add_dependencies(paltest_lockfile_test4 coreclrpal)
 
 target_link_libraries(paltest_lockfile_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test5/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test5/CMakeLists.txt
index 70e3db4561..82a174907e 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test5/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_lockfile_test5
 add_dependencies(paltest_lockfile_test5 coreclrpal)
 
 target_link_libraries(paltest_lockfile_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_lockfile_test5_helper
 add_dependencies(paltest_lockfile_test5_helper coreclrpal)
 
 target_link_libraries(paltest_lockfile_test5_helper
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test6/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test6/CMakeLists.txt
index 255ecbcc8d..fc5f90113e 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test6/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_lockfile_test6
 add_dependencies(paltest_lockfile_test6 coreclrpal)
 
 target_link_libraries(paltest_lockfile_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_lockfile_test6_helper
 add_dependencies(paltest_lockfile_test6_helper coreclrpal)
 
 target_link_libraries(paltest_lockfile_test6_helper
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test7/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test7/CMakeLists.txt
index 68a5b9f659..c52bf55ba8 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/LockFile/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_lockfile_test7
 add_dependencies(paltest_lockfile_test7 coreclrpal)
 
 target_link_libraries(paltest_lockfile_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test1/CMakeLists.txt
index 01679e5387..bdd664f0ab 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_mapviewoffile_test1
 add_dependencies(paltest_mapviewoffile_test1 coreclrpal)
 
 target_link_libraries(paltest_mapviewoffile_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test2/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test2/CMakeLists.txt
index 88f3344567..c24ade8ff6 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_mapviewoffile_test2
 add_dependencies(paltest_mapviewoffile_test2 coreclrpal)
 
 target_link_libraries(paltest_mapviewoffile_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test3/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test3/CMakeLists.txt
index e48ce13408..ce8ca02c40 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_mapviewoffile_test3
 add_dependencies(paltest_mapviewoffile_test3 coreclrpal)
 
 target_link_libraries(paltest_mapviewoffile_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test4/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test4/CMakeLists.txt
index 7f6d905212..29a0a1d8b9 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_mapviewoffile_test4
 add_dependencies(paltest_mapviewoffile_test4 coreclrpal)
 
 target_link_libraries(paltest_mapviewoffile_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test5/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test5/CMakeLists.txt
index 3911ffa53c..836a3c9612 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_mapviewoffile_test5
 add_dependencies(paltest_mapviewoffile_test5 coreclrpal)
 
 target_link_libraries(paltest_mapviewoffile_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test6/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test6/CMakeLists.txt
index 8199981eec..e3a7d09dfa 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/MapViewOfFile/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_mapviewoffile_test6
 add_dependencies(paltest_mapviewoffile_test6 coreclrpal)
 
 target_link_libraries(paltest_mapviewoffile_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingA/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingA/test1/CMakeLists.txt
index e4d87d5e0f..5f0362607d 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_openfilemappinga_test1
 add_dependencies(paltest_openfilemappinga_test1 coreclrpal)
 
 target_link_libraries(paltest_openfilemappinga_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingA/test2/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingA/test2/CMakeLists.txt
index 670346fe3b..f8c08e9c98 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingA/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingA/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_openfilemappinga_test2
 add_dependencies(paltest_openfilemappinga_test2 coreclrpal)
 
 target_link_libraries(paltest_openfilemappinga_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingA/test3/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingA/test3/CMakeLists.txt
index dab27b5c74..7357262e1c 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingA/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingA/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_openfilemappinga_test3
 add_dependencies(paltest_openfilemappinga_test3 coreclrpal)
 
 target_link_libraries(paltest_openfilemappinga_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingW/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingW/test1/CMakeLists.txt
index b2f4494ad8..25a6b4ca57 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_openfilemappingw_test1
 add_dependencies(paltest_openfilemappingw_test1 coreclrpal)
 
 target_link_libraries(paltest_openfilemappingw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingW/test2/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingW/test2/CMakeLists.txt
index 655fa753f2..f7ca6cf445 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_openfilemappingw_test2
 add_dependencies(paltest_openfilemappingw_test2 coreclrpal)
 
 target_link_libraries(paltest_openfilemappingw_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingW/test3/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingW/test3/CMakeLists.txt
index a7039a1c73..002ea05d02 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingW/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/OpenFileMappingW/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_openfilemappingw_test3
 add_dependencies(paltest_openfilemappingw_test3 coreclrpal)
 
 target_link_libraries(paltest_openfilemappingw_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/ProbeMemory/ProbeMemory_neg1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/ProbeMemory/ProbeMemory_neg1/CMakeLists.txt
index e96c92e2ae..cdd8be0267 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/ProbeMemory/ProbeMemory_neg1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/ProbeMemory/ProbeMemory_neg1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_probememory_probememory_neg1
 add_dependencies(paltest_probememory_probememory_neg1 coreclrpal)
 
 target_link_libraries(paltest_probememory_probememory_neg1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/ProbeMemory/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/ProbeMemory/test1/CMakeLists.txt
index 739ba62284..8103b1ecbc 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/ProbeMemory/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/ProbeMemory/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_probememory_test1
 add_dependencies(paltest_probememory_test1 coreclrpal)
 
 target_link_libraries(paltest_probememory_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/RtlMoveMemory/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/RtlMoveMemory/test1/CMakeLists.txt
index 8aa1c80368..12aba80d0a 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/RtlMoveMemory/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/RtlMoveMemory/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_rtlmovememory_test1
 add_dependencies(paltest_rtlmovememory_test1 coreclrpal)
 
 target_link_libraries(paltest_rtlmovememory_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/RtlMoveMemory/test3/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/RtlMoveMemory/test3/CMakeLists.txt
index d292cff494..3773cb79cd 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/RtlMoveMemory/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/RtlMoveMemory/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_rtlmovememory_test3
 add_dependencies(paltest_rtlmovememory_test3 coreclrpal)
 
 target_link_libraries(paltest_rtlmovememory_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/RtlMoveMemory/test4/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/RtlMoveMemory/test4/CMakeLists.txt
index e8aeb0c0b3..0b4414b08b 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/RtlMoveMemory/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/RtlMoveMemory/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_rtlmovememory_test4
 add_dependencies(paltest_rtlmovememory_test4 coreclrpal)
 
 target_link_libraries(paltest_rtlmovememory_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/RtlMoveMemory/test5/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/RtlMoveMemory/test5/CMakeLists.txt
index 7f4986eb27..f3c38f2e6a 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/RtlMoveMemory/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/RtlMoveMemory/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_rtlmovememory_test5
 add_dependencies(paltest_rtlmovememory_test5 coreclrpal)
 
 target_link_libraries(paltest_rtlmovememory_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/UnlockFile/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/UnlockFile/test1/CMakeLists.txt
index 8ed46bae43..58b0329d0d 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/UnlockFile/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/UnlockFile/test1/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_unlockfile_test1
 add_dependencies(paltest_unlockfile_test1 coreclrpal)
 
 target_link_libraries(paltest_unlockfile_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_unlockfile_test1_helper
 add_dependencies(paltest_unlockfile_test1_helper coreclrpal)
 
 target_link_libraries(paltest_unlockfile_test1_helper
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
\ No newline at end of file
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/UnlockFile/test2/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/UnlockFile/test2/CMakeLists.txt
index 3033876f80..251d21ba65 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/UnlockFile/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/UnlockFile/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_unlockfile_test2
 add_dependencies(paltest_unlockfile_test2 coreclrpal)
 
 target_link_libraries(paltest_unlockfile_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/UnlockFile/test3/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/UnlockFile/test3/CMakeLists.txt
index d46d7db344..980a9b0f75 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/UnlockFile/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/UnlockFile/test3/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_unlockfile_test3
 add_dependencies(paltest_unlockfile_test3 coreclrpal)
 
 target_link_libraries(paltest_unlockfile_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_unlockfile_test3_helper
 add_dependencies(paltest_unlockfile_test3_helper coreclrpal)
 
 target_link_libraries(paltest_unlockfile_test3_helper
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/UnlockFile/test4/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/UnlockFile/test4/CMakeLists.txt
index 635a1ca07c..e721b04b6c 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/UnlockFile/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/UnlockFile/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_unlockfile_test4
 add_dependencies(paltest_unlockfile_test4 coreclrpal)
 
 target_link_libraries(paltest_unlockfile_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/UnmapViewOfFile/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/UnmapViewOfFile/test1/CMakeLists.txt
index 1b8062ff9c..f2402bee8d 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/UnmapViewOfFile/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/UnmapViewOfFile/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_unmapviewoffile_test1
 add_dependencies(paltest_unmapviewoffile_test1 coreclrpal)
 
 target_link_libraries(paltest_unmapviewoffile_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/UnmapViewOfFile/test2/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/UnmapViewOfFile/test2/CMakeLists.txt
index 750e446a17..8aa842968f 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/UnmapViewOfFile/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/UnmapViewOfFile/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_unmapviewoffile_test2
 add_dependencies(paltest_unmapviewoffile_test2 coreclrpal)
 
 target_link_libraries(paltest_unmapviewoffile_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test1/CMakeLists.txt
index f8c0645a4b..9fe73ac005 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test1
 add_dependencies(paltest_virtualalloc_test1 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test10/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test10/CMakeLists.txt
index 1b66f0d7cb..6ccecb60b5 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test10/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test10/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test10
 add_dependencies(paltest_virtualalloc_test10 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test10
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test11/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test11/CMakeLists.txt
index 95e1a06f55..fe848f0c48 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test11/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test11/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test11
 add_dependencies(paltest_virtualalloc_test11 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test11
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test12/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test12/CMakeLists.txt
index 7564f960fe..dc59a294a9 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test12/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test12/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test12
 add_dependencies(paltest_virtualalloc_test12 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test12
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test13/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test13/CMakeLists.txt
index a49dcfc81d..04cf162f39 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test13/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test13/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test13
 add_dependencies(paltest_virtualalloc_test13 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test13
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test14/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test14/CMakeLists.txt
index 180a48e74d..0f18f9722b 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test14/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test14/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test14
 add_dependencies(paltest_virtualalloc_test14 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test14
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test15/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test15/CMakeLists.txt
index 4ba219472e..56f8be6529 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test15/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test15/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test15
 add_dependencies(paltest_virtualalloc_test15 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test15
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test16/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test16/CMakeLists.txt
index 1c5f63dce5..9b00d20d8b 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test16/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test16/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test16
 add_dependencies(paltest_virtualalloc_test16 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test16
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test17/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test17/CMakeLists.txt
index 6523bb9292..07be5b3d37 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test17/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test17/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test17
 add_dependencies(paltest_virtualalloc_test17 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test17
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test18/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test18/CMakeLists.txt
index 3fe65b4ac8..b6196846c2 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test18/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test18/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test18
 add_dependencies(paltest_virtualalloc_test18 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test18
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test19/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test19/CMakeLists.txt
index 1795b8ba54..27690a2ebe 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test19/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test19/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test19
 add_dependencies(paltest_virtualalloc_test19 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test19
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test2/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test2/CMakeLists.txt
index 20da178bfc..8637ef84e8 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test2
 add_dependencies(paltest_virtualalloc_test2 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test20/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test20/CMakeLists.txt
index 5c23fe2b0d..83cadbe3d7 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test20/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test20/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test20
 add_dependencies(paltest_virtualalloc_test20 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test20
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test21/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test21/CMakeLists.txt
index 96a3144e8a..437e06435e 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test21/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test21/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test21
 add_dependencies(paltest_virtualalloc_test21 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test21
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test22/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test22/CMakeLists.txt
index cdad2ca19d..7c6cf0c881 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test22/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test22/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test22
 add_dependencies(paltest_virtualalloc_test22 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test22
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test3/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test3/CMakeLists.txt
index 77822f7862..8ca013c6a5 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test3
 add_dependencies(paltest_virtualalloc_test3 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test4/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test4/CMakeLists.txt
index 0e2c448659..3c6c689208 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test4
 add_dependencies(paltest_virtualalloc_test4 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test5/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test5/CMakeLists.txt
index 247053ff0f..5646ec57b9 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test5
 add_dependencies(paltest_virtualalloc_test5 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test6/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test6/CMakeLists.txt
index d19391d294..1dbadc95af 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test6
 add_dependencies(paltest_virtualalloc_test6 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test7/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test7/CMakeLists.txt
index 8c01e041de..e4ccebf5ac 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test7
 add_dependencies(paltest_virtualalloc_test7 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test8/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test8/CMakeLists.txt
index db2a7447be..e94e081223 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test8/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test8/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test8
 add_dependencies(paltest_virtualalloc_test8 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test8
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test9/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test9/CMakeLists.txt
index 254fc6fcf2..7639adfc9d 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test9/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualAlloc/test9/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualalloc_test9
 add_dependencies(paltest_virtualalloc_test9 coreclrpal)
 
 target_link_libraries(paltest_virtualalloc_test9
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualFree/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualFree/test1/CMakeLists.txt
index d2319506f2..e16a7ff408 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualFree/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualFree/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualfree_test1
 add_dependencies(paltest_virtualfree_test1 coreclrpal)
 
 target_link_libraries(paltest_virtualfree_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualFree/test2/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualFree/test2/CMakeLists.txt
index 9a3bc7ac61..576dc05d10 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualFree/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualFree/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualfree_test2
 add_dependencies(paltest_virtualfree_test2 coreclrpal)
 
 target_link_libraries(paltest_virtualfree_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualFree/test3/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualFree/test3/CMakeLists.txt
index 8484c0fd94..b56ed07140 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualFree/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualFree/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualfree_test3
 add_dependencies(paltest_virtualfree_test3 coreclrpal)
 
 target_link_libraries(paltest_virtualfree_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test1/CMakeLists.txt
index 4283398a6f..2e3d26c744 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualprotect_test1
 add_dependencies(paltest_virtualprotect_test1 coreclrpal)
 
 target_link_libraries(paltest_virtualprotect_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test2/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test2/CMakeLists.txt
index aed68fd27f..4064bb5ecb 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualprotect_test2
 add_dependencies(paltest_virtualprotect_test2 coreclrpal)
 
 target_link_libraries(paltest_virtualprotect_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test3/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test3/CMakeLists.txt
index 70728592ad..11347b92e7 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualprotect_test3
 add_dependencies(paltest_virtualprotect_test3 coreclrpal)
 
 target_link_libraries(paltest_virtualprotect_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test4/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test4/CMakeLists.txt
index 5ad64a74eb..ed891093f8 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualprotect_test4
 add_dependencies(paltest_virtualprotect_test4 coreclrpal)
 
 target_link_libraries(paltest_virtualprotect_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test6/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test6/CMakeLists.txt
index 78932ef453..5fc3da928b 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualprotect_test6
 add_dependencies(paltest_virtualprotect_test6 coreclrpal)
 
 target_link_libraries(paltest_virtualprotect_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test7/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test7/CMakeLists.txt
index caf5ef91f4..8f47e60298 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualProtect/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualprotect_test7
 add_dependencies(paltest_virtualprotect_test7 coreclrpal)
 
 target_link_libraries(paltest_virtualprotect_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/filemapping_memmgt/VirtualQuery/test1/CMakeLists.txt b/src/pal/tests/palsuite/filemapping_memmgt/VirtualQuery/test1/CMakeLists.txt
index 17cbdee4a5..16ec598f3d 100644
--- a/src/pal/tests/palsuite/filemapping_memmgt/VirtualQuery/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/filemapping_memmgt/VirtualQuery/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_virtualquery_test1
 add_dependencies(paltest_virtualquery_test1 coreclrpal)
 
 target_link_libraries(paltest_virtualquery_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/loader/LoadLibraryA/test1/CMakeLists.txt b/src/pal/tests/palsuite/loader/LoadLibraryA/test1/CMakeLists.txt
index 62b896df65..319dcab325 100644
--- a/src/pal/tests/palsuite/loader/LoadLibraryA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/loader/LoadLibraryA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_loadlibrarya_test1
 add_dependencies(paltest_loadlibrarya_test1 coreclrpal)
 
 target_link_libraries(paltest_loadlibrarya_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/loader/LoadLibraryA/test2/CMakeLists.txt b/src/pal/tests/palsuite/loader/LoadLibraryA/test2/CMakeLists.txt
index 48a4c36cd0..e82b88a47f 100644
--- a/src/pal/tests/palsuite/loader/LoadLibraryA/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/loader/LoadLibraryA/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_loadlibrarya_test2
 add_dependencies(paltest_loadlibrarya_test2 coreclrpal)
 
 target_link_libraries(paltest_loadlibrarya_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/loader/LoadLibraryA/test3/CMakeLists.txt b/src/pal/tests/palsuite/loader/LoadLibraryA/test3/CMakeLists.txt
index ae05b3560d..084dcbc5f5 100644
--- a/src/pal/tests/palsuite/loader/LoadLibraryA/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/loader/LoadLibraryA/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_loadlibrarya_test3
 add_dependencies(paltest_loadlibrarya_test3 coreclrpal)
 
 target_link_libraries(paltest_loadlibrarya_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/loader/LoadLibraryA/test5/CMakeLists.txt b/src/pal/tests/palsuite/loader/LoadLibraryA/test5/CMakeLists.txt
index 99915eea2c..7555d26ef8 100644
--- a/src/pal/tests/palsuite/loader/LoadLibraryA/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/loader/LoadLibraryA/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_loadlibrarya_test5
 add_dependencies(paltest_loadlibrarya_test5 coreclrpal)
 
 target_link_libraries(paltest_loadlibrarya_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/loader/LoadLibraryA/test6/CMakeLists.txt b/src/pal/tests/palsuite/loader/LoadLibraryA/test6/CMakeLists.txt
index 0fac8785a8..c256ff567f 100644
--- a/src/pal/tests/palsuite/loader/LoadLibraryA/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/loader/LoadLibraryA/test6/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_loadlibrarya_test6
 add_dependencies(paltest_loadlibrarya_test6 coreclrpal)
 
 target_link_libraries(paltest_loadlibrarya_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_loadlibrarya_test6_dlltest
 add_dependencies(paltest_loadlibrarya_test6_dlltest coreclrpal)
 
 target_link_libraries(paltest_loadlibrarya_test6_dlltest
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/loader/LoadLibraryA/test7/CMakeLists.txt b/src/pal/tests/palsuite/loader/LoadLibraryA/test7/CMakeLists.txt
index bb403c6466..154f26f6f6 100644
--- a/src/pal/tests/palsuite/loader/LoadLibraryA/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/loader/LoadLibraryA/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_loadlibrarya_test7
 add_dependencies(paltest_loadlibrarya_test7 coreclrpal)
 
 target_link_libraries(paltest_loadlibrarya_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/loader/LoadLibraryA/test8/CMakeLists.txt b/src/pal/tests/palsuite/loader/LoadLibraryA/test8/CMakeLists.txt
index 9e3449166b..2bdbfb5705 100644
--- a/src/pal/tests/palsuite/loader/LoadLibraryA/test8/CMakeLists.txt
+++ b/src/pal/tests/palsuite/loader/LoadLibraryA/test8/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_loadlibrarya_test8
 add_dependencies(paltest_loadlibrarya_test8 coreclrpal)
 
 target_link_libraries(paltest_loadlibrarya_test8
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_loadlibrarya_test8_dlltest
 add_dependencies(paltest_loadlibrarya_test8_dlltest coreclrpal)
 
 target_link_libraries(paltest_loadlibrarya_test8_dlltest
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/loader/LoadLibraryW/test1/CMakeLists.txt b/src/pal/tests/palsuite/loader/LoadLibraryW/test1/CMakeLists.txt
index 171d1d59d4..569f6f7921 100644
--- a/src/pal/tests/palsuite/loader/LoadLibraryW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/loader/LoadLibraryW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_loadlibraryw_test1
 add_dependencies(paltest_loadlibraryw_test1 coreclrpal)
 
 target_link_libraries(paltest_loadlibraryw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/loader/LoadLibraryW/test2/CMakeLists.txt b/src/pal/tests/palsuite/loader/LoadLibraryW/test2/CMakeLists.txt
index 9873e1332d..e37f19a45c 100644
--- a/src/pal/tests/palsuite/loader/LoadLibraryW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/loader/LoadLibraryW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_loadlibraryw_test2
 add_dependencies(paltest_loadlibraryw_test2 coreclrpal)
 
 target_link_libraries(paltest_loadlibraryw_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/loader/LoadLibraryW/test3/CMakeLists.txt b/src/pal/tests/palsuite/loader/LoadLibraryW/test3/CMakeLists.txt
index be758643fa..73638dd626 100644
--- a/src/pal/tests/palsuite/loader/LoadLibraryW/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/loader/LoadLibraryW/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_loadlibraryw_test3
 add_dependencies(paltest_loadlibraryw_test3 coreclrpal)
 
 target_link_libraries(paltest_loadlibraryw_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/loader/LoadLibraryW/test5/CMakeLists.txt b/src/pal/tests/palsuite/loader/LoadLibraryW/test5/CMakeLists.txt
index 1ca990b514..5ab178d878 100644
--- a/src/pal/tests/palsuite/loader/LoadLibraryW/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/loader/LoadLibraryW/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_loadlibraryw_test5
 add_dependencies(paltest_loadlibraryw_test5 coreclrpal)
 
 target_link_libraries(paltest_loadlibraryw_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/CompareStringA/test1/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/CompareStringA/test1/CMakeLists.txt
index 171d5b77e8..2ea8b71aee 100644
--- a/src/pal/tests/palsuite/locale_info/CompareStringA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/CompareStringA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_comparestringa_test1
 add_dependencies(paltest_comparestringa_test1 coreclrpal)
 
 target_link_libraries(paltest_comparestringa_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/CompareStringW/test1/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/CompareStringW/test1/CMakeLists.txt
index 15a7fe7685..8f283a55db 100644
--- a/src/pal/tests/palsuite/locale_info/CompareStringW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/CompareStringW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_comparestringw_test1
 add_dependencies(paltest_comparestringw_test1 coreclrpal)
 
 target_link_libraries(paltest_comparestringw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/GetACP/test1/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/GetACP/test1/CMakeLists.txt
index cf4431ea94..be766d7e8e 100644
--- a/src/pal/tests/palsuite/locale_info/GetACP/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/GetACP/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getacp_test1
 add_dependencies(paltest_getacp_test1 coreclrpal)
 
 target_link_libraries(paltest_getacp_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/GetCPInfo/test1/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/GetCPInfo/test1/CMakeLists.txt
index b4cf017c2b..e8c9077598 100644
--- a/src/pal/tests/palsuite/locale_info/GetCPInfo/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/GetCPInfo/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getcpinfo_test1
 add_dependencies(paltest_getcpinfo_test1 coreclrpal)
 
 target_link_libraries(paltest_getcpinfo_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/GetCPInfo/test2/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/GetCPInfo/test2/CMakeLists.txt
index b366f3ce8d..3ce744e942 100644
--- a/src/pal/tests/palsuite/locale_info/GetCPInfo/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/GetCPInfo/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getcpinfo_test2
 add_dependencies(paltest_getcpinfo_test2 coreclrpal)
 
 target_link_libraries(paltest_getcpinfo_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/GetCPInfo/test3/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/GetCPInfo/test3/CMakeLists.txt
index 032dd00290..fe17e33578 100644
--- a/src/pal/tests/palsuite/locale_info/GetCPInfo/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/GetCPInfo/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getcpinfo_test3
 add_dependencies(paltest_getcpinfo_test3 coreclrpal)
 
 target_link_libraries(paltest_getcpinfo_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/GetLocaleInfoW/test1/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/GetLocaleInfoW/test1/CMakeLists.txt
index 4f685cb8a4..ea574a8bdb 100644
--- a/src/pal/tests/palsuite/locale_info/GetLocaleInfoW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/GetLocaleInfoW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getlocaleinfow_test1
 add_dependencies(paltest_getlocaleinfow_test1 coreclrpal)
 
 target_link_libraries(paltest_getlocaleinfow_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/GetLocaleInfoW/test2/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/GetLocaleInfoW/test2/CMakeLists.txt
index 7851b36b96..10d81bcad7 100644
--- a/src/pal/tests/palsuite/locale_info/GetLocaleInfoW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/GetLocaleInfoW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getlocaleinfow_test2
 add_dependencies(paltest_getlocaleinfow_test2 coreclrpal)
 
 target_link_libraries(paltest_getlocaleinfow_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/GetStringTypeExW/test1/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/GetStringTypeExW/test1/CMakeLists.txt
index e68621681a..9d6e4e2be8 100644
--- a/src/pal/tests/palsuite/locale_info/GetStringTypeExW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/GetStringTypeExW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getstringtypeexw_test1
 add_dependencies(paltest_getstringtypeexw_test1 coreclrpal)
 
 target_link_libraries(paltest_getstringtypeexw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/GetStringTypeExW/test2/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/GetStringTypeExW/test2/CMakeLists.txt
index e37b7495d0..7f90601ef9 100644
--- a/src/pal/tests/palsuite/locale_info/GetStringTypeExW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/GetStringTypeExW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getstringtypeexw_test2
 add_dependencies(paltest_getstringtypeexw_test2 coreclrpal)
 
 target_link_libraries(paltest_getstringtypeexw_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/GetSystemDefaultLangID/test1/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/GetSystemDefaultLangID/test1/CMakeLists.txt
index e34e1837e0..acbe40d847 100644
--- a/src/pal/tests/palsuite/locale_info/GetSystemDefaultLangID/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/GetSystemDefaultLangID/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getsystemdefaultlangid_test1
 add_dependencies(paltest_getsystemdefaultlangid_test1 coreclrpal)
 
 target_link_libraries(paltest_getsystemdefaultlangid_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/GetThreadLocale/test1/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/GetThreadLocale/test1/CMakeLists.txt
index 8abbd822c2..b6d0f270d8 100644
--- a/src/pal/tests/palsuite/locale_info/GetThreadLocale/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/GetThreadLocale/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getthreadlocale_test1
 add_dependencies(paltest_getthreadlocale_test1 coreclrpal)
 
 target_link_libraries(paltest_getthreadlocale_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/GetTimeZoneInformation/test1/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/GetTimeZoneInformation/test1/CMakeLists.txt
index 8bf0a6ca23..d62a4c22aa 100644
--- a/src/pal/tests/palsuite/locale_info/GetTimeZoneInformation/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/GetTimeZoneInformation/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_gettimezoneinformation_test1
 add_dependencies(paltest_gettimezoneinformation_test1 coreclrpal)
 
 target_link_libraries(paltest_gettimezoneinformation_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/GetUserDefaultLCID/test1/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/GetUserDefaultLCID/test1/CMakeLists.txt
index b6f08b1f7d..256d818778 100644
--- a/src/pal/tests/palsuite/locale_info/GetUserDefaultLCID/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/GetUserDefaultLCID/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getuserdefaultlcid_test1
 add_dependencies(paltest_getuserdefaultlcid_test1 coreclrpal)
 
 target_link_libraries(paltest_getuserdefaultlcid_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/GetUserDefaultLangID/test1/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/GetUserDefaultLangID/test1/CMakeLists.txt
index 8fc795a52b..ac3c78a2bd 100644
--- a/src/pal/tests/palsuite/locale_info/GetUserDefaultLangID/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/GetUserDefaultLangID/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getuserdefaultlangid_test1
 add_dependencies(paltest_getuserdefaultlangid_test1 coreclrpal)
 
 target_link_libraries(paltest_getuserdefaultlangid_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/IsDBCSLeadByte/test1/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/IsDBCSLeadByte/test1/CMakeLists.txt
index e9b22dcfc5..2264d3e8f7 100644
--- a/src/pal/tests/palsuite/locale_info/IsDBCSLeadByte/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/IsDBCSLeadByte/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_isdbcsleadbyte_test1
 add_dependencies(paltest_isdbcsleadbyte_test1 coreclrpal)
 
 target_link_libraries(paltest_isdbcsleadbyte_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/IsDBCSLeadByteEx/test1/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/IsDBCSLeadByteEx/test1/CMakeLists.txt
index f3a232b143..3109b71737 100644
--- a/src/pal/tests/palsuite/locale_info/IsDBCSLeadByteEx/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/IsDBCSLeadByteEx/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_isdbcsleadbyteex_test1
 add_dependencies(paltest_isdbcsleadbyteex_test1 coreclrpal)
 
 target_link_libraries(paltest_isdbcsleadbyteex_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/IsValidCodePage/test1/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/IsValidCodePage/test1/CMakeLists.txt
index ae12b37950..a90784818a 100644
--- a/src/pal/tests/palsuite/locale_info/IsValidCodePage/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/IsValidCodePage/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_isvalidcodepage_test1
 add_dependencies(paltest_isvalidcodepage_test1 coreclrpal)
 
 target_link_libraries(paltest_isvalidcodepage_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/IsValidCodePage/test2/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/IsValidCodePage/test2/CMakeLists.txt
index 6eeff25d4d..5cf6d4c7ae 100644
--- a/src/pal/tests/palsuite/locale_info/IsValidCodePage/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/IsValidCodePage/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_isvalidcodepage_test2
 add_dependencies(paltest_isvalidcodepage_test2 coreclrpal)
 
 target_link_libraries(paltest_isvalidcodepage_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/IsValidLocale/test1/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/IsValidLocale/test1/CMakeLists.txt
index 27d61693b0..f9e1c884a0 100644
--- a/src/pal/tests/palsuite/locale_info/IsValidLocale/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/IsValidLocale/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_isvalidlocale_test1
 add_dependencies(paltest_isvalidlocale_test1 coreclrpal)
 
 target_link_libraries(paltest_isvalidlocale_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/MultiByteToWideChar/test1/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/MultiByteToWideChar/test1/CMakeLists.txt
index 7bf79e36a7..f400843bd2 100644
--- a/src/pal/tests/palsuite/locale_info/MultiByteToWideChar/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/MultiByteToWideChar/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_multibytetowidechar_test1
 add_dependencies(paltest_multibytetowidechar_test1 coreclrpal)
 
 target_link_libraries(paltest_multibytetowidechar_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/MultiByteToWideChar/test2/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/MultiByteToWideChar/test2/CMakeLists.txt
index b3e3f64c5c..c51cfd6469 100644
--- a/src/pal/tests/palsuite/locale_info/MultiByteToWideChar/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/MultiByteToWideChar/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_multibytetowidechar_test2
 add_dependencies(paltest_multibytetowidechar_test2 coreclrpal)
 
 target_link_libraries(paltest_multibytetowidechar_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/MultiByteToWideChar/test3/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/MultiByteToWideChar/test3/CMakeLists.txt
index c6eac9bd60..386425f90f 100644
--- a/src/pal/tests/palsuite/locale_info/MultiByteToWideChar/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/MultiByteToWideChar/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_multibytetowidechar_test3
 add_dependencies(paltest_multibytetowidechar_test3 coreclrpal)
 
 target_link_libraries(paltest_multibytetowidechar_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/MultiByteToWideChar/test4/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/MultiByteToWideChar/test4/CMakeLists.txt
index c9c92952f2..dc119abd08 100644
--- a/src/pal/tests/palsuite/locale_info/MultiByteToWideChar/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/MultiByteToWideChar/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_multibytetowidechar_test4
 add_dependencies(paltest_multibytetowidechar_test4 coreclrpal)
 
 target_link_libraries(paltest_multibytetowidechar_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
\ No newline at end of file
diff --git a/src/pal/tests/palsuite/locale_info/SetThreadLocale/test1/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/SetThreadLocale/test1/CMakeLists.txt
index 5ac7433c98..7b0cde4a14 100644
--- a/src/pal/tests/palsuite/locale_info/SetThreadLocale/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/SetThreadLocale/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setthreadlocale_test1
 add_dependencies(paltest_setthreadlocale_test1 coreclrpal)
 
 target_link_libraries(paltest_setthreadlocale_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/WideCharToMultiByte/test1/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/WideCharToMultiByte/test1/CMakeLists.txt
index 07dae640f1..913cccc8e1 100644
--- a/src/pal/tests/palsuite/locale_info/WideCharToMultiByte/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/WideCharToMultiByte/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_widechartomultibyte_test1
 add_dependencies(paltest_widechartomultibyte_test1 coreclrpal)
 
 target_link_libraries(paltest_widechartomultibyte_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/WideCharToMultiByte/test2/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/WideCharToMultiByte/test2/CMakeLists.txt
index 99c64afa2a..305348cd12 100644
--- a/src/pal/tests/palsuite/locale_info/WideCharToMultiByte/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/WideCharToMultiByte/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_widechartomultibyte_test2
 add_dependencies(paltest_widechartomultibyte_test2 coreclrpal)
 
 target_link_libraries(paltest_widechartomultibyte_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/WideCharToMultiByte/test3/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/WideCharToMultiByte/test3/CMakeLists.txt
index 70dabead6f..f5a8bf9774 100644
--- a/src/pal/tests/palsuite/locale_info/WideCharToMultiByte/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/WideCharToMultiByte/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_widechartomultibyte_test3
 add_dependencies(paltest_widechartomultibyte_test3 coreclrpal)
 
 target_link_libraries(paltest_widechartomultibyte_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/WideCharToMultiByte/test4/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/WideCharToMultiByte/test4/CMakeLists.txt
index 8839c19183..bea8e1aacf 100644
--- a/src/pal/tests/palsuite/locale_info/WideCharToMultiByte/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/WideCharToMultiByte/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_widechartomultibyte_test4
 add_dependencies(paltest_widechartomultibyte_test4 coreclrpal)
 
 target_link_libraries(paltest_widechartomultibyte_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/locale_info/WideCharToMultiByte/test5/CMakeLists.txt b/src/pal/tests/palsuite/locale_info/WideCharToMultiByte/test5/CMakeLists.txt
index e00657879d..51851e45d6 100644
--- a/src/pal/tests/palsuite/locale_info/WideCharToMultiByte/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/locale_info/WideCharToMultiByte/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_widechartomultibyte_test5
 add_dependencies(paltest_widechartomultibyte_test5 coreclrpal)
 
 target_link_libraries(paltest_widechartomultibyte_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
\ No newline at end of file
diff --git a/src/pal/tests/palsuite/miscellaneous/CharNextA/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/CharNextA/test1/CMakeLists.txt
index 23df52b430..aa7abfbee7 100644
--- a/src/pal/tests/palsuite/miscellaneous/CharNextA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/CharNextA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_charnexta_test1
 add_dependencies(paltest_charnexta_test1 coreclrpal)
 
 target_link_libraries(paltest_charnexta_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/CharNextA/test2/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/CharNextA/test2/CMakeLists.txt
index 5f089e963c..3339e097d0 100644
--- a/src/pal/tests/palsuite/miscellaneous/CharNextA/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/CharNextA/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_charnexta_test2
 add_dependencies(paltest_charnexta_test2 coreclrpal)
 
 target_link_libraries(paltest_charnexta_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/CharNextExA/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/CharNextExA/test1/CMakeLists.txt
index ae1433f089..959a661b7a 100644
--- a/src/pal/tests/palsuite/miscellaneous/CharNextExA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/CharNextExA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_charnextexa_test1
 add_dependencies(paltest_charnextexa_test1 coreclrpal)
 
 target_link_libraries(paltest_charnextexa_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/CharNextExA/test2/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/CharNextExA/test2/CMakeLists.txt
index 1c81d1f9a4..7c0427127c 100644
--- a/src/pal/tests/palsuite/miscellaneous/CharNextExA/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/CharNextExA/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_charnextexa_test2
 add_dependencies(paltest_charnextexa_test2 coreclrpal)
 
 target_link_libraries(paltest_charnextexa_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/CloseHandle/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/CloseHandle/test1/CMakeLists.txt
index 78bb701959..f35d6fb10e 100644
--- a/src/pal/tests/palsuite/miscellaneous/CloseHandle/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/CloseHandle/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_closehandle_test1
 add_dependencies(paltest_closehandle_test1 coreclrpal)
 
 target_link_libraries(paltest_closehandle_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/CloseHandle/test2/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/CloseHandle/test2/CMakeLists.txt
index 18350f20ad..691d44b82a 100644
--- a/src/pal/tests/palsuite/miscellaneous/CloseHandle/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/CloseHandle/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_closehandle_test2
 add_dependencies(paltest_closehandle_test2 coreclrpal)
 
 target_link_libraries(paltest_closehandle_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/CreatePipe/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/CreatePipe/test1/CMakeLists.txt
index 15a0f572bb..494c948aba 100644
--- a/src/pal/tests/palsuite/miscellaneous/CreatePipe/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/CreatePipe/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createpipe_test1
 add_dependencies(paltest_createpipe_test1 coreclrpal)
 
 target_link_libraries(paltest_createpipe_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/FlushInstructionCache/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/FlushInstructionCache/test1/CMakeLists.txt
index 47ee4b0abd..57b925c8a7 100644
--- a/src/pal/tests/palsuite/miscellaneous/FlushInstructionCache/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/FlushInstructionCache/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_flushinstructioncache_test1
 add_dependencies(paltest_flushinstructioncache_test1 coreclrpal)
 
 target_link_libraries(paltest_flushinstructioncache_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test1/CMakeLists.txt
index df91482855..f0e366ec86 100644
--- a/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_formatmessagew_test1
 add_dependencies(paltest_formatmessagew_test1 coreclrpal)
 
 target_link_libraries(paltest_formatmessagew_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test2/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test2/CMakeLists.txt
index 818649aac7..564830acdf 100644
--- a/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_formatmessagew_test2
 add_dependencies(paltest_formatmessagew_test2 coreclrpal)
 
 target_link_libraries(paltest_formatmessagew_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test3/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test3/CMakeLists.txt
index 516d4bcc9a..70b039bf03 100644
--- a/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_formatmessagew_test3
 add_dependencies(paltest_formatmessagew_test3 coreclrpal)
 
 target_link_libraries(paltest_formatmessagew_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test4/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test4/CMakeLists.txt
index 642727c6dc..c4ecccf7d0 100644
--- a/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_formatmessagew_test4
 add_dependencies(paltest_formatmessagew_test4 coreclrpal)
 
 target_link_libraries(paltest_formatmessagew_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test5/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test5/CMakeLists.txt
index bae113475d..2d4e2a2c44 100644
--- a/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_formatmessagew_test5
 add_dependencies(paltest_formatmessagew_test5 coreclrpal)
 
 target_link_libraries(paltest_formatmessagew_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test6/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test6/CMakeLists.txt
index f403cba0f4..33ca130e26 100644
--- a/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/FormatMessageW/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_formatmessagew_test6
 add_dependencies(paltest_formatmessagew_test6 coreclrpal)
 
 target_link_libraries(paltest_formatmessagew_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/FreeEnvironmentStringsW/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/FreeEnvironmentStringsW/test1/CMakeLists.txt
index 206707efa6..081df32533 100644
--- a/src/pal/tests/palsuite/miscellaneous/FreeEnvironmentStringsW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/FreeEnvironmentStringsW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_freeenvironmentstringsw_test1
 add_dependencies(paltest_freeenvironmentstringsw_test1 coreclrpal)
 
 target_link_libraries(paltest_freeenvironmentstringsw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/FreeEnvironmentStringsW/test2/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/FreeEnvironmentStringsW/test2/CMakeLists.txt
index d8197d1c90..7a69e103fa 100644
--- a/src/pal/tests/palsuite/miscellaneous/FreeEnvironmentStringsW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/FreeEnvironmentStringsW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_freeenvironmentstringsw_test2
 add_dependencies(paltest_freeenvironmentstringsw_test2 coreclrpal)
 
 target_link_libraries(paltest_freeenvironmentstringsw_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetCalendarInfoW/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetCalendarInfoW/test1/CMakeLists.txt
index 92cabba428..11c278015c 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetCalendarInfoW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetCalendarInfoW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getcalendarinfow_test1
 add_dependencies(paltest_getcalendarinfow_test1 coreclrpal)
 
 target_link_libraries(paltest_getcalendarinfow_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetCalendarInfoW/test2/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetCalendarInfoW/test2/CMakeLists.txt
index 0cfc9679e7..2abf2901c0 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetCalendarInfoW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetCalendarInfoW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getcalendarinfow_test2
 add_dependencies(paltest_getcalendarinfow_test2 coreclrpal)
 
 target_link_libraries(paltest_getcalendarinfow_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetCommandLineW/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetCommandLineW/test1/CMakeLists.txt
index d15b84a59e..6d00bf85c3 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetCommandLineW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetCommandLineW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getcommandlinew_test1
 add_dependencies(paltest_getcommandlinew_test1 coreclrpal)
 
 target_link_libraries(paltest_getcommandlinew_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetComputerNameW/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetComputerNameW/test1/CMakeLists.txt
index 0ce9ac07b7..fe5b72071e 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetComputerNameW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetComputerNameW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getcomputernamew_test1
 add_dependencies(paltest_getcomputernamew_test1 coreclrpal)
 
 target_link_libraries(paltest_getcomputernamew_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetDateFormatW/GetDateFormatW_neg1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetDateFormatW/GetDateFormatW_neg1/CMakeLists.txt
index 04ef85b74d..9d9512ce78 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetDateFormatW/GetDateFormatW_neg1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetDateFormatW/GetDateFormatW_neg1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getdateformatw_getdateformatw_neg1
 add_dependencies(paltest_getdateformatw_getdateformatw_neg1 coreclrpal)
 
 target_link_libraries(paltest_getdateformatw_getdateformatw_neg1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetDateFormatW/GetDateFormatW_neg2/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetDateFormatW/GetDateFormatW_neg2/CMakeLists.txt
index fcd56fc7f2..dc4215ea57 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetDateFormatW/GetDateFormatW_neg2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetDateFormatW/GetDateFormatW_neg2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getdateformatw_getdateformatw_neg2
 add_dependencies(paltest_getdateformatw_getdateformatw_neg2 coreclrpal)
 
 target_link_libraries(paltest_getdateformatw_getdateformatw_neg2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetDateFormatW/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetDateFormatW/test1/CMakeLists.txt
index bd86370611..b392d02ca4 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetDateFormatW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetDateFormatW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getdateformatw_test1
 add_dependencies(paltest_getdateformatw_test1 coreclrpal)
 
 target_link_libraries(paltest_getdateformatw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentStringsW/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentStringsW/test1/CMakeLists.txt
index 3a745fdbd3..378390b150 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentStringsW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentStringsW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getenvironmentstringsw_test1
 add_dependencies(paltest_getenvironmentstringsw_test1 coreclrpal)
 
 target_link_libraries(paltest_getenvironmentstringsw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test1/CMakeLists.txt
index 0721fd60b7..2af3c9de8a 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getenvironmentvariablea_test1
 add_dependencies(paltest_getenvironmentvariablea_test1 coreclrpal)
 
 target_link_libraries(paltest_getenvironmentvariablea_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test2/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test2/CMakeLists.txt
index a9be983369..64da266af2 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getenvironmentvariablea_test2
 add_dependencies(paltest_getenvironmentvariablea_test2 coreclrpal)
 
 target_link_libraries(paltest_getenvironmentvariablea_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test3/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test3/CMakeLists.txt
index 1c35eba54d..65ff937365 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getenvironmentvariablea_test3
 add_dependencies(paltest_getenvironmentvariablea_test3 coreclrpal)
 
 target_link_libraries(paltest_getenvironmentvariablea_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test4/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test4/CMakeLists.txt
index 331ea8ca6b..df7697beff 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getenvironmentvariablea_test4
 add_dependencies(paltest_getenvironmentvariablea_test4 coreclrpal)
 
 target_link_libraries(paltest_getenvironmentvariablea_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test5/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test5/CMakeLists.txt
index 69bedf4947..8e6e26363e 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getenvironmentvariablea_test5
 add_dependencies(paltest_getenvironmentvariablea_test5 coreclrpal)
 
 target_link_libraries(paltest_getenvironmentvariablea_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test6/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test6/CMakeLists.txt
index 38c186740f..ac25f769fd 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableA/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getenvironmentvariablea_test6
 add_dependencies(paltest_getenvironmentvariablea_test6 coreclrpal)
 
 target_link_libraries(paltest_getenvironmentvariablea_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test1/CMakeLists.txt
index a3cb878ef4..e87cbf4da0 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getenvironmentvariablew_test1
 add_dependencies(paltest_getenvironmentvariablew_test1 coreclrpal)
 
 target_link_libraries(paltest_getenvironmentvariablew_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test2/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test2/CMakeLists.txt
index 2c6ec6247e..2e6f61a4ba 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getenvironmentvariablew_test2
 add_dependencies(paltest_getenvironmentvariablew_test2 coreclrpal)
 
 target_link_libraries(paltest_getenvironmentvariablew_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test3/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test3/CMakeLists.txt
index 6af382b6cd..70151c419d 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getenvironmentvariablew_test3
 add_dependencies(paltest_getenvironmentvariablew_test3 coreclrpal)
 
 target_link_libraries(paltest_getenvironmentvariablew_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test4/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test4/CMakeLists.txt
index 674b187fa7..56de6a1cc2 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getenvironmentvariablew_test4
 add_dependencies(paltest_getenvironmentvariablew_test4 coreclrpal)
 
 target_link_libraries(paltest_getenvironmentvariablew_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test5/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test5/CMakeLists.txt
index 71e974703b..9d73780c97 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getenvironmentvariablew_test5
 add_dependencies(paltest_getenvironmentvariablew_test5 coreclrpal)
 
 target_link_libraries(paltest_getenvironmentvariablew_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test6/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test6/CMakeLists.txt
index 8771ab0cc8..f331a89742 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetEnvironmentVariableW/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getenvironmentvariablew_test6
 add_dependencies(paltest_getenvironmentvariablew_test6 coreclrpal)
 
 target_link_libraries(paltest_getenvironmentvariablew_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetLastError/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetLastError/test1/CMakeLists.txt
index 3c851c7260..1bf6407318 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetLastError/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetLastError/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getlasterror_test1
 add_dependencies(paltest_getlasterror_test1 coreclrpal)
 
 target_link_libraries(paltest_getlasterror_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetSystemInfo/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetSystemInfo/test1/CMakeLists.txt
index 9419517128..3fd07c4ded 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetSystemInfo/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetSystemInfo/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getsysteminfo_test1
 add_dependencies(paltest_getsysteminfo_test1 coreclrpal)
 
 target_link_libraries(paltest_getsysteminfo_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetTickCount/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetTickCount/test1/CMakeLists.txt
index f7be23bc0b..fcf7cb4c03 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetTickCount/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetTickCount/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_gettickcount_test1
 add_dependencies(paltest_gettickcount_test1 coreclrpal)
 
 target_link_libraries(paltest_gettickcount_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetUserNameW/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetUserNameW/test1/CMakeLists.txt
index 8ed7ace073..6527b83d13 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetUserNameW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetUserNameW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getusernamew_test1
 add_dependencies(paltest_getusernamew_test1 coreclrpal)
 
 target_link_libraries(paltest_getusernamew_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetVersionExA/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetVersionExA/test1/CMakeLists.txt
index 2cb305f22b..1e512f3c2f 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetVersionExA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetVersionExA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getversionexa_test1
 add_dependencies(paltest_getversionexa_test1 coreclrpal)
 
 target_link_libraries(paltest_getversionexa_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/GetVersionExW/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/GetVersionExW/test1/CMakeLists.txt
index 09494240cc..4ef820c479 100644
--- a/src/pal/tests/palsuite/miscellaneous/GetVersionExW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/GetVersionExW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getversionexw_test1
 add_dependencies(paltest_getversionexw_test1 coreclrpal)
 
 target_link_libraries(paltest_getversionexw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/InterLockedExchangeAdd/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/InterLockedExchangeAdd/test1/CMakeLists.txt
index e5ba709c11..47af14e0fc 100644
--- a/src/pal/tests/palsuite/miscellaneous/InterLockedExchangeAdd/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/InterLockedExchangeAdd/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_interlockedexchangeadd_test1
 add_dependencies(paltest_interlockedexchangeadd_test1 coreclrpal)
 
 target_link_libraries(paltest_interlockedexchangeadd_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/InterlockedBit/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/InterlockedBit/test1/CMakeLists.txt
index a70802ea2d..2fe88a3fad 100644
--- a/src/pal/tests/palsuite/miscellaneous/InterlockedBit/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/InterlockedBit/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_interlockedbit_test1
 add_dependencies(paltest_interlockedbit_test1 coreclrpal)
 
 target_link_libraries(paltest_interlockedbit_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/InterlockedBit/test2/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/InterlockedBit/test2/CMakeLists.txt
index 6b50a755fe..3a6854b84b 100644
--- a/src/pal/tests/palsuite/miscellaneous/InterlockedBit/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/InterlockedBit/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_interlockedbit_test2
 add_dependencies(paltest_interlockedbit_test2 coreclrpal)
 
 target_link_libraries(paltest_interlockedbit_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/InterlockedCompareExchange/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/InterlockedCompareExchange/test1/CMakeLists.txt
index d9e867256a..e62ba779dc 100644
--- a/src/pal/tests/palsuite/miscellaneous/InterlockedCompareExchange/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/InterlockedCompareExchange/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_interlockedcompareexchange_test1
 add_dependencies(paltest_interlockedcompareexchange_test1 coreclrpal)
 
 target_link_libraries(paltest_interlockedcompareexchange_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/InterlockedCompareExchange/test2/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/InterlockedCompareExchange/test2/CMakeLists.txt
index 038d375273..ef7d64f724 100644
--- a/src/pal/tests/palsuite/miscellaneous/InterlockedCompareExchange/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/InterlockedCompareExchange/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_interlockedcompareexchange_test2
 add_dependencies(paltest_interlockedcompareexchange_test2 coreclrpal)
 
 target_link_libraries(paltest_interlockedcompareexchange_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/InterlockedCompareExchange64/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/InterlockedCompareExchange64/test1/CMakeLists.txt
index 722603eb4a..7778acd397 100644
--- a/src/pal/tests/palsuite/miscellaneous/InterlockedCompareExchange64/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/InterlockedCompareExchange64/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_interlockedcompareexchange64_test1
 add_dependencies(paltest_interlockedcompareexchange64_test1 coreclrpal)
 
 target_link_libraries(paltest_interlockedcompareexchange64_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/InterlockedCompareExchange64/test2/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/InterlockedCompareExchange64/test2/CMakeLists.txt
index f052ca0b27..0f8e390ac5 100644
--- a/src/pal/tests/palsuite/miscellaneous/InterlockedCompareExchange64/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/InterlockedCompareExchange64/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_interlockedcompareexchange64_test2
 add_dependencies(paltest_interlockedcompareexchange64_test2 coreclrpal)
 
 target_link_libraries(paltest_interlockedcompareexchange64_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/InterlockedCompareExchangePointer/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/InterlockedCompareExchangePointer/test1/CMakeLists.txt
index 0c48c4e296..3bd17c20af 100644
--- a/src/pal/tests/palsuite/miscellaneous/InterlockedCompareExchangePointer/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/InterlockedCompareExchangePointer/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_interlockedcompareexchangepointer_test1
 add_dependencies(paltest_interlockedcompareexchangepointer_test1 coreclrpal)
 
 target_link_libraries(paltest_interlockedcompareexchangepointer_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/InterlockedDecrement/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/InterlockedDecrement/test1/CMakeLists.txt
index 6cd307d2e8..54004bc9a7 100644
--- a/src/pal/tests/palsuite/miscellaneous/InterlockedDecrement/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/InterlockedDecrement/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_interlockeddecrement_test1
 add_dependencies(paltest_interlockeddecrement_test1 coreclrpal)
 
 target_link_libraries(paltest_interlockeddecrement_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/InterlockedDecrement/test2/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/InterlockedDecrement/test2/CMakeLists.txt
index 331d89d5d6..cf049672ed 100644
--- a/src/pal/tests/palsuite/miscellaneous/InterlockedDecrement/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/InterlockedDecrement/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_interlockeddecrement_test2
 add_dependencies(paltest_interlockeddecrement_test2 coreclrpal)
 
 target_link_libraries(paltest_interlockeddecrement_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/InterlockedDecrement64/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/InterlockedDecrement64/test1/CMakeLists.txt
index 727a328d07..39476869bf 100644
--- a/src/pal/tests/palsuite/miscellaneous/InterlockedDecrement64/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/InterlockedDecrement64/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_interlockeddecrement64_test1
 add_dependencies(paltest_interlockeddecrement64_test1 coreclrpal)
 
 target_link_libraries(paltest_interlockeddecrement64_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/InterlockedDecrement64/test2/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/InterlockedDecrement64/test2/CMakeLists.txt
index ecea6399a7..0031928b52 100644
--- a/src/pal/tests/palsuite/miscellaneous/InterlockedDecrement64/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/InterlockedDecrement64/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_interlockeddecrement64_test2
 add_dependencies(paltest_interlockeddecrement64_test2 coreclrpal)
 
 target_link_libraries(paltest_interlockeddecrement64_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/InterlockedExchange/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/InterlockedExchange/test1/CMakeLists.txt
index a1a7f862ed..d6c0dbf883 100644
--- a/src/pal/tests/palsuite/miscellaneous/InterlockedExchange/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/InterlockedExchange/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_interlockedexchange_test1
 add_dependencies(paltest_interlockedexchange_test1 coreclrpal)
 
 target_link_libraries(paltest_interlockedexchange_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/InterlockedExchange64/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/InterlockedExchange64/test1/CMakeLists.txt
index 3f4cd5e058..5a3e8c4ff2 100644
--- a/src/pal/tests/palsuite/miscellaneous/InterlockedExchange64/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/InterlockedExchange64/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_interlockedexchange64_test1
 add_dependencies(paltest_interlockedexchange64_test1 coreclrpal)
 
 target_link_libraries(paltest_interlockedexchange64_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/InterlockedExchangePointer/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/InterlockedExchangePointer/test1/CMakeLists.txt
index b0858963a0..cbc30c1443 100644
--- a/src/pal/tests/palsuite/miscellaneous/InterlockedExchangePointer/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/InterlockedExchangePointer/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_interlockedexchangepointer_test1
 add_dependencies(paltest_interlockedexchangepointer_test1 coreclrpal)
 
 target_link_libraries(paltest_interlockedexchangepointer_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/InterlockedIncrement/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/InterlockedIncrement/test1/CMakeLists.txt
index f87dc72281..8689e5c379 100644
--- a/src/pal/tests/palsuite/miscellaneous/InterlockedIncrement/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/InterlockedIncrement/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_interlockedincrement_test1
 add_dependencies(paltest_interlockedincrement_test1 coreclrpal)
 
 target_link_libraries(paltest_interlockedincrement_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/InterlockedIncrement/test2/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/InterlockedIncrement/test2/CMakeLists.txt
index e8c5278cbc..049e0ed3f5 100644
--- a/src/pal/tests/palsuite/miscellaneous/InterlockedIncrement/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/InterlockedIncrement/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_interlockedincrement_test2
 add_dependencies(paltest_interlockedincrement_test2 coreclrpal)
 
 target_link_libraries(paltest_interlockedincrement_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/InterlockedIncrement64/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/InterlockedIncrement64/test1/CMakeLists.txt
index d7bec46d4e..0834e67b04 100644
--- a/src/pal/tests/palsuite/miscellaneous/InterlockedIncrement64/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/InterlockedIncrement64/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_interlockedincrement64_test1
 add_dependencies(paltest_interlockedincrement64_test1 coreclrpal)
 
 target_link_libraries(paltest_interlockedincrement64_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/InterlockedIncrement64/test2/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/InterlockedIncrement64/test2/CMakeLists.txt
index be571a535b..ec8e0684d7 100644
--- a/src/pal/tests/palsuite/miscellaneous/InterlockedIncrement64/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/InterlockedIncrement64/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_interlockedincrement64_test2
 add_dependencies(paltest_interlockedincrement64_test2 coreclrpal)
 
 target_link_libraries(paltest_interlockedincrement64_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/IsBadCodePtr/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/IsBadCodePtr/test1/CMakeLists.txt
index bc3f11b705..c712b24397 100644
--- a/src/pal/tests/palsuite/miscellaneous/IsBadCodePtr/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/IsBadCodePtr/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_isbadcodeptr_test1
 add_dependencies(paltest_isbadcodeptr_test1 coreclrpal)
 
 target_link_libraries(paltest_isbadcodeptr_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/IsBadReadPtr/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/IsBadReadPtr/test1/CMakeLists.txt
index 82aecefa70..db19d5bff8 100644
--- a/src/pal/tests/palsuite/miscellaneous/IsBadReadPtr/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/IsBadReadPtr/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_isbadreadptr_test1
 add_dependencies(paltest_isbadreadptr_test1 coreclrpal)
 
 target_link_libraries(paltest_isbadreadptr_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/IsBadWritePtr/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/IsBadWritePtr/test1/CMakeLists.txt
index e3a08167b3..89966056cf 100644
--- a/src/pal/tests/palsuite/miscellaneous/IsBadWritePtr/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/IsBadWritePtr/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_isbadwriteptr_test1
 add_dependencies(paltest_isbadwriteptr_test1 coreclrpal)
 
 target_link_libraries(paltest_isbadwriteptr_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/IsBadWritePtr/test2/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/IsBadWritePtr/test2/CMakeLists.txt
index 718cbaa297..ff0dbdce90 100644
--- a/src/pal/tests/palsuite/miscellaneous/IsBadWritePtr/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/IsBadWritePtr/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_isbadwriteptr_test2
 add_dependencies(paltest_isbadwriteptr_test2 coreclrpal)
 
 target_link_libraries(paltest_isbadwriteptr_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/IsBadWritePtr/test3/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/IsBadWritePtr/test3/CMakeLists.txt
index 0efd3179db..30a2de3004 100644
--- a/src/pal/tests/palsuite/miscellaneous/IsBadWritePtr/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/IsBadWritePtr/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_isbadwriteptr_test3
 add_dependencies(paltest_isbadwriteptr_test3 coreclrpal)
 
 target_link_libraries(paltest_isbadwriteptr_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/MessageBoxW/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/MessageBoxW/test1/CMakeLists.txt
index bc80853ea1..458b952662 100644
--- a/src/pal/tests/palsuite/miscellaneous/MessageBoxW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/MessageBoxW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_messageboxw_test1
 add_dependencies(paltest_messageboxw_test1 coreclrpal)
 
 target_link_libraries(paltest_messageboxw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/MessageBoxW/test2/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/MessageBoxW/test2/CMakeLists.txt
index b8993af4cf..d86d99c33c 100644
--- a/src/pal/tests/palsuite/miscellaneous/MessageBoxW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/MessageBoxW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_messageboxw_test2
 add_dependencies(paltest_messageboxw_test2 coreclrpal)
 
 target_link_libraries(paltest_messageboxw_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableA/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableA/test1/CMakeLists.txt
index 5d63281eab..19ae519356 100644
--- a/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setenvironmentvariablea_test1
 add_dependencies(paltest_setenvironmentvariablea_test1 coreclrpal)
 
 target_link_libraries(paltest_setenvironmentvariablea_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableA/test2/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableA/test2/CMakeLists.txt
index fe05887c3e..483d0302cb 100644
--- a/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableA/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableA/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setenvironmentvariablea_test2
 add_dependencies(paltest_setenvironmentvariablea_test2 coreclrpal)
 
 target_link_libraries(paltest_setenvironmentvariablea_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableA/test3/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableA/test3/CMakeLists.txt
index 98c9dc0a63..27c96d950e 100644
--- a/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableA/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableA/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setenvironmentvariablea_test3
 add_dependencies(paltest_setenvironmentvariablea_test3 coreclrpal)
 
 target_link_libraries(paltest_setenvironmentvariablea_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableA/test4/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableA/test4/CMakeLists.txt
index 1c53d4b6a1..4ffaaa31ee 100644
--- a/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableA/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableA/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setenvironmentvariablea_test4
 add_dependencies(paltest_setenvironmentvariablea_test4 coreclrpal)
 
 target_link_libraries(paltest_setenvironmentvariablea_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableW/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableW/test1/CMakeLists.txt
index 6eb52ab92e..2433b1578e 100644
--- a/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setenvironmentvariablew_test1
 add_dependencies(paltest_setenvironmentvariablew_test1 coreclrpal)
 
 target_link_libraries(paltest_setenvironmentvariablew_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableW/test2/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableW/test2/CMakeLists.txt
index a82d849bde..c9ecdf78f3 100644
--- a/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setenvironmentvariablew_test2
 add_dependencies(paltest_setenvironmentvariablew_test2 coreclrpal)
 
 target_link_libraries(paltest_setenvironmentvariablew_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableW/test3/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableW/test3/CMakeLists.txt
index 266231e6e9..e9dd681f7a 100644
--- a/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableW/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableW/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setenvironmentvariablew_test3
 add_dependencies(paltest_setenvironmentvariablew_test3 coreclrpal)
 
 target_link_libraries(paltest_setenvironmentvariablew_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableW/test4/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableW/test4/CMakeLists.txt
index c82e0f0394..cfc139fcfe 100644
--- a/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableW/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/SetEnvironmentVariableW/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setenvironmentvariablew_test4
 add_dependencies(paltest_setenvironmentvariablew_test4 coreclrpal)
 
 target_link_libraries(paltest_setenvironmentvariablew_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/SetLastError/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/SetLastError/test1/CMakeLists.txt
index 40eb2ff865..740ce97965 100644
--- a/src/pal/tests/palsuite/miscellaneous/SetLastError/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/SetLastError/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setlasterror_test1
 add_dependencies(paltest_setlasterror_test1 coreclrpal)
 
 target_link_libraries(paltest_setlasterror_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/_i64tow/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/_i64tow/test1/CMakeLists.txt
index c3c4b61999..718c208831 100644
--- a/src/pal/tests/palsuite/miscellaneous/_i64tow/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/_i64tow/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_i64tow_test1
 add_dependencies(paltest_i64tow_test1 coreclrpal)
 
 target_link_libraries(paltest_i64tow_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/lstrlenA/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/lstrlenA/test1/CMakeLists.txt
index 6bb520100d..f0b43ac143 100644
--- a/src/pal/tests/palsuite/miscellaneous/lstrlenA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/lstrlenA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_lstrlena_test1
 add_dependencies(paltest_lstrlena_test1 coreclrpal)
 
 target_link_libraries(paltest_lstrlena_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/lstrlenW/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/lstrlenW/test1/CMakeLists.txt
index 4209cbee89..a036291da5 100644
--- a/src/pal/tests/palsuite/miscellaneous/lstrlenW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/lstrlenW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_lstrlenw_test1
 add_dependencies(paltest_lstrlenw_test1 coreclrpal)
 
 target_link_libraries(paltest_lstrlenw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/queryperformancecounter/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/queryperformancecounter/test1/CMakeLists.txt
index ba53f42ccc..6ff03558da 100644
--- a/src/pal/tests/palsuite/miscellaneous/queryperformancecounter/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/queryperformancecounter/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_queryperformancecounter_test1
 add_dependencies(paltest_queryperformancecounter_test1 coreclrpal)
 
 target_link_libraries(paltest_queryperformancecounter_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/miscellaneous/queryperformancefrequency/test1/CMakeLists.txt b/src/pal/tests/palsuite/miscellaneous/queryperformancefrequency/test1/CMakeLists.txt
index bc6bd22d5d..4125ff0e73 100644
--- a/src/pal/tests/palsuite/miscellaneous/queryperformancefrequency/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/miscellaneous/queryperformancefrequency/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_queryperformancefrequency_test1
 add_dependencies(paltest_queryperformancefrequency_test1 coreclrpal)
 
 target_link_libraries(paltest_queryperformancefrequency_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/pal_specific/PAL_GetPALDirectoryW/test1/CMakeLists.txt b/src/pal/tests/palsuite/pal_specific/PAL_GetPALDirectoryW/test1/CMakeLists.txt
index 515815f9d2..ffab57f00e 100644
--- a/src/pal/tests/palsuite/pal_specific/PAL_GetPALDirectoryW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/pal_specific/PAL_GetPALDirectoryW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_getpaldirectoryw_test1
 add_dependencies(paltest_pal_getpaldirectoryw_test1 coreclrpal)
 
 target_link_libraries(paltest_pal_getpaldirectoryw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/pal_specific/PAL_GetUserTempDirectoryW/test1/CMakeLists.txt b/src/pal/tests/palsuite/pal_specific/PAL_GetUserTempDirectoryW/test1/CMakeLists.txt
index 26eb1a860b..17baa9f6e2 100644
--- a/src/pal/tests/palsuite/pal_specific/PAL_GetUserTempDirectoryW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/pal_specific/PAL_GetUserTempDirectoryW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_getusertempdirectoryw_test1
 add_dependencies(paltest_pal_getusertempdirectoryw_test1 coreclrpal)
 
 target_link_libraries(paltest_pal_getusertempdirectoryw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/pal_specific/PAL_Initialize_Terminate/test1/CMakeLists.txt b/src/pal/tests/palsuite/pal_specific/PAL_Initialize_Terminate/test1/CMakeLists.txt
index 281efcd8be..27750bb26f 100644
--- a/src/pal/tests/palsuite/pal_specific/PAL_Initialize_Terminate/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/pal_specific/PAL_Initialize_Terminate/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_initialize_terminate_test1
 add_dependencies(paltest_pal_initialize_terminate_test1 coreclrpal)
 
 target_link_libraries(paltest_pal_initialize_terminate_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/pal_specific/PAL_Initialize_Terminate/test2/CMakeLists.txt b/src/pal/tests/palsuite/pal_specific/PAL_Initialize_Terminate/test2/CMakeLists.txt
index 46b42aa714..951aa5d59a 100644
--- a/src/pal/tests/palsuite/pal_specific/PAL_Initialize_Terminate/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/pal_specific/PAL_Initialize_Terminate/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_initialize_terminate_test2
 add_dependencies(paltest_pal_initialize_terminate_test2 coreclrpal)
 
 target_link_libraries(paltest_pal_initialize_terminate_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/pal_specific/PAL_RegisterLibraryW_UnregisterLibraryW/test1/CMakeLists.txt b/src/pal/tests/palsuite/pal_specific/PAL_RegisterLibraryW_UnregisterLibraryW/test1/CMakeLists.txt
index 573ab3834a..850c44f778 100644
--- a/src/pal/tests/palsuite/pal_specific/PAL_RegisterLibraryW_UnregisterLibraryW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/pal_specific/PAL_RegisterLibraryW_UnregisterLibraryW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_registerlibraryw_unregisterlibraryw_test1
 add_dependencies(paltest_pal_registerlibraryw_unregisterlibraryw_test1 coreclrpal)
 
 target_link_libraries(paltest_pal_registerlibraryw_unregisterlibraryw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/pal_specific/PAL_RegisterLibraryW_UnregisterLibraryW/test2_neg/CMakeLists.txt b/src/pal/tests/palsuite/pal_specific/PAL_RegisterLibraryW_UnregisterLibraryW/test2_neg/CMakeLists.txt
index ef5c0479b7..707d347923 100644
--- a/src/pal/tests/palsuite/pal_specific/PAL_RegisterLibraryW_UnregisterLibraryW/test2_neg/CMakeLists.txt
+++ b/src/pal/tests/palsuite/pal_specific/PAL_RegisterLibraryW_UnregisterLibraryW/test2_neg/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_reg_unreg_libraryw_neg
 add_dependencies(paltest_reg_unreg_libraryw_neg coreclrpal)
 
 target_link_libraries(paltest_reg_unreg_libraryw_neg
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/pal_specific/PAL_errno/test1/CMakeLists.txt b/src/pal/tests/palsuite/pal_specific/PAL_errno/test1/CMakeLists.txt
index d20ddd9a43..2938189f1b 100644
--- a/src/pal/tests/palsuite/pal_specific/PAL_errno/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/pal_specific/PAL_errno/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_errno_test1
 add_dependencies(paltest_pal_errno_test1 coreclrpal)
 
 target_link_libraries(paltest_pal_errno_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/pal_specific/PAL_get_stderr/test1/CMakeLists.txt b/src/pal/tests/palsuite/pal_specific/PAL_get_stderr/test1/CMakeLists.txt
index dbedac95f5..3d177074e9 100644
--- a/src/pal/tests/palsuite/pal_specific/PAL_get_stderr/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/pal_specific/PAL_get_stderr/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_get_stderr_test1
 add_dependencies(paltest_pal_get_stderr_test1 coreclrpal)
 
 target_link_libraries(paltest_pal_get_stderr_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/pal_specific/PAL_get_stdin/test1/CMakeLists.txt b/src/pal/tests/palsuite/pal_specific/PAL_get_stdin/test1/CMakeLists.txt
index 4d714a3735..75469a2937 100644
--- a/src/pal/tests/palsuite/pal_specific/PAL_get_stdin/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/pal_specific/PAL_get_stdin/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_get_stdin_test1
 add_dependencies(paltest_pal_get_stdin_test1 coreclrpal)
 
 target_link_libraries(paltest_pal_get_stdin_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/pal_specific/PAL_get_stdout/test1/CMakeLists.txt b/src/pal/tests/palsuite/pal_specific/PAL_get_stdout/test1/CMakeLists.txt
index 4c2f51b50d..bd78218d64 100644
--- a/src/pal/tests/palsuite/pal_specific/PAL_get_stdout/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/pal_specific/PAL_get_stdout/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_get_stdout_test1
 add_dependencies(paltest_pal_get_stdout_test1 coreclrpal)
 
 target_link_libraries(paltest_pal_get_stdout_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/pal_specific/pal_entrypoint/test1/CMakeLists.txt b/src/pal/tests/palsuite/pal_specific/pal_entrypoint/test1/CMakeLists.txt
index 82ff9225de..154791c20d 100644
--- a/src/pal/tests/palsuite/pal_specific/pal_entrypoint/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/pal_specific/pal_entrypoint/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_entrypoint_test1
 add_dependencies(paltest_pal_entrypoint_test1 coreclrpal)
 
 target_link_libraries(paltest_pal_entrypoint_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/pal_specific/pal_initializedebug/test1/CMakeLists.txt b/src/pal/tests/palsuite/pal_specific/pal_initializedebug/test1/CMakeLists.txt
index 56c9d02eaa..198e582ec8 100644
--- a/src/pal/tests/palsuite/pal_specific/pal_initializedebug/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/pal_specific/pal_initializedebug/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_pal_initializedebug_test1
 add_dependencies(paltest_pal_initializedebug_test1 coreclrpal)
 
 target_link_libraries(paltest_pal_initializedebug_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/paltestlist.txt b/src/pal/tests/palsuite/paltestlist.txt
index 98b17fa6f9..600c2a533b 100644
--- a/src/pal/tests/palsuite/paltestlist.txt
+++ b/src/pal/tests/palsuite/paltestlist.txt
@@ -355,7 +355,6 @@ c_runtime/_putenv/test1/paltest_putenv_test1
 c_runtime/_putenv/test2/paltest_putenv_test2
 c_runtime/_putenv/test3/paltest_putenv_test3
 c_runtime/_putenv/test4/paltest_putenv_test4
-c_runtime/_putw/test1/paltest_putw_test1
 c_runtime/_rotl/test1/paltest_rotl_test1
 c_runtime/_rotr/test1/paltest_rotr_test1
 c_runtime/_snprintf_s/test1/paltest_snprintf_test1
diff --git a/src/pal/tests/palsuite/samples/test1/CMakeLists.txt b/src/pal/tests/palsuite/samples/test1/CMakeLists.txt
index 42f2ebdcdd..9db683907f 100644
--- a/src/pal/tests/palsuite/samples/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/samples/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_samples_test1
 add_dependencies(paltest_samples_test1 coreclrpal)
 
 target_link_libraries(paltest_samples_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/samples/test2/CMakeLists.txt b/src/pal/tests/palsuite/samples/test2/CMakeLists.txt
index 1a7ce2918e..9e7fb7b930 100644
--- a/src/pal/tests/palsuite/samples/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/samples/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_samples_test2
 add_dependencies(paltest_samples_test2 coreclrpal)
 
 target_link_libraries(paltest_samples_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateEventA/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateEventA/test1/CMakeLists.txt
index 7be9481150..44a6d98495 100644
--- a/src/pal/tests/palsuite/threading/CreateEventA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateEventA/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createeventa_test1
 add_dependencies(paltest_createeventa_test1 coreclrpal)
 
 target_link_libraries(paltest_createeventa_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateEventA/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateEventA/test2/CMakeLists.txt
index 9725c89721..3b7daaa530 100644
--- a/src/pal/tests/palsuite/threading/CreateEventA/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateEventA/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createeventa_test2
 add_dependencies(paltest_createeventa_test2 coreclrpal)
 
 target_link_libraries(paltest_createeventa_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateEventA/test3/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateEventA/test3/CMakeLists.txt
index b596a881d5..c3d110d733 100644
--- a/src/pal/tests/palsuite/threading/CreateEventA/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateEventA/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createeventa_test3
 add_dependencies(paltest_createeventa_test3 coreclrpal)
 
 target_link_libraries(paltest_createeventa_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateEventW/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateEventW/test1/CMakeLists.txt
index ef18312cda..989bc44d60 100644
--- a/src/pal/tests/palsuite/threading/CreateEventW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateEventW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createeventw_test1
 add_dependencies(paltest_createeventw_test1 coreclrpal)
 
 target_link_libraries(paltest_createeventw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateEventW/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateEventW/test2/CMakeLists.txt
index 7f9543e0cb..f8ebb5319f 100644
--- a/src/pal/tests/palsuite/threading/CreateEventW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateEventW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createeventw_test2
 add_dependencies(paltest_createeventw_test2 coreclrpal)
 
 target_link_libraries(paltest_createeventw_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateEventW/test3/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateEventW/test3/CMakeLists.txt
index 6778740f7e..b6ba370d50 100644
--- a/src/pal/tests/palsuite/threading/CreateEventW/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateEventW/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createeventw_test3
 add_dependencies(paltest_createeventw_test3 coreclrpal)
 
 target_link_libraries(paltest_createeventw_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateMutexA_ReleaseMutex/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateMutexA_ReleaseMutex/test1/CMakeLists.txt
index 782c671b84..40ed5848c1 100644
--- a/src/pal/tests/palsuite/threading/CreateMutexA_ReleaseMutex/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateMutexA_ReleaseMutex/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createmutexa_releasemutex_test1
 add_dependencies(paltest_createmutexa_releasemutex_test1 coreclrpal)
 
 target_link_libraries(paltest_createmutexa_releasemutex_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateMutexA_ReleaseMutex/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateMutexA_ReleaseMutex/test2/CMakeLists.txt
index 3540cb2b8c..2486a70250 100644
--- a/src/pal/tests/palsuite/threading/CreateMutexA_ReleaseMutex/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateMutexA_ReleaseMutex/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createmutexa_releasemutex_test2
 add_dependencies(paltest_createmutexa_releasemutex_test2 coreclrpal)
 
 target_link_libraries(paltest_createmutexa_releasemutex_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateMutexW_ReleaseMutex/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateMutexW_ReleaseMutex/test1/CMakeLists.txt
index aa1f7831c0..c30bad275b 100644
--- a/src/pal/tests/palsuite/threading/CreateMutexW_ReleaseMutex/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateMutexW_ReleaseMutex/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createmutexw_releasemutex_test1
 add_dependencies(paltest_createmutexw_releasemutex_test1 coreclrpal)
 
 target_link_libraries(paltest_createmutexw_releasemutex_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateMutexW_ReleaseMutex/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateMutexW_ReleaseMutex/test2/CMakeLists.txt
index 5a9095cb1b..cfcbde466b 100644
--- a/src/pal/tests/palsuite/threading/CreateMutexW_ReleaseMutex/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateMutexW_ReleaseMutex/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createmutexw_releasemutex_test2
 add_dependencies(paltest_createmutexw_releasemutex_test2 coreclrpal)
 
 target_link_libraries(paltest_createmutexw_releasemutex_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateProcessA/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateProcessA/test1/CMakeLists.txt
index 9cd0aa5dfd..32ef242431 100644
--- a/src/pal/tests/palsuite/threading/CreateProcessA/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateProcessA/test1/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_createprocessa_test1
 add_dependencies(paltest_createprocessa_test1 coreclrpal)
 
 target_link_libraries(paltest_createprocessa_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_createprocessa_test1_child
 add_dependencies(paltest_createprocessa_test1_child coreclrpal)
 
 target_link_libraries(paltest_createprocessa_test1_child
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateProcessA/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateProcessA/test2/CMakeLists.txt
index f035f0a888..4f4bc850ba 100644
--- a/src/pal/tests/palsuite/threading/CreateProcessA/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateProcessA/test2/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_createprocessa_test2
 add_dependencies(paltest_createprocessa_test2 coreclrpal)
 
 target_link_libraries(paltest_createprocessa_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_createprocessa_test2_child
 add_dependencies(paltest_createprocessa_test2_child coreclrpal)
 
 target_link_libraries(paltest_createprocessa_test2_child
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateProcessW/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateProcessW/test1/CMakeLists.txt
index 174d6fe3c7..a5a0ca8b0c 100644
--- a/src/pal/tests/palsuite/threading/CreateProcessW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateProcessW/test1/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_createprocessw_test1
 add_dependencies(paltest_createprocessw_test1 coreclrpal)
 
 target_link_libraries(paltest_createprocessw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_createprocessw_test1_child
 add_dependencies(paltest_createprocessw_test1_child coreclrpal)
 
 target_link_libraries(paltest_createprocessw_test1_child
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateProcessW/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateProcessW/test2/CMakeLists.txt
index 021a0d2da2..f32924b8bd 100644
--- a/src/pal/tests/palsuite/threading/CreateProcessW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateProcessW/test2/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_createprocessw_test2
 add_dependencies(paltest_createprocessw_test2 coreclrpal)
 
 target_link_libraries(paltest_createprocessw_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_createprocessw_test2_child
 add_dependencies(paltest_createprocessw_test2_child coreclrpal)
 
 target_link_libraries(paltest_createprocessw_test2_child
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateSemaphoreA_ReleaseSemaphore/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateSemaphoreA_ReleaseSemaphore/test1/CMakeLists.txt
index 8a9255ce7a..76b2dd690f 100644
--- a/src/pal/tests/palsuite/threading/CreateSemaphoreA_ReleaseSemaphore/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateSemaphoreA_ReleaseSemaphore/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createsemaphorea_releasesemaphore_test1
 add_dependencies(paltest_createsemaphorea_releasesemaphore_test1 coreclrpal)
 
 target_link_libraries(paltest_createsemaphorea_releasesemaphore_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateSemaphoreA_ReleaseSemaphore/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateSemaphoreA_ReleaseSemaphore/test2/CMakeLists.txt
index 6d1249bf05..1f01ed0129 100644
--- a/src/pal/tests/palsuite/threading/CreateSemaphoreA_ReleaseSemaphore/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateSemaphoreA_ReleaseSemaphore/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createsemaphorea_releasesemaphore_test2
 add_dependencies(paltest_createsemaphorea_releasesemaphore_test2 coreclrpal)
 
 target_link_libraries(paltest_createsemaphorea_releasesemaphore_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateSemaphoreA_ReleaseSemaphore/test3/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateSemaphoreA_ReleaseSemaphore/test3/CMakeLists.txt
index 94998f59a9..a7dcfdd32f 100644
--- a/src/pal/tests/palsuite/threading/CreateSemaphoreA_ReleaseSemaphore/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateSemaphoreA_ReleaseSemaphore/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createsemaphorea_releasesemaphore_test3
 add_dependencies(paltest_createsemaphorea_releasesemaphore_test3 coreclrpal)
 
 target_link_libraries(paltest_createsemaphorea_releasesemaphore_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateSemaphoreW_ReleaseSemaphore/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateSemaphoreW_ReleaseSemaphore/test1/CMakeLists.txt
index 32902cf914..47b09e8e9d 100644
--- a/src/pal/tests/palsuite/threading/CreateSemaphoreW_ReleaseSemaphore/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateSemaphoreW_ReleaseSemaphore/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createsemaphorew_releasesemaphore_test1
 add_dependencies(paltest_createsemaphorew_releasesemaphore_test1 coreclrpal)
 
 target_link_libraries(paltest_createsemaphorew_releasesemaphore_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateSemaphoreW_ReleaseSemaphore/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateSemaphoreW_ReleaseSemaphore/test2/CMakeLists.txt
index bd0a5a6e53..374f02c21d 100644
--- a/src/pal/tests/palsuite/threading/CreateSemaphoreW_ReleaseSemaphore/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateSemaphoreW_ReleaseSemaphore/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createsemaphorew_releasesemaphore_test2
 add_dependencies(paltest_createsemaphorew_releasesemaphore_test2 coreclrpal)
 
 target_link_libraries(paltest_createsemaphorew_releasesemaphore_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateSemaphoreW_ReleaseSemaphore/test3/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateSemaphoreW_ReleaseSemaphore/test3/CMakeLists.txt
index d0340c64cb..6e12df92b4 100644
--- a/src/pal/tests/palsuite/threading/CreateSemaphoreW_ReleaseSemaphore/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateSemaphoreW_ReleaseSemaphore/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createsemaphorew_releasesemaphore_test3
 add_dependencies(paltest_createsemaphorew_releasesemaphore_test3 coreclrpal)
 
 target_link_libraries(paltest_createsemaphorew_releasesemaphore_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateThread/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateThread/test1/CMakeLists.txt
index b47afe498a..e190800e3f 100644
--- a/src/pal/tests/palsuite/threading/CreateThread/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateThread/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createthread_test1
 add_dependencies(paltest_createthread_test1 coreclrpal)
 
 target_link_libraries(paltest_createthread_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateThread/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateThread/test2/CMakeLists.txt
index 47877607b9..aed986fd54 100644
--- a/src/pal/tests/palsuite/threading/CreateThread/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateThread/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createthread_test2
 add_dependencies(paltest_createthread_test2 coreclrpal)
 
 target_link_libraries(paltest_createthread_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CreateThread/test3/CMakeLists.txt b/src/pal/tests/palsuite/threading/CreateThread/test3/CMakeLists.txt
index d454992e59..3986665254 100644
--- a/src/pal/tests/palsuite/threading/CreateThread/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CreateThread/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_createthread_test3
 add_dependencies(paltest_createthread_test3 coreclrpal)
 
 target_link_libraries(paltest_createthread_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test1/CMakeLists.txt
index 8d2c1441c4..204b316b20 100644
--- a/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_criticalsectionfunctions_test1
 add_dependencies(paltest_criticalsectionfunctions_test1 coreclrpal)
 
 target_link_libraries(paltest_criticalsectionfunctions_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test2/CMakeLists.txt
index e0f59f4207..dba47f6ee2 100644
--- a/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_criticalsectionfunctions_test2
 add_dependencies(paltest_criticalsectionfunctions_test2 coreclrpal)
 
 target_link_libraries(paltest_criticalsectionfunctions_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test3/CMakeLists.txt b/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test3/CMakeLists.txt
index 11555ec484..599572b99b 100644
--- a/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_criticalsectionfunctions_test3
 add_dependencies(paltest_criticalsectionfunctions_test3 coreclrpal)
 
 target_link_libraries(paltest_criticalsectionfunctions_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test4/CMakeLists.txt b/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test4/CMakeLists.txt
index 8aa18854b3..71c49248aa 100644
--- a/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_criticalsectionfunctions_test4
 add_dependencies(paltest_criticalsectionfunctions_test4 coreclrpal)
 
 target_link_libraries(paltest_criticalsectionfunctions_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test5/CMakeLists.txt b/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test5/CMakeLists.txt
index 9474bcc6c9..16a0ccdb48 100644
--- a/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_criticalsectionfunctions_test5
 add_dependencies(paltest_criticalsectionfunctions_test5 coreclrpal)
 
 target_link_libraries(paltest_criticalsectionfunctions_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test6/CMakeLists.txt b/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test6/CMakeLists.txt
index f4887ad67d..3f463940b7 100644
--- a/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_criticalsectionfunctions_test6
 add_dependencies(paltest_criticalsectionfunctions_test6 coreclrpal)
 
 target_link_libraries(paltest_criticalsectionfunctions_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test7/CMakeLists.txt b/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test7/CMakeLists.txt
index ceb78a0512..21b813ba32 100644
--- a/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_criticalsectionfunctions_test7
 add_dependencies(paltest_criticalsectionfunctions_test7 coreclrpal)
 
 target_link_libraries(paltest_criticalsectionfunctions_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test8/CMakeLists.txt b/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test8/CMakeLists.txt
index d3f271d677..a8ab4b0aaf 100644
--- a/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test8/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/CriticalSectionFunctions/test8/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_criticalsectionfunctions_test8
 add_dependencies(paltest_criticalsectionfunctions_test8 coreclrpal)
 
 target_link_libraries(paltest_criticalsectionfunctions_test8
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/DuplicateHandle/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/DuplicateHandle/test1/CMakeLists.txt
index 18b1927a4e..f5fb47c0f0 100644
--- a/src/pal/tests/palsuite/threading/DuplicateHandle/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/DuplicateHandle/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_duplicatehandle_test1
 add_dependencies(paltest_duplicatehandle_test1 coreclrpal)
 
 target_link_libraries(paltest_duplicatehandle_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/DuplicateHandle/test10/CMakeLists.txt b/src/pal/tests/palsuite/threading/DuplicateHandle/test10/CMakeLists.txt
index 98c7a273dc..135f1494a6 100644
--- a/src/pal/tests/palsuite/threading/DuplicateHandle/test10/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/DuplicateHandle/test10/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_duplicatehandle_test10
 add_dependencies(paltest_duplicatehandle_test10 coreclrpal)
 
 target_link_libraries(paltest_duplicatehandle_test10
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/DuplicateHandle/test11/CMakeLists.txt b/src/pal/tests/palsuite/threading/DuplicateHandle/test11/CMakeLists.txt
index f47f9bc350..5584b9d1e7 100644
--- a/src/pal/tests/palsuite/threading/DuplicateHandle/test11/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/DuplicateHandle/test11/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_duplicatehandle_test11
 add_dependencies(paltest_duplicatehandle_test11 coreclrpal)
 
 target_link_libraries(paltest_duplicatehandle_test11
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_duplicatehandle_test11_child
 add_dependencies(paltest_duplicatehandle_test11_child coreclrpal)
 
 target_link_libraries(paltest_duplicatehandle_test11_child
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/DuplicateHandle/test12/CMakeLists.txt b/src/pal/tests/palsuite/threading/DuplicateHandle/test12/CMakeLists.txt
index 6a50a13265..fb5ed234ca 100644
--- a/src/pal/tests/palsuite/threading/DuplicateHandle/test12/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/DuplicateHandle/test12/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_duplicatehandle_test12
 add_dependencies(paltest_duplicatehandle_test12 coreclrpal)
 
 target_link_libraries(paltest_duplicatehandle_test12
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/DuplicateHandle/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/DuplicateHandle/test2/CMakeLists.txt
index 9faa58a271..9668dfd109 100644
--- a/src/pal/tests/palsuite/threading/DuplicateHandle/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/DuplicateHandle/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_duplicatehandle_test2
 add_dependencies(paltest_duplicatehandle_test2 coreclrpal)
 
 target_link_libraries(paltest_duplicatehandle_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/DuplicateHandle/test3/CMakeLists.txt b/src/pal/tests/palsuite/threading/DuplicateHandle/test3/CMakeLists.txt
index b161b928d3..e44c2a2f76 100644
--- a/src/pal/tests/palsuite/threading/DuplicateHandle/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/DuplicateHandle/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_duplicatehandle_test3
 add_dependencies(paltest_duplicatehandle_test3 coreclrpal)
 
 target_link_libraries(paltest_duplicatehandle_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/DuplicateHandle/test4/CMakeLists.txt b/src/pal/tests/palsuite/threading/DuplicateHandle/test4/CMakeLists.txt
index 901151f4eb..2261e6e1cd 100644
--- a/src/pal/tests/palsuite/threading/DuplicateHandle/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/DuplicateHandle/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_duplicatehandle_test4
 add_dependencies(paltest_duplicatehandle_test4 coreclrpal)
 
 target_link_libraries(paltest_duplicatehandle_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/DuplicateHandle/test5/CMakeLists.txt b/src/pal/tests/palsuite/threading/DuplicateHandle/test5/CMakeLists.txt
index 94cd07f96f..72e77aab1d 100644
--- a/src/pal/tests/palsuite/threading/DuplicateHandle/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/DuplicateHandle/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_duplicatehandle_test5
 add_dependencies(paltest_duplicatehandle_test5 coreclrpal)
 
 target_link_libraries(paltest_duplicatehandle_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/DuplicateHandle/test6/CMakeLists.txt b/src/pal/tests/palsuite/threading/DuplicateHandle/test6/CMakeLists.txt
index a0dcae843c..620d788435 100644
--- a/src/pal/tests/palsuite/threading/DuplicateHandle/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/DuplicateHandle/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_duplicatehandle_test6
 add_dependencies(paltest_duplicatehandle_test6 coreclrpal)
 
 target_link_libraries(paltest_duplicatehandle_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/DuplicateHandle/test7/CMakeLists.txt b/src/pal/tests/palsuite/threading/DuplicateHandle/test7/CMakeLists.txt
index a222331fe7..fff3ba5284 100644
--- a/src/pal/tests/palsuite/threading/DuplicateHandle/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/DuplicateHandle/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_duplicatehandle_test7
 add_dependencies(paltest_duplicatehandle_test7 coreclrpal)
 
 target_link_libraries(paltest_duplicatehandle_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/DuplicateHandle/test8/CMakeLists.txt b/src/pal/tests/palsuite/threading/DuplicateHandle/test8/CMakeLists.txt
index 18ed969cb7..2fb32aa3f7 100644
--- a/src/pal/tests/palsuite/threading/DuplicateHandle/test8/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/DuplicateHandle/test8/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_duplicatehandle_test8
 add_dependencies(paltest_duplicatehandle_test8 coreclrpal)
 
 target_link_libraries(paltest_duplicatehandle_test8
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/DuplicateHandle/test9/CMakeLists.txt b/src/pal/tests/palsuite/threading/DuplicateHandle/test9/CMakeLists.txt
index 0383a010ac..f2bca82933 100644
--- a/src/pal/tests/palsuite/threading/DuplicateHandle/test9/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/DuplicateHandle/test9/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_duplicatehandle_test9
 add_dependencies(paltest_duplicatehandle_test9 coreclrpal)
 
 target_link_libraries(paltest_duplicatehandle_test9
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/ExitProcess/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/ExitProcess/test1/CMakeLists.txt
index f2d28e06ca..28f1247659 100644
--- a/src/pal/tests/palsuite/threading/ExitProcess/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/ExitProcess/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_exitprocess_test1
 add_dependencies(paltest_exitprocess_test1 coreclrpal)
 
 target_link_libraries(paltest_exitprocess_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/ExitProcess/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/ExitProcess/test2/CMakeLists.txt
index 5281a02aa4..6b9202e581 100644
--- a/src/pal/tests/palsuite/threading/ExitProcess/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/ExitProcess/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_exitprocess_test2
 add_dependencies(paltest_exitprocess_test2 coreclrpal)
 
 target_link_libraries(paltest_exitprocess_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/ExitProcess/test3/CMakeLists.txt b/src/pal/tests/palsuite/threading/ExitProcess/test3/CMakeLists.txt
index 3fca087d05..c4152181ce 100644
--- a/src/pal/tests/palsuite/threading/ExitProcess/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/ExitProcess/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_exitprocess_test3
 add_dependencies(paltest_exitprocess_test3 coreclrpal)
 
 target_link_libraries(paltest_exitprocess_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/ExitThread/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/ExitThread/test1/CMakeLists.txt
index c34b5257ab..3f8531a33a 100644
--- a/src/pal/tests/palsuite/threading/ExitThread/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/ExitThread/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_exitthread_test1
 add_dependencies(paltest_exitthread_test1 coreclrpal)
 
 target_link_libraries(paltest_exitthread_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/ExitThread/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/ExitThread/test2/CMakeLists.txt
index 5e16d36082..606e02774c 100644
--- a/src/pal/tests/palsuite/threading/ExitThread/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/ExitThread/test2/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_exitthread_test2
 add_dependencies(paltest_exitthread_test2 coreclrpal)
 
 target_link_libraries(paltest_exitthread_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_exitthread_test2_child
 add_dependencies(paltest_exitthread_test2_child coreclrpal)
 
 target_link_libraries(paltest_exitthread_test2_child
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/GetCurrentProcess/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/GetCurrentProcess/test1/CMakeLists.txt
index af4746bcb4..be17127c1a 100644
--- a/src/pal/tests/palsuite/threading/GetCurrentProcess/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/GetCurrentProcess/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getcurrentprocess_test1
 add_dependencies(paltest_getcurrentprocess_test1 coreclrpal)
 
 target_link_libraries(paltest_getcurrentprocess_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/GetCurrentProcessId/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/GetCurrentProcessId/test1/CMakeLists.txt
index 523320a53c..f1ac1e0d48 100644
--- a/src/pal/tests/palsuite/threading/GetCurrentProcessId/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/GetCurrentProcessId/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getcurrentprocessid_test1
 add_dependencies(paltest_getcurrentprocessid_test1 coreclrpal)
 
 target_link_libraries(paltest_getcurrentprocessid_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/GetCurrentThread/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/GetCurrentThread/test1/CMakeLists.txt
index 23af2edbca..dacb9b40c9 100644
--- a/src/pal/tests/palsuite/threading/GetCurrentThread/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/GetCurrentThread/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getcurrentthread_test1
 add_dependencies(paltest_getcurrentthread_test1 coreclrpal)
 
 target_link_libraries(paltest_getcurrentthread_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/GetCurrentThread/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/GetCurrentThread/test2/CMakeLists.txt
index 9da2d075b2..58419a8693 100644
--- a/src/pal/tests/palsuite/threading/GetCurrentThread/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/GetCurrentThread/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getcurrentthread_test2
 add_dependencies(paltest_getcurrentthread_test2 coreclrpal)
 
 target_link_libraries(paltest_getcurrentthread_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/GetCurrentThreadId/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/GetCurrentThreadId/test1/CMakeLists.txt
index a0824ab9a2..ecad3d287a 100644
--- a/src/pal/tests/palsuite/threading/GetCurrentThreadId/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/GetCurrentThreadId/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getcurrentthreadid_test1
 add_dependencies(paltest_getcurrentthreadid_test1 coreclrpal)
 
 target_link_libraries(paltest_getcurrentthreadid_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/GetExitCodeProcess/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/GetExitCodeProcess/test1/CMakeLists.txt
index 1ef9db2299..184470aee0 100644
--- a/src/pal/tests/palsuite/threading/GetExitCodeProcess/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/GetExitCodeProcess/test1/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_getexitcodeprocess_test1
 add_dependencies(paltest_getexitcodeprocess_test1 coreclrpal)
 
 target_link_libraries(paltest_getexitcodeprocess_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_getexitcodeprocess_test1_child
 add_dependencies(paltest_getexitcodeprocess_test1_child coreclrpal)
 
 target_link_libraries(paltest_getexitcodeprocess_test1_child
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/GetProcessTimes/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/GetProcessTimes/test2/CMakeLists.txt
index 8e905873e9..b062b349aa 100644
--- a/src/pal/tests/palsuite/threading/GetProcessTimes/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/GetProcessTimes/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getprocesstimes_test2
 add_dependencies(paltest_getprocesstimes_test2 coreclrpal)
 
 target_link_libraries(paltest_getprocesstimes_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/GetThreadTimes/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/GetThreadTimes/test1/CMakeLists.txt
index aa4dad11ce..23ae7abc58 100644
--- a/src/pal/tests/palsuite/threading/GetThreadTimes/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/GetThreadTimes/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_getthreadtimes_test1
 add_dependencies(paltest_getthreadtimes_test1 coreclrpal)
 
 target_link_libraries(paltest_getthreadtimes_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/NamedMutex/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/NamedMutex/test1/CMakeLists.txt
index 315144e1e8..8e3e754631 100644
--- a/src/pal/tests/palsuite/threading/NamedMutex/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/NamedMutex/test1/CMakeLists.txt
@@ -14,7 +14,5 @@ add_executable(paltest_namedmutex_test1
 add_dependencies(paltest_namedmutex_test1 coreclrpal)
 
 target_link_libraries(paltest_namedmutex_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/NamedMutex/test1/nopal.cpp b/src/pal/tests/palsuite/threading/NamedMutex/test1/nopal.cpp
index 46a5d87341..ae3ebc361c 100644
--- a/src/pal/tests/palsuite/threading/NamedMutex/test1/nopal.cpp
+++ b/src/pal/tests/palsuite/threading/NamedMutex/test1/nopal.cpp
@@ -16,6 +16,7 @@
 
 #define _countof(a) (sizeof(a) / sizeof(a[0]))
 
+#undef PAGE_SIZE
 #define PAGE_SIZE (4096)
 
 auto test_strcpy = strcpy;
diff --git a/src/pal/tests/palsuite/threading/OpenEventW/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/OpenEventW/test1/CMakeLists.txt
index 2d5698b153..e6470c5992 100644
--- a/src/pal/tests/palsuite/threading/OpenEventW/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/OpenEventW/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_openeventw_test1
 add_dependencies(paltest_openeventw_test1 coreclrpal)
 
 target_link_libraries(paltest_openeventw_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/OpenEventW/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/OpenEventW/test2/CMakeLists.txt
index bedf83b487..4fd04737cc 100644
--- a/src/pal/tests/palsuite/threading/OpenEventW/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/OpenEventW/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_openeventw_test2
 add_dependencies(paltest_openeventw_test2 coreclrpal)
 
 target_link_libraries(paltest_openeventw_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/OpenEventW/test3/CMakeLists.txt b/src/pal/tests/palsuite/threading/OpenEventW/test3/CMakeLists.txt
index 7f7622dca0..2ccd175c42 100644
--- a/src/pal/tests/palsuite/threading/OpenEventW/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/OpenEventW/test3/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_openeventw_test3
 add_dependencies(paltest_openeventw_test3 coreclrpal)
 
 target_link_libraries(paltest_openeventw_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_openeventw_test3_child
 add_dependencies(paltest_openeventw_test3_child coreclrpal)
 
 target_link_libraries(paltest_openeventw_test3_child
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/OpenEventW/test4/CMakeLists.txt b/src/pal/tests/palsuite/threading/OpenEventW/test4/CMakeLists.txt
index 73b8904993..dbf3a276b6 100644
--- a/src/pal/tests/palsuite/threading/OpenEventW/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/OpenEventW/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_openeventw_test4
 add_dependencies(paltest_openeventw_test4 coreclrpal)
 
 target_link_libraries(paltest_openeventw_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/OpenEventW/test5/CMakeLists.txt b/src/pal/tests/palsuite/threading/OpenEventW/test5/CMakeLists.txt
index 3bad4d9cc5..2830182e56 100644
--- a/src/pal/tests/palsuite/threading/OpenEventW/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/OpenEventW/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_openeventw_test5
 add_dependencies(paltest_openeventw_test5 coreclrpal)
 
 target_link_libraries(paltest_openeventw_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/OpenProcess/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/OpenProcess/test1/CMakeLists.txt
index dd2e30516c..df66c3f2d3 100644
--- a/src/pal/tests/palsuite/threading/OpenProcess/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/OpenProcess/test1/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_openprocess_test1
 add_dependencies(paltest_openprocess_test1 coreclrpal)
 
 target_link_libraries(paltest_openprocess_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_openprocess_test1_child
 add_dependencies(paltest_openprocess_test1_child coreclrpal)
 
 target_link_libraries(paltest_openprocess_test1_child
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/QueryThreadCycleTime/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/QueryThreadCycleTime/test1/CMakeLists.txt
index 9a54ad15b6..12a575926a 100644
--- a/src/pal/tests/palsuite/threading/QueryThreadCycleTime/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/QueryThreadCycleTime/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_querythreadcycletime_test1
 add_dependencies(paltest_querythreadcycletime_test1 coreclrpal)
 
 target_link_libraries(paltest_querythreadcycletime_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/QueueUserAPC/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/QueueUserAPC/test1/CMakeLists.txt
index a99b0a69cc..402188d274 100644
--- a/src/pal/tests/palsuite/threading/QueueUserAPC/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/QueueUserAPC/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_queueuserapc_test1
 add_dependencies(paltest_queueuserapc_test1 coreclrpal)
 
 target_link_libraries(paltest_queueuserapc_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/QueueUserAPC/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/QueueUserAPC/test2/CMakeLists.txt
index 5d86efdddd..b9f5f01cf5 100644
--- a/src/pal/tests/palsuite/threading/QueueUserAPC/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/QueueUserAPC/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_queueuserapc_test2
 add_dependencies(paltest_queueuserapc_test2 coreclrpal)
 
 target_link_libraries(paltest_queueuserapc_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/QueueUserAPC/test3/CMakeLists.txt b/src/pal/tests/palsuite/threading/QueueUserAPC/test3/CMakeLists.txt
index e07ab67070..8a4c9f26ad 100644
--- a/src/pal/tests/palsuite/threading/QueueUserAPC/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/QueueUserAPC/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_queueuserapc_test3
 add_dependencies(paltest_queueuserapc_test3 coreclrpal)
 
 target_link_libraries(paltest_queueuserapc_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/QueueUserAPC/test4/CMakeLists.txt b/src/pal/tests/palsuite/threading/QueueUserAPC/test4/CMakeLists.txt
index 08a5cc763b..dd97490796 100644
--- a/src/pal/tests/palsuite/threading/QueueUserAPC/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/QueueUserAPC/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_queueuserapc_test4
 add_dependencies(paltest_queueuserapc_test4 coreclrpal)
 
 target_link_libraries(paltest_queueuserapc_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/QueueUserAPC/test5/CMakeLists.txt b/src/pal/tests/palsuite/threading/QueueUserAPC/test5/CMakeLists.txt
index 0ef65ce583..a451712234 100644
--- a/src/pal/tests/palsuite/threading/QueueUserAPC/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/QueueUserAPC/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_queueuserapc_test5
 add_dependencies(paltest_queueuserapc_test5 coreclrpal)
 
 target_link_libraries(paltest_queueuserapc_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/QueueUserAPC/test6/CMakeLists.txt b/src/pal/tests/palsuite/threading/QueueUserAPC/test6/CMakeLists.txt
index 2e7198358c..440b24cf81 100644
--- a/src/pal/tests/palsuite/threading/QueueUserAPC/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/QueueUserAPC/test6/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_queueuserapc_test6
 add_dependencies(paltest_queueuserapc_test6 coreclrpal)
 
 target_link_libraries(paltest_queueuserapc_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/QueueUserAPC/test7/CMakeLists.txt b/src/pal/tests/palsuite/threading/QueueUserAPC/test7/CMakeLists.txt
index c27cd7e67c..6dbeb07e2f 100644
--- a/src/pal/tests/palsuite/threading/QueueUserAPC/test7/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/QueueUserAPC/test7/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_queueuserapc_test7
 add_dependencies(paltest_queueuserapc_test7 coreclrpal)
 
 target_link_libraries(paltest_queueuserapc_test7
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/ReleaseMutex/test3/CMakeLists.txt b/src/pal/tests/palsuite/threading/ReleaseMutex/test3/CMakeLists.txt
index 6bb3a79db4..f8f0d8fb80 100644
--- a/src/pal/tests/palsuite/threading/ReleaseMutex/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/ReleaseMutex/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_releasemutex_test3
 add_dependencies(paltest_releasemutex_test3 coreclrpal)
 
 target_link_libraries(paltest_releasemutex_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/ResetEvent/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/ResetEvent/test1/CMakeLists.txt
index 12c83119d8..769c1f3825 100644
--- a/src/pal/tests/palsuite/threading/ResetEvent/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/ResetEvent/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_resetevent_test1
 add_dependencies(paltest_resetevent_test1 coreclrpal)
 
 target_link_libraries(paltest_resetevent_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/ResetEvent/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/ResetEvent/test2/CMakeLists.txt
index 1f67b5d884..69c7b7cc63 100644
--- a/src/pal/tests/palsuite/threading/ResetEvent/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/ResetEvent/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_resetevent_test2
 add_dependencies(paltest_resetevent_test2 coreclrpal)
 
 target_link_libraries(paltest_resetevent_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/ResetEvent/test3/CMakeLists.txt b/src/pal/tests/palsuite/threading/ResetEvent/test3/CMakeLists.txt
index fd0d6e8b16..acb31489c4 100644
--- a/src/pal/tests/palsuite/threading/ResetEvent/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/ResetEvent/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_resetevent_test3
 add_dependencies(paltest_resetevent_test3 coreclrpal)
 
 target_link_libraries(paltest_resetevent_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/ResetEvent/test4/CMakeLists.txt b/src/pal/tests/palsuite/threading/ResetEvent/test4/CMakeLists.txt
index ca2a918775..d20135a040 100644
--- a/src/pal/tests/palsuite/threading/ResetEvent/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/ResetEvent/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_resetevent_test4
 add_dependencies(paltest_resetevent_test4 coreclrpal)
 
 target_link_libraries(paltest_resetevent_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/ResumeThread/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/ResumeThread/test1/CMakeLists.txt
index 96d7edcbba..0321a28b81 100644
--- a/src/pal/tests/palsuite/threading/ResumeThread/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/ResumeThread/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_resumethread_test1
 add_dependencies(paltest_resumethread_test1 coreclrpal)
 
 target_link_libraries(paltest_resumethread_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/SetErrorMode/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/SetErrorMode/test1/CMakeLists.txt
index 7c145a8528..ff90b41abe 100644
--- a/src/pal/tests/palsuite/threading/SetErrorMode/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/SetErrorMode/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_seterrormode_test1
 add_dependencies(paltest_seterrormode_test1 coreclrpal)
 
 target_link_libraries(paltest_seterrormode_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/SetEvent/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/SetEvent/test1/CMakeLists.txt
index 8d9d729554..56081c1814 100644
--- a/src/pal/tests/palsuite/threading/SetEvent/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/SetEvent/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setevent_test1
 add_dependencies(paltest_setevent_test1 coreclrpal)
 
 target_link_libraries(paltest_setevent_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/SetEvent/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/SetEvent/test2/CMakeLists.txt
index 7d33b56058..f94fb486b2 100644
--- a/src/pal/tests/palsuite/threading/SetEvent/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/SetEvent/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setevent_test2
 add_dependencies(paltest_setevent_test2 coreclrpal)
 
 target_link_libraries(paltest_setevent_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/SetEvent/test3/CMakeLists.txt b/src/pal/tests/palsuite/threading/SetEvent/test3/CMakeLists.txt
index 1c66460ea0..c2d48ba483 100644
--- a/src/pal/tests/palsuite/threading/SetEvent/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/SetEvent/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setevent_test3
 add_dependencies(paltest_setevent_test3 coreclrpal)
 
 target_link_libraries(paltest_setevent_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/SetEvent/test4/CMakeLists.txt b/src/pal/tests/palsuite/threading/SetEvent/test4/CMakeLists.txt
index 04f1815259..ae8adecb93 100644
--- a/src/pal/tests/palsuite/threading/SetEvent/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/SetEvent/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_setevent_test4
 add_dependencies(paltest_setevent_test4 coreclrpal)
 
 target_link_libraries(paltest_setevent_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/Sleep/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/Sleep/test1/CMakeLists.txt
index 601789600b..ec9d04f53b 100644
--- a/src/pal/tests/palsuite/threading/Sleep/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/Sleep/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sleep_test1
 add_dependencies(paltest_sleep_test1 coreclrpal)
 
 target_link_libraries(paltest_sleep_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/Sleep/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/Sleep/test2/CMakeLists.txt
index b8bc3ed7d7..b24f5e2808 100644
--- a/src/pal/tests/palsuite/threading/Sleep/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/Sleep/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sleep_test2
 add_dependencies(paltest_sleep_test2 coreclrpal)
 
 target_link_libraries(paltest_sleep_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/SleepEx/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/SleepEx/test1/CMakeLists.txt
index b2aed8333b..cf240d7f1a 100644
--- a/src/pal/tests/palsuite/threading/SleepEx/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/SleepEx/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sleepex_test1
 add_dependencies(paltest_sleepex_test1 coreclrpal)
 
 target_link_libraries(paltest_sleepex_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/SleepEx/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/SleepEx/test2/CMakeLists.txt
index 991e9b40e2..6762ec78d7 100644
--- a/src/pal/tests/palsuite/threading/SleepEx/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/SleepEx/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_sleepex_test2
 add_dependencies(paltest_sleepex_test2 coreclrpal)
 
 target_link_libraries(paltest_sleepex_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/SwitchToThread/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/SwitchToThread/test1/CMakeLists.txt
index b9008c486f..18390a6059 100644
--- a/src/pal/tests/palsuite/threading/SwitchToThread/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/SwitchToThread/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_switchtothread_test1
 add_dependencies(paltest_switchtothread_test1 coreclrpal)
 
 target_link_libraries(paltest_switchtothread_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/TLS/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/TLS/test1/CMakeLists.txt
index fef741272f..85795fa2ea 100644
--- a/src/pal/tests/palsuite/threading/TLS/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/TLS/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_tls_test1
 add_dependencies(paltest_tls_test1 coreclrpal)
 
 target_link_libraries(paltest_tls_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/TLS/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/TLS/test2/CMakeLists.txt
index 10c5034589..1dde9e6cb7 100644
--- a/src/pal/tests/palsuite/threading/TLS/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/TLS/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_tls_test2
 add_dependencies(paltest_tls_test2 coreclrpal)
 
 target_link_libraries(paltest_tls_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/TLS/test3/CMakeLists.txt b/src/pal/tests/palsuite/threading/TLS/test3/CMakeLists.txt
index 6bd76d3fdf..ac814bba93 100644
--- a/src/pal/tests/palsuite/threading/TLS/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/TLS/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_tls_test3
 add_dependencies(paltest_tls_test3 coreclrpal)
 
 target_link_libraries(paltest_tls_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/TLS/test4/CMakeLists.txt b/src/pal/tests/palsuite/threading/TLS/test4/CMakeLists.txt
index 73ba496f1d..40c1752f61 100644
--- a/src/pal/tests/palsuite/threading/TLS/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/TLS/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_tls_test4
 add_dependencies(paltest_tls_test4 coreclrpal)
 
 target_link_libraries(paltest_tls_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/TLS/test5/CMakeLists.txt b/src/pal/tests/palsuite/threading/TLS/test5/CMakeLists.txt
index e26fcfff26..c6367f5660 100644
--- a/src/pal/tests/palsuite/threading/TLS/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/TLS/test5/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_tls_test5
 add_dependencies(paltest_tls_test5 coreclrpal)
 
 target_link_libraries(paltest_tls_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/TLS/test6_optimizedtls/CMakeLists.txt b/src/pal/tests/palsuite/threading/TLS/test6_optimizedtls/CMakeLists.txt
index bfc7b75e0b..b1ca82c304 100644
--- a/src/pal/tests/palsuite/threading/TLS/test6_optimizedtls/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/TLS/test6_optimizedtls/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_tls_test6_optimizedtls
 add_dependencies(paltest_tls_test6_optimizedtls coreclrpal)
 
 target_link_libraries(paltest_tls_test6_optimizedtls
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/TerminateProcess/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/TerminateProcess/test1/CMakeLists.txt
index 382e801e29..6cac1488e2 100644
--- a/src/pal/tests/palsuite/threading/TerminateProcess/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/TerminateProcess/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_terminateprocess_test1
 add_dependencies(paltest_terminateprocess_test1 coreclrpal)
 
 target_link_libraries(paltest_terminateprocess_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/ThreadPriority/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/ThreadPriority/test1/CMakeLists.txt
index 026f4ed043..7ca88c7001 100644
--- a/src/pal/tests/palsuite/threading/ThreadPriority/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/ThreadPriority/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_threadpriority_test1
 add_dependencies(paltest_threadpriority_test1 coreclrpal)
 
 target_link_libraries(paltest_threadpriority_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/WaitForMultipleObjects/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/WaitForMultipleObjects/test1/CMakeLists.txt
index ea13c7de4c..f7ab138611 100644
--- a/src/pal/tests/palsuite/threading/WaitForMultipleObjects/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/WaitForMultipleObjects/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_waitformultipleobjects_test1
 add_dependencies(paltest_waitformultipleobjects_test1 coreclrpal)
 
 target_link_libraries(paltest_waitformultipleobjects_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test1/CMakeLists.txt
index 59d4cd8cd4..605c59f7e2 100644
--- a/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_waitformultipleobjectsex_test1
 add_dependencies(paltest_waitformultipleobjectsex_test1 coreclrpal)
 
 target_link_libraries(paltest_waitformultipleobjectsex_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test2/CMakeLists.txt b/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test2/CMakeLists.txt
index e970ec526e..fb74acc289 100644
--- a/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test2/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test2/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_waitformultipleobjectsex_test2
 add_dependencies(paltest_waitformultipleobjectsex_test2 coreclrpal)
 
 target_link_libraries(paltest_waitformultipleobjectsex_test2
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test3/CMakeLists.txt b/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test3/CMakeLists.txt
index f1b76fb819..a00e2fdce4 100644
--- a/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test3/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test3/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_waitformultipleobjectsex_test3
 add_dependencies(paltest_waitformultipleobjectsex_test3 coreclrpal)
 
 target_link_libraries(paltest_waitformultipleobjectsex_test3
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test4/CMakeLists.txt b/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test4/CMakeLists.txt
index 815b2b069c..85be0e77ad 100644
--- a/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test4/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test4/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_waitformultipleobjectsex_test4
 add_dependencies(paltest_waitformultipleobjectsex_test4 coreclrpal)
 
 target_link_libraries(paltest_waitformultipleobjectsex_test4
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test5/CMakeLists.txt b/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test5/CMakeLists.txt
index 730ec60649..14b8dc1755 100644
--- a/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test5/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test5/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_waitformultipleobjectsex_test5
 add_dependencies(paltest_waitformultipleobjectsex_test5 coreclrpal)
 
 target_link_libraries(paltest_waitformultipleobjectsex_test5
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_waitformultipleobjectsex_test5_helper
 add_dependencies(paltest_waitformultipleobjectsex_test5_helper coreclrpal)
 
 target_link_libraries(paltest_waitformultipleobjectsex_test5_helper
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test6/CMakeLists.txt b/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test6/CMakeLists.txt
index 01331821a8..88254b9eb6 100644
--- a/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test6/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/WaitForMultipleObjectsEx/test6/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_waitformultipleobjectsex_test6
 add_dependencies(paltest_waitformultipleobjectsex_test6 coreclrpal)
 
 target_link_libraries(paltest_waitformultipleobjectsex_test6
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_waitformultipleobjectsex_test6_child
 add_dependencies(paltest_waitformultipleobjectsex_test6_child coreclrpal)
 
 target_link_libraries(paltest_waitformultipleobjectsex_test6_child
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOExMutexTest/CMakeLists.txt b/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOExMutexTest/CMakeLists.txt
index 816a98bf2f..1e51e47f60 100644
--- a/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOExMutexTest/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOExMutexTest/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_waitforsingleobject_wfsoexmutextest
 add_dependencies(paltest_waitforsingleobject_wfsoexmutextest coreclrpal)
 
 target_link_libraries(paltest_waitforsingleobject_wfsoexmutextest
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOExSemaphoreTest/CMakeLists.txt b/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOExSemaphoreTest/CMakeLists.txt
index 2d12b25e69..a36649178c 100644
--- a/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOExSemaphoreTest/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOExSemaphoreTest/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_waitforsingleobject_wfsoexsemaphoretest
 add_dependencies(paltest_waitforsingleobject_wfsoexsemaphoretest coreclrpal)
 
 target_link_libraries(paltest_waitforsingleobject_wfsoexsemaphoretest
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOExThreadTest/CMakeLists.txt b/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOExThreadTest/CMakeLists.txt
index 915ee94a62..b7940cdee5 100644
--- a/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOExThreadTest/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOExThreadTest/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_waitforsingleobject_wfsoexthreadtest
 add_dependencies(paltest_waitforsingleobject_wfsoexthreadtest coreclrpal)
 
 target_link_libraries(paltest_waitforsingleobject_wfsoexthreadtest
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOMutexTest/CMakeLists.txt b/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOMutexTest/CMakeLists.txt
index b96324d654..0446a9aee2 100644
--- a/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOMutexTest/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOMutexTest/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_waitforsingleobject_wfsomutextest
 add_dependencies(paltest_waitforsingleobject_wfsomutextest coreclrpal)
 
 target_link_libraries(paltest_waitforsingleobject_wfsomutextest
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOProcessTest/CMakeLists.txt b/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOProcessTest/CMakeLists.txt
index 61e17eb3ad..b0a250e484 100644
--- a/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOProcessTest/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOProcessTest/CMakeLists.txt
@@ -13,9 +13,7 @@ add_executable(paltest_waitforsingleobject_wfsoprocesstest
 add_dependencies(paltest_waitforsingleobject_wfsoprocesstest coreclrpal)
 
 target_link_libraries(paltest_waitforsingleobject_wfsoprocesstest
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
 
 
@@ -30,7 +28,5 @@ add_executable(paltest_waitforsingleobject_wfsoprocesstest_child
 add_dependencies(paltest_waitforsingleobject_wfsoprocesstest_child coreclrpal)
 
 target_link_libraries(paltest_waitforsingleobject_wfsoprocesstest_child
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOSemaphoreTest/CMakeLists.txt b/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOSemaphoreTest/CMakeLists.txt
index d17f8da8e5..474edde7fd 100644
--- a/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOSemaphoreTest/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOSemaphoreTest/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_waitforsingleobject_wfsosemaphoretest
 add_dependencies(paltest_waitforsingleobject_wfsosemaphoretest coreclrpal)
 
 target_link_libraries(paltest_waitforsingleobject_wfsosemaphoretest
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOThreadTest/CMakeLists.txt b/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOThreadTest/CMakeLists.txt
index e2d36e08e1..5988b6a8f4 100644
--- a/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOThreadTest/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/WaitForSingleObject/WFSOThreadTest/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_waitforsingleobject_wfsothreadtest
 add_dependencies(paltest_waitforsingleobject_wfsothreadtest coreclrpal)
 
 target_link_libraries(paltest_waitforsingleobject_wfsothreadtest
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/WaitForSingleObject/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/WaitForSingleObject/test1/CMakeLists.txt
index 25f3739492..44a9d8fe6a 100644
--- a/src/pal/tests/palsuite/threading/WaitForSingleObject/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/WaitForSingleObject/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_waitforsingleobject_test1
 add_dependencies(paltest_waitforsingleobject_test1 coreclrpal)
 
 target_link_libraries(paltest_waitforsingleobject_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/YieldProcessor/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/YieldProcessor/test1/CMakeLists.txt
index 1c600bd81c..83a5616144 100644
--- a/src/pal/tests/palsuite/threading/YieldProcessor/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/YieldProcessor/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_yieldprocessor_test1
 add_dependencies(paltest_yieldprocessor_test1 coreclrpal)
 
 target_link_libraries(paltest_yieldprocessor_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tests/palsuite/threading/releasesemaphore/test1/CMakeLists.txt b/src/pal/tests/palsuite/threading/releasesemaphore/test1/CMakeLists.txt
index 4f6947476d..6941fb06b4 100644
--- a/src/pal/tests/palsuite/threading/releasesemaphore/test1/CMakeLists.txt
+++ b/src/pal/tests/palsuite/threading/releasesemaphore/test1/CMakeLists.txt
@@ -13,7 +13,5 @@ add_executable(paltest_releasesemaphore_test1
 add_dependencies(paltest_releasesemaphore_test1 coreclrpal)
 
 target_link_libraries(paltest_releasesemaphore_test1
-  pthread
-  m
-  coreclrpal
+  ${COMMON_TEST_LIBRARIES}
 )
diff --git a/src/pal/tools/clang-compiler-override-arm.txt b/src/pal/tools/clang-compiler-override-arm.txt
new file mode 100644
index 0000000000..da25715ade
--- /dev/null
+++ b/src/pal/tools/clang-compiler-override-arm.txt
@@ -0,0 +1,20 @@
+SET (CMAKE_C_FLAGS_INIT                "-Wall -std=c11")
+SET (CMAKE_C_FLAGS_DEBUG_INIT          "-g -O0")
+SET (CLR_C_FLAGS_CHECKED_INIT          "-g -O1")
+# Refer to the below instruction to support __thread with -O2/-O3 on Linux/ARM
+# https://github.com/dotnet/coreclr/blob/master/Documentation/building/linux-instructions.md
+SET (CMAKE_C_FLAGS_RELEASE_INIT        "-g -O1")
+SET (CMAKE_C_FLAGS_RELWITHDEBINFO_INIT "-g -O1")
+
+SET (CMAKE_CXX_FLAGS_INIT                "-Wall -Wno-null-conversion -std=c++11")
+SET (CMAKE_CXX_FLAGS_DEBUG_INIT          "-g -O0")
+SET (CLR_CXX_FLAGS_CHECKED_INIT          "-g -O1")
+SET (CMAKE_CXX_FLAGS_RELEASE_INIT        "-g -O1")
+SET (CMAKE_CXX_FLAGS_RELWITHDEBINFO_INIT "-g -O1")
+
+SET (CLR_DEFINES_DEBUG_INIT              DEBUG _DEBUG _DBG URTBLDENV_FRIENDLY=Checked BUILDENV_CHECKED=1)
+SET (CLR_DEFINES_CHECKED_INIT            DEBUG _DEBUG _DBG URTBLDENV_FRIENDLY=Checked BUILDENV_CHECKED=1)
+SET (CLR_DEFINES_RELEASE_INIT            NDEBUG URTBLDENV_FRIENDLY=Retail)
+SET (CLR_DEFINES_RELWITHDEBINFO_INIT     NDEBUG URTBLDENV_FRIENDLY=Retail)
+
+SET (CMAKE_INSTALL_PREFIX                $ENV{__CMakeBinDir})
diff --git a/src/pal/tools/gen-buildsys-clang.sh b/src/pal/tools/gen-buildsys-clang.sh
index 5d4d4c8920..db342eb2c9 100755
--- a/src/pal/tools/gen-buildsys-clang.sh
+++ b/src/pal/tools/gen-buildsys-clang.sh
@@ -144,9 +144,15 @@ if [ "$build_arch" == "armel" ]; then
     cmake_extra_defines="$cmake_extra_defines -DARM_SOFTFP=1"
 fi
 
+if [ "$build_arch" == "arm" -o "$build_arch" == "armel" ]; then
+    overridefile=clang-compiler-override-arm.txt  
+else
+    overridefile=clang-compiler-override.txt  
+fi
+
 cmake \
   -G "$generator" \
-  "-DCMAKE_USER_MAKE_RULES_OVERRIDE=$1/src/pal/tools/clang-compiler-override.txt" \
+  "-DCMAKE_USER_MAKE_RULES_OVERRIDE=$1/src/pal/tools/$overridefile" \
   "-DCMAKE_AR=$llvm_ar" \
   "-DCMAKE_LINKER=$llvm_link" \
   "-DCMAKE_NM=$llvm_nm" \
diff --git a/src/publish.proj b/src/publish.proj
index d4e4a7f24b..c6c2149ba3 100644
--- a/src/publish.proj
+++ b/src/publish.proj
@@ -14,7 +14,7 @@
     <ItemGroup>
       <ForPublishing>
         <RelativeBlobPath Condition="'$(PublishTestNativeBins)' != 'true'">$(__BuildType)/%(RecursiveDir)%(Filename)%(Extension)</RelativeBlobPath>
-        <RelativeBlobPath Condition="'$(PublishTestNativeBins)' == 'true'">$(__DistroRid)-$(__BuildArch)/$(__BuildType)/%(RecursiveDir)%(Filename)%(Extension)</RelativeBlobPath>    
+        <RelativeBlobPath Condition="'$(PublishTestNativeBins)' == 'true'">$(__BuildType)/%(RecursiveDir)%(Filename)%(Extension)</RelativeBlobPath>    
       </ForPublishing>
     </ItemGroup>
     <Error Condition="'@(ForPublishing)' == ''" Text="No items were found matching pattern '$(PublishPattern)'." />
@@ -22,7 +22,7 @@
 
   <PropertyGroup>
     <PublishPattern Condition="'$(PublishPattern)' == '' and '$(PublishTestNativeBins)' != 'true'">$(PackagesBinDir)**\*.nupkg</PublishPattern>
-    <PublishPattern Condition="'$(PublishPattern)' == '' and '$(PublishTestNativeBins)' == 'true'">$(OutputPath)\tests\src\**</PublishPattern>
+    <PublishPattern Condition="'$(PublishPattern)' == '' and '$(PublishTestNativeBins)' == 'true'">$(OutputPath)\bin\**</PublishPattern>
   </PropertyGroup>
 
   <Target Name="CreateContainerName"
@@ -30,9 +30,10 @@
           Condition="'$(ContainerName)' == '' or '$(PublishTestNativeBins)' == 'true'">
     <PropertyGroup>
       <ContainerName Condition="'$(__Container)' == '' and '$(PublishTestNativeBins)' != 'true'">coreclr-$(PreReleaseLabel)-$(BuildNumberMajor)-$(BuildNumberMinor)</ContainerName>
-      <ContainerName Condition="'$(__Container)' == '' and '$(PublishTestNativeBins)' == 'true'">coreclr-$(PreReleaseLabel)-$(BuildNumberMajor)-$(BuildNumberMinor)-test-native-bins</ContainerName>
+      <ContainerName Condition="'$(__Container)' == '' and '$(PublishTestNativeBins)' == 'true'">coreclr-$(PreReleaseLabel)-$(BuildNumberMajor)-$(BuildNumberMinor)-$(__DistroRid)-$(__BuildArch)</ContainerName>
       <ContainerName Condition="'$(__Container)' != '' and '$(PublishTestNativeBins)' != 'true'">$(__Container)</ContainerName>
-      <ContainerName Condition="'$(__Container)' != '' and '$(PublishTestNativeBins)' == 'true'">$(__Container)-test-native-bins</ContainerName>
+      <ContainerName Condition="'$(__Container)' != '' and '$(PublishTestNativeBins)' == 'true'">$(__Container)-$(__DistroRid)-$(__BuildArch)</ContainerName>
+      <ContainerName>$(ContainerName.Replace(".","-"))</ContainerName>
     </PropertyGroup>
   </Target>
 
diff --git a/src/strongname/api/strongname.cpp b/src/strongname/api/strongname.cpp
index 00b115698c..09c438b213 100644
--- a/src/strongname/api/strongname.cpp
+++ b/src/strongname/api/strongname.cpp
@@ -113,9 +113,6 @@ enum StrongNameCachedCsp {
 // allocated lazily as needed.
 struct SN_THREAD_CTX {
     DWORD       m_dwLastError;
-#if !defined(FEATURE_CORECLR)
-    HCRYPTPROV  m_hProv[CachedCspCount];
-#endif // !FEATURE_CORECLR
 };
 
 #endif // !DACCESS_COMPILE
@@ -170,8 +167,6 @@ struct SN_THREAD_CTX {
                                 memcmp((_pk), g_rbTheKey, sizeof(g_rbTheKey)) == 0)
 
 
-#ifdef FEATURE_CORECLR
-
 // Silverlight platform key
 #define SN_THE_SILVERLIGHT_PLATFORM_KEYTOKEN() ((PublicKeyBlob*)g_rbTheSilverlightPlatformKeyToken)
 #define SN_IS_THE_SILVERLIGHT_PLATFORM_KEY(_pk) (SN_SIZEOF_KEY((PublicKeyBlob*)(_pk)) == sizeof(g_rbTheSilverlightPlatformKey) && \
@@ -197,4480 +192,9 @@ struct SN_THREAD_CTX {
                                 memcmp((_pk), g_rbTheMicrosoftXNAKey, sizeof(g_rbTheMicrosoftXNAKey)) == 0)
 
 #endif // FEATURE_WINDOWSPHONE
-#endif // FEATURE_CORECLR
-
-#if !defined(FEATURE_CORECLR)
-
-#ifdef FEATURE_STRONGNAME_MIGRATION
-#include "caparser.h"
-#include "custattr.h"
-#include "cahlprinternal.h"
-#endif // FEATURE_STRONGNAME_MIGRATION
-
-// The maximum length of CSP name we support (in characters).
-#define SN_MAX_CSP_NAME 1024
-
-// If we're being built as a standalone library, then we shouldn't redirect through the hosting APIs
-#if !STRONGNAME_IN_VM
-
-#undef MapViewOfFile
-#undef UnmapViewOfFile
-
-#define CLRMapViewOfFile MapViewOfFile
-#define CLRUnmapViewOfFile UnmapViewOfFile
-
-#if FEATURE_STANDALONE_SN && !FEATURE_CORECLR
-
-// We will need to call into shim, therefore include new hosting APIs
-#include "metahost.h"
-#include "clrinternal.h"
-
-#endif //FEATURE_STANDALONE_SN && !FEATURE_CORECLR
-
-#define DONOT_DEFINE_ETW_CALLBACK
-
-#endif // !STRONGNAME_IN_VM
-#include "eventtracebase.h"
-
-#ifndef DACCESS_COMPILE
-
-// Flag indicating whether the initialization of the strong name APIs has been completed.
-BOOLEAN g_bStrongNamesInitialized = FALSE;
-
-// Flag indicating whether it's OK to cache the results of verifying an assembly
-// whose file is accessible to users.
-BOOLEAN g_fCacheVerify = TRUE;
-
-// Algorithm IDs for hashing and signing. Like the CSP name, these values are
-// read from the registry at initialization time.
-ALG_ID g_uHashAlgId;
-ALG_ID g_uSignAlgId;
-
-// Flag read from the registry at initialization time. It controls the key spec 
-// to be used. AT_SIGNATURE will be the default.
-DWORD g_uKeySpec;
-
-// CSP provider type. PROV_RSA_FULL will be the default.
-DWORD g_uProvType;
-
-// Critical section used to serialize some non-thread safe crypto APIs.
-CRITSEC_COOKIE g_rStrongNameMutex = NULL;
-
-// Name of CSP to use. This is read from the registry at initialization time. If
-// not found we look up a CSP by hashing and signing algorithms (see below) or
-// use the default CSP.
-
-BOOLEAN g_bHasCSPName = FALSE;
-WCHAR g_wszCSPName[SN_MAX_CSP_NAME + 1] = {0};
-
-// Flag read from the registry at initialization time. Controls whether we use
-// machine or user based key containers.
-BOOLEAN g_bUseMachineKeyset = TRUE;
-
-#ifdef FEATURE_STRONGNAME_DELAY_SIGNING_ALLOWED
-// Verification Skip Records
-//
-// These are entries in the registry (usually set up by SN) that control whether
-// an assembly needs to pass signature verification to be considered valid (i.e.
-// return TRUE from StrongNameSignatureVerification). This is useful during
-// development when it's not feasible to fully sign each assembly on each build.
-// Assemblies to be skipped can be specified by name and public key token, all
-// assemblies with a given public key token or just all assemblies. Each entry
-// can be further qualified by a list of user names to which the records
-// applies. When matching against an entry, the most specific one wins.
-//
-// We read these entries at startup time and place them into a global, singly
-// linked, NULL terminated list.
-
-// Structure used to represent each record we find in the registry.
-struct SN_VER_REC {
-    SN_VER_REC     *m_pNext;                    // Pointer to next record (or NULL)
-    WCHAR          *m_wszAssembly;              // Assembly name/public key token as a string
-    WCHAR          *m_mszUserList;              // Pointer to multi-string list of valid users (or NULL)
-    WCHAR          *m_wszTestPublicKey;         // Test public key to use during strong name verification (or NULL)
-};
-
-// Head of the list of entries we found in the registry during initialization.
-SN_VER_REC *g_pVerificationRecords = NULL;
-#endif // FEATURE_STRONGNAME_DELAY_SIGNING_ALLOWED
-
-#ifdef FEATURE_STRONGNAME_MIGRATION
-
-struct SN_REPLACEMENT_KEY_REC {
-    SN_REPLACEMENT_KEY_REC *m_pNext;
-    BYTE               *m_pbReplacementKey;
-    ULONG               m_cbReplacementKey;
-};
-
-struct SN_REVOCATION_REC {
-    SN_REVOCATION_REC      *m_pNext;
-    BYTE                   *m_pbRevokedKey;
-    ULONG                   m_cbRevokedKey;
-    SN_REPLACEMENT_KEY_REC *m_pReplacementKeys;
-};
-
-SN_REVOCATION_REC *g_pRevocationRecords = NULL;
-
-#endif // FEATURE_STRONGNAME_MIGRATION
-
-#endif // #ifndef DACCESS_COMPILE
-
-
-
-#ifndef DACCESS_COMPILE
-
-// The actions that can be performed upon opening a CSP with LocateCSP.
-#define SN_OPEN_CONTAINER   0
-#define SN_IGNORE_CONTAINER 1
-#define SN_CREATE_CONTAINER 2
-#define SN_DELETE_CONTAINER 3
-#define SN_HASH_SHA1_ONLY   4
-
-// Macro to aid in setting flags for CryptAcquireContext based on container
-// actions above.
-#define SN_CAC_FLAGS(_act)                                                                      \
-    (((_act) == SN_OPEN_CONTAINER ? 0 :                                                         \
-      ((_act) == SN_HASH_SHA1_ONLY) || ((_act) == SN_IGNORE_CONTAINER) ? CRYPT_VERIFYCONTEXT :  \
-      (_act) == SN_CREATE_CONTAINER ? CRYPT_NEWKEYSET :                                         \
-      (_act) == SN_DELETE_CONTAINER ? CRYPT_DELETEKEYSET :                                      \
-      0) |                                                                                      \
-     (g_bUseMachineKeyset ? CRYPT_MACHINE_KEYSET : 0))
-
-// Substitute a strong name error if the error we're wrapping is not transient
-FORCEINLINE HRESULT SubstituteErrorIfNotTransient(HRESULT hrOriginal, HRESULT hrSubstitute)
-{
-    return Exception::IsTransient(hrOriginal) ? hrOriginal : hrSubstitute;
-}
-
-// Private routine prototypes.
-SN_THREAD_CTX *GetThreadContext();
-VOID SetStrongNameErrorInfo(DWORD dwStatus);
-HCRYPTPROV LocateCSP(LPCWSTR    wszKeyContainer,
-                     DWORD      dwAction,
-                     ALG_ID     uHashAlgId = 0,
-                     ALG_ID     uSignAlgId = 0);
-VOID FreeCSP(HCRYPTPROV hProv);
-HCRYPTPROV LookupCachedCSP(StrongNameCachedCsp cspNumber);
-VOID CacheCSP(HCRYPTPROV hProv, StrongNameCachedCsp cspNumber);
-BOOLEAN IsCachedCSP(HCRYPTPROV hProv);
-HRESULT ReadRegistryConfig();
-BOOLEAN LoadCryptoApis();
-#ifdef FEATURE_STRONGNAME_DELAY_SIGNING_ALLOWED
-HRESULT ReadVerificationRecords();
-
-#ifdef FEATURE_STRONGNAME_MIGRATION
-HRESULT ReadRevocationRecords();
-#endif // FEATURE_STRONGNAME_MIGRATION
-SN_VER_REC *GetVerificationRecord(__in_z __deref LPWSTR wszAssemblyName, PublicKeyBlob *pPublicKey);
-#endif // FEATURE_STRONGNAME_DELAY_SIGNING_ALLOWED
-
-BOOLEAN IsValidUser(__in_z WCHAR *mszUserList);
-BOOLEAN GetKeyContainerName(LPCWSTR *pwszKeyContainer, BOOLEAN *pbTempContainer);
-VOID FreeKeyContainerName(LPCWSTR wszKeyContainer, BOOLEAN bTempContainer);
-HRESULT GetMetadataImport(__in const SN_LOAD_CTX *pLoadCtx,
-                          __in mdAssembly *ptkAssembly,
-                          __out IMDInternalImport **ppMetaDataImport);
-HRESULT FindPublicKey(const SN_LOAD_CTX *pLoadCtx,
-                      __out_ecount_opt(cchAssemblyName) LPWSTR         wszAssemblyName,
-                      DWORD cchAssemblyName,
-                      __out PublicKeyBlob **ppPublicKey,
-                      DWORD *pcbPublicKey = NULL);
-PublicKeyBlob *GetPublicKeyFromHex(LPCWSTR wszPublicKeyHexString);
-BOOLEAN RehashModules(SN_LOAD_CTX *pLoadCtx, LPCWSTR szFilePath);
-HRESULT VerifySignature(SN_LOAD_CTX *pLoadCtx,
-                        DWORD dwInFlags,
-                        PublicKeyBlob *pRealEcmaPublicKey,
-                        DWORD *pdwOutFlags);
-HRESULT InitStrongNameCriticalSection();
-HRESULT InitStrongName();
-typedef BOOLEAN (*HashFunc)(HCRYPTHASH hHash, PBYTE start, DWORD length, DWORD flags, void* cookie);
-BOOLEAN ComputeHash(SN_LOAD_CTX *pLoadCtx, HCRYPTHASH hHash, HashFunc func, void* cookie);
-bool VerifyKeyMatchesAssembly(PublicKeyBlob * pAssemblySignaturePublicKey, __in_z LPCWSTR wszKeyContainer, BYTE *pbKeyBlob, ULONG cbKeyBlob, DWORD dwFlags);
-
-#ifdef FEATURE_STRONGNAME_MIGRATION
-HRESULT GetVerifiedSignatureKey(__in SN_LOAD_CTX *pLoadCtx, __out PublicKeyBlob **ppPublicKey, __out DWORD *pcbPublicKey = NULL);
-#endif // FEATURE_STRONGNAME_MIGRATION
-
-#if defined(_DEBUG) && !defined(DACCESS_COMPILE)
-
-void DbgCount(__in_z WCHAR *szCounterName)
-{
-
-#ifndef FEATURE_CORECLR
-    if (g_fLoggingInitialized && !(g_dwLoggingFlags & 4))
-        return;
-
-    DWORD dwError = GetLastError();
-
-    if (!g_fLoggingInitialized) {
-        g_dwLoggingFlags = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_MscorsnLogging);
-        g_fLoggingInitialized = TRUE;
-    }
-
-    if (!(g_dwLoggingFlags & 4)) {
-        SetLastError(dwError);
-        return;
-    }
-
-    HKEY    hKey = NULL;
-    DWORD   dwCounter = 0;
-    DWORD   dwBytes;
-
-    if (WszRegCreateKeyEx(HKEY_LOCAL_MACHINE,
-                          SN_CONFIG_KEY_W W("\\Counters"),
-                          0,
-                          NULL,
-                          0,
-                          KEY_ALL_ACCESS,
-                          NULL,
-                          &hKey,
-                          NULL) != ERROR_SUCCESS)
-        goto End;
-
-    WszRegQueryValueEx(hKey, szCounterName, NULL, NULL, (BYTE*)&dwCounter, &dwBytes);
-    dwCounter++;
-    WszRegSetValueEx(hKey, szCounterName, NULL, REG_DWORD, (BYTE*)&dwCounter, sizeof(DWORD));
-
- End:
-    if (hKey)
-        RegCloseKey(hKey);
-    SetLastError(dwError);
-
-#endif //#ifndef FEATURE_CORECLR
-
-}
-
-
-void HexDump(BYTE  *pbData,
-    DWORD  cbData)
-{
-    if (g_dwLoggingFlags == 0)
-        return;
-
-    DWORD dwRow, dwCol;
-    WCHAR  wszBuffer[1024];
-    WCHAR  *wszPtr = wszBuffer;
-
-#define SN_PUSH0(_fmt)          do { wszPtr += swprintf_s(wszPtr, COUNTOF(wszBuffer) - (wszPtr - wszBuffer), _fmt); } while (false)
-#define SN_PUSH1(_fmt, _arg1)   do { wszPtr += swprintf_s(wszPtr, COUNTOF(wszBuffer) - (wszPtr - wszBuffer), _fmt, _arg1); } while (false)
-
-    wszBuffer[0] = W('\0');
-
-    for (dwRow = 0; dwRow < ((cbData + 15) / 16); dwRow++) {
-        SN_PUSH1(W("%08p "), pbData + (16 * dwRow));
-        for (dwCol = 0; dwCol < 16; dwCol++)
-        if (((dwRow * 16) + dwCol) < cbData)
-            SN_PUSH1(W("%02X "), pbData[(dwRow * 16) + dwCol]);
-        else
-            SN_PUSH0(W("   "));
-        for (dwCol = 0; dwCol < 16; dwCol++)
-        if (((dwRow * 16) + dwCol) < cbData) {
-            unsigned char c = pbData[(dwRow * 16) + dwCol];
-            if ((c >= 32) && (c <= 127))
-                SN_PUSH1(W("%c"), c);
-            else
-                SN_PUSH0(W("."));
-        } else
-            SN_PUSH0(W(" "));
-        SN_PUSH0(W("\n"));
-    }
-#undef SN_PUSH1
-#undef SN_PUSH0
-
-    _ASSERTE(wszPtr < &wszBuffer[COUNTOF(wszBuffer)]);
-
-    Log(W("%s"), wszBuffer);
-}
-
-#else // _DEBUG && !DACCESS_COMPILE
-
-#define HexDump(x)
-#define DbgCount(x)
-
-#endif // _DEBUG && !DACCESS_COMPILE
-
-
-BOOLEAN CalculateSize(HCRYPTHASH hHash, PBYTE start, DWORD length, DWORD flags, void* cookie)
-{
-    *(size_t*)cookie += length;
-    return TRUE;
-}
-
-struct CopyDataBufferDesc
-{
-    PBYTE pbData;
-    DWORD cbDataSize;
-};
-
-BOOLEAN CopyData(HCRYPTHASH hHash, PBYTE start, DWORD length, DWORD flags, void* cookie)
-{
-    _ASSERTE(cookie);
-
-    CopyDataBufferDesc *pBuffer = reinterpret_cast<CopyDataBufferDesc *>(cookie);
-    _ASSERTE(pBuffer->pbData);
-
-    memcpy_s(pBuffer->pbData, pBuffer->cbDataSize, start, length);
-    pBuffer->pbData += length;
-
-    _ASSERTE(pBuffer->cbDataSize >= length);
-    pBuffer->cbDataSize = pBuffer->cbDataSize >= length ? pBuffer->cbDataSize - length : 0;
-
-    return TRUE;
-}
-
-BOOLEAN CalcHash(HCRYPTHASH hHash, PBYTE start, DWORD length, DWORD flags, void* cookie)
-{
-    return CryptHashData(hHash, start, length, flags);
-}
-
-VOID
-WINAPI Fls_Callback (
-    IN PVOID lpFlsData
-    )
-{
-    STATIC_CONTRACT_SO_TOLERANT;
-    SN_THREAD_CTX *pThreadCtx = (SN_THREAD_CTX*)lpFlsData;
-    if (pThreadCtx != NULL) {
-        for(ULONG i = 0; i < CachedCspCount; i++)
-        {
-            if (pThreadCtx->m_hProv[i])
-                CryptReleaseContext(pThreadCtx->m_hProv[i], 0);
-        }
-        
-        delete pThreadCtx;
-    }
-}
-
-HRESULT InitStrongNameCriticalSection()
-{
-    if (g_rStrongNameMutex)
-        return S_OK;
-
-    CRITSEC_COOKIE pv = ClrCreateCriticalSection(CrstStrongName, CRST_DEFAULT);
-    if (pv == NULL)
-        return E_OUTOFMEMORY;
-
-    if (InterlockedCompareExchangeT(&g_rStrongNameMutex, pv, NULL) != NULL)
-        ClrDeleteCriticalSection(pv);
-    return S_OK;
-}
-
-HRESULT InitStrongName()
-{
-    HRESULT hr = S_OK;
-    if (g_bStrongNamesInitialized)
-        return hr;
-
-    // Read CSP configuration info from the registry (if provided).
-    hr = ReadRegistryConfig();
-    if (FAILED(hr))
-        return hr;
-
-    // Associate a callback for freeing our TLS data.
-    ClrFlsAssociateCallback(TlsIdx_StrongName, Fls_Callback);
-
-    g_bStrongNamesInitialized = TRUE;
-
-    return hr;
-}
-
-// Generate a new key pair for strong name use.
-SNAPI StrongNameKeyGen(LPCWSTR  wszKeyContainer,    // [in] desired key container name, must be a non-empty string
-                       DWORD    dwFlags,            // [in] flags (see below)
-                       BYTE   **ppbKeyBlob,         // [out] public/private key blob
-                       ULONG   *pcbKeyBlob)
-{
-    BOOLEAN retVal = FALSE;
-    BEGIN_ENTRYPOINT_VOIDRET;
-
-    SN_COMMON_PROLOG();
-
-    if (wszKeyContainer == NULL && ppbKeyBlob == NULL)
-        SN_ERROR(E_INVALIDARG);
-    if (ppbKeyBlob != NULL && pcbKeyBlob == NULL)
-        SN_ERROR(E_POINTER);
-
-    DWORD dwKeySize;
-
-    // We set a key size of 1024 if we're using the default
-    // signing algorithm (RSA), otherwise we leave it at the default.
-    if (g_uSignAlgId == CALG_RSA_SIGN)
-        dwKeySize = 1024;
-    else
-        dwKeySize = 0;
-
-    retVal = StrongNameKeyGenEx(wszKeyContainer, dwFlags, dwKeySize, ppbKeyBlob, pcbKeyBlob);
-
-Exit:
-    END_ENTRYPOINT_VOIDRET;
-    return retVal;
-}
-
-// Generate a new key pair with the specified key size for strong name use.
-SNAPI StrongNameKeyGenEx(LPCWSTR  wszKeyContainer,    // [in] desired key container name, must be a non-empty string
-                         DWORD    dwFlags,            // [in] flags (see below)
-                         DWORD    dwKeySize,          // [in] desired key size.
-                         BYTE   **ppbKeyBlob,         // [out] public/private key blob
-                         ULONG   *pcbKeyBlob)
-{
-    BOOLEAN     retVal = FALSE;
-
-    BEGIN_ENTRYPOINT_VOIDRET;
-
-    HCRYPTPROV  hProv = NULL;
-    HCRYPTKEY   hKey = NULL;
-    BOOLEAN     bTempContainer = FALSE;
-
-    SNLOG((W("StrongNameKeyGenEx(\"%s\", %08X, %08X, %08X, %08X)\n"), wszKeyContainer, dwFlags, dwKeySize, ppbKeyBlob, pcbKeyBlob));
-
-    SN_COMMON_PROLOG();
-
-    if (wszKeyContainer == NULL && ppbKeyBlob == NULL)
-        SN_ERROR(E_INVALIDARG);
-    if (ppbKeyBlob != NULL && pcbKeyBlob == NULL)
-        SN_ERROR(E_POINTER);
-
-    // Check to see if a temporary container name is needed.
-    _ASSERTE((wszKeyContainer != NULL) || !(dwFlags & SN_LEAVE_KEY));
-    if (!GetKeyContainerName(&wszKeyContainer, &bTempContainer))
-    {
-        goto Exit;
-    }
-
-    // Open a CSP and container.
-    hProv = LocateCSP(wszKeyContainer, SN_CREATE_CONTAINER);
-    if (!hProv)
-        goto Error;
-
-
-    // Generate the new key pair, try for exportable first.
-    // Note: The key size in bits is encoded in the upper
-    // 16-bits of a DWORD (and OR'd together with other flags for the
-    // CryptGenKey call). 
-    if (!CryptGenKey(hProv, g_uKeySpec, (dwKeySize << 16) | CRYPT_EXPORTABLE, &hKey)) {
-        SNLOG((W("Couldn't create exportable key, trying for non-exportable: %08X\n"), GetLastError()));
-        if (!CryptGenKey(hProv, g_uKeySpec, dwKeySize << 16, &hKey)) {
-            SNLOG((W("Couldn't create key pair: %08X\n"), GetLastError()));
-            goto Error;
-        }
-    }
-
-#if defined(_DEBUG) && !defined(DACCESS_COMPILE)
-    if (g_bHasCSPName) {
-        ALG_ID  uAlgId;
-        DWORD   dwAlgIdLen = sizeof(uAlgId);
-        // Check that signature algorithm used was the one we expected.
-        if (CryptGetKeyParam(hKey, KP_ALGID, (BYTE*)&uAlgId, &dwAlgIdLen, 0)) {
-            _ASSERTE(uAlgId == g_uSignAlgId);
-        } else
-            SNLOG((W("Failed to get key params: %08X\n"), GetLastError()));
-    }
-#endif // _DEBUG
-
-    // If the user wants the key pair back, attempt to export it.
-    if (ppbKeyBlob) {
-
-        // Calculate length of blob first;
-        if (!CryptExportKey(hKey, 0, PRIVATEKEYBLOB, 0, NULL, pcbKeyBlob)) {
-            SNLOG((W("Couldn't export key pair: %08X\n"), GetLastError()));
-            goto Error;
-        }
-
-        // Allocate a buffer of the right size.
-        *ppbKeyBlob = new (nothrow) BYTE[*pcbKeyBlob];
-        if (*ppbKeyBlob == NULL) {
-            SetLastError(E_OUTOFMEMORY);
-            goto Error;
-        }
-
-        // Export the key pair.
-        if (!CryptExportKey(hKey, 0, PRIVATEKEYBLOB, 0, *ppbKeyBlob, pcbKeyBlob)) {
-            SNLOG((W("Couldn't export key pair: %08X\n"), GetLastError()));
-            delete[] *ppbKeyBlob;
-            *ppbKeyBlob = NULL;
-            goto Error;
-        }
-    }
-
-    // Destroy the key handle (but not the key pair itself).
-    CryptDestroyKey(hKey);
-    hKey = NULL;
-
-    // Release the CSP.
-    FreeCSP(hProv);
-
-    // If the user didn't explicitly want to keep the key pair around, delete the
-    // key container.
-    if (!(dwFlags & SN_LEAVE_KEY) || bTempContainer)
-        LocateCSP(wszKeyContainer, SN_DELETE_CONTAINER);
-
-    // Free temporary key container name if allocated.
-    FreeKeyContainerName(wszKeyContainer, bTempContainer);
-    retVal = TRUE;
-    goto Exit;
-
- Error:
-    SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-    if (hKey)
-        CryptDestroyKey(hKey);
-    if (hProv) {
-        FreeCSP(hProv);
-        if (!(dwFlags & SN_LEAVE_KEY) || bTempContainer)
-            LocateCSP(wszKeyContainer, SN_DELETE_CONTAINER);
-    }
-    FreeKeyContainerName(wszKeyContainer, bTempContainer);
-
- Exit:
-    END_ENTRYPOINT_VOIDRET;
-    return retVal;
-}
-
-
-// Import key pair into a key container.
-SNAPI StrongNameKeyInstall(LPCWSTR  wszKeyContainer,// [in] desired key container name, must be a non-empty string
-                           BYTE    *pbKeyBlob,      // [in] public/private key pair blob
-                           ULONG    cbKeyBlob)
-{
-    BOOLEAN retVal = FALSE;
-
-    BEGIN_ENTRYPOINT_VOIDRET;
-
-    HCRYPTPROV  hProv = NULL;
-    HCRYPTKEY   hKey = NULL;
-
-    SNLOG((W("StrongNameKeyInstall(\"%s\", %08X, %08X)\n"), wszKeyContainer, pbKeyBlob, cbKeyBlob));
-
-    SN_COMMON_PROLOG();
-
-    if (wszKeyContainer == NULL)
-        SN_ERROR(E_POINTER);
-    if (pbKeyBlob == NULL)
-        SN_ERROR(E_POINTER);
-    if (cbKeyBlob == 0)
-        SN_ERROR(E_INVALIDARG);
-
-    // Open a CSP and container.
-    hProv = LocateCSP(wszKeyContainer, SN_CREATE_CONTAINER);
-    if (!hProv) {
-        SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-        goto Exit;
-    }
-
-    // Import the key pair.
-    if (!CryptImportKey(hProv,
-                           pbKeyBlob,
-                           cbKeyBlob,
-                           0, 0, &hKey)) {
-        SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-        FreeCSP(hProv);
-        goto Exit;
-    }
-
-    // Release the CSP.
-    FreeCSP(hProv);
-    retVal = TRUE;
-Exit:
-
-    END_ENTRYPOINT_VOIDRET;
-    return retVal;
-}
-
-
-// Delete a key pair.
-SNAPI StrongNameKeyDelete(LPCWSTR wszKeyContainer)  // [in] desired key container name
-{
-    BOOLEAN retVal = FALSE;
-
-    BEGIN_ENTRYPOINT_VOIDRET;
-
-    HCRYPTPROV      hProv;
-
-    SNLOG((W("StrongNameKeyDelete(\"%s\")\n"), wszKeyContainer));
-
-    SN_COMMON_PROLOG();
-
-    if (wszKeyContainer == NULL)
-        SN_ERROR(E_POINTER);
-
-    // Open and delete the named container.
-    hProv = LocateCSP(wszKeyContainer, SN_DELETE_CONTAINER);
-    if (hProv) {
-        // Returned handle isn't actually valid in the delete case, so we're
-        // finished.
-        retVal = TRUE;
-    } else {
-        SetStrongNameErrorInfo(CORSEC_E_CONTAINER_NOT_FOUND);
-        retVal = FALSE;
-    }
-Exit:
-
-    END_ENTRYPOINT_VOIDRET;
-    return retVal;
-
-}
-
-// Retrieve the public portion of a key pair.
-SNAPI StrongNameGetPublicKey (LPCWSTR   wszKeyContainer,    // [in] desired key container name
-                              BYTE     *pbKeyBlob,          // [in] public/private key blob (optional)
-                              ULONG     cbKeyBlob,
-                              BYTE    **ppbPublicKeyBlob,   // [out] public key blob
-                              ULONG    *pcbPublicKeyBlob)
-{
-    LIMITED_METHOD_CONTRACT;
-    BOOLEAN retVal = FALSE;
-
-    BEGIN_ENTRYPOINT_VOIDRET;
-    
-    retVal = StrongNameGetPublicKeyEx(
-        wszKeyContainer,
-        pbKeyBlob,
-        cbKeyBlob,
-        ppbPublicKeyBlob,
-        pcbPublicKeyBlob,
-        0,
-        0);
-    
-    END_ENTRYPOINT_VOIDRET;
-    return retVal;
-}
-
-// Holder for any HCRYPTPROV handles allocated by the strong name APIs
-typedef Wrapper<HCRYPTPROV, DoNothing, FreeCSP, 0> HandleStrongNameCspHolder;
-
-
-SNAPI StrongNameGetPublicKeyEx (LPCWSTR   wszKeyContainer,    // [in] desired key container name
-                                BYTE     *pbKeyBlob,          // [in] public/private key blob (optional)
-                                ULONG     cbKeyBlob,
-                                BYTE    **ppbPublicKeyBlob,   // [out] public key blob
-                                ULONG    *pcbPublicKeyBlob,
-                                ULONG     uHashAlgId,
-                                ULONG     uReserved)         // reserved for future use as uSigAlgId (signature algorithm id)
-{
-    BOOLEAN         retVal = FALSE;
-
-    BEGIN_ENTRYPOINT_VOIDRET;
-
-    HandleStrongNameCspHolder hProv(NULL);
-    CapiKeyHolder             hKey(NULL);
-    DWORD                     dwKeyLen;
-    PublicKeyBlob            *pKeyBlob;
-    DWORD                     dwSigAlgIdLen;
-
-    SNLOG((W("StrongNameGetPublicKeyEx(\"%s\", %08X, %08X, %08X, %08X, %08X)\n"), wszKeyContainer, pbKeyBlob, cbKeyBlob, ppbPublicKeyBlob, pcbPublicKeyBlob, uHashAlgId));
-
-    SN_COMMON_PROLOG();
-
-    if (wszKeyContainer == NULL && pbKeyBlob == NULL)
-        SN_ERROR(E_INVALIDARG);
-    if (pbKeyBlob != NULL && !(StrongNameIsEcmaKey(pbKeyBlob, cbKeyBlob) || StrongNameIsValidKeyPair(pbKeyBlob, cbKeyBlob)))
-        SN_ERROR(E_INVALIDARG);
-    if (ppbPublicKeyBlob == NULL)
-        SN_ERROR(E_POINTER);
-    if (pcbPublicKeyBlob == NULL)
-        SN_ERROR(E_POINTER);
-    if (uReserved != 0)
-        SN_ERROR(E_INVALIDARG);
-
-    bool fHashAlgorithmValid;
-    fHashAlgorithmValid = uHashAlgId == 0 || 
-                          (GET_ALG_CLASS(uHashAlgId) == ALG_CLASS_HASH && GET_ALG_SID(uHashAlgId) >= ALG_SID_SHA1 && GET_ALG_SID(uHashAlgId) <= ALG_SID_SHA_512);
-    if(!fHashAlgorithmValid)
-        SN_ERROR(E_INVALIDARG);
-
-    if(uHashAlgId == 0)
-        uHashAlgId = g_uHashAlgId;
-
-    // If we're handed a platform neutral public key, just hand it right back to
-    // the user. Well, hand back a copy at least.
-    if (pbKeyBlob && cbKeyBlob && SN_IS_NEUTRAL_KEY(pbKeyBlob)) {
-        *pcbPublicKeyBlob = sizeof(g_rbNeutralPublicKey);
-        *ppbPublicKeyBlob = (BYTE*)g_rbNeutralPublicKey;
-        retVal = TRUE;
-        goto Exit;
-    }
-
-    // Open a CSP. Create a key container if a public/private key blob is
-    // provided, otherwise we assume a key container already exists.
-    if (pbKeyBlob)
-        hProv = LocateCSP(NULL, SN_IGNORE_CONTAINER);
-    else
-        hProv = LocateCSP(wszKeyContainer, SN_OPEN_CONTAINER);
-    if (!hProv)
-        goto Error;
-
-    // If a key blob was provided, import the key pair into the container.
-    if (pbKeyBlob) {
-        if (!CryptImportKey(hProv,
-                               pbKeyBlob,
-                               cbKeyBlob,
-                               0, 0, &hKey))
-            goto Error;
-    } else {
-#if !defined(FEATURE_CORESYSTEM)
-        // Else fetch the signature key pair from the container.
-        if (!CryptGetUserKey(hProv, g_uKeySpec, &hKey))
-            goto Error;
-#else // FEATURE_CORESYSTEM
-        SetLastError(E_NOTIMPL);
-        goto Error;
-#endif // !FEATURE_CORESYSTEM
-    }
-
-    // Determine the length of the public key part as a blob.
-    if (!CryptExportKey(hKey, 0, PUBLICKEYBLOB, 0, NULL, &dwKeyLen))
-        goto Error;
-
-
-#ifdef _PREFAST_
-#pragma warning(push)
-#pragma warning(disable:22011) // Suppress this PREFast warning which gets triggered by the offset macro expansion.
-#endif
-    // And then the length of the PublicKeyBlob structure we return to the
-    // caller.
-    *pcbPublicKeyBlob = offsetof(PublicKeyBlob, PublicKey) + dwKeyLen;
-#ifdef _PREFAST_
-#pragma warning(pop)
-#endif
-
-    // Allocate a large enough buffer.
-    *ppbPublicKeyBlob = new (nothrow) BYTE[*pcbPublicKeyBlob];
-    if (*ppbPublicKeyBlob == NULL) {
-        SetLastError(E_OUTOFMEMORY);
-        goto Error;
-    }
-
-    pKeyBlob = (PublicKeyBlob*)*ppbPublicKeyBlob;
-
-    // Extract the public part as a blob.
-    if (!CryptExportKey(hKey, 0, PUBLICKEYBLOB, 0, pKeyBlob->PublicKey, &dwKeyLen)) {
-        delete[] *ppbPublicKeyBlob;
-        *ppbPublicKeyBlob = NULL;
-        goto Error;
-    }
-
-    // Extract key's signature algorithm and store it in the key blob.
-    dwSigAlgIdLen = sizeof(unsigned int);
-    ALG_ID SigAlgID;
-    if (!CryptGetKeyParam(hKey, KP_ALGID, (BYTE*)&SigAlgID, &dwSigAlgIdLen, 0)) {
-        delete[] *ppbPublicKeyBlob;
-        *ppbPublicKeyBlob = NULL;
-        goto Error;
-    }
-    SET_UNALIGNED_VAL32(&pKeyBlob->SigAlgID, SigAlgID);
-
-    // Fill in the other public key blob fields.
-    SET_UNALIGNED_VAL32(&pKeyBlob->HashAlgID, uHashAlgId);
-    SET_UNALIGNED_VAL32(&pKeyBlob->cbPublicKey, dwKeyLen);
-    
-    retVal = TRUE;
-    goto Exit;
-
-Error:
-    SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-Exit:
-    END_ENTRYPOINT_VOIDRET;
-    return retVal;
-}
-
-// Hash and sign a manifest.
-SNAPI StrongNameSignatureGeneration(LPCWSTR     wszFilePath,        // [in] valid path to the PE file for the assembly
-                                    LPCWSTR     wszKeyContainer,    // [in] desired key container name
-                                    BYTE       *pbKeyBlob,          // [in] public/private key blob (optional)
-                                    ULONG       cbKeyBlob,
-                                    BYTE      **ppbSignatureBlob,   // [out] signature blob
-                                    ULONG      *pcbSignatureBlob)
-{
-    BOOL fRetVal = FALSE;
-    BEGIN_ENTRYPOINT_VOIDRET;
-    fRetVal = StrongNameSignatureGenerationEx(wszFilePath, wszKeyContainer, pbKeyBlob, cbKeyBlob, ppbSignatureBlob, pcbSignatureBlob, 0);
-    END_ENTRYPOINT_VOIDRET;
-    return fRetVal;
-}
-
-HRESULT FindAssemblySignaturePublicKey(const SN_LOAD_CTX *pLoadCtx,
-                                       __out PublicKeyBlob **ppPublicKey)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr;
-    StrongNameBufferHolder<PublicKeyBlob> result = NULL;
-
-    IfFailRet(FindPublicKey(pLoadCtx, NULL, 0, &result));
-
-#ifdef FEATURE_STRONGNAME_MIGRATION
-    PublicKeyBlob *pSignaturePublicKey = NULL;
-    IfFailRet(GetVerifiedSignatureKey((SN_LOAD_CTX*) pLoadCtx, &pSignaturePublicKey));
-    
-    if(hr != S_FALSE)
-    {
-        result = pSignaturePublicKey;
-    }
-#endif // FEATURE_STRONGNAME_MIGRATION
-    
-    *ppPublicKey = result.Extract();
-
-    return S_OK;
-}
-
-SNAPI StrongNameSignatureGenerationEx(LPCWSTR     wszFilePath,        // [in] valid path to the PE file for the assembly
-                                      LPCWSTR     wszKeyContainer,    // [in] desired key container name
-                                      BYTE       *pbKeyBlob,          // [in] public/private key blob (optional)
-                                      ULONG       cbKeyBlob,
-                                      BYTE      **ppbSignatureBlob,   // [out] signature blob
-                                      ULONG      *pcbSignatureBlob,
-                                      DWORD       dwFlags)            // [in] modifer flags
-{
-    BOOLEAN         retVal = FALSE;
-
-    BEGIN_ENTRYPOINT_VOIDRET;
-    HandleStrongNameCspHolder hProv(NULL);
-    CapiHashHolder            hHash(NULL);
-    NewArrayHolder<BYTE>      pbSig(NULL);
-    ULONG                     cbSig = 0;
-    SN_LOAD_CTX               sLoadCtx;
-    BOOLEAN                   bImageLoaded = FALSE;
-    ALG_ID                    uHashAlgId;
-    StrongNameBufferHolder<PublicKeyBlob> pSignatureKey = NULL;
-
-    SNLOG((W("StrongNameSignatureGenerationEx(\"%s\", \"%s\", %08X, %08X, %08X, %08X, %08X)\n"), wszFilePath, wszKeyContainer, pbKeyBlob, cbKeyBlob, ppbSignatureBlob, pcbSignatureBlob, dwFlags));
-
-    SN_COMMON_PROLOG();
-    
-    uHashAlgId = g_uHashAlgId;
-
-    if (pbKeyBlob != NULL && !StrongNameIsValidKeyPair(pbKeyBlob, cbKeyBlob))
-        SN_ERROR(E_INVALIDARG);
-    if (ppbSignatureBlob != NULL && pcbSignatureBlob == NULL)
-        SN_ERROR(E_POINTER);
-    
-    if (wszFilePath != NULL) {
-        // Map the assembly into memory.
-        sLoadCtx.m_fReadOnly = FALSE;
-        if (!LoadAssembly(&sLoadCtx, wszFilePath))
-            goto Error;
-        bImageLoaded = TRUE;
-
-        // If we've asked to recalculate the file hashes of linked modules we have
-        // to load the metadata engine and search for file references.
-        if (dwFlags & SN_SIGN_ALL_FILES)
-            if (!RehashModules(&sLoadCtx, wszFilePath))
-                goto Error;
-
-        // If no key pair is provided, then we were only called to re-compute the hashes of
-        // linked modules in the assembly.
-        if (!wszKeyContainer && !pbKeyBlob)
-        {
-            retVal = TRUE;
-            goto Exit;
-        }
-
-        HRESULT hr;
-        if(FAILED(hr = FindAssemblySignaturePublicKey(&sLoadCtx, &pSignatureKey)))
-        {
-            SN_ERROR(hr);
-        }
-        
-        // Ecma key has an algorithm of zero, so we ignore that case.
-        ALG_ID uKeyHashAlgId = GET_UNALIGNED_VAL32(&pSignatureKey->HashAlgID);
-        if(uKeyHashAlgId != 0) 
-        {
-            uHashAlgId = uKeyHashAlgId;
-        }
-    }
-
-    if (wszKeyContainer || pbKeyBlob) { // We have a key pair in a container, or in a blob
-        // Open a CSP. If a public/private key blob is provided, use CRYPT_VERIFYCONTEXT,
-        // otherwise we assume the key container already exists.
-        if (pbKeyBlob)
-            hProv = LocateCSP(NULL, SN_IGNORE_CONTAINER, uHashAlgId);
-        else
-            hProv = LocateCSP(wszKeyContainer, SN_OPEN_CONTAINER, uHashAlgId);
-
-        if (hProv.GetValue() == NULL)
-            goto Error;
-
-        // If a key blob was provided, import the key pair into the container.
-        // This might be the real key or the test-sign key. In the case of test signing,
-        // there's no way to specify hash algorithm, so we use the one from the 
-        // assembly signature public key (in the metadata table, or the migration attribute).
-        if (pbKeyBlob) {
-            // The provider holds a reference to the key, so we don't need to 
-            // keep one around.
-            CapiKeyHolder hKey(NULL); 
-            if (!CryptImportKey(hProv,
-                                pbKeyBlob,
-                                cbKeyBlob,
-                                0, 
-                                0, 
-                                &hKey))
-                goto Error;
-        }
-
-        // Create a hash object.
-        if (!CryptCreateHash(hProv, uHashAlgId, 0, 0, &hHash))
-            goto Error;
-
-        // Compute size of the signature blob.
-        if (!CryptSignHashW(hHash, g_uKeySpec, NULL, 0, NULL, &cbSig))
-            goto Error;
-
-        // If the caller only wants the size of the signature, return it now and
-        // exit.
-        // RSA signature length is independent of the hash size, so hash algorithm 
-        // doesn't matter here (we don't know the algorithm if the assembly path was passed in as NULL)
-        if (wszFilePath == NULL) {
-            *pcbSignatureBlob = cbSig;
-            retVal = TRUE;
-            goto Exit;
-        }
-    }
-
-    // Verify that the public key of the assembly being signed matches the private key we're signing with
-    if ((wszKeyContainer != NULL || pbKeyBlob != NULL) && !VerifyKeyMatchesAssembly(pSignatureKey, wszKeyContainer, pbKeyBlob, cbKeyBlob, dwFlags))
-    {
-        SetLastError(StrongNameErrorInfo());
-        goto Error;
-    }
-
-    // We set a bit in the header to indicate we're fully signing the assembly.
-    if (!(dwFlags & SN_TEST_SIGN))
-        sLoadCtx.m_pCorHeader->Flags |= VAL32(COMIMAGE_FLAGS_STRONGNAMESIGNED);
-    else
-        sLoadCtx.m_pCorHeader->Flags &= ~VAL32(COMIMAGE_FLAGS_STRONGNAMESIGNED);
-
-    // Destroy the old hash object and create a new one
-    // because CryptoAPI says you can't reuse a hash once you've signed it
-    // Note that this seems to work with MS-based CSPs but breaks on
-    // at least newer nCipher CSPs.
-    if (!CryptCreateHash(hProv, uHashAlgId, 0, 0, &hHash))
-        goto Error;
-
-    // Compute a hash over the image.
-    if (!ComputeHash(&sLoadCtx, hHash, CalcHash, NULL))
-        goto Error;
-
-    // Allocate the blob.
-    pbSig = new (nothrow) BYTE[cbSig];
-    if (pbSig == NULL) {
-        SetLastError(E_OUTOFMEMORY);
-        goto Error;
-    }
-
-    // Compute a signature blob over the hash of the manifest.
-    if (!CryptSignHashW(hHash, g_uKeySpec, NULL, 0, pbSig, &cbSig))
-        goto Error;
-
-    // Check the signature size
-    if (sLoadCtx.m_cbSignature != cbSig) {
-        SetLastError(CORSEC_E_SIGNATURE_MISMATCH);
-        goto Error;
-    }
-
-    // If the user hasn't asked for the signature to be returned as a pointer, write it to file.
-    if (!ppbSignatureBlob)
-    {
-        memcpy_s(sLoadCtx.m_pbSignature, sLoadCtx.m_cbSignature, pbSig, cbSig);
-
-        // 
-        // Memory-mapped IO in Windows doesn't guarantee that it will update
-        // the file's "Modified" timestamp, so we update it ourselves. 
-        //
-        _ASSERTE(sLoadCtx.m_hFile != INVALID_HANDLE_VALUE);
-
-        FILETIME ft;
-        SYSTEMTIME st;
-
-        GetSystemTime(&st);
-        
-        // We don't care if updating the timestamp fails for any reason.
-        if(SystemTimeToFileTime(&st, &ft))
-        {
-            SetFileTime(sLoadCtx.m_hFile, (LPFILETIME) NULL, (LPFILETIME) NULL, &ft);
-        }
-    }
-
-    // Unmap the image (automatically recalculates and updates the image
-    // checksum).
-    bImageLoaded = FALSE;
-    if (!UnloadAssembly(&sLoadCtx))
-        goto Error;
-
-    if (ppbSignatureBlob) {
-        *ppbSignatureBlob = pbSig.Extract();
-        *pcbSignatureBlob = cbSig;
-    }
-
-    retVal = TRUE;
-    goto Exit;
-
-Error:
-    SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-Exit:
-    if (bImageLoaded)
-        UnloadAssembly(&sLoadCtx);
-    END_ENTRYPOINT_VOIDRET;
-    return retVal;
-}
-
-//
-// Generate the digest of a delay signed assembly, which can be signed with StrongNameDigestSign.  The digest
-// algorithm is determined from the HashAlgID of the assembly's public key blob. 
-//
-// Parameters:
-//  wszFilePath   - path to the delay signed assembly to generate the digest of
-//  ppbDigestBlob - on success this will point to a buffer that contains the digest of the wszFilePath
-//                  assembly.  This buffer should be freed with StrongNameFreeBuffer.
-//  pcbDigestBlob - on success this will point to the size of the digest buffer in *ppbDigestBlob
-//  dwFlags       - flags used to control signing.  This is the same set of flags used by
-//                  StrongNameSignatureGenerationEx
-//
-
-bool StrongNameDigestGenerate_Internal(_In_z_ LPCWSTR                                       wszFilePath,
-                                       _Outptr_result_bytebuffer_(*pcbDigestBlob) BYTE**    ppbDigestBlob,
-                                       _Out_  ULONG*                                        pcbDigestBlob,
-                                       DWORD                                                dwFlags)
-{
-    // Load up the assembly and find its public key - this tells us which hash algorithm we need to use
-    // Note that it cannot be loaded read-only since we need to toggle the fully siged bit in order to
-    // calculate the correct hash for the signature.
-    StrongNameAssemblyLoadHolder assembly(wszFilePath, false /* read only */);
-    if (!assembly.IsLoaded())
-    {
-        return false;
-    }
-
-    // If we were asked to do a full rehashing of all modules that needs to be done before calculating the digest
-    if ((dwFlags & SN_SIGN_ALL_FILES) == SN_SIGN_ALL_FILES)
-    {
-        if (!RehashModules(assembly.GetLoadContext(), wszFilePath))
-        {
-            return false;
-        }
-    }
-
-    // During signature verification, the fully signed bit will be set in the assembly's COR header.
-    // Therefore, when calculating the digest of the assembly we must toggle this bit in order to make the
-    // digest match what will be calculated during verificaiton.  However, we do not want to persist the
-    // bit flip on disk, since we're not actually signing the assembly now.  We'll save the current COR
-    // flags, flip the bit for digesting, and then restore the COR flags before we finish calculating the
-    // digest.
-    class AssemblyFlagsHolder
-    {
-    private:
-        IMAGE_COR20_HEADER* m_pHeader;
-        DWORD               m_originalFlags;
-
-    public:
-        AssemblyFlagsHolder(_In_ IMAGE_COR20_HEADER* pHeader)
-            : m_pHeader(pHeader),
-              m_originalFlags(pHeader->Flags)
-        {
-        }
-
-        ~AssemblyFlagsHolder()
-        {
-            m_pHeader->Flags = m_originalFlags;
-        }
-    } flagsHolder(assembly.GetLoadContext()->m_pCorHeader);
-    assembly.GetLoadContext()->m_pCorHeader->Flags |= VAL32(COMIMAGE_FLAGS_STRONGNAMESIGNED);
-
-    StrongNameBufferHolder<PublicKeyBlob> pPublicKey;
-    HRESULT hrPublicKey = FindAssemblySignaturePublicKey(assembly.GetLoadContext(), &pPublicKey);
-    if (FAILED(hrPublicKey))
-    {
-        SetStrongNameErrorInfo(hrPublicKey);
-        return false;
-    }
-
-    // Generate the digest of the assembly
-    HandleStrongNameCspHolder hProv(LocateCSP(nullptr, SN_IGNORE_CONTAINER, pPublicKey->HashAlgID));
-    if (!hProv)
-    {
-        SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-        return false;
-    }
-
-    CapiHashHolder hHash;
-    if (!CryptCreateHash(hProv, pPublicKey->HashAlgID, NULL, 0, &hHash))
-    {
-        SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-        return false;
-    }
-
-    if (!ComputeHash(assembly.GetLoadContext(), hHash, CalcHash, nullptr))
-    {
-        return false;
-    }
-
-    // Figure out how big the resulting digest is so that we can pass it back out
-    DWORD hashSize = 0;
-    DWORD dwordSize = sizeof(hashSize);
-    if (!CryptGetHashParam(hHash, HP_HASHSIZE, reinterpret_cast<BYTE*>(&hashSize), &dwordSize, 0))
-    {
-        SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-        return false;
-    }
-
-    StrongNameBufferHolder<BYTE> pbHash(new (nothrow)BYTE[hashSize]);
-    if (!pbHash)
-    {
-        SetStrongNameErrorInfo(E_OUTOFMEMORY);
-        return false;
-    }
-
-    if (!CryptGetHashParam(hHash, HP_HASHVAL, pbHash, &hashSize, 0))
-    {
-        SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-        return false;
-    }
-
-    *ppbDigestBlob = pbHash.Extract();
-    *pcbDigestBlob = hashSize;
-    return true;
-}
-
-SNAPI StrongNameDigestGenerate(_In_z_ LPCWSTR                                       wszFilePath,
-                               _Outptr_result_bytebuffer_(*pcbDigestBlob) BYTE**    ppbDigestBlob,
-                               _Out_  ULONG*                                        pcbDigestBlob,
-                               DWORD                                                dwFlags)
-{
-    BOOLEAN retVal = FALSE;
-    BEGIN_ENTRYPOINT_VOIDRET;
-
-    SNLOG((W("StrongNameDigestGenerate(\"%s\", %08X, %08X, %04X)\n"), wszFilePath, ppbDigestBlob, pcbDigestBlob, dwFlags));
-
-    SN_COMMON_PROLOG();
-    if (wszFilePath == nullptr)
-        SN_ERROR(E_POINTER);
-    if (ppbDigestBlob == nullptr)
-        SN_ERROR(E_POINTER);
-    if (pcbDigestBlob == nullptr)
-        SN_ERROR(E_POINTER);
-
-    retVal = StrongNameDigestGenerate_Internal(wszFilePath, ppbDigestBlob, pcbDigestBlob, dwFlags);
-
-    END_ENTRYPOINT_VOIDRET;
-
-Exit:
-    return retVal;
-}
-
-//
-// Sign an the digest of an assembly calculated by StrongNameDigestGenerate
-//
-// Parameters:
-//  wszKeyContainer  - name of the key container that holds the key pair used to generate the signature.  If
-//                     both a key container and key blob are specified, the key container name is ignored.
-//  pbKeyBlob        - raw key pair to be used to generate the signature.  If both a key pair and a key
-//                     container are given, the key blob will be used.
-//  cbKeyBlob        - size of the key pair in pbKeyBlob
-//  pbDigestBlob     - digest of the assembly, calculated by StrongNameDigestGenerate
-//  cbDigestBlob     - size of the digest blob
-//  hashAlgId        - algorithm ID of the hash algorithm used to generate the digest blob
-//  ppbSignatureBlob - on success this will point to a buffer that contains a signature over the blob.  This
-//                     buffer should be freed with StrongNameFreeBuffer.
-//  pcbSignatureBlob - on success this will point to the size of the signature blob in *ppbSignatureBlob
-//  dwFlags          - flags used to control signing.  This is the same set of flags used by
-//                     StrongNameSignatureGenerationEx
-//
-
-bool StrongNameDigestSign_Internal(_In_opt_z_ LPCWSTR                                   wszKeyContainer,
-                                   _In_reads_bytes_opt_(cbKeyBlob) BYTE*                pbKeyBlob,
-                                   ULONG                                                cbKeyBlob,
-                                   _In_reads_bytes_(cbDigestBlob) BYTE*                 pbDigestBlob,
-                                   ULONG                                                cbDigestBlob,
-                                   DWORD                                                hashAlgId,
-                                   _Outptr_result_bytebuffer_(*pcbSignatureBlob) BYTE** ppbSignatureBlob,
-                                   _Out_ ULONG*                                         pcbSignatureBlob,
-                                   DWORD                                                dwFlags)
-{
-    //
-    // Get the key we'll be signing with loaded into CAPI
-    //
-
-    HandleStrongNameCspHolder hProv;
-    CapiKeyHolder hKey;
-    if (pbKeyBlob != nullptr)
-    {
-        hProv = LocateCSP(nullptr, SN_IGNORE_CONTAINER, hashAlgId);
-
-        if (hProv != NULL)
-        {
-            if (!CryptImportKey(hProv, pbKeyBlob, cbKeyBlob, 0, 0, &hKey))
-            {
-                SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-                return false;
-            }
-        }
-    }
-    else
-    {
-        hProv = LocateCSP(wszKeyContainer, SN_OPEN_CONTAINER, hashAlgId);
-    }
-
-    if (!hProv)
-    {
-        SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-        return false;
-    }
-
-    //
-    // Get the pre-calculated digest loaded into a CAPI Hash object
-    //
-
-    CapiHashHolder hHash;
-    if (!CryptCreateHash(hProv, hashAlgId, 0, 0, &hHash))
-    {
-        SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-        return false;
-    }
-
-    DWORD hashSize = 0;
-    DWORD cbHashSize = sizeof(hashSize);
-    if (!CryptGetHashParam(hHash, HP_HASHSIZE, reinterpret_cast<BYTE*>(&hashSize), &cbHashSize, 0))
-    {
-        SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-        return false;
-    }
-
-    if (hashSize != cbDigestBlob)
-    {
-        SetStrongNameErrorInfo(NTE_BAD_HASH);
-        return false;
-    }
-
-    if (!CryptSetHashParam(hHash, HP_HASHVAL, pbDigestBlob, 0))
-    {
-        SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-        return false;
-    }
-
-    //
-    // Sign the hash
-    //
-
-    DWORD cbSignature = 0;
-    if (!CryptSignHashW(hHash, g_uKeySpec, nullptr, 0, nullptr, &cbSignature))
-    {
-        SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-        return false;
-    }
-
-    // CAPI has a quirk where some CSPs do not allow you to sign a hash object once you've asked for the size
-    // of the signature. To work in those cases, we must create a new hash object to sign.
-    if (!CryptCreateHash(hProv, hashAlgId, 0, 0, &hHash))
-    {
-        SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-        return false;
-    }
-
-    if (!CryptGetHashParam(hHash, HP_HASHSIZE, reinterpret_cast<BYTE*>(&hashSize), &cbHashSize, 0))
-    {
-        SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-        return false;
-    }
-
-    if (hashSize != cbDigestBlob)
-    {
-        SetStrongNameErrorInfo(NTE_BAD_HASH);
-        return false;
-    }
-
-    if (!CryptSetHashParam(hHash, HP_HASHVAL, pbDigestBlob, 0))
-    {
-        SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-        return false;
-    }
-
-    // Now that we've got a fresh hash object to sign, we can compute the final signature
-    StrongNameBufferHolder<BYTE> pbSignature(new (nothrow)BYTE[cbSignature]);
-    if (pbSignature == nullptr)
-    {
-        SetStrongNameErrorInfo(E_OUTOFMEMORY);
-        return false;
-    }
-
-    if (!CryptSignHashW(hHash, g_uKeySpec, nullptr, 0, pbSignature, &cbSignature))
-    {
-        SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-        return false;
-    }
-
-    *ppbSignatureBlob = pbSignature.Extract();
-    *pcbSignatureBlob = cbSignature;
-    return true;
-}
-
-SNAPI StrongNameDigestSign(_In_opt_z_ LPCWSTR                                   wszKeyContainer,
-                           _In_reads_bytes_opt_(cbKeyBlob) BYTE*                pbKeyBlob,
-                           ULONG                                                cbKeyBlob,
-                           _In_reads_bytes_(cbDigestBlob) BYTE*                 pbDigestBlob,
-                           ULONG                                                cbDigestBlob,
-                           DWORD                                                hashAlgId,
-                           _Outptr_result_bytebuffer_(*pcbSignatureBlob) BYTE** ppbSignatureBlob,
-                           _Out_ ULONG*                                         pcbSignatureBlob,
-                           DWORD                                                dwFlags)
-{
-    BOOLEAN retVal = FALSE;
-
-    BEGIN_ENTRYPOINT_VOIDRET;
-    SNLOG((W("StrongNameDigestSign(\"%s\", %08X, %04X, %08X, %04X, %04X, %08X, %08X, %04X)\n"), wszKeyContainer, pbKeyBlob, cbKeyBlob, pbDigestBlob, cbDigestBlob, hashAlgId, ppbSignatureBlob, pcbSignatureBlob, dwFlags));
-    SN_COMMON_PROLOG();
-
-    if (wszKeyContainer == nullptr && pbKeyBlob == nullptr)
-        SN_ERROR(E_POINTER);
-    if (pbKeyBlob != nullptr && !StrongNameIsValidKeyPair(pbKeyBlob, cbKeyBlob))
-        SN_ERROR(E_INVALIDARG);
-    if (pbDigestBlob == nullptr)
-        SN_ERROR(E_POINTER);
-    if (ppbSignatureBlob == nullptr)
-        SN_ERROR(E_POINTER);
-    if (pcbSignatureBlob == nullptr)
-        SN_ERROR(E_POINTER);
-
-    *ppbSignatureBlob = nullptr;
-    *pcbSignatureBlob = 0;
-
-    retVal = StrongNameDigestSign_Internal(wszKeyContainer, pbKeyBlob, cbKeyBlob, pbDigestBlob, cbDigestBlob, hashAlgId, ppbSignatureBlob, pcbSignatureBlob, dwFlags);
-
-    END_ENTRYPOINT_VOIDRET;
-Exit:
-    return retVal;
-}
-
-//
-// Embed a digest signature generated with StrongNameDigestSign into a delay signed assembly, completing
-// the signing process for that assembly.
-//
-// Parameters:
-//  wszFilePath     - path to the assembly to sign
-//  pbSignatureBlob - signature blob to embed in the assembly
-//  cbSignatureBlob - size of the signature blob
-//
-
-bool StrongNameDigestEmbed_Internal(_In_z_ LPCWSTR                          wszFilePath,
-                                    _In_reads_bytes_(cbSignatureBlob) BYTE* pbSignatureBlob,
-                                    ULONG                                   cbSignatureBlob)
-{
-    StrongNameAssemblyLoadHolder assembly(wszFilePath, false);
-    if (!assembly.IsLoaded())
-    {
-        SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-        return false;
-    }
-
-    memcpy_s(assembly.GetLoadContext()->m_pbSignature, assembly.GetLoadContext()->m_cbSignature, pbSignatureBlob, cbSignatureBlob);
-    assembly.GetLoadContext()->m_pCorHeader->Flags |= VAL32(COMIMAGE_FLAGS_STRONGNAMESIGNED);
-
-    FILETIME ft = { 0 };
-    SYSTEMTIME st = { 0 };
-    GetSystemTime(&st);
-    if (SystemTimeToFileTime(&st, &ft))
-    {
-        SetFileTime(assembly.GetLoadContext()->m_hFile, nullptr, nullptr, &ft);
-    }
-
-    return true;
-}
-
-SNAPI StrongNameDigestEmbed(_In_z_ LPCWSTR                          wszFilePath,                        // [in] valid path to the PE file for the assembly to update
-                            _In_reads_bytes_(cbSignatureBlob) BYTE* pbSignatureBlob,                    // [in] signatuer blob for the assembly
-                            ULONG                                   cbSignatureBlob)
-{
-    BOOLEAN retVal = FALSE;
-
-    BEGIN_ENTRYPOINT_VOIDRET;
-    SNLOG((W("StrongNameDigestEmbed(\"%s\", %08X, %04X)\n"), wszFilePath, pbSignatureBlob, cbSignatureBlob));
-    SN_COMMON_PROLOG();
-
-    if (wszFilePath == nullptr)
-        SN_ERROR(E_POINTER);
-    if (pbSignatureBlob == nullptr)
-        SN_ERROR(E_POINTER);
-
-    retVal = StrongNameDigestEmbed_Internal(wszFilePath, pbSignatureBlob, cbSignatureBlob);
-
-    END_ENTRYPOINT_VOIDRET;
-Exit:
-    return retVal;
-}
-
-// Create a strong name token from an assembly file.
-SNAPI StrongNameTokenFromAssembly(LPCWSTR   wszFilePath,            // [in] valid path to the PE file for the assembly
-                                  BYTE    **ppbStrongNameToken,     // [out] strong name token 
-                                  ULONG    *pcbStrongNameToken)
-{
-    BOOL fRetValue = FALSE;
-    BEGIN_ENTRYPOINT_VOIDRET;
-    fRetValue = StrongNameTokenFromAssemblyEx(wszFilePath,
-                                         ppbStrongNameToken,
-                                         pcbStrongNameToken,
-                                         NULL,
-                                         NULL);
-    END_ENTRYPOINT_VOIDRET;
-    return fRetValue;
-}
-
-// Create a strong name token from an assembly file and additionally return the full public key.
-SNAPI StrongNameTokenFromAssemblyEx(LPCWSTR   wszFilePath,            // [in] valid path to the PE file for the assembly
-                                    BYTE    **ppbStrongNameToken,     // [out] strong name token 
-                                    ULONG    *pcbStrongNameToken,
-                                    BYTE    **ppbPublicKeyBlob,       // [out] public key blob
-                                    ULONG    *pcbPublicKeyBlob)
-{
-    BOOLEAN         retVal = FALSE;
-
-    BEGIN_ENTRYPOINT_VOIDRET;
-    SN_LOAD_CTX     sLoadCtx;
-    BOOLEAN         fMapped = FALSE;
-    BOOLEAN         fSetErrorInfo = TRUE;
-    PublicKeyBlob  *pPublicKey = NULL;
-    HRESULT         hrKey = S_OK;
-
-    SNLOG((W("StrongNameTokenFromAssemblyEx(\"%s\", %08X, %08X, %08X, %08X)\n"), wszFilePath, ppbStrongNameToken, pcbStrongNameToken, ppbPublicKeyBlob, pcbPublicKeyBlob));
-
-    SN_COMMON_PROLOG();
-
-    if (wszFilePath == NULL)
-        SN_ERROR(E_POINTER);
-    if (ppbStrongNameToken == NULL)
-        SN_ERROR(E_POINTER);
-    if (pcbStrongNameToken == NULL)
-        SN_ERROR(E_POINTER);
-
-    // Map the assembly into memory.
-    sLoadCtx.m_fReadOnly = TRUE;
-    if (!LoadAssembly(&sLoadCtx, wszFilePath))
-        goto Error;
-    fMapped = TRUE;
-
-    // Read the public key used to sign the assembly from the assembly metadata.
-    hrKey = FindPublicKey(&sLoadCtx, NULL, 0, &pPublicKey);
-    if (FAILED(hrKey))
-    {
-        SetStrongNameErrorInfo(hrKey);
-        fSetErrorInfo = FALSE;
-        goto Error;
-    }
-
-    // Unload the assembly.
-    fMapped = FALSE;
-    if (!UnloadAssembly(&sLoadCtx))
-        goto Error;
-
-    // Now we have a public key blob, we can call our more direct API to do the
-    // actual work.
-    if (!StrongNameTokenFromPublicKey((BYTE*)pPublicKey,
-                                      SN_SIZEOF_KEY(pPublicKey),
-                                      ppbStrongNameToken,
-                                      pcbStrongNameToken)) {
-        fSetErrorInfo = FALSE;
-        goto Error;
-    }
-
-    if (pcbPublicKeyBlob)
-        *pcbPublicKeyBlob = SN_SIZEOF_KEY(pPublicKey);
- 
-    // Return public key information.
-    if (ppbPublicKeyBlob)
-        *ppbPublicKeyBlob = (BYTE*)pPublicKey;
-    else
-        delete [] (BYTE*)pPublicKey;
-
-    retVal = TRUE;
-    goto Exit;
-
- Error:
-    if (fSetErrorInfo)
-        SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-    if (pPublicKey)
-        delete [] (BYTE*)pPublicKey;
-    if (fMapped)
-        UnloadAssembly(&sLoadCtx);
-
-Exit:
-    END_ENTRYPOINT_VOIDRET;
-        
-    return retVal;
-}
-
-bool StrongNameSignatureVerificationEx2_Internal(LPCWSTR wszFilePath,
-                                                 BOOLEAN fForceVerification,
-                                                 BYTE *pbEcmaPublicKey,
-                                                 DWORD cbEcmaPublicKey,
-                                                 BOOLEAN *pfWasVerified)
-{
-    StrongNameAssemblyLoadHolder assembly(wszFilePath, true);
-    if (!assembly.IsLoaded())
-    {
-        SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-        return false;
-    }
-    else
-    {
-        DWORD dwOutFlags = 0;
-        HRESULT hrVerify =  VerifySignature(assembly.GetLoadContext(),
-                                            SN_INFLAG_INSTALL | SN_INFLAG_ALL_ACCESS | (fForceVerification ? SN_INFLAG_FORCE_VER : 0),
-                                            reinterpret_cast<PublicKeyBlob *>(pbEcmaPublicKey),
-                                            &dwOutFlags);
-        if (FAILED(hrVerify))
-        {
-            SetStrongNameErrorInfo(hrVerify);
-            return false;
-        }
-
-        if (pfWasVerified)
-        {
-            *pfWasVerified = (dwOutFlags & SN_OUTFLAG_WAS_VERIFIED) != 0;
-        }
-
-        return true;
-    }
-}
-
-//
-// Verify the signature of a strongly named assembly, providing a mapping from the ECMA key to a real key
-//
-// Arguments:
-//    wszFilePath         - valid path to the PE file for the assembly
-//    fForceVerification  - verify even if settings in the registry disable it
-//    pbEcmaPublicKey     - mapping from the ECMA public key to the real key used for verification
-//    cbEcmaPublicKey     - length of the real ECMA public key
-//    fWasVerified        - [out] set to false if verify succeeded due to registry settings
-//    
-// Return Value:
-//    TRUE if the signature was successfully verified, FALSE otherwise
-//
-
-SNAPI StrongNameSignatureVerificationEx2(LPCWSTR wszFilePath,
-                                         BOOLEAN fForceVerification,
-                                         BYTE *pbEcmaPublicKey,
-                                         DWORD cbEcmaPublicKey,
-                                         BOOLEAN *pfWasVerified)
-{
-    BOOLEAN retVal = FALSE;
-    BEGIN_ENTRYPOINT_VOIDRET;
-
-    SNLOG((W("StrongNameSignatureVerificationEx2(\"%s\", %d, %08X, %08X, %08X)\n"), wszFilePath, fForceVerification, pbEcmaPublicKey, cbEcmaPublicKey, pfWasVerified));
-
-    SN_COMMON_PROLOG();
-
-    if (wszFilePath == NULL)
-        SN_ERROR(E_POINTER);
-    if (pbEcmaPublicKey == NULL)
-        SN_ERROR(E_POINTER);
-    if (!StrongNameIsValidPublicKey(pbEcmaPublicKey, cbEcmaPublicKey, false))
-        SN_ERROR(CORSEC_E_INVALID_PUBLICKEY);
-
-    retVal = StrongNameSignatureVerificationEx2_Internal(wszFilePath, fForceVerification, pbEcmaPublicKey, cbEcmaPublicKey, pfWasVerified);
-
-Exit:
-    END_ENTRYPOINT_VOIDRET;
-    return retVal;
-}
-
-// Verify a strong name/manifest against a public key blob.
-SNAPI StrongNameSignatureVerificationEx(LPCWSTR     wszFilePath,        // [in] valid path to the PE file for the assembly
-                                        BOOLEAN     fForceVerification, // [in] verify even if settings in the registry disable it
-                                        BOOLEAN    *pfWasVerified)      // [out] set to false if verify succeeded due to registry settings
-{
-    BOOLEAN fRet = FALSE;
-    BEGIN_ENTRYPOINT_VOIDRET;
-
-    fRet = StrongNameSignatureVerificationEx2(wszFilePath,
-                                              fForceVerification,
-                                              const_cast<BYTE *>(g_rbTheKey),
-                                              COUNTOF(g_rbTheKey),
-                                              pfWasVerified);
-
-    END_ENTRYPOINT_VOIDRET;
-    return fRet;
-}
-
-
-// Verify a strong name/manifest against a public key blob.
-SNAPI StrongNameSignatureVerification(LPCWSTR wszFilePath,      // [in] valid path to the PE file for the assembly
-                                      DWORD   dwInFlags,        // [in] flags modifying behaviour
-                                      DWORD  *pdwOutFlags)      // [out] additional output info
-{
-    BOOLEAN     retVal = TRUE;
-
-    BEGIN_ENTRYPOINT_VOIDRET;
-
-    SN_LOAD_CTX sLoadCtx;
-    BOOLEAN     fMapped = FALSE;
-
-    SNLOG((W("StrongNameSignatureVerification(\"%s\", %08X, %08X, %08X)\n"), wszFilePath, dwInFlags, pdwOutFlags));
-
-    SN_COMMON_PROLOG();
-
-    if (wszFilePath == NULL)
-        SN_ERROR(E_POINTER);
-
-    // Map the assembly into memory.
-    sLoadCtx.m_fReadOnly = TRUE;
-    if (LoadAssembly(&sLoadCtx, wszFilePath))
-    {
-        fMapped = TRUE;
-    }
-    else
-    {
-        SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-        retVal = FALSE;
-    }
-
-    // Go to common code to process the verification.
-    if (fMapped)
-    {
-        HRESULT hrVerify = VerifySignature(&sLoadCtx, dwInFlags, reinterpret_cast<PublicKeyBlob *>(const_cast<BYTE *>(g_rbTheKey)), pdwOutFlags);
-        if (FAILED(hrVerify))
-        {
-            SetStrongNameErrorInfo(hrVerify);
-            retVal = FALSE;
-        }
-
-        // Unmap the image. Only set error information if VerifySignature succeeded, since we do not want to
-        // overwrite its error information with the error code from UnloadAssembly.
-        if (!UnloadAssembly(&sLoadCtx))
-        {
-            if (retVal)
-                SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-            retVal = FALSE;
-        }
-    }
-
-    // SN_COMMON_PROLOG requires an Exit location
-Exit:
-    END_ENTRYPOINT_VOIDRET;
-    return retVal;
-}
-
-
-// Verify a strong name/manifest against a public key blob when the assembly is
-// already memory mapped.
-SNAPI StrongNameSignatureVerificationFromImage(BYTE     *pbBase,             // [in] base address of mapped manifest file
-                                               DWORD     dwLength,           // [in] length of mapped image in bytes
-                                               DWORD     dwInFlags,          // [in] flags modifying behaviour
-                                               DWORD    *pdwOutFlags)        // [out] additional output info
-{
-    BOOLEAN     retVal = TRUE;
-
-    BEGIN_ENTRYPOINT_VOIDRET
-
-    SN_LOAD_CTX sLoadCtx;
-    BOOLEAN     fMapped = FALSE;
-
-    SNLOG((W("StrongNameSignatureVerificationFromImage(%08X, %08X, %08X, %08X)\n"), pbBase, dwLength, dwInFlags, pdwOutFlags));
-
-    SN_COMMON_PROLOG();
-
-    if (pbBase == NULL)
-        SN_ERROR(E_POINTER);
-
-    // We don't need to map the image, it's already in memory. But we do need to
-    // set up a load context for some of the following routines. LoadAssembly
-    // copes with this case for us.
-    sLoadCtx.m_pbBase = pbBase;
-    sLoadCtx.m_dwLength = dwLength;
-    sLoadCtx.m_fReadOnly = TRUE;
-    if (LoadAssembly(&sLoadCtx, NULL, dwInFlags))
-    {
-        fMapped = TRUE;
-    }
-    else
-    {
-        SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-        retVal = FALSE;
-    }
-
-    if (fMapped)
-    {
-        // Go to common code to process the verification.
-        HRESULT hrVerify = VerifySignature(&sLoadCtx, dwInFlags, reinterpret_cast<PublicKeyBlob *>(const_cast<BYTE *>(g_rbTheKey)), pdwOutFlags);
-        if (FAILED(hrVerify))
-        {
-            SetStrongNameErrorInfo(hrVerify);
-            retVal = FALSE;
-        }
-
-        // Unmap the image.
-        if (!UnloadAssembly(&sLoadCtx))
-        {
-            SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-            retVal = FALSE;
-        }
-    }
-
-    // SN_COMMON_PROLOG requires an Exit location
-Exit:
-    END_ENTRYPOINT_VOIDRET;
-    return retVal;
-}
-
-// Find portions of an assembly to hash.
-BOOLEAN CollectBlob(SN_LOAD_CTX *pLoadCtx, PBYTE pbBlob, DWORD* pcbBlob)
-{
-    // Calculate the required size
-    DWORD cbRequired = 0;
-    BOOLEAN bRetval = ComputeHash(pLoadCtx, (HCRYPTHASH)INVALID_HANDLE_VALUE, CalculateSize, &cbRequired);
-    if (!bRetval)
-        return FALSE;
-    if (*pcbBlob < cbRequired) {
-        *pcbBlob = cbRequired;
-        SetLastError( E_INVALIDARG );
-        return FALSE;
-    }
-
-    CopyDataBufferDesc buffer = { pbBlob, *pcbBlob };
-    if (!ComputeHash(pLoadCtx, (HCRYPTHASH)INVALID_HANDLE_VALUE, CopyData, &buffer))
-        return FALSE;
-    
-    *pcbBlob = cbRequired;
-    return TRUE;
-}
-
-// ensure that the symbol will be exported properly
-extern "C" SNAPI StrongNameGetBlob(LPCWSTR wszFilePath,
-                        PBYTE     pbBlob,
-                        DWORD    *cbBlob);
-
-SNAPI StrongNameGetBlob(LPCWSTR wszFilePath,      // [in] valid path to the PE file for the assembly
-                        PBYTE     pbBlob,         // [in] buffer to fill with blob
-                        DWORD    *cbBlob)         // [in/out] size of buffer/number of bytes put into buffer
-{
-    BOOLEAN     retVal = FALSE;
-
-    BEGIN_ENTRYPOINT_VOIDRET;
-
-    SN_LOAD_CTX sLoadCtx;
-    BOOLEAN     fMapped = FALSE;
-
-    SNLOG((W("StrongNameGetBlob(\"%s\", %08X, %08X)\n"), wszFilePath, pbBlob, cbBlob));
-
-    SN_COMMON_PROLOG();
-
-    if (wszFilePath == NULL)
-        SN_ERROR(E_POINTER);
-    if (pbBlob == NULL)
-        SN_ERROR(E_POINTER);
-    if (cbBlob == NULL)
-        SN_ERROR(E_POINTER);
-
-    // Map the assembly into memory.
-    sLoadCtx.m_fReadOnly = TRUE;
-    if (!LoadAssembly(&sLoadCtx, wszFilePath, 0, FALSE))
-        goto Error;
-    fMapped = TRUE;
-
-    if (!CollectBlob(&sLoadCtx, pbBlob, cbBlob))
-        goto Error;
-
-    // Unmap the image.
-    fMapped = FALSE;
-    if (!UnloadAssembly(&sLoadCtx))
-        goto Error;
-
-    retVal = TRUE;
-    goto Exit;
-
- Error:
-    SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-    if (fMapped)
-        UnloadAssembly(&sLoadCtx);
-Exit:
-    END_ENTRYPOINT_VOIDRET;
-    return retVal;
-}
-
-// ensure that the symbol will be exported properly
-extern "C" SNAPI StrongNameGetBlobFromImage(BYTE     *pbBase,
-                                 DWORD     dwLength,
-                                 PBYTE     pbBlob,
-                                 DWORD    *cbBlob);
-
-SNAPI StrongNameGetBlobFromImage(BYTE     *pbBase,             // [in] base address of mapped manifest file
-                                 DWORD     dwLength,           // [in] length of mapped image in bytes
-                                 PBYTE     pbBlob,             // [in] buffer to fill with blob
-                                 DWORD    *cbBlob)             // [in/out] size of buffer/number of bytes put into buffer
-{
-    BOOLEAN     retVal = FALSE;
-
-    BEGIN_ENTRYPOINT_VOIDRET;
-
-    SN_LOAD_CTX sLoadCtx;
-    BOOLEAN     fMapped = FALSE;
-
-
-    SNLOG((W("StrongNameGetBlobFromImage(%08X, %08X, %08X, %08X)\n"), pbBase, dwLength, pbBlob, cbBlob));
-
-    SN_COMMON_PROLOG();
-
-    if (pbBase == NULL)
-        SN_ERROR(E_POINTER);
-    if (pbBlob == NULL)
-        SN_ERROR(E_POINTER);
-    if (cbBlob == NULL)
-        SN_ERROR(E_POINTER);
-
-    // We don't need to map the image, it's already in memory. But we do need to
-    // set up a load context for some of the following routines. LoadAssembly
-    // copes with this case for us.
-    sLoadCtx.m_pbBase = pbBase;
-    sLoadCtx.m_dwLength = dwLength;
-    sLoadCtx.m_fReadOnly = TRUE;
-    if (!LoadAssembly(&sLoadCtx, NULL, 0, FALSE))
-        goto Error;
-    fMapped = TRUE;
-
-    // Go to common code to process the verification.
-    if (!CollectBlob(&sLoadCtx, pbBlob, cbBlob))
-        goto Error;
-
-    // Unmap the image.
-    fMapped = FALSE;
-    if (!UnloadAssembly(&sLoadCtx))
-        goto Error;
-
-    retVal = TRUE;
-    goto Exit;
-
- Error:
-    SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-    if (fMapped)
-        UnloadAssembly(&sLoadCtx);
-
-Exit:
-    END_ENTRYPOINT_VOIDRET;
-
-    return retVal;
-}
-
-
-// Verify that two assemblies differ only by signature blob.
-SNAPI StrongNameCompareAssemblies(LPCWSTR   wszAssembly1,           // [in] file name of first assembly
-                                  LPCWSTR   wszAssembly2,           // [in] file name of second assembly
-                                  DWORD    *pdwResult)              // [out] result of comparison
-{
-    BOOLEAN     retVal = FALSE;
-
-    BEGIN_ENTRYPOINT_VOIDRET;
-
-
-    SN_LOAD_CTX sLoadCtx1;
-    SN_LOAD_CTX sLoadCtx2;
-    size_t      dwSkipOffsets[3];
-    size_t      dwSkipLengths[3];
-    BOOLEAN     bMappedAssem1 = FALSE;
-    BOOLEAN     bMappedAssem2 = FALSE;
-    BOOLEAN     bIdentical;
-    BOOLEAN     bSkipping;
-    DWORD       i, j;
-
-
-
-    SNLOG((W("StrongNameCompareAssemblies(\"%s\", \"%s\", %08X)\n"), wszAssembly1, wszAssembly2, pdwResult));
-
-    SN_COMMON_PROLOG();
-
-    if (wszAssembly1 == NULL)
-        SN_ERROR(E_POINTER);
-    if (wszAssembly2 == NULL)
-        SN_ERROR(E_POINTER);
-    if (pdwResult == NULL)
-        SN_ERROR(E_POINTER);
-
-    // Map each assembly.
-    sLoadCtx1.m_fReadOnly = TRUE;
-    if (!LoadAssembly(&sLoadCtx1, wszAssembly1))
-        goto Error;
-    bMappedAssem1 = TRUE;
-
-    sLoadCtx2.m_fReadOnly = TRUE;
-    if (!LoadAssembly(&sLoadCtx2, wszAssembly2))
-        goto Error;
-    bMappedAssem2 = TRUE;
-
-    // If the files aren't even the same length then they must be different.
-    if (sLoadCtx1.m_dwLength != sLoadCtx2.m_dwLength)
-        goto ImagesDiffer;
-
-    // Check that the signatures are located at the same offset and are the same
-    // length in each assembly.
-    if (sLoadCtx1.m_pCorHeader->StrongNameSignature.VirtualAddress !=
-        sLoadCtx2.m_pCorHeader->StrongNameSignature.VirtualAddress)
-        goto ImagesDiffer;
-    if (sLoadCtx1.m_pCorHeader->StrongNameSignature.Size !=
-        sLoadCtx2.m_pCorHeader->StrongNameSignature.Size)
-        goto ImagesDiffer;
-
-    // Set up list of image ranges to skip in the upcoming comparison.
-    // First there's the signature blob.
-    dwSkipOffsets[0] = sLoadCtx1.m_pbSignature - sLoadCtx1.m_pbBase;
-    dwSkipLengths[0] = sLoadCtx1.m_cbSignature;
-
-    // Then there's the checksum.
-    if (sLoadCtx1.m_pNtHeaders->OptionalHeader.Magic != sLoadCtx2.m_pNtHeaders->OptionalHeader.Magic)
-        goto ImagesDiffer;
-    if (sLoadCtx1.m_pNtHeaders->OptionalHeader.Magic == VAL16(IMAGE_NT_OPTIONAL_HDR32_MAGIC))
-        dwSkipOffsets[1] = (BYTE*)&((IMAGE_NT_HEADERS32*)sLoadCtx1.m_pNtHeaders)->OptionalHeader.CheckSum - sLoadCtx1.m_pbBase;
-    else if (sLoadCtx1.m_pNtHeaders->OptionalHeader.Magic == VAL16(IMAGE_NT_OPTIONAL_HDR64_MAGIC))
-        dwSkipOffsets[1] = (BYTE*)&((IMAGE_NT_HEADERS64*)sLoadCtx1.m_pNtHeaders)->OptionalHeader.CheckSum - sLoadCtx1.m_pbBase;
-    else {
-        SetLastError(CORSEC_E_INVALID_IMAGE_FORMAT);
-        goto Error;
-    }
-    dwSkipLengths[1] = sizeof(DWORD);
-
-    // Skip the COM+ 2.0 PE header extension flags field. It's updated by the
-    // signing operation.
-    dwSkipOffsets[2] = (BYTE*)&sLoadCtx1.m_pCorHeader->Flags - sLoadCtx1.m_pbBase;
-    dwSkipLengths[2] = sizeof(DWORD);
-
-    // Compare the two mapped images, skipping the ranges we defined above.
-    bIdentical = TRUE;
-    for (i = 0; i < sLoadCtx1.m_dwLength; i++) {
-
-        // Determine if we're skipping the check on the current byte.
-        bSkipping = FALSE;
-        for (j = 0; j < (sizeof(dwSkipOffsets) / sizeof(dwSkipOffsets[0])); j++)
-            if ((i >= dwSkipOffsets[j]) && (i < (dwSkipOffsets[j] + dwSkipLengths[j]))) {
-                bSkipping = TRUE;
-                break;
-            }
-
-        // Perform comparisons as desired.
-        if (sLoadCtx1.m_pbBase[i] != sLoadCtx2.m_pbBase[i])
-            if (bSkipping)
-                bIdentical = FALSE;
-            else
-                goto ImagesDiffer;
-    }
-
-    // The assemblies are the same.
-    *pdwResult = bIdentical ? SN_CMP_IDENTICAL : SN_CMP_SIGONLY;
-
-    UnloadAssembly(&sLoadCtx1);
-    UnloadAssembly(&sLoadCtx2);
-
-    retVal = TRUE;
-    goto Exit;
-
- Error:
-    SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-    if (bMappedAssem1)
-        UnloadAssembly(&sLoadCtx1);
-    if (bMappedAssem2)
-        UnloadAssembly(&sLoadCtx2);
-    goto Exit;
-
- ImagesDiffer:
-    if (bMappedAssem1)
-        UnloadAssembly(&sLoadCtx1);
-    if (bMappedAssem2)
-        UnloadAssembly(&sLoadCtx2);
-    *pdwResult = SN_CMP_DIFFERENT;
-    retVal = TRUE;
-
-Exit:
-    END_ENTRYPOINT_VOIDRET;
-
-    return retVal;
-}
-
-
-// Compute the size of buffer needed to hold a hash for a given hash algorithm.
-SNAPI StrongNameHashSize(ULONG  ulHashAlg,  // [in] hash algorithm
-                         DWORD *pcbSize)    // [out] size of the hash in bytes
-{
-    BOOLEAN     retVal = FALSE;
-
-    BEGIN_ENTRYPOINT_VOIDRET;
-
-    HCRYPTPROV  hProv = NULL;
-    HCRYPTHASH  hHash = NULL;
-    DWORD       dwSize;
-
-
-    SNLOG((W("StrongNameHashSize(%08X, %08X)\n"), ulHashAlg, pcbSize));
-
-    SN_COMMON_PROLOG();
-
-    if (pcbSize == NULL)
-        SN_ERROR(E_POINTER);
-
-    // Default hashing algorithm ID if necessary.
-    if (ulHashAlg == 0)
-        ulHashAlg = CALG_SHA1;
-
-    // Find a CSP supporting the required algorithm.
-    hProv = LocateCSP(NULL, SN_IGNORE_CONTAINER, ulHashAlg);
-    if (!hProv)
-        goto Error;
-
-    // Create a hash object.
-    if (!CryptCreateHash(hProv, ulHashAlg, 0, 0, &hHash))
-        goto Error;
-
-    // And ask for the size of the hash.
-    dwSize = sizeof(DWORD);
-    if (!CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)pcbSize, &dwSize, 0))
-        goto Error;
-
-    // Cleanup and exit.
-    CryptDestroyHash(hHash);
-    FreeCSP(hProv);
-
-    retVal = TRUE;
-    goto Exit;
-
- Error:
-    SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-    if (hHash)
-        CryptDestroyHash(hHash);
-    if (hProv)
-        FreeCSP(hProv);
-
- Exit:
-
-    END_ENTRYPOINT_VOIDRET;
-
-    return retVal;
-}
-
-
-// Compute the size that needs to be allocated for a signature in an assembly.
-SNAPI StrongNameSignatureSize(BYTE    *pbPublicKeyBlob,    // [in] public key blob
-                              ULONG    cbPublicKeyBlob,
-                              DWORD   *pcbSize)            // [out] size of the signature in bytes
-{
-    BOOLEAN         retVal = FALSE;
-
-    BEGIN_ENTRYPOINT_VOIDRET;
-
-    PublicKeyBlob  *pPublicKey = (PublicKeyBlob*)pbPublicKeyBlob;
-    ALG_ID          uHashAlgId;
-    ALG_ID          uSignAlgId;
-    HCRYPTPROV      hProv = NULL;
-    HCRYPTHASH      hHash = NULL;
-    HCRYPTKEY       hKey = NULL;
-    LPCWSTR         wszKeyContainer = NULL;
-    BOOLEAN         bTempContainer = FALSE;
-    DWORD           dwKeyLen;
-    DWORD           dwBytes;
-
-    SNLOG((W("StrongNameSignatureSize(%08X, %08X, %08X)\n"), pbPublicKeyBlob, cbPublicKeyBlob, pcbSize));
-
-    SN_COMMON_PROLOG();
-
-    if (pbPublicKeyBlob == NULL)
-        SN_ERROR(E_POINTER);
-    if (!StrongNameIsValidPublicKey(pbPublicKeyBlob, cbPublicKeyBlob, false))
-        SN_ERROR(CORSEC_E_INVALID_PUBLICKEY);
-    if (pcbSize == NULL)
-        SN_ERROR(E_POINTER);
-
-    // Special case neutral key.
-    if (SN_IS_NEUTRAL_KEY(pPublicKey))
-        pPublicKey = SN_THE_KEY();
-
-    // Determine hashing/signing algorithms.
-    uHashAlgId = GET_UNALIGNED_VAL32(&pPublicKey->HashAlgID);
-    uSignAlgId = GET_UNALIGNED_VAL32(&pPublicKey->SigAlgID);
-
-    // Default hashing and signing algorithm IDs if necessary.
-    if (uHashAlgId == 0)
-        uHashAlgId = CALG_SHA1;
-    if (uSignAlgId == 0)
-        uSignAlgId = CALG_RSA_SIGN;
-
-    // Create a temporary key container name.
-    if (!GetKeyContainerName(&wszKeyContainer, &bTempContainer))
-        goto Exit;
-
-    // Find a CSP supporting the required algorithms and create a temporary key
-    // container.
-    hProv = LocateCSP(wszKeyContainer, SN_CREATE_CONTAINER, uHashAlgId, uSignAlgId);
-    if (!hProv)
-        goto Error;
-
-    // Import the public key (we need to do this in order to determine the key
-    // length reliably).
-    if (!CryptImportKey(hProv,
-                           pPublicKey->PublicKey,
-                           GET_UNALIGNED_VAL32(&pPublicKey->cbPublicKey),
-                           0, 0, &hKey))
-        goto Error;
-
-    // Query the key attributes (it's the length we're interested in).
-    dwBytes = sizeof(dwKeyLen);
-    if (!CryptGetKeyParam(hKey, KP_KEYLEN, (BYTE*)&dwKeyLen, &dwBytes, 0))
-        goto Error;
-
-    // Delete the key container.
-    if (LocateCSP(wszKeyContainer, SN_DELETE_CONTAINER) == NULL) {
-        SetLastError(CORSEC_E_CONTAINER_NOT_FOUND);
-        goto Error;
-    }
-
-    // Take shortcut for the typical case
-    if ((uSignAlgId == CALG_RSA_SIGN) && (dwKeyLen % 8 == 0)) {
-        // The signature size known for CALG_RSA_SIGN
-        *pcbSize = dwKeyLen / 8;
-    }
-    else {
-        // Recreate the container so we can create a temporary key pair.
-        hProv = LocateCSP(wszKeyContainer, SN_CREATE_CONTAINER, uHashAlgId, uSignAlgId);
-        if (!hProv)
-            goto Error;
-
-        // Create the temporary key pair.
-        if (!CryptGenKey(hProv, g_uKeySpec, dwKeyLen << 16, &hKey))
-            goto Error;
-
-        // Create a hash.
-        if (!CryptCreateHash(hProv, uHashAlgId, 0, 0, &hHash))
-            goto Error;
-
-        // Compute size of the signature blob.
-        if (!CryptSignHashW(hHash, g_uKeySpec, NULL, 0, NULL, pcbSize))
-            goto Error;
-        CryptDestroyHash(hHash);
-
-        if (bTempContainer)
-            LocateCSP(wszKeyContainer, SN_DELETE_CONTAINER);
-    }
-
-    SNLOG((W("Signature size for  hashalg %08X, %08X key (%08X bits) is %08X bytes\n"), uHashAlgId, uSignAlgId, dwKeyLen, *pcbSize));
-
-    CryptDestroyKey(hKey);
-    FreeCSP(hProv);
-    FreeKeyContainerName(wszKeyContainer, bTempContainer);
-
-    retVal = TRUE;
-    goto Exit;
-
- Error:
-    SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-    if (hHash)
-        CryptDestroyHash(hHash);
-    if (hKey)
-        CryptDestroyKey(hKey);
-    if (hProv)
-        FreeCSP(hProv);
-    if (bTempContainer)
-        LocateCSP(wszKeyContainer, SN_DELETE_CONTAINER);
-    FreeKeyContainerName(wszKeyContainer, bTempContainer);
-
- Exit:
-    END_ENTRYPOINT_VOIDRET;
-
-    return retVal;
-}
-
-// Locate CSP based on criteria specified in the registry (CSP name etc).
-// Optionally create or delete a named key container within that CSP.
-HCRYPTPROV LocateCSP(LPCWSTR    wszKeyContainer,
-                     DWORD      dwAction,
-                     ALG_ID     uHashAlgId,
-                     ALG_ID     uSignAlgId)
-{
-    DWORD           i;
-    DWORD           dwType;
-    WCHAR           wszName[SN_MAX_CSP_NAME + 1];
-    DWORD           dwNameLength;
-    HCRYPTPROV      hProv;
-    BOOLEAN         bFirstAlg;
-    BOOLEAN         bFoundHash;
-    BOOLEAN         bFoundSign;
-    PROV_ENUMALGS   rAlgs;
-    HCRYPTPROV      hRetProv;
-    DWORD           dwAlgsLen;
-
-    DWORD dwProvType = g_uProvType;
-
-    // If a CSP name has been provided (and we're not opening a CSP just to do a
-    // SHA1 hash or a verification), open the CSP directly.
-    if (g_bHasCSPName &&
-        (dwAction != SN_HASH_SHA1_ONLY))
-    {
-        if (StrongNameCryptAcquireContext(&hProv,
-                                          wszKeyContainer ? wszKeyContainer : NULL,
-                                          g_wszCSPName,
-                                          dwProvType,
-                                          SN_CAC_FLAGS(dwAction)))
-            return (dwAction == SN_DELETE_CONTAINER) ? (HCRYPTPROV)~0 : hProv;
-        else {
-            SNLOG((W("Failed to open CSP '%s': %08X\n"), g_wszCSPName, GetLastError()));
-            return NULL;
-        }
-    }
-
-    // Set up hashing and signing algorithms to look for based upon input
-    // parameters. Or if these haven't been supplied use the configured defaults
-    // instead.
-    if (uHashAlgId == 0)
-        uHashAlgId = g_uHashAlgId;
-    if (uSignAlgId == 0)
-        uSignAlgId = g_uSignAlgId;
-
-    // If default hashing and signing algorithms have been selected (SHA1 and
-    // RSA), we select the default CSP for the RSA_FULL type. 
-    // For SHA2 and RSA, we select the default CSP For RSA_AES.
-    // Otherwise, you just get the first CSP that supports the algorithms 
-    // you specified (with no guarantee that the selected CSP is a default of any type). 
-    // This is because we have no way of forcing the enumeration to just give us default
-    // CSPs.
-    bool fUseDefaultCsp = false;
-    StrongNameCachedCsp cachedCspNumber = None;
-
-    // We know what container to use for SHA1 algorithms with RSA
-    if (((uHashAlgId == CALG_SHA1) && (uSignAlgId == CALG_RSA_SIGN)) ||
-        (dwAction == SN_HASH_SHA1_ONLY)) {
-        fUseDefaultCsp = true;
-        cachedCspNumber = Sha1CachedCsp;
-        dwProvType = PROV_RSA_FULL;
-
-        SNLOG((W("Attempting to open default provider\n")));
-    }
-
-    // We know what container to use for SHA2 algorithms with RSA
-    if ((uHashAlgId == CALG_SHA_256 || uHashAlgId == CALG_SHA_384 || uHashAlgId == CALG_SHA_512)
-        && uSignAlgId == CALG_RSA_SIGN) {
-        fUseDefaultCsp = true;
-        cachedCspNumber = Sha2CachedCsp;
-        dwProvType = PROV_RSA_AES;
-
-        SNLOG((W("Attempting to open default SHA2 provider\n")));
-    }
-    
-    if (fUseDefaultCsp)
-    {
-        // If we're not trying to create/open/delete a key container, see if a
-        // CSP is cached.
-        if (wszKeyContainer == NULL && dwAction != SN_DELETE_CONTAINER) {
-            hProv = LookupCachedCSP(cachedCspNumber);
-            if (hProv) {
-                SNLOG((W("Found provider in cache\n")));
-                return hProv;
-            }
-        }
-        if (StrongNameCryptAcquireContext(&hProv,
-                                          wszKeyContainer ? wszKeyContainer : NULL,
-                                          NULL,
-                                          dwProvType,
-                                          SN_CAC_FLAGS(dwAction))) {
-            // If we're not trying to create/open/delete a key container, cache
-            // the CSP returned.
-            if (wszKeyContainer == NULL && dwAction != SN_DELETE_CONTAINER)
-                CacheCSP(hProv, cachedCspNumber);
-            return (dwAction == SN_DELETE_CONTAINER) ? (HCRYPTPROV)~0 : hProv;
-        } else {
-            SNLOG((W("Failed to open: %08X\n"), GetLastError()));
-            return NULL;
-        }
-    }
-
-    HRESULT hr = InitStrongNameCriticalSection();
-    if (FAILED(hr)) {
-        SetLastError(hr);
-        return NULL;
-    }
-
-    // Some crypto APIs are non thread safe (e.g. enumerating CSP
-    // hashing/signing algorithms). Use a mutex to serialize these operations.
-    // The following usage is GC-safe and exception-safe:
-    {
-        CRITSEC_Holder csh(g_rStrongNameMutex);
-
-        for (i = 0; ; i++) {
-
-            // Enumerate all CSPs.
-            dwNameLength = sizeof(wszName);
-            if (CryptEnumProvidersW(i, 0, 0, &dwType, wszName, &dwNameLength)) {
-
-                // Open the currently selected CSP.
-                SNLOG((W("Considering CSP '%s'\n"), wszName));
-                if (StrongNameCryptAcquireContext(&hProv,
-                                                  NULL,
-                                                  wszName,
-                                                  dwType,
-                                                  CRYPT_SILENT |
-                                                  CRYPT_VERIFYCONTEXT |
-                                                  (g_bUseMachineKeyset ? CRYPT_MACHINE_KEYSET : 0))) {
-
-                    // Enumerate all the algorithms the CSP supports.
-                    bFirstAlg = TRUE;
-                    bFoundHash = FALSE;
-                    bFoundSign = FALSE;
-                    for (;;) {
-
-                        dwAlgsLen = sizeof(rAlgs);
-                        if (CryptGetProvParam(hProv,
-                                                 PP_ENUMALGS, (BYTE*)&rAlgs, &dwAlgsLen,
-                                                 bFirstAlg ? CRYPT_FIRST : 0)) {
-
-                            if (rAlgs.aiAlgid == uHashAlgId)
-                                bFoundHash = TRUE;
-                            else if (rAlgs.aiAlgid == uSignAlgId)
-                                bFoundSign = TRUE;
-
-                            if (bFoundHash && bFoundSign) {
-
-                                // Found a CSP that supports the required
-                                // algorithms. Re-open the context with access to
-                                // the required key container.
-
-                                SNLOG((W("CSP matches\n")));
-
-                                if (StrongNameCryptAcquireContext(&hRetProv,
-                                                                  wszKeyContainer ? wszKeyContainer : NULL,
-                                                                  wszName,
-                                                                  dwType,
-                                                                  CRYPT_SILENT | 
-                                                                  SN_CAC_FLAGS(dwAction))) {
-                                    CryptReleaseContext(hProv, 0);
-                                    return (dwAction == SN_DELETE_CONTAINER) ? (HCRYPTPROV)~0 : hRetProv;
-                                } else {
-                                    SNLOG((W("Failed to re-open for container: %08X\n"), GetLastError()));
-                                    break;
-                                }
-                            }
-
-                            bFirstAlg = FALSE;
-
-                        } else {
-                            _ASSERTE(GetLastError() == ERROR_NO_MORE_ITEMS);
-                            break;
-                        }
-
-                    }
-
-                    CryptReleaseContext(hProv, 0);
-
-                } else
-                    SNLOG((W("Failed to open CSP: %08X\n"), GetLastError()));
-
-            } else if (GetLastError() == ERROR_NO_MORE_ITEMS)
-                break;
-
-        }
-        // csh for g_rStrongNameMutex goes out of scope here
-    }
-
-    // No matching CSP found.
-    SetLastError(CORSEC_E_NO_SUITABLE_CSP);
-    return NULL;
-}
-
-
-// Release a CSP acquired through LocateCSP.
-VOID FreeCSP(HCRYPTPROV hProv)
-{
-    // If the CSP is currently cached, don't release it yet.
-    if (!IsCachedCSP(hProv))
-        CryptReleaseContext(hProv, 0);
-}
-
-// Locate a cached CSP for this thread.
-HCRYPTPROV LookupCachedCSP(StrongNameCachedCsp cspNumber)
-{
-    SN_THREAD_CTX *pThreadCtx = GetThreadContext();
-    if (pThreadCtx == NULL)
-        return NULL;
-    return pThreadCtx->m_hProv[cspNumber];
-}
-
-
-// Update the CSP cache for this thread (freeing any CSP displaced).
-VOID CacheCSP(HCRYPTPROV hProv, StrongNameCachedCsp cspNumber)
-{
-    SN_THREAD_CTX *pThreadCtx = GetThreadContext();
-    if (pThreadCtx == NULL)
-        return;
-    if (pThreadCtx->m_hProv[cspNumber])
-        CryptReleaseContext(pThreadCtx->m_hProv[cspNumber], 0);
-    pThreadCtx->m_hProv[cspNumber] = hProv;
-}
-
-
-// Determine whether a given CSP is currently cached.
-BOOLEAN IsCachedCSP(HCRYPTPROV hProv)
-{
-    SN_THREAD_CTX *pThreadCtx = GetThreadContext();
-    if (pThreadCtx == NULL)
-        return FALSE;
-    for (ULONG i = 0; i < CachedCspCount; i++)
-    {
-        if(pThreadCtx->m_hProv[i] == hProv)
-        {
-            return TRUE;
-        }
-    }
-    return FALSE;
-}
-
-// rehash all files in a multi-module assembly
-BOOLEAN RehashModules (SN_LOAD_CTX *pLoadCtx, LPCWSTR wszFilePath) {
-    HRESULT             hr;
-    ULONG               ulHashAlg;
-    mdAssembly          tkAssembly;
-    HENUMInternal       hFileEnum;
-    mdFile              tkFile;
-    LPCSTR              pszFile;
-    BYTE               *pbFileHash;
-    DWORD               cbFileHash;
-    NewArrayHolder<BYTE> pbNewFileHash(NULL);
-    DWORD               cbNewFileHash = 0;
-    DWORD               cchDirectory;
-    DWORD               cchFullFile;
-    CHAR                szFullFile[MAX_LONGPATH + 1];
-    WCHAR               wszFullFile[MAX_LONGPATH + 1];
-    LPCWSTR             pszSlash;
-    DWORD               cchFile;
-    IMDInternalImport  *pMetaDataImport = NULL;
-
-    // Determine the directory the assembly lives in (this is where we'll
-    // look for linked files).
-    if (((pszSlash = wcsrchr(wszFilePath, W('\\'))) != NULL) || ((pszSlash = wcsrchr(wszFilePath, W('/'))) != NULL)) {
-        cchDirectory = (DWORD) (pszSlash - wszFilePath + 1);
-        cchDirectory = WszWideCharToMultiByte(CP_UTF8, 0, wszFilePath, cchDirectory, szFullFile, MAX_LONGPATH, NULL, NULL);
-        if (cchDirectory >= MAX_LONGPATH) {
-            SNLOG((W("Assembly directory name too long\n")));
-            hr = ERROR_BUFFER_OVERFLOW;
-            goto Error;
-        }
-    } else
-        cchDirectory = 0;
-
-    // Open the scope on the mapped image.
-    if (FAILED(hr = GetMetadataImport(pLoadCtx, &tkAssembly, &pMetaDataImport)))
-    {
-        goto Error;
-    }
-
-    // Determine the hash algorithm used for file references.
-    if (FAILED(hr = pMetaDataImport->GetAssemblyProps(
-        tkAssembly,           // [IN] The Assembly for which to get the properties
-        NULL,                 // [OUT] Pointer to the Originator blob
-        NULL,                 // [OUT] Count of bytes in the Originator Blob
-        &ulHashAlg,           // [OUT] Hash Algorithm
-        NULL,                 // [OUT] Buffer to fill with name
-        NULL,                 // [OUT] Assembly MetaData
-        NULL)))               // [OUT] Flags
-    {
-        SNLOG((W("Failed to get assembly 0x%08X info, %08X\n"), tkAssembly, hr));
-        goto Error;
-    }
-    
-    // Enumerate all file references.
-    if (FAILED(hr = pMetaDataImport->EnumInit(mdtFile, mdTokenNil, &hFileEnum)))
-    {
-        SNLOG((W("Failed to enumerate linked files, %08X\n"), hr));
-        goto Error;
-    }
-
-    for (; pMetaDataImport->EnumNext(&hFileEnum, &tkFile); ) {
-
-        // Determine the file name and the location of the hash.
-        if (FAILED(hr = pMetaDataImport->GetFileProps(
-            tkFile, 
-            &pszFile, 
-            (const void **)&pbFileHash, 
-            &cbFileHash, 
-            NULL)))
-        {
-            SNLOG((W("Failed to get file 0x%08X info, %08X\n"), tkFile, hr));
-            goto Error;
-        }
-        
-        // Build the full filename by appending to the assembly directory we
-        // calculated earlier.
-        cchFile = (DWORD) strlen(pszFile);
-        if ((cchFile + cchDirectory) >= COUNTOF(szFullFile)) {
-            pMetaDataImport->EnumClose(&hFileEnum);
-            SNLOG((W("Linked file name too long (%S)\n"), pszFile));
-            hr = ERROR_BUFFER_OVERFLOW;
-            goto Error;
-        }
-        memcpy_s(&szFullFile[cchDirectory], COUNTOF(szFullFile) - cchDirectory, pszFile, cchFile + 1);
-
-        // Allocate enough buffer for the new hash.
-        if (cbNewFileHash < cbFileHash) {
-            pbNewFileHash = new (nothrow) BYTE[cbFileHash];
-            if (pbNewFileHash == NULL) {
-                hr = E_OUTOFMEMORY;
-                goto Error;
-            }
-            cbNewFileHash = cbFileHash;
-        }
-
-        cchFullFile = WszMultiByteToWideChar(CP_UTF8, 0, szFullFile, -1, wszFullFile, MAX_LONGPATH);
-        if (cchFullFile == 0 || cchFullFile >= MAX_LONGPATH) {
-            pMetaDataImport->EnumClose(&hFileEnum);
-            SNLOG((W("Assembly directory name too long\n")));
-            hr = ERROR_BUFFER_OVERFLOW;
-            goto Error;
-        }
-
-        // Compute a new hash for the file.
-        if (FAILED(hr = GetHashFromFileW(wszFullFile,
-                                         (unsigned*)&ulHashAlg,
-                                         pbNewFileHash,
-                                         cbNewFileHash,
-                                         &cbNewFileHash))) {
-            pMetaDataImport->EnumClose(&hFileEnum);
-            SNLOG((W("Failed to get compute file hash, %08X\n"), hr));
-            goto Error;
-        }
-
-        // The new hash has to be the same size (since we used the same
-        // algorithm).
-        _ASSERTE(cbNewFileHash == cbFileHash);
-
-        // We make the assumption here that the pointer to the file hash
-        // handed to us by the metadata is a direct pointer and not a
-        // buffered copy. If this changes, we'll need a new metadata API to
-        // support updates of this type.
-        memcpy_s(pbFileHash, cbFileHash, pbNewFileHash, cbFileHash);
-    }
-
-    pMetaDataImport->EnumClose(&hFileEnum);
-    pMetaDataImport->Release();
-    return TRUE;
-
-Error:
-    if (pMetaDataImport)
-        pMetaDataImport->Release();
-    if (pbNewFileHash)
-        pbNewFileHash.Release();
-    SetLastError(hr);
-    return FALSE;
-}
-
-//
-// Check that the public key portion of an assembly's identity matches the private key that it is being
-// signed with.
-//
-// Arguments:
-//    pAssemblySignaturePublicKey - Assembly signature public key blob
-//    wszKeyContainer             - Key container holding the key the assembly is signed with
-//    dwFlags                     - SN_ECMA_SIGN if the assembly is being ECMA signed, SN_TEST_SIGN if it is being test signed
-//    
-// Return Value:
-//    true if the assembly's public key matches the private key in wszKeyContainer, otherwise false
-//
-
-bool VerifyKeyMatchesAssembly(PublicKeyBlob * pAssemblySignaturePublicKey, __in_z LPCWSTR wszKeyContainer, BYTE *pbKeyBlob, ULONG cbKeyBlob, DWORD dwFlags)
-{
-    _ASSERTE(wszKeyContainer != NULL || pbKeyBlob != NULL);
-
-    // If we're test signing, then the assembly's public key will not match the private key by design. 
-    // Since there's nothing to check, we can quit early.
-    if ((dwFlags & SN_TEST_SIGN) == SN_TEST_SIGN)
-    {
-        return true;
-    }
-
-    if (SN_IS_NEUTRAL_KEY(pAssemblySignaturePublicKey))
-    {
-        // If we're ECMA signing an assembly with the ECMA public key, then by definition the key matches. 
-        if ((dwFlags & SN_ECMA_SIGN) == SN_ECMA_SIGN)
-        {
-            return true;
-        }
-
-        // Swap the real public key in for ECMA signing
-        pAssemblySignaturePublicKey = SN_THE_KEY();
-    }
-
-    // Otherwise, we need to check that the public key from the key container matches the public key from
-    // the assembly.
-    StrongNameBufferHolder<BYTE> pbSignaturePublicKey = NULL;
-    DWORD cbSignaturePublicKey;
-    if (!StrongNameGetPublicKeyEx(wszKeyContainer, pbKeyBlob, cbKeyBlob, &pbSignaturePublicKey, &cbSignaturePublicKey, GET_UNALIGNED_VAL32(&pAssemblySignaturePublicKey->HashAlgID), 0 /*Should be GET_UNALIGNED_VAL32(&pAssemblySignaturePublicKey->HashAlgID) once we support different signature algorithms*/))
-    {
-        // We failed to get the public key for the key in the given key container. StrongNameGetPublicKey
-        // has already set the error information, so we can just return false here without resetting it.
-        return false;
-    }
-    _ASSERTE(!pbSignaturePublicKey.IsNull() && pAssemblySignaturePublicKey != NULL);
-
-    // Do a raw compare on the public key blobs to see if they match
-    if (SN_SIZEOF_KEY(reinterpret_cast<PublicKeyBlob *>(pbSignaturePublicKey.GetValue())) == SN_SIZEOF_KEY(pAssemblySignaturePublicKey) &&
-        memcmp(static_cast<void *>(pAssemblySignaturePublicKey),
-               static_cast<void *>(pbSignaturePublicKey.GetValue()),
-               cbSignaturePublicKey) == 0)
-    {
-        return true;
-    }
-
-    SetStrongNameErrorInfo(SN_E_PUBLICKEY_MISMATCH);
-    return false;
-}
-
-// Map an assembly into memory.
-BOOLEAN LoadAssembly(SN_LOAD_CTX *pLoadCtx, LPCWSTR wszFilePath, DWORD inFlags, BOOLEAN fRequireSignature)
-{
-    DWORD dwError = S_OK;
-
-    // If a filename is not supplied, the image has already been mapped (and the
-    // image base and length fields set up correctly).
-    if (wszFilePath == NULL)
-    {
-        pLoadCtx->m_fPreMapped = TRUE;
-        pLoadCtx->m_pedecoder = new (nothrow) PEDecoder(pLoadCtx->m_pbBase, static_cast<COUNT_T>(pLoadCtx->m_dwLength));
-        if (pLoadCtx->m_pedecoder == NULL) {
-            dwError = E_OUTOFMEMORY;
-            goto Error;
-        }
-    }
-    else {
-
-        pLoadCtx->m_hMap = INVALID_HANDLE_VALUE;
-        pLoadCtx->m_pbBase = NULL;
-
-        // Open the file for reading or writing.
-        pLoadCtx->m_hFile = WszCreateFile(wszFilePath,
-                                          GENERIC_READ | (pLoadCtx->m_fReadOnly ? 0 : GENERIC_WRITE),
-                                          pLoadCtx->m_fReadOnly ? FILE_SHARE_READ : FILE_SHARE_WRITE,
-                                          NULL,
-                                          OPEN_EXISTING,
-                                          0,
-                                          NULL);
-        if (pLoadCtx->m_hFile == INVALID_HANDLE_VALUE) {
-            dwError = HRESULT_FROM_GetLastError();
-            goto Error;
-        }
-
-        pLoadCtx->m_dwLength = SafeGetFileSize(pLoadCtx->m_hFile, NULL);
-        if (pLoadCtx->m_dwLength == 0xffffffff) {
-            dwError = HRESULT_FROM_GetLastError();
-            goto Error;
-        }
-
-        // Create a mapping handle for the file.
-        pLoadCtx->m_hMap = WszCreateFileMapping(pLoadCtx->m_hFile, NULL, pLoadCtx->m_fReadOnly ? PAGE_READONLY : PAGE_READWRITE, 0, 0, NULL);
-        if (pLoadCtx->m_hMap == NULL) {
-            dwError = HRESULT_FROM_GetLastError();
-            goto Error;
-        }
-
-        // And map it into memory.
-        pLoadCtx->m_pbBase = (BYTE*)CLRMapViewOfFile(pLoadCtx->m_hMap, pLoadCtx->m_fReadOnly ? FILE_MAP_READ : FILE_MAP_WRITE, 0, 0, 0);
-        if (pLoadCtx->m_pbBase == NULL) {
-            dwError = HRESULT_FROM_GetLastError();
-            goto Error;
-        }
-        pLoadCtx->m_pedecoder = new (nothrow) PEDecoder(pLoadCtx->m_pbBase, static_cast<COUNT_T>(pLoadCtx->m_dwLength));
-        if (pLoadCtx->m_pedecoder == NULL) {
-            dwError = E_OUTOFMEMORY;
-            goto Error;
-    }
-    }
-
-    if (!pLoadCtx->m_pedecoder->HasContents() || !pLoadCtx->m_pedecoder->CheckCORFormat()) {
-        dwError = CORSEC_E_INVALID_IMAGE_FORMAT;
-        goto Error;
-    }
-    
-    // Locate standard NT image header.
-    pLoadCtx->m_pNtHeaders = pLoadCtx->m_pedecoder->GetNTHeaders32();
-
-    if (pLoadCtx->m_pNtHeaders == NULL) {
-        dwError = CORSEC_E_INVALID_IMAGE_FORMAT;
-        goto Error;
-    }
-
-    pLoadCtx->m_pCorHeader = pLoadCtx->m_pedecoder->GetCorHeader();
-
-    if (pLoadCtx->m_pCorHeader == NULL) {
-        dwError = CORSEC_E_INVALID_IMAGE_FORMAT;
-        goto Error;
-    }
-
-    // Set up signature pointer (if we require it).
-    if (fRequireSignature && pLoadCtx->m_pedecoder->HasStrongNameSignature()) 
-    {
-        COUNT_T size = 0;
-        BYTE* pbSignature = (BYTE*)pLoadCtx->m_pedecoder->GetStrongNameSignature(&size);
-
-        // Make sure the signature doesn't point back into the header
-        if (pbSignature <= reinterpret_cast<BYTE*>(pLoadCtx->m_pCorHeader) &&
-            pbSignature > reinterpret_cast<BYTE*>(pLoadCtx->m_pCorHeader) - size)
-        {
-            dwError = CORSEC_E_INVALID_IMAGE_FORMAT;
-            goto Error;
-        }
-        if (pbSignature >= reinterpret_cast<BYTE*>(pLoadCtx->m_pCorHeader) &&
-            pbSignature - sizeof(IMAGE_COR20_HEADER) < reinterpret_cast<BYTE*>(pLoadCtx->m_pCorHeader))
-        {
-            dwError = CORSEC_E_INVALID_IMAGE_FORMAT;
-            goto Error;
-        }
-
-        pLoadCtx->m_pbSignature = pbSignature;
-        pLoadCtx->m_cbSignature = static_cast<DWORD>(size); 
-    }
-
-    return TRUE;
-
- Error:
-    if (!pLoadCtx->m_fPreMapped) {
-    if (pLoadCtx->m_pbBase)
-        CLRUnmapViewOfFile(pLoadCtx->m_pbBase);
-    if (pLoadCtx->m_hMap != INVALID_HANDLE_VALUE)
-        CloseHandle(pLoadCtx->m_hMap);
-        if (pLoadCtx->m_hFile != INVALID_HANDLE_VALUE)
-            CloseHandle(pLoadCtx->m_hFile);
-    }
-    SetLastError(dwError);
-    return FALSE;
-}
-
-
-// Unload an assembly loaded with LoadAssembly (recomputing checksum if
-// necessary).
-BOOLEAN UnloadAssembly(SN_LOAD_CTX *pLoadCtx)
-{
-    BOOLEAN             bResult = TRUE;
-
-    if (!pLoadCtx->m_fReadOnly) {
-
-        IMAGE_NT_HEADERS   *pNtHeaders = NULL;
-        DWORD               dwCheckSum = 0;
-
-        // We late bind CheckSumMappedFile to avoid bringing in IMAGEHLP unless
-        // we need to.
-        HMODULE hLibrary = WszLoadLibrary(W("imagehlp.dll"));
-        if (hLibrary) {
-            IMAGE_NT_HEADERS *(*SN_CheckSumMappedFile)(BYTE*, DWORD, DWORD*, DWORD*);
-
-            if ((*(FARPROC*)&SN_CheckSumMappedFile = GetProcAddress(hLibrary, "CheckSumMappedFile")) != NULL) {
-                DWORD               dwOldCheckSum;
-
-                pNtHeaders = SN_CheckSumMappedFile(pLoadCtx->m_pbBase,
-                                        pLoadCtx->m_dwLength,
-                                        &dwOldCheckSum,
-                                        &dwCheckSum);
-            }
-
-            FreeLibrary(hLibrary);
-
-        }
-
-        if (pNtHeaders != NULL) {
-            if (pNtHeaders->OptionalHeader.Magic == VAL16(IMAGE_NT_OPTIONAL_HDR32_MAGIC))
-                ((IMAGE_NT_HEADERS32*)pNtHeaders)->OptionalHeader.CheckSum = VAL32(dwCheckSum);
-            else
-                if (pNtHeaders->OptionalHeader.Magic == VAL16(IMAGE_NT_OPTIONAL_HDR64_MAGIC))
-                    ((IMAGE_NT_HEADERS64*)pNtHeaders)->OptionalHeader.CheckSum = VAL32(dwCheckSum);
-        } else
-            bResult = FALSE;
-
-        if (!pLoadCtx->m_fPreMapped && !FlushViewOfFile(pLoadCtx->m_pbBase, 0))
-            bResult = FALSE;
-    }
-
-    if (!pLoadCtx->m_fPreMapped) {
-        if (!CLRUnmapViewOfFile(pLoadCtx->m_pbBase))
-            bResult = FALSE;
-
-        if (!CloseHandle(pLoadCtx->m_hMap))
-            bResult = FALSE;
-
-        if (!CloseHandle(pLoadCtx->m_hFile))
-            bResult = FALSE;
-    }
-
-    if (pLoadCtx->m_pedecoder != NULL)
-    {
-        delete (pLoadCtx->m_pedecoder);
-        pLoadCtx->m_pedecoder = NULL;
-    }
-
-    return bResult;
-}
-
-template<class T>
-LONG RegQueryValueT(HKEY hKey, LPCWSTR pValueName, T * pData)
-{
-    DWORD dwLength = sizeof(T);
-    
-    LONG status = WszRegQueryValueEx(hKey, pValueName, NULL, NULL, (BYTE*) pData, & dwLength);
-
-    return status;
-}
-
-// Reads CSP configuration info (name of CSP to use, IDs of hashing/signing
-// algorithms) from the registry.
-HRESULT ReadRegistryConfig()
-{
-    HKEY    hKey;
-    DWORD   dwLength;
-
-    // Initialize all settings to their default values, in case they've not been
-    // specified in the registry.
-    g_bHasCSPName = FALSE;
-    g_bUseMachineKeyset = TRUE;
-    g_uKeySpec = AT_SIGNATURE;
-    g_uHashAlgId = CALG_SHA1;
-    g_uSignAlgId = CALG_RSA_SIGN;
-    g_uProvType = PROV_RSA_FULL;
-
-#ifdef FEATURE_STRONGNAME_DELAY_SIGNING_ALLOWED
-    g_pVerificationRecords = NULL;
-#endif
-
-    g_fCacheVerify = TRUE;
-
-    // Open the configuration key in the registry.
-    if (WszRegOpenKeyEx(HKEY_LOCAL_MACHINE, SN_CONFIG_KEY_W, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
-        return S_OK;
-
-    // Read the preferred CSP name.
-    {
-        // Working set optimization: avoid touching g_wszCSPName (2052 bytes in size) unless registry has value for it
-        WCHAR tempCSPName[_countof(g_wszCSPName)];
-        dwLength = sizeof(tempCSPName);
-            
-        tempCSPName[0] = 0;
-
-        // If the registry key value is too long, that means it is invalid.
-        VERIFY(WszRegQueryValueEx(hKey, SN_CONFIG_CSP_W, NULL, NULL,
-               (BYTE*) tempCSPName, &dwLength) != ERROR_MORE_DATA);
-        tempCSPName[COUNTOF(tempCSPName) - 1] = W('\0');   // make sure the string is NULL-terminated
-        SNLOG((W("Preferred CSP name: '%s'\n"), tempCSPName));
-
-        if (tempCSPName[0] != W('\0'))
-        {
-            memcpy(g_wszCSPName, tempCSPName, sizeof(g_wszCSPName));
-            g_bHasCSPName = TRUE;
-        }
-    }
-
-    // Read the machine vs user key container flag.
-    DWORD dwUseMachineKeyset = TRUE;
-    RegQueryValueT(hKey, SN_CONFIG_MACHINE_KEYSET_W, & dwUseMachineKeyset);
-    SNLOG((W("Use machine keyset: %s\n"), dwUseMachineKeyset ? W("TRUE") : W("FALSE")));
-    g_bUseMachineKeyset = (BOOLEAN)dwUseMachineKeyset;
-
-    // Read the key spec.
-    RegQueryValueT(hKey, SN_CONFIG_KEYSPEC_W, & g_uKeySpec);
-    SNLOG((W("Key spec: %08X\n"), g_uKeySpec));
-
-    // Read the provider type
-    RegQueryValueT(hKey, SN_CONFIG_PROV_TYPE_W, & g_uProvType);
-    SNLOG((W("Provider Type: %08X\n"), g_uProvType));
-
-    // Read the hashing algorithm ID.
-    RegQueryValueT(hKey, SN_CONFIG_HASH_ALG_W, & g_uHashAlgId);
-    SNLOG((W("Hashing algorithm: %08X\n"), g_uHashAlgId));
-
-    // Read the signing algorithm ID.
-    RegQueryValueT(hKey, SN_CONFIG_SIGN_ALG_W, & g_uSignAlgId);
-    SNLOG((W("Signing algorithm: %08X\n"), g_uSignAlgId));
-
-    // Read the OK to cache verifications flag.
-    DWORD dwCacheVerify = TRUE;
-    RegQueryValueT(hKey, SN_CONFIG_CACHE_VERIFY_W, & dwCacheVerify);
-    SNLOG((W("OK to cache verifications: %s\n"), dwCacheVerify ? W("TRUE") : W("FALSE")));
-    g_fCacheVerify = (BOOLEAN)dwCacheVerify;
-
-    RegCloseKey(hKey);
-    
-    HRESULT hr = S_OK;
-#ifdef FEATURE_STRONGNAME_DELAY_SIGNING_ALLOWED
-    // Read verify disable records.
-    IfFailRet(ReadVerificationRecords());
-#endif // FEATURE_STRONGNAME_DELAY_SIGNING_ALLOWED
-    
-#ifdef FEATURE_STRONGNAME_MIGRATION
-    IfFailRet(ReadRevocationRecords());
-#endif // FEATURE_STRONGNAME_MIGRATION
-    
-    return hr;
-}
-
-#ifdef FEATURE_STRONGNAME_DELAY_SIGNING_ALLOWED
-// Read verification records from the registry during startup.
-HRESULT ReadVerificationRecords()
-{
-    HKEYHolder hKey;
-    WCHAR      wszSubKey[MAX_PATH_FNAME + 1];
-    DWORD      cchSubKey;
-    SN_VER_REC *pVerificationRecords = NULL;
-    HRESULT    hr = S_OK;
-
-    // Open the verification subkey in the registry.
-    if (WszRegOpenKeyEx(HKEY_LOCAL_MACHINE, SN_CONFIG_KEY_W W("\\") SN_CONFIG_VERIFICATION_W, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
-        return hr;
-
-    // Assembly specific records are represented as subkeys of the key we've
-    // just opened.
-    for (DWORD i = 0; ; i++) {
-        // Get the name of the next subkey.
-        cchSubKey = MAX_PATH_FNAME + 1;
-        FILETIME sFiletime;
-        if (WszRegEnumKeyEx(hKey, i, wszSubKey, &cchSubKey, NULL, NULL, NULL, &sFiletime) != ERROR_SUCCESS)
-            break;
-
-        // Open the subkey.
-        HKEYHolder hSubKey;
-        if (WszRegOpenKeyEx(hKey, wszSubKey, 0, KEY_READ, &hSubKey) == ERROR_SUCCESS) {
-            NewArrayHolder<WCHAR> mszUserList(NULL);
-            DWORD cbUserList;
-            NewArrayHolder<WCHAR> wszTestPublicKey(NULL);
-            DWORD cbTestPublicKey;
-            NewArrayHolder<WCHAR> wszAssembly(NULL);
-            SN_VER_REC *pVerRec;
-
-            // Read a list of valid users, if supplied.
-            if ((WszRegQueryValueEx(hSubKey, SN_CONFIG_USERLIST_W, NULL, NULL, NULL, &cbUserList) == ERROR_SUCCESS) &&
-                (cbUserList > 0)) {
-                mszUserList = new (nothrow) WCHAR[cbUserList / sizeof(WCHAR)];
-                if (!mszUserList) {
-                    hr = E_OUTOFMEMORY;
-                    goto FreeListExit;
-                }
-                WszRegQueryValueEx(hSubKey, SN_CONFIG_USERLIST_W, NULL, NULL, (BYTE*)mszUserList.GetValue(), &cbUserList);
-            }
-
-            // Read the test public key, if supplied
-            if ((WszRegQueryValueEx(hSubKey, SN_CONFIG_TESTPUBLICKEY_W, NULL, NULL, NULL, &cbTestPublicKey) == ERROR_SUCCESS) &&
-                (cbTestPublicKey > 0)) {
-                wszTestPublicKey = new (nothrow) WCHAR[cbTestPublicKey / sizeof(WCHAR)];
-                if (!wszTestPublicKey) {
-                    hr = E_OUTOFMEMORY;
-                    goto FreeListExit;
-                }
-                WszRegQueryValueEx(hSubKey, SN_CONFIG_TESTPUBLICKEY_W, NULL, NULL, (BYTE*)wszTestPublicKey.GetValue(), &cbTestPublicKey);
-            }
-
-            size_t dwSubKeyLen = wcslen(wszSubKey);
-            wszAssembly = new (nothrow) WCHAR[dwSubKeyLen+1];
-            if (!wszAssembly) {
-                hr = E_OUTOFMEMORY;
-                goto FreeListExit;
-            }
-            wcsncpy_s(wszAssembly, dwSubKeyLen+1, wszSubKey, _TRUNCATE);
-            wszAssembly[dwSubKeyLen] =  W('\0');
-
-            // We've found a valid entry, add it to the local list.
-            pVerRec = new (nothrow) SN_VER_REC;
-            if (!pVerRec) {
-                hr = E_OUTOFMEMORY;
-                goto FreeListExit;
-            }
-
-            pVerRec->m_mszUserList = mszUserList;
-            pVerRec->m_wszTestPublicKey = wszTestPublicKey;
-            pVerRec->m_wszAssembly = wszAssembly;
-
-            mszUserList.SuppressRelease();
-            wszTestPublicKey.SuppressRelease();
-            wszAssembly.SuppressRelease();
-
-            pVerRec->m_pNext = pVerificationRecords;
-            pVerificationRecords = pVerRec;
-            SNLOG((W("Verification record for '%s' found in registry\n"), wszSubKey));
-        }
-    }
-
-    // Initialize the global list of verification records.
-    PVOID pv = InterlockedCompareExchangeT(&g_pVerificationRecords, pVerificationRecords, NULL);
-    if (pv == NULL)
-        return hr;
-
-FreeListExit:
-    // Iterate over local list of verification records and free allocated memory.
-    SN_VER_REC *pVerRec = pVerificationRecords;
-    while (pVerRec) {
-        delete [] pVerRec->m_mszUserList;
-        delete [] pVerRec->m_wszTestPublicKey;
-        delete [] pVerRec->m_wszAssembly;
-        SN_VER_REC *tmp = pVerRec->m_pNext;
-        delete pVerRec;
-        pVerRec = tmp;
-    }
-    return hr;
-}
-#endif // FEATURE_STRONGNAME_DELAY_SIGNING_ALLOWED
-
-
-#ifdef FEATURE_STRONGNAME_MIGRATION
-
-#define SN_REVOCATION_KEY_NAME_W      W("RevokedKeys") // Registry revocation key name
-#define SN_REVOKEDKEY_VALUE_NAME_W   W("RevokedKey")  // Registry value name
-
-HRESULT ReadReplacementKeys(HKEY hKey, SN_REPLACEMENT_KEY_REC **ppReplacementRecords)
-{
-    HRESULT hr = S_OK;
-                
-    DWORD uValueCount;
-    DWORD cchMaxValueNameLen;
-
-    NewArrayHolder<WCHAR> wszValueName(NULL);
-
-    if(RegQueryInfoKey(hKey, NULL, NULL, NULL, NULL, NULL, NULL, &uValueCount, &cchMaxValueNameLen, NULL, NULL, NULL) != ERROR_SUCCESS)
-        return hr;
-
-    cchMaxValueNameLen++; // Add 1 for null character
-
-    DWORD cchValueName;
-    wszValueName = new (nothrow) WCHAR[cchMaxValueNameLen];
-    if (!wszValueName) {
-        return E_OUTOFMEMORY;
-    }
-                
-    for (DWORD j = 0; j < uValueCount; j++) {
-        cchValueName = cchMaxValueNameLen;
-        if (WszRegEnumValue(hKey, j, wszValueName, &cchValueName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
-            break;
-
-        if(SString::_wcsicmp(wszValueName, SN_REVOKEDKEY_VALUE_NAME_W) == 0) // Skip over the "RevokedKey" value
-            continue;
-
-        NewArrayHolder<BYTE> pbReplacementKey(NULL);
-        DWORD cbReplacementKey;
-        DWORD dwValType;
-        if ((WszRegQueryValueEx(hKey, wszValueName, NULL, &dwValType, NULL, &cbReplacementKey) == ERROR_SUCCESS) &&
-            (cbReplacementKey > 0) && (dwValType == REG_BINARY)) {
-            pbReplacementKey = new (nothrow) BYTE[cbReplacementKey];
-            if (!pbReplacementKey) {
-                return E_OUTOFMEMORY;
-            }
-            if(WszRegQueryValueEx(hKey, wszValueName, NULL, NULL, (BYTE*)pbReplacementKey.GetValue(), &cbReplacementKey) == ERROR_SUCCESS)
-            {
-                NewHolder<SN_REPLACEMENT_KEY_REC> pReplacementRecord(new (nothrow) SN_REPLACEMENT_KEY_REC);
-                if (pReplacementRecord == NULL) {
-                    return E_OUTOFMEMORY;
-                }
-                
-                pReplacementRecord->m_pbReplacementKey = pbReplacementKey.Extract();
-                pReplacementRecord->m_cbReplacementKey = cbReplacementKey;
-                // Insert into list
-                pReplacementRecord->m_pNext = *ppReplacementRecords;
-                *ppReplacementRecords = pReplacementRecord.Extract();
-            }
-        }
-    }
-
-    return hr;
-}
-
-// Read revocation records from the registry during startup.
-HRESULT ReadRevocationRecordsFromKey(REGSAM samDesired, SN_REVOCATION_REC **ppRevocationRecords)
-{
-    HKEYHolder          hKey;
-    WCHAR               wszSubKey[MAX_PATH_FNAME + 1];
-    DWORD               cchSubKey;
-    HRESULT             hr = S_OK;
-
-    // Open the revocation subkey in the registry.
-    if (WszRegOpenKeyEx(HKEY_LOCAL_MACHINE, SN_CONFIG_KEY_W W("\\") SN_REVOCATION_KEY_NAME_W, 0, samDesired, &hKey) != ERROR_SUCCESS)
-        return hr;
-    
-    // Assembly specific records are represented as subkeys of the key we've
-    // just opened.
-    for (DWORD i = 0; ; i++) {
-        // Read the next subkey
-        cchSubKey = MAX_PATH_FNAME + 1; // reset size of buffer, as the following call changes it
-        if (WszRegEnumKeyEx(hKey, i, wszSubKey, &cchSubKey, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
-            break;
-        
-        // Open the subkey.
-        HKEYHolder hSubKey;
-        if (WszRegOpenKeyEx(hKey, wszSubKey, 0, samDesired, &hSubKey) == ERROR_SUCCESS) {
-            NewArrayHolder<BYTE> pbRevokedKey(NULL);
-            DWORD cbRevokedKey;
-            DWORD dwValType;
-
-            // Read the "RevokedKey" value
-            if ((WszRegQueryValueEx(hSubKey, SN_REVOKEDKEY_VALUE_NAME_W, NULL, &dwValType, NULL, &cbRevokedKey) == ERROR_SUCCESS) &&
-                (cbRevokedKey > 0) && (dwValType == REG_BINARY)) {
-                pbRevokedKey = new (nothrow) BYTE[cbRevokedKey];
-                if (!pbRevokedKey) {
-                    return E_OUTOFMEMORY;
-                }
-
-                if(WszRegQueryValueEx(hSubKey, SN_REVOKEDKEY_VALUE_NAME_W, NULL, NULL, (BYTE*)pbRevokedKey.GetValue(), &cbRevokedKey) == ERROR_SUCCESS)
-                {
-                    // We've found a valid entry, store it
-                    NewHolder<SN_REVOCATION_REC> pRevocationRecord(new (nothrow) SN_REVOCATION_REC);
-                    if (pRevocationRecord == NULL) {
-                        return E_OUTOFMEMORY;
-                    }
-                    
-                    pRevocationRecord->m_pbRevokedKey = pbRevokedKey.Extract();
-                    pRevocationRecord->m_cbRevokedKey = cbRevokedKey;
-                    pRevocationRecord->m_pReplacementKeys = NULL;
-
-                    // Insert into list
-                    pRevocationRecord->m_pNext = *ppRevocationRecords;
-                    *ppRevocationRecords = pRevocationRecord.Extract();
-
-                    IfFailRet(ReadReplacementKeys(hSubKey, &pRevocationRecord->m_pReplacementKeys));
-
-                    SNLOG((W("Revocation record '%s' found in registry\n"), wszSubKey));
-                }
-            }
-        }
-    }
-
-    return hr;
-}
-
-HRESULT ReadRevocationRecords()
-{
-    HRESULT             hr = S_OK;
-
-    SYSTEM_INFO systemInfo;
-    SN_REVOCATION_REC *pRevocationRecords = NULL;
-
-    GetNativeSystemInfo(&systemInfo);
-     // Read both Software\ and Software\WOW6432Node\ on 64-bit systems
-    if(systemInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
-    {
-        IfFailGoto(ReadRevocationRecordsFromKey(KEY_READ | KEY_WOW64_64KEY, &pRevocationRecords), FreeListExit);
-        IfFailGoto(ReadRevocationRecordsFromKey(KEY_READ | KEY_WOW64_32KEY, &pRevocationRecords), FreeListExit);
-    }
-    else
-    {
-        IfFailGoto(ReadRevocationRecordsFromKey(KEY_READ, &pRevocationRecords), FreeListExit);
-    }
-    
-    // Initialize the global list of verification records.
-    PVOID pv = InterlockedCompareExchangeT(&g_pRevocationRecords, pRevocationRecords, NULL);
-
-    if (pv == NULL) // Successfully inserted the list we just created
-        return hr;
-
-FreeListExit:
-    // Iterate over local list of verification records and free allocated memory.
-    SN_REVOCATION_REC *pRevRec = pRevocationRecords;
-    while (pRevRec) {
-        if(pRevRec->m_pbRevokedKey)
-            delete [] pRevRec->m_pbRevokedKey;
-
-        SN_REPLACEMENT_KEY_REC *pKeyRec = pRevRec->m_pReplacementKeys;
-        while (pKeyRec) {
-            if(pKeyRec->m_pbReplacementKey)
-                delete [] pKeyRec->m_pbReplacementKey;
-            
-            SN_REPLACEMENT_KEY_REC *tmp = pKeyRec->m_pNext;
-            delete pKeyRec;
-            pKeyRec = tmp;
-        }
-
-        SN_REVOCATION_REC *tmp2 = pRevRec->m_pNext;
-        delete pRevRec;
-        pRevRec = tmp2;
-    }
-    return hr;
-}
-
-#endif // FEATURE_STRONGNAME_MIGRATION
-
-// Check current user name against a multi-string user name list. Return true if
-// the name is found (or the list is empty).
-BOOLEAN IsValidUser(__in_z WCHAR *mszUserList)
-{
-    HANDLE          hToken;
-    DWORD           dwRetLen;
-    TOKEN_USER     *pUser;
-    WCHAR           wszUser[1024];
-    WCHAR           wszDomain[1024];
-    DWORD           cchUser;
-    DWORD           cchDomain;
-    SID_NAME_USE    eSidUse;
-    WCHAR          *wszUserEntry;
-
-    // Empty list implies no user name checking.
-    if (mszUserList == NULL)
-        return TRUE;
-
-    // Get current user name. Don't cache this to avoid threading/impersonation
-    // problems.
-    // First look to see if there's a security token on the current thread
-    // (maybe we're impersonating). If not, we'll get the token from the
-    // process.
-    if (!OpenThreadToken(GetCurrentThread(), TOKEN_READ, FALSE, &hToken))
-        if (!OpenProcessToken(GetCurrentProcess(), TOKEN_READ, &hToken)) {
-            SNLOG((W("Failed to find a security token, error %08X\n"), GetLastError()));
-            return FALSE;
-        }
-
-    // Get the user SID. (Calculate buffer size first).
-    if (!GetTokenInformation(hToken, TokenUser, NULL, 0, &dwRetLen) &&
-        GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
-        SNLOG((W("Failed to calculate token information buffer size, error %08X\n"), GetLastError()));
-        CloseHandle(hToken);
-        return FALSE;
-    }
-
-    NewArrayHolder<BYTE> pvBuffer = new (nothrow) BYTE[dwRetLen];
-    if (pvBuffer == NULL)
-    {
-        SetLastError(E_OUTOFMEMORY);
-        return FALSE;
-    }
-
-    if (!GetTokenInformation(hToken, TokenUser, reinterpret_cast<LPVOID>((BYTE*)pvBuffer), dwRetLen, &dwRetLen)) {
-        SNLOG((W("Failed to acquire token information, error %08X\n"), GetLastError()));
-        CloseHandle(hToken);
-        return FALSE;
-    }
-
-    pUser = reinterpret_cast<TOKEN_USER *>(pvBuffer.GetValue());
-
-    // Get the user and domain names.
-    cchUser = sizeof(wszUser) / sizeof(WCHAR);
-    cchDomain = sizeof(wszDomain) / sizeof(WCHAR);
-    if (!WszLookupAccountSid(NULL, pUser->User.Sid,
-                             wszUser, &cchUser,
-                             wszDomain, &cchDomain,
-                             &eSidUse)) {
-        SNLOG((W("Failed to lookup account information, error %08X\n"), GetLastError()));
-        CloseHandle(hToken);
-        return FALSE;
-    }
-
-    CloseHandle(hToken);
-
-    // Concatenate user and domain name to get a fully qualified account name.
-    if (((wcslen(wszUser) + wcslen(wszDomain) + 2) * sizeof(WCHAR)) > sizeof(wszDomain)) {
-        SNLOG((W("Fully qualified account name was too long\n")));
-        return FALSE;
-    }
-    wcscat_s(wszDomain, COUNTOF(wszDomain), W("\\"));
-    wcscat_s(wszDomain, COUNTOF(wszDomain), wszUser);
-    SNLOG((W("Current username is '%s'\n"), wszDomain));
-
-    // Check current user against each name in the multi-string (packed
-    // list of nul terminated strings terminated with an additional nul).
-    wszUserEntry = mszUserList;
-    while (*wszUserEntry) {
-        if (!SString::_wcsicmp(wszDomain, wszUserEntry))
-            return TRUE;
-        wszUserEntry += wcslen(wszUserEntry) + 1;
-    }
-
-    // No user name match, fail search.
-    SNLOG((W("No username match\n")));
-
-    return FALSE;
-}
-
-#ifdef FEATURE_STRONGNAME_DELAY_SIGNING_ALLOWED
-// See if there's a verification records for the given assembly.
-SN_VER_REC *GetVerificationRecord(__in_z __deref LPWSTR wszAssemblyName, PublicKeyBlob *pPublicKey)
-{
-    SN_VER_REC *pVerRec;
-    SN_VER_REC *pWildcardVerRec = NULL;
-    LPWSTR      pAssembly = NULL;
-    BYTE       *pbToken;
-    DWORD       cbToken;
-    WCHAR       wszStrongName[(SN_SIZEOF_TOKEN * 2) + 1];
-    DWORD       i;
-
-    // Compress the public key to make for a shorter assembly name.
-    if (!StrongNameTokenFromPublicKey((BYTE*)pPublicKey,
-                                      SN_SIZEOF_KEY(pPublicKey),
-                                      &pbToken,
-                                      &cbToken))
-        return NULL;
-
-    if (cbToken > SN_SIZEOF_TOKEN)
-        return NULL;
-
-    // Turn the token into hex.
-    for (i = 0; i < cbToken; i++) {
-        static WCHAR *wszHex = W("0123456789ABCDEF");
-        wszStrongName[(i * 2) + 0] = wszHex[(pbToken[i] >> 4)];
-        wszStrongName[(i * 2) + 1] = wszHex[(pbToken[i] & 0x0F)];
-    }
-    wszStrongName[i * 2] = W('\0');
-    delete[] pbToken;
-
-    // Build the full assembly name.
-
-    size_t nLen = wcslen(wszAssemblyName) + wcslen(W(",")) + wcslen(wszStrongName);
-    pAssembly = new (nothrow) WCHAR[nLen +1]; // +1 for NULL
-    if (pAssembly == NULL)
-            return NULL;
-    wcscpy_s(pAssembly, nLen + 1, wszAssemblyName);
-    wcscat_s(pAssembly, nLen + 1, W(","));
-    wcscat_s(pAssembly, nLen + 1, wszStrongName);
-
-    // Iterate over global list of verification records.
-    for (pVerRec = g_pVerificationRecords; pVerRec; pVerRec = pVerRec->m_pNext) {
-        // Look for matching assembly name.
-        if (!SString::_wcsicmp(pAssembly, pVerRec->m_wszAssembly)) {
-            delete[] pAssembly;
-            // Check current user against allowed user name list.
-            if (IsValidUser(pVerRec->m_mszUserList))
-                return pVerRec;
-            else
-                return NULL;
-        } else if (!wcscmp(W("*,*"), pVerRec->m_wszAssembly)) {
-            // Found a wildcard record, it'll do if we don't find something more
-            // specific.
-            if (pWildcardVerRec == NULL)
-                pWildcardVerRec = pVerRec;
-        } else if (!wcsncmp(W("*,"), pVerRec->m_wszAssembly, 2)) {
-            // Found a wildcard record (with a specific strong name). If the
-            // strong names match it'll do unless we find something more
-            // specific (it overrides "*,*" wildcards though).
-            if (!SString::_wcsicmp(wszStrongName, &pVerRec->m_wszAssembly[2]))
-                pWildcardVerRec = pVerRec;
-        }
-    }
-
-    delete[] pAssembly;
-
-    // No match on specific assembly name, see if there's a wildcard entry.
-    if (pWildcardVerRec)
-        // Check current user against allowed user name list.
-        if (IsValidUser(pWildcardVerRec->m_mszUserList))
-            return pWildcardVerRec;
-        else
-            return NULL;
-
-    return NULL;
-}
-#endif // FEATURE_STRONGNAME_DELAY_SIGNING_ALLOWED
-
-HRESULT 
-CallGetMetaDataInternalInterface(
-    LPVOID  pData, 
-    ULONG   cbData, 
-    DWORD   flags, 
-    REFIID  riid, 
-    LPVOID *ppInterface)
-{
-#ifdef FEATURE_STRONGNAME_STANDALONE_WINRT
-    return E_NOTIMPL; 
-#elif STRONGNAME_IN_VM || !FEATURE_STANDALONE_SN
-    // We link the GetMetaDataInternalInterface, so just call it
-    return GetMetaDataInternalInterface(
-        pData, 
-        cbData, 
-        flags, 
-        riid, 
-        ppInterface);
-#elif FEATURE_CORECLR
-    return E_NOTIMPL; 
-#else
-
-    // We late bind the metadata function to avoid having a direct dependence on 
-    // mscoree.dll unless we absolutely need to.
-    
-    HRESULT                  hr = S_OK;
-    ICLRMetaHost            *pCLRMetaHost = NULL;
-    ICLRRuntimeInfo         *pCLRRuntimeInfo = NULL;
-    ICLRRuntimeHostInternal *pCLRRuntimeHostInternal = NULL;
-    
-    HMODULE hLibrary = WszLoadLibrary(MSCOREE_SHIM_W);
-    if (hLibrary == NULL)
-    {
-        hr = HRESULT_FROM_GetLastError();
-        SNLOG((W("WszLoadLibrary(\"") MSCOREE_SHIM_W W("\") failed with %08x\n"), hr));
-        goto ErrExit;
-    }
-    
-    typedef HRESULT (__stdcall *PFNCLRCreateInstance)(REFCLSID clsid, REFIID riid, /*iid_is(riid)*/ LPVOID *ppInterface);
-    PFNCLRCreateInstance pfnCLRCreateInstance = reinterpret_cast<PFNCLRCreateInstance>(GetProcAddress(
-        hLibrary, 
-        "CLRCreateInstance"));
-    if (pfnCLRCreateInstance == NULL)
-    {
-        hr = HRESULT_FROM_GetLastError();
-        SNLOG((W("Couldn't find CLRCreateInstance() in ") MSCOREE_SHIM_W W(": %08x\n"), hr));
-        goto ErrExit;
-    }
-    
-    if (FAILED(hr = pfnCLRCreateInstance(CLSID_CLRMetaHost, IID_ICLRMetaHost, (LPVOID *)&pCLRMetaHost)))
-    {
-        SNLOG((W("Error calling CLRCreateInstance() in ") MSCOREE_SHIM_W W(": %08x\n"), hr));
-        goto ErrExit;
-    }
-    
-    if (FAILED(hr = pCLRMetaHost->GetRuntime(
-        W("v") VER_PRODUCTVERSION_NO_QFE_STR_L, 
-        IID_ICLRRuntimeInfo, 
-        (LPVOID *)&pCLRRuntimeInfo)))
-    {
-        SNLOG((W("Error calling ICLRMetaHost::GetRuntime() in ") MSCOREE_SHIM_W W(": %08x\n"), hr));
-        goto ErrExit;
-    }
-    
-    if (FAILED(hr = pCLRRuntimeInfo->GetInterface(
-        CLSID_CLRRuntimeHostInternal, 
-        IID_ICLRRuntimeHostInternal, 
-        (LPVOID *)&pCLRRuntimeHostInternal)))
-    {
-        SNLOG((W("Error calling ICLRRuntimeInfo::GetInterface() in ") MSCOREE_SHIM_W W(": %08x\n"), hr));
-        goto ErrExit;
-    }
-    
-    hr = pCLRRuntimeHostInternal->GetMetaDataInternalInterface(
-        (BYTE *)pData, 
-        cbData, 
-        flags, 
-        riid, 
-        ppInterface);
-    
-ErrExit:
-    if (pCLRMetaHost != NULL)
-    {
-        pCLRMetaHost->Release();
-    }
-    if (pCLRRuntimeInfo != NULL)
-    {
-        pCLRRuntimeInfo->Release();
-    }
-    if (pCLRRuntimeHostInternal != NULL)
-    {
-        pCLRRuntimeHostInternal->Release();
-    }
-    
-    return hr;
-
-#endif
-} // CallGetMetaDataInternalInterface
-
-// Load metadata engine and return an importer.
-HRESULT 
-GetMetadataImport(
-    __in const SN_LOAD_CTX   *pLoadCtx, 
-    __in mdAssembly          *ptkAssembly, 
-    __out IMDInternalImport **ppMetaDataImport)
-{
-    HRESULT hr = E_FAIL;
-    BYTE   *pMetaData = NULL;
-
-    // Locate the COM+ meta data within the header.
-    if (pLoadCtx->m_pedecoder->CheckCorHeader())
-    {
-        pMetaData = (BYTE *)pLoadCtx->m_pedecoder->GetMetadata();
-    }
-
-    if (pMetaData == NULL)
-    {
-        SNLOG((W("Couldn't locate the COM+ header\n")));
-        return CORSEC_E_INVALID_IMAGE_FORMAT;
-    }
-
-    // Open a metadata scope on the memory directly.
-    ReleaseHolder<IMDInternalImport> pMetaDataImportHolder;
-    if (FAILED(hr = CallGetMetaDataInternalInterface(
-        pMetaData, 
-        VAL32(pLoadCtx->m_pCorHeader->MetaData.Size), 
-        ofRead, 
-        IID_IMDInternalImport, 
-        &pMetaDataImportHolder)))
-    {
-        SNLOG((W("GetMetaDataInternalInterface() failed with %08x\n"), hr));
-        return SubstituteErrorIfNotTransient(hr, CORSEC_E_INVALID_IMAGE_FORMAT);
-    }
-
-    // Determine the metadata token for the assembly from the scope.
-    if (FAILED(hr = pMetaDataImportHolder->GetAssemblyFromScope(ptkAssembly)))
-    {
-        SNLOG((W("pMetaData->GetAssemblyFromScope() failed with %08x\n"), hr));
-        return SubstituteErrorIfNotTransient(hr, CORSEC_E_INVALID_IMAGE_FORMAT);
-    }
-
-    *ppMetaDataImport = pMetaDataImportHolder.Extract(); 
-    return S_OK;
-}
-#if STRONGNAME_IN_VM
-// Function to form the fully qualified assembly name from the load context
-BOOL FormFullyQualifiedAssemblyName(SN_LOAD_CTX   *pLoadCtx, SString &assemblyName)
-{
-    mdAssembly tkAssembly;
-    // Open a metadata scope on the image.
-    ReleaseHolder<IMDInternalImport> pMetaDataImport;
-    HRESULT hr;
-    if (FAILED(hr = GetMetadataImport(pLoadCtx, &tkAssembly, &pMetaDataImport)))
-        return FALSE;
-
-    if (pMetaDataImport != NULL)
-    {
-        PEAssembly::GetFullyQualifiedAssemblyName(pMetaDataImport, tkAssembly, assemblyName);
-        return TRUE;
-    }
-    return FALSE;
-}
-#endif
-
-
-// Locate the public key blob located within the metadata of an assembly file
-// and return a copy (use delete to deallocate). Optionally get the assembly
-// name as well.
-HRESULT FindPublicKey(const SN_LOAD_CTX *pLoadCtx,
-                      __out_ecount_opt(cchAssemblyName) LPWSTR         wszAssemblyName,
-                      DWORD cchAssemblyName,
-                      __out PublicKeyBlob **ppPublicKey,
-                      DWORD *pcbPublicKey)
-{
-    HRESULT hr = S_OK;
-    *ppPublicKey = NULL;
-
-    // Open a metadata scope on the image.
-    mdAssembly tkAssembly;
-    ReleaseHolder<IMDInternalImport> pMetaDataImport;
-    if (FAILED(hr = GetMetadataImport(pLoadCtx, &tkAssembly, &pMetaDataImport)))
-        return hr;
-
-    // Read the public key location from the assembly properties (it's known as
-    // the originator property).
-    PublicKeyBlob *pKey;
-    DWORD dwKeyLen;
-    LPCSTR szAssemblyName;
-    if (FAILED(hr = pMetaDataImport->GetAssemblyProps(tkAssembly,           // [IN] The Assembly for which to get the properties
-                                      (const void **)&pKey, // [OUT] Pointer to the Originator blob
-                                      &dwKeyLen,            // [OUT] Count of bytes in the Originator Blob
-                                      NULL,                 // [OUT] Hash Algorithm
-                                      &szAssemblyName,      // [OUT] Buffer to fill with name
-                                      NULL,                 // [OUT] Assembly MetaData
-                                                      NULL)))               // [OUT] Flags
-    {
-        SNLOG((W("Did not get public key property: %08x\n"), hr));
-        return SubstituteErrorIfNotTransient(hr, CORSEC_E_MISSING_STRONGNAME);
-    }
-
-    if (dwKeyLen == 0)
-    {
-        SNLOG((W("No public key stored in metadata\n")));
-        return CORSEC_E_MISSING_STRONGNAME;
-    }
-
-    // Make a copy of the key blob (because we're going to close the metadata scope).
-    NewArrayHolder<BYTE> pKeyCopy(new (nothrow) BYTE[dwKeyLen]);
-    if (pKeyCopy == NULL)
-        return E_OUTOFMEMORY;
-    memcpy_s(pKeyCopy, dwKeyLen, pKey, dwKeyLen);
-
-    // Copy the assembly name as well (if it was asked for). We also convert
-    // from UTF8 to UNICODE while we're at it.
-    if (wszAssemblyName)
-        WszMultiByteToWideChar(CP_UTF8, 0, szAssemblyName, -1, wszAssemblyName, cchAssemblyName);
-
-    *ppPublicKey = reinterpret_cast<PublicKeyBlob *>(pKeyCopy.Extract());
-    if(pcbPublicKey != NULL)
-        *pcbPublicKey = dwKeyLen;
-
-    return S_OK;
-}
-
-BYTE HexToByte (WCHAR wc) {
-    if (!iswxdigit(wc)) return (BYTE) 0xff;
-    if (iswdigit(wc)) return (BYTE) (wc - W('0'));
-    if (iswupper(wc)) return (BYTE) (wc - W('A') + 10);
-    return (BYTE) (wc - W('a') + 10);
-}
-
-// Read the hex string into a PublicKeyBlob structure.
-// Caller owns the blob.
-PublicKeyBlob *GetPublicKeyFromHex(LPCWSTR wszPublicKeyHexString) {
-    size_t cchHex = wcslen(wszPublicKeyHexString);
-    size_t cbHex = cchHex / 2;
-    if (cchHex % 2 != 0)
-        return NULL;
-
-    BYTE *pKey = new (nothrow) BYTE[cbHex];
-    if (!pKey)
-        return NULL;
-    for (size_t i = 0; i < cbHex; i++) {
-        pKey[i] = (BYTE) ((HexToByte(*wszPublicKeyHexString) << 4) | HexToByte(*(wszPublicKeyHexString + 1)));
-        wszPublicKeyHexString += 2;
-    }
-    return (PublicKeyBlob*) pKey;
-}
-
-// Create a temporary key container name likely to be unique to this process and
-// thread. Any existing container with the same name is deleted.
-BOOLEAN GetKeyContainerName(LPCWSTR *pwszKeyContainer, BOOLEAN *pbTempContainer)
-{
-    *pbTempContainer = FALSE;
-
-    if (*pwszKeyContainer != NULL)
-        return TRUE;
-
-    GUID guid;
-    HRESULT hr = CoCreateGuid(&guid);
-    if (FAILED(hr)) {
-        SetStrongNameErrorInfo(hr);
-        return FALSE;
-    }
-
-    WCHAR wszGuid[64];
-    if (GuidToLPWSTR(guid, wszGuid, sizeof(wszGuid) / sizeof(WCHAR)) == 0) {
-        SetStrongNameErrorInfo(E_UNEXPECTED); // this operation should never fail
-        return FALSE;
-    }
-
-    // Name is of form '__MSCORSN__<guid>__' where <guid> is a GUID.
-    const size_t cchLengthOfKeyContainer = sizeof("__MSCORSN____") + (sizeof(wszGuid) / sizeof(WCHAR)) + 1 /* null */;
-    LPWSTR wszKeyContainer = new (nothrow) WCHAR[cchLengthOfKeyContainer];
-    if (wszKeyContainer == NULL) {
-        SetStrongNameErrorInfo(E_OUTOFMEMORY);
-        return FALSE;
-    }
-
-    _snwprintf_s(wszKeyContainer, cchLengthOfKeyContainer - 1 /* exclude null */, _TRUNCATE,
-             W("__MSCORSN__%s__"),
-             wszGuid);
-
-    // Delete any stale container with the same name.
-    LocateCSP(wszKeyContainer, SN_DELETE_CONTAINER);
-
-    SNLOG((W("Creating temporary key container name '%s'\n"), wszKeyContainer));
-
-    *pwszKeyContainer = wszKeyContainer;
-    *pbTempContainer = TRUE;
-
-    return TRUE;
-}
-
-
-// Free resources allocated by GetKeyContainerName and delete the named
-// container.
-VOID FreeKeyContainerName(LPCWSTR wszKeyContainer, BOOLEAN bTempContainer)
-{
-    if (bTempContainer) {
-        // Free the name.
-        delete [] (WCHAR*)wszKeyContainer;
-    }
-}
-
-static DWORD GetSpecialKeyFlags(PublicKeyBlob* pKey)
-{
-    if (SN_IS_THE_KEY(pKey))
-        return SN_OUTFLAG_MICROSOFT_SIGNATURE;
-
-    return 0;
-}
-
-#ifdef FEATURE_STRONGNAME_MIGRATION
-
-HRESULT VerifyCounterSignature(
-    PublicKeyBlob *pSignaturePublicKey,
-    ULONG          cbSignaturePublicKey,
-    PublicKeyBlob *pIdentityPublicKey,
-    BYTE          *pCounterSignature,
-    ULONG          cbCounterSignature)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    HRESULT hr = S_OK;
-
-    HandleStrongNameCspHolder hProv(NULL);
-    HandleKeyHolder hKey(NULL);
-    HandleHashHolder hHash(NULL);
-
-    hProv = LocateCSP(NULL, SN_IGNORE_CONTAINER, GET_UNALIGNED_VAL32(&pIdentityPublicKey->HashAlgID), GET_UNALIGNED_VAL32(&pIdentityPublicKey->SigAlgID));
-
-    if (!hProv)
-    {
-        hr = HRESULT_FROM_GetLastError();
-        SNLOG((W("Failed to acquire a CSP: %08x"), hr));
-        return hr;
-    }
-
-    if(SN_IS_NEUTRAL_KEY(pIdentityPublicKey))
-    {
-        pIdentityPublicKey = reinterpret_cast<PublicKeyBlob *>(const_cast<BYTE *>(g_rbTheKey));
-    }
-
-    BYTE *pbRealPublicKey = pIdentityPublicKey->PublicKey;
-    DWORD cbRealPublicKey = GET_UNALIGNED_VAL32(&pIdentityPublicKey->cbPublicKey);
-    
-    if (!CryptImportKey(hProv, pbRealPublicKey, cbRealPublicKey, 0, 0, &hKey))
-    {
-        hr = HRESULT_FROM_GetLastError();
-        SNLOG((W("Failed to import key: %08x"), hr));
-        return hr;
-    }
-
-    // Create a hash object.
-    if (!CryptCreateHash(hProv, GET_UNALIGNED_VAL32(&pIdentityPublicKey->HashAlgID), 0, 0, &hHash))
-    {
-        hr = HRESULT_FROM_GetLastError();
-        SNLOG((W("Failed to create hash: %08x"), hr));
-        return hr;
-    }
-
-    if (!CryptHashData(hHash, (BYTE*)pSignaturePublicKey, cbSignaturePublicKey, 0))
-    {
-        hr = HRESULT_FROM_GetLastError();
-        SNLOG((W("Failed to compute hash: %08x"), hr));
-        return hr;
-    }
-
-#if defined(_DEBUG) && !defined(DACCESS_COMPILE)
-    if (hHash != (HCRYPTHASH)INVALID_HANDLE_VALUE) {
-        DWORD   cbHash;
-        DWORD   dwRetLen = sizeof(cbHash);
-        if (CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&cbHash, &dwRetLen, 0))
-        {
-            NewArrayHolder<BYTE> pbHash(new (nothrow) BYTE[cbHash]);
-            if (pbHash != NULL)
-            {
-                if (CryptGetHashParam(hHash, HP_HASHVAL, pbHash, &cbHash, 0))
-                {
-                    SNLOG((W("Computed Hash Value (%u bytes):\n"), cbHash));
-                    HexDump(pbHash, cbHash);
-                }
-                else
-                {
-                    SNLOG((W("CryptGetHashParam() failed with %08X\n"), GetLastError()));
-                }
-            }
-        }
-        else
-        {
-            SNLOG((W("CryptGetHashParam() failed with %08X\n"), GetLastError()));
-        }
-    }
-#endif // _DEBUG
-
-    // Verify the hash against the signature.
-    //DbgCount(dwInFlags & SN_INFLAG_RUNTIME ? W("RuntimeVerify") : W("FusionVerify"));
-    if (pCounterSignature != NULL && cbCounterSignature != 0 && 
-        CryptVerifySignatureW(hHash, pCounterSignature, cbCounterSignature, hKey, NULL, 0))
-    {
-        SNLOG((W("Counter-signature verification succeeded\n")));
-    }
-    else
-    {
-        SNLOG((W("Counter-signature verification failed\n")));
-        hr = CORSEC_E_INVALID_COUNTERSIGNATURE;
-    }
-
-    return hr;
-}
-
-HRESULT ParseStringArgs(
-    CustomAttributeParser &ca,    // The Custom Attribute blob.
-    CaArg* pArgs,                 // Array of argument descriptors.
-    ULONG cArgs)                  // Count of argument descriptors.
-{
-    LIMITED_METHOD_CONTRACT;
-
-    HRESULT     hr = S_OK;
-
-    // For each expected arg...
-    for (ULONG ix=0; ix<cArgs; ++ix)
-    {
-        CaArg* pArg = &pArgs[ix];
-        if(pArg->type.tag != SERIALIZATION_TYPE_STRING)
-        {
-            return E_UNEXPECTED; // The blob shouldn't have anything other than strings
-        }
-        IfFailGo(ca.GetString(&pArg->val.str.pStr, &pArg->val.str.cbStr));
-    }
-    
-ErrExit:
-    return hr;
-}
-
-HRESULT GetVerifiedSignatureKey(__in SN_LOAD_CTX *pLoadCtx, __out PublicKeyBlob **ppPublicKey, __out_opt DWORD *pcbPublicKey)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-    
-    mdAssembly tkAssembly;
-    ReleaseHolder<IMDInternalImport> pMetaDataImport;
-    IfFailRet(GetMetadataImport(pLoadCtx, &tkAssembly, &pMetaDataImport));
-
-    HRESULT attributeHr;
-    void *pAttribute;
-    ULONG cbAttribute;
-    hr = pMetaDataImport->GetCustomAttributeByName(tkAssembly, g_AssemblySignatureKeyAttribute, const_cast<const void**>(&pAttribute), &cbAttribute);
-
-    if (SUCCEEDED(hr) && hr != S_FALSE)
-    {
-        CustomAttributeParser parser(pAttribute, cbAttribute);
-        IfFailRet(parser.ValidateProlog());
-
-        CaType caTypeString;
-        caTypeString.Init(SERIALIZATION_TYPE_STRING);
-        
-        CaArg args[2];
-
-        CaArg* argPublicKey = &args[0];
-        argPublicKey->Init(caTypeString);
-        
-        CaArg* argCounterSignature = &args[1];
-        argCounterSignature->Init(caTypeString);
-        
-        IfFailRet(ParseStringArgs(parser, args, lengthof(args)));
-
-        StrongNameBufferHolder<PublicKeyBlob> pSignaturePublicKey;
-        ULONG cbSignaturePublicKey;
-        if (argPublicKey->val.str.pStr == NULL || argPublicKey->val.str.cbStr == 0 ||
-            (!GetBytesFromHex(argPublicKey->val.str.pStr, argPublicKey->val.str.cbStr, (BYTE**)(pSignaturePublicKey.GetAddr()), &cbSignaturePublicKey)) ||
-            !StrongNameIsValidPublicKey((BYTE*)pSignaturePublicKey.GetValue(), cbSignaturePublicKey, false))
-        {
-            return CORSEC_E_INVALID_SIGNATUREKEY;
-        }
-        
-        NewArrayHolder<BYTE> pCounterSignature;
-        ULONG cbCounterSignature;
-        if (argCounterSignature->val.str.pStr == NULL || argCounterSignature->val.str.cbStr == 0 ||
-            (!GetBytesFromHex(argCounterSignature->val.str.pStr, argCounterSignature->val.str.cbStr, &pCounterSignature, &cbCounterSignature)))
-        {
-            return CORSEC_E_INVALID_COUNTERSIGNATURE;
-        }
-
-        StrongNameBufferHolder<PublicKeyBlob> pIdentityPublicKey = NULL;
-        IfFailRet(FindPublicKey(pLoadCtx, NULL, 0, &pIdentityPublicKey));
-
-        IfFailRet(VerifyCounterSignature(pSignaturePublicKey, cbSignaturePublicKey, pIdentityPublicKey, pCounterSignature, cbCounterSignature));
-
-        *ppPublicKey = pSignaturePublicKey.Extract();
-        if (pcbPublicKey != NULL)
-            *pcbPublicKey = cbSignaturePublicKey;
-    }
-    else
-    {
-        *ppPublicKey = NULL;
-        if (pcbPublicKey != NULL)
-            *pcbPublicKey = 0;
-    }
-
-    return hr;
-}
-
-// Checks revocation list against the assembly's public keys.
-// If the identity key has been revoked, then the signature key must be non-null and
-// must be in the replacement keys list to be allowed.
-bool AreKeysAllowedByRevocationList(BYTE* pbAssemblyIdentityKey, DWORD cbAssemblyIdentityKey, BYTE* pbAssemblySignatureKey, DWORD cbAssemblySignatureKey)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    bool fRevoked = false;
-
-    SN_REVOCATION_REC *pRevocationRec = g_pRevocationRecords;
-    while (pRevocationRec)
-    {
-        if (pRevocationRec->m_cbRevokedKey == cbAssemblyIdentityKey && 
-            memcmp(pRevocationRec->m_pbRevokedKey, pbAssemblyIdentityKey, cbAssemblyIdentityKey) == 0)
-        {
-            fRevoked = true; // Identity key can't be trusted.
-            
-            if (pbAssemblySignatureKey != NULL)
-            {
-                SN_REPLACEMENT_KEY_REC *pReplacementKeyRec = pRevocationRec->m_pReplacementKeys;
-
-                while (pReplacementKeyRec)
-                {
-                    if (pReplacementKeyRec->m_cbReplacementKey == cbAssemblySignatureKey && 
-                        memcmp(pReplacementKeyRec->m_pbReplacementKey, pbAssemblySignatureKey, cbAssemblySignatureKey) == 0)
-                    {
-                        // Signature key was allowed as a replacement for the revoked identity key.
-                        return true;
-                    }
-
-                    pReplacementKeyRec = pReplacementKeyRec->m_pNext;
-                }
-            }
-            // We didn't find the signature key in the list of allowed replacement keys for this record. 
-            // However, we don't return here, because another record might have the same identity key 
-            // and allow the signature key as a replacement.
-        }
-
-        pRevocationRec = pRevocationRec->m_pNext;
-    }
-
-    return !fRevoked; 
-}
-
-#endif // FEATURE_STRONGNAME_MIGRATION
-
-// The common code used to verify a signature (taking into account whether skip
-// verification is enabled for the given assembly).
-HRESULT VerifySignature(__in SN_LOAD_CTX *pLoadCtx, DWORD dwInFlags, PublicKeyBlob *pRealEcmaPublicKey,__out_opt DWORD *pdwOutFlags)
-{
-    if (pdwOutFlags)
-        *pdwOutFlags = 0;
-
-    // Read the public key used to sign the assembly from the assembly metadata.
-    // Also get the assembly name, we might need this if we fail the
-    // verification and need to look up a verification disablement entry.
-    WCHAR           wszSimpleAssemblyName[MAX_PATH_FNAME + 1];
-    SString         strFullyQualifiedAssemblyName;
-    BOOL            bSuccess = FALSE;
-#if STRONGNAME_IN_VM
-    BOOL            bAssemblyNameFormed = FALSE;
-    BOOL            bVerificationBegun = FALSE;
-#endif
-    
-    HandleKeyHolder             hKey(NULL);
-    HandleHashHolder            hHash(NULL);
-    HandleStrongNameCspHolder   hProv(NULL);
-
-    StrongNameBufferHolder<PublicKeyBlob> pAssemblyIdentityKey;
-    DWORD cbAssemblyIdentityKey;
-    HRESULT hr = FindPublicKey(pLoadCtx,
-                               wszSimpleAssemblyName,
-                               sizeof(wszSimpleAssemblyName) / sizeof(WCHAR),
-                               &pAssemblyIdentityKey,
-                               &cbAssemblyIdentityKey);
-    if (FAILED(hr))
-        return hr;
-
-    BOOL isEcmaKey = SN_IS_NEUTRAL_KEY(pAssemblyIdentityKey);
-    // If we're handed the ECMA key, we translate it to the real key at this point.
-    // Note: gcc gets confused with the complexity of StrongNameBufferHolder<> and 
-    // won't auto-convert pAssemblyIdentityKey to type PublicKeyBlob*, so cast it explicitly.
-    PublicKeyBlob *pRealPublicKey = isEcmaKey ? pRealEcmaPublicKey : static_cast<PublicKeyBlob*>(pAssemblyIdentityKey);
-
-// An assembly can specify a signature public key in an attribute. 
-// If one is present, we verify the signature using that public key.
-#ifdef FEATURE_STRONGNAME_MIGRATION
-    StrongNameBufferHolder<PublicKeyBlob> pAssemblySignaturePublicKey;
-    DWORD cbAssemblySignaturePublicKey;
-    IfFailRet(GetVerifiedSignatureKey(pLoadCtx, &pAssemblySignaturePublicKey, &cbAssemblySignaturePublicKey));
-    if(hr != S_FALSE) // Attribute was found
-    {
-        pRealPublicKey = pAssemblySignaturePublicKey;
-    }
-    
-#endif // FEATURE_STRONGNAME_MIGRATION
-
-    DWORD dwSpecialKeys = GetSpecialKeyFlags(pRealPublicKey);
-
-    // If this isn't the first time we've been called for this assembly and we
-    // know it was fully signed and we're confident it couldn't have been
-    // tampered with in the meantime, we can just skip the verification.
-    if (!(dwInFlags & SN_INFLAG_FORCE_VER) &&
-        !(dwInFlags & SN_INFLAG_INSTALL) &&
-        (pLoadCtx->m_pCorHeader->Flags & VAL32(COMIMAGE_FLAGS_STRONGNAMESIGNED)) &&
-        ((dwInFlags & SN_INFLAG_ADMIN_ACCESS) || g_fCacheVerify))
-    {
-        SNLOG((W("Skipping verification due to cached result\n")));
-        DbgCount(dwInFlags & SN_INFLAG_RUNTIME ? W("RuntimeSkipCache") : W("FusionSkipCache"));
-        return S_OK;
-    }
-
-#ifdef FEATURE_STRONGNAME_DELAY_SIGNING_ALLOWED
-    // If we're not forcing verification, let's see if there's a skip
-    // verification entry for this assembly. If there is we can skip all the
-    // hard work and just lie about the strong name now. The exception is if the
-    // assembly is marked as fully signed, in which case we have to force a
-    // verification to see if they're telling the truth.
-    StrongNameBufferHolder<PublicKeyBlob> pTestKey = NULL;
-    SN_VER_REC *pVerRec = GetVerificationRecord(wszSimpleAssemblyName, pAssemblyIdentityKey);
-    if (!(dwInFlags & SN_INFLAG_FORCE_VER) && !(pLoadCtx->m_pCorHeader->Flags & VAL32(COMIMAGE_FLAGS_STRONGNAMESIGNED)))
-    {
-        if (pVerRec != NULL)
-        {
-            if (pVerRec->m_wszTestPublicKey)
-            {
-                // substitute the public key with the test public key.
-                pTestKey = GetPublicKeyFromHex(pVerRec->m_wszTestPublicKey);
-                if (pTestKey != NULL)
-                {
-
-                    SNLOG((W("Using test public key for verification due to registry entry\n")));
-                    DbgCount(dwInFlags & SN_INFLAG_RUNTIME ? W("RuntimeSkipDelay") : W("FusionSkipDelay"));
-
-                    // If the assembly was not ECMA signed, then we need to update the key that it will be
-                    // verified with as well.
-                    if (!isEcmaKey)
-                    {
-                        // When test signing, there's no way to specify a hash algorithm. 
-                        // So instead of defaulting to SHA1, we pick the algorithm the assembly 
-                        // would've been signed with, if the test key wasn't present.
-                        // Thus we use the same algorithm when verifying the signature.
-                        SET_UNALIGNED_VAL32(&pTestKey->HashAlgID, GET_UNALIGNED_VAL32(&pRealPublicKey->HashAlgID));
-
-                        pRealPublicKey = pTestKey;
-                    }
-                }
-            }
-            else
-            {
-                SNLOG((W("Skipping verification due to registry entry\n")));
-                DbgCount(dwInFlags & SN_INFLAG_RUNTIME ? W("RuntimeSkipDelay") : W("FusionSkipDelay"));
-                if (pdwOutFlags)
-                {
-                    *pdwOutFlags |= dwSpecialKeys;
-                }
-                return S_OK;
-            }
-        }
-    }
-#endif // FEATURE_STRONGNAME_DELAY_SIGNING_ALLOWED
-
-#ifdef FEATURE_STRONGNAME_MIGRATION
-    if(!isEcmaKey) // We should never revoke the ecma key, as it is tied strongly to the runtime
-    {
-        if(!AreKeysAllowedByRevocationList((BYTE*)pAssemblyIdentityKey.GetValue(), cbAssemblyIdentityKey, (BYTE*)pAssemblySignaturePublicKey.GetValue(), cbAssemblySignaturePublicKey))
-        {
-            if(pAssemblySignaturePublicKey == NULL)
-            {
-                SNLOG((W("Verification failed. Assembly public key has been revoked\n")));
-            }
-            else
-            {
-                SNLOG((W("Verification failed. Assembly identity key has been revoked, an the assembly signature key isn't in the replacement key list\n")));
-            }
-
-            hr = CORSEC_E_INVALID_STRONGNAME;
-            goto Error;
-        }
-    }
-
-#endif // FEATURE_STRONGNAME_MIGRATION
-
-#ifdef FEATURE_CORECLR
-    // TritonTODO: check with security team on this
-    if (pLoadCtx->m_pbSignature == NULL)
-    {
-        hr = CORSEC_E_MISSING_STRONGNAME;
-        goto Error;
-    }
-#endif //FEATURE_CORECLR
-
-#if STRONGNAME_IN_VM
-    bVerificationBegun = TRUE;
-    // SN verification start event
-    if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context, TRACE_LEVEL_INFORMATION, CLR_SECURITY_KEYWORD))
-    {
-        // form the fully qualified assembly name using the load context
-        bAssemblyNameFormed = FormFullyQualifiedAssemblyName(pLoadCtx, strFullyQualifiedAssemblyName);
-        if(bAssemblyNameFormed)
-        {
-            ETW::SecurityLog::StrongNameVerificationStart(dwInFlags,(LPWSTR)strFullyQualifiedAssemblyName.GetUnicode());
-        }
-    }
-#endif // STRONGNAME_IN_VM
-
-    ALG_ID uHashAlgId = GET_UNALIGNED_VAL32(&pRealPublicKey->HashAlgID);
-    ALG_ID uSignAlgId = GET_UNALIGNED_VAL32(&pRealPublicKey->SigAlgID);
-
-    // Default hashing and signing algorithm IDs if necessary.
-    if (uHashAlgId == 0)
-        uHashAlgId = CALG_SHA1;
-    if (uSignAlgId == 0)
-        uSignAlgId = CALG_RSA_SIGN;
-
-    // Find a CSP supporting the required algorithms.
-    hProv = LocateCSP(NULL, SN_IGNORE_CONTAINER, uHashAlgId, uSignAlgId);
-    if (!hProv)
-    {
-        hr = HRESULT_FROM_GetLastError();
-        SNLOG((W("Failed to acquire a CSP: %08x"), hr));
-        goto Error;
-    }
-
-    BYTE *pbRealPublicKey;
-    pbRealPublicKey = pRealPublicKey->PublicKey;
-    DWORD cbRealPublicKey;
-    cbRealPublicKey = GET_UNALIGNED_VAL32(&pRealPublicKey->cbPublicKey);
-    
-    if (!CryptImportKey(hProv, pbRealPublicKey, cbRealPublicKey, 0, 0, &hKey))
-    {
-        hr = HRESULT_FROM_GetLastError();
-        SNLOG((W("Failed to import key: %08x"), hr));
-        goto Error;
-    }
-
-    // Create a hash object.
-    
-    if (!CryptCreateHash(hProv, uHashAlgId, 0, 0, &hHash))
-    {
-        hr = HRESULT_FROM_GetLastError();
-        SNLOG((W("Failed to create hash: %08x"), hr));
-        goto Error;
-    }
-
-    // Compute a hash over the image.
-    if (!ComputeHash(pLoadCtx, hHash, CalcHash, NULL))
-    {
-        hr = HRESULT_FROM_GetLastError();
-        SNLOG((W("Failed to compute hash: %08x"), hr));
-        goto Error;
-    }
-
-    // Verify the hash against the signature.
-    DbgCount(dwInFlags & SN_INFLAG_RUNTIME ? W("RuntimeVerify") : W("FusionVerify"));
-    if (pLoadCtx->m_pbSignature != NULL && pLoadCtx->m_cbSignature != 0 && 
-        CryptVerifySignatureW(hHash, pLoadCtx->m_pbSignature, pLoadCtx->m_cbSignature, hKey, NULL, 0))
-    {
-        SNLOG((W("Verification succeeded (for real)\n")));
-        if (pdwOutFlags)
-        {
-            *pdwOutFlags |= dwSpecialKeys | SN_OUTFLAG_WAS_VERIFIED;
-        }
-        bSuccess = TRUE;
-    }
-    else
-    {
-        SNLOG((W("Verification failed\n")));
-        hr = CORSEC_E_INVALID_STRONGNAME;
-    }
-
-Error:
-
-#if STRONGNAME_IN_VM
-    // SN verification end event
-    if(bVerificationBegun &&
-        ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context, TRACE_LEVEL_VERBOSE, CLR_SECURITY_KEYWORD))
-    {
-        // form the fully qualified assembly name using the load context if it has not yet been formed
-        if(!bAssemblyNameFormed)
-        {
-            strFullyQualifiedAssemblyName.Clear();
-            bAssemblyNameFormed = FormFullyQualifiedAssemblyName(pLoadCtx, strFullyQualifiedAssemblyName);
-        }
-        if(bAssemblyNameFormed)
-        {
-            ETW::SecurityLog::StrongNameVerificationStop(dwInFlags,(ULONG)hr, (LPWSTR)strFullyQualifiedAssemblyName.GetUnicode());
-        }  
-    }
-#endif // STRONGNAME_IN_VM
- 
-    if (bSuccess)
-        return S_OK;
-    else
-        return hr;
-}
-
-// Compute a hash over the elements of an assembly manifest file that should
-// remain static (skip checksum, Authenticode signatures and strong name
-// signature blob).
-// This function can also be used to get the blob of bytes that would be 
-// hashed without actually hashing.
-BOOLEAN ComputeHash(SN_LOAD_CTX *pLoadCtx, HCRYPTHASH hHash, HashFunc func, void* cookie)
-{
-    union {
-        IMAGE_NT_HEADERS32  m_32;
-        IMAGE_NT_HEADERS64  m_64;
-    }                       sHeaders;
-    IMAGE_SECTION_HEADER   *pSections;
-    ULONG                   i;
-    BYTE                   *pbSig = pLoadCtx->m_pbSignature;
-    DWORD                   cbSig = pLoadCtx->m_cbSignature;
-
-#define LIMIT_CHECK(_start, _length, _fileStart, _fileLength)               \
-        do { if (((_start) < (_fileStart))              ||                  \
-                 (((_start)+(_length)) < (_start))      ||                  \
-                 (((_start)+(_length)) < (_fileStart))  ||                  \
-                 (((_start)+(_length)) > ((_fileStart)+(_fileLength))) )    \
-        { SetLastError(CORSEC_E_INVALID_IMAGE_FORMAT); return FALSE; }  } while (false)
-        
-#define FILE_LIMIT_CHECK(_start, _length) LIMIT_CHECK(_start, _length, pLoadCtx->m_pbBase, pLoadCtx->m_dwLength)
-        
-#define SN_HASH(_start, _length) do { if (!func(hHash, (_start), (_length), 0, cookie)) return FALSE; } while (false)
-    
-#define SN_CHECK_AND_HASH(_start, _length) do { FILE_LIMIT_CHECK(_start, _length); SN_HASH(_start, _length); } while (false)
-
-    // Make sure the file size doesn't wrap around.
-    if (pLoadCtx->m_pbBase + pLoadCtx->m_dwLength <= pLoadCtx->m_pbBase)
-    {
-        SetLastError(CORSEC_E_INVALID_IMAGE_FORMAT);
-        return FALSE;
-    }
-
-    // Make sure the signature is completely contained within the file.
-    FILE_LIMIT_CHECK(pbSig, cbSig);
-
-    // Hash the DOS header if it exists.
-    if ((BYTE*)pLoadCtx->m_pNtHeaders != pLoadCtx->m_pbBase)
-        SN_CHECK_AND_HASH(pLoadCtx->m_pbBase, (DWORD)((BYTE*)pLoadCtx->m_pNtHeaders - pLoadCtx->m_pbBase));
-
-    // Add image headers minus the checksum and security data directory.
-    if (pLoadCtx->m_pNtHeaders->OptionalHeader.Magic == VAL16(IMAGE_NT_OPTIONAL_HDR32_MAGIC)) {
-        sHeaders.m_32 = *((IMAGE_NT_HEADERS32*)pLoadCtx->m_pNtHeaders);
-        sHeaders.m_32.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].VirtualAddress = 0;
-        sHeaders.m_32.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].Size = 0;
-        sHeaders.m_32.OptionalHeader.CheckSum = 0;
-        SN_HASH((BYTE*)&sHeaders.m_32, sizeof(sHeaders.m_32));
-    } else if (pLoadCtx->m_pNtHeaders->OptionalHeader.Magic == VAL16(IMAGE_NT_OPTIONAL_HDR64_MAGIC)) {
-        sHeaders.m_64 = *((IMAGE_NT_HEADERS64*)pLoadCtx->m_pNtHeaders);
-        sHeaders.m_64.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].VirtualAddress = 0;
-        sHeaders.m_64.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].Size = 0;
-        sHeaders.m_64.OptionalHeader.CheckSum = 0;
-        SN_HASH((BYTE*)&sHeaders.m_64, sizeof(sHeaders.m_64));
-    } else {
-        SetLastError(CORSEC_E_INVALID_IMAGE_FORMAT);
-        return FALSE;
-    }
-
-    // Then the section headers.
-    pSections = IMAGE_FIRST_SECTION(pLoadCtx->m_pNtHeaders);
-    SN_CHECK_AND_HASH((BYTE*)pSections, VAL16(pLoadCtx->m_pNtHeaders->FileHeader.NumberOfSections) * sizeof(IMAGE_SECTION_HEADER));
-
-    // Finally, add data from each section.
-    for (i = 0; i < VAL16(pLoadCtx->m_pNtHeaders->FileHeader.NumberOfSections); i++) {
-        BYTE   *pbData = pLoadCtx->m_pbBase + VAL32(pSections[i].PointerToRawData);
-        DWORD   cbData = VAL32(pSections[i].SizeOfRawData);
-
-        // We need to exclude the strong name signature blob from the hash. The
-        // blob could intersect the section in a number of ways.
-
-        if ((pbSig + cbSig) <= pbData || pbSig >= (pbData + cbData))
-            // No intersection at all. Hash all data.
-            SN_CHECK_AND_HASH(pbData, cbData);
-        else if (pbSig == pbData && cbSig == cbData)
-            // Signature consumes entire block. Hash no data.
-            ;
-        else if (pbSig == pbData)
-            // Signature at start. Hash end.
-            SN_CHECK_AND_HASH(pbData + cbSig, cbData - cbSig);
-        else if ((pbSig + cbSig) == (pbData + cbData))
-            // Signature at end. Hash start.
-            SN_CHECK_AND_HASH(pbData, cbData - cbSig);
-        else {
-            // Signature in the middle. Hash head and tail.
-            SN_CHECK_AND_HASH(pbData, (DWORD)(pbSig - pbData));
-            SN_CHECK_AND_HASH(pbSig + cbSig, cbData - (DWORD)(pbSig + cbSig - pbData));
-        }
-    }
-
-#if defined(_DEBUG) && !defined(DACCESS_COMPILE)
-    if (hHash != (HCRYPTHASH)INVALID_HANDLE_VALUE) {
-        DWORD   cbHash;
-        DWORD   dwRetLen = sizeof(cbHash);
-        if (CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&cbHash, &dwRetLen, 0))
-        {
-            NewArrayHolder<BYTE> pbHash(new (nothrow) BYTE[cbHash]);
-            if (pbHash != NULL)
-            {
-                if (CryptGetHashParam(hHash, HP_HASHVAL, pbHash, &cbHash, 0))
-                {
-                    SNLOG((W("Computed Hash Value (%u bytes):\n"), cbHash));
-                    HexDump(pbHash, cbHash);
-                }
-                else
-                {
-                    SNLOG((W("CryptGetHashParam() failed with %08X\n"), GetLastError()));
-                }
-            }
-        }
-        else
-        {
-            SNLOG((W("CryptGetHashParam() failed with %08X\n"), GetLastError()));
-        }
-    }
-#endif // _DEBUG
-
-    return TRUE;
-
-#undef SN_CHECK_AND_HASH    
-#undef SN_HASH
-#undef FILE_LIMIT_CHECK
-#undef LIMIT_CHECK
-}
-
-
-SNAPI_(DWORD) GetHashFromAssemblyFile(LPCSTR szFilePath, // [IN] location of file to be hashed
-                                      unsigned int *piHashAlg, // [IN/OUT] constant specifying the hash algorithm (set to 0 if you want the default)
-                                      BYTE   *pbHash,    // [OUT] hash buffer
-                                      DWORD  cchHash,    // [IN]  max size of buffer
-                                      DWORD  *pchHash)   // [OUT] length of hash byte array
-{
-    BOOL retVal = FALSE;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-    // Convert filename to wide characters and call the W version of this
-    // function.
-
-    MAKE_WIDEPTR_FROMANSI(wszFilePath, szFilePath);
-    retVal = GetHashFromAssemblyFileW(wszFilePath, piHashAlg, pbHash, cchHash, pchHash);
-    END_ENTRYPOINT_NOTHROW;
-    return retVal;
-}
-
-SNAPI_(DWORD) GetHashFromAssemblyFileW(LPCWSTR wszFilePath, // [IN] location of file to be hashed
-                                       unsigned int *piHashAlg, // [IN/OUT] constant specifying the hash algorithm (set to 0 if you want the default)
-                                       BYTE   *pbHash,    // [OUT] hash buffer
-                                       DWORD  cchHash,    // [IN]  max size of buffer
-                                       DWORD  *pchHash)   // [OUT] length of hash byte array
-{
-    HRESULT         hr;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    SN_LOAD_CTX     sLoadCtx;
-    BYTE           *pbMetaData = NULL;
-    DWORD           cbMetaData;
-
-    sLoadCtx.m_fReadOnly = TRUE;
-    if (!LoadAssembly(&sLoadCtx, wszFilePath, 0, FALSE))
-        IfFailGo(HRESULT_FROM_GetLastError());
-
-    if (sLoadCtx.m_pedecoder->CheckCorHeader())
-    {
-        pbMetaData = (BYTE *)sLoadCtx.m_pedecoder->GetMetadata();
-    }
-    if (pbMetaData == NULL) {
-        UnloadAssembly(&sLoadCtx);
-        IfFailGo(E_INVALIDARG);
-    }
-    cbMetaData = VAL32(sLoadCtx.m_pCorHeader->MetaData.Size);
-
-    hr = GetHashFromBlob(pbMetaData, cbMetaData, piHashAlg, pbHash, cchHash, pchHash);
-
-    UnloadAssembly(&sLoadCtx);
-ErrExit:
-    
-    END_ENTRYPOINT_NOTHROW;
-    return hr;
-}
-    
-SNAPI_(DWORD) GetHashFromFile(LPCSTR szFilePath, // [IN] location of file to be hashed
-                              unsigned int *piHashAlg, // [IN/OUT] constant specifying the hash algorithm (set to 0 if you want the default)
-                              BYTE   *pbHash,    // [OUT] hash buffer
-                              DWORD  cchHash,    // [IN]  max size of buffer
-                              DWORD  *pchHash)   // [OUT] length of hash byte array
-{
-    HRESULT hr = S_OK;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-    
-    HANDLE hFile = CreateFileA(szFilePath,
-                               GENERIC_READ,
-                               FILE_SHARE_READ,
-                               NULL,
-                               OPEN_EXISTING,
-                               FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,
-                               NULL);
-    if (hFile == INVALID_HANDLE_VALUE)
-    {
-        hr = HRESULT_FROM_GetLastError();
-    }
-    else
-    {
-        hr = GetHashFromHandle(hFile, piHashAlg, pbHash, cchHash, pchHash);
-        CloseHandle(hFile);
-    }
-    END_ENTRYPOINT_NOTHROW;
-    return hr;
-}
-
-SNAPI_(DWORD) GetHashFromFileW(LPCWSTR wszFilePath, // [IN] location of file to be hashed
-                               unsigned int *piHashAlg, // [IN/OUT] constant specifying the hash algorithm (set to 0 if you want the default)
-                               BYTE   *pbHash,    // [OUT] hash buffer
-                               DWORD  cchHash,    // [IN]  max size of buffer
-                               DWORD  *pchHash)   // [OUT] length of hash byte array
-{
-    HRESULT hr = S_OK;
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    HANDLE hFile = WszCreateFile(wszFilePath,
-                                 GENERIC_READ,
-                                 FILE_SHARE_READ,
-                                 NULL,
-                                 OPEN_EXISTING,
-                                 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,
-                                 NULL);
-    if (hFile == INVALID_HANDLE_VALUE)
-        IfFailGo(HRESULT_FROM_GetLastError());
-
-    hr = GetHashFromHandle(hFile, piHashAlg, pbHash, cchHash, pchHash);
-    CloseHandle(hFile);
-ErrExit:
-    
-    END_ENTRYPOINT_NOTHROW;
-    return hr;
-}
-
-SNAPI_(DWORD) GetHashFromHandle(HANDLE hFile,      // [IN] handle of file to be hashed
-                                unsigned int *piHashAlg, // [IN/OUT] constant specifying the hash algorithm (set to 0 if you want the default)
-                                BYTE   *pbHash,    // [OUT] hash buffer
-                                DWORD  cchHash,    // [IN]  max size of buffer
-                                DWORD  *pchHash)   // [OUT] length of hash byte array
-{
-    HRESULT hr;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    PBYTE pbBuffer = NULL;
-    DWORD dwFileLen = SafeGetFileSize(hFile, 0);
-    if (dwFileLen == 0xffffffff)
-        IfFailGo(HRESULT_FROM_GetLastError());
-
-    if (SetFilePointer(hFile, 0, NULL, FILE_BEGIN) == 0xFFFFFFFF)
-        IfFailGo(HRESULT_FROM_GetLastError());
-
-    DWORD dwResultLen;
-    pbBuffer = new (nothrow) BYTE[dwFileLen];
-    IfNullGo(pbBuffer);
-
-    if (ReadFile(hFile, pbBuffer, dwFileLen, &dwResultLen, NULL))
-        hr = GetHashFromBlob(pbBuffer, dwResultLen, piHashAlg, pbHash, cchHash, pchHash);
-    else
-        hr = HRESULT_FROM_GetLastError();
-
-    delete[] pbBuffer;
-
-ErrExit:
-    END_ENTRYPOINT_NOTHROW;
-
-    return hr;
-}
-
-SNAPI_(DWORD) GetHashFromBlob(BYTE   *pbBlob,       // [IN] pointer to memory block to hash
-                              DWORD  cchBlob,       // [IN] length of blob
-                              unsigned int *piHashAlg,  // [IN/OUT] constant specifying the hash algorithm (set to 0 if you want the default)
-                              BYTE   *pbHash,       // [OUT] hash buffer
-                              DWORD  cchHash,       // [IN]  max size of buffer
-                              DWORD  *pchHash)      // [OUT] length of hash byte array
-{
-    HRESULT    hr = S_OK;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    HandleStrongNameCspHolder   hProv(NULL);
-    CapiHashHolder              hHash(NULL);
-
-    if (!piHashAlg || !pbHash || !pchHash)
-        IfFailGo(E_INVALIDARG);
-
-    if (!(*piHashAlg))
-        *piHashAlg = CALG_SHA1;
-
-    *pchHash = cchHash;
-
-    hProv = LocateCSP(NULL, SN_IGNORE_CONTAINER, *piHashAlg);
-
-    if (!hProv ||
-        (!CryptCreateHash(hProv, *piHashAlg, 0, 0, &hHash)) ||
-        (!CryptHashData(hHash, pbBlob, cchBlob, 0)) ||
-        (!CryptGetHashParam(hHash, HP_HASHVAL, pbHash, pchHash, 0)))
-        hr = HRESULT_FROM_GetLastError();
-
-ErrExit:
-    END_ENTRYPOINT_NOTHROW;
-
-    return hr;
-}
-
-#endif // #ifndef DACCESS_COMPILE
-
-#else // !defined(FEATURE_CORECLR)
 
 #define InitStrongName() S_OK
 
-#endif // !defined(FEATURE_CORECLR)
-
 
 // Free buffer allocated by routines below.
 SNAPI_(VOID) StrongNameFreeBuffer(BYTE *pbMemory)            // [in] address of memory to free
@@ -4695,12 +219,6 @@ SN_THREAD_CTX *GetThreadContext()
         if (pThreadCtx == NULL)
             return NULL;
         pThreadCtx->m_dwLastError = S_OK;
-#if !defined(FEATURE_CORECLR)
-        for (ULONG i = 0; i < CachedCspCount; i++)
-        {
-            pThreadCtx->m_hProv[i] = NULL;
-        }
-#endif // !FEATURE_CORECLR
 
         EX_TRY {
             ClrFlsSetValue(TlsIdx_StrongName, pThreadCtx);
@@ -4760,18 +278,8 @@ SNAPI StrongNameTokenFromPublicKey(BYTE    *pbPublicKeyBlob,        // [in] publ
 
 #ifndef DACCESS_COMPILE
 
-#ifndef FEATURE_CORECLR
-    HCRYPTPROV      hProv = NULL;
-    HCRYPTHASH      hHash = NULL;
-    HCRYPTKEY       hKey  = NULL;
-    DWORD           dwHashLen;
-    DWORD           dwRetLen;
-    NewArrayHolder<BYTE> pHash(NULL);
-#else // !FEATURE_CORECLR
     SHA1Hash        sha1;
     BYTE            *pHash = NULL;
-#endif // !FEATURE_CORECLR
-
     DWORD           i;
     DWORD           cbKeyBlob;
     PublicKeyBlob   *pPublicKey = NULL;
@@ -4814,7 +322,7 @@ SNAPI StrongNameTokenFromPublicKey(BYTE    *pbPublicKeyBlob,        // [in] publ
         retVal = TRUE;
         goto Exit;
     }
-#ifdef FEATURE_CORECLR
+
     if (SN_IS_THE_SILVERLIGHT_PLATFORM_KEY(pbPublicKeyBlob))
     {
         memcpy_s(*ppbStrongNameToken, *pcbStrongNameToken, SN_THE_SILVERLIGHT_PLATFORM_KEYTOKEN(), SN_SIZEOF_TOKEN);
@@ -4846,7 +354,6 @@ SNAPI StrongNameTokenFromPublicKey(BYTE    *pbPublicKeyBlob,        // [in] publ
     }
 
 #endif //FEATURE_WINDOWSPHONE
-#endif //FEATURE_CORECLR
 
     // To compute the correct public key token, we need to make sure the public key blob
     // was not padded with extra bytes that CAPI CryptImportKey would've ignored.
@@ -4876,79 +383,11 @@ SNAPI StrongNameTokenFromPublicKey(BYTE    *pbPublicKeyBlob,        // [in] publ
         goto Error;
     }
 
-#ifndef FEATURE_CORECLR
-
-    // Look for a CSP to hash the public key.
-    hProv = LocateCSP(NULL, SN_HASH_SHA1_ONLY);
-    if (!hProv)
-        goto Error;
-
-    if (!CryptImportKey(hProv, 
-                           pPublicKey->PublicKey, 
-                           GET_UNALIGNED_VAL32(&pPublicKey->cbPublicKey),
-                           0, 
-                           0, 
-                           &hKey))
-        goto Error;
-
-    cbKeyBlob = sizeof(DWORD);
-    if (!CryptExportKey(hKey, 0, PUBLICKEYBLOB, 0, NULL, &cbKeyBlob))
-        goto Error;
-
-    if ((offsetof(PublicKeyBlob, PublicKey) + cbKeyBlob) != cbPublicKeyBlob) {
-        SetLastError(CORSEC_E_INVALID_PUBLICKEY);
-        goto Error;
-    }
-
-    // Create a hash object.
-    if (!CryptCreateHash(hProv, CALG_SHA1, 0, 0, &hHash))
-        goto Error;
-
-    // Compute a hash over the public key.
-    if (!CryptHashData(hHash, pbPublicKeyBlob, cbPublicKeyBlob, 0))
-        goto Error;
-
-    // Get the length of the hash.
-    dwRetLen = sizeof(dwHashLen);
-    if (!CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&dwHashLen, &dwRetLen, 0))
-        goto Error;
-
-    // Allocate a temporary block to hold the hash.
-    pHash = new (nothrow) BYTE[dwHashLen];
-    if (pHash == NULL)
-    {
-        SetLastError(E_OUTOFMEMORY);
-        goto Error;
-    }
-
-    // Read the hash value.
-    if (!CryptGetHashParam(hHash, HP_HASHVAL, pHash, &dwHashLen, 0))
-        goto Error;
-
-    // We no longer need the hash object or the provider.
-    CryptDestroyHash(hHash);
-    CryptDestroyKey(hKey);
-    FreeCSP(hProv);
-
-    // Take the last few bytes of the hash value for our token. (These are the
-    // low order bytes from a network byte order point of view). Reverse the
-    // order of these bytes in the output buffer to get host byte order.
-    _ASSERTE(dwHashLen >= SN_SIZEOF_TOKEN);
-    if (!ClrSafeInt<DWORD>::subtraction(dwHashLen, SN_SIZEOF_TOKEN, dwHashLenMinusTokenSize))
-    {
-        SetLastError(COR_E_OVERFLOW);
-        goto Error;
-    }
-
-#else // !FEATURE_CORECLR
-
     // Compute a hash over the public key.
     sha1.AddData(pbPublicKeyBlob, cbPublicKeyBlob);
     pHash = sha1.GetHash();
     static_assert(SHA1_HASH_SIZE >= SN_SIZEOF_TOKEN, "SN_SIZEOF_TOKEN must be smaller or equal to the SHA1_HASH_SIZE");
     dwHashLenMinusTokenSize = SHA1_HASH_SIZE - SN_SIZEOF_TOKEN;
-    
-#endif // !FEATURE_CORECLR
 
     // Take the last few bytes of the hash value for our token. (These are the
     // low order bytes from a network byte order point of view). Reverse the
@@ -4961,14 +400,6 @@ SNAPI StrongNameTokenFromPublicKey(BYTE    *pbPublicKeyBlob,        // [in] publ
 
  Error:
     SetStrongNameErrorInfo(HRESULT_FROM_GetLastError());
-#ifndef FEATURE_CORECLR
-    if (hHash)
-        CryptDestroyHash(hHash);
-    if (hKey)
-        CryptDestroyKey(hKey);
-    if (hProv)
-        FreeCSP(hProv);
-#endif // !FEATURE_CORECLR
 
     if (*ppbStrongNameToken) {
         delete [] *ppbStrongNameToken;
diff --git a/src/strongname/api/strongnamecoreclr.cpp b/src/strongname/api/strongnamecoreclr.cpp
index 1ed7f0e10c..b02cde3dd9 100644
--- a/src/strongname/api/strongnamecoreclr.cpp
+++ b/src/strongname/api/strongnamecoreclr.cpp
@@ -10,8 +10,6 @@
 
 #include "common.h"
 
-#if defined(FEATURE_CORECLR) 
-
 CoreClrCallbacks *GetCoreClrCallbacks();
 
 //
@@ -95,4 +93,3 @@ void InitUtilcode()
     InitUtilcode(*GetCoreClrCallbacks());
 }
 
-#endif // FEATURE_CORECLR && !STRONGNAME_IN_VM
diff --git a/src/strongname/api/strongnameinternal.cpp b/src/strongname/api/strongnameinternal.cpp
index 843436772c..56b1c0e031 100644
--- a/src/strongname/api/strongnameinternal.cpp
+++ b/src/strongname/api/strongnameinternal.cpp
@@ -86,7 +86,6 @@ bool StrongNameIsTheKey(__in_ecount(cbKey) const BYTE *pbKey, DWORD cbKey)
     return (memcmp(pbKey, g_rbTheKey, sizeof(g_rbTheKey)) == 0);
 }
 
-#ifdef FEATURE_CORECLR
 //---------------------------------------------------------------------------------------
 //
 // Check to see if a public key blob is the Silverlight Platform public key blob
@@ -135,7 +134,6 @@ bool StrongNameIsSilverlightPlatformKey(const PublicKeyBlob &keyPublicKey)
     return StrongNameSizeOfPublicKey(keyPublicKey) == sizeof(g_rbTheSilverlightPlatformKey) &&
            memcmp(reinterpret_cast<const BYTE *>(&keyPublicKey), g_rbTheSilverlightPlatformKey, sizeof(g_rbTheSilverlightPlatformKey)) == 0;
 }
-#endif //FEATURE_CORECLR
 
 //---------------------------------------------------------------------------------------
 //
@@ -223,7 +221,7 @@ bool StrongNameIsValidPublicKey(const PublicKeyBlob &keyPublicKey, bool fImportK
         return false;
     }
 
-#if !defined(FEATURE_CORECLR) || (defined(CROSSGEN_COMPILE) && !defined(PLATFORM_UNIX))
+#if (defined(CROSSGEN_COMPILE) && !defined(PLATFORM_UNIX))
     // Make sure the public key blob imports properly
     if (fImportKeys)
     {
@@ -239,9 +237,9 @@ bool StrongNameIsValidPublicKey(const PublicKeyBlob &keyPublicKey, bool fImportK
             return false;
         }
     }
-#else // !FEATURE_CORECLR || (CROSSGEN_COMPILE && !PLATFORM_UNIX)
+#else // (CROSSGEN_COMPILE && !PLATFORM_UNIX)
     _ASSERTE(!fImportKeys);
-#endif // !FEATURE_CORECLR || (CROSSGEN_COMPILE && !PLATFORM_UNIX)
+#endif // (CROSSGEN_COMPILE && !PLATFORM_UNIX)
 
     return true;
 }
@@ -268,7 +266,7 @@ DWORD StrongNameSizeOfPublicKey(const PublicKeyBlob &keyPublicKey)
            GET_UNALIGNED_VAL32(&keyPublicKey.cbPublicKey);  // the number of bytes in the key
 }
 
-#if !defined(FEATURE_CORECLR) || (defined(CROSSGEN_COMPILE) && !defined(PLATFORM_UNIX))
+#if (defined(CROSSGEN_COMPILE) && !defined(PLATFORM_UNIX))
 
 //---------------------------------------------------------------------------------------
 //
@@ -362,10 +360,10 @@ bool StrongNameCryptAcquireContext(HCRYPTPROV *phProv, LPCWSTR pwszContainer, LP
     {
         dwFlags &= ~CRYPT_MACHINE_KEYSET;
     }
-#endif // FEATURE_CRYPTO
+#endif // defined(CRYPT_VERIFYCONTEXT) && defined(CRYPT_MACHINE_KEYSET)
 
     return !!WszCryptAcquireContext(phProv, pwszContainer, pwszProvider, dwProvType, dwFlags);
 }
 
-#endif // !FEATURE_CORECLR || (CROSSGEN_COMPILE && !PLATFORM_UNIX)
+#endif // (CROSSGEN_COMPILE && !PLATFORM_UNIX)
 
diff --git a/src/strongname/inc/sncoreclr.h b/src/strongname/inc/sncoreclr.h
index a2f794b26a..1b84a32372 100644
--- a/src/strongname/inc/sncoreclr.h
+++ b/src/strongname/inc/sncoreclr.h
@@ -5,9 +5,6 @@
 #ifndef _SNCORECLR_H
 #define _SNCORECLR_H
 
-#if !defined(FEATURE_CORECLR)
-#error sncoreclr.h should only be used on CoreCLR builds
-#endif // !FEATURE_CORECLR
 
 void InitUtilcode();
 
diff --git a/src/strongname/inc/strongnameholders.h b/src/strongname/inc/strongnameholders.h
index a439768e74..1a95c87aa7 100644
--- a/src/strongname/inc/strongnameholders.h
+++ b/src/strongname/inc/strongnameholders.h
@@ -21,7 +21,7 @@ void VoidStrongNameFreeBuffer(__in T *pBuffer)
 }
 NEW_WRAPPER_TEMPLATE1(StrongNameBufferHolder, VoidStrongNameFreeBuffer<_TYPE>);
 
-#if !defined(FEATURE_CORECLR) || (defined(CROSSGEN_COMPILE) && !defined(PLATFORM_UNIX))
+#if defined(CROSSGEN_COMPILE) && !defined(PLATFORM_UNIX)
 // Holder for HCRYPTPROV handles directly allocated from CAPI
 inline void ReleaseCapiProvider(HCRYPTPROV hProv)
 {
@@ -40,7 +40,7 @@ inline void ReleaseCapiHash(HCRYPTHASH hHash)
     CryptDestroyHash(hHash);
 }
 typedef Wrapper<HCRYPTHASH, DoNothing, ReleaseCapiHash, 0> CapiHashHolder;
-#endif // !FEATURE_CORECLR || CROSSGEN_COMPILE
+#endif // defined(CROSSGEN_COMPILE) && !defined(PLATFORM_UNIX)
 
 #if SNAPI_INTERNAL
 
diff --git a/src/strongname/inc/strongnameinternal.h b/src/strongname/inc/strongnameinternal.h
index 614fdfb53a..7cbf5d87a8 100644
--- a/src/strongname/inc/strongnameinternal.h
+++ b/src/strongname/inc/strongnameinternal.h
@@ -35,7 +35,7 @@ bool StrongNameIsEcmaKey(const PublicKeyBlob &keyPublicKey);
 
 bool StrongNameIsTheKey(__in_ecount(cbKey) const BYTE *pbKey, DWORD cbKey);
 
-#if !defined(FEATURE_CORECLR) || (defined(CROSSGEN_COMPILE) && !defined(PLATFORM_UNIX))
+#if defined(CROSSGEN_COMPILE) && !defined(PLATFORM_UNIX)
 
 // Verify the format of a public key blob
 bool StrongNameIsValidKeyPair(__in_ecount(cbKeyPair) const BYTE *pbKeyPair, DWORD cbKeyPair);
@@ -43,11 +43,9 @@ bool StrongNameIsValidKeyPair(__in_ecount(cbKeyPair) const BYTE *pbKeyPair, DWOR
 bool GetBytesFromHex(LPCUTF8 szHexString, ULONG cchHexString, BYTE** buffer, ULONG *cbBufferSize);
 
 bool StrongNameCryptAcquireContext(HCRYPTPROV *phProv, LPCWSTR pwszContainer, LPCWSTR pwszProvider, DWORD dwProvType, DWORD dwFlags);
-#endif // !FEATURE_CORECLR || (CROSSGEN_COMPILE && !PLATFORM_UNIX)
+#endif // (CROSSGEN_COMPILE && !PLATFORM_UNIX)
 
-#ifdef FEATURE_CORECLR
 bool StrongNameIsSilverlightPlatformKey(__in_ecount(cbKey) const BYTE *pbKey, DWORD cbKey);
 bool StrongNameIsSilverlightPlatformKey(const PublicKeyBlob &keyPublicKey);
-#endif // FEATURE_CORECLR
 
 #endif // !_STRONGNAME_INTERNAL_H
diff --git a/src/strongname/inc/thekey.h b/src/strongname/inc/thekey.h
index 24d0375c5e..7a53f4713b 100644
--- a/src/strongname/inc/thekey.h
+++ b/src/strongname/inc/thekey.h
@@ -21,7 +21,6 @@ static const BYTE g_rbTheKey[] =
 static const BYTE g_rbTheKeyToken[] = {0xb0,0x3f,0x5f,0x7f,0x11,0xd5,0x0a,0x3a};
 
 
-#ifdef FEATURE_CORECLR
 static const BYTE g_rbTheSilverlightPlatformKey[] = 
 {
 0x00,0x24,0x00,0x00,0x04,0x80,0x00,0x00,0x94,0x00,0x00,0x00,0x06,0x02,0x00,0x00,
@@ -100,5 +99,4 @@ static const BYTE g_rbTheMicrosoftXNAKeyToken[] = {0xCC,0xAC,0x92,0xED,0x87,0x3B
 #endif
 // for FEATURE_WINDOWSPHONE, we can add the Microsoft.Phone key and the Xna key to the list of blessed keys...
 
-#endif // FEATURE_CORECLR
 
diff --git a/src/syncAzure.proj b/src/syncAzure.proj
index 0b71a3bdcd..a5bb4958a9 100644
--- a/src/syncAzure.proj
+++ b/src/syncAzure.proj
@@ -5,10 +5,10 @@
   <PropertyGroup>
     <ContainerNamePrefix Condition="'$(ContainerNamePrefix)' == ''">coreclr-$(PreReleaseLabel)</ContainerNamePrefix>
     <ContainerName Condition="'$(__Container)' == '' and '$(ContainerNamePrefix)' != '' and '$(BuildNumberMajor)' != '' and '$(BuildNumberMinor)' != ''">$(ContainerNamePrefix)-$(BuildNumberMajor)-$(BuildNumberMinor)</ContainerName>
-    <ContainerName Condition="'$(__Container)' != '' and '$(PublishTestNativeBins)' != 'true'">$(__Container)</ContainerName>
-    <ContainerName Condition="'$(__Container)' != '' and '$(PublishTestNativeBins)' == 'true'">$(__Container)-test-native-bins</ContainerName>
+    <ContainerName Condition="'$(__Container)' != ''">$(__Container)</ContainerName>
+    <ContainerName>$(ContainerName.Replace(".","-"))</ContainerName>
     <DownloadDirectory Condition="'$(PublishTestNativeBins)' != 'true'">$(PackagesDir)AzureTransfer</DownloadDirectory>
-    <DownloadDirectory Condition="'$(PublishTestNativeBins)' == 'true'">$(PackagesDir)TestNativeBins</DownloadDirectory>
+    <DownloadDirectory Condition="'$(PublishTestNativeBins)' == 'true'">$(PackagesDir)TestNativeBins\$(RuntimeId)</DownloadDirectory>
   </PropertyGroup>
 
   <Import Project="$(ToolsDir)SyncCloudContent.targets" />
@@ -16,6 +16,8 @@
   <Target Name="ValidateRequiredProperties">
     <Error Condition="'$(CloudDropAccountName)' == ''" Text="Missing property CloudDropAccountName." />
     <Error Condition="'$(CloudDropAccessToken)' == ''" Text="Missing property CloudDropAccessToken." />
+    <Error Condition="'$(__Container)' == '' and '$(PublishTestNativeBins)' == 'true'" Text="Missing property Container." />
+    <Error Condition="'$(RuntimeId)' == '' and '$(PublishTestNativeBins)' == 'true'" Text="Missing property RuntimeId." />
   </Target>
 
   <Target Name="Build" DependsOnTargets="ValidateRequiredProperties;DownloadBlobsFromAzureTargets" />
diff --git a/src/tools/crossgen/crossgen.cpp b/src/tools/crossgen/crossgen.cpp
index a3e66e69e2..625789613f 100644
--- a/src/tools/crossgen/crossgen.cpp
+++ b/src/tools/crossgen/crossgen.cpp
@@ -36,9 +36,7 @@ enum ReturnValues
 STDAPI CreatePDBWorker(LPCWSTR pwzAssemblyPath, LPCWSTR pwzPlatformAssembliesPaths, LPCWSTR pwzTrustedPlatformAssemblies, LPCWSTR pwzPlatformResourceRoots, LPCWSTR pwzAppPaths, LPCWSTR pwzAppNiPaths, LPCWSTR pwzPdbPath, BOOL fGeneratePDBLinesInfo, LPCWSTR pwzManagedPdbSearchPath, LPCWSTR pwzPlatformWinmdPaths, LPCWSTR pwzDiasymreaderPath);
 STDAPI NGenWorker(LPCWSTR pwzFilename, DWORD dwFlags, LPCWSTR pwzPlatformAssembliesPaths, LPCWSTR pwzTrustedPlatformAssemblies, LPCWSTR pwzPlatformResourceRoots, LPCWSTR pwzAppPaths, LPCWSTR pwzOutputFilename=NULL, LPCWSTR pwzPlatformWinmdPaths=NULL, ICorSvcLogger *pLogger = NULL, LPCWSTR pwszCLRJITPath = nullptr);
 void SetSvcLogger(ICorSvcLogger *pCorSvcLogger);
-#ifdef FEATURE_CORECLR
 void SetMscorlibPath(LPCWSTR wzSystemDirectory);
-#endif
 
 /* --------------------------------------------------------------------------- *    
  * Console stuff
@@ -94,11 +92,7 @@ void ErrorWin32(DWORD err)
 
 void PrintLogoHelper()
 {
-#ifdef FEATURE_CORECLR
     Output(W("Microsoft (R) CoreCLR Native Image "));
-#else
-    Output(W("Microsoft (R) CLR Native Image "));
-#endif
     Outputf(W("Generator - Version %S\n"), VER_FILEVERSION_STR);
     Outputf(W("%S\n"), VER_LEGALCOPYRIGHT_LOGO_STR);
     Output(W("\n"));
@@ -116,12 +110,9 @@ void PrintUsageHelper()
        W("    /nologo              - Prevents displaying the logo\n")
        W("    @response.rsp        - Process command line arguments from specified\n")
        W("                           response file\n")
-#ifdef FEATURE_CORECLR
        W("    /partialtrust        - Assembly will be run in a partial trust domain.\n")
-#endif
        W("    /in <file>           - Specifies input filename (optional)\n")
        W("    /out <file>          - Specifies output filename (optional)\n")
-#ifdef FEATURE_CORECLR
        W("    /Trusted_Platform_Assemblies <path[") PATH_SEPARATOR_STR_W W("path]>\n")
        W("                         - List of assemblies treated as trusted platform\n")
        W("                         - Cannot be used with Platform_Assemblies_Paths\n")
@@ -134,15 +125,12 @@ void PrintUsageHelper()
        W("                         - List of paths containing user-application native images\n")
        W("                         - Must be used with /CreatePDB switch\n")
 #endif // NO_NGENPDB
-#endif // FEATURE_CORECLR
 
        W("    /Platform_Assemblies_Paths <path[") PATH_SEPARATOR_STR_W W("path]>\n")
        W("                         - List of paths containing target platform assemblies\n")
-#ifdef FEATURE_CORECLR
        // If Platform_Assemblies_Paths, we will use it to build the TPA list and thus,
        // TPA list cannot be explicitly specified.
        W("                         - Cannot be used with Trusted_Platform_Assemblies\n")
-#endif // FEATURE_CORECLR
        
 #ifdef FEATURE_COMINTEROP
        W("    /Platform_Winmd_Paths <path[") PATH_SEPARATOR_STR_W W("path]>\n")
@@ -156,10 +144,10 @@ void PrintUsageHelper()
        W("    /Tuning              - Generate an instrumented image to collect\n")
        W("                           scenario traces, which can be used with ibcmerge.exe\n")
 #endif
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#if !defined(FEATURE_MERGE_JIT_AND_ENGINE)
        W("    /JITPath <path>\n")
        W("                         - Specifies the absolute file path to JIT compiler to be used.\n")
-#endif // defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#endif // !defined(FEATURE_MERGE_JIT_AND_ENGINE)
 #ifdef FEATURE_READYTORUN_COMPILER
        W("    /ReadyToRun          - Generate images resilient to the runtime and\n")
        W("                           dependency versions\n")
@@ -168,19 +156,15 @@ void PrintUsageHelper()
        W(" WinMD Parameters\n")
        W("    /WinMDResilient - Generate images resilient to WinMD dependency changes.\n")
 #endif
-#ifdef FEATURE_CORECLR
        W(" Size on Disk Parameters\n")
        W("    /NoMetaData     - Do not copy metadata and IL into native image.\n")
-#endif // FEATURE_CORECLR
 #ifndef NO_NGENPDB
        W(" Debugging Parameters\n")
        W("    /CreatePDB <Dir to store PDB> [/lines [<search path for managed PDB>] ]\n")
        W("        When specifying /CreatePDB, the native image should be created\n")
        W("        first, and <assembly name> should be the path to the NI.\n")
-#ifdef FEATURE_CORECLR
        W("    /DiasymreaderPath <Path to diasymreader.dll>\n")
        W("        - Specifies the absolute file path to diasymreader.dll to be used.\n")
-#endif // FEATURE_CORECLR
 #elif defined(FEATURE_PERFMAP)
        W(" Debugging Parameters\n")
        W("    /CreatePerfMap <Dir to store perf map>\n")
@@ -265,7 +249,6 @@ bool StringEndsWith(LPCWSTR pwzString, LPCWSTR pwzCandidate)
     return !_wcsicmp(pwzStringEnd, pwzCandidate);
 }
 
-#ifdef FEATURE_CORECLR
 //
 // When using the Phone binding model (TrustedPlatformAssemblies), automatically
 // detect which path CoreLib.[ni.]dll lies in.
@@ -429,7 +412,6 @@ void ComputeTPAListFromPlatformAssembliesPath(LPCWSTR pwzPlatformAssembliesPaths
         }
     }
 }
-#endif // FEATURE_CORECLR
 
 extern HMODULE g_hThisInst;
 
@@ -459,9 +441,9 @@ int _cdecl wmain(int argc, __in_ecount(argc) WCHAR **argv)
     LPCWSTR pwzOutputFilename = NULL;
     LPCWSTR pwzPublicKeys = nullptr;
 
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#if !defined(FEATURE_MERGE_JIT_AND_ENGINE)
     LPCWSTR pwszCLRJITPath = nullptr;
-#endif // defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#endif // !defined(FEATURE_MERGE_JIT_AND_ENGINE)
 
     LPCWSTR pwzDiasymreaderPath = nullptr;
 
@@ -501,10 +483,8 @@ int _cdecl wmain(int argc, __in_ecount(argc) WCHAR **argv)
     // By default, Crossgen will assume code-generation for fulltrust domains unless /PartialTrust switch is specified
     dwFlags |= NGENWORKER_FLAGS_FULLTRUSTDOMAIN;
 
-#ifdef FEATURE_CORECLR
     // By default, Crossgen will generate readytorun images unless /FragileNonVersionable switch is specified
     dwFlags |= NGENWORKER_FLAGS_READYTORUN;
-#endif
 
     while (argc > 0)
     {
@@ -526,7 +506,6 @@ int _cdecl wmain(int argc, __in_ecount(argc) WCHAR **argv)
         {
             dwFlags |= NGENWORKER_FLAGS_MISSINGDEPENDENCIESOK;
         }
-#ifdef FEATURE_CORECLR
         else if (MatchParameter(*argv, W("PartialTrust")))
         {
             // Clear the /fulltrust flag
@@ -551,7 +530,6 @@ int _cdecl wmain(int argc, __in_ecount(argc) WCHAR **argv)
             argc--;
         }
 #endif // !defined(FEATURE_MERGE_JIT_AND_ENGINE)
-#endif
 #ifdef FEATURE_WINMD_RESILIENT
         else if (MatchParameter(*argv, W("WinMDResilient")))
         {
@@ -568,12 +546,10 @@ int _cdecl wmain(int argc, __in_ecount(argc) WCHAR **argv)
             dwFlags &= ~NGENWORKER_FLAGS_READYTORUN;
         }
 #endif
-#ifdef FEATURE_CORECLR
         else if (MatchParameter(*argv, W("NoMetaData")))
         {
             dwFlags |= NGENWORKER_FLAGS_NO_METADATA;
         }
-#endif
         else if (MatchParameter(*argv, W("out")))
         {
             if (pwzOutputFilename != NULL)
@@ -596,7 +572,6 @@ int _cdecl wmain(int argc, __in_ecount(argc) WCHAR **argv)
             argv++;
             argc--;
         }
-#ifdef FEATURE_CORECLR
         else if (MatchParameter(*argv, W("Trusted_Platform_Assemblies")) && (argc > 1))
         {
             pwzTrustedPlatformAssemblies = argv[1];
@@ -631,7 +606,6 @@ int _cdecl wmain(int argc, __in_ecount(argc) WCHAR **argv)
             argc--;
         }
 #endif // NO_NGENPDB
-#endif // FEATURE_CORECLR
         else if (MatchParameter(*argv, W("Platform_Assemblies_Paths")) && (argc > 1))
         {
             pwzPlatformAssembliesPaths = argv[1];
@@ -708,7 +682,6 @@ int _cdecl wmain(int argc, __in_ecount(argc) WCHAR **argv)
             argv--;
             argc++;
         }
-#ifdef FEATURE_CORECLR
         else if (MatchParameter(*argv, W("DiasymreaderPath")) && (argc > 1))
         {
             pwzDiasymreaderPath = argv[1];
@@ -717,7 +690,6 @@ int _cdecl wmain(int argc, __in_ecount(argc) WCHAR **argv)
             argv++;
             argc--;
         }
-#endif // FEATURE_CORECLR
 #endif // NO_NGENPDB
 #ifdef FEATURE_PERFMAP
         else if (MatchParameter(*argv, W("CreatePerfMap")) && (argc > 1))
@@ -816,23 +788,22 @@ int _cdecl wmain(int argc, __in_ecount(argc) WCHAR **argv)
         exit(FAILURE_RESULT);
     }
 
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#if !defined(FEATURE_MERGE_JIT_AND_ENGINE)
     if (pwszCLRJITPath != nullptr && fCreatePDB)
     {
         Output(W("The /JITPath switch can not be used with the /CreatePDB switch.\n"));
         exit(FAILURE_RESULT);
     }
-#endif // defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#endif // !defined(FEATURE_MERGE_JIT_AND_ENGINE)
 
-#if defined(FEATURE_CORECLR) && !defined(NO_NGENPDB)
+#if !defined(NO_NGENPDB)
     if (pwzDiasymreaderPath != nullptr && !fCreatePDB)
     {
         Output(W("The /DiasymreaderPath switch can only be used with the /CreatePDB switch.\n"));
         exit(FAILURE_RESULT);
     }
-#endif // defined(FEATURE_CORECLR) && !defined(NO_NGENPDB)
+#endif // !defined(NO_NGENPDB)
 
-#if defined(FEATURE_CORECLR)
     if ((pwzTrustedPlatformAssemblies != nullptr) && (pwzPlatformAssembliesPaths != nullptr))
     {
         Output(W("The /Trusted_Platform_Assemblies and /Platform_Assemblies_Paths switches cannot be both specified.\n"));
@@ -863,7 +834,6 @@ int _cdecl wmain(int argc, __in_ecount(argc) WCHAR **argv)
             exit(FAILURE_RESULT);
         }
     }
-#endif // FEATURE_CORESYSTEM
 
 #ifdef FEATURE_READYTORUN_COMPILER
     if (((dwFlags & NGENWORKER_FLAGS_TUNING) != 0) && ((dwFlags & NGENWORKER_FLAGS_READYTORUN) != 0))
@@ -888,7 +858,6 @@ int _cdecl wmain(int argc, __in_ecount(argc) WCHAR **argv)
 
     PathString wzTrustedPathRoot;
 
-#ifdef FEATURE_CORECLR
     SString ssTPAList;  
 
     if (fCreatePDB)
@@ -924,7 +893,6 @@ int _cdecl wmain(int argc, __in_ecount(argc) WCHAR **argv)
             SetMscorlibPath(pwzPlatformAssembliesPaths);
         }
     }
-#endif // FEATURE_CORECLR
 
     if (pwzPlatformAssembliesPaths == NULL)
     {
@@ -977,11 +945,11 @@ int _cdecl wmain(int argc, __in_ecount(argc) WCHAR **argv)
          pwzAppPaths,
          pwzOutputFilename,
          pwzPlatformWinmdPaths
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)      
+#if !defined(FEATURE_MERGE_JIT_AND_ENGINE)
         ,
         NULL, // ICorSvcLogger
         pwszCLRJITPath   
-#endif // defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#endif // !defined(FEATURE_MERGE_JIT_AND_ENGINE)
          );
     }
     
diff --git a/src/tools/metainfo/mdinfo.cpp b/src/tools/metainfo/mdinfo.cpp
index 70dfa28bcf..143220117e 100644
--- a/src/tools/metainfo/mdinfo.cpp
+++ b/src/tools/metainfo/mdinfo.cpp
@@ -22,9 +22,6 @@
 
 #define LEGACY_ACTIVATION_SHIM_LOAD_LIBRARY WszLoadLibrary
 #define LEGACY_ACTIVATION_SHIM_DEFINE_CoInitializeEE
-#ifndef FEATURE_CORECLR
-#include "LegacyActivationShim.h"
-#endif
 
 #define ENUM_BUFFER_SIZE 10
 #define TAB_SIZE 8
@@ -760,12 +757,6 @@ void MDInfo::Error(const char* szError, HRESULT hr)
             pIErr->Release();
 
     }
-#ifndef FEATURE_CORECLR
-    LegacyActivationShim::CoUninitializeCor();
-#ifndef FEATURE_PAL
-    CoUninitialize();
-#endif
-#endif
     exit(hr);
 } // void MDInfo::Error()
 
diff --git a/src/unwinder/i386/unwinder_i386.cpp b/src/unwinder/i386/unwinder_i386.cpp
index f4490ace7e..ca9e28e44a 100644
--- a/src/unwinder/i386/unwinder_i386.cpp
+++ b/src/unwinder/i386/unwinder_i386.cpp
@@ -67,7 +67,6 @@ OOPStackUnwinderX86::VirtualUnwind(
     __deref_opt_out_opt PEXCEPTION_ROUTINE *HandlerRoutine
     )
 {
-    *EstablisherFrame = ContextRecord->Esp;
     if (HandlerRoutine != NULL)
     {
         *HandlerRoutine = NULL;
@@ -75,26 +74,14 @@ OOPStackUnwinderX86::VirtualUnwind(
 
     REGDISPLAY rd;
 
-    if (ContextPointers != NULL)
-    {
-#define CALLEE_SAVED_REGISTER(reg) rd.p##reg = ContextPointers->reg;
-        ENUM_CALLEE_SAVED_REGISTERS();
-#undef CALLEE_SAVED_REGISTER
-    }
-    else
-    {
-#define CALLEE_SAVED_REGISTER(reg) rd.p##reg = NULL;
-        ENUM_CALLEE_SAVED_REGISTERS();
-#undef CALLEE_SAVED_REGISTER
-    }
+    FillRegDisplay(&rd, ContextRecord);
 
-    if (rd.pEbp == NULL)
+    rd.PCTAddr = (UINT_PTR)&(ContextRecord->Eip);
+
+    if (ContextPointers)
     {
-        rd.pEbp = &(ContextRecord->Ebp);
+        rd.pCurrentContextPointers = ContextPointers;
     }
-    rd.SP = ContextRecord->Esp;
-    rd.ControlPC = (PCODE)(ContextRecord->Eip);
-    rd.PCTAddr = (UINT_PTR)&(ContextRecord->Eip);
 
     CodeManState codeManState;
     codeManState.dwIsSet = 0;
@@ -107,23 +94,23 @@ OOPStackUnwinderX86::VirtualUnwind(
         return HRESULT_FROM_WIN32(ERROR_READ_FAULT);
     }
 
-#define CALLEE_SAVED_REGISTER(reg) if (rd.p##reg != NULL) { ContextRecord->reg = *rd.p##reg; }
+    ContextRecord->ContextFlags |= CONTEXT_UNWOUND_TO_CALL;
+
+#define ARGUMENT_AND_SCRATCH_REGISTER(reg) if (rd.pCurrentContextPointers->reg) ContextRecord->reg = *rd.pCurrentContextPointers->reg;
+    ENUM_ARGUMENT_AND_SCRATCH_REGISTERS();
+#undef ARGUMENT_AND_SCRATCH_REGISTER
+
+#define CALLEE_SAVED_REGISTER(reg) if (rd.pCurrentContextPointers->reg) ContextRecord->reg = *rd.pCurrentContextPointers->reg;
     ENUM_CALLEE_SAVED_REGISTERS();
 #undef CALLEE_SAVED_REGISTER
-    
-    if (ContextPointers != NULL) 
-    {
-#define CALLEE_SAVED_REGISTER(reg) if (rd.p##reg != &(ContextRecord->reg)) { ContextPointers->reg = rd.p##reg; }
-        ENUM_CALLEE_SAVED_REGISTERS();
-#undef CALLEE_SAVED_REGISTER
-    }
-
-    ContextRecord->ContextFlags |= CONTEXT_UNWOUND_TO_CALL;
 
     ContextRecord->Esp = rd.SP;
     ContextRecord->Eip = rd.ControlPC;
-    ContextRecord->Ebp = *rd.pEbp;
 
+    // For x86, the value of Establisher Frame Pointer is Caller SP
+    //
+    // (Please refers to CLR ABI for details)
+    *EstablisherFrame = ContextRecord->Esp;
     return S_OK;
 }
 
diff --git a/src/utilcode/appxutil.cpp b/src/utilcode/appxutil.cpp
index 759fbffcb1..5d095a4873 100644
--- a/src/utilcode/appxutil.cpp
+++ b/src/utilcode/appxutil.cpp
@@ -19,7 +19,6 @@
 
 #include "shlwapi.h"    // Path manipulation APIs
 
-#ifdef FEATURE_CORECLR
 
 GVAL_IMPL(bool, g_fAppX);
 INDEBUG(bool g_fIsAppXAsked;)
@@ -49,822 +48,3 @@ namespace AppX
 #endif
 };
 
-#else // FEATURE_CORECLR
-
-//---------------------------------------------------------------------------------------------
-// Convenience values
-
-#ifndef E_INSUFFICIENT_BUFFER
-    #define E_INSUFFICIENT_BUFFER (HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER))
-#endif
-
-#ifndef E_FILE_NOT_FOUND
-    #define E_FILE_NOT_FOUND (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
-#endif
-
-//---------------------------------------------------------------------------------------------
-using clr::str::IsNullOrEmpty;
-
-//---------------------------------------------------------------------------------------------
-typedef decltype(GetCurrentPackageId)   GetCurrentPackageId_t;
-typedef decltype(GetCurrentPackageInfo) GetCurrentPackageInfo_t;
-typedef decltype(GetCurrentPackagePath) GetCurrentPackagePath_t;
-typedef decltype(OpenPackageInfoByFullName) OpenPackageInfoByFullName_t;
-typedef decltype(ClosePackageInfo)          ClosePackageInfo_t;
-typedef decltype(GetPackageInfo)            GetPackageInfo_t;
-
-//---------------------------------------------------------------------------------------------
-// Caches AppX ARI API-related information.
-struct AppXRTInfo
-{
-    HMODULE                     m_hAppXRTMod;
-    bool                        m_fIsAppXProcess;
-    bool                        m_fIsAppXAdaptiveApp;
-    bool                        m_fIsAppXNGen;
-
-    GetCurrentPackageId_t *     m_pfnGetCurrentPackageId;
-    GetCurrentPackageInfo_t *   m_pfnGetCurrentPackageInfo;
-    GetCurrentPackagePath_t *   m_pfnGetCurrentPackagePath;
-
-    NewArrayHolder<BYTE>        m_pbAppContainerInfo;
-    DWORD                       m_cbAppContainerInfo;
-
-    struct CurrentPackageInfo
-    {
-        UINT32        m_cbCurrentPackageInfo;
-        PBYTE         m_pbCurrentPackageInfo;
-        UINT32        m_nCount;
-
-        CurrentPackageInfo(UINT32 cbPkgInfo, PBYTE pbPkgInfo, UINT32 nCount)
-            : m_cbCurrentPackageInfo(cbPkgInfo)
-            , m_pbCurrentPackageInfo(pbPkgInfo)
-            , m_nCount(nCount)
-        { LIMITED_METHOD_CONTRACT; }
-
-        ~CurrentPackageInfo()
-        {
-            LIMITED_METHOD_CONTRACT;
-            if (m_pbCurrentPackageInfo != nullptr)
-            {
-                delete [] m_pbCurrentPackageInfo;
-                m_pbCurrentPackageInfo = nullptr;
-            }
-        }
-    };
-
-    CurrentPackageInfo *        m_pCurrentPackageInfo;
-
-    NewArrayHolder<WCHAR>       m_AdaptiveAppWinmetadataDir;
-
-    AppXRTInfo() :
-        m_hAppXRTMod(nullptr),
-        m_fIsAppXProcess(false),
-        m_fIsAppXAdaptiveApp(false),
-        m_fIsAppXNGen(false),
-        m_pfnGetCurrentPackageId(nullptr),
-        m_pfnGetCurrentPackageInfo(nullptr),
-        m_pfnGetCurrentPackagePath(nullptr),
-        m_pbAppContainerInfo(nullptr),
-        m_pCurrentPackageInfo(nullptr),
-        m_AdaptiveAppWinmetadataDir(nullptr)
-    { LIMITED_METHOD_CONTRACT; }
-
-    ~AppXRTInfo()
-    {
-        LIMITED_METHOD_CONTRACT;
-        if (m_pCurrentPackageInfo != nullptr)
-        {
-            delete m_pCurrentPackageInfo;
-            m_pCurrentPackageInfo = nullptr;
-        }
-
-        if (m_hAppXRTMod != nullptr)
-        {
-            FreeLibrary(m_hAppXRTMod);
-            m_hAppXRTMod = nullptr;
-        }
-    }
-};  // struct AppXRTInfo
-
-GPTR_IMPL(AppXRTInfo, g_pAppXRTInfo); // Relies on zero init static memory.
-
-#ifndef DACCESS_COMPILE
-
-//---------------------------------------------------------------------------------------------
-static
-HRESULT GetAppContainerTokenInfoForProcess(
-    DWORD pid,
-    NewArrayHolder<BYTE>& pbAppContainerTokenInfo,
-    DWORD* pcbAppContainerTokenInfo)
-{
-    PRECONDITION(CheckPointer(pcbAppContainerTokenInfo, NULL_OK));
-
-    HRESULT hr = S_OK;
-
-    pbAppContainerTokenInfo = nullptr;
-
-    // In order to get the AppContainer SID we need to open the process token
-    HandleHolder hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid);
-    if (hProcess == NULL)
-        return HRESULT_FROM_GetLastError();
-
-    HandleHolder hToken;
-    if (!OpenProcessToken(hProcess, TOKEN_QUERY, &hToken))
-        return HRESULT_FROM_GetLastError();
-
-    // Query the process to see if it's inside an AppContainer
-    ULONG isAppContainer = 0;
-    DWORD actualLength = 0;
-    if (!GetTokenInformation(hToken, static_cast<TOKEN_INFORMATION_CLASS>(TokenIsAppContainer), &isAppContainer, sizeof(isAppContainer), &actualLength))
-        return HRESULT_FROM_GetLastError();
-
-    _ASSERTE(actualLength > 0);
-
-    // Not an AppContainer so bail
-    if (!isAppContainer)
-    {
-        return S_FALSE;
-    }
-
-    // Now we need the AppContainer SID so first get the required buffer length
-    actualLength = 0;
-    VERIFY(!GetTokenInformation(hToken, static_cast<TOKEN_INFORMATION_CLASS>(TokenAppContainerSid), NULL, 0, &actualLength));
-    hr = HRESULT_FROM_GetLastError();
-    _ASSERTE(hr == E_INSUFFICIENT_BUFFER);
-
-    // Something unexpected happened
-    if (hr != E_INSUFFICIENT_BUFFER)
-        return hr;
-
-    // Now we know the length of the AppContainer SID so create a buffer and retrieve it
-    pbAppContainerTokenInfo = new (nothrow) BYTE[actualLength];
-    IfNullRet(pbAppContainerTokenInfo);
-
-    if (!GetTokenInformation(hToken, static_cast<TOKEN_INFORMATION_CLASS>(TokenAppContainerSid), pbAppContainerTokenInfo.GetValue(), actualLength, &actualLength))
-        return HRESULT_FROM_GetLastError();
-
-    if (pcbAppContainerTokenInfo != nullptr)
-        *pcbAppContainerTokenInfo = actualLength;
-
-    return S_OK;
-}
-
-//---------------------------------------------------------------------------------------------
-// Initializes a global AppXRTInfo structure if it has not already been initialized. Returns
-// false only in the event of OOM; otherwise caches the result of ARI information in
-// g_pAppXRTInfo. Thread safe.
-static
-HRESULT InitAppXRT()
-{
-    // This will be used for catastrophic errors.
-    HRESULT hr = S_OK;
-
-    if (VolatileLoad(&g_pAppXRTInfo) == nullptr)
-    {
-        NewHolder<AppXRTInfo> pAppXRTInfo = new (nothrow) AppXRTInfo();
-        IfNullRet(pAppXRTInfo); // Catastrophic error.
-
-        pAppXRTInfo->m_fIsAppXProcess = false;
-
-        do
-        {
-            if (!RunningOnWin8())
-            {
-                break;
-            }
-
-            LPCWSTR wzAppXRTDll = W("api-ms-win-appmodel-runtime-l1-1-0.dll");
-            // Does not use GetLoadWithAlteredSearchPathFlag() because that would cause infinite recursion.
-            pAppXRTInfo->m_hAppXRTMod = WszLoadLibraryEx(wzAppXRTDll, nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
-            if (pAppXRTInfo->m_hAppXRTMod == nullptr)
-            {   // Error is catastrophic: can't find kernel32.dll?
-                hr = HRESULT_FROM_GetLastError();
-                break;
-            }
-
-            pAppXRTInfo->m_pfnGetCurrentPackageId = reinterpret_cast<GetCurrentPackageId_t *>(
-                GetProcAddress(pAppXRTInfo->m_hAppXRTMod, "GetCurrentPackageId"));
-            if (pAppXRTInfo->m_pfnGetCurrentPackageId == nullptr)
-            {   // Error is non-catastrophic: could be running downlevel
-                break;
-            }
-
-            pAppXRTInfo->m_pfnGetCurrentPackageInfo = reinterpret_cast<GetCurrentPackageInfo_t *>(
-                GetProcAddress(pAppXRTInfo->m_hAppXRTMod, "GetCurrentPackageInfo"));
-            if (pAppXRTInfo->m_pfnGetCurrentPackageInfo == nullptr)
-            {   // Error is catastrophic: GetCurrentPackageId is available but not GetCurrentPackageInfo?
-                hr = HRESULT_FROM_GetLastError();
-                break;
-            }
-
-            pAppXRTInfo->m_pfnGetCurrentPackagePath = reinterpret_cast<GetCurrentPackagePath_t *>(
-                GetProcAddress(pAppXRTInfo->m_hAppXRTMod, "GetCurrentPackagePath"));
-            if (pAppXRTInfo->m_pfnGetCurrentPackagePath == nullptr)
-            {   // Error is catastrophic: GetCurrentPackageInfo is available but not GetCurrentPackagePath?
-                hr = HRESULT_FROM_GetLastError();
-                break;
-            }
-
-            // Determine if this is an AppX process
-            UINT32 cbBuffer = 0;
-            LONG lRes = (*pAppXRTInfo->m_pfnGetCurrentPackageId)(&cbBuffer, nullptr);
-            pAppXRTInfo->m_fIsAppXProcess = (lRes == ERROR_INSUFFICIENT_BUFFER);
-
-            _ASSERTE(AppX::IsAppXSupported());
-
-            hr = GetAppContainerTokenInfoForProcess(
-                            GetCurrentProcessId(),
-                            pAppXRTInfo->m_pbAppContainerInfo,
-                            &pAppXRTInfo->m_cbAppContainerInfo);
-
-            if (FAILED(hr))
-            {
-                if (pAppXRTInfo->m_fIsAppXProcess)
-                {   // Error is catastrophic: running in true immersive process but no token info?
-                }
-                else
-                {   // Error is non-catastrophic: reset HRESULT to S_OK.
-                    hr = S_OK;
-                }
-                break;
-            }
-        }
-        while (false);
-
-        if (InterlockedCompareExchangeT<AppXRTInfo>(&g_pAppXRTInfo, pAppXRTInfo, nullptr) == nullptr)
-        {
-            pAppXRTInfo.SuppressRelease();
-        }
-    }
-
-    return hr;
-}
-
-//---------------------------------------------------------------------------------------------
-// Inline helper to check first an only init when required.
-static inline HRESULT CheckInitAppXRT()
-{
-    return (VolatileLoad(&g_pAppXRTInfo) != nullptr) ? S_OK : InitAppXRT();
-}
-
-#endif // !DACCESS_COMPILE
-
-//---------------------------------------------------------------------------------------------
-// Contains general helper methods for interacting with AppX functionality. This code will
-// gracefully fail on downlevel OS by returning false from AppX::IsAppXProcess, so always
-// call this API first to check before calling any of the others defined in this namespace.
-//
-// See http://windows/windows8/docs/Windows%208%20Feature%20Documents/Developer%20Experience%20(DEVX)/Apps%20Experience%20(APPX)/Modern%20Client/App%20Runtime%20Improvements%20API%20Developer%20Platform%20Spec.docm
-// for more information.
-
-namespace AppX
-{
-#ifdef DACCESS_COMPILE
-
-    //-----------------------------------------------------------------------------------------
-    // DAC-only IsAppXProcess. Returns false if g_pAppXRTInfo has not been initialized.
-    bool DacIsAppXProcess()
-    {
-        LIMITED_METHOD_DAC_CONTRACT;
-        return (g_pAppXRTInfo != nullptr && g_pAppXRTInfo->m_fIsAppXProcess);
-    }
-
-#else // DACCESS_COMPILE
-
-    //---------------------------------------------------------------------------------------------
-    // cleans up resources allocated in InitAppXRT()
-    void ShutDown()
-    {
-        if (VolatileLoad(&g_pAppXRTInfo) != nullptr)
-        {
-            delete g_pAppXRTInfo;
-            g_pAppXRTInfo = nullptr;
-        }
-    }
-
-    //-----------------------------------------------------------------------------------------
-    // Returns true if the current process is immersive.
-    // NOTE: a return value of true doesn't necessarily indicate that the process is a
-    //       real Metro app, e.g. it could be an ngen process compiling an AppX assembly.
-    bool IsAppXProcess()
-    {
-        LIMITED_METHOD_CONTRACT;
-        HRESULT hr = S_OK;
-
-        if (FAILED(hr = CheckInitAppXRT()))
-        {
-            SetLastError(hr); // HRESULT_FROM_WIN32 is idempotent when error value is HRESULT.
-            return false;
-        }
-
-        return g_pAppXRTInfo->m_fIsAppXProcess;
-    }
-
-    //-----------------------------------------------------------------------------------------
-    // Returns true if the current process is immersive.
-    // Only produces reliable results after IsAppXProcess is inititalized
-    bool IsAppXProcess_Initialized_NoFault()
-    {
-        LIMITED_METHOD_CONTRACT;
-        if (VolatileLoad(&g_pAppXRTInfo) == nullptr)
-        {
-            return false;
-        }
-        return g_pAppXRTInfo->m_fIsAppXProcess;
-    }
-
-    bool IsAppXNGen()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return VolatileLoad(&g_pAppXRTInfo) != nullptr && g_pAppXRTInfo->m_fIsAppXNGen;
-    }
-
-    //-----------------------------------------------------------------------------------------
-    HRESULT InitCurrentPackageInfoCache()
-    {
-        LIMITED_METHOD_CONTRACT;
-        HRESULT hr = S_OK;
-
-        UINT32 cbBuffer = 0;
-        hr = HRESULT_FROM_WIN32((*g_pAppXRTInfo->m_pfnGetCurrentPackageInfo)(PACKAGE_FILTER_CLR_DEFAULT, &cbBuffer, nullptr, nullptr));
-        if (hr != E_INSUFFICIENT_BUFFER)
-            return hr;
-
-        NewArrayHolder<BYTE> pbBuffer(new (nothrow) BYTE[cbBuffer]);
-        IfNullRet(pbBuffer);
-
-        UINT32 nCount = 0;
-        IfFailRet(HRESULT_FROM_WIN32((*g_pAppXRTInfo->m_pfnGetCurrentPackageInfo)(PACKAGE_FILTER_CLR_DEFAULT, &cbBuffer, pbBuffer, &nCount)));
-
-        NewHolder<AppXRTInfo::CurrentPackageInfo> pPkgInfo(
-            new (nothrow) AppXRTInfo::CurrentPackageInfo(cbBuffer, pbBuffer.Extract(), nCount));
-        IfNullRet(pPkgInfo);
-
-        if (InterlockedCompareExchangeT<AppXRTInfo::CurrentPackageInfo>(
-                &g_pAppXRTInfo->m_pCurrentPackageInfo, pPkgInfo, nullptr) == nullptr)
-        {
-            pPkgInfo.SuppressRelease();
-        }
-
-        return S_OK;
-    }
-
-    //-----------------------------------------------------------------------------------------
-    FORCEINLINE HRESULT CheckInitCurrentPackageInfoCache()
-    {
-        WRAPPER_NO_CONTRACT;
-        PRECONDITION(IsAppXProcess());
-
-        if (!IsAppXProcess())
-            return E_UNEXPECTED;
-
-        if (g_pAppXRTInfo->m_pCurrentPackageInfo == nullptr)
-            return InitCurrentPackageInfoCache();
-        else
-            return S_OK;
-    }
-
-    //-----------------------------------------------------------------------------------------
-    LPCWSTR GetHeadPackageMoniker()
-    {
-        STANDARD_VM_CONTRACT;
-
-        IfFailThrow(CheckInitCurrentPackageInfoCache());
-        return reinterpret_cast<PPACKAGE_INFO>(
-            g_pAppXRTInfo->m_pCurrentPackageInfo->m_pbCurrentPackageInfo)->packageFullName;
-    }
-
-    //-----------------------------------------------------------------------------------------
-    // Returns the current process' PACKAGE_ID in the provided buffer. See the ARI spec (above)
-    // for more information.
-    HRESULT GetCurrentPackageId(
-        PUINT32 pBufferLength,
-        PBYTE pBuffer)
-    {
-        LIMITED_METHOD_CONTRACT;
-        HRESULT hr = S_OK;
-
-        IfFailRet(CheckInitAppXRT());
-        IfFailRet(HRESULT_FROM_WIN32((*g_pAppXRTInfo->m_pfnGetCurrentPackageId)(pBufferLength, pBuffer)));
-
-        return S_OK;
-    }
-
-    //-----------------------------------------------------------------------------------------
-    // Returns the current process' PACKAGE_INFO in the provided buffer. See the ARI spec
-    // (above) for more information.
-    HRESULT GetCurrentPackageInfo(
-        UINT32 uiFlags,
-        PUINT32 pcbBuffer,
-        PBYTE pbBuffer,
-        PUINT32 pnCount)
-    {
-        LIMITED_METHOD_CONTRACT;
-        PRECONDITION(IsAppXProcess());
-        PRECONDITION(CheckPointer(pcbBuffer));
-
-        HRESULT hr = S_OK;
-
-        IfFailRet(CheckInitAppXRT());
-
-        if (pcbBuffer == nullptr)
-            return E_INVALIDARG;
-
-        if (uiFlags == PACKAGE_FILTER_CLR_DEFAULT)
-        {
-            IfFailRet(CheckInitCurrentPackageInfoCache());
-
-            DWORD cbBuffer = *pcbBuffer;
-            *pcbBuffer = g_pAppXRTInfo->m_pCurrentPackageInfo->m_cbCurrentPackageInfo;
-            if (pnCount != nullptr)
-            {
-                *pnCount = g_pAppXRTInfo->m_pCurrentPackageInfo->m_nCount;
-            }
-
-            if (pbBuffer == nullptr || cbBuffer < g_pAppXRTInfo->m_pCurrentPackageInfo->m_cbCurrentPackageInfo)
-            {
-                return E_INSUFFICIENT_BUFFER;
-            }
-            memcpy(pbBuffer, g_pAppXRTInfo->m_pCurrentPackageInfo->m_pbCurrentPackageInfo, g_pAppXRTInfo->m_pCurrentPackageInfo->m_cbCurrentPackageInfo);
-        }
-        else
-        {
-            IfFailRet(HRESULT_FROM_WIN32((*g_pAppXRTInfo->m_pfnGetCurrentPackageInfo)(uiFlags, pcbBuffer, pbBuffer, pnCount)));
-        }
-
-        return S_OK;
-    }
-
-    //-----------------------------------------------------------------------------------------
-    bool IsAdaptiveApp()
-    {
-         LIMITED_METHOD_CONTRACT;
-        
-         HRESULT hr = S_OK;
-         static bool cachedIsAdaptiveApp = false;
-   
-         if (!IsAppXProcess())
-         {
-             return false;
-         }
-
-         if (!cachedIsAdaptiveApp)
-         {
-             cachedIsAdaptiveApp = true;
-             LPWSTR adaptiveAppWinmetaDataDir = NULL;
-   
-             if (SUCCEEDED(hr = AppX::GetWinMetadataDirForAdaptiveApps(&adaptiveAppWinmetaDataDir)))
-             {
-                 g_pAppXRTInfo->m_fIsAppXAdaptiveApp = clr::fs::Dir::Exists(adaptiveAppWinmetaDataDir);
-                            
-             }
-             else
-             {
-                 SetLastError(hr); 
-                 g_pAppXRTInfo->m_fIsAppXAdaptiveApp = false;
-             }
-                    
-         }
-
-         return g_pAppXRTInfo->m_fIsAppXAdaptiveApp;
-    }
-    
-   
-    //-----------------------------------------------------------------------------------------
-    // length       : Upon success, contains the  the length of packagePath
-    // [in/out]       
-    //
-    // packageRoot  : Upon success, contains the  full packagePath 
-    // [out]          [ Note: The memory has to be preallocated for the above length]
-    //
-    HRESULT GetCurrentPackagePath(_Inout_ UINT32* length, _Out_opt_ PWSTR packageRoot)
-    {
-            PRECONDITION(IsAppXProcess());
-            PRECONDITION(CheckPointer(length));
-
-            HRESULT hr;
-            IfFailRet(CheckInitAppXRT());
-           
-            IfFailRet(HRESULT_FROM_WIN32((*g_pAppXRTInfo->m_pfnGetCurrentPackagePath)(length, packageRoot)));
-            return S_OK;
-    }
-
-    //-----------------------------------------------------------------------------------------
-    // winMetadDataDir        : Upon success, contains the absolute path for the winmetadata directory for the adaptive app
-    // [out]                    NOTE: The string the pointer points to is global memory and never should be modified
-    //
-    HRESULT GetWinMetadataDirForAdaptiveApps(_Out_ LPWSTR* winMetadDataDir)
-    {
-
-            PRECONDITION(IsAppXProcess());
-            
-            HRESULT hr;
-
-            IfFailRet(CheckInitAppXRT());
-
-            if (g_pAppXRTInfo->m_AdaptiveAppWinmetadataDir == nullptr)
-            {
-                LPCWSTR wzWinMetadataFolder=W("\\WinMetadata");
-                NewArrayHolder<WCHAR> wzCompletePath;
-                UINT32 length=0;
-
-                hr = GetCurrentPackagePath(&length, NULL);
-                if (hr != HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER))
-                    return hr;
-
-                NewArrayHolder<WCHAR> wzPath_holder = new (nothrow) WCHAR[length];  
-
-                IfNullRet(wzPath_holder);
-                IfFailRet(GetCurrentPackagePath(&length, wzPath_holder.GetValue()));
-
-                DWORD cchFullPathBuf = length + (DWORD)wcslen(wzWinMetadataFolder) + 1;
-                IfNullRet(wzCompletePath = new (nothrow) WCHAR[cchFullPathBuf]);
-                IfFailRet(clr::fs::Path::Combine(wzPath_holder.GetValue(), wzWinMetadataFolder, &cchFullPathBuf, wzCompletePath.GetValue()));
-                g_pAppXRTInfo->m_AdaptiveAppWinmetadataDir = wzCompletePath.Extract();
-            }
-
-            *winMetadDataDir = g_pAppXRTInfo->m_AdaptiveAppWinmetadataDir; 
-
-            return S_OK;
-    }
-
-#if defined(FEATURE_APPX_BINDER)
-    //-----------------------------------------------------------------------------------------
-    // Iterates the current process' packages and returns the first package that contains a
-    // file matching wzFileName.
-    //
-    // wzFileName   :  The file to look for in the current process' packages. If this is a
-    // [in]           relative path, then it appends the path to the root of each package in
-    //                sequence to see if the resulting path points to an existing file. If this
-    //                is an absolute path, then for each package it determines if the package
-    //                root is a prefix of wzFileName.
-    // pcchPathName : Upon entry contains the length of the buffer pwzPathName, and upon return
-    // [in/out]       contains either the number of characters written or the buffer size
-    //                required.
-    // pwzPathName  : Upon success, contains the absolute path for the first matching file.
-    // [out]
-    HRESULT FindFileInCurrentPackage(
-        PCWSTR wzFileName,
-        PUINT32 pcchPathName,
-        PWSTR pwzPathName,
-        UINT32 uiFlags,
-        __in PCWSTR *rgwzAltPaths,
-        __in UINT32 cAltPaths,
-        FindFindInPackageFlags findInCurrentPackageFlags)
-    {
-        LIMITED_METHOD_CONTRACT;
-        PRECONDITION(IsAppXProcess());
-        PRECONDITION(CheckPointer(wzFileName));
-        PRECONDITION(CheckPointer(pcchPathName));
-        PRECONDITION(CheckPointer(pwzPathName));
-
-        HRESULT hr = S_OK;
-
-        if (!IsAppXProcess())
-            return E_UNEXPECTED;
-
-        // PACKAGE_FILTER_ALL_LOADED is obsolete, and shouldn't be used.
-        // We also don't currently handle the case where PACKAGE_FILTER_HEAD isn't set.
-        _ASSERTE(uiFlags != PACKAGE_FILTER_ALL_LOADED && (uiFlags & PACKAGE_FILTER_HEAD) != 0);
-        if (uiFlags == PACKAGE_FILTER_ALL_LOADED || (uiFlags & PACKAGE_FILTER_HEAD) == 0)
-            return E_NOTIMPL;
-
-        // File name must be non-null and relative
-        if (IsNullOrEmpty(wzFileName) || pcchPathName == nullptr || pwzPathName == nullptr)
-            return E_INVALIDARG;
-
-        // If we've been provided a full path and the file doesn't actually exist
-        // then we can immediately say that this function will fail with "file not found".
-        bool fIsRelative = clr::fs::Path::IsRelative(wzFileName);
-        if (!fIsRelative && !clr::fs::File::Exists(wzFileName))
-            return E_FILE_NOT_FOUND;
-
-        IfFailRet(CheckInitCurrentPackageInfoCache());
-
-        DWORD const           cchFileName    = static_cast<DWORD>(wcslen(wzFileName));
-        DWORD                 cchFullPathBuf = _MAX_PATH;
-        NewArrayHolder<WCHAR> wzFullPathBuf  = new (nothrow) WCHAR[cchFullPathBuf];
-        IfNullRet(wzFullPathBuf);
-
-        auto FindFileInCurrentPackageHelper = [&](LPCWSTR wzPath) -> HRESULT
-        {
-            HRESULT hr = S_OK;
-
-            if (!(findInCurrentPackageFlags & FindFindInPackageFlags_AllowLongFormatPath) && clr::fs::Path::HasLongFormatPrefix(wzPath))
-                return COR_E_BAD_PATHNAME; // We can't handle long format paths.
-
-            // If the path is relative, concatenate the package root and the file name and see
-            // if the file exists.
-            if (fIsRelative)
-            {
-                DWORD cchFullPath = cchFullPathBuf;
-                hr = clr::fs::Path::Combine(wzPath, wzFileName, &cchFullPath, wzFullPathBuf);
-                if (hr == E_INSUFFICIENT_BUFFER)
-                {
-                    IfNullRet(wzFullPathBuf = new (nothrow) WCHAR[cchFullPathBuf = (cchFullPath + 1)]);
-                    hr = clr::fs::Path::Combine(wzPath, wzFileName, &cchFullPath, wzFullPathBuf);
-                }
-                IfFailRet(hr);
-
-                if (!clr::fs::Path::IsValid(wzFullPathBuf, cchFullPath, !!(findInCurrentPackageFlags & FindFindInPackageFlags_AllowLongFormatPath)))
-                    return COR_E_BAD_PATHNAME;
-
-                if (clr::fs::File::Exists(wzFullPathBuf))
-                {
-                    DWORD cchPathName = *pcchPathName;
-                    *pcchPathName = cchFullPath;
-                    return StringCchCopy(pwzPathName, cchPathName, wzFullPathBuf);
-                }
-            }
-            // If the path is absolute, see if the file name contains the pacakge root as a prefix
-            // and if the file exists.
-            else
-            {
-                DWORD cchPath = static_cast<DWORD>(wcslen(wzPath));
-
-                // Determine if wzPath is a path prefix of wzFileName
-                if (cchPath < cchFileName &&
-                    _wcsnicmp(wzPath, wzFileName, cchPath) == 0 &&
-                    (wzFileName[cchPath] == W('\\') || wzPath[cchPath-1] == W('\\'))) // Ensure wzPath is not just a prefix, but a path prefix
-                {
-                    if (clr::fs::File::Exists(wzFileName))
-                    {
-                        DWORD cchPathName = *pcchPathName;
-                        *pcchPathName = cchFileName;
-                        return StringCchCopy(pwzPathName, cchPathName, wzFileName);
-                    }
-                }    
-            }
-
-            return S_FALSE;
-        }; // FindFileInCurrentPackageHelper
-
-        if (!(findInCurrentPackageFlags & FindFindInPackageFlags_SkipCurrentPackageGraph))
-        {
-            PCPACKAGE_INFO pCurNode = reinterpret_cast<PPACKAGE_INFO>(
-                g_pAppXRTInfo->m_pCurrentPackageInfo->m_pbCurrentPackageInfo);
-            PCPACKAGE_INFO pEndNode = pCurNode + g_pAppXRTInfo->m_pCurrentPackageInfo->m_nCount;
-            for (; pCurNode != pEndNode; ++pCurNode)
-            {
-                IfFailRet(FindFileInCurrentPackageHelper(pCurNode->path));
-
-                if (hr == S_OK)
-                {
-                    return hr;
-                }
-
-                // End search if dependent packages should not be checked.
-                if ((uiFlags & PACKAGE_FILTER_DIRECT) == 0)
-                {
-                    break;
-                }
-            }
-        }
-
-        // Process alternative paths
-        for (UINT iAltPath = 0; iAltPath < cAltPaths; iAltPath++)
-        {
-            IfFailRet(FindFileInCurrentPackageHelper(rgwzAltPaths[iAltPath]));
-
-            if (hr == S_OK)
-            {
-                return hr;
-            }
-        }
-
-        return E_FILE_NOT_FOUND;
-    }
-#endif // FEATURE_APPX_BINDER
-
-    //-----------------------------------------------------------------------------------------
-    HRESULT GetAppContainerTokenInfoForProcess(
-        DWORD dwPid,
-        NewArrayHolder<BYTE>& pbAppContainerTokenInfo,
-        DWORD* pcbAppContainerTokenInfo)
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        HRESULT hr = S_OK;
-
-        pbAppContainerTokenInfo = nullptr;
-
-        if (!IsAppXSupported())
-        {
-            return S_FALSE;
-        }
-
-        if (dwPid == GetCurrentProcessId())
-        {
-            if (FAILED(hr = CheckInitAppXRT()))
-            {
-                SetLastError(hr);
-                return S_FALSE;
-            }
-            
-            if (g_pAppXRTInfo->m_pbAppContainerInfo == nullptr)
-            {
-                return S_FALSE;
-            }
-            else
-            {
-                pbAppContainerTokenInfo = g_pAppXRTInfo->m_pbAppContainerInfo.GetValue();
-                pbAppContainerTokenInfo.SuppressRelease(); // Caller does not need to free mem.
-                if (pcbAppContainerTokenInfo != nullptr)
-                {
-                    *pcbAppContainerTokenInfo = g_pAppXRTInfo->m_cbAppContainerInfo;
-                }
-                return S_OK;
-            }
-        }
-        else
-        {
-            return ::GetAppContainerTokenInfoForProcess(dwPid, pbAppContainerTokenInfo, pcbAppContainerTokenInfo);
-        }
-    }
-
-    // Called during NGen to pretend that we're in a certain package.  Due to Windows restriction, we can't
-    // start NGen worker processes in the right package environment (only in the right AppContainer).  So
-    // NGen calls this function with a package name, to indicate that all AppX-related code should behave as
-    // if the current process is running in that package.
-    HRESULT SetCurrentPackageForNGen(__in PCWSTR pszPackageFullName)
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        HRESULT hr = S_OK;
-
-        IfFailRet(CheckInitAppXRT());
-
-        _ASSERTE(IsAppXSupported());
-        _ASSERTE(g_pAppXRTInfo->m_hAppXRTMod != nullptr);
-
-        HMODULE hAppXRTMod = g_pAppXRTInfo->m_hAppXRTMod;
-        OpenPackageInfoByFullName_t *pfnOpenPackageInfoByFullName
-            = reinterpret_cast<OpenPackageInfoByFullName_t*>(GetProcAddress(hAppXRTMod, "OpenPackageInfoByFullName"));
-        _ASSERTE(pfnOpenPackageInfoByFullName != nullptr);
-        if (pfnOpenPackageInfoByFullName == nullptr)
-            return HRESULT_FROM_GetLastError();
-
-        ClosePackageInfo_t *pfnClosePackageInfo
-            = reinterpret_cast<ClosePackageInfo_t*>(GetProcAddress(hAppXRTMod, "ClosePackageInfo"));
-        _ASSERTE(pfnClosePackageInfo != nullptr);
-        if (pfnClosePackageInfo == nullptr)
-            return HRESULT_FROM_GetLastError();
-
-        GetPackageInfo_t *pfnGetPackageInfo
-            = reinterpret_cast<GetPackageInfo_t*>(GetProcAddress(hAppXRTMod, "GetPackageInfo"));
-        _ASSERTE(pfnGetPackageInfo != nullptr);
-        if (pfnGetPackageInfo == nullptr)
-            return HRESULT_FROM_GetLastError();
-
-        PACKAGE_INFO_REFERENCE packageInfoReference;
-        hr = HRESULT_FROM_WIN32(pfnOpenPackageInfoByFullName(pszPackageFullName, 0, &packageInfoReference));
-        if (FAILED(hr))
-            return hr;
-
-        // Automatically close packageInfoReference before we return.
-        class PackageInfoReferenceHolder
-        {
-        public:
-            PackageInfoReferenceHolder(ClosePackageInfo_t *pfnClosePackageInfo, PACKAGE_INFO_REFERENCE &packageInfoReference)
-                :m_pfnClosePackageInfo(pfnClosePackageInfo),
-                 m_packageInfoReference(packageInfoReference)
-            {
-            }
-            ~PackageInfoReferenceHolder() { m_pfnClosePackageInfo(m_packageInfoReference); }
-        private:
-            ClosePackageInfo_t *m_pfnClosePackageInfo;
-            PACKAGE_INFO_REFERENCE &m_packageInfoReference;
-        } pirh(pfnClosePackageInfo, packageInfoReference);
-
-        UINT32 cbBuffer = 0;
-        hr = HRESULT_FROM_WIN32(pfnGetPackageInfo(packageInfoReference, PACKAGE_FILTER_CLR_DEFAULT, &cbBuffer, nullptr, nullptr));
-        if (hr != E_INSUFFICIENT_BUFFER)
-            return hr;
-
-        NewArrayHolder<BYTE> pbBuffer(new (nothrow) BYTE[cbBuffer]);
-        IfNullRet(pbBuffer);
-
-        UINT32 nCount = 0;
-        IfFailRet(HRESULT_FROM_WIN32(pfnGetPackageInfo(packageInfoReference, PACKAGE_FILTER_CLR_DEFAULT, &cbBuffer, pbBuffer, &nCount)));
-
-        NewHolder<AppXRTInfo::CurrentPackageInfo> pPkgInfo(
-            new (nothrow) AppXRTInfo::CurrentPackageInfo(cbBuffer, pbBuffer.Extract(), nCount));
-        IfNullRet(pPkgInfo);
-
-        if (InterlockedCompareExchangeT<AppXRTInfo::CurrentPackageInfo>(
-                &g_pAppXRTInfo->m_pCurrentPackageInfo, pPkgInfo, nullptr) == nullptr)
-        {
-            pPkgInfo.SuppressRelease();
-        }
-
-        g_pAppXRTInfo->m_fIsAppXProcess = true;
-        g_pAppXRTInfo->m_fIsAppXNGen = true;
-
-        return hr;
-    }
-
-#endif // DACCESS_COMPILE
-} // namespace AppX
-
-
-#endif // FEATURE_CORECLR
diff --git a/src/utilcode/ccomprc.cpp b/src/utilcode/ccomprc.cpp
index a4c79fc127..ed902dc6ca 100644
--- a/src/utilcode/ccomprc.cpp
+++ b/src/utilcode/ccomprc.cpp
@@ -261,12 +261,8 @@ HRESULT CCompRC::AddMapNode(LocaleID langId, HRESOURCEDLL hInst, BOOL fMissing)
 //*****************************************************************************
 // Initialize
 //*****************************************************************************
-#ifndef FEATURE_CORECLR
-LPCWSTR CCompRC::m_pDefaultResource = W("mscorrc.dll");
-#else // !FEATURE_CORECLR
 LPCWSTR CCompRC::m_pDefaultResource = W("mscorrc.debug.dll");
 LPCWSTR CCompRC::m_pFallbackResource= W("mscorrc.dll");
-#endif // !FEATURE_CORECLR
 
 #ifdef FEATURE_PAL
 LPCSTR CCompRC::m_pDefaultResourceDomain = "mscorrc.debug";
@@ -482,7 +478,6 @@ CCompRC* CCompRC::GetDefaultResourceDll()
     return &m_DefaultResourceDll;
 }
 
-#ifdef FEATURE_CORECLR
 LONG    CCompRC::m_dwFallbackInitialized = 0;
 CCompRC CCompRC::m_FallbackResourceDll;
 
@@ -510,7 +505,6 @@ CCompRC* CCompRC::GetFallbackResourceDll()
     return &m_FallbackResourceDll;
 }
 
-#endif // FEATURE_CORECLR
 
 
 //*****************************************************************************
@@ -747,7 +741,6 @@ HRESULT CCompRC::LoadString(ResourceCategory eCategory, LocaleID langId, UINT iR
     // Failed to load string
     if ( hr != E_OUTOFMEMORY && ShouldUseFallback())
     {
-#ifdef FEATURE_CORECLR        
         CCompRC* pFallback=CCompRC::GetFallbackResourceDll();
         if (pFallback)
         {
@@ -761,13 +754,11 @@ HRESULT CCompRC::LoadString(ResourceCategory eCategory, LocaleID langId, UINT iR
             if(SUCCEEDED(hr))
                 return hr;
         }
-#endif
         switch (eCategory)
         {
             case Optional:
                 hr = E_FAIL;
                 break;
-#ifdef FEATURE_CORECLR        
             case  DesktopCLR:
                 hr = E_FAIL;
                 break;
@@ -837,12 +828,6 @@ HRESULT CCompRC::LoadString(ResourceCategory eCategory, LocaleID langId, UINT iR
                 // if we got here then we couldn't get the fallback message
                 // the fallback message is required so just falling through into "Required"
                 
-#else  // FEATURE_CORECLR
-            // everything that's not optional goes here for Desktop
-            case DesktopCLR:
-            case Debugging:
-            case Error:
-#endif        
             case Required:
 
                 if ( hr != E_OUTOFMEMORY)
@@ -1035,7 +1020,6 @@ HRESULT CCompRC::LoadLibraryThrows(HRESOURCEDLL * pHInst)
     PathString       rcPath;      // Path to resource DLL.
 
     // Try first in the same directory as this dll.
-#if defined(FEATURE_CORECLR)
 
     VALIDATECORECLRCALLBACKS();
 
@@ -1046,73 +1030,6 @@ HRESULT CCompRC::LoadLibraryThrows(HRESOURCEDLL * pHInst)
 
     hr = LoadLibraryHelper(pHInst, rcPath);
 
-#else // FEATURE_CORECLR
-
-    if (!WszGetModuleFileName(GetModuleInst(), rcPath))
-        return HRESULT_FROM_GetLastError();
-    
-    CopySystemDirectory(rcPath, rcPath);
-    
-    hr = LoadLibraryHelper(pHInst, rcPath);
-    if (hr == E_OUTOFMEMORY)
-        return hr;
-
-    // In case of default rc file, also try CORSystemDirectory.
-    // Note that GetRequestedRuntimeInfo is a function in ths shim.  As of 12/06, this is the only
-    // place where utilcode appears to take a dependency on the shim.  This forces everyone that links
-    // with us to also dynamically link to mscoree.dll.  Perhaps this should be a delay-load to prevent
-    // that static dependency and have a gracefull fallback when the shim isn't installed.
-    // We don't do this in DAC builds because mscordacwks.dll cannot take a dependency on other CLR
-    // dlls (eg. you must be able to examine a managed dump on a machine without any CLR installed).
-#ifndef DACCESS_COMPILE
-    if (FAILED(hr) && m_pResourceFile == m_pDefaultResource)
-    {
-#ifdef SELF_NO_HOST
-        WCHAR rcVersion[MAX_VERSION_STRING];
-        DWORD rcVersionSize;
-
-        DWORD corSystemPathSize;
-
-        // The reason for using GetRequestedRuntimeInfo is the ability to suppress message boxes
-        // with RUNTIME_INFO_DONT_SHOW_ERROR_DIALOG.
-        COUNT_T size = MAX_PATH;
-        hr = LegacyActivationShim::GetRequestedRuntimeInfo(
-            NULL, 
-            W("v")VER_PRODUCTVERSION_NO_QFE_STR_L, 
-            NULL, 
-            0,
-            RUNTIME_INFO_UPGRADE_VERSION|RUNTIME_INFO_DONT_SHOW_ERROR_DIALOG|RUNTIME_INFO_CONSIDER_POST_2_0,
-            rcPath.OpenUnicodeBuffer(size-1),
-            size,
-            &corSystemPathSize,
-            rcVersion,
-            NumItems(rcVersion),
-            &rcVersionSize);
-
-        rcPath.CloseBuffer(corSystemPathSize);
-
-        if (SUCCEEDED(hr))
-        {
-            if (rcVersionSize > 0)
-            {
-                rcPath.Append(rcVersion);
-                rcPath.Append(W("\\"));
-            }
-        }
-#else
-        // If we're hosted, we have the advantage of a CoreClrCallbacks reference.
-        // More importantly, we avoid calling back to mscoree.dll.
-        
-        hr = GetClrCallbacks().m_pfnGetCORSystemDirectory(rcPath);
-#endif
-        if (SUCCEEDED(hr))
-        {
-            hr = LoadLibraryHelper(pHInst, rcPath);
-        }
-    }
-#endif // !DACCESS_COMPILE
-
-#endif  // FEATURE_CORECLR
 
 #endif // CROSSGEN_COMPILE
 
diff --git a/src/utilcode/clrhost.cpp b/src/utilcode/clrhost.cpp
index 8a61eee966..15678a9861 100644
--- a/src/utilcode/clrhost.cpp
+++ b/src/utilcode/clrhost.cpp
@@ -16,9 +16,7 @@
 #include "contract.h"
 #include "tls.h"
 
-#if defined(FEATURE_CORECLR) || !defined(SELF_NO_HOST) || defined(DACCESS_COMPILE) || defined(CROSSGEN_COMPILE)
 CoreClrCallbacks g_CoreClrCallbacks;
-#endif
 
 
 // In some cirumstance (e.g, the thread suspecd another thread), allocation on heap
@@ -206,7 +204,6 @@ int RFS_HashStack ()
 #endif // FAILPOINTS_ENABLED
 
 
-#if defined(FEATURE_CORECLR) || !defined(SELF_NO_HOST) || defined(DACCESS_COMPILE)
 
 //-----------------------------------------------------------------------------------
 // This is the approved way to get a module handle to mscorwks.dll (or coreclr.dll).
@@ -264,7 +261,6 @@ HMODULE GetCLRModule ()
     return g_CoreClrCallbacks.m_hmodCoreCLR;
 }
 
-#endif // defined(FEATURE_CORECLR) || !defined(SELF_NO_HOST) || defined(DACCESS_COMPILE)
 
 
 #if defined(SELF_NO_HOST)
@@ -402,7 +398,6 @@ LoadsTypeHolder::~LoadsTypeHolder()
 // versions in the same process.
 //--------------------------------------------------------------------------
 
-#if defined(FEATURE_CORECLR) || !defined(SELF_NO_HOST) || defined(DACCESS_COMPILE)
 
 //--------------------------------------------------------------------------
 // One-time initialized called by coreclr.dll in its dllmain.
@@ -435,7 +430,7 @@ void OnUninitializedCoreClrCallbacks()
     // (other than coreclr.dll) that links to utilcode.lib, or that you're using a nohost
     // variant of utilcode.lib but hitting code that assumes there is a CLR in the process.
     //
-    // Under FEATURE_CORECLR (and not SELF_NO_HOST), it is expected that coreclr.dll 
+    // It is expected that coreclr.dll 
     // is the ONLY dll that links to utilcode libraries.
     //
     // If you must introduce a new dll that links to utilcode.lib, it is your responsibility
@@ -456,4 +451,3 @@ void OnUninitializedCoreClrCallbacks()
 }
 #endif // _DEBUG
 
-#endif // defined(FEATURE_CORECLR) || !defined(SELF_NO_HOST) || defined(DACCESS_COMPILE)
diff --git a/src/utilcode/dlwrap.cpp b/src/utilcode/dlwrap.cpp
index 0c9026a421..a6771c9daa 100644
--- a/src/utilcode/dlwrap.cpp
+++ b/src/utilcode/dlwrap.cpp
@@ -77,155 +77,3 @@ VerQueryValueW_NoThrow(
     
 }
 
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-// The following functions are not used in CoreCLR. Normally LINKER can remove these functions
-// from generated files.  But LINKER does it in two steps:
-// 1. If no function in a source file is used, the file is ignored by LINKER
-// 2. If one function is used, LINKER will first make sure all imported functions in the file
-//    is available, and then it will remove unused functions.
-// Instead of specifying all libs for imported functions needed by the following codes, we just
-// remove them from compiling phase.
-__success(return)
-BOOL 
-CreateUrlCacheEntryW_NoThrow(
-        IN LPCWSTR lpszUrlName,
-        IN DWORD dwExpectedFileSize,
-        IN LPCWSTR lpszFileExtension,
-        __out_ecount(MAX_LONGPATH+1) LPWSTR lpszFileName,
-        IN DWORD dwReserved
-        )
-{
-    WRAPPER_NO_CONTRACT;
-    HRESULT hr=S_OK;
-    BOOL bRet=FALSE;
-    EX_TRY
-    {
-         bRet=CreateUrlCacheEntryW(lpszUrlName,dwExpectedFileSize,lpszFileExtension,
-                                                                lpszFileName,dwReserved);
-    }
-    EX_CATCH_HRESULT(hr);
-    if (hr!=S_OK)
-        SetLastError(hr);
-    return bRet;
-    
-}
-
-BOOL  
-CommitUrlCacheEntryW_NoThrow(
-        IN LPCWSTR lpszUrlName,
-        IN LPCWSTR lpszLocalFileName,
-        IN FILETIME ExpireTime,
-        IN FILETIME LastModifiedTime,
-        IN DWORD CacheEntryType,
-        IN LPCWSTR lpHeaderInfo,
-        IN DWORD dwHeaderSize,
-        IN LPCWSTR lpszFileExtension,
-        IN LPCWSTR lpszOriginalUrl
-        )
-{
-    WRAPPER_NO_CONTRACT;
-    HRESULT hr=S_OK;
-    BOOL bRet=FALSE;
-    EX_TRY
-    {
-         bRet=CommitUrlCacheEntryW(lpszUrlName,lpszLocalFileName,ExpireTime,
-                                                        LastModifiedTime,CacheEntryType,(LPWSTR)lpHeaderInfo,
-                                                        dwHeaderSize,lpszFileExtension,lpszOriginalUrl);
-    }
-    EX_CATCH_HRESULT(hr);
-    if (hr!=S_OK)
-        SetLastError(hr);
-    return bRet;
-    
-}
-
-BOOL 
-InternetTimeToSystemTimeA_NoThrow(
-        IN  LPCSTR lpszTime,         // NULL terminated string
-        OUT SYSTEMTIME *pst,         // output in GMT time
-        IN  DWORD dwReserved
-        ) 
-{
-    WRAPPER_NO_CONTRACT;
-    HRESULT hr=S_OK;
-    BOOL bRet=FALSE;
-    EX_TRY
-    {
-         bRet=InternetTimeToSystemTimeA(lpszTime,pst,dwReserved); 
-    }
-    EX_CATCH_HRESULT(hr);
-    if (hr!=S_OK)
-        SetLastError(hr);
-    return bRet;
-    
-}
-
-HRESULT 
-CoInternetCreateSecurityManager_NoThrow(
-        IServiceProvider *pSP,
-        IInternetSecurityManager **ppSM, 
-        DWORD dwReserved
-        )
-{
-    WRAPPER_NO_CONTRACT;
-    HRESULT hr=S_OK;
-    EX_TRY
-    {
-         hr=CoInternetCreateSecurityManager(pSP,ppSM, dwReserved);
-    }
-    EX_CATCH_HRESULT(hr);
-    return hr;
-}
-
-HRESULT 
-URLDownloadToCacheFileW_NoThrow(
-        LPUNKNOWN lpUnkcaller,
-        LPCWSTR szURL,
-        __out_ecount(dwBufLength) LPWSTR szFileName,
-        DWORD dwBufLength,
-        DWORD dwReserved,
-        IBindStatusCallback *pBSC
-        )
-{
-    WRAPPER_NO_CONTRACT;
-    HRESULT hr=S_OK;
-    EX_TRY
-    {
-         hr=URLDownloadToCacheFileW(lpUnkcaller,szURL,szFileName,dwBufLength,dwReserved,pBSC);
-    }
-    EX_CATCH_HRESULT(hr);
-    return hr;
-}
-
-HRESULT 
-CoInternetGetSession_NoThrow(
-        WORD dwSessionMode,
-        IInternetSession **ppIInternetSession,
-        DWORD dwReserved
-        )
-{
-   WRAPPER_NO_CONTRACT;
-    HRESULT hr=S_OK;
-    EX_TRY
-    {
-         hr=CoInternetGetSession(dwSessionMode,ppIInternetSession,dwReserved);
-    }
-    EX_CATCH_HRESULT(hr);
-    return hr;
-}
-
-HRESULT 
-CopyBindInfo_NoThrow( 
-        const BINDINFO * pcbiSrc, BINDINFO * pbiDest
-        )
-{
-   WRAPPER_NO_CONTRACT;
-    HRESULT hr=S_OK;
-    EX_TRY
-    {
-         hr=CopyBindInfo(pcbiSrc,pbiDest );
-    }
-    EX_CATCH_HRESULT(hr);
-    return hr;
-}
-#endif // FEATURE_CORECLR && !CROSSGEN_COMPILE
diff --git a/src/utilcode/ex.cpp b/src/utilcode/ex.cpp
index bb164571ad..92b25b0aaf 100644
--- a/src/utilcode/ex.cpp
+++ b/src/utilcode/ex.cpp
@@ -2037,9 +2037,9 @@ static DWORD MarkAsThrownByUsWorker(UINT numArgs, /*out*/ ULONG_PTR exceptionArg
 
     exceptionArgs[0] = arg0;
 
-#if !defined(FEATURE_UTILCODE_NO_DEPENDENCIES) && (defined(FEATURE_CORECLR) || !defined(SELF_NO_HOST) || defined(DACCESS_COMPILE))
+#if !defined(FEATURE_UTILCODE_NO_DEPENDENCIES)
     exceptionArgs[INSTANCE_TAGGED_SEH_PARAM_ARRAY_SIZE - 1] = (ULONG_PTR) (GetCLRModule());
-#endif // !defined(FEATURE_UTILCODE_NO_DEPENDENCIES) && defined(FEATURE_CORECLR) || !defined(SELF_NO_HOST) || defined(DACCESS_COMPILE)
+#endif // !defined(FEATURE_UTILCODE_NO_DEPENDENCIES)
     
     return INSTANCE_TAGGED_SEH_PARAM_ARRAY_SIZE;
 }
@@ -2086,15 +2086,15 @@ BOOL WasThrownByUs(const EXCEPTION_RECORD *pcER, DWORD dwExceptionCode)
     {
         return FALSE;
     }
-#if!defined(FEATURE_UTILCODE_NO_DEPENDENCIES) && (defined(FEATURE_CORECLR) || !defined(SELF_NO_HOST) || defined(DACCESS_COMPILE))
+#if!defined(FEATURE_UTILCODE_NO_DEPENDENCIES)
     if ( ((ULONG_PTR)(GetCLRModule())) != pcER->ExceptionInformation[INSTANCE_TAGGED_SEH_PARAM_ARRAY_SIZE - 1] )
     {
         return FALSE;
     }
     return TRUE;
-#else // !(!defined(FEATURE_UTILCODE_NO_DEPENDENCIES) && (defined(FEATURE_CORECLR) || !defined(SELF_NO_HOST) || defined(DACCESS_COMPILE)))
+#else // !(!defined(FEATURE_UTILCODE_NO_DEPENDENCIES)
     return FALSE;
-#endif // !defined(FEATURE_UTILCODE_NO_DEPENDENCIES) && defined(FEATURE_CORECLR) || !defined(SELF_NO_HOST) || defined(DACCESS_COMPILE)
+#endif // !defined(FEATURE_UTILCODE_NO_DEPENDENCIES)
 }
 
 
diff --git a/src/utilcode/longfilepathwrappers.cpp b/src/utilcode/longfilepathwrappers.cpp
index 5272d35807..2e493d02b5 100644
--- a/src/utilcode/longfilepathwrappers.cpp
+++ b/src/utilcode/longfilepathwrappers.cpp
@@ -1187,7 +1187,6 @@ FindFirstFileExWrapper(
 }
 #endif //!FEATURE_PAL
 
-#if defined(FEATURE_CORECLR) || defined(CROSSGEN_COMPILE)
 
 #ifndef FEATURE_PAL
 
@@ -1247,7 +1246,6 @@ BOOL PAL_GetPALDirectoryWrapper(SString& pbuffer)
 
 #endif // FEATURE_PAL
 
-#endif // FEATURE_CORECLR || CROSSGEN_COMPILE
 
 //Implementation of LongFile Helpers
 const WCHAR LongFile::DirectorySeparatorChar = W('\\');
diff --git a/src/utilcode/makepath.cpp b/src/utilcode/makepath.cpp
index 701c525cf4..6e0b56281c 100644
--- a/src/utilcode/makepath.cpp
+++ b/src/utilcode/makepath.cpp
@@ -15,158 +15,6 @@
 #include "utilcode.h"
 #include "ex.h"
 
-#ifndef FEATURE_CORECLR
-/***
-*void MakePath() - build path name from components
-*
-*Purpose:
-*       create a path name from its individual components
-*
-*Entry:
-*       WCHAR *path  - pointer to buffer for constructed path
-*       WCHAR *drive - pointer to drive component, may or may not contain
-*                     trailing ':'
-*       WCHAR *dir   - pointer to subdirectory component, may or may not include
-*                     leading and/or trailing '/' or '\' characters
-*       WCHAR *fname - pointer to file base name component
-*       WCHAR *ext   - pointer to extension component, may or may not contain
-*                     a leading '.'.
-*
-*Exit:
-*       path - pointer to constructed path name
-*
-*Exceptions:
-*
-*******************************************************************************/
-
-void MakePath (
-        __out_ecount (MAX_LONGPATH) WCHAR *path,
-        __in LPCWSTR drive,
-        __in LPCWSTR dir,
-        __in LPCWSTR fname,
-        __in LPCWSTR ext
-        )
-{
-        CONTRACTL
-        {
-            NOTHROW;
-            GC_NOTRIGGER;
-            FORBID_FAULT;
-        }
-        CONTRACTL_END
-
-        const WCHAR *p;
-        DWORD count = 0;
-
-        /* we assume that the arguments are in the following form (although we
-         * do not diagnose invalid arguments or illegal filenames (such as
-         * names longer than 8.3 or with illegal characters in them)
-         *
-         *  drive:
-         *      A           ; or
-         *      A:
-         *  dir:
-         *      \top\next\last\     ; or
-         *      /top/next/last/     ; or
-         *      either of the above forms with either/both the leading
-         *      and trailing / or \ removed.  Mixed use of '/' and '\' is
-         *      also tolerated
-         *  fname:
-         *      any valid file name
-         *  ext:
-         *      any valid extension (none if empty or null )
-         */
-
-        /* copy drive */
-
-        if (drive && *drive) {
-                *path++ = *drive;
-                *path++ = _T(':');
-                count += 2;
-        }
-
-        /* copy dir */
-
-        if ((p = dir)) {
-                while (*p) {
-                        *path++ = *p++;
-                        count++;
-
-                        if (count == MAX_LONGPATH) {
-                            --path;
-                            *path = _T('\0');
-                            return;
-                        }
-                }
-
-#ifdef _MBCS
-                if (*(p=_mbsdec(dir,p)) != _T('/') && *p != _T('\\')) {
-#else  /* _MBCS */
-                // suppress warning for the following line; this is safe but would require significant code
-                // delta for prefast to understand.
-#ifdef _PREFAST_
-                #pragma warning( suppress: 26001 ) 
-#endif
-                if (*(p-1) != _T('/') && *(p-1) != _T('\\')) {
-#endif  /* _MBCS */
-                        *path++ = _T('\\');
-                        count++;
-
-                        if (count == MAX_LONGPATH) {
-                            --path;
-                            *path = _T('\0');
-                            return;
-                        }
-                }
-        }
-
-        /* copy fname */
-
-        if ((p = fname)) {
-                while (*p) {
-                        *path++ = *p++;
-                        count++;
-
-                        if (count == MAX_LONGPATH) {
-                            --path;
-                            *path = _T('\0');
-                            return;
-                        }
-                }
-        }
-
-        /* copy ext, including 0-terminator - check to see if a '.' needs
-         * to be inserted.
-         */
-
-        if ((p = ext)) {
-                if (*p && *p != _T('.')) {
-                        *path++ = _T('.');
-                        count++;
-
-                        if (count == MAX_LONGPATH) {
-                            --path;
-                            *path = _T('\0');
-                            return;
-                        }
-                }
-
-                while ((*path++ = *p++)) {
-                    count++;
-
-                    if (count == MAX_LONGPATH) {
-                        --path;
-                        *path = _T('\0');
-                        return;
-                    }
-                }
-        }
-        else {
-                /* better add the 0-terminator */
-                *path = _T('\0');
-        }
-}
-#endif // !FEATURE_CORECLR
 
 /***
 *void Makepath() - build path name from components
@@ -307,57 +155,6 @@ void MakePath (
         szPath.Shrink(count + 1);
 }
 
-#if !defined(FEATURE_CORECLR)
-static LPCWSTR g_wszProcessExePath = NULL;
-
-HRESULT GetProcessExePath(LPCWSTR *pwszProcessExePath)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        CONSISTENCY_CHECK(CheckPointer(pwszProcessExePath));
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    if (g_wszProcessExePath == NULL)
-    {
-        DWORD cchProcName = 0;
-        NewArrayHolder<WCHAR> wszProcName;
-        EX_TRY
-        {
-            PathString wszProcNameString;
-            cchProcName = WszGetModuleFileName(NULL, wszProcNameString);
-            if (cchProcName == 0)
-            {
-                hr = HRESULT_FROM_GetLastError();
-            }
-            else
-            {
-                wszProcName = wszProcNameString.GetCopyOfUnicodeString();
-            }
-        }
-        EX_CATCH_HRESULT(hr);
-
-        if (FAILED(hr))
-        {
-            return hr;
-        }
-        
-        if (InterlockedCompareExchangeT(&g_wszProcessExePath, const_cast<LPCWSTR>(wszProcName.GetValue()), NULL) == NULL)
-        {
-            wszProcName.SuppressRelease();
-        }
-    }
-    _ASSERTE(g_wszProcessExePath != NULL);
-    _ASSERTE(SUCCEEDED(hr));
-
-    *pwszProcessExePath = g_wszProcessExePath;
-    return hr;
-}
-#endif
 
 // Returns the directory for HMODULE. So, if HMODULE was for "C:\Dir1\Dir2\Filename.DLL",
 // then this would return "C:\Dir1\Dir2\" (note the trailing backslash).
diff --git a/src/utilcode/newapis.cpp b/src/utilcode/newapis.cpp
index 3717f0280d..c05d024b7e 100644
--- a/src/utilcode/newapis.cpp
+++ b/src/utilcode/newapis.cpp
@@ -32,27 +32,6 @@ namespace NewApis
 
         FARPROC result = NULL;
 
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-
-        // First try to use the function defined in the culture dll 
-        // if we are running on a platform prior to Win7
-        if(!IsWindows7Platform())
-        {
-            // only need to load the culture dll's handle once then we can hold onto it
-            static HMODULE hCulture = NULL;
-            // if we haven't loaded the culture dll yet
-            if (hCulture == NULL)
-            {
-                UtilCode::LoadLibraryShim(MAKEDLLNAME_W(W("culture")), NULL, 0, &hCulture);
-            }
-            
-            // make sure we were successful before using the handle
-            if (hCulture != NULL)
-            {
-                result=GetProcAddress(hCulture,lpProcName);
-            }
-        }
-#endif // !FEATURE_CORECLR && !CROSSGEN_COMPILE
 
         // next try the kernel
         if(result==NULL)
@@ -1094,9 +1073,7 @@ inline BOOL IsInvariantCasing(__in LPCWSTR lpLocaleName, __in DWORD dwMapFlags)
         retVal = ::LCIDToLocaleName(Locale, lpName, cchName, dwFlags | LOCALE_ALLOW_NEUTRAL_NAMES);
 #else
 
-#ifdef FEATURE_CORECLR
         retVal = DownLevel::LCIDToLocaleName(Locale, lpName,cchName,dwFlags | LOCALE_ALLOW_NEUTRAL_NAMES);
-#endif // FEATURE_CORECLR
 
         typedef int (WINAPI *PFNLCIDToLocaleName)(LCID, LPWSTR,int ,DWORD);
         static PFNLCIDToLocaleName pFNLCIDToLocaleName=NULL;
@@ -1138,9 +1115,7 @@ inline BOOL IsInvariantCasing(__in LPCWSTR lpLocaleName, __in DWORD dwMapFlags)
 #if !defined(ENABLE_DOWNLEVEL_FOR_NLS)
         return ::LocaleNameToLCID(lpName, dwFlags | LOCALE_ALLOW_NEUTRAL_NAMES);
 #else
-#ifdef FEATURE_CORECLR
         retVal = DownLevel::LocaleNameToLCID(lpName, dwFlags | LOCALE_ALLOW_NEUTRAL_NAMES);
-#endif // FEATURE_CORECLR
 
         typedef int (WINAPI *PFNLocaleNameToLCID)(LPCWSTR,DWORD);
         static PFNLocaleNameToLCID pFNLocaleNameToLCID=NULL;
@@ -1278,26 +1253,6 @@ inline BOOL IsInvariantCasing(__in LPCWSTR lpLocaleName, __in DWORD dwMapFlags)
     }
 
 
-#if !defined(FEATURE_CORECLR)
-    BOOL GetNlsVersionEx(__in NLS_FUNCTION Function, __in LPCWSTR lpLocaleName, __inout LPNLSVERSIONINFOEX lpVersionInfo)
-    {
-
-        typedef BOOL (WINAPI *PFNGetNLSVersionEx)(NLS_FUNCTION, LPCWSTR, LPNLSVERSIONINFOEX);
-        
-        static PFNGetNLSVersionEx pFNGetNLSVersionEx=NULL;
-
-        // See if we still need to find our function
-        if (pFNGetNLSVersionEx == NULL)
-        {
-            // We only call this on Win8 and above, so this should always work.
-            pFNGetNLSVersionEx = (PFNGetNLSVersionEx) GetSystemProcAddressForSortingApi("GetNLSVersionEx", NULL);
-        }
-
-        _ASSERTE(pFNGetNLSVersionEx != NULL);
-
-        return pFNGetNLSVersionEx(Function, lpLocaleName, lpVersionInfo);
-    }
-#endif
 
     // This is a Windows 7 and above function
     // This returns the "specific" locale from an input name, ie: "en" returns "en-US",
diff --git a/src/utilcode/pedecoder.cpp b/src/utilcode/pedecoder.cpp
index c437c21c35..0ab1cf3563 100644
--- a/src/utilcode/pedecoder.cpp
+++ b/src/utilcode/pedecoder.cpp
@@ -1173,12 +1173,6 @@ CHECK PEDecoder::CheckCorHeader() const
     CHECK_OK;
 }
 
-#if !defined(FEATURE_CORECLR)
-#define WHIDBEY_SP2_VERSION_MAJOR 2
-#define WHIDBEY_SP2_VERSION_MINOR 0
-#define WHIDBEY_SP2_VERSION_BUILD 50727
-#define WHIDBEY_SP2_VERSION_PRIVATE_BUILD 3053
-#endif // !defined(FEATURE_CORECLR)
 
 
 // This function exists to provide compatibility between two different native image
@@ -1236,71 +1230,10 @@ IMAGE_DATA_DIRECTORY *PEDecoder::GetMetaDataHelper(METADATA_SECTION_TYPE type) c
     // COR_HEADER and so the value of pDirRet is correct
     if (HasNativeHeader())
     {
-#ifdef FEATURE_CORECLR
 
         if (type == METADATA_SECTION_MANIFEST)
             pDirRet = &GetNativeHeader()->ManifestMetaData;
 
-#else // FEATURE_CORECLR
-
-        IMAGE_DATA_DIRECTORY *pDirNativeHeader = &GetNativeHeader()->ManifestMetaData;
-
-        // This code leverages the fact that pre-Whidbey SP2 private build numbers can never
-        // be greater than Whidbey SP2 private build number, because otherwise major setup
-        // issues would arise. To prevent this, it is standard to bump the private build
-        // number up a significant amount for SPs, as was the case between Whidbey SP1 and
-        // Whidbey SP2.
-        // 
-        // Since we could be reading an older version of native image, we tell
-        // GetNativeVersionInfoMaybeNull to skip checking the native header.
-        CORCOMPILE_VERSION_INFO *pVerInfo = GetNativeVersionInfoMaybeNull(true);
-        bool fIsPreWhidbeySP2 = false;
-
-        // If pVerInfo is NULL, we assume that we're in an NGEN compilation domain and that
-        // the information has not yet been written. Since an NGEN compilation domain running
-        // in the v4.0 runtime can only complie v4.0 native images, we'll assume the default
-        // fIsPreWhidbeySP2 value (false) is correct.
-        if (pVerInfo != NULL && pVerInfo->wVersionMajor <= WHIDBEY_SP2_VERSION_MAJOR)
-        {
-            if (pVerInfo->wVersionMajor < WHIDBEY_SP2_VERSION_MAJOR)
-                fIsPreWhidbeySP2 = true;
-            else if (pVerInfo->wVersionMajor == WHIDBEY_SP2_VERSION_MAJOR)
-            {
-                // If the sp2 minor version isn't 0, we need this logic:
-                //     if (pVerInfo->wVersionMinor < WHIDBEY_SP2_VERSION_MINOR)
-                //         fIsPreWhidbeySP2 = true;
-                //     else
-                // However, if it is zero, with that logic we get a warning about the comparison
-                // of an unsigned variable to zero always being false.
-                _ASSERTE(WHIDBEY_SP2_VERSION_MINOR == 0);
-
-                if (pVerInfo->wVersionMinor == WHIDBEY_SP2_VERSION_MINOR)
-                {
-                    if (pVerInfo->wVersionBuildNumber < WHIDBEY_SP2_VERSION_BUILD)
-                        fIsPreWhidbeySP2 = true;
-                    else if (pVerInfo->wVersionBuildNumber == WHIDBEY_SP2_VERSION_BUILD)
-                    {
-                        if (pVerInfo->wVersionPrivateBuildNumber < WHIDBEY_SP2_VERSION_PRIVATE_BUILD)
-                            fIsPreWhidbeySP2 = true;
-                    }
-                }
-            }
-        }
-
-        // In pre-Whidbey SP2, pDirRet points to manifest and pDirNativeHeader points to full.
-        if (fIsPreWhidbeySP2)
-        {
-            if (type == METADATA_SECTION_FULL)
-                pDirRet = pDirNativeHeader;
-        }
-        // In Whidbey SP2 and later, pDirRet points to full and pDirNativeHeader points to manifest.
-        else
-        {
-            if (type == METADATA_SECTION_MANIFEST)
-                pDirRet = pDirNativeHeader;
-        }
-
-#endif // FEATURE_CORECLR
 
     }
 
diff --git a/src/utilcode/peinformation.cpp b/src/utilcode/peinformation.cpp
index 948948a4da..20a9fe18b0 100644
--- a/src/utilcode/peinformation.cpp
+++ b/src/utilcode/peinformation.cpp
@@ -11,100 +11,6 @@
 #include "utilcode.h"
 #include "peinformation.h"
 
-#if defined(FEATURE_FUSION) && !defined(DACCESS_COMPILE)
-
-extern BOOL g_fWow64Process;    // Wow64 Process
-
-PEKIND GetCurrentRealProcessorPEKIND()
-{
-    PEKIND curProcessorPEKind = TargetNativePEKIND();
-
-#ifdef _TARGET_X86_
-    if (g_fWow64Process)
-    {
-        SYSTEM_INFO si = {0};
-
-        GetNativeSystemInfo(&si);
-        switch (si.wProcessorArchitecture)
-        {
-        case PROCESSOR_ARCHITECTURE_AMD64:
-            curProcessorPEKind = peAMD64;
-            break;
-        default:
-            _ASSERTE(FALSE);
-            curProcessorPEKind = peInvalid;
-            break;
-        }
-    }
-#endif // _TARGET_X86_
-
-    return curProcessorPEKind;
-}
-
-HRESULT RuntimeIsValidAssemblyOnThisPlatform_CheckProcessorArchitecture(PEKIND processorArchitecture, BOOL bForInstall)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    HRESULT hr = S_OK;
-    
-    // MSIL / legacy images always allowed
-    if (IsPEMSIL(processorArchitecture) || (processorArchitecture == peNone))
-    {
-        goto Exit;
-    }
-    else if (IsPE32(processorArchitecture))
-    {
-#ifdef _TARGET_ARM_
-        // ARM can use only native ones
-        if (processorArchitecture != TargetNativePEKIND())
-        {
-            hr = HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
-            goto Exit;
-        }
-
-#else //!_TARGET_ARM_
-        //ARM assemblies can be installed only on ARM
-        if (processorArchitecture == peARM)
-        {
-            hr = HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
-            goto Exit;
-        }
-#endif //!_TARGET_ARM_
-        
-        if (bForInstall)
-        {
-            goto Exit;
-        }
-        else
-        {
-            // won't allow bind to x86 while in 64 bit process.
-            if (!IsProcess32())
-            {
-                hr = HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
-            }
-            goto Exit;
-        }
-    }
-    // 64 bit images must match processor type
-    else if(IsPE64(processorArchitecture))
-    {
-        if (!IsProcess32() && (processorArchitecture == TargetNativePEKIND()))
-        {
-            goto Exit;
-        }
-        else if (bForInstall && (GetCurrentRealProcessorPEKIND() == processorArchitecture))
-        {
-            goto Exit;
-        }
-    }
-
-    // Everything else, fails match
-    hr = HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
-
-Exit:
-    return hr;
-}
-#endif // FEATURE_FUSION && !DACCESS_COMPILE
 
 HRESULT TranslatePEToArchitectureType(CorPEKind CLRPeKind, DWORD dwImageType, PEKIND * pPeKind)
 {
diff --git a/src/utilcode/registrywrapper.cpp b/src/utilcode/registrywrapper.cpp
index f6b88db977..b3c4b42946 100644
--- a/src/utilcode/registrywrapper.cpp
+++ b/src/utilcode/registrywrapper.cpp
@@ -74,288 +74,3 @@
 #include "clrconfig.h"
 #include "strsafe.h"
 
-#if !defined(FEATURE_UTILCODE_NO_DEPENDENCIES) && !defined(FEATURE_CORECLR)
-
-static LPCWSTR kRegistryRootKey = W("SOFTWARE\\");
-static const HKEY kRegistryRootHive = HKEY_LOCAL_MACHINE;
-static LPCWSTR kWow6432Node = W("Wow6432Node\\");
-static LPCWSTR kMicrosoftDotNetFrameworkPolicy = W("Microsoft\\.NETFramework\\Policy");
-static LPCWSTR wszHKLM = W("HKLM\\");
-static WCHAR * g_registryRoot = NULL;
-static volatile bool g_initialized = false;
-static const WCHAR BACKSLASH_CHARACTER[] = W("\\");
-
-//
-// Called the first time we use ClrRegCreateKeyEx or ClrRegOpenKeyEx to determine if the registry redirection
-// config value has been set.  If so, we parse it into g_registryRoot
-// If the config string is mal-formed, we don't set the global variable.
-//
-HRESULT ParseRegistryRootConfigValue()
-{
-    if (!IsNgenOffline())
-    {
-        return ERROR_SUCCESS;
-    }
-    
-    CLRConfigStringHolder configValue(CLRConfig::GetConfigValue(CLRConfig::UNSUPPORTED_RegistryRoot));
-    // Since IsNgenOffline returned true, this better not be NULL
-    if (configValue == NULL)
-        return ERROR_BAD_ARGUMENTS;
-    
-    if (_wcsnicmp(configValue, wszHKLM, wcslen(wszHKLM)) != 0)
-    {
-        return ERROR_BAD_ARGUMENTS;
-    }
-    
-    // The rest of the string is the location of the redirected registry key
-    LPWSTR configValueKey = (LPWSTR)configValue;
-    configValueKey = _wcsninc(configValueKey, wcslen(wszHKLM));
-    
-    size_t len = wcslen(configValueKey) + 1;
-    
-    bool appendBackslash = false;
-    if (configValueKey[wcslen(configValueKey) - 1] != W('\\'))
-    {
-        appendBackslash = true;
-        len += wcslen(BACKSLASH_CHARACTER);
-    }
-    g_registryRoot = new (nothrow) WCHAR[len];
-    
-    if (g_registryRoot == NULL)
-    {
-        return ERROR_NOT_ENOUGH_MEMORY;
-    }
-    
-    wcscpy_s(g_registryRoot, len, configValueKey);
-    if (appendBackslash)
-    {
-        StringCchCat(g_registryRoot, len, BACKSLASH_CHARACTER);
-    }
-    
-    return ERROR_SUCCESS;
-}
-
-//
-// This is our check that the target machine is 32/64bit
-// If 32bit only, there will be no Wow6432Node key
-// If 64bit, there will be a Wow6432Node key
-//
-HRESULT CheckWow6432NodeNetFxExists(bool * fResult)
-{
-    static bool bInitialized = false;
-    static bool bNodeExists = false;
-    HRESULT hr = ERROR_SUCCESS;
-    
-    if (!bInitialized)
-    {
-        size_t redirectedLength = wcslen(g_registryRoot) + wcslen(kWow6432Node) + wcslen(kMicrosoftDotNetFrameworkPolicy) + 1;
-        LPWSTR lpRedirectedKey = new (nothrow) WCHAR[redirectedLength];
-    
-        if (lpRedirectedKey == NULL)
-        {
-            return ERROR_NOT_ENOUGH_MEMORY;
-        }
-        
-        wcscpy_s(lpRedirectedKey, redirectedLength, g_registryRoot);
-        StringCchCat(lpRedirectedKey, redirectedLength, kWow6432Node);
-        StringCchCat(lpRedirectedKey, redirectedLength, kMicrosoftDotNetFrameworkPolicy);
-        
-        HKEY hkey;
-        hr = RegOpenKeyExW(HKEY_LOCAL_MACHINE, lpRedirectedKey, 0, KEY_READ, &hkey);
-        bNodeExists = hr == ERROR_SUCCESS;
-        
-        if (hr == ERROR_FILE_NOT_FOUND)
-        {
-            hr = ERROR_SUCCESS;
-        }
-        
-        if (hkey)
-        {
-            RegCloseKey(hkey);
-        }
-        bInitialized = true;
-    }
-    *fResult = bNodeExists;
-    return hr;
-}
-
-HRESULT CheckUseWow6432Node(REGSAM samDesired, bool * fResult)
-{
-    HRESULT hr = ERROR_SUCCESS;
-    bool fWow6432NodeExists = false;
-    
-    hr = CheckWow6432NodeNetFxExists(&fWow6432NodeExists);
-    if (hr == ERROR_SUCCESS)
-    {
-        if (!fWow6432NodeExists)
-        {
-            *fResult = false;
-        } else
-        {
-#if defined(_WIN64)
-            *fResult = false;
-#else
-            *fResult = true;
-#endif
-            // If KEY_WOW64_64KEY or KEY_WOW64_32KEY are set, override
-            // If both are set, the actual registry call will fail with ERROR_INVALID_PARAMETER
-            // so no worries here
-            if (samDesired & KEY_WOW64_64KEY)
-            {
-                *fResult = false;
-            } else if (samDesired & KEY_WOW64_32KEY)
-            {
-                *fResult = true;
-            }
-        }
-    }
-    return hr;
-}
-
-//
-// lpRedirectedKey is allocated and returned from this method.  Caller owns the new string and
-// should release
-//
-__success(return == ERROR_SUCCESS)
-HRESULT RedirectKey(REGSAM samDesired, HKEY hKey, LPCWSTR lpKey, __deref_out_z LPWSTR * lpRedirectedKey)
-{
-    if (hKey != kRegistryRootHive || _wcsnicmp(lpKey, kRegistryRootKey, wcslen(kRegistryRootKey)) != 0)
-    {
-        *lpRedirectedKey = NULL;
-        return ERROR_SUCCESS;
-    }
-    
-    LPCWSTR lpRootStrippedKey = lpKey + wcslen(kRegistryRootKey);
-    size_t redirectedLength = wcslen(g_registryRoot) + wcslen(lpRootStrippedKey) + 1;
-    
-    bool bUseWow = false;
-    HRESULT hr = CheckUseWow6432Node(samDesired, &bUseWow);
-    
-    if (hr != ERROR_SUCCESS)
-    {
-        return hr;
-    }
-    
-    if (bUseWow)
-    {
-        redirectedLength += wcslen(kWow6432Node);
-    }
-    
-    *lpRedirectedKey = new (nothrow) WCHAR[redirectedLength];
-    
-    if (*lpRedirectedKey == NULL)
-    {
-        return ERROR_NOT_ENOUGH_MEMORY;
-    }
-    
-    wcscpy_s(*lpRedirectedKey, redirectedLength, g_registryRoot);
-    if (bUseWow)
-    {
-        StringCchCat(*lpRedirectedKey, redirectedLength, kWow6432Node);
-    }
-    
-    StringCchCat(*lpRedirectedKey, redirectedLength, lpRootStrippedKey);
-    
-    return ERROR_SUCCESS;
-}
-
-LONG ClrRegCreateKeyEx(
-        HKEY hKey,
-        LPCWSTR lpSubKey,
-        DWORD Reserved,
-        __in_opt LPWSTR lpClass,
-        DWORD dwOptions,
-        REGSAM samDesired,
-        LPSECURITY_ATTRIBUTES lpSecurityAttributes,
-        PHKEY phkResult,
-        LPDWORD lpdwDisposition
-        )
-{
-    HRESULT hr;
-    if (!g_initialized)
-    {
-        hr = ParseRegistryRootConfigValue();
-        if (hr != ERROR_SUCCESS)
-            return hr;
-        g_initialized = true;
-    }
-    
-    if (g_registryRoot != NULL)
-    {
-        NewArrayHolder<WCHAR> lpRedirectedKey(NULL);
-        hr = RedirectKey(samDesired, hKey, lpSubKey, &lpRedirectedKey);
-        // We don't want to touch the registry if we're low on memory and can't redirect properly.  It could lead
-        // to use reading and writing to two separate registries and corrupting both in the process
-        if (hr != ERROR_SUCCESS)
-            return hr;
-        LPCWSTR lpKeyToUse = lpRedirectedKey == NULL ? lpSubKey : lpRedirectedKey;
-        return RegCreateKeyExW(hKey, lpKeyToUse, Reserved, lpClass, dwOptions, samDesired, lpSecurityAttributes, phkResult, lpdwDisposition);
-    }
-    return RegCreateKeyExW(hKey, lpSubKey, Reserved, lpClass, dwOptions, samDesired, lpSecurityAttributes, phkResult, lpdwDisposition);
-} // ClrRegCreateKeyEx
-
-LONG ClrRegOpenKeyEx(
-        HKEY hKey,
-        LPCWSTR lpSubKey,
-        DWORD ulOptions,
-        REGSAM samDesired,
-        PHKEY phkResult
-        )
-{
-    HRESULT hr;
-    if (!g_initialized)
-    {
-        hr = ParseRegistryRootConfigValue();
-        if (hr != ERROR_SUCCESS)
-            return hr;
-        g_initialized = true;
-    }
-    
-    if (g_registryRoot != NULL)
-    {
-        NewArrayHolder<WCHAR> lpRedirectedKey(NULL);
-        hr = RedirectKey(samDesired, hKey, lpSubKey, &lpRedirectedKey);
-        // We don't want to touch the registry if we're low on memory and can't redirect properly.  It could lead
-        // to use reading and writing to two separate registries and corrupting both in the process
-        if (hr != ERROR_SUCCESS)
-            return hr;
-        LPCWSTR lpKeyToUse = lpRedirectedKey == NULL ? lpSubKey : lpRedirectedKey;
-        return RegOpenKeyExW(hKey, lpKeyToUse, ulOptions, samDesired, phkResult);
-    }
-    return RegOpenKeyExW(hKey, lpSubKey, ulOptions, samDesired, phkResult);
-}
-
-//
-// Determine whether we're running Offline Ngen for Build Lab based on the settings of several Config Values.
-//
-bool IsNgenOffline()
-{
-    static volatile bool fInitialized = false;
-    static volatile bool fNgenOffline = false;
-    
-    if (!fInitialized)
-    {
-        REGUTIL::CORConfigLevel kCorConfigLevel = static_cast<REGUTIL::CORConfigLevel>(REGUTIL::COR_CONFIG_ENV);
-        CLRConfigStringHolder pwzConfigInstallRoot = REGUTIL::GetConfigString_DontUse_(CLRConfig::INTERNAL_InstallRoot,
-                                                          TRUE /* Prepend Complus */,
-                                                          kCorConfigLevel,
-                                                          FALSE /* fUsePerfCache */);
-        CLRConfigStringHolder pwzConfigNicPath(CLRConfig::GetConfigValue(CLRConfig::UNSUPPORTED_NicPath));
-        CLRConfigStringHolder pwzRegistryRoot(CLRConfig::GetConfigValue(CLRConfig::UNSUPPORTED_RegistryRoot));
-        CLRConfigStringHolder pwzConfigAssemblyPath(CLRConfig::GetConfigValue(CLRConfig::UNSUPPORTED_AssemblyPath));
-        CLRConfigStringHolder pwzConfigAssemblyPath2(CLRConfig::GetConfigValue(CLRConfig::UNSUPPORTED_AssemblyPath2));
-        if (pwzConfigInstallRoot != NULL && 
-                pwzConfigNicPath != NULL &&
-                pwzConfigAssemblyPath != NULL && 
-                pwzConfigAssemblyPath2 != NULL &&
-                pwzRegistryRoot != NULL)
-        {
-            fNgenOffline = true;
-        }
-        fInitialized = true;
-    }
-    
-    return fNgenOffline;
-}
-
-#endif //!FEATURE_UTILCODE_NO_DEPENDENCIES && !FEATURE_CORECLR
diff --git a/src/utilcode/regutil.cpp b/src/utilcode/regutil.cpp
index d611ef965f..c38c38907a 100644
--- a/src/utilcode/regutil.cpp
+++ b/src/utilcode/regutil.cpp
@@ -111,19 +111,6 @@ LPWSTR REGUTIL::EnvGetString(LPCWSTR name, BOOL fPrependCOMPLUS)
 
 #ifdef ALLOW_REGISTRY
 
-#ifndef FEATURE_CORECLR
-
-//*****************************************************************************
-// Gives the use the ability to turn on/off REGUTIL's ability to read from
-// the registry. This is useful in mscoree.dll on startup, in order to avoid
-// loading advapi32 and rpcrt4 until we're ready for them
-//*****************************************************************************
-void REGUTIL::AllowRegistryUse(BOOL fAllowUse)
-{
-    s_fUseRegistry = fAllowUse;
-}// AllowRegistryUse
-
-#endif // !FEATURE_CORECLR
 
 #endif // ALLOW_REGISTRY
 
@@ -522,690 +509,6 @@ DWORD REGUTIL::GetConfigFlag_DontUse_(LPCWSTR name, DWORD bitToSet, BOOL defValu
 
 #ifdef ALLOW_REGISTRY
 
-#ifndef FEATURE_CORECLR
-
-//*****************************************************************************
-// Open's the given key and returns the value desired.  If the key or value is
-// not found, then the default is returned.
-//*****************************************************************************
-long REGUTIL::GetLong(                  // Return value from registry or default.
-    LPCTSTR     szName,                 // Name of value to get.
-    long        iDefault,               // Default value to return if not found.
-    LPCTSTR     szKey,                  // Name of key, NULL==default.
-    HKEY        hKeyVal)                // What key to work on.
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        FORBID_FAULT;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-    
-    long        iValue;                 // The value to read.
-    DWORD       iType;                  // Type of value to get.
-    DWORD       iSize;                  // Size of buffer.
-    HKEY        hKey;                   // Key for the registry entry.
-
-    _ASSERTE(UseRegistry());
-    
-    FAULT_NOT_FATAL(); // We don't report OOM errors here, we return a default value.
-    
-    // Open the key if it is there.
-    if (ERROR_SUCCESS != WszRegOpenKeyEx(hKeyVal, (szKey) ? szKey : FRAMEWORK_REGISTRY_KEY_W, 0, KEY_READ, &hKey))
-        return (iDefault);
-
-    // Read the key value if found.
-    iType = REG_DWORD;
-    iSize = sizeof(long);
-    if (ERROR_SUCCESS != WszRegQueryValueEx(hKey, szName, NULL, 
-            &iType, (LPBYTE)&iValue, &iSize) || iType != REG_DWORD)
-        iValue = iDefault;
-
-    // We're done with the key now.
-    VERIFY(!RegCloseKey(hKey));
-    return (iValue);
-}
-
-
-// Opens or creates desired reg key, then writes iValue
-//*****************************************************************************
-long REGUTIL::SetOrCreateLong(          // Return value from registry or default.
-    LPCTSTR     szName,                 // Name of value to get.
-    long        iValue,                 // Value to set.
-    LPCTSTR     szKey,                  // Name of key, NULL==default.
-    HKEY        hKeyVal)                // What key to work on.
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    _ASSERTE(UseRegistry());
-
-    long        lRtn;                   // Return code.
-    HKEY        hKey;                   // Key for the registry entry.
-
-
-    // Open the key if it is there, else create it
-    if (WszRegCreateKeyEx(hKeyVal,
-                      (szKey) ? szKey : FRAMEWORK_REGISTRY_KEY_W,
-                      0,
-                      NULL,
-                      REG_OPTION_NON_VOLATILE,
-                      KEY_WRITE,
-                      NULL,
-                      &hKey,
-                      NULL) != ERROR_SUCCESS)
-    {
-        return (-1);        
-    }
-                                                    
-    // Read the key value if found.
-    lRtn = WszRegSetValueEx(hKey, szName, NULL, REG_DWORD, (const BYTE *) &iValue, sizeof(DWORD));
-
-    // We're done with the key now.
-    VERIFY(!RegCloseKey(hKey));
-    return (lRtn);
-}
-
-
-//*****************************************************************************
-// Open's the given key and returns the value desired.  If the key or value is
-// not found, then the default is returned.
-//*****************************************************************************
-long REGUTIL::SetLong(                  // Return value from registry or default.
-    LPCTSTR     szName,                 // Name of value to get.
-    long        iValue,                 // Value to set.
-    LPCTSTR     szKey,                  // Name of key, NULL==default.
-    HKEY        hKeyVal)                // What key to work on.
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    _ASSERTE(UseRegistry());
-    
-    long        lRtn;                   // Return code.
-    HKEY        hKey;                   // Key for the registry entry.
-
-    // Open the key if it is there.
-    if (ERROR_SUCCESS != WszRegOpenKey(hKeyVal, (szKey) ? szKey : FRAMEWORK_REGISTRY_KEY_W, &hKey))
-        return (-1);
-
-    // Read the key value if found.
-    lRtn = WszRegSetValueEx(hKey, szName, NULL, REG_DWORD, (const BYTE *) &iValue, sizeof(DWORD));
-
-    // We're done with the key now.
-    VERIFY(!RegCloseKey(hKey));
-    return (lRtn);
-}
-
-//*****************************************************************************
-// Set an entry in the registry of the form:
-// HKEY_CLASSES_ROOT\szKey\szSubkey = szValue.  If szSubkey or szValue are
-// NULL, omit them from the above expression.
-//*****************************************************************************
-BOOL REGUTIL::SetKeyAndValue(           // TRUE or FALSE.
-    LPCTSTR     szKey,                  // Name of the reg key to set.
-    LPCTSTR     szSubkey,               // Optional subkey of szKey.
-    LPCTSTR     szValue)                // Optional value for szKey\szSubkey.
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    _ASSERTE(UseRegistry());
-
-    size_t nLen = _tcslen(szKey) + 1;
-    if (szSubkey)
-        nLen += (_tcslen(szSubkey) + 1);
-
-    NewArrayHolder<TCHAR> rcKey = new (nothrow) TCHAR[nLen]; // Buffer for the full key name.
-    if (rcKey == NULL)
-        return FALSE;
-
-    HKEY hKey = NULL; // Handle to the new reg key.
-
-    // Init the key with the base key name.
-    _tcscpy_s(rcKey, nLen, szKey);
-
-    // Append the subkey name (if there is one).
-    if (szSubkey != NULL)
-    {
-        _tcscat_s(rcKey, nLen, _T("\\"));
-        _tcscat_s(rcKey, nLen, szSubkey);
-    }
-
-    // Create the registration key.
-    if (WszRegCreateKeyEx(HKEY_CLASSES_ROOT, rcKey, 0, NULL,
-                        REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,
-                        &hKey, NULL) != ERROR_SUCCESS)
-        return(FALSE);
-
-    // Set the value (if there is one).
-    if (szValue != NULL)
-         if( WszRegSetValueEx(hKey, NULL, 0, REG_SZ, (BYTE *) szValue,
-                         (Wszlstrlen(szValue)+1) * sizeof(TCHAR)) != ERROR_SUCCESS ) {
-              VERIFY(!RegCloseKey(hKey));
-              return(FALSE);
-         }            
-    	
-    VERIFY(!RegCloseKey(hKey));
-    return(TRUE);
-}
-
-
-//*****************************************************************************
-// Delete an entry in the registry of the form:
-// HKEY_CLASSES_ROOT\szKey\szSubkey.
-//*****************************************************************************
-LONG REGUTIL::DeleteKey(                // TRUE or FALSE.
-    LPCTSTR     szKey,                  // Name of the reg key to set.
-    LPCTSTR     szSubkey)               // Subkey of szKey.
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    _ASSERTE(UseRegistry());
-
-    size_t nLen = _tcslen(szKey) + 1;
-    if (szSubkey)
-        nLen += (_tcslen(szSubkey) + 1);
-
-    NewArrayHolder<TCHAR> rcKey = new (nothrow) TCHAR[nLen]; // Buffer for the full key name.
-    if (rcKey == NULL)
-        return ERROR_NOT_ENOUGH_MEMORY;
-
-    // Init the key with the base key name.
-    _tcscpy_s(rcKey, nLen, szKey);
-
-    // Append the subkey name (if there is one).
-    if (szSubkey != NULL)
-    {
-        _tcscat_s(rcKey, nLen, _T("\\"));
-        _tcscat_s(rcKey, nLen, szSubkey);
-    }
-
-    // Delete the registration key.
-    return WszRegDeleteKey(HKEY_CLASSES_ROOT, rcKey);
-}
-
-
-//*****************************************************************************
-// Open the key, create a new keyword and value pair under it.
-//*****************************************************************************
-BOOL REGUTIL::SetRegValue(              // Return status.
-    LPCTSTR     szKeyName,              // Name of full key.
-    LPCTSTR     szKeyword,              // Name of keyword.
-    LPCTSTR     szValue)                // Value of keyword.
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    _ASSERTE(UseRegistry());
-
-    HKEY        hKey;                   // Handle to the new reg key.
-
-    // Create the registration key.
-    if (WszRegCreateKeyEx(HKEY_CLASSES_ROOT, szKeyName, 0, NULL,
-                        REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,
-                        &hKey, NULL) != ERROR_SUCCESS)
-        return (FALSE);
-
-    // Set the value (if there is one).
-    if (szValue != NULL)
-        if( WszRegSetValueEx(hKey, szKeyword, 0, REG_SZ, (BYTE *)szValue, 
-        	(Wszlstrlen(szValue)+1) * sizeof(TCHAR)) != ERROR_SUCCESS) {
-              VERIFY(!RegCloseKey(hKey));
-              return(FALSE);
-        }                	
-
-    VERIFY(!RegCloseKey(hKey));
-    return (TRUE);
-}
-
-
-//*****************************************************************************
-// Does standard registration of a CoClass with a progid.
-//*****************************************************************************
-HRESULT REGUTIL::RegisterCOMClass(      // Return code.
-    REFCLSID    rclsid,                 // Class ID.
-    LPCTSTR     szDesc,                 // Description of the class.
-    LPCTSTR     szProgIDPrefix,         // Prefix for progid.
-    int         iVersion,               // Version # for progid.
-    LPCTSTR     szClassProgID,          // Class progid.
-    LPCTSTR     szThreadingModel,       // What threading model to use.
-    LPCTSTR     szModule,               // Path to class.
-    HINSTANCE   hInst,                  // Handle to module being registered
-    LPCTSTR     szAssemblyName,         // Optional Assembly,
-    LPCTSTR     szVersion,              // Optional Runtime version (directory containing runtime)
-    BOOL        fExternal,              // flag - External to mscoree.
-    BOOL        fRelativePath)          // flag - Relative path in szModule 
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-    
-    WCHAR       rcCLSID[256];           // CLSID\\szID.
-    WCHAR       rcInproc[_MAX_PATH+64]; // CLSID\\InprocServer32
-    WCHAR       rcProgID[256];          // szProgIDPrefix.szClassProgID
-    WCHAR       rcIndProgID[256];       // rcProgID.iVersion
-    WCHAR       rcShim[_MAX_PATH];
-    HRESULT     hr;
-
-    // Format the prog ID values.
-    VERIFY(_snwprintf_s(rcIndProgID, _countof(rcIndProgID), _TRUNCATE, W("%s.%s"), szProgIDPrefix, szClassProgID));
-
-    VERIFY(_snwprintf_s(rcProgID, _countof(rcProgID), _TRUNCATE, W("%s.%d"), rcIndProgID, iVersion));
-
-    // Do the initial portion.
-    if (FAILED(hr = RegisterClassBase(rclsid, szDesc, rcProgID, rcIndProgID, rcCLSID, NumItems(rcCLSID))))
-        return (hr);
-    
-    VERIFY(_snwprintf_s(rcInproc, _countof(rcInproc), _TRUNCATE, W("%s\\%s"), rcCLSID, W("InprocServer32")));
-
-    if (!fExternal){
-        SetKeyAndValue(rcCLSID, W("InprocServer32"), szModule);
-    }
-    else{
-        LPCTSTR pSep = szModule;
-        if (!fRelativePath && szModule) {
-            pSep = wcsrchr(szModule, W('\\'));
-            if(pSep == NULL)
-                pSep = szModule;
-            else 
-                pSep++;
-        }        
-        HMODULE hMod = WszLoadLibrary(W("mscoree.dll"));
-        if (!hMod)
-            return E_FAIL;
-        
-        DWORD ret;
-        VERIFY(ret = WszGetModuleFileName(hMod, rcShim, NumItems(rcShim)));
-        FreeLibrary(hMod);        
-        if( !ret ) 
-        	return E_FAIL;	       
-        
-        // Set the server path.
-        SetKeyAndValue(rcCLSID, W("InprocServer32"), rcShim);
-        if(pSep)
-            SetKeyAndValue(rcCLSID, W("Server"), pSep);
-
-        if(szAssemblyName) {
-            SetRegValue(rcInproc, W("Assembly"), szAssemblyName);
-            SetRegValue(rcInproc, W("Class"), rcIndProgID);
-        }
-    }
-
-    // Set the runtime version, it needs to be passed in from the outside
-    if(szVersion != NULL) {
-        LPCTSTR pSep2 = NULL;
-        LPTSTR pSep1 = const_cast<LPTSTR>(wcsrchr(szVersion, W('\\')));
-        if(pSep1 != NULL) {
-            *pSep1 = '\0';
-            pSep2 = wcsrchr(szVersion, W('\\'));
-            if (!pSep2)
-                pSep2 = szVersion;
-            else
-                pSep2 = pSep2++;    // exclude '\\'
-        }
-        else 
-            pSep2 = szVersion;
-
-        size_t bufLen = wcslen(rcInproc)+wcslen(pSep2)+2;
-        WCHAR* rcVersion = new (nothrow) WCHAR[bufLen];
-        if(rcVersion==NULL)
-            return (E_OUTOFMEMORY);
-        wcscpy_s(rcVersion, bufLen, rcInproc);
-        wcscat_s(rcVersion, bufLen, W("\\"));
-        wcscat_s(rcVersion, bufLen, pSep2);
-        SetRegValue(rcVersion, W("ImplementedInThisVersion"), W(""));
-        delete[] rcVersion;
-
-        if(pSep1 != NULL)
-            *pSep1 = W('\\');
-    }
-
-    // Add the threading model information.
-    SetRegValue(rcInproc, W("ThreadingModel"), szThreadingModel);
-    return (S_OK);
-}
-
-
-
-//*****************************************************************************
-// Does standard registration of a CoClass with a progid.
-// NOTE: This is the non-side-by-side execution version.
-//*****************************************************************************
-HRESULT REGUTIL::RegisterCOMClass(      // Return code.
-    REFCLSID    rclsid,                 // Class ID.
-    LPCTSTR     szDesc,                 // Description of the class.
-    LPCTSTR     szProgIDPrefix,         // Prefix for progid.
-    int         iVersion,               // Version # for progid.
-    LPCTSTR     szClassProgID,          // Class progid.
-    LPCTSTR     szThreadingModel,       // What threading model to use.
-    LPCTSTR     szModule,               // Path to class.
-    BOOL        bInprocServer)          // Whether we register the server as inproc or local
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-    
-    WCHAR       rcCLSID[256];           // CLSID\\szID.
-    WCHAR       rcInproc[_MAX_PATH+64]; // CLSID\\InprocServer32
-    WCHAR       rcProgID[256];          // szProgIDPrefix.szClassProgID
-    WCHAR       rcIndProgID[256];       // rcProgID.iVersion
-    HRESULT     hr;
-
-    // Format the prog ID values.
-    VERIFY(_snwprintf_s(rcIndProgID, _countof(rcIndProgID), _TRUNCATE, W("%s.%s"), szProgIDPrefix, szClassProgID));
-
-    VERIFY(_snwprintf_s(rcProgID, _countof(rcProgID), _TRUNCATE, W("%s.%d"), rcIndProgID, iVersion));
-
-    // Do the initial portion.
-    if (FAILED(hr = RegisterClassBase(rclsid, szDesc, rcProgID, rcIndProgID, rcCLSID, NumItems(rcCLSID))))
-        return (hr);
-
-    WCHAR *szServerType = bInprocServer ? W("InprocServer32") : W("LocalServer32");
-
-    // Set the server path.
-    SetKeyAndValue(rcCLSID, szServerType , szModule);
-
-    // Add the threading model information.
-    VERIFY(_snwprintf_s(rcInproc, _countof(rcInproc), _TRUNCATE, W("%s\\%s"), rcCLSID, szServerType));
-   
-    SetRegValue(rcInproc, W("ThreadingModel"), szThreadingModel);
-    return (S_OK);
-}
-
-
-
-//*****************************************************************************
-// Register the basics for a in proc server.
-//*****************************************************************************
-HRESULT REGUTIL::RegisterClassBase(     // Return code.
-    REFCLSID    rclsid,                 // Class ID we are registering.
-    LPCTSTR     szDesc,                 // Class description.
-    LPCTSTR     szProgID,               // Class prog ID.
-    LPCTSTR     szIndepProgID,          // Class version independant prog ID.
-    __out_ecount(cchOutCLSID) LPTSTR      szOutCLSID,             // CLSID formatted in character form.
-    DWORD      cchOutCLSID)           // Out CLS ID buffer size
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-    
-    TCHAR       szID[64];               // The class ID to register.
-
-    // Create some base key strings.
-    GuidToLPWSTR(rclsid, szID, NumItems(szID));
-
-    size_t nLen = _tcslen(_T("CLSID\\")) + _tcslen( szID) + 1;
-    if( cchOutCLSID < nLen ) 	
-	return E_INVALIDARG;
-
-    _tcscpy_s(szOutCLSID, cchOutCLSID, W("CLSID\\"));
-    _tcscat_s(szOutCLSID, cchOutCLSID, szID);
-
-    // Create ProgID keys.
-    SetKeyAndValue(szProgID, NULL, szDesc);
-    SetKeyAndValue(szProgID, W("CLSID"), szID);
-
-    // Create VersionIndependentProgID keys.
-    SetKeyAndValue(szIndepProgID, NULL, szDesc);
-    SetKeyAndValue(szIndepProgID, W("CurVer"), szProgID);
-    SetKeyAndValue(szIndepProgID, W("CLSID"), szID);
-
-    // Create entries under CLSID.
-    SetKeyAndValue(szOutCLSID, NULL, szDesc);
-    SetKeyAndValue(szOutCLSID, W("ProgID"), szProgID);
-    SetKeyAndValue(szOutCLSID, W("VersionIndependentProgID"), szIndepProgID);
-    SetKeyAndValue(szOutCLSID, W("NotInsertable"), NULL);
-    return (S_OK);
-}
-
-
-
-//*****************************************************************************
-// Unregister the basic information in the system registry for a given object
-// class.
-//*****************************************************************************
-HRESULT REGUTIL::UnregisterCOMClass(    // Return code.
-    REFCLSID    rclsid,                 // Class ID we are registering.
-    LPCTSTR     szProgIDPrefix,         // Prefix for progid.
-    int         iVersion,               // Version # for progid.
-    LPCTSTR     szClassProgID,          // Class progid.
-    BOOL        fExternal)              // flag - External to mscoree.
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-    
-    WCHAR       rcCLSID[64];            // CLSID\\szID.
-    WCHAR       rcProgID[128];          // szProgIDPrefix.szClassProgID
-    WCHAR       rcIndProgID[128];       // rcProgID.iVersion
-
-    // Format the prog ID values.
-    VERIFY(_snwprintf_s(rcProgID, _countof(rcProgID), _TRUNCATE, W("%s.%s"), szProgIDPrefix, szClassProgID));
-
-    VERIFY(_snwprintf_s(rcIndProgID, _countof(rcIndProgID), _TRUNCATE, W("%s.%d"), rcProgID, iVersion));
-
-    UnregisterClassBase(rclsid, rcProgID, rcIndProgID, rcCLSID, NumItems(rcCLSID));
-    DeleteKey(rcCLSID, W("InprocServer32"));
-    if (fExternal){
-        DeleteKey(rcCLSID, W("Server"));
-        DeleteKey(rcCLSID, W("Version"));
-    }
-    GuidToLPWSTR(rclsid, rcCLSID, NumItems(rcCLSID));
-    DeleteKey(W("CLSID"), rcCLSID);
-    return (S_OK);
-}
-
-
-//*****************************************************************************
-// Unregister the basic information in the system registry for a given object
-// class.
-// NOTE: This is the non-side-by-side execution version.
-//*****************************************************************************
-HRESULT REGUTIL::UnregisterCOMClass(    // Return code.
-    REFCLSID    rclsid,                 // Class ID we are registering.
-    LPCTSTR     szProgIDPrefix,         // Prefix for progid.
-    int         iVersion,               // Version # for progid.
-    LPCTSTR     szClassProgID)          // Class progid.
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-    
-    WCHAR       rcCLSID[64];            // CLSID\\szID.
-    WCHAR       rcProgID[128];          // szProgIDPrefix.szClassProgID
-    WCHAR       rcIndProgID[128];       // rcProgID.iVersion
-
-    // Format the prog ID values.
-    VERIFY(_snwprintf_s(rcProgID, _countof(rcProgID), _TRUNCATE, W("%s.%s"), szProgIDPrefix, szClassProgID));
-
-    VERIFY(_snwprintf_s(rcIndProgID, _countof(rcIndProgID), _TRUNCATE, W("%s.%d"), rcProgID, iVersion));
-
-    UnregisterClassBase(rclsid, rcProgID, rcIndProgID, rcCLSID, NumItems(rcCLSID));
-    DeleteKey(rcCLSID, W("InprocServer32"));
-    DeleteKey(rcCLSID, W("LocalServer32"));
-    
-    GuidToLPWSTR(rclsid, rcCLSID, NumItems(rcCLSID));
-    DeleteKey(W("CLSID"), rcCLSID);
-    return (S_OK);
-}
-
-
-//*****************************************************************************
-// Delete the basic settings for an inproc server.
-//*****************************************************************************
-HRESULT REGUTIL::UnregisterClassBase(   // Return code.
-    REFCLSID    rclsid,                 // Class ID we are registering.
-    LPCTSTR     szProgID,               // Class prog ID.
-    LPCTSTR     szIndepProgID,          // Class version independant prog ID.
-    __out_ecount(cchOutCLSID) LPTSTR      szOutCLSID,             // Return formatted class ID here.
-    DWORD      cchOutCLSID)           // Out CLS ID buffer size    
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-    
-    TCHAR       szID[64];               // The class ID to register.
-
-    // Create some base key strings.
-    GuidToLPWSTR(rclsid, szID, NumItems(szID));
-    size_t nLen = _tcslen(_T("CLSID\\")) + _tcslen( szID) + 1;
-    if( cchOutCLSID < nLen ) 	
-	return E_INVALIDARG;
-
-    _tcscpy_s(szOutCLSID, cchOutCLSID, W("CLSID\\"));
-    _tcscat_s(szOutCLSID, cchOutCLSID, szID);
-
-    // Delete the version independant prog ID settings.
-    DeleteKey(szIndepProgID, W("CurVer"));
-    DeleteKey(szIndepProgID, W("CLSID"));
-    WszRegDeleteKey(HKEY_CLASSES_ROOT, szIndepProgID);
-
-    // Delete the prog ID settings.
-    DeleteKey(szProgID, W("CLSID"));
-    WszRegDeleteKey(HKEY_CLASSES_ROOT, szProgID);
-
-    // Delete the class ID settings.
-    DeleteKey(szOutCLSID, W("ProgID"));
-    DeleteKey(szOutCLSID, W("VersionIndependentProgID"));
-    DeleteKey(szOutCLSID, W("NotInsertable"));
-    WszRegDeleteKey(HKEY_CLASSES_ROOT, szOutCLSID);
-    return (S_OK);
-}
-
-
-//*****************************************************************************
-// Register a type library.
-//*****************************************************************************
-HRESULT REGUTIL::RegisterTypeLib(       // Return code.
-    REFGUID     rtlbid,                 // TypeLib ID we are registering.
-    int         iVersion,               // Typelib version.
-    LPCTSTR     szDesc,                 // TypeLib description.
-    LPCTSTR     szModule)               // Path to the typelib.
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-    
-    WCHAR       szID[64];               // The typelib ID to register.
-    WCHAR       szTLBID[256];           // TypeLib\\szID.
-    WCHAR       szHelpDir[_MAX_PATH];
-    WCHAR       szDrive[_MAX_DRIVE] = {0};
-    WCHAR       szDir[_MAX_DIR] = {0};
-    WCHAR       szVersion[64];
-    LPWSTR      szTmp;
-
-    // Create some base key strings.
-    GuidToLPWSTR(rtlbid, szID, NumItems(szID));
-
-    _tcscpy_s(szTLBID, _countof(szTLBID), W("TypeLib\\"));
-    _tcscat_s(szTLBID, _countof(szTLBID), szID);
-
-    VERIFY(_snwprintf_s(szVersion, _countof(szVersion), _TRUNCATE, W("%d.0"), iVersion));
-
-    // Create Typelib keys.
-    SetKeyAndValue(szTLBID, NULL, NULL);
-    SetKeyAndValue(szTLBID, szVersion, szDesc);
-    _tcscat_s(szTLBID, _countof(szTLBID), W("\\"));
-    _tcscat_s(szTLBID, _countof(szTLBID), szVersion);
-    SetKeyAndValue(szTLBID, W("0"), NULL);
-    SetKeyAndValue(szTLBID, W("0\\win32"), szModule);
-    SetKeyAndValue(szTLBID, W("FLAGS"), W("0"));
-    SplitPath(szModule, szDrive, _MAX_DRIVE, szDir, _MAX_DIR, NULL, 0, NULL, 0);
-    _tcscpy_s(szHelpDir, _countof(szHelpDir), szDrive);
-    if ((szTmp = CharPrev(szDir, szDir + Wszlstrlen(szDir))) != NULL)
-        *szTmp = '\0';
-    _tcscat_s(szHelpDir, _countof(szHelpDir), szDir);
-    SetKeyAndValue(szTLBID, W("HELPDIR"), szHelpDir);
-    return (S_OK);
-}
-
-
-//*****************************************************************************
-// Remove the registry keys for a type library.
-//*****************************************************************************
-HRESULT REGUTIL::UnregisterTypeLib(     // Return code.
-    REFGUID     rtlbid,                 // TypeLib ID we are registering.
-    int         iVersion)               // Typelib version.
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-    
-    WCHAR       szID[64];               // The typelib ID to register.
-    WCHAR       szTLBID[256];           // TypeLib\\szID.
-    WCHAR       szTLBVersion[256];      // TypeLib\\szID\\szVersion
-    WCHAR       szVersion[64];
-
-    // Create some base key strings.
-    GuidToLPWSTR(rtlbid, szID, NumItems(szID));
-
-    VERIFY(_snwprintf_s(szVersion, _countof(szVersion), _TRUNCATE, W("%d.0"), iVersion));
-
-    _tcscpy_s(szTLBID, _countof(szTLBID), W("TypeLib\\"));
-    _tcscat_s(szTLBID, _countof(szTLBID), szID);
-    _tcscpy_s(szTLBVersion, _countof(szTLBVersion), szTLBID);
-    _tcscat_s(szTLBVersion, _countof(szTLBVersion), W("\\"));
-    _tcscat_s(szTLBVersion, _countof(szTLBVersion), szVersion);
-
-    // Delete Typelib keys.
-    DeleteKey(szTLBVersion, W("HELPDIR"));
-    DeleteKey(szTLBVersion, W("FLAGS"));
-    DeleteKey(szTLBVersion, W("0\\win32"));
-    DeleteKey(szTLBVersion, W("0"));
-    DeleteKey(szTLBID, szVersion);
-    WszRegDeleteKey(HKEY_CLASSES_ROOT, szTLBID);
-    return (0);
-}
-
-#endif // !FEATURE_CORECLR
 
 
 //
diff --git a/src/utilcode/sortversioning.cpp b/src/utilcode/sortversioning.cpp
index 5420947842..65781cdc1a 100644
--- a/src/utilcode/sortversioning.cpp
+++ b/src/utilcode/sortversioning.cpp
@@ -136,230 +136,6 @@ namespace SortVersioning
         return i;
     }
 
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-    ////////////////////////////////////////////////////////////////////////////
-    //
-    //  LoadSortModuleAndInvariant()
-    //
-    //  Attempts to load the given dll. If that is successful, attempts to
-    //  load the invariant data. If that is successful, returns the module handle
-    //  and the addresses of the SortGetHandle function and SortCloseHandle function
-    //
-    //  failure is indicated by returning NULL for the module handle and the
-    //  function addresses
-    //
-    ////////////////////////////////////////////////////////////////////////////
-
-    HMODULE LoadSortModuleAndInvariant(
-        __in LPCWSTR sDllName,
-        __in DWORD dwVersion,
-        __out SORTGETHANDLE* ppGetHandle,
-        __out SORTCLOSEHANDLE* ppCloseHandle
-        )
-    {
-        *ppGetHandle = NULL;
-        *ppCloseHandle = NULL;
-        HMODULE hSort;
-
-        if(FAILED(UtilCode::LoadLibraryShim(sDllName, NULL, NULL, &hSort))) 
-        {            
-            return NULL;
-        }
-
-        SORTGETHANDLE pGetHandle = (SORTGETHANDLE)GetProcAddress(hSort, "SortGetHandle");
-        SORTCLOSEHANDLE pCloseHandle = (SORTCLOSEHANDLE)GetProcAddress(hSort, "SortCloseHandle");
-
-        // If we didn't load the procs, then remember that
-        if (pCloseHandle == NULL || pGetHandle == NULL)
-        {
-            ::FreeLibrary(hSort);
-            return NULL;
-        }
-
-        // Verify that the data file's available
-        NLSVERSIONINFO  sortVersion;
-        sortVersion.dwNLSVersionInfoSize = sizeof(NLSVERSIONINFO);
-        sortVersion.dwNLSVersion = dwVersion;
-        sortVersion.dwDefinedVersion = dwVersion;
-
-        // Invariant must be there and is kinda common, so we'll just get it
-        PSORTHANDLE pSort = pGetHandle(W(""), &sortVersion, NULL);
-        if (!pSort)
-        {
-            // Yikes, invariant failed, forget about it.
-            ::FreeLibrary(hSort);
-            return NULL;
-        }
-
-        // Since we found it, may as well remember it.
-        const SORTHANDLE * const pSortInHash = InsertSortHashNode(pSort);
-
-        // If we got a different one back then free the one we added
-        if (pSortInHash != pSort && pSortInHash)
-        {
-            // We got a different one from the hash (someone beat us to the cache)
-            // so use that and discard the new one.
-            pCloseHandle(pSort);
-        }
-
-        *ppGetHandle = pGetHandle;
-        *ppCloseHandle = pCloseHandle;
-        return hSort;
-    }
-
-    // Attempts to load a Sort DLL.  If this fails, the values of the __out parameters are unchanged.
-    __success(return)
-    BOOL LoadSortDllAndPublish(
-        __in  LPCWSTR sDllName, 
-        __in  DWORD dwVersion, 
-        __out __encoded_pointer SORTGETHANDLE* ppGetHandle,
-        __out __encoded_pointer SORTCLOSEHANDLE* ppCloseHandle,
-        __out HMODULE* phSortDll)
-    {
-        HMODULE hSortDll;
-        SORTGETHANDLE   pGetHandle;
-        SORTCLOSEHANDLE pCloseHandle;
-        
-        hSortDll = LoadSortModuleAndInvariant(sDllName, dwVersion, &pGetHandle, &pCloseHandle);        
-
-        if(hSortDll != NULL) {
-            *phSortDll = hSortDll;
-            *ppGetHandle = (SORTGETHANDLE)EncodePointer(pGetHandle);
-            *ppCloseHandle = (SORTCLOSEHANDLE)EncodePointer(pCloseHandle);
-            return TRUE;
-        }
-
-        return FALSE;
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-    //
-    //  GetSortGetHandle()
-    //
-    //  Get the SortGetHandle() function for the proper dll version.
-    //
-    ////////////////////////////////////////////////////////////////////////////
-    SORTGETHANDLE GetSortGetHandle(__in DWORD dwVersion)
-    {
-        if(dwVersion == SORT_VERSION_DEFAULT)
-        {
-            // If we haven't tried to load the module/proc before do so now
-            if (g_hSortDefault == (HMODULE)-1)
-            {
-                LoadSortDllAndPublish(SORT_DEFAULT_DLL_NAME, SORT_VERSION_DEFAULT, &g_pDefaultGetHandle, &g_pDefaultCloseHandle, &g_hSortDefault);
-            }
-
-            // This check is necessary because the LoadSortDllAndPublish call may have failed since some platforms
-            // won't have nlssorting.dll (e.g. Windows 8 and above).
-            if (g_hSortDefault != (HMODULE)-1) 
-            {
-                return (SORTGETHANDLE)DecodePointer(g_pDefaultGetHandle);
-            }
-        }
-
-        HMODULE* pHSortModule; 
-        SORTGETHANDLE*   ppGetHandle;
-        SORTCLOSEHANDLE* ppCloseHandle;
-
-        if(dwVersion == SORT_VERSION_V4)
-        {
-            ppGetHandle = &g_pV4GetHandle;
-            ppCloseHandle = &g_pV4CloseHandle;
-            pHSortModule = &g_hSortCompatV4;
-        } 
-        else if(dwVersion == SORT_VERSION_WHIDBEY) 
-        {
-            ppGetHandle = &g_pV2GetHandle;
-            ppCloseHandle = &g_pV2CloseHandle;
-            pHSortModule = &g_hSortCompatV2;
-        }
-        else
-        {
-            // Unsupported sorting version.
-            return NULL;
-        }
-
-        if(*pHSortModule == (HMODULE) -1)
-        {
-            // get module name - the module name should be "Sort"+dwVersion.ToString("x8")+".dll"
-            WCHAR moduleName[] = W("Sort00000000.dll");
-            // replace the "00000000" with the hexadecimal of dwVersion
-            LPCWSTR hex = W("0123456789abcdef");
-            WCHAR* p = &moduleName[4+8]; // position at end of number part of dll name
-
-            unsigned int value = dwVersion;
-
-            while (value != 0 && p != moduleName) {
-                int digit = value & 0xF;
-                *--p = hex[digit];
-                value >>= 4;
-            }
-
-            if(!LoadSortDllAndPublish(&moduleName[0], dwVersion, ppGetHandle, ppCloseHandle, pHSortModule)) 
-            {
-                // We failed to load a versioned sort dll, try to fall back to the current version.
-                // If we haven't tried to load the module/proc before do so now
-                if (g_hSortDefault == (HMODULE)-1)
-                {
-                    LoadSortDllAndPublish(SORT_DEFAULT_DLL_NAME, SORT_VERSION_DEFAULT, &g_pDefaultGetHandle, &g_pDefaultCloseHandle, &g_hSortDefault);
-                }
-
-                *pHSortModule = g_hSortDefault;
-                *ppCloseHandle = g_pDefaultCloseHandle;
-                *ppGetHandle = g_pDefaultGetHandle;
-            }           
-        }
-
-        // At this point, we've either loaded a sorting dll or we've exausted all options.
-        if(*pHSortModule == (HMODULE) -1)
-        {
-            // Couldn't find anything, give up.
-            return NULL;
-        }
-        else
-        {
-            return (SORTGETHANDLE)DecodePointer(*ppGetHandle);
-        }
-
-        // Unknown version requested
-        return NULL;
-    }
-
-    void DoSortCloseHandle(__in DWORD dwVersion, __in PSORTHANDLE pSort)
-    {
-        if (dwVersion == SORT_VERSION_DEFAULT)
-        {
-            SORTCLOSEHANDLE pDefaultCloseHandle = (SORTCLOSEHANDLE)DecodePointer(g_pDefaultCloseHandle);
-            if(pDefaultCloseHandle != NULL)
-            {
-                (pDefaultCloseHandle)(pSort);
-                return;
-            }
-        }
-
-        if (dwVersion == SORT_VERSION_V4)
-        {
-            SORTCLOSEHANDLE pV4CloseHandle = (SORTCLOSEHANDLE)DecodePointer(g_pV4CloseHandle);
-            if(pV4CloseHandle != NULL)
-            {
-                (pV4CloseHandle)(pSort);
-                return;
-            }
-        }
-
-
-        if (dwVersion == SORT_VERSION_WHIDBEY) 
-        {
-            SORTCLOSEHANDLE pV2CloseHandle = (SORTCLOSEHANDLE)DecodePointer(g_pV2CloseHandle);
-            if(pV2CloseHandle != NULL)
-            {
-                (pV2CloseHandle)(pSort);
-                return;
-            }
-        }
-    }
-
-#else // !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
 
     SORTGETHANDLE GetSortGetHandle(__in DWORD dwVersion)
     {
@@ -370,7 +146,6 @@ namespace SortVersioning
     {
     }
 
-#endif // !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
 
     ////////////////////////////////////////////////////////////////////////////
     //
@@ -663,26 +438,7 @@ namespace SortVersioning
     ////////////////////////////////////////////////////////////////////////////
     DWORD SortNLSVersion()
     {
-#ifdef FEATURE_CORECLR
         return SORT_VERSION_DEFAULT;
-#else
-        static bool sortNLSVersionConfigChecked = false;
-        static DWORD sortNLSVersion = SORT_VERSION_DEFAULT;
-
-        if(!sortNLSVersionConfigChecked)
-        {
-            BEGIN_SO_INTOLERANT_CODE_NO_THROW_CHECK_THREAD(return false);
-            sortNLSVersion = CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CompatSortNLSVersion);
-            if(sortNLSVersion == 0)
-            {
-                sortNLSVersion = SORT_VERSION_DEFAULT;
-            }
-            END_SO_INTOLERANT_CODE;
-
-            sortNLSVersionConfigChecked = true;
-        }
-        return sortNLSVersion;
-#endif // !FEATURE_CORECLR
     }
 
     ////////////////////////////////////////////////////////////////////////////
diff --git a/src/utilcode/stacktrace.cpp b/src/utilcode/stacktrace.cpp
index 858fac723e..3dee1802f4 100644
--- a/src/utilcode/stacktrace.cpp
+++ b/src/utilcode/stacktrace.cpp
@@ -949,7 +949,7 @@ void MagicDeinit(void)
     }
 }
 
-#if defined(_TARGET_X86_) && defined(FEATURE_CORECLR)
+#if defined(_TARGET_X86_)
 /****************************************************************************
 * ClrCaptureContext *
 *-------------------*
@@ -989,4 +989,4 @@ ClrCaptureContext(__out PCONTEXT ctx)
         ret  4
     }
 }
-#endif // _TARGET_X86_ && FEATURE_CORECLR
+#endif // _TARGET_X86
diff --git a/src/utilcode/stresslog.cpp b/src/utilcode/stresslog.cpp
index d364b06dd6..91c5c0e8ef 100644
--- a/src/utilcode/stresslog.cpp
+++ b/src/utilcode/stresslog.cpp
@@ -608,12 +608,7 @@ FORCEINLINE BOOL StressLog::InlinedETWLogOn(unsigned facility, unsigned level)
     STATIC_CONTRACT_LEAF;
     STATIC_CONTRACT_SUPPORTS_DAC;
 
-#if defined(FEATURE_EVENT_TRACE) && !defined(FEATURE_CORECLR) && !defined(DACCESS_COMPILE)
-    return ((Microsoft_Windows_DotNETRuntimeStressHandle != 0) && 
-        (ETW_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_STRESS_PROVIDER_Context, (UCHAR)level, facility) != 0));
-#else
     return FALSE;
-#endif
 }
 
 BOOL StressLog::ETWLogOn(unsigned facility, unsigned level)
@@ -671,28 +666,6 @@ void StressLog::LogMsg (unsigned level, unsigned facility, int cArgs, const char
     }
 
 // Stress Log ETW feature available only on the desktop versions of the runtime
-#if !defined(FEATURE_CORECLR)
-    // The previous LogMsg call could have modified the Args, so we need to reset it
-    if(InlinedETWLogOn(facility, level))
-    {
-#define MAX_STRESSLOG_DATA_ETW_LENGTH 256
-        CHAR logMessage[MAX_STRESSLOG_DATA_ETW_LENGTH];
-
-        va_start(Args, format);
-        ULONG messageLength = (USHORT)_vsnprintf_s(logMessage, COUNTOF(logMessage), MAX_STRESSLOG_DATA_ETW_LENGTH-1, format, Args);
-        va_end(Args);
-        
-        if(messageLength >= 0 && 
-           messageLength < MAX_STRESSLOG_DATA_ETW_LENGTH) // this condition has been added to make prefast happy
-        {
-            logMessage[messageLength] = 0;
-        }
-        messageLength++;
-        logMessage[MAX_STRESSLOG_DATA_ETW_LENGTH-1] = 0;
-        FireEtwStressLogEvent_V1((UINT32)facility, (UCHAR)level, logMessage, GetClrInstanceId());
-#undef MAX_STRESSLOG_DATA_ETW_LENGTH
-    }
-#endif // !FEATURE_CORECLR
 #endif //!DACCESS_COMPILE
 }
 
diff --git a/src/utilcode/tlbutils.cpp b/src/utilcode/tlbutils.cpp
deleted file mode 100644
index ed42c28fc8..0000000000
--- a/src/utilcode/tlbutils.cpp
+++ /dev/null
@@ -1,221 +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.
-
-//
-// Utilities used to help manipulating typelibs.
-
-#include "stdafx.h"                     // Precompiled header key.
-
-#include "tlbutils.h"
-#include "dispex.h"
-#include "posterror.h"
-#include "ndpversion.h"
-
-#define CUSTOM_MARSHALER_ASM ", CustomMarshalers, Version=" VER_ASSEMBLYVERSION_STR ", Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
-
-static const LPCWSTR        DLL_EXTENSION           = {W(".dll")};
-static const int            DLL_EXTENSION_LEN       = 4;
-static const LPCWSTR        EXE_EXTENSION           = {W(".exe")};
-static const int            EXE_EXTENSION_LEN       = 4;
-
-const StdConvertibleItfInfo aStdConvertibleInterfaces[] = 
-{
-    { "System.Runtime.InteropServices.Expando.IExpando", (GUID*)&IID_IDispatchEx, 
-      "System.Runtime.InteropServices.CustomMarshalers.ExpandoToDispatchExMarshaler" CUSTOM_MARSHALER_ASM, "IExpando" },
-
-    { "System.Reflection.IReflect", (GUID*)&IID_IDispatchEx, 
-      "System.Runtime.InteropServices.CustomMarshalers.ExpandoToDispatchExMarshaler" CUSTOM_MARSHALER_ASM, "IReflect" },
-
-    { "System.Collections.IEnumerator", (GUID*)&IID_IEnumVARIANT,
-      "System.Runtime.InteropServices.CustomMarshalers.EnumeratorToEnumVariantMarshaler" CUSTOM_MARSHALER_ASM, "" },
-
-    { "System.Type", (GUID*)&IID_ITypeInfo,
-      "System.Runtime.InteropServices.CustomMarshalers.TypeToTypeInfoMarshaler" CUSTOM_MARSHALER_ASM, "" },
-};
-
-// This method returns the custom marshaler info to convert the native interface
-// to its managed equivalent. Or null if the interface is not a standard convertible interface.
-const StdConvertibleItfInfo *GetConvertionInfoFromNativeIID(REFGUID rGuidNativeItf)
-{
-    CONTRACT (const StdConvertibleItfInfo*)
-    {
-        NOTHROW;
-        POSTCONDITION(CheckPointer(RETVAL, NULL_OK));
-    }
-    CONTRACT_END;
-    
-    // Look in the table of interfaces that have standard convertions to see if the
-    // specified interface is there.
-    for (int i = 0; i < sizeof(aStdConvertibleInterfaces) / sizeof(StdConvertibleItfInfo); i++)
-    {
-        if (IsEqualGUID(rGuidNativeItf, *(aStdConvertibleInterfaces[i].m_pNativeTypeIID)))
-            RETURN &aStdConvertibleInterfaces[i];
-    }
-
-    // The interface is not in the table.
-    RETURN NULL;
-}
-
-//*****************************************************************************
-// Given a typelib, determine the managed namespace name.
-//*****************************************************************************
-HRESULT GetNamespaceNameForTypeLib(     // S_OK or error.
-    ITypeLib    *pITLB,                 // [IN] The TypeLib.
-    BSTR        *pwzNamespace)          // [OUT] Put the namespace name here.
-{
-    CONTRACTL
-    {
-        DISABLED(NOTHROW);  // PostError goes down a throwing path right now.  Revisit this when fixed.
-        PRECONDITION(CheckPointer(pITLB));
-        PRECONDITION(CheckPointer(pwzNamespace));
-    }
-    CONTRACTL_END;
-    
-    HRESULT     hr = S_OK;              // A result.
-    ITypeLib2   *pITLB2=0;              //For getting custom value.
-    TLIBATTR    *pAttr=0;               // Typelib attributes.
-    BSTR        szPath=0;               // Typelib path.
-    
-    // If custom attribute for namespace exists, use it.
-    if (pITLB->QueryInterface(IID_ITypeLib2, (void **)&pITLB2) == S_OK)
-    {
-        VARIANT vt;
-        VariantInit(&vt);
-        if (pITLB2->GetCustData(GUID_ManagedName, &vt) == S_OK)
-        {   
-            if (V_VT(&vt) == VT_BSTR)
-            {   
-                // If the namespace ends with .dll then remove the extension.
-                LPWSTR pDest = wcsstr(vt.bstrVal, DLL_EXTENSION);
-                if (pDest && (pDest[DLL_EXTENSION_LEN] == 0 || pDest[DLL_EXTENSION_LEN] == ' '))
-                    *pDest = 0;
-
-                if (!pDest)
-                {
-                    // If the namespace ends with .exe then remove the extension.
-                    pDest = wcsstr(vt.bstrVal, EXE_EXTENSION);
-                    if (pDest && (pDest[EXE_EXTENSION_LEN] == 0 || pDest[EXE_EXTENSION_LEN] == ' '))
-                        *pDest = 0;
-                }
-
-                if (pDest)
-                {
-                    // We removed the extension so re-allocate a string of the new length.
-                    *pwzNamespace = SysAllocString(vt.bstrVal);
-                    SysFreeString(vt.bstrVal);
-                }
-                else
-                {
-                    // There was no extension to remove so we can use the string returned
-                    // by GetCustData().
-                    *pwzNamespace = vt.bstrVal;
-                }        
-
-                goto ErrExit;
-            }
-            else
-            {
-                VariantClear(&vt);
-            }
-        }
-    }
-    
-    // No custom attribute, use library name.
-    IfFailGo(pITLB->GetDocumentation(MEMBERID_NIL, pwzNamespace, 0, 0, 0));
-
-ErrExit:
-    if (szPath)
-        ::SysFreeString(szPath);
-    if (pAttr)
-        pITLB->ReleaseTLibAttr(pAttr);
-    if (pITLB2)
-        pITLB2->Release();
-    
-    return hr;
-} // HRESULT GetNamespaceNameForTypeLib()
-
-//*****************************************************************************
-// Given an ITypeInfo, determine the managed name.  Optionally supply a default
-//  namespace, otherwise derive namespace from containing typelib.
-//*****************************************************************************
-HRESULT GetManagedNameForTypeInfo(      // S_OK or error.
-    ITypeInfo   *pITI,                  // [IN] The TypeInfo.
-    LPCWSTR     wzNamespace,            // [IN, OPTIONAL] Default namespace name.
-    LPCWSTR     wzAsmName,              // [IN, OPTIONAL] Assembly name.
-    BSTR        *pwzName)               // [OUT] Put the name here.
-{
-    CONTRACTL
-    {
-        DISABLED(NOTHROW);
-        PRECONDITION(CheckPointer(pITI));
-        PRECONDITION(CheckPointer(wzNamespace, NULL_OK));
-        PRECONDITION(CheckPointer(wzAsmName, NULL_OK));
-        PRECONDITION(CheckPointer(pwzName));
-    }
-    CONTRACTL_END;
-    
-    HRESULT     hr = S_OK;              // A result.
-    ITypeInfo2  *pITI2=0;               // For getting custom value.
-    ITypeLib    *pITLB=0;               // Containing typelib.
-    
-    BSTR        bstrName=0;             // Typeinfo's name.
-    BSTR        bstrNamespace=0;        // Typelib's namespace.
-    int         cchFullyQualifiedName;  // Size of namespace + name buffer.
-    int         cchAsmName=0;           // The size of the assembly name.
-    int         cchAsmQualifiedName=0;  // The size of the assembly qualified name buffer.
-    CQuickArray<WCHAR> qbFullyQualifiedName;  // The fully qualified type name.  
-
-    // Check for a custom value with name.
-    if (pITI->QueryInterface(IID_ITypeInfo2, (void **)&pITI2) == S_OK)
-    {
-        VARIANT     vt;                     // For getting custom value.
-        ::VariantInit(&vt);
-        if (pITI2->GetCustData(GUID_ManagedName, &vt) == S_OK && vt.vt == VT_BSTR)
-        {   // There is a custom value with the name.  Just believe it.
-            *pwzName = vt.bstrVal;
-            vt.bstrVal = 0;
-            vt.vt = VT_EMPTY;
-            goto ErrExit;
-        }
-    }
-    
-    // Still need name, get the namespace.
-    if (wzNamespace == 0)
-    {
-        IfFailGo(pITI->GetContainingTypeLib(&pITLB, 0));
-        IfFailGo(GetNamespaceNameForTypeLib(pITLB, &bstrNamespace));
-        wzNamespace = bstrNamespace;
-    }
-    
-    // Get the name, and combine with namespace.
-    IfFailGo(pITI->GetDocumentation(MEMBERID_NIL, &bstrName, 0,0,0));
-    cchFullyQualifiedName = (int)(wcslen(bstrName) + wcslen(wzNamespace) + 1);
-    IfFailGo(qbFullyQualifiedName.ReSizeNoThrow(cchFullyQualifiedName + 1));
-    ns::MakePath(qbFullyQualifiedName.Ptr(), cchFullyQualifiedName + 1, wzNamespace, bstrName);
-
-    // If the assembly name is specified, then add it to the type name.
-    if (wzAsmName)
-    {
-        cchAsmName = (int)wcslen(wzAsmName);
-        cchAsmQualifiedName = cchFullyQualifiedName + cchAsmName + 3;
-        IfNullGo(*pwzName = ::SysAllocStringLen(0, cchAsmQualifiedName));
-        ns::MakeAssemblyQualifiedName(*pwzName, cchAsmQualifiedName, qbFullyQualifiedName.Ptr(), cchFullyQualifiedName, wzAsmName, cchAsmName);
-    }
-    else
-    {
-        IfNullGo(*pwzName = ::SysAllocStringLen(qbFullyQualifiedName.Ptr(), cchFullyQualifiedName));
-    }
-
-ErrExit:
-    if (bstrName)
-        ::SysFreeString(bstrName);
-    if (bstrNamespace)
-        ::SysFreeString(bstrNamespace);
-    if (pITLB)
-        pITLB->Release();
-    if (pITI2)
-        pITI2->Release();
-
-    return (hr);
-} // HRESULT GetManagedNameForTypeInfo()
diff --git a/src/utilcode/util.cpp b/src/utilcode/util.cpp
index bcfe74ace7..b9ca380212 100644
--- a/src/utilcode/util.cpp
+++ b/src/utilcode/util.cpp
@@ -19,9 +19,6 @@
 #include "cor.h"
 #include "corinfo.h"
 
-#ifndef FEATURE_CORECLR
-#include "metahost.h"
-#endif // !FEATURE_CORECLR
 
 const char g_RTMVersion[]= "v1.0.3705";
 
@@ -562,6 +559,17 @@ LPVOID ClrVirtualAllocAligned(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocatio
 #endif // !FEATURE_PAL
 }
 
+#ifdef _DEBUG
+static DWORD ShouldInjectFaultInRange()
+{
+    static DWORD fInjectFaultInRange = 99;
+
+    if (fInjectFaultInRange == 99)
+        fInjectFaultInRange = (CLRConfig::GetConfigValue(CLRConfig::INTERNAL_InjectFault) & 0x40);
+    return fInjectFaultInRange;
+}
+#endif
+
 // Reserves free memory within the range [pMinAddr..pMaxAddr] using
 // ClrVirtualQuery to find free memory and ClrVirtualAlloc to reserve it.
 //
@@ -576,17 +584,6 @@ LPVOID ClrVirtualAllocAligned(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocatio
 // the range.
 //
 
-#ifdef _DEBUG
-static DWORD ShouldInjectFaultInRange()
-{
-    static DWORD fInjectFaultInRange = 99;
-
-    if (fInjectFaultInRange == 99)
-        fInjectFaultInRange = (CLRConfig::GetConfigValue(CLRConfig::INTERNAL_InjectFault) & 0x40);
-    return fInjectFaultInRange;
-}
-#endif
-
 BYTE * ClrVirtualAllocWithinRange(const BYTE *pMinAddr,
                                   const BYTE *pMaxAddr,
                                   SIZE_T dwSize, 
@@ -601,7 +598,11 @@ BYTE * ClrVirtualAllocWithinRange(const BYTE *pMinAddr,
     }
     CONTRACTL_END;
 
-    BYTE *pResult = NULL;
+    BYTE *pResult = nullptr;  // our return value;
+
+    static unsigned countOfCalls = 0;  // We log the number of tims we call this method
+    countOfCalls++;                    // increment the call counter
+
     //
     // First lets normalize the pMinAddr and pMaxAddr values
     //
@@ -630,55 +631,98 @@ BYTE * ClrVirtualAllocWithinRange(const BYTE *pMinAddr,
         return NULL;
     }
 
-    // We will do one scan: [pMinAddr .. pMaxAddr]
-    // Align to 64k. See docs for VirtualAllocEx and lpAddress and 64k alignment for reasons.
-    BYTE *tryAddr = (BYTE *)ALIGN_UP((BYTE *)pMinAddr, VIRTUAL_ALLOC_RESERVE_GRANULARITY);
+    // We will do one scan from [pMinAddr .. pMaxAddr]
+    // First align the tryAddr up to next 64k base address. 
+    // See docs for VirtualAllocEx and lpAddress and 64k alignment for reasons.
+    //
+    BYTE *   tryAddr            = (BYTE *)ALIGN_UP((BYTE *)pMinAddr, VIRTUAL_ALLOC_RESERVE_GRANULARITY);
+    bool     virtualQueryFailed = false;
+    bool     faultInjected      = false;
+    unsigned virtualQueryCount  = 0;
 
     // Now scan memory and try to find a free block of the size requested.
     while ((tryAddr + dwSize) <= (BYTE *) pMaxAddr)
     {
         MEMORY_BASIC_INFORMATION mbInfo;
-
+            
         // Use VirtualQuery to find out if this address is MEM_FREE
         //
+        virtualQueryCount++;
         if (!ClrVirtualQuery((LPCVOID)tryAddr, &mbInfo, sizeof(mbInfo)))
+        {
+            // Exit and return nullptr if the VirtualQuery call fails.
+            virtualQueryFailed = true;
             break;
-
+        }
+            
         // Is there enough memory free from this start location?
-        // The PAL version of VirtualQuery sets RegionSize to 0 for free
-        // memory regions, in which case we go just ahead and try
-        // VirtualAlloc without checking the size, and see if it succeeds.
-        if (mbInfo.State == MEM_FREE &&
-            (mbInfo.RegionSize >= (SIZE_T) dwSize || mbInfo.RegionSize == 0))
+        // Note that for most versions of UNIX the mbInfo.RegionSize returned will always be 0
+        if ((mbInfo.State == MEM_FREE) && 
+            (mbInfo.RegionSize >= (SIZE_T) dwSize || mbInfo.RegionSize == 0)) 
         {
             // Try reserving the memory using VirtualAlloc now
-            pResult = (BYTE*) ClrVirtualAlloc(tryAddr, dwSize, MEM_RESERVE, flProtect);
+            pResult = (BYTE*)ClrVirtualAlloc(tryAddr, dwSize, MEM_RESERVE, flProtect);
 
-            if (pResult != NULL) 
+            // Normally this will be successful
+            //
+            if (pResult != nullptr)
             {
-                return pResult;
+                // return pResult
+                break;
             }
-#ifdef _DEBUG 
-            // pResult == NULL
-            else if (ShouldInjectFaultInRange())
+
+#ifdef _DEBUG
+            if (ShouldInjectFaultInRange())
             {
-                return NULL;
+                // return nullptr (failure)
+                faultInjected = true;
+                break;
             }
 #endif // _DEBUG
 
-            // We could fail in a race.  Just move on to next region and continue trying
+            // On UNIX we can also fail if our request size 'dwSize' is larger than 64K and
+            // and our tryAddr is pointing at a small MEM_FREE region (smaller than 'dwSize')
+            // However we can't distinguish between this and the race case.
+
+            // We might fail in a race.  So just move on to next region and continue trying
             tryAddr = tryAddr + VIRTUAL_ALLOC_RESERVE_GRANULARITY;
         }
         else
         {
             // Try another section of memory
             tryAddr = max(tryAddr + VIRTUAL_ALLOC_RESERVE_GRANULARITY,
-                (BYTE*) mbInfo.BaseAddress + mbInfo.RegionSize);
+                          (BYTE*) mbInfo.BaseAddress + mbInfo.RegionSize);
         }
     }
 
-    // Our tryAddr reached pMaxAddr
-    return NULL;
+    STRESS_LOG7(LF_JIT, LL_INFO100,
+                "ClrVirtualAllocWithinRange request #%u for %08x bytes in [ %p .. %p ], query count was %u - returned %s: %p\n",
+                countOfCalls, (DWORD)dwSize, pMinAddr, pMaxAddr,
+                virtualQueryCount, (pResult != nullptr) ? "success" : "failure", pResult);
+
+    // If we failed this call the process will typically be terminated
+    // so we log any additional reason for failing this call.
+    //
+    if (pResult == nullptr)
+    {
+        if ((tryAddr + dwSize) > (BYTE *)pMaxAddr)
+        {
+            // Our tryAddr reached pMaxAddr
+            STRESS_LOG0(LF_JIT, LL_INFO100, "Additional reason: Address space exhausted.\n");
+        }
+
+        if (virtualQueryFailed)
+        {
+            STRESS_LOG0(LF_JIT, LL_INFO100, "Additional reason: VirtualQuery operation failed.\n");
+        }
+
+        if (faultInjected)
+        {
+            STRESS_LOG0(LF_JIT, LL_INFO100, "Additional reason: fault injected.\n");
+        }
+    }
+
+    return pResult;
 }
 
 //******************************************************************************
@@ -3275,114 +3319,6 @@ BOOL FileExists(LPCWSTR filename)
     return TRUE;                
 }
 
-#ifndef FEATURE_CORECLR
-// Current users for FileLock are ngen and ngen service
-
-FileLockHolder::FileLockHolder()
-{
-    _hLock = INVALID_HANDLE_VALUE;
-}
-    
-FileLockHolder::~FileLockHolder()
-{
-    Release();
-}
-
-// the amount of time we want to wait
-#define FILE_LOCK_RETRY_TIME 100
-
-void FileLockHolder::Acquire(LPCWSTR lockName, HANDLE hInterrupt, BOOL* pInterrupted)
-{
-    WRAPPER_NO_CONTRACT;
-
-    DWORD dwErr = 0;
-    DWORD dwAccessDeniedRetry = 0;
-    const DWORD MAX_ACCESS_DENIED_RETRIES = 10;
-
-    if (pInterrupted)
-    {
-        *pInterrupted = FALSE;
-    }
-
-    _ASSERTE(_hLock == INVALID_HANDLE_VALUE);
-
-    for (;;) {
-        _hLock = WszCreateFile(lockName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_FLAG_DELETE_ON_CLOSE, NULL);
-        if (_hLock != INVALID_HANDLE_VALUE) {
-            return; 
-        }
-
-        dwErr = GetLastError();
-        // Logically we should only expect ERROR_SHARING_VIOLATION, but Windows can also return
-        // ERROR_ACCESS_DENIED for underlying NtStatus DELETE_PENDING.  That happens when another process
-        // (gacutil.exe or indexer) have the file opened.  Unfortunately there is no public API that would
-        // allow us to detect this NtStatus and distinguish it from 'real' access denied (candidates are
-        // RtlGetLastNtStatus that is not documented on MSDN and NtCreateFile that is internal and can change
-        // at any time), so we retry on access denied, but only for a limited number of times.
-        if (dwErr == ERROR_SHARING_VIOLATION ||
-            (dwErr == ERROR_ACCESS_DENIED && ++dwAccessDeniedRetry <= MAX_ACCESS_DENIED_RETRIES))
-        {
-            // Somebody is holding the lock. Let's sleep, and come back again.
-            if (hInterrupt)
-            {
-                _ASSERTE(pInterrupted && 
-                    "If you can be interrupted, you better want to know if you actually were interrupted");
-                if (WaitForSingleObject(hInterrupt, FILE_LOCK_RETRY_TIME) == WAIT_OBJECT_0)
-                {
-                      if (pInterrupted)
-                      {
-                        *pInterrupted = TRUE;
-                      }
-
-                      // We've been interrupted, so return without acquiring
-                      return;
-                }
-            }
-            else
-            {
-                ClrSleepEx(FILE_LOCK_RETRY_TIME, FALSE);
-            }
-        }
-        else {
-            ThrowHR(HRESULT_FROM_WIN32(dwErr));
-        }
-    }
-}
-
-
-HRESULT FileLockHolder::AcquireNoThrow(LPCWSTR lockName, HANDLE hInterrupt, BOOL* pInterrupted)
-{
-    HRESULT hr = S_OK;
-    
-    EX_TRY
-    {
-        Acquire(lockName, hInterrupt, pInterrupted);
-    }
-    EX_CATCH_HRESULT(hr);
-
-    return hr;
-}
-
-BOOL FileLockHolder::IsTaken(LPCWSTR lockName)
-{
-    
-    // We don't want to do an acquire the lock to know if its taken, so we want to see if the file
-    // exists. However, in situations like unplugging a machine, a DELETE_ON_CLOSE still leaves the file
-    // around. We try to delete it here. If the lock is acquired, DeleteFile will fail, as the file is
-    // not opened with SHARE_DELETE.
-    WszDeleteFile(lockName);
-
-    return FileExists(lockName);
-}
-
-void FileLockHolder::Release()
-{
-    if (_hLock != INVALID_HANDLE_VALUE) {
-        CloseHandle(_hLock);
-        _hLock = INVALID_HANDLE_VALUE;
-    }
-}
-#endif // FEATURE_CORECLR
 
 //======================================================================
 // This function returns true, if it can determine that the instruction pointer
@@ -3540,59 +3476,6 @@ RUNTIMEVERSIONINFO RUNTIMEVERSIONINFO::notDefined;
 
 BOOL IsV2RuntimeLoaded(void)
 {
-#ifndef FEATURE_CORECLR
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        CANNOT_TAKE_LOCK;
-    }
-    CONTRACTL_END;
-
-    ReleaseHolder<ICLRMetaHost>    pMetaHost(NULL);
-    ReleaseHolder<IEnumUnknown>    pEnum(NULL);
-    ReleaseHolder<IUnknown>        pUnk(NULL);
-    ReleaseHolder<ICLRRuntimeInfo> pRuntime(NULL);
-    HRESULT hr;
-
-    HModuleHolder hModule = WszLoadLibrary(MSCOREE_SHIM_W);
-    if (hModule == NULL)
-        return FALSE;
-
-    CLRCreateInstanceFnPtr pfnCLRCreateInstance = (CLRCreateInstanceFnPtr)::GetProcAddress(hModule, "CLRCreateInstance");
-    if (pfnCLRCreateInstance == NULL)
-        return FALSE;
-
-    hr = (*pfnCLRCreateInstance)(CLSID_CLRMetaHost, IID_ICLRMetaHost, (LPVOID *)&pMetaHost);
-    if (FAILED(hr))
-        return FALSE;
-
-    hr = pMetaHost->EnumerateLoadedRuntimes(GetCurrentProcess(), &pEnum);
-    if (FAILED(hr))
-        return FALSE;
-
-    while (pEnum->Next(1, &pUnk, NULL) == S_OK)
-    {
-        hr = pUnk->QueryInterface(IID_ICLRRuntimeInfo, (void **)&pRuntime);
-        if (FAILED(hr))
-            continue;
-
-        WCHAR wszVersion[30];
-        DWORD cchVersion = _countof(wszVersion);
-        hr = pRuntime->GetVersionString(wszVersion, &cchVersion);
-        if (FAILED(hr))
-            continue;
-
-        // Is it a V2 runtime?
-        if ((cchVersion < 3) || 
-            ((wszVersion[0] != W('v')) && (wszVersion[0] != W('V'))) || 
-            (wszVersion[1] != W('2')) || 
-            (wszVersion[2] != W('.')))
-            continue;
-
-        return TRUE;
-    }
-#endif //  FEATURE_CORECLR
 
     return FALSE;
 }
@@ -3616,54 +3499,6 @@ BOOL IsClrHostedLegacyComObject(REFCLSID rclsid)
 
 
 
-#if !defined(FEATURE_CORECLR) && !defined(SELF_NO_HOST) && !defined(FEATURE_UTILCODE_NO_DEPENDENCIES)
-
-namespace UtilCode
-{
-
-#pragma warning(push)
-#pragma warning(disable:4996) // For use of deprecated LoadLibraryShim
-
-    // When a NULL version is passed to LoadLibraryShim, this told the shim to bind the already-loaded
-    // runtime or to the latest runtime. In hosted environments, we already know a runtime (or two) is
-    // loaded, and since we are no longer guaranteed that a call to mscoree!LoadLibraryShim with a NULL
-    // version will return the correct runtime, this code uses the ClrCallbacks infrastructure
-    // available to get the ICLRRuntimeInfo for the runtime in which this code is hosted, and then
-    // calls ICLRRuntimeInfo::LoadLibrary to make sure that the load occurs within the context of the
-    // correct runtime.
-    HRESULT LoadLibraryShim(LPCWSTR szDllName, LPCWSTR szVersion, LPVOID pvReserved, HMODULE *phModDll)
-    {
-        HRESULT hr = S_OK;
-
-        if (szVersion != NULL)
-        {   // If a version is provided, then we just fall back to the legacy function to allow
-            // it to construct the explicit path and load from that location.
-            //@TODO: Can we verify that all callers of LoadLibraryShim in hosted environments always pass null and eliminate this code?
-            return ::LoadLibraryShim(szDllName, szVersion, pvReserved, phModDll);
-        }
-
-        //
-        // szVersion is NULL, which means we should load the DLL from the hosted environment's directory.
-        //
-
-        typedef ICLRRuntimeInfo *GetCLRRuntime_t();
-        GetCLRRuntime_t *pfnGetCLRRuntime =
-            reinterpret_cast<GetCLRRuntime_t *>((*GetClrCallbacks().m_pfnGetCLRFunction)("GetCLRRuntime"));
-        if (pfnGetCLRRuntime == NULL)
-            return E_UNEXPECTED;
-
-        ICLRRuntimeInfo* pRI = (*pfnGetCLRRuntime)();
-        if (pRI == NULL)
-            return E_UNEXPECTED;
-
-        return pRI->LoadLibrary(szDllName, phModDll);
-    }
-
-#pragma warning(pop)
-
-}
-
-#endif //!FEATURE_CORECLR && !SELF_NO_HOST && !FEATURE_UTILCODE_NO_DEPENDENCIES
 
 namespace Clr
 {
diff --git a/src/utilcode/utilmessagebox.cpp b/src/utilcode/utilmessagebox.cpp
index 4559d16b7f..58fd7554c2 100644
--- a/src/utilcode/utilmessagebox.cpp
+++ b/src/utilcode/utilmessagebox.cpp
@@ -24,29 +24,6 @@
 #include "commctrl.h"
 #endif
 
-#if !defined(SELF_NO_HOST) && !defined(FEATURE_CORECLR)
-
-//
-// This should be used for runtime dialog box, because we assume the resource is from mscorrc.dll
-// For tools like ildasm or Shim which uses their own resource file, you need to define IDS_RTL in 
-// their resource file and define a function like this and append the style returned from the function 
-// to every calls to WszMessageBox.
-//
-UINT GetCLRMBRTLStyle() 
-{
-    WRAPPER_NO_CONTRACT;
-
-    UINT mbStyle = 0;
-    WCHAR buff[MAX_LONGPATH];                        
-    if(SUCCEEDED(UtilLoadStringRC(IDS_RTL, buff, MAX_LONGPATH, true))) {
-        if(wcscmp(buff, W("RTL_True")) == 0) {
-            mbStyle = 0x00080000 |0x00100000; // MB_RIGHT || MB_RTLREADING
-        }
-    }
-    return mbStyle;
-}
-
-#endif //!defined(SELF_NO_HOST) && !defined(FEATURE_CORECLR)
 
 BOOL ShouldDisplayMsgBoxOnCriticalFailure()
 {
@@ -72,16 +49,6 @@ BOOL ShouldDisplayMsgBoxOnCriticalFailure()
 }
 
 
-#if !defined(FEATURE_CORESYSTEM) && !defined(FEATURE_CORECLR)
-enum ProbedTaskDialogIndirectState
-{
-    ProbedTaskDialogIndirectState_NotProbed = 0,
-    ProbedTaskDialogIndirectState_NotAvailable = 1,
-    ProbedTaskDialogIndirectState_Available = 2
-};
-
-static ProbedTaskDialogIndirectState siProbedTaskDialogIndirect = ProbedTaskDialogIndirectState_NotProbed;
-#endif // !FEATURE_CORESYSTEM && !FEATURE_CORECLR
 
 
 // We'd like to use TaskDialogIndirect for asserts coming from managed code in particular
@@ -109,157 +76,7 @@ int MessageBoxImpl(
     }
     CONTRACTL_END;
 
-#if defined(FEATURE_CORESYSTEM) || defined (FEATURE_CORECLR)
     return WszMessageBox(hWnd, message, title, uType);
-#else
-    bool mustUseMessageBox = false;  // Mac, Silverlight, pre-Vista?  Do we support this type of message box?
-    decltype(TaskDialogIndirect)* pfnTaskDialogIndirect = NULL;
-    ULONG_PTR cookie = NULL;  // For activation context.
-    bool activatedActivationContext = false;
-    HModuleHolder hmodComctl32;
-    HANDLE hActCtx = INVALID_HANDLE_VALUE;
-
-    // Note: TaskDialogIndirect is only in the v6 and above versions of comctl32.  Windows
-    // stores that library in the WinSxS directory in a directory with 
-    // "Microsoft.Windows.Common-Controls" in the name.  Your application can only see
-    // this library if the linker has added a manifest dependency on the V6 common controls
-    // to your application.  Or, you can create an activation context to make this work,
-    // if your library also has the appropriate manifest dependency.
-    // Also, I'm not going to leave comctl32.dll mapped, to ensure it can't somehow 
-    // interfere with older versions.  Therefore, re-load comctl32.dll every time through
-    // this method.  We will record whether TaskDialogIndirect is available though, so
-    // we can fall back to MessageBox faster.
-
-    // We don't yet have a perfect mapping from all MessageBox behavior to TaskDialogIndirect behavior.
-    // Use MessageBox to avoid most of this complexity.
-    if (((uType & MB_ICONMASK) != MB_ICONWARNING) && (uType & MB_ICONMASK) != MB_ICONERROR  ||
-        (uType & MB_TYPEMASK) != MB_ABORTRETRYIGNORE ||
-        (uType & MB_DEFMASK) != 0 ||
-        (uType & MB_MODEMASK) != 0 ||
-        (uType & MB_MISCMASK) != 0)
-        mustUseMessageBox = true;
-    else if (mustUseMessageBox || siProbedTaskDialogIndirect == ProbedTaskDialogIndirectState_NotAvailable)
-        mustUseMessageBox = true;
-    else {
-        // Replace our application's ActivationContext temporarily, load comctl32
-        // & look for TaskDialogIndirect.  Don't cache pointer.
-        // The following code was suggested by some Windows experts.  We do not want
-		// to add a manifest to our library saying we use comctl32 v6, because that
-		// will mean loading a lot of extra libraries on startup (a significant perf hit).
-		// We could either store the manifest as a resource, or more creatively since
-		// we are effectively a Windows component, rely on %windir%\WindowsShell.manifest.
-        ACTCTX ctx = { sizeof(ACTCTX) };
-        ctx.dwFlags = 0;
-        StackSString manifestPath;  // Point this at %windir%\WindowsShell.manifest, for comctl32 version 6.
-        UINT numChars = WszGetWindowsDirectory(manifestPath.OpenUnicodeBuffer(MAX_PATH_FNAME), MAX_PATH_FNAME);
-        if (numChars == 0 || numChars >= MAX_PATH_FNAME)
-        {
-            _ASSERTE(0);  // How did this fail?
-        }
-        else {
-            manifestPath.CloseBuffer(numChars);
-            if (manifestPath[manifestPath.GetCount() - 1] != W('\\'))
-                manifestPath.Append(W('\\'));
-            manifestPath.Append(W("WindowsShell.manifest"));  // Other Windows components have already loaded this.
-            ctx.lpSource = manifestPath.GetUnicode();
-            hActCtx = CreateActCtx(&ctx);
-            if (hActCtx != INVALID_HANDLE_VALUE)
-            {           
-                if (!ActivateActCtx(hActCtx, &cookie))
-                {
-                    cookie = NULL;
-                    _ASSERTE(0);  // Why did ActivateActCtx fail?  (We'll continue executing & cope with the failure.)
-                }
-                else {
-                    activatedActivationContext = true;
-                    // Activation context was replaced - now we can load comctl32 version 6.
-                    hmodComctl32 = WszLoadLibrary(W("comctl32.dll"));
-
-                    if (hmodComctl32 != INVALID_HANDLE_VALUE) {
-                        pfnTaskDialogIndirect = (decltype(TaskDialogIndirect)*)GetProcAddress(hmodComctl32, "TaskDialogIndirect");
-                        if (pfnTaskDialogIndirect == NULL) {
-                            hmodComctl32.Release();
-                        }
-                    }
-                }
-            }
-        }
-
-        siProbedTaskDialogIndirect = (pfnTaskDialogIndirect == NULL) ? ProbedTaskDialogIndirectState_NotAvailable : ProbedTaskDialogIndirectState_Available;
-        mustUseMessageBox = (pfnTaskDialogIndirect == NULL);
-    }
-
-    int result = MB_OK;
-    if (mustUseMessageBox) {
-        result = WszMessageBox(hWnd, message, title, uType);
-    }
-    else {
-        _ASSERTE(pfnTaskDialogIndirect != NULL);
-        int nButtonPressed                  = 0;
-        TASKDIALOGCONFIG config             = {0};
-        config.cbSize                       = sizeof(config);
-        config.hwndParent                   = hWnd;
-        config.dwCommonButtons              = 0;
-        config.pszWindowTitle               = title;
-        config.dwFlags                      = (uType & MB_RTLREADING) ? TDF_RTL_LAYOUT : 0;
-
-        // Set the user-visible icon in the window.
-        _ASSERTE(((uType & MB_ICONMASK) == MB_ICONWARNING) || ((uType & MB_ICONMASK) == MB_ICONERROR));
-        config.pszMainIcon                  = ((uType & MB_ICONMASK) == MB_ICONWARNING) ? TD_WARNING_ICON : TD_ERROR_ICON;
-
-        config.pszMainInstruction           = title;
-        config.pszContent                   = message;
-        config.pszExpandedInformation       = detailedText;
-
-        // Set up the buttons
-        // Note about button hot keys: Windows keeps track of of where the last input came from
-        // (ie, mouse or keyboard).  If you use the mouse to interact w/ one dialog box and then use
-        // the keyboard, the next dialog will not include hot keys.  This is a Windows feature to
-        // minimize clutter on the screen for mouse users.
-        _ASSERTE((uType & MB_TYPEMASK) == MB_ABORTRETRYIGNORE);
-        StackSString abortLabel, debugLabel, ignoreLabel;
-        const WCHAR *pAbortLabel, *pDebugLabel, *pIgnoreLabel;
-
-        if (abortLabel.LoadResource(CCompRC::Optional, IDS_DIALOG_BOX_ABORT_BUTTON))
-            pAbortLabel = abortLabel.GetUnicode();
-        else
-            pAbortLabel = W("&Abort");
-        if (debugLabel.LoadResource(CCompRC::Optional, IDS_DIALOG_BOX_DEBUG_BUTTON))
-            pDebugLabel = debugLabel.GetUnicode();
-        else
-            pDebugLabel = W("&Debug");
-        if (ignoreLabel.LoadResource(CCompRC::Optional, IDS_DIALOG_BOX_IGNORE_BUTTON))
-            pIgnoreLabel = ignoreLabel.GetUnicode();
-        else
-            pIgnoreLabel = W("&Ignore");
-
-        const TASKDIALOG_BUTTON abortDebugIgnoreButtons[] = { 
-            { IDOK, pAbortLabel },
-            { IDRETRY, pDebugLabel },
-            { IDIGNORE, pIgnoreLabel }
-        };
-        config.pButtons = abortDebugIgnoreButtons;
-        config.cButtons = 3;
-
-        HRESULT hr = pfnTaskDialogIndirect(&config, &nButtonPressed, NULL, NULL);
-        _ASSERTE(hr == S_OK);
-        if (hr == S_OK) {
-            result = nButtonPressed;
-        }
-        else {
-            result = IDOK;
-        }
-
-        _ASSERTE(result == IDOK || result == IDRETRY || result == IDIGNORE);
-    }
-
-    if (activatedActivationContext) {
-        DeactivateActCtx(0, cookie);
-        ReleaseActCtx(hActCtx);  // perf isn't important so we won't bother caching the actctx
-    }
- 
-    return result;
-#endif
 }
 
 int UtilMessageBoxVA(
@@ -428,9 +245,6 @@ int UtilMessageBoxNonLocalizedVA(
             // in use.  However, outside the CLR (SELF_NO_HOST) we can't assume we have resources and
             // in CORECLR we can't even necessarily expect that our CLR callbacks have been initialized.
             // This code path is used for ASSERT dialogs.
-#if !defined(SELF_NO_HOST) && !defined(FEATURE_CORECLR)
-            uType |= GetCLRMBRTLStyle();
-#endif
             
             result = MessageBoxImpl(hWnd, formattedMessage, formattedTitle, details, uType);
             
diff --git a/src/vm/CMakeLists.txt b/src/vm/CMakeLists.txt
index 4a64fcf10b..e1cfcbb06f 100644
--- a/src/vm/CMakeLists.txt
+++ b/src/vm/CMakeLists.txt
@@ -216,7 +216,6 @@ set(VM_SOURCES_WKS
     securitydeclarative.cpp
     securitydeclarativecache.cpp
     securitydescriptorappdomain.cpp
-    securityhostprotection.cpp
     securitymeta.cpp
     securitypolicy.cpp
     securitytransparentassembly.cpp
@@ -241,12 +240,6 @@ set(VM_SOURCES_WKS
     ${VM_SOURCES_GDBJIT}
 )
 
-if(FEATURE_CER)
-    list(APPEND VM_SOURCES_WKS
-        constrainedexecutionregion.cpp
-        )
-endif(FEATURE_CER)
-
 if(FEATURE_EVENT_TRACE)
     list(APPEND VM_SOURCES_WKS
         eventtrace.cpp
@@ -294,7 +287,6 @@ list(APPEND VM_SOURCES_WKS
     rcwrefcache.cpp
     rtlfunctions.cpp
     runtimecallablewrapper.cpp
-    securityprincipal.cpp
     stacksampler.cpp
     stdinterfaces.cpp
     stdinterfaces_wrapper.cpp
diff --git a/src/vm/amd64/remotingamd64.cpp b/src/vm/amd64/remotingamd64.cpp
deleted file mode 100644
index 587afae124..0000000000
--- a/src/vm/amd64/remotingamd64.cpp
+++ /dev/null
@@ -1,672 +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.
-/*===========================================================================
-**
-** File:    RemotingCpu.cpp
-** 
-**
-**
-** Purpose: Defines various remoting related functions for the AMD64 architecture
-**
-**
-** See code:EEStartup#TableOfContents for EE overview
-**
-=============================================================================*/
-
-#include "common.h"
-
-#ifdef FEATURE_REMOTING
-
-#include "excep.h"
-#include "comdelegate.h"
-#include "remoting.h"
-#include "field.h"
-#include "siginfo.hpp"
-#include "stackbuildersink.h"
-#include "threads.h"
-#include "method.hpp"
-
-#include "asmconstants.h"
-
-// External variables
-extern DWORD g_dwNonVirtualThunkRemotingLabelOffset;
-extern DWORD g_dwNonVirtualThunkReCheckLabelOffset;
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::CheckForContextMatch   public
-//
-//  Synopsis:   This code generates a check to see if the current context and
-//              the context of the proxy match.
-// 
-//+----------------------------------------------------------------------------
-//
-// returns zero if contexts match
-// returns non-zero if contexts don't match
-//
-extern "C" UINT_PTR __stdcall CRemotingServices__CheckForContextMatch(Object* pStubData)
-{
-    // This method cannot have a contract because CreateStubForNonVirtualMethod assumes 
-    // it won't trash XMM registers. The code generated for contracts by recent compilers
-    // is trashing XMM registers.
-    STATIC_CONTRACT_NOTHROW;
-    STATIC_CONTRACT_GC_NOTRIGGER;
-    STATIC_CONTRACT_MODE_COOPERATIVE; // due to the Object parameter
-    STATIC_CONTRACT_SO_TOLERANT;
-
-    UINT_PTR contextID  = *(UINT_PTR*)pStubData->UnBox();
-    UINT_PTR contextCur = (UINT_PTR)GetThread()->m_Context;
-    return (contextCur != contextID);   // chosen to match x86 convention
-}
-
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CTPMethodTable::CreateThunkForVirtualMethod   private
-//
-//  Synopsis:   Creates the thunk that pushes the supplied slot number and jumps
-//              to TP Stub
-// 
-//+----------------------------------------------------------------------------
-PCODE CTPMethodTable::CreateThunkForVirtualMethod(DWORD dwSlot, BYTE* pbCode)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    BYTE *pbCodeStart = pbCode;
-
-    // NOTE: if you change the code generated here, update
-    // CVirtualThunkMgr::IsThunkByASM, CVirtualThunkMgr::GetMethodDescByASM
-
-    //
-    // mov  r10, <dwSlot>
-    // mov  rax, TransparentProxyStub
-    // jmp  rax
-    //
-    *pbCode++           = 0x49;
-    *pbCode++           = 0xc7;
-    *pbCode++           = 0xc2;
-    *((DWORD*)pbCode)   = dwSlot;
-    pbCode += sizeof(DWORD);
-    *pbCode++           = 0x48;
-    *pbCode++           = 0xB8;
-    *((UINT64*)pbCode)  = (UINT64)(TransparentProxyStub);
-    pbCode += sizeof(UINT64);
-    *pbCode++           = 0xFF;
-    *pbCode++           = 0xE0;
-
-    _ASSERTE(pbCode - pbCodeStart == ConstVirtualThunkSize);
-    _ASSERTE(CVirtualThunkMgr::IsThunkByASM((PCODE)pbCodeStart));
-
-    return (PCODE)pbCodeStart;
-}
-
-
-#ifdef HAS_REMOTING_PRECODE
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CTPMethodTable::ActivatePrecodeRemotingThunk    private
-//
-//  Synopsis:   Patch the precode remoting thunk to begin interception
-//
-//+----------------------------------------------------------------------------
-void CTPMethodTable::ActivatePrecodeRemotingThunk()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    PORTABILITY_WARNING("CTPMethodTable::ActivatePrecodeRemotingThunk");
-}
-
-#else // HAS_REMOTING_PRECODE
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CTPMethodTable::CreateStubForNonVirtualMethod   public
-//
-//  Synopsis:   Create a stub for a non virtual method
-// 
-//+----------------------------------------------------------------------------
-Stub* CTPMethodTable::CreateStubForNonVirtualMethod(MethodDesc* pMD, CPUSTUBLINKER* psl,
-                                                    LPVOID pvAddrOfCode, Stub* pInnerStub)
-{
-    STANDARD_VM_CONTRACT;
-
-    // Sanity check
-
-    Stub *pStub = NULL;
-
-    // we need a hash table only for virtual methods
-    _ASSERTE(!pMD->IsVirtual());
-
-    // Ensure the TP MethodTable's fields have been initialized.
-    EnsureFieldsInitialized();
-
-    /*
-    NonVirtualMethodStub<thisReg, pvAddrOfCode, pTPMethodTable, pvTPStub>
-    {
-      ;; thisReg:   this
-
-      sub     rsp, 0x28
-
-      test    thisReg, thisReg
-      je      JmpAddrLabel
-
-      mov     rax, [thisReg]
-      mov     r10, <pTPMethodTable>
-      cmp     rax, r10
-      jne     JmpAddrLabel
-
-      mov     [rsp+0x30], rcx                     ;|
-      mov     [rsp+0x38], rdx                     ;|
-      mov     [rsp+0x40], r8                      ;|
-      mov     [rsp+0x48], r9                      ;|
-                                                  ;|
-      mov     rax, [thisReg + TransparentProxyObject___stubData] ;|
-      call    [thisReg + TransparentProxyObject___stub]          ;| EmitCallToStub<pCtxMismatch>
-                                                  ;|
-      mov     rcx, [rsp+0x30]                     ;|
-      mov     rdx, [rsp+0x38]                     ;|
-      mov     r8, [rsp+0x40]                      ;|
-      mov     r9, [rsp+0x48]                      ;|
-                                                  ;|
-      test    rax, rax                            ;|
-      jnz     RemotingLabel                       ;|
-
-    JmpAddrLabel:
-      mov     rax, <pvAddrOfCode>
-      add     rsp, 0x28
-      jmp     rax
-
-    RemotingLabel:
-      mov     r10, <pMD>
-      mov     rax, <pvTPStub>
-      add     rsp, 0x20
-      jmp     rax
-    }
-    */
-
-    X86Reg  thisReg = kRCX;
-    void*   pvTPStub = TransparentProxyStub_CrossContext;
-
-    // Generate label where a null reference exception will be thrown
-    CodeLabel *pJmpAddrLabel = psl->NewCodeLabel();
-    // Generate label where remoting code will execute
-    CodeLabel *pRemotingLabel = psl->NewCodeLabel();
-
-    // NOTE: if you change any of this code, you must update
-    // CNonVirtualThunkMgr::IsThunkByASM.
-
-    // Allocate callee scratch area
-    // sub      rsp, 0x28
-    psl->X86EmitSubEsp(0x28);
-
-    // test     thisReg, thisReg
-    psl->X86EmitR2ROp(0x85, thisReg, thisReg);
-    // je       JmpAddrLabel
-    psl->X86EmitCondJump(pJmpAddrLabel, X86CondCode::kJE);
-
-    // Emit a label here for the debugger. A breakpoint will
-    // be set at the next instruction and the debugger will
-    // call CNonVirtualThunkMgr::TraceManager when the
-    // breakpoint is hit with the thread's context.
-    CodeLabel *pRecheckLabel = psl->NewCodeLabel();
-    psl->EmitLabel(pRecheckLabel);
-
-    // mov      rax, [thisReg]
-    psl->X86EmitIndexRegLoad(kRAX, thisReg, 0);
-
-    // mov      r10, CTPMethodTable::GetMethodTable()
-    psl->X86EmitRegLoad(kR10, (UINT_PTR)CTPMethodTable::GetMethodTable());
-    // cmp      rax, r10
-    psl->X86EmitR2ROp(0x3B, kRAX, kR10);
-
-    // jne      JmpAddrLabel
-    psl->X86EmitCondJump(pJmpAddrLabel, X86CondCode::kJNE);
-
-    // CONSIDER: write all possible stubs in asm to ensure param registers are not trashed
-
-    // mov      [rsp+0x30], rcx
-    // mov      [rsp+0x38], rdx
-    // mov      [rsp+0x40], r8
-    // mov      [rsp+0x48], r9
-    psl->X86EmitRegSave(kRCX, 0x30);
-    psl->X86EmitRegSave(kRDX, 0x38);
-    psl->X86EmitRegSave(kR8, 0x40);
-    psl->X86EmitRegSave(kR9, 0x48);
-
-    // mov      rax, [thisReg + TransparentProxyObject___stub]
-    psl->X86EmitIndexRegLoad(kRAX, thisReg, TransparentProxyObject___stub);
-
-    // mov      rcx, [thisReg + TransparentProxyObject___stubData]
-    psl->X86EmitIndexRegLoad(kRCX, thisReg, TransparentProxyObject___stubData);
-
-    // call      rax
-    psl->Emit16(0xd0ff);
-
-    // mov      rcx, [rsp+0x30]
-    // mov      rdx, [rsp+0x38]
-    // mov      r8, [rsp+0x40]
-    // mov      r9, [rsp+0x48]
-    psl->X86EmitEspOffset(0x8b, kRCX, 0x30);
-    psl->X86EmitEspOffset(0x8b, kRDX, 0x38);
-    psl->X86EmitEspOffset(0x8b, kR8, 0x40);
-    psl->X86EmitEspOffset(0x8b, kR9, 0x48);
-
-    // test     rax, rax
-    psl->X86EmitR2ROp(0x85, kRAX, kRAX);
-    // jnz      RemotingLabel
-    psl->X86EmitCondJump(pRemotingLabel, X86CondCode::kJNZ);
-
-//  pJmpAddrLabel:
-    psl->EmitLabel(pJmpAddrLabel);
-
-    // Make sure that the actual code does not require MethodDesc in r10
-    _ASSERTE(!pMD->RequiresMethodDescCallingConvention());
-
-    //       mov      rax, <pvAddrOfCode>
-    //       add      rsp, 0x28
-    // REX.W jmp      rax 
-    psl->X86EmitTailcallWithESPAdjust(psl->NewExternalCodeLabel(pvAddrOfCode), 0x28);
-
-// pRemotingLabel:
-    psl->EmitLabel(pRemotingLabel);
-
-    // mov      r10, <pMD>
-    psl->X86EmitRegLoad(kR10, (UINT_PTR)pMD);
-
-    //       mov      rax, <pvTPStub>
-    //       add      rsp, 0x28
-    // REX.W jmp      rax
-    psl->X86EmitTailcallWithESPAdjust(psl->NewExternalCodeLabel(pvTPStub), 0x28);
-
-    // Link and produce the stub
-    pStub = psl->LinkInterceptor(pMD->GetLoaderAllocator()->GetStubHeap(),
-                                    pInnerStub, pvAddrOfCode);
-
-    return pStub;
-}
-
-
-//+----------------------------------------------------------------------------
-//
-//  Synopsis:   Find an existing thunk or create a new one for the given
-//              method descriptor. NOTE: This is used for the methods that do
-//              not go through the vtable such as constructors, private and
-//              final methods.
-// 
-//+----------------------------------------------------------------------------
-PCODE CTPMethodTable::CreateNonVirtualThunkForVirtualMethod(MethodDesc* pMD)
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pMD));
-    }
-    CONTRACTL_END;
-
-    CPUSTUBLINKER sl;
-    CPUSTUBLINKER* psl = &sl;
-
-    Stub *pStub = NULL;
-
-    // The thunk has not been created yet. Go ahead and create it.
-    // Compute the address of the slot
-    LPVOID pvEntryPoint = (LPVOID)pMD->GetMethodEntryPoint();
-
-    X86Reg  thisReg = kRCX;
-    void*   pvStub = CRemotingServices__DispatchInterfaceCall;
-
-    // Generate label where a null reference exception will be thrown
-    CodeLabel *pExceptionLabel = psl->NewCodeLabel();
-
-    //  !!! WARNING WARNING WARNING WARNING WARNING !!!
-    //
-    //  DO NOT CHANGE this code without changing the thunk recognition
-    //  code in CNonVirtualThunkMgr::IsThunkByASM
-    //  & CNonVirtualThunkMgr::GetMethodDescByASM
-    //
-    //  !!! WARNING WARNING WARNING WARNING WARNING !!!
-
-    // NOTE: constant mov's should use an extended register to force a REX
-    // prefix and the full 64-bit immediate value, so that
-    // g_dwNonVirtualThunkRemotingLabelOffset and
-    // g_dwNonVirtualThunkReCheckLabelOffset are the same for all
-    // generated code.
-
-    // if this == NULL throw NullReferenceException
-    // test rcx, rcx
-    psl->X86EmitR2ROp(0x85, thisReg, thisReg);
-
-    // je ExceptionLabel
-    psl->X86EmitCondJump(pExceptionLabel, X86CondCode::kJE);
-
-    // Generate label where remoting code will execute
-    CodeLabel *pRemotingLabel = psl->NewCodeLabel();
-
-    // Emit a label here for the debugger. A breakpoint will
-    // be set at the next instruction and the debugger will
-    // call CNonVirtualThunkMgr::TraceManager when the
-    // breakpoint is hit with the thread's context.
-    CodeLabel *pRecheckLabel = psl->NewCodeLabel();
-    psl->EmitLabel(pRecheckLabel);
-
-    // If this.MethodTable == TPMethodTable then do RemotingCall
-    // mov      rax, [thisReg]
-    psl->X86EmitIndexRegLoad(kRAX, thisReg, 0);
-    // mov      r10, CTPMethodTable::GetMethodTable()
-    psl->X86EmitRegLoad(kR10, (UINT_PTR)CTPMethodTable::GetMethodTable());
-    // cmp      rax, r10
-    psl->X86EmitR2ROp(0x3B, kRAX, kR10);
-    // je RemotingLabel
-    psl->X86EmitCondJump(pRemotingLabel, X86CondCode::kJE);
-
-    // Exception handling and non-remoting share the
-    // same codepath
-    psl->EmitLabel(pExceptionLabel);
-
-    // Non-RemotingCode
-    // Jump to the vtable slot of the method
-    // mov rax, pvEntryPoint
-    // Encoded the mov manually so that it always uses the 64-bit form.
-    //psl->X86EmitRegLoad(kRAX, (UINT_PTR)pvEntryPoint);
-    psl->Emit8(REX_PREFIX_BASE | REX_OPERAND_SIZE_64BIT);
-    psl->Emit8(0xb8);
-    psl->EmitBytes((BYTE*)&pvEntryPoint, 8);
-    // jmp rax
-    psl->Emit8(0xff);
-    psl->Emit8(0xe0);
-
-    // Remoting code. Note: CNonVirtualThunkMgr::TraceManager
-    // relies on this label being right after the jmp pvEntryPoint
-    // instruction above. If you move this label, update
-    // CNonVirtualThunkMgr::DoTraceStub.
-    psl->EmitLabel(pRemotingLabel);
-
-    // Save the MethodDesc and goto TPStub
-    // push MethodDesc
-    psl->X86EmitRegLoad(kR10, (UINT_PTR)pMD);
-
-    // jmp TPStub
-    psl->X86EmitNearJump(psl->NewExternalCodeLabel(pvStub));
-
-    // Link and produce the stub
-    // FUTURE: Do we have to provide the loader heap ?
-    pStub = psl->Link(SystemDomain::GetGlobalLoaderAllocator()->GetExecutableHeap());
-
-    // Grab the offset of the RemotingLabel and RecheckLabel
-    // for use in CNonVirtualThunkMgr::DoTraceStub and
-    // TraceManager.
-    DWORD dwOffset;
-
-    dwOffset = psl->GetLabelOffset(pRemotingLabel);
-    ASSERT(!g_dwNonVirtualThunkRemotingLabelOffset || g_dwNonVirtualThunkRemotingLabelOffset == dwOffset);
-    g_dwNonVirtualThunkRemotingLabelOffset = dwOffset;
-
-    dwOffset = psl->GetLabelOffset(pRecheckLabel);
-    ASSERT(!g_dwNonVirtualThunkReCheckLabelOffset || g_dwNonVirtualThunkReCheckLabelOffset == dwOffset);
-    g_dwNonVirtualThunkReCheckLabelOffset = dwOffset;
-
-    return (pStub->GetEntryPoint());
-}
-
-#endif // HAS_REMOTING_PRECODE
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CVirtualThunkMgr::DoTraceStub   public
-//
-//  Synopsis:   Traces the stub given the starting address
-// 
-//+----------------------------------------------------------------------------
-BOOL CVirtualThunkMgr::DoTraceStub(PCODE stubStartAddress, TraceDestination *trace)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    // <TODO> implement this </TODO>
-    return FALSE;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CVirtualThunkMgr::IsThunkByASM  public
-//
-//  Synopsis:   Check assembly to see if this one of our thunks
-// 
-//+----------------------------------------------------------------------------
-BOOL CVirtualThunkMgr::IsThunkByASM(PCODE startaddr)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    PTR_BYTE pbCode = PTR_BYTE(startaddr);
-
-    // NOTE: this depends on the code generated by
-    // CTPMethodTable::CreateThunkForVirtualMethod.
-
-        // mov  r10, <dwSlot>
-    return 0x49 == pbCode[0]
-        && 0xc7 == pbCode[1]
-        && 0xc2 == pbCode[2]
-        // mov rax, TransparentProxyStub
-        && 0x48 == pbCode[7]
-        && 0xb8 == pbCode[8]
-        && (TADDR)TransparentProxyStub == *PTR_TADDR(pbCode+9)
-        // jmp rax
-        && 0xff == pbCode[17]
-        && 0xe0 == pbCode[18];
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CVirtualThunkMgr::GetMethodDescByASM   public
-//
-//  Synopsis:   Parses MethodDesc out of assembly code
-//
-//+----------------------------------------------------------------------------
-MethodDesc *CVirtualThunkMgr::GetMethodDescByASM(PCODE pbThunkCode, MethodTable *pMT)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    // NOTE: this depends on the code generated by
-    // CTPMethodTable::CreateThunkForVirtualMethod.
-
-    return pMT->GetMethodDescForSlot(*((DWORD *) (pbThunkCode + 3)));
-}
-
-
-#ifndef HAS_REMOTING_PRECODE
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CNonVirtualThunkMgr::TraceManager   public
-//
-//  Synopsis:   Traces the stub given the current context
-// 
-//+----------------------------------------------------------------------------
-BOOL CNonVirtualThunkMgr::TraceManager(Thread* thread,
-                                       TraceDestination* trace,
-                                       CONTEXT* pContext,
-                                       BYTE** pRetAddr)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(thread, NULL_OK));
-        PRECONDITION(CheckPointer(trace));
-        PRECONDITION(CheckPointer(pContext));
-        PRECONDITION(CheckPointer(pRetAddr));
-    }
-    CONTRACTL_END;
-
-    BOOL bRet = FALSE;
-
-    MethodDesc * pMD = GetMethodDescByASM(GetIP(pContext) - g_dwNonVirtualThunkReCheckLabelOffset);
-
-    LPBYTE pThis = (LPBYTE)pContext->Rcx;
-
-    if ((pThis != NULL) &&
-        (*(LPBYTE*)(SIZE_T)pThis == (LPBYTE)(SIZE_T)CTPMethodTable::GetMethodTable()))
-    {
-        // <TODO>We know that we've got a proxy
-        // in the way. If the proxy is to a remote call, with no
-        // managed code in between, then the debugger doesn't care and
-        // we should just be able to return FALSE.
-        //
-        // </TODO>
-        bRet = FALSE;
-    }
-    else
-    {
-        // No proxy in the way, so figure out where we're really going
-        // to and let the stub manager try to pickup the trace from
-        // there.
-        LPBYTE stubStartAddress = (LPBYTE)GetIP(pContext) -
-            g_dwNonVirtualThunkReCheckLabelOffset;
-        
-        // Extract the address of the destination
-        BYTE* pbAddr = (BYTE *)(SIZE_T)(stubStartAddress +
-                                g_dwNonVirtualThunkRemotingLabelOffset - 2 - sizeof(void *));
-
-        SIZE_T destAddress = *(SIZE_T *)pbAddr;
-
-        // Ask the stub manager to trace the destination address
-        bRet = StubManager::TraceStub((PCODE)(BYTE *)(size_t)destAddress, trace);
-    }
-
-    // While we may have made it this far, further tracing may reveal
-    // that the debugger can't continue on. Therefore, since there is
-    // no frame currently pushed, we need to tell the debugger where
-    // we're returning to just in case it hits such a situtation.  We
-    // know that the return address is on the top of the thread's
-    // stack.
-    (*pRetAddr) = *((BYTE**)(size_t)(GetSP(pContext)));
-
-    return bRet;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CNonVirtualThunkMgr::DoTraceStub   public
-//
-//  Synopsis:   Traces the stub given the starting address
-// 
-//+----------------------------------------------------------------------------
-BOOL CNonVirtualThunkMgr::DoTraceStub(PCODE stubStartAddress,
-                                      TraceDestination* trace)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        PRECONDITION(stubStartAddress != NULL);
-        PRECONDITION(CheckPointer(trace));
-    }
-    CONTRACTL_END;
-
-    BOOL bRet = FALSE;
-
-    if (!IsThunkByASM(stubStartAddress))
-        return FALSE;
-
-    CNonVirtualThunk* pThunk = FindThunk((const BYTE *)stubStartAddress);
-
-    if(NULL != pThunk)
-    {
-        // We can either jump to 
-        // (1) a slot in the transparent proxy table (UNMANAGED)
-        // (2) a slot in the non virtual part of the vtable
-        // ... so, we need to return TRACE_MGR_PUSH with the address
-        // at which we want to be called back with the thread's context
-        // so we can figure out which way we're gonna go.
-        if((const BYTE *)stubStartAddress == pThunk->GetThunkCode())
-        {
-            trace->InitForManagerPush(
-                (PCODE) (stubStartAddress + g_dwNonVirtualThunkReCheckLabelOffset),
-                this);
-            bRet = TRUE;
-        }
-    }
-
-    return bRet;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CNonVirtualThunkMgr::IsThunkByASM  public
-//
-//  Synopsis:   Check assembly to see if this one of our thunks
-// 
-//+----------------------------------------------------------------------------
-BOOL CNonVirtualThunkMgr::IsThunkByASM(PCODE startaddr)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    PTR_BYTE pbCode = PTR_BYTE(startaddr);
-
-    // test rcx, rcx ; 3 bytes
-    return 0x48 == pbCode[0]
-        && 0x85 == pbCode[1]
-        && 0xc9 == pbCode[2]
-        // je ...  ; 2 bytes
-        && 0x74 == pbCode[3]
-        // mov rax, [rcx]  ; 3 bytes
-        // mov r10, CTPMethodTable::GetMethodTable()  ; 2 bytes + MethodTable*
-        && (TADDR)CTPMethodTable::GetMethodTable() == *PTR_TADDR(pbCode + 10);
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CNonVirtualThunkMgr::GetMethodDescByASM   public
-//
-//  Synopsis:   Parses MethodDesc out of assembly code
-// 
-//+----------------------------------------------------------------------------
-MethodDesc* CNonVirtualThunkMgr::GetMethodDescByASM(PCODE pbThunkCode)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    return *((MethodDesc **) (pbThunkCode + g_dwNonVirtualThunkRemotingLabelOffset + 2));
-}
-
-#endif // HAS_REMOTING_PRECODE
-
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CTPMethodTable::GenericCheckForContextMatch private
-//
-//  Synopsis:   Calls the stub in the TP & returns TRUE if the contexts
-//              match, FALSE otherwise.
-//
-//  Note:       1. Called during FieldSet/Get, used for proxy extensibility
-// 
-//+----------------------------------------------------------------------------
-BOOL __stdcall CTPMethodTable__GenericCheckForContextMatch(Object* orTP)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_COOPERATIVE;    // due to the Object parameter
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    Object *StubData = OBJECTREFToObject(((TransparentProxyObject*)orTP)->GetStubData());
-    CTPMethodTable::CheckContextCrossingProc *pfnCheckContextCrossing =
-            (CTPMethodTable::CheckContextCrossingProc*)(((TransparentProxyObject*)orTP)->GetStub());
-    return pfnCheckContextCrossing(StubData) == 0;
-}
-
-#endif // FEATURE_REMOTING
-
-
diff --git a/src/vm/appdomain.cpp b/src/vm/appdomain.cpp
index ab51eb523b..e13c7dbe2a 100644
--- a/src/vm/appdomain.cpp
+++ b/src/vm/appdomain.cpp
@@ -14,12 +14,6 @@
 #include "eeconfig.h"
 #include "gcheaputilities.h"
 #include "eventtrace.h"
-#ifdef FEATURE_FUSION
-#include "assemblysink.h"
-#include "fusion.h"
-#include "fusionbind.h"
-#include "fusionlogging.h"
-#endif
 #include "perfcounters.h"
 #include "assemblyname.hpp"
 #include "eeprofinterfaces.h"
@@ -43,7 +37,6 @@
 #include "comdelegate.h"
 #include "siginfo.hpp"
 #ifdef FEATURE_REMOTING
-#include "appdomainhelper.h"
 #include "objectclone.h"
 #endif
 #include "typekey.h"
@@ -75,7 +68,6 @@
 #include "appdomain.inl"
 #include "typeparse.h"
 #include "mdaassistants.h"
-#include "stackcompressor.h"
 #ifdef FEATURE_REMOTING
 #include "mscorcfg.h"
 #include "appdomainconfigfactory.hpp"
@@ -93,20 +85,11 @@
 
 #include "stringarraylist.h"
 
-#ifdef FEATURE_VERSIONING
 #include "../binder/inc/clrprivbindercoreclr.h"
-#endif
 
-#if defined(FEATURE_APPX_BINDER)
-#include "appxutil.h"
-#include "clrprivbinderappx.h"
-#endif
 
 #include "clrprivtypecachewinrt.h"
 
-#ifndef FEATURE_CORECLR
-#include "nlsinfo.h"
-#endif
 
 #ifdef FEATURE_RANDOMIZED_STRING_HASHING
 #pragma warning(push)
@@ -740,10 +723,8 @@ OBJECTHANDLE ThreadStaticHandleTable::AllocateHandles(DWORD nRequested)
 void BaseDomain::Attach()
 {
 #ifdef  FEATURE_RANDOMIZED_STRING_HASHING
-#ifdef FEATURE_CORECLR
     // Randomized string hashing is on by default for String.GetHashCode in coreclr.
     COMNlsHashProvider::s_NlsHashProvider.SetUseRandomHashing((CorHost2::GetStartupFlags() & STARTUP_DISABLE_RANDOMIZED_STRING_HASHING) == 0);
-#endif // FEATURE_CORECLR
 #endif // FEATURE_RANDOMIZED_STRING_HASHING
     m_SpecialStaticsCrst.Init(CrstSpecialStatics);
 }
@@ -764,9 +745,7 @@ BaseDomain::BaseDomain()
     m_fDisableInterfaceCache = FALSE;
 
     m_pFusionContext = NULL;
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)  
     m_pTPABinderContext = NULL;
-#endif
 
     // Make sure the container is set to NULL so that it gets loaded when it is used.
     m_pLargeHeapHandleTable = NULL;
@@ -862,9 +841,6 @@ void BaseDomain::Init()
     // Allocate the managed standard interfaces information.
     m_pMngStdInterfacesInfo = new MngStdInterfacesInfo();
     
-#if defined(FEATURE_APPX_BINDER)
-    if (!AppX::IsAppXProcess())
-#endif
     {
         CLRPrivBinderWinRT::NamespaceResolutionKind fNamespaceResolutionKind = CLRPrivBinderWinRT::NamespaceResolutionKind_WindowsAPI;
         if (CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_DesignerNamespaceResolutionEnabled) != FALSE)
@@ -1077,12 +1053,10 @@ void BaseDomain::ClearFusionContext()
         m_pFusionContext->Release();
         m_pFusionContext = NULL;
     }
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)  
     if (m_pTPABinderContext) {
         m_pTPABinderContext->Release();
         m_pTPABinderContext = NULL;
     }
-#endif
 }
 
 #ifdef  FEATURE_PREJIT
@@ -1230,7 +1204,6 @@ void AppDomain::RegisterLoaderAllocatorForDeletion(LoaderAllocator * pLoaderAllo
     m_pDelayedLoaderAllocatorUnloadList = pLoaderAllocator;
 }
 
-#ifdef FEATURE_CORECLR
 void AppDomain::ShutdownNativeDllSearchDirectories()
 {
     LIMITED_METHOD_CONTRACT;
@@ -1244,7 +1217,6 @@ void AppDomain::ShutdownNativeDllSearchDirectories()
 
     m_NativeDllSearchDirectories.Clear();
 }
-#endif
 
 void AppDomain::ReleaseDomainBoundInfo()
 {
@@ -2526,7 +2498,6 @@ void SystemDomain::Init()
 
     DWORD size = 0;
 
-#ifdef FEATURE_VERSIONING
 
     // Get the install directory so we can find mscorlib
     hr = GetInternalSystemDirectory(NULL, &size);
@@ -2541,11 +2512,6 @@ void SystemDomain::Init()
 
     // At this point m_SystemDirectory should already be canonicalized
 
-#else
-
-    m_SystemDirectory = GetInternalSystemDirectory(&size);
-
-#endif // FEATURE_VERSIONING
 
     m_BaseLibrary.Append(m_SystemDirectory);
     if (!m_BaseLibrary.EndsWith(DIRECTORY_SEPARATOR_CHAR_W))
@@ -2576,10 +2542,6 @@ void SystemDomain::Init()
 
         // Finish loading mscorlib now.
         m_pSystemAssembly->GetDomainAssembly()->EnsureActive();
-#ifdef FEATURE_FUSION
-        // disable fusion log for m_pSystemFile, because m_pSystemFile will get reused
-        m_pSystemFile->DisableFusionLogging();
-#endif
     }
 
 #ifdef _DEBUG
@@ -2812,15 +2774,7 @@ void SystemDomain::LoadBaseSystemClasses()
     ETWOnStartup(LdSysBases_V1, LdSysBasesEnd_V1);
 
     {
-#ifdef FEATURE_FUSION        
-        ETWOnStartup (FusionAppCtx_V1, FusionAppCtxEnd_V1);
-        // Setup fusion context for the system domain - this is used for binding mscorlib.
-        IfFailThrow(FusionBind::SetupFusionContext(m_SystemDirectory, NULL, &m_pFusionContext));
-
-        m_pSystemFile = PEAssembly::OpenSystem(m_pFusionContext);
-#else
         m_pSystemFile = PEAssembly::OpenSystem(NULL);
-#endif // FEATURE_FUSION
     }
     // Only partially load the system assembly. Other parts of the code will want to access
     // the globals in this function before finishing the load.
@@ -2872,10 +2826,11 @@ void SystemDomain::LoadBaseSystemClasses()
     // the SZArrayHelper class here.
     g_pSZArrayHelperClass = MscorlibBinder::GetClass(CLASS__SZARRAYHELPER);
 
-#ifdef FEATURE_SPAN_OF_T
     // Load ByReference class
+    //
+    // NOTE: ByReference<T> must be the first by-ref-like system type to be loaded,
+    //       because MethodTable::ClassifyEightBytesWithManagedLayout depends on it.
     g_pByReferenceClass = MscorlibBinder::GetClass(CLASS__BYREFERENCE);
-#endif
 
     // Load Nullable class
     g_pNullableClass = MscorlibBinder::GetClass(CLASS__NULLABLE);
@@ -2950,16 +2905,6 @@ void SystemDomain::LoadBaseSystemClasses()
     g_pExecutionEngineExceptionClass = MscorlibBinder::GetException(kExecutionEngineException);
     g_pThreadAbortExceptionClass = MscorlibBinder::GetException(kThreadAbortException);
 
-#ifdef FEATURE_CER
-    // Used for determining whether a class has a critical finalizer
-    // To determine whether a class has a critical finalizer, we
-    // currently will simply see if it's parent class has a critical
-    // finalizer. To introduce a class with a critical finalizer,
-    // we'll explicitly load CriticalFinalizerObject and set the bit
-    // here.
-    g_pCriticalFinalizerObjectClass = MscorlibBinder::GetClass(CLASS__CRITICAL_FINALIZER_OBJECT);
-    _ASSERTE(g_pCriticalFinalizerObjectClass->HasCriticalFinalizer());
-#endif
 
     // used by gc to handle predefined agility checking
     g_pThreadClass = MscorlibBinder::GetClass(CLASS__THREAD);
@@ -2989,9 +2934,6 @@ void SystemDomain::LoadBaseSystemClasses()
 
     // Load a special marker method used to detect Constrained Execution Regions
     // at jit time.
-#ifdef FEATURE_CER
-    g_pPrepareConstrainedRegionsMethod = MscorlibBinder::GetMethod(METHOD__RUNTIME_HELPERS__PREPARE_CONSTRAINED_REGIONS);
-#endif
     g_pExecuteBackoutCodeHelperMethod = MscorlibBinder::GetMethod(METHOD__RUNTIME_HELPERS__EXECUTE_BACKOUT_CODE_HELPER);
 
     // Make sure that FCall mapping for Monitor.Enter is initialized. We need it in case Monitor.Enter is used only as JIT helper. 
@@ -3319,31 +3261,6 @@ BOOL SystemDomain::SetGlobalSharePolicyUsingAttribute(IMDInternalImport* pScope,
 {
     STANDARD_VM_CONTRACT;
 
-#ifdef FEATURE_FUSION
-    HRESULT hr;
-
-    //
-    // Check to see if the assembly has the LoaderOptimization attribute set.
-    //
-
-    DWORD cbVal;
-    BYTE *pVal;
-    IfFailThrow(hr = pScope->GetCustomAttributeByName(mdMethod,
-                                                      DEFAULTDOMAIN_LOADEROPTIMIZATION_TYPE,
-                                                      (const void**)&pVal, &cbVal));
-
-    if (hr == S_OK) {
-        CustomAttributeParser cap(pVal, cbVal);
-        IfFailThrow(cap.SkipProlog());
-
-        UINT8 u1;
-        IfFailThrow(cap.GetU1(&u1));
-
-        g_dwGlobalSharePolicy = u1 & AppDomain::SHARE_POLICY_MASK;
-
-        return TRUE;
-    }
-#endif    
 
     return FALSE;
 }
@@ -3425,49 +3342,6 @@ void SystemDomain::InitializeDefaultDomain(
 
     ETWOnStartup (InitDefaultDomain_V1, InitDefaultDomainEnd_V1);
 
-#if defined(FEATURE_FUSION) // SxS
-    // Determine the application base and the configuration file name
-    CQuickWSTR sPathName;
-    CQuickWSTR sConfigName;
-
-    SIZE_T  dwSize;
-    HRESULT hr = GetConfigFileFromWin32Manifest(sConfigName.Ptr(),
-                                                sConfigName.MaxSize(),
-                                                &dwSize);
-    if(FAILED(hr))
-    {
-        if(hr == HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER))
-        {
-            sConfigName.ReSizeThrows(dwSize);
-            hr = GetConfigFileFromWin32Manifest(sConfigName.Ptr(),
-                                                sConfigName.MaxSize(),
-                                                &dwSize);
-        }
-        IfFailThrow(hr);
-    }
-    else
-        sConfigName.ReSizeThrows(dwSize);
-
-    hr = GetApplicationPathFromWin32Manifest(sPathName.Ptr(),
-                                             sPathName.MaxSize(),
-                                             &dwSize);
-    if(FAILED(hr))
-    {
-        if(hr == HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER))
-        {
-            sPathName.ReSizeThrows(dwSize);
-            hr = GetApplicationPathFromWin32Manifest(sPathName.Ptr(),
-                                                     sPathName.MaxSize(),
-                                                     &dwSize);
-        }
-        IfFailThrow(hr);
-    }
-    else
-        sPathName.ReSizeThrows(dwSize);
-
-    pwsConfig = (sConfigName.Size() > 0 ? sConfigName.Ptr() : NULL);
-    pwsPath = (sPathName.Size() > 0 ? sPathName.Ptr() : NULL);
-#endif // defined(FEATURE_FUSION) // SxS
 
     // Setup the default AppDomain.
 
@@ -3481,13 +3355,6 @@ void SystemDomain::InitializeDefaultDomain(
     {
         pDefaultDomain->SetLoadContextHostBinder(pBinder);
     }
-    #ifdef FEATURE_APPX_BINDER
-        else if (AppX::IsAppXProcess())
-        {
-            CLRPrivBinderAppX * pAppXBinder = CLRPrivBinderAppX::GetOrCreateBinder();
-            pDefaultDomain->SetLoadContextHostBinder(pAppXBinder);
-        }
-    #endif
 
     {
         GCX_COOP();
@@ -3495,10 +3362,6 @@ void SystemDomain::InitializeDefaultDomain(
 #ifndef CROSSGEN_COMPILE
         if (!NingenEnabled())
         {
-#ifndef FEATURE_CORECLR
-            pDefaultDomain->InitializeHashing(NULL);
-            pDefaultDomain->InitializeSorting(NULL);
-#endif // FEATURE_CORECLR
         }
 #endif // CROSSGEN_COMPILE
 
@@ -3507,9 +3370,6 @@ void SystemDomain::InitializeDefaultDomain(
 #ifndef CROSSGEN_COMPILE
         if (!NingenEnabled())
         {
-#ifdef FEATURE_CLICKONCE
-            pDefaultDomain->InitializeDefaultClickOnceDomain();
-#endif // FEATURE_CLICKONCE
     
             if (!IsSingleAppDomain())
             {
@@ -3538,209 +3398,7 @@ void SystemDomain::InitializeDefaultDomain(
 Volatile<LONG> g_fInExecuteMainMethod = 0;
 #endif
 
-#ifndef FEATURE_CORECLR
-void SystemDomain::ExecuteMainMethod(HMODULE hMod, __in_opt LPWSTR path /*=NULL*/)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        PRECONDITION(CheckPointer(hMod, NULL_OK));
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-#ifdef _DEBUG
-    CounterHolder counter(&g_fInExecuteMainMethod);
-#endif
-
-    Thread *pThread = GetThread();
-    _ASSERTE(pThread);
-
-    GCX_COOP();
-
-    //
-    // There is no EH protecting this transition!
-    // This is generically ok in this method because if we throw out of here, it becomes unhandled anyway.
-    //
-    FrameWithCookie<ContextTransitionFrame> frame;
-    pThread->EnterContextRestricted(SystemDomain::System()->DefaultDomain()->GetDefaultContext(), &frame);
-    _ASSERTE(pThread->GetDomain());
-
-    AppDomain *pDomain = GetAppDomain();
-    _ASSERTE(pDomain);
-
-    // Push this frame around loading the main assembly to ensure the
-    // debugger can properly recognize any managed code that gets run
-    // as "class initializaion" code.
-    FrameWithCookie<DebuggerClassInitMarkFrame> __dcimf;
-    {
-        GCX_PREEMP();
-
-        PEImageHolder pTempImage(PEImage::LoadImage(hMod));
-
-        PEFileHolder pTempFile(PEFile::Open(pTempImage.Extract()));
-
-        // Check for CustomAttributes - Set up the DefaultDomain and the main thread
-        // Note that this has to be done before ExplicitBind() as it
-        // affects the bind
-        mdToken tkEntryPoint = pTempFile->GetEntryPointToken();
-        // <TODO>@TODO: What if the entrypoint is in another file of the assembly?</TODO>
-        ReleaseHolder<IMDInternalImport> scope(pTempFile->GetMDImportWithRef());
-        // In theory, we should have a valid executable image and scope should never be NULL, but we've been  
-        // getting Watson failures for AVs here due to ISVs modifying image headers and some new OS loader 
-        // checks (see Dev10# 718530 and Windows 7# 615596)
-        if (scope == NULL)
-        {
-            ThrowHR(COR_E_BADIMAGEFORMAT);
-        }
-
-#ifdef FEATURE_COMINTEROP
-        Thread::ApartmentState state = Thread::AS_Unknown;        
-
-        if((!IsNilToken(tkEntryPoint)) && (TypeFromToken(tkEntryPoint) == mdtMethodDef)) {
-            if (scope->IsValidToken(tkEntryPoint))
-                state = SystemDomain::GetEntryPointThreadAptState(scope, tkEntryPoint);
-            else
-                ThrowHR(COR_E_BADIMAGEFORMAT);
-        }
-
-        // If the entry point has an explicit thread apartment state, set it
-        // before running the AppDomainManager initialization code.
-        if (state == Thread::AS_InSTA || state == Thread::AS_InMTA)
-            SystemDomain::SetThreadAptState(scope, state);
-#endif // FEATURE_COMINTEROP
-
-        BOOL fSetGlobalSharePolicyUsingAttribute = FALSE;
-
-        if((!IsNilToken(tkEntryPoint)) && (TypeFromToken(tkEntryPoint) == mdtMethodDef))
-        {
-            // The global share policy needs to be set before initializing default domain 
-            // so that it is in place for loading of appdomain manager.
-            fSetGlobalSharePolicyUsingAttribute = SystemDomain::SetGlobalSharePolicyUsingAttribute(scope, tkEntryPoint);
-        }
-
-        // This can potentially run managed code.
-        InitializeDefaultDomain(FALSE);
-
-#ifdef FEATURE_COMINTEROP
-        // If we haven't set an explicit thread apartment state, set it after the
-        // AppDomainManager has got a chance to go set it in InitializeNewDomain.
-        if (state != Thread::AS_InSTA && state != Thread::AS_InMTA)
-            SystemDomain::SetThreadAptState(scope, state);
-#endif // FEATURE_COMINTEROP
-
-        if (fSetGlobalSharePolicyUsingAttribute)
-            SystemDomain::System()->DefaultDomain()->SetupLoaderOptimization(g_dwGlobalSharePolicy);
-
-        NewHolder<IPEFileSecurityDescriptor> pSecDesc(Security::CreatePEFileSecurityDescriptor(pDomain, pTempFile));
-
-        {
-            GCX_COOP();
-            pSecDesc->Resolve();
-            if (pSecDesc->AllowBindingRedirects())
-                pDomain->TurnOnBindingRedirects();
-        }
-
-        PEAssemblyHolder pFile(pDomain->BindExplicitAssembly(hMod, TRUE));
-
-        pDomain->m_pRootAssembly = GetAppDomain()->LoadAssembly(NULL, pFile, FILE_ACTIVE);
-
-        {
-            GCX_COOP();
-
-            // Reuse the evidence that was generated for the PEFile for the assembly so we don't have to
-            // regenerate evidence of the same type again if it is requested later.
-            pDomain->m_pRootAssembly->GetSecurityDescriptor()->SetEvidenceFromPEFile(pSecDesc);
-        }
-
-        // If the AppDomainManager for the default domain was specified in the application config file then
-        // we require that the assembly be trusted in order to set the manager
-        if (pDomain->HasAppDomainManagerInfo() && pDomain->AppDomainManagerSetFromConfig())
-        {
-            Assembly *pEntryAssembly = pDomain->GetAppDomainManagerEntryAssembly();
-            if (!pEntryAssembly->GetSecurityDescriptor()->AllowApplicationSpecifiedAppDomainManager())
-            {
-                COMPlusThrow(kTypeLoadException, IDS_E_UNTRUSTED_APPDOMAIN_MANAGER);
-            }
-        }
 
-        if (CorCommandLine::m_pwszAppFullName == NULL) {
-            StackSString friendlyName;
-            StackSString assemblyPath = pFile->GetPath();
-            SString::Iterator i = assemblyPath.End();
-
-            if (PEAssembly::FindLastPathSeparator(assemblyPath, i)) {
-                i++;
-                friendlyName.Set(assemblyPath, i, assemblyPath.End());
-            }
-            else
-                friendlyName.Set(assemblyPath);
-
-            pDomain->SetFriendlyName(friendlyName, TRUE);
-        }
-    }
-    __dcimf.Pop();
-
-    {
-        GCX_PREEMP();
-
-        LOG((LF_CLASSLOADER | LF_CORDB,
-             LL_INFO10,
-             "Created domain for an executable at %p\n",
-             (pDomain->m_pRootAssembly ? pDomain->m_pRootAssembly->Parent() : NULL)));
-        TESTHOOKCALL(RuntimeStarted(RTS_CALLINGENTRYPOINT));
-
-#ifdef FEATURE_MULTICOREJIT
-        pDomain->GetMulticoreJitManager().AutoStartProfile(pDomain);
-#endif
-
-        pDomain->m_pRootAssembly->ExecuteMainMethod(NULL, TRUE /* waitForOtherThreads */);
-    }
-
-    pThread->ReturnToContext(&frame);
-
-#ifdef FEATURE_TESTHOOKS
-    TESTHOOKCALL(LeftAppDomain(DefaultADID));
-#endif
-}
-#endif //!FEATURE_CORECLR
-
-#ifdef FEATURE_CLICKONCE
-void SystemDomain::ActivateApplication(int *pReturnValue)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    struct _gc {
-        OBJECTREF   orThis;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCX_COOP();
-    GCPROTECT_BEGIN(gc);
-
-    gc.orThis = SystemDomain::System()->DefaultDomain()->GetExposedObject();
-
-    MethodDescCallSite activateApp(METHOD__APP_DOMAIN__ACTIVATE_APPLICATION, &gc.orThis);
-
-    ARG_SLOT args[] = {
-        ObjToArgSlot(gc.orThis),
-    };
-    int retval = activateApp.Call_RetI4(args);
-    if (pReturnValue)
-        *pReturnValue = retval;
-
-    GCPROTECT_END();
-}
-#endif // FEATURE_CLICKONCE
 
 #ifdef FEATURE_MIXEDMODE
 static HRESULT RunDllMainHelper(HINSTANCE hInst, DWORD dwReason, LPVOID lpReserved, Thread* pThread, bool bReenablePreemptive)
@@ -3893,7 +3551,6 @@ Assembly *AppDomain::LoadAssemblyHelper(LPCWSTR wszAssembly,
 
 #if defined(FEATURE_CLASSIC_COMINTEROP) && !defined(CROSSGEN_COMPILE)
 
-#ifdef FEATURE_CORECLR
 MethodTable *AppDomain::LoadCOMClass(GUID clsid,
                                      BOOL bLoadRecord/*=FALSE*/,
                                      BOOL* pfAssemblyInReg/*=NULL*/)
@@ -3901,135 +3558,6 @@ MethodTable *AppDomain::LoadCOMClass(GUID clsid,
     // @CORESYSTODO: what to do here?
     return NULL;
 }
-#else // FEATURE_CORECLR
-
-static BOOL IsSameRuntimeVersion(ICLRRuntimeInfo *pInfo1, ICLRRuntimeInfo *pInfo2)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    WCHAR wszVersion1[_MAX_PATH]; 
-    WCHAR wszVersion2[_MAX_PATH];
-    DWORD cchVersion;
-
-    cchVersion = COUNTOF(wszVersion1);
-    IfFailThrow(pInfo1->GetVersionString(wszVersion1, &cchVersion));
-
-    cchVersion = COUNTOF(wszVersion2);
-    IfFailThrow(pInfo2->GetVersionString(wszVersion2, &cchVersion));
-
-    return SString::_wcsicmp(wszVersion1, wszVersion2) == 0;
-}
-
-MethodTable *AppDomain::LoadCOMClass(GUID clsid,
-                                     BOOL bLoadRecord/*=FALSE*/,
-                                     BOOL* pfAssemblyInReg/*=NULL*/)
-{
-    CONTRACT (MethodTable*)
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        POSTCONDITION(CheckPointer(RETVAL, NULL_OK));
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACT_END;
-
-
-    MethodTable* pMT = NULL;
-
-    NewArrayHolder<WCHAR>  wszClassName = NULL;
-    NewArrayHolder<WCHAR>  wszAssemblyString = NULL;
-    NewArrayHolder<WCHAR>  wszCodeBaseString = NULL;
-
-    DWORD   cbAssembly = 0;
-    DWORD   cbCodeBase = 0;
-    Assembly *pAssembly = NULL;
-    BOOL    fFromRegistry = FALSE;
-    BOOL    fRegFreePIA = FALSE;
-
-    HRESULT hr = S_OK;
-
-    if (pfAssemblyInReg != NULL)
-        *pfAssemblyInReg = FALSE;
-
-    // with sxs.dll help
-    hr = FindShimInfoFromWin32(clsid, bLoadRecord, NULL, NULL, &wszClassName, &wszAssemblyString, &fRegFreePIA);
-
-    if(FAILED(hr))
-    {
-        hr = FindShimInfoFromRegistry(clsid, bLoadRecord, VER_ASSEMBLYMAJORVERSION, VER_ASSEMBLYMINORVERSION,
-                                      &wszClassName, &wszAssemblyString, &wszCodeBaseString);
-        if (FAILED(hr))
-            RETURN NULL;
-
-        fFromRegistry = TRUE;
-    }
-
-    // Skip the GetRuntimeForManagedCOMObject check for value types since they cannot be activated and are
-    // always used for wrapping existing instances coming from COM.
-    if (!bLoadRecord)
-    {
-        // We will load the assembly only if it is a PIA or if unmanaged activation would load the currently running
-        // runtime. Otherwise we return NULL which will result in using the default System.__ComObject type.
-
-        // the type is a PIA type if mscoree.dll is not its inproc server dll or it was specified as <clrSurrogate> in the manifest
-        BOOL fPIA = (fFromRegistry ? !Clr::Util::Com::CLSIDHasMscoreeAsInprocServer32(clsid) : fRegFreePIA);
-        if (!fPIA)
-        {
-            // this isn't a PIA, so we must determine which runtime it would load
-            ReleaseHolder<ICLRRuntimeHostInternal> pRuntimeHostInternal;
-            IfFailThrow(g_pCLRRuntime->GetInterface(CLSID_CLRRuntimeHostInternal,
-                                                    IID_ICLRRuntimeHostInternal,
-                                                    &pRuntimeHostInternal));
-
-            // we call the shim to see which runtime would this be activated in
-            ReleaseHolder<ICLRRuntimeInfo> pRuntimeInfo;
-            if (FAILED(pRuntimeHostInternal->GetRuntimeForManagedCOMObject(clsid, IID_ICLRRuntimeInfo, &pRuntimeInfo)))
-            {
-                // the requested runtime is not loadable - don't load the assembly
-                RETURN NULL;
-            }
-
-            if (!IsSameRuntimeVersion(g_pCLRRuntime, pRuntimeInfo))
-            {
-                // the requested runtime is different from this runtime - don't load the assembly
-                RETURN NULL;
-            }
-        }
-    }
-
-    if (pfAssemblyInReg != NULL)
-        *pfAssemblyInReg = TRUE;
-
-    if (wszAssemblyString != NULL) {
-        pAssembly = LoadAssemblyHelper(wszAssemblyString, wszCodeBaseString);
-        pMT = TypeName::GetTypeFromAssembly(wszClassName, pAssembly).GetMethodTable();
-        if (!pMT)
-            goto ErrExit;
-    }
-
-    if (pMT == NULL) {
-    ErrExit:
-        // Convert the GUID to its string representation.
-        WCHAR szClsid[64];
-        if (GuidToLPWSTR(clsid, szClsid, NumItems(szClsid)) == 0)
-            szClsid[0] = 0;
-
-        // Throw an exception indicating we failed to load the type with
-        // the requested CLSID.
-        COMPlusThrow(kTypeLoadException, IDS_CLASSLOAD_NOCLSIDREG, szClsid);
-    }
-
-    RETURN pMT;
-}
-
-#endif // FEATURE_CORECLR
 
 #endif // FEATURE_CLASSIC_COMINTEROP && !CROSSGEN_COMPILE
 
@@ -4076,17 +3604,6 @@ bool SystemDomain::IsReflectionInvocationMethod(MethodDesc* pMeth)
         CLASS__ASSEMBLY,
         CLASS__TYPE_DELEGATOR,
         CLASS__RUNTIME_HELPERS,
-#if defined(FEATURE_COMINTEROP) && !defined(FEATURE_CORECLR)
-        CLASS__ITYPE,
-        CLASS__IASSEMBLY,
-        CLASS__IMETHODBASE,
-        CLASS__IMETHODINFO,
-        CLASS__ICONSTRUCTORINFO,
-        CLASS__IFIELDINFO,
-        CLASS__IPROPERTYINFO,
-        CLASS__IEVENTINFO,
-        CLASS__IAPPDOMAIN,
-#endif // FEATURE_COMINTEROP && !FEATURE_CORECLR
         CLASS__LAZY_INITIALIZER,
         CLASS__DYNAMICMETHOD,
         CLASS__DELEGATE,
@@ -4147,9 +3664,6 @@ bool SystemDomain::IsReflectionInvocationMethod(MethodDesc* pMeth)
         // unmaintainable as more changes are made to BCL types.
         if ((pCaller == MscorlibBinder::GetExistingClass(CLASS__APP_DOMAIN))
             && (pMeth != MscorlibBinder::GetMethod(METHOD__APP_DOMAIN__CREATE_APP_DOMAIN_MANAGER)) // This uses reflection to create an AppDomainManager
-    #ifdef FEATURE_CLICKONCE
-            && (pMeth != MscorlibBinder::GetMethod(METHOD__APP_DOMAIN__ACTIVATE_APPLICATION)) // This uses reflection to create an ActivationContext
-    #endif
             )
         {
             return true;
@@ -4708,106 +4222,6 @@ HRESULT SystemDomain::NotifyProfilerShutdown()
 }
 #endif // PROFILING_SUPPORTED
 
-#ifdef FEATURE_FUSION
-static HRESULT GetVersionPath(HKEY root, __in LPWSTR key, __out LPWSTR* pDevpath, DWORD* pdwDevpath)
-{
-    CONTRACTL
-    {
-        MODE_PREEMPTIVE;
-        NOTHROW;
-        GC_NOTRIGGER;
-        INJECT_FAULT(return E_OUTOFMEMORY;);
-    }
-    CONTRACTL_END;
-
-    DWORD rtn;
-    RegKeyHolder versionKey;
-    rtn = WszRegOpenKeyEx(root, key, 0, KEY_READ, &versionKey);
-    if(rtn == ERROR_SUCCESS) {
-        DWORD type;
-        DWORD cbDevpath;
-        if(WszRegQueryValueEx(versionKey, W("devpath"), 0, &type, (LPBYTE) NULL, &cbDevpath) == ERROR_SUCCESS && type == REG_SZ) {
-            *pDevpath = (LPWSTR) new (nothrow) BYTE[cbDevpath];
-            if(*pDevpath == NULL)
-                return E_OUTOFMEMORY;
-            else {
-                rtn = WszRegQueryValueEx(versionKey, W("devpath"), 0, &type, (LPBYTE) *pDevpath, &cbDevpath);
-                if ((rtn == ERROR_SUCCESS) && (type == REG_SZ))
-                    *pdwDevpath = (DWORD) wcslen(*pDevpath);
-            }
-        }
-        else
-            return REGDB_E_INVALIDVALUE;
-    }
-
-    return HRESULT_FROM_WIN32(rtn);
-}
-
-// Get the developers path from the environment. This can only be set through the environment and
-// cannot be added through configuration files, registry etc. This would make it to easy for
-// developers to deploy apps that are not side by side. The environment variable should only
-// be used on developers machines where exact matching to versions makes build and testing to
-// difficult.
-void SystemDomain::GetDevpathW(__out_ecount_opt(1) LPWSTR* pDevpath, DWORD* pdwDevpath)
-{
-   CONTRACTL
-    {
-        THROWS;
-        MODE_ANY;
-        GC_TRIGGERS;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    GCX_PREEMP();
-
-    if(g_pConfig->DeveloperInstallation() && m_fDevpath == FALSE) {
-
-        LockHolder lh;
-
-        if(m_fDevpath == FALSE) {
-            DWORD dwPath = 0;
-            PathString m_pwDevpathholder; 
-            dwPath = WszGetEnvironmentVariable(APPENV_DEVPATH, m_pwDevpathholder);
-            if(dwPath) {
-                m_pwDevpath = m_pwDevpathholder.GetCopyOfUnicodeString();
-            }
-            else {
-                RegKeyHolder userKey;
-                RegKeyHolder machineKey;
-
-                WCHAR pVersion[MAX_PATH_FNAME];
-                DWORD dwVersion = MAX_PATH_FNAME;
-                HRESULT hr = S_OK;
-                hr = FusionBind::GetVersion(pVersion, &dwVersion);
-                if(SUCCEEDED(hr)) {
-                    LONG rslt;
-                    rslt = WszRegOpenKeyEx(HKEY_CURRENT_USER, FRAMEWORK_REGISTRY_KEY_W,0,KEY_READ, &userKey);
-                    hr = HRESULT_FROM_WIN32(rslt);
-                    if (SUCCEEDED(hr)) {
-                        hr = GetVersionPath(userKey, pVersion, &m_pwDevpath, &m_dwDevpath);
-                    }
-
-                    if (FAILED(hr) && WszRegOpenKeyEx(HKEY_LOCAL_MACHINE, FRAMEWORK_REGISTRY_KEY_W,0,KEY_READ, &machineKey) == ERROR_SUCCESS) {
-                        hr = GetVersionPath(machineKey, pVersion, &m_pwDevpath, &m_dwDevpath);
-                    }
-                }
-                if (Assembly::FileNotFound(hr))
-                    hr = S_FALSE;
-                else
-                    IfFailThrow(hr);
-            }
-
-            m_fDevpath = TRUE;
-        }
-        // lh out of scope here
-    }
-
-    if(pDevpath) *pDevpath = m_pwDevpath;
-    if(pdwDevpath) *pdwDevpath = m_dwDevpath;
-    return;
-}
-#endif // FEATURE_FUSION
 
 #ifdef _DEBUG
 struct AppDomain::ThreadTrackInfo {
@@ -4836,15 +4250,6 @@ AppDomain::AppDomain()
     m_pUnloadRequestThread = NULL;
     m_ADUnloadSink=NULL;
 
-#ifndef FEATURE_CORECLR
-    m_bUseOsSorting = RunningOnWin8();
-    m_sortVersion = DEFAULT_SORT_VERSION;
-    m_pCustomSortLibrary = NULL;
-#if _DEBUG
-    m_bSortingInitialized = FALSE;
-#endif // _DEBUG
-    m_pNlsHashProvider = NULL;
-#endif //!FEATURE_CORECLR
 
     // Initialize Shared state. Assemblies are loaded
     // into each domain by default.
@@ -4938,9 +4343,7 @@ AppDomain::AppDomain()
     m_pDomainFileWithNativeImageList = NULL;
 #endif
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
     m_fIsBindingModelLocked.Store(FALSE);
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
 } // AppDomain::AppDomain
 
@@ -4977,13 +4380,6 @@ AppDomain::~AppDomain()
     if(!g_fEEInit)
         Terminate();
 
-#ifndef FEATURE_CORECLR
-    if (m_pCustomSortLibrary)
-        delete m_pCustomSortLibrary;
-
-    if (m_pNlsHashProvider)
-        delete m_pNlsHashProvider;
-#endif
 
 
 #ifdef FEATURE_REMOTING
@@ -5184,18 +4580,6 @@ void AppDomain::Init()
         m_pReflectionOnlyWinRtBinder = clr::SafeAddRef(new CLRPrivBinderReflectionOnlyWinRT(m_pReflectionOnlyWinRtTypeCache));
 #endif
     }
-#ifdef FEATURE_APPX_BINDER
-    else if (g_fEEStarted && !IsDefaultDomain())
-    {   // Non-default domain in an AppX process. This exists only for designers and we'd better be in dev mode.
-        _ASSERTE(IsCompilationProcess() || AppX::IsAppXDesignMode());
-
-        // Inherit AppX binder from default domain.
-        SetLoadContextHostBinder(SystemDomain::System()->DefaultDomain()->GetLoadContextHostBinder());
-
-        // Note: LoadFrom, LoadFile, Load(byte[], ...), ReflectionOnlyLoad, LoadWithPartialName,
-        /// etc. are not supported and are actively blocked.
-    }
-#endif //FEATURE_APPX_BINDER
 #endif //FEATURE_COMINTEROP
 
 #endif // CROSSGEN_COMPILE
@@ -5403,13 +4787,6 @@ void AppDomain::Terminate()
 
 #endif // FEATURE_COMINTEROP
 
-#ifdef FEATURE_FUSION
-    if(m_pAsyncPool != NULL)
-    {
-        delete m_pAsyncPool;
-        m_pAsyncPool = NULL;
-    }
-#endif
 
     if (!IsAtProcessExit())
     {
@@ -5448,9 +4825,7 @@ void AppDomain::Terminate()
     }
 
     ShutdownAssemblies();
-#ifdef FEATURE_CORECLR    
     ShutdownNativeDllSearchDirectories();
-#endif
 
     if (m_pRefClassFactHash)
     {
@@ -5587,123 +4962,7 @@ OBJECTREF AppDomain::GetExposedObject()
     return ref;
 }
 
-#ifndef FEATURE_CORECLR
-void AppDomain::InitializeSorting(OBJECTREF* ppAppdomainSetup)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        THROWS;
-        GC_NOTRIGGER;
-        PRECONDITION(ppAppdomainSetup == NULL || IsProtectedByGCFrame(ppAppdomainSetup));
-    }
-    CONTRACTL_END;
-
-    DWORD sortVersionFromConfig = CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CompatSortNLSVersion);
-
-    if(sortVersionFromConfig != 0)
-    {
-        m_bUseOsSorting = FALSE;
-        m_sortVersion = sortVersionFromConfig;
-    }
-
-    if(ppAppdomainSetup != NULL)
-    {
-        APPDOMAINSETUPREF adSetup = (APPDOMAINSETUPREF) *ppAppdomainSetup;
-        APPDOMAINSORTINGSETUPINFOREF sortingSetup = adSetup->GetAppDomainSortingSetupInfo();
-
-        if(sortingSetup != NULL)
-        {
-            if(sortingSetup->UseV2LegacySorting() || sortingSetup->UseV4LegacySorting())
-            {        
-
-                m_bUseOsSorting = FALSE;
-    
-                if(sortingSetup->UseV2LegacySorting())
-                {           
-                    m_sortVersion = SORT_VERSION_WHIDBEY;
-                }
-
-                if(sortingSetup->UseV4LegacySorting())
-                {
-                    m_sortVersion = SORT_VERSION_V4;
-                }
-            }
-            else if(sortingSetup->GetPFNIsNLSDefinedString() != NULL 
-                    && sortingSetup->GetPFNCompareStringEx() != NULL 
-                    && sortingSetup->GetPFNLCMapStringEx() != NULL 
-                    && sortingSetup->GetPFNFindNLSStringEx() != NULL 
-                    && sortingSetup->GetPFNCompareStringOrdinal() != NULL 
-                    && sortingSetup->GetPFNGetNLSVersionEx() != NULL
-                    && sortingSetup->GetPFNFindStringOrdinal() != NULL)
-            {
-                m_pCustomSortLibrary = new COMNlsCustomSortLibrary;    
-                m_pCustomSortLibrary->pIsNLSDefinedString = (PFN_IS_NLS_DEFINED_STRING) sortingSetup->GetPFNIsNLSDefinedString();
-                m_pCustomSortLibrary->pCompareStringEx = (PFN_COMPARE_STRING_EX) sortingSetup->GetPFNCompareStringEx();
-                m_pCustomSortLibrary->pLCMapStringEx = (PFN_LC_MAP_STRING_EX) sortingSetup->GetPFNLCMapStringEx();
-                m_pCustomSortLibrary->pFindNLSStringEx = (PFN_FIND_NLS_STRING_EX) sortingSetup->GetPFNFindNLSStringEx();
-                m_pCustomSortLibrary->pCompareStringOrdinal = (PFN_COMPARE_STRING_ORDINAL) sortingSetup->GetPFNCompareStringOrdinal();
-                m_pCustomSortLibrary->pGetNLSVersionEx = (PFN_GET_NLS_VERSION_EX) sortingSetup->GetPFNGetNLSVersionEx();
-                m_pCustomSortLibrary->pFindStringOrdinal = (PFN_FIND_STRING_ORDINAL) sortingSetup->GetPFNFindStringOrdinal();
-            }
-        }
-    }
-
-    if(m_bUseOsSorting == FALSE && m_sortVersion == DEFAULT_SORT_VERSION)
-    {
-        // If we are using the legacy sorting dlls, the default version for sorting is SORT_VERSION_V4.  Note that
-        // we don't expect this to change in the future (even when V5 or V6 of the runtime comes out).
-        m_sortVersion = SORT_VERSION_V4;
-    }
-
-    if(RunningOnWin8() && m_bUseOsSorting == FALSE)
-    {
-        // We need to ensure that the versioned sort DLL could load so we don't crash later.  This ensures we have
-        // the same behavior as Windows 7, where even if we couldn't load the correct versioned sort dll, we would
-        // provide the default sorting behavior.
-        INT_PTR sortOrigin;
-        if(COMNlsInfo::InternalInitVersionedSortHandle(W(""), &sortOrigin, m_sortVersion) == NULL)
-        {
-            LOG((LF_APPDOMAIN, LL_WARNING, "AppDomain::InitializeSorting failed to load legacy sort DLL for AppDomain.\n"));
-            // We couldn't load a sort DLL.  Fall back to default sorting using the OS.
-            m_bUseOsSorting = TRUE;
-            m_sortVersion = DEFAULT_SORT_VERSION;
-        }        
-    }
-
-#if _DEBUG
-    m_bSortingInitialized = TRUE;
-#endif
-}
-#endif
-
-#ifndef FEATURE_CORECLR
-void AppDomain::InitializeHashing(OBJECTREF* ppAppdomainSetup)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        THROWS;
-        GC_NOTRIGGER;
-        PRECONDITION(ppAppdomainSetup == NULL || IsProtectedByGCFrame(ppAppdomainSetup));
-    }
-    CONTRACTL_END;
- 
-    m_pNlsHashProvider = new COMNlsHashProvider;
-
-#ifdef FEATURE_RANDOMIZED_STRING_HASHING
-    BOOL fUseRandomizedHashing = (BOOL) CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_UseRandomizedStringHashAlgorithm);
 
-    if(ppAppdomainSetup != NULL)
-    {
-        APPDOMAINSETUPREF adSetup = (APPDOMAINSETUPREF) *ppAppdomainSetup;
-        fUseRandomizedHashing |= adSetup->UseRandomizedStringHashing();
-    }
-
-    m_pNlsHashProvider->SetUseRandomHashing(fUseRandomizedHashing);
-#endif // FEATURE_RANDOMIZED_STRING_HASHING
-}
-#endif // FEATURE_CORECLR
 
 OBJECTREF AppDomain::DoSetup(OBJECTREF* setupInfo)
 {
@@ -5947,11 +5206,7 @@ bool IsPlatformAssembly(LPCSTR szName, DomainAssembly *pDomainAssembly)
         return false;
     }
 
-#ifdef FEATURE_CORECLR
     return StrongNameIsSilverlightPlatformKey(pbPublicKey, cbPublicKey);
-#else
-    return StrongNameIsEcmaKey(pbPublicKey, cbPublicKey);
-#endif
 }
 
 void AppDomain::AddAssembly(DomainAssembly * assem)
@@ -6045,54 +5300,6 @@ BOOL AppDomain::HasSetSecurityPolicy()
     RETURN ((APPDOMAINREF)GetExposedObject())->HasSetPolicy();
 }
 
-#if defined (FEATURE_LOADER_OPTIMIZATION) && !defined(FEATURE_CORECLR)
-// Returns true if the user has declared the desire to load an 
-// assembly domain-neutral.  This is either by specifying System.LoaderOptimizationAttribute
-// on the entry routine or the host has set this loader-optimization flag.  
-BOOL AppDomain::ApplySharePolicy(DomainAssembly *pFile)
-{
-    CONTRACT(BOOL)
-    {
-        PRECONDITION(CheckPointer(pFile));
-        THROWS;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACT_END;
-
-    if (!pFile->GetFile()->IsShareable())
-        RETURN FALSE;
-
-    if (ApplySharePolicyFlag(pFile))
-        RETURN TRUE;
-
-    RETURN FALSE;
-}
-
-BOOL AppDomain::ApplySharePolicyFlag(DomainAssembly *pFile)
-{
-    CONTRACT(BOOL)
-    {
-        PRECONDITION(CheckPointer(pFile));
-        THROWS;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACT_END;
-
-    switch(GetSharePolicy()) {
-    case SHARE_POLICY_ALWAYS:
-        RETURN (!pFile->MayHaveUnknownDependencies());
-
-    case SHARE_POLICY_GAC:
-        RETURN (pFile->IsClosedInGAC());
-
-    case SHARE_POLICY_NEVER:
-        RETURN pFile->IsSystem();
-
-    default:
-        UNREACHABLE_MSG("Unknown share policy");
-    }
-}
-#endif // FEATURE_LOADER_OPTIMIZATION
 
 EEClassFactoryInfoHashTable* AppDomain::SetupClassFactHash()
 {
@@ -6712,7 +5919,6 @@ DomainAssembly* AppDomain::LoadDomainAssembly( AssemblySpec* pSpec,
         Exception* pEx=GET_EXCEPTION();
         if (!pEx->IsTransient())
         {
-#if defined(FEATURE_CORECLR)
             // Setup the binder reference in AssemblySpec from the PEAssembly if one is not already set.
             ICLRPrivBinder* pCurrentBindingContext = pSpec->GetBindingContext();
             ICLRPrivBinder* pBindingContextFromPEAssembly = pFile->GetBindingContext();
@@ -6731,7 +5937,6 @@ DomainAssembly* AppDomain::LoadDomainAssembly( AssemblySpec* pSpec,
                 _ASSERTE(AreSameBinderInstance(pCurrentBindingContext, pBindingContextFromPEAssembly));
             }
 #endif // _DEBUG            
-#endif // defined(FEATURE_CORECLR)
 
             if (!EEFileLoadException::CheckType(pEx))
             {
@@ -7150,16 +6355,6 @@ void AppDomain::TryIncrementalLoad(DomainFile *pFile, FileLoadLevel workLevel, F
 
     EX_TRY
     {
-#ifndef FEATURE_CORECLR
-        // Event Tracing for Windows is used to log data for performance and functional testing purposes.
-        // The events below are used to measure the performance of two steps in the assembly loader, namely assembly initialization and delivering events.
-        StackSString ETWAssemblySimpleName;
-        if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context, TRACE_LEVEL_INFORMATION, CLR_PRIVATEBINDING_KEYWORD))
-        {
-            LPCUTF8 simpleName = pFile->GetSimpleName();
-            ETWAssemblySimpleName.AppendUTF8(simpleName ? simpleName : "NULL"); // Gather data used by ETW events later in this function.
-        }
-#endif // FEATURE_CORECLR
 
         // Special case: for LoadLibrary, we cannot hold the lock during the
         // actual LoadLibrary call, because we might get a callback from _CorDllMain on any
@@ -7170,28 +6365,10 @@ void AppDomain::TryIncrementalLoad(DomainFile *pFile, FileLoadLevel workLevel, F
             lockHolder.Release();
             released = TRUE;
         }
-#ifndef FEATURE_CORECLR
-        else if (workLevel == FILE_LOAD_DELIVER_EVENTS)
-        {
-            FireEtwLoaderDeliverEventsPhaseStart(GetId().m_dwId, ETWLoadContextNotAvailable, ETWFieldUnused, ETWLoaderLoadTypeNotAvailable, NULL, ETWAssemblySimpleName, GetClrInstanceId());
-        }
-#endif // FEATURE_CORECLR
 
         // Do the work
         TESTHOOKCALL(NextFileLoadLevel(GetId().m_dwId,pFile,workLevel));
-#ifndef FEATURE_CORECLR
-        if (workLevel == FILE_LOAD_ALLOCATE)
-        {
-            FireEtwLoaderAssemblyInitPhaseStart(GetId().m_dwId, ETWLoadContextNotAvailable, ETWFieldUnused, ETWLoaderLoadTypeNotAvailable, NULL, ETWAssemblySimpleName, GetClrInstanceId());
-        }                                                                             
-#endif // FEATURE_CORECLR
         BOOL success = pFile->DoIncrementalLoad(workLevel);
-#ifndef FEATURE_CORECLR
-        if (workLevel == FILE_LOAD_ALLOCATE)
-        {
-            FireEtwLoaderAssemblyInitPhaseEnd(GetId().m_dwId, ETWLoadContextNotAvailable, ETWFieldUnused, ETWLoaderLoadTypeNotAvailable, NULL, ETWAssemblySimpleName, GetClrInstanceId());
-       }
-#endif // FEATURE_CORECLR
         TESTHOOKCALL(CompletingFileLoadLevel(GetId().m_dwId,pFile,workLevel));
         if (released)
         {
@@ -7214,9 +6391,6 @@ void AppDomain::TryIncrementalLoad(DomainFile *pFile, FileLoadLevel workLevel, F
                 lockHolder.Release();
                 released = TRUE;
                 pFile->DeliverAsyncEvents();
-#ifndef FEATURE_CORECLR
-                FireEtwLoaderDeliverEventsPhaseEnd(GetId().m_dwId, ETWLoadContextNotAvailable, ETWFieldUnused, ETWLoaderLoadTypeNotAvailable, NULL, ETWAssemblySimpleName, GetClrInstanceId());
-#endif // FEATURE_CORECLR
             };
         }
     }
@@ -7403,13 +6577,6 @@ void AppDomain::SetSharePolicy(SharePolicy policy)
 
 #ifdef FEATURE_PREJIT
 
-#ifdef FEATURE_FUSION
-        GCX_PREEMP();
-
-        // Update the native image config flags
-        FusionBind::SetApplicationContextDWORDProperty(m_pFusionContext, ACTAG_ZAP_CONFIG_FLAGS,
-                                                       PEFile::GetNativeImageConfigFlags());
-#endif //FEATURE_FUSION
 
 #endif // FEATURE_PREJIT
 
@@ -7419,49 +6586,6 @@ void AppDomain::SetSharePolicy(SharePolicy policy)
     return;
 }
 
-#ifdef FEATURE_FUSION
-BOOL AppDomain::ReduceSharePolicyFromAlways()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    // We may have already committed to always sharing - this is the case if
-    // we have already loaded non-GAC-bound assemblies as domain neutral.
-
-    if (GetSharePolicy() == SHARE_POLICY_ALWAYS)
-    {
-        AppDomain::AssemblyIterator i = IterateAssembliesEx((AssemblyIterationFlags)(kIncludeLoaded | kIncludeLoading | kIncludeExecution));
-        CollectibleAssemblyHolder<DomainAssembly *> pDomainAssembly;
-
-        // If we have loaded any non-GAC assemblies, we cannot set app domain policy as we have
-        // already committed to the process-wide policy.
-
-        while (i.Next(pDomainAssembly.This()))
-        {
-            if (pDomainAssembly->GetAssembly() && 
-                pDomainAssembly->GetAssembly()->IsDomainNeutral() &&
-                !pDomainAssembly->IsClosedInGAC())
-            {
-                // This assembly has been loaded domain neutral because of SHARE_POLICY_ALWAYS. We
-                // can't reverse that decision now, so we have to fail the sharing policy change.
-                return FALSE;
-            }
-        }
-
-        // We haven't loaded any non-GAC assemblies yet - scale back to SHARE_POLICY_GAC so
-        // future non-GAC assemblies won't be loaded as domain neutral.
-        SetSharePolicy(SHARE_POLICY_GAC);
-    }
-
-    return TRUE;
-}
-#endif // FEATURE_FUSION
 
 AppDomain::SharePolicy AppDomain::GetSharePolicy()
 {
@@ -7487,7 +6611,6 @@ AppDomain::SharePolicy AppDomain::GetSharePolicy()
 #endif // FEATURE_LOADER_OPTIMIZATION
 
 
-#ifdef FEATURE_CORECLR
 void AppDomain::CheckForMismatchedNativeImages(AssemblySpec * pSpec, const GUID * pGuid)
 {
     STANDARD_VM_CONTRACT;
@@ -7553,7 +6676,6 @@ void AppDomain::CheckForMismatchedNativeImages(AssemblySpec * pSpec, const GUID
         amTracker.SuppressRelease();
     }
 }
-#endif // FEATURE_CORECLR
 
 
 void AppDomain::SetupSharedStatics()
@@ -7926,33 +7048,6 @@ void AppDomain::CacheStringsForDAC()
     // If the application base, private bin paths, and configuration file are
     // available, cache them so DAC can read them out of memory
     //
-#ifdef FEATURE_FUSION    
-    if (m_pFusionContext)
-    {
-        CQuickBytes qb;
-        LPWSTR ssz = (LPWSTR) qb.AllocThrows(MAX_URL_LENGTH * sizeof(WCHAR));
-
-        DWORD dwSize;
-
-        // application base
-        ssz[0] = '\0';
-        dwSize = MAX_URL_LENGTH * sizeof(WCHAR);
-        m_pFusionContext->Get(ACTAG_APP_BASE_URL, ssz, &dwSize, 0);
-        m_applicationBase.Set(ssz);
-
-        // private bin paths
-        ssz[0] = '\0';
-        dwSize = MAX_URL_LENGTH * sizeof(WCHAR);
-        m_pFusionContext->Get(ACTAG_APP_PRIVATE_BINPATH, ssz, &dwSize, 0);
-        m_privateBinPaths.Set(ssz);
-
-        // configuration file
-        ssz[0] = '\0';
-        dwSize = MAX_URL_LENGTH * sizeof(WCHAR);
-        m_pFusionContext->Get(ACTAG_APP_CONFIG_FILE, ssz, &dwSize, 0);
-        m_configFile.Set(ssz);
-    }
-#endif // FEATURE_FUSION    
 }
 
 #ifndef DACCESS_COMPILE
@@ -8007,17 +7102,6 @@ BOOL AppDomain::AddAssemblyToCache(AssemblySpec* pSpec, DomainAssembly *pAssembl
     CrstHolder holder(&m_DomainCacheCrst);
     // !!! suppress exceptions
     BOOL bRetVal = m_AssemblyCache.StoreAssembly(pSpec, pAssembly);
-#ifdef FEATURE_FUSION
-    // check for context propagation
-    if (bRetVal && pSpec->GetParentLoadContext() == LOADCTX_TYPE_LOADFROM && pAssembly->GetFile()->GetLoadContext() == LOADCTX_TYPE_DEFAULT)
-    {
-        // LoadFrom propagation occurred, store it in a way reachable by Load() (the "post-policy" one)
-        AssemblySpec loadSpec;
-        loadSpec.CopyFrom(pSpec);
-        loadSpec.SetParentAssembly(NULL);
-        bRetVal = m_AssemblyCache.StoreAssembly(&loadSpec, pAssembly);
-    }
-#endif
     return bRetVal;
 }
 
@@ -8095,13 +7179,11 @@ BOOL AppDomain::IsCached(AssemblySpec *pSpec)
     return m_AssemblyCache.Contains(pSpec);
 }
 
-#ifdef FEATURE_CORECLR
 void AppDomain::GetCacheAssemblyList(SetSHash<PTR_DomainAssembly>& assemblyList)
 {
     CrstHolder holder(&m_DomainCacheCrst);
     m_AssemblyCache.GetAllAssemblies(assemblyList);
 }
-#endif
 
 PEAssembly* AppDomain::FindCachedFile(AssemblySpec* pSpec, BOOL fThrow /*=TRUE*/)
 {
@@ -8147,26 +7229,6 @@ BOOL AppDomain::PostBindResolveAssembly(AssemblySpec  *pPrePolicySpec,
     BOOL fFailure = TRUE;
     *ppFailedSpec = pPrePolicySpec;
 
-#ifdef FEATURE_FUSION
-    // Fusion policy could have been applied,
-    // so failed assembly could be not exactly what we ordered
-
-    IAssemblyName *pIPostPolicyName = pPrePolicySpec->GetNameAfterPolicy();
-
-    // Get post-policy assembly name
-    if (pIPostPolicyName != NULL)
-    {
-        pPostPolicySpec->InitializeSpec(pIPostPolicyName,
-                                        NULL,
-                                        pPrePolicySpec->IsIntrospectionOnly());
-        pPrePolicySpec->ReleaseNameAfterPolicy();
-
-        if (!pPostPolicySpec->CompareEx(pPrePolicySpec))
-        {
-            *ppFailedSpec = pPostPolicySpec;
-        }
-    }
-#endif //FEATURE_FUSION
 
     PEAssemblyHolder result;
 
@@ -8362,19 +7424,6 @@ HRESULT AppDomain::BindAssemblySpecForHostedBinder(
 
     HRESULT hr = S_OK;
 
-#ifdef FEATURE_FUSION
-    StackSString wszAssemblyName;
-
-    if (fusion::logging::LoggingEnabled())
-    {   // Don't perform computation if logging is not enabled.
-        FusionBind::GetAssemblyNameDisplayName(pAssemblyName, wszAssemblyName, ASM_DISPLAYF_FULL);
-    }
-
-    // Fire ETW Start event.
-    FireEtwBindingPhaseStart(
-        GetId().m_dwId, LOADCTX_TYPE_HOSTED, ETWFieldUnused, ETWLoaderLoadTypeNotAvailable,
-        pSpec->m_wszCodeBase, wszAssemblyName.GetUnicode(), GetClrInstanceId());
-#endif
 
     // The Fusion binder can throw (to preserve compat, since it will actually perform an assembly
     // load as part of it's bind), so we need to be careful here to catch any FileNotFoundException
@@ -8388,13 +7437,6 @@ HRESULT AppDomain::BindAssemblySpecForHostedBinder(
 
     IfFailRet(BindHostedPrivAssembly(nullptr, pPrivAssembly, pAssemblyName, ppAssembly));
 
-#ifdef FEATURE_FUSION
-    // Fire ETW End event.
-    FireEtwBindingPhaseEnd(
-        GetId().m_dwId, LOADCTX_TYPE_HOSTED, ETWFieldUnused, ETWLoaderLoadTypeNotAvailable,
-        pSpec->m_wszCodeBase, wszAssemblyName.GetUnicode(), GetClrInstanceId());
-
- #endif
 
     return S_OK;
 }
@@ -8466,11 +7508,6 @@ AppDomain::BindHostedPrivAssembly(
     // Create a PEAssembly using the IL and NI images.
     PEAssemblyHolder pPEAssembly = PEAssembly::Open(pParentAssembly, pPEImageIL, pPEImageNI, pPrivAssembly, fIsIntrospectionOnly);
 
-#ifdef FEATURE_FUSION
-    // Ensure that the assembly found can be loaded for execution in the process.
-    if (!fIsIntrospectionOnly)
-        IfFailRet(RuntimeIsValidAssemblyOnThisPlatform_CheckProcessorArchitecture(pPEAssembly->GetFusionProcessorArchitecture(), FALSE));
-#endif
 
     // Ask the binder to verify.
     IfFailRet(VerifyBindHelper(pPrivAssembly, pAssemblyName, pPEAssembly));
@@ -8500,144 +7537,11 @@ PEAssembly * AppDomain::BindAssemblySpec(
 
     BOOL fForceReThrow = FALSE;
 
-#if defined(FEATURE_APPX_BINDER)
-    //
-    // If there is a host binder available and this is an unparented bind within the
-    // default load context, then the bind will be delegated to the domain-wide host
-    // binder. If there is a parent assembly, then a bind will occur only if it has
-    // an associated ICLRPrivAssembly to serve as the binder.
-    //
-    // fUseHostBinderIfAvailable can be false if this method is called by
-    // CLRPrivBinderFusion::BindAssemblyByName, which explicitly indicates that it
-    // wants to use the fusion binder.
-    //
-
-    if (AppX::IsAppXProcess() &&
-        fUseHostBinderIfAvailable &&
-        (
-         ( pSpec->HasParentAssembly()
-           ? // Parent assembly is hosted
-             pSpec->GetParentAssembly()->GetFile()->HasHostAssembly()
-           : // Non-parented default context bind
-             ( HasLoadContextHostBinder() &&
-               !pSpec->IsIntrospectionOnly() 
-             )
-         ) ||
-         (pSpec->GetHostBinder() != nullptr)
-         )
-       )
-    {
-        HRESULT hr = S_OK;
-
-        if (pSpec->GetCodeBase() != nullptr)
-        {   // LoadFrom is not supported in AppX (we should never even get here)
-            IfFailThrow(E_INVALIDARG);
-        }
-        
-        // Get the assembly display name.
-        ReleaseHolder<IAssemblyName> pAssemblyName;
-        IfFailThrow(pSpec->CreateFusionName(&pAssemblyName, TRUE, TRUE));
-        
-        // Create new binding scope for fusion logging.
-        fusion::logging::BindingScope defaultScope(pAssemblyName, FUSION_BIND_LOG_CATEGORY_DEFAULT);
-        
-        PEAssemblyHolder pAssembly;
-        EX_TRY
-        {
-            // If there is a specified binder, then it is used.
-            // Otherwise if there exist a parent assembly, then it provides the binding context
-            // Otherwise the domain's root-level binder is used.
-            ICLRPrivBinder * pBinder = nullptr;
-
-            if (pSpec->GetHostBinder() != nullptr)
-            {
-                pBinder = pSpec->GetHostBinder();
-            }
-            else
-            {
-                PEAssembly * pParentAssembly =
-                    (pSpec->GetParentAssembly() == nullptr) ? nullptr : pSpec->GetParentAssembly()->GetFile();
-
-                if ((pParentAssembly != nullptr) && (pParentAssembly->HasHostAssembly()))
-                {
-                    BOOL fMustUseOriginalLoadContextBinder = FALSE;
-                    if (pSpec->IsContentType_WindowsRuntime())
-                    {
-                        // Ugly, but we need to handle Framework assemblies that contain WinRT type references,
-                        // and the Fusion binder won't resolve these in AppX processes. The shareable flag is currently
-                        // a reasonable proxy for these cases. (It also catches first party WinMD files, but depedencies
-                        // from those can also be resolved by the original load context binder).
-                        // TODO! Update the fusion binder to resolve WinMD references correctly.
-                        IfFailThrow(pParentAssembly->GetHostAssembly()->IsShareable(&fMustUseOriginalLoadContextBinder));
-                    }
-
-                    if (fMustUseOriginalLoadContextBinder)
-                    {
-                        pBinder = GetLoadContextHostBinder();
-                    }
-                    else
-                    {
-                        pBinder = pParentAssembly->GetHostAssembly();
-                    }
-                }
-                else
-                {
-                    pBinder = GetCurrentLoadContextHostBinder();
-                }
-            }
-            _ASSERTE(pBinder != nullptr);
-            
-            hr = BindAssemblySpecForHostedBinder(pSpec, pAssemblyName, pBinder, &pAssembly);
-            if (FAILED(hr))
-            {
-                goto EndTry1;
-            }
-EndTry1:;
-        }
-        // The combination of this conditional catch/ the following if statement which will throw reduces the count of exceptions 
-        // thrown in scenarios where the exception does not escape the method. We cannot get rid of the try/catch block, as
-        // there are cases within some of the clrpriv binder's which throw.
-        // Note: In theory, FileNotFound should always come here as HRESULT, never as exception.
-        EX_CATCH_HRESULT_IF(hr,
-            !fThrowOnFileNotFound && Assembly::FileNotFound(hr))
-
-        if (FAILED(hr) && (fThrowOnFileNotFound || !Assembly::FileNotFound(hr)))
-        {
-            if (Assembly::FileNotFound(hr))
-            {
-                _ASSERTE(fThrowOnFileNotFound);
-                // Uses defaultScope
-                EEFileLoadException::Throw(pSpec, fusion::logging::GetCurrentFusionBindLog(), hr);
-            }
-            if ((hr == CLR_E_BIND_UNRECOGNIZED_IDENTITY_FORMAT) && pSpec->IsContentType_WindowsRuntime())
-            {   // Error returned e.g. for WinRT type name without namespace
-                if (fThrowOnFileNotFound)
-                {   // Throw ArgumentException (with the HRESULT) wrapped by TypeLoadException to give user type name for diagnostics
-                    // Note: TypeLoadException is equivalent of FileNotFound in WinRT world
-                    EEMessageException ex(hr);
-                    EX_THROW_WITH_INNER(EETypeLoadException, (pSpec->GetWinRtTypeNamespace(), pSpec->GetWinRtTypeClassName(), nullptr, nullptr, IDS_EE_WINRT_LOADFAILURE), &ex);
-                }
-            }
-            else
-            {
-                IfFailThrow(hr);
-            }
-        }
-
-        _ASSERTE((pAssembly != nullptr) || (FAILED(hr) && !fThrowOnFileNotFound));
-        return pAssembly.Extract();
-    }
-    else
-#endif // FEATURE_APPX_BINDER
 #if defined(FEATURE_COMINTEROP)
     // Handle WinRT assemblies in the classic/hybrid scenario. If this is an AppX process,
     // then this case will be handled by the previous block as part of the full set of
     // available binding hosts.
-#ifndef FEATURE_APPX_BINDER
     if (pSpec->IsContentType_WindowsRuntime())
-#else
-    if (!AppX::IsAppXProcess() && pSpec->IsContentType_WindowsRuntime())
-#endif
     {
         HRESULT hr = S_OK;
 
@@ -8646,10 +7550,6 @@ EndTry1:;
 
         IfFailThrow(pSpec->CreateFusionName(&pAssemblyName, TRUE, TRUE));
 
-#ifdef FEATURE_FUSION
-        // Create new binding scope for fusion logging.
-        fusion::logging::BindingScope defaultScope(pAssemblyName, FUSION_BIND_LOG_CATEGORY_DEFAULT);
-#endif
 
         PEAssemblyHolder pAssembly;
 
@@ -8673,11 +7573,7 @@ EndTry2:;
             {
                 _ASSERTE(fThrowOnFileNotFound);
                 // Uses defaultScope
-#ifdef FEATURE_FUSION
-                EEFileLoadException::Throw(pSpec, fusion::logging::GetCurrentFusionBindLog(), hr);
-#else
                 EEFileLoadException::Throw(pSpec, hr);
-#endif // FEATURE_FUSION
             }
 
             // WinRT type bind failures
@@ -8780,88 +7676,11 @@ EndTry2:;
             if (!IsCached(pSpec))
             {
 
-#ifdef FEATURE_FUSION
-                if (fRaisePrebindEvents
-                    && (result = TryResolveAssembly(pSpec, TRUE /*fPreBind*/)) != NULL
-                    && result->CanUseWithBindingCache())
-                {
-                    // Failure to add simply means someone else beat us to it. In that case
-                    // the FindCachedFile call below (after catch block) will update result
-                    // to the cached value.
-                    AddFileToCache(pSpec, result, TRUE /*fAllowFailure*/);
-                }
-                else
-#endif
                 {
                     bool fAddFileToCache = false;
 
                     BOOL fIsWellKnown = FALSE;
 
-#ifdef FEATURE_FUSION
-                    SafeComHolderPreemp<IAssembly> pIAssembly;
-                    SafeComHolderPreemp<IBindResult> pNativeFusionAssembly;
-                    SafeComHolderPreemp<IHostAssembly> pIHostAssembly;
-                    SafeComHolderPreemp<IFusionBindLog> pFusionLog;
-
-                    // Event Tracing for Windows is used to log data for performance and functional testing purposes.
-                    // The events below are used to measure the performance of assembly binding as a whole.
-                    FireEtwBindingPhaseStart(GetId().m_dwId, ETWLoadContextNotAvailable, ETWFieldUnused, ETWLoaderLoadTypeNotAvailable, pSpec->m_wszCodeBase, NULL, GetClrInstanceId());
-                    fIsWellKnown = pSpec->FindAssemblyFile(this,
-                                                           fThrowOnFileNotFound,
-                                                           &pIAssembly,
-                                                           &pIHostAssembly,
-                                                           &pNativeFusionAssembly,
-                                                           &pFusionLog,
-                                                           &hrBindResult,
-                                                           pCallerStackMark,
-                                                           pLoadSecurity);
-                    FireEtwBindingPhaseEnd(GetId().m_dwId, ETWLoadContextNotAvailable, ETWFieldUnused, ETWLoaderLoadTypeNotAvailable, pSpec->m_wszCodeBase, NULL, GetClrInstanceId());
-                    if (pIAssembly || pIHostAssembly)
-                    {
-
-                        if (fIsWellKnown &&
-                            m_pRootAssembly &&
-                            pIAssembly == m_pRootAssembly->GetFusionAssembly())
-                        {
-                            // This is a shortcut to avoid opening another copy of the process exe.
-                            // In fact, we have other similar cases where we've called
-                            // ExplicitBind() rather than normal binding, which aren't covered here.
-
-                            // <TODO>@todo: It would be nice to populate the cache with those assemblies
-                            // to avoid getting in this situation.</TODO>
-
-                            result = m_pRootAssembly->GetManifestFile();
-                            result.SuppressRelease(); // Didn't get a refcount
-                        }
-                        else
-                        {
-                            BOOL isSystemAssembly = pSpec->IsMscorlib(); // can use SystemDomain::m_pSystemAssembly 
-                            BOOL isIntrospectionOnly = pSpec->IsIntrospectionOnly();
-                            if (pIAssembly)
-                                result = PEAssembly::Open(pIAssembly, pNativeFusionAssembly, pFusionLog,
-                                                          isSystemAssembly, isIntrospectionOnly);
-                            else
-                                result = PEAssembly::Open(pIHostAssembly, isSystemAssembly,
-                                                          isIntrospectionOnly);
-                        }
-                        fAddFileToCache = true;
-                    }
-                    else if (!fIsWellKnown)
-                    {
-                        // Trigger the resolve event also for non-throw situation.
-                        // However, this code path will behave as if the resolve handler has thrown,
-                        // that is, not trigger an MDA.
-                        _ASSERTE(fThrowOnFileNotFound == FALSE);
-
-                        AssemblySpec NewSpec(this);
-                        AssemblySpec *pFailedSpec = NULL;
-
-                        fForceReThrow = TRUE; // Managed resolve event handler can throw
-
-                        // Purposly ignore return value
-                        PostBindResolveAssembly(pSpec, &NewSpec, hrBindResult, &pFailedSpec);
-                    }
-#else //!FEATURE_FUSION
                     // Use CoreClr's fusion alternative
                     CoreBindResult bindResult;
 
@@ -8884,15 +7703,12 @@ EndTry2:;
                         }
                         fAddFileToCache = true;
                         
-#if defined(FEATURE_CORECLR)                        
                         // Setup the reference to the binder, which performed the bind, into the AssemblySpec
                         ICLRPrivBinder* pBinder = result->GetBindingContext();
                         _ASSERTE(pBinder != NULL);
                         pSpec->SetBindingContext(pBinder);
-#endif // defined(FEATURE_CORECLR)
                     }
 
-#endif //!FEATURE_FUSION
 
                     if (fAddFileToCache)
                     {
@@ -9246,85 +8062,6 @@ PEAssembly *AppDomain::TryResolveAssembly(AssemblySpec *pSpec, BOOL fPreBind)
     return result;
 }
 
-#ifdef FEATURE_FUSION
-void AppDomain::GetFileFromFusion(IAssembly *pIAssembly, LPCWSTR wszModuleName,
-                                  SString &path)
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        THROWS;
-        INJECT_FAULT(COMPlusThrowOM());
-    }
-    CONTRACTL_END;
-
-    SafeComHolder<IAssemblyModuleImport> pImport;
-    IfFailThrow(pIAssembly->GetModuleByName(wszModuleName, &pImport));
-
-    if (!pImport->IsAvailable()) {
-        AssemblySink* pSink = AllocateAssemblySink(NULL);
-        SafeComHolder<IAssemblyBindSink> sinkholder(pSink);
-        SafeComHolder<IAssemblyModuleImport> pResult;
-
-        IfFailThrow(FusionBind::RemoteLoadModule(GetFusionContext(),
-                                                 pImport,
-                                                 pSink,
-                                                 &pResult));
-        pResult->AddRef();
-        pImport.Assign(pResult);
-    }
-
-    DWORD dwPath = 0;
-    pImport->GetModulePath(NULL, &dwPath);
-
-    LPWSTR buffer = path.OpenUnicodeBuffer(dwPath-1);
-    IfFailThrow(pImport->GetModulePath(buffer, &dwPath));
-    path.CloseBuffer();
-}
-
-PEAssembly *AppDomain::BindExplicitAssembly(HMODULE hMod, BOOL bindable)
-{
-    CONTRACT(PEAssembly *)
-    {
-        PRECONDITION(CheckPointer(hMod));
-        GC_TRIGGERS;
-        THROWS;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACT_END;
-
-    SafeComHolder<IAssembly> pFusionAssembly;
-    SafeComHolder<IBindResult> pNativeFusionAssembly;
-    SafeComHolder<IFusionBindLog> pFusionLog;
-
-    StackSString path;
-    PEImage::GetPathFromDll(hMod, path);
-
-    HRESULT hr = ExplicitBind(path, GetFusionContext(),
-                              bindable ? EXPLICITBIND_FLAGS_EXE : EXPLICITBIND_FLAGS_NON_BINDABLE,
-                              NULL, &pFusionAssembly, &pNativeFusionAssembly,&pFusionLog);
-    if (FAILED(hr))
-        EEFileLoadException::Throw(path, hr);
-
-    RETURN PEAssembly::OpenHMODULE(hMod, pFusionAssembly,pNativeFusionAssembly, pFusionLog, FALSE);
-}
-
-Assembly *AppDomain::LoadExplicitAssembly(HMODULE hMod, BOOL bindable)
-{
-    CONTRACT(Assembly *)
-    {
-        PRECONDITION(CheckPointer(hMod));
-        GC_TRIGGERS;
-        THROWS;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACT_END;
-
-    PEAssemblyHolder pFile(BindExplicitAssembly(hMod, bindable));
-
-    RETURN LoadAssembly(NULL, pFile, FILE_ACTIVE);
-}
-#endif // FEATURE_FUSION
 
 ULONG AppDomain::AddRef()
 {
@@ -9354,26 +8091,6 @@ ULONG AppDomain::Release()
     return (cRef);
 }
 
-#ifdef FEATURE_FUSION
-AssemblySink* AppDomain::AllocateAssemblySink(AssemblySpec* pSpec)
-{
-    CONTRACT(AssemblySink *)
-    {
-        THROWS;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACT_END;
-
-    AssemblySink* ret = FastInterlockExchangePointer(&m_pAsyncPool, NULL);
-
-    if(ret == NULL)
-        ret = new AssemblySink(this);
-    else
-        ret->AddRef();
-    ret->SetAssemblySpec(pSpec);
-    RETURN ret;
-}
-#endif
 
 AppDomain* AppDomain::s_pAppDomainToRaiseUnloadEvent;
 BOOL AppDomain::s_fProcessUnloadDomainEvent = FALSE;
@@ -9566,13 +8283,6 @@ BOOL AppDomain::OnUnhandledException(OBJECTREF *pThrowable, BOOL isTerminating/*
     orSender = pAppDomain->GetRawExposedObject();
 
     retVal = pAppDomain->RaiseUnhandledExceptionEventNoThrow(&orSender, pThrowable, isTerminating);
-#ifndef FEATURE_CORECLR    
-// CoreCLR#520: 
-// To make this work correctly we need the changes for coreclr 473
-    if (pAppDomain != SystemDomain::System()->DefaultDomain())
-        retVal |= SystemDomain::System()->DefaultDomain()->RaiseUnhandledExceptionEventNoThrow
-                        (&orSender, pThrowable, isTerminating);
-#endif    
 
     GCPROTECT_END();
 
@@ -9668,54 +8378,6 @@ void AppDomain::RaiseExitProcessEvent()
     }
 }
 
-#ifndef FEATURE_CORECLR
-void AppDomain::RaiseUnhandledExceptionEvent_Wrapper(LPVOID ptr)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM(););
-        SO_INTOLERANT;
-    }
-    CONTRACTL_END;
-    AppDomain::RaiseUnhandled_Args *args = (AppDomain::RaiseUnhandled_Args *) ptr;
-
-    struct _gc {
-        OBJECTREF orThrowable;
-        OBJECTREF orSender;
-    } gc;
-
-    ZeroMemory(&gc, sizeof(gc));
-
-    _ASSERTE(args->pTargetDomain == GetAppDomain());
-    GCPROTECT_BEGIN(gc);
-    EX_TRY
-    {
-        SetObjectReference(&gc.orThrowable,
-                           AppDomainHelper::CrossContextCopyFrom(args->pExceptionDomain,
-                                                                 args->pThrowable),
-                           args->pTargetDomain);
-
-        SetObjectReference(&gc.orSender,
-                           AppDomainHelper::CrossContextCopyFrom(args->pExceptionDomain,
-                                                                 args->pSender),
-                           args->pTargetDomain);
-    }
-    EX_CATCH
-    {
-        SetObjectReference(&gc.orThrowable, GET_THROWABLE(), args->pTargetDomain);
-        SetObjectReference(&gc.orSender, GetAppDomain()->GetRawExposedObject(), args->pTargetDomain);
-    }
-    EX_END_CATCH(SwallowAllExceptions)
-    *(args->pResult) = args->pTargetDomain->RaiseUnhandledExceptionEvent(&gc.orSender,
-                                                                         &gc.orThrowable,
-                                                                         args->isTerminating);
-    GCPROTECT_END();
-
-}
-#endif //!FEATURE_CORECLR        
 
 BOOL
 AppDomain::RaiseUnhandledExceptionEventNoThrow(OBJECTREF *pSender, OBJECTREF *pThrowable, BOOL isTerminating)
@@ -9778,18 +8440,7 @@ AppDomain::RaiseUnhandledExceptionEvent(OBJECTREF *pSender, OBJECTREF *pThrowabl
     _ASSERTE(pThrowable != NULL && IsProtectedByGCFrame(pThrowable));
     _ASSERTE(pSender    != NULL && IsProtectedByGCFrame(pSender));
 
-#ifndef FEATURE_CORECLR
-    Thread *pThread = GetThread();
-    if (this != pThread->GetDomain())
-    {
-        RaiseUnhandled_Args args = {pThread->GetDomain(), this, pSender, pThrowable, isTerminating, &result};
-        // call through DoCallBack with a domain transition
-        pThread->DoADCallBack(this, AppDomain::RaiseUnhandledExceptionEvent_Wrapper, &args, ADV_DEFAULTAD);
-        return result;
-    }
-#else
     _ASSERTE(this == GetThread()->GetDomain());
-#endif
 
 
     OBJECTREF orDelegate = NULL;
@@ -9812,48 +8463,6 @@ AppDomain::RaiseUnhandledExceptionEvent(OBJECTREF *pSender, OBJECTREF *pThrowabl
 }
 
 
-#ifndef FEATURE_CORECLR
-// Create a domain based on a string name
-AppDomain* AppDomain::CreateDomainContext(LPCWSTR fileName)
-{
-    CONTRACTL
-    {
-        THROWS;
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    if(fileName == NULL) return NULL;
-
-    AppDomain* pDomain = NULL;
-
-    MethodDescCallSite valCreateDomain(METHOD__APP_DOMAIN__VAL_CREATE_DOMAIN);
-
-    STRINGREF pFilePath = NULL;
-    GCPROTECT_BEGIN(pFilePath);
-    pFilePath = StringObject::NewString(fileName);
-
-    ARG_SLOT args[1] =
-    {
-        ObjToArgSlot(pFilePath),
-    };
-
-    APPDOMAINREF pDom = (APPDOMAINREF) valCreateDomain.Call_RetOBJECTREF(args);
-    if(pDom != NULL)
-    {
-        Context* pContext = Context::GetExecutionContext(pDom);
-        if(pContext)
-        {
-            pDomain = pContext->GetDomain();
-        }
-    }
-    GCPROTECT_END();
-
-    return pDomain;
-}
-#endif // !FEATURE_CORECLR
 
 #endif // CROSSGEN_COMPILE
 
@@ -9875,13 +8484,8 @@ void AppDomain::InitializeDomainContext(BOOL allowRedirects,
 
     if (NingenEnabled())
     {
-#ifdef FEATURE_FUSION   
-        CreateFusionContext();
-#endif // FEATURE_FUSION
 
-#ifdef FEATURE_VERSIONING
         CreateFusionContext();
-#endif // FEATURE_VERSIONING
 
         return;
     }
@@ -9907,28 +8511,6 @@ void AppDomain::InitializeDomainContext(BOOL allowRedirects,
         gc.pConfig = StringObject::NewString(pwszConfig);
     }
 
-#ifndef FEATURE_CORECLR
-    StringArrayList *pPropertyNames;
-    StringArrayList *pPropertyValues;
-    CorHost2::GetDefaultAppDomainProperties(&pPropertyNames, &pPropertyValues);
-
-    _ASSERTE(pPropertyNames->GetCount() == pPropertyValues->GetCount());
-
-    if (pPropertyNames->GetCount() > 0)
-    {
-        gc.propertyNames = (PTRARRAYREF)AllocateObjectArray(pPropertyNames->GetCount(), g_pStringClass);
-        gc.propertyValues = (PTRARRAYREF)AllocateObjectArray(pPropertyValues->GetCount(), g_pStringClass);
-
-        for (DWORD i = 0; i < pPropertyNames->GetCount(); ++i)
-        {
-            STRINGREF propertyName = StringObject::NewString(pPropertyNames->Get(i));
-            gc.propertyNames->SetAt(i, propertyName);
-
-            STRINGREF propertyValue = StringObject::NewString(pPropertyValues->Get(i));
-            gc.propertyValues->SetAt(i, propertyValue);
-        }
-    }
-#endif // !FEATURE_CORECLR
 
     if ((gc.ref = GetExposedObject()) != NULL)
     {
@@ -9951,226 +8533,7 @@ void AppDomain::InitializeDomainContext(BOOL allowRedirects,
 #endif // CROSSGEN_COMPILE
 }
 
-#ifdef FEATURE_FUSION
-
-void AppDomain::SetupLoaderOptimization(DWORD optimization)
-{
-    STANDARD_VM_CONTRACT;
-
-    GCX_COOP();
-
-    if ((GetExposedObject()) != NULL)
-    {
-        MethodDescCallSite setupLoaderOptimization(METHOD__APP_DOMAIN__SETUP_LOADER_OPTIMIZATION);
-
-        ARG_SLOT args[2] =
-        {
-            ObjToArgSlot(GetExposedObject()),
-            optimization
-        };
-        setupLoaderOptimization.Call(args);
-    }
-}
 
-// The fusion context should only be null when appdomain is being setup
-// and there should be no reason to protect the creation.
-IApplicationContext *AppDomain::CreateFusionContext()
-{
-    CONTRACT(IApplicationContext *)
-    {
-        GC_TRIGGERS;
-        THROWS;
-        MODE_ANY;
-        POSTCONDITION(CheckPointer(RETVAL));
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACT_END;
-
-    if (m_pFusionContext == NULL)
-    {
-        ETWOnStartup (FusionAppCtx_V1, FusionAppCtxEnd_V1);
-
-        GCX_PREEMP();
-
-        SafeComHolderPreemp<IApplicationContext> pFusionContext;
-        
-        IfFailThrow(FusionBind::CreateFusionContext(NULL, &pFusionContext));
-        
-#if defined(FEATURE_COMINTEROP) && !defined(FEATURE_CORECLR)
-        CLRPrivBinderWinRT * pWinRtBinder;
-        if (AppX::IsAppXProcess())
-        {   // Note: Fusion binder is used in AppX to bind .NET Fx assemblies - some of them depend on .winmd files (e.g. System.Runtime.WindowsRuntime.dll)
-            CLRPrivBinderAppX * pAppXBinder = CLRPrivBinderAppX::GetOrCreateBinder();
-            pWinRtBinder = pAppXBinder->GetWinRtBinder();
-        }
-        else
-        {
-            pWinRtBinder = m_pWinRtBinder;
-        }
-        _ASSERTE(pWinRtBinder != nullptr);
-        
-        IfFailThrow(SetApplicationContext_WinRTBinder(
-            pFusionContext, 
-            static_cast<IBindContext *>(pWinRtBinder)));
-#endif
-
-#ifdef FEATURE_PREJIT
-        if (NGENImagesAllowed())
-        {
-            // Set the native image settings so fusion will bind native images
-            SString zapString(g_pConfig->ZapSet());
-            FusionBind::SetApplicationContextStringProperty(pFusionContext, ACTAG_ZAP_STRING, zapString);
-            FusionBind::SetApplicationContextDWORDProperty(pFusionContext, ACTAG_ZAP_CONFIG_FLAGS,
-                                                            PEFile::GetNativeImageConfigFlags());
-        }
-#endif // FEATURE_PREJIT
-
-        pFusionContext.SuppressRelease();
-        m_pFusionContext = pFusionContext;
-
-        DWORD dwId = m_dwId.m_dwId;
-        IfFailThrow(m_pFusionContext->Set(ACTAG_APP_DOMAIN_ID, &dwId, sizeof(DWORD), 0));
-
-        if (HasLoadContextHostBinder())
-            FusionBind::SetApplicationContextDWORDProperty(pFusionContext, ACTAG_FX_ONLY,1);
-
-    }
-
-    RETURN m_pFusionContext;
-}
-
-void AppDomain::TurnOnBindingRedirects()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-
-    if ((GetExposedObject()) != NULL)
-    {
-        MethodDescCallSite turnOnBindingRedirects(METHOD__APP_DOMAIN__TURN_ON_BINDING_REDIRECTS);
-        ARG_SLOT args[1] =
-        {
-            ObjToArgSlot(GetExposedObject()),
-        };
-        turnOnBindingRedirects.Call(args);
-    }
-
-    IfFailThrow(m_pFusionContext->Set(ACTAG_DISALLOW_APP_BINDING_REDIRECTS,
-                                      NULL,
-                                      0,
-                                      0));
-}
-
-void AppDomain::SetupExecutableFusionContext(LPCWSTR exePath)
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(GetAppDomain() == this);
-    }
-    CONTRACTL_END;
-
-    GCX_COOP();
-
-    struct _gc {
-        STRINGREF pFilePath;
-        OBJECTREF ref;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc);
-    gc.pFilePath = StringObject::NewString(exePath);
-
-    if ((gc.ref = GetExposedObject()) != NULL)
-    {
-        MethodDescCallSite setDomainContext(METHOD__APP_DOMAIN__SET_DOMAIN_CONTEXT, &gc.ref);
-        ARG_SLOT args[2] =
-        {
-            ObjToArgSlot(gc.ref),
-            ObjToArgSlot(gc.pFilePath),
-        };
-        setDomainContext.Call(args);
-    }
-
-    GCPROTECT_END();
-
-}
-
-BOOL AppDomain::SetContextProperty(IApplicationContext* pFusionContext,
-                                   LPCWSTR pProperty, OBJECTREF* obj)
-
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    if (GetAppDomain()->HasLoadContextHostBinder())
-        COMPlusThrow(kNotSupportedException);
-
-
-    if(obj) {
-        if ((*obj) != NULL){
-            MethodTable* pMT = (*obj)->GetMethodTable();
-            DWORD lgth;
-
-            if(MscorlibBinder::IsClass(pMT, CLASS__STRING)) {
-
-                lgth = (ObjectToSTRINGREF(*(StringObject**)obj))->GetStringLength();
-                CQuickBytes qb;
-                LPWSTR wszValue = (LPWSTR) qb.AllocThrows((lgth+1)*sizeof(WCHAR));
-                memcpy(wszValue, (ObjectToSTRINGREF(*(StringObject**)obj))->GetBuffer(), lgth*sizeof(WCHAR));
-                if(lgth > 0 && wszValue[lgth-1] == '/')
-                    lgth--;
-                wszValue[lgth] = W('\0');
-
-                LOG((LF_LOADER,
-                     LL_INFO10,
-                     "Set: %S: *%S*.\n",
-                     pProperty, wszValue));
-
-                IfFailThrow(pFusionContext->Set(pProperty,
-                                                wszValue,
-                                                (lgth+1) * sizeof(WCHAR),
-                                                0));
-            }
-            else {
-                // Pin byte array for loading
-                Wrapper<OBJECTHANDLE, DoNothing, DestroyPinningHandle> handle(
-            GetAppDomain()->CreatePinningHandle(*obj));
-
-                const BYTE *pbArray = ((U1ARRAYREF)(*obj))->GetDirectConstPointerToNonObjectElements();
-                DWORD cbArray = (*obj)->GetNumComponents();
-
-                IfFailThrow(pFusionContext->Set(pProperty,
-                                                (LPVOID) pbArray,
-                                                cbArray,
-                                                0));
-            }
-        }
-        else { // Un-set the property
-            IfFailThrow(pFusionContext->Set(pProperty,
-                                                NULL,
-                                                0,
-                                                0));
-        }
-    }
-
-    return TRUE;
-}
-#endif // FEATURE_FUSION
-
-#ifdef FEATURE_VERSIONING
 IUnknown *AppDomain::CreateFusionContext()
 {
     CONTRACT(IUnknown *)
@@ -10194,59 +8557,14 @@ IUnknown *AppDomain::CreateFusionContext()
         IfFailThrow(CCoreCLRBinderHelper::DefaultBinderSetupContext(GetId().m_dwId, &pTPABinder));
         m_pFusionContext = reinterpret_cast<IUnknown *>(pTPABinder);
         
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)  
         // By default, initial binding context setup for CoreCLR is also the TPABinding context
         (m_pTPABinderContext = pTPABinder)->AddRef();
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
     }
 
     RETURN m_pFusionContext;
 }
-#endif // FEATURE_VERSIONING
-
-#ifdef FEATURE_FUSION
-LPWSTR AppDomain::GetDynamicDir()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
 
-    if (m_pwDynamicDir == NULL) {
-
-        BaseDomain::LockHolder lh(this);
-
-        if(m_pwDynamicDir == NULL) {
-            IApplicationContext* pFusionContext = GetFusionContext();
-            _ASSERTE(pFusionContext);
-
-            HRESULT hr = S_OK;
-            DWORD dwSize = 0;
-            hr = pFusionContext->GetDynamicDirectory(NULL, &dwSize);
-            AllocMemHolder<WCHAR> tempDynamicDir;
-
-            if(hr == HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)) {
-                tempDynamicDir = GetLowFrequencyHeap()->AllocMem(S_SIZE_T(dwSize) * S_SIZE_T(sizeof(WCHAR)));
-                hr = pFusionContext->GetDynamicDirectory(tempDynamicDir, &dwSize);
-            }
-            if(hr==HRESULT_FROM_WIN32(ERROR_NOT_FOUND))
-                return NULL;
-            IfFailThrow(hr);
-
-            tempDynamicDir.SuppressRelease();
-            m_pwDynamicDir = tempDynamicDir;
-        }
-        // lh out of scope here
-    }
-
-    return m_pwDynamicDir;;
-}
-#endif //FEATURE_FUSION
 
 
 //---------------------------------------------------------------------------------------
@@ -12585,13 +10903,6 @@ AppDomain::RaiseAssemblyResolveEvent(
     {
         if (pSpec->GetParentAssembly() != NULL)
         {
-#ifndef FEATURE_CORECLR
-            if ( pSpec->IsIntrospectionOnly() 
-#ifdef FEATURE_FUSION
-                    || pSpec->GetParentLoadContext() == LOADCTX_TYPE_UNKNOWN
-#endif
-                )
-#endif // FEATURE_CORECLR
             {
                 gc.AssemblyRef=pSpec->GetParentAssembly()->GetExposedAssemblyObject();
             }
@@ -12634,68 +10945,6 @@ AppDomain::RaiseAssemblyResolveEvent(
     RETURN pAssembly;
 } // AppDomain::RaiseAssemblyResolveEvent
 
-#ifndef FEATURE_CORECLR
-
-//---------------------------------------------------------------------------------------
-//
-// Ask the AppDomainManager for the entry assembly of the application
-//
-// Note:
-//   Most AppDomainManagers will fall back on the root assembly for the domain, so we need
-//   to make sure this is set before we call through to the AppDomainManager itself.
-//
-
-Assembly *AppDomain::GetAppDomainManagerEntryAssembly()
-{
-    CONTRACT(Assembly *)
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(HasAppDomainManagerInfo());
-        PRECONDITION(CheckPointer(m_pRootAssembly));
-        POSTCONDITION(CheckPointer(RETVAL));
-    }
-    CONTRACT_END;
-
-    GCX_COOP();
-
-    Assembly *pEntryAssembly = NULL;
-
-    struct
-    {
-        APPDOMAINREF    orDomain;
-        OBJECTREF       orAppDomainManager;
-        ASSEMBLYREF     orEntryAssembly;
-    }
-    gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc);
-
-    gc.orDomain = static_cast<APPDOMAINREF>(GetExposedObject());
-    gc.orAppDomainManager = gc.orDomain->GetAppDomainManager();
-    _ASSERTE(gc.orAppDomainManager != NULL);
-
-    MethodDescCallSite getEntryAssembly(METHOD__APPDOMAIN_MANAGER__GET_ENTRY_ASSEMBLY, &gc.orAppDomainManager);
-    ARG_SLOT argThis = ObjToArgSlot(gc.orAppDomainManager);
-    gc.orEntryAssembly = static_cast<ASSEMBLYREF>(getEntryAssembly.Call_RetOBJECTREF(&argThis));
-
-    if (gc.orEntryAssembly != NULL)
-    {
-        pEntryAssembly = gc.orEntryAssembly->GetAssembly();
-    }
-
-    GCPROTECT_END();
-
-    // If the AppDomainManager did not return an entry assembly, we'll assume the default assembly
-    if (pEntryAssembly == NULL)
-    {
-        pEntryAssembly = m_pRootAssembly;
-    }
-
-    RETURN(pEntryAssembly);
-}
-
-#endif // !FEATURE_CORECLR
 
 //---------------------------------------------------------------------------------------
 //
@@ -12738,45 +10987,6 @@ void AppDomain::InitializeDefaultDomainManager()
 
         LOG((LF_APPDOMAIN, LL_INFO10, "Setting default AppDomainManager '%S', '%S' from hosting API.\n", GetAppDomainManagerAsm(), GetAppDomainManagerType()));
     }
-#ifndef FEATURE_CORECLR
-    else
-    {
-        CLRConfigStringHolder wszConfigAppDomainManagerAssembly(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_AppDomainManagerAsm));
-        CLRConfigStringHolder wszConfigAppDomainManagerType(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_AppDomainManagerType));
-
-        if (wszConfigAppDomainManagerAssembly != NULL &&
-            wszConfigAppDomainManagerType != NULL)
-        {
-            SetAppDomainManagerInfo(wszConfigAppDomainManagerAssembly,
-                                    wszConfigAppDomainManagerType,
-                                    eInitializeNewDomainFlags_None);
-            m_fAppDomainManagerSetInConfig = TRUE;
-
-            LOG((LF_APPDOMAIN, LL_INFO10, "Setting default AppDomainManager '%S', '%S' from application config file.\n", GetAppDomainManagerAsm(), GetAppDomainManagerType()));
-        }
-        else
-        {
-            CLRConfigStringHolder wszEnvironmentAppDomainManagerAssembly(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_LEGACY_APPDOMAIN_MANAGER_ASM));
-            CLRConfigStringHolder wszEnvironmentAppDomainManagerType(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_LEGACY_APPDOMAIN_MANAGER_TYPE));
-
-            if (wszEnvironmentAppDomainManagerAssembly != NULL &&
-                wszEnvironmentAppDomainManagerType != NULL)
-            {
-                SetAppDomainManagerInfo(wszEnvironmentAppDomainManagerAssembly,
-                                        wszEnvironmentAppDomainManagerType,
-                                        eInitializeNewDomainFlags_None);
-                m_fAppDomainManagerSetInConfig = FALSE;
-
-                LOG((LF_APPDOMAIN, LL_INFO10, "Setting default AppDomainManager '%S', '%S' from environment variables.\n", GetAppDomainManagerAsm(), GetAppDomainManagerType()));
-
-                // Reset the environmetn variables so that child processes do not inherit our domain manager
-                // by default.
-                WszSetEnvironmentVariable(CLRConfig::EXTERNAL_LEGACY_APPDOMAIN_MANAGER_ASM.name, NULL);
-                WszSetEnvironmentVariable(CLRConfig::EXTERNAL_LEGACY_APPDOMAIN_MANAGER_TYPE.name, NULL);
-            }
-        }
-    }
-#endif // !FEATURE_CORECLR
 
     // If we found an AppDomain manager to use, create and initialize it
     // Otherwise, initialize the config flags.
@@ -12822,102 +11032,6 @@ void AppDomain::InitializeDefaultDomainManager()
     }
 }
 
-#ifdef FEATURE_CLICKONCE
-
-//---------------------------------------------------------------------------------------
-//
-// If we are launching a ClickOnce application, setup the default domain with the deails
-// of the application.
-//
-
-void AppDomain::InitializeDefaultClickOnceDomain()
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-        THROWS;
-        PRECONDITION(GetId().m_dwId == DefaultADID);
-    }
-    CONTRACTL_END;
-
-    //
-    // If the CLR is being started to run a ClickOnce application, then capture the information about the
-    // application to setup the default domain wtih.
-    //
-
-    if (CorCommandLine::m_pwszAppFullName != NULL)
-    {
-        struct
-        {
-            OBJECTREF   orThis;
-            STRINGREF   orAppFullName;
-            PTRARRAYREF orManifestPathsArray;
-            PTRARRAYREF orActivationDataArray;
-        }
-        gc;
-        ZeroMemory(&gc, sizeof(gc));
-
-        GCPROTECT_BEGIN(gc);
-
-        gc.orAppFullName = StringObject::NewString(CorCommandLine::m_pwszAppFullName);
-
-        // If specific manifests have been pointed at, make a note of them
-        if (CorCommandLine::m_dwManifestPaths > 0)
-        {
-            _ASSERTE(CorCommandLine::m_ppwszManifestPaths != NULL);
-
-            gc.orManifestPathsArray = static_cast<PTRARRAYREF>(AllocateObjectArray(CorCommandLine::m_dwManifestPaths, g_pStringClass));
-            for (DWORD i = 0; i < CorCommandLine::m_dwManifestPaths; ++i)
-            {
-                STRINGREF str = StringObject::NewString(CorCommandLine::m_ppwszManifestPaths[i]);
-                gc.orManifestPathsArray->SetAt(i, str);
-            }
-        }
-
-        // Check for any activation parameters to pass to the ClickOnce application
-        if (CorCommandLine::m_dwActivationData > 0)
-        {
-            _ASSERTE(CorCommandLine::m_ppwszActivationData != NULL);
-
-            gc.orActivationDataArray = static_cast<PTRARRAYREF>(AllocateObjectArray(CorCommandLine::m_dwActivationData, g_pStringClass));
-            for (DWORD i = 0; i < CorCommandLine::m_dwActivationData; ++i)
-            {
-                STRINGREF str = StringObject::NewString(CorCommandLine::m_ppwszActivationData[i]);
-                gc.orActivationDataArray->SetAt(i, str);
-            }
-        }
-
-        gc.orThis = GetExposedObject();
-
-        MethodDescCallSite setupDefaultClickOnceDomain(METHOD__APP_DOMAIN__SETUP_DEFAULT_CLICKONCE_DOMAIN);
-        ARG_SLOT args[] =
-        {
-            ObjToArgSlot(gc.orThis),
-            ObjToArgSlot(gc.orAppFullName),
-            ObjToArgSlot(gc.orManifestPathsArray),
-            ObjToArgSlot(gc.orActivationDataArray),
-        };
-        setupDefaultClickOnceDomain.Call(args);
-
-        GCPROTECT_END();
-    }
-}
-
-BOOL AppDomain::IsClickOnceAppDomain()
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-        THROWS;
-    }
-    CONTRACTL_END;
-
-    return ((APPDOMAINREF)GetExposedObject())->HasActivationContext();
-}
-
-#endif // FEATURE_CLICKONCE
 
 //---------------------------------------------------------------------------------------
 //
@@ -12960,11 +11074,9 @@ void AppDomain::CreateADUnloadWorker()
 {
     STANDARD_VM_CONTRACT;
 
-#ifdef FEATURE_CORECLR
     // Do not create adUnload thread if there is only default domain
     if(IsSingleAppDomain())
         return;
-#endif
 
 Retry:
     BOOL fCreator = FALSE;
@@ -13818,95 +11930,6 @@ PTR_MethodTable BaseDomain::LookupType(UINT32 id) {
 
 #ifndef DACCESS_COMPILE
 
-#ifndef FEATURE_CORECLR
-//------------------------------------------------------------------------
-DWORD* SetupCompatibilityFlags()
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-    } CONTRACTL_END;
-
-    LPCWSTR buf;
-    bool return_null = true;
-
-    FAULT_NOT_FATAL(); // we can simply give up
-
-    BEGIN_SO_INTOLERANT_CODE_NO_THROW_CHECK_THREAD(SetLastError(COR_E_STACKOVERFLOW); return NULL;)
-    InlineSString<4> bufString;
-    
-    if (WszGetEnvironmentVariable(W("UnsupportedCompatSwitchesEnabled"), bufString) != 0)
-    {
-        buf = bufString.GetUnicode();
-        if (buf[0] != '1' || buf[1] != '\0')
-        {
-            return_null = true;
-        }
-        else
-        {
-            return_null = false;
-        }
-
-    }
-    END_SO_INTOLERANT_CODE
-
-    if (return_null)
-        return NULL;
-
-    static const LPCWSTR rgFlagNames[] = {
-#define COMPATFLAGDEF(name) TEXT(#name),
-#include "compatibilityflagsdef.h"
-    };
-
-    int size = (compatCount+31) / 32;
-    DWORD* pFlags = new (nothrow) DWORD[size];
-    if (pFlags == NULL)
-        return NULL;
-    ZeroMemory(pFlags, size * sizeof(DWORD));
-
-    BEGIN_SO_INTOLERANT_CODE_NO_THROW_CHECK_THREAD(SetLastError(COR_E_STACKOVERFLOW); return NULL;)
-    InlineSString<4> bufEnvString;
-    for (int i = 0; i < COUNTOF(rgFlagNames); i++)
-    {
-        if (WszGetEnvironmentVariable(rgFlagNames[i], bufEnvString) == 0)
-            continue;
-
-        buf = bufEnvString.GetUnicode();
-        if (buf[0] != '1' || buf[1] != '\0')
-            continue;
-
-        pFlags[i / 32] |= 1 << (i % 32);
-    }
-    END_SO_INTOLERANT_CODE
-    
-    return pFlags;
-}
-
-//------------------------------------------------------------------------
-static VolatilePtr<DWORD> g_pCompatibilityFlags = (DWORD*)(-1);
-
-DWORD* GetGlobalCompatibilityFlags()
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-    } CONTRACTL_END;
-
-    if (g_pCompatibilityFlags == (DWORD*)(-1))
-    {
-        DWORD *pCompatibilityFlags = SetupCompatibilityFlags();
-
-        if (FastInterlockCompareExchangePointer(g_pCompatibilityFlags.GetPointer(), pCompatibilityFlags, reinterpret_cast<DWORD *>(-1)) != (VOID*)(-1))
-        {
-            delete [] pCompatibilityFlags;
-        }
-    }
-
-    return g_pCompatibilityFlags;
-}
-#endif // !FEATURE_CORECLR
 
 //------------------------------------------------------------------------
 BOOL GetCompatibilityFlag(CompatibilityFlag flag)
@@ -13917,16 +11940,7 @@ BOOL GetCompatibilityFlag(CompatibilityFlag flag)
         SO_TOLERANT;
     } CONTRACTL_END;
 
-#ifndef FEATURE_CORECLR
-    DWORD *pFlags = GetGlobalCompatibilityFlags();
-
-    if (pFlags != NULL)
-        return (pFlags[flag / 32] & (1 << (flag % 32))) ? TRUE : FALSE;
-    else
-        return FALSE;
-#else // !FEATURE_CORECLR
     return FALSE;
-#endif // !FEATURE_CORECLR
 }
 #endif // !DACCESS_COMPILE
 
@@ -14125,7 +12139,6 @@ AppDomain::AssemblyIterator::Next_UnsafeNoAddRef(
     return FALSE;
 } // AppDomain::AssemblyIterator::Next_UnsafeNoAddRef
 
-#ifdef FEATURE_CORECLR
 
 //---------------------------------------------------------------------------------------
 // 
@@ -14163,11 +12176,10 @@ BOOL AppDomain::IsImageFullyTrusted(PEImage* pPEImage)
     return IsImageFromTrustedPath(pPEImage);
 }
 
-#endif //FEATURE_CORECLR
 
 #endif //!DACCESS_COMPILE
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#if !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
 
 // Returns a BOOL indicating if the binding model has been locked for the AppDomain
 BOOL AppDomain::IsBindingModelLocked()
@@ -14409,7 +12421,7 @@ HRESULT RuntimeInvokeHostAssemblyResolver(INT_PTR pManagedAssemblyLoadContextToB
     return hr;
     
 }
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#endif // !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
 
 //approximate size of loader data
 //maintained for each assembly
@@ -14733,10 +12745,6 @@ void AppDomain::PublishHostedAssembly(
     }
     else
     {
-#ifdef FEATURE_APPX_BINDER
-        // In AppX processes, all PEAssemblies that are reach this stage should have host binders.
-        _ASSERTE(!AppX::IsAppXProcess());
-#endif
     }
 }
 
@@ -14804,10 +12812,6 @@ void AppDomain::UpdatePublishHostedAssembly(
     }
     else
     {
-#ifdef FEATURE_APPX_BINDER
-        // In AppX processes, all PEAssemblies that are reach this stage should have host binders.
-        _ASSERTE(!AppX::IsAppXProcess());
-#endif
 
         pAssembly->UpdatePEFileWorker(pFile);
     }
@@ -14848,7 +12852,7 @@ void AppDomain::UnPublishHostedAssembly(
     }
 }
 
-#if defined(FEATURE_CORECLR) && defined(FEATURE_COMINTEROP)
+#if defined(FEATURE_COMINTEROP)
 HRESULT AppDomain::SetWinrtApplicationContext(SString &appLocalWinMD)
 {
     STANDARD_VM_CONTRACT;
@@ -14863,7 +12867,7 @@ HRESULT AppDomain::SetWinrtApplicationContext(SString &appLocalWinMD)
     return m_pWinRtBinder->SetApplicationContext(pApplicationContext, appLocalWinMD);
 }
 
-#endif // FEATURE_CORECLR && FEATURE_COMINTEROP
+#endif // FEATURE_COMINTEROP
 
 #endif //!DACCESS_COMPILE
 
@@ -14902,7 +12906,7 @@ PTR_DomainAssembly AppDomain::FindAssembly(PTR_ICLRPrivAssembly pHostAssembly)
     }
 }
 
-#if !defined(DACCESS_COMPILE) && defined(FEATURE_CORECLR) && defined(FEATURE_NATIVE_IMAGE_GENERATION)
+#if !defined(DACCESS_COMPILE) && defined(FEATURE_NATIVE_IMAGE_GENERATION)
 
 void ZapperSetBindingPaths(ICorCompilationDomain *pDomain, SString &trustedPlatformAssemblies, SString &platformResourceRoots, SString &appPaths, SString &appNiPaths)
 {
@@ -14917,7 +12921,7 @@ void ZapperSetBindingPaths(ICorCompilationDomain *pDomain, SString &trustedPlatf
 
 #endif
 
-#if defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
+#if !defined(CROSSGEN_COMPILE)
 bool IsSingleAppDomain()
 {
     STARTUP_FLAGS flags = CorHost2::GetStartupFlags();
diff --git a/src/vm/appdomain.hpp b/src/vm/appdomain.hpp
index 670f685fdc..9bf43b8ffe 100644
--- a/src/vm/appdomain.hpp
+++ b/src/vm/appdomain.hpp
@@ -19,9 +19,6 @@
 #include "assembly.hpp"
 #include "clsload.hpp"
 #include "eehash.h"
-#ifdef FEATURE_FUSION
-#include "fusion.h"
-#endif
 #include "arraylist.h"
 #include "comreflectioncache.hpp"
 #include "comutilnative.h"
@@ -31,9 +28,7 @@
 #include "ilstubcache.h"
 #include "testhookmgr.h"
 #include "gcheaputilities.h"
-#ifdef FEATURE_VERSIONING
 #include "../binder/inc/applicationcontext.hpp"
-#endif // FEATURE_VERSIONING
 #include "rejit.h"
 
 #ifdef FEATURE_MULTICOREJIT
@@ -42,10 +37,6 @@
 
 #ifdef FEATURE_COMINTEROP
 #include "clrprivbinderwinrt.h"
-#ifndef FEATURE_CORECLR
-#include "clrprivbinderreflectiononlywinrt.h"
-#include "clrprivtypecachereflectiononlywinrt.h"
-#endif
 #include "..\md\winmd\inc\adapter.h"
 #include "winrttypenameconverter.h"
 #endif // FEATURE_COMINTEROP
@@ -1338,16 +1329,10 @@ public:
 
     BOOL ContainsOBJECTHANDLE(OBJECTHANDLE handle);
 
-#ifdef FEATURE_FUSION
-    IApplicationContext *GetFusionContext() {LIMITED_METHOD_CONTRACT;  return m_pFusionContext; }
-#else
     IUnknown *GetFusionContext() {LIMITED_METHOD_CONTRACT;  return m_pFusionContext; }
     
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)    
     CLRPrivBinderCoreCLR *GetTPABinderContext() {LIMITED_METHOD_CONTRACT;  return m_pTPABinderContext; }
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
-#endif
 
     CrstExplicitInit * GetLoaderAllocatorReferencesLock()
     {
@@ -1392,16 +1377,10 @@ protected:
     // Fusion context, used for adding assemblies to the is domain. It defines
     // fusion properties for finding assemblyies such as SharedBinPath,
     // PrivateBinPath, Application Directory, etc.
-#ifdef FEATURE_FUSION    
-    IApplicationContext* m_pFusionContext; // Binding context for the domain
-#else
     IUnknown *m_pFusionContext; // Current binding context for the domain
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)    
     CLRPrivBinderCoreCLR *m_pTPABinderContext; // Reference to the binding context that holds TPA list details
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
-#endif    
 
     HandleTableBucket *m_hHandleTableBucket;
 
@@ -1417,7 +1396,7 @@ protected:
     // Information regarding the managed standard interfaces.
     MngStdInterfacesInfo        *m_pMngStdInterfacesInfo;
     
-    // WinRT binder (only in classic = non-AppX; AppX has the WinRT binder inside code:CLRPrivBinderAppX)
+    // WinRT binder
     PTR_CLRPrivBinderWinRT m_pWinRtBinder;
 #endif // FEATURE_COMINTEROP
 
@@ -1793,9 +1772,7 @@ public:
 protected:
     DWORD m_type;
     LPVOID m_value;
-#if FEATURE_VERSIONING    
     ULONG   m_uIdentityHash;
-#endif
 };
 #endif // FEATURE_LOADER_OPTIMIZATION
 
@@ -1805,9 +1782,6 @@ protected:
 struct FailedAssembly {
     SString displayName;
     SString location;
-#ifdef FEATURE_FUSION    
-    LOADCTX_TYPE context;
-#endif
     HRESULT error;
 
     void Initialize(AssemblySpec *pSpec, Exception *ex)
@@ -1830,9 +1804,6 @@ struct FailedAssembly {
         // If the parent hasn't been set but the code base has, use LoadFrom.
         // Otherwise, use the default.
         //
-#ifdef FEATURE_FUSION        
-        context = pSpec->GetParentIAssembly() ? pSpec->GetParentIAssembly()->GetFusionLoadContext() : LOADCTX_TYPE_LOADFROM;
-#endif // FEATURE_FUSION
     }
 };
 
@@ -1988,15 +1959,10 @@ public:
     inline LPCWSTR GetAppDomainManagerType();
     inline EInitializeNewDomainFlags GetAppDomainManagerInitializeNewDomainFlags();
 
-#ifndef FEATURE_CORECLR
-    inline BOOL AppDomainManagerSetFromConfig();
-    Assembly *GetAppDomainManagerEntryAssembly();
-    void ComputeTargetFrameworkName();
-#endif // FEATURE_CORECLR
 
-#if defined(FEATURE_CORECLR) && defined(FEATURE_COMINTEROP)
+#if defined(FEATURE_COMINTEROP)
     HRESULT SetWinrtApplicationContext(SString &appLocalWinMD);
-#endif // FEATURE_CORECLR && FEATURE_COMINTEROP
+#endif // FEATURE_COMINTEROP
 
     BOOL CanReversePInvokeEnter();
     void SetReversePInvokeCannotEnter();
@@ -2032,10 +1998,6 @@ public:
     virtual BOOL IsAppDomain() { LIMITED_METHOD_DAC_CONTRACT; return TRUE; }
     virtual PTR_AppDomain AsAppDomain() { LIMITED_METHOD_CONTRACT; return dac_cast<PTR_AppDomain>(this); }
 
-#ifndef FEATURE_CORECLR
-    void InitializeSorting(OBJECTREF* ppAppdomainSetup);
-    void InitializeHashing(OBJECTREF* ppAppdomainSetup);
-#endif
 
     OBJECTREF DoSetup(OBJECTREF* setupInfo);
 
@@ -2290,7 +2252,6 @@ public:
         return AssemblyIterator::Create(this, assemblyIterationFlags);
     }
 
-#ifdef FEATURE_CORECLR
 private:
     struct NativeImageDependenciesEntry
     {
@@ -2346,7 +2307,6 @@ public:
     void SetNativeDllSearchDirectories(LPCWSTR paths);
     BOOL HasNativeDllSearchDirectories();
     void ShutdownNativeDllSearchDirectories();
-#endif // FEATURE_CORECLR
 
 public:
     SIZE_T GetAssemblyCount()
@@ -2413,12 +2373,6 @@ public:
     DomainFile *LoadDomainNeutralModuleDependency(Module *pModule, FileLoadLevel targetLevel);
 #endif
 
-#ifdef FEATURE_FUSION
-    PEAssembly *BindExplicitAssembly(HMODULE hMod, BOOL bindable);
-    Assembly *LoadExplicitAssembly(HMODULE hMod, BOOL bindable);
-    void GetFileFromFusion(IAssembly *pIAssembly, LPCWSTR wszModuleName,
-                           SString &path);
-#endif
     // private:
     void LoadSystemAssemblies();
 
@@ -2485,10 +2439,6 @@ public:
     //****************************************************************************************
     // Determines if the image is to be loaded into the shared assembly or an individual
     // appdomains.
-#ifndef FEATURE_CORECLR    
-    BOOL ApplySharePolicy(DomainAssembly *pFile);
-    BOOL ApplySharePolicyFlag(DomainAssembly *pFile);
-#endif    
 #endif // FEATURE_LOADER_OPTIMIZATION
 
     BOOL HasSetSecurityPolicy();
@@ -2577,19 +2527,11 @@ public:
 
     //****************************************************************************************
     //
-#ifdef FEATURE_FUSION    
-    static BOOL SetContextProperty(IApplicationContext* pFusionContext,
-                                   LPCWSTR pProperty,
-                                   OBJECTREF* obj);
-#endif
     //****************************************************************************************
     //
     // Uses the first assembly to add an application base to the Context. This is done
     // in a lazy fashion so executables do not take the perf hit unless the load other
     // assemblies
-#ifdef FEATURE_FUSION    
-    LPWSTR GetDynamicDir();
-#endif
 #ifndef DACCESS_COMPILE
     void OnAssemblyLoad(Assembly *assem);
     void OnAssemblyLoadUnlocked(Assembly *assem);
@@ -2784,15 +2726,8 @@ public:
 
     void InitializeDomainContext(BOOL allowRedirects, LPCWSTR pwszPath, LPCWSTR pwszConfig);
 
-#ifdef FEATURE_FUSION
-    IApplicationContext *CreateFusionContext();
-    void SetupLoaderOptimization(DWORD optimization);
-#endif
-#ifdef FEATURE_VERSIONING
     IUnknown *CreateFusionContext();
-#endif // FEATURE_VERSIONING
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
     void OverrideDefaultContextBinder(IUnknown *pOverrideBinder)
     {
         LIMITED_METHOD_CONTRACT;
@@ -2803,7 +2738,6 @@ public:
         m_pFusionContext = pOverrideBinder;
     }
     
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
 #ifdef FEATURE_PREJIT
     CorCompileConfigFlags GetNativeConfigFlags();
@@ -2822,9 +2756,6 @@ public:
     //****************************************************************************************
     // Manage a pool of asyncrhonous objects used to fetch assemblies.  When a sink is released
     // it places itself back on the pool list.  Only one object is kept in the pool.
-#ifdef FEATURE_FUSION
-    AssemblySink* AllocateAssemblySink(AssemblySpec* pSpec);
-#endif
     void SetIsUserCreatedDomain()
     {
         LIMITED_METHOD_CONTRACT;
@@ -3421,15 +3352,9 @@ private:
 
     void InitializeDefaultDomainManager ();
 
-#ifdef FEATURE_CLICKONCE
-    void InitializeDefaultClickOnceDomain();
-#endif // FEATURE_CLICKONCE
 
     void InitializeDefaultDomainSecurity();
 public:
-#ifdef FEATURE_CLICKONCE
-    BOOL IsClickOnceAppDomain();
-#endif // FEATURE_CLICKONCE
 
 protected:
     BOOL PostBindResolveAssembly(AssemblySpec  *pPrePolicySpec,
@@ -3480,9 +3405,6 @@ private:
         BOOL isTerminating;
         BOOL *pResult;
     };
-    #ifndef FEATURE_CORECLR 
-    static void RaiseUnhandledExceptionEvent_Wrapper(LPVOID /* RaiseUnhandled_Args * */);
-    #endif
 
 
     static void AllowThreadEntrance(AppDomain *pApp);
@@ -3802,19 +3724,14 @@ private:
     // Stub caches for Method stubs
     //---------------------------------------------------------
 
-#ifdef FEATURE_FUSION
-    void TurnOnBindingRedirects();
-#endif
 public:
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 private:
     Volatile<BOOL> m_fIsBindingModelLocked;
 public:
     BOOL IsHostAssemblyResolverInUse();
     BOOL IsBindingModelLocked();
     BOOL LockBindingModel();
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
     UMEntryThunkCache *GetUMEntryThunkCache();
 
@@ -3843,11 +3760,9 @@ public:
         ILLEGAL_VERIFICATION_DOMAIN =       0x8000, // This can't be a verification domain
         IGNORE_UNHANDLED_EXCEPTIONS =      0x10000, // AppDomain was created using the APPDOMAIN_IGNORE_UNHANDLED_EXCEPTIONS flag
         ENABLE_PINVOKE_AND_CLASSIC_COMINTEROP    =      0x20000, // AppDomain was created using the APPDOMAIN_ENABLE_PINVOKE_AND_CLASSIC_COMINTEROP flag
-#ifdef FEATURE_CORECLR
         ENABLE_SKIP_PLAT_CHECKS         = 0x200000, // Skip various assembly checks (like platform check)
         ENABLE_ASSEMBLY_LOADFILE        = 0x400000, // Allow Assembly.LoadFile in CoreCLR
         DISABLE_TRANSPARENCY_ENFORCEMENT= 0x800000, // Disable enforcement of security transparency rules
-#endif        
     };
 
     SecurityContext *m_pSecContext;
@@ -3861,9 +3776,7 @@ public:
     BOOL    m_fAppDomainManagerSetInConfig;
     EInitializeNewDomainFlags m_dwAppDomainManagerInitializeDomainFlags;
 
-#ifdef FEATURE_CORECLR 
     ArrayList m_NativeDllSearchDirectories;
-#endif
     BOOL m_ReversePInvokeCanEnter;
     bool m_ForceTrivialWaitOperations;
     // Section to support AD unload due to escalation
@@ -3891,10 +3804,8 @@ public:
         return (m_Stage == STAGE_UNLOAD_REQUESTED);
     }
 
-#ifdef FEATURE_CORECLR
     BOOL IsImageFromTrustedPath(PEImage* pImage);
     BOOL IsImageFullyTrusted(PEImage* pImage);
-#endif
 
 #ifdef FEATURE_TYPEEQUIVALENCE
 private:
@@ -3941,15 +3852,6 @@ private:
 #endif //FEATURE_COMINTEROP
 
 public:
-#ifndef FEATURE_CORECLR
-    BOOL m_bUseOsSorting;
-    DWORD m_sortVersion;
-    COMNlsCustomSortLibrary *m_pCustomSortLibrary;
-#if _DEBUG
-    BOOL m_bSortingInitialized;
-#endif // _DEBUG
-    COMNlsHashProvider *m_pNlsHashProvider;
-#endif // !FEATURE_CORECLR
 
 private:
     // This is the root-level default load context root binder. If null, then
@@ -4367,9 +4269,6 @@ public:
     }
 #endif // DACCESS_COMPILE
 
-#ifndef FEATURE_CORECLR    
-	static void ExecuteMainMethod(HMODULE hMod, __in_opt LPWSTR path = NULL);
-#endif
     static void ActivateApplication(int *pReturnValue);
 
     static void InitializeDefaultDomain(BOOL allowRedirects, ICLRPrivBinder * pBinder = NULL);
@@ -4446,9 +4345,6 @@ public:
 
     //****************************************************************************************
     // return the dev path
-#ifdef FEATURE_FUSION    
-    void GetDevpathW(__out_ecount_opt(1) LPWSTR* pPath, DWORD* pSize);
-#endif
 
 #ifndef DACCESS_COMPILE
     void IncrementNumAppDomains ()
@@ -4751,15 +4647,8 @@ private:
 
     InlineSString<100>  m_BaseLibrary;
 
-#ifdef FEATURE_VERSIONING
-
     InlineSString<100>  m_SystemDirectory;
 
-#else
-
-    LPCWSTR             m_SystemDirectory;
-
-#endif
 
     LPWSTR      m_pwDevpath;
     DWORD       m_dwDevpath;
diff --git a/src/vm/appdomain.inl b/src/vm/appdomain.inl
index 210334c78e..2986588ddc 100644
--- a/src/vm/appdomain.inl
+++ b/src/vm/appdomain.inl
@@ -231,13 +231,6 @@ inline LPCWSTR AppDomain::GetAppDomainManagerType()
     return m_AppDomainManagerType;
 }
 
-#ifndef FEATURE_CORECLR
-inline BOOL AppDomain::AppDomainManagerSetFromConfig()
-{
-    WRAPPER_NO_CONTRACT;
-    return m_fAppDomainManagerSetInConfig;
-}
-#endif // !FEATURE_CORECLR
 
 inline EInitializeNewDomainFlags AppDomain::GetAppDomainManagerInitializeNewDomainFlags()
 {
@@ -245,7 +238,6 @@ inline EInitializeNewDomainFlags AppDomain::GetAppDomainManagerInitializeNewDoma
     return m_dwAppDomainManagerInitializeDomainFlags;
 }
 
-#ifdef FEATURE_CORECLR
 inline AppDomain::PathIterator AppDomain::IterateNativeDllSearchDirectories()
 {
     WRAPPER_NO_CONTRACT;
@@ -260,7 +252,6 @@ inline BOOL AppDomain::HasNativeDllSearchDirectories()
     return m_NativeDllSearchDirectories.GetCount() !=0;
 }
 
-#endif // FEATURE_CORECLR
 
 inline BOOL AppDomain::CanReversePInvokeEnter()
 {
diff --git a/src/vm/appdomainhelper.cpp b/src/vm/appdomainhelper.cpp
deleted file mode 100644
index 2c0531648f..0000000000
--- a/src/vm/appdomainhelper.cpp
+++ /dev/null
@@ -1,546 +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.
-
-
-// 
-
-#include "common.h"
-
-#ifdef FEATURE_REMOTING
-
-#include "appdomainhelper.h"
-#include "appdomain.inl"
-
-void AppDomainHelper::CopyEncodingToByteArray(IN PBYTE   pbData,
-                                              IN DWORD   cbData,
-                                              OUT OBJECTREF* pArray)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(cbData==0 || pbData!=NULL);
-        PRECONDITION(CheckPointer(pArray));
-    }
-    CONTRACTL_END;
-    PREFIX_ASSUME(pArray != NULL);
-
-    U1ARRAYREF pObj;
-
-    if(cbData) {
-        pObj = (U1ARRAYREF)AllocatePrimitiveArray(ELEMENT_TYPE_U1,cbData);
-        memcpyNoGCRefs(pObj->m_Array, pbData, cbData);
-        *pArray = (OBJECTREF) pObj;
-    } else
-        *pArray = NULL;
-
-    VALIDATEOBJECTREF(*pArray);
-}
-
-
-void AppDomainHelper::CopyByteArrayToEncoding(IN U1ARRAYREF* pArray,
-                                              OUT PBYTE*   ppbData,
-                                              OUT DWORD*   pcbData)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_COOPERATIVE;
-        PRECONDITION(pArray!=NULL);
-        PRECONDITION(ppbData!=NULL);
-        PRECONDITION(pcbData!=NULL);
-    }
-    CONTRACTL_END;
-
-    VALIDATEOBJECTREF(*pArray);
-
-    if (*pArray == NULL) {
-        *ppbData = NULL;
-        *pcbData = 0;
-        return;
-    }
-
-    DWORD size = (*pArray)->GetNumComponents();
-    if(size) {
-        *ppbData = new BYTE[size];
-        *pcbData = size;
-
-        CopyMemory(*ppbData, (*pArray)->GetDirectPointerToNonObjectElements(), size);
-    }
-}
-
-
-struct MarshalObjectArgs : public CtxTransitionBaseArgs
-{
-    OBJECTREF* orObject;
-    U1ARRAYREF* porBlob;
-};
-
-void MarshalObjectADCallback(MarshalObjectArgs * args)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-    MethodDescCallSite marshalObject(METHOD__APP_DOMAIN__MARSHAL_OBJECT);
-    
-    ARG_SLOT argsCall[] = {
-        ObjToArgSlot(*(args->orObject))
-    };
-    
-    *(args->porBlob) = (U1ARRAYREF) marshalObject.Call_RetOBJECTREF(argsCall);
-}
-
-
-// Marshal a single object into a serialized blob.
-void AppDomainHelper::MarshalObject(ADID appDomain,
-                                    IN OBJECTREF *orObject, // Object must be GC protected
-                                    OUT U1ARRAYREF *porBlob)
-{
-
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(orObject!=NULL);
-        PRECONDITION(porBlob!=NULL);
-        PRECONDITION(IsProtectedByGCFrame(orObject));
-    }
-    CONTRACTL_END;
-
-    VALIDATEOBJECTREF(*orObject);
-
-    MarshalObjectArgs args;
-    args.orObject = orObject;
-    args.porBlob = porBlob;
-    
-    MakeCallWithPossibleAppDomainTransition(appDomain, (FPAPPDOMAINCALLBACK) MarshalObjectADCallback, &args);
-
-    VALIDATEOBJECTREF(*porBlob);
-
-}
-
-void AppDomainHelper::MarshalObject(IN OBJECTREF *orObject, // Object must be GC protected
-                                    OUT U1ARRAYREF *porBlob)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(orObject!=NULL);
-        PRECONDITION(porBlob!=NULL);
-        PRECONDITION(IsProtectedByGCFrame(orObject));
-    }
-    CONTRACTL_END;
-
-    VALIDATEOBJECTREF(*orObject);
-
-    MethodDescCallSite marshalObject(METHOD__APP_DOMAIN__MARSHAL_OBJECT);
-    
-    ARG_SLOT argsCall[] = {
-        ObjToArgSlot(*orObject)
-    };
-    
-    *porBlob = (U1ARRAYREF) marshalObject.Call_RetOBJECTREF(argsCall);
-
-    VALIDATEOBJECTREF(*porBlob);
-}
-
-// Marshal a single object into a serialized blob.
-void AppDomainHelper::MarshalObject(IN AppDomain *pDomain,
-                                    IN OBJECTREF *orObject, // Object must be GC protected
-                                    OUT BYTE    **ppbBlob,
-                                    OUT DWORD    *pcbBlob)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(pDomain!=NULL);
-        PRECONDITION(orObject!=NULL);
-        PRECONDITION(ppbBlob!=NULL);
-        PRECONDITION(pcbBlob!=NULL);
-        PRECONDITION(IsProtectedByGCFrame(orObject));
-    }
-    CONTRACTL_END;
-
-    VALIDATEOBJECTREF(*orObject);
-
-    U1ARRAYREF orBlob = NULL;
-
-    GCPROTECT_BEGIN(orBlob);
-
-    MethodDescCallSite marshalObject(METHOD__APP_DOMAIN__MARSHAL_OBJECT);
-
-    ENTER_DOMAIN_PTR(pDomain,ADV_RUNNINGIN)
-    {
-        ARG_SLOT args[] = 
-        {
-            ObjToArgSlot(*orObject)
-        };
-
-        orBlob = (U1ARRAYREF) marshalObject.Call_RetOBJECTREF(args);
-    }
-    END_DOMAIN_TRANSITION;
-        
-    if (orBlob != NULL)
-        CopyByteArrayToEncoding(&orBlob,
-                                ppbBlob,
-                                pcbBlob);
-    GCPROTECT_END();
-}
-
-// Marshal two objects into serialized blobs.
-void AppDomainHelper::MarshalObjects(IN AppDomain *pDomain,
-                                    IN OBJECTREF  *orObject1,
-                                    IN OBJECTREF  *orObject2,
-                                    OUT BYTE    **ppbBlob1,
-                                    OUT DWORD    *pcbBlob1,
-                                    OUT BYTE    **ppbBlob2,
-                                    OUT DWORD    *pcbBlob2)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(pDomain!=NULL);
-        PRECONDITION(orObject1!=NULL);
-        PRECONDITION(ppbBlob1!=NULL);
-        PRECONDITION(pcbBlob1!=NULL);
-        PRECONDITION(orObject2!=NULL);
-        PRECONDITION(ppbBlob2!=NULL);
-        PRECONDITION(pcbBlob2!=NULL);
-        PRECONDITION(IsProtectedByGCFrame(orObject1));
-        PRECONDITION(IsProtectedByGCFrame(orObject2));
-    }
-    CONTRACTL_END;
-
-    VALIDATEOBJECTREF(*orObject1);
-    VALIDATEOBJECTREF(*orObject2);
-
-    struct _gc {
-        U1ARRAYREF  orBlob1;
-        U1ARRAYREF  orBlob2;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc);
-
-    MethodDescCallSite marshalObjects(METHOD__APP_DOMAIN__MARSHAL_OBJECTS);
-
-    ENTER_DOMAIN_PTR(pDomain,ADV_RUNNINGIN)
-    {
-        ARG_SLOT args[] = 
-        {
-            ObjToArgSlot(*orObject1),
-            ObjToArgSlot(*orObject2),
-            PtrToArgSlot(&gc.orBlob2),
-        };
-
-        gc.orBlob1 = (U1ARRAYREF) marshalObjects.Call_RetOBJECTREF(args);
-    }
-    END_DOMAIN_TRANSITION;
-
-    if (gc.orBlob1 != NULL)
-    {
-        CopyByteArrayToEncoding(&gc.orBlob1,
-                                ppbBlob1,
-                                pcbBlob1);
-    }
-    
-    if (gc.orBlob2 != NULL)
-    {
-        CopyByteArrayToEncoding(&gc.orBlob2,
-                                ppbBlob2,
-                                pcbBlob2);
-    }
-    
-    GCPROTECT_END();
-}
-
-// Unmarshal a single object from a serialized blob.
-// Callers must GC protect both porBlob and porObject.
-void AppDomainHelper::UnmarshalObject(IN AppDomain  *pDomain,
-                                     IN U1ARRAYREF  *porBlob,  // Object must be GC protected
-                                     OUT OBJECTREF  *porObject)  // Object must be GC protected
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(pDomain!=NULL);
-        PRECONDITION(porBlob!=NULL);
-        PRECONDITION(porObject!=NULL);
-        PRECONDITION(IsProtectedByGCFrame(porBlob));
-        PRECONDITION(IsProtectedByGCFrame(porObject));
-    }
-    CONTRACTL_END;
-
-    VALIDATEOBJECTREF(*porBlob);
-
-    MethodDescCallSite unmarshalObject(METHOD__APP_DOMAIN__UNMARSHAL_OBJECT);
-
-    ENTER_DOMAIN_PTR(pDomain,ADV_RUNNINGIN)
-    {
-        ARG_SLOT args[] = 
-        {
-            ObjToArgSlot(*porBlob)
-        };
-
-        *porObject = unmarshalObject.Call_RetOBJECTREF(args);
-    }
-    END_DOMAIN_TRANSITION;
-
-    VALIDATEOBJECTREF(*porObject);
-}
-
-// Unmarshal a single object from a serialized blob.
-void AppDomainHelper::UnmarshalObject(IN AppDomain   *pDomain,
-                                     IN BYTE        *pbBlob,
-                                     IN DWORD        cbBlob,
-                                     OUT OBJECTREF  *porObject)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(pDomain!=NULL);
-        PRECONDITION(porObject!=NULL);
-        PRECONDITION(IsProtectedByGCFrame(porObject));
-    }
-    CONTRACTL_END;
-
-    OBJECTREF orBlob = NULL;
-
-    MethodDescCallSite unmarshalObject(METHOD__APP_DOMAIN__UNMARSHAL_OBJECT);
-
-    ENTER_DOMAIN_PTR(pDomain,ADV_RUNNINGIN)
-    {
-        GCPROTECT_BEGIN(orBlob);
-
-        AppDomainHelper::CopyEncodingToByteArray(pbBlob,
-                                                cbBlob,
-                                                &orBlob);
-
-        ARG_SLOT args[] = 
-        {
-            ObjToArgSlot(orBlob)
-        };
-
-        *porObject = unmarshalObject.Call_RetOBJECTREF(args);
-
-        GCPROTECT_END();
-    }
-    END_DOMAIN_TRANSITION;
-
-    VALIDATEOBJECTREF(*porObject);
-}
-
-// Unmarshal two objects from serialized blobs.
-void AppDomainHelper::UnmarshalObjects(IN AppDomain   *pDomain,
-                                      IN BYTE        *pbBlob1,
-                                      IN DWORD        cbBlob1,
-                                      IN BYTE        *pbBlob2,
-                                      IN DWORD        cbBlob2,
-                                      OUT OBJECTREF  *porObject1,
-                                      OUT OBJECTREF  *porObject2)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(pDomain!=NULL);
-        PRECONDITION(porObject1!=NULL);
-        PRECONDITION(porObject2!=NULL);
-        PRECONDITION(IsProtectedByGCFrame(porObject1));
-        PRECONDITION(IsProtectedByGCFrame(porObject2));
-    }
-    CONTRACTL_END;
-
-    MethodDescCallSite unmarshalObjects(METHOD__APP_DOMAIN__UNMARSHAL_OBJECTS);
-
-    struct _gc {
-        OBJECTREF  orBlob1;
-        OBJECTREF  orBlob2;
-        OBJECTREF  orObject2;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    ENTER_DOMAIN_PTR(pDomain,ADV_RUNNINGIN)
-    {
-
-        GCPROTECT_BEGIN(gc);
-
-        AppDomainHelper::CopyEncodingToByteArray(pbBlob1,
-                                                cbBlob1,
-                                                &gc.orBlob1);
-
-        AppDomainHelper::CopyEncodingToByteArray(pbBlob2,
-                                                cbBlob2,
-                                                &gc.orBlob2);
-
-        ARG_SLOT args[] = 
-        {
-            ObjToArgSlot(gc.orBlob1),
-            ObjToArgSlot(gc.orBlob2),
-            PtrToArgSlot(&gc.orObject2),
-        };
-
-        *porObject1 = unmarshalObjects.Call_RetOBJECTREF(args);
-        *porObject2 = gc.orObject2;
-
-        GCPROTECT_END();
-    }
-    END_DOMAIN_TRANSITION;
-
-    VALIDATEOBJECTREF(*porObject1);
-    VALIDATEOBJECTREF(*porObject2);
-}
-
-// Copy an object from the given appdomain into the current appdomain.
-OBJECTREF AppDomainHelper::CrossContextCopyFrom(IN ADID dwDomainId,
-                                                IN OBJECTREF *orObject) // Object must be GC protected
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(orObject!=NULL);
-        PRECONDITION(IsProtectedByGCFrame(orObject));
-    }
-    CONTRACTL_END;
-
-    struct _gc
-    {
-        U1ARRAYREF  orBlob;
-        OBJECTREF pResult;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-    
-    GCPROTECT_BEGIN(gc);
-    AppDomainHelper::MarshalObject(dwDomainId, orObject, &gc.orBlob);
-    AppDomainHelper::UnmarshalObject(GetAppDomain(), &gc.orBlob, &gc.pResult);
-    GCPROTECT_END();
-    VALIDATEOBJECTREF(gc.pResult);
-    return gc.pResult;
-}
-
-// Copy an object from the given appdomain into the current appdomain.
-OBJECTREF AppDomainHelper::CrossContextCopyTo(IN ADID dwDomainId,
-                                              IN OBJECTREF *orObject) // Object must be GC protected
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(orObject!=NULL);
-        PRECONDITION(IsProtectedByGCFrame(orObject));
-    }
-    CONTRACTL_END;
-
-
-    struct _gc
-    {
-        U1ARRAYREF  orBlob;
-        OBJECTREF pResult;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-    
-    GCPROTECT_BEGIN(gc);
-    AppDomainHelper::MarshalObject(orObject, &gc.orBlob);
-    ENTER_DOMAIN_ID(dwDomainId);
-    AppDomainHelper::UnmarshalObject(GetAppDomain(),&gc.orBlob, &gc.pResult);
-    END_DOMAIN_TRANSITION;
-    GCPROTECT_END();
-    VALIDATEOBJECTREF(gc.pResult);
-    return gc.pResult;
-
-}
-
-// Copy an object from the given appdomain into the current appdomain.
-OBJECTREF AppDomainHelper::CrossContextCopyFrom(IN AppDomain *pDomain,
-                                                IN OBJECTREF *orObject) // Object must be GC protected
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(orObject!=NULL);
-        PRECONDITION(IsProtectedByGCFrame(orObject));
-        PRECONDITION(pDomain!=NULL);
-        PRECONDITION(pDomain != GetAppDomain());
-    }
-    CONTRACTL_END;
-
-    VALIDATEOBJECTREF(*orObject);
-
-    struct _gc {
-        U1ARRAYREF  orBlob;
-        OBJECTREF   result;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc);
-    ENTER_DOMAIN_PTR(pDomain, ADV_RUNNINGIN);
-    AppDomainHelper::MarshalObject(orObject, &gc.orBlob);
-    END_DOMAIN_TRANSITION;
-    AppDomainHelper::UnmarshalObject(GetAppDomain(),&gc.orBlob, &gc.result);
-    GCPROTECT_END();
-
-    VALIDATEOBJECTREF(gc.result);
-
-    return gc.result;
-}
-
-// Copy an object to the given appdomain from the current appdomain.
-OBJECTREF AppDomainHelper::CrossContextCopyTo(IN AppDomain *pDomain,
-                                              IN OBJECTREF *orObject) // Object must be GC protected
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(orObject!=NULL);
-        PRECONDITION(IsProtectedByGCFrame(orObject));
-        PRECONDITION(pDomain!=NULL);
-        PRECONDITION(pDomain != GetAppDomain());
-    }
-    CONTRACTL_END;
-
-    VALIDATEOBJECTREF(*orObject);
-
-    struct _gc {
-        U1ARRAYREF  orBlob;
-        OBJECTREF   result;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc);
-    AppDomainHelper::MarshalObject(orObject, &gc.orBlob);
-    AppDomainHelper::UnmarshalObject(pDomain, &gc.orBlob, &gc.result);
-    GCPROTECT_END();
-
-    VALIDATEOBJECTREF(gc.result);
-
-    return gc.result;
-}
-
-#endif //  FEATURE_REMOTING
-
diff --git a/src/vm/appdomainhelper.h b/src/vm/appdomainhelper.h
deleted file mode 100644
index e331555292..0000000000
--- a/src/vm/appdomainhelper.h
+++ /dev/null
@@ -1,371 +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.
-
-
-#ifndef _APPDOMAIN_HELPER_H_
-#define _APPDOMAIN_HELPER_H_
-
-#ifndef FEATURE_REMOTING
-#error FEATURE_REMOTING is not set, please do not include appdomainhelper.h
-#endif
-
-// Marshal a single object into a serialized blob.
-//
-//
-
-class AppDomainHelper {
-
-    friend class MarshalCache;
-
-    // A pair of helper to move serialization info between managed byte-array and
-    // unmanaged blob.
-    static void AppDomainHelper::CopyEncodingToByteArray(IN PBYTE   pbData, 
-                                                         IN DWORD   cbData, 
-                                                         OUT OBJECTREF* pArray);
-
-    static void AppDomainHelper::CopyByteArrayToEncoding(IN U1ARRAYREF* pArray,
-                                                         OUT PBYTE*   ppbData,
-                                                         OUT DWORD*   pcbData);
-
-public:
-    // Marshal a single object into a serialized blob.
-    static void AppDomainHelper::MarshalObject(IN OBJECTREF  *orObject,
-                                               OUT U1ARRAYREF *porBlob);
-    
-    static void AppDomainHelper::MarshalObject(IN ADID pDomain,
-                                               IN OBJECTREF  *orObject,
-                                               OUT U1ARRAYREF *porBlob);
-    // Marshal one object into a seraialized blob.
-    static void AppDomainHelper::MarshalObject(IN AppDomain *pDomain,
-                                               IN OBJECTREF  *orObject,
-                                               OUT BYTE    **ppbBlob,
-                                               OUT DWORD    *pcbBlob);
-
-    // Marshal two objects into serialized blobs.
-    static void AppDomainHelper::MarshalObjects(IN AppDomain *pDomain,
-                                                IN OBJECTREF  *orObject1,
-                                                IN OBJECTREF  *orObject2,
-                                                OUT BYTE    **ppbBlob1,
-                                                OUT DWORD    *pcbBlob1,
-                                                OUT BYTE    **ppbBlob2,
-                                                OUT DWORD    *pcbBlob2);
-
-    // Unmarshal a single object from a serialized blob.
-    static void AppDomainHelper::UnmarshalObject(IN AppDomain   *pDomain,
-                                                 IN U1ARRAYREF  *porBlob,
-                                                 OUT OBJECTREF  *porObject);
-
-    // Unmarshal a single object from a serialized blob.
-    static void AppDomainHelper::UnmarshalObject(IN AppDomain   *pDomain,
-                                                 IN BYTE        *pbBlob,
-                                                 IN DWORD        cbBlob,
-                                                 OUT OBJECTREF  *porObject);
-
-    // Unmarshal two objects from serialized blobs.
-    static void AppDomainHelper::UnmarshalObjects(IN AppDomain   *pDomain,
-                                                  IN BYTE        *pbBlob1,
-                                                  IN DWORD        cbBlob1,
-                                                  IN BYTE        *pbBlob2,
-                                                  IN DWORD        cbBlob2,
-                                                  OUT OBJECTREF  *porObject1,
-                                                  OUT OBJECTREF  *porObject2);
-
-    // Copy an object from the given appdomain into the current appdomain.
-    static OBJECTREF AppDomainHelper::CrossContextCopyFrom(IN AppDomain *pAppDomain,
-                                                           IN OBJECTREF *orObject);
-    // Copy an object to the given appdomain from the current appdomain.
-    static OBJECTREF AppDomainHelper::CrossContextCopyTo(IN AppDomain *pAppDomain,
-                                                         IN OBJECTREF  *orObject);
-    // Copy an object from the given appdomain into the current appdomain.
-    static OBJECTREF AppDomainHelper::CrossContextCopyFrom(IN ADID dwDomainId,
-                                                           IN OBJECTREF *orObject);
-    // Copy an object to the given appdomain from the current appdomain.
-    static OBJECTREF AppDomainHelper::CrossContextCopyTo(IN ADID dwDomainId,
-                                                         IN OBJECTREF  *orObject);
-
-};
-
-// Cache the bits needed to serialize/deserialize managed objects that will be
-// passed across appdomain boundaries during a stackwalk. The serialization is
-// performed lazily the first time it's needed and remains valid throughout the
-// stackwalk. The last deserialized object is cached and tagged with its
-// appdomain context. It's valid as long as we're walking frames within the same
-// appdomain.
-//
-class MarshalCache
-{
-public:
-    MarshalCache()
-    {
-        LIMITED_METHOD_CONTRACT;
-        ZeroMemory(this, sizeof(*this));
-    }
-
-    ~MarshalCache()
-    {
-        LIMITED_METHOD_CONTRACT;
-        if (m_pbObj1)
-            delete [] m_pbObj1;
-        if (m_pbObj2)
-            delete [] m_pbObj2;
-    }
-
-    void EnsureSerializationOK()
-    {
-        CONTRACTL
-        {
-            THROWS;
-            GC_TRIGGERS;
-            MODE_COOPERATIVE;
-        } 
-        CONTRACTL_END;
-        if ((m_sGC.m_orInput1 != NULL && (m_pbObj1 == NULL || m_cbObj1 == 0)) ||
-            (m_sGC.m_orInput2 != NULL && (m_pbObj2 == NULL || m_cbObj2 == 0)))
-        {
-            // Serialization went bad -> Throw exception indicating so.
-            COMPlusThrow(kSecurityException, IDS_UNMARSHALABLE_DEMAND_OBJECT);
-        }
-    }
-
-    void EnsureDeserializationOK()
-    {
-        CONTRACTL
-        {
-            THROWS;
-            GC_TRIGGERS;
-            MODE_COOPERATIVE;
-        } 
-        CONTRACTL_END;
-        if ((m_pbObj1 != NULL && m_sGC.m_orOutput1 == NULL ) ||
-            (m_pbObj2 != NULL && m_sGC.m_orOutput2 == NULL ) )
-        {
-            // DeSerialization went bad -> Throw exception indicating so.
-            COMPlusThrow(kSecurityException, IDS_UNMARSHALABLE_DEMAND_OBJECT);
-        }
-    }
-
-#ifndef DACCESS_COMPILE
-    
-    // Set the original value of the first cached object.
-    void SetObject(OBJECTREF orObject)
-    {
-        LIMITED_METHOD_CONTRACT;
-        m_pOriginalDomain = ::GetAppDomain();
-        m_sGC.m_orInput1 = orObject;
-    }
-
-    // Set the original values of both cached objects.
-    void SetObjects(OBJECTREF orObject1, OBJECTREF orObject2)
-    {
-        LIMITED_METHOD_CONTRACT;
-        m_pOriginalDomain = ::GetAppDomain();
-        m_sGC.m_orInput1 = orObject1;
-        m_sGC.m_orInput2 = orObject2;
-    }
-
-#endif //!DACCESS_COMPILE
-    
-    // Get a copy of the first object suitable for use in the given appdomain.
-    OBJECTREF GetObject(AppDomain *pDomain)
-    {
-        CONTRACTL
-        {
-            THROWS;
-            GC_TRIGGERS;
-            MODE_COOPERATIVE;
-        }
-        CONTRACTL_END;
-        CheckADValidity(pDomain, ADV_RUNNINGIN);
-
-        // No transition -- just return original object.
-        if (pDomain == m_pOriginalDomain) {
-            if (m_fObjectUpdated)
-                UpdateObjectFinish();
-            return m_sGC.m_orInput1;
-        }
-
-        // We've already deserialized the object into the correct context.
-        if (pDomain == m_pCachedDomain)
-            return m_sGC.m_orOutput1;
-
-        // If we've updated the object in a different appdomain from the one we
-        // originally started in, the cached object will be more up to date than
-        // the original. Resync the objects.
-        if (m_fObjectUpdated)
-            UpdateObjectFinish();
-
-        // Check whether we've serialized the original input object yet.
-        if (m_pbObj1 == NULL && m_sGC.m_orInput1 != NULL)
-        {
-            AppDomainHelper::MarshalObject(m_pOriginalDomain,
-                                          &m_sGC.m_orInput1,
-                                          &m_pbObj1,
-                                          &m_cbObj1);
-            EnsureSerializationOK();
-        }
-
-        // Deserialize into the correct context.
-        if (m_pbObj1 != NULL)
-        {
-            AppDomainHelper::UnmarshalObject(pDomain,
-                                            m_pbObj1,
-                                            m_cbObj1,
-                                            &m_sGC.m_orOutput1);
-            EnsureDeserializationOK();
-        }
-        m_pCachedDomain = pDomain;
-
-        return m_sGC.m_orOutput1;
-    }
-
-    // As above, but retrieve both objects.
-    OBJECTREF GetObjects(AppDomain *pDomain, OBJECTREF *porObject2)
-    {
-        CONTRACTL
-        {
-            THROWS;
-            GC_TRIGGERS;
-            MODE_COOPERATIVE;
-        }
-        CONTRACTL_END;
-        CheckADValidity(pDomain, ADV_RUNNINGIN);
-        // No transition -- just return original objects.
-        if (pDomain == m_pOriginalDomain) {
-            if (m_fObjectUpdated)
-                UpdateObjectFinish();
-            *porObject2 = m_sGC.m_orInput2;
-            return m_sGC.m_orInput1;
-        }
-
-        // We've already deserialized the objects into the correct context.
-        if (pDomain == m_pCachedDomain) {
-            *porObject2 = m_sGC.m_orOutput2;
-            return m_sGC.m_orOutput1;
-        }
-
-        // If we've updated the object in a different appdomain from the one we
-        // originally started in, the cached object will be more up to date than
-        // the original. Resync the objects.
-        if (m_fObjectUpdated)
-            UpdateObjectFinish();
-
-        // Check whether we've serialized the original input objects yet.
-        if ((m_pbObj1 == NULL && m_sGC.m_orInput1 != NULL) ||
-            (m_pbObj2 == NULL && m_sGC.m_orInput2 != NULL))
-        {
-            AppDomainHelper::MarshalObjects(m_pOriginalDomain,
-                                           &m_sGC.m_orInput1,
-                                           &m_sGC.m_orInput2,
-                                           &m_pbObj1,
-                                           &m_cbObj1,
-                                           &m_pbObj2,
-                                           &m_cbObj2);
-            EnsureSerializationOK();
-
-        }
-        if (m_pbObj1 != NULL || m_pbObj2 != NULL)
-        {
-            // Deserialize into the correct context.
-            AppDomainHelper::UnmarshalObjects(pDomain,
-                                              m_pbObj1,
-                                              m_cbObj1,
-                                              m_pbObj2,
-                                              m_cbObj2,
-                                              &m_sGC.m_orOutput1,
-                                              &m_sGC.m_orOutput2);
-            EnsureDeserializationOK();
-        }
-        m_pCachedDomain = pDomain;
-
-        *porObject2 = m_sGC.m_orOutput2;
-        return m_sGC.m_orOutput1;
-    }
-
-    // Change the first object (updating the cacheing information
-    // appropriately).
-    void UpdateObject(AppDomain *pDomain, OBJECTREF orObject)
-    {
-        CONTRACTL
-        {
-            NOTHROW;
-            GC_NOTRIGGER;
-            MODE_ANY;
-        }
-        CONTRACTL_END;
-
-        // The cached serialized blob is now useless.
-		CheckADValidity(pDomain, ADV_RUNNINGIN);        
-        if (m_pbObj1)
-            delete [] m_pbObj1;
-        m_pbObj1 = NULL;
-        m_cbObj1 = 0;
-
-        // The object we have now is valid in it's own appdomain, so place that
-        // in the object cache.
-        m_pCachedDomain = pDomain;
-        m_sGC.m_orOutput1 = orObject;
-
-        // If the object is updated in the original context, just use the new
-        // value as is. In this case we have the data to re-marshal the updated
-        // object as normal, so we can consider the cache fully updated and exit
-        // now.
-        if (pDomain == m_pOriginalDomain) {
-            m_sGC.m_orInput1 = orObject;
-            m_fObjectUpdated = false;
-            return;
-        }
-
-        // We want to avoid re-marshaling the updated value as long as possible
-        // (it might be updated again before we need its value in a different
-        // context). So set a flag to indicate that the object must be
-        // re-marshaled when the value is queried in a new context.
-        m_fObjectUpdated = true;
-    }
-
-    // This structure is public only so that it can be GC protected. Do not
-    // access the fields directly, they change in an unpredictable fashion due
-    // to the lazy cacheing algorithm.
-    struct _gc {
-        OBJECTREF   m_orInput1;
-        OBJECTREF   m_orInput2;
-        OBJECTREF   m_orOutput1;
-        OBJECTREF   m_orOutput2;
-    }           m_sGC;
-
-private:
-
-    // Called after one or more calls to UpdateObject to marshal the updated
-    // object back into its original context (it's assumed we're called in this
-    // context).
-    void UpdateObjectFinish()
-    {
-		CONTRACTL
-		{
-			THROWS;
-			GC_TRIGGERS;
-			MODE_COOPERATIVE;
-			PRECONDITION(m_fObjectUpdated && m_pbObj1 == NULL);
-		}
-		CONTRACTL_END;
-        AppDomainHelper::MarshalObject(m_pCachedDomain,
-                                      &m_sGC.m_orOutput1,
-                                      &m_pbObj1,
-                                      &m_cbObj1);
-        AppDomainHelper::UnmarshalObject(m_pOriginalDomain,
-                                        m_pbObj1,
-                                        m_cbObj1,
-                                        &m_sGC.m_orInput1);
-        m_fObjectUpdated = false;
-    }
-
-    BYTE       *m_pbObj1;
-    DWORD       m_cbObj1;
-    BYTE       *m_pbObj2;
-    DWORD       m_cbObj2;
-    AppDomain  *m_pCachedDomain;
-    AppDomain  *m_pOriginalDomain;
-    bool        m_fObjectUpdated;
-};
-
-#endif
diff --git a/src/vm/appdomainnative.cpp b/src/vm/appdomainnative.cpp
index a96c643537..dd46add6ee 100644
--- a/src/vm/appdomainnative.cpp
+++ b/src/vm/appdomainnative.cpp
@@ -9,26 +9,16 @@
 #include "appdomainnative.hpp"
 #ifdef FEATURE_REMOTING
 #include "remoting.h"
-#include "appdomainhelper.h"
 #endif
 #include "security.h"
 #include "vars.hpp"
 #include "eeconfig.h"
 #include "appdomain.inl"
 #include "eventtrace.h"
-#ifndef FEATURE_CORECLR
-#include "comutilnative.h"
-#endif // !FEATURE_CORECLR
 #if defined(FEATURE_APPX)
 #include "appxutil.h"
 #endif // FEATURE_APPX
-#if defined(FEATURE_APPX_BINDER)
-#include "clrprivbinderappx.h"
-#include "clrprivtypecachewinrt.h"
-#endif // FEATURE_APPX_BINDER
-#ifdef FEATURE_VERSIONING
 #include "../binder/inc/clrprivbindercoreclr.h"
-#endif
 
 #include "clr/fs/path.h"
 using namespace clr::fs;
@@ -177,12 +167,6 @@ void AppDomainNative::CreateDomainHelper (STRINGREF* ppFriendlyName, OBJECTREF*
 
         setupInfo = prepareDataForSetup.Call_RetOBJECTREF(args);
 
-#ifndef FEATURE_CORECLR
-        // We need to setup domain sorting before any other managed code runs in the domain, since that code 
-        // could end up caching data based on the sorting mode of the domain.
-        pDomain->InitializeSorting(ppAppdomainSetup);
-        pDomain->InitializeHashing(ppAppdomainSetup);
-#endif
 
         // We need to ensure that the AppDomainProxy is generated before we call into DoSetup, since
         // GetAppDomainProxy will ensure that remoting is correctly configured in the domain.  DoSetup can
@@ -289,38 +273,10 @@ void QCALLTYPE AppDomainNative::SetupDomainSecurity(QCall::AppDomainHandle pDoma
         }
     }
 
-#ifdef FEATURE_CAS_POLICY
-    if (gc.orEvidence != NULL)
-    {
-        pSecDesc->SetEvidence(gc.orEvidence);
-    }
-#endif // FEATURE_CAS_POLICY
 
     // We need to downgrade sharing level if the AppDomain is homogeneous and not fully trusted, or the
     // AppDomain is in legacy mode.  Effectively, we need to be sure that all assemblies loaded into the
     // domain must be fully trusted in order to allow non-GAC sharing.
-#ifdef FEATURE_FUSION
-    if (pDomain->GetSharePolicy() == AppDomain::SHARE_POLICY_ALWAYS)
-    {
-        bool fSandboxedHomogenousDomain = false;
-        if (pSecDesc->IsHomogeneous())
-        {
-            pSecDesc->Resolve();
-            fSandboxedHomogenousDomain = !pSecDesc->IsFullyTrusted();
-        }
-
-        if (fSandboxedHomogenousDomain || pSecDesc->IsLegacyCasPolicyEnabled())
-        {
-            // We may not be able to reduce sharing policy at this point, if we have already loaded
-            // some non-GAC assemblies as domain neutral.  For this case we must regrettably fail
-            // the whole operation.
-            if (!pDomain->ReduceSharePolicyFromAlways())
-            {
-                ThrowHR(COR_E_CANNOT_SET_POLICY);
-            }
-        }
-    }
-#endif
 
     // Now finish the initialization.
     pSecDesc->FinishInitialization();
@@ -421,25 +377,6 @@ FCIMPLEND
 
 #endif // FEATURE_COMINTEROP
 
-#ifdef FEATURE_FUSION
-FCIMPL1(LPVOID, AppDomainNative::GetFusionContext, AppDomainBaseObject* refThis)
-{
-    FCALL_CONTRACT;
-
-    LPVOID rv = NULL;
-    
-    HELPER_METHOD_FRAME_BEGIN_RET_1(rv);
-
-    AppDomain* pApp = ValidateArg((APPDOMAINREF)refThis);
-
-    rv = pApp->CreateFusionContext();
-
-    HELPER_METHOD_FRAME_END();
-
-    return rv;
-}
-FCIMPLEND
-#endif
 
 FCIMPL1(void*, AppDomainNative::GetSecurityDescriptor, AppDomainBaseObject* refThisUNSAFE)
 {
@@ -474,244 +411,7 @@ FCIMPL2(void, AppDomainNative::UpdateLoaderOptimization, AppDomainBaseObject* re
 FCIMPLEND
 #endif // FEATURE_LOADER_OPTIMIZATION
 
-#ifdef FEATURE_FUSION
-FCIMPL3(void, AppDomainNative::UpdateContextProperty, LPVOID fusionContext, StringObject* keyUNSAFE, Object* valueUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    struct _gc
-    {
-        STRINGREF key;
-        OBJECTREF value;
-    } gc;
-
-    gc.key   = ObjectToSTRINGREF(keyUNSAFE);
-    gc.value = ObjectToOBJECTREF(valueUNSAFE);
-    _ASSERTE(gc.key != NULL);
-
-    HELPER_METHOD_FRAME_BEGIN_PROTECT(gc);
-
-    IApplicationContext* pContext = (IApplicationContext*) fusionContext;
-
-    BOOL fFXOnly;
-    DWORD size = sizeof(fFXOnly);
-    HRESULT hr = pContext->Get(ACTAG_FX_ONLY, &fFXOnly, &size, 0);
-    if (hr == HRESULT_FROM_WIN32(ERROR_NOT_FOUND))
-    {
-        fFXOnly = FALSE;
-        hr = S_FALSE;
-    }
-    IfFailThrow(hr);
-
-    if (!fFXOnly)
-    {
-        DWORD lgth = gc.key->GetStringLength();
-        CQuickBytes qb;
-        LPWSTR key = (LPWSTR) qb.AllocThrows((lgth+1)*sizeof(WCHAR));
-        memcpy(key, gc.key->GetBuffer(), lgth*sizeof(WCHAR));
-        key[lgth] = W('\0');
-            
-        AppDomain::SetContextProperty(pContext, key, &gc.value);
-    }
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-#endif  // FEATURE_FUSION
-
-/* static */
-INT32 AppDomainNative::ExecuteAssemblyHelper(Assembly* pAssembly,
-                                             BOOL bCreatedConsole,
-                                             PTRARRAYREF *pStringArgs)
-{
-    STATIC_CONTRACT_THROWS;
-
-    struct Param
-    {
-        Assembly* pAssembly;
-        PTRARRAYREF *pStringArgs;
-        INT32 iRetVal;
-    } param;
-    param.pAssembly = pAssembly;
-    param.pStringArgs = pStringArgs;
-    param.iRetVal = 0;
-
-    EE_TRY_FOR_FINALLY(Param *, pParam, &param)
-    {
-        pParam->iRetVal = pParam->pAssembly->ExecuteMainMethod(pParam->pStringArgs, FALSE /* waitForOtherThreads */);
-    }
-    EE_FINALLY 
-    {
-#ifndef FEATURE_PAL
-        if(bCreatedConsole)
-            FreeConsole();
-#endif // !FEATURE_PAL
-    } 
-    EE_END_FINALLY
-
-    return param.iRetVal;
-}
-
-static void UpgradeLinkTimeCheckToLateBoundDemand(MethodDesc* pMeth)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-
-    BOOL isEveryoneFullyTrusted = FALSE;
-
-    struct _gc 
-    {
-        OBJECTREF refClassNonCasDemands;
-        OBJECTREF refClassCasDemands;
-        OBJECTREF refMethodNonCasDemands;
-        OBJECTREF refMethodCasDemands;
-        OBJECTREF refThrowable;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc);
-
-    isEveryoneFullyTrusted = Security::AllDomainsOnStackFullyTrusted();
-
-    // If all assemblies in the domain are fully trusted then we are not
-    // going to do any security checks anyway..
-    if (isEveryoneFullyTrusted) 
-    {
-        goto Exit1;
-    }
-
-
-    if (pMeth->RequiresLinktimeCheck()) 
-    {
-        // Fetch link demand sets from all the places in metadata where we might
-        // find them (class and method). These might be split into CAS and non-CAS
-        // sets as well.
-        Security::RetrieveLinktimeDemands(pMeth,
-                                          &gc.refClassCasDemands,
-                                          &gc.refClassNonCasDemands,
-                                          &gc.refMethodCasDemands,
-                                          &gc.refMethodNonCasDemands);
-
-        if (gc.refClassCasDemands == NULL && gc.refClassNonCasDemands == NULL &&
-            gc.refMethodCasDemands == NULL && gc.refMethodNonCasDemands == NULL &&
-            isEveryoneFullyTrusted) 
-        {
-            // All code access security demands will pass anyway.
-            goto Exit1;
-        }
-   
-        // The following logic turns link demands on the target method into full
-        // stack walks in order to close security holes in poorly written
-        // reflection users.
-
-#ifdef FEATURE_APTCA
-        if (Security::IsUntrustedCallerCheckNeeded(pMeth) )
-        {
-            // Check for untrusted caller
-            // It is possible that wrappers like VBHelper libraries that are
-            // fully trusted, make calls to public methods that do not have
-            // safe for Untrusted caller custom attribute set.
-            // Like all other link demand that gets transformed to a full stack 
-            // walk for reflection, calls to public methods also gets 
-            // converted to full stack walk
-
-            // NOTE: this will always do the APTCA check, regardless of method caller
-            Security::DoUntrustedCallerChecks(NULL, pMeth, TRUE);
-        }
-#endif
-
-        // CAS Link Demands
-        if (gc.refClassCasDemands != NULL)
-            Security::DemandSet(SSWT_LATEBOUND_LINKDEMAND, gc.refClassCasDemands);
-
-        if (gc.refMethodCasDemands != NULL)
-            Security::DemandSet(SSWT_LATEBOUND_LINKDEMAND, gc.refMethodCasDemands);
-
-        // Non-CAS demands are not applied against a grant
-        // set, they're standalone.
-        if (gc.refClassNonCasDemands != NULL)
-            Security::CheckNonCasDemand(&gc.refClassNonCasDemands);
-
-        if (gc.refMethodNonCasDemands != NULL)
-            Security::CheckNonCasDemand(&gc.refMethodNonCasDemands);
-    }
-
-Exit1:;
-    GCPROTECT_END();
-}
-
-FCIMPL3(INT32, AppDomainNative::ExecuteAssembly, AppDomainBaseObject* refThisUNSAFE,
-    AssemblyBaseObject* assemblyNameUNSAFE, PTRArray* stringArgsUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    INT32 iRetVal = 0;
-
-    struct _gc
-    {
-        APPDOMAINREF    refThis;
-        ASSEMBLYREF     assemblyName;
-        PTRARRAYREF     stringArgs;
-    } gc;
-
-    gc.refThis      = (APPDOMAINREF) refThisUNSAFE;
-    gc.assemblyName = (ASSEMBLYREF)  assemblyNameUNSAFE;
-    gc.stringArgs   = (PTRARRAYREF)  stringArgsUNSAFE;
-
-    HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc);
-
-    AppDomain* pDomain = ValidateArg(gc.refThis);
-
-    if (gc.assemblyName == NULL)
-        COMPlusThrow(kArgumentNullException, W("ArgumentNull_Generic"));
-
-    if((BaseDomain*) pDomain == SystemDomain::System()) 
-        COMPlusThrow(kUnauthorizedAccessException, W("UnauthorizedAccess_SystemDomain"));
-
-    Assembly* pAssembly = (Assembly*) gc.assemblyName->GetAssembly();
-
-    if (!pDomain->m_pRootAssembly)
-        pDomain->m_pRootAssembly = pAssembly;
-
-    MethodDesc *pEntryPointMethod;
-    {
-        pEntryPointMethod = pAssembly->GetEntryPoint();
-        if (pEntryPointMethod)
-        {
-            UpgradeLinkTimeCheckToLateBoundDemand(pEntryPointMethod);        
-        }
-    }
-
-    BOOL bCreatedConsole = FALSE;
-
-#ifndef FEATURE_PAL
-    if (pAssembly->GetManifestFile()->GetSubsystem() == IMAGE_SUBSYSTEM_WINDOWS_CUI)
-    {
-        {
-            GCX_COOP();
-            Security::CheckBeforeAllocConsole(pDomain, pAssembly);
-        }
-        bCreatedConsole = AllocConsole();
-        StackSString codebase;
-        pAssembly->GetManifestFile()->GetCodeBase(codebase);
-        SetConsoleTitle(codebase);
-    }
-#endif // !FEATURE_PAL
 
-    // This helper will call FreeConsole()
-    iRetVal = ExecuteAssemblyHelper(pAssembly, bCreatedConsole, &gc.stringArgs);
-
-    HELPER_METHOD_FRAME_END();
-
-    return iRetVal;
-}
-FCIMPLEND
-
-#ifdef FEATURE_VERSIONING
 FCIMPL1(void,
         AppDomainNative::CreateContext,
         AppDomainBaseObject *refThisUNSAFE)
@@ -771,9 +471,8 @@ void QCALLTYPE AppDomainNative::SetupBindingPaths(__in_z LPCWSTR wszTrustedPlatf
     END_QCALL;
 }
 
-#endif // FEATURE_VERSIONING
 
-FCIMPL12(Object*, AppDomainNative::CreateDynamicAssembly, AppDomainBaseObject* refThisUNSAFE, AssemblyNameBaseObject* assemblyNameUNSAFE, Object* identityUNSAFE, StackCrawlMark* stackMark, Object* requiredPsetUNSAFE, Object* optionalPsetUNSAFE, Object* refusedPsetUNSAFE, U1Array *securityRulesBlobUNSAFE, U1Array *aptcaBlobUNSAFE, INT32 access, INT32 dwFlags, SecurityContextSource securityContextSource)
+FCIMPL9(Object*, AppDomainNative::CreateDynamicAssembly, AppDomainBaseObject* refThisUNSAFE, AssemblyNameBaseObject* assemblyNameUNSAFE, Object* identityUNSAFE, StackCrawlMark* stackMark, U1Array *securityRulesBlobUNSAFE, U1Array *aptcaBlobUNSAFE, INT32 access, INT32 dwFlags, SecurityContextSource securityContextSource)
 {
     FCALL_CONTRACT;
 
@@ -787,9 +486,6 @@ FCIMPL12(Object*, AppDomainNative::CreateDynamicAssembly, AppDomainBaseObject* r
     args.refThis                = (APPDOMAINREF)    refThisUNSAFE;
     args.assemblyName           = (ASSEMBLYNAMEREF) assemblyNameUNSAFE;
     args.identity               = (OBJECTREF)       identityUNSAFE;
-    args.requiredPset           = (OBJECTREF)       requiredPsetUNSAFE;
-    args.optionalPset           = (OBJECTREF)       optionalPsetUNSAFE;
-    args.refusedPset            = (OBJECTREF)       refusedPsetUNSAFE;
     args.securityRulesBlob      = (U1ARRAYREF)      securityRulesBlobUNSAFE;
     args.aptcaBlob              = (U1ARRAYREF)      aptcaBlobUNSAFE;
     args.loaderAllocator        = NULL;
@@ -990,53 +686,6 @@ void QCALLTYPE AppDomainNative::SetAppDomainManagerType(QCall::AppDomainHandle a
     END_QCALL;
 }
 
-#ifdef FEATURE_APPDOMAINMANAGER_INITOPTIONS
-
-FCIMPL0(FC_BOOL_RET, AppDomainNative::HasHost)
-{
-    FCALL_CONTRACT;
-    FC_RETURN_BOOL(CorHost2::GetHostControl() != NULL);
-}
-FCIMPLEND
-
-//
-// Callback to the CLR host to register an AppDomainManager->AppDomain ID pair with it.
-//
-// Arguments:
-//    punkAppDomainManager - COM reference to the AppDomainManager being registered with the host
-//
-
-// static
-void QCALLTYPE AppDomainNative::RegisterWithHost(IUnknown *punkAppDomainManager)
-{
-    CONTRACTL
-    {
-        QCALL_CHECK;
-        PRECONDITION(CheckPointer(punkAppDomainManager));
-        PRECONDITION(CheckPointer(CorHost2::GetHostControl()));
-    }
-    CONTRACTL_END;
-
-    BEGIN_QCALL;
-
-    EnsureComStarted();
-
-    IHostControl *pHostControl = CorHost2::GetHostControl();
-    ADID dwDomainId = SystemDomain::GetCurrentDomain()->GetId();
-    HRESULT hr = S_OK;
-
-    BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread());
-    hr = pHostControl->SetAppDomainManager(dwDomainId.m_dwId, punkAppDomainManager);
-    END_SO_TOLERANT_CODE_CALLING_HOST;
-
-    if (FAILED(hr))
-    {
-        ThrowHR(hr);
-    }
-
-    END_QCALL;
-}
-#endif // FEATURE_APPDOMAINMANAGER_INITOPTIONS
 
 FCIMPL1(void, AppDomainNative::SetHostSecurityManagerFlags, DWORD dwFlags);
 {
@@ -1064,59 +713,7 @@ void QCALLTYPE AppDomainNative::SetSecurityHomogeneousFlag(QCall::AppDomainHandl
     END_QCALL;
 }
 
-#ifdef FEATURE_CAS_POLICY
-
-// static
-void QCALLTYPE AppDomainNative::SetLegacyCasPolicyEnabled(QCall::AppDomainHandle adhTarget)
-{
-    QCALL_CONTRACT;
-
-    BEGIN_QCALL;
-
-    IApplicationSecurityDescriptor *pAppSecDesc = adhTarget->GetSecurityDescriptor();
-    pAppSecDesc->SetLegacyCasPolicyEnabled();
-
-    END_QCALL;
-}
-
-// static
-BOOL QCALLTYPE AppDomainNative::IsLegacyCasPolicyEnabled(QCall::AppDomainHandle adhTarget)
-{
-    QCALL_CONTRACT;
-
-    BOOL fLegacyCasPolicy = FALSE;
-
-    BEGIN_QCALL;
-
-    IApplicationSecurityDescriptor *pAppSecDesc = adhTarget->GetSecurityDescriptor();
-    fLegacyCasPolicy = !!pAppSecDesc->IsLegacyCasPolicyEnabled();
-
-    END_QCALL;
-
-    return fLegacyCasPolicy;
-}
-
-#endif // FEATURE_CAS_POLICY
 
-#ifdef FEATURE_APTCA
-
-// static
-void QCALLTYPE AppDomainNative::SetCanonicalConditionalAptcaList(QCall::AppDomainHandle adhTarget,
-                                                                 LPCWSTR wszCanonicalConditionalAptcaList)
-{
-    QCALL_CONTRACT;
-
-    BEGIN_QCALL;
-
-    IApplicationSecurityDescriptor *pAppSecDesc = adhTarget->GetSecurityDescriptor();
-
-    GCX_COOP();
-    pAppSecDesc->SetCanonicalConditionalAptcaList(wszCanonicalConditionalAptcaList);
-
-    END_QCALL;
-}
-
-#endif // FEATURE_APTCA
 
 FCIMPL1(Object*, AppDomainNative::GetFriendlyName, AppDomainBaseObject* refThisUNSAFE)
 {
@@ -1307,18 +904,6 @@ FCIMPL1(void, AppDomainNative::ChangeSecurityPolicy, AppDomainBaseObject* refThi
     HELPER_METHOD_FRAME_BEGIN_1(refThis);
     AppDomain* pApp = ValidateArg(refThis);
 
-#ifdef FEATURE_FUSION
-
-    // We do not support sharing behavior of ALWAYS when using app-domain local security config
-    if (pApp->GetSharePolicy() == AppDomain::SHARE_POLICY_ALWAYS)
-    {
-        // We may not be able to reduce sharing policy at this point, if we have already loaded
-        // some non-GAC assemblies as domain neutral.  For this case we must regrettably fail
-        // the whole operation.
-        if (!pApp->ReduceSharePolicyFromAlways())
-            ThrowHR(COR_E_CANNOT_SET_POLICY);
-    }
-#endif
     pApp->GetSecurityDescriptor()->SetPolicyLevelFlag();
 
     HELPER_METHOD_FRAME_END();
@@ -1384,14 +969,6 @@ FCIMPL1(Object*, AppDomainNative::GetDynamicDir, AppDomainBaseObject* refThisUNS
     FCALL_CONTRACT;
 
     STRINGREF    str        = NULL;
-#ifdef FEATURE_FUSION    
-    APPDOMAINREF refThis    = (APPDOMAINREF) refThisUNSAFE;
-    HELPER_METHOD_FRAME_BEGIN_RET_1(refThis);
-    
-    AppDomain *pDomain = ValidateArg(refThis);
-    str = StringObject::NewString(pDomain->GetDynamicDir());
-    HELPER_METHOD_FRAME_END();
-#endif    
     return OBJECTREFToObject(str);
 }
 FCIMPLEND
@@ -1488,29 +1065,7 @@ FCIMPL2(StringObject*, AppDomainNative::nApplyPolicy, AppDomainBaseObject* refTh
 
     StackSString sDisplayName;
 
-#ifdef FEATURE_FUSION
-    {
-        GCX_PREEMP();
-
-        SafeComHolderPreemp<IAssemblyName> pAssemblyName(NULL);
-        SafeComHolderPreemp<IAssemblyName> pBoundName(NULL);
-        IfFailThrow(spec.CreateFusionName(&pAssemblyName));
-        HRESULT hr = PreBindAssembly(pDomain->GetFusionContext(),
-                                    pAssemblyName,
-                                    NULL, // pAsmParent (only needed to see if parent is loadfrom - in this case, we always want it to load in the normal ctx)
-                                    &pBoundName,
-                                    NULL  // pvReserved
-                                    );
-        if (FAILED(hr) && hr != FUSION_E_REF_DEF_MISMATCH)
-        {
-            ThrowHR(hr);
-        }
-
-        FusionBind::GetAssemblyNameDisplayName(pBoundName, /*modifies*/sDisplayName, 0 /*flags*/);
-    }
-#else
     spec.GetFileOrDisplayName(0,sDisplayName);
-#endif
 
     gc.rv = StringObject::NewString(sDisplayName);
 
@@ -1556,7 +1111,6 @@ FCIMPL1(void , AppDomainNative::PublishAnonymouslyHostedDynamicMethodsAssembly,
 }
 FCIMPLEND
 
-#ifdef FEATURE_CORECLR    
 
 void QCALLTYPE AppDomainNative::SetNativeDllSearchDirectories(__in_z LPCWSTR wszNativeDllSearchDirectories)
 {
@@ -1613,7 +1167,6 @@ void QCALLTYPE AppDomainNative::SetNativeDllSearchDirectories(__in_z LPCWSTR wsz
     END_QCALL;
 }
 
-#endif // FEATURE_CORECLR    
 
 #ifdef FEATURE_APPDOMAIN_RESOURCE_MONITORING
 FCIMPL0(void, AppDomainNative::EnableMonitoring)
@@ -1728,55 +1281,4 @@ FCIMPL0(INT64, AppDomainNative::GetLastSurvivedProcessMemorySize)
 FCIMPLEND
 #endif // FEATURE_APPDOMAIN_RESOURCE_MONITORING
 
-#if defined(FEATURE_APPX_BINDER)
-ICLRPrivBinder * QCALLTYPE AppDomainNative::CreateDesignerContext(LPCWSTR *rgPaths, 
-                                                            UINT cPaths,
-                                                            BOOL fShared)
-{
-    QCALL_CONTRACT;
-
-    ICLRPrivBinder *pRetVal = nullptr;
-
-    BEGIN_QCALL;
-    ReleaseHolder<ICLRPrivBinder> pBinder;
-
-     // The runtime check is done on the managed side to enable the debugger to use
-     // FuncEval to create designer contexts outside of DesignMode.
-    _ASSERTE(AppX::IsAppXDesignMode() || (AppX::IsAppXProcess() && CORDebuggerAttached()));
-
-    AppDomain *pAppDomain = GetAppDomain();
-
-    pBinder = CLRPrivBinderAppX::CreateParentedBinder(fShared ? pAppDomain->GetLoadContextHostBinder() : pAppDomain->GetSharedContextHostBinder(), CLRPrivTypeCacheWinRT::GetOrCreateTypeCache(), rgPaths, cPaths, fShared /* fCanUseNativeImages */);
-
-    {
-        BaseDomain::LockHolder lh(pAppDomain);
-        pAppDomain->AppDomainInterfaceReleaseList.Append(pRetVal);
-    }
-    pBinder.SuppressRelease();
-    pRetVal = pBinder;
-    
-    END_QCALL;
-
-    return pRetVal;
-}
-
-void QCALLTYPE AppDomainNative::SetCurrentDesignerContext(BOOL fDesignerContext, ICLRPrivBinder *newContext)
-{
-    QCALL_CONTRACT;
-
-    BEGIN_QCALL;
-
-    if (fDesignerContext)
-    {
-        GetAppDomain()->SetCurrentContextHostBinder(newContext);
-    }
-    else
-    {
-        // Managed code is responsible for ensuring this isn't called more than once per AppDomain.
-        GetAppDomain()->SetSharedContextHostBinder(newContext);
-    }
-
-    END_QCALL;
-}
-#endif // defined(FEATURE_APPX_BINDER)
 
diff --git a/src/vm/appdomainnative.hpp b/src/vm/appdomainnative.hpp
index ee3af20aaa..6f6c564869 100644
--- a/src/vm/appdomainnative.hpp
+++ b/src/vm/appdomainnative.hpp
@@ -34,20 +34,14 @@ public:
     static FCDECL2(void, UpdateLoaderOptimization, AppDomainBaseObject* refThisUNSAFE, DWORD optimization);
 #endif // FEATURE_LOADER_OPTIMIZATION
 
-    static FCDECL12(Object*, CreateDynamicAssembly, AppDomainBaseObject* refThisUNSAFE, AssemblyNameBaseObject* assemblyNameUNSAFE, Object* identityUNSAFE, StackCrawlMark* stackMark, Object* requiredPsetUNSAFE, Object* optionalPsetUNSAFE, Object* refusedPsetUNSAFE, U1Array* securityRulesBlobUNSAFE, U1Array* aptcaBlobUNSAFE, INT32 access, INT32 flags, SecurityContextSource securityContextSource);
-#ifdef FEATURE_APPDOMAINMANAGER_INITOPTIONS
-    static FCDECL0(FC_BOOL_RET, HasHost);
-#endif // FEATURE_APPDOMAINMANAGER_INITOPTIONS
+    static FCDECL9(Object*, CreateDynamicAssembly, AppDomainBaseObject* refThisUNSAFE, AssemblyNameBaseObject* assemblyNameUNSAFE, Object* identityUNSAFE, StackCrawlMark* stackMark, U1Array* securityRulesBlobUNSAFE, U1Array* aptcaBlobUNSAFE, INT32 access, INT32 flags, SecurityContextSource securityContextSource);
     static FCDECL1(void, SetHostSecurityManagerFlags, DWORD dwFlags);
     static FCDECL1(Object*, GetFriendlyName, AppDomainBaseObject* refThisUNSAFE);
     static FCDECL1(FC_BOOL_RET, IsDefaultAppDomainForEvidence, AppDomainBaseObject* refThisUNSAFE);
     static FCDECL2(Object*, GetAssemblies, AppDomainBaseObject* refThisUNSAFE, CLR_BOOL fForIntrospection); 
     static FCDECL2(Object*, GetOrInternString, AppDomainBaseObject* refThisUNSAFE, StringObject* pStringUNSAFE);
-    static FCDECL3(INT32, ExecuteAssembly, AppDomainBaseObject* refThisUNSAFE, AssemblyBaseObject* assemblyNameUNSAFE, PTRArray* stringArgsUNSAFE);
-#ifdef FEATURE_VERSIONING
     static FCDECL1(void, CreateContext, AppDomainBaseObject *refThisUNSAFE);
     static void QCALLTYPE SetupBindingPaths(__in_z LPCWSTR wszTrustedPlatformAssemblies, __in_z LPCWSTR wszPlatformResourceRoots, __in_z LPCWSTR wszAppPaths, __in_z LPCWSTR wszAppNiPaths, __in_z LPCWSTR appLocalWinMD);
-#endif // FEATURE_VERSIONING
     static FCDECL1(void, Unload, INT32 dwId);
     static FCDECL1(Object*, GetDynamicDir, AppDomainBaseObject* refThisUNSAFE);
     static FCDECL1(INT32, GetId, AppDomainBaseObject* refThisUNSAFE);
@@ -67,9 +61,7 @@ public:
     static FCDECL2(FC_BOOL_RET, IsFrameworkAssembly, AppDomainBaseObject* refThisUNSAFE, AssemblyNameBaseObject* refAssemblyNameUNSAFE);
     static FCDECL1(UINT32,  GetAppDomainId, AppDomainBaseObject* refThisUNSAFE);
     static FCDECL1(void , PublishAnonymouslyHostedDynamicMethodsAssembly, AssemblyBaseObject * pAssemblyUNSAFE);
-#ifdef FEATURE_CORECLR    
     static void QCALLTYPE SetNativeDllSearchDirectories(__in_z LPCWSTR wszAssembly);
-#endif // FEATURE_CORECLR
 
 #ifdef FEATURE_APPDOMAIN_RESOURCE_MONITORING
     static FCDECL0(void,  EnableMonitoring);
@@ -122,32 +114,9 @@ public:
     void QCALLTYPE SetSecurityHomogeneousFlag(QCall::AppDomainHandle adhTarget,
                                               BOOL fRuntimeSuppliedHomgenousGrantSet);
 
-#ifdef FEATURE_CAS_POLICY
-    static
-    void QCALLTYPE SetLegacyCasPolicyEnabled(QCall::AppDomainHandle adhTarget);
 
-    static
-    BOOL QCALLTYPE IsLegacyCasPolicyEnabled(QCall::AppDomainHandle adhTarget);
-#endif // FEATURE_CAS_POLICY
 
-#ifdef FEATURE_APTCA
-    static
-    void QCALLTYPE SetCanonicalConditionalAptcaList(QCall::AppDomainHandle adhTarget,
-                                                    LPCWSTR wszCanonicalConditionalAptcaList);
-#endif // FEATURE_APTCA
-
-#ifdef FEATURE_APPDOMAINMANAGER_INITOPTIONS
-    static
-    void QCALLTYPE RegisterWithHost(IUnknown *punkAppDomainManager);
-#endif // FEATURE_APPDOMAINMANAGER_INITOPTIONS
 
-#if defined(FEATURE_APPX_BINDER)
-    static
-    ICLRPrivBinder * QCALLTYPE CreateDesignerContext(LPCWSTR *rgPaths, UINT cPaths, BOOL fShared);
-
-    static
-    void QCALLTYPE SetCurrentDesignerContext(BOOL fDesignerContext, ICLRPrivBinder *newContext);
-#endif
 };
 
 #endif
diff --git a/src/vm/appdomainstack.cpp b/src/vm/appdomainstack.cpp
index bb21c8e7bd..7e55a8d597 100644
--- a/src/vm/appdomainstack.cpp
+++ b/src/vm/appdomainstack.cpp
@@ -86,91 +86,6 @@ BOOL AppDomainStackEntry::HasFlagsOrFullyTrustedWithNoStackModifiers(DWORD flags
     return Security::CheckDomainWideSpecialFlag(currAppSecDesc, flags);
 }
 
-
-void AppDomainStackEntry::UpdateHomogeneousPLS(OBJECTREF* homogeneousPLS)
-{
-    
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-    
-    AppDomainFromIDHolder domain(m_domainID, TRUE);
-    if (domain.IsUnloaded())
-        return;
-
-    IApplicationSecurityDescriptor *thisAppSecDesc = domain->GetSecurityDescriptor();
-
-    if (thisAppSecDesc->IsHomogeneous())
-    {
-        // update the intersection with the current grant set
-        
-        NewArrayHolder<BYTE> pbtmpSerializedObject(NULL);
-        
-        struct gc
-        {
-            OBJECTREF refGrantSet;
-        } gc;
-        ZeroMemory( &gc, sizeof( gc ) );
-        AppDomain* pCurrentDomain;
-        pCurrentDomain = GetAppDomain();
-            
-        GCPROTECT_BEGIN( gc );
-#ifdef FEATURE_REMOTING // should not be possible without remoting
-        DWORD cbtmpSerializedObject = 0;
-        if (pCurrentDomain->GetId() != m_domainID)
-        {
-            // Unlikely scenario where we have another homogeneous AD on the callstack that's different from
-            // the current one. If there's another AD on the callstack, it's likely to be FT.
-            ENTER_DOMAIN_ID(m_domainID)
-            {
-                // Release the holder to allow GCs.  This is safe because we've entered the AD, so it won't go away.
-                domain.Release();
-
-                gc.refGrantSet = thisAppSecDesc->GetGrantedPermissionSet(NULL); 
-                AppDomainHelper::MarshalObject(GetAppDomain(), &gc.refGrantSet, &pbtmpSerializedObject, &cbtmpSerializedObject);
-                if (pbtmpSerializedObject == NULL)
-            	{
-                    // this is an error: possibly an OOM prevented the blob from getting created.
-                    // We could return null and let the managed code use a fully restricted object or throw here.
-                    // Let's throw here...
-                    COMPlusThrow(kSecurityException);
-                }
-                gc.refGrantSet = NULL;
-
-            }
-            END_DOMAIN_TRANSITION
-            AppDomainHelper::UnmarshalObject(pCurrentDomain,pbtmpSerializedObject, cbtmpSerializedObject, &gc.refGrantSet);
-        }
-        else
-#else
-        _ASSERTE(pCurrentDomain->GetId() == m_domainID);
-#endif //!FEATURE_CORECLR 
-        {
-            // Release the holder to allow GCs.  This is safe because we're running in this AD, so it won't go away.
-            domain.Release();
-            gc.refGrantSet = thisAppSecDesc->GetGrantedPermissionSet(NULL); 
-        }
-
-        // At this point gc.refGrantSet has the grantSet of pDomain (thisAppSecDesc) in the current domain.
-        // We don't care about refused perms since we established there were 
-        // none earlier for this call stack.
-        // Let's intersect with what we've already got.
-
-        PREPARE_NONVIRTUAL_CALLSITE(METHOD__PERMISSION_LIST_SET__UPDATE);
-        DECLARE_ARGHOLDER_ARRAY(args, 2);
-        args[ARGNUM_0]  = OBJECTREF_TO_ARGHOLDER(*homogeneousPLS);    // arg 0
-        args[ARGNUM_1]  = OBJECTREF_TO_ARGHOLDER(gc.refGrantSet);       // arg 1 
-        CALL_MANAGED_METHOD_NORET(args);
-
-        GCPROTECT_END();
-    }
-}
-
-
 BOOL AppDomainStack::AllDomainsHomogeneousWithNoStackModifiers()
 {
     WRAPPER_NO_CONTRACT;
diff --git a/src/vm/appdomainstack.h b/src/vm/appdomainstack.h
index 1390364e47..fffabf97e4 100644
--- a/src/vm/appdomainstack.h
+++ b/src/vm/appdomainstack.h
@@ -45,9 +45,6 @@ struct AppDomainStackEntry
     BOOL IsFullyTrustedWithNoStackModifiers(void);
     BOOL IsHomogeneousWithNoStackModifiers(void);
     BOOL HasFlagsOrFullyTrustedWithNoStackModifiers(DWORD flags);
-#ifndef DACCESS_COMPILE    
-    void UpdateHomogeneousPLS(OBJECTREF* homogeneousPLS);
-#endif
 };
 
 class AppDomainStack
diff --git a/src/vm/appxutil.cpp b/src/vm/appxutil.cpp
index 6bc04d74cd..6ec0386d0a 100644
--- a/src/vm/appxutil.cpp
+++ b/src/vm/appxutil.cpp
@@ -148,48 +148,9 @@ namespace AppX
         }
         CONTRACTL_END
 
-#ifdef FEATURE_CORECLR
         // CoreCLR does not have proper support for AppX design mode. Once/if it has one, it should not need
         // any special casing like desktop. Avoid the expensive check completely.
         return false;
-#else
-        // DevMode does not change over the lifetime of a process and is expensive to compute
-        // Cache the first answer and return it once computed; idempotent so races are fine
-        static enum
-        {
-            CachedAppxMode_Unknown,
-            CachedAppxMode_Normal,
-            CachedAppxMode_Design
-        }
-        s_cachedAppxMode = CachedAppxMode_Unknown;
-
-        bool result = false;
-
-        switch (s_cachedAppxMode)
-        {
-            case CachedAppxMode_Unknown:
-                if (SUCCEEDED(IsAppXDesignModeWorker(&result)))
-                {   // Cache the result on success; otherwise use the default value of false.
-                    s_cachedAppxMode = result ? CachedAppxMode_Design : CachedAppxMode_Normal;
-                }
-                break;
-
-            case CachedAppxMode_Normal:
-                result = false;
-                break;
-
-            case CachedAppxMode_Design:
-                result = true;
-                break;
-        }
-
-#ifdef _DEBUG
-        bool dbg_result = false;
-        _ASSERTE(FAILED(IsAppXDesignModeWorker(&dbg_result)) || dbg_result == result);
-#endif
-
-        return result;
-#endif // FEATURE_CORECLR
     }
 
     HRESULT GetApplicationId(LPCWSTR& rString)
diff --git a/src/vm/aptca.cpp b/src/vm/aptca.cpp
deleted file mode 100644
index e4e8f19255..0000000000
--- a/src/vm/aptca.cpp
+++ /dev/null
@@ -1,1363 +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.
-//--------------------------------------------------------------------------
-// aptca.h
-//
-// Functions for handling allow partially trusted callers assemblies
-//
-
-// 
-//--------------------------------------------------------------------------
-
-
-#include "common.h"
-#include "aptca.h"
-
-//
-// Conditional APTCA cache implementation
-//
-
-ConditionalAptcaCache::ConditionalAptcaCache(AppDomain *pAppDomain) 
-    : m_pAppDomain(pAppDomain),
-      m_canonicalListIsNull(false),
-      m_domainState(kDomainStateUnknown)
-{
-    WRAPPER_NO_CONTRACT;
-
-    _ASSERTE(pAppDomain != NULL);
-}
-
-ConditionalAptcaCache::~ConditionalAptcaCache()
-{
-    WRAPPER_NO_CONTRACT;
-}
-
-void ConditionalAptcaCache::SetCachedState(PTR_PEImage pImage, ConditionalAptcaCache::State state)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pImage));
-        PRECONDITION(state != kUnknown);
-    }
-    CONTRACTL_END;
-
-    if (state == kNotCAptca)
-    {
-        pImage->SetIsNotConditionalAptca();
-    }
-}
-
-ConditionalAptcaCache::State ConditionalAptcaCache::GetCachedState(PTR_PEImage pImage)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pImage));
-    }
-    CONTRACTL_END;
-
-    if (!pImage->MayBeConditionalAptca())
-    {
-        return kNotCAptca;
-    }
-
-    return kUnknown;
-}
-
-void ConditionalAptcaCache::SetCanonicalConditionalAptcaList(LPCWSTR wszCanonicalConditionalAptcaList)
-{
-    WRAPPER_NO_CONTRACT;
-    m_canonicalListIsNull = (wszCanonicalConditionalAptcaList == NULL);
-    m_canonicalList.Set(wszCanonicalConditionalAptcaList);
-}
-
-#ifndef CROSSGEN_COMPILE
-ConditionalAptcaCache::DomainState ConditionalAptcaCache::GetConditionalAptcaDomainState()
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        THROWS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (m_domainState == kDomainStateUnknown)
-    {
-        IApplicationSecurityDescriptor *pASD = m_pAppDomain->GetSecurityDescriptor();
-        DomainState domainState = kDomainStateUnknown;
-
-        // In the full trust case we only need to look at the conditional APTCA list in the case that the host
-        // has configured one on the default domain (for instance WPF).  Otherwise, all full trust domains have
-        // all conditional APTCA assemblies enabled.
-        bool processFullTrustAptcaList = false;
-        if (m_pAppDomain->IsCompilationDomain())
-        {
-            processFullTrustAptcaList = false;
-        }
-        else if (m_pAppDomain->IsDefaultDomain())
-        {
-            processFullTrustAptcaList = !m_canonicalListIsNull;
-        }
-        else
-        {
-            processFullTrustAptcaList = ConsiderFullTrustConditionalAptcaLists();
-        }
-
-        // Consider the domain to be fully trusted if it really is fully trusted, or if we're currently
-        // setting the domain up, it looks like it will be fully trusted, and the AppDomainManager has
-        // promised that won't change.
-        bool isFullTrustDomain = !m_pAppDomain->GetSecurityDescriptor()->DomainMayContainPartialTrustCode();
-        if (pASD->IsInitializationInProgress() && (m_pAppDomain->GetAppDomainManagerInitializeNewDomainFlags() & eInitializeNewDomainFlags_NoSecurityChanges))
-        {
-            BOOL preResolveFullTrust;
-            BOOL preResolveHomogenous;
-            pASD->PreResolve(&preResolveFullTrust, &preResolveHomogenous);
-
-            isFullTrustDomain = preResolveFullTrust && preResolveHomogenous;
-        }
-
-        if (m_pAppDomain->IsCompilationDomain())
-        {
-            // NGEN always enables all conditional APTCA assemblies
-            domainState = kAllEnabled;
-        }
-        else if (!isFullTrustDomain || processFullTrustAptcaList)
-        {
-            if (m_canonicalList.GetCount() == 0)
-            {
-                // A null or empty conditional APTCA list means that no assemblies are enabled in this domain
-                domainState = kAllDisabled;
-            }
-            else
-            {
-                // We're in a domain that supports conditional APTCA and an interesting list is supplied.  In
-                // this domain, some assemblies are enabled.
-                domainState = kSomeEnabled;
-            }
-        }
-        else
-        {
-            domainState = kAllEnabled;
-        }
-
-        _ASSERTE(domainState != kDomainStateUnknown);
-        InterlockedCompareExchange(reinterpret_cast<volatile LONG *>(&m_domainState), domainState, kDomainStateUnknown);
-    }
-
-    return m_domainState;
-}
-
-// static
-bool ConditionalAptcaCache::ConsiderFullTrustConditionalAptcaLists()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (GetAppDomain()->IsCompilationDomain())
-    {
-        return false;
-    }
-
-    IApplicationSecurityDescriptor *pASD = SystemDomain::System()->DefaultDomain()->GetSecurityDescriptor();
-    ConditionalAptcaCache *pDefaultDomainCaptca = pASD->GetConditionalAptcaCache();
-
-    // The only way that we use CAPTCA lists is if the host has configured the default domain to not be all
-    // enabled (that is, the host has setup a CAPTCA list of any sort for the default domain)
-    return pDefaultDomainCaptca->GetConditionalAptcaDomainState() != kAllEnabled;
-}
-
-// APTCA killbit list helper functions
-namespace
-{
-    static const LPCWSTR wszAptcaRootKey = W("SOFTWARE\\Microsoft\\.NETFramework\\Policy\\APTCA");
-
-    //--------------------------------------------------------------------------------------------------------
-    //
-    // The AptcaKillBitList class is responsible for holding the machine wide list of assembly name / file
-    // versions which have been disabled for APTCA on the machine.
-    //
-
-    class AptcaKillBitList
-    {
-    private:
-        ArrayList m_killBitList;
-
-    public:
-        ~AptcaKillBitList();
-
-        bool AreAnyAssembliesKillBitted();
-        bool IsAssemblyKillBitted(PEAssembly *pAssembly);
-        bool IsAssemblyKillBitted(IAssemblyName *pAssemblyName, ULARGE_INTEGER fileVersion);
-
-        static AptcaKillBitList *ReadMachineKillBitList();
-
-    private:
-        AptcaKillBitList();
-        AptcaKillBitList(const AptcaKillBitList &other); // not implemented
-
-    private:
-        static const LPCWSTR wszKillBitValue;
-
-    private:
-        static bool FileVersionsAreEqual(ULARGE_INTEGER targetVersion, IAssemblyName *pKillBitAssemblyName);
-    };
-    const LPCWSTR AptcaKillBitList::wszKillBitValue = W("APTCA_FLAG");
-    
-    AptcaKillBitList::AptcaKillBitList()
-    {
-        LIMITED_METHOD_CONTRACT;
-    }
-
-    AptcaKillBitList::~AptcaKillBitList()
-    {
-        WRAPPER_NO_CONTRACT;
-
-        // Release all of the IAssemblyName objects stored in this list
-        for (DWORD i = 0; i < m_killBitList.GetCount(); ++i)
-        {
-            IAssemblyName *pKillBitAssemblyName = reinterpret_cast<IAssemblyName *>(m_killBitList.Get(i));
-            if (pKillBitAssemblyName != NULL)
-            {
-                pKillBitAssemblyName->Release();
-            }
-        }
-    }
-
-    //--------------------------------------------------------------------------------------------------------
-    //
-    // Determine if any assemblies are on the APTCA killbit list
-    //
-
-    bool AptcaKillBitList::AreAnyAssembliesKillBitted()
-    {
-        CONTRACTL
-        {
-            THROWS;
-            GC_TRIGGERS;
-            MODE_ANY;
-        }
-        CONTRACTL_END;
-
-        // We don't consider the killbit for NGEN, as ngened code always assumes that APTCA is enabled.
-        if (GetAppDomain()->IsCompilationDomain())
-        {
-            return false;
-        }
-
-        return m_killBitList.GetCount() > 0;
-    }
-
-    //--------------------------------------------------------------------------------------------------------
-    //
-    // Compare the file versions of an assembly with the verison that is being killbitted to see if they
-    // match.  For compatibility with v3.5, we assume any failure means that the versions do not match.
-    //
-
-    // static
-    bool AptcaKillBitList::FileVersionsAreEqual(ULARGE_INTEGER targetVersion, IAssemblyName *pKillBitAssemblyName)
-    {
-        DWORD dwKillBitMajorVersion = 0;
-        DWORD dwVersionSize = sizeof(dwKillBitMajorVersion);
-        if (FAILED(pKillBitAssemblyName->GetProperty(ASM_NAME_FILE_MAJOR_VERSION, &dwKillBitMajorVersion, &dwVersionSize)) ||
-            dwVersionSize == 0)
-        {
-            return false;
-        }
-
-        DWORD dwKillBitMinorVersion = 0;
-        dwVersionSize = sizeof(dwKillBitMinorVersion);
-        if (FAILED(pKillBitAssemblyName->GetProperty(ASM_NAME_FILE_MINOR_VERSION, &dwKillBitMinorVersion, &dwVersionSize)) ||
-            dwVersionSize == 0)
-        {
-            return false;
-        }
-
-        DWORD dwKillBitBuildVersion = 0;
-        dwVersionSize = sizeof(dwKillBitBuildVersion);
-        if (FAILED(pKillBitAssemblyName->GetProperty(ASM_NAME_FILE_BUILD_NUMBER, &dwKillBitBuildVersion, &dwVersionSize)) ||
-            dwVersionSize == 0)
-        {
-            return false;
-        }
-
-        DWORD dwKillBitRevisionVersion = 0;
-        dwVersionSize = sizeof(dwKillBitRevisionVersion);
-        if (FAILED(pKillBitAssemblyName->GetProperty(ASM_NAME_FILE_REVISION_NUMBER, &dwKillBitRevisionVersion, &dwVersionSize)) ||
-            dwVersionSize == 0)
-        {
-            return false;
-        }
-
-        DWORD dwTargetMajorVersion = (targetVersion.HighPart & 0xFFFF0000) >> 16;
-        DWORD dwTargetMinorVersion = targetVersion.HighPart & 0x0000FFFF;
-        DWORD dwTargetBuildVersion = (targetVersion.LowPart & 0xFFFF0000) >> 16;
-        DWORD dwTargetRevisionVersion = targetVersion.LowPart & 0x0000FFFF;
-
-        return dwTargetMajorVersion == dwKillBitMajorVersion &&
-               dwTargetMinorVersion == dwKillBitMinorVersion &&
-               dwTargetBuildVersion == dwKillBitBuildVersion &&
-               dwTargetRevisionVersion == dwKillBitRevisionVersion;
-    }
-
-    //--------------------------------------------------------------------------------------------------------
-    //
-    // Determine if a specific assembly is on the killbit list
-    //
-
-    bool AptcaKillBitList::IsAssemblyKillBitted(PEAssembly *pAssembly)
-    {
-        STANDARD_VM_CONTRACT;
-
-        IAssemblyName *pTargetAssemblyName = pAssembly->GetFusionAssemblyName();
-
-        // For compat with v3.5, we use hte Win32 file version here rather than the Fusion version
-        LPCWSTR pwszPath = pAssembly->GetPath().GetUnicode();
-        if (pwszPath != NULL)
-        {
-            ULARGE_INTEGER fileVersion = { 0, 0 };
-            HRESULT hr = GetFileVersion(pwszPath, &fileVersion);
-            if (SUCCEEDED(hr))
-            {
-                return IsAssemblyKillBitted(pTargetAssemblyName, fileVersion);
-            }
-        }
-
-        return false;
-    }
-
-    //--------------------------------------------------------------------------------------------------------
-    //
-    // Determine if a specific assembly is on the killbit list
-    //
-
-    bool AptcaKillBitList::IsAssemblyKillBitted(IAssemblyName *pTargetAssemblyName, ULARGE_INTEGER fileVersion)
-    {
-        STANDARD_VM_CONTRACT;
-
-        // If nothing is killbitted, then this assembly cannot be killbitted
-        if (!AreAnyAssembliesKillBitted())
-        {
-            return false;
-        }
-
-        for (DWORD i = 0; i < m_killBitList.GetCount(); ++i)
-        {
-            IAssemblyName *pKillBitAssemblyName = reinterpret_cast<IAssemblyName *>(m_killBitList.Get(i));
-
-            // By default, we compare all fields of the assembly's name, however if the culture was neutral,
-            // we strip that out.
-            DWORD dwCmpFlags = ASM_CMPF_IL_ALL;
-
-            DWORD cbCultureSize = 0;
-            SString strCulture;
-            HRESULT hrCulture = pKillBitAssemblyName->GetProperty(ASM_NAME_CULTURE, NULL, &cbCultureSize);
-            if (hrCulture == HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER))
-            {
-                DWORD cchCulture = (cbCultureSize / sizeof(WCHAR)) - 1;
-                WCHAR *wszCultureBuffer = strCulture.OpenUnicodeBuffer(cchCulture);
-                hrCulture = pKillBitAssemblyName->GetProperty(ASM_NAME_CULTURE, wszCultureBuffer, &cbCultureSize);
-                strCulture.CloseBuffer();
-            }
-
-            if (SUCCEEDED(hrCulture))
-            {
-                if (cbCultureSize == 0 || strCulture.EqualsCaseInsensitive(W("")) || strCulture.EqualsCaseInsensitive(W("neutral")))
-                {
-                    dwCmpFlags &= ~ASM_CMPF_CULTURE;
-                }
-            }
-
-            // If the input assembly matches the kill bit assembly's name and file version, then we need to
-            // kill it.
-            if (pTargetAssemblyName->IsEqual(pKillBitAssemblyName, dwCmpFlags) == S_OK &&
-                FileVersionsAreEqual(fileVersion, pKillBitAssemblyName))
-            {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    //--------------------------------------------------------------------------------------------------------
-    //
-    // Read the machine-wide APTCA kill bit list into a kill bit list object.  For compatibility with v3.5,
-    // errors during this initialization are ignored - leading to APTCA entries that may not be considered
-    // for kill bitting.
-    //
-
-    // static
-    AptcaKillBitList *AptcaKillBitList::ReadMachineKillBitList()
-    {
-        CONTRACT(AptcaKillBitList *)
-        {
-            STANDARD_VM_CHECK;
-            POSTCONDITION(CheckPointer(RETVAL));
-        }
-        CONTRACT_END;
-
-        NewHolder<AptcaKillBitList> pKillBitList(new AptcaKillBitList);
-
-        HKEYHolder hKeyAptca;
-
-        // Open the APTCA subkey in the registry.
-        if (WszRegOpenKeyEx(HKEY_LOCAL_MACHINE, wszAptcaRootKey, 0, KEY_READ, &hKeyAptca) == ERROR_SUCCESS)
-        {
-
-            DWORD cchSubKeySize = 0;
-            if (WszRegQueryInfoKey(hKeyAptca, NULL, NULL, NULL, NULL, &cchSubKeySize, NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
-            {
-                cchSubKeySize = MAX_PATH_FNAME;
-            }
-            ++cchSubKeySize;
-
-            NewArrayHolder<WCHAR> wszSubKey(new WCHAR[cchSubKeySize]);
-
-            DWORD dwKey = 0;
-            DWORD cchWszSubKey = cchSubKeySize;
-            // Assembly specific records are represented as subkeys of the key we've just opened with names
-            // equal to the strong name of the assembly being kill bitted, and a value of APTCA_FLAG = 1.
-            while (WszRegEnumKeyEx(hKeyAptca, dwKey, wszSubKey, &cchWszSubKey, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
-            {
-                ++dwKey;
-                cchWszSubKey = cchSubKeySize;
-
-                // Open the subkey: the key name is the full name of the assembly to potentially kill-bit
-                HKEYHolder hSubKey;
-                if (WszRegOpenKeyEx(hKeyAptca, wszSubKey, 0, KEY_READ, &hSubKey) != ERROR_SUCCESS)
-                {
-                    continue;
-                }
-
-                DWORD dwKillbit = 0;
-                DWORD dwType = REG_DWORD;
-                DWORD dwSize = sizeof(dwKillbit);
-
-                // look for the APTCA flag
-                LONG queryValue =  WszRegQueryValueEx(hSubKey,
-                                                      wszKillBitValue,
-                                                      NULL,
-                                                      &dwType,
-                                                      reinterpret_cast<LPBYTE>(&dwKillbit),
-                                                      &dwSize);
-                if (queryValue == ERROR_SUCCESS && dwKillbit == 1)
-                {
-                    // We have a strong named assembly with an APTCA killbit value set - parse the key into
-                    // an assembly name, and add it to our list
-                    ReleaseHolder<IAssemblyName> pKillBitAssemblyName;
-                    HRESULT hrAssemblyName = CreateAssemblyNameObject(&pKillBitAssemblyName, wszSubKey, CANOF_PARSE_DISPLAY_NAME, NULL);
-                    if (FAILED(hrAssemblyName))
-                    {
-                        continue;
-                    }
-
-                    //
-                    // For compatibility with v3.5, we only accept kill bit entries which have four part
-                    // assembly versions, names, and public key tokens.
-                    //
-
-                    // Verify the version first
-                    bool validVersion = true;
-                    for (DWORD dwVersionPartId = ASM_NAME_MAJOR_VERSION; dwVersionPartId <= ASM_NAME_REVISION_NUMBER; ++dwVersionPartId)
-                    {
-                        DWORD dwVersionPart;
-                        DWORD cbVersionPart = sizeof(dwVersionPart);
-                        HRESULT hrVersion = pKillBitAssemblyName->GetProperty(dwVersionPartId, &dwVersionPart, &cbVersionPart);
-                        if (FAILED(hrVersion) || cbVersionPart == 0)
-                        {
-                            validVersion = false;
-                        }
-                    }
-                    if (!validVersion)
-                    {
-                        continue;
-                    }
-
-                    // Make sure there is a simple name
-                    DWORD cbNameSize = 0;
-                    HRESULT hrName = pKillBitAssemblyName->GetProperty(ASM_NAME_NAME, NULL, &cbNameSize);
-                    if (hrName != HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER))
-                    {
-                        continue;
-                    }
-
-                    // Verify the killbit assembly has a public key token
-                    DWORD cbPublicKeyTokenSize = 0;
-                    HRESULT hrPublicKey = pKillBitAssemblyName->GetProperty(ASM_NAME_PUBLIC_KEY_TOKEN, NULL, &cbPublicKeyTokenSize);
-                    if (hrPublicKey != HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER))
-                    {
-                        continue;
-                    }
-
-                    // Verify the killbit assembly has either no culture or a valid culture token
-                    DWORD cbCultureSize = 0;
-                    HRESULT hrCulture = pKillBitAssemblyName->GetProperty(ASM_NAME_CULTURE, NULL, &cbCultureSize);
-                    if (FAILED(hrCulture) && hrCulture != HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER))
-                    {
-                        continue;
-                    }
-
-                    // The name checks out, so add the kill bit entry
-                    LOG((LF_SECURITY,
-                         LL_INFO10,
-                         "APTCA killbit added for assembly '%S'.\n",
-                         wszSubKey));
-                    pKillBitList->m_killBitList.Append(pKillBitAssemblyName.Extract());
-                }
-            }
-        }
-
-        RETURN(pKillBitList.Extract());
-    }
-
-    VolatilePtr<AptcaKillBitList> g_pAptcaKillBitList(NULL);
-
-    //--------------------------------------------------------------------------------------------------------
-    //
-    // Get the APTCA killbit list
-    //
-
-    AptcaKillBitList *GetKillBitList()
-    {
-        STANDARD_VM_CONTRACT;
-
-        if (g_pAptcaKillBitList.Load() == NULL)
-        {
-            NewHolder<AptcaKillBitList> pAptcaKillBitList(AptcaKillBitList::ReadMachineKillBitList());
-
-            LPVOID pvOldValue = InterlockedCompareExchangeT(g_pAptcaKillBitList.GetPointer(),
-                                                            pAptcaKillBitList.GetValue(),
-                                                            NULL);
-            if (pvOldValue == NULL)
-            {
-                pAptcaKillBitList.SuppressRelease();
-            }
-        }
-
-        _ASSERTE(g_pAptcaKillBitList.Load() != NULL);
-        return g_pAptcaKillBitList.Load();
-    }
-}
-
-// APTCA helper functions
-namespace
-{
-    enum ConditionalAptcaSharingMode
-    {
-        kShareUnknown,
-        kShareIfEnabled,        // Share an assembly only if all conditional APTCA assemblies in its closure are enabled
-        kShareIfDisabled,       // Share an assembly only if all conditional APTCA assemblies in its closure are disabled
-    };
-
-    //--------------------------------------------------------------------------------------------------------
-    //
-    // Get the name of an assembly as it would appear in the APTCA enabled list of an AppDomain
-    //
-
-    void GetAssemblyNameForConditionalAptca(Assembly *pAssembly, SString *pAssemblyName)
-    {
-        CONTRACTL
-        {
-            THROWS;
-            GC_TRIGGERS;
-            MODE_ANY;
-            PRECONDITION(CheckPointer(pAssembly));
-            PRECONDITION(CheckPointer(pAssemblyName));
-        }
-        CONTRACTL_END;
-
-        GCX_COOP();
-
-        // Call assembly.GetName().GetNameWithPublicKey() to get the name the user would have to add to the 
-        // whitelist to enable this assembly
-        struct
-        {
-            OBJECTREF orAssembly;
-            STRINGREF orAssemblyName;
-        }
-        gc;
-        ZeroMemory(&gc, sizeof(gc));
-
-        GCPROTECT_BEGIN(gc);
-
-        gc.orAssembly = pAssembly->GetExposedObject();
-        MethodDescCallSite getAssemblyName(METHOD__ASSEMBLY__GET_NAME_FOR_CONDITIONAL_APTCA, &gc.orAssembly);
-        ARG_SLOT args[1] =
-        { 
-            ObjToArgSlot(gc.orAssembly)
-        };
-        gc.orAssemblyName = getAssemblyName.Call_RetSTRINGREF(args);
-            
-        // Copy to assemblyName
-        pAssemblyName->Set(gc.orAssemblyName->GetBuffer());
-
-        GCPROTECT_END();
-    }
-
-    //--------------------------------------------------------------------------------------------------------
-    //
-    // Determine which types of conditional APTCA assemblies may be shared
-    //
-
-    ConditionalAptcaSharingMode GetConditionalAptcaSharingMode()
-    {
-        CONTRACTL
-        {
-            THROWS;
-            GC_TRIGGERS;
-            MODE_ANY;
-        }
-        CONTRACTL_END;
-
-        static ConditionalAptcaSharingMode sharingMode = kShareUnknown;
-
-        if (sharingMode == kShareUnknown)
-        {
-            // If the default domain has any conditional APTCA assemblies enabled in it, then we share in the
-            // enabled direction.  Otherwise, the default domain has all conditional APTCA assemblies disabled
-            // so we need to share in the disabled direction
-            ConditionalAptcaCache *pDefaultDomainCache = SystemDomain::System()->DefaultDomain()->GetSecurityDescriptor()->GetConditionalAptcaCache();
-            ConditionalAptcaCache::DomainState domainState = pDefaultDomainCache->GetConditionalAptcaDomainState();
-            
-            if (domainState == ConditionalAptcaCache::kAllDisabled)
-            {
-                sharingMode = kShareIfDisabled;
-            }
-            else
-            {
-                sharingMode = kShareIfEnabled;
-            }
-        }
-
-        return sharingMode;
-    }
-
-    /* XXX Fri 7/17/2009
-     * I can't call DomainAssembly::IsConditionalAPTCAVisible() here.  That requires an Assembly which means
-     * we have to be at FILE_LOAD_ALLOCATE.  There are two problems:
-     * 1) We don't want to load dependencies here if we can avoid it
-     * 2) We can't load them anyway (hard bound dependencies can't get past
-     *      FILE_LOAD_VERIFY_NATIVE_IMAGE_DEPENDENCIES.
-     *
-     * We're going to do a relaxed check here.  Instead of checking the public key, we're
-     * only going to check the public key token.  See
-     * code:AppDomain::IsAssemblyOnAptcaVisibleListRaw for more information.
-     *
-     * pAsmName - The name of the assembly to check.
-     * pDomainAssembly - The Domain Assembly used for logging.
-     */
-    bool IsAssemblyOnAptcaVisibleList(IAssemblyName * pAsmName, DomainAssembly *pDomainAssembly)
-    {
-        CONTRACTL
-        {
-            STANDARD_VM_CHECK;
-            PRECONDITION(CheckPointer(pAsmName));
-        }
-        CONTRACTL_END;
-
-        ConditionalAptcaCache *pDomainCache = pDomainAssembly->GetAppDomain()->GetSecurityDescriptor()->GetConditionalAptcaCache();
-        if (pDomainCache->GetConditionalAptcaDomainState() == ConditionalAptcaCache::kAllEnabled)
-        {
-            return true;
-        }
-
-        CQuickBytes qbName;
-        LPWSTR pszName;
-        DWORD cbName = 0;
-        HRESULT hr = pAsmName->GetProperty(ASM_NAME_NAME, NULL, &cbName);
-        if (hr == HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER))
-        {
-            pszName = (LPWSTR)qbName.AllocThrows(cbName);
-        }
-        else
-        {
-            pDomainAssembly->ExternalLog(LL_ERROR, W("Rejecting native image / code sharing because there was an ")
-                                         W("error checking for conditional APTCA: 0x%x"), hr);
-            return false;
-        }
-        hr = pAsmName->GetProperty(ASM_NAME_NAME, (void *)pszName, &cbName);
-        if (FAILED(hr))
-        {
-            pDomainAssembly->ExternalLog(LL_ERROR, W("Rejecting native image / code sharing because there was an ")
-                                         W("error checking for conditional APTCA: 0x%x"), hr);
-            return false;
-        }
-        BYTE rgPublicKeyToken[8];
-        DWORD cbPkt = _countof(rgPublicKeyToken);
-        hr = pAsmName->GetProperty(ASM_NAME_PUBLIC_KEY_TOKEN,
-                                                  (void*)rgPublicKeyToken, &cbPkt);
-        if (FAILED(hr))
-        {
-            pDomainAssembly->ExternalLog(LL_ERROR, W("Rejecting native image / code sharing because there was an ")
-                                         W("error obtaining the public key token for %s: 0x%x"),
-                                         pszName, hr);
-            return false;
-        }
-
-        GCX_COOP();
-
-        CLR_BOOL isVisible = FALSE;
-
-        struct
-        {
-            OBJECTREF orThis;
-        }
-        gc;
-        ZeroMemory(&gc, sizeof(gc));
-        GCPROTECT_BEGIN(gc);
-        gc.orThis = pDomainAssembly->GetAppDomain()->GetExposedObject();
-
-        MethodDescCallSite assemblyVisible(METHOD__APP_DOMAIN__IS_ASSEMBLY_ON_APTCA_VISIBLE_LIST_RAW,
-                                           &gc.orThis);
-        ARG_SLOT args[] = {
-            ObjToArgSlot(gc.orThis),
-            (ARG_SLOT)pszName,
-            (ARG_SLOT)wcslen(pszName),
-            (ARG_SLOT)rgPublicKeyToken,
-            (ARG_SLOT)cbPkt
-        };
-        isVisible = assemblyVisible.Call_RetBool(args);
-        GCPROTECT_END();
-
-        return isVisible;
-    }
-
-    bool IsAssemblyOnAptcaVisibleList(DomainAssembly *pAssembly)
-    {
-        CONTRACTL
-        {
-            STANDARD_VM_CHECK;
-            PRECONDITION(CheckPointer(pAssembly));
-            PRECONDITION(GetAppDomain() == pAssembly->GetAppDomain());
-        }
-        CONTRACTL_END;
-
-        ConditionalAptcaCache *pDomainCache = pAssembly->GetAppDomain()->GetSecurityDescriptor()->GetConditionalAptcaCache();
-        if (pDomainCache->GetConditionalAptcaDomainState() == ConditionalAptcaCache::kAllEnabled)
-        {
-            return true;
-        }
-
-        GCX_COOP();
-
-        bool foundInList = false;
-
-        // Otherwise, we need to transition into the BCL code to find out if the assembly is on the list
-        struct
-        {
-            OBJECTREF orAppDomain;
-            OBJECTREF orAssembly;
-        }
-        gc;
-        ZeroMemory(&gc, sizeof(gc));
-
-        GCPROTECT_BEGIN(gc);
-
-        MethodDescCallSite isAssemblyOnAptcaVisibleList(METHOD__APP_DOMAIN__IS_ASSEMBLY_ON_APTCA_VISIBLE_LIST);
-        gc.orAppDomain = GetAppDomain()->GetExposedObject();
-        gc.orAssembly = pAssembly->GetAssembly()->GetExposedObject();
-
-        ARG_SLOT args[] =
-        { 
-            ObjToArgSlot(gc.orAppDomain),
-            ObjToArgSlot(gc.orAssembly)
-        };
-
-        foundInList = isAssemblyOnAptcaVisibleList.Call_RetBool(args);
-
-        GCPROTECT_END();
-
-        return foundInList;
-    }
-
-    //--------------------------------------------------------------------------------------------------------
-    //
-    // Determine if an assembly is APTCA in the current domain or not
-    //
-    // Arguments:
-    //    pDomainAssembly - Assembly to check for APTCA-ness
-    //    tokenFlags      - raw metadata security bits from the assembly
-    //
-    // Return Value:
-    //    true if the assembly is APTCA, false if it is not
-    //
-
-    bool IsAssemblyAptcaEnabled(DomainAssembly *pDomainAssembly, TokenSecurityDescriptorFlags tokenFlags)
-    {
-        CONTRACTL
-        {
-            THROWS;
-            GC_TRIGGERS;
-            MODE_ANY;
-            PRECONDITION(CheckPointer(pDomainAssembly));
-        }
-        CONTRACTL_END;
-
-#ifdef _DEBUG
-        SString strAptcaAssemblyBreak(CLRConfig::GetConfigValue(CLRConfig::INTERNAL_Security_AptcaAssemblyBreak));
-        SString strAssemblySimpleName(SString::Utf8, pDomainAssembly->GetSimpleName());
-        if (strAptcaAssemblyBreak.EqualsCaseInsensitive(strAssemblySimpleName))
-        {
-            _ASSERTE(!"Checking APTCA-ness of an APTCA break assembly");
-        }
-#endif // _DEBUG
-
-        // If the assembly is not marked APTCA, then it cannot possibly be APTCA enabled
-        if ((tokenFlags & TokenSecurityDescriptorFlags_APTCA) == TokenSecurityDescriptorFlags_None)
-        {
-            return false;
-        }
-
-        GCX_PREEMP();
-
-        // Additionally, if the assembly is on the APTCA kill list, then no matter what it says in its metadata,
-        // it should not be considered APTCA
-        if (GetKillBitList()->IsAssemblyKillBitted(pDomainAssembly->GetFile()))
-        {
-            return false;
-        }
-
-        // If the assembly is conditionally APTCA, then we need to check the current AppDomain's APTCA enabled
-        // list to figure out if it is APTCA in this domain.
-        if (tokenFlags & TokenSecurityDescriptorFlags_ConditionalAPTCA)
-        {
-            return IsAssemblyOnAptcaVisibleList(pDomainAssembly);
-        }
-
-        // Otherwise, the assembly is APTCA
-        return true;
-    }
-
-    //--------------------------------------------------------------------------------------------------------
-    //
-    // Determine if the assembly matches the conditional APTCA sharing mode.  That is, if we are sharing
-    // enabled conditional APTCA assemblies check that this assembly is enabled.  Similarly, if we are
-    // sharing disabled conditional APTCA assemblies check that this assembly is disabled.
-    // 
-    // This method assumes that the assembly is conditionally APTCA
-    //
-
-    bool AssemblyMatchesShareMode(IAssemblyName *pAsmName, DomainAssembly *pDomainAssembly)
-    {
-        CONTRACTL
-        {
-            STANDARD_VM_CHECK;
-            PRECONDITION(CheckPointer(pAsmName));
-            PRECONDITION(GetConditionalAptcaSharingMode() != kShareUnknown);
-        }
-        CONTRACTL_END;
-
-        if (IsAssemblyOnAptcaVisibleList(pAsmName, pDomainAssembly))
-        {
-            return GetConditionalAptcaSharingMode() == kShareIfEnabled;
-        }
-        else
-        {
-            return GetConditionalAptcaSharingMode() == kShareIfDisabled;
-        }
-    }
-
-    bool AssemblyMatchesShareMode(ConditionalAptcaCache::State state)
-    {
-        STANDARD_VM_CONTRACT;
-
-        _ASSERTE(state == ConditionalAptcaCache::kEnabled || state == ConditionalAptcaCache::kDisabled);
-
-        if (state == ConditionalAptcaCache::kEnabled)
-        {
-            return GetConditionalAptcaSharingMode() == kShareIfEnabled;
-        }
-        else
-        {
-            return GetConditionalAptcaSharingMode() == kShareIfDisabled;
-        }
-    }
-}
-
-//------------------------------------------------------------------------------------------------------------
-//
-// Determine if the AppDomain can share an assembly or if APTCA restrictions prevent sharing
-// 
-
-bool DomainCanShareAptcaAssembly(DomainAssembly *pDomainAssembly)
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pDomainAssembly));
-    }
-    CONTRACTL_END;
-
-#ifdef _DEBUG
-    DWORD dwAptcaAssemblyDomainBreak = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_Security_AptcaAssemblySharingDomainBreak);
-    if (dwAptcaAssemblyDomainBreak == 0 || ADID(dwAptcaAssemblyDomainBreak) == pDomainAssembly->GetAppDomain()->GetId())
-    {
-        SString strAptcaAssemblySharingBreak(CLRConfig::GetConfigValue(CLRConfig::INTERNAL_Security_AptcaAssemblySharingBreak));
-        SString strAssemblySimpleName(SString::Utf8, pDomainAssembly->GetSimpleName());
-
-        if (strAptcaAssemblySharingBreak.EqualsCaseInsensitive(strAssemblySimpleName))
-        {
-            _ASSERTE(!"Checking code sharing for APTCA break assembly");
-        }
-    }
-#endif // _DEBUG
-
-    //
-    // We can only share an assembly if all conditional APTCA assemblies in its full closure of dependencies
-    // are enabled.
-    //
-
-    // We always allow sharing of mscorlib
-    if (pDomainAssembly->IsSystem())
-    {
-        return true;
-    }
-
-    IApplicationSecurityDescriptor *pDomainSecDesc = pDomainAssembly->GetAppDomain()->GetSecurityDescriptor();
-    ConditionalAptcaCache *pConditionalAptcaCache = pDomainSecDesc->GetConditionalAptcaCache();
-
-    // If all assemblies in the domain match the sharing mode, then we can share the assembly
-    ConditionalAptcaCache::DomainState domainState = pConditionalAptcaCache->GetConditionalAptcaDomainState();
-    if (GetConditionalAptcaSharingMode() == kShareIfEnabled)
-    {
-        if (domainState == ConditionalAptcaCache::kAllEnabled)
-        {
-            return true;
-        }
-    }
-    else
-    {
-        if (domainState == ConditionalAptcaCache::kAllDisabled)
-        {
-            return true;
-        }
-    }
-
-    // If the root assembly is conditionally APTCA, then it needs to be enabled
-    ReleaseHolder<IMDInternalImport> pRootImport(pDomainAssembly->GetFile()->GetMDImportWithRef());
-    TokenSecurityDescriptorFlags rootSecurityAttributes =
-        TokenSecurityDescriptor::ReadSecurityAttributes(pRootImport, TokenFromRid(1, mdtAssembly));
-    if (rootSecurityAttributes & TokenSecurityDescriptorFlags_ConditionalAPTCA)
-    {
-        if (!AssemblyMatchesShareMode(pDomainAssembly->GetFile()->GetFusionAssemblyName(), pDomainAssembly))
-        {
-            return false;
-        }
-    }
-
-    // Now we need to get the full closure of assemblies that this assembly depends upon and ensure that each
-    // one of those is either not conditional APTCA or is enabled in the domain.  We get a new assembly
-    // closure object here rather than using DomainAssembly::GetAssemblyBindingClosure because we don't want
-    // to force that closure to walk the full dependency graph (and therefore not be considered equal to
-    // closures which weren't fully walked).
-    IUnknown *pFusionAssembly;
-    if (pDomainAssembly->GetFile()->IsIStream())
-    {
-        pFusionAssembly = pDomainAssembly->GetFile()->GetIHostAssembly();
-    }
-    else
-    {
-        pFusionAssembly = pDomainAssembly->GetFile()->GetFusionAssembly();
-    }
-
-    // Get the closure and force it to do a full dependency walk, not stopping at framework assemblies
-    SafeComHolder<IAssemblyBindingClosure> pClosure;
-
-
-    LPCWSTR pNIPath = NULL;
-    PEAssembly *pPEAsm = pDomainAssembly->GetFile();
-    if (pPEAsm->HasNativeImage())
-    {
-        ReleaseHolder<PEImage> pNIImage = pPEAsm->GetNativeImageWithRef();
-        pNIPath = pNIImage->GetPath().GetUnicode();
-    }
-
-    IfFailThrow(pDomainAssembly->GetAppDomain()->GetFusionContext()->GetAssemblyBindingClosure(pFusionAssembly, pNIPath, &pClosure));
-    IfFailThrow(pClosure->EnsureWalked(pFusionAssembly, pDomainAssembly->GetAppDomain()->GetFusionContext(), LEVEL_FXPROBED));
-
-    // Now iterate the closure looking for conditional APTCA assemblies
-    SafeComHolder<IAssemblyBindingClosureEnumerator> pClosureEnumerator;
-    IfFailThrow(pClosure->EnumerateAssemblies(&pClosureEnumerator));
-    LPCOLESTR szDependentAssemblyPath = NULL;
-    LPCOLESTR szDependentNIAssemblyPath = NULL;
-
-    for (HRESULT hr = pClosureEnumerator->GetNextAssemblyPath(&szDependentAssemblyPath, &szDependentNIAssemblyPath);
-         SUCCEEDED(hr);
-         hr = pClosureEnumerator->GetNextAssemblyPath(&szDependentAssemblyPath, &szDependentNIAssemblyPath))
-    {
-        // Make sure we've succesfully enumerated an item
-        if (hr != S_OK && hr != HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS))
-        {
-            pDomainAssembly->ExternalLog(LL_ERROR, W("Rejecting code sharing because of an error enumerating dependent assemblies: 0x%x"), hr);
-            return false;
-        }
-        else if (szDependentAssemblyPath == NULL)
-        {
-            // This means we have an assembly but no way to verify the image at this point -- should we get
-            // into this state, we'll be conservative and fail the share
-            pDomainAssembly->ExternalLog(LL_ERROR, W("Rejecting code sharing because an assembly in the closure does not have a path"));
-            return false;
-        }
-        else
-        {
-            // We have succesfully found a new item in the closure of assemblies - now check to ensure that
-            // it is either not conditionally APTCA or is enabled in tihs domain.
-            PEImageHolder pDependentImage;
-
-            // Use the native image if it is loaded. 
-            if (szDependentNIAssemblyPath != NULL)
-            {
-                SString strNIAssemblyPath(szDependentNIAssemblyPath);
-                pDependentImage = PEImage::OpenImage(strNIAssemblyPath, MDInternalImport_OnlyLookInCache);
-                if (pDependentImage != NULL && !pDependentImage->HasLoadedLayout())
-                {
-                    pDependentImage = NULL;
-                }
-                else
-                {
-#if FEATURE_CORECLR
-#error Coreclr needs to check native image version here.
-#endif
-                }
-            }
-
-            if (pDependentImage == NULL)
-            {
-                SString strAssemblyPath(szDependentAssemblyPath);
-                pDependentImage = PEImage::OpenImage(strAssemblyPath);
-            }
-
-            // See if we already know if this image is enabled in the current domain or not
-            ConditionalAptcaCache::State dependentState = pConditionalAptcaCache->GetCachedState(pDependentImage);
-
-            // We don't know this assembly's conditional APTCA state in this domain, so we need to figure it
-            // out now.
-            if (dependentState == ConditionalAptcaCache::kUnknown)
-            {
-                // First figure out if the assembly is even conditionally APTCA to begin with
-                IMDInternalImport *pDependentImport = pDependentImage->GetMDImport();
-                TokenSecurityDescriptorFlags dependentSecurityAttributes =
-                    TokenSecurityDescriptor::ReadSecurityAttributes(pDependentImport, TokenFromRid(1, mdtAssembly));
-
-                if (dependentSecurityAttributes & TokenSecurityDescriptorFlags_ConditionalAPTCA)
-                {
-                    // The the assembly name of the dependent assembly so we can check it to the domain
-                    // enabled list
-                    ReleaseHolder<IAssemblyName> pDependentAssemblyName;
-                    AssemblySpec dependentAssemblySpec(pDomainAssembly->GetAppDomain());
-                    dependentAssemblySpec.InitializeSpec(TokenFromRid(1, mdtAssembly), pDependentImport);
-                    IfFailThrow(dependentAssemblySpec.CreateFusionName(&pDependentAssemblyName, FALSE));
-
-                    // Check the domain list to see if the assembly is on it
-                    if (IsAssemblyOnAptcaVisibleList(pDependentAssemblyName, pDomainAssembly))
-                    {
-                        dependentState = ConditionalAptcaCache::kEnabled;
-                    }
-                    else
-                    {
-                        dependentState = ConditionalAptcaCache::kDisabled;
-                    }
-                }
-                else
-                {
-                    // The dependent assembly doesn't have the conditional APTCA bit set on it, so we don't
-                    // need to do any checking to see if it's enabled
-                    dependentState = ConditionalAptcaCache::kNotCAptca;
-                }
-
-                // Cache the result of evaluating conditional APTCA on this assembly in the domain
-                pConditionalAptcaCache->SetCachedState(pDependentImage, dependentState);
-            }
-
-            // If the dependent assembly does not match the sharing mode, then we cannot share the
-            // dependency. We can always share dependencies which are not conditionally APTCA, so don't
-            // bother checking the share mode for them.
-            if (dependentState != ConditionalAptcaCache::kNotCAptca)
-            {
-                if (!AssemblyMatchesShareMode(dependentState))
-                {
-                    pDomainAssembly->ExternalLog(LL_ERROR, W("Rejecting code sharing because a dependent assembly did not match the conditional APTCA share mode"));
-                    return false;
-                }
-            }
-        }
-    }
-
-    // The root assembly and all of its dependents were either on the conditional APTCA list or are not
-    // conditional APTCA, so we can share this assembly
-    return true;   
-}
-
-//------------------------------------------------------------------------------------------------------------
-//
-// Get an exception string indicating how to enable a conditional APTCA assembly if it was disabled and
-// caused an exception
-// 
-
-SString GetConditionalAptcaAccessExceptionContext(Assembly *pTargetAssembly)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pTargetAssembly));
-    }
-    CONTRACTL_END;
-
-    SString exceptionContext;
-
-    ModuleSecurityDescriptor *pMSD = ModuleSecurityDescriptor::GetModuleSecurityDescriptor(pTargetAssembly);
-
-    if (pMSD->GetTokenFlags() & TokenSecurityDescriptorFlags_ConditionalAPTCA)
-    {
-        GCX_PREEMP();
-
-        if (!IsAssemblyOnAptcaVisibleList(pTargetAssembly->GetDomainAssembly()))
-        {
-            // We have a conditional APTCA assembly which is not on the visible list for the current
-            // AppDomain, provide information on how to enable it.
-            SString assemblyDisplayName;
-            pTargetAssembly->GetDisplayName(assemblyDisplayName);
-
-            SString assemblyConditionalAptcaName;
-            GetAssemblyNameForConditionalAptca(pTargetAssembly, &assemblyConditionalAptcaName);
-
-            EEException::GetResourceMessage(IDS_ACCESS_EXCEPTION_CONTEXT_CONDITIONAL_APTCA,
-                                            exceptionContext,
-                                            assemblyDisplayName,
-                                            assemblyConditionalAptcaName);
-        }
-    }
-
-    return exceptionContext;
-}
-
-//------------------------------------------------------------------------------------------------------------
-//
-// Get an exception string indicating that an assembly was on the kill bit list if it caused an exception
-//
-
-SString GetAptcaKillBitAccessExceptionContext(Assembly *pTargetAssembly)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pTargetAssembly));
-    }
-    CONTRACTL_END;
-
-    GCX_PREEMP();
-
-    SString exceptionContext;
-
-    if (GetKillBitList()->IsAssemblyKillBitted(pTargetAssembly->GetDomainAssembly()->GetFile()))
-    {
-        SString assemblyDisplayName;
-        pTargetAssembly->GetDisplayName(assemblyDisplayName);
-
-        EEException::GetResourceMessage(IDS_ACCESS_EXCEPTION_CONTEXT_APTCA_KILLBIT,
-                                        exceptionContext,
-                                        assemblyDisplayName);
-    }
-
-    return exceptionContext;
-}
-
-//------------------------------------------------------------------------------------------------------------
-//
-// Determine if a native image is valid to use from the perspective of APTCA.  This means that the image
-// itself and all of its dependencies must:
-//   1. Not be killbitted
-//   2. Be enabled if they are conditionally APTCA
-//
-// Arguments:
-//    pNativeImage    -  native image to accept or reject
-//    pDomainAssembly -  assembly that is being loaded
-//
-// Return Value:
-//    true if the native image can be accepted due to APTCA-ness, false if we need to reject it
-//
-
-bool NativeImageHasValidAptcaDependencies(PEImage *pNativeImage, DomainAssembly *pDomainAssembly)
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pNativeImage));
-        PRECONDITION(CheckPointer(pDomainAssembly));
-    }
-    CONTRACTL_END;
-
-    AptcaKillBitList *pKillBitList = GetKillBitList();
-
-    ConditionalAptcaCache *pDomainCache = pDomainAssembly->GetAppDomain()->GetSecurityDescriptor()->GetConditionalAptcaCache();
-    // If we have any killbitted assemblies, then we need to make sure that the current assembly and its dependencies
-    BOOL aptcaChecks = pKillBitList->AreAnyAssembliesKillBitted();
-    BOOL conditionalAptcaChecks = pDomainCache->GetConditionalAptcaDomainState() != ConditionalAptcaCache::kAllEnabled;
-    if (!aptcaChecks && !conditionalAptcaChecks)
-        return true;
-
-    //
-    // Check to see if the NGEN image itself is APTCA and killbitted
-    //
-
-    ReleaseHolder<IMDInternalImport> pAssemblyMD(pDomainAssembly->GetFile()->GetMDImportWithRef());
-    TokenSecurityDescriptorFlags assemblySecurityAttributes =
-        TokenSecurityDescriptor::ReadSecurityAttributes(pAssemblyMD, TokenFromRid(1, mdtAssembly));
-
-    if (aptcaChecks)
-    {
-        if ((assemblySecurityAttributes & TokenSecurityDescriptorFlags_APTCA) &&
-            pKillBitList->IsAssemblyKillBitted(pDomainAssembly->GetFile()))
-        {
-            return false;
-        }
-    }
-    if (conditionalAptcaChecks
-        && (assemblySecurityAttributes & TokenSecurityDescriptorFlags_ConditionalAPTCA))
-    {
-        //
-        // First check to see if we're disabled.
-        //
-
-        AssemblySpec spec;
-        spec.InitializeSpec(pDomainAssembly->GetFile());
-        ReleaseHolder<IAssemblyName> pAsmName;
-        IfFailThrow(spec.CreateFusionName(&pAsmName, FALSE));
-
-        if (!IsAssemblyOnAptcaVisibleList(pAsmName, pDomainAssembly))
-        {
-            //IsAssemblyOnAptcaVisibleList has already logged an error.
-            return false;
-        }
-    }
-
-    if (aptcaChecks || conditionalAptcaChecks)
-    {
-        //
-        // Also check its dependencies
-        //
-
-        COUNT_T dependencyCount;
-        PEImageLayout *pNativeLayout = pNativeImage->GetLoadedLayout();
-        CORCOMPILE_DEPENDENCY *pDependencies = pNativeLayout->GetNativeDependencies(&dependencyCount);
-
-        for (COUNT_T i = 0; i < dependencyCount; ++i)
-        {
-            CORCOMPILE_DEPENDENCY* pDependency = &(pDependencies[i]);
-            // Look for any dependency which is APTCA
-            if (pDependencies[i].dwAssemblyDef != mdAssemblyRefNil)
-            {
-                AssemblySpec name;
-                name.InitializeSpec(pDependency->dwAssemblyRef,
-                                    pNativeImage->GetNativeMDImport(),
-                                    NULL,
-                                    pDomainAssembly->GetFile()->IsIntrospectionOnly());
-
-                ReleaseHolder<IAssemblyName> pDependencyAssemblyName;
-                HRESULT hr = name.CreateFusionName(&pDependencyAssemblyName, FALSE);
-
-                // If we couldn't build the assemlby name up conservatively discard the image
-                if (FAILED(hr))
-                {
-                    pDomainAssembly->ExternalLog(LL_ERROR, W("Rejecting native image because could not get ")
-                                                 W("name for assemblyref 0x%x for native image dependency: ")
-                                                 W("hr=0x%x"), pDependency->dwAssemblyRef, hr);
-                    return false;
-                }
-
-                if (pDependencies[i].dependencyInfo & (CORCOMPILE_DEPENDENCY_IS_APTCA))
-                {
-                    ULARGE_INTEGER fileVersion;
-
-                    //This is a workaround for Dev10# 743602
-                    fileVersion.QuadPart = GET_UNALIGNED_VAL64(&(pDependencies[i].uliFileVersion));
-                    // If the dependency really is killbitted, then discard the image
-                    if (pKillBitList->IsAssemblyKillBitted(pDependencyAssemblyName, fileVersion))
-                    {
-                        pDomainAssembly->ExternalLog(LL_ERROR, W("Rejecting native image because dependency ")
-                                                     W("assemblyref 0x%x is killbitted."),
-                                                     pDependency->dwAssemblyRef);
-                        return false;
-                    }
-                }
-                if (pDependencies[i].dependencyInfo & (CORCOMPILE_DEPENDENCY_IS_CAPTCA))
-                {
-                    if (!IsAssemblyOnAptcaVisibleList(pDependencyAssemblyName, pDomainAssembly))
-                    {
-                        //IsAssemblyOnAptcaVisibleList has already logged an error.
-                        return false;
-                    }
-                }
-            }
-        }
-    }
-    return true;
-}
-#else // CROSSGEN_COMPILE
-namespace
-{
-    bool IsAssemblyAptcaEnabled(DomainAssembly *pDomainAssembly, TokenSecurityDescriptorFlags tokenFlags)
-    {
-        // No killbits or conditional APTCA for crossgen. Just check whether the assembly is marked APTCA.
-        return ((tokenFlags & TokenSecurityDescriptorFlags_APTCA) != TokenSecurityDescriptorFlags_None);
-    }
-}
-#endif // CROSSGEN_COMPILE
-
-//------------------------------------------------------------------------------------------------------------
-//
-// Process an assembly's real APTCA flags to determine if the assembly should be considered
-// APTCA or not
-//
-// Arguments:
-//    pDomainAssembly - Assembly to check for APTCA-ness
-//    tokenFlags      - raw metadata security bits from the assembly
-//
-// Return Value:
-//    updated token security descriptor flags which indicate the assembly's true APTCA state
-//
-
-TokenSecurityDescriptorFlags ProcessAssemblyAptcaFlags(DomainAssembly *pDomainAssembly,
-                                                       TokenSecurityDescriptorFlags tokenFlags)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pDomainAssembly));
-    }
-    CONTRACTL_END;
-
-    const TokenSecurityDescriptorFlags aptcaFlags = TokenSecurityDescriptorFlags_APTCA |
-                                                    TokenSecurityDescriptorFlags_ConditionalAPTCA;
-
-    if (IsAssemblyAptcaEnabled(pDomainAssembly, tokenFlags))
-    {
-        // The assembly is APTCA - temporarially remove all of its APTCA bits, and then add back the
-        // unconditionally APTCA bit
-        tokenFlags = tokenFlags & ~aptcaFlags;
-        return tokenFlags | TokenSecurityDescriptorFlags_APTCA;
-    }
-    else
-    {
-        // The assembly is not APTCA, so remove all of its APTCA bits from the token security descriptor
-        return tokenFlags & ~aptcaFlags;
-    }
-}
diff --git a/src/vm/aptca.h b/src/vm/aptca.h
deleted file mode 100644
index 3d590a093a..0000000000
--- a/src/vm/aptca.h
+++ /dev/null
@@ -1,110 +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.
-//--------------------------------------------------------------------------
-// aptca.h
-//
-// Functions for handling allow partially trusted callers assemblies
-//
-// This should be the only interface for talking about the APTCA-ness of an assembly, and even then should
-// be used only from very select areas of the CLR that absolutely need to know the information.  For
-// instance:
-// 
-//   * the class loader (for code sharing and formatting exception messages)
-//   * NGEN (for determining if a native image is valid)
-//   * security attribute processing code (for obvious reasons)
-//   
-// may use this interface.  Nearly every other section of the code should simply be relying on the
-// ModuleSecurityDescriptor for the assembly in question.  And no other sections of the code should be
-// directly asking questions like "is this assembly conditional APTCA" ... we explicitly want to hide that
-// information away behind the final assembly security attribute computation as much as possible.
-// 
-// In particular, no code should be making security enforcement decisions based upon conditional APTCA, and
-// instead should rely on the existing transparency / legacy APTCA enforcement.  This means that once the
-// security system, JIT, and class loader have finished setting up an assembly's APTCA attributes, there
-// should be no further questions asked about the particular APTCA attribute applied to the assembly.
-// 
-// Put another way, once an assembly is loaded, the APTCA kill bit and conditional APTCA enabled / disabled
-// decision for an assembly should evaporate away, and all assemblies should look as if they either have a
-// full APTCA attribute (in the not-killbitted / conditional APTCA enabled case) or no APTCA attribute at
-// all (killbitted or conditional APTCA disabled).
-//
-
-// 
-//--------------------------------------------------------------------------
-
-
-#ifndef __APTCA_H__
-#define __APTCA_H__
-
-#ifndef FEATURE_APTCA
-#error FEATURE_APTCA is required for this file
-#endif // FEATURE_APTCA
-
-#include "securitymeta.h"
-
-class ConditionalAptcaCache
-{
-public:
-    typedef enum
-    {
-        kUnknown,           // No cached state
-        kEnabled,           // The assembly is enabled in this domain
-        kDisabled,          // The assembly is disabled in this domain
-        kNotCAptca,         // The assembly is not conditionally APTCA
-    }
-    State;
-
-    typedef enum
-    {
-        kDomainStateUnknown,    // The domain state is not yet initialized
-        kAllEnabled,            // All assemblies in the domain are enabled
-        kSomeEnabled,           // Some assemblies in the domain are enabled
-        kAllDisabled,           // All assemblies in the domain are disabled
-    }
-    DomainState;
-
-    ConditionalAptcaCache(AppDomain *pAppDomain);
-    ~ConditionalAptcaCache();
-
-    State GetCachedState(PTR_PEImage pImage);
-    void SetCachedState(PTR_PEImage pImage, State state);
-
-    DomainState GetConditionalAptcaDomainState();
-    void SetCanonicalConditionalAptcaList(LPCWSTR wszCanonicalConditionalAptcaList);
-
-    static bool ConsiderFullTrustConditionalAptcaLists();
-
-private:
-    ConditionalAptcaCache(ConditionalAptcaCache &other); // not implemented - used to prevent compiler generating a copy constructor
-    ConditionalAptcaCache& operator=(const ConditionalAptcaCache &other); // not implemented - used to prevent compiler generating an assignment operator
-
-private:
-    AppDomain *m_pAppDomain;
-
-    bool      m_canonicalListIsNull;
-    SString   m_canonicalList;
-    DomainState m_domainState;
-};
-
-// Determine if the AppDomain can share an assembly or if APTCA restrictions prevent sharing
-bool DomainCanShareAptcaAssembly(DomainAssembly *pDomainAssembly);
-
-// Get an exception string indicating how to enable a conditional APTCA assembly if it was disabled and
-// caused an exception
-SString GetConditionalAptcaAccessExceptionContext(Assembly *pTargetAssembly);
-
-// Get an exception string indicating that 
-SString GetConditionalAptcaSharingExceptionContext(Assembly *pTargetAssembly);
-
-// Get an exception string indicating that an assembly was on the kill bit list if it caused an exception
-SString GetAptcaKillBitAccessExceptionContext(Assembly *pTargetAssembly);
-
-// Determine if a native image is OK to use from an APTCA perspective (it and its dependencies all have the
-// same APTCA-ness now as at NGEN time)
-bool NativeImageHasValidAptcaDependencies(PEImage *pNativeImage, DomainAssembly *pDomainAssembly);
-
-// Process an assembly's real APTCA flags to determine if the assembly should be considered APTCA or not
-TokenSecurityDescriptorFlags ProcessAssemblyAptcaFlags(DomainAssembly *pDomainAssembly, TokenSecurityDescriptorFlags tokenFlags);
-
-#endif // __APTCA_H__
diff --git a/src/vm/argdestination.h b/src/vm/argdestination.h
index e90217f93a..8a3fb4fdf2 100644
--- a/src/vm/argdestination.h
+++ b/src/vm/argdestination.h
@@ -201,7 +201,8 @@ public:
                     _ASSERTE(eightByteSize == 8);
                     _ASSERTE(IS_ALIGNED((SIZE_T)genRegDest, 8));
 
-                    (*fn)(dac_cast<PTR_PTR_Object>(genRegDest), sc, 0);
+                    uint32_t flags = eightByteClassification == SystemVClassificationTypeIntegerByRef ? GC_CALL_INTERIOR : 0;
+                    (*fn)(dac_cast<PTR_PTR_Object>(genRegDest), sc, flags);
                 }
 
                 genRegDest += eightByteSize;
diff --git a/src/vm/arm/stubs.cpp b/src/vm/arm/stubs.cpp
index 1309695f73..5c9e31eab5 100644
--- a/src/vm/arm/stubs.cpp
+++ b/src/vm/arm/stubs.cpp
@@ -2675,7 +2675,6 @@ void InitJITHelpers1()
     }
 
 
-#ifdef FEATURE_CORECLR
     if(IsSingleAppDomain())
     {
         SetJitHelperFunction(CORINFO_HELP_GETSHARED_GCSTATIC_BASE,          JIT_GetSharedGCStaticBase_SingleAppDomain);
@@ -2684,7 +2683,6 @@ void InitJITHelpers1()
         SetJitHelperFunction(CORINFO_HELP_GETSHARED_NONGCSTATIC_BASE_NOCTOR,JIT_GetSharedNonGCStaticBaseNoCtor_SingleAppDomain);
     }
     else
-#endif
     if (gAppDomainTLSIndex >= TLS_MINIMUM_AVAILABLE)
     {
         SetJitHelperFunction(CORINFO_HELP_GETSHARED_GCSTATIC_BASE,          JIT_GetSharedGCStaticBase_Portable);
diff --git a/src/vm/arm64/asmhelpers.S b/src/vm/arm64/asmhelpers.S
index 32eeb4edfa..d92e91cfd7 100644
--- a/src/vm/arm64/asmhelpers.S
+++ b/src/vm/arm64/asmhelpers.S
@@ -93,8 +93,8 @@ LEAF_ENTRY HelperMethodFrameRestoreState, _TEXT
     #endif
 
     // If machine state is invalid, then simply exit
-    ldr x1, [x0, #MachState__isValid]
-    cmp x1, #0
+    ldr w1, [x0, #MachState__isValid]
+    cmp w1, #0
     beq LOCAL_LABEL(Done)
 
     RestoreRegMS 19, X19
@@ -286,7 +286,7 @@ WRITE_BARRIER_END JIT_CheckedWriteBarrier
 //
 WRITE_BARRIER_ENTRY JIT_WriteBarrier
     dmb  ST
-    str  x15, [x14], 8
+    str  x15, [x14]
 
     // Branch to Exit if the reference is not in the Gen0 heap
     //
@@ -312,6 +312,7 @@ LOCAL_LABEL(UpdateCardTable):
     mov  x12, 0xFF 
     strb w12, [x15]
 LOCAL_LABEL(Exit):
+    add  x14, x14, 8
     ret  lr  
 WRITE_BARRIER_END JIT_WriteBarrier
 
diff --git a/src/vm/arm64/crthelpers.S b/src/vm/arm64/crthelpers.S
index ff0df5b898..36eb4ee7a3 100644
--- a/src/vm/arm64/crthelpers.S
+++ b/src/vm/arm64/crthelpers.S
@@ -18,7 +18,7 @@
 //
 //void JIT_MemSet(void *dst, int val, SIZE_T count)
 //
-//    uintptr_t valEx = (char)val;
+//    uintptr_t valEx = (unsigned char)val;
 //    valEx = valEx | valEx << 8;
 //    valEx = valEx | valEx << 16;
 //    valEx = valEx | valEx << 32;
@@ -52,7 +52,7 @@
 //        }
 //    }
 //
-//    while(count > 8)
+//    while(count >= 8)
 //    {
 //        *(uintptr_t*)dst = valEx;
 //        dst = (uintptr_t*)dst + 1;
@@ -85,7 +85,7 @@
 // as C++ method.
 
 LEAF_ENTRY JIT_MemSet, _TEXT
-    sxtb        w8,w1
+    uxtb        w8,w1
     sxtw        x8,w8
     orr         x8,x8,x8, lsl #8
     orr         x8,x8,x8, lsl #0x10
@@ -121,11 +121,9 @@ LOCAL_LABEL(JIT_MemSet_0x60):
     cbnz        x2,LOCAL_LABEL(JIT_MemSet_0x60)
 LOCAL_LABEL(JIT_MemSet_0x7c):
     cmp         x2,#8
-    bls         LOCAL_LABEL(JIT_MemSet_0xb8)
-    mov         x8,#-9
-    add         x8,x2,x8
-    lsr         x8,x8,#3
-    add         x11,x8,#1
+    blo         LOCAL_LABEL(JIT_MemSet_0xb8)
+    lsr         x8,x2,#3
+    mov         x11,x8
     mov         x10,x0
     add         x8,x10,x11, lsl #3
 LOCAL_LABEL(JIT_MemSet_0x9c):
@@ -188,7 +186,7 @@ LEAF_END_MARKED JIT_MemSet, _TEXT
 //        }
 //    }
 //
-//    while(count > 8)
+//    while(count >= 8)
 //    {
 //        *(uintptr_t*)dst = *(uintptr_t*)src;
 //        dst = (uintptr_t*)dst + 1;
@@ -257,11 +255,8 @@ LOCAL_LABEL(JIT_MemCpy_0x5c):
     cbnz        x2,LOCAL_LABEL(JIT_MemCpy_0x5c)
 LOCAL_LABEL(JIT_MemCpy_0x80):
     cmp         x2,#8
-    bls         LOCAL_LABEL(JIT_MemCpy_0xb4)
-    mov         x8,#-9
-    add         x8,x2,x8
-    lsr         x8,x8,#3
-    add         x9,x8,#1
+    blo         LOCAL_LABEL(JIT_MemCpy_0xb4)
+    lsr         x9,x2,#3
     mov         x8,#-8
     madd        x2,x9,x8,x2
 LOCAL_LABEL(JIT_MemCpy_0xa0):
diff --git a/src/vm/arm64/stubs.cpp b/src/vm/arm64/stubs.cpp
index 9c9b6a8a68..e526d9e36b 100644
--- a/src/vm/arm64/stubs.cpp
+++ b/src/vm/arm64/stubs.cpp
@@ -786,8 +786,6 @@ void TransitionFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
     SyncRegDisplayToCurrentContext(pRD);
     
     LOG((LF_GCROOTS, LL_INFO100000, "STACKWALK    TransitionFrame::UpdateRegDisplay(pc:%p, sp:%p)\n", pRD->ControlPC, pRD->SP));
-    
-
 }
 
 #endif
@@ -796,6 +794,7 @@ void TransitionFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
 
 void TailCallFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
 { 
+    LOG((LF_GCROOTS, LL_INFO100000, "STACKWALK    TailCallFrame::UpdateRegDisplay(pc:%p, sp:%p)\n", pRD->ControlPC, pRD->SP));
     _ASSERTE(!"ARM64:NYI");
 }
 
@@ -835,6 +834,8 @@ void FaultingExceptionFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
 
     pRD->IsCallerContextValid = FALSE;
     pRD->IsCallerSPValid      = FALSE;        // Don't add usage of this field.  This is only temporary.
+
+    LOG((LF_GCROOTS, LL_INFO100000, "STACKWALK    FaultingExceptionFrame::UpdateRegDisplay(pc:%p, sp:%p)\n", pRD->ControlPC, pRD->SP));
 }
 
 void InlinedCallFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
@@ -874,6 +875,8 @@ void InlinedCallFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
     pRD->pCurrentContext->Fp = m_pCalleeSavedFP;
     pRD->pCurrentContextPointers->Fp = &m_pCalleeSavedFP;
 
+    LOG((LF_GCROOTS, LL_INFO100000, "STACKWALK    InlinedCallFrame::UpdateRegDisplay(pc:%p, sp:%p)\n", pRD->ControlPC, pRD->SP));
+
     RETURN;
 }
 
@@ -919,6 +922,8 @@ void ResumableFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
     pRD->IsCallerContextValid = FALSE;
     pRD->IsCallerSPValid      = FALSE;        // Don't add usage of this field.  This is only temporary.
     
+    LOG((LF_GCROOTS, LL_INFO100000, "STACKWALK    ResumableFrame::UpdateRegDisplay(pc:%p, sp:%p)\n", pRD->ControlPC, pRD->SP));
+
     RETURN;
 }
 
@@ -965,6 +970,8 @@ void HijackFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
      pRD->pCurrentContextPointers->Lr = NULL;
 
      SyncRegDisplayToCurrentContext(pRD);
+
+    LOG((LF_GCROOTS, LL_INFO100000, "STACKWALK    HijackFrame::UpdateRegDisplay(pc:%p, sp:%p)\n", pRD->ControlPC, pRD->SP));
 }
 #endif // FEATURE_HIJACK
 
diff --git a/src/vm/assembly.cpp b/src/vm/assembly.cpp
index b3e7611205..fc9ce7189c 100644
--- a/src/vm/assembly.cpp
+++ b/src/vm/assembly.cpp
@@ -22,16 +22,7 @@
 #include "perfcounters.h"
 #include "assemblyname.hpp"
 
-#ifdef FEATURE_FUSION
-#include "fusion.h"
-#include "assemblysink.h"
-#include "ngenoptout.h"
-#endif
 
-#if !defined(FEATURE_CORECLR) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
-#include "assemblyusagelogmanager.h"
-#include "policy.h"
-#endif
 
 #include "eeprofinterfaces.h"
 #include "reflectclasswriter.h"
@@ -55,22 +46,16 @@
 #include "appdomainnative.hpp"
 #ifdef FEATURE_REMOTING
 #include "remoting.h"
-#include "appdomainhelper.h"
 #endif
 #include "customattribute.h"
 #include "winnls.h"
 
-#include "constrainedexecutionregion.h"
 #include "caparser.h"
 #include "../md/compiler/custattr.h"
 #include "mdaassistants.h"
 
 #include "peimagelayout.inl"
 
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-#include <shlobj.h>
-#include "eventmsg.h"
-#endif
 
 #ifdef FEATURE_TRACELOGGING
 #include "clrtracelogging.h"
@@ -161,9 +146,6 @@ Assembly::Assembly(BaseDomain *pDomain, PEAssembly* pFile, DebuggerAssemblyContr
     m_fIsDomainNeutral(pDomain == SharedDomain::GetDomain()),
 #ifdef FEATURE_LOADER_OPTIMIZATION
     m_bMissingDependenciesCheckDone(FALSE),
-#ifdef FEATURE_FUSION
-    m_pBindingClosure(NULL),
-#endif
 #endif // FEATURE_LOADER_OPTIMIZATION
     m_debuggerFlags(debuggerFlags),
     m_fTerminated(FALSE),
@@ -171,9 +153,6 @@ Assembly::Assembly(BaseDomain *pDomain, PEAssembly* pFile, DebuggerAssemblyContr
 #ifdef FEATURE_COMINTEROP
     , m_InteropAttributeStatus(INTEROP_ATTRIBUTE_UNSET)
 #endif
-#ifndef FEATURE_CORECLR
-    , m_fSupportsAutoNGen(FALSE)
-#endif
 {
     STANDARD_VM_CONTRACT;
 }
@@ -285,13 +264,6 @@ void Assembly::Init(AllocMemTracker *pamTracker, LoaderAllocator *pLoaderAllocat
     if (!m_pManifest->IsReadyToRun())
         CacheManifestExportedTypes(pamTracker);
 
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-    GenerateBreadcrumbForServicing();
-
-    m_fSupportsAutoNGen = SupportsAutoNGenWorker();
-
-    ReportAssemblyUse();
-#endif
 
 #ifdef FEATURE_TRACELOGGING
 
@@ -384,12 +356,6 @@ Assembly::~Assembly()
     if (m_pAllowedFiles)
         delete(m_pAllowedFiles);
 #endif 
-#ifdef FEATURE_FUSION
-    if (m_pBindingClosure) 
-    {
-        m_pBindingClosure->Release();
-    }
-#endif
     if (IsDynamic()) {
         if (m_pOnDiskManifest)
             // clear the on disk manifest if it is not cleared yet.
@@ -757,7 +723,6 @@ Assembly *Assembly::CreateDynamic(AppDomain *pDomain, CreateDynamicAssemblyArgs
                                                    &ma));
         pFile = PEAssembly::Create(pCallerAssembly->GetManifestFile(), pAssemblyEmit, args->access & ASSEMBLY_ACCESS_REFLECTION_ONLY);
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
         // Dynamically created modules (aka RefEmit assemblies) do not have a LoadContext associated with them since they are not bound
         // using an actual binder. As a result, we will assume the same binding/loadcontext information for the dynamic assembly as its
         // caller/creator to ensure that any assembly loads triggered by the dynamic assembly are resolved using the intended load context.
@@ -803,90 +768,21 @@ Assembly *Assembly::CreateDynamic(AppDomain *pDomain, CreateDynamicAssemblyArgs
 
         // Set it as the fallback load context binder for the dynamic assembly being created
         pFile->SetFallbackLoadContextBinder(pFallbackLoadContextBinder);
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
     }            
     
     AssemblyLoadSecurity loadSecurity;
-#ifndef FEATURE_CORECLR
-    DWORD dwSpecialFlags = 0xFFFFFFFF;
-    
-    // Don't bother with setting up permissions if this isn't allowed to run
-    // This doesn't apply in CoreCLR because you cannot specify evidence when creating a dynamic assembly
-    if ((args->identity != NULL) &&
-        (args->access & ASSEMBLY_ACCESS_RUN))
-    {
-        loadSecurity.m_pAdditionalEvidence = &args->identity;
-    }
-    else
-    {
-        if (pCallerAssembly != NULL) // can be null if caller is interop
-        {
-            if (args->securityContextSource == kCurrentAssembly)
-            {
-                IAssemblySecurityDescriptor *pCallerSecDesc = pCallerAssembly->GetSecurityDescriptor(pCallersDomain);
-                gc.granted = pCallerSecDesc->GetGrantedPermissionSet(&(gc.denied));
-                dwSpecialFlags = pCallerSecDesc->GetSpecialFlags();
-            }
-            else
-            {
-                IApplicationSecurityDescriptor *pCallersDomainSecDesc = pCallersDomain->GetSecurityDescriptor();
-
-#ifdef FEATURE_CAS_POLICY
-                // We only want to propigate the identity of homogenous domains, since heterogenous domains tend
-                // to be fully trusted even if they are housing partially trusted code - which could lead to an
-                // elevation of privilege if we allow the grant set to be pushed to assemblies partially trusted
-                // code is loading.
-                if (!pCallersDomainSecDesc->IsHomogeneous())
-                {
-                    COMPlusThrow(kNotSupportedException, W("NotSupported_SecurityContextSourceAppDomainInHeterogenous"));
-                }
-#endif // FEATURE_CAS_POLICY
-
-                gc.granted = pCallersDomainSecDesc->GetGrantedPermissionSet();
-                dwSpecialFlags = pCallersDomainSecDesc->GetSpecialFlags();
-            }
-
-            // Caller may be in another appdomain context, in which case we'll
-            // need to marshal/unmarshal the grant and deny sets across.
-#ifdef FEATURE_REMOTING  // should not happen without remoting              
-            if (pCallersDomain != ::GetAppDomain())
-            {
-                gc.granted = AppDomainHelper::CrossContextCopyFrom(pCallersDomain->GetId(), &(gc.granted));
-                if (gc.denied != NULL)
-                {
-                    gc.denied = AppDomainHelper::CrossContextCopyFrom(pCallersDomain->GetId(), &(gc.denied));
-                }
-            }
-#else // !FEATURE_REMOTING
-            _ASSERTE(pCallersDomain == ::GetAppDomain());
-#endif // FEATURE_REMOTING
-        }
-    }
-#else // FEATURE_CORECLR
     // In SilverLight all dynamic assemblies should be transparent and partially trusted, even if they are
     // created by platform assemblies. Thus they should inherit the grant sets from the appdomain not the 
     // parent assembly.
     IApplicationSecurityDescriptor *pCurrentDomainSecDesc = ::GetAppDomain()->GetSecurityDescriptor();
     gc.granted = pCurrentDomainSecDesc->GetGrantedPermissionSet();
     DWORD dwSpecialFlags = pCurrentDomainSecDesc->GetSpecialFlags();
-#endif // !FEATURE_CORECLR
 
     // If the dynamic assembly creator did not specify evidence for the newly created assembly, then it
     // should inherit the grant set of the creation assembly.
     if (loadSecurity.m_pAdditionalEvidence == NULL)
     {   
-#ifdef FEATURE_CAS_POLICY
-        // If we're going to inherit the grant set of an anonymously hosted dynamic method, it will be
-        // full trust/transparent. In that case, we should demand full trust.
-        if(args->securityContextSource == kCurrentAssembly &&
-            pCallerAssembly != NULL &&
-            pCallersDomain != NULL &&
-            pCallerAssembly->GetDomainAssembly(pCallersDomain) == pCallersDomain->GetAnonymouslyHostedDynamicMethodsAssembly())
-        {
-            loadSecurity.m_fPropagatingAnonymouslyHostedDynamicMethodGrant = true;
-        }
-#endif // FEATURE_CAS_POLICY
 
         loadSecurity.m_pGrantSet = &gc.granted;
         loadSecurity.m_pRefusedSet = &gc.denied;
@@ -924,23 +820,6 @@ Assembly *Assembly::CreateDynamic(AppDomain *pDomain, CreateDynamicAssemblyArgs
     }
 
     // Start loading process
-
-#ifdef FEATURE_CAS_POLICY
-    // Get the security descriptor for the assembly.
-    IAssemblySecurityDescriptor *pSecDesc = pDomainAssembly->GetSecurityDescriptor();
-
-    // Propagate identity and permission request information into the assembly's
-    // security descriptor. Then when policy is resolved we'll end up with the
-    // correct grant set.
-    // If identity has not been provided then the caller's assembly will be
-    // calculated instead and we'll just copy the granted permissions from the
-    // caller to the new assembly and mark policy as resolved (done
-    // automatically by SetGrantedPermissionSet).
-    pSecDesc->SetRequestedPermissionSet(args->requiredPset,
-                                        args->optionalPset,
-                                        args->refusedPset);
-#endif // FEATURE_CAS_POLICY
-
     {
         // Create a concrete assembly
         // (!Do not remove scoping brace: order is important here: the Assembly holder must destruct before the AllocMemTracker!)
@@ -967,33 +846,11 @@ Assembly *Assembly::CreateDynamic(AppDomain *pDomain, CreateDynamicAssemblyArgs
 
         pAssem->m_dwDynamicAssemblyAccess = args->access;
 
-#ifdef FEATURE_CAS_POLICY
-        // If a legacy assembly is emitting an assembly, then we implicitly add the legacy attribute. If the legacy
-        // assembly is also in partial trust, we implicitly make the emitted assembly transparent.
-        ModuleSecurityDescriptor *pEmittingMSD = ModuleSecurityDescriptor::GetModuleSecurityDescriptor(pCallerAssembly);
-        if (pEmittingMSD->GetSecurityRuleSet() == SecurityRuleSet_Level1)
-        {
-            IAssemblySecurityDescriptor *pCallerSecDesc = pCallerAssembly->GetSecurityDescriptor(pCallersDomain);
-            if (!pCallerSecDesc->IsFullyTrusted())
-            {
-                args->flags = kTransparentAssembly;
-            }
-        }
-
-        // If the code emitting the dynamic assembly is transparent and it is attempting to emit a non-transparent
-        // assembly, then we need to do a demand for the grant set of the emitting assembly (which should also be
-        // is the grant set of the dynamic assembly).
-        if (Security::IsMethodTransparent(pmdEmitter) && !(args->flags & kTransparentAssembly))
-        {
-            Security::DemandGrantSet(pCallerAssembly->GetSecurityDescriptor(pCallersDomain));
-        }
-#else // FEATURE_CORECLR
         // Making the dynamic assembly opportunistically critical in full trust CoreCLR and transparent otherwise.
         if (!GetAppDomain()->GetSecurityDescriptor()->IsFullyTrusted())
         {
             args->flags = kTransparentAssembly;
         }
-#endif //!FEATURE_CORECLR
 
         // Fake up a module security descriptor for the assembly.
         TokenSecurityDescriptorFlags tokenFlags = TokenSecurityDescriptorFlags_None;
@@ -1008,42 +865,7 @@ Assembly *Assembly::CreateDynamic(AppDomain *pDomain, CreateDynamicAssemblyArgs
         if (args->flags & kTreatAsSafeAssembly)
             tokenFlags |= TokenSecurityDescriptorFlags_TreatAsSafe;
 
-#ifdef FEATURE_APTCA
-        if (args->aptcaBlob != NULL)
-        {
-            tokenFlags |= ParseAptcaAttribute(args->aptcaBlob->GetDirectPointerToNonObjectElements(),
-                                              args->aptcaBlob->GetNumComponents());
-        }
 
-#endif // FEATURE_APTCA
-
-#ifndef FEATURE_CORECLR
-        // Use the security rules given to us if the emitting code has selected a specific one. Otherwise,
-        // inherit the security rules of the emitting assembly.
-        if (args->securityRulesBlob != NULL)
-        {
-            tokenFlags |= ParseSecurityRulesAttribute(args->securityRulesBlob->GetDirectPointerToNonObjectElements(),
-                                                      args->securityRulesBlob->GetNumComponents());
-        }
-        else
-        {
-            // Ensure that dynamic assemblies created by mscorlib always specify a rule set, since we want to
-            // make sure that creating a level 2 assembly was an explicit decision by the emitting code,
-            // rather than an implicit decision because mscorlib is level 2 itself.
-            //
-            // If you're seeing this assert, it means that you've created a dynamic assembly from mscorlib,
-            // but did not pass a CustomAttributeBuilder for the SecurityRulesAttribute to the 
-            // DefineDynamicAssembly call.
-           _ASSERTE(!pCallerAssembly->IsSystem());
-
-            // Use the creating assembly's security rule set for the emitted assembly
-            SecurityRuleSet callerRuleSet = 
-                ModuleSecurityDescriptor::GetModuleSecurityDescriptor(pCallerAssembly)->GetSecurityRuleSet();
-            tokenFlags |= EncodeSecurityRuleSet(callerRuleSet);
-
-            tokenFlags |= TokenSecurityDescriptorFlags_SecurityRules;
-        }
-#endif // !FEATURE_CORECLR
 
         _ASSERTE(pAssem->GetManifestModule()->m_pModuleSecurityDescriptor != NULL);
         pAssem->GetManifestModule()->m_pModuleSecurityDescriptor->OverrideTokenFlags(tokenFlags); 
@@ -1055,47 +877,6 @@ Assembly *Assembly::CreateDynamic(AppDomain *pDomain, CreateDynamicAssemblyArgs
         if (publicKey.GetSize() > 0)
         {
             pAssem->SetStrongNameLevel(Assembly::SN_PUBLIC_KEY);
-#ifndef FEATURE_CORECLR
-            gc.strongNameKeyPair = args->assemblyName->GetStrongNameKeyPair();
-            // If there's a public key, there might be a strong name key pair.
-            if (gc.strongNameKeyPair != NULL) 
-            {
-                MethodDescCallSite getKeyPair(METHOD__STRONG_NAME_KEY_PAIR__GET_KEY_PAIR, &gc.strongNameKeyPair);
-
-                ARG_SLOT arglist[] = 
-                {
-                    ObjToArgSlot(gc.strongNameKeyPair),
-                    PtrToArgSlot(&gc.orArrayOrContainer)
-                };
-
-                BOOL bKeyInArray;
-                bKeyInArray = (BOOL)getKeyPair.Call_RetBool(arglist);
-
-                if (bKeyInArray)
-                {
-                    U1ARRAYREF orArray = (U1ARRAYREF)gc.orArrayOrContainer;
-                    pAssem->m_cbStrongNameKeyPair = orArray->GetNumComponents();
-                    pAssem->m_pbStrongNameKeyPair = new BYTE[pAssem->m_cbStrongNameKeyPair];
-
-                    pAssem->m_FreeFlag |= pAssem->FREE_KEY_PAIR;
-                    memcpy(pAssem->m_pbStrongNameKeyPair, orArray->GetDataPtr(), pAssem->m_cbStrongNameKeyPair);
-                    pAssem->SetStrongNameLevel(Assembly::SN_FULL_KEYPAIR_IN_ARRAY);
-                }
-                else
-                {
-                    STRINGREF orContainer = (STRINGREF)gc.orArrayOrContainer;
-                    DWORD cchContainer = orContainer->GetStringLength();
-                    pAssem->m_pwStrongNameKeyContainer = new WCHAR[cchContainer + 1];
-
-                    pAssem->m_FreeFlag |= pAssem->FREE_KEY_CONTAINER;
-                    memcpy(pAssem->m_pwStrongNameKeyContainer, orContainer->GetBuffer(), cchContainer * sizeof(WCHAR));
-                    pAssem->m_pwStrongNameKeyContainer[cchContainer] = W('\0');
-
-                    pAssem->SetStrongNameLevel(Assembly::SN_FULL_KEYPAIR_IN_CONTAINER);
-                }
-            }
-            else
-#endif // FEATURE_CORECLR
             {
                 // Since we have no way to validate the public key of a dynamic assembly we don't allow 
                 // partial trust code to emit a dynamic assembly with an arbitrary public key.
@@ -1789,11 +1570,6 @@ Module * Assembly::FindModuleByTypeRef(
                 RETURN NULL;
             }
 
-#ifndef FEATURE_CORECLR
-            // Event Tracing for Windows is used to log data for performance and functional testing purposes.
-            // The events below are used to help measure the performance of assembly loading of a static reference.
-            FireEtwLoaderPhaseStart((::GetAppDomain() ? ::GetAppDomain()->GetId().m_dwId : ETWAppDomainIdNotAvailable), ETWLoadContextNotAvailable, ETWFieldUnused, ETWLoaderStaticLoad, NULL, NULL, GetClrInstanceId());
-#endif //!FEATURE_CORECLR
             
             DomainAssembly * pDomainAssembly = pModule->LoadAssembly(
                     ::GetAppDomain(), 
@@ -1801,27 +1577,6 @@ Module * Assembly::FindModuleByTypeRef(
                     szNamespace, 
                     szClassName);
 
-#ifndef FEATURE_CORECLR
-            if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context, TRACE_LEVEL_INFORMATION, CLR_PRIVATEBINDING_KEYWORD))
-            {
-                StackSString assemblySimpleName;
-                EX_TRY
-                {
-                    if ((pDomainAssembly != NULL) && (pDomainAssembly->GetCurrentAssembly() != NULL))
-                    {
-                        assemblySimpleName.AppendUTF8(pDomainAssembly->GetCurrentAssembly()->GetSimpleName());
-                        assemblySimpleName.Normalize(); // Ensures that the later cast to LPCWSTR does not throw.
-                    }
-                }
-                EX_CATCH
-                {
-                    assemblySimpleName.Clear();
-                }
-                EX_END_CATCH(RethrowTransientExceptions)
-                
-                FireEtwLoaderPhaseEnd(::GetAppDomain() ? ::GetAppDomain()->GetId().m_dwId : ETWAppDomainIdNotAvailable, ETWLoadContextNotAvailable, ETWFieldUnused, ETWLoaderStaticLoad, NULL, assemblySimpleName.IsEmpty() ? NULL : (LPCWSTR)assemblySimpleName, GetClrInstanceId());
-            }
-#endif //!FEATURE_CORECLR
 
             if (pDomainAssembly == NULL)
                 RETURN NULL;
@@ -2564,20 +2319,7 @@ HRESULT RunMain(MethodDesc *pFD ,
 
     if ((EntryType == EntryManagedMain) &&
         (stringArgs == NULL)) {
- #ifndef FEATURE_CORECLR
-       // If you look at the DIFF on this code then you will see a major change which is that we
-        // no longer accept all the different types of data arguments to main.  We now only accept
-        // an array of strings.
-
-        wzArgs = CorCommandLine::GetArgvW(&cCommandArgs);
-        // In the WindowsCE case where the app has additional args the count will come back zero.
-        if (cCommandArgs > 0) {
-            if (!wzArgs)
-                return E_INVALIDARG;
-        }
-#else // !FEATURE_CORECLR
         return E_INVALIDARG;
-#endif // !FEATURE_CORECLR
     }
 
     ETWFireEvent(Main_V1);
@@ -2728,37 +2470,12 @@ INT32 Assembly::ExecuteMainMethod(PTRARRAYREF *stringArgs, BOOL waitForOtherThre
         if (pMeth) {
             RunMainPre();
 
-#if defined(FEATURE_APPX_BINDER) && defined(FEATURE_MULTICOREJIT)
-            if (AppX::IsAppXProcess())
-            {
-                GCX_PREEMP();
-                
-                // we call this to obtain and cache the PRAID value which is used
-                // by multicore JIT manager and watson bucket params generation.
-
-                // NOTE: this makes a COM call into WinRT so we must do this after we've
-                //       set the thread's apartment state which will do CoInitializeEx().
-                LPCWSTR praid;
-                hr = AppX::GetApplicationId(praid);
-                _ASSERTE(SUCCEEDED(hr));
-
-                if (!pMeth->GetModule()->HasNativeImage())
-                {
-                    // For Appx, multicore JIT is only needed when root assembly does not have NI image
-                    // When it has NI image, we can't generate profile, and do not need to playback profile
-                    AppDomain * pDomain = pThread->GetDomain();
-                    pDomain->GetMulticoreJitManager().AutoStartProfileAppx(pDomain);
-                }
-            }
-#endif // FEATURE_APPX_BINDER && FEATURE_MULTICOREJIT
             
-#ifdef FEATURE_CORECLR
             // Set the root assembly as the assembly that is containing the main method
             // The root assembly is used in the GetEntryAssembly method that on CoreCLR is used
             // to get the TargetFrameworkMoniker for the app
             AppDomain * pDomain = pThread->GetDomain();
             pDomain->SetRootAssembly(pMeth->GetAssembly());
-#endif
             hr = RunMain(pMeth, 1, &iRetVal, stringArgs);
         }
     }
@@ -2942,20 +2659,6 @@ PEModule * Assembly::LoadModule_AddRef(mdFile kFile, BOOL fLoadResource)
         {
             GCX_PREEMP();
 
-#ifdef FEATURE_FUSION    // specific to remote modules
-            if (GetFusionAssembly()) {
-                StackSString path;
-                ::GetAppDomain()->GetFileFromFusion(GetFusionAssembly(),
-                                                  (LPCWSTR)name, path);
-                pModule = PEModule::Open(m_pManifestFile, kFile, path);
-                goto lDone;
-            }
-            
-            if (GetIHostAssembly()) {
-                pModule = PEModule::Open(m_pManifestFile, kFile, name);
-                goto lDone;
-            }
-#endif
             if (!m_pManifestFile->GetPath().IsEmpty()) {
                 StackSString path = m_pManifestFile->GetPath();
                 
@@ -2967,9 +2670,6 @@ PEModule * Assembly::LoadModule_AddRef(mdFile kFile, BOOL fLoadResource)
                 }
                 pModule = PEModule::Open(m_pManifestFile, kFile, path);
             }
-#ifdef FEATURE_FUSION        
-        lDone: ;
-#endif
         }
         EX_CATCH
         {
@@ -3190,24 +2890,13 @@ mdAssemblyRef Assembly::AddAssemblyRef(Assembly *refedAssembly, IMetaDataAssembl
         GC_TRIGGERS;
         INJECT_FAULT(COMPlusThrowOM(););
         PRECONDITION(CheckPointer(refedAssembly));
-#ifdef FEATURE_CORECLR
         PRECONDITION(CheckPointer(pAssemEmitter, NULL_NOT_OK));
-#else
-        PRECONDITION(CheckPointer(pAssemEmitter, NULL_OK));
-#endif //FEATURE_CORECLR
         POSTCONDITION(!IsNilToken(RETVAL));
         POSTCONDITION(TypeFromToken(RETVAL) == mdtAssemblyRef);
     }
     CONTRACT_END;
 
     SafeComHolder<IMetaDataAssemblyEmit> emitHolder;
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-    if (pAssemEmitter == NULL)
-    {
-        pAssemEmitter = GetOnDiskMDAssemblyEmitter();
-        emitHolder.Assign(pAssemEmitter);
-    }
-#endif // FEATURE_CORECLR && !CROSSGEN_COMPILE
 
     AssemblySpec spec;
     spec.InitializeSpec(refedAssembly->GetManifestFile());
@@ -3275,476 +2964,6 @@ void Assembly::AddExportedType(mdExportedType cl)
 }
 
 
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-
-//***********************************************************
-//
-// get the IMetaDataAssemblyEmit for the on disk manifest.
-// Note that the pointer returned is AddRefed. It is the caller's
-// responsibility to release the reference.
-//
-//***********************************************************
-IMetaDataAssemblyEmit *Assembly::GetOnDiskMDAssemblyEmitter()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END
-
-    IMetaDataAssemblyEmit *pAssemEmitter = NULL;
-    IMetaDataEmit   *pEmitter;
-    RefClassWriter  *pRCW;
-
-    _ASSERTE(m_pOnDiskManifest);
-
-    pRCW = m_pOnDiskManifest->GetClassWriter();
-    _ASSERTE(pRCW);
-
-    // If the RefClassWriter has a on disk emitter, then use it rather than the in-memory emitter.
-    pEmitter = pRCW->GetOnDiskEmitter();
-
-    if (pEmitter == NULL)
-        pEmitter = m_pOnDiskManifest->GetEmitter();
-    
-    _ASSERTE(pEmitter != NULL);
-    
-    IfFailThrow(pEmitter->QueryInterface(IID_IMetaDataAssemblyEmit, (void**) &pAssemEmitter));
-    
-    if (pAssemEmitter == NULL)
-    {
-        // the manifest is not writable
-        _ASSERTE(!"Bad usage!");
-    }
-    return pAssemEmitter;
-}
-
-//***********************************************************
-//
-// prepare saving manifest to disk.
-//
-//***********************************************************
-void Assembly::PrepareSavingManifest(ReflectionModule *pAssemblyModule)
-{
-    STANDARD_VM_CONTRACT;
-
-    if (pAssemblyModule)
-    {
-        // embedded assembly
-        m_pOnDiskManifest = pAssemblyModule;
-        m_fEmbeddedManifest = true;
-    }
-    else
-    {
-        m_fEmbeddedManifest = false;
-
-        StackSString name(SString::Utf8, GetSimpleName());
-
-        // Create the module
-        m_pOnDiskManifest = CreateDynamicModule(name, name, FALSE /*fIsTransient*/);
-        // store the fact this on disk manifest is temporary and can be hidden from the user
-        m_needsToHideManifestForEmit = TRUE;
-    }
-
-    NonVMComHolder<IMetaDataAssemblyEmit> pAssemblyEmit(GetOnDiskMDAssemblyEmitter());
-
-    // Copy assembly metadata to emit scope
-    //<TODO>@todo: add Title, Description, Alias as CA</TODO>
-    // <TODO>@todo: propagate all of the information</TODO>
-    // <TODO>@todo: introduce a helper in metadata to take the ansi version of string.</TODO>
-
-    IMetaDataAssemblyImport *pAssemblyImport = GetManifestFile()->GetAssemblyImporter();
-
-    const void          *pbPublicKey;
-    ULONG               cbPublicKey;
-    ULONG               ulHashAlgId;
-    LPWSTR              szName;
-    ULONG               chName;
-    ASSEMBLYMETADATA    MetaData;
-    DWORD               dwAssemblyFlags;
-
-    MetaData.cbLocale = 0;
-    MetaData.ulProcessor = 0;
-    MetaData.ulOS = 0;
-    IfFailThrow(pAssemblyImport->GetAssemblyProps(TokenFromRid(1, mdtAssembly),
-                                                  NULL, NULL, NULL,
-                                                  NULL, 0, &chName,
-                                                  &MetaData, NULL));
-    StackSString name;
-    szName = name.OpenUnicodeBuffer(chName);
-
-    SString locale;
-    MetaData.szLocale = locale.OpenUnicodeBuffer(MetaData.cbLocale);
-
-    SBuffer proc;
-    MetaData.rProcessor = (DWORD *) proc.OpenRawBuffer(MetaData.ulProcessor*sizeof(*MetaData.rProcessor));
-
-    SBuffer os;
-    MetaData.rOS = (OSINFO *) os.OpenRawBuffer(MetaData.ulOS*sizeof(*MetaData.rOS));
-
-    IfFailThrow(pAssemblyImport->GetAssemblyProps(TokenFromRid(1, mdtAssembly),
-                                                  &pbPublicKey, &cbPublicKey, &ulHashAlgId,
-                                                  szName, chName, &chName,
-                                                  &MetaData, &dwAssemblyFlags));
-
-    mdAssembly ad;
-    IfFailThrow(pAssemblyEmit->DefineAssembly(pbPublicKey, cbPublicKey, ulHashAlgId,
-                                              szName, &MetaData, dwAssemblyFlags, &ad));
-
-    SafeComHolder<IMetaDataImport> pImport;
-    IfFailThrow(pAssemblyEmit->QueryInterface(IID_IMetaDataImport, (void**)&pImport));
-    ULONG cExistingName = 0;
-    if (FAILED(pImport->GetScopeProps(NULL, 0, &cExistingName, NULL)) || cExistingName == 0)
-    {
-        SafeComHolder<IMetaDataEmit> pEmit;
-        IfFailThrow(pAssemblyEmit->QueryInterface(IID_IMetaDataEmit, (void**)&pEmit));
-        IfFailThrow(pEmit->SetModuleProps(szName));
-    }
-
-    name.CloseBuffer();
-    locale.CloseBuffer();
-    proc.CloseRawBuffer();
-    os.CloseRawBuffer();
-}   // Assembly::PrepareSavingManifest
-
-
-//***********************************************************
-//
-// add a file name to the file list of this assembly. On disk only.
-//
-//***********************************************************
-mdFile Assembly::AddFile(LPCWSTR wszFileName)
-{
-    STANDARD_VM_CONTRACT;
-
-    SafeComHolder<IMetaDataAssemblyEmit> pAssemEmitter(GetOnDiskMDAssemblyEmitter());
-    mdFile          fl;
-
-    // Define File.
-    IfFailThrow( pAssemEmitter->DefineFile(
-        wszFileName,                // [IN] Name of the file.
-        0,                          // [IN] Hash Blob.
-        0,                          // [IN] Count of bytes in the Hash Blob.
-        0,                          // [IN] Flags.
-        &fl) );                     // [OUT] Returned File token.
-
-    return fl;
-}   // Assembly::AddFile
-
-
-//***********************************************************
-//
-// Set the hash value on a file table entry.
-//
-//***********************************************************
-void Assembly::SetFileHashValue(mdFile tkFile, LPCWSTR wszFullFileName)
-{
-    STANDARD_VM_CONTRACT;
-
-    SafeComHolder<IMetaDataAssemblyEmit> pAssemEmitter(GetOnDiskMDAssemblyEmitter());
-
-    // Get the hash value.
-    SBuffer buffer;
-    PEImageHolder map(PEImage::OpenImage(StackSString(wszFullFileName)));
-    map->ComputeHash(GetHashAlgId(), buffer);
-
-    // Set the hash blob.
-    IfFailThrow( pAssemEmitter->SetFileProps(
-        tkFile,                 // [IN] File Token.
-        buffer,                 // [IN] Hash Blob.
-        buffer.GetSize(),       // [IN] Count of bytes in the Hash Blob.
-        (DWORD) -1));           // [IN] Flags.
-
-}   // Assembly::SetHashValue
-
-//*****************************************************************************
-// Add a Type name to the ExportedType table in the on-disk assembly manifest.
-//*****************************************************************************
-mdExportedType Assembly::AddExportedTypeOnDisk(LPCWSTR wszExportedType, mdToken tkImpl, mdToken tkTypeDef, CorTypeAttr flags)
-{
-    STANDARD_VM_CONTRACT;
-
-    _ASSERTE(TypeFromToken(tkTypeDef) == mdtTypeDef);
-
-    // The on-disk assembly manifest
-    SafeComHolder<IMetaDataAssemblyEmit> pAssemEmitter(GetOnDiskMDAssemblyEmitter());
-
-    mdExportedType ct;
-
-    IfFailThrow( pAssemEmitter->DefineExportedType(
-        wszExportedType,            // [IN] Name of the COMType.
-        tkImpl,                     // [IN] mdFile or mdAssemblyRef that provides the ExportedType.
-        tkTypeDef,                  // [IN] TypeDef token within the file.
-        flags,                      // [IN] Flags.
-        &ct) );                     // [OUT] Returned ExportedType token.
-
-    return ct;
-} // Assembly::AddExportedTypeOnDisk
-
-//*******************************************************************************
-// Add a Type name to the ExportedType table in the in-memory assembly manifest.
-//*******************************************************************************
-mdExportedType Assembly::AddExportedTypeInMemory(LPCWSTR wszExportedType, mdToken tkImpl, mdToken tkTypeDef, CorTypeAttr flags)
-{
-    STANDARD_VM_CONTRACT;
-
-    _ASSERTE(TypeFromToken(tkTypeDef) == mdtTypeDef);
-
-    // The in-memory assembly manifest
-    IMetaDataAssemblyEmit* pAssemEmitter = GetManifestFile()->GetAssemblyEmitter();
-
-    mdExportedType ct;
-
-    IfFailThrow( pAssemEmitter->DefineExportedType(
-        wszExportedType,            // [IN] Name of the COMType.
-        tkImpl,                     // [IN] mdFile or mdAssemblyRef that provides the ExportedType.
-        tkTypeDef,                  // [IN] TypeDef token within the file.
-        flags,                      // [IN] Flags.
-        &ct) );                     // [OUT] Returned ExportedType token.
-
-    return ct;
-} // Assembly::AddExportedTypeInMemory
-
-
-//***********************************************************
-// add an entry to ManifestResource table for a stand alone managed resource. On disk only.
-//***********************************************************
-void Assembly::AddStandAloneResource(LPCWSTR wszName, LPCWSTR wszDescription, LPCWSTR wszMimeType, LPCWSTR wszFileName, LPCWSTR wszFullFileName, int iAttribute)
-{
-    STANDARD_VM_CONTRACT;
-
-    SafeComHolder<IMetaDataAssemblyEmit> pAssemEmitter(GetOnDiskMDAssemblyEmitter());
-    mdFile          tkFile;
-    mdManifestResource mr;
-    SBuffer         hash;
-
-    // Get the hash value;
-    if (GetHashAlgId())
-    {
-        PEImageHolder pImage(PEImage::OpenImage(StackSString(wszFullFileName)));
-        pImage->ComputeHash(GetHashAlgId(), hash);
-    }
-
-    IfFailThrow( pAssemEmitter->DefineFile(
-        wszFileName,            // [IN] Name of the file.
-        hash,                   // [IN] Hash Blob.
-        hash.GetSize(),         // [IN] Count of bytes in the Hash Blob.
-        ffContainsNoMetaData,   // [IN] Flags.
-        &tkFile) );             // [OUT] Returned File token.
-
-
-    IfFailThrow( pAssemEmitter->DefineManifestResource(
-        wszName,                // [IN] Name of the resource.
-        tkFile,                 // [IN] mdFile or mdAssemblyRef that provides the resource.
-        0,                      // [IN] Offset to the beginning of the resource within the file.
-        iAttribute,             // [IN] Flags.
-        &mr) );                 // [OUT] Returned ManifestResource token.
-
-}   // Assembly::AddStandAloneResource
-
-
-//***********************************************************
-// Save security permission requests.
-//***********************************************************
-void Assembly::AddDeclarativeSecurity(DWORD dwAction, void const *pValue, DWORD cbValue)
-{
-    STANDARD_VM_CONTRACT;
-
-    mdAssembly tkAssembly = 0x20000001;
-
-    SafeComHolder<IMetaDataAssemblyEmit> pAssemEmitter(GetOnDiskMDAssemblyEmitter());
-    _ASSERTE( pAssemEmitter );
-
-    SafeComHolder<IMetaDataEmitHelper> pEmitHelper;
-    IfFailThrow( pAssemEmitter->QueryInterface(IID_IMetaDataEmitHelper, (void**)&pEmitHelper) );
-
-    IfFailThrow(pEmitHelper->AddDeclarativeSecurityHelper(tkAssembly,
-                                                          dwAction,
-                                                          pValue,
-                                                          cbValue,
-                                                          NULL));
-}
-
-
-//***********************************************************
-// Allocate space for a strong name signature in the manifest
-//***********************************************************
-HRESULT Assembly::AllocateStrongNameSignature(ICeeFileGen  *pCeeFileGen,
-                                              HCEEFILE      ceeFile)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_PREEMPTIVE;
-        INJECT_FAULT(return E_OUTOFMEMORY;);
-    }
-    CONTRACTL_END
-    
-    HRESULT     hr;
-    HCEESECTION TData;
-    DWORD       dwDataOffset;
-    DWORD       dwDataLength;
-    DWORD       dwDataRVA;
-    VOID       *pvBuffer;
-    const void *pbPublicKey;
-    ULONG       cbPublicKey;
-    
-    // Determine size of signature blob.
-    
-    IfFailRet(GetManifestImport()->GetAssemblyProps(TokenFromRid(1, mdtAssembly),
-                                          &pbPublicKey, &cbPublicKey, NULL,
-                                          NULL, NULL, NULL));
-    
-    if (!StrongNameSignatureSize((BYTE *) pbPublicKey, cbPublicKey, &dwDataLength)) {
-        hr = StrongNameErrorInfo();
-        return hr;
-    }
-    
-    // Allocate space for the signature in the text section and update the COM+
-    // header to point to the space.
-    IfFailRet(pCeeFileGen->GetIlSection(ceeFile, &TData));
-    IfFailRet(pCeeFileGen->GetSectionDataLen(TData, &dwDataOffset));
-    IfFailRet(pCeeFileGen->GetSectionBlock(TData, dwDataLength, 4, &pvBuffer));
-    IfFailRet(pCeeFileGen->GetMethodRVA(ceeFile, dwDataOffset, &dwDataRVA));
-    IfFailRet(pCeeFileGen->SetStrongNameEntry(ceeFile, dwDataLength, dwDataRVA));
-    
-    return S_OK;
-}
-
-
-//***********************************************************
-// Strong name sign a manifest already persisted to disk
-//***********************************************************
-HRESULT Assembly::SignWithStrongName(LPCWSTR wszFileName)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        INJECT_FAULT(return E_OUTOFMEMORY;);
-    }
-    CONTRACTL_END
-
-    HRESULT hr = S_OK;
-
-    // If we're going to do a full signing we have a key pair either
-    // in a key container or provided directly in a byte array.
-
-    switch (m_eStrongNameLevel) {
-    case SN_FULL_KEYPAIR_IN_ARRAY:
-        if (!StrongNameSignatureGeneration(wszFileName, NULL, m_pbStrongNameKeyPair, m_cbStrongNameKeyPair, NULL, NULL))
-            hr = StrongNameErrorInfo();
-        break;
-
-    case SN_FULL_KEYPAIR_IN_CONTAINER:
-        if (!StrongNameSignatureGeneration(wszFileName, m_pwStrongNameKeyContainer, NULL, 0, NULL, NULL))
-            hr = StrongNameErrorInfo();
-        break;
-
-    default:
-        break;
-    }
-
-    return hr;
-}
-
-
-//***********************************************************
-// save the manifest to disk!
-//***********************************************************
-void Assembly::SaveManifestToDisk(LPCWSTR wszFileName, int entrypoint, int fileKind, DWORD corhFlags, DWORD peFlags)
-{
-    STANDARD_VM_CONTRACT;
-
-    HRESULT         hr = NOERROR;
-    HCEEFILE        ceeFile = NULL;
-    ICeeFileGen     *pCeeFileGen = NULL;
-    RefClassWriter  *pRCW;
-    IMetaDataEmit   *pEmitter;
-
-    _ASSERTE( m_fEmbeddedManifest == false );
-
-    pRCW = m_pOnDiskManifest->GetClassWriter();
-    _ASSERTE(pRCW);
-
-    IfFailGo( pRCW->EnsureCeeFileGenCreated(corhFlags, peFlags) );
-
-    pCeeFileGen = pRCW->GetCeeFileGen();
-    ceeFile = pRCW->GetHCEEFILE();
-    _ASSERTE(ceeFile && pCeeFileGen);
-
-    //Emit the MetaData
-    pEmitter = m_pOnDiskManifest->GetClassWriter()->GetEmitter();
-    IfFailGo( pCeeFileGen->EmitMetaDataEx(ceeFile, pEmitter) );
-
-    // Allocate space for a strong name signature if a public key was supplied
-    // (this doesn't strong name the assembly, but it makes it possible to do so
-    // as a post processing step).
-    if (IsStrongNamed())
-        IfFailGo(AllocateStrongNameSignature(pCeeFileGen, ceeFile));
-
-    IfFailGo( pCeeFileGen->SetOutputFileName(ceeFile, (LPWSTR)wszFileName) );
-
-    // the entryPoint for an assembly is a tkFile token if exist.
-    if (RidFromToken(entrypoint) != mdTokenNil)
-        IfFailGo( pCeeFileGen->SetEntryPoint(ceeFile, entrypoint) );
-    if (fileKind == Dll)
-    {
-        pCeeFileGen->SetDllSwitch(ceeFile, true);
-    }
-    else
-    {
-        // should have a valid entry point for applications
-        if (fileKind == WindowApplication)
-        {
-            IfFailGo( pCeeFileGen->SetSubsystem(ceeFile, IMAGE_SUBSYSTEM_WINDOWS_GUI, CEE_IMAGE_SUBSYSTEM_MAJOR_VERSION, CEE_IMAGE_SUBSYSTEM_MINOR_VERSION) );
-        }
-        else
-        {
-            _ASSERTE(fileKind == ConsoleApplication);
-            IfFailGo( pCeeFileGen->SetSubsystem(ceeFile, IMAGE_SUBSYSTEM_WINDOWS_CUI, CEE_IMAGE_SUBSYSTEM_MAJOR_VERSION, CEE_IMAGE_SUBSYSTEM_MINOR_VERSION) );
-        }
-
-    }
-
-    //Generate the CeeFile
-    IfFailGo(pCeeFileGen->GenerateCeeFile(ceeFile) );
-
-    // Strong name sign the resulting assembly if required.
-    if (IsStrongNamed())
-        IfFailGo(SignWithStrongName(wszFileName));
-
-    // now release the m_pOnDiskManifest
-ErrExit:
-    pRCW->DestroyCeeFileGen();
-
-    // we keep the on disk manifest so that the GetModules code can skip over this ad-hoc module when modules are enumerated.
-    // Need to see if we can remove the creation of this module alltogether
-    //m_pOnDiskManifest = NULL;
-
-    if (FAILED(hr))
-    {
-        if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
-        {
-            if (IsWin32IOError(HRESULT_CODE(hr)))
-            {
-                COMPlusThrowHR(COR_E_IO);
-            }
-            else
-            {
-                COMPlusThrowHR(hr);
-            }
-        }
-        if (hr == CEE_E_CVTRES_NOT_FOUND)
-            COMPlusThrow(kIOException, W("Argument_cvtres_NotFound"));
-        COMPlusThrowHR(hr);
-    }
-}   // Assembly::SaveManifestToDisk
-
-#endif // FEATURE_CORECLR && !CROSSGEN_COMPILE
 
 
 HRESULT STDMETHODCALLTYPE
@@ -3774,78 +2993,7 @@ GetAssembliesByName(LPCWSTR  szAppBase,
     if (!(szAssemblyName && ppIUnk && pcAssemblies))
         return E_POINTER;
 
-#if defined(FEATURE_CORECLR) || defined(CROSSGEN_COMPILE)
     hr = COR_E_NOTSUPPORTED;
-#else
-    AppDomain *pDomain = NULL;
-
-    BEGIN_EXTERNAL_ENTRYPOINT(&hr)
-    if(szAppBase || szPrivateBin)
-    {
-        GCX_COOP_THREAD_EXISTS(GET_THREAD());
-        MethodDescCallSite createDomainEx(METHOD__APP_DOMAIN__CREATE_DOMAINEX);
-        struct _gc {
-            STRINGREF pFriendlyName;
-            STRINGREF pAppBase;
-            STRINGREF pPrivateBin;
-        } gc;
-        ZeroMemory(&gc, sizeof(gc));
-
-        GCPROTECT_BEGIN(gc);
-        gc.pFriendlyName = StringObject::NewString(W("GetAssembliesByName"));
-
-        if(szAppBase)
-        {
-            gc.pAppBase = StringObject::NewString(szAppBase);
-        }
-            
-        if(szPrivateBin)
-        {
-            gc.pPrivateBin = StringObject::NewString(szPrivateBin);
-        }
-
-        ARG_SLOT args[5] = 
-        {
-            ObjToArgSlot(gc.pFriendlyName),
-            NULL,
-            ObjToArgSlot(gc.pAppBase),
-            ObjToArgSlot(gc.pPrivateBin),
-            BoolToArgSlot(false)
-        };
-        APPDOMAINREF pDom = (APPDOMAINREF) createDomainEx.Call_RetOBJECTREF(args);
-        if (pDom == NULL)
-        {
-            hr = E_FAIL;
-        }
-        else 
-        {
-            Context *pContext = CRemotingServices::GetServerContextForProxy((OBJECTREF) pDom);
-            _ASSERTE(pContext);
-            pDomain = pContext->GetDomain();
-        }
-
-        GCPROTECT_END();
-    }
-    else
-        pDomain = SystemDomain::System()->DefaultDomain();
-
-    Assembly *pFoundAssembly;
-    if (SUCCEEDED(hr)) {
-        pFoundAssembly = pDomain->LoadAssemblyHelper(szAssemblyName,
-                                                     NULL);
-        if (SUCCEEDED(hr)) {
-            if (cMax < 1)
-                hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
-            else {
-                ppIUnk[0] = (IUnknown *)pFoundAssembly->GetManifestAssemblyImporter();
-                ppIUnk[0]->AddRef();
-            }
-            *pcAssemblies = 1;
-        }
-    }
-
-    END_EXTERNAL_ENTRYPOINT;
-#endif // FEATURE_CORECLR
 
     return hr;
 }// Used by the IMetadata API's to access an assemblies metadata.
@@ -3865,188 +3013,7 @@ BOOL Assembly::MissingDependenciesCheckDone()
 };
 
 
-#ifdef FEATURE_FUSION
-void Assembly::SetBindingClosure(IAssemblyBindingClosure* pClosure) // Addrefs. It is assumed the caller did not addref pClosure for us.
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
 
-    _ASSERTE(m_pBindingClosure == NULL);
-    _ASSERTE(pClosure != NULL);
-
-    m_pBindingClosure = pClosure;
-    pClosure->AddRef(); // It is assumed the caller did not addref pBindingClosure for us.
-}
-
-IAssemblyBindingClosure * Assembly::GetBindingClosure()
-{
-    LIMITED_METHOD_CONTRACT;
-    return m_pBindingClosure;
-}
-
-
-// The shared module list is effectively an extension of the shared domain assembly hash table.
-// It is the canonical list and aribiter of modules loaded from this assembly by any app domain.
-// Modules are stored here immediately on creating (to prevent duplicate creation), as opposed to
-// in the rid map, where they are only placed upon load completion.
-
-BOOL Assembly::CanBeShared(DomainAssembly *pDomainAssembly)
-{
-    CONTRACTL
-    {
-        PRECONDITION(CheckPointer(pDomainAssembly));
-        THROWS;
-        GC_TRIGGERS;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    LOG((LF_CODESHARING,
-         LL_INFO100,
-         "Checking if we can share: \"%S\" in domain 0x%x.\n",
-         GetDebugName(), pDomainAssembly->GetAppDomain()));
-
-    STRESS_LOG2(LF_CODESHARING, LL_INFO1000,"Checking whether DomainAssembly %p is compatible with Assembly %p",
-        pDomainAssembly,this);
-
-    // We must always share the same system assemblies
-    if (IsSystem())
-    {
-        STRESS_LOG0(LF_CODESHARING, LL_INFO1000,"System assembly - sharing");
-        return TRUE;
-    }
-
-    if ((pDomainAssembly->GetDebuggerInfoBits()&~(DACF_PDBS_COPIED|DACF_IGNORE_PDBS|DACF_OBSOLETE_TRACK_JIT_INFO))
-        != (m_debuggerFlags&~(DACF_PDBS_COPIED|DACF_IGNORE_PDBS|DACF_OBSOLETE_TRACK_JIT_INFO)))
-    {
-        LOG((LF_CODESHARING,
-             LL_INFO100,
-             "We can't share it, desired debugging flags %x are different than %x\n",
-             pDomainAssembly->GetDebuggerInfoBits(), (m_debuggerFlags&~(DACF_PDBS_COPIED|DACF_IGNORE_PDBS|DACF_OBSOLETE_TRACK_JIT_INFO))));
-        STRESS_LOG2(LF_CODESHARING, LL_INFO100,"Flags diff= %08x [%08x/%08x]",pDomainAssembly->GetDebuggerInfoBits(),
-                    m_debuggerFlags);
-        g_dwLoaderReasonForNotSharing = ReasonForNotSharing_DebuggerFlagMismatch;
-        return FALSE;
-    }
-
-    PEAssembly * pDomainAssemblyFile = pDomainAssembly->GetFile();
-    if (pDomainAssemblyFile == NULL)
-    {
-        g_dwLoaderReasonForNotSharing = ReasonForNotSharing_NullPeassembly;
-        return FALSE;
-    }
-    
-    IAssemblyBindingClosure * pContext = GetBindingClosure();
-    if (pContext == NULL)
-    {
-        STRESS_LOG1(LF_CODESHARING, LL_INFO1000,"No context 1 - status=%d",pDomainAssemblyFile->IsSystem());
-        if (pDomainAssemblyFile->IsSystem())
-            return TRUE;
-        else
-        {
-            g_dwLoaderReasonForNotSharing = ReasonForNotSharing_MissingAssemblyClosure1;
-            return FALSE;
-        }
-    }
-
-    IAssemblyBindingClosure * pCurrentContext = pDomainAssembly->GetAssemblyBindingClosure(LEVEL_STARTING);
-    if (pCurrentContext == NULL)
-    {
-        STRESS_LOG1(LF_CODESHARING, LL_INFO1000,"No context 2 - status=%d",pDomainAssemblyFile->IsSystem());
-        if (pDomainAssemblyFile->IsSystem())
-            return TRUE;
-        else
-        {
-            g_dwLoaderReasonForNotSharing = ReasonForNotSharing_MissingAssemblyClosure2;
-            return FALSE;
-        }
-    }
-
-    // ensure the closures are walked
-    {
-        ReleaseHolder<IBindResult> pWinRTBindResult;
-        
-        IUnknown * pUnk;
-        if (pDomainAssembly->GetFile()->IsWindowsRuntime())
-        {   // It is .winmd file (WinRT assembly)
-            IfFailThrow(CLRPrivAssemblyWinRT::GetIBindResult(pDomainAssembly->GetFile()->GetHostAssembly(), &pWinRTBindResult));
-            pUnk = pWinRTBindResult;
-        }
-        else
-        {
-            pUnk = pDomainAssembly->GetFile()->GetFusionAssembly();
-        }
-        
-        GCX_PREEMP();
-        IfFailThrow(pCurrentContext->EnsureWalked(pUnk, ::GetAppDomain()->GetFusionContext(), LEVEL_COMPLETE));
-    }
-
-    if ((pContext->HasBeenWalked(LEVEL_COMPLETE) != S_OK) || !MissingDependenciesCheckDone())
-    {
-        GCX_COOP();
-
-        BOOL fMissingDependenciesResolved = FALSE;
-
-        ENTER_DOMAIN_PTR(SystemDomain::System()->DefaultDomain(), ADV_DEFAULTAD);
-        {
-            {
-                ReleaseHolder<IBindResult> pWinRTBindResult;
-        
-                IUnknown * pUnk;
-                if (GetManifestFile()->IsWindowsRuntime())
-                {   // It is .winmd file (WinRT assembly)
-                    IfFailThrow(CLRPrivAssemblyWinRT::GetIBindResult(GetManifestFile()->GetHostAssembly(), &pWinRTBindResult));
-                    pUnk = pWinRTBindResult;
-                }
-                else
-                {
-                    pUnk = GetManifestFile()->GetFusionAssembly();
-                }
-                
-                GCX_PREEMP();
-                IfFailThrow(pContext->EnsureWalked(pUnk, ::GetAppDomain()->GetFusionContext(), LEVEL_COMPLETE));
-            }
-            DomainAssembly * domainAssembly = ::GetAppDomain()->FindDomainAssembly(this);
-            if (domainAssembly != NULL)
-            {
-                if (domainAssembly->CheckMissingDependencies() == CMD_Resolved)
-                {
-                    //cannot share
-                    fMissingDependenciesResolved = TRUE;
-                }
-            }
-        }
-        END_DOMAIN_TRANSITION;
-
-        if (fMissingDependenciesResolved)
-        {
-            STRESS_LOG0(LF_CODESHARING, LL_INFO1000,"Missing dependencies resolved - not sharing");
-            g_dwLoaderReasonForNotSharing = ReasonForNotSharing_MissingDependenciesResolved;
-            return FALSE;
-        }
-    }
-
-    HRESULT hr = pContext->IsEqual(pCurrentContext);
-    IfFailThrow(hr);
-    if (hr != S_OK)
-    {
-        STRESS_LOG1(LF_CODESHARING, LL_INFO1000,"Closure comparison returned %08x - not sharing",hr);        
-        g_dwLoaderReasonForNotSharing = ReasonForNotSharing_ClosureComparisonFailed;
-        return FALSE;
-    }
-
-    LOG((LF_CODESHARING, LL_INFO100, "We can share it : \"%S\"\n", GetDebugName()));
-    STRESS_LOG0(LF_CODESHARING, LL_INFO1000,"Everything is fine - sharing");                
-    return TRUE;
-}
-#endif
-
-#ifdef FEATURE_VERSIONING
 
 BOOL Assembly::CanBeShared(DomainAssembly *pDomainAssembly)
 {
@@ -4076,11 +3043,10 @@ BOOL Assembly::CanBeShared(DomainAssembly *pDomainAssembly)
     return TRUE;
 }
 
-#endif // FEATURE_VERSIONING
 
 #endif // FEATURE_LOADER_OPTIMIZATION
 
-#if defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM)
+#if defined(FEATURE_CORESYSTEM)
 BOOL Assembly::AllowUntrustedCaller()
 {
     CONTRACTL
@@ -4093,7 +3059,7 @@ BOOL Assembly::AllowUntrustedCaller()
 
     return ModuleSecurityDescriptor::GetModuleSecurityDescriptor(this)->IsAPTCA();
 }
-#endif // defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM)
+#endif // defined(FEATURE_CORESYSTEM)
 
 void DECLSPEC_NORETURN Assembly::ThrowTypeLoadException(LPCUTF8 pszFullName, UINT resIDWhy)
 {
@@ -4323,365 +3289,6 @@ IWinMDImport *Assembly::GetManifestWinMDImport()
 
 #endif // FEATURE_COMINTEROP
 
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-void Assembly::GenerateBreadcrumbForServicing()
-{
-    STANDARD_VM_CONTRACT;
-
-    if (AppX::IsAppXProcess() || IsIntrospectionOnly() || GetManifestFile()->IsDynamic())
-    {
-        return;
-    }
-
-    if (HasServiceableAttribute() || IsExistingOobAssembly())
-    {
-        StackSString ssDisplayName;
-        GetDisplayName(ssDisplayName);
-
-        WriteBreadcrumb(ssDisplayName);
-        CheckDenyList(ssDisplayName);
-    }
-}
-
-void Assembly::WriteBreadcrumb(const SString &ssDisplayName)
-{
-    STANDARD_VM_CONTRACT;
-
-    WCHAR path[MAX_LONGPATH];
-    HRESULT hr = WszSHGetFolderPath(NULL, CSIDL_COMMON_APPDATA, NULL, SHGFP_TYPE_CURRENT, ARRAYSIZE(path), path);
-    if (hr != S_OK)
-    {
-        return;
-    }
-
-    if (wcscat_s(path, W("\\Microsoft\\NetFramework\\BreadcrumbStore\\")) != 0)
-    {
-        return;
-    }
-
-    size_t dirPathLen = wcslen(path);
-
-    // Validate the display name.  E.g., we don't want the display name to start with "..\\".
-    bool inSimpleName = true;
-    for (SString::CIterator it = ssDisplayName.Begin(); it != ssDisplayName.End(); ++it)
-    {
-        WCHAR c = *it;
-
-        // The following characters are always allowed: a-zA-Z0-9_
-        if (c >= W('a') && c <= W('z') || c >= W('A') && c <= W('Z') || c >= W('0') && c <= W('9') || c == W('_')) continue;
-
-        // The period is allowed except as the first char.
-        if (c == W('.') && it != ssDisplayName.Begin()) continue;
-
-        // A comma terminates the assembly simple name, and we are in key=value portion of the display name.
-        if (c == W(','))
-        {
-            inSimpleName = false;
-            continue;
-        }
-
-        // In key=value portion, space and equal sign are also allowed.
-        if (!inSimpleName && (c == W(' ') || c == W('='))) continue;
-
-        // If we reach here, we have an invalid assembly display name. Return without writing breadcrumb.
-        return;
-    }
-
-    // Log a breadcrumb using full display name.
-    if (wcscat_s(path, ssDisplayName.GetUnicode()) == 0)
-    {
-        HandleHolder hFile = WszCreateFile(path, 0, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
-    }
-
-    // Log another breadcrumb using display name without version.
-    // First make a copy of the display name, and look for its version part.
-    StackSString ssNoVersion(ssDisplayName);
-    SString::Iterator itVersion = ssNoVersion.Begin();
-    if (!ssNoVersion.Find(itVersion, W(", Version=")))
-    {
-        return;
-    }
-
-    // Start from the comma before Version=, advance past the comma, then look for the next comma.
-    SString::Iterator itVersionEnd = itVersion;
-    ++itVersionEnd;
-    if (!ssNoVersion.Find(itVersionEnd, W(',')))
-    {
-        // Version is the last key=value pair.
-        itVersionEnd = ssNoVersion.End();
-    }
-
-    // Erase the version.
-    ssNoVersion.Delete(itVersion, itVersionEnd - itVersion);
-
-    // Generate the full path string and create the file.
-    path[dirPathLen] = W('\0');
-    if (wcscat_s(path, ssNoVersion.GetUnicode()) == 0)
-    {
-        HandleHolder hFile = WszCreateFile(path, 0, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
-    }
-
-}
-
-bool Assembly::HasServiceableAttribute()
-{
-    STANDARD_VM_CONTRACT;
-
-    IMDInternalImport *pImport = GetManifestImport();
-    MDEnumHolder hEnum(pImport);
-    HRESULT hr = pImport->EnumCustomAttributeByNameInit(GetManifestToken(), ASSEMBLY_METADATA_TYPE, &hEnum);
-    if (hr != S_OK)
-    {
-        return false;
-    }
-
-    mdCustomAttribute tkAttribute;
-    while (pImport->EnumNext(&hEnum, &tkAttribute))
-    {
-        // Get raw custom attribute.
-        const BYTE  *pbAttr = NULL;         // Custom attribute data as a BYTE*.
-        ULONG cbAttr = 0;                   // Size of custom attribute data.
-        if (FAILED(pImport->GetCustomAttributeAsBlob(tkAttribute, reinterpret_cast<const void **>(&pbAttr), &cbAttr)))
-        {
-            THROW_BAD_FORMAT(BFA_INVALID_TOKEN, GetManifestModule());
-        }
-
-        CustomAttributeParser cap(pbAttr, cbAttr);
-        if (FAILED(cap.ValidateProlog()))
-        {
-            THROW_BAD_FORMAT(BFA_BAD_CA_HEADER, GetManifestModule());
-        }
-
-        // Get the metadata key. It is not null terminated.
-        LPCUTF8 key;
-        ULONG   cbKey;
-        if (FAILED(cap.GetString(&key, &cbKey)))
-        {
-            THROW_BAD_FORMAT(BFA_BAD_CA_HEADER, GetManifestModule());
-        }
-
-        const LPCUTF8 szServiceable = "Serviceable";
-        const ULONG cbServiceable = 11;
-        if (cbKey != cbServiceable || strncmp(key, szServiceable, cbKey) != 0)
-        {
-            continue;
-        }
-
-        // Get the metadata value. It is not null terminated.
-        if (FAILED(cap.GetString(&key, &cbKey)))
-        {
-            THROW_BAD_FORMAT(BFA_BAD_CA_HEADER, GetManifestModule());
-        }
-
-        const LPCUTF8 szTrue = "True";
-        const ULONG cbTrue = 4;
-        if (cbKey == cbTrue && strncmp(key, szTrue, cbKey) == 0)
-        {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-bool Assembly::IsExistingOobAssembly()
-{
-    WRAPPER_NO_CONTRACT;
-
-    return ExistingOobAssemblyList::Instance()->IsOnlist(this);
-}
-
-void Assembly::CheckDenyList(const SString &ssDisplayName)
-{
-    STANDARD_VM_CONTRACT;
-
-    StackSString ssKeyName(W("SOFTWARE\\Microsoft\\.NETFramework\\Policy\\DenyList\\"));
-
-    ssKeyName.Append(ssDisplayName);
-
-    RegKeyHolder hKey;
-    LONG status = RegOpenKeyEx(HKEY_LOCAL_MACHINE, ssKeyName.GetUnicode(), 0, KEY_WOW64_64KEY | GENERIC_READ, &hKey);
-
-    if (status != ERROR_SUCCESS)
-    {
-        return;
-    }
-
-    StackSString ssFwlink;
-    HRESULT hr = Clr::Util::Reg::ReadStringValue(hKey, NULL, NULL, ssFwlink);
-    if (FAILED(hr) || ssFwlink.GetCount() == 0)
-    {
-        ssFwlink.Set(W("http://go.microsoft.com/fwlink/?LinkID=286319"));
-    }
-
-    StackSString ssMessageTemplate;
-    if(!ssMessageTemplate.LoadResource(CCompRC::Optional, IDS_EE_ASSEMBLY_ON_DENY_LIST))
-    {
-        ssMessageTemplate.Set(W("The assembly %1 that the application tried to load has a known vulnerability. Please go to %2 to find a fix for this issue."));
-    }
-
-    StackSString ssMessage;
-    ssMessage.FormatMessage(FORMAT_MESSAGE_FROM_STRING, ssMessageTemplate.GetUnicode(), 0, 0, ssDisplayName, ssFwlink);
-
-    ClrReportEvent(
-        W(".NET Runtime"),            // Event source
-        EVENTLOG_ERROR_TYPE,        // Type
-        0,                          // Category
-        SecurityConfig,             // Event ID
-        NULL,                       // User SID
-        ssMessage.GetUnicode());    // Message
-
-    NewHolder<EEMessageException> pEx(new EEMessageException(kSecurityException, IDS_EE_ASSEMBLY_ON_DENY_LIST, ssDisplayName.GetUnicode(), ssFwlink.GetUnicode()));
-    EEFileLoadException::Throw(m_pManifestFile, pEx->GetHR(), pEx);
-}
-
-BOOL IsReportableAssembly(PEAssembly *pPEAssembly)
-{
-    STANDARD_VM_CONTRACT;
-
-    // If the assembly could have used a native image, but did not, report the IL image
-    BOOL fCanUseNativeImage = (pPEAssembly->HasHostAssembly() || pPEAssembly->IsContextLoad()) && 
-                               pPEAssembly->CanUseNativeImage() && 
-                               !IsNativeImageOptedOut(pPEAssembly->GetFusionAssemblyName());
-
-    return fCanUseNativeImage;
-}
-
-BOOL Assembly::SupportsAutoNGenWorker()
-{
-    STANDARD_VM_CONTRACT;
-
-    PEAssembly *pPEAssembly = GetManifestFile();
-
-    if (pPEAssembly->IsSourceGAC() && Fusion::Util::IsUnifiedAssembly(pPEAssembly->GetFusionAssemblyName()) == S_OK)
-    {
-        // Assemblies in the .NET Framework supports Auto NGen.
-        return TRUE;
-    }
-
-    if (IsAfContentType_WindowsRuntime(GetFlags()))
-    {
-        // WinMD files support Auto NGen.
-        return TRUE;
-    }
-    
-    if (pPEAssembly->HasHostAssembly())
-    {
-        // Auto NGen is enabled on all Metro app assemblies.
-        return TRUE;
-    }
-
-    if (pPEAssembly->IsSourceGAC())
-    {
-        // For non-framework assemblies in GAC, look for TargetFrameworkAttriute.
-        const BYTE  *pbAttr;                // Custom attribute data as a BYTE*.
-        ULONG       cbAttr;                 // Size of custom attribute data.
-        HRESULT hr = GetManifestImport()->GetCustomAttributeByName(GetManifestToken(), TARGET_FRAMEWORK_TYPE, (const void**)&pbAttr, &cbAttr);
-        if (hr != S_OK)
-        {
-            return FALSE;
-        }
-
-        CustomAttributeParser cap(pbAttr, cbAttr);
-        if (FAILED(cap.ValidateProlog()))
-        {
-            THROW_BAD_FORMAT(BFA_BAD_CA_HEADER, GetManifestModule());
-        }
-        LPCUTF8 lpTargetFramework;
-        ULONG cbTargetFramework;
-        if (FAILED(cap.GetString(&lpTargetFramework, &cbTargetFramework)))
-        {
-            THROW_BAD_FORMAT(BFA_BAD_CA_HEADER, GetManifestModule());
-        }
-
-        if (lpTargetFramework == NULL || cbTargetFramework == 0)
-        {
-            return FALSE;
-        }
-
-        SString ssTargetFramework(SString::Utf8, lpTargetFramework, cbTargetFramework);
-
-        // Look for two special TargetFramework values that disables AutoNGen.  To guard against future
-        // variations of the string values, we do prefix matches.
-        SString ssFramework40(SString::Literal, W(".NETFramework,Version=v4.0"));
-        SString ssPortableLib(SString::Literal, W(".NETPortable,"));
-        if (ssTargetFramework.BeginsWithCaseInsensitive(ssFramework40) || ssTargetFramework.BeginsWithCaseInsensitive(ssPortableLib))
-        {
-            return FALSE;
-        }
-
-        // If TargetFramework doesn't match one of the two special values, we enable Auto NGen.
-        return TRUE;
-    }
-
-    return FALSE;
-}
-
-void Assembly::ReportAssemblyUse()
-{
-    STANDARD_VM_CONTRACT;
-
-    // Do not log if we don't have a global gac logger object
-    if (g_pIAssemblyUsageLogGac != NULL)
-    {
-        // Only consider reporting for loads that could possibly use native images.
-        PEAssembly *pPEAssembly = this->GetManifestFile();
-        if (IsReportableAssembly(pPEAssembly) && !pPEAssembly->IsReportedToUsageLog())
-        {
-            // Do not log repeatedly
-            pPEAssembly->SetReportedToUsageLog();
-
-            ReleaseHolder<IAssemblyUsageLog> pRefCountedUsageLog;
-            IAssemblyUsageLog *pUsageLog = NULL;
-            if (SupportsAutoNGen())
-            {
-                if (pPEAssembly->IsSourceGAC())
-                {
-                    pUsageLog = g_pIAssemblyUsageLogGac;
-                }
-                else if (pPEAssembly->HasHostAssembly())
-                {
-                    UINT_PTR binderId;
-                    IfFailThrow(pPEAssembly->GetHostAssembly()->GetBinderID(&binderId));
-                    pRefCountedUsageLog = AssemblyUsageLogManager::GetUsageLogForBinder(binderId);
-                    pUsageLog = pRefCountedUsageLog;
-                }
-            }
-
-            if (pUsageLog)
-            {
-                PEAssembly *pPEAssembly = GetManifestFile();
-                StackSString name;
-                // GAC Assemblies are reported by assembly name
-                if (pUsageLog == g_pIAssemblyUsageLogGac)
-                {
-                    this->GetDisplayName(name);
-                }
-                // Other assemblies (AppX...) are reported by file path
-                else
-                {
-                    name.Set(pPEAssembly->GetILimage()->GetPath().GetUnicode());
-                }
-
-                if (pPEAssembly->HasNativeImage())
-                {
-                    if(!IsSystem())
-                    {
-                        // If the assembly used a native image, report it
-                        ReleaseHolder<PEImage> pNativeImage = pPEAssembly->GetNativeImageWithRef();
-                        pUsageLog->LogFile(name.GetUnicode(), pNativeImage->GetPath().GetUnicode(), ASSEMBLY_USAGE_LOG_FLAGS_NI);
-                    }
-                }
-                else
-                {
-                    // If the assembly could have used a native image, but did not, report the IL image
-                    pUsageLog->LogFile(name.GetUnicode(), NULL, ASSEMBLY_USAGE_LOG_FLAGS_IL);
-                }
-            }
-        }
-    }
-}
-#endif // FEATURE_CORECLR && !CROSSGEN_COMPILE
 
 #endif // #ifndef DACCESS_COMPILE
 
@@ -4767,11 +3374,7 @@ FriendAssemblyDescriptor::~FriendAssemblyDescriptor()
     while (itFullAccessAssemblies.Next())
     {
         FriendAssemblyName_t *pFriendAssemblyName = static_cast<FriendAssemblyName_t *>(itFullAccessAssemblies.GetElement());
-#ifdef FEATURE_FUSION
-        pFriendAssemblyName->Release();
-#else // FEATURE_FUSION
         delete pFriendAssemblyName;
-#endif // FEATURE_FUSION
     }
 }
 
@@ -4856,9 +3459,6 @@ FriendAssemblyDescriptor *FriendAssemblyDescriptor::CreateFriendAssemblyDescript
 
             // Create an AssemblyNameObject from the string.
             FriendAssemblyNameHolder pFriendAssemblyName;
-#ifdef FEATURE_FUSION
-            hr = CreateAssemblyNameObject(&pFriendAssemblyName, displayName.GetUnicode(), CANOF_PARSE_FRIEND_DISPLAY_NAME, NULL);
-#else // FEATURE_FUSION
             StackScratchBuffer buffer;
             pFriendAssemblyName = new FriendAssemblyName_t;
             hr = pFriendAssemblyName->Init(displayName.GetUTF8(buffer));
@@ -4867,7 +3467,6 @@ FriendAssemblyDescriptor *FriendAssemblyDescriptor::CreateFriendAssemblyDescript
             {
                 hr = pFriendAssemblyName->CheckFriendAssemblyName();
             }
-#endif // FEATURE_FUSION
 
             if (FAILED(hr))
             {
@@ -4884,31 +3483,6 @@ FriendAssemblyDescriptor *FriendAssemblyDescriptor::CreateFriendAssemblyDescript
 
             // CoreCLR does not have a valid scenario for strong-named assemblies requiring their dependencies
             // to be strong-named as well.
-#if !defined(FEATURE_CORECLR)        
-            // If this assembly has a strong name, then its friends declarations need to have strong names too
-            if (pAssembly->IsStrongNamed())
-            {
-#ifdef FEATURE_FUSION        
-                DWORD dwSize = 0;
-                if (SUCCEEDED(hr = pFriendAssemblyName->GetProperty(ASM_NAME_PUBLIC_KEY, NULL, &dwSize)))
-                {
-                    // If this call succeeds with an empty buffer, then the supplied name doesn't have a public key.
-                    THROW_HR_ERROR_WITH_INFO(META_E_CA_FRIENDS_SN_REQUIRED, pAssembly);
-                }
-                else if (hr != HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER))
-                {
-                    IfFailThrow(hr);
-                }
-#else // FEATURE_FUSION
-                // Desktop crossgen comes here
-                if (!pFriendAssemblyName->IsStrongNamed())
-                {
-                    // If this call succeeds with an empty buffer, then the supplied name doesn't have a public key.
-                    THROW_HR_ERROR_WITH_INFO(META_E_CA_FRIENDS_SN_REQUIRED, pAssembly);
-                }
-#endif // FEATURE_FUSION            
-            }
-#endif // !defined(FEATURE_CORECLR)
 
             pFriendAssemblies->AddFriendAssembly(pFriendAssemblyName);
 
@@ -4971,23 +3545,14 @@ bool FriendAssemblyDescriptor::IsAssemblyOnList(PEAssembly *pAssembly, const Arr
     }
     CONTRACTL_END;
 
-#ifndef FEATURE_FUSION
     AssemblySpec asmDef;
     asmDef.InitializeSpec(pAssembly);
-#endif        
 
     ArrayList::ConstIterator itAssemblyNames = alAssemblyNames.Iterate();
     while (itAssemblyNames.Next())
     {
         const FriendAssemblyName_t *pFriendAssemblyName = static_cast<const FriendAssemblyName_t *>(itAssemblyNames.GetElement());
-#ifdef FEATURE_FUSION
-        // This is a const operation on the pointer, but Fusion is not const-correct.
-        //  @TODO - propigate const correctness through Fusion and remove this cast
-        HRESULT hr = const_cast<FriendAssemblyName_t *>(pFriendAssemblyName)->IsEqual(pAssembly->GetFusionAssemblyName(), ASM_CMPF_DEFAULT);
-        IfFailThrow(hr);
-#else       
         HRESULT hr = AssemblySpec::RefMatchesDef(pFriendAssemblyName, &asmDef) ? S_OK : S_FALSE;
-#endif
 
         if (hr == S_OK)
         {
@@ -5001,70 +3566,3 @@ bool FriendAssemblyDescriptor::IsAssemblyOnList(PEAssembly *pAssembly, const Arr
 #endif // !DACCESS_COMPILE
 
 
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE) && !defined(DACCESS_COMPILE)
-
-ExistingOobAssemblyList::ExistingOobAssemblyList()
-{
-    STANDARD_VM_CONTRACT;
-
-    RegKeyHolder hKey;
-    LONG status = RegOpenKeyExW(HKEY_LOCAL_MACHINE, W("SOFTWARE\\Microsoft\\.NETFramework\\Policy\\Servicing"), 0, KEY_WOW64_64KEY | GENERIC_READ, &hKey);
-    if (status != ERROR_SUCCESS)
-    {
-        return;
-    }
-
-    for (DWORD i = 0; ; i++)
-    {
-        WCHAR name[MAX_PATH_FNAME + 1];
-        DWORD cchName = ARRAYSIZE(name);
-        status = RegEnumKeyExW(hKey, i, name, &cchName, NULL, NULL, NULL, NULL);
-
-        if (status == ERROR_NO_MORE_ITEMS)
-        {
-            break;
-        }
-
-        if (status == ERROR_SUCCESS)
-        {
-            NonVMComHolder<IAssemblyName> pAssemblyName;
-            HRESULT hr = CreateAssemblyNameObject(&pAssemblyName, name, CANOF_PARSE_DISPLAY_NAME, NULL);
-            if (SUCCEEDED(hr))
-            {
-                hr = m_alExistingOobAssemblies.Append(pAssemblyName.GetValue());
-                if (SUCCEEDED(hr))
-                {
-                    pAssemblyName.SuppressRelease();
-                }
-            }
-        }
-    }
-}
-
-bool ExistingOobAssemblyList::IsOnlist(Assembly *pAssembly)
-{
-    STANDARD_VM_CONTRACT;
-
-    ArrayList::Iterator itAssemblyNames = m_alExistingOobAssemblies.Iterate();
-    while (itAssemblyNames.Next())
-    {
-        IAssemblyName *pAssemblyName = static_cast<IAssemblyName *>(itAssemblyNames.GetElement());
-        HRESULT hr = pAssemblyName->IsEqual(pAssembly->GetFusionAssemblyName(), ASM_CMPF_DEFAULT);
-        if (hr == S_OK)
-        {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-void ExistingOobAssemblyList::Init()
-{
-    STANDARD_VM_CONTRACT;
-
-    s_pInstance = new ExistingOobAssemblyList();
-}
-
-ExistingOobAssemblyList *ExistingOobAssemblyList::s_pInstance;
-#endif // !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE) && !defined(DACCESS_COMPILE)
diff --git a/src/vm/assembly.hpp b/src/vm/assembly.hpp
index bcd36b9a5f..da82001b32 100644
--- a/src/vm/assembly.hpp
+++ b/src/vm/assembly.hpp
@@ -18,10 +18,6 @@
 #include "ceeload.h"
 #include "exceptmacros.h"
 #include "clsload.hpp"
-#ifdef FEATURE_FUSION
-#include "fusion.h"
-#include "fusionbind.h"
-#endif
 #include "eehash.h"
 #include "listlock.h"
 #include "iceefilegen.h"
@@ -73,9 +69,6 @@ enum DynamicAssemblyFlags
 struct CreateDynamicAssemblyArgsGC
 {
     APPDOMAINREF    refThis;
-    OBJECTREF       refusedPset;
-    OBJECTREF       optionalPset;
-    OBJECTREF       requiredPset;
     OBJECTREF       identity;
     ASSEMBLYNAMEREF assemblyName;
     U1ARRAYREF      securityRulesBlob;
@@ -294,9 +287,9 @@ public:
 
     BOOL GetModuleZapFile(LPCWSTR name, SString &path);
 
-#if defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM)
+#if defined(FEATURE_CORESYSTEM)
     BOOL AllowUntrustedCaller();
-#endif // defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM)
+#endif // defined(FEATURE_CORESYSTEM)
     
 #ifdef LOGGING
     LPCWSTR GetDebugName()
@@ -534,23 +527,7 @@ public:
     void AddType(Module* pModule,
                  mdTypeDef cl);
     void AddExportedType(mdExportedType cl);
-#ifndef FEATURE_CORECLR
-    void PrepareSavingManifest(ReflectionModule *pAssemblyModule);
-    mdFile AddFile(LPCWSTR wszFileName);
-    void SetFileHashValue(mdFile tkFile, LPCWSTR wszFullFileName);
-#endif
     mdAssemblyRef AddAssemblyRef(Assembly *refedAssembly, IMetaDataAssemblyEmit *pAssemEmitter = NULL, BOOL fUsePublicKeyToken = TRUE);
-#ifndef FEATURE_CORECLR
-    mdExportedType AddExportedTypeOnDisk(LPCWSTR wszExportedType, mdToken tkImpl, mdToken tkTypeDef, CorTypeAttr flags);
-    mdExportedType AddExportedTypeInMemory(LPCWSTR wszExportedType, mdToken tkImpl, mdToken tkTypeDef, CorTypeAttr flags);
-    void AddStandAloneResource(LPCWSTR wszName, LPCWSTR wszDescription, LPCWSTR wszMimeType, LPCWSTR wszFileName, LPCWSTR wszFullFileName, int iAttribute);
-    void SaveManifestToDisk(LPCWSTR wszFileName, int entrypoint, int fileKind, DWORD corhFlags, DWORD peFlags);
-#endif // FEATURE_CORECLR
-#ifndef FEATURE_CORECLR
-    void AddDeclarativeSecurity(DWORD dwAction, void const *pValue, DWORD cbValue);
-
-    IMetaDataAssemblyEmit *GetOnDiskMDAssemblyEmitter();
-#endif // FEATURE_CORECLR
 
     //****************************************************************************************
 
@@ -584,10 +561,6 @@ public:
 #ifdef FEATURE_LOADER_OPTIMIZATION
     BOOL MissingDependenciesCheckDone();
     void SetMissingDependenciesCheckDone();
-#ifdef FEATURE_FUSION
-    void SetBindingClosure(IAssemblyBindingClosure* pClosure); // Addrefs. It is assumed the caller did not addref pClosure for us.
-    IAssemblyBindingClosure* GetBindingClosure();
-#endif
 #endif // FEATURE_LOADER_OPTIMIZATION
 
     void SetDomainNeutral() { LIMITED_METHOD_CONTRACT; m_fIsDomainNeutral = TRUE; }
@@ -604,31 +577,6 @@ public:
                                         HCEEFILE      ceeFile);
     HRESULT SignWithStrongName(LPCWSTR wszFileName);
 
-#ifdef FEATURE_FUSION
-    IAssembly* GetFusionAssembly()
-    {
-        WRAPPER_NO_CONTRACT;
-        return m_pManifestFile->GetFusionAssembly();
-    }
-
-    IAssemblyName* GetFusionAssemblyName()
-    {
-        WRAPPER_NO_CONTRACT;
-        return m_pManifestFile->GetFusionAssemblyName();
-    }
-
-    IAssemblyName* GetFusionAssemblyNameNoCreate()
-    {
-        WRAPPER_NO_CONTRACT;
-        return m_pManifestFile->GetFusionAssemblyNameNoCreate();
-    }
-    
-    IHostAssembly* GetIHostAssembly()
-    {
-        WRAPPER_NO_CONTRACT;
-        return m_pManifestFile->GetIHostAssembly();
-    }
-#endif// FEATURE_FUSION
 
 #ifdef FEATURE_COMINTEROP
     // Get any cached ITypeLib* for the assembly.
@@ -717,13 +665,6 @@ public:
     IWinMDImport *GetManifestWinMDImport();
 #endif
 
-#ifndef FEATURE_CORECLR
-    BOOL SupportsAutoNGen()
-    {
-        WRAPPER_NO_CONTRACT;
-        return m_fSupportsAutoNGen;
-    }
-#endif
 
 protected:
 
@@ -800,15 +741,6 @@ private:
 
     void CacheFriendAssemblyInfo();
    
-#ifndef FEATURE_CORECLR
-    void GenerateBreadcrumbForServicing();
-    void WriteBreadcrumb(const SString &ssDisplayName);
-    bool HasServiceableAttribute();
-    bool IsExistingOobAssembly();
-    void CheckDenyList(const SString &ssDisplayName);
-
-    BOOL SupportsAutoNGenWorker();
-#endif
 
     PTR_BaseDomain        m_pDomain;        // Parent Domain
     PTR_ClassLoader       m_pClassLoader;   // Single Loader
@@ -859,9 +791,6 @@ private:
     BOOL                   m_fIsDomainNeutral;
 #ifdef FEATURE_LOADER_OPTIMIZATION
     BOOL m_bMissingDependenciesCheckDone;
-#ifdef FEATURE_FUSION
-    IAssemblyBindingClosure * m_pBindingClosure;
-#endif
 #endif // FEATURE_LOADER_OPTIMIZATION
 
     DebuggerAssemblyControlFlags m_debuggerFlags;
@@ -873,9 +802,6 @@ private:
 
     DWORD                 m_dwReliabilityContract;
 
-#ifndef FEATURE_CORECLR
-    BOOL                  m_fSupportsAutoNGen;
-#endif
 };
 
 typedef Assembly::ModuleIterator ModuleIterator;
@@ -926,25 +852,6 @@ public:
         return IsAssemblyOnList(pAccessingAssembly, m_alFullAccessFriendAssemblies);
     }
 
-#ifndef FEATURE_CORECLR
-    //------------------------------------------------------------------------------
-    // It is undesirable to reintroduce the concept of inquiring about friendship without specifying a member or type
-    // but necessary for TP. In case of doubt, it's safer to return "true" as this won't affect
-    // correctness (but might cause unnecessary ngen's when updating assemblies.)
-    //------------------------------------------------------------------------------
-    bool MightGrantFriendAccessTo(PEAssembly *pAccessingAssembly)
-    {
-        CONTRACTL
-        {
-            THROWS;
-            GC_TRIGGERS;
-            PRECONDITION(CheckPointer(pAccessingAssembly));
-        }
-        CONTRACTL_END;
-
-        return IsAssemblyOnList(pAccessingAssembly, m_alFullAccessFriendAssemblies);
-    }
-#endif // !FEATURE_CORECLR
 
     bool IgnoresAccessChecksTo(Assembly *pAccessedAssembly)
     {
@@ -952,13 +859,8 @@ public:
     }
 
 private:
-#ifdef FEATURE_FUSION
-    typedef IAssemblyName FriendAssemblyName_t;
-    typedef NonVMComHolder<IAssemblyName> FriendAssemblyNameHolder;
-#else // FEATURE_FUSION
     typedef AssemblySpec FriendAssemblyName_t;
     typedef NewHolder<AssemblySpec> FriendAssemblyNameHolder;
-#endif // FEATURE_FUSION
 
     ArrayList                  m_alFullAccessFriendAssemblies;      // Friend assemblies which have access to all internals
     ArrayList                  m_subjectAssemblies;                 // Subject assemblies which we will not perform access checks against
@@ -980,25 +882,5 @@ private:
 
 #endif // !DACCESS_COMPILE
 
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-class ExistingOobAssemblyList
-{
-public:
-#ifndef DACCESS_COMPILE
-    ExistingOobAssemblyList();
-
-    bool IsOnlist(Assembly *pAssembly);
-
-    static void Init();
-    static ExistingOobAssemblyList *Instance() { return s_pInstance; }
-#endif
-
-private:
-    ArrayList m_alExistingOobAssemblies;
-
-    // The single instance of this class:
-    static ExistingOobAssemblyList *s_pInstance;
-};
-#endif // !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
 
 #endif
diff --git a/src/vm/assemblyname.cpp b/src/vm/assemblyname.cpp
index d7689e8b88..a7cf2ec250 100644
--- a/src/vm/assemblyname.cpp
+++ b/src/vm/assemblyname.cpp
@@ -22,9 +22,6 @@
 #include "assemblyname.hpp"
 #include "security.h"
 #include "field.h"
-#ifdef FEATURE_FUSION
-#include "fusion.h"
-#endif
 #include "strongname.h"
 #include "eeconfig.h"
 
@@ -62,15 +59,11 @@ FCIMPL1(Object*, AssemblyNameNative::GetFileInformation, StringObject* filenameU
 
     EX_TRY
     {
-#ifdef FEATURE_CORECLR
         // Allow AssemblyLoadContext.GetAssemblyName for native images on CoreCLR
         if (pImage->HasNTHeaders() && pImage->HasCorHeader() && pImage->HasNativeHeader())
             pImage->VerifyIsNIAssembly();
         else
             pImage->VerifyIsAssembly();
-#else
-        pImage->VerifyIsAssembly();
-#endif
     }
     EX_CATCH
     {
@@ -84,9 +77,6 @@ FCIMPL1(Object*, AssemblyNameNative::GetFileInformation, StringObject* filenameU
 
     AssemblySpec spec;
     spec.InitializeSpec(TokenFromRid(mdtAssembly,1),pImage->GetMDImport(),NULL,TRUE);
-#ifndef FEATURE_CORECLR
-    spec.SetCodeBase(sUrl);
-#endif
     spec.AssemblyNameInit(&gc.result, pImage);
     
     HELPER_METHOD_FRAME_END();
@@ -113,14 +103,10 @@ FCIMPL1(Object*, AssemblyNameNative::ToString, Object* refThisUNSAFE)
     spec.InitializeSpec(&(pThread->m_MarshalAlloc), (ASSEMBLYNAMEREF*) &pThis, FALSE, FALSE); 
 
     StackSString name;
-#ifndef FEATURE_FUSION
     spec.GetFileOrDisplayName(ASM_DISPLAYF_VERSION |
                               ASM_DISPLAYF_CULTURE |
                               ASM_DISPLAYF_PUBLIC_KEY_TOKEN,
                               name);
-#else
-    spec.GetFileOrDisplayName(0, name);
-#endif // FEATURE_FUSION
 
     pObj = (OBJECTREF) StringObject::NewString(name);
 
@@ -168,52 +154,6 @@ FCIMPL1(Object*, AssemblyNameNative::GetPublicKeyToken, Object* refThisUNSAFE)
 }
 FCIMPLEND
 
-#ifndef FEATURE_CORECLR
-FCIMPL1(Object*, AssemblyNameNative::EscapeCodeBase, StringObject* filenameUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    STRINGREF rv        = NULL;
-    STRINGREF filename  = (STRINGREF) filenameUNSAFE;
-    HELPER_METHOD_FRAME_BEGIN_RET_1(filename);
-
-    LPWSTR pCodeBase = NULL;
-    DWORD  dwCodeBase = 0;
-    CQuickBytes qb;
-
-    if (filename != NULL) {
-        WCHAR* pString;
-        int    iString;
-        filename->RefInterpretGetStringValuesDangerousForGC(&pString, &iString);
-        dwCodeBase = (DWORD) iString;
-        pCodeBase = (LPWSTR) qb.AllocThrows((++dwCodeBase) * sizeof(WCHAR));
-        memcpy(pCodeBase, pString, dwCodeBase*sizeof(WCHAR));
-    }
-
-    if(pCodeBase) {
-        CQuickBytes qb2;
-        DWORD dwEscaped = 1;
-
-        DWORD flags = 0;
-        if (RunningOnWin7())
-            flags |= URL_ESCAPE_AS_UTF8;
-
-        UrlEscape(pCodeBase, (LPWSTR) qb2.Ptr(), &dwEscaped, flags);
-
-        LPWSTR result = (LPWSTR)qb2.AllocThrows((++dwEscaped) * sizeof(WCHAR));
-        HRESULT hr = UrlEscape(pCodeBase, result, &dwEscaped, flags);
-
-        if (SUCCEEDED(hr))
-            rv = StringObject::NewString(result);
-        else
-            COMPlusThrowHR(hr);
-    }
-
-    HELPER_METHOD_FRAME_END();
-    return OBJECTREFToObject(rv);
-}
-FCIMPLEND
-#endif // !FEATURE_CORECLR
 
 FCIMPL4(void, AssemblyNameNative::Init, Object * refThisUNSAFE, OBJECTREF * pAssemblyRef, CLR_BOOL fForIntrospection, CLR_BOOL fRaiseResolveEvent)
 {
@@ -295,18 +235,7 @@ FCIMPL3(FC_BOOL_RET, AssemblyNameNative::ReferenceMatchesDefinition, AssemblyNam
     AssemblySpec defSpec;
     defSpec.InitializeSpec(&(pThread->m_MarshalAlloc), (ASSEMBLYNAMEREF*) &gc.pDef, fParse, FALSE);
 
-#ifdef FEATURE_FUSION
-    SafeComHolder<IAssemblyName> pRefName (NULL);
-    IfFailThrow(refSpec.CreateFusionName(&pRefName, FALSE));
-
-    SafeComHolder <IAssemblyName> pDefName (NULL);
-    IfFailThrow(defSpec.CreateFusionName(&pDefName, FALSE));
-
-    // Order matters: Ref->IsEqual(Def)
-    result = (S_OK == pRefName->IsEqual(pDefName, ASM_CMPF_IL_ALL));
-#else
     result=AssemblySpec::RefMatchesDef(&refSpec,&defSpec);
-#endif
     HELPER_METHOD_FRAME_END();
     FC_RETURN_BOOL(result);
 }
diff --git a/src/vm/assemblynamesconfigfactory.cpp b/src/vm/assemblynamesconfigfactory.cpp
deleted file mode 100644
index ed5da9679b..0000000000
--- a/src/vm/assemblynamesconfigfactory.cpp
+++ /dev/null
@@ -1,264 +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.
-// AssemblyNamesConfigFactory.cpp
-//
-
-//
-// 
-// Parses XML files and adding runtime entries to assembly list
-// Abstract, derived classes need to override AddAssemblyName
-#include "common.h"
-#include "common.h"
-#include <xmlparser.h>
-#include <objbase.h>
-#include "parse.h"
-#include "assemblynamesconfigfactory.h"
-
-
-#define ISWHITE(ch) ((ch) >= 0x09 && (ch) <= 0x0D || (ch) == 0x20)
-
-#define CONST_STRING_AND_LEN(str) str, NumItems(str)-1
-
-extern int EEXMLStringCompare(const WCHAR *pStr1, 
-                    DWORD cchStr1, 
-                    const WCHAR *pStr2, 
-                    DWORD cchStr2);
-extern HRESULT VersionFromString(LPCWSTR wzVersion, WORD *pwVerMajor, WORD *pwVerMinor,
-                          WORD *pwVerBld, WORD *pwVerRev);
-extern HRESULT MapProcessorArchitectureToPEKIND(LPCWSTR pwzProcArch, PEKIND *pe);
-
-AssemblyNamesConfigFactory::AssemblyNamesConfigFactory()
-{
-    LIMITED_METHOD_CONTRACT;
-    m_pAssemblyName = NULL;
-    m_bCurrentEntryInvalid = TRUE;
-    m_dwCurrentElementDepth = 0;
-    m_dwProperty = ASM_NAME_MAX_PARAMS;
-}
-
-AssemblyNamesConfigFactory::~AssemblyNamesConfigFactory()
-{
-    LIMITED_METHOD_CONTRACT;
-}
-
-
-HRESULT STDMETHODCALLTYPE AssemblyNamesConfigFactory::NotifyEvent( 
-            /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-            /* [in] */ XML_NODEFACTORY_EVENT iEvt)
-{
-    LIMITED_METHOD_CONTRACT;
-    
-    return S_OK;
-}
-
-HRESULT STDMETHODCALLTYPE AssemblyNamesConfigFactory::BeginChildren( 
-    /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-    /* [in] */ XML_NODE_INFO __RPC_FAR *pNodeInfo)
-{
-    LIMITED_METHOD_CONTRACT;
-    m_dwCurrentElementDepth ++;
-
-    return S_OK;
-}
-
-//---------------------------------------------------------------------------
-HRESULT STDMETHODCALLTYPE AssemblyNamesConfigFactory::EndChildren( 
-    /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-    /* [in] */ BOOL fEmptyNode,
-    /* [in] */ XML_NODE_INFO __RPC_FAR *pNodeInfo)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        INJECT_FAULT(return E_OUTOFMEMORY;);
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-    EX_TRY
-    {
-        if (m_dwCurrentElementDepth == 1 && m_pAssemblyName != NULL)
-        {
-            if (!m_bCurrentEntryInvalid)
-            {
-                // publish 
-                AddAssemblyName(m_pAssemblyName);
-            };
-            m_pAssemblyName->Release();
-            m_pAssemblyName = NULL;
-        }
-
-        if (!fEmptyNode)
-            m_dwCurrentElementDepth --;
-    }
-    EX_CATCH_HRESULT(hr);
-    return hr;
-}
-
-
-
-HRESULT STDMETHODCALLTYPE AssemblyNamesConfigFactory::CreateNode( 
-    /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-    /* [in] */ PVOID pNode,
-    /* [in] */ USHORT cNumRecs,
-    /* [in] */ XML_NODE_INFO* __RPC_FAR * __RPC_FAR apNodeInfo)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        INJECT_FAULT(return E_OUTOFMEMORY;);
-    }
-    CONTRACTL_END;
-
-    if(m_dwCurrentElementDepth > 1)
-        return S_OK;
-
-    HRESULT hr = S_OK;
-
-    for(DWORD i = 0; i < cNumRecs; i++) { 
-        CONTRACT_VIOLATION(ThrowsViolation); // Lots of stuff in here throws!
-        
-        if(apNodeInfo[i]->dwType == XML_ELEMENT ||
-           apNodeInfo[i]->dwType == XML_ATTRIBUTE ||
-           apNodeInfo[i]->dwType == XML_PCDATA) 
-        {
-
-            DWORD dwStringSize = apNodeInfo[i]->ulLen;
-            LPWSTR pszString = (WCHAR*) apNodeInfo[i]->pwcText;
-            // Trim the value
-
-            // we should never decrement lgth if it's 0, because it's unsigned
-
-            for(;*pszString && ISWHITE(*pszString) && dwStringSize>0; pszString++, dwStringSize--);
-            while( dwStringSize > 0 && ISWHITE(pszString[dwStringSize-1]))
-                   dwStringSize--;
-            switch(apNodeInfo[i]->dwType) 
-            {
-            case XML_ELEMENT : 
-                if(EEXMLStringCompare(pszString, dwStringSize, CONST_STRING_AND_LEN(W("assemblyIdentity"))) == 0) 
-                {
-                    // new entry 
-                    _ASSERTE(m_pAssemblyName == NULL);
-                    IfFailRet(CreateAssemblyNameObject(&m_pAssemblyName, NULL,0,NULL));
-                    m_bCurrentEntryInvalid = FALSE;
-                }
-                else
-                {
-                    m_bCurrentEntryInvalid = TRUE;
-                }
-
-                break;
-
-
-            case XML_ATTRIBUTE : 
-                if(m_bCurrentEntryInvalid)
-                    break;
-
-                if(EEXMLStringCompare(pszString, dwStringSize, CONST_STRING_AND_LEN(W("name"))) == 0) 
-                {
-                    m_dwProperty = ASM_NAME_NAME;
-                }
-                else
-                if(EEXMLStringCompare(pszString, dwStringSize, CONST_STRING_AND_LEN(W("version"))) == 0) 
-                {
-                    m_dwProperty = ASM_NAME_MAJOR_VERSION;
-                }
-                else
-                if(EEXMLStringCompare(pszString, dwStringSize, CONST_STRING_AND_LEN(W("publicKeyToken"))) == 0) 
-                {
-                    m_dwProperty = ASM_NAME_PUBLIC_KEY_TOKEN;
-                }
-                else
-                if(EEXMLStringCompare(pszString, dwStringSize, CONST_STRING_AND_LEN(W("processorArchitecture"))) == 0) 
-                {
-                    m_dwProperty = ASM_NAME_ARCHITECTURE;
-                }
-                else
-                {
-                    m_bCurrentEntryInvalid = TRUE;
-                }
-                break;
-
-
-            case XML_PCDATA : 
-                if(m_bCurrentEntryInvalid)
-                    break;
-
-                _ASSERTE(m_pAssemblyName!= NULL); // can only be null if m_bCurrentEntryInvalid
-                switch(m_dwProperty)
-                {
-                case ASM_NAME_NAME:
-                    {
-                        StackSString s(pszString,dwStringSize);
-                        // takes number of bytes, thus *2
-                        IfFailRet(m_pAssemblyName->SetProperty(ASM_NAME_NAME, LPCWSTR(s), (dwStringSize+1)*sizeof(WCHAR)));
-                    }
-                    break;
-                case ASM_NAME_MAJOR_VERSION:
-                    {
-                        StackSString s(pszString,dwStringSize);
-                        WORD  wVerMajor = 0;
-                        WORD  wVerMinor = 0;
-                        WORD  wVerBld = 0;
-                        WORD  wVerRev = 0;
-                        if (SUCCEEDED(VersionFromString(s, &wVerMajor, &wVerMinor, &wVerBld, &wVerRev)))
-                        {
-                            IfFailRet(m_pAssemblyName->SetProperty(ASM_NAME_MAJOR_VERSION, &wVerMajor, sizeof(WORD)));
-                            IfFailRet(m_pAssemblyName->SetProperty(ASM_NAME_MINOR_VERSION, &wVerMinor, sizeof(WORD)));
-                            IfFailRet(m_pAssemblyName->SetProperty(ASM_NAME_BUILD_NUMBER, &wVerBld, sizeof(WORD)));
-                            IfFailRet(m_pAssemblyName->SetProperty(ASM_NAME_REVISION_NUMBER, &wVerRev, sizeof(WORD)));
-                        }
-                        else
-                            m_bCurrentEntryInvalid = TRUE;
-
-                    }
-                    break;
-                case ASM_NAME_ARCHITECTURE:
-                    {
-                        StackSString s(pszString,dwStringSize);
-                        PEKIND PeKind = peNone;
-                        if(SUCCEEDED(MapProcessorArchitectureToPEKIND(s, &PeKind)))
-                        {
-                            IfFailRet(m_pAssemblyName->SetProperty(ASM_NAME_ARCHITECTURE, (LPBYTE) &PeKind, sizeof(PeKind)));
-                        }
-                        else
-                        {
-                            m_bCurrentEntryInvalid = TRUE;
-                        }
-
-                    }
-                    break;    
-                case ASM_NAME_PUBLIC_KEY_TOKEN:
-                    {
-                       if(EEXMLStringCompare(pszString, dwStringSize, CONST_STRING_AND_LEN(W("null"))) == 0) 
-                        {
-                            IfFailRet(m_pAssemblyName->SetProperty(ASM_NAME_NULL_PUBLIC_KEY_TOKEN, NULL, 0));
-                        }
-                        else
-                        {
-                            if (dwStringSize % 2 != 0)
-                                return FUSION_E_INVALID_NAME;
-
-                            DWORD cbProp = dwStringSize / 2;
-                            NewHolder<BYTE> pbProp = new BYTE[cbProp];
-                            CParseUtils::UnicodeHexToBin(pszString, dwStringSize, pbProp); //????
-                            IfFailRet(m_pAssemblyName->SetProperty(ASM_NAME_PUBLIC_KEY_TOKEN, pbProp, cbProp));
-                        }
-                        break;
-                    }
-
-                default:
-                    _ASSERTE(!"Invalid format");
-                    m_bCurrentEntryInvalid = TRUE;
-                    break;
-                }
-                break;
-            }
-
-        }
-    }
-    return S_OK;
-}
diff --git a/src/vm/assemblynamesconfigfactory.h b/src/vm/assemblynamesconfigfactory.h
deleted file mode 100644
index 234adb9208..0000000000
--- a/src/vm/assemblynamesconfigfactory.h
+++ /dev/null
@@ -1,72 +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.
-// AssemblyNamesConfigFactory.h
-//
-
-//
-// 
-// Parses XML files and adding runtime entries to assembly list
-// Abstract, derived classes need to override AddAssemblyName
-
-
-#ifndef ASSEMBLYNAMESCONFIGFACTORY_H
-#define ASSEMBLYNAMESCONFIGFACTORY_H
-
-#include "unknwn.h"
-#include "../xmlparser/_reference.h"
-#include "../xmlparser/_unknown.h"
-
-
-class AssemblyNamesConfigFactory : public _unknown<IXMLNodeFactory, &IID_IXMLNodeFactory>
-{
-
-public:
-    AssemblyNamesConfigFactory ();
-    ~AssemblyNamesConfigFactory ();
-    HRESULT STDMETHODCALLTYPE NotifyEvent( 
-            /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-            /* [in] */ XML_NODEFACTORY_EVENT iEvt);
-
-    HRESULT STDMETHODCALLTYPE BeginChildren( 
-        /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-        /* [in] */ XML_NODE_INFO* __RPC_FAR pNodeInfo);
-
-    HRESULT STDMETHODCALLTYPE EndChildren( 
-        /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-        /* [in] */ BOOL fEmptyNode,
-        /* [in] */ XML_NODE_INFO* __RPC_FAR pNodeInfo);
-    
-    HRESULT STDMETHODCALLTYPE Error( 
-        /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-        /* [in] */ HRESULT hrErrorCode,
-        /* [in] */ USHORT cNumRecs,
-        /* [in] */ XML_NODE_INFO* __RPC_FAR * __RPC_FAR apNodeInfo)
-    {
-        LIMITED_METHOD_CONTRACT;
-      /* 
-         UNUSED(pSource);
-         UNUSED(hrErrorCode);
-         UNUSED(cNumRecs);
-         UNUSED(apNodeInfo);
-      */
-        return hrErrorCode;
-    }
-    
-    HRESULT STDMETHODCALLTYPE CreateNode( 
-        /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-        /* [in] */ PVOID pNodeParent,
-        /* [in] */ USHORT cNumRecs,
-        /* [in] */ XML_NODE_INFO* __RPC_FAR * __RPC_FAR apNodeInfo);
-
-    virtual void AddAssemblyName(IAssemblyName*) = 0;
-protected:
-    IAssemblyName* m_pAssemblyName;
-    BOOL m_bCurrentEntryInvalid;
-    DWORD m_dwCurrentElementDepth;
-    DWORD m_dwProperty;
-
-};
-
-
-#endif
diff --git a/src/vm/assemblynative.cpp b/src/vm/assemblynative.cpp
index f372bcb349..8daa851c74 100644
--- a/src/vm/assemblynative.cpp
+++ b/src/vm/assemblynative.cpp
@@ -18,11 +18,6 @@
 
 #include <shlwapi.h>
 #include <stdlib.h>
-#ifdef FEATURE_FUSION
-#include "actasm.h"
-#include "appctx.h"
-#include "asm.h"
-#endif
 #include "assemblynative.hpp"
 #include "dllimport.h"
 #include "field.h"
@@ -34,108 +29,13 @@
 #include "frames.h"
 #include "typeparse.h"
 #ifdef FEATURE_REMOTING
-#include "appdomainhelper.h"
 #endif
 #include "stackprobe.h"
-#ifdef FEATURE_FUSION
-#include "dbglog.h"
-#include "bindinglog.hpp"
-#include "policy.h"
-#endif
 
-#ifdef FEATURE_CORECLR
 #include "appdomainnative.hpp"
 #include "../binder/inc/clrprivbindercoreclr.h"
-#endif // FEATURE_CORECLR
-
-#ifndef FEATURE_CORECLR
-#include "assemblynativeresource.h"
-#endif // !FEATURE_CORECLR
-
-#if !defined(FEATURE_CORECLR)
-#include "clrprivbinderloadfile.h" 
-#endif
-
-
-#ifdef FEATURE_FUSION
-//----------------------------------------------------------------------------------------------------
-// Allows managed code in mscorlib to find out whether an assembly name corresponds to mscorlib,
-// a .NET Framework assembly found in the unification list (see fxretarget.h), or a portable assembly (see portabilityPolicy.cpp)
-// See Fusion::Util::IsAnyFrameworkAssembly for more details.
-// The NGEN task uses this function (via System.Reflection.RuntimeAssembly.IsFrameworkAssembly)
-FCIMPL1(FC_BOOL_RET, AssemblyNative::IsFrameworkAssembly, AssemblyNameBaseObject* refAssemblyNameUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    struct _gc
-    {
-        ASSEMBLYNAMEREF assemblyName;
-    } gc;
-    gc.assemblyName = (ASSEMBLYNAMEREF) refAssemblyNameUNSAFE;
-
-    BOOL bIsFxAssembly = FALSE;
-
-    HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc);
-    AssemblySpec spec;
 
-    Thread *pThread = GetThread();
-    CheckPointHolder cph(pThread->m_MarshalAlloc.GetCheckpoint()); //hold checkpoint for autorelease
 
-    spec.InitializeSpec(&(pThread->m_MarshalAlloc), 
-                        &gc.assemblyName,
-                        FALSE, /*fIsStringized*/ 
-                        FALSE /*fForIntrospection*/
-                       );
-    ReleaseHolder<IAssemblyName> pIAssemblyName;
-    IfFailThrow(spec.CreateFusionName(&pIAssemblyName,FALSE));
-    
-    bIsFxAssembly = (IfFailThrow(Fusion::Util::IsAnyFrameworkAssembly(pIAssemblyName)) == S_OK);
-    HELPER_METHOD_FRAME_END();
-
-    FC_RETURN_BOOL(bIsFxAssembly);
-}
-FCIMPLEND
-#endif // FEATURE_FUSION
-
-#ifdef FEATURE_FUSION
-//----------------------------------------------------------------------------------------------------
-FCIMPL1(FC_BOOL_RET, AssemblyNative::IsNewPortableAssembly, AssemblyNameBaseObject* refAssemblyNameUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    struct _gc
-    {
-        ASSEMBLYNAMEREF assemblyName;
-    } gc;
-    gc.assemblyName = (ASSEMBLYNAMEREF) refAssemblyNameUNSAFE;
-
-    BOOL fIsPortable = FALSE;
-
-    HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc);
-
-    AssemblySpec spec;
-
-    Thread *pThread = GetThread();
-    CheckPointHolder cph(pThread->m_MarshalAlloc.GetCheckpoint()); //hold checkpoint for autorelease
-
-    {
-        GCX_COOP();
-        spec.InitializeSpec(&(pThread->m_MarshalAlloc), 
-                            &gc.assemblyName,
-                            FALSE, /*fIsStringized*/ 
-                            FALSE /*fForIntrospection*/);
-    }
-
-    ReleaseHolder<IAssemblyName> pIAssemblyName;
-    IfFailThrow(spec.CreateFusionName(&pIAssemblyName,FALSE));
-    
-    fIsPortable = (IfFailThrow(Fusion::Util::IsNewPortableAssembly(pIAssemblyName)) == S_OK);
-    HELPER_METHOD_FRAME_END();
-
-    FC_RETURN_BOOL(fIsPortable);
-}
-FCIMPLEND
-#endif // FEATURE_FUSION
 
 FCIMPL10(Object*, AssemblyNative::Load, AssemblyNameBaseObject* assemblyNameUNSAFE, 
         StringObject* codeBaseUNSAFE, 
@@ -243,7 +143,6 @@ FCIMPL10(Object*, AssemblyNative::Load, AssemblyNameBaseObject* assemblyNameUNSA
     if (pParentAssembly != NULL)
         spec.SetParentAssembly(pParentAssembly);
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)    
     // Have we been passed the reference to the binder against which this load should be triggered?
     // If so, then use it to set the fallback load context binder.
     if (ptrLoadContextBinder != NULL)
@@ -258,7 +157,6 @@ FCIMPL10(Object*, AssemblyNative::Load, AssemblyNameBaseObject* assemblyNameUNSA
         PEFile *pRefAssemblyManifestFile = pRefAssembly->GetManifestFile();
         spec.SetFallbackLoadContextBinderForRequestingAssembly(pRefAssemblyManifestFile->GetFallbackLoadContextBinder());
     }
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
     AssemblyLoadSecurity loadSecurity;
     loadSecurity.m_pAdditionalEvidence = &gc.security;
@@ -320,12 +218,6 @@ Assembly* AssemblyNative::LoadFromBuffer(BOOL fForIntrospection, const BYTE* pAs
     if (pAssemblyData == NULL)
         COMPlusThrow(kArgumentNullException, W("ArgumentNull_Array"));
 
-#ifndef FEATURE_CORECLR
-    // Event Tracing for Windows is used to log data for performance and functional testing purposes.
-    // The events in this function are used to help measure the performance of assembly loading as a whole when loading from a buffer.
-     FireEtwLoaderPhaseStart(GetAppDomain() ? GetAppDomain()->GetId().m_dwId : ETWAppDomainIdNotAvailable, ETWLoadContextNotAvailable, ETWFieldUnused, ETWLoaderDynamicLoad, NULL, NULL, GetClrInstanceId());
-#endif // FEATURE_CORECLR
-
     if (fForIntrospection) {
         if (!GetThread()->GetDomain()->IsVerificationDomain())
             GetThread()->GetDomain()->SetIllegalVerificationDomain();
@@ -347,35 +239,6 @@ Assembly* AssemblyNative::LoadFromBuffer(BOOL fForIntrospection, const BYTE* pAs
     if (pCallersAssembly == NULL) {
         pCallersAssembly = SystemDomain::System()->SystemAssembly();
     } else {
-#ifdef FEATURE_CAS_POLICY
-        // If no evidence was provided to the Assembly.Load(byte[]) call, 
-        // we want to inherit the evidence from the security context source
-        if (fPropagateIdentity) {
-            ISecurityDescriptor *pSecDesc = NULL;
-            if (securityContextSource == kCurrentAppDomain) {
-                pSecDesc = pCallersDomain->GetSecurityDescriptor();
-            }
-            else {
-                _ASSERTE(securityContextSource == kCurrentAssembly);
-                pSecDesc = pCallersAssembly->GetSecurityDescriptor(pCallersDomain);
-            }
-
-            ENTER_DOMAIN_PTR(pSecDesc->GetDomain(),ADV_RUNNINGIN)
-            {
-                gc.orefSecurity = pSecDesc->GetEvidence();
-            }
-            END_DOMAIN_TRANSITION;
-
-            // Caller may be in another appdomain context, in which case we'll
-            // need to marshal/unmarshal the evidence across.
-#ifdef FEATURE_REMOTING   // should not happenwithout remoting
-            if (pCallersDomain != GetAppDomain())
-                gc.orefSecurity = AppDomainHelper::CrossContextCopyFrom(pCallersDomain->GetId(), &gc.orefSecurity);
-#else
-            _ASSERTE(pCallersDomain == GetAppDomain());
-#endif
-        }
-#endif // FEATURE_CAS_POLICY
     }
 
     if ((COUNT_T)uAssemblyLength !=uAssemblyLength)  // overflow
@@ -388,13 +251,6 @@ Assembly* AssemblyNative::LoadFromBuffer(BOOL fForIntrospection, const BYTE* pAs
 
         CLRPrivBinderLoadFile* pBinderToUse = NULL;
 
-#if !defined(FEATURE_CORECLR)
-        if (GetAppDomain()->HasLoadContextHostBinder())
-        {
-            pBinderToUse = CLRPrivBinderLoadFile::GetOrCreateBinder();
-        }
-#endif // !FEATURE_CORECLR
-
         pFile = PEAssembly::OpenMemory(pCallersAssembly->GetManifestFile(),
                                                   pAssemblyData, (COUNT_T)uAssemblyLength, 
                                                   fForIntrospection,
@@ -409,35 +265,9 @@ Assembly* AssemblyNative::LoadFromBuffer(BOOL fForIntrospection, const BYTE* pAs
     {
         DWORD dwSpecialFlags = 0;
 
-#ifdef FEATURE_CAS_POLICY
-        if (securityContextSource == kCurrentAssembly)
-        {
-            IAssemblySecurityDescriptor *pCallersSecDesc = pCallersAssembly->GetSecurityDescriptor(pCallersDomain);
-            gc.granted = pCallersSecDesc->GetGrantedPermissionSet( &(gc.denied));
-            dwSpecialFlags = pCallersSecDesc->GetSpecialFlags();
-
-            // If we're going to inherit the grant set of an anonymously hosted dynamic method, it will be
-            // full trust/transparent. In that case, we should demand full trust.
-            if(pCallersAssembly != NULL && pCallersDomain != NULL && pCallersAssembly->GetDomainAssembly(pCallersDomain) == pCallersDomain->GetAnonymouslyHostedDynamicMethodsAssembly())
-            {
-                loadSecurity.m_fPropagatingAnonymouslyHostedDynamicMethodGrant = true;
-            }
-        }
-        else
-#endif // FEATURE_CAS_POLICY
         {
             IApplicationSecurityDescriptor *pDomainSecDesc = pCallersDomain->GetSecurityDescriptor();
 
-#ifdef FEATURE_CAS_POLICY
-            // We only want to propigate the identity of homogenous domains, since heterogenous domains tend
-            // to be fully trusted even if they are housing partially trusted code - which could lead to an
-            // elevation of privilege if we allow the grant set to be pushed to assemblies partially trusted
-            // code is loading.
-            if (!pDomainSecDesc->IsHomogeneous())
-            {
-                COMPlusThrow(kNotSupportedException, W("NotSupported_SecurityContextSourceAppDomainInHeterogenous"));
-            }
-#endif // FEATURE_CAS_POLICY
 
 
             gc.granted = pDomainSecDesc->GetGrantedPermissionSet();
@@ -504,9 +334,6 @@ Assembly* AssemblyNative::LoadFromBuffer(BOOL fForIntrospection, const BYTE* pAs
     }
 #endif // FEATURE_REFLECTION_ONLY_LOAD    
 
-#ifndef FEATURE_CORECLR
-    FireEtwLoaderPhaseEnd(GetAppDomain() ? GetAppDomain()->GetId().m_dwId : ETWAppDomainIdNotAvailable, ETWLoadContextNotAvailable, ETWFieldUnused, ETWLoaderDynamicLoad, NULL, NULL, GetClrInstanceId());
-#endif // FEATURE_CORECLR
     LOG((LF_CLASSLOADER, 
          LL_INFO100, 
          "\tLoaded in-memory module\n"));
@@ -585,12 +412,6 @@ FCIMPL6(Object*, AssemblyNative::LoadImage, U1Array* PEByteArrayUNSAFE,
         pAssembly = LoadFromBuffer(fForIntrospection, pbImage, cbImage, pbSyms, cbSyms, stackMark, OBJECTREFToObject(gc.security), securityContextSource);
     }
 
-#ifdef FEATURE_FUSION
-    if (!fForIntrospection && IsLoggingNeeded())
-    {
-        BinderLogging::BindingLog::LogLoadByteArray(GetAppDomain()->GetFusionContext(), pAssembly);
-    }
-#endif    
 
     if (pAssembly != NULL)
         gc.refRetVal = pAssembly->GetExposedObject();
@@ -626,67 +447,7 @@ FCIMPL2(Object*, AssemblyNative::LoadFile, StringObject* pathUNSAFE, Object* sec
     StackSString path;
     gc.strPath->GetSString(path);
 
-#ifdef FEATURE_FUSION // use BindResult for abstraction
-    // Event Tracing for Windows is used to log data for performance and functional testing purposes.
-    // The events in this function are used to help measure the performance of assembly loading as a whole when loading directly from a file,
-    // of binding to an assembly, as well as of lookup scenarios such as from a host store.
-    FireEtwLoaderPhaseStart(ETWAppDomainIdNotAvailable, ETWLoadContextNotAvailable, ETWFieldUnused, ETWLoaderDynamicLoad, path, NULL, GetClrInstanceId());
-    SafeComHolder<IAssembly> pFusionAssembly;
-    SafeComHolder<IBindResult> pNativeFusionAssembly;
-    SafeComHolder<IFusionBindLog> pFusionLog;
-
-    PEAssemblyHolder pFile;
-    FireEtwBindingPhaseStart(GetAppDomain() ? GetAppDomain()->GetId().m_dwId : ETWAppDomainIdNotAvailable, ETWLoadContextNotAvailable, ETWFieldUnused, ETWLoaderLoadTypeNotAvailable, path, NULL, GetClrInstanceId());
-    
-    if(GetAppDomain()->HasLoadContextHostBinder())
-    {
-        GCX_PREEMP();
-        CLRPrivBinderLoadFile* pLFBinder =  CLRPrivBinderLoadFile::GetOrCreateBinder();
-        ReleaseHolder<PEImage> pImage(PEImage::OpenImage(path));
-        ReleaseHolder<ICLRPrivAssembly> pAsm;
-        ReleaseHolder<IAssemblyName> pAssemblyName;
-        IfFailThrow(pLFBinder->BindAssemblyExplicit(pImage, &pAssemblyName, &pAsm));
-        IfFailThrow(GetAppDomain()->BindHostedPrivAssembly(nullptr, pAsm, pAssemblyName, &pFile));
-        _ASSERTE(pFile);
-    }
-    else
-    {
-        GCX_PREEMP();
-        IfFailThrow(ExplicitBind(path, GetAppDomain()->GetFusionContext(), 
-                                 EXPLICITBIND_FLAGS_NON_BINDABLE,
-                                 NULL, &pFusionAssembly, &pNativeFusionAssembly, &pFusionLog));
-        pFile.Assign(PEAssembly::Open(pFusionAssembly, pNativeFusionAssembly, pFusionLog, FALSE, FALSE));
-    }
-
-    FireEtwBindingLookupAndProbingPhaseEnd(GetAppDomain() ? GetAppDomain()->GetId().m_dwId : ETWAppDomainIdNotAvailable, ETWLoadContextNotAvailable, ETWFieldUnused, ETWLoaderLoadTypeNotAvailable, path, NULL, GetClrInstanceId());
-
-    FireEtwBindingPhaseEnd(GetAppDomain() ? GetAppDomain()->GetId().m_dwId : ETWAppDomainIdNotAvailable, ETWLoadContextNotAvailable, ETWFieldUnused, ETWLoaderLoadTypeNotAvailable, path, NULL, GetClrInstanceId());
-
-    AssemblyLoadSecurity loadSecurity;
-    loadSecurity.m_pAdditionalEvidence = &gc.refSecurity;
-    loadSecurity.m_fCheckLoadFromRemoteSource = true;
-
-    // If we're in an APPX domain, then all loads from the application will find themselves within the APPX package
-    // graph or from a trusted location.   However, assemblies within the package may have been marked by Windows as
-    // not being from the MyComputer zone, which can trip the LoadFromRemoteSources check.  Since we do not need to
-    // defend against accidental loads from HTTP for APPX applications, we simply suppress the remote load check.
-    if (AppX::IsAppXProcess())
-    {
-        loadSecurity.m_fCheckLoadFromRemoteSource = false;
-    }
-
-    Assembly *pAssembly = GetPostPolicyAssembly(pFile, FALSE, &loadSecurity);
-
-    FireEtwLoaderPhaseEnd(ETWAppDomainIdNotAvailable, ETWLoadContextNotAvailable, ETWFieldUnused, ETWLoaderDynamicLoad, path, NULL, GetClrInstanceId());
-    
-    if (IsLoggingNeeded())
-    {
-        BinderLogging::BindingLog::LogLoadFile(GetAppDomain()->GetFusionContext(), path, pAssembly);
-    }
-
-#else // FEATURE_FUSION
     Assembly *pAssembly = AssemblySpec::LoadAssembly(path);
-#endif // FEATURE_FUSION
 
     LOG((LF_CLASSLOADER, 
          LL_INFO100, 
@@ -702,7 +463,6 @@ FCIMPL2(Object*, AssemblyNative::LoadFile, StringObject* pathUNSAFE, Object* sec
 }
 FCIMPLEND
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
 /* static */
 Assembly* AssemblyNative::LoadFromPEImage(ICLRPrivBinder* pBinderContext, PEImage *pILImage, PEImage *pNIImage)
@@ -982,7 +742,6 @@ void QCALLTYPE AssemblyNative::LoadFromStream(INT_PTR ptrNativeAssemblyLoadConte
     END_QCALL;
 }
 
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
 /* static */
 Assembly* AssemblyNative::GetPostPolicyAssembly(PEAssembly *pFile,
@@ -1003,60 +762,6 @@ Assembly* AssemblyNative::GetPostPolicyAssembly(PEAssembly *pFile,
 
     GCX_PREEMP();
 
-#ifdef FEATURE_FUSION
-    if (!fForIntrospection && !GetAppDomain()->HasLoadContextHostBinder()) {
-        DWORD   dwSize = 0;
-        // if strongly named and not an exempt
-        BOOL bOptionallyRetargetable;
-
-        IfFailThrow(IsOptionallyRetargetableAssembly(pFile->GetFusionAssemblyName(), &bOptionallyRetargetable));
-        if ( !bOptionallyRetargetable && pFile->GetFusionAssemblyName()->GetProperty(ASM_NAME_PUBLIC_KEY_TOKEN, NULL, &dwSize) == HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)) {
-
-            SafeComHolder<IAssemblyName> pPostPolicyName(NULL);
-            HRESULT hr = PreBindAssembly(GetAppDomain()->GetFusionContext(),
-                                         pFile->GetFusionAssemblyName(), 
-                                         NULL,  // pAsmParent
-                                         &pPostPolicyName,
-                                         NULL); // pvReserved
-            if (FAILED(hr)) {
-                if (hr == FUSION_E_REF_DEF_MISMATCH) {
-                    // Policy redirects to another version
-                    AssemblySpec spec;
-                    spec.InitializeSpec(pPostPolicyName, FALSE);
-                    RETURN spec.LoadAssembly(FILE_LOADED, pLoadSecurity);
-                }
-                else
-                    ThrowHR(hr);
-            }
-            else {
-                ReleaseHolder<IAssembly> pAsm;
-
-                SafeComHolder<IAssemblyCache> pIAsmCache (NULL);
-                IfFailThrow(CreateAssemblyCache(&pIAsmCache, 0));
-                
-                DWORD dwFlags = ASM_DISPLAYF_FULL;
-
-                if (pFile->IsMarkedAsNoPlatform()) { // No Platform implies that the assembly is not tied to a specific machine architecture, which means we need to do full GAC probing.
-                    hr = CreateAssemblyFromCacheLookup(GetAppDomain()->GetFusionContext(), pFile->GetFusionAssemblyName(), TRUE, &pAsm, NULL);
-                }
-                else {
-                    SString sourceDisplay;
-                    FusionBind::GetAssemblyNameDisplayName(pFile->GetFusionAssemblyName(), sourceDisplay, dwFlags);
-                    hr = pIAsmCache->QueryAssemblyInfo(0, sourceDisplay, NULL);
-                }
-
-                if (SUCCEEDED(hr)) {
-                    // It's in the GAC
-                    AssemblySpec spec;
-                    spec.InitializeSpec(pFile->GetFusionAssemblyName(), FALSE);
-                    RETURN spec.LoadAssembly(FILE_LOADED, pLoadSecurity);
-                }
-                else if (hr != HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
-                    ThrowHR(hr);
-            }
-        }
-    }
-#else // FEATURE_FUSION
     if (fIsLoadByteArray)
     {
         PEImage *pPEImage = pFile->GetILimage();
@@ -1081,7 +786,6 @@ Assembly* AssemblyNative::GetPostPolicyAssembly(PEAssembly *pFile,
             ThrowHR(hr);
         }
     }   
-#endif // FEATURE_FUSION
 
     RETURN GetAppDomain()->LoadAssembly(NULL, pFile, FILE_LOADED, pLoadSecurity);
 }
@@ -1179,15 +883,6 @@ void QCALLTYPE AssemblyNative::GetLocation(QCall::AssemblyHandle pAssembly, QCal
 
     BEGIN_QCALL;
 
-#ifndef FEATURE_CORECLR
-    // workaround - lie about where mscorlib is. Mscorlib is now loaded out of the GAC, 
-    // but some apps query its location to find the system directory. (Notably system.web)
-    if (pAssembly->IsSystem())
-    {
-        retString.Set(SystemDomain::System()->BaseLibrary());
-    }
-    else
-#endif // !FEATURE_CORECLR
     {
         retString.Set(pAssembly->GetFile()->GetPath());
     }
@@ -1284,26 +979,6 @@ void QCALLTYPE AssemblyNative::GetPublicKey(QCall::AssemblyHandle pAssembly, QCa
     END_QCALL;
 }
 
-#if !FEATURE_CORECLR
-
-BYTE QCALLTYPE AssemblyNative::GetSecurityRuleSet(QCall::AssemblyHandle pAssembly)
-{
-    QCALL_CONTRACT;
-
-    SecurityRuleSet ruleSet = SecurityRuleSet_Default;
-
-    BEGIN_QCALL;
-
-    ModuleSecurityDescriptor *pMSD = ModuleSecurityDescriptor::GetModuleSecurityDescriptor(pAssembly->GetAssembly());
-    ruleSet = pMSD->GetSecurityRuleSet();
-
-    END_QCALL;
-
-    return static_cast<BYTE>(ruleSet);
-}
-
-#endif // !FEATURE_CORECLR
-
 void QCALLTYPE AssemblyNative::GetSimpleName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retSimpleName)
 {
     QCALL_CONTRACT;
@@ -1336,14 +1011,6 @@ void QCALLTYPE AssemblyNative::GetCodeBase(QCall::AssemblyHandle pAssembly, BOOL
 
     StackSString codebase;
 
-#ifndef FEATURE_CORECLR
-    if (pAssembly->IsSystem()) {
-        // workaround: lie about the location of mscorlib.  Some callers assume it is in the install dir.
-        codebase.Set(SystemDomain::System()->BaseLibrary());
-        PEAssembly::PathToUrl(codebase);
-    }
-    else 
-#endif // !FEATURE_CORECLR
     {
         pAssembly->GetFile()->GetCodeBase(codebase);
     }
@@ -1409,23 +1076,6 @@ BYTE * QCALLTYPE AssemblyNative::GetResource(QCall::AssemblyHandle pAssembly, LP
     return pbInMemoryResource;
 }
 
-#ifndef FEATURE_CORECLR
-
-BOOL QCALLTYPE AssemblyNative::UseRelativeBindForSatellites()
-{
-    QCALL_CONTRACT;
-
-    BOOL retVal = TRUE;
-
-    BEGIN_QCALL;
-    retVal  = CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_RelativeBindForResources);
-    END_QCALL;
-
-    return retVal;
-
-}
-#endif // !FEATURE_CORECLR
-
 INT32 QCALLTYPE AssemblyNative::GetManifestResourceInfo(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, QCall::ObjectHandleOnStack retAssembly, QCall::StringHandleOnStack retFileName, QCall::StackCrawlMarkHandle stackMark)
 {
     QCALL_CONTRACT;
@@ -1937,121 +1587,6 @@ void QCALLTYPE AssemblyNative::GetEntryPoint(QCall::AssemblyHandle pAssembly, QC
     return;
 }
 
-#ifndef FEATURE_CORECLR
-// prepare saving manifest to disk
-void QCALLTYPE AssemblyNative::PrepareForSavingManifestToDisk(QCall::AssemblyHandle pAssembly, QCall::ModuleHandle pAssemblyModule)
-{
-    QCALL_CONTRACT;
-    
-    BEGIN_QCALL;
-
-    pAssembly->GetAssembly()->PrepareSavingManifest((ReflectionModule *)(Module *)pAssemblyModule);
-
-    END_QCALL;
-}
-
-#endif    
-
-#ifndef FEATURE_CORECLR
-// add a file name to the file list of this assembly. On disk only.
-mdFile QCALLTYPE AssemblyNative::AddFile(QCall::AssemblyHandle pAssembly, LPCWSTR wszFileName)
-{
-    QCALL_CONTRACT;
-    
-    mdFile      retVal = 0;
-
-    BEGIN_QCALL;
-    
-    retVal = pAssembly->GetAssembly()->AddFile(wszFileName);
-
-    END_QCALL;
-
-    return retVal;
-}
-#endif //FEATURE_CORECLR   
-
-#ifndef FEATURE_CORECLR
-// set the hash value on a file.
-void QCALLTYPE AssemblyNative::SetFileHashValue(QCall::AssemblyHandle pAssembly, INT32 tkFile, LPCWSTR wszFullFileName)
-{
-    QCALL_CONTRACT;
-
-    BEGIN_QCALL;
-
-    pAssembly->GetAssembly()->SetFileHashValue(tkFile, wszFullFileName);
-
-    END_QCALL;
-}
-#endif //FEATURE_CORECLR   
-
-#ifndef FEATURE_CORECLR
-// Add a Type name to the ExportedType table in the on-disk assembly manifest.
-mdExportedType QCALLTYPE AssemblyNative::AddExportedTypeOnDisk(QCall::AssemblyHandle pAssembly, LPCWSTR wszCOMTypeName, INT32 tkImpl, INT32 tkTypeDef, INT32 flags)
-{
-    QCALL_CONTRACT;
-
-    mdExportedType  retVal = 0;
-
-    BEGIN_QCALL;
-    
-    retVal = pAssembly->GetAssembly()->AddExportedTypeOnDisk(wszCOMTypeName, tkImpl, tkTypeDef, (CorTypeAttr)flags);
-
-    END_QCALL;
-
-    return retVal;
-}
-
-// Add a Type name to the ExportedType table in the in-memory assembly manifest.
-mdExportedType QCALLTYPE AssemblyNative::AddExportedTypeInMemory(QCall::AssemblyHandle pAssembly, LPCWSTR wszCOMTypeName, INT32 tkImpl, INT32 tkTypeDef, INT32 flags)
-{
-    QCALL_CONTRACT;
-
-    mdExportedType  retVal = 0;
-
-    BEGIN_QCALL;
-    
-    retVal = pAssembly->GetAssembly()->AddExportedTypeInMemory(wszCOMTypeName, tkImpl, tkTypeDef, (CorTypeAttr)flags);
-
-    END_QCALL;
-
-    return retVal;
-}
-#endif //FEATURE_CORECLR   
-
-#ifndef FEATURE_CORECLR
-// add a Stand alone resource to ManifestResource table
-void QCALLTYPE AssemblyNative::AddStandAloneResource(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, LPCWSTR wszFileName, LPCWSTR wszFullFileName, INT32 iAttribute)
-{
-    QCALL_CONTRACT;
-
-    BEGIN_QCALL;
-
-    pAssembly->GetAssembly()->AddStandAloneResource(
-        wszName, 
-        NULL,
-        NULL,
-        wszFileName,
-        wszFullFileName,        
-        iAttribute); 
-
-    END_QCALL;
-}
-#endif //FEATURE_CORECLR   
-
-#ifndef FEATURE_CORECLR
-// Save security permission requests.
-void QCALLTYPE AssemblyNative::AddDeclarativeSecurity(QCall::AssemblyHandle pAssembly, INT32 action, PVOID blob, INT32 length)
-{
-    QCALL_CONTRACT;
-
-    BEGIN_QCALL;
-
-    pAssembly->GetAssembly()->AddDeclarativeSecurity(action, blob, length);
-
-    END_QCALL;
-}
-#endif //FEATURE_CORECLR   
-
 //---------------------------------------------------------------------------------------
 //
 // Get the raw bytes making up this assembly
@@ -2116,27 +1651,6 @@ extern void ManagedBitnessFlagsToUnmanagedBitnessFlags(
     INT32 portableExecutableKind, INT32 imageFileMachine,
     DWORD* pPeFlags, DWORD* pCorhFlags);
 
-#ifndef FEATURE_CORECLR
-void QCALLTYPE AssemblyNative::SaveManifestToDisk(QCall::AssemblyHandle pAssembly, 
-                                                  LPCWSTR wszManifestFileName,
-                                                  INT32 entrypoint, 
-                                                  INT32 fileKind, 
-                                                  INT32 portableExecutableKind, 
-                                                  INT32 imageFileMachine)
-{
-    QCALL_CONTRACT;
-    
-    BEGIN_QCALL;
-
-    DWORD peFlags = 0, corhFlags = 0;
-    ManagedBitnessFlagsToUnmanagedBitnessFlags(portableExecutableKind, imageFileMachine, &peFlags, &corhFlags);   
-
-    pAssembly->GetAssembly()->SaveManifestToDisk(wszManifestFileName, entrypoint, fileKind, corhFlags, peFlags);
-    
-    END_QCALL;
-}
-#endif // !FEATURE_CORECLR
-
 void QCALLTYPE AssemblyNative::GetFullName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString)
 {
     QCALL_CONTRACT;
@@ -2317,89 +1831,6 @@ FCIMPL1(ReflectModuleBaseObject *, AssemblyNative::GetInMemoryAssemblyModule, As
 }
 FCIMPLEND
 
-
-#ifndef FEATURE_CORECLR
-// Create a stand-alone resource file for version resource.
-void QCALLTYPE AssemblyNative::CreateVersionInfoResource(LPCWSTR    pwzFilename,
-                                                         LPCWSTR    pwzTitle,
-                                                         LPCWSTR    pwzIconFilename,
-                                                         LPCWSTR    pwzDescription,
-                                                         LPCWSTR    pwzCopyright,
-                                                         LPCWSTR    pwzTrademark,
-                                                         LPCWSTR    pwzCompany,
-                                                         LPCWSTR    pwzProduct,
-                                                         LPCWSTR    pwzProductVersion,
-                                                         LPCWSTR    pwzFileVersion,
-                                                         INT32 lcid,
-                                                         BOOL       fIsDll,
-                                                         QCall::StringHandleOnStack retFileName)
-{
-    QCALL_CONTRACT;
-
-    BEGIN_QCALL;
-
-    Win32Res    res;                    // Resource helper object.
-    const void  *pvData=0;              // Pointer to the resource.
-    ULONG       cbData;                 // Size of the resource data.
-    ULONG       cbWritten;
-    PathString       szFile;     // File name for resource file.
-    PathString       szPath;     // Path name for resource file.
-    HandleHolder hFile;
-
-    res.SetInfo(pwzFilename, 
-                pwzTitle, 
-                pwzIconFilename, 
-                pwzDescription, 
-                pwzCopyright, 
-                pwzTrademark,
-                pwzCompany, 
-                pwzProduct, 
-                pwzProductVersion, 
-                pwzFileVersion, 
-                lcid,
-                fIsDll);
-
-    res.MakeResFile(&pvData, &cbData);
-
-    //<TODO>Change the COMPlusThrowWin32's to exceptions with
-    // messages including the path/file name</TODO>
-
-    // Persist to a file.
-    if (!WszGetTempPath(szPath))
-        COMPlusThrowWin32();
-    if (!WszGetTempFileName(szPath.GetUnicode(), W("RES"), 0, szFile))
-        COMPlusThrowWin32();
-
-    hFile = WszCreateFile(szFile, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
-    if (hFile == INVALID_HANDLE_VALUE)
-        COMPlusThrowWin32();
-
-    if (!WriteFile(hFile, pvData, cbData, &cbWritten, NULL))
-        COMPlusThrowWin32();
-
-    retFileName.Set(szFile);
-
-    END_QCALL;
-}
-#endif // !FEATURE_CORECLR
-
-#ifndef FEATURE_CORECLR
-FCIMPL1(FC_BOOL_RET, AssemblyNative::IsGlobalAssemblyCache, AssemblyBaseObject* pAssemblyUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    ASSEMBLYREF refAssembly = (ASSEMBLYREF)ObjectToOBJECTREF(pAssemblyUNSAFE);
-    
-    if (refAssembly == NULL)
-        FCThrowRes(kArgumentNullException, W("Arg_InvalidHandle"));
-
-    DomainAssembly *pAssembly = refAssembly->GetDomainAssembly();
-
-    FC_RETURN_BOOL(pAssembly->GetFile()->IsSourceGAC());
-}
-FCIMPLEND
-#endif // !FEATURE_CORECLR
-
 void QCALLTYPE AssemblyNative::GetImageRuntimeVersion(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString)
 {
     QCALL_CONTRACT;
@@ -2414,9 +1845,6 @@ void QCALLTYPE AssemblyNative::GetImageRuntimeVersion(QCall::AssemblyHandle pAss
     IfFailThrow(pPEFile->GetMDImport()->GetVersionString(&pszVersion));
 
     SString version(SString::Utf8, pszVersion);
- #ifndef FEATURE_CORECLR   
-    AdjustImageRuntimeVersion(&version);
-#endif // FEATURE_CORECLR   
 
     // Allocate a managed string that contains the version and return it.
     retString.Set(version);
@@ -2424,44 +1852,7 @@ void QCALLTYPE AssemblyNative::GetImageRuntimeVersion(QCall::AssemblyHandle pAss
     END_QCALL;
 }
 
-#ifdef FEATURE_FUSION
-INT64 QCALLTYPE AssemblyNative::GetHostContext(QCall::AssemblyHandle pAssembly)
-{
-    QCALL_CONTRACT;
-
-    UINT64 Context = 0;
 
-    BEGIN_QCALL;
-
-    IHostAssembly *pIHostAssembly = pAssembly->GetFile()->GetIHostAssembly();
-    if (pIHostAssembly != NULL)
-    {
-        IfFailThrow(pIHostAssembly->GetAssemblyContext(&Context));
-    }
-
-    END_QCALL;
-
-    return Context;
-}
-#endif // FEATURE_FUSION
-
-#ifdef FEATURE_CAS_POLICY
-BOOL QCALLTYPE AssemblyNative::IsStrongNameVerified(QCall::AssemblyHandle pAssembly)
-{
-    QCALL_CONTRACT;
-
-    BOOL fStrongNameVerified = FALSE;
-
-    BEGIN_QCALL;
-
-    PEFile *pPEFile = pAssembly->GetFile();
-    fStrongNameVerified = pPEFile->IsStrongNameVerified();
-
-    END_QCALL;
-
-    return fStrongNameVerified;
-}
-#endif // FEATURE_CAS_POLICY
 
 #ifdef FEATURE_APPX
 /*static*/
@@ -2482,7 +1873,6 @@ BOOL QCALLTYPE AssemblyNative::IsDesignerBindingContext(QCall::AssemblyHandle pA
 }
 #endif // FEATURE_APPX
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 /*static*/
 INT_PTR QCALLTYPE AssemblyNative::InitializeAssemblyLoadContext(INT_PTR ptrManagedAssemblyLoadContext, BOOL fRepresentsTPALoadContext)
 {
@@ -2641,7 +2031,6 @@ INT_PTR QCALLTYPE AssemblyNative::GetLoadContextForAssembly(QCall::AssemblyHandl
     
     return ptrManagedAssemblyLoadContext;
 }
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
 // static
 BOOL QCALLTYPE AssemblyNative::InternalTryGetRawMetadata(
diff --git a/src/vm/assemblynative.hpp b/src/vm/assemblynative.hpp
index 99f51e9837..ece8100e95 100644
--- a/src/vm/assemblynative.hpp
+++ b/src/vm/assemblynative.hpp
@@ -74,10 +74,6 @@ public:
     static
     INT32 QCALLTYPE GetHashAlgorithm(QCall::AssemblyHandle pAssembly);
 
-#ifndef FEATURE_CORECLR
-    static
-    BYTE QCALLTYPE GetSecurityRuleSet(QCall::AssemblyHandle pAssembly);
-#endif // !FEATURE_CORECLR
 
     static 
     void QCALLTYPE GetSimpleName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retSimpleName);
@@ -149,10 +145,6 @@ public:
     static FCDECL1(ReflectModuleBaseObject *, GetOnDiskAssemblyModule, AssemblyBaseObject * pAssemblyUNSAFE);
     static FCDECL1(ReflectModuleBaseObject *, GetInMemoryAssemblyModule, AssemblyBaseObject * pAssemblyUNSAFE);
 
-#ifndef FEATURE_CORECLR
-    static 
-    FCDECL1(FC_BOOL_RET, IsGlobalAssemblyCache, AssemblyBaseObject* pAssemblyUNSAFE);
-#endif // !FEATURE_CORECLR
 
     static
     void QCALLTYPE GetGrantSet(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retGranted, QCall::ObjectHandleOnStack retDenied);
@@ -175,10 +167,6 @@ public:
     static
     INT64 QCALLTYPE GetHostContext(QCall::AssemblyHandle pAssembly);
 
-#ifdef FEATURE_CAS_POLICY
-    static
-    BOOL QCALLTYPE IsStrongNameVerified(QCall::AssemblyHandle pAssembly);
-#endif // FEATURE_CAS_POLICY
 
     //
     // AssemblyBuilder FCALLs
@@ -187,22 +175,6 @@ public:
     static
     void QCALLTYPE PrepareForSavingManifestToDisk(QCall::AssemblyHandle pAssembly, QCall::ModuleHandle pAssemblyModule);
 
-#ifndef FEATURE_CORECLR    
-    static
-    void QCALLTYPE SaveManifestToDisk(QCall::AssemblyHandle pAssembly,
-                                      LPCWSTR           wszManifestFileName, 
-                                      INT32             entrypoint, 
-                                      INT32             fileKind, 
-                                      INT32             portableExecutableKind, 
-                                      INT32             imageFileMachine);
-
-    static 
-    mdExportedType QCALLTYPE AddExportedTypeOnDisk(QCall::AssemblyHandle pAssembly, LPCWSTR wzzCOMTypeName, INT32 tkImpl, INT32 tkTypeDef, INT32 flags);
-
-    static 
-    mdExportedType QCALLTYPE AddExportedTypeInMemory(QCall::AssemblyHandle pAssembly, LPCWSTR wzzCOMTypeName, INT32 tkImpl, INT32 tkTypeDef, INT32 flags);
-
-#endif // FEATURE_CORECLR
 
     static
     mdFile QCALLTYPE AddFile(QCall::AssemblyHandle pAssembly, LPCWSTR wszFileName);
@@ -216,22 +188,6 @@ public:
     static
     void QCALLTYPE AddDeclarativeSecurity(QCall::AssemblyHandle pAssembly, INT32 action, PVOID blob, INT32 length);
 
-#ifndef FEATURE_CORECLR
-    static 
-    void QCALLTYPE CreateVersionInfoResource(LPCWSTR    pwzFilename,
-                                             LPCWSTR    pwzTitle,
-                                             LPCWSTR    pwzIconFilename,
-                                             LPCWSTR    pwzDescription,
-                                             LPCWSTR    pwzCopyright,
-                                             LPCWSTR    pwzTrademark,
-                                             LPCWSTR    pwzCompany,
-                                             LPCWSTR    pwzProduct,
-                                             LPCWSTR    pwzProductVersion,
-                                             LPCWSTR    pwzFileVersion,
-                                             INT32      lcid,
-                                             BOOL       fIsDll,
-                                             QCall::StringHandleOnStack retFileName);
-#endif // !FEATURE_CORECLR
 
     static
     void QCALLTYPE GetRawBytes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retRawBytes);
diff --git a/src/vm/assemblysink.cpp b/src/vm/assemblysink.cpp
deleted file mode 100644
index 8fe33f5bf4..0000000000
--- a/src/vm/assemblysink.cpp
+++ /dev/null
@@ -1,153 +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.
-
-/*============================================================
-**
-** Header:  AssemblySink.cpp
-**
-** Purpose: Implements AssemblySink, event objects that block
-**          the current thread waiting for an asynchronous load
-**          of an assembly to succeed.
-**
-**
-
-
-**
-===========================================================*/
-
-#include "common.h"
-#ifdef FEATURE_FUSION
-#include <stdlib.h>
-#include "assemblysink.h"
-#include "assemblyspec.hpp"
-#include "corpriv.h"
-#include "appdomain.inl"
-
-AssemblySink::AssemblySink(AppDomain* pDomain) 
-{
-    WRAPPER_NO_CONTRACT;
-    m_Domain=pDomain->GetId();
-    m_pSpec=NULL;
-    m_CheckCodebase = FALSE;
-}
-
-void AssemblySink::Reset()
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    m_CheckCodebase = FALSE;
-    FusionSink::Reset();
-}
-
-ULONG AssemblySink::Release()
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        NOTHROW;
-        if (GetThread()) {GC_TRIGGERS;} else {DISABLED(GC_TRIGGERS);}
-        MODE_ANY;
-        PRECONDITION(CheckPointer(this));
-    } CONTRACTL_END;
-    
-    
-    ULONG   cRef = InterlockedDecrement(&m_cRef);
-    if (!cRef) {
-        Reset();
-        AssemblySink* ret = this;
-        // If we have a domain we keep a pool of one around. If we get an entry
-        // back from the pool then we were not added to the pool and need to be deleted.
-        // If we do not have a pool then we need to delete it.
-        
-        
-
-
-        // TODO: SetupThread may throw.  What do we do with Release?
-        HRESULT hr = S_OK;
-        SetupThreadNoThrow(&hr);
-        {
-            GCX_COOP();
-        
-            if(m_Domain.m_dwId) {
-                AppDomainFromIDHolder AD(m_Domain, TRUE);
-                if (!AD.IsUnloaded())
-                     ret = FastInterlockCompareExchangePointer(&(AD->m_pAsyncPool),
-                                                               this,
-                                                               NULL);
-
-            }
-        }
-
-        if(ret != NULL) 
-            delete this;
-    }
-    return (cRef);
-}
-
-
-
-STDMETHODIMP AssemblySink::OnProgress(DWORD dwNotification,
-                                      HRESULT hrNotification,
-                                      LPCWSTR szNotification,
-                                      DWORD dwProgress,
-                                      DWORD dwProgressMax,
-                                      LPVOID pvBindInfo,
-                                      IUnknown* punk)
-{
-    STATIC_CONTRACT_NOTHROW;
-
-    HRESULT hr = S_OK;
-
-    switch(dwNotification) {
-
-    case ASM_NOTIFICATION_BIND_INFO:
-        FusionBindInfo          *pBindInfo;
-
-        pBindInfo = (FusionBindInfo *)pvBindInfo;
-
-        if (pBindInfo && pBindInfo->pNamePolicy && m_pSpec) {
-            pBindInfo->pNamePolicy->AddRef();
-            m_pSpec->SetNameAfterPolicy(pBindInfo->pNamePolicy);
-        }
-        break;
-
-    default:
-        break;
-    }
-
-    if (SUCCEEDED(hr))
-        hr = FusionSink::OnProgress(dwNotification, hrNotification, szNotification, 
-                                    dwProgress, dwProgressMax, pvBindInfo, punk);
-
-    return hr;
-}
-
-
-HRESULT AssemblySink::Wait()
-{
-    STATIC_CONTRACT_NOTHROW;
-
-    HRESULT hr = FusionSink::Wait();
-
-    if (FAILED(hr)) {
-        // If we get an exception then we will just release this sink. It may be the
-        // case that the appdomain was terminated. Other exceptions will cause the
-        // sink to be scavenged but this is ok. A new one will be generated for the
-        // next bind.
-        m_Domain.m_dwId = 0;
-        // The AssemblySpec passed is stack allocated in some cases.
-        // Remove reference to it to prevent AV in delayed fusion bind notifications.
-        m_pSpec = NULL;
-    }
-
-    return hr;
-}
-#endif
diff --git a/src/vm/assemblysink.h b/src/vm/assemblysink.h
deleted file mode 100644
index 9293a65b11..0000000000
--- a/src/vm/assemblysink.h
+++ /dev/null
@@ -1,59 +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.
-
-/*============================================================
-**
-** Header:  AssemblySink.hpp
-**
-** Purpose: Asynchronous call back for loading classes
-**
-**
-
-
-**
-===========================================================*/
-#ifndef _ASSEMBLYSINK_H
-#define _ASSEMBLYSINK_H
-
-#ifndef FEATURE_FUSION
-#error FEATURE_FUSION is not enabled, please do not include assemblysink.h
-#endif
-
-class AppDomain;
-
-class AssemblySink : public FusionSink
-{
-public:
-    AssemblySink(AppDomain* pDomain);
-    ~AssemblySink() { WRAPPER_NO_CONTRACT; };
-
-    void Reset();
-
-    ULONG STDMETHODCALLTYPE Release(void);
-
-    STDMETHODIMP OnProgress(DWORD dwNotification,
-                            HRESULT hrNotification,
-                            LPCWSTR szNotification,
-                            DWORD dwProgress,
-                            DWORD dwProgressMax,
-                            LPVOID pvBindInfo,
-                            IUnknown* punk);
-
-    virtual HRESULT Wait();
-
-    void RequireCodebaseSecurityCheck() {LIMITED_METHOD_CONTRACT;  m_CheckCodebase = TRUE;}
-    BOOL DoCodebaseSecurityCheck() {LIMITED_METHOD_CONTRACT;  return m_CheckCodebase;}
-    void SetAssemblySpec(AssemblySpec* pSpec) 
-    {
-        LIMITED_METHOD_CONTRACT; 
-        m_pSpec=pSpec;
-    }
-
-private:
-    ADID m_Domain; // Which domain (index) do I belong to
-    AssemblySpec* m_pSpec;
-    BOOL m_CheckCodebase;
-};
-
-#endif
diff --git a/src/vm/assemblyspec.cpp b/src/vm/assemblyspec.cpp
index 2b4b1fb480..13b1992b4a 100644
--- a/src/vm/assemblyspec.cpp
+++ b/src/vm/assemblyspec.cpp
@@ -18,21 +18,11 @@
 
 #include <stdlib.h>
 
-#ifdef FEATURE_FUSION
-#include "actasm.h"
-#include "appctx.h"
-#endif
 #include "assemblyspec.hpp"
 #include "security.h"
 #include "eeconfig.h"
 #include "strongname.h"
 #include "strongnameholders.h"
-#ifdef FEATURE_FUSION
-#include "assemblysink.h"
-#include "dbglog.h"
-#include "bindinglog.hpp"
-#include "assemblyfilehash.h"
-#endif
 #include "mdaassistants.h"
 #include "eventtrace.h"
 
@@ -252,13 +242,6 @@ HRESULT AssemblySpec::InitializeSpecInternal(mdToken kAssemblyToken,
         if (pStaticParent != NULL)
         {
             // We dont validate this for CoreCLR as there is no good use-case for this scenario.
-#if !defined(FEATURE_CORECLR)        
-            // It is OK for signed assemblies to reference WinRT assemblies (.winmd files) that are not signed
-            if (!IsContentType_WindowsRuntime() && pStaticParent->GetFile()->IsStrongNamed() && !IsStrongNamed())
-            {
-                ThrowHR(FUSION_E_PRIVATE_ASM_DISALLOWED);
-            }
-#endif // !defined(FEATURE_CORECLR)
             
             SetParentAssembly(pStaticParent);
         }
@@ -268,41 +251,6 @@ HRESULT AssemblySpec::InitializeSpecInternal(mdToken kAssemblyToken,
     return hr;
 } // AssemblySpec::InitializeSpecInternal
 
-#ifdef FEATURE_FUSION
-void AssemblySpec::InitializeSpec(IAssemblyName *pName,
-                                  DomainAssembly *pStaticParent /*=NULL*/ ,
-                                  BOOL fIntrospectionOnly /*=FALSE*/  )
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        GC_TRIGGERS;
-        THROWS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    // Normalize this boolean as it tends to be used for comparisons
-    m_fIntrospectionOnly = !!fIntrospectionOnly;
-    IfFailThrow(Init(pName));
-
-    // For static binds, we cannot reference a strongly named assembly from a weakly named one.
-    // (Note that this constraint doesn't apply to dynamic binds which is why this check is
-    // not farther down the stack.)
-
-    if (pStaticParent != NULL) {
-        if (pStaticParent->GetFile()->IsStrongNamed() && !IsStrongNamed())
-        {
-            EEFileLoadException::Throw(this, FUSION_E_PRIVATE_ASM_DISALLOWED);
-        }
-        SetParentAssembly(pStaticParent);
-    }
-
-    // Extract embedded WinRT name, if present.
-    ParseEncodedName();
-}
-#endif //FEATURE_FUSION
 
 #ifdef FEATURE_MIXEDMODE
 void AssemblySpec::InitializeSpec(HMODULE hMod,
@@ -378,7 +326,6 @@ void AssemblySpec::InitializeSpec(PEAssembly * pFile)
     }
 #endif //FEATURE_COMINTEROP
 
-#if defined(FEATURE_CORECLR)
     // Set the binding context for the AssemblySpec
     ICLRPrivBinder* pCurrentBinder = GetBindingContext();
     ICLRPrivBinder* pExpectedBinder = pFile->GetBindingContext();
@@ -391,152 +338,11 @@ void AssemblySpec::InitializeSpec(PEAssembly * pFile)
         _ASSERTE((pExpectedBinder != NULL) || pFile->IsSystem() || pFile->IsDynamic());
         SetBindingContext(pExpectedBinder);
     }
-#endif // defined(FEATURE_CORECLR)
 }
 
 #ifndef CROSSGEN_COMPILE
 
 // This uses thread storage to allocate space. Please use Checkpoint and release it.
-#ifdef FEATURE_FUSION
-HRESULT AssemblySpec::InitializeSpec(StackingAllocator* alloc, ASSEMBLYNAMEREF* pName, 
-                                  BOOL fParse /*=TRUE*/, BOOL fIntrospectionOnly /*=FALSE*/)
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        THROWS;
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-        PRECONDITION(CheckPointer(alloc));
-        PRECONDITION(CheckPointer(pName));
-        PRECONDITION(IsProtectedByGCFrame(pName));
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    // Simple name
-    if ((*pName)->GetSimpleName() != NULL) {
-        WCHAR* pString;
-        int    iString;
-        ((STRINGREF) (*pName)->GetSimpleName())->RefInterpretGetStringValuesDangerousForGC(&pString, &iString);
-        DWORD lgth = WszWideCharToMultiByte(CP_UTF8, 0, pString, iString, NULL, 0, NULL, NULL);
-        if (lgth + 1 < lgth)
-            ThrowHR(E_INVALIDARG);
-        LPSTR lpName = (LPSTR) alloc->Alloc(S_UINT32(lgth) + S_UINT32(1));
-        WszWideCharToMultiByte(CP_UTF8, 0, pString, iString,
-                               lpName, lgth+1, NULL, NULL);
-        lpName[lgth] = '\0';
-        m_pAssemblyName = lpName;
-    }
-
-    if (fParse) {
-        HRESULT hr = ParseName();
-        // Sometimes Fusion flags invalid characters in the name, sometimes it doesn't
-        // depending on where the invalid characters are
-        // We want to Raise the assembly resolve event on all invalid characters
-        // but calling ParseName before checking for invalid characters gives Fusion a chance to
-        // parse the rest of the name (to get a public key token, etc.)
-        if ((hr == FUSION_E_INVALID_NAME) || (!IsValidAssemblyName())) {
-            // This is the only case where we do not throw on an error
-            // We don't want to throw so as to give the caller a chance to call RaiseAssemblyResolveEvent
-            // The only caller that cares is System.Reflection.Assembly.InternalLoad which calls us through
-            // AssemblyNameNative::Init
-            return FUSION_E_INVALID_NAME;
-        }
-        else
-            IfFailThrow(hr);
-    }
-    else {
-        // Flags
-        m_dwFlags = (*pName)->GetFlags();
-    
-        // Version
-        VERSIONREF version = (VERSIONREF) (*pName)->GetVersion();
-        if(version == NULL) {
-            m_context.usMajorVersion = (USHORT)-1;
-            m_context.usMinorVersion = (USHORT)-1;
-            m_context.usBuildNumber = (USHORT)-1;
-            m_context.usRevisionNumber = (USHORT)-1;
-        }
-        else {
-            m_context.usMajorVersion = (USHORT)version->GetMajor();
-            m_context.usMinorVersion = (USHORT)version->GetMinor();
-            m_context.usBuildNumber = (USHORT)version->GetBuild();
-            m_context.usRevisionNumber = (USHORT)version->GetRevision();
-        }
-
-        m_context.szLocale = 0;
-
-        if ((*pName)->GetCultureInfo() != NULL) 
-        {
-            struct _gc {
-                OBJECTREF   cultureinfo;
-                STRINGREF   pString;
-            } gc;
-
-            gc.cultureinfo = (*pName)->GetCultureInfo();
-            gc.pString = NULL;
-            
-            GCPROTECT_BEGIN(gc);
-
-            MethodDescCallSite getName(METHOD__CULTURE_INFO__GET_NAME, &gc.cultureinfo);
-            
-            ARG_SLOT args[] = {
-                ObjToArgSlot(gc.cultureinfo)
-            };
-            gc.pString = getName.Call_RetSTRINGREF(args);
-            if (gc.pString != NULL) {
-                WCHAR* pString;
-                int    iString;
-                gc.pString->RefInterpretGetStringValuesDangerousForGC(&pString, &iString);
-                DWORD lgth = WszWideCharToMultiByte(CP_UTF8, 0, pString, iString, NULL, 0, NULL, NULL);
-                LPSTR lpLocale = (LPSTR) alloc->Alloc(S_UINT32(lgth) + S_UINT32(1));
-                WszWideCharToMultiByte(CP_UTF8, 0, pString, iString,
-                                       lpLocale, lgth+1, NULL, NULL);
-                lpLocale[lgth] = '\0';
-                m_context.szLocale = lpLocale;
-            }
-            GCPROTECT_END();
-        }
-
-        // Strong name
-        // Note that we prefer to take a public key token if present,
-        // even if flags indicate a full public key
-        if ((*pName)->GetPublicKeyToken() != NULL) {
-            m_dwFlags &= ~afPublicKey;
-            PBYTE  pArray = NULL;
-            pArray = (*pName)->GetPublicKeyToken()->GetDirectPointerToNonObjectElements();
-            m_cbPublicKeyOrToken = (*pName)->GetPublicKeyToken()->GetNumComponents();
-            m_pbPublicKeyOrToken = new (alloc) BYTE[m_cbPublicKeyOrToken];
-            memcpy(m_pbPublicKeyOrToken, pArray, m_cbPublicKeyOrToken);
-        }
-        else if ((*pName)->GetPublicKey() != NULL) {
-            m_dwFlags |= afPublicKey;
-            PBYTE  pArray = NULL;
-            pArray = (*pName)->GetPublicKey()->GetDirectPointerToNonObjectElements();
-            m_cbPublicKeyOrToken = (*pName)->GetPublicKey()->GetNumComponents();
-            m_pbPublicKeyOrToken = new (alloc) BYTE[m_cbPublicKeyOrToken]; 
-            memcpy(m_pbPublicKeyOrToken, pArray, m_cbPublicKeyOrToken);
-        }
-    }
-
-    // Hash for control 
-    // <TODO>@TODO cts, can we use unsafe in this case!!!</TODO>
-    if ((*pName)->GetHashForControl() != NULL)
-        SetHashForControl((*pName)->GetHashForControl()->GetDataPtr(), 
-                          (*pName)->GetHashForControl()->GetNumComponents(), 
-                          (*pName)->GetHashAlgorithmForControl());
-
-    // Normalize this boolean as it tends to be used for comparisons
-    m_fIntrospectionOnly = !!fIntrospectionOnly;
-
-    // Extract embedded WinRT name, if present.
-    ParseEncodedName();
-
-    return S_OK;
-}
-
-#else // FEATURE_FUSION
 HRESULT AssemblySpec::InitializeSpec(StackingAllocator* alloc, ASSEMBLYNAMEREF* pName, 
                                   BOOL fParse /*=TRUE*/, BOOL fIntrospectionOnly /*=FALSE*/)
 {
@@ -696,7 +502,6 @@ HRESULT AssemblySpec::InitializeSpec(StackingAllocator* alloc, ASSEMBLYNAMEREF*
 
     return S_OK;
 }
-#endif // FEATURE_FUSION
 
 void AssemblySpec::AssemblyNameInit(ASSEMBLYNAMEREF* pAsmName, PEImage* pImageInfo)
 {
@@ -860,213 +665,6 @@ void AssemblySpec::SetCodeBase(StackingAllocator* alloc, STRINGREF *pCodeBase)
 
 #endif // CROSSGEN_COMPILE
 
-#ifdef FEATURE_FUSION
-
-/* static */
-void AssemblySpec::DemandFileIOPermission(PEAssembly *pFile)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pFile));
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    // should have already checked permission if the codebase is set
-    if (!GetCodeBase()) { 
-
-        if (pFile->IsBindingCodeBase()) {
-            if (pFile->IsSourceDownloadCache()) {
-                StackSString check;
-                pFile->GetCodeBase(check);
-
-                DemandFileIOPermission(check, FALSE, FILE_WEBPERM);
-            }
-            else
-                DemandFileIOPermission(pFile->GetPath(), TRUE, FILE_READANDPATHDISC);
-        }
-    }
-}
-
-STDAPI RuntimeCheckLocationAccess(LPCWSTR wszLocation)
-{
-
-    if (GetThread()==NULL)
-        return S_FALSE;
-
-    CONTRACTL
-    {
-        NOTHROW;
-        MODE_ANY;
-        GC_TRIGGERS;
-        PRECONDITION(CheckPointer(wszLocation));
-    }
-    CONTRACTL_END;
-    OVERRIDE_LOAD_LEVEL_LIMIT(FILE_ACTIVE);
-    HRESULT hr=S_OK;
-    DWORD dwDemand = 0;
-
-    if (SString::_wcsnicmp(wszLocation, W("file"), 4))
-        dwDemand = AssemblySpec::FILE_WEBPERM;
-    else
-        dwDemand = AssemblySpec::FILE_READANDPATHDISC;
-
-    EX_TRY
-    {
-        AssemblySpec::DemandFileIOPermission(wszLocation,
-                                             FALSE,
-                                             dwDemand);
-    }
-    EX_CATCH_HRESULT(hr);
-    return hr;
-
-}
-
-/* static */
-void AssemblySpec::DemandFileIOPermission(LPCWSTR wszCodeBase,
-                                          BOOL fHavePath,
-                                          DWORD dwDemandFlag)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(wszCodeBase));
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    GCX_COOP();
-        
-    MethodDescCallSite demandPermission(METHOD__ASSEMBLY__DEMAND_PERMISSION);
-
-    STRINGREF codeBase = NULL;
-    GCPROTECT_BEGIN(codeBase);
-            
-    codeBase = StringObject::NewString(wszCodeBase);
-    ARG_SLOT args[3] = 
-    {
-        ObjToArgSlot(codeBase),
-        BoolToArgSlot(fHavePath),
-        dwDemandFlag
-    };
-    demandPermission.Call(args);
-    GCPROTECT_END();
-}
-
-BOOL AssemblySpec::FindAssemblyFile(AppDomain* pAppDomain, BOOL fThrowOnFileNotFound,
-                                    IAssembly** ppIAssembly, IHostAssembly **ppIHostAssembly, IBindResult** ppNativeFusionAssembly,
-                                    IFusionBindLog** ppFusionLog, HRESULT *pHRBindResult, StackCrawlMark *pCallerStackMark /* = NULL */,
-                                    AssemblyLoadSecurity *pLoadSecurity /* = NULL */)
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pAppDomain));
-        PRECONDITION(CheckPointer(pHRBindResult));
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    GCX_PREEMP();
-
-    IApplicationContext *pFusionContext = pAppDomain->GetFusionContext();
-
-    AssemblySink* pSink = pAppDomain->AllocateAssemblySink(this);
-    SafeComHolderPreemp<IAssemblyBindSink> sinkholder(pSink);
-
-    BOOL fSuppressSecurityChecks = pLoadSecurity != NULL && pLoadSecurity->m_fSuppressSecurityChecks;
-
-    if (!GetCodeBase() && !fSuppressSecurityChecks)
-        pSink->RequireCodebaseSecurityCheck();
-
-    BOOL fIsWellKnown = FALSE;
-    HRESULT hr = S_OK;
-
-    IfFailGo(AssemblySpec::LoadAssembly(pFusionContext,
-                                    pSink,
-                                    ppIAssembly,
-                                    ppIHostAssembly,
-                                    ppNativeFusionAssembly,
-                                    IsIntrospectionOnly(),
-                                    fSuppressSecurityChecks));
-
-    // Host should have already done appropriate permission demand
-    if (!(*ppIHostAssembly)) {
-        DWORD dwLocation;
-        IfFailGo((*ppIAssembly)->GetAssemblyLocation(&dwLocation));
-
-        fIsWellKnown = (dwLocation == ASMLOC_UNKNOWN);
-
-        // check if it was cached, where a codebase had originally loaded it
-        if (pSink->DoCodebaseSecurityCheck() &&
-            !fSuppressSecurityChecks &&
-            (dwLocation & ASMLOC_CODEBASE_HINT)) {
-            if ((dwLocation & ASMLOC_LOCATION_MASK) == ASMLOC_DOWNLOAD_CACHE) {
-                StackSString codeBase;
-                SafeComHolderPreemp<IAssemblyName> pNameDef;
-                
-                // <TODO>We could be caching the IAssemblyName and codebase</TODO>
-                IfFailGo((*ppIAssembly)->GetAssemblyNameDef(&pNameDef));
-
-                FusionBind::GetAssemblyNameStringProperty(pNameDef, ASM_NAME_CODEBASE_URL, codeBase);
-
-                DemandFileIOPermission(codeBase, FALSE, FILE_WEBPERM);
-            }
-            else if ((dwLocation & ASMLOC_LOCATION_MASK) != ASMLOC_GAC) {
-                StackSString path;
-                FusionBind::GetAssemblyManifestModulePath((*ppIAssembly), path);
-                
-                DemandFileIOPermission(path, TRUE, FILE_READANDPATHDISC);
-            }
-        }
-
-        // Verify control hash
-        if (m_HashForControl.GetSize() > 0) {
-            StackSString path;
-            
-            FusionBind::GetAssemblyManifestModulePath((*ppIAssembly), path);
-            
-            AssemblyFileHash fileHash;
-            IfFailGo(fileHash.SetFileName(path));
-            IfFailGo(fileHash.CalculateHash(m_dwHashAlg));
-            
-            if (!m_HashForControl.Equals(fileHash.GetHash(), fileHash.GetHashSize()))
-                IfFailGo(FUSION_E_REF_DEF_MISMATCH);
-        }
-    }
-
-#ifdef MDA_SUPPORTED
-    MdaLoadFromContext* pProbe = MDA_GET_ASSISTANT(LoadFromContext);
-    if (pProbe) {
-        pProbe->NowLoading(ppIAssembly, pCallerStackMark);
-    }
-#endif
-
-    *ppFusionLog = pSink->m_pFusionLog;
-    if (*ppFusionLog)
-        (*ppFusionLog)->AddRef();
-    return fIsWellKnown;
-
- ErrExit:
-    {
-        
-        *pHRBindResult = hr;
-
-        if (fThrowOnFileNotFound || (!Assembly::FileNotFound(hr)))
-            EEFileLoadException::Throw(this, pSink->m_pFusionLog, hr);
-    }
-
-    return FALSE;
-}
-#endif // FEATURE_FUSION
 
 void AssemblySpec::MatchRetargetedPublicKeys(Assembly *pAssembly)
 {
@@ -1079,28 +677,6 @@ void AssemblySpec::MatchRetargetedPublicKeys(Assembly *pAssembly)
         PRECONDITION(CheckPointer(pAssembly));
     }
     CONTRACTL_END;
-#ifdef FEATURE_FUSION
-    GCX_PREEMP();
-
-    // Manually apply fusion policy to obtain retargeted public key
-    SafeComHolderPreemp<IAssemblyName> pRequestedAssemblyName(NULL);
-    SafeComHolderPreemp<IAssemblyName> pPostPolicyAssemblyName(NULL);
-    IfFailThrow(CreateFusionName(&pRequestedAssemblyName));
-    HRESULT hr = PreBindAssembly(GetAppDomain()->GetFusionContext(),
-                                 pRequestedAssemblyName,
-                                 NULL, // pAsmParent
-                                 &pPostPolicyAssemblyName,
-                                 NULL  // pvReserved
-                                 );
-    if (SUCCEEDED(hr)
-        || (FAILED(hr) && (hr == FUSION_E_REF_DEF_MISMATCH))) {
-        IAssemblyName *pResultAssemblyName = pAssembly->GetFusionAssemblyName();
-        if (pResultAssemblyName
-            && pPostPolicyAssemblyName
-            && pResultAssemblyName->IsEqual(pPostPolicyAssemblyName, ASM_CMPF_PUBLIC_KEY_TOKEN) == S_OK)
-            return;
-    }
-#endif // FEATURE_FUSION
     ThrowHR(FUSION_E_REF_DEF_MISMATCH);
 }
 
@@ -1173,11 +749,6 @@ PEAssembly *AssemblySpec::ResolveAssemblyFile(AppDomain *pDomain, BOOL fPreBind)
     Assembly *pAssembly = pDomain->RaiseAssemblyResolveEvent(this, IsIntrospectionOnly(), fPreBind);
 
     if (pAssembly != NULL) {
-#ifdef FEATURE_FUSION
-        if (!IsIntrospectionOnly() && IsLoggingNeeded()) {
-            BinderLogging::BindingLog::CacheResultOfAssemblyResolveEvent(pDomain->GetFusionContext(), GetParentLoadContext(), pAssembly);
-        }
-#endif
         PEAssembly *pFile = pAssembly->GetManifestFile();
         pFile->AddRef();
 
@@ -1206,7 +777,6 @@ Assembly *AssemblySpec::LoadAssembly(FileLoadLevel targetLevel, AssemblyLoadSecu
     return pDomainAssembly->GetAssembly();
 }
 
-#if defined(FEATURE_CORECLR)
 // Returns a BOOL indicating if the two Binder references point to the same
 // binder instance.
 BOOL AreSameBinderInstance(ICLRPrivBinder *pBinderA, ICLRPrivBinder *pBinderB)
@@ -1233,7 +803,6 @@ BOOL AreSameBinderInstance(ICLRPrivBinder *pBinderA, ICLRPrivBinder *pBinderB)
     
     return fIsSameInstance;
 }
-#endif // defined(FEATURE_CORECLR)
 
 ICLRPrivBinder* AssemblySpec::GetBindingContextFromParentAssembly(AppDomain *pDomain)
 {
@@ -1256,9 +825,17 @@ ICLRPrivBinder* AssemblySpec::GetBindingContextFromParentAssembly(AppDomain *pDo
         
         // ICLRPrivAssembly implements ICLRPrivBinder and thus, "is a" binder in a manner of semantics.
         pParentAssemblyBinder = pParentPEAssembly->GetBindingContext();
+        if (pParentAssemblyBinder == NULL)
+        {
+            if (pParentPEAssembly->IsDynamic())
+            {
+                // If the parent assembly is dynamically generated, then use its fallback load context
+                // as the binder.
+                pParentAssemblyBinder = pParentPEAssembly->GetFallbackLoadContextBinder();
+            }
+        }
     }
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
     if (GetPreferFallbackLoadContextBinder())
     {
         // If we have been asked to use the fallback load context binder (currently only supported for AssemblyLoadContext.LoadFromAssemblyName),
@@ -1325,7 +902,6 @@ ICLRPrivBinder* AssemblySpec::GetBindingContextFromParentAssembly(AppDomain *pDo
         // used as the parent assembly binder.
         pParentAssemblyBinder = static_cast<ICLRPrivBinder*>(pDomain->GetFusionContext());
     }
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
     
     return pParentAssemblyBinder;
 }
@@ -1351,78 +927,6 @@ DomainAssembly *AssemblySpec::LoadDomainAssembly(FileLoadLevel targetLevel,
     ETWOnStartup (LoaderCatchCall_V1, LoaderCatchCallEnd_V1);
     AppDomain* pDomain = GetAppDomain();
 
-#ifndef FEATURE_CORECLR
-    // Event Tracing for Windows is used to log data for performance and functional testing purposes.
-    // The events in this function are used to help measure the performance of assembly loading as a whole for dynamic loads.
-
-    // Special-purpose holder structure to ensure the LoaderPhaseEnd ETW event is fired when returning from function.
-    struct ETWLoaderPhaseHolder
-    {
-        StackSString ETWCodeBase, ETWAssemblyName;
-
-        DWORD _dwAppDomainId;
-        BOOL initialized;
-
-        ETWLoaderPhaseHolder()
-            : _dwAppDomainId(ETWAppDomainIdNotAvailable)
-            , initialized(FALSE)
-        { }
-
-        void Init(DWORD dwAppDomainId, LPCWSTR wszCodeBase, LPCSTR szAssemblyName)
-        {
-            _dwAppDomainId = dwAppDomainId;
-
-            EX_TRY
-            {
-                if (wszCodeBase != NULL)
-                {
-                    ETWCodeBase.Append(wszCodeBase);
-                    ETWCodeBase.Normalize(); // Ensures that the later cast to LPCWSTR does not throw.
-                }
-            }
-            EX_CATCH
-            {
-                ETWCodeBase.Clear();
-            }
-            EX_END_CATCH(RethrowTransientExceptions)            
-
-            EX_TRY
-            {
-                if (szAssemblyName != NULL)
-                {
-                    ETWAssemblyName.AppendUTF8(szAssemblyName);
-                    ETWAssemblyName.Normalize(); // Ensures that the later cast to LPCWSTR does not throw.
-                }
-            }
-            EX_CATCH
-            {
-                ETWAssemblyName.Clear();
-            }
-            EX_END_CATCH(RethrowTransientExceptions)            
-
-            FireEtwLoaderPhaseStart(_dwAppDomainId, ETWLoadContextNotAvailable, ETWFieldUnused, ETWLoaderDynamicLoad, ETWCodeBase.IsEmpty() ? NULL : (LPCWSTR)ETWCodeBase, ETWAssemblyName.IsEmpty() ? NULL : (LPCWSTR)ETWAssemblyName, GetClrInstanceId());
-
-            initialized = TRUE;
-        }
-
-        ~ETWLoaderPhaseHolder()
-        {
-            if (initialized)
-            {
-                FireEtwLoaderPhaseEnd(_dwAppDomainId, ETWLoadContextNotAvailable, ETWFieldUnused, ETWLoaderDynamicLoad, ETWCodeBase.IsEmpty() ? NULL : (LPCWSTR)ETWCodeBase, ETWAssemblyName.IsEmpty() ? NULL : (LPCWSTR)ETWAssemblyName, GetClrInstanceId());
-            }
-        }
-    };
-
-    ETWLoaderPhaseHolder loaderPhaseHolder;
-    if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context, TRACE_LEVEL_INFORMATION, CLR_PRIVATEBINDING_KEYWORD)) {
-#ifdef  FEATURE_FUSION
-        loaderPhaseHolder.Init(pDomain->GetId().m_dwId, m_wszCodeBase, m_pAssemblyName);
-#else
-        loaderPhaseHolder.Init(pDomain->GetId().m_dwId, NULL, NULL);
-#endif    
-    }
-#endif // FEATURE_CORECLR
 
     DomainAssembly *pAssembly = nullptr;
 
@@ -1434,13 +938,6 @@ DomainAssembly *AssemblySpec::LoadDomainAssembly(FileLoadLevel targetLevel,
         pBinder = GetBindingContextFromParentAssembly(pDomain);
     }
 
-#ifdef FEATURE_APPX_BINDER
-    // If no explicit or parent binder, check domain.
-    if (pBinder == nullptr && AppX::IsAppXProcess())
-    {
-        pBinder = pDomain->GetCurrentLoadContextHostBinder();
-    }
-#endif
 
     if (pBinder != nullptr)
     {
@@ -1540,7 +1037,6 @@ Assembly *AssemblySpec::LoadAssembly(LPCWSTR pFilePath)
     RETURN spec.LoadAssembly(FILE_LOADED);
 }
 
-#ifndef  FEATURE_FUSION  
 HRESULT AssemblySpec::CheckFriendAssemblyName()
 {
     WRAPPER_NO_CONTRACT;
@@ -1558,7 +1054,6 @@ HRESULT AssemblySpec::CheckFriendAssemblyName()
         return S_OK;
     }
 }
-#endif //FEATURE_FUSION
 
 HRESULT AssemblySpec::EmitToken(
     IMetaDataAssemblyEmit *pEmit, 
@@ -1812,7 +1307,6 @@ void AssemblySpecBindingCache::Init(CrstBase *pCrst, LoaderHeap *pHeap)
     m_pHeap = pHeap;
 }
 
-#if defined(FEATURE_CORECLR)
 AssemblySpecBindingCache::AssemblyBinding* AssemblySpecBindingCache::GetAssemblyBindingEntryForAssemblySpec(AssemblySpec* pSpec, BOOL fThrow)
 {
     CONTRACTL
@@ -1886,19 +1380,12 @@ AssemblySpecBindingCache::AssemblyBinding* AssemblySpecBindingCache::GetAssembly
     
     return pEntry;
 }
-#endif // defined(FEATURE_CORECLR)
 
 BOOL AssemblySpecBindingCache::Contains(AssemblySpec *pSpec)
 {
     WRAPPER_NO_CONTRACT;
 
-#if !defined(FEATURE_CORECLR)
-    DWORD key = pSpec->Hash();
-    AssemblyBinding *entry = (AssemblyBinding *) m_map.LookupValue(key, pSpec);
-    return (entry != (AssemblyBinding *) INVALIDENTRY);
-#else // defined(FEATURE_CORECLR)    
     return (GetAssemblyBindingEntryForAssemblySpec(pSpec, TRUE) != (AssemblyBinding *) INVALIDENTRY);
-#endif // !defined(FEATURE_CORECLR)    
 }
 
 DomainAssembly *AssemblySpecBindingCache::LookupAssembly(AssemblySpec *pSpec,
@@ -1924,12 +1411,7 @@ DomainAssembly *AssemblySpecBindingCache::LookupAssembly(AssemblySpec *pSpec,
 
     AssemblyBinding *entry = (AssemblyBinding *) INVALIDENTRY;
     
-#if !defined(FEATURE_CORECLR)    
-    DWORD key = pSpec->Hash();
-    entry = (AssemblyBinding *) m_map.LookupValue(key, pSpec);
-#else // defined(FEATURE_CORECLR)
     entry = GetAssemblyBindingEntryForAssemblySpec(pSpec, fThrow);
-#endif // !defined(FEATURE_CORECLR)
 
     if (entry == (AssemblyBinding *) INVALIDENTRY)
         RETURN NULL;
@@ -1967,12 +1449,7 @@ PEAssembly *AssemblySpecBindingCache::LookupFile(AssemblySpec *pSpec, BOOL fThro
 
     AssemblyBinding *entry = (AssemblyBinding *) INVALIDENTRY;
     
-#if !defined(FEATURE_CORECLR)    
-    DWORD key = pSpec->Hash();
-    entry = (AssemblyBinding *) m_map.LookupValue(key, pSpec);
-#else // defined(FEATURE_CORECLR)
     entry = GetAssemblyBindingEntryForAssemblySpec(pSpec, fThrow);
-#endif // !defined(FEATURE_CORECLR)
     
     if (entry == (AssemblyBinding *) INVALIDENTRY)
         RETURN NULL;
@@ -2099,7 +1576,6 @@ BOOL AssemblySpecBindingCache::StoreAssembly(AssemblySpec *pSpec, DomainAssembly
 
     UPTR key = (UPTR)pSpec->Hash();
 
-#if defined(FEATURE_CORECLR)
     // On CoreCLR, we will use the BinderID as the key 
     ICLRPrivBinder* pBinderContextForLookup = pAssembly->GetFile()->GetBindingContext();
     _ASSERTE(pBinderContextForLookup || pAssembly->GetFile()->IsSystem());
@@ -2115,7 +1591,6 @@ BOOL AssemblySpecBindingCache::StoreAssembly(AssemblySpec *pSpec, DomainAssembly
             pSpec->SetBindingContext(pBinderContextForLookup);
         }
     }
-#endif // defined(FEATURE_CORECLR)
     
     AssemblyBinding *entry = (AssemblyBinding *) m_map.LookupValue(key, pSpec);
 
@@ -2181,7 +1656,6 @@ BOOL AssemblySpecBindingCache::StoreFile(AssemblySpec *pSpec, PEAssembly *pFile)
 
     UPTR key = (UPTR)pSpec->Hash();
 
-#if defined(FEATURE_CORECLR)
     // On CoreCLR, we will use the BinderID as the key 
     ICLRPrivBinder* pBinderContextForLookup = pFile->GetBindingContext();
     _ASSERTE(pBinderContextForLookup || pFile->IsSystem());
@@ -2197,7 +1671,6 @@ BOOL AssemblySpecBindingCache::StoreFile(AssemblySpec *pSpec, PEAssembly *pFile)
             pSpec->SetBindingContext(pBinderContextForLookup);
         }
     }
-#endif // defined(FEATURE_CORECLR)
 
     AssemblyBinding *entry = (AssemblyBinding *) m_map.LookupValue(key, pSpec);
 
@@ -2254,9 +1727,6 @@ BOOL AssemblySpecBindingCache::StoreException(AssemblySpec *pSpec, Exception* pE
 
     UPTR key = (UPTR)pSpec->Hash();
 
-#if !defined(FEATURE_CORECLR)    
-    AssemblyBinding *entry = (AssemblyBinding *) m_map.LookupValue(key, pSpec);
-#else // defined(FEATURE_CORECLR)
     AssemblyBinding *entry = GetAssemblyBindingEntryForAssemblySpec(pSpec, TRUE);
     if (entry == (AssemblyBinding *) INVALIDENTRY)
     {
@@ -2278,7 +1748,6 @@ BOOL AssemblySpecBindingCache::StoreException(AssemblySpec *pSpec, Exception* pE
             }
         }
     }
-#endif // defined(FEATURE_CORECLR)
 
     if (entry == (AssemblyBinding *) INVALIDENTRY) {
         AssemblyBindingHolder abHolder;
@@ -2333,11 +1802,6 @@ BOOL AssemblySpecBindingCache::CompareSpecs(UPTR u1, UPTR u2)
     AssemblySpec *a1 = (AssemblySpec *) (u1 << 1);
     AssemblySpec *a2 = (AssemblySpec *) u2;
 
-#if defined(FEATURE_APPX_BINDER)
-    _ASSERTE(a1->GetAppDomain() == a2->GetAppDomain());
-    if (a1->GetAppDomain()->HasLoadContextHostBinder())
-        return (CLRPrivBinderUtil::CompareHostBinderSpecs(a1,a2));
-#endif
 
     if ((!a1->CompareEx(a2)) ||
         (a1->IsIntrospectionOnly() != a2->IsIntrospectionOnly()))
@@ -2355,12 +1819,6 @@ BOOL DomainAssemblyCache::CompareBindingSpec(UPTR spec1, UPTR spec2)
     AssemblySpec* pSpec1 = (AssemblySpec*) (spec1 << 1);
     AssemblyEntry* pEntry2 = (AssemblyEntry*) spec2;
 
-#if defined(FEATURE_FUSION)
-    AssemblySpec* pSpec2 = &pEntry2->spec;
-    _ASSERTE(pSpec1->GetAppDomain() == pSpec2->GetAppDomain());
-    if (pSpec1->GetAppDomain()->HasLoadContextHostBinder())
-        return (CLRPrivBinderUtil::CompareHostBinderSpecs(pSpec1,pSpec2));
-#endif
 
 
     if ((!pSpec1->CompareEx(&pEntry2->spec)) ||
@@ -2438,31 +1896,6 @@ VOID DomainAssemblyCache::InsertEntry(AssemblySpec* pSpec, LPVOID pData1, LPVOID
 
 }
 
-#ifdef FEATURE_FUSION
-
-IAssembly * AssemblySpec::GetParentIAssembly()
-{
-    LIMITED_METHOD_CONTRACT;
-    if(m_pParentAssembly)
-        return m_pParentAssembly->GetFile()->GetFusionAssembly();
-
-    return NULL;
-}
-
-LPCVOID AssemblySpec::GetParentAssemblyPtr()
-{
-    LIMITED_METHOD_CONTRACT;
-    if(m_pParentAssembly)
-    {
-        if (m_pParentAssembly->GetFile()->HasHostAssembly())
-            return m_pParentAssembly->GetFile()->GetHostAssembly();
-        else
-            return m_pParentAssembly->GetFile()->GetFusionAssembly();
-    }
-    return NULL;
-}
-
-#endif //FEATURE_FUSION
 
 
 
diff --git a/src/vm/assemblyspec.hpp b/src/vm/assemblyspec.hpp
index d94a847124..48a6b459e2 100644
--- a/src/vm/assemblyspec.hpp
+++ b/src/vm/assemblyspec.hpp
@@ -17,9 +17,6 @@
 #define _ASSEMBLYSPEC_H
 #include "hash.h"
 #include "memorypool.h"
-#ifdef FEATURE_FUSION
-#include "fusionbind.h"
-#endif
 #include "assemblyspecbase.h"
 #include "domainfile.h"
 #include "genericstackprobe.h"
@@ -42,13 +39,11 @@ class AssemblySpec  : public BaseAssemblySpec
     DWORD            m_dwHashAlg;
     DomainAssembly  *m_pParentAssembly;
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
     // Contains the reference to the fallback load context associated with RefEmitted assembly requesting the load of another assembly (static or dynamic)
     ICLRPrivBinder *m_pFallbackLoadContextBinder;
 
     // Flag to indicate if we should prefer the fallback load context binder for binding or not.
     bool m_fPreferFallbackLoadContextBinder;
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
     BOOL IsValidAssemblyName();
     
@@ -76,10 +71,8 @@ class AssemblySpec  : public BaseAssemblySpec
         LIMITED_METHOD_CONTRACT;
         m_pParentAssembly = NULL;
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
         m_pFallbackLoadContextBinder = NULL;     
         m_fPreferFallbackLoadContextBinder = false;   
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
     }
 #endif //!DACCESS_COMPILE
@@ -89,18 +82,11 @@ class AssemblySpec  : public BaseAssemblySpec
         LIMITED_METHOD_CONTRACT
         m_pParentAssembly = NULL;
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
         m_pFallbackLoadContextBinder = NULL;
         m_fPreferFallbackLoadContextBinder = false;        
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
     }
 
-#ifdef FEATURE_FUSION
-    virtual IAssembly* GetParentIAssembly();
-
-    virtual LPCVOID GetParentAssemblyPtr();
-#endif
 
     DomainAssembly* GetParentAssembly();
     
@@ -125,16 +111,8 @@ class AssemblySpec  : public BaseAssemblySpec
         HRESULT hr=InitializeSpecInternal(kAssemblyRefOrDef, pImport,pStaticParent,fIntrospectionOnly,TRUE);
         if(FAILED(hr))
             EEFileLoadException::Throw(this,hr);
-#ifndef FEATURE_CORECLR
-        CloneFields();
-#endif
     };
 
-#ifdef FEATURE_FUSION
-    void InitializeSpec(IAssemblyName *pName,
-                        DomainAssembly *pStaticParent = NULL,
-                        BOOL fIntrospectionOnly = FALSE);
-#endif // FEATURE_FUSION
 
     void InitializeSpec(PEAssembly *pFile);
     HRESULT InitializeSpec(StackingAllocator* alloc,
@@ -167,18 +145,8 @@ class AssemblySpec  : public BaseAssemblySpec
         CONTRACTL_END;
 
         m_pParentAssembly = pAssembly;
-#ifdef FEATURE_FUSION
-        if (pAssembly)
-        {
-            _ASSERTE(GetHostBinder() == nullptr);
-            m_fParentLoadContext=pAssembly->GetFile()->GetLoadContext();
-        }
-        else
-            m_fParentLoadContext = LOADCTX_TYPE_DEFAULT;
-#endif
     }
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
     void SetFallbackLoadContextBinderForRequestingAssembly(ICLRPrivBinder *pFallbackLoadContextBinder)
     {
        LIMITED_METHOD_CONTRACT;
@@ -206,7 +174,6 @@ class AssemblySpec  : public BaseAssemblySpec
 
         return m_fPreferFallbackLoadContextBinder;
     }
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
     // Note that this method does not clone the fields!
     void CopyFrom(AssemblySpec* pSource)
@@ -224,20 +191,16 @@ class AssemblySpec  : public BaseAssemblySpec
         SetIntrospectionOnly(pSource->IsIntrospectionOnly());
         SetParentAssembly(pSource->GetParentAssembly());
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
         // Copy the details of the fallback load context binder
         SetFallbackLoadContextBinderForRequestingAssembly(pSource->GetFallbackLoadContextBinderForRequestingAssembly());
         m_fPreferFallbackLoadContextBinder = pSource->GetPreferFallbackLoadContextBinder();
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
         m_HashForControl = pSource->m_HashForControl;
         m_dwHashAlg = pSource->m_dwHashAlg;
     }
 
 
-#ifndef FEATURE_FUSION     
     HRESULT CheckFriendAssemblyName();
-#endif // FEATURE_FUSION
 
 
     HRESULT EmitToken(IMetaDataAssemblyEmit *pEmit, 
@@ -253,15 +216,8 @@ class AssemblySpec  : public BaseAssemblySpec
         FILE_WEBPERM         = 0x3
     };
 
-#ifdef FEATURE_FUSION    
-    static void DemandFileIOPermission(LPCWSTR wszCodeBase,
-                                       BOOL fHavePath,
-                                       DWORD dwDemandFlag);
-    void DemandFileIOPermission(PEAssembly *pFile);
-#endif
 
 
-#ifndef FEATURE_FUSION
     VOID Bind(
         AppDomain* pAppDomain, 
         BOOL fThrowOnFileNotFound,
@@ -269,10 +225,6 @@ class AssemblySpec  : public BaseAssemblySpec
         BOOL fNgenExplicitBind = FALSE, 
         BOOL fExplicitBindToNativeImage = FALSE,
         StackCrawlMark *pCallerStackMark  = NULL );
-#ifndef FEATURE_CORECLR
-    static VOID BindToSystem(BINDER_SPACE::Assembly** ppAssembly);
-#endif
-#endif
 
     Assembly *LoadAssembly(FileLoadLevel targetLevel, 
                            AssemblyLoadSecurity *pLoadSecurity = NULL,
@@ -294,27 +246,10 @@ class AssemblySpec  : public BaseAssemblySpec
                                   DWORD cbPublicKeyOrToken,
                                   DWORD dwFlags);
 
-#ifdef FEATURE_FUSION
-    //****************************************************************************************
-    //
-    HRESULT LoadAssembly(IApplicationContext *pFusionContext, 
-                         FusionSink *pSink,
-                         IAssembly** ppIAssembly,
-                         IHostAssembly** ppIHostAssembly,
-                         IBindResult **ppNativeFusionAssembly,
-                         BOOL fForIntrospectionOnly,
-                         BOOL fSuppressSecurityChecks);
-#endif
 
     // Load an assembly based on an explicit path
     static Assembly *LoadAssembly(LPCWSTR pFilePath);
 
-#ifdef FEATURE_FUSION
-    BOOL FindAssemblyFile(AppDomain *pAppDomain, BOOL fThrowOnFileNotFound,
-                          IAssembly** ppIAssembly, IHostAssembly **ppIHostAssembly, IBindResult** pNativeFusionAssembly,
-                          IFusionBindLog **ppFusionLog, HRESULT *pHRBindResult, StackCrawlMark *pCallerStackMark = NULL,
-                          AssemblyLoadSecurity *pLoadSecurity = NULL);
-#endif // FEATURE_FUSION
 
   private:
     void MatchRetargetedPublicKeys(Assembly *pAssembly);
@@ -385,11 +320,7 @@ class AssemblySpec  : public BaseAssemblySpec
     inline BOOL CanUseWithBindingCache() const
     {
         STATIC_CONTRACT_LIMITED_METHOD;
-#if defined(FEATURE_APPX_BINDER)
-        return (GetHostBinder() == nullptr) && HasUniqueIdentity();
-#else
         return HasUniqueIdentity(); 
-#endif
     }
 
     inline ICLRPrivBinder *GetHostBinder() const
@@ -653,9 +584,7 @@ class AssemblySpecBindingCache
     PtrHashMap m_map;
     LoaderHeap *m_pHeap;
 
-#if defined(FEATURE_CORECLR)    
     AssemblySpecBindingCache::AssemblyBinding* GetAssemblyBindingEntryForAssemblySpec(AssemblySpec* pSpec, BOOL fThrow);
-#endif // defined(FEATURE_CORECLR)
     
   public:
 
@@ -683,7 +612,7 @@ class AssemblySpecBindingCache
         return pSpec->Hash();
     }
     
-#if defined(FEATURE_CORECLR) && !defined(DACCESS_COMPILE)    
+#if !defined(DACCESS_COMPILE)
     void GetAllAssemblies(SetSHash<PTR_DomainAssembly>& assemblyList)
     {
         PtrHashMap::PtrIterator i = m_map.begin();
@@ -695,7 +624,7 @@ class AssemblySpecBindingCache
             ++i;
         }
     }
-#endif // defined(FEATURE_CORECLR) && !defined(DACCESS_COMPILE)
+#endif // !defined(DACCESS_COMPILE)
 
     static BOOL CompareSpecs(UPTR u1, UPTR u2);
 };
diff --git a/src/vm/assemblyspecbase.h b/src/vm/assemblyspecbase.h
index a52df06009..3442c9184e 100644
--- a/src/vm/assemblyspecbase.h
+++ b/src/vm/assemblyspecbase.h
@@ -16,11 +16,9 @@
 #ifndef __ASSEMBLY_SPEC_BASE_H__
 #define __ASSEMBLY_SPEC_BASE_H__
 
-#ifndef FEATURE_FUSION
 #include "coreclr/corebindresult.h"
 #include "coreclr/corebindresult.inl"
 #include "../binder/inc/assembly.hpp"
-#endif // FEATURE_FUSION
 
 #include "baseassemblyspec.h"
 #include "baseassemblyspec.inl"
diff --git a/src/vm/baseassemblyspec.cpp b/src/vm/baseassemblyspec.cpp
index 806416e923..fdaa981523 100644
--- a/src/vm/baseassemblyspec.cpp
+++ b/src/vm/baseassemblyspec.cpp
@@ -122,7 +122,6 @@ BOOL BaseAssemblySpec::IsMscorlib()
                ( (iNameLen == CoreLibNameLen) || (m_pAssemblyName[CoreLibNameLen] == ',') ) ) ) );
 }
 
-#ifdef FEATURE_CORECLR
 BOOL BaseAssemblySpec::IsAssemblySpecForMscorlib()
 {
     CONTRACTL
@@ -150,9 +149,6 @@ BOOL BaseAssemblySpec::IsAssemblySpecForMscorlib()
 }
 
 #define MSCORLIB_PUBLICKEY g_rbTheSilverlightPlatformKey
-#else
-#define MSCORLIB_PUBLICKEY g_rbNeutralPublicKey
-#endif
 
 
 // A satellite assembly for mscorlib is named "mscorlib.resources" or 
@@ -232,7 +228,6 @@ VOID BaseAssemblySpec::ConvertPublicKeyToToken()
     m_dwFlags &= ~afPublicKey;
 }
 
-#ifndef FEATURE_FUSION
 // Similar to BaseAssemblySpec::CompareEx, but allows the ref to be partially specified
 // Returns TRUE if ref matches def, FALSE otherwise.
 //
@@ -362,7 +357,6 @@ BOOL BaseAssemblySpec::RefMatchesDef(const BaseAssemblySpec* pRef, const BaseAss
         return (CompareStrings(pRef->GetName(), pDef->GetName())==0);
     }
 }
-#endif // FEATURE_FUSION
 
 //===========================================================================================
 // This function may embed additional information, if required.
@@ -683,21 +677,9 @@ HRESULT BaseAssemblySpec::CreateFusionName(
                 }
             }
             else {
-#ifdef FEATURE_FUSION
-                IfFailGo(pFusionAssemblyName->SetProperty(ASM_NAME_NULL_PUBLIC_KEY_TOKEN,
-                                                          NULL, 0));
-#endif
             }
         }
 
-#ifdef FEATURE_FUSION
-        // See if the assembly[ref] is retargetable (ie, for a generic assembly).
-        if (IsAfRetargetable(m_dwFlags)) {
-            BOOL bTrue = TRUE;
-            IfFailGo(pFusionAssemblyName->SetProperty(ASM_NAME_RETARGET, 
-                                                      &bTrue, sizeof(bTrue)));
-        }
-#endif
 
         // Set the Processor Architecture (if any)
         {
@@ -723,15 +705,7 @@ HRESULT BaseAssemblySpec::CreateFusionName(
             }
         }
 
-#ifdef FEATURE_FUSION
-        if (fIncludeCodeBase && m_wszCodeBase) {
-            IfFailGo(pFusionAssemblyName->SetProperty(ASM_NAME_CODEBASE_URL,
-                                                      (void*)m_wszCodeBase, 
-                                                      (DWORD)(wcslen(m_wszCodeBase)+1) * sizeof(WCHAR)));
-        }
-#else
         _ASSERTE(m_wszCodeBase == NULL);
-#endif
 
         *ppName = pFusionAssemblyName;
 
diff --git a/src/vm/baseassemblyspec.h b/src/vm/baseassemblyspec.h
index 0a21d95ee8..9381157f7a 100644
--- a/src/vm/baseassemblyspec.h
+++ b/src/vm/baseassemblyspec.h
@@ -27,18 +27,12 @@ protected:
     DWORD                       m_cbPublicKeyOrToken;
     DWORD                       m_dwFlags;             // CorAssemblyFlags
     LPCWSTR                     m_wszCodeBase;         // URL to the code
-#ifdef FEATURE_FUSION
-    LOADCTX_TYPE                m_fParentLoadContext;  // m_pParentAssembly->GetFusionLoadContext()
-    ReleaseHolder<IAssemblyName> m_pNameAfterPolicy;
-#endif
     LPCSTR                      m_szWinRtTypeNamespace;
     LPCSTR                      m_szWinRtTypeClassName;
     ICLRPrivBinder             *m_pHostBinder;
     int                         m_ownedFlags;
     BOOL                        m_fIntrospectionOnly;
-#if defined(FEATURE_CORECLR)
     ICLRPrivBinder             *m_pBindingContext;
-#endif // defined(FEATURE_CORECLR)
 
 public:
     enum 
@@ -76,7 +70,6 @@ public:
     VOID    CloneFieldsToLoaderHeap(int flags, LoaderHeap *pHeap, AllocMemTracker *pamTracker);
     VOID    CloneFieldsToStackingAllocator(StackingAllocator* alloc);
 
-#if defined(FEATURE_CORECLR)
     inline void SetBindingContext(ICLRPrivBinder *pBindingContext)
     {
         LIMITED_METHOD_CONTRACT;
@@ -92,7 +85,6 @@ public:
     }
     
     BOOL IsAssemblySpecForMscorlib();
-#endif // defined(FEATURE_CORECLR)
     
     HRESULT ParseName();
     DWORD Hash();
@@ -150,19 +142,6 @@ public:
         BOOL fIncludeCodeBase = TRUE, /* Used by fusion only */
         BOOL fMustBeBindable = FALSE) const;
 
-#ifdef FEATURE_FUSION
-    // for fusion binding
-    virtual IAssembly* GetParentIAssembly() =0;
-
-    // for identity comparison
-    virtual LPCVOID GetParentAssemblyPtr() =0;
-
-    inline LOADCTX_TYPE GetParentLoadContext()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return m_fParentLoadContext;
-    }
-#endif
 
     BOOL IsIntrospectionOnly()
     {
@@ -253,48 +232,6 @@ public:
         return IsAfRetargetable(m_dwFlags);
     }
 
-#ifdef FEATURE_FUSION
-    inline IAssemblyName* GetNameAfterPolicy() const
-    {
-        LIMITED_METHOD_CONTRACT;
-        return m_pNameAfterPolicy;
-    }
-
-    inline void ReleaseNameAfterPolicy()
-    {
-        LIMITED_METHOD_CONTRACT;
-        m_pNameAfterPolicy=NULL;
-    }
-
-    inline void SetNameAfterPolicy(IAssemblyName* pName)
-    {
-        LIMITED_METHOD_CONTRACT;
-        m_pNameAfterPolicy=pName;
-    }
-
-
-    void SetPEKIND(PEKIND peKind)
-    {
-        LIMITED_METHOD_CONTRACT;
-        C_ASSERT(afPA_None == PAFlag(peNone));
-        C_ASSERT(afPA_MSIL == PAFlag(peMSIL));
-        C_ASSERT(afPA_x86 == PAFlag(peI386));
-        C_ASSERT(afPA_IA64 == PAFlag(peIA64));
-        C_ASSERT(afPA_AMD64 == PAFlag(peAMD64));
-        C_ASSERT(afPA_ARM == PAFlag(peARM));
-        
-        _ASSERTE((peKind <= peARM) || (peKind == peInvalid));
-        
-        m_dwFlags &= ~afPA_FullMask;
-        m_dwFlags |= PAFlag(peKind);
-    }
-
-    PEKIND GetPEKIND() const
-    {
-        LIMITED_METHOD_CONTRACT;
-        return static_cast<PEKIND>(PAIndex(m_dwFlags));
-    }
-#endif //FEATURE_FUSION
 
 protected:
     static BOOL CompareRefToDef(const BaseAssemblySpec *pRef, const BaseAssemblySpec *pDef);
diff --git a/src/vm/baseassemblyspec.inl b/src/vm/baseassemblyspec.inl
index 53c312f069..5205056c14 100644
--- a/src/vm/baseassemblyspec.inl
+++ b/src/vm/baseassemblyspec.inl
@@ -17,9 +17,7 @@
 
 extern LocaleID g_lcid;
 
-#if defined(FEATURE_CORECLR)
 BOOL AreSameBinderInstance(ICLRPrivBinder *pBinderA, ICLRPrivBinder *pBinderB);
-#endif // defined(FEATURE_CORECLR)
 
 inline int BaseAssemblySpec::CompareStrings(LPCUTF8 string1, LPCUTF8 string2)
 {
@@ -262,25 +260,13 @@ inline void BaseAssemblySpec::CopyFrom(const BaseAssemblySpec *pSpec)
 
     m_pHostBinder = pSpec->m_pHostBinder;
 
-#ifdef FEATURE_CORECLR
     if ((pSpec->m_ownedFlags & BAD_NAME_OWNED) != 0)
     {
         m_ownedFlags |= BAD_NAME_OWNED;
     }
-#endif
 
-#ifdef FEATURE_FUSION
-    IAssemblyName* pNameAfterPolicy=pSpec->GetNameAfterPolicy();
-    if (pNameAfterPolicy)
-    {
-        pNameAfterPolicy->AddRef();
-        SetNameAfterPolicy(pNameAfterPolicy);
-    }
-#endif
 
-#if defined(FEATURE_CORECLR)
     m_pBindingContext = pSpec->m_pBindingContext;
-#endif // defined(FEATURE_CORECLR)
 
 }
 
@@ -294,10 +280,8 @@ inline DWORD BaseAssemblySpec::Hash()
         MODE_ANY;
     } CONTRACTL_END;
 
-#ifdef FEATURE_CORECLR
     if(m_wszCodeBase)
         return HashString(m_wszCodeBase);
-#endif
 
     // Hash fields.
     DWORD hash = 0;
@@ -312,11 +296,6 @@ inline DWORD BaseAssemblySpec::Hash()
     hash ^= m_dwFlags;
     hash = _rotl(hash, 4);
 
-#ifndef FEATURE_CORECLR
-    if (m_wszCodeBase)
-        hash ^= HashString(m_wszCodeBase);
-    hash = _rotl(hash, 4);
-#endif
 
     hash ^= m_context.usMajorVersion;
     hash = _rotl(hash, 8);
@@ -352,9 +331,6 @@ inline DWORD BaseAssemblySpec::Hash()
         hash = _rotl(hash, 4);
     }
 
-#ifdef FEATURE_FUSION
-    hash ^= (m_fParentLoadContext == LOADCTX_TYPE_LOADFROM);
-#endif
 
     return hash;
 }
@@ -364,50 +340,15 @@ inline BOOL BaseAssemblySpec::CompareEx(BaseAssemblySpec *pSpec, DWORD dwCompare
 {
     WRAPPER_NO_CONTRACT;
 
-#ifndef FEATURE_CORECLR
-    _ASSERTE(pSpec != NULL);
 
-    if ((m_dwFlags & afContentType_Mask) == (pSpec->m_dwFlags & afContentType_Mask))
-    {
-        if (IsContentType_WindowsRuntime() && pSpec->IsContentType_WindowsRuntime())
-        {
-            // If comparing assembly definitions, can not use bindability attributes as
-            // a shortcut for equivalence, as this type of shortcut is only applicable
-            // when comparing assembly references (not definitions).
-            //
-            // Example of why this is needed: native images still need to compare
-            // assembly identities even if they are not bindable, because it needs to
-            // ensure that the exact same assembly file (definition) is used at runtime
-            // as was used during compilation.
-            if ((dwCompareFlags & ASC_DefinitionEquality) != ASC_DefinitionEquality)
-            {
-                // WinRT assembly references are meaningless, they are all equal to each other
-                return TRUE;
-            }
-        }
-    }
-    else
-    {
-        return FALSE;
-    }
-#endif
-
-#ifdef FEATURE_CORECLR
     if(m_wszCodeBase || pSpec->m_wszCodeBase)
     {
         if(!m_wszCodeBase || !pSpec->m_wszCodeBase)    
             return FALSE;
         return wcscmp(m_wszCodeBase,(pSpec->m_wszCodeBase))==0;
     }
-#endif
 
     // Compare fields
-#ifdef FEATURE_FUSION
-    BOOL fIsInLoadFromContext = (m_fParentLoadContext == LOADCTX_TYPE_LOADFROM);
-    BOOL fSpecIsInLoadFromContext = (pSpec->m_fParentLoadContext == LOADCTX_TYPE_LOADFROM);
-    if (fIsInLoadFromContext != fSpecIsInLoadFromContext)
-        return FALSE;
-#endif
 
     if (m_pAssemblyName != pSpec->m_pAssemblyName
         && (m_pAssemblyName == NULL || pSpec->m_pAssemblyName == NULL
@@ -418,12 +359,6 @@ inline BOOL BaseAssemblySpec::CompareEx(BaseAssemblySpec *pSpec, DWORD dwCompare
         || memcmp(m_pbPublicKeyOrToken, pSpec->m_pbPublicKeyOrToken, m_cbPublicKeyOrToken))
         return FALSE;
 
-#ifndef FEATURE_CORECLR
-    if (m_wszCodeBase != pSpec->m_wszCodeBase
-        && (m_wszCodeBase == NULL || pSpec->m_wszCodeBase == NULL
-            || wcscmp(m_wszCodeBase, pSpec->m_wszCodeBase)))
-        return FALSE;
-#endif
 
     if (m_dwFlags != pSpec->m_dwFlags)
         return FALSE;
@@ -451,21 +386,7 @@ inline BOOL BaseAssemblySpec::CompareEx(BaseAssemblySpec *pSpec, DWORD dwCompare
             || strcmp(m_context.szLocale, pSpec->m_context.szLocale)))
         return FALSE;
 
-#ifdef FEATURE_FUSION
-    if (!IsIntrospectionOnly() && !pSpec->IsIntrospectionOnly()) {
-        // Post-policy load-neither binds can be picked up by nobody
-        // except their own parent assembly. This only applies to executable assemblies.
-        BOOL bParentsMustMatch;
-
-        // doesn't need the check if one is in load context
-        bParentsMustMatch = (m_fParentLoadContext == LOADCTX_TYPE_UNKNOWN && pSpec->m_fParentLoadContext == LOADCTX_TYPE_UNKNOWN);
-        
-        if ( bParentsMustMatch && GetParentAssemblyPtr() != pSpec->GetParentAssemblyPtr())
-            return FALSE;
-    }
-#endif
 
-#if defined(FEATURE_CORECLR)
     // If the assemblySpec contains the binding context, then check if they match.
     if (!(pSpec->IsAssemblySpecForMscorlib() && IsAssemblySpecForMscorlib()))
     {
@@ -474,7 +395,6 @@ inline BOOL BaseAssemblySpec::CompareEx(BaseAssemblySpec *pSpec, DWORD dwCompare
             return FALSE;
         }
     }
-#endif // defined(FEATURE_CORECLR)
 
 
     return TRUE;
diff --git a/src/vm/callhelpers.cpp b/src/vm/callhelpers.cpp
index addd5192da..18c935a5b4 100644
--- a/src/vm/callhelpers.cpp
+++ b/src/vm/callhelpers.cpp
@@ -35,17 +35,6 @@ void AssertMulticoreJitAllowedModule(PCODE pTarget)
 
     Module * pModule = pMethod->GetModule_NoLogging();
 
-#if defined(FEATURE_APPX_BINDER)
-    
-    // For Appx process, allow certain modules to load on background thread
-    if (AppX::IsAppXProcess())
-    {
-        if (MulticoreJitManager::IsLoadOkay(pModule))
-        {
-            return;
-        }
-    }
-#endif
 
     _ASSERTE(pModule->IsSystem());
 }
diff --git a/src/vm/ceeload.cpp b/src/vm/ceeload.cpp
index c95fbac16e..f6317f03aa 100644
--- a/src/vm/ceeload.cpp
+++ b/src/vm/ceeload.cpp
@@ -78,14 +78,10 @@
 #include "perflog.h"
 #include "ecall.h"
 #include "../md/compiler/custattr.h"
-#include "constrainedexecutionregion.h"
 #include "typekey.h"
 #include "peimagelayout.inl"
 #include "ildbsymlib.h"
 
-#if defined(FEATURE_APPX_BINDER)
-#include "clrprivbinderappx.h"
-#endif // defined(FEATURE_APPX_BINDER)
 
 #if defined(PROFILING_SUPPORTED)
 #include "profilermetadataemitvalidator.h"
@@ -1656,24 +1652,6 @@ void Module::Destruct()
     m_InstMethodHashTableCrst.Destroy();
     m_ISymUnmanagedReaderCrst.Destroy();
 
-#ifdef FEATURE_CER
-    if (m_pCerPrepInfo)
-    {
-        _ASSERTE(m_pCerCrst != NULL);
-        CrstHolder sCrstHolder(m_pCerCrst);
-
-        EEHashTableIteration sIter;
-        m_pCerPrepInfo->IterateStart(&sIter);
-        while (m_pCerPrepInfo->IterateNext(&sIter)) {
-            CerPrepInfo *pPrepInfo = (CerPrepInfo*)m_pCerPrepInfo->IterateGetValue(&sIter);
-            delete pPrepInfo;
-        }
-
-        delete m_pCerPrepInfo;
-    }
-    if (m_pCerCrst)
-        delete m_pCerCrst;
-#endif // FEATURE_CER
 
     if (m_debuggerSpecificData.m_pDynamicILCrst)
     {
@@ -1704,10 +1682,6 @@ void Module::Destruct()
     }
 
 #ifdef FEATURE_PREJIT 
-#ifdef FEATURE_CER
-    if (m_pCerNgenRootTable && (m_dwTransientFlags & M_CER_ROOT_TABLE_ON_HEAP))
-        delete m_pCerNgenRootTable;
-#endif
 
     if (HasNativeImage())
     {
@@ -3158,34 +3132,6 @@ BOOL Module::IsPreV4Assembly()
     return !!(m_dwPersistedFlags & IS_PRE_V4_ASSEMBLY);
 }
 
-#ifdef FEATURE_CER
-DWORD Module::GetReliabilityContract()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END
-
-    if (!(m_dwPersistedFlags & COMPUTED_RELIABILITY_CONTRACT))
-    {
-        // The flags should be precomputed in native images
-        _ASSERTE(!HasNativeImage());
-
-        // This flag applies to assembly, but it is stored on module so it can be cached in ngen image
-        // Thus, we should ever need it for manifest module only.
-        IMDInternalImport *mdImport = GetAssembly()->GetManifestImport();
-
-        m_dwReliabilityContract = ::GetReliabilityContract(mdImport, TokenFromRid(1, mdtAssembly));
-
-        FastInterlockOr(&m_dwPersistedFlags, COMPUTED_RELIABILITY_CONTRACT);
-    }
-
-    return m_dwReliabilityContract;
-}
-#endif // FEATURE_CER
 
 ArrayDPTR(FixupPointer<PTR_MethodTable>) ModuleCtorInfo::GetGCStaticMTs(DWORD index)
 {
@@ -3896,103 +3842,6 @@ void Module::ReleaseILData(void)
 }
 
 
-#ifdef FEATURE_FUSION
-
-//
-// Module::FusionCopyPDBs asks Fusion to copy PDBs for a given
-// assembly if they need to be copied. This is for the case where a PE
-// file is shadow copied to the Fusion cache. Fusion needs to be told
-// to take the time to copy the PDB, too.
-//
-STDAPI CopyPDBs(IAssembly *pAsm); // private fusion API
-void Module::FusionCopyPDBs(LPCWSTR moduleName)
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    Assembly *pAssembly = GetAssembly();
-
-    // Just return if we've already done this for this Module's
-    // Assembly.
-    if ((pAssembly->GetDebuggerInfoBits() & DACF_PDBS_COPIED) ||
-        (pAssembly->GetFusionAssembly() == NULL))
-    {
-        LOG((LF_CORDB, LL_INFO10,
-             "Don't need to copy PDB's for module %S\n",
-             moduleName));
-
-        return;
-    }
-
-    LOG((LF_CORDB, LL_INFO10,
-         "Attempting to copy PDB's for module %S\n", moduleName));
-
-    HRESULT hr;
-    hr = CopyPDBs(pAssembly->GetFusionAssembly());
-    LOG((LF_CORDB, LL_INFO10,
-            "Fusion.dll!CopyPDBs returned hr=0x%08x for module 0x%08x\n",
-            hr, this));
-
-    // Remember that we've copied the PDBs for this assembly.
-    pAssembly->SetCopiedPDBs();
-}
-
-// This function will return PDB stream if exist.
-// It is the caller responsibility to call release on *ppStream after a successful
-// result.
-// We will first check to see if we have a cached pdb stream available. If not,
-// we will ask fusion which in terms to ask host vis HostProvideAssembly. Host may
-// decide to provide one or not.
-//
-HRESULT Module::GetHostPdbStream(IStream **ppStream)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        if(GetThread()) {GC_TRIGGERS;} else {GC_NOTRIGGER;}
-    }
-    CONTRACTL_END
-
-    HRESULT hr = NOERROR;
-
-    _ASSERTE(ppStream);
-
-    *ppStream = NULL;
-
-    if (m_file->IsIStream() == false)
-    {
-        // not a host stream
-        return E_FAIL;
-    }
-
-    // Maybe fusion can ask our host. This will give us back a PDB stream if
-    // host decides to provide one.
-    //
-    if (m_file->IsAssembly())
-    {
-        GCX_PREEMP();
-        hr = ((PEAssembly*)m_file)->GetIHostAssembly()->GetAssemblyDebugStream(ppStream);
-    }
-    else
-    {
-        _ASSERTE(m_file->IsModule());
-        IHostAssemblyModuleImport *pIHAMI;
-        MAKE_WIDEPTR_FROMUTF8_NOTHROW(pName, m_file->GetSimpleName());
-        if (pName == NULL)
-            return E_OUTOFMEMORY;
-        IfFailRet(m_file->GetAssembly()->GetIHostAssembly()->GetModuleByName(pName, &pIHAMI));
-        hr = pIHAMI->GetModuleDebugStream(ppStream);
-    }
-    return hr;
-}
-
-#endif
 
 //---------------------------------------------------------------------------------------
 //
@@ -4260,14 +4109,12 @@ ISymUnmanagedReader *Module::GetISymUnmanagedReader(void)
 
         SafeComHolder<ISymUnmanagedBinder> pBinder;
 
-#if defined(FEATURE_CORECLR)
         if (g_pDebugInterface == NULL)
         {
             // @TODO: this is reachable when debugging!
             UNREACHABLE_MSG("About to CoCreateInstance!  This code should not be "
                             "reachable or needs to be reimplemented for CoreCLR!");
         }
-#endif // FEATURE_CORECLR
 
         if (this->GetInMemorySymbolStreamFormat() == eSymbolFormatILDB)
         {
@@ -4286,21 +4133,13 @@ ISymUnmanagedReader *Module::GetISymUnmanagedReader(void)
             // On desktop, the framework installer is supposed to install diasymreader.dll as well
             // and so this shouldn't happen.
             hr = FakeCoCreateInstanceEx(CLSID_CorSymBinder_SxS,
-#ifdef FEATURE_CORECLR
                                         NATIVE_SYMBOL_READER_DLL,
-#else
-                                        GetInternalSystemDirectory(),
-#endif
                                         IID_ISymUnmanagedBinder,
                                         (void**)&pBinder,
                                         NULL);
             if (FAILED(hr))
             {
-#ifdef FEATURE_CORECLR
                 RETURN (NULL);
-#else
-                ThrowHR(hr);
-#endif
             }
 
         }
@@ -4337,18 +4176,6 @@ ISymUnmanagedReader *Module::GetISymUnmanagedReader(void)
                     pIStream->AddRef();
                 }
             }
-#ifdef FEATURE_FUSION
-            else
-            {
-                // Verified this above.
-                _ASSERTE(m_file->IsIStream());
-
-                // Case 2: get assembly from host.
-                // This commonly would be cached already as GetInMemorySymbolStream() in code:Module.FetchPdbsFromHost,
-                // but may not be cached if the host didn't provide the PDBs at the time. 
-                hr = GetHostPdbStream(&pIStream);
-            }
-#endif
             if (SUCCEEDED(hr))
             {
                 hr = pBinder->GetReaderFromStream(GetRWImporter(), pIStream, &pReader);
@@ -4362,9 +4189,6 @@ ISymUnmanagedReader *Module::GetISymUnmanagedReader(void)
             // Call Fusion to ensure that any PDB's are shadow copied before
             // trying to get a symbol reader. This has to be done once per
             // Assembly.
-#ifdef FEATURE_FUSION
-            FusionCopyPDBs(path);
-#endif
             // for this to work with winmds we cannot simply call GetRWImporter() as winmds are RO
             // and thus don't implement the RW interface. so we call this wrapper function which knows 
             // how to get a IMetaDataImport interface regardless of the underlying module type.
@@ -5792,14 +5616,6 @@ Module::GetAssemblyIfLoaded(
 #endif //!DACCESS_COMPILE
                     if (pAssembly == nullptr)
                     {   
-#if defined(FEATURE_APPX_BINDER)
-                        // Use WinRT binder from "global" AppX binder (there's only 1 AppDomain in non-design mode)
-                        CLRPrivBinderAppX * pAppXBinder = CLRPrivBinderAppX::GetBinderOrNull();
-                        if (pAppXBinder != nullptr)
-                        {
-                            pWinRtBinder = pAppXBinder->GetWinRtBinder();
-                        }
-#endif // defined(FEATURE_APPX_BINDER)
                     }
                 }
                 
@@ -5840,7 +5656,6 @@ Module::GetAssemblyIfLoaded(
                     continue;
                 }
 
-#if defined(FEATURE_CORECLR)                
                 // If we have been passed the binding context for the loaded assembly that is being looked up in the 
                 // cache, then set it up in the AssemblySpec for the cache lookup to use it below.
                 if (pBindingContextForLoadedAssembly != NULL)
@@ -5848,23 +5663,8 @@ Module::GetAssemblyIfLoaded(
                     _ASSERTE(spec.GetBindingContext() == NULL);
                     spec.SetBindingContext(pBindingContextForLoadedAssembly);
                 }
-#endif // defined(FEATURE_CORECLR)
                 DomainAssembly * pDomainAssembly = nullptr;
 
-#ifdef FEATURE_APPX_BINDER
-                if (AppX::IsAppXProcess_Initialized_NoFault() && GetAssembly()->GetManifestFile()->HasHostAssembly())
-                {
-                    ICLRPrivAssembly * pPrivBinder = GetAssembly()->GetManifestFile()->GetHostAssembly();
-                    ReleaseHolder<ICLRPrivAssembly> pPrivAssembly;
-                    HRESULT hrCachedResult;
-                    if (SUCCEEDED(pPrivBinder->FindAssemblyBySpec(pAppDomainExamine, &spec, &hrCachedResult, &pPrivAssembly)) &&
-                        SUCCEEDED(hrCachedResult))
-                    {
-                        pDomainAssembly = pAppDomainExamine->FindAssembly(pPrivAssembly);
-                    }
-                }
-                else
-#endif // FEATURE_APPX_BINDER
                 {
                     pDomainAssembly = pAppDomainExamine->FindCachedAssembly(&spec, FALSE /*fThrow*/);
                 }
@@ -5901,10 +5701,6 @@ Module::GetAssemblyIfLoaded(
         BOOL eligibleForAdditionalChecks = TRUE;
         if (szWinRtNamespace != NULL)
             eligibleForAdditionalChecks = FALSE; // WinRT binds do not support this scan
-#ifdef FEATURE_FUSION
-        else if ((this->GetAssembly()->GetManifestFile()->GetLoadContext() != LOADCTX_TYPE_DEFAULT) && (this->GetAssembly()->GetManifestFile()->GetLoadContext() != LOADCTX_TYPE_HOSTED))
-            eligibleForAdditionalChecks = FALSE; // Only load and hosted context binds support this kind of discovery.
-#endif // FEATURE_FUSION
         else if (this->GetAssembly()->GetManifestFile()->IsDesignerBindingContext())
         {
             eligibleForAdditionalChecks = FALSE; 
@@ -6154,7 +5950,6 @@ DomainAssembly * Module::LoadAssembly(
                 szWinRtTypeClassName);
         AssemblySpec spec;
         spec.InitializeSpec(kAssemblyRef, GetMDImport(), GetDomainFile(GetAppDomain())->GetDomainAssembly(), IsIntrospectionOnly());
-#if defined(FEATURE_CORECLR)      
         // Set the binding context in the AssemblySpec if one is available. This can happen if the LoadAssembly ended up
         // invoking the custom AssemblyLoadContext implementation that returned a reference to an assembly bound to a different
         // AssemblyLoadContext implementation.
@@ -6163,7 +5958,6 @@ DomainAssembly * Module::LoadAssembly(
         {
             spec.SetBindingContext(pBindingContext);
         }
-#endif // defined(FEATURE_CORECLR)
         if (szWinRtTypeClassName != NULL)
         {
             spec.SetWindowsRuntimeType(szWinRtTypeNamespace, szWinRtTypeClassName);
@@ -7444,84 +7238,6 @@ void Module::UpdateDynamicMetadataIfNeeded()
 
 #ifdef DEBUGGING_SUPPORTED 
 
-#ifdef FEATURE_FUSION
-
-// Fetch Pdbs from the host
-// 
-// Returns:
-//    No explicit return value. 
-//    Caches the pdb stream on the module instance if available.
-//    Does nothing if not hosted or if the host does not provide a stream.
-//    Throws on exception if the host does provide a stream, but we can't copy it out. 
-//    
-// Notes:
-//    This fetches PDBs from the host and caches them so that they are available for when the debugger attaches.
-//    This lets Arrowhead tools run against Whidbey hosts in a compatibility mode.
-//    We expect to add a hosting knob that will allow a host to disable this eager fetching and not run in
-//    compat mode.
-void Module::FetchPdbsFromHost()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr;
-    
-    ReleaseHolder<IStream> pHostStream;
-
-    hr = GetHostPdbStream(&pHostStream); // addrefs, holder will release
-    if (pHostStream == NULL)
-    {
-        // Common failure case, we're either not hosted, or the host doesn't have a stream.
-        return;
-    }
-    // pHostStream is a stream implemented by the host, so be extra cautious about methods failing,
-    // especially with E_NOTIMPL.
-
-    SafeComHolder<CGrowableStream> pStream(new CGrowableStream()); // throws
-
-    //
-    // Copy from pHostStream (owned by host) to CGrowableStream (owned by CLR, and visible to debugger from OOP).
-    // 
-    
-    // Get number of bytes to copy.
-    STATSTG     SizeData = {0};
-    hr = pHostStream->Stat(&SizeData, STATFLAG_NONAME);
-    IfFailThrow(hr);
-    ULARGE_INTEGER streamSize = SizeData.cbSize;
-
-    if (streamSize.u.HighPart > 0)
-    {
-        // Too big. We shouldn't have a PDB larger than 4gb. 
-        ThrowHR(E_OUTOFMEMORY);
-    }
-    ULONG cbRequest = streamSize.u.LowPart;
-
-
-    // Allocate 
-    hr = pStream->SetSize(streamSize);
-    IfFailThrow(hr);
-
-    _ASSERTE(pStream->GetRawBuffer().Size() == cbRequest);
-
-    // Do the actual copy
-    ULONG cbActualRead = 0;
-    hr = pHostStream->Read(pStream->GetRawBuffer().StartAddress(), cbRequest, &cbActualRead);
-    IfFailThrow(hr);
-    if (cbRequest != cbActualRead)
-    {
-        ThrowWin32(ERROR_READ_FAULT);
-    }
-
-    // We now have a full copy of the PDB provided from the host. 
-    // This addrefs pStream, which lets it survive past the holder's scope.
-    SetInMemorySymbolStream(pStream, eSymbolFormatPDB);
-}
-#endif // FEATURE_FUSION
 
 #endif // DEBUGGING_SUPPORTED
 
@@ -7540,16 +7256,6 @@ BOOL Module::NotifyDebuggerLoad(AppDomain *pDomain, DomainFile * pDomainFile, in
         pModule->UpdateDynamicMetadataIfNeeded();
     }
 
-#ifdef FEATURE_FUSION
-    // Eagerly fetch pdbs for hosted modules.
-    // This is only needed for debugging, so errors are not fatal in normal cases.
-    HRESULT hrFetchPdbs = S_OK;
-    EX_TRY
-    {
-        FetchPdbsFromHost();
-    }
-    EX_CATCH_HRESULT(hrFetchPdbs);
-#endif // FEATURE_FUSION
 
     //
     // Remaining work is only needed if a debugger is attached
@@ -9866,12 +9572,6 @@ void Module::PrepareTypesForSave(DataImage *image)
             PrepareRemotableMethodInfo(pMT);
 #endif // FEATURE_REMOTING
 
-#ifdef FEATURE_CER
-            // If this module defines any CriticalFinalizerObject derived classes,
-            // then we'll prepare these types for Constrained Execution Regions (CER) now.
-            // (Normally they're prepared at object instantiation time, a little too late for ngen).
-            PrepareCriticalType(pMT);
-#endif // FEATURE_CER
         }
     }
 
@@ -9955,9 +9655,6 @@ void Module::Save(DataImage *image)
     // Cache values of all persisted flags computed from custom attributes
     IsNoStringInterning();
     IsRuntimeWrapExceptions();
-#ifdef FEATURE_CER
-    GetReliabilityContract();
-#endif
     IsPreV4Assembly();
 
     HasDefaultDllImportSearchPathsAttribute();
@@ -10312,12 +10009,6 @@ void Module::Save(DataImage *image)
                           m_nPropertyNameSet * sizeof(BYTE),
                           DataImage::ITEM_PROPERTY_NAME_SET);
 
-#ifdef FEATURE_CER
-    // Save Constrained Execution Region (CER) fixup information (used to eagerly fixup trees of methods to avoid any runtime
-    // induced failures when invoking the tree).
-    if (m_pCerNgenRootTable != NULL)
-        m_pCerNgenRootTable->Save(image, profileData);
-#endif
 
     // Sort the list of RVA statics in an ascending order wrt the RVA
     // and save them.
@@ -10773,18 +10464,6 @@ void Module::PlaceMethod(DataImage *image, MethodDesc *pMD, DWORD profilingFlags
         image->PlaceStructureForAddress(pMD, CORCOMPILE_SECTION_WRITE);
     }
 
-#ifdef FEATURE_CER
-    if (profilingFlags & (1 << ReadCerMethodList))
-    {
-        // protect against stale IBC data
-        // Check if the profiling data incorrectly set the ReadCerMethodList bit.
-        // This is more likely to happen with incremental IBC.
-        if ((m_pCerNgenRootTable != NULL) && m_pCerNgenRootTable->IsNgenRootMethod(pMD))
-        {
-            image->PlaceStructureForAddress(m_pCerNgenRootTable->GetList(pMD), CORCOMPILE_SECTION_HOT);
-        }
-    }
-#endif // FEATURE_CER
 
     if (profilingFlags & (1 << WriteMethodPrecode))
     {
@@ -11328,24 +11007,6 @@ void Module::Fixup(DataImage *image)
     image->ZeroField(m_FileReferencesMap.pTable, 0,
                      m_FileReferencesMap.GetSize() * sizeof(void*));
 
-#ifdef FEATURE_CER
-    //
-    // Fixup Constrained Execution Regions restoration records.
-    //
-    if (m_pCerNgenRootTable != NULL)
-    {
-        image->BeginRegion(CORINFO_REGION_HOT);
-        image->FixupPointerField(this, offsetof(Module, m_pCerNgenRootTable));
-        m_pCerNgenRootTable->Fixup(image);
-        image->EndRegion(CORINFO_REGION_HOT);
-    }
-    else
-        image->ZeroPointerField(this, offsetof(Module, m_pCerNgenRootTable));
-
-    // Zero out fields we always compute at runtime lazily.
-    image->ZeroField(this, offsetof(Module, m_pCerPrepInfo), sizeof(m_pCerPrepInfo));
-    image->ZeroField(this, offsetof(Module, m_pCerCrst), sizeof(m_pCerCrst));
-#endif // FEATURE_CER
 
     image->ZeroField(this, offsetof(Module, m_debuggerSpecificData), sizeof(m_debuggerSpecificData));
 
@@ -15609,159 +15270,6 @@ FieldDesc *Module::LookupFieldDef(mdFieldDef token)
 #endif // DACCESS_COMPILE
 
 
-#if !defined(DACCESS_COMPILE) && defined(FEATURE_CER)
-
-// Access to CerPrepInfo, the structure used to track CERs prepared at runtime (as opposed to ngen time). GetCerPrepInfo will
-// return the structure associated with the given method desc if it exists or NULL otherwise. CreateCerPrepInfo will get the
-// structure if it exists or allocate and return a new struct otherwise. Creation of CerPrepInfo structures is automatically
-// synchronized by the CerCrst (lazily allocated as needed).
-CerPrepInfo *Module::GetCerPrepInfo(MethodDesc *pMD)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        SO_TOLERANT;
-        PRECONDITION(CheckPointer(pMD));
-    }
-    CONTRACTL_END;
-
-    if (m_pCerPrepInfo == NULL)
-        return NULL;
-
-    // Don't need a crst for read only access to the hash table.
-    HashDatum sDatum;
-    if (m_pCerPrepInfo->GetValue(pMD, &sDatum))
-        return (CerPrepInfo*)sDatum;
-    else
-        return NULL;
-}
-
-CerPrepInfo *Module::CreateCerPrepInfo(MethodDesc *pMD)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pMD));
-    }
-    CONTRACTL_END;
-
-    // Lazily allocate a Crst to serialize update access to the info structure.
-    // Carefully synchronize to ensure we don't leak a Crst in race conditions.
-    if (m_pCerCrst == NULL)
-    {
-        Crst *pCrst = new Crst(CrstCer);
-        if (InterlockedCompareExchangeT(&m_pCerCrst, pCrst, NULL) != NULL)
-            delete pCrst;
-    }
-
-    CrstHolder sCrstHolder(m_pCerCrst);
-
-    // Lazily allocate the info structure.
-    if (m_pCerPrepInfo == NULL)
-    {
-        LockOwner sLock = {m_pCerCrst, IsOwnerOfCrst};
-        NewHolder <EEPtrHashTable> tempCerPrepInfo (new EEPtrHashTable());
-        if (!tempCerPrepInfo->Init(CER_DEFAULT_HASH_SIZE, &sLock))
-            COMPlusThrowOM();
-        m_pCerPrepInfo = tempCerPrepInfo.Extract ();
-    }
-    else
-    {
-        // Try getting an existing value first.
-        HashDatum sDatum;
-        if (m_pCerPrepInfo->GetValue(pMD, &sDatum))
-            return (CerPrepInfo*)sDatum;
-    }
-
-    // We get here if there was no info structure or no existing method desc entry. Either way we now have an info structure and
-    // need to create a new method desc entry.
-    NewHolder<CerPrepInfo> pInfo(new CerPrepInfo());
-
-    m_pCerPrepInfo->InsertValue(pMD, (HashDatum)pInfo);
-
-    return pInfo.Extract();
-}
-
-#ifdef FEATURE_NATIVE_IMAGE_GENERATION
-// Access to CerNgenRootTable which holds holds information for all the CERs rooted at a method in this module (that were
-// discovered during an ngen).
-
-// Add a list of MethodContextElements representing a CER to the root table keyed by the MethodDesc* of the root method. Creates
-// or expands the root table as necessary. This should only be called during ngen (at runtime we only read the table).
-void Module::AddCerListToRootTable(MethodDesc *pRootMD, MethodContextElement *pList)
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(IsCompilationProcess());
-    }
-    CONTRACTL_END;
-
-    // Although this is only called during ngen we still get cases where a module comes through here already ngen'd (because of
-    // ngen's habit of letting code execute during compilation). Until that's fixed we'll just back out if the module has already
-    // fixed the root table into unwriteable storage.
-    if (m_pCerNgenRootTable && !(m_dwTransientFlags & M_CER_ROOT_TABLE_ON_HEAP))
-        return;
-
-    // Lazily allocate a Crst to serialize update access to the info structure.
-    // Carefully synchronize to ensure we don't leak a Crst in race conditions.
-    if (m_pCerCrst == NULL)
-    {
-        Crst *pCrst = new Crst(CrstCer);
-        if (InterlockedCompareExchangeT(&m_pCerCrst, pCrst, NULL) != NULL)
-            delete pCrst;
-    }
-
-    CrstHolder sCrstHolder(m_pCerCrst);
-
-    // Lazily allocate the root table structure.
-    if (m_pCerNgenRootTable == NULL)
-    {
-        FastInterlockOr(&m_dwTransientFlags, M_CER_ROOT_TABLE_ON_HEAP);
-        m_pCerNgenRootTable = new CerNgenRootTable();
-    }
-
-    _ASSERTE(m_dwTransientFlags & M_CER_ROOT_TABLE_ON_HEAP);
-
-    // And add the new element.
-    m_pCerNgenRootTable->AddRoot(pRootMD, pList);
-}
-#endif // FEATURE_NATIVE_IMAGE_GENERATION
-
-#ifdef FEATURE_PREJIT 
-// Returns true if the given method is a CER root detected at ngen time.
-bool Module::IsNgenCerRootMethod(MethodDesc *pMD)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-    _ASSERTE(pMD->GetModule() == this);
-    if (m_pCerNgenRootTable)
-        return m_pCerNgenRootTable->IsNgenRootMethod(pMD);
-    return false;
-}
-
-// Restores the CER rooted at this method (no-op if this method isn't a CER root).
-void Module::RestoreCer(MethodDesc *pMD)
-{
-    STANDARD_VM_CONTRACT;
-    _ASSERTE(pMD->GetModule() == this);
-    if (m_pCerNgenRootTable)
-        m_pCerNgenRootTable->Restore(pMD);
-}
-
-#endif // FEATURE_PREJIT
-
-#endif // !DACCESS_COMPILE && FEATURE_CER
 
 
 
@@ -15794,7 +15302,6 @@ LPCWSTR Module::GetPathForErrorMessages()
     }
 }
 
-#ifdef FEATURE_CORECLR
 #ifndef DACCESS_COMPILE
 BOOL IsVerifiableWrapper(MethodDesc* pMD)
 {
@@ -15861,9 +15368,6 @@ void Module::VerifyAllMethods()
     };
     //Verify all methods in a module eagerly, forcing them to get loaded.
 
-    /* XXX Thu 4/26/2007
-     * This code is lifted mostly from Validator.cpp
-     */
     IMDInternalImport * pMDI = GetMDImport();
     HENUMTypeDefInternalHolder hEnum(pMDI);
     mdTypeDef td;
@@ -15887,7 +15391,6 @@ void Module::VerifyAllMethods()
         EEFileLoadException::Throw(GetFile(), COR_E_VERIFICATION);
 #endif //DACCESS_COMPILE
 }
-#endif //FEATURE_CORECLR
 
 
 #if defined(_DEBUG) && !defined(DACCESS_COMPILE) && !defined(CROSS_COMPILE)
diff --git a/src/vm/ceeload.h b/src/vm/ceeload.h
index d15bd6b3d1..42023b3ec1 100644
--- a/src/vm/ceeload.h
+++ b/src/vm/ceeload.h
@@ -13,9 +13,6 @@
 #define CEELOAD_H_
 
 #include "common.h"
-#ifdef FEATURE_FUSION
-#include <fusion.h>
-#endif
 #include "vars.hpp" // for LPCUTF8
 #include "hash.h"
 #include "clsload.hpp"
@@ -95,7 +92,6 @@ class PersistentInlineTrackingMap;
 #define GUID_TO_TYPE_HASH_BUCKETS 16
             
 // The native symbol reader dll name
-#ifdef FEATURE_CORECLR
 #if defined(_AMD64_)
 #define NATIVE_SYMBOL_READER_DLL W("Microsoft.DiaSymReader.Native.amd64.dll")
 #elif defined(_X86_)
@@ -107,9 +103,6 @@ class PersistentInlineTrackingMap;
 //#define NATIVE_SYMBOL_READER_DLL W("Microsoft.DiaSymReader.Native.arm64.dll")
 #define NATIVE_SYMBOL_READER_DLL W("diasymreader.dll")
 #endif
-#else
-#define NATIVE_SYMBOL_READER_DLL W("diasymreader.dll")
-#endif
 
 typedef DPTR(PersistentInlineTrackingMap) PTR_PersistentInlineTrackingMap;
 
@@ -2185,11 +2178,6 @@ protected:
 
     virtual void ReleaseILData();
 
-#ifdef FEATURE_FUSION
-    void FusionCopyPDBs(LPCWSTR moduleName);
-    // This function will return PDB stream if exist.
-    HRESULT GetHostPdbStream(IStream **ppStream);
-#endif // FEATURE_FUSION
 
 #endif // DACCESS_COMPILE
 
@@ -3394,12 +3382,6 @@ public:
     //-----------------------------------------------------------------------------------------
     BOOL                    IsPreV4Assembly();
 
-#ifdef FEATURE_CER
-    //-----------------------------------------------------------------------------------------
-    // Get reliability contract info, see ConstrainedExecutionRegion.cpp for details.
-    //-----------------------------------------------------------------------------------------
-    DWORD                   GetReliabilityContract();
-#endif
 
     //-----------------------------------------------------------------------------------------
     // Parse/Return NeutralResourcesLanguageAttribute if it exists (updates Module member variables at ngen time)
@@ -3408,50 +3390,13 @@ public:
 
 protected:
 
-#ifdef FEATURE_CER
-    Volatile<DWORD>         m_dwReliabilityContract;
-#endif
 
     // initialize Crst controlling the Dynamic IL hashtables
     void                    InitializeDynamicILCrst();
 
 public:
-#if !defined(DACCESS_COMPILE) && defined(FEATURE_CER)
-
-    // Support for getting and creating information about Constrained Execution Regions rooted in this module.
-
-    // Access to CerPrepInfo, the structure used to track CERs prepared at runtime (as opposed to ngen time). GetCerPrepInfo will
-    // return the structure associated with the given method desc if it exists or NULL otherwise. CreateCerPrepInfo will get the
-    // structure if it exists or allocate and return a new struct otherwise. Creation of CerPrepInfo structures is automatically
-    // synchronized by the CerCrst (lazily allocated as needed).
-    CerPrepInfo *GetCerPrepInfo(MethodDesc *pMD);
-    CerPrepInfo *CreateCerPrepInfo(MethodDesc *pMD);
-
-#ifdef FEATURE_PREJIT
-    // Access to CerNgenRootTable which holds holds information for all the CERs rooted at a method in this module (that were
-    // discovered during an ngen).
 
-    // Add a list of MethodContextElements representing a CER to the root table keyed by the MethodDesc* of the root method. Creates
-    // or expands the root table as necessary.
-    void AddCerListToRootTable(MethodDesc *pRootMD, MethodContextElement *pList);
-
-    // Returns true if the given method is a CER root detected at ngen time.
-    bool IsNgenCerRootMethod(MethodDesc *pMD);
-
-    // Restores the CER rooted at this method (no-op if this method isn't a CER root).
-    void RestoreCer(MethodDesc *pMD);
-#endif // FEATURE_PREJIT
-
-    Crst *GetCerCrst()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return m_pCerCrst;
-    }
-#endif // !DACCESS_COMPILE && FEATURE_CER
-
-#ifdef FEATURE_CORECLR
     void VerifyAllMethods();
-#endif //FEATURE_CORECLR
 
     CrstBase *GetLookupTableCrst()
     {
@@ -3460,13 +3405,6 @@ public:
     }
 
 private:
-#ifdef FEATURE_CER
-    EEPtrHashTable       *m_pCerPrepInfo;       // Root methods prepared for Constrained Execution Regions
-    Crst                 *m_pCerCrst;           // Mutex protecting update access to both of the above hashes
-#ifdef FEATURE_PREJIT
-    CerNgenRootTable     *m_pCerNgenRootTable;  // Root methods of CERs found during ngen and requiring runtime restoration
-#endif
-#endif
 
     // This struct stores the data used by the managed debugging infrastructure.  If it turns out that 
     // the debugger is increasing the size of the Module class by too much, we can consider allocating
diff --git a/src/vm/ceemain.cpp b/src/vm/ceemain.cpp
index 0f455f17eb..850bee3f08 100644
--- a/src/vm/ceemain.cpp
+++ b/src/vm/ceemain.cpp
@@ -213,10 +213,6 @@
 
 #include "bbsweep.h"
 
-#ifndef FEATURE_CORECLR
-#include <metahost.h>
-#include "assemblyusagelogmanager.h"
-#endif
 
 #ifdef FEATURE_COMINTEROP
 #include "runtimecallablewrapper.h"
@@ -244,9 +240,7 @@
 #include "interpreter.h"
 #endif // FEATURE_INTERPRETER
 
-#ifndef FEATURE_FUSION
 #include "../binder/inc/coreclrbindercommon.h"
-#endif // !FEATURE_FUSION
 
 #ifdef FEATURE_UEF_CHAINMANAGER
 // This is required to register our UEF callback with the UEF chain manager
@@ -275,21 +269,12 @@ static HRESULT GetThreadUICultureNames(__inout StringArrayList* pCultureNames);
 #endif // !CROSSGEN_COMPILE
 
 HRESULT EEStartup(COINITIEE fFlags);
-#ifdef FEATURE_FUSION
-extern "C" HRESULT STDMETHODCALLTYPE InitializeFusion();
-#endif
 
 #ifdef FEATURE_MIXEDMODE
 HRESULT PrepareExecuteDLLForThunk(HINSTANCE hInst,
                                   DWORD dwReason,
                                   LPVOID lpReserved);
 #endif // FEATURE_MIXEDMODE
-#ifndef FEATURE_CORECLR
-BOOL STDMETHODCALLTYPE ExecuteDLL(HINSTANCE hInst,
-                                  DWORD dwReason,
-                                  LPVOID lpReserved,
-                                  BOOL fFromThunk);
-#endif // !FEATURE_CORECLR
 
 BOOL STDMETHODCALLTYPE ExecuteEXE(HMODULE hMod);
 BOOL STDMETHODCALLTYPE ExecuteEXE(__in LPWSTR pImageNameIn);
@@ -305,12 +290,6 @@ extern "C" HRESULT __cdecl CorDBGetInterface(DebugInterface** rcInterface);
 #endif // !CROSSGEN_COMPILE
 
 
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-
-// Pointer to the activated CLR interface provided by the shim.
-ICLRRuntimeInfo *g_pCLRRuntime = NULL;
-
-#endif // !FEATURE_CORECLR && !CROSSGEN_COMPILE
 
 extern "C" IExecutionEngine* __stdcall IEE();
 
@@ -391,7 +370,7 @@ HRESULT EnsureEEStarted(COINITIEE flags)
     {
         BEGIN_ENTRYPOINT_NOTHROW;
 
-#if defined(FEATURE_CORECLR) && defined(FEATURE_APPX) && !defined(CROSSGEN_COMPILE)
+#if defined(FEATURE_APPX) && !defined(CROSSGEN_COMPILE)
         STARTUP_FLAGS startupFlags = CorHost2::GetStartupFlags();
         // On CoreCLR, the host is in charge of determining whether the process is AppX or not.
         AppX::SetIsAppXProcess(!!(startupFlags & STARTUP_APPX_APP_MODEL));
@@ -528,58 +507,7 @@ static BOOL WINAPI DbgCtrlCHandler(DWORD dwCtrlType)
 // A host can specify that it only wants one version of hosting interface to be used.
 BOOL g_singleVersionHosting;
 
-#ifndef FEATURE_CORECLR
-HRESULT STDMETHODCALLTYPE 
-SetRuntimeInfo(
-    IUnknown *                pUnk, 
-    STARTUP_FLAGS             dwStartupFlags, 
-    LPCWSTR                   pwzHostConfig, 
-    const CoreClrCallbacks ** ppClrCallbacks)
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        ENTRY_POINT;
-        PRECONDITION(CheckPointer(pUnk));
-        PRECONDITION(CheckPointer(pwzHostConfig, NULL_OK));
-    } CONTRACTL_END;
-
-    ICLRRuntimeInfo *pRuntime;
-    HRESULT hr;
-    
-    IfFailGo(pUnk->QueryInterface(IID_ICLRRuntimeInfo, (LPVOID *)&pRuntime));
-
-    IfFailGo(CorHost2::SetFlagsAndHostConfig(dwStartupFlags, pwzHostConfig, FALSE));
-
-    if (InterlockedCompareExchangeT(&g_pCLRRuntime, pRuntime, NULL) != NULL)
-    {
-        // already set, release this one
-        pRuntime->Release();
-    }
-    *ppClrCallbacks = &GetClrCallbacks();
 
-ErrExit:
-    return hr;
-}
-#endif // !FEATURE_CORECLR
-
-#ifndef FEATURE_CORECLR
-HRESULT InitializeHostConfigFile()
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(return E_OUTOFMEMORY);
-    } CONTRACTL_END;
-
-    g_pszHostConfigFile = CorHost2::GetHostConfigFile();
-    g_dwHostConfigFile = (g_pszHostConfigFile == NULL ? 0 : wcslen(g_pszHostConfigFile));
-
-    return S_OK;
-}
-#endif // !FEATURE_CORECLR
 
 void InitializeStartupFlags()
 {
@@ -591,54 +519,12 @@ void InitializeStartupFlags()
 
     STARTUP_FLAGS flags = CorHost2::GetStartupFlags();
 
-#ifndef FEATURE_CORECLR
-    // If we are running under a requested performance default mode, honor any changes to startup flags
-    // In the future, we could make this conditional on the host telling us which subset of flags is 
-    // valid to override.  See file:PerfDefaults.h
-    flags = PerformanceDefaults::GetModifiedStartupFlags(flags);
-#endif // !FEATURE_CORECLR
 
     if (flags & STARTUP_CONCURRENT_GC)
         g_IGCconcurrent = 1;
     else
         g_IGCconcurrent = 0;
 
-#ifndef FEATURE_CORECLR // TODO: We can remove this. Retaining it now just to be safe
-    if (flags & STARTUP_SINGLE_VERSION_HOSTING_INTERFACE)
-    {
-        g_singleVersionHosting = TRUE;
-    }
-
-#ifndef FEATURE_CORECLR
-    g_pConfig->SetDisableCommitThreadStack(!CLRHosted() || (flags & STARTUP_DISABLE_COMMITTHREADSTACK));
-#else
-    g_pConfig->SetDisableCommitThreadStack(true);
-#endif
-
-    if(flags & STARTUP_LEGACY_IMPERSONATION)
-        g_pConfig->SetLegacyImpersonationPolicy();
-
-    if(flags & STARTUP_ALWAYSFLOW_IMPERSONATION)
-        g_pConfig->SetAlwaysFlowImpersonationPolicy();
-
-    if(flags & STARTUP_HOARD_GC_VM)
-        g_IGCHoardVM = 1;
-    else
-        g_IGCHoardVM = 0;
-
-#ifdef GCTRIMCOMMIT
-    if (flags & STARTUP_TRIM_GC_COMMIT)
-        g_IGCTrimCommit = 1;
-    else
-        g_IGCTrimCommit = 0;
-#endif
-
-    if(flags & STARTUP_ETW)
-        g_fEnableETW = TRUE;
-
-    if(flags & STARTUP_ARM)
-        g_fEnableARM = TRUE;
-#endif // !FEATURE_CORECLR
 
     InitializeHeapType((flags & STARTUP_SERVER_GC) != 0);
 
@@ -740,37 +626,6 @@ void InitGSCookie()
     }
 }
 
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-void InitAssemblyUsageLogManager()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    } CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    g_pIAssemblyUsageLogGac = NULL;
-
-    AssemblyUsageLogManager::Config config;
-
-    config.wszLogDir = NULL;
-    config.cLogBufferSize = 32768;
-#ifdef FEATURE_APPX
-    config.uiLogRefreshInterval = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_NGenAssemblyUsageLogRefreshInterval);
-#endif
-
-    NewArrayHolder<WCHAR> szCustomLogDir(CLRConfig::GetConfigValue(CLRConfig::INTERNAL_NGenAssemblyUsageLog));
-    config.wszLogDir = szCustomLogDir;
-
-    AssemblyUsageLogManager::Init(&config);
-
-    // Once the logger is initialized, create a log object for logging GAC loads.
-    AssemblyUsageLogManager::GetUsageLogForContext(W("fusion"), W("GAC"), &g_pIAssemblyUsageLogGac);
-}
-#endif
 
 // ---------------------------------------------------------------------------
 // %%Function: EEStartupHelper
@@ -845,10 +700,6 @@ void EEStartupHelper(COINITIEE fFlags)
         if (!g_pConfig)
         {
             IfFailGo(EEConfig::Setup());
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-            IfFailGo(InitializeHostConfigFile());
-            IfFailGo(g_pConfig->SetupConfiguration());
-#endif // !FEATURE_CORECLR && !CROSSGEN_COMPILE
         }
 
 #ifndef CROSSGEN_COMPILE
@@ -858,11 +709,6 @@ void EEStartupHelper(COINITIEE fFlags)
         NumaNodeInfo::InitNumaNodeInfo();
         CPUGroupInfo::EnsureInitialized();
 
-#ifndef FEATURE_CORECLR
-        // Check in EEConfig whether a workload-specific set of performance defaults have been requested
-        // This needs to be done before InitializeStartupFlags in case one is to be overridden
-        PerformanceDefaults::InitializeForScenario(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_PerformanceScenario));
-#endif
 
         // Initialize global configuration settings based on startup flags
         // This needs to be done before the EE has started
@@ -897,10 +743,6 @@ void EEStartupHelper(COINITIEE fFlags)
 
 #endif // CROSSGEN_COMPILE
 
-#ifndef FEATURE_CORECLR
-        // Ensure initialization of Apphacks environment variables
-        GetGlobalCompatibilityFlags();
-#endif // !FEATURE_CORECLR
 
 #ifdef STRESS_LOG
         if (REGUTIL::GetConfigDWORD_DontUse_(CLRConfig::UNSUPPORTED_StressLog, g_pConfig->StressLog ()) != 0) {
@@ -935,15 +777,8 @@ void EEStartupHelper(COINITIEE fFlags)
 #endif
 
         // Fusion
-#ifdef FEATURE_FUSION 
-        {
-            ETWOnStartup (FusionInit_V1, FusionInitEnd_V1);
-            IfFailGoLog(InitializeFusion());
-        }
-#else // FEATURE_FUSION
         // Initialize the general Assembly Binder infrastructure
         IfFailGoLog(CCoreCLRBinderHelper::Init());
-#endif // FEATURE_FUSION
 
         if (g_pConfig != NULL)
         {
@@ -988,16 +823,6 @@ void EEStartupHelper(COINITIEE fFlags)
 
 #ifndef CROSSGEN_COMPILE
 
-#if defined(STRESS_HEAP) && defined(_DEBUG) && !defined(FEATURE_CORECLR)
-        // TODO: is this still an issue?
-        // There is a race that causes random AVs on dual proc boxes
-        // that we suspect is due to memory coherancy problems (see Whidbey bug 2360)
-        // Avoid the issue by making the box effectively single proc.
-        if (GCStress<cfg_instr>::IsEnabled() &&
-            g_SystemInfo.dwNumberOfProcessors > 1)
-            SetProcessAffinityMask(GetCurrentProcess(),
-                                   1 << (DbgGetEXETimeStamp() % g_SystemInfo.dwNumberOfProcessors));
-#endif // STRESS_HEAP && _DEBUG && !FEATURE_CORECLR
 
 #ifdef FEATURE_PREJIT
         // Initialize the sweeper thread.  THis is violating our rules with hosting
@@ -1099,10 +924,6 @@ void EEStartupHelper(COINITIEE fFlags)
 
         GCInterface::m_MemoryPressureLock.Init(CrstGCMemoryPressure);
 
-#ifndef FEATURE_CORECLR
-        // Initialize Assembly Usage Logger
-        InitAssemblyUsageLogManager();
-#endif
 
 #endif // CROSSGEN_COMPILE
 
@@ -1239,9 +1060,6 @@ void EEStartupHelper(COINITIEE fFlags)
         SystemDomain::System()->PublishAppDomainAndInformDebugger(SystemDomain::System()->DefaultDomain());
 #endif
  
-#ifndef FEATURE_CORECLR
-        ExistingOobAssemblyList::Init();
-#endif
 
 #endif // CROSSGEN_COMPILE
 
@@ -1329,12 +1147,10 @@ void EEStartupHelper(COINITIEE fFlags)
         }
 
         //For a similar reason, let's not run VerifyAllOnLoad either.
-#ifdef FEATURE_CORECLR
         if (g_pConfig->VerifyModulesOnLoad())
         {
             SystemDomain::SystemModule()->VerifyAllMethods();
         }
-#endif //FEATURE_CORECLR
 
         // Perform mscorlib consistency check if requested
         g_Mscorlib.CheckExtended();
@@ -1595,11 +1411,6 @@ static void ExternalShutdownHelper(int exitCode, ShutdownCompleteAction sca)
     // process exit code.  This can be modified by the app via System.SetExitCode().
     SetLatchedExitCode(exitCode);
 
-#ifndef FEATURE_CORECLR // no shim
-    // Bump up the ref-count on the module
-    for (int i =0; i<6; i++)
-        CLRLoadLibrary(MSCOREE_SHIM_W);
-#endif // FEATURE_CORECLR
 
     ForceEEShutdown(sca);
 
@@ -1671,12 +1482,6 @@ BOOL IsRuntimeStarted(DWORD *pdwStartupFlags)
     if (pdwStartupFlags != NULL) // this parameter is optional
     {
         *pdwStartupFlags = 0;
-#ifndef FEATURE_CORECLR
-        if (g_fEEStarted)
-        {
-            *pdwStartupFlags = CorHost2::GetStartupFlags();
-        }
-#endif
     }
     return g_fEEStarted;
 }
@@ -1791,7 +1596,7 @@ void STDMETHODCALLTYPE EEShutDownHelper(BOOL fIsDllUnloading)
         ETW::EnumerationLog::ProcessShutdown();
     }
 
-#if defined(FEATURE_CAS_POLICY) || defined(FEATURE_COMINTEROP)
+#if defined(FEATURE_COMINTEROP)
     // Get the current thread.
     Thread * pThisThread = GetThread();
 #endif
@@ -1869,14 +1674,6 @@ void STDMETHODCALLTYPE EEShutDownHelper(BOOL fIsDllUnloading)
             fFinalizeOK = FinalizerThread::FinalizerThreadWatchDog();
         }
 
-#ifndef FEATURE_CORECLR
-        if (!g_fFastExitProcess)
-        {
-            // Log usage data to disk. (Only do this in normal shutdown scenarios, and not involving ngen)
-            if (!IsCompilationProcess())
-                AssemblyUsageLogManager::GenerateLog(AssemblyUsageLogManager::GENERATE_LOG_FLAGS_NONE);
-        }
-#endif
 
         // Ok.  Let's stop the EE.
         if (!g_fProcessDetach)
@@ -1990,22 +1787,6 @@ void STDMETHODCALLTYPE EEShutDownHelper(BOOL fIsDllUnloading)
         }
 #endif // PROFILING_SUPPORTED
 
-#ifndef FEATURE_CORECLR
-        // CoEEShutDownCOM moved to
-        // the Finalizer thread. See bug 87809
-        if (!g_fProcessDetach && !g_fFastExitProcess)
-        {
-            g_fEEShutDown |= ShutDown_COM;
-            if (fFinalizeOK)
-            {
-                FinalizerThread::FinalizerThreadWatchDog();
-            }
-        }
-#ifdef _DEBUG
-        else
-            g_fEEShutDown |= ShutDown_COM;
-#endif
-#endif //FEATURE_CORECLR
 
 #ifdef _DEBUG
         g_fEEShutDown |= ShutDown_SyncBlock;
@@ -2015,15 +1796,6 @@ void STDMETHODCALLTYPE EEShutDownHelper(BOOL fIsDllUnloading)
             // because we are shutting down.
             CONTRACT_VIOLATION(ModeViolation);
 
-#ifdef FEATURE_CAS_POLICY
-            // Save the security policy cache as necessary.
-            if (!g_fProcessDetach || pThisThread != NULL)
-            {
-                // If process shutdown has started, it is not safe to create Thread object which is needed
-                // by the following call.
-                Security::SaveCache();
-            }
-#endif
 #ifdef FEATURE_COMINTEROP
             // We need to call CoUninitialize in part one to ensure orderly shutdown of COM dlls.
             if (!g_fFastExitProcess)
@@ -2662,75 +2434,6 @@ void STDMETHODCALLTYPE CoUninitializeEE(BOOL fIsDllUnloading)
 
 }
 
-#ifndef FEATURE_CORECLR
-//*****************************************************************************
-// This entry point is called from the native DllMain of the loaded image.
-// This gives the COM+ loader the chance to dispatch the loader event.  The
-// first call will cause the loader to look for the entry point in the user
-// image.  Subsequent calls will dispatch to either the user's DllMain or
-// their Module derived class.
-//*****************************************************************************
-BOOL STDMETHODCALLTYPE _CorDllMain(     // TRUE on success, FALSE on error.
-    HINSTANCE   hInst,                  // Instance handle of the loaded module.
-    DWORD       dwReason,               // Reason for loading.
-    LPVOID      lpReserved              // Unused.
-    )
-{
-    STATIC_CONTRACT_NOTHROW;
-    //STATIC_CONTRACT_GC_TRIGGERS;
-    STATIC_CONTRACT_ENTRY_POINT;
-
-    //BEGIN_ENTRYPOINT_NOTHROW;
-
-    struct Param
-    {
-        HINSTANCE hInst;
-        DWORD dwReason;
-        LPVOID lpReserved;
-        BOOL retval;
-    } param;
-    param.hInst = hInst;
-    param.dwReason = dwReason;
-    param.lpReserved = lpReserved;
-    param.retval = FALSE;
-
-    // Can't use PAL_TRY/EX_TRY here as they access the ClrDebugState which gets blown away as part of the
-    // PROCESS_DETACH path. Must use special PAL_TRY_FOR_DLLMAIN, passing the reason were in the DllMain.
-    PAL_TRY_FOR_DLLMAIN(Param *, pParam, &param, pParam->dwReason)
-    {
-#ifdef _DEBUG
-        if (CLRTaskHosted() &&
-            ((pParam->dwReason == DLL_PROCESS_ATTACH && pParam->lpReserved == NULL) ||  // LoadLibrary of a managed dll
-             (pParam->dwReason == DLL_PROCESS_DETACH && pParam->lpReserved == NULL)     // FreeLibrary of a managed dll
-             )) {
-            // OS loader lock is being held by the current thread.  We can not allow the fiber
-            // to be rescheduled here while processing DllMain for managed dll.
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES
-            IHostTask *pTask = GetCurrentHostTask();
-            if (pTask) {
-                Thread *pThread = GetThread();
-                _ASSERTE (pThread);
-                _ASSERTE (pThread->HasThreadAffinity());
-            }
-#endif // FEATURE_INCLUDE_ALL_INTERFACES
-        }
-#endif
-        // Since we're in _CorDllMain, we know that we were not called because of a
-        // bootstrap thunk, since they will call CorDllMainForThunk. Because of this,
-        // we can pass FALSE for the fFromThunk parameter.
-        pParam->retval = ExecuteDLL(pParam->hInst,pParam->dwReason,pParam->lpReserved, FALSE);
-    }
-    PAL_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
-    {
-    }
-    PAL_ENDTRY;
-
-    //END_ENTRYPOINT_NOTHROW;
-
-    return param.retval;
-}
-
-#endif // !FEATURE_CORECLR
 
 #ifdef FEATURE_MIXEDMODE
 //*****************************************************************************
@@ -2779,334 +2482,6 @@ void STDMETHODCALLTYPE CorDllMainForThunk(HINSTANCE hInst, HINSTANCE hInstShim)
 #endif // FEATURE_MIXEDMODE
 
 
-#ifndef FEATURE_CORECLR
-
-// This function will do some additional PE Checks to make sure everything looks good.
-// We must do these before we run any managed code (that's why we can't do them in PEVerifier, as
-// managed code is used to determine the policy settings)
-HRESULT DoAdditionalPEChecks(HINSTANCE hInst)
-{
-    STATIC_CONTRACT_NOTHROW;
-    STATIC_CONTRACT_GC_TRIGGERS;
-
-    struct Param
-    {
-        HINSTANCE hInst;
-        HRESULT hr;
-    } param;
-    param.hInst = hInst;
-    param.hr = S_OK;
-
-    PAL_TRY(Param *, pParam, &param)
-    {
-        PEDecoder pe(pParam->hInst);
-
-        if (!pe.CheckWillCreateGuardPage())
-            pParam->hr = COR_E_BADIMAGEFORMAT;
-    }
-    PAL_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
-    {
-    }
-    PAL_ENDTRY
-
-    return param.hr;
-}
-
-//*****************************************************************************
-// This entry point is called from the native entry point of the loaded
-// executable image.  This simply calls into _CorExeMainInternal, the real
-// entry point inside a filter to trigger unhandled exception processing in the 
-// event an exception goes unhandled, independent of the OS UEF mechanism.
-//*****************************************************************************
-__int32 STDMETHODCALLTYPE _CorExeMain(  // Executable exit code.
-    )
-{
-    STATIC_CONTRACT_GC_TRIGGERS;
-    STATIC_CONTRACT_THROWS;
-    
-    // We really have nothing to share with our filter at this point.
-    struct Param
-    {
-        PVOID pData;
-    } param;
-    param.pData = NULL;
-
-    PAL_TRY(Param*, _pParam, &param)
-    {
-        // Call the real function that will invoke the managed entry point
-        _CorExeMainInternal();
-    }
-    PAL_EXCEPT_FILTER(EntryPointFilter)
-    {
-        LOG((LF_STARTUP, LL_INFO10, "EntryPointFilter returned EXCEPTION_EXECUTE_HANDLER!"));
-    }
-    PAL_ENDTRY;
-
-    return 0;
-}
-
-//*****************************************************************************
-// This entry point is called from _CorExeMain. If an exception goes unhandled
-// from here, we will trigger unhandled exception processing in _CorExeMain.
-//
-// The command line arguments and other entry point data
-// will be gathered here.  The entry point for the user image will be found
-// and handled accordingly.
-//*****************************************************************************
-__int32 STDMETHODCALLTYPE _CorExeMainInternal(  // Executable exit code.
-    )
-{
-    STATIC_CONTRACT_GC_TRIGGERS;
-    STATIC_CONTRACT_THROWS;
-    STATIC_CONTRACT_ENTRY_POINT;
-    
-    // Yes, CorExeMain needs throws. If an exception passes through here, it will cause the
-    // "The application has generated an unhandled exception" dialog and offer to debug.
-
-    BEGIN_ENTRYPOINT_THROWS;
-
-    // Make sure PE file looks ok
-    HRESULT hr;
-    {
-        // We are early in the process, if we get an SO here we will just rip
-        CONTRACT_VIOLATION(SOToleranceViolation);
-        if (FAILED(hr = DoAdditionalPEChecks(WszGetModuleHandle(NULL))))
-        {
-            GCX_PREEMP();
-            VMDumpCOMErrors(hr);
-            SetLatchedExitCode (-1);
-            goto exit;
-        }
-    }
-
-    g_fEEManagedEXEStartup = TRUE;
-    // Before we initialize the EE, make sure we've snooped for all EE-specific
-    // command line arguments that might guide our startup.
-    WCHAR   *pCmdLine = WszGetCommandLine();
-    HRESULT result = CorCommandLine::SetArgvW(pCmdLine);
-
-    if (SUCCEEDED(result))
-    {
-        g_fWeOwnProcess = TRUE;
-        result = EnsureEEStarted(COINITEE_MAIN);
-    }
-
-    if (FAILED(result))
-    {
-        g_fWeOwnProcess = FALSE;
-        GCX_PREEMP();
-        VMDumpCOMErrors(result);
-        SetLatchedExitCode (-1);
-        goto exit;
-    }
-
-    INSTALL_UNWIND_AND_CONTINUE_HANDLER;
-
-    // This will be called from a EXE so this is a self referential file so I am going to call
-    // ExecuteEXE which will do the work to make a EXE load.
-
-    BOOL bretval = 0;
-
-    bretval = ExecuteEXE(WszGetModuleHandle(NULL));
-    if (!bretval) {
-        // The only reason I've seen this type of error in the wild is bad
-        // metadata file format versions and inadequate error handling for
-        // partially signed assemblies.  While this may happen during
-        // development, our customers should not get here.  This is a back-stop
-        // to catch CLR bugs. If you see this, please try to find a better way
-        // to handle your error, like throwing an unhandled exception.
-        EEMessageBoxCatastrophic(IDS_EE_COREXEMAIN_FAILED_TEXT, IDS_EE_COREXEMAIN_FAILED_TITLE);
-        SetLatchedExitCode (-1);
-    }
-
-    UNINSTALL_UNWIND_AND_CONTINUE_HANDLER;
-
-exit:
-    STRESS_LOG1(LF_STARTUP, LL_ALWAYS, "Program exiting: return code = %d", GetLatchedExitCode());
-
-    STRESS_LOG0(LF_STARTUP, LL_INFO10, "EEShutDown invoked from _CorExeMainInternal");
-
-    EEPolicy::HandleExitProcess();
-
-    END_ENTRYPOINT_THROWS;
-
-    return 0;
-}
-
-
-static BOOL CacheCommandLine(__in LPWSTR pCmdLine, __in_opt LPWSTR* ArgvW)
-{
-    CONTRACTL {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pCmdLine));
-        PRECONDITION(CheckPointer(ArgvW));
-    } CONTRACTL_END;
-
-    if (pCmdLine) {
-        size_t len = wcslen(pCmdLine);
-
-        _ASSERT(g_pCachedCommandLine== NULL);
-        g_pCachedCommandLine = new WCHAR[len+1];
-        wcscpy_s(g_pCachedCommandLine, len+1, pCmdLine);
-    }
-
-    if (ArgvW != NULL && ArgvW[0] != NULL) {
-        PathString wszModuleName;
-        PathString wszCurDir;
-        if (!WszGetCurrentDirectory(wszCurDir))
-            return FALSE;
-
-#ifdef _PREFAST_
-#pragma warning(push)
-#pragma warning(disable:25025)
-#endif
-
-        // usage of PathCombine is safe if we ensure that buffer specified by
-        // parameter1 can accomodate buffers specified by paramater2, parameter3
-        // and one path separator
-        COUNT_T wszModuleName_len = wszCurDir.GetCount() + lstrlenW(ArgvW[0]);
-        WCHAR* wszModuleName_buf = wszModuleName.OpenUnicodeBuffer(wszModuleName_len);
-
-        if (PathCombine(wszModuleName_buf, wszCurDir, ArgvW[0]) == NULL)
-            return FALSE;
-        wszModuleName.CloseBuffer();
-#ifdef _PREFAST_
-#pragma warning(pop)
-#endif
-
-        size_t len = wszModuleName.GetCount();
-        _ASSERT(g_pCachedModuleFileName== NULL);
-        g_pCachedModuleFileName = new WCHAR[len+1];
-        wcscpy_s(g_pCachedModuleFileName, len+1, wszModuleName);
-    }
-
-    return TRUE;
-}
-
-//*****************************************************************************
-// This entry point is called from the native entry point of the loaded
-// executable image.  The command line arguments and other entry point data
-// will be gathered here.  The entry point for the user image will be found
-// and handled accordingly.
-//*****************************************************************************
-__int32 STDMETHODCALLTYPE _CorExeMain2( // Executable exit code.
-    PBYTE   pUnmappedPE,                // -> memory mapped code
-    DWORD   cUnmappedPE,                // Size of memory mapped code
-    __in LPWSTR  pImageNameIn,          // -> Executable Name
-    __in LPWSTR  pLoadersFileName,      // -> Loaders Name
-    __in LPWSTR  pCmdLine)              // -> Command Line
-{
-
-    // This entry point is used by clix
-    BOOL bRetVal = 0;
-
-    BEGIN_ENTRYPOINT_VOIDRET;
-    {
-        // Before we initialize the EE, make sure we've snooped for all EE-specific
-        // command line arguments that might guide our startup.
-        HRESULT result = CorCommandLine::SetArgvW(pCmdLine);
-
-        if (!CacheCommandLine(pCmdLine, CorCommandLine::GetArgvW(NULL))) {
-            LOG((LF_STARTUP, LL_INFO10, "Program exiting - CacheCommandLine failed\n"));
-            bRetVal = -1;
-            goto exit;
-        }
-
-        if (SUCCEEDED(result))
-            result = InitializeEE(COINITEE_MAIN);
-
-        if (FAILED(result)) {
-            VMDumpCOMErrors(result);
-            SetLatchedExitCode (-1);
-            goto exit;
-        }
-
-        // Load the executable
-        bRetVal = ExecuteEXE(pImageNameIn);
-
-        if (!bRetVal) {
-            // The only reason I've seen this type of error in the wild is bad
-            // metadata file format versions and inadequate error handling for
-            // partially signed assemblies.  While this may happen during
-            // development, our customers should not get here.  This is a back-stop
-            // to catch CLR bugs. If you see this, please try to find a better way
-            // to handle your error, like throwing an unhandled exception.
-            EEMessageBoxCatastrophic(IDS_EE_COREXEMAIN2_FAILED_TEXT, IDS_EE_COREXEMAIN2_FAILED_TITLE);
-            SetLatchedExitCode (-1);
-        }
-
-exit:
-        STRESS_LOG1(LF_STARTUP, LL_ALWAYS, "Program exiting: return code = %d", GetLatchedExitCode());
-
-        STRESS_LOG0(LF_STARTUP, LL_INFO10, "EEShutDown invoked from _CorExeMain2");
-
-        EEPolicy::HandleExitProcess();
-    }
-    END_ENTRYPOINT_VOIDRET;
-
-    return bRetVal;
-}
-
-//*****************************************************************************
-// This is the call point to wire up an EXE.  In this case we have the HMODULE
-// and just need to make sure we do to correct self referantial things.
-//*****************************************************************************
-
-
-BOOL STDMETHODCALLTYPE ExecuteEXE(HMODULE hMod)
-{
-    STATIC_CONTRACT_GC_TRIGGERS;
-
-    _ASSERTE(hMod);
-    if (!hMod)
-        return FALSE;
-
-    ETWFireEvent(ExecExe_V1);
-
-    struct Param
-    {
-        HMODULE hMod;
-    } param;
-    param.hMod = hMod;
-
-    EX_TRY_NOCATCH(Param *, pParam, &param)
-    {
-        // Executables are part of the system domain
-        SystemDomain::ExecuteMainMethod(pParam->hMod);
-    }
-    EX_END_NOCATCH;
-
-    ETWFireEvent(ExecExeEnd_V1);
-
-    return TRUE;
-}
-
-BOOL STDMETHODCALLTYPE ExecuteEXE(__in LPWSTR pImageNameIn)
-{
-    STATIC_CONTRACT_GC_TRIGGERS;
-
-    EX_TRY_NOCATCH(LPWSTR, pImageNameInner, pImageNameIn)
-    {
-        WCHAR               wzPath[MAX_LONGPATH];
-        DWORD               dwPathLength = 0;
-
-        // get the path of executable
-        dwPathLength = WszGetFullPathName(pImageNameInner, MAX_LONGPATH, wzPath, NULL);
-
-        if (!dwPathLength || dwPathLength > MAX_LONGPATH)
-        {
-            ThrowWin32( !dwPathLength ? GetLastError() : ERROR_FILENAME_EXCED_RANGE);
-        }
-
-        SystemDomain::ExecuteMainMethod( NULL, (WCHAR *)wzPath );
-    }
-    EX_END_NOCATCH;
-
-    return TRUE;
-}
-#endif //  FEATURE_CORECLR
 
 #ifdef FEATURE_MIXEDMODE
 
@@ -3449,31 +2824,6 @@ BOOL ExecuteDLL_ReturnOrThrow(HRESULT hr, BOOL fFromThunk)
     return SUCCEEDED(hr);
 }
 
-#if !defined(FEATURE_CORECLR) && defined(_DEBUG)
-//*****************************************************************************
-// Factor some common debug code.
-//*****************************************************************************
-static void EnsureManagedThreadExistsForHostedThread()
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    } CONTRACTL_END;
-
-    if (CLRTaskHosted()) {
-        // If CLR is hosted, and this is on a thread that a host controls,
-        // we must have created Thread object.
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES
-        IHostTask *pHostTask = GetCurrentHostTask();
-        if (pHostTask)
-        {
-            CONSISTENCY_CHECK(CheckPointer(GetThread()));
-        }
-#endif // FEATURE_INCLUDE_ALL_INTERFACES
-    }
-}
-#endif // !FEATURE_CORECLR && _DEBUG
 
 #ifdef FEATURE_MIXEDMODE
 //*****************************************************************************
@@ -3520,161 +2870,6 @@ HRESULT PrepareExecuteDLLForThunk(HINSTANCE hInst,
 
 #endif // FEATURE_MIXEDMODE
 
-#ifndef FEATURE_CORECLR
-//*****************************************************************************
-// This is the call point to make a DLL that is already loaded into our address
-// space run. There will be other code to actually have us load a DLL due to a
-// class reference.
-//*****************************************************************************
-BOOL STDMETHODCALLTYPE ExecuteDLL(HINSTANCE hInst,
-                                  DWORD dwReason,
-                                  LPVOID lpReserved,
-                                  BOOL fFromThunk)
-{
-
-    CONTRACTL{
-        THROWS;
-        WRAPPER(GC_TRIGGERS);
-        MODE_ANY;
-        ENTRY_POINT;
-        PRECONDITION(CheckPointer(lpReserved, NULL_OK));
-        PRECONDITION(CheckPointer(hInst));
-        PRECONDITION(GetThread() != NULL || !fFromThunk);
-    } CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-    BOOL fRetValue = FALSE;
-
-    // This needs to be before the BEGIN_ENTRYPOINT_THROWS since
-    // we can't call ReportStackOverflow if we're almost done with
-    // shutdown and can't run managed code.
-    if (!CanRunManagedCode(LoaderLockCheck::None))
-    {
-        return fRetValue;
-    }
-        
-    BEGIN_ENTRYPOINT_THROWS;
-
-    Thread *pThread = GetThread();
-
-    if (!hInst)
-    {
-        fRetValue = ExecuteDLL_ReturnOrThrow(E_FAIL, fFromThunk);
-        goto Exit;
-    }
-
-    // Note that we always check fFromThunk before checking the dwReason value.
-    // This is because the dwReason value is undefined in the case that we're
-    // being invoked due to a bootstrap (because that is by definition outside
-    // of the loader lock and there is no appropriate dwReason value).
-    if (fFromThunk ||
-        dwReason == DLL_PROCESS_ATTACH ||
-        dwReason == DLL_THREAD_ATTACH)
-    {
-        INDEBUG(EnsureManagedThreadExistsForHostedThread();)
-
-
-        // If necessary, start the runtime and create a managed thread object.
-        if (fFromThunk || dwReason == DLL_PROCESS_ATTACH)
-        {
-            hr = EnsureEEStarted(COINITEE_DLL);
-
-            if (SUCCEEDED(hr) && pThread == NULL)
-            {
-                pThread = SetupThreadNoThrow(&hr);
-            }
-
-            if(FAILED(hr))
-            {
-                fRetValue = ExecuteDLL_ReturnOrThrow(hr, fFromThunk);
-                goto Exit;
-            }
-        }
-
-        // IJW assemblies cause the thread doing the process attach to
-        // re-enter ExecuteDLL and do a thread attach. This happens when
-        // CoInitializeEE() above executed
-        else if (!(pThread &&
-                   pThread->GetDomain() &&
-                   CanRunManagedCode(LoaderLockCheck::None)))
-        {
-            fRetValue = ExecuteDLL_ReturnOrThrow(S_OK, fFromThunk);
-            goto Exit;
-        }
-
-        // we now have a thread setup - either the 1st if set it up, or
-        // the else if ran if we didn't have a thread setup.
-
-#ifdef FEATURE_MIXEDMODE
-
-        EX_TRY
-        {
-            hr = ExecuteDLLForAttach(hInst, dwReason, lpReserved, fFromThunk);
-        }
-        EX_CATCH
-        {
-            // We rethrow directly here instead of using ExecuteDLL_ReturnOrThrow() to 
-            // preserve the full exception information, rather than just the HRESULT
-            if (fFromThunk)
-            {
-                EX_RETHROW;
-            }
-            else
-            {
-                hr = GET_EXCEPTION()->GetHR();
-            }
-        }
-        EX_END_CATCH(SwallowAllExceptions);
-
-        if (FAILED(hr))
-        {
-            fRetValue = ExecuteDLL_ReturnOrThrow(hr, fFromThunk);
-            goto Exit;
-        }
-#endif // FEATURE_MIXEDMODE
-    }
-    else
-    {
-        PEDecoder pe(hInst);
-        if (pe.HasManagedEntryPoint())
-        {
-            // If the EE is still intact, then run user entry points.  Otherwise
-            // detach was handled when the app domain was stopped.
-            //
-            // Checks for the loader lock will occur within RunDllMain, if that's
-            FAULT_NOT_FATAL();
-            if (CanRunManagedCode(LoaderLockCheck::None))
-            {
-                hr = SystemDomain::RunDllMain(hInst, dwReason, lpReserved);
-            }
-        }
-        // This does need to match the attach. We will only unload dll's
-        // at the end and CoUninitialize will just bounce at 0. WHEN and IF we
-        // get around to unloading IL DLL's during execution prior to
-        // shutdown we will need to bump the reference one to compensate
-        // for this call.
-        if (dwReason == DLL_PROCESS_DETACH && !g_fForbidEnterEE)
-        {
-#ifdef FEATURE_MIXEDMODE
-            // If we're in a decent state, we need to free the memory associated
-            // with the IJW thunk fixups.
-            // we are not in a decent state if the process is terminating (lpReserved!=NULL)
-            if (g_fEEStarted && !g_fEEShutDown && !lpReserved)
-            {
-                PEImage::UnloadIJWModule(hInst);
-            }
-#endif // FEATURE_MIXEDMODE
-        }
-    }
-
-    fRetValue = ExecuteDLL_ReturnOrThrow(hr, fFromThunk);
-
-Exit:
-    
-    END_ENTRYPOINT_THROWS;
-    return fRetValue;
-}
-#endif // !FEATURE_CORECLR
 
 
 Volatile<BOOL> g_bIsGarbageCollectorFullyInitialized = FALSE;
@@ -3803,15 +2998,6 @@ BOOL STDMETHODCALLTYPE EEDllMain( // TRUE on success, FALSE on error.
                 // Remember module instance
                 g_pMSCorEE = pParam->hInst;
 
-#ifndef FEATURE_CORECLR
-                CoreClrCallbacks cccallbacks;
-                cccallbacks.m_hmodCoreCLR               = (HINSTANCE)g_pMSCorEE;
-                cccallbacks.m_pfnIEE                    = IEE;
-                cccallbacks.m_pfnGetCORSystemDirectory  = GetCORSystemDirectoryInternaL;
-                cccallbacks.m_pfnGetCLRFunction         = GetCLRFunction;
-
-                InitUtilcode(cccallbacks);
-#endif // !FEATURE_CORECLR
 
                 // Set callbacks so that LoadStringRC knows which language our
                 // threads are in so that it can return the proper localized string.
@@ -3820,7 +3006,6 @@ BOOL STDMETHODCALLTYPE EEDllMain( // TRUE on success, FALSE on error.
                                             GetThreadUICultureId);
 
                 InitEEPolicy();
-                InitHostProtectionManager();
 
                 break;
             }
@@ -3935,125 +3120,6 @@ BOOL STDMETHODCALLTYPE EEDllMain( // TRUE on success, FALSE on error.
     return TRUE;
 }
 
-#ifdef FEATURE_COMINTEROP_REGISTRATION
-//*****************************************************************************
-// Helper function to call the managed registration services.
-//*****************************************************************************
-enum EnumRegServicesMethods
-{
-    RegServicesMethods_RegisterAssembly = 0,
-    RegServicesMethods_UnregisterAssembly,
-    RegServicesMethods_LastMember
-};
-
-void InvokeRegServicesMethod(EnumRegServicesMethods Method, HMODULE hMod)
-{
-    CONTRACT_VOID
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(Method == RegServicesMethods_RegisterAssembly ||
-                     Method == RegServicesMethods_UnregisterAssembly);
-    }
-    CONTRACT_END;
-
-    GCX_PREEMP();
-    Assembly *pAssembly = GetAppDomain()->LoadExplicitAssembly(hMod, TRUE);
-
-    {
-        GCX_COOP();
-
-        // The names of the RegistrationServices methods.
-        static const BinderMethodID aMethods[] =
-        {
-            METHOD__REGISTRATION_SERVICES__REGISTER_ASSEMBLY,
-            METHOD__REGISTRATION_SERVICES__UNREGISTER_ASSEMBLY
-        };
-
-        // Allocate the RegistrationServices object.
-        OBJECTREF RegServicesObj = AllocateObject(MscorlibBinder::GetClass(CLASS__REGISTRATION_SERVICES));
-        GCPROTECT_BEGIN(RegServicesObj)
-        {
-            MethodDescCallSite registrationMethod(aMethods[Method], &RegServicesObj);
-
-            ARG_SLOT Args[] =
-            {
-                ObjToArgSlot(RegServicesObj),
-                ObjToArgSlot(pAssembly->GetExposedObject()),
-                0       // unused by UnregisterAssembly
-            };
-
-            registrationMethod.Call(Args);
-        }
-        GCPROTECT_END();
-    }
-    RETURN;
-}
-
-//*****************************************************************************
-// This entry point is called to register the classes contained inside a
-// COM+ assembly.
-//*****************************************************************************
-STDAPI EEDllRegisterServer(HMODULE hMod)
-{
-
-    CONTRACTL{
-        NOTHROW;
-        GC_TRIGGERS;
-        ENTRY_POINT;
-        MODE_PREEMPTIVE;
-    } CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    // Start up the runtime since we are going to use managed code to actually
-    // do the registration.
-    IfFailGo(EnsureEEStarted(COINITEE_DEFAULT));
-
-    BEGIN_EXTERNAL_ENTRYPOINT(&hr)
-    {
-        InvokeRegServicesMethod(RegServicesMethods_RegisterAssembly, hMod);
-    }
-    END_EXTERNAL_ENTRYPOINT;
-
-ErrExit:
-    
-
-    return hr;
-}
-
-//*****************************************************************************
-// This entry point is called to unregister the classes contained inside a
-// COM+ assembly.
-//*****************************************************************************
-STDAPI EEDllUnregisterServer(HMODULE hMod)
-{
-
-    CONTRACTL{
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_PREEMPTIVE;
-        ENTRY_POINT;
-    } CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    // Start up the runtime since we are going to use managed code to actually
-    // do the registration.
-    IfFailGo(EnsureEEStarted(COINITEE_DEFAULT));
-
-    BEGIN_EXTERNAL_ENTRYPOINT(&hr)
-    {
-        InvokeRegServicesMethod(RegServicesMethods_UnregisterAssembly, hMod);
-    }
-    END_EXTERNAL_ENTRYPOINT;
-ErrExit:
-
-
-    return hr;
-}
-#endif // FEATURE_COMINTEROP_REGISTRATION
 
 #ifdef FEATURE_IPCMAN
 extern CCLRSecurityAttributeManager s_CLRSecurityAttributeManager;
@@ -4125,7 +3191,6 @@ static void InitializeDebugger(void)
         hr = g_pDebugInterface->Startup(); // throw on error
         _ASSERTE(SUCCEEDED(hr));
 
-#ifdef FEATURE_CORECLR
         // 
         // If the debug pack is not installed, Startup will return S_FALSE
         // and we should cleanup and proceed without debugging support.
@@ -4134,31 +3199,8 @@ static void InitializeDebugger(void)
         {
             return;
         }
-#endif // FEATURE_CORECLR
     }
 
-#if !defined(FEATURE_CORECLR) // simple hosting
-    // If there's a DebuggerThreadControl interface, then we
-    // need to update the DebuggerSpecialThread list.
-    if (CorHost::GetDebuggerThreadControl())
-    {
-        hr = CorHost::RefreshDebuggerSpecialThreadList();
-        _ASSERTE((SUCCEEDED(hr)) && (hr != S_FALSE));
-
-        // So we don't think this will ever fail, but just in case...
-        IfFailThrow(hr);
-    }
-
-    // If there is a DebuggerThreadControl interface, then it was set before the debugger
-    // was initialized and we need to provide this interface now.  If debugging is already
-    // initialized then the IDTC pointer is passed in when it is set through CorHost
-    IDebuggerThreadControl *pDTC = CorHost::GetDebuggerThreadControl();
-
-    if (pDTC != NULL)
-    {
-        g_pDebugInterface->SetIDbgThreadControl(pDTC);
-    }
-#endif // !defined(FEATURE_CORECLR)
 
     LOG((LF_CORDB, LL_INFO10, "Left-side debugging services setup.\n"));
 
@@ -4199,9 +3241,6 @@ static void TerminateDebugger(void)
 
     g_CORDebuggerControlFlags = DBCF_NORMAL_OPERATION;
 
-#if !defined(FEATURE_CORECLR) // simple hosting
-    CorHost::CleanupDebuggerThreadControl();
-#endif // !defined(FEATURE_CORECLR)
 }
 
 
@@ -4826,172 +3865,6 @@ void ContractRegressionCheck()
 
 #endif // ENABLE_CONTRACTS_IMPL
 
-#ifndef FEATURE_CORECLR
-//-------------------------------------------------------------------------
-// CorCommandLine state and methods
-//-------------------------------------------------------------------------
-// Class to encapsulate Cor Command line processing
-
-// Statics for the CorCommandLine class
-DWORD                CorCommandLine::m_NumArgs     = 0;
-LPWSTR              *CorCommandLine::m_ArgvW       = 0;
-
-LPWSTR               CorCommandLine::m_pwszAppFullName = NULL;
-DWORD                CorCommandLine::m_dwManifestPaths = 0;
-LPWSTR              *CorCommandLine::m_ppwszManifestPaths = NULL;
-DWORD                CorCommandLine::m_dwActivationData = 0;
-LPWSTR              *CorCommandLine::m_ppwszActivationData = NULL;
-
-#ifdef _DEBUG
-LPCWSTR  g_CommandLine;
-#endif
-
-// Set argvw from command line
-/* static */
-HRESULT CorCommandLine::SetArgvW(LPCWSTR lpCommandLine)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        INJECT_FAULT(return E_OUTOFMEMORY;);
-
-        PRECONDITION(CheckPointer(lpCommandLine));
-    }
-    CONTRACTL_END
-
-    HRESULT hr = S_OK;
-    if(!m_ArgvW) {
-        INDEBUG(g_CommandLine = lpCommandLine);
-
-        InitializeLogging();        // This is so early, we may not be initialized
-        LOG((LF_ALWAYS, LL_INFO10, "Executing program with command line '%S'\n", lpCommandLine));
-
-        m_ArgvW = SegmentCommandLine(lpCommandLine, &m_NumArgs);
-
-        if (!m_ArgvW)
-            return E_OUTOFMEMORY;
-
-        // Click once specific parsing
-        hr = ReadClickOnceEnvVariables();
-    }
-
-    return hr;
-}
-
-// Retrieve the command line
-/* static */
-LPWSTR* CorCommandLine::GetArgvW(DWORD *pNumArgs)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    if (pNumArgs != 0)
-        *pNumArgs = m_NumArgs;
-
-    return m_ArgvW;
-}
-
-HRESULT CorCommandLine::ReadClickOnceEnvVariables()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    } CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    BEGIN_SO_INTOLERANT_CODE_NO_THROW_CHECK_THREAD(return COR_E_STACKOVERFLOW);
-
-    EX_TRY
-    {
-        // Find out if this is a ClickOnce application being activated.
-        PathString m_pwszAppFullNameHolder;
-        DWORD cAppFullName = WszGetEnvironmentVariable(g_pwzClickOnceEnv_FullName, m_pwszAppFullNameHolder);
-        if (cAppFullName > 0) {
-            // get the application full name.
-            m_pwszAppFullName = m_pwszAppFullNameHolder.GetCopyOfUnicodeString();
-                       
-            // reset the variable now that we read it so child processes
-            // do not think they are a clickonce app.
-            WszSetEnvironmentVariable(g_pwzClickOnceEnv_FullName, NULL);
-
-            // see if we have application manifest files.
-            DWORD dwManifestPaths = 0;
-            while (1) {
-                StackSString manifestFile(g_pwzClickOnceEnv_Manifest);
-                StackSString buf;
-                COUNT_T size = buf.GetUnicodeAllocation();
-                _itow_s(dwManifestPaths, buf.OpenUnicodeBuffer(size), size, 10);
-                buf.CloseBuffer();
-                manifestFile.Append(buf);
-                SString temp;
-                if (WszGetEnvironmentVariable(manifestFile.GetUnicode(), temp) > 0)
-                    dwManifestPaths++;
-                else
-                    break;
-            }
-            m_ppwszManifestPaths = new LPWSTR[dwManifestPaths];
-            for (DWORD i=0; i<dwManifestPaths; i++) {
-                StackSString manifestFile(g_pwzClickOnceEnv_Manifest);
-                StackSString buf;
-                COUNT_T size = buf.GetUnicodeAllocation();
-                _itow_s(i, buf.OpenUnicodeBuffer(size), size, 10);
-                buf.CloseBuffer();
-                manifestFile.Append(buf);
-                PathString m_ppwszManifestPathsHolder;
-                DWORD cManifestPath = WszGetEnvironmentVariable(manifestFile.GetUnicode(), m_ppwszManifestPathsHolder);
-                if (cManifestPath > 0) {
-                    
-                    m_ppwszManifestPaths[i] = m_ppwszManifestPathsHolder.GetCopyOfUnicodeString();
-                    WszSetEnvironmentVariable(manifestFile.GetUnicode(), NULL); // reset the env. variable.
-                }
-            }
-            m_dwManifestPaths = dwManifestPaths;
-
-            // see if we have activation data arguments.
-            DWORD dwActivationData = 0;
-            while (1) {
-                StackSString activationData(g_pwzClickOnceEnv_Parameter);
-                StackSString buf;
-                COUNT_T size = buf.GetUnicodeAllocation();
-                _itow_s(dwActivationData, buf.OpenUnicodeBuffer(size), size, 10);
-                buf.CloseBuffer();
-                activationData.Append(buf);
-                SString temp;
-                if (WszGetEnvironmentVariable(activationData.GetUnicode(), temp) > 0)
-                    dwActivationData++;
-                else
-                    break;
-            }
-            m_ppwszActivationData = new LPWSTR[dwActivationData];
-            for (DWORD i=0; i<dwActivationData; i++) {
-                StackSString activationData(g_pwzClickOnceEnv_Parameter);
-                StackSString buf;
-                COUNT_T size = buf.GetUnicodeAllocation();
-                _itow_s(i, buf.OpenUnicodeBuffer(size), size, 10);
-                buf.CloseBuffer();
-                activationData.Append(buf);
-                PathString m_ppwszActivationDataHolder;
-                DWORD cActivationData = WszGetEnvironmentVariable(activationData.GetUnicode(), m_ppwszActivationDataHolder);
-                if (cActivationData > 0) {
-                    m_ppwszActivationData[i] = m_ppwszActivationDataHolder.GetCopyOfUnicodeString();
-                    WszSetEnvironmentVariable(activationData.GetUnicode(), NULL); // reset the env. variable.
-                }
-            }
-            m_dwActivationData = dwActivationData;
-        }
-    }
-    EX_CATCH_HRESULT(hr);
-
-    END_SO_INTOLERANT_CODE;
-
-    return hr;
-}
-
-#endif // !FEATURE_CORECLR
 
 #endif // CROSSGEN_COMPILE
 
@@ -5005,62 +3878,6 @@ HRESULT CorCommandLine::ReadClickOnceEnvVariables()
 //
 BOOL GetOSVersion(LPOSVERSIONINFO lposVer)
 {
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-   CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-
-    //declared static to cache the version info
-    static OSVERSIONINFOEX osvi = {0};
-    BOOL ret = TRUE;
-
-    BEGIN_SO_INTOLERANT_CODE_NOTHROW(GetThread(), return FALSE);
-
-    //If not yet cached get the OS version info
-    if(osvi.dwMajorVersion == 0)
-    {
-        osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
-
-        ReleaseHolder<ICLRRuntimeHostInternal>  pRuntimeHostInternal;
-        //Get the interface
-        HRESULT hr = g_pCLRRuntime->GetInterface(CLSID_CLRRuntimeHostInternal,
-                        IID_ICLRRuntimeHostInternal,
-                        &pRuntimeHostInternal);
-
-        _ASSERT(SUCCEEDED(hr));
-
-        //Call mscoree!GetVersionExWrapper() through mscoreei interface method
-        hr = pRuntimeHostInternal->GetTrueOSVersion((LPOSVERSIONINFO)&osvi);
-        if(!SUCCEEDED(hr))
-        {
-           osvi.dwMajorVersion = 0;
-           ret = FALSE;
-           goto FUNCEND;
-        }
-    }
-
-    if(lposVer->dwOSVersionInfoSize==sizeof(OSVERSIONINFOEX)||lposVer->dwOSVersionInfoSize==sizeof(OSVERSIONINFO))
-    {
-        //Copy the cached version info to the return memory location
-        memcpy(lposVer,&osvi, lposVer->dwOSVersionInfoSize);
-    }
-    else
-    {
-        //return failure if dwOSVersionInfoSize not set properly
-        ret = FALSE;
-    }
-
-FUNCEND:
-    END_SO_INTOLERANT_CODE;
-    
-    return ret;
-#else
 // Fix for warnings when building against WinBlue build 9444.0.130614-1739
 // warning C4996: 'GetVersionExW': was declared deprecated
 // externalapis\windows\winblue\sdk\inc\sysinfoapi.h(442)
@@ -5068,5 +3885,4 @@ FUNCEND:
 #pragma warning( disable : 4996 )
     return WszGetVersionEx(lposVer);
 #pragma warning( default : 4996 )
-#endif
 }
diff --git a/src/vm/ceemain.h b/src/vm/ceemain.h
index 37fc3dcddf..f3d4db5b00 100644
--- a/src/vm/ceemain.h
+++ b/src/vm/ceemain.h
@@ -210,44 +210,5 @@ INT32 GetLatchedExitCode (void);
 // Stronger than IsGCHeapInitialized
 BOOL IsGarbageCollectorFullyInitialized();
 
-#ifndef FEATURE_CORECLR
-//---------------------------------------------------------------------------------------
-// 
-// Class to encapsulate Cor Command line processing
-// 
-class CorCommandLine
-{
-public:
-
-//********** TYPES
-
-    // Note: We don't bother with interlocked operations as we manipulate these bits,
-    // because we don't anticipate free-threaded access.  (Most of this is used only
-    // during startup / shutdown).
-
-//********** DATA
-
-    // Hold the current (possibly parsed) command line here
-    static DWORD            m_NumArgs;
-    static LPWSTR          *m_ArgvW;
-
-    static LPWSTR          m_pwszAppFullName;
-    static DWORD           m_dwManifestPaths;
-    static LPWSTR         *m_ppwszManifestPaths;
-    static DWORD           m_dwActivationData;
-    static LPWSTR         *m_ppwszActivationData;
-
-//********** METHODS
-
-    // parse the command line
-    static HRESULT         SetArgvW(LPCWSTR lpCommandLine);
-
-    // Retrieve the parsed command line
-    static LPWSTR          *GetArgvW(DWORD *pNumArgs);
-
-private:
-    static HRESULT ReadClickOnceEnvVariables();
-};
-#endif // !FEATURE_CORECLR
 
 #endif
diff --git a/src/vm/certificatecache.cpp b/src/vm/certificatecache.cpp
deleted file mode 100644
index 21ee5a37e1..0000000000
--- a/src/vm/certificatecache.cpp
+++ /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.
-// 
-
-// 
-
-
-#include "common.h"
-
-#ifdef FEATURE_CAS_POLICY
-#include "certificatecache.h"
-
-CertificateCache::CertificateCache () {
-    WRAPPER_NO_CONTRACT;
-    m_dwNumEntries = 0;
-    for (DWORD i=0; i < MAX_CACHED_CERTIFICATES; i++) {
-        m_Entry[i] = NULL;
-    }
-    m_CertificateCacheCrst.Init(CrstPublisherCertificate);
-}
-
-CertificateCache::~CertificateCache () {
-    // Let the OS collect the memory allocated for the cached certificates.
-}
-
-COR_TRUST* CertificateCache::GetEntry (DWORD index) {
-    LIMITED_METHOD_CONTRACT;
-    if (index < 0 || index >= MAX_CACHED_CERTIFICATES)
-        return NULL;
-    return m_Entry[index];
-}
-
-EnumCertificateAdditionFlags CertificateCache::AddEntry (COR_TRUST* pCertificate, DWORD* pIndex) {
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_PREEMPTIVE;
-        PRECONDITION(pIndex != NULL);
-    } CONTRACTL_END;
-
-    *pIndex = FindEntry(pCertificate);
-    if (*pIndex < MAX_CACHED_CERTIFICATES)
-        return AlreadyExists; // the certificate is already cached.
-    if (m_dwNumEntries >= MAX_CACHED_CERTIFICATES)
-        return CacheSaturated; // the cache is full
-
-    CrstHolder csh(&m_CertificateCacheCrst);
-    if (m_dwNumEntries >= MAX_CACHED_CERTIFICATES)
-        return CacheSaturated;
-
-    // check again now that we have the lock.
-    *pIndex = FindEntry(pCertificate);
-    if (*pIndex < MAX_CACHED_CERTIFICATES)
-        return AlreadyExists;
-
-    *pIndex = m_dwNumEntries;
-    m_Entry[m_dwNumEntries++] = pCertificate;
-    return Success;
-}
-
-BOOL CertificateCache::Contains (COR_TRUST* pCertificate) {
-    WRAPPER_NO_CONTRACT;
-    DWORD index = FindEntry(pCertificate);
-    return (index < MAX_CACHED_CERTIFICATES && index >= 0);
-}
-
-DWORD CertificateCache::FindEntry (COR_TRUST* pCertificate) {
-    CONTRACTL 
-    {
-        MODE_ANY;
-        GC_NOTRIGGER;
-        NOTHROW;
-    }CONTRACTL_END;
-
-    for (DWORD i=0; i < MAX_CACHED_CERTIFICATES; i++) {
-        if (m_Entry[i] != NULL) {
-            if ((pCertificate->cbSigner == m_Entry[i]->cbSigner) &&
-                (memcmp(pCertificate->pbSigner, m_Entry[i]->pbSigner, m_Entry[i]->cbSigner) == 0))
-                return i;
-        }
-    }
-    return 0xFFFFFFFF;
-}
-#endif // FEATURE_CAS_POLICY
diff --git a/src/vm/certificatecache.h b/src/vm/certificatecache.h
deleted file mode 100644
index bc6d92ba4c..0000000000
--- a/src/vm/certificatecache.h
+++ /dev/null
@@ -1,40 +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.
-// 
-
-// 
-
-
-#ifndef _CERTIFICATECACHE_H_
-#define _CERTIFICATECACHE_H_
-
-#include "corpermp.h"
-#include "crst.h"
-
-#define MAX_CACHED_CERTIFICATES 10
-
-enum EnumCertificateAdditionFlags {
-    Success         = 0,
-    CacheSaturated  = 1,
-    AlreadyExists   = 2
-};
-
-class CertificateCache {
-public:
-    EnumCertificateAdditionFlags AddEntry (COR_TRUST* pCertificate, DWORD* pIndex);
-    COR_TRUST* GetEntry (DWORD index);
-    BOOL Contains (COR_TRUST* pCertificate);
-
-    CertificateCache ();
-    ~CertificateCache ();
-
-private:
-    DWORD       m_dwNumEntries;
-    COR_TRUST*  m_Entry [MAX_CACHED_CERTIFICATES];
-    CrstStatic  m_CertificateCacheCrst;
-
-    DWORD FindEntry (COR_TRUST* pCertificate);
-};
-
-#endif //_CERTIFICATECACHE_H_
diff --git a/src/vm/cgensys.h b/src/vm/cgensys.h
index 4dd1ee4b4b..d55d15dd7d 100644
--- a/src/vm/cgensys.h
+++ b/src/vm/cgensys.h
@@ -105,6 +105,7 @@ inline void GetSpecificCpuInfo(CORINFO_CPU * cpuInfo)
 
 #if (defined(_TARGET_X86_) || defined(_TARGET_AMD64_)) && !defined(CROSSGEN_COMPILE)
 extern "C" DWORD __stdcall getcpuid(DWORD arg, unsigned char result[16]);
+extern "C" DWORD __stdcall getextcpuid(DWORD arg1, DWORD arg2, unsigned char result[16]);
 extern "C" DWORD __stdcall xmmYmmStateSupport();
 #endif
 
diff --git a/src/vm/class.cpp b/src/vm/class.cpp
index cff71f328f..785536a7a4 100644
--- a/src/vm/class.cpp
+++ b/src/vm/class.cpp
@@ -16,7 +16,6 @@
 #include "dllimport.h"
 #include "dllimportcallback.h"
 #include "fieldmarshaler.h"
-#include "constrainedexecutionregion.h"
 #include "customattribute.h"
 #include "encee.h"
 #include "typestring.h"
@@ -2491,14 +2490,6 @@ MethodTable::GetSubstitutionForParent(
 
 #endif //!DACCESS_COMPILE
 
-#ifdef FEATURE_CER
-//*******************************************************************************
-DWORD EEClass::GetReliabilityContract()
-{
-    LIMITED_METHOD_CONTRACT;
-    return HasOptionalFields() ? GetOptionalFields()->m_dwReliabilityContract : RC_NULL;
-}
-#endif // FEATURE_CER
 
 //*******************************************************************************
 #ifdef FEATURE_PREJIT
diff --git a/src/vm/class.h b/src/vm/class.h
index 7517863278..80be180a6e 100644
--- a/src/vm/class.h
+++ b/src/vm/class.h
@@ -703,9 +703,6 @@ class EEClassOptionalFields
     #define    MODULE_NON_DYNAMIC_STATICS      ((DWORD)-1)
     DWORD m_cbModuleDynamicID;
 
-#ifdef FEATURE_CER
-    DWORD m_dwReliabilityContract;
-#endif
 
     SecurityProperties m_SecProps;
 
@@ -1360,9 +1357,6 @@ public:
         _ASSERTE(HasCriticalTransparentInfo());
         return (m_VMFlags & VMFLAG_TRANSPARENCY_MASK) == VMFLAG_TRANSPARENCY_ALLCRITICAL_TAS ||
                (m_VMFlags & VMFLAG_TRANSPARENCY_MASK) == VMFLAG_TRANSPARENCY_TAS_NOTCRITICAL
-#ifndef FEATURE_CORECLR
-            || (m_VMFlags & VMFLAG_TRANSPARENCY_MASK) == VMFLAG_TRANSPARENCY_CRITICAL_TAS
-#endif // !FEATURE_CORECLR;
             ;
     }
 
@@ -1388,9 +1382,6 @@ public:
     }
 
     void SetCriticalTransparentInfo(
-#ifndef FEATURE_CORECLR
-                                    BOOL fIsCritical,
-#endif // !FEATURE_CORECLR
                                     BOOL fIsTreatAsSafe,
                                     BOOL fIsAllTransparent,
                                     BOOL fIsAllCritical)
@@ -1399,9 +1390,7 @@ public:
         
         // TAS wihtout critical doesn't make sense - although it was allowed in the v2 desktop model,
         // so we need to allow it for compatibility reasons on the desktop.
-#ifdef FEATURE_CORECLR
         _ASSERTE(!fIsTreatAsSafe || fIsAllCritical);
-#endif // FEATURE_CORECLR
 
         //if nothing is set, then we're transparent.
         unsigned flags = VMFLAG_TRANSPARENCY_TRANSPARENT;
@@ -1415,13 +1404,6 @@ public:
             flags = fIsTreatAsSafe ? VMFLAG_TRANSPARENCY_ALLCRITICAL_TAS :
                                      VMFLAG_TRANSPARENCY_ALLCRITICAL;
         }
-#ifndef FEATURE_CORECLR
-        else if (fIsCritical)
-        {
-            flags = fIsTreatAsSafe ? VMFLAG_TRANSPARENCY_CRITICAL_TAS :
-                                     VMFLAG_TRANSPARENCY_CRITICAL;
-        }
-#endif // !FEATURE_CORECLR
         else
         {
             flags = fIsTreatAsSafe ? VMFLAG_TRANSPARENCY_TAS_NOTCRITICAL :
@@ -1770,14 +1752,6 @@ public:
     // Cached class level reliability contract info, see ConstrainedExecutionRegion.cpp for details.
     DWORD GetReliabilityContract();
 
-#ifdef FEATURE_CER
-    inline void SetReliabilityContract(DWORD dwValue)
-    {
-        LIMITED_METHOD_CONTRACT;
-        _ASSERTE(HasOptionalFields());
-        GetOptionalFields()->m_dwReliabilityContract = dwValue;
-    }
-#endif
 
 #if defined(UNIX_AMD64_ABI) && defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)
     // Get number of eightbytes used by a struct passed in registers.
diff --git a/src/vm/class.inl b/src/vm/class.inl
index 7d5c74d586..1a7e169ed7 100644
--- a/src/vm/class.inl
+++ b/src/vm/class.inl
@@ -13,7 +13,6 @@
 
 #ifndef _CLASS_INL_
 #define _CLASS_INL_
-#include "constrainedexecutionregion.h"
 //***************************************************************************************
 inline PTR_MethodDescChunk EEClass::GetChunks()
 {
@@ -50,9 +49,6 @@ inline void EEClassOptionalFields::Init()
     m_WinRTRedirectedTypeIndex = WinMDAdapter::RedirectedTypeIndex_Invalid;
 #endif // FEATURE_COMINTEROP
     m_cbModuleDynamicID = MODULE_NON_DYNAMIC_STATICS;
-#ifdef FEATURE_CER
-    m_dwReliabilityContract = RC_NULL;
-#endif
     m_SecProps = 0;
 #if defined(UNIX_AMD64_ABI) && defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)
     m_numberEightBytes = 0;
diff --git a/src/vm/classnames.h b/src/vm/classnames.h
index 47f1fecdec..a2da111ed0 100644
--- a/src/vm/classnames.h
+++ b/src/vm/classnames.h
@@ -16,9 +16,7 @@
 #define g_ArrayClassName "System.Array"
 
 #define g_NullableName "Nullable`1"
-#ifdef FEATURE_SPAN_OF_T
 #define g_ByReferenceName "ByReference`1"
-#endif
 
 #define g_CollectionsEnumerableItfName "System.Collections.IEnumerable"
 #define g_CollectionsEnumeratorClassName "System.Collections.IEnumerator"
@@ -158,18 +156,14 @@
 
 #define g_SecurityCriticalAttribute "System.Security.SecurityCriticalAttribute"
 #define g_SecurityTransparentAttribute "System.Security.SecurityTransparentAttribute"
-#ifndef FEATURE_CORECLR
-#define g_SecurityTreatAsSafeAttribute "System.Security.SecurityTreatAsSafeAttribute"
-#define g_SecurityRulesAttribute "System.Security.SecurityRulesAttribute"
-#endif //FEATURE_CORECLR
 
 #define g_SecuritySafeCriticalAttribute "System.Security.SecuritySafeCriticalAttribute"
 
-#if defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM)
+#if defined(FEATURE_CORESYSTEM)
 #define g_SecurityAPTCA "System.Security.AllowPartiallyTrustedCallersAttribute"
 #define g_SecurityPartialTrustVisibilityLevel "System.Security.PartialTrustVisibilityLevel"
 #define g_PartialTrustVisibilityLevel "PartialTrustVisibilityLevel"
-#endif // defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM)
+#endif // defined(FEATURE_CORESYSTEM)
 
 #define g_ReferenceAssemblyAttribute "System.Runtime.CompilerServices.ReferenceAssemblyAttribute"
 
diff --git a/src/vm/clrex.cpp b/src/vm/clrex.cpp
index c8fc2f3886..6f8c157541 100644
--- a/src/vm/clrex.cpp
+++ b/src/vm/clrex.cpp
@@ -1717,11 +1717,7 @@ OBJECTREF EETypeLoadException::CreateThrowable()
 // EEFileLoadException is an EE exception subclass representing a file loading
 // error
 // ---------------------------------------------------------------------------
-#ifdef FEATURE_FUSION
-EEFileLoadException::EEFileLoadException(const SString &name, HRESULT hr, IFusionBindLog *pFusionLog, Exception *pInnerException/* = NULL*/)
-#else
 EEFileLoadException::EEFileLoadException(const SString &name, HRESULT hr, void *pFusionLog, Exception *pInnerException/* = NULL*/)
-#endif
   : EEException(GetFileLoadKind(hr)),
     m_name(name),
     m_pFusionLog(pFusionLog),
@@ -1753,10 +1749,6 @@ EEFileLoadException::EEFileLoadException(const SString &name, HRESULT hr, void *
 
         m_name.Set(wszTemplate);
     }
-#ifdef FEATURE_FUSION
-    if (m_pFusionLog != NULL)
-        m_pFusionLog->AddRef();
-#endif    
 }
 
 
@@ -1765,10 +1757,6 @@ EEFileLoadException::~EEFileLoadException()
     STATIC_CONTRACT_NOTHROW;
     STATIC_CONTRACT_GC_NOTRIGGER;
 
-#ifdef FEATURE_FUSION
-    if (m_pFusionLog)
-        m_pFusionLog->Release();
-#endif    
 }
 
 
@@ -1880,19 +1868,6 @@ OBJECTREF EEFileLoadException::CreateThrowable()
 
     // Fetch any log info from the fusion log
     SString logText;
-#ifdef FEATURE_FUSION    
-    if (m_pFusionLog != NULL)
-    {
-        DWORD dwSize = 0;
-        HRESULT hr = m_pFusionLog->GetBindLog(0,0,NULL,&dwSize);
-        if (hr==HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)) 
-        {
-            WCHAR *buffer = logText.OpenUnicodeBuffer(dwSize);
-            hr=m_pFusionLog->GetBindLog(0,0,buffer, &dwSize);
-            logText.CloseBuffer();
-        }
-    }
-#endif
     struct _gc {
         OBJECTREF pNewException;
         STRINGREF pNewFileString;
@@ -1958,33 +1933,6 @@ BOOL EEFileLoadException::CheckType(Exception* ex)
 // <TODO>@todo: ideally we would use inner exceptions with these routines</TODO>
 
 /* static */
-#ifdef FEATURE_FUSION
-void DECLSPEC_NORETURN EEFileLoadException::Throw(AssemblySpec *pSpec, IFusionBindLog *pFusionLog, HRESULT hr, Exception *pInnerException/* = NULL*/)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        THROWS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-    
-    if (hr == COR_E_THREADABORTED)
-        COMPlusThrow(kThreadAbortException);
-    if (hr == E_OUTOFMEMORY)
-        COMPlusThrowOM();
-#ifdef FEATURE_COMINTEROP
-    if ((hr == RO_E_METADATA_NAME_NOT_FOUND) || (hr == CLR_E_BIND_TYPE_NOT_FOUND))
-    {   // These error codes behave like FileNotFound, but are exposed as TypeLoadException
-        EX_THROW_WITH_INNER(EETypeLoadException, (pSpec->GetWinRtTypeNamespace(), pSpec->GetWinRtTypeClassName(), nullptr, nullptr, IDS_EE_WINRT_LOADFAILURE), pInnerException);
-    }
-#endif //FEATURE_COMINTEROP
-    
-    StackSString name;
-    pSpec->GetFileOrDisplayName(0, name);
-    EX_THROW_WITH_INNER(EEFileLoadException, (name, hr, pFusionLog), pInnerException);
-}
-#endif //FEATURE_FUSION
 
 /* static */
 void DECLSPEC_NORETURN EEFileLoadException::Throw(AssemblySpec  *pSpec, HRESULT hr, Exception *pInnerException/* = NULL*/)
@@ -2070,41 +2018,6 @@ void DECLSPEC_NORETURN EEFileLoadException::Throw(LPCWSTR path, HRESULT hr, Exce
 }
 
 /* static */
-#ifdef FEATURE_FUSION
-void DECLSPEC_NORETURN EEFileLoadException::Throw(IAssembly *pIAssembly, IHostAssembly *pIHostAssembly, HRESULT hr, Exception *pInnerException/* = NULL*/)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        THROWS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-    
-    if (hr == COR_E_THREADABORTED)
-        COMPlusThrow(kThreadAbortException);
-    if (hr == E_OUTOFMEMORY || hr == HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY))
-        COMPlusThrowOM();
-
-    StackSString name;
-
-    {
-        SafeComHolder<IAssemblyName> pName;
-    
-        HRESULT newHr;
-        
-        if (pIAssembly)
-            newHr = pIAssembly->GetAssemblyNameDef(&pName);
-        else
-            newHr = pIHostAssembly->GetAssemblyNameDef(&pName);
-
-        if (SUCCEEDED(newHr))
-            FusionBind::GetAssemblyNameDisplayName(pName, name, 0);
-    }
-        
-    EX_THROW_WITH_INNER(EEFileLoadException, (name, hr), pInnerException);
-}
-#endif
 /* static */
 void DECLSPEC_NORETURN EEFileLoadException::Throw(PEAssembly *parent, 
                                                   const void *memory, COUNT_T size, HRESULT hr, Exception *pInnerException/* = NULL*/)
diff --git a/src/vm/clrex.h b/src/vm/clrex.h
index 02de452370..15d1071fb9 100644
--- a/src/vm/clrex.h
+++ b/src/vm/clrex.h
@@ -28,11 +28,9 @@ struct StackTraceElement
     UINT_PTR        ip;
     UINT_PTR        sp;
     PTR_MethodDesc  pFunc;
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
     // TRUE if this element represents the last frame of the foreign
     // exception stack trace.
     BOOL			fIsLastFrameFromForeignStackTrace;
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 
     bool operator==(StackTraceElement const & rhs) const
     {
@@ -681,21 +679,13 @@ class EEFileLoadException : public EEException
     
   private:
     SString m_name;
-#ifdef FEATURE_FUSION	
-    IFusionBindLog *m_pFusionLog;
-#else
     void  *m_pFusionLog;
-#endif
     HRESULT m_hr;       
                         
 
   public:
 
-#ifdef FEATURE_FUSION	
-    EEFileLoadException(const SString &name, HRESULT hr, IFusionBindLog *pFusionLog = NULL, Exception *pInnerException = NULL);
-#else
     EEFileLoadException(const SString &name, HRESULT hr, void *pFusionLog = NULL,  Exception *pInnerException = NULL);
-#endif
     ~EEFileLoadException();
 
     // virtual overrides
@@ -709,10 +699,6 @@ class EEFileLoadException : public EEException
     OBJECTREF CreateThrowable();
 
     static RuntimeExceptionKind GetFileLoadKind(HRESULT hr);
-#ifdef FEATURE_FUSION	
-    static void DECLSPEC_NORETURN Throw(AssemblySpec *pSpec, IFusionBindLog *pFusionLog, HRESULT hr, Exception *pInnerException = NULL);
-    static void DECLSPEC_NORETURN Throw(IAssembly *pIAssembly, IHostAssembly *pIHostAssembly, HRESULT hr, Exception *pInnerException = NULL);
-#endif
     static void DECLSPEC_NORETURN Throw(AssemblySpec *pSpec, HRESULT hr, Exception *pInnerException = NULL);
     static void DECLSPEC_NORETURN Throw(PEFile *pFile, HRESULT hr, Exception *pInnerException = NULL);
     static void DECLSPEC_NORETURN Throw(LPCWSTR path, HRESULT hr, Exception *pInnerException = NULL);
diff --git a/src/vm/clrprivbinderappx.cpp b/src/vm/clrprivbinderappx.cpp
deleted file mode 100644
index b55ece4556..0000000000
--- a/src/vm/clrprivbinderappx.cpp
+++ /dev/null
@@ -1,1057 +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.
-
-
-
-#include "common.h" // precompiled header
-#include "assemblyusagelogmanager.h"
-
-//=====================================================================================================================
-#include "clrprivbinderappx.h"
-//CLRPrivBinderAppX * CLRPrivBinderAppX::s_pSingleton = nullptr;
-SPTR_IMPL_INIT(CLRPrivBinderAppX, CLRPrivBinderAppX, s_pSingleton, nullptr);
-
-#ifndef DACCESS_COMPILE
-//=====================================================================================================================
-#include "appxutil.h"
-#include "clrprivbinderutil.h"
-#include "fusionlogging.h"
-#include "clrprivtypecachewinrt.h"
-#include "fusionp.h"
-
-using namespace CLRPrivBinderUtil;
-
-//=====================================================================================================================
-CLRPrivBinderAppX::CLRPrivBinderAppX(LPCWSTR * rgwzAltPath, UINT cAltPaths)
-    : m_MapReadLock(CrstCLRPrivBinderMaps,
-                static_cast<CrstFlags>(CRST_DEBUG_ONLY_CHECK_FORBID_SUSPEND_THREAD |
-                                       CRST_GC_NOTRIGGER_WHEN_TAKEN |
-                                       CRST_DEBUGGER_THREAD |
-                                       // FindAssemblyBySpec complicates matters, which needs to take the m_MapReadLock.
-                                       // But FindAssemblyBySpec cannot switch to preemptive mode, as that would trigger
-                                       // a GC. Since this is a leaf lock, and since it does not make any calls out of
-                                       // the runtime, this lock can be taken in cooperative mode if the locked scope is
-                                       // also marked as ForbidSuspend (since FindAssemblyBySpec can be called by
-                                       // the debugger and the profiler). TODO: it would be nice to be able to specify
-                                       // this flag for just the specific places where it is necessary rather than for
-                                       // the lock as a whole.
-                                       CRST_UNSAFE_ANYMODE)),
-      m_MapWriteLock(CrstCLRPrivBinderMapsAdd, CRST_DEFAULT),
-      m_cAltPaths(cAltPaths),
-      m_fCanUseNativeImages(TRUE),
-      m_pParentBinder(nullptr),
-      m_pFusionBinder(nullptr),
-      m_pWinRTBinder(nullptr),
-
-      // Note: the first CLRPrivBinderAppX object is created prior to runtime startup, so this code cannot call
-      // AppX::IsAppXDesignMode; however, FindAssemblyBySpec cannot call IsAppXDesignMode either because that would
-      // cause a GC_TRIGGERS violation for the GetAssemblyIfLoaded scenario. However this doesn't matter because
-      // the assembly map will be empty until at least the first call to BindAssemblyByName is made, at which point
-      // a call to IsAppXDesignMode can be made. Thus, we default to the most conversative setting and overwrite this
-      // value in BindAssemblyByName.
-      m_fusionBindingScope(CLRPrivBinderFusion::kBindingScope_FrameworkSubset)
-{
-    STANDARD_VM_CONTRACT;
-
-    // Copy altpaths
-    if (cAltPaths > 0)
-    {
-        m_rgAltPathsHolder = new NewArrayHolder<WCHAR>[cAltPaths];
-        m_rgAltPaths = new WCHAR *[cAltPaths];
-
-        for (UINT iAltPath = 0; iAltPath < cAltPaths; iAltPath++)
-        {
-            size_t cchAltPath = wcslen(rgwzAltPath[iAltPath]);
-            m_rgAltPathsHolder[iAltPath] = m_rgAltPaths[iAltPath] = new WCHAR[cchAltPath + 1];
-            wcscpy_s(m_rgAltPaths[iAltPath], cchAltPath + 1, rgwzAltPath[iAltPath]);
-        }
-    }
-
-#ifdef FEATURE_FUSION
-    IfFailThrow(RuntimeCreateCachingILFingerprintFactory(&m_pFingerprintFactory));
-#endif
-}
-
-//=====================================================================================================================
-CLRPrivBinderFusion::BindingScope CLRPrivBinderAppX::GetFusionBindingScope()
-{
-    WRAPPER_NO_CONTRACT;
-
-    m_fusionBindingScope = (AppX::IsAppXDesignMode() || (m_pParentBinder != nullptr))
-                           ? CLRPrivBinderFusion::kBindingScope_FrameworkAll
-                           : CLRPrivBinderFusion::kBindingScope_FrameworkSubset;
-
-    return m_fusionBindingScope;
-}
-
-//=====================================================================================================================
-CLRPrivBinderAppX::~CLRPrivBinderAppX()
-{
-    WRAPPER_NO_CONTRACT;
-    
-    m_NameToAssemblyMap.RemoveAll();
-    AssemblyUsageLogManager::UnRegisterBinderFromUsageLog((UINT_PTR)this);
-    
-    clr::SafeRelease(m_pWinRTBinder);
-}
-
-//=====================================================================================================================
-CLRPrivBinderAppX * 
-CLRPrivBinderAppX::GetOrCreateBinder()
-{
-    STANDARD_VM_CONTRACT;
-    HRESULT hr = S_OK;
-
-    if (s_pSingleton == nullptr)
-    {
-        ReleaseHolder<IAssemblyUsageLog> pNewUsageLog;
-        IfFailThrow(AssemblyUsageLogManager::GetUsageLogForContext(W("App"), AppX::GetHeadPackageMoniker(), &pNewUsageLog));
-
-        ReleaseHolder<CLRPrivBinderAppX> pBinder;
-        pBinder = clr::SafeAddRef(new CLRPrivBinderAppX(nullptr, 0));
-        
-        pBinder->m_pFusionBinder = clr::SafeAddRef(new CLRPrivBinderFusion());
-        
-        CLRPrivTypeCacheWinRT * pWinRtTypeCache = CLRPrivTypeCacheWinRT::GetOrCreateTypeCache();
-        pBinder->m_pWinRTBinder = clr::SafeAddRef(new CLRPrivBinderWinRT(
-            pBinder, 
-            pWinRtTypeCache, 
-            nullptr,    // rgwzAltPath
-            0,          // cAltPaths
-            CLRPrivBinderWinRT::NamespaceResolutionKind_WindowsAPI, 
-            TRUE // fCanUseNativeImages
-            ));
-        
-        if (InterlockedCompareExchangeT<decltype(s_pSingleton)>(&s_pSingleton, pBinder, nullptr) == nullptr)
-            pBinder.SuppressRelease();
-
-        // Register binder with usagelog infrastructure.
-        UINT_PTR binderId;
-        IfFailThrow(pBinder->GetBinderID(&binderId));
-        IfFailThrow(AssemblyUsageLogManager::RegisterBinderWithUsageLog(binderId, pNewUsageLog));
-        
-        // Create and register WinRT usage log
-        ReleaseHolder<IAssemblyUsageLog> pNewWinRTUsageLog;
-        IfFailThrow(AssemblyUsageLogManager::GetUsageLogForContext(W("WinRT"), AppX::GetHeadPackageMoniker(), &pNewWinRTUsageLog));
-
-        UINT_PTR winRTBinderId;
-        IfFailThrow(pBinder->m_pWinRTBinder->GetBinderID(&winRTBinderId));
-        IfFailThrow(AssemblyUsageLogManager::RegisterBinderWithUsageLog(winRTBinderId, pNewWinRTUsageLog));
-    }
-
-    return s_pSingleton;
-}
-
-//=====================================================================================================================
-// Used only for designer binding context
-CLRPrivBinderAppX * CLRPrivBinderAppX::CreateParentedBinder(
-    ICLRPrivBinder *         pParentBinder, 
-    CLRPrivTypeCacheWinRT *  pWinRtTypeCache,
-    LPCWSTR *                rgwzAltPath, 
-    UINT                     cAltPaths,
-    BOOL                     fCanUseNativeImages)
-{
-    STANDARD_VM_CONTRACT;
-    HRESULT hr = S_OK;
-
-    ReleaseHolder<CLRPrivBinderAppX> pBinder;
-    pBinder = clr::SafeAddRef(new CLRPrivBinderAppX(rgwzAltPath, cAltPaths));
-
-    pBinder->m_pParentBinder = clr::SafeAddRef(pParentBinder);
-    pBinder->m_fCanUseNativeImages = fCanUseNativeImages;
-    
-    // We want to share FusionBinder with pParentBinder (which bubbles up through the chain of binders to the global AppXBinder code:s_pSingleton)
-    // Ideally we would get the FusionBinder from pParentBinder (via casting to a new interface). It is much easier just to fetch it from 
-    // the global AppX binder directly
-    pBinder->m_pFusionBinder = clr::SafeAddRef(s_pSingleton->GetFusionBinder());
-    
-    if (cAltPaths > 0)
-    {
-        pBinder->m_pWinRTBinder = clr::SafeAddRef(new CLRPrivBinderWinRT(
-            pBinder, 
-            pWinRtTypeCache, 
-            rgwzAltPath, 
-            cAltPaths, 
-            CLRPrivBinderWinRT::NamespaceResolutionKind_WindowsAPI,
-            fCanUseNativeImages));
-    }
-
-    pBinder.SuppressRelease();
-    return pBinder;
-}
-
-//=====================================================================================================================
-HRESULT CLRPrivBinderAppX::BindAppXAssemblyByNameWorker(
-    IAssemblyName * pIAssemblyName,
-    DWORD dwAppXBindFlags,
-    CLRPrivAssemblyAppX ** ppAssembly)
-{
-    STANDARD_VM_CONTRACT;
-    HRESULT hr = S_OK;
-
-    fusion::logging::StatusScope logStatus(0, ID_FUSLOG_BINDING_STATUS_IMMERSIVE, &hr);
-
-    VALIDATE_ARG_RET(pIAssemblyName != nullptr);
-    VALIDATE_ARG_RET((dwAppXBindFlags & ABF_BindIL) == ABF_BindIL);
-    VALIDATE_ARG_RET(ppAssembly != nullptr);
-
-    DWORD dwContentType = AssemblyContentType_Default;
-    IfFailRet(hr = fusion::util::GetProperty(pIAssemblyName, ASM_NAME_CONTENT_TYPE, &dwContentType));
-    if ((hr == S_OK) && (dwContentType != AssemblyContentType_Default))
-    {
-        IfFailRet(CLR_E_BIND_UNRECOGNIZED_IDENTITY_FORMAT);
-    }
-
-    ReleaseHolder<CLRPrivAssemblyAppX> pAssembly;
-
-    // Get the simple name.
-    WCHAR wzSimpleName[_MAX_PATH];
-    DWORD cchSimpleName = _MAX_PATH;
-    IfFailRet(pIAssemblyName->GetName(&cchSimpleName, wzSimpleName));
-
-    {   // Look for previous successful bind. Host callouts are now forbidden.
-        ForbidSuspendThreadCrstHolder lock(&m_MapReadLock);
-        pAssembly = clr::SafeAddRef(m_NameToAssemblyMap.Lookup(wzSimpleName));
-    }
-
-    if (pAssembly == nullptr)
-    {
-        ReleaseHolder<ICLRPrivResource> pResourceIL;
-        ReleaseHolder<ICLRPrivResource> pResourceNI;
-
-        // Create assembly identity using the simple name. For successful binds this will be updated
-        // with the full assembly identity in the VerifyBind callback.
-        NewHolder<AssemblyIdentity> pIdentity = new AssemblyIdentity();
-        IfFailRet(pIdentity->Initialize(wzSimpleName));
-
-        //
-        // Check the head package first to see if this matches an EXE, then check
-        // all packages to see if this matches a DLL.
-        //
-        WCHAR wzFilePath[_MAX_PATH];
-        {
-            hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
-
-            if (FAILED(hr))
-            {
-                // Create simple name with .EXE extension
-                WCHAR wzSimpleFileName[_MAX_PATH];
-                wcscpy_s(wzSimpleFileName, NumItems(wzSimpleFileName), wzSimpleName);
-                wcscat_s(wzSimpleFileName, NumItems(wzSimpleFileName), W(".EXE"));
-
-                // Search for the file using AppX::FileFileInCurrentPackage helper.
-                UINT32 cchFilePath = NumItems(wzFilePath);
-                hr = AppX::FindFileInCurrentPackage(
-                        wzSimpleFileName,
-                        &cchFilePath,
-                        wzFilePath,
-                        PACKAGE_FILTER_CLR_DEFAULT,
-                        (PCWSTR *)(void *)m_rgAltPaths,
-                        m_cAltPaths,
-                        m_pParentBinder != NULL ? AppX::FindFindInPackageFlags_SkipCurrentPackageGraph : AppX::FindFindInPackageFlags_None);
-            }
-
-            if (FAILED(hr))
-            {
-                // Create simple name with .DLL extension
-                WCHAR wzSimpleFileName[_MAX_PATH];
-                wcscpy_s(wzSimpleFileName, NumItems(wzSimpleFileName), wzSimpleName);
-                wcscat_s(wzSimpleFileName, NumItems(wzSimpleFileName), W(".DLL"));
-
-                // Search for the file using AppX::FileFileInCurrentPackage helper
-                UINT32 cchFilePath = NumItems(wzFilePath);
-                hr = AppX::FindFileInCurrentPackage(
-                        wzSimpleFileName,
-                        &cchFilePath,
-                        wzFilePath,
-                        PACKAGE_FILTER_CLR_DEFAULT,
-                        (PCWSTR *)(void *)m_rgAltPaths,
-                        m_cAltPaths,
-                        m_pParentBinder != NULL ? AppX::FindFindInPackageFlags_SkipCurrentPackageGraph : AppX::FindFindInPackageFlags_None);
-            }
-
-            if (SUCCEEDED(hr))
-            {
-                fusion::logging::LogMessage(0, ID_FUSLOG_BINDING_STATUS_FOUND, wzFilePath);
-            }
-            else
-            {
-                // Cache the bind failure result before returning. Careful not to overwrite the bind result with the cache insertion result.
-                HRESULT hrResult = hr;
-                IfFailRet(CacheBindResult(pIdentity, hr));
-                if (hr == S_OK)
-                {   // Cache now owns identity object lifetime.
-                    pIdentity.SuppressRelease();
-                }
-                hr = hrResult;
-            }
-            IfFailRet(hr);
-        }
-
-        NewHolder<CLRPrivResourcePathImpl> pResourcePath = new CLRPrivResourcePathImpl(wzFilePath);
-        IfFailRet(pResourcePath->QueryInterface(__uuidof(ICLRPrivResource), (LPVOID*)&pResourceIL));
-        pResourcePath.SuppressRelease();
-
-        // Create an IBindResult and provide it to the new CLRPrivAssemblyAppX object.
-        ReleaseHolder<IBindResult> pIBindResult = ToInterface<IBindResult>(
-            new CLRPrivAssemblyBindResultWrapper(pIAssemblyName, wzFilePath, m_pFingerprintFactory));
-
-
-        // Create the new CLRPrivAssemblyAppX object.
-        NewHolder<CLRPrivAssemblyAppX> pAssemblyObj =
-            new CLRPrivAssemblyAppX(pIdentity, this, pResourceIL, pIBindResult);
-
-        //
-        // Check cache. If someone beat us then use it instead; otherwise add new ICLRPrivAssembly.
-        //
-        do
-        {
-            // Because the read lock must be taken within a ForbidSuspend region, use AddInPhases.
-            if (m_NameToAssemblyMap.CheckAddInPhases<ForbidSuspendThreadCrstHolder, CrstHolder>(
-                    pAssemblyObj, m_MapReadLock, m_MapWriteLock, pAssemblyObj.GetValue()))
-            {
-                {   // Careful not to allow the cache insertion result to overwrite the bind result.
-                    HRESULT hrResult = hr;
-                    IfFailRet(CacheBindResult(pIdentity, hr));
-                    if (hr == S_OK)
-                    {   // Cache now owns identity object lifetime, but ~CLRPrivBinderAssembly
-                        // can also remove the identity from the cache prior to cache deletion.
-                        pIdentity.SuppressRelease();
-                    }
-                    hr = hrResult;
-                }
-                
-                pAssembly = pAssemblyObj.Extract();
-            }
-            else
-            {
-                ForbidSuspendThreadCrstHolder lock(&m_MapReadLock);
-                pAssembly = clr::SafeAddRef(m_NameToAssemblyMap.Lookup(wzSimpleName));
-            }
-        }
-        while (pAssembly == nullptr); // Keep looping until we find the existing one, or add a new one
-    }
-
-    _ASSERTE(pAssembly != nullptr);
-
-    if (((dwAppXBindFlags & ABF_BindNI) == ABF_BindNI) && 
-        m_fCanUseNativeImages)
-    {
-        //
-        // Look to see if there's a native image available.
-        //
-
-        // Fire BindingNgenPhaseStart ETW event if enabled.
-        {
-            InlineSString<128> ssAssemblyName;
-            FireEtwBindingNgenPhaseStart(
-                (AppDomain::GetCurrentDomain()->GetId().m_dwId),
-                LOADCTX_TYPE_HOSTED,
-                ETWFieldUnused,
-                ETWLoaderLoadTypeNotAvailable,
-                NULL,
-                FusionBind::GetAssemblyNameDisplayName(pIAssemblyName, ssAssemblyName, ASM_DISPLAYF_FULL).GetUnicode(),
-                GetClrInstanceId());
-        }
-
-        ReleaseHolder<IBindResult> pIBindResultIL;
-        IfFailRet(pAssembly->GetIBindResult(&pIBindResultIL));
-        _ASSERTE(pIBindResultIL != nullptr);
-
-        NewArrayHolder<WCHAR> wzZapSet = DuplicateStringThrowing(g_pConfig->ZapSet());
-        NativeConfigData cfgData = {
-            wzZapSet,
-            PEFile::GetNativeImageConfigFlags()
-        };
-
-        IfFailRet(BindToNativeAssembly(
-            pIBindResultIL, &cfgData, static_cast<IBindContext*>(this), fusion::logging::GetCurrentFusionBindLog()));
-
-        // Ensure that the native image found above in BindToNativeAssembly is reported as existing in the CLRPrivAssembly object
-        if (hr == S_OK)
-        {
-            ReleaseHolder<ICLRPrivResource> pNIImageResource;
-            // This will make GetAvailableImageTypes return that a native image exists.
-            IfFailRet(pAssembly->GetImageResource(ASSEMBLY_IMAGE_TYPE_NATIVE, NULL, &pNIImageResource));
-#ifdef _DEBUG
-            DWORD dwImageTypes;
-
-            _ASSERTE(SUCCEEDED(pAssembly->GetAvailableImageTypes(&dwImageTypes)));
-            _ASSERTE((dwImageTypes & ASSEMBLY_IMAGE_TYPE_NATIVE) == ASSEMBLY_IMAGE_TYPE_NATIVE);
-#endif
-        }
-
-        // Fire BindingNgenPhaseEnd ETW event if enabled.
-        {
-            InlineSString<128> ssAssemblyName;
-            FireEtwBindingNgenPhaseEnd(
-                (AppDomain::GetCurrentDomain()->GetId().m_dwId),
-                LOADCTX_TYPE_HOSTED,
-                ETWFieldUnused,
-                ETWLoaderLoadTypeNotAvailable,
-                NULL,
-                FusionBind::GetAssemblyNameDisplayName(pIAssemblyName, ssAssemblyName, ASM_DISPLAYF_FULL).GetUnicode(),
-                GetClrInstanceId());
-        }
-
-        // BindToNativeAssembly can return S_FALSE, but this could be misleading.
-        if (hr == S_FALSE)
-            hr = S_OK;
-    }
-
-    if (SUCCEEDED(hr))
-    {
-        *ppAssembly = pAssembly.Extract();
-    }
-
-    return hr;
-}
-
-//=====================================================================================================================
-HRESULT CLRPrivBinderAppX::BindAppXAssemblyByName(
-    IAssemblyName * pIAssemblyName,
-    DWORD dwAppXBindFlags,
-    ICLRPrivAssembly ** ppPrivAssembly)
-{
-    STANDARD_VM_CONTRACT;
-    HRESULT hr = S_OK;
-
-    ReleaseHolder<CLRPrivAssemblyAppX> pAppXAssembly;
-    IfFailRet(BindAppXAssemblyByNameWorker(pIAssemblyName, dwAppXBindFlags, &pAppXAssembly));
-    IfFailRet(pAppXAssembly->QueryInterface(__uuidof(ICLRPrivAssembly), (LPVOID*)ppPrivAssembly));
-
-    return hr;
-}
-
-//=====================================================================================================================
-HRESULT CLRPrivBinderAppX::PreBindAppXAssemblyByName(
-    IAssemblyName * pIAssemblyName,
-    DWORD           dwAppXBindFlags,
-    IBindResult **  ppIBindResult)
-{
-    STANDARD_VM_CONTRACT;
-    HRESULT hr = S_OK;
-
-    VALIDATE_ARG_RET(pIAssemblyName != nullptr);
-    VALIDATE_ARG_RET(ppIBindResult != nullptr);
-
-
-    ReleaseHolder<CLRPrivAssemblyAppX> pAppXAssembly;
-    IfFailRet(BindAppXAssemblyByNameWorker(pIAssemblyName, dwAppXBindFlags, &pAppXAssembly));
-    IfFailRet(pAppXAssembly->GetIBindResult(ppIBindResult));
-
-    return hr;
-}
-
-//=====================================================================================================================
-HRESULT CLRPrivBinderAppX::FindAssemblyBySpec(
-    LPVOID pvAppDomain,
-    LPVOID pvAssemblySpec,
-    HRESULT * pResult,
-    ICLRPrivAssembly ** ppAssembly)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        FORBID_FAULT;
-        MODE_ANY;
-        CAN_TAKE_LOCK;
-    }
-    CONTRACTL_END
-
-    HRESULT hr = S_OK;
-
-    AppDomain* pAppDomain = reinterpret_cast<AppDomain*>(pvAppDomain);
-    AssemblySpec* pAssemblySpec = reinterpret_cast<AssemblySpec*>(pvAssemblySpec);
-    VALIDATE_PTR_RET(pAppDomain);
-    VALIDATE_PTR_RET(pAssemblySpec);
-    VALIDATE_PTR_RET(pResult);
-    VALIDATE_PTR_RET(ppAssembly);
-
-    //
-    // Follow the same order as a bind.
-    //
-
-    hr = CLR_E_BIND_UNRECOGNIZED_IDENTITY_FORMAT;
-
-    if (FAILED(hr))
-    {
-        _ASSERTE(m_pFusionBinder != nullptr);
-        hr = m_pFusionBinder->FindFusionAssemblyBySpec(pAppDomain, pAssemblySpec, m_fusionBindingScope, pResult, ppAssembly);
-    }
-
-    // See comment in code:CLRPrivBinderAppX::BindAssemblyByName for explanation of this conditional.
-    if (hr == CLR_E_BIND_UNRECOGNIZED_IDENTITY_FORMAT)
-    {
-        if (FAILED(hr) && (m_pWinRTBinder != nullptr))
-        {
-            hr = m_pWinRTBinder->FindWinRTAssemblyBySpec(pAppDomain, pAssemblySpec, pResult, ppAssembly);
-        }
-
-        if (FAILED(hr))
-        {
-            AssemblyIdentity refId;
-            IfFailRet(refId.Initialize(pAssemblySpec));
-            bool fCheckParent = false;
-
-            {   // Check for a previously-recorded bind. Host callouts are now forbidden.
-                ForbidSuspendThreadCrstHolder lock(&m_MapReadLock);
-                BindingRecordMap::element_t const * pKeyVal = m_BindingRecordMap.LookupPtr(&refId);
-
-                if (pKeyVal != nullptr)
-                {
-                    //
-                    // Previous bind occurred. If a failure result is cached then the binder would
-                    // have tried the parent binder (if available) before returning.
-                    //
-
-                    AssemblyIdentity const & defId(*pKeyVal->Key());
-                    BindingRecord const & record(pKeyVal->Value());
-
-                    *ppAssembly = nullptr;
-                    *pResult = record.hr;
-
-                    if (SUCCEEDED(*pResult))
-                    {
-                        //
-                        // Previous bind succeeded. Get the corresponding ICLRPrivAssembly.
-                        //
-
-                        // Check this binder for a match. Host callouts are now forbidden.
-                        CLRPrivAssemblyAppX* pPrivAssembly = m_NameToAssemblyMap.Lookup(defId.Name);
-
-                        if (pPrivAssembly == nullptr)
-                        {
-                            _ASSERTE_MSG(false, "Should never see success value and a null CLRPrivAssemblyAppX pointer.");
-                            return (*pResult = E_UNEXPECTED);
-                        }
-
-                        _ASSERTE(pPrivAssembly->m_pIdentity != nullptr);
-                        _ASSERTE(pPrivAssembly->m_pIdentity == &defId);
-
-                        // Now check that the version and PKT values are compatible.
-                        *pResult = CLRPrivBinderUtil::VerifyBind(refId, *pPrivAssembly->m_pIdentity);
-
-                        if (SUCCEEDED(*pResult))
-                        {
-                            VERIFY(SUCCEEDED(pPrivAssembly->QueryInterface(__uuidof(ICLRPrivAssembly), (LPVOID*)ppAssembly)));
-                        }
-
-                        return S_OK;
-                    }
-                    else
-                    {
-                        //
-                        // Previous bind failed. Check the parent binder (if available), but do it outside of this binder's lock.
-                        //
-
-                        fCheckParent = true;
-                    }
-                }
-                else
-                {
-                    //
-                    // No previous bind occurred. Do not check the parent binder since this could result
-                    // in an incorrect bind (if this binder would have bound to a different assembly).
-                    //
-
-                    return E_FAIL;
-                }
-            }
-
-            if (fCheckParent && m_pParentBinder != nullptr)
-            {   // Check the parent (shared designer context) for a match.
-                hr = m_pParentBinder->FindAssemblyBySpec(pAppDomain, pAssemblySpec, pResult, ppAssembly);
-            }
-        }
-    }
-
-    // There are three possibilities upon exit:
-    //   1. Cache lookup failed, in which case FAILED(hr) == true
-    //   2. A binding failure was cached, in which case (1) == false && FAILED(*pResult) == true
-    //   3. A binding success was cached, in which case we must find an assembly:
-    //      (1) == false && (2) == false && *ppAssembly != nullptr
-    _ASSERTE(FAILED(hr) || FAILED(*pResult) || *ppAssembly != nullptr);
-    return hr;
-}
-
-//=====================================================================================================================
-// Record the binding result to support cache-based lookups (using ICLRPrivCachedBinder::FindAssemblyBySpec).
-
-HRESULT CLRPrivBinderAppX::CacheBindResult(
-    AssemblyIdentity *      pIdentity,  // On success, will assume object lifetime ownership.
-    HRESULT                 hrResult)
-{
-    STANDARD_VM_CONTRACT;
-
-    HRESULT hr = S_OK;
-
-    VALIDATE_PTR_RET(pIdentity);
-
-    // Initialize the binding record.
-    BindingRecord rec = { hrResult };
-    BindingRecordMap::element_t newEntry(pIdentity, rec);
-
-    // Because the read lock must be taken within a ForbidSusped region, use CheckAddInPhases.
-    if (m_BindingRecordMap.CheckAddInPhases<ForbidSuspendThreadCrstHolder, CrstHolder>(
-            newEntry, m_MapReadLock, m_MapWriteLock))
-    {
-        // Indicates that this identity object was cached.
-        // Caller relinquishes object ownership.
-        return S_OK;
-    }
-    else
-    {
-        // Pre-existing entry was found.
-
-#ifdef _DEBUG
-        ForbidSuspendThreadCrstHolder lock(&m_MapReadLock);
-        auto pExistingEntry = m_BindingRecordMap.LookupPtr(pIdentity);
-        if (pExistingEntry != nullptr)
-        {
-            // It's possible for racing threads to try to cache their results;
-            // just make sure that they got the same HRESULT.
-            _ASSERTE(pExistingEntry->Value().hr == rec.hr);
-        }
-#endif
-
-        // Indicates that previous entry existed, and this identity object was not cached.
-        // Caller retains object ownership.
-        hr = S_FALSE;
-    }
-
-    return hr;
-}
-
-//=====================================================================================================================
-// Implements code:ICLRPrivBinder::BindAssemblyByName
-
-HRESULT CLRPrivBinderAppX::BindAssemblyByName(
-    IAssemblyName * pAssemblyName,
-    ICLRPrivAssembly ** ppAssembly)
-{
-    STANDARD_BIND_CONTRACT;
-    BinderHRESULT hr = S_OK;
-    ReleaseHolder<ICLRPrivAssembly> pResult;
-
-    VALIDATE_ARG_RET(pAssemblyName != nullptr && ppAssembly != nullptr);
-
-    EX_TRY
-    {
-        hr = CLR_E_BIND_UNRECOGNIZED_IDENTITY_FORMAT;
-
-        if (FAILED(hr))
-        {
-            _ASSERTE(m_pFusionBinder != nullptr);
-            hr = m_pFusionBinder->BindFusionAssemblyByName(pAssemblyName, GetFusionBindingScope(), &pResult);
-        }
-
-        //
-        // The fusion binder returns CLR_E_BIND_UNRECOGNIZED_IDENTITY_FORMAT only if it did not
-        // recognize pAssemblyName as a FX assembly. Only then should other binders be consulted
-        // (otherwise applications would be able to copy arbitrary FX assemblies into their AppX
-        // package and use them directly).
-        //
-
-        if (hr == CLR_E_BIND_UNRECOGNIZED_IDENTITY_FORMAT)
-        {
-            if (FAILED(hr) && (m_pWinRTBinder != nullptr))
-            {
-                hr = m_pWinRTBinder->BindWinRTAssemblyByName(pAssemblyName, &pResult);
-            }
-
-            if (FAILED(hr))
-            {
-                hr = BindAppXAssemblyByName(pAssemblyName, ABF_Default, &pResult);
-            }
-
-            if (FAILED(hr) && (m_pParentBinder != nullptr))
-            {
-                hr = m_pParentBinder->BindAssemblyByName(pAssemblyName, &pResult);
-            }
-
-            _ASSERTE(FAILED(hr) || pResult != nullptr);
-        }
-    }
-    EX_CATCH_HRESULT(hr);
-
-    // Return if either the bind or the bind cache fails.
-    IfFailRet(hr);
-
-    // Success.
-    *ppAssembly = pResult.Extract();
-    return hr;
-}
-
-//=====================================================================================================================
-// Implements code:IBindContext::PreBind
-HRESULT CLRPrivBinderAppX::PreBind(
-    IAssemblyName * pIAssemblyName, 
-    DWORD           dwPreBindFlags, 
-    IBindResult **  ppIBindResult)
-{
-    STANDARD_BIND_CONTRACT;
-    BinderHRESULT hr = S_OK;
-
-    VALIDATE_ARG_RET((dwPreBindFlags & ~(PRE_BIND_APPLY_POLICY)) == 0);
-    VALIDATE_ARG_RET(pIAssemblyName != nullptr && ppIBindResult != nullptr);
-
-    // Assert that we are only working with binder that supports Native Images context bits.
-    _ASSERTE(m_fCanUseNativeImages);
-
-    EX_TRY
-    {
-        hr = CLR_E_BIND_UNRECOGNIZED_IDENTITY_FORMAT;
-
-        if (FAILED(hr))
-        {
-            hr = m_pFusionBinder->PreBindFusionAssemblyByName(pIAssemblyName, dwPreBindFlags, ppIBindResult);
-        }
-
-        if (FAILED(hr) && (m_pWinRTBinder != nullptr))
-        {
-            hr = m_pWinRTBinder->BindWinRTAssemblyByName(pIAssemblyName, ppIBindResult, TRUE);
-        }
-
-        if (FAILED(hr))
-        {
-            hr = PreBindAppXAssemblyByName(pIAssemblyName, ABF_BindIL, ppIBindResult);
-        }
-    }
-    EX_CATCH_HRESULT(hr);
-    
-    if (FAILED(hr) && (m_pParentBinder != nullptr))
-    {
-        ReleaseHolder<IBindContext> pParentBindContext;
-        hr = m_pParentBinder->QueryInterface(__uuidof(IBindContext), (LPVOID *)&pParentBindContext);
-        if (SUCCEEDED(hr))
-        {
-            hr = pParentBindContext->PreBind(pIAssemblyName, dwPreBindFlags, ppIBindResult);
-        }
-    }
-    
-    return hr;
-}
-
-//=====================================================================================================================
-UINT_PTR CLRPrivBinderAppX::GetBinderID()
-{
-    LIMITED_METHOD_CONTRACT;
-    return reinterpret_cast<UINT_PTR>(this);
-}
-
-//=====================================================================================================================
-// Implements code:ICLRPrivBinder::GetBinderID
-HRESULT CLRPrivBinderAppX::GetBinderID(
-    UINT_PTR *pBinderId)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    *pBinderId = GetBinderID();
-    return S_OK;
-}
-
-//=====================================================================================================================
-// Implements code:IBindContext::IsDefaultContext
-HRESULT CLRPrivBinderAppX::IsDefaultContext()
-{
-    LIMITED_METHOD_CONTRACT;
-    return S_OK;
-}
-
-//=====================================================================================================================
-// Implements code:ICLRPrivWinRtTypeBinder::FindAssemblyForWinRtTypeIfLoaded
-// Finds Assembly * for type in AppDomain * if it is loaded.
-// Returns NULL if assembly is not loaded or type is not found.
-// 
-void * 
-CLRPrivBinderAppX::FindAssemblyForWinRtTypeIfLoaded(
-    void *  pAppDomain, 
-    LPCUTF8 szNamespace, 
-    LPCUTF8 szClassName)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        FORBID_FAULT;
-        MODE_ANY;
-    }
-    CONTRACTL_END
-    
-    void * pAssembly = nullptr;
-    if (m_pWinRTBinder != nullptr)
-    {
-        pAssembly = (void *)m_pWinRTBinder->FindAssemblyForTypeIfLoaded(
-            dac_cast<PTR_AppDomain>((AppDomain *)pAppDomain), 
-            szNamespace, 
-            szClassName);
-    }
-    
-    if ((pAssembly == nullptr) && (m_pParentBinder != nullptr))
-    {
-        ReleaseHolder<ICLRPrivWinRtTypeBinder> pParentBinder = 
-                ToInterface_NoThrow<ICLRPrivWinRtTypeBinder>(m_pParentBinder.GetValue());
-        // Parent binder should be another instance of code:CLRPrivBinderAppX class that implements the interface
-        _ASSERTE(pParentBinder != nullptr);
-        
-        pAssembly = pParentBinder->FindAssemblyForWinRtTypeIfLoaded(
-            pAppDomain, 
-            szNamespace, 
-            szClassName);
-    }
-    
-    return pAssembly;
-}
-
-//=====================================================================================================================
-CLRPrivAssemblyAppX::CLRPrivAssemblyAppX(
-    CLRPrivBinderUtil::AssemblyIdentity * pIdentity,
-    CLRPrivBinderAppX *pBinder,
-    ICLRPrivResource *pIResourceIL,
-    IBindResult * pIBindResult)
-    : m_pIdentity(pIdentity),
-      m_pBinder(nullptr),
-      m_pIResourceIL(nullptr),
-      m_pIResourceNI(nullptr),
-      m_pIBindResult(nullptr)
-{
-    STANDARD_VM_CONTRACT;
-
-    VALIDATE_PTR_THROW(pIdentity);
-    VALIDATE_PTR_THROW(pBinder);
-    VALIDATE_PTR_THROW(pIResourceIL);
-    VALIDATE_PTR_THROW(pIBindResult);
-
-    m_pBinder = clr::SafeAddRef(pBinder);
-    m_pIResourceIL = clr::SafeAddRef(pIResourceIL);
-    m_pIBindResult = clr::SafeAddRef(pIBindResult);
-}
-
-//=====================================================================================================================
-CLRPrivAssemblyAppX::~CLRPrivAssemblyAppX()
-{
-    LIMITED_METHOD_CONTRACT;
-    clr::SafeRelease(m_pIResourceNI);
-}
-
-//=====================================================================================================================
-LPCWSTR CLRPrivAssemblyAppX::GetSimpleName() const
-{
-    LIMITED_METHOD_CONTRACT;
-    return m_pIdentity->Name;
-}
-
-//=====================================================================================================================
-// Implements code:IUnknown::Release
-ULONG CLRPrivAssemblyAppX::Release()
-{
-    LIMITED_METHOD_CONTRACT;
-    STATIC_CONTRACT_CAN_TAKE_LOCK;
-    _ASSERTE(m_cRef > 0);
-
-    ULONG cRef;
-    
-    {
-        // To achieve proper lifetime semantics, the name to assembly map elements' CLRPrivAssemblyAppX 
-        // instances are not ref counted. We cannot allow discovery of the object via m_NameToAssemblyMap 
-        // when the ref count is 0 (to prevent another thread to AddRef and Release it back to 0 in parallel).
-        // All uses of the map are guarded by the map lock, so we have to decrease the ref count under that 
-        // lock (to avoid the chance that 2 threads are running Release to ref count 0 at once).
-        // Host callouts are now forbidden.
-        ForbidSuspendThreadCrstHolder lock(&m_pBinder->m_MapReadLock);
-        
-        cRef = InterlockedDecrement(&m_cRef);
-        if (cRef == 0)
-        {
-            m_pBinder->m_NameToAssemblyMap.Remove(GetSimpleName());
-            m_pBinder->m_BindingRecordMap.Remove(m_pIdentity);
-        }
-    }
-
-    if (cRef == 0)
-    {
-        delete this;
-    }
-    
-    return cRef;
-}
-
-//=====================================================================================================================
-// Implements code:ICLRPrivBinder::BindAssemblyByName
-HRESULT CLRPrivAssemblyAppX::BindAssemblyByName(
-    IAssemblyName * pAssemblyName,
-    ICLRPrivAssembly ** ppAssembly)
-{
-    WRAPPER_NO_CONTRACT;
-
-    return m_pBinder->BindAssemblyByName(
-        pAssemblyName,
-        ppAssembly);
-}
-
-//=====================================================================================================================
-// Implements code:ICLRPrivBinder::GetBinderID
-HRESULT CLRPrivAssemblyAppX::GetBinderID(
-    UINT_PTR *pBinderId)
-{
-    WRAPPER_NO_CONTRACT;
-    return m_pBinder->GetBinderID(
-        pBinderId);
-}
-
-//=====================================================================================================================
-// Implements code:ICLRPrivAssembly::IsShareable
-HRESULT CLRPrivAssemblyAppX::IsShareable(
-    BOOL * pbIsShareable)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    VALIDATE_ARG_RET(pbIsShareable != nullptr);
-
-    *pbIsShareable = FALSE;
-    return S_OK;
-}
-
-//=====================================================================================================================
-// Implements code:ICLRPrivAssembly::GetAvailableImageTypes
-HRESULT CLRPrivAssemblyAppX::GetAvailableImageTypes(
-    LPDWORD pdwImageTypes)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    VALIDATE_ARG_RET(pdwImageTypes != nullptr);
-
-    *pdwImageTypes = 0;
-
-    if (m_pIResourceIL != nullptr)
-        *pdwImageTypes |= ASSEMBLY_IMAGE_TYPE_IL;
-
-    if (m_pIResourceNI != nullptr)
-        *pdwImageTypes |= ASSEMBLY_IMAGE_TYPE_NATIVE;
-
-    return S_OK;
-}
-
-//=====================================================================================================================
-static ICLRPrivResource* GetResourceForBindResult(
-    IBindResult * pIBindResult)
-{
-    STANDARD_VM_CONTRACT;
-    VALIDATE_ARG_THROW(pIBindResult != nullptr);
-
-    WCHAR wzPath[_MAX_PATH];
-    DWORD cchPath = NumItems(wzPath);
-    ReleaseHolder<IAssemblyLocation> pIAssemLoc;
-    IfFailThrow(pIBindResult->GetAssemblyLocation(&pIAssemLoc));
-    IfFailThrow(pIAssemLoc->GetPath(wzPath, &cchPath));
-    return ToInterface<ICLRPrivResource>(new CLRPrivResourcePathImpl(wzPath));
-}
-
-//=====================================================================================================================
-// Implements code:ICLRPrivAssembly::GetImageResource
-HRESULT CLRPrivAssemblyAppX::GetImageResource(
-    DWORD dwImageType,
-    DWORD * pdwImageType,
-    ICLRPrivResource ** ppIResource)
-{
-    STANDARD_BIND_CONTRACT;
-    HRESULT hr = S_OK;
-
-    VALIDATE_ARG_RET(ppIResource != nullptr && m_pIBindResult != nullptr);
-
-    EX_TRY
-    {
-        DWORD _dwImageType;
-        if (pdwImageType == nullptr)
-            pdwImageType = &_dwImageType;
-
-        if ((dwImageType & ASSEMBLY_IMAGE_TYPE_NATIVE) == ASSEMBLY_IMAGE_TYPE_NATIVE)
-        {
-            ReleaseHolder<IBindResult> pIBindResultNI;
-            if (m_pIResourceNI == nullptr)
-            {
-                if (SUCCEEDED(hr = m_pIBindResult->GetNativeImage(&pIBindResultNI, nullptr)) && pIBindResultNI != nullptr)
-                {
-                    ReleaseHolder<ICLRPrivResource> pResourceNI = GetResourceForBindResult(pIBindResultNI);
-                    if (InterlockedCompareExchangeT<ICLRPrivResource *>(&m_pIResourceNI, pResourceNI, nullptr) == nullptr)
-                        pResourceNI.SuppressRelease();
-                }
-                else
-                {
-                    IfFailGo(CLR_E_BIND_IMAGE_UNAVAILABLE);
-                }
-            }
-
-            *ppIResource = clr::SafeAddRef(m_pIResourceNI);
-            *pdwImageType = ASSEMBLY_IMAGE_TYPE_NATIVE;
-        }
-        else if ((dwImageType & ASSEMBLY_IMAGE_TYPE_IL) == ASSEMBLY_IMAGE_TYPE_IL)
-        {
-            *ppIResource = clr::SafeAddRef(m_pIResourceIL);
-            *pdwImageType = ASSEMBLY_IMAGE_TYPE_IL;
-        }
-        else
-        {
-            hr = CLR_E_BIND_IMAGE_UNAVAILABLE;
-        }
-
-    ErrExit:
-        ;
-    }
-    EX_CATCH_HRESULT(hr);
-
-    return hr;
-}
-
-
-//=====================================================================================================================
-// Implements code:ICLRPrivBinder::VerifyBind
-HRESULT CLRPrivBinderAppX::VerifyBind(
-    IAssemblyName *pAssemblyName,
-    ICLRPrivAssembly *pAssembly,
-    ICLRPrivAssemblyInfo *pAssemblyInfo)
-{
-    STANDARD_BIND_CONTRACT;
-
-    HRESULT hr = S_OK;
-
-    VALIDATE_ARG_RET(pAssemblyName!= nullptr && pAssemblyInfo != nullptr);
-
-    UINT_PTR binderID;
-    IfFailRet(pAssembly->GetBinderID(&binderID));
-
-    if (binderID != GetBinderID())
-    {
-        return pAssembly->VerifyBind(pAssemblyName, pAssembly, pAssemblyInfo);
-    }
-
-    return CLRPrivBinderUtil::VerifyBind(pAssemblyName, pAssemblyInfo);
-}
-
-//=====================================================================================================================
-/*static*/
-LPCWSTR CLRPrivBinderAppX::NameToAssemblyMapTraits::GetKey(CLRPrivAssemblyAppX *pAssemblyAppX)
-{
-    WRAPPER_NO_CONTRACT;
-    _ASSERT(pAssemblyAppX != nullptr);
-    return pAssemblyAppX->GetSimpleName();
-}
-
-//=====================================================================================================================
-HRESULT CLRPrivAssemblyAppX::GetIBindResult(
-    IBindResult ** ppIBindResult)
-{
-    STANDARD_VM_CONTRACT;
-
-    VALIDATE_ARG_RET(ppIBindResult != nullptr);
-    VALIDATE_CONDITION(m_pIBindResult != nullptr, return E_UNEXPECTED);
-
-    *ppIBindResult = clr::SafeAddRef(m_pIBindResult);
-
-    return S_OK;
-}
-
-#endif // !DACCESS_COMPILE
diff --git a/src/vm/clrprivbinderappx.h b/src/vm/clrprivbinderappx.h
deleted file mode 100644
index 4b241e0cc5..0000000000
--- a/src/vm/clrprivbinderappx.h
+++ /dev/null
@@ -1,364 +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.
-
-
-
-#pragma once
-
-#include "holder.h"
-#include "internalunknownimpl.h"
-#include "shash.h"
-#include "fusion.h"
-#include "clrprivbinding.h"
-#include "clrprivruntimebinders.h"
-#include "clrprivbinderfusion.h"
-#include "clrprivbinderwinrt.h"
-
-//=====================================================================================================================
-// Forward declarations
-class CLRPrivBinderAppX;
-class CLRPrivAssemblyAppX;
-
-class DomainAssembly;
-
-// Forward declaration of helper class used in native image binding.
-class CLRPrivAssemblyAppX_NIWrapper;
-
-typedef DPTR(CLRPrivBinderAppX) PTR_CLRPrivBinderAppX;
-
-//=====================================================================================================================
-class CLRPrivBinderAppX : 
-    public IUnknownCommon<ICLRPrivBinder, IBindContext, ICLRPrivWinRtTypeBinder>
-{
-    friend class CLRPrivAssemblyAppX;
-
-public:
-    //=============================================================================================
-    // ICLRPrivBinder methods
-
-    // Implements code:ICLRPrivBinder::BindAssemblyByName
-    STDMETHOD(BindAssemblyByName)(
-        IAssemblyName * pAssemblyName,
-        ICLRPrivAssembly ** ppAssembly);
-
-    // Implements code:ICLRPrivBinder::VerifyBind
-    STDMETHOD(VerifyBind)(
-        IAssemblyName *pAssemblyName,
-        ICLRPrivAssembly *pAssembly,
-        ICLRPrivAssemblyInfo *pAssemblyInfo);
-
-    // Implements code:ICLRPrivBinder::GetBinderFlags
-    STDMETHOD(GetBinderFlags)(
-        DWORD *pBinderFlags)
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        if (pBinderFlags == NULL)
-            return E_INVALIDARG;
-
-        *pBinderFlags = m_pParentBinder != NULL ? BINDER_DESIGNER_BINDING_CONTEXT : BINDER_NONE;
-        return S_OK;
-    }
-
-    // Implements code:ICLRPrivBinder::GetBinderID
-    STDMETHOD(GetBinderID)(
-        UINT_PTR *pBinderId);
-    
-    STDMETHOD(FindAssemblyBySpec)(
-        LPVOID pvAppDomain,
-        LPVOID pvAssemblySpec,
-        HRESULT * pResult,
-        ICLRPrivAssembly ** ppAssembly);
-
-    //=============================================================================================
-    // ICLRPrivWinRtTypeBinder methods
-    
-    // Implements code:ICLRPrivWinRtTypeBinder::FindAssemblyForWinRtTypeIfLoaded
-    STDMETHOD_(void *, FindAssemblyForWinRtTypeIfLoaded)(
-        void *  pAppDomain, 
-        LPCUTF8 szNamespace, 
-        LPCUTF8 szClassName);
-    
-    //=============================================================================================
-    // IBindContext methods
-
-    // Implements code:IBindContext::PreBind
-    STDMETHOD(PreBind)(
-        IAssemblyName  *pIAssemblyName,
-        DWORD           dwPreBindFlags,
-        IBindResult   **ppIBindResult);
-
-    // Implements code:IBindContext::IsDefaultContext
-    STDMETHOD(IsDefaultContext)();
-
-    //=============================================================================================
-    // Class methods
-
-    //---------------------------------------------------------------------------------------------
-    static
-    CLRPrivBinderAppX * GetOrCreateBinder();
-    
-    static 
-    PTR_CLRPrivBinderAppX GetBinderOrNull()
-    {
-        LIMITED_METHOD_DAC_CONTRACT;
-        return s_pSingleton;
-    }
-    
-    static 
-    CLRPrivBinderAppX * CreateParentedBinder(
-        ICLRPrivBinder *        pParentBinder, 
-        CLRPrivTypeCacheWinRT * pWinRtTypeCache, 
-        LPCWSTR *               rgwzAltPath, 
-        UINT                    cAltPaths,
-        BOOL                    fCanUseNativeImages);
-    
-    //---------------------------------------------------------------------------------------------
-    ~CLRPrivBinderAppX();
-
-    //---------------------------------------------------------------------------------------------
-    enum AppXBindFlags
-    {
-        ABF_BindIL      = 1,
-        ABF_BindNI      = 2,
-        ABF_Default     = ABF_BindIL | ABF_BindNI,
-    };
-
-    //---------------------------------------------------------------------------------------------
-    CLRPrivBinderFusion * GetFusionBinder()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return m_pFusionBinder;
-    }
-    
-    PTR_CLRPrivBinderWinRT GetWinRtBinder()
-    {
-        LIMITED_METHOD_DAC_CONTRACT;
-        return m_pWinRTBinder;
-    }
-    
-private:
-    //---------------------------------------------------------------------------------------------
-    // Binds within AppX packages only. BindAssemblyByName takes care of delegating to Fusion
-    // when needed.
-    HRESULT BindAppXAssemblyByNameWorker(
-        IAssemblyName * pIAssemblyName,
-        DWORD dwAppXBindFlags,
-        CLRPrivAssemblyAppX ** ppAssembly);
-
-    //---------------------------------------------------------------------------------------------
-    // Binds within AppX packages only. BindAssemblyByName takes care of delegating to Fusion
-    // when needed.
-    HRESULT BindAppXAssemblyByName(
-        IAssemblyName * pIAssemblyName,
-        DWORD dwAppXBindFlags,
-        ICLRPrivAssembly ** ppPrivAssembly);
-
-    //---------------------------------------------------------------------------------------------
-    // Binds within AppX packages only. PreBindAssemblyByName takes care of delegating to Fusion
-    // when needed.
-    HRESULT PreBindAppXAssemblyByName(
-        IAssemblyName * pIAssemblyName,
-        DWORD dwAppXBindFlags,
-        IBindResult ** ppIBindResult);
-
-    //---------------------------------------------------------------------------------------------
-    UINT_PTR GetBinderID();
-
-    //---------------------------------------------------------------------------------------------
-    CLRPrivBinderAppX(LPCWSTR *rgwzAltPath, UINT cAltPaths);
-
-    //---------------------------------------------------------------------------------------------
-    HRESULT CheckGetAppXRT();
-
-    //---------------------------------------------------------------------------------------------
-    HRESULT CacheBindResult(
-        CLRPrivBinderUtil::AssemblyIdentity *   pIdentity,
-        HRESULT                                 hrResult);
-    
-    //---------------------------------------------------------------------------------------------
-    CLRPrivBinderFusion::BindingScope GetFusionBindingScope();
-
-    //---------------------------------------------------------------------------------------------
-    Crst              m_MapReadLock;
-    Crst              m_MapWriteLock;
-
-    //---------------------------------------------------------------------------------------------
-    // Identity to CLRPrivBinderAppX map
-    struct NameToAssemblyMapTraits : public StringSHashTraits<CLRPrivAssemblyAppX, WCHAR, CaseInsensitiveStringCompareHash<WCHAR> >
-    {
-        static LPCWSTR GetKey(CLRPrivAssemblyAppX *pAssemblyAppX);
-    };
-    typedef SHash<NameToAssemblyMapTraits> NameToAssemblyMap;
-
-    NameToAssemblyMap m_NameToAssemblyMap;
-
-    //---------------------------------------------------------------------------------------------
-    // Binding record map, used by cache lookup requests.
-    struct BindingRecord
-    {
-        // This stores the result of the original bind request.
-        HRESULT hr;
-    };
-
-    struct BindingRecordMapTraits : public MapSHashTraits<CLRPrivBinderUtil::AssemblyIdentity*, BindingRecord>
-    {
-        typedef MapSHashTraits<CLRPrivBinderUtil::AssemblyIdentity*, BindingRecord> base_t;
-        typedef base_t::element_t element_t;
-        typedef base_t::count_t count_t;
-        typedef base_t::key_t;
-
-        static count_t Hash(key_t k) 
-        {
-            return HashiString(k->Name);
-        }
-
-        static BOOL Equals(key_t k1, key_t k2)
-        {
-            return SString::_wcsicmp(k1->Name, k2->Name) == 0;
-        }
-
-        static const bool s_DestructPerEntryCleanupAction = true;
-        static inline void OnDestructPerEntryCleanupAction(element_t const & e)
-        {
-            delete [] e.Key();
-        }
-    };
-    typedef SHash<BindingRecordMapTraits> BindingRecordMap;
-
-    BindingRecordMap m_BindingRecordMap;
-
-    //---------------------------------------------------------------------------------------------
-    NewArrayHolder< NewArrayHolder<WCHAR> > m_rgAltPathsHolder;
-    NewArrayHolder< WCHAR* >                m_rgAltPaths;
-    UINT                                    m_cAltPaths;
-
-#ifdef FEATURE_FUSION
-    BOOL                                    m_fCanUseNativeImages;
-    ReleaseHolder<IILFingerprintFactory>    m_pFingerprintFactory;
-#endif
-
-    //---------------------------------------------------------------------------------------------
-    // ParentBinder is set only in designer binding context (forms a chain of binders)
-    ReleaseHolder<ICLRPrivBinder>      m_pParentBinder;
-    
-    ReleaseHolder<CLRPrivBinderFusion> m_pFusionBinder;
-    PTR_CLRPrivBinderWinRT             m_pWinRTBinder;
-    
-    //---------------------------------------------------------------------------------------------
-    //static CLRPrivBinderAppX * s_pSingleton;
-    SPTR_DECL(CLRPrivBinderAppX, s_pSingleton);
-
-    //---------------------------------------------------------------------------------------------
-    // Cache the binding scope in the constructor so that there is no need to call into a WinRT
-    // API in a GC_NOTRIGGER scope later on.
-    CLRPrivBinderFusion::BindingScope   m_fusionBindingScope;
-};  // class CLRPrivBinderAppX
-
-
-//=====================================================================================================================
-class CLRPrivAssemblyAppX :
-    public IUnknownCommon<ICLRPrivAssembly>
-{
-    friend class CLRPrivBinderAppX;
-
-public:
-    //---------------------------------------------------------------------------------------------
-    CLRPrivAssemblyAppX(
-        CLRPrivBinderUtil::AssemblyIdentity * pIdentity,
-        CLRPrivBinderAppX *pBinder,
-        ICLRPrivResource *pIResourceIL,
-        IBindResult * pIBindResult);
-
-    //---------------------------------------------------------------------------------------------
-    ~CLRPrivAssemblyAppX();
-
-    //---------------------------------------------------------------------------------------------
-    // Implements code:IUnknown::Release
-    STDMETHOD_(ULONG, Release)();
-
-    //---------------------------------------------------------------------------------------------
-    LPCWSTR GetSimpleName() const;
-
-    //=============================================================================================
-    // ICLRPrivBinder interface methods
-    
-    // Implements code:ICLRPrivBinder::BindAssemblyByName
-    STDMETHOD(BindAssemblyByName)(
-        IAssemblyName * pAssemblyName,
-        ICLRPrivAssembly ** ppAssembly);
-
-    // Implements code:ICLRPrivBinder::VerifyBind
-    STDMETHOD(VerifyBind)(
-        IAssemblyName *pAssemblyName,
-        ICLRPrivAssembly *pAssembly,
-        ICLRPrivAssemblyInfo *pAssemblyInfo)
-    {
-        STANDARD_BIND_CONTRACT;
-
-        HRESULT hr = S_OK;
-
-        VALIDATE_PTR_RET(pAssemblyName);
-        VALIDATE_PTR_RET(pAssembly);
-        VALIDATE_PTR_RET(pAssemblyInfo);
-
-        // Re-initialize the assembly identity with full identity contained in metadata.
-        IfFailRet(m_pIdentity->Initialize(pAssemblyInfo));
-
-        return m_pBinder->VerifyBind(pAssemblyName, pAssembly, pAssemblyInfo);
-    }
-
-    // Implements code:ICLRPrivBinder::GetBinderFlags
-    STDMETHOD(GetBinderFlags)(
-        DWORD *pBinderFlags)
-    {
-        LIMITED_METHOD_CONTRACT;
-        return m_pBinder->GetBinderFlags(pBinderFlags);
-    }
-
-    // Implements code:ICLRPrivBinder::GetBinderID
-    STDMETHOD(GetBinderID)(
-        UINT_PTR *pBinderId);
-
-    // Implements code:ICLRPrivBinder::FindAssemblyBySpec
-    STDMETHOD(FindAssemblyBySpec)(
-        LPVOID pvAppDomain,
-        LPVOID pvAssemblySpec,
-        HRESULT * pResult,
-        ICLRPrivAssembly ** ppAssembly)
-    { STATIC_CONTRACT_WRAPPER; return m_pBinder->FindAssemblyBySpec(pvAppDomain, pvAssemblySpec, pResult, ppAssembly); }
-
-    //=============================================================================================
-    // ICLRPrivAssembly interface methods
-    
-    // Implements code:ICLRPrivAssembly::IsShareable
-    STDMETHOD(IsShareable)(
-        BOOL * pbIsShareable);
-
-    // Implements code:ICLRPrivAssembly::GetAvailableImageTypes
-    STDMETHOD(GetAvailableImageTypes)(
-        LPDWORD pdwImageTypes);
-
-    // Implements code:ICLRPrivAssembly::GetImageResource
-    STDMETHOD(GetImageResource)(
-        DWORD dwImageType,
-        DWORD *pdwImageType,
-        ICLRPrivResource ** ppIResource);
-
-    //---------------------------------------------------------------------------------------------
-    HRESULT GetIBindResult(
-        IBindResult ** ppIBindResult);
-
-private:
-    CLRPrivBinderUtil::AssemblyIdentity * m_pIdentity;
-    
-    ReleaseHolder<CLRPrivBinderAppX>      m_pBinder;
-
-    ReleaseHolder<ICLRPrivResource>       m_pIResourceIL;
-    // This cannot be a holder as there can be a race to assign to it.
-    ICLRPrivResource *                    m_pIResourceNI;
-
-    ReleaseHolder<IBindResult>            m_pIBindResult;
-};
-
diff --git a/src/vm/clrprivbinderfusion.cpp b/src/vm/clrprivbinderfusion.cpp
deleted file mode 100644
index d31774f7b2..0000000000
--- a/src/vm/clrprivbinderfusion.cpp
+++ /dev/null
@@ -1,819 +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.
-
-
-
-#include "common.h" // precompiled header
-
-#ifndef DACCESS_COMPILE
-
-//=====================================================================================================================
-#include "assemblyspec.hpp"
-#include "corhdr.h"
-#include "domainfile.h"
-#include "fusion.h"
-#include "policy.h"
-#include "sstring.h"
-#include "stackingallocator.h"
-#include "threads.h"
-#include "clrprivbinderfusion.h"
-#include "clrprivbinderutil.h"
-#include "fusionlogging.h"
-
-using namespace CLRPrivBinderUtil;
-
-//=================================================================================================
-#define STDMETHOD_NOTIMPL(...) \
-    STDMETHOD(__VA_ARGS__) \
-    { \
-        WRAPPER_NO_CONTRACT; \
-        _ASSERTE_MSG(false, "Method not implemented."); \
-        return E_NOTIMPL; \
-    }
-
-//=================================================================================================
-static HRESULT PropagateOutStringArgument(
-    __in  LPCSTR pszValue,
-    __out_ecount_opt(*pcchArg) LPWSTR pwzArg,
-    __in  DWORD cchArg,
-    __out DWORD * pcchArg)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    VALIDATE_PTR_RET(pszValue);
-    VALIDATE_CONDITION((pwzArg == nullptr || cchArg > 0), return E_INVALIDARG);
-
-    HRESULT hr = S_OK;
-
-    if (pwzArg != nullptr)
-    {
-        DWORD cchWritten = WszMultiByteToWideChar(
-            CP_UTF8, 0 /*flags*/, pszValue, -1, pwzArg, cchArg);
-
-        if (cchWritten == 0)
-        {
-            hr = HRESULT_FROM_GetLastError();
-        }
-        else if (pcchArg != nullptr)
-        {
-            *pcchArg = cchWritten;
-        }
-    }
-
-    if (pcchArg != nullptr && (pwzArg == nullptr || hr == HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)))
-    {
-        *pcchArg = WszMultiByteToWideChar(
-            CP_UTF8, 0 /*flags*/, pszValue, -1, nullptr, 0);
-
-        if (*pcchArg == 0)
-        {
-            hr = HRESULT_FROM_GetLastError();
-        }
-    }
-
-    return hr;
-}
-
-//=================================================================================================
-// This is needed to allow calls to IsAnyFrameworkAssembly in GC_NOTRIGGER/NO_FAULT regions (i.e.,
-// GC stack walking). CAssemblyName (which implements IAssemblyName in most other uses) allocates
-// during construction and so cannot be used in this scenario.
-
-class AssemblySpecAsIAssemblyName
-    : public IAssemblyName
-{
-public:
-    AssemblySpecAsIAssemblyName(
-        AssemblySpec * pSpec)
-        : m_pSpec(pSpec)
-    { LIMITED_METHOD_CONTRACT; }
-
-    //=============================================================================================
-    // IUnknown methods
-
-    // Not used by IsAnyFrameworkAssembly
-    STDMETHOD_(ULONG, AddRef())
-    {
-        WRAPPER_NO_CONTRACT;
-        _ASSERTE_MSG(false, "Method not implemented.");
-        return E_NOTIMPL;
-    }
-
-    // Not used by IsAnyFrameworkAssembly
-    STDMETHOD_(ULONG, Release())
-    {
-        WRAPPER_NO_CONTRACT;
-        _ASSERTE_MSG(false, "Method not implemented.");
-        return E_NOTIMPL;
-    }
-
-    // Not used by IsAnyFrameworkAssembly
-    STDMETHOD_NOTIMPL(QueryInterface(
-        REFIID riid,
-        void **ppvObject));
-
-    //=============================================================================================
-    // IAssemblyName methods
-
-    STDMETHOD_NOTIMPL(SetProperty(
-        DWORD        PropertyId, 
-        void const * pvProperty,
-        DWORD        cbProperty));
-
-#define ASSURE_SUFFICIENT_BUFFER(SRCSIZE) \
-    do { \
-        if ((pvProperty == nullptr) || (*pcbProperty < SRCSIZE)) { \
-            *pcbProperty = SRCSIZE; \
-            return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER); \
-        } \
-    } while (false)
-
-    STDMETHOD(GetProperty)(
-        DWORD    PropertyId, 
-        LPVOID   pvProperty,
-        LPDWORD  pcbProperty)
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        VALIDATE_PTR_RET(pcbProperty);
-        VALIDATE_CONDITION((pvProperty == nullptr) == (*pcbProperty == 0), return E_INVALIDARG);
-
-        HRESULT hr = S_OK;
-
-        switch (PropertyId)
-        {
-        case ASM_NAME_NAME:
-            return PropagateOutStringArgument(m_pSpec->GetName(), (LPWSTR) pvProperty,
-                                              *pcbProperty / sizeof(WCHAR), pcbProperty);
-
-        case ASM_NAME_MAJOR_VERSION:
-            ASSURE_SUFFICIENT_BUFFER(sizeof(USHORT));
-            *reinterpret_cast<USHORT*>(pvProperty) = m_pSpec->GetContext()->usMajorVersion;
-            *pcbProperty = sizeof(USHORT);
-            return S_OK;
-
-        case ASM_NAME_MINOR_VERSION:
-            ASSURE_SUFFICIENT_BUFFER(sizeof(USHORT));
-            *reinterpret_cast<USHORT*>(pvProperty) = m_pSpec->GetContext()->usMinorVersion;
-            *pcbProperty = sizeof(USHORT);
-            return S_OK;
-
-        case ASM_NAME_BUILD_NUMBER:
-            ASSURE_SUFFICIENT_BUFFER(sizeof(USHORT));
-            *reinterpret_cast<USHORT*>(pvProperty) = m_pSpec->GetContext()->usBuildNumber;
-            *pcbProperty = sizeof(USHORT);
-            return S_OK;
-
-        case ASM_NAME_REVISION_NUMBER:
-            ASSURE_SUFFICIENT_BUFFER(sizeof(USHORT));
-            *reinterpret_cast<USHORT*>(pvProperty) = m_pSpec->GetContext()->usRevisionNumber;
-            *pcbProperty = sizeof(USHORT);
-            return S_OK;
-
-        case ASM_NAME_CULTURE:
-            if (m_pSpec->GetContext()->szLocale == nullptr)
-            {
-                return FUSION_E_INVALID_NAME;
-            }
-            return PropagateOutStringArgument(m_pSpec->GetContext()->szLocale, (LPWSTR) pvProperty,
-                                              *pcbProperty / sizeof(WCHAR), pcbProperty);
-
-        case ASM_NAME_PUBLIC_KEY_TOKEN:
-            {
-                if (!m_pSpec->HasPublicKeyToken())
-                {
-                    return FUSION_E_INVALID_NAME;
-                }
-
-                PBYTE pbSN;
-                DWORD cbSN;
-                m_pSpec->GetPublicKeyToken(&pbSN, &cbSN);
-                ASSURE_SUFFICIENT_BUFFER(cbSN);
-                memcpy_s(pvProperty, *pcbProperty, pbSN, cbSN);
-                *pcbProperty = cbSN;
-            }
-            return S_OK;
-
-        case ASM_NAME_RETARGET:
-            ASSURE_SUFFICIENT_BUFFER(sizeof(BOOL));
-            *reinterpret_cast<BOOL*>(pvProperty) = m_pSpec->IsRetargetable();
-            *pcbProperty = sizeof(BOOL);
-            return S_OK;
-
-        default:
-            _ASSERTE_MSG(false, "Unexpected property requested.");
-            return E_INVALIDARG;
-        }
-    }
-
-#undef ASSURE_SUFFICIENT_BUFFER
-
-    // Not used by IsAnyFrameworkAssembly
-    STDMETHOD_NOTIMPL(Finalize());
-
-    // Not used by IsAnyFrameworkAssembly
-    STDMETHOD_NOTIMPL(GetDisplayName(
-        __out_ecount_opt(*pccDisplayName) LPOLESTR szDisplayName,
-        __inout LPDWORD pccDisplayName,
-        DWORD dwDisplayFlags));
-
-    // Not used by IsAnyFrameworkAssembly
-    STDMETHOD_NOTIMPL(Reserved(
-        REFIID               refIID,
-        IUnknown            *pUnkReserved1, 
-        IUnknown            *pUnkReserved2,
-        LPCOLESTR            szReserved,
-        LONGLONG             llReserved,
-        LPVOID               pvReserved,
-        DWORD                cbReserved,
-        LPVOID               *ppReserved));
-
-
-    STDMETHOD(GetName)(
-        __inout LPDWORD lpcwBuffer,
-        __out_ecount_opt(*lpcwBuffer) WCHAR *pwzName)
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        VALIDATE_PTR_RET(lpcwBuffer);
-        return PropagateOutStringArgument(
-            m_pSpec->GetName(), pwzName, *lpcwBuffer, lpcwBuffer);
-    }
-        
-    STDMETHOD(GetVersion)(
-        LPDWORD pdwVersionHi,
-        LPDWORD pdwVersionLow)
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        HRESULT     hr = S_OK;
-
-        VALIDATE_PTR_RET(pdwVersionHi);
-        VALIDATE_PTR_RET(pdwVersionLow);
-
-        AssemblyMetaDataInternal * pAMDI = m_pSpec->GetContext();
-        
-        *pdwVersionHi  = MAKELONG(pAMDI->usMinorVersion, pAMDI->usMajorVersion);
-        *pdwVersionLow = MAKELONG(pAMDI->usRevisionNumber, pAMDI->usBuildNumber);
-
-        return S_OK;
-    }
-
-
-    // Exists exclusively to support fusion's IsSystem helper, which compares against 'mscorlib'.
-    STDMETHOD(IsEqual)(
-        IAssemblyName *pName,
-        DWORD dwCmpFlags)
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        HRESULT     hr = S_OK;
-
-        VALIDATE_PTR_RET(pName);
-
-        // This function is here just to support checks against the name 'mscorlib'.
-        if ((dwCmpFlags & ASM_CMPF_NAME) != ASM_CMPF_NAME)
-        {
-            return E_NOTIMPL;
-        }
-
-        DWORD cchName1 = 0;
-        WCHAR wzName1[_MAX_PATH];
-        IfFailRet(pName->GetName(&cchName1, wzName1));
-        _ASSERTE(SString::_wcsicmp(wzName1, W("mscorlib")) == 0);
-
-        WCHAR wzName2[_MAX_PATH];
-        DWORD cchName2 = WszMultiByteToWideChar(
-            CP_UTF8, 0 /*flags*/, m_pSpec->GetName(), -1, wzName2, (int) (sizeof(wzName2) / sizeof(wzName2[0])));
-
-        if (0 == cchName2)
-        {
-            _ASSERTE(HRESULT_FROM_GetLastError() != HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER));
-            return HRESULT_FROM_GetLastError();
-        }
-
-        if (cchName1 != cchName2)
-        {
-            return S_FALSE;
-        }
-
-        return SString::_wcsnicmp(wzName1, wzName2, cchName1) == 0
-             ? S_OK
-             : S_FALSE;
-    }
-        
-    STDMETHOD_NOTIMPL(Clone(
-        IAssemblyName **pName));
-
-private:
-    AssemblySpec * m_pSpec;
-};
-
-//=====================================================================================================================
-HRESULT CLRPrivBinderFusion::FindFusionAssemblyBySpec(
-    LPVOID pvAppDomain,
-    LPVOID pvAssemblySpec,
-    BindingScope kBindingScope,
-    HRESULT * pResult,
-    ICLRPrivAssembly ** ppAssembly)
-{
-    LIMITED_METHOD_CONTRACT;;
-    HRESULT hr = S_OK;
-
-    AppDomain* pAppDomain = reinterpret_cast<AppDomain*>(pvAppDomain);
-    AssemblySpec* pAssemblySpec = reinterpret_cast<AssemblySpec*>(pvAssemblySpec);
-    VALIDATE_PTR_RET(pAppDomain);
-    VALIDATE_PTR_RET(pAssemblySpec);
-    VALIDATE_PTR_RET(pResult);
-    VALIDATE_PTR_RET(ppAssembly);
-    
-    if (pAssemblySpec->IsContentType_WindowsRuntime())
-    {
-        return CLR_E_BIND_UNRECOGNIZED_IDENTITY_FORMAT;
-    }
-
-    BOOL fIsSupportedInAppX;
-    {    
-        AssemblySpecAsIAssemblyName asName(pAssemblySpec);
-
-        if (Fusion::Util::IsAnyFrameworkAssembly(&asName, &fIsSupportedInAppX) != S_OK)
-        {   // Not a framework assembly identity.
-            IfFailRet(CLR_E_BIND_UNRECOGNIZED_IDENTITY_FORMAT);
-        }
-    }
-
-    if (kBindingScope == kBindingScope_FrameworkSubset)
-    {   // We should allow only some framework assemblies to load
-        
-        // DevMode has to allow all FX assemblies, not just a subset - see code:PreBind for more info
-        {
-            // Disabling for now, as it causes too many violations.
-            //CONTRACT_VIOLATION(GCViolation | FaultViolation | ModeViolation);
-            //_ASSERTE(!AppX::IsAppXDesignMode());
-        }
-        
-        if (!fIsSupportedInAppX)
-        {   // Assembly is blocked for AppX, fail the load
-            *pResult = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
-            *ppAssembly = nullptr;
-            return S_OK;
-        }
-    }
-
-    return FindAssemblyBySpec(pvAppDomain, pvAssemblySpec, pResult, ppAssembly);
-}
-
-//=====================================================================================================================
-static
-PEAssembly * FindCachedFile(AppDomain * pDomain, AssemblySpec * pSpec)
-{
-    // Look for cached bind result. Prefer a cached DomainAssembly, as it takes priority over a
-    // cached PEAssembly (which can be different from the one associated with the DomainAssembly).
-    DomainAssembly * pDomainAssembly = pDomain->FindCachedAssembly(pSpec, FALSE);
-    return (pDomainAssembly != nullptr)
-         ? (pDomainAssembly->GetFile())
-         : (pDomain->FindCachedFile(pSpec, FALSE));
-}
-
-//=====================================================================================================================
-// There is no need to create a separate binding record, since we can always just look in the AppDomain's
-// AssemblySpecBindingCache for an answer (which is precisely what this function does).
-
-HRESULT CLRPrivBinderFusion::FindAssemblyBySpec(
-    LPVOID pvAppDomain,
-    LPVOID pvAssemblySpec,
-    HRESULT * pResult,
-    ICLRPrivAssembly ** ppAssembly)
-{
-    LIMITED_METHOD_CONTRACT;;
-    HRESULT hr = S_OK;
-
-    AppDomain* pAppDomain = reinterpret_cast<AppDomain*>(pvAppDomain);
-    AssemblySpec* pAssemblySpec = reinterpret_cast<AssemblySpec*>(pvAssemblySpec);
-    VALIDATE_PTR_RET(pAppDomain);
-    VALIDATE_PTR_RET(pAssemblySpec);
-    VALIDATE_PTR_RET(pResult);
-    VALIDATE_PTR_RET(ppAssembly);
-
-    // For the Architecture property, canonicalize peMSIL to peNone (which are considered equivalent),
-    // to ensure consistent lookups in the AssemblySpecBindingCache for the CLRPrivBinderFusion binder.
-    if (pAssemblySpec->GetPEKIND() == peMSIL)
-    {
-        pAssemblySpec->SetPEKIND(peNone);
-    }
-
-    PEAssembly * pPEAssembly = FindCachedFile(pAppDomain, pAssemblySpec);
-    if (pPEAssembly == nullptr)
-    {
-        return E_FAIL;
-    }
-
-    // Could be racing with another thread that has just added the PEAssembly to the binding cache
-    // but not yet allocated and assigned a host assembly.
-    if (!pPEAssembly->HasHostAssembly())
-    {
-        return E_FAIL;
-    }
-
-    *pResult = S_OK;
-    *ppAssembly = clr::SafeAddRef(pPEAssembly->GetHostAssembly());
-
-    return S_OK;
-}
-
-//=====================================================================================================================
-HRESULT CLRPrivBinderFusion::BindAssemblyByNameWorker(
-    IAssemblyName *     pAssemblyName, 
-    ICLRPrivAssembly ** ppAssembly)
-{
-    STANDARD_VM_CONTRACT;
-    PRECONDITION(CheckPointer(pAssemblyName));
-    PRECONDITION(CheckPointer(ppAssembly));
-
-    HRESULT hr = S_OK;
-
-    AppDomain * pCurDomain = AppDomain::GetCurrentDomain();
-    if (pCurDomain == nullptr)
-        ThrowHR(E_UNEXPECTED);
-
-    AssemblySpec prePolicySpec;
-    AssemblySpec postPolicySpec;
-
-    prePolicySpec.InitializeSpec(pAssemblyName);
-
-    // For the Architecture property, canonicalize peMSIL to peNone (which are considered equivalent),
-    // to ensure consistent lookups in the AssemblySpecBindingCache for the CLRPrivBinderFusion binder.
-    if (prePolicySpec.GetPEKIND() == peMSIL)
-    {
-        prePolicySpec.SetPEKIND(peNone);
-    }
-
-    AssemblySpec * pBindSpec = &prePolicySpec;
-    PEAssemblyHolder pPEAssembly = clr::SafeAddRef(FindCachedFile(pCurDomain, pBindSpec));
-
-    if (pPEAssembly == nullptr)
-    {
-        // Early on in domain setup there may not be a fusion context, so skip ApplyPolicy then.
-        _ASSERTE(pCurDomain->GetFusionContext() != nullptr || prePolicySpec.IsMscorlib());
-        if (pCurDomain->GetFusionContext() != nullptr)
-        {
-            ReleaseHolder<IAssemblyName> pPolicyAssemblyName;
-            DWORD dwPolicyApplied = 0;
-            ApplyPolicy(pAssemblyName, pCurDomain->GetFusionContext(), nullptr, &pPolicyAssemblyName, nullptr, nullptr, &dwPolicyApplied);
-
-            if (dwPolicyApplied != 0)
-            {
-                postPolicySpec.InitializeSpec(pPolicyAssemblyName);
-                pBindSpec = &postPolicySpec;
-                pPEAssembly = clr::SafeAddRef(FindCachedFile(pCurDomain, pBindSpec));
-            }
-        }
-
-        if (pPEAssembly == nullptr)
-        {
-            // Trigger a load.
-            pPEAssembly = pCurDomain->BindAssemblySpec(
-                pBindSpec,  // AssemblySpec
-                TRUE,       // ThrowOnFileNotFound
-                FALSE,      // RaisePrebindEvents
-                nullptr,    // CallerStackMark
-                nullptr,    // AssemblyLoadSecurity
-                FALSE);     // fUseHostBinderIfAvailable - to avoid infinite recursion
-                _ASSERTE(FindCachedFile(pCurDomain, pBindSpec) == pPEAssembly || pBindSpec->IsMscorlib());
-        }
-
-        // If a post-policy spec was used, add the pre-policy spec to the binding cache
-        // so that it can be found by FindAssemblyBySpec.
-        if (&prePolicySpec != pBindSpec)
-        {
-            // Failure to add simply means someone else beat us to it. In that case
-            // the FindCachedFile call below (after catch block) will update result
-            // to the cached value.
-            INDEBUG(BOOL fRes =) pCurDomain->AddFileToCache(&prePolicySpec, pPEAssembly, TRUE /* fAllowFailure */);
-            _ASSERTE(!fRes || prePolicySpec.IsMscorlib() || FindCachedFile(pCurDomain, &prePolicySpec) == pPEAssembly);
-        }
-
-        // Ensure that the assembly is discoverable through a consistent assembly name (the assembly def name of the assembly)
-        AssemblySpec specAssemblyDef;
-        specAssemblyDef.InitializeSpec(pPEAssembly);
-
-        // It is expected that all assemlbies found here will be unified assemblies, and therefore have a public key.
-        _ASSERTE(specAssemblyDef.IsStrongNamed()); 
-
-        // Convert public key into the format that matches the garaunteed cache in the AssemblySpecBindingCache  ... see the extended logic
-        // in Module::GetAssemblyIfLoaded.
-        if (specAssemblyDef.IsStrongNamed() && specAssemblyDef.HasPublicKey())
-        {
-            specAssemblyDef.ConvertPublicKeyToToken();
-        }
-        pCurDomain->AddFileToCache(&specAssemblyDef, pPEAssembly, TRUE);
-    }
-
-    if (!pPEAssembly->HasHostAssembly())
-    {
-        // This can happen if we just loaded the PEAssembly with BindAssemblySpec above, or if the PEAssembly
-        // Was not loaded through this binder. (NGEN Case)
-        
-        // Note: There can be multiple PEAssembly objects for the same file, however we have to create unique 
-        // CLRPrivAssemblyFusion object, otherwise code:AppDomain::FindAssembly will not recognize the duplicates which 
-        // will lead to creation of multiple code:DomainAssembly objects for the same file in the same AppDomain.
-        
-        InlineSString<128> ssPEAssemblyName;
-        FusionBind::GetAssemblyNameDisplayName(pPEAssembly->GetFusionAssemblyName(), ssPEAssemblyName, ASM_DISPLAYF_FULL);
-        NewHolder<CLRPrivAssemblyFusion> pAssemblyObj = new CLRPrivAssemblyFusion(ssPEAssemblyName.GetUnicode(), this);
-        
-        {
-            CrstHolder lock(&m_SetHostAssemblyLock);
-            if (!pPEAssembly->HasHostAssembly())
-            {
-                // Add the host assembly to the PEAssembly.
-                pPEAssembly->SetHostAssembly(pAssemblyObj.Extract());
-            }
-        }
-    }
-
-    // Trigger a load so that a DomainAssembly is associated with the ICLRPrivAssembly created above.
-    pPEAssembly = clr::SafeAddRef(pCurDomain->LoadDomainAssembly(pBindSpec, pPEAssembly, FILE_LOADED)->GetFile());
-
-    _ASSERTE(pPEAssembly != nullptr);
-    _ASSERTE(pPEAssembly->HasHostAssembly());
-    _ASSERTE(pCurDomain->FindAssembly(pPEAssembly->GetHostAssembly()) != nullptr);
-
-    fusion::logging::LogMessage(0, ID_FUSLOG_BINDING_STATUS_FOUND, pPEAssembly->GetPath().GetUnicode());
-
-    *ppAssembly = clr::SafeAddRef(pPEAssembly->GetHostAssembly());
-
-    return hr;
-}
-
-//=====================================================================================================================
-void CLRPrivBinderFusion::BindMscorlib(
-    PEAssembly * pPEAssembly)
-{
-    STANDARD_VM_CONTRACT;
-    
-#ifdef _DEBUG
-    NewArrayHolder<WCHAR> dbg_wszAssemblySimpleName;
-    _ASSERTE(SUCCEEDED(fusion::util::GetProperty(pPEAssembly->GetFusionAssemblyName(), ASM_NAME_NAME, &dbg_wszAssemblySimpleName)));
-    
-    _ASSERTE(wcscmp(dbg_wszAssemblySimpleName, W("mscorlib")) == 0);
-#endif //_DEBUG
-    
-    NewHolder<CLRPrivAssemblyFusion> pPrivAssembly = new CLRPrivAssemblyFusion(W("mscorlib"), this);
-   
-    pPEAssembly->SetHostAssembly(pPrivAssembly.Extract());
-}
-
-//=====================================================================================================================
-HRESULT CLRPrivBinderFusion::BindFusionAssemblyByName(
-    IAssemblyName *     pAssemblyName, 
-    BindingScope        kBindingScope, 
-    ICLRPrivAssembly ** ppAssembly)
-{
-    STANDARD_VM_CONTRACT;
-    HRESULT hr = S_OK;
-    
-    fusion::logging::StatusScope logStatus(0, ID_FUSLOG_BINDING_STATUS_FRAMEWORK, &hr);
-    
-    DWORD dwContentType = AssemblyContentType_Default;
-    IfFailRet(fusion::util::GetProperty(pAssemblyName, ASM_NAME_CONTENT_TYPE, &dwContentType));
-    if ((hr == S_OK) && (dwContentType != AssemblyContentType_Default))
-    {   // Not a NetFX content type.
-        IfFailRet(CLR_E_BIND_UNRECOGNIZED_IDENTITY_FORMAT);
-    }
-    
-    BOOL fIsSupportedInAppX;
-    if (Fusion::Util::IsAnyFrameworkAssembly(pAssemblyName, &fIsSupportedInAppX) != S_OK)
-    {   // Not a framework assembly identity.
-        IfFailRet(CLR_E_BIND_UNRECOGNIZED_IDENTITY_FORMAT);
-    }
-    if (kBindingScope == kBindingScope_FrameworkSubset)
-    {   // We should allow only some framework assemblies to load
-        
-        // DevMode has to allow all FX assemblies, not just a subset - see code:PreBind for more info
-        _ASSERTE(!AppX::IsAppXDesignMode());
-        
-        if (!fIsSupportedInAppX)
-        {   // Assembly is blocked for AppX, fail the load
-            fusion::logging::LogMessage(0, ID_FUSLOG_BINDING_STATUS_FX_ASSEMBLY_BLOCKED);
-            
-            IfFailRet(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND));
-        }
-    }
-    
-    return (hr = BindAssemblyByNameWorker(pAssemblyName, ppAssembly));
-}
-
-//=====================================================================================================================
-// Implements code:ICLRPrivBinder::BindAssemblyByName
-HRESULT CLRPrivBinderFusion::BindAssemblyByName(
-    IAssemblyName * pAssemblyName,
-    ICLRPrivAssembly ** ppAssembly)
-{
-    WRAPPER_NO_CONTRACT;
-    return BindAssemblyByNameWorker(
-        pAssemblyName, 
-        ppAssembly);
-}
-
-//=====================================================================================================================
-// Implements code:ICLRPrivBinder::GetBinderID
-HRESULT CLRPrivBinderFusion::GetBinderID(
-    UINT_PTR *pBinderId)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    *pBinderId = (UINT_PTR)this;
-    return S_OK;
-}
-
-//=====================================================================================================================
-// Implements code:IBindContext::PreBind
-HRESULT CLRPrivBinderFusion::PreBind(
-    IAssemblyName * pIAssemblyName,
-    DWORD           dwPreBindFlags,
-    IBindResult **  ppIBindResult)
-{
-    STANDARD_BIND_CONTRACT;
-    PRECONDITION(CheckPointer(pIAssemblyName));
-    PRECONDITION(CheckPointer(ppIBindResult));
-    
-    HRESULT hr = S_OK;
-    
-    BOOL fIsSupportedInAppX;
-    if (Fusion::Util::IsAnyFrameworkAssembly(pIAssemblyName, &fIsSupportedInAppX) != S_OK)
-    {   // Not a framework assembly identity.
-        return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
-    }
-    
-    EX_TRY
-    {
-        // Create new IL binding scope.
-        fusion::logging::BindingScope defaultScope(pIAssemblyName, FUSION_BIND_LOG_CATEGORY_DEFAULT);
-        
-        // Ideally the caller would give us arg kBindingContext like in code:BindFusionAssemblyByName, so we can give the same answer.
-        // That is not easy, so we will make the decision here:
-        //   - DevMode will allow all FX assemblies (that covers designer binding context scenario for designers that need to 
-        //      load WPF with ngen images for perf reasons).
-        //      We know that the real bind via code:BindFusionAssemblyByName will succeed for the assemblies (because we are in DevMode).
-        //   - Normal mode (non-DevMode) we will allow only subset of FX assemblies.
-        //      It implies that designer binding context (used by debuggers) will not use ngen images for blocked FX assemblies 
-        //      (transitively). That is acceptable performance trade-off.
-        if (!AppX::IsAppXDesignMode())
-        {   // We should allow only some framework assemblies to load
-            if (!fIsSupportedInAppX)
-            {   // Assembly is blocked for AppX, fail the load
-                fusion::logging::LogMessage(0, ID_FUSLOG_BINDING_STATUS_FX_ASSEMBLY_BLOCKED);
-                
-                hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
-            }
-        }
-        
-        if (SUCCEEDED(hr))
-        {
-            AppDomain * pDomain = AppDomain::GetCurrentDomain();
-            ReleaseHolder<IBindContext> pIBindContext;
-            if (SUCCEEDED(hr = GetBindContextFromApplicationContext(pDomain->CreateFusionContext(), &pIBindContext)))
-            {
-                hr = pIBindContext->PreBind(pIAssemblyName, dwPreBindFlags, ppIBindResult);
-            }
-        }
-    }
-    EX_CATCH_HRESULT(hr);
-    
-    return hr;
-}
-
-//=====================================================================================================================
-HRESULT CLRPrivBinderFusion::PreBindFusionAssemblyByName(
-    IAssemblyName  *pIAssemblyName,
-    DWORD           dwPreBindFlags,
-    IBindResult   **ppIBindResult)
-{
-    STANDARD_VM_CONTRACT;
-    HRESULT hr = S_OK;
-
-    DWORD dwContentType = AssemblyContentType_Default;
-    IfFailRet(fusion::util::GetProperty(pIAssemblyName, ASM_NAME_CONTENT_TYPE, &dwContentType));
-    if ((hr == S_OK) && (dwContentType != AssemblyContentType_Default))
-    {   // Not a NetFX content type.
-        IfFailRet(CLR_E_BIND_UNRECOGNIZED_IDENTITY_FORMAT);
-    }
-
-    IfFailRet(PreBind(pIAssemblyName, dwPreBindFlags, ppIBindResult));
-    _ASSERTE(*ppIBindResult != nullptr);
-
-    if (*ppIBindResult == nullptr)
-        IfFailRet(E_UNEXPECTED);
-
-    return S_OK;
-}
-
-//=====================================================================================================================
-// Implements code:IBindContext::IsDefaultContext
-HRESULT CLRPrivBinderFusion::IsDefaultContext()
-{
-    STANDARD_BIND_CONTRACT;
-    return S_OK;
-}
-
-//=====================================================================================================================
-CLRPrivBinderFusion::~CLRPrivBinderFusion()
-{
-    WRAPPER_NO_CONTRACT;
-}
-
-//=====================================================================================================================
-CLRPrivAssemblyFusion::CLRPrivAssemblyFusion(
-    LPCWSTR               wszName, 
-    CLRPrivBinderFusion * pBinder)
-    : m_pBinder(clr::SafeAddRef(pBinder)), 
-    m_wszName(DuplicateStringThrowing(wszName))
-{
-    STANDARD_VM_CONTRACT;
-}
-
-//=====================================================================================================================
-LPCWSTR CLRPrivAssemblyFusion::GetName() const
-{
-    LIMITED_METHOD_CONTRACT;
-    
-    return m_wszName;
-}
-
-//=====================================================================================================================
-// Implements code:IUnknown::Release
-ULONG CLRPrivAssemblyFusion::Release()
-{
-    LIMITED_METHOD_CONTRACT;
-    STATIC_CONTRACT_CAN_TAKE_LOCK;
-    _ASSERTE(m_cRef > 0);
-    
-    ULONG cRef = InterlockedDecrement(&m_cRef);
-
-    if (cRef == 0)
-    {
-        delete this;
-    }
-
-    return cRef;
-}
-
-//=====================================================================================================================
-// Implements code:ICLRPrivBinder::BindAssemblyByName
-HRESULT CLRPrivAssemblyFusion::BindAssemblyByName(
-    IAssemblyName * pAssemblyName,
-    ICLRPrivAssembly ** ppAssembly)
-{
-    WRAPPER_NO_CONTRACT;
-    return m_pBinder->BindAssemblyByName(
-        pAssemblyName, 
-        ppAssembly);
-}
-
-//=====================================================================================================================
-// Implements code:ICLRPrivBinder::GetBinderID
-HRESULT CLRPrivAssemblyFusion::GetBinderID(
-    UINT_PTR *pBinderId)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    *pBinderId = reinterpret_cast<UINT_PTR>(m_pBinder.GetValue());
-    return S_OK;
-}
-
-//=====================================================================================================================
-// Implements code:ICLRPrivAssembly::IsShareable
-HRESULT CLRPrivAssemblyFusion::IsShareable(
-    BOOL * pbIsShareable)
-{
-    LIMITED_METHOD_CONTRACT;
-    *pbIsShareable = TRUE; // These things are only used in the AppX scenario, where all fusion assemblies are unified, shareable assemblies.
-    return S_OK;
-}
-
-//=====================================================================================================================
-// Implements code:ICLRPrivAssembly::GetAvailableImageTypes
-HRESULT CLRPrivAssemblyFusion::GetAvailableImageTypes(
-    LPDWORD pdwImageTypes)
-{
-    LIMITED_METHOD_CONTRACT;
-    _ASSERTE(!"CLRPrivAssemblyFusion::GetAvailableImageTypes");
-    return E_NOTIMPL;
-}    
-
-//=====================================================================================================================
-// Implements code:ICLRPrivAssembly::GetImageResource
-HRESULT CLRPrivAssemblyFusion::GetImageResource(
-    DWORD dwImageType,
-    DWORD *pdwImageType,
-    ICLRPrivResource ** ppIResource)
-{
-    LIMITED_METHOD_CONTRACT;
-    _ASSERTE(!"CLRPrivAssemblyFusion::GetImageResource");
-    return E_NOTIMPL;
-}
-
-#endif // !DACCESS_COMPILE
-
diff --git a/src/vm/clrprivbinderfusion.h b/src/vm/clrprivbinderfusion.h
deleted file mode 100644
index 3cf3694e4f..0000000000
--- a/src/vm/clrprivbinderfusion.h
+++ /dev/null
@@ -1,228 +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.
-
-
-
-#pragma once
-
-#include "holder.h"
-#include "internalunknownimpl.h"
-#include "shash.h"
-#include "clrprivbinding.h"
-#include "clrprivruntimebinders.h"
-
-//=====================================================================================================================
-// Forward declarations
-class CLRPrivBinderFusion;
-class CLRPrivAssemblyFusion;
-
-class PEAssembly;
-class DomainAssembly;
-struct IMDInternalImport;
-
-//=====================================================================================================================
-class CLRPrivBinderFusion :
-    public IUnknownCommon<ICLRPrivBinder, IBindContext>
-{
-    friend class CLRPrivAssemblyFusion;
-    
-public:
-    // Scope for the bind operation
-    enum BindingScope
-    {
-        // Binds only to subset of framework that is not on the black list (non-FX assemblies bindings are rejected)
-        kBindingScope_FrameworkSubset, 
-        // Binds to all framework assemblies (incl. those on the black list) (non-FX assemblies bindings are rejected)
-        // Used by designer binding context and in DevMode
-        kBindingScope_FrameworkAll
-    };
-    
-public:
-    //=============================================================================================
-    // ICLRPrivBinder methods
-
-    //---------------------------------------------------------------------------------------------
-    // Implements code:ICLRPrivBinder::BindAssemblyByName
-    STDMETHOD(BindAssemblyByName(
-        IAssemblyName * pAssemblyName,
-        ICLRPrivAssembly ** ppAssembly));
-
-    //---------------------------------------------------------------------------------------------
-    // Implements code:ICLRPrivBinder::VerifyBind
-    STDMETHOD(VerifyBind)(
-        IAssemblyName *pAssemblyName,
-        ICLRPrivAssembly *pAssembly,
-        ICLRPrivAssemblyInfo *pAssemblyInfo)
-    {
-        LIMITED_METHOD_CONTRACT;
-        if (pAssemblyName == nullptr || pAssembly == nullptr || pAssemblyInfo == nullptr)
-            return E_INVALIDARG;
-        return S_OK;
-    }
-
-    //---------------------------------------------------------------------------------------------
-    // Implements code:ICLRPrivBinder::GetBinderFlags
-    STDMETHOD(GetBinderFlags)(
-        DWORD *pBinderFlags)
-    {
-        LIMITED_METHOD_CONTRACT;
-        *pBinderFlags = BINDER_FINDASSEMBLYBYSPEC_REQUIRES_EXACT_MATCH;
-        return S_OK;
-    }
-
-    //---------------------------------------------------------------------------------------------
-    // Implements code:ICLRPrivBinder::GetBinderID
-    STDMETHOD(GetBinderID)(
-        UINT_PTR *pBinderId);
-
-    STDMETHOD(FindAssemblyBySpec)(
-        LPVOID pvAppDomain,
-        LPVOID pvAssemblySpec,
-        HRESULT * pResult,
-        ICLRPrivAssembly ** ppAssembly);
-
-    //=============================================================================================
-    // IBindContext methods
-
-    // Implements code:IBindContext::PreBind
-    STDMETHOD(PreBind)(
-        IAssemblyName  *pIAssemblyName,
-        DWORD           dwPreBindFlags,
-        IBindResult   **ppIBindResult);
-
-    // Implements code:IBindContext::IsDefaultContext
-    STDMETHOD(IsDefaultContext)();
-
-    //=============================================================================================
-    // Class methods
-
-    //---------------------------------------------------------------------------------------------
-    CLRPrivBinderFusion()
-        : m_SetHostAssemblyLock(CrstLeafLock)
-    { STANDARD_VM_CONTRACT; }
-    
-    //---------------------------------------------------------------------------------------------
-    ~CLRPrivBinderFusion();
-
-    //---------------------------------------------------------------------------------------------
-    HRESULT FindFusionAssemblyBySpec(
-        LPVOID pvAppDomain,
-        LPVOID pvAssemblySpec,
-        BindingScope kBindingScope,
-        HRESULT * pResult,
-        ICLRPrivAssembly ** ppAssembly);
-
-    //---------------------------------------------------------------------------------------------
-    HRESULT BindFusionAssemblyByName(
-        IAssemblyName *     pAssemblyName, 
-        BindingScope        kBindingScope, 
-        ICLRPrivAssembly ** ppAssembly);
-
-    //---------------------------------------------------------------------------------------------
-    HRESULT PreBindFusionAssemblyByName(
-        IAssemblyName * pIAssemblyName,
-        DWORD           dwPreBindFlags,
-        IBindResult **  ppIBindResult);
-    
-    //---------------------------------------------------------------------------------------------
-    // Binds mscorlib.dll
-    void BindMscorlib(
-        PEAssembly * pPEAssembly);
-    
-private:
-    //---------------------------------------------------------------------------------------------
-    HRESULT BindAssemblyByNameWorker(
-        IAssemblyName *     pAssemblyName, 
-        ICLRPrivAssembly ** ppAssembly);
-    
-private:
-    //---------------------------------------------------------------------------------------------
-    // This lock is used to serialize assigning ICLRPrivAssembly instances to PEAssembly objects.
-    Crst              m_SetHostAssemblyLock;
-
-};  // class CLRPrivBinderFusion
-
-//=====================================================================================================================
-class CLRPrivAssemblyFusion :
-    public IUnknownCommon<ICLRPrivAssembly>
-{
-public:
-    //---------------------------------------------------------------------------------------------
-    CLRPrivAssemblyFusion(
-        LPCWSTR               wszName, 
-        CLRPrivBinderFusion * pBinder);
-    
-    //---------------------------------------------------------------------------------------------
-    LPCWSTR GetName() const;
-    
-    //---------------------------------------------------------------------------------------------
-    // Implements code:IUnknown::Release
-    STDMETHOD_(ULONG, Release)();
-    
-    //---------------------------------------------------------------------------------------------
-    // Implements code:ICLRPrivBinder::BindAssemblyByName
-    STDMETHOD(BindAssemblyByName)(
-        IAssemblyName * pAssemblyName,
-        ICLRPrivAssembly ** ppAssembly);
-
-    //---------------------------------------------------------------------------------------------
-    // Implements code:ICLRPrivAssembly::IsShareable
-    STDMETHOD(IsShareable)(
-        BOOL * pbIsShareable);
-
-    //---------------------------------------------------------------------------------------------
-    // Implements code:ICLRPrivAssembly::GetAvailableImageTypes
-    STDMETHOD(GetAvailableImageTypes)(
-        LPDWORD pdwImageTypes);
-
-    //---------------------------------------------------------------------------------------------
-    // Implements code:ICLRPrivAssembly::GetImageResource
-    STDMETHOD(GetImageResource)(
-        DWORD dwImageType,
-        DWORD *pdwImageType,
-        ICLRPrivResource ** ppIResource);
-
-    //---------------------------------------------------------------------------------------------
-    // Implements code:ICLRPrivBinder::VerifyBind
-    STDMETHOD(VerifyBind)(
-        IAssemblyName *pAssemblyName,
-        ICLRPrivAssembly *pAssembly,
-        ICLRPrivAssemblyInfo *pAssemblyInfo)
-    {
-        WRAPPER_NO_CONTRACT;
-        return m_pBinder->VerifyBind(pAssemblyName, pAssembly, pAssemblyInfo);
-    }
-
-    //---------------------------------------------------------------------------------------------
-    // Implements code:ICLRPrivBinder::GetBinderFlags
-    STDMETHOD(GetBinderFlags)(
-        DWORD *pBinderFlags)
-    {
-        LIMITED_METHOD_CONTRACT;
-        return m_pBinder->GetBinderFlags(pBinderFlags);
-    }
-
-    //---------------------------------------------------------------------------------------------
-    // Implements code:ICLRPrivBinder::GetBinderID
-    STDMETHOD(GetBinderID)(
-        UINT_PTR *pBinderId);
-
-    //---------------------------------------------------------------------------------------------
-    // Implements code:ICLRPrivBinder::FindAssemblyBySpec
-    STDMETHOD(FindAssemblyBySpec)(
-        LPVOID pvAppDomain,
-        LPVOID pvAssemblySpec,
-        HRESULT * pResult,
-        ICLRPrivAssembly ** ppAssembly)
-    { STATIC_CONTRACT_WRAPPER; return m_pBinder->FindAssemblyBySpec(pvAppDomain, pvAssemblySpec, pResult, ppAssembly); }
-
-protected:
-    //---------------------------------------------------------------------------------------------
-    // The fusion binder. Need to keep it around as long as this object is around.
-    ReleaseHolder<CLRPrivBinderFusion> m_pBinder;
-    
-    // Full display name of the assembly - used to avoid duplicate CLRPrivAssemblyFusion objects
-    NewArrayHolder<WCHAR> m_wszName;
-    
-};  // class CLRPrivAssemblyFusion
diff --git a/src/vm/clrprivbinderloadfile.cpp b/src/vm/clrprivbinderloadfile.cpp
deleted file mode 100644
index 20d05688f9..0000000000
--- a/src/vm/clrprivbinderloadfile.cpp
+++ /dev/null
@@ -1,264 +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.
-
-
-
-#include "common.h" // precompiled header
-#include "clrprivbinderutil.h"
-#include "clrprivbinderloadfile.h"
-#include "clrprivbinderfusion.h"
-#include "clrprivbinderappx.h"
-#include "fusionlogging.h"
-
-using namespace CLRPrivBinderUtil;
-
-#ifndef DACCESS_COMPILE
-
-using namespace CLRPrivBinderUtil;
-using clr::SafeAddRef;
-using clr::SafeRelease;
-
-//=====================================================================================================================
-CLRPrivBinderLoadFile * CLRPrivBinderLoadFile::s_pSingleton = nullptr;
-
-
-//=====================================================================================================================
-CLRPrivBinderLoadFile * CLRPrivBinderLoadFile::GetOrCreateBinder()
-{
-    STANDARD_VM_CONTRACT;
-    HRESULT hr = S_OK;
-
-    if (s_pSingleton == nullptr)
-    {
-        ReleaseHolder<CLRPrivBinderLoadFile> pBinder = SafeAddRef(new CLRPrivBinderLoadFile());
-        
-        CLRPrivBinderAppX *   pAppXBinder = CLRPrivBinderAppX::GetOrCreateBinder();
-        CLRPrivBinderFusion * pFusionBinder = pAppXBinder->GetFusionBinder();
-        
-        pBinder->m_pFrameworkBinder = SafeAddRef(pFusionBinder);
-        _ASSERTE(pBinder->m_pFrameworkBinder != nullptr);
-        
-        if (InterlockedCompareExchangeT<decltype(s_pSingleton)>(&s_pSingleton, pBinder, nullptr) == nullptr)
-            pBinder.SuppressRelease();
-    }
-    
-    return s_pSingleton;
-}
-
-//=====================================================================================================================
-CLRPrivBinderLoadFile::CLRPrivBinderLoadFile()
-{
-    STANDARD_VM_CONTRACT;
-}
-
-//=====================================================================================================================
-CLRPrivBinderLoadFile::~CLRPrivBinderLoadFile()
-{
-    WRAPPER_NO_CONTRACT;
-}
-
-//=====================================================================================================================
-STDMETHODIMP CLRPrivBinderLoadFile::BindAssemblyExplicit(
-        PEImage* pImage,
-        IAssemblyName **ppAssemblyName,
-        ICLRPrivAssembly ** ppAssembly)
-{
-    STANDARD_BIND_CONTRACT;
-    PRECONDITION(AppDomain::GetCurrentDomain()->IsDefaultDomain());
-    VALIDATE_ARG_RET(pImage != nullptr);
-    VALIDATE_ARG_RET(ppAssemblyName != nullptr);
-    VALIDATE_ARG_RET(ppAssembly != nullptr);
-
-    HRESULT hr = S_OK;
-
-    fusion::logging::StatusScope logStatus(0, ID_FUSLOG_BINDING_STATUS_LOAD_FILE, &hr);
-
-    ReleaseHolder<IAssemblyName> pAssemblyName;
-    ReleaseHolder<ICLRPrivAssembly> pAssembly;
-
-    EX_TRY
-    {
-        // check if a framework assembly
-        {
-            AssemblySpec spec;
-            mdAssembly a;
-            IfFailThrow(pImage->GetMDImport()->GetAssemblyFromScope(&a));
-            spec.InitializeSpec(a, pImage->GetMDImport(), NULL, false);
-            IfFailThrow(spec.CreateFusionName(&pAssemblyName));
-        }
-
-        hr = IfTransientFailThrow(m_pFrameworkBinder->BindFusionAssemblyByName(
-                pAssemblyName, 
-                CLRPrivBinderFusion::kBindingScope_FrameworkSubset, 
-                &pAssembly));
-        if (FAILED(hr)) // not a Framework assembly
-        {
-            ReleaseHolder<CLRPrivResourcePathImpl> pPathResource =
-                clr::SafeAddRef(new CLRPrivResourcePathImpl(pImage->GetPath().GetUnicode()));
-            pAssembly = clr::SafeAddRef(new CLRPrivAssemblyLoadFile(this, m_pFrameworkBinder, pPathResource));
-
-            hr = S_OK;
-        }
-    }
-    EX_CATCH_HRESULT(hr);
-
-    if (SUCCEEDED(hr))
-    {
-        *ppAssemblyName = pAssemblyName.Extract();
-        *ppAssembly = pAssembly.Extract();
-    }
-
-    return hr;
-};
-
-//=====================================================================================================================
-STDMETHODIMP CLRPrivBinderLoadFile::BindAssemblyByName(
-    IAssemblyName * pAssemblyName,
-    ICLRPrivAssembly ** ppAssembly)
-{
-    WRAPPER_NO_CONTRACT;
-    _ASSERTE(!"No parentless binds are allowed in NEITHER context");
-    return E_NOTIMPL;
-};
-
-//=====================================================================================================================
-STDMETHODIMP CLRPrivBinderLoadFile::VerifyBind(
-    IAssemblyName *pAssemblyName,
-    ICLRPrivAssembly *pAssembly,
-    ICLRPrivAssemblyInfo *pAssemblyInfo)
-{
-    WRAPPER_NO_CONTRACT;
-    // TODO: move ublic Key verification here, once we are willing to fully convert to hosted model
-    _ASSERTE(!"CLRPrivAssemblyLoadFile::VerifyBind");
-    return E_NOTIMPL; // we don't care about anything here...
-};
-
-//=====================================================================================================================
-HRESULT CLRPrivBinderLoadFile::GetBinderID(
-    UINT_PTR *pBinderId)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    *pBinderId = (UINT_PTR)this;
-    return S_OK;
-}
-
-//==========================================================================
-CLRPrivAssemblyLoadFile::CLRPrivAssemblyLoadFile(
-    CLRPrivBinderLoadFile* pBinder,
-    CLRPrivBinderFusion* pFrameworkBinder,
-    CLRPrivBinderUtil::CLRPrivResourcePathImpl* pPathResource)
-    : m_pBinder(SafeAddRef(pBinder))
-    , m_pFrameworkBinder(SafeAddRef(pFrameworkBinder))
-    , m_pPathResource(SafeAddRef(pPathResource))
-{
-    STANDARD_VM_CONTRACT;
-    VALIDATE_ARG_THROW(pBinder != nullptr);
-    VALIDATE_ARG_THROW(pFrameworkBinder != nullptr);
-    VALIDATE_ARG_THROW(pPathResource != nullptr);
-}
-
-//=====================================================================================================================
-STDMETHODIMP CLRPrivAssemblyLoadFile::BindAssemblyByName(
-    IAssemblyName * pAssemblyName,
-    ICLRPrivAssembly ** ppAssembly)
-{
-    STANDARD_BIND_CONTRACT;
-    HRESULT hr = S_OK;
-
-    EX_TRY
-    {
-        hr = m_pFrameworkBinder->BindFusionAssemblyByName(
-                pAssemblyName, 
-                CLRPrivBinderFusion::kBindingScope_FrameworkSubset, 
-                ppAssembly);
-        if (FAILED(hr) && !Exception::IsTransient(hr)) // not a Framework assembly
-        {
-            *ppAssembly = RaiseAssemblyResolveEvent(pAssemblyName, this);
-            if (*ppAssembly == NULL)
-            {
-                hr = COR_E_FILENOTFOUND;
-            }
-            else
-            {
-                (*ppAssembly)->AddRef();
-                hr = S_OK;
-            }
-        }
-    }
-    EX_CATCH_HRESULT(hr);
-
-    return hr;
-};
-
-//=====================================================================================================================
-HRESULT CLRPrivAssemblyLoadFile::GetBinderID(
-    UINT_PTR *pBinderId)
-{
-    LIMITED_METHOD_CONTRACT;
-    return m_pBinder->GetBinderID(pBinderId);
-}
-
-//=====================================================================================================================
-STDMETHODIMP CLRPrivAssemblyLoadFile::VerifyBind(
-    IAssemblyName *pAssemblyName,
-    ICLRPrivAssembly *pAssembly,
-    ICLRPrivAssemblyInfo *pAssemblyInfo)
-{
-    STANDARD_BIND_CONTRACT;
-    return S_OK;
-};
-
-//=====================================================================================================================
-HRESULT CLRPrivAssemblyLoadFile::IsShareable(
-    BOOL * pbIsShareable)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    VALIDATE_ARG_RET(pbIsShareable != nullptr);
-
-    *pbIsShareable = FALSE;   // no sharing for loadfile
-    return S_OK;
-}
-
-//=====================================================================================================================
-HRESULT CLRPrivAssemblyLoadFile::GetAvailableImageTypes(
-    LPDWORD pdwImageTypes)
-{
-    LIMITED_METHOD_CONTRACT;
-    VALIDATE_ARG_RET(pdwImageTypes != nullptr);
-    PRECONDITION(m_pPathResource != nullptr);
-
-    *pdwImageTypes = ASSEMBLY_IMAGE_TYPE_IL;
-
-    return S_OK;
-}
-
-
-//=====================================================================================================================
-HRESULT CLRPrivAssemblyLoadFile::GetImageResource(
-    DWORD dwImageType,
-    DWORD *pdwImageType,
-    ICLRPrivResource ** ppIResource)
-{
-    LIMITED_METHOD_CONTRACT;
-    VALIDATE_ARG_RET(pdwImageType != nullptr);
-    VALIDATE_ARG_RET(ppIResource != nullptr);
-
-    *ppIResource = nullptr;
-
-    HRESULT hr = S_OK;
-    if ((dwImageType & ASSEMBLY_IMAGE_TYPE_NATIVE) == ASSEMBLY_IMAGE_TYPE_NATIVE)
-    {
-        return CLR_E_BIND_IMAGE_UNAVAILABLE;
-    }
-
-    *pdwImageType = ASSEMBLY_IMAGE_TYPE_IL;
-    *ppIResource = clr::SafeAddRef(m_pPathResource);
-
-    return S_OK;
-}
-
-#endif // !DACCESS_COMPILE
-
diff --git a/src/vm/clrprivbinderreflectiononlywinrt.cpp b/src/vm/clrprivbinderreflectiononlywinrt.cpp
deleted file mode 100644
index ad46511e81..0000000000
--- a/src/vm/clrprivbinderreflectiononlywinrt.cpp
+++ /dev/null
@@ -1,497 +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.
-// 
-
-// 
-// Contains the types that implement code:ICLRPrivBinder and code:ICLRPrivAssembly for WinRT ReflectionOnly (aka introspection) binding.
-// 
-//=====================================================================================================================
-
-#include "common.h" // precompiled header
-
-#ifndef DACCESS_COMPILE
-#ifdef FEATURE_REFLECTION_ONLY_LOAD
-
-//=====================================================================================================================
-#include "sstring.h"
-#include "policy.h"
-#include "clrprivbinderreflectiononlywinrt.h"
-#include "appxutil.h"
-#include "clrprivbinderutil.h"
-#include "imprthelpers.h" // in fusion/inc
-
-#include <winstring.h>
-#include <typeresolution.h>
-
-using namespace CLRPrivBinderUtil;
-
-//=====================================================================================================================
-
-//=====================================================================================================================
-CLRPrivBinderReflectionOnlyWinRT::CLRPrivBinderReflectionOnlyWinRT(
-    CLRPrivTypeCacheReflectionOnlyWinRT * pTypeCache)
-    : m_MapsLock(CrstLeafLock, CRST_REENTRANCY) // Reentracy is needed for code:CLRPrivAssemblyReflectionOnlyWinRT::Release
-{
-    STANDARD_VM_CONTRACT;
-    
-    // This binder is not supported in AppX scenario.
-    _ASSERTE(!AppX::IsAppXProcess());
-    
-    _ASSERTE(pTypeCache != nullptr);
-    m_pTypeCache = clr::SafeAddRef(pTypeCache);
-}
-
-//=====================================================================================================================
-CLRPrivBinderReflectionOnlyWinRT::~CLRPrivBinderReflectionOnlyWinRT()
-{
-    WRAPPER_NO_CONTRACT;
-    
-    if (m_pTypeCache != nullptr)
-    {
-        m_pTypeCache->Release();
-    }
-}
-
-//=====================================================================================================================
-HRESULT 
-CLRPrivBinderReflectionOnlyWinRT::BindWinRtType_Internal(
-    LPCSTR                                szTypeNamespace, 
-    LPCSTR                                szTypeClassName, 
-    DomainAssembly *                      pParentAssembly, 
-    CLRPrivAssemblyReflectionOnlyWinRT ** ppAssembly)
-{
-    STANDARD_VM_CONTRACT;
-    
-    HRESULT hr = S_OK;
-    
-    VALIDATE_ARG_RET(ppAssembly != nullptr);
-    
-    CLRPrivBinderUtil::WStringList * pFileNameList = nullptr;
-    
-    StackSString ssTypeNamespace(SString::Utf8, szTypeNamespace);
-    
-    GetFileNameListForNamespace(ssTypeNamespace.GetUnicode(), pParentAssembly, &pFileNameList);
-    
-    if (pFileNameList == nullptr)
-    {   // There are no files associated with the namespace
-        return CLR_E_BIND_TYPE_NOT_FOUND;
-    }
-    
-    StackSString ssTypeName(ssTypeNamespace);
-    ssTypeName.Append(W('.'));
-    ssTypeName.AppendUTF8(szTypeClassName);
-    
-    CLRPrivBinderUtil::WStringListElem * pFileNameElem = pFileNameList->GetHead();
-    while (pFileNameElem != nullptr)
-    {
-        const WCHAR * wszFileName = pFileNameElem->GetValue();
-        ReleaseHolder<CLRPrivAssemblyReflectionOnlyWinRT> pAssembly = FindOrCreateAssemblyByFileName(wszFileName);
-        _ASSERTE(pAssembly != NULL);
-        
-        IfFailRet(hr = m_pTypeCache->ContainsType(pAssembly, ssTypeName.GetUnicode()));
-        if (hr == S_OK)
-        {   // The type we are looking for has been found in this assembly
-            *ppAssembly = pAssembly.Extract();
-            return S_OK;
-        }
-        _ASSERTE(hr == S_FALSE);
-        
-        // Try next file name for this namespace
-        pFileNameElem = CLRPrivBinderUtil::WStringList::GetNext(pFileNameElem);
-    }
-    
-    // The type has not been found in any of the files from the type's namespace
-    return CLR_E_BIND_TYPE_NOT_FOUND;
-} // CLRPrivBinderReflectionOnlyWinRT::BindWinRtType_Internal
-
-//=====================================================================================================================
-HRESULT 
-CLRPrivBinderReflectionOnlyWinRT::BindWinRtType(
-    LPCSTR              szTypeNamespace, 
-    LPCSTR              szTypeClassName, 
-    DomainAssembly *    pParentAssembly, 
-    ICLRPrivAssembly ** ppPrivAssembly)
-{
-    STANDARD_VM_CONTRACT;
-    
-    HRESULT hr = S_OK;
-    
-    ReleaseHolder<CLRPrivAssemblyReflectionOnlyWinRT> pWinRTAssembly;
-    IfFailRet(BindWinRtType_Internal(szTypeNamespace, szTypeClassName, pParentAssembly, &pWinRTAssembly));
-    IfFailRet(pWinRTAssembly->QueryInterface(__uuidof(ICLRPrivAssembly), (LPVOID *)ppPrivAssembly));
-    
-    return hr;
-}
-
-//=====================================================================================================================
-// Implements interface method code:ICLRPrivBinder::BindAssemblyByName.
-// 
-HRESULT CLRPrivBinderReflectionOnlyWinRT::BindAssemblyByName(
-    IAssemblyName     * pAssemblyName, 
-    ICLRPrivAssembly ** ppAssembly)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    _ASSERTE_MSG(false, "Unexpected call to CLRPrivBinderReflectionOnlyWinRT::BindAssemblyByName");
-    return E_UNEXPECTED;
-}
-
-//=====================================================================================================================
-ReleaseHolder<CLRPrivAssemblyReflectionOnlyWinRT> 
-CLRPrivBinderReflectionOnlyWinRT::FindAssemblyByFileName(
-    LPCWSTR wszFileName)
-{
-    LIMITED_METHOD_CONTRACT;
-    STATIC_CONTRACT_CAN_TAKE_LOCK;
-    
-    CrstHolder lock(&m_MapsLock);
-    const FileNameToAssemblyMapEntry * pEntry = m_FileNameToAssemblyMap.LookupPtr(wszFileName);
-    return (pEntry == nullptr) ? nullptr : clr::SafeAddRef(pEntry->m_pAssembly);
-}
-
-//=====================================================================================================================
-// Add FileName -> CLRPrivAssemblyReflectionOnlyWinRT * mapping to the map (multi-thread safe).
-ReleaseHolder<CLRPrivAssemblyReflectionOnlyWinRT> 
-CLRPrivBinderReflectionOnlyWinRT::AddFileNameToAssemblyMapping(
-    LPCWSTR                              wszFileName, 
-    CLRPrivAssemblyReflectionOnlyWinRT * pAssembly)
-{
-    STANDARD_VM_CONTRACT;
-    
-    _ASSERTE(pAssembly != nullptr);
-    
-    CrstHolder lock(&m_MapsLock);
-    
-    const FileNameToAssemblyMapEntry * pEntry = m_FileNameToAssemblyMap.LookupPtr(wszFileName);
-    CLRPrivAssemblyReflectionOnlyWinRT * pResultAssembly = nullptr;
-    if (pEntry != nullptr)
-    {
-        pResultAssembly = pEntry->m_pAssembly;
-    }
-    else
-    {
-        FileNameToAssemblyMapEntry e;
-        e.m_wszFileName = wszFileName;
-        e.m_pAssembly = pAssembly;
-        m_FileNameToAssemblyMap.Add(e);
-        
-        pResultAssembly = pAssembly;
-    }
-    return clr::SafeAddRef(pResultAssembly);
-}
-
-//=====================================================================================================================
-void 
-CLRPrivBinderReflectionOnlyWinRT::RemoveFileNameToAssemblyMapping(
-    LPCWSTR wszFileName)
-{
-    LIMITED_METHOD_CONTRACT;
-    STATIC_CONTRACT_CAN_TAKE_LOCK;
-    
-    CrstHolder lock(&m_MapsLock);
-    m_FileNameToAssemblyMap.Remove(wszFileName);
-}
-
-//=====================================================================================================================
-ReleaseHolder<CLRPrivAssemblyReflectionOnlyWinRT> 
-CLRPrivBinderReflectionOnlyWinRT::FindOrCreateAssemblyByFileName(
-    LPCWSTR wszFileName)
-{
-    STANDARD_VM_CONTRACT;
-    
-    ReleaseHolder<CLRPrivAssemblyReflectionOnlyWinRT> pAssembly = FindAssemblyByFileName(wszFileName);
-    
-    if (pAssembly == nullptr)
-    {
-        NewHolder<CLRPrivResourcePathImpl> pResource(
-            new CLRPrivResourcePathImpl(wszFileName));
-        
-        NewHolder<CLRPrivAssemblyReflectionOnlyWinRT> pNewAssembly(
-            new CLRPrivAssemblyReflectionOnlyWinRT(wszFileName, this, pResource));
-        
-        // pNewAssembly holds reference to this now
-        pResource.SuppressRelease();
-        
-        // Add the assembly into cache (multi-thread aware)
-        pAssembly = AddFileNameToAssemblyMapping(pResource->GetPath(), pNewAssembly);
-        
-        if (pAssembly == pNewAssembly)
-        {   // We did not find an existing assembly in the cache and are using the newly created pNewAssembly.
-            // Stop it from being deleted when we go out of scope.
-            pNewAssembly.SuppressRelease();
-        }
-    }
-    return pAssembly.Extract();
-}
-
-//=====================================================================================================================
-// Returns list of file names from code:m_NamespaceToFileNameListMap for the namespace.
-// 
-void 
-CLRPrivBinderReflectionOnlyWinRT::GetFileNameListForNamespace(
-    LPCWSTR                           wszNamespace, 
-    DomainAssembly *                  pParentAssembly, 
-    CLRPrivBinderUtil::WStringList ** ppFileNameList)
-{
-    STANDARD_VM_CONTRACT;
-    
-    CLRPrivBinderUtil::WStringList * pFileNameList = nullptr;
-    {
-        CrstHolder lock(&m_MapsLock);
-        
-        const NamespaceToFileNameListMapEntry * pEntry = m_NamespaceToFileNameListMap.LookupPtr(wszNamespace);
-        if (pEntry != nullptr)
-        {
-            // Entries from the map are never removed, so we do not have to protect the file name list with a lock
-            pFileNameList = pEntry->m_pFileNameList;
-        }
-    }
-    
-    if (pFileNameList != nullptr)
-    {
-        *ppFileNameList = pFileNameList;
-    }
-    else
-    {
-        CLRPrivBinderUtil::WStringListHolder hFileNameList;
-        
-        EX_TRY
-        {
-            m_pTypeCache->RaiseNamespaceResolveEvent(wszNamespace, pParentAssembly, &hFileNameList);
-        }
-        EX_CATCH
-        {
-            Exception * ex = GET_EXCEPTION();
-            if (!ex->IsTransient())
-            {   // Exception was caused by user code
-                // Cache empty file name list for this namespace
-                (void)AddFileNameListForNamespace(wszNamespace, nullptr, ppFileNameList);
-            }
-            EX_RETHROW;
-        }
-        EX_END_CATCH_UNREACHABLE
-        
-        if (AddFileNameListForNamespace(wszNamespace, hFileNameList.GetValue(), ppFileNameList))
-        {   // The file name list was added to the cache - do not delete it
-            _ASSERTE(*ppFileNameList == hFileNameList.GetValue());
-            (void)hFileNameList.Extract();
-        }
-    }
-} // CLRPrivBinderReflectionOnlyWinRT::GetFileNameListForNamespace
-
-//=====================================================================================================================
-// Adds (thread-safe) list of file names to code:m_NamespaceToFileNameListMap for the namespace - returns the cached value.
-// Returns TRUE, if pFileNameList was added to the cache and caller should NOT delete it.
-// Returns FALSE, if pFileNameList was not added to the cache and caller should delete it.
-// 
-BOOL 
-CLRPrivBinderReflectionOnlyWinRT::AddFileNameListForNamespace(
-    LPCWSTR                           wszNamespace, 
-    CLRPrivBinderUtil::WStringList *  pFileNameList, 
-    CLRPrivBinderUtil::WStringList ** ppFileNameList)
-{
-    STANDARD_VM_CONTRACT;
-    
-    NewArrayHolder<WCHAR> wszEntryNamespace = DuplicateStringThrowing(wszNamespace);
-    
-    NamespaceToFileNameListMapEntry entry;
-    entry.m_wszNamespace = wszEntryNamespace;
-    entry.m_pFileNameList = pFileNameList;
-    
-    {
-        CrstHolder lock(&m_MapsLock);
-        
-        const NamespaceToFileNameListMapEntry * pEntry = m_NamespaceToFileNameListMap.LookupPtr(wszEntryNamespace);
-        if (pEntry == nullptr)
-        {
-            m_NamespaceToFileNameListMap.Add(entry);
-            
-            // These values are now owned by the hash table element
-            wszEntryNamespace.SuppressRelease();
-            *ppFileNameList = pFileNameList;
-            return TRUE;
-        }
-        else
-        {   // Another thread beat us adding this entry to the hash table
-            *ppFileNameList = pEntry->m_pFileNameList;
-            return FALSE;
-        }
-    }
-} // CLRPrivBinderReflectionOnlyWinRT::AddFileNameListForNamespace
-
-//=====================================================================================================================
-HRESULT 
-CLRPrivBinderReflectionOnlyWinRT::BindAssemblyExplicit(
-    const WCHAR *       wszFileName, 
-    ICLRPrivAssembly ** ppAssembly)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-    
-    HRESULT hr;
-    
-    GCX_PREEMP();
-    
-    ReleaseHolder<CLRPrivAssemblyReflectionOnlyWinRT> pAssembly = FindOrCreateAssemblyByFileName(wszFileName);
-    _ASSERTE(pAssembly != NULL);
-    
-    IfFailRet(pAssembly->QueryInterface(__uuidof(ICLRPrivAssembly), (LPVOID *)ppAssembly));
-    
-    return S_OK;
-}
-
-//=====================================================================================================================
-CLRPrivAssemblyReflectionOnlyWinRT::CLRPrivAssemblyReflectionOnlyWinRT(
-    LPCWSTR                            wzSimpleName, 
-    CLRPrivBinderReflectionOnlyWinRT * pBinder, 
-    CLRPrivResourcePathImpl *          pResourceIL)
-{
-    STANDARD_VM_CONTRACT;
-    VALIDATE_ARG_THROW((wzSimpleName != nullptr) && (pBinder != nullptr) && (pResourceIL != nullptr));
-
-    m_pBinder = clr::SafeAddRef(pBinder);
-    m_pResourceIL = clr::SafeAddRef(pResourceIL);
-}
-
-//=====================================================================================================================
-ULONG CLRPrivAssemblyReflectionOnlyWinRT::Release()
-{
-    LIMITED_METHOD_CONTRACT;
-    STATIC_CONTRACT_CAN_TAKE_LOCK;
-    _ASSERTE(m_cRef > 0);
-    
-    ULONG cRef;
-    
-    {
-        // To achieve proper lifetime semantics, the name to assembly map elements' CLRPrivAssemblyReflectionOnlyWinRT 
-        // instances are not ref counted. We cannot allow discovery of the object via m_FileNameToAssemblyMap 
-        // when the ref count is 0 (to prevent another thread to AddRef and Release it back to 0 in parallel).
-        // All uses of the map are guarded by the map lock, so we have to decrease the ref count under that 
-        // lock (to avoid the chance that 2 threads are running Release to ref count 0 at once).
-        CrstHolder lock(&m_pBinder->m_MapsLock);
-        
-        cRef = InterlockedDecrement(&m_cRef);
-        if (cRef == 0)
-        {
-            m_pBinder->RemoveFileNameToAssemblyMapping(m_pResourceIL->GetPath());
-        }
-    }
-    
-    if (cRef == 0)
-    {
-        delete this;
-    }
-    return cRef;
-}
-
-//=====================================================================================================================
-// Implements interface method code:ICLRPrivAssembly::IsShareable.
-// 
-HRESULT CLRPrivAssemblyReflectionOnlyWinRT::IsShareable(
-    BOOL * pbIsShareable)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    VALIDATE_ARG_RET(pbIsShareable != nullptr);
-
-    *pbIsShareable = FALSE;
-    return S_OK;
-}
-
-//=====================================================================================================================
-// Implements interface method code:ICLRPrivAssembly::GetAvailableImageTypes.
-// 
-HRESULT CLRPrivAssemblyReflectionOnlyWinRT::GetAvailableImageTypes(
-    LPDWORD pdwImageTypes)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    VALIDATE_ARG_RET(pdwImageTypes != nullptr);
-
-    *pdwImageTypes = 0;
-
-    if (m_pResourceIL != nullptr)
-        *pdwImageTypes |= ASSEMBLY_IMAGE_TYPE_IL;
-
-    return S_OK;
-}
-
-//=====================================================================================================================
-// Implements interface method code:ICLRPrivAssembly::GetImageResource.
-// 
-HRESULT CLRPrivAssemblyReflectionOnlyWinRT::GetImageResource(
-    DWORD               dwImageType, 
-    DWORD *             pdwImageType, 
-    ICLRPrivResource ** ppIResource)
-{
-    STANDARD_BIND_CONTRACT;
-    HRESULT hr = S_OK;
-    
-    VALIDATE_ARG_RET(ppIResource != nullptr);
-    
-    EX_TRY
-    {
-        DWORD _dwImageType;
-        if (pdwImageType == nullptr)
-        {
-            pdwImageType = &_dwImageType;
-        }
-        
-        if ((dwImageType & ASSEMBLY_IMAGE_TYPE_IL) == ASSEMBLY_IMAGE_TYPE_IL)
-        {
-            *ppIResource = clr::SafeAddRef(m_pResourceIL);
-            *pdwImageType = ASSEMBLY_IMAGE_TYPE_IL;
-        }
-        else
-        {   // Native image is not supported by this binder
-            hr = CLR_E_BIND_IMAGE_UNAVAILABLE;
-        }
-    }
-    EX_CATCH_HRESULT(hr);
-    
-    return hr;
-}
-
-//=====================================================================================================================
-// Implements interface method code:ICLRPrivBinder::VerifyBind.
-// 
-HRESULT CLRPrivBinderReflectionOnlyWinRT::VerifyBind(
-    IAssemblyName *        pAssemblyName, 
-    ICLRPrivAssembly *     pAssembly, 
-    ICLRPrivAssemblyInfo * pAssemblyInfo)
-{
-    STANDARD_BIND_CONTRACT;
-    HRESULT hr = S_OK;
-    
-    UINT_PTR binderID;
-    IfFailRet(pAssembly->GetBinderID(&binderID));
-    if (binderID != reinterpret_cast<UINT_PTR>(this))
-    {
-        return pAssembly->VerifyBind(pAssemblyName, pAssembly, pAssemblyInfo);
-    }
-    
-    // Since WinRT types are bound by type name and not assembly name, assembly-level version validation 
-    // does not make sense here. Just return S_OK.
-    return S_OK;
-}
-
-//=====================================================================================================================
-// Implements interface method code:ICLRPrivBinder::GetBinderID.
-// 
-HRESULT CLRPrivBinderReflectionOnlyWinRT::GetBinderID(
-    UINT_PTR * pBinderId)
-{
-    LIMITED_METHOD_CONTRACT;
-    
-    *pBinderId = reinterpret_cast<UINT_PTR>(this);
-    return S_OK;
-}
-
-#endif //FEATURE_REFLECTION_ONLY_LOAD
-#endif //!DACCESS_COMPILE
diff --git a/src/vm/clrprivbinderreflectiononlywinrt.h b/src/vm/clrprivbinderreflectiononlywinrt.h
deleted file mode 100644
index 5f8ef46773..0000000000
--- a/src/vm/clrprivbinderreflectiononlywinrt.h
+++ /dev/null
@@ -1,295 +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.
-// 
-
-// 
-// Contains the types that implement code:ICLRPrivBinder and code:ICLRPrivAssembly for WinRT ReflectionOnly (aka introspection) binding.
-// 
-//=====================================================================================================================
-
-#ifdef FEATURE_REFLECTION_ONLY_LOAD
-
-#pragma once
-
-#include "holder.h"
-#include "internalunknownimpl.h"
-#include "clrprivbinding.h"
-#include "clrprivruntimebinders.h"
-#include "clrprivbinderutil.h"
-#include "clr_std/utility"
-
-//=====================================================================================================================
-// Forward declarations
-class CLRPrivBinderReflectionOnlyWinRT;
-class CLRPrivAssemblyReflectionOnlyWinRT;
-class CLRPrivTypeCacheReflectionOnlyWinRT;
-class DomainAssembly;
-
-//=====================================================================================================================
-//=====================================================================================================================
-//=====================================================================================================================
-class CLRPrivBinderReflectionOnlyWinRT : 
-    public IUnknownCommon<ICLRPrivBinder>
-{
-    friend class CLRPrivAssemblyReflectionOnlyWinRT;
-    
-private:
-    //=============================================================================================
-    // Data structures for Namespace -> FileNameList hash (as returned by RoResolveNamespace API)
-    
-    // Entry in SHash table that maps namespace to list of files
-    struct NamespaceToFileNameListMapEntry
-    {
-        PWSTR                            m_wszNamespace;
-        CLRPrivBinderUtil::WStringList * m_pFileNameList;
-    };
-    
-    // SHash traits for Namespace -> FileNameList hash
-    class NamespaceToFileNameListMapTraits : public NoRemoveSHashTraits< DefaultSHashTraits< NamespaceToFileNameListMapEntry > >
-    {
-    public:
-        typedef PCWSTR key_t;
-        static const NamespaceToFileNameListMapEntry Null() { NamespaceToFileNameListMapEntry e; e.m_wszNamespace = nullptr; return e; }
-        static bool IsNull(const NamespaceToFileNameListMapEntry & e) { return e.m_wszNamespace == nullptr; }
-        static PCWSTR GetKey(const NamespaceToFileNameListMapEntry & e) { return e.m_wszNamespace; }
-        static count_t Hash(PCWSTR str) { return HashString(str); }
-        static BOOL Equals(PCWSTR lhs, PCWSTR rhs) { LIMITED_METHOD_CONTRACT; return (wcscmp(lhs, rhs) == 0); }
-        
-        void OnDestructPerEntryCleanupAction(const NamespaceToFileNameListMapEntry & e)
-        {
-            delete [] e.m_wszNamespace;
-            CLRPrivBinderUtil::WStringList_Delete(e.m_pFileNameList);
-        }
-        static const bool s_DestructPerEntryCleanupAction = true;
-    };
-
-    typedef SHash<NamespaceToFileNameListMapTraits> NamespaceToFileNameListMap;
-    
-    //=============================================================================================
-    // Data structure for FileName -> CLRPrivAssemblyReflectionOnlyWinRT * map
-    
-    struct FileNameToAssemblyMapEntry
-    {
-        PCWSTR                               m_wszFileName;   // File name (owned by m_pAssembly)
-        CLRPrivAssemblyReflectionOnlyWinRT * m_pAssembly;
-    };
-    
-    class FileNameToAssemblyMapTraits : public DefaultSHashTraits<FileNameToAssemblyMapEntry>
-    {
-    public:
-        typedef PCWSTR key_t;
-        static const FileNameToAssemblyMapEntry Null() { FileNameToAssemblyMapEntry e; e.m_wszFileName = NULL; return e; }
-        static bool IsNull(const FileNameToAssemblyMapEntry &e) { return e.m_wszFileName == NULL; }
-        static const FileNameToAssemblyMapEntry Deleted() { FileNameToAssemblyMapEntry e; e.m_wszFileName = (PCWSTR)-1; return e; }
-        static bool IsDeleted(const FileNameToAssemblyMapEntry & e) { return e.m_wszFileName == (PCWSTR)-1; }
-        static PCWSTR GetKey(const FileNameToAssemblyMapEntry & e) { return e.m_wszFileName; }
-        static count_t Hash(PCWSTR str) { return HashString(str); }
-        static BOOL Equals(PCWSTR lhs, PCWSTR rhs) { LIMITED_METHOD_CONTRACT; return (wcscmp(lhs, rhs) == 0); }
-    };
-    
-    typedef SHash<FileNameToAssemblyMapTraits> FileNameToAssemblyMap;
-    
-public:
-    //=============================================================================================
-    // ICLRPrivBinder interface methods
-
-    STDMETHOD(BindAssemblyByName)(
-        IAssemblyName * pAssemblyName,
-        ICLRPrivAssembly ** ppAssembly);
-
-    // Implements interface method code:ICLRPrivBinder::VerifyBind.
-    STDMETHOD(VerifyBind)(
-        IAssemblyName *        pAssemblyName, 
-        ICLRPrivAssembly *     pAssembly, 
-        ICLRPrivAssemblyInfo * pAssemblyInfo);
-
-    // Implements interface method code:ICLRPrivBinder::GetBinderFlags
-    STDMETHOD(GetBinderFlags)(
-        DWORD *pBinderFlags)
-    {
-        LIMITED_METHOD_CONTRACT;
-        *pBinderFlags = BINDER_NONE;
-        return S_OK;
-    }
-
-    // Implements interface method code:ICLRPrivBinder::GetBinderID.
-    STDMETHOD(GetBinderID)(
-        UINT_PTR * pBinderId);
-
-    // FindAssemblyBySpec is not supported by this binder.
-    STDMETHOD(FindAssemblyBySpec)(
-        LPVOID pvAppDomain,
-        LPVOID pvAssemblySpec,
-        HRESULT * pResult,
-        ICLRPrivAssembly ** ppAssembly)
-    { STATIC_CONTRACT_WRAPPER; return E_FAIL; }
-
-    //=============================================================================================
-    // Class methods
-
-    CLRPrivBinderReflectionOnlyWinRT(
-        CLRPrivTypeCacheReflectionOnlyWinRT * pTypeCache);
-    
-    ~CLRPrivBinderReflectionOnlyWinRT();
-
-    HRESULT BindAssemblyExplicit(
-        const WCHAR *       wszFileName, 
-        ICLRPrivAssembly ** ppAssembly);
-
-    HRESULT BindWinRtType(
-        LPCSTR              szTypeNamespace, 
-        LPCSTR              szTypeClassName, 
-        DomainAssembly *    pParentAssembly, 
-        ICLRPrivAssembly ** ppPrivAssembly);
-    
-private:
-    //=============================================================================================
-    // Accessors for FileName -> CLRPrivAssemblyReflectionOnlyWinRT * map
-    
-    ReleaseHolder<CLRPrivAssemblyReflectionOnlyWinRT> FindAssemblyByFileName(
-        LPCWSTR wzsFileName);
-    
-    ReleaseHolder<CLRPrivAssemblyReflectionOnlyWinRT> AddFileNameToAssemblyMapping(
-        LPCWSTR                              wszFileName,
-        CLRPrivAssemblyReflectionOnlyWinRT * pAssembly);
-    
-    void RemoveFileNameToAssemblyMapping(
-        LPCWSTR wszFileName);
-    
-    ReleaseHolder<CLRPrivAssemblyReflectionOnlyWinRT> FindOrCreateAssemblyByFileName(
-        LPCWSTR wzsFileName);
-    
-    //=============================================================================================
-    // Internal methods
-    
-    // Returns list of file names from code:m_NamespaceToFileNameListMap for the namespace.
-    void GetFileNameListForNamespace(
-        LPCWSTR                           wszNamespace, 
-        DomainAssembly *                  pParentAssembly, 
-        CLRPrivBinderUtil::WStringList ** ppFileNameList);
-    
-    // Adds (thread-safe) list of file names to code:m_NamespaceToFileNameListMap for the namespace - returns the cached value.
-    BOOL AddFileNameListForNamespace(
-        LPCWSTR                           wszNamespace, 
-        CLRPrivBinderUtil::WStringList *  pFileNameList, 
-        CLRPrivBinderUtil::WStringList ** ppFileNameList);
-    
-    HRESULT BindWinRtType_Internal(
-        LPCSTR                                szTypeNamespace, 
-        LPCSTR                                szTypeClassName, 
-        DomainAssembly *                      pParentAssembly, 
-        CLRPrivAssemblyReflectionOnlyWinRT ** ppAssembly);
-    
-private:
-    //=============================================================================================
-    
-    // Namespace -> FileName list map ... items are never removed
-    NamespaceToFileNameListMap m_NamespaceToFileNameListMap;
-    // FileName -> CLRPrivAssemblyReflectionOnlyWinRT * map ... items can be removed when CLRPrivAssemblyReflectionOnlyWinRT dies
-    FileNameToAssemblyMap      m_FileNameToAssemblyMap;
-    
-    // Lock for the above maps
-    Crst m_MapsLock;
-    
-    //=============================================================================================
-    CLRPrivTypeCacheReflectionOnlyWinRT * m_pTypeCache;
-    
-};  // class CLRPrivBinderReflectionOnlyWinRT
-
-
-//=====================================================================================================================
-//=====================================================================================================================
-//=====================================================================================================================
-class CLRPrivAssemblyReflectionOnlyWinRT :
-    public IUnknownCommon<ICLRPrivAssembly>
-{
-    friend class CLRPrivBinderReflectionOnlyWinRT;
-
-public:
-    //=============================================================================================
-    // Class methods
-    
-    CLRPrivAssemblyReflectionOnlyWinRT(
-        LPCWSTR                                      wzFullTypeName, 
-        CLRPrivBinderReflectionOnlyWinRT *           pBinder, 
-        CLRPrivBinderUtil::CLRPrivResourcePathImpl * pResourceIL);
-    
-    //=============================================================================================
-    // IUnknown interface methods
-    
-    // Overridden to implement self-removal from assembly map code:CLRPrivBinderReflectionOnlyWinRT::m_FileNameToAssemblyMap.
-    STDMETHOD_(ULONG, Release)();
-    
-    //=============================================================================================
-    // ICLRPrivBinder interface methods
-    
-    STDMETHOD(BindAssemblyByName)(
-        IAssemblyName * pAssemblyName,
-        ICLRPrivAssembly ** ppAssembly)
-    {
-        STATIC_CONTRACT_WRAPPER;
-        return m_pBinder->BindAssemblyByName(pAssemblyName, ppAssembly);
-    }
-    
-    // Implements interface method code:ICLRPrivBinder::VerifyBind.
-    STDMETHOD(VerifyBind)(
-        IAssemblyName *        pAssemblyName, 
-        ICLRPrivAssembly *     pAssembly, 
-        ICLRPrivAssemblyInfo * pAssemblyInfo)
-    {
-        STATIC_CONTRACT_WRAPPER;
-        return m_pBinder->VerifyBind(pAssemblyName, pAssembly, pAssemblyInfo);
-    }
-
-    //---------------------------------------------------------------------------------------------
-    // Implements interface method code:ICLRPrivBinder::GetBinderFlags
-    STDMETHOD(GetBinderFlags)(
-        DWORD *pBinderFlags)
-    {
-        STATIC_CONTRACT_WRAPPER;
-        return m_pBinder->GetBinderFlags(pBinderFlags);
-    }
-
-    // Implements interface method code:ICLRPrivBinder::GetBinderID.
-    STDMETHOD(GetBinderID)(
-        UINT_PTR * pBinderId)
-    {
-        STATIC_CONTRACT_WRAPPER;
-        return m_pBinder->GetBinderID(pBinderId);
-    }
-
-    //=============================================================================================
-    // ICLRPrivAssembly interface methods
-    
-    // Implements interface method code:ICLRPrivAssembly::IsShareable.
-    STDMETHOD(IsShareable)(
-        BOOL * pbIsShareable);
-    
-    // Implements interface method code:ICLRPrivAssembly::GetAvailableImageTypes.
-    STDMETHOD(GetAvailableImageTypes)(
-        LPDWORD pdwImageTypes);
-    
-    // Implements interface method code:ICLRPrivAssembly::GetImageResource.
-    STDMETHOD(GetImageResource)(
-        DWORD               dwImageType, 
-        DWORD *             pdwImageType, 
-        ICLRPrivResource ** ppIResource);
-    
-    // Implements code:ICLRPrivBinder::FindAssemblyBySpec
-    STDMETHOD(FindAssemblyBySpec)(
-        LPVOID pvAppDomain,
-        LPVOID pvAssemblySpec,
-        HRESULT * pResult,
-        ICLRPrivAssembly ** ppAssembly)
-    { STATIC_CONTRACT_WRAPPER; return m_pBinder->FindAssemblyBySpec(pvAppDomain, pvAssemblySpec, pResult, ppAssembly); }
-
-private:
-    //=============================================================================================
-    
-    ReleaseHolder<CLRPrivBinderReflectionOnlyWinRT> m_pBinder;
-    ReleaseHolder<CLRPrivBinderUtil::CLRPrivResourcePathImpl> m_pResourceIL;
-    
-};  // class CLRPrivAssemblyReflectionOnlyWinRT
-
-#endif //FEATURE_REFLECTION_ONLY_LOAD
diff --git a/src/vm/clrprivbinderutil.cpp b/src/vm/clrprivbinderutil.cpp
index b6871123d9..0eccf508c5 100644
--- a/src/vm/clrprivbinderutil.cpp
+++ b/src/vm/clrprivbinderutil.cpp
@@ -39,327 +39,6 @@ LPWSTR CopyStringThrowing(
 
 namespace CLRPrivBinderUtil
 {
-#ifdef FEATURE_FUSION
-    //-----------------------------------------------------------------------------------------------------------------
-    CLRPrivAssemblyBindResultWrapper::CLRPrivAssemblyBindResultWrapper(
-        IAssemblyName *pIAssemblyName,
-        PCWSTR wzAssemblyPath,
-        IILFingerprintFactory *pILFingerprintFactory
-        ) :
-        m_wzAssemblyPath(DuplicateStringThrowing(wzAssemblyPath)),
-        m_pIAssemblyName(clr::SafeAddRef(pIAssemblyName)),
-        m_bIBindResultNISet(false),
-        m_pIBindResultNI(nullptr),
-        m_pIILFingerprint(nullptr),
-        m_pILFingerprintFactory(clr::SafeAddRef(pILFingerprintFactory)),
-        m_lock(CrstLeafLock)
-    {
-        STANDARD_VM_CONTRACT;
-        VALIDATE_ARG_THROW(pIAssemblyName != nullptr && wzAssemblyPath != nullptr);
-    }
-
-    //-----------------------------------------------------------------------------------------------------------------
-    CLRPrivAssemblyBindResultWrapper::~CLRPrivAssemblyBindResultWrapper()
-    {
-        clr::SafeRelease(m_pIAssemblyName);
-        clr::SafeRelease(m_pIILFingerprint);
-        clr::SafeRelease(m_pIBindResultNI);
-    }
-
-    //=================================================================================================================
-    // IBindResult methods
-
-    //-----------------------------------------------------------------------------------------------------------------
-    HRESULT CLRPrivAssemblyBindResultWrapper::GetAssemblyNameDef(
-        /*out*/ IAssemblyName **ppIAssemblyNameDef)
-    {
-        LIMITED_METHOD_CONTRACT;
-        
-        VALIDATE_ARG_RET(ppIAssemblyNameDef != nullptr);
-        *ppIAssemblyNameDef = clr::SafeAddRef(m_pIAssemblyName);
-        return S_OK;
-    }
-
-    //-----------------------------------------------------------------------------------------------------------------
-    HRESULT CLRPrivAssemblyBindResultWrapper::GetNextAssemblyModuleName(
-        /*in*/      DWORD   dwNIndex,
-        __inout_ecount(*pdwCCModuleName)    LPWSTR  pwzModuleName,
-        /*in, out, annotation("__inout")*/  LPDWORD pdwCCModuleName)
-    {
-        STANDARD_BIND_CONTRACT;
-        _ASSERTE(!("E_NOTIMPL: " __FUNCTION__));
-        return E_NOTIMPL;
-    }
-
-    //-----------------------------------------------------------------------------------------------------------------
-    HRESULT CLRPrivAssemblyBindResultWrapper::GetAssemblyLocation(
-        /*out*/ IAssemblyLocation **ppIAssemblyLocation)
-    {
-        STANDARD_BIND_CONTRACT;
-        VALIDATE_ARG_RET(ppIAssemblyLocation != nullptr);
-        return this->QueryInterface(ppIAssemblyLocation);
-    }
-
-    //-----------------------------------------------------------------------------------------------------------------
-    HRESULT CLRPrivAssemblyBindResultWrapper::GetNativeImage(
-        /*out*/ IBindResult **ppIBindResultNI,
-        /*out*/ BOOL         *pfIBindResultNIProbed)
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        // m_bIBindResultNISet must always be read *before* m_pIBindResultNI
-        bool bIBindResultNISet = m_bIBindResultNISet;
-
-        if (pfIBindResultNIProbed != nullptr)
-            *pfIBindResultNIProbed = bIBindResultNISet;
-
-        if (bIBindResultNISet && ppIBindResultNI != nullptr)
-            *ppIBindResultNI = clr::SafeAddRef(m_pIBindResultNI);
-
-        return S_OK;
-    }
-
-    //-----------------------------------------------------------------------------------------------------------------
-    HRESULT CLRPrivAssemblyBindResultWrapper::SetNativeImage(
-        /*in*/  IBindResult  *pIBindResultNI,
-        /*out*/ IBindResult **ppIBindResultNIFinal)
-    {
-        STANDARD_BIND_CONTRACT;
-        HRESULT hr = S_OK;
-
-        EX_TRY
-        {
-            // Native Binder needs S_FALSE returned if it loses the race.
-            hr = S_FALSE;
-
-            if (!m_bIBindResultNISet)
-            {
-                CrstHolder lock(&m_lock);
-                if (!m_bIBindResultNISet)
-                {
-                    m_pIBindResultNI = clr::SafeAddRef(pIBindResultNI);
-                    m_bIBindResultNISet = true;
-
-                    // Won the race!
-                    hr = S_OK;
-                }
-            }
-        }
-        EX_CATCH_HRESULT(hr);
-
-        if (ppIBindResultNIFinal != nullptr)
-            *ppIBindResultNIFinal = clr::SafeAddRef(m_pIBindResultNI);
-
-        return hr;
-    }
-
-    //-----------------------------------------------------------------------------------------------------------------
-    HRESULT CLRPrivAssemblyBindResultWrapper::IsEqual(
-        /*in*/ IUnknown *pIUnk)
-    {
-        STANDARD_BIND_CONTRACT;
-        HRESULT hr = S_OK;
-
-        VALIDATE_ARG_RET(pIUnk != nullptr);
-
-        ReleaseHolder<IBindResult> pIBindResult;
-
-        hr = pIUnk->QueryInterface(__uuidof(IBindResult), (void **)&pIBindResult);
-        if (SUCCEEDED(hr))
-        {
-            hr = pIBindResult == static_cast<IBindResult*>(this) ? S_OK : S_FALSE;
-        }
-        else if (hr == E_NOINTERFACE)
-        {
-            hr = S_FALSE;
-        }
-
-        return hr;
-    }
-
-    //-----------------------------------------------------------------------------------------------------------------
-    HRESULT CLRPrivAssemblyBindResultWrapper::GetNextAssemblyNameRef(
-        /*in*/  DWORD           dwNIndex,
-        /*out*/ IAssemblyName **ppIAssemblyNameRef)
-    {
-        STANDARD_BIND_CONTRACT;
-        _ASSERTE(!("E_UNEXPECTED: " __FUNCTION__));
-        return E_UNEXPECTED;
-    }
-
-    //-----------------------------------------------------------------------------------------------------------------
-    HRESULT CLRPrivAssemblyBindResultWrapper::GetNextDependentAssembly(
-        /*in*/  DWORD      dwNIndex,
-        /*out*/ IUnknown **ppIUnknownAssembly)
-    {
-        STANDARD_BIND_CONTRACT;
-        _ASSERTE(!("E_UNEXPECTED: " __FUNCTION__));
-        return E_UNEXPECTED;
-    }
-
-    //-----------------------------------------------------------------------------------------------------------------
-    HRESULT CLRPrivAssemblyBindResultWrapper::GetAssemblyLocationOfILImage(
-        /*out*/ IAssemblyLocation **ppAssemblyLocation)
-    {
-        LIMITED_METHOD_CONTRACT;
-        return this->QueryInterface(ppAssemblyLocation);
-    }
-
-    //-----------------------------------------------------------------------------------------------------------------
-    HRESULT CLRPrivAssemblyBindResultWrapper::GetILFingerprint(
-        /*out*/ IILFingerprint **ppFingerprint)
-    {
-        STANDARD_BIND_CONTRACT;
-        HRESULT hr = S_OK;
-
-        VALIDATE_ARG_RET(ppFingerprint != nullptr);
-
-        EX_TRY
-        {
-            *ppFingerprint = m_pIILFingerprint;
-            if (*ppFingerprint == nullptr)
-            {
-                ReleaseHolder<IILFingerprint> pFingerprint;
-                if (SUCCEEDED(hr = m_pILFingerprintFactory->GetILFingerprintForPath(GetILAssemblyPath(), &pFingerprint)))
-                {
-                    if (InterlockedCompareExchangeT<IILFingerprint>(&m_pIILFingerprint, pFingerprint, nullptr) == nullptr)
-                    {
-                        pFingerprint.SuppressRelease();
-                    }
-                }
-            }
-            *ppFingerprint = clr::SafeAddRef(m_pIILFingerprint);
-        }
-        EX_CATCH_HRESULT(hr);
-
-        return hr;
-    }
-
-    //-----------------------------------------------------------------------------------------------------------------
-    HRESULT CLRPrivAssemblyBindResultWrapper::GetSourceILTimestamp(
-        /*out*/ FILETIME* pFileTime)
-    {
-        STANDARD_BIND_CONTRACT;
-        HRESULT hr = S_OK;
-
-        VALIDATE_ARG_RET(pFileTime != nullptr);
-
-        EX_TRY
-        {
-            WIN32_FILE_ATTRIBUTE_DATA wfd;
-            if (!WszGetFileAttributesEx(GetILAssemblyPath(), GetFileExInfoStandard, &wfd))
-                ThrowLastError();
-            *pFileTime = wfd.ftLastWriteTime;
-        }
-        EX_CATCH_HRESULT(hr);
-
-        return hr;
-    }
-
-    //-----------------------------------------------------------------------------------------------------------------
-    HRESULT CLRPrivAssemblyBindResultWrapper::GetSourceILSize(
-        /*out*/ DWORD* pSize)
-    {
-        STANDARD_BIND_CONTRACT;
-        HRESULT hr = S_OK;
-
-        VALIDATE_ARG_RET(pSize != nullptr);
-
-        EX_TRY
-        {
-            WIN32_FILE_ATTRIBUTE_DATA wfd;
-            if (!WszGetFileAttributesEx(GetILAssemblyPath(), GetFileExInfoStandard, &wfd))
-                ThrowLastError();
-            if(wfd.nFileSizeHigh != 0)
-                ThrowHR(COR_E_OVERFLOW);
-            *pSize = wfd.nFileSizeLow;
-        }
-        EX_CATCH_HRESULT(hr);
-
-        return hr;
-    }
-
-    //-----------------------------------------------------------------------------------------------------------------
-    HRESULT CLRPrivAssemblyBindResultWrapper::GetNIInfo(
-        /*out*/ INativeImageInstallInfo** pInfo)
-    {
-        STANDARD_BIND_CONTRACT;
-        _ASSERTE(!("E_UNEXPECTED: " __FUNCTION__));
-        return E_UNEXPECTED;
-    }
-
-    //-----------------------------------------------------------------------------------------------------------------
-    HRESULT CLRPrivAssemblyBindResultWrapper::GetFlags(
-        /*out*/ DWORD * pdwFlags)
-    {
-        STANDARD_BIND_CONTRACT;
-        PRECONDITION(CheckPointer(pdwFlags));
-        if (pdwFlags == nullptr)
-        {
-            return E_POINTER;
-        }
-
-        // Currently, no effort is made to open assemblies and build a full IAssemblyName - this currently
-        // only contains the simple name. Since AppX packages cannot be in-place updated we can be confident
-        // that the binding environment will remain unchanged between NGEN and runtime. As such, return the
-        // flag to indicate that the native image binder should skip self assembly definition validation.
-        *pdwFlags = IBindResultFlag_AssemblyNameDefIncomplete;
-
-        return S_OK;
-    }
-
-    //-----------------------------------------------------------------------------------------------------------------
-    HRESULT CLRPrivAssemblyBindResultWrapper::GetLocationType(
-        /*out*/DWORD *pdwLocationType)
-    {
-        LIMITED_METHOD_CONTRACT;
-        VALIDATE_ARG_RET(pdwLocationType != nullptr);
-        
-        if (pdwLocationType == nullptr)
-            return E_INVALIDARG;
-        *pdwLocationType = ASSEMBLY_LOCATION_PATH;
-        return S_OK;
-    }
-
-    //-----------------------------------------------------------------------------------------------------------------
-    HRESULT CLRPrivAssemblyBindResultWrapper::GetPath(
-        __inout_ecount(*pdwccAssemblyPath) LPWSTR  pwzAssemblyPath,
-        /*in, annotation("__inout")*/      LPDWORD pdwccAssemblyPath)
-    {
-        STANDARD_BIND_CONTRACT;
-        HRESULT hr = S_OK;
-
-        VALIDATE_ARG_RET(pdwccAssemblyPath != nullptr);
-
-        EX_TRY
-        {
-            DWORD cchILAssemblyPath = static_cast<DWORD>(wcslen(GetILAssemblyPath())) + 1;
-            if (pwzAssemblyPath != nullptr && cchILAssemblyPath <= *pdwccAssemblyPath)
-            {
-                IfFailThrow(StringCchCopy(pwzAssemblyPath, *pdwccAssemblyPath, GetILAssemblyPath()));
-                *pdwccAssemblyPath = cchILAssemblyPath;
-                hr = S_OK;
-            }
-            else
-            {
-                *pdwccAssemblyPath = cchILAssemblyPath;
-                hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
-            }
-        }
-        EX_CATCH_HRESULT(hr);
-
-        return hr;
-    }
-
-    //-----------------------------------------------------------------------------------------------------------------
-    HRESULT CLRPrivAssemblyBindResultWrapper::GetHostID(
-        /*out*/ UINT64 *puiHostID)
-    {
-        STANDARD_BIND_CONTRACT;
-        _ASSERTE(!("E_UNEXPECTED: " __FUNCTION__));
-        return E_UNEXPECTED;
-    }
-#endif //FEATURE_FUSION
 
     //-----------------------------------------------------------------------------------------------------------------
     HRESULT VerifyBind(
@@ -661,49 +340,6 @@ namespace CLRPrivBinderUtil
         return hr;
     }
 
-#ifdef FEATURE_FUSION
-    //=====================================================================================================================
-    HRESULT AssemblyIdentity::Initialize(
-        AssemblySpec * pSpec)
-    {
-        CONTRACTL
-        {
-            NOTHROW;
-            GC_NOTRIGGER;
-            FORBID_FAULT;
-            MODE_ANY;
-            CAN_TAKE_LOCK;
-        }
-        CONTRACTL_END
-
-        HRESULT hr = S_OK;
-
-        if (0 == WszMultiByteToWideChar(
-            CP_UTF8, 0 /*flags*/, pSpec->GetName(), -1, Name, (int) (sizeof(Name) / sizeof(Name[0]))))
-        {
-            return HRESULT_FROM_GetLastError();
-        }
-
-        AssemblyMetaDataInternal * pAMDI = pSpec->GetContext();
-        if (pAMDI != nullptr)
-        {
-            Version.wMajor = pAMDI->usMajorVersion;
-            Version.wMinor = pAMDI->usMinorVersion;
-            Version.wBuild = pAMDI->usBuildNumber;
-            Version.wRevision = pAMDI->usRevisionNumber;
-        }
-
-        if (pSpec->HasPublicKeyToken())
-        {
-            PBYTE pbKey;
-            DWORD cbKey;
-            pSpec->GetPublicKeyToken(&pbKey, &cbKey);
-            IfFailRet(KeyToken.Initialize(pbKey, cbKey));
-        }
-
-        return hr;
-    }
-#endif
 
     
     //=====================================================================================================================
@@ -731,101 +367,4 @@ namespace CLRPrivBinderUtil
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 ///// ----------------------------- Direct calls to VM  -------------------------------------------
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-#if defined(FEATURE_APPX_BINDER)
-    ICLRPrivAssembly* RaiseAssemblyResolveEvent(IAssemblyName *pAssemblyName, ICLRPrivAssembly* pRequestingAssembly)
-    {
-        CONTRACT(ICLRPrivAssembly*)
-        {
-            THROWS;
-            GC_TRIGGERS;
-            MODE_ANY;
-            PRECONDITION(AppX::IsAppXProcess());
-            PRECONDITION(AppDomain::GetCurrentDomain()->IsDefaultDomain());
-            POSTCONDITION(CheckPointer(RETVAL, NULL_OK));
-            INJECT_FAULT(COMPlusThrowOM(););
-        }
-        CONTRACT_END;
-
-        BinderMethodID methodId;
-
-        methodId = METHOD__APP_DOMAIN__ON_ASSEMBLY_RESOLVE;  // post-bind execution event (the classic V1.0 event)
-
-        // Elevate threads allowed loading level.  This allows the host to load an assembly even in a restricted
-        // condition.  Note, however, that this exposes us to possible recursion failures, if the host tries to
-        // load the assemblies currently being loaded.  (Such cases would then throw an exception.)
-
-        OVERRIDE_LOAD_LEVEL_LIMIT(FILE_ACTIVE);
-        OVERRIDE_TYPE_LOAD_LEVEL_LIMIT(CLASS_LOADED);
-
-        DomainAssembly* pDomainAssembly = AppDomain::GetCurrentDomain()->FindAssembly(pRequestingAssembly);
-
-        GCX_COOP();
-
-        Assembly* pAssembly = NULL;
-
-        struct _gc {
-            OBJECTREF AppDomainRef;
-            OBJECTREF AssemblyRef;
-            STRINGREF str;
-        } gc;
-        ZeroMemory(&gc, sizeof(gc));
-
-        SString ssAssemblyName;
-        FusionBind::GetAssemblyNameDisplayName(pAssemblyName, ssAssemblyName);
-
-        GCPROTECT_BEGIN(gc);
-        if ((gc.AppDomainRef = GetAppDomain()->GetRawExposedObject()) != NULL)
-        {
-            gc.AssemblyRef = pDomainAssembly->GetExposedAssemblyObject();
-
-            MethodDescCallSite onAssemblyResolve(methodId, &gc.AppDomainRef);
-
-            gc.str = StringObject::NewString(ssAssemblyName.GetUnicode());
-            ARG_SLOT args[3] = {
-                ObjToArgSlot(gc.AppDomainRef),
-                ObjToArgSlot(gc.AssemblyRef),
-                ObjToArgSlot(gc.str)
-            };
-            ASSEMBLYREF ResultingAssemblyRef = (ASSEMBLYREF) onAssemblyResolve.Call_RetOBJECTREF(args);
-            if (ResultingAssemblyRef != NULL)
-            {
-                pAssembly = ResultingAssemblyRef->GetAssembly();
-            }
-        }
-        GCPROTECT_END();
-
-        if (pAssembly != NULL)
-        {
-            if (pAssembly->IsIntrospectionOnly())
-            {
-                // Cannot return an introspection assembly from an execution callback or vice-versa
-                COMPlusThrow(kFileLoadException, IDS_CLASSLOAD_ASSEMBLY_RESOLVE_RETURNED_INTROSPECTION );
-            }
-            if (pAssembly->IsCollectible())
-            {
-                COMPlusThrow(kNotSupportedException, W("NotSupported_CollectibleAssemblyResolve"));
-            }
-
-            // Check that the public key token matches the one specified in the spec
-            // MatchPublicKeys throws as appropriate.
-            
-            StackScratchBuffer ssBuffer;
-            AssemblySpec spec;
-            IfFailThrow(spec.Init(ssAssemblyName.GetUTF8(ssBuffer)));
-            spec.MatchPublicKeys(pAssembly);
-
-        }
-
-        if (pAssembly == nullptr)
-            ThrowHR(COR_E_FILENOTFOUND);
-
-        RETURN  pAssembly->GetManifestFile()->GetHostAssembly();
-    }
-
-    BOOL CompareHostBinderSpecs(AssemblySpec * a1, AssemblySpec * a2)
-    {
-        WRAPPER_NO_CONTRACT;
-        return a1->CompareEx(a2, AssemblySpec::ASC_Default);
-    }
-#endif // FEATURE_APPX
 } // namespace CLRPrivBinderUtil
diff --git a/src/vm/clrprivbinderwinrt.cpp b/src/vm/clrprivbinderwinrt.cpp
index b4fb45c083..f73d01a46d 100644
--- a/src/vm/clrprivbinderwinrt.cpp
+++ b/src/vm/clrprivbinderwinrt.cpp
@@ -11,9 +11,6 @@
 
 #include "common.h" // precompiled header
 
-#ifndef FEATURE_CORECLR
-#include "assemblyusagelogmanager.h"
-#endif
 #include "clr/fs/file.h"
 #include "clrprivbinderwinrt.h"
 #include "clrprivbinderutil.h"
@@ -22,25 +19,17 @@
 
 //=====================================================================================================================
 #include "sstring.h"
-#ifdef FEATURE_FUSION
-#include "fusionlogging.h"
-#include "policy.h"
-#include "imprthelpers.h" // in fusion/inc
-#include "asmimprt.h"
-#endif
 #ifdef FEATURE_APPX
 #include "appxutil.h"
 #endif
 #include <TypeResolution.h>
 #include "delayloadhelpers.h"
-#ifdef FEATURE_CORECLR
 #include "../binder/inc/applicationcontext.hpp"
 #include "../binder/inc/assemblybinder.hpp"
 #include "../binder/inc/assembly.hpp"
 #include "../binder/inc/debuglog.hpp"
 #include "../binder/inc/utils.hpp"
 #include "../binder/inc/fusionassemblyname.hpp"
-#endif
 
 #ifdef CROSSGEN_COMPILE
 #include "crossgenroresolvenamespace.h"
@@ -134,17 +123,9 @@ CLRPrivBinderWinRT::CLRPrivBinderWinRT(
     BOOL                    fCanUseNativeImages)
     : m_pTypeCache(clr::SafeAddRef(pWinRtTypeCache))
     , m_pParentBinder(pParentBinder)                        // Do not addref, lifetime directly tied to parent.
-#ifdef FEATURE_FUSION
-    , m_fCanUseNativeImages(fCanUseNativeImages)
-#endif
     , m_fNamespaceResolutionKind(fNamespaceResolutionKind)
-#ifdef FEATURE_CORECLR
     , m_pApplicationContext(nullptr)
     , m_appLocalWinMDPath(nullptr)
-#endif
-#ifdef FEATURE_COMINTEROP_WINRT_DESKTOP_HOST
-    , m_fCanSetLocalWinMDPath(TRUE)
-#endif // FEATURE_COMINTEROP_WINRT_DESKTOP_HOST
 {
     STANDARD_VM_CONTRACT;
     PRECONDITION(CheckPointer(pWinRtTypeCache));
@@ -160,9 +141,6 @@ CLRPrivBinderWinRT::CLRPrivBinderWinRT(
                     INDEBUG(| CRST_DEBUG_ONLY_CHECK_FORBID_SUSPEND_THREAD)));
     m_MapsAddLock.Init(CrstCLRPrivBinderMapsAdd);
 
-#ifdef FEATURE_COMINTEROP_WINRT_DESKTOP_HOST
-    m_localWinMDPathLock.Init(CrstCrstCLRPrivBinderLocalWinMDPath);
-#endif // FEATURE_COMINTEROP_WINRT_DESKTOP_HOST
 
     // Copy altpaths
     if (cAltPaths > 0)
@@ -177,39 +155,8 @@ CLRPrivBinderWinRT::CLRPrivBinderWinRT(
                 m_rgAltPaths.GetRawArray() + iAltPath));
         }
     }
-#if defined(FEATURE_APPX) && !defined(FEATURE_CORECLR)
-    else if (AppX::IsAppXNGen())
-    {
-        // If this is an NGen worker process for AppX, then the process doesn't actually run in the package,
-        // and RoResolveNamespace won't work without some help.  AppX::GetCurrentPackageInfo can give us the
-        // package graph, which we can pass to RoResolveNamespace to make it work properly.
-        UINT32 cbBuffer = 0;
-        UINT32 nCount = 0;
-        HRESULT hr = AppX::GetCurrentPackageInfo(PACKAGE_FILTER_CLR_DEFAULT, &cbBuffer, nullptr, nullptr);
-        if (hr != HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER))
-            ThrowHR(hr);
-
-        NewArrayHolder<BYTE> pbBuffer(new (nothrow) BYTE[cbBuffer]);
-        IfNullThrow(pbBuffer);
-        IfFailThrow(AppX::GetCurrentPackageInfo(PACKAGE_FILTER_CLR_DEFAULT, &cbBuffer, pbBuffer, &nCount));
-
-        m_rgAltPaths.Allocate(nCount);
-
-        PCPACKAGE_INFO pPackageInfo = reinterpret_cast<PCPACKAGE_INFO>(static_cast<PBYTE>(pbBuffer));
-        for (UINT32 iAltPath = 0; iAltPath < nCount; iAltPath++)
-        {
-            IfFailThrow(WindowsCreateString(
-                pPackageInfo[iAltPath].path,
-                (UINT32)wcslen(pPackageInfo[iAltPath].path),
-                m_rgAltPaths.GetRawArray() + iAltPath));
-        }
-    }
-#endif //FEATURE_APPX && !FEATURE_CORECLR
 #endif //CROSSGEN_COMPILE
 
-#ifdef FEATURE_FUSION
-    IfFailThrow(RuntimeCreateCachingILFingerprintFactory(&m_pFingerprintFactory));
-#endif
 }
 
 //=====================================================================================================================
@@ -217,9 +164,6 @@ CLRPrivBinderWinRT::~CLRPrivBinderWinRT()
 {
     WRAPPER_NO_CONTRACT;
 
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-    AssemblyUsageLogManager::UnRegisterBinderFromUsageLog((UINT_PTR)this);
-#endif
     if (m_pTypeCache != nullptr)
     {
         m_pTypeCache->Release();
@@ -235,11 +179,6 @@ CLRPrivBinderWinRT::GetOrCreateBinder(
     STANDARD_VM_CONTRACT;
     HRESULT hr = S_OK;
 
-    // This should be allocated directly by CLRPrivBinderAppX in the AppX scenario.
-#ifdef FEATURE_APPX_BINDER
-	_ASSERTE(!AppX::IsAppXProcess());
-#endif
-
     if (s_pSingleton == nullptr)
     {
         ReleaseHolder<CLRPrivBinderWinRT> pBinder;
@@ -256,15 +195,6 @@ CLRPrivBinderWinRT::GetOrCreateBinder(
         {
             pBinder.SuppressRelease();
         }
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-        // Create and register WinRT usage log
-        ReleaseHolder<IAssemblyUsageLog> pNewWinRTUsageLog;
-        IfFailThrow(AssemblyUsageLogManager::GetUsageLogForContext(W("WinRT"), W("NotApp"), &pNewWinRTUsageLog));
-
-        UINT_PTR winRTBinderId;
-        IfFailThrow(pBinder->GetBinderID(&winRTBinderId));
-        IfFailThrow(AssemblyUsageLogManager::RegisterBinderWithUsageLog(winRTBinderId, pNewWinRTUsageLog));
-#endif
     }
     _ASSERTE(s_pSingleton->m_fNamespaceResolutionKind == fNamespaceResolutionKind);
     
@@ -289,17 +219,10 @@ HRESULT CLRPrivBinderWinRT::BindWinRTAssemblyByName(
     HRESULT hr = S_OK;
     ReleaseHolder<CLRPrivAssemblyWinRT> pAssembly;
     LPWSTR wszFullTypeName = nullptr;
-#ifndef FEATURE_CORECLR
-    NewArrayHolder<WCHAR> wszAssemblySimpleName;
-#endif
 
 #ifndef CROSSGEN_COMPILE
-#ifndef FEATURE_CORECLR
-    fusion::logging::StatusScope logStatus(0, ID_FUSLOG_BINDING_STATUS_WINRT, &hr);
-#else
     BINDER_SPACE::BINDER_LOG_ENTER(W("CLRPrivBinderWinRT_CoreCLR::BindWinRTAssemblyByName"));
 #endif
-#endif
     VALIDATE_ARG_RET(pAssemblyName != nullptr);
     VALIDATE_ARG_RET(ppAssembly != nullptr);
     
@@ -316,15 +239,11 @@ HRESULT CLRPrivBinderWinRT::BindWinRTAssemblyByName(
         IfFailGo(COR_E_PLATFORMNOTSUPPORTED);
     }
     
-#ifndef FEATURE_CORECLR
-    IfFailGo(fusion::util::GetProperty(pAssemblyName, ASM_NAME_NAME, &wszAssemblySimpleName));
-#else
     WCHAR wszAssemblySimpleName[_MAX_PATH];
     {
         DWORD cchAssemblySimpleName = _MAX_PATH;
         IfFailGo(pAssemblyName->GetName(&cchAssemblySimpleName, wszAssemblySimpleName));
     }
-#endif
     
     wszFullTypeName = wcschr(wszAssemblySimpleName, W('!'));
     
@@ -414,10 +333,6 @@ HRESULT CLRPrivBinderWinRT::BindWinRTAssemblyByName(
                 // 
                 IfFailGo(pAssemblyDefName->SetProperty(ASM_NAME_NAME, wszFileNameStripped, (lstrlenW(wszFileNameStripped) + 1) * sizeof(WCHAR)));
 
-#ifdef FEATURE_FUSION
-                NewHolder<CLRPrivAssemblyBindResultWrapper> pBindResult(
-                    new CLRPrivAssemblyBindResultWrapper(pAssemblyDefName, wszFileName, m_pFingerprintFactory));
-#else                
                 NewHolder<CoreBindResult> pBindResult(new CoreBindResult());
                 StackSString sAssemblyPath(pResource->GetPath());
                 ReleaseHolder<BINDER_SPACE::Assembly> pBinderAssembly;
@@ -427,7 +342,6 @@ HRESULT CLRPrivBinderWinRT::BindWinRTAssemblyByName(
                 // We have set bInGac to TRUE here because the plan is full trust for WinRT.  If this changes, we may need to check with
                 // AppDomain to verify trust based on the WinMD's path
                 pBindResult->Init(pBinderAssembly, TRUE);
-#endif
                 NewHolder<CLRPrivAssemblyWinRT> pNewAssembly(
                     new CLRPrivAssemblyWinRT(this, pResource, pBindResult, fIsWindowsNamespace));
                 
@@ -445,49 +359,7 @@ HRESULT CLRPrivBinderWinRT::BindWinRTAssemblyByName(
                     pNewAssembly.SuppressRelease();
                 }
                 
-#ifndef FEATURE_CORECLR                
-                if (fPreBind)
-                {
-                    // We are pre-binding to this WinMD and do not want to open it
-                    // Compare the filename to the assembly simple name.  This is legal to do with WinRT because at NGen time
-                    // we embed a WinRT dependency as assembly def name component plus a namespace and type from it.
-                    // At bind time, this type should still exist in the same assembly.  If it doesn't, and has been moved,
-                    // the native image validation will fail anyway and we'll fall back to IL.  This is because if the type has 
-                    // been moved to another WinMD, it must have been removed from the first one because WinRT allows no duplicates.
-                    // See comment on CLRPrivBinderWinRT::PreBind for further details.                    
-                    if (!_wcsicmp(wszAssemblySimpleName, wszFileNameStripped))
-                    {
-                        *ppAssembly = pAssembly.Extract();
-                        return (hr = S_OK);
-                    }
-                    else
-                    {
-                        continue;
-                    }
-                }
-#endif
-            }
-#ifndef FEATURE_CORECLR
-            else if (fPreBind)
-            {
-                // We are pre-binding to this WinMD and do not want to force it to be loaded into the runtime yet.
-                // Compare the filename to the assembly simple name.  This is legal to do with WinRT because at NGen time
-                // we embed a WinRT dependency as assembly def name component plus a namespace and type from it.
-                // At bind time, this type should still exist in the same assembly.  If it doesn't, and has been moved,
-                // the native image validation will fail anyway and we'll fall back to IL.  This is because if the type has 
-                // been moved to another WinMD, it must have been removed from the first one because WinRT allows no duplicates.
-                // See comment on CLRPrivBinderWinRT::PreBind for further details.
-                if (!_wcsicmp(wszAssemblySimpleName, wszFileNameStripped))
-                {
-                    *ppAssembly = pAssembly.Extract();
-                    return (hr = S_OK);
-                } 
-                else
-                {
-                    continue;
-                }
             }
-#endif
 
             //
             // Look to see if there's a native image available.
@@ -499,12 +371,8 @@ HRESULT CLRPrivBinderWinRT::BindWinRTAssemblyByName(
             if (hr == S_OK)
             {   // The type we are looking for has been found in this assembly
 #ifndef CROSSGEN_COMPILE
-#ifndef FEATURE_CORECLR
-                fusion::logging::LogMessage(0, ID_FUSLOG_BINDING_STATUS_FOUND, wszFileName);
-#else
                 BINDER_SPACE::BINDER_LOG_LEAVE_HR(W("CLRPrivBinderWinRT_CoreCLR::BindWinRTAssemblyByName"), hr);
 #endif
-#endif
                 *ppAssembly = pAssembly.Extract();
                 return (hr = S_OK);
             }
@@ -516,102 +384,11 @@ HRESULT CLRPrivBinderWinRT::BindWinRTAssemblyByName(
     hr = CLR_E_BIND_TYPE_NOT_FOUND;
  ErrExit:
 
-#ifdef FEATURE_CORECLR
     BINDER_SPACE::BINDER_LOG_LEAVE_HR(W("CLRPrivBinderWinRT_CoreCLR::BindWinRTAssemblyByName"), hr);
-#endif
     return hr;
 } // CLRPrivBinderWinRT::BindWinRTAssemblyByName
 
-#ifdef FEATURE_FUSION
-//=====================================================================================================================
-HRESULT CLRPrivBinderWinRT::BindAssemblyToNativeAssembly(CLRPrivAssemblyWinRT *pAssembly)
-{
-    HRESULT hr = S_OK;
-
-    if (!m_fCanUseNativeImages)
-        return hr;
 
-    ReleaseHolder<IBindResult> pIBindResultIL;
-    IfFailRet(pAssembly->GetIBindResult(&pIBindResultIL));
-    _ASSERTE(pIBindResultIL != nullptr);
-
-    NewArrayHolder<WCHAR> wzZapSet = DuplicateStringThrowing(g_pConfig->ZapSet());
-    NativeConfigData cfgData = {
-        wzZapSet,
-        PEFile::GetNativeImageConfigFlags()
-    };
-
-    ReleaseHolder<IBindContext> pIBindContext;
-    IfFailRet(GetParentIBindContext(&pIBindContext));
-                    
-    // Fire BindingNgenPhaseStart ETW event if enabled.
-    {
-        InlineSString<_MAX_PATH> ssAssemblyName;
-        FireEtwBindingNgenPhaseStart(
-            (AppDomain::GetCurrentDomain()->GetId().m_dwId),
-            LOADCTX_TYPE_HOSTED,
-            ETWFieldUnused,
-            ETWLoaderLoadTypeNotAvailable,
-            NULL,
-            pAssembly->m_pResourceIL->GetPath(),
-            GetClrInstanceId());
-    }
-                    
-    IfFailRet(BindToNativeAssembly(pIBindResultIL, &cfgData, pIBindContext, fusion::logging::GetCurrentFusionBindLog()));
-
-    // Fire BindingNgenPhaseEnd ETW event if enabled.
-    {
-        InlineSString<_MAX_PATH> ssAssemblyName;
-        FireEtwBindingNgenPhaseEnd(
-            (AppDomain::GetCurrentDomain()->GetId().m_dwId),
-            LOADCTX_TYPE_HOSTED,
-            ETWFieldUnused,
-            ETWLoaderLoadTypeNotAvailable,
-            NULL,
-            pAssembly->m_pResourceIL->GetPath(),
-            GetClrInstanceId());
-    }
-                    
-    // BindToNativeAssembly can return S_FALSE, but this could be misleading.
-    if (hr == S_FALSE)
-        hr = S_OK;
-
-    return hr;
-}
-#endif
-
-#if defined(FEATURE_COMINTEROP_WINRT_DESKTOP_HOST) && !defined(CROSSGEN_COMPILE)
-BOOL CLRPrivBinderWinRT::SetLocalWinMDPath(HSTRING localWinMDPath)
-{
-    STANDARD_VM_CONTRACT;
-    STATIC_CONTRACT_CAN_TAKE_LOCK;
-
-    CrstHolder lock(&m_localWinMDPathLock);
-
-    // We use the empty string as a sential, so don't allow explicitly setting the binding base to empty.
-    if (localWinMDPath == nullptr)
-    {
-        return FALSE;
-    }
-
-    // If we've already set a binding base, then the current base must match the exisitng one exactly
-    if (!m_localWinMDPath.IsEmpty())
-    {
-        return m_localWinMDPath.CompareOrdinal(clr::winrt::StringReference(localWinMDPath)) == 0;
-    }
-
-    // If we've already done WinRT binding, we can't set the binding base because that could lead to inconsistent results when binding
-    // the same name after the base is set.
-    if (!m_fCanSetLocalWinMDPath)
-    {
-        return FALSE;
-    }
-
-    m_localWinMDPath.Initialize(localWinMDPath);
-
-    return TRUE;
-}
-#endif // FEATURE_COMINTEROP_WINRT_DESKTOP_HOST && !CROSSGEN_COMPILE
 
 //=====================================================================================================================
 HRESULT CLRPrivBinderWinRT::BindWinRTAssemblyByName(
@@ -648,7 +425,6 @@ HRESULT CLRPrivBinderWinRT::BindWinRTAssemblyByName(
     return hr;
 }
 
-#ifndef FEATURE_FUSION
 //
 // This method opens the assembly using the CoreCLR Binder, which has logic supporting opening either the IL or 
 // even just the native image without IL present.
@@ -659,7 +435,6 @@ HRESULT CLRPrivBinderWinRT::GetAssemblyAndTryFindNativeImage(SString &sWinmdFile
 {
     HRESULT hr = S_OK;
 
-#ifdef FEATURE_CORECLR
     if (!m_pApplicationContext->IsTpaListProvided())
         return COR_E_FILENOTFOUND;
 
@@ -732,24 +507,10 @@ HRESULT CLRPrivBinderWinRT::GetAssemblyAndTryFindNativeImage(SString &sWinmdFile
                             FALSE, /* fIsInGAC */
                             FALSE /* fExplicitBindToNativeImage */,
                             ppAssembly);
-#else
-    ReleaseHolder<BINDER_SPACE::Assembly> pAssembly;
-
-    // This codepath is used for desktop crossgen
-    pAssembly = new BINDER_SPACE::Assembly();
-
-    pAssembly->SetPEImage(PEImage::OpenImage(sWinmdFilename, MDInternalImport_Default));
-
-    pAssembly->m_assemblyPath.Set(sWinmdFilename);
-
-    *ppAssembly = pAssembly.Extract();
-#endif
 
     return hr;
 }
-#endif // !FEATURE_FUSION
 
-#ifdef FEATURE_CORECLR
 //=====================================================================================================================
 HRESULT CLRPrivBinderWinRT::SetApplicationContext(BINDER_SPACE::ApplicationContext *pApplicationContext, SString &appLocalWinMD)
 {
@@ -784,7 +545,6 @@ HRESULT CLRPrivBinderWinRT::SetApplicationContext(BINDER_SPACE::ApplicationConte
     
     return hr;
 }
-#endif //FEATURE_CORECLR
 
 //=====================================================================================================================
 // Implements interface method code:ICLRPrivBinder::BindAssemblyByName.
@@ -950,20 +710,7 @@ CLRPrivBinderWinRT::GetFileNameListForNamespace(
             LPWSTR wszWinMDPath = nullptr;
             UINT32 cchWinMDPath = 0;
 
-#ifdef FEATURE_CORECLR
             wszWinMDPath = m_appLocalWinMDPath;
-#else
-            if (AppX::IsAdaptiveApp())
-            {
-                IfFailRet(AppX::GetWinMetadataDirForAdaptiveApps(&wszWinMDPath));
-            }
-
-            else if (AppX::IsAppXDesignMode() || IsNgenOffline())
-            {
-                wszWinMDPathConfig = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_WinMDPath);
-                wszWinMDPath = wszWinMDPathConfig;
-            }
-#endif // FEATURE_CORECLR
                 
             if (wszWinMDPath != nullptr)
             {
@@ -981,7 +728,6 @@ CLRPrivBinderWinRT::GetFileNameListForNamespace(
                 &rgFileNames, 
                 nullptr,    // pcDirectNamespaceChildren
                 nullptr);  // rgDirectNamespaceChildren
-#ifdef FEATURE_CORECLR
             // For CoreCLR, if the process is not AppX, deliver more appropriate error message
             // when trying to bind to 3rd party WinMDs that is not confusing.
             if (HRESULT_FROM_WIN32(APPMODEL_ERROR_NO_PACKAGE) == hr)
@@ -991,57 +737,7 @@ CLRPrivBinderWinRT::GetFileNameListForNamespace(
                     IfFailRet(HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED));
                 }
             }
-#endif
 
-#ifdef FEATURE_COMINTEROP_WINRT_DESKTOP_HOST
-            // If we failed to find the requested name, but we have an application local probing path setup, then
-            // we can use that to try to find the name now.
-            if (hr == RO_E_METADATA_NAME_NOT_FOUND || hr == HRESULT_FROM_WIN32(APPMODEL_ERROR_NO_PACKAGE))
-            {
-                // We only want to probe the application local path for 3rd party WinMDs as these are the only ones
-                // which do not have code sharing enabled.  Although we currently only allow a single alternate probing
-                // path per process, shutting this off now will give us easier behavior to support in the future if we
-                // do need to enable per-domain local paths.
-                if (!IsWindowsNamespace(wszNamespaceRoResolve))
-                {
-                    HSTRING localWinMDPath = nullptr;
-                    {
-                        CrstHolder lock(&m_localWinMDPathLock);
-
-                        localWinMDPath = m_localWinMDPath.Get();
-
-                        // If the host has not configured the local winmd path, and we have not yet done any winmd probing
-                        // then see if we have config to setup a local winmd path.
-                        if (localWinMDPath == nullptr && m_fCanSetLocalWinMDPath)
-                        {
-                            NewArrayHolder<WCHAR> configWinMDPath(CLRConfig::GetConfigValue(CLRConfig::INTERNAL_LocalWinMDPath));
-                            if (!configWinMDPath.IsNull())
-                            {
-                                m_localWinMDPath.Initialize(configWinMDPath);
-                                localWinMDPath = m_localWinMDPath.Get();
-                            }
-                        }
-
-                        // Do not allow any further setting of the application binding base at this point, since if it
-                        // is not currently set, setting it in the future could result in different binding results.
-                        m_fCanSetLocalWinMDPath = FALSE;
-                    }
-
-                    if (localWinMDPath != nullptr)
-                    {
-                        hr = RoResolveNamespace(
-                            WinRtStringRef(wszNamespaceRoResolve, cchNamespaceRoResolve),
-                            wszWinMDPath != nullptr ? (HSTRING)WinRtStringRef(wszWinMDPath, cchWinMDPath) : nullptr, // hsWindowsSdkPath
-                            1,        // cPackageGraph
-                            &localWinMDPath, // rgPackageGraph
-                            &cFileNames,
-                            &rgFileNames,
-                            nullptr,    // pcDirectNamespaceChildren
-                            nullptr);  // rgDirectNamespaceChildren
-                    }
-                }
-            }
-#endif // FEATURE_COMINTEROP_WINRT_DESKTOP_HOST
 
             IfFailRet(hr);
             if (hr != S_OK)
@@ -1059,33 +755,6 @@ CLRPrivBinderWinRT::GetFileNameListForNamespace(
                     &cchFileName);
                 
                 BOOL fSkipFilename = FALSE;
-#ifndef FEATURE_CORECLR            
-                // If we have a specified path list. Be certain to only find filenames in that list.
-                // NGen for AppX is an exception, where the path list contains the package graph, and we can
-                // accept files found elsewhere (e.g., in the Windows WinMD directory).
-                // On CoreCLR, we have no concept of an AppX package, so we want the passed in app
-                // paths to additively contribute to the set of WinMDs the API can find.
-                if (m_rgAltPaths.GetCount() > 0 && !AppX::IsAppXNGen())
-                {
-                    fSkipFilename = TRUE;
-                    for (DWORD iAltPath = 0; iAltPath < m_rgAltPaths.GetCount(); iAltPath++)
-                    {
-                        UINT32  cchAltPath = 0;
-                        LPCWSTR wszAltPath = WindowsGetStringRawBuffer(
-                            m_rgAltPaths.GetAt(iAltPath), 
-                            &cchAltPath);
-                    
-                        if (cchAltPath >= cchFileName)
-                            continue;
-                    
-                        if (wcsncmp(wszAltPath, wszFileName, cchAltPath) == 0)
-                        {
-                            fSkipFilename = FALSE;
-                            break;
-                        }
-                    }
-                }
-#endif            
                 if (!fSkipFilename)
                     hFileNameList.InsertTail(wszFileName);
             }
@@ -1309,60 +978,6 @@ CLRPrivBinderWinRT::FindAssemblyForTypeIfLoaded(
 
 #ifndef DACCESS_COMPILE
 
-#ifdef FEATURE_FUSION
-//=====================================================================================================================
-// Implements interface method code:IBindContext::PreBind.
-// 
-// Prebinding to WinMD files follows a special contract. We want to avoid loading the actual target assembly
-// and we need to validate that all dependencies of the file remain equivalent to that which was available at ngen time
-// We do this by comparing the filename to the assembly simple name.  This is legal to do with WinRT because at NGen time
-// we embed a WinRT dependency as assembly def name component plus a namespace and type from it.
-// At bind time, this type should still exist in the same assembly.  If it doesn't, and has been moved,
-// the native image validation will fail anyway and we'll fall back to IL.  This is because if the type has 
-// been moved to another WinMD, it must have been removed from the first one because WinRT allows no duplicates.
-// This no duplicate rule is obviously not actually gauranteed by the WinRT runtime for 3rd party assemblies,
-// but violating the rule is known to cause a number of binding behavior errors that we do not attempt to protect against.
-HRESULT 
-CLRPrivBinderWinRT::PreBind(
-    IAssemblyName * pAssemblyName, 
-    DWORD           dwPreBindFlags, 
-    IBindResult **  ppIBindResult)
-{
-    STANDARD_VM_CONTRACT;
-    HRESULT hr  = S_OK;
-    
-    // Assert that we are only working with a binder that supports native images
-    _ASSERTE(m_fCanUseNativeImages);
-    
-    ReleaseHolder<IBindContext> pIBindContext;
-    IfFailRet(GetParentIBindContext(&pIBindContext));
-    
-    DWORD dwContentType = AssemblyContentType_Default;
-    DWORD cbContentTypeSize = sizeof(dwContentType);
-    IfFailRet(pAssemblyName->GetProperty(ASM_NAME_CONTENT_TYPE, &dwContentType, &cbContentTypeSize));
-
-    if (dwContentType == AssemblyContentType_Default)
-    {
-        hr = pIBindContext->PreBind(pAssemblyName, dwPreBindFlags, ppIBindResult);
-    }
-    else
-    {
-        hr = BindWinRTAssemblyByName(pAssemblyName, ppIBindResult, TRUE);
-    }
-    
-    return hr;
-}
-
-//=====================================================================================================================
-// Implements interface method code:IBindContext::IsDefaultContext.
-// 
-HRESULT 
-CLRPrivBinderWinRT::IsDefaultContext()
-{
-    LIMITED_METHOD_CONTRACT;
-    return S_OK;
-}
-#endif
 
 //=====================================================================================================================
 CLRPrivAssemblyWinRT::CLRPrivAssemblyWinRT(
@@ -1470,21 +1085,6 @@ HRESULT CLRPrivAssemblyWinRT::GetAvailableImageTypes(
     return hr;
 }
 
-#ifdef FEATURE_FUSION
-static ICLRPrivResource * GetResourceForBindResult(
-    IBindResult * pIBindResult)
-{
-    STANDARD_VM_CONTRACT;
-    VALIDATE_ARG_THROW(pIBindResult != nullptr);
-
-    WCHAR wzPath[_MAX_PATH];
-    DWORD cchPath = NumItems(wzPath);
-    ReleaseHolder<IAssemblyLocation> pIAssemLoc;
-    IfFailThrow(pIBindResult->GetAssemblyLocation(&pIAssemLoc));
-    IfFailThrow(pIAssemLoc->GetPath(wzPath, &cchPath));
-    return ToInterface<ICLRPrivResource>(new CLRPrivResourcePathImpl(wzPath));
-}
-#endif
 
 //=====================================================================================================================
 // Implements interface method code:ICLRPrivAssembly::GetImageResource.
@@ -1573,7 +1173,6 @@ HRESULT CLRPrivBinderWinRT::GetBinderID(
     return S_OK;
 }
 
-#if defined(FEATURE_CORECLR) || defined(CROSSGEN_COMPILE)
 //=====================================================================================================================
 HRESULT CLRPrivBinderWinRT::FindWinRTAssemblyBySpec(
     LPVOID pvAppDomain,
@@ -1584,68 +1183,7 @@ HRESULT CLRPrivBinderWinRT::FindWinRTAssemblyBySpec(
     STATIC_CONTRACT_WRAPPER;
     return E_FAIL; 
 }
-#endif
 
-#ifdef FEATURE_FUSION
-//=====================================================================================================================
-HRESULT CLRPrivBinderWinRT::FindWinRTAssemblyBySpec(
-    LPVOID pvAppDomain,
-    LPVOID pvAssemblySpec,
-    HRESULT * pResult,
-    ICLRPrivAssembly ** ppAssembly)
-{
-    LIMITED_METHOD_CONTRACT;;
-    HRESULT hr = S_OK;
-
-    AppDomain* pAppDomain = reinterpret_cast<AppDomain*>(pvAppDomain);
-    AssemblySpec* pAssemblySpec = reinterpret_cast<AssemblySpec*>(pvAssemblySpec);
-    VALIDATE_PTR_RET(pAppDomain);
-    VALIDATE_PTR_RET(pAssemblySpec);
-    VALIDATE_PTR_RET(pResult);
-    VALIDATE_PTR_RET(ppAssembly);
-
-    if (pAssemblySpec->IsContentType_WindowsRuntime())
-    {
-        // FindAssemblyBySpec is not supported by this binder.
-        *pResult = CLR_E_BIND_TYPE_NOT_FOUND;
-        *ppAssembly = nullptr;
-        return S_OK;
-    }
-    else
-    {
-        return CLR_E_BIND_UNRECOGNIZED_IDENTITY_FORMAT;
-    }
-}
-
-//=====================================================================================================================
-HRESULT CLRPrivBinderWinRT::GetParentIBindContext(
-    IBindContext **ppIBindContext)
-{
-    STANDARD_BIND_CONTRACT;
-    VALIDATE_ARG_RET(ppIBindContext != nullptr);
-
-    HRESULT hr = S_OK;
-
-    if (m_pParentBinder != nullptr)
-    {
-        _ASSERTE(AppX::IsAppXProcess());
-        IfFailRet(m_pParentBinder->QueryInterface(__uuidof(IBindContext), (void**)ppIBindContext));
-    }
-    else
-    {
-        _ASSERTE(!AppX::IsAppXProcess());
-        EX_TRY
-        {
-            AppDomain* pDomain = AppDomain::GetCurrentDomain();
-            hr = GetBindContextFromApplicationContext(pDomain->CreateFusionContext(), ppIBindContext);
-        }
-        EX_CATCH_HRESULT(hr);
-    }
-
-    _ASSERTE(FAILED(hr) || *ppIBindContext != nullptr);
-    return hr;
-}
-#endif
 
 //=====================================================================================================================
 HRESULT CLRPrivAssemblyWinRT::GetIBindResult(
@@ -1672,29 +1210,14 @@ HRESULT CLRPrivAssemblyWinRT::EnsureAvailableImageTypes()
     // If image types has not yet been set, attempt to bind to native assembly
     if (dwImageTypesLocal == 0)
     {
-#ifdef FEATURE_FUSION
-        CLRPrivBinderWinRT *pBinder = m_pBinder;
-        IfFailGo(pBinder->BindAssemblyToNativeAssembly(this));
-#endif
         if (m_pIResourceNI == nullptr)
         {
-#ifdef FEATURE_FUSION
-            ReleaseHolder<IBindResult> pIBindResultNI;
-
-            if (SUCCEEDED(hr = m_pIBindResult->GetNativeImage(&pIBindResultNI, nullptr)) && pIBindResultNI != nullptr)
-            {
-                ReleaseHolder<ICLRPrivResource> pResourceNI = GetResourceForBindResult(pIBindResultNI);
-                if (InterlockedCompareExchangeT<ICLRPrivResource *>(&m_pIResourceNI, pResourceNI, nullptr) == nullptr)
-                    pResourceNI.SuppressRelease();
-            }
-#else
             if (m_pIBindResult->HasNativeImage())
             {
                 SString sPath = m_pIBindResult->GetNativeImage()->GetPath();
                 m_pIResourceNI = new CLRPrivResourcePathImpl(sPath.GetUnicode());
                 m_pIResourceNI->AddRef();
             }
-#endif
             IfFailGo(hr);
         }
 
diff --git a/src/vm/clrprivbinderwinrt.h b/src/vm/clrprivbinderwinrt.h
index caaefff6d2..14c467044b 100644
--- a/src/vm/clrprivbinderwinrt.h
+++ b/src/vm/clrprivbinderwinrt.h
@@ -21,21 +21,17 @@
 #include "winrt/windowsstring.h"
 #include "appxutil.h"
 
-#ifndef FEATURE_FUSION
 #include "coreclr/corebindresult.h"
 
 // IBindResult maps directly to its one and only implementation on CoreCLR.
 typedef CoreBindResult IBindResult;
-#endif // FEATURE_FUSION
 
 //=====================================================================================================================
 // Forward declarations
 class CLRPrivBinderWinRT;
 class CLRPrivAssemblyWinRT;
-#ifdef FEATURE_CORECLR
 class BINDER_SPACE::ApplicationContext;
 class BINDER_SPACE::Assembly;
-#endif
 
 typedef DPTR(CLRPrivBinderWinRT)     PTR_CLRPrivBinderWinRT;
 typedef DPTR(CLRPrivAssemblyWinRT)   PTR_CLRPrivAssemblyWinRT;
@@ -48,9 +44,6 @@ IsWindowsNamespace(const char * wszNamespace);
 //=====================================================================================================================
 class CLRPrivBinderWinRT : 
     public IUnknownCommon<ICLRPrivBinder
-#ifdef FEATURE_FUSION
-     , IBindContext
-#endif //FEATURE_FUSION
     >
 {
     friend class CLRPrivAssemblyWinRT;
@@ -189,19 +182,6 @@ public:
         HRESULT * pResult,
         ICLRPrivAssembly ** ppAssembly);
 
-#ifdef FEATURE_FUSION	
-    //=============================================================================================
-    // IBindContext interface methods
-    
-    // Implements interface method code:IBindContext::PreBind.
-    STDMETHOD(PreBind)(
-        IAssemblyName * pIAssemblyName, 
-        DWORD           dwPreBindFlags, 
-        IBindResult **  ppIBindResult);
-    
-    // Implements interface method code:IBindContext::IsDefaultContext.
-    STDMETHOD(IsDefaultContext)();
-#endif //FEATURE_FUSION
 
     //=============================================================================================
     // Class methods
@@ -239,15 +219,11 @@ public:
         IBindResult ** ppIBindResult,
         BOOL fPreBind = FALSE);
 
-#ifndef FEATURE_FUSION
     HRESULT GetAssemblyAndTryFindNativeImage(SString &sWinmdFilename, LPCWSTR pwzSimpleName, BINDER_SPACE::Assembly ** ppAssembly);
-#endif
-#ifdef FEATURE_CORECLR
     // On Phone the application's APP_PATH CoreCLR hosting config property is used as the app
     // package graph for RoResolveNamespace to find 3rd party WinMDs.  This method wires up
     // the app paths so the WinRT binder will find 3rd party WinMDs.
     HRESULT SetApplicationContext(BINDER_SPACE::ApplicationContext *pApplicationContext, SString &appLocalWinMD);
-#endif
     // Finds assembly with WinRT type if it is already loaded
     // Note: This method could implement interface code:ICLRPrivWinRtTypeBinder if it is ever needed
     PTR_Assembly FindAssemblyForTypeIfLoaded(
@@ -255,9 +231,6 @@ public:
         LPCUTF8       szNamespace, 
         LPCUTF8       szClassName);
 
-#if defined(FEATURE_COMINTEROP_WINRT_DESKTOP_HOST) && !defined(CROSSGEN_COMPILE)
-    BOOL SetLocalWinMDPath(HSTRING localWinMDPath);
-#endif // FEATURE_COMINTEROP_WINRT_DESKTOP_HOST && !CROSSGEN_COMPILE
 
 private:
     //=============================================================================================
@@ -286,9 +259,6 @@ private:
         CLRPrivBinderUtil::WStringList *  pFileNameList, 
         CLRPrivBinderUtil::WStringList ** ppFileNameList);
     
-#ifdef FEATURE_FUSION
-    HRESULT BindAssemblyToNativeAssembly(CLRPrivAssemblyWinRT *pAssembly);
-#endif
 
 private:
     //=============================================================================================
@@ -320,30 +290,11 @@ private:
     CLRPrivBinderUtil::HSTRINGArrayHolder m_rgAltPaths;
 #endif
 
-#ifdef FEATURE_FUSION
-    // Native binder assisting logic
-    BOOL m_fCanUseNativeImages;
-
-    ReleaseHolder<IILFingerprintFactory> m_pFingerprintFactory;
-#endif
 
-#ifdef FEATURE_FUSION
-    HRESULT GetParentIBindContext(IBindContext **ppIBindContext);
-#endif //FEATURE_FUSION
 
-#ifdef FEATURE_CORECLR
     BINDER_SPACE::ApplicationContext * m_pApplicationContext;
     NewArrayHolder<WCHAR> m_appLocalWinMDPath;
-#endif
 
-#ifdef FEATURE_COMINTEROP_WINRT_DESKTOP_HOST
-    // App-local location that can be probed for WinMD files
-    BOOL m_fCanSetLocalWinMDPath;
-    CrstExplicitInit m_localWinMDPathLock;
-#ifndef CROSSGEN_COMPILE
-    clr::winrt::String m_localWinMDPath;
-#endif // !CROSSGEN_COMPILE
-#endif // FEATURE_COMINTEROP_WINRT_DESKTOP_HOST
 
 };  // class CLRPrivBinderWinRT
 
diff --git a/src/vm/clrprivtypecachereflectiononlywinrt.cpp b/src/vm/clrprivtypecachereflectiononlywinrt.cpp
deleted file mode 100644
index 40f90dfe3f..0000000000
--- a/src/vm/clrprivtypecachereflectiononlywinrt.cpp
+++ /dev/null
@@ -1,260 +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.
-// 
-
-// 
-// Contains VM implementation of WinRT type cache for code:CLRPrivBinderReflectionOnlyWinRT binder.
-// 
-//=====================================================================================================================
-
-#include "common.h" // precompiled header
-
-#ifndef DACCESS_COMPILE
-#ifdef FEATURE_REFLECTION_ONLY_LOAD
-
-#include "clrprivtypecachereflectiononlywinrt.h"
-#include <typeresolution.h>
-
-//=====================================================================================================================
-// S_OK - pAssembly contains type wszTypeName
-// S_FALSE - pAssembly does not contain type wszTypeName
-// 
-HRESULT 
-CLRPrivTypeCacheReflectionOnlyWinRT::ContainsType(
-    ICLRPrivAssembly * pPrivAssembly, 
-    LPCWSTR            wszTypeName)
-{
-    STANDARD_VM_CONTRACT;
-    
-    HRESULT hr = S_OK;
-    
-    AppDomain * pAppDomain = AppDomain::GetCurrentDomain();
-
-    ReleaseHolder<PEAssembly> pPEAssembly;
-    IfFailGo(pAppDomain->BindHostedPrivAssembly(nullptr, pPrivAssembly, nullptr, &pPEAssembly, TRUE));
-    _ASSERTE(pPEAssembly != nullptr);
-    
-    {
-        // Find DomainAssembly * (can be cached if this is too slow to call always)
-        DomainAssembly * pDomainAssembly = pAppDomain->LoadDomainAssembly(
-            nullptr,    // pIdentity
-            pPEAssembly, 
-            FILE_LOADED, 
-            nullptr);   // pLoadSecurity
-        
-        // Convert the type name into namespace and type names in UTF8
-        StackSString ssTypeNameWCHAR(wszTypeName);
-        
-        StackSString ssTypeName;
-        ssTypeNameWCHAR.ConvertToUTF8(ssTypeName);
-        LPUTF8 szTypeName = (LPUTF8)ssTypeName.GetUTF8NoConvert();
-        
-        LPCUTF8 szNamespace;
-        LPCUTF8 szClassName;
-        ns::SplitInline(szTypeName, szNamespace, szClassName);
-        
-        NameHandle typeName(szNamespace, szClassName);
-        
-        // Find the type in the assembly (use existing hash of all type names defined in the assembly)
-        TypeHandle thType;
-        mdToken    tkType;
-        Module *   pTypeModule;
-        mdToken    tkExportedType;
-        if (pDomainAssembly->GetAssembly()->GetLoader()->FindClassModuleThrowing(
-            &typeName, 
-            &thType, 
-            &tkType, 
-            &pTypeModule, 
-            &tkExportedType, 
-            nullptr,    // ppClassHashEntry
-            nullptr,    // pLookInThisModuleOnly
-            Loader::DontLoad))
-        {   // The type is present in the assembly
-            hr = S_OK;
-        }
-        else
-        {   // The type is not present in the assembly
-            hr = S_FALSE;
-        }
-    }
-    
-ErrExit:
-    return hr;
-} // CLRPrivTypeCacheReflectionOnlyWinRT::ContainsType
-
-//=====================================================================================================================
-// Raises user event NamespaceResolveEvent to get a list of files for this namespace.
-// 
-void 
-CLRPrivTypeCacheReflectionOnlyWinRT::RaiseNamespaceResolveEvent(
-    LPCWSTR                                wszNamespace, 
-    DomainAssembly *                       pParentAssembly, 
-    CLRPrivBinderUtil::WStringListHolder * pFileNameList)
-{
-    STANDARD_VM_CONTRACT;
-    
-    _ASSERTE(pFileNameList != nullptr);
-    
-    AppDomain * pAppDomain = AppDomain::GetCurrentDomain();
-    
-    GCX_COOP();
-    
-    struct _gc {
-        OBJECTREF AppDomainRef;
-        OBJECTREF AssemblyRef;
-        STRINGREF str;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-    
-    GCPROTECT_BEGIN(gc);
-    if ((gc.AppDomainRef = pAppDomain->GetRawExposedObject()) != NULL)
-    {
-        if (pParentAssembly != nullptr)
-        {
-            gc.AssemblyRef = pParentAssembly->GetExposedAssemblyObject();
-        }
-        
-        MethodDescCallSite onNamespaceResolve(METHOD__APP_DOMAIN__ON_REFLECTION_ONLY_NAMESPACE_RESOLVE, &gc.AppDomainRef);
-        gc.str = StringObject::NewString(wszNamespace);
-        ARG_SLOT args[3] =
-        {
-            ObjToArgSlot(gc.AppDomainRef),
-            ObjToArgSlot(gc.AssemblyRef),
-            ObjToArgSlot(gc.str)
-        };
-        PTRARRAYREF ResultingAssemblyArrayRef = (PTRARRAYREF) onNamespaceResolve.Call_RetOBJECTREF(args);
-        if (ResultingAssemblyArrayRef != NULL)
-        {
-            for (DWORD i = 0; i < ResultingAssemblyArrayRef->GetNumComponents(); i++)
-            {
-                ASSEMBLYREF ResultingAssemblyRef = (ASSEMBLYREF) ResultingAssemblyArrayRef->GetAt(i);
-                Assembly * pAssembly = ResultingAssemblyRef->GetAssembly();
-                
-                if (pAssembly->IsCollectible())
-                {
-                    COMPlusThrow(kNotSupportedException, W("NotSupported_CollectibleAssemblyResolve"));
-                }
-                
-                PEAssembly * pPEAssembly = pAssembly->GetManifestFile();
-                
-                ICLRPrivAssembly * pPrivAssembly = pPEAssembly->GetHostAssembly();
-                if ((pPrivAssembly == NULL) || !IsAfContentType_WindowsRuntime(pPEAssembly->GetFlags()))
-                {
-                    COMPlusThrow(kNotSupportedException, IDS_EE_REFLECTIONONLY_WINRT_INVALIDASSEMBLY);
-                }
-                
-                pFileNameList->InsertTail(pPEAssembly->GetILimage()->GetPath());
-            }
-        }
-    }
-    GCPROTECT_END();
-} // CLRPrivTypeCacheReflectionOnlyWinRT::RaiseNamespaceResolveEvent
-
-//=====================================================================================================================
-// Implementation of QCall System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMetadata.nResolveNamespace
-// It's basically a PInvoke wrapper into Win8 API RoResolveNamespace
-// 
-void 
-QCALLTYPE 
-CLRPrivTypeCacheReflectionOnlyWinRT::ResolveNamespace(
-    LPCWSTR                    wszNamespace, 
-    LPCWSTR                    wszWindowsSdkPath, 
-    LPCWSTR *                  rgPackageGraphPaths, 
-    INT32                      cPackageGraphPaths, 
-    QCall::ObjectHandleOnStack retFileNames)
-{
-    QCALL_CONTRACT;
-    
-    _ASSERTE(wszNamespace != nullptr);
-    
-    BEGIN_QCALL;
-    
-    CoTaskMemHSTRINGArrayHolder hFileNames;
-    
-    if (!WinRTSupported())
-    {
-        IfFailThrow(COR_E_PLATFORMNOTSUPPORTED);
-    }
-    
-    {
-        CLRPrivBinderUtil::HSTRINGArrayHolder rgPackageGraph;
-        rgPackageGraph.Allocate(cPackageGraphPaths);
-        
-        LPCWSTR wszNamespaceRoResolve = wszNamespace;
-
-        for (INT32 i = 0; i < cPackageGraphPaths; i++)
-        {
-            _ASSERTE(rgPackageGraph.GetRawArray()[i] == nullptr);
-            WinRtString hsPackageGraphPath;
-            IfFailThrow(hsPackageGraphPath.Initialize(rgPackageGraphPaths[i]));
-            hsPackageGraphPath.Detach(&rgPackageGraph.GetRawArray()[i]);
-        }
-
-        UINT32 cchNamespace, cchWindowsSdkPath;
-        IfFailThrow(StringCchLength(wszNamespace, &cchNamespace));
-        IfFailThrow(StringCchLength(wszWindowsSdkPath, &cchWindowsSdkPath));
-        
-        DWORD     cFileNames = 0;
-        HSTRING * rgFileNames = nullptr;
-        HRESULT hr = RoResolveNamespace(
-            WinRtStringRef(wszNamespace, cchNamespace),
-            WinRtStringRef(wszWindowsSdkPath, cchWindowsSdkPath),
-            rgPackageGraph.GetCount(), 
-            rgPackageGraph.GetRawArray(), 
-            &cFileNames, 
-            &rgFileNames, 
-            nullptr,    // pcDirectNamespaceChildren
-            nullptr);   // rgDirectNamespaceChildren
-        hFileNames.Init(rgFileNames, cFileNames);
-        
-        if (hr == HRESULT_FROM_WIN32(APPMODEL_ERROR_NO_PACKAGE))
-        {   // User tried to resolve 3rd party namespace without passing package graph - throw InvalidOperationException with custom message
-            _ASSERTE(cPackageGraphPaths == 0);
-            COMPlusThrow(kInvalidOperationException, IDS_EE_REFLECTIONONLY_WINRT_LOADFAILURE_THIRDPARTY);
-        }
-        IfFailThrow(hr);
-        if (hr != S_OK)
-        {
-            IfFailThrow(E_UNEXPECTED);
-        }
-    }
-    
-    {
-        GCX_COOP();
-        
-        PTRARRAYREF orFileNames = NULL;
-        GCPROTECT_BEGIN(orFileNames);
-        
-        orFileNames = (PTRARRAYREF) AllocateObjectArray(hFileNames.GetCount(), g_pStringClass);
-        
-        for (DWORD i = 0; i < hFileNames.GetCount(); i++)
-        {
-            UINT32  cchFileName = 0;
-
-            HSTRING hsFileName = hFileNames.GetAt(i);
-            LPCWSTR wszFileName;
-            
-            if (hsFileName != nullptr)
-            {
-                wszFileName = WindowsGetStringRawBuffer(
-                    hsFileName, 
-                    &cchFileName);
-            
-                STRINGREF str = StringObject::NewString(wszFileName);
-                orFileNames->SetAt(i, str);
-            }
-        }
-        
-        retFileNames.Set(orFileNames);
-        
-        GCPROTECT_END();
-    }
-    
-    END_QCALL;
-} // CLRPrivTypeCacheReflectionOnlyWinRT::ResolveNamespace
-
-//=====================================================================================================================
-
-#endif //FEATURE_REFLECTION_ONLY_LOAD
-#endif //!DACCESS_COMPILE
diff --git a/src/vm/clrprivtypecachereflectiononlywinrt.h b/src/vm/clrprivtypecachereflectiononlywinrt.h
deleted file mode 100644
index a605c3dc2e..0000000000
--- a/src/vm/clrprivtypecachereflectiononlywinrt.h
+++ /dev/null
@@ -1,58 +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.
-// 
-
-// 
-// Contains VM implementation of code:ICLRPrivTypeCacheReflectionOnlyWinRT for code:CLRPrivBinderReflectionOnlyWinRT binder.
-// 
-//=====================================================================================================================
-
-#ifdef FEATURE_REFLECTION_ONLY_LOAD
-
-#pragma once
-
-#include "internalunknownimpl.h"
-#include "clrprivbinding.h"
-
-//=====================================================================================================================
-// Forward declarations
-class DomainAssembly;
-
-//=====================================================================================================================
-class CLRPrivTypeCacheReflectionOnlyWinRT : 
-    public IUnknownCommon<IUnknown>
-{
-public:
-    //=============================================================================================
-    // Class methods
-    
-    // S_OK - pAssembly contains type wszTypeName
-    // S_FALSE - pAssembly does not contain type wszTypeName
-    STDMETHOD(ContainsType)(
-        ICLRPrivAssembly * pAssembly, 
-        LPCWSTR            wszTypeName);
-    
-#ifndef DACCESS_COMPILE
-    
-    // Raises user event NamespaceResolveEvent to get a list of files for this namespace.
-    void RaiseNamespaceResolveEvent(
-        LPCWSTR                                wszNamespace, 
-        DomainAssembly *                       pParentAssembly, 
-        CLRPrivBinderUtil::WStringListHolder * pFileNameList);
-
-#endif //!DACCESS_COMPILE
-    
-    // Implementation of QCall System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMetadata.nResolveNamespace
-    // It's basically a PInvoke wrapper into Win8 API RoResolveNamespace
-    static 
-    void QCALLTYPE ResolveNamespace(
-        LPCWSTR                    wszNamespace, 
-        LPCWSTR                    wszWindowsSdkPath, 
-        LPCWSTR *                  rgPackageGraphPaths, 
-        INT32                      cPackageGraphPaths, 
-        QCall::ObjectHandleOnStack retFileNames);
-    
-};  // class CLRPrivTypeCaheReflectionOnlyWinRT
-
-#endif //FEATURE_REFLECTION_ONLY_LOAD
diff --git a/src/vm/clsload.cpp b/src/vm/clsload.cpp
index fe74bf8a6f..7802521228 100644
--- a/src/vm/clsload.cpp
+++ b/src/vm/clsload.cpp
@@ -52,9 +52,6 @@
 #include "virtualcallstub.h"
 #include "stringarraylist.h"
 
-#if defined(FEATURE_FUSION) && !defined(DACCESS_COMPILE)
-#include "policy.h" // For Fusion::Util::IsAnyFrameworkAssembly
-#endif
 
 // This method determines the "loader module" for an instantiated type
 // or method. The rule must ensure that any types involved in the
@@ -4620,24 +4617,7 @@ VOID ClassLoader::AddAvailableClassHaveLock(
                 // However, this used to be allowed in 1.0/1.1, and some third-party DLLs have
                 // been obfuscated so that they have duplicate private typedefs.
                 // We must allow this for old assemblies for app compat reasons
-#ifdef FEATURE_CORECLR
                 pModule->GetAssembly()->ThrowBadImageException(pszNameSpace, pszName, BFA_MULT_TYPE_SAME_NAME);
-#else
-                LPCSTR pszVersion = NULL;
-                if (FAILED(pModule->GetMDImport()->GetVersionString(&pszVersion)))
-                {
-                    pModule->GetAssembly()->ThrowBadImageException(pszNameSpace, pszName, BFA_MULT_TYPE_SAME_NAME);
-                }
-                
-                SString ssVersion(SString::Utf8, pszVersion);
-                SString ssV1(SString::Literal, "v1.");
-
-                AdjustImageRuntimeVersion(&ssVersion);
-
-                // If not "v1.*", throw an exception
-                if (!ssVersion.BeginsWith(ssV1))
-                    pModule->GetAssembly()->ThrowBadImageException(pszNameSpace, pszName, BFA_MULT_TYPE_SAME_NAME);
-#endif
             }
         }
         else {
@@ -4914,41 +4894,6 @@ bool StaticAccessCheckContext::IsCallerCritical()
 }
 
 
-#ifndef FEATURE_CORECLR
-
-//******************************************************************************
-// This function determines whether a Type is accessible from
-//  outside of the assembly it lives in.
-
-static BOOL IsTypeVisibleOutsideAssembly(MethodTable* pMT)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-    DWORD dwProtection;
-        // check all types in nesting chain, while inner types are public
-    while (IsTdPublic(dwProtection = pMT->GetClass()->GetProtection()) ||
-           IsTdNestedPublic(dwProtection))
-    {
-        // if type is nested, check outer type, too
-        if (IsTdNested(dwProtection))
-        {
-            pMT = GetEnclosingMethodTable(pMT);
-        }
-        // otherwise, type is visible outside of the assembly
-        else
-        {
-            return TRUE;
-        }
-    }
-    return FALSE;
-} // static BOOL IsTypeVisibleOutsideAssembly(MethodTable* pMT)
-
-#endif //!FEATURE_CORECLR
 
 //******************************************************************************
 
@@ -5031,7 +4976,6 @@ BOOL AccessCheckOptions::DemandMemberAccess(AccessCheckContext *pContext, Method
     BOOL canAccessTarget = FALSE;
 
 #ifndef CROSSGEN_COMPILE
-#ifdef FEATURE_CORECLR
 
     BOOL fAccessingFrameworkCode = FALSE;
 
@@ -5079,102 +5023,6 @@ BOOL AccessCheckOptions::DemandMemberAccess(AccessCheckContext *pContext, Method
         ThrowAccessException(pContext, pTargetMT, NULL, fAccessingFrameworkCode);
     }
 
-#else // FEATURE_CORECLR
-
-    GCX_COOP();
-
-    // Overriding the rules of visibility checks in Win8 immersive: no access is allowed to internal
-    // code in the framework even in full trust, unless the caller is also framework code.
-    if ( (m_accessCheckType == kUserCodeOnlyRestrictedMemberAccess ||
-          m_accessCheckType == kUserCodeOnlyRestrictedMemberAccessNoTransparency) &&
-        visibilityCheck )
-    {
-        IAssemblyName *pIAssemblyName = pTargetMT->GetAssembly()->GetFusionAssemblyName();
-
-        HRESULT hr = Fusion::Util::IsAnyFrameworkAssembly(pIAssemblyName);
-
-        // S_OK: pIAssemblyName is a framework assembly.
-        // S_FALSE: pIAssemblyName is not a framework assembly.
-        // Other values: pIAssemblyName is an invalid name. 
-        if (hr == S_OK)
-        {
-            if (pContext->IsCalledFromInterop())
-                return TRUE;
-
-            // If the caller method is NULL and we are not called from interop
-            // this is not a normal method access check (e.g. a CA accessibility check)
-            // The access check should fail in this case.
-            hr = S_FALSE;
-
-            MethodDesc* pCallerMD = pContext->GetCallerMethod();
-            if (pCallerMD != NULL)
-            {
-                pIAssemblyName = pCallerMD->GetAssembly()->GetFusionAssemblyName();
-                hr = Fusion::Util::IsAnyFrameworkAssembly(pIAssemblyName);
-            }
-
-            // The caller is not framework code.
-            if (hr != S_OK)
-            {
-                if (m_fThrowIfTargetIsInaccessible)
-                    ThrowAccessException(pContext, pTargetMT, NULL, TRUE);
-                else
-                    return FALSE;
-            }
-        }
-    }
-
-    EX_TRY
-    {
-        if (m_accessCheckType == kMemberAccess)
-        {
-            Security::SpecialDemand(SSWT_LATEBOUND_LINKDEMAND, REFLECTION_MEMBER_ACCESS);
-        }
-        else
-        {
-            _ASSERTE(m_accessCheckType == kRestrictedMemberAccess || 
-                     m_accessCheckType == kUserCodeOnlyRestrictedMemberAccess ||
-                     (m_accessCheckType == kUserCodeOnlyRestrictedMemberAccessNoTransparency && visibilityCheck));
-
-            // JIT guarantees that pTargetMT has been fully loaded and ready to execute by this point, but reflection doesn't. 
-            // So GetSecurityDescriptor could AV because the DomainAssembly cannot be found. 
-            // For now we avoid this by calling EnsureActive aggressively. We might want to move this to the reflection code in the future:
-            // ReflectionInvocation::PerformVisibilityCheck, PerformSecurityCheckHelper, COMDelegate::BindToMethodName/Info, etc.
-            // We don't need to call EnsureInstanceActive because we will be doing access check on all the generic arguments any way so
-            // EnsureActive will be called on everyone of them if needed.
-            pTargetMT->EnsureActive();
-
-            IAssemblySecurityDescriptor * pTargetSecurityDescriptor = pTargetMT->GetModule()->GetSecurityDescriptor();
-            _ASSERTE(pTargetSecurityDescriptor != NULL);
-
-            if (m_pAccessContext != NULL)
-            {
-                // If we have a context, use it to do the demand
-                Security::ReflectionTargetDemand(REFLECTION_MEMBER_ACCESS,
-                    pTargetSecurityDescriptor,
-                    m_pAccessContext);
-            }
-            else
-            {
-                // Just do a normal Demand
-                Security::ReflectionTargetDemand(REFLECTION_MEMBER_ACCESS, pTargetSecurityDescriptor);
-            }
-        }
-
-        canAccessTarget = TRUE;
-    }
-    EX_CATCH 
-    {
-        canAccessTarget = FALSE;
-
-        if (m_fThrowIfTargetIsInaccessible)
-        {
-            ThrowAccessException(pContext, pTargetMT, GET_EXCEPTION());
-        } 
-    }
-    EX_END_CATCH(RethrowTerminalExceptions);
-
-#endif // FEATURE_CORECLR
 #endif // CROSSGEN_COMPILE
 
     return canAccessTarget;
@@ -5335,55 +5183,7 @@ void GetAccessExceptionAdditionalContextForSecurity(Assembly *pAccessingAssembly
         pContextInformation->Append(accessingFrameworkCodeError);
     }
 
-#ifndef FEATURE_CORECLR
-    if (isTransparencyError)
-    {
-        ModuleSecurityDescriptor *pMSD = ModuleSecurityDescriptor::GetModuleSecurityDescriptor(pAccessingAssembly);
-
-        // If the accessing assembly is APTCA and using level 2 transparency, then transparency errors may be
-        // because APTCA newly opts assemblies into being all transparent.
-        if (pMSD->IsMixedTransparency() && !pAccessingAssembly->GetSecurityTransparencyBehavior()->DoesUnsignedImplyAPTCA())
-        {
-            SString callerDisplayName;
-            pAccessingAssembly->GetDisplayName(callerDisplayName);
-
-            SString level2AptcaTransparencyError;
-            EEException::GetResourceMessage(IDS_ACCESS_EXCEPTION_CONTEXT_LEVEL2_APTCA, level2AptcaTransparencyError, callerDisplayName);
-
-            pContextInformation->Append(level2AptcaTransparencyError);
-        }
-
-        // If the assessing assembly is fully transparent and it is partially trusted, then transparency
-        // errors may be because the CLR forced the assembly to be transparent due to its trust level.
-        if (pMSD->IsAllTransparentDueToPartialTrust())
-        {
-            _ASSERTE(pMSD->IsAllTransparent());
-            SString callerDisplayName;
-            pAccessingAssembly->GetDisplayName(callerDisplayName);
 
-            SString partialTrustTransparencyError;
-            EEException::GetResourceMessage(IDS_ACCESS_EXCEPTION_CONTEXT_PT_TRANSPARENT, partialTrustTransparencyError, callerDisplayName);
-
-            pContextInformation->Append(partialTrustTransparencyError);
-        }
-    }
-#endif // FEATURE_CORECLR
-
-#if defined(FEATURE_APTCA) && !defined(CROSSGEN_COMPILE)
-    // If the target assembly is conditionally APTCA, then it may needed to have been enabled in the domain
-    SString conditionalAptcaContext = Security::GetConditionalAptcaAccessExceptionContext(pTargetAssembly);
-    if (!conditionalAptcaContext.IsEmpty())
-    {
-        pContextInformation->Append(conditionalAptcaContext);
-    }
-
-    // If the target assembly is APTCA killbitted, then indicate that as well
-    SString aptcaKillBitContext = Security::GetAptcaKillBitAccessExceptionContext(pTargetAssembly);
-    if (!aptcaKillBitContext.IsEmpty())
-    {
-        pContextInformation->Append(aptcaKillBitContext);
-    }
-#endif // FEATURE_APTCA && !CROSSGEN_COMPILE
 }
 
 // Generate additional context about the root cause of an access exception which may help in debugging it (for
@@ -5690,18 +5490,6 @@ static BOOL CheckTransparentAccessToCriticalCode(
                    (pOptionalTargetField ? 1 : 0) +
                    (pOptionalTargetType ? 1 : 0)));
 
-#ifndef FEATURE_CORECLR
-    if (pTargetMT->GetAssembly()->GetSecurityTransparencyBehavior()->DoesPublicImplyTreatAsSafe())
-    {
-        // @ telesto: public => TAS in non-coreclr only. The intent is to remove this ifdef and remove
-        // public => TAS in all flavors/branches.
-        // check if the Target member accessible outside the assembly
-        if (IsMdPublic(dwMemberAccess) && IsTypeVisibleOutsideAssembly(pTargetMT))
-        {
-            return TRUE;
-        }
-    }
-#endif // !FEATURE_CORECLR
 
     // if the caller [Method] is transparent, do special security checks
     // check if security disallows access to target member
diff --git a/src/vm/clsload.hpp b/src/vm/clsload.hpp
index a3a0de3cf4..2ee6524a7b 100644
--- a/src/vm/clsload.hpp
+++ b/src/vm/clsload.hpp
@@ -408,19 +408,6 @@ public:
         // CoreCLR: Do RestrictedMemberAcess visibility checks but bypass transparency checks.
         kRestrictedMemberAccessNoTransparency,
 
-#ifndef FEATURE_CORECLR
-        // Used by DynamicMethod with kRestrictedMemberAccess in Win8 immersive mode.
-        // Desktop: Equals kNormalAccessibilityChecks for non-framework code calling framework code,
-        //          kRestrictedMemberAccess otherwise.
-        kUserCodeOnlyRestrictedMemberAccess,
-
-        // A variation of kUserCodeOnlyRestrictedMemberAccess, but without transparency checks.
-        // This is used for reflection invocation in Win8 immersive when all domains on the call stack is full trust.
-        // This is an optimization to avoid stackwalks for transparency checks in full trust.
-        // Note that both kUserCodeOnlyRestrictedMemberAccess and kUserCodeOnlyRestrictedMemberAccessNoTransparency
-        // are needed because we restrict user code from accessing framework internals in Win8 immersive even in full trust.
-        kUserCodeOnlyRestrictedMemberAccessNoTransparency
-#endif
     };
 
     AccessCheckOptions(
@@ -472,11 +459,7 @@ public:
     BOOL TransparencyCheckNeeded() const
     {
         LIMITED_METHOD_CONTRACT;
-#ifdef FEATURE_CORECLR
         return (m_accessCheckType != kNormalAccessNoTransparency && m_accessCheckType != kRestrictedMemberAccessNoTransparency);
-#else //FEATURE_CORECLR
-        return (m_accessCheckType != kUserCodeOnlyRestrictedMemberAccessNoTransparency);
-#endif //FEATURE_CORECLR
     }
 
     static AccessCheckOptions* s_pNormalAccessChecks;
diff --git a/src/vm/clsload.inl b/src/vm/clsload.inl
index a362d5a3db..991498ec9c 100644
--- a/src/vm/clsload.inl
+++ b/src/vm/clsload.inl
@@ -80,14 +80,8 @@ inline void AccessCheckOptions::Initialize(
                      !throwIfTargetIsInaccessible ||
                      ((pTargetMT ? 1 : 0) + (pTargetMethod ? 1 : 0) + (pTargetField ? 1 : 0)) == 1);
         // m_pAccessContext can only be set for kRestrictedMemberAccess
-#ifdef FEATURE_CORECLR
         PRECONDITION(m_pAccessContext == NULL || 
                      accessCheckType == AccessCheckOptions::kRestrictedMemberAccess);
-#else
-        PRECONDITION(m_pAccessContext == NULL || 
-                     accessCheckType == AccessCheckOptions::kUserCodeOnlyRestrictedMemberAccess ||
-                     accessCheckType == AccessCheckOptions::kRestrictedMemberAccess);
-#endif
     }
     CONTRACTL_END;
 
diff --git a/src/vm/codeman.cpp b/src/vm/codeman.cpp
index c615d668cb..ad4c5196b1 100644
--- a/src/vm/codeman.cpp
+++ b/src/vm/codeman.cpp
@@ -31,9 +31,7 @@
 #include "debuginfostore.h"
 #include "strsafe.h"
 
-#ifdef FEATURE_CORECLR
 #include "configuration.h"
-#endif
 
 #ifdef _WIN64
 #define CHECK_DUPLICATED_STRUCT_LAYOUTS
@@ -70,6 +68,16 @@ SVAL_IMPL(LONG, ExecutionManager, m_dwWriterLock);
 CrstStatic ExecutionManager::m_JumpStubCrst;
 CrstStatic ExecutionManager::m_RangeCrst;
 
+unsigned   ExecutionManager::m_normal_JumpStubLookup;
+unsigned   ExecutionManager::m_normal_JumpStubUnique;
+unsigned   ExecutionManager::m_normal_JumpStubBlockAllocCount;
+unsigned   ExecutionManager::m_normal_JumpStubBlockFullCount;
+
+unsigned   ExecutionManager::m_LCG_JumpStubLookup;
+unsigned   ExecutionManager::m_LCG_JumpStubUnique;
+unsigned   ExecutionManager::m_LCG_JumpStubBlockAllocCount;
+unsigned   ExecutionManager::m_LCG_JumpStubBlockFullCount;
+
 #endif // DACCESS_COMPILE
 
 #if defined(_TARGET_AMD64_) && !defined(DACCESS_COMPILE) // We don't do this on ARM just amd64
@@ -1329,7 +1337,7 @@ void EEJitManager::SetCpuInfo()
                         CPUCompileFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_USE_AVX);
                         if (maxCpuId >= 0x07)
                         {
-                            (void) getcpuid(0x07, buffer);
+                            (void) getextcpuid(0, 0x07, buffer);
                             if ((buffer[4]  & 0x20) != 0)
                             {
                                 CPUCompileFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_USE_AVX2);
@@ -1387,12 +1395,12 @@ struct JIT_LOAD_DATA
 // Here's the global data for JIT load and initialization state.
 JIT_LOAD_DATA g_JitLoadData;
 
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#if !defined(FEATURE_MERGE_JIT_AND_ENGINE)
 
 // Global that holds the path to custom JIT location
 extern "C" LPCWSTR g_CLRJITPath = nullptr;
 
-#endif // defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#endif // !defined(FEATURE_MERGE_JIT_AND_ENGINE)
 
 
 // LoadAndInitializeJIT: load the JIT dll into the process, and initialize it (call the UtilCode initialization function,
@@ -1429,7 +1437,6 @@ static void LoadAndInitializeJIT(LPCWSTR pwzJitName, OUT HINSTANCE* phJit, OUT I
 
     HRESULT hr = E_FAIL;
 
-#ifdef FEATURE_CORECLR
     PathString CoreClrFolderHolder;
     extern HINSTANCE g_hThisInst;
     bool havePath = false;
@@ -1472,9 +1479,6 @@ static void LoadAndInitializeJIT(LPCWSTR pwzJitName, OUT HINSTANCE* phJit, OUT I
         }
     }
 
-#else
-    hr = g_pCLRRuntime->LoadLibrary(pwzJitName, phJit);
-#endif
 
     if (SUCCEEDED(hr))
     {
@@ -1483,25 +1487,9 @@ static void LoadAndInitializeJIT(LPCWSTR pwzJitName, OUT HINSTANCE* phJit, OUT I
         EX_TRY
         {
             bool fContinueToLoadJIT = false;
-#if !defined(FEATURE_CORECLR)
-            typedef void (__stdcall* psxsJitStartup) (CoreClrCallbacks const &);
-            psxsJitStartup sxsJitStartupFn = (psxsJitStartup) GetProcAddress(*phJit, "sxsJitStartup");
-
-            if (sxsJitStartupFn)
-            {
-                pJitLoadData->jld_status = JIT_LOAD_STATUS_DONE_GET_SXSJITSTARTUP;
-
-                CoreClrCallbacks cccallbacks = GetClrCallbacks();
-                (*sxsJitStartupFn) (cccallbacks);
-
-                pJitLoadData->jld_status = JIT_LOAD_STATUS_DONE_CALL_SXSJITSTARTUP;
-                fContinueToLoadJIT = true;
-            }
-#else // FEATURE_CORECLR
             // For CoreCLR, we never use "sxsJitStartup" as that is Desktop utilcode initialization
             // specific. Thus, assume we always got 
             fContinueToLoadJIT = true;
-#endif // !defined(FEATURE_CORECLR)
 
             if (fContinueToLoadJIT)
             {
@@ -1634,7 +1622,7 @@ BOOL EEJitManager::LoadJIT()
     // Set as a courtesy to code:CorCompileGetRuntimeDll
     s_ngenCompilerDll = m_JITCompiler;
 
-#if (defined(_TARGET_AMD64_) && !defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)) || (defined(_TARGET_X86_) && defined(FEATURE_CORECLR))
+#if defined(_TARGET_X86_)
     // If COMPlus_UseLegacyJit=1, then we fall back to compatjit.dll.
     //
     // This fallback mechanism was introduced for Visual Studio "14" Preview, when JIT64 (the legacy JIT) was replaced with
@@ -1660,11 +1648,7 @@ BOOL EEJitManager::LoadJIT()
     // Thus, the COMPlus_useLegacyJit=1 mechanism has been enabled for x86 CoreCLR. This scenario does not have the UseRyuJIT
     // registry key, nor the AppX binder mode.
 
-#if defined(FEATURE_CORECLR)
     bool fUseRyuJit = true;
-#else
-    bool fUseRyuJit = UseRyuJit();
-#endif
 
     if ((!IsCompilationProcess() || !fUseRyuJit) &&     // Use RyuJIT for all NGEN, unless we're falling back to JIT64 for everything.
         (newJitCompiler != nullptr))    // the main JIT must successfully load before we try loading the fallback JIT
@@ -1678,34 +1662,13 @@ BOOL EEJitManager::LoadJIT()
 
         if (!fUsingCompatJit)
         {
-#if defined(FEATURE_CORECLR)
             DWORD useLegacyJit = Configuration::GetKnobBooleanValue(W("System.JIT.UseWindowsX86CoreLegacyJit"), CLRConfig::EXTERNAL_UseWindowsX86CoreLegacyJit);
-#else
-            DWORD useLegacyJit = CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_UseLegacyJit); // uncached access, since this code is run no more than one time
-#endif
             if (useLegacyJit == 1)
             {
                 fUsingCompatJit = TRUE;
             }
         }
 
-#if defined(FEATURE_APPX_BINDER)
-        if (!fUsingCompatJit)
-        {
-            // AppX applications don't have a .config file for per-app configuration. So, we allow the placement of a single
-            // distinguished file, "UseLegacyJit.txt" in the root of the app's package to indicate that the app should fall
-            // back to JIT64. This same file is also used to prevent this app from participating in AutoNgen.
-            if (AppX::IsAppXProcess())
-            {
-                WCHAR szPathName[MAX_LONGPATH];
-                UINT32 cchPathName = MAX_LONGPATH;
-                if (AppX::FindFileInCurrentPackage(L"UseLegacyJit.txt", &cchPathName, szPathName, PACKAGE_FILTER_HEAD) == S_OK)
-                {
-                    fUsingCompatJit = TRUE;
-                }
-            }
-        }
-#endif // FEATURE_APPX_BINDER
 
         if (fUsingCompatJit)
         {
@@ -1730,7 +1693,7 @@ BOOL EEJitManager::LoadJIT()
             }
         }
     }
-#endif // (defined(_TARGET_AMD64_) && !defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)) || (defined(_TARGET_X86_) && defined(FEATURE_CORECLR))
+#endif // (defined(_TARGET_AMD64_) && !defined(CROSSGEN_COMPILE)) || (defined(_TARGET_X86_) )
 
 #endif // !FEATURE_MERGE_JIT_AND_ENGINE
 
@@ -4394,7 +4357,6 @@ LPCWSTR ExecutionManager::GetJitName()
 
     LPCWSTR  pwzJitName = NULL;
 
-#if defined(FEATURE_CORECLR)
 #if !defined(CROSSGEN_COMPILE)
     if (g_CLRJITPath != nullptr)
     {
@@ -4409,10 +4371,6 @@ LPCWSTR ExecutionManager::GetJitName()
         }
     }
 #endif // !defined(CROSSGEN_COMPILE)
-#else // !FEATURE_CORECLR
-    // Try to obtain a name for the jit library from the env. variable
-    IfFailThrow(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_JitName, const_cast<LPWSTR *>(&pwzJitName)));
-#endif // !FEATURE_CORECLR
     
     if (NULL == pwzJitName)
     {
@@ -4930,6 +4888,49 @@ void ExecutionManager::Unload(LoaderAllocator *pLoaderAllocator)
     GetEEJitManager()->Unload(pLoaderAllocator);
 }
 
+// This method is used by the JIT and the runtime for PreStubs. It will return
+// the address of a short jump thunk that will jump to the 'target' address.
+// It is only needed when the target architecture has a perferred call instruction
+// that doesn't actually span the full address space.  This is true for x64 where
+// the preferred call instruction is a 32-bit pc-rel call instruction. 
+// (This is also true on ARM64, but it not true for x86)
+//
+// For these architectures, in JITed code and in the prestub, we encode direct calls
+// using the preferred call instruction and we also try to insure that the Jitted
+// code is within the 32-bit pc-rel range of clr.dll to allow direct JIT helper calls.
+//
+// When the call target is too far away to encode using the preferred call instruction.
+// We will create a short code thunk that uncoditionally jumps to the target address. 
+// We call this jump thunk a "jumpStub" in the CLR code.
+// We have the requirement that the "jumpStub" that we create on demand be usable by
+// the preferred call instruction, this requires that on x64 the location in memory
+// where we create the "jumpStub" be within the 32-bit pc-rel range of the call that
+// needs it.
+//
+// The arguments to this method:
+//  pMD    - the MethodDesc for the currenty managed method in Jitted code 
+//           or for the target method for a PreStub
+//           It is required if calling from or to a dynamic method (LCG method)
+//  target - The call target address (this is the address that was too far to encode)
+//  loAddr
+//  hiAddr - The range of the address that we must place the jumpStub in, so that it
+//           can be used to encode the preferred call instruction.
+//  pLoaderAllocator 
+//         - The Loader allocator to use for allocations, this can be null.
+//           When it is null, then the pMD must be valid and is used to obtain
+//           the allocator.
+//
+// This method will either locate and return an existing jumpStub thunk that can be 
+// reused for this request, because it meets all of the requirements necessary.
+// Or it will allocate memory in the required region and create a new jumpStub that
+// meets all of the requirements necessary.
+//
+// Note that for dynamic methods (LCG methods) we cannot share the jumpStubs between
+// different methods. This is because we allow for the unloading (reclaiming) of
+// individual dynamic methods. And we associate the jumpStub memory allocated with 
+// the dynamic method that requested the jumpStub.
+//
+
 PCODE ExecutionManager::jumpStub(MethodDesc* pMD, PCODE target,
                                  BYTE * loAddr,   BYTE * hiAddr,
                                  LoaderAllocator *pLoaderAllocator)
@@ -4949,6 +4950,8 @@ PCODE ExecutionManager::jumpStub(MethodDesc* pMD, PCODE target,
         pLoaderAllocator = pMD->GetLoaderAllocatorForCode();
     _ASSERTE(pLoaderAllocator != NULL);
 
+    bool isLCG = pMD && pMD->IsLCGMethod();
+
     CrstHolder ch(&m_JumpStubCrst);
 
     JumpStubCache * pJumpStubCache = (JumpStubCache *)pLoaderAllocator->m_pJumpStubCache;
@@ -4958,6 +4961,19 @@ PCODE ExecutionManager::jumpStub(MethodDesc* pMD, PCODE target,
         pLoaderAllocator->m_pJumpStubCache = pJumpStubCache;
     }
 
+    if (isLCG)
+    {
+        // Increment counter of LCG jump stub lookup attempts
+        m_LCG_JumpStubLookup++;
+    }
+    else
+    {
+        // Increment counter of normal jump stub lookup attempts
+        m_normal_JumpStubLookup++;
+    }
+
+    // search for a matching jumpstub in the jumpStubCache 
+    //
     for (JumpStubTable::KeyIterator i = pJumpStubCache->m_Table.Begin(target), 
         end = pJumpStubCache->m_Table.End(target); i != end; i++)
     {
@@ -5000,6 +5016,8 @@ PCODE ExecutionManager::getNextJumpStub(MethodDesc* pMD, PCODE target,
     JumpStubBlockHeader ** ppHead   = isLCG ? &(pMD->AsDynamicMethodDesc()->GetLCGMethodResolver()->m_jumpStubBlock) : &(((JumpStubCache *)(pLoaderAllocator->m_pJumpStubCache))->m_pBlocks);
     JumpStubBlockHeader *  curBlock = *ppHead;
     
+    // allocate a new jumpstub from 'curBlock' if it is not fully allocated
+    //
     while (curBlock)
     {
         _ASSERTE(pLoaderAllocator == (isLCG ? curBlock->GetHostCodeHeap()->GetAllocator() : curBlock->GetLoaderAllocator()));
@@ -5020,6 +5038,17 @@ PCODE ExecutionManager::getNextJumpStub(MethodDesc* pMD, PCODE target,
 
     // If we get here then we need to allocate a new JumpStubBlock
 
+    if (isLCG)
+    {
+        // Increment counter of LCG jump stub block allocations
+        m_LCG_JumpStubBlockAllocCount++;
+    }
+    else
+    {
+        // Increment counter of normal jump stub block allocations
+        m_normal_JumpStubBlockAllocCount++;
+    }
+
     // allocJumpStubBlock will allocate from the LoaderCodeHeap for normal methods and HostCodeHeap for LCG methods
     // this can throw an OM exception
     curBlock = ExecutionManager::GetEEJitManager()->allocJumpStubBlock(pMD, DEFAULT_JUMPSTUBS_PER_BLOCK, loAddr, hiAddr, pLoaderAllocator);
@@ -5062,8 +5091,54 @@ DONE:
         pJumpStubCache->m_Table.Add(entry);
     }
 
-    curBlock->m_used++;
+    curBlock->m_used++;    // record that we have used up one more jumpStub in the block
+
+    // Every time we create a new jumpStub thunk one of these counters is incremented
+    if (isLCG)
+    {
+        // Increment counter of LCG unique jump stubs
+        m_LCG_JumpStubUnique++;
+    }
+    else
+    {
+        // Increment counter of normal unique jump stubs 
+        m_normal_JumpStubUnique++;
+    }
+
+    // Is the 'curBlock' now completely full?
+    if (curBlock->m_used == curBlock->m_allocated)
+    {
+        if (isLCG)
+        {
+            // Increment counter of LCG jump stub blocks that are full
+            m_LCG_JumpStubBlockFullCount++;
 
+            // Log this "LCG JumpStubBlock filled" along with the four counter values
+            STRESS_LOG4(LF_JIT, LL_INFO1000, "LCG JumpStubBlock filled - (%u, %u, %u, %u)\n",
+                        m_LCG_JumpStubLookup, m_LCG_JumpStubUnique, 
+                        m_LCG_JumpStubBlockAllocCount, m_LCG_JumpStubBlockFullCount);
+        }
+        else
+        {
+            // Increment counter of normal jump stub blocks that are full
+            m_normal_JumpStubBlockFullCount++;
+
+            // Log this "normal JumpStubBlock filled" along with the four counter values
+            STRESS_LOG4(LF_JIT, LL_INFO1000, "Normal JumpStubBlock filled - (%u, %u, %u, %u)\n",
+                        m_normal_JumpStubLookup, m_normal_JumpStubUnique, 
+                        m_normal_JumpStubBlockAllocCount, m_normal_JumpStubBlockFullCount);
+
+            if ((m_LCG_JumpStubLookup > 0) && ((m_normal_JumpStubBlockFullCount % 5) == 1))
+            {
+                // Every 5 occurance of the above we also 
+                // Log "LCG JumpStubBlock status" along with the four counter values
+                STRESS_LOG4(LF_JIT, LL_INFO1000, "LCG JumpStubBlock status - (%u, %u, %u, %u)\n",
+                            m_LCG_JumpStubLookup, m_LCG_JumpStubUnique, 
+                            m_LCG_JumpStubBlockAllocCount, m_LCG_JumpStubBlockFullCount);
+            }
+        }
+    }
+    
     RETURN((PCODE)jumpStub);
 }
 #endif // !DACCESS_COMPILE && !CROSSGEN_COMPILE
diff --git a/src/vm/codeman.h b/src/vm/codeman.h
index 5fb8da1e47..5fbddea875 100644
--- a/src/vm/codeman.h
+++ b/src/vm/codeman.h
@@ -181,7 +181,7 @@ public:
         return phdrMDesc;
     }
 #if defined(FEATURE_GDBJIT)
-    PTR_BYTE                GetCalledMethods()
+    VOID*                GetCalledMethods()
     {
         SUPPORTS_DAC;
         return pCalledMethods;
@@ -1480,6 +1480,16 @@ private:
     };
     typedef SHash<JumpStubTraits> JumpStubTable;
 
+    static unsigned m_normal_JumpStubLookup;
+    static unsigned m_normal_JumpStubUnique;
+    static unsigned m_normal_JumpStubBlockAllocCount;
+    static unsigned m_normal_JumpStubBlockFullCount;
+
+    static unsigned m_LCG_JumpStubLookup;
+    static unsigned m_LCG_JumpStubUnique;
+    static unsigned m_LCG_JumpStubBlockAllocCount;
+    static unsigned m_LCG_JumpStubBlockFullCount;
+
     struct JumpStubCache
     {
         JumpStubCache() 
diff --git a/src/vm/comcallablewrapper.cpp b/src/vm/comcallablewrapper.cpp
index 17f0fb60aa..91e9afcda3 100644
--- a/src/vm/comcallablewrapper.cpp
+++ b/src/vm/comcallablewrapper.cpp
@@ -1774,12 +1774,10 @@ IUnknown* SimpleComCallWrapper::QIStandardInterface(Enum_StdInterfaces index)
 
     else if (index == enum_IDispatchEx)
     {
-#ifdef FEATURE_CORECLR
         if (AppX::IsAppXProcess())
         { 
             RETURN NULL;
         }
-#endif // FEATURE_CORECLR
 
         if (SupportsIReflect(m_pMT))
         {
@@ -1988,9 +1986,6 @@ IUnknown* SimpleComCallWrapper::QIStandardInterface(REFIID riid)
             // Keeping the Apollo behaviour also ensures that we allow SL 8.1 scenarios (which do not pass the AppX flag like the modern host) 
             // to use CorDispatcher for async, in the expected manner, as the OS implementation for CoreDispatcher expects objects to be Agile.
             if (!IsAggregated() 
-#if !defined(FEATURE_CORECLR)
-            && AppX::IsAppXProcess()
-#endif // !defined(FEATURE_CORECLR)
             )
             {
                 ComCallWrapperTemplate *pTemplate = GetComCallWrapperTemplate();
@@ -3614,12 +3609,10 @@ IUnknown* ComCallWrapper::GetComIPFromCCW(ComCallWrapper *pWrap, REFIID riid, Me
     }                    
     if (IsIDispatch(riid))
     {
-#ifdef FEATURE_CORECLR
         if (AppX::IsAppXProcess())
         { 
             RETURN NULL;
         }
-#endif // FEATURE_CORECLR
 
         // We don't do visibility checks on IUnknown.
         RETURN pWrap->GetIDispatchIP();
@@ -4735,11 +4728,6 @@ BOOL ComMethodTable::LayOutInterfaceMethodTable(MethodTable* pClsMT)
     SLOT *pComVtable;
     unsigned i;
 
-#ifndef FEATURE_CORECLR
-    // Skip this unnecessary expensive check for CoreCLR
-    if (!CheckSigTypesCanBeLoaded(pItfClass))
-        return FALSE;
-#endif
 
     LOG((LF_INTEROP, LL_INFO1000, "LayOutInterfaceMethodTable: %s, this: %p\n", pItfClass->GetDebugClassName(), this));
 
diff --git a/src/vm/comdelegate.cpp b/src/vm/comdelegate.cpp
index 4c85a0216e..2bb792aeab 100644
--- a/src/vm/comdelegate.cpp
+++ b/src/vm/comdelegate.cpp
@@ -1098,7 +1098,6 @@ void COMDelegate::BindToMethod(DELEGATEREF   *pRefThis,
     GCPROTECT_END();
 }
 
-#ifdef FEATURE_CORECLR
 // On the CoreCLR, we don't allow non-fulltrust delegates to be marshaled out (or created: CorHost::CreateDelegate ensures that)
 // This helper function checks if we have a full-trust delegate with AllowReversePInvokeCallsAttribute targets.
 BOOL COMDelegate::IsFullTrustDelegate(DELEGATEREF pDelegate)
@@ -1218,7 +1217,6 @@ BOOL COMDelegate::IsMethodAllowedToSinkReversePInvoke(MethodDesc *pMD)
                         NULL));
 #endif // FEATURE_WINDOWSPHONE
 }
-#endif // FEATURE_CORECLR
 
 // Marshals a managed method to an unmanaged callback provided the 
 // managed method is static and it's parameters require no marshalling.
@@ -1312,7 +1310,6 @@ LPVOID COMDelegate::ConvertToCallback(OBJECTREF pDelegateObj)
     MethodTable* pMT = pDelegate->GetMethodTable();
     DelegateEEClass* pClass = (DelegateEEClass*)(pMT->GetClass());
 
-#ifdef FEATURE_CORECLR
     // On the CoreCLR, we only allow marshaling out delegates that we can guarantee are full-trust delegates
     if (!IsFullTrustDelegate(pDelegate))
     {        
@@ -1320,7 +1317,6 @@ LPVOID COMDelegate::ConvertToCallback(OBJECTREF pDelegateObj)
         TypeString::AppendType(strDelegateType, pMT, TypeString::FormatNamespace | TypeString::FormatAngleBrackets| TypeString::FormatSignature);
         COMPlusThrow(kSecurityException, IDS_E_DELEGATE_FULLTRUST_ARPIC_1, strDelegateType.GetUnicode());
     }
-#endif        
 
     if (pMT->HasInstantiation())
         COMPlusThrowArgumentException(W("delegate"), W("Argument_NeedNonGenericType"));
@@ -1502,13 +1498,11 @@ OBJECTREF COMDelegate::ConvertToDelegate(LPVOID pCallback, MethodTable* pMT)
         if (pUMEntryThunk->GetDomainId() != GetAppDomain()->GetId())
             COMPlusThrow(kNotSupportedException, W("NotSupported_DelegateMarshalToWrongDomain"));
 
-#ifdef FEATURE_CORECLR
         // On the CoreCLR, we only allow marshaling out delegates that we can guarantee are full-trust delegates
         if (!IsFullTrustDelegate((DELEGATEREF)pDelegate))
         {
             COMPlusThrow(kSecurityException, IDS_E_DELEGATE_FULLTRUST_ARPIC_2);
         }
-#endif        
 
         GCPROTECT_END();
         return pDelegate;
@@ -1590,13 +1584,6 @@ OBJECTREF COMDelegate::ConvertToDelegate(LPVOID pCallback, MethodTable* pMT)
         MethodDesc *pStubMD = pClass->m_pForwardStubMD;
         _ASSERTE(pStubMD != NULL && pStubMD->IsILStub());
 
-#ifndef FEATURE_CORECLR
-        if (pStubMD->AsDynamicMethodDesc()->HasCopyCtorArgs())
-        {
-            // static stub that gets its arguments in a thread-static field
-            pInterceptStub = NDirect::GetStubForCopyCtor();
-        }
-#endif // !FEATURE_CORECLR
 
 #ifdef MDA_SUPPORTED
         if (MDA_GET_ASSISTANT(PInvokeStackImbalance))
@@ -1630,13 +1617,11 @@ OBJECTREF COMDelegate::ConvertToDelegate(LPVOID pCallback, MethodTable* pMT)
     GCPROTECT_END();
 #endif // defined(_TARGET_X86_)
 
-#ifdef FEATURE_CORECLR
     // On the CoreCLR, we only allow marshaling out delegates that we can guarantee are full-trust delegates
     if (!IsFullTrustDelegate(delObj))
     {
         COMPlusThrow(kSecurityException, IDS_E_DELEGATE_FULLTRUST_ARPIC_2);
     }
-#endif        
 
     return delObj;
 }
@@ -2182,17 +2167,6 @@ void COMDelegate::DoUnmanagedCodeAccessCheck(MethodDesc* pMeth)
     {
         // Check whether this is actually a SuppressUnmanagedCodePermission attribute and
         // if so, don't do a demand
-#ifndef FEATURE_CORECLR
-        MethodTable* pMTMeth = pMeth->GetMethodTable();
-        if (pMTMeth->GetMDImport()->GetCustomAttributeByName(pMeth->GetMethodTable()->GetCl(),
-                                                             COR_SUPPRESS_UNMANAGED_CODE_CHECK_ATTRIBUTE_ANSI,
-                                                             NULL,
-                                                             NULL) == S_OK ||
-            pMTMeth->GetMDImport()->GetCustomAttributeByName(pMeth->GetMemberDef(),
-                                                             COR_SUPPRESS_UNMANAGED_CODE_CHECK_ATTRIBUTE_ANSI,
-                                                             NULL,
-                                                             NULL) == S_OK)
-#endif
         {
             return;
         }
@@ -2555,38 +2529,7 @@ BOOL COMDelegate::NeedsSecureDelegate(MethodDesc* pCreatorMethod, AppDomain *pCr
     }
     CONTRACTL_END;
 
-#ifndef FEATURE_CAS_POLICY
     return FALSE;
-#else
-    if (pCreatorMethod)
-    {
-        Assembly* pTargetAssembly = pTargetMD->GetAssembly();
-        Assembly* pCreatorAssembly = pCreatorMethod->GetAssembly();
-        if (pCreatorAssembly != pTargetAssembly)
-        {
-            // We don't need secure delegate is everything in the AppDomain is full trust.
-            if (!pCreatorDomain->GetSecurityDescriptor()->DomainMayContainPartialTrustCode())
-                return FALSE;
-
-            IAssemblySecurityDescriptor *pCreatorAsd = pCreatorAssembly->GetSecurityDescriptor(pCreatorDomain);
-
-            // We should also create secure delegates for anonymously hosted dynamic methods which
-            // are themselves full trust (although transparent) yet can be created from partial trust.
-            if (!pCreatorAsd->IsFullyTrusted() ||
-                pCreatorAssembly->GetDomainAssembly(pCreatorDomain) == pCreatorDomain->GetAnonymouslyHostedDynamicMethodsAssembly())
-            {
-                return TRUE;
-            }
-
-            // Note that if we begin to support using an NGEN image which is not fully trusted, we may need
-            // to force on secure delegates as the grant set of the image may not match between NGEN time
-            // and runtime.
-        }
-    }
-
-    return FALSE;
-
-#endif // FEATURE_CAS_POLICY
 }
 
 BOOL COMDelegate::NeedsWrapperDelegate(MethodDesc* pTargetMD)
@@ -2928,9 +2871,6 @@ PCODE COMDelegate::GetSecureInvoke(MethodDesc* pMD)
     }
     CONTRACTL_END;
 
-#ifdef FEATURE_CAS_POLICY
-#error GetSecureInvoke not implemented
-#else
     MethodTable *       pDelegateMT = pMD->GetMethodTable();
     DelegateEEClass*    delegateEEClass = (DelegateEEClass*) pDelegateMT->GetClass();
     Stub *pStub = delegateEEClass->m_pSecureDelegateInvokeStub;
@@ -2986,7 +2926,6 @@ PCODE COMDelegate::GetSecureInvoke(MethodDesc* pMD)
 
     }
     return pStub->GetEntryPoint();
-#endif
 }
 #else // FEATURE_STUBS_AS_IL
 PCODE COMDelegate::GetSecureInvoke(MethodDesc* pMD)
@@ -3800,7 +3739,6 @@ BOOL COMDelegate::ValidateSecurityTransparency(MethodDesc *pFtn, MethodTable *pd
 {
     WRAPPER_NO_CONTRACT;
 
-#ifdef FEATURE_CORECLR
     if (GetAppDomain()->GetSecurityDescriptor()->IsFullyTrusted())
         return TRUE;
 
@@ -3811,9 +3749,6 @@ BOOL COMDelegate::ValidateSecurityTransparency(MethodDesc *pFtn, MethodTable *pd
     //     1. the delegate is critical and the target method is critical, or
     //     2. the delegate is transparent/safecritical and the target method is transparent/safecritical
     return (fCriticalDelegate == fCriticalTarget);
-#else
-    return TRUE;
-#endif // !FEATURE_CORECLR
 }
 
 
@@ -4029,13 +3964,7 @@ static void InvokeUnhandledSwallowing(OBJECTREF *pDelegate,
 
     EX_TRY
     {
-        // We have used both the FEATURE_ defines here since without CSE feature,
-        // this aspect of notification feature is pointless. And skipping
-        // FEATURE_EXCEPTION_NOTIFICATIONS with only FEATURE_CORRUPTING_EXCEPTIONS
-        // specified would enable this change for builds that dont support
-        // FEATURE_EXCEPTION_NOTIFICATIONS, like CoreCLR. We dont want that to happen
-        // as well.
-#if defined(FEATURE_CORRUPTING_EXCEPTIONS) && defined(FEATURE_EXCEPTION_NOTIFICATIONS)
+#if defined(FEATURE_CORRUPTING_EXCEPTIONS)
         BOOL fCanMethodHandleException = g_pConfig->LegacyCorruptedStateExceptionsPolicy();
         if (!fCanMethodHandleException)
         {
@@ -4067,7 +3996,7 @@ static void InvokeUnhandledSwallowing(OBJECTREF *pDelegate,
         }
 
         if (fCanMethodHandleException)
-#endif // defined(FEATURE_CORRUPTING_EXCEPTIONS) && defined(FEATURE_EXCEPTION_NOTIFICATIONS)
+#endif // defined(FEATURE_CORRUPTING_EXCEPTIONS)
         {
             // We've already exercised the prestub on this delegate's COMDelegate::GetMethodDesc,
             // as part of wiring up a reliable event sink. Deliver the notification.
diff --git a/src/vm/comdelegate.h b/src/vm/comdelegate.h
index a562f88392..c8ebf377ba 100644
--- a/src/vm/comdelegate.h
+++ b/src/vm/comdelegate.h
@@ -131,14 +131,10 @@ public:
 
     static BOOL IsTrueMulticastDelegate(OBJECTREF delegate);
 
-#ifdef FEATURE_CORECLR    
     static BOOL IsMethodAllowedToSinkReversePInvoke(MethodDesc *pMD);
-#endif
 
 private:
-#ifdef FEATURE_CORECLR    
     static BOOL IsFullTrustDelegate(DELEGATEREF pDelegate);
-#endif
     static Stub* SetupShuffleThunk(MethodTable * pDelMT, MethodDesc *pTargetMeth);
 
 public:
diff --git a/src/vm/comdynamic.cpp b/src/vm/comdynamic.cpp
index 835b5cab3b..97e408ac32 100644
--- a/src/vm/comdynamic.cpp
+++ b/src/vm/comdynamic.cpp
@@ -714,33 +714,6 @@ INT32 QCALLTYPE COMDynamicWrite::SetParamInfo(QCall::ModuleHandle pModule, UINT3
     return (INT32)retVal;
 }
 
-#ifndef FEATURE_CORECLR
-/*============================CWSetMarshal============================
-**Action: Helper to set marshal information
-**Returns:
-**Arguments:
-**Exceptions:
-==============================================================================*/
-void QCALLTYPE COMDynamicWrite::SetFieldMarshal(QCall::ModuleHandle pModule, UINT32 tk, LPCBYTE pMarshal, INT32 cbMarshal)
-{
-    QCALL_CONTRACT;
-    
-    BEGIN_QCALL;
-
-    RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); 
-    _ASSERTE(pRCW); 
-    
-    _ASSERTE(pMarshal);
-
-    // Define the signature
-    IfFailThrow(pRCW->GetEmitter()->SetFieldMarshal(
-            tk,
-            (PCCOR_SIGNATURE)pMarshal, // marshal blob
-            cbMarshal));               // blob length
-
-    END_QCALL;
-}
-#endif   
 
 /*============================SetConstantValue============================
 **Action: Helper to set constant value to field or parameter
@@ -1103,275 +1076,6 @@ void ManagedBitnessFlagsToUnmanagedBitnessFlags(
         *pPeFlags |= ICEE_CREATE_MACHINE_ARM|ICEE_CREATE_FILE_PE32;        
 }
 
-#ifndef FEATURE_CORECLR
-//=============================PreSavePEFile=====================================*/
-// PreSave the PEFile
-//==============================================================================*/
-void QCALLTYPE COMDynamicWrite::PreSavePEFile(QCall::ModuleHandle pModule, INT32 portableExecutableKind, INT32 imageFileMachine)
-{    
-    QCALL_CONTRACT;
-    
-    BEGIN_QCALL;
-    
-    RefClassWriter *pRCW = pModule->GetReflectionModule()->GetClassWriter(); 
-    _ASSERTE(pRCW);
-    
-    DWORD peFlags = 0, corhFlags = 0;
-    ManagedBitnessFlagsToUnmanagedBitnessFlags(portableExecutableKind, imageFileMachine, &peFlags, &corhFlags);
-    IfFailThrow(pRCW->EnsureCeeFileGenCreated(corhFlags, peFlags));
-    
-    ICeeFileGen *pCeeFileGen = pRCW->GetCeeFileGen();
-    HCEEFILE ceeFile = pRCW->GetHCEEFILE();
-    _ASSERTE(ceeFile && pCeeFileGen);
-    
-    // We should not have the on disk emitter yet
-    if (pRCW->GetOnDiskEmitter() != NULL)
-        pRCW->SetOnDiskEmitter(NULL);
-    
-    // Get the dispenser.
-    SafeComHolderPreemp<IMetaDataDispenserEx> pDisp;
-    IfFailThrow(MetaDataGetDispenser(CLSID_CorMetaDataDispenser, IID_IMetaDataDispenserEx, (void**)&pDisp));
-    
-    //Get the emitter and the importer
-    IMetaDataImport *pImport = pRCW->GetRWImporter();
-    IMetaDataEmit   *pEmit = pRCW->GetEmitter();
-    _ASSERTE((pEmit != NULL ) && (pImport != NULL));
-    
-    // Set the option on the dispenser turn on duplicate check for TypeDef and moduleRef
-    VARIANT  varOption;
-    V_VT(&varOption) = VT_UI4;
-    V_I4(&varOption) = MDDupDefault | MDDupTypeDef | MDDupModuleRef | MDDupExportedType | MDDupAssemblyRef | MDDupFile | MDDupAssembly;
-    IfFailThrow(pDisp->SetOption(MetaDataCheckDuplicatesFor, &varOption));
-    
-    V_VT(&varOption) = VT_UI4;
-    V_I4(&varOption) = MDRefToDefNone;
-    IfFailThrow(pDisp->SetOption(MetaDataRefToDefCheck, &varOption));
-    
-    V_VT(&varOption) = VT_UI4;
-    V_I4(&varOption) = MergeManifest;
-    IfFailThrow(pDisp->SetOption(MetaDataMergerOptions, &varOption));
-    
-    //Define an empty scope
-    SafeComHolderPreemp<IMetaDataEmit> pEmitNew;
-    IfFailThrow(pDisp->DefineScope(CLSID_CorMetaDataRuntime, 0, IID_IMetaDataEmit, (IUnknown**)&pEmitNew));
-    
-    // Token can move upon merge. Get the IMapToken from the CeeFileGen that is created for save
-    // and pass it to merge to receive token movement notification.
-    // Note that this is not a long term fix. We are relying on the fact that those tokens embedded
-    // in PE cannot move after the merge. These tokens are TypeDef, TypeRef, MethodDef, FieldDef, MemberRef,
-    // TypeSpec, UserString. If this is no longer true, we can break!
-    //
-    // Note that we don't need to release pIMapToken because it is not AddRef'ed in the GetIMapTokenIfaceEx.
-    //
-    IUnknown *pUnknown = NULL;
-    IfFailThrow(pCeeFileGen->GetIMapTokenIfaceEx(ceeFile, pEmit, &pUnknown));
-    
-    SafeComHolderPreemp<IMapToken> pIMapToken;
-    IfFailThrow(SafeQueryInterfacePreemp(pUnknown, IID_IMapToken, (IUnknown**) &pIMapToken));
-    
-    // get the unmanaged writer.
-    ISymUnmanagedWriter *pWriter = pModule->GetReflectionModule()->GetISymUnmanagedWriter();
-    SafeComHolderPreemp<CSymMapToken> pSymMapToken(new CSymMapToken(pWriter, pIMapToken));
-    
-    //Merge the old tokens into the new (empty) scope
-    //This is a copy.
-    IfFailThrow(pEmitNew->Merge(pImport, pSymMapToken, NULL));
-    IfFailThrow(pEmitNew->MergeEnd());
-    
-    // Update the Module name in the new scope.
-    CQuickArray<WCHAR> cqModuleName;
-    ULONG              cchName;
-    
-    IfFailThrow(pImport->GetScopeProps(0, 0, &cchName, 0));
-    
-    cqModuleName.ReSizeThrows(cchName);
-    
-    IfFailThrow(pImport->GetScopeProps(cqModuleName.Ptr(), cchName, &cchName, 0));
-    IfFailThrow(pEmitNew->SetModuleProps(cqModuleName.Ptr()));
-    
-    // cache the pEmitNew to RCW!!
-    pRCW->SetOnDiskEmitter(pEmitNew);
-    
-    END_QCALL;
-} // COMDynamicWrite::PreSavePEFile
-
-//=============================SavePEFile=====================================*/
-// Save the PEFile to disk
-//==============================================================================*/
-void QCALLTYPE COMDynamicWrite::SavePEFile(QCall::ModuleHandle pModule, LPCWSTR wszPeName, UINT32 entryPoint, UINT32 fileKind, BOOL isManifestFile)
-{
-    QCALL_CONTRACT;
-    
-    BEGIN_QCALL;
-
-    HRESULT         hr=S_OK;
-    HCORENUM        hTypeDefs=0;
-    mdTypeDef       td;
-    ULONG           count;
-    IMetaDataImport *pImportNew = 0;
-    ULONG           newMethRVA;
-    DWORD           metaDataSize;   
-    BYTE            *metaData;
-    ULONG           metaDataOffset;
-    HCEESECTION     pILSection;
-    ISymUnmanagedWriter *pWriter = NULL;
-
-    if (wszPeName==NULL)
-        COMPlusThrow(kArgumentNullException, W("ArgumentNull_String"));
-    if (wszPeName[0] == '\0')
-        COMPlusThrow(kFormatException, W("Format_StringZeroLength"));
-
-    Assembly * pAssembly = pModule->GetAssembly();
-    _ASSERTE( pAssembly );
-
-    RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); 
-    _ASSERTE(pRCW);
-
-    ICeeFileGen * pCeeFileGen = pRCW->GetCeeFileGen();
-    HCEEFILE ceeFile = pRCW->GetHCEEFILE();
-    _ASSERTE(ceeFile && pCeeFileGen);
-
-    IMetaDataEmit * pEmitNew = pRCW->GetOnDiskEmitter();
-    _ASSERTE(pEmitNew);
-
-    //Get the emitter and the importer 
-
-    if (pAssembly->IsDynamic() && isManifestFile)
-    {
-        // manifest is stored in this file
-
-        // Allocate space for a strong name signature if an originator was supplied
-        // (this doesn't strong name the assembly, but it makes it possible to do so
-        // as a post processing step).
-        if (pAssembly->IsStrongNamed())
-            IfFailGo(pAssembly->AllocateStrongNameSignature(pCeeFileGen, ceeFile));
-    }
-
-    //Set the Output FileName
-    IfFailGo( pCeeFileGen->SetOutputFileName(ceeFile, (LPWSTR)wszPeName) );
-    
-    //Set the Entry Point or throw the dll switch if we're creating a dll.
-    if (entryPoint!=0) 
-    {
-        IfFailGo( pCeeFileGen->SetEntryPoint(ceeFile, entryPoint) );
-    }
-
-    switch (fileKind)
-    {
-        case Dll:
-        {
-            IfFailGo( pCeeFileGen->SetDllSwitch(ceeFile, true) );
-            break;
-        }
-        case WindowApplication:
-        {
-            // window application. Set the SubSystem
-            IfFailGo( pCeeFileGen->SetSubsystem(ceeFile, IMAGE_SUBSYSTEM_WINDOWS_GUI, CEE_IMAGE_SUBSYSTEM_MAJOR_VERSION, CEE_IMAGE_SUBSYSTEM_MINOR_VERSION) );
-            break;
-        }
-        case ConsoleApplication:
-        {
-            // Console application. Set the SubSystem
-            IfFailGo( pCeeFileGen->SetSubsystem(ceeFile, IMAGE_SUBSYSTEM_WINDOWS_CUI, CEE_IMAGE_SUBSYSTEM_MAJOR_VERSION, CEE_IMAGE_SUBSYSTEM_MINOR_VERSION) );
-            break;
-        }
-        default:
-        {
-            _ASSERTE(!"Unknown file kind!");
-            break;
-        }
-    }
-
-    IfFailGo( pCeeFileGen->GetIlSection(ceeFile, &pILSection) );
-    IfFailGo( pEmitNew->GetSaveSize(cssAccurate, &metaDataSize) );
-    IfFailGo( pCeeFileGen->GetSectionBlock(pILSection, metaDataSize, sizeof(DWORD), (void**) &metaData) );
-    IfFailGo( pCeeFileGen->GetSectionDataLen(pILSection, &metaDataOffset) );
-    metaDataOffset -= metaDataSize;
-
-    // get the unmanaged writer.
-    pWriter = pModule->GetReflectionModule()->GetISymUnmanagedWriter();
-    IfFailGo( EmitDebugInfoBegin(pModule, pCeeFileGen, ceeFile, pILSection, wszPeName, pWriter) );
-
-    if (pAssembly->IsDynamic() && pRCW->m_ulResourceSize)
-    {
-        // There are manifest in this file
-
-        IfFailGo( pCeeFileGen->GetMethodRVA(ceeFile, 0, &newMethRVA) );            
-
-        // Point to manifest resource
-        IfFailGo( pCeeFileGen->SetManifestEntry( ceeFile, pRCW->m_ulResourceSize, newMethRVA ) );
-    }
-
-    IfFailGo( pCeeFileGen->LinkCeeFile(ceeFile) );
-
-    // Get the import interface from the new Emit interface.
-    IfFailGo( pEmitNew->QueryInterface(IID_IMetaDataImport, (void **)&pImportNew));
-
-
-    //Enumerate the TypeDefs and update method RVAs.
-    while ((hr = pImportNew->EnumTypeDefs( &hTypeDefs, &td, 1, &count)) == S_OK) 
-    {
-        UpdateMethodRVAs(pEmitNew, pImportNew, pCeeFileGen, ceeFile, td, pModule->GetReflectionModule()->m_sdataSection);
-    }
-
-    if (hTypeDefs) 
-    {
-        pImportNew->CloseEnum(hTypeDefs);
-    }
-    hTypeDefs=0;
-    
-    //Update Global Methods.
-    UpdateMethodRVAs(pEmitNew, pImportNew, pCeeFileGen, ceeFile, 0, pModule->GetReflectionModule()->m_sdataSection);
-    
-
-    //Emit the MetaData 
-    // IfFailGo( pCeeFileGen->EmitMetaDataEx(ceeFile, pEmitNew));
-    IfFailGo( pCeeFileGen->EmitMetaDataAt(ceeFile, pEmitNew, pILSection, metaDataOffset, metaData, metaDataSize) );
-
-    // finish the debugging info emitting after the metadata save so that token remap will be caught correctly
-    IfFailGo( EmitDebugInfoEnd(pModule, pCeeFileGen, ceeFile, pILSection, wszPeName, pWriter) );
-
-    //Generate the CeeFile
-    IfFailGo(pCeeFileGen->GenerateCeeFile(ceeFile) );
-
-    // Strong name sign the resulting assembly if required.
-    if (pAssembly->IsDynamic() && isManifestFile && pAssembly->IsStrongNamed())
-        IfFailGo(pAssembly->SignWithStrongName((LPWSTR)wszPeName));
-
-ErrExit:
-
-    pRCW->SetOnDiskEmitter(NULL);
-
-    //Release the interfaces.  This should free some of the associated resources.
-    if (pImportNew)
-        pImportNew->Release();
-
-    //Release our interfaces if we allocated them to begin with
-    pRCW->DestroyCeeFileGen();
-
-    //Check all file IO errors. If so, throw IOException. Otherwise, just throw the hr.
-    if (FAILED(hr))
-    {
-        if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
-        {
-            if (IsWin32IOError(HRESULT_CODE(hr)))
-            {
-                SString hrMessage;
-                GenerateTopLevelHRExceptionMessage(hr, hrMessage);
-                COMPlusThrowHR(COR_E_IO, IDS_EE_GENERIC, hrMessage.GetUnicode());
-            }
-            else
-            {
-                COMPlusThrowHR(hr);
-            }
-        }
-        COMPlusThrowHR(hr);
-    }
-
-    END_QCALL;
-}
-
-#endif  // FEATURE_CORECLR
 
 //=============================EmitDebugInfoBegin============================*/
 // Phase 1 of emit debugging directory and symbol file.
@@ -1592,152 +1296,6 @@ ErrExit:
 }
 
 
-#ifndef FEATURE_CORECLR
-//==============================================================================
-// Define external file for native resource.
-//==============================================================================
-void QCALLTYPE COMDynamicWrite::DefineNativeResourceFile(QCall::ModuleHandle pModule, LPCWSTR pwzFileName, INT32 portableExecutableKind, INT32 imageFileMachine)
-{
-    QCALL_CONTRACT;
-    
-    BEGIN_QCALL;
-
-    RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); 
-    _ASSERTE(pRCW);
-
-    DWORD peFlags = 0, corhFlags = 0;
-    ManagedBitnessFlagsToUnmanagedBitnessFlags(portableExecutableKind, imageFileMachine, &peFlags, &corhFlags);
-    IfFailThrow( pRCW->EnsureCeeFileGenCreated(corhFlags, peFlags) );
-    
-    ICeeFileGen * pCeeFileGen = pRCW->GetCeeFileGen();
-    HCEEFILE ceeFile = pRCW->GetHCEEFILE();
-    _ASSERTE(ceeFile && pCeeFileGen);
-
-    // Set the resource file name.
-    IfFailThrow( pCeeFileGen->SetResourceFileName(ceeFile, (LPWSTR)pwzFileName) );
-
-    END_QCALL;
-} // void __stdcall COMDynamicWrite::DefineNativeResourceFile()
-
-//==============================================================================
-// Define array of bytes for native resource.
-//==============================================================================
-void QCALLTYPE COMDynamicWrite::DefineNativeResourceBytes(QCall::ModuleHandle pModule, LPCBYTE pbResource, INT32 cbResource, INT32 portableExecutableKind, INT32 imageFileMachine)
-{
-    QCALL_CONTRACT;
-    
-    BEGIN_QCALL;    
-
-    RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); 
-    _ASSERTE(pRCW);
-
-    DWORD peFlags = 0, corhFlags = 0;
-    ManagedBitnessFlagsToUnmanagedBitnessFlags(portableExecutableKind, imageFileMachine, &peFlags, &corhFlags);   
-    IfFailThrow( pRCW->EnsureCeeFileGenCreated(corhFlags, peFlags) );
-
-    ICeeFileGen * pCeeFileGen = pRCW->GetCeeFileGen();
-    HCEEFILE ceeFile = pRCW->GetHCEEFILE();
-    _ASSERTE(ceeFile && pCeeFileGen);
-
-    // Set the resource stream.
-    HCEESECTION ceeSection = NULL;
-    IfFailThrow( pCeeFileGen->GetSectionCreate(ceeFile, ".rsrc", sdReadOnly, &ceeSection) );
-
-    void * pvResource;
-    IfFailThrow( pCeeFileGen->GetSectionBlock(ceeSection, cbResource, 1, &pvResource) );
-    memcpy(pvResource, pbResource, cbResource);
-
-    END_QCALL;
-} // void __stdcall COMDynamicWrite::DefineNativeResourceBytes()
-
-//=============================AddResource=====================================*/
-// ecall for adding embedded resource to this module
-//==============================================================================*/
-void QCALLTYPE COMDynamicWrite::AddResource(QCall::ModuleHandle pModule, LPCWSTR pName, LPCBYTE pResBytes, INT32 resByteCount, UINT32 uFileTk, UINT32 iAttribute, INT32 portableExecutableKind, INT32 imageFileMachine)
-{
-    QCALL_CONTRACT;
-
-    BEGIN_QCALL;       
-
-    RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); 
-    _ASSERTE(pRCW);
-
-    DWORD peFlags = 0, corhFlags = 0;
-    ManagedBitnessFlagsToUnmanagedBitnessFlags(portableExecutableKind, imageFileMachine, &peFlags, &corhFlags);   
-    IfFailThrow( pRCW->EnsureCeeFileGenCreated(corhFlags, peFlags) );
-
-    Assembly * pAssembly = pModule->GetAssembly();
-    _ASSERTE( pAssembly && pAssembly->IsDynamic() );
-
-    ICeeFileGen * pCeeFileGen = pRCW->GetCeeFileGen();
-    HCEEFILE ceeFile = pRCW->GetHCEEFILE();
-    _ASSERTE(ceeFile && pCeeFileGen);
-
-    IMetaDataEmit * pOnDiskEmit = pRCW->GetOnDiskEmitter();
-
-    // First, put it into .rdata section. The only reason that we choose .rdata section at
-    // this moment is because this is the first section on the PE file. We don't need to deal with
-    // reloc. Actually, I don't know how to deal with the reloc with CeeFileGen given that the reloc
-    // position is not in the same file!
-
-    // Get the .rdata section
-    HCEESECTION hSection;
-    IfFailThrow( pCeeFileGen->GetRdataSection(ceeFile, &hSection) );
-
-    // the current section data length is the RVA
-    ULONG ulOffset;
-    IfFailThrow( pCeeFileGen->GetSectionDataLen(hSection, &ulOffset) );
-
-    // Allocate a block of space fromt he .rdata section
-    BYTE * pbBuffer;
-    IfFailThrow( pCeeFileGen->GetSectionBlock(
-        hSection,           // from .rdata section
-        resByteCount + sizeof(DWORD),   // number of bytes that we need
-        1,                  // alignment
-        (void**) &pbBuffer) ); 
-
-    // now copy over the resource
-    memcpy( pbBuffer, &resByteCount, sizeof(DWORD) );
-    memcpy( pbBuffer + sizeof(DWORD), pResBytes, resByteCount );
-
-    // track the total resource size so far. The size is actually the offset into the section
-    // after writing the resource out
-    IfFailThrow( pCeeFileGen->GetSectionDataLen(hSection, &pRCW->m_ulResourceSize) );
-
-    mdFile tkFile = RidFromToken(uFileTk) ? uFileTk : mdFileNil;
-    mdManifestResource mr;
-
-    if (tkFile != mdFileNil)
-    {
-        SafeComHolderPreemp<IMetaDataAssemblyEmit> pOnDiskAssemblyEmit;
-
-        IfFailThrow( pOnDiskEmit->QueryInterface(IID_IMetaDataAssemblyEmit, (void **) &pOnDiskAssemblyEmit) );
-        
-        // The resource is stored in a file other than the manifest file
-        IfFailThrow(pOnDiskAssemblyEmit->DefineManifestResource(
-                 pName,
-                 mdFileNil,              // implementation -- should be file token of this module in the manifest
-                 ulOffset,               // offset to this file -- need to be adjusted upon save
-                 iAttribute,       // resource flag
-                 &mr));                  // manifest resource token
-    }
-
-    // Add an entry into the ManifestResource table for this resource
-    // The RVA is ulOffset
-    SafeComHolderPreemp<IMetaDataAssemblyEmit> pAssemEmitter(pAssembly->GetOnDiskMDAssemblyEmitter());
-    IfFailThrow(pAssemEmitter->DefineManifestResource(
-        pName,
-        tkFile,                 // implementation -- should be file token of this module in the manifest
-        ulOffset,               // offset to this file -- need to be adjusted upon save
-        iAttribute,             // resource flag
-        &mr));                  // manifest resource token
-
-    pRCW->m_tkFile = tkFile;
-
-    END_QCALL;    
-}
-
-#endif // FEATURE_CORECLR
 
 //============================AddDeclarativeSecurity============================*/
 // Add a declarative security serialized blob and a security action code to a
diff --git a/src/vm/comdynamic.h b/src/vm/comdynamic.h
index 224e017330..a605fa19ba 100644
--- a/src/vm/comdynamic.h
+++ b/src/vm/comdynamic.h
@@ -90,16 +90,6 @@ public:
     static
     void QCALLTYPE SavePEFile(QCall::ModuleHandle pModule, LPCWSTR wszPeName, UINT32 entryPoint, UINT32 fileKind, BOOL isManifestFile);
 
-#ifndef FEATURE_CORECLR
-    static 
-    void QCALLTYPE DefineNativeResourceFile(QCall::ModuleHandle pModule, LPCWSTR pwzFileName, INT32 portableExecutableKind, INT32 imageFileMachine);
-
-    static 
-    void QCALLTYPE DefineNativeResourceBytes(QCall::ModuleHandle pModule, LPCBYTE pbResource, INT32 cbResource, INT32 portableExecutableKind, INT32 imageFileMachine);
-
-    static
-    void QCALLTYPE AddResource(QCall::ModuleHandle pModule, LPCWSTR pName, LPCBYTE pResBytes, INT32 resByteCount, UINT32 uFileTk, UINT32 iAttribute, INT32 portableExecutableKind, INT32 imageFileMachine);
-#endif // !FEATURE_CORECLR
 
     // not an ecall!
     static HRESULT EmitDebugInfoBegin(
@@ -160,11 +150,6 @@ public:
     static
     INT32 QCALLTYPE SetParamInfo(QCall::ModuleHandle pModule, UINT32 tkMethod, UINT32 iSequence, UINT32 iAttributes, LPCWSTR wszParamName);
 
-#ifndef FEATURE_CORECLR
-    // functions to set FieldMarshal
-    static
-    void QCALLTYPE SetFieldMarshal(QCall::ModuleHandle pModule, UINT32 tk, LPCBYTE pMarshal, INT32 cbMarshal);
-#endif
     // functions to set default value
     static
     void QCALLTYPE SetConstantValue(QCall::ModuleHandle pModule, UINT32 tk, DWORD valueType, LPVOID pValue);
diff --git a/src/vm/cominterfacemarshaler.cpp b/src/vm/cominterfacemarshaler.cpp
index 251beff352..58dd504d6a 100644
--- a/src/vm/cominterfacemarshaler.cpp
+++ b/src/vm/cominterfacemarshaler.cpp
@@ -20,7 +20,6 @@
 #include "interopconverter.h"
 #ifdef FEATURE_REMOTING
 #include "remoting.h"
-#include "appdomainhelper.h"
 #include "crossdomaincalls.h"
 #endif
 #include "notifyexternals.h"
@@ -389,20 +388,8 @@ OBJECTREF COMInterfaceMarshaler::HandleInProcManagedComponent()
     }
     else
     {
-#ifdef FEATURE_CORECLR
         _ASSERTE(!"NYI");
         COMPlusThrowHR(COR_E_NOTSUPPORTED);
-#else // FEATURE_CORECLR
-        // TODO: probably we can cache the object on a per App domain bases
-        // using CCW as the key
-        OBJECTREF pwrap = NULL;
-        GCPROTECT_BEGIN(pwrap);
-        {
-            pwrap = GetCCWObject();
-            oref = AppDomainHelper::CrossContextCopyFrom(m_dwServerDomainId, &pwrap);
-        }
-        GCPROTECT_END();
-#endif // FEATURE_CORECLR
     }
     
     return oref;
diff --git a/src/vm/comisolatedstorage.cpp b/src/vm/comisolatedstorage.cpp
index 2f4f4f69b3..36dd787e11 100644
--- a/src/vm/comisolatedstorage.cpp
+++ b/src/vm/comisolatedstorage.cpp
@@ -992,9 +992,6 @@ HRESULT AccountingInfo::Lock()
     DWORD dwRet;
     {
         // m_hLock is a mutex
-#ifndef FEATURE_CORECLR        
-        Thread::BeginThreadAffinityAndCriticalRegion();
-#endif
         dwRet = WaitForSingleObject(m_hLock, INFINITE);
     }
 
@@ -1065,9 +1062,6 @@ void AccountingInfo::Unlock()
     InterlockedDecrement((LPLONG)&m_dwNumLocks);
 #endif
 
-#ifndef FEATURE_CORECLR        
-    Thread::EndThreadAffinityAndCriticalRegion();
-#endif
 }
 
 #endif
diff --git a/src/vm/commethodrental.cpp b/src/vm/commethodrental.cpp
deleted file mode 100644
index 0a5c011270..0000000000
--- a/src/vm/commethodrental.cpp
+++ /dev/null
@@ -1,120 +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.
-////////////////////////////////////////////////////////////////////////////////
-
-
-
-#include "common.h"
-#include "commethodrental.h"
-#include "corerror.h"
-
-#ifdef FEATURE_METHOD_RENTAL
-// SwapMethodBody
-// This method will take the rgMethod as the new function body for a given method. 
-//
-
-void QCALLTYPE COMMethodRental::SwapMethodBody(EnregisteredTypeHandle cls, INT32 tkMethod, LPVOID rgMethod, INT32 iSize, INT32 flags, QCall::StackCrawlMarkHandle stackMark)
-{
-    QCALL_CONTRACT;
-    
-    BEGIN_QCALL;
-
-    BYTE        *pNewCode       = NULL;
-    MethodDesc  *pMethodDesc;
-    ReflectionModule *module;
-    ICeeGen*    pGen;
-    ULONG       methodRVA;
-    HRESULT     hr;
-
-    if ( cls == NULL)
-    {
-        COMPlusThrowArgumentNull(W("cls"));
-    }
-
-    MethodTable *pMethodTable = TypeHandle::FromPtr(cls).GetMethodTable();
-    PREFIX_ASSUME(pMethodTable != NULL);
-    module = (ReflectionModule *) pMethodTable->GetModule();
-    pGen = module->GetCeeGen();
-
-    Assembly* caller = SystemDomain::GetCallersAssembly( stackMark );
-
-    _ASSERTE( caller != NULL && "Unable to get calling assembly" );
-    _ASSERTE( module->GetCreatingAssembly() != NULL && "ReflectionModule must have a creating assembly to be used with method rental" );
-
-    if (module->GetCreatingAssembly() != caller)
-    {
-        COMPlusThrow(kSecurityException);
-    }
-
-    // Find the methoddesc given the method token
-    pMethodDesc = MemberLoader::FindMethod(pMethodTable, tkMethod);
-    if (pMethodDesc == NULL)
-    {
-        COMPlusThrowArgumentException(W("methodtoken"), NULL);
-    }
-    if (pMethodDesc->GetMethodTable() != pMethodTable || pMethodDesc->GetNumGenericClassArgs() != 0 || pMethodDesc->GetNumGenericMethodArgs() != 0)
-    {
-        COMPlusThrowArgumentException(W("methodtoken"), W("Argument_TypeDoesNotContainMethod"));
-    }
-    hr = pGen->AllocateMethodBuffer(iSize, &pNewCode, &methodRVA);    
-    if (FAILED(hr))
-        COMPlusThrowHR(hr);
-
-    if (pNewCode == NULL)
-    {
-        COMPlusThrowOM();
-    }
-
-    // <TODO>
-    // if method desc is pointing to the post-jitted native code block,
-    // we want to recycle this code block
-
-    // @todo: SEH handling. Will we need to support a method that can throw exception
-    // If not, add an assertion to make sure that there is no SEH contains in the method header.
-
-    // @todo: figure out a way not to copy the code block.
-
-    // @todo: add link time security check. This function can be executed only if fully trusted.</TODO>
-
-    // copy the new function body to the buffer
-    memcpy(pNewCode, (void *) rgMethod, iSize);
-
-    // add the starting address of the il blob to the il blob hash table
-    // we need to find this information from out of process for debugger inspection
-    // APIs so we have to store this information where we can get it later
-    module->SetDynamicIL(mdToken(tkMethod), TADDR(pNewCode), FALSE);
-
-    // Reset the methoddesc back to unjited state
-    pMethodDesc->Reset();
-
-    if (flags)
-    {
-        // JITImmediate
-#if _DEBUG
-        COR_ILMETHOD* ilHeader = pMethodDesc->GetILHeader(TRUE);
-        _ASSERTE(((BYTE *)ilHeader) == pNewCode);
-#endif
-        COR_ILMETHOD_DECODER header((COR_ILMETHOD *)pNewCode, pMethodDesc->GetMDImport(), NULL); 
-
-        // minimum validation on the correctness of method header
-        if (header.GetCode() == NULL)
-            COMPlusThrowHR(VLDTR_E_MD_BADHEADER);
-
-#ifdef FEATURE_INTERPRETER
-        pMethodDesc->MakeJitWorker(&header, CORJIT_FLAGS(CORJIT_FLAGS::CORJIT_FLAG_MAKEFINALCODE));
-#else // !FEATURE_INTERPRETER
-        pMethodDesc->MakeJitWorker(&header, CORJIT_FLAGS());
-#endif // !FEATURE_INTERPRETER
-    }
-
-    // add feature::
-    // If SQL is generating class with inheritance hierarchy, we may need to
-    // check the whole vtable to find duplicate entries.
-
-    END_QCALL;
-
-}   // COMMethodRental::SwapMethodBody
-
-
-#endif // FEATURE_METHOD_RENTAL
diff --git a/src/vm/commethodrental.h b/src/vm/commethodrental.h
deleted file mode 100644
index 0523af274e..0000000000
--- a/src/vm/commethodrental.h
+++ /dev/null
@@ -1,29 +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.
-////////////////////////////////////////////////////////////////////////////////
-
-
-
-#ifndef _COMMETHODRENTAL_H_
-#define _COMMETHODRENTAL_H_
-
-#include "excep.h"
-#include "fcall.h"
-
-#ifdef FEATURE_METHOD_RENTAL
-// COMMethodRental
-// This class implements SwapMethodBody for our MethodRenting story
-class COMMethodRental
-{
-public:
-
-    // COMMethodRental.SwapMethodBody -- this function will swap an existing method body with
-    // a new method body
-    //
-    static
-    void QCALLTYPE SwapMethodBody(EnregisteredTypeHandle cls, INT32 tkMethod, LPVOID rgMethod, INT32 iSize, INT32 flags, QCall::StackCrawlMarkHandle stackMark);
-};
-#endif // FEATURE_METHOD_RENTAL
-
-#endif //_COMMETHODRENTAL_H_
diff --git a/src/vm/commodule.cpp b/src/vm/commodule.cpp
index af6dc48d15..e3a7e3dbdd 100644
--- a/src/vm/commodule.cpp
+++ b/src/vm/commodule.cpp
@@ -45,12 +45,6 @@ static ISymUnmanagedWriter **CreateISymWriterForDynamicModule(ReflectionModule *
     // 
     ESymbolFormat symFormatToUse = eSymbolFormatILDB;
 
-#ifndef FEATURE_CORECLR // On desktop only we still use PDB format if the symbols are savable to disk
-    if(mod->GetAssembly()->HasSaveAccess())
-    {
-        symFormatToUse = eSymbolFormatPDB;
-    }
-#endif
    
     static ConfigDWORD dbgForcePDBSymbols;
     if(dbgForcePDBSymbols.val_DontUse_(W("DbgForcePDBSymbols"), 0) == 1)
@@ -951,13 +945,6 @@ void QCALLTYPE COMModule::GetFullyQualifiedName(QCall::ModuleHandle pModule, QCa
     {
         LPCWSTR fileName = pModule->GetPath();
         if (*fileName != 0) {
-#ifndef FEATURE_CORECLR
-            // workaround - lie about where mscorlib is. Mscorlib is now loaded out of the GAC, 
-            // but some apps query its location to find the system directory. (Notably CodeDOM)
-            if (pModule->IsSystem())
-                retString.Set(SystemDomain::System()->BaseLibrary());
-            else
-#endif // !FEATURE_CORECLR
             {
 #ifdef FEATURE_WINDOWSPHONE
                 //
@@ -1182,60 +1169,6 @@ Object* GetTypesInner(Module* pModule)
     RETURN(OBJECTREFToObject(refArrClasses));
 }
 
-#if defined(FEATURE_X509) && defined(FEATURE_CAS_POLICY)
-//+--------------------------------------------------------------------------
-//  
-//  Member:     COMModule::GetSignerCertificate()
-//  
-//  Synopsis:   Gets the certificate with which the module was signed.
-//
-//  Effects:    Creates an X509Certificate and returns it.
-// 
-//  Arguments:  None.
-//
-//  Returns:    OBJECTREF to an X509Certificate object containing the 
-//              signer certificate.
-//
-//---------------------------------------------------------------------------
-
-void QCALLTYPE COMModule::GetSignerCertificate(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retData)
-{
-    QCALL_CONTRACT;
-    
-    BEGIN_QCALL;
-
-    PCOR_TRUST                  pCorTrust = NULL;
-    IAssemblySecurityDescriptor* pSecDesc = NULL;
-    PBYTE                       pbSigner = NULL;
-    DWORD                       cbSigner = 0;
-
-    // ******** Get the security descriptor ********
-
-    // Get a pointer to the module security descriptor
-    pSecDesc = pModule->GetSecurityDescriptor();
-    _ASSERTE(pSecDesc);
-
-    // ******** Get COR_TRUST info from module security descriptor ********
-    if (FAILED(pSecDesc->LoadSignature(&pCorTrust)))
-    {
-        COMPlusThrow(kArgumentNullException, W("InvalidOperation_MetaDataError"));
-    }
-
-    if( pCorTrust )
-    {
-        // Get a pointer to the signer certificate information in the COR_TRUST
-        pbSigner = pCorTrust->pbSigner;
-        cbSigner = pCorTrust->cbSigner;
-
-        if( pbSigner && cbSigner )
-        {
-            retData.SetByteArray(pbSigner, cbSigner);
-        }
-    }
-
-    END_QCALL;
-}
-#endif // #if defined(FEATURE_X509) && defined(FEATURE_CAS_POLICY)
 
 FCIMPL1(FC_BOOL_RET, COMModule::IsResource, ReflectModuleBaseObject* pModuleUNSAFE)
 {
@@ -1248,7 +1181,6 @@ FCIMPL1(FC_BOOL_RET, COMModule::IsResource, ReflectModuleBaseObject* pModuleUNSA
 }
 FCIMPLEND
 
-#ifdef FEATURE_CORECLR
 
 //---------------------------------------------------------------------
 // Helper code for PunkSafeHandle class. This does the Release in the
@@ -1283,6 +1215,5 @@ FCIMPL0(void*, COMPunkSafeHandle::nGetDReleaseTarget)
     return (void*)DReleaseTarget;
 }
 FCIMPLEND
-#endif //FEATURE_CORECLR
 
 
diff --git a/src/vm/commodule.h b/src/vm/commodule.h
index 255b22dfbf..4ec82e7cd8 100644
--- a/src/vm/commodule.h
+++ b/src/vm/commodule.h
@@ -103,11 +103,6 @@ public:
     static
     mdString QCALLTYPE GetStringConstant(QCall::ModuleHandle pModule, LPCWSTR pwzValue, INT32 iLength);
 
-#if defined(FEATURE_X509) && defined(FEATURE_CAS_POLICY)
-    /*X509Certificate*/
-    static
-    void QCALLTYPE GetSignerCertificate(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retData);
-#endif // #if defined(FEATURE_X509) && defined(FEATURE_CAS_POLICY)
 
     static
     void QCALLTYPE SetModuleName(QCall::ModuleHandle pModule, LPCWSTR wszModuleName);
@@ -135,9 +130,7 @@ public:
 class COMPunkSafeHandle
 {
   public:
-#ifdef FEATURE_CORECLR
     static FCDECL0(void*, nGetDReleaseTarget);
-#endif
 };
 
 #endif
diff --git a/src/vm/common.h b/src/vm/common.h
index 9de9f35141..45f2d62d61 100644
--- a/src/vm/common.h
+++ b/src/vm/common.h
@@ -99,9 +99,6 @@
 
 #include "compatibilityflags.h"
 extern BOOL GetCompatibilityFlag(CompatibilityFlag flag);
-#ifndef FEATURE_CORECLR
-extern DWORD* GetGlobalCompatibilityFlags();
-#endif // !FEATURE_CORECLR
 
 #include "strongname.h"
 #include "stdmacros.h"
@@ -399,11 +396,6 @@ inline VOID UnsafeEEEnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
     STATIC_CONTRACT_GC_NOTRIGGER;
     STATIC_CONTRACT_CAN_TAKE_LOCK;
 
-#ifndef FEATURE_CORECLR
-    if (CLRTaskHosted()) {
-        Thread::BeginThreadAffinity();
-    }
-#endif // !FEATURE_CORECLR
     UnsafeEnterCriticalSection(lpCriticalSection);
     INCTHREADLOCKCOUNT();
 }
@@ -415,11 +407,6 @@ inline VOID UnsafeEELeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
 
     UnsafeLeaveCriticalSection(lpCriticalSection);
     DECTHREADLOCKCOUNT();
-#ifndef FEATURE_CORECLR
-    if (CLRTaskHosted()) {
-        Thread::EndThreadAffinity();
-    }
-#endif // !FEATURE_CORECLR
 }
 
 inline BOOL UnsafeEETryEnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
diff --git a/src/vm/compile.cpp b/src/vm/compile.cpp
index 87107151eb..8aca2ad6df 100644
--- a/src/vm/compile.cpp
+++ b/src/vm/compile.cpp
@@ -27,14 +27,10 @@
 #include "zapsig.h"
 #include "gcrefmap.h"
 
-#ifndef FEATURE_CORECLR
-#include "corsym.h"
-#endif // FEATURE_CORECLR
 
 #include "virtualcallstub.h"
 #include "typeparse.h"
 #include "typestring.h"
-#include "constrainedexecutionregion.h"
 #include "dllimport.h"
 #include "comdelegate.h"
 #include "stringarraylist.h"
@@ -51,11 +47,6 @@
 #include "cgensys.h"
 #include "peimagelayout.inl"
 
-#if defined(FEATURE_APPX_BINDER)
-#include "appxutil.h"
-#include "clrprivbinderappx.h"
-#include "clrprivtypecachewinrt.h"
-#endif // defined(FEATURE_APPX_BINDER)
 
 #ifdef FEATURE_COMINTEROP
 #include "clrprivbinderwinrt.h"
@@ -163,17 +154,6 @@ HRESULT CEECompileInfo::CreateDomain(ICorCompilationDomain **ppDomain,
     if (pEmitter)
         pCompilationDomain->SetDependencyEmitter(pEmitter);
     
-#if defined(FEATURE_APPX_BINDER)
-    if (AppX::IsAppXProcess())
-    {
-        HRESULT hr = S_OK;
-        ReleaseHolder<ICLRPrivBinder> pBinderInterface;
-        CLRPrivBinderAppX * pBinder = CLRPrivBinderAppX::GetOrCreateBinder();
-        
-        IfFailThrow(pBinder->QueryInterface(IID_ICLRPrivBinder, &pBinderInterface));
-        pCompilationDomain->SetLoadContextHostBinder(pBinderInterface);
-    }
-#endif // defined(FEATURE_APPX_BINDER)
 
 #ifdef DEBUGGING_SUPPORTED 
     // Notify the debugger here, before the thread transitions into the
@@ -192,20 +172,14 @@ HRESULT CEECompileInfo::CreateDomain(ICorCompilationDomain **ppDomain,
 
         ENTER_DOMAIN_PTR(pCompilationDomain,ADV_COMPILATION)
         {
-#ifdef FEATURE_CORECLR
             if (fForceFulltrustDomain)
                 ((ApplicationSecurityDescriptor *)pCompilationDomain->GetSecurityDescriptor())->SetGrantedPermissionSet(NULL, NULL, 0xFFFFFFFF);
-#endif
 
 #ifndef CROSSGEN_COMPILE
-#ifndef FEATURE_CORECLR
-            pCompilationDomain->InitializeHashing(NULL);
-#endif // FEATURE_CORECLR
 #endif
             pCompilationDomain->InitializeDomainContext(TRUE, NULL, NULL);
 
 #ifndef CROSSGEN_COMPILE
-#ifdef FEATURE_CORECLR
 
             if (!NingenEnabled())
             {
@@ -223,7 +197,6 @@ HRESULT CEECompileInfo::CreateDomain(ICorCompilationDomain **ppDomain,
                 initializeSecurity.Call(args);
                 GCPROTECT_END();
             }
-#endif //FEATURE_CORECLR
 #endif
 
             {
@@ -231,28 +204,9 @@ HRESULT CEECompileInfo::CreateDomain(ICorCompilationDomain **ppDomain,
 
                 // We load assemblies as domain-bound (However, they're compiled as domain neutral)
 #ifdef FEATURE_LOADER_OPTIMIZATION
-#ifdef FEATURE_FUSION
-                if (NingenEnabled())
-                {
-                    pCompilationDomain->SetSharePolicy(AppDomain::SHARE_POLICY_NEVER);
-                }
-                else
-                {
-                    pCompilationDomain->SetupLoaderOptimization(AppDomain::SHARE_POLICY_NEVER);
-                }
-#else //FEATURE_FUSION
                 pCompilationDomain->SetSharePolicy(AppDomain::SHARE_POLICY_NEVER);
-#endif //FEATURE_FUSION
 #endif // FEATURE_LOADER_OPTIMIZATION
 
-#ifdef FEATURE_FUSION
-                CorCompileConfigFlags flags = PEFile::GetNativeImageConfigFlags(pCompilationDomain->m_fForceDebug,
-                                                                                pCompilationDomain->m_fForceProfiling,
-                                                                                pCompilationDomain->m_fForceInstrument);
-
-                FusionBind::SetApplicationContextDWORDProperty(GetAppDomain()->GetFusionContext(),
-                                                               ACTAG_ZAP_CONFIG_FLAGS, flags);
-#endif //FEATURE_FUSION
             }
 
             pCompilationDomain->SetFriendlyName(W("Compilation Domain"));
@@ -393,14 +347,6 @@ HRESULT CEECompileInfo::LoadAssemblyByPath(
 
         PEImageHolder pImage;
 
-#if defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)
-        // If the path is not absolute, look for the assembly on platform path list first
-        if (wcschr(wzPath, '\\') == NULL || wcschr(wzPath, ':') == NULL || wcschr(wzPath, '/') == NULL)
-        {
-            CompilationDomain::FindImage(wzPath,
-                fExplicitBindToNativeImage ? MDInternalImport_NoCache : MDInternalImport_Default, &pImage);
-        }
-#endif
 
         if (pImage == NULL)
         {
@@ -477,16 +423,6 @@ HRESULT CEECompileInfo::LoadAssemblyByPath(
             }
             else
             {
-#ifdef FEATURE_FUSION
-                SafeComHolder<IBindResult> pNativeFusionAssembly;        
-                SafeComHolder<IFusionBindLog> pFusionLog;
-                SafeComHolder<IAssembly> pFusionAssembly;
-
-                IfFailThrow(ExplicitBind(wzPath, pDomain->GetFusionContext(), EXPLICITBIND_FLAGS_EXE,
-                                         NULL, &pFusionAssembly, &pNativeFusionAssembly, &pFusionLog));
-
-                pAssemblyHolder = PEAssembly::Open(pFusionAssembly, pNativeFusionAssembly, pFusionLog, FALSE, FALSE);
-#else //FEATURE_FUSION
                 //ExplicitBind
                 CoreBindResult bindResult;
                 spec.SetCodeBase(pImage->GetPath());
@@ -510,21 +446,14 @@ HRESULT CEECompileInfo::LoadAssemblyByPath(
                     fExplicitBindToNativeImage
                     );
                 pAssemblyHolder = PEAssembly::Open(&bindResult,FALSE,FALSE);
-#endif //FEATURE_FUSION
             }
 
             // Now load assembly into domain.
             DomainAssembly * pDomainAssembly = pDomain->LoadDomainAssembly(&spec, pAssemblyHolder, FILE_LOAD_BEGIN);
 
-#ifndef FEATURE_APPX_BINDER
             if (spec.CanUseWithBindingCache() && pDomainAssembly->CanUseWithBindingCache())
                 pDomain->AddAssemblyToCache(&spec, pDomainAssembly);
-#endif
 
-#if defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)
-            if (!IsReadyToRunCompilation())
-                pDomain->ToCompilationDomain()->ComputeAssemblyHardBindList(pAssemblyHolder->GetPersistentMDImport());
-#endif
 
             {
                 // Mark the assembly before it gets fully loaded and NGen image dependencies are verified. This is necessary
@@ -556,156 +485,6 @@ HRESULT CEECompileInfo::LoadAssemblyByPath(
     return hr;
 }
 
-#ifdef FEATURE_FUSION
-
-// Simple helper that factors out code common to LoadAssemblyByIAssemblyName and
-// LoadAssemblyByName
-static HRESULT LoadAssemblyByIAssemblyNameWorker(
-    IAssemblyName *pAssemblyName,
-    CORINFO_ASSEMBLY_HANDLE *pHandle)
-{
-    CONTRACTL                   
-    {                           
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        SO_INTOLERANT;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;              
-
-    Assembly *pAssembly;
-
-    AssemblySpec spec;
-    spec.InitializeSpec(pAssemblyName, NULL, FALSE);
-
-    if (spec.IsMscorlib())
-    {
-        pAssembly = SystemDomain::System()->SystemAssembly();
-    }
-    else
-    {
-
-        DomainAssembly * pDomainAssembly = spec.LoadDomainAssembly(FILE_LOAD_BEGIN);
-
-        // Mark the assembly before it gets fully loaded and NGen image dependencies are verified. This is necessary
-        // to allow skipping compilation if there is NGen image already.
-        pDomainAssembly->GetFile()->SetSafeToHardBindTo();
-
-        pAssembly = spec.LoadAssembly(FILE_LOADED);
-    }
-
-    //
-    // Return the module handle
-    //
-
-    *pHandle = CORINFO_ASSEMBLY_HANDLE(pAssembly);
-
-    return S_OK;
-}
-
-HRESULT CEECompileInfo::LoadAssemblyByName(
-    LPCWSTR                  wzName,
-    CORINFO_ASSEMBLY_HANDLE *pHandle)
-{
-    STANDARD_VM_CONTRACT;
-
-    HRESULT hr = S_OK;
-
-    COOPERATIVE_TRANSITION_BEGIN();
-
-    EX_TRY
-    {
-        ReleaseHolder<IAssemblyName> pAssemblyName;
-        IfFailThrow(CreateAssemblyNameObject(&pAssemblyName, wzName, CANOF_PARSE_DISPLAY_NAME, NULL));
-        IfFailThrow(LoadAssemblyByIAssemblyNameWorker(pAssemblyName, pHandle));
-    }
-    EX_CATCH_HRESULT(hr);
-
-    COOPERATIVE_TRANSITION_END();
-
-    return hr;
-}
-
-HRESULT CEECompileInfo::LoadAssemblyRef(
-    IMDInternalImport       *pAssemblyImport,
-    mdAssemblyRef           ref,
-    CORINFO_ASSEMBLY_HANDLE *pHandle,
-    IAssemblyName           **refAssemblyName /*=NULL*/)
-{
-    STANDARD_VM_CONTRACT;
-
-    HRESULT hr = S_OK;
-
-    ReleaseHolder<IAssemblyName> pAssemblyName;
-
-    COOPERATIVE_TRANSITION_BEGIN();
-    
-    EX_TRY
-    {
-        Assembly *pAssembly;
-
-        if (refAssemblyName)
-            *refAssemblyName = NULL;
-
-        AssemblySpec spec;
-        spec.InitializeSpec(ref, pAssemblyImport, NULL, FALSE);
-        
-        if (spec.HasBindableIdentity())
-        {
-            if (refAssemblyName)
-            {
-                IfFailThrow(spec.CreateFusionName(&pAssemblyName));
-            }
-
-            pAssembly = spec.LoadAssembly(FILE_LOADED);
-
-            //
-            // Return the module handle
-            //
-
-            *pHandle = CORINFO_ASSEMBLY_HANDLE(pAssembly);
-        }
-        else
-        {   // Cannot load assembly refs with non-unique id.
-            hr = S_FALSE;
-        }
-    }
-    EX_CATCH_HRESULT(hr);
-
-    COOPERATIVE_TRANSITION_END();
-
-    if (refAssemblyName != NULL && pAssemblyName != NULL)
-    {
-        *refAssemblyName = pAssemblyName.Extract();
-    }
-
-    return hr;
-}
-
-HRESULT CEECompileInfo::LoadAssemblyByIAssemblyName(
-        IAssemblyName           *pAssemblyName,
-        CORINFO_ASSEMBLY_HANDLE *pHandle
-        )
-{
-    STANDARD_VM_CONTRACT;
-
-    HRESULT hr = S_OK;
-
-    COOPERATIVE_TRANSITION_BEGIN();
-
-    EX_TRY
-    {
-        IfFailThrow(LoadAssemblyByIAssemblyNameWorker(pAssemblyName, pHandle));
-    }
-    EX_CATCH_HRESULT(hr);
-
-    COOPERATIVE_TRANSITION_END();
-
-    return hr;
-}
-
-#endif //FEATURE_FUSION
 
 #ifdef FEATURE_COMINTEROP
 HRESULT CEECompileInfo::LoadTypeRefWinRT(
@@ -802,66 +581,6 @@ HRESULT CEECompileInfo::LoadAssemblyModule(
     return S_OK;
 }
 
-#ifndef FEATURE_CORECLR
-BOOL CEECompileInfo::SupportsAutoNGen(CORINFO_ASSEMBLY_HANDLE assembly)
-{
-    STANDARD_VM_CONTRACT;
-
-    Assembly *pAssembly = (Assembly*) assembly;
-    return pAssembly->SupportsAutoNGen();
-}
-
-HRESULT CEECompileInfo::SetCachedSigningLevel(HANDLE hNI, HANDLE *pModules, COUNT_T nModules)
-{
-    STANDARD_VM_CONTRACT;
-
-    HRESULT hr = S_OK;
-
-    HMODULE hKernel32 = WszLoadLibrary(W("kernel32.dll"));
-    typedef BOOL (WINAPI *SetCachedSigningLevel_t)
-        (__in_ecount(Count) PHANDLE SourceFiles, __in ULONG Count, __in ULONG Flags, __in HANDLE TargetFile);
-    SetCachedSigningLevel_t SetCachedSigningLevel
-        = (SetCachedSigningLevel_t)GetProcAddress(hKernel32, "SetCachedSigningLevel");
-    if (SetCachedSigningLevel == NULL)
-    {
-        return S_OK;
-    }
-
-    StackSArray<PEImage*> images;
-    PEImage::GetAll(images);
-
-    StackSArray<HANDLE> handles;
-    for (StackSArray<PEImage*>::Iterator i = images.Begin(), end = images.End(); i != end; i++)
-    {
-        if (!(*i)->IsFile())
-        {
-            continue;
-        }
-        HANDLE hFile = (*i)->GetFileHandleLocking();
-        handles.Append(hFile);
-    }
-
-    if (!SetCachedSigningLevel(handles.GetElements(), handles.GetCount(), 0, hNI))
-    {
-        hr = HRESULT_FROM_WIN32(GetLastError());
-        _ASSERTE(FAILED(hr));
-        goto ErrExit;
-    }
-
-    for (COUNT_T i = 0; i < nModules; i++)
-    {
-        if (!SetCachedSigningLevel(handles.GetElements(), handles.GetCount(), 0, pModules[i]))
-        {
-            hr = HRESULT_FROM_WIN32(GetLastError());
-            _ASSERTE(FAILED(hr));
-            goto ErrExit;
-        }
-    }
-
-ErrExit:
-    return hr;
-}
-#endif
 
 BOOL CEECompileInfo::CheckAssemblyZap(
     CORINFO_ASSEMBLY_HANDLE assembly, 
@@ -1045,42 +764,6 @@ CORINFO_ASSEMBLY_HANDLE
     return (CORINFO_ASSEMBLY_HANDLE) GetModule(module)->GetAssembly();
 }
 
-#ifdef FEATURE_FUSION
-HRESULT CEECompileInfo::GetAssemblyName(
-    CORINFO_ASSEMBLY_HANDLE hAssembly,
-    DWORD                   dwFlags,
-    __out_z LPWSTR          wzAssemblyName, 
-    LPDWORD                 pcchAssemblyName)
-{
-    STANDARD_VM_CONTRACT;
-
-    _ASSERTE(hAssembly != NULL);
-    if (hAssembly == NULL)
-    {
-        return E_INVALIDARG;
-    }
-
-    HRESULT hr = S_OK;
-    EX_TRY
-    {
-        Assembly *pAssembly = (Assembly *) hAssembly;
-        IAssemblyName * pAssemblyName = pAssembly->GetFusionAssemblyName();
-        if (dwFlags == GANF_Default)
-        {
-            hr = pAssemblyName->GetDisplayName(wzAssemblyName, pcchAssemblyName, 0);
-        }
-        else if (dwFlags == GANF_Simple)
-        {
-            DWORD cbAssemblyName = *pcchAssemblyName * sizeof(WCHAR);
-            hr = pAssemblyName->GetProperty(ASM_NAME_NAME, (LPVOID)wzAssemblyName, &cbAssemblyName);
-            *pcchAssemblyName = cbAssemblyName / sizeof(WCHAR);
-        }
-    }
-    EX_CATCH_HRESULT(hr);
-
-    return hr;
-}
-#endif //FEATURE_FUSION
 
 #ifdef CROSSGEN_COMPILE
 //
@@ -2910,11 +2593,7 @@ public:
         LIMITED_METHOD_CONTRACT;
     }
 
-#ifdef FEATURE_CORECLR
 #define WRITER_LOAD_ERROR_MESSAGE W("Unable to load ") NATIVE_SYMBOL_READER_DLL W(".  Please ensure that ") NATIVE_SYMBOL_READER_DLL W(" is on the path.  Error='%d'\n")
-#else
-#define WRITER_LOAD_ERROR_MESSAGE W("Unable to load diasymreader.dll.  Please ensure that version 11 or greater of diasymreader.dll is on the path.  You can typically find this DLL in the desktop .NET install directory for 4.5 or greater.  Error='%d'\n")
-#endif
 
     HRESULT Load(LPCWSTR wszDiasymreaderPath = nullptr)
     {
@@ -2942,11 +2621,7 @@ public:
         {
             hr = FakeCoCreateInstanceEx(
                 CLSID_CorSymBinder_SxS,
-#ifdef FEATURE_CORECLR
                 wszDiasymreaderPath != nullptr ? wszDiasymreaderPath : (LPCWSTR)NATIVE_SYMBOL_READER_DLL,
-#else
-                wszDiasymreaderPath,
-#endif
                 IID_ISymUnmanagedBinder,
                 (void**)&m_pBinder,
                 NULL);
@@ -4952,9 +4627,6 @@ void CEECompileInfo::SetAssemblyHardBindList(
 {
     STANDARD_VM_CONTRACT;
 
-#ifndef FEATURE_CORECLR // hardbinding
-    GetAppDomain()->ToCompilationDomain()->SetAssemblyHardBindList(pHardBindList, cHardBindList);
-#endif
 }
 
 HRESULT CEECompileInfo::SetVerboseLevel(
@@ -6603,9 +6275,6 @@ void CEEPreloader::PrePrepareMethodIfNecessary(CORINFO_METHOD_HANDLE hMethod)
 {
     STANDARD_VM_CONTRACT;
 
-#ifdef FEATURE_CER
-    ::PrePrepareMethodIfNecessary(hMethod);
-#endif
 }
 
 static void SetStubMethodDescOnInteropMethodDesc(MethodDesc* pInteropMD, MethodDesc* pStubMD, bool fReverseStub)
@@ -7254,11 +6923,6 @@ CompilationDomain::CompilationDomain(BOOL fForceDebug,
 {
     STANDARD_VM_CONTRACT;
 
-#ifndef FEATURE_CORECLR // hardbinding
-    m_hardBoundModules.Init(FALSE, NULL);
-    m_cantHardBindModules.Init(FALSE, NULL);
-    m_useHardBindList = FALSE;
-#endif
 }
 
 void CompilationDomain::ReleaseDependencyEmitter()
@@ -7307,11 +6971,6 @@ void CompilationDomain::Init()
     Security::SetDefaultAppDomainProperty(GetSecurityDescriptor());
     SetCompilationDomain();
 
-#ifndef FEATURE_CORECLR
-    // We need the Compilation Domain to be homogeneous.  We've already forced everything to be full trust.
-    // However, CheckZapSecurity needs this to be set, so set it here.
-    GetSecurityDescriptor()->SetHomogeneousFlag(TRUE);
-#endif // !FEATURE_CORECLR
 
 #ifdef _DEBUG 
     g_pConfig->DisableGenerateStubForHost();
@@ -7374,9 +7033,6 @@ HRESULT CompilationDomain::AddDependencyEntry(PEAssembly *pFile,
     pDependency->dwAssemblyDef = def;
 
     pDependency->signNativeImage = INVALID_NGEN_SIGNATURE;
-#ifdef FEATURE_APTCA
-    pDependency->dependencyInfo = CorCompileDependencyInfo(0);
-#endif //FEATURE_APTCA
 
     if (pFile)
     {
@@ -7384,49 +7040,8 @@ HRESULT CompilationDomain::AddDependencyEntry(PEAssembly *pFile,
         // Note that this can trigger an assembly load (of mscorlib)
         pAssembly->GetOptimizedIdentitySignature(&pDependency->signAssemblyDef);
 
-#if defined(FEATURE_APTCA) || !defined(FEATURE_CORECLR)
-        ReleaseHolder<IMDInternalImport> pAssemblyMD(pFile->GetMDImportWithRef());
-#endif
-
-#ifdef FEATURE_APTCA
-        // determine if there's an APTCA reference, before we retrieve the target file version (for killbit)
-        TokenSecurityDescriptorFlags assemblySecurityAttributes =
-            TokenSecurityDescriptor::ReadSecurityAttributes(pAssemblyMD, TokenFromRid(1, mdtAssembly));
-
-        pFile->AddRef();
-
-        BOOL fIsAptca = assemblySecurityAttributes & (TokenSecurityDescriptorFlags_APTCA
-                                                      | TokenSecurityDescriptorFlags_ConditionalAPTCA);
-        if (fIsAptca)
-        {
-            //  get the file path
-            LPCWSTR pwszPath = pFile->GetPath().GetUnicode();
-            if (pwszPath == NULL)
-            {
-                return E_FAIL;
-            }
-            // retrieve the file version based on the file path (using Watson OS wrapper)
-            if (FAILED(GetFileVersion(pwszPath, &pDependency->uliFileVersion)))
-                // ignore failures (e.g. platform doesn't support file version, or version info missing
-
-            {
-                fIsAptca = FALSE;
-            }
-        }
-        if (fIsAptca)
-        {
-            pDependency->dependencyInfo = CorCompileDependencyInfo(pDependency->dependencyInfo
-                                                                   | CORCOMPILE_DEPENDENCY_IS_APTCA);
-            }
 
-        if (assemblySecurityAttributes & TokenSecurityDescriptorFlags_ConditionalAPTCA)
-        {
-            pDependency->dependencyInfo = CorCompileDependencyInfo(pDependency->dependencyInfo
-                                                                   | CORCOMPILE_DEPENDENCY_IS_CAPTCA);
-        }
-#endif //FEATURE_APTCA
 
-#ifdef FEATURE_CORECLR // hardbinding
         //
         // This is done in CompilationDomain::CanEagerBindToZapFile with full support for hardbinding
         //
@@ -7435,59 +7050,7 @@ HRESULT CompilationDomain::AddDependencyEntry(PEAssembly *pFile,
             CORCOMPILE_VERSION_INFO * pNativeVersion = pFile->GetLoadedNative()->GetNativeVersionInfo();
             pDependency->signNativeImage = pNativeVersion->signature;
         }
-#endif
-
-#ifndef FEATURE_CORECLR
-        // Find the architecture of the dependency, using algorithm from Fusion GetRuntimeVersionForAssembly.
-        // Normally, when an assembly is loaded at runtime, Fusion determines its architecture based on the
-        // metadata. However, if assembly load is skipped due to presence of native image, then Fusion needs
-        // to get assembly architecture from another source. For assemblies in GAC, the GAC structure provides
-        // architecture data. For assemblies outside of GAC, however, no other source of info is available.
-        // So we calculate the architecture now and store it in the native image, to make it available to Fusion.
-        // The algorithm here must exactly match  the algorithm in GetRuntimeVersionForAssembly.
-        LPCSTR pszPERuntime;
-        IfFailThrow(pAssemblyMD->GetVersionString(&pszPERuntime));
-
-        if (SString::_strnicmp(pszPERuntime, "v1.0", 4) != 0 &&
-            SString::_strnicmp(pszPERuntime, "v1.1", 4) != 0 &&
-            SString::_stricmp(pszPERuntime, "Standard CLI 2002") != 0)
-        {
-            // Get the PE architecture of this dependency, similar to PEAssembly::GetFusionProcessorArchitecture.
-            // The difference is when NI is loaded, PEAssembly::GetFusionProcessorArchitecture returns the
-            // architecture of the NI (which is never processor neutral), but we want the architecture
-            // associated with the IL image.
-            DWORD dwPEKind, dwMachine;
-            if (pFile->HasNativeImage())
-            {
-                // CrossGen can load an NI without loading the corresponding IL image, in which case
-                // PEAssembly::GetILImage() actually returns an NI. Thus we need specific code to handle NI.
-                PEImageHolder pImage(pFile->GetNativeImageWithRef());
-                pImage->GetNativeILPEKindAndMachine(&dwPEKind, &dwMachine);
-            }
-            else
-            {
-                pFile->GetILimage()->GetPEKindAndMachine(&dwPEKind, &dwMachine);
-            }
 
-            DWORD dwAssemblyFlags = 0;
-            IfFailThrow(pAssemblyMD->GetAssemblyProps(TokenFromRid(1, mdtAssembly),
-                NULL, NULL, NULL,
-                NULL, NULL, &dwAssemblyFlags));
-
-            PEKIND peKind;
-            if (SUCCEEDED(TranslatePEToArchitectureType(
-                (CorPEKind)dwPEKind,
-                dwMachine,
-                dwAssemblyFlags,
-                &peKind)))
-            {
-                CorCompileDependencyInfo peKindShifted = CorCompileDependencyInfo(peKind << CORCOMPILE_DEPENDENCY_PEKIND_SHIFT);
-                _ASSERTE(peKindShifted == (peKindShifted & CORCOMPILE_DEPENDENCY_PEKIND_MASK));
-                pDependency->dependencyInfo = CorCompileDependencyInfo(pDependency->dependencyInfo
-                    | (peKindShifted & CORCOMPILE_DEPENDENCY_PEKIND_MASK));
-            }
-        }
-#endif //FEATURE_FUSION
     }
 
     return S_OK;
@@ -7659,68 +7222,6 @@ AssemblySpec* CompilationDomain::FindAssemblyRefSpecForDefSpec(
     return (pEntry != NULL) ? pEntry->m_pRef : NULL;
 }
 
-#ifndef FEATURE_CORECLR // hardbinding
-//----------------------------------------------------------------------------
-// Was the assembly asked to be hard-bound to?
-
-BOOL CompilationDomain::IsInHardBindRequestList(Assembly * pAssembly)
-{
-    return IsInHardBindRequestList(pAssembly->GetManifestFile());
-}
-
-BOOL CompilationDomain::IsInHardBindRequestList(PEAssembly * pAssembly)
-{
-    if (!m_useHardBindList)
-        return FALSE;
-
-    StackSString displayName;
-    pAssembly->GetDisplayName(displayName);
-
-    for (COUNT_T i = 0; i < m_assemblyHardBindList.GetCount(); i++)
-    {
-        if (displayName.Equals(m_assemblyHardBindList[i]))
-            return TRUE;
-    }
-
-    return FALSE;
-}
-
-BOOL CompilationDomain::IsSafeToHardBindTo(PEAssembly * pAssembly)
-{
-    WRAPPER_NO_CONTRACT;
-    // The dependency worker does not have m_useHardBindList set.
-    // We do want to allow all possible native images to be loaded in this case.
-    if (!m_useHardBindList)
-        return TRUE;
-
-    if (CompilationDomain::IsInHardBindRequestList(pAssembly))
-        return TRUE;
-
-    return FALSE;
-}
-
-PtrHashMap::PtrIterator CompilationDomain::IterateHardBoundModules()
-{
-    WRAPPER_NO_CONTRACT;
-    return m_hardBoundModules.begin();
-}
-
-void CompilationDomain::SetAssemblyHardBindList(
-        __in_ecount( cHardBindList )
-            LPWSTR *pHardBindList,
-        DWORD cHardBindList)
-{
-    m_assemblyHardBindList.SetCount(0);
-
-    for (DWORD i = 0; i < cHardBindList; i++)
-    {
-        SString s(pHardBindList[i]);
-        m_assemblyHardBindList.Append(s);
-    }
-
-    m_useHardBindList = TRUE;
-}
-#endif // FEATURE_CORECLR
 
 //----------------------------------------------------------------------------
 // Is it OK to embed direct pointers to an ngen dependency?
@@ -7743,261 +7244,13 @@ BOOL CompilationDomain::CanEagerBindToZapFile(Module *targetModule, BOOL limitTo
         return TRUE;
     }
 
-#ifdef FEATURE_CORECLR // hardbinding
     //
     // CoreCLR does not have attributes for fine grained eager binding control.
     // We hard bind to mscorlib.dll only.
     //
     return targetModule->IsSystem();
-#else
-    // Now, look up the hashtables to avoid doing the heavy-duty work everytime
-
-    if (m_cantHardBindModules.LookupValue((UPTR)targetModule, targetModule) !=
-        LPVOID(INVALIDENTRY))
-    {
-        return FALSE;
-    }
-
-    if (m_hardBoundModules.LookupValue((UPTR)targetModule, targetModule) !=
-        LPVOID(INVALIDENTRY))
-    {
-        return TRUE;
-    }
-
-    const char * logMsg = NULL;
-
-    EEConfig::NgenHardBindType ngenHardBindConfig = g_pConfig->NgenHardBind();
-
-    if (ngenHardBindConfig == EEConfig::NGEN_HARD_BIND_NONE)
-    {
-        logMsg = "COMPlus_HardPrejitEnabled=0 is specified";        
-        goto CANNOT_HARD_BIND;
-    }
-
-    if (ngenHardBindConfig == EEConfig::NGEN_HARD_BIND_ALL)
-    {
-        // COMPlus_HardPrejitEnabled=2 is specified
-        limitToHardBindList = FALSE;
-    }
-
-    if (!targetModule->HasNativeImage())
-    {
-        logMsg = "dependency does not have a native image (check FusLogVw for reason)";
-        goto CANNOT_HARD_BIND;
-    }
-
-    // The loader/Fusion cannot currently guarantee that a non-manifest module of a 
-    // hardbound dependency gets eagerly loaded.
-    if (!targetModule->GetFile()->IsAssembly())
-    {
-        logMsg = "dependency is a non-manifest module";
-        goto CANNOT_HARD_BIND;
-    }
-
-    // Don't hard bind to modules not on the list
-    if (limitToHardBindList && m_useHardBindList)
-    {
-        if (!IsInHardBindRequestList(targetModule->GetAssembly()))
-        {
-            logMsg = "dependency was not found in m_assemblyHardBindList";
-            goto CANNOT_HARD_BIND;
-        }
-    }
-
-    // Mark targetModule as a hard dependency
-    //
-    m_hardBoundModules.InsertValue((UPTR)targetModule, targetModule);
-
-    // Update m_pDependencies for the corresponding assembly, to reflect the fact
-    // that we are hard-binding to its native image
-    //
-    PEAssembly * pTargetAssembly;
-    pTargetAssembly = targetModule->GetFile()->GetAssembly();
-    UpdateDependencyEntryForHardBind(pTargetAssembly);
-
-    logMsg = "new dependency";        
-
-    // Try to hardbind to the hardbound dependency closure as there is 
-    // no extra cost in doing so
-    IncludeHardBindClosure(pTargetAssembly);
-
-    LOG((LF_ZAP, LL_INFO100, "Success CanEagerBindToZapFile: %S (%s)\n",
-                             targetModule->GetDebugName(), logMsg));
-
-    return TRUE;
-
-CANNOT_HARD_BIND:
-
-    m_cantHardBindModules.InsertValue((UPTR)targetModule, targetModule);
-
-    // If we have a hard binding list, check if this module is on the list.
-    if (targetModule->GetFile()->IsAssembly() && 
-        IsInHardBindRequestList(targetModule->GetAssembly()))
-    {
-        StackSString displayName;
-        targetModule->GetAssembly()->GetDisplayName(displayName);
-
-        GetSvcLogger()->Printf(LogLevel_Warning, W("WARNING: Cannot hardbind to %s because %S\n"), 
-            displayName.GetUnicode(), logMsg);
-    }
-
-    if (logMsg)
-    {
-        LOG((LF_ZAP, LL_INFO100, "Failure CanEagerBindToZapFile: %S (%s)\n",
-             targetModule->GetDebugName(), logMsg));
-    }
-
-    return FALSE;
-#endif // FEATURE_CORECLR
 }
 
-#if defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)
-
-SArray<LPCWSTR> * s_pPlatformAssembliesPaths;
-
-void ZapperSetPlatformAssembliesPaths(SString &platformAssembliesPaths)
-{
-    STANDARD_VM_CONTRACT;
-
-    _ASSERTE(s_pPlatformAssembliesPaths == NULL);
-    s_pPlatformAssembliesPaths = new SArray<LPCWSTR>();
-
-    SString strPaths(platformAssembliesPaths);
-    if (strPaths.IsEmpty())
-        return;
-
-    for (SString::Iterator i = strPaths.Begin(); i != strPaths.End(); )
-    {
-        // Skip any leading spaces or semicolons
-        if (strPaths.Skip(i, W(';')))
-        {
-            continue;
-        }
-    
-        SString::Iterator iEnd = i;     // Where current assembly name ends
-        SString::Iterator iNext;        // Where next assembly name starts
-        if (strPaths.Find(iEnd, W(';')))
-        {
-            iNext = iEnd + 1;
-        }
-        else
-        {
-            iNext = iEnd = strPaths.End();
-        }
-    
-        _ASSERTE(i < iEnd);
-        if(i != iEnd)
-        {
-            SString strPath(strPaths, i, iEnd);
-
-            SString strFullPath;
-            Clr::Util::Win32::GetFullPathName(strPath, strFullPath, NULL);
-
-            NewArrayHolder<WCHAR> wszFullPath = DuplicateStringThrowing(strFullPath.GetUnicode());
-            s_pPlatformAssembliesPaths->Append(wszFullPath);
-            wszFullPath.SuppressRelease();
-        }
-        i = iNext;
-    }
-}
-
-BOOL CompilationDomain::FindImage(const SString& fileName, MDInternalImportFlags flags, PEImage ** ppImage)
-{
-    if (s_pPlatformAssembliesPaths == NULL)
-        return FALSE;
-
-    for (COUNT_T i = 0; i < s_pPlatformAssembliesPaths->GetCount(); i++)
-    {
-        SString sPath((*s_pPlatformAssembliesPaths)[i]);
-        if (sPath[sPath.GetCount() - 1] != '\\')
-            sPath.Append(W("\\"));
-        sPath.Append(fileName);
-
-        if (!FileExists(sPath))
-            continue;
-
-        // Normalize the path to maintain identity
-        SString sFullPath;
-        Clr::Util::Win32::GetFullPathName(sPath, sFullPath, NULL);
-
-        PEImageHolder image(PEImage::OpenImage(sFullPath, flags));
-
-        PEImageLayoutHolder pLayout(image->GetLayout(
-            (flags == MDInternalImport_NoCache) ? PEImageLayout::LAYOUT_FLAT : PEImageLayout::LAYOUT_MAPPED,
-            PEImage::LAYOUT_CREATEIFNEEDED));
-
-        if (!pLayout->HasNTHeaders())
-            continue;
-
-        if (!pLayout->IsNativeMachineFormat())
-        {
-            // Check for platform agnostic IL
-            if (!pLayout->IsPlatformNeutral())
-                continue;
-        }
-
-        *ppImage = image.Extract();
-        return TRUE;
-    }
-
-    return FALSE;
-}
-
-BOOL CompilationDomain::IsInHardBindList(SString& simpleName)
-{
-    for (COUNT_T i = 0; i < m_assemblyHardBindList.GetCount(); i++)
-    {
-        if (simpleName.Equals(m_assemblyHardBindList[i]))
-            return TRUE;
-    }
-
-    return FALSE;
-}
-
-void CompilationDomain::ComputeAssemblyHardBindList(IMDInternalImport * pImport)
-{
-    AssemblyForLoadHint assembly(pImport);
-
-    HENUMInternalHolder hEnum(pImport);
-    hEnum.EnumAllInit(mdtAssemblyRef);
-
-    mdAssembly token;
-    while (pImport->EnumNext(&hEnum, &token))
-    {
-        LPCSTR pszName;
-        IfFailThrow(pImport->GetAssemblyRefProps(token, NULL, NULL,
-                                                 &pszName, NULL,
-                                                 NULL, NULL, NULL));
-
-        SString sSimpleName(SString::Utf8, pszName);
-
-        SString sFileName(sSimpleName, W(".dll"));
-
-        PEImageHolder pDependencyImage;
-
-        if (!FindImage(sFileName, MDInternalImport_Default, &pDependencyImage))
-            continue;
-
-        AssemblyForLoadHint assemblyDependency(pDependencyImage->GetMDImport());
-
-        LoadHintEnum loadHint;
-        ::GetLoadHint(&assembly, &assemblyDependency, &loadHint);
-
-        if (loadHint == LoadAlways)
-        {
-            GetSvcLogger()->Printf(W("Hardbinding to %s\n"), sSimpleName.GetUnicode());
-
-            if (!IsInHardBindList(sSimpleName))
-            {
-                m_assemblyHardBindList.Append(sSimpleName);
-            }
-        }
-    }
-
-    // Note that we are not setting m_useHardBindList to TRUE here. When we load the NGen image, we are good to hardbind.
-    // m_useHardBindList = TRUE;
-}
-#endif
 
 void CompilationDomain::SetTarget(Assembly *pAssembly, Module *pModule)
 {
@@ -8017,7 +7270,6 @@ void CompilationDomain::SetTargetImage(DataImage *pImage, CEEPreloader * pPreloa
     _ASSERTE(pImage->GetModule() == GetTargetModule());
 }
 
-#if defined(FEATURE_CORECLR) || defined(CROSSGEN_COMPILE)
 void ReportMissingDependency(Exception * e)
 {
     // Avoid duplicate error messages
@@ -8031,7 +7283,6 @@ void ReportMissingDependency(Exception * e)
 
     g_hrFatalError = COR_E_FILELOAD;
 }
-#endif
 
 PEAssembly *CompilationDomain::BindAssemblySpec(
     AssemblySpec *pSpec,
@@ -8062,13 +7313,11 @@ PEAssembly *CompilationDomain::BindAssemblySpec(
     }
     EX_HOOK
     {
-#if defined(FEATURE_CORECLR) || defined(CROSSGEN_COMPILE)
         if (!g_fNGenMissingDependenciesOk)
         {
             ReportMissingDependency(GET_EXCEPTION());
             EX_RETHROW;
         }
-#endif
 
         //
         // Record missing dependencies
@@ -8101,56 +7350,6 @@ HRESULT
 
     COOPERATIVE_TRANSITION_BEGIN();
 
-#ifdef FEATURE_FUSION
-    if (isExe)
-    {
-        if (NingenEnabled())
-        {
-            WCHAR buf[MAX_LONGPATH + sizeof(CONFIGURATION_EXTENSION)/sizeof(WCHAR) + 1];
-            if (0 != wcscpy_s(buf, sizeof(buf)/sizeof(*buf), path))
-            {
-                COMPlusThrowHR(COR_E_PATHTOOLONG);
-            }
-            WCHAR *pSlash = wcsrchr(buf, W('\\'));
-            if (!pSlash)
-            {
-                COMPlusThrowHR(COR_E_BAD_PATHNAME);
-            }
-
-            *(pSlash + 1) = W('\0');
-            hr = m_pFusionContext->Set(ACTAG_APP_BASE_URL, buf, (DWORD)((wcslen(buf) + 1) * sizeof(WCHAR)), 0);
-            if (FAILED(hr))
-            {
-                COMPlusThrowHR(hr);
-            }
-
-            if (0 != wcscpy_s(buf, sizeof(buf)/sizeof(*buf), path + (pSlash - buf) + 1))
-            {
-                COMPlusThrowHR(COR_E_PATHTOOLONG);
-            }
-
-            if (0 != wcscat_s(buf, sizeof(buf)/sizeof(*buf), CONFIGURATION_EXTENSION))
-            {
-                COMPlusThrowHR(COR_E_PATHTOOLONG);
-            }
-            hr = m_pFusionContext->Set(ACTAG_APP_CONFIG_FILE, buf, (DWORD)((wcslen(buf) + 1) * sizeof(WCHAR)), 0);
-            if (FAILED(hr))
-            {
-                COMPlusThrowHR(hr);
-            }
-        }
-        else
-        {
-            SetupExecutableFusionContext(path);
-        }
-    }
-    else
-    {
-        hr = m_pFusionContext->Set(ACTAG_APP_BASE_URL,
-                                   (void*) path, (DWORD) ((wcslen(path)+1) * sizeof(WCHAR)),
-                                   0);
-    }
-#endif //FEATURE_FUSION
 
     COOPERATIVE_TRANSITION_END();
 
@@ -8167,199 +7366,6 @@ void CompilationDomain::SetDependencyEmitter(IMetaDataAssemblyEmit *pEmit)
     m_pDependencyRefSpecs = new AssemblySpecHash();
 }
 
-#ifndef FEATURE_CORECLR // hardbinding
-/* Update m_pDependencies for the corresponding assembly, to reflect the fact
-   that we are hard-binding to its native image
- */
-
-void CompilationDomain::UpdateDependencyEntryForHardBind(PEAssembly * pDependencyAssembly)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(pDependencyAssembly->HasBindableIdentity()); // Currently no hard deps on WinMD files.
-    }
-    CONTRACTL_END;
-    AssemblySpec assemblySpec;
-    assemblySpec.InitializeSpec(pDependencyAssembly);
-
-    mdAssemblyRef defToken;
-    IfFailThrow(assemblySpec.EmitToken(m_pEmit, &defToken));
-
-    CORCOMPILE_DEPENDENCY * pDep = m_pDependencies;
-
-    for (unsigned i = 0; i < m_cDependenciesCount; i++, pDep++)
-    {
-        if (pDep->dwAssemblyDef == defToken)
-        {
-            PEImage * pNativeImage = pDependencyAssembly->GetPersistentNativeImage();
-            CORCOMPILE_VERSION_INFO * pNativeVersion = pNativeImage->GetLoadedLayout()->GetNativeVersionInfo();
-            _ASSERTE(pDep->signNativeImage == INVALID_NGEN_SIGNATURE ||
-                     pDep->signNativeImage == pNativeVersion->signature);
-            pDep->signNativeImage = pNativeVersion->signature;
-            return;
-        }
-    }
-
-    // We should have found and updated the corresponding dependency
-    _ASSERTE(!"This should be unreachable");
-}
-
-// pAssembly is a hardbound ngen dependency of m_pTargetModule.
-// Try to hardbind to the hardbound dependency closure as there is 
-// no extra cost in doing so, and it will help generate better code
-//
-
-void CompilationDomain::IncludeHardBindClosure(PEAssembly * pAssembly)
-{
-    CONTRACTL {
-        PRECONDITION(pAssembly->GetPersistentNativeImage() != NULL);
-    } CONTRACTL_END;
-
-    PEImageLayout *pNativeImage = pAssembly->GetLoadedNative();
-    COUNT_T cDependencies;
-    CORCOMPILE_DEPENDENCY *pDependencies = pNativeImage->GetNativeDependencies(&cDependencies);
-    CORCOMPILE_DEPENDENCY *pDependenciesEnd = pDependencies + cDependencies;
-
-    for (/**/; pDependencies < pDependenciesEnd; pDependencies++)
-    {
-        // Ignore "soft" dependencies
-
-        if (pDependencies->signNativeImage == INVALID_NGEN_SIGNATURE)
-            continue;
-
-        // Load the manifest file for the given hardbound name-assembly-spec.
-
-        AssemblySpec name;
-        name.InitializeSpec(pDependencies->dwAssemblyRef,
-                            pAssembly->GetPersistentNativeImage()->GetNativeMDImport(),
-                            FindAssembly(pAssembly),
-                            FALSE);
-
-        DomainAssembly * pDependency = name.LoadDomainAssembly(FILE_LOADED);
-
-        // Since pAssembly hardbinds to pDependency, pDependency better
-        // have a native image
-        _ASSERTE(pDependency->GetFile()->HasNativeImage());
-
-        //
-        // Now add pDependency as a hard dependency of m_pTargetModule.
-        // We pass in limitToHardBindList=FALSE as it is OK to hardbind even if
-        // pDependency is not in the hardbound list.
-        //
-
-        CanEagerBindToZapFile(pDependency->GetLoadedModule(), FALSE);
-    }
-}
-
-//-----------------------------------------------------------------------------
-// Check if we were successfully able to hardbind to the requested dependency
-
-void CompilationDomain::CheckHardBindToZapFile(SString dependencyNameFromCA)
-{
-    // First check if we were successfully able to hard-bind
-    
-    for (PtrHashMap::PtrIterator hbItr = m_hardBoundModules.begin(); !hbItr.end(); ++hbItr)
-    {
-        Module * pModule = (Module*) hbItr.GetValue();
-
-        if (IsAssemblySpecifiedInCA(pModule->GetAssembly(), dependencyNameFromCA))
-        {
-            // We did successfully use "dependencyNameFromCA"
-            return;
-        }
-    }
-
-    // Next, check if we failed to hard-bind. CompilationDomain::CanEagerBindToZapFile()
-    // would have logged a warning message with the cause of the soft-bind
-    
-    for (PtrHashMap::PtrIterator sbItr = m_cantHardBindModules.begin(); !sbItr.end(); ++sbItr)
-    {
-        Module * pModule = (Module*) sbItr.GetValue();
-
-        if (IsAssemblySpecifiedInCA(pModule->GetAssembly(), dependencyNameFromCA))
-        {
-            if (!IsInHardBindRequestList(pModule->GetAssembly()))
-            {
-                // CompilationDomain::CanEagerBindToZapFile() does not give a warning
-                // message for the cyclic dependency case, since the NGEN service
-                // breaks the cycle by overriding the CA. So give a message here instead.
-                GetSvcLogger()->Printf(LogLevel_Warning, W("WARNING: Dependency attribute for %s is being ignored, possibly because of cyclic dependencies.\n"), 
-                    dependencyNameFromCA.GetUnicode());
-            }
-            return;
-        }
-    }
-
-    // Finally, it looks like the assembly was either not loaded, or that
-    // there was no reason to even try to hard-bind.
-
-    GetSvcLogger()->Printf(LogLevel_Warning, W("WARNING: Cannot hardbind to %s because it is not loaded\n"), 
-        dependencyNameFromCA.GetUnicode());
-}
-
-//-----------------------------------------------------------------------------
-// Check if we were successfully able to hardbind to all the requested
-// dependencies.
-
-void CompilationDomain::CheckLoadHints()
-{
-    if (!m_useHardBindList)
-        return;
-    
-    if (g_pConfig->NgenHardBind() == EEConfig::NGEN_HARD_BIND_NONE)
-        return;
-
-    // Look for the binding custom attribute
-
-    IMDInternalImport * pImport = m_pTargetAssembly->GetManifestImport();
-    _ASSERTE(pImport);
-
-    MDEnumHolder hEnum(pImport);        // Enumerator for custom attributes
-    if (FAILED(pImport->EnumCustomAttributeByNameInit(m_pTargetAssembly->GetManifestToken(),
-                                                     DEPENDENCY_TYPE, 
-                                                     &hEnum)))
-    {
-        return;
-    }
-
-    mdCustomAttribute tkAttribute;      // A custom attribute on this assembly.
-    const BYTE  *pbAttr;                // Custom attribute data as a BYTE*.
-    ULONG       cbAttr;                 // Size of custom attribute data.
-
-    while (pImport->EnumNext(&hEnum, &tkAttribute))
-    {   // Get raw custom attribute.
-        IfFailThrow(pImport->GetCustomAttributeAsBlob(tkAttribute, (const void**)&pbAttr, &cbAttr));
-
-        CustomAttributeParser cap(pbAttr, cbAttr);
-        if (FAILED(cap.ValidateProlog()))
-        {
-            THROW_BAD_FORMAT(BFA_BAD_CA_HEADER, m_pTargetAssembly->GetManifestModule());
-        }
-
-        LPCUTF8 szString;
-        ULONG   cbString;
-        if (FAILED(cap.GetNonNullString(&szString, &cbString)))
-        {
-            THROW_BAD_FORMAT(BFA_BAD_CA_STRING, m_pTargetAssembly->GetManifestModule());
-        }
-
-        UINT32 u4;
-        IfFailThrow(cap.GetU4(&u4));
-        LoadHintEnum loadHint = (LoadHintEnum)u4;
-
-        if (loadHint != LoadAlways)
-            continue;
-
-        // Convert the string to Unicode.
-        StackSString dependencyNameFromCA(SString::Utf8, szString, cbString);
-
-        CheckHardBindToZapFile(dependencyNameFromCA);
-    }
-}
-#endif // FEATURE_CORECLR
 
 HRESULT
     CompilationDomain::GetDependencies(CORCOMPILE_DEPENDENCY **ppDependencies,
@@ -8367,9 +7373,6 @@ HRESULT
 {
     STANDARD_VM_CONTRACT;
 
-#ifndef FEATURE_CORECLR // hardbinding
-    CheckLoadHints();
-#endif
 
     //
     // Return the bindings.
@@ -8384,27 +7387,6 @@ HRESULT
     return S_OK;
 }
 
-#ifdef FEATURE_FUSION
-HRESULT
-    CompilationDomain::GetIBindContext(IBindContext **ppBindCtx)
-{
-    LIMITED_METHOD_CONTRACT;
-    HRESULT hr = S_OK;
-
-    ReleaseHolder<IBindContext> pBindCtx;
-    if (HasLoadContextHostBinder())
-    {
-        IfFailRet(GetCurrentLoadContextHostBinder()->QueryInterface(__uuidof(IBindContext), &pBindCtx));
-    }
-    else
-    {
-        GetBindContextFromApplicationContext(BaseDomain::GetFusionContext(), &pBindCtx); // Can't fail
-    }
-
-    *ppBindCtx = pBindCtx.Extract();
-    return S_OK;
-}
-#endif
 
 #ifdef CROSSGEN_COMPILE
 HRESULT CompilationDomain::SetPlatformWinmdPaths(LPCWSTR pwzPlatformWinmdPaths)
@@ -8452,16 +7434,5 @@ HRESULT CompilationDomain::SetPlatformWinmdPaths(LPCWSTR pwzPlatformWinmdPaths)
 }
 #endif // CROSSGEN_COMPILE
 
-#if defined(_TARGET_AMD64_) && !defined(FEATURE_CORECLR)
-bool UseRyuJit()
-{
-#ifdef CROSSGEN_COMPILE
-    return true;
-#else
-    static ConfigDWORD useRyuJitValue;
-    return useRyuJitValue.val(CLRConfig::INTERNAL_UseRyuJit) == 1 || IsNgenOffline();
-#endif
-}
-#endif
 
 #endif // FEATURE_PREJIT
diff --git a/src/vm/compile.h b/src/vm/compile.h
index 8ee66dbec8..7aeef31b6c 100644
--- a/src/vm/compile.h
+++ b/src/vm/compile.h
@@ -207,21 +207,6 @@ class CEECompileInfo : public ICorCompileInfo
                                BOOL                     fExplicitBindToNativeImage,
                                CORINFO_ASSEMBLY_HANDLE *pHandle);
 
-#ifdef FEATURE_FUSION
-    HRESULT LoadAssemblyByName(LPCWSTR                  wzName,
-                               CORINFO_ASSEMBLY_HANDLE *pHandle);
-
-    HRESULT LoadAssemblyRef(IMDInternalImport     *pAssemblyImport,
-                            mdAssemblyRef           ref,
-                            CORINFO_ASSEMBLY_HANDLE *pHandle,
-                            IAssemblyName           **refAssemblyName = NULL);
-
-    HRESULT LoadAssemblyByIAssemblyName(
-            IAssemblyName           *pAssemblyName,
-            CORINFO_ASSEMBLY_HANDLE *pHandle
-            );
-
-#endif //FEATURE_FUSION
 
 #ifdef FEATURE_COMINTEROP
     HRESULT LoadTypeRefWinRT(IMDInternalImport       *pAssemblyImport,
@@ -235,12 +220,6 @@ class CEECompileInfo : public ICorCompileInfo
                                mdFile                  file,
                                CORINFO_MODULE_HANDLE   *pHandle);
 
-#ifndef FEATURE_CORECLR
-    // Check if the assembly supports automatic NGen
-    BOOL SupportsAutoNGen(CORINFO_ASSEMBLY_HANDLE assembly);
-
-    HRESULT SetCachedSigningLevel(HANDLE hNI, HANDLE *pModules, COUNT_T nModules);
-#endif
 
     BOOL CheckAssemblyZap(
         CORINFO_ASSEMBLY_HANDLE assembly, 
@@ -343,13 +322,6 @@ class CEECompileInfo : public ICorCompileInfo
                                     ICorCompileDataStore    *pData,
                                     CorProfileData          *profileData);
 
-#ifdef FEATURE_FUSION
-    HRESULT GetAssemblyName(
-            CORINFO_ASSEMBLY_HANDLE hAssembly,
-            DWORD                   dwFlags,
-            __out_z LPWSTR          wzAssemblyName, 
-            LPDWORD                 cchAssemblyName);
-#endif //FEATURE_FUSION
     
     HRESULT GetLoadHint(CORINFO_ASSEMBLY_HANDLE   hAssembly,
                         CORINFO_ASSEMBLY_HANDLE hAssemblyDependency,
@@ -757,9 +729,6 @@ typedef SHash<AssemblySpecDefRefMapTraits> AssemblySpecMapDefRefMapTable;
 class CompilationDomain : public AppDomain, 
                           public ICorCompilationDomain
 {
-#ifndef FEATURE_CORECLR
-    VPTR_MULTI_VTABLE_CLASS(CompilationDomain, AppDomain);
-#endif
 
  public:
     BOOL                    m_fForceDebug; 
@@ -796,14 +765,6 @@ class CompilationDomain : public AppDomain,
     HRESULT AddDependencyEntry(PEAssembly *pFile, mdAssemblyRef ref,mdAssemblyRef def);
     void ReleaseDependencyEmitter();
 
-#ifndef FEATURE_CORECLR // hardbinding
-    PtrHashMap              m_hardBoundModules;     // Hard dependency on native image of these dependency modules
-    PtrHashMap              m_cantHardBindModules;
-    void UpdateDependencyEntryForHardBind(PEAssembly * pDependencyAssembly);
-    void IncludeHardBindClosure(PEAssembly * pDependencyAssembly);
-    void CheckHardBindToZapFile(SString dependencyNameFromCustomAttribute);
-    void CheckLoadHints();
-#endif
 
   public:
 
@@ -831,28 +792,7 @@ class CompilationDomain : public AppDomain,
 
     BOOL CanEagerBindToZapFile(Module *targetModule, BOOL limitToHardBindList = TRUE);
 
-#ifndef FEATURE_CORECLR // hardbinding
-    PtrHashMap::PtrIterator IterateHardBoundModules();
-
-    // List of full display names of assemblies to hard-bind to
-    SArray<SString,FALSE> m_assemblyHardBindList;
-    BOOL                  m_useHardBindList;
-    BOOL IsInHardBindRequestList(Assembly * pAssembly);
-    BOOL IsInHardBindRequestList(PEAssembly * pAssembly);
-    BOOL IsSafeToHardBindTo(PEAssembly * pAssembly);
-
-    void SetAssemblyHardBindList(
-                        __in_ecount( cHardBindList )
-                            LPWSTR *pHardBindList,
-                        DWORD  cHardBindList);
-#endif
 
-#if defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)
-    void ComputeAssemblyHardBindList(IMDInternalImport * pImport);
-    BOOL IsInHardBindList(SString& simpleName);
-
-    static BOOL FindImage(const SString& fileName, MDInternalImportFlags flags, PEImage ** ppImage);
-#endif
 
     // Returns NULL on out-of-memory
     RefCache *GetRefCache(Module *pModule)
@@ -898,9 +838,6 @@ class CompilationDomain : public AppDomain,
     HRESULT SetContextInfo(LPCWSTR exePath, BOOL isExe) DAC_EMPTY_RET(E_FAIL);
     HRESULT GetDependencies(CORCOMPILE_DEPENDENCY **ppDependencies,
                             DWORD *cDependencies) DAC_EMPTY_RET(E_FAIL);
-#ifdef FEATURE_FUSION
-    HRESULT GetIBindContext(IBindContext **ppBindCtx) DAC_EMPTY_RET(E_FAIL);
-#endif
 
 #ifdef CROSSGEN_COMPILE
     HRESULT SetPlatformWinmdPaths(LPCWSTR pwzPlatformWinmdPaths) DAC_EMPTY_RET(E_FAIL);
diff --git a/src/vm/comsynchronizable.cpp b/src/vm/comsynchronizable.cpp
index e62ec13dde..3a395235e6 100644
--- a/src/vm/comsynchronizable.cpp
+++ b/src/vm/comsynchronizable.cpp
@@ -28,9 +28,7 @@
 #include "remoting.h"
 #endif
 #include "eeconfig.h"
-#include "stackcompressor.h"
 #ifdef FEATURE_REMOTING
-#include "appdomainhelper.h"
 #include "objectclone.h"
 #else
 #include "callhelpers.h"
@@ -53,9 +51,8 @@ struct SharedState
     OBJECTHANDLE    m_Threadable;
     OBJECTHANDLE    m_ThreadStartArg;
     Thread         *m_Internal;
-    OBJECTHANDLE    m_Principal;
 
-    SharedState(OBJECTREF threadable, OBJECTREF threadStartArg, Thread *internal, OBJECTREF principal)
+    SharedState(OBJECTREF threadable, OBJECTREF threadStartArg, Thread *internal)
     {
         CONTRACTL
         {
@@ -72,8 +69,6 @@ struct SharedState
         m_ThreadStartArg = ad->CreateHandle(threadStartArg);
 
         m_Internal = internal;
-
-        m_Principal = ad->CreateHandle(principal);
     }
 
     ~SharedState()
@@ -96,7 +91,6 @@ struct SharedState
         {
             DestroyHandle(m_Threadable);
             DestroyHandle(m_ThreadStartArg);
-            DestroyHandle(m_Principal);
         }
     }
 };
@@ -231,7 +225,6 @@ void ThreadNative::KickOffThread_Worker(LPVOID ptr)
     // we are saving the delagate and result primarily for debugging
     struct _gc
     {
-        OBJECTREF orPrincipal;
         OBJECTREF orThreadStartArg;
         OBJECTREF orDelegate;
         OBJECTREF orResult;
@@ -245,22 +238,6 @@ void ThreadNative::KickOffThread_Worker(LPVOID ptr)
     GCPROTECT_BEGIN(gc);
     BEGIN_SO_INTOLERANT_CODE(pThread);
 
-    gc.orPrincipal = ObjectFromHandle(args->share->m_Principal);
-
-#ifdef FEATURE_IMPERSONATION
-    // Push the initial security principal object (if any) onto the
-    // managed thread.
-    if (gc.orPrincipal != NULL)
-    {
-        gc.orThread = args->pThread->GetExposedObject();
-        MethodDescCallSite setPrincipalInternal(METHOD__THREAD__SET_PRINCIPAL_INTERNAL, &gc.orThread);
-        ARG_SLOT argsToSetPrincipal[2];
-        argsToSetPrincipal[0] = ObjToArgSlot(gc.orThread);
-        argsToSetPrincipal[1] = ObjToArgSlot(gc.orPrincipal);
-        setPrincipalInternal.Call(argsToSetPrincipal);
-    }
-#endif
-
     gc.orDelegate = ObjectFromHandle(args->share->m_Threadable);
     gc.orThreadStartArg = ObjectFromHandle(args->share->m_ThreadStartArg);
 
@@ -435,20 +412,20 @@ ULONG __stdcall ThreadNative::KickOffThread(void* pass)
 }
 
 
-FCIMPL3(void, ThreadNative::Start, ThreadBaseObject* pThisUNSAFE, Object* pPrincipalUNSAFE, StackCrawlMark* pStackMark)
+FCIMPL2(void, ThreadNative::Start, ThreadBaseObject* pThisUNSAFE, StackCrawlMark* pStackMark)
 {
     FCALL_CONTRACT;
 
     HELPER_METHOD_FRAME_BEGIN_NOPOLL();
 
-    StartInner(pThisUNSAFE, pPrincipalUNSAFE, pStackMark);
+    StartInner(pThisUNSAFE, pStackMark);
 
     HELPER_METHOD_FRAME_END_POLL();
 }
 FCIMPLEND
 
 // Start up a thread, which by now should be in the ThreadStore's Unstarted list.
-void ThreadNative::StartInner(ThreadBaseObject* pThisUNSAFE, Object* pPrincipalUNSAFE, StackCrawlMark* pStackMark)
+void ThreadNative::StartInner(ThreadBaseObject* pThisUNSAFE, StackCrawlMark* pStackMark)
 {
     CONTRACTL
     {
@@ -460,11 +437,9 @@ void ThreadNative::StartInner(ThreadBaseObject* pThisUNSAFE, Object* pPrincipalU
 
     struct _gc
     {
-        OBJECTREF       pPrincipal;
         THREADBASEREF   pThis;
     } gc;
 
-    gc.pPrincipal  = (OBJECTREF) pPrincipalUNSAFE;
     gc.pThis       = (THREADBASEREF) pThisUNSAFE;
 
     GCPROTECT_BEGIN(gc);
@@ -499,7 +474,7 @@ void ThreadNative::StartInner(ThreadBaseObject* pThisUNSAFE, Object* pPrincipalU
 
         // Allocate this away from our stack, so we can unwind without affecting
         // KickOffThread.  It is inside a GCFrame, so we can enable GC now.
-        NewHolder<SharedState> share(new SharedState(threadable, threadStartArg, pNewThread, gc.pPrincipal));
+        NewHolder<SharedState> share(new SharedState(threadable, threadStartArg, pNewThread));
 
         pNewThread->IncExternalCount();
 
@@ -631,59 +606,6 @@ FCIMPL1(void, ThreadNative::ResetAbort, ThreadBaseObject* pThis)
 }
 FCIMPLEND
 
-#ifndef FEATURE_CORECLR
-// You can only suspend a running thread.
-FCIMPL1(void, ThreadNative::Suspend, ThreadBaseObject* pThisUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    if (pThisUNSAFE == NULL)
-        FCThrowResVoid(kNullReferenceException, W("NullReference_This"));
-
-    Thread  *thread = pThisUNSAFE->GetInternal();
-
-    HELPER_METHOD_FRAME_BEGIN_0();
-
-#ifdef MDA_SUPPORTED
-    MDA_TRIGGER_ASSISTANT(DangerousThreadingAPI, ReportViolation(W("System.Threading.Thread.Suspend")));
-#endif
-    
-    if (!ThreadIsRunning(thread))
-        COMPlusThrow(kThreadStateException, IDS_EE_THREAD_SUSPEND_NON_RUNNING);
-
-    thread->UserSuspendThread();
-
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-
-// You can only resume a thread that is in the user-suspended state.  (This puts a large
-// burden on the app developer, but we want him to be thinking carefully about race
-// conditions.  Precise errors give him a hope of sorting out his logic).
-FCIMPL1(void, ThreadNative::Resume, ThreadBaseObject* pThisUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    if (pThisUNSAFE == NULL)
-        FCThrowResVoid(kNullReferenceException, W("NullReference_This"));
-
-    Thread  *thread = pThisUNSAFE->GetInternal();
-
-    HELPER_METHOD_FRAME_BEGIN_0();
-
-    // UserResumeThread() will return 0 if there isn't a user suspension for us to
-    // clear.
-    if (!ThreadIsRunning(thread))
-        COMPlusThrow(kThreadStateException, IDS_EE_THREAD_RESUME_NON_RUNNING);
-
-    if (thread->UserResumeThread() == 0)
-        COMPlusThrow(kThreadStateException, IDS_EE_THREAD_RESUME_NON_USER_SUSPEND);
-
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-
-#endif // FEATURE_CORECLR
 
 // Note that you can manipulate the priority of a thread that hasn't started yet,
 // or one that is running.  But you get an exception if you manipulate the priority
@@ -1937,41 +1859,6 @@ UINT64 QCALLTYPE ThreadNative::GetProcessDefaultStackSize()
     return (UINT64)reserve;
 }
 
-#ifndef FEATURE_CORECLR
-FCIMPL0(void, ThreadNative::BeginCriticalRegion)
-{
-    FCALL_CONTRACT;
-    if (CLRHosted())
-    {
-        GetThread()->BeginCriticalRegion_NoCheck();
-    }
-}
-FCIMPLEND
-
-FCIMPL0(void, ThreadNative::EndCriticalRegion)
-{
-    FCALL_CONTRACT;
-    if (CLRHosted())
-    {
-        GetThread()->EndCriticalRegion_NoCheck();
-    }
-}
-FCIMPLEND
-
-FCIMPL0(void, ThreadNative::BeginThreadAffinity)
-{
-    FCALL_CONTRACT;
-    Thread::BeginThreadAffinity();
-}
-FCIMPLEND
-
-FCIMPL0(void, ThreadNative::EndThreadAffinity)
-{
-    FCALL_CONTRACT;
-    Thread::EndThreadAffinity();
-}
-FCIMPLEND
-#endif // !FEATURE_CORECLR
 
 
 FCIMPL1(FC_BOOL_RET, ThreadNative::IsThreadpoolThread, ThreadBaseObject* thread)
@@ -2041,51 +1928,6 @@ BOOL QCALLTYPE ThreadNative::YieldThread()
     return ret;
 }
 
-#ifdef FEATURE_COMPRESSEDSTACK
-FCIMPL2(void*, ThreadNative::SetAppDomainStack, ThreadBaseObject* pThis, SafeHandle* hcsUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    void* pRet = NULL;
-    SAFEHANDLE hcsSAFE = (SAFEHANDLE) hcsUNSAFE;
-    HELPER_METHOD_FRAME_BEGIN_RET_1(hcsSAFE);
-
-
-    void* unmanagedCompressedStack = NULL;
-    if (hcsSAFE != NULL)
-    {
-        unmanagedCompressedStack = (void *)hcsSAFE->GetHandle();
-    }
-
-
-    VALIDATEOBJECT(pThis);
-    Thread *pThread = pThis->GetInternal();
-    if (pThread == NULL)
-        COMPlusThrow(kThreadStateException, IDS_EE_THREAD_CANNOT_GET);
-
-    pRet = StackCompressor::SetAppDomainStack(pThread, unmanagedCompressedStack);
-    HELPER_METHOD_FRAME_END_POLL();
-    return pRet;
-}
-FCIMPLEND
-
-
-FCIMPL2(void, ThreadNative::RestoreAppDomainStack, ThreadBaseObject* pThis, void* appDomainStack)
-{
-    FCALL_CONTRACT;
-
-    HELPER_METHOD_FRAME_BEGIN_NOPOLL();
-
-    VALIDATEOBJECT(pThis);
-    Thread *pThread = pThis->GetInternal();
-    if (pThread == NULL)
-        COMPlusThrow(kThreadStateException, IDS_EE_THREAD_CANNOT_GET);
-
-    StackCompressor::RestoreAppDomainStack(pThread, appDomainStack);
-    HELPER_METHOD_FRAME_END_POLL();
-}
-FCIMPLEND
-#endif //#ifdef FEATURE_COMPRESSEDSTACK
 
 FCIMPL0(void, ThreadNative::FCMemoryBarrier)
 {
@@ -2152,69 +1994,6 @@ FCIMPL2(void, ThreadNative::SetAbortReason, ThreadBaseObject* pThisUNSAFE, Objec
 }
 FCIMPLEND
 
-#ifndef FEATURE_CORECLR // core clr does not support abort reason 
-FCIMPL1(Object*, ThreadNative::GetAbortReason, ThreadBaseObject *pThisUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    if (pThisUNSAFE==NULL)
-        FCThrowRes(kNullReferenceException, W("NullReference_This"));
-
-    OBJECTREF refRetVal = NULL;
-    Thread   *pThread   = pThisUNSAFE->GetInternal();
-
-    // Set up a frame in case of GC or EH
-    HELPER_METHOD_FRAME_BEGIN_RET_1(refRetVal)
-
-    if (pThread == NULL)
-        COMPlusThrow(kThreadStateException, IDS_EE_THREAD_CANNOT_GET);
-
-    // While the ExceptionInfo probably will be *set* from a different
-    //  thread, it should only be *read* from the current thread.
-    _ASSERTE(GetThread() == pThread);
-
-    // Set cooperative mode, to avoid AD unload while we're working.
-    GCX_COOP();
-
-    OBJECTHANDLE oh=NULL;
-    ADID adid;
-    // Scope the lock to reading the two fields on the Thread object.
-    {   // Atomically get the OBJECTHANDLE and ADID of the object
-        //  NOTE: get the lock on this thread object, not on the executing thread.
-        Thread::AbortRequestLockHolder lock(pThread);
-        oh = pThread->m_AbortReason;
-        adid = pThread->m_AbortReasonDomainID;
-    }
-
-    // If the OBJECTHANDLE is not 0...
-    if (oh != 0)
-    {
-
-        AppDomain *pCurrentDomain = pThread->GetDomain();
-        // See if the appdomain is equal to the appdomain of the currently running
-        //  thread.  
-
-        if (pCurrentDomain->GetId() == adid)
-        {   // Same appdomain; just return object from the OBJECTHANDLE
-            refRetVal = ObjectFromHandle(oh);
-        }
-        else
-        {   // Otherwise, try to marshal the object from the other AppDomain
-            ENTER_DOMAIN_ID(adid);
-            CrossAppDomainClonerCallback cadcc;
-            ObjectClone Cloner(&cadcc, CrossAppDomain, FALSE);
-            refRetVal = Cloner.Clone(ObjectFromHandle(oh), GetAppDomain(), pCurrentDomain, NULL);
-            Cloner.RemoveGCFrames();
-            END_DOMAIN_TRANSITION;
-        }
-    }
-
-    HELPER_METHOD_FRAME_END()
-
-    return OBJECTREFToObject(refRetVal);
-}
-FCIMPLEND
-#endif // !FEATURE_CORECLR
 
 FCIMPL1(void, ThreadNative::ClearAbortReason, ThreadBaseObject* pThisUNSAFE)
 {
diff --git a/src/vm/comsynchronizable.h b/src/vm/comsynchronizable.h
index 65ec21228b..0f727cb056 100644
--- a/src/vm/comsynchronizable.h
+++ b/src/vm/comsynchronizable.h
@@ -64,15 +64,11 @@ public:
     static LPVOID F_CALL_CONV FastGetCurrentThread();
     static LPVOID F_CALL_CONV FastGetDomain();
 
-    static void StartInner(ThreadBaseObject* pThisUNSAFE, Object* pPrincipalUNSAFE, StackCrawlMark* pStackMark);
+    static void StartInner(ThreadBaseObject* pThisUNSAFE, StackCrawlMark* pStackMark);
 
     static FCDECL1(void, Abort, ThreadBaseObject* pThis);
     static FCDECL1(void, ResetAbort, ThreadBaseObject* pThis);
-    static FCDECL3(void,    Start,             ThreadBaseObject* pThisUNSAFE, Object* pPrincipalUNSAFE, StackCrawlMark* pStackMark);
-#ifndef FEATURE_CORECLR
-    static FCDECL1(void,    Suspend,           ThreadBaseObject* pThisUNSAFE);
-    static FCDECL1(void,    Resume,            ThreadBaseObject* pThisUNSAFE);
-#endif // FEATURE_CORECLR
+    static FCDECL2(void,    Start,             ThreadBaseObject* pThisUNSAFE, StackCrawlMark* pStackMark);
     static FCDECL1(INT32,   GetPriority,       ThreadBaseObject* pThisUNSAFE);
     static FCDECL2(void,    SetPriority,       ThreadBaseObject* pThisUNSAFE, INT32 iPriority);
     static FCDECL1(void,    Interrupt,         ThreadBaseObject* pThisUNSAFE);
@@ -109,12 +105,6 @@ public:
     UINT64 QCALLTYPE GetProcessDefaultStackSize();
 
     static FCDECL1(INT32,   GetManagedThreadId, ThreadBaseObject* th);
-#ifndef FEATURE_CORECLR
-    static FCDECL0(void,    BeginCriticalRegion);
-    static FCDECL0(void,    EndCriticalRegion);
-    static FCDECL0(void,    BeginThreadAffinity);
-    static FCDECL0(void,    EndThreadAffinity);
-#endif // !FEATURE_CORECLR
     static FCDECL1(void,    SpinWait,                       int iterations);
     static BOOL QCALLTYPE YieldThread();
     static FCDECL0(Object*, GetCurrentThread);
@@ -126,18 +116,11 @@ public:
     static FCDECL1(FC_BOOL_RET,SetThreadUILocale,              StringObject* localeNameUNSAFE);
 #endif // FEATURE_LEAK_CULTURE_INFO
     static FCDECL1(FC_BOOL_RET,IsThreadpoolThread,             ThreadBaseObject* thread);
-#ifdef FEATURE_COMPRESSEDSTACK    
-    static FCDECL2(void*,    SetAppDomainStack, ThreadBaseObject* pThis, SafeHandle* hcsUNSAFE);
-    static FCDECL2(void,    RestoreAppDomainStack, ThreadBaseObject* pThis, void* appDomainStack);
-#endif // #ifdef FEATURE_COMPRESSEDSTACK
 
     static FCDECL0(void, FCMemoryBarrier);
     static FCDECL1(void, SetIsThreadStaticsArray, Object* pObject);
 
     static FCDECL2(void,    SetAbortReason, ThreadBaseObject* pThisUNSAFE, Object* pObject);
-#ifndef FEATURE_CORECLR	
-    static FCDECL1(Object*, GetAbortReason, ThreadBaseObject* pThisUNSAFE);
-#endif
     static FCDECL1(void,    ClearAbortReason, ThreadBaseObject* pThisUNSAFE);
 
 private:
diff --git a/src/vm/comthreadpool.cpp b/src/vm/comthreadpool.cpp
index a4c7e75064..c26242e85d 100644
--- a/src/vm/comthreadpool.cpp
+++ b/src/vm/comthreadpool.cpp
@@ -632,31 +632,6 @@ void SetAsyncResultProperties(
     STATIC_CONTRACT_MODE_ANY;
     STATIC_CONTRACT_SO_TOLERANT;
 
-#ifndef FEATURE_CORECLR
-    ASYNCRESULTREF asyncResult = overlapped->m_asyncResult;
-    // only filestream is expected to have a null delegate in which
-    // case we do the necessary book-keeping here. However, for robustness
-    // we should make sure that the asyncResult is indeed an instance of
-    // FileStreamAsyncResult
-    if (asyncResult->GetMethodTable() == g_pAsyncFileStream_AsyncResultClass)
-    {
-        // Handle reading from & writing to closed pipes. It's possible for
-        // an async read on a pipe to be issued and then the pipe is closed,
-        // returning this error.  This may very well be necessary. -BG
-        if (dwErrorCode == ERROR_BROKEN_PIPE || dwErrorCode == ERROR_NO_DATA)
-            dwErrorCode = 0;
-        asyncResult->SetErrorCode(dwErrorCode);
-        asyncResult->SetNumBytes(dwNumBytes);
-        asyncResult->SetCompletedAsynchronously();
-        asyncResult->SetIsComplete();
-
-        // Signal the event - the OS does not do this for us.
-        WAITHANDLEREF waitHandle = asyncResult->GetWaitHandle();
-        HANDLE h = waitHandle->GetWaitHandle();
-        if ((h != NULL) && (h != (HANDLE) -1))
-            UnsafeSetEvent(h);
-    }
-#endif // !FEATURE_CORECLR
 }
 
 VOID BindIoCompletionCallBack_Worker(LPVOID args)
@@ -698,13 +673,6 @@ VOID BindIoCompletionCallBack_Worker(LPVOID args)
         // no user delegate to callback
         _ASSERTE((overlapped->m_iocbHelper == NULL) || !"This is benign, but should be optimized");
 
-#ifndef FEATURE_CORECLR
-        // we cannot do this at threadpool initialization time since mscorlib may not have been loaded
-        if (!g_pAsyncFileStream_AsyncResultClass)
-        {
-            g_pAsyncFileStream_AsyncResultClass = MscorlibBinder::GetClass(CLASS__FILESTREAM_ASYNCRESULT);
-        }
-#endif // !FEATURE_CORECLR
 
         SetAsyncResultProperties(overlapped, ErrorCode, numBytesTransferred);
     }
diff --git a/src/vm/comtypelibconverter.cpp b/src/vm/comtypelibconverter.cpp
deleted file mode 100644
index f6f0e1e405..0000000000
--- a/src/vm/comtypelibconverter.cpp
+++ /dev/null
@@ -1,791 +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.
-
-/*============================================================
-**
-** Header:  COMTypeLibConverter.cpp
-**
-**
-** Purpose: Implementation of the native methods used by the 
-**          typelib converter.
-**
-** 
-===========================================================*/
-
-#include "common.h"
-
-#include "comtypelibconverter.h"
-#include "runtimecallablewrapper.h"
-#include "assembly.hpp"
-#include "debugmacros.h"
-#include <tlbimpexp.h>
-#include "..\md\inc\imptlb.h"
-#include <tlbutils.h>
-#include "posterror.h"
-
-BOOL            COMTypeLibConverter::m_bInitialized = FALSE;
-
-void  COMTypeLibConverter::TypeLibImporterWrapper(
-    ITypeLib    *pITLB,                 // Typelib to import.
-    LPCWSTR     szFname,                // Name of the typelib, if known.
-    LPCWSTR     szNamespace,            // Optional namespace override.
-    IMetaDataEmit *pEmit,               // Metadata scope to which to emit.
-    Assembly    *pAssembly,             // Assembly containing the imported module.
-    Module      *pModule,               // Module we are emitting into.
-    ITypeLibImporterNotifySink *pNotify,// Callback interface.
-    TlbImporterFlags flags,             // Importer flags.
-    CImportTlb  **ppImporter)           // The importer.
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_PREEMPTIVE;
-        PRECONDITION(CheckPointer(pITLB));
-        PRECONDITION(CheckPointer(szFname, NULL_OK));
-        PRECONDITION(CheckPointer(szNamespace, NULL_OK));
-        PRECONDITION(CheckPointer(pEmit));
-        PRECONDITION(CheckPointer(pAssembly));
-        PRECONDITION(CheckPointer(pModule));
-        PRECONDITION(CheckPointer(pNotify));
-        PRECONDITION(CheckPointer(ppImporter));
-    }
-    CONTRACTL_END;
-   
-    HRESULT     hr;
-    
-    // Retrieve flag indicating whether runtime or linktime interface
-    // security checks are required.
-    BOOL bUnsafeInterfaces = (BOOL)(flags & TlbImporter_UnsafeInterfaces);
-
-    // Determine if we import SAFEARRAY's as System.Array's.
-    BOOL bSafeArrayAsSysArray = (BOOL)(flags & TlbImporter_SafeArrayAsSystemArray);
-
-    // Determine if we are doing the [out,retval] transformation on disp only interfaces.
-    BOOL bTransformDispRetVals = (BOOL)(flags & TlbImporter_TransformDispRetVals);
-
-    // Determine if we are adding members to classes.
-    BOOL bPreventClassMembers = (BOOL)(flags & TlbImporter_PreventClassMembers);
-
-    // Determine if we are marking value classes as serializable
-    BOOL bSerializableValueClasses = (BOOL)(flags & TlbImporter_SerializableValueClasses);
-    
-    // Create and initialize a TypeLib importer.
-    NewPreempHolder<CImportTlb> pImporter = CImportTlb::CreateImporter(szFname, pITLB, true, bUnsafeInterfaces, bSafeArrayAsSysArray, bTransformDispRetVals, bPreventClassMembers, bSerializableValueClasses);
-    if (!pImporter)
-        COMPlusThrowOM();
-
-    // If a namespace is specified, use it.
-    if (szNamespace)
-        pImporter->SetNamespace(szNamespace);
-
-    // Set the various pointers.
-    hr = pImporter->SetMetaData(pEmit);
-    _ASSERTE(SUCCEEDED(hr) && "Couldn't get IMetaDataEmit* from Module");
-    if (FAILED(hr))
-        COMPlusThrowArgumentNull(W("pEmit"));
-    
-    pImporter->SetNotification(pNotify);
-    pImporter->SetAssembly(pAssembly);
-    pImporter->SetModule(pModule);
-
-    // Do the conversion.
-    hr = pImporter->Import();
-    if (SUCCEEDED(hr))
-    {
-        *ppImporter = pImporter;
-        pImporter.SuppressRelease();
-    }
-    else
-    {
-        COMPlusThrowHR(hr, kGetErrorInfo);
-    }
-} // HRESULT COMTypeLibConverter::TypeLibImporterWrapper()
-
-
-void COMTypeLibConverter::ConvertAssemblyToTypeLibInternal(OBJECTREF* ppAssembly, 
-                                                                STRINGREF* ppTypeLibName, 
-                                                                DWORD Flags, 
-                                                                OBJECTREF* ppNotifySink,
-                                                                OBJECTREF* pRetObj)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION (IsProtectedByGCFrame (ppAssembly));
-        PRECONDITION (IsProtectedByGCFrame (ppTypeLibName));
-        PRECONDITION (IsProtectedByGCFrame (ppNotifySink));
-        PRECONDITION (IsProtectedByGCFrame (pRetObj));
-        INJECT_FAULT(COMPlusThrowOM());
-    }
-    CONTRACTL_END;
-    
-    Assembly    *pAssembly=0;           // Assembly to export.
-
-    NewArrayHolder<WCHAR>                       szTypeLibName=0;  // The name for the typelib.
-    SafeComHolder<ITypeLib>                     pTLB=0;     // The new typelib.
-    SafeComHolder<ITypeLibExporterNotifySink>   pINotify=0; // Callback parameter.
-
-    // Make sure the COMTypeLibConverter has been initialized.
-    if (!m_bInitialized)
-        Init();
-
-    // Validate flags
-    if ((Flags & ~TlbExporter_ValidFlags) != 0)
-        COMPlusThrowArgumentOutOfRange(W("flags"), W("Argument_InvalidFlag"));
-
-    // Retrieve the callback.
-    if (*ppNotifySink == NULL)
-        COMPlusThrowArgumentNull(W("notifySink"));
-    
-    pINotify = (ITypeLibExporterNotifySink*)GetComIPFromObjectRef(ppNotifySink, MscorlibBinder::GetClass(CLASS__ITYPE_LIB_EXPORTER_NOTIFY_SINK));
-    if (!pINotify)
-        COMPlusThrow(kArgumentException, W("Arg_NoImporterCallback"));
-        
-    // If a name was specified then copy it to a temporary string.
-    if (*ppTypeLibName != NULL)
-    {
-        int TypeLibNameLen = (*ppTypeLibName)->GetStringLength();
-        szTypeLibName = new WCHAR[TypeLibNameLen + 1];
-        memcpyNoGCRefs(szTypeLibName, (*ppTypeLibName)->GetBuffer(), TypeLibNameLen * sizeof(WCHAR));
-        szTypeLibName[TypeLibNameLen] = 0;
-    }
-
-    // Retrieve the assembly from the AssemblyBuilder argument.
-    if (*ppAssembly == NULL)
-        COMPlusThrowNonLocalized(kArgumentNullException, W("assembly"));
-
-    pAssembly = ((ASSEMBLYREF)*ppAssembly)->GetAssembly();
-    _ASSERTE(pAssembly);
-
-    if (IsAfContentType_WindowsRuntime(pAssembly->GetFlags()))
-        COMPlusThrow(kArgumentException, W("Argument_AssemblyWinMD"));
-
-    {
-        GCX_PREEMP();
-        ExportTypeLibFromLoadedAssembly(pAssembly, szTypeLibName, &pTLB, pINotify, Flags);
-    }
-
-    // Make sure we got a typelib back.
-    _ASSERTE(pTLB);
-
-    // Convert the ITypeLib interface pointer to a COM+ object.
-    GetObjectRefFromComIP(pRetObj, pTLB, NULL);
-}
-
-// static
-void COMTypeLibConverter::LoadType(
-    Module * pModule,
-    mdTypeDef cl,
-    TlbImporterFlags Flags)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM());
-    }
-    CONTRACTL_END;
-
-    OBJECTREF pThrowable = NULL;
-    
-    GCPROTECT_BEGIN(pThrowable)
-    {    
-        EX_TRY
-        {
-            // Load the EE class that represents the type, so that
-            // the TypeDefToMethodTable rid map contains this entry
-            // (They were going to be loaded, anyway, to generate comtypes)
-            TypeHandle typeHnd;
-            typeHnd = ClassLoader::LoadTypeDefThrowing(pModule, cl, 
-                                                       ClassLoader::ThrowIfNotFound, 
-                                                       ClassLoader::PermitUninstDefOrRef);
-        }
-        EX_CATCH
-        {
-            pThrowable = GET_THROWABLE();
-        }
-        EX_END_CATCH(SwallowAllExceptions);
-
-        if (pThrowable != NULL)
-        {
-            // Only spit out a special message if PreventClassMembers is set.
-            if ((Flags & TlbImporter_PreventClassMembers) == 0)
-            {
-                struct _gc
-                {
-                    OBJECTREF pInnerException;
-                    OBJECTREF pThrowable;
-                    STRINGREF pMsg;
-                } gc;
-                
-                gc.pInnerException = NULL;
-                gc.pThrowable = NULL;
-                gc.pMsg = NULL;
-                
-                GCPROTECT_BEGIN(gc);
-                {
-                    MethodTable* pMT = MscorlibBinder::GetException(kSystemException);
-
-                    gc.pThrowable = AllocateObject(pMT);
-                    gc.pInnerException = pThrowable;
-                    ResMgrGetString(W("Arg_ImporterLoadFailure"), &gc.pMsg);                        
-
-                    MethodDescCallSite exceptionCtor(METHOD__SYSTEM_EXCEPTION__STR_EX_CTOR, &gc.pThrowable);
-
-                    ARG_SLOT args[] = { ObjToArgSlot(gc.pThrowable),
-                                        ObjToArgSlot(gc.pMsg),
-                                        ObjToArgSlot(gc.pInnerException) };
-
-                    exceptionCtor.Call(args);
-
-                    COMPlusThrow(gc.pThrowable);
-                }
-                GCPROTECT_END();
-            }
-            
-            COMPlusThrow(pThrowable);
-        }
-    }
-    GCPROTECT_END();
-}
-
-void COMTypeLibConverter::ConvertTypeLibToMetadataInternal(OBJECTREF* ppTypeLib, 
-                                                           OBJECTREF* ppAsmBldr, 
-                                                           OBJECTREF* ppModBldr, 
-                                                           STRINGREF* ppNamespace, 
-                                                           TlbImporterFlags Flags, 
-                                                           OBJECTREF* ppNotifySink, 
-                                                           OBJECTREF* pEventItfInfoList)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM());
-        PRECONDITION(IsProtectedByGCFrame (ppTypeLib));
-        PRECONDITION(IsProtectedByGCFrame (ppAsmBldr));
-        PRECONDITION(IsProtectedByGCFrame (ppModBldr));
-        PRECONDITION(IsProtectedByGCFrame (ppNamespace));
-        PRECONDITION(IsProtectedByGCFrame (ppNotifySink));
-        PRECONDITION(IsProtectedByGCFrame (pEventItfInfoList));
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    Module      *pModule = NULL;               // ModuleBuilder parameter.
-    Assembly    *pAssembly = NULL;      // AssemblyBuilder parameter.
-    REFLECTMODULEBASEREF pReflect = NULL;      // ReflectModule passed as param.
-    int         cTypeDefs;              // Count of imported TypeDefs.
-    int         i;                      // Loop control.
-    mdTypeDef   cl;                     // An imported TypeDef.
-
-    NewArrayHolder<WCHAR>        szNamespace = NULL;            // The namespace to put the type in.
-    NewPreempHolder<CImportTlb>  pImporter = NULL;              // The importer used to import the typelib.
-    SafeComHolder<ITypeLib>      pTLB = NULL;                   // TypeLib parameter.
-    SafeComHolder<ITypeLibImporterNotifySink> pINotify = NULL;  // Callback parameter.
-
-    // Make sure the COMTypeLibConverter has been initialized.
-    if (!m_bInitialized)
-        Init();
-
-    // Validate the flags.
-    if ((Flags & ~TlbImporter_ValidFlags) != 0)
-        COMPlusThrowArgumentOutOfRange(W("flags"), W("Argument_InvalidFlag"));
-    
-    // Retrieve the callback.
-    MethodTable * pSinkMT = MscorlibBinder::GetClass(CLASS__ITYPE_LIB_IMPORTER_NOTIFY_SINK);
-    pINotify = (ITypeLibImporterNotifySink*)GetComIPFromObjectRef(ppNotifySink, pSinkMT);
-    if (!pINotify)
-        COMPlusThrow(kArgumentException, W("Arg_NoImporterCallback"));
-        
-    pReflect = (REFLECTMODULEBASEREF) *ppModBldr;
-    _ASSERTE(pReflect);
-    
-   
-    pModule = pReflect->GetModule();
-    _ASSERTE(pModule);
-
-    // Suppress capturing while we dispatch events. This is a performance optimization to avoid
-    // re-serializing metadata between each type. Instead, we suppress serialization while we bake all
-    // the types and then re-enable it at the end (when this holder goes out of scope).
-    _ASSERTE(pModule->IsReflection());
-    ReflectionModule::SuppressMetadataCaptureHolder holderCapture(pModule->GetReflectionModule());
-        
-
-    // Retrieve the assembly from the AssemblyBuilder argument.
-    pAssembly = ((ASSEMBLYREF)*ppAsmBldr)->GetAssembly();
-    _ASSERTE(pAssembly);
-
-    // Retrieve a pointer to the ITypeLib interface.
-    pTLB = (ITypeLib*)GetComIPFromObjectRef(ppTypeLib, IID_ITypeLib);
-    if (!pTLB)
-        COMPlusThrow(kArgumentException, W("Arg_NoITypeLib"));
-    
-    // If a namespace was specified then copy it to a temporary string.
-    if (*ppNamespace != NULL)
-    {
-        int NamespaceLen = (*ppNamespace)->GetStringLength();
-        szNamespace = new WCHAR[NamespaceLen + 1];
-        memcpyNoGCRefs(szNamespace, (*ppNamespace)->GetBuffer(), NamespaceLen * sizeof(WCHAR));
-        szNamespace[NamespaceLen] = 0;
-    }
-
-    // Switch to preemptive GC before we call out to COM.
-    {
-        GCX_PREEMP();
-        
-        // Have to wrap the CImportTlb object in a call, because it has a destructor.
-        TypeLibImporterWrapper(pTLB, NULL /*filename*/, szNamespace,
-                               pModule->GetEmitter(), pAssembly, pModule, pINotify,
-                               Flags, &pImporter);
-    }
-
-    // Enumerate the types imported from the typelib, and add them to the assembly's available type table.
-    IMDInternalImport* pInternalImport = pModule->GetMDImport();
-    HENUMTypeDefInternalHolder hEnum(pInternalImport);
-        
-    hEnum.EnumTypeDefInit();
-    cTypeDefs = pInternalImport->EnumTypeDefGetCount(&hEnum);
-
-    for (i=0; i<cTypeDefs; ++i)
-    {
-        BOOL success = pInternalImport->EnumTypeDefNext(&hEnum, &cl);
-        _ASSERTE(success);
-            
-        pAssembly->AddType(pModule, cl);
-    }
-
-    // Allocate an empty array
-    CreateItfInfoList(pEventItfInfoList);
-
-#ifdef _DEBUG
-    if (!g_pConfig->TlbImpSkipLoading())
-    {
-#endif // _DEBUG
-        pInternalImport->EnumReset(&hEnum);
-        for (i=0; i<cTypeDefs; ++i)
-        {
-            BOOL success = pInternalImport->EnumTypeDefNext(&hEnum, &cl);
-            _ASSERTE(success);
-
-            LoadType(pModule, cl, Flags);
-        }
-
-        // Retrieve the event interface list.
-        GetEventItfInfoList(pImporter, pAssembly, pEventItfInfoList);
-#ifdef _DEBUG
-    }
-#endif // _DEBUG
-}
-
-void COMTypeLibConverter::CreateItfInfoList(OBJECTREF* pEventItfInfoList)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM());
-        PRECONDITION(IsProtectedByGCFrame (pEventItfInfoList));
-    }
-    CONTRACTL_END;
-    
-    // Allocate the array list that will contain the event sources.
-    SetObjectReference(pEventItfInfoList, 
-                       AllocateObject(MscorlibBinder::GetClass(CLASS__ARRAY_LIST)),
-                       SystemDomain::GetCurrentDomain());
-
-    MethodDescCallSite ctor(METHOD__ARRAY_LIST__CTOR, pEventItfInfoList);
-
-    // Call the ArrayList constructor.
-    ARG_SLOT CtorArgs[] =
-    { 
-        ObjToArgSlot(*pEventItfInfoList)
-    };
-    ctor.Call(CtorArgs);
-}
-
-//*****************************************************************************
-//*****************************************************************************
-void COMTypeLibConverter::GetEventItfInfoList(CImportTlb *pImporter, Assembly *pAssembly, OBJECTREF *pEventItfInfoList)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM());
-        PRECONDITION(CheckPointer(pImporter));
-        PRECONDITION(CheckPointer(pAssembly));
-        PRECONDITION(IsProtectedByGCFrame (pEventItfInfoList));
-    }
-    CONTRACTL_END;
-
-    UINT                            i;              
-    CQuickArray<ImpTlbEventInfo*>   qbEvInfoList;
-
-    // Retrieve the list of event interfaces.
-    pImporter->GetEventInfoList(qbEvInfoList);
-
-    // Iterate over TypeInfos.
-    for (i = 0; i < qbEvInfoList.Size(); i++)
-    {
-        // Retrieve the Add method desc for the ArrayList.
-        MethodDescCallSite addMeth(METHOD__ARRAY_LIST__ADD, pEventItfInfoList);
-
-        // Retrieve the event interface info for the current CoClass.
-        OBJECTREF EventItfInfoObj = GetEventItfInfo(pAssembly, qbEvInfoList[i]);
-        _ASSERTE(EventItfInfoObj);
-
-        // Add the event interface info to the list.
-        ARG_SLOT AddArgs[] = { 
-            ObjToArgSlot(*pEventItfInfoList),
-            ObjToArgSlot(EventItfInfoObj)
-        };
-        addMeth.Call(AddArgs);
-    }
-} // LPVOID COMTypeLibConverter::GetTypeLibEventSourceList()
-
-//*****************************************************************************
-// Initialize the COMTypeLibConverter.
-//*****************************************************************************
-void COMTypeLibConverter::Init()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    // Ensure COM is started up.
-    EnsureComStarted();
-
-    // Set the initialized flag to TRUE.
-    m_bInitialized = TRUE;
-} // void COMTypeLibConverter::Init()
-
-//*****************************************************************************
-// Given an imported class in an assembly, generate a list of event sources.
-//*****************************************************************************
-OBJECTREF COMTypeLibConverter::GetEventItfInfo(Assembly *pAssembly, ImpTlbEventInfo *pImpTlbEventInfo)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM());
-        PRECONDITION(CheckPointer(pAssembly));
-        PRECONDITION(CheckPointer(pImpTlbEventInfo));
-    }
-    CONTRACTL_END;
-
-    OBJECTREF   RetObj = NULL;
-
-    struct _gc
-    {
-        OBJECTREF EventItfInfoObj;
-        STRINGREF EventItfNameStrObj;
-        STRINGREF SrcItfNameStrObj;
-        STRINGREF EventProvNameStrObj;
-        OBJECTREF AssemblyObj;
-        OBJECTREF SrcItfAssemblyObj;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc)
-    {
-        // Create the EventSource object.
-        gc.EventItfInfoObj = AllocateObject(MscorlibBinder::GetClass(CLASS__TCE_EVENT_ITF_INFO));
-                            
-        // Retrieve the assembly object.
-        gc.AssemblyObj = pAssembly->GetExposedObject();
-
-        // Retrieve the source interface assembly object (may be the same assembly).
-        gc.SrcItfAssemblyObj = pImpTlbEventInfo->SrcItfAssembly->GetExposedObject();
-
-        // Prepare the constructor arguments.
-        gc.EventItfNameStrObj = StringObject::NewString(pImpTlbEventInfo->szEventItfName);       
-        gc.SrcItfNameStrObj = StringObject::NewString(pImpTlbEventInfo->szSrcItfName);       
-        gc.EventProvNameStrObj = StringObject::NewString(pImpTlbEventInfo->szEventProviderName);
-
-        MethodDescCallSite ctor(METHOD__TCE_EVENT_ITF_INFO__CTOR, &gc.EventItfInfoObj);
-        
-        // Call the EventItfInfo constructor.
-        ARG_SLOT CtorArgs[] = { 
-            ObjToArgSlot(gc.EventItfInfoObj),
-            ObjToArgSlot(gc.EventItfNameStrObj),
-            ObjToArgSlot(gc.SrcItfNameStrObj),
-            ObjToArgSlot(gc.EventProvNameStrObj),
-            ObjToArgSlot(gc.AssemblyObj),
-            ObjToArgSlot(gc.SrcItfAssemblyObj),
-        };
-        ctor.Call(CtorArgs);
-
-        RetObj = gc.EventItfInfoObj;
-    }
-    GCPROTECT_END();
-
-    return RetObj;
-} // OBJECTREF COMTypeLibConverter::GetEventSourceInfo()
-
-//*****************************************************************************
-// Given the string persisted from a TypeLib export, recreate the assembly
-//  reference.
-//*****************************************************************************
-mdAssemblyRef DefineAssemblyRefForExportedAssembly(
-    LPCWSTR     pszFullName,            // Full name of the assembly.
-    IUnknown    *pIMeta)                // Metadata emit interface.
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pszFullName));
-        PRECONDITION(CheckPointer(pIMeta));
-    }
-    CONTRACTL_END;
-    
-    mdAssemblyRef ar=0;
-    HRESULT     hr;                                 // A result.  
-    AssemblySpec spec;                              // "Name" of assembly.
-    CQuickArray<char> rBuf;
-    int iLen;    
-    SafeComHolder<IMetaDataAssemblyEmit> pMeta=0;   // Emit interface.
-    
-    iLen = WszWideCharToMultiByte(CP_ACP,0, pszFullName,-1, 0,0, 0,0);
-    IfFailGo(rBuf.ReSizeNoThrow(iLen+1));
-    WszWideCharToMultiByte(CP_ACP,0, pszFullName,-1, rBuf.Ptr(),iLen+1, 0,0);
-     
-    // Restore the AssemblySpec data.
-    IfFailGo(spec.Init(rBuf.Ptr()));
-    
-    // Make sure we have the correct pointer type.
-    IfFailGo(SafeQueryInterface(pIMeta, IID_IMetaDataAssemblyEmit, (IUnknown**)&pMeta));
-    
-    // Create the assemblyref token.
-    IfFailGo(spec.EmitToken(pMeta, &ar));
-        
-ErrExit:
-    return ar;
-} // mdAssemblyRef DefineAssemblyRefForExportedAssembly()
-
-//*****************************************************************************
-// Public helper function used by typelib converter to create AssemblyRef
-//  for a referenced typelib.
-//*****************************************************************************
-extern mdAssemblyRef DefineAssemblyRefForImportedTypeLib(
-    void        *pvAssembly,            // Assembly importing the typelib.
-    void        *pvModule,              // Module importing the typelib.
-    IUnknown    *pIMeta,                // IMetaData* from import module.
-    IUnknown    *pIUnk,                 // IUnknown to referenced Assembly.
-    BSTR        *pwzNamespace,          // The namespace of the resolved assembly.
-    BSTR        *pwzAsmName,            // The name of the resolved assembly.
-    Assembly    **ppAssemblyRef)        // The resolved assembly.        
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pvAssembly));
-        PRECONDITION(CheckPointer(pvModule));
-        PRECONDITION(CheckPointer(pIMeta));
-        PRECONDITION(CheckPointer(pIUnk));
-        PRECONDITION(CheckPointer(pwzNamespace));
-        PRECONDITION(CheckPointer(pwzAsmName));
-        PRECONDITION(CheckPointer(ppAssemblyRef, NULL_OK));
-    }
-    CONTRACTL_END;
-    
-    // This is a workaround to allow an untyped param.  To really fix, move imptlb to this project,
-    //  and out of the metadata project.  Once here, imptlb can just reference any of 
-    //  the .h files in this project.
-    Assembly*       pAssembly = reinterpret_cast<Assembly*>(pvAssembly);
-    Module*         pTypeModule = reinterpret_cast<Module*>(pvModule);
-    HRESULT         hr;
-    Assembly*       pRefdAssembly           = NULL;
-    IMetaDataEmit*  pEmitter                = NULL;
-    MethodTable*    pAssemblyClass          = NULL;
-    mdAssemblyRef   ar                      = mdAssemblyRefNil;
-    Module*         pManifestModule         = NULL;
-    mdTypeDef       td                      = 0;
-    LPCSTR          szName                  = NULL;
-    LPCSTR          szNamespace = NULL;
-    CQuickBytes qb;
-    WCHAR* wszBuff = (WCHAR*) qb.AllocThrows((MAX_CLASSNAME_LENGTH+1) * sizeof(WCHAR));
-    SString         szRefdAssemblyName;
-    IMDInternalImport*      pRefdMDImport = NULL;
-    SafeComHolder<IMetaDataAssemblyEmit>  pAssemEmitter = NULL;
-
-    GCX_COOP();
-
-    // Initialize the output strings to NULL.
-    *pwzNamespace = NULL;
-    *pwzAsmName = NULL;
-    BSTRHolder local_pwzNamespace = NULL;
-    BSTRHolder local_pwzAsmName = NULL;
-
-    // Get the Referenced Assembly object from the IUnknown.
-    PREFIX_ASSUME(pIUnk != NULL);
-    ASSEMBLYREF RefdAsmObj = NULL;
-    GCPROTECT_BEGIN(RefdAsmObj);
-    GetObjectRefFromComIP((OBJECTREF*)&RefdAsmObj, pIUnk, pAssemblyClass);
-    PREFIX_ASSUME(RefdAsmObj != NULL);
-
-    // Get the internal assembly from the assembly object.
-    pRefdAssembly = RefdAsmObj->GetAssembly();
-    GCPROTECT_END();
-    PREFIX_ASSUME(pRefdAssembly != NULL);
-
-    // Return the assembly if asked for
-    if (ppAssemblyRef)
-        *ppAssemblyRef = pRefdAssembly;
-
-    // Get the manifest module for the importing and the referenced assembly.
-    pManifestModule = pAssembly->GetManifestModule();  
-        
-    // Define the AssemblyRef in the global assembly.
-    pEmitter = pManifestModule->GetEmitter();
-    _ASSERTE(pEmitter);
-    IfFailGo(SafeQueryInterface(pEmitter, IID_IMetaDataAssemblyEmit, (IUnknown**) &pAssemEmitter));
-    ar = pAssembly->AddAssemblyRef(pRefdAssembly, pAssemEmitter);
-    pAssemEmitter.Release();
-
-    // Add the assembly ref token and the manifest module it is referring to the manifest module's rid map.
-    pManifestModule->StoreAssemblyRef(ar, pRefdAssembly);
-
-    // Add assembly ref in module manifest.
-    IfFailGo(SafeQueryInterface(pIMeta, IID_IMetaDataAssemblyEmit, (IUnknown**) &pAssemEmitter));
-    ar = pAssembly->AddAssemblyRef(pRefdAssembly, pAssemEmitter);    
-
-    // Add the assembly ref token and the manifest module it is referring to the rid map of the module we are 
-    // emiting into.
-    pTypeModule->StoreAssemblyRef(ar, pRefdAssembly);
-    
-    // Retrieve the first typedef in the assembly.
-    {
-        ModuleIterator i = pRefdAssembly->IterateModules();
-        Module *pRefdModule = NULL;
-    
-        while (i.Next())
-        {
-            pRefdModule = i.GetModule();
-            pRefdMDImport = pRefdModule->GetMDImport();
-            HENUMTypeDefInternalHolder hTDEnum(pRefdMDImport);
-
-            IfFailGo(hTDEnum.EnumTypeDefInitNoThrow());
-
-            if (pRefdMDImport->EnumTypeDefNext(&hTDEnum, &td) == true)
-            {
-                IfFailGo(pRefdMDImport->GetNameOfTypeDef(td, &szName, &szNamespace));
-                break;
-            }
-        }
-    }
-
-    // DefineAssemblyRefForImportedTypeLib should never be called for assemblies that
-    // do not contain any types so we better have found one.
-    _ASSERTE(szNamespace);
-
-    // Give the namespace back to the caller.
-    WszMultiByteToWideChar(CP_UTF8,0, szNamespace, -1, wszBuff, MAX_CLASSNAME_LENGTH);
-    local_pwzNamespace = SysAllocString(wszBuff);
-    IfNullGo(local_pwzNamespace);
-
-    // Give the assembly name back to the caller.
-    pRefdAssembly->GetDisplayName(szRefdAssemblyName);
-    local_pwzAsmName = SysAllocString(szRefdAssemblyName);
-    IfNullGo(local_pwzAsmName);
-
-ErrExit:
-    if (FAILED(hr))
-    {
-        ar = mdAssemblyRefNil;
-    }
-    else
-    {
-        local_pwzNamespace.SuppressRelease();
-        local_pwzAsmName.SuppressRelease();
-        *pwzNamespace = local_pwzNamespace;
-        *pwzAsmName = local_pwzAsmName;
-    }
-    
-    return ar;
-} // mdAssemblyRef DefineAssemblyRefForImportedTypeLib()
-
-
-
-//*****************************************************************************
-// A typelib exporter.
-//*****************************************************************************
-FCIMPL4(Object*, COMTypeLibConverter::ConvertAssemblyToTypeLib, Object* AssemblyUNSAFE, StringObject* TypeLibNameUNSAFE, DWORD Flags, Object* NotifySinkUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    OBJECTREF RetObj = NULL;
-    struct _gc
-    {
-        OBJECTREF Assembly;
-        STRINGREF TypeLibName;
-        OBJECTREF NotifySink;
-        OBJECTREF RetObj;
-    } gc;
-    
-    gc.Assembly = (OBJECTREF) AssemblyUNSAFE;
-    gc.TypeLibName = (STRINGREF) TypeLibNameUNSAFE;
-    gc.NotifySink = (OBJECTREF) NotifySinkUNSAFE;
-    gc.RetObj = NULL;
-    
-    HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc);
-
-    ConvertAssemblyToTypeLibInternal(&gc.Assembly, &gc.TypeLibName, Flags, &gc.NotifySink, &gc.RetObj);
-
-    HELPER_METHOD_FRAME_END();
-    return OBJECTREFToObject(gc.RetObj);
-} // LPVOID COMTypeLibConverter::ConvertAssemblyToTypeLib()
-FCIMPLEND
-
-//*****************************************************************************
-// Import a typelib as metadata.  Doesn't add TCE adapters.
-//*****************************************************************************
-FCIMPL7(void, COMTypeLibConverter::ConvertTypeLibToMetadata, Object* TypeLibUNSAFE, Object* AsmBldrUNSAFE, Object* ModBldrUNSAFE, StringObject* NamespaceUNSAFE, TlbImporterFlags Flags, Object* NotifySinkUNSAFE, OBJECTREF* pEventItfInfoList)
-{
-    FCALL_CONTRACT;
-
-    struct _gc
-    {
-        OBJECTREF TypeLib;
-        OBJECTREF AsmBldr;
-        OBJECTREF ModBldr;
-        STRINGREF Namespace;
-        OBJECTREF NotifySink;
-    } gc;
-    
-    gc.TypeLib = (OBJECTREF) TypeLibUNSAFE;
-    gc.AsmBldr = (OBJECTREF) AsmBldrUNSAFE;
-    gc.ModBldr = (OBJECTREF) ModBldrUNSAFE;
-    gc.Namespace = (STRINGREF) NamespaceUNSAFE;
-    gc.NotifySink = (OBJECTREF) NotifySinkUNSAFE;
-    
-    HELPER_METHOD_FRAME_BEGIN_PROTECT(gc);
-
-    ASSUME_BYREF_FROM_JIT_STACK_BEGIN(pEventItfInfoList);
-    ConvertTypeLibToMetadataInternal(&gc.TypeLib, &gc.AsmBldr, &gc.ModBldr, &gc.Namespace, Flags, &gc.NotifySink, pEventItfInfoList);
-    ASSUME_BYREF_FROM_JIT_STACK_END();
-
-    HELPER_METHOD_FRAME_END();
-} // void COMTypeLibConverter::ConvertTypeLibToMetadata()
-FCIMPLEND
diff --git a/src/vm/comtypelibconverter.h b/src/vm/comtypelibconverter.h
deleted file mode 100644
index f835999794..0000000000
--- a/src/vm/comtypelibconverter.h
+++ /dev/null
@@ -1,107 +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.
-
-/*============================================================
-**
-** Header:  COMTypeLibConverter.h
-**
-**
-** Purpose: Definition of the native methods used by the 
-**          typelib converter.
-**
-** 
-===========================================================*/
-
-#ifndef _COMTYPELIBCONVERTER_H
-#define _COMTYPELIBCONVERTER_H
-
-#ifndef FEATURE_COMINTEROP
-#error FEATURE_COMINTEROP is required for this file
-#endif // FEATURE_COMINTEROP
-#ifndef FEATURE_COMINTEROP_TLB_SUPPORT
-#error FEATURE_COMINTEROP_TLB_SUPPORT is required for this file
-#endif // FEATURE_COMINTEROP
-
-#include "vars.hpp"
-
-struct ITypeLibImporterNotifySink;
-class ImpTlbEventInfo;
-
-
-enum TlbImporterFlags
-{
-    TlbImporter_PrimaryInteropAssembly          = 0x00000001,   // Generate a PIA.
-    TlbImporter_UnsafeInterfaces                = 0x00000002,   // Generate unsafe interfaces.
-    TlbImporter_SafeArrayAsSystemArray          = 0x00000004,   // Safe array import control.
-    TlbImporter_TransformDispRetVals            = 0x00000008,   // Disp only itf [out, retval] transformation.
-    TlbImporter_PreventClassMembers             = 0x00000010,   // Prevent adding members to class.
-    TlbImporter_SerializableValueClasses        = 0x00000020,   // Mark value classes as serializable.
-    TlbImporter_ImportAsX86                     = 0x00000100,   // Import to a 32-bit assembly
-    TlbImporter_ImportAsX64                     = 0x00000200,   // Import to an x64 assembly
-    TlbImporter_ImportAsItanium                 = 0x00000400,   // Import to an itanium assembly
-    TlbImporter_ImportAsAgnostic                = 0x00000800,   // Import to an agnostic assembly
-    TlbImporter_ReflectionOnlyLoading           = 0x00001000,   // Use ReflectionOnly loading.
-    TlbImporter_NoDefineVersionResource         = 0x00002000,   // Don't call AssemblyBuilder.DefineVersionResource
-    TlbImporter_ImportAsArm                     = 0x00004000,   // Import to an ARM assembly
-    TlbImporter_ValidFlags                      = TlbImporter_PrimaryInteropAssembly | 
-                                                  TlbImporter_UnsafeInterfaces | 
-                                                  TlbImporter_SafeArrayAsSystemArray |
-                                                  TlbImporter_TransformDispRetVals |
-                                                  TlbImporter_PreventClassMembers |
-                                                  TlbImporter_SerializableValueClasses |
-                                                  TlbImporter_ImportAsX86 |
-                                                  TlbImporter_ImportAsX64 |
-                                                  TlbImporter_ImportAsItanium |
-                                                  TlbImporter_ImportAsAgnostic |
-                                                  TlbImporter_ReflectionOnlyLoading |
-                                                  TlbImporter_NoDefineVersionResource |
-                                                  TlbImporter_ImportAsArm
-};
-
-// Note that the second hex digit is reserved
-enum TlbExporterFlags
-{
-    TlbExporter_OnlyReferenceRegistered         = 0x00000001,   // Only reference an external typelib if it is registered.
-    TlbExporter_CallerResolvedReferences        = 0x00000002,   // Always allow caller to resolve typelib references first
-    TlbExporter_OldNames                        = 0x00000004,   // Do not ignore non COM visible types when doing name decoration.
-//  TlbExporter_Unused                          = 0x00000008,   // This is currently unused - feel free to use this for another switch
-    TlbExporter_ExportAs32Bit                   = 0x00000010,   // Export the type library using 32-bit semantics
-    TlbExporter_ExportAs64Bit                   = 0x00000020,   // Export the type library using 64-bit semantics
-//  TlbExporter_Reserved                        = 0x00000040,   // Do not use this
-//  TlbExporter_Reserved                        = 0x00000080,   // Do not use this
-    TlbExporter_ValidFlags                      = TlbExporter_OnlyReferenceRegistered | 
-                                                  TlbExporter_CallerResolvedReferences | 
-                                                  TlbExporter_OldNames |
-                                                  TlbExporter_ExportAs32Bit |
-                                                  TlbExporter_ExportAs64Bit
-};
-
-#define TlbExportAsMask         0x000000F0
-#define TlbExportAs32Bit(x)     ((TlbExportAsMask & x) == TlbExporter_ExportAs32Bit)
-#define TlbExportAs64Bit(x)     ((TlbExportAsMask & x) == TlbExporter_ExportAs64Bit)
-#define TlbExportAsDefault(x)   ((!TlbExportAs32Bit(x)) && (!TlbExportAs64Bit(x)))
-
-class COMTypeLibConverter
-{
-public:
-    static FCDECL4(Object*, ConvertAssemblyToTypeLib, Object* AssemblyUNSAFE, StringObject* TypeLibNameUNSAFE, DWORD Flags, Object* NotifySinkUNSAFE);
-    static FCDECL7(void, ConvertTypeLibToMetadata, Object* TypeLibUNSAFE, Object* AsmBldrUNSAFE, Object* ModBldrUNSAFE, StringObject* NamespaceUNSAFE, TlbImporterFlags Flags, Object* NotifySinkUNSAFE, OBJECTREF* pEventItfInfoList);
-
-private:
-    static void             Init();
-    static void             CreateItfInfoList(OBJECTREF* pEventItfInfoList);
-    static void             GetEventItfInfoList(CImportTlb *pImporter, Assembly *pAssembly, OBJECTREF *pEventItfInfoList);
-    static OBJECTREF        GetEventItfInfo(Assembly *pAssembly, ImpTlbEventInfo *pImpTlbEventInfo);
-    static void             TypeLibImporterWrapper(ITypeLib *pITLB, LPCWSTR szFname, LPCWSTR szNamespace, IMetaDataEmit *pEmit, Assembly *pAssembly, Module *pModule, ITypeLibImporterNotifySink *pNotify, TlbImporterFlags flags, CImportTlb **ppImporter);
-
-    static void             ConvertAssemblyToTypeLibInternal(OBJECTREF* ppAssembly, STRINGREF* ppTypeLibName, DWORD Flags, OBJECTREF* ppNotifySink, OBJECTREF* pRetObj);
-    static void             COMTypeLibConverter::LoadType(Module * pModule,
-                                                          mdTypeDef cl,
-                                                          TlbImporterFlags Flags);
-    static void             ConvertTypeLibToMetadataInternal(OBJECTREF* ppTypeLib, OBJECTREF* ppAsmBldr, OBJECTREF* ppModBldr, STRINGREF* ppNamespace, TlbImporterFlags Flags, OBJECTREF* ppNotifySink, OBJECTREF* pEventItfInfoList);
-
-    static BOOL             m_bInitialized;
-};
-
-#endif // _COMTYPELIBCONVERTER_H
diff --git a/src/vm/comutilnative.cpp b/src/vm/comutilnative.cpp
index 41655cb5b0..891c302402 100644
--- a/src/vm/comutilnative.cpp
+++ b/src/vm/comutilnative.cpp
@@ -777,50 +777,7 @@ FCIMPL1(FC_BOOL_RET, ExceptionNative::IsTransient, INT32 hresult)
 }
 FCIMPLEND
 
-#ifndef FEATURE_CORECLR
 
-FCIMPL3(StringObject *, ExceptionNative::StripFileInfo, Object *orefExcepUNSAFE, StringObject *orefStrUNSAFE, CLR_BOOL isRemoteStackTrace)
-{
-    FCALL_CONTRACT;
-
-    OBJECTREF orefExcep = ObjectToOBJECTREF(orefExcepUNSAFE);
-    STRINGREF orefStr = (STRINGREF)ObjectToOBJECTREF(orefStrUNSAFE);
-
-    if (orefStr == NULL)
-    {
-        return NULL;
-    }
-
-    HELPER_METHOD_FRAME_BEGIN_RET_2(orefExcep, orefStr);
-
-    if (isRemoteStackTrace)
-    {
-        if (!AppX::IsAppXProcess() && ExceptionTypeOverridesStackTraceGetter(orefExcep->GetMethodTable()))
-        {
-            // In classic processes, the remote stack trace could have been generated using a custom get_StackTrace
-            // override which means that we would not be able to parse is - strip the whole string by returning NULL.
-            orefStr = NULL;
-        }
-    }
-
-    if (orefStr != NULL)
-    {
-        SString stackTrace;
-        orefStr->GetSString(stackTrace);
-
-        StripFileInfoFromStackTrace(stackTrace);
-
-        orefStr = AllocateString(stackTrace);
-    }
-
-    HELPER_METHOD_FRAME_END();
-    return (StringObject *)OBJECTREFToObject(orefStr);
-}
-FCIMPLEND
-
-#endif // !FEATURE_CORECLR
-
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
 // This FCall sets a flag against the thread exception state to indicate to
 // IL_Throw and the StackTraceInfo implementation to account for the fact
 // that we have restored a foreign exception dispatch details.
@@ -1021,7 +978,6 @@ FCIMPL1(Object*, ExceptionNative::CopyDynamicMethods, Object* pDynamicMethodsUNS
 }
 FCIMPLEND
 
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 
 BSTR BStrFromString(STRINGREF s)
 {
@@ -1542,7 +1498,7 @@ void QCALLTYPE Buffer::MemMove(void *dst, void *src, size_t length)
 {
     QCALL_CONTRACT;
 
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_CORESYSTEM)
+#if !defined(FEATURE_CORESYSTEM)
     // Callers of memcpy do expect and handle access violations in some scenarios.
     // Access violations in the runtime dll are turned into fail fast by the vector exception handler by default.
     // We need to supress this behavior for CoreCLR using AVInRuntimeImplOkayHolder because of memcpy is statically linked in.
@@ -2853,67 +2809,8 @@ FCIMPL1(INT32, ValueTypeHelper::GetHashCodeOfPtr, LPVOID ptr)
 }
 FCIMPLEND
 
-#ifndef FEATURE_CORECLR
-FCIMPL1(OBJECTHANDLE, SizedRefHandle::Initialize, Object* _obj)
-{
-    FCALL_CONTRACT;
-
-    OBJECTHANDLE result = 0; 
-    OBJECTREF obj(_obj);
-
-    HELPER_METHOD_FRAME_BEGIN_RET_0();
-
-    result = GetAppDomain()->CreateSizedRefHandle(obj);
-
-    HELPER_METHOD_FRAME_END();
-
-    return result;
-}
-FCIMPLEND
-
-FCIMPL1(VOID, SizedRefHandle::Free, OBJECTHANDLE handle)
-{
-    FCALL_CONTRACT;
-
-    _ASSERTE(handle != NULL);
-
-    HELPER_METHOD_FRAME_BEGIN_0();
-
-    DestroySizedRefHandle(handle);
-
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-
-FCIMPL1(LPVOID, SizedRefHandle::GetTarget, OBJECTHANDLE handle)
-{
-    FCALL_CONTRACT;
-
-    _ASSERTE(handle != NULL);
-
-    OBJECTREF objRef = NULL;
-
-    objRef = ObjectFromHandle(handle);
-
-    FCUnique(0x33);
-    return *((LPVOID*)&objRef);
-}
-FCIMPLEND
-
-FCIMPL1(INT64, SizedRefHandle::GetApproximateSize, OBJECTHANDLE handle)
-{
-    FCALL_CONTRACT;
-
-    _ASSERTE(handle != NULL);
-
-    return (INT64)HndGetHandleExtraInfo(handle);
-}
-FCIMPLEND
-#endif //!FEATURE_CORECLR
 
-#ifdef FEATURE_CORECLR
 COMNlsHashProvider COMNlsHashProvider::s_NlsHashProvider;
-#endif // FEATURE_CORECLR
 
 
 COMNlsHashProvider::COMNlsHashProvider()
diff --git a/src/vm/comutilnative.h b/src/vm/comutilnative.h
index dce7ec600b..21d31f8672 100644
--- a/src/vm/comutilnative.h
+++ b/src/vm/comutilnative.h
@@ -26,9 +26,6 @@
 #include "windows.h"
 #undef GetCurrentTime
 
-#ifndef FEATURE_CORECLR
-#include <winnls.h>
-#endif
 
 #ifdef  FEATURE_RANDOMIZED_STRING_HASHING
 #pragma warning(push)
@@ -98,13 +95,11 @@ public:
     static FCDECL1(FC_BOOL_RET, IsTransient, INT32 hresult);
     static FCDECL3(StringObject *, StripFileInfo, Object *orefExcepUNSAFE, StringObject *orefStrUNSAFE, CLR_BOOL isRemoteStackTrace);
     static void QCALLTYPE GetMessageFromNativeResources(ExceptionMessageKind kind, QCall::StringHandleOnStack retMesg);
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
     static FCDECL0(VOID, PrepareForForeignExceptionRaise);
     static FCDECL1(Object*, CopyStackTrace, Object* pStackTraceUNSAFE);
     static FCDECL1(Object*, CopyDynamicMethods, Object* pDynamicMethodsUNSAFE);
     static FCDECL3(VOID, GetStackTracesDeepCopy, Object* pExceptionObjectUnsafe, Object **pStackTraceUnsafe, Object **pDynamicMethodsUnsafe);
     static FCDECL3(VOID, SaveStackTracesFromDeepCopy, Object* pExceptionObjectUnsafe, Object *pStackTraceUnsafe, Object *pDynamicMethodsUnsafe);
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 
 
     // NOTE: caller cleans up any partially initialized BSTRs in pED
@@ -249,35 +244,6 @@ public:
     static FCDECL1(INT32, GetHashCodeOfPtr, LPVOID ptr);
 };
 
-#ifndef FEATURE_CORECLR
-class SizedRefHandle
-{
-public:
-    static FCDECL1(OBJECTHANDLE,    Initialize, Object* _obj);
-    static FCDECL1(VOID,            Free, OBJECTHANDLE handle);
-    static FCDECL1(LPVOID,          GetTarget, OBJECTHANDLE handle);
-    static FCDECL1(INT64,           GetApproximateSize, OBJECTHANDLE handle);
-};
-
-typedef BOOL (*PFN_IS_NLS_DEFINED_STRING)(NLS_FUNCTION, DWORD, LPNLSVERSIONINFO, LPCWSTR, INT);
-typedef INT (*PFN_COMPARE_STRING_EX)(LPCWSTR, DWORD, LPCWSTR, INT, LPCWSTR, INT, LPNLSVERSIONINFO, LPVOID, LPARAM);
-typedef INT (*PFN_LC_MAP_STRING_EX)(LPCWSTR, DWORD, LPCWSTR, INT, LPWSTR, INT, LPNLSVERSIONINFO, LPVOID, LPARAM);
-typedef INT (*PFN_FIND_NLS_STRING_EX)(LPCWSTR, DWORD, LPCWSTR, INT, LPCWSTR, INT, LPINT, LPNLSVERSIONINFO, LPVOID, LPARAM);
-typedef INT (*PFN_COMPARE_STRING_ORDINAL)(LPCWSTR, INT, LPCWSTR, INT, BOOL);
-typedef BOOL (*PFN_GET_NLS_VERSION_EX)(NLS_FUNCTION, LPCWSTR, LPNLSVERSIONINFOEX);
-typedef INT (*PFN_FIND_STRING_ORDINAL)(DWORD, LPCWSTR, INT, LPCWSTR, INT, BOOL);
-
-class COMNlsCustomSortLibrary {
-public:
-    PFN_IS_NLS_DEFINED_STRING pIsNLSDefinedString;
-    PFN_COMPARE_STRING_EX pCompareStringEx;
-    PFN_LC_MAP_STRING_EX pLCMapStringEx;
-    PFN_FIND_NLS_STRING_EX pFindNLSStringEx;
-    PFN_COMPARE_STRING_ORDINAL pCompareStringOrdinal;
-    PFN_GET_NLS_VERSION_EX pGetNLSVersionEx;
-    PFN_FIND_STRING_ORDINAL pFindStringOrdinal;
-};
-#endif //!FEATURE_CORECLR
 
 typedef const BYTE  * PCBYTE;
 
@@ -289,9 +255,7 @@ public:
     INT32 HashSortKey(PCBYTE pSrc, SIZE_T cbSrc, BOOL forceRandomHashing, INT64 additionalEntropy);
     INT32 HashiStringKnownLower80(LPCWSTR lpszStr, INT32 strLen, BOOL forceRandomHashing, INT64 additionalEntropy);
 
-#ifdef FEATURE_CORECLR
     static COMNlsHashProvider s_NlsHashProvider;
-#endif // FEATURE_CORECLR
 
 #ifdef  FEATURE_RANDOMIZED_STRING_HASHING
     void SetUseRandomHashing(BOOL useRandomHashing) { LIMITED_METHOD_CONTRACT; bUseRandomHashing = useRandomHashing; }
diff --git a/src/vm/comwaithandle.cpp b/src/vm/comwaithandle.cpp
index 13886c3de8..610bb867be 100644
--- a/src/vm/comwaithandle.cpp
+++ b/src/vm/comwaithandle.cpp
@@ -181,11 +181,6 @@ FCIMPL4(INT32, WaitHandleNative::CorWaitOneNative, SafeHandle* safeWaitHandleUNS
     Context* defaultContext;
     defaultContext = pThread->GetDomain()->GetDefaultContext();
     _ASSERTE(defaultContext);
-#ifndef FEATURE_CORECLR
-    // DoAppropriateWait calls LeaveRuntime/EnterRuntime which may cause the current
-    // fiber to be re-scheduled.
-    ThreadAffinityAndCriticalRegionHolder affinityAndCriticalRegionHolder(hasThreadAffinity);
-#endif
     SafeHandleHolder shh(&sh);
     // Note that SafeHandle is a GC object, and RequestCallback and 
     // DoAppropriateWait work on an array of handles.  Don't pass the address
@@ -222,18 +217,6 @@ FCIMPL4(INT32, WaitHandleNative::CorWaitOneNative, SafeHandle* safeWaitHandleUNS
 
     retVal = res;
 
-#ifndef FEATURE_CORECLR
-    if (res == WAIT_OBJECT_0 && hasThreadAffinity) {
-        affinityAndCriticalRegionHolder.SuppressRelease();
-    }
-    else if(res == WAIT_ABANDONED_0) {
-        // WAIT_ABANDONED means the specified object is a mutex object that was not released by the thread 
-        // that owned the mutex object before the owning thread terminated. 
-        // Ownership of the mutex object is granted to the calling thread, and the mutex is set to nonsignaled.    
-        _ASSERTE(hasThreadAffinity);
-        affinityAndCriticalRegionHolder.SuppressRelease();    
-    }
-#endif
 
     HELPER_METHOD_FRAME_END();
     return retVal;
@@ -259,26 +242,14 @@ FCIMPL4(INT32, WaitHandleNative::CorWaitMultipleNative, Object* waitObjectsUNSAF
     // Because it's not, CoreCLR will allow WaitAll on STA threads.
     // But fixing this would be a breaking change at this point, since we already shipped
     // SL 2 and 3 this way.
-    // We we'll also check for FEATURE_CORECLR here, so that if we enable FEATURE_COMINTEROP
-    // on CoreCLR we won't break anyone.
     // Perhaps in a future release we can fix this, if we aren't quite so concerned about
     // compatibility....
-#if defined(FEATURE_COMINTEROP) && !defined(FEATURE_CORECLR)
-    if (waitForAll && numWaiters > 1 && pThread->GetApartment() == Thread::AS_InSTA) {
-        COMPlusThrow(kNotSupportedException, W("NotSupported_WaitAllSTAThread"));
-    }
-#endif // FEATURE_COMINTEROP && !FEATURE_CORECLR
 
     WaitHandleArrayHolder arrayHolder;
     arrayHolder.Initialize(numWaiters, (PTRARRAYREF*) &waitObjects);
     
     pWaitObjects = (PTRARRAYREF)waitObjects;  // array of objects on which to wait
     HANDLE* internalHandles = (HANDLE*) _alloca(numWaiters*sizeof(HANDLE));
-#ifndef FEATURE_CORECLR
-    BOOL *hasThreadAffinity = (BOOL*) _alloca(numWaiters*sizeof(BOOL));
-
-    BOOL mayRequireThreadAffinity = FALSE;
-#endif // !FEATURE_CORECLR
     for (int i=0;i<numWaiters;i++)
     {
         WAITHANDLEREF waitObject = (WAITHANDLEREF) pWaitObjects->m_Array[i];
@@ -289,19 +260,9 @@ FCIMPL4(INT32, WaitHandleNative::CorWaitMultipleNative, Object* waitObjectsUNSAF
         //   this behavior seems wrong but someone explicitly coded that condition so it must have been for a reason.        
         internalHandles[i] = waitObject->m_handle;
 
-#ifndef FEATURE_CORECLR
-        // m_hasThreadAffinity is set for Mutex only 
-        hasThreadAffinity[i] = waitObject->m_hasThreadAffinity;
-        if (hasThreadAffinity[i]) {
-            mayRequireThreadAffinity = TRUE;
-        }
-#endif // !FEATURE_CORECLR
     }
 
     DWORD res = (DWORD) -1;
-#ifndef FEATURE_CORECLR
-    ThreadAffinityHolder affinityHolder(mayRequireThreadAffinity);
-#endif // !FEATURE_CORECLR
     Context* targetContext;
     targetContext = pThread->GetContext();
     _ASSERTE(targetContext);
@@ -335,45 +296,6 @@ FCIMPL4(INT32, WaitHandleNative::CorWaitMultipleNative, Object* waitObjectsUNSAF
         }
     }
 
-#ifndef FEATURE_CORECLR
-    if (mayRequireThreadAffinity) {
-        if (waitForAll) {
-            if (res >= (DWORD) WAIT_OBJECT_0 && res < (DWORD) WAIT_OBJECT_0 + numWaiters) {
-                for (int i = 0; i < numWaiters; i ++) {
-                    if (hasThreadAffinity[i]) {
-                        Thread::BeginThreadAffinityAndCriticalRegion();
-                    }
-                }
-            }
-            // If some mutex is abandoned
-            else if (res >= (DWORD) WAIT_ABANDONED_0 && res < (DWORD) WAIT_ABANDONED_0+numWaiters) {
-                for (int i = 0; i < numWaiters; i ++) {
-                    if (hasThreadAffinity[i])
-                    {
-                        if (WaitForSingleObject(internalHandles[i],0) == WAIT_OBJECT_0)
-                        {
-                            BOOL result;
-                            result = ReleaseMutex(internalHandles[i]);
-                            _ASSERTE (result);
-                            Thread::BeginThreadAffinityAndCriticalRegion();
-                        }
-                    }
-                }
-            }
-        }
-        else {
-            if ( res >= (DWORD)WAIT_OBJECT_0 && res < (DWORD)WAIT_OBJECT_0 + numWaiters) {
-                if (hasThreadAffinity[res - WAIT_OBJECT_0]) {
-                    Thread::BeginThreadAffinityAndCriticalRegion();
-                }
-            }
-            else if (res >= (DWORD)WAIT_ABANDONED_0 && res < (DWORD)WAIT_ABANDONED_0 + numWaiters) {
-                _ASSERTE (hasThreadAffinity[res - WAIT_ABANDONED_0]);
-                Thread::BeginThreadAffinityAndCriticalRegion();                
-            }
-        }
-    }
-#endif // !FEATURE_CORECLR
 
     retVal = res;
 
@@ -415,11 +337,6 @@ FCIMPL5(INT32, WaitHandleNative::CorSignalAndWaitOneNative, SafeHandle* safeWait
     Context* defaultContext = pThread->GetDomain()->GetDefaultContext();
     _ASSERTE(defaultContext);
 
-#ifndef FEATURE_CORECLR
-    // DoSignalAndWait calls LeaveRuntime/EnterRuntime which may cause the current
-    // fiber to be re-scheduled.
-    ThreadAffinityAndCriticalRegionHolder affinityAndCriticalRegionHolder(hasThreadAffinity);
-#endif // !FEATURE_CORECLR
 
     SafeHandleHolder shhSignal(&shSignal);
     SafeHandleHolder shhWait(&shWait);
@@ -444,15 +361,6 @@ FCIMPL5(INT32, WaitHandleNative::CorSignalAndWaitOneNative, SafeHandle* safeWait
         res = pThread->DoSignalAndWait(handles,timeout,TRUE /*alertable*/);
     }
 
-#ifndef FEATURE_CORECLR
-    if (res == WAIT_OBJECT_0 && hasThreadAffinity) {
-        affinityAndCriticalRegionHolder.SuppressRelease();
-    }
-    else if(res == WAIT_ABANDONED_0) {
-        _ASSERTE(hasThreadAffinity);
-        affinityAndCriticalRegionHolder.SuppressRelease();    
-    }
-#endif // !FEATURE_CORECLR
 
     retVal = res;
 
diff --git a/src/vm/confighelper.cpp b/src/vm/confighelper.cpp
deleted file mode 100644
index 815aac7c08..0000000000
--- a/src/vm/confighelper.cpp
+++ /dev/null
@@ -1,309 +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.
-//*****************************************************************************
-// ConfigHelper.cpp
-// 
-//*****************************************************************************
-//
-// XML Helper so that NodeFactory can be implemented in Managed code  
-//
-
-
-
-#include "common.h"
-
-#include "confighelper.h"
-
-ConfigFactory::ConfigFactory(OBJECTREF *pFactory)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-
-    _ASSERTE(pFactory != NULL);
-    Initialize(pFactory);
-    AddRef();
-}
-
-HRESULT STDMETHODCALLTYPE ConfigFactory::NotifyEvent( 
-            /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-            /* [in] */ XML_NODEFACTORY_EVENT iEvt)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_ANY;
-        NOTHROW;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    BEGIN_SO_INTOLERANT_CODE_NOTHROW(GetThread(), return COR_E_STACKOVERFLOW)
-
-    EX_TRY
-    {
-        GetNotifyEventFunctionality()(iEvt);
-    }
-    EX_CATCH_HRESULT(hr);
-
-    END_SO_INTOLERANT_CODE
-
-    return hr;
-}
-
-//---------------------------------------------------------------------------
-HRESULT STDMETHODCALLTYPE ConfigFactory::BeginChildren( 
-    /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-    /* [in] */ XML_NODE_INFO __RPC_FAR *pNodeInfo)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_ANY;
-        NOTHROW;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    BEGIN_SO_INTOLERANT_CODE_NOTHROW(GetThread(), return COR_E_STACKOVERFLOW)
-    EX_TRY
-    {
-        GetBeginChildrenFunctionality()(pNodeInfo->dwSize, 
-                                        pNodeInfo->dwSubType, 
-                                        pNodeInfo->dwType, 
-                                        pNodeInfo->fTerminal, 
-                                        pNodeInfo->pwcText, 
-                                        pNodeInfo->ulLen, 
-                                        pNodeInfo->ulNsPrefixLen);
-    }
-    EX_CATCH_HRESULT(hr);
-
-    END_SO_INTOLERANT_CODE
-    
-    return hr;
-
-}
-
-//---------------------------------------------------------------------------
-HRESULT STDMETHODCALLTYPE ConfigFactory::EndChildren( 
-    /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-    /* [in] */ BOOL fEmptyNode,
-    /* [in] */ XML_NODE_INFO __RPC_FAR *pNodeInfo)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_ANY;
-        NOTHROW;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    BEGIN_SO_INTOLERANT_CODE_NOTHROW(GetThread(), return COR_E_STACKOVERFLOW)
-    
-    EX_TRY
-    {
-        GetEndChildrenFunctionality()(fEmptyNode, 
-                                      pNodeInfo->dwSize, 
-                                      pNodeInfo->dwSubType, 
-                                      pNodeInfo->dwType, 
-                                      pNodeInfo->fTerminal, 
-                                      pNodeInfo->pwcText, 
-                                      pNodeInfo->ulLen, 
-                                      pNodeInfo->ulNsPrefixLen);
-    }
-    EX_CATCH_HRESULT(hr);
-
-    END_SO_INTOLERANT_CODE
-    
-    return hr;
-}
-
-//---------------------------------------------------------------------------
-HRESULT STDMETHODCALLTYPE ConfigFactory::CreateNode(
-    /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-    /* [in] */ PVOID pNode,
-    /* [in] */ USHORT cNumRecs,
-    /* [in] */ XML_NODE_INFO* __RPC_FAR * __RPC_FAR apNodeInfo)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_ANY;
-        NOTHROW;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    BEGIN_SO_INTOLERANT_CODE_NOTHROW(GetThread(), return COR_E_STACKOVERFLOW)
-
-    EX_TRY
-    {
-        DWORD i;
-        WCHAR wstr[128]; 
-        WCHAR *pString = wstr;
-        DWORD dwString = sizeof(wstr)/sizeof(WCHAR);
-        
-        for( i = 0; i < cNumRecs; i++) { 
-            if ( apNodeInfo[i]->ulLen >= dwString) {
-                dwString = apNodeInfo[i]->ulLen+1;
-                if(pString != wstr) delete [] pString;
-                pString = new(nothrow) WCHAR[dwString];
-                IfNullGo(pString);
-            }
-
-            pString[apNodeInfo[i]->ulLen] = W('\0');
-            wcsncpy_s(pString, dwString, apNodeInfo[i]->pwcText, apNodeInfo[i]->ulLen);
-
-            if(i == 0) {
-                GetCreateNodeFunctionality()(apNodeInfo[i]->dwSize, 
-                                             apNodeInfo[i]->dwSubType, 
-                                             apNodeInfo[i]->dwType, 
-                                             apNodeInfo[i]->fTerminal, 
-                                             pString, 
-                                             apNodeInfo[i]->ulLen, 
-                                             apNodeInfo[i]->ulNsPrefixLen);
-            }
-            else {
-                GetCreateAttributeFunctionality()(apNodeInfo[i]->dwSize, 
-                                                  apNodeInfo[i]->dwSubType, 
-                                                  apNodeInfo[i]->dwType, 
-                                                  apNodeInfo[i]->fTerminal, 
-                                                  pString, 
-                                                  apNodeInfo[i]->ulLen, 
-                                                  apNodeInfo[i]->ulNsPrefixLen);
-            }
-
-            if (FAILED(hr))
-                break;
-        }
-        if(pString != wstr) delete [] pString;
-ErrExit:;
-    }
-    EX_CATCH_HRESULT(hr);
-
-    END_SO_INTOLERANT_CODE
-    return hr;
-}
-
-
-
-STDAPI GetXMLObjectEx(IXMLParser **ppv);
-
-//
-//Helper routines to call into managed Node Factory
-//
-
-HRESULT ConfigNative::RunInternal(OBJECTREF *pFactory, LPCWSTR filename)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        INJECT_FAULT(return E_OUTOFMEMORY;);
-    }
-    CONTRACTL_END
-
-    HRESULT        hr = S_OK;  
-    SafeComHolder<IXMLParser> pIXMLParser;
-    SafeComHolder<ConfigFactory>  helperfactory; 
-    SafeComHolder<IStream> pFile; 
-    if (!pFactory){
-        return E_POINTER;
-    }
-
-    hr = CreateConfigStreamHelper(filename,&pFile);
-    if(FAILED(hr))
-        return hr;
-    
-    hr = GetXMLObjectEx(&pIXMLParser);
-    if(FAILED(hr))
-        return hr;
-
-    helperfactory = new (nothrow)ConfigFactory(pFactory);  // RefCount = 1 
-    if ( ! helperfactory) { 
-        return E_OUTOFMEMORY; 
-    }
-
-    hr = pIXMLParser->SetInput(pFile); // filestream's RefCount=2
-    if(FAILED(hr))
-        return hr;
-
-    hr = pIXMLParser->SetFactory(helperfactory); // factory's RefCount=2
-    if(FAILED(hr))
-        return hr;
-
-    // On X86, we emit a call to LogUMTransition which needs us to be in preemptive GC mode
-    // Since we are done dealing with REF's after the call to ConfigFactory constructor,
-    // it is safe to switch to preemptive mode here
-    {
-        GCX_PREEMP();
-        hr = pIXMLParser->Run(-1);
-    }
-
-    if (hr== (HRESULT) XML_E_MISSINGROOT)  //empty file
-        hr=S_OK;
-    return hr;
-}
-
-//
-// Entrypoint to return an Helper interface which Managed code can call to build managed Node factory
-//
-
-FCIMPL2(void, ConfigNative::RunParser, Object* refHandlerUNSAFE, StringObject* strFileNameUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    OBJECTREF  refHandler = (OBJECTREF) refHandlerUNSAFE;
-    STRINGREF  strFileName = (STRINGREF) strFileNameUNSAFE;
-
-    HELPER_METHOD_FRAME_BEGIN_2(refHandler, strFileName);
-
-    HRESULT     hr;
-    WCHAR*      pString;
-    int         iString;
-    LPWSTR      pFileName;
-    CQuickBytes qb;
-
-    if (refHandler == NULL) {
-        COMPlusThrowArgumentNull(W("handler"));
-    }
-
-    if (strFileName == NULL) {
-        COMPlusThrowArgumentNull(W("fileName"));
-    }
-
-    //Get string data.
-    strFileName->RefInterpretGetStringValuesDangerousForGC(&pString, &iString);
-
-    S_UINT32 bufSize = (S_UINT32(iString) + S_UINT32(1)) * S_UINT32(sizeof(WCHAR));
-    _ASSERTE(!bufSize.IsOverflow());
-    if(bufSize.IsOverflow())
-    {
-        ThrowWin32(ERROR_ARITHMETIC_OVERFLOW);
-    }
-
-    pFileName = (LPWSTR) qb.AllocThrows(bufSize.Value());
-    memcpy(pFileName, pString, bufSize.Value());
-
-    hr = RunInternal(&refHandler, pFileName);
-
-    if (FAILED(hr))
-        COMPlusThrowHR(hr);
-
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
diff --git a/src/vm/confighelper.h b/src/vm/confighelper.h
deleted file mode 100644
index 3784dfc39b..0000000000
--- a/src/vm/confighelper.h
+++ /dev/null
@@ -1,203 +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.
-//*****************************************************************************
-// ConfigHelper.h
-// 
-//*****************************************************************************
-//
-// These are unmanaged definitions of interfaces used call Managed Node Factories
-// If you make any changes please do corresponding changes in \src\bcl\system\__xmlparser.cs
-//
-
-
-#ifndef _CONFIGHELPER_H
-#define _CONFIGHELPER_H
-
-#include <mscoree.h>
-#include <xmlparser.h>
-#include <mscorcfg.h>
-#include "unknwn.h"
-#include "../xmlparser/_reference.h"
-#include "../xmlparser/_unknown.h"
-#include "comdelegate.h"
-
-class ConfigFactory : public _unknown<IXMLNodeFactory, &IID_IXMLNodeFactory>
-{
-    #define ICONFIGHANDLER_CALLBACK_COUNT 6
-    OBJECTREF *m_pManagedFactory;
-    LPVOID eventCallbacks[ICONFIGHANDLER_CALLBACK_COUNT];
-    
-    // We assume the offsets as per the object layout of ConfigTreeParser defined in CfgParser.cs
-    // Any changes made at either place must be propagated to the other
-    LPVOID GetCallbackAtOffset(DWORD dwOffset)
-    {
-        CONTRACTL
-        {
-            THROWS;
-            GC_TRIGGERS;
-            MODE_COOPERATIVE;
-            PRECONDITION(dwOffset < ICONFIGHANDLER_CALLBACK_COUNT);
-        }
-        CONTRACTL_END;
-
-        PTRARRAYREF refAllDelegates = (PTRARRAYREF)ObjectToOBJECTREF((Object *)((*m_pManagedFactory)->GetPtrOffset(0)));
-        _ASSERTE(refAllDelegates->GetNumComponents()==ICONFIGHANDLER_CALLBACK_COUNT);
-        return COMDelegate::ConvertToCallback(refAllDelegates->GetAt(dwOffset));
-    }
-
-    void Initialize(OBJECTREF *pFactory)
-    {
-        CONTRACTL
-        {
-            NOTHROW;
-            GC_TRIGGERS;
-            MODE_COOPERATIVE;
-            PRECONDITION(pFactory != NULL);
-        }
-        CONTRACTL_END;
-
-        m_pManagedFactory = pFactory;
-        EX_TRY
-        {
-            for(int i=0; i<ICONFIGHANDLER_CALLBACK_COUNT; i++)
-            {
-                eventCallbacks[i] = GetCallbackAtOffset(i);
-            }
-        } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);        
-    }
-
-    typedef VOID (STDMETHODCALLTYPE *NotifyEventCallback)(
-            /* [in] */ XML_NODEFACTORY_EVENT iEvt);
-
-    NotifyEventCallback GetNotifyEventFunctionality()
-    {
-        LIMITED_METHOD_CONTRACT;
-        _ASSERTE(eventCallbacks[0] != NULL);
-        return (NotifyEventCallback)eventCallbacks[0];
-    }
-
-    typedef VOID (STDMETHODCALLTYPE *BeginChildrenCallback)(
-            /* [in] */ DWORD dwSize,
-            /* [in] */ DWORD dwSubType,
-            /* [in] */ DWORD dwType,
-            /* [in] */ BOOL fTerminal,
-            /* [in] */ LPCWSTR pwcText,
-            /* [in] */ DWORD ulLen,
-            /* [in] */ DWORD ulNsPrefixLen);
-    
-    BeginChildrenCallback GetBeginChildrenFunctionality()
-    {
-        LIMITED_METHOD_CONTRACT;
-        _ASSERTE(eventCallbacks[1] != NULL);
-        return (BeginChildrenCallback)eventCallbacks[1];
-    }
-
-    typedef VOID (STDMETHODCALLTYPE *EndChildrenCallback)(
-            /* [in] */ BOOL  fEmpty,
-            /* [in] */ DWORD dwSize,
-            /* [in] */ DWORD dwSubType,
-            /* [in] */ DWORD dwType,
-            /* [in] */ BOOL fTerminal,
-            /* [in] */ LPCWSTR pwcText,
-            /* [in] */ DWORD ulLen,
-            /* [in] */ DWORD ulNsPrefixLen);
-
-    EndChildrenCallback GetEndChildrenFunctionality()
-    {
-        LIMITED_METHOD_CONTRACT;
-        _ASSERTE(eventCallbacks[2] != NULL);
-        return (EndChildrenCallback)eventCallbacks[2];
-    }
-
-    typedef VOID (STDMETHODCALLTYPE *ErrorCallback)(
-            /* [in] */ DWORD dwSize,
-            /* [in] */ DWORD dwSubType,
-            /* [in] */ DWORD dwType,
-            /* [in] */ BOOL fTerminal,
-            /* [in] */ LPCWSTR pwcText,
-            /* [in] */ DWORD ulLen,
-            /* [in] */ DWORD ulNsPrefixLen);
-    
-    ErrorCallback GetErrorFunctionality()
-    {
-        _ASSERTE(eventCallbacks[3] != NULL);
-        return (ErrorCallback)eventCallbacks[3];
-    }
-
-    typedef VOID (STDMETHODCALLTYPE *CreateNodeCallback)(
-            /* [in] */ DWORD dwSize,
-            /* [in] */ DWORD dwSubType,
-            /* [in] */ DWORD dwType,
-            /* [in] */ BOOL fTerminal,
-            /* [in] */ LPCWSTR pwcText,
-            /* [in] */ DWORD ulLen,
-            /* [in] */ DWORD ulNsPrefixLen);
-
-    CreateNodeCallback GetCreateNodeFunctionality()
-    {
-        LIMITED_METHOD_CONTRACT;
-        _ASSERTE(eventCallbacks[4] != NULL);
-        return (CreateNodeCallback)eventCallbacks[4];
-    }
-
-    typedef VOID (STDMETHODCALLTYPE *CreateAttributeCallback)(
-            /* [in] */ DWORD dwSize,
-            /* [in] */ DWORD dwSubType,
-            /* [in] */ DWORD dwType,
-            /* [in] */ BOOL fTerminal,
-            /* [in] */ LPCWSTR pwcText,
-            /* [in] */ DWORD ulLen,
-            /* [in] */ DWORD ulNsPrefixLen);
-
-    CreateAttributeCallback GetCreateAttributeFunctionality()
-    {
-        LIMITED_METHOD_CONTRACT;
-        _ASSERTE(eventCallbacks[5] != NULL);
-        return (CreateAttributeCallback)eventCallbacks[5];
-    }
-    #undef ICONFIGHANDLER_CALLBACK_COUNT
-    
-public:
-    ConfigFactory(OBJECTREF *pFactory);
-
-    HRESULT STDMETHODCALLTYPE NotifyEvent( 
-            /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-            /* [in] */ XML_NODEFACTORY_EVENT iEvt);
-
-    HRESULT STDMETHODCALLTYPE BeginChildren( 
-        /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-        /* [in] */ XML_NODE_INFO* __RPC_FAR pNodeInfo);
-    
-    HRESULT STDMETHODCALLTYPE EndChildren( 
-        /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-        /* [in] */ BOOL fEmptyNode,
-        /* [in] */ XML_NODE_INFO* __RPC_FAR pNodeInfo);
-    
-    HRESULT STDMETHODCALLTYPE Error( 
-        /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-        /* [in] */ HRESULT hrErrorCode,
-        /* [in] */ USHORT cNumRecs,
-        /* [in] */ XML_NODE_INFO* __RPC_FAR * __RPC_FAR apNodeInfo)
-    {
-        LIMITED_METHOD_CONTRACT;
-        STATIC_CONTRACT_SO_TOLERANT;
-        return hrErrorCode;
-    }
-    
-    HRESULT STDMETHODCALLTYPE CreateNode( 
-        /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-        /* [in] */ PVOID pNodeParent,
-        /* [in] */ USHORT cNumRecs,
-        /* [in] */ XML_NODE_INFO* __RPC_FAR * __RPC_FAR apNodeInfo);
-};
-
-class ConfigNative
-{
-    static HRESULT RunInternal(OBJECTREF *pFactory, LPCWSTR filename);
-
-public:
-    static FCDECL2(void, RunParser, Object* refHandlerUNSAFE, StringObject* strFileNameUNSAFE);
-};
-
-#endif //  _CONFIGHELPER_H
diff --git a/src/vm/constrainedexecutionregion.cpp b/src/vm/constrainedexecutionregion.cpp
deleted file mode 100644
index 77b944c416..0000000000
--- a/src/vm/constrainedexecutionregion.cpp
+++ /dev/null
@@ -1,2265 +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.
-//
-// Methods to support the implementation of Constrained Execution Regions (CERs). This includes logic to walk the IL of methods to
-// determine the statically determinable call graph and prepare each submethod (jit, prepopulate generic dictionaries etc.,
-// everything needed to ensure that the runtime won't generate implicit failure points during the execution of said call graph).
-//
-
-//
-
-
-#include "common.h"
-#include <openum.h>
-#include <mdaassistants.h>
-#include <constrainedexecutionregion.h>
-#include <ecmakey.h>
-#include <typestring.h>
-#include <jitinterface.h>
-
-#ifdef FEATURE_PREJIT
-#include <compile.h>
-#endif
-
-
-// Internal debugging support. Would be nice to use the common logging code but we've run out of unique facility codes and the debug
-// info we spew out is of interest to a limited audience anyhow.
-#ifdef _DEBUG
-
-#define CER_NOISY_PREPARE       0x00000001
-#define CER_NOISY_RESTORE       0x00000002
-#define CER_NOISY_CONTRACTS     0x00000004
-#define CER_NOISY_WARNINGS      0x00000008
-#define CER_NOISY_NGEN_STATS    0x00000010
-
-DWORD g_dwCerLogActions = 0xffffffff;
-DWORD GetCerLoggingOptions()
-{
-    WRAPPER_NO_CONTRACT;
-    if (g_dwCerLogActions != 0xffffffff)
-        return g_dwCerLogActions;
-    return g_dwCerLogActions = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_CerLogging);
-}
-
-#define CER_LOG(_reason, _msg) do { if (GetCerLoggingOptions() & CER_NOISY_##_reason) printf _msg; } while (false)
-#else
-#define CER_LOG(_reason, _msg)
-#endif
-
-
-// Enumeration used to determine the number of inline data bytes included inside a given IL instruction (except for the case of a
-// SWITCH instruction, where a dynamic calculation is required).
-enum
-{
-        ArgBytes_InlineNone             = 0,    // no inline args       
-        ArgBytes_InlineVar              = 2,    // local variable       (U2 (U1 if Short on))
-        ArgBytes_InlineI                = 4,    // an signed integer    (I4 (I1 if Short on))
-        ArgBytes_InlineR                = 8,    // a real number        (R8 (R4 if Short on))
-        ArgBytes_InlineBrTarget         = 4,    // branch target        (I4 (I1 if Short on))
-        ArgBytes_InlineI8               = 8,
-        ArgBytes_InlineMethod           = 4,    // method token (U4)
-        ArgBytes_InlineField            = 4,    // field token  (U4)
-        ArgBytes_InlineType             = 4,    // type token   (U4)
-        ArgBytes_InlineString           = 4,    // string TOKEN (U4)
-        ArgBytes_InlineSig              = 4,    // signature tok (U4)
-        ArgBytes_InlineRVA              = 4,    // ldptr token  (U4)
-        ArgBytes_InlineTok              = 4,    // a meta-data token of unknown type (U4)
-        ArgBytes_InlineSwitch           = 4,    // count (U4), pcrel1 (U4) .... pcrelN (U4)
-        ArgBytes_ShortInlineVar         = 1,
-        ArgBytes_ShortInlineI           = 1,
-        ArgBytes_ShortInlineR           = 4,
-        ArgBytes_ShortInlineBrTarget    = 1
-};
-
-// Build an array of argument byte counts as described above by extracting the 'args' field of each entry in opcode.def.
-#define OPDEF(c, s, pop, push, args, type, l, s1, s2, ctrl) ArgBytes_##args,
-const BYTE g_rOpArgs[] = {
-#include <opcode.def>
-};
-#undef OPDEF
-
-
-// Global cache of methods and their reliability contract state.
-PtrHashCache *g_pMethodContractCache = NULL;
-
-
-// Private method forward references.
-bool IsPcrReference(Module *pModule, mdToken tkMethod);
-MethodContext *TokenToMethodDesc(Module *pModule, mdToken tokMethod, SigTypeContext *pTypeContext);
-TypeHandle GetTypeFromMemberDefOrRefOrSpecThrowing(Module         *pModule,
-                                                   mdToken         tokMethod,
-                                                   SigTypeContext *pTypeContext);
-
-bool MethodCallGraphPreparer::ShouldGatherExplicitCERCallInfo()
-{
-    LIMITED_METHOD_CONTRACT;
-
-    // If we're partially processing a method body (at the top of the call graph), we need to fetch exception handling
-    // information to determine possible ranges of interesting IL (potentially each finally and catch clause).
-    // 
-    // And if we are probing for stack overflow, we need to know if the explicit CER region contains any calls out, in 
-    // which case we want to probe in the call to PrepareConstrainedExecutionRegions.  This will ensure that we don't
-    // take an SO in boundary code and not be able to call the CER.  When stack probing is disabled, we rip the process
-    // if we take an SO anywhere but managed, or if we take an SO with a CER on the stack.  For NGEN images, we need 
-    // to always probe because stack probing may be enabled in the runtime, but if we haven't probed in the NGEN image
-    // then we could take an SO in boundary code and not be able to crawl the stack to know that we've skipped a CER and
-    // need to tear the process.
-    //
-    // Additionally, if the MDA for illegal PrepareConstrainedRegions call positioning is enabled we gather this information for
-    // all methods in the graph.
-    return !m_fEntireMethod 
-#ifdef MDA_SUPPORTED
-        || MDA_GET_ASSISTANT(IllegalPrepareConstrainedRegion)
-#endif
-#ifdef FEATURE_NATIVE_IMAGE_GENERATION
-        || m_fNgen
-#endif
-        || g_pConfig->ProbeForStackOverflow();
-}
-
-MethodCallGraphPreparer::MethodCallGraphPreparer(MethodDesc *pRootMD, SigTypeContext *pRootTypeContext, bool fEntireMethod, bool fExactTypeContext, bool fIgnoreVirtualCERCallMDA)
-{
-    CONTRACTL {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pRootMD));
-        PRECONDITION(CheckPointer(pRootTypeContext));
-    } CONTRACTL_END;
-
-    // Canonicalize value type unboxing stubs into their underlying method desc.
-    if (pRootMD->IsUnboxingStub())
-        pRootMD = pRootMD->GetWrappedMethodDesc();
-
-    m_pRootMD = pRootMD;
-    m_pRootTypeContext = pRootTypeContext;
-    m_fEntireMethod = fEntireMethod;
-    m_fExactTypeContext = fExactTypeContext;
-    m_fIgnoreVirtualCERCallMDA = fIgnoreVirtualCERCallMDA;
-    
-    m_pEHClauses = NULL;
-    m_cEHClauses = 0;
-    m_pCerPrepInfo = NULL;  
-    m_pMethodDecoder = NULL;
-
-#ifdef FEATURE_NATIVE_IMAGE_GENERATION
-    m_fNgen = false; 
-#endif
-
-    m_pThread = GetThread(); 
-    m_fPartialPreparation = false;
-    m_fMethodHasCallsWithinExplicitCer = false;
-}
-
-// Walk the call graph of the method given by pRootMD (and type context in pRootTypeContext which provides instantiation information
-// for generic methods/classes).
-//
-// If fEntireMethod is true then the entire body of pRootMD is scanned for callsites, otherwise we assume that one or more CER
-// exception handlers exist in the method and only the finally and catch blocks of such handlers are scanned for graph roots.
-//
-// Each method we come across in the call graph (excluding late bound invocation destinations precipitated by virtual or interface
-// calls) is jitted and has any generic dictionary information we can determine at jit time prepopulated. This includes implicit
-// cctor invocations. If this method is called at ngen time we will attach extra fixup information to the affected method to ensure
-// that fixing up the root method of the graph will cause all methods in the graph to be fixed up at that point also.
-//
-// Some generic dictionary entries may not be prepopulated if unbound type variables exist at the root of the call tree. Such cases
-// will be ignored (as for the virtual/interface dispatch case we assume the caller will use an out-of-band mechanism to pre-prepare
-// these entries explicitly).
-bool MethodCallGraphPreparer::Run()
-{
-    STANDARD_VM_CONTRACT;
-
-    // Avoid recursion while jitting methods for another preparation.
-    if (!m_pThread->GetCerPreparationState()->CanPreparationProceed(m_pRootMD, m_pRootTypeContext))
-        return TRUE;   // Assume the worst
-
-#ifdef FEATURE_NATIVE_IMAGE_GENERATION
-    // Determine if we're being called in order to provide an ngen image. This impacts whether we actually prepare methods and the
-    // type of tracking data we produce. Ideally we'd call GetAppDomain()->IsCompilationDomain() here, but we have to deal with the
-    // problem of ngen'ing mscorlib. Mscorlib code is always shared and some of it is run before the compilation domain is fully
-    // created (so we'd end up with some methods being prepared without saving any ngen metadata to that effect). So instead we
-    // check to see whether this is an ngen process. This will catch those first few mscorlib methods.
-    m_fNgen = IsCompilationProcess() != FALSE;
-
-    // We keep a hash table of CERs we've processed on the module object of the root method. See if any work has been done on this
-    // CER before. We store different data for ngen and non-ngen cases.
-    if (m_fNgen) {
-
-        // Pretty simple in ngen case -- if we've stored a context record for this method at all then we've already processed it.
-        if (m_pRootMD->GetModule()->IsNgenCerRootMethod(m_pRootMD)) {
-            m_pCerPrepInfo = m_pRootMD->GetModule()->GetCerPrepInfo(m_pRootMD);
-
-            // We always store CerPrepInfo if the method has calls, so if we haven't stored
-            // anything then we know it doesn't have any calls
-            return (m_pCerPrepInfo && m_pCerPrepInfo->m_fMethodHasCallsWithinExplicitCer);
-        }
-    } else 
-#endif
-    {
-        // The non-ngen case (normal jit, call to PrepareMethod etc).
-        m_pCerPrepInfo = m_pRootMD->GetModule()->GetCerPrepInfo(m_pRootMD);
-        if (m_pCerPrepInfo) {
-
-            // Check for the "everything's done" case.
-            if (m_pCerPrepInfo->m_fFullyPrepared)
-                return m_pCerPrepInfo->m_fMethodHasCallsWithinExplicitCer;
-
-            // Check for the "we can't do anything" case (see below for descriptions of that).
-            if (m_pCerPrepInfo->m_fRequiresInstantiation && !m_fExactTypeContext)
-                return m_pCerPrepInfo->m_fMethodHasCallsWithinExplicitCer;
-
-            // Check for the "need to prepare per-instantiation, but we've already done this one" case.
-            if (m_pCerPrepInfo->m_fRequiresInstantiation) {
-                HashDatum sDatum;
-                if (m_pCerPrepInfo->m_sIsInitAtInstHash.GetValue(m_pRootTypeContext, &sDatum))
-                    return m_pCerPrepInfo->m_fMethodHasCallsWithinExplicitCer;
-            }
-        }
-    }
-
-    // We can't deal with generic methods or methods on generic types that may have some representative type parameters in their
-    // instantiation (i.e. some reference types indicated by Object rather than the exact type). The jit will tend to pass us these
-    // since it shares code between instantiations over reference types. We can't prepare methods like these completely -- even
-    // though we can jit all the method bodies the code might require generic dictionary information at the class or method level
-    // that is populated at runtime and can introduce failure points. So we reject such methods immediately (they will need to be
-    // prepared at non-jit time by an explicit call to PrepareMethod with a fully instantiated method).
-    //
-    // In the case where the type context is marked as suspect (m_fExactTypeContext == false) there are a number of possibilites for
-    // bad methods the jit will pass us:
-    //  1) We're passed a MethodDesc that shared between instantiations (bogus because exact method descs are never shared).
-    //  2) We're passed a MethodDesc that's an instantiating stub (bogus because non-shared methods don't need this).
-    //  3) We're passed a MethodDesc that has generic variables in its instantiations (I've seen this during ngen).
-    //
-    // Technically we could do a little better than this -- we could determine whether any of the representative type parameters are
-    // actually used within the CER call graph itself. But this would require us to understand the IL at a much deeper level (i.e.
-    // parse every instruction that could take a type or member spec and pull apart those specs to see if a type var is used). Plus
-    // we couldn't make this determination until we've prepared the entire region and the result is rather brittle from the code
-    // author's point of view (i.e. we might prepare a CER automatically one day but stop doing after some relatively subtle changes
-    // in the source code).
-    m_fPartialPreparation = m_pRootMD->IsSharedByGenericInstantiations() || m_pRootMD->IsInstantiatingStub() || m_pRootMD->ContainsGenericVariables();
-    if (!m_fExactTypeContext && m_fPartialPreparation) {
-#ifdef MDA_SUPPORTED
-        MDA_TRIGGER_ASSISTANT(OpenGenericCERCall, ReportViolation(m_pRootMD));
-#endif
-        CER_LOG(WARNINGS, ("CER: %s has open type parameters and can't be pre-prepared\n", m_pRootMD->m_pszDebugMethodName));
-
-
-#ifdef FEATURE_NATIVE_IMAGE_GENERATION
-        if (!m_fNgen) 
-#endif
-        {
-            // Set up a prep info structure for this method if it's not there already (the create method takes care of races).
-            if (m_pCerPrepInfo == NULL)
-                m_pCerPrepInfo = m_pRootMD->GetModule()->CreateCerPrepInfo(m_pRootMD);
-
-            // We may be racing to update the structure at this point but that's OK since the flag we're setting is never cleared once
-            // it's set and is always guaranteed to be set before we rely on its value (setting it here is just a performance thing,
-            // letting us early-out on multiple attempts to prepare this CER from the jit).
-            m_pCerPrepInfo->m_fRequiresInstantiation = true;
-        }
-
-        if (! g_pConfig->ProbeForStackOverflow())
-        {
-            return FALSE;
-        }
-        m_pCerPrepInfo = m_pRootMD->GetModule()->GetCerPrepInfo(m_pRootMD);
-
-        // We always store CerPrepInfo if the method has calls, so if we haven't stored
-        // anything then we know it doesn't have any calls
-        return (m_pCerPrepInfo && m_pCerPrepInfo->m_fMethodHasCallsWithinExplicitCer);
-        
-    }
-
-#ifdef FEATURE_NATIVE_IMAGE_GENERATION
-    // If we've been called for a shared generic root method and the exact instantiation (this can happen because ngen lets code
-    // execute under some circumstances) we don't currently support saving this information in the ngen image (we don't have a
-    // format for the instantiation info). We just ignore the preparation in this case (it will be prepared at runtime).
-    if (m_fNgen && m_fPartialPreparation)
-        return TRUE;
-#endif
-
-    // Prevent inlining of the root method (otherwise it's hard to tell where ThreadAbort exceptions should be delayed). Note that
-    // MethodDesc::SetNotInline is thread safe.
-    m_pRootMD->SetNotInline(true);
-
-    // Remember the checkpoint for all of our allocations. Keep it in a holder so they'll be unwound if we throw an exception past
-    // here.
-    CheckPointHolder sCheckpoint(m_pThread->m_MarshalAlloc.GetCheckpoint());
-
-    // Push the current method as the one and only method to process so far.
-    m_sLeftToProcess.Push(MethodContext::PerThreadAllocate(m_pRootMD, m_pRootTypeContext));
-
-    MethodContext      *pContext = NULL;               // The current MethodContext we're processing
-    
-    // Iterate until we run out of methods to process.
-    while ((pContext = m_sLeftToProcess.Pop()) != NULL) {
-
-        // Restore the MD if necessary. In particular, if this is an instantiating stub and the wrapped MethodDesc could
-        // not be hard bound, then we'll need to restore that pointer before getting it.
-        pContext->m_pMethodDesc->CheckRestore();
-
-        // Transfer the method to the already seen stack immediately (we don't want to loop infinitely in the case of method
-        // recursion).
-        m_sAlreadySeen.Push(pContext);
-
-        // Check if the enclosing class requires a static class constructor to be run. If so, we need to prepare that method as
-        // though it were any other call.
-        if (pContext->m_pMethodDesc->GetMethodTable()->HasClassConstructor()) {
-
-            // Decode target method into MethodDesc and new SigTypeContext.
-            // The type context is easy to derive here : .cctors never have any method type parameters and the class instantiations
-            // are those of the method we're currently parsing, so can be simply copied down.
-            MethodDesc *pCctor = pContext->m_pMethodDesc->GetCanonicalMethodTable()->GetClassConstructor();
-            SigTypeContext sCctorTypeContext(pCctor, pContext->m_sTypeContext.m_classInst, Instantiation());
-            MethodContext *pCctorContext = MethodContext::PerThreadAllocate(pCctor, &sCctorTypeContext);
-
-            // Only process this cctor the first time we find it in this call graph.
-            if (!m_sAlreadySeen.IsInStack(pCctorContext) && !m_sLeftToProcess.IsInStack(pCctorContext))
-                m_sLeftToProcess.Push(pCctorContext);
-        }
-
-        // Skip further processing if this method doesn't have an IL body (note that we assume the method we entered with was IL, so
-        // we don't need to bother with partial method processing).
-        if (!pContext->m_pMethodDesc->IsIL()) {
-            _ASSERTE(m_fEntireMethod);
-            continue;
-        }
-
-        // Locate the IL body of the current method. May have to account for the fact that the current method desc is an
-        // instantiating stub and burrow down for the real method desc.
-        MethodDesc *pRealMethod = pContext->m_pMethodDesc;
-        if (pRealMethod->IsInstantiatingStub()) {
-            _ASSERTE(!pRealMethod->ContainsGenericVariables());
-            pRealMethod = pRealMethod->GetWrappedMethodDesc();
-        }
-
-        COR_ILMETHOD* pILHeader = pRealMethod->GetILHeader();
-
-        // Skip malformed methods. (We should always have method with IL for well-formed images here.)
-        if (pILHeader == NULL) {
-            continue;
-        }
-
-        COR_ILMETHOD_DECODER method(pILHeader);
-        m_pMethodDecoder = &method;
-
-        // We want to reget the EH clauses for the current method so that we can scan its handlers
-        GetEHClauses();
-
-        LookForInterestingCallsites(pContext);
-
-        // Whatever we've done, we're definitely not processing the top-level method at this point (so we'll be processing full
-        // method bodies from now on).
-        m_fEntireMethod = true;
-    }
-
-#ifdef FEATURE_NATIVE_IMAGE_GENERATION
-    if (!m_fNgen) 
-#endif
-    {
-        // Set up a prep info structure for this method if it's not there already (the create method takes care of races).
-        // This needs to happen before we start JITing the methods as part of preparation. The JIT needs to know
-        // about the CER root in CEEInfo::canTailCall.
-        if (m_pCerPrepInfo == NULL)
-            m_pCerPrepInfo = m_pRootMD->GetModule()->CreateCerPrepInfo(m_pRootMD);
-    }
-
-    // Prevent infinite recursion by recording on the thread which roots we're currently preparing.
-    ThreadPreparingCerHolder sCerHolder(this);
-
-    // Once we get here we've run out of methods to process and have recorded each method we visited in the m_sAlreadySeen stack. Now
-    // it's time to prepare each of these methods (jit, prepopulate generic dictionaries etc.).
-    PrepareMethods();
-
-    return RecordResults();
-}
-
-
-// Determine whether a CER preparation for the given root method (with type context for generic instantiation
-// if necessary) can go ahead given any current preparation already being performed on the current thread.
-BOOL MethodCallGraphPreparer::CanPreparationProceed(MethodDesc * pMD, SigTypeContext * pTypeContext)
-{
-    WRAPPER_NO_CONTRACT;
-    MethodCallGraphPreparer * pCurrPrep = this;
-    while (pCurrPrep)
-    {
-        // Is the prepartion request for the root method of the current preparer?
-        if (pMD == pCurrPrep->m_pRootMD && SigTypeContext::Equal(pTypeContext, pCurrPrep->m_pRootTypeContext))
-        {
-            // We're already preparing this root, return FALSE to turn the request into a no-op and avoid
-            // infinite recursion.
-            return FALSE;
-        }
-
-        pCurrPrep = pCurrPrep->m_pNext;
-    }
-
-    // We found no previous preparation for the same root, so the request can proceed.
-    return TRUE;
-}
-
-// Methods that push and pop thread local state used to determine if a re-entrant preparation request should
-// complete immediately as a no-op (because it would lead to an infinite recursion) or should proceed
-// recursively.
-
-//static
-void MethodCallGraphPreparer::BeginPrepareCerForHolder(MethodCallGraphPreparer * pPrepState)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    Thread * pThread = pPrepState->m_pThread;
-    pPrepState->m_pNext = pThread->GetCerPreparationState();
-    pThread->SetCerPreparationState(pPrepState);
-}
-
-//static
-void MethodCallGraphPreparer::EndPrepareCerForHolder(MethodCallGraphPreparer * pPrepState)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    Thread * pThread = pPrepState->m_pThread;
-    _ASSERTE(pThread && pThread->GetCerPreparationState() == pPrepState);
-    pThread->SetCerPreparationState(pPrepState->m_pNext);
-}
-
-
-void MethodCallGraphPreparer::GetEHClauses()
-{
-    STANDARD_VM_CONTRACT;
-
-    if (! ShouldGatherExplicitCERCallInfo())
-    {
-        return;
-    }
-
-    m_cEHClauses = 0;
-    m_pEHClauses = NULL;    // we use the StackingAllocator, so don't have to delete the previous storage
-    
-    COR_ILMETHOD_SECT_EH const * pEH = m_pMethodDecoder->EH;
-    if (pEH == NULL ||pEH->EHCount() == 0) 
-    {
-        return;
-    }
-
-    m_cEHClauses = pEH->EHCount();
-    m_pEHClauses = new (&m_pThread->m_MarshalAlloc) EHClauseRange[m_cEHClauses];
-
-    for (DWORD i = 0; i < m_cEHClauses; i++) 
-    {
-        COR_ILMETHOD_SECT_EH_CLAUSE_FAT         sEHClauseBuffer;
-        const COR_ILMETHOD_SECT_EH_CLAUSE_FAT   *pEHClause;
-
-        pEHClause = (COR_ILMETHOD_SECT_EH_CLAUSE_FAT*)pEH->EHClause(i, &sEHClauseBuffer);
-
-        // The algorithm below assumes handlers are located after their associated try blocks. If this turns out to be a
-        // false assumption we need to move to a two pass technique (or defer callsite handling in some other fashion until
-        // we've scanned the IL for all calls to our preparation marker method).
-        if (!(pEHClause->GetTryOffset() < pEHClause->GetHandlerOffset()))
-        {
-            COMPlusThrowHR(COR_E_NOTSUPPORTED, IDS_EE_NOTSUPPORTED_CATCHBEFORETRY);
-        }
-
-        m_pEHClauses[i].m_dwTryOffset = pEHClause->GetTryOffset();
-        m_pEHClauses[i].m_dwHandlerOffset = pEHClause->GetHandlerOffset();
-        m_pEHClauses[i].m_dwHandlerLength = pEHClause->GetHandlerLength();
-        m_pEHClauses[i].m_fActive = false;
-
-        //printf("Try: %u Handler: %u -> %u\n", pEHClause->GetTryOffset(), pEHClause->GetHandlerOffset(), pEHClause->GetHandlerOffset() + pEHClause->GetHandlerLength() - 1);
-    }
- 
-}
-
-void MethodCallGraphPreparer::MarkEHClauseActivatedByCERCall(MethodContext *pContext, BYTE *pbIL, DWORD cbIL)
-{
-    STANDARD_VM_CONTRACT;
-
-    DWORD   dwOffset = (DWORD)(SIZE_T)((pbIL + ArgBytes_InlineTok) - (BYTE*)m_pMethodDecoder->Code);
-
-    // Additionally we need to cope with the fact that VB and C# (for debug builds) can generate NOP instructions
-    // between the PCR call and the beginning of the try block. So we're potentially looking for the
-    // intersection of the try with a range of instructions. Count the number of consecutive NOP instructions
-    // which follow the call.
-    DWORD   dwLength = 0;
-    BYTE   *pbTmpIL = pbIL + ArgBytes_InlineTok;
-    while (pbTmpIL < (pbIL + cbIL) && *pbTmpIL++ == CEE_NOP)
-    {
-        dwLength++;
-    }
-
-    bool    fMatched = false;
-    for (DWORD i = 0; i < m_cEHClauses; i++)
-    {
-        if (m_pEHClauses[i].m_dwTryOffset >= dwOffset &&
-            m_pEHClauses[i].m_dwTryOffset <= (dwOffset + dwLength)) 
-        {
-            fMatched = true;
-            m_pEHClauses[i].m_fActive = true;
-        }
-    }
-    if (!fMatched) 
-    {
-#if defined(_DEBUG) || defined(MDA_SUPPORTED)
-        DWORD dwPCROffset = (DWORD)(SIZE_T)((pbIL - 1) - (BYTE*)m_pMethodDecoder->Code);
-#endif // defined(_DEBUG) || defined(MDA_SUPPORTED)
-#ifdef MDA_SUPPORTED
-        MDA_TRIGGER_ASSISTANT(IllegalPrepareConstrainedRegion, ReportViolation(pContext->m_pMethodDesc, dwPCROffset));
-#endif
-        CER_LOG(WARNINGS, ("CER: %s: Invalid call to PrepareConstrainedRegions() at IL +%04X\n",
-                           pContext->m_pMethodDesc->m_pszDebugMethodName, dwPCROffset));
-    }
-}
-
-bool MethodCallGraphPreparer::CheckIfCallsiteWithinCER(DWORD dwOffset)
-{
-    STANDARD_VM_CONTRACT;
-
-    //printf("Found: %s at %u\n", pCallTarget->m_pMethodDesc->m_pszDebugMethodName, dwOffset);
-
-    // Search all the EH regions we know about.
-    for (DWORD i = 0; i < m_cEHClauses; i++) 
-    {
-        bool fCallsiteWithinCER = false;
-        if (! m_pEHClauses[i].m_fActive) 
-        {
-            // clause not CER-active so skip it
-            continue;
-        }
-        if (dwOffset >= (m_pEHClauses[i].m_dwHandlerOffset + m_pEHClauses[i].m_dwHandlerLength)) 
-        {
-            // offset beyond clause, so skip it
-            continue;
-        }
-        if (dwOffset >= m_pEHClauses[i].m_dwTryOffset)
-        {   
-            // For stack probing optimization, we care if either the try or the handler has a call.  If neither
-            // does, then we can optimize the probe out.
-            m_fMethodHasCallsWithinExplicitCer = true;
-            if (dwOffset >= m_pEHClauses[i].m_dwHandlerOffset)
-            {
-                fCallsiteWithinCER = true;
-            }
-        }
-        // Only terminate if we got a positive result (i.e. the calliste is within a hardened clause).
-        // We can't terminate early in the negative case because the callsite could be nested
-        // in another EH region which may be hardened.
-        if (fCallsiteWithinCER == true)
-        {
-            return true;
-        }
-    }
-    
-    return false;
-}
-
-
-// Iterate through the body of the method looking for interesting call sites.
-void MethodCallGraphPreparer::LookForInterestingCallsites(MethodContext *pContext)
-{
-    STANDARD_VM_CONTRACT;
-
-    BYTE *pbIL = (BYTE*)m_pMethodDecoder->Code;
-    DWORD cbIL = m_pMethodDecoder->GetCodeSize();
-
-    while (cbIL) {
-
-        // Read the IL op.
-        DWORD dwOp = *pbIL++; cbIL--;
-
-        // Handle prefix codes (only CEE_PREFIX1 is legal so far).
-        if (dwOp == CEE_PREFIX1) {
-            if (!cbIL)
-                COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
-            dwOp = 256 + *pbIL++; cbIL--;
-        } else if (dwOp >= CEE_PREFIX7)
-            COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
-
-        // We're interested in NEWOBJ, JMP, CALL and CALLVIRT (can't trace through CALLI). We include CALLVIRT becase C#
-        // routinely calls non-virtual instance methods this way in order to get this pointer null checking. We prepare NEWOBJ
-        // because that covers the corner case of value types which can be constructed with no failure path.
-        if (dwOp == CEE_CALL || dwOp == CEE_CALLVIRT || dwOp == CEE_NEWOBJ || dwOp == CEE_JMP) {
-
-            if (cbIL < sizeof(DWORD))
-                COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
-
-            // Decode target method into MethodDesc and new SigTypeContext.
-            mdToken tkCallTarget = (mdToken)GET_UNALIGNED_VAL32(pbIL);
-            MethodContext *pCallTarget = TokenToMethodDesc(pContext->m_pMethodDesc->GetModule(), tkCallTarget, &pContext->m_sTypeContext);
-
-            // Check whether we've found a call to our own preparation marker method.
-            if (pCallTarget->m_pMethodDesc == g_pPrepareConstrainedRegionsMethod) {
-
-                if (ShouldGatherExplicitCERCallInfo()) {
-                    // If we're preparing a partial method these callsites are significant (we mark which EH clauses are now
-                    // 'activated' by proximity to this marker method call). Look for EH regions that are 'activated' by the call to
-                    // PrepareConstrainedRegions by comparing the IL offset of the start of the try to the offset immediately after
-                    // the callsite (remember to account for the rest of the CALLVIRT instruction we haven't skipped yet).
-                    MarkEHClauseActivatedByCERCall(pContext, pbIL, cbIL);
-                }
-
-                // Record the fact that we found a method in the CER which is the root of a sub-CER. This is important since the
-                // rude thread abort protection algorithm relies on root CER methods being marked as such.
-                pContext->m_fRoot = true;
-            }
-
-            // Determine if this was really a virtual call (we discard those since we can't reliably determine the call target).
-            bool fNonVirtualCall = dwOp == CEE_CALL || !pCallTarget->m_pMethodDesc->IsVirtual() || pCallTarget->m_pMethodDesc->IsFinal();
-
-            // When we're only processing qualified catch / finally handlers then we need to compute whether this call site
-            // lands in one of them.  The callsite is always within a cer if we are processing the full method.
-            // If we have stackoverflow probing on, also call to determine if the CER try or finally makes any calls
-            bool fCallsiteWithinCerInThisFunction = false;
-            if (!m_fEntireMethod || g_pConfig->ProbeForStackOverflow()) {
-                DWORD dwOffset = (DWORD)(SIZE_T)((pbIL - 1) - (BYTE*)m_pMethodDecoder->Code);
-                fCallsiteWithinCerInThisFunction = CheckIfCallsiteWithinCER(dwOffset);
-            }
-            bool fCallsiteWithinCer = m_fEntireMethod || fCallsiteWithinCerInThisFunction;
-
-            // Check for the presence of some sort of reliability contract (on the method, class or assembly). This will
-            // determine whether we log an error, ignore the method or treat it as part of the prepared call graph.
-            ReliabilityContractLevel eLevel = RCL_UNKNOWN;
-            if (fNonVirtualCall &&                          // Ignore virtual calls
-                fCallsiteWithinCer &&                       // And calls outside CERs
-                !m_sAlreadySeen.IsInStack(pCallTarget) &&     // And methods we've seen before
-                !m_sLeftToProcess.IsInStack(pCallTarget) &&   // And methods we've already queued for processing
-                (eLevel = CheckForReliabilityContract(pCallTarget->m_pMethodDesc)) >= RCL_PREPARE_CONTRACT) // And unreliable methods
-                m_sLeftToProcess.Push(pCallTarget);           // Otherwise add this method to the list to process
-            else if (fCallsiteWithinCer) { 
-#if defined(_DEBUG) || defined(MDA_SUPPORTED)
-                DWORD dwOffset = (DWORD)(SIZE_T)((pbIL - 1) - (BYTE*)m_pMethodDecoder->Code);
-#endif // defined(_DEBUG) || defined(MDA_SUPPORTED)
-                if (eLevel == RCL_NO_CONTRACT) {
-                    // Method was sufficiently unreliable for us to warn interested users that something may be amiss. Do this
-                    // through MDA logging.
-#ifdef MDA_SUPPORTED
-                    MDA_TRIGGER_ASSISTANT(InvalidCERCall, ReportViolation(pContext->m_pMethodDesc, pCallTarget->m_pMethodDesc, dwOffset));
-#endif
-                    CER_LOG(WARNINGS, ("CER: %s +%04X -> %s: weak contract\n", pContext->ToString(), dwOffset, pCallTarget->ToString()));
-                } else if (!fNonVirtualCall && !m_fIgnoreVirtualCERCallMDA) {
-                    // Warn users about virtual calls in CERs (so they can go back and consider which target methods need to be
-                    // prepared ahead of time).
-#ifdef MDA_SUPPORTED
-                    MDA_TRIGGER_ASSISTANT(VirtualCERCall, ReportViolation(pContext->m_pMethodDesc, pCallTarget->m_pMethodDesc, dwOffset));
-#endif
-                    CER_LOG(WARNINGS, ("CER: %s +%04X -> %s: virtual call\n", pContext->ToString(), dwOffset, pCallTarget->ToString()));
-                }
-            }
-        }
-
-        // Skip the rest of the current IL instruction. Look up the table built statically at the top of this module for most
-        // instructions, but CEE_SWITCH requires special processing (the length of that instruction depends on a count DWORD
-        // embedded right after the opcode).
-        if (dwOp == CEE_SWITCH) {
-            DWORD dwTargets = GET_UNALIGNED_VAL32(pbIL);
-            if (dwTargets >= (MAXDWORD / sizeof(DWORD)))
-                COMPlusThrowHR(COR_E_BADIMAGEFORMAT); // multiplication below would overflow
-            DWORD cbSwitch = (1 + dwTargets) * sizeof(DWORD);
-            if (cbIL < cbSwitch)
-                COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
-            pbIL += cbSwitch;
-            cbIL -= cbSwitch;
-        } else {
-            if (dwOp >= _countof(g_rOpArgs))
-                COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
-            DWORD cbOp = g_rOpArgs[dwOp];
-            if (cbIL < cbOp)
-                COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
-            pbIL += cbOp;
-            cbIL -= cbOp;
-        }
-
-    } // End of IL parsing loop
-}
-
-void MethodCallGraphPreparer::PrepareMethods()
-{
-    STANDARD_VM_CONTRACT;
-
-#ifdef _DEBUG
-    DWORD dwCount = 0;
-    if (GetCerLoggingOptions())
-    {
-        CER_LOG(PREPARE, ("---------------------------------------------------------------\n"));
-        SString ssMethod;
-        TypeString::AppendMethodInternal(ssMethod, m_pRootMD, TypeString::FormatNamespace | TypeString::FormatStubInfo);
-        CER_LOG(PREPARE, ("Preparing from %S\n", ssMethod.GetUnicode()));
-    }
-#endif
-
-    MethodContext      *pContext;               // The current MethodContext we're processing
-
-    while ((pContext = m_sAlreadySeen.Pop()) != NULL) {
-        MethodDesc *pMD = pContext->m_pMethodDesc;
-
-#ifndef CROSSGEN_COMPILE
-        // Jitting. Don't need to do this for the ngen case.
-#ifdef FEATURE_NATIVE_IMAGE_GENERATION
-        if (!m_fNgen)
-#endif
-        {
-            // Also skip the jit for the root method in the activated from jit case (where this would result in a recursive
-            // jit). We'd cope with this just fine, the main reason for this logic is to avoid unbalancing some profiler event
-            // counts that upset some of our test cases. This is safe in the face of multiple instantiations of the same method
-            // because in the jit activated case (where we're told the root type context is not exact) we early exit if the root
-            // method desc isn't 'unique' (i.e. independent of the type context).
-            if (m_fExactTypeContext || pMD != m_pRootMD) {
-
-                // Jit the method we traced.
-                if (pMD->IsPointingToPrestub())
-                {
-                    pMD->EnsureActive();
-                    pMD->DoPrestub(NULL);
-                }
-
-                // If we traced an instantiating stub we need to jit the wrapped (real) method as well.
-                if (pMD->IsInstantiatingStub()) {
-                    _ASSERTE(!pMD->ContainsGenericVariables());
-                    MethodDesc *pRealMD = pMD->GetWrappedMethodDesc();
-                    if (pRealMD->IsPointingToPrestub())
-                    {
-                        pMD->EnsureActive();
-                        pRealMD->DoPrestub(NULL);
-                    }
-                }
-            }
-
-            // Remember sub-CER root methods for further processing in RecordResults. We need to build CerPrepInfo structures for
-            // these just the same as top-level CERs since we may wander in to them by a route that doesn't include the top-level CER
-            // and the thread abort deflection algorithm relies on each CER root method being marked by a CerPrepInfo. Defer this
-            // processing to RecordResults since we aren't guaranteed to have prepared all the methods of the sub-graph at this
-            // point.
-            if (pContext->m_fRoot && pMD != m_pRootMD)
-                m_sPersist.Push(pContext);
-        }
-#endif // CROSSGEN_COMPILE
-
-        // Prepare generic dictionaries (both class and method as needed). We do this even in the ngen scenario, trying to get
-        // as many slots filled as possible. By the looks of it, it's possible that not all of these entries will make it across
-        // to runtime (the fixup code seems to give up on some of the more complex entries, not sure of the details). But we'll
-        // do as best we can here to hopefully minimize any real work on the other side.
-
-        // Don't use the direct PrepopulateDictionary method on MethodTable here, it takes binding considerations into account
-        // (which we don't care about).
-        DictionaryLayout *pClassDictLayout = pMD->GetClass()->GetDictionaryLayout();
-        if (pClassDictLayout) {
-            // Translate the representative method table we can find from our method desc into an exact instantiation using the
-            // type context we have.
-            MethodTable *pMT = TypeHandle(pMD->GetMethodTable()).Instantiate(pContext->m_sTypeContext.m_classInst).AsMethodTable();
-
-            pMT->GetDictionary()->PrepopulateDictionary(NULL, pMT, false);
-
-            // The dictionary may have overflowed in which case we need to prepopulate the jit's lookup cache as well.
-            PrepopulateGenericHandleCache(pClassDictLayout, NULL, pMT);
-        }
-
-        // Don't use the direct PrepopulateDictionary method on MethodDesc here, it appears to use a representative class
-        // instantiation (and we have the exact one handy).
-        DictionaryLayout *pMethDictLayout = pMD->GetDictionaryLayout();
-        if (pMethDictLayout) {
-            pMD->GetMethodDictionary()->PrepopulateDictionary(pMD, NULL, false);
-
-            // The dictionary may have overflowed in which case we need to prepopulate the jit's lookup cache as well.
-            PrepopulateGenericHandleCache(pMethDictLayout, pMD, NULL);
-        }
-
-#ifdef FEATURE_NATIVE_IMAGE_GENERATION
-        // Keep some of the method contexts around for the ngen case (the ones that might still need fixup at runtime). We'll
-        // write them into a persisted data structure in the next step.
-        // @todo: We use a horrible workaround here to get round the fact that while ngen'ing mscorlib we may prepare some of its
-        // methods before we've had a chance to start up the compilation domain (mscorlib code is shared and used by the ngen
-        // process itself). So we can't blindly call NeedsRestore() on an mscorlib method since that code asserts we're in the
-        // compilation domain. Instead, if we're in the ngen process and we're outside the compilation domain we're going to
-        // assume that the method doesn't need restoration. This only affects a handful of methods (six at last count, all to do
-        // with security safe handles or some CERs in remoting).
-        if (m_fNgen) {
-            if (GetAppDomain() == NULL ||
-                !GetAppDomain()->IsCompilationDomain() ||
-                !(GetAppDomain()->ToCompilationDomain()->canCallNeedsRestore()) ||
-                !(GetAppDomain()->ToCompilationDomain()->GetTargetImage()->CanPrerestoreEagerBindToMethodDesc(pMD, NULL))||
-                pMD->HasClassOrMethodInstantiation() ||
-                pMD->IsNDirect() ||
-                pMD->IsComPlusCall() ||
-                pMD->IsFCall() ||
-                pContext->m_fRoot)
-                m_sPersist.Push(pContext);
-        }
-#endif
-
-#ifdef _DEBUG
-        CER_LOG(PREPARE, ("  %s\n", pContext->ToString()));
-        dwCount++;
-#endif
-    }
-
-#ifdef _DEBUG
-    CER_LOG(PREPARE, ("Prepared a total of %u methods\n", dwCount));
-#ifdef FEATURE_NATIVE_IMAGE_GENERATION
-    if (m_fNgen)
-        CER_LOG(PREPARE, ("Saved data for %u of them in the ngen image\n", m_sPersist.GetCount()));
-#endif
-    CER_LOG(PREPARE, ("---------------------------------------------------------------\n"));
-#endif
-}
-
-// Common code used in creating/looking up a CerPrepInfo and initializing/updating it.
-void InitPrepInfo(MethodDesc *pMD, SigTypeContext *pTypeContext, bool fMethodHasCallsWithinExplicitCer)
-{
-    CONTRACTL {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pMD));
-    } CONTRACTL_END;
-
-    // Lookup or allocate the CerPrepInfo.
-    CerPrepInfo *pInfo = pMD->GetModule()->CreateCerPrepInfo(pMD);
-
-    pInfo->m_fMethodHasCallsWithinExplicitCer = fMethodHasCallsWithinExplicitCer;
-
-    // Work out if this was a partial preparation.
-    bool fPartialPreparation = pMD->IsSharedByGenericInstantiations() ||
-                               pMD->IsInstantiatingStub() ||
-                               pMD->ContainsGenericVariables();
-
-    // Simple case first: if this isn't a partial preparation (no pesky unbound type vars to worry about), then the method is
-    // now fully prepared.
-    if (!fPartialPreparation) {
-        pInfo->m_fFullyPrepared = true;
-        return;
-    }
-
-    // Else we know we require per-instantiation initialization. We need to update a hash table to record the preparation we did
-    // in this case, and that requires taking a mutex. We could check that nobody beat us to it first, but that will hardly ever
-    // happen, so it's not really worth it. So just acquire the mutex right away.
-    CrstHolder sHolder(pMD->GetModule()->GetCerCrst());
-
-    pInfo->m_fRequiresInstantiation = true;
-
-    // Add an entry to a hash that records which instantiations we've prep'd for (again, only if someone hasn't beaten us).
-    HashDatum sDatum;
-    if (!pInfo->m_sIsInitAtInstHash.GetValue(pTypeContext, &sDatum))
-    {
-        pInfo->m_sIsInitAtInstHash.InsertKeyAsValue(pTypeContext);
-    }
-}
-
-bool  MethodCallGraphPreparer::RecordResults()
-{
-    STANDARD_VM_CONTRACT;
-
-    // Preparation has been successful, record what we've done in a manner consistent with whether we're ngen'ing or running for
-    // real.
-
-#ifdef FEATURE_NATIVE_IMAGE_GENERATION
-    // If we're ngen'ing an image we save our progess as a list of method contexts that might need restoration at runtime (since
-    // even with prejitting there are some things that need to be prepared at runtime). This list goes into a per module table (the
-    // module in question being that of the root method in the CER).
-    if (m_fNgen) {
-
-        // We have the list of MethodContexts ready, but they're in cheap storage that will go away once we exit this method.
-        // Not only do we have to copy them to heap memory, but we also know exactly how many there are. So we can allocate a
-        // single array with a more compact form of MethodContext for each element. We allocate an extra sentinel value for the end
-        // of the list. This means we can store just a pointer to the list without a count (the code that accesses this list cares
-        // about keeping the list heads compact and densely packed and doesn't care about counting the elements in the list).
-        DWORD cContexts = m_sPersist.GetCount();
-        LoaderHeap *pHeap = m_pRootMD->GetAssembly()->GetLowFrequencyHeap();
-        MethodContextElement *pContexts = (MethodContextElement*)(void*)pHeap->AllocMem(S_SIZE_T(sizeof(MethodContextElement)) * (S_SIZE_T(cContexts) + S_SIZE_T(1)));
-        DWORD i = 0;
-
-        MethodContext      *pContext;               // The current MethodContext we're processing
-        while ((pContext = m_sPersist.Pop()) != NULL) {
-            pContexts[i].m_pMethodDesc.SetValue(pContext->m_pMethodDesc);
-
-            MethodTable * pExactMT = NULL;
-            if (!pContext->m_sTypeContext.m_classInst.IsEmpty())
-            {
-                pExactMT = TypeHandle(pContext->m_pMethodDesc->GetMethodTable()).Instantiate(pContext->m_sTypeContext.m_classInst).AsMethodTable();
-                _ASSERTE(pExactMT->HasInstantiation());
-            }
-            else
-            {
-                _ASSERTE(!pContext->m_pMethodDesc->GetMethodTable()->HasInstantiation());
-            }
-            pContexts[i].m_pExactMT.SetValue(pExactMT);
-
-            i++;
-
-            // Keep the context round for a little longer if the method in question was the root of a sub-CER.
-            if (pContext->m_fRoot)
-                m_sRootMethods.Push(pContext);
-        }
-
-        // Write sentinel entry terminating list.
-        _ASSERTE(i == cContexts);
-
-        // Add list representing this CER to the per-module table (keyed by root method desc).
-        m_pRootMD->GetModule()->AddCerListToRootTable(m_pRootMD, pContexts);
-
-        // If this did have an call from an explicit PCER range, create a PrepInfo for it so that we can
-        // quickly grab that information later when we jit that method.  This allows us to optimize the probe
-        // away if there are no calls from the PCER range.  This is an issue when we've prepared a method
-        // as part of a CER call from another method, but haven't ngened that method yet.  When we get
-        // around to finally ngening that method, we want to be able to optimize the CER probe out if
-        // we can, but don't want to reprepare the method.
-        if (g_pConfig->ProbeForStackOverflow() && m_fMethodHasCallsWithinExplicitCer)
-        {
-            if (m_pCerPrepInfo == NULL)
-                m_pCerPrepInfo = m_pRootMD->GetModule()->CreateCerPrepInfo(m_pRootMD);
-            m_pCerPrepInfo->m_fMethodHasCallsWithinExplicitCer = TRUE;
-        }
-
-
-        // We need to be careful with sub-CERs in the ngen case. In the jit case they're dealt with automatically (preparing a
-        // super-CER always completely prepares a sub-CER). But in the ngen case we potentially need to run further preparation
-        // steps at the point that a CER root is executed for the first time. If the sub-root is encountered before the super-root
-        // then the sub-CER won't have been prepared correctly.
-        // We solve this simply by recursively running this routine over the methods we noted were sub-roots earlier (this list
-        // doesn't include the main root). We could potentially do a little better than this given that we've calculated the
-        // super-graph, but this is complicated somewhat by the fact that we don't retain the graph structure (i.e. we can't extract
-        // sub-graphs easily) and the effort seems wasted just to avoid a little CPU time and stack space just for the ngen creation
-        // scenario.
-        while ((pContext = m_sRootMethods.Pop()) != NULL)
-        {
-            MethodCallGraphPreparer mgcp(pContext->m_pMethodDesc, &pContext->m_sTypeContext, false, false);
-            mgcp.Run();
-        }
-
-        return m_fMethodHasCallsWithinExplicitCer;
-    }
-#endif // FEATURE_NATIVE_IMAGE_GENERATION
-
-    // This is the runtime (non-ngen case). Record our progress in an info structure placed in a hash table hung off the module
-    // which owns the root method desc in the CER. The methods which create this info structure handle race conditions (to
-    // ensure we don't leak memory or data), but the updates to the info structure itself might not require any serialization
-    // (the values are 'latched' -- recomputation should yield the same result). The exception is any update to a more complex
-    // data fields (lists and hash tables) that require serialization to prevent corruption of the basic data structure.
-
-    // Process sub-CER roots first. We need to build CerPrepInfo structures for these just as same as top-level CERs since we may
-    // wander in to them by a route that doesn't include the top-level CER and the thread abort deflection algorithm relies on each
-    // CER root method being marked by a CerPrepInfo.
-    MethodContext *pContext;
-    while ((pContext = m_sPersist.Pop()) != NULL) {
-        _ASSERTE(pContext->m_fRoot);
-
-        // @todo: need to flow fMethodHasCallsWithinExplicitCer information through method contexts. For now just make a
-        // conservative, safe choice.
-        InitPrepInfo(pContext->m_pMethodDesc, &pContext->m_sTypeContext, true);
-    }
-
-    // Now process the top-level CER.
-    InitPrepInfo(m_pRootMD, m_pRootTypeContext, m_fMethodHasCallsWithinExplicitCer);
-
-    return m_fMethodHasCallsWithinExplicitCer;
-}
-
-// Determines whether the given method contains a CER root that can be pre-prepared (i.e. prepared at jit time).
-bool ContainsPrePreparableCerRoot(MethodDesc *pMD)
-{
-    CONTRACTL {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pMD));
-    } CONTRACTL_END;
-
-    // Deal with exotic cases (non-IL methods and the like).
-    if (!pMD->IsIL() || pMD->IsAbstract())
-        return false;
-
-    // And cases where we can't jit prepare (because the code is shared between instantiations).
-    if (pMD->IsSharedByGenericInstantiations() || pMD->IsInstantiatingStub() || pMD->ContainsGenericVariables())
-        return false;
-
-    // Otherwise we have a trickier calculation. We don't want to force the jit of the method at this point (may cause infinite
-    // recursion problems when we're called from the jit in the presence of call cycles). Instead we walk the top-level of the
-    // method IL using the same algorithm as PrepareMethodCallGraph.
-
-    // Locate the IL body of the current method. May have to account for the fact that the current method desc is an
-    // instantiating stub and burrow down for the real method desc.
-    MethodDesc *pRealMethod = pMD;
-    if (pRealMethod->IsInstantiatingStub()) {
-        _ASSERTE(!pRealMethod->ContainsGenericVariables());
-        pRealMethod = pRealMethod->GetWrappedMethodDesc();
-    }
-    COR_ILMETHOD_DECODER method(pRealMethod->GetILHeader());
-    BYTE *pbIL = (BYTE*)method.Code;
-    DWORD cbIL = method.GetCodeSize();
-
-    // Look for exception handling information for the method. If there isn't any then we know there can't be a CER rooted here.
-    COR_ILMETHOD_SECT_EH const * pEH = method.EH;
-    if (pEH == NULL || pEH->EHCount() == 0)
-        return false;
-
-    // Iterate through the body of the method looking for interesting call sites.
-    while (cbIL) {
-
-        // Read the IL op.
-        DWORD dwOp = *pbIL++; cbIL--;
-
-        // Handle prefix codes (only CEE_PREFIX1 is legal so far).
-        if (dwOp == CEE_PREFIX1) {
-            if (!cbIL)
-                COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
-            dwOp = 256 + *pbIL++; cbIL--;
-            if (dwOp >= CEE_ILLEGAL)
-                COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
-        } else if (dwOp >= CEE_PREFIX7)
-            COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
-
-        // We'll only ever see CALL instructions targeting PrepareConstrainedRegions (well those are the ones we're interested in
-        // anyway).
-        if (dwOp == CEE_CALL)
-        {
-            if (cbIL < sizeof(DWORD))
-                COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
-            if (IsPcrReference(pMD->GetModule(), (mdToken)GET_UNALIGNED_VAL32(pbIL)))
-                return true;
-        }
-
-        // Skip the rest of the current IL instruction. Look up the table built statically at the top of this module for most
-        // instructions, but CEE_SWITCH requires special processing (the length of that instruction depends on a count DWORD
-        // embedded right after the opcode).
-        if (dwOp == CEE_SWITCH) {
-            if (cbIL < sizeof(DWORD))
-                COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
-            DWORD dwTargets = GET_UNALIGNED_VAL32(pbIL);
-            if (dwTargets >= (MAXDWORD / sizeof(DWORD)))
-                COMPlusThrowHR(COR_E_BADIMAGEFORMAT); // multiplication below would overflow
-            DWORD cbSwitch = (1 + dwTargets) * sizeof(DWORD);
-            if (cbIL < cbSwitch)
-                COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
-            pbIL += cbSwitch;
-            cbIL -= cbSwitch;
-        } else {
-            if (dwOp >= _countof(g_rOpArgs))
-                COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
-            DWORD cbOp = g_rOpArgs[dwOp];
-            if (cbIL < cbOp)
-                COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
-            pbIL += cbOp;
-            cbIL -= cbOp;
-        }
-
-    } // End of IL parsing loop
-
-    // If we get here then there was no CER-root.
-    return false;
-}
-
-// The name of the PrepareConstrainedRegions method, broken down into its components (the code below scans for these directly in the
-// metadata).
-#define PCR_METHOD      "PrepareConstrainedRegions"
-#define PCR_TYPE        "RuntimeHelpers"
-#define PCR_NAMESPACE   "System.Runtime.CompilerServices"
-
-// Given a token and a module scoping it, determine if that token is a reference to PrepareConstrainedRegions. We want to do this
-// without loading any random types since we're called in a context where type loading is prohibited.
-bool IsPcrReference(Module *pModule, mdToken tkMethod)
-{
-    CONTRACTL {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pModule));
-    } CONTRACTL_END;
-
-    IMDInternalImport *pImport = pModule->GetMDImport();
-
-    // Validate that the token is one that we can handle.
-    if (!pImport->IsValidToken(tkMethod) || (TypeFromToken(tkMethod) != mdtMethodDef &&
-                                             TypeFromToken(tkMethod) != mdtMethodSpec &&
-                                             TypeFromToken(tkMethod) != mdtMemberRef))
-        COMPlusThrowHR(COR_E_BADIMAGEFORMAT, BFA_INVALID_METHOD_TOKEN);
-
-    // No reason to see a method spec for a call to something as simple as PrepareConstrainedRegions.
-    if (TypeFromToken(tkMethod) == mdtMethodSpec)
-        return false;
-
-    // If it's a method def then the module had better be mscorlib.
-    if (TypeFromToken(tkMethod) == mdtMethodDef) {
-        if (pModule->GetAssembly()->GetManifestModule() == SystemDomain::SystemAssembly()->GetManifestModule())
-            return tkMethod == g_pPrepareConstrainedRegionsMethod->GetMemberDef();
-        else
-            return false;
-    }
-
-    // That leaves the cross module reference case.
-    _ASSERTE(TypeFromToken(tkMethod) == mdtMemberRef);
-
-    // First get the method name and signature and validate it.
-    PCCOR_SIGNATURE pSig;
-    DWORD cbSig;
-    LPCSTR szMethod;
-    IfFailThrow(pImport->GetNameAndSigOfMemberRef(tkMethod, &pSig, &cbSig, &szMethod));
-    
-    {
-        SigParser sig(pSig, cbSig);
-        ULONG nCallingConvention;
-        ULONG nArgumentsCount;
-        BYTE  bReturnType;
-        
-        // Signature is easy: void PCR().
-        // Must be a static method signature.
-        if (FAILED(sig.GetCallingConvInfo(&nCallingConvention)))
-            return false;
-        if (nCallingConvention != IMAGE_CEE_CS_CALLCONV_DEFAULT)
-            return false;
-        // With no arguments.
-        if (FAILED(sig.GetData(&nArgumentsCount)))
-            return false;
-        if (nArgumentsCount != 0)
-            return false;
-        // And a void return type.
-        if (FAILED(sig.GetByte(&bReturnType)))
-            return false;
-        if (bReturnType != (BYTE)ELEMENT_TYPE_VOID)
-            return false;
-    }
-
-    // Validate the name.
-    if (strcmp(szMethod, PCR_METHOD) != 0)
-        return false;
-
-    // The method looks OK, move up to the type and validate that.
-    mdToken tkType;
-    IfFailThrow(pImport->GetParentOfMemberRef(tkMethod, &tkType));
-    
-    if (!pImport->IsValidToken(tkType))
-        COMPlusThrowHR(COR_E_BADIMAGEFORMAT, BFA_INVALID_TOKEN);
-    
-    // If the parent is not a type ref then this isn't our target (we assume that mscorlib never uses a member ref to target
-    // PrepareConstrainedRegions, check that with the assert below, if it ever fails we need to add some additional logic below).
-    _ASSERTE(TypeFromToken(tkType) != mdtTypeDef ||
-             pModule->GetAssembly()->GetManifestModule() != SystemDomain::SystemAssembly()->GetManifestModule());
-    if (TypeFromToken(tkType) != mdtTypeRef)
-        return false;
-
-    // Get the type name and validate it.
-    LPCSTR szNamespace;
-    LPCSTR szType;
-    IfFailThrow(pImport->GetNameOfTypeRef(tkType, &szNamespace, &szType));
-    
-    if (strcmp(szType, PCR_TYPE) != 0)
-        return false;
-    if (strcmp(szNamespace, PCR_NAMESPACE) != 0)
-        return false;
-    
-    // Type is OK as well. Check the assembly reference.
-    mdToken tkScope;
-    IfFailThrow(pImport->GetResolutionScopeOfTypeRef(tkType, &tkScope));
-    
-    if (TypeFromToken(tkScope) != mdtAssemblyRef)
-        return false;
-    if (!pImport->IsValidToken(tkScope))
-    {
-        COMPlusThrowHR(COR_E_BADIMAGEFORMAT, BFA_INVALID_TOKEN);
-    }
-    
-    // Fetch the name and public key or public key token.
-    BYTE *pbPublicKeyOrToken;
-    DWORD cbPublicKeyOrToken;
-    LPCSTR szAssembly;
-    DWORD dwAssemblyFlags;
-    IfFailThrow(pImport->GetAssemblyRefProps(
-        tkScope, 
-        (const void**)&pbPublicKeyOrToken, 
-        &cbPublicKeyOrToken, 
-        &szAssembly, 
-        NULL,   // AssemblyMetaDataInternal: we don't care about version, culture etc.
-        NULL,   // Hash value pointer, obsolete information
-        NULL,   // Byte count for above
-        &dwAssemblyFlags));
-    
-    // Validate the name.
-    if (stricmpUTF8(szAssembly, g_psBaseLibraryName) != 0)
-        return false;
-    
-    // And the public key or token, which ever was burned into the reference by the compiler. For mscorlib this is the ECMA key or
-    // token.
-    if (IsAfPublicKeyToken(dwAssemblyFlags)) {
-        if (cbPublicKeyOrToken != sizeof(g_rbNeutralPublicKeyToken) ||
-            memcmp(pbPublicKeyOrToken, g_rbNeutralPublicKeyToken, cbPublicKeyOrToken) != 0)
-            return false;
-    } else {
-        if (cbPublicKeyOrToken != sizeof(g_rbNeutralPublicKey) ||
-            memcmp(pbPublicKeyOrToken, g_rbNeutralPublicKey, cbPublicKeyOrToken) != 0)
-            return false;
-    }
-
-    // If we get here we've finally proved the call target was indeed PrepareConstrainedRegions. Whew.
-    return true;
-}
-
-// Prepares a method as a CER root. In some scenarios we set
-// fIgnoreVirtualCERCallMDA=TRUE, this happens when we want to ignore firing a
-// VirtualCERCall MDA because we know for sure that the virtual methods are
-// already prepared. A good example of this case is preparing
-// g_pExecuteBackoutCodeHelperMethod method. 
-void PrepareMethodDesc(MethodDesc* pMD, Instantiation classInst, Instantiation methodInst, BOOL onlyContractedMethod, BOOL fIgnoreVirtualCERCallMDA)
-{
-     CONTRACTL 
-     {
-        THROWS;
-        DISABLED(GC_TRIGGERS);
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    GCX_PREEMP();
-
-#ifdef FEATURE_PREJIT
-    // This method may have some ngen fixup information provided, in which case we just check that it's been restored and can
-    // dispense with the preparation altogether.
-    Module *pModule = pMD->GetModule();
-    if (pModule->IsNgenCerRootMethod(pMD))
-    {
-        pMD->CheckRestore();
-        pModule->RestoreCer(pMD);
-        return;
-    }
-#endif
-
-    // If we are only going to prepare contracted methods and this method does
-    // not have a contract then we just return.
-    if (onlyContractedMethod && CheckForReliabilityContract(pMD) < RCL_BASIC_CONTRACT)
-    {
-        return;
-    }
-
-    SigTypeContext sTypeContext(pMD, classInst, methodInst);
-    MethodCallGraphPreparer mcgp(pMD, &sTypeContext, true, true, fIgnoreVirtualCERCallMDA == TRUE);
-    mcgp.Run();
-}
-
-// Prepares the critical finalizer call graph for the given object type (which
-// must derive from CriticalFinalizerObject). This involves preparing at least
-// the finalizer method and possibly some others (for SafeHandle and
-// CriticalHandle derivations). If a module pointer is supplied then only the
-// critical methods introduced in that module are prepared (this is used at
-// ngen time to ensure that we're only generating ngen preparation info for the
-// targetted module). 
-void PrepareCriticalFinalizerObject(MethodTable *pMT, Module *pModule)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pMT));
-    } CONTRACTL_END;
-
-    // Have we prepared this type before?
-    if (pMT->CriticalTypeHasBeenPrepared())
-        return;
-
-    GCX_PREEMP();
-
-    // Restore the method table if necessary.
-    pMT->CheckRestore();
-
-    // Determine the interesting parent class (either SafeHandle, CriticalHandle or CriticalFinalizerObject).
-    MethodTable *pSafeHandleClass = MscorlibBinder::GetClass(CLASS__SAFE_HANDLE);
-    MethodTable *pCriticalHandleClass = MscorlibBinder::GetClass(CLASS__CRITICAL_HANDLE);
-    MethodTable *pParent = pMT;
-    while (pParent) {
-        if (pParent == g_pCriticalFinalizerObjectClass ||
-            pParent == pSafeHandleClass ||
-            pParent == pCriticalHandleClass) {
-            break;
-        }
-        pParent = pParent->GetParentMethodTable();
-    }
-    _ASSERTE(pParent != NULL);
-
-    BinderMethodID rgMethods[5];
-    int nMethods;
-
-    // Prepare the method or methods based on the parent class.
-    if (pParent == pSafeHandleClass) {
-        rgMethods[0] = METHOD__CRITICAL_FINALIZER_OBJECT__FINALIZE;
-        rgMethods[1] = METHOD__SAFE_HANDLE__RELEASE_HANDLE;
-        rgMethods[2] = METHOD__SAFE_HANDLE__GET_IS_INVALID;
-        rgMethods[3] = METHOD__SAFE_HANDLE__DISPOSE;
-        rgMethods[4] = METHOD__SAFE_HANDLE__DISPOSE_BOOL;
-        nMethods = 5;
-    } else if (pParent == pCriticalHandleClass) {
-        rgMethods[0] = METHOD__CRITICAL_FINALIZER_OBJECT__FINALIZE;
-        rgMethods[1] = METHOD__CRITICAL_HANDLE__RELEASE_HANDLE;
-        rgMethods[2] = METHOD__CRITICAL_HANDLE__GET_IS_INVALID;
-        rgMethods[3] = METHOD__CRITICAL_HANDLE__DISPOSE;
-        rgMethods[4] = METHOD__CRITICAL_HANDLE__DISPOSE_BOOL;
-        nMethods = 5;
-    } else {
-        _ASSERTE(pParent == g_pCriticalFinalizerObjectClass);
-        rgMethods[0] = METHOD__CRITICAL_FINALIZER_OBJECT__FINALIZE;
-        nMethods = 1;
-    }
-
-    for (int iMethod = 0; iMethod < nMethods; iMethod++)
-    {
-        // Prepare a (possibly virtual) method on an instance. The method is identified via a binder ID, so the initial
-        // declaration of the method must reside within mscorlib. We might have ngen fixup information for the method and can avoid direct
-        // preparation as well.
-
-        MethodDesc *pPrepMethod = pMT->GetMethodDescForSlot(MscorlibBinder::GetMethod(rgMethods[iMethod])->GetSlot());
-#ifdef FEATURE_PREJIT
-        if (pPrepMethod->GetModule()->IsNgenCerRootMethod(pPrepMethod)) {
-            pPrepMethod->GetModule()->RestoreCer(pPrepMethod);
-        }
-        else
-        if (IsCompilationProcess() && pPrepMethod->IsAbstract()) {
-            // Skip abstract methods during NGen (we should not ever get abstract methods here at runtime)
-        }
-        else
-#endif
-        {
-            if (pModule == NULL || pPrepMethod->GetModule() == pModule) {
-                SigTypeContext _sTypeContext(pPrepMethod, TypeHandle(pMT));
-                MethodCallGraphPreparer mcgp(pPrepMethod, &_sTypeContext, true, true);
-                mcgp.Run();
-            }
-        }
-    }
-
-    // Note the fact that we've prepared this type before to prevent repetition of the work above. (Though repetition is harmless in
-    // all other respects, so there's no need to worry about the race setting this flag).
-    pMT->SetCriticalTypeHasBeenPrepared();
-}
-
-#ifdef _DEBUG
-
-static const char * const g_rszContractNames[] = { "RCL_NO_CONTRACT", "RCL_BASIC_CONTRACT", "RCL_PREPARE_CONTRACT" };
-static DWORD g_dwContractChecks = 0;
-
-#define ReturnContractLevel(_level) do {                                                        \
-    g_dwContractChecks++;                                                                       \
-    if ((g_dwContractChecks % 100) == 0 && g_pMethodContractCache)                              \
-        g_pMethodContractCache->DbgDumpStats();                                                 \
-    ReliabilityContractLevel __level = (_level);                                                \
-    CER_LOG(CONTRACTS, ("%s -- %s\n", pMD->m_pszDebugMethodName, g_rszContractNames[__level])); \
-    return __level;                                                                             \
-} while (false)
-#else
-#define ReturnContractLevel(_level) return (_level)
-#endif
-
-// Look for reliability contracts at the method, class and assembly level and parse them to extract the information we're interested
-// in from a runtime preparation viewpoint. This information is abstracted in the form of the ReliabilityContractLevel enumeration.
-ReliabilityContractLevel CheckForReliabilityContract(MethodDesc *pMD)
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pMD));
-    } CONTRACTL_END;
-
-    // We are attempting to abstract reliability contracts for the given method into three different buckets: those methods that
-    // will cause an error (or a MDA report at least) during preparation (RCL_NO_CONTRACT), those we allow but don't prepare
-    // (RCL_BASIC_CONTRACT) and those we allow and prepare (RCL_PREPARE_CONTRACT).
-    //
-    // We place methods into the first bucket below that matches:
-    //  RCL_NO_CONTRACT      --  Methods with no consistency or whose consistency states they may corrupt the appdomain or process.
-    //  RCL_BASIC_CONTRACT   --  Methods that state CER.None (or don't specify a CER attribute)
-    //  RCL_PREPARE_CONTRACT --  Methods that state CER.MayFail or CER.Success
-    //
-    // We look for reliability contracts at three levels: method, class and assembly. Definitions found at the method level override
-    // those at the class and assembly level and those at the class level override assembly settings.
-    //
-    // In the interests of efficiency we cache contract information in a number of ways. Firstly we look at a hash of recently
-    // queried MethodDescs. This contains authoritative answers (assembly/class/method information has already been composed so on a
-    // hit we don't need to look anywhere else). This cache is allocated lazily, never grows (newer items eventually displace older
-    // ones), is global, requires no locks and is never freed. The idea is to limit the amount of working set we ever occupy while
-    // keeping the CPU usage as low as possible. Typical usages of this method involve querying a small number of methods in a stack
-    // walk, possibly multiple times, so a small hash cache should work reasonably well here.
-    //
-    // On a miss we're going to have to bite the bullet and look at the assembly, class and method. The assembly and class cache
-    // this information at load (ngen) time though, so they're not so expensive (class level data is cached on the EEClass, so it's
-    // cold data, but the most performance sensitive scenario in which we're called here, ThreadAbort, isn't all that hot).
-
-    // Check the cache first, it contains a raw contract level.
-    ReliabilityContractLevel eLevel;
-    if (g_pMethodContractCache && g_pMethodContractCache->Lookup(pMD, (DWORD*)&eLevel))
-        ReturnContractLevel(eLevel);
-
-    // Start at the method level and work up until we've found enough information to make a decision. The contract level is composed
-    // in an encoded DWORD form that lets us track both parts of the state (consistency and cer) and whether each has been supplied
-    // yet. See the RC_* macros for encoding details.
-    DWORD dwMethodContractInfo = GetReliabilityContract(pMD->GetMDImport(), pMD->GetMemberDef());
-    if (RC_INCOMPLETE(dwMethodContractInfo)) {
-        DWORD dwClassContractInfo = pMD->GetClass()->GetReliabilityContract();
-        dwMethodContractInfo = RC_MERGE(dwMethodContractInfo, dwClassContractInfo);
-        if (RC_INCOMPLETE(dwMethodContractInfo)) {
-            DWORD dwAssemblyContractInfo = pMD->GetModule()->GetReliabilityContract();
-            dwMethodContractInfo = RC_MERGE(dwMethodContractInfo, dwAssemblyContractInfo);
-        }
-    }
-
-    // We've got an answer, so attempt to cache it for the next time.
-
-    // First check we have a cache (we allocate it lazily).
-    if (g_pMethodContractCache == NULL) {
-        PtrHashCache *pCache = new (nothrow) PtrHashCache();
-        if (pCache)
-            if (FastInterlockCompareExchangePointer(&g_pMethodContractCache, pCache, NULL) != NULL)
-                delete pCache;
-    }
-
-    // We still might not have a cache in low memory situations. That's OK.
-    if (g_pMethodContractCache)
-        g_pMethodContractCache->Add(pMD, RC_ENCODED_TO_LEVEL(dwMethodContractInfo));
-
-    ReturnContractLevel(RC_ENCODED_TO_LEVEL(dwMethodContractInfo));
-}
-
-
-// Macro used to handle failures in the routine below.
-#define IfFailRetRcNull(_hr) do { if (FAILED(_hr)) return RC_NULL; } while (false)
-
-// Look for a reliability contract attached to the given metadata token in the given scope. Return the result as an encoded DWORD
-// (see the RC_ENCODE macro).
-DWORD GetReliabilityContract(IMDInternalImport *pImport, mdToken tkParent)
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pImport));
-    } CONTRACTL_END;
-
-    HRESULT hr;
-    DWORD   dwResult = RC_NULL;
-
-    // Sadly we only have two unmanaged APIs available to us for looking at custom attributes. One looks up attributes by name but
-    // only returns the byte blob, not the attribute ctor information (which we need to parse the blob) while the other returns
-    // everything but requires us to enumerate all attributes on a given token looking for the one we're interested in. To keep the
-    // cost down we probe for the existence of the attribute using the first API and then use the enumeration method if we get a
-    // hit.
-    hr = pImport->GetCustomAttributeByName(tkParent, RELIABILITY_CONTRACT_NAME, NULL, NULL);
-    if (hr == S_FALSE)
-        return RC_NULL;
-
-    IfFailRetRcNull(hr);
-
-    // Got at least one contract against this parent. Enumerate them all (filtering by name).
-    MDEnumHolder hEnum(pImport);
-    hr = pImport->SafeAndSlowEnumCustomAttributeByNameInit(tkParent, RELIABILITY_CONTRACT_NAME, &hEnum);
-    _ASSERTE(hr != S_FALSE);
-    IfFailRetRcNull(hr);
-
-    // Enumerate over all the contracts.
-    mdToken tkContract;
-    while (S_OK == pImport->SafeAndSlowEnumCustomAttributeByNameNext(tkParent, RELIABILITY_CONTRACT_NAME, &hEnum, &tkContract)) {
-
-        // Get the attribute type (token of the ctor used) since we need this information in order to parse the blob we'll find
-        // next.
-        mdToken tkAttrType;
-        IfFailRetRcNull(pImport->GetCustomAttributeProps(tkContract, &tkAttrType));
-        if (!pImport->IsValidToken(tkAttrType))
-            continue;
-
-        // The token should be a member ref or method def.
-        // Get the signature of the ctor so we know which version has been called.
-        PCCOR_SIGNATURE pSig;
-        DWORD           cbSig;
-        LPCSTR          szName_Ignore;
-        if (TypeFromToken(tkAttrType) == mdtMemberRef)
-        {
-            IfFailRetRcNull(pImport->GetNameAndSigOfMemberRef(tkAttrType, &pSig, &cbSig, &szName_Ignore));
-        }
-        else
-        {
-            if (TypeFromToken(tkAttrType) != mdtMethodDef)
-                continue;
-            IfFailRetRcNull(pImport->GetNameAndSigOfMethodDef(tkAttrType, &pSig, &cbSig, &szName_Ignore));
-        }
-
-        // Only two signatures are supported: the null sig '()' and the full sig '(Consistency, CER)'.
-        // Set a boolean based on which one was provided.
-        bool                    fNullCtor;
-        ULONG                   eCallConv;
-
-        SigPointer sig(pSig, cbSig);
-
-        // Check the calling convention is what we expect (default convention on an instance method).
-        IfFailRetRcNull(sig.GetCallingConvInfo(&eCallConv));
-        _ASSERTE(eCallConv == (IMAGE_CEE_CS_CALLCONV_DEFAULT | IMAGE_CEE_CS_CALLCONV_HASTHIS));
-        if (eCallConv != (IMAGE_CEE_CS_CALLCONV_DEFAULT | IMAGE_CEE_CS_CALLCONV_HASTHIS))
-            IfFailRetRcNull(COR_E_BADIMAGEFORMAT);
-
-        // If so, the next datum is the count of arguments, and this is all we need to determine which ctor has been used.
-        ULONG dwArgs;
-        IfFailRetRcNull(sig.GetData(&dwArgs));
-        _ASSERTE(dwArgs == 0 || dwArgs == 2);
-        if (dwArgs != 0 && dwArgs != 2)
-            IfFailRetRcNull(COR_E_BADIMAGEFORMAT);
-
-        fNullCtor = dwArgs == 0;
-
-        // Now we know how to parse the blob, let's fetch a pointer to it.
-        BYTE const *pbData;
-        DWORD       cbData;
-        IfFailRetRcNull(pImport->GetCustomAttributeAsBlob(tkContract, (const void **)&pbData, &cbData));
-        
-        // Check serialization format (we support version 1 only).
-        if (cbData < sizeof(WORD) || GET_UNALIGNED_VAL16(pbData) != 1)
-            IfFailRetRcNull(COR_E_BADIMAGEFORMAT);
-        pbData += sizeof(WORD);
-        cbData -= sizeof(WORD);
-
-        // Parse ctor arguments if we have any.
-        if (!fNullCtor) {
-
-            // We assume the enums are based on DWORDS.
-            if (cbData < (sizeof(DWORD) * 2))
-                IfFailRetRcNull(COR_E_BADIMAGEFORMAT);
-
-            // Consistency first.
-            DWORD dwConsistency = GET_UNALIGNED_VAL32(pbData);
-            pbData += sizeof(DWORD);
-            cbData -= sizeof(DWORD);
-            if (dwConsistency > RC_CONSISTENCY_CORRUPT_NOTHING)
-                IfFailRetRcNull(COR_E_BADIMAGEFORMAT);
-
-            // Followed by Cer.
-            DWORD dwCer = GET_UNALIGNED_VAL32(pbData);
-            pbData += sizeof(DWORD);
-            cbData -= sizeof(DWORD);
-            if (dwCer > RC_CER_SUCCESS)
-                IfFailRetRcNull(COR_E_BADIMAGEFORMAT);
-
-            dwResult = RC_MERGE(dwResult, RC_ENCODE(dwConsistency, dwCer));
-        }
-
-        // Get the count of field/property, value pairs.
-        if (cbData < sizeof(WORD))
-            IfFailRetRcNull(COR_E_BADIMAGEFORMAT);
-        WORD cPairs = GET_UNALIGNED_VAL16(pbData);
-        pbData += sizeof(WORD);
-        cbData -= sizeof(WORD);
-
-        // Iterate over any such pairs, looking for values we haven't picked up yet.
-        for (DWORD i = 0 ; i < cPairs; i++) {
-
-            // First is a field vs property selector. We expect only properties.
-            if (cbData < sizeof(BYTE) || *(BYTE*)pbData != SERIALIZATION_TYPE_PROPERTY)
-                IfFailRetRcNull(COR_E_BADIMAGEFORMAT);
-            pbData += sizeof(BYTE);
-            cbData -= sizeof(BYTE);
-
-            // Next is the type of the property. It had better be an enum.
-            if (cbData < sizeof(BYTE) || *(BYTE*)pbData != SERIALIZATION_TYPE_ENUM)
-                IfFailRetRcNull(COR_E_BADIMAGEFORMAT);
-            pbData += sizeof(BYTE);
-            cbData -= sizeof(BYTE);
-
-            // Next we have the assembly qualified enum type name. This is preceded by a metadata style packed byte length (the
-            // string itself is 8-bit and not null terminated). Ignore it (just skip across) and we'll key off the property name
-            // (coming up) instead.
-            DWORD cbName;
-            BYTE const * pbPostEncodedLength;
-            IfFailRetRcNull(CPackedLen::SafeGetData(pbData, cbData, &cbName, &pbPostEncodedLength));
-            DWORD cbEncodedLength = static_cast<DWORD>(pbPostEncodedLength - pbData);
-            pbData += cbEncodedLength + cbName;
-            cbData -= cbEncodedLength + cbName;
-
-            // Now we have the name of the property (in a similar format to above).
-            IfFailRetRcNull(CPackedLen::SafeGetData(pbData, cbData, &cbName, &pbPostEncodedLength));
-            cbEncodedLength = static_cast<DWORD>(pbPostEncodedLength - pbData);
-            pbData += cbEncodedLength;
-            cbData -= cbEncodedLength;
-
-            bool fConsistencyProp = false;
-            if (cbName == strlen(RC_CONSISTENCY_PROP_NAME) && strncmp((const char*)pbData, RC_CONSISTENCY_PROP_NAME, cbName) == 0)
-                fConsistencyProp = true;
-            else if (cbName == strlen(RC_CER_PROP_NAME) && strncmp((const char*)pbData, RC_CER_PROP_NAME, cbName) == 0)
-                fConsistencyProp = false;
-            else
-                IfFailRetRcNull(COR_E_BADIMAGEFORMAT);
-            pbData += cbName;
-            cbData -= cbName;
-
-            // And finally the actual enum value (again, we assume the underlying type is a DWORD).
-            if (cbData < sizeof(DWORD))
-                IfFailRetRcNull(COR_E_BADIMAGEFORMAT);
-            DWORD dwValue = GET_UNALIGNED_VAL32(pbData);
-            pbData += sizeof(DWORD);
-            cbData -= sizeof(DWORD);
-
-            if (fConsistencyProp) {
-                if (dwValue > RC_CONSISTENCY_CORRUPT_NOTHING)
-                    IfFailRetRcNull(COR_E_BADIMAGEFORMAT);
-                dwResult = RC_MERGE(dwResult, RC_ENCODE(dwValue, RC_CER_UNDEFINED));
-            } else {
-                if (dwValue > RC_CER_SUCCESS)
-                    IfFailRetRcNull(COR_E_BADIMAGEFORMAT);
-                dwResult = RC_MERGE(dwResult, RC_ENCODE(RC_CONSISTENCY_UNDEFINED, dwValue));
-            }
-        }
-
-        // Shouldn't have any bytes left in the blob at this stage.
-        _ASSERTE(cbData == 0);
-    }
-
-    // Return the result encoded and packed into the 2 low order bits of a DWORD.
-    return dwResult;
-}
-
-// Given a metadata token, a scoping module and a type context, look up the appropriate MethodDesc (and recomputed accompanying type
-// context).
-MethodContext *TokenToMethodDesc(Module *pModule, mdToken tokMethod, SigTypeContext *pTypeContext)
-{
-    STANDARD_VM_CONTRACT;
-
-    // Validate that the token is one that we can handle.
-    if (!pModule->GetMDImport()->IsValidToken(tokMethod) || (TypeFromToken(tokMethod) != mdtMethodDef &&
-                                                             TypeFromToken(tokMethod) != mdtMethodSpec &&
-                                                             TypeFromToken(tokMethod) != mdtMemberRef)) {
-        COMPlusThrowHR(COR_E_BADIMAGEFORMAT, BFA_INVALID_METHOD_TOKEN);
-    }
-
-    // Look up the MethodDesc based on the token and type context.
-    MethodDesc *pMD = MemberLoader::GetMethodDescFromMemberDefOrRefOrSpec(pModule,
-                                                                          tokMethod,
-                                                                          pTypeContext,
-                                                                          TRUE,
-                                                                          FALSE);
-
-    // The MethodDesc we get might be shared between several types. If so we'll need to do extra work to locate the exact
-    // class instantiation instead of the default representative one.
-    SigTypeContext sNewTypeContext;
-    if (pMD->IsSharedByGenericInstantiations()) {
-        TypeHandle th = GetTypeFromMemberDefOrRefOrSpecThrowing(pModule,
-                                                                tokMethod,
-                                                                pTypeContext);
-        SigTypeContext::InitTypeContext(pMD, th,&sNewTypeContext);
-    } else
-        SigTypeContext::InitTypeContext(pMD, pMD->GetClassInstantiation(), pMD->GetMethodInstantiation(),&sNewTypeContext);
-
-    return MethodContext::PerThreadAllocate(pMD, &sNewTypeContext);
-}
-
-// Locate an exact type definition given a method token and the type context in which it can be resolved.
-TypeHandle GetTypeFromMemberDefOrRefOrSpecThrowing(Module         *pModule,
-                                                   mdToken         tokMethod,
-                                                   SigTypeContext *pTypeContext)
-{
-    STANDARD_VM_CONTRACT;
-
-    IMDInternalImport *pImport = pModule->GetMDImport();
-
-    // Convert method specs into the underlying member ref.
-    if (TypeFromToken(tokMethod) == mdtMethodSpec)
-    {
-        PCCOR_SIGNATURE   pSig;
-        ULONG             cSig;
-        mdMemberRef       tkGenericMemberRef;
-        
-        IfFailThrow(pImport->GetMethodSpecProps(tokMethod, &tkGenericMemberRef, &pSig, &cSig));
-        
-        if (!pImport->IsValidToken(tkGenericMemberRef) || 
-            (TypeFromToken(tkGenericMemberRef) != mdtMethodDef &&
-             TypeFromToken(tkGenericMemberRef) != mdtMemberRef))
-        {
-            COMPlusThrowHR(COR_E_BADIMAGEFORMAT, BFA_INVALID_TOKEN_TYPE);
-        }
-        
-        tokMethod = tkGenericMemberRef;
-    }
-    
-    // Follow the member ref/def back up to the type def/ref/spec or module (for global methods).
-    if (TypeFromToken(tokMethod) == mdtMemberRef)
-    {
-        IfFailThrow(pImport->GetParentOfMemberRef(tokMethod, &tokMethod));
-        
-        // For varargs, a memberref can point to a methodDef
-        if (TypeFromToken(tokMethod) == mdtMethodDef)
-        {
-            if (!pImport->IsValidToken(tokMethod))
-            {
-                COMPlusThrowHR(COR_E_BADIMAGEFORMAT, BFA_INVALID_TOKEN);
-            }
-            IfFailThrow(pImport->GetParentToken(tokMethod, &tokMethod));
-        }
-    }
-    else if (TypeFromToken(tokMethod) == mdtMethodDef)
-    {
-        IfFailThrow(pImport->GetParentToken(tokMethod, &tokMethod));
-    }
-    
-    if (!pImport->IsValidToken(tokMethod) || (TypeFromToken(tokMethod) != mdtTypeDef  &&
-                                              TypeFromToken(tokMethod) != mdtTypeRef  &&
-                                              TypeFromToken(tokMethod) != mdtTypeSpec &&
-                                              TypeFromToken(tokMethod) != mdtModuleRef))
-    {
-        COMPlusThrowHR(COR_E_BADIMAGEFORMAT, BFA_INVALID_TOKEN);
-    }
-    
-    // Load the type in question, using a type context if necessary to get an exact representation.
-    TypeHandle th;
-    if (TypeFromToken(tokMethod) == mdtModuleRef) {
-        DomainFile *pNewModule = pModule->LoadModule(GetAppDomain(), tokMethod, FALSE);
-        if (pNewModule != NULL)
-            th = TypeHandle(pNewModule->GetModule()->GetGlobalMethodTable());
-    } else {
-        th = ClassLoader::LoadTypeDefOrRefOrSpecThrowing(pModule,
-                                                         tokMethod,
-                                                         pTypeContext);
-    }
-
-    if (th.IsNull())
-        COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
-
-    return th;
-}
-
-// Determine whether the method given as a parameter is the root of a CER.
-// @todo: Need an x86 offset as well and logic to determine whether we're actually in a root-CER portion of the method (if the whole
-// thing isn't the root).
-bool IsCerRootMethod(MethodDesc *pMD)
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pMD));
-        SO_TOLERANT;
-    } CONTRACTL_END;
-
-    // Treat IL stubs as CER roots (marshaling code needs to string together operations without being interruped by thread aborts).
-    if (pMD->IsILStub())
-        return true;
-
-    // There are some well defined root methods defined by the system.
-    if (pMD == g_pExecuteBackoutCodeHelperMethod)
-        return true;
-
-    // For now we just look to see whether there is some prep or fixup info stored for this method.
-    Module *pModule = pMD->GetModule();
-
-    if (pModule->GetCerPrepInfo(pMD) != NULL)
-        return true;
-
-#ifdef FEATURE_PREJIT
-    if (pModule->IsNgenCerRootMethod(pMD))
-        return true;
-#endif
-
-    return false;
-}
-
-// Fill the cache of overflowed generic dictionary entries that the jit maintains with all the overflow slots stored so far in the
-// dictionary layout.
-void PrepopulateGenericHandleCache(DictionaryLayout  *pDictionaryLayout,
-                                   MethodDesc        *pMD,
-                                   MethodTable       *pMT)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    } CONTRACTL_END;
-
-    // Dictionary overflow entries are recorded starting in the second bucket of the dictionary layout.
-    DictionaryLayout *pOverflows = pDictionaryLayout->GetNextLayout();
-
-    while (pOverflows) {
-        for (DWORD i = 0; i < pOverflows->GetMaxSlots(); i++) {
-            DictionaryEntryLayout *pEntry = pOverflows->GetEntryLayout(i);
-
-            // We've finished as soon as we find the first unused slot.
-            if (!pEntry->m_signature)
-                return;
-
-            // We have a valid overflow entry. Determine the handle value given the type context we have and push it into the JIT's
-            // cache.
-            JIT_GenericHandleWorker(pMD, pMT, pEntry->m_signature);
-        }
-        pOverflows = pOverflows->GetNextLayout();
-    }
-}
-
-#ifdef FEATURE_PREJIT
-
-// Prepare the CER rooted at the given method (it's OK to pass a MethodDesc* that doesn't root a CER, in which case the method
-// is a no-op).
-void CerNgenRootTable::Restore(MethodDesc *pRootMD)
-{
-#ifndef CROSSGEN_COMPILE
-    STANDARD_VM_CONTRACT;
-
-    // We don't have a restoration bitmap at ngen time. No matter, we just always claim everything is restored.
-    if (m_pRestoreBitmap == NULL)
-        return;
-
-    // Locate the root index from the table. Failure indicates there's no work to do.
-    DWORD dwIndex = FindIndex(pRootMD);
-    if (dwIndex == NoSuchRoot)
-        return;
-
-    _ASSERTE(m_pRoots[dwIndex].m_pRootMD == pRootMD);
-
-    // Check then mark the fact that we're preparing (to prevent potential recursion).
-    SigTypeContext typeContext;
-    if (!GetThread()->GetCerPreparationState()->CanPreparationProceed(pRootMD, &typeContext))
-        return;
-
-    MethodCallGraphPreparer sPrep(pRootMD, &typeContext, true, true);
-    MethodCallGraphPreparer::ThreadPreparingCerHolder sCerHolder(&sPrep);
-
-#ifdef _DEBUG
-    if (GetCerLoggingOptions())
-    {
-        CER_LOG(RESTORE, ("---------------------------------------------------------------\n"));
-        SString ssRootMethod;
-        TypeString::AppendMethodInternal(ssRootMethod, pRootMD, TypeString::FormatNamespace | TypeString::FormatStubInfo);
-        CER_LOG(RESTORE, ("Restoring CER graph from %S\n", ssRootMethod.GetUnicode()));
-    }
-#endif
-
-    g_IBCLogger.LogCerMethodListReadAccess(pRootMD);
-
-    // Retrieve the CerRoot structure.
-    CerRoot *pRoot = &m_pRoots[dwIndex];
-    _ASSERTE(pRoot->m_pRootMD == pRootMD);
-
-    // Scan the list of methods in the CER (the last one is a sentinel with a NULL MethodDesc*). Restore each method as we go.
-    MethodContextElement *pEntry = pRoot->m_pList;
-    while (pEntry->GetMethodDesc())
-    {
-        // Method desc and type handle pointers may still be tokenized at this point.
-        Module::RestoreMethodDescPointer(&pEntry->m_pMethodDesc);
-        Module::RestoreMethodTablePointer(&pEntry->m_pExactMT);
-
-        g_IBCLogger.LogCerMethodListReadAccess(pEntry->GetMethodDesc());
-
-        MethodDesc * pMD = pEntry->GetMethodDesc();
-
-        // Check whether there are generic dictionaries that need to be pre-populated.
-
-        // Don't use the direct PrepopulateDictionary method here for MethodTable/MethodDesc
-        //  - MethodTable: Takes binding considerations into account (which we don't care about)
-        //  - MethodDesc: Appears to use a representative class instantiation (and we have the exact one handy)
-        //
-        // Additionally, avoid touching EE Class if we don't need to
-        MethodTable * pMT = pEntry->GetExactMT();
-        if (pMT != NULL)
-        {
-            // MethodTable
-            DictionaryLayout *pClassDictLayout = pMT->GetClass()->GetDictionaryLayout();
-            if (pClassDictLayout)
-            {
-                pMT->GetDictionary()->PrepopulateDictionary(NULL, pMT, false);
-
-                // The dictionary may have overflowed in which case we need to prepopulate the jit's lookup cache as well.
-                PrepopulateGenericHandleCache(pClassDictLayout, NULL, pMT);
-            }
-
-            // MethodDesc
-            DictionaryLayout *pMethDictLayout = pMD->GetDictionaryLayout();
-            if (pMethDictLayout)
-            {
-                pMD->GetMethodDictionary()->PrepopulateDictionary(pMD, NULL, false);
-
-                // The dictionary may have overflowed in which case we need to prepopulate the jit's lookup cache as well.
-                PrepopulateGenericHandleCache(pMethDictLayout, pMD, NULL);
-            }
-        }
-
-        // Recreate stubs used by P/Invoke, COM calls, or FCalls by exercising the prestub.
-        if (pMD->IsPointingToPrestub() && (pMD->IsNDirect() || pMD->IsComPlusCall() || pMD->IsFCall()))
-        {
-            pMD->EnsureActive();
-            pMD->DoPrestub(NULL);
-        }
-
-#ifdef _DEBUG
-        if (GetCerLoggingOptions())
-        {
-            SString ssMethod;
-            TypeString::AppendMethodInternal(ssMethod, pMD, TypeString::FormatNamespace | TypeString::FormatStubInfo);
-            CER_LOG(RESTORE, ("  %S\n", ssMethod.GetUnicode()));
-        }
-#endif
-
-        // Move to next entry.
-        pEntry++;
-    }
-
-    CER_LOG(RESTORE, ("---------------------------------------------------------------\n"));
-
-    // Mark this whole CER region as fixed up by setting a flag in the restore bitmap (kept separate so we can cluster all our page
-    // writes).
-    // Compute the DWORD offset into the flag array and then the mask for the specific bit in that DWORD.
-    DWORD dwOffset = dwIndex / (sizeof(DWORD) * 8);
-    DWORD dwMask = 1 << (dwIndex % (sizeof(DWORD) * 8));
-    EnsureWritablePages(m_pRestoreBitmap, sizeof(DWORD) * SizeOfRestoreBitmap());
-    FastInterlockOr(&m_pRestoreBitmap[dwOffset], dwMask);
-
-    // If we fixed up any methods with their own CERs then we will have implicitly fixed up those too. Mark their fixup records as
-    // completed as well to avoid further unecessary work.
-    pEntry = pRoot->m_pList;
-    while (pEntry->GetMethodDesc()) {
-        dwIndex = FindIndex(pEntry->GetMethodDesc());
-        if (dwIndex != NoSuchRoot) {
-            dwOffset = dwIndex / (sizeof(DWORD) * 8);
-            dwMask = 1 << (dwIndex % (sizeof(DWORD) * 8));
-            FastInterlockOr(&m_pRestoreBitmap[dwOffset], dwMask);
-        }
-        pEntry++;
-    }
-#endif // CROSSGEN_COMPILE
-}
-
-#ifdef FEATURE_NATIVE_IMAGE_GENERATION
-// Add a new root to the table, expanding it as necessary. Note that this method must be called with the CerCrst already held.
-void CerNgenRootTable::AddRoot(MethodDesc *pRootMD, MethodContextElement *pList)
-{
-    CONTRACTL {
-        STANDARD_VM_CHECK;
-        PRECONDITION(IsOwnerOfCrst(pRootMD->GetModule()->GetCerCrst()));
-    } CONTRACTL_END;
-
-    // Ensure we have enough space first.
-    if (m_cRoots == m_cSlots) {
-        DWORD cNewSize = m_cSlots + 16;
-        CerRoot *pNewArray = new CerRoot[cNewSize];
-        memcpyNoGCRefs(pNewArray, m_pRoots, m_cRoots * sizeof(CerRoot));
-        MethodContextElement **pNewRootsInCompilationOrder = new MethodContextElement*[cNewSize];
-        memcpyNoGCRefs(pNewRootsInCompilationOrder, m_pRootsInCompilationOrder, m_cRoots * sizeof(MethodContextElement*) );
-        m_cSlots = cNewSize;
-        delete m_pRoots;
-        m_pRoots = pNewArray;
-        delete m_pRootsInCompilationOrder;
-        m_pRootsInCompilationOrder = pNewRootsInCompilationOrder;
-    }
-
-    // Fill in the new entry in sorted order.
-    DWORD i;
-    for (i = 0; i < m_cRoots; i++)
-        if ((UPTR) m_pRoots[i].m_pRootMD > (UPTR) pRootMD)
-            break;
-    if (i < m_cRoots)
-        memmove(&m_pRoots[i + 1], &m_pRoots[i], (m_cRoots - i) * sizeof(CerRoot));
-    m_pRoots[i].m_pRootMD = pRootMD;
-    m_pRoots[i].m_pList = pList;
-
-    m_pRootsInCompilationOrder[m_cRoots] = pList;
-
-    m_cRoots++;
-}
-
-// Ngen callouts to help serialize this structure and its children to storage.
-void CerNgenRootTable::Save(DataImage *image, CorProfileData *profileData)
-{
-    STANDARD_VM_CONTRACT;
-
-#ifdef _DEBUG
-    DWORD dwMaxEntries = 0;
-    DWORD dwTotalEntries = 0;
-#endif
-
-    image->StoreStructure(this, sizeof(CerNgenRootTable), DataImage::ITEM_CER_ROOT_TABLE);
-    image->StoreStructure(m_pRoots, m_cRoots * sizeof(CerRoot), DataImage::ITEM_CER_ROOT_TABLE);
-
-    // Create a bitmap of boolean flags (1 bit per flag) indicating whether the CER at a given index in the array has been restored.
-    // This is initially all zero and only filled in at runtime (keep all the flags together this way because they're the only
-    // things we have to write at runtime and we want to keep them as dense as possible).
-    _ASSERTE((SizeOfRestoreBitmap() % sizeof(DWORD)) == 0);
-    m_pRestoreBitmap = new DWORD[SizeOfRestoreBitmap() / sizeof(DWORD)];
-    memset(m_pRestoreBitmap, 0xff, SizeOfRestoreBitmap());
-
-    image->StoreStructure(m_pRestoreBitmap,
-                          SizeOfRestoreBitmap(),
-                          DataImage::ITEM_CER_RESTORE_FLAGS);
-
-    // Next save off the list of MethodContextElements associated with each root.
-    for (DWORD i = 0; i < m_cRoots; i++) {
-        MethodContextElement *pEntry = m_pRootsInCompilationOrder[i];
-        
-        // Count entries in list.
-        DWORD cEntries = 0;
-        while (pEntry->GetMethodDesc()) {
-            cEntries++;
-            pEntry++;
-        }
-
-        // Plus one for the sentinel value.
-        cEntries++;
-
-#ifdef _DEBUG
-        dwTotalEntries += cEntries;
-        if (cEntries > dwMaxEntries)
-            dwMaxEntries = cEntries;
-#endif
-
-        // Store this list.
-        image->StoreStructure(m_pRootsInCompilationOrder[i],
-                              cEntries * sizeof(MethodContextElement),
-                              DataImage::ITEM_CER_METHOD_LIST);
-    }
-
-#ifdef _DEBUG
-    if (m_cRoots > 0) {
-        CER_LOG(NGEN_STATS, ("Saving %u CER roots in ngen image\n", m_cRoots));
-        CER_LOG(NGEN_STATS, ("  Max methods in CER: %u\n", dwMaxEntries));
-        CER_LOG(NGEN_STATS, ("  Avg methods in CER: %.1f\n", (float)((float)dwTotalEntries / (float)m_cRoots)));
-    } else
-        CER_LOG(NGEN_STATS, ("No CER roots in ngen image\n"));
-#endif
-}
-
-void CerNgenRootTable::Fixup(DataImage *image)
-{
-    STANDARD_VM_CONTRACT;
-
-    DWORD i;
-
-    // We still use the point to the root array even though at runtime the two structures will be adjacent.
-    image->FixupPointerField(this, offsetof(CerNgenRootTable, m_pRoots));
-
-    // Restoration flags are used only at runtime and must start off zeroed.
-    image->FixupPointerField(this, offsetof(CerNgenRootTable, m_pRestoreBitmap));
-    image->ZeroField(m_pRestoreBitmap, 0, SizeOfRestoreBitmap());
-
-    // The root list in compilation order is only used at ngen time, and is not written into native image.
-    image->ZeroPointerField(this, offsetof(CerNgenRootTable, m_pRootsInCompilationOrder));
-
-    // Fixup all the pointers in the individual CERs.
-    for (i = 0; i < m_cRoots; i++) {
-
-        // For each MethodContextElement in the list we need to fixup a pointer to a MethodDesc and two array pointers (one for any
-        // class instantiation and one for any method instantiation). The actual MethodDescs and TypeHandles themselves are already
-        // fixed up as are the instantiation arrays we point to (they're the ones inside the generic dictionaries of the class/method
-        // concerned).
-        MethodContextElement *pList = m_pRootsInCompilationOrder[i];
-        MethodContextElement *pEntry = pList;
-        while (pEntry->GetMethodDesc()) {
-            image->FixupMethodDescPointer(pList, &pEntry->m_pMethodDesc);
-            image->FixupMethodTablePointer(pList, &pEntry->m_pExactMT);
-            pEntry++;
-        }
-    }
-}
-
-void CerNgenRootTable::FixupRVAs(DataImage *image)
-{
-    STANDARD_VM_CONTRACT;
-
-    DWORD i, j;
-
-    // Now we go back through the root table and sort the entries based on the locations of the root method descs in the new image
-    // (they may be rearranged due to IBC profiling).
-    CerRoot *pNewRoots = (CerRoot*)image->GetImagePointer(m_pRoots);
-    PREFIX_ASSUME(pNewRoots != NULL);
-
-    // Simple insertion sort. Starting at the second element insert a candidate into its correct location in the sub-list
-    // preceding it (which by definition will already be sorted).
-    for (i = 1; i < m_cRoots; i++)
-    {
-        // Look at all of the preceding elements for the first that is larger than the candidate (i.e. should succeed the
-        // candidate in sorted order). If we don't find one then the candidate is already in place and we can proceed to the
-        // next candidate.
-        for (j = 0; j < i; j++)
-            if (image->GetRVA(pNewRoots[j].m_pRootMD) > image->GetRVA(pNewRoots[i].m_pRootMD)) {
-
-                // Need to move candidate element up. Cache its value because we're about to overwrite it.
-                MethodDesc *pTmpRootMD = pNewRoots[i].m_pRootMD;
-                MethodContextElement *pTmpList = pNewRoots[i].m_pList;
-
-                // Shuffle the sorted list one up to make room for the candidate.
-                memmove(&pNewRoots[j + 1], &pNewRoots[j], (i - j) * sizeof(CerRoot));
-
-                // Insert the candidate into position.
-                pNewRoots[j].m_pRootMD = pTmpRootMD;
-                pNewRoots[j].m_pList = pTmpList;
-
-                // Sorted the candidate, move onto the next.
-                break;
-            }
-    }
-
-    // Fixup all the pointers in the individual CERs.
-    for (i = 0; i < m_cRoots; i++) {
-        // Fix up the pointer to the root method and the list of methods in the CER.
-        image->FixupField(m_pRoots, sizeof(CerRoot) * i + offsetof(CerRoot, m_pRootMD),
-            pNewRoots[i].m_pRootMD);
-        image->FixupField(m_pRoots, sizeof(CerRoot) * i + offsetof(CerRoot, m_pList),
-            pNewRoots[i].m_pList);
-    }
-}
-#endif // FEATURE_NATIVE_IMAGE_GENERATION
-
-// Locate the index of a given CerRoot record in the array given the root method. This is used to access the array and to locate the
-// restored flag for the entry in the restored bitmap. NoSuchRoot is returned if the root cannot be found.
-DWORD CerNgenRootTable::FindIndex(MethodDesc *pRootMD)
-{
-    CONTRACTL {
-        NOTHROW;
-        MODE_ANY;
-        GC_NOTRIGGER;
-        PRECONDITION(CheckPointer(pRootMD));
-        SO_TOLERANT;
-    } CONTRACTL_END;
-
-    // The table is guaranteed to be sorted, so we can lookup our target with a binary search.
-    DWORD dwLow = 0;
-    DWORD dwHigh = m_cRoots - 1;
-    while (true) {
-
-        // Take out the simple cases first.
-
-        // The range has only one entry.
-        if (dwLow == dwHigh) {
-            if (m_pRoots[dwLow].m_pRootMD == pRootMD)
-                return dwLow;
-#ifdef _DEBUG
-            for (DWORD i = 0; i < m_cRoots; i++)
-                _ASSERTE(m_pRoots[i].m_pRootMD != pRootMD);
-#endif
-            return NoSuchRoot;
-        }
-
-        // The range has only two entries.
-        if (dwLow == dwHigh - 1) {
-            if (m_pRoots[dwLow].m_pRootMD == pRootMD)
-                return dwLow;
-            if (m_pRoots[dwHigh].m_pRootMD == pRootMD)
-                return dwHigh;
-#ifdef _DEBUG
-            for (DWORD i = 0; i < m_cRoots; i++)
-                _ASSERTE(m_pRoots[i].m_pRootMD != pRootMD);
-#endif
-            return NoSuchRoot;
-        }
-
-        // Now we can compute a midpoint that is definitely distinct and in-between the endpoints.
-        DWORD dwMid = dwLow + ((dwHigh - dwLow) / 2);
-
-        // Did we nail it?
-        if (m_pRoots[dwMid].m_pRootMD == pRootMD)
-            return dwMid;
-
-        // Otherwise adjust our range to be the bit we haven't looked at and iterate.
-        if ((UPTR)m_pRoots[dwMid].m_pRootMD < (UPTR)pRootMD)
-            dwLow = dwMid + 1;
-        else
-            dwHigh = dwMid - 1;
-    }
-}
-
-// Prepare the class if it is derived from CriticalFinalizerObject. This is used at ngen time since such classes are normally 
-// prepared at runtime (at instantiation) and would therefore miss the ngen image.
-void PrepareCriticalType(MethodTable * pMT)
-{
-    STANDARD_VM_CONTRACT;
-
-    // Prepare any class that satisfies the criteria. Pass a pointer to this module so that we'll only prepare any overrides of
-    // the critical methods that were actually introduced here.
-    if (pMT->HasCriticalFinalizer())
-        PrepareCriticalFinalizerObject(pMT, pMT->GetLoaderModule());
-}
-
-// Prepare a method and its statically determinable call graph if a hint attribute has been applied. This is only called at ngen
-// time to save additional preparation information into the ngen image that wouldn't normally be there (and thus lower runtime
-// overheads).
-void PrePrepareMethodIfNecessary(CORINFO_METHOD_HANDLE hMethod)
-{
-    STANDARD_VM_CONTRACT;
-
-    EX_TRY {
-
-        // Translate jit-style method handle into method desc.
-        MethodDesc *pMD = GetMethod(hMethod);
-
-        // Check for the existance of the attribute.
-        IMDInternalImport  *pImport = pMD->GetMDImport();
-        mdToken             tkMethod = pMD->GetMemberDef();
-        HRESULT             hr = pImport->GetCustomAttributeByName(tkMethod,
-                                                                   "System.Runtime.ConstrainedExecution.PrePrepareMethodAttribute",
-                                                                   NULL, NULL);
-
-        // TODO: We should add IBC probes which indicate that methods need to be preprepared
-        //                which can then be reflected in the IBC data, we can add an additional check
-        //                here to cover that case, then we can get around this problem with profiling
-        //                instead of manual programmer effort.
-
-        // Only prepare if we definitely saw the attribute.
-        if (hr == S_OK) {
-            // Prepare the method and its graph. There should never be any open type parameters (we can't do much at ngen time with these),
-            // so we can pass a null type context.
-            SigTypeContext sTypeContext;
-            MethodCallGraphPreparer mcgp(pMD, &sTypeContext, true, true);
-            mcgp.Run();
-        }
-
-    } EX_CATCH {
-    } EX_END_CATCH(SwallowAllExceptions);
-}
-
-#endif // FEATURE_PREJIT
-
-PtrHashCache::PtrHashCache()
-{
-    LIMITED_METHOD_CONTRACT;
-    ZeroMemory(this, sizeof(*this));
-
-    // First entry in each bucket is a chain index used to evenly distribute inserts within a bucket.
-    _ASSERTE(PHC_CHAIN > 1);
-}
-
-bool PtrHashCache::Lookup(void *pKey, DWORD *pdwValue)
-{
-    LIMITED_METHOD_CONTRACT;
-    _ASSERTE(((UINT_PTR)pKey & PHC_DATA_MASK) == 0);
-
-    DWORD dwBucket = GetHash(pKey);
-
-    // Skip first entry in bucket, it's a sequence number used for insertions.
-    for (DWORD i = 1; i < PHC_CHAIN; i++) {
-        UINT_PTR uipEntry = VolatileLoad<UINT_PTR>(&m_rEntries[(dwBucket * PHC_CHAIN) + i]);
-        if ((uipEntry & ~PHC_DATA_MASK) == (UINT_PTR)pKey) {
-#ifdef _DEBUG
-            FastInterlockIncrement((LONG*)&m_dwHits);
-#endif
-            *pdwValue = uipEntry & PHC_DATA_MASK;
-            return true;
-        }
-    }
-
-#ifdef _DEBUG
-    FastInterlockIncrement((LONG*)&m_dwMisses);
-#endif
-    return false;
-}
-
-void PtrHashCache::Add(void *pKey, DWORD dwValue)
-{
-    LIMITED_METHOD_CONTRACT;
-    _ASSERTE(((UINT_PTR)pKey & PHC_DATA_MASK) == 0);
-    _ASSERTE((dwValue & ~PHC_DATA_MASK) == 0);
-
-    DWORD dwBucket = GetHash(pKey);
-
-    // We keep a sequence number in the first entry of the bucket so that we distribute insertions within the bucket evenly. We're
-    // racing when we update this value, but it doesn't matter if we lose an update (we're a cache after all). We don't bother being
-    // careful to avoid overflowing the value here (we just keep incrementing); we'll do the modulo logic when we insert our value
-    // instead.
-    DWORD dwIndex = static_cast<DWORD>(m_rEntries[dwBucket * PHC_CHAIN]++);
-    dwIndex = (dwIndex % (PHC_CHAIN - 1)) + 1;
-    m_rEntries[(dwBucket * PHC_CHAIN) + dwIndex] = ((UINT_PTR)pKey & ~PHC_DATA_MASK) | dwValue;
-}
-
-DWORD PtrHashCache::GetHash(void *pKey)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    return (DWORD)(((UINT_PTR)pKey >> 4) % PHC_BUCKETS);
-}
-
-#ifdef _DEBUG
-void PtrHashCache::DbgDumpStats()
-{
-#if 0
-    if ((m_dwHits + m_dwMisses) == 0)
-        return;
-
-    printf("Dumping stats for PtrHashCache %08X\n", this);
-    printf("  %u hits, %u misses (%u%% hit rate)\n", m_dwHits, m_dwMisses, (m_dwHits * 100) / (m_dwHits + m_dwMisses));
-    for (DWORD i = 0; i < PHC_BUCKETS; i++)
-        printf("    [%2u] : %u insertions\n", i, m_rEntries[i * PHC_CHAIN]);
-    printf("\n");
-#endif
-}
-#endif
diff --git a/src/vm/constrainedexecutionregion.h b/src/vm/constrainedexecutionregion.h
deleted file mode 100644
index 4b41b2570e..0000000000
--- a/src/vm/constrainedexecutionregion.h
+++ /dev/null
@@ -1,566 +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.
-//
-// Methods to support the implementation of Constrained Execution Regions (CERs). This includes logic to walk the IL of methods to
-// determine the statically determinable call graph and prepare each submethod (jit, prepopulate generic dictionaries etc.,
-// everything needed to ensure that the runtime won't generate implicit failure points during the execution of said call graph).
-//
-
-//
-
-
-#ifndef __CONSTRAINED_EXECUTION_REGION_H
-#define __CONSTRAINED_EXECUTION_REGION_H
-
-#ifdef FEATURE_CER
-
-#include <corhlpr.h>
-#include <typestring.h>
-
-
-// An enumeration that abstracts the interesting information (from our point of view) present in a reliability contract decorating a
-// method.
-enum ReliabilityContractLevel
-{
-    RCL_UNKNOWN             = -1,   // The contract attribute hasn't been read yet
-    RCL_NO_CONTRACT         = 0,    // No contract (or a fairly useless one) was specified
-    RCL_BASIC_CONTRACT      = 1,    // The contract promises enough for the method to be a legal member of a CER call graph
-    RCL_PREPARE_CONTRACT    = 2,    // The contract promises enough to be worth preparing the method as part of a CER call graph
-};
-
-// Various definitions used to parse reliability contracts. These must be kept synchronized with the managed version in
-// BCL\System\Runtime\Reliability\ReliabilityContractAttribute.cs
-
-#define RELIABILITY_CONTRACT_NAME       "System.Runtime.ConstrainedExecution.ReliabilityContractAttribute"
-#define RC_CONSISTENCY_PROP_NAME        "ConsistencyGuarantee"
-#define RC_CER_PROP_NAME                "Cer"
-
-enum {
-    RC_CONSISTENCY_CORRUPT_PROCESS      = 0,
-    RC_CONSISTENCY_CORRUPT_APPDOMAIN    = 1,
-    RC_CONSISTENCY_CORRUPT_INSTANCE     = 2,
-    RC_CONSISTENCY_CORRUPT_NOTHING      = 3,
-    RC_CONSISTENCY_UNDEFINED            = 4,
-    RC_CER_NONE                         = 0,
-    RC_CER_MAYFAIL                      = 1,
-    RC_CER_SUCCESS                      = 2,
-    RC_CER_UNDEFINED                    = 3
-};
-
-
-// We compact the reliability contract states above into a single DWORD format easy to cache at the assembly and class level
-// opaquely. We also encode in this DWORD whether a given part of the state has been defined yet (an assembly might set a
-// consistency level without specifying a cer level, for instance, and this information is vital when merging states between
-// assembly, class and method levels).
-// The macros below handle the encoding so nobody else needs to know the details.
-
-// The base state for an encoded DWORD: neither consistency or cer defined.
-#define RC_NULL RC_ENCODE(RC_CONSISTENCY_UNDEFINED, RC_CER_UNDEFINED)
-
-// Extract the raw consistency value from an encoded DWORD.
-#define RC_CONSISTENCY(_encoded) ((_encoded) >> 2)
-
-// Extract the raw cer value from an encoded DWORD.
-#define RC_CER(_encoded) ((_encoded) & 3)
-
-// Produce an encoded DWORD from a pair of raw consistency and cer values. Values must have been range validated first.
-#define RC_ENCODE(_consistency, _cer) (DWORD)(((_consistency) << 2) | (_cer))
-
-// Produce an abstracted ReliabilityContractLevel from an encoded DWORD, see CheckForReliabilityContract for details of the rules.
-#define RC_ENCODED_TO_LEVEL(_encoded)                                                   \
-    ((RC_CONSISTENCY(_encoded) == RC_CONSISTENCY_UNDEFINED ||                           \
-      RC_CONSISTENCY(_encoded) < RC_CONSISTENCY_CORRUPT_INSTANCE) ? RCL_NO_CONTRACT :   \
-     (RC_CER(_encoded) == RC_CER_UNDEFINED ||                                           \
-      RC_CER(_encoded) == RC_CER_NONE) ? RCL_BASIC_CONTRACT :                           \
-     RCL_PREPARE_CONTRACT)
-
-// Given two DWORD encodings presumed to come from different scopes (e.g. method and class) merge them to find the effective
-// contract state. It's presumed the first encoding is the most tightly scoped (i.e. method would go first in the example above) and
-// therefore takes precedence.
-#define RC_MERGE(_old, _new) RC_ENCODE((RC_CONSISTENCY(_old) == RC_CONSISTENCY_UNDEFINED) ? \
-                                       RC_CONSISTENCY(_new) : RC_CONSISTENCY(_old),         \
-                                       (RC_CER(_old) == RC_CER_UNDEFINED) ?                 \
-                                       RC_CER(_new) : RC_CER(_old))                         \
-
-// Return true if either consistency or cer has not been specified in the encoded DWORD given.
-#define RC_INCOMPLETE(_encoded) (RC_CONSISTENCY(_encoded) == RC_CONSISTENCY_UNDEFINED || RC_CER(_encoded) == RC_CER_UNDEFINED)
-
-// Look for reliability contracts at the method, class and assembly level and parse them to extract the information we're interested
-// in from a runtime preparation viewpoint. This information is abstracted in the form of the ReliabilityContractLevel enumeration.
-ReliabilityContractLevel CheckForReliabilityContract(MethodDesc *pMD);
-
-
-// Structure used to track enough information to identify a method (possibly generic or belonging to a generic class). Includes a
-// MethodDesc pointer and a SigTypeContext (values of class and method type parameters to narrow down the exact method being refered
-// to). Similar to MethodContext (see ConstrainedExecutionRegion.cpp), but without the unneeded list link field (we expect to embed
-// these in arrays, hence the name).
-struct MethodContextElement
-{
-    FixupPointer<PTR_MethodDesc> m_pMethodDesc; // Pointer to a MethodDesc
-    FixupPointer<PTR_MethodTable> m_pExactMT;   // Exact type to disambiguate code shared by instantiations
-
-    MethodDesc * GetMethodDesc()
-    {
-        return m_pMethodDesc.GetValue();
-    }
-
-    MethodTable * GetExactMT()
-    {
-        return m_pExactMT.GetValue();
-    }
-};
-
-
-// Base structure used to track which CERs have been prepared so far.
-// These structures are looked up via a per-assembly hash table using the root method desc as a key.
-// Used to avoid extra work in both the jit and PrepareMethod calls. The latter case is more involved because we support preparing a
-// CER with generic type parameters (the instantiation is passed in along with the method in the PrepareMethod call). In that case
-// we need to track exactly which instantiations we've prepared for a given method.
-struct CerPrepInfo
-{
-    CerPrepInfo() :
-        m_fFullyPrepared(false),
-        m_fRequiresInstantiation(false),
-        m_fMethodHasCallsWithinExplicitCer(false)
-    {
-        CONTRACTL {
-            THROWS;
-            GC_NOTRIGGER;
-            MODE_ANY;
-        } CONTRACTL_END;
-
-        if (!m_sIsInitAtInstHash.Init(17, NULL, NULL, FALSE))
-            COMPlusThrowOM();
-    }
-
-    bool                        m_fFullyPrepared;           // True implies we've prep'd this once and there are no shared instantiations
-    bool                        m_fRequiresInstantiation;   // True implies that this method is shared amongst multiple instantiations
-    bool                        m_fMethodHasCallsWithinExplicitCer; // True if method contains calls out from within an explicit PCER range
-    EEInstantiationHashTable    m_sIsInitAtInstHash;        // Hash of instantiations we've prepared this CER for 
-};
-
-
-#ifdef FEATURE_PREJIT
-
-// Structure used to represent a CER by a root method and a list of MethodContextElements that indicate all the methods contained.
-// The MethodContextElement list is terminated with a sentinel entry (m_pMethodDesc set to NULL).
-// Keep this structure small since we'll access the whole array of them randomly at runtime; density is our best friend.
-struct CerRoot
-{
-    MethodDesc                 *m_pRootMD;                  // Root method (no type context since it never has type params)
-    MethodContextElement       *m_pList;                    // List of methods in this CER
-};
-
-// Class used to track all the CERs rooted at methods defined within a given module that are discovered at ngen time. This data is
-// then used at runtime to determine when and how to perform necessary restoration work so that the CERs don't encounter any
-// unexpected failure points during execution.
-// During ngen this class keeps a dynamically expanded array of CER roots (both the class and the array are allocated from a win32
-// heap). When we save the image to storage (and thus know the final size of the table) we combine the two so that at runtime
-// they're adjacent and exactly the right size.
-class CerNgenRootTable
-{
-#ifdef DACCESS_COMPILE
-    friend class NativeImageDumper;
-#endif
-
-    DWORD                      *m_pRestoreBitmap;           // Pointer to array of restored flag bits
-    DWORD                       m_cRoots;                   // Count of root methods represented
-    DWORD                       m_cSlots;                   // Extra empty slots at the tail of the array below (ngen time only)
-    CerRoot                    *m_pRoots;                   // Pointer to array of CER roots (sorted by RootMD address)
-    MethodContextElement      **m_pRootsInCompilationOrder; // Pointer to array of CerRoot::m_pList (in the order AddRoot is called)
-
-public:
-
-    CerNgenRootTable() :
-        m_pRestoreBitmap(NULL),
-        m_cRoots(0),
-        m_cSlots(0),
-        m_pRoots(NULL),
-        m_pRootsInCompilationOrder(NULL)
-    {
-    }
-
-    ~CerNgenRootTable()
-    {
-        CONTRACTL
-        {
-            NOTHROW;
-            GC_NOTRIGGER;
-            SO_TOLERANT;
-            MODE_ANY;
-        }
-        CONTRACTL_END;
-        delete m_pRestoreBitmap;
-        delete m_pRoots;
-        delete m_pRootsInCompilationOrder;
-    }
-
-    // Add a new root to the table, expanding it as necessary. Note that this method must be called with the CerCrst already held.
-    void AddRoot(MethodDesc *pRootMD, MethodContextElement *pList);
-
-    // Retrieve the address of the list of methods for the CER rooted at the given index.
-    inline MethodContextElement *GetList(DWORD dwIndex) { LIMITED_METHOD_CONTRACT; _ASSERTE(dwIndex < m_cRoots); return m_pRoots[dwIndex].m_pList; }
-
-    // Retrieve the address of the list of methods for the CER rooted at the given method. (The root must exist).
-    inline MethodContextElement *GetList(MethodDesc *pRootMD) { WRAPPER_NO_CONTRACT; return GetList(FindIndex(pRootMD)); }
-
-    // Indicate whether the given method has ngen restoration information associated with it.
-    inline bool IsNgenRootMethod(MethodDesc *pRootMD) { WRAPPER_NO_CONTRACT; return FindIndex(pRootMD) != NoSuchRoot; }
-
-    // Prepare the CER rooted at the given method (it's OK to pass a MethodDesc* that doesn't root a CER, in which case the method
-    // is a no-op).
-    void Restore(MethodDesc *pRootMD);
-
-    // Ngen callouts to help serialize this structure and its children to storage.
-    void Save(DataImage *image, CorProfileData *profileData);
-    void Fixup(DataImage *image);
-    void FixupRVAs(DataImage *image);
-
-    // Calculate (in bytes) the size of bitmap to allocate to record whether each CER has been restored at runtime. Size is
-    // rounded up to DWORD alignment.
-    inline DWORD SizeOfRestoreBitmap()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return ((m_cRoots + 31) / 32) * sizeof(DWORD);
-    }
-
-    inline DWORD GetRootCount() { LIMITED_METHOD_CONTRACT; return m_cRoots; }
-    inline CerRoot *GetRoots() { LIMITED_METHOD_CONTRACT; return m_pRoots; }
-    inline DWORD *GetRestoreBitmap() { LIMITED_METHOD_CONTRACT; return m_pRestoreBitmap; }
-
-private:
-    enum { NoSuchRoot = 0xffffffff };
-
-    // Locate the index of a given CerRoot record in the array given the root method. This is used to access the array and to locate
-    // the restored flag for the entry in the restored bitmap. NoSuchRoot is returned if the root cannot be found.
-    DWORD FindIndex(MethodDesc *pRootMD);
-};
-
-#endif
-
-
-// Default initial size for hash table used to track CerPrepInfo structures on a per-module basis.
-#define CER_DEFAULT_HASH_SIZE   17
-
-
-// Structure used to track a single exception handling range (catch, finally etc.). We build an array of these and then track which
-// ones have become 'activated' by virtue of having their try clause immediately preceded by a call to our preparation marker
-// method. This allows us to determine which call sites in the method body should be followed during method preparation.
-struct EHClauseRange
-{
-    DWORD   m_dwTryOffset;
-    DWORD   m_dwHandlerOffset;
-    DWORD   m_dwHandlerLength;
-    bool    m_fActive;
-};
-
-
-// Structure used to track enough information to identify a method (possibly generic or belonging to a generic class). Includes a
-// MethodDesc pointer and a SigTypeContext (values of class and method type parameters to narrow down the exact method being refered
-// to). The structure also contains a next pointer so that it can be placed in a singly linked list (see MethodContextStack below).
-struct MethodContext
-{
-    MethodContext  *m_pNext;            // Next MethodContext in a MethodContextStack list
-    MethodDesc     *m_pMethodDesc;      // Pointer to a MethodDesc
-    SigTypeContext  m_sTypeContext;     // Additional type parameter information to qualify the exact method targetted
-    bool            m_fRoot;            // Does this method contain a CER root of its own?
-
-    // Allocate and initialize a MethodContext from the per-thread stacking allocator (we assume the checkpoint has already been
-    // taken).
-    static MethodContext* PerThreadAllocate(MethodDesc *pMD, SigTypeContext *pTypeContext)
-    {
-        CONTRACTL {
-            THROWS;
-            GC_TRIGGERS;
-            MODE_ANY;
-        } CONTRACTL_END;
-
-
-        MethodContext *pContext = new (&GetThread()->m_MarshalAlloc) MethodContext();
-        pContext->m_pMethodDesc = pMD;
-        pContext->m_sTypeContext = *pTypeContext;
-        pContext->m_fRoot = false;
-
-        return pContext;
-    }
-
-    // Determine if two MethodContexts are equivalent (same MethodDesc pointer and identical arrays of TypeHandles in the
-    // TypeContext).
-    bool Equals(MethodContext *pOther)
-    {
-        WRAPPER_NO_CONTRACT;
-
-        if (pOther->m_pMethodDesc != m_pMethodDesc)
-            return false;
-
-        if (pOther->m_sTypeContext.m_classInst.GetNumArgs() != m_sTypeContext.m_classInst.GetNumArgs())
-            return false;
-
-        if (pOther->m_sTypeContext.m_methodInst.GetNumArgs() != m_sTypeContext.m_methodInst.GetNumArgs())
-            return false;
-
-        DWORD i;
-
-        for (i = 0; i < m_sTypeContext.m_classInst.GetNumArgs(); i++)
-            if (pOther->m_sTypeContext.m_classInst[i] != m_sTypeContext.m_classInst[i])
-                return false;
-
-        for (i = 0; i < m_sTypeContext.m_methodInst.GetNumArgs(); i++)
-            if (pOther->m_sTypeContext.m_methodInst[i] != m_sTypeContext.m_methodInst[i])
-                return false;
-
-        return true;
-    }
-
-#ifdef _DEBUG
-#define CER_DBG_MAX_OUT 4096
-    char *ToString()
-    {
-        STATIC_CONTRACT_THROWS;
-        STATIC_CONTRACT_GC_TRIGGERS;
-        STATIC_CONTRACT_MODE_ANY;
-
-        // Support up to two ToString calls before we re-use a buffer and overwrite previous output.
-        static char szOut1[CER_DBG_MAX_OUT];
-        static char szOut2[CER_DBG_MAX_OUT];
-        static char *pszOut = szOut1;
-
-        StackSString ssBuffer;
-        StackScratchBuffer ssScratch;
-
-        TypeString::AppendMethod(ssBuffer, m_pMethodDesc, m_sTypeContext.m_classInst, TypeString::FormatNamespace | TypeString::FormatAngleBrackets);
-        sprintf_s(&pszOut[0], CER_DBG_MAX_OUT, "%s", ssBuffer.GetUTF8(ssScratch));
-
-        char *pszReturn = pszOut;
-        pszOut = pszOut == szOut1 ? szOut2 : szOut1;
-        return pszReturn;
-    }
-#endif
-};
-
-// Maintains a stack of MethodContexts (implemented as a singly linked list with insert and remove operations only at the head).
-class MethodContextStack
-{
-    MethodContext  *m_pFirst;       // The head of the linked list
-    DWORD           m_cElements;    // Count of elements in the stack
-
-public:
-
-    // Initialize to an empty list.
-    MethodContextStack()
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        m_pFirst = NULL;
-        m_cElements = 0;
-    }
-
-    // Push a MethodContext pointer on the head of the list.
-    void Push(MethodContext *pContext)
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        pContext->m_pNext = m_pFirst;
-        m_pFirst = pContext;
-        m_cElements++;
-    }
-
-    // Remove and retrieve the most recently pushed MethodContext. Return NULL if no more entries exist.
-    MethodContext *Pop()
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        MethodContext* pContext = m_pFirst;
-        if (pContext == NULL)
-            return NULL;
-
-        m_pFirst = pContext->m_pNext;
-        m_cElements--;
-
-        return pContext;
-    }
-
-    // Return true if an MethodContext equivalent to the argument exists in the stack.
-    bool IsInStack(MethodContext *pMatchContext)
-    {
-        WRAPPER_NO_CONTRACT;
-
-        MethodContext* pContext = m_pFirst;
-        while (pContext) {
-            if (pContext->Equals(pMatchContext))
-                return true;
-            pContext = pContext->m_pNext;
-        }
-
-        return false;
-    }
-
-    // Get count of elements in the stack.
-    DWORD GetCount()
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        return m_cElements;
-    }
-};
-
-
-class MethodCallGraphPreparer
-{
-    MethodDesc *m_pRootMD;
-    SigTypeContext *m_pRootTypeContext;
-
-    COR_ILMETHOD_DECODER *m_pMethodDecoder; 
-    
-    MethodContextStack  m_sLeftToProcess;       // MethodContexts we have yet to look at in this call graph
-    MethodContextStack  m_sAlreadySeen;         // MethodContexts we've already processed at least once
-
-    EHClauseRange      *m_pEHClauses;           // Array of exception handling clauses in current method (only if !fEntireMethod)
-    DWORD               m_cEHClauses;           // Number of elements in above array
-    CerPrepInfo        *m_pCerPrepInfo;         // Context recording how much preparation this region has had
-    MethodContextStack  m_sPersist;             // MethodContexts we need to keep around past the 'prepare' phase of preparation
-#ifdef FEATURE_NATIVE_IMAGE_GENERATION
-    bool                m_fNgen;                // True when being called as part of an ngen
-    MethodContextStack  m_sRootMethods;         // Methods containing a sub-CER (excludes the real root)
-#endif // FEATURE_NATIVE_IMAGE_GENERATION
-    Thread             *m_pThread;              // Cached managed thread pointer (for allocations and the like)
-    bool                m_fPartialPreparation;  // True if we have unbound type vars at the CER root and can only prep one instantiation at a time
-
-    bool                m_fEntireMethod;        // True if are preparing for the entire method
-    bool                m_fExactTypeContext;
-    bool                m_fMethodHasCallsWithinExplicitCer; // True if method contains calls out from within an explicit PCER range
-
-    bool                m_fIgnoreVirtualCERCallMDA;  // True if VirtualCER MDA is not desirable to be fired
-
-    MethodCallGraphPreparer * m_pNext;          // Links this instance on a per-thread stack used to detect
-                                                // and defeat recursive preparations
-
-  public:
-    MethodCallGraphPreparer(MethodDesc *pRootMD, SigTypeContext *pRootTypeContext, bool fEntireMethod, bool fExactTypeContext, bool fIgnoreVirtualCERCallMDA = false);
-
-    // Walk the call graph of the method given by m_pRootMD (and type context in m_pRootTypeContext which provides instantiation information
-    // for generic methods/classes).
-    //
-    // If fEntireMethod is true then the entire body of pRootMD is scanned for callsites, otherwise we assume that one or more CER
-    // exception handlers exist in the method and only the finally and catch blocks of such handlers are scanned for graph roots.
-    //
-    // Each method we come across in the call graph (excluding late bound invocation destinations precipitated by virtual or interface
-    // calls) is jitted and has any generic dictionary information we can determine at jit time prepopulated. This includes implicit
-    // cctor invocations. If this method is called at ngen time we will attach extra fixup information to the affected method to ensure
-    // that fixing up the root method of the graph will cause all methods in the graph to be fixed up at that point also.
-    //
-    // Some generic dictionary entries may not be prepopulated if unbound type variables exist at the root of the call tree. Such cases
-    // will be ignored (as for the virtual/interface dispatch case we assume the caller will use an out-of-band mechanism to pre-prepare
-    // these entries explicitly).
-    //
-    // Returns true if the m_pRootMD contains a CER that calls outside the method. 
-    //
-    bool Run();
-    
-    // Methods used to control re-entrancy on the same thread. Essentially we'd like to avoid all re-entrancy
-    // (since it can lead to unbounded recursion easily) but unfortunately jitting methods during the
-    // preparation phase can cause this both directly (if we spot a sub-root) or indirectly (where implicit
-    // jit execution of a cctor causes a possibly unrelated CER graph to be prepared). The algorithm we use to
-    // avoid this records a stack of preparations attempts on the current thread (implemented via a singly
-    // linked list of the MethodCallGraphPreparer instances). Re-entrant prepare requests become noops if
-    // they're for a root method we're already processing (anywhere in the stack) and run to completion
-    // otherwise. This prevents infinite recursion since it removes at least one method from the intersection
-    // of the CER call graphs on each iteration. Theoretically it might not be the most efficient solution
-    // since there might still be a lot of overlap between graphs, but in practice the number of sub-CER roots
-    // is likely to be small and we won't recurse very far. This will still allow a re-entrant preparation
-    // that is the result of running a cctor to potentially early-out (and thus allow code to run before its
-    // CERs have been fully prepped). But this should only happen when a CER causes (directly or indirectly) a
-    // cctor to run that depends on that CER having been prepared already, which we really can't do much
-    // about.
-    //
-    BOOL CanPreparationProceed(MethodDesc * pMD, SigTypeContext * pTypeContext);
-
-    static void BeginPrepareCerForHolder(MethodCallGraphPreparer *pPrepState);
-    static void EndPrepareCerForHolder(MethodCallGraphPreparer *pPrepState);
-
-    typedef Holder<MethodCallGraphPreparer*, BeginPrepareCerForHolder, EndPrepareCerForHolder> ThreadPreparingCerHolder;
-
-  private:
-    void GetEHClauses();
-    void MarkEHClauseActivatedByCERCall(MethodContext *pContext, BYTE *pbIL, DWORD cbIL);
-    bool CheckIfCallsiteWithinCER(DWORD dwOffset);
-    bool ShouldGatherExplicitCERCallInfo();
-    void LookForInterestingCallsites(MethodContext *pContext);
-    void PrepareMethods();
-    bool RecordResults();
-};
-
-// Determines whether the given method contains a CER root that can be pre-prepared (i.e. prepared at jit time).
-bool ContainsPrePreparableCerRoot(MethodDesc *pMD);
-
-// Prepares the critical finalizer call graph for the given object type (which must derive from CriticalFinalizerObject). This
-// involves preparing at least the finalizer method and possibly some others (for SafeHandle and CriticalHandle derivations). If a
-// module pointer is supplied then only the critical methods introduced in that module are prepared (this is used at ngen time to
-// ensure that we're only generating ngen preparation info for the targetted module).
-void PrepareCriticalFinalizerObject(MethodTable *pMT, Module *pModule = NULL);
-
-void PrepareMethodDesc(MethodDesc* pMD, Instantiation classInst = Instantiation(), Instantiation methodInst = Instantiation(), BOOL onlyContractedMethod = FALSE, BOOL fIgnoreVirtualCERCallMDA = FALSE);
-// Determine whether the method given as a parameter is the root of a CER.
-// @todo: Need an x86 offset as well and logic to determine whether we're actually in a root-CER portion of the method (if the whole
-// thing isn't the root).
-bool IsCerRootMethod(MethodDesc *pMD);
-
-// Fill the cache of overflowed generic dictionary entries that the jit maintains with all the overflow slots stored so far in the
-// dictionary layout.
-void PrepopulateGenericHandleCache(DictionaryLayout  *pDictionaryLayout,
-                                   MethodDesc        *pMD,
-                                   MethodTable       *pMT);
-    
-DWORD GetReliabilityContract(IMDInternalImport *pImport, mdToken tkParent);
-
-#ifdef FEATURE_PREJIT
-
-// Prepare the class if it is derived from CriticalFinalizerObject. This is used at ngen time since such classes are normally 
-// prepared at runtime (at instantiation) and would therefore miss the ngen image.
-void PrepareCriticalType(MethodTable *pMT);
-
-// Prepare a method and its statically determinable call graph if a hint attribute has been applied. This is only called at ngen
-// time to save additional preparation information into the ngen image that wouldn't normally be there (and thus lower runtime
-// overheads).
-void PrePrepareMethodIfNecessary(CORINFO_METHOD_HANDLE hMethod);
-
-#endif
-
-
-// A fixed sized hash table keyed by pointers and storing two bits worth of value for every entry. The value is stored in the low
-// order bits of the keys, so the pointers must be at least DWORD aligned. No hash table expansion occurs so new entries will sooner
-// or later overwrite old. The implementation uses no locks (all accesses are single aligned pointer sized operations and therefore
-// inherently atomic).
-// The purpose of this table is to store a smallish number of reliability contract levels for the most recently queried methods,
-// mainly for the purpose of speeding up thread abort processing (where we will walk the stack probing methods for contracts,
-// sometimes repeatedly). So we use a small fixed sized hash to speed up lookups on average but avoid impacting working set.
-#define PHC_BUCKETS     29
-#define PHC_CHAIN       5
-#define PHC_DATA_MASK   3
-
-class PtrHashCache
-{
-public:
-    PtrHashCache();
-    bool Lookup(void *pKey, DWORD *pdwValue);
-    void Add(void *pKey, DWORD dwValue);
-
-#ifdef _DEBUG
-    void DbgDumpStats();
-#endif
-
-private:
-    DWORD GetHash(void *pKey);
-
-    UINT_PTR    m_rEntries[PHC_BUCKETS * PHC_CHAIN];
-
-#ifdef _DEBUG
-    DWORD       m_dwHits;
-    DWORD       m_dwMisses;
-#endif
-};
-
-#endif // FEATURE_CER
-
-#endif
diff --git a/src/vm/coreassemblyspec.cpp b/src/vm/coreassemblyspec.cpp
index 310c663392..7cb1f56315 100644
--- a/src/vm/coreassemblyspec.cpp
+++ b/src/vm/coreassemblyspec.cpp
@@ -24,7 +24,6 @@
 #include "compile.h"
 #endif
 
-#ifndef FEATURE_FUSION
 
 #include "../binder/inc/textualidentityparser.hpp"
 #include "../binder/inc/assemblyidentity.hpp"
@@ -85,7 +84,6 @@ STDAPI BinderGetDisplayName(PEAssembly *pAssembly,
 }
 
 
-#ifdef FEATURE_VERSIONING
 
 static VOID ThrowLoadError(AssemblySpec * pSpec, HRESULT hr)
 {
@@ -222,7 +220,6 @@ VOID  AssemblySpec::Bind(AppDomain      *pAppDomain,
     }
 }
 
-#endif // FEATURE_VERSIONING
 
 STDAPI BinderAcquirePEImage(LPCWSTR   wszAssemblyPath,
                             PEImage **ppPEImage,
@@ -355,13 +352,13 @@ HRESULT BaseAssemblySpec::ParseName()
 
         if (pIUnknownBinder != NULL)
         {
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#if !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
             if (pDomain->GetFusionContext() != pDomain->GetTPABinderContext())
             {
                 pAppContext = (static_cast<CLRPrivBinderAssemblyLoadContext *>(pIUnknownBinder))->GetAppContext();
             }
             else
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#endif // !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
             {
                 pAppContext = (static_cast<CLRPrivBinderCoreCLR *>(pIUnknownBinder))->GetAppContext();
             }
@@ -595,104 +592,4 @@ VOID BaseAssemblySpec::GetFileOrDisplayName(DWORD flags, SString &result) const
                                                               result));
 }
 
-#ifndef FEATURE_CORECLR
 
-//
-// Trivial assembly binder for desktop crossgen
-//
-
-VOID  AssemblySpec::Bind(AppDomain      *pAppDomain,
-                             BOOL            fThrowOnFileNotFound,
-                             CoreBindResult *pResult,
-                             BOOL fNgenExplicitBind /* = FALSE */,
-                             BOOL fExplicitBindToNativeImage /* = FALSE */,
-                             StackCrawlMark *pCallerStackMark /* = NULL */)
-{
-    PEImageHolder pImage;
-    BOOL fNativeImage = FALSE;
-
-    if (GetCodeBase() != NULL)
-    {
-        // Normalize the path to maintain identity
-        SString sFullAssemblyPath;
-        Clr::Util::Win32::GetFullPathName(GetCodeBase(), sFullAssemblyPath, NULL);
-
-        pImage = PEImage::OpenImage(sFullAssemblyPath, MDInternalImport_Default);
-    }
-    else
-    {
-        SString sSimpleName(SString::Utf8, m_pAssemblyName);
-
-        fNativeImage = !IsReadyToRunCompilation() && pAppDomain->ToCompilationDomain()->IsInHardBindList(sSimpleName);
-
-        SString sFileName(sSimpleName, fNativeImage ? W(".ni.dll") : W(".dll"));
-
-        if (!CompilationDomain::FindImage(sFileName,
-                fNativeImage ?  MDInternalImport_TrustedNativeImage : MDInternalImport_Default,
-                &pImage))
-        {
-            sFileName.Set(sSimpleName, fNativeImage ? W(".ni.exe") : W(".exe"));
-
-            if (!CompilationDomain::FindImage(sFileName,
-                    fNativeImage ?  MDInternalImport_TrustedNativeImage : MDInternalImport_Default,
-                    &pImage))
-            {
-                EEFileLoadException::Throw(sSimpleName, COR_E_FILENOTFOUND);
-            }
-        }
-    }
-
-    GetSvcLogger()->Printf(W("Loading %s\n"), pImage->GetPath().GetUnicode());
-
-    NewHolder<BINDER_SPACE::Assembly> pAssembly;
-    pAssembly = new BINDER_SPACE::Assembly();
-
-    pAssembly->m_assemblyPath.Set(pImage->GetPath());
-
-    if (fNativeImage)
-        pAssembly->SetNativePEImage(pImage.Extract());
-    else
-        pAssembly->SetPEImage(pImage.Extract());
-
-    pResult->Init(pAssembly.Extract(), TRUE, TRUE);
-}
-
-VOID AssemblySpec::BindToSystem(BINDER_SPACE::Assembly** ppAssembly)
-{
-    PEImageHolder pImage;
-    BOOL fNativeImage = FALSE;
-
-    _ASSERTE(ppAssembly != nullptr);
-
-    if (g_fAllowNativeImages)
-    {
-        if (CompilationDomain::FindImage(W("mscorlib.ni.dll"), MDInternalImport_TrustedNativeImage, &pImage))
-            fNativeImage = TRUE;
-    }
-
-    if (!fNativeImage)
-    {
-        if (!CompilationDomain::FindImage(W("mscorlib.dll"), MDInternalImport_Default, &pImage))
-        {
-            EEFileLoadException::Throw(W("mscorlib.dll"), COR_E_FILENOTFOUND);
-        }
-    }
-
-    GetSvcLogger()->Printf(W("Loading %s\n"), pImage->GetPath().GetUnicode());
-
-    NewHolder<BINDER_SPACE::Assembly> pAssembly;
-    pAssembly = new BINDER_SPACE::Assembly();
-
-    pAssembly->m_assemblyPath.Set(pImage->GetPath());
-
-    if (fNativeImage)
-        pAssembly->SetNativePEImage(pImage.Extract());
-    else
-        pAssembly->SetPEImage(pImage.Extract());
-
-    *ppAssembly = pAssembly.Extract();
-}
-
-#endif // !FEATURE_CORECLR
-
-#endif // FEATURE_FUSION
diff --git a/src/vm/corebindresult.cpp b/src/vm/corebindresult.cpp
index 68803e24b9..3013264ade 100644
--- a/src/vm/corebindresult.cpp
+++ b/src/vm/corebindresult.cpp
@@ -15,7 +15,6 @@
 
 #include "../binder/inc/assembly.hpp"
 
-#ifndef FEATURE_FUSION
 #ifndef DACCESS_COMPILE
 
 STDMETHODIMP CoreBindResult::QueryInterface(REFIID   riid,
@@ -63,4 +62,3 @@ STDMETHODIMP_(ULONG) CoreBindResult::Release()
 
 
 #endif  // DACCES_COMPILE
-#endif // FEATURE_FUSION
diff --git a/src/vm/corhost.cpp b/src/vm/corhost.cpp
index 6091bad9e2..64f4e2b4cb 100644
--- a/src/vm/corhost.cpp
+++ b/src/vm/corhost.cpp
@@ -27,7 +27,6 @@
 #include "ipcmanagerinterface.h"
 #endif // FEATURE_IPCMAN
 #include "comcallablewrapper.h"
-#include "hostexecutioncontext.h"
 #include "invokeutil.h"
 #include "appdomain.inl"
 #include "vars.hpp"
@@ -50,10 +49,6 @@
 #include "winrttypenameconverter.h"
 #endif
 
-#if defined(FEATURE_APPX_BINDER)
-#include "clrprivbinderappx.h"
-#include "clrprivtypecachewinrt.h"
-#endif
 
 GVAL_IMPL_INIT(DWORD, g_fHostConfig, 0);
 
@@ -89,395 +84,9 @@ extern BOOL g_fEEHostedStartup;
 INT64 g_PauseTime;         // Total time in millisecond the CLR has been paused
 Volatile<BOOL> g_IsPaused;  // True if the runtime is paused (FAS)
 CLREventStatic g_ClrResumeEvent; // Event that is fired at FAS Resuming 
-#ifndef FEATURE_CORECLR
-CLREventStatic g_PauseCompletedEvent; // Set when Pause has completed its work on another thread.
-#endif
 
-#if defined(FEATURE_CORECLR)
 extern BYTE g_rbTestKeyBuffer[];
-#endif
-
-#if !defined(FEATURE_CORECLR)
-//******************************************************************************
-// <TODO>TODO: ICorThreadpool: Move this into a separate file CorThreadpool.cpp
-// after the move to VBL </TODO>
-//******************************************************************************
-
-HRESULT STDMETHODCALLTYPE  CorThreadpool::CorRegisterWaitForSingleObject(PHANDLE phNewWaitObject,
-                                                                         HANDLE hWaitObject,
-                                                                         WAITORTIMERCALLBACK Callback,
-                                                                         PVOID Context,
-                                                                         ULONG timeout,
-                                                                         BOOL  executeOnlyOnce,
-                                                                         BOOL* pResult)
-{
-    CONTRACTL
-    {
-        DISABLED(NOTHROW);
-        GC_TRIGGERS;
-        MODE_ANY;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = E_UNEXPECTED;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    ULONG flag = executeOnlyOnce ? WAIT_SINGLE_EXECUTION : 0;
-    *pResult = FALSE;
-    EX_TRY
-    {
-        *pResult = ThreadpoolMgr::RegisterWaitForSingleObject(phNewWaitObject,
-                                                  hWaitObject,
-                                                  Callback,
-                                                  Context,
-                                                  timeout,
-                                                  flag);
-
-        hr = (*pResult ? S_OK : HRESULT_FROM_GetLastError());
-    }
-    EX_CATCH
-    {
-        hr = GET_EXCEPTION()->GetHR();
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-
-    END_ENTRYPOINT_NOTHROW;
-
-    return hr;
-}
-
-
-HRESULT STDMETHODCALLTYPE  CorThreadpool::CorBindIoCompletionCallback(HANDLE fileHandle,
-                                                                      LPOVERLAPPED_COMPLETION_ROUTINE callback)
-{
-    CONTRACTL
-    {
-        DISABLED(NOTHROW);
-        GC_TRIGGERS;
-        MODE_ANY;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = E_UNEXPECTED;
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    BOOL ret = FALSE;
-    DWORD errCode = 0;
-
-    EX_TRY
-    {
-        ret = ThreadpoolMgr::BindIoCompletionCallback(fileHandle,callback,0, errCode);
-        hr = (ret ? S_OK : HRESULT_FROM_WIN32(errCode));
-    }
-    EX_CATCH
-    {
-        hr = GET_EXCEPTION()->GetHR();
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-
-    END_ENTRYPOINT_NOTHROW;
-
-    return hr;
-}
-
-
-HRESULT STDMETHODCALLTYPE  CorThreadpool::CorUnregisterWait(HANDLE hWaitObject,
-                                                            HANDLE CompletionEvent,
-                                                            BOOL* pResult)
-{
-    CONTRACTL
-    {
-        DISABLED(NOTHROW);
-        GC_TRIGGERS;
-        MODE_ANY;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = E_UNEXPECTED;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
 
-    *pResult = FALSE;
-    EX_TRY
-    {
-
-        *pResult = ThreadpoolMgr::UnregisterWaitEx(hWaitObject,CompletionEvent);
-        hr = (*pResult ? S_OK : HRESULT_FROM_GetLastError());
-    }
-    EX_CATCH
-    {
-        hr = GET_EXCEPTION()->GetHR();
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-
-    END_ENTRYPOINT_NOTHROW;
-
-    return hr;
-
-}
-
-HRESULT STDMETHODCALLTYPE  CorThreadpool::CorQueueUserWorkItem(LPTHREAD_START_ROUTINE Function,
-                                                               PVOID Context,BOOL executeOnlyOnce,
-                                                               BOOL* pResult )
-{
-    CONTRACTL
-    {
-        DISABLED(NOTHROW);
-        GC_TRIGGERS;
-        MODE_ANY;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = E_UNEXPECTED;
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    *pResult = FALSE;
-    EX_TRY
-    {
-        *pResult = ThreadpoolMgr::QueueUserWorkItem(Function,Context,QUEUE_ONLY);
-        hr = (*pResult ? S_OK : HRESULT_FROM_GetLastError());
-    }
-    EX_CATCH
-    {
-        hr = GET_EXCEPTION()->GetHR();
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-
-    END_ENTRYPOINT_NOTHROW;
-    return hr;
-}
-
-HRESULT STDMETHODCALLTYPE  CorThreadpool::CorCallOrQueueUserWorkItem(LPTHREAD_START_ROUTINE Function,
-                                                                     PVOID Context,
-                                                                     BOOL* pResult )
-{
-    CONTRACTL
-    {
-        DISABLED(NOTHROW);
-        GC_TRIGGERS;
-        MODE_ANY;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = E_UNEXPECTED;
-    BEGIN_ENTRYPOINT_NOTHROW;
-    *pResult = FALSE;
-    EX_TRY
-    {
-        *pResult = ThreadpoolMgr::QueueUserWorkItem(Function,Context,CALL_OR_QUEUE);
-        hr = (*pResult ? S_OK : HRESULT_FROM_GetLastError());
-    }
-    EX_CATCH
-    {
-        hr = GET_EXCEPTION()->GetHR();
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-    END_ENTRYPOINT_NOTHROW;
-    return hr;
-}
-
-
-HRESULT STDMETHODCALLTYPE  CorThreadpool::CorCreateTimer(PHANDLE phNewTimer,
-                                                         WAITORTIMERCALLBACK Callback,
-                                                         PVOID Parameter,
-                                                         DWORD DueTime,
-                                                         DWORD Period,
-                                                         BOOL* pResult)
-{
-    CONTRACTL
-    {
-        DISABLED(NOTHROW);
-        GC_TRIGGERS;
-        MODE_ANY;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = E_UNEXPECTED;
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    *pResult = FALSE;
-    EX_TRY
-    {
-        *pResult = ThreadpoolMgr::CreateTimerQueueTimer(phNewTimer,Callback,Parameter,DueTime,Period,0);
-        hr = (*pResult ? S_OK : HRESULT_FROM_GetLastError());
-    }
-    EX_CATCH
-    {
-        hr = GET_EXCEPTION()->GetHR();
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-
-    END_ENTRYPOINT_NOTHROW;
-    return hr;
-}
-
-
-HRESULT STDMETHODCALLTYPE  CorThreadpool::CorDeleteTimer(HANDLE Timer, HANDLE CompletionEvent, BOOL* pResult)
-{
-    CONTRACTL
-    {
-        DISABLED(NOTHROW);
-        GC_TRIGGERS;
-        MODE_ANY;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = E_UNEXPECTED;
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    *pResult = FALSE;
-    EX_TRY
-    {
-        *pResult = ThreadpoolMgr::DeleteTimerQueueTimer(Timer,CompletionEvent);
-        hr = (*pResult ? S_OK : HRESULT_FROM_GetLastError());
-    }
-    EX_CATCH
-    {
-        hr = GET_EXCEPTION()->GetHR();
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-
-    END_ENTRYPOINT_NOTHROW;
-    return hr;
-}
-
-HRESULT STDMETHODCALLTYPE  CorThreadpool::CorChangeTimer(HANDLE Timer,
-                                                         ULONG DueTime,
-                                                         ULONG Period,
-                                                         BOOL* pResult)
-{
-    CONTRACTL
-    {
-        DISABLED(NOTHROW);
-        GC_TRIGGERS;
-        MODE_ANY;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = E_UNEXPECTED;
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    *pResult = FALSE;
-    EX_TRY
-    {
-        //CONTRACT_VIOLATION(ThrowsViolation);
-        *pResult = ThreadpoolMgr::ChangeTimerQueueTimer(Timer,DueTime,Period);
-        hr = (*pResult ? S_OK : HRESULT_FROM_GetLastError());
-    }
-    EX_CATCH
-    {
-        hr = GET_EXCEPTION()->GetHR();
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-
-    END_ENTRYPOINT_NOTHROW;
-    return hr;
-}
-
-
-HRESULT STDMETHODCALLTYPE CorThreadpool::CorSetMaxThreads(DWORD MaxWorkerThreads,
-                                                          DWORD MaxIOCompletionThreads)
-{
-    CONTRACTL
-    {
-        DISABLED(NOTHROW);
-        GC_TRIGGERS;
-        MODE_ANY;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = E_UNEXPECTED;
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    BOOL result = FALSE;
-    EX_TRY
-    {
-        result = ThreadpoolMgr::SetMaxThreads(MaxWorkerThreads, MaxIOCompletionThreads);
-        hr = (result ? S_OK : E_FAIL);
-    }
-    EX_CATCH
-    {
-        hr = GET_EXCEPTION()->GetHR();
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-
-    END_ENTRYPOINT_NOTHROW;
-    return hr;
-}
-
-HRESULT STDMETHODCALLTYPE CorThreadpool::CorGetMaxThreads(DWORD *MaxWorkerThreads,
-                                                          DWORD *MaxIOCompletionThreads)
-{
-    CONTRACTL
-    {
-        DISABLED(NOTHROW);
-        GC_TRIGGERS;
-        MODE_ANY;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = E_UNEXPECTED;
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    BOOL result = FALSE;
-    EX_TRY
-    {
-        result = ThreadpoolMgr::GetMaxThreads(MaxWorkerThreads, MaxIOCompletionThreads);
-        hr = (result ? S_OK : E_FAIL);
-    }
-    EX_CATCH
-    {
-        hr = GET_EXCEPTION()->GetHR();
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-
-    END_ENTRYPOINT_NOTHROW;
-    return hr;
-}
-
-HRESULT STDMETHODCALLTYPE CorThreadpool::CorGetAvailableThreads(DWORD *AvailableWorkerThreads,
-                                                                DWORD *AvailableIOCompletionThreads)
-{
-    CONTRACTL
-    {
-        DISABLED(NOTHROW);
-        GC_TRIGGERS;
-        MODE_ANY;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = E_UNEXPECTED;
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    BOOL result = FALSE;
-    EX_TRY
-    {
-        result = ThreadpoolMgr::GetAvailableThreads(AvailableWorkerThreads, AvailableIOCompletionThreads);
-        hr = (result ? S_OK : E_FAIL);
-    }
-    EX_CATCH
-    {
-        hr = GET_EXCEPTION()->GetHR();
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-
-    END_ENTRYPOINT_NOTHROW;
-
-    return hr;
-}
-#endif // !defined(FEATURE_CORECLR)
 //***************************************************************************
 
 ULONG CorRuntimeHostBase::m_Version = 0;
@@ -666,102 +275,9 @@ CrstStatic CCLRDebugManager::m_lockConnectionNameTable;
 #ifndef DACCESS_COMPILE
 
 
-#if !defined(FEATURE_CORECLR) // simple hosting
-//*****************************************************************************
-// ICorRuntimeHost
-//*****************************************************************************
-extern BOOL g_singleVersionHosting;
-
-// *** ICorRuntimeHost methods ***
-// Returns an object for configuring the runtime prior to
-// it starting. If the runtime has been initialized this
-// routine returns an error. See ICorConfiguration.
-HRESULT CorHost::GetConfiguration(ICorConfiguration** pConfiguration)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-    HRESULT hr=E_FAIL;
-    BEGIN_ENTRYPOINT_NOTHROW;
-    if (CorHost::GetHostVersion() != 1)
-    {
-        hr=HOST_E_INVALIDOPERATION;
-    }
-    else
-    if (!pConfiguration)
-        hr= E_POINTER;
-    else
-    if (!m_Started)
-    {
-        *pConfiguration = (ICorConfiguration *) this;
-        AddRef();
-        hr=S_OK;
-    }
-    END_ENTRYPOINT_NOTHROW;
-    // Cannot obtain configuration after the runtime is started
-    return hr;
-}
-
-STDMETHODIMP CorHost::Start(void)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr;
-    BEGIN_ENTRYPOINT_NOTHROW;
-    hr = CorRuntimeHostBase::Start();
-
-    END_ENTRYPOINT_NOTHROW;
-
-    if (hr == S_FALSE)
-    {
-        // This is to keep v1 behavior.
-        hr = S_OK;
-    }
-    return(hr);
-}
-#endif // !defined(FEATURE_CORECLR)
 
 
 // *** ICorRuntimeHost methods ***
-#ifndef FEATURE_CORECLR
-// Returns an object for configuring the runtime prior to
-// it starting. If the runtime has been initialized this
-// routine returns an error. See ICorConfiguration.
-HRESULT CorHost2::GetConfiguration(ICorConfiguration** pConfiguration)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    if (!pConfiguration)
-        return E_POINTER;
-    HRESULT hr=E_FAIL;
-    BEGIN_ENTRYPOINT_NOTHROW;
-    if (!m_Started)
-    {
-        *pConfiguration = (ICorConfiguration *) this;
-        AddRef();
-        hr=S_OK;
-    }
-    END_ENTRYPOINT_NOTHROW;
-    // Cannot obtain configuration after the runtime is started
-    return hr;
-}
-#endif // FEATURE_CORECLR
 
 extern BOOL g_fWeOwnProcess;
 
@@ -769,11 +285,9 @@ CorHost2::CorHost2()
 {
     LIMITED_METHOD_CONTRACT;
 
-#ifdef FEATURE_CORECLR
     m_fStarted = FALSE;
     m_fFirstToLoadCLR = FALSE;
     m_fAppDomainCreated = FALSE;
-#endif // FEATURE_CORECLR
 }
 
 static DangerousNonHostedSpinLock lockOnlyOneToInvokeStart;
@@ -791,7 +305,6 @@ STDMETHODIMP CorHost2::Start()
 
     BEGIN_ENTRYPOINT_NOTHROW;
 
-#ifdef FEATURE_CORECLR
     // Ensure that only one thread at a time gets in here
     DangerousNonHostedSpinLockHolder lockHolder(&lockOnlyOneToInvokeStart);
         
@@ -821,7 +334,6 @@ STDMETHODIMP CorHost2::Start()
         }
     }
     else
-#endif // FEATURE_CORECLR
     {
         // Using managed C++ libraries, its possible that when the runtime is already running,
         // MC++ will use CorBindToRuntimeEx to make callbacks into specific appdomain of its
@@ -842,7 +354,6 @@ STDMETHODIMP CorHost2::Start()
         hr = CorRuntimeHostBase::Start();
         if (SUCCEEDED(hr))
         {
-#ifdef FEATURE_CORECLR
             // Set our flag that this host invoked the Start method.
             m_fStarted = TRUE;
 
@@ -855,7 +366,6 @@ STDMETHODIMP CorHost2::Start()
             // So, if you want to do that, just make sure you are the first host to load the
             // specific version of CLR in memory AND start it.
             m_fFirstToLoadCLR = TRUE;
-#endif // FEATURE_CORECLR
             if (FastInterlockIncrement(&m_RefCount) != 1)
             {
             }
@@ -901,21 +411,6 @@ HRESULT CorRuntimeHostBase::Start()
     return hr;
 }
 
-#if !defined(FEATURE_CORECLR) // simple hosting
-HRESULT CorHost::Stop()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        ENTRY_POINT;
-        if (GetThread()) {GC_TRIGGERS;} else {DISABLED(GC_NOTRIGGER);}
-    }
-    CONTRACTL_END;
-
-    // This must remain this way (that is doing nothing) for backwards compat reasons.
-    return S_OK;
-}
-#endif // !defined(FEATURE_CORECLR)
 
 HRESULT CorHost2::Stop()
 {
@@ -933,7 +428,6 @@ HRESULT CorHost2::Stop()
     HRESULT hr=S_OK;
     BEGIN_ENTRYPOINT_NOTHROW;
 
-#ifdef FEATURE_CORECLR
     // Is this host eligible to invoke the Stop method?
     if ((!m_fStarted) && (!m_fFirstToLoadCLR))
     {
@@ -944,28 +438,21 @@ HRESULT CorHost2::Stop()
         hr = HOST_E_CLRNOTAVAILABLE;
     }
     else
-#endif // FEATURE_CORECLR
     {
         while (TRUE)
         {
             LONG refCount = m_RefCount;
             if (refCount == 0)
             {
-    #ifdef FEATURE_CORECLR
                 hr = HOST_E_CLRNOTAVAILABLE;
-    #else // !FEATURE_CORECLR
-                hr= E_UNEXPECTED;
-    #endif // FEATURE_CORECLR
                 break;
             }
             else
             if (FastInterlockCompareExchange(&m_RefCount, refCount - 1, refCount) == refCount)
             {
-    #ifdef FEATURE_CORECLR
                 // Indicate that we have got a Stop for a corresponding Start call from the
                 // Host. Semantically, CoreCLR has stopped for them.
                 m_fStarted = FALSE;
-    #endif // FEATURE_CORECLR
 
                 if (refCount > 1)
                 {
@@ -979,125 +466,12 @@ HRESULT CorHost2::Stop()
             }
         }
     }
-#ifndef  FEATURE_CORECLR    
-    if (hr==S_OK)
-    {
-        EPolicyAction action = GetEEPolicy()->GetDefaultAction(OPR_ProcessExit, NULL);
-        if (action > eExitProcess)
-        {
-            g_fFastExitProcess = 1;
-        }
-        EEShutDown(FALSE);
-    }
-#endif // FEATURE_CORECLR     
     END_ENTRYPOINT_NOTHROW;
 
-#ifndef FEATURE_CORECLR
-    if (hr == S_OK)
-    {
-        if (m_HostControl)
-        {
-            m_HostControl->Release();
-            m_HostControl = NULL;
-        }
-    }
-#endif // FEATURE_CORECLR
 
     return hr;
 }
 
-#if defined(FEATURE_COMINTEROP) && !defined(FEATURE_CORECLR)
-
-// Creates a domain in the runtime. The identity array is
-// a pointer to an array TYPE containing IIdentity objects defining
-// the security identity.
-HRESULT CorRuntimeHostBase::CreateDomain(LPCWSTR pwzFriendlyName,
-                                         IUnknown* pIdentityArray, // Optional
-                                         IUnknown ** pAppDomain)
-{
-    WRAPPER_NO_CONTRACT;
-    STATIC_CONTRACT_ENTRY_POINT;
-
-    return CreateDomainEx(pwzFriendlyName,
-                          NULL,
-                          NULL,
-                          pAppDomain);
-}
-
-
-// Returns the default domain.
-HRESULT CorRuntimeHostBase::GetDefaultDomain(IUnknown ** pAppDomain)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_PREEMPTIVE;
-        ENTRY_POINT;
-    } CONTRACTL_END;
-
-    HRESULT hr = E_UNEXPECTED;
-    if (!g_fEEStarted)
-        return hr;
-
-    if( pAppDomain == NULL)
-        return E_POINTER;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    BEGIN_EXTERNAL_ENTRYPOINT(&hr);
-    {
-        GCX_COOP_THREAD_EXISTS(GET_THREAD());
-
-        if (SystemDomain::System()) {
-            AppDomain* pCom = SystemDomain::System()->DefaultDomain();
-            if(pCom)
-                hr = pCom->GetComIPForExposedObject(pAppDomain);
-        }
-
-    }
-    END_EXTERNAL_ENTRYPOINT;
-    END_ENTRYPOINT_NOTHROW;
-
-    return hr;
-}
-
-// Returns the default domain.
-HRESULT CorRuntimeHostBase::CurrentDomain(IUnknown ** pAppDomain)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        MODE_PREEMPTIVE;
-        ENTRY_POINT;
-        if (GetThread()) {GC_TRIGGERS;} else {DISABLED(GC_NOTRIGGER);}
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = E_UNEXPECTED;
-    if (!g_fEEStarted)
-        return hr;
-
-   if( pAppDomain == NULL) return E_POINTER;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    BEGIN_EXTERNAL_ENTRYPOINT(&hr);
-    {
-        GCX_COOP_THREAD_EXISTS(GET_THREAD());
-
-        AppDomain* pCom = ::GetAppDomain();
-        if(pCom)
-            hr = pCom->GetComIPForExposedObject(pAppDomain);
-
-    }
-    END_EXTERNAL_ENTRYPOINT;
-    END_ENTRYPOINT_NOTHROW;
-
-    return hr;
-};
-
-#endif // FEATURE_COMINTEROP && !FEATURE_CORECLR
 
 HRESULT CorHost2::GetCurrentAppDomainId(DWORD *pdwAppDomainId)
 {
@@ -1113,9 +487,7 @@ HRESULT CorHost2::GetCurrentAppDomainId(DWORD *pdwAppDomainId)
     // We use CanRunManagedCode() instead of IsRuntimeActive() because this allows us
     // to specify test using the form that does not trigger a GC.
     if (!(g_fEEStarted && CanRunManagedCode(LoaderLockCheck::None))
-#ifdef FEATURE_CORECLR
         || !m_fStarted
-#endif    
     )
     {
         return HOST_E_CLRNOTAVAILABLE;
@@ -1154,64 +526,9 @@ HRESULT CorHost2::ExecuteApplication(LPCWSTR   pwzAppFullName,
                                      LPCWSTR   *ppwzActivationData,
                                      int       *pReturnValue)
 {
-#ifndef FEATURE_CORECLR
-    // This API should not be called when the EE has already been started.
-    HRESULT hr = E_UNEXPECTED;
-    if (g_fEEStarted)
-        return hr;
-
-    //
-    // We will let unhandled exceptions in the activated application
-    // propagate all the way up, so that ClickOnce semi-trusted apps
-    // can participate in the Dr Watson program, etc...
-    //
-
-    CONTRACTL {
-        THROWS;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    if (!pwzAppFullName)
-        IfFailGo(E_POINTER);
-
-    // Set the information about the application to execute.
-    CorCommandLine::m_pwszAppFullName = (LPWSTR) pwzAppFullName;
-    CorCommandLine::m_dwManifestPaths = dwManifestPaths;
-    CorCommandLine::m_ppwszManifestPaths = (LPWSTR*) ppwzManifestPaths;
-    CorCommandLine::m_dwActivationData = dwActivationData;
-    CorCommandLine::m_ppwszActivationData = (LPWSTR*) ppwzActivationData;
-
-    // Start up the EE.
-    IfFailGo(Start());
-
-    Thread *pThread;
-    pThread = GetThread();
-    if (pThread == NULL)
-        pThread = SetupThreadNoThrow(&hr);
-    if (pThread == NULL)
-        goto ErrExit;
-
-    _ASSERTE (!pThread->PreemptiveGCDisabled());
-
-    hr = S_OK;
-
-    BEGIN_ENTRYPOINT_THROWS_WITH_THREAD(pThread);
-    ENTER_DOMAIN_PTR(SystemDomain::System()->DefaultDomain(),ADV_DEFAULTAD)
-
-    SystemDomain::ActivateApplication(pReturnValue);
-
-    END_DOMAIN_TRANSITION;
-    END_ENTRYPOINT_THROWS_WITH_THREAD;
-
-ErrExit:
-    return hr;
-#else // FEATURE_CORECLR
     return E_NOTIMPL;
-#endif
 }
 
-#ifdef FEATURE_CORECLR
 /*
  * This method processes the arguments sent to the host which are then used
  * to invoke the main method.
@@ -1363,7 +680,6 @@ ErrExit:
 
     return hr;
 }
-#endif
 
 HRESULT CorHost2::ExecuteInDefaultAppDomain(LPCWSTR pwzAssemblyPath,
                                             LPCWSTR pwzTypeName,
@@ -1380,98 +696,15 @@ HRESULT CorHost2::ExecuteInDefaultAppDomain(LPCWSTR pwzAssemblyPath,
 
     // No point going further if the runtime is not running...
     if (!IsRuntimeActive()
-#ifdef FEATURE_CORECLR
         || !m_fStarted
-#endif    
     )
     {
         return HOST_E_CLRNOTAVAILABLE;
     }   
    
     
-#ifndef FEATURE_CORECLR
-    if(! (pwzAssemblyPath && pwzTypeName && pwzMethodName) )
-        return E_POINTER;
-
-    HRESULT hr = S_OK;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    Thread *pThread = GetThread();
-    if (pThread == NULL)
-    {
-        pThread = SetupThreadNoThrow(&hr);
-        if (pThread == NULL)
-        {
-            goto ErrExit;
-    }
-    }
-
-    _ASSERTE (!pThread->PreemptiveGCDisabled());
-
-    EX_TRY
-    {
-    ENTER_DOMAIN_PTR(SystemDomain::System()->DefaultDomain(),ADV_DEFAULTAD)
-
-    INSTALL_UNWIND_AND_CONTINUE_HANDLER;
-
-    Assembly *pAssembly = AssemblySpec::LoadAssembly(pwzAssemblyPath);
-
-    SString szTypeName(pwzTypeName);
-    StackScratchBuffer buff1;
-    const char* szTypeNameUTF8 = szTypeName.GetUTF8(buff1);
-    MethodTable *pMT = ClassLoader::LoadTypeByNameThrowing(pAssembly,
-                                                           NULL,
-                                                           szTypeNameUTF8).AsMethodTable();
-
-    SString szMethodName(pwzMethodName);
-    StackScratchBuffer buff;
-    const char* szMethodNameUTF8 = szMethodName.GetUTF8(buff);
-    MethodDesc *pMethodMD = MemberLoader::FindMethod(pMT, szMethodNameUTF8, &gsig_SM_Str_RetInt);
-
-    if (!pMethodMD)
-    {
-        hr = COR_E_MISSINGMETHOD;
-    }
-    else
-    {
-        GCX_COOP();
-
-        MethodDescCallSite method(pMethodMD);
-
-        STRINGREF sref = NULL;
-        GCPROTECT_BEGIN(sref);
-
-        if (pwzArgument)
-            sref = StringObject::NewString(pwzArgument);
-
-        ARG_SLOT MethodArgs[] =
-        {
-            ObjToArgSlot(sref)
-        };
-        DWORD retval = method.Call_RetI4(MethodArgs);
-        if (pReturnValue)
-            {
-            *pReturnValue = retval;
-            }
-
-        GCPROTECT_END();
-    }
-
-    UNINSTALL_UNWIND_AND_CONTINUE_HANDLER;
-    END_DOMAIN_TRANSITION;
-    }
-    EX_CATCH_HRESULT(hr);
-
-ErrExit:
-
-    END_ENTRYPOINT_NOTHROW;
-
-    return hr;
-#else // FEATURE_CORECLR
     // Ensure that code is not loaded in the Default AppDomain
     return HOST_E_INVALIDOPERATION;
-#endif
 }
 
 HRESULT ExecuteInAppDomainHelper(FExecuteInAppDomainCallback pCallback,
@@ -1496,22 +729,18 @@ HRESULT CorHost2::ExecuteInAppDomain(DWORD dwAppDomainId,
 
     // No point going further if the runtime is not running...
     if (!IsRuntimeActive()
-#ifdef FEATURE_CORECLR
         || !m_fStarted
-#endif // FEATURE_CORECLR    
     )
     {
         return HOST_E_CLRNOTAVAILABLE;
     }       
 
-#ifdef FEATURE_CORECLR
     if(!(m_dwStartupFlags & STARTUP_SINGLE_APPDOMAIN))
     {
         // Ensure that code is not loaded in the Default AppDomain
         if (dwAppDomainId == DefaultADID)
            return HOST_E_INVALIDOPERATION;
     }
-#endif // FEATURE_CORECLR
 
     // Moved this here since no point validating the pointer
     // if the basic checks [above] fail
@@ -1555,9 +784,6 @@ HRESULT CorHost2::_CreateAppDomain(
     int nProperties, 
     LPCWSTR* pPropertyNames, 
     LPCWSTR* pPropertyValues,
-#if !defined(FEATURE_CORECLR)
-    ICLRPrivBinder* pBinder,
-#endif
     DWORD* pAppDomainID)
 {
     CONTRACTL
@@ -1570,13 +796,11 @@ HRESULT CorHost2::_CreateAppDomain(
 
     HRESULT hr=S_OK;
 
-#ifdef FEATURE_CORECLR
     //cannot call the function more than once when single appDomain is allowed
     if (m_fAppDomainCreated && (m_dwStartupFlags & STARTUP_SINGLE_APPDOMAIN))
     {
         return HOST_E_INVALIDOPERATION;
     }
-#endif
 
     //normalize empty strings
     EMPTY_STRING_TO_NULL(wszFriendlyName);
@@ -1586,10 +810,8 @@ HRESULT CorHost2::_CreateAppDomain(
     if(pAppDomainID==NULL)
         return E_POINTER;
 
-#ifdef FEATURE_CORECLR
     if (!m_fStarted)
         return HOST_E_INVALIDOPERATION;
-#endif // FEATURE_CORECLR
 
     if(wszFriendlyName == NULL)
         return E_INVALIDARG;
@@ -1604,26 +826,22 @@ HRESULT CorHost2::_CreateAppDomain(
 
     AppDomainCreationHolder<AppDomain> pDomain;
 
-#ifdef FEATURE_CORECLR
     // If StartupFlag specifies single appDomain then return the default domain instead of creating new one
     if(m_dwStartupFlags & STARTUP_SINGLE_APPDOMAIN)
     {
         pDomain.Assign(SystemDomain::System()->DefaultDomain());
     }
     else
-#endif
     {
         AppDomain::CreateUnmanagedObject(pDomain);
     }
 
     ETW::LoaderLog::DomainLoad(pDomain, (LPWSTR)wszFriendlyName);
 
-#ifdef FEATURE_CORECLR
     if (dwFlags & APPDOMAIN_IGNORE_UNHANDLED_EXCEPTIONS)
     {
         pDomain->SetIgnoreUnhandledExceptions();
     }
-#endif // FEATURE_CORECLR
 
     if (dwFlags & APPDOMAIN_SECURITY_FORBID_CROSSAD_REVERSE_PINVOKE)
         pDomain->SetReversePInvokeCannotEnter();
@@ -1631,10 +849,6 @@ HRESULT CorHost2::_CreateAppDomain(
     if (dwFlags & APPDOMAIN_FORCE_TRIVIAL_WAIT_OPERATIONS)
         pDomain->SetForceTrivialWaitOperations();
 
-#if !defined(FEATURE_CORECLR)
-    if (pBinder != NULL)
-        pDomain->SetLoadContextHostBinder(pBinder);
-#endif
         
 #ifdef PROFILING_SUPPORTED
     EX_TRY
@@ -1689,12 +903,8 @@ HRESULT CorHost2::_CreateAppDomain(
         args[1]=ObjToArgSlot(NULL);
         args[2]=ObjToArgSlot(NULL);
         args[3]=ObjToArgSlot(NULL);
-#ifdef FEATURE_CORECLR
         //CoreCLR shouldn't have dependencies on parent app domain.
         args[4]=ObjToArgSlot(NULL);
-#else
-        args[4]=PtrToArgSlot(GetAppDomain()->GetSecurityDescriptor());
-#endif //FEATURE_CORECLR
         args[5]=ObjToArgSlot(_gc.sandboxName);
         args[6]=ObjToArgSlot(_gc.propertyNames);
         args[7]=ObjToArgSlot(_gc.propertyValues);
@@ -1707,12 +917,6 @@ HRESULT CorHost2::_CreateAppDomain(
         PTRARRAYREF handleArrayObj = (PTRARRAYREF) ObjectToOBJECTREF(_gc.setupInfo);
         _gc.adSetup = ObjectToOBJECTREF(handleArrayObj->GetAt(1));
 
-#ifndef FEATURE_CORECLR
-        // We need to setup domain sorting before any other managed code runs in the domain, since that code 
-        // could end up caching data based on the sorting mode of the domain.
-        pDomain->InitializeSorting(&_gc.adSetup);
-        pDomain->InitializeHashing(&_gc.adSetup);
-#endif
 
         pDomain->DoSetup(&_gc.setupInfo);
 
@@ -1722,13 +926,11 @@ HRESULT CorHost2::_CreateAppDomain(
 
         *pAppDomainID=pDomain->GetId().m_dwId;
 
-#ifdef FEATURE_CORECLR
         // If StartupFlag specifies single appDomain then set the flag that appdomain has already been created
         if(m_dwStartupFlags & STARTUP_SINGLE_APPDOMAIN)
         {
             m_fAppDomainCreated = TRUE;
         }
-#endif
     }
 #ifdef PROFILING_SUPPORTED
     EX_HOOK
@@ -1798,7 +1000,6 @@ HRESULT CorHost2::_CreateDelegate(
     if(wszMethodName == NULL)
         return E_INVALIDARG;
     
-#ifdef FEATURE_CORECLR
     if (!m_fStarted)
         return HOST_E_INVALIDOPERATION;
 
@@ -1808,7 +1009,6 @@ HRESULT CorHost2::_CreateDelegate(
         if (appDomainID == DefaultADID)
             return HOST_E_INVALIDOPERATION;
     }
-#endif
 
     BEGIN_ENTRYPOINT_NOTHROW;
 
@@ -1856,11 +1056,9 @@ HRESULT CorHost2::_CreateDelegate(
     if (pMD==NULL || !pMD->IsStatic() || pMD->ContainsGenericVariables()) 
         ThrowHR(COR_E_MISSINGMETHOD);
 
-#ifdef FEATURE_CORECLR
     // the target method must be decorated with AllowReversePInvokeCallsAttribute
     if (!COMDelegate::IsMethodAllowedToSinkReversePInvoke(pMD))
         ThrowHR(COR_E_SECURITY);
-#endif
 
     UMEntryThunk *pUMEntryThunk = GetAppDomain()->GetUMEntryThunkCache()->GetUMEntryThunk(pMD);
     *fnPtr = (INT_PTR)pUMEntryThunk->GetCode();
@@ -1874,7 +1072,6 @@ HRESULT CorHost2::_CreateDelegate(
     return hr;
 }
 
-#ifdef FEATURE_CORECLR
 HRESULT CorHost2::CreateAppDomainWithManager(
     LPCWSTR wszFriendlyName,
     DWORD  dwFlags,
@@ -1957,70 +1154,7 @@ HRESULT CorHost2::SetStartupFlags(STARTUP_FLAGS flag)
     return S_OK;
 }
 
-#endif //FEATURE_CORECLR
 
-#ifndef FEATURE_CORECLR
-void PauseOneAppDomain(AppDomainIterator* pi)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-
-    EX_TRY {
-        ENTER_DOMAIN_PTR(pi->GetDomain(),ADV_ITERATOR);
-
-        MethodDescCallSite(METHOD__APP_DOMAIN__PAUSE).Call(NULL);
-
-        END_DOMAIN_TRANSITION;
-    } EX_CATCH {
-    } EX_END_CATCH(SwallowAllExceptions);
-}
-
-void ResumeOneAppDomain(AppDomainIterator* pi)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-
-    EX_TRY {
-        ENTER_DOMAIN_PTR(pi->GetDomain(),ADV_ITERATOR);
-
-        MethodDescCallSite(METHOD__APP_DOMAIN__RESUME).Call(NULL);
-
-        END_DOMAIN_TRANSITION;
-    } EX_CATCH {
-    } EX_END_CATCH(SwallowAllExceptions);
-}
-
-// see comments in SuspendEEFromPause
-DWORD WINAPI SuspendAndResumeForPause(LPVOID arg)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        MODE_ANY;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-
-    ThreadSuspend::SuspendEE(ThreadSuspend::SUSPEND_OTHER);
-
-    g_PauseCompletedEvent.Set();
-    g_ClrResumeEvent.Wait(INFINITE, FALSE);
-
-    ThreadSuspend::RestartEE(FALSE, TRUE);
-    return 0;
-}
-
-#endif // !FEATURE_CORECLR
 
 HRESULT SuspendEEForPause()
 {
@@ -2034,33 +1168,9 @@ HRESULT SuspendEEForPause()
 
     HRESULT hr = S_OK;
 
-#ifdef FEATURE_CORECLR
     // In CoreCLR, we always resume from the same thread that paused.  So we can simply suspend the EE from this thread,
     // knowing we'll restart from the same thread.
     ThreadSuspend::SuspendEE(ThreadSuspend::SUSPEND_OTHER);
-#else
-    // In the CLR, we can resume from a different thread than the one that paused.  We can't call SuspendEE directly,
-    // because we can't call RestartEE from another thread.  So we queue a workitem to the ThreadPool to call SuspendEE
-    // and ResumeEE on our behalf.
-
-    EX_TRY
-    {
-        if (!ThreadpoolMgr::QueueUserWorkItem(SuspendAndResumeForPause, NULL, QUEUE_ONLY))
-        {
-            hr = HRESULT_FROM_GetLastError();
-        }
-        else
-        {
-            // wait for SuspendEE to complete before returning.
-            g_PauseCompletedEvent.Wait(INFINITE,FALSE);
-        }
-    }
-    EX_CATCH
-    {
-        hr = GET_EXCEPTION()->GetHR();
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-#endif
 
     return hr;
 }
@@ -2076,12 +1186,7 @@ HRESULT RestartEEFromPauseAndSetResumeEvent()
     CONTRACTL_END;
 
     // see comments in SuspendEEFromPause
-#ifdef FEATURE_CORECLR
     ThreadSuspend::RestartEE(FALSE, TRUE);
-#else
-    // setting the resume event below will restart the EE as well.  We don't wait for the restart
-    // to complete, because we'll sync with it next time we go to cooperative mode.
-#endif
 
     _ASSERTE(g_ClrResumeEvent.IsValid());
     g_ClrResumeEvent.Set();
@@ -2111,10 +1216,6 @@ HRESULT CorExecutionManager::Pause(DWORD dwAppDomainId, DWORD dwFlags)
 
     HRESULT hr = S_OK;
 
-#ifndef FEATURE_CORECLR
-    if (!IsRuntimeActive())
-        return HOST_E_CLRNOTAVAILABLE;
-#endif
 
     if(g_IsPaused)
         return E_FAIL;
@@ -2126,12 +1227,6 @@ HRESULT CorExecutionManager::Pause(DWORD dwAppDomainId, DWORD dwFlags)
         else
             g_ClrResumeEvent.Reset();
 
-#ifndef FEATURE_CORECLR
-        if (!g_PauseCompletedEvent.IsValid())
-            g_PauseCompletedEvent.CreateManualEvent(FALSE);
-        else
-            g_PauseCompletedEvent.Reset();
-#endif
     }
     EX_CATCH_HRESULT(hr);
     
@@ -2142,20 +1237,6 @@ HRESULT CorExecutionManager::Pause(DWORD dwAppDomainId, DWORD dwFlags)
 
     m_dwFlags = dwFlags;
 
-#ifndef FEATURE_CORECLR
-    if ((m_dwFlags & PAUSE_APP_DOMAINS) != 0)
-    {
-        Thread* pThread = SetupThreadNoThrow(&hr);
-        if (pThread != NULL)
-        {
-            GCX_COOP_THREAD_EXISTS(pThread);
-
-            AppDomainIterator ai(/*bOnlyActive:*/ TRUE);
-            while (ai.Next())
-                PauseOneAppDomain(&ai);
-        }
-    }
-#endif
 
     if (SUCCEEDED(hr))
     {
@@ -2185,15 +1266,10 @@ HRESULT CorExecutionManager::Resume(DWORD dwAppDomainId)
 
     HRESULT hr = S_OK;
 
-#ifndef FEATURE_CORECLR
-    if (!IsRuntimeActive())
-        return HOST_E_CLRNOTAVAILABLE;
-#endif
 
     if(!g_IsPaused)
         return E_FAIL;
 
-#ifdef FEATURE_CORECLR
     // GCThread is the thread that did the Pause. Resume should also happen on that same thread
     Thread *pThread = GetThread();
     if(pThread != ThreadSuspend::GetSuspensionThread())
@@ -2201,7 +1277,6 @@ HRESULT CorExecutionManager::Resume(DWORD dwAppDomainId)
         _ASSERTE(!"HOST BUG: The same thread that did Pause should do the Resume");
         return E_FAIL;
     }
-#endif
 
     BEGIN_ENTRYPOINT_NOTHROW;
 
@@ -2215,23 +1290,6 @@ HRESULT CorExecutionManager::Resume(DWORD dwAppDomainId)
 
     hr = RestartEEFromPauseAndSetResumeEvent();
 
-#ifndef FEATURE_CORECLR
-    if (SUCCEEDED(hr))
-    {
-        if ((m_dwFlags & PAUSE_APP_DOMAINS) != 0)
-        {
-            Thread* pThread = SetupThreadNoThrow(&hr);
-            if (pThread != NULL)
-            {
-                GCX_COOP_THREAD_EXISTS(pThread);
-
-                AppDomainIterator ai(/*bOnlyActive:*/ TRUE);
-                while (ai.Next())
-                    ResumeOneAppDomain(&ai);
-            }
-        }
-    }
-#endif
 
     END_ENTRYPOINT_NOTHROW;
 
@@ -2241,7 +1299,6 @@ HRESULT CorExecutionManager::Resume(DWORD dwAppDomainId)
 
 #endif //!DACCESS_COMPILE
 
-#ifdef FEATURE_CORECLR
 #ifndef DACCESS_COMPILE
 SVAL_IMPL(STARTUP_FLAGS, CorHost2, m_dwStartupFlags = STARTUP_CONCURRENT_GC);
 #else
@@ -2252,347 +1309,9 @@ STARTUP_FLAGS CorHost2::GetStartupFlags()
 {
     return m_dwStartupFlags;
 }
-#endif //FEATURE_CORECLR
 
 #ifndef DACCESS_COMPILE
 
-#if !defined(FEATURE_CORECLR)
-/*************************************************************************************
- ** ICLRPrivRuntime Methods
- *************************************************************************************/
-
-HRESULT CorHost2::GetInterface(
-    REFCLSID rclsid,
-    REFIID   riid,
-    LPVOID * ppUnk)
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_PREEMPTIVE;
-    } CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    EX_TRY
-    {
-        if (rclsid == __uuidof(CLRPrivAppXBinder))
-        {
-            CLRPrivBinderAppX * pBinder = CLRPrivBinderAppX::GetOrCreateBinder();
-            hr = pBinder->QueryInterface(riid, ppUnk);
-        }
-        else
-        {
-            hr = E_NOINTERFACE;
-        }
-    }
-    EX_CATCH_HRESULT(hr);
-
-    return hr;
-}
-
-HRESULT CorHost2::CreateAppDomain(
-    LPCWSTR pwzFriendlyName,
-    ICLRPrivBinder * pBinder,
-    LPDWORD pdwAppDomainId)
-{
-    return _CreateAppDomain(
-        pwzFriendlyName,
-        0 /* default security */,
-        nullptr, /* domain manager */
-        nullptr, /* domain manager */
-        0, /* property count */
-        nullptr, /* property names */
-        nullptr, /* property values */
-        pBinder,
-        pdwAppDomainId);
-}
-
-HRESULT CorHost2::CreateDelegate(
-    DWORD appDomainID,
-    LPCWSTR wszAssemblyName,
-    LPCWSTR wszClassName,
-    LPCWSTR wszMethodName,
-    LPVOID * ppvDelegate)
-{
-    return _CreateDelegate(appDomainID, wszAssemblyName, wszClassName,
-                          wszMethodName, reinterpret_cast<INT_PTR*>(ppvDelegate));
-}
-
-// Flag indicating if the EE was started up by an managed exe. Defined in ceemain.cpp.
-extern BOOL g_fEEManagedEXEStartup;
-
-HRESULT CorHost2::ExecuteMain(
-    ICLRPrivBinder * pBinder,
-    int * pRetVal)
-{
-    STATIC_CONTRACT_GC_TRIGGERS;
-    STATIC_CONTRACT_THROWS;
-    STATIC_CONTRACT_ENTRY_POINT;
-    
-    HRESULT hr = S_OK;
-
-    // If an exception passes through here, it will cause the
-    // "The application has generated an unhandled exception" dialog and offer to debug.
-    BEGIN_ENTRYPOINT_THROWS;
-
-    // Indicates that the EE was started up by a managed exe.
-    g_fEEManagedEXEStartup = TRUE;
-
-    IfFailGo(CorCommandLine::SetArgvW(WszGetCommandLine()));
-
-    IfFailGo(EnsureEEStarted(COINITEE_MAIN));
-
-    INSTALL_UNWIND_AND_CONTINUE_HANDLER;
-
-    //
-    // Look for the [STAThread] or [MTAThread] attribute
-    // TODO delete this code when we move to the default  AppDomain
-    // 
-    HMODULE hMod = WszGetModuleHandle(NULL);
-    
-    PEImageHolder pTempImage(PEImage::LoadImage(hMod));
-    PEFileHolder pTempFile(PEFile::Open(pTempImage.Extract()));
-
-    // Check for CustomAttributes - Set up the DefaultDomain and the main thread
-    // Note that this has to be done before ExplicitBind() as it
-    // affects the bind
-    mdToken tkEntryPoint = pTempFile->GetEntryPointToken();
-    // <TODO>@TODO: What if the entrypoint is in another file of the assembly?</TODO>
-    ReleaseHolder<IMDInternalImport> scope(pTempFile->GetMDImportWithRef());
-    // In theory, we should have a valid executable image and scope should never be NULL, but we've been  
-    // getting Watson failures for AVs here due to ISVs modifying image headers and some new OS loader 
-    // checks (see Dev10# 718530 and Windows 7# 615596)
-    if (scope == NULL)
-    {
-        ThrowHR(COR_E_BADIMAGEFORMAT);
-    }
-
-    Thread::ApartmentState state = Thread::AS_Unknown;
-
-    if((!IsNilToken(tkEntryPoint)) && (TypeFromToken(tkEntryPoint) == mdtMethodDef)) {
-        if (scope->IsValidToken(tkEntryPoint))
-            state = SystemDomain::GetEntryPointThreadAptState(scope, tkEntryPoint);
-        else
-            ThrowHR(COR_E_BADIMAGEFORMAT);
-    }
-
-    BOOL fSetGlobalSharePolicyUsingAttribute = FALSE;
-
-    if((!IsNilToken(tkEntryPoint)) && (TypeFromToken(tkEntryPoint) == mdtMethodDef))
-    {
-        // The global share policy needs to be set before initializing default domain 
-        // so that it is in place for loading of appdomain manager.
-        fSetGlobalSharePolicyUsingAttribute = SystemDomain::SetGlobalSharePolicyUsingAttribute(scope, tkEntryPoint);
-    }
-
-    // If the entry point has an explicit thread apartment state, set it
-    // before running the AppDomainManager initialization code.
-    if (state == Thread::AS_InSTA || state == Thread::AS_InMTA)
-        SystemDomain::SetThreadAptState(scope, state);
-
-    // This can potentially run managed code.
-    SystemDomain::InitializeDefaultDomain(FALSE, pBinder);
-
-    // If we haven't set an explicit thread apartment state, set it after the
-    // AppDomainManager has got a chance to go set it in InitializeNewDomain.
-    if (state != Thread::AS_InSTA && state != Thread::AS_InMTA)
-        SystemDomain::SetThreadAptState(scope, state);
-
-    if (fSetGlobalSharePolicyUsingAttribute)
-        SystemDomain::System()->DefaultDomain()->SetupLoaderOptimization(g_dwGlobalSharePolicy);
-
-    ADID adId(DefaultADID);
-
-    GCX_COOP();
-
-    ENTER_DOMAIN_ID(adId)
-    TESTHOOKCALL(EnteredAppDomain(adId.m_dwId));
-    {
-        GCX_PREEMP();
-
-        AppDomain *pDomain = GetAppDomain();
-        _ASSERTE(pDomain);
-
-        PathString wzExeFileName;
-         
-        if (WszGetModuleFileName(nullptr, wzExeFileName) == 0)
-            IfFailThrow(E_UNEXPECTED);
-
-        LPWSTR wzExeSimpleFileName = nullptr;
-        size_t cchExeSimpleFileName = 0;
-        SplitPathInterior(
-        wzExeFileName,
-        nullptr, nullptr, // drive
-        nullptr, nullptr, // dir
-        (LPCWSTR*)&wzExeSimpleFileName, &cchExeSimpleFileName, // filename
-        nullptr, nullptr); // ext
-
-        // Remove the extension
-        wzExeSimpleFileName[cchExeSimpleFileName] = W('\0');
-
-        ReleaseHolder<IAssemblyName> pAssemblyName;
-        IfFailThrow(CreateAssemblyNameObject(
-            &pAssemblyName,             // Returned IAssemblyName
-            wzExeSimpleFileName,        // Name of assembly
-            CANOF_PARSE_DISPLAY_NAME,   // Parse as display name
-            nullptr));                  // Reserved
-
-        AssemblySpec specExe;
-        specExe.InitializeSpec(pAssemblyName, nullptr, false);
-        
-        PEAssemblyHolder pPEAssembly = pDomain->BindAssemblySpec(&specExe, TRUE, FALSE);
-
-        pDomain->SetRootAssembly(pDomain->LoadAssembly(NULL, pPEAssembly, FILE_ACTIVE));
-
-        LOG((LF_CLASSLOADER | LF_CORDB,
-             LL_INFO10,
-             "Created domain for an executable at %p\n",
-             (pDomain->GetRootAssembly()? pDomain->GetRootAssembly()->Parent() : NULL)));
-        TESTHOOKCALL(RuntimeStarted(RTS_CALLINGENTRYPOINT));
-
-        // Set the friendly name to indicate that this is an immersive domain.
-        pDomain->SetFriendlyName(W("Immersive Application Domain"), TRUE);
-
-        // Execute the main method
-        // NOTE: we call the entry point with our entry point exception filter active
-        // after the AppDomain transition which is a bit different from classic apps.
-        // this is so that we have the correct context when notifying the debugger
-        // or invoking WER on the main thread and mimics the behavior of classic apps.
-		// the assumption is that AppX entry points are always invoked post-AD transition.
-        ExecuteMainInner(pDomain->GetRootAssembly());
-
-        // Get the global latched exit code instead of the return value from ExecuteMainMethod
-        // because in the case of a "void Main" method the return code is always 0,
-        // while the latched exit code is set in either case.
-        *pRetVal = GetLatchedExitCode();
-    }
-    END_DOMAIN_TRANSITION;
-    TESTHOOKCALL(LeftAppDomain(adId.m_dwId));
-
-    UNINSTALL_UNWIND_AND_CONTINUE_HANDLER;
-    
-ErrExit:
-    END_ENTRYPOINT_THROWS;
-
-    return hr;
-}
-
-VOID CorHost2::ExecuteMainInner(Assembly* pRootAssembly)
-{
-    STATIC_CONTRACT_GC_TRIGGERS;
-    STATIC_CONTRACT_THROWS;
-    STATIC_CONTRACT_ENTRY_POINT;
-
-    struct Param
-    {
-        Assembly* pRootAssembly;
-    } param;
-
-    param.pRootAssembly = pRootAssembly;
-
-    PAL_TRY(Param*, pParam, &param)
-    {
-		// since this is the thread 0 entry point for AppX apps we use
-		// the EntryPointFilter so that an unhandled exception here will
-		// trigger the same behavior as in classic apps.
-        pParam->pRootAssembly->ExecuteMainMethod(NULL, TRUE /* waitForOtherThreads */);
-    }
-    PAL_EXCEPT_FILTER(EntryPointFilter)
-    {
-        LOG((LF_STARTUP, LL_INFO10, "EntryPointFilter returned EXCEPTION_EXECUTE_HANDLER!"));
-    }
-    PAL_ENDTRY
-}
-
-// static
-HRESULT CorHost2::SetFlagsAndHostConfig(STARTUP_FLAGS dwStartupFlags, LPCWSTR pwzHostConfigFile, BOOL fFinalize)
-{
-    WRAPPER_NO_CONTRACT;
-
-    HRESULT hr = E_INVALIDARG;
-
-    if (pwzHostConfigFile == NULL)
-        pwzHostConfigFile = W("");
-
-    DangerousNonHostedSpinLockHolder lockHolder(&m_FlagsLock);
-
-    if (m_dwFlagsFinalized)
-    {
-        // verify that flags and config file are the same
-        if (dwStartupFlags == m_dwStartupFlags &&
-            _wcsicmp(pwzHostConfigFile, m_wzHostConfigFile) == 0)
-        {
-            hr = S_OK;
-        }   
-    }
-    else
-    {
-        // overwrite the flags and config with the incoming values
-        if (wcslen(pwzHostConfigFile) < COUNTOF(m_wzHostConfigFile))
-        {
-            VERIFY(wcscpy_s(m_wzHostConfigFile, COUNTOF(m_wzHostConfigFile), pwzHostConfigFile) == 0);
-
-            // If they asked for the server gc but only have one processor, deny that option.
-            // Keep this in sync with shim logic in ComputeStartupFlagsAndFlavor that also switches to 
-            // the workstation GC on uniprocessor boxes.
-            if (g_SystemInfo.dwNumberOfProcessors == 1 && (dwStartupFlags & STARTUP_SERVER_GC)) 
-                dwStartupFlags = (STARTUP_FLAGS)(dwStartupFlags & ~(STARTUP_SERVER_GC | STARTUP_CONCURRENT_GC));
-
-            m_dwStartupFlags = dwStartupFlags;
-
-            if (fFinalize)
-                m_dwFlagsFinalized = TRUE;
-
-            hr = S_OK;
-        }
-    }
-
-    return hr;
-}
-
-// static
-STARTUP_FLAGS CorHost2::GetStartupFlags()
-{
-    WRAPPER_NO_CONTRACT;
-
-    if (!m_dwFlagsFinalized) // make sure we return consistent results
-    {
-        DangerousNonHostedSpinLockHolder lockHolder(&m_FlagsLock);
-        m_dwFlagsFinalized = TRUE;
-    }
-
-    return m_dwStartupFlags;
-}
-
-// static
-LPCWSTR CorHost2::GetHostConfigFile()
-{
-    WRAPPER_NO_CONTRACT;
-
-    if (!m_dwFlagsFinalized) // make sure we return consistent results
-    {
-        DangerousNonHostedSpinLockHolder lockHolder(&m_FlagsLock);
-        m_dwFlagsFinalized = TRUE;
-    }
-
-    return m_wzHostConfigFile;
-}
-
-// static
-void CorHost2::GetDefaultAppDomainProperties(StringArrayList **pPropertyNames, StringArrayList **pPropertyValues)
-{
-    LIMITED_METHOD_CONTRACT;
-    
-    // We should only read these after the runtime has started to ensure that the host isn't modifying them
-    // still
-    _ASSERTE(g_fEEStarted || HasStarted());
-
-    *pPropertyNames = &s_defaultDomainPropertyNames;
-    *pPropertyValues = &s_defaultDomainPropertyValues;
-}
-
-#endif // !FEATURE_CORECLR
 
 #ifdef FEATURE_COMINTEROP
 
@@ -2644,370 +1363,12 @@ HRESULT  GetCLRRuntimeHost(REFIID riid, IUnknown **ppUnk)
     return CorHost2::CreateObject(riid, (void**)ppUnk);
 }
 
-#if defined(FEATURE_COMINTEROP) && !defined(FEATURE_CORECLR)
-
-HRESULT NextDomainWorker(AppDomainIterator *pEnum,
-                         IUnknown** pAppDomain)
-{
-    CONTRACTL
-    {
-        DISABLED(NOTHROW); // nothrow contract's fs:0 handler gets called before the C++ EH fs:0 handler which is pushed in the prolog
-        GC_TRIGGERS;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-    Thread *pThread = GetThread();
-    BEGIN_SO_INTOLERANT_CODE_NOTHROW(pThread, return COR_E_STACKOVERFLOW);
-
-    EX_TRY
-    {
-        GCX_COOP_THREAD_EXISTS(pThread);
-
-        if (pEnum->Next())
-        {
-            AppDomain* pDomain = pEnum->GetDomain();
-            // Need to enter the AppDomain to synchronize access to the exposed
-            // object properly (can't just take the system domain mutex since we
-            // might need to run code that uses higher ranking crsts).
-            ENTER_DOMAIN_PTR(pDomain,ADV_ITERATOR)
-            {
-
-                hr = pDomain->GetComIPForExposedObject(pAppDomain);
-            }
-            END_DOMAIN_TRANSITION;
-        }
-        else
-        {
-            hr = S_FALSE;
-        }
-    }
-    EX_CATCH_HRESULT(hr);
-
-    END_SO_INTOLERANT_CODE;
-
-    return hr;
-}
-
-// Returns S_FALSE when there are no more domains. A domain
-// is passed out only when S_OK is returned.
-HRESULT CorRuntimeHostBase::NextDomain(HDOMAINENUM hEnum,
-                                       IUnknown** pAppDomain)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    if(hEnum == NULL || pAppDomain == NULL)
-        return E_POINTER;
-
-    // If the runtime has not started, we have nothing to do.
-    if (!g_fEEStarted)
-    {
-        return HOST_E_CLRNOTAVAILABLE;
-    }
-
-    HRESULT hr;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    AppDomainIterator *pEnum = (AppDomainIterator *) hEnum;
-
-    do
-    {
-        hr = NextDomainWorker(pEnum, pAppDomain);
-    // Might need to look at the next appdomain if we were attempting to get at
-    // the exposed appdomain object and were chucked out as the result of an
-    // appdomain unload.
-    } while (hr == COR_E_APPDOMAINUNLOADED);
-    END_ENTRYPOINT_NOTHROW;
-    return hr;
-}
-
-// Creates a domain in the runtime. The identity array is
-// a pointer to an array TYPE containing IIdentity objects defining
-// the security identity.
-HRESULT CorRuntimeHostBase::CreateDomainEx(LPCWSTR pwzFriendlyName,
-                                           IUnknown* pSetup, // Optional
-                                           IUnknown* pEvidence, // Optional
-                                           IUnknown ** pAppDomain)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_PREEMPTIVE;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-    if(!pwzFriendlyName) return E_POINTER;
-    if(pAppDomain == NULL) return E_POINTER;
-    if(!g_fEEStarted) return E_FAIL;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    BEGIN_EXTERNAL_ENTRYPOINT(&hr);
-    {
-        GCX_COOP_THREAD_EXISTS(GET_THREAD());
-
-        struct _gc {
-            STRINGREF pName;
-            OBJECTREF pSetup;
-            OBJECTREF pEvidence;
-            APPDOMAINREF pDomain;
-        } gc;
-        ZeroMemory(&gc, sizeof(gc));
-
-        if (FAILED(hr = EnsureComStartedNoThrow()))
-            goto lDone;
-
-        GCPROTECT_BEGIN(gc);
-
-        gc.pName = StringObject::NewString(pwzFriendlyName);
-
-        if(pSetup)
-            GetObjectRefFromComIP(&gc.pSetup, pSetup);
-        if(pEvidence)
-            GetObjectRefFromComIP(&gc.pEvidence, pEvidence);
-
-        MethodDescCallSite createDomain(METHOD__APP_DOMAIN__CREATE_DOMAIN);
-
-        ARG_SLOT args[3] = {
-            ObjToArgSlot(gc.pName),
-            ObjToArgSlot(gc.pEvidence),
-            ObjToArgSlot(gc.pSetup),
-        };
-
-        gc.pDomain = (APPDOMAINREF) createDomain.Call_RetOBJECTREF(args);
-
-        *pAppDomain = GetComIPFromObjectRef((OBJECTREF*) &gc.pDomain);
-
-        GCPROTECT_END();
-
-lDone: ;
-    }
-    END_EXTERNAL_ENTRYPOINT;
-
-    END_ENTRYPOINT_NOTHROW;
-
-    return hr;
-}
-
-// Close the enumeration releasing resources
-HRESULT CorRuntimeHostBase::CloseEnum(HDOMAINENUM hEnum)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    if(hEnum) {
-        AppDomainIterator* pEnum = (AppDomainIterator*) hEnum;
-        delete pEnum;
-    }
-
-    END_ENTRYPOINT_NOTHROW;
-    return hr;
-}
-
-
-HRESULT CorRuntimeHostBase::CreateDomainSetup(IUnknown **pAppDomainSetup)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        ENTRY_POINT;
-        MODE_PREEMPTIVE;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    if (!pAppDomainSetup)
-        return E_POINTER;
-
-    // If the runtime has not started, we have nothing to do.
-    if (!g_fEEStarted)
-    {
-        return HOST_E_CLRNOTAVAILABLE;
-    }
-
-    // Create the domain.
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    BEGIN_EXTERNAL_ENTRYPOINT(&hr);
-    {
-        GCX_COOP_THREAD_EXISTS(GET_THREAD());
-
-        struct _gc {
-            OBJECTREF pSetup;
-        } gc;
-        ZeroMemory(&gc, sizeof(gc));
-        MethodTable* pMT = NULL;
-
-        hr = EnsureComStartedNoThrow();
-        if (FAILED(hr))
-            goto lDone;
-
-        pMT = MscorlibBinder::GetClass(CLASS__APPDOMAIN_SETUP);
-
-        GCPROTECT_BEGIN(gc);
-        gc.pSetup = AllocateObject(pMT);
-        *pAppDomainSetup = GetComIPFromObjectRef((OBJECTREF*) &gc.pSetup);
-        GCPROTECT_END();
-
-lDone: ;
-    }
-    END_EXTERNAL_ENTRYPOINT;
-    END_ENTRYPOINT_NOTHROW;
-
-    return hr;
-}
-
-HRESULT CorRuntimeHostBase::CreateEvidence(IUnknown **pEvidence)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_PREEMPTIVE;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    if (!pEvidence)
-        return E_POINTER;
-
-#ifdef FEATURE_CAS_POLICY
-
-    // If the runtime has not started, we have nothing to do.
-    if (!g_fEEStarted)
-    {
-        return HOST_E_CLRNOTAVAILABLE;
-    }
-
-    // Create the domain.
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    BEGIN_EXTERNAL_ENTRYPOINT(&hr);
-    {
-        GCX_COOP_THREAD_EXISTS(GET_THREAD());
-
-        struct _gc {
-            OBJECTREF pEvidence;
-        } gc;
-        ZeroMemory(&gc, sizeof(gc));
-
-        MethodTable* pMT = NULL;
-
-        hr = EnsureComStartedNoThrow();
-        if (FAILED(hr))
-            goto lDone;
-
-        pMT = MscorlibBinder::GetClass(CLASS__EVIDENCE);
-
-        GCPROTECT_BEGIN(gc);
-        gc.pEvidence = AllocateObject(pMT);
-        MethodDescCallSite ctor(METHOD__EVIDENCE__CTOR, &(gc.pEvidence));
-
-        // Call the Evidence class constructor.
-        ARG_SLOT CtorArgs[] =
-        { 
-            ObjToArgSlot(gc.pEvidence)
-        };
-        ctor.Call(CtorArgs);
-
-        *pEvidence = GetComIPFromObjectRef((OBJECTREF*) &gc.pEvidence);
-        GCPROTECT_END();
-
-lDone: ;
-    }
-    END_EXTERNAL_ENTRYPOINT;
-    END_ENTRYPOINT_NOTHROW;
-#else // !FEATURE_CAS_POLICY
-    // There is no Evidence class support without CAS policy.
-    return E_NOTIMPL;
-#endif // FEATURE_CAS_POLICY
-
-    return hr;
-}
-
-HRESULT CorRuntimeHostBase::UnloadDomain(IUnknown *pUnkDomain)
-{
-    CONTRACTL
-    {
-        DISABLED(NOTHROW);
-        GC_TRIGGERS;
-        MODE_ANY;
-        FORBID_FAULT;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    if (!pUnkDomain)
-        return E_POINTER;
-
-    // If the runtime has not started, we have nothing to do.
-    if (!g_fEEStarted)
-    {
-        return HOST_E_CLRNOTAVAILABLE;
-    }
-
-    CONTRACT_VIOLATION(FaultViolation); // This entire function is full of OOM potential: must fix.
-
-    HRESULT hr = S_OK;
-    DWORD dwDomainId = 0;
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    _ASSERTE (g_fComStarted);
-
-    {
-        SystemDomain::LockHolder lh;
-
-        ComCallWrapper* pWrap = GetCCWFromIUnknown(pUnkDomain, FALSE);
-        if (!pWrap)
-        {
-            hr = COR_E_APPDOMAINUNLOADED;
-        }
-        if (SUCCEEDED(hr))
-        {
-            dwDomainId = pWrap->GetDomainID().m_dwId;
-        }
-    }
-    if (SUCCEEDED(hr))
-    {
-        hr = UnloadAppDomain(dwDomainId, TRUE);
-    }
-    END_ENTRYPOINT_NOTHROW;
-
-    return hr;
-}
-
-#endif // FEATURE_COMINTEROP && !FEATURE_CORECLR
 
 STDMETHODIMP CorHost2::UnloadAppDomain(DWORD dwDomainId, BOOL fWaitUntilDone)
 {
     WRAPPER_NO_CONTRACT;
     STATIC_CONTRACT_SO_TOLERANT;
 
-#ifdef FEATURE_CORECLR
     if (!m_fStarted)
         return HOST_E_INVALIDOPERATION;
 
@@ -3056,7 +1417,6 @@ STDMETHODIMP CorHost2::UnloadAppDomain(DWORD dwDomainId, BOOL fWaitUntilDone)
         return hr;
     }
     else
-#endif // FEATURE_CORECLR
 
     return CorRuntimeHostBase::UnloadAppDomain(dwDomainId, fWaitUntilDone);
 }
@@ -3093,9 +1453,7 @@ HRESULT CorRuntimeHostBase::UnloadAppDomain(DWORD dwDomainId, BOOL fSync)
         // for this scope only.
         CONTRACT_VIOLATION(FaultViolation);
         if (!IsRuntimeActive()
-    #ifdef FEATURE_CORECLR
             || !m_fStarted
-    #endif // FEATURE_CORECLR    
         )
         {
             return HOST_E_CLRNOTAVAILABLE;
@@ -3117,126 +1475,6 @@ HRESULT CorRuntimeHostBase::UnloadAppDomain(DWORD dwDomainId, BOOL fSync)
 //*****************************************************************************
 // Fiber Methods
 //*****************************************************************************
-#if !defined(FEATURE_CORECLR) // simple hosting
-HRESULT CorHost::CreateLogicalThreadState()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        DISABLED(GC_TRIGGERS);
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-    if (CorHost::GetHostVersion() != 1)
-    {
-        hr=HOST_E_INVALIDOPERATION;
-    }
-    else
-    {
-        _ASSERTE (GetThread() == 0 || GetThread()->HasRightCacheStackBase());
-        /* Thread  *thread = */ SetupThreadNoThrow(&hr);
-      
-    }
-    END_ENTRYPOINT_NOTHROW;
-    return hr;
-}
-
-
-HRESULT CorHost::DeleteLogicalThreadState()
-{
-    if (CorHost::GetHostVersion() != 1)
-    {
-        return HOST_E_INVALIDOPERATION;
-    }
-
-    Thread *pThread = GetThread();
-    if (!pThread)
-        return E_UNEXPECTED;
-
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-    HRESULT hr = S_OK;
-    BEGIN_ENTRYPOINT_NOTHROW;
-    // We need to reset the TrapReturningThread count that was
-    // set when a thread is requested to be aborted.  Otherwise
-    // every stub call is going to go through a slow path.
-    if (pThread->IsAbortRequested())
-        pThread->UnmarkThreadForAbort(Thread::TAR_ALL);
-
-    // see code:Thread::OnThreadTerminate#ReportDeadOnThreadTerminate
-    pThread->SetThreadState(Thread::TS_ReportDead);
-
-    pThread->OnThreadTerminate(FALSE);
-    END_ENTRYPOINT_NOTHROW;
-    return hr;
-}
-
-
-HRESULT CorHost::SwitchInLogicalThreadState(DWORD *pFiberCookie)
-{
-    STATIC_CONTRACT_NOTHROW;
-    STATIC_CONTRACT_GC_NOTRIGGER;
-    STATIC_CONTRACT_MODE_ANY;
-    STATIC_CONTRACT_ENTRY_POINT;
-
-    if (CorHost::GetHostVersion() != 1)
-    {
-        return HOST_E_INVALIDOPERATION;
-    }
-
-    if (!pFiberCookie)
-    {
-        return E_POINTER;
-    }
-
-    HRESULT hr = S_OK;
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    hr = ((Thread*)pFiberCookie)->SwitchIn(::GetCurrentThread());
-
-    END_ENTRYPOINT_NOTHROW;
-    return hr;
-
-}
-
-HRESULT CorHost::SwitchOutLogicalThreadState(DWORD **pFiberCookie)
-{
-    STATIC_CONTRACT_NOTHROW;
-    STATIC_CONTRACT_GC_NOTRIGGER;
-    STATIC_CONTRACT_MODE_ANY;
-    STATIC_CONTRACT_ENTRY_POINT;
-
-    if (CorHost::GetHostVersion() != 1)
-    {
-        return HOST_E_INVALIDOPERATION;
-    }
-
-     if (!pFiberCookie)
-    {
-        return E_POINTER;
-    }
-
-     Thread *pThread = GetThread();
-     if (!pThread)
-     {
-        return E_UNEXPECTED;
-     }
-
-        pThread->InternalSwitchOut();
-        *pFiberCookie = (DWORD*)pThread;
-
-    return S_OK;
-}
-#endif // !defined(FEATURE_CORECLR)
 
 HRESULT CorRuntimeHostBase::LocksHeldByLogicalThread(DWORD *pCount)
 {
@@ -3267,242 +1505,6 @@ HRESULT CorRuntimeHostBase::LocksHeldByLogicalThread(DWORD *pCount)
 //*****************************************************************************
 // ICorConfiguration
 //*****************************************************************************
-#if !defined(FEATURE_CORECLR)
-IGCThreadControl *CorConfiguration::m_CachedGCThreadControl = 0;
-IGCHostControl *CorConfiguration::m_CachedGCHostControl = 0;
-IDebuggerThreadControl *CorConfiguration::m_CachedDebuggerThreadControl = 0;
-DWORD *CorConfiguration::m_DSTArray = 0;
-DWORD CorConfiguration::m_DSTCount = 0;
-DWORD CorConfiguration::m_DSTArraySize = 0;
-
-// *** ICorConfiguration methods ***
-
-
-HRESULT CorConfiguration::SetGCThreadControl(IGCThreadControl *pGCThreadControl)
-{
-    if (!pGCThreadControl)
-        return E_POINTER;
-
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    if (m_CachedGCThreadControl)
-        m_CachedGCThreadControl->Release();
-
-    m_CachedGCThreadControl = pGCThreadControl;
-
-    if (m_CachedGCThreadControl)
-        m_CachedGCThreadControl->AddRef();
-
-    END_ENTRYPOINT_NOTHROW;
-
-    return S_OK;
-}
-
-HRESULT CorConfiguration::SetGCHostControl(IGCHostControl *pGCHostControl)
-{
-    if (!pGCHostControl)
-        return E_POINTER;
-
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    if (m_CachedGCHostControl)
-        m_CachedGCHostControl->Release();
-
-    m_CachedGCHostControl = pGCHostControl;
-
-    if (m_CachedGCHostControl)
-        m_CachedGCHostControl->AddRef();
-
-    END_ENTRYPOINT_NOTHROW;
-
-    return S_OK;
-}
-
-HRESULT CorConfiguration::SetDebuggerThreadControl(IDebuggerThreadControl *pDebuggerThreadControl)
-{
-    if (!pDebuggerThreadControl)
-        return E_POINTER;
-
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-#ifdef DEBUGGING_SUPPORTED
-    // Can't change the debugger thread control object once its been set.
-    if (m_CachedDebuggerThreadControl != NULL)
-        IfFailGo(E_INVALIDARG);
-
-    m_CachedDebuggerThreadControl = pDebuggerThreadControl;
-
-    // If debugging is already initialized then provide this interface pointer to it.
-    // It will also addref the new one and release the old one.
-    if (g_pDebugInterface)
-        g_pDebugInterface->SetIDbgThreadControl(pDebuggerThreadControl);
-
-    if (m_CachedDebuggerThreadControl)
-        m_CachedDebuggerThreadControl->AddRef();
-
-    hr = S_OK;
-#else // !DEBUGGING_SUPPORTED
-    hr = E_NOTIMPL;
-#endif // !DEBUGGING_SUPPORTED
-
-ErrExit:
-    END_ENTRYPOINT_NOTHROW;
-    return hr;
-
-}
-
-
-HRESULT CorConfiguration::AddDebuggerSpecialThread(DWORD dwSpecialThreadId)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        ENTRY_POINT;    // debugging not hardened for SO
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-
-#ifdef DEBUGGING_SUPPORTED
-    // If it's already in the list, don't add it again.
-    if (IsDebuggerSpecialThread(dwSpecialThreadId))
-    {
-        hr = S_OK;
-        goto ErrExit;
-    }
-    // Grow the array if necessary.
-    if (m_DSTCount >= m_DSTArraySize)
-    {
-        // There's probably only ever gonna be one or two of these
-        // things, so we'll start small.
-        DWORD newSize = (m_DSTArraySize == 0) ? 2 : m_DSTArraySize * 2;
-
-        DWORD *newArray = new (nothrow) DWORD[newSize];
-        IfNullGo(newArray);
-
-        // If we're growing instead of starting, then copy the old array.
-        if (m_DSTArray)
-        {
-            memcpy(newArray, m_DSTArray, m_DSTArraySize * sizeof(DWORD));
-            delete [] m_DSTArray;
-        }
-
-        // Update to the new array and size.
-        m_DSTArray = newArray;
-        m_DSTArraySize = newSize;
-    }
-
-    // Save the new thread ID.
-    m_DSTArray[m_DSTCount++] = dwSpecialThreadId;
-
-    hr = (RefreshDebuggerSpecialThreadList());
-#else // !DEBUGGING_SUPPORTED
-    hr = E_NOTIMPL;
-#endif // !DEBUGGING_SUPPORTED
-ErrExit:
-    END_ENTRYPOINT_NOTHROW;
-    return hr;
-
-}
-// Helper function to update the thread list in the debugger control block
-HRESULT CorConfiguration::RefreshDebuggerSpecialThreadList()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-#ifdef DEBUGGING_SUPPORTED
-    HRESULT hr = S_OK;
-
-    if (g_pDebugInterface)
-    {
-        // Inform the debugger services that this list has changed
-        hr = g_pDebugInterface->UpdateSpecialThreadList(
-            m_DSTCount, m_DSTArray);
-
-        _ASSERTE(SUCCEEDED(hr));
-    }
-
-    return (hr);
-#else // !DEBUGGING_SUPPORTED
-    return E_NOTIMPL;
-#endif // !DEBUGGING_SUPPORTED
-}
-
-
-// Helper func that returns true if the thread is in the debugger special thread list
-BOOL CorConfiguration::IsDebuggerSpecialThread(DWORD dwThreadId)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    for (DWORD i = 0; i < m_DSTCount; i++)
-    {
-        if (m_DSTArray[i] == dwThreadId)
-            return (TRUE);
-    }
-
-    return (FALSE);
-}
-
-
-// Clean up any debugger thread control object we may be holding, called at shutdown.
-void CorConfiguration::CleanupDebuggerThreadControl()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    if (m_CachedDebuggerThreadControl != NULL)
-    {
-        // Note: we don't release the IDebuggerThreadControl object if we're cleaning up from
-        // our DllMain. The DLL that implements the object may already have been unloaded.
-        // Leaking the object is okay... the PDM doesn't care.
-        if (!IsAtProcessExit())
-            m_CachedDebuggerThreadControl->Release();
-
-        m_CachedDebuggerThreadControl = NULL;
-    }
-}
-#endif // !defined(FEATURE_CORECLR)
 
 //*****************************************************************************
 // IUnknown
@@ -3520,20 +1522,6 @@ ULONG CorRuntimeHostBase::AddRef()
     return InterlockedIncrement(&m_cRef);
 }
 
-#if !defined(FEATURE_CORECLR) // simple hosting
-ULONG CorHost::Release()
-{
-    LIMITED_METHOD_CONTRACT;
-    STATIC_CONTRACT_SO_TOLERANT;
-
-    ULONG   cRef = InterlockedDecrement(&m_cRef);
-    if (!cRef) {
-        delete this;
-    }
-
-    return (cRef);
-}
-#endif // !defined(FEATURE_CORECLR)
 
 ULONG CorHost2::Release()
 {
@@ -3551,62 +1539,6 @@ ULONG CorHost2::Release()
     return (cRef);
 }
 
-#if !defined(FEATURE_CORECLR) // simple hosting
-HRESULT CorHost::QueryInterface(REFIID riid, void **ppUnk)
-{
-    if (!ppUnk)
-        return E_POINTER;
-
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        SO_TOLERANT;    // no global state updates that need guarding.
-    }
-    CONTRACTL_END;
-
-    if (ppUnk == NULL)
-    {
-        return E_POINTER;
-    }
-
-    *ppUnk = 0;
-
-    // Deliberately do NOT hand out ICorConfiguration.  They must explicitly call
-    // GetConfiguration to obtain that interface.
-    if (riid == IID_IUnknown)
-        *ppUnk = (IUnknown *) (ICorRuntimeHost *) this;
-    else if (riid == IID_ICorRuntimeHost)
-    {
-        ULONG version = 1;
-        if (m_Version == 0)
-            FastInterlockCompareExchange((LONG*)&m_Version, version, 0);
-
-        if (m_Version != version && (g_singleVersionHosting || !g_fEEStarted))
-        {
-            return HOST_E_INVALIDOPERATION;
-        }
-
-        *ppUnk = (ICorRuntimeHost *) this;
-    }
-    else if (riid == IID_ICorThreadpool)
-        *ppUnk = (ICorThreadpool *) this;
-    else if (riid == IID_IGCHost)
-        *ppUnk = (IGCHost *) this;
-    else if (riid == IID_IGCHost2)
-        *ppUnk = (IGCHost2 *) this;
-    else if (riid == IID_IValidator)
-        *ppUnk = (IValidator *) this;
-    else if (riid == IID_IDebuggerInfo)
-        *ppUnk = (IDebuggerInfo *) this;
-    else if (riid == IID_ICLRExecutionManager)
-        *ppUnk = (ICLRExecutionManager *) this;
-    else
-        return (E_NOINTERFACE);
-    AddRef();
-    return (S_OK);
-}
-#endif // !defined(FEATURE_CORECLR)
 
 
 HRESULT CorHost2::QueryInterface(REFIID riid, void **ppUnk)
@@ -3633,7 +1565,6 @@ HRESULT CorHost2::QueryInterface(REFIID riid, void **ppUnk)
     // GetConfiguration to obtain that interface.
     if (riid == IID_IUnknown)
         *ppUnk = static_cast<IUnknown *>(static_cast<ICLRRuntimeHost *>(this));
-#ifdef FEATURE_CORECLR // CoreCLR only supports IID_ICLRRuntimeHost2
     else if (riid == IID_ICLRRuntimeHost2)
     {
         ULONG version = 2;
@@ -3642,16 +1573,6 @@ HRESULT CorHost2::QueryInterface(REFIID riid, void **ppUnk)
 
         *ppUnk = static_cast<ICLRRuntimeHost2 *>(this);
     }
-#else // DesktopCLR only supports IID_ICLRRuntimeHost
-    else if (riid == IID_ICLRRuntimeHost)
-    {
-        ULONG version = 2;
-        if (m_Version == 0)
-            FastInterlockCompareExchange((LONG*)&m_Version, version, 0);
-
-        *ppUnk = static_cast<ICLRRuntimeHost *>(this);
-    }
-#endif // FEATURE_CORECLR
     else if (riid == IID_ICLRExecutionManager)
     {
         ULONG version = 2;
@@ -3660,79 +1581,18 @@ HRESULT CorHost2::QueryInterface(REFIID riid, void **ppUnk)
 
         *ppUnk = static_cast<ICLRExecutionManager *>(this);
     }
-#if !defined(FEATURE_CORECLR)
-    else if (riid == __uuidof(ICLRPrivRuntime))
-    {
-        ULONG version = 2;
-        if (m_Version == 0)
-            FastInterlockCompareExchange((LONG*)&m_Version, version, 0);
-
-        *ppUnk = static_cast<ICLRPrivRuntime *>(this);
-    }
-#endif
 #ifndef FEATURE_PAL
     else if (riid == IID_IPrivateManagedExceptionReporting)
     {
         *ppUnk = static_cast<IPrivateManagedExceptionReporting *>(this);
     }
 #endif // !FEATURE_PAL
-#ifndef FEATURE_CORECLR
-    else if (riid == IID_ICorThreadpool)
-        *ppUnk = static_cast<ICorThreadpool *>(this);
-    // TODO: wwl Remove this after SQL uses new interface.
-    else if (riid == IID_IGCHost &&
-             GetHostVersion() == 3)
-        *ppUnk = static_cast<IGCHost *>(this);
-    else if (riid == IID_ICLRValidator)
-        *ppUnk = static_cast<ICLRValidator *>(this);
-    else if (riid == IID_IDebuggerInfo)
-        *ppUnk = static_cast<IDebuggerInfo *>(this);
-#ifdef FEATURE_TESTHOOKS
-    else if (riid == IID_ICLRTestHookManager)
-    {
-        *ppUnk=CLRTestHookManager::Start();
-        if(*ppUnk==NULL)
-            return E_OUTOFMEMORY;
-    }
-#endif // FEATURE_TESTHOOKS
-#endif // FEATURE_CORECLR
     else
         return (E_NOINTERFACE);
     AddRef();
     return (S_OK);
 }
 
-#ifndef FEATURE_CORECLR // CorHost isn't exposed externally
-//*****************************************************************************
-// Called by the class factory template to create a new instance of this object.
-//*****************************************************************************
-HRESULT CorHost::CreateObject(REFIID riid, void **ppUnk)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    CorHost *pCorHost = new (nothrow) CorHost();
-    if (!pCorHost)
-    {
-        hr = E_OUTOFMEMORY;
-    }
-    else
-    {
-        hr = pCorHost->QueryInterface(riid, ppUnk);
-
-    if (FAILED(hr))
-        delete pCorHost;
-    }
-    return (hr);
-}
-#endif // FEATURE_CORECLR
 
 #ifndef FEATURE_PAL
 HRESULT CorHost2::GetBucketParametersForCurrentException(BucketParameters *pParams)
@@ -3849,34 +1709,6 @@ HRESULT CorRuntimeHostBase::MapFile(HANDLE hFile, HMODULE* phHandle)
 
 ///////////////////////////////////////////////////////////////////////////////
 // IDebuggerInfo::IsDebuggerAttached
-#if !defined(FEATURE_CORECLR)
-HRESULT CorDebuggerInfo::IsDebuggerAttached(BOOL *pbAttached)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    if (pbAttached == NULL)
-        hr = E_INVALIDARG;
-    else
-#ifdef DEBUGGING_SUPPORTED
-    *pbAttached = (CORDebuggerAttached() != 0);
-#else
-    *pbAttached = FALSE;
-#endif
-
-    END_ENTRYPOINT_NOTHROW;
-
-    return hr;
-}
-#endif // !defined(FEATURE_CORECLR)
 
 LONG CorHost2::m_RefCount = 0;
 
@@ -3886,440 +1718,6 @@ LPCWSTR CorHost2::s_wszAppDomainManagerAsm = NULL;
 LPCWSTR CorHost2::s_wszAppDomainManagerType = NULL;
 EInitializeNewDomainFlags CorHost2::s_dwDomainManagerInitFlags = eInitializeNewDomainFlags_None;
 
-#ifndef FEATURE_CORECLR // not supported
-
-StringArrayList CorHost2::s_defaultDomainPropertyNames;
-StringArrayList CorHost2::s_defaultDomainPropertyValues;
-
-IHostMemoryManager *CorHost2::m_HostMemoryManager = NULL;
-IHostMalloc *CorHost2::m_HostMalloc = NULL;
-IHostTaskManager *CorHost2::m_HostTaskManager = NULL;
-IHostThreadpoolManager *CorHost2::m_HostThreadpoolManager = NULL;
-IHostIoCompletionManager *CorHost2::m_HostIoCompletionManager = NULL;
-IHostSyncManager *CorHost2::m_HostSyncManager = NULL;
-IHostAssemblyManager *CorHost2::m_HostAssemblyManager = NULL;
-IHostGCManager *CorHost2::m_HostGCManager = NULL;
-IHostSecurityManager *CorHost2::m_HostSecurityManager = NULL;
-IHostPolicyManager *CorHost2::m_HostPolicyManager = NULL;
-int CorHost2::m_HostOverlappedExtensionSize = -1;
-
-STARTUP_FLAGS CorHost2::m_dwStartupFlags = STARTUP_CONCURRENT_GC;
-WCHAR CorHost2::m_wzHostConfigFile[_MAX_PATH] = { 0 };
-
-BOOL CorHost2::m_dwFlagsFinalized = FALSE;
-DangerousNonHostedSpinLock CorHost2::m_FlagsLock;
-
-class CCLRMemoryNotificationCallback: public ICLRMemoryNotificationCallback
-{
-public:
-    virtual HRESULT STDMETHODCALLTYPE OnMemoryNotification(EMemoryAvailable eMemoryAvailable) {
-        CONTRACTL
-        {
-            NOTHROW;
-            GC_NOTRIGGER;
-            ENTRY_POINT;
-        }
-        CONTRACTL_END;
-
-        // We have not started runtime yet.
-        if (!g_fEEStarted)
-            return S_OK;
-
-        BEGIN_ENTRYPOINT_NOTHROW;
-
-        switch (eMemoryAvailable)
-        {
-        case eMemoryAvailableLow:
-            STRESS_LOG0(LF_GC, LL_INFO100, "Host delivers memory notification: Low\n");
-            break;
-        case eMemoryAvailableNeutral:
-            STRESS_LOG0(LF_GC, LL_INFO100, "Host delivers memory notification: Neutral\n");
-            break;
-        case eMemoryAvailableHigh:
-            STRESS_LOG0(LF_GC, LL_INFO100, "Host delivers memory notification: High\n");
-            break;
-        }
-        static DWORD lastTime = (DWORD)-1;
-        if (eMemoryAvailable == eMemoryAvailableLow)
-        {
-            FastInterlockIncrement ((LONG *)&g_bLowMemoryFromHost);
-            DWORD curTime = GetTickCount();
-            if (curTime < lastTime || curTime - lastTime >= 0x2000)
-            {
-                lastTime = curTime;
-                FinalizerThread::EnableFinalization();
-            }
-        }
-        else
-        {
-            FastInterlockExchange ((LONG *)&g_bLowMemoryFromHost, FALSE);
-        }
-        END_ENTRYPOINT_NOTHROW;
-
-        return S_OK;
-    }
-
-    virtual ULONG STDMETHODCALLTYPE AddRef(void)
-    {
-        LIMITED_METHOD_CONTRACT;
-        return 1;
-    }
-
-    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject)
-    {
-        LIMITED_METHOD_CONTRACT;
-        if (riid != IID_ICLRMemoryNotificationCallback && riid != IID_IUnknown)
-            return (E_NOINTERFACE);
-        *ppvObject = this;
-        return S_OK;
-    }
-
-    virtual ULONG STDMETHODCALLTYPE Release(void)
-    {
-        LIMITED_METHOD_CONTRACT;
-        return 1;
-    }
-};
-
-static CCLRMemoryNotificationCallback s_MemoryNotification;
-
-class CLRTaskManager : public ICLRTaskManager
-{
-public:
-    virtual ULONG STDMETHODCALLTYPE AddRef(void)
-    {
-        LIMITED_METHOD_CONTRACT;
-        return 1;
-    }
-
-    virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject) {
-        LIMITED_METHOD_CONTRACT;
-        if (riid != IID_ICLRTaskManager && riid != IID_IUnknown)
-            return (E_NOINTERFACE);
-        *ppvObject = this;
-        return S_OK;
-    }
-
-    virtual ULONG STDMETHODCALLTYPE Release(void)
-    {
-        LIMITED_METHOD_CONTRACT;
-        return 1;
-    }
-
-    virtual HRESULT STDMETHODCALLTYPE CreateTask(ICLRTask **pTask)
-    {
-        CONTRACTL
-        {
-            NOTHROW;
-            DISABLED(GC_NOTRIGGER);
-            ENTRY_POINT;
-        }
-        CONTRACTL_END;
-
-        HRESULT hr = S_OK;
-        BEGIN_ENTRYPOINT_NOTHROW;
-
-#ifdef _DEBUG
-        _ASSERTE (!CLRTaskHosted() || GetCurrentHostTask());
-#endif
-        _ASSERTE (GetThread() == NULL);
-        Thread *pThread = NULL;
-        pThread = SetupThreadNoThrow(&hr);
-        *pTask = pThread;
-
-        END_ENTRYPOINT_NOTHROW;
-
-        return hr;
-    }
-
-    virtual HRESULT STDMETHODCALLTYPE GetCurrentTask(ICLRTask **pTask)
-    {
-        // This function may be called due SQL SwitchIn/Out.  Contract may
-        // force memory allocation which is not allowed during Switch.
-        STATIC_CONTRACT_NOTHROW;
-        STATIC_CONTRACT_GC_NOTRIGGER;
-        STATIC_CONTRACT_SO_TOLERANT;
-        STATIC_CONTRACT_ENTRY_POINT;
-
-        *pTask = GetThread();
-        return S_OK;
-    }
-
-    virtual HRESULT STDMETHODCALLTYPE SetUILocale(LCID lcid)
-    {
-        Thread *pThread = GetThread();
-        if (pThread == NULL)
-            return HOST_E_INVALIDOPERATION;
-
-        CONTRACTL
-        {
-            GC_TRIGGERS;
-            NOTHROW;
-            MODE_PREEMPTIVE;
-            ENTRY_POINT;
-        }
-        CONTRACTL_END;
-
-        HRESULT hr = S_OK;
-        //BEGIN_ENTRYPOINT_NOTHROW;
-        BEGIN_EXTERNAL_ENTRYPOINT(&hr)
-        {
-            pThread->SetCultureId(lcid,TRUE);
-        }
-        END_EXTERNAL_ENTRYPOINT;
-        //END_ENTRYPOINT_NOTHROW;
-
-        return hr;
-    }
-
-    virtual HRESULT STDMETHODCALLTYPE SetLocale(LCID lcid)
-    {
-        Thread *pThread = GetThread();
-        if (pThread == NULL)
-            return HOST_E_INVALIDOPERATION;
-
-        CONTRACTL
-        {
-            GC_TRIGGERS;
-            NOTHROW;
-            MODE_PREEMPTIVE;
-            ENTRY_POINT;
-        }
-        CONTRACTL_END;
-
-        HRESULT hr = S_OK;
-        //BEGIN_ENTRYPOINT_NOTHROW;
-
-        BEGIN_EXTERNAL_ENTRYPOINT(&hr)
-        {
-            pThread->SetCultureId(lcid,FALSE);
-        }
-        END_EXTERNAL_ENTRYPOINT;
-        //END_ENTRYPOINT_NOTHROW;
-        return hr;
-    }
-
-    virtual HRESULT STDMETHODCALLTYPE GetCurrentTaskType(ETaskType *pTaskType)
-    {
-        CONTRACTL
-        {
-            NOTHROW;
-            GC_NOTRIGGER;
-            MODE_ANY;
-            ENTRY_POINT;
-        }
-        CONTRACTL_END;
-
-        BEGIN_ENTRYPOINT_NOTHROW;
-        *pTaskType = ::GetCurrentTaskType();
-        END_ENTRYPOINT_NOTHROW;
-
-        return S_OK;
-    }
-};
-
-static CLRTaskManager s_CLRTaskManager;
-
-class CLRSyncManager : public ICLRSyncManager
-{
-public:
-    virtual HRESULT STDMETHODCALLTYPE GetMonitorOwner(SIZE_T Cookie,
-                                                      IHostTask **ppOwnerHostTask)
-    {
-        CONTRACTL
-        {
-            NOTHROW;
-            MODE_PREEMPTIVE;
-            GC_NOTRIGGER;
-            ENTRY_POINT;;
-        }
-        CONTRACTL_END;
-
-        BEGIN_ENTRYPOINT_NOTHROW;
-
-        // Cookie is the SyncBlock
-        // <TODO>TODO: Lifetime of Cookie?</TODO>
-        AwareLock* pAwareLock = (AwareLock*)Cookie;
-        IHostTask *pTask = NULL;
-        Thread *pThread = pAwareLock->GetOwningThread();
-        if (pThread)
-        {
-            ThreadStoreLockHolder tsLock;
-            pThread = pAwareLock->GetOwningThread();
-            if (pThread)
-            {
-                // See if the lock is orphaned, and the Thread object has been deleted
-                Thread *pWalk = NULL;
-                while ((pWalk = ThreadStore::GetAllThreadList(pWalk, 0, 0)) != NULL)
-                {
-                    if (pWalk == pThread)
-                    {
-                        pTask = pThread->GetHostTaskWithAddRef();
-                        break;
-                    }
-                }
-            }
-        }
-
-        *ppOwnerHostTask = pTask;
-
-        END_ENTRYPOINT_NOTHROW;
-
-
-        return S_OK;
-    }
-    virtual HRESULT STDMETHODCALLTYPE CreateRWLockOwnerIterator(SIZE_T Cookie,
-                                                                SIZE_T *pIterator) {
-        Thread *pThread = GetThread();
-
-        // We may open a window for GC here.
-        // A host should not hijack a coop thread to do deadlock detection.
-        if (pThread && pThread->PreemptiveGCDisabled())
-            return HOST_E_INVALIDOPERATION;
-
-        CONTRACTL
-        {
-            NOTHROW;
-            MODE_PREEMPTIVE;
-            GC_NOTRIGGER;
-            ENTRY_POINT;
-        }
-        CONTRACTL_END;
-
-        HRESULT hr = E_FAIL;
-
-#ifdef FEATURE_RWLOCK
-        BEGIN_ENTRYPOINT_NOTHROW;
-        ThreadStoreLockHolder tsLock;
-        // Cookie is a weak handle.  We need to make sure that the object is not moving.
-        CRWLock *pRWLock = *(CRWLock **) Cookie;
-        *pIterator = NULL;
-        if (pRWLock == NULL)
-        {
-            hr = S_OK;
-        }
-        else
-        {
-            hr = pRWLock->CreateOwnerIterator(pIterator);
-        }
-        END_ENTRYPOINT_NOTHROW;
-#endif // FEATURE_RWLOCK
-
-        return hr;
-    }
-
-    virtual HRESULT STDMETHODCALLTYPE GetRWLockOwnerNext(SIZE_T Iterator,
-                                                         IHostTask **ppOwnerHostTask)
-    {
-        CONTRACTL
-        {
-            NOTHROW;
-            GC_NOTRIGGER;
-            ENTRY_POINT;
-        }
-        CONTRACTL_END;
-
-#ifdef FEATURE_RWLOCK
-        BEGIN_ENTRYPOINT_NOTHROW;
-        CRWLock::GetNextOwner(Iterator,ppOwnerHostTask);
-        END_ENTRYPOINT_NOTHROW;
-#endif // FEATURE_RWLOCK
-
-        return S_OK;
-    }
-
-    virtual HRESULT STDMETHODCALLTYPE DeleteRWLockOwnerIterator(SIZE_T Iterator)
-    {
-        CONTRACTL
-        {
-            NOTHROW;
-            GC_NOTRIGGER;
-            ENTRY_POINT;
-        }
-        CONTRACTL_END;
-
-#ifdef FEATURE_RWLOCK
-        BEGIN_ENTRYPOINT_NOTHROW;
-        CRWLock::DeleteOwnerIterator(Iterator);
-        END_ENTRYPOINT_NOTHROW;
-#endif // FEATURE_RWLOCK
-
-        return S_OK;
-    }
-
-    virtual ULONG STDMETHODCALLTYPE AddRef(void)
-    {
-        LIMITED_METHOD_CONTRACT;
-        return 1;
-    }
-
-    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject)
-    {
-        LIMITED_METHOD_CONTRACT;
-        if (riid != IID_ICLRSyncManager && riid != IID_IUnknown)
-            return (E_NOINTERFACE);
-        *ppvObject = this;
-        return S_OK;
-    }
-
-    virtual ULONG STDMETHODCALLTYPE Release(void)
-    {
-        LIMITED_METHOD_CONTRACT;
-        return 1;
-    }
-};
-
-static CLRSyncManager s_CLRSyncManager;
-
-extern void HostIOCompletionCallback(DWORD ErrorCode,
-                                     DWORD numBytesTransferred,
-                                     LPOVERLAPPED lpOverlapped);
-class CCLRIoCompletionManager :public ICLRIoCompletionManager
-{
-public:
-    virtual HRESULT STDMETHODCALLTYPE OnComplete(DWORD dwErrorCode,
-                                                 DWORD NumberOfBytesTransferred,
-                                                 void* pvOverlapped)
-    {
-        WRAPPER_NO_CONTRACT;
-        STATIC_CONTRACT_ENTRY_POINT;
-
-        if (pvOverlapped)
-        {
-            BEGIN_ENTRYPOINT_NOTHROW;
-            HostIOCompletionCallback (dwErrorCode, NumberOfBytesTransferred, (LPOVERLAPPED)pvOverlapped);
-            END_ENTRYPOINT_NOTHROW;
-        }
-
-        return S_OK;
-    }
-
-    virtual ULONG STDMETHODCALLTYPE AddRef(void)
-    {
-        STATIC_CONTRACT_SO_TOLERANT;
-        LIMITED_METHOD_CONTRACT;
-        return 1;
-    }
-
-    virtual ULONG STDMETHODCALLTYPE Release(void)
-    {
-        STATIC_CONTRACT_SO_TOLERANT;
-        LIMITED_METHOD_CONTRACT;
-        return 1;
-    }
-    BEGIN_INTERFACE HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject)
-    {
-        STATIC_CONTRACT_SO_TOLERANT;
-        LIMITED_METHOD_CONTRACT;
-        if (riid != IID_ICLRIoCompletionManager && riid != IID_IUnknown)
-            return (E_NOINTERFACE);
-        *ppvObject = this;
-        return S_OK;
-    }
-};
-
-static CCLRIoCompletionManager s_CLRIoCompletionManager;
-#endif // FEATURE_CORECLR
 
 #ifdef _DEBUG
 extern void ValidateHostInterface();
@@ -4375,181 +1773,9 @@ HRESULT CorHost2::SetHostControl(IHostControl* pHostControl)
 
     while (FastInterlockExchange((LONG*)&fOneOnly, 1) == 1)
     {
-    #ifndef FEATURE_CORECLR
-        if (m_HostTaskManager != NULL)
-        {
-            m_HostTaskManager->SwitchToTask(0);
-        }
-        else
-        {
-            IHostTaskManager *pHostTaskManager = NULL;
-            if (pHostControl->GetHostManager(IID_IHostTaskManager, (void**)&pHostTaskManager) == S_OK &&
-                pHostTaskManager != NULL)
-            {
-                pHostTaskManager->SwitchToTask(0);
-                pHostTaskManager->Release();
-            }
-            else
-            {
-                __SwitchToThread(0, ++dwSwitchCount);
-            }
-        }
-    #else
              __SwitchToThread(0, ++dwSwitchCount);
-    #endif //  FEATURE_CORECLR        
     }
     
-#ifndef FEATURE_CORECLR
-
-#ifdef _DEBUG
-    ValidateHostInterface();
-#endif
-
-#ifdef _DEBUG
-    DWORD dbg_HostManagerConfig = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_HostManagerConfig);
-#endif
-
-    IHostMemoryManager *memoryManager = NULL;
-    IHostTaskManager *taskManager = NULL;
-    IHostThreadpoolManager *threadpoolManager = NULL;
-    IHostIoCompletionManager *ioCompletionManager = NULL;
-    IHostSyncManager *syncManager = NULL;
-    IHostAssemblyManager *assemblyManager = NULL;
-    IHostGCManager *gcManager = NULL;
-    IHostSecurityManager *securityManager = NULL;
-    IHostPolicyManager *policyManager = NULL;
-
-    if (m_HostMemoryManager == NULL &&
-#ifdef _DEBUG
-        (dbg_HostManagerConfig & CLRMEMORYHOSTED) &&
-#endif
-        pHostControl->GetHostManager(IID_IHostMemoryManager,(void**)&memoryManager) == S_OK &&
-        memoryManager != NULL) {
-        if (m_HostMalloc == NULL)
-        {
-            hr = memoryManager->CreateMalloc (MALLOC_THREADSAFE, &m_HostMalloc);
-            if (hr == S_OK)
-            {
-                memoryManager->RegisterMemoryNotificationCallback(&s_MemoryNotification);
-            }
-            else
-            {
-                memoryManager->Release();
-                IfFailGo(E_UNEXPECTED);
-            }
-        }
-        m_HostMemoryManager = memoryManager;
-        g_fHostConfig |= CLRMEMORYHOSTED;
-    }
-
-    if (m_HostTaskManager == NULL &&
-#ifdef _DEBUG
-        (dbg_HostManagerConfig & CLRTASKHOSTED) &&
-#endif
-        pHostControl->GetHostManager(IID_IHostTaskManager,(void**)&taskManager) == S_OK &&
-        taskManager != NULL) {
-#ifdef _TARGET_ARM_ // @ARMTODO: re-enable once we support hosted p/invokes.
-        IfFailGo(E_NOTIMPL);
-#endif
-        m_HostTaskManager = taskManager;
-        m_HostTaskManager->SetCLRTaskManager(&s_CLRTaskManager);
-        g_fHostConfig |= CLRTASKHOSTED;
-    }
-
-    if (m_HostThreadpoolManager == NULL &&
-#ifdef _DEBUG
-        (dbg_HostManagerConfig & CLRTHREADPOOLHOSTED) &&
-#endif
-        pHostControl->GetHostManager(IID_IHostThreadpoolManager,(void**)&threadpoolManager) == S_OK &&
-        threadpoolManager != NULL) {
-        m_HostThreadpoolManager = threadpoolManager;
-        g_fHostConfig |= CLRTHREADPOOLHOSTED;
-    }
-
-    if (m_HostIoCompletionManager == NULL &&
-#ifdef _DEBUG
-        (dbg_HostManagerConfig & CLRIOCOMPLETIONHOSTED) &&
-#endif
-        pHostControl->GetHostManager(IID_IHostIoCompletionManager,(void**)&ioCompletionManager) == S_OK &&
-        ioCompletionManager != NULL) {
-        DWORD hostSize;
-        hr = ioCompletionManager->GetHostOverlappedSize(&hostSize);
-        if (FAILED(hr))
-        {
-            ioCompletionManager->Release();
-            IfFailGo(E_UNEXPECTED);
-        }
-        m_HostOverlappedExtensionSize = (int)hostSize;
-        m_HostIoCompletionManager = ioCompletionManager;
-        m_HostIoCompletionManager->SetCLRIoCompletionManager(&s_CLRIoCompletionManager);
-        g_fHostConfig |= CLRIOCOMPLETIONHOSTED;
-    }
-
-    if (m_HostSyncManager == NULL &&
-#ifdef _DEBUG
-        (dbg_HostManagerConfig & CLRSYNCHOSTED) &&
-#endif
-        pHostControl->GetHostManager(IID_IHostSyncManager,(void**)&syncManager) == S_OK &&
-        syncManager != NULL) {
-        m_HostSyncManager = syncManager;
-        m_HostSyncManager->SetCLRSyncManager(&s_CLRSyncManager);
-        g_fHostConfig |= CLRSYNCHOSTED;
-    }
-
-    if (m_HostAssemblyManager == NULL &&
-#ifdef _DEBUG
-        (dbg_HostManagerConfig & CLRASSEMBLYHOSTED) &&
-#endif
-        pHostControl->GetHostManager(IID_IHostAssemblyManager,(void**)&assemblyManager) == S_OK &&
-        assemblyManager != NULL) {
-
-        assemblyManager->GetAssemblyStore(&g_pHostAssemblyStore);
-
-        hr = assemblyManager->GetNonHostStoreAssemblies(&g_pHostAsmList);
-        if (FAILED(hr))
-        {
-            assemblyManager->Release();
-            IfFailGo(hr);
-        }
-
-        if (g_pHostAssemblyStore || g_pHostAsmList)
-            g_bFusionHosted = TRUE;
-        m_HostAssemblyManager = assemblyManager;
-        g_fHostConfig |= CLRASSEMBLYHOSTED;
-    }
-
-    if (m_HostGCManager == NULL &&
-#ifdef _DEBUG
-        (dbg_HostManagerConfig & CLRGCHOSTED) &&
-#endif
-        pHostControl->GetHostManager(IID_IHostGCManager,
-                                     (void**)&gcManager) == S_OK &&
-        gcManager != NULL) {
-        m_HostGCManager = gcManager;
-        g_fHostConfig |= CLRGCHOSTED;
-    }
-
-    if (m_HostSecurityManager == NULL &&
-#ifdef _DEBUG
-        (dbg_HostManagerConfig & CLRSECURITYHOSTED) &&
-#endif
-        pHostControl->GetHostManager(IID_IHostSecurityManager,
-                                     (void**)&securityManager) == S_OK &&
-        securityManager != NULL) {
-        g_fHostConfig |= CLRSECURITYHOSTED;
-        m_HostSecurityManager = securityManager;
-#ifdef FEATURE_CAS_POLICY
-        HostExecutionContextManager::InitializeRestrictedContext();
-#endif // #ifdef FEATURE_CAS_POLICY
-    }
-
-    if (m_HostPolicyManager == NULL &&
-        pHostControl->GetHostManager(IID_IHostPolicyManager,
-                                     (void**)&policyManager) == S_OK &&
-        policyManager != NULL) {
-        m_HostPolicyManager = policyManager;
-    }
-#endif //!FEATURE_CORECLR
 
     if (m_HostControl == NULL)
     {
@@ -4574,64 +1800,28 @@ public:
                                                        EPolicyAction action)
     {
         LIMITED_METHOD_CONTRACT;
-#ifndef FEATURE_CORECLR    
-        STATIC_CONTRACT_ENTRY_POINT;
-        HRESULT hr;
-        BEGIN_ENTRYPOINT_NOTHROW;
-        hr = GetEEPolicy()->SetDefaultAction(operation, action);
-        END_ENTRYPOINT_NOTHROW;
-        return hr;
-#else // FEATURE_CORECLR
         return E_NOTIMPL;
-#endif // !FEATURE_CORECLR        
     }
 
     virtual HRESULT STDMETHODCALLTYPE SetTimeout(EClrOperation operation,
                                                  DWORD dwMilliseconds)
     {
         LIMITED_METHOD_CONTRACT;
-#ifndef FEATURE_CORECLR    
-        STATIC_CONTRACT_ENTRY_POINT;
-        HRESULT hr;
-        BEGIN_ENTRYPOINT_NOTHROW;
-        hr = GetEEPolicy()->SetTimeout(operation,dwMilliseconds);
-        END_ENTRYPOINT_NOTHROW;
-        return hr;
-#else // FEATURE_CORECLR
         return E_NOTIMPL;
-#endif // !FEATURE_CORECLR          
     }
 
     virtual HRESULT STDMETHODCALLTYPE SetActionOnTimeout(EClrOperation operation,
                                                          EPolicyAction action)
     {
         LIMITED_METHOD_CONTRACT;
-#ifndef FEATURE_CORECLR    
-        STATIC_CONTRACT_ENTRY_POINT;
-        HRESULT hr;
-        BEGIN_ENTRYPOINT_NOTHROW;
-        hr = GetEEPolicy()->SetActionOnTimeout(operation,action);
-        END_ENTRYPOINT_NOTHROW;
-        return hr;
-#else // FEATURE_CORECLR
         return E_NOTIMPL;
-#endif // !FEATURE_CORECLR          
     }
 
     virtual HRESULT STDMETHODCALLTYPE SetTimeoutAndAction(EClrOperation operation, DWORD dwMilliseconds,
                                                           EPolicyAction action)
     {
         LIMITED_METHOD_CONTRACT;
-#ifndef FEATURE_CORECLR    
-        STATIC_CONTRACT_SO_TOLERANT;
-        HRESULT hr;
-        BEGIN_ENTRYPOINT_NOTHROW;
-        hr = GetEEPolicy()->SetTimeoutAndAction(operation,dwMilliseconds,action);
-        END_ENTRYPOINT_NOTHROW;
-        return hr;
-#else // FEATURE_CORECLR
         return E_NOTIMPL;
-#endif // !FEATURE_CORECLR          
     }
 
     virtual HRESULT STDMETHODCALLTYPE SetActionOnFailure(EClrFailure failure,
@@ -4642,7 +1832,6 @@ public:
         STATIC_CONTRACT_ENTRY_POINT;
         LIMITED_METHOD_CONTRACT;
         HRESULT hr;
-#ifdef FEATURE_CORECLR
         // For CoreCLR, this method just supports FAIL_AccessViolation as a valid
         // failure input arg. The validation of the specified action for the failure
         // will be done in EEPolicy::IsValidActionForFailure.
@@ -4650,7 +1839,6 @@ public:
         {
             return E_INVALIDARG;
         }
-#endif // FEATURE_CORECLR        
         BEGIN_ENTRYPOINT_NOTHROW;
         hr = GetEEPolicy()->SetActionOnFailure(failure,action);
         END_ENTRYPOINT_NOTHROW;
@@ -4660,16 +1848,7 @@ public:
     virtual HRESULT STDMETHODCALLTYPE SetUnhandledExceptionPolicy(EClrUnhandledException policy)
     {
         LIMITED_METHOD_CONTRACT;
-#ifndef FEATURE_CORECLR    
-        STATIC_CONTRACT_ENTRY_POINT;
-        HRESULT hr;
-        BEGIN_ENTRYPOINT_NOTHROW;
-        hr = GetEEPolicy()->SetUnhandledExceptionPolicy(policy);
-        END_ENTRYPOINT_NOTHROW;
-        return hr;
-#else // FEATURE_CORECLR
         return E_NOTIMPL;
-#endif // !FEATURE_CORECLR          
     }
 
     virtual ULONG STDMETHODCALLTYPE AddRef(void)
@@ -4705,427 +1884,22 @@ public:
 
 static CCLRPolicyManager s_PolicyManager;
 
-#ifndef FEATURE_CORECLR // not supported
-class CCLROnEventManager: public ICLROnEventManager
-{
-public:
-    virtual HRESULT STDMETHODCALLTYPE RegisterActionOnEvent(EClrEvent event,
-                                                            IActionOnCLREvent *pAction)
-    {
-        CONTRACTL
-        {
-            GC_TRIGGERS;
-            NOTHROW;
-            ENTRY_POINT;
-
-            // This function is always called from outside the Runtime. So, we assert that we either don't have a
-            // managed thread, or if we do, that we're in preemptive GC mode.
-            PRECONDITION((GetThread() == NULL) || !GetThread()->PreemptiveGCDisabled());
-        }
-        CONTRACTL_END;
-
-        if (event >= MaxClrEvent || pAction == NULL || event < (EClrEvent)0)
-            return E_INVALIDARG;
-
-        HRESULT hr = S_OK;
-        BEGIN_ENTRYPOINT_NOTHROW;
-
-        // Note: its only safe to use a straight ReleaseHolder from within the VM directory when we know we're
-        // called from outside the Runtime. We assert that above, just to be sure.
-        ReleaseHolder<IActionOnCLREvent>  actionHolder(pAction);
-        pAction->AddRef();
-
-        CrstHolderWithState ch(m_pLock);
-
-        DWORD dwSwitchCount = 0;
-        while (m_ProcessEvent != 0)
-        {
-            ch.Release();
-            __SwitchToThread(0, ++dwSwitchCount);
-            ch.Acquire();
-        }
-
-        if (m_pAction[event] == NULL)
-        {
-            m_pAction[event] = new (nothrow)ActionNode;
-            if (m_pAction[event] == NULL)
-                hr = E_OUTOFMEMORY;
-        }
-
-        if (SUCCEEDED(hr))
-        {
-            ActionNode *walk = m_pAction[event];
-            while (TRUE)
-            {
-                int n = 0;
-                for ( ; n < ActionNode::ActionArraySize; n ++)
-                {
-                    if (walk->pAction[n] == NULL)
-                    {
-                        walk->pAction[n] = pAction;
-                        actionHolder.SuppressRelease();
-                        hr = S_OK;
-                        break;
-                    }
-                }
-                if (n < ActionNode::ActionArraySize)
-                {
-                    break;
-                }
-                if (walk->pNext == NULL)
-                {
-                    walk->pNext = new (nothrow) ActionNode;
-                    if (walk->pNext == NULL)
-                    {
-                        hr = E_OUTOFMEMORY;
-                        break;
-                    }
-                }
-                walk = walk->pNext;
-            }
-        }
-
-        END_ENTRYPOINT_NOTHROW;
-        return hr;
-    }
-
-    virtual HRESULT STDMETHODCALLTYPE UnregisterActionOnEvent(EClrEvent event,
-                                                              IActionOnCLREvent *pAction)
-    {
-        CONTRACTL
-        {
-            GC_NOTRIGGER;
-            NOTHROW;
-            ENTRY_POINT;
-        }
-        CONTRACTL_END;
-
-        if (event == Event_StackOverflow)
-        {
-            // We don't want to take a lock when we process StackOverflow event, because we may
-            // not have enough stack to do it.
-            // So we do not release our cache of the callback in order to avoid race.
-            return HOST_E_INVALIDOPERATION;
-        }
-
-        HRESULT hr = S_OK;
-
-        ActionNode *walk = NULL;
-        ActionNode *prev = NULL;
-
-
-        BEGIN_ENTRYPOINT_NOTHROW;
-
-        CrstHolderWithState ch(m_pLock);
-
-        DWORD dwSwitchCount = 0;
-        while (m_ProcessEvent != 0)
-        {
-            ch.Release();
-            __SwitchToThread(0, ++dwSwitchCount);
-            ch.Acquire();
-        }
-
-        if (m_pAction[event] == NULL)
-            IfFailGo(HOST_E_INVALIDOPERATION);
-
-        walk = m_pAction[event];
-        while (walk)
-        {
-            BOOL fInUse = FALSE;
-            for (int n = 0; n < ActionNode::ActionArraySize; n ++)
-            {
-                if (prev && !fInUse && walk->pAction[n])
-                    fInUse = TRUE;
-                if (walk->pAction[n] == pAction)
-                {
-                    walk->pAction[n] = NULL;
-                    ch.Release();
-                    pAction->Release();
-                    hr = S_OK;
-                    goto ErrExit;
-                }
-            }
-            if (prev && !fInUse)
-            {
-                prev->pNext = walk->pNext;
-                delete walk;
-                walk = prev;
-            }
-            prev = walk;
-            walk = walk->pNext;
-        }
-        hr = HOST_E_INVALIDOPERATION;
-ErrExit:
-        END_ENTRYPOINT_NOTHROW;
-
-        return hr;
-    }
-
-    virtual ULONG STDMETHODCALLTYPE AddRef(void)
-    {
-        STATIC_CONTRACT_SO_TOLERANT;
-        LIMITED_METHOD_CONTRACT;
-        return 1;
-    }
-
-    virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppUnk)
-    {
-        STATIC_CONTRACT_SO_TOLERANT;
-        LIMITED_METHOD_CONTRACT;
-        if (riid != IID_ICLROnEventManager && riid != IID_IUnknown)
-            return (E_NOINTERFACE);
-        *ppUnk = this;
-        return S_OK;
-    }
-
-    virtual ULONG STDMETHODCALLTYPE Release(void)
-    {
-        STATIC_CONTRACT_SO_TOLERANT;
-        LIMITED_METHOD_CONTRACT;
-        return 1;
-    }
-
-    // This function is to work around an issue in scan.exe.
-    // scan.exe is not smart to handle that if (){} else {}.
-    void ProcessSOEvent(void *data)
-    {
-        STATIC_CONTRACT_SO_TOLERANT;
-        WRAPPER_NO_CONTRACT;
-
-        if (m_pLock == NULL)
-            return;
-
-        ActionNode *walk = m_pAction[Event_StackOverflow];
-
-            while (walk)
-            {
-                for (int n = 0; n < ActionNode::ActionArraySize; n ++)
-                {
-                    if (walk->pAction[n])
-                    {
-                    walk->pAction[n]->OnEvent(Event_StackOverflow,data);
-                    }
-                }
-                walk = walk->pNext;
-            }
-    }
-
-    void ProcessEvent(EClrEvent event, void *data)
-    {
-        WRAPPER_NO_CONTRACT;
-
-        if (m_pLock == NULL)
-        {
-            return;
-        }
-
-        _ASSERTE (event != Event_StackOverflow);
-
-        {
-            CrstHolder ch(m_pLock);
-
-            if (event == Event_ClrDisabled)
-            {
-                if (m_CLRDisabled)
-                {
-                    return;
-                }
-                m_CLRDisabled = TRUE;
-            }
-            m_ProcessEvent ++;
-
-            // Release the lock around the call into the host. Is this correct?
-            // It seems that we need to hold the lock except for the actual callback itself.
-        }
-
-        BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread());
-        {
-        ActionNode *walk = m_pAction[event];
-        while (walk)
-        {
-            for (int n = 0; n < ActionNode::ActionArraySize; n ++)
-            {
-                if (walk->pAction[n])
-                {
-                    walk->pAction[n]->OnEvent(event,data);
-                }
-            }
-            walk = walk->pNext;
-        }
-        }    
-        END_SO_TOLERANT_CODE_CALLING_HOST;
-
-        {
-            CrstHolder ch(m_pLock);
-            m_ProcessEvent --;
-        }
-    }
-
-    BOOL IsActionRegisteredForEvent(EClrEvent event)
-    {
-        WRAPPER_NO_CONTRACT;
-
-        // Check to see if the event manager has been set up.
-        if (m_pLock == NULL)
-            return FALSE;
-
-        CrstHolder ch(m_pLock);
-
-        ActionNode *walk = m_pAction[event];
-        while (walk)
-        {
-            for (int n = 0; n < ActionNode::ActionArraySize; n ++)
-            {
-                if (walk->pAction[n] != NULL)
-                {
-                    // We found an action registered for this event.
-                    return TRUE;
-                }
-            }
-            walk = walk->pNext;
-        }
-
-        // There weren't any actions registered.
-        return FALSE;
-    }
-
-    HRESULT Init()
-    {
-        STATIC_CONTRACT_NOTHROW;
-        STATIC_CONTRACT_GC_NOTRIGGER;
-        STATIC_CONTRACT_MODE_ANY;
-        STATIC_CONTRACT_SO_TOLERANT;
-
-        HRESULT hr = S_OK;
-        if (m_pLock == NULL)
-        {
-            EX_TRY
-            {
-                BEGIN_SO_INTOLERANT_CODE(GetThread());
-                {
-                InitHelper();
-            }
-                END_SO_INTOLERANT_CODE;
-            }
-            EX_CATCH
-            {
-                hr = GET_EXCEPTION()->GetHR();
-            }
-            EX_END_CATCH(SwallowAllExceptions);
-        }
-
-        return hr;
-    }
-
-#if 0
-    // We do not need this one.  We have one instance of this class
-    // and it is static.
-    CCLROnEventManager()
-    {
-        LIMITED_METHOD_CONTRACT;
-        for (int n = 0; n < MaxClrEvent; n ++)
-            m_pAction[n] = NULL;
-    }
-#endif
-
-private:
-    struct ActionNode
-    {
-        static const int ActionArraySize = 8;
-
-        IActionOnCLREvent *pAction[ActionArraySize];
-        ActionNode        *pNext;
-
-        ActionNode ()
-        : pNext(NULL)
-        {
-            LIMITED_METHOD_CONTRACT;
-
-            for (int n = 0; n < ActionArraySize; n ++)
-                pAction[n] = 0;
-        }
-    };
-    ActionNode *m_pAction[MaxClrEvent];
-
-    Crst* m_pLock;
-
-    BOOL m_CLRDisabled;
-
-    // We can not call out into host while holding the lock.  At the same time
-    // we need to make our data consistent.  Therefore, m_ProcessEvent is a marker
-    // to forbid touching the data structure from Register and UnRegister.
-    DWORD m_ProcessEvent;
-
-    void InitHelper()
-    {
-        CONTRACTL
-        {
-            GC_NOTRIGGER;
-            THROWS;
-            MODE_ANY;
-        }
-        CONTRACTL_END;
-
-        m_ProcessEvent = 0;
-
-        Crst* tmp = new Crst(CrstOnEventManager, CrstFlags(CRST_DEFAULT | CRST_DEBUGGER_THREAD));
-        if (FastInterlockCompareExchangePointer(&m_pLock, tmp, NULL) != NULL)
-            delete tmp;
-    }
-};
-
-static CCLROnEventManager s_OnEventManager;
-#endif // FEATURE_CORECLR
 
 
 void ProcessEventForHost(EClrEvent event, void *data)
 {
-#ifndef FEATURE_CORECLR
-    WRAPPER_NO_CONTRACT;
-
-    _ASSERTE (event != Event_StackOverflow);
-
-    GCX_PREEMP();
-
-    s_OnEventManager.ProcessEvent(event,data);
-#endif // FEATURE_CORECLR
 }
 
 // We do not call ProcessEventForHost for stack overflow, since we have limit stack
 // and we should avoid calling GCX_PREEMPT
 void ProcessSOEventForHost(EXCEPTION_POINTERS *pExceptionInfo, BOOL fInSoTolerant)
 {
-#ifndef FEATURE_CORECLR
-    WRAPPER_NO_CONTRACT;
-
-    StackOverflowInfo soInfo;
-    if (fInSoTolerant)
-    {
-        soInfo.soType = SO_Managed;
-    }
-    else if (pExceptionInfo == NULL || IsIPInModule(g_pMSCorEE, GetIP(pExceptionInfo->ContextRecord)))
-    {
-        soInfo.soType = SO_ClrEngine;
-    }
-    else
-    {
-        soInfo.soType = SO_Other;
-    }
-
-    soInfo.pExceptionInfo = pExceptionInfo;
-    s_OnEventManager.ProcessSOEvent(&soInfo);
-#endif // FEATURE_CORECLR
 }
 
 BOOL IsHostRegisteredForEvent(EClrEvent event)
 {
     WRAPPER_NO_CONTRACT;
-#ifdef FEATURE_CORECLR
     return FALSE;
-#else // FEATURE_CORECLR
-    return s_OnEventManager.IsActionRegisteredForEvent(event);
-#endif // FEATURE_CORECLR
 }
 
 inline size_t SizeInKBytes(size_t cbSize)
@@ -5154,7 +1928,7 @@ void UpdateGCSettingFromHost ()
     }
 }
 
-#if !defined(FEATURE_CORECLR) || defined(FEATURE_WINDOWSPHONE)
+#if defined(FEATURE_WINDOWSPHONE)
 class CCLRGCManager: public ICLRGCManager2
 {
 public:
@@ -5394,7 +2168,7 @@ HRESULT CCLRGCManager::_SetGCMaxGen0Size(SIZE_T MaxGen0Size)
 }
 
 static CCLRGCManager s_GCManager;
-#endif // !FEATURE_CORECLR || FEATURE_WINDOWSPHONE
+#endif //FEATURE_WINDOWSPHONE
 
 #ifdef FEATURE_APPDOMAIN_RESOURCE_MONITORING
 class CCLRAppDomainResourceMonitor : public ICLRAppDomainResourceMonitor
@@ -5542,100 +2316,6 @@ public:
 static CCLRAppDomainResourceMonitor s_Arm;
 #endif //FEATURE_APPDOMAIN_RESOURCE_MONITORING
 
-#ifdef FEATURE_APTCA
-class CLRDomainManager : public ICLRDomainManager
-{
-public:
-    virtual HRESULT STDMETHODCALLTYPE SetAppDomainManagerType(__in LPCWSTR wszAppDomainManagerAssembly,
-                                                              __in LPCWSTR wszAppDomainManagerType,
-                                                              EInitializeNewDomainFlags dwInitializeDomainFlags)
-    {
-        CONTRACTL
-        {
-            NOTHROW;
-            GC_NOTRIGGER;
-            ENTRY_POINT;
-        }
-        CONTRACTL_END;
-
-        HRESULT hr = S_OK;
-        BEGIN_ENTRYPOINT_NOTHROW;
-
-        hr = CorHost2::SetAppDomainManagerType(wszAppDomainManagerAssembly,
-                                               wszAppDomainManagerType,
-                                               dwInitializeDomainFlags);
-        END_ENTRYPOINT_NOTHROW;
-        return hr;
-    }
-
-    virtual HRESULT STDMETHODCALLTYPE SetPropertiesForDefaultAppDomain(DWORD nProperties,
-                                                                       __in_ecount(nProperties) LPCWSTR *pwszPropertyNames,
-                                                                       __in_ecount(nProperties) LPCWSTR *pwszPropertyValues)
-    {
-        CONTRACTL
-        {
-            NOTHROW;
-            GC_NOTRIGGER;
-        }
-        CONTRACTL_END;
-
-        HRESULT hr = S_OK;
-        BEGIN_ENTRYPOINT_NOTHROW;
-
-        hr = CorHost2::SetPropertiesForDefaultAppDomain(nProperties, pwszPropertyNames, pwszPropertyValues);
-
-        END_ENTRYPOINT_NOTHROW;
-        return hr;
-    }
-
-    virtual ULONG STDMETHODCALLTYPE AddRef()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return 1;
-    }
-
-    virtual ULONG STDMETHODCALLTYPE Release()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return 1;
-    }
-
-    virtual HRESULT STDMETHODCALLTYPE QueryInterface(__in REFIID riid, __out LPVOID *ppvObject)
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        if (ppvObject == NULL)
-            return E_POINTER;
-
-        *ppvObject = NULL;
-
-        if (riid == IID_ICLRDomainManager)
-        {
-            *ppvObject = this;
-        }
-        else if (riid == IID_IUnknown)
-        {
-            *ppvObject = static_cast<IUnknown *>(this);
-        }
-
-        if (*ppvObject == NULL)
-            return E_NOINTERFACE;
-
-        AddRef();
-        return S_OK;
-    }
-};
-
-static CLRDomainManager s_CLRDomainManager;
-#endif // FEATURE_APTCA
-
-BYTE g_CorHostProtectionManagerInstance[sizeof(CorHostProtectionManager)];
-
-void InitHostProtectionManager()
-{
-    WRAPPER_NO_CONTRACT;
-    new (g_CorHostProtectionManagerInstance) CorHostProtectionManager();
-}
 
 BOOL g_CLRPolicyRequested = FALSE;
 
@@ -5656,35 +2336,19 @@ public:
         if (ppObject == NULL)
             return E_INVALIDARG;
 
-#ifndef FEATURE_CORECLR
-        // ErrorReportingManager is allowed, even if runtime is started, so
-        //  make this check first.
-        // Host must call release on CLRErrorReportingManager after this call
-        if (riid == IID_ICLRErrorReportingManager)
-        {
-            *ppObject = &g_CLRErrorReportingManager;
-            return S_OK;
-        }
-        else 
-#elif defined(FEATURE_WINDOWSPHONE)
+#if defined(FEATURE_WINDOWSPHONE)
         if (riid == IID_ICLRErrorReportingManager2)
         {
             *ppObject = &g_CLRErrorReportingManager;
             return S_OK;
         }
         else
-#endif // !FEATURE_CORECLR || defined(FEATURE_WINDOWSPHONE)
+#endif //defined(FEATURE_WINDOWSPHONE)
         if (g_fEEStarted && !m_fFullAccess)
         {
             // If runtime has been started, do not allow user to obtain CLR managers.
             return HOST_E_INVALIDOPERATION;
         }
-#ifndef FEATURE_CORECLR
-        else if (riid == IID_ICLRTaskManager) {
-            *ppObject = &s_CLRTaskManager;
-            return S_OK;
-        }
-#endif // !FEATURE_CORECLR      
 
         // CoreCLR supports ICLRPolicyManager since it allows the host
         // to specify the policy for AccessViolation.  
@@ -5693,36 +2357,14 @@ public:
             FastInterlockExchange((LONG*)&g_CLRPolicyRequested, TRUE);
             return S_OK;
         }
-#ifndef FEATURE_CORECLR        
-        else if (riid == IID_ICLRHostProtectionManager) {
-            *ppObject = GetHostProtectionManager();
-            return S_OK;
-        }
-
-        // Host must call release on CLRDebugManager after this call
-        else if (riid == IID_ICLRDebugManager)
-        {
-            *ppObject = &s_CLRDebugManager;
-            return S_OK;
-        }
 
-        else if (riid == IID_ICLROnEventManager)
-        {
-            HRESULT hr = s_OnEventManager.Init();
-            if (FAILED(hr))
-                return hr;
-            *ppObject = &s_OnEventManager;
-            return S_OK;
-        }
-#endif // !FEATURE_CORECLR
-
-#if !defined(FEATURE_CORECLR) || defined(FEATURE_WINDOWSPHONE)
+#if defined(FEATURE_WINDOWSPHONE)
         else if ((riid == IID_ICLRGCManager) || (riid == IID_ICLRGCManager2))
         {
             *ppObject = &s_GCManager;
             return S_OK;
         }
-#endif // !FEATURE_CORECLR || FEATURE_WINDOWSPHONE
+#endif //FEATURE_WINDOWSPHONE
 
 #ifdef FEATURE_APPDOMAIN_RESOURCE_MONITORING
         else if (riid == IID_ICLRAppDomainResourceMonitor)
@@ -5732,13 +2374,6 @@ public:
             return S_OK;
         }
 #endif //FEATURE_APPDOMAIN_RESOURCE_MONITORING
-#ifdef FEATURE_APTCA
-        else if (riid == IID_ICLRDomainManager)
-        {
-            *ppObject = &s_CLRDomainManager;
-            return S_OK;
-        }
-#endif // FEATURE_APTCA
         else
             return (E_NOINTERFACE);
     }
@@ -5747,29 +2382,9 @@ public:
         LPCWSTR pwzAppDomainManagerAssembly,
         LPCWSTR pwzAppDomainManagerType)
     {
-#ifndef FEATURE_CORECLR    
-        CONTRACTL
-        {
-            NOTHROW;
-            GC_NOTRIGGER;
-            ENTRY_POINT;    // no global state updates
-        }
-        CONTRACTL_END;
-
-        HRESULT hr = S_OK;
-
-        BEGIN_ENTRYPOINT_NOTHROW;
-
-        hr = CorHost2::SetAppDomainManagerType(pwzAppDomainManagerAssembly,
-                                               pwzAppDomainManagerType,
-                                               eInitializeNewDomainFlags_None);
-        END_ENTRYPOINT_NOTHROW;
-        return hr;
-#else // FEATURE_CORECLR
         
         // CoreCLR does not support this method
         return E_NOTIMPL;
-#endif // !FEATURE_CORECLR        
     }
 
     virtual ULONG STDMETHODCALLTYPE AddRef(void)
@@ -5814,9 +2429,6 @@ private:
 // After CLR starts, we give out s_CorCLRControlLimited which allows limited access to managers.
 static CCorCLRControl s_CorCLRControl;
 
-#ifndef FEATURE_CORECLR
-static CCorCLRControl s_CorCLRControlLimited;
-#endif // FEATURE_CORECLR
 
 ///////////////////////////////////////////////////////////////////////////////
 // ICLRRuntimeHost::GetCLRControl
@@ -5841,11 +2453,6 @@ HRESULT CorHost2::GetCLRControl(ICLRControl** pCLRControl)
     }
     else
     {
-#ifndef FEATURE_CORECLR
-        // Even CLR is hosted by v1 hosting interface, we still allow part of CLRControl, like IID_ICLRErrorReportingManager.
-        s_CorCLRControlLimited.SetAccess(FALSE);
-        *pCLRControl = &s_CorCLRControlLimited;
-#else // FEATURE_CORECLR
         // If :
         // 1) request comes for interface other than ICLRControl*, OR
         // 2) runtime has already started, OR
@@ -5862,175 +2469,30 @@ HRESULT CorHost2::GetCLRControl(ICLRControl** pCLRControl)
         {
             hr = E_NOTIMPL;
         }
-#endif // !FEATURE_CORECLR    
     }
     END_ENTRYPOINT_NOTHROW;
 
     return hr;
 }
 
-#ifndef FEATURE_CORECLR
-
-// static
-HRESULT CorHost2::SetPropertiesForDefaultAppDomain(DWORD nProperties,
-                                                    __in_ecount(nProperties) LPCWSTR *pwszPropertyNames,
-                                                    __in_ecount(nProperties) LPCWSTR *pwszPropertyValues)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    // Default domain properties can only be set before the CLR has started
-    if (g_fEEStarted || HasStarted())
-    {
-        return HOST_E_INVALIDOPERATION;
-    }
-
-    // If the host is specifying properties, they should be there
-    if (nProperties > 0 && (pwszPropertyNames == NULL || pwszPropertyValues == NULL))
-    {
-        return E_POINTER;
-    }
-
-    // v4 - since this property is being added late in the cycle to address a specific scenario, we
-    // reject any attempt to set anything but a single well known property name.  This restriction
-    // can be removed in the future.
-    for (DWORD iProperty = 0; iProperty < nProperties; ++iProperty)
-    {
-        if (pwszPropertyNames[iProperty] == NULL)
-        {
-            return E_POINTER;
-        }
-        if (pwszPropertyValues[iProperty] == NULL)
-        {
-            return E_POINTER;
-        }
-        if (wcscmp(PARTIAL_TRUST_VISIBLE_ASSEMBLIES_PROPERTY, pwszPropertyNames[iProperty]) != 0)
-        {
-            return HRESULT_FROM_WIN32(ERROR_UNKNOWN_PROPERTY);
-        }
-    }
-
-    HRESULT hr = S_OK;
-
-    EX_TRY
-    {
-        for (DWORD iProperty = 0; iProperty < nProperties; ++iProperty)
-        {
-            SString propertyName(pwszPropertyNames[iProperty]);
-            s_defaultDomainPropertyNames.Append(propertyName);
-
-            SString propertyValue(pwszPropertyValues[iProperty]);
-            s_defaultDomainPropertyValues.Append(propertyValue);
-        }
-    }
-    EX_CATCH_HRESULT(hr);
-
-    return hr;
-}
-
-// static
-HRESULT CorHost2::SetAppDomainManagerType(LPCWSTR wszAppDomainManagerAssembly,
-                                          LPCWSTR wszAppDomainManagerType,
-                                          EInitializeNewDomainFlags dwInitializeDomainFlags)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    // The AppDomainManger can only be set by the host before the CLR has started
-    if (g_fEEStarted || HasStarted())
-    {
-        return HOST_E_INVALIDOPERATION;
-    }
-
-    // Both the type and assembly must be specified
-    if (wszAppDomainManagerAssembly == NULL || wszAppDomainManagerType == NULL)
-    {
-        return E_INVALIDARG;
-    }
-    
-    // Make sure we understand the incoming flags
-    const EInitializeNewDomainFlags knownFlags = eInitializeNewDomainFlags_NoSecurityChanges;
-    if ((dwInitializeDomainFlags & (~knownFlags)) != eInitializeNewDomainFlags_None)
-    {
-        return E_INVALIDARG;
-    }
-
-    // Get a copy of the AppDomainManager assembly
-    size_t cchAsm = wcslen(wszAppDomainManagerAssembly) + 1;
-    NewArrayHolder<WCHAR> wszAppDomainManagerAssemblyCopy(new (nothrow) WCHAR[cchAsm]);
-    if (wszAppDomainManagerAssemblyCopy == NULL)
-    {
-        return E_OUTOFMEMORY;
-    }
-    wcsncpy_s(wszAppDomainManagerAssemblyCopy, cchAsm, wszAppDomainManagerAssembly, cchAsm - 1);
-
-    // And of the AppDomainManagerType
-    size_t cchType = wcslen(wszAppDomainManagerType) + 1;
-    NewArrayHolder<WCHAR> wszAppDomainManagerTypeCopy(new (nothrow) WCHAR[cchType]);
-    if (wszAppDomainManagerTypeCopy == NULL)
-    {
-        return E_OUTOFMEMORY;
-    }
-    wcsncpy_s(wszAppDomainManagerTypeCopy, cchType, wszAppDomainManagerType, cchType - 1);
-
-    LPCWSTR wszOldAsmValue = FastInterlockCompareExchangePointer(&s_wszAppDomainManagerAsm,
-                                                                 static_cast<LPCWSTR>(wszAppDomainManagerAssemblyCopy.GetValue()),
-                                                                 NULL);
-    if (wszOldAsmValue != NULL)
-    {
-        // We've tried to setup an AppDomainManager twice ... that's not allowed
-        return HOST_E_INVALIDOPERATION;
-    }
-
-    s_wszAppDomainManagerType = wszAppDomainManagerTypeCopy;
-    s_dwDomainManagerInitFlags = dwInitializeDomainFlags;
-
-    wszAppDomainManagerAssemblyCopy.SuppressRelease();
-    wszAppDomainManagerTypeCopy.SuppressRelease();
-    return S_OK;
-}
-#endif // !FEATURE_CORECLR
 
 LPCWSTR CorHost2::GetAppDomainManagerAsm()
 {
     LIMITED_METHOD_CONTRACT;
-#ifdef FEATURE_CORECLR
     return NULL;
-#else // FEATURE_CORECLR
-    _ASSERTE (g_fEEStarted);
-    return s_wszAppDomainManagerAsm;
-#endif // FEATURE_CORECLR
 }
 
 LPCWSTR CorHost2::GetAppDomainManagerType()
 {
     LIMITED_METHOD_CONTRACT;
-#ifdef FEATURE_CORECLR
     return NULL;
-#else // FEATURE_CORECLR
-    _ASSERTE (g_fEEStarted);
-    return s_wszAppDomainManagerType;
-#endif // FEATURE_CORECLR
 }
 
 // static
 EInitializeNewDomainFlags CorHost2::GetAppDomainManagerInitializeNewDomainFlags()
 {
     LIMITED_METHOD_CONTRACT;
-#ifdef FEATURE_CORECLR
     return eInitializeNewDomainFlags_None;
-#else // FEAUTRE_CORECLR
-    _ASSERTE (g_fEEStarted);
-    return s_dwDomainManagerInitFlags;
-#endif // FEATURE_CORECLR
 }
 
 #ifdef FEATURE_INCLUDE_ALL_INTERFACES
@@ -7330,9 +3792,6 @@ struct ClrTlsInfo
 
 #define DataToClrTlsInfo(a) (a)?(ClrTlsInfo*)((BYTE*)a - offsetof(ClrTlsInfo, data)):NULL
 
-#if !defined(FEATURE_CORECLR)
-#define HAS_FLS_SUPPORT 1
-#endif
 
 #ifdef HAS_FLS_SUPPORT
 
@@ -8439,11 +4898,11 @@ SIZE_T STDMETHODCALLTYPE CExecutionEngine::ClrVirtualQuery(LPCVOID lpAddress,
 }
 #define ClrVirtualQuery EEVirtualQuery
 
-#if defined(_DEBUG) && defined(FEATURE_CORECLR) && !defined(FEATURE_PAL)
+#if defined(_DEBUG) && !defined(FEATURE_PAL)
 static VolatilePtr<BYTE> s_pStartOfUEFSection = NULL;
 static VolatilePtr<BYTE> s_pEndOfUEFSectionBoundary = NULL;
 static Volatile<DWORD> s_dwProtection = 0;
-#endif // _DEBUG && FEATURE_CORECLR && !FEATURE_PAL
+#endif // _DEBUG && !FEATURE_PAL
 
 #undef ClrVirtualProtect
 
@@ -8489,7 +4948,7 @@ BOOL STDMETHODCALLTYPE CExecutionEngine::ClrVirtualProtect(LPVOID lpAddress,
    //
    // We assert if either of the two conditions above are true.
 
-#if defined(_DEBUG) && defined(FEATURE_CORECLR) && !defined(FEATURE_PAL)
+#if defined(_DEBUG) && !defined(FEATURE_PAL)
    // We do this check in debug/checked builds only
 
     // Do we have the UEF details?
@@ -8559,7 +5018,7 @@ BOOL STDMETHODCALLTYPE CExecutionEngine::ClrVirtualProtect(LPVOID lpAddress,
                 "Do not virtual protect the section in which UEF lives!");
         }
     }
-#endif // _DEBUG && FEATURE_CORECLR && !FEATURE_PAL
+#endif // _DEBUG && !FEATURE_PAL
 
     return EEVirtualProtect(lpAddress, dwSize, flNewProtect, lpflOldProtect);
 }
@@ -8663,14 +5122,11 @@ void CExecutionEngine::GetLastThrownObjectExceptionFromThread(void **ppvExceptio
 } // HRESULT CExecutionEngine::GetLastThrownObjectExceptionFromThread()
 
 
-#ifdef FEATURE_VERSIONING
 LocaleID RuntimeGetFileSystemLocale()
 {
     return PEImage::GetFileSystemLocale();
 };
-#endif
 
-#ifdef FEATURE_CORECLR
 HRESULT CorHost2::DllGetActivationFactory(DWORD appDomainID, LPCWSTR wszTypeName, IActivationFactory ** factory)
 {
 #ifdef FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION
@@ -8700,7 +5156,6 @@ HRESULT CorHost2::DllGetActivationFactory(DWORD appDomainID, LPCWSTR wszTypeName
     return E_NOTIMPL;
 #endif
 }
-#endif
 
 
 #ifdef FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION
@@ -8725,16 +5180,6 @@ HRESULT STDMETHODCALLTYPE DllGetActivationFactoryImpl(LPCWSTR wszAssemblyName,
 
     AppDomain* pDomain = SystemDomain::System()->DefaultDomain();
     _ASSERTE(pDomain);
-#ifndef FEATURE_CORECLR // coreclr uses winrt binder which does not allow redirects
-    {
-        BaseDomain::LockHolder lh(pDomain);
-        if (!pDomain->HasLoadContextHostBinder())
-        {
-            // don't allow redirects
-            SystemDomain::InitializeDefaultDomain(FALSE);
-        }
-    }
-#endif
 
     BEGIN_EXTERNAL_ENTRYPOINT(&hr);
     {
@@ -8749,16 +5194,6 @@ HRESULT STDMETHODCALLTYPE DllGetActivationFactoryImpl(LPCWSTR wszAssemblyName,
             } gc;
             memset(&gc, 0, sizeof(gc));
 
-#if defined(FEATURE_MULTICOREJIT) && defined(FEATURE_APPX_BINDER)
-            // For Appx, multicore JIT is only needed when root assembly does not have NI image
-            // When it has NI image, we can't generate profile, and do not need to playback profile
-            if (AppX::IsAppXProcess() && ! typeHandle.IsZapped())
-            {
-                GCX_PREEMP();
-
-                pDomain->GetMulticoreJitManager().AutoStartProfileAppx(pDomain);
-            }
-#endif
 
             IActivationFactory* activationFactory;
             GCPROTECT_BEGIN(gc);
@@ -8789,64 +5224,6 @@ HRESULT STDMETHODCALLTYPE DllGetActivationFactoryImpl(LPCWSTR wszAssemblyName,
 #endif // !FEATURE_COMINTEROP_MANAGED_ACTIVATION
 
 
-#ifdef FEATURE_COMINTEROP_WINRT_DESKTOP_HOST
-
-HRESULT STDMETHODCALLTYPE GetClassActivatorForApplicationImpl(HSTRING appPath, IWinRTClassActivator** ppActivator)
-{
-    CONTRACTL
-    {
-        DISABLED(NOTHROW);
-        GC_TRIGGERS;
-        MODE_ANY;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-    BEGIN_EXTERNAL_ENTRYPOINT(&hr);
-    {
-        if (GetAppDomain()->GetWinRtBinder()->SetLocalWinMDPath(appPath))
-        {
-            GCX_COOP();
-
-            struct
-            {
-                STRINGREF appbase;
-            } gc;
-            ZeroMemory(&gc, sizeof(gc));
-            GCPROTECT_BEGIN(gc);
-
-            UINT32 appPathLength = 0;
-            PCWSTR wszAppPath = WindowsGetStringRawBuffer(appPath, &appPathLength);
-
-            gc.appbase = StringObject::NewString(wszAppPath, appPathLength);
-
-            MethodDescCallSite getClassActivator(METHOD__WINDOWSRUNTIMEMARSHAL__GET_CLASS_ACTIVATOR_FOR_APPLICATION);
-
-            ARG_SLOT args[] =
-            {
-                ObjToArgSlot(gc.appbase)
-            };
-
-            IWinRTClassActivator* pActivator = reinterpret_cast<IWinRTClassActivator *>(getClassActivator.Call_RetLPVOID(args));
-            *ppActivator = pActivator;
-
-            GCPROTECT_END();
-        }
-        else
-        {
-            hr = CO_E_BAD_PATH;
-        }
-    }
-    END_EXTERNAL_ENTRYPOINT;
-    END_ENTRYPOINT_NOTHROW;
-
-    return hr;
-}
-
-#endif // FEATURE_COMINTEROP_WINRT_DESKTOP_HOST
 
 
 #endif // !DACCESS_COMPILE
diff --git a/src/vm/crossdomaincalls.cpp b/src/vm/crossdomaincalls.cpp
deleted file mode 100644
index b528915a54..0000000000
--- a/src/vm/crossdomaincalls.cpp
+++ /dev/null
@@ -1,2587 +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.
-// 
-// File: CrossDomainCalls.cpp
-// 
-
-// 
-// The CrossDomainCall class provides a fast path of execution for qualifying
-// cross domain calls. Asynch calls, one way calls, calls on context bound objects
-// etc dont qualify.
-// 
-
-
-#include "common.h"
-
-#ifdef FEATURE_REMOTING
-
-#include "crossdomaincalls.h"
-#include "callhelpers.h"
-#include "remoting.h"
-#include "objectclone.h"
-#include "dbginterface.h"
-#include "stackprobe.h"
-#include "virtualcallstub.h"
-#include "typeparse.h"
-#include "typestring.h"
-#include "appdomain.inl"
-#include "callingconvention.h"
-
-// See explanation of flags in crossdomaincalls.h
-RemotableMethodInfo::XADOptimizationType
-RemotableMethodInfo::IsCrossAppDomainOptimizable(MethodDesc *pMeth, DWORD *pNumStackSlotsToCopy)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-
-    // This method table might be representative, but that's OK for the kinds of analysis we're about to do.
-    MethodTable *pMT = pMeth->GetMethodTable()->GetCanonicalMethodTable();
-
-    _ASSERTE(pMT->HasRemotableMethodInfo());
-    _ASSERTE(pMT->GetRemotableMethodInfo());
-
-    if (pMT->IsContextful())
-        return XAD_NOT_OPTIMIZABLE;
-
-    DWORD flags;
-
-    // If this method is generic then we can't used cached analysis data stored on the method table and keyed by slot -- the same
-    // slot is shared by methods with very different characteristics (such as whether the return type is a GC ref etc.).
-    if (pMeth->GetNumGenericMethodArgs() > 0)
-    {
-        flags = DoStaticAnalysis(pMeth);
-    }
-    else
-    {
-        _ASSERTE(pMeth->GetSlot() < pMeth->GetMethodTable()->GetNumVtableSlots());
-        RemotableMethodInfo *pRMI = &(pMT->GetRemotableMethodInfo()->GetRemotableMethodInfo()[pMeth->GetSlot()]);
-        flags = pRMI->m_OptFlags;
-
-        if (!(flags & XAD_FLAGS_INITIALIZED))
-        {
-            flags = DoStaticAnalysis(pMeth);
-            pRMI->m_OptFlags = flags;
-        }
-    }
-
-    *pNumStackSlotsToCopy = flags & XAD_ARG_COUNT_MASK;
-
-    return (XADOptimizationType) (flags & XAD_FLAG_MASK);
-}
-
-// This method is not synchronized because the operation is idempotent
-DWORD
-RemotableMethodInfo::DoStaticAnalysis(MethodDesc *pMeth)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        THROWS;
-        PRECONDITION(CheckPointer(pMeth));
-    }
-    CONTRACTL_END
-
-    BOOL bCallArgsBlittable = TRUE;
-    BOOL bRetArgBlittable = TRUE;
-    BOOL bOptimizable = TRUE;
-    BOOL bMethodIsVirtual = FALSE;
-    BOOL bArgsHaveAFloat  = FALSE;
-
-    DWORD numStackBytes = 0;
-    DWORD numStackSlots = 0;
-    DWORD returnTypeFlags = 0;
-
-    if (pMeth->ContainsGenericVariables())
-    {
-        bOptimizable = FALSE;
-    }
-    else
-    {
-        MetaSig mSig(pMeth);
-        ArgIterator argit(&mSig);
-
-        SigPointer spRet;
-        CorElementType retElem;
-
-        IMDInternalImport *pMDImport = pMeth->GetModule()->GetMDImport();
-        MDEnumHolder    ePm(pMDImport);         // For enumerating  params.
-        mdParamDef      tkPm;                   // A param token.
-        DWORD           dwFlags;                // Param flags.
-        USHORT          usSeq;                  // Sequence of a parameter.
-
-        if (pMeth->IsOneWay())
-        {
-            bOptimizable = FALSE;
-            goto SetFlags;
-        }
-
-        if (pMeth->IsVirtual())
-        {
-            bMethodIsVirtual = TRUE;
-        }
-
-        numStackBytes = argit.SizeOfFrameArgumentArray();
-
-        _ASSERTE(numStackBytes % sizeof(SIZE_T) == 0);
-        numStackSlots = numStackBytes / sizeof(SIZE_T);
-
-        if (numStackSlots > XAD_ARG_COUNT_MASK)
-        {
-            bOptimizable = FALSE;
-            goto SetFlags;
-        }
-
-        // Check if there are any [Out] args. If there are, skip the fast path
-        IfFailThrow(pMDImport->EnumInit(mdtParamDef, pMeth->GetMemberDef(), &ePm));
-
-        // Enumerate through the params and check the flags.
-        while (pMDImport->EnumNext(&ePm, &tkPm))
-        {
-            LPCSTR szParamName_Ignore;
-            IfFailThrow(pMDImport->GetParamDefProps(tkPm, &usSeq, &dwFlags, &szParamName_Ignore));
-            if (usSeq == 0)     // Skip return type flags.
-                continue;
-            // If the param has Out attribute, do not use fast path for this method
-            if (IsPdOut(dwFlags))
-            {
-                bOptimizable = FALSE;
-                goto SetFlags;
-            }
-        }
-
-        // We're getting SigPointer first because this way we can differentiate E_T_STRING and E_T_CLASS
-        spRet = mSig.GetReturnProps();
-        IfFailThrow(spRet.GetElemType(&retElem));
-        if (retElem > ELEMENT_TYPE_PTR &&
-            retElem != ELEMENT_TYPE_I &&
-            retElem != ELEMENT_TYPE_U &&
-            retElem != ELEMENT_TYPE_FNPTR)
-        {
-            bRetArgBlittable = FALSE;
-        }
-
-        // Now we can normalize the return type so as to get rid of any generic type variables and the like.
-        retElem = mSig.GetReturnType();
-
-        if (retElem == ELEMENT_TYPE_VALUETYPE)
-        {
-            // Make a note that we have a struct in the signature. This way we wont blit the contents
-            // and end up in a situation where we have data, but the type isnt loaded yet
-            bCallArgsBlittable = FALSE;
-
-            // Do some further inspection
-            TypeHandle retTypeHandle = mSig.GetRetTypeHandleThrowing();
-
-                // Currently we don't handle the special unbox handling for ret values of Nullable<T> in MarshalAndCall
-            if (Nullable::IsNullableType(retTypeHandle)) 
-            {
-                bOptimizable = FALSE;
-            }
-
-            retElem = retTypeHandle.GetInternalCorElementType();
-            if ((retElem <= ELEMENT_TYPE_PTR || retElem == ELEMENT_TYPE_I || retElem == ELEMENT_TYPE_U) &&
-                !retTypeHandle.AsMethodTable()->CannotBeBlittedByObjectCloner())
-                bRetArgBlittable = TRUE;
-        }
-
-        // Check if the return type is a GC ref
-        if (gElementTypeInfo[retElem].m_gc == TYPE_GC_REF)
-        {
-            returnTypeFlags = XAD_RET_GC_REF;
-        }
-        else
-        {
-            returnTypeFlags = GetRetTypeFlagsFromFPReturnSize(argit.GetFPReturnSize());
-        }
-
-        CorElementType currType;
-        while ((currType = mSig.NextArg()) != ELEMENT_TYPE_END)
-        {                   
-            SigPointer sp = mSig.GetArgProps();
-            CorElementType retTy;
-            IfFailThrow(sp.GetElemType(&retTy));
-            if (retTy > ELEMENT_TYPE_PTR &&
-                retTy != ELEMENT_TYPE_VALUETYPE &&
-                retTy != ELEMENT_TYPE_I &&
-                retTy != ELEMENT_TYPE_U &&
-                retTy != ELEMENT_TYPE_FNPTR)
-            {
-                bCallArgsBlittable = FALSE;
-            }
-
-                // Currently we don't handle the special unbox handling for Nullable<T> for byrefs in MarshalAndCall
-            if (currType == ELEMENT_TYPE_BYREF) 
-            {
-                TypeHandle refType;
-                if (mSig.GetByRefType(&refType) == ELEMENT_TYPE_VALUETYPE)
-                    if (Nullable::IsNullableType(refType))  
-                    {
-                        bOptimizable = FALSE;
-                    }
-            }
-            else if (currType == ELEMENT_TYPE_VALUETYPE)
-            {
-#if ENREGISTERED_PARAMTYPE_MAXSIZE
-                // Since we also do implict ByRef in some cases, we also have to probit the optimization there too
-                TypeHandle argType = mSig.GetLastTypeHandleThrowing();
-                if (Nullable::IsNullableType(argType)) 
-                {
-                    if (ArgIterator::IsArgPassedByRef(argType))
-                        bOptimizable = FALSE;
-                }
-#endif
-                bCallArgsBlittable = FALSE;
-            }
-            else if (currType == ELEMENT_TYPE_R4 || currType == ELEMENT_TYPE_R8)
-            {
-                bArgsHaveAFloat = TRUE;
-            }
-        }
-    }
-
-SetFlags:
-    DWORD optimizationFlags = 0;
-    if (!bOptimizable)
-    {
-        optimizationFlags |= XAD_NOT_OPTIMIZABLE;
-    }
-    else
-    {
-        optimizationFlags |= returnTypeFlags;
-
-        if (bCallArgsBlittable)
-        {
-            optimizationFlags |= XAD_BLITTABLE_ARGS;
-        }
-        if (bRetArgBlittable)
-        {
-            optimizationFlags |= XAD_BLITTABLE_RET;
-        }
-        if (bMethodIsVirtual)
-        {
-            optimizationFlags |= XAD_METHOD_IS_VIRTUAL;
-        }
-        if (bArgsHaveAFloat)
-        {
-            optimizationFlags |= XAD_ARGS_HAVE_A_FLOAT;
-        }
-    }
-    optimizationFlags |= numStackSlots;
-    optimizationFlags |= XAD_FLAGS_INITIALIZED;
-
-    return optimizationFlags;
-}
-
-#ifndef CROSSGEN_COMPILE
-
-BOOL RemotableMethodInfo::TypeIsConduciveToBlitting(MethodTable *pFromMT, MethodTable *pToMT)
-{
-    LIMITED_METHOD_CONTRACT;
-    // Presence of GC fields or certain atributes, rules out blittability
-    if (pFromMT->CannotBeBlittedByObjectCloner() ||
-        pToMT->CannotBeBlittedByObjectCloner())
-        return FALSE;
-
-    // Shared types are okay to blit
-    if (pFromMT == pToMT)
-        return TRUE;
-
-   if (pFromMT->IsEnum() && pToMT->IsEnum()
-   && pFromMT->GetBaseSize() == pToMT->GetBaseSize())
-        return TRUE;
-
-   return FALSE;
-}
-
-PtrHashMap *CrossDomainTypeMap::s_crossDomainMTMap = NULL;
-SimpleRWLock *CrossDomainTypeMap::s_MTMapLock = NULL;
-
-BOOL CrossDomainTypeMap::CompareMTMapEntry (UPTR val1, UPTR val2)
-{
-    CONTRACTL {
-        MODE_ANY;
-        NOTHROW;
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    CrossDomainTypeMap::MTMapEntry *entry1 = (CrossDomainTypeMap::MTMapEntry *)(val1 << 1);
-    CrossDomainTypeMap::MTMapEntry *entry2 = (CrossDomainTypeMap::MTMapEntry *)val2;
-
-    if (entry1->m_pFromMT == entry2->m_pFromMT &&
-        entry1->m_dwFromDomain == entry2->m_dwFromDomain &&
-        entry1->m_dwToDomain == entry2->m_dwToDomain)
-        return TRUE;
-
-    return FALSE;
-}
-
-CrossDomainTypeMap::MTMapEntry::MTMapEntry(AppDomain *pFromDomain, MethodTable *pFromMT, AppDomain *pToDomain, MethodTable *pToMT)
-{
-    WRAPPER_NO_CONTRACT;
-
-    m_dwFromDomain = pFromDomain->GetId();
-    m_dwToDomain = pToDomain->GetId();
-    m_pFromMT = pFromMT;
-    m_pToMT = pToMT;
-}
-
-static BOOL IsOwnerOfRWLock(LPVOID lock)
-{
-    // @TODO - SimpleRWLock does not have knowledge of which thread gets the writer
-    // lock, so no way to verify
-    return TRUE;
-}
-
-/*static*/
-PtrHashMap *CrossDomainTypeMap::GetTypeMap()
-{
-    CONTRACTL
-    {
-        GC_NOTRIGGER;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END
-
-    if (s_MTMapLock == NULL)
-    {
-        void *tempLockSpace = SystemDomain::GetGlobalLoaderAllocator()->GetLowFrequencyHeap()->AllocMem(S_SIZE_T(sizeof(SimpleRWLock)));
-        SimpleRWLock *tempLock = new (tempLockSpace) SimpleRWLock(COOPERATIVE_OR_PREEMPTIVE, LOCK_TYPE_DEFAULT);
-
-        if (FastInterlockCompareExchangePointer(&s_MTMapLock,
-                                                tempLock,
-                                                NULL) != NULL)
-        {
-            // We lost the race
-            SystemDomain::GetGlobalLoaderAllocator()->GetLowFrequencyHeap()->BackoutMem(tempLockSpace, sizeof(SimpleRWLock));
-        }
-    }
-
-    // Now we have a Crst we can use to synchronize the remainder of the init.
-    if (s_crossDomainMTMap == NULL)
-    {
-        SimpleWriteLockHolder swlh(s_MTMapLock);
-
-        if (s_crossDomainMTMap == NULL)
-        {
-            PtrHashMap *map = new (SystemDomain::GetGlobalLoaderAllocator()->GetLowFrequencyHeap()) PtrHashMap ();
-            LockOwner lock = {s_MTMapLock, IsOwnerOfRWLock};
-            map->Init (32, CompareMTMapEntry, TRUE, &lock);
-            s_crossDomainMTMap = map;
-        }
-    }
-
-    return s_crossDomainMTMap;
-}
-
-MethodTable *
-CrossDomainTypeMap::GetMethodTableForDomain(MethodTable *pMT, AppDomain *pFromDomain, AppDomain *pToDomain)
-{
-    CONTRACTL
-    {
-        GC_NOTRIGGER;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END
-    PtrHashMap *map = GetTypeMap();
-
-    MTMapEntry admt(pFromDomain, pMT, pToDomain, NULL);
-
-    SimpleReadLockHolder srlh(s_MTMapLock);
-    MTMapEntry *pFound = (MTMapEntry *) map->LookupValue(admt.GetHash(), (LPVOID) &admt);
-    if ((MTMapEntry *)INVALIDENTRY == pFound)
-        return NULL;
-
-    return pFound->m_pToMT;
-}
-
-void
-CrossDomainTypeMap::SetMethodTableForDomain(MethodTable *pFromMT, AppDomain *pFromDomain, MethodTable *pToMT, AppDomain *pToDomain)
-{
-    CONTRACTL
-    {
-        GC_NOTRIGGER;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END
-    PtrHashMap *map = GetTypeMap();
-
-    NewHolder<MTMapEntry> admt(new MTMapEntry(pFromDomain, pFromMT, pToDomain, pToMT));
-    PREFIX_ASSUME(admt != NULL);
-
-    SimpleWriteLockHolder swlh(s_MTMapLock);
-
-    UPTR key = admt->GetHash();
-
-    MTMapEntry *pFound = (MTMapEntry *) map->LookupValue(key, (LPVOID) admt);
-    if ((MTMapEntry *)INVALIDENTRY == pFound)
-    {
-        map->InsertValue(key, (LPVOID) admt);
-        admt.SuppressRelease();
-    }
-}
-
-// Remove any entries in the table that refer to an appdomain that is no longer live.
-void CrossDomainTypeMap::FlushStaleEntries()
-{
-    CONTRACTL
-    {
-        GC_NOTRIGGER;
-        MODE_COOPERATIVE;
-        NOTHROW;
-    }
-    CONTRACTL_END
-
-    if (s_MTMapLock == NULL || s_crossDomainMTMap == NULL)
-        return;
-
-    SimpleWriteLockHolder swlh(s_MTMapLock);
-
-    bool fDeletedEntry = false;
-    PtrHashMap::PtrIterator iter = s_crossDomainMTMap->begin();
-    while (!iter.end())
-    {
-        MTMapEntry *pEntry = (MTMapEntry *)iter.GetValue();
-        AppDomainFromIDHolder adFrom(pEntry->m_dwFromDomain, TRUE);
-        AppDomainFromIDHolder adTo(pEntry->m_dwToDomain, TRUE);        
-        if (adFrom.IsUnloaded() ||
-            adTo.IsUnloaded())
-        {
-#ifdef _DEBUG 
-            LPVOID pDeletedEntry =
-#endif
-            s_crossDomainMTMap->DeleteValue(pEntry->GetHash(), pEntry);
-            _ASSERTE(pDeletedEntry == pEntry);
-            delete pEntry;
-            fDeletedEntry = true;
-        }
-        ++iter;
-    }
-
-    if (fDeletedEntry)
-        s_crossDomainMTMap->Compact();
-}
-
-
-
-// Before a cross appdomain call, we read the principal on the thread and set it aside, so that it can
-// be restored when the call returns.
-// In addition, we let the principal flow thru to the called appdomain, if the principal is serializable
-OBJECTREF CrossDomainChannel::ReadPrincipal()
-{
-    CONTRACTL
-    {
-        GC_NOTRIGGER;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END
-
-    THREADBASEREF ref = (THREADBASEREF) GetThread()->GetExposedObjectRaw();
-    _ASSERTE(ref != NULL);
-
-    EXECUTIONCONTEXTREF refExecCtx = (EXECUTIONCONTEXTREF )ref->GetExecutionContext();
-    if (refExecCtx == NULL)
-        return NULL;
-
-    LOGICALCALLCONTEXTREF refCallContext = refExecCtx->GetLogicalCallContext();
-    if (refCallContext == NULL)
-        return NULL;
-
-    CCSECURITYDATAREF refSecurityData = refCallContext->GetSecurityData();
-    if (refSecurityData == NULL)
-        return NULL;
-
-    OBJECTREF refPrincipal = refSecurityData->GetPrincipal();
-    if (refPrincipal != NULL)
-    {
-        MethodTable *pPrincipalType = refPrincipal->GetMethodTable();
-        if (!pPrincipalType->IsSerializable())
-        {
-            refSecurityData->SetPrincipal(NULL);
-        }
-    }
-
-    return refPrincipal;
-}
-
-// Principal never flows from called appdomain back to caller domain.
-VOID CrossDomainChannel::ResetPrincipal()
-{
-    CONTRACTL
-    {
-        GC_NOTRIGGER;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END
-
-    THREADBASEREF ref = (THREADBASEREF) GetThread()->GetExposedObjectRaw();
-    _ASSERTE(ref != NULL);
-
-    EXECUTIONCONTEXTREF refExecCtx = (EXECUTIONCONTEXTREF )ref->GetExecutionContext();
-    if (refExecCtx == NULL)
-        return;
-
-    LOGICALCALLCONTEXTREF refCallContext = refExecCtx->GetLogicalCallContext();
-    if (refCallContext == NULL)
-        return;
-
-    CCSECURITYDATAREF refSecurityData = refCallContext->GetSecurityData();
-    if (refSecurityData == NULL)
-        return;
-
-    refSecurityData->SetPrincipal(NULL);
-
-}
-
-// At the end of a cross-appdomain call, we restore whatever principal was on the thread at the beginning of the call
-VOID CrossDomainChannel::RestorePrincipal(OBJECTREF *prefPrincipal)
-{
-    CONTRACTL
-    {
-        GC_NOTRIGGER;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END
-
-    THREADBASEREF ref = (THREADBASEREF) GetThread()->GetExposedObjectRaw();
-    if (ref == NULL)
-        return;
-
-    EXECUTIONCONTEXTREF refExecCtx = (EXECUTIONCONTEXTREF )ref->GetExecutionContext();
-    _ASSERTE(*prefPrincipal == NULL || refExecCtx != NULL);
-
-    if (refExecCtx == NULL)
-        return;
-
-    LOGICALCALLCONTEXTREF refCallContext = refExecCtx->GetLogicalCallContext();
-    if (refCallContext == NULL)
-        return;
-
-    CCSECURITYDATAREF refSecurityData = refCallContext->GetSecurityData();
-    _ASSERTE(*prefPrincipal == NULL || refSecurityData != NULL);
-
-    if (refSecurityData == NULL)
-        return;
-
-    refSecurityData->SetPrincipal(*prefPrincipal);
-
-}
-
-// This method mimics the Lease renewal mechanism of the managed CrossDomainChannel
-// The lease object for the server can be accessed via its ServerIdentity.
-VOID CrossDomainChannel::RenewLease()
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END
-    // Check if lease needs to be renewed
-    OBJECTREF refSrvIdentity = ObjectFromHandle(m_refSrvIdentity);
-    if (refSrvIdentity == NULL)
-        return;
-
-    OBJECTREF refLease = ObjectToOBJECTREF((Object *)refSrvIdentity->GetPtrOffset(CRemotingServices::GetOffsetOfLeaseInIdentity()));
-    if (refLease != NULL)
-    {
-        GCPROTECT_BEGIN(refLease);
-        MethodDesc *pLeaseMeth = CRemotingServices::MDofRenewLeaseOnCall();
-        PCODE pCode = (PCODE)pLeaseMeth->GetCallTarget(&refLease);
-
-        PREPARE_NONVIRTUAL_CALLSITE_USING_CODE(pCode);
-
-        DECLARE_ARGHOLDER_ARRAY(args, 2);
-
-        args[ARGNUM_0]    = OBJECTREF_TO_ARGHOLDER(refLease);
-        args[ARGNUM_1]    = NULL;
-
-        CATCH_HANDLER_FOUND_NOTIFICATION_CALLSITE;
-        CALL_MANAGED_METHOD_NORET(args);
-
-        GCPROTECT_END();
-    }
-}
-
-// Given a client side instantiated method desc and a server side generic definition method desc extract the instantiation,
-// translate all the types involved into the server domain and return the fully instantiated server method desc. Note that the
-// client and server method descs might not represent the same type -- the client method might be from an interface, whereas the
-// server method will always be on the real class.
-MethodDesc *InstantiateMethod(MethodDesc *pClientMD, MethodDesc *pServerMD, MethodTable *pServerMT)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        THROWS;
-        PRECONDITION(CheckPointer(pClientMD));
-        PRECONDITION(pClientMD->HasMethodInstantiation());
-        PRECONDITION(CheckPointer(pServerMD));
-        PRECONDITION(pServerMD->HasMethodInstantiation());
-        PRECONDITION(pClientMD->GetNumGenericMethodArgs() == pServerMD->GetNumGenericMethodArgs());
-    }
-    CONTRACTL_END;
-
-    Instantiation clientInst = pClientMD->GetMethodInstantiation();
-
-    DWORD dwAllocaSize;
-    if (!ClrSafeInt<DWORD>::multiply(clientInst.GetNumArgs(), sizeof(TypeHandle), dwAllocaSize))
-        COMPlusThrowHR(COR_E_OVERFLOW);
-
-    CQuickBytes qbServerInst;
-    TypeHandle *pServerInst = reinterpret_cast<TypeHandle*>(qbServerInst.AllocThrows(dwAllocaSize));
-
-    for (DWORD dwArgNum = 0; dwArgNum < clientInst.GetNumArgs(); dwArgNum++)
-    {
-        SString thName;
-        TypeString::AppendType(thName, clientInst[dwArgNum], TypeString::FormatNamespace|TypeString::FormatFullInst|TypeString::FormatAssembly);
-
-        pServerInst[dwArgNum] = TypeName::GetTypeFromAsmQualifiedName(thName.GetUnicode(), pClientMD->IsIntrospectionOnly());
-
-        _ASSERTE(!pServerInst[dwArgNum].IsNull());
-
-        // Check that the type is actually visible on the server side. This prevents a malicious client from luring a trusted server
-        // into manipulating types that would be normally invisible to it.
-        if (!pServerInst[dwArgNum].IsExternallyVisible())
-            COMPlusThrow(kRemotingException, W("Remoting_NonPublicOrStaticCantBeCalledRemotely"));
-    }
-
-    // Find or create the method will the full instantiation.
-    return MethodDesc::FindOrCreateAssociatedMethodDesc(pServerMD,
-                                                        pServerMT,
-                                                        FALSE,
-                                                        Instantiation(pServerInst, clientInst.GetNumArgs()),
-                                                        FALSE);
-}
-
-BOOL CrossDomainChannel::GetGenericMethodAddress(MethodTable *pServerType)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END;
-
-    m_pSrvMD = InstantiateMethod(m_pCliMD, pServerType->GetMethodDescForSlot(m_pCliMD->GetSlot()), pServerType);
-
-    OBJECTREF thisObj = GetServerObject();
-    m_pTargetAddress = m_pSrvMD->GetCallTarget(&thisObj);
-
-    return TRUE;
-}
-
-// We use this method to find the target address when we are convinced that the most derived type the proxy is cast
-// to on the client side is equivalent to the corresponding type on the server side, in the sense the method table
-// layouts are similar. This fact can be used to look up method addresses faster
-BOOL CrossDomainChannel::GetTargetAddressFast(DWORD optFlags, MethodTable *pSrvMT, BOOL bFindServerMD)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END
-    _ASSERTE(m_pCliMD);
-    _ASSERTE(m_pSrvDomain == SystemDomain::GetCurrentDomain()->GetId());
-
-    MethodTable *pCliMT = m_pCliMD->GetMethodTable();
-    _ASSERTE(!pCliMT->IsInterface());
-
-    m_pSrvMD = NULL;
-
-    DWORD dwMethodSlot = m_pCliMD->GetSlot();
-    if (!RemotableMethodInfo::IsMethodVirtual(m_xret))
-    {
-        // This is a non-virtual method. Find the matching MT on the
-        // server side, dereference the slot and get the method address
-
-        MethodTable *pSrvSideMT = pSrvMT;
-
-        // We now need to walk the server type hierarchy till we find the type that
-        // declared the method we're going to call
-
-        // First find how far is the type declaring the called method, from System.Object
-        DWORD cliDepth = 0;
-        MethodTable *pCurrLevel = pCliMT;
-        while (pCurrLevel != NULL)
-        {
-            _ASSERTE(pCurrLevel);
-            pCurrLevel = pCurrLevel->GetParentMethodTable();
-            cliDepth++;
-        };
-
-        // Next find how deep is the server type from System.Object
-        DWORD srvDepth = 0;
-        pCurrLevel = pSrvMT;
-        while (pCurrLevel != NULL)
-        {
-            _ASSERTE(pCurrLevel);
-            pCurrLevel = pCurrLevel->GetParentMethodTable();
-            srvDepth++;
-        };
-
-        _ASSERTE(srvDepth >= cliDepth);
-
-        while (srvDepth > cliDepth)
-        {
-            _ASSERTE(pSrvSideMT);
-            _ASSERTE(srvDepth != 0);
-            pSrvSideMT = pSrvSideMT->GetParentMethodTable();
-            srvDepth--;
-        };
-
-        if (m_pCliMD->HasMethodInstantiation())
-        {
-            GetGenericMethodAddress(pSrvSideMT);
-        }
-        else
-        {
-            m_pTargetAddress = pSrvSideMT->GetRestoredSlot(dwMethodSlot);
-
-#ifndef _DEBUG 
-            if (bFindServerMD)
-#endif
-                m_pSrvMD = pSrvSideMT->GetMethodDescForSlot(dwMethodSlot);
-        }
-    }
-    else
-    {
-        if (m_pCliMD->HasMethodInstantiation())
-            GetGenericMethodAddress(pSrvMT);
-        else
-        {
-            m_pTargetAddress = pSrvMT->GetRestoredSlot(dwMethodSlot);
-
-#ifndef _DEBUG 
-            if (bFindServerMD)
-#endif
-                m_pSrvMD = pSrvMT->GetMethodDescForSlot(dwMethodSlot);
-        }
-    }
-
-    _ASSERTE(m_pTargetAddress);
-#ifdef _DEBUG 
-    _ASSERTE(!strcmp(m_pSrvMD->GetName(), m_pCliMD->GetName()));
-    DefineFullyQualifiedNameForClass();
-    LPCUTF8 szSrvTypeName = GetFullyQualifiedNameForClassNestedAware(pSrvMT);
-    LPCUTF8 pszMethodName = m_pCliMD->GetName();
-    LOG((LF_REMOTING, LL_INFO100, "GetTargetAddressFast. Address of %s::%s is 0x%x\n", &szSrvTypeName[0], pszMethodName, m_pTargetAddress));
-#endif // _DEBUG
-    return TRUE;
-}
-
-BOOL
-CrossDomainChannel::GetInterfaceMethodAddressFast(DWORD optFlags, MethodTable *pSrvMT, BOOL bFindServerMD)
-{
-    CONTRACTL
-    {
-        THROWS;
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-
-    _ASSERTE(m_pCliMD);
-
-    MethodTable *pCliItfMT = m_pCliMD->GetMethodTable();
-    _ASSERTE(pCliItfMT->IsInterface());
-
-    // Only use the fast path if the interface is shared. If the interface isnt shared, then we'll have to search the
-    // interface map on server type using name as key and then deref the slot # etc. I think shared interfaces will
-    // be the common pattern. If not they should be.
-    // Note that it's not enough to check that the client interface is shared, it must also be loaded in the server appdomain (since
-    // it's now possible to have more than one instance of a shared assembly in a process).
-    _ASSERTE(pCliItfMT->IsDomainNeutral());
-    AppDomain* ad = SystemDomain::GetAppDomainFromId(m_pSrvDomain,ADV_RUNNINGIN);
-    if (ad->FindDomainAssembly(pCliItfMT->GetAssembly()) == NULL)
-        return FALSE;
-
-    m_pSrvMD = NULL;
-
-    OBJECTREF thisObj = GetServerObject();
-
-#ifdef FEATURE_COMINTEROP
-    // Check for a COM interop server. 
-    if (thisObj->GetMethodTable()->IsComObjectType())
-    {
-#if 0
-        // We don't have all the logic in place to deal with COM interop yet. The following code is taken from the regular remoting
-        // invocation path in CStackBuilderSink::PrivateProcessMessage, but I think we still need some work on the actual invocation
-        // itself (leastways we didn't end up invoking the method correctly when I tried it).
-        // For now we'll just bail back to the regular remoting path for COM interop.
-        m_pSrvMD = thisObj->GetMethodTable()->GetMethodDescForComInterfaceMethod(m_pCliMD, false);
-        if (m_pSrvMD == NULL)
-            return FALSE;
-#endif
-        return FALSE;
-    }
-#endif // FEATURE_COMINTEROP
-
-    GCPROTECT_BEGIN(thisObj);
-
-    DispatchSlot impl(pSrvMT->FindDispatchSlotForInterfaceMD(m_pCliMD));
-    CONSISTENCY_CHECK(!impl.IsNull());
-    m_pSrvMD = impl.GetMethodDesc();
-
-    _ASSERTE(m_pSrvMD);
-
-    // If the method called has a generic instantiation then the server method desc we've just received doesn't contain that
-    // information (generic method slots are filled with generic definition method descs). We need to build the exact method desc by
-    // copying the instantiation from the client method (translating each type into the new domain of course).
-    if (m_pSrvMD->HasMethodInstantiation())
-        m_pSrvMD = InstantiateMethod(m_pCliMD, m_pSrvMD, pSrvMT);
-
-    m_pTargetAddress = m_pSrvMD->GetCallTarget(&thisObj);
-
-    GCPROTECT_END();
-
-    return TRUE;
-}
-
-
-// Here we check whether the remote call is a cross domain call, if so, does it qualify
-BOOL
-CrossDomainChannel::CheckCrossDomainCall(TPMethodFrame *pFrame)
-{
-    CONTRACTL
-    {
-        THROWS;
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-
-    m_pFrame = pFrame;
-    m_pCliMD = m_pFrame->GetFunction();
-
-    MethodTable *pCliMT = m_pCliMD->GetMethodTable();
-
-    // Check if this is an async delegate call
-    if (pCliMT->IsDelegate())
-        return FALSE;
-
-    // Only use the fast path if the interface is shared. If the interface isnt shared, then we'll have to search the
-    // interface map on server type using name as key and then deref the slot # etc. I think shared interfaces will
-    // be the common pattern.
-    if (pCliMT->IsInterface() && !pCliMT->IsDomainNeutral())
-        return FALSE;
-
-    OBJECTREF refTP = pFrame->GetThis();
-    REALPROXYREF refRP = CTPMethodTable::GetRP(refTP);
-
-    // Check if this is a x-domain call
-    DWORD domainID = refRP->GetDomainID();
-    if (domainID == 0)
-        return FALSE;   // Not x-appdomain call, or proxy not initted for optimization
-
-    // Check if we are in a context different from default. If so, we may need to run context
-    // policies etc. Use regular path.
-    if (GetThread()->GetContext() != SystemDomain::GetCurrentDomain()->GetDefaultContext())
-        return FALSE;
-
-    // Check if method call args can be blitted (or not optimizable at all)
-    m_xret = RemotableMethodInfo::IsCrossAppDomainOptimizable(m_pCliMD, &m_numStackSlotsToCopy);
-    if (RemotableMethodInfo::IsCallNotOptimizable(m_xret))
-    {
-#ifdef _DEBUG 
-        DefineFullyQualifiedNameForClass();
-        LPCUTF8 szSrvTypeName = GetFullyQualifiedNameForClassNestedAware(m_pCliMD->GetMethodTable());
-        LOG((LF_REMOTING, LL_INFO100, "CheckCrossDomainCall. Call to %s::%s is not optimizable\n",
-            &szSrvTypeName[0], m_pCliMD->GetName()));
-#endif // _DEBUG
-        return FALSE;
-    }
-
-    m_pCliDomain = SystemDomain::GetCurrentDomain();
-    m_pSrvDomain = ADID(domainID);
-
-    return ExecuteCrossDomainCall();
-}
-
-// Dereference the server identity handle, to reach the server object
-// If the handle is null, someone either called Disconnect on the server
-// or the server's lease ran out
-OBJECTREF CrossDomainChannel::GetServerObject()
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        THROWS;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END
-
-    _ASSERTE(m_pSrvDomain == SystemDomain::GetCurrentDomain()->GetId());
-
-    OBJECTREF refSrvIdentity = ObjectFromHandle(m_refSrvIdentity);
-    if (refSrvIdentity == NULL)
-    {
-        OBJECTREF refTP = m_pFrame->GetThis();
-        REALPROXYREF refRP = CTPMethodTable::GetRP(refTP);
-        OBJECTREF refIdentity = ObjectToOBJECTREF((Object *)refRP->GetPtrOffset(CRemotingServices::GetOffsetOfCliIdentityInRP()));
-        STRINGREF refURI = (STRINGREF)ObjectToOBJECTREF((Object *)refIdentity->GetPtrOffset(CRemotingServices::GetOffsetOfURIInIdentity()));
-        SString sURI;
-        refURI->GetSString(sURI);
-
-        COMPlusThrow(kRemotingException,
-            IDS_REMOTING_SERVER_DISCONNECTED,
-            sURI.GetUnicode());
-    }
-    OBJECTREF srvObject = ObjectToOBJECTREF((Object *)refSrvIdentity->GetPtrOffset(CRemotingServices::GetOffsetOfTPOrObjInIdentity()));
-    return srvObject;
-}
-
-// Here the we find the target method address, make a decision whether to
-// execute the call locally, if remote whether to blit the arguments or to marshal them,
-BOOL CrossDomainChannel::ExecuteCrossDomainCall()
-{
-    STATIC_CONTRACT_THROWS;
-    STATIC_CONTRACT_GC_TRIGGERS;
-    STATIC_CONTRACT_MODE_COOPERATIVE;
-
-    BOOL bOptimizable = TRUE;
-
-    {
-        ProfilerRemotingClientCallbackHolder profilerHolder;
-
-        // Short circuit calls to Object::GetType and run them locally
-        if (m_pCliMD == CRemotingServices::MDofObjectGetType())
-        {
-            LOG((LF_REMOTING, LL_INFO100, "ExecuteCrossDomainCall. Short circuiting call to Object::GetType and running it locally.\n"));
-            OBJECTREF refTP = m_pFrame->GetThis();
-            OBJECTREF refType = CRemotingServices::GetClass(refTP);
-            LPVOID pReturnValuePtr = m_pFrame->GetReturnValuePtr();
-            *(Object **)pReturnValuePtr = OBJECTREFToObject(refType);
-        }
-        else if (RemotableMethodInfo::AreArgsBlittable(m_xret))
-        {
-            bOptimizable = BlitAndCall();
-        }
-        else
-        {
-            bOptimizable = MarshalAndCall();
-        }
-    }
-
-    if (!bOptimizable)
-        return FALSE;
-
-    // Check for the need to trip thread
-    if (GetThread()->CatchAtSafePointOpportunistic())
-    {
-        // There is no need to GC protect the return object as
-        // TPFrame is GC protecting it
-        CommonTripThread();
-    }
-
-#ifdef _TARGET_X86_
-    // Set the number of bytes to pop for x86
-    m_pFrame->SetCbStackPop(m_numStackSlotsToCopy * sizeof(SIZE_T));
-#endif // _TARGET_X86_
-
-    return TRUE;
-}
-
-BOOL
-CrossDomainChannel::InitServerInfo()
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        THROWS;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END
-
-    _ASSERTE(m_pFrame);
-    _ASSERTE(m_pSrvDomain == SystemDomain::GetCurrentDomain()->GetId());
-
-    // Get the server object
-    OBJECTREF refTP = m_pFrame->GetThis();
-    REALPROXYREF refRP = CTPMethodTable::GetRP(refTP);
-    m_refSrvIdentity = (OBJECTHANDLE)refRP->GetPtrOffset(CRemotingServices::GetOffsetOfSrvIdentityInRP());
-    OBJECTREF srvObject = GetServerObject();
-
-    MethodTable *pSrvMT = srvObject->GetMethodTable();
-
-    // Find the target address
-    DWORD optFlag = refRP->GetOptFlags();
-
-    // If we are cloning some arguments to server domain, we want to do a type check
-    // on the cloned objects against the expected type. To find the expected type, we need to
-    // know the method signature on the server side, which in turn is obtainable if we know
-    // the server MethodDesc. Finding MethodDesc from a slot isnt cheap, so we do it only if we need it
-    BOOL bFindServerMD = (RemotableMethodInfo::AreArgsBlittable(m_xret)) ? FALSE : TRUE;
-    BOOL bResultOfAddressLookup = FALSE;
-
-    if (m_pCliMD->GetMethodTable()->IsInterface())
-    {
-        bResultOfAddressLookup = GetInterfaceMethodAddressFast(optFlag, pSrvMT, bFindServerMD);
-    }
-    else if ((optFlag & OPTIMIZATION_FLAG_INITTED) && (optFlag & OPTIMIZATION_FLAG_PROXY_EQUIVALENT))
-    {
-        bResultOfAddressLookup = GetTargetAddressFast(optFlag, pSrvMT, bFindServerMD);
-    }
-    else
-    {
-        // If the proxy is not cast to an equivalent type, do not perform any optimizations
-        bResultOfAddressLookup = FALSE;
-    }
-
-#ifdef _DEBUG 
-    if (!bResultOfAddressLookup)
-        LOG((LF_REMOTING, LL_INFO100, "InitServerInfo. Skipping fast path because failed to find target address.\n"));
-#endif // _DEBUG
-
-    _ASSERTE(!bResultOfAddressLookup || !bFindServerMD || m_pSrvMD);
-    return bResultOfAddressLookup;
-}
-
-// A macro used to help calculate the exact declaring type of a method (this may not be as simple as calling GetMethodTable on the
-// method desc if the type is generic and not an interface). We get the additional information from the instance (which provides an
-// exact method table, though not necessarily the one the method is actually _declared_ on). We don't compute the instance or the
-// method table from that instance in this macro since the logic varies greatly from client to server (the client has to adjust for
-// the fact that the instance is a TP).
-// We assume a variable called thDeclaringType has already been declared in the current scope.
-#define CDC_DETERMINE_DECLARING_TYPE(_pMD, _thInst)                                                                 \
-    if (!(_pMD)->HasClassInstantiation() || (_pMD)->IsInterface())                                                  \
-    {                                                                                                               \
-        thDeclaringType = TypeHandle((_pMD)->GetMethodTable());                                                     \
-    }                                                                                                               \
-    else                                                                                                            \
-    {                                                                                                               \
-        Instantiation inst = (_pMD)->GetExactClassInstantiation(_thInst);                                           \
-        MethodTable *pApproxDeclaringMT = (_pMD)->GetMethodTable();                                                 \
-        thDeclaringType = ClassLoader::LoadGenericInstantiationThrowing(pApproxDeclaringMT->GetModule(),            \
-                                                                        pApproxDeclaringMT->GetCl(),                \
-                                                                        inst);                                      \
-    }
-
-// We have decided the arguments are blittable. We may still need to marshal
-// call context if any.
-BOOL
-CrossDomainChannel::BlitAndCall()
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END
-
-    SIZE_T *pRegArgs   = NULL;
-    SIZE_T *pStackArgs = NULL;
-#ifdef CALLDESCR_ARGREGS
-    ArgumentRegisters RegArgs = {0};
-    pRegArgs = (SIZE_T*)&RegArgs;
-#endif
-#ifdef CALLDESCR_FPARGREGS
-    FloatArgumentRegisters *pFloatArgumentRegisters = NULL;
-#endif
-
-    BOOL bOptimizable        = TRUE;
-    BOOL bHasObjRefReturnVal = FALSE;
-
-    Thread  *pCurThread = GetThread();
-
-#ifdef _DEBUG 
-    LPCUTF8 pszMethodName;
-    pszMethodName = m_pCliMD->GetName();
-    LOG((LF_REMOTING, LL_INFO100, "BlitAndCall. Blitting arguments to method %s\n", pszMethodName));
-#endif // _DEBUG
-
-    // Collect all client domain GC references together in a single GC frame.
-    // refReturnValue contains the returned object.
-    // It can also contain a boxed object when the return is a value type and needs marshalling
-    struct _gc {
-        OBJECTREF   refReturnValue;
-        OBJECTREF   refException;
-        OBJECTREF   refExecutionContext;
-        OBJECTREF   refPrincipal;
-    } ClientGC;
-    ZeroMemory(&ClientGC, sizeof(ClientGC));
-    GCPROTECT_BEGIN(ClientGC);
-
-    _ASSERTE(RemotableMethodInfo::IsReturnBlittable(m_xret));
-
-    // Check for any logical call context that contains data
-    BOOL bMarshalCallContext = FALSE;
-    BOOL bMarshalReturnCallContext = FALSE;
-    if (pCurThread->IsExposedObjectSet())
-    {
-        THREADBASEREF ref = (THREADBASEREF) pCurThread->GetExposedObjectRaw();
-        _ASSERTE(ref != NULL);
-
-        EXECUTIONCONTEXTREF refExecCtx = (EXECUTIONCONTEXTREF) ref->GetExecutionContext();
-        if (refExecCtx != NULL)
-        {
-            ClientGC.refExecutionContext = refExecCtx;
-            ClientGC.refPrincipal = ReadPrincipal();
-
-            LOGICALCALLCONTEXTREF refLogCallCtx = refExecCtx->GetLogicalCallContext();
-            if (refLogCallCtx != NULL)
-            {
-                if (refLogCallCtx->ContainsDataForSerialization())
-                {
-                    bMarshalCallContext = TRUE;
-                }
-            }
-        }
-    }
-
-#ifdef FEATURE_CORRUPTING_EXCEPTIONS
-    // Assume that exception at server was NotCorrupting
-    CorruptionSeverity severity = NotCorrupting;
-#endif // FEATURE_CORRUPTING_EXCEPTIONS
-
-    // Push the frame
-    ENTER_DOMAIN_ID(m_pSrvDomain);
-
-    // Now create a server domain GC frame for all server side GC references.
-    struct _gc {
-        OBJECTREF   refReturnValue;
-        OBJECTREF   refException;
-        OBJECTREF   refExecutionContext;
-    } ServerGC;
-    ZeroMemory(&ServerGC, sizeof(ServerGC));
-    GCPROTECT_BEGIN(ServerGC);
-
-    // Initialize server side info, such as method address etc
-    bOptimizable = InitServerInfo();
-
-    if (!bOptimizable)
-        goto LeaveDomain;
-
-    RenewLease();
-
-    if (bMarshalCallContext)
-    {
-        LOG((LF_REMOTING, LL_INFO100, "BlitAndCall. Marshalling call context\n", pszMethodName));
-        CrossAppDomainClonerCallback cadcc;
-        ObjectClone Marshaller(&cadcc, CrossAppDomain, FALSE);
-        ServerGC.refExecutionContext = Marshaller.Clone(ClientGC.refExecutionContext,
-                                                        m_pCliDomain,
-                                                        GetAppDomain(),
-                                                        ClientGC.refExecutionContext);
-        THREADBASEREF ref = (THREADBASEREF) pCurThread->GetExposedObjectRaw();
-        _ASSERTE(ref != NULL);
-
-        ref->SetExecutionContext(ServerGC.refExecutionContext);
-
-        Marshaller.RemoveGCFrames();
-    }
-    else if (pCurThread->IsExposedObjectSet())
-    {
-        THREADBASEREF ref = (THREADBASEREF) pCurThread->GetExposedObjectRaw();
-        _ASSERTE(ref != NULL);
-
-        ref->SetExecutionContext(NULL);
-    }
-
-#ifdef PROFILING_SUPPORTED 
-    // If we're profiling, notify the profiler that we're about to invoke the remoting target
-    {
-        BEGIN_PIN_PROFILER(CORProfilerTrackRemoting());
-        GCX_PREEMP();
-        g_profControlBlock.pProfInterface->RemotingServerInvocationStarted();
-        END_PIN_PROFILER();
-    }
-#endif // PROFILING_SUPPORTED
-
-    {
-        GCX_COOP();
-        UINT64 uRegTypeMap = 0;
-        pStackArgs = (SIZE_T *)(m_pFrame->GetTransitionBlock() + TransitionBlock::GetOffsetOfArgs());
-
-        // Get the 'this' object
-        OBJECTREF srvObject = GetServerObject();
-
-#if defined(_TARGET_X86_)
-        pRegArgs[0] = *((SIZE_T*)(m_pFrame->GetTransitionBlock() + TransitionBlock::GetOffsetOfArgumentRegisters()));
-        pRegArgs[1] = (SIZE_T) OBJECTREFToObject(srvObject);
-#elif defined(CALLDESCR_ARGREGS)
-        // Have to buffer argument registers since we're going to overwrite the this object with the server
-        // version and the frame owning the registers is in the wrong domain to report that object.
-        pRegArgs[0] = (SIZE_T) OBJECTREFToObject(srvObject);
-        memcpy(pRegArgs + 1,
-               (SIZE_T*)(m_pFrame->GetTransitionBlock() + TransitionBlock::GetOffsetOfArgumentRegisters()) + 1,
-               sizeof(ArgumentRegisters) - sizeof(SIZE_T));
-
-#ifdef CALLDESCR_FPARGREGS
-        // Only provide a pointer to the floating point area of the stack frame if there any any floating
-        // point arguments (passing NULL optimizes the CallDescr thunk by omitting the initialization of
-        // floating point argument registers).
-        if (RemotableMethodInfo::DoArgsContainAFloat(m_xret))
-            pFloatArgumentRegisters = (FloatArgumentRegisters*)(m_pFrame->GetTransitionBlock() + TransitionBlock::GetOffsetOfFloatArgumentRegisters());
-#endif // CALLDESCR_FPARGREGS
-
-#else // CALLDESCR_ARGREGS
-
-        // It's a pity that we have to allocate a buffer for the arguments on the stack even in BlitAndCall().
-        // The problem is we can't use the portion of the stack protected by m_pFrame to store the srvObject,
-        // since the srvObject is in the server domain and the TPMethodFrame m_pFrame is in the client domain.
-        // I don't think we need to protect the srvOjbect in this case, since it's reachable from the transparent
-        // proxy, which is protected by the TPMethodFrame.
-        SIZE_T* pTmpStackArgs = (SIZE_T*)_alloca(m_numStackSlotsToCopy * sizeof(SIZE_T));
-        memcpy(pTmpStackArgs, pStackArgs, m_numStackSlotsToCopy * sizeof(SIZE_T));
-        pStackArgs = pTmpStackArgs;
-
-        pStackArgs[0] = (SIZE_T)OBJECTREFToObject(srvObject);
-#endif // CALLDESCR_ARGREGS
-
-#if defined(CALLDESCR_REGTYPEMAP) || defined(COM_STUBS_SEPARATE_FP_LOCATIONS) 
-        // We have to copy the floating point registers from a different stack location to the portion of
-        // the stack used to save the general registers.  Since this is expensive, we only do this if
-        // we have some floating point arguments.
-        if (RemotableMethodInfo::DoArgsContainAFloat(m_xret))
-        {
-            // When computing the method signature we need to take special care if the call is on a non-interface class with a
-            // generic instantiation (since in that case we may have a representative method with a non-concrete signature).
-            TypeHandle thDeclaringType;
-            CDC_DETERMINE_DECLARING_TYPE(m_pCliMD, TypeHandle(CTPMethodTable::GetMethodTableBeingProxied(m_pFrame->GetThis())));
-            MetaSig mSig(m_pCliMD, thDeclaringType);
-            ArgIterator argit(&mSig);
-
-            int offset;
-            while (TransitionBlock::InvalidOffset != (offset = argit.GetNextOffset()))
-            {    
-                int regArgNum = TransitionBlock::GetArgumentIndexFromOffset(offset);
-
-                if (regArgNum >= NUM_ARGUMENT_REGISTERS)
-                    break;
-
-                CorElementType argTyp = argit.GetArgType();
-
-#ifdef CALLDESCR_REGTYPEMAP
-                FillInRegTypeMap(offset, argTyp, (BYTE*)&uRegTypeMap);
-#endif
-
-#ifdef COM_STUBS_SEPARATE_FP_LOCATIONS
-                if (argTyp == ELEMENT_TYPE_R4 || argTyp == ELEMENT_TYPE_R8)
-                {
-                    PVOID pSrc = (PVOID)(m_pFrame->GetTransitionBlock() + m_pFrame->GetFPArgOffset(regArgNum));
-
-                    ARG_SLOT val;
-                    if (argTyp == ELEMENT_TYPE_R4)
-                        val = FPSpillToR4(pSrc);
-                    else
-                        val = FPSpillToR8(pSrc);
-
-                    *(ARG_SLOT*)(&pStackArgs[regArgNum]) = val;
-                }
-#endif
-            }
-        }
-#endif // CALLDESCR_REGTYPEMAP || COM_STUBS_SEPARATE_FP_LOCATIONS
-
-        CallDescrData callDescrData;
-
-        callDescrData.pSrc = pStackArgs;
-        callDescrData.numStackSlots = m_numStackSlotsToCopy,
-#ifdef CALLDESCR_ARGREGS
-        callDescrData.pArgumentRegisters = (ArgumentRegisters *)pRegArgs;
-#endif
-#ifdef CALLDESCR_FPARGREGS
-        callDescrData.pFloatArgumentRegisters = pFloatArgumentRegisters;
-#endif
-#ifdef CALLDESCR_REGTYPEMAP
-        callDescrData.dwRegTypeMap = uRegTypeMap;
-#endif
-        callDescrData.fpReturnSize = GetFPReturnSize();
-        callDescrData.pTarget = m_pTargetAddress;
-
-        DispatchCall(
-            &callDescrData,
-            &ServerGC.refException,
-            GET_CTX_TRANSITION_FRAME()
-            COMMA_CORRUPTING_EXCEPTIONS_ONLY(&severity)
-            );
-
-        // If the return value is a GC ref, store it in a protected place
-        if (ServerGC.refException != NULL)
-        {
-            // Return value is invalid if there was exception thrown
-        }
-        else
-        if (RemotableMethodInfo::IsReturnGCRef(m_xret))
-        {
-            ServerGC.refReturnValue = ObjectToOBJECTREF(*(Object **)(&callDescrData.returnValue));
-            bHasObjRefReturnVal = TRUE;
-        }
-        else
-        {
-            memcpyNoGCRefs(m_pFrame->GetReturnValuePtr(), &callDescrData.returnValue, sizeof(callDescrData.returnValue));
-        }
-    }
-
-#ifdef PROFILING_SUPPORTED 
-    {
-        BEGIN_PIN_PROFILER(CORProfilerTrackRemoting());
-        GCX_PREEMP();
-        g_profControlBlock.pProfInterface->RemotingServerInvocationReturned();
-        END_PIN_PROFILER();
-    }
-#endif // PROFILING_SUPPORTED
-
-    // Propagate any logical call context changes except those to the principal
-    if (pCurThread->IsExposedObjectSet())
-    {
-        THREADBASEREF ref = (THREADBASEREF) pCurThread->GetExposedObjectRaw();
-        _ASSERTE(ref != NULL);
-
-        EXECUTIONCONTEXTREF refExecCtx = (EXECUTIONCONTEXTREF) ref->GetExecutionContext();
-        if (refExecCtx != NULL)
-        {
-            LOGICALCALLCONTEXTREF refLogCallCtx = refExecCtx->GetLogicalCallContext();
-            if (bMarshalCallContext ||
-                (refLogCallCtx != NULL && refLogCallCtx->ContainsNonSecurityDataForSerialization()))
-            {
-                ServerGC.refExecutionContext = ref->GetExecutionContext();
-                bMarshalReturnCallContext = TRUE;
-                LOG((LF_REMOTING, LL_INFO100, "BlitAndCall. Marshalling return call context\n", pszMethodName));
-                CrossAppDomainClonerCallback cadcc;
-                ObjectClone Marshaller(&cadcc, CrossAppDomain, FALSE);
-
-                ResetPrincipal();
-
-                EXECUTIONCONTEXTREF ecref = (EXECUTIONCONTEXTREF)Marshaller.Clone(ServerGC.refExecutionContext,
-                                                                                  GetAppDomain(),
-                                                                                  m_pCliDomain,
-                                                                                  ServerGC.refExecutionContext);
-                if (ClientGC.refExecutionContext != NULL)
-                    ((EXECUTIONCONTEXTREF)ClientGC.refExecutionContext)->SetLogicalCallContext(ecref->GetLogicalCallContext());
-                else
-                    ClientGC.refExecutionContext = (OBJECTREF)ecref;
-
-                Marshaller.RemoveGCFrames();
-            }
-        }
-    }
-
-    if (ServerGC.refException != NULL)
-    {
-        LOG((LF_REMOTING, LL_INFO100, "BlitAndCall. Exception thrown ! Marshalling exception. \n", pszMethodName));
-
-        // Save Watson buckets before the exception object is changed
-        if (GetThread() != NULL)
-        {
-            // Ensure that we have the buckets for the exception in question.
-            // For preallocated exceptions, we capture the buckets in the 
-            // UE WatsonBucket Tracker in AppDomainTransitionExceptionFilter.
-            //
-            // When the exception is reraised in the returning AppDomain,
-            // StackTraceInfo::AppendElement will copy over the buckets 
-            // to the EHtracker corresponding to the raised exception.
-            if (!CLRException::IsPreallocatedExceptionObject(ServerGC.refException))
-            {
-                // For non-preallocated exception objects, the throwable
-                // is expected have the buckets in it, assuming that
-                // CLR's personality routine for managed code was notified
-                // of the exception before returning from the AD transition.
-                //
-                // There are scenarios where few managed frames, post AD transition,
-                // may get optimized away by the JIT. If a managed exception is
-                // thrown from within the VM at a later time, the personality routine 
-                // for managed will not be invoked if there are no managed frames present
-                // between the AD Transition frame and the frame where VM raised the managed
-                // exception.
-                //
-                // When such an exception comes back to the calling AppDomain, we will
-                // come here and look for watson buckets and may not find them. In such
-                // a case, simply log it.
-                if(!((EXCEPTIONREF)ServerGC.refException)->AreWatsonBucketsPresent())
-                {
-                    LOG((LF_EH, LL_INFO100, "CrossDomainChannel::BlitAndCall: Watson buckets not found in regular exception object. Exception likely raised in native code.\n"));
-                }
-            }
-        }
-
-        CrossAppDomainClonerCallback cadcc;
-        ObjectClone    Marshaller(&cadcc, CrossAppDomain, FALSE);
-        ClientGC.refException = Marshaller.Clone(ServerGC.refException, GetAppDomain(), m_pCliDomain, ServerGC.refExecutionContext);
-
-        Marshaller.RemoveGCFrames();
-
-        // We have to be in the right domain before we throw the exception
-        goto LeaveDomain;
-    }
-
-    if (bHasObjRefReturnVal)
-    {
-        // Must be a domain agile GC ref. We can just copy the reference into the client GC frame.
-        ClientGC.refReturnValue = ServerGC.refReturnValue;
-    }
-
-LeaveDomain: ;
-
-    GCPROTECT_END(); // ServerGC
-
-    END_DOMAIN_TRANSITION;
-
-    if (ClientGC.refException != NULL)
-    {
-        RestorePrincipal(&ClientGC.refPrincipal);
-        COMPlusThrow(ClientGC.refException
-                     COMMA_CORRUPTING_EXCEPTIONS_ONLY(severity)
-            );
-    }
-
-    if (pCurThread->IsExposedObjectSet())
-    {
-        THREADBASEREF ref = (THREADBASEREF) pCurThread->GetExposedObjectRaw();
-        _ASSERTE(ref != NULL);
-
-        ref->SetExecutionContext(ClientGC.refExecutionContext);
-    }
-
-    RestorePrincipal(&ClientGC.refPrincipal);
-
-    // If the return type is an object, take it out of the protected ref
-    if (bHasObjRefReturnVal)
-    {
-        *(Object **)m_pFrame->GetReturnValuePtr() = OBJECTREFToObject(ClientGC.refReturnValue);
-    }
-
-    GCPROTECT_END(); // ClientGC
-
-    return bOptimizable;
-}
-
-// Argument attributes
-#define ARG_NEEDS_UNBOX     0x80000000
-#define ARG_GOES_IN_EDX     0x40000000
-#define ARG_IS_BYREF        0x20000000
-#define ARG_OFFSET_MASK     0x00FFFFFF
-
-// Structure to hold arguments for MarshalAndCall
-struct MarshalAndCallArgs  : public CtxTransitionBaseArgs
-{
-    MarshalAndCallArgs() : Marshaller(&cadcc, CrossAppDomain, FALSE)
-    {
-        STATIC_CONTRACT_SO_INTOLERANT;
-    }
-
-    CrossDomainChannel * pThis;
-
-    struct _gc {
-        OBJECTREF   refReturnValue;
-        OBJECTREF   refException;
-        OBJECTREF   refExecutionContext;
-        OBJECTREF   refPrincipal;
-    } ClientGC;
-
-    BOOL bOptimizable;
-
-    ObjectClone Marshaller;
-    CrossAppDomainClonerCallback cadcc;
-
-    MetaSig     *mSig;
-    ArgIterator *argit;
-
-    DWORD   dwNumArgs;
-#ifdef CALLDESCR_ARGREGS
-    SIZE_T *pRegArgs;
-#endif
-#ifdef CALLDESCR_FPARGREGS
-    FloatArgumentRegisters *pFloatArgumentRegisters;
-#endif
-    SIZE_T *pStackArgs;
-    DWORD  *pArgAttribs;
-
-    DWORD      dwNumObjectsMarshalled;
-    BOOL      *bMarshalledArgs;
-    OBJECTREF *pClientArgArray;
-
-    BOOL        bHasByRefArgsToMarshal;
-    int        *pByRefArgAttribs;
-    TypeHandle *pThByRefs;
-
-    TypeHandle retTh;
-    BOOL bHasObjRefReturnVal;
-    BOOL bHasRetBuffArg;
-    BOOL bHasValueTypeReturnValToMarshal;
-
-    BOOL bMarshalCallContext;
-    BOOL bMarshalReturnCallContext;
-
-#ifdef CALLDESCR_REGTYPEMAP
-    UINT64 uRegTypeMap;
-#endif
-
-#ifdef FEATURE_CORRUPTING_EXCEPTIONS
-    CorruptionSeverity severity;
-#endif // FEATURE_CORRUPTING_EXCEPTIONS
-};
-
-// Simple wrapper to go from C to C++.
-void MarshalAndCall_Wrapper2(MarshalAndCallArgs * pArgs)
-{
-    WRAPPER_NO_CONTRACT;
-
-    pArgs->pThis->MarshalAndCall_Wrapper(pArgs);
-}
-
-void CrossDomainChannel::MarshalAndCall_Wrapper(MarshalAndCallArgs * pArgs)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END;
-
-    // Set up a rip-cord that will immediately stop us reporting GC references we're keeping alive in the Marshaller that was passed
-    // to us in the event that this appdomain is unloaded underneath our feet. This avoids us keeping any server objects alive after
-    // their domain has unloaded.
-    ReportClonerRefsHolder sHolder(&pArgs->Marshaller);
-
-    Thread*    pCurThread    = GetThread();
-    AppDomain* pCurAppDomain = GetAppDomain();
-
-    // Now create a server domain GC frame for all non-arg server side GC references.
-    struct _gc {
-        OBJECTREF   refReturnValue;
-        OBJECTREF   refException;
-        OBJECTREF   refExecutionContext;
-    } ServerGC;
-    ZeroMemory(&ServerGC, sizeof(ServerGC));
-    GCPROTECT_BEGIN(ServerGC);
-
-    // And a variable sized array and frame of marshaled arg GC references.
-    OBJECTREF *pServerArgArray = NULL;
-    pServerArgArray = (OBJECTREF *) _alloca(pArgs->dwNumObjectsMarshalled * sizeof(OBJECTREF));
-    ZeroMemory(pServerArgArray, sizeof(OBJECTREF) * pArgs->dwNumObjectsMarshalled);
-
-    TypeHandle* pServerArgTH = (TypeHandle *) _alloca(pArgs->dwNumObjectsMarshalled * sizeof(TypeHandle));
-    GCPROTECT_ARRAY_BEGIN(pServerArgArray[0], pArgs->dwNumObjectsMarshalled);
-
-    // Initialize server side info, such as method address etc
-    pArgs->bOptimizable = InitServerInfo();
-
-    if (!pArgs->bOptimizable)
-        goto LeaveDomain;
-
-    RenewLease();
-
-    // First clone objref arguments into the called domain
-    if (!RemotableMethodInfo::AreArgsBlittable(m_xret))
-    {
-        // When computing the method signature we need to take special care if the call is on a non-interface class with a
-        // generic instantiation (since in that case we may have a representative method with a non-concrete signature).
-        TypeHandle thDeclaringType;
-        CDC_DETERMINE_DECLARING_TYPE(m_pSrvMD, TypeHandle(GetServerObject()->GetTypeHandle()));
-        MetaSig mSrvSideSig(m_pSrvMD, thDeclaringType);
-        DWORD dwMarshalledArg = 0;
-        for (DWORD i = 0; i < pArgs->dwNumArgs; i++)
-        {
-            CorElementType cType = mSrvSideSig.NextArg();
-            if (pArgs->bMarshalledArgs[i] != TRUE)
-            {
-                // Make sure argument type is loaded
-                if (cType == ELEMENT_TYPE_VALUETYPE)
-                {
-                    mSrvSideSig.GetLastTypeHandleThrowing();
-                }
-                continue;
-            }
-
-            TypeHandle argTh;
-            if (cType == ELEMENT_TYPE_BYREF)
-                mSrvSideSig.GetByRefType(&argTh);
-            else
-                argTh = mSrvSideSig.GetLastTypeHandleThrowing();
-
-            pServerArgTH[dwMarshalledArg] = argTh;
-            pServerArgArray[dwMarshalledArg] = pArgs->Marshaller.Clone(pArgs->pClientArgArray[dwMarshalledArg],
-                                                                       argTh,
-                                                                       m_pCliDomain,
-                                                                       pCurAppDomain,
-                                                                       pArgs->ClientGC.refExecutionContext);
-            dwMarshalledArg++;
-        }
-
-        // Make sure return type is loaded
-        TypeHandle thReturn = mSrvSideSig.GetRetTypeHandleThrowing();
-        _ASSERTE(!thReturn.IsNull());
-
-        if (pArgs->bHasValueTypeReturnValToMarshal)
-        {
-            // The return is a value type which could have GC ref fields. Allocate a boxed value type so that the
-            // return value goes into that. During return from call we'll clone it and copy it onto the stack
-            ServerGC.refReturnValue = thReturn.AsMethodTable()->Allocate();
-        }
-    }
-
-    // Then clone the call context if any
-    if (pArgs->bMarshalCallContext)
-    {
-#ifdef _DEBUG 
-        LOG((LF_REMOTING, LL_INFO100, "MarshalAndCall. Marshalling call context\n"));
-#endif
-        ServerGC.refExecutionContext = pArgs->Marshaller.Clone(pArgs->ClientGC.refExecutionContext,
-                                                               m_pCliDomain,
-                                                               pCurAppDomain,
-                                                               pArgs->ClientGC.refExecutionContext);
-        THREADBASEREF ref = (THREADBASEREF) pCurThread->GetExposedObjectRaw();
-        _ASSERTE(ref != NULL);
-
-        ref->SetExecutionContext(ServerGC.refExecutionContext);
-    }
-    else if (pCurThread->IsExposedObjectSet())
-    {
-        THREADBASEREF ref = (THREADBASEREF) pCurThread->GetExposedObjectRaw();
-        _ASSERTE(ref != NULL);
-
-        ref->SetExecutionContext(NULL);
-    }
-
-#ifdef PROFILING_SUPPORTED 
-        // If we're profiling, notify the profiler that we're about to invoke the remoting target
-        {
-            BEGIN_PIN_PROFILER(CORProfilerTrackRemoting());
-            GCX_PREEMP();
-            g_profControlBlock.pProfInterface->RemotingServerInvocationStarted();
-            END_PIN_PROFILER();
-        }
-#endif // PROFILING_SUPPORTED
-
-    {
-        GCX_COOP();
-        if (!RemotableMethodInfo::AreArgsBlittable(m_xret))
-        {
-            // Next place arguments into the destination array
-            // No GC should occur between now and call dispatch
-            for (DWORD i = 0 ; i < pArgs->dwNumObjectsMarshalled; i++)
-            {
-                BOOL bNeedUnbox = pArgs->pArgAttribs[i] & ARG_NEEDS_UNBOX;
-                BOOL bGoesInEDX = pArgs->pArgAttribs[i] & ARG_GOES_IN_EDX;
-                BOOL bIsByRef = pArgs->pArgAttribs[i] & ARG_IS_BYREF;
-                DWORD dwOffset = pArgs->pArgAttribs[i] & ARG_OFFSET_MASK;
-
-                SIZE_T *pDest = NULL;
-
-#if defined(_TARGET_X86_)
-                if (bGoesInEDX)
-                {
-                    // This has to be EDX for this platform.
-                    pDest = pArgs->pRegArgs;
-                }
-                else
-                {
-                    pDest = (SIZE_T *)((BYTE *)(pArgs->pStackArgs) + dwOffset);
-                }
-#elif defined(CALLDESCR_ARGREGS)
-                // To help deal with the fact that a single argument can span both registers and stack
-                // we've ensured that the register and stack buffers are contiguous and encoded all offsets
-                // from the beginning of the register buffer.
-                pDest = (SIZE_T *)((BYTE *)(pArgs->pRegArgs) + dwOffset);
-#else
-                pDest = (SIZE_T *)((BYTE *)(pArgs->pStackArgs) + dwOffset);
-#endif
-
-                if (bNeedUnbox && !bIsByRef)
-                {
-                    pServerArgTH[i].GetMethodTable()->UnBoxIntoUnchecked(pDest, pServerArgArray[i]);
-                }
-                else if (bIsByRef)
-                {
-                    if (bNeedUnbox)
-                    {
-                        // We don't use the fast path for byref nullables, so UnBox() can be used
-                        *pDest = (SIZE_T)pServerArgArray[i]->UnBox();
-                    }
-                    else
-                    {
-                        // Point to the OBJECTREF
-                        *pDest = (SIZE_T)&pServerArgArray[i];
-                    }
-                }
-                else
-                {
-                    *pDest = (SIZE_T)OBJECTREFToObject(pServerArgArray[i]);
-                }
-            }
-        }
-
-        // Get the 'this' object
-        OBJECTREF srvObject    = GetServerObject();
-        LPVOID    pvRetBuff = NULL;
-
-        FrameWithCookie<ProtectValueClassFrame>* pProtectValueClassFrame = NULL;
-        ValueClassInfo* pValueClasses = NULL;
-
-        if (pArgs->bHasRetBuffArg)
-        {
-            // Need some sort of check here that retTH has been initialized?
-            MethodTable* pMT = pArgs->retTh.GetMethodTable();
-            _ASSERTE_MSG(pMT != NULL, "GetRetType failed?");
-            if (pMT->IsStructRequiringStackAllocRetBuf())
-            {
-                SIZE_T sz = pMT->GetNumInstanceFieldBytes();
-                pvRetBuff = _alloca(sz);
-                memset(pvRetBuff, 0, sz);
-                pValueClasses = new (_alloca(sizeof(ValueClassInfo))) ValueClassInfo(pvRetBuff, pMT, pValueClasses);
-            }
-            else
-            {
-                // We don't use the fast path for values that return nullables, so UnBox() can be used
-                pvRetBuff = (PVOID)ServerGC.refReturnValue->UnBox();
-            }
-        }
-#if defined(_TARGET_X86_)
-        // Check if EDX should point to a return buffer (either stack- or heap-allocated).
-        if (pArgs->bHasValueTypeReturnValToMarshal && pArgs->bHasRetBuffArg)
-        {
-            *(pArgs->pRegArgs) = (SIZE_T)pvRetBuff;
-        }
-        (pArgs->pRegArgs)[1] = (SIZE_T)OBJECTREFToObject(srvObject);
-#elif defined(CALLDESCR_ARGREGS)
-        // On ARM the this pointer goes in r0 and any return buffer argument pointer in r1.
-        pArgs->pRegArgs[0] = (SIZE_T)OBJECTREFToObject(srvObject);
-        if (pArgs->bHasRetBuffArg)
-        {
-            pArgs->pRegArgs[1] = (SIZE_T)pvRetBuff;
-        }
-#else // CALLDESCR_ARGREGS
-
-        if (pArgs->bHasRetBuffArg)
-        {
-            (pArgs->pStackArgs)[0] = (SIZE_T)OBJECTREFToObject(srvObject);
-            (pArgs->pStackArgs)[1] = (SIZE_T)pvRetBuff;
-        }
-        else
-        {
-            (pArgs->pStackArgs)[0] = (SIZE_T)OBJECTREFToObject(srvObject);
-        }
-
-#endif // CALLDESCR_ARGREGS
-
-        CallDescrData callDescrData;
-
-
-        callDescrData.pSrc = pArgs->pStackArgs;
-        callDescrData.numStackSlots = m_numStackSlotsToCopy,
-#ifdef CALLDESCR_ARGREGS
-        callDescrData.pArgumentRegisters = (ArgumentRegisters *)pArgs->pRegArgs;
-#endif
-#ifdef CALLDESCR_FPARGREGS
-        callDescrData.pFloatArgumentRegisters = pArgs->pFloatArgumentRegisters;
-#endif
-#ifdef CALLDESCR_REGTYPEMAP
-        callDescrData.dwRegTypeMap = pArgs->uRegTypeMap;
-#endif
-        callDescrData.fpReturnSize = GetFPReturnSize();
-        callDescrData.pTarget = m_pTargetAddress;
-
-        if (pValueClasses != NULL)
-        {
-            pProtectValueClassFrame = new (_alloca (sizeof (FrameWithCookie<ProtectValueClassFrame>))) 
-                FrameWithCookie<ProtectValueClassFrame>(pCurThread, pValueClasses);
-        }
-
-        DispatchCall(&callDescrData,
-                     &ServerGC.refException,
-                     pArgs->GetCtxTransitionFrame()
-                     COMMA_CORRUPTING_EXCEPTIONS_ONLY(&(pArgs->severity))
-                     );
-
-        // If the return value is a GC ref, store it in a protected place
-        if (ServerGC.refException != NULL)
-        {
-            // Return value is invalid if there was exception thrown
-        }
-        else
-        if (RemotableMethodInfo::IsReturnGCRef(m_xret))
-        {
-            ServerGC.refReturnValue = ObjectToOBJECTREF(*(Object **)(&callDescrData.returnValue));
-            pArgs->bHasObjRefReturnVal = TRUE;
-        }
-        else
-        if (pArgs->bHasValueTypeReturnValToMarshal)
-        {
-            if (!pArgs->bHasRetBuffArg)
-            {
-                //
-                // The value type return value is returned by value in this case.
-                // We have to copy it back into our server object. 
-                //
-                // We don't use the fast path for values that return nullables, so UnBox() can be used
-                //
-                CopyValueClass(ServerGC.refReturnValue->UnBox(), &callDescrData.returnValue, ServerGC.refReturnValue->GetMethodTable(), pCurAppDomain);
-            }
-            else if (pValueClasses != NULL)
-            {
-                // We passed a stack allocated ret buff.  Copy back into the allocated server object.
-                // We don't use the fast path for values that return nullables, so UnBox() can be used
-                CopyValueClass(ServerGC.refReturnValue->UnBox(), pvRetBuff, ServerGC.refReturnValue->GetMethodTable(), pCurAppDomain);
-            }
-            // In all other cases, the return value should be in the server object already.
-        }
-        else
-        {
-            memcpyNoGCRefs(m_pFrame->GetReturnValuePtr(), &callDescrData.returnValue, sizeof(callDescrData.returnValue));
-        }
-
-        if (pProtectValueClassFrame != NULL)
-            pProtectValueClassFrame->Pop(pCurThread);
-    }
-
-#ifdef PROFILING_SUPPORTED 
-        {
-            BEGIN_PIN_PROFILER(CORProfilerTrackRemoting());
-            GCX_PREEMP();
-            g_profControlBlock.pProfInterface->RemotingServerInvocationReturned();
-            END_PIN_PROFILER();
-        }
-#endif // PROFILING_SUPPORTED
-
-    if (pCurThread->IsExposedObjectSet())
-    {
-        THREADBASEREF ref = (THREADBASEREF) pCurThread->GetExposedObjectRaw();
-        _ASSERTE(ref != NULL);
-
-        EXECUTIONCONTEXTREF refExecCtx = (EXECUTIONCONTEXTREF) ref->GetExecutionContext();
-        if (refExecCtx != NULL)
-        {
-            LOGICALCALLCONTEXTREF refLogCallCtx = refExecCtx->GetLogicalCallContext();
-            if (pArgs->bMarshalCallContext ||
-                (refLogCallCtx != NULL && refLogCallCtx->ContainsNonSecurityDataForSerialization()))
-            {
-                ServerGC.refExecutionContext = ref->GetExecutionContext();
-                pArgs->bMarshalReturnCallContext = TRUE;
-#ifdef _DEBUG 
-                LOG((LF_REMOTING, LL_INFO100, "MarshalAndCall. Marshalling return call context\n"));
-#endif
-                ResetPrincipal();
-                EXECUTIONCONTEXTREF ecref = (EXECUTIONCONTEXTREF)pArgs->Marshaller.Clone(ServerGC.refExecutionContext,
-                                                                                         pCurAppDomain,
-                                                                                         m_pCliDomain,
-                                                                                         ServerGC.refExecutionContext);
-                if (pArgs->ClientGC.refExecutionContext != NULL)
-                {
-                    ((EXECUTIONCONTEXTREF)pArgs->ClientGC.refExecutionContext)->SetLogicalCallContext(ecref->GetLogicalCallContext());
-                }
-                else
-                {
-                    pArgs->ClientGC.refExecutionContext = (OBJECTREF)ecref;
-                }
-            }
-        }
-    }
-
-
-    if (ServerGC.refException != NULL)
-    {
-#ifdef _DEBUG 
-        LOG((LF_REMOTING, LL_INFO100, "MarshalAndCall. Exception thrown ! Marshalling exception. \n"));
-#endif
-
-        // Save Watson buckets before the exception object is changed
-        if (GetThread() != NULL)
-        {
-            // Ensure that we have the buckets for the exception in question.
-            // For preallocated exceptions, we capture the buckets in the 
-            // UE WatsonBucket Tracker in AppDomainTransitionExceptionFilter.
-            //
-            // When the exception is reraised in the returning AppDomain,
-            // StackTraceInfo::AppendElement will copy over the buckets 
-            // to the EHtracker corresponding to the raised exception.
-            if (!CLRException::IsPreallocatedExceptionObject(ServerGC.refException))
-            {
-                // For non-preallocated exception objects, the throwable
-                // should already have the buckets in it, unless it was raised in VM native code
-                // and reached here before CLR's managed code exception handler could see it.
-                if(!((EXCEPTIONREF)ServerGC.refException)->AreWatsonBucketsPresent())
-                {
-                    LOG((LF_EH, LL_INFO1000, "MarshalAndCall - Regular exception object received (%p) does not contain watson buckets.\n", 
-                        OBJECTREFToObject(ServerGC.refException)));
-                }
-            }
-        }
-
-        pArgs->ClientGC.refException = pArgs->Marshaller.Clone(ServerGC.refException,
-                                                               pCurAppDomain,
-                                                               m_pCliDomain,
-                                                               ServerGC.refExecutionContext);
-        goto LeaveDomain;
-    }
-
-    if (!RemotableMethodInfo::IsReturnBlittable(m_xret))
-    {
-        LOG((LF_REMOTING, LL_INFO100, "MarshalAndCall. Marshalling return object\n"));
-        // Need to marshal the return object
-
-        pArgs->ClientGC.refReturnValue = pArgs->Marshaller.Clone(ServerGC.refReturnValue,
-                                                                 pArgs->retTh,
-                                                                 pCurAppDomain,
-                                                                 m_pCliDomain,
-                                                                 ServerGC.refExecutionContext);
-
-        if (pArgs->bHasValueTypeReturnValToMarshal)
-        {
-            // Need to copy contents from temp return buffer to the original return buffer
-            void *pDest;
-            if (!pArgs->bHasRetBuffArg)
-            {
-                pDest = m_pFrame->GetReturnValuePtr();
-            }
-            else
-            {
-                pDest = *(void **)(m_pFrame->GetTransitionBlock() + pArgs->argit->GetRetBuffArgOffset());
-            }
-            // We don't use the fast path for values that return nullables, so UnBox() can be used
-            CopyValueClass(pDest, pArgs->ClientGC.refReturnValue->UnBox(), pArgs->ClientGC.refReturnValue->GetMethodTable(), m_pCliDomain);
-        }
-    }
-    else if (pArgs->bHasObjRefReturnVal)
-    {
-        // Must be a domain agile GC ref. We can just copy the reference into the client GC frame.
-        pArgs->ClientGC.refReturnValue = ServerGC.refReturnValue;
-    }
-
-    // Marshal any by-ref args into calling domain
-    if (pArgs->bHasByRefArgsToMarshal)
-    {
-#ifdef _DEBUG 
-        LOG((LF_REMOTING, LL_INFO100, "MarshalAndCall. Marshalling by-ref args\n"));
-#endif
-        int iMarshalledArg = -1;
-        // Look for by ref args
-        for (DWORD i = 0; i < pArgs->dwNumArgs; i++)
-        {
-            if (pArgs->bMarshalledArgs[i] != TRUE)
-                continue;
-
-            iMarshalledArg++;
-
-            BOOL bNeedUnbox = pArgs->pArgAttribs[iMarshalledArg] & ARG_NEEDS_UNBOX;
-            BOOL bIsByRef = pArgs->pArgAttribs[iMarshalledArg] & ARG_IS_BYREF;
-
-            if (!bIsByRef)
-                continue;
-
-            TypeHandle argTh = pArgs->pThByRefs[iMarshalledArg];
-            int offset = pArgs->pByRefArgAttribs[iMarshalledArg];
-            OBJECTREF refReturn = pServerArgArray[iMarshalledArg];
-            GCPROTECT_BEGIN(refReturn);
-
-            refReturn = pArgs->Marshaller.Clone(refReturn,
-                                                argTh,
-                                                pCurAppDomain,
-                                                m_pCliDomain,
-                                                ServerGC.refExecutionContext);
-            if (bNeedUnbox)
-            {
-                // We don't use the fast path for byref nullables, so UnBox() can be used
-                BYTE *pTargetAddress = *((BYTE **)(m_pFrame->GetTransitionBlock() + offset));
-                CopyValueClass(pTargetAddress, refReturn->UnBox(), refReturn->GetMethodTable(), m_pCliDomain);
-            }
-            else
-            {
-                SetObjectReference(*((OBJECTREF **)(m_pFrame->GetTransitionBlock() + offset)), refReturn, m_pCliDomain);
-            }
-            GCPROTECT_END();
-        }
-    }
-
-    LeaveDomain:;
-
-    GCPROTECT_END(); // pServerArgArray
-    GCPROTECT_END(); // ServerGC
-}
-
-
-// Arguments need to be marshalled before dispatch. We walk thru each argument,
-// inspect its type, make a list of objects that need to be marshalled, cross over to the new domain,
-// marshal the objects and dispatch the call. Upon return, we marshal the return object if any and
-// by ref objects if any. Call contexts flows either way
-#ifdef _PREFAST_
-#pragma warning(push)
-#pragma warning(disable:21000) // Suppress PREFast warning about overly large function
-#endif
-BOOL
-CrossDomainChannel::MarshalAndCall()
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END
-
-    MarshalAndCallArgs args;
-
-    args.bHasByRefArgsToMarshal = FALSE;
-
-    args.bHasObjRefReturnVal             = FALSE;
-    args.bHasRetBuffArg                  = FALSE;
-    args.bHasValueTypeReturnValToMarshal = FALSE;
-
-    DWORD dwNumArgs = 0;
-    DWORD dwNumObjectsMarshalled = 0;
-
-    DWORD *pArgAttribs = NULL;
-    BOOL *bMarshalledArgs = NULL;
-    int *pByRefArgAttribs = NULL;
-    TypeHandle *pThByRefs = NULL;
-
-    Thread *pCurThread = GetThread();
-
-#ifdef _DEBUG 
-    LPCUTF8 pszMethodName;
-    pszMethodName = m_pCliMD->GetName();
-    LOG((LF_REMOTING, LL_INFO100, "MarshalAndCall. Marshalling arguments to method %s\n", pszMethodName));
-#endif // _DEBUG
-
-    // Collect all client domain GC references together in a single GC frame.
-    // refReturnValue contains the returned object when its a value type and needs marshalling
-    ZeroMemory(&args.ClientGC, sizeof(args.ClientGC));
-    GCPROTECT_BEGIN(args.ClientGC);
-
-    // When computing the method signature we need to take special care if the call is on a non-interface class with a
-    // generic instantiation (since in that case we may have a representative method with a non-concrete signature).
-    TypeHandle thDeclaringType;
-    CDC_DETERMINE_DECLARING_TYPE(m_pCliMD, TypeHandle(CTPMethodTable::GetMethodTableBeingProxied(m_pFrame->GetThis())));
-    MetaSig mSig(m_pCliMD, thDeclaringType);
-    ArgIterator argit(&mSig);
-    int ofs;
-
-    // NumFixedArgs() doesn't count the "this" object, but SizeOfFrameArgumentArray() does.
-    dwNumArgs = mSig.NumFixedArgs();
-    m_numStackSlotsToCopy = argit.SizeOfFrameArgumentArray() / sizeof(SIZE_T);
-
-    // Ensure none of the following _alloca's are subject to integer overflow problems.
-    DWORD dwMaxEntries = dwNumArgs > m_numStackSlotsToCopy ? dwNumArgs : m_numStackSlotsToCopy;
-    DWORD dwResult;
-    if (!ClrSafeInt<DWORD>::multiply(dwMaxEntries, sizeof(SIZE_T), dwResult))
-        COMPlusThrowOM();
-#ifdef _PREFAST_
-#pragma warning(push)
-#pragma warning(disable:26000) // "Suppress PREFast warning about integer overflow (we're doing an umbrella check)"
-#endif
-
-    args.bHasRetBuffArg           = argit.HasRetBuffArg();
-
-#ifdef _TARGET_X86_
-    BOOL  bArgumentRegisterUsed = FALSE;
-    if (args.bHasRetBuffArg)
-    {
-        bArgumentRegisterUsed = TRUE;
-    }
-#endif // _TARGET_X86_
-
-    // pArgAttribs tell where the marshalled objects should go, where they need unboxing etc
-    pArgAttribs = (DWORD*) _alloca(dwNumArgs * sizeof(DWORD));
-    ZeroMemory(pArgAttribs, sizeof(DWORD) * dwNumArgs);
-    // pThByRefs has the typehandles of the by-ref args
-    pThByRefs = (TypeHandle *)_alloca(dwNumArgs * sizeof(TypeHandle));
-    ZeroMemory(pThByRefs, sizeof(TypeHandle) *dwNumArgs);
-    // pByRefArgAttribs tell where the by-ref args should go, after the call
-    pByRefArgAttribs = (int*) _alloca(dwNumArgs * sizeof(int));
-    ZeroMemory(pByRefArgAttribs, sizeof(int) * dwNumArgs);
-    // bMarshalledArgs is a bunch of flags that tell which args were marshalled
-    bMarshalledArgs = (BOOL*) _alloca(dwNumArgs * sizeof(BOOL));
-    ZeroMemory(bMarshalledArgs, sizeof(BOOL) * dwNumArgs);
-
-    // pArgArray contains marshalled objects on the client side
-    OBJECTREF *pClientArgArray = NULL;
-    pClientArgArray = (OBJECTREF *) _alloca(dwNumArgs * sizeof(OBJECTREF));
-    ZeroMemory(pClientArgArray, sizeof(OBJECTREF) * dwNumArgs);
-    GCPROTECT_ARRAY_BEGIN(pClientArgArray[0], dwNumArgs);
-
-    // pStackArgs will finally contain the arguments that'll be fed to Dispatch call. The Marshalled objects
-    // are not placed directly into pStackArgs because its not possible to GCPROTECT an array that can contain
-    // both GC refs and primitives.
-    DWORD cbStackArgs = m_numStackSlotsToCopy * sizeof (SIZE_T);
-#ifdef CALLDESCR_ARGREGS
-    // Allocate enough space to put ArgumentRegisters at the front of the buffer so we can ensure
-    // register and stack arguments are stored contiguously and simply the case of unboxing a value type that
-    // spans registers and the stack.
-    cbStackArgs += sizeof(ArgumentRegisters);
-#endif
-    SIZE_T *pStackArgs = (SIZE_T*)_alloca(cbStackArgs);
-    ZeroMemory(pStackArgs, cbStackArgs);
-#ifdef CALLDESCR_ARGREGS
-    SIZE_T *pRegArgs = pStackArgs;
-    pStackArgs += sizeof(ArgumentRegisters) / sizeof(SIZE_T);
-#endif
-#ifdef CALLDESCR_FPARGREGS
-    FloatArgumentRegisters *pFloatArgumentRegisters = NULL;
-#endif
-
-#if defined(CALLDESCR_REGTYPEMAP) 
-    UINT64 uRegTypeMap = 0;
-    BYTE*  pMap         = (BYTE*)&uRegTypeMap;
-#endif
-
-    TADDR pTransitionBlock = m_pFrame->GetTransitionBlock();
-
-    for (int argNum = 0;
-         TransitionBlock::InvalidOffset != (ofs = argit.GetNextOffset());
-         argNum++
-        )
-    {
-        DWORD dwOffsetOfArg = 0;
-
-#if defined(CALLDESCR_REGTYPEMAP) 
-        int regArgNum = TransitionBlock::GetArgumentIndexFromOffset(ofs);
-
-        FillInRegTypeMap(ofs, argit.GetArgType(), pMap);
-#endif // defined(CALLDESCR_REGTYPEMAP)
-
-        SIZE_T *pDestToCopy = NULL;
-
-#if defined(_TARGET_ARM_)
-
-        // On ARM there are ranges of offset that can be returned from ArgIterator::GetNextOffset() (where R
-        // == TransitionBlock::GetOffsetOfArgumentRegisters() and S == sizeof(TransitionBlock)):
-        //
-        //  * ofs < 0               : arg is in a floating point register
-        //  * ofs >= R && ofs < S   : arg is in a general register
-        //  * ofs >= S              : arg is on the stack at offset (ofs - X)
-        //
-        // Arguments can be split between general registers and the stack on ARM and as a result both
-        // FramedMethodFrame and this method ensure the storage for register and stack locations is
-        // contiguous.
-        int iInitialRegOffset = TransitionBlock::GetOffsetOfArgumentRegisters();
-        int iInitialStackOffset = sizeof(TransitionBlock);
-        _ASSERTE(iInitialStackOffset == (iInitialRegOffset + sizeof(ArgumentRegisters)));
-        if (ofs < 0)
-        {
-            // Floating point register case. Since these registers can never hold a GC reference we can just
-            // pass through a pointer to the spilled FP reg area in the frame. But we don't do this unless we
-            // see at least one FP arg: passing NULL for pFloatArgumentRegisters enables an optimization in
-            // the call thunk.
-            if (pFloatArgumentRegisters == NULL)
-                pFloatArgumentRegisters = (FloatArgumentRegisters*) (pTransitionBlock + TransitionBlock::GetOffsetOfFloatArgumentRegisters());
-
-            // No arg to copy in this case.
-            continue;
-        }
-
-        _ASSERTE(ofs >= iInitialRegOffset);
-
-        // We've ensured our registers and stack locations are contiguous so treat both types of arguments
-        // identically (i.e. compute a destination offset from the base of the register save area and it will
-        // work for arguments that span from registers to stack or live entirely on the stack).
-        dwOffsetOfArg = ofs - TransitionBlock::GetOffsetOfArgumentRegisters();
-        pDestToCopy = (SIZE_T*)((BYTE *)pRegArgs + dwOffsetOfArg);
-
-#else // _TARGET_ARM_
-
-        dwOffsetOfArg = ofs - TransitionBlock::GetOffsetOfArgs();
-
-#ifdef _TARGET_X86_
-        if (!bArgumentRegisterUsed && gElementTypeInfo[argit.GetArgType()].m_enregister)
-        {
-            pDestToCopy = pRegArgs;
-            bArgumentRegisterUsed = TRUE;
-        }
-        else
-#endif // _TARGET_X86_
-        {
-            _ASSERTE(dwOffsetOfArg < (m_numStackSlotsToCopy * sizeof(SIZE_T)));
-            pDestToCopy = (SIZE_T*)((BYTE *)pStackArgs + dwOffsetOfArg);
-        }
-
-#endif // _TARGET_ARM_
-
-        CorElementType origTyp = argit.GetArgType();
-
-        // Get the signature type of the argument (For ex. enum will be E_T_VT, not E_T_I4 etc)
-        SigPointer sp = mSig.GetArgProps();
-        CorElementType typ;
-        IfFailThrow(sp.GetElemType(&typ));
-        
-        if (typ == ELEMENT_TYPE_VAR ||
-            typ == ELEMENT_TYPE_MVAR ||
-            typ == ELEMENT_TYPE_GENERICINST)
-        {
-            typ = origTyp;
-        }
-
-        switch (typ)
-        {
-                case ELEMENT_TYPE_BOOLEAN:
-                case ELEMENT_TYPE_I1:
-                case ELEMENT_TYPE_U1:
-                case ELEMENT_TYPE_I2:
-                case ELEMENT_TYPE_U2:
-                case ELEMENT_TYPE_CHAR:
-                case ELEMENT_TYPE_I4:
-                case ELEMENT_TYPE_U4:
-#if !defined(COM_STUBS_SEPARATE_FP_LOCATIONS) 
-                case ELEMENT_TYPE_R4:
-#endif
-
-#if defined(_TARGET_X86_) || defined(_TARGET_ARM_)
-                    *(pDestToCopy) = *((SIZE_T*) (pTransitionBlock + ofs));
-#elif defined(_WIN64)
-                    switch (GetSizeForCorElementType((CorElementType)typ))
-                    {
-                        case 1:
-                            *(BYTE*)(pDestToCopy) = *(BYTE*)(pTransitionBlock + ofs);
-                            break;
-
-                        case 2:
-                            *(USHORT*)(pDestToCopy) = *(USHORT*)(pTransitionBlock + ofs);
-                            break;
-
-                        case 4:
-                            *(UINT*)(pDestToCopy) = *(UINT*)(pTransitionBlock + ofs);
-                            break;
-
-                        case 8:
-                            *(SIZE_T*)(pDestToCopy) = *(SIZE_T*)(pTransitionBlock + ofs);
-                            break;
-
-                        default:
-                            _ASSERTE(!"MarshalAndCall() - unexpected size");
-                    }
-#else // !defined(_WIN64)
-                    PORTABILITY_ASSERT("MarshalAndCall() - NYI on this platform");
-#endif // !defined(_WIN64)
-                    break;
-
-                case ELEMENT_TYPE_I:
-                case ELEMENT_TYPE_U:
-                case ELEMENT_TYPE_PTR:
-                case ELEMENT_TYPE_FNPTR:
-
-                    *((SIZE_T*)((BYTE *)pDestToCopy)) = *((SIZE_T*)(pTransitionBlock + ofs));
-                    break;
-
-                case ELEMENT_TYPE_I8:
-                case ELEMENT_TYPE_U8:
-#if !defined(COM_STUBS_SEPARATE_FP_LOCATIONS) 
-                case ELEMENT_TYPE_R8:
-#endif
-
-                    *((INT64*)((BYTE *)pDestToCopy)) = *((INT64 *)(pTransitionBlock + ofs));
-                    break;
-
-#if defined(COM_STUBS_SEPARATE_FP_LOCATIONS) 
-                case ELEMENT_TYPE_R4:
-
-                    if (regArgNum < NUM_ARGUMENT_REGISTERS)
-                    {
-                        *(ARG_SLOT*)pDestToCopy = FPSpillToR4( (LPVOID)(pTransitionBlock + m_pFrame->GetFPArgOffset(regArgNum)) );
-                    }
-                    else
-                    {
-                        *(UINT*)(pDestToCopy) = *(UINT*)(pTransitionBlock + ofs);
-                    }
-                    break;
-
-                case ELEMENT_TYPE_R8:
-
-                    if (regArgNum < NUM_ARGUMENT_REGISTERS)
-                    {
-                        *(ARG_SLOT*)pDestToCopy = FPSpillToR8( (LPVOID)(pTransitionBlock + m_pFrame->GetFPArgOffset(regArgNum)) );
-                    }
-                    else
-                    {
-                        *(SIZE_T*)(pDestToCopy) = *(SIZE_T*)(pTransitionBlock + ofs);
-                    }
-                    break;
-#endif // defined(COM_STUBS_SEPARATE_FP_LOCATIONS)
-
-                case ELEMENT_TYPE_BYREF:
-                {
-                    // Check if this is a by-ref primitive
-                    OBJECTREF refTmpBox = NULL;
-                    TypeHandle ty = TypeHandle();
-                    CorElementType brType = mSig.GetByRefType(&ty);
-                    if (CorIsPrimitiveType(brType) || ty.IsValueType())
-                    {
-
-                        // Needs marshalling
-                        MethodTable *pMT = NULL;
-                        if (CorIsPrimitiveType(brType))
-                            pMT = MscorlibBinder::GetElementType(brType);
-                        else
-                            pMT = ty.GetMethodTable();
-                        refTmpBox = pMT->Box(*((SIZE_T**)(pTransitionBlock + ofs)));
-                        pArgAttribs[dwNumObjectsMarshalled] |= ARG_NEEDS_UNBOX;
-                    }
-                    else
-                    {
-                        OBJECTREF *refRefObj = *((OBJECTREF **)(pTransitionBlock + ofs));
-                        refTmpBox = (refRefObj == NULL ? NULL : *refRefObj);
-                    }
-
-                    pByRefArgAttribs[dwNumObjectsMarshalled] = ofs;
-                    pThByRefs[dwNumObjectsMarshalled] = ty;
-
-                    // we should have stopped nullables before we got here in DoStaticAnalysis
-                    _ASSERTE(ty.IsNull() || !Nullable::IsNullableType(ty));
-                    pArgAttribs[dwNumObjectsMarshalled] |= ARG_IS_BYREF;
-
-                    args.bHasByRefArgsToMarshal = TRUE;
-
-                    pClientArgArray[dwNumObjectsMarshalled] = refTmpBox;
-                    bMarshalledArgs[argNum] = TRUE;
-
-#if defined(_TARGET_X86_)
-                    if (pDestToCopy == pRegArgs)
-                    {
-                        pArgAttribs[dwNumObjectsMarshalled] |= ARG_GOES_IN_EDX;    // Indicate that this goes in EDX
-                    }
-                    else
-#endif // _TARGET_X86_
-                    {
-                        // @TODO - Use QWORD for attribs
-                        _ASSERTE(dwOffsetOfArg < ARG_OFFSET_MASK);
-                        pArgAttribs[dwNumObjectsMarshalled] |= dwOffsetOfArg;
-                    }
-                    dwNumObjectsMarshalled++;
-                }
-                break;
-
-                case ELEMENT_TYPE_VALUETYPE:
-                {
-#if defined(COM_STUBS_SEPARATE_FP_LOCATIONS) 
-                    if (regArgNum < NUM_ARGUMENT_REGISTERS) 
-                    {
-
-                        // We have to copy the floating point registers from a different stack location to the portion of
-                        // the stack used to save the general registers.
-                        if (origTyp == ELEMENT_TYPE_R4)
-                        {
-                            LPVOID pDest = (LPVOID)(pTransitionBlock + ofs);
-                            *(ARG_SLOT*)pDest = FPSpillToR4( (LPVOID)(pTransitionBlock + m_pFrame->GetFPArgOffset(regArgNum)) );
-                        }
-                        else if (origTyp == ELEMENT_TYPE_R8)
-                        {
-                            LPVOID pDest = (LPVOID)(pTransitionBlock + ofs);
-                            *(ARG_SLOT*)pDest = FPSpillToR8( (LPVOID)(pTransitionBlock + m_pFrame->GetFPArgOffset(regArgNum)) );
-                        }
-                    }
-#endif // defined(COM_STUBS_SEPARATE_FP_LOCATIONS)
-
-                    TypeHandle th = mSig.GetLastTypeHandleThrowing();
-
-#ifdef _DEBUG 
-                    {
-                        DefineFullyQualifiedNameForClass()
-                        LPCUTF8 szTypeName = GetFullyQualifiedNameForClassNestedAware(th.GetMethodTable());
-                        LOG((LF_REMOTING, LL_INFO100, "MarshalAndCall. Boxing a value type argument of type %s.\n", &szTypeName[0]));
-                    }
-#endif // _DEBUG
-
-                    OBJECTREF refTmpBox;
-#if defined(ENREGISTERED_PARAMTYPE_MAXSIZE) 
-                    if (argit.IsArgPassedByRef())
-                    {
-                        refTmpBox = th.GetMethodTable()->Box(*(LPVOID*)(pTransitionBlock + ofs));
-
-                        // we should have stopped nullables before we got here in DoStaticAnalysis
-                        _ASSERTE(!Nullable::IsNullableType(th));
-                        pArgAttribs[dwNumObjectsMarshalled] |= ARG_IS_BYREF;
-
-                        pByRefArgAttribs[dwNumObjectsMarshalled] = ofs;
-                        pThByRefs[dwNumObjectsMarshalled] = th;
-                    }
-                    else
-#endif // defined(ENREGISTERED_PARAMTYPE_MAXSIZE)
-                    {
-                        refTmpBox = th.GetMethodTable()->Box((void *)(pTransitionBlock + ofs));
-                    }
-                    pClientArgArray[dwNumObjectsMarshalled] = refTmpBox;
-                    bMarshalledArgs[argNum] = TRUE;
-
-#if defined(_TARGET_X86_)
-                    if (pDestToCopy == pRegArgs)
-                    {
-                        pArgAttribs[dwNumObjectsMarshalled]  |= ARG_GOES_IN_EDX;    // Indicate that this goes in EDX
-                    }
-                    else
-#endif // _TARGET_X86_
-                    {
-                        // @TODO - Use QWORD for attribs
-                        _ASSERTE(dwOffsetOfArg < ARG_OFFSET_MASK);
-                        pArgAttribs[dwNumObjectsMarshalled] |= dwOffsetOfArg;
-                    }
-                    pArgAttribs[dwNumObjectsMarshalled] |= ARG_NEEDS_UNBOX; // Indicate that an unboxing is required
-                    dwNumObjectsMarshalled++;
-                }
-                break;
-
-                case ELEMENT_TYPE_SZARRAY:          // Single Dim
-                case ELEMENT_TYPE_ARRAY:            // General Array
-                case ELEMENT_TYPE_CLASS:            // Class
-                case ELEMENT_TYPE_OBJECT:
-                case ELEMENT_TYPE_STRING:           // System.String
-                case ELEMENT_TYPE_VAR:
-                {
-                    OBJECTREF *refRefObj = (OBJECTREF *)(pTransitionBlock + ofs);
-                    // The frame does protect this object, so mark it as such to avoid asserts
-                    INDEBUG(Thread::ObjectRefNew(refRefObj);)
-                    INDEBUG(Thread::ObjectRefProtected(refRefObj);)
-
-                    pClientArgArray[dwNumObjectsMarshalled] = *refRefObj;
-                    bMarshalledArgs[argNum] = TRUE;
-
-#ifdef _TARGET_X86_
-                    if (pDestToCopy == pRegArgs)
-                    {
-                        pArgAttribs[dwNumObjectsMarshalled] |= ARG_GOES_IN_EDX;    // Indicate that this goes in EDX
-                    }
-                    else
-#endif // _TARGET_X86_
-                    {
-                        // @TODO - Use QWORD for attribs
-                        _ASSERTE(dwOffsetOfArg < ARG_OFFSET_MASK);
-                        pArgAttribs[dwNumObjectsMarshalled] |= dwOffsetOfArg;
-                    }
-                    dwNumObjectsMarshalled++;
-                }
-                break;
-
-                default:
-                    _ASSERTE(!"Unknown Element type in MarshalAndCall" );
-        }
-    }
-
-    if (!RemotableMethodInfo::IsReturnBlittable(m_xret))
-    {
-        CorElementType retType = mSig.GetReturnType();
-        if (retType == ELEMENT_TYPE_VALUETYPE)
-        {
-            args.retTh = mSig.GetRetTypeHandleThrowing();
-            args.bHasValueTypeReturnValToMarshal = TRUE;
-        }
-        else
-        {
-            args.retTh = mSig.GetRetTypeHandleThrowing();
-        }
-    }
-
-    // Check for any call context
-    BOOL bMarshalCallContext = FALSE;
-    args.bMarshalReturnCallContext = FALSE;
-    if (pCurThread->IsExposedObjectSet())
-    {
-        THREADBASEREF ref = (THREADBASEREF) pCurThread->GetExposedObjectRaw();
-        _ASSERTE(ref != NULL);
-
-        EXECUTIONCONTEXTREF refExecCtx = (EXECUTIONCONTEXTREF) ref->GetExecutionContext();
-        if (refExecCtx != NULL)
-        {
-            args.ClientGC.refExecutionContext = refExecCtx;
-            args.ClientGC.refPrincipal = ReadPrincipal();
-
-            LOGICALCALLCONTEXTREF refLogCallCtx = refExecCtx->GetLogicalCallContext();
-            if (refLogCallCtx != NULL)
-            {
-                if (refLogCallCtx->ContainsDataForSerialization())
-                {
-                    bMarshalCallContext = TRUE;
-                }
-            }
-        }
-    }
-
-#ifdef _PREFAST_
-#pragma warning(pop)
-#endif
-
-    // Make the Cross-AppDomain call
-    {
-        args.pThis = this;
-
-        args.bOptimizable = TRUE;
-
-        args.mSig  = &mSig;
-        args.argit = &argit;
-
-        args.dwNumArgs = dwNumArgs;
-        args.pStackArgs = pStackArgs;
-#ifdef CALLDESCR_ARGREGS
-        args.pRegArgs = pRegArgs;
-#endif
-#ifdef CALLDESCR_FPARGREGS
-        args.pFloatArgumentRegisters = pFloatArgumentRegisters;
-#endif
-        args.pArgAttribs = pArgAttribs;
-
-        args.dwNumObjectsMarshalled = dwNumObjectsMarshalled;
-        args.bMarshalledArgs = bMarshalledArgs;
-        args.pClientArgArray = pClientArgArray;
-
-        args.pByRefArgAttribs = pByRefArgAttribs;
-        args.pThByRefs        = pThByRefs;
-
-        args.bMarshalCallContext = bMarshalCallContext;
-
-#ifdef CALLDESCR_REGTYPEMAP
-        args.uRegTypeMap = *(UINT64*)pMap;
-#endif
-
-#ifdef FEATURE_CORRUPTING_EXCEPTIONS
-        // By default assume that exception thrown across the cross-AD call is NotCorrupting.
-        args.severity = NotCorrupting;
-#endif // FEATURE_CORRUPTING_EXCEPTIONS
-
-        MakeCallWithPossibleAppDomainTransition(m_pSrvDomain, (FPAPPDOMAINCALLBACK) MarshalAndCall_Wrapper2, &args);
-    }
-
-    if (args.ClientGC.refException != NULL)
-    {
-        RestorePrincipal(&args.ClientGC.refPrincipal);
-        COMPlusThrow(args.ClientGC.refException
-                     COMMA_CORRUPTING_EXCEPTIONS_ONLY(args.severity)
-            );
-    }
-
-    if (pCurThread->IsExposedObjectSet())
-    {
-        THREADBASEREF ref = (THREADBASEREF) pCurThread->GetExposedObjectRaw();
-        _ASSERTE(ref != NULL);
-
-        ref->SetExecutionContext(args.ClientGC.refExecutionContext);
-    }
-
-    RestorePrincipal(&args.ClientGC.refPrincipal);
-
-    // If the return type is an object, take it out of the protected ref
-    if (args.bHasObjRefReturnVal)
-    {
-        *(Object **)m_pFrame->GetReturnValuePtr() = OBJECTREFToObject(args.ClientGC.refReturnValue);
-    }
-
-    GCPROTECT_END();    // pClientArgArray
-    GCPROTECT_END();    // args.ClientGC
-
-    args.Marshaller.RemoveGCFrames();
-
-    return args.bOptimizable;
-}
-#ifdef _PREFAST_
-#pragma warning(pop)
-#endif
-
-#endif // CROSSGEN_COMPILE
-
-#endif // FEATURE_REMOTING
diff --git a/src/vm/crossgen/CMakeLists.txt b/src/vm/crossgen/CMakeLists.txt
index c6ef163d53..bef9f62d85 100644
--- a/src/vm/crossgen/CMakeLists.txt
+++ b/src/vm/crossgen/CMakeLists.txt
@@ -96,12 +96,6 @@ set(VM_CROSSGEN_SOURCES
     ../crossgencompile.cpp
 )
 
-if(FEATURE_CER)
-    list(APPEND VM_CROSSGEN_SOURCES
-      ../constrainedexecutionregion.cpp
-        )
-endif(FEATURE_CER)
-
 if(FEATURE_READYTORUN)
     list(APPEND VM_CROSSGEN_SOURCES
       ../readytoruninfo.cpp
diff --git a/src/vm/crossgencompile.cpp b/src/vm/crossgencompile.cpp
index ffb025adb0..5a4f41e021 100644
--- a/src/vm/crossgencompile.cpp
+++ b/src/vm/crossgencompile.cpp
@@ -16,7 +16,6 @@
 
 #include "comdelegate.h"
 #include "compile.h"
-#include "constrainedexecutionregion.h"
 #include "security.h"
 #include "invokeutil.h"
 #include "comcallablewrapper.h"
@@ -461,12 +460,10 @@ void AppDomain::RaiseLoadingAssemblyEvent(DomainAssembly *pAssembly)
 {
 }
 
-#ifdef FEATURE_CORECLR
 BOOL AppDomain::BindingByManifestFile()
 {
     return FALSE;
 }
-#endif
 
 ReJitManager::ReJitManager()
 { 
diff --git a/src/vm/crst.cpp b/src/vm/crst.cpp
index 7bf9bd65da..a1a9a9f71f 100644
--- a/src/vm/crst.cpp
+++ b/src/vm/crst.cpp
@@ -202,62 +202,6 @@ void CrstBase::Enter(INDEBUG(NoLevelCheckFlag noLevelCheckFlag/* = CRST_LEVEL_CH
 #else // !DACCESS_COMPILE
 
 
-#if !defined(FEATURE_CORECLR)
-// Slower spin enter path after first attemp failed
-void CrstBase::SpinEnter()
-{
-    STATIC_CONTRACT_NOTHROW;
-    STATIC_CONTRACT_GC_NOTRIGGER;
-    STATIC_CONTRACT_CAN_TAKE_LOCK;
-
-    // We only reach this routine when first attemp failed, so time to fire ETW event (fyuan)
-
-    // Fire an ETW event to mark the beginning of native contention
-    FireEtwContentionStart_V1(ETW::ContentionLog::ContentionStructs::NativeContention, GetClrInstanceId());
-
-    // Try spinning and yielding before eventually blocking.
-    // The limit of dwRepetitions = 10 is largely arbitrary - feel free to tune if you have evidence
-    // you're making things better.
-    
-    for (DWORD iter = 0; iter < g_SpinConstants.dwRepetitions; iter++)
-    {
-        DWORD i = g_SpinConstants.dwInitialDuration;
-        
-        do
-        {
-            if (  (m_criticalsection.LockCount == -1 || 
-                (size_t)m_criticalsection.OwningThread == (size_t) GetCurrentThreadId())
-            && UnsafeTryEnterCriticalSection(&m_criticalsection))
-            {
-                return;
-            }
-                
-            if (g_SystemInfo.dwNumberOfProcessors <= 1)
-            {
-                break;
-            }
-            
-            // Delay by approximately 2*i clock cycles (Pentium III).
-            // This is brittle code - future processors may of course execute this
-            // faster or slower, and future code generators may eliminate the loop altogether.
-            // The precise value of the delay is not critical, however, and can't think
-            // of a better way that isn't machine-dependent.
-            
-            for (int delayCount = i; --delayCount; ) 
-            {
-                YieldProcessor();           // indicate to the processor that we are spining 
-            }
-
-            // exponential backoff: wait a factor longer in the next iteration
-            i *= g_SpinConstants.dwBackoffFactor;
-        } while (i < g_SpinConstants.dwMaximumDuration);
-        
-        __SwitchToThread(0, CALLER_LIMITS_SPINNING);
-    }
-
-    UnsafeEnterCriticalSection(& m_criticalsection);
-}
-#endif // FEATURE_CORECLR
 
 
 void CrstBase::Enter(INDEBUG(NoLevelCheckFlag noLevelCheckFlag/* = CRST_LEVEL_CHECK*/))
@@ -438,10 +382,6 @@ void CrstBase::Enter(INDEBUG(NoLevelCheckFlag noLevelCheckFlag/* = CRST_LEVEL_CH
         
         if (! fIsCriticalSectionEnteredAfterFailingOnce)
         {
-#ifndef FEATURE_CORECLR
-            // Fire an ETW event to mark the beginning of native contention
-            FireEtwContentionStart_V1(ETW::ContentionLog::ContentionStructs::NativeContention, GetClrInstanceId());
-#endif // !FEATURE_CORECLR
             fIsCriticalSectionEnteredAfterFailingOnce = TRUE;
 
             hr = m_pHostCrst->Enter(option);
@@ -465,36 +405,13 @@ void CrstBase::Enter(INDEBUG(NoLevelCheckFlag noLevelCheckFlag/* = CRST_LEVEL_CH
             Thread::BeginThreadAffinity();
         }
 
-#ifdef FEATURE_CORECLR
         UnsafeEnterCriticalSection(&m_criticalsection);
-#else
-        // Try entering the critical section once, if we fail we contend
-        // and fire the contention start ETW event
-        if ((m_criticalsection.LockCount == -1 || (size_t)m_criticalsection.OwningThread == (size_t) GetCurrentThreadId())
-             && UnsafeTryEnterCriticalSection(& m_criticalsection))
-        {
-        }
-        else
-        {
-            SpinEnter();
-
-            fIsCriticalSectionEnteredAfterFailingOnce = TRUE;
-        }
-#endif
 
 #ifdef FEATURE_INCLUDE_ALL_INTERFACES
         INCTHREADLOCKCOUNTTHREAD(pThread);
 #endif
     }
 
-#ifndef FEATURE_CORECLR
-    // Fire an ETW event to mark the end of native contention
-    // This we do only when we have fired a contention start event before
-    if (fIsCriticalSectionEnteredAfterFailingOnce)
-    {
-        FireEtwContentionStop(ETW::ContentionLog::ContentionStructs::NativeContention, GetClrInstanceId());
-    }
-#endif // !FEATURE_CORECLR
 
 #ifdef _DEBUG
     PostEnter();
diff --git a/src/vm/customattribute.cpp b/src/vm/customattribute.cpp
index a83815f8bf..5b679548db 100644
--- a/src/vm/customattribute.cpp
+++ b/src/vm/customattribute.cpp
@@ -906,93 +906,6 @@ FCIMPL5(VOID, COMCustomAttribute::ParseAttributeUsageAttribute, PVOID pData, ULO
 }
 FCIMPLEND
 
-#ifdef FEATURE_CAS_POLICY
-FCIMPL4(VOID, COMCustomAttribute::GetSecurityAttributes, ReflectModuleBaseObject *pModuleUNSAFE, DWORD tkToken, CLR_BOOL fAssembly, PTRARRAYREF* ppArray)
-{
-    FCALL_CONTRACT;
-
-    OBJECTREF throwable = NULL;
-    REFLECTMODULEBASEREF refModule = (REFLECTMODULEBASEREF)ObjectToOBJECTREF(pModuleUNSAFE);
-
-    if(refModule == NULL)
-        FCThrowResVoid(kArgumentNullException, W("Arg_InvalidHandle"));
-
-    Module *pModule = refModule->GetModule();
-
-    HELPER_METHOD_FRAME_BEGIN_2(throwable, refModule);
-    {
-        IMDInternalImport* pScope = pModule->GetMDImport();
-
-        DWORD action;    
-
-        CORSEC_ATTRSET_ARRAY aAttrset;
-        DWORD dwCount = 0;
-        for(action = 1; action <= dclMaximumValue; action++)
-        {
-            // We cannot use IsAssemblyDclAction(action) != fAssembly because CLR_BOOL is defined 
-            // as BYTE in PAL so it might contain a value other than 0 or 1.
-            if (IsNGenOnlyDclAction(action) || IsAssemblyDclAction(action) == !fAssembly)
-                continue;
-
-            HENUMInternalHolder hEnum(pScope);                                                                   
-            if (!hEnum.EnumPermissionSetsInit(tkToken, (CorDeclSecurity)action))
-                continue;
-
-            mdPermission tkPerm;
-            BYTE* pbBlob;
-            ULONG cbBlob;
-            DWORD dwAction;
-
-            while (pScope->EnumNext(&hEnum, &tkPerm))
-            {
-                IfFailThrow(pScope->GetPermissionSetProps(
-                    tkPerm,
-                    &dwAction,
-                    (void const **)&pbBlob,
-                    &cbBlob));
-                
-                CORSEC_ATTRSET* pAttrSet = &*aAttrset.Append();
-                IfFailThrow(BlobToAttributeSet(pbBlob, cbBlob, pAttrSet, dwAction));
-
-                dwCount += pAttrSet->dwAttrCount;
-            }
-        }
-
-        *ppArray = (PTRARRAYREF)AllocateObjectArray(dwCount, g_pObjectClass);
-
-        CQuickBytes qb;
-
-        COUNT_T c = 0;
-        for (COUNT_T i = 0; i < aAttrset.GetCount(); i ++)
-        {
-            CORSEC_ATTRSET& attrset = aAttrset[i];
-            OBJECTREF* attrArray = (OBJECTREF*)qb.AllocThrows(attrset.dwAttrCount * sizeof(OBJECTREF));
-            memset(attrArray, 0, attrset.dwAttrCount * sizeof(OBJECTREF));
-            {
-                // Convert to a managed array of attribute objects
-                DWORD dwErrorIndex;
-                HRESULT hr = E_FAIL;
-                GCPROTECT_ARRAY_BEGIN(*attrArray, attrset.dwAttrCount);
-                // This is very tricky.
-                // We have a GCFrame local here.  The local goes out of scope beyond for loop.  The stack location of the local
-                // is then reused by other variables, and the content in GCFrame may be changed.  But the Frame is still chained
-                // on our Thread object.
-                // If exception is thrown before we pop our frame chain, we will have corrupted frame chain.
-                hr = SecurityAttributes::AttributeSetToManaged(attrArray, &attrset, &throwable, &dwErrorIndex, true);
-                GCPROTECT_END();
-                if (FAILED(hr))
-                    COMPlusThrowHR(hr);
-
-                for (COUNT_T j = 0; j < attrset.dwAttrCount; j ++)
-                    (*ppArray)->SetAt(c++, attrArray[j]);
-            }
-            
-        }
-    }
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-#endif // FEATURE_CAS_POLICY
 
 FCIMPL7(void, COMCustomAttribute::GetPropertyOrFieldData, ReflectModuleBaseObject *pModuleUNSAFE, BYTE** ppBlobStart, BYTE* pBlobEnd, STRINGREF* pName, CLR_BOOL* pbIsProperty, OBJECTREF* pType, OBJECTREF* value)
 {
diff --git a/src/vm/dangerousapis.h b/src/vm/dangerousapis.h
index 13122b7e8d..51686135e8 100644
--- a/src/vm/dangerousapis.h
+++ b/src/vm/dangerousapis.h
@@ -48,20 +48,6 @@ DEFINE_DANGEROUS_API(EVENT_INFO,                API_NAMES("AddEventHandler", "Re
 DEFINE_DANGEROUS_API(EVENT,                     API_NAMES("AddEventHandler", "RemoveEventHandler", "ToString"))
 DEFINE_DANGEROUS_API(RESOURCE_MANAGER,          API_NAMES("GetResourceSet", "InternalGetResourceSet", ".ctor"))
 
-#if defined(FEATURE_COMINTEROP) && !defined(FEATURE_CORECLR)
-// The COM interfaces implemented by the reflection types.
-// The IDispatch Invoke methods are not included here because they are not implemented in mscorlib.
-DEFINE_DANGEROUS_API(ITYPE,                     API_NAMES("InvokeMember"))
-DEFINE_DANGEROUS_API(IASSEMBLY,                 API_NAMES("CreateInstance"))
-DEFINE_DANGEROUS_API(IMETHODBASE,               API_NAMES("Invoke"))
-DEFINE_DANGEROUS_API(IMETHODINFO,               API_NAMES("Invoke"))
-DEFINE_DANGEROUS_API(ICONSTRUCTORINFO,          API_NAMES("Invoke", "Invoke_2", "Invoke_3", "Invoke_4", "Invoke_5"))
-DEFINE_DANGEROUS_API(IFIELDINFO,                API_NAMES("GetValue", "SetValue"))
-DEFINE_DANGEROUS_API(IPROPERTYINFO,             API_NAMES("GetValue", "SetValue"))
-DEFINE_DANGEROUS_API(IEVENTINFO,                API_NAMES("AddEventHandler", "RemoveEventHandler"))
-DEFINE_DANGEROUS_API(IAPPDOMAIN,                API_NAMES("CreateInstance", "CreateInstanceFrom", "DefineDynamicAssembly", "Load"))
-DEFINE_DANGEROUS_API(IREFLECT,                  API_NAMES("InvokeMember"))
-#endif // FEATURE_COMINTEROP && !FEATURE_CORECLR
 
 
 
diff --git a/src/vm/dataimage.cpp b/src/vm/dataimage.cpp
index e90c7e6a0e..f6b8337b7c 100644
--- a/src/vm/dataimage.cpp
+++ b/src/vm/dataimage.cpp
@@ -12,7 +12,6 @@
 #include "compile.h"
 
 #include "field.h"
-#include "constrainedexecutionregion.h"
 
 //
 // Include Zapper infrastructure here
@@ -128,11 +127,7 @@ DataImage::DataImage(Module *module, CEEPreloader *preloader)
 
     m_pInternedStructures = new InternedStructureHashTable();
 
-#ifdef FEATURE_CORECLR
     m_inlineTrackingMap = NULL;
-#else
-    m_inlineTrackingMap = new InlineTrackingMap();
-#endif
 }
 
 DataImage::~DataImage()
@@ -896,10 +891,6 @@ void DataImage::FixupRVAs()
     FixupModuleRVAs();
     FixupRvaStructure();
 
-#ifdef FEATURE_CER
-    if (m_module->m_pCerNgenRootTable != NULL)
-        m_module->m_pCerNgenRootTable->FixupRVAs(this);
-#endif
 
     // Dev11 bug 181494 instrumentation
     if (m_Fixups.GetCount() != m_iCurrentFixup) EEPOLICY_HANDLE_FATAL_ERROR(COR_E_EXECUTIONENGINE);
diff --git a/src/vm/debugdebugger.cpp b/src/vm/debugdebugger.cpp
index c8b76bf6dc..32c6cd6cce 100644
--- a/src/vm/debugdebugger.cpp
+++ b/src/vm/debugdebugger.cpp
@@ -102,61 +102,6 @@ UINT_PTR FindMostRecentUserCodeOnStack(void)
     return address;
 }
 
-#ifndef FEATURE_CORECLR   
-// Call into the unhandled-exception processing code to launch Watson.
-// 
-// Arguments:
-//    address - address to distinguish callsite of break.
-//    
-// Notes:
-//    Invokes a watson dialog in response to a user break (Debug.Break).
-//    Assumes that caller has already enforced any policy it cares about related to whether a debugger is attached.
-void DoWatsonForUserBreak(UINT_PTR address)
-{
-    CONTRACTL
-    {
-        MODE_ANY;
-        GC_TRIGGERS;
-        THROWS;
-        PRECONDITION(address != NULL);
-    }
-    CONTRACTL_END;
-
-    CONTEXT context;
-    EXCEPTION_RECORD exceptionRecord;
-    EXCEPTION_POINTERS exceptionPointers;
-
-    ZeroMemory(&context, sizeof(context));
-    ZeroMemory(&exceptionRecord, sizeof(exceptionRecord));
-    ZeroMemory(&exceptionPointers, sizeof(exceptionPointers));
-
-    // Try to locate the user managed code invoking System.Diagnostics.Debugger.Break
-    UINT_PTR userCodeAddress = FindMostRecentUserCodeOnStack();
-    if (userCodeAddress != NULL)
-    {
-        address = userCodeAddress;
-    }
-
-    LOG((LF_EH, LL_INFO10, "DoDebugBreak: break at %0p\n", address));
-
-    exceptionRecord.ExceptionAddress = reinterpret_cast< PVOID >(address);
-    exceptionPointers.ExceptionRecord = &exceptionRecord;
-    exceptionPointers.ContextRecord = &context;
-
-    Thread *pThread = GetThread();
-    PTR_EHWatsonBucketTracker pUEWatsonBucketTracker = pThread->GetExceptionState()->GetUEWatsonBucketTracker();
-    _ASSERTE(pUEWatsonBucketTracker != NULL);
-    pUEWatsonBucketTracker->SaveIpForWatsonBucket(address);
-    pUEWatsonBucketTracker->CaptureUnhandledInfoForWatson(TypeOfReportedError::UserBreakpoint, pThread, NULL);
-    if (pUEWatsonBucketTracker->RetrieveWatsonBuckets() == NULL)
-    {
-        pUEWatsonBucketTracker->ClearWatsonBucketDetails();
-    }
-
-    WatsonLastChance(GetThread(), &exceptionPointers, TypeOfReportedError::UserBreakpoint);
-
-} // void DoDebugBreak()
-#endif // !FEATURE_CORECLR   
 
 // This does a user break, triggered by System.Diagnostics.Debugger.Break, or the IL opcode for break.
 //
@@ -210,12 +155,6 @@ FCIMPL0(void, DebugDebugger::Break)
     }
     else
     {   
-#ifndef FEATURE_CORECLR        
-        // No debugger attached -- Watson up.
-
-        // The HelperMethodFrame knows how to get the return address.
-        DoWatsonForUserBreak(HELPER_METHOD_FRAME_GET_RETURN_ADDRESS());
-#endif //FEATURE_CORECLR
     }
 
     HELPER_METHOD_FRAME_END();
@@ -507,7 +446,6 @@ FCIMPL4(void, DebugStackTrace::GetStackFramesInternal,
         SetObjectReference( (OBJECTREF *)&(pStackFrameHelper->rgiColumnNumber), (OBJECTREF)columnNumbers,
                             pStackFrameHelper->GetAppDomain());
 
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
         // Allocate memory for the flag indicating if this frame represents the last one from a foreign
         // exception stack trace provided we have any such frames. Otherwise, set it to null.
         // When StackFrameHelper.IsLastFrameFromForeignExceptionStackTrace is invoked in managed code,
@@ -528,7 +466,6 @@ FCIMPL4(void, DebugStackTrace::GetStackFramesInternal,
             SetObjectReference( (OBJECTREF *)&(pStackFrameHelper->rgiLastFrameFromForeignExceptionStackTrace), NULL,
                                 pStackFrameHelper->GetAppDomain());
         }
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 
         // Determine if there are any dynamic methods in the stack trace.  If there are,
         // allocate an ObjectArray large enough to hold an ObjRef to each one.
@@ -579,7 +516,6 @@ FCIMPL4(void, DebugStackTrace::GetStackFramesInternal,
             I4 *pILI4 = (I4 *)((I4ARRAYREF)pStackFrameHelper->rgiILOffset)->GetDirectPointerToNonObjectElements();
             pILI4[iNumValidFrames] = data.pElements[i].dwILOffset;
 
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
             if (data.fDoWeHaveAnyFramesFromForeignStackTrace)
             {
                 // Set the BOOL indicating if the frame represents the last frame from a foreign exception stack trace.
@@ -587,7 +523,6 @@ FCIMPL4(void, DebugStackTrace::GetStackFramesInternal,
                                             ->GetDirectPointerToNonObjectElements();
                 pIsLastFrameFromForeignExceptionStackTraceU1 [iNumValidFrames] = (U1) data.pElements[i].fIsLastFrameFromForeignStackTrace; 
             }
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 
             MethodDesc *pMethod = data.pElements[i].pFunc;
 
@@ -1223,10 +1158,8 @@ void DebugStackTrace::GetStackFramesFromException(OBJECTREF * e,
         // The number of frame info elements in the stack trace info
         pData->cElements = static_cast<int>(traceData.Size());
 
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
         // By default, assume that we have no frames from foreign exception stack trace.
         pData->fDoWeHaveAnyFramesFromForeignStackTrace = FALSE;
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 
         // Now we know the size, allocate the information for the data struct
         if (pData->cElements != 0)
@@ -1239,7 +1172,6 @@ void DebugStackTrace::GetStackFramesFromException(OBJECTREF * e,
             {
                 StackTraceElement const & cur = traceData[i];
 
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
                 // If we come across any frame representing foreign exception stack trace,
                 // then set the flag indicating so. This will be used to allocate the
                 // corresponding array in StackFrameHelper.
@@ -1247,7 +1179,6 @@ void DebugStackTrace::GetStackFramesFromException(OBJECTREF * e,
                 {
                     pData->fDoWeHaveAnyFramesFromForeignStackTrace = TRUE;
                 }
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 
                 // Fill out the MethodDesc*
                 MethodDesc *pMD = cur.pFunc;
@@ -1270,9 +1201,7 @@ void DebugStackTrace::GetStackFramesFromException(OBJECTREF * e,
                 }
 
                 pData->pElements[i].InitPass1(dwNativeOffset, pMD, (PCODE) cur.ip
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
                     , cur.fIsLastFrameFromForeignStackTrace
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
                     );
 #ifndef DACCESS_COMPILE
                 pData->pElements[i].InitPass2();            
@@ -1294,9 +1223,7 @@ void DebugStackTrace::DebugStackTraceElement::InitPass1(
     DWORD dwNativeOffset,
     MethodDesc *pFunc,
     PCODE ip
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
     , BOOL fIsLastFrameFromForeignStackTrace /*= FALSE*/
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 )
 {
     LIMITED_METHOD_CONTRACT;
@@ -1308,9 +1235,7 @@ void DebugStackTrace::DebugStackTraceElement::InitPass1(
     this->pFunc = pFunc;
     this->dwOffset = dwNativeOffset;
     this->ip = ip;
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
     this->fIsLastFrameFromForeignStackTrace = fIsLastFrameFromForeignStackTrace;
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 }
 
 #ifndef DACCESS_COMPILE
diff --git a/src/vm/debugdebugger.h b/src/vm/debugdebugger.h
index 9cf5c3c0f0..6c4d383765 100644
--- a/src/vm/debugdebugger.h
+++ b/src/vm/debugdebugger.h
@@ -92,9 +92,7 @@ public:
     I4ARRAYREF rgiLineNumber;
     I4ARRAYREF rgiColumnNumber;
 
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
     BOOLARRAYREF rgiLastFrameFromForeignExceptionStackTrace;
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 
     OBJECTREF getSourceLineInfo;
     int iFrameCount;
@@ -136,11 +134,9 @@ private:
         DWORD dwILOffset;
         MethodDesc *pFunc;
         PCODE ip;
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
         // TRUE if this element represents the last frame of the foreign
         // exception stack trace.
         BOOL			fIsLastFrameFromForeignStackTrace;
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 
         // Initialization done under TSL.
         // This is used when first collecting the stack frame data.
@@ -148,9 +144,7 @@ private:
             DWORD dwNativeOffset,
             MethodDesc *pFunc,
             PCODE ip
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
             , BOOL			fIsLastFrameFromForeignStackTrace = FALSE
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 			);
 
         // Initialization done outside the TSL.
@@ -171,9 +165,7 @@ public:
         DebugStackTraceElement* pElements;
         THREADBASEREF   TargetThread;
         AppDomain *pDomain;
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
         BOOL	fDoWeHaveAnyFramesFromForeignStackTrace;
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 
 
         GetStackFramesData() :  skip(0), 
@@ -184,9 +176,7 @@ public:
                                 TargetThread((THREADBASEREF)(TADDR)NULL)
         { 
             LIMITED_METHOD_CONTRACT;
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
             fDoWeHaveAnyFramesFromForeignStackTrace = FALSE;
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 
         }
 
diff --git a/src/vm/disassembler.h b/src/vm/disassembler.h
index 1b3bf46e0e..5a7976a44f 100644
--- a/src/vm/disassembler.h
+++ b/src/vm/disassembler.h
@@ -10,7 +10,6 @@
 #define USE_COREDISTOOLS_DISASSEMBLER 0
 #define USE_MSVC_DISASSEMBLER 0
 #ifdef HAVE_GCCOVER
-    #if defined(FEATURE_CORECLR)
         // COREDISTOOLS disassembler only supports amd64 and x86, so if this is
         // CoreCLR but not amd64 and not x86, we will fall out of this check and not
         // set USE_DISASSEMBLER.
@@ -18,10 +17,6 @@
             #undef USE_COREDISTOOLS_DISASSEMBLER
             #define USE_COREDISTOOLS_DISASSEMBLER 1
         #endif
-    #elif defined(_TARGET_AMD64_) || defined(_TARGET_X86_)
-        #undef USE_MSVC_DISASSEMBLER
-        #define USE_MSVC_DISASSEMBLER 1
-    #endif // defined(FEATURE_CORECLR) || defined(_TARGET_AMD64_) || defined(_TARGET_X86_)
 #endif // HAVE_GCCOVER
 
 #if USE_COREDISTOOLS_DISASSEMBLER
diff --git a/src/vm/dllimport.cpp b/src/vm/dllimport.cpp
index b7989e92bc..9f06e11799 100644
--- a/src/vm/dllimport.cpp
+++ b/src/vm/dllimport.cpp
@@ -50,10 +50,6 @@
 
 #include "eventtrace.h"
 
-#ifndef FEATURE_CORECLR
-#define NEEDDATA
-#include "fxretarget.h"
-#endif
 
 #include "clr/fs/path.h"
 using namespace clr::fs;
@@ -913,7 +909,6 @@ public:
         }
 #endif // MDA_SUPPORTED
 
-#ifdef FEATURE_CORECLR
         // For CoreClr, clear the last error before calling the target that returns last error.
         // There isn't always a way to know the function have failed without checking last error,
         // in particular on Unix.
@@ -921,7 +916,6 @@ public:
         {
             pcsDispatch->EmitCALL(METHOD__STUBHELPERS__CLEAR_LAST_ERROR, 0, 0);
         }
-#endif // FEATURE_CORECLR
 
         // Invoke the target (calli, call method, call delegate, get/set field, etc.)
         EmitInvokeTarget(pStubMD);
@@ -1158,178 +1152,8 @@ public:
         LOG((LF_STUBS, LL_INFO1000, "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n"));
 #endif // LOGGING
         
-#ifndef FEATURE_CORECLR
-        //
-        // Publish ETW events for IL stubs
-        //
-        
-        // If the category and the event is enabled...
-        if (ETW_EVENT_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context, ILStubGenerated))
-        {
-            EtwOnILStubGenerated(
-                pStubMD, 
-                pbLocalSig, 
-                cbSig,
-                jitFlags,
-                &convertToHRTryCatch,
-                &cleanupTryFinally,
-                maxStack,
-                (DWORD)cbCode
-                );
-        }
-#endif // !FEATURE_CORECLR
     }
 
-#ifndef FEATURE_CORECLR
-    //---------------------------------------------------------------------------------------
-    // 
-    void 
-    EtwOnILStubGenerated(
-        MethodDesc *    pStubMD, 
-        PCCOR_SIGNATURE pbLocalSig, 
-        DWORD           cbSig, 
-        CORJIT_FLAGS    jitFlags,
-        ILStubEHClause * pConvertToHRTryCatchBounds,
-        ILStubEHClause * pCleanupTryFinallyBounds,
-        DWORD           maxStack, 
-        DWORD           cbCode)
-    {
-        STANDARD_VM_CONTRACT;
-
-        //
-        // Interop Method Information
-        //
-        MethodDesc *pTargetMD = m_slIL.GetTargetMD();
-        SString strNamespaceOrClassName, strMethodName, strMethodSignature;                
-        UINT64 uModuleId = 0;
-        
-        if (pTargetMD)
-        {
-            pTargetMD->GetMethodInfoWithNewSig(strNamespaceOrClassName, strMethodName, strMethodSignature);
-            uModuleId = (UINT64)pTargetMD->GetModule()->GetAddrModuleID();
-        }
-
-        //
-        // Stub Method Signature
-        //
-        SString stubNamespaceOrClassName, stubMethodName, stubMethodSignature;
-        pStubMD->GetMethodInfoWithNewSig(stubNamespaceOrClassName, stubMethodName, stubMethodSignature);
-        
-        IMDInternalImport *pStubImport = pStubMD->GetModule()->GetMDImport();
-        
-        CQuickBytes qbLocal;
-        PrettyPrintSig(pbLocalSig, (DWORD)cbSig, NULL, &qbLocal,  pStubImport, NULL);
-
-        SString strLocalSig(SString::Utf8, (LPCUTF8)qbLocal.Ptr());
-        
-        //
-        // Native Signature
-        // 
-        SString strNativeSignature(SString::Utf8);
-        if (m_dwStubFlags & NDIRECTSTUB_FL_REVERSE_INTEROP)
-        {
-            // Reverse interop. Use StubSignature
-            strNativeSignature = stubMethodSignature;                
-        }
-        else
-        {
-            // Forward interop. Use StubTarget siganture
-            PCCOR_SIGNATURE pCallTargetSig = GetStubTargetMethodSig();
-            DWORD           cCallTargetSig = GetStubTargetMethodSigLength();
-            
-            CQuickBytes qbCallTargetSig;
-            
-            PrettyPrintSig(pCallTargetSig, cCallTargetSig, "", &qbCallTargetSig,  pStubImport, NULL);
-
-            strNativeSignature.SetUTF8((LPCUTF8)qbCallTargetSig.Ptr());
-        }
-        
-        //
-        // Dump IL stub code       
-        //
-        SString strILStubCode;
-        strILStubCode.Preallocate(4096);    // Preallocate 4K bytes to avoid unnecessary growth
-
-        SString codeSizeFormat;
-        codeSizeFormat.LoadResource(CCompRC::Optional, IDS_EE_INTEROP_CODE_SIZE_COMMENT);
-        strILStubCode.AppendPrintf(W("// %s\t%d (0x%04x)\n"), codeSizeFormat.GetUnicode(), cbCode, cbCode);
-        strILStubCode.AppendPrintf(W(".maxstack %d \n"), maxStack);
-        strILStubCode.AppendPrintf(W(".locals %s\n"), strLocalSig.GetUnicode());
-        
-        m_slIL.LogILStub(jitFlags, &strILStubCode);
-
-        if (pConvertToHRTryCatchBounds->cbTryLength != 0 && pConvertToHRTryCatchBounds->cbHandlerLength != 0)
-        {
-            strILStubCode.AppendPrintf(
-                W(".try IL_%04x to IL_%04x catch handler IL_%04x to IL_%04x\n"), 
-                pConvertToHRTryCatchBounds->dwTryBeginOffset, 
-                pConvertToHRTryCatchBounds->dwTryBeginOffset + pConvertToHRTryCatchBounds->cbTryLength, 
-                pConvertToHRTryCatchBounds->dwHandlerBeginOffset, 
-                pConvertToHRTryCatchBounds->dwHandlerBeginOffset + pConvertToHRTryCatchBounds->cbHandlerLength);
-        }
-
-        if (pCleanupTryFinallyBounds->cbTryLength != 0 && pCleanupTryFinallyBounds->cbHandlerLength != 0)
-        {
-            strILStubCode.AppendPrintf(
-                W(".try IL_%04x to IL_%04x finally handler IL_%04x to IL_%04x\n"), 
-                pCleanupTryFinallyBounds->dwTryBeginOffset, 
-                pCleanupTryFinallyBounds->dwTryBeginOffset + pCleanupTryFinallyBounds->cbTryLength, 
-                pCleanupTryFinallyBounds->dwHandlerBeginOffset, 
-                pCleanupTryFinallyBounds->dwHandlerBeginOffset + pCleanupTryFinallyBounds->cbHandlerLength);
-        }
-
-        //
-        // Fire the event
-        //
-        DWORD dwFlags = 0;
-        if (m_dwStubFlags & NDIRECTSTUB_FL_REVERSE_INTEROP)
-            dwFlags |= ETW_IL_STUB_FLAGS_REVERSE_INTEROP;
-#ifdef FEATURE_COMINTEROP            
-        if (m_dwStubFlags & NDIRECTSTUB_FL_COM)
-            dwFlags |= ETW_IL_STUB_FLAGS_COM_INTEROP;
-#endif // FEATURE_COMINTEROP            
-        if (m_dwStubFlags & NDIRECTSTUB_FL_NGENEDSTUB)
-            dwFlags |= ETW_IL_STUB_FLAGS_NGENED_STUB;
-        if (m_dwStubFlags & NDIRECTSTUB_FL_DELEGATE)
-            dwFlags |= ETW_IL_STUB_FLAGS_DELEGATE;
-        if (m_dwStubFlags & NDIRECTSTUB_FL_CONVSIGASVARARG)
-            dwFlags |= ETW_IL_STUB_FLAGS_VARARG;
-        if (m_dwStubFlags & NDIRECTSTUB_FL_UNMANAGED_CALLI)
-            dwFlags |= ETW_IL_STUB_FLAGS_UNMANAGED_CALLI;
-            
-        DWORD dwToken = 0;
-        if (pTargetMD)
-            dwToken = pTargetMD->GetMemberDef();
-
-
-        //
-        // Truncate string fields. Make sure the whole event is less than 64KB
-        //
-        TruncateUnicodeString(strNamespaceOrClassName, ETW_IL_STUB_EVENT_STRING_FIELD_MAXSIZE);
-        TruncateUnicodeString(strMethodName,           ETW_IL_STUB_EVENT_STRING_FIELD_MAXSIZE);
-        TruncateUnicodeString(strMethodSignature,      ETW_IL_STUB_EVENT_STRING_FIELD_MAXSIZE);
-        TruncateUnicodeString(strNativeSignature,      ETW_IL_STUB_EVENT_STRING_FIELD_MAXSIZE);
-        TruncateUnicodeString(stubMethodSignature,     ETW_IL_STUB_EVENT_STRING_FIELD_MAXSIZE);
-        TruncateUnicodeString(strILStubCode,           ETW_IL_STUB_EVENT_CODE_STRING_FIELD_MAXSIZE);
-        
-        //
-        // Fire ETW event
-        //
-        FireEtwILStubGenerated(
-            GetClrInstanceId(),                         // ClrInstanceId
-            uModuleId,                                  // ModuleIdentifier
-            (UINT64)pStubMD,                            // StubMethodIdentifier
-            dwFlags,                                    // StubFlags                 
-            dwToken,                                    // ManagedInteropMethodToken
-            strNamespaceOrClassName.GetUnicode(),       // ManagedInteropMethodNamespace
-            strMethodName.GetUnicode(),                 // ManagedInteropMethodName
-            strMethodSignature.GetUnicode(),            // ManagedInteropMethodSignature
-            strNativeSignature.GetUnicode(),            // NativeSignature
-            stubMethodSignature.GetUnicode(),           // StubMethodSigature
-            strILStubCode.GetUnicode()                  // StubMethodILCode
-            );            
-    } // EtwOnILStubGenerated
-#endif // !FEATURE_CORECLR
 
 #ifdef LOGGING
     //---------------------------------------------------------------------------------------
@@ -1790,10 +1614,6 @@ NDirectStubLinker::NDirectStubLinker(
     m_dwThreadLocalNum(-1),
     m_dwCleanupWorkListLocalNum(-1),
     m_dwRetValLocalNum(-1),
-#if defined(_TARGET_X86_) && !defined(FEATURE_CORECLR)
-    m_dwFirstCopyCtorCookieLocalNum(-1),
-    m_dwLastCopyCtorCookieLocalNum(-1),
-#endif // _TARGET_X86_ && !FEATURE_CORECLR
     m_ErrorResID(-1),
     m_ErrorParamIdx(-1),
     m_iLCIDParamIdx(iLCIDParamIdx),
@@ -2218,46 +2038,6 @@ void NDirectStubLinker::LoadCleanupWorkList(ILCodeStream* pcsEmit)
     pcsEmit->EmitLDLOCA(GetCleanupWorkListLocalNum());
 }
 
-#if defined(_TARGET_X86_) && !defined(FEATURE_CORECLR)
-
-BOOL NDirectStubLinker::IsCopyCtorStubNeeded()
-{
-    LIMITED_METHOD_CONTRACT;
-    return (m_dwFirstCopyCtorCookieLocalNum != (DWORD)-1);
-}
-
-DWORD NDirectStubLinker::CreateCopyCtorCookie(ILCodeStream* pcsEmit)
-{
-    STANDARD_VM_CONTRACT;
-
-    MethodTable *pCookieMT = MscorlibBinder::GetClass(CLASS__COPYCTORSTUBCOOKIE);
-
-    LocalDesc desc(pCookieMT);
-    DWORD dwCookieLocalNum = pcsEmit->NewLocal(desc);
-
-    // <dwCookieLocalNum> = new CopyCtorStubCookie()
-    pcsEmit->EmitLDLOCA(dwCookieLocalNum);
-    pcsEmit->EmitINITOBJ(pcsEmit->GetToken(pCookieMT));
-
-    if (m_dwLastCopyCtorCookieLocalNum == (DWORD)-1)
-    {
-        // this is the first cookie in this stub
-        m_dwFirstCopyCtorCookieLocalNum = dwCookieLocalNum;
-    }
-    else
-    {
-        // this is not the first cookie - build a linked list
-        // <m_dwLastCopyCtorCookieLocalNum>.SetNext(&<dwCookieLocalNum>)
-        pcsEmit->EmitLDLOCA(m_dwLastCopyCtorCookieLocalNum);
-        pcsEmit->EmitLDLOCA(dwCookieLocalNum);
-        pcsEmit->EmitCALL(METHOD__COPYCTORSTUBCOOKIE__SET_NEXT, 2, 0);
-    }
-
-    m_dwLastCopyCtorCookieLocalNum = dwCookieLocalNum;
-    return dwCookieLocalNum;
-}
-
-#endif // _TARGET_X86_ && !FEATURE_CORECLR
 
 void NDirectStubLinker::Begin(DWORD dwStubFlags)
 {
@@ -2292,23 +2072,6 @@ void NDirectStubLinker::Begin(DWORD dwStubFlags)
 
     if (SF_IsForwardStub(dwStubFlags))
     {
-#ifndef FEATURE_CORECLR // CAS
-        // we may need to demand security permission
-        if (SF_IsStubWithDemand(dwStubFlags))
-        {
-            if (SF_IsCOMStub(dwStubFlags) || SF_IsDelegateStub(dwStubFlags))
-            {
-                // pass NULL NDirectMethodDesc for COM and delegate P/Invoke
-                m_pcsSetup->EmitLoadNullPtr();
-            }
-            else
-            {
-                // pass the real MD for direct P/Invoke
-                EmitLoadStubContext(m_pcsSetup, dwStubFlags);
-            }
-            m_pcsSetup->EmitCALL(METHOD__STUBHELPERS__DEMAND_PERMISSION, 1, 0);
-        }
-#endif // !FEATURE_CORECLR
 
         if (SF_IsStubWithCctorTrigger(dwStubFlags))
         {
@@ -2327,7 +2090,7 @@ void NDirectStubLinker::Begin(DWORD dwStubFlags)
 
         if (SF_IsDelegateStub(dwStubFlags))
         {
-#if defined(MDA_SUPPORTED) || (defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR))
+#if defined(MDA_SUPPORTED)
             // GC was induced (gcUnmanagedToManagedMDA), arguments have been marshaled, and we are about
             // to touch the UMEntryThunk and extract the delegate target from it so this is the right time
             // to do the collected delegate MDA check.
@@ -2469,38 +2232,6 @@ void NDirectStubLinker::DoNDirect(ILCodeStream *pcsEmit, DWORD dwStubFlags, Meth
     STANDARD_VM_CONTRACT;
     if (SF_IsForwardStub(dwStubFlags)) // managed-to-native
     {
-#if defined(_TARGET_X86_) && !defined(FEATURE_CORECLR)
-        // set the copy ctor cookie chain if needed
-        if (IsCopyCtorStubNeeded())
-        {
-            // StubHelpers.SetCopyCtorCookieChain(pStubArg, pUnmngThis, dwStubFlags, &<m_dwFirstCopyCtorCookieLocalNum>)
-            if (SF_IsDelegateStub(dwStubFlags))
-            {
-                // for forward delegate P/Invoke load the target from 'this'
-                pcsEmit->EmitLoadThis();
-                pcsEmit->EmitLDFLD(pcsEmit->GetToken(MscorlibBinder::GetField(FIELD__DELEGATE__METHOD_PTR_AUX)));
-            }
-            else
-            {
-                // otherwise load the secret argument
-                EmitLoadStubContext(pcsEmit, dwStubFlags);
-            }
-
-            if (SF_IsCOMStub(dwStubFlags))
-            {
-                // for forward COM load the unmanaged interface pointer
-                pcsEmit->EmitLDLOC(m_dwTargetInterfacePointerLocalNum);
-            }
-            else
-            {
-                // otherwise load 0
-                pcsEmit->EmitLoadNullPtr();
-            }
-            pcsEmit->EmitLDC(dwStubFlags);
-            pcsEmit->EmitLDLOCA(m_dwFirstCopyCtorCookieLocalNum);
-            pcsEmit->EmitCALL(METHOD__STUBHELPERS__SET_COPY_CTOR_COOKIE_CHAIN, 4, 0);
-        }
-#endif // _TARGET_X86_ && !FEATURE_CORECLR
 
         if (SF_IsDelegateStub(dwStubFlags)) // delegate invocation
         {
@@ -2529,15 +2260,6 @@ void NDirectStubLinker::DoNDirect(ILCodeStream *pcsEmit, DWORD dwStubFlags, Meth
 
 #ifdef _TARGET_X86_
 
-#ifndef FEATURE_CORECLR
-                if (IsCopyCtorStubNeeded())
-                {
-                    // if we need to call copy ctor(s), we go to the copy ctor stub
-                    Stub *pCopyCtorStub = NDirect::GetStubForCopyCtor();
-                    pcsEmit->EmitLDC((DWORD_PTR)pCopyCtorStub->GetEntryPoint());
-                }
-                else
-#endif // !FEATURE_CORECLR
                 {
                     // for managed-to-unmanaged CALLI that requires marshaling, the target is passed
                     // as the secret argument to the stub by GenericPInvokeCalliHelper (asmhelpers.asm)
@@ -4217,16 +3939,6 @@ static void CreateNDirectStubWorker(StubState*         pss,
         fMarshalReturnValueFirst = HasRetBuffArg(&msig);
 #endif
 
-#if defined(_TARGET_AMD64_) && defined(_WIN64) && !defined(FEATURE_CORECLR)
-        // JIT64 (which is only used on the Windows Desktop CLR) has a problem generating code
-        // for the pinvoke ILStubs which do a return using a struct type.  Therefore, we
-        // change the signature of calli to return void and make the return buffer as first argument. 
-        // This matches the ABI i.e. return buffer is passed as first arg. So native target will get
-        // the return buffer in correct register.
-        // Ideally we only want to set it for JIT64 and not ryujit but currently there isn't a fast way 
-        // to determine that at runtime.
-        fMarshalReturnValueFirst = HasRetBuffArg(&msig);
-#endif
     }
     
     if (fMarshalReturnValueFirst)
@@ -4388,12 +4100,6 @@ static void CreateNDirectStubWorker(StubState*         pss,
                     COMPlusThrow(kMarshalDirectiveException, IDS_EE_NDIRECT_BADNATL_THISCALL);
             }
 
-#ifndef FEATURE_CORECLR
-            if (info.GetMarshalType() == MarshalInfo::MARSHAL_TYPE_BLITTABLEVALUECLASSWITHCOPYCTOR)
-            {
-                fHasCopyCtorArgs = true;
-            }
-#endif // !FEATURE_CORECLR
 
             argidx++;
         }
@@ -6206,15 +5912,6 @@ VOID NDirectMethodDesc::SetNDirectTarget(LPVOID pTarget)
 
 #ifdef _TARGET_X86_
 
-#ifndef FEATURE_CORECLR
-    if (HasCopyCtorArgs())
-    {
-        _ASSERTE(pInterceptStub == NULL);
-
-        // static stub that gets its arguments in a thread-static field
-        pInterceptStub = NDirect::GetStubForCopyCtor();
-    }
-#endif // !FEATURE_CORECLR
 
 #ifdef MDA_SUPPORTED
     if (!IsQCall() && MDA_GET_ASSISTANT(PInvokeStackImbalance))
@@ -6263,39 +5960,6 @@ VOID NDirectMethodDesc::SetNDirectTarget(LPVOID pTarget)
     }
 }
 
-#if defined(_TARGET_X86_) && !defined(FEATURE_CORECLR)
-
-// Returns a small stub whose purpose is to record current ESP and call code:CopyCtorCallStubWorker
-// to invoke copy constructors and destructors as appropriate. This stub operates on arguments
-// already pushed to the stack by JITted IL stub and must not create a new frame, i.e. it must
-// tail call to the target for it to see the arguments that copy ctors have been called on.
-//
-// As a consequence, the stub doesn't take any extra secret arguments and the description of the
-// ctors/dtors to call is passed "out-of-band" in a thread static field. The worker returns
-// address of the real target (also passed out of band) which enables us to have only one static
-// stub in i386\asmhelpers.asm.
-
-// static
-Stub *NDirect::GetStubForCopyCtor()
-{
-    STANDARD_VM_CONTRACT;
-
-    static Stub *s_pStub = NULL;
-
-    if (s_pStub == NULL)
-    {
-        Stub *pStub = Stub::NewStub(GetEEFuncEntryPoint(CopyCtorCallStub));
-        if (InterlockedCompareExchangeT(&s_pStub, pStub, NULL) != NULL)
-        {
-            pStub->DecRef();
-        }
-    }
-
-    s_pStub->IncRef();
-    return s_pStub;
-}
-
-#endif // _TARGET_X86_ && !FEATURE_CORECLR
 
 #ifdef FEATURE_INCLUDE_ALL_INTERFACES
 BOOL NDirect::IsHostHookEnabled()
@@ -6354,147 +6018,6 @@ EXTERN_C VOID __stdcall PInvokeStackImbalanceWorker(StackImbalanceCookie *pSICoo
 }
 #endif // _TARGET_X86_ && MDA_SUPPORTED
 
-#if defined(_TARGET_X86_) && !defined(FEATURE_CORECLR)
-struct CopyCtorStubCookie // same layout as StubHelpers.CopyCtorStubCookie
-{
-    LPVOID m_srcInstancePtr;
-    DWORD  m_dstStackOffset;
-    LPVOID m_ctorPtr; // managed method ptr
-    LPVOID m_dtorPtr; // managed method ptr
-
-    CopyCtorStubCookie *m_pNext;
-};
-
-struct CopyCtorStubDesc // same layout as StubHelpers.CopyCtorStubDesc
-{
-    CopyCtorStubCookie *m_pCookie;
-    LPVOID m_pTarget;
-};
-
-// Called by CopyCtorCallStub after we have already transitioned to unmanaged. Invokes copy ctor(s)
-// and dtor(s) using reverse P/Invoke which has some perf impact but provides all the debugging and
-// profiling support. An alternative solution would be CallDescr or some optimized variant of it
-// which would probably result in confusing call stacks.
-EXTERN_C LPVOID __stdcall CopyCtorCallStubWorker(BYTE *pESP)
-{
-    STATIC_CONTRACT_THROWS;
-    STATIC_CONTRACT_GC_TRIGGERS;
-    STATIC_CONTRACT_MODE_PREEMPTIVE; // we've already switched to preemptive
-
-    CopyCtorStubCookie *pCookie;
-    LPVOID pTarget;
-    {
-        GCX_COOP();
-        // get address of the thread-static field
-        FieldDesc *pFD = MscorlibBinder::GetField(FIELD__STUBHELPERS__COPY_CTOR_STUB_DESC);
-
-        CopyCtorStubDesc *pStubDesc = (CopyCtorStubDesc *)Thread::GetStaticFieldAddress(pFD);
-
-        // read the fields in cooperative mode
-        pCookie = pStubDesc->m_pCookie;
-        pTarget = pStubDesc->m_pTarget;
-
-        _ASSERTE(pCookie != NULL && pTarget != NULL);
-
-        // make sure we ASSERT/AV reliably if we are called by mistake
-        pStubDesc->m_pCookie = NULL;
-        pStubDesc->m_pTarget = NULL;
-    }
-
-    while (pCookie != NULL)
-    {
-        if (pCookie->m_ctorPtr != NULL)
-        {
-            // get reverse P/Invoke to the copy ctor (cache on AD)
-            MethodDesc *pMD = Entry2MethodDesc((PCODE)pCookie->m_ctorPtr, NULL);
-            UMEntryThunk *pUMEntryThunk = GetAppDomain()->GetUMEntryThunkCache()->GetUMEntryThunk(pMD);
-
-            // GetUMEntryThunk always returns stdcall-able function pointers for ordinary managed methods
-            // but the ctor can be a P/Invoke (pre-Whidbey MC++ only)
-            typedef void (__stdcall  *CtorFnPtr_StdCall) (LPVOID dst, LPVOID src);
-            typedef void (__thiscall *CtorFnPtr_ThisCall)(LPVOID dst, LPVOID src);
-            typedef void (__cdecl    *CtorFnPtr_Cdecl)   (LPVOID dst, LPVOID src);
-
-            // call the copy ctor using the right calling convention
-            UMThunkMarshInfo *pMarshInfo = pUMEntryThunk->GetUMThunkMarshInfo();
-            pMarshInfo->RunTimeInit();
-
-            switch (pMarshInfo->GetCallingConvention() & pmCallConvMask)
-            {
-                case pmCallConvStdcall:
-                case pmCallConvWinapi:
-                {
-                    CtorFnPtr_StdCall fnPtr = (CtorFnPtr_StdCall)pUMEntryThunk->GetCode();
-                    fnPtr(pESP + pCookie->m_dstStackOffset, pCookie->m_srcInstancePtr);
-                    break;
-                }
-
-                case pmCallConvThiscall:
-                {
-                    CtorFnPtr_ThisCall fnPtr = (CtorFnPtr_ThisCall)pUMEntryThunk->GetCode();
-                    fnPtr(pESP + pCookie->m_dstStackOffset, pCookie->m_srcInstancePtr);
-                    break;
-                }
-
-                default:
-                {
-                    _ASSERTE((pMarshInfo->GetCallingConvention() & pmCallConvMask) == pmCallConvCdecl);
-
-                    CtorFnPtr_Cdecl fnPtr = (CtorFnPtr_Cdecl)pUMEntryThunk->GetCode();
-                    fnPtr(pESP + pCookie->m_dstStackOffset, pCookie->m_srcInstancePtr);
-                    break;
-                }
-            }
-        }
-        if (pCookie->m_dtorPtr != NULL)
-        {
-            // get reverse P/Invoke to the dtor (cache on AD)
-            MethodDesc *pMD = Entry2MethodDesc((PCODE)pCookie->m_dtorPtr, NULL);
-            UMEntryThunk *pUMEntryThunk = GetAppDomain()->GetUMEntryThunkCache()->GetUMEntryThunk(pMD);
-
-            // GetUMEntryThunk always returns stdcall-able function pointers for ordinary managed methods
-            // but the dtor can be a P/Invoke (pre-Whidbey MC++ only)
-            typedef void (__stdcall  *DtorFnPtr_StdCall) (LPVOID src);
-            typedef void (__thiscall *DtorFnPtr_ThisCall)(LPVOID src);
-            typedef void (__cdecl    *DtorFnPtr_Cdecl)   (LPVOID src);
-
-            // call the dtor using the right calling convention
-            UMThunkMarshInfo *pMarshInfo = pUMEntryThunk->GetUMThunkMarshInfo();
-            pMarshInfo->RunTimeInit();
-
-            switch (pMarshInfo->GetCallingConvention() & pmCallConvMask)
-            {
-                case pmCallConvStdcall:
-                case pmCallConvWinapi:
-                {
-                    DtorFnPtr_StdCall fnPtr = (DtorFnPtr_StdCall)pUMEntryThunk->GetCode();
-                    fnPtr(pCookie->m_srcInstancePtr);
-                    break;
-                }
-
-                case pmCallConvThiscall:
-                {
-                    DtorFnPtr_ThisCall fnPtr = (DtorFnPtr_ThisCall)pUMEntryThunk->GetCode();
-                    fnPtr(pCookie->m_srcInstancePtr);
-                    break;
-                }
-
-                default:
-                {
-                    _ASSERTE((pMarshInfo->GetCallingConvention() & pmCallConvMask) == pmCallConvCdecl);
-
-                    DtorFnPtr_Cdecl fnPtr = (DtorFnPtr_Cdecl)pUMEntryThunk->GetCode();
-                    fnPtr(pCookie->m_srcInstancePtr);
-                    break;
-                }
-            }
-        }
-        pCookie = pCookie->m_pNext;
-    }
-
-    return pTarget;
-}
-#endif // _TARGET_X86_ && !FEATURE_CORECLR
 
 // Preserving good error info from DllImport-driven LoadLibrary is tricky because we keep loading from different places
 // if earlier loads fail and those later loads obliterate error codes.
@@ -6721,79 +6244,6 @@ HINSTANCE NDirect::CheckForWellKnownModules(LPCWSTR wszLibName, LoadLibErrorTrac
 #define TOLOWER(a) (((a) >= W('A') && (a) <= W('Z')) ? (W('a') + (a - W('A'))) : (a))
 #define TOHEX(a)   ((a)>=10 ? W('a')+(a)-10 : W('0')+(a))
 
-#ifndef FEATURE_CORECLR
-/*static*/
-VOID NDirect::CheckUnificationList(NDirectMethodDesc * pMD, DWORD * pDllImportSearchPathFlag, BOOL * pSearchAssemblyDirectory)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    // If neither assembly and method have the attribute, check the unification list.
-    Assembly *pAssembly = pMD->GetAssembly();
-
-    if (!pAssembly->IsStrongNamed())
-        return;
-    
-    const char * simpleName = pAssembly->GetSimpleName();
-        
-    StringHashIterator(it, g_arFxPolicy, simpleName);
-
-    int pos;
-
-    while ((pos = it.GetNext()) >= 0) 
-    {
-        const FrameworkConfig & config = g_arFxPolicy[pos];
-
-        FixedSizeString<char> asmName;
-            
-        config.GetFxAssemblyName(asmName);
-
-        if (_stricmp(asmName, simpleName) == 0)
-        {
-            DWORD cbPublicKey = 0;
-            const void *pbPublicKey = NULL;
-            pbPublicKey = pAssembly->GetPublicKey(&cbPublicKey);
-
-            //
-            // StrongNameTokenFromPublicKey is potentially expensive operation. Do it only once we got a match on the simple name.
-            //
-            StrongNameBufferHolder<BYTE> pbStrongNameToken;
-            DWORD cbStrongNameToken;
-            
-            if (StrongNameTokenFromPublicKey((BYTE*) pbPublicKey,cbPublicKey,&pbStrongNameToken,&cbStrongNameToken))
-            {
-                BOOL pktIsEqual = TRUE;
-
-                LPCWSTR pwzPKT = config.GetPKT();
-
-                for (UINT j = 0; j < cbStrongNameToken; j++)
-                {
-                    WCHAR firstChar = TOHEX(pbStrongNameToken[j] / 16);
-                    WCHAR secondChar = TOHEX(pbStrongNameToken[j] % 16);
-                    
-                    if (firstChar != TOLOWER(pwzPKT[j*2]) || secondChar != TOLOWER(pwzPKT[j*2+1]))
-                    {
-                        pktIsEqual = FALSE;
-                        break;
-                    }
-                }
-
-                if (pktIsEqual)
-                { 
-                    *pDllImportSearchPathFlag = LOAD_LIBRARY_SEARCH_DEFAULT_DIRS; 
-                    *pSearchAssemblyDirectory = TRUE;
-                    break;
-                }
-            }
-        }
-    }
-}
-#endif // !FEATURE_CORECLR
 
 // static
 HMODULE NDirect::LoadLibraryFromPath(LPCWSTR libraryPath)
@@ -6811,7 +6261,6 @@ HMODULE NDirect::LoadLibraryFromPath(LPCWSTR libraryPath)
     return systemModuleHandle;
 }
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 /* static */
 HMODULE NDirect::LoadLibraryModuleViaHost(NDirectMethodDesc * pMD, AppDomain* pDomain, const wchar_t* wszLibName)
 {
@@ -6913,7 +6362,6 @@ HMODULE NDirect::LoadLibraryModuleViaHost(NDirectMethodDesc * pMD, AppDomain* pD
 
     return (HMODULE)hmod;
 }
-#endif //defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
 // Try to load the module alongside the assembly where the PInvoke was declared.
 HMODULE NDirect::LoadFromPInvokeAssemblyDirectory(Assembly *pAssembly, LPCWSTR libName, DWORD flags, LoadLibErrorTracker *pErrorTracker)
@@ -6937,7 +6385,6 @@ HMODULE NDirect::LoadFromPInvokeAssemblyDirectory(Assembly *pAssembly, LPCWSTR l
     return hmod;
 }
 
-#ifdef FEATURE_CORECLR
 // Try to load the module from the native DLL search directories
 HMODULE NDirect::LoadFromNativeDllSearchDirectories(AppDomain* pDomain, LPCWSTR libName, DWORD flags, LoadLibErrorTracker *pErrorTracker)
 {
@@ -6961,7 +6408,6 @@ HMODULE NDirect::LoadFromNativeDllSearchDirectories(AppDomain* pDomain, LPCWSTR
 
     return hmod;
 }
-#endif // FEATURE_CORECLR
 
 HINSTANCE NDirect::LoadLibraryModule(NDirectMethodDesc * pMD, LoadLibErrorTracker * pErrorTracker)
 {
@@ -6985,7 +6431,6 @@ HINSTANCE NDirect::LoadLibraryModule(NDirectMethodDesc * pMD, LoadLibErrorTracke
 
     AppDomain* pDomain = GetAppDomain();
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
     // AssemblyLoadContext is not supported in AppX mode and thus,
     // we should not perform PInvoke resolution via it when operating in
     // AppX mode.
@@ -6993,7 +6438,6 @@ HINSTANCE NDirect::LoadLibraryModule(NDirectMethodDesc * pMD, LoadLibErrorTracke
     {
         hmod = LoadLibraryModuleViaHost(pMD, pDomain, wszLibName);
     }
-#endif  //FEATURE_HOST_ASSEMBLY_RESOLVER
     
     
     if(hmod == NULL)
@@ -7032,13 +6476,11 @@ HINSTANCE NDirect::LoadLibraryModule(NDirectMethodDesc * pMD, LoadLibErrorTracke
     }
 #endif // FEATURE_CORESYSTEM && !FEATURE_PAL
 
-#ifdef FEATURE_CORECLR
     if (hmod == NULL)
     {
         // NATIVE_DLL_SEARCH_DIRECTORIES set by host is considered well known path 
         hmod = LoadFromNativeDllSearchDirectories(pDomain, wszLibName, loadWithAlteredPathFlags, pErrorTracker);
     }
-#endif // FEATURE_CORECLR   
 
     DWORD dllImportSearchPathFlag = 0;
     BOOL searchAssemblyDirectory = TRUE;
@@ -7069,12 +6511,6 @@ HINSTANCE NDirect::LoadLibraryModule(NDirectMethodDesc * pMD, LoadLibErrorTracke
             }
         }
 
-#ifndef FEATURE_CORECLR
-        if (!attributeIsFound)
-        {
-            CheckUnificationList(pMD, &dllImportSearchPathFlag, &searchAssemblyDirectory);
-        }
-#endif
 
         if (!libNameIsRelativePath)
         {
@@ -7093,68 +6529,6 @@ HINSTANCE NDirect::LoadLibraryModule(NDirectMethodDesc * pMD, LoadLibErrorTracke
             Assembly* pAssembly = pMD->GetMethodTable()->GetAssembly();
             hmod = LoadFromPInvokeAssemblyDirectory(pAssembly, wszLibName, loadWithAlteredPathFlags | dllImportSearchPathFlag, pErrorTracker);
 
-#ifndef FEATURE_CORECLR
-            if (hmod == NULL)
-            {
-                // Try to load the DLL alongside the assembly where the PInvoke was 
-                // declared using the codebase of the assembly. This is required for download
-                // and shadow copy scenarios.
-                const WCHAR* ptr;
-                SString codebase;
-                pAssembly->GetCodeBase(codebase);
-                DWORD dwCodebaseLength = codebase.GetCount();
-
-                // Strip off the protocol
-                for (ptr = codebase.GetUnicode(); *ptr && *ptr != W(':'); ptr++);
-
-                // If we have a code base then prepend it to the library name
-                if (*ptr) 
-                {
-                    SString pathFromCodebase;
-
-                    // After finding the colon move forward until no more forward slashes
-                    for (ptr++; *ptr && *ptr == W('/'); ptr++);
-                    if (*ptr) 
-                    {
-                        // Calculate the number of characters we are interested in
-                        if (dwCodebaseLength > (DWORD)(ptr - codebase.GetUnicode()) )
-                        {
-                            // Back up to the last slash (forward or backwards)
-                            const WCHAR* tail;
-
-                            for (tail = codebase.GetUnicode() + (dwCodebaseLength - 1); tail > ptr && *tail != W('/') && *tail != W('\\'); tail--);
-
-                            if (tail > ptr) 
-                            {
-                                for (;ptr <= tail; ptr++) 
-                                {
-                                    if (*ptr == W('/')) 
-                                        pathFromCodebase.Append(W('\\'));
-                                    else
-                                        pathFromCodebase.Append(*ptr);
-                                }
-                            }
-                        }
-                    }
-
-                    pathFromCodebase.Append(wszLibName);
-
-                    SString path = pAssembly->GetManifestFile()->GetPath();
-                    SString::Iterator i = path.End();
-                    if (PEAssembly::FindLastPathSeparator(path, i))
-                    {
-                        i++;
-                        path.Truncate(i);
-                        path.Append(wszLibName);
-                    }
-
-                    if (!pathFromCodebase.EqualsCaseInsensitive(path, PEImage::GetFileSystemLocale()))
-                    {
-                        hmod = LocalLoadLibraryHelper(pathFromCodebase, loadWithAlteredPathFlags | dllImportSearchPathFlag, pErrorTracker);
-                    }
-                }
-            }
-#endif // !FEATURE_CORECLR
         }
     }
 
@@ -7353,25 +6727,6 @@ VOID NDirect::NDirectLink(NDirectMethodDesc *pMD)
     }
     CONTRACTL_END;
 
-#if !defined(FEATURE_CORECLR)
-    // Generate a table of some well known native dlls
-    s_pWellKnownNativeModules = ::new PtrHashMap();
-    s_pWellKnownNativeModules->Init(sizeof(wellKnownModules)/sizeof(LPCWSTR), CompareLibNames, TRUE, NULL);
-    for (int index = 0; index < sizeof(wellKnownModules)/sizeof(LPCWSTR); index++)
-    {
-        s_pWellKnownNativeModules->InsertValue((UPTR) HashiString(wellKnownModules[index]), (LPVOID)wellKnownModules[index]);
-    }
-
-    // Check if the OS supports the new secure LoadLibraryEx flags introduced in KB2533623
-    HMODULE hMod = CLRGetModuleHandle(WINDOWS_KERNEL32_DLLNAME_W);
-    _ASSERTE(hMod != NULL);
-
-    if (GetProcAddress(hMod, "AddDllDirectory") != NULL)
-    {
-        // The AddDllDirectory export was added in KB2533623 together with the new flag support
-        s_fSecureLoadLibrarySupported = true;
-    }
-#endif // !FEATURE_CORECLR
 }
 
 
diff --git a/src/vm/dllimport.h b/src/vm/dllimport.h
index b393bf6cdd..b08b845625 100644
--- a/src/vm/dllimport.h
+++ b/src/vm/dllimport.h
@@ -80,9 +80,6 @@ public:
     static HMODULE LoadLibraryFromPath(LPCWSTR libraryPath);
     static HINSTANCE LoadLibraryModule(NDirectMethodDesc * pMD, LoadLibErrorTracker *pErrorTracker);
 
-#ifndef FEATURE_CORECLR
-    static VOID CheckUnificationList(NDirectMethodDesc * pMD, DWORD * pDllImportSearchPathFlag, BOOL * pSearchAssemblyDirectory);
-#endif // !FEATURE_CORECLR
 
     static VOID NDirectLink(NDirectMethodDesc *pMD);
 
@@ -121,9 +118,6 @@ public:
 
     inline static ILStubCache*     GetILStubCache(NDirectStubParameters* pParams);
 
-#if defined(_TARGET_X86_) && !defined(FEATURE_CORECLR)
-    static Stub*            GetStubForCopyCtor();
-#endif // _TARGET_X86_ && !FEATURE_CORECLR
 
     static BOOL IsHostHookEnabled();
 
@@ -132,14 +126,10 @@ public:
 private:
     NDirect() {LIMITED_METHOD_CONTRACT;};     // prevent "new"'s on this class
 
-#ifdef FEATURE_CORECLR
     static HMODULE LoadFromNativeDllSearchDirectories(AppDomain* pDomain, LPCWSTR libName, DWORD flags, LoadLibErrorTracker *pErrorTracker);
-#endif
     static HMODULE LoadFromPInvokeAssemblyDirectory(Assembly *pAssembly, LPCWSTR libName, DWORD flags, LoadLibErrorTracker *pErrorTracker);
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
     static HMODULE LoadLibraryModuleViaHost(NDirectMethodDesc * pMD, AppDomain* pDomain, const wchar_t* wszLibName);
-#endif //defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
 #if !defined(FEATURE_CORESYSTEM)
     static HINSTANCE    CheckForWellKnownModules(LPCWSTR wszLibName, LoadLibErrorTracker *pErrorTracker);
@@ -507,9 +497,6 @@ public:
     void    GetCleanupFinallyOffsets(ILStubEHClause * pClause);
     void    AdjustTargetStackDeltaForReverseInteropHRESULTSwapping();
     void    AdjustTargetStackDeltaForExtraParam();
-#if defined(_TARGET_X86_) && !defined(FEATURE_CORECLR)
-    DWORD   CreateCopyCtorCookie(ILCodeStream* pcsEmit);
-#endif // _TARGET_X86_ && !FEATURE_CORECLR
 
     void    SetInteropParamExceptionInfo(UINT resID, UINT paramIdx);
     bool    HasInteropParamExceptionInfo();
@@ -549,9 +536,6 @@ protected:
     void            InitCleanupCode();
     void            InitExceptionCleanupCode();
 
-#if defined(_TARGET_X86_) && !defined(FEATURE_CORECLR)
-    BOOL            IsCopyCtorStubNeeded();
-#endif // _TARGET_X86_ && !FEATURE_CORECLR
 
 
     ILCodeStream*   m_pcsSetup;
@@ -583,10 +567,6 @@ protected:
     DWORD               m_dwCleanupWorkListLocalNum;
     DWORD               m_dwRetValLocalNum;
     
-#if defined(_TARGET_X86_) && !defined(FEATURE_CORECLR)
-    DWORD               m_dwFirstCopyCtorCookieLocalNum;    // list head passed to SetCopyCtorCookieChain
-    DWORD               m_dwLastCopyCtorCookieLocalNum;     // used for chaining the cookies into a linked list
-#endif // _TARGET_X86_ && !FEATURE_CORECLR
 
     UINT                m_ErrorResID;
     UINT                m_ErrorParamIdx;
diff --git a/src/vm/domainfile.cpp b/src/vm/domainfile.cpp
index bfb69cdd48..c50c3c4d86 100644
--- a/src/vm/domainfile.cpp
+++ b/src/vm/domainfile.cpp
@@ -33,9 +33,6 @@
 #include "umthunkhash.h"
 #include "peimagelayout.inl"
 
-#if !defined(FEATURE_CORECLR) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
-#include "policy.h" // for fusion::util::isanyframeworkassembly
-#endif
 #include "winrthelpers.h"
 
 #ifdef FEATURE_PERFMAP
@@ -743,7 +740,6 @@ void DomainFile::VerifyNativeImageDependencies(bool verifyOnly)
         if (pDependency->signNativeImage == INVALID_NGEN_SIGNATURE)
             continue;
 
-#ifdef FEATURE_CORECLR // hardbinding
 
         //
         // CoreCLR hard binds to mscorlib.dll only. Avoid going through the full load.
@@ -759,51 +755,6 @@ void DomainFile::VerifyNativeImageDependencies(bool verifyOnly)
 
         PEAssembly * pDependencyFile = SystemDomain::SystemFile();
  
-#else // FEATURE_CORECLR
-
-        //
-        // Load the manifest file for the given name assembly spec.
-        //
-
-        AssemblySpec name;
-        name.InitializeSpec(pDependency->dwAssemblyRef,
-                            ((pManifestNativeImage != NULL) ? pManifestNativeImage : pNativeImage)->GetNativeMDImport(),
-                            GetDomainAssembly());
-
-        if (this->GetAppDomain()->IsCompilationDomain())
-        {
-            //
-            // Allow transitive closure of hardbound dependecies to be loaded during ngen.
-            //
-
-            DomainAssembly * pDependencyAssembly = name.LoadDomainAssembly(FILE_LOAD_FIND_NATIVE_IMAGE);
-            pDependencyAssembly->GetFile()->SetSafeToHardBindTo();
-        }
-
-        DomainAssembly * pDependencyAssembly = NULL;
-        {
-            // We are about to validate the hard-bound dependencies of the assembly being loaded. The invariant of being hard-bound states
-            // that each hard-bound dependency must have its NI image to be valid and available for loading and this is done recursively for each
-            // hard-bound dependency.
-            //
-            // The validity (and presence) of the NI image happens in FILE_LOAD_ALLOCATE stage of assembly load, which is the next stage in assembly loading,
-            // and not the current stage (FILE_LOAD_VERIFY_NATIVE_DEPENDENCIES). In FILE_LOAD_ALLOCATE, we do sharing checks, closure validation, redirection policy application, etc
-            // before computing if a NI is available and if it is, whether it is valid or not.
-            //
-            // However, we need to know about validity of NI in the current(and earlier) stage. As a result, we will temporarily set the assembly load limit (defined as the maximum
-            // load level till which recursive assembly load can execute) to be FILE_LOAD_ALLOCATE if we have been invoked to validate the NI dependencies for the first time. 
-            //
-            // A valid concern at this point is that we would allow to load a dependency at a load stage higher than its dependent assembly as it could crete cycles. This concern is
-            // alleviated since we are doing this override (of the load stage) only for hard-bound dependencies and NGEN is responsible for ensuring that there are no cycles.
-            //
-            // As a result, once the dependency load returns, we will know for sure if the dependency has a valid NI or not. 
-            OVERRIDE_LOAD_LEVEL_LIMIT(verifyOnly ? FILE_LOADED : FILE_LOAD_ALLOCATE);
-            pDependencyAssembly = name.LoadDomainAssembly(FILE_LOADED);
-        }
-
-        PEAssembly * pDependencyFile = pDependencyAssembly->GetFile();
-
-#endif // FEATURE_CORECLR
 
         ReleaseHolder<PEImage> pDependencyNativeImage = pDependencyFile->GetNativeImageWithRef();
         if (pDependencyNativeImage == NULL)
@@ -815,7 +766,6 @@ void DomainFile::VerifyNativeImageDependencies(bool verifyOnly)
             goto NativeImageRejected;
         }
 
-#ifndef FEATURE_FUSION // Fusion does this verification at native binding time.
         PTR_PEImageLayout pDependencyNativeLayout = pDependencyNativeImage->GetLoadedLayout();
         // Assert that the native image signature is as expected
         // Fusion will ensure this
@@ -825,7 +775,6 @@ void DomainFile::VerifyNativeImageDependencies(bool verifyOnly)
         LoggablePEAssembly logAsm(pDependencyFile);
         if (!RuntimeVerifyNativeImageDependency(pDependency, pDependencyNativeVersion, &logAsm))
             goto NativeImageRejected;
-#endif
     }
     LOG((LF_ZAP, LL_INFO100, "ZAP: Native image dependencies for %S OK.\n",
             pNativeImage->GetPath().GetUnicode()));
@@ -1175,52 +1124,9 @@ void DomainFile::AddDependencies()
 
 #ifdef FEATURE_PREJIT
 
-#ifdef FEATURE_CORECLR // hardbinding
     //
     // CoreCLR hard binds to mscorlib.dll only. No need to track hardbound dependencies.
     //
-#else
-    // Add hard bindings as unconditional dependencies
-    if (GetFile()->HasNativeImage() && GetCurrentModule()->HasNativeImage() && IsAssembly())
-    {
-        PEImage *pNativeImage = GetFile()->GetPersistentNativeImage();
-        PEImageLayout *pNativeLayout = pNativeImage->GetLoadedLayout();
-
-        COUNT_T cDependencies;
-        CORCOMPILE_DEPENDENCY *pDependencies = pNativeLayout->GetNativeDependencies(&cDependencies);
-        CORCOMPILE_DEPENDENCY *pDependenciesEnd = pDependencies + cDependencies;
-
-        while (pDependencies < pDependenciesEnd)
-        {
-            if (pDependencies->signNativeImage != INVALID_NGEN_SIGNATURE)
-            {
-
-                //
-                // Load the manifest file for the given name assembly spec.
-                //
-
-                AssemblySpec name;
-                name.InitializeSpec(pDependencies->dwAssemblyRef,
-                                    pNativeImage->GetNativeMDImport(),
-                                    GetDomainAssembly());
-
-                DomainAssembly *pDependency = name.LoadDomainAssembly(FILE_LOADED);
-
-                // Right now we only support hard binding to other manifest modules so we don't
-                // need to consider the other module cases
-                Module *pModule = pDependency->GetModule();
-
-                // Add hard binding as an unconditional active dependency
-                STRESS_LOG4(LF_CODESHARING,LL_INFO100,"unconditional dependency %p %p %i %i\n",
-                    GetFile(),GetCurrentModule(),GetFile()->HasNativeImage(),GetCurrentModule()->HasNativeImage());
-                if(!pModule->IsSystem())
-                    GetCurrentModule()->AddActiveDependency(pModule, TRUE);
-            }
-
-            pDependencies++;
-        }
-    }
-#endif // FEATURE_CORECLR
 
 #endif // FEATURE_PREJIT
 }
@@ -1282,27 +1188,6 @@ void DomainFile::FinishLoad()
 
     if (m_pFile->HasNativeImage())
     {
-#ifdef FEATURE_FUSION
-        // <REVISIT_TODO>Because of bug 112034, we may commit to a native image even though
-        // we should not have.</REVISIT_TODO>
-
-// #ifdef _DEBUG
-
-        // Verify that the native image dependencies are still valid
-        // Since we had already committed to using a native image, they cannot
-        // be invalidated
-        VerifyNativeImageDependencies(true);
-        _ASSERTE(m_pFile->HasNativeImage());
-
-        if (!m_pFile->HasNativeImage())
-        {
-            STRESS_LOG1(LF_CODESHARING, LL_FATALERROR, "Incorrectly committed to using native image for %S",
-                                                       m_pFile->GetPath().GetUnicode());
-            EEPOLICY_HANDLE_FATAL_ERROR(COR_E_EXECUTIONENGINE);
-        }
-// #endif
-
-#endif // FEATURE_FUSION
 
         LOG((LF_ZAP, LL_INFO10, "Using native image %S.\n", m_pFile->GetPersistentNativeImage()->GetPath().GetUnicode()));
         ExternalLog(LL_INFO10, "Native image successfully used.");
@@ -1315,7 +1200,7 @@ void DomainFile::FinishLoad()
     // Are we absolutely required to use a native image?
     CheckZapRequired();
 
-#if defined(FEATURE_CORECLR) && defined(FEATURE_COMINTEROP)
+#if defined(FEATURE_COMINTEROP)
     // If this is a winmd file, ensure that the ngen reference namespace is loadable.
     // This is necessary as on the phone we don't check ngen image dependencies, and thus we can get in a situation 
     // where a winmd is loaded as a dependency of an ngen image, but the type used to build cross module references 
@@ -1350,7 +1235,7 @@ void DomainFile::FinishLoad()
             }
         }
     }
-#endif // defined(FEATURE_CORECLR) && defined(FEATURE_COMINTEROP)
+#endif //defined(FEATURE_COMINTEROP)
 #endif // FEATURE_PREJIT
 
     // Flush any log messages
@@ -1499,12 +1384,10 @@ void DomainFile::Activate()
             m_bDisableActivationCheck=TRUE;
             pMT->CheckRunClassInitThrowing();
         }
-#ifdef FEATURE_CORECLR
         if (g_pConfig->VerifyModulesOnLoad())
         {
             m_pModule->VerifyAllMethods();
         }
-#endif //FEATURE_CORECLR
 #ifdef _DEBUG
         if (g_pConfig->ExpandModulesOnLoad())
         {
@@ -1699,9 +1582,6 @@ DomainAssembly::DomainAssembly(AppDomain *pDomain, PEFile *pFile, AssemblyLoadSe
   : DomainFile(pDomain, pFile),
     m_pAssembly(NULL),
     m_debuggerFlags(DACF_NONE),
-#ifdef FEATURE_FUSION
-    m_pAssemblyBindingClosure(NULL),
-#endif
     m_MissingDependenciesCheckStatus(CMD_Unknown),
     m_fSkipPolicyResolution(pLoadSecurity != NULL && !pLoadSecurity->ShouldResolvePolicy()),
     m_fDebuggerUnloadStarted(FALSE),
@@ -1735,76 +1615,6 @@ DomainAssembly::DomainAssembly(AppDomain *pDomain, PEFile *pFile, AssemblyLoadSe
 
     if (pLoadSecurity != NULL)
     {
-#ifdef FEATURE_CAS_POLICY
-        // If this assembly had a file name specified, we aren't allowed to load from remote sources and we
-        // aren't in CAS policy mode (which sandboxes remote assemblies automatically), then we need to do a
-        // check on this assembly's zone of origin when creating it.
-        if (pLoadSecurity->m_fCheckLoadFromRemoteSource &&
-            !pLoadSecurity->m_fSuppressSecurityChecks &&
-            !m_pDomain->GetSecurityDescriptor()->AllowsLoadsFromRemoteSources() &&
-            !pFile->IsIntrospectionOnly())
-        {
-            SString strCodeBase;
-            BYTE pbUniqueID[MAX_SIZE_SECURITY_ID];
-            DWORD cbUniqueID = COUNTOF(pbUniqueID);
-            SecZone dwZone = NoZone;
-
-            GetSecurityIdentity(strCodeBase,
-                                &dwZone,
-                                0,
-                                pbUniqueID,
-                                &cbUniqueID);
-
-            // Since loads from remote sources are not enabled for this assembly, we only want to allow the
-            // load if any of the following conditions apply:
-            //
-            //  * The load is coming off the local machine
-            //  * The load is coming from the intranet or a trusted site, and the code base is UNC.  (ie,
-            //    don't allow HTTP loads off the local intranet
-
-            bool safeLoad = false;
-            if (dwZone == LocalMachine)
-            {
-                safeLoad = true;
-            }
-            else if (dwZone == Intranet || dwZone == Trusted)
-            {
-                if (UrlIsFileUrl(strCodeBase.GetUnicode()))
-                {
-                    safeLoad = true;
-                }
-                else if (PathIsUNC(strCodeBase.GetUnicode()))
-                {
-                    safeLoad = true;
-                }
-            }
-
-            if (!safeLoad)
-            {
-                // We've tried to load an assembly from a location where it would have been sandboxed in legacy
-                // CAS situations, but the application hasn't indicated that this is a safe thing to do. In
-                // order to prevent accidental security holes by silently loading assemblies in full trust that
-                // an application expected to be sandboxed, we'll throw an exception instead.
-                //
-                // Since this exception can commonly occur with if the file is physically located on the
-                // hard drive, but has the mark of the web on it we'll also try to detect this mark and
-                // provide a customized error message if we find it.   We do that by re-evaluating the
-                // assembly's zone with the NOSAVEDFILECHECK flag, which ignores the mark of the web, and if
-                // that comes back as MyComputer we flag the assembly as having the mark of the web on it.
-                SecZone dwNoMotwZone = NoZone;
-                GetSecurityIdentity(strCodeBase, &dwNoMotwZone, MUTZ_NOSAVEDFILECHECK, pbUniqueID, &cbUniqueID);
-
-                if (dwNoMotwZone == LocalMachine)
-                {
-                    COMPlusThrow(kNotSupportedException, IDS_E_LOADFROM_REMOTE_SOURCE_MOTW);
-                }
-                else
-                {
-                    COMPlusThrow(kNotSupportedException, IDS_E_LOADFROM_REMOTE_SOURCE);
-                }
-            }
-        }
-#endif // FEATURE_CAS_POLICY
 
         if (GetFile()->IsSourceGAC())
         {
@@ -1816,45 +1626,9 @@ DomainAssembly::DomainAssembly(AppDomain *pDomain, PEFile *pFile, AssemblyLoadSe
         }
         else
         {
-#ifdef FEATURE_FUSION
-            // We do not support sharing behavior of ALWAYS when using evidence to load assemblies
-            if (pDomain->GetSharePolicy() == AppDomain::SHARE_POLICY_ALWAYS
-                && ShouldLoadDomainNeutral())
-            {
-                // Just because we have information about the loaded assembly's security doesn't mean that
-                // we're trying to override evidence, make sure we're not just trying to push a grant set
-                if (((pLoadSecurity->m_pEvidence != NULL) && (*pLoadSecurity->m_pEvidence != NULL)) ||
-                    ((pLoadSecurity->m_pAdditionalEvidence != NULL) && (*pLoadSecurity->m_pAdditionalEvidence != NULL)))
-                {
-                    // We may not be able to reduce sharing policy at this point, if we have already loaded
-                    // some non-GAC assemblies as domain neutral.  For this case we must regrettably fail
-                    // the whole operation.
-                    if (!pDomain->ReduceSharePolicyFromAlways())
-                    {
-                        ThrowHR(COR_E_CANNOT_SPECIFY_EVIDENCE);
-                    }
-                }
-            }
-#endif
             {
                 GCX_COOP();
 
-#ifdef FEATURE_CAS_POLICY
-                if (pLoadSecurity->m_pAdditionalEvidence != NULL)
-                {
-                    if(*pLoadSecurity->m_pAdditionalEvidence != NULL)
-                    {
-                        pSecurityDescriptorHolder->SetAdditionalEvidence(*pLoadSecurity->m_pAdditionalEvidence);
-                    }
-                }
-                else if (pLoadSecurity->m_pEvidence != NULL)
-                {
-                    if (*pLoadSecurity->m_pEvidence != NULL)
-                    {
-                        pSecurityDescriptorHolder->SetEvidence(*pLoadSecurity->m_pEvidence);
-                    }
-                }
-#endif // FEATURE_CAS_POLICY
 
                 // If the assembly being loaded already knows its grant set (for instnace, it's being pushed
                 // from the loading assembly), then we can set that up now as well
@@ -1862,15 +1636,6 @@ DomainAssembly::DomainAssembly(AppDomain *pDomain, PEFile *pFile, AssemblyLoadSe
                 {
                     _ASSERTE(pLoadSecurity->m_pGrantSet != NULL);
 
-#ifdef FEATURE_CAS_POLICY
-                    // The permissions from an anonymously hosted dynamic method are fulltrust/transparent,
-                    // so ensure we have full trust to pass that on to the new assembly
-                    if(pLoadSecurity->m_fPropagatingAnonymouslyHostedDynamicMethodGrant &&
-                       !CLRConfig::GetConfigValue(CLRConfig::UNSUPPORTED_Security_DisableAnonymouslyHostedDynamicMethodCreatorSecurityCheck))
-                    {
-                        Security::SpecialDemand(SSWT_LATEBOUND_LINKDEMAND, SECURITY_FULL_TRUST);
-                    }
-#endif // FEATURE_CAS_POLICY
 
                     pSecurityDescriptorHolder->PropagatePermissionSet(
                                                       *pLoadSecurity->m_pGrantSet,
@@ -1928,10 +1693,6 @@ void DomainAssembly::ReleaseFiles()
 
     if(m_pAssembly)
         m_pAssembly->StartUnload();
-#ifdef FEATURE_FUSION
-    // release the old closure from the holder
-    m_pAssemblyBindingClosure=NULL;
-#endif
     ModuleIterator i = IterateModules(kModIterIncludeLoading);
     while (i.Next())
     {
@@ -2070,144 +1831,17 @@ OBJECTREF DomainAssembly::GetExposedAssemblyObject()
 
 #ifdef FEATURE_LOADER_OPTIMIZATION
 
-#ifdef FEATURE_FUSION
-// This inner method exists to avoid EX_TRY calling _alloca repeatedly in the for loop below.
-DomainAssembly::CMDI_Result DomainAssembly::CheckMissingDependencyInner(IAssemblyBindingClosure* pClosure, DWORD idx)
-{
-    CONTRACTL {
-        INSTANCE_CHECK;
-        THROWS;
-        GC_TRIGGERS;
-    } CONTRACTL_END;
-
-    SafeComHolder<IAssemblyName>  pAssemblyName;
-    HRESULT hrBindFailure = S_OK;
-    HRESULT hr = pClosure->GetNextFailureAssembly(idx, &pAssemblyName, &hrBindFailure);
-    if (hr == HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS))
-    {
-        return CMDI_End;
-    }
-
-    IfFailThrow(hr);
-
-    CMDI_Result ret = CMDI_AssemblyResolveFailed;
-    AssemblySpec spec;
-    PEAssemblyHolder result;
-
-    EX_TRY
-    {
-        spec.InitializeSpec(pAssemblyName, this, FALSE);
-        result = this->GetAppDomain()->TryResolveAssembly(&spec,FALSE);
-
-        if (result && result->CanUseWithBindingCache())
-        {
-            this->GetAppDomain()->AddFileToCache(&spec, result);
-            ret = CMDI_AssemblyResolveSucceeded;
-        }
-        else
-        {
-            _ASSERTE(FAILED(hrBindFailure));
-
-            StackSString name;
-            spec.GetFileOrDisplayName(0, name);
-            NewHolder<EEFileLoadException> pEx(new EEFileLoadException(name, hrBindFailure));
-            this->GetAppDomain()->AddExceptionToCache(&spec, pEx);
-        }
-    }
-    EX_CATCH
-    {
-        // For compat reasons, we don't want to throw right now but make sure that we
-        // cache the exception so that it can be thrown if/when we try to load the
-        // further down the road. See VSW 528532 for more details.
-    }
-    EX_END_CATCH(RethrowTransientExceptions);
-
-    return ret;
-}
-
-
-// CheckMissingDependencies returns FALSE if any missing dependency would
-// successfully bind with an AssemblyResolve event. When this is the case, we
-// want to avoid sharing this assembly, since AssemblyResolve events are not
-// under our control, and therefore not predictable.
-CMD_State DomainAssembly::CheckMissingDependencies()
-{
-    CONTRACTL {
-        INSTANCE_CHECK;
-        THROWS;
-        GC_TRIGGERS;
-    } CONTRACTL_END;
-
-    if (MissingDependenciesCheckDone())
-        return m_MissingDependenciesCheckStatus;
-
-    if (this->GetAppDomain()->IsCompilationDomain())
-    {
-        // Compilation domains will never have resolve events.  Plus, this path
-        // will sidestep the compilation domain's bind override, which will make
-        // us skip over some dependencies.
-        m_MissingDependenciesCheckStatus = CMD_NotNeeded;
-        return m_MissingDependenciesCheckStatus;
-    }
-
-    if (IsSystem())
-    {
-        m_MissingDependenciesCheckStatus = CMD_NotNeeded;
-        return m_MissingDependenciesCheckStatus;
-    }
-
-    GCX_PREEMP();
-    IAssemblyBindingClosure * pClosure = GetAssemblyBindingClosure(LEVEL_COMPLETE);
-
-    if(pClosure == NULL)
-    {
-        // If the closure is empty, no need to iterate them.
-        m_MissingDependenciesCheckStatus = CMD_NotNeeded;
-        return m_MissingDependenciesCheckStatus;
-    }
-
-    for (DWORD idx = 0;;idx++)
-    {
-        switch (CheckMissingDependencyInner(pClosure, idx))
-        {
-          case CMDI_AssemblyResolveSucceeded:
-          {
-            STRESS_LOG1(LF_CODESHARING,LL_INFO100,"Missing dependencies check FAILED, DomainAssembly=%p",this);
-            m_MissingDependenciesCheckStatus = CMD_Resolved;
-            return m_MissingDependenciesCheckStatus;
-            break;
-          }
-
-          case CMDI_End:
-          {
-            STRESS_LOG1(LF_CODESHARING,LL_INFO100,"Missing dependencies check SUCCESSFUL, DomainAssembly=%p",this);
-            m_MissingDependenciesCheckStatus = CMD_IndeedMissing;
-            return m_MissingDependenciesCheckStatus;
-            break;
-          }
-
-          case CMDI_AssemblyResolveFailed:
-          {
-            // Don't take any action, just continue the loop.
-            break;
-          }
-        }
-    }
-}
-#endif // FEATURE_FUSION
 
 BOOL DomainAssembly::MissingDependenciesCheckDone()
 {
     return m_MissingDependenciesCheckStatus != CMD_Unknown;
 }
 
-#ifdef FEATURE_CORECLR
 CMD_State DomainAssembly::CheckMissingDependencies()
 {
     //CoreCLR simply doesn't share if dependencies are missing
     return CMD_NotNeeded;
 }
-#endif // FEATURE_CORECLR
 
 #endif // FEATURE_LOADER_OPTIMIZATION
 
@@ -2305,34 +1939,7 @@ void DomainAssembly::FindNativeImage()
     }
 #endif // FEATURE_TREAT_NI_AS_MSIL_DURING_DIAGNOSTICS
 
-#ifndef FEATURE_CORECLR // hardbinding
-    // The IsSafeToHardBindTo() check is only for use during the ngen compilation phase. It discards ngen images for
-    // assemblies that aren't hard-bound to (as this would cause all such assemblies be loaded eagerly.)
-    if (!IsSystem() && this->GetAppDomain()->IsCompilationDomain() && !GetFile()->IsSafeToHardBindTo())
-    {
-        if (!this->GetAppDomain()->ToCompilationDomain()->IsSafeToHardBindTo(GetFile()))
-        {
-            GetFile()->SetCannotUseNativeImage();
 
-            if (GetFile()->HasNativeImage())
-                GetFile()->ClearNativeImage();
-
-            return;
-        }
-
-        GetFile()->SetSafeToHardBindTo();
-    }
-#endif
-
-#ifdef FEATURE_FUSION
-    DomainAssembly * pDomainAssembly = GetDomainAssembly();
-    if (pDomainAssembly->GetSecurityDescriptor()->HasAdditionalEvidence() ||
-        !(pDomainAssembly->GetFile()->IsContextLoad() ||
-        pDomainAssembly->GetFile()->HasHostAssembly()))
-    {
-        m_pFile->SetCannotUseNativeImage();
-    }
-#endif //FEATURE_FUSION
 
     ClearNativeImageStress();
 
@@ -2340,7 +1947,7 @@ void DomainAssembly::FindNativeImage()
 
     if (GetFile()->HasNativeImage())
     {
-#if defined(_DEBUG) && defined(FEATURE_CORECLR)
+#if defined(_DEBUG)
         if (g_pConfig->ForbidZap(GetSimpleName()))
         {
             SString sbuf;
@@ -2357,10 +1964,6 @@ void DomainAssembly::FindNativeImage()
             m_dwReasonForRejectingNativeImage = ReasonForRejectingNativeImage_MscorlibNotNative;
             STRESS_LOG2(LF_ZAP,LL_INFO100,"Rejecting native file %p, because mscolib has not NI - reason 0x%x\n",pNativeImage.GetValue(),m_dwReasonForRejectingNativeImage);
             ExternalLog(LL_ERROR, "Rejecting native image because mscorlib does not have native image");
-#ifdef FEATURE_FUSION
-            if(GetFile())
-                GetFile()->ETWTraceLogMessage(ETW::BinderLog::BinderStructs::NGEN_BIND_SYSTEM_ASSEMBLY_NATIVEIMAGE_NOT_AVAILABLE, NULL);
-#endif
             GetFile()->ClearNativeImage();
 
 #ifdef FEATURE_WINDOWSPHONE
@@ -2377,10 +1980,6 @@ void DomainAssembly::FindNativeImage()
                 "The assembly's permissions must have changed since the time it was ngenned, "
                 "or it is running with a different security context.");
 
-#ifdef FEATURE_FUSION
-            if(GetFile())
-                GetFile()->ETWTraceLogMessage(ETW::BinderLog::BinderStructs::NGEN_BIND_ASSEMBLY_HAS_DIFFERENT_GRANT, NULL);
-#endif
             GetFile()->ClearNativeImage();
 
 #ifdef FEATURE_WINDOWSPHONE
@@ -2397,10 +1996,6 @@ void DomainAssembly::FindNativeImage()
                 "with one or more of its assembly dependencies. The assembly needs "
                 "to be ngenned again");
 
-#ifdef FEATURE_FUSION
-            if(GetFile())
-                GetFile()->ETWTraceLogMessage(ETW::BinderLog::BinderStructs::NGEN_BIND_DEPENDENCY_HAS_DIFFERENT_IDENTITY, NULL);
-#endif
             GetFile()->ClearNativeImage();
 
 #ifdef FEATURE_WINDOWSPHONE
@@ -2429,15 +2024,6 @@ void DomainAssembly::FindNativeImage()
             {
                 GetFile()->SetNativeImageUsedExclusively();
             }
-#ifdef FEATURE_FUSION
-            else
-            {
-                if (!IsSystem())
-                {
-                    GetFile()->SetNativeImageClosure(GetAssemblyBindingClosure(LEVEL_STARTING));
-                }
-            }
-#endif //FEATURE_FUSION
 
             PEAssembly * pFile = (PEAssembly *)FastInterlockCompareExchangePointer((void **)ppNativeFile, (void *)GetFile(), (void *)NULL);
             STRESS_LOG3(LF_ZAP,LL_INFO100,"Attempted to set  new native file %p, old file was %p, location in the image=%p\n",GetFile(),pFile,ppNativeFile);
@@ -2446,9 +2032,6 @@ void DomainAssembly::FindNativeImage()
                     ( !bExpectedToBeShared ||
                        pFile == PEFile::Dummy() ||
                        pFile->IsNativeImageUsedExclusively() ||
-#ifdef FEATURE_FUSION
-                       !pFile->HasEqualNativeClosure(this) ||
-#endif //FEATURE_FUSION
                        !(GetFile()->GetPath().Equals(pFile->GetPath())))
 
                 )
@@ -2465,10 +2048,6 @@ void DomainAssembly::FindNativeImage()
                     "- abandoning ngen image. The assembly will be JIT-compiled in "
                     "the second appdomain. See System.LoaderOptimization.MultiDomain "
                     "for information about domain-neutral loading.");
-#ifdef FEATURE_FUSION
-                if(GetFile())
-                    GetFile()->ETWTraceLogMessage(ETW::BinderLog::BinderStructs::NGEN_BIND_ASSEMBLY_NOT_DOMAIN_NEUTRAL, NULL);
-#endif
                 GetFile()->ClearNativeImage();
 
                 // We only support a (non-shared) native image to be used from a single
@@ -2489,7 +2068,6 @@ void DomainAssembly::FindNativeImage()
         }
     }
 
-#if defined(FEATURE_CORECLR)
     if (!GetFile()->HasNativeImage())
     {
         //
@@ -2504,7 +2082,6 @@ void DomainAssembly::FindNativeImage()
 
         GetAppDomain()->CheckForMismatchedNativeImages(&spec, &mvid);
     }
-#endif
 
     CheckZapRequired();
 }
@@ -2529,65 +2106,6 @@ BOOL DomainAssembly::ShouldLoadDomainNeutralHelper()
 
 #ifdef FEATURE_LOADER_OPTIMIZATION
 
-#ifndef FEATURE_CORECLR
-
-    BOOL fIsShareableHostAssembly = FALSE;
-    if (GetFile()->HasHostAssembly())
-    {
-        IfFailThrow(GetFile()->GetHostAssembly()->IsShareable(&fIsShareableHostAssembly));
-    }
-    
-#ifdef FEATURE_FUSION
-    // Only use domain neutral code for normal assembly loads
-    if ((GetFile()->GetFusionAssembly() == NULL) && !fIsShareableHostAssembly)
-    {
-        return FALSE;
-    }
-#endif
-
-#ifdef FEATURE_REFLECTION_ONLY_LOAD
-    // Introspection only does not use domain neutral code
-    if (IsIntrospectionOnly())
-        return FALSE;
-#endif
-
-#ifdef FEATURE_FUSION
-    // use domain neutral code only for Load context, as the
-    // required eager binding interferes with LoadFrom binding semantics
-    if (!GetFile()->IsContextLoad() && !fIsShareableHostAssembly)
-        return FALSE;
-#endif
-
-    // Check app domain policy...
-    if (this->GetAppDomain()->ApplySharePolicy(this))
-    {
-        if (IsSystem())
-            return TRUE;
-
-        // if not the default AD, ensure that the closure is filled in
-        if (this->GetAppDomain() != SystemDomain::System()->DefaultDomain())
-            GetAssemblyBindingClosure(LEVEL_COMPLETE);
-
-
-        // Can be domain neutral only if we aren't binding any missing dependencies with
-        // the assembly resolve event
-        if ((this->GetAppDomain() != SystemDomain::System()->DefaultDomain()) &&
-            (CheckMissingDependencies() == CMD_Resolved))
-        {
-            return FALSE;
-        }
-
-        // Ensure that all security conditions are met for code sharing
-        if (!Security::CanShareAssembly(this))
-        {
-            return FALSE;
-        }
-
-        return TRUE;
-    }
-    return FALSE;
-
-#else // FEATURE_CORECLR
 
     if (IsSystem())
         return TRUE;
@@ -2620,7 +2138,6 @@ BOOL DomainAssembly::ShouldLoadDomainNeutralHelper()
     
     return FALSE; // No meaning in doing costly closure walk for CoreCLR.
 
-#endif // FEATURE_CORECLR
 
 #else // FEATURE_LOADER_OPTIMIZATION
     return IsSystem();
@@ -2634,55 +2151,6 @@ BOOL DomainAssembly::ShouldSkipPolicyResolution()
 }
 
 
-#if defined(FEATURE_LOADER_OPTIMIZATION) && defined(FEATURE_FUSION)
-//
-// Returns TRUE if the attempt to steal ownership of the native image succeeded, or if there are other
-// reasons for retrying load of the native image in the current appdomain.
-//
-// Returns FALSE if the native image should be rejected in the current appdomain.
-//
-static BOOL TryToStealSharedNativeImageOwnership(PEFile ** ppNativeImage, PEFile * pNativeFile, PEFile * pFile)
-{
-    STANDARD_VM_CONTRACT;
-
-    if (pNativeFile == PEFile::Dummy())
-    {
-        // Nothing to steal anymore. Loading of the native image failed elsewhere.
-        return FALSE;
-    }
-
-    _ASSERTE(!pNativeFile->IsNativeImageUsedExclusively());
-    _ASSERTE(!pFile->IsNativeImageUsedExclusively());
-
-    SharedDomain * pSharedDomain = SharedDomain::GetDomain();
-
-    // Take the lock so that nobody steals or creates Assembly object for this native image while we are stealing it
-    SharedFileLockHolder pNativeFileLock(pSharedDomain, pNativeFile, TRUE);
-
-    if (pNativeFile != VolatileLoad(ppNativeImage))
-    {
-        // The ownership changed before we got a chance. Retry.
-        return TRUE;
-    }
-
-    SharedAssemblyLocator locator(pNativeFile->AsAssembly(), SharedAssemblyLocator::PEASSEMBLYEXACT);
-    if (pSharedDomain->FindShareableAssembly(&locator))
-    {
-        // Another shared assembly (with different binding closure) uses this image, therefore we cannot use it
-        return FALSE;
-    }
-
-    BOOL success = InterlockedCompareExchangeT(ppNativeImage, pFile, pNativeFile) == pNativeFile;
-
-    // If others can reuse us, we cannot go away
-    if (success)
-        pFile->AddRef();
-
-    STRESS_LOG3(LF_ZAP,LL_INFO100,"Attempt to steal ownership from native file %p by %p success %d\n", pNativeFile, pFile, success);
-
-    return TRUE;
-}
-#endif // FEATURE_LOADER_OPTIMIZATION && FEATURE_FUSION
 
 // This is where the decision whether an assembly is DomainNeutral (shared) nor not is made.
 void DomainAssembly::Allocate()
@@ -2717,9 +2185,6 @@ void DomainAssembly::Allocate()
 
 #ifdef FEATURE_LOADER_OPTIMIZATION
 
-#ifdef FEATURE_FUSION
-Retry:
-#endif
 
             // Try to find an existing shared version of the assembly which
             // is compatible with our domain.
@@ -2749,54 +2214,6 @@ Retry:
 
             if (pAssembly == NULL)
             {
-#ifdef FEATURE_FUSION
-                // Final verification that we can use the ngen image.
-                //
-                // code:DomainAssembly::FindNativeImage checks the binding closures before declaring the native image as shareable candidate, 
-                // but the ultimate decisions about sharing happens inside code:Assembly::CanBeShared called from FindShareableAssembly above. 
-                // code:Assembly::CanBeShared checks more conditions than just binding closures. In particular, it also checks whether AssemblyResolve 
-                // event resolves any missing dependencies found in the binding closure - the assembly cannot be shared if it is the case.
-                // The end result is that same ngen image can get here in multiple domains in parallel, but it may not be shareable between all of them.
-                //
-                // We reconcile this conflict by checking whether there is somebody else conflicting with us. If it is, we will try to steal
-                // the ownership of the native image from the other guy and retry. The retry logic is required to prevent a perfectly valid
-                // native image being dropped on the floor just because of multiple appdomains raced to load it.
-                {
-                    ReleaseHolder<PEImage> pNativeImage = GetFile()->GetNativeImageWithRef();
-                    if ((pNativeImage != NULL) && (pNativeImage->GetLoadedLayout() != NULL))
-                    {
-                        Module * pNativeModule = pNativeImage->GetLoadedLayout()->GetPersistedModuleImage();
-                        if (pNativeModule != NULL)
-                        {
-                            // The owner of the native module was set thread-safe in code:DomainAssembly::FindNativeImage
-                            // However the final decision if we can share the native image is done in this function (see usage of code:FindShareableAssembly above)
-                            PEFile ** ppNativeFile = (PEFile **) (PBYTE(pNativeModule) + Module::GetFileOffset());
-                            PEFile * pNativeFile = VolatileLoad(ppNativeFile);
-                            if (pNativeFile != GetFile())
-                            {
-                                pFileLock.Release();
-
-                                // Ensures that multiple threads won't fight with each other indefinitely
-                                __SwitchToThread(0, ++dwSwitchCount);
-
-                                if (!TryToStealSharedNativeImageOwnership(ppNativeFile, pNativeFile, GetFile()))
-                                {
-                                    // If a shared assembly got loaded in the mean time, retry all lookups again
-                                    if (pSharedDomain->GetShareableAssemblyCount() != nInitialShareableAssemblyCount)
-                                        goto Retry;
-
-                                    m_dwReasonForRejectingNativeImage = ReasonForRejectingNativeImage_NiAlreadyUsedInAnotherSharedAssembly;
-                                    STRESS_LOG3(LF_ZAP,LL_INFO100,"Rejecting native file %p, because it is already used by shared file %p - reason 0x%x\n",GetFile(),pNativeFile,m_dwReasonForRejectingNativeImage);
-                                    GetFile()->ClearNativeImage();
-                                    GetFile()->SetCannotUseNativeImage();
-                                }
-
-                                goto Retry;
-                            }
-                        }
-                    }
-                }
-#endif // FEATURE_FUSION
 
                 // We can now rely on the fact that our MDImport will not change so we can stop refcounting it.
                 GetFile()->MakeMDImportPersistent();
@@ -2822,13 +2239,6 @@ Retry:
                 // This is because the resulting shared assembly that we will depend on
                 // DOES have those dependencies, but we won't be able to validly share that
                 // assembly unless we match all of ITS dependencies, too.
-#ifdef FEATURE_FUSION
-                if ((this->GetAppDomain()->GetFusionContext() != NULL) && !IsSystem())
-                {
-                    IAssemblyBindingClosure* pClosure = GetAssemblyBindingClosure(LEVEL_STARTING);
-                    pAssembly->SetBindingClosure(pClosure);
-                }
-#endif // FEATURE_FUSION
                 // Sets the tenured bit atomically with the hash insert.
                 pSharedDomain->AddShareableAssembly(pAssembly);
             }
@@ -2884,15 +2294,8 @@ Retry:
 
     // Insert AssemblyDef details into AssemblySpecBindingCache if appropriate
 
-#ifdef FEATURE_FUSION
-    fInsertIntoAssemblySpecBindingCache = GetFile()->GetLoadContext() == LOADCTX_TYPE_DEFAULT;
-#endif
     
-#if defined(FEATURE_APPX_BINDER)
-    fInsertIntoAssemblySpecBindingCache = fInsertIntoAssemblySpecBindingCache && !GetFile()->HasHostAssembly();
-#else
     fInsertIntoAssemblySpecBindingCache = fInsertIntoAssemblySpecBindingCache && GetFile()->CanUseWithBindingCache();
-#endif
 
     if (fInsertIntoAssemblySpecBindingCache)
     {
@@ -3155,52 +2558,7 @@ void GetTimeStampsForNativeImage(CORCOMPILE_VERSION_INFO * pNativeVersionInfo)
     }
     CONTRACTL_END;
 
-#ifdef FEATURE_CORECLR
     // Do not store runtime timestamps into NGen image for cross-platform NGen determinism
-#else
-    // fill in pRuntimeDllInfo
-    CORCOMPILE_RUNTIME_DLL_INFO *pRuntimeDllInfo = pNativeVersionInfo->runtimeDllInfo;
-
-    for (DWORD index = 0; index < NUM_RUNTIME_DLLS; index++)
-    {
-#ifdef CROSSGEN_COMPILE
-        SString sFileName(SString::Utf8, CorCompileGetRuntimeDllName((CorCompileRuntimeDlls)index));
-
-        PEImageHolder pImage;
-        if (!GetAppDomain()->ToCompilationDomain()->FindImage(sFileName, MDInternalImport_NoCache, &pImage))
-        {
-            EEFileLoadException::Throw(sFileName, COR_E_FILENOTFOUND);
-        }
-
-        PEImageLayoutHolder pLayout(pImage->GetLayout(PEImageLayout::LAYOUT_FLAT,PEImage::LAYOUT_CREATEIFNEEDED));
-        pRuntimeDllInfo[index].timeStamp = pLayout->GetTimeDateStamp();
-        pRuntimeDllInfo[index].virtualSize = pLayout->GetVirtualSize();
-
-#else // CROSSGEN_COMPILE
-
-        HMODULE hMod = CorCompileGetRuntimeDll((CorCompileRuntimeDlls)index);
-
-        if (hMod == NULL)
-        {
-            _ASSERTE((CorCompileRuntimeDlls)index == NGEN_COMPILER_INFO);
-
-            LPCWSTR wszDllName = CorCompileGetRuntimeDllName((CorCompileRuntimeDlls)index);
-            if (FAILED(g_pCLRRuntime->LoadLibrary(wszDllName, &hMod)))
-            {
-                EEPOLICY_HANDLE_FATAL_ERROR_WITH_MESSAGE(COR_E_EXECUTIONENGINE, W("Unable to load CLR DLL during ngen"));
-            }
-        }
-
-        _ASSERTE(hMod != NULL);
-
-        PEDecoder pe(hMod);
-
-        pRuntimeDllInfo[index].timeStamp = pe.GetTimeDateStamp();
-        pRuntimeDllInfo[index].virtualSize = pe.GetVirtualSize();
-#endif // CROSSGEN_COMPILE
-
-    }
-#endif // FEATURE_CORECLR
 }
 
 //
@@ -3215,7 +2573,6 @@ void GetNGenCpuInfo(CORINFO_CPU * cpuInfo)
 
 #ifdef _TARGET_X86_
 
-#ifdef FEATURE_CORECLR
     static CORINFO_CPU ngenCpuInfo =
         {
             (CPU_X86_PENTIUM_PRO << 8), // dwCPUType
@@ -3225,26 +2582,6 @@ void GetNGenCpuInfo(CORINFO_CPU * cpuInfo)
 
     // We always generate P3-compatible code on CoreCLR
     *cpuInfo = ngenCpuInfo;
-#else // FEATURE_CORECLR
-    static CORINFO_CPU ngenCpuInfo =
-        {
-            (CPU_X86_PENTIUM_4 << 8),   // dwCPUType
-            0x00008001,                 // dwFeatures
-            0                           // dwExtendedFeatures
-        };
-
-#ifndef CROSSGEN_COMPILE
-    GetSpecificCpuInfo(cpuInfo);
-    if (!IsCompatibleCpuInfo(cpuInfo, &ngenCpuInfo))
-    {
-        // Use the actual cpuInfo if the platform is not compatible 
-        // with the "recommended" processor. We expect most platforms to be compatible
-        return;
-    }
-#endif
-
-    *cpuInfo = ngenCpuInfo;
-#endif // FEATURE_CORECLR
 
 #else // _TARGET_X86_
     cpuInfo->dwCPUType = 0;
@@ -3373,12 +2710,6 @@ void DomainAssembly::GetCurrentVersionInfo(CORCOMPILE_VERSION_INFO *pNativeVersi
         pNativeVersionInfo->wConfigFlags |= CORCOMPILE_CONFIG_INSTRUMENTATION_NONE;
     }
 
-#if defined(_TARGET_AMD64_) && !defined(FEATURE_CORECLR)
-    if (UseRyuJit())
-    {
-        pNativeVersionInfo->wCodegenFlags |= CORCOMPILE_CODEGEN_USE_RYUJIT;
-    }
-#endif
 
     GetTimeStampsForNativeImage(pNativeVersionInfo);
 
@@ -3449,7 +2780,6 @@ BOOL DomainAssembly::CheckZapDependencyIdentities(PEImage *pNativeImage)
     }
     CONTRACTL_END;
 
-#ifdef FEATURE_CORECLR
     AssemblySpec spec;
     spec.InitializeSpec(this->GetFile());
 
@@ -3479,7 +2809,6 @@ BOOL DomainAssembly::CheckZapDependencyIdentities(PEImage *pNativeImage)
             AssemblySpec name;
             name.InitializeSpec(pDependencies->dwAssemblyDef, pNativeImage->GetNativeMDImport(), this);
             
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)            
             if (!name.IsAssemblySpecForMscorlib())
             {
                 // We just initialized the assembly spec for the NI dependency. This will not have binding context
@@ -3489,14 +2818,12 @@ BOOL DomainAssembly::CheckZapDependencyIdentities(PEImage *pNativeImage)
                 _ASSERTE(pParentAssemblyBindingContext);
                 name.SetBindingContext(pParentAssemblyBindingContext);
             }
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
             
             GetAppDomain()->CheckForMismatchedNativeImages(&name, &pDependencies->signAssemblyDef.mvid);
         }
 
         pDependencies++;
     }
-#endif
 
     return TRUE;
 }
@@ -3510,250 +2837,12 @@ BOOL DomainAssembly::CheckZapSecurity(PEImage *pNativeImage)
     }
     CONTRACTL_END;
 
-#ifdef FEATURE_CORECLR
-    return TRUE;
-#else
-
-    //
-    // System libraries are a special case, the security info's always OK.
-    //
-
-    if (IsSystem())
-        return TRUE;
-
-#ifdef FEATURE_NATIVE_IMAGE_GENERATION
-    //
-    // If we're just loading files as part of PDB generation, we're not executing code,
-    // so no need to do security checks
-    //
-    
-    if (IsNgenPDBCompilationProcess())
-        return TRUE;
-#endif
-
-    ETWOnStartup (SecurityCatchCall_V1, SecurityCatchCallEnd_V1);
-
-#ifdef CROSSGEN_COMPILE
     return TRUE;
-#else
-
-#ifdef FEATURE_APTCA
-    if (!Security::NativeImageHasValidAptcaDependencies(pNativeImage, this))
-    {
-        return FALSE;
-    }
-#endif // !FEATURE_APTCA
-
-    GCX_COOP();
-
-    BOOL fHostProtectionOK = FALSE;
-    BOOL fImageAndDependenciesAreFullTrust = FALSE;
-
-    EX_TRY
-    {
-        // Check the HostProtection settings.
-        EApiCategories eRequestedProtectedCategories = GetHostProtectionManager()->GetProtectedCategories();
-        if (eRequestedProtectedCategories == eNoChecks)
-            fHostProtectionOK = TRUE;
-
-        // Due to native code generated for one IL image being more agressively put into another
-        // assembly's native image, we're disabling partial trust NGEN images.  If the current
-        // domain can only have fully trusted assemblies, then we can load this image, or if the current
-        // assembly and its closure are all in the GAC we can also use it.  Otherwise, we'll conservatively
-        // disable the use of this image.
-        IApplicationSecurityDescriptor *pAppDomainSecurity = this->GetAppDomain()->GetSecurityDescriptor();
-        if (pAppDomainSecurity->IsFullyTrusted() && pAppDomainSecurity->IsHomogeneous())
-        {
-            // A fully trusted homogenous domain can only have full trust assemblies, therefore this assembly
-            // and all its dependencies must be full trust
-            fImageAndDependenciesAreFullTrust = TRUE;
-        }
-        else if (IsClosedInGAC())
-        {
-            // The domain allows partial trust assemblies to be loaded into it.  However, this assembly and
-            // all of its dependencies came from the GAC, so we know that they must all be trusted even if
-            // other code in this domain is not.
-            fImageAndDependenciesAreFullTrust = TRUE;
-        }
-        else
-        {
-            // The domain allows partial trust assemblies and we cannot prove that the closure of
-            // dependencies of this assembly will all be fully trusted.  Conservatively throw away this NGEN
-            // image.
-            fImageAndDependenciesAreFullTrust = FALSE;
-        }
-    }
-    EX_CATCH
-    {
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-
-    return fHostProtectionOK && fImageAndDependenciesAreFullTrust;
-#endif // CROSSGEN_COMPILE
-
-#endif // FEATURE_CORECLR
 }
 #endif // FEATURE_PREJIT
 
-#ifdef FEATURE_CAS_POLICY
-void DomainAssembly::InitializeSecurityManager()
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_PREEMPTIVE;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
 
-    GetFile()->InitializeSecurityManager();
-}
-#endif // FEATURE_CAS_POLICY
-
-#ifdef FEATURE_CAS_POLICY
-// Returns security information for the assembly based on the codebase
-void DomainAssembly::GetSecurityIdentity(SString &codebase,
-                                         SecZone *pdwZone,
-                                         DWORD dwFlags,
-                                         BYTE *pbUniqueID,
-                                         DWORD *pcbUniqueID)
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        THROWS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pdwZone));
-        PRECONDITION(CheckPointer(pbUniqueID));
-        PRECONDITION(CheckPointer(pcbUniqueID));
-    }
-    CONTRACTL_END;
-
-    GetFile()->GetSecurityIdentity(codebase, pdwZone, dwFlags, pbUniqueID, pcbUniqueID);
-}
-#endif // FEATURE_CAS_POLICY
-
-#ifdef FEATURE_FUSION
-IAssemblyBindingClosure* DomainAssembly::GetAssemblyBindingClosure(WALK_LEVEL level)
-{
-    CONTRACT(IAssemblyBindingClosure *)
-    {
-        INSTANCE_CHECK;
-        POSTCONDITION(CheckPointer(RETVAL,NULL_OK));
-        //we could  return NULL instead of asserting but hitting code paths that call this for mscorlib is just wasting of cycles anyhow
-        PRECONDITION(!IsSystem());
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACT_END;
-
-    if (m_pAssemblyBindingClosure == NULL || m_pAssemblyBindingClosure->HasBeenWalked(level) == S_FALSE)
-    {
-        SafeComHolder<IAssemblyBindingClosure> pClosure;
-        if (this->GetAppDomain()->GetFusionContext() == NULL)
-        {
-            _ASSERTE(IsSystem());
-            RETURN NULL;
-        }
-        
-        GCX_PREEMP();
-
-        ReleaseHolder<IBindResult> pWinRTBindResult;
-        IUnknown * pUnk;
-        
-        if (GetFile()->IsIStream())
-        {
-            pUnk = GetFile()->GetIHostAssembly();
-        }
-        else if (GetFile()->IsWindowsRuntime())
-        {   // It is .winmd file (WinRT assembly)
-            IfFailThrow(CLRPrivAssemblyWinRT::GetIBindResult(GetFile()->GetHostAssembly(), &pWinRTBindResult));
-            pUnk = pWinRTBindResult;
-        }
-        else
-        {
-            pUnk = GetFile()->GetFusionAssembly();
-        }
-
-        if (m_pAssemblyBindingClosure == NULL)
-        {
-            IfFailThrow(this->GetAppDomain()->GetFusionContext()->GetAssemblyBindingClosure(pUnk, NULL, &pClosure));
-            if (FastInterlockCompareExchangePointer<IAssemblyBindingClosure*>(&m_pAssemblyBindingClosure, pClosure.GetValue(), NULL) == NULL)
-            {
-                pClosure.SuppressRelease();
-            }
-        }
-        IfFailThrow(m_pAssemblyBindingClosure->EnsureWalked(pUnk, this->GetAppDomain()->GetFusionContext(), level));
-    }
-    RETURN m_pAssemblyBindingClosure;
-}
-
-// This is used to determine if the binding closure of the assembly in question is in the GAC. Amongst other uses,
-// this is the MULTI_DOMAIN_HOST scenario.
-BOOL DomainAssembly::IsClosedInGAC()
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    if (IsSystem())
-        return TRUE;
-
-    BOOL fIsWindowsRuntime = GetFile()->IsWindowsRuntime();
-
-    if (!GetFile()->IsSourceGAC() && !fIsWindowsRuntime)
-        return FALSE;
-
-    // Do a binding closure that will help us determine if all the dependencies are in the GAC or not.
-    IAssemblyBindingClosure * pClosure = GetAssemblyBindingClosure(LEVEL_GACCHECK);
-    if (pClosure == NULL)
-        return FALSE;
-    
-    // Once the closure is complete, determine if the dependencies are closed in the GAC (or not).
-    HRESULT hr = pClosure->IsAllAssembliesInGAC();
-    IfFailThrow(hr);
-    
-    return (hr == S_OK);
-}
-
-BOOL DomainAssembly::MayHaveUnknownDependencies()
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    if (IsSystem())
-        return FALSE;
-    
-    // Perform the binding closure walk to initialize state that will help us
-    // determine if we have dependencies that could prevent code-sharing.
-    IAssemblyBindingClosure * pClosure = GetAssemblyBindingClosure(LEVEL_WINRTCHECK);
-    if (pClosure == NULL)
-        return FALSE;
-    
-    HRESULT hr = pClosure->MayHaveUnknownDependencies();
-    IfFailThrow(hr);
-
-    return (hr == S_OK);
-}
 
-#endif // FEATURE_FUSION
 
 
 // <TODO>@todo Find a better place for these</TODO>
diff --git a/src/vm/domainfile.h b/src/vm/domainfile.h
index 55a0907a0b..e91077425d 100644
--- a/src/vm/domainfile.h
+++ b/src/vm/domainfile.h
@@ -521,11 +521,6 @@ public:
         return PTR_PEAssembly(m_pFile);
     }
 
-#ifdef FEATURE_FUSION
-   IAssemblyBindingClosure* GetAssemblyBindingClosure(WALK_LEVEL level);
-   BOOL IsClosedInGAC();
-   BOOL MayHaveUnknownDependencies();
-#endif
 
     // Returns security information for the assembly based on the codebase
     void GetSecurityIdentity(SString &codebase, SecZone *pdwZone, DWORD dwFlags, BYTE *pbUniqueID, DWORD *pcbUniqueID);
@@ -537,19 +532,6 @@ public:
     }
 #ifdef FEATURE_LOADER_OPTIMIZATION
     
-#ifdef FEATURE_FUSION
-private:
-    enum CMDI_Result
-    {
-        CMDI_End,
-        CMDI_AssemblyResolveSucceeded,
-        CMDI_AssemblyResolveFailed
-    };
-
-    CMDI_Result CheckMissingDependencyInner(IAssemblyBindingClosure* pClosure, DWORD idx);
-
-
-#endif
 public:
     CMD_State CheckMissingDependencies();
     BOOL MissingDependenciesCheckDone();
@@ -810,11 +792,6 @@ private:
     ULONG HashIdentity();
 
  private:
-#ifdef FEATURE_CAS_POLICY
-    // Pulls in URLMON's security manager. It is used to translate a codebase
-    // into a zone and site
-    void InitializeSecurityManager();
-#endif // FEATURE_CAS_POLICY
 
     BOOL ShouldLoadDomainNeutral();
     BOOL ShouldLoadDomainNeutralHelper();
@@ -829,9 +806,6 @@ private:
     PTR_IAssemblySecurityDescriptor         m_pSecurityDescriptor;
     PTR_Assembly                            m_pAssembly;
     DebuggerAssemblyControlFlags            m_debuggerFlags;
-#ifdef FEATURE_FUSION	
-    ReleaseHolder<IAssemblyBindingClosure>  m_pAssemblyBindingClosure;
-#endif
     CMD_State                               m_MissingDependenciesCheckStatus;
     ArrayList                               m_Modules;
     BOOL                                    m_fSkipPolicyResolution;
diff --git a/src/vm/dwbucketmanager.hpp b/src/vm/dwbucketmanager.hpp
index a3aef9b2a8..2e37e1be5e 100644
--- a/src/vm/dwbucketmanager.hpp
+++ b/src/vm/dwbucketmanager.hpp
@@ -887,27 +887,7 @@ void BaseBucketParamsManager::GetPackageMoniker(__out_ecount(maxLength) WCHAR* t
     }
     CONTRACTL_END;
 
-#ifndef FEATURE_CORECLR
-    bool success = false;
-    EX_TRY
-    {
-        wcsncpy_s(targetParam, maxLength, AppX::GetHeadPackageMoniker(), _TRUNCATE);
-        success = true;
-    }
-    EX_CATCH
-    {
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-
-    if (!success)
-    {
-        // should this ever legitimately fail??
-        _ASSERTE(!"failed to get package moniker for watson");
-        wcsncpy_s(targetParam, maxLength, W("missing"), _TRUNCATE);
-    }
-#else
     _ASSERTE(!"AppX support NYI for CoreCLR");
-#endif // FEATURE_CORECLR
 }
 
 void BaseBucketParamsManager::GetPRAID(__out_ecount(maxLength) WCHAR* targetParam, int maxLength)
@@ -920,25 +900,7 @@ void BaseBucketParamsManager::GetPRAID(__out_ecount(maxLength) WCHAR* targetPara
     }
     CONTRACTL_END;
 
-#ifndef FEATURE_CORECLR
-    LPCWSTR pPraid = NULL;
-    if (SUCCEEDED(AppX::GetApplicationId(pPraid)))
-    {
-        _snwprintf_s(targetParam,
-                    maxLength,
-                    _TRUNCATE,
-                    W("praid:%s"),
-                    pPraid);
-    }
-    else
-    {
-        // should this ever legitimately fail??
-        _ASSERTE(!"failed to get PRAID for watson");
-        wcsncpy_s(targetParam, maxLength, W("missing"), _TRUNCATE);
-    }
-#else
     _ASSERTE(!"PRAID support NYI for CoreCLR");
-#endif
 }
 
 void BaseBucketParamsManager::GetIlRva(__out_ecount(maxLength) WCHAR* targetParam, int maxLength)
@@ -1475,11 +1437,6 @@ WatsonBucketType GetWatsonBucketType()
     }
     CONTRACTL_END;
 
-#if defined(FEATURE_APPX) && !defined(FEATURE_CORECLR)
-    if (AppX::IsAppXProcess() && !AppX::IsAppXNGen())
-        return MoCrash;
-    else
-#endif // FEATURE_APPX
 
 #ifdef FEATURE_WINDOWSPHONE
         return WinPhoneCrash;
diff --git a/src/vm/dwreport.cpp b/src/vm/dwreport.cpp
index 5ae4f84de2..6414ff5c0e 100644
--- a/src/vm/dwreport.cpp
+++ b/src/vm/dwreport.cpp
@@ -1496,19 +1496,6 @@ BOOL RunWatson(
         
 
         {
-    #if !defined(FEATURE_CORECLR)
-            // Use the version of DW20.exe that lives in the system directory.
-            DWORD ret;
-
-            if (FAILED(GetCORSystemDirectoryInternaL(watsonAppName)))
-            {
-                hr = E_FAIL;
-                break;
-            }
-            watsonCommandLine.Set(watsonAppName);
-            watsonCommandLine.Append(kWatsonImageNameOnVista);
-
-    #else // FEATURE_CORECLR
             HKEYHolder hKey;
             // Look for key \\HKLM\Software\Microsoft\PCHealth\ErrorReporting\DW\Installed"
             DWORD ret = WszRegOpenKeyEx(HKEY_LOCAL_MACHINE,
@@ -1529,7 +1516,6 @@ BOOL RunWatson(
 
             ClrRegReadString(hKey, kWatsonValue, watsonAppName);
 
-    #endif // ! FEATURE_CORECLR
 
             COUNT_T len = watsonCommandLine.GetCount();
             WCHAR* buffer = watsonCommandLine.OpenUnicodeBuffer(len);
@@ -1907,14 +1893,6 @@ HRESULT GetManagedBucketParametersForIp(
     }
 
     WatsonBucketType bucketType = GetWatsonBucketType();
-#ifndef FEATURE_CORECLR
-    if (bucketType == MoCrash)
-    {
-        MoCrashBucketParamsManager moCrashManager(pGenericModeBlock, tore, currentPC, pThread, pThrowable);
-        moCrashManager.PopulateBucketParameters();
-    }
-    else
-#endif // !FEATURE_CORECLR
     {
 #ifdef FEATURE_WINDOWSPHONE
         _ASSERTE(bucketType == WinPhoneCrash);
@@ -2053,11 +2031,9 @@ HRESULT RetrieveManagedBucketParameters(
 #if defined(PRESERVE_WATSON_ACROSS_CONTEXTS)
     GenericModeBlock *pBuckets = NULL;
 
-#ifdef FEATURE_CORECLR
     // On CoreCLR, Watson may not be enabled. Thus, we should
     // skip this.
     if (IsWatsonEnabled())
-#endif // FEATURE_CORECLR
     {
         if (pThread != NULL)
         {
@@ -3094,7 +3070,6 @@ FaultReportResult DoFaultReport(            // Was Watson attempted, successful?
 
     Thread *pThread = GetThread();
 
-#ifdef FEATURE_CORECLR    
     // If watson isn't available (eg. in Silverlight), then use a simple dialog box instead
     if (!IsWatsonEnabled())
     {
@@ -3133,7 +3108,6 @@ FaultReportResult DoFaultReport(            // Was Watson attempted, successful?
 
         return fri.m_faultReportResult;
     } 
-#endif // FEATURE_CORECLR
 
 #ifdef FEATURE_UEF_CHAINMANAGER
     if (g_pUEFManager && !tore.IsUserBreakpoint())
diff --git a/src/vm/ecall.h b/src/vm/ecall.h
index 768b8a9698..c4fed1ff42 100644
--- a/src/vm/ecall.h
+++ b/src/vm/ecall.h
@@ -16,16 +16,8 @@
 
 class MethodDesc;
 
-#ifndef FEATURE_CORECLR
-// Every program tends to use only a subset of ~1000 FCalls. Even big apps like 
-// VS do not usually hit more than 300. Pick a size of the hashtable that's sufficient
-// for the typical case. It is ok to have some colisions in the rare case. Note that 
-// the size of the table should be prime.
-#define FCALL_HASH_SIZE 257
-#else
 // CoreCLR defines fewer FCalls so make the hashtable even smaller.
 #define FCALL_HASH_SIZE 127
-#endif
 
 typedef DPTR(struct ECHash) PTR_ECHash;
 
diff --git a/src/vm/ecalllist.h b/src/vm/ecalllist.h
index 50f0189226..abf79802b5 100644
--- a/src/vm/ecalllist.h
+++ b/src/vm/ecalllist.h
@@ -112,14 +112,6 @@ FCFuncStart(gDependentHandleFuncs)
     FCFuncElement("nSetSecondary",           DependentHandle::nSetSecondary)
 FCFuncEnd()
 
-#ifndef FEATURE_CORECLR
-FCFuncStart(gSizedRefHandleFuncs)
-    FCFuncElement("CreateSizedRef",                 SizedRefHandle::Initialize)
-    FCFuncElement("FreeSizedRef",                   SizedRefHandle::Free)
-    FCFuncElement("GetTargetOfSizedRef",            SizedRefHandle::GetTarget)
-    FCFuncElement("GetApproximateSizeOfSizedRef",   SizedRefHandle::GetApproximateSize)
-FCFuncEnd()
-#endif // !FEATURE_CORECLR
 
 #ifdef FEATURE_RWLOCK
 FCFuncStart(gRWLockFuncs)
@@ -178,11 +170,9 @@ FCFuncStart(gStackBuilderSinkFuncs)
 FCFuncEnd()
 #endif
 
-#ifdef FEATURE_CORECLR
 FCFuncStart(gSymWrapperCodePunkSafeHandleFuncs)
     FCFuncElement("nGetDReleaseTarget", COMPunkSafeHandle::nGetDReleaseTarget)
 FCFuncEnd()
-#endif //FEATURE_CORECLR
 
 FCFuncStart(gParseNumbersFuncs)
     FCFuncElement("IntToString", ParseNumbers::IntToString)
@@ -191,11 +181,6 @@ FCFuncStart(gParseNumbersFuncs)
     FCFuncElement("StringToLong", ParseNumbers::StringToLong)
 FCFuncEnd()
 
-#ifndef FEATURE_CORECLR  // FCalls used by System.TimeSpan
-FCFuncStart(gTimeSpanFuncs)
-    FCFuncElement("LegacyFormatMode", SystemNative::LegacyFormatMode)
-FCFuncEnd()
-#endif // !FEATURE_CORECLR
 
 FCFuncStart(gObjectFuncs)
     FCIntrinsic("GetType", ObjectNative::GetClass, CORINFO_INTRINSIC_Object_GetType)
@@ -267,10 +252,6 @@ FCFuncEnd()
 
 FCFuncStart(gDateTimeFuncs)
     FCFuncElement("GetSystemTimeAsFileTime", SystemNative::__GetSystemTimeAsFileTime)
-#ifndef FEATURE_CORECLR
-    QCFuncElement("LegacyParseMode", SystemNative::LegacyDateTimeParseMode)
-    QCFuncElement("EnableAmPmParseAdjustment", SystemNative::EnableAmPmParseAdjustment)
-#endif
 FCFuncEnd()
 
 FCFuncStart(gEnvironmentFuncs)
@@ -282,13 +263,6 @@ FCFuncStart(gEnvironmentFuncs)
     FCFuncElement("get_ExitCode", SystemNative::GetExitCode)
     FCFuncElement("get_HasShutdownStarted", SystemNative::HasShutdownStarted)
     QCFuncElement("GetProcessorCount", SystemNative::GetProcessorCount)
-#ifndef FEATURE_CORECLR
-    QCFuncElement("GetWorkingSet", SystemNative::GetWorkingSet)
-    FCFuncElement("nativeGetEnvironmentVariable", SystemNative::_GetEnvironmentVariable)
-    FCFuncElement("GetCompatibilityFlag", SystemNative::_GetCompatibilityFlag)
-    QCFuncElement("GetCommandLine", SystemNative::_GetCommandLine)
-    FCFuncElement("GetResourceFromDefault", GetResourceFromDefault)
-#endif // !FEATURE_CORECLR
     FCFuncElement("GetCommandLineArgsNative", SystemNative::GetCommandLineArgs)
     FCFuncElement("get_CurrentProcessorNumber", SystemNative::GetCurrentProcessorNumber)
 
@@ -296,36 +270,14 @@ FCFuncStart(gEnvironmentFuncs)
     QCFuncElement("WinRTSupported", SystemNative::WinRTSupported)
 #endif // FEATURE_COMINTEROP
     FCFuncElementSig("FailFast", &gsig_SM_Str_RetVoid, SystemNative::FailFast)
-#ifndef FEATURE_CORECLR
-    FCFuncElementSig("FailFast", &gsig_SM_Str_Uint_RetVoid, SystemNative::FailFastWithExitCode)
-#endif
     FCFuncElementSig("FailFast", &gsig_SM_Str_Exception_RetVoid, SystemNative::FailFastWithException)
-#ifndef FEATURE_CORECLR
-    QCFuncElement("GetIsCLRHosted", SystemNative::IsCLRHosted)
-    QCFuncElement("TriggerCodeContractFailure", SystemNative::TriggerCodeContractFailure)
-#endif // !FEATURE_CORECLR
 FCFuncEnd()
 
 FCFuncStart(gRuntimeEnvironmentFuncs)
     FCFuncElement("GetModuleFileName", SystemNative::_GetModuleFileName)
-    FCFuncElement("GetRuntimeDirectoryImpl", SystemNative::GetRuntimeDirectory)
-#ifdef FEATURE_FUSION
-    FCFuncElement("GetDeveloperPath", SystemNative::GetDeveloperPath)
-    FCFuncElement("GetHostBindingFile", SystemNative::GetHostBindingFile)
-#endif // FEATURE_FUSION
-#ifndef FEATURE_CORECLR
-    QCFuncElement("_GetSystemVersion", SystemNative::_GetSystemVersion)
-#endif
-#if defined(FEATURE_CLASSIC_COMINTEROP) && !defined(FEATURE_CORECLR)
-    QCFuncElement("GetRuntimeInterfaceImpl", SystemNative::GetRuntimeInterfaceImpl)
-#endif
 FCFuncEnd()
 
 FCFuncStart(gSerializationFuncs)
-#ifndef FEATURE_CORECLR
-    FCFuncElement("GetEnableUnsafeTypeForwarders", ReflectionSerialization::GetEnableUnsafeTypeForwarders)
-    FCFuncElement("nativeGetSafeUninitializedObject", ReflectionSerialization::GetSafeUninitializedObject)
-#endif
     FCFuncElement("nativeGetUninitializedObject", ReflectionSerialization::GetUninitializedObject)
 FCFuncEnd()
 
@@ -333,17 +285,12 @@ FCFuncStart(gExceptionFuncs)
     FCFuncElement("IsImmutableAgileException", ExceptionNative::IsImmutableAgileException)
     FCFuncElement("nIsTransient", ExceptionNative::IsTransient)
     FCFuncElement("GetMethodFromStackTrace", SystemNative::GetMethodFromStackTrace)
-#ifndef FEATURE_CORECLR
-    FCFuncElement("StripFileInfo", ExceptionNative::StripFileInfo)
-#endif
     QCFuncElement("GetMessageFromNativeResources", ExceptionNative::GetMessageFromNativeResources)
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
     FCFuncElement("PrepareForForeignExceptionRaise", ExceptionNative::PrepareForForeignExceptionRaise)
     FCFuncElement("CopyStackTrace", ExceptionNative::CopyStackTrace)
     FCFuncElement("CopyDynamicMethods", ExceptionNative::CopyDynamicMethods)
     FCFuncElement("GetStackTracesDeepCopy", ExceptionNative::GetStackTracesDeepCopy)
     FCFuncElement("SaveStackTracesFromDeepCopy", ExceptionNative::SaveStackTracesFromDeepCopy)
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 FCFuncEnd()
 
 FCFuncStart(gSafeHandleFuncs)
@@ -373,10 +320,8 @@ FCFuncEnd()
 
 FCFuncStart(gTypedReferenceFuncs)
     FCFuncElement("InternalToObject", ReflectionInvocation::TypedReferenceToObject)
-#ifndef FEATURE_CORECLR
     FCFuncElement("InternalSetTypedReference", ReflectionInvocation::SetTypedReference)
     FCFuncElement("InternalMakeTypedReference", ReflectionInvocation::MakeTypedReference)
-#endif
 FCFuncEnd()
 
 FCFuncStart(gSystem_Type)
@@ -470,10 +415,6 @@ FCFuncStart(gCOMTypeHandleFuncs)
     FCFuncElement("Allocate", RuntimeTypeHandle::Allocate) //for A.CI
     FCFuncElement("CompareCanonicalHandles", RuntimeTypeHandle::CompareCanonicalHandles)
     FCIntrinsic("GetValueInternal", RuntimeTypeHandle::GetValueInternal, CORINFO_INTRINSIC_RTH_GetValueInternal)
-#ifndef FEATURE_CORECLR
-    FCFuncElement("IsEquivalentTo", RuntimeTypeHandle::IsEquivalentTo)
-    FCFuncElement("IsEquivalentType", RuntimeTypeHandle::IsEquivalentType)
-#endif // FEATURE_CORECLR
 FCFuncEnd()
 
 FCFuncStart(gMetaDataImport)
@@ -517,9 +458,6 @@ FCFuncEnd()
 FCFuncStart(gRuntimeMethodHandle)
     QCFuncElement("ConstructInstantiation", RuntimeMethodHandle::ConstructInstantiation)
     FCFuncElement("_GetCurrentMethod", RuntimeMethodHandle::GetCurrentMethod)
-#ifdef FEATURE_SERIALIZATION
-    FCFuncElement("SerializationInvoke", RuntimeMethodHandle::SerializationInvoke)
-#endif // FEATURE_SERIALIZATION
     FCFuncElement("InvokeMethod", RuntimeMethodHandle::InvokeMethod)
     QCFuncElement("GetFunctionPointer", RuntimeMethodHandle::GetFunctionPointer)
     FCFuncElement("GetImplAttributes", RuntimeMethodHandle::GetImplAttributes)
@@ -540,11 +478,6 @@ FCFuncStart(gRuntimeMethodHandle)
     FCFuncElement("GetMethodFromCanonical", RuntimeMethodHandle::GetMethodFromCanonical)
     FCFuncElement("IsDynamicMethod", RuntimeMethodHandle::IsDynamicMethod)
     FCFuncElement("GetMethodBody", RuntimeMethodHandle::GetMethodBody)    
-#ifndef FEATURE_CORECLR
-    FCFuncElement("_IsTokenSecurityTransparent", RuntimeMethodHandle::IsTokenSecurityTransparent)
-    QCFuncElement("_IsSecurityCritical", RuntimeMethodHandle::IsSecurityCritical)
-    QCFuncElement("_IsSecuritySafeCritical", RuntimeMethodHandle::IsSecuritySafeCritical)
-#endif // FEATURE_CORECLR
     QCFuncElement("_IsSecurityTransparent", RuntimeMethodHandle::IsSecurityTransparent)
     FCFuncElement("CheckLinktimeDemands", RuntimeMethodHandle::CheckLinktimeDemands)    
     QCFuncElement("IsCAVisibleFromDecoratedType", RuntimeMethodHandle::IsCAVisibleFromDecoratedType)
@@ -553,10 +486,6 @@ FCFuncStart(gRuntimeMethodHandle)
     FCFuncElement("GetResolver", RuntimeMethodHandle::GetResolver)
     FCFuncElement("GetLoaderAllocator", RuntimeMethodHandle::GetLoaderAllocator)
     FCFuncElement("GetSpecialSecurityFlags", ReflectionInvocation::GetSpecialSecurityFlags)
-#ifndef FEATURE_CORECLR
-    QCFuncElement("GetCallerType", RuntimeMethodHandle::GetCallerType)
-    FCFuncElement("PerformSecurityCheck", ReflectionInvocation::PerformSecurityCheck)
-#endif // FEATURE_CORECLR
 FCFuncEnd()
 
 FCFuncStart(gCOMDefaultBinderFuncs)
@@ -568,12 +497,8 @@ FCFuncEnd()
 FCFuncStart(gCOMFieldHandleNewFuncs)
     FCFuncElement("GetValue", RuntimeFieldHandle::GetValue)
     FCFuncElement("SetValue", RuntimeFieldHandle::SetValue)
-#ifndef FEATURE_CORECLR
     FCFuncElement("GetValueDirect", RuntimeFieldHandle::GetValueDirect)
-#endif
-#ifdef FEATURE_SERIALIZATION
     FCFuncElement("SetValueDirect", RuntimeFieldHandle::SetValueDirect)
-#endif
     FCFuncElement("GetName", RuntimeFieldHandle::GetName)
     FCFuncElement("_GetUtf8Name", RuntimeFieldHandle::GetUtf8Name)
     FCFuncElement("MatchesNameHash", RuntimeFieldHandle::MatchesNameHash)
@@ -596,9 +521,6 @@ FCFuncStart(gCOMModuleFuncs)
     QCFuncElement("GetFullyQualifiedName", COMModule::GetFullyQualifiedName)
     QCFuncElement("nIsTransientInternal", COMModule::IsTransient)
     FCFuncElement("IsResource", COMModule::IsResource)    
-#if defined(FEATURE_X509) && defined(FEATURE_CAS_POLICY)
-    QCFuncElement("GetSignerCertificate", COMModule::GetSignerCertificate)
-#endif // defined(FEATURE_X509) && defined(FEATURE_CAS_POLICY)
 FCFuncEnd()
 
 FCFuncStart(gCOMModuleBuilderFuncs)
@@ -610,18 +532,8 @@ FCFuncStart(gCOMModuleBuilderFuncs)
     QCFuncElement("GetMemberRefOfMethodInfo", COMModule::GetMemberRefOfMethodInfo)
     QCFuncElement("GetMemberRefOfFieldInfo", COMModule::GetMemberRefOfFieldInfo)
     QCFuncElement("GetMemberRefFromSignature", COMModule::GetMemberRefFromSignature)
-#ifndef FEATURE_CORECLR
-    QCFuncElement("SetModuleName", COMModule::SetModuleName)
-    QCFuncElement("PreSavePEFile", COMDynamicWrite::PreSavePEFile)
-    QCFuncElement("SavePEFile", COMDynamicWrite::SavePEFile)
-    QCFuncElement("AddResource", COMDynamicWrite::AddResource)
-#endif
     QCFuncElement("GetArrayMethodToken", COMModule::GetArrayMethodToken)
     QCFuncElement("SetFieldRVAContent", COMModule::SetFieldRVAContent)
-#ifndef FEATURE_CORECLR
-    QCFuncElement("DefineNativeResourceFile", COMDynamicWrite::DefineNativeResourceFile)
-    QCFuncElement("DefineNativeResourceBytes", COMDynamicWrite::DefineNativeResourceBytes)
-#endif // FEATURE_CORECLR
 FCFuncEnd()
 
 FCFuncStart(gCOMModuleHandleFuncs)
@@ -633,9 +545,6 @@ FCFuncStart(gCOMModuleHandleFuncs)
     QCFuncElement("ResolveMethod", ModuleHandle::ResolveMethod)
     QCFuncElement("_ContainsPropertyMatchingHash", ModuleHandle::ContainsPropertyMatchingHash)
     QCFuncElement("ResolveField", ModuleHandle::ResolveField)
-#ifndef FEATURE_CORECLR    
-    QCFuncElement("GetAssembly", ModuleHandle::GetAssembly)
-#endif // FEATURE_CORECLR
     QCFuncElement("GetPEKind", ModuleHandle::GetPEKind)
     FCFuncElement("GetMDStreamVersion", ModuleHandle::GetMDStreamVersion)
 FCFuncEnd()
@@ -644,23 +553,12 @@ FCFuncStart(gCustomAttributeEncodedArgument)
     FCFuncElement("ParseAttributeArguments", Attribute::ParseAttributeArguments)
 FCFuncEnd()
 
-#ifdef FEATURE_CAS_POLICY
-FCFuncStart(gPseudoCustomAttribute)
-    FCFuncElement("_GetSecurityAttributes", COMCustomAttribute::GetSecurityAttributes)
-FCFuncEnd()
-#endif
-
 FCFuncStart(gCOMCustomAttributeFuncs)
     FCFuncElement("_ParseAttributeUsageAttribute", COMCustomAttribute::ParseAttributeUsageAttribute)
     FCFuncElement("_CreateCaObject", COMCustomAttribute::CreateCaObject)
     FCFuncElement("_GetPropertyOrFieldData",  COMCustomAttribute::GetPropertyOrFieldData)
 FCFuncEnd()
 
-FCFuncStart(gSecurityContextFrameFuncs)
-    FCFuncElement("Push", COMCustomAttribute::PushSecurityContextFrame)
-    FCFuncElement("Pop", COMCustomAttribute::PopSecurityContextFrame)
-FCFuncEnd()
-
 FCFuncStart(gCOMClassWriter)
     QCFuncElement("DefineGenericParam", COMDynamicWrite::DefineGenericParam)
     QCFuncElement("DefineType", COMDynamicWrite::DefineType)
@@ -680,15 +578,8 @@ FCFuncStart(gCOMClassWriter)
     QCFuncElement("SetFieldLayoutOffset", COMDynamicWrite::SetFieldLayoutOffset)
     QCFuncElement("SetClassLayout", COMDynamicWrite::SetClassLayout)
     QCFuncElement("SetParamInfo", COMDynamicWrite::SetParamInfo)
-#ifndef FEATURE_CORECLR
-    QCFuncElement("SetPInvokeData", COMDynamicWrite::SetPInvokeData)
-    QCFuncElement("SetFieldMarshal", COMDynamicWrite::SetFieldMarshal)
-#endif // FEATURE_CORECLR
     QCFuncElement("SetConstantValue", COMDynamicWrite::SetConstantValue)
     QCFuncElement("DefineCustomAttribute", COMDynamicWrite::DefineCustomAttribute)
-#ifndef FEATURE_CORECLR
-    QCFuncElement("AddDeclarativeSecurity", COMDynamicWrite::AddDeclarativeSecurity)
-#endif // FEATURE_CORECLR
 FCFuncEnd()
 
 #ifdef FEATURE_METHOD_RENTAL
@@ -697,243 +588,25 @@ FCFuncStart(gCOMMethodRental)
 FCFuncEnd()
 #endif // FEATURE_METHOD_RENTAL
 
-#ifdef FEATURE_CAS_POLICY
-FCFuncStart(gFrameSecurityDescriptorFuncs)
-    FCFuncElement("IncrementOverridesCount", SecurityPolicy::IncrementOverridesCount)
-    FCFuncElement("DecrementOverridesCount", SecurityPolicy::DecrementOverridesCount)
-    FCFuncElement("IncrementAssertCount", SecurityPolicy::IncrementAssertCount)
-    FCFuncElement("DecrementAssertCount", SecurityPolicy::DecrementAssertCount)
-FCFuncEnd()
-#endif // FEATURE_CAS_POLICY
-
-#ifdef FEATURE_CAS_POLICY
-FCFuncStart(gCodeAccessSecurityEngineFuncs)
-    FCFuncElement("SpecialDemand", SecurityStackWalk::FcallSpecialDemand)
-    FCFuncElement("Check", SecurityStackWalk::Check)
-    FCFuncElement("CheckNReturnSO", SecurityStackWalk::CheckNReturnSO)
-    FCFuncElement("GetZoneAndOriginInternal", SecurityStackWalk::GetZoneAndOrigin)
-#ifdef FEATURE_COMPRESSEDSTACK    
-    FCFuncElement("QuickCheckForAllDemands", SecurityStackWalk::FCallQuickCheckForAllDemands)
-    FCFuncElement("AllDomainsHomogeneousWithNoStackModifiers", SecurityStackWalk::FCallAllDomainsHomogeneousWithNoStackModifiers)    
-#endif
-FCFuncEnd()
-#endif // FEATURE_CAS_POLICY
-
 FCFuncStart(gCompatibilitySwitchFuncs)
     FCFuncElement("GetValueInternalCall", CompatibilitySwitch::GetValue)
-#ifndef FEATURE_CORECLR
-    FCFuncElement("IsEnabledInternalCall", CompatibilitySwitch::IsEnabled)
-    FCFuncElement("GetAppContextOverridesInternalCall", CompatibilitySwitch::GetAppContextOverrides)
-#endif
-FCFuncEnd()
-
-
-#ifdef FEATURE_COMPRESSEDSTACK    
-FCFuncStart(gCompressedStackFuncs)
-    FCFuncElement("DestroyDelayedCompressedStack", SecurityStackWalk::FcallDestroyDelayedCompressedStack)
-    FCFuncElement("DestroyDCSList", NewCompressedStack::DestroyDCSList)
-    FCFuncElement("GetDelayedCompressedStack", SecurityStackWalk::EcallGetDelayedCompressedStack)
-    FCFuncElement("GetDCSCount", NewCompressedStack::FCallGetDCSCount)
-    FCFuncElement("GetDomainCompressedStack", NewCompressedStack::GetDomainCompressedStack)
-    FCFuncElement("GetHomogeneousPLS", NewCompressedStack::FCallGetHomogeneousPLS)
-    FCFuncElement("IsImmediateCompletionCandidate", NewCompressedStack::FCallIsImmediateCompletionCandidate)    
-FCFuncEnd()
-
-FCFuncStart(gDomainCompressedStackFuncs)
-    FCFuncElement("GetDescCount", DomainCompressedStack::GetDescCount)
-    FCFuncElement("GetDomainPermissionSets", DomainCompressedStack::GetDomainPermissionSets)
-    FCFuncElement("GetDescriptorInfo", DomainCompressedStack::GetDescriptorInfo)
-    FCFuncElement("IgnoreDomain", DomainCompressedStack::IgnoreDomain)
-FCFuncEnd()
-#endif // #ifdef FEATURE_COMPRESSEDSTACK
-
-FCFuncStart(gCOMSecurityManagerFuncs)
-    QCFuncElement("IsSameType", SecurityPolicy::IsSameType)
-    FCFuncElement("_SetThreadSecurity", SecurityPolicy::SetThreadSecurity)
-#ifdef FEATURE_CAS_POLICY
-    QCFuncElement("GetGrantedPermissions", SecurityPolicy::GetGrantedPermissions)
-#endif
 FCFuncEnd()
 
-FCFuncStart(gCOMSecurityContextFuncs)
-#ifdef FEATURE_IMPERSONATION
-    FCFuncElement("GetImpersonationFlowMode", SecurityPolicy::GetImpersonationFlowMode)
-#endif
-#ifdef FEATURE_COMPRESSEDSTACK    
-    FCFuncElement("IsDefaultThreadSecurityInfo", SecurityPolicy::IsDefaultThreadSecurityInfo)
-#endif // #ifdef FEATURE_COMPRESSEDSTACK    
-FCFuncEnd()
-
-#ifdef FEATURE_CAS_POLICY
-FCFuncStart(gCOMSecurityZone)
-    QCFuncElement("_CreateFromUrl", SecurityPolicy::CreateFromUrl)
-FCFuncEnd()
-#endif // FEATURE_CAS_POLICY
-
-FCFuncStart(gCOMFileIOAccessFuncs)
-    QCFuncElement("IsLocalDrive", SecurityPolicy::IsLocalDrive)
-FCFuncEnd()
-
-FCFuncStart(gCOMStringExpressionSetFuncs)
-    QCFuncElement("GetLongPathName", SecurityPolicy::_GetLongPathName)
-FCFuncEnd()
-
-
-FCFuncStart(gCOMUrlStringFuncs)
-    QCFuncElement("GetDeviceName", SecurityPolicy::GetDeviceName)
-FCFuncEnd()
-
-#ifdef FEATURE_CAS_POLICY
-FCFuncStart(gCOMSecurityRuntimeFuncs)
-    FCFuncElement("GetSecurityObjectForFrame", SecurityRuntime::GetSecurityObjectForFrame)
-FCFuncEnd()
-#endif // FEATURE_CAS_POLICY
-
-#ifdef FEATURE_X509
-
-FCFuncStart(gX509CertificateFuncs)
-#ifndef FEATURE_CORECLR
-FCFuncElement("_AddCertificateToStore", COMX509Store::AddCertificate)
-#endif // !FEATURE_CORECLR
-    FCFuncElement("_DuplicateCertContext", COMX509Certificate::DuplicateCertContext)
-#ifndef FEATURE_CORECLR
-    FCFuncElement("_ExportCertificatesToBlob", COMX509Store::ExportCertificatesToBlob)
-#endif // !FEATURE_CORECLR
-    FCFuncElement("_GetCertRawData", COMX509Certificate::GetCertRawData)
-    FCFuncElement("_GetDateNotAfter", COMX509Certificate::GetDateNotAfter)
-    FCFuncElement("_GetDateNotBefore", COMX509Certificate::GetDateNotBefore)
-    FCFuncElement("_GetIssuerName", COMX509Certificate::GetIssuerName)
-    FCFuncElement("_GetPublicKeyOid", COMX509Certificate::GetPublicKeyOid)
-    FCFuncElement("_GetPublicKeyParameters", COMX509Certificate::GetPublicKeyParameters)
-    FCFuncElement("_GetPublicKeyValue", COMX509Certificate::GetPublicKeyValue)
-    FCFuncElement("_GetSerialNumber", COMX509Certificate::GetSerialNumber)
-    FCFuncElement("_GetSubjectInfo", COMX509Certificate::GetSubjectInfo)
-    FCFuncElement("_GetThumbprint", COMX509Certificate::GetThumbprint)
-    FCFuncElement("_LoadCertFromBlob", COMX509Certificate::LoadCertFromBlob)
-    FCFuncElement("_LoadCertFromFile", COMX509Certificate::LoadCertFromFile)
-#ifndef FEATURE_CORECLR
-    FCFuncElement("_OpenX509Store", COMX509Store::OpenX509Store)
-#endif // !FEATURE_CORECLR
-    FCFuncElement("_QueryCertBlobType", COMX509Certificate::QueryCertBlobType)
-    FCFuncElement("_QueryCertFileType", COMX509Certificate::QueryCertFileType)
-FCFuncEnd()
-
-FCFuncStart(gX509SafeCertContextHandleFuncs)
-    FCFuncElement("_FreePCertContext", COMX509Certificate::FreePCertContext)
-FCFuncEnd()
-
-#ifndef FEATURE_CORECLR
-FCFuncStart(gX509SafeCertStoreHandleFuncs)
-    FCFuncElement("_FreeCertStoreContext", COMX509Store::FreeCertStoreContext)
-FCFuncEnd()
-#endif
-
-#endif // FEATURE_X509
 
 FCFuncStart(gBCLDebugFuncs)
     FCFuncElement("GetRegistryLoggingValues", ManagedLoggingHelper::GetRegistryLoggingValues)
 FCFuncEnd()
 
-#ifdef FEATURE_CRYPTO
-FCFuncStart(gCryptographyUtilsFuncs)
-    FCFuncElement("_AcquireCSP", COMCryptography::_AcquireCSP)
-    FCFuncElement("_CreateCSP", COMCryptography::_CreateCSP)
-    FCFuncElement("_ExportKey", COMCryptography::_ExportKey)
-    FCFuncElement("_GenerateKey", COMCryptography::_GenerateKey)
-    FCFuncElement("_GetKeyParameter", COMCryptography::_GetKeyParameter)
-    FCFuncElement("_GetUserKey", COMCryptography::_GetUserKey)
-    FCFuncElement("_ImportKey", COMCryptography::_ImportKey)
-    FCFuncElement("_ImportCspBlob", COMCryptography::_ImportCspBlob)
-    FCFuncElement("_OpenCSP", COMCryptography::_OpenCSP)
-    QCFuncElement("ExportCspBlob", COMCryptography::ExportCspBlob)
-    QCFuncElement("GetPersistKeyInCsp", COMCryptography::GetPersistKeyInCsp)
-    QCFuncElement("SetPersistKeyInCsp", COMCryptography::SetPersistKeyInCsp)
-    QCFuncElement("SignValue", COMCryptography::SignValue)
-    QCFuncElement("VerifySign", COMCryptography::VerifySign)
-    FCFuncElement("_GetProviderParameter", COMCryptography::_GetProviderParameter)
-    FCFuncElement("_ProduceLegacyHmacValues", COMCryptography::_ProduceLegacyHMACValues)
-    QCFuncElement("CreateHash", COMCryptography::CreateHash)
-    QCFuncElement("EndHash", COMCryptography::EndHash)
-    QCFuncElement("HashData", COMCryptography::HashData)
-    QCFuncElement("SetProviderParameter", COMCryptography::SetProviderParameter)
-#ifndef FEATURE_CORECLR
-    FCFuncElement("_DecryptData", COMCryptography::_DecryptData)
-    FCFuncElement("_EncryptData", COMCryptography::_EncryptData)
-    FCFuncElement("_GetEnforceFipsPolicySetting", COMCryptography::_GetEnforceFipsPolicySetting)
-    FCFuncElement("_ImportBulkKey", COMCryptography::_ImportBulkKey)
-    FCFuncElement("_GetKeySetSecurityInfo", COMCryptography::_GetKeySetSecurityInfo)
-    QCFuncElement("SearchForAlgorithm", COMCryptography::SearchForAlgorithm)
-    QCFuncElement("SetKeyParamDw", COMCryptography::SetKeyParamDw)
-    QCFuncElement("SetKeyParamRgb", COMCryptography::SetKeyParamRgb)
-    QCFuncElement("SetKeySetSecurityInfo", COMCryptography::SetKeySetSecurityInfo)
-#endif //FEATURE_CORECLR
-FCFuncEnd()
-
-FCFuncStart(gSafeHashHandleFuncs)
-    QCFuncElement("FreeHash", COMCryptography::FreeHash)
-FCFuncEnd()
-
-FCFuncStart(gSafeKeyHandleFuncs)
-    QCFuncElement("FreeKey", COMCryptography::FreeKey)
-FCFuncEnd()
-
-FCFuncStart(gSafeProvHandleFuncs)
-    QCFuncElement("FreeCsp", COMCryptography::FreeCsp)
-FCFuncEnd()
-
-#ifndef FEATURE_CORECLR
-FCFuncStart(gPasswordDeriveBytesFuncs)
-    QCFuncElement("DeriveKey", COMCryptography::DeriveKey)
-FCFuncEnd()
-#endif
-
-#if defined(FEATURE_CRYPTO)
-FCFuncStart(gRfc2898DeriveBytesFuncs)
-    QCFuncElement("DeriveKey", COMCryptography::DeriveKey)
-FCFuncEnd()
-#endif
-
-#ifndef FEATURE_CORECLR
-FCFuncStart(gRNGCryptoServiceProviderFuncs)
-    QCFuncElement("GetBytes", COMCryptography::GetBytes)
-    QCFuncElement("GetNonZeroBytes", COMCryptography::GetNonZeroBytes)
-FCFuncEnd()
-#endif //FEATURE_CORECLR
-
-FCFuncStart(gRSACryptoServiceProviderFuncs)
-    QCFuncElement("DecryptKey", COMCryptography::DecryptKey)
-    QCFuncElement("EncryptKey", COMCryptography::EncryptKey)
-FCFuncEnd()
-#endif // FEATURE_CRYPTO
-
 FCFuncStart(gAppDomainManagerFuncs)
     QCFuncElement("GetEntryAssembly", AssemblyNative::GetEntryAssembly)
-#ifdef FEATURE_APPDOMAINMANAGER_INITOPTIONS
-    FCFuncElement("HasHost", AppDomainNative::HasHost)
-    QCFuncElement("RegisterWithHost", AppDomainNative::RegisterWithHost)
-#endif    
 FCFuncEnd()
 
-#ifdef FEATURE_FUSION
-FCFuncStart(gAppDomainSetupFuncs)
-    FCFuncElement("UpdateContextProperty", AppDomainNative::UpdateContextProperty)
-FCFuncEnd()
-#endif // FEATURE_FUSION
 
-#ifndef FEATURE_CORECLR
-FCFuncStart(gWindowsRuntimeContextFuncs)
-    QCFuncElement("CreateDesignerContext", AppDomainNative::CreateDesignerContext)
-    QCFuncElement("SetCurrentContext", AppDomainNative::SetCurrentDesignerContext)
-FCFuncEnd()
-#endif // FEATURE_CORECLR
 
 FCFuncStart(gAppDomainFuncs)
 #ifdef FEATURE_REMOTING 
     FCFuncElement("GetDefaultDomain", AppDomainNative::GetDefaultDomain)
 #endif    
-#ifdef FEATURE_FUSION
-    FCFuncElement("GetFusionContext", AppDomainNative::GetFusionContext)
-#endif // FEATURE_FUSION
     FCFuncElement("IsStringInterned", AppDomainNative::IsStringInterned)
     FCFuncElement("IsUnloadingForcedFinalize", AppDomainNative::IsUnloadingForcedFinalize)
 #ifdef FEATURE_REMOTING    
@@ -951,30 +624,13 @@ FCFuncStart(gAppDomainFuncs)
     QCFuncElement("GetAppDomainManagerType", AppDomainNative::GetAppDomainManagerType)
     QCFuncElement("SetAppDomainManagerType", AppDomainNative::SetAppDomainManagerType)
     FCFuncElement("nGetFriendlyName", AppDomainNative::GetFriendlyName)
-#ifndef FEATURE_CORECLR
-    FCFuncElement("GetSecurityDescriptor", AppDomainNative::GetSecurityDescriptor)
-    FCFuncElement("nIsDefaultAppDomainForEvidence", AppDomainNative::IsDefaultAppDomainForEvidence)
-    FCFuncElement("nGetAssemblies", AppDomainNative::GetAssemblies)
-#endif
-#ifdef FEATURE_CAS_POLICY
-    FCFuncElement("nSetHostSecurityManagerFlags", AppDomainNative::SetHostSecurityManagerFlags)
-    QCFuncElement("SetLegacyCasPolicyEnabled", AppDomainNative::SetLegacyCasPolicyEnabled)
-#endif // FEATURE_CAS_POLICY
-#ifdef FEATURE_APTCA
-    QCFuncElement("SetCanonicalConditionalAptcaList", AppDomainNative::SetCanonicalConditionalAptcaList)
-#endif // FEATURE_ATPCA
     QCFuncElement("SetSecurityHomogeneousFlag", AppDomainNative::SetSecurityHomogeneousFlag)
     QCFuncElement("SetupDomainSecurity", AppDomainNative::SetupDomainSecurity)
     FCFuncElement("nSetupFriendlyName", AppDomainNative::SetupFriendlyName)
 #if FEATURE_COMINTEROP
     FCFuncElement("nSetDisableInterfaceCache", AppDomainNative::SetDisableInterfaceCache)
 #endif // FEATURE_COMINTEROP
-#ifndef FEATURE_CORECLR
-    FCFuncElement("_nExecuteAssembly", AppDomainNative::ExecuteAssembly)
-#endif
-#ifdef FEATURE_VERSIONING
     FCFuncElement("nCreateContext", AppDomainNative::CreateContext)
-#endif // FEATURE_VERSIONING
 #ifdef FEATURE_REMOTING
     FCFuncElement("nUnload", AppDomainNative::Unload)
 #endif // FEATURE_REMOTING
@@ -983,17 +639,12 @@ FCFuncStart(gAppDomainFuncs)
     QCFuncElement("GetGrantSet", AppDomainNative::GetGrantSet)
 #ifdef FEATURE_REMOTING
     FCFuncElement("GetDynamicDir", AppDomainNative::GetDynamicDir)
-#ifdef FEATURE_CAS_POLICY
-    QCFuncElement("GetIsLegacyCasPolicyEnabled", AppDomainNative::IsLegacyCasPolicyEnabled)
-#endif // FEATURE_CAS_POLICY
     FCFuncElement("nChangeSecurityPolicy", AppDomainNative::ChangeSecurityPolicy)
     FCFuncElement("IsDomainIdValid", AppDomainNative::IsDomainIdValid)
     FCFuncElement("nApplyPolicy", AppDomainNative::nApplyPolicy)
 #endif // FEATURE_REMOTING
-#ifdef FEATURE_CORECLR    
     QCFuncElement("nSetupBindingPaths", AppDomainNative::SetupBindingPaths)
     QCFuncElement("nSetNativeDllSearchDirectories", AppDomainNative::SetNativeDllSearchDirectories)
-#endif    
     FCFuncElement("IsFinalizingForUnload", AppDomainNative::IsFinalizingForUnload)
     FCFuncElement("PublishAnonymouslyHostedDynamicMethodsAssembly", AppDomainNative::PublishAnonymouslyHostedDynamicMethodsAssembly)
 #ifdef FEATURE_APPDOMAIN_RESOURCE_MONITORING
@@ -1007,12 +658,6 @@ FCFuncStart(gAppDomainFuncs)
 #endif //FEATURE_APPDOMAIN_RESOURCE_MONITORING
 FCFuncEnd()
 
-#if defined(FEATURE_MULTICOREJIT) && !defined(FEATURE_CORECLR)
-FCFuncStart(gProfileOptimizationFuncs)
-    QCFuncElement("InternalSetProfileRoot", MultiCoreJITNative::InternalSetProfileRoot)
-    QCFuncElement("InternalStartProfile",   MultiCoreJITNative::InternalStartProfile)
-FCFuncEnd()
-#endif  // defined(FEATURE_MULTICOREJIT) && !defined(FEATURE_CORECLR)
 
 FCFuncStart(gUtf8String)
     FCFuncElement("EqualsCaseSensitive", Utf8String::EqualsCaseSensitive)
@@ -1050,12 +695,6 @@ FCFuncStart(gTypeNameParser)
     QCFuncElement("_GetAssemblyName",       TypeName::QGetAssemblyName)
 FCFuncEnd()
 
-#ifdef FEATURE_CAS_POLICY
-FCFuncStart(gPEFileFuncs)
-    QCFuncElement("ReleaseSafePEFileHandle", AssemblyNative::ReleaseSafePEFileHandle)
-FCFuncEnd()
-#endif // FEATURE_CAS_POLICY
-
 FCFuncStart(gManifestBasedResourceGrovelerFuncs)
     QCFuncElement("GetNeutralResourcesLanguageAttribute", AssemblyNative::GetNeutralResourcesLanguageAttribute)
 FCFuncEnd()
@@ -1070,80 +709,36 @@ FCFuncStart(gAssemblyFuncs)
     QCFuncElement("GetHashAlgorithm", AssemblyNative::GetHashAlgorithm)
     QCFuncElement("GetLocale", AssemblyNative::GetLocale)
     QCFuncElement("GetPublicKey", AssemblyNative::GetPublicKey)
-#ifndef FEATURE_CORECLR
-    QCFuncElement("GetSecurityRuleSet", AssemblyNative::GetSecurityRuleSet)
-#endif // !FEATURE_CORECLR
     QCFuncElement("GetSimpleName", AssemblyNative::GetSimpleName)
     QCFuncElement("GetVersion", AssemblyNative::GetVersion)
     FCFuncElement("FCallIsDynamic", AssemblyNative::IsDynamic)
     FCFuncElement("_nLoad", AssemblyNative::Load)
-#ifndef FEATURE_CORECLR
-    FCFuncElement("IsFrameworkAssembly", AssemblyNative::IsFrameworkAssembly)
-    FCFuncElement("IsNewPortableAssembly", AssemblyNative::IsNewPortableAssembly)
-#endif
     FCFuncElement("nLoadImage", AssemblyNative::LoadImage)
-#ifndef FEATURE_CORECLR
-    FCFuncElement("nLoadFile", AssemblyNative::LoadFile)
-    QCFuncElement("LoadModule", AssemblyNative::LoadModule)
-#endif  // FEATURE_CORECLR
     QCFuncElement("GetType", AssemblyNative::GetType)
     QCFuncElement("GetManifestResourceInfo", AssemblyNative::GetManifestResourceInfo)
-#ifndef FEATURE_CORECLR
-    QCFuncElement("UseRelativeBindForSatellites", AssemblyNative::UseRelativeBindForSatellites)
-#endif
     QCFuncElement("GetModules", AssemblyNative::GetModules)
     QCFuncElement("GetModule", AssemblyNative::GetModule)
     FCFuncElement("GetReferencedAssemblies", AssemblyNative::GetReferencedAssemblies)
-#ifndef FEATURE_CORECLR
-    QCFuncElement("GetForwardedTypes", AssemblyNative::GetForwardedTypes)
-#endif  // FEATURE_CORECLR
     QCFuncElement("GetExportedTypes", AssemblyNative::GetExportedTypes)
     FCFuncElement("GetManifestResourceNames", AssemblyNative::GetManifestResourceNames)
     QCFuncElement("GetEntryPoint", AssemblyNative::GetEntryPoint)
     QCFuncElement("IsAllSecurityTransparent", AssemblyNative::IsAllSecurityTransparent)
     QCFuncElement("IsAllSecurityCritical", AssemblyNative::IsAllSecurityCritical)
-#ifndef FEATURE_CORECLR
-    QCFuncElement("IsAllSecuritySafeCritical", AssemblyNative::IsAllSecuritySafeCritical)
-    QCFuncElement("IsAllPublicAreaSecuritySafeCritical", AssemblyNative::IsAllPublicAreaSecuritySafeCritical)
-    QCFuncElement("GetGrantSet", AssemblyNative::GetGrantSet)
-    FCFuncElement("IsGlobalAssemblyCache", AssemblyNative::IsGlobalAssemblyCache)
-#endif // !FEATURE_CORECLR
-#ifdef FEATURE_CAS_POLICY
-    QCFuncElement("GetEvidence", SecurityPolicy::GetEvidence)
-#endif // FEATURE_CAS_POLICY
     QCFuncElement("GetImageRuntimeVersion", AssemblyNative::GetImageRuntimeVersion)
     FCFuncElement("IsReflectionOnly", AssemblyNative::IsReflectionOnly)
-#ifndef FEATURE_CORECLR
-    QCFuncElement("GetHostContext", AssemblyNative::GetHostContext)
-#endif
-#ifdef FEATURE_CAS_POLICY
-    QCFuncElement("GetIsStrongNameVerified", AssemblyNative::IsStrongNameVerified)
-    QCFuncElement("GetRawBytes", AssemblyNative::GetRawBytes)
-#endif // FEATURE_CAS_POLICY
     FCFuncElement("GetManifestModule", AssemblyHandle::GetManifestModule)
     FCFuncElement("GetToken", AssemblyHandle::GetToken)
-#ifdef FEATURE_APTCA
-    FCFuncElement("AptcaCheck", AssemblyHandle::AptcaCheck)
-#endif // FEATURE_APTCA
-#ifdef FEATURE_APPX
-    QCFuncElement("nIsDesignerBindingContext", AssemblyNative::IsDesignerBindingContext)
-#endif
-
 FCFuncEnd()
 
-#ifdef FEATURE_CORECLR
 FCFuncStart(gAssemblyExtensionsFuncs)
     QCFuncElement("InternalTryGetRawMetadata", AssemblyNative::InternalTryGetRawMetadata)
 FCFuncEnd()
-#endif
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 FCFuncStart(gAssemblyLoadContextFuncs)
     QCFuncElement("InitializeAssemblyLoadContext", AssemblyNative::InitializeAssemblyLoadContext)
     QCFuncElement("LoadFromPath", AssemblyNative::LoadFromPath)
     QCFuncElement("GetLoadedAssembliesInternal", AssemblyNative::GetLoadedAssembliesInternal)
     QCFuncElement("InternalLoadUnmanagedDllFromPath", AssemblyNative::InternalLoadUnmanagedDllFromPath)
-    QCFuncElement("OverrideDefaultAssemblyLoadContextForCurrentDomain", AssemblyNative::OverrideDefaultAssemblyLoadContextForCurrentDomain)
     QCFuncElement("CanUseAppPathAssemblyLoadContextInCurrentDomain", AssemblyNative::CanUseAppPathAssemblyLoadContextInCurrentDomain)
     QCFuncElement("LoadFromStream", AssemblyNative::LoadFromStream)
     FCFuncElement("nGetFileInformation", AssemblyNameNative::GetFileInformation)
@@ -1153,15 +748,11 @@ FCFuncStart(gAssemblyLoadContextFuncs)
     QCFuncElement("InternalStartProfile",   MultiCoreJITNative::InternalStartProfile)
 #endif // defined(FEATURE_MULTICOREJIT)
 FCFuncEnd()
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
 FCFuncStart(gAssemblyNameFuncs)
     FCFuncElement("nInit", AssemblyNameNative::Init)
     FCFuncElement("nToString", AssemblyNameNative::ToString)
     FCFuncElement("nGetPublicKeyToken", AssemblyNameNative::GetPublicKeyToken)
-#ifndef FEATURE_CORECLR
-    FCFuncElement("EscapeCodeBase", AssemblyNameNative::EscapeCodeBase)
-#endif // !FEATURE_CORECLR
     FCFuncElement("ReferenceMatchesDefinitionInternal", AssemblyNameNative::ReferenceMatchesDefinition)
     FCFuncElement("nGetFileInformation", AssemblyNameNative::GetFileInformation)
 FCFuncEnd()
@@ -1173,21 +764,6 @@ FCFuncEnd()
 FCFuncStart(gAssemblyBuilderFuncs)
     FCFuncElement("nCreateDynamicAssembly", AppDomainNative::CreateDynamicAssembly)
     FCFuncElement("GetInMemoryAssemblyModule", AssemblyNative::GetInMemoryAssemblyModule)
-#ifndef FEATURE_CORECLR
-    FCFuncElement("GetOnDiskAssemblyModule", AssemblyNative::GetOnDiskAssemblyModule)
-#ifdef FEATURE_MULTIMODULE_ASSEMBLIES    
-    QCFuncElement("DefineDynamicModule", COMModule::DefineDynamicModule)
-#endif // FEATURE_MULTIMODULE_ASSEMBLIES
-    QCFuncElement("PrepareForSavingManifestToDisk", AssemblyNative::PrepareForSavingManifestToDisk)
-    QCFuncElement("SaveManifestToDisk", AssemblyNative::SaveManifestToDisk)
-    QCFuncElement("AddFile", AssemblyNative::AddFile)
-    QCFuncElement("SetFileHashValue", AssemblyNative::SetFileHashValue)
-    QCFuncElement("AddStandAloneResource", AssemblyNative::AddStandAloneResource)
-    QCFuncElement("AddExportedTypeOnDisk", AssemblyNative::AddExportedTypeOnDisk)
-    QCFuncElement("AddExportedTypeInMemory", AssemblyNative::AddExportedTypeInMemory)
-    QCFuncElement("AddDeclarativeSecurity", AssemblyNative::AddDeclarativeSecurity)
-    QCFuncElement("CreateVersionInfoResource", AssemblyNative::CreateVersionInfoResource)
-#endif // !FEATURE_CORECLR
 FCFuncEnd()
 
 #ifdef MDA_SUPPORTED 
@@ -1291,10 +867,6 @@ FCFuncEnd()
 FCFuncStart(gThreadFuncs)
     FCDynamic("InternalGetCurrentThread", CORINFO_INTRINSIC_Illegal, ECall::InternalGetCurrentThread)
     FCFuncElement("StartInternal", ThreadNative::Start)
-#ifndef FEATURE_CORECLR
-    FCFuncElement("SuspendInternal", ThreadNative::Suspend)
-    FCFuncElement("ResumeInternal", ThreadNative::Resume)
-#endif
 #ifdef FEATURE_LEAK_CULTURE_INFO
     FCFuncElement("nativeGetSafeCulture", ThreadNative::nativeGetSafeCulture)
 #else
@@ -1309,24 +881,10 @@ FCFuncStart(gThreadFuncs)
 #endif    
     FCFuncElement("GetDomainInternal", ThreadNative::GetDomain)
     FCFuncElement("GetFastDomainInternal", ThreadNative::FastGetDomain)
-#ifdef FEATURE_COMPRESSEDSTACK    
-    FCFuncElement("SetAppDomainStack", ThreadNative::SetAppDomainStack)
-    FCFuncElement("RestoreAppDomainStack", ThreadNative::RestoreAppDomainStack)    
-#endif // #ifdef FEATURE_COMPRESSEDSTACK    
 #ifdef FEATURE_REMOTING         
     FCFuncElement("InternalCrossContextCallback", ThreadNative::InternalCrossContextCallback)
 #endif    
     QCFuncElement("InformThreadNameChange", ThreadNative::InformThreadNameChange)
-#ifndef FEATURE_CORECLR
-    QCFuncElement("GetProcessDefaultStackSize", ThreadNative::GetProcessDefaultStackSize)
-    FCFuncElement("BeginCriticalRegion", ThreadNative::BeginCriticalRegion)
-    FCFuncElement("EndCriticalRegion", ThreadNative::EndCriticalRegion)
-    FCFuncElement("BeginThreadAffinity", ThreadNative::BeginThreadAffinity)
-    FCFuncElement("EndThreadAffinity", ThreadNative::EndThreadAffinity)
-#endif // FEATURE_CORECLR
-#ifndef FEATURE_CORECLR
-    FCFuncElement("ResetAbortNative", ThreadNative::ResetAbort)
-#endif // FEATURE_CORECLR
     FCFuncElement("SpinWaitInternal", ThreadNative::SpinWait)
     QCFuncElement("YieldInternal", ThreadNative::YieldThread)
     FCIntrinsic("GetCurrentThreadNative", ThreadNative::GetCurrentThread, CORINFO_INTRINSIC_GetCurrentManagedThread)
@@ -1339,11 +897,6 @@ FCFuncStart(gThreadFuncs)
     FCFuncElement("StartupSetApartmentStateInternal", ThreadNative::StartupSetApartmentState)
 #endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT
     FCIntrinsic("MemoryBarrier", ThreadNative::FCMemoryBarrier, CORINFO_INTRINSIC_MemoryBarrier)
-#ifndef FEATURE_CORECLR    // coreclr does not support abort reason 
-    FCFuncElement("SetAbortReason", ThreadNative::SetAbortReason)
-    FCFuncElement("GetAbortReason", ThreadNative::GetAbortReason)
-    FCFuncElement("ClearAbortReason", ThreadNative::ClearAbortReason)
-#endif    
 FCFuncEnd()
 
 FCFuncStart(gThreadPoolFuncs)
@@ -1391,9 +944,6 @@ FCFuncStart(gNumberFuncs)
     FCFuncElement("FormatInt64", COMNumber::FormatInt64)
     FCFuncElement("FormatUInt64", COMNumber::FormatUInt64)
     FCFuncElement("FormatSingle", COMNumber::FormatSingle)
-#if !defined(FEATURE_CORECLR)
-    FCFuncElement("FormatNumberBuffer", COMNumber::FormatNumberBuffer)
-#endif // !FEATURE_CORECLR
     FCFuncElement("NumberBufferToDecimal", COMNumber::NumberBufferToDecimal)
     FCFuncElement("NumberBufferToDouble", COMNumber::NumberBufferToDouble)
 FCFuncEnd()
@@ -1421,11 +971,6 @@ FCFuncStart(gDecimalFuncs)
     FCFuncElement("FCallAddSub", COMDecimal::DoAddSubThrow)
     FCFuncElement("FCallMultiply", COMDecimal::DoMultiplyThrow)
     FCFuncElement("FCallDivide", COMDecimal::DoDivideThrow)
-#ifndef FEATURE_CORECLR
-    FCFuncElement("FCallAddSubOverflowed", COMDecimal::DoAddSub)
-    FCFuncElement("FCallMultiplyOverflowed", COMDecimal::DoMultiply)
-    FCFuncElement("FCallDivideOverflowed", COMDecimal::DoDivide)
-#endif // FEATURE_CORECLR
     FCFuncElement("FCallCompare", COMDecimal::DoCompare)
     FCFuncElement("FCallFloor", COMDecimal::DoFloor)
     FCFuncElement("GetHashCode", COMDecimal::GetHashCode)
@@ -1441,12 +986,6 @@ FCFuncStart(gCurrencyFuncs)
     FCFuncElement("FCallToDecimal", COMCurrency::DoToDecimal)
 FCFuncEnd()
 
-#ifndef FEATURE_CORECLR
-FCFuncStart(gCLRConfigFuncs)
-    FCFuncElement("CheckLegacyManagedDeflateStream", SystemNative::CheckLegacyManagedDeflateStream) 
-    FCFuncElement("CheckThrowUnobservedTaskExceptions", SystemNative::CheckThrowUnobservedTaskExceptions) 
-FCFuncEnd()
-#endif // ifndef FEATURE_CORECLR
 
 #if !defined(FEATURE_COREFX_GLOBALIZATION)
 FCFuncStart(gCompareInfoFuncs)
@@ -1456,9 +995,6 @@ FCFuncStart(gCompareInfoFuncs)
     QCFuncElement("NativeInternalInitSortHandle", COMNlsInfo::InternalInitSortHandle)
     QCFuncElement("InternalIsSortable", COMNlsInfo::InternalIsSortable)
     QCFuncElement("InternalGetSortKey", COMNlsInfo::InternalGetSortKey)
-#ifndef FEATURE_CORECLR
-    QCFuncElement("InternalGetSortVersion", COMNlsInfo::InternalGetSortVersion)
-#endif
     QCFuncElement("InternalGetNlsVersionEx", COMNlsInfo::InternalGetNlsVersionEx)
 FCFuncEnd()
 
@@ -1466,9 +1002,6 @@ FCFuncStart(gEncodingTableFuncs)
     FCFuncElement("GetNumEncodingItems", COMNlsInfo::nativeGetNumEncodingItems)
     FCFuncElement("GetEncodingData", COMNlsInfo::nativeGetEncodingTableDataPointer)
     FCFuncElement("GetCodePageData", COMNlsInfo::nativeGetCodePageTableDataPointer)
-#if FEATURE_CODEPAGES_FILE
-    FCFuncElement("nativeCreateOpenFileMapping", COMNlsInfo::nativeCreateOpenFileMapping)
-#endif
 FCFuncEnd()
 
 FCFuncStart(gCalendarDataFuncs)
@@ -1493,15 +1026,10 @@ FCFuncStart(gCultureInfoFuncs)
     FCFuncElement("nativeGetLocaleInfoEx", COMNlsInfo::nativeGetLocaleInfoEx)
     FCFuncElement("nativeGetLocaleInfoExInt", COMNlsInfo::nativeGetLocaleInfoExInt)
     
-#ifndef FEATURE_CORECLR
-    FCFuncElement("nativeSetThreadLocale", COMNlsInfo::nativeSetThreadLocale)
-#endif
     QCFuncElement("InternalGetUserDefaultUILanguage", COMNlsInfo::InternalGetUserDefaultUILanguage)
     QCFuncElement("InternalGetSystemDefaultUILanguage", COMNlsInfo::InternalGetSystemDefaultUILanguage)
 // Added but disabled from desktop in .NET 4.0, stayed disabled in .NET 4.5
-#ifdef FEATURE_CORECLR
     FCFuncElement("nativeGetResourceFallbackArray", COMNlsInfo::nativeGetResourceFallbackArray)
-#endif
 FCFuncEnd()
 
 FCFuncStart(gTextInfoFuncs)
@@ -1595,13 +1123,6 @@ FCFuncStart(gInteropMarshalFuncs)
     FCFuncElement("UnsafeAddrOfPinnedArrayElement", MarshalNative::FCUnsafeAddrOfPinnedArrayElement)
     FCFuncElement("GetExceptionCode", ExceptionNative::GetExceptionCode)
     QCFuncElement("GetHINSTANCE", COMModule::GetHINSTANCE)
-#ifndef FEATURE_CORECLR
-    QCFuncElement("InternalNumParamBytes", MarshalNative::NumParamBytes)
-    FCFuncElement("GetExceptionPointers", ExceptionNative::GetExceptionPointers)
-    FCFuncElement("GetUnmanagedThunkForManagedMethodPtr", MarshalNative::GetUnmanagedThunkForManagedMethodPtr)
-    FCFuncElement("GetManagedThunkForUnmanagedMethodPtr", MarshalNative::GetManagedThunkForUnmanagedMethodPtr)
-    FCFuncElement("InternalGetThreadFromFiberCookie", MarshalNative::GetThreadFromFiberCookie)
-#endif
 
     FCFuncElement("OffsetOfHelper", MarshalNative::OffsetOfHelper)
     FCFuncElement("SizeOfType", SafeBuffer::SizeOfType)
@@ -1637,9 +1158,6 @@ FCFuncStart(gInteropMarshalFuncs)
 
     FCFuncElement("GetNativeActivationFactory", MarshalNative::GetNativeActivationFactory)
     FCFuncElement("GetIUnknownForObjectNative", MarshalNative::GetIUnknownForObjectNative)
-#ifndef FEATURE_CORECLR
-    FCFuncElement("GetIDispatchForObjectNative", MarshalNative::GetIDispatchForObjectNative)
-#endif // FEATURE_CORECLR
     FCFuncElement("GetComInterfaceForObjectNative", MarshalNative::GetComInterfaceForObjectNative)
     FCFuncElement("InternalReleaseComObject", MarshalNative::ReleaseComObject)
     FCFuncElement("Release", MarshalNative::Release)
@@ -1647,26 +1165,6 @@ FCFuncStart(gInteropMarshalFuncs)
     FCFuncElement("GetTypedObjectForIUnknown", MarshalNative::GetTypedObjectForIUnknown)
     FCFuncElement("ChangeWrapperHandleStrength", MarshalNative::ChangeWrapperHandleStrength)
     FCFuncElement("CleanupUnusedObjectsInCurrentContext", MarshalNative::CleanupUnusedObjectsInCurrentContext)
-#ifndef FEATURE_CORECLR
-    FCFuncElement("GetLoadedTypeForGUID", MarshalNative::GetLoadedTypeForGUID)
-    FCFuncElement("GetITypeInfoForType", MarshalNative::GetITypeInfoForType)
-    FCFuncElement("IsTypeVisibleFromCom", MarshalNative::IsTypeVisibleFromCom)
-    FCFuncElement("FCallGenerateGuidForType", MarshalNative::DoGenerateGuidForType)
-    FCFuncElement("FCallGetTypeLibGuid", MarshalNative::DoGetTypeLibGuid)
-    FCFuncElement("GetTypeLibLcid", MarshalNative::GetTypeLibLcid)
-    FCFuncElement("GetTypeLibVersion", MarshalNative::GetTypeLibVersion)
-    FCFuncElement("FCallGetTypeInfoGuid", MarshalNative::DoGetTypeInfoGuid)
-    FCFuncElement("FCallGetTypeLibGuidForAssembly", MarshalNative::DoGetTypeLibGuidForAssembly)
-    FCFuncElement("_GetTypeLibVersionForAssembly", MarshalNative::GetTypeLibVersionForAssembly)
-    FCFuncElement("GetEndComSlot", MarshalNative::GetEndComSlot)
-    FCFuncElement("GetMethodInfoForComSlot", MarshalNative::GetMethodInfoForComSlot)
-    FCFuncElement("InternalGetComSlotForMethodInfo", MarshalNative::GetComSlotForMethodInfo)
-    FCFuncElement("InternalSwitchCCW", MarshalNative::SwitchCCW)
-    FCFuncElement("InternalWrapIUnknownWithComObject", MarshalNative::WrapIUnknownWithComObject)
-    QCFuncElement("_GetInspectableIids", MarshalNative::GetInspectableIIDs)
-    QCFuncElement("_GetCachedWinRTTypes", MarshalNative::GetCachedWinRTTypes)
-    QCFuncElement("_GetCachedWinRTTypeByIid", MarshalNative::GetCachedWinRTTypeByIID)
-#endif // FEATURE_CORECLR
 #endif // FEATURE_COMINTEROP
 FCFuncEnd()
 
@@ -1676,20 +1174,8 @@ FCFuncEnd()
 
 #ifdef FEATURE_COMINTEROP
 
-#ifndef FEATURE_CORECLR
-FCFuncStart(gExtensibleClassFactoryFuncs)
-    FCFuncElement("RegisterObjectCreationCallback", RegisterObjectCreationCallback)
-FCFuncEnd()
-#endif
 
 
-#ifdef FEATURE_COMINTEROP_TLB_SUPPORT
-FCFuncStart(gTypeLibConverterFuncs)
-    FCFuncElement("nConvertAssemblyToTypeLib", COMTypeLibConverter::ConvertAssemblyToTypeLib)
-    FCFuncElement("nConvertTypeLibToMetadata", COMTypeLibConverter::ConvertTypeLibToMetadata)
-    QCFuncElement("LoadInMemoryTypeByName", COMModule::LoadInMemoryTypeByName)
-FCFuncEnd()
-#endif // FEATURE_COMINTEROP_TLB_SUPPORT
 
 #ifdef FEATURE_COMINTEROP_MANAGED_ACTIVATION
 FCFuncStart(gRegistrationFuncs)
@@ -1700,81 +1186,6 @@ FCFuncEnd()
 
 #endif // FEATURE_COMINTEROP
 
-#ifdef FEATURE_CAS_POLICY
-FCFuncStart(gPolicyManagerFuncs)
-#ifdef _DEBUG
-    QCFuncElement("DebugOut", SecurityConfig::DebugOut)
-#endif
-FCFuncEnd()
-
-FCFuncStart(gPolicyConfigFuncs)
-    QCFuncElement("ResetCacheData", SecurityConfig::ResetCacheData)
-    QCFuncElement("SaveDataByte", SecurityConfig::SaveDataByte)
-    QCFuncElement("RecoverData", SecurityConfig::RecoverData)
-    QCFuncElement("SetQuickCache", SecurityConfig::SetQuickCache)
-    QCFuncElement("GetCacheEntry", SecurityConfig::GetCacheEntry)
-    QCFuncElement("AddCacheEntry", SecurityConfig::AddCacheEntry)
-    QCFuncElement("GetMachineDirectory", SecurityConfig::_GetMachineDirectory)
-    QCFuncElement("GetUserDirectory", SecurityConfig::_GetUserDirectory)
-    QCFuncElement("WriteToEventLog", SecurityConfig::WriteToEventLog)
-FCFuncEnd()
-#endif // FEATURE_CAS_POLICY
-
-#ifndef FEATURE_CORECLR
-FCFuncStart(gPrincipalFuncs)
-    FCFuncElement("OpenThreadToken", COMPrincipal::OpenThreadToken)
-    QCFuncElement("ImpersonateLoggedOnUser", COMPrincipal::ImpersonateLoggedOnUser)
-    QCFuncElement("RevertToSelf", COMPrincipal::RevertToSelf)
-    QCFuncElement("SetThreadToken", COMPrincipal::SetThreadToken)
-FCFuncEnd()
-#endif // !FEATURE_CORECLR
-
-#ifdef FEATURE_CAS_POLICY
-FCFuncStart(gEvidenceFuncs)
-FCFuncEnd()
-
-FCFuncStart(gAssemblyEvidenceFactoryFuncs)
-    QCFuncElement("GetAssemblyPermissionRequests", SecurityPolicy::GetAssemblyPermissionRequests)
-    QCFuncElement("GetStrongNameInformation", SecurityPolicy::GetStrongNameInformation)
-FCFuncEnd()
-
-FCFuncStart(gPEFileEvidenceFactoryFuncs)
-    QCFuncElement("GetAssemblySuppliedEvidence", SecurityPolicy::GetAssemblySuppliedEvidence)
-    QCFuncElement("GetLocationEvidence", SecurityPolicy::GetLocationEvidence)
-    QCFuncElement("GetPublisherCertificate", SecurityPolicy::GetPublisherCertificate)
-    QCFuncElement("FireEvidenceGeneratedEvent", SecurityPolicy::FireEvidenceGeneratedEvent)
-FCFuncEnd()
-
-FCFuncStart(gHostExecutionContextManagerFuncs)
-    FCFuncElement("ReleaseHostSecurityContext", HostExecutionContextManager::ReleaseSecurityContext)
-    FCFuncElement("CloneHostSecurityContext", HostExecutionContextManager::CloneSecurityContext)
-    FCFuncElement("CaptureHostSecurityContext", HostExecutionContextManager::CaptureSecurityContext)
-    FCFuncElement("SetHostSecurityContext", HostExecutionContextManager::SetSecurityContext)
-    FCFuncElement("HostSecurityManagerPresent", HostExecutionContextManager::HostPresent)
-FCFuncEnd()
-#endif // FEATURE_CAS_POLICY
-
-#if defined(FEATURE_ISOSTORE) && !defined(FEATURE_ISOSTORE_LIGHT)
-FCFuncStart(gIsolatedStorage)
-    QCFuncElement("GetCaller", COMIsolatedStorage::GetCaller)
-FCFuncEnd()
-
-FCFuncStart(gIsolatedStorageFile)
-    QCFuncElement("GetRootDir", COMIsolatedStorageFile::GetRootDir)
-    QCFuncElement("GetQuota", COMIsolatedStorageFile::GetQuota)
-    QCFuncElement("SetQuota", COMIsolatedStorageFile::SetQuota)
-    QCFuncElement("Reserve", COMIsolatedStorageFile::Reserve)
-    QCFuncElement("GetUsage", COMIsolatedStorageFile::GetUsage)
-    QCFuncElement("Open", COMIsolatedStorageFile::Open)
-    QCFuncElement("Lock", COMIsolatedStorageFile::Lock)
-    QCFuncElement("CreateDirectoryWithDacl", COMIsolatedStorageFile::CreateDirectoryWithDacl)
-FCFuncEnd()
-
-FCFuncStart(gIsolatedStorageFileHandle)
-    QCFuncElement("Close", COMIsolatedStorageFile::Close)
-FCFuncEnd()
-#endif // FEATURE_ISOSTORE && !FEATURE_ISOSTORE_LIGHT
-
 FCFuncStart(gTypeLoadExceptionFuncs)
     QCFuncElement("GetTypeLoadExceptionMessage", GetTypeLoadExceptionMessage)
 FCFuncEnd()
@@ -1812,13 +1223,11 @@ FCFuncEnd()
 
 FCFuncStart(gVarArgFuncs)
     FCFuncElementSig(COR_CTOR_METHOD_NAME, &gsig_IM_IntPtr_PtrVoid_RetVoid, VarArgsNative::Init2)
-#ifndef FEATURE_CORECLR
     FCFuncElementSig(COR_CTOR_METHOD_NAME, &gsig_IM_IntPtr_RetVoid, VarArgsNative::Init)
     FCFuncElement("GetRemainingCount", VarArgsNative::GetRemainingCount)
     FCFuncElement("_GetNextArgType", VarArgsNative::GetNextArgType)
     FCFuncElement("FCallGetNextArg", VarArgsNative::DoGetNextArg)
     FCFuncElement("InternalGetNextArg", VarArgsNative::GetNextArg2)
-#endif // FEATURE_CORECLR
 FCFuncEnd()
 
 FCFuncStart(gMonitorFuncs)
@@ -1844,13 +1253,7 @@ FCFuncStart(gCompilerFuncs)
     FCIntrinsic("InitializeArray", ArrayNative::InitializeArray, CORINFO_INTRINSIC_InitializeArray)
     FCFuncElement("_RunClassConstructor", ReflectionInvocation::RunClassConstructor)
     FCFuncElement("_RunModuleConstructor", ReflectionInvocation::RunModuleConstructor)
-#ifndef FEATURE_CORECLR
-    FCFuncElement("_PrepareMethod", ReflectionInvocation::PrepareMethod)
-#endif // !FEATURE_CORECLR
     QCFuncElement("_CompileMethod", ReflectionInvocation::CompileMethod)
-#ifndef FEATURE_CORECLR
-    FCFuncElement("PrepareDelegate", ReflectionInvocation::PrepareDelegate)
-#endif // !FEATURE_CORECLR
     FCFuncElement("PrepareContractedDelegate", ReflectionInvocation::PrepareContractedDelegate)
     FCFuncElement("ProbeForSufficientStack", ReflectionInvocation::ProbeForSufficientStack)
     FCFuncElement("ExecuteCodeWithGuaranteedCleanup", ReflectionInvocation::ExecuteCodeWithGuaranteedCleanup)
@@ -1861,9 +1264,7 @@ FCFuncStart(gCompilerFuncs)
 FCFuncEnd()
 
 FCFuncStart(gContextSynchronizationFuncs)
-#ifdef FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
     FCFuncElement("WaitHelperNative", SynchronizationContextNative::WaitHelper)
-#endif // #ifdef FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
 #ifdef FEATURE_APPX
     QCFuncElement("GetWinRTDispatcherForCurrentThread", SynchronizationContextNative::GetWinRTDispatcherForCurrentThread)
 #endif
@@ -1948,20 +1349,12 @@ FCFuncStart(gMngdRefCustomMarshalerFuncs)
 FCFuncEnd()
 
 FCFuncStart(gStubHelperFuncs)
-#ifndef FEATURE_CORECLR
-#ifndef _WIN64
-    FCFuncElement("GetFinalStubTarget", StubHelpers::GetFinalStubTarget)
-#endif // !_WIN64
-    FCFuncElement("DemandPermission", StubHelpers::DemandPermission)
-#endif // !FEATURE_CORECLR
     FCFuncElement("IsQCall", StubHelpers::IsQCall)
     FCFuncElement("InitDeclaringType", StubHelpers::InitDeclaringType)
     FCIntrinsic("GetNDirectTarget", StubHelpers::GetNDirectTarget, CORINFO_INTRINSIC_StubHelpers_GetNDirectTarget)
     FCFuncElement("GetDelegateTarget", StubHelpers::GetDelegateTarget)
     FCFuncElement("SetLastError", StubHelpers::SetLastError)
-#ifdef FEATURE_CORECLR
     FCFuncElement("ClearLastError", StubHelpers::ClearLastError)
-#endif
     FCFuncElement("ThrowInteropParamException", StubHelpers::ThrowInteropParamException)
     FCFuncElement("InternalGetHRExceptionObject", StubHelpers::GetHRExceptionObject)
 #ifdef FEATURE_COMINTEROP
@@ -2029,22 +1422,8 @@ FCFuncStart(gGCHandleFuncs)
     FCFuncElement("InternalCompareExchange", MarshalNative::GCHandleInternalCompareExchange)
     FCFuncElement("InternalAddrOfPinnedObject", MarshalNative::GCHandleInternalAddrOfPinnedObject)
     FCFuncElement("InternalCheckDomain", MarshalNative::GCHandleInternalCheckDomain)
-#ifndef FEATURE_CORECLR
-    FCFuncElement("InternalGetHandleType", MarshalNative::GCHandleInternalGetHandleType)
-#endif
-FCFuncEnd()
-
-#ifndef FEATURE_CORECLR
-FCFuncStart(gConfigHelper)
-    FCFuncElement("RunParser", ConfigNative::RunParser)
 FCFuncEnd()
-#endif // FEATURE_CORECLR
 
-#ifndef FEATURE_CORECLR
-FCFuncStart(gConsoleFuncs)    
-    QCFuncElement("GetTitleNative", ConsoleNative::GetTitle) 
-FCFuncEnd()
-#endif // ifndef FEATURE_CORECLR
 
 FCFuncStart(gVersioningHelperFuncs)
     FCFuncElement("GetRuntimeId", GetRuntimeId_Wrapper)
@@ -2055,12 +1434,6 @@ FCFuncStart(gStreamFuncs)
     FCFuncElement("HasOverriddenBeginEndWrite", StreamNative::HasOverriddenBeginEndWrite)
 FCFuncEnd()
 
-#ifndef FEATURE_CORECLR
-FCFuncStart(gConsoleStreamFuncs)
-    FCFuncElement("WaitForAvailableConsoleInput", ConsoleStreamHelper::WaitForAvailableConsoleInput)
-FCFuncEnd()
-#endif
-
 #if defined(FEATURE_COMINTEROP) && defined(FEATURE_REFLECTION_ONLY_LOAD)
 FCFuncStart(gWindowsRuntimeMetadata)
     QCFuncElement("nResolveNamespace", CLRPrivTypeCacheReflectionOnlyWinRT::ResolveNamespace)
@@ -2143,57 +1516,24 @@ FCFuncEnd()
 
 FCClassElement("AppDomain", "System", gAppDomainFuncs)
 FCClassElement("AppDomainManager", "System", gAppDomainManagerFuncs)
-#ifdef FEATURE_FUSION
-FCClassElement("AppDomainSetup", "System", gAppDomainSetupFuncs)
-#endif // FEATURE_FUSION
 FCClassElement("ArgIterator", "System", gVarArgFuncs)
 FCClassElement("Array", "System", gArrayFuncs)
 FCClassElement("ArrayWithOffset", "System.Runtime.InteropServices", gArrayWithOffsetFuncs)
 FCClassElement("AssemblyBuilder", "System.Reflection.Emit", gAssemblyBuilderFuncs)
-#ifdef FEATURE_CAS_POLICY
-FCClassElement("AssemblyEvidenceFactory", "System.Security.Policy", gAssemblyEvidenceFactoryFuncs)
-#endif // FEATURE_CAS_POLICY
 
-#ifdef FEATURE_CORECLR
 FCClassElement("AssemblyExtensions", "System.Reflection.Metadata", gAssemblyExtensionsFuncs)
-#endif
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 FCClassElement("AssemblyLoadContext", "System.Runtime.Loader", gAssemblyLoadContextFuncs)
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
 FCClassElement("AssemblyName", "System.Reflection", gAssemblyNameFuncs)
 FCClassElement("Assert", "System.Diagnostics", gDiagnosticsAssert)
 FCClassElement("BCLDebug", "System", gBCLDebugFuncs)
-#ifndef FEATURE_CORECLR
-FCClassElement("BaseConfigHandler", "System", gConfigHelper)
-#endif // FEATURE_CORECLR
 FCClassElement("Buffer", "System", gBufferFuncs)
-#ifndef FEATURE_CORECLR
-// Since the 2nd letter of the classname is capital, we need to sort this before all class names
-// that start with Cx where x is any small letter (strcmp is used for verification).
-FCClassElement("CLRConfig", "System", gCLRConfigFuncs)
-#endif // FEATURE_CORECLR
 #if !defined(FEATURE_COREFX_GLOBALIZATION)
 FCClassElement("CalendarData", "System.Globalization", gCalendarDataFuncs)
 #endif // !defined(FEATURE_COREFX_GLOBALIZATION)
-#ifndef FEATURE_CORECLR
-FCClassElement("ChannelServices", "System.Runtime.Remoting.Channels", gChannelServicesFuncs)
-#endif // FEATURE_CORECLR
-#ifdef FEATURE_CAS_POLICY
-FCClassElement("CodeAccessSecurityEngine", "System.Security", gCodeAccessSecurityEngineFuncs)
-#endif
 FCClassElement("CompareInfo", "System.Globalization", gCompareInfoFuncs)
 FCClassElement("CompatibilitySwitch", "System.Runtime.Versioning", gCompatibilitySwitchFuncs)
-#ifdef FEATURE_COMPRESSEDSTACK    
-FCClassElement("CompressedStack", "System.Threading", gCompressedStackFuncs)
-#endif // FEATURE_COMPRESSEDSTACK    
-#ifdef FEATURE_CAS_POLICY
-FCClassElement("Config", "System.Security.Util", gPolicyConfigFuncs)
-#endif // FEATURE_CAS_POLICY
-#ifndef FEATURE_CORECLR
-FCClassElement("Console", "System", gConsoleFuncs)
-#endif // ifndef FEATURE_CORECLR
 #ifdef FEATURE_REMOTING    
 FCClassElement("Context", "System.Runtime.Remoting.Contexts", gContextFuncs)
 #endif
@@ -2212,9 +1552,6 @@ FCClassElement("Decimal", "System", gDecimalFuncs)
 FCClassElement("DefaultBinder", "System", gCOMDefaultBinderFuncs)
 FCClassElement("Delegate", "System", gDelegateFuncs)
 FCClassElement("DependentHandle", "System.Runtime.CompilerServices", gDependentHandleFuncs)
-#ifdef FEATURE_COMPRESSEDSTACK
-FCClassElement("DomainCompressedStack", "System.Threading", gDomainCompressedStackFuncs)    
-#endif // FEATURE_COMPRESSEDSTACK    
 #if !defined(FEATURE_COREFX_GLOBALIZATION)
 FCClassElement("EncodingTable", "System.Globalization", gEncodingTableFuncs)
 #endif // !defined(FEATURE_COREFX_GLOBALIZATION)
@@ -2224,20 +1561,10 @@ FCClassElement("Environment", "System", gEnvironmentFuncs)
 FCClassElement("EventArgsMarshaler", "System.StubHelpers", gEventArgsMarshalerFuncs)
 #endif // FEATURE_COMINTEROP
 FCClassElement("Exception", "System", gExceptionFuncs)
-#if defined(FEATURE_COMINTEROP) && !defined(FEATURE_CORECLR)
-FCClassElement("ExtensibleClassFactory", "System.Runtime.InteropServices", gExtensibleClassFactoryFuncs)
-#endif
-FCClassElement("FileIOAccess", "System.Security.Permissions", gCOMFileIOAccessFuncs)
 FCClassElement("FileLoadException", "System.IO", gFileLoadExceptionFuncs)
 FCClassElement("FormatterServices", "System.Runtime.Serialization", gSerializationFuncs)
-#ifdef FEATURE_CAS_POLICY
-FCClassElement("FrameSecurityDescriptor", "System.Security", gFrameSecurityDescriptorFuncs)
-#endif
 FCClassElement("GC", "System", gGCInterfaceFuncs)
 FCClassElement("GCHandle", "System.Runtime.InteropServices", gGCHandleFuncs)
-#ifdef FEATURE_CAS_POLICY
-FCClassElement("HostExecutionContextManager", "System.Threading", gHostExecutionContextManagerFuncs)
-#endif // FEATURE_CAS_POLICY
 #ifdef FEATURE_COMINTEROP
 FCClassElement("IEnumerable", "System.Collections", gStdMngIEnumerableFuncs)
 FCClassElement("IEnumerator", "System.Collections", gStdMngIEnumeratorFuncs)
@@ -2251,10 +1578,6 @@ FCClassElement("IReflect", "System.Reflection", gStdMngIReflectFuncs)
 FCClassElement("InterfaceMarshaler", "System.StubHelpers", gInterfaceMarshalerFuncs)
 #endif
 FCClassElement("Interlocked", "System.Threading", gInterlockedFuncs)
-#if defined(FEATURE_ISOSTORE) && !defined(FEATURE_ISOSTORE_LIGHT)
-FCClassElement("IsolatedStorage", "System.IO.IsolatedStorage", gIsolatedStorage)
-FCClassElement("IsolatedStorageFile", "System.IO.IsolatedStorage", gIsolatedStorageFile)
-#endif // FEATURE_ISOSTORE && !FEATURE_ISOSTORE_LIGHT
 FCClassElement("JitHelpers", "System.Runtime.CompilerServices", gJitHelpers)
 FCClassElement("LoaderAllocatorScout", "System.Reflection", gLoaderAllocatorFuncs)
 FCClassElement("Log", "System.Diagnostics", gDiagnosticsLog)
@@ -2300,33 +1623,10 @@ FCClassElement("Object", "System", gObjectFuncs)
 FCClassElement("ObjectMarshaler", "System.StubHelpers", gObjectMarshalerFuncs)
 #endif
 FCClassElement("OverlappedData", "System.Threading", gOverlappedFuncs)
-#ifdef FEATURE_CAS_POLICY
-FCClassElement("PEFileEvidenceFactory", "System.Security.Policy", gPEFileEvidenceFactoryFuncs)
-#endif // FEATURE_CAS_POLICY
 FCClassElement("ParseNumbers", "System", gParseNumbersFuncs)
-#ifndef FEATURE_CORECLR
-FCClassElement("PasswordDeriveBytes", "System.Security.Cryptography", gPasswordDeriveBytesFuncs)
-#endif
-#ifdef FEATURE_CAS_POLICY
-FCClassElement("PolicyManager", "System.Security", gPolicyManagerFuncs)
-#endif    
 
-#if defined(FEATURE_MULTICOREJIT) && !defined(FEATURE_CORECLR)
-FCClassElement("ProfileOptimization", "System.Runtime", gProfileOptimizationFuncs)
-#endif  // defined(FEATURE_MULTICOREJIT) && !defined(FEATURE_CORECLR)
 
-#ifdef FEATURE_CAS_POLICY
-FCClassElement("PseudoCustomAttribute", "System.Reflection", gPseudoCustomAttribute)
-#endif
-#ifdef FEATURE_CORECLR
 FCClassElement("PunkSafeHandle", "System.Reflection.Emit", gSymWrapperCodePunkSafeHandleFuncs)
-#endif
-#ifndef FEATURE_CORECLR
-FCClassElement("RNGCryptoServiceProvider", "System.Security.Cryptography", gRNGCryptoServiceProviderFuncs)
-#endif
-#ifdef FEATURE_CRYPTO
-FCClassElement("RSACryptoServiceProvider", "System.Security.Cryptography", gRSACryptoServiceProviderFuncs)
-#endif
 #ifdef FEATURE_RWLOCK
 FCClassElement("ReaderWriterLock", "System.Threading", gRWLockFuncs)
 #endif  // FEATURE_RWLOCK
@@ -2343,9 +1643,6 @@ FCClassElement("RegistrationServices", "System.Runtime.InteropServices", gRegist
 #ifdef FEATURE_REMOTING
 FCClassElement("RemotingServices", "System.Runtime.Remoting", gRemotingFuncs)
 #endif
-#if defined(FEATURE_CRYPTO)
-FCClassElement("Rfc2898DeriveBytes", "System.Security.Cryptography", gRfc2898DeriveBytesFuncs)
-#endif
 FCClassElement("RtFieldInfo", "System.Reflection", gRuntimeFieldInfoFuncs)
 FCClassElement("RuntimeAssembly", "System.Reflection", gAssemblyFuncs)
 #ifdef FEATURE_COMINTEROP    
@@ -2360,42 +1657,10 @@ FCClassElement("RuntimeThread", "Internal.Runtime.Augments", gRuntimeThreadFuncs
 FCClassElement("RuntimeType", "System", gSystem_RuntimeType)
 FCClassElement("RuntimeTypeHandle", "System", gCOMTypeHandleFuncs)
 FCClassElement("SafeBuffer", "System.Runtime.InteropServices", gSafeBufferFuncs)
-#ifdef FEATURE_X509
-FCClassElement("SafeCertContextHandle", "System.Security.Cryptography.X509Certificates", gX509SafeCertContextHandleFuncs)
-#ifndef FEATURE_CORECLR
-FCClassElement("SafeCertStoreHandle", "System.Security.Cryptography.X509Certificates", gX509SafeCertStoreHandleFuncs)
-#endif // FEATURE_CORECLR
-#endif // FEATURE_X509
 FCClassElement("SafeHandle", "System.Runtime.InteropServices", gSafeHandleFuncs)
-#ifdef FEATURE_CRYPTO
-FCClassElement("SafeHashHandle", "System.Security.Cryptography", gSafeHashHandleFuncs)
-#endif // FEATURE_CRYPTO
-#if defined(FEATURE_ISOSTORE) && !defined(FEATURE_ISOSTORE_LIGHT)
-FCClassElement("SafeIsolatedStorageFileHandle", "System.IO.IsolatedStorage", gIsolatedStorageFileHandle)
-#endif // FEATURE_ISOSTORE && !FEATURE_ISOSTORE_LIGHT
-#ifdef FEATURE_CRYPTO
-FCClassElement("SafeKeyHandle", "System.Security.Cryptography", gSafeKeyHandleFuncs)
-#endif
-#ifdef FEATURE_CAS_POLICY
-FCClassElement("SafePEFileHandle", "Microsoft.Win32.SafeHandles", gPEFileFuncs)
-#endif // FEATURE_CAS_POLICY
-#ifdef FEATURE_CRYPTO
-FCClassElement("SafeProvHandle", "System.Security.Cryptography", gSafeProvHandleFuncs)
-#endif
 FCClassElement("SafeTypeNameParserHandle", "System", gSafeTypeNameParserHandle)
 
-#if defined(FEATURE_IMPERSONATION) || defined(FEATURE_COMPRESSEDSTACK)
-FCClassElement("SecurityContext", "System.Security", gCOMSecurityContextFuncs)
-#endif // defined(FEATURE_IMPERSONATION) || defined(FEATURE_COMPRESSEDSTACK)
-FCClassElement("SecurityContextFrame", "System.Reflection", gSecurityContextFrameFuncs)
-FCClassElement("SecurityManager", "System.Security", gCOMSecurityManagerFuncs)
-#ifdef FEATURE_CAS_POLICY
-FCClassElement("SecurityRuntime", "System.Security", gCOMSecurityRuntimeFuncs)
-#endif
 FCClassElement("Signature", "System", gSignatureNative)
-#ifndef FEATURE_CORECLR
-FCClassElement("SizedReference", "System", gSizedRefHandleFuncs)
-#endif // !FEATURE_CORECLR
 #ifdef FEATURE_REMOTING    
 FCClassElement("StackBuilderSink", "System.Runtime.Remoting.Messaging", gStackBuilderSinkFuncs)
 #endif    
@@ -2403,37 +1668,24 @@ FCClassElement("StackTrace", "System.Diagnostics", gDiagnosticsStackTrace)
 FCClassElement("Stream", "System.IO", gStreamFuncs)
 FCClassElement("String", "System", gStringFuncs)
 FCClassElement("StringBuilder", "System.Text", gStringBufferFuncs)
-FCClassElement("StringExpressionSet", "System.Security.Util", gCOMStringExpressionSetFuncs)
 FCClassElement("StubHelpers", "System.StubHelpers", gStubHelperFuncs)
-#if defined(FEATURE_SYNCHRONIZATIONCONTEXT_WAIT) || defined(FEATURE_APPX)
 FCClassElement("SynchronizationContext", "System.Threading", gContextSynchronizationFuncs)
-#endif // FEATURE_SYNCHRONIZATIONCONTEXT_WAIT || FEATURE_APPX
 #if !defined(FEATURE_COREFX_GLOBALIZATION)
 FCClassElement("TextInfo", "System.Globalization", gTextInfoFuncs)
 #endif // !defined(FEATURE_COREFX_GLOBALIZATION)
 FCClassElement("Thread", "System.Threading", gThreadFuncs)
 FCClassElement("ThreadPool", "System.Threading", gThreadPoolFuncs)
-#ifndef FEATURE_CORECLR
-FCClassElement("TimeSpan", "System", gTimeSpanFuncs)
-#endif // !FEATURE_CORECLR
 FCClassElement("TimerQueue", "System.Threading", gTimerFuncs)
 FCClassElement("Type", "System", gSystem_Type)
 FCClassElement("TypeBuilder", "System.Reflection.Emit", gCOMClassWriter)
-#ifdef FEATURE_COMINTEROP_TLB_SUPPORT
-FCClassElement("TypeLibConverter", "System.Runtime.InteropServices", gTypeLibConverterFuncs)
-#endif
 FCClassElement("TypeLoadException", "System", gTypeLoadExceptionFuncs)
 FCClassElement("TypeNameBuilder", "System.Reflection.Emit", gTypeNameBuilder)
 FCClassElement("TypeNameParser", "System", gTypeNameParser)
 FCClassElement("TypedReference", "System", gTypedReferenceFuncs)
-FCClassElement("URLString", "System.Security.Util", gCOMUrlStringFuncs)
 #ifdef FEATURE_COMINTEROP
 FCClassElement("UriMarshaler", "System.StubHelpers", gUriMarshalerFuncs)
 #endif
 FCClassElement("Utf8String", "System", gUtf8String)
-#ifdef FEATURE_CRYPTO
-FCClassElement("Utils", "System.Security.Cryptography", gCryptographyUtilsFuncs)
-#endif
 FCClassElement("ValueClassMarshaler", "System.StubHelpers", gValueClassMarshalerFuncs)
 FCClassElement("ValueType", "System", gValueTypeFuncs)
 #ifdef FEATURE_COMINTEROP
@@ -2444,10 +1696,6 @@ FCClassElement("WaitHandle", "System.Threading", gWaitHandleFuncs)
 FCClassElement("WeakReference", "System", gWeakReferenceFuncs)
 FCClassElement("WeakReference`1", "System", gWeakReferenceOfTFuncs)
 
-#ifndef FEATURE_CORECLR
-FCClassElement("Win32", "System.Security.Principal", gPrincipalFuncs)
-#endif
-
 #ifdef FEATURE_COMINTEROP
 FCClassElement("WinRTTypeNameConverter", "System.StubHelpers", gWinRTTypeNameConverterFuncs)
 #endif // FEATURE_COMINTEROP
@@ -2456,27 +1704,14 @@ FCClassElement("WinRTTypeNameConverter", "System.StubHelpers", gWinRTTypeNameCon
 FCClassElement("WindowsRuntimeBufferHelper", "System.Runtime.InteropServices.WindowsRuntime", gWindowsRuntimeBufferHelperFuncs)                    
 #endif
 
-#ifndef FEATURE_CORECLR
-FCClassElement("WindowsRuntimeDesignerContext", "System.Runtime.DesignerServices", gWindowsRuntimeContextFuncs)
-#endif
 
 #if defined(FEATURE_COMINTEROP) && defined(FEATURE_REFLECTION_ONLY_LOAD)
 FCClassElement("WindowsRuntimeMetadata", "System.Runtime.InteropServices.WindowsRuntime", gWindowsRuntimeMetadata)
 #endif
 
-#ifdef FEATURE_X509
-FCClassElement("X509Utils", "System.Security.Cryptography.X509Certificates", gX509CertificateFuncs)
-#endif // FEATURE_X509
 #if defined(FEATURE_EVENTSOURCE_XPLAT)
 FCClassElement("XplatEventLogger", "System.Diagnostics.Tracing", gEventLogger)
 #endif //defined(FEATURE_EVENTSOURCE_XPLAT)
-#ifdef FEATURE_CAS_POLICY
-FCClassElement("Zone", "System.Security.Policy", gCOMSecurityZone)
-#endif // FEATURE_CAS_POLICY
-#ifndef FEATURE_CORECLR
-FCClassElement("__ConsoleStream", "System.IO", gConsoleStreamFuncs)
-#endif
-
 
 #undef FCFuncElement
 #undef FCFuncElementSig
diff --git a/src/vm/eeconfig.cpp b/src/vm/eeconfig.cpp
index 91b9e64a78..f7301531b4 100644
--- a/src/vm/eeconfig.cpp
+++ b/src/vm/eeconfig.cpp
@@ -16,14 +16,6 @@
 #endif
 #include "eeconfig.h"
 #include "method.hpp"
-#ifndef FEATURE_CORECLR
-#include <xmlparser.h>
-#include <mscorcfg.h>
-#include "eeconfigfactory.h"
-#endif
-#ifdef FEATURE_FUSION
-#include "fusionsetup.h"
-#endif
 #include "eventtrace.h"
 #include "eehash.h"
 #include "eemessagebox.h"
@@ -33,9 +25,7 @@
 #ifdef FEATURE_WIN_DB_APPCOMPAT
 #include "QuirksApi.h"
 #endif
-#ifdef FEATURE_CORECLR
 #include "configuration.h"
-#endif
 
 using namespace clr;
 
@@ -294,9 +284,7 @@ HRESULT EEConfig::Init()
     
     INDEBUG(fStressLog = true;)
 
-#ifdef FEATURE_CORECLR
     fVerifyAllOnLoad = false;
-#endif
 #ifdef _DEBUG
     fExpandAllOnLoad = false;
     fDebuggable = false;
@@ -798,14 +786,12 @@ HRESULT EEConfig::sync()
     }
 
     bool gcConcurrentWasForced = false;
-#ifdef FEATURE_CORECLR
     // The CLRConfig value for UNSUPPORTED_gcConcurrent defaults to -1, and treats any
     // positive value as 'forcing' concurrent GC to be on. Because the standard logic
     // for mapping a DWORD CLRConfig to a boolean configuration treats -1 as true (just
     // like any other nonzero value), we will explicitly check the DWORD later if this
     // check returns false.
     gcConcurrentWasForced = Configuration::GetKnobBooleanValue(W("System.GC.Concurrent"), false);
-#endif
 
     int gcConcurrentConfigVal = 0;
     if (!gcConcurrentWasForced)
@@ -975,14 +961,9 @@ HRESULT EEConfig::sync()
 #endif
 
     iGCForceCompact     =  GetConfigDWORD_DontUse_(CLRConfig::UNSUPPORTED_gcForceCompact, iGCForceCompact);
-#ifdef FEATURE_CORECLR
     iGCNoAffinitize = Configuration::GetKnobBooleanValue(W("System.GC.NoAffinitize"), 
                                                          CLRConfig::UNSUPPORTED_GCNoAffinitize);
     iGCHeapCount = Configuration::GetKnobDWORDValue(W("System.GC.HeapCount"), CLRConfig::UNSUPPORTED_GCHeapCount);
-#else
-    iGCNoAffinitize = CLRConfig::GetConfigValue(CLRConfig::UNSUPPORTED_GCNoAffinitize);
-    iGCHeapCount = CLRConfig::GetConfigValue(CLRConfig::UNSUPPORTED_GCHeapCount);
-#endif
 
     fStressLog        =  GetConfigDWORD_DontUse_(CLRConfig::UNSUPPORTED_StressLog, fStressLog) != 0;
     fForceEnc         =  GetConfigDWORD_DontUse_(CLRConfig::UNSUPPORTED_ForceEnc, fForceEnc) != 0;
@@ -1084,26 +1065,6 @@ HRESULT EEConfig::sync()
         g_IBCLogger.DisableAllInstr();
 #endif
 
-#ifdef FEATURE_FUSION
-    IfFailRet(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_ZapSet, (LPWSTR*)&pZapSet));
-
-    m_fFreepZapSet = true;
-    
-    if (pZapSet == NULL)
-    {
-        m_fFreepZapSet = false;
-        pZapSet = W("");
-    }
-    if (wcslen(pZapSet) > 3)
-    {
-        _ASSERTE(!"Zap Set String must be less than 3 chars");
-        delete[] pZapSet;
-        m_fFreepZapSet = false;
-        pZapSet = W("");
-    }
-
-    fNgenBindOptimizeNonGac = CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_NgenBind_OptimizeNonGac) != 0;
-#endif
 
     dwDisableStackwalkCache = GetConfigDWORD_DontUse_(CLRConfig::EXTERNAL_DisableStackwalkCache, dwDisableStackwalkCache);
 
@@ -1137,59 +1098,6 @@ HRESULT EEConfig::sync()
     fPInvokeRestoreEsp = CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_Jit_NetFx40PInvokeStackResilience);
 #endif
 
-#ifndef FEATURE_CORECLR
-    // These two values respect the Shim's policy of favoring config files over registry settings.
-    fLegacyNullReferenceExceptionPolicy = (GetConfigDWORDFavoringConfigFile_DontUse_(CLRConfig::UNSUPPORTED_legacyNullReferenceExceptionPolicy,
-                                                                            fLegacyNullReferenceExceptionPolicy) != 0);
-    fLegacyUnhandledExceptionPolicy = (GetConfigDWORDFavoringConfigFile_DontUse_(CLRConfig::UNSUPPORTED_legacyUnhandledExceptionPolicy,
-                                                                        fLegacyUnhandledExceptionPolicy) != 0);
-
-#ifdef FEATURE_CORRUPTING_EXCEPTIONS
-    // Check if the user has overriden how Corrupted State Exceptions (CSE) will be handled. If the 
-    // <runtime> section of app.exe.config has "legacyCorruptedStateExceptionsPolicy" set to 1, then
-    // V4 runtime will treat CSE in the same fashion as V2.
-    fLegacyCorruptedStateExceptionsPolicy = (CLRConfig::GetConfigValue(CLRConfig::UNSUPPORTED_legacyCorruptedStateExceptionsPolicy) != 0);
-#endif // FEATURE_CORRUPTING_EXCEPTIONS
-
-    fLegacyVirtualMethodCallVerification = (GetConfigDWORDFavoringConfigFile_DontUse_(CLRConfig::EXTERNAL_legacyVirtualMethodCallVerification,
-                                                                             fLegacyVirtualMethodCallVerification,
-                                                                             REGUTIL::COR_CONFIG_ALL, TRUE,
-                                                                             CONFIG_SYSTEMONLY) != 0);
-
-    fLegacyApartmentInitPolicy = (GetConfigDWORDFavoringConfigFile_DontUse_(CLRConfig::EXTERNAL_legacyApartmentInitPolicy, 
-                                                                    fLegacyApartmentInitPolicy) != 0);
-
-    fLegacyComHierarchyVisibility = (GetConfigDWORDFavoringConfigFile_DontUse_(CLRConfig::EXTERNAL_legacyComHierarchyVisibility, 
-                                                                    fLegacyComHierarchyVisibility) != 0);
-
-    fLegacyComVTableLayout = (GetConfigDWORDFavoringConfigFile_DontUse_(CLRConfig::EXTERNAL_legacyComVTableLayout, 
-                                                                    fLegacyComVTableLayout) != 0);
-    fNewComVTableLayout = (GetConfigDWORDFavoringConfigFile_DontUse_(CLRConfig::EXTERNAL_newComVTableLayout, 
-                                                                    fNewComVTableLayout) != 0);
-        
-    if (CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_legacyImpersonationPolicy) != 0)
-        iImpersonationPolicy = IMP_NOFLOW;
-    else if (CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_alwaysFlowImpersonationPolicy) != 0)
-        iImpersonationPolicy = IMP_ALWAYSFLOW;
-
-    fLegacyLoadMscorsnOnStartup = (GetConfigDWORDFavoringConfigFile_DontUse_(CLRConfig::UNSUPPORTED_legacyLoadMscorsnOnStartup, 
-                                                                    fLegacyLoadMscorsnOnStartup) != 0);
-    fBypassStrongNameVerification = (GetConfigDWORDFavoringConfigFile_DontUse_(W("bypassTrustedAppStrongNames"), fBypassStrongNameVerification) != 0) &&  // App opted in
-                                    (GetConfigDWORD_DontUse_(SN_CONFIG_BYPASS_POLICY_W, TRUE, REGUTIL::COR_CONFIG_MACHINE) != 0);                        // And the machine policy allows for bypass
-    fGeneratePublisherEvidence = (GetConfigDWORDFavoringConfigFile_DontUse_(CLRConfig::EXTERNAL_generatePublisherEvidence, fGeneratePublisherEvidence) != 0);
-    fEnforceFIPSPolicy = (GetConfigDWORDFavoringConfigFile_DontUse_(CLRConfig::EXTERNAL_enforceFIPSPolicy, fEnforceFIPSPolicy) != 0);
-    fLegacyHMACMode = (GetConfigDWORDFavoringConfigFile_DontUse_(CLRConfig::EXTERNAL_legacyHMACMode, fLegacyHMACMode) != 0);
-
-    fCacheBindingFailures = !(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_disableCachingBindingFailures));
-    fUseLegacyIdentityFormat = 
-#ifdef FEATURE_APPX
-                               AppX::IsAppXProcess() ||
-#endif
-                               (CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_useLegacyIdentityFormat) != 0);
-    fDisableFusionUpdatesFromADManager = (CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_disableFusionUpdatesFromADManager) != 0);
-    fDisableCommitThreadStack = (GetConfigDWORDFavoringConfigFile_DontUse_(CLRConfig::EXTERNAL_disableCommitThreadStack, fDisableCommitThreadStack) != 0);
-    fProbeForStackOverflow = !(CLRConfig::GetConfigValue(CLRConfig::UNSUPPORTED_disableStackOverflowProbing));
-#endif // FEATURE_CORECLR
     
 #ifdef _DEBUG
     fDebuggable         = (GetConfigDWORD_DontUse_(CLRConfig::INTERNAL_JitDebuggable,      fDebuggable)         != 0);
@@ -1264,26 +1172,13 @@ HRESULT EEConfig::sync()
     fEnableRCWCleanupOnSTAShutdown = (CLRConfig::GetConfigValue(CLRConfig::INTERNAL_EnableRCWCleanupOnSTAShutdown) != 0);
 #endif // FEATURE_COMINTEROP
 
-#ifdef FEATURE_CORECLR
     //Eager verification of all assemblies.
     fVerifyAllOnLoad = (GetConfigDWORD_DontUse_(CLRConfig::EXTERNAL_VerifyAllOnLoad, fVerifyAllOnLoad) != 0);
-#endif //FEATURE_CORECLR
 
 #ifdef _DEBUG
     fExpandAllOnLoad = (GetConfigDWORD_DontUse_(CLRConfig::INTERNAL_ExpandAllOnLoad, fExpandAllOnLoad) != 0);
 #endif //_DEBUG
 
-#ifdef FEATURE_FUSION
-    if(g_pConfig) {
-        LPCWSTR result = NULL;
-        if(SUCCEEDED(g_pConfig->GetConfiguration_DontUse_(CLRConfig::EXTERNAL_developerInstallation, CONFIG_SYSTEM, &result)) && result)
-        {
-            // <TODO> CTS, add addtional checks to ensure this is an SDK installation </TODO>
-            if(SString::_wcsicmp(result, W("true")) == 0)
-                m_fDeveloperInstallation = true;
-        }
-    }
-#endif
 
 #ifdef AD_NO_UNLOAD
     fAppDomainUnload = (CLRConfig::GetConfigValue(CLRConfig::INTERNAL_AppDomainNoUnload) == 0);
@@ -1367,12 +1262,6 @@ HRESULT EEConfig::sync()
     m_fInteropLogArguments = (CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_InteropLogArguments) != 0);
 
 #ifdef FEATURE_PREJIT
-#ifndef FEATURE_CORECLR
-    DWORD iNgenHardBindOverride = GetConfigDWORD_DontUse_(CLRConfig::EXTERNAL_HardPrejitEnabled, iNgenHardBind);
-    _ASSERTE(iNgenHardBindOverride < NGEN_HARD_BIND_COUNT);
-    if (iNgenHardBindOverride < NGEN_HARD_BIND_COUNT)
-        iNgenHardBind = NgenHardBindType(iNgenHardBindOverride);
-#endif
 #ifdef _DEBUG
     dwNgenForceFailureMask  = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_NgenForceFailureMask);
     dwNgenForceFailureCount = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_NgenForceFailureCount);
@@ -1565,305 +1454,6 @@ SIZE_T EEConfig::GetSizeOfProcessBindingFile()
     return g_dwHostConfigFile;
 }
 
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE) // unimpactful install --> no config files
-
-/**************************************************************/
-static void MessageBoxParseError(HRESULT hr, __in_z LPCWSTR wszFile);
-
-#define IfFailParseError(FILE, ISAPPCONFIG, ...) \
-    do \
-    { \
-        /* On error, always show an error dialog and return an error result when process is immersive; */ \
-        /* otherwise show dialog (conditionally for App config) and swallow error. */ \
-        if (FAILED(hr = (__VA_ARGS__)) && (!(ISAPPCONFIG) || AppX::IsAppXProcess() || GetConfigDWORDInternal_DontUse_(CLRConfig::EXTERNAL_NotifyBadAppCfg,false))) \
-        { \
-            MessageBoxParseError(hr, FILE); \
-            if (AppX::IsAppXProcess()) \
-            { /* Fail on bad config in AppX process. */ \
-                return hr; \
-            } \
-            else \
-            { \
-                hr = S_FALSE; \
-            } \
-        } \
-    } while (false)
-
-/**************************************************************/
-HRESULT EEConfig::SetupConfiguration()
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-    } CONTRACTL_END;
-
-    WCHAR version[_MAX_PATH];
-    DWORD dwVersion = _MAX_PATH;
-
-    HRESULT hr = S_OK;
-    // Get the version location
-    IfFailRet(GetCORVersionInternal(version, _MAX_PATH, & dwVersion));
-
-    // See if the environment has specified an XML file
-    NewArrayHolder<WCHAR> file(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CONFIG));
-    if(file != NULL)
-    {
-        IfFailParseError(file, false, AppendConfigurationFile(file, version));
-    }
-
-    // We need to read configuration information from 3 sources... the app config file, the
-    // host supplied config file, and the machine.config file. The order in which we
-    // read them are very import. If the different config sources specify the same config
-    // setting, we will use the setting of the first one read.
-    //
-    // In the pecking order, machine.config should always have the final say. The host supplied config
-    // file should follow, and lastly, the app config file.
-    //
-    // Note: the order we read them is not the order they are published. Need to read the AppConfig
-    // first so that we can decide if we should import machine.config (yes in Classic, typically no
-    // in AppX). We still publish in the order required as described above.
-
-    enum
-    {
-        MachineConfig = 0,
-        HostConfig    = 1,
-        AppConfig     = 2,
-        NumConfig     = 3,
-    };
-
-    ConfigSource * rgpSources[NumConfig] = { nullptr };
-
-    // Create ConfigSource objects for all config files.
-    for (size_t i = 0; i < NumConfig; ++i)
-    {
-        rgpSources[i] = new (nothrow) ConfigSource();
-        if (rgpSources[i] == NULL)
-        {
-            while (i != 0)
-            {
-                --i;
-                delete rgpSources[i];
-                rgpSources[i] = nullptr;
-            }
-            return E_OUTOFMEMORY;
-        }
-    }
-
-    // Publish ConfigSource objects in required order. It's ok that the file contents are imported below,
-    // since we're in EEStartup and this data cannot be accessed by any other threads yet.
-    for (size_t i = 0; i < NumConfig; ++i)
-    {
-        m_Configuration.Append(rgpSources[i]);
-    }
-
-    // ----------------------------------------------------
-    // Import the app.config file, or in the case of an
-    // AppX process check to make sure no app.config file
-    // exists unless launched with AO_DESIGNMODE.
-    // ----------------------------------------------------
-    
-    do
-    {
-        size_t cchProcExe=0;
-        PathString wzProcExe;
-        EX_TRY
-        {
-
-
-
-            // Get name of file used to create process
-            if (g_pCachedModuleFileName)
-            {
-                wzProcExe.Set(g_pCachedModuleFileName);
-                cchProcExe = wzProcExe.GetCount();
-            }
-            else
-            {
-                cchProcExe = WszGetModuleFileName(NULL, wzProcExe);
-
-                if (cchProcExe == 0)
-                {
-                    hr = HRESULT_FROM_GetLastError();
-                    break;
-                }
-            }
-
-            if (cchProcExe != 0)
-            {
-                wzProcExe.Append(CONFIGURATION_EXTENSION);
-
-                if (AppX::IsAppXProcess() && !AppX::IsAppXDesignMode())
-                {
-                    if (clr::fs::Path::Exists(wzProcExe))
-                    {
-                        hr = CLR_E_APP_CONFIG_NOT_ALLOWED_IN_APPX_PROCESS;
-                        break;
-                    }
-                }
-            }
-        }
-        EX_CATCH_HRESULT(hr);
-        if (cchProcExe != 0)
-        {
-            IfFailParseError(wzProcExe, true, AppendConfigurationFile(wzProcExe, version));
-
-            // We really should return a failure hresult if the app config file is bad, but that
-            // would be a breaking change. Not sure if it's worth it yet.
-            hr = S_OK;
-            break;
-        }
-    } while (false);
-    
-
-    if (hr != S_OK)
-        return hr;
-    // ----------------------------------------------------
-    // Import machine.config, if needed.
-    // ----------------------------------------------------
-    if (!AppX::IsAppXProcess() || AppX::IsAppXDesignMode())
-    {
-        WCHAR wzSystemDir[_MAX_PATH];
-        DWORD cchSystemDir = COUNTOF(wzSystemDir);
-        IfFailRet(GetInternalSystemDirectory(wzSystemDir, &cchSystemDir));
-
-        // cchSystemDir already includes the NULL
-        if(cchSystemDir + StrLen(MACHINE_CONFIGURATION_FILE) <= _MAX_PATH)
-        {
-            IfFailRet(StringCchCat(wzSystemDir, COUNTOF(wzSystemDir), MACHINE_CONFIGURATION_FILE));
-
-            // CLR_STARTUP_OPT:
-            // The machine.config file can be very large.  We cannot afford
-            // to parse all of it at CLR startup time.
-            //
-            // Accordingly, we instruct the XML parser to stop parsing the
-            // machine.config file when it sees the end of the
-            // <runtime>...</runtime> section that holds our data (if any).
-            //
-            // By construction, this section is now placed near the top
-            // of machine.config.
-            // 
-            IfFailParseError(wzSystemDir, false, ImportConfigurationFile(
-                rgpSources[MachineConfig]->Table(), wzSystemDir, version, stopAfterRuntimeSection));
-
-            if (hr == S_FALSE) // means that we couldn't find machine.config
-                hr = S_OK;
-        }
-    }
-
-    // ----------------------------------------------------
-    // Import the host supplied config file, if needed.
-    // ----------------------------------------------------
-    // Cannot host an AppX managed process, so no need to check devModeEnabled.
-    if (!AppX::IsAppXProcess())
-    {
-        if (GetProcessBindingFile() != NULL && GetSizeOfProcessBindingFile() > 0)
-        {
-            IfFailRet(ImportConfigurationFile(
-                rgpSources[HostConfig]->Table(), GetProcessBindingFile(), version));
-        }
-    }
-
-    return hr;
-}
-
-//
-// There was an error 'hr' parsing the file 'wszFile'.
-// Pop up a MessageBox reporting the error, unless the config setting
-// 'NoGuiFromShim' is in effect.
-//
-static void MessageBoxParseError(HRESULT hr, __in_z LPCWSTR wszFile)
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(FAILED(hr)); 
-    } CONTRACTL_END;
-
-    if (!REGUTIL::GetConfigDWORD_DontUse_(CLRConfig::UNSUPPORTED_NoGuiFromShim, FALSE))
-    {
-        EEMessageBoxCatastrophic(IDS_EE_CONFIGPARSER_ERROR, IDS_EE_CONFIGPARSER_ERROR_CAPTION, wszFile, hr);
-    }
-}
-
-/**************************************************************/
-
-STDAPI GetXMLObjectEx(IXMLParser **ppv);
-
-HRESULT EEConfig::ImportConfigurationFile(
-    ConfigStringHashtable* pTable,
-    LPCWSTR pszFileName,
-    LPCWSTR version,
-    ParseCtl parseCtl)
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pTable));
-        PRECONDITION(CheckPointer(pszFileName));
-        PRECONDITION(CheckPointer(version));
-        INJECT_FAULT(return E_OUTOFMEMORY);
-    } CONTRACTL_END;
-
-    NonVMComHolder<IXMLParser>         pIXMLParser(NULL);
-    NonVMComHolder<IStream>            pFile(NULL);
-    NonVMComHolder<EEConfigFactory>    factory(NULL); 
-
-    HRESULT hr = CreateConfigStreamHelper(pszFileName, &pFile);
-    if(FAILED(hr)) goto Exit;
-
-    hr = GetXMLObjectEx(&pIXMLParser);
-    if(FAILED(hr)) goto Exit;
-
-    factory = new (nothrow) EEConfigFactory(pTable, version, parseCtl);
-    
-    if ( ! factory) { 
-        hr = E_OUTOFMEMORY; 
-        goto Exit; 
-    }
-    factory->AddRef(); // RefCount = 1 
-
-    
-    hr = pIXMLParser->SetInput(pFile); // filestream's RefCount=2
-    if ( ! SUCCEEDED(hr)) 
-        goto Exit;
-
-    hr = pIXMLParser->SetFactory(factory); // factory's RefCount=2
-    if ( ! SUCCEEDED(hr)) 
-        goto Exit;
-
-    {
-        CONTRACT_VIOLATION(ThrowsViolation); // @todo: Run() throws!
-        hr = pIXMLParser->Run(-1);
-    }
-    
-Exit:  
-    if (hr == (HRESULT) XML_E_MISSINGROOT)
-        hr = S_OK;
-    else if (Assembly::FileNotFound(hr))
-        hr = S_FALSE;
-
-    return hr;
-}
-
-HRESULT EEConfig::AppendConfigurationFile(
-    LPCWSTR pszFileName,
-    LPCWSTR version,
-    ParseCtl parseCtl)
-{
-    LIMITED_METHOD_CONTRACT;
-    HRESULT hr = S_OK;
-
-    ConfigStringHashtable* pTable = m_Configuration.Append();
-    IfNullRet(pTable);
-
-    return ImportConfigurationFile(pTable, pszFileName, version, parseCtl);
-}
-
-
-#endif // FEATURE_CORECLR && !CROSSGEN_COMPILE
 
 bool EEConfig::RequireZap(LPCUTF8 assemblyName) const
 {
diff --git a/src/vm/eeconfig.h b/src/vm/eeconfig.h
index 02342d7e93..8e21c445da 100644
--- a/src/vm/eeconfig.h
+++ b/src/vm/eeconfig.h
@@ -261,8 +261,6 @@ enum ParseCtl {
     stopAfterRuntimeSection // stop after <runtime>...</runtime> section
 };
 
-extern CorHostProtectionManager s_CorHostProtectionManager;
-
 class EEConfig
 {
 public:
@@ -512,9 +510,7 @@ public:
     }
 #endif // FEATURE_COMINTEROP
 
-#ifdef FEATURE_CORECLR
     bool VerifyModulesOnLoad(void) const { LIMITED_METHOD_CONTRACT; return fVerifyAllOnLoad; }
-#endif
 #ifdef _DEBUG
     bool ExpandModulesOnLoad(void) const { LIMITED_METHOD_CONTRACT; return fExpandAllOnLoad; }
 #endif //_DEBUG
@@ -1010,9 +1006,7 @@ private: //----------------------------------------------------------------
     bool   m_fDeveloperInstallation;      // We are on a developers machine
     bool   fAppDomainUnload;            // Enable appdomain unloading
     
-#ifdef FEATURE_CORECLR
     bool fVerifyAllOnLoad;              // True if we want to verify all methods in an assembly at load time.
-#endif //FEATURE_CORECLR
 
     DWORD  dwADURetryCount;
 
@@ -1199,20 +1193,6 @@ private: //----------------------------------------------------------------
 #endif
 
 public:
-#ifndef FEATURE_CORECLR // unimpactful install --> no config files
-    HRESULT ImportConfigurationFile(
-        ConfigStringHashtable* pTable,
-        LPCWSTR pszFileName,
-        LPCWSTR version,
-        ParseCtl parseCtl = parseAll);
-
-    HRESULT AppendConfigurationFile(
-        LPCWSTR pszFileName,
-        LPCWSTR version,
-        ParseCtl parseCtl = parseAll); 
-
-    HRESULT SetupConfiguration();
-#endif // FEATURE_CORECLR
 
     HRESULT GetConfiguration_DontUse_(__in_z LPCWSTR pKey, ConfigSearch direction, __deref_out_opt LPCWSTR* value);
     LPCWSTR  GetProcessBindingFile();  // All flavors must support this method
@@ -1332,24 +1312,6 @@ public:
 
 #endif
 
-void InitHostProtectionManager();
-
-extern BYTE g_CorHostProtectionManagerInstance[];
-
-inline CorHostProtectionManager* GetHostProtectionManager()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-//        MODE_ANY;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    return (CorHostProtectionManager*)g_CorHostProtectionManagerInstance;
-}
-
 extern BOOL g_CLRPolicyRequested;
 
 // NGENImagesAllowed is the safe way to determine if NGEN Images are allowed to be loaded. (Defined as
diff --git a/src/vm/eeconfigfactory.cpp b/src/vm/eeconfigfactory.cpp
deleted file mode 100644
index a0eb927ce9..0000000000
--- a/src/vm/eeconfigfactory.cpp
+++ /dev/null
@@ -1,398 +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.
-// EEConfigFactory.cpp
-//
-
-//
-// Factory used to with the XML parser to read configuration files
-//
-
-#include "common.h"
-#include "ngenoptout.h"
-#include "eeconfigfactory.h"
-
-
-#define ISWHITE(ch) ((ch) >= 0x09 && (ch) <= 0x0D || (ch) == 0x20)
-
-#define CONST_STRING_AND_LEN(str) str, NumItems(str)-1
-
-
-int EEXMLStringCompare(const WCHAR *pStr1, 
-                    DWORD cchStr1, 
-                    const WCHAR *pStr2, 
-                    DWORD cchStr2)
-{
-    LIMITED_METHOD_CONTRACT;
-    if (cchStr1 != cchStr2)
-        return -1;
-
-    return wcsncmp(pStr1, pStr2, cchStr1);
-}// EEXMLStringCompare
-
-
-int EEXMLStringComparei(const WCHAR *pStr1, 
-                    DWORD cchStr1, 
-                    const WCHAR *pStr2, 
-                    DWORD cchStr2)
-{
-    WRAPPER_NO_CONTRACT;
-    if (cchStr1 != cchStr2)
-        return -1;
-
-    return SString::_wcsnicmp(pStr1, pStr2, cchStr1);
-}// EEXMLStringCompare
-
-
-
-EEConfigFactory::EEConfigFactory(
-    ConfigStringHashtable* pTable,
-    LPCWSTR pString,
-    ParseCtl parseCtl) 
-{
-    LIMITED_METHOD_CONTRACT;
-    m_pTable = pTable;
-    m_pVersion = pString;
-    m_dwDepth = 0;
-    m_fUnderRuntimeElement = FALSE;
-    m_fDeveloperSettings = FALSE;
-    m_fVersionedRuntime= FALSE;
-    m_fOnEnabledAttribute = FALSE;
-    m_fOnValueAttribute = FALSE;
-    m_pCurrentRuntimeElement = m_pBuffer;
-    m_dwCurrentRuntimeElement = 0;
-    m_dwSize = CONFIG_KEY_SIZE;
-    m_parseCtl = parseCtl;
-    m_pActiveFactory = NULL;
-}
-
-EEConfigFactory::~EEConfigFactory() 
-{
-    LIMITED_METHOD_CONTRACT;
-    DeleteKey();
-}
-
-HRESULT STDMETHODCALLTYPE EEConfigFactory::NotifyEvent( 
-            /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-            /* [in] */ XML_NODEFACTORY_EVENT iEvt)
-{
-    LIMITED_METHOD_CONTRACT;
-    if(iEvt == XMLNF_ENDDOCUMENT) {
-        // <TODO> add error handling.</TODO>
-    }
-    if(m_pActiveFactory != NULL)
-        return m_pActiveFactory->NotifyEvent(pSource, iEvt);    
-    
-    return S_OK;
-}
-//---------------------------------------------------------------------------
-HRESULT STDMETHODCALLTYPE EEConfigFactory::BeginChildren( 
-    /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-    /* [in] */ XML_NODE_INFO __RPC_FAR *pNodeInfo)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    m_dwDepth++;
-    if(m_pActiveFactory != NULL)
-        return m_pActiveFactory->BeginChildren(pSource, pNodeInfo);    
-    return S_OK;
-
-}
-//---------------------------------------------------------------------------
-HRESULT STDMETHODCALLTYPE EEConfigFactory::EndChildren( 
-    /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-    /* [in] */ BOOL fEmptyNode,
-    /* [in] */ XML_NODE_INFO __RPC_FAR *pNodeInfo)
-{
-    LIMITED_METHOD_CONTRACT;
-    if ( fEmptyNode ) { 
-        m_fDeveloperSettings = FALSE;        
-    }
-    else {
-        m_dwDepth--;
-    }
-
-    if (m_pActiveFactory != NULL)
-    {
-        HRESULT hr = S_OK;
-        IfFailRet(m_pActiveFactory->EndChildren(pSource, fEmptyNode, pNodeInfo));
-
-
-        if(m_dwDepth == 2) // when generalizing: use the current active factory depth
-        {
-            m_pActiveFactory = NULL;
-        }
-        
-    }
-
-    if (m_fUnderRuntimeElement && wcscmp(pNodeInfo->pwcText, W("runtime")) == 0) {
-        m_fUnderRuntimeElement = FALSE;
-        m_fVersionedRuntime = FALSE;
-        ClearKey();
-        // CLR_STARTUP_OPT:
-        // Early out if we only need to read <runtime> section.
-        //
-        if (m_parseCtl == stopAfterRuntimeSection)
-            pSource->Abort(NULL/*unused*/);
-    }
-    
-    return S_OK;
-}
-//---------------------------------------------------------------------------
-HRESULT STDMETHODCALLTYPE EEConfigFactory::CreateNode( 
-    /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-    /* [in] */ PVOID pNode,
-    /* [in] */ USHORT cNumRecs,
-    /* [in] */ XML_NODE_INFO* __RPC_FAR * __RPC_FAR apNodeInfo)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        INJECT_FAULT(return E_OUTOFMEMORY;);
-    }
-    CONTRACTL_END;
-    
-    if(m_pActiveFactory != NULL)
-        return m_pActiveFactory->CreateNode(pSource, pNode, cNumRecs, apNodeInfo);    
-
-    if(m_dwDepth > 3)
-    {
-        
-        return S_OK;
-    }
-
-    HRESULT hr = S_OK;
-    DWORD  dwStringSize = 0;
-    WCHAR* pszString = NULL;
-    DWORD  i; 
-    BOOL   fRuntimeKey = FALSE;
-    BOOL   fVersion = FALSE;
-
-    for( i = 0; i < cNumRecs; i++) { 
-        CONTRACT_VIOLATION(ThrowsViolation); // Lots of stuff in here throws!
-        
-        if(apNodeInfo[i]->dwType == XML_ELEMENT ||
-           apNodeInfo[i]->dwType == XML_ATTRIBUTE ||
-           apNodeInfo[i]->dwType == XML_PCDATA) {
-
-            dwStringSize = apNodeInfo[i]->ulLen;
-            pszString = (WCHAR*) apNodeInfo[i]->pwcText;
-            // Trim the value
-
-            // we should never decrement lgth if it's 0, because it's unsigned
-
-            for(;*pszString && ISWHITE(*pszString) && dwStringSize>0; pszString++, dwStringSize--);
-            while( dwStringSize > 0 && ISWHITE(pszString[dwStringSize-1]))
-                   dwStringSize--;
-
-            // NOTE: pszString is not guaranteed to be null terminated. Use EEXMLStringCompare to do
-            // string comparisions on it
-
-            switch(apNodeInfo[i]->dwType) {
-            case XML_ELEMENT : 
-                fRuntimeKey = FALSE;
-                ClearKey();
-                
-                if (m_dwDepth == 1 && EEXMLStringCompare(pszString, dwStringSize, CONST_STRING_AND_LEN(W("runtime"))) == 0) {
-                    m_fUnderRuntimeElement = TRUE;
-                    fRuntimeKey = TRUE;
-                }
-    
-                if(m_dwDepth == 2 && m_fUnderRuntimeElement) {
-                    
-                    // Developer settings can look like
-                    // <runtime>
-                    //     <developerSettings installationVersion="v2.0.40223.0" />
-                    //
-                    // or
-                    //
-                    //     <developmentMode developerInstallation="true" />
-                    //
-                    // Neither one is your standard config setting.
-                    if (!EEXMLStringCompare(pszString, dwStringSize, CONST_STRING_AND_LEN(W("developerSettings"))) ||
-                        !EEXMLStringCompare(pszString, dwStringSize, CONST_STRING_AND_LEN(W("developmentMode"))))
-                    {
-                        m_fDeveloperSettings = TRUE;
-                    }
-                    else
-                    // when generalizing: use map of (string, depth) -> class
-                    if (!EEXMLStringCompare(pszString, dwStringSize, CONST_STRING_AND_LEN(W("disableNativeImageLoad"))))
-                    {
-                        m_pActiveFactory = new NativeImageOptOutConfigFactory();
-                        m_pActiveFactory->AddRef();
-                    }
-                    else
-                    {
-                        // This is a standard element under the runtime node.... it could look like this
-                        // <runtime>
-                        //     <pszString enabled="1" />
-
-                        hr = CopyToKey(pszString, dwStringSize);
-                        if(FAILED(hr)) return hr;
-                    }
-                }
-                // If our depth isn't 2, and we're not under the runtime element....
-                else
-                    ClearKey();
-
-                break ;     
-                
-            case XML_ATTRIBUTE : 
-                if(fRuntimeKey && EEXMLStringCompare(pszString, dwStringSize, CONST_STRING_AND_LEN(W("version"))) == 0) {
-                    fVersion = TRUE;
-                }
-                else 
-                {
-                    if (m_dwDepth == 2 && m_fUnderRuntimeElement)
-                    {
-                        if (!m_fDeveloperSettings)
-                        {
-                            _ASSERTE(m_dwCurrentRuntimeElement > 0);
-
-                            // The standard model for runtime config settings is as follows
-                            //
-                            // <runtime>
-                            //    <m_pCurrentRuntimeElement enabled="true|false" />
-                            // or
-                            //    <m_pCurrentRuntimeElement enabled="1|0" />
-                            // or
-                            //    <m_pCurrentRuntimeElement value="string" />
-
-                            m_fOnEnabledAttribute = (EEXMLStringComparei(pszString, dwStringSize, CONST_STRING_AND_LEN(W("enabled"))) == 0);
-                            m_fOnValueAttribute = (EEXMLStringComparei(pszString, dwStringSize, CONST_STRING_AND_LEN(W("value"))) == 0);
-                        }
-                        else // We're looking at developer settings 
-                        {       
-                            // Developer settings look like
-                            //     <developerSettings installationVersion="v2.0.40223.0" />
-                            //
-                            // or
-                            //
-                            //     <developmentMode developerInstallation="true" />
-                            //
-
-                            // The key name will actually be the attribute name                            
-                            
-                            hr = CopyToKey(pszString, dwStringSize);
-                            if(FAILED(hr)) return hr;
-                            m_fOnEnabledAttribute = FALSE;
-                            m_fOnValueAttribute = FALSE;
-                        }
-                    }     
-                }
-                break;
-            case XML_PCDATA:
-                if(fVersion) {
-                    // if this is not the right version
-                    // then we are not interested 
-                    if(EEXMLStringCompare(pszString, dwStringSize, m_pVersion, (DWORD)wcslen(m_pVersion))) {
-                        m_fUnderRuntimeElement = FALSE;
-                    }
-                    else {
-                        // if it is the right version then overwrite
-                        // all entries that exist in the hash table
-                        m_fVersionedRuntime = TRUE;
-                    }
-
-                    fVersion = FALSE;
-                }
-                else if(fRuntimeKey) {
-                    break; // Ignore all other attributes on <runtime>
-                }
-                
-                // m_dwCurrentRuntimeElement is set when we called CopyToKey in the XML_ELEMENT case
-                // section above.
-                else if(m_dwCurrentRuntimeElement > 0 && (m_fDeveloperSettings || m_fOnEnabledAttribute || m_fOnValueAttribute)) {
-
-                    // This means that, either we are working on attribute values for the developer settings,
-                    // or we've got what "enabled" is equal to, or we're reading a string for a value setting.
-                    //
-                    // <runtime>
-                    //   <m_pwzCurrentElementUnderRuntimeElement m_pLastKey=pString />
-                        
-                    if (m_fOnEnabledAttribute) {
-                        // For the enabled settings, let's convert all trues to 1s and the falses to 0s
-                        if (EEXMLStringComparei(pszString, dwStringSize, CONST_STRING_AND_LEN(W("false"))) == 0) {
-                            pszString = W("0");
-                            dwStringSize = 1;
-                        }    
-                        else if (EEXMLStringComparei(pszString, dwStringSize, CONST_STRING_AND_LEN(W("true"))) == 0) {
-                            pszString = W("1");
-                            dwStringSize = 1;
-                        }
-
-                        // <TODO> Right now, if pString isn't 0 or 1, then the XML schema is bad.
-                        // If we were to ever do schema validation, this would be a place to put it.
-                        // </TODO>
-                    }
-                    
-                    hr = AddKeyValuePair(pszString, dwStringSize, m_pCurrentRuntimeElement, m_dwCurrentRuntimeElement);
-                    if(FAILED(hr)) { return hr; }
-                }
-                    
-                break ;     
-            default: 
-                ;
-            } // end of switch
-        }
-    }
-    return hr;
-}
-
-HRESULT STDMETHODCALLTYPE EEConfigFactory::AddKeyValuePair( 
-    __in_ecount(dwStringSize) WCHAR * pszString,
-    /* [in] */ DWORD dwStringSize,
-    __in_ecount(m_dwCurrentRuntimeElement) WCHAR * m_pCurrentRuntimeElement,
-    /* [in] */ DWORD m_dwCurrentRuntimeElement
-    )
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        INJECT_FAULT(return E_OUTOFMEMORY;);
-    }
-    CONTRACTL_END;
-    
-    HRESULT hr = S_OK;
-    
-    // verify we the size fields don't overflow
-    if (dwStringSize + 1 < dwStringSize) { return E_FAIL; }
-    if (m_dwCurrentRuntimeElement < m_dwCurrentRuntimeElement - 1) { return E_FAIL; }   
-
-    EX_TRY
-    {
-        // Allocate memory that can store this setting
-        NewArrayHolder<WCHAR> pStringToKeep(new WCHAR[dwStringSize+1]);
-        wcsncpy_s(pStringToKeep, dwStringSize + 1, pszString, dwStringSize);
-        
-        // See if we've already picked up a value for this setting
-        ConfigStringKeyValuePair * pair = m_pTable->Lookup(m_pCurrentRuntimeElement);
-        if(pair != NULL) {
-            // If this is a config section for this runtime version, then it's allowed to overwrite
-            // previous settings that we've picked up
-            if(m_fVersionedRuntime) {
-                delete[] pair->value;
-                pair->value = pStringToKeep;
-                pStringToKeep.SuppressRelease();
-            }
-        }
-        else {            
-            // We're adding a new config item
-            NewArrayHolder<WCHAR> pKeyToKeep (new WCHAR[m_dwCurrentRuntimeElement]);
-            wcsncpy_s(pKeyToKeep, m_dwCurrentRuntimeElement, m_pCurrentRuntimeElement, m_dwCurrentRuntimeElement - 1);
-            
-            ConfigStringKeyValuePair * newPair = new ConfigStringKeyValuePair();
-            newPair->key = pKeyToKeep;
-            newPair->value = pStringToKeep;
-            m_pTable->Add(newPair);
-            pKeyToKeep.SuppressRelease();
-            pStringToKeep.SuppressRelease();
-        }
-    }
-    EX_CATCH_HRESULT(hr);
-    
-    return hr;
-}
-
diff --git a/src/vm/eeconfigfactory.h b/src/vm/eeconfigfactory.h
deleted file mode 100644
index 2554295268..0000000000
--- a/src/vm/eeconfigfactory.h
+++ /dev/null
@@ -1,149 +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.
-// EEConfigFactory.h
-//
-
-//
-// Parses XML files and adding runtime entries to the EEConfig list
-//
-
-
-#ifndef EECONFIGFACTORY_H
-#define EECONFIGFACTORY_H
-
-#include <xmlparser.h>
-#include <objbase.h>
-#include "unknwn.h"
-#include "../xmlparser/_reference.h"
-#include "../xmlparser/_unknown.h"
-#include "eehash.h"
-#include "eeconfig.h"
-
-#define CONFIG_KEY_SIZE 128
-
-class EEConfigFactory : public _unknown<IXMLNodeFactory, &IID_IXMLNodeFactory>
-{
-
-public:
-    EEConfigFactory(
-        ConfigStringHashtable* pTable, 
-        LPCWSTR, 
-        ParseCtl parseCtl = parseAll);
-    ~EEConfigFactory();
-    HRESULT STDMETHODCALLTYPE NotifyEvent( 
-            /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-            /* [in] */ XML_NODEFACTORY_EVENT iEvt);
-
-    HRESULT STDMETHODCALLTYPE BeginChildren( 
-        /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-        /* [in] */ XML_NODE_INFO* __RPC_FAR pNodeInfo);
-
-    HRESULT STDMETHODCALLTYPE EndChildren( 
-        /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-        /* [in] */ BOOL fEmptyNode,
-        /* [in] */ XML_NODE_INFO* __RPC_FAR pNodeInfo);
-    
-    HRESULT STDMETHODCALLTYPE Error( 
-        /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-        /* [in] */ HRESULT hrErrorCode,
-        /* [in] */ USHORT cNumRecs,
-        /* [in] */ XML_NODE_INFO* __RPC_FAR * __RPC_FAR apNodeInfo)
-    {
-        LIMITED_METHOD_CONTRACT;
-      /* 
-         UNUSED(pSource);
-         UNUSED(hrErrorCode);
-         UNUSED(cNumRecs);
-         UNUSED(apNodeInfo);
-      */
-        return hrErrorCode;
-    }
-    
-    HRESULT STDMETHODCALLTYPE CreateNode( 
-        /* [in] */ IXMLNodeSource __RPC_FAR *pSource,
-        /* [in] */ PVOID pNodeParent,
-        /* [in] */ USHORT cNumRecs,
-        /* [in] */ XML_NODE_INFO* __RPC_FAR * __RPC_FAR apNodeInfo);
-
-private:
-
-    HRESULT GrowKey(DWORD dwSize)
-    {
-        CONTRACTL
-        {
-      	    NOTHROW;	    
-      	    GC_NOTRIGGER;
-      	    INJECT_FAULT(return E_OUTOFMEMORY);
-        }
-        CONTRACTL_END;
-        
-        if(dwSize > m_dwSize) {
-            DeleteKey();
-            m_pCurrentRuntimeElement = new(nothrow) WCHAR[dwSize];
-            if(m_pCurrentRuntimeElement == NULL) return E_OUTOFMEMORY;
-            m_dwSize = dwSize;
-        }
-        return S_OK;
-    }
-
-    void ClearKey()
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        *m_pCurrentRuntimeElement = 0;
-        m_dwCurrentRuntimeElement = 0;
-    }
-
-    void DeleteKey()
-    {
-        WRAPPER_NO_CONTRACT;
-        if(m_pCurrentRuntimeElement != NULL && m_pCurrentRuntimeElement != m_pBuffer)
-            delete [] m_pCurrentRuntimeElement;
-        m_dwSize = 0;
-        m_dwCurrentRuntimeElement = 0;
-    }
-
-    HRESULT CopyToKey(__in_z LPCWSTR pString, DWORD dwString)
-    {
-        WRAPPER_NO_CONTRACT;
-        dwString++; // add in the null
-        HRESULT hr = GrowKey(dwString);
-        if(FAILED(hr)) return hr;
-        wcsncpy_s(m_pCurrentRuntimeElement, m_dwSize, pString, dwString-1);
-
-        m_dwCurrentRuntimeElement = dwString;
-        return S_OK;
-    }
-    
-    HRESULT STDMETHODCALLTYPE AddKeyValuePair( 
-        __in_ecount(dwStringSize) WCHAR * pszString,
-        /* [in] */ DWORD dwStringSize,
-        __in_ecount(m_dwCurrentRuntimeElement) WCHAR * m_pCurrentRuntimeElement,
-        /* [in] */ DWORD m_dwCurrentRuntimeElement);
-        
-    HRESULT CopyVersion(LPCWSTR version, DWORD dwVersion);
-
-    ConfigStringHashtable* m_pTable;
-    BOOL    m_fUnderRuntimeElement;
-    BOOL    m_fOnEnabledAttribute;
-    BOOL    m_fOnValueAttribute;
-    BOOL    m_fVersionedRuntime;
-    BOOL    m_fDeveloperSettings;
-
-    LPCWSTR m_pVersion;
-    LPWSTR  m_pCurrentRuntimeElement;
-    DWORD   m_dwCurrentRuntimeElement;
-
-    WCHAR   m_pBuffer[CONFIG_KEY_SIZE];
-    DWORD   m_dwSize;
-
-    DWORD   m_dwDepth;
-
-    bool    m_bSafeMode; // If true, will ignore any settings that may compromise security
-    ParseCtl m_parseCtl; // usually parseAll, sometimes stopAfterRuntimeSection
-
-    ReleaseHolder<IXMLNodeFactory> m_pActiveFactory; // hold a factory responsible for parsing subnode
-};
-
-#endif
diff --git a/src/vm/eedbginterface.h b/src/vm/eedbginterface.h
index b65ab348cf..8c8c44d3e2 100644
--- a/src/vm/eedbginterface.h
+++ b/src/vm/eedbginterface.h
@@ -139,8 +139,10 @@ public:
 
 #ifndef DACCESS_COMPILE
 
+#ifndef USE_GC_INFO_DECODER
     virtual BOOL IsInPrologOrEpilog(const BYTE *address,
                                     size_t* prologSize) = 0;
+#endif
 
     // Determine whether certain native offsets of the specified function are within
     // an exception filter or handler.
diff --git a/src/vm/eedbginterfaceimpl.cpp b/src/vm/eedbginterfaceimpl.cpp
index ff63d846e7..b7a4359350 100644
--- a/src/vm/eedbginterfaceimpl.cpp
+++ b/src/vm/eedbginterfaceimpl.cpp
@@ -483,6 +483,7 @@ MethodDesc *EEDbgInterfaceImpl::GetNativeCodeMethodDesc(const PCODE address)
     RETURN ExecutionManager::GetCodeMethodDesc(address);
 }
 
+#ifndef USE_GC_INFO_DECODER
 // IsInPrologOrEpilog doesn't seem to be used for code that uses GC_INFO_DECODER
 BOOL EEDbgInterfaceImpl::IsInPrologOrEpilog(const BYTE *address,
                                             size_t* prologSize)
@@ -511,6 +512,7 @@ BOOL EEDbgInterfaceImpl::IsInPrologOrEpilog(const BYTE *address,
 
     return FALSE;
 }
+#endif // USE_GC_INFO_DECODER
 
 // 
 // Given a collection of native offsets of a certain function, determine if each falls
diff --git a/src/vm/eedbginterfaceimpl.h b/src/vm/eedbginterfaceimpl.h
index 1752da8122..979c706fb2 100644
--- a/src/vm/eedbginterfaceimpl.h
+++ b/src/vm/eedbginterfaceimpl.h
@@ -124,8 +124,10 @@ public:
 
     MethodDesc *GetNativeCodeMethodDesc(const PCODE address) DAC_UNEXPECTED();
 
+#ifndef USE_GC_INFO_DECODER
     BOOL IsInPrologOrEpilog(const BYTE *address,
                             size_t* prologSize);
+#endif
 
     void DetermineIfOffsetsInFilterOrHandler(const BYTE *functionAddress,
                                                   DebugOffsetToHandlerInfo *pOffsetToHandlerInfo,
diff --git a/src/vm/eepolicy.cpp b/src/vm/eepolicy.cpp
index 236f5afd6e..b35e9e9864 100644
--- a/src/vm/eepolicy.cpp
+++ b/src/vm/eepolicy.cpp
@@ -70,12 +70,10 @@ EEPolicy::EEPolicy ()
     m_ActionOnFailure[FAIL_NonCriticalResource] = eThrowException;
     m_ActionOnFailure[FAIL_OrphanedLock] = eNoAction;
     m_ActionOnFailure[FAIL_FatalRuntime] = eRudeExitProcess;
-#ifdef FEATURE_CORECLR
     // For CoreCLR, initialize the default action for AV processing to all
     // all kind of code to catch AV exception. If the host wants, they can
     // specify a different action for this.
     m_ActionOnFailure[FAIL_AccessViolation] = eNoAction;
-#endif // FEATURE_CORECLR    
     m_ActionOnFailure[FAIL_StackOverflow] = eRudeExitProcess;
     m_ActionOnFailure[FAIL_CodeContract] = eThrowException;
     m_unhandledExceptionPolicy = eRuntimeDeterminedPolicy;
@@ -178,22 +176,10 @@ BOOL EEPolicy::IsValidActionForFailure(EClrFailure failure, EPolicyAction action
         return action >= eUnloadAppDomain &&
             action < MaxPolicyAction;
     case FAIL_AccessViolation:
-#ifdef FEATURE_CORECLR
         // Allowed actions on failure are:
         // 
         // eNoAction or eRudeExitProcess.
         return ((action == eNoAction) || (action == eRudeExitProcess));
-#else // !FEATURE_CORECLR
-        // FAIL_AccessViolation is defined for the desktop so that
-        // if any more definitions are added after it, their value
-        // should remain constant irrespective of whether its the
-        // desktop CLR or CoreCLR.
-        //
-        // That said, currently, Desktop CLR does not support
-        // FAIL_AccessViolation. Thus, any calls which use
-        // this failure are not allowed.
-        return FALSE;
-#endif // FEATURE_CORECLR         
     case FAIL_StackOverflow:
         return action >= eRudeUnloadAppDomain &&
             action < MaxPolicyAction;
@@ -602,21 +588,6 @@ void EEPolicy::ExitProcessViaShim(UINT exitCode)
     // runtime in a process with many. We need to give the other runtimes a chance to exit
     // cleanly. If we can't make the call, or if the call fails for some reason, then we
     // simply exit the process here, which is rude to the others, but the best we can do.
-#if !defined(FEATURE_CORECLR)
-    {
-        ReleaseHolder<ICLRRuntimeHostInternal> pRuntimeHostInternal;
-
-        HRESULT hr = g_pCLRRuntime->GetInterface(CLSID_CLRRuntimeHostInternal,
-            IID_ICLRRuntimeHostInternal,
-            &pRuntimeHostInternal);
-
-        if (SUCCEEDED(hr))
-        {
-            pRuntimeHostInternal->ShutdownAllRuntimesThenExit(exitCode);
-            LOG((LF_EH, LL_INFO10, "ExitProcessViaShim: shim returned... exiting now.\n"));
-        }
-    }
-#endif // !FEATURE_CORECLR
 
     ExitProcess(exitCode);
 }
diff --git a/src/vm/eetoprofinterfaceimpl.cpp b/src/vm/eetoprofinterfaceimpl.cpp
index 1ceed3d81b..ca35717bec 100644
--- a/src/vm/eetoprofinterfaceimpl.cpp
+++ b/src/vm/eetoprofinterfaceimpl.cpp
@@ -2370,18 +2370,6 @@ HRESULT EEToProfInterfaceImpl::SetEventMask(DWORD dwEventMask, DWORD dwEventMask
         }        
     }
 
-    // Flags defined in COR_PRF_REQUIRE_PROFILE_IMAGE will force to JIT mscorlib if the
-    // user does not ngen mscorlib with /profiler. Similarly, the
-    // COR_PRF_DISABLE_ALL_NGEN_IMAGES flag always forces us to JIT mscorlib. Using the
-    // jitted version of mscorlib with HPA(Host Protection Attributes) enabled will cause
-    // stack overflow inside JIT. See Dev 10 Bug 637987 for the detail.
-    if (((dwEventMask & (COR_PRF_REQUIRE_PROFILE_IMAGE | COR_PRF_DISABLE_ALL_NGEN_IMAGES)) != 0) &&
-        (GetHostProtectionManager() != NULL) &&
-        (GetHostProtectionManager()->GetProtectedCategories() != eNoChecks))
-    {
-        return CORPROF_E_INCONSISTENT_FLAGS_WITH_HOST_PROTECTION_SETTING;
-    }
-
     // High event bits
 
     if (((dwEventMaskHigh & COR_PRF_HIGH_ADD_ASSEMBLY_REFERENCES) != 0) &&
@@ -6294,116 +6282,6 @@ HRESULT EEToProfInterfaceImpl::ProfilerDetachSucceeded()
     }
 }
 
-#ifdef FEATURE_FUSION
-
-// Minimal wrappers so that Fusion can call the GetAssemblyReferences profiler callback
-// without needing a ton of profapi includes.
-
-BOOL ShouldCallGetAssemblyReferencesProfilerCallback()
-{
-    return CORProfilerAddsAssemblyReferences();
-}
-
-void CallGetAssemblyReferencesProfilerCallbackIfNecessary(LPCWSTR wszAssemblyPath, IAssemblyBindingClosure * pClosure, AssemblyReferenceClosureWalkContextForProfAPI * pContext)
-{
-    BEGIN_PIN_PROFILER(CORProfilerAddsAssemblyReferences());
-    g_profControlBlock.pProfInterface->GetAssemblyReferences(wszAssemblyPath, pClosure, pContext);
-    END_PIN_PROFILER();
-}
-
-// Implementation of ICorProfilerAssemblyReferenceProvider, which is given to the profiler so
-// that it can call back into the CLR with extra assembly references that should be considered
-// while Fusion performs its assembly reference closure walk.
-class ProfilerAssemblyReferenceProvider : public ICorProfilerAssemblyReferenceProvider
-{
-public:
-    // IUnknown functions
-    virtual HRESULT __stdcall QueryInterface(REFIID id, void** pInterface)
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        if (id == IID_IUnknown)
-        {
-            *pInterface = static_cast<IUnknown *>(this);
-        }
-        else if (id == IID_ICorProfilerAssemblyReferenceProvider)
-        {
-            *pInterface = static_cast<ICorProfilerAssemblyReferenceProvider *>(this);
-        }
-        else
-        {
-            *pInterface = NULL;
-            return E_NOINTERFACE;
-        }
-
-        AddRef();
-        return S_OK;
-    }
-
-    virtual ULONG __stdcall AddRef()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return InterlockedIncrement(&m_refCount);
-    }
-
-    virtual ULONG __stdcall Release()
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        ULONG refCount = InterlockedDecrement(&m_refCount);
-
-        if (0 == refCount)
-        {
-            delete this;
-        }
-
-        return refCount;
-    }
-
-    // ICorProfilerAssemblyReferenceProvider functions
-    
-    // This is what the profiler calls to tell us about an assembly reference we should include
-    // when Fusion performs its closure walk.  When this is called, the walk is already underway,
-    // and is sitting on our stack already.
-    virtual HRESULT __stdcall AddAssemblyReference(const COR_PRF_ASSEMBLY_REFERENCE_INFO * pAssemblyRefInfo)
-    {
-        _ASSERTE(m_pClosure != NULL);
-
-        return m_pClosure->AddProfilerAssemblyReference(
-                pAssemblyRefInfo->pbPublicKeyOrToken,
-                pAssemblyRefInfo->cbPublicKeyOrToken,
-                pAssemblyRefInfo->szName,
-                pAssemblyRefInfo->pMetaData,
-                pAssemblyRefInfo->pbHashValue,
-                pAssemblyRefInfo->cbHashValue,
-                pAssemblyRefInfo->dwAssemblyRefFlags,
-                m_pContext);
-    }
-
-    // Implementation
-    ProfilerAssemblyReferenceProvider(IAssemblyBindingClosure * pClosure, AssemblyReferenceClosureWalkContextForProfAPI * pContext) :
-        m_refCount(1),
-        m_pClosure(pClosure),
-        m_pContext(pContext)
-    {
-        LIMITED_METHOD_CONTRACT;
-        m_pClosure->AddRef();
-    }
-
-protected:
-    Volatile<LONG> m_refCount;
-
-    // Our interface into Fusion's closure walk.  We use this to inform Fusion about
-    // the assembly reference the profiler gave us.
-    ReleaseHolder<IAssemblyBindingClosure> m_pClosure;
-
-    // Extra context built up by fusion's closure walk that we need to remember.  The
-    // walk is already in action by the time we're called, and this structure remembers
-    // the lists that are getting built up by the walk
-    AssemblyReferenceClosureWalkContextForProfAPI * m_pContext;
-};
-
-#endif // FEATURE_FUSION
 
 
 HRESULT EEToProfInterfaceImpl::GetAssemblyReferences(LPCWSTR wszAssemblyPath, IAssemblyBindingClosure * pClosure, AssemblyReferenceClosureWalkContextForProfAPI * pContext)
@@ -6433,30 +6311,6 @@ HRESULT EEToProfInterfaceImpl::GetAssemblyReferences(LPCWSTR wszAssemblyPath, IA
                                 ));
     HRESULT hr = S_OK;
 
-#ifdef FEATURE_FUSION
-
-    SString sPath;
-    _ASSERTE(IsCallback6Supported());
-
-    // Create an instance of the class implementing the interface we pass back to the profiler,
-    // feeding it the context we're currently at in Fusion's closure walk
-    ReleaseHolder<ProfilerAssemblyReferenceProvider> pReferenceProvider = 
-        new (nothrow) ProfilerAssemblyReferenceProvider(pClosure, pContext);
-    if (pReferenceProvider == NULL)
-    {
-        return E_OUTOFMEMORY;
-    }
-
-    {
-        // All callbacks are really NOTHROW, but that's enforced partially by the profiler,
-        // whose try/catch blocks aren't visible to the contract system        
-        PERMANENT_CONTRACT_VIOLATION(ThrowsViolation, ReasonProfilerCallout);
-        hr = m_pCallback6->GetAssemblyReferences(
-            wszAssemblyPath, 
-            static_cast<ICorProfilerAssemblyReferenceProvider *>(pReferenceProvider));
-    }
-
-#endif // FEATURE_FUSION
 
     return hr;
 }
diff --git a/src/vm/eetwain.cpp b/src/vm/eetwain.cpp
index 8bbe213ef8..340ea85e94 100644
--- a/src/vm/eetwain.cpp
+++ b/src/vm/eetwain.cpp
@@ -1642,10 +1642,10 @@ void *      getCalleeSavedReg(PREGDISPLAY pContext, regNum reg)
 
     switch (reg)
     {
-        case REGI_EBP: return pContext->pEbp;
-        case REGI_EBX: return pContext->pEbx;
-        case REGI_ESI: return pContext->pEsi;
-        case REGI_EDI: return pContext->pEdi;
+        case REGI_EBP: return pContext->GetEbpLocation();
+        case REGI_EBX: return pContext->GetEbxLocation();
+        case REGI_ESI: return pContext->GetEsiLocation();
+        case REGI_EDI: return pContext->GetEdiLocation();
 
         default: _ASSERTE(!"bad info.thisPtrResult"); return NULL;
     }
@@ -2840,7 +2840,9 @@ void    TRASH_CALLEE_UNSAVED_REGS(PREGDISPLAY pContext)
     /* This is not completely correct as we lose the current value, but
        it should not really be useful to anyone. */
     static DWORD s_badData = 0xDEADBEEF;
-    pContext->pEax = pContext->pEcx = pContext->pEdx = &s_badData;
+    pContext->SetEaxLocation(&s_badData);
+    pContext->SetEcxLocation(&s_badData);
+    pContext->SetEdxLocation(&s_badData);
 #endif //_DEBUG
 }
 
@@ -3061,7 +3063,7 @@ void EECodeManager::EnsureCallerContextIsValid( PREGDISPLAY  pRD, StackwalkCache
 
     if( !pRD->IsCallerContextValid )
     {
-#if !defined(DACCESS_COMPILE)
+#if !defined(DACCESS_COMPILE) && defined(HAS_QUICKUNWIND)
         if (pCacheEntry != NULL)
         {
             // lightened schema: take stack unwind info from stackwalk cache
@@ -3072,13 +3074,9 @@ void EECodeManager::EnsureCallerContextIsValid( PREGDISPLAY  pRD, StackwalkCache
         {
             // We need to make a copy here (instead of switching the pointers), in order to preserve the current context
             *(pRD->pCallerContext) = *(pRD->pCurrentContext);
-            
-            NOT_X86(*(pRD->pCallerContextPointers) = *(pRD->pCurrentContextPointers));
-
-            T_KNONVOLATILE_CONTEXT_POINTERS *pCallerContextPointers = NULL;
-            NOT_X86(pCallerContextPointers = pRD->pCallerContextPointers);
+            *(pRD->pCallerContextPointers) = *(pRD->pCurrentContextPointers);
 
-            Thread::VirtualUnwindCallFrame(pRD->pCallerContext, pCallerContextPointers, pCodeInfo);
+            Thread::VirtualUnwindCallFrame(pRD->pCallerContext, pRD->pCallerContextPointers, pCodeInfo);
         }
 
         pRD->IsCallerContextValid = TRUE;
@@ -3106,6 +3104,7 @@ size_t EECodeManager::GetCallerSp( PREGDISPLAY  pRD )
 
 #endif // WIN64EXCEPTIONS && !CROSSGEN_COMPILE
 
+#ifdef HAS_QUICKUNWIND
 /*
   *  Light unwind the current stack frame, using provided cache entry.
   *  pPC, Esp and pEbp of pContext are updated.
@@ -3130,9 +3129,11 @@ void EECodeManager::QuickUnwindStackFrame(PREGDISPLAY pRD, StackwalkCacheEntry *
     if (pCacheEntry->fUseEbpAsFrameReg)
     {
         _ASSERTE(pCacheEntry->fUseEbp);
+        TADDR curEBP = (TADDR)*pRD->GetEbpLocation();
+
         // EBP frame, update ESP through EBP, since ESPOffset may vary
-        pRD->pEbp = PTR_DWORD((TADDR)*pRD->pEbp);
-        pRD->SP = (TADDR)pRD->pEbp + sizeof(void*);
+        pRD->SetEbpLocation(PTR_DWORD(curEBP));
+        pRD->SP = curEBP + sizeof(void*);
     }
     else
     {
@@ -3194,6 +3195,7 @@ void EECodeManager::QuickUnwindStackFrame(PREGDISPLAY pRD, StackwalkCacheEntry *
     PORTABILITY_ASSERT("EECodeManager::QuickUnwindStackFrame is not implemented on this platform.");
 #endif // !_TARGET_X86_ && !_TARGET_AMD64_
 }
+#endif // HAS_QUICKUNWIND
 
 /*****************************************************************************/
 #ifdef _TARGET_X86_ // UnwindStackFrame
@@ -3207,13 +3209,32 @@ const RegMask CALLEE_SAVED_REGISTERS_MASK[] =
     RM_EBP  // last register to be pushed
 };
 
-const SIZE_T REGDISPLAY_OFFSET_OF_CALLEE_SAVED_REGISTERS[] =
+static void SetLocation(PREGDISPLAY pRD, int ind, PDWORD loc)
 {
-    offsetof(REGDISPLAY, pEdi), // first register to be pushed
-    offsetof(REGDISPLAY, pEsi),
-    offsetof(REGDISPLAY, pEbx),
-    offsetof(REGDISPLAY, pEbp)  // last register to be pushed
-};
+#ifdef WIN64EXCEPTIONS
+    static const SIZE_T OFFSET_OF_CALLEE_SAVED_REGISTERS[] =
+    {
+        offsetof(T_KNONVOLATILE_CONTEXT_POINTERS, Edi), // first register to be pushed
+        offsetof(T_KNONVOLATILE_CONTEXT_POINTERS, Esi),
+        offsetof(T_KNONVOLATILE_CONTEXT_POINTERS, Ebx),
+        offsetof(T_KNONVOLATILE_CONTEXT_POINTERS, Ebp), // last register to be pushed
+    };
+
+    SIZE_T offsetOfRegPtr = OFFSET_OF_CALLEE_SAVED_REGISTERS[ind];
+    *(LPVOID*)(PBYTE(pRD->pCurrentContextPointers) + offsetOfRegPtr) = loc;
+#else
+    static const SIZE_T OFFSET_OF_CALLEE_SAVED_REGISTERS[] =
+    {
+        offsetof(REGDISPLAY, pEdi), // first register to be pushed
+        offsetof(REGDISPLAY, pEsi),
+        offsetof(REGDISPLAY, pEbx),
+        offsetof(REGDISPLAY, pEbp), // last register to be pushed
+    };
+
+    SIZE_T offsetOfRegPtr = OFFSET_OF_CALLEE_SAVED_REGISTERS[ind];
+    *(LPVOID*)(PBYTE(pRD) + offsetOfRegPtr) = loc;
+#endif
+}
 
 /*****************************************************************************/
 
@@ -3279,8 +3300,7 @@ void UnwindEspFrameEpilog(
                Get the value from the stack if needed */
             if ((flags & UpdateAllRegs) || (regMask == RM_EBP))
             {
-                SIZE_T offsetOfRegPtr = REGDISPLAY_OFFSET_OF_CALLEE_SAVED_REGISTERS[i - 1];
-                *(LPVOID*)(PBYTE(pContext) + offsetOfRegPtr) = PTR_DWORD((TADDR)ESP);
+                SetLocation(pContext, i - 1, PTR_DWORD((TADDR)ESP));
             }
 
             /* Adjust ESP */
@@ -3385,7 +3405,7 @@ void UnwindEbpDoubleAlignFrameEpilog(
             unsigned calleeSavedRegsSize = info->savedRegsCountExclFP * sizeof(void*); 
 
             if (!InstructionAlreadyExecuted(offset, info->epilogOffs))
-                ESP = (*pContext->pEbp) - calleeSavedRegsSize;
+                ESP = *pContext->GetEbpLocation() - calleeSavedRegsSize;
             
             offset = SKIP_LEA_ESP_EBP(-int(calleeSavedRegsSize), epilogBase, offset);
         }
@@ -3403,8 +3423,7 @@ void UnwindEbpDoubleAlignFrameEpilog(
         {
             if (flags & UpdateAllRegs)
             {
-                SIZE_T offsetOfRegPtr = REGDISPLAY_OFFSET_OF_CALLEE_SAVED_REGISTERS[i - 1];
-                *(LPVOID*)(PBYTE(pContext) + offsetOfRegPtr) = PTR_DWORD((TADDR)ESP);
+                SetLocation(pContext, i - 1, PTR_DWORD((TADDR)ESP));
             }
             ESP += sizeof(void*);
         }
@@ -3415,7 +3434,7 @@ void UnwindEbpDoubleAlignFrameEpilog(
     if (needMovEspEbp)
     {
         if (!InstructionAlreadyExecuted(offset, info->epilogOffs))
-            ESP = *pContext->pEbp;
+            ESP = *pContext->GetEbpLocation();
             
         offset = SKIP_MOV_REG_REG(epilogBase, offset);
     }
@@ -3423,7 +3442,7 @@ void UnwindEbpDoubleAlignFrameEpilog(
     // Have we executed the pop EBP?
     if (!InstructionAlreadyExecuted(offset, info->epilogOffs))
     {
-        pContext->pEbp = PTR_DWORD(TADDR(ESP));
+        pContext->SetEbpLocation(PTR_DWORD(TADDR(ESP)));
         ESP += sizeof(void*);
     }
     offset = SKIP_POP_REG(epilogBase, offset);
@@ -3434,6 +3453,12 @@ void UnwindEbpDoubleAlignFrameEpilog(
     pContext->SP = ESP;
 }
 
+inline SIZE_T GetStackParameterSize(hdrInfo * info)
+{
+    SUPPORTS_DAC;
+    return (info->varargs ? 0 : info->argSize); // Note varargs is caller-popped
+}
+
 //****************************************************************************
 // This is the value ESP is incremented by on doing a "return"
 
@@ -3441,8 +3466,7 @@ inline SIZE_T ESPIncrOnReturn(hdrInfo * info)
 {
     SUPPORTS_DAC;
     return sizeof(void *) + // pop off the return address
-           // Note varargs is caller-popped
-           (info->varargs ? 0 : info->argSize);
+           GetStackParameterSize(info);
 }
 
 /*****************************************************************************/
@@ -3551,16 +3575,16 @@ void UnwindEspFrameProlog(
 
     // Always restore EBP
     if (regsMask & RM_EBP)
-        pContext->pEbp = savedRegPtr++;
+        pContext->SetEbpLocation(savedRegPtr++);
 
     if (flags & UpdateAllRegs)
     {
         if (regsMask & RM_EBX)
-            pContext->pEbx = savedRegPtr++;
+            pContext->SetEbxLocation(savedRegPtr++);
         if (regsMask & RM_ESI)
-            pContext->pEsi = savedRegPtr++;
+            pContext->SetEsiLocation(savedRegPtr++);
         if (regsMask & RM_EDI)
-            pContext->pEdi = savedRegPtr++;
+            pContext->SetEdiLocation(savedRegPtr++);
 
         TRASH_CALLEE_UNSAVED_REGS(pContext);
     }
@@ -3626,8 +3650,7 @@ void UnwindEspFrame(
             if ((regMask & regsMask) == 0)
                 continue;
             
-            SIZE_T offsetOfRegPtr = REGDISPLAY_OFFSET_OF_CALLEE_SAVED_REGISTERS[i - 1];
-            *(LPVOID*)(PBYTE(pContext) + offsetOfRegPtr) = PTR_DWORD((TADDR)ESP);
+            SetLocation(pContext, i - 1, PTR_DWORD((TADDR)ESP));
 
             ESP += sizeof(unsigned);
         }
@@ -3705,7 +3728,7 @@ void UnwindEbpDoubleAlignFrameProlog(
        can be determined using EBP. Since we are still in the prolog,
        we need to know our exact location to determine the callee-saved registers */
        
-    const unsigned curEBP = *pContext->pEbp;
+    const unsigned curEBP = *pContext->GetEbpLocation();
     
     if (flags & UpdateAllRegs)
     {        
@@ -3738,8 +3761,7 @@ void UnwindEbpDoubleAlignFrameProlog(
             
             if (InstructionAlreadyExecuted(offset, curOffs))
             {
-                SIZE_T offsetOfRegPtr = REGDISPLAY_OFFSET_OF_CALLEE_SAVED_REGISTERS[i];
-                *(LPVOID*)(PBYTE(pContext) + offsetOfRegPtr) = --pSavedRegs;
+                SetLocation(pContext, i, PTR_DWORD(--pSavedRegs));
             }
 
             // "push reg"
@@ -3751,7 +3773,7 @@ void UnwindEbpDoubleAlignFrameProlog(
     
     /* The caller's saved EBP is pointed to by our EBP */
 
-    pContext->pEbp = PTR_DWORD((TADDR)curEBP);
+    pContext->SetEbpLocation(PTR_DWORD((TADDR)curEBP));
     pContext->SP = DWORD((TADDR)(curEBP + sizeof(void *)));
     
     /* Stack pointer points to return address */
@@ -3775,7 +3797,7 @@ bool UnwindEbpDoubleAlignFrame(
     _ASSERTE(info->ebpFrame || info->doubleAlign);
 
     const unsigned curESP =  pContext->SP;
-    const unsigned curEBP = *pContext->pEbp;
+    const unsigned curEBP = *pContext->GetEbpLocation();
 
     /* First check if we are in a filter (which is obviously after the prolog) */
 
@@ -3818,8 +3840,13 @@ bool UnwindEbpDoubleAlignFrame(
             {
                 static DWORD s_badData = 0xDEADBEEF;
 
-                pContext->pEax = pContext->pEbx = pContext->pEcx =
-                pContext->pEdx = pContext->pEsi = pContext->pEdi = &s_badData;
+                pContext->SetEaxLocation(&s_badData);
+                pContext->SetEcxLocation(&s_badData);
+                pContext->SetEdxLocation(&s_badData);
+
+                pContext->SetEbxLocation(&s_badData);
+                pContext->SetEsiLocation(&s_badData);
+                pContext->SetEdiLocation(&s_badData);
             }
 #endif
 
@@ -3862,8 +3889,7 @@ bool UnwindEbpDoubleAlignFrame(
             if ((info->savedRegMask & regMask) == 0)
                 continue;
             
-            SIZE_T offsetOfRegPtr = REGDISPLAY_OFFSET_OF_CALLEE_SAVED_REGISTERS[i];
-            *(LPVOID*)(PBYTE(pContext) + offsetOfRegPtr) = --pSavedRegs;
+            SetLocation(pContext, i, --pSavedRegs);
         }
     }
 
@@ -3878,7 +3904,7 @@ bool UnwindEbpDoubleAlignFrame(
 
     /* The caller's saved EBP is pointed to by our EBP */
 
-    pContext->pEbp = PTR_DWORD((TADDR)curEBP);
+    pContext->SetEbpLocation(PTR_DWORD((TADDR)curEBP));
 
     return true;
 }
@@ -4093,7 +4119,8 @@ void promoteVarArgs(PTR_BYTE argsStart, PTR_VASigCookie varArgSig, GCCONTEXT* ct
 
 INDEBUG(void* forceStack1;)
 
-#if defined(_TARGET_X86_)
+#ifndef CROSSGEN_COMPILE
+#ifndef USE_GC_INFO_DECODER
 
 /*****************************************************************************
  *
@@ -4117,7 +4144,7 @@ bool EECodeManager::EnumGcRefs( PREGDISPLAY     pContext,
     GCInfoToken gcInfoToken = pCodeInfo->GetGCInfoToken();
     unsigned  curOffs = pCodeInfo->GetRelOffset();
 
-    unsigned  EBP     = *pContext->pEbp;
+    unsigned  EBP     = *pContext->GetEbpLocation();
     unsigned  ESP     =  pContext->SP;
 
     unsigned  ptrOffs;
@@ -4184,7 +4211,7 @@ bool EECodeManager::EnumGcRefs( PREGDISPLAY     pContext,
             if (dspPtr)                                                 \
                 printf("    Live pointer register %s: ", #regName);     \
                 pCallBack(hCallBack,                                    \
-                          (OBJECTREF*)(pContext->p##regName),           \
+                          (OBJECTREF*)(pContext->Get##regName##Location()), \
                           (iptr ? GC_CALL_INTERIOR : 0)                 \
                           | CHECK_APP_DOMAIN                            \
                           DAC_ARG(DacSlotLocation(reg, 0, false)));     \
@@ -4193,7 +4220,7 @@ bool EECodeManager::EnumGcRefs( PREGDISPLAY     pContext,
 #define CHK_AND_REPORT_REG(reg, doIt, iptr, regName)                    \
         if  (doIt)                                                      \
                 pCallBack(hCallBack,                                    \
-                          (OBJECTREF*)(pContext->p##regName),           \
+                          (OBJECTREF*)(pContext->Get##regName##Location()), \
                           (iptr ? GC_CALL_INTERIOR : 0)                 \
                           | CHECK_APP_DOMAIN                            \
                           DAC_ARG(DacSlotLocation(reg, 0, false)));
@@ -4734,7 +4761,7 @@ bool EECodeManager::EnumGcRefs( PREGDISPLAY     pContext,
     return true;
 }
 
-#elif defined(USE_GC_INFO_DECODER) && !defined(CROSSGEN_COMPILE) // !defined(_TARGET_X86_)
+#else // !USE_GC_INFO_DECODER
 
 
 /*****************************************************************************
@@ -4774,7 +4801,6 @@ bool EECodeManager::EnumGcRefs( PREGDISPLAY     pRD,
     GCInfoToken gcInfoToken = pCodeInfo->GetGCInfoToken();
 
 #if defined(STRESS_HEAP) && defined(PARTIALLY_INTERRUPTIBLE_GC_SUPPORTED)
-#ifdef USE_GC_INFO_DECODER
     // When we simulate a hijack during gcstress
     //  we start with ActiveStackFrame and the offset
     //  after the call
@@ -4797,7 +4823,6 @@ bool EECodeManager::EnumGcRefs( PREGDISPLAY     pRD,
             flags &= ~((unsigned)ActiveStackFrame);
         }
     }
-#endif // USE_GC_INFO_DECODER
 #endif // STRESS_HEAP && PARTIALLY_INTERRUPTIBLE_GC_SUPPORTED
 
 #ifdef _DEBUG
@@ -4812,7 +4837,6 @@ bool EECodeManager::EnumGcRefs( PREGDISPLAY     pRD,
     }
 #endif
 
-#ifdef USE_GC_INFO_DECODER
     /* If we are not in the active method, we are currently pointing
          * to the return address; at the return address stack variables
          * can become dead if the call is the last instruction of a try block
@@ -4872,7 +4896,6 @@ bool EECodeManager::EnumGcRefs( PREGDISPLAY     pRD,
             methodName, curOffs));
     }
 
-#endif  // USE_GC_INFO_DECODER
 
 #if defined(WIN64EXCEPTIONS)   // funclets
     if (pCodeInfo->GetJitManager()->IsFilterFunclet(pCodeInfo))
@@ -4970,11 +4993,11 @@ bool EECodeManager::EnumGcRefs( PREGDISPLAY     pRD,
 
         _ASSERTE(prevSP + VASigCookieOffset >= dac_cast<PTR_BYTE>(GetSP(pRD->pCurrentContext)));        
 
-#if defined(_DEBUG) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
+#if defined(_DEBUG) && !defined(DACCESS_COMPILE)
         // Note that I really want to say hCallBack is a GCCONTEXT, but this is pretty close
         extern void GcEnumObject(LPVOID pData, OBJECTREF *pObj, uint32_t flags);
         _ASSERTE((void*) GcEnumObject == pCallBack);
-#endif
+#endif // _DEBUG && !DACCESS_COMPILE
         GCCONTEXT   *pCtx = (GCCONTEXT *) hCallBack;
 
         // For varargs, look up the signature using the varArgSig token passed on the stack
@@ -4987,21 +5010,10 @@ bool EECodeManager::EnumGcRefs( PREGDISPLAY     pRD,
 
 }
 
-#else // !defined(_TARGET_X86_) && !(defined(USE_GC_INFO_DECODER) && !defined(CROSSGEN_COMPILE))
-
-bool EECodeManager::EnumGcRefs( PREGDISPLAY     pContext,
-                                EECodeInfo     *pCodeInfo,
-                                unsigned        flags,
-                                GCEnumCallback  pCallBack,
-                                LPVOID          hCallBack,
-                                DWORD           relOffsetOverride)
-{
-    PORTABILITY_ASSERT("EECodeManager::EnumGcRefs is not implemented on this platform.");
-    return false;
-}
-
-#endif // _TARGET_X86_
+#endif // USE_GC_INFO_DECODER
+#endif // !CROSSGEN_COMPILE
 
+#ifdef _TARGET_X86_
 /*****************************************************************************
  *
  *  Return the address of the local security object reference
@@ -5012,20 +5024,17 @@ bool EECodeManager::EnumGcRefs( PREGDISPLAY     pContext,
 OBJECTREF* EECodeManager::GetAddrOfSecurityObjectFromCachedInfo(PREGDISPLAY pRD, StackwalkCacheUnwindInfo * stackwalkCacheUnwindInfo)
 {
     LIMITED_METHOD_CONTRACT;
-#ifdef _TARGET_X86_
     size_t securityObjectOffset = stackwalkCacheUnwindInfo->securityObjectOffset;
+
     _ASSERTE(securityObjectOffset != 0);
     // We pretend that filters are ESP-based methods in UnwindEbpDoubleAlignFrame().
     // Hence we cannot enforce this assert.
     // _ASSERTE(stackwalkCacheUnwindInfo->fUseEbpAsFrameReg);
-    return (OBJECTREF *) (size_t) (DWORD(*pRD->pEbp) - (securityObjectOffset * sizeof(void*)));
-#else
-    PORTABILITY_ASSERT("EECodeManager::GetAddrOfSecurityObjectFromContext is not implemented on this platform.");
-    return NULL;
-#endif
+    return (OBJECTREF *) (size_t) (*pRD->GetEbpLocation() - (securityObjectOffset * sizeof(void*)));
 }
+#endif // _TARGET_X86_
 
-#ifndef DACCESS_COMPILE
+#if !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)
 OBJECTREF* EECodeManager::GetAddrOfSecurityObject(CrawlFrame *pCF)
 {
     CONTRACTL {
@@ -5043,7 +5052,7 @@ OBJECTREF* EECodeManager::GetAddrOfSecurityObject(CrawlFrame *pCF)
 
     _ASSERTE(sizeof(CodeManStateBuf) <= sizeof(pState->stateBuf));
 
-#if defined(_TARGET_X86_)
+#ifndef USE_GC_INFO_DECODER
     CodeManStateBuf * stateBuf = (CodeManStateBuf*)pState->stateBuf;
 
     /* Extract the necessary information from the info block header */
@@ -5058,10 +5067,10 @@ OBJECTREF* EECodeManager::GetAddrOfSecurityObject(CrawlFrame *pCF)
         if(stateBuf->hdrInfoBody.prologOffs == hdrInfo::NOT_IN_PROLOG &&
                 stateBuf->hdrInfoBody.epilogOffs == hdrInfo::NOT_IN_EPILOG)
         {
-            return (OBJECTREF *)(size_t)(((DWORD)*pRD->pEbp) - GetSecurityObjectOffset(&stateBuf->hdrInfoBody));
+            return (OBJECTREF *)(size_t)(*pRD->GetEbpLocation() - GetSecurityObjectOffset(&stateBuf->hdrInfoBody));
         }
     }
-#elif defined(USE_GC_INFO_DECODER) && !defined(CROSSGEN_COMPILE)
+#else // !USE_GC_INFO_DECODER
 
     GcInfoDecoder gcInfoDecoder(
             gcInfoToken,
@@ -5096,14 +5105,13 @@ OBJECTREF* EECodeManager::GetAddrOfSecurityObject(CrawlFrame *pCF)
         OBJECTREF* pSlot = (OBJECTREF*) (spOffset + uCallerSP);
         return pSlot;
     }
-#else // !_TARGET_X86_ && !(USE_GC_INFO_DECODER && !CROSSGEN_COMPILE)
-    PORTABILITY_ASSERT("EECodeManager::GetAddrOfSecurityObject is not implemented on this platform.");
-#endif
+#endif // USE_GC_INFO_DECODER
 
     return NULL;
 }
-#endif
+#endif // !DACCESS_COMPILE && !CROSSGEN_COMPILE
 
+#ifndef CROSSGEN_COMPILE
 /*****************************************************************************
  *
  *  Returns "this" pointer if it is a non-static method
@@ -5125,7 +5133,7 @@ OBJECTREF EECodeManager::GetInstance( PREGDISPLAY    pContext,
         SUPPORTS_DAC;
     } CONTRACTL_END;
 
-#ifdef _TARGET_X86_
+#ifndef USE_GC_INFO_DECODER
     GCInfoToken gcInfoToken = pCodeInfo->GetGCInfoToken();
     unsigned    relOffset = pCodeInfo->GetRelOffset();
 
@@ -5160,7 +5168,7 @@ OBJECTREF EECodeManager::GetInstance( PREGDISPLAY    pContext,
     if (info.ebpFrame)
     {
         _ASSERTE(stackDepth == 0);
-        taArgBase = *pContext->pEbp;
+        taArgBase = *pContext->GetEbpLocation();
     }
     else
     {
@@ -5233,25 +5241,22 @@ OBJECTREF EECodeManager::GetInstance( PREGDISPLAY    pContext,
 #endif
 
     return NULL;
-#elif defined(USE_GC_INFO_DECODER) && !defined(CROSSGEN_COMPILE)
+#else // !USE_GC_INFO_DECODER
     PTR_VOID token = EECodeManager::GetExactGenericsToken(pContext, pCodeInfo);
 
     OBJECTREF oRef = ObjectToOBJECTREF(PTR_Object(dac_cast<TADDR>(token)));
     VALIDATEOBJECTREF(oRef);
     return oRef;
-#else // !_TARGET_X86_ && !(USE_GC_INFO_DECODER && !CROSSGEN_COMPILE)
-    PORTABILITY_ASSERT("Port: EECodeManager::GetInstance is not implemented on this platform.");
-    return NULL;
-#endif // _TARGET_X86_
+#endif // USE_GC_INFO_DECODER
 }
-
+#endif // !CROSSGEN_COMPILE
 
 GenericParamContextType EECodeManager::GetParamContextType(PREGDISPLAY     pContext,
                                                            EECodeInfo *    pCodeInfo)
 {
     LIMITED_METHOD_DAC_CONTRACT;
 
-#ifdef _TARGET_X86_
+#ifndef USE_GC_INFO_DECODER
     /* Extract the necessary information from the info block header */
     GCInfoToken gcInfoToken = pCodeInfo->GetGCInfoToken();
     PTR_VOID    methodInfoPtr = pCodeInfo->GetGCInfo();
@@ -5269,16 +5274,16 @@ GenericParamContextType EECodeManager::GetParamContextType(PREGDISPLAY     pCont
     {
         return GENERIC_PARAM_CONTEXT_NONE;
     }
-    else if (info.genericsContextIsMethodDesc)
+
+    if (info.genericsContextIsMethodDesc)
     {
         return GENERIC_PARAM_CONTEXT_METHODDESC;
     }
-    else
-    {
-        return GENERIC_PARAM_CONTEXT_METHODTABLE;
-    }
+
+    return GENERIC_PARAM_CONTEXT_METHODTABLE;
+
     // On x86 the generic param context parameter is never this.
-#elif defined(USE_GC_INFO_DECODER)
+#else // !USE_GC_INFO_DECODER
     GCInfoToken gcInfoToken = pCodeInfo->GetGCInfoToken();
 
     GcInfoDecoder gcInfoDecoder(
@@ -5300,12 +5305,10 @@ GenericParamContextType EECodeManager::GetParamContextType(PREGDISPLAY     pCont
         return GENERIC_PARAM_CONTEXT_THIS;
     }
     return GENERIC_PARAM_CONTEXT_NONE;
-#else // !_TARGET_X86_ && !USE_GC_INFO_DECODER
-    PORTABILITY_ASSERT("Port: EECodeManager::GetParamContextType is not implemented on this platform.");
-    return GENERIC_PARAM_CONTEXT_NONE;
-#endif // _TARGET_X86_
+#endif // USE_GC_INFO_DECODER
 }
 
+#ifndef CROSSGEN_COMPILE
 /*****************************************************************************
  *
  *  Returns the extra argument passed to to shared generic code if it is still alive.
@@ -5317,7 +5320,7 @@ PTR_VOID EECodeManager::GetParamTypeArg(PREGDISPLAY     pContext,
 {
     LIMITED_METHOD_DAC_CONTRACT;
 
-#ifdef _TARGET_X86_
+#ifndef USE_GC_INFO_DECODER
     GCInfoToken gcInfoToken = pCodeInfo->GetGCInfoToken();
     PTR_VOID    methodInfoPtr = pCodeInfo->GetGCInfo();
     unsigned    relOffset = pCodeInfo->GetRelOffset();
@@ -5340,16 +5343,14 @@ PTR_VOID EECodeManager::GetParamTypeArg(PREGDISPLAY     pContext,
     TADDR taParamTypeArg = *PTR_TADDR(fp - GetParamTypeArgOffset(&info));
     return PTR_VOID(taParamTypeArg);
 
-#elif defined(USE_GC_INFO_DECODER) && !defined(CROSSGEN_COMPILE)
+#else // !USE_GC_INFO_DECODER
     return EECodeManager::GetExactGenericsToken(pContext, pCodeInfo);
 
-#else // !_TARGET_X86_ && !(USE_GC_INFO_DECODER && !CROSSGEN_COMPILE)
-    PORTABILITY_ASSERT("Port: EECodeManager::GetInstance is not implemented on this platform.");
-    return NULL;
-#endif // _TARGET_X86_
+#endif // USE_GC_INFO_DECODER
 }
+#endif // !CROSSGEN_COMPILE
 
-#if defined(WIN64EXCEPTIONS) && !defined(CROSSGEN_COMPILE)
+#if defined(WIN64EXCEPTIONS) && defined(USE_GC_INFO_DECODER) && !defined(CROSSGEN_COMPILE)
 /*
     Returns the generics token.  This is used by GetInstance() and GetParamTypeArg() on WIN64.
 */
@@ -5368,7 +5369,6 @@ PTR_VOID EECodeManager::GetExactGenericsToken(SIZE_T          baseStackSlot,
 {
     LIMITED_METHOD_DAC_CONTRACT;
 
-#ifdef USE_GC_INFO_DECODER
     GCInfoToken gcInfoToken = pCodeInfo->GetGCInfoToken();
 
     GcInfoDecoder gcInfoDecoder(
@@ -5418,15 +5418,12 @@ PTR_VOID EECodeManager::GetExactGenericsToken(SIZE_T          baseStackSlot,
         return PTR_VOID(taExactGenericsToken);
     }
     return NULL;
-#else // USE_GC_INFO_DECODER
-    PORTABILITY_ASSERT("EECodeManager::GetExactGenericsToken");
-    return NULL;
-#endif // USE_GC_INFO_DECODER
 }
 
 
-#endif // WIN64EXCEPTIONS / CROSSGEN_COMPILE
+#endif // WIN64EXCEPTIONS && USE_GC_INFO_DECODER && !CROSSGEN_COMPILE
 
+#ifndef CROSSGEN_COMPILE
 /*****************************************************************************/
 
 void * EECodeManager::GetGSCookieAddr(PREGDISPLAY     pContext,
@@ -5443,7 +5440,14 @@ void * EECodeManager::GetGSCookieAddr(PREGDISPLAY     pContext,
     GCInfoToken    gcInfoToken = pCodeInfo->GetGCInfoToken();
     unsigned       relOffset = pCodeInfo->GetRelOffset();
 
-#if defined(_TARGET_X86_)
+#ifdef WIN64EXCEPTIONS
+    if (pCodeInfo->IsFunclet())
+    {
+        return NULL;
+    }
+#endif
+
+#ifndef USE_GC_INFO_DECODER
     CodeManStateBuf * stateBuf = (CodeManStateBuf*)pState->stateBuf;
     
     /* Extract the necessary information from the info block header */
@@ -5463,7 +5467,15 @@ void * EECodeManager::GetGSCookieAddr(PREGDISPLAY     pContext,
     
     if  (info->ebpFrame)
     {
-        return PVOID(SIZE_T((DWORD(*pContext->pEbp) - info->gsCookieOffset)));
+        DWORD curEBP;
+
+#ifdef WIN64EXCEPTIONS
+        curEBP = GetCallerSp(pContext) - 2 * 4;
+#else
+        curEBP = *pContext->pEbp;
+#endif
+
+        return PVOID(SIZE_T(curEBP - info->gsCookieOffset));
     }
     else
     {
@@ -5473,12 +5485,7 @@ void * EECodeManager::GetGSCookieAddr(PREGDISPLAY     pContext,
         return PVOID(SIZE_T(pContext->SP + argSize + info->gsCookieOffset));
     }
 
-#elif defined(USE_GC_INFO_DECODER) && !defined(CROSSGEN_COMPILE)
-    if (pCodeInfo->IsFunclet())
-    {
-        return NULL;
-    }
-
+#else // !USE_GC_INFO_DECODER
     GcInfoDecoder gcInfoDecoder(
             gcInfoToken,
             DECODE_GS_COOKIE
@@ -5496,12 +5503,11 @@ void * EECodeManager::GetGSCookieAddr(PREGDISPLAY     pContext,
     }
     return NULL;
 
-#else
-    PORTABILITY_WARNING("EECodeManager::GetGSCookieAddr is not implemented on this platform.");
-    return NULL;
-#endif
+#endif // USE_GC_INFO_DECODER
 }
+#endif // !CROSSGEN_COMPILE
 
+#ifndef USE_GC_INFO_DECODER
 /*****************************************************************************
  *
  *  Returns true if the given IP is in the given method's prolog or epilog.
@@ -5515,7 +5521,6 @@ bool EECodeManager::IsInPrologOrEpilog(DWORD       relPCoffset,
         GC_NOTRIGGER;
     } CONTRACTL_END;
 
-#ifndef USE_GC_INFO_DECODER
     hdrInfo info;
 
     DecodeGCHdrInfo(gcInfoToken, relPCoffset, &info);
@@ -5525,10 +5530,6 @@ bool EECodeManager::IsInPrologOrEpilog(DWORD       relPCoffset,
 
     return ((info.prologOffs != hdrInfo::NOT_IN_PROLOG) || 
             (info.epilogOffs != hdrInfo::NOT_IN_EPILOG));
-#else // USE_GC_INFO_DECODER
-    _ASSERTE(!"@NYI - EECodeManager::IsInPrologOrEpilog (EETwain.cpp)");
-    return false;
-#endif // USE_GC_INFO_DECODER
 }
 
 /*****************************************************************************
@@ -5544,7 +5545,6 @@ bool  EECodeManager::IsInSynchronizedRegion(DWORD       relOffset,
         GC_NOTRIGGER;
     } CONTRACTL_END;
 
-#ifndef USE_GC_INFO_DECODER
     hdrInfo info;
 
     DecodeGCHdrInfo(gcInfoToken, relOffset, &info);
@@ -5561,11 +5561,8 @@ bool  EECodeManager::IsInSynchronizedRegion(DWORD       relOffset,
         // Synchronized methods have at most one epilog. The epilog does not have to be at the end of the method though.
         // Everything after the epilog is also in synchronized region.
         (info.epilogCnt != 0 && info.syncEpilogStart + info.epilogSize <= relOffset);
-#else // USE_GC_INFO_DECODER
-    _ASSERTE(!"@NYI - EECodeManager::IsInSynchronizedRegion (EETwain.cpp)");
-    return false;
-#endif // USE_GC_INFO_DECODER
 }
+#endif // !USE_GC_INFO_DECODER
 
 /*****************************************************************************
  *
@@ -5579,13 +5576,13 @@ size_t EECodeManager::GetFunctionSize(GCInfoToken gcInfoToken)
         SUPPORTS_DAC;
     } CONTRACTL_END;
 
-#if defined(_TARGET_X86_)
+#ifndef USE_GC_INFO_DECODER
     hdrInfo info;
 
     DecodeGCHdrInfo(gcInfoToken, 0, &info);
 
     return info.methodSize;
-#elif defined(USE_GC_INFO_DECODER)
+#else // !USE_GC_INFO_DECODER
 
     GcInfoDecoder gcInfoDecoder(
             gcInfoToken,
@@ -5596,10 +5593,7 @@ size_t EECodeManager::GetFunctionSize(GCInfoToken gcInfoToken)
     _ASSERTE( codeLength > 0 );
     return codeLength;
 
-#else // !_TARGET_X86_ && !USE_GC_INFO_DECODER
-    PORTABILITY_ASSERT("EECodeManager::GetFunctionSize is not implemented on this platform.");
-    return 0;
-#endif
+#endif // USE_GC_INFO_DECODER
 }
 
 /*****************************************************************************
@@ -5619,23 +5613,21 @@ ReturnKind EECodeManager::GetReturnKind(GCInfoToken gcInfoToken)
         return RT_Illegal;
     }
 
-#if defined(_TARGET_X86_)
+#ifndef USE_GC_INFO_DECODER
     hdrInfo info;
 
     DecodeGCHdrInfo(gcInfoToken, 0, &info);
 
     return info.returnKind;
-#elif defined(USE_GC_INFO_DECODER)
+#else // !USE_GC_INFO_DECODER
 
     GcInfoDecoder gcInfoDecoder(gcInfoToken, DECODE_RETURN_KIND);
     return gcInfoDecoder.GetReturnKind();
 
-#else // !_TARGET_X86_ && !USE_GC_INFO_DECODER
-    PORTABILITY_ASSERT("EECodeManager::GetReturnKind is not implemented on this platform.");
-    return 0;
-#endif
+#endif // USE_GC_INFO_DECODER
 }
 
+#ifndef USE_GC_INFO_DECODER
 /*****************************************************************************
  *
  *  Returns the size of the frame of the given function.
@@ -5647,7 +5639,6 @@ unsigned int EECodeManager::GetFrameSize(GCInfoToken gcInfoToken)
         GC_NOTRIGGER;
     } CONTRACTL_END;
 
-#ifndef USE_GC_INFO_DECODER
     hdrInfo info;
 
     DecodeGCHdrInfo(gcInfoToken, 0, &info);
@@ -5656,26 +5647,19 @@ unsigned int EECodeManager::GetFrameSize(GCInfoToken gcInfoToken)
     // in all likelyhood
     _ASSERTE(!info.doubleAlign);
     return info.stackSize;
-#else // USE_GC_INFO_DECODER
-    PORTABILITY_ASSERT("EECodeManager::GetFrameSize is not implemented on this platform.");
-    return false;
-#endif // USE_GC_INFO_DECODER
 }
+#endif // USE_GC_INFO_DECODER
 
 #ifndef DACCESS_COMPILE
 
 /*****************************************************************************/
 
+#ifndef WIN64EXCEPTIONS
 const BYTE* EECodeManager::GetFinallyReturnAddr(PREGDISPLAY pReg)
 {
     LIMITED_METHOD_CONTRACT;
 
-#ifdef _TARGET_X86_
     return *(const BYTE**)(size_t)(GetRegdisplaySP(pReg));
-#else
-    PORTABILITY_ASSERT("EECodeManager::GetFinallyReturnAddr is not implemented on this platform.");
-    return NULL;
-#endif
 }
 
 BOOL EECodeManager::IsInFilter(GCInfoToken gcInfoToken,
@@ -5688,8 +5672,6 @@ BOOL EECodeManager::IsInFilter(GCInfoToken gcInfoToken,
         GC_NOTRIGGER;
     } CONTRACTL_END;
 
-#ifdef _TARGET_X86_
-
     /* Extract the necessary information from the info block header */
 
     hdrInfo     info;
@@ -5714,15 +5696,9 @@ BOOL EECodeManager::IsInFilter(GCInfoToken gcInfoToken,
 //    _ASSERTE(nestingLevel == curNestLevel);
 
     return frameType == FR_FILTER;
-
-#else
-    PORTABILITY_ASSERT("EECodeManager::IsInFilter is not implemented on this platform.");
-    return FALSE;
-#endif
 }
 
 
-#ifndef WIN64EXCEPTIONS
 BOOL EECodeManager::LeaveFinally(GCInfoToken gcInfoToken,
                                 unsigned offset,
                                 PCONTEXT pCtx)
@@ -5921,7 +5897,7 @@ ULONG32 EECodeManager::GetStackParameterSize(EECodeInfo * pCodeInfo)
 
     // We need to subtract 4 here because ESPIncrOnReturn() includes the stack slot containing the return
     // address.
-    return (ULONG32)(ESPIncrOnReturn(pHdrInfo) - 4);
+    return (ULONG32)::GetStackParameterSize(pHdrInfo);
 
 #else
     return 0;
diff --git a/src/vm/eventreporter.cpp b/src/vm/eventreporter.cpp
index 567f4f5d51..a96c525439 100644
--- a/src/vm/eventreporter.cpp
+++ b/src/vm/eventreporter.cpp
@@ -20,9 +20,7 @@
 
 #include "../dlls/mscorrc/resource.h"
 
-#if defined(FEATURE_CORECLR)
 #include "getproductversionnumber.h"
-#endif // FEATURE_CORECLR
 
 //---------------------------------------------------------------------------------------
 //
@@ -84,30 +82,13 @@ EventReporter::EventReporter(EventReporterType type)
 
     ssMessage.Clear();
     if(!ssMessage.LoadResource(CCompRC::Optional, IDS_ER_FRAMEWORK_VERSION))
-#ifndef FEATURE_CORECLR
-        m_Description.Append(W("Framework Version: "));
-#else // FEATURE_CORECLR
         m_Description.Append(W("CoreCLR Version: "));
-#endif // !FEATURE_CORECLR
     else
     {
         m_Description.Append(ssMessage);
     }
 
     BOOL fHasVersion = FALSE;
-#ifndef FEATURE_CORECLR
-    if (GetCLRModule() != NULL)
-    {
-        WCHAR buffer[80];
-        DWORD length;
-        if (SUCCEEDED(GetCORVersionInternal(buffer, 80, &length)))
-        {
-            m_Description.Append(buffer);
-            m_Description.Append(W("\n"));
-            fHasVersion = TRUE;
-        }
-    }
-#else // FEATURE_CORECLR
     DWORD dwMajorVersion = 0;
     DWORD dwMinorVersion = 0;
     DWORD dwBuild = 0;
@@ -115,7 +96,6 @@ EventReporter::EventReporter(EventReporterType type)
     EventReporter::GetCoreCLRInstanceProductVersion(&dwMajorVersion, &dwMinorVersion, &dwBuild, &dwRevision);
     m_Description.AppendPrintf(W("%lu.%lu.%lu.%lu\n"),dwMajorVersion, dwMinorVersion, dwBuild, dwRevision);
     fHasVersion = TRUE;
-#endif // !FEATURE_CORECLR
 
     if (!fHasVersion)
     {
@@ -699,7 +679,6 @@ void DoReportForUnhandledException(PEXCEPTION_POINTERS pExceptionInfo)
                 gc.throwable = pThread->GetThrowable();
                 _ASSERTE(gc.throwable != NULL);
 
-#ifdef FEATURE_CORECLR
                 // On CoreCLR, managed code execution happens in non-default AppDomains and all threads have an AD transition
                 // at their base from DefaultDomain to the target Domain before they start executing managed code. Thus, when 
                 // an exception goes unhandled in a non-default AppDomain on a reverse pinvoke thread, the original exception details are copied 
@@ -741,7 +720,6 @@ void DoReportForUnhandledException(PEXCEPTION_POINTERS pExceptionInfo)
                     }
                 }
                 else
-#endif // FEATURE_CORECLR
                 {
                     if (IsException(gc.throwable->GetMethodTable()))
                     {
@@ -796,7 +774,6 @@ void DoReportForUnhandledException(PEXCEPTION_POINTERS pExceptionInfo)
     }
 }
 
-#if defined(FEATURE_CORECLR)
 // This function will return the product version of CoreCLR
 // instance we are executing in.
 void EventReporter::GetCoreCLRInstanceProductVersion(DWORD * pdwMajor, DWORD * pdwMinor, DWORD * pdwBuild, DWORD * pdwRevision)
@@ -834,4 +811,3 @@ void EventReporter::GetCoreCLRInstanceProductVersion(DWORD * pdwMajor, DWORD * p
         LOG((LF_CORDB, LL_INFO100, "GetCoreCLRInstanceVersion: Unable to get CoreCLR version.\n"));
     }
 }
-#endif // FEATURE_CORECLR
diff --git a/src/vm/eventreporter.h b/src/vm/eventreporter.h
index ecbc9d1382..54317133dd 100644
--- a/src/vm/eventreporter.h
+++ b/src/vm/eventreporter.h
@@ -49,9 +49,7 @@ private:
     // Flag to indicate if the buffer is full
     BOOL fBufferFull;
 
-#ifdef FEATURE_CORECLR
     static void GetCoreCLRInstanceProductVersion(DWORD * pdwMajor, DWORD * pdwMinor, DWORD * pdwBuild, DWORD * pdwRevision);
-#endif // FEATURE_CORECLR
 
 public:
     // Construct 
diff --git a/src/vm/eventtrace.cpp b/src/vm/eventtrace.cpp
index cec79214a4..c40797effb 100644
--- a/src/vm/eventtrace.cpp
+++ b/src/vm/eventtrace.cpp
@@ -4336,16 +4336,10 @@ HRESULT ETW::CEtwTracer::Register()
     EventRegisterMicrosoft_Windows_DotNETRuntimeRundown();
 
     // Stress Log ETW events are available only on the desktop version of the runtime
-#ifndef FEATURE_CORECLR
-    EventRegisterMicrosoft_Windows_DotNETRuntimeStress();
-#endif // !FEATURE_CORECLR
 
     MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context.RegistrationHandle = Microsoft_Windows_DotNETRuntimeHandle;
     MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context.RegistrationHandle = Microsoft_Windows_DotNETRuntimePrivateHandle;
     MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context.RegistrationHandle = Microsoft_Windows_DotNETRuntimeRundownHandle;
-#ifndef FEATURE_CORECLR
-    MICROSOFT_WINDOWS_DOTNETRUNTIME_STRESS_PROVIDER_Context.RegistrationHandle = Microsoft_Windows_DotNETRuntimeStressHandle;
-#endif // !FEATURE_CORECLR
 
     return S_OK;
 }
@@ -4371,9 +4365,6 @@ HRESULT ETW::CEtwTracer::UnRegister()
     EventUnregisterMicrosoft_Windows_DotNETRuntime();
     EventUnregisterMicrosoft_Windows_DotNETRuntimePrivate();
     EventUnregisterMicrosoft_Windows_DotNETRuntimeRundown();
-#ifndef FEATURE_CORECLR
-    EventUnregisterMicrosoft_Windows_DotNETRuntimeStress();
-#endif // !FEATURE_CORECLR
     return S_OK;
 }
 
@@ -4923,11 +4914,7 @@ VOID ETW::InfoLog::RuntimeInformation(INT32 type)
                 g_fEEComActivatedStartup ||      //CLR started as a COM object
                 g_fEEOtherStartup  );            //In case none of the 4 above mentioned cases are true for example ngen, ildasm then we asssume its a "other" startup
 
-#ifdef FEATURE_CORECLR
             Sku = ETW::InfoLog::InfoStructs::CoreCLR;
-#else
-            Sku = ETW::InfoLog::InfoStructs::DesktopCLR;
-#endif //FEATURE_CORECLR
         
             //version info for clr.dll
             USHORT vmMajorVersion = VER_MAJORVERSION;
@@ -4946,30 +4933,6 @@ VOID ETW::InfoLog::RuntimeInformation(INT32 type)
             PCWSTR lpwszCommandLine = W("");
             
 
-#ifndef FEATURE_CORECLR
-            startupFlags = CorHost2::GetStartupFlags();
-
-            // Some of the options specified by the startup flags can be overwritten by config files. 
-            // Strictly speaking since the field in this event is called StartupFlags there's nothing 
-            // wrong with just showing the actual startup flags but it makes it less useful (a more 
-            // appropriate name for the field is StartupOptions).
-            startupFlags &= ~STARTUP_CONCURRENT_GC;
-            if (g_pConfig->GetGCconcurrent())
-                startupFlags |= STARTUP_CONCURRENT_GC;
-
-            if (g_pConfig->DefaultSharePolicy() != AppDomain::SHARE_POLICY_UNSPECIFIED)
-            {
-                startupFlags &= ~STARTUP_LOADER_OPTIMIZATION_MASK;
-                startupFlags |= g_pConfig->DefaultSharePolicy() << 1;
-            }
-
-            startupFlags &= ~STARTUP_LEGACY_IMPERSONATION;
-            startupFlags &= ~STARTUP_ALWAYSFLOW_IMPERSONATION;
-            if (g_pConfig->ImpersonationMode() == IMP_NOFLOW)
-                startupFlags |= STARTUP_LEGACY_IMPERSONATION;
-            else if (g_pConfig->ImpersonationMode() == IMP_ALWAYSFLOW)
-                startupFlags |= STARTUP_ALWAYSFLOW_IMPERSONATION;
-#endif //!FEATURE_CORECLR
 
             // Determine the startupmode
             if(g_fEEIJWStartup)
@@ -5477,9 +5440,6 @@ VOID ETW::MethodLog::MethodTableRestored(MethodTable *pMethodTable)
 VOID ETW::SecurityLog::StrongNameVerificationStart(DWORD dwInFlags, __in LPWSTR strFullyQualifiedAssemblyName)
 {
     WRAPPER_NO_CONTRACT;
-#ifndef FEATURE_CORECLR
-    FireEtwStrongNameVerificationStart_V1(dwInFlags, 0, strFullyQualifiedAssemblyName, GetClrInstanceId());
-#endif // !FEATURE_CORECLR
 }
 
 
@@ -5489,9 +5449,6 @@ VOID ETW::SecurityLog::StrongNameVerificationStart(DWORD dwInFlags, __in LPWSTR
 VOID ETW::SecurityLog::StrongNameVerificationStop(DWORD dwInFlags,ULONG result, __in LPWSTR strFullyQualifiedAssemblyName)
 {
     WRAPPER_NO_CONTRACT;
-#ifndef FEATURE_CORECLR
-    FireEtwStrongNameVerificationStop_V1(dwInFlags, result, strFullyQualifiedAssemblyName, GetClrInstanceId());
-#endif // !FEATURE_CORECLR
 }
 
 /****************************************************************************/
@@ -5832,9 +5789,6 @@ VOID ETW::LoaderLog::SendAssemblyEvent(Assembly *pAssembly, DWORD dwEventOptions
     ULONGLONG ullAssemblyId = (ULONGLONG)pAssembly;
     ULONGLONG ullDomainId = (ULONGLONG)pAssembly->GetDomain();
     ULONGLONG ullBindingID = 0;
-#if (defined FEATURE_PREJIT) && (defined FEATURE_FUSION)  
-    ullBindingID = pAssembly->GetManifestFile()->GetBindingID();
-#endif
     ULONG ulAssemblyFlags = ((bIsDomainNeutral ? ETW::LoaderLog::LoaderStructs::DomainNeutralAssembly : 0) |
                              (bIsDynamicAssembly ? ETW::LoaderLog::LoaderStructs::DynamicAssembly : 0) |
                              (bHasNativeImage ? ETW::LoaderLog::LoaderStructs::NativeAssembly : 0) |
@@ -6853,11 +6807,8 @@ VOID ETW::MethodLog::SendEventsForNgenMethods(Module *pModule, DWORD dwEventOpti
     if (!pModule)
         return;
 
-    PEImageLayout * pLoadedLayout = pModule->GetFile()->GetLoaded();
-    _ASSERTE(pLoadedLayout != NULL);
-
 #ifdef FEATURE_READYTORUN
-    if (pLoadedLayout->HasReadyToRunHeader())
+    if (pModule->IsReadyToRun())
     {
         ReadyToRunInfo::MethodIterator mi(pModule->GetReadyToRunInfo());
         while (mi.Next())
diff --git a/src/vm/excep.cpp b/src/vm/excep.cpp
index 0346c85666..a7117c2ead 100644
--- a/src/vm/excep.cpp
+++ b/src/vm/excep.cpp
@@ -58,10 +58,6 @@ IUEFManager * g_pUEFManager = NULL;
 // Support for extracting MethodDesc of a delegate.
 #include "comdelegate.h"
 
-#if defined(FEATURE_APPX_BINDER) && !defined(DACCESS_COMPILE)
-// For determining if we have a framework assembly trying to handle a corrupted state exception
-#include "policy.h"
-#endif // FEATURE_APPX && !DACCESS_COMPILE
 
 #ifndef FEATURE_PAL
 // Windows uses 64kB as the null-reference area
@@ -1644,6 +1640,7 @@ const char *TCFStringFromConst(TRY_CATCH_FINALLY tcf)
 }
 #endif //LOGGING
 
+#ifndef WIN64EXCEPTIONS
 // We're unwinding if we'll return to the EE's code.  Otherwise
 // we'll return to someplace in the current code.  Anywhere outside
 // this function is "EE code".
@@ -1675,7 +1672,6 @@ bool FinallyIsUnwinding(EHRangeTreeNode *pNode,
         return false;
 }
 
-#ifndef WIN64EXCEPTIONS
 BOOL LeaveCatch(ICodeManager* pEECM,
                 Thread *pThread,
                 CONTEXT *pCtx,
@@ -1690,7 +1686,6 @@ BOOL LeaveCatch(ICodeManager* pEECM,
     }
     CONTRACTL_END;
 
-#ifndef FEATURE_PAL
     // We can assert these things here, and skip a call
     // to COMPlusCheckForAbort later.
 
@@ -1708,10 +1703,6 @@ BOOL LeaveCatch(ICodeManager* pEECM,
 
     SetSP(pCtx, (UINT_PTR)esp);
     return TRUE;
-#else // FEATURE_PAL
-    PORTABILITY_ASSERT("LeaveCatch");
-    return FALSE;
-#endif
 }
 #endif // WIN64EXCEPTIONS
 
@@ -1926,7 +1917,7 @@ HRESULT IsLegalTransition(Thread *pThread,
                 case TCF_NONE:
                 case TCF_TRY:
                 {
-#if !defined(WIN64EXCEPTIONS)
+#ifndef WIN64EXCEPTIONS
                     if (!FinallyIsUnwinding(pNode, pEECM, pReg, addrStart))
                     {
                         CONTEXT *pFilterCtx = pThread->GetFilterContext();
@@ -1946,14 +1937,14 @@ HRESULT IsLegalTransition(Thread *pThread,
                     {
                         return CORDBG_E_CANT_SET_IP_OUT_OF_FINALLY;
                     }
-#else  // _WIN64
+#else // !WIN64EXCEPTIONS
                     // <NOTE>
                     // Setting IP out of a non-unwinding finally clause is not supported on WIN64EXCEPTIONS because of funclets.
                     // This scenario is disabled with approval from VS because it's not considered to be a common user
                     // scenario.
                     // </NOTE>
                     return CORDBG_E_CANT_SET_IP_OUT_OF_FINALLY_ON_WIN64;
-#endif // _WIN64
+#endif // WIN64EXCEPTIONS
 
                     break;
                 }
@@ -2292,7 +2283,6 @@ void StackTraceInfo::SaveStackTrace(BOOL bAllowAllocMem, OBJECTHANDLE hThrowable
     // Do not save stacktrace to preallocated exception.  These are shared.
     if (CLRException::IsPreallocatedExceptionHandle(hThrowable))
     {
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
         // Preallocated exceptions will never have this flag set. However, its possible
         // that after this flag is set for a regular exception but before we throw, we have an async
         // exception like a RudeThreadAbort, which will replace the exception
@@ -2302,7 +2292,6 @@ void StackTraceInfo::SaveStackTrace(BOOL bAllowAllocMem, OBJECTHANDLE hThrowable
         // preallocated exception will not have the restored (or any) stack trace.
         PTR_ThreadExceptionState pCurTES = GetThread()->GetExceptionState();
         pCurTES->ResetRaisingForeignException();
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 
         return;
     }
@@ -2315,14 +2304,12 @@ void StackTraceInfo::SaveStackTrace(BOOL bAllowAllocMem, OBJECTHANDLE hThrowable
     bool         fSuccess = false;
     MethodTable* pMT      = ObjectFromHandle(hThrowable)->GetTrueMethodTable();
 
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
     // Check if the flag indicating foreign exception raise has been setup or not,
     // and then reset it so that subsequent processing of managed frames proceeds
     // normally.
     PTR_ThreadExceptionState pCurTES = GetThread()->GetExceptionState();
     BOOL fRaisingForeignException = pCurTES->IsRaisingForeignException();
     pCurTES->ResetRaisingForeignException();
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 
     if (bAllowAllocMem && m_dFrameCount != 0)
     {
@@ -2363,19 +2350,15 @@ void StackTraceInfo::SaveStackTrace(BOOL bAllowAllocMem, OBJECTHANDLE hThrowable
                 struct _gc
                 {
                     StackTraceArray stackTrace;
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
                     StackTraceArray stackTraceTemp;
                     PTRARRAYREF dynamicMethodsArrayTemp;
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
                     PTRARRAYREF dynamicMethodsArray; // Object array of Managed Resolvers
                     PTRARRAYREF pOrigDynamicArray;
 
                     _gc()
                         : stackTrace()
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
                         , stackTraceTemp()
                         , dynamicMethodsArrayTemp(static_cast<PTRArray *>(NULL))
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)                        
                         , dynamicMethodsArray(static_cast<PTRArray *>(NULL))
                         , pOrigDynamicArray(static_cast<PTRArray *>(NULL))
                     {}
@@ -2384,7 +2367,6 @@ void StackTraceInfo::SaveStackTrace(BOOL bAllowAllocMem, OBJECTHANDLE hThrowable
                 _gc gc;
                 GCPROTECT_BEGIN(gc);
 
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
                 // If the flag indicating foreign exception raise has been setup, then check 
                 // if the exception object has stacktrace or not. If we have an async non-preallocated
                 // exception after setting this flag but before we throw, then the new
@@ -2399,14 +2381,11 @@ void StackTraceInfo::SaveStackTrace(BOOL bAllowAllocMem, OBJECTHANDLE hThrowable
                         fRaisingForeignException = FALSE;
                     }
                 }
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 
                 // Replace stack (i.e. build a new stack trace) only if we are not raising a foreign exception.
                 // If we are, then we will continue to extend the existing stack trace.
                 if (bReplaceStack
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
                     && (!fRaisingForeignException)
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
                     )
                 {
                     // Cleanup previous info
@@ -2440,7 +2419,6 @@ void StackTraceInfo::SaveStackTrace(BOOL bAllowAllocMem, OBJECTHANDLE hThrowable
                     // Fetch the stacktrace and the dynamic method array
                     ((EXCEPTIONREF)ObjectFromHandle(hThrowable))->GetStackTrace(gc.stackTrace, &gc.pOrigDynamicArray);
 
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
                     if (fRaisingForeignException)
                     {
                         // Just before we append to the stack trace, mark the last recorded frame to be from
@@ -2455,7 +2433,6 @@ void StackTraceInfo::SaveStackTrace(BOOL bAllowAllocMem, OBJECTHANDLE hThrowable
                             refLastElementFromForeignStackTrace.fIsLastFrameFromForeignStackTrace = TRUE;
                         }
                     }
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 
                     if (bSkipLastElement && gc.stackTrace.Size() != 0)
                         gc.stackTrace.AppendSkipLast(m_pStackTrace, m_pStackTrace + m_dFrameCount);
@@ -2477,9 +2454,7 @@ void StackTraceInfo::SaveStackTrace(BOOL bAllowAllocMem, OBJECTHANDLE hThrowable
                     }
 
                     if ((gc.pOrigDynamicArray != NULL)
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
                     || (fRaisingForeignException)
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
                     )
                     {
                         // Since we have just restored the dynamic method array as well,
@@ -3773,12 +3748,10 @@ BOOL StackTraceInfo::AppendElement(BOOL bAllowAllocMem, UINT_PTR currentIP, UINT
         pStackTraceElem->ip = currentIP;
         pStackTraceElem->sp = currentSP;
 
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
         // When we are building stack trace as we encounter managed frames during exception dispatch,
         // then none of those frames represent a stack trace from a foreign exception (as they represent
         // the current exception). Hence, set the corresponding flag to FALSE.
         pStackTraceElem->fIsLastFrameFromForeignStackTrace = FALSE;
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 
         // This is a workaround to fix the generation of stack traces from exception objects so that
         // they point to the line that actually generated the exception instead of the line
@@ -4130,32 +4103,6 @@ void DisableOSWatson(void)
     SetErrorMode(lastErrorMode | SEM_NOGPFAULTERRORBOX);
     LOG((LF_EH, LL_INFO100, "DisableOSWatson: SetErrorMode = 0x%x\n", lastErrorMode | SEM_NOGPFAULTERRORBOX));
 
-#ifndef FEATURE_CORECLR
-    // CoreCLR is always hosted and so this condition is always false
-    if (RunningOnWin7() && !CLRHosted())
-    {
-        typedef DWORD (WINAPI * GetThreadErrorModeFnPtr)(void);
-        typedef BOOL  (WINAPI * SetThreadErrorModeFnPtr)(DWORD, LPDWORD);
-        GetThreadErrorModeFnPtr pFnGetThreadErrorMode;
-        SetThreadErrorModeFnPtr pFnSetThreadErrorMode;
-
-        HINSTANCE hKernel32 = WszGetModuleHandle(WINDOWS_KERNEL32_DLLNAME_W);
-        if (hKernel32 != NULL)
-        {
-            pFnGetThreadErrorMode = (GetThreadErrorModeFnPtr)GetProcAddress(hKernel32, "GetThreadErrorMode");
-            pFnSetThreadErrorMode = (SetThreadErrorModeFnPtr)GetProcAddress(hKernel32, "SetThreadErrorMode");
-
-            // GetThreadErrorMode and SetThreadErrorMode should be available on Win7.
-            _ASSERTE((pFnGetThreadErrorMode != NULL) && (pFnSetThreadErrorMode != NULL));
-            if ((pFnGetThreadErrorMode != NULL) && (pFnSetThreadErrorMode != NULL))
-            {
-                DWORD dwOldMode = (*pFnGetThreadErrorMode)();
-                (*pFnSetThreadErrorMode)(dwOldMode | SEM_NOGPFAULTERRORBOX, &dwOldMode);
-                LOG((LF_EH, LL_INFO100, "DisableOSWatson: SetThreadErrorMode = 0x%x\n", dwOldMode | SEM_NOGPFAULTERRORBOX));
-            }
-        }
-    }
-#endif // FEATURE_CORECLR
 }
 
 
@@ -4875,7 +4822,6 @@ LONG DefaultCatchNoSwallowFilter(EXCEPTION_POINTERS *ep, PVOID pv)
     return EXCEPTION_CONTINUE_SEARCH;
 } // LONG DefaultCatchNoSwallowFilter()
 
-#if defined(FEATURE_CORECLR)
 // Note: This is used only for CoreCLR on WLC.
 //
 // We keep a pointer to the previous unhandled exception filter.  After we install, we use
@@ -4888,7 +4834,6 @@ LONG DefaultCatchNoSwallowFilter(EXCEPTION_POINTERS *ep, PVOID pv)
 // yet and having installed it but the original handler was NULL.
 static LPTOP_LEVEL_EXCEPTION_FILTER g_pOriginalUnhandledExceptionFilter = (LPTOP_LEVEL_EXCEPTION_FILTER)-1;
 #define FILTER_NOT_INSTALLED (LPTOP_LEVEL_EXCEPTION_FILTER) -1
-#endif // defined(FEATURE_CORECLR)
 
 
 BOOL InstallUnhandledExceptionFilter() {
@@ -5239,7 +5184,6 @@ LONG InternalUnhandledExceptionFilter_Worker(
     //
     if (pThread && (pThread->HasThreadStateNC(Thread::TSNC_ProcessedUnhandledException) || pThread->HasThreadStateNC(Thread::TSNC_AppDomainContainUnhandled)))
     {
-#ifdef FEATURE_CORECLR
         // This assert shouldnt be hit in CoreCLR since:
         //
         // 1) It has no concept of managed entry point that is invoked by the shim. You can
@@ -5253,7 +5197,6 @@ LONG InternalUnhandledExceptionFilter_Worker(
         {
             _ASSERTE(!"How come a thread with TSNC_ProcessedUnhandledException state entered the UEF on CoreCLR?");
         }
-#endif // FEATURE_CORECLR
 
         LOG((LF_EH, LL_INFO100, "InternalUnhandledExceptionFilter_Worker: have already processed unhandled exception for this thread.\n"));
         return EXCEPTION_CONTINUE_SEARCH;
@@ -5335,7 +5278,6 @@ LONG InternalUnhandledExceptionFilter_Worker(
         {
             BOOL fIsProcessTerminating = TRUE;
 
-#ifdef FEATURE_CORECLR
             // In CoreCLR, we can be asked to not let an exception go unhandled on managed threads in a given AppDomain.
             // If the exception reaches the top of the thread's stack, we simply deliver AppDomain's UnhandledException event and
             // return back to the filter, instead of letting the process terminate because of unhandled exception.
@@ -5359,7 +5301,6 @@ LONG InternalUnhandledExceptionFilter_Worker(
                 fIsProcessTerminating = !(pParam->pThread->GetDomain()->IgnoreUnhandledExceptions());
             else
                 fIsProcessTerminating = !(pParam->pThread->HasThreadStateNC(Thread::TSNC_IgnoreUnhandledExceptions));
-#endif // FEATURE_CORECLR
 
 #ifndef FEATURE_PAL
             // Setup the watson bucketing details for UE processing.
@@ -5371,14 +5312,12 @@ LONG InternalUnhandledExceptionFilter_Worker(
             // Send notifications to the AppDomains.
             NotifyAppDomainsOfUnhandledException(pParam->pExceptionInfo, NULL, useLastThrownObject, fIsProcessTerminating /*isTerminating*/);
 
-#ifdef FEATURE_CORECLR
             // If the process is not terminating, then return back to the filter and ask it to execute
             if (!fIsProcessTerminating)
             {
                 pParam->retval = EXCEPTION_EXECUTE_HANDLER;
                 goto lDone;
             }
-#endif // FEATURE_CORECLR
         }
         else
         {
@@ -5564,7 +5503,6 @@ LONG InternalUnhandledExceptionFilter(
     //
     // Note: Also see the conditional UEF registration with the OS in EEStartupHelper.
 
-#ifdef FEATURE_CORECLR
     // We would be here only on CoreCLR for WLC since we dont register
     // the UEF with the OS for SL.
     if (g_pOriginalUnhandledExceptionFilter != FILTER_NOT_INSTALLED
@@ -5572,7 +5510,6 @@ LONG InternalUnhandledExceptionFilter(
     {
         STRESS_LOG1(LF_EH, LL_INFO100, "InternalUnhandledExceptionFilter: Not chaining back to previous UEF at address %p on CoreCLR!\n", g_pOriginalUnhandledExceptionFilter);
     }
-#endif // FEATURE_CORECLR
 
     return retval;
 
@@ -5640,9 +5577,9 @@ LONG EntryPointFilter(PEXCEPTION_POINTERS pExceptionInfo, PVOID _pData)
 // Returns
 //   the result of calling InternalUnhandledExceptionFilter
 //------------------------------------------------------------------------------
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_PAL)
+#if !defined(FEATURE_PAL)
 #pragma code_seg(push, uef, CLR_UEF_SECTION_NAME)
-#endif // FEATURE_CORECLR && !FEATURE_PAL
+#endif // !FEATURE_PAL
 LONG __stdcall COMUnhandledExceptionFilter(     // EXCEPTION_CONTINUE_SEARCH or EXCEPTION_CONTINUE_EXECUTION
     EXCEPTION_POINTERS *pExceptionInfo)         // Information about the exception.
 {
@@ -5670,47 +5607,6 @@ LONG __stdcall COMUnhandledExceptionFilter(     // EXCEPTION_CONTINUE_SEARCH or
         return retVal;
     }
 
-#ifndef FEATURE_CORECLR
-#ifdef _DEBUG
-    // V4 onwards, we will reach here in the UEF only on the following conditions:
-    //
-    // 1) Faulting address is in native code on a reverse pinvoke thread. An example is an exception that escaped
-    //    out of the reverse pinvoke thread but was caught in the native part of the thread. The native part then
-    //    had another exception that went unhandled. The difference between this and (3) below is that
-    //    we have a thread object here but not in (3).
-    //
-    //    An exception from PInvoke, that is never caught/rethrown in managed code and goes unhandled, also falls
-    //    in this category.
-    //
-    // 2) The exception escaped out of a reverse pinvoke thread and went unhandled.
-    //
-    // 3) Faulting thread was never seen by the runtime. An example is a another native thread
-    //    which the user code created that had unhandled exception.
-    //
-    // 4) A corrupting exception may become unhandled.
-    //
-    // This is not applicable to CoreCLR, as this unhandled exception filter is always set up, and all hardware exceptions in
-    // managed code, including those that are not process-corrupting, such as integer division by zero, will end up here.
-
-    // Assert these conditions here - we shouldnt be here for any other unhandled exception processing.
-    Thread *pThread = GetThread();
-    if ((pThread != NULL) && // condition 3
-        !(pThread->GetExceptionState()->IsExceptionInProgress() &&
-            pThread->GetExceptionState()->GetFlags()->ReversePInvokeEscapingException()) && // condition 2
-        (ExecutionManager::IsManagedCode((PCODE)pExceptionInfo->ExceptionRecord->ExceptionAddress))) // condition 1
-    {
-#ifdef FEATURE_CORRUPTING_EXCEPTIONS
-        if (!CEHelper::IsProcessCorruptedStateException(pExceptionInfo->ExceptionRecord->ExceptionCode)) // condition 4
-        {
-            GCX_COOP();
-            _ASSERTE(CEHelper::IsProcessCorruptedStateException(pThread->GetThrowable())); // condition 4
-        }
-#else // !FEATURE_CORRUPTING_EXCEPTIONS
-        _ASSERTE(false);
-#endif // FEATURE_CORRUPTING_EXCEPTIONS
-    }
-#endif // _DEBUG
-#endif // !FEATURE_CORECLR
 
     retVal = InternalUnhandledExceptionFilter(pExceptionInfo);
 
@@ -5723,9 +5619,9 @@ LONG __stdcall COMUnhandledExceptionFilter(     // EXCEPTION_CONTINUE_SEARCH or
 
     return retVal;
 } // LONG __stdcall COMUnhandledExceptionFilter()
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_PAL)
+#if !defined(FEATURE_PAL)
 #pragma code_seg(pop, uef)
-#endif // FEATURE_CORECLR && !FEATURE_PAL
+#endif // !FEATURE_PAL
 
 void PrintStackTraceToStdout();
 
@@ -6819,10 +6715,8 @@ exit:
 
 #ifndef FEATURE_PAL
 
-#ifdef FEATURE_CORECLR
     // Only proceed if Watson is enabled - CoreCLR may have it disabled.
     if (IsWatsonEnabled())
-#endif // FEATURE_CORECLR
     {
         BOOL fClearUEWatsonBucketTracker = TRUE;
         PTR_EHWatsonBucketTracker pUEWatsonBucketTracker = pThread->GetExceptionState()->GetUEWatsonBucketTracker();
@@ -7125,16 +7019,16 @@ bool IsInterceptableException(Thread *pThread)
 // appropriate exception code, or zero if the code is not a GC marker.
 DWORD GetGcMarkerExceptionCode(LPVOID ip)
 {
-#if defined(HAVE_GCCOVER) && defined(FEATURE_CORECLR)
+#if defined(HAVE_GCCOVER)
     WRAPPER_NO_CONTRACT;
 
     if (GCStress<cfg_any>::IsEnabled() && IsGcCoverageInterrupt(ip))
     {
         return STATUS_CLR_GCCOVER_CODE;
     }
-#else // !(defined(HAVE_GCCOVER) && defined(FEATURE_CORECLR))
+#else // defined(HAVE_GCCOVER)
     LIMITED_METHOD_CONTRACT;
-#endif // defined(HAVE_GCCOVER) && defined(FEATURE_CORECLR)
+#endif // defined(HAVE_GCCOVER)
     return 0;
 }
 
@@ -9339,13 +9233,11 @@ BOOL SetupWatsonBucketsForNonPreallocatedExceptions(OBJECTREF oThrowable /* = NU
 {
 #ifndef DACCESS_COMPILE
 
-#ifdef FEATURE_CORECLR
     // CoreCLR may have watson bucketing conditionally enabled.
     if (!IsWatsonEnabled())
     {
         return FALSE;
     }
-#endif // FEATURE_CORECLR
 
     CONTRACTL
     {
@@ -9458,13 +9350,11 @@ BOOL SetupWatsonBucketsForEscapingPreallocatedExceptions()
 {
 #ifndef DACCESS_COMPILE
 
-#ifdef FEATURE_CORECLR
     // CoreCLR may have watson bucketing conditionally enabled.
     if (!IsWatsonEnabled())
     {
         return FALSE;
     }
-#endif // FEATURE_CORECLR
 
     CONTRACTL
     {
@@ -9589,13 +9479,11 @@ void SetupWatsonBucketsForUEF(BOOL fUseLastThrownObject)
 {
 #ifndef DACCESS_COMPILE
 
-#ifdef FEATURE_CORECLR
     // CoreCLR may have watson bucketing conditionally enabled.
     if (!IsWatsonEnabled())
     {
         return;
     }
-#endif // FEATURE_CORECLR
 
     CONTRACTL
     {
@@ -10045,14 +9933,12 @@ BOOL SetupWatsonBucketsForFailFast(EXCEPTIONREF refException)
     BOOL fResult = TRUE;
 
 #ifndef DACCESS_COMPILE
-#ifdef FEATURE_CORECLR
     // On CoreCLR, Watson may not be enabled. Thus, we should
     // skip this.
     if (!IsWatsonEnabled())
     {
         return fResult;
     }
-#endif // FEATURE_CORECLR
 
     CONTRACTL
     {
@@ -10307,14 +10193,12 @@ void SetupInitialThrowBucketDetails(UINT_PTR adjustedIp)
 {
 #ifndef DACCESS_COMPILE
 
-#ifdef FEATURE_CORECLR
     // On CoreCLR, Watson may not be enabled. Thus, we should
     // skip this.
     if (!IsWatsonEnabled())
     {
         return;
     }
-#endif // FEATURE_CORECLR
 
     CONTRACTL
     {
@@ -10918,14 +10802,12 @@ void SetStateForWatsonBucketing(BOOL fIsRethrownException, OBJECTHANDLE ohOrigin
 {
 #ifndef DACCESS_COMPILE
 
-#ifdef FEATURE_CORECLR
     // On CoreCLR, Watson may not be enabled. Thus, we should
     // skip this.
     if (!IsWatsonEnabled())
     {
         return;
     }
-#endif // FEATURE_CORECLR
 
     CONTRACTL
     {
@@ -11381,12 +11263,12 @@ UINT_PTR EHWatsonBucketTracker::RetrieveWatsonBucketIp()
 // This is *also* invoked from the DAC when buckets are requested.
 PTR_VOID EHWatsonBucketTracker::RetrieveWatsonBuckets()
 {
-#if defined(FEATURE_CORECLR) && !defined(DACCESS_COMPILE)
+#if !defined(DACCESS_COMPILE)
     if (!IsWatsonEnabled())
     {
         return NULL;
     }
-#endif // defined(FEATURE_CORECLR) && !defined(DACCESS_COMPILE)
+#endif //!defined(DACCESS_COMPILE)
 
     CONTRACTL
     {
@@ -11407,12 +11289,10 @@ void EHWatsonBucketTracker::ClearWatsonBucketDetails()
 {
 #ifndef DACCESS_COMPILE
 
-#ifdef FEATURE_CORECLR
     if (!IsWatsonEnabled())
     {
         return;
     }
-#endif // FEATURE_CORECLR
 
     CONTRACTL
     {
@@ -11670,25 +11550,6 @@ BOOL CEHelper::CanMethodHandleCE(PTR_MethodDesc pMethodDesc, CorruptionSeverity
     }
     CONTRACTL_END;
 
-#ifdef FEATURE_APPX_BINDER
-    // In an Metro application, disallow application code to catch any corrupted state exception
-    if (AppX::IsAppXProcess())
-    {
-        // This call to GetFusionAssemblyNameNoCreate will return a valid fusion assembly name
-        // in the second pass of exception dispatch as the name would have been created in the first pass,
-        // if not already existent.
-        IAssemblyName *pIAssemblyName = pMethodDesc->GetAssembly()->GetFusionAssemblyNameNoCreate();
-        if (!pIAssemblyName)
-        {
-            pIAssemblyName = pMethodDesc->GetAssembly()->GetFusionAssemblyName();
-        }
-        
-        if (Fusion::Util::IsAnyFrameworkAssembly(pIAssemblyName) != S_OK)
-        {
-            return FALSE;
-        }
-    }
-#endif // FEATURE_APPX
 
     if (g_pConfig->LegacyCorruptedStateExceptionsPolicy())
     {
@@ -12613,9 +12474,6 @@ void ReturnToPreviousAppDomainHolder::SuppressRelease()
 #ifndef DACCESS_COMPILE
 // This method will deliver the actual exception notification. Its assumed that the caller has done the necessary checks, including
 // checking whether the delegate can be invoked for the exception's corruption severity.
-//
-// This has been factored out of the #IFDEF FEATURE_EXCEPTION_NOTIFICATIONS so that existing ADUEN mechanism can be integrated with
-// the enhanced exception notifications.
 void ExceptionNotifications::DeliverExceptionNotification(ExceptionNotificationHandlerType notificationType, OBJECTREF *pDelegate,
         OBJECTREF *pAppDomain, OBJECTREF *pEventArgs)
 {
@@ -12641,7 +12499,6 @@ void ExceptionNotifications::DeliverExceptionNotification(ExceptionNotificationH
     CALL_MANAGED_METHOD_NORET(args);
 }
 
-#ifdef FEATURE_EXCEPTION_NOTIFICATIONS
 // To include definition of COMDelegate::GetMethodDesc
 #include "comdelegate.h"
 
@@ -13052,7 +12909,6 @@ void ExceptionNotifications::DeliverFirstChanceNotification()
     }
 }
 
-#endif // FEATURE_EXCEPTION_NOTIFICATIONS
 
 #ifdef WIN64EXCEPTIONS
 struct TAResetStateCallbackData
@@ -13872,24 +13728,6 @@ VOID DECLSPEC_NORETURN RealCOMPlusThrowSO()
 // Throw an InvalidCastException
 //==========================================================================
 
-#ifdef FEATURE_FUSION
-static const WCHAR *GetContextName(LOADCTX_TYPE kLoadContext,
-                                   BOOL         fIntrospectionOnly)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    // Context names are treated as symbols and therefore not localized
-    switch (kLoadContext)
-    {
-    case LOADCTX_TYPE_DEFAULT:
-        return W("Default");
-    case LOADCTX_TYPE_LOADFROM:
-        return W("LoadFrom");
-    default:
-        return (fIntrospectionOnly ? W("InspectionContext") : W("LoadNeither"));
-    }
-}
-#endif
 
 VOID GetAssemblyDetailInfo(SString    &sType,
                            SString    &sAssemblyDisplayName,
@@ -13899,12 +13737,7 @@ VOID GetAssemblyDetailInfo(SString    &sType,
     WRAPPER_NO_CONTRACT;
 
     InlineSString<MAX_LONGPATH> sFormat;
-#ifdef FEATURE_FUSION
-    const WCHAR *pwzLoadContext = GetContextName(pPEAssembly->GetLoadContext(),
-                                                 pPEAssembly->IsIntrospectionOnly());
-#else
     const WCHAR *pwzLoadContext = W("Default");
-#endif
 
     if (pPEAssembly->GetPath().IsEmpty())
     {
diff --git a/src/vm/excep.h b/src/vm/excep.h
index 53fa20160a..13d8a3b847 100644
--- a/src/vm/excep.h
+++ b/src/vm/excep.h
@@ -174,7 +174,7 @@ BOOL IsCOMPlusExceptionHandlerInstalled();
 BOOL InstallUnhandledExceptionFilter();
 void UninstallUnhandledExceptionFilter();
 
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_PAL)
+#if !defined(FEATURE_PAL)
 // Section naming is a strategy by itself. Ideally, we could have named the UEF section
 // ".text$zzz" (lowercase after $ is important). What the linker does is look for the sections
 // that has the same name before '$' sign. It combines them together but sorted in an alphabetical
@@ -193,7 +193,7 @@ void UninstallUnhandledExceptionFilter();
 // section that comes after UEF section, it can affect the UEF section and we will
 // assert about it in "CExecutionEngine::ClrVirtualProtect".
 #define CLR_UEF_SECTION_NAME ".CLR_UEF"
-#endif // defined(FEATURE_CORECLR) && !defined(FEATURE_PAL)
+#endif //!defined(FEATURE_PAL)
 LONG __stdcall COMUnhandledExceptionFilter(EXCEPTION_POINTERS *pExceptionInfo);
 
 
@@ -888,10 +888,8 @@ LONG EntryPointFilter(PEXCEPTION_POINTERS pExceptionInfo, PVOID _pData);
 enum ExceptionNotificationHandlerType
 {
     UnhandledExceptionHandler   = 0x1
-#ifdef FEATURE_EXCEPTION_NOTIFICATIONS
     ,
     FirstChanceExceptionHandler = 0x2
-#endif // FEATURE_EXCEPTION_NOTIFICATIONS
 };
 
 // Defined in Frames.h
@@ -900,7 +898,6 @@ enum ExceptionNotificationHandlerType
 // This class contains methods to support delivering the various exception notifications.
 class ExceptionNotifications
 {
-#ifdef FEATURE_EXCEPTION_NOTIFICATIONS
 private:
     void static GetEventArgsForNotification(ExceptionNotificationHandlerType notificationType,
         OBJECTREF *pOutEventArgs, OBJECTREF *pThrowable);
@@ -932,7 +929,6 @@ public:
 #ifdef FEATURE_CORRUPTING_EXCEPTIONS
     BOOL static CanDelegateBeInvokedForException(OBJECTREF *pDelegate, CorruptionSeverity severity);
 #endif // FEATURE_CORRUPTING_EXCEPTIONS
-#endif // FEATURE_EXCEPTION_NOTIFICATIONS
 
 public:
     void static DeliverExceptionNotification(ExceptionNotificationHandlerType notificationType, OBJECTREF *pDelegate, 
diff --git a/src/vm/exceptionhandling.cpp b/src/vm/exceptionhandling.cpp
index d3485e3671..ba7a68dba7 100644
--- a/src/vm/exceptionhandling.cpp
+++ b/src/vm/exceptionhandling.cpp
@@ -389,7 +389,7 @@ void ExceptionTracker::UpdateNonvolatileRegisters(CONTEXT *pContextRecord, REGDI
     do {                                                                                    \
         if (pRegDisplay->pCurrentContextPointers->reg != NULL)                              \
         {                                                                                   \
-            STRESS_LOG3(LF_GCROOTS, LL_INFO100, "Updating reg %p to %p from %p\n",          \
+            STRESS_LOG3(LF_GCROOTS, LL_INFO100, "Updating " #reg " %p to %p from %p\n",     \
                     pContextRecord->reg,                                                    \
                     *pRegDisplay->pCurrentContextPointers->reg,                             \
                     pRegDisplay->pCurrentContextPointers->reg);                             \
@@ -966,7 +966,6 @@ ProcessCLRException(IN     PEXCEPTION_RECORD   pExceptionRecord
         }
 #endif // FEATURE_CORRUPTING_EXCEPTIONS
 
-#ifdef FEATURE_CORECLR
         {
             // Switch to COOP mode since we are going to work
             // with throwable
@@ -1009,7 +1008,6 @@ ProcessCLRException(IN     PEXCEPTION_RECORD   pExceptionRecord
                 }
             }
         }
-#endif // FEATURE_CORECLR
 
 #ifndef FEATURE_PAL // Watson is on Windows only
         // Setup bucketing details for nested exceptions (rethrow and non-rethrow) only if we are in the first pass
@@ -1208,12 +1206,9 @@ bool FixNonvolatileRegisters(UINT_PTR  uOriginalSP,
     CONTRACTL_END;
 
     CONTEXT _ctx = {0};
-#if defined(_TARGET_AMD64_)
-    REGDISPLAY regdisp = {0};
-#else
+
     // Ctor will initialize it to NULL
     REGDISPLAY regdisp;
-#endif // _TARGET_AMD64_
 
     pThread->FillRegDisplay(&regdisp, &_ctx);
 
@@ -2216,13 +2211,11 @@ CLRUnwindStatus ExceptionTracker::ProcessExplicitFrame(
 #if defined(DEBUGGING_SUPPORTED)
                 if (ExceptionTracker::NotifyDebuggerOfStub(pThread, sf, pFrame))
                 {
-#ifdef FEATURE_EXCEPTION_NOTIFICATIONS
                     // Deliver the FirstChanceNotification after the debugger, if not already delivered.
                     if (!this->DeliveredFirstChanceNotification())
                     {
                         ExceptionNotifications::DeliverFirstChanceNotification();
                     }
-#endif // FEATURE_EXCEPTION_NOTIFICATIONS
                 }
 #endif // DEBUGGING_SUPPORTED
 
@@ -2556,14 +2549,12 @@ CLRUnwindStatus ExceptionTracker::ProcessManagedCallFrame(
                     }
 #endif // DEBUGGING_SUPPORTED
 
-#ifdef FEATURE_EXCEPTION_NOTIFICATIONS
                     // Attempt to deliver the first chance notification to the AD only *AFTER* the debugger
                     // has done that, provided we have not already delivered it.
                     if (!this->DeliveredFirstChanceNotification())
                     {
                         ExceptionNotifications::DeliverFirstChanceNotification();
                     }
-#endif // FEATURE_EXCEPTION_NOTIFICATIONS
                 }
                 else
                 {
@@ -4690,7 +4681,7 @@ VOID DECLSPEC_NORETURN DispatchManagedException(PAL_SEHException& ex, bool isHar
     throw std::move(ex);
 }
 
-#ifdef _AMD64_
+#if defined(_TARGET_AMD64_) || defined(_TARGET_X86_)
 
 /*++
 Function :
@@ -4707,8 +4698,29 @@ Return value :
 --*/
 VOID* GetRegisterAddressByIndex(PCONTEXT pContext, UINT index)
 {
+#if defined(_TARGET_AMD64_)
     _ASSERTE(index < 16);
     return &((&pContext->Rax)[index]);
+#elif defined(_TARGET_X86_)
+    _ASSERTE(index < 8);
+
+    static const SIZE_T OFFSET_OF_REGISTERS[] =
+    {
+        offsetof(CONTEXT, Eax),
+        offsetof(CONTEXT, Ecx),
+        offsetof(CONTEXT, Edx),
+        offsetof(CONTEXT, Ebx),
+        offsetof(CONTEXT, Esp),
+        offsetof(CONTEXT, Ebp),
+        offsetof(CONTEXT, Esi),
+        offsetof(CONTEXT, Edi),
+    };
+
+    return (VOID*)(PBYTE(pContext) + OFFSET_OF_REGISTERS[index]);
+#else
+    PORTABILITY_ASSERT("GetRegisterAddressByIndex");
+    return NULL;
+#endif
 }
 
 /*++
@@ -4980,7 +4992,7 @@ Return value :
 --*/
 bool IsDivByZeroAnIntegerOverflow(PCONTEXT pContext)
 {
-    BYTE * ip = (BYTE*)pContext->Rip;
+    BYTE * ip = (BYTE *)GetIP(pContext);
     BYTE rex = 0;
     bool hasOpSizePrefix = false;
 
@@ -5012,7 +5024,7 @@ bool IsDivByZeroAnIntegerOverflow(PCONTEXT pContext)
     // must have been an overflow.
     return divisor != 0;
 }
-#endif //_AMD64_
+#endif // _TARGET_AMD64_ || _TARGET_X86_
 
 BOOL IsSafeToCallExecutionManager()
 {
@@ -5059,7 +5071,7 @@ BOOL HandleHardwareException(PAL_SEHException* ex)
             return TRUE;
         }
 
-#ifdef _AMD64_
+#if defined(_TARGET_AMD64_) || defined(_TARGET_X86_)
         // It is possible that an overflow was mapped to a divide-by-zero exception. 
         // This happens when we try to divide the maximum negative value of a
         // signed integer with -1. 
@@ -5072,7 +5084,7 @@ BOOL HandleHardwareException(PAL_SEHException* ex)
             // The exception was an integer overflow, so augment the exception code.
             ex->GetExceptionRecord()->ExceptionCode = EXCEPTION_INT_OVERFLOW;
         }
-#endif //_AMD64_
+#endif // _TARGET_AMD64_ || _TARGET_X86_
 
         // Create frame necessary for the exception handling
         FrameWithCookie<FaultingExceptionFrame> fef;
diff --git a/src/vm/exceptionhandling.h b/src/vm/exceptionhandling.h
index 8b675d596d..c6fe35ae09 100644
--- a/src/vm/exceptionhandling.h
+++ b/src/vm/exceptionhandling.h
@@ -85,11 +85,9 @@ public:
         m_CorruptionSeverity = NotSet;
 #endif // FEATURE_CORRUPTING_EXCEPTIONS
 
-#ifdef FEATURE_EXCEPTION_NOTIFICATIONS
         // By default, mark the tracker as not having delivered the first
         // chance exception notification
         m_fDeliveredFirstChanceNotification = FALSE;
-#endif // FEATURE_EXCEPTION_NOTIFICATIONS
 
         m_sfFirstPassTopmostFrame.Clear();
         
@@ -147,11 +145,9 @@ public:
         m_CorruptionSeverity = NotSet;
 #endif // FEATURE_CORRUPTING_EXCEPTIONS
 
-#ifdef FEATURE_EXCEPTION_NOTIFICATIONS
         // By default, mark the tracker as not having delivered the first
         // chance exception notification
         m_fDeliveredFirstChanceNotification = FALSE;
-#endif // FEATURE_EXCEPTION_NOTIFICATIONS
 
         m_dwIndexClauseForCatch = 0;
         m_sfEstablisherOfActualHandlerFrame.Clear();
@@ -389,7 +385,7 @@ public:
 
     bool IsStackOverflowException();
 
-#ifdef FEATURE_PAL
+#if defined(FEATURE_PAL) && !defined(CROSS_COMPILE)
     void TakeExceptionPointersOwnership(PAL_SEHException* ex)
     {
         _ASSERTE(ex->GetExceptionRecord() == m_ptrs.ExceptionRecord);
@@ -397,7 +393,7 @@ public:
         ex->Clear();
         m_fOwnsExceptionPointers = TRUE;
     }
-#endif // FEATURE_PAL
+#endif // FEATURE_PAL && !CROSS_COMPILE
 
 private:
     DWORD_PTR
@@ -428,7 +424,7 @@ private:
 
         m_hThrowable = NULL;
     }
-#endif
+#endif // !DACCESS_COMPILE
 
     void SaveStackTrace();
 
@@ -616,7 +612,6 @@ public:
     }
 #endif // FEATURE_CORRUPTING_EXCEPTIONS
 
-#ifdef FEATURE_EXCEPTION_NOTIFICATIONS
 private:
     BOOL                    m_fDeliveredFirstChanceNotification;
 
@@ -634,7 +629,6 @@ public:
     
         m_fDeliveredFirstChanceNotification = fDelivered;
     }
-#endif // FEATURE_EXCEPTION_NOTIFICATIONS
 
     // Returns the exception tracker previous to the current
     inline PTR_ExceptionTracker GetPreviousExceptionTracker()
diff --git a/src/vm/exinfo.cpp b/src/vm/exinfo.cpp
index 1ae011e85a..1a73e25a6e 100644
--- a/src/vm/exinfo.cpp
+++ b/src/vm/exinfo.cpp
@@ -118,11 +118,9 @@ void ExInfo::Init()
     m_CorruptionSeverity = NotSet;
 #endif // FEATURE_CORRUPTING_EXCEPTIONS
 
-#ifdef FEATURE_EXCEPTION_NOTIFICATIONS
     // By default, mark the tracker as not having delivered the first
     // chance exception notification
     m_fDeliveredFirstChanceNotification = FALSE;
-#endif // FEATURE_EXCEPTION_NOTIFICATIONS
 
     m_pTopMostHandlerDuringSO = NULL;
 
diff --git a/src/vm/exinfo.h b/src/vm/exinfo.h
index 2a8030fb56..6b34e71116 100644
--- a/src/vm/exinfo.h
+++ b/src/vm/exinfo.h
@@ -109,7 +109,6 @@ public:
     }
 #endif // FEATURE_CORRUPTING_EXCEPTIONS
     
-#ifdef FEATURE_EXCEPTION_NOTIFICATIONS
 private:
     BOOL                    m_fDeliveredFirstChanceNotification;
 public:
@@ -126,7 +125,6 @@ public:
     
         m_fDeliveredFirstChanceNotification = fDelivered;
     }
-#endif // FEATURE_EXCEPTION_NOTIFICATIONS
 
     // Returns the exception tracker previous to the current
     inline PTR_ExInfo GetPreviousExceptionTracker()
diff --git a/src/vm/exstate.h b/src/vm/exstate.h
index 50e71ed79b..34f6427b51 100644
--- a/src/vm/exstate.h
+++ b/src/vm/exstate.h
@@ -116,16 +116,13 @@ public:
         // to start a funclet-skipping stackwalk in this time window.
         TEF_InconsistentExceptionState    = 0x00000001,
 
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
         TEF_ForeignExceptionRaise         = 0x00000002,
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
     };
 
     void SetThreadExceptionFlag(ThreadExceptionFlag flag);
     void ResetThreadExceptionFlag(ThreadExceptionFlag flag);
     BOOL HasThreadExceptionFlag(ThreadExceptionFlag flag);
 
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
     inline void SetRaisingForeignException()
     {
         LIMITED_METHOD_CONTRACT;
@@ -143,7 +140,6 @@ public:
         LIMITED_METHOD_CONTRACT;
         ResetThreadExceptionFlag(TEF_ForeignExceptionRaise);
     }
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 
 #if defined(_DEBUG)
     void AssertStackTraceInfo(StackTraceInfo *pSTI);
diff --git a/src/vm/finalizerthread.cpp b/src/vm/finalizerthread.cpp
index 4c0f5acbf9..d52d599db2 100644
--- a/src/vm/finalizerthread.cpp
+++ b/src/vm/finalizerthread.cpp
@@ -1408,12 +1408,10 @@ BOOL FinalizerThread::FinalizerThreadWatchDogHelper()
     }
 #endif // PROFILING_SUPPORTED
 
-#ifdef FEATURE_CORECLR
     // This change was added late in Windows Phone 8, so we want to keep it minimal.
     // We should consider refactoring this later, as we've got a lot of dead code here now on CoreCLR.
     dwTimeout = INFINITE;
     maxTotalWait = INFINITE;
-#endif // FEATURE_CORECLR
 
     while (1) {
         struct Param
diff --git a/src/vm/frames.cpp b/src/vm/frames.cpp
index 04a1815cf3..ae3cfdbc75 100644
--- a/src/vm/frames.cpp
+++ b/src/vm/frames.cpp
@@ -2006,8 +2006,8 @@ BOOL MulticastFrame::TraceFrame(Thread *thread, BOOL fromPatch,
 
 #if defined(_TARGET_X86_)
     // At this point the counter hasn't been incremented yet.
-    delegateCount = *regs->pEdi + 1;
-    pbDel = *(BYTE **)( (size_t)*(regs->pEsi) + GetOffsetOfTransitionBlock() + ArgIterator::GetThisOffset());
+    delegateCount = *regs->GetEdiLocation() + 1;
+    pbDel = *(BYTE **)( (size_t)*regs->GetEsiLocation() + GetOffsetOfTransitionBlock() + ArgIterator::GetThisOffset());
 #elif defined(_TARGET_AMD64_)
     // At this point the counter hasn't been incremented yet.
     delegateCount = (int)regs->pCurrentContext->Rdi + 1;
diff --git a/src/vm/frames.h b/src/vm/frames.h
index e37f980b9f..2c9ddb4ab0 100644
--- a/src/vm/frames.h
+++ b/src/vm/frames.h
@@ -3203,9 +3203,6 @@ private:
     PTR_Object  m_LastThrownObjectInParentContext;                                        
     ULONG_PTR   m_LockCount;            // Number of locks the thread takes
                                         // before the transition.
-#ifndef FEATURE_CORECLR
-    ULONG_PTR   m_CriticalRegionCount;
-#endif // !FEATURE_CORECLR
     VPTR_VTABLE_CLASS(ContextTransitionFrame, Frame)
 
 public:
@@ -3244,18 +3241,6 @@ public:
         return (DWORD) m_LockCount;
     }
 
-#ifndef FEATURE_CORECLR
-    void SetCriticalRegionCount(DWORD criticalRegionCount)
-    {
-        LIMITED_METHOD_CONTRACT;
-        m_CriticalRegionCount = criticalRegionCount;
-    }
-    DWORD GetCriticalRegionCount()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return (DWORD) m_CriticalRegionCount;
-    }
-#endif // !FEATURE_CORECLR
 
     // Let debugger know that we're transitioning between AppDomains.
     ETransitionType GetTransitionType()
@@ -3270,9 +3255,6 @@ public:
     , m_ReturnExecutionContext(NULL)
     , m_LastThrownObjectInParentContext(NULL)
     , m_LockCount(0)
-#ifndef FEATURE_CORECLR
-    , m_CriticalRegionCount(0)
-#endif // !FEATURE_CORECLR
     {
         LIMITED_METHOD_CONTRACT;
     }
diff --git a/src/vm/fusionbind.cpp b/src/vm/fusionbind.cpp
deleted file mode 100644
index 0a337796bb..0000000000
--- a/src/vm/fusionbind.cpp
+++ /dev/null
@@ -1,661 +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.
-
-/*============================================================
-**
-** Header: FusionBind.cpp
-**
-** Purpose: Implements fusion interface
-**
-**
-
-
-===========================================================*/
-
-#include "common.h"
-
-#include <stdlib.h>
-#include "fusionbind.h"
-#include "shimload.h"
-#include "eventtrace.h"
-#include "strongnameholders.h"
-
-HRESULT BaseAssemblySpec::ParseName()
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        GC_NOTRIGGER;
-        NOTHROW;
-        INJECT_FAULT(return E_OUTOFMEMORY;);
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    if (!m_pAssemblyName)
-        return S_OK;
-
-    CQuickBytes ssName;
-
-    hr = ssName.ConvertUtf8_UnicodeNoThrow(m_pAssemblyName);
-
-    if (SUCCEEDED(hr))
-    {
-        NonVMComHolder<IAssemblyName> pName;
-
-        IfFailRet(CreateAssemblyNameObject(&pName, (LPCWSTR) ssName.Ptr(), CANOF_PARSE_DISPLAY_NAME, NULL));
-
-        if (m_ownedFlags & NAME_OWNED)
-            delete [] m_pAssemblyName;
-        m_pAssemblyName = NULL;
-
-        hr = Init(pName);
-    }
-
-    return hr;
-}
-
-void BaseAssemblySpec::GetFileOrDisplayName(DWORD flags, SString &result) const
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        THROWS;
-        INJECT_FAULT(ThrowOutOfMemory());
-        PRECONDITION(CheckValue(result));
-        PRECONDITION(result.IsEmpty());
-    }
-    CONTRACTL_END;
-
-    if (m_pAssemblyName != NULL) {
-        NonVMComHolder<IAssemblyName> pFusionName;
-        IfFailThrow(CreateFusionName(&pFusionName));
-
-        FusionBind::GetAssemblyNameDisplayName(pFusionName, result, flags);
-    }
-    else
-        result.Set(m_wszCodeBase);
-}
-
-HRESULT AssemblySpec::LoadAssembly(IApplicationContext* pFusionContext,
-                                 FusionSink *pSink,
-                                 IAssembly** ppIAssembly,
-                                 IHostAssembly** ppIHostAssembly,
-                                 IBindResult** ppNativeFusionAssembly,
-                                 BOOL fForIntrospectionOnly,
-                                 BOOL fSuppressSecurityChecks)
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        THROWS;
-        MODE_PREEMPTIVE;
-        INJECT_FAULT(ThrowOutOfMemory());
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = E_FAIL;
-    
-    if (!IsAfContentType_Default(m_dwFlags))
-    {   // Fusion can process only Default ContentType (non-WindowsRuntime)
-        IfFailThrow(COR_E_BADIMAGEFORMAT);
-    }
-    
-    NonVMComHolder<IAssembly> pIAssembly(NULL);
-    NonVMComHolder<IBindResult> pNativeFusionAssembly(NULL);    
-    NonVMComHolder<IHostAssembly> pIHostAssembly(NULL);
-    NonVMComHolder<IAssemblyName> pSpecName;
-    NonVMComHolder<IAssemblyName> pCodeBaseName;
-
-
-    BOOL fFXOnly = FALSE;
-    DWORD size = sizeof(fFXOnly);
-    
-    hr = pFusionContext->Get(ACTAG_FX_ONLY, &fFXOnly, &size, 0);
-    if(FAILED(hr))
-    {
-        /// just in case it corrupted fFXOnly
-        fFXOnly = FALSE;
-    }
-
-    // reset hr
-    hr = E_FAIL;
-
-    // Make sure we don't have malformed names
-    
-    if (m_pAssemblyName)
-        IfFailGo(FusionBind::VerifyBindingString(m_pAssemblyName));
-
-    if (m_context.szLocale)
-        IfFailGo(FusionBind::VerifyBindingString(m_context.szLocale));
-
-    // If we have assembly name info, first bind using that
-    if (m_pAssemblyName != NULL) {
-        IfFailGo(CreateFusionName(&pSpecName, FALSE));
-
-        if(m_fParentLoadContext == LOADCTX_TYPE_UNKNOWN)
-        {
-            BOOL bOptionallyRetargetable;
-            IfFailGo(IsOptionallyRetargetableAssembly(pSpecName, &bOptionallyRetargetable));
-            if (bOptionallyRetargetable)
-                return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND); // do not propagate to load, let the event handle
-        }
-
-        hr = FusionBind::RemoteLoad(pFusionContext, pSink, 
-                        pSpecName, GetParentIAssembly(), NULL, 
-                        &pIAssembly, &pIHostAssembly, &pNativeFusionAssembly, fForIntrospectionOnly, fSuppressSecurityChecks);
-    }
-
-
-    // Now, bind using the codebase.
-    if (FAILED(hr) && !fFXOnly && m_wszCodeBase) {
-        // No resolution by code base for SQL-hosted environment, except for introspection
-        if((!fForIntrospectionOnly) && CorHost2::IsLoadFromBlocked())
-        {
-            hr = FUSION_E_LOADFROM_BLOCKED;
-            goto ErrExit;
-        }
-        IfFailGo(CreateAssemblyNameObject(&pCodeBaseName, NULL, 0, NULL));
-
-        IfFailGo(pCodeBaseName->SetProperty(ASM_NAME_CODEBASE_URL,
-                                            (void*)m_wszCodeBase, 
-                                            (DWORD)(wcslen(m_wszCodeBase) + 1) * sizeof(WCHAR)));
-
-        // Note that we cannot bind a native image using a codebase, as it will
-        // always be in the LoadFrom context which does not support native images.
-
-        pSink->Reset();
-        hr = FusionBind::RemoteLoad(pFusionContext, pSink, 
-                        pCodeBaseName, NULL, m_wszCodeBase,
-                        &pIAssembly, &pIHostAssembly, &pNativeFusionAssembly, fForIntrospectionOnly, fSuppressSecurityChecks);
-
-        // If we had both name info and codebase, make sure they are consistent.
-        if (SUCCEEDED(hr) && m_pAssemblyName != NULL) {
-
-            NonVMComHolder<IAssemblyName> pPolicyRefName(NULL);
-            if (!fForIntrospectionOnly) {
-                // Get post-policy ref, because we'll be comparing
-                // it against a post-policy def
-                HRESULT policyHr = PreBindAssembly(pFusionContext,
-                                                   pSpecName,
-                                                   NULL, // pAsmParent
-                                                   &pPolicyRefName,
-                                                   NULL);  // pvReserved
-                if (FAILED(policyHr) && (policyHr != FUSION_E_REF_DEF_MISMATCH) &&
-                    (policyHr != E_INVALIDARG)) // partial ref
-                    IfFailGo(policyHr);
-            }
-
-            NonVMComHolder<IAssemblyName> pBoundName;
-            if (pIAssembly == NULL)
-                IfFailGo(pIHostAssembly->GetAssemblyNameDef(&pBoundName));
-            else
-                IfFailGo(pIAssembly->GetAssemblyNameDef(&pBoundName));
-
-            // Order matters: Ref->IsEqual(Def)
-            HRESULT equalHr;
-            if (pPolicyRefName)
-                equalHr = pPolicyRefName->IsEqual(pBoundName, ASM_CMPF_DEFAULT);
-            else
-                equalHr = pSpecName->IsEqual(pBoundName, ASM_CMPF_DEFAULT);
-            if (equalHr != S_OK)
-            {
-                // post-policy name is pBoundName and it's not correct for the  
-                // original name, so we need to clear it
-                ReleaseNameAfterPolicy();
-                IfFailGo(FUSION_E_REF_DEF_MISMATCH);
-            }
-        }
-    }
-
-    // We should have found an assembly by now.
-    IfFailGo(hr);
-
-    // <NOTE> Comment about the comment below. The work is done in fusion now. 
-    // But we still keep the comment here to illustrate the problem. </NOTE>
-    
-    // Until we can create multiple Assembly objects for a single HMODULE
-    // we can only store one IAssembly* per Assembly. It is very important
-    // to maintain the IAssembly* for an image that is in the load-context.
-    // An Assembly in the load-from-context can bind to an assembly in the
-    // load-context but not visa-versa. Therefore, if we every get an IAssembly
-    // from the load-from-context we must make sure that it will never be 
-    // found using a load. If it did then we could end up with Assembly dependencies
-    // that are wrong. For example, if I do a LoadFrom() on an assembly in the GAC
-    // and it requires another Assembly that I have preloaded in the load-from-context
-    // then that dependency gets burnt into the Jitted code. Later on a Load() is
-    // done on the assembly in the GAC and we single instance it back to the one
-    // we have gotten from the load-from-context because the HMODULES are the same.
-    // Now the dependency is wrong because it would not have the preloaded assembly
-    // if the order was reversed.
-
-#if 0    
-    if (!fForIntrospectionOnly)
-    {
-        NonVMComHolder<IFusionLoadContext> pLoadContext;
-        if (pIAssembly == NULL)
-            IfFailGo(pIHostAssembly->GetFusionLoadContext(&pLoadContext));
-        else
-            IfFailGo(pIAssembly->GetFusionLoadContext(&pLoadContext));
-     
-        if (pLoadContext->GetContextType() == LOADCTX_TYPE_LOADFROM) {
-            _ASSERTE(pIAssembly != NULL);
-            HRESULT hrLocal;
-    
-            NonVMComHolder<IAssemblyName> pBoundName;
-            pIAssembly->GetAssemblyNameDef(&pBoundName);
-    
-            // We need to copy the bound name to modify it
-            IAssemblyName *pClone;
-            IfFailGo(pBoundName->Clone(&pClone));
-            pBoundName.Release();
-            pBoundName = pClone;
-    
-            // Null out the architecture for the second bind
-            IfFailGo(pBoundName->SetProperty(ASM_NAME_ARCHITECTURE, NULL, 0));
-    
-            NonVMComHolder<IAssembly> pAliasingAssembly;
-            NonVMComHolder<IHostAssembly> pIHA;
-            pSink->Reset();
-            hrLocal = FusionBind::RemoteLoad(pFusionContext, pSink,
-                                 pBoundName, NULL, NULL, 
-                                 &pAliasingAssembly, &pIHA, fForIntrospectionOnly);
-    
-            if(SUCCEEDED(hrLocal)) {
-                // If the paths are the same or the loadfrom assembly is in the GAC,
-                // then use the non-LoadFrom assembly as the result.
-    
-                DWORD location;
-                hrLocal = pIAssembly->GetAssemblyLocation(&location); 
-                BOOL alias = (SUCCEEDED(hrLocal) && location == ASMLOC_GAC);
-    
-                if (!alias)  {
-                    SString boundPath;
-                    GetAssemblyManifestModulePath(pIAssembly, boundPath);
-    
-                    SString aliasingPath;
-                    GetAssemblyManifestModulePath(pAliasingAssembly, aliasingPath);
-    
-                    alias = SString::_wcsicmp(boundPath, aliasingPath) == 0;
-                }
-    
-                // Keep the default context's IAssembly if the paths are the same
-                if (alias) 
-                    pIAssembly = pAliasingAssembly.Extract();
-            }
-        }
-    }
-#endif
-
-    if (SUCCEEDED(hr)) {
-        if (pIAssembly == NULL)
-            *ppIHostAssembly = pIHostAssembly.Extract();
-        else
-            *ppIAssembly = pIAssembly.Extract();
-        if (ppNativeFusionAssembly) {
-            *ppNativeFusionAssembly = pNativeFusionAssembly.Extract();
-        }
-    }
-
- ErrExit:
-    return hr;
-}
-
-
-/* static */
-HRESULT FusionBind::RemoteLoad(IApplicationContext* pFusionContext,
-                               FusionSink *pSink,
-                               IAssemblyName *pName,
-                               IAssembly *pParentAssembly,
-                               LPCWSTR pCodeBase,
-                               IAssembly** ppIAssembly,
-                               IHostAssembly** ppIHostAssembly,
-                               IBindResult **ppNativeFusionAssembly,
-                               BOOL    fForIntrospectionOnly,
-                               BOOL fSuppressSecurityChecks)
-{
-    CONTRACTL
-    {
-        THROWS;
-        MODE_PREEMPTIVE;
-        // The resulting IP must be held so the assembly will not be scavenged.
-        PRECONDITION(CheckPointer(ppIAssembly));
-        PRECONDITION(CheckPointer(ppIHostAssembly));
-
-        PRECONDITION(CheckPointer(pName));
-        INJECT_FAULT(return E_OUTOFMEMORY;);
-    } CONTRACTL_END;
-
-    ETWOnStartup (FusionBinding_V1, FusionBindingEnd_V1);
-
-    HRESULT hr;
-    ASM_BIND_FLAGS dwFlags = ASM_BINDF_NONE;
-    DWORD dwReserved = 0;
-    LPVOID pReserved = NULL;
-
-    // Event Tracing for Windows is used to log data for performance and functional testing purposes.
-    // The events below are used to help measure the performance of the download phase of assembly binding (be it download of a remote file or accessing a local file on disk),
-    // as well as of lookup scenarios such as from a host store.
-    DWORD dwAppDomainId = ETWAppDomainIdNotAvailable;
-    if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context, TRACE_LEVEL_INFORMATION, CLR_PRIVATEBINDING_KEYWORD)) {
-        DWORD cbValue = sizeof(dwAppDomainId);
-        // Gather data used by ETW events later in this function.
-        if (pFusionContext == NULL || FAILED(pFusionContext->Get(ACTAG_APP_DOMAIN_ID, &dwAppDomainId, &cbValue, 0))) {
-            dwAppDomainId = ETWAppDomainIdNotAvailable;
-        }
-    }
-
-    NonVMComHolder< IUnknown > pSinkIUnknown(NULL);
-    NonVMComHolder< IAssemblyNameBinder> pBinder(NULL);
-    *ppNativeFusionAssembly=NULL;
-
-    if(pParentAssembly != NULL) {
-        // Only use a parent assembly hint when the parent assembly has a load context.
-        // Assemblies in anonymous context are not dicoverable by loader's binding rules,
-        // thus loader can't find their dependencies. 
-        // Loader will only try to locate dependencies in default load context.
-        if (pParentAssembly->GetFusionLoadContext() != LOADCTX_TYPE_UNKNOWN) {
-            dwReserved = sizeof(IAssembly*);
-            pReserved = (LPVOID) pParentAssembly;
-            dwFlags = ASM_BINDF_PARENT_ASM_HINT;
-        }
-    }
-    
-    IfFailRet(pSink->AssemblyResetEvent());
-    IfFailRet(pSink->QueryInterface(IID_IUnknown, (void**)&pSinkIUnknown));
-    IUnknown *pFusionAssembly=NULL;
-    IUnknown  *pNativeAssembly=NULL;
-    BOOL fCached = TRUE;
-
-
-    if (fForIntrospectionOnly)
-    {
-        dwFlags = (ASM_BIND_FLAGS)(dwFlags | ASM_BINDF_INSPECTION_ONLY);
-    }
-
-    if (fSuppressSecurityChecks)
-    {
-        dwFlags = (ASM_BIND_FLAGS)(dwFlags | ASM_BINDF_SUPPRESS_SECURITY_CHECKS);
-    }
-
-    IfFailRet(pName->QueryInterface(IID_IAssemblyNameBinder, (void **)&pBinder));
-    {
-        // In SQL, this can call back into the runtime
-        CONTRACT_VIOLATION(ThrowsViolation);
-        hr = pBinder->BindToObject(IID_IAssembly,
-                                 pSinkIUnknown,
-                                 pFusionContext,
-                                 pCodeBase,
-                                 dwFlags,
-                                 pReserved,
-                                 dwReserved,
-                                 (void**) &pFusionAssembly,
-                                 (void**)&pNativeAssembly);
-    }
-    
-    if(hr == E_PENDING) {
-        // If there is an assembly IP then we were successful.
-        hr = pSink->Wait();
-        if (SUCCEEDED(hr))
-            hr = pSink->LastResult();
-        if(SUCCEEDED(hr)) {
-            if(pSink->m_punk) {
-                if (pSink->m_pNIunk)
-                    pNativeAssembly=pSink->m_pNIunk;
-                pFusionAssembly = pSink->m_punk;
-                fCached = FALSE;
-            }
-            else
-                hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
-        }
-    }
-
-    FireEtwBindingDownloadPhaseEnd(dwAppDomainId, ETWLoadContextNotAvailable, ETWFieldUnused, ETWLoaderLoadTypeNotAvailable, pCodeBase, NULL, GetClrInstanceId());
-
-    FireEtwBindingLookupAndProbingPhaseEnd(dwAppDomainId, ETWLoadContextNotAvailable, ETWFieldUnused, ETWLoaderLoadTypeNotAvailable, pCodeBase, NULL, GetClrInstanceId());
-
-    if (SUCCEEDED(hr)) {
-        // Keep a handle to ensure it does not disappear from the cache
-        // and allow access to modules associated with the assembly.
-        hr = pFusionAssembly->QueryInterface(IID_IAssembly, 
-                                             (void**) ppIAssembly);
-        if (hr == E_NOINTERFACE) // IStream assembly
-            hr = pFusionAssembly->QueryInterface(IID_IHostAssembly, 
-                                                 (void**) ppIHostAssembly);
-        if (SUCCEEDED(hr) && pNativeAssembly)
-            hr=pNativeAssembly->QueryInterface(IID_IBindResult,
-                                            (void**)ppNativeFusionAssembly);
-
-        if (fCached)
-        {
-            pFusionAssembly->Release();
-            if(pNativeAssembly)
-                pNativeAssembly->Release();
-        }
-    }
-
-    return hr;
-}
-
-/* static */
-HRESULT FusionBind::RemoteLoadModule(IApplicationContext * pFusionContext, 
-                                     IAssemblyModuleImport* pModule, 
-                                     FusionSink *pSink,
-                                     IAssemblyModuleImport** pResult)
-{
-    
-    CONTRACTL
-    {
-        NOTHROW;
-        PRECONDITION(CheckPointer(pFusionContext));
-        PRECONDITION(CheckPointer(pModule));
-        PRECONDITION(CheckPointer(pSink));
-        PRECONDITION(CheckPointer(pResult));
-        INJECT_FAULT(return E_OUTOFMEMORY;);
-    } CONTRACTL_END;
-
-    ETWOnStartup (FusionBinding_V1, FusionBindingEnd_V1);
-
-    HRESULT hr;
-    IfFailGo(pSink->AssemblyResetEvent());
-    hr = pModule->BindToObject(pSink,
-                               pFusionContext,
-                               ASM_BINDF_NONE,
-                               (void**) pResult);
-    if(hr == E_PENDING) {
-        // If there is an assembly IP then we were successful.
-        hr = pSink->Wait();
-        if (SUCCEEDED(hr))
-            hr = pSink->LastResult();
-        if (SUCCEEDED(hr)) {
-            if(pSink->m_punk)
-                hr = pSink->m_punk->QueryInterface(IID_IAssemblyModuleImport, 
-                                                   (void**) pResult);
-            else
-                hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
-        }
-    }
-
- ErrExit:
-    return hr;
-}
-
-
-/* static */
-HRESULT FusionBind::AddEnvironmentProperty(__in LPCWSTR variable, 
-                                           __in LPCWSTR pProperty, 
-                                           IApplicationContext* pFusionContext)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        PRECONDITION(CheckPointer(pProperty));
-        PRECONDITION(CheckPointer(variable));
-        PRECONDITION(CheckPointer(pFusionContext));
-        INJECT_FAULT(return E_OUTOFMEMORY;);
-    }
-    CONTRACTL_END;
-
-    DWORD size = _MAX_PATH;
-    WCHAR rcValue[_MAX_PATH];    // Buffer for the directory.
-    WCHAR *pValue = &(rcValue[0]);
-    size = WszGetEnvironmentVariable(variable, pValue, size);
-    if(size > _MAX_PATH) {
-        pValue = (WCHAR*) _alloca(size * sizeof(WCHAR));
-        size = WszGetEnvironmentVariable(variable, pValue, size);
-        size++; // Add in the null terminator
-    }
-
-    if(size)
-        return pFusionContext->Set(pProperty,
-                                   pValue,
-                                   size * sizeof(WCHAR),
-                                   0);
-    else 
-        return S_FALSE; // no variable found
-}
-
-// Fusion uses a context class to drive resolution of assemblies.
-// Each application has properties that can be pushed into the
-// fusion context (see fusionp.h). The public api is part of
-// application domains.
-/* static */
-HRESULT FusionBind::SetupFusionContext(LPCWSTR szAppBase,
-                                       LPCWSTR szPrivateBin,
-                                       IApplicationContext** ppFusionContext)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        PRECONDITION(CheckPointer(ppFusionContext));
-        INJECT_FAULT(return E_OUTOFMEMORY;);
-    }
-    CONTRACTL_END;
-
-    HRESULT hr;
-    NonVMComHolder <IApplicationContext> pFusionContext;
-
-    LPCWSTR pBase;
-    // if the appbase is null then use the current directory
-    if (szAppBase == NULL) {
-        pBase = (LPCWSTR) _alloca(_MAX_PATH * sizeof(WCHAR));
-        if(!WszGetCurrentDirectory(_MAX_PATH, (LPWSTR) pBase))
-            IfFailGo(HRESULT_FROM_GetLastError());
-    }
-    else
-        pBase = szAppBase;
-
-
-    IfFailGo(CreateFusionContext(pBase, &pFusionContext));
-
-    
-    IfFailGo((pFusionContext)->Set(ACTAG_APP_BASE_URL,
-                                   (void*) pBase,
-                                   (DWORD)(wcslen(pBase) + 1) * sizeof(WCHAR),
-                                   0));
-        
-    if (szPrivateBin)
-        IfFailGo((pFusionContext)->Set(ACTAG_APP_PRIVATE_BINPATH,
-                                       (void*) szPrivateBin,
-                                       (DWORD)(wcslen(szPrivateBin) + 1) * sizeof(WCHAR),
-                                       0));
-    else
-        IfFailGo(AddEnvironmentProperty(APPENV_RELATIVEPATH, ACTAG_APP_PRIVATE_BINPATH, pFusionContext));
-
-    *ppFusionContext=pFusionContext;
-    pFusionContext.SuppressRelease();
-    
-ErrExit:    
-    return hr;
-}
-
-/* static */
-HRESULT FusionBind::CreateFusionContext(LPCWSTR pzName, IApplicationContext** ppFusionContext)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        PRECONDITION(CheckPointer(ppFusionContext));
-        INJECT_FAULT(return E_OUTOFMEMORY;);
-    }
-    CONTRACTL_END;
-
-    // This is a file name not a namespace
-    LPCWSTR contextName = NULL;
-
-    if(pzName) {
-        contextName = wcsrchr( pzName, W('\\') );
-        if(contextName)
-            contextName++;
-        else
-            contextName = pzName;
-    }
-    // We go off and create a fusion context for this application domain.
-    // Note, once it is made it can not be modified.
-    NonVMComHolder<IAssemblyName> pFusionAssemblyName;
-    HRESULT hr = CreateAssemblyNameObject(&pFusionAssemblyName, contextName, 0, NULL);
-
-    if(SUCCEEDED(hr))
-        hr = CreateApplicationContext(pFusionAssemblyName, ppFusionContext);
-    
-    return hr;
-}
-
-/* static */
-HRESULT FusionBind::GetVersion(__out_ecount(*pdwVersion) LPWSTR pVersion, __inout DWORD* pdwVersion)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        PRECONDITION(CheckPointer(pdwVersion));
-        PRECONDITION(pdwVersion>0 && CheckPointer(pVersion));
-        INJECT_FAULT(return E_OUTOFMEMORY;);
-    }
-    CONTRACTL_END;
-
-    DWORD dwCORSystem = 0;
-    
-    LPCWSTR pCORSystem = GetInternalSystemDirectory(&dwCORSystem);
-    
-    if (dwCORSystem == 0) 
-        return E_FAIL;
-
-    dwCORSystem--; // remove the null character
-    if (dwCORSystem && pCORSystem[dwCORSystem-1] == W('\\'))
-        dwCORSystem--; // and the trailing slash if it exists
-
-    if (dwCORSystem==0)
-        return E_FAIL;
-
-    const WCHAR* pSeparator;
-    const WCHAR* pTail = pCORSystem + dwCORSystem;
-
-    for (pSeparator = pCORSystem+dwCORSystem-1; pSeparator > pCORSystem && *pSeparator != W('\\');pSeparator--);
-
-    if (*pSeparator == W('\\'))
-        pSeparator++;
-    
-    DWORD lgth = (DWORD)(pTail - pSeparator);
-    
-    if (lgth > *pdwVersion) {
-        *pdwVersion = lgth+1;
-        return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
-    }
-
-#ifdef _PREFAST_
-#pragma warning(push)
-#pragma warning(disable:26000) // "Disable PREFast/espX warning about buffer overflow"
-#endif
-    while(pSeparator < pTail) 
-        *pVersion++ = *pSeparator++;
-
-    *pVersion = W('\0');
-#ifdef _PREFAST_
-#pragma warning(pop)
-#endif
-
-    return S_OK;
-} // FusionBind::GetVersion
-
diff --git a/src/vm/fusioninit.cpp b/src/vm/fusioninit.cpp
deleted file mode 100644
index eb4cba6ee4..0000000000
--- a/src/vm/fusioninit.cpp
+++ /dev/null
@@ -1,624 +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.
-
-
-
-
-#include "common.h"
-
-#include "clrhost.h"
-#include "helpers.h"
-#include "dbglog.h"
-#include "adl.h"
-#include "cacheutils.h"
-#include "installlogger.h"
-#include "actasm.h"
-#include "naming.h"
-#include "policy.h"
-#include "bindhelpers.h"
-#ifdef FEATURE_COMINTEROP
-#include "appxutil.h"
-#endif
-
-#include "msi.h"
-
-STDAPI InitializeNativeBinder();
-
-#define DEVOVERRIDE_PATH							W(".local\\")
-#define REG_KEY_IMAGE_FILE_EXECUTION_OPTIONS		W("Software\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options")
-#define REG_VAL_DEVOVERRIDE_PATH					W("DevOverridePath")
-#define REG_VAL_DEVOVERRIDE_ENABLE					W("DevOverrideEnable")
-#define REG_VAL_FUSION_FORCE_UNIFICATION			W("OnlyUseLatestCLR") 
-#define REG_VAL_USE_LEGACY_IDENTITY_FORMAT			W("UseLegacyIdentityFormat")
-#define REG_VAL_ENABLE_MSI_IN_LOCAL_GAC				W("FusionEnableMSIInLocalGac")
-#define REG_VAL_ENABLE_FORCED_FULL_CLOSURE_WALK     W("FusionEnableForcedFullClosureWalk")
-
-// Registry / Environment variable
-#define BINDING_CONFIGURATION                  W("BindingConfiguration")
-
-extern HMODULE g_pMSCorEE;
-extern BOOL g_bRunningOnNT6OrHigher;
-
-WCHAR                         g_szWindowsDir[MAX_LONGPATH+1];
-WCHAR                         g_FusionDllPath[MAX_LONGPATH+1];
-HINSTANCE                     g_hInst = NULL;
-HMODULE                       g_hMSCorEE = NULL;
-DWORD                         g_dwLogInMemory;
-DWORD                         g_dwLogLevel;
-DWORD                         g_dwForceLog;
-DWORD                         g_dwLogFailures;
-DWORD                         g_dwLogResourceBinds;
-BOOL                          g_bBinderLoggingNeeded;
-DWORD                         g_dwDevOverrideEnable;
-WORD                          g_wProcessorArchitecture;     // Default to 32 bit
-BOOL                          g_fWow64Process;          // Wow64 Process
-PEKIND                        g_peKindProcess;
-List<CAssemblyDownload *>    *g_pDownloadList;
-BOOL                          g_bLogToWininet;
-WCHAR                         g_wzCustomLogPath[MAX_LONGPATH];
-DWORD                         g_dwConfigForceUnification;
-DWORD                         g_dwFileInUseRetryAttempts;
-DWORD                         g_dwFileInUseMillisecondsBetweenRetries;
-DWORD                         g_dwUseLegacyIdentityFormat;
-DWORD                         g_dwConfigEnableMSIInLocalGac = 0;
-DWORD                         g_dwConfigEnableForcedFullClosureWalk = 0;
-
-CRITSEC_COOKIE                g_csInitClb;
-CRITSEC_COOKIE                g_csConfigSettings;
-CRITSEC_COOKIE                g_csSingleUse;
-CRITSEC_COOKIE                g_csDownload;
-CRITSEC_COOKIE                g_csBindLog;
-
-// Defined in peimage.cpp
-extern LCID                          g_lcid;
-
-IIdentityAuthority           *g_pIdentityAuthority;
-CIdentityCache               *g_pIdentityCache;
-
-WCHAR                         g_wzEXEPath[MAX_LONGPATH+1];
-
-
-#ifdef _DEBUG
-BOOL                          g_bTagAssemblyNames;
-#endif //_DEBUG
-
-extern int SetOsFlag(void) ;
-
-// MSI
-DWORD g_dwDisableMSIPeek; 
-typedef HRESULT (*pfnMsiProvideAssemblyW)(LPCWSTR wzAssemblyName, LPCWSTR szAppContext,
-                                          DWORD dwInstallMode, DWORD dwUnused,
-                                          LPWSTR lpPathBuf, DWORD *pcchPathBuf);
-typedef INSTALLUILEVEL (*pfnMsiSetInternalUI)(INSTALLUILEVEL dwUILevel, HWND *phWnd);
-typedef UINT (*pfnMsiInstallProductW)(LPCWSTR wzPackagePath, LPCWSTR wzCmdLine);
-
-pfnMsiProvideAssemblyW     g_pfnMsiProvideAssemblyW;
-pfnMsiSetInternalUI        g_pfnMsiSetInternalUI;
-pfnMsiInstallProductW      g_pfnMsiInstallProductW;
-BOOL                       g_bCheckedMSIPresent;
-HMODULE                    g_hModMSI;
-
-WCHAR g_wzLocalDevOverridePath[MAX_LONGPATH + 1];
-WCHAR g_wzGlobalDevOverridePath[MAX_LONGPATH + 1];
-DWORD g_dwDevOverrideFlags;
-
-HRESULT GetScavengerQuotasFromReg(DWORD *pdwZapQuotaInGAC,
-                                  DWORD *pdwDownloadQuotaAdmin,
-                                  DWORD *pdwDownloadQuotaUser);
-
-HRESULT SetupDevOverride(LPCWSTR pwzBindingConfigDevOverridePath);
-
-static DWORD GetConfigDWORD(HKEY hkey, LPCWSTR wzName, DWORD dwDefault)
-{
-    LIMITED_METHOD_CONTRACT;
-    DWORD   lResult;
-    DWORD   dwSize;
-    DWORD   dwType = REG_DWORD;
-    DWORD   dwValue;
-
-    if (hkey == 0) {
-        return dwDefault;
-    }
-
-    dwSize = sizeof(DWORD);
-    lResult = WszRegQueryValueEx(hkey, wzName, NULL,
-                                &dwType, (LPBYTE)&dwValue, &dwSize);
-    if (lResult != ERROR_SUCCESS || dwType != REG_DWORD) {
-        return dwDefault;
-    }
-
-    return dwValue;
-}
-
-BOOL InitFusionCriticalSections()
-{
-    WRAPPER_NO_CONTRACT;
-    BOOL fRet = FALSE;
-
-    g_csInitClb = ClrCreateCriticalSection(CrstFusionClb, CRST_REENTRANCY);
-    if (!g_csInitClb) {
-        goto Exit;
-    }
-
-    g_csDownload = ClrCreateCriticalSection(CrstFusionDownload, CRST_REENTRANCY);
-    if (!g_csDownload) {
-        goto Exit;
-    }
-
-    g_csBindLog = ClrCreateCriticalSection(CrstFusionLog, CRST_DEFAULT);
-    if (!g_csBindLog) {
-        goto Exit;
-    }
-
-    g_csSingleUse = ClrCreateCriticalSection(CrstFusionSingleUse, CRST_DEFAULT);
-    if (!g_csSingleUse) {
-        goto Exit;
-    }
-
-    // <TODO> Get rid of this critical section</TODO>
-    g_csConfigSettings = ClrCreateCriticalSection(CrstFusionConfigSettings, CRST_DEFAULT);
-    if (!g_csConfigSettings) {
-        goto Exit;
-    }
-
-    fRet = TRUE;
-    
-Exit:
-    return fRet;
-}
-
-// ensure that the symbol will be exported properly
-extern "C" HRESULT STDMETHODCALLTYPE InitializeFusion();
-
-HRESULT STDMETHODCALLTYPE InitializeFusion()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        INJECT_FAULT(return E_OUTOFMEMORY;);
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    HRESULT             hr = S_OK;
-    static BOOL         bInitialized = FALSE;
-    LPWSTR              pwzBindingConfigAssemblyStorePath = NULL;
-    LPWSTR              pwzBindingConfigDevOverridePath = NULL;
-    ReleaseHolder<CNodeFactory> pNodeFact;
-    DWORD               dwSize = 0;
-    BOOL                fExecutableIsKnown = FALSE;
-    LPWSTR              pwzFileName = NULL;
-    WCHAR               wzBindingConfigPath[MAX_LONGPATH + 1];
-
-    BEGIN_SO_INTOLERANT_CODE_NO_THROW_CHECK_THREAD(return COR_E_STACKOVERFLOW);
-    
-    if (bInitialized) {
-        hr = S_OK;
-        goto Exit;
-    }
-
-    g_hInst = g_pMSCorEE;
-
-    SetOsFlag();
-
-    g_lcid = MAKELCID(LOCALE_INVARIANT, SORT_DEFAULT);
-
-    WszGetModuleFileName(g_hInst, g_FusionDllPath, MAX_LONGPATH);
-
-    if (!InitFusionCriticalSections()) {
-        hr = E_OUTOFMEMORY;
-        goto Exit;
-    }
-
-    g_wProcessorArchitecture = g_SystemInfo.wProcessorArchitecture;
-
-    g_fWow64Process = RunningInWow64();
-
-    if (IsProcess32()) {
-        g_peKindProcess = (g_wProcessorArchitecture==PROCESSOR_ARCHITECTURE_INTEL)?peI386:peARM;
-    }
-    else {
-        g_peKindProcess = (g_wProcessorArchitecture==PROCESSOR_ARCHITECTURE_IA64)?peIA64:peAMD64;
-    }
-
-    if (!g_pIdentityAuthority) {
-        IIdentityAuthority                      *pAuth = NULL;
-
-        hr = GetIdentityAuthority(&pAuth);
-        if (FAILED(hr)) {
-            goto Exit;
-        }
-
-        if (InterlockedCompareExchangeT(&g_pIdentityAuthority, pAuth, NULL) != NULL) {
-            SAFE_RELEASE(pAuth);
-        }
-    }
-
-    if (!g_pIdentityCache) {
-        CIdentityCache              *pIdentityCache;
-        
-        hr = CIdentityCache::Create(&pIdentityCache);
-        if (FAILED(hr)) {
-            goto Exit;
-        }
-        
-        if (InterlockedCompareExchangeT(&g_pIdentityCache, pIdentityCache, NULL) != NULL) {
-            SAFEDELETE(pIdentityCache);
-        }
-    }
-
-    DWORD           lResult;
-    HKEY            hKey;
-
-    lResult = FusionRegOpenKeyEx(HKEY_LOCAL_MACHINE, REG_KEY_FUSION_SETTINGS, 0, KEY_READ, &hKey);
-    if (lResult != ERROR_SUCCESS) {
-        hKey = 0;
-    }
-    
-#define _GetConfigDWORD(name, default) GetConfigDWORD(hKey, name, default)
-
-    // Get this executable's filename
-    fExecutableIsKnown = WszGetModuleFileName(NULL, g_wzEXEPath, MAX_LONGPATH);
-    if(!fExecutableIsKnown) {
-        hr = StringCbCopy(g_wzEXEPath, sizeof(g_wzEXEPath), W("Unknown"));
-        if (FAILED(hr)) {
-            goto Exit;
-        }
-    }
-
-    if (g_bRunningOnNT6OrHigher) {
-        //
-        // BINDINGCONFIGURATION
-        //
-        // Obtain the path to an override xml file via the registry for
-        // this executable or from the environment variable
-        //
-        wzBindingConfigPath[0] = W('\0');
-
-        // If there is a BindingConfiguration entry for this 
-        // executable, then read it
-        pwzFileName = PathFindFileName(g_wzEXEPath);
-        if(fExecutableIsKnown && pwzFileName) {
-            WCHAR       wzValue[MAX_LONGPATH + 1];
-            HKEY        hKeyExeName = NULL;
-            DWORD       dwType = REG_SZ;
-
-            wzValue[0] = W('\0');
-
-            // key name + '\' + filename + null
-            if(lstrlenW(REG_KEY_IMAGE_FILE_EXECUTION_OPTIONS) + 1 + lstrlenW(pwzFileName) + 1 > MAX_PATH_FNAME) {
-                hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
-                goto Exit;
-            }
-
-            hr = StringCchPrintf(wzValue, MAX_PATH_FNAME, W("%ws\\%ws"), 
-                REG_KEY_IMAGE_FILE_EXECUTION_OPTIONS, pwzFileName);
-            if (FAILED(hr)) {
-                goto Exit;
-            }
-
-            lResult = FusionRegOpenKeyEx(HKEY_LOCAL_MACHINE, wzValue, 0, KEY_READ, &hKeyExeName);
-            if(lResult != ERROR_SUCCESS) {
-                if(lResult != ERROR_FILE_NOT_FOUND) {
-                    hr = HRESULT_FROM_WIN32(lResult);
-                    goto Exit;
-                }
-            }
-            else {  // Success
-                dwSize = MAX_LONGPATH * sizeof(WCHAR);
-                wzValue[0] = W('\0');
-
-                lResult = WszRegQueryValueEx(hKeyExeName, BINDING_CONFIGURATION, NULL, &dwType, (LPBYTE)wzValue, &dwSize);
-                RegCloseKey(hKeyExeName);
-                if(lResult != ERROR_SUCCESS) {
-                    if(lResult != ERROR_FILE_NOT_FOUND) {
-                        hr = HRESULT_FROM_WIN32(lResult);
-                        goto Exit;
-                    }
-                }
-                else {  // Success
-                    if(dwType != REG_SZ) {
-                        hr = HRESULT_FROM_WIN32(ERROR_BADKEY);
-                        goto Exit;
-                    }
-
-                    if(wzValue[0]) {
-                        hr = StringCbCopy(wzBindingConfigPath, sizeof(wzBindingConfigPath), wzValue);
-                        if (FAILED(hr)) {
-                            goto Exit;
-                        }
-                    }
-                }
-            }
-        }
-
-        // If we didn't get a path from the registry,
-        // try the ENV variable.
-        if(!wzBindingConfigPath[0]) {
-            dwSize = WszGetEnvironmentVariable(BINDING_CONFIGURATION, wzBindingConfigPath, MAX_LONGPATH);
-            if(dwSize > MAX_LONGPATH) {
-                hr = HRESULT_FROM_WIN32(ERROR_BUFFER_OVERFLOW);
-                goto Exit;
-            }
-        }
-
-        // We have a path to XML config override file
-        if(wzBindingConfigPath[0]) {
-            hr = ParseXML(&pNodeFact, wzBindingConfigPath, NULL, FALSE);
-            if (FAILED(hr)) {
-                goto Exit;
-            }
-        
-            // Get AssemblyStore override path
-            hr = pNodeFact->GetAssemblyStorePath(&pwzBindingConfigAssemblyStorePath);
-            if(FAILED(hr)) {
-                goto Exit;
-            }
-        
-            // Get DevOverride path
-            hr = pNodeFact->GetDevOverridePath(&pwzBindingConfigDevOverridePath);
-            if(FAILED(hr)) {
-                goto Exit;
-            }
-        }
-    }
-
-    //
-    // end BindingConfiguration
-    //
-
-    hr = SetRootCachePath(pwzBindingConfigAssemblyStorePath);
-    if(FAILED(hr)) {
-        goto Exit;
-    }
-
-    GetScavengerQuotasFromReg(NULL, NULL, NULL);
-
-#ifdef _DEBUG
-    g_bTagAssemblyNames = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_TagAssemblyNames);
-#endif //_DEBUG
-
-    // Machine level logging settings
-    g_dwLogInMemory = _GetConfigDWORD(REG_VAL_FUSION_LOG_ENABLE, 0);
-    g_dwLogLevel = _GetConfigDWORD(REG_VAL_FUSION_LOG_LEVEL, 1);
-    g_dwForceLog = _GetConfigDWORD(REG_VAL_FUSION_LOG_FORCE, 0);
-    g_dwLogFailures = _GetConfigDWORD(REG_VAL_FUSION_LOG_FAILURES, 0);
-    g_dwLogResourceBinds = _GetConfigDWORD(REG_VAL_FUSION_LOG_RESOURCE_BINDS, 0);
-
-    BOOL fusionMessagesAreEnabled = ETW_EVENT_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context, FusionMessageEvent);
-    g_bBinderLoggingNeeded = !!(fusionMessagesAreEnabled || g_dwLogFailures || g_dwForceLog || g_dwLogResourceBinds || g_dwLogInMemory);
-
-    g_dwConfigForceUnification = REGUTIL::GetConfigDWORD_DontUse_(REG_VAL_FUSION_FORCE_UNIFICATION, 0);
-
-    // Settings to indicate how many times to retry opening a hard-locked file for reading, moving/renaming or deletion.
-    // Used to configure CreateFileWithRetries and MoveFileWithRetries in fusion\Utils\Helpers.cpp
-    // These are used mainly for GAC Installation where anti-virus and indexing programs can temporarily hard-lock files.
-    // g_dwFileInUseRetryAttempts does not include the first attempt to open the file (hence set it to 0 to prevent retries).
-    g_dwFileInUseRetryAttempts = _GetConfigDWORD(REG_VAL_FUSION_FILE_IN_USE_RETRY_ATTEMPTS, FILE_IN_USE_RETRY_ATTEMPTS);
-    if (g_dwFileInUseRetryAttempts > MAX_FILE_IN_USE_RETRY_ATTEMPTS)
-        g_dwFileInUseRetryAttempts = MAX_FILE_IN_USE_RETRY_ATTEMPTS;    
-    g_dwFileInUseMillisecondsBetweenRetries = _GetConfigDWORD(REG_VAL_FUSION_FILE_IN_USE_MILLISECONDS_BETWEEN_RETRIES, FILE_IN_USE_MILLISECONDS_BETWEEN_RETRIES);
-    if (g_dwFileInUseMillisecondsBetweenRetries > MAX_FILE_IN_USE_MILLISECONDS_BETWEEN_RETRIES)
-        g_dwFileInUseMillisecondsBetweenRetries = MAX_FILE_IN_USE_MILLISECONDS_BETWEEN_RETRIES;    
-
-    // This setting is only relevant in the unsupported case where we're running out of a local GAC
-    // g_bUseDefaultStore is initialized in SetRootCachePath above
-    if (!g_bUseDefaultStore)
-    {
-        g_dwConfigEnableMSIInLocalGac = REGUTIL::GetConfigDWORD_DontUse_(REG_VAL_ENABLE_MSI_IN_LOCAL_GAC, 0);
-    }
-    g_dwConfigEnableForcedFullClosureWalk = REGUTIL::GetConfigDWORD_DontUse_(REG_VAL_ENABLE_FORCED_FULL_CLOSURE_WALK, 0);
-
-    g_dwUseLegacyIdentityFormat = AppX::IsAppXProcess() || _GetConfigDWORD(REG_VAL_USE_LEGACY_IDENTITY_FORMAT, 0);
-    g_dwDisableMSIPeek = _GetConfigDWORD(W("DisableMSIPeek"), FALSE);
-    g_dwDisableMSIPeek |= CLRConfig::GetConfigValue(CLRConfig::INTERNAL_DisableMSIPeek);
-
-    if (hKey) {
-        RegCloseKey(hKey);
-        hKey = NULL;
-    }
-
-    {
-        WCHAR wzBuf[1];
-
-        wzBuf[0] = W('\0');
-        dwSize = WszGetEnvironmentVariable(W("USE_LEGACY_IDENTITY_FORMAT"), wzBuf, 1);
-        if (dwSize == 1 && !FusionCompareString(wzBuf, W("1"))) {
-            g_dwUseLegacyIdentityFormat = 1;
-        }
-    }
-
-    if (IsLoggingNeeded()) {
-        g_bLogToWininet = TRUE;
-        dwSize = MAX_LONGPATH;
-        DWORD dwAttr;
-        BOOL  fExists;
-        g_wzCustomLogPath[0] = W('\0');
-        GetCustomLogPath(g_wzCustomLogPath, &dwSize);
-        if (g_wzCustomLogPath[0] != W('\0')) {
-            if(SUCCEEDED(CheckFileExistence(g_wzCustomLogPath, &fExists, &dwAttr)) &&
-               fExists && (dwAttr & FILE_ATTRIBUTE_DIRECTORY)) {
-                g_bLogToWininet = FALSE;
-            }
-        }
-    }
-
-    // make devoverride longhorn+ only
-    if (g_bRunningOnNT6OrHigher) {
-        hr = SetupDevOverride(pwzBindingConfigDevOverridePath);
-        if (FAILED(hr)) {
-            goto Exit;
-        }
-    }
-    
-    g_pDownloadList = new (nothrow) List<CAssemblyDownload *>;
-    if (!g_pDownloadList) {
-        hr = E_OUTOFMEMORY;
-        goto Exit;
-    }
-
-    g_pAssemblyFingerprintCache = new (nothrow) CAssemblyFingerprintCache;
-    if (!g_pAssemblyFingerprintCache) {
-        hr = E_OUTOFMEMORY;
-        goto Exit;
-    }
-
-    hr = g_pAssemblyFingerprintCache->Init();
-    if (FAILED(hr))
-    {
-        goto Exit;
-    }
-
-    bInitialized = TRUE;
-
-    hr = InitializeNativeBinder();
-    if (FAILED(hr))
-    {
-        goto Exit;
-    }
-
-Exit:
-    SAFEDELETEARRAY(pwzBindingConfigAssemblyStorePath);
-    SAFEDELETEARRAY(pwzBindingConfigDevOverridePath);
-
-    END_SO_INTOLERANT_CODE;
-    
-    return hr;
-}
-
-HRESULT SetupDevOverride(LPCWSTR pwzBindingConfigDevOverridePath)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        INJECT_FAULT(return E_OUTOFMEMORY;);
-    }
-    CONTRACTL_END;
-
-    HRESULT         hr = S_OK;
-
- // g_wzLocalDevOverridePath[0] = W('\0');
- // g_wzGlobalDevOverridePath[0] = W('\0');
-    g_dwDevOverrideFlags = 0;
-
-    DWORD                                        dwFileAttr;
-    DWORD                                        dwType;
-    DWORD                                        dwSize;
-    LONG                                         lResult = 0;
-    HKEY                                         hKey = 0;
-
-    lResult = FusionRegOpenKeyEx(HKEY_LOCAL_MACHINE, REG_KEY_IMAGE_FILE_EXECUTION_OPTIONS, 0, KEY_READ, &hKey);
-    if (lResult != ERROR_SUCCESS) {
-        hr = S_FALSE; 
-        goto Exit;
-    }
-
-    g_dwDevOverrideEnable = _GetConfigDWORD(REG_VAL_DEVOVERRIDE_ENABLE, 0);
-
-    if (g_dwDevOverrideEnable != 0) {
-
-        // Check local dev path
-        if (!WszGetModuleFileName(NULL, g_wzLocalDevOverridePath, MAX_LONGPATH)) {
-            hr = HRESULT_FROM_GetLastError();
-            goto Exit;
-        }
-
-        if (lstrlenW(g_wzLocalDevOverridePath) + lstrlenW(DEVOVERRIDE_PATH) <= MAX_LONGPATH) {
-            // Only process .devoverride if the total path length <= MAX_LONGPATH
-
-            hr = StringCbCat(g_wzLocalDevOverridePath, sizeof(g_wzLocalDevOverridePath), DEVOVERRIDE_PATH);
-            if (FAILED(hr)) {
-                goto Exit;
-            }
-
-            dwFileAttr = WszGetFileAttributes(g_wzLocalDevOverridePath);
-            if ((dwFileAttr != INVALID_FILE_ATTRIBUTES) && (dwFileAttr & FILE_ATTRIBUTE_DIRECTORY)) {
-                g_dwDevOverrideFlags |= DEVOVERRIDE_LOCAL;
-            }
-            else {
-                // Clear the path just for goodness sake
-                g_wzLocalDevOverridePath[0] = W('\0');
-            }
-        }
-
-        // Check global dev path
-        dwSize = sizeof(g_wzGlobalDevOverridePath);
-
-        lResult = WszRegQueryValueEx(hKey, REG_VAL_DEVOVERRIDE_PATH, NULL, &dwType, (LPBYTE)g_wzGlobalDevOverridePath, &dwSize);
-        if (lResult == ERROR_SUCCESS && lstrlenW(g_wzGlobalDevOverridePath) && dwType == REG_SZ) {
-            
-            dwFileAttr = WszGetFileAttributes(g_wzGlobalDevOverridePath);
-            if ((dwFileAttr != INVALID_FILE_ATTRIBUTES) && (dwFileAttr & FILE_ATTRIBUTE_DIRECTORY)) {
-                g_dwDevOverrideFlags |= DEVOVERRIDE_GLOBAL;
-            }
-            else {
-                // Clear the path just for goodness sake
-                g_wzGlobalDevOverridePath[0] = W('\0');
-            }
-        }
-
-        // BINDING_CONFIGURATION Env check
-        if(pwzBindingConfigDevOverridePath && pwzBindingConfigDevOverridePath[0]) {
-            WCHAR       wzTempPath[MAX_LONGPATH + 1];
-            BOOL        fExists = FALSE;
-            WIN32_FILE_ATTRIBUTE_DATA fileInfo;
-
-            wzTempPath[0] = W('\0');
-
-#ifdef _PREFAST_
-#pragma warning(push)
-#pragma warning(disable:25025)
-#endif
-            // usage of PathCanonicalize is safe if we ensure that
-            // length of buffer specified by parameter1 is >= length of buffer specified by parameter2
-            if(lstrlenW(pwzBindingConfigDevOverridePath) + 1 > COUNTOF(wzTempPath)) {
-                hr = HRESULT_FROM_WIN32(ERROR_BUFFER_OVERFLOW);
-                goto Exit;
-            }
-
-            if(!PathCanonicalize(wzTempPath, pwzBindingConfigDevOverridePath)) {
-                hr = E_FAIL;
-                goto Exit;
-            }
-
-#ifdef _PREFAST_
-#pragma warning(pop)
-#endif
-
-            if(!WszGetFileAttributesEx(wzTempPath, GetFileExInfoStandard, &fileInfo)) {
-                hr = HRESULT_FROM_WIN32(GetLastError());
-                goto Exit;
-            }
-
-            if(!(fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
-                hr = HRESULT_FROM_WIN32(ERROR_FILE_EXISTS);
-                goto Exit;
-            }
-            
-            hr = StringCbCopy(g_wzGlobalDevOverridePath, sizeof(g_wzGlobalDevOverridePath), wzTempPath);
-            if (FAILED(hr)) {
-                goto Exit;
-            }
-
-            g_dwDevOverrideFlags |= DEVOVERRIDE_GLOBAL;
-        }
-
-        if(g_dwDevOverrideFlags & DEVOVERRIDE_GLOBAL) {
-            PathAddBackslashWrap(g_wzGlobalDevOverridePath, MAX_LONGPATH);
-        }
-    }
-
-Exit:
-
-    if (hKey) {
-        RegCloseKey(hKey);
-    }
-
-    return hr;
-}
-
diff --git a/src/vm/fusionsink.cpp b/src/vm/fusionsink.cpp
deleted file mode 100644
index b40192b68a..0000000000
--- a/src/vm/fusionsink.cpp
+++ /dev/null
@@ -1,215 +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.
-
-/*============================================================
-**
-** Header:  FusionSink.cpp
-**
-** Purpose: Implements FusionSink, event objects that block 
-**          the current thread waiting for an asynchronous load
-**          of an assembly to succeed. 
-**
-**
-
-
-===========================================================*/
-
-#include "common.h"
-
-#include <stdlib.h>
-#include "fusionsink.h"
-#include "ex.h"
-
-STDMETHODIMP FusionSink::QueryInterface(REFIID riid, void** ppv)
-{
-    CONTRACTL
-    {
-        MODE_ANY;
-        GC_NOTRIGGER;
-        NOTHROW;
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-    
-    *ppv = NULL;
-
-    if (riid == IID_IUnknown)
-        *ppv = (IUnknown*) (IAssemblyBindSink*) this;
-    else if (riid == IID_IAssemblyBindSink)   
-        *ppv = (IAssemblyBindSink*)this;
-    else if (riid == IID_INativeImageEvaluate)   
-        *ppv = (INativeImageEvaluate*)this;
-    if (*ppv == NULL)
-        hr = E_NOINTERFACE;
-    else
-        AddRef();   
-
-    END_ENTRYPOINT_NOTHROW;
-
-    return hr;
-}
-
-STDMETHODIMP FusionSink::OnProgress(DWORD dwNotification,
-                                    HRESULT hrNotification,
-                                    LPCWSTR szNotification,
-                                    DWORD dwProgress,
-                                    DWORD dwProgressMax,
-                                    LPVOID pvBindInfo,
-                                    IUnknown* punk)
-{
-    LIMITED_METHOD_CONTRACT;
-    HRESULT hr = S_OK;
-    switch(dwNotification) {
-    case ASM_NOTIFICATION_DONE:
-        m_LastResult = hrNotification;
-        if(m_pAbortUnk) {
-            m_pAbortUnk->Release();
-            m_pAbortUnk = NULL;
-        }
-
-        if(punk && SUCCEEDED(hrNotification))
-            hr = punk->QueryInterface(IID_IUnknown, (void**) &m_punk);
-        m_hEvent->Set();
-        break;
-    case ASM_NOTIFICATION_NATIVE_IMAGE_DONE:
-        if(punk && SUCCEEDED(hrNotification))
-            hr = punk->QueryInterface(IID_IUnknown, (void**) &m_pNIunk);
-        break;
-        
-    case ASM_NOTIFICATION_START:
-        if(punk)
-            hr = punk->QueryInterface(IID_IUnknown, (void**) &m_pAbortUnk);
-        break;
-
-    case ASM_NOTIFICATION_ATTEMPT_NEXT_CODEBASE:
-        break;
-
-    case ASM_NOTIFICATION_BIND_INFO:
-        FusionBindInfo          *pBindInfo;
-
-        pBindInfo = (FusionBindInfo *)pvBindInfo;
-
-        if (pBindInfo && m_pFusionLog == NULL) {
-            m_pFusionLog = pBindInfo->pdbglog;
-            if (m_pFusionLog) {
-                m_pFusionLog->AddRef();
-            }
-        }
-        break;
-    default:
-        break;
-    }
-    
-    return hr;
-}
-
-ULONG FusionSink::AddRef()
-{
-    LIMITED_METHOD_CONTRACT;
-    ULONG cRefCount = 0;
-    //BEGIN_ENTRYPOINT_VOIDRET;
-
-    cRefCount = (InterlockedIncrement(&m_cRef));
-    //END_ENTRYPOINT_VOIDRET;
-    return cRefCount;
-}
-
-ULONG FusionSink::Release()
-{
-    WRAPPER_NO_CONTRACT;
-    STATIC_CONTRACT_ENTRY_POINT;
-    BEGIN_CLEANUP_ENTRYPOINT;
-    
-    ULONG   cRef = InterlockedDecrement(&m_cRef);
-    if (!cRef) {
-        Reset();
-        delete this;
-    }
-    END_CLEANUP_ENTRYPOINT;
-    return (cRef);
-}
-
-HRESULT FusionSink::AssemblyResetEvent()
-{
-    WRAPPER_NO_CONTRACT;
-    HRESULT hr = AssemblyCreateEvent();
-    if(FAILED(hr)) return hr;
-
-    if(!m_hEvent->Reset()) {
-        hr = HRESULT_FROM_GetLastErrorNA();
-    }
-
-    return hr;
-}
-
-HRESULT FusionSink::AssemblyCreateEvent()
-{
-    STATIC_CONTRACT_NOTHROW;
-    HRESULT hr = S_OK;
-    if(m_hEvent == NULL) {
-        // Initialize the event to require manual reset
-        // and to initially signaled.
-        EX_TRY {
-            m_hEvent = new Event();
-            m_hEvent->CreateManualEvent(TRUE);
-        }
-        EX_CATCH
-        {
-            hr = GET_EXCEPTION()->GetHR();
-        }
-        EX_END_CATCH(SwallowAllExceptions);
-    }
-    return hr;
-}
-
-HRESULT FusionSink::Wait()
-{
-    STATIC_CONTRACT_NOTHROW;
-
-#if CHECK_INVARIANTS
-    _ASSERTE(CheckPointer(this));
-    _ASSERTE(CheckPointer(m_hEvent));
-#endif  // CHECK_INVARIANTS
-
-    HRESULT hr = S_OK;
-    DWORD   dwReturn = 0;
-
-    // CLREvent::Wait will switch mode if needed;
-
-    // Waiting for a signal from fusion - which we are guaranteed to get.
-    // We do a WaitForMultipleObjects (STA and MTA) and pump messages in the STA case
-    // in the call so we shouldn't freeze the system.
-    EX_TRY 
-    {
-        dwReturn = m_hEvent->Wait(INFINITE,TRUE);
-    } 
-    EX_CATCH 
-    {
-        // Fusion uses us via COM interface so we need to swallow exceptions
-        hr = GET_EXCEPTION()->GetHR();
-
-        //@todo: is it right thing to do to swallow exceptions here
-    } 
-    EX_END_CATCH(SwallowAllExceptions);
-
-    return hr;
-}
-
-HRESULT FusionSink::Evaluate (
-        IAssembly *pILAssembly, 
-        IAssembly *pNativeAssembly,
-        BYTE * pbCachedData,
-        DWORD dwDataSize
-        )
-{
-    LIMITED_METHOD_CONTRACT;
-    STATIC_CONTRACT_ENTRY_POINT;
-
-    return S_OK;
-}
-
diff --git a/src/vm/gccover.cpp b/src/vm/gccover.cpp
index d5e7b60d1a..02bb0de5e0 100644
--- a/src/vm/gccover.cpp
+++ b/src/vm/gccover.cpp
@@ -1565,10 +1565,10 @@ void DoGcStress (PCONTEXT regs, MethodDesc *pMD)
             
             _ASSERTE(pThread->PreemptiveGCDisabled());    // Epilogs should be in cooperative mode, no GC can happen right now. 
             bool gcHappened = gcCover->gcCount != GCHeapUtilities::GetGCHeap()->GetGcCount();
-            checkAndUpdateReg(gcCover->callerRegs.Edi, *regDisp.pEdi, gcHappened);
-            checkAndUpdateReg(gcCover->callerRegs.Esi, *regDisp.pEsi, gcHappened);
-            checkAndUpdateReg(gcCover->callerRegs.Ebx, *regDisp.pEbx, gcHappened);
-            checkAndUpdateReg(gcCover->callerRegs.Ebp, *regDisp.pEbp, gcHappened);
+            checkAndUpdateReg(gcCover->callerRegs.Edi, *regDisp.GetEdiLocation(), gcHappened);
+            checkAndUpdateReg(gcCover->callerRegs.Esi, *regDisp.GetEsiLocation(), gcHappened);
+            checkAndUpdateReg(gcCover->callerRegs.Ebx, *regDisp.GetEbxLocation(), gcHappened);
+            checkAndUpdateReg(gcCover->callerRegs.Ebp, *regDisp.GetEbpLocation(), gcHappened);
             
             gcCover->gcCount = GCHeapUtilities::GetGCHeap()->GetGcCount();
 
diff --git a/src/vm/gcenv.os.cpp b/src/vm/gcenv.os.cpp
index 52789b835c..784984472d 100644
--- a/src/vm/gcenv.os.cpp
+++ b/src/vm/gcenv.os.cpp
@@ -380,11 +380,7 @@ static size_t GetRestrictedPhysicalMemoryLimit()
 
     size_t job_physical_memory_limit = (size_t)MAX_PTR;
     BOOL in_job_p = FALSE;
-#ifdef FEATURE_CORECLR
     HINSTANCE hinstKernel32 = 0;
-#else
-    HINSTANCE hinstPsapi = 0;
-#endif
 
     PIS_PROCESS_IN_JOB GCIsProcessInJob = 0;
     PQUERY_INFORMATION_JOB_OBJECT GCQueryInformationJobObject = 0;
@@ -396,21 +392,11 @@ static size_t GetRestrictedPhysicalMemoryLimit()
 
     if (in_job_p)
     {
-#ifdef FEATURE_CORECLR
         hinstKernel32 = WszLoadLibrary(L"kernel32.dll");
         if (!hinstKernel32)
             goto exit;
 
         GCGetProcessMemoryInfo = (PGET_PROCESS_MEMORY_INFO)GetProcAddress(hinstKernel32, "K32GetProcessMemoryInfo");
-#else
-        // We need a way to get the working set in a job object and GetProcessMemoryInfo 
-        // is the way to get that. According to MSDN, we should use GetProcessMemoryInfo In order to 
-        // compensate for the incompatibility that psapi.dll introduced we are getting this dynamically.
-        hinstPsapi = WszLoadLibrary(L"psapi.dll");
-        if (!hinstPsapi)
-            return 0;
-        GCGetProcessMemoryInfo = (PGET_PROCESS_MEMORY_INFO)GetProcAddress(hinstPsapi, "GetProcessMemoryInfo");
-#endif
 
         if (!GCGetProcessMemoryInfo)
             goto exit;
@@ -462,11 +448,7 @@ exit:
     {
         job_physical_memory_limit = 0;
 
-#ifdef FEATURE_CORECLR
         FreeLibrary(hinstKernel32);
-#else
-        FreeLibrary(hinstPsapi);
-#endif
     }
 
     VolatileStore(&g_RestrictedPhysicalMemoryLimit, job_physical_memory_limit);
diff --git a/src/vm/gchelpers.cpp b/src/vm/gchelpers.cpp
index 30f6dd0c81..f2311f8351 100644
--- a/src/vm/gchelpers.cpp
+++ b/src/vm/gchelpers.cpp
@@ -21,7 +21,6 @@
 #include "threads.h"
 #include "fieldmarshaler.h"
 #include "interoputil.h"
-#include "constrainedexecutionregion.h"
 #include "dynamicmethod.h"
 #include "stubhelpers.h"
 #include "eventtrace.h"
@@ -1005,10 +1004,6 @@ OBJECTREF AllocateObject(MethodTable *pMT
     g_IBCLogger.LogMethodTableAccess(pMT);
     SetTypeHandleOnThreadForAlloc(TypeHandle(pMT));
 
-#ifdef FEATURE_CER
-    if (pMT->HasCriticalFinalizer())
-        PrepareCriticalFinalizerObject(pMT);
-#endif
 
 #ifdef FEATURE_COMINTEROP
 #ifdef FEATURE_COMINTEROP_UNMANAGED_ACTIVATION
diff --git a/src/vm/gchost.cpp b/src/vm/gchost.cpp
deleted file mode 100644
index b51f2459fd..0000000000
--- a/src/vm/gchost.cpp
+++ /dev/null
@@ -1,276 +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.
-//*****************************************************************************
-// gchost.cpp
-//
-// This module contains the implementation for the IGCController interface.
-// This interface is published through the gchost.idl file.  It allows a host
-// environment to set config values for the GC.
-//
-
-//
-//*****************************************************************************
-
-//********** Includes *********************************************************
-
-#include "common.h"
-#include "vars.hpp"
-#include "eeconfig.h"
-#include "perfcounters.h"
-#include "gchost.h"
-#include "corhost.h"
-#include "excep.h"
-#include "field.h"
-#include "gcheaputilities.h"
-
-#if !defined(FEATURE_CORECLR)
-inline size_t SizeInKBytes(size_t cbSize)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    size_t cb = (cbSize % 1024) ? 1 : 0;
-    return ((cbSize / 1024) + cb);
-}
-
-// IGCController
-
-HRESULT CorGCHost::_SetGCSegmentSize(SIZE_T SegmentSize)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    // Sanity check the value, it must be a power of two and big enough.
-    if (!GCHeapUtilities::GetGCHeap()->IsValidSegmentSize(SegmentSize))
-    {
-        hr = E_INVALIDARG;
-    }
-    else
-    {
-        Host_SegmentSize = SegmentSize;
-        Host_fSegmentSizeSet = TRUE;
-    }
-
-    return (hr);
-}
-
-HRESULT CorGCHost::_SetGCMaxGen0Size(SIZE_T MaxGen0Size)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    // Sanity check the value is at least large enough.
-    if (!GCHeapUtilities::GetGCHeap()->IsValidGen0MaxSize(MaxGen0Size))
-    {
-        hr = E_INVALIDARG;
-    }
-    else
-    {
-        Host_MaxGen0Size = MaxGen0Size;
-        Host_fMaxGen0SizeSet = TRUE;
-    }
-
-    return (hr);
-}
-
-HRESULT CorGCHost::SetGCStartupLimits(
-    DWORD SegmentSize,
-    DWORD MaxGen0Size)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    // Set default overrides if specified by caller.
-    if (SegmentSize != (DWORD) ~0 && SegmentSize > 0)
-    {
-        hr = _SetGCSegmentSize(SegmentSize);
-    }
-
-    if (SUCCEEDED(hr) && MaxGen0Size != (DWORD) ~0 && MaxGen0Size > 0)
-    {
-        hr = _SetGCMaxGen0Size(MaxGen0Size);
-    }
-
-    return (hr);
-}
-
-HRESULT CorGCHost::SetGCStartupLimitsEx( 
-    SIZE_T SegmentSize,
-    SIZE_T MaxGen0Size)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    // Set default overrides if specified by caller.
-    if (SegmentSize != (SIZE_T) ~0 && SegmentSize > 0)
-    {
-        hr = _SetGCSegmentSize(SegmentSize);
-    }
-
-    if (SUCCEEDED(hr) && MaxGen0Size != (SIZE_T) ~0 && MaxGen0Size > 0)
-    {
-        hr = _SetGCMaxGen0Size(MaxGen0Size);
-    }
-
-    return (hr);
-}
-
-// Collect the requested generation.
-HRESULT CorGCHost::Collect( 
-    LONG       Generation)
-{
-    STATIC_CONTRACT_SO_TOLERANT;
-    
-    HRESULT     hr = E_FAIL;
-    
-    if (Generation > (int) GCHeapUtilities::GetGCHeap()->GetMaxGeneration())
-        hr = E_INVALIDARG;
-    else
-    {
-        // Set up a Thread object if this is called on a native thread.
-        Thread *pThread;
-        pThread = GetThread();
-        if (pThread == NULL)
-            pThread = SetupThreadNoThrow(&hr);
-
-        if (pThread != NULL)
-        {
-            // Put thread into co-operative mode, which is how GC must run.
-            GCX_COOP();
-        
-            BEGIN_SO_INTOLERANT_CODE_NO_THROW_CHECK_THREAD(return COR_E_STACKOVERFLOW);
-
-            EX_TRY
-            {			
-                hr = GCHeapUtilities::GetGCHeap()->GarbageCollect(Generation);
-            }
-            EX_CATCH
-            {
-                hr = GET_EXCEPTION()->GetHR();
-            }
-            EX_END_CATCH(SwallowAllExceptions);
-
-            END_SO_INTOLERANT_CODE;
-        }
-    }
-    return (hr);
-}
-
-
-// Return GC counters in the gchost format.
-HRESULT CorGCHost::GetStats( 
-    COR_GC_STATS *pStats)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-#if defined(ENABLE_PERF_COUNTERS)
-
-    Perf_GC     *pgc = &GetPerfCounters().m_GC;
-
-    if (!pStats)
-        return (E_INVALIDARG);
-
-    if (pStats->Flags & COR_GC_COUNTS)
-    {
-        pStats->ExplicitGCCount = pgc->cInducedGCs;
-        for (int idx=0; idx<3; idx++)
-        {
-            pStats->GenCollectionsTaken[idx] = pgc->cGenCollections[idx];
-        }
-    }
-    
-    if (pStats->Flags & COR_GC_MEMORYUSAGE)
-    {
-        pStats->CommittedKBytes = SizeInKBytes(pgc->cTotalCommittedBytes);
-        pStats->ReservedKBytes = SizeInKBytes(pgc->cTotalReservedBytes);
-        pStats->Gen0HeapSizeKBytes = SizeInKBytes(pgc->cGenHeapSize[0]);
-        pStats->Gen1HeapSizeKBytes = SizeInKBytes(pgc->cGenHeapSize[1]);
-        pStats->Gen2HeapSizeKBytes = SizeInKBytes(pgc->cGenHeapSize[2]);
-        pStats->LargeObjectHeapSizeKBytes = SizeInKBytes(pgc->cLrgObjSize);
-        pStats->KBytesPromotedFromGen0 = SizeInKBytes(pgc->cbPromotedMem[0]);
-        pStats->KBytesPromotedFromGen1 = SizeInKBytes(pgc->cbPromotedMem[1]);
-    }
-    return (S_OK);
-#else
-    return (E_NOTIMPL);
-#endif // ENABLE_PERF_COUNTERS
-}
-
-// Return per-thread allocation information.
-HRESULT CorGCHost::GetThreadStats( 
-    DWORD *pFiberCookie,
-    COR_GC_THREAD_STATS *pStats)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    Thread      *pThread;
-
-    // Get the thread from the caller or the current thread.
-    if (!pFiberCookie)
-        pThread = GetThread();
-    else
-        pThread = (Thread *) pFiberCookie;
-    if (!pThread)
-        return (E_INVALIDARG);
-    
-    return pThread->GetMemStats (pStats);
-}
-
-// Return per-thread allocation information.
-HRESULT CorGCHost::SetVirtualMemLimit(
-    SIZE_T sztMaxVirtualMemMB)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    GCHeapUtilities::GetGCHeap()->SetReservedVMLimit (sztMaxVirtualMemMB);
-    return (S_OK);
-}
-#endif // !defined(FEATURE_CORECLR)
-
-
diff --git a/src/vm/gdbjit.cpp b/src/vm/gdbjit.cpp
index e7049b5c2f..2ae7009888 100644
--- a/src/vm/gdbjit.cpp
+++ b/src/vm/gdbjit.cpp
@@ -137,6 +137,14 @@ GetTypeInfoFromTypeHandle(TypeHandle typeHandle, NotifyGdb::PTK_TypeInfoMap pTyp
                     info->members[1].m_member_type = arrayTypeInfo;
                 }
             }
+            // Ignore inheritance from System.Object and System.ValueType classes.
+            if (!typeHandle.IsValueType() &&
+                pMT->GetParentMethodTable() && pMT->GetParentMethodTable()->GetParentMethodTable())
+            {
+                static_cast<ClassTypeInfo*>(typeInfo)->m_parent =
+                    GetTypeInfoFromTypeHandle(typeHandle.GetParent(), pTypeMap);
+            }
+
             if (refTypeInfo)
                 return refTypeInfo;
             else
@@ -689,14 +697,7 @@ const unsigned char AbbrevTable[] = {
     4, DW_TAG_subprogram, DW_CHILDREN_yes,
         DW_AT_name, DW_FORM_strp, DW_AT_linkage_name, DW_FORM_strp, DW_AT_decl_file, DW_FORM_data1, DW_AT_decl_line, DW_FORM_data1,
         DW_AT_type, DW_FORM_ref4, DW_AT_external, DW_FORM_flag_present,
-        DW_AT_low_pc, DW_FORM_addr, DW_AT_high_pc,
-#if defined(_TARGET_AMD64_)
-        DW_FORM_data8,
-#elif defined(_TARGET_ARM_)
-        DW_FORM_data4,
-#else
-#error Unsupported platform!
-#endif
+        DW_AT_low_pc, DW_FORM_addr, DW_AT_high_pc, DW_FORM_size,
         DW_AT_frame_base, DW_FORM_exprloc, 0, 0,
 
     5, DW_TAG_variable, DW_CHILDREN_no,
@@ -725,14 +726,7 @@ const unsigned char AbbrevTable[] = {
     12, DW_TAG_subprogram, DW_CHILDREN_yes,
         DW_AT_name, DW_FORM_strp, DW_AT_linkage_name, DW_FORM_strp, DW_AT_decl_file, DW_FORM_data1, DW_AT_decl_line, DW_FORM_data1,
         DW_AT_type, DW_FORM_ref4, DW_AT_external, DW_FORM_flag_present,
-        DW_AT_low_pc, DW_FORM_addr, DW_AT_high_pc, 
-#if defined(_TARGET_AMD64_)
-        DW_FORM_data8,
-#elif defined(_TARGET_ARM_)
-        DW_FORM_data4,
-#else
-#error Unsupported platform!
-#endif
+        DW_AT_low_pc, DW_FORM_addr, DW_AT_high_pc, DW_FORM_size,
         DW_AT_frame_base, DW_FORM_exprloc, DW_AT_object_pointer, DW_FORM_ref4, 0, 0,
 
     13, DW_TAG_formal_parameter, DW_CHILDREN_no,
@@ -746,25 +740,14 @@ const unsigned char AbbrevTable[] = {
         0, 0,
 
     16, DW_TAG_try_block, DW_CHILDREN_no,
-        DW_AT_low_pc, DW_FORM_addr, DW_AT_high_pc,
-#if defined(_TARGET_AMD64_)
-        DW_FORM_data8,
-#elif defined(_TARGET_ARM_)
-        DW_FORM_data4,
-#else
-#error Unsupported platform!
-#endif
+        DW_AT_low_pc, DW_FORM_addr, DW_AT_high_pc, DW_FORM_size,
         0, 0,
 
     17, DW_TAG_catch_block, DW_CHILDREN_no,
-        DW_AT_low_pc, DW_FORM_addr, DW_AT_high_pc,
-#if defined(_TARGET_AMD64_)
-        DW_FORM_data8,
-#elif defined(_TARGET_ARM_)
-        DW_FORM_data4,
-#else
-#error Unsupported platform!
-#endif
+        DW_AT_low_pc, DW_FORM_addr, DW_AT_high_pc, DW_FORM_size,
+        0, 0,
+
+    18, DW_TAG_inheritance, DW_CHILDREN_no, DW_AT_type, DW_FORM_ref4, DW_AT_data_member_location, DW_FORM_data1,
         0, 0,
 
     0
@@ -796,13 +779,7 @@ struct __attribute__((packed)) DebugInfoCU
 struct __attribute__((packed)) DebugInfoTryCatchSub
 {
     uint8_t m_sub_abbrev;
-#if defined(_TARGET_AMD64_)
-    uint64_t m_sub_low_pc, m_sub_high_pc;
-#elif defined(_TARGET_ARM_)
-    uint32_t m_sub_low_pc, m_sub_high_pc;
-#else
-#error Unsupported platform!
-#endif
+    uintptr_t m_sub_low_pc, m_sub_high_pc;
 };
 
 struct __attribute__((packed)) DebugInfoSub
@@ -812,13 +789,7 @@ struct __attribute__((packed)) DebugInfoSub
     uint32_t m_linkage_name;
     uint8_t m_file, m_line;
     uint32_t m_sub_type;
-#if defined(_TARGET_AMD64_)
-    uint64_t m_sub_low_pc, m_sub_high_pc;
-#elif defined(_TARGET_ARM_)
-    uint32_t m_sub_low_pc, m_sub_high_pc;
-#else
-#error Unsupported platform!
-#endif
+    uintptr_t m_sub_low_pc, m_sub_high_pc;
     uint8_t m_sub_loc[2];
 };
 
@@ -911,6 +882,13 @@ struct __attribute__((packed)) DebugInfoClassType
     uint8_t m_byte_size;
 };
 
+struct __attribute__((packed)) DebugInfoInheritance
+{
+    uint8_t m_abbrev;
+    uint32_t m_type;
+    uint8_t m_data_member_location;
+};
+
 struct __attribute__((packed)) DebugInfoClassMember
 {
     uint8_t m_member_abbrev;
@@ -1021,8 +999,10 @@ void ByteTypeInfo::DumpStrings(char* ptr, int& offset)
 void ByteTypeInfo::DumpDebugInfo(char *ptr, int &offset)
 {
     m_typedef_info->DumpDebugInfo(ptr, offset);
-    m_type_offset = m_typedef_info->m_typedef_type_offset;
     PrimitiveTypeInfo::DumpDebugInfo(ptr, offset);
+    // Replace offset from real type to typedef
+    if (ptr != nullptr)
+        m_type_offset = m_typedef_info->m_typedef_type_offset;
 }
 
 void PrimitiveTypeInfo::DumpDebugInfo(char* ptr, int& offset)
@@ -1052,7 +1032,8 @@ void PrimitiveTypeInfo::DumpDebugInfo(char* ptr, int& offset)
 ClassTypeInfo::ClassTypeInfo(TypeHandle typeHandle, int num_members)
         : TypeInfoBase(typeHandle),
           m_num_members(num_members),
-          members(new TypeMember[num_members])
+          members(new TypeMember[num_members]),
+          m_parent(nullptr)
 {
 }
 
@@ -1392,6 +1373,11 @@ void ClassTypeInfo::DumpStrings(char* ptr, int& offset)
     {
         members[i].DumpStrings(ptr, offset);
     }
+
+    if (m_parent != nullptr)
+    {
+        m_parent->DumpStrings(ptr, offset);
+    }
 }
 
 void RefTypeInfo::DumpStrings(char* ptr, int& offset)
@@ -1428,6 +1414,20 @@ void ClassTypeInfo::DumpDebugInfo(char* ptr, int& offset)
     {
         return;
     }
+
+    if (m_parent != nullptr)
+    {
+        if (m_parent->m_type_offset == 0)
+        {
+            m_parent->DumpDebugInfo(ptr, offset);
+        }
+        else if (RefTypeInfo* m_p = dynamic_cast<RefTypeInfo*>(m_parent))
+        {
+            if (m_p->m_value_type->m_type_offset == 0)
+                m_p->m_value_type->DumpDebugInfo(ptr, offset);
+        }
+    }
+
     // make sure that types of all members are dumped
     for (int i = 0; i < m_num_members; ++i)
     {
@@ -1463,6 +1463,22 @@ void ClassTypeInfo::DumpDebugInfo(char* ptr, int& offset)
         }
     }
 
+    if (m_parent != nullptr)
+    {
+        if (ptr != nullptr)
+        {
+            DebugInfoInheritance buf;
+            buf.m_abbrev = 18;
+            if (RefTypeInfo *m_p = dynamic_cast<RefTypeInfo*>(m_parent))
+                buf.m_type = m_p->m_value_type->m_type_offset;
+            else
+                buf.m_type = m_parent->m_type_offset;
+            buf.m_data_member_location = 0;
+            memcpy(ptr + offset, &buf, sizeof(DebugInfoInheritance));
+        }
+        offset += sizeof(DebugInfoInheritance);
+    }
+
     // members terminator
     if (ptr != nullptr)
     {
@@ -1475,7 +1491,6 @@ void ClassTypeInfo::DumpDebugInfo(char* ptr, int& offset)
         if (members[i].m_static_member_address != 0)
             members[i].DumpStaticDebugInfo(ptr, offset);
     }
-
 }
 
 void ArrayTypeInfo::DumpDebugInfo(char* ptr, int& offset)
diff --git a/src/vm/gdbjit.h b/src/vm/gdbjit.h
index 19ece0180a..cafeac829d 100644
--- a/src/vm/gdbjit.h
+++ b/src/vm/gdbjit.h
@@ -24,12 +24,14 @@
     typedef Elf32_Ehdr  Elf_Ehdr;
     typedef Elf32_Shdr  Elf_Shdr;
     typedef Elf32_Sym   Elf_Sym;
+    const uint16_t DW_FORM_size = DW_FORM_data4;
 #define ADDRESS_SIZE 4    
 #elif defined(_TARGET_AMD64_) || defined(_TARGET_ARM64_)
     typedef Elf64_Ehdr  Elf_Ehdr;
     typedef Elf64_Shdr  Elf_Shdr;
     typedef Elf64_Sym   Elf_Sym;
-#define ADDRESS_SIZE 8    
+    const uint16_t DW_FORM_size = DW_FORM_data8;
+#define ADDRESS_SIZE 8
 #else
 #error "Target is not supported"
 #endif
@@ -245,6 +247,7 @@ public:
 
     int m_num_members;
     TypeMember* members;
+    TypeInfoBase* m_parent;
 };
 
 class TypeMember: public DwarfDumpable
@@ -468,6 +471,10 @@ public:
         m_sub_loc[0] = 1;
 #if defined(_TARGET_AMD64_)
         m_sub_loc[1] = DW_OP_reg6;
+#elif defined(_TARGET_X86_)
+        m_sub_loc[1] = DW_OP_reg5;
+#elif defined(_TARGET_ARM64_)
+        m_sub_loc[1] = DW_OP_reg29;
 #elif defined(_TARGET_ARM_)
         m_sub_loc[1] = DW_OP_reg11;
 #else
diff --git a/src/vm/hostexecutioncontext.cpp b/src/vm/hostexecutioncontext.cpp
deleted file mode 100644
index 2d9f16a6f1..0000000000
--- a/src/vm/hostexecutioncontext.cpp
+++ /dev/null
@@ -1,230 +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.
-
-
-
-#include "common.h"
-#ifdef FEATURE_CAS_POLICY
-
-#include "hostexecutioncontext.h"
-#include "corhost.h"
-#include "security.h"
-
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES
-IHostSecurityContext *HostExecutionContextManager::m_pRestrictedHostContext = NULL;
-#endif // FEATURE_INCLUDE_ALL_INTERFACES
-
-// initialize HostRestrictedContext
-void HostExecutionContextManager::InitializeRestrictedContext()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-	
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES
-	_ASSERTE(m_pRestrictedHostContext == NULL);
-	
-	IHostSecurityManager *pSM = CorHost2::GetHostSecurityManager();
-	if (pSM)
-	{
-        BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread());
-		pSM->GetSecurityContext(eRestrictedContext, &m_pRestrictedHostContext);
-        END_SO_TOLERANT_CODE_CALLING_HOST;
-	}	
-#endif // FEATURE_INCLUDE_ALL_INTERFACES
-}
-// notify the Host to SetRestrictedContext
-void HostExecutionContextManager::SetHostRestrictedContext()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-	
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES
-	if(m_pRestrictedHostContext != NULL)
-	{		
-        	IHostSecurityManager *pSM = CorHost2::GetHostSecurityManager();
-		if (pSM)
-		{
-            BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread());
-			pSM->SetSecurityContext(eRestrictedContext, m_pRestrictedHostContext);
-            END_SO_TOLERANT_CODE_CALLING_HOST;
-		}
-	}
-#endif // FEATURE_INCLUDE_ALL_INTERFACES
-}
-
-FCIMPL0(FC_BOOL_RET, HostExecutionContextManager::HostPresent)
-{
-    FCALL_CONTRACT;
-    
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES
-    FC_RETURN_BOOL(CorHost2::GetHostSecurityManager() != NULL);
-#else // !FEATURE_INCLUDE_ALL_INTERFACES
-    FC_RETURN_BOOL(FALSE);
-#endif // FEATURE_INCLUDE_ALL_INTERFACES
-}
-FCIMPLEND
-
-FCIMPL1(HRESULT, HostExecutionContextManager::ReleaseSecurityContext, LPVOID handle)
-{
-	CONTRACTL {
-        FCALL_CHECK;
-	 PRECONDITION(CheckPointer(handle));
-    	} CONTRACTL_END;
-
-	HELPER_METHOD_FRAME_BEGIN_RET_NOPOLL();
-	
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES
-	IHostSecurityManager *pSM = CorHost2::GetHostSecurityManager();
-	if (pSM)
-	{		
-		// get the IUnknown pointer from handle
-		IHostSecurityContext* pSecurityContext = (IHostSecurityContext*)handle;
-		// null out the IUnknown pointer in the handle
-		//hTokenSAFE->SetHandle((void*)NULL);
-		// release the IUnknown pointer if it is non null
-		if (pSecurityContext != NULL)
-		{
-			pSecurityContext->Release();			
-		}
-	}
-#endif // FEATURE_INCLUDE_ALL_INTERFACES
-	
-	HELPER_METHOD_FRAME_END();
-	return S_OK;
-
-}
-FCIMPLEND
-
-FCIMPL1(HRESULT, HostExecutionContextManager::CaptureSecurityContext, SafeHandle* hTokenUNSAFE)
-{
-	CONTRACTL {
-        FCALL_CHECK;
-	 PRECONDITION(CheckPointer(hTokenUNSAFE));
-    	} CONTRACTL_END;
-	
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES
-	IHostSecurityContext* pCurrentHostSecurityContext = NULL;
-	IHostSecurityContext* pCapturedSecurityContext = NULL;
-#endif // FEATURE_INCLUDE_ALL_INTERFACES
-
-	HRESULT hr = S_OK;
-	SAFEHANDLE hTokenSAFE = (SAFEHANDLE) hTokenUNSAFE;
-	HELPER_METHOD_FRAME_BEGIN_RET_1(hTokenSAFE);
-	
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES
-	IHostSecurityManager *pSM = CorHost2::GetHostSecurityManager();
-	if (pSM)
-	{
-        BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread());
-		hr = pSM->GetSecurityContext(eCurrentContext, &pCurrentHostSecurityContext);
-        END_SO_TOLERANT_CODE_CALLING_HOST;
-		if (hr == S_OK)
-		{
-			if(pCurrentHostSecurityContext != NULL)
-			{				
-                BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread());
-				hr = pCurrentHostSecurityContext->Capture(&pCapturedSecurityContext);				
-                END_SO_TOLERANT_CODE_CALLING_HOST;
-				hTokenSAFE->SetHandle((void*)pCapturedSecurityContext);
-				SafeRelease(pCurrentHostSecurityContext);
-			}			
-		}
-	}
-#endif // FEATURE_INCLUDE_ALL_INTERFACES
-	
-	if (FAILED(hr))
-		COMPlusThrowHR(hr);	
-	
-	HELPER_METHOD_FRAME_END();
-	return hr;
-
-}
-FCIMPLEND
-
-FCIMPL2(HRESULT, HostExecutionContextManager::CloneSecurityContext, SafeHandle* hTokenUNSAFE, SafeHandle* hTokenClonedUNSAFE)
-{
-	CONTRACTL {
-        FCALL_CHECK;
-	PRECONDITION(CheckPointer(hTokenUNSAFE));
-	PRECONDITION(CheckPointer(hTokenClonedUNSAFE));
-    	} CONTRACTL_END;
-
-	SAFEHANDLE hTokenClonedSAFE = (SAFEHANDLE) hTokenClonedUNSAFE;
-	SAFEHANDLE hTokenSAFE = (SAFEHANDLE)hTokenUNSAFE;
-	
-	HELPER_METHOD_FRAME_BEGIN_RET_2(hTokenSAFE, hTokenClonedSAFE);
-
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES
-	IHostSecurityManager *pSM = CorHost2::GetHostSecurityManager();
-	if (pSM)
-	{		
-		IHostSecurityContext* pSecurityContext = (IHostSecurityContext*)hTokenSAFE->GetHandle();
-		if (pSecurityContext != NULL)
-		{
-			pSecurityContext->AddRef();
-			hTokenClonedSAFE->SetHandle((void*)pSecurityContext);
-		}
-	}
-#endif // FEATURE_INCLUDE_ALL_INTERFACES
-	
-	HELPER_METHOD_FRAME_END();
-	return S_OK;
-}
-FCIMPLEND
-
-FCIMPL3(HRESULT, HostExecutionContextManager::SetSecurityContext, SafeHandle* hTokenUNSAFE, CLR_BOOL fReturnPrevious, SafeHandle* hTokenPreviousUNSAFE)
-{
-	CONTRACTL {
-        FCALL_CHECK;
-	 PRECONDITION(CheckPointer(hTokenUNSAFE));
-    	} CONTRACTL_END;
-
-	HRESULT hr = S_OK;
-	
-	SAFEHANDLE hTokenPreviousSAFE = (SAFEHANDLE) hTokenPreviousUNSAFE;
-	SAFEHANDLE hTokenSAFE = (SAFEHANDLE) hTokenUNSAFE;
-	
-	HELPER_METHOD_FRAME_BEGIN_RET_2(hTokenSAFE, hTokenPreviousSAFE);
-
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES
-	IHostSecurityManager *pSM = CorHost2::GetHostSecurityManager();
-	if (pSM)
-	{
-		if (fReturnPrevious)
-		{
-			IHostSecurityContext* pPreviousHostSecurityContext = NULL;
-            BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread());
-			hr = pSM->GetSecurityContext(eCurrentContext, &pPreviousHostSecurityContext);
-            END_SO_TOLERANT_CODE_CALLING_HOST;
-			if (FAILED(hr))
-				COMPlusThrowHR(hr);
-			// store the previous host context in the safe handle
-			hTokenPreviousSAFE->SetHandle((void*)pPreviousHostSecurityContext);
-		}
-		
-        BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread());
-		hr = pSM->SetSecurityContext(eCurrentContext, (IHostSecurityContext*)hTokenSAFE->GetHandle());
-        END_SO_TOLERANT_CODE_CALLING_HOST;
-		if (FAILED(hr))
-			COMPlusThrowHR(hr);
-	}
-#endif // FEATURE_INCLUDE_ALL_INTERFACES
-
-	HELPER_METHOD_FRAME_END();
-	return hr;
-}
-FCIMPLEND
-#endif // #ifdef FEATURE_CAS_POLICY
-
diff --git a/src/vm/hostexecutioncontext.h b/src/vm/hostexecutioncontext.h
deleted file mode 100644
index 721c8953ad..0000000000
--- a/src/vm/hostexecutioncontext.h
+++ /dev/null
@@ -1,29 +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.
-
-
-
-#ifndef __hostexecutioncontext_h__
-#define __hostexecutioncontext_h__
-
-#ifdef FEATURE_CAS_POLICY
-
-class HostExecutionContextManager
-{
-public:
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES
-    static IHostSecurityContext*  m_pRestrictedHostContext;
-#endif // FEATURE_INCLUDE_ALL_INTERFACES
-    static void InitializeRestrictedContext();
-    static void SetHostRestrictedContext();
-    	
-    static FCDECL0(FC_BOOL_RET, HostPresent);	
-    static FCDECL1(HRESULT, ReleaseSecurityContext, LPVOID handle);
-    static FCDECL1(HRESULT, CaptureSecurityContext, SafeHandle* hTokenUNSAFE);	
-    static FCDECL2(HRESULT, CloneSecurityContext, SafeHandle* hTokenUNSAFE, SafeHandle* hTokenClonedUNSAFE);	
-    static FCDECL3(HRESULT, SetSecurityContext, SafeHandle* hTokenUNSAFE, CLR_BOOL fReturnPrevious, SafeHandle* hTokenPreviousUNSAFE);	    
-};
-#endif // #ifdef FEATURE_CAS_POLICY
-#endif // __hostexecutioncontext_h__
-
diff --git a/src/vm/hosting.cpp b/src/vm/hosting.cpp
index 4dd6a59729..7a3f636add 100644
--- a/src/vm/hosting.cpp
+++ b/src/vm/hosting.cpp
@@ -14,10 +14,6 @@
 #include "corhost.h"
 #include "threads.h"
 
-#if defined(FEATURE_CLICKONCE)
-#include "isolationpriv.h"
-#include "shlwapi.h"
-#endif
 
 #define countof(x) (sizeof(x) / sizeof(x[0]))
 
@@ -197,15 +193,6 @@ BOOL GlobalAllocStore::m_Disabled = FALSE;
 
 #endif
 
-#if defined(_DEBUG) && !defined(FEATURE_CORECLR)
-// The helper thread can't call regular new / delete b/c of interop-debugging deadlocks.
-// It must use the (InteropSafe) heap from debugger.h, you also can't allocate normally
-// when we have any other thread hard-suspended.
-
-// Telesto doesn't support interop-debugging, so this won't be an issue.
-
-void AssertAllocationAllowed();
-#endif
 
 
 HANDLE g_ExecutableHeapHandle = NULL;
@@ -225,9 +212,6 @@ LPVOID EEVirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, D
             return NULL;
 #endif
 
-#if defined(_DEBUG) && !defined(FEATURE_CORECLR)
-    AssertAllocationAllowed();
-#endif
 
 #ifdef _DEBUG
         if (g_fEEStarted) {
@@ -570,9 +554,6 @@ LPVOID EEHeapAlloc(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes)
         return NULL;
 #endif
 
-#if defined(_DEBUG) && !defined(FEATURE_CORECLR)
-    AssertAllocationAllowed();
-#endif
 
 #ifdef FEATURE_INCLUDE_ALL_INTERFACES
     IHostMalloc *pHM = CorHost2::GetHostMalloc();
@@ -644,9 +625,6 @@ BOOL EEHeapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem)
     // @todo -  Need a backout validation here.
     CONTRACT_VIOLATION(SOToleranceViolation);
 
-#if defined(_DEBUG) && !defined(FEATURE_CORECLR)
-    AssertAllocationAllowed();
-#endif
 
     BOOL retVal = FALSE;
 
@@ -745,7 +723,6 @@ HANDLE EEGetProcessExecutableHeap() {
     STATIC_CONTRACT_NOTHROW;
     STATIC_CONTRACT_GC_NOTRIGGER;
 
-#ifdef FEATURE_CORECLR
 
 #ifndef FEATURE_PAL
 
@@ -780,18 +757,6 @@ HANDLE EEGetProcessExecutableHeap() {
     UNREACHABLE();
 #endif // !FEATURE_PAL
 
-#else // FEATURE_CORECLR
-
-    //
-    // Use process executable heap created by the shim
-    //
-    if (g_ExecutableHeapHandle == NULL)
-    {
-        extern HANDLE GetProcessExecutableHeap();
-        g_ExecutableHeapHandle = GetProcessExecutableHeap();
-    }
-
-#endif // FEATURE_CORECLR
 
     // TODO: implement hosted executable heap
     return g_ExecutableHeapHandle;
@@ -1155,751 +1120,3 @@ BOOL EEAllocationDisallowed()
 #endif
 }
 
-#ifdef FEATURE_CLICKONCE
-
-HRESULT GetApplicationManifest (LPCWSTR pwzAppFullName,
-                                DWORD dwManifestPaths,
-                                LPCWSTR *ppwzManifestPaths,
-                                __out_z __deref_out_opt LPWSTR *ppwzApplicationFolderPath,
-				    __out_z __deref_out_opt LPWSTR *ppszKeyForm,                                                                
-                                ICMS **ppApplicationManifest)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pwzAppFullName));
-        PRECONDITION(CheckPointer(ppwzManifestPaths, NULL_OK));
-        PRECONDITION(CheckPointer(ppApplicationManifest));
-    } CONTRACTL_END;
-
-    ReleaseHolder<IStore> pStore(NULL);
-    ReleaseHolder<IAppIdAuthority> pAppIdAuth(NULL);
-    ReleaseHolder<IDefinitionAppId> pDefinitionIdentity(NULL);
-    ReleaseHolder<IEnumDefinitionIdentity> pEnumDefinitionIdentity(NULL);
-    ReleaseHolder<IDefinitionIdentity> pDeploymentDefinitionIdentity(NULL);
-    ReleaseHolder<IDefinitionIdentity> pApplicationDefinitionIdentity(NULL);
-    ReleaseHolder<IDefinitionIdentity> pSubscriptionIdentity(NULL);	
-    ReleaseHolder<IDefinitionAppId> pSubscriptionAppId(NULL);
-
-    ReleaseHolder<IUnknown> TempFetched(NULL);
-    HRESULT hr = S_OK;
-
-    // Maybe this is not an installed application. Grab the manifest path if specified and parse the manifest.
-    if (dwManifestPaths > 0) {
-        if (dwManifestPaths < 2)
-            goto ErrExit;
-
-        hr = ParseManifest(ppwzManifestPaths[1], NULL, __uuidof(ICMS), &TempFetched);
-        if (TempFetched == NULL)
-        {
-            goto ErrExit;
-        }
-
-        IfFailGo(TempFetched->QueryInterface(__uuidof(ICMS), (void**) ppApplicationManifest));
-        TempFetched.Release();
-
-        // Set the application directory to be the location of the application manifest.
-        if (ppwzApplicationFolderPath) {
-            LPCWSTR pszSlash;
-            if (((pszSlash = wcsrchr(ppwzManifestPaths[1], W('\\'))) != NULL) || ((pszSlash = wcsrchr(ppwzManifestPaths[1], W('/'))) != NULL)) {
-                DWORD cchDirectory = (DWORD) (pszSlash - ppwzManifestPaths[1] + 1);
-                *ppwzApplicationFolderPath = (LPWSTR) CoTaskMemAlloc(2 * (cchDirectory + 1));
-
-                if (*ppwzApplicationFolderPath == NULL)
-                {
-                    hr = E_OUTOFMEMORY;
-                    goto ErrExit;
-                }
-
-                memcpy(*ppwzApplicationFolderPath, ppwzManifestPaths[1], 2 * cchDirectory);
-                (*ppwzApplicationFolderPath)[cchDirectory] = W('\0');
-            }
-        }
-        goto ErrExit;
-    }
-
-    // Get the user store.
-    IfFailGo(GetUserStore(0, NULL, __uuidof(IStore), &pStore));
-
-    // Get the AppId authority
-    IfFailGo(GetAppIdAuthority(&pAppIdAuth));
-
-    // Get the IDefintionIdentity of the application full name passed in as an argument.
-    IfFailGo(pAppIdAuth->TextToDefinition(0, pwzAppFullName, &pDefinitionIdentity));
-
-    // Get the ICMS object representing the application manifest.
-    IfFailGo(pDefinitionIdentity->EnumAppPath(&pEnumDefinitionIdentity));
-    IfFailGo(pEnumDefinitionIdentity->Reset());
-    ULONG numItems = 0;
-    IfFailGo(pEnumDefinitionIdentity->Next(1, &pDeploymentDefinitionIdentity, &numItems));
-    if (numItems < 1) {
-        hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
-        goto ErrExit;
-    }
-    IfFailGo(pEnumDefinitionIdentity->Next(1, &pApplicationDefinitionIdentity, &numItems));
-    if (numItems < 1) {
-        hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
-        goto ErrExit;
-    }
-
-   if (ppszKeyForm){
-	    // Create subscription identity from deployment identity.
-	    IfFailGo(pDeploymentDefinitionIdentity->Clone(0,NULL,&pSubscriptionIdentity));
-	    IfFailGo(pSubscriptionIdentity->SetAttribute(NULL,W("version"),NULL));
-		
-	    // Create the subscription app id.
-	    IfFailGo(pAppIdAuth->CreateDefinition(&pSubscriptionAppId));
-		
-	    IDefinitionIdentity *defIdentityArray[1];
-	    defIdentityArray[0] = pSubscriptionIdentity;	
-
-	    IfFailGo(pSubscriptionAppId->SetAppPath(1,defIdentityArray));   
-	    IfFailGo(pAppIdAuth->GenerateDefinitionKey(0,pSubscriptionAppId,ppszKeyForm));
-   }  
-	
-    hr = pStore->GetAssemblyInformation(0, pApplicationDefinitionIdentity, __uuidof(ICMS), &TempFetched);
-    if (SUCCEEDED(hr)) {
-        if (ppwzApplicationFolderPath) {
-            // Get the application folder path.
-            LPVOID cookie = NULL;
-            IfFailGo(pStore->LockApplicationPath(0, pDefinitionIdentity, &cookie, ppwzApplicationFolderPath));
-            IfFailGo(pStore->ReleaseApplicationPath(cookie));
-        }
-    }
-    IfFailGo(TempFetched->QueryInterface(__uuidof(ICMS), (void**) ppApplicationManifest));
-    TempFetched.Release();
-
-ErrExit:
-    pStore.Release();
-    pAppIdAuth.Release();
-    pDefinitionIdentity.Release();
-    pEnumDefinitionIdentity.Release();
-    pDeploymentDefinitionIdentity.Release();
-    pApplicationDefinitionIdentity.Release();
-    pSubscriptionIdentity.Release();
-    pSubscriptionAppId.Release();	
-
-    return hr;
-}
-
-BOOL DoesMarkOfTheWebExist (LPCWSTR pwzAppFullName)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pwzAppFullName));
-    } CONTRACTL_END;
-
-    HANDLE alternateStreamHandle = INVALID_HANDLE_VALUE;
-
-    StackSString alternateStreamPath(pwzAppFullName);
-    alternateStreamPath.Append(W(":Zone.Identifier"));
-
-    // Try to open alternate file stream
-    alternateStreamHandle = WszCreateFile(
-                    alternateStreamPath.GetUnicode(),
-                    GENERIC_READ,
-                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                    NULL,
-                    OPEN_EXISTING,
-                    0,
-                    NULL);
-
-    if (INVALID_HANDLE_VALUE != alternateStreamHandle)
-    {
-        CloseHandle(alternateStreamHandle);
-
-        // We only check if MOTW (alternate stream) is present,
-        // no matter what the zone is.
-        return TRUE;
-    }
-
-    return FALSE;
-}
-
-HRESULT GetApplicationEntryPointInfo (LPCWSTR pwzAppFullName,
-                                      DWORD dwManifestPaths,
-                                      LPCWSTR *ppwzManifestPaths,
-                                      __out_z __deref_out_opt LPWSTR *ppwzApplicationFolderPath,
-                                      LPCWSTR *ppwzCodeBase,
-                                      LPCWSTR *ppwzParameters,
-                                      __out_z __deref_out_opt LPWSTR *ppwzProcessorArch,
-                                      __out_z __deref_out_opt LPWSTR *ppwzAppIdKeyForm)                                      
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pwzAppFullName));
-        PRECONDITION(CheckPointer(ppwzManifestPaths, NULL_OK));
-        PRECONDITION(CheckPointer(ppwzCodeBase, NULL_OK));
-        PRECONDITION(CheckPointer(ppwzParameters, NULL_OK));
-        PRECONDITION(CheckPointer(ppwzProcessorArch, NULL_OK));
-    } CONTRACTL_END;
-
-    ReleaseHolder<ICMS> pApplicationManifest(NULL);
-    ReleaseHolder<ISection> pEntrySection(NULL);
-    ReleaseHolder<IEnumUnknown> pEntryEnum(NULL);
-    ReleaseHolder<IEntryPointEntry> pEntry(NULL);
-    ReleaseHolder<IReferenceIdentity> pReferenceId(NULL);
-    ReleaseHolder<ISectionWithStringKey> pNamedRefSection(NULL);
-    ReleaseHolder<ISectionWithReferenceIdentityKey> pRefSection(NULL);
-    ReleaseHolder<IAssemblyReferenceEntry> pRefEntry(NULL);
-    ReleaseHolder<IAssemblyReferenceDependentAssemblyEntry> pDependentAssemblyEntry(NULL);
-    CoTaskMemHolder<WCHAR> pwszDependencyName = NULL;
-
-    ReleaseHolder<IUnknown> TempFetched(NULL);
-    ReleaseHolder<ISection> TempFetchedSection(NULL);
-    HRESULT hr = S_OK;
-
-    // Get the ICMS object representing the application manifest.
-    IfFailGo(GetApplicationManifest(pwzAppFullName, dwManifestPaths, ppwzManifestPaths, ppwzApplicationFolderPath, ppwzAppIdKeyForm,&pApplicationManifest));
-
-    // Get the app entry point section.
-    IfFailGo(pApplicationManifest->get_EntryPointSection(&pEntrySection));
-    if (pEntrySection == NULL) {
-        hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
-        goto ErrExit;
-    }
-
-    // Get the entry point enum.
-    IfFailGo(pEntrySection->get__NewEnum(&TempFetched));
-    IfFailGo(TempFetched->QueryInterface(__uuidof(IEnumUnknown), &pEntryEnum));
-    TempFetched.Release();
-
-    // Get the first entry point.
-    ULONG numItems = 0;
-    IfFailGo(pEntryEnum->Next(1, &TempFetched, &numItems));
-    if (numItems < 1) {
-        hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
-        goto ErrExit;
-    }
-    IfFailGo(TempFetched->QueryInterface(__uuidof(IEntryPointEntry), &pEntry));
-    TempFetched.Release();
-
-    // We support both name and identity based entry points.
-    IfFailGo(pEntry->get_Identity(&pReferenceId));
-    if (pReferenceId == NULL) {
-         hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
-         goto ErrExit;
-     }
-
-    // Get the assembly reference section.
-    IfFailGo(pApplicationManifest->get_AssemblyReferenceSection(&TempFetchedSection));
-    IfFailGo(TempFetchedSection->QueryInterface(__uuidof(ISectionWithReferenceIdentityKey), &pRefSection));
-    TempFetchedSection.Release();    
-
-#ifdef CLICKONCE_LONGHORN_RELATED 
-    //
-    // If a reference assembly matching entry point does not exist, use the codebase
-    // of command line file.
-    // 
-    if (FAILED(pRefSection->Lookup(pReferenceId, &TempFetched)))
-    {
-        if (ppwzCodeBase) {
-            IfFailGo(pEntry->get_CommandLine_File(ppwzCodeBase));
-        }
-    }
-    else
-#endif
-    {
-        // Lookup the assembly reference entry.
-        IfFailGo(pRefSection->Lookup(pReferenceId, &TempFetched));
-        IfFailGo(TempFetched->QueryInterface(__uuidof(IAssemblyReferenceEntry), &pRefEntry));
-        TempFetched.Release();
-
-        // Get the assembly codebase. Codebase may either come from <dependentAssembly> or <installFrom>.
-        // In a valid reference there should always be a <dependentAssembly> section.
-        IfFailGo(pRefEntry->get_DependentAssembly(&pDependentAssemblyEntry));
-
-        if (ppwzCodeBase) {
-            IfFailGo(pDependentAssemblyEntry->get_Codebase(ppwzCodeBase));
-        }
-    }
-
-    // Get the parameters
-    if (ppwzParameters)
-        IfFailGo(pEntry->get_CommandLine_Parameters(ppwzParameters));
-
-    // Get the processor architecture requested in the app manifest
-    if (ppwzProcessorArch)
-        IfFailGo(pReferenceId->GetAttribute(NULL, W("processorArchitecture"), ppwzProcessorArch));
-
-ErrExit:
-    pApplicationManifest.Release();
-    pEntrySection.Release();
-    pEntryEnum.Release();
-    pEntry.Release();
-    pReferenceId.Release();
-    pNamedRefSection.Release();
-    pRefSection.Release();
-    pRefEntry.Release();
-    pDependentAssemblyEntry.Release();
-    pwszDependencyName.Release();
-
-    return hr;
-}
-
-//
-// Export used in the ClickOnce installer for launching manifest-based applications.
-//
-
-typedef struct _tagNameMap {
-    LPWSTR  pwszProcessorArch;
-    DWORD   dwRuntimeInfoFlag;
-} NAME_MAP;
-
-DWORD g_DfSvcSpinLock = 0;
-void EnterDfSvcSpinLock () {
-    WRAPPER_NO_CONTRACT;
-    while (1) {
-        if (InterlockedExchange ((LPLONG)&g_DfSvcSpinLock, 1) == 1)
-            ClrSleepEx (5, FALSE);
-        else
-            return;
-    }
-}
-
-void LeaveDfSvcSpinLock () {
-    InterlockedExchange ((LPLONG)&g_DfSvcSpinLock, 0);
-}
-
-//
-// ThreadProc used by SHCreateProcess call - to activate ClickOnce app with ShellExecuteEx
-// ShellExecuteEx can only be used from STA threads - we are creating our own STA thread
-//
-DWORD CorLaunchApplication_ThreadProc(void*)
-{
-    return 0;
-}
-
-//
-// This callback is executed as the sync-callback on SHCreateThread.
-// SHCreateThread does not return till this callback returns.
-//
-DWORD CorLaunchApplication_Callback(void* pv)
-{
-    SHELLEXECUTEINFO *pSei = static_cast<SHELLEXECUTEINFO *>(pv);
-    IUnknown* pDummyUnknown;
-    CreateStreamOnHGlobal(NULL, TRUE, (LPSTREAM*) &pDummyUnknown);
-    
-    if (RunningOnWin8())
-    {
-        // When SEE_MASK_FLAG_HINST_IS_SITE is specified SHELLEXECUTEINFO.hInstApp is used as an
-        // _In_ parameter and specifies a IUnknown* to be used as a site pointer. The site pointer
-        // is used to provide services to shell execute, the handler binding process and the verb handlers
-        // once they are invoked.
-        //
-        // SEE_MASK_HINST_IS_SITE is available on Win8+
-        // Defining it locally in Win8-conditioned code
-        //
-        const ULONG SEE_MASK_HINST_IS_SITE = 0x08000000;
-
-        pSei->fMask = SEE_MASK_HINST_IS_SITE;
-        pSei->hInstApp = reinterpret_cast<HINSTANCE>(pDummyUnknown);
-    }
-
-    WszShellExecuteEx(pSei);
-    // We ignore all errors from ShellExecute.
-    //
-    // This may change with Win8:783168
-
-    if (pDummyUnknown)
-    {
-        pDummyUnknown->Release();
-    }
-
-    return 0;
-}
-
-//-----------------------------------------------------------------------------
-// WszSHCreateThread
-//
-// @func calls SHCreateThread with the provided parameters
-//
-// @rdesc Result
-//-----------------------------------------------------------------------------------
-HRESULT WszSHCreateThread(
-    LPTHREAD_START_ROUTINE pfnThreadProc,
-    void *pData,
-    SHCT_FLAGS dwFlags,
-    LPTHREAD_START_ROUTINE pfnCallback
-)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        MODE_PREEMPTIVE;
-        INJECT_FAULT(return E_OUTOFMEMORY;);
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-    HMODULE _hmodShlwapi = 0;
-
-    typedef BOOL (*PFNSHCREATETHREAD) (
-              __in      LPTHREAD_START_ROUTINE pfnThreadProc,
-              __in_opt  void *pData,
-              __in      SHCT_FLAGS dwFlags,
-              __in_opt  LPTHREAD_START_ROUTINE pfnCallback
-            );
-
-    static PFNSHCREATETHREAD pfnW = NULL;
-    if (NULL == pfnW)
-    {
-        _hmodShlwapi = CLRLoadLibrary(W("shlwapi.dll"));
-    
-        if (_hmodShlwapi)
-        {
-            pfnW = (PFNSHCREATETHREAD)GetProcAddress(_hmodShlwapi, "SHCreateThread");
-        }
-    }
-
-    if (pfnW)
-    {
-        BOOL bRet = pfnW(pfnThreadProc, pData, dwFlags, pfnCallback);
-
-        if (!bRet)
-        {
-            hr = HRESULT_FROM_WIN32(GetLastError());
-        }
-    }
-    else
-    {
-        hr = HRESULT_FROM_WIN32(GetLastError());
-    }
-    
-    // NOTE: We leak the module handles and let the OS gather them at process shutdown.
-
-    return hr;
-}
-
-STDAPI CorLaunchApplication (HOST_TYPE               dwClickOnceHost,
-                             LPCWSTR                 pwzAppFullName,
-                             DWORD                   dwManifestPaths,
-                             LPCWSTR                 *ppwzManifestPaths,
-                             DWORD                   dwActivationData,
-                             LPCWSTR                 *ppwzActivationData,
-                             LPPROCESS_INFORMATION   lpProcessInformation)
-{
-    // HostType is encoded in the lowest 2 bits.
-    unsigned hostType = dwClickOnceHost & MASK_HOSTTYPE;
-	 
-    // NoPinnableBit is the highest bit.
-    unsigned notPinnableBit = dwClickOnceHost & MASK_NOTPINNABLE;	
-
-    // DontShowInstallDialog bit
-    unsigned dontShowInstallDialog = dwClickOnceHost & MASK_DONT_SHOW_INSTALL_DIALOG;
-
-    bool bUseShellExecute = false;
-	 
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-        ENTRY_POINT;
-        PRECONDITION(CheckPointer(pwzAppFullName, NULL_OK));
-        PRECONDITION(CheckPointer(ppwzManifestPaths, NULL_OK));
-        PRECONDITION(CheckPointer(ppwzActivationData, NULL_OK));
-        PRECONDITION(hostType == HOST_TYPE_DEFAULT || hostType == HOST_TYPE_APPLAUNCH || hostType == HOST_TYPE_CORFLAG);
-        PRECONDITION(CheckPointer(lpProcessInformation));
-    } CONTRACTL_END;
-
-
-    if (pwzAppFullName == NULL)
-        return E_POINTER;
-
-    HRESULT hr = S_OK;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    LPVOID lpEnvironment = NULL;
-    EX_TRY
-    {
-        StackSString commandLine(StackSString::Ascii, "\""); // put quotes around path to the command line.
-        StackSString appEntryPath(W("")); // the path to the entry point(the exe to run) of the application, initialized to empty string
-        NewArrayHolder<WCHAR> wszDirectory(NULL);
-        NewArrayHolder<WCHAR> wszVersion(NULL);
-        CoTaskMemHolder<WCHAR> pwszApplicationFolderPath(NULL);
-        CoTaskMemHolder<WCHAR> pwszAppIdKeyForm(NULL);			
-        CoTaskMemHolder<WCHAR> pwszCodebase(NULL);
-        CoTaskMemHolder<WCHAR> pwszParameters(NULL);
-        CoTaskMemHolder<WCHAR> pwszProcessorArch(NULL);
-
-        hr = GetApplicationEntryPointInfo(pwzAppFullName, dwManifestPaths, ppwzManifestPaths, (LPWSTR*) (void*) &pwszApplicationFolderPath, (LPCWSTR*) (void*) &pwszCodebase, (LPCWSTR*) (void*) &pwszParameters, (LPWSTR*) (void*) &pwszProcessorArch,(LPWSTR*) (void*) &pwszAppIdKeyForm);
-
-        if (SUCCEEDED(hr)) {
-            // construct the application Entry Path
-            if (pwszApplicationFolderPath != NULL) {
-                appEntryPath.Append(pwszApplicationFolderPath);
-                SString::CIterator i = appEntryPath.End()-1;
-                if (i[0] != '\\')
-                    appEntryPath.Append(W("\\"));
-            }
-            appEntryPath.Append(pwszCodebase);
-        
-        if (hostType == HOST_TYPE_CORFLAG) {
-                // construct the command line
-                commandLine.Append(appEntryPath);
-                commandLine.Append(W("\""));
-
-                if (RunningOnWin8() &&
-                    DoesMarkOfTheWebExist(appEntryPath.GetUnicode()))
-                {
-                    // We will use ShellExecute for any zone set in MOTW stream.
-                    // ShellExecute would call Application Reputation API if the zone is the one
-                    // that requires AppRep validation. At the moment, they would do this for Internet Zone only,
-                    // but there are talks about changing the behavior to include some of the other zones.
-                    // By not checking the zone here we leave to AppRep/ShellExecute to decide,
-                    // which is exactly what we want.
-                    bUseShellExecute = true;
-                }
-                else
-                {
-                    if (pwszParameters != NULL) {
-                        commandLine.Append(W(" "));
-                        commandLine.Append(pwszParameters);
-                    }
-                }
-
-                // now construct the environment variables
-                EnterDfSvcSpinLock();
-                WszSetEnvironmentVariable(g_pwzClickOnceEnv_FullName, pwzAppFullName);
-
-                if (dwManifestPaths > 0 && ppwzManifestPaths) {
-                    for (DWORD i=0; i<dwManifestPaths; i++) {
-                        StackSString manifestFile(g_pwzClickOnceEnv_Manifest);
-                        StackSString buf;
-                        COUNT_T size = buf.GetUnicodeAllocation();
-                        _itow_s(i, buf.OpenUnicodeBuffer(size), size, 10);
-                        buf.CloseBuffer();
-                        manifestFile.Append(buf);
-                        WszSetEnvironmentVariable(manifestFile.GetUnicode(), *ppwzManifestPaths++);
-                    }
-                }
-
-                if (dwActivationData > 0 && ppwzActivationData) {
-                    for (DWORD i=0; i<dwActivationData; i++) {
-                        StackSString activationData(g_pwzClickOnceEnv_Parameter);
-                        StackSString buf;
-                        COUNT_T size = buf.GetUnicodeAllocation();
-                        _itow_s(i, buf.OpenUnicodeBuffer(size), size, 10);
-                        buf.CloseBuffer();
-                        activationData.Append(buf);
-                        WszSetEnvironmentVariable(activationData.GetUnicode(), *ppwzActivationData++);
-                    }
-                }
-
-#undef GetEnvironmentStrings
-#undef GetEnvironmentStringsW
-                lpEnvironment = (LPVOID) GetEnvironmentStringsW();
-#define GetEnvironmentStringsW() Use_WszGetEnvironmentStrings()
-#define GetEnvironmentStrings() Use_WszGetEnvironmentStrings()
-            } else {
-                // application folder is required to determine appEntryPath for framework version selection, 
-                // but should not be used as working directory for partial trust apps
-                pwszApplicationFolderPath.Clear();
-
-                // find the architecture from manifest and required version from the application itself
-                static const NAME_MAP g_NameMapArray[] = {
-                    {W("x86"), RUNTIME_INFO_REQUEST_X86},
-                    {W("ia64"), RUNTIME_INFO_REQUEST_IA64},
-                    {W("amd64"), RUNTIME_INFO_REQUEST_AMD64},
-                };
-
-                DWORD dwRuntimeInfoFlags = RUNTIME_INFO_UPGRADE_VERSION |
-                                           RUNTIME_INFO_CONSIDER_POST_2_0 |
-                                           RUNTIME_INFO_EMULATE_EXE_LAUNCH;
-
-                // We want to control whether shim should show install dialog or not,
-				// and not leave this decision to the Shim.
-				if (dontShowInstallDialog > 0)
-                {
-                    dwRuntimeInfoFlags |= RUNTIME_INFO_DONT_SHOW_ERROR_DIALOG;
-                }
-                else
-                {
-                    // show even if SEM_CRITICAL is set
-                    dwRuntimeInfoFlags |= METAHOST_POLICY_IGNORE_ERROR_MODE;
-                }
-
-                if (pwszProcessorArch) {
-                    for (DWORD index = 0; index < sizeof(g_NameMapArray) / sizeof(NAME_MAP); index++) {
-                        if (SString::_wcsicmp(g_NameMapArray[index].pwszProcessorArch, pwszProcessorArch) == 0) {
-                            dwRuntimeInfoFlags |= g_NameMapArray[index].dwRuntimeInfoFlag;
-                            break;
-                        }
-                    }
-                }
-                wszDirectory = new WCHAR[MAX_LONGPATH + 1];
-                wszVersion = new WCHAR[MAX_PATH_FNAME + 1];
-                wszVersion[0] = 0; // we don't prefer any version
-                DWORD cchBuffer = MAX_LONGPATH;
-
-                // Use GetRequestedRuntimeInfo because MetaHost APIs do not yet support architecture arguments.
-                // Calls to GetRequestedRuntimeInfo() will goes to a local copy inside clr.dll, 
-                // have to call mscoree::GetRequestedRuntimeInfo.
-                typedef HRESULT (*PFNGetRequestedRuntimeInfo)(LPCWSTR pExe,
-                                                              LPCWSTR pwszVersion,
-                                                              LPCWSTR pConfigurationFile,
-                                                              DWORD startupFlags,
-                                                              DWORD runtimeInfoFlags,
-                                                              LPWSTR pDirectory,
-                                                              DWORD dwDirectory,
-                                                              DWORD *dwDirectoryLength,
-                                                              LPWSTR pVersion,
-                                                              DWORD cchBuffer,
-                                                              DWORD* dwlength);
-                PFNGetRequestedRuntimeInfo pfnGetRequestedRuntimeInfo = NULL;
-                HMODULE hMscoree = GetModuleHandleW( W("mscoree.dll") );  // mscoree.dll should have already been loaded
-                if( hMscoree != NULL )
-                    pfnGetRequestedRuntimeInfo = (PFNGetRequestedRuntimeInfo)GetProcAddress( hMscoree, "GetRequestedRuntimeInfo" );
-                if( pfnGetRequestedRuntimeInfo == NULL )
-                        pfnGetRequestedRuntimeInfo = GetRequestedRuntimeInfoInternal;  // in case mscoree has not been loaded, use the built in function
-                hr = pfnGetRequestedRuntimeInfo(appEntryPath.GetUnicode(),    // Use the image path to guide all version binding
-                                                NULL,                         // Do not prime with any preferred version
-                                                NULL,                         // No explicit config file - pick up on one next to image if there.
-                                                0,                            // startupFlags
-                                                dwRuntimeInfoFlags,           // Will bind to post-v2 runtimes if EXE PE runtime version is post-v2
-                                                                              // or EXE has config file binding to post-v2 runtime.
-                                                wszDirectory, MAX_LONGPATH, NULL, // Retrieve bound directory
-                                                wszVersion, MAX_PATH_FNAME, NULL);  // Retrieve bound version
-
-                if (SUCCEEDED(hr)) {
-                    commandLine.Append(wszDirectory);
-                    commandLine.Append(wszVersion);
-                    commandLine.Append(W("\\applaunch.exe"));
-                    commandLine.Append(W("\" /activate \""));
-                    commandLine.Append(pwzAppFullName);
-                    commandLine.Append(W("\" "));
-
-                    if (dwManifestPaths > 0 && ppwzManifestPaths) {
-                        commandLine.Append(W("/manifests "));
-                        for (DWORD i=0; i<dwManifestPaths; i++) {
-                            commandLine.Append(W("\""));
-                            commandLine.Append(*ppwzManifestPaths++);
-                            commandLine.Append(W("\" "));
-                        }
-                    }
-
-                    if (dwActivationData > 0 && ppwzActivationData) {
-                        commandLine.Append(W("/parameters "));
-                        for (DWORD i=0; i<dwActivationData; i++) {
-                            commandLine.Append(W("\""));
-                            commandLine.Append(*ppwzActivationData++);
-                            commandLine.Append(W("\" "));
-                        }
-                    }
-                }
-            }
-        }
-
-        if (SUCCEEDED(hr)) {
-            // CreateProcess won't let this parameter be const
-            // (it writes a NULL in the middle), so we create a writable version
-            LPCWSTR wszCommandLineNonWritable = commandLine.GetUnicode();
-            size_t len = wcslen(wszCommandLineNonWritable);
-            NewArrayHolder<WCHAR> wszCommandLine(new WCHAR[len + 1]);
-            memcpy(wszCommandLine, wszCommandLineNonWritable, len * sizeof(WCHAR));
-            wszCommandLine[len] = W('\0');
-
-            STARTUPINFO sui;
-            memset(&sui, 0, sizeof(STARTUPINFO));
-            sui.cb = sizeof(STARTUPINFO);
-	        sui.lpTitle = pwszAppIdKeyForm;	     
-	        sui.dwFlags = STARTF_TITLEISAPPID;		 
-
-	        if (notPinnableBit>0)
-		        sui.dwFlags |= STARTF_PREVENTPINNING;
-
-            // ClickOnce uses ShellExecute to utilize Win8+ Application Reputation service.
-            // Application Reputation validates applications coming from the Internet.
-            // ClickOnce will use ShellExecute only if there is a Mark-of-the-Web file-stream for the executable.
-            // In all other cases we continue to use CreateProcess. CreateProcess does not use AppRep service.
-            if (bUseShellExecute)
-            {
-                SHELLEXECUTEINFO sei;
-                memset(&sei, 0, sizeof(SHELLEXECUTEINFO));
-                sei.cbSize = sizeof(SHELLEXECUTEINFO);
-                sei.hwnd = NULL;
-                sei.lpVerb = NULL;
-                sei.lpFile = wszCommandLine;
-                sei.lpParameters = pwszParameters;
-                sei.lpDirectory = pwszApplicationFolderPath;
-                sei.nShow = SW_SHOWDEFAULT;
-                sei.hInstApp = NULL;
-
-                // Application Reputation is a COM Shell Extension that requires a calling thread to be an STA
-                // CorLaunchApplication_Callback calls ShellExecuteEx.
-                hr = WszSHCreateThread((LPTHREAD_START_ROUTINE) CorLaunchApplication_ThreadProc, &sei, CTF_COINIT_STA,
-                                    (LPTHREAD_START_ROUTINE) CorLaunchApplication_Callback);
-            }
-            else
-            {
-                // Launch the child process
-                BOOL result = WszCreateProcess(NULL,
-                                               wszCommandLine,
-                                               NULL, NULL, FALSE,
-                                               (lpEnvironment) ? NORMAL_PRIORITY_CLASS | CREATE_UNICODE_ENVIRONMENT | CREATE_DEFAULT_ERROR_MODE : NORMAL_PRIORITY_CLASS | CREATE_DEFAULT_ERROR_MODE,
-                                               lpEnvironment, pwszApplicationFolderPath,
-                                               &sui, lpProcessInformation);
-                if (!result)
-                    hr = HRESULT_FROM_GetLastError();
-            }
-        }
-    }
-    EX_CATCH_HRESULT(hr);
-
-    // cleanup
-    if (hostType == HOST_TYPE_CORFLAG) {
-        // free the environment block
-#undef FreeEnvironmentStringsA
-#undef FreeEnvironmentStringsW
-        if (NULL != lpEnvironment) {
-                FreeEnvironmentStringsW((LPWSTR) lpEnvironment);
-        }
-#define FreeEnvironmentStringsW(lpEnvironment) Use_WszFreeEnvironmentStrings(lpEnvironment)
-#define FreeEnvironmentStringsA(lpEnvironment) Use_WszFreeEnvironmentStrings(lpEnvironment)
-        // reset the environment variables
-        WszSetEnvironmentVariable(g_pwzClickOnceEnv_FullName, NULL);
-        EX_TRY
-        {
-            if (dwManifestPaths > 0 && ppwzManifestPaths) {
-                for (DWORD i=0; i<dwManifestPaths; i++) {
-                    StackSString manifestFile(g_pwzClickOnceEnv_Manifest);
-                    StackSString buf;
-                    COUNT_T size = buf.GetUnicodeAllocation();
-                    _itow_s(i, buf.OpenUnicodeBuffer(size), size, 10);
-                    buf.CloseBuffer();
-                    manifestFile.Append(buf);
-                    WszSetEnvironmentVariable(manifestFile.GetUnicode(), NULL);
-                }
-            }
-            if (dwActivationData > 0 && ppwzActivationData) {
-                for (DWORD i=0; i<dwActivationData; i++) {
-                    StackSString activationData(g_pwzClickOnceEnv_Parameter);
-                    StackSString buf;
-                    COUNT_T size = buf.GetUnicodeAllocation();
-                    _itow_s(i, buf.OpenUnicodeBuffer(size), size, 10);
-                    buf.CloseBuffer();
-                    activationData.Append(buf);
-                    WszSetEnvironmentVariable(activationData.GetUnicode(), NULL);
-                }
-            }
-        }
-        EX_CATCH_HRESULT(hr);
-        // leave the spin lock so other requests can be served.
-        LeaveDfSvcSpinLock();
-    }
-
-    END_ENTRYPOINT_NOTHROW;
-
-    return hr;
-}
-#endif // FEATURE_CLICKONCE
diff --git a/src/vm/i386/asmconstants.h b/src/vm/i386/asmconstants.h
index 259017470e..0d5237bd5a 100644
--- a/src/vm/i386/asmconstants.h
+++ b/src/vm/i386/asmconstants.h
@@ -34,12 +34,7 @@
 #endif
 
 //***************************************************************************
-#if defined(_DEBUG) && defined(_TARGET_X86_) && !defined(FEATURE_CORECLR)
- #define HAS_TRACK_CXX_EXCEPTION_CODE_HACK 1
- #define TRACK_CXX_EXCEPTION_CODE_HACK
-#else
  #define HAS_TRACK_CXX_EXCEPTION_CODE_HACK 0
-#endif
 
 #define INITIAL_SUCCESS_COUNT               0x100
 
@@ -97,6 +92,7 @@ ASMCONSTANTS_C_ASSERT(SpinConstants_dwMaximumDuration == offsetof(SpinConstants,
 #define SpinConstants_dwBackoffFactor 8
 ASMCONSTANTS_C_ASSERT(SpinConstants_dwBackoffFactor == offsetof(SpinConstants,dwBackoffFactor))
 
+#ifndef WIN64EXCEPTIONS
 // EHContext from clr/src/vm/i386/cgencpu.h
 #define EHContext_Eax 0x00
 ASMCONSTANTS_C_ASSERT(EHContext_Eax == offsetof(EHContext,Eax))
@@ -124,6 +120,7 @@ ASMCONSTANTS_C_ASSERT(EHContext_Esp == offsetof(EHContext,Esp))
 
 #define EHContext_Eip 0x20
 ASMCONSTANTS_C_ASSERT(EHContext_Eip == offsetof(EHContext,Eip))
+#endif // WIN64EXCEPTIONS
 
 
 // from clr/src/fjit/helperframe.h
diff --git a/src/vm/i386/asmhelpers.S b/src/vm/i386/asmhelpers.S
index 9445fa0e0f..2bb9560e09 100644
--- a/src/vm/i386/asmhelpers.S
+++ b/src/vm/i386/asmhelpers.S
@@ -127,110 +127,6 @@ LEAF_ENTRY RestoreFPUContext, _TEXT
     ret     4
 LEAF_END RestoreFPUContext, _TEXT
 
-LEAF_ENTRY ResumeAtJitEHHelper, _TEXT
-    mov     edx, [esp + 4]     // edx = pContext (EHContext*)
-
-    mov     ebx, [edx + EHContext_Ebx]
-    mov     esi, [edx + EHContext_Esi]
-    mov     edi, [edx + EHContext_Edi]
-    mov     ebp, [edx + EHContext_Ebp]
-    mov     ecx, [edx + EHContext_Esp]
-    mov     eax, [edx + EHContext_Eip]
-    mov     [ecx - 4], eax
-    mov     eax, [edx + EHContext_Eax]
-    mov     [ecx - 8], eax
-    mov     eax, [edx + EHContext_Ecx]
-    mov     [ecx - 0Ch], eax
-    mov     eax, [edx + EHContext_Edx]
-    mov     [ecx - 10h], eax
-    lea     esp, [ecx - 10h]
-    pop     edx
-    pop     ecx
-    pop     eax
-    ret
-LEAF_END ResumeAtJitEHHelper, _TEXT
-
-// int __stdcall CallJitEHFilterHelper(size_t *pShadowSP, EHContext *pContext);
-//   on entry, only the pContext->Esp, Ebx, Esi, Edi, Ebp, and Eip are initialized
-NESTED_ENTRY CallJitEHFilterHelper, _TEXT, NoHandler
-    push    ebp
-    mov     ebp, esp
-    push    ebx
-    push    esi
-    push    edi
-
-    // Write esp-4 to the shadowSP slot
-    mov     eax, [ebp + 8] // pShadowSP = [ebp+8]
-    test    eax, eax
-    jz      LOCAL_LABEL(DONE_SHADOWSP_FILTER)
-    mov     ebx, esp
-    sub     ebx, 4
-    or      ebx, SHADOW_SP_IN_FILTER_ASM
-    mov     [eax], ebx
-
-LOCAL_LABEL(DONE_SHADOWSP_FILTER):
-    mov     edx, [ebp + 12]       // pContext = [ebp+12]
-    mov     eax, [edx + EHContext_Eax]
-    mov     ebx, [edx + EHContext_Ebx]
-    mov     esi, [edx + EHContext_Esi]
-    mov     edi, [edx + EHContext_Edi]
-    mov     ebp, [edx + EHContext_Ebp]
-
-    call    DWORD PTR [edx + EHContext_Eip]
-#ifdef _DEBUG
-    nop  // Indicate that it is OK to call managed code directly from here
-#endif // _DEBUG
-
-    pop     edi
-    pop     esi
-    pop     ebx
-    pop     ebp // don't use 'leave' here, as ebp as been trashed
-    ret     8
-NESTED_END CallJitEHFilterHelper, _TEXT
-
-// void __stdcall CallJITEHFinallyHelper(size_t *pShadowSP, EHContext *pContext);
-//   on entry, only the pContext->Esp, Ebx, Esi, Edi, Ebp, and Eip are initialized
-NESTED_ENTRY CallJitEHFinallyHelper, _TEXT, NoHandler
-    push    ebp
-    mov     ebp, esp
-    push    ebx
-    push    esi
-    push    edi
-
-    // Write esp-4 to the shadowSP slot
-    mov     eax, [ebp + 8]  // pShadowSP = [ebp+8]
-    test    eax, eax
-    jz      LOCAL_LABEL(DONE_SHADOWSP_FINALLY)
-    mov     ebx, esp
-    sub     ebx, 4
-    mov     [eax], ebx
-
-LOCAL_LABEL(DONE_SHADOWSP_FINALLY):
-    mov     edx, [ebp + 12] // pContext = [ebp+12]
-    mov     eax, [edx + EHContext_Eax]
-    mov     ebx, [edx + EHContext_Ebx]
-    mov     esi, [edx + EHContext_Esi]
-    mov     edi, [edx + EHContext_Edi]
-    mov     ebp, [edx + EHContext_Ebp]
-    call    DWORD PTR [edx + EHContext_Eip]
-#ifdef _DEBUG
-    nop  // Indicate that it is OK to call managed code directly from here
-#endif // _DEBUG
-
-    // Reflect the changes to the context and only update non-volatile registers.
-    // This will be used later to update REGDISPLAY
-    mov     edx, [esp + 12 + 12]
-    mov     [edx + EHContext_Ebx], ebx
-    mov     [edx + EHContext_Esi], esi
-    mov     [edx + EHContext_Edi], edi
-    mov     [edx + EHContext_Ebp], ebp
-
-    pop     edi
-    pop     esi
-    pop     ebx
-    pop     ebp // don't use 'leave' here, as ebp as been trashed
-    ret     8
-NESTED_END CallJitEHFinallyHelper, _TEXT
 
 LEAF_ENTRY GetSpecificCpuTypeAsm, _TEXT
     push    ebx         // ebx is trashed by the cpuid calls
diff --git a/src/vm/i386/cgencpu.h b/src/vm/i386/cgencpu.h
index 2c29d2793a..6dc53beb92 100644
--- a/src/vm/i386/cgencpu.h
+++ b/src/vm/i386/cgencpu.h
@@ -39,9 +39,6 @@ Stub * GenerateInitPInvokeFrameHelper();
 EXTERN_C void STDCALL PInvokeStackImbalanceHelper(void);
 #endif // MDA_SUPPORTED
 
-#ifndef FEATURE_CORECLR
-EXTERN_C void STDCALL CopyCtorCallStub(void);
-#endif // !FEATURE_CORECLR
 
 #ifdef FEATURE_STUBS_AS_IL
 EXTERN_C void SinglecastDelegateInvokeStub();
@@ -154,6 +151,11 @@ typedef INT32 StackElemType;
 // This represents some of the FramedMethodFrame fields that are
 // stored at negative offsets.
 //--------------------------------------------------------------------
+#define ENUM_ARGUMENT_AND_SCRATCH_REGISTERS() \
+    ARGUMENT_AND_SCRATCH_REGISTER(Eax) \
+    ARGUMENT_AND_SCRATCH_REGISTER(Ecx) \
+    ARGUMENT_AND_SCRATCH_REGISTER(Edx)
+
 #define ENUM_CALLEE_SAVED_REGISTERS() \
     CALLEE_SAVED_REGISTER(Edi) \
     CALLEE_SAVED_REGISTER(Esi) \
@@ -203,6 +205,7 @@ struct ArgumentRegisters {
 struct REGDISPLAY;
 typedef REGDISPLAY *PREGDISPLAY;
 
+#ifndef WIN64EXCEPTIONS
 // Sufficient context for Try/Catch restoration.
 struct EHContext {
     INT32       Eax;
@@ -251,6 +254,7 @@ struct EHContext {
         Eip = 0;
     }
 };
+#endif // !WIN64EXCEPTIONS
 
 #define ARGUMENTREGISTERS_SIZE sizeof(ArgumentRegisters)
 
diff --git a/src/vm/i386/cgenx86.cpp b/src/vm/i386/cgenx86.cpp
index 85db84a60e..105b05823e 100644
--- a/src/vm/i386/cgenx86.cpp
+++ b/src/vm/i386/cgenx86.cpp
@@ -60,6 +60,32 @@ extern "C" DWORD STDCALL GetSpecificCpuFeaturesAsm(DWORD *pInfo);
 
 void generate_noref_copy (unsigned nbytes, StubLinkerCPU* sl);
 
+#ifdef WIN64EXCEPTIONS
+void UpdateRegDisplayFromCalleeSavedRegisters(REGDISPLAY * pRD, CalleeSavedRegisters * regs)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    T_CONTEXT * pContext = pRD->pCurrentContext;
+#define CALLEE_SAVED_REGISTER(regname) pContext->regname = regs->regname;
+    ENUM_CALLEE_SAVED_REGISTERS();
+#undef CALLEE_SAVED_REGISTER
+
+    KNONVOLATILE_CONTEXT_POINTERS * pContextPointers = pRD->pCurrentContextPointers;
+#define CALLEE_SAVED_REGISTER(regname) pContextPointers->regname = (DWORD*)&regs->regname;
+    ENUM_CALLEE_SAVED_REGISTERS();
+#undef CALLEE_SAVED_REGISTER
+}
+
+void ClearRegDisplayArgumentAndScratchRegisters(REGDISPLAY * pRD)
+{
+    LIMITED_METHOD_CONTRACT;
+
+#define ARGUMENT_AND_SCRATCH_REGISTER(regname) pRD->pCurrentContextPointers->regname = NULL;
+    ENUM_ARGUMENT_AND_SCRATCH_REGISTERS();
+#undef ARGUMENT_AND_SCRATCH_REGISTER
+}
+#endif // WIN64EXCEPTIONS
+
 #ifndef DACCESS_COMPILE
 
 //=============================================================================
@@ -193,6 +219,7 @@ void GetSpecificCpuInfo(CORINFO_CPU * cpuInfo)
 #endif // #ifndef DACCESS_COMPILE
 
 
+#ifndef WIN64EXCEPTIONS
 //---------------------------------------------------------------------------------------
 //
 // Initialize the EHContext using the resume PC and the REGDISPLAY.  The EHContext is currently used in two
@@ -256,6 +283,7 @@ void EHContext::UpdateFrame(PREGDISPLAY regs)
     *regs->pEdi = this->Edi;
     *regs->pEbp = this->Ebp;
 }
+#endif // WIN64EXCEPTIONS
 
 void TransitionFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
 {
@@ -294,13 +322,6 @@ void TransitionFrame::UpdateRegDisplayHelper(const PREGDISPLAY pRD, UINT cbStack
 
     CalleeSavedRegisters* regs = GetCalleeSavedRegisters();
 
-    // reset pContext; it's only valid for active (top-most) frame
-
-    pRD->pContext = NULL;
-
-#define CALLEE_SAVED_REGISTER(regname) pRD->p##regname = (DWORD*) &regs->regname;
-    ENUM_CALLEE_SAVED_REGISTERS();
-#undef CALLEE_SAVED_REGISTER
     pRD->PCTAddr = GetReturnAddressPtr();
 
 #ifdef WIN64EXCEPTIONS
@@ -311,20 +332,20 @@ void TransitionFrame::UpdateRegDisplayHelper(const PREGDISPLAY pRD, UINT cbStack
     pRD->pCurrentContext->Eip = *PTR_PCODE(pRD->PCTAddr);;
     pRD->pCurrentContext->Esp = GetSP();
 
-    T_CONTEXT * pContext = pRD->pCurrentContext;
-#define CALLEE_SAVED_REGISTER(regname) pContext->regname = regs->regname;
-    ENUM_CALLEE_SAVED_REGISTERS();
-#undef CALLEE_SAVED_REGISTER
-
-    KNONVOLATILE_CONTEXT_POINTERS * pContextPointers = pRD->pCurrentContextPointers;
-#define CALLEE_SAVED_REGISTER(regname) pContextPointers->regname = (DWORD*)&regs->regname;
-    ENUM_CALLEE_SAVED_REGISTERS();
-#undef CALLEE_SAVED_REGISTER
+    UpdateRegDisplayFromCalleeSavedRegisters(pRD, regs);
+    ClearRegDisplayArgumentAndScratchRegisters(pRD);
 
     SyncRegDisplayToCurrentContext(pRD);
 
 #else // WIN64EXCEPTIONS
 
+    // reset pContext; it's only valid for active (top-most) frame
+    pRD->pContext = NULL;
+
+#define CALLEE_SAVED_REGISTER(regname) pRD->p##regname = (DWORD*) &regs->regname;
+    ENUM_CALLEE_SAVED_REGISTERS();
+#undef CALLEE_SAVED_REGISTER
+
     pRD->ControlPC = *PTR_PCODE(pRD->PCTAddr);
     pRD->SP  = (DWORD)(pRD->PCTAddr + sizeof(TADDR) + cbStackPop);
 
@@ -350,6 +371,38 @@ void HelperMethodFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
 
     LOG((LF_GCROOTS, LL_INFO100000, "STACKWALK    HelperMethodFrame::UpdateRegDisplay cached ip:%p, sp:%p\n", m_MachState.GetRetAddr(), m_MachState.esp()));
 
+    pRD->PCTAddr = dac_cast<TADDR>(m_MachState.pRetAddr());
+
+#ifdef WIN64EXCEPTIONS
+
+    pRD->IsCallerContextValid = FALSE;
+    pRD->IsCallerSPValid      = FALSE;        // Don't add usage of this field.  This is only temporary.
+
+#ifdef DACCESS_COMPILE
+    PORTABILITY_ASSERT("HelperMethodFrame::UpdateRegDisplay");
+#endif // DACCESS_COMPILE
+
+    pRD->pCurrentContext->Eip = pRD->ControlPC = m_MachState.GetRetAddr();
+    pRD->pCurrentContext->Esp = pRD->SP = (DWORD) m_MachState.esp();
+
+#define CALLEE_SAVED_REGISTER(regname) pRD->pCurrentContext->regname = *((DWORD*) m_MachState.p##regname());
+    ENUM_CALLEE_SAVED_REGISTERS();
+#undef CALLEE_SAVED_REGISTER
+
+#define CALLEE_SAVED_REGISTER(regname) pRD->pCurrentContextPointers->regname = (DWORD*) m_MachState.p##regname();
+    ENUM_CALLEE_SAVED_REGISTERS();
+#undef CALLEE_SAVED_REGISTER
+
+    //
+    // Clear all knowledge of scratch registers.  We're skipping to any
+    // arbitrary point on the stack, and frames aren't required to preserve or
+    // keep track of these anyways.
+    //
+
+    ClearRegDisplayArgumentAndScratchRegisters(pRD);
+
+#else // WIN64EXCEPTIONS
+
     // reset pContext; it's only valid for active (top-most) frame
     pRD->pContext = NULL;
 
@@ -391,15 +444,12 @@ void HelperMethodFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
         // in the real code.  I'm not sure exactly
         // what should happen in the on-the-fly case,
         // but go with what would happen from an InsureInit.
-#ifdef WIN64EXCEPTIONS
-        PORTABILITY_ASSERT("HelperMethodFrame::UpdateRegDisplay");
-#endif
 
         RETURN;
     }
 
 #endif // #ifdef DACCESS_COMPILE
-    
+
     // DACCESS: The MachState pointers are kept as PTR_TADDR so
     // the host pointers here refer to the appropriate size and
     // these casts are not a problem.
@@ -407,27 +457,10 @@ void HelperMethodFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
     pRD->pEsi = (DWORD*) m_MachState.pEsi();
     pRD->pEbx = (DWORD*) m_MachState.pEbx();
     pRD->pEbp = (DWORD*) m_MachState.pEbp();
-    pRD->PCTAddr = dac_cast<TADDR>(m_MachState.pRetAddr());
+
     pRD->ControlPC = m_MachState.GetRetAddr();
     pRD->SP  = (DWORD) m_MachState.esp();
 
-#ifdef WIN64EXCEPTIONS
-    pRD->IsCallerContextValid = FALSE;
-    pRD->IsCallerSPValid      = FALSE;        // Don't add usage of this field.  This is only temporary.
-
-    //
-    // Copy the saved state from the frame to the current context.
-    //
-    pRD->pCurrentContext->Eip = pRD->ControlPC;
-    pRD->pCurrentContext->Esp = pRD->SP;
-
-#define CALLEE_SAVED_REGISTER(regname) pRD->pCurrentContext->regname = *pRD->p##regname;
-    ENUM_CALLEE_SAVED_REGISTERS();
-#undef CALLEE_SAVED_REGISTER
-
-#define CALLEE_SAVED_REGISTER(regname) pRD->pCurrentContextPointers->regname = pRD->p##regname;
-    ENUM_CALLEE_SAVED_REGISTERS();
-#undef CALLEE_SAVED_REGISTER
 #endif // WIN64EXCEPTIONS
 
     RETURN;
@@ -563,34 +596,36 @@ void FaultingExceptionFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
     // reset pContext; it's only valid for active (top-most) frame
     pRD->pContext = NULL;
 
-#ifndef WIN64EXCEPTIONS
-    CalleeSavedRegisters* regs = GetCalleeSavedRegisters();
-
-#define CALLEE_SAVED_REGISTER(regname) pRD->p##regname = (DWORD*) &regs->regname;
-    ENUM_CALLEE_SAVED_REGISTERS();
-#undef CALLEE_SAVED_REGISTER
-    pRD->SP = m_Esp;
     pRD->PCTAddr = GetReturnAddressPtr();
-    pRD->ControlPC = *PTR_PCODE(pRD->PCTAddr);
 
-#else // WIN64EXCEPTIONS
-
-    pRD->IsCallerContextValid = FALSE;
-    pRD->IsCallerSPValid = FALSE;        // Don't add usage of this field.  This is only temporary.
+#ifdef WIN64EXCEPTIONS
 
     memcpy(pRD->pCurrentContext, &m_ctx, sizeof(CONTEXT));
 
+    pRD->SP = m_ctx.Esp;
+    pRD->ControlPC = m_ctx.Eip;
+
+#define ARGUMENT_AND_SCRATCH_REGISTER(regname) pRD->pCurrentContextPointers->regname = &m_ctx.regname;
+    ENUM_ARGUMENT_AND_SCRATCH_REGISTERS();
+#undef ARGUMENT_AND_SCRATCH_REGISTER
+
 #define CALLEE_SAVED_REGISTER(regname) pRD->pCurrentContextPointers->regname = &m_ctx.regname;
     ENUM_CALLEE_SAVED_REGISTERS();
 #undef CALLEE_SAVED_REGISTER
 
-#define CALLEE_SAVED_REGISTER(regname) pRD->p##regname = &m_ctx.regname;
+    pRD->IsCallerContextValid = FALSE;
+    pRD->IsCallerSPValid = FALSE;        // Don't add usage of this field.  This is only temporary.
+
+#else // WIN64EXCEPTIONS
+
+    CalleeSavedRegisters* regs = GetCalleeSavedRegisters();
+
+#define CALLEE_SAVED_REGISTER(regname) pRD->p##regname = (DWORD*) &regs->regname;
     ENUM_CALLEE_SAVED_REGISTERS();
 #undef CALLEE_SAVED_REGISTER
 
-    pRD->SP = m_ctx.Esp;
-    pRD->PCTAddr = GetReturnAddressPtr();
-    pRD->ControlPC = m_ctx.Eip;
+    pRD->SP = m_Esp;
+    pRD->ControlPC = *PTR_PCODE(pRD->PCTAddr);
 
 #endif // WIN64EXCEPTIONS
 
@@ -638,36 +673,41 @@ void InlinedCallFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
         stackArgSize = pMD->GetStackArgumentSize();
     }
 
-    // reset pContext; it's only valid for active (top-most) frame
-    pRD->pContext = NULL;
-
-
-    pRD->pEbp = (DWORD*) &m_pCalleeSavedFP;
-
     /* The return address is just above the "ESP" */
     pRD->PCTAddr = PTR_HOST_MEMBER_TADDR(InlinedCallFrame, this,
                                          m_pCallerReturnAddress);
-    pRD->ControlPC = *PTR_PCODE(pRD->PCTAddr);
-
-    /* Now we need to pop off the outgoing arguments */
-    pRD->SP  = (DWORD) dac_cast<TADDR>(m_pCallSiteSP) + stackArgSize;
 
 #ifdef WIN64EXCEPTIONS
+
     pRD->IsCallerContextValid = FALSE;
     pRD->IsCallerSPValid      = FALSE;        // Don't add usage of this field.  This is only temporary.
 
-    pRD->pCurrentContext->Eip = pRD->ControlPC;
-    pRD->pCurrentContext->Esp = pRD->SP;
-    pRD->pCurrentContext->Ebp = *pRD->pEbp;
+    pRD->pCurrentContext->Eip = *PTR_PCODE(pRD->PCTAddr);
+    pRD->pCurrentContext->Esp = (DWORD) dac_cast<TADDR>(m_pCallSiteSP) + stackArgSize;
+    pRD->pCurrentContext->Ebp = (DWORD) m_pCalleeSavedFP;
+
+    ClearRegDisplayArgumentAndScratchRegisters(pRD);
 
 #define CALLEE_SAVED_REGISTER(regname) pRD->pCurrentContextPointers->regname = NULL;
     ENUM_CALLEE_SAVED_REGISTERS();
 #undef CALLEE_SAVED_REGISTER
 
-    pRD->pCurrentContextPointers->Ebp = pRD->pEbp;
+    pRD->pCurrentContextPointers->Ebp = (DWORD*) &m_pCalleeSavedFP;
 
     SyncRegDisplayToCurrentContext(pRD);
-#endif
+
+#else // WIN64EXCEPTIONS
+
+    // reset pContext; it's only valid for active (top-most) frame
+    pRD->pContext = NULL;
+
+    pRD->pEbp = (DWORD*) &m_pCalleeSavedFP;
+
+    pRD->ControlPC = *PTR_PCODE(pRD->PCTAddr);
+    /* Now we need to pop off the outgoing arguments */
+    pRD->SP  = (DWORD) dac_cast<TADDR>(m_pCallSiteSP) + stackArgSize;
+
+#endif // WIN64EXCEPTIONS
 
     LOG((LF_GCROOTS, LL_INFO100000, "STACKWALK    InlinedCallFrame::UpdateRegDisplay(ip:%p, sp:%p)\n", pRD->ControlPC, pRD->SP));
 
@@ -696,12 +736,33 @@ void ResumableFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
     }
     CONTRACT_END;
 
+    pRD->PCTAddr = dac_cast<TADDR>(m_Regs) + offsetof(CONTEXT, Eip);
+
+#ifdef WIN64EXCEPTIONS
+
+    memcpy(pRD->pCurrentContext, &m_Regs, sizeof(CONTEXT));
+
+    pRD->SP = m_Regs->Esp;
+    pRD->ControlPC = m_Regs->Eip;
+
+#define ARGUMENT_AND_SCRATCH_REGISTER(reg) pRD->pCurrentContextPointers->reg = &m_Regs->reg;
+    ENUM_ARGUMENT_AND_SCRATCH_REGISTERS();
+#undef ARGUMENT_AND_SCRATCH_REGISTER
+
+#define CALLEE_SAVED_REGISTER(reg) pRD->pCurrentContextPointers->reg = &m_Regs->reg;
+    ENUM_CALLEE_SAVED_REGISTERS();
+#undef CALLEE_SAVED_REGISTER
+
+    pRD->IsCallerContextValid = FALSE;
+    pRD->IsCallerSPValid      = FALSE;        // Don't add usage of this field.  This is only temporary.
+
+#else // WIN64EXCEPTIONS
+
     // reset pContext; it's only valid for active (top-most) frame
     pRD->pContext = NULL;
 
     CONTEXT* pUnwoundContext = m_Regs;
 
-#ifndef WIN64EXCEPTIONS
 #if !defined(DACCESS_COMPILE)
     // "pContextForUnwind" field is only used on X86 since not only is it initialized just for it,
     // but its used only under the confines of STACKWALKER_MAY_POP_FRAMES preprocessor define,
@@ -721,7 +782,6 @@ void ResumableFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
         pUnwoundContext->Eip = m_Regs->Eip;
     }
 #endif // !defined(DACCESS_COMPILE)
-#endif // !WIN64EXCEPTIONS
 
     pRD->pEax = &pUnwoundContext->Eax;
     pRD->pEcx = &pUnwoundContext->Ecx;
@@ -733,14 +793,16 @@ void ResumableFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
     pRD->pEbp = &pUnwoundContext->Ebp;
 
     pRD->ControlPC = pUnwoundContext->Eip;
-    pRD->PCTAddr = dac_cast<TADDR>(m_Regs) + offsetof(CONTEXT, Eip);
 
     pRD->SP  = m_Regs->Esp;
 
+#endif // !WIN64EXCEPTIONS
+
     RETURN;
 }
 
 // The HijackFrame has to know the registers that are pushed by OnHijackTripThread
+//  -> HijackFrame::UpdateRegDisplay should restore all the registers pushed by OnHijackTripThread
 void HijackFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
 {
     CONTRACTL {
@@ -751,20 +813,47 @@ void HijackFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
     }
     CONTRACTL_END;
 
+    pRD->PCTAddr = dac_cast<TADDR>(m_Args) + offsetof(HijackArgs, Eip);
+
+#ifdef WIN64EXCEPTIONS
+
+    pRD->IsCallerContextValid = FALSE;
+    pRD->IsCallerSPValid      = FALSE;        // Don't add usage of this field.  This is only temporary.
+
+    pRD->pCurrentContext->Eip = *PTR_PCODE(pRD->PCTAddr);
+    pRD->pCurrentContext->Esp = (DWORD)(pRD->PCTAddr + sizeof(TADDR));
+
+#define RESTORE_REG(reg) { pRD->pCurrentContext->reg = m_Args->reg; pRD->pCurrentContextPointers->reg = &m_Args->reg; }
+#define CALLEE_SAVED_REGISTER(reg) RESTORE_REG(reg)
+    ENUM_CALLEE_SAVED_REGISTERS();
+#undef CALLEE_SAVED_REGISTER
+
+#define ARGUMENT_AND_SCRATCH_REGISTER(reg) RESTORE_REG(reg)
+    ENUM_ARGUMENT_AND_SCRATCH_REGISTERS();
+#undef ARGUMENT_AND_SCRATCH_REGISTER
+#undef RESTORE_REG
+
+    SyncRegDisplayToCurrentContext(pRD);
+
+#else // WIN64EXCEPTIONS
+
     // This only describes the top-most frame
     pRD->pContext = NULL;
 
-    pRD->pEdi = &m_Args->Edi;
-    pRD->pEsi = &m_Args->Esi;
-    pRD->pEbx = &m_Args->Ebx;
-    pRD->pEdx = &m_Args->Edx;
-    pRD->pEcx = &m_Args->Ecx;
-    pRD->pEax = &m_Args->Eax;
+#define RESTORE_REG(reg) { pRD->p##reg = &m_Args->reg; }
+#define CALLEE_SAVED_REGISTER(reg) RESTORE_REG(reg)
+    ENUM_CALLEE_SAVED_REGISTERS();
+#undef CALLEE_SAVED_REGISTER
+
+#define ARGUMENT_AND_SCRATCH_REGISTER(reg) RESTORE_REG(reg)
+    ENUM_ARGUMENT_AND_SCRATCH_REGISTERS();
+#undef ARGUMENT_AND_SCRATCH_REGISTER
+#undef RESTORE_REG
 
-    pRD->pEbp = &m_Args->Ebp;
-    pRD->PCTAddr = dac_cast<TADDR>(m_Args) + offsetof(HijackArgs, Eip);
     pRD->ControlPC = *PTR_PCODE(pRD->PCTAddr);
     pRD->SP  = (DWORD)(pRD->PCTAddr + sizeof(TADDR));
+
+#endif // WIN64EXCEPTIONS
 }
 
 #endif  // FEATURE_HIJACK
@@ -801,15 +890,34 @@ void TailCallFrame::UpdateRegDisplay(const PREGDISPLAY pRD)
 
     // reset pContext; it's only valid for active (top-most) frame
     pRD->pContext = NULL;
+    pRD->PCTAddr = GetReturnAddressPtr();
+
+#ifdef WIN64EXCEPTIONS
+
+    pRD->IsCallerContextValid = FALSE;
+    pRD->IsCallerSPValid      = FALSE;        // Don't add usage of this field.  This is only temporary.
+
+    pRD->pCurrentContext->Eip = *PTR_PCODE(pRD->PCTAddr);
+    pRD->pCurrentContext->Esp = (DWORD)(pRD->PCTAddr + sizeof(TADDR));
+
+    UpdateRegDisplayFromCalleeSavedRegisters(pRD, &m_regs);
+    ClearRegDisplayArgumentAndScratchRegisters(pRD);
+
+    SyncRegDisplayToCurrentContext(pRD);
+
+#else
 
 #define CALLEE_SAVED_REGISTER(regname) pRD->p##regname = (DWORD*) &m_regs.regname;
     ENUM_CALLEE_SAVED_REGISTERS();
 #undef CALLEE_SAVED_REGISTER
 
-    pRD->PCTAddr = GetReturnAddressPtr();
     pRD->ControlPC = *PTR_PCODE(pRD->PCTAddr);
     pRD->SP  = (DWORD)(pRD->PCTAddr + sizeof(TADDR));
 
+#endif
+
+    LOG((LF_GCROOTS, LL_INFO100000, "STACKWALK    TailCallFrame::UpdateRegDisplay(ip:%p, sp:%p)\n", pRD->ControlPC, pRD->SP));
+
     RETURN;
 }
 
diff --git a/src/vm/i386/excepx86.cpp b/src/vm/i386/excepx86.cpp
index 0f05aa29cd..2997c5784f 100644
--- a/src/vm/i386/excepx86.cpp
+++ b/src/vm/i386/excepx86.cpp
@@ -28,12 +28,10 @@
 #include "dllimportcallback.h"
 #include "threads.h"
 #ifdef FEATURE_REMOTING
-#include "appdomainhelper.h"
 #endif
 #include "eeconfig.h"
 #include "vars.hpp"
 #include "generics.h"
-#include "securityprincipal.h"
 
 #include "asmconstants.h"
 #include "virtualcallstub.h"
@@ -1096,7 +1094,6 @@ CPFH_RealFirstPassHandler(                  // ExceptionContinueSearch, etc.
         }
 #endif // FEATURE_CORRUPTING_EXCEPTIONS
 
-#ifdef FEATURE_CORECLR
         // Check if we are dealing with AV or not and if we are,
         // ensure that this is a real AV and not managed AV exception
         BOOL fIsThrownExceptionAV = FALSE;
@@ -1125,7 +1122,6 @@ CPFH_RealFirstPassHandler(                  // ExceptionContinueSearch, etc.
                 EEPOLICY_HANDLE_FATAL_ERROR(COR_E_SECURITY);
             }
         }
-#endif // FEATURE_CORECLR
 
         // If we're out of memory, then we figure there's probably not memory to maintain a stack trace, so we skip it.
         // If we've got a stack overflow, then we figure the stack will be so huge as to make tracking the stack trace
@@ -2434,13 +2430,11 @@ StackWalkAction COMPlusThrowCallback(       // SWA value
                     currentSP = (SIZE_T) ((void*) pFrameStub);
                     currentIP = 0; // no IP.
                     EEToDebuggerExceptionInterfaceWrapper::FirstChanceManagedException(pThread, (SIZE_T)currentIP, (SIZE_T)currentSP);
-#ifdef FEATURE_EXCEPTION_NOTIFICATIONS
                     // Deliver the FirstChanceNotification after the debugger, if not already delivered.
                     if (!pExInfo->DeliveredFirstChanceNotification())
                     {
                         ExceptionNotifications::DeliverFirstChanceNotification();
                     }
-#endif // FEATURE_EXCEPTION_NOTIFICATIONS
                 }
             }
         }
@@ -2489,14 +2483,12 @@ StackWalkAction COMPlusThrowCallback(       // SWA value
         }
 #endif // DEBUGGING_SUPPORTED
 
-#ifdef FEATURE_EXCEPTION_NOTIFICATIONS
         // Attempt to deliver the first chance notification to the AD only *AFTER* the debugger
         // has done that, provided we have not already done that.
         if (!pExInfo->DeliveredFirstChanceNotification())
         {
             ExceptionNotifications::DeliverFirstChanceNotification();
         }
-#endif // FEATURE_EXCEPTION_NOTIFICATIONS
     }
     IJitManager* pJitManager = pCf->GetJitManager();
     _ASSERTE(pJitManager);
diff --git a/src/vm/i386/gmsx86.cpp b/src/vm/i386/gmsx86.cpp
index 34d65856fe..840a50d045 100644
--- a/src/vm/i386/gmsx86.cpp
+++ b/src/vm/i386/gmsx86.cpp
@@ -1323,6 +1323,8 @@ void LazyMachState::unwindLazyState(LazyMachState* baseState,
 
         pvControlPc = GetIP(&ctx);
 
+        _ASSERTE(pvControlPc != 0);
+
         if (funCallDepth > 0)
         {
             --funCallDepth;
diff --git a/src/vm/i386/jithelp.S b/src/vm/i386/jithelp.S
index 35a02613ea..9a7e3344cd 100644
--- a/src/vm/i386/jithelp.S
+++ b/src/vm/i386/jithelp.S
@@ -720,34 +720,3 @@ LEAF_END JIT_PatchedCodeLast, _TEXT
 LEAF_ENTRY JIT_PatchedCodeEnd, _TEXT
     ret
 LEAF_END JIT_PatchedCodeEnd, _TEXT
-
-// Note that the debugger skips this entirely when doing SetIP,
-// since COMPlusCheckForAbort should always return 0.  Excep.cpp:LeaveCatch
-// asserts that to be true.  If this ends up doing more work, then the
-// debugger may need additional support.
-// void __stdcall JIT_EndCatch();
-NESTED_ENTRY JIT_EndCatch, _TEXT, NoHandler
-#ifndef WIN64EXCEPTIONS
-    // make temp storage for return address, and push the address of that
-    // as the last arg to COMPlusEndCatch
-    mov     ecx, [esp]
-    push    ecx
-    push    esp
-
-    // push the rest of COMPlusEndCatch's args, right-to-left
-    push    esi
-    push    edi
-    push    ebx
-    push    ebp
-
-    // returns old esp value in eax, stores jump address
-    call    C_FUNC(COMPlusEndCatch)
-    // now eax = new esp, [esp] = new eip
-
-    pop     edx         // edx = new eip
-    mov     esp, eax    // esp = new esp
-    jmp     edx         // eip = new eip
-#else
-    int3
-#endif
-NESTED_END JIT_EndCatch, _TEXT
diff --git a/src/vm/i386/jitinterfacex86.cpp b/src/vm/i386/jitinterfacex86.cpp
index a80b5e6325..01d8119c63 100644
--- a/src/vm/i386/jitinterfacex86.cpp
+++ b/src/vm/i386/jitinterfacex86.cpp
@@ -1397,6 +1397,10 @@ void EmitFastGetSharedStaticBase(CPUSTUBLINKER *psl, CodeLabel *init, bool bCCto
         // DoInit:
         psl->EmitLabel(DoInit);
 
+#if defined(UNIX_X86_ABI)
+        // sub esp, 8 ; to align the stack
+        psl->X86EmitSubEsp(8);
+#endif
         // push edx (must be preserved)
         psl->X86EmitPushReg(kEDX);
 
@@ -1406,6 +1410,10 @@ void EmitFastGetSharedStaticBase(CPUSTUBLINKER *psl, CodeLabel *init, bool bCCto
         // pop edx
         psl->X86EmitPopReg(kEDX);
 
+#if defined(UNIX_X86_ABI)
+        // add esp, 8
+        psl->X86EmitAddEsp(8);
+#endif
         // ret
         psl->X86EmitReturn(0);
     }
diff --git a/src/vm/i386/remotingx86.cpp b/src/vm/i386/remotingx86.cpp
deleted file mode 100644
index 3a9e891267..0000000000
--- a/src/vm/i386/remotingx86.cpp
+++ /dev/null
@@ -1,225 +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.
-//
-//
-// 
-// File: remotingx86.cpp
-// 
-
-// 
-// 
-// Purpose: Defines various remoting related functions for the x86 architecture
-//
-
-//
-// 
-
-//
-
-#include "common.h"
-
-#ifdef FEATURE_REMOTING
-
-#include "excep.h"
-#include "comdelegate.h"
-#include "remoting.h"
-#include "field.h"
-#include "siginfo.hpp"
-#include "stackbuildersink.h"
-#include "threads.h"
-#include "method.hpp"
-#include "asmconstants.h"
-#include "interoputil.h"
-#include "virtualcallstub.h"
-
-#ifdef FEATURE_COMINTEROP 
-#include "comcallablewrapper.h"
-#include "comcache.h"
-#endif // FEATURE_COMINTEROP
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CTPMethodTable::CreateThunkForVirtualMethod   private
-//
-//  Synopsis:   Creates the thunk that pushes the supplied slot number and jumps
-//              to TP Stub
-//
-//+----------------------------------------------------------------------------
-PCODE CTPMethodTable::CreateThunkForVirtualMethod(DWORD dwSlot, BYTE *startaddr)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(startaddr));
-    }
-    CONTRACTL_END;
-
-    BYTE *pCode = startaddr;
-
-    // 0000   B8 67 45 23 01     MOV  EAX, dwSlot
-    // 0005   E9 ?? ?? ?? ??     JMP  TransparentProxyStub
-    *pCode++ = 0xB8;
-    *((DWORD *) pCode) = dwSlot;
-    pCode += sizeof(DWORD);
-    *pCode++ = 0xE9;
-    // self-relative call, based on the start of the next instruction.
-    *((LONG *) pCode) = (LONG)((size_t)GetTPStubEntryPoint() - (size_t) (pCode + sizeof(LONG)));
-
-    _ASSERTE(CVirtualThunkMgr::IsThunkByASM((PCODE)startaddr));
-
-    return (PCODE)startaddr;
-}
-
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CTPMethodTable::ActivatePrecodeRemotingThunk    private
-//
-//  Synopsis:   Patch the precode remoting thunk to begin interception
-//
-//+----------------------------------------------------------------------------
-void CTPMethodTable::ActivatePrecodeRemotingThunk()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    // Before activation:
-    // 0000 C3                  ret
-    // 0001 90                  nop
-
-    // After activation:
-    // 0000 85 C9               test     ecx,ecx
-
-    // 0002 74 XX               je       RemotingDone
-    // 0004 81 39 XX XX XX XX   cmp      dword ptr [ecx],11111111h
-    // 000A 74 XX               je       RemotingCheck
-
-    // Switch offset and size of patch based on the jump opcode used.
-    BYTE* pCode = (BYTE*)PrecodeRemotingThunk;
-
-    SIZE_T mtOffset = 0x0006;
-    SIZE_T size = 0x000A;
-
-    // Patch "ret + nop" to "test ecx,ecx"
-    *(UINT16 *)pCode = 0xC985;
-
-    // Replace placeholder value with the actual address of TP method table
-    _ASSERTE(*(PVOID*)(pCode+mtOffset) == (PVOID*)0x11111111);
-    *(PVOID*)(pCode+mtOffset) = GetMethodTable();
-
-    FlushInstructionCache(GetCurrentProcess(), pCode, size);
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CVirtualThunkMgr::DoTraceStub   public
-//
-//  Synopsis:   Traces the stub given the starting address
-//
-//+----------------------------------------------------------------------------
-BOOL CVirtualThunkMgr::DoTraceStub(PCODE stubStartAddress, TraceDestination *trace)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        PRECONDITION(stubStartAddress != NULL);
-        PRECONDITION(CheckPointer(trace));
-    }
-    CONTRACTL_END;
-
-    BOOL bIsStub = FALSE;
-
-    // Find a thunk whose code address matching the starting address
-    LPBYTE pThunk = FindThunk((LPBYTE)stubStartAddress);
-    if(NULL != pThunk)
-    {
-        LPBYTE pbAddr = NULL;
-        LONG destAddress = 0;
-        if((LPBYTE)stubStartAddress == pThunk)
-        {
-
-            // Extract the long which gives the self relative address
-            // of the destination
-            pbAddr = pThunk + sizeof(BYTE) + sizeof(DWORD) + sizeof(BYTE);
-            destAddress = *(LONG *)pbAddr;
-
-            // Calculate the absolute address by adding the offset of the next
-            // instruction after the call instruction
-            destAddress += (LONG)(size_t)(pbAddr + sizeof(LONG));
-
-        }
-
-        // We cannot tell where the stub will end up until OnCall is reached.
-        // So we tell the debugger to run till OnCall is reached and then
-        // come back and ask us again for the actual destination address of
-        // the call
-
-        Stub *stub = Stub::RecoverStub((TADDR)destAddress);
-
-        trace->InitForFramePush(stub->GetPatchAddress());
-        bIsStub = TRUE;
-    }
-
-    return bIsStub;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CVirtualThunkMgr::IsThunkByASM  public
-//
-//  Synopsis:   Check assembly to see if this one of our thunks
-//
-//+----------------------------------------------------------------------------
-BOOL CVirtualThunkMgr::IsThunkByASM(PCODE startaddr)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        PRECONDITION(startaddr != NULL);
-    }
-    CONTRACTL_END;
-
-    PTR_BYTE pbCode = PTR_BYTE(startaddr);
-
-    return ((pbCode[0] == 0xB8) &&
-            (pbCode[5] == 0xe9) &&
-            (rel32Decode((TADDR)(pbCode + 6)) == CTPMethodTable::GetTPStubEntryPoint()));
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CVirtualThunkMgr::GetMethodDescByASM   public
-//
-//  Synopsis:   Parses MethodDesc out of assembly code
-//
-//+----------------------------------------------------------------------------
-MethodDesc *CVirtualThunkMgr::GetMethodDescByASM(PCODE startaddr, MethodTable *pMT)
-{
-    CONTRACT (MethodDesc*)
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        PRECONDITION(startaddr != NULL);
-        PRECONDITION(CheckPointer(pMT));
-        POSTCONDITION(CheckPointer(RETVAL));
-    }
-    CONTRACT_END;
-
-    RETURN (pMT->GetMethodDescForSlot(*((DWORD *) (startaddr + 1))));
-}
-
-#endif// FEATURE_REMOTING
-
diff --git a/src/vm/i386/umthunkstub.S b/src/vm/i386/umthunkstub.S
index 22a4329a8e..5a557d4b32 100644
--- a/src/vm/i386/umthunkstub.S
+++ b/src/vm/i386/umthunkstub.S
@@ -28,7 +28,7 @@ NESTED_ENTRY UMThunkStub, _TEXT, UnhandledExceptionHandlerUnix
 #define UMThunkStub_UMENTRYTHUNK_OFFSET     (UMThunkStub_SAVEDREG+4)
 #define UMThunkStub_THREAD_OFFSET           (UMThunkStub_UMENTRYTHUNK_OFFSET+4)
 #define UMThunkStub_INT_ARG_OFFSET          (UMThunkStub_THREAD_OFFSET+4)
-#define UMThunkStub_FIXEDALLOCSIZE          (UMThunkStub_LOCALVARS)
+#define UMThunkStub_FIXEDALLOCSIZE          (UMThunkStub_LOCALVARS+4) // extra 4 is for stack alignment
 
 // return address                           <-- entry ESP
 // saved ebp                                <-- EBP
@@ -37,6 +37,7 @@ NESTED_ENTRY UMThunkStub, _TEXT, UnhandledExceptionHandlerUnix
 // saved edi
 // UMEntryThunk*
 // Thread*
+// dummy 4 byte for 16 byte stack alignment
 // {optional stack args passed to callee}   <-- new esp
 
     PROLOG_BEG
@@ -122,11 +123,13 @@ LOCAL_LABEL(InvalidTransition):
 LOCAL_LABEL(DoTrapReturningThreadsTHROW):
 
     // extern "C" VOID STDCALL UMThunkStubRareDisableWorker(Thread *pThread, UMEntryThunk *pUMEntryThunk)
+    sub     esp, (2*4) // add padding to ensure 16 byte stack alignment
     mov     eax, dword ptr [ebp - UMThunkStub_UMENTRYTHUNK_OFFSET]
     push    eax
     mov     eax, dword ptr [ebp - UMThunkStub_THREAD_OFFSET]
     push    eax
     call    C_FUNC(UMThunkStubRareDisableWorker)
+    add     esp, (2*4) // restore to before stack alignment
 
     jmp     LOCAL_LABEL(InCooperativeMode)
 
diff --git a/src/vm/ilmarshalers.cpp b/src/vm/ilmarshalers.cpp
index c44e561df3..a72276ef4a 100644
--- a/src/vm/ilmarshalers.cpp
+++ b/src/vm/ilmarshalers.cpp
@@ -3305,135 +3305,6 @@ ILCriticalHandleMarshaler::ReturnOverride(
     return OVERRIDDEN;
 } // ILCriticalHandleMarshaler::ReturnOverride
 
-#ifndef FEATURE_CORECLR
-//---------------------------------------------------------------------------------------
-// 
-MarshalerOverrideStatus ILBlittableValueClassWithCopyCtorMarshaler::ArgumentOverride(NDirectStubLinker* psl,
-                                                BOOL               byref,
-                                                BOOL               fin,
-                                                BOOL               fout,
-                                                BOOL               fManagedToNative,
-                                                OverrideProcArgs*  pargs,
-                                                UINT*              pResID,
-                                                UINT               argidx,
-                                                UINT               nativeStackOffset)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-    
-    ILCodeStream* pslIL         = psl->GetMarshalCodeStream();
-    ILCodeStream* pslILDispatch = psl->GetDispatchCodeStream();
-
-    if (byref)
-    {
-        *pResID = IDS_EE_BADMARSHAL_COPYCTORRESTRICTION;
-        return DISALLOWED;
-    }        
-
-    if (fManagedToNative)
-    {
-#ifdef _TARGET_X86_
-        _ASSERTE(nativeStackOffset != (UINT)-1);
-
-        // get a new copy ctor cookie
-        DWORD dwCookieLocalNum = psl->CreateCopyCtorCookie(pslIL);
-
-        // and initialize it with our values
-        pslIL->EmitLDLOCA(dwCookieLocalNum);
-        pslIL->EmitLDARG(argidx);
-        pslIL->EmitLDC(nativeStackOffset);
-
-        // SetData takes pointers to managed methods although code:CopyCtorCallStubWorker
-        // currently calls them via reverse P/Invokes
-        if (pargs->mm.m_pCopyCtor)
-        {
-            pslIL->EmitLDFTN(pslIL->GetToken(pargs->mm.m_pCopyCtor));
-        }
-        else
-        {
-            pslIL->EmitLoadNullPtr();
-        }
-
-        if (pargs->mm.m_pDtor)
-        {
-            pslIL->EmitLDFTN(pslIL->GetToken(pargs->mm.m_pDtor));
-        }
-        else
-        {
-            pslIL->EmitLoadNullPtr();
-        }
-
-        // <dwCookieLocalNum>.SetData(<argidx>, <nativeStackOffset>, ctorPtr, dtorPtr)
-        pslIL->EmitCALL(METHOD__COPYCTORSTUBCOOKIE__SET_DATA, 5, 0);
-
-        LocalDesc   locDesc(pargs->mm.m_pMT);
-        pslIL->SetStubTargetArgType(&locDesc);              // native type is the value type
-
-        pslILDispatch->EmitLDARG(argidx);                   // we load the argument directly
-        pslILDispatch->EmitLDOBJ(pslILDispatch->GetToken(pargs->mm.m_pMT));
-#else // _TARGET_X86_
-        // On WIN64 platforms, copy-constructed arguments are actually passed by reference.
-        // This is the same calling convention as used by managed code, but to maintain parity,
-        // we mimic the x86 behaviour:
-        // 
-        // 1) create new native value type local
-        // 2) run new->CopyCtor(old)
-        // 3) run old->Dtor()
-
-        LocalDesc   locDesc(pargs->mm.m_pMT);
-
-        DWORD       dwNewValueTypeLocal;
-
-        // Step 1
-        dwNewValueTypeLocal = pslIL->NewLocal(locDesc);
-
-        // Step 2
-        if (pargs->mm.m_pCopyCtor)
-        {
-            pslIL->EmitLDLOCA(dwNewValueTypeLocal);
-            pslIL->EmitLDARG(argidx);
-            pslIL->EmitCALL(pslIL->GetToken(pargs->mm.m_pCopyCtor), 2, 0);
-        }
-        else
-        {
-            pslIL->EmitLDARG(argidx);
-            pslIL->EmitLDOBJ(pslIL->GetToken(pargs->mm.m_pMT));
-            pslIL->EmitSTLOC(dwNewValueTypeLocal);
-        }
-
-        // Step 3
-        if (pargs->mm.m_pDtor)
-        {
-            pslIL->EmitLDARG(argidx);
-            pslIL->EmitCALL(pslIL->GetToken(pargs->mm.m_pDtor), 1, 0);
-        }
-
-        pslIL->SetStubTargetArgType(ELEMENT_TYPE_I);        // native type is a pointer
-        pslILDispatch->EmitLDLOCA(dwNewValueTypeLocal);
-#endif // _TARGET_X86_
-
-        return OVERRIDDEN;
-    }
-    else
-    {
-        // nothing to do but pass the value along
-        // note that on x86 the argument comes by-value but is converted to pointer by the UM thunk
-        // so that we don't make copies that would not be accounted for by copy ctors
-        LocalDesc   locDesc(pargs->mm.m_pMT);
-        locDesc.MakeCopyConstructedPointer();
-
-        pslIL->SetStubTargetArgType(&locDesc);              // native type is a pointer
-        pslILDispatch->EmitLDARG(argidx);
-
-        return OVERRIDDEN;
-    }
-}
-#endif // FEATURE_CORECLR
 
 LocalDesc ILArgIteratorMarshaler::GetNativeType()
 {
diff --git a/src/vm/ilmarshalers.h b/src/vm/ilmarshalers.h
index 5337b081c6..7c7f9a6553 100644
--- a/src/vm/ilmarshalers.h
+++ b/src/vm/ilmarshalers.h
@@ -600,7 +600,7 @@ public:
                 nativeSize = wNativeSize;
             }
 
-#if defined(_TARGET_X86_) || (defined(_TARGET_AMD64_) && defined(_WIN64) && !defined(FEATURE_CORECLR))
+#if defined(_TARGET_X86_)
             // JIT32 and JIT64 (which is only used on the Windows Desktop CLR) has a problem generating
             // code for the pinvoke ILStubs which do a return using a struct type.  Therefore, we
             // change the signature of calli to return void and make the return buffer as first argument. 
@@ -2716,42 +2716,6 @@ protected:
 };
 
 
-#ifndef FEATURE_CORECLR
-class ILBlittableValueClassWithCopyCtorMarshaler : public ILMarshaler
-{
-public:
-    enum
-    {
-        c_fInOnly               = TRUE,
-        c_nativeSize            = VARIABLESIZE,
-        c_CLRSize               = sizeof(OBJECTREF),
-    };
-
-    LocalDesc GetManagedType()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return LocalDesc();
-    }
-
-    LocalDesc GetNativeType()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return LocalDesc();
-    }
-
-    static MarshalerOverrideStatus ArgumentOverride(NDirectStubLinker* psl,
-                                            BOOL               byref,
-                                            BOOL               fin,
-                                            BOOL               fout,
-                                            BOOL               fManagedToNative,
-                                            OverrideProcArgs*  pargs,
-                                            UINT*              pResID,
-                                            UINT               argidx,
-                                            UINT               nativeStackOffset);
-
-
-};
-#endif // !FEATURE_CORECLR
 
 
 class ILArgIteratorMarshaler : public ILMarshaler
diff --git a/src/vm/ilstubcache.cpp b/src/vm/ilstubcache.cpp
index 9cd904aec7..ff6bdc0335 100644
--- a/src/vm/ilstubcache.cpp
+++ b/src/vm/ilstubcache.cpp
@@ -531,47 +531,6 @@ MethodDesc* ILStubCache::GetStubMethodDesc(
         }
     }
 
-#ifndef FEATURE_CORECLR
-    //
-    // Publish ETW events for IL stubs
-    //
-    if (bFireETWCacheHitEvent)    
-    {
-        if (ETW_EVENT_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context, ILStubCacheHit))
-        {
-
-            SString strNamespaceOrClassName, strMethodName, strMethodSignature;
-            UINT64 uModuleId = 0;
-
-            if (pTargetMD)
-            {
-                pTargetMD->GetMethodInfoWithNewSig(strNamespaceOrClassName, strMethodName, strMethodSignature);
-                uModuleId = (UINT64)pTargetMD->GetModule()->GetAddrModuleID();               
-            }
-
-            DWORD dwToken = 0;
-            if (pTargetMD)
-                dwToken = pTargetMD->GetMemberDef();
-
-            //
-            // Truncate string fields. Make sure the whole event is less than 64KB
-            //
-            TruncateUnicodeString(strNamespaceOrClassName, ETW_IL_STUB_EVENT_STRING_FIELD_MAXSIZE);
-            TruncateUnicodeString(strMethodName,           ETW_IL_STUB_EVENT_STRING_FIELD_MAXSIZE);
-            TruncateUnicodeString(strMethodSignature,      ETW_IL_STUB_EVENT_STRING_FIELD_MAXSIZE);           
-            
-            FireEtwILStubCacheHit(
-                GetClrInstanceId(),                         // ClrInstanceId
-                uModuleId,                                  // ModuleIdentifier
-                (UINT64)pMD,                                // StubMethodIdentifier
-                dwToken,                                    // ManagedInteropMethodToken
-                strNamespaceOrClassName.GetUnicode(),       // ManagedInteropMethodNamespace
-                strMethodName.GetUnicode(),                 // ManagedInteropMethodName
-                strMethodSignature.GetUnicode()             // ManagedInteropMethodSignature
-                );
-        }                       
-    }
-#endif // !FEATURE_CORECLR
     
     if (!pMD)
     {
diff --git a/src/vm/interoputil.cpp b/src/vm/interoputil.cpp
index 6a0fbded12..809704235e 100644
--- a/src/vm/interoputil.cpp
+++ b/src/vm/interoputil.cpp
@@ -46,9 +46,6 @@
 #include "clrtocomcall.h"
 #include "comcache.h"
 #include "commtmemberinfomap.h"
-#ifdef FEATURE_COMINTEROP_TLB_SUPPORT
-#include "comtypelibconverter.h"
-#endif
 #include "olevariant.h"
 #include "stdinterfaces.h"
 #include "notifyexternals.h"
@@ -294,7 +291,6 @@ static const BinderMethodID s_stubsDisposableToClosable[] =
     METHOD__IDISPOSABLE_TO_ICLOSABLE_ADAPTER__CLOSE
 };
 
-#ifdef FEATURE_CORECLR
 DEFINE_ASM_QUAL_TYPE_NAME(NCCWINRT_ASM_QUAL_TYPE_NAME, g_INotifyCollectionChanged_WinRTName, g_SystemRuntimeWindowsRuntimeAsmName, VER_ASSEMBLYVERSION_STR, g_ECMAKeyToken);
 DEFINE_ASM_QUAL_TYPE_NAME(NCCMA_ASM_QUAL_TYPE_NAME, g_NotifyCollectionChangedToManagedAdapterName, g_SystemRuntimeWindowsRuntimeAsmName, VER_ASSEMBLYVERSION_STR, g_ECMAKeyToken);
 DEFINE_ASM_QUAL_TYPE_NAME(NCCWA_ASM_QUAL_TYPE_NAME, g_NotifyCollectionChangedToWinRTAdapterName, g_SystemRuntimeWindowsRuntimeAsmName, VER_ASSEMBLYVERSION_STR, g_ECMAKeyToken);
@@ -306,20 +302,6 @@ DEFINE_ASM_QUAL_TYPE_NAME(CMDMA_ASM_QUAL_TYPE_NAME, g_ICommandToManagedAdapterNa
 DEFINE_ASM_QUAL_TYPE_NAME(CMDWA_ASM_QUAL_TYPE_NAME, g_ICommandToWinRTAdapterName, g_SystemRuntimeWindowsRuntimeAsmName, VER_ASSEMBLYVERSION_STR, g_ECMAKeyToken);
 DEFINE_ASM_QUAL_TYPE_NAME(NCCEHWINRT_ASM_QUAL_TYPE_NAME, g_NotifyCollectionChangedEventHandler_WinRT, g_SystemRuntimeWindowsRuntimeAsmName, VER_ASSEMBLYVERSION_STR, g_ECMAKeyToken);
 DEFINE_ASM_QUAL_TYPE_NAME(PCEHWINRT_ASM_QUAL_TYPE_NAME, g_PropertyChangedEventHandler_WinRT_Name, g_SystemRuntimeWindowsRuntimeAsmName, VER_ASSEMBLYVERSION_STR, g_ECMAKeyToken);
-#else
-DEFINE_ASM_QUAL_TYPE_NAME(NCCWINRT_ASM_QUAL_TYPE_NAME, g_INotifyCollectionChanged_WinRTName, g_SystemAsmName, VER_ASSEMBLYVERSION_STR, g_ECMAKeyToken);
-DEFINE_ASM_QUAL_TYPE_NAME(NCCMA_ASM_QUAL_TYPE_NAME, g_NotifyCollectionChangedToManagedAdapterName, g_SystemAsmName, VER_ASSEMBLYVERSION_STR, g_ECMAKeyToken);
-DEFINE_ASM_QUAL_TYPE_NAME(NCCWA_ASM_QUAL_TYPE_NAME, g_NotifyCollectionChangedToWinRTAdapterName, g_SystemAsmName, VER_ASSEMBLYVERSION_STR, g_ECMAKeyToken);
-DEFINE_ASM_QUAL_TYPE_NAME(NPCWINRT_ASM_QUAL_TYPE_NAME, g_INotifyPropertyChanged_WinRTName, g_SystemAsmName, VER_ASSEMBLYVERSION_STR, g_ECMAKeyToken);
-DEFINE_ASM_QUAL_TYPE_NAME(NPCMA_ASM_QUAL_TYPE_NAME, g_NotifyPropertyChangedToManagedAdapterName, g_SystemAsmName, VER_ASSEMBLYVERSION_STR, g_ECMAKeyToken);
-DEFINE_ASM_QUAL_TYPE_NAME(NPCWA_ASM_QUAL_TYPE_NAME, g_NotifyPropertyChangedToWinRTAdapterName, g_SystemAsmName, VER_ASSEMBLYVERSION_STR, g_ECMAKeyToken);
-DEFINE_ASM_QUAL_TYPE_NAME(CMDWINRT_ASM_QUAL_TYPE_NAME, g_ICommand_WinRTName, g_SystemAsmName, VER_ASSEMBLYVERSION_STR, g_ECMAKeyToken);
-DEFINE_ASM_QUAL_TYPE_NAME(CMDMA_ASM_QUAL_TYPE_NAME, g_ICommandToManagedAdapterName, g_SystemAsmName, VER_ASSEMBLYVERSION_STR, g_ECMAKeyToken);
-DEFINE_ASM_QUAL_TYPE_NAME(CMDWA_ASM_QUAL_TYPE_NAME, g_ICommandToWinRTAdapterName, g_SystemAsmName, VER_ASSEMBLYVERSION_STR, g_ECMAKeyToken);
-DEFINE_ASM_QUAL_TYPE_NAME(NCCEHWINRT_ASM_QUAL_TYPE_NAME, g_NotifyCollectionChangedEventHandler_WinRT, g_SystemAsmName, VER_ASSEMBLYVERSION_STR, g_ECMAKeyToken);
-DEFINE_ASM_QUAL_TYPE_NAME(PCEHWINRT_ASM_QUAL_TYPE_NAME, g_PropertyChangedEventHandler_WinRT_Name, g_SystemAsmName, VER_ASSEMBLYVERSION_STR, g_ECMAKeyToken);
-
-#endif
 
 const WinRTInterfaceRedirector::NonMscorlibRedirectedInterfaceInfo WinRTInterfaceRedirector::s_rNonMscorlibInterfaceInfos[3] =
 {
@@ -2370,48 +2352,7 @@ HRESULT LoadTypeLibExWithFlags(LPCOLESTR  szFile,
     }
     CONTRACTL_END;
 
-#ifndef FEATURE_COMINTEROP_TLB_SUPPORT
     return E_FAIL;
-#else //FEATURE_COMINTEROP_TLB_SUPPORT
-
-    *pptlib = NULL;
-
-    GCX_PREEMP();
-
-    REGKIND rk = REGKIND_NONE;
-
-    if ((flags & TlbExporter_ExportAs64Bit) == TlbExporter_ExportAs64Bit)
-    {
-        rk = (REGKIND)(REGKIND_NONE | LOAD_TLB_AS_64BIT);
-    }
-    else if ((flags & TlbExporter_ExportAs32Bit) == TlbExporter_ExportAs32Bit)
-    {
-        rk = (REGKIND)(REGKIND_NONE | LOAD_TLB_AS_32BIT);
-    }
-
-    HRESULT hr = S_OK;
-    
-    EX_TRY
-    {
-        LeaveRuntimeHolder lrh((size_t)LoadTypeLibEx);
-        
-        hr = LoadTypeLibEx(szFile, rk, pptlib);
-
-        // If we fail with E_INVALIDARG, it's probably because we're on a downlevel
-        //  platform that doesn't support loading type libraries by bitness.
-        if (hr == E_INVALIDARG)
-        {
-            hr = LoadTypeLibEx(szFile, REGKIND_NONE, pptlib);
-        }
-    }
-    EX_CATCH
-    {
-        hr = E_OUTOFMEMORY;
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-
-    return hr;
-#endif //FEATURE_COMINTEROP_TLB_SUPPORT
 }
 
 
@@ -6950,12 +6891,6 @@ TypeHandle GetClassFromIInspectable(IUnknown* pUnk, bool *pfSupportsIInspectable
     LPCWSTR pwszClassName = winrtClassName.GetRawBuffer(&cchClassName);
     SString ssClassName(SString::Literal, pwszClassName, cchClassName);
 
-#ifndef FEATURE_CORECLR
-    if (ETW_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context, TRACE_LEVEL_INFORMATION, CLR_PRIVATE_DYNAMICTYPEUSAGE_KEYWORD))
-    {
-        FireEtwIInspectableRuntimeClassName(pwszClassName, GetClrInstanceId());
-    }
-#endif
     
     // Check a cache to see if this has already been looked up.
     AppDomain *pDomain = GetAppDomain();
diff --git a/src/vm/invokeutil.cpp b/src/vm/invokeutil.cpp
index 42e5a86249..63979a3b21 100644
--- a/src/vm/invokeutil.cpp
+++ b/src/vm/invokeutil.cpp
@@ -1551,14 +1551,6 @@ void InvokeUtil::CanAccessClass(RefSecContext*  pCtx,
 
     InvokeUtil::CheckAccessClass(pCtx, pClass, checkAccessForImplicitValueTypeCtor);
 
-#ifndef FEATURE_CORECLR
-    // Reflection invocation should turn critical method access into a full demand of full trust
-    // for level 2 assemblies.
-    if (InvokeUtil::IsCriticalWithConversionToFullDemand(pClass))
-    {
-        Security::SpecialDemand(SSWT_LATEBOUND_LINKDEMAND, SECURITY_FULL_TRUST);
-    }
-#endif //FEATURE_CORECLR
 }
 
 #ifndef DACCESS_COMPILE
@@ -1579,30 +1571,12 @@ void InvokeUtil::CanAccessMethod(MethodDesc*    pMeth,
     }
     CONTRACTL_END;
 
-#ifndef FEATURE_CORECLR
-    // Security checks are expensive as they involve stack walking. Avoid them if we can.
-    // In immersive we don't allow private reflection to framework code. So we need to perform
-    // the access check even if all the domains on the stack are fully trusted.
-    if (Security::AllDomainsOnStackFullyTrusted() && !AppX::IsAppXProcess() && !pParentMT->GetAssembly()->IsDisabledPrivateReflection())
-        return;
-#endif // FEATURE_CORECLR
 
     InvokeUtil::CheckAccessMethod(pSCtx,
                                   pParentMT,
                                   pInstanceMT,
                                   pMeth);
 
-#ifndef FEATURE_CORECLR
-    // Reflection invocation should turn critical method access into a full demand of full trust
-    // for level 2 assemblies.
-    if (fCriticalToFullDemand && InvokeUtil::IsCriticalWithConversionToFullDemand(pMeth, pParentMT))
-    {
-        Security::SpecialDemand(SSWT_LATEBOUND_LINKDEMAND, SECURITY_FULL_TRUST);
-
-        // No need to do any more checks if a full trust full demand has succeeded.
-        return;
-    }
-#endif //FEATURE_CORECLR
 
     if (pMeth->RequiresLinktimeCheck())
     {
@@ -1610,25 +1584,6 @@ void InvokeUtil::CanAccessMethod(MethodDesc*    pMeth,
         // stack walks in order to close security holes in poorly written
         // reflection users.
 
-#ifdef FEATURE_APTCA
-        if (Security::IsUntrustedCallerCheckNeeded(pMeth))
-        {
-            if (pSCtx->GetCallerMT()) 
-            { 
-                // Check for untrusted caller
-                // It is possible that wrappers like VBHelper libraries that are
-                // fully trusted, make calls to public methods that do not have
-                // safe for Untrusted caller custom attribute set.
-                // Like all other link demand that gets transformed to a full stack 
-                // walk for reflection, calls to public methods also gets 
-                // converted to full stack walk
-    
-                Security::DoUntrustedCallerChecks(
-                    pSCtx->GetCallerMT()->GetAssembly(), pMeth,
-                    TRUE);
-            }
-        }
-#endif // FEATURE_APTCA
 
         struct _gc
         {
@@ -1667,7 +1622,6 @@ void InvokeUtil::CanAccessMethod(MethodDesc*    pMeth,
 
         GCPROTECT_END();
 
-#ifdef FEATURE_CORECLR                
         if (pMeth->IsNDirect() ||
             (pMeth->IsComPlusCall() && !pMeth->IsInterface()))
         {
@@ -1683,27 +1637,6 @@ void InvokeUtil::CanAccessMethod(MethodDesc*    pMeth,
             }
         }
 
-#else  // FEATURE_CORECLR
-        // We perform automatic linktime checks for UnmanagedCode in three cases:
-        //   o  P/Invoke calls.
-        //   o  Calls through an interface that have a suppress runtime check
-        //      attribute on them (these are almost certainly interop calls).
-        //   o  Interop calls made through method impls.
-        if (pMeth->IsNDirect() ||
-            (pMeth->IsInterface() &&
-             (pMeth->GetMDImport()->GetCustomAttributeByName(pParentMT->GetCl(),
-                                                           COR_SUPPRESS_UNMANAGED_CODE_CHECK_ATTRIBUTE_ANSI,
-                                                           NULL,
-                                                           NULL) == S_OK ||
-              pMeth->GetMDImport()->GetCustomAttributeByName(pMeth->GetMemberDef(),
-                                                           COR_SUPPRESS_UNMANAGED_CODE_CHECK_ATTRIBUTE_ANSI,
-                                                           NULL,
-                                                           NULL) == S_OK) ) ||
-            (pMeth->IsComPlusCall() && !pMeth->IsInterface()))
-        {
-            Security::SpecialDemand(SSWT_LATEBOUND_LINKDEMAND, SECURITY_UNMANAGED_CODE);
-        }
-#endif // FEATURE_CORECLR
     }
 
     // @todo: 
@@ -1731,9 +1664,6 @@ void InvokeUtil::CanAccessMethod(MethodDesc*    pMeth,
             }
         }
 
-#ifndef FEATURE_CORECLR
-        Security::SpecialDemand(SSWT_LATEBOUND_LINKDEMAND, SECURITY_SKIP_VER);
-#endif // !FEATURE_CORECLR
     }
 }
 #endif // #ifndef DACCESS_COMPILE
@@ -1753,14 +1683,6 @@ void InvokeUtil::CanAccessField(RefSecContext*  pCtx,
 
     InvokeUtil::CheckAccessField(pCtx, pTargetMT, pInstanceMT, pTargetField);
 
-#ifndef FEATURE_CORECLR
-    // Reflection invocation should turn critical method access into a full demand of full trust
-    // for level 2 assemblies.
-    if (InvokeUtil::IsCriticalWithConversionToFullDemand(pTargetField, pInstanceMT))
-    {
-        Security::SpecialDemand(SSWT_LATEBOUND_LINKDEMAND, SECURITY_FULL_TRUST);
-    }
-#endif //FEATURE_CORECLR
 }
 
 //
@@ -2009,7 +1931,6 @@ AccessCheckOptions::AccessCheckType InvokeUtil::GetInvocationAccessCheckType(BOO
 
     AppDomain * pAppDomain = GetAppDomain();
 
-#ifdef FEATURE_CORECLR
 
     if (pAppDomain->GetSecurityDescriptor()->IsFullyTrusted())
         // Ignore transparency so that reflection invocation is consistenct with LCG.
@@ -2018,14 +1939,6 @@ AccessCheckOptions::AccessCheckType InvokeUtil::GetInvocationAccessCheckType(BOO
 
     return AccessCheckOptions::kMemberAccess;
 
-#else // !FEATURE_CORECLR
-    return 
-        AppX::IsAppXProcess() ?
-           (Security::AllDomainsOnStackFullyTrusted() ? 
-                AccessCheckOptions::kUserCodeOnlyRestrictedMemberAccessNoTransparency : 
-                AccessCheckOptions::kUserCodeOnlyRestrictedMemberAccess) :
-           AccessCheckOptions::kRestrictedMemberAccess;
-#endif //FEATURE_CORECLR
 }
 
 #endif // CROSSGEN_COMPILE
diff --git a/src/vm/jithelpers.cpp b/src/vm/jithelpers.cpp
index 7b9389d5b6..d132741b0d 100644
--- a/src/vm/jithelpers.cpp
+++ b/src/vm/jithelpers.cpp
@@ -50,7 +50,6 @@
 #include "genericdict.h"
 #include "array.h"
 #include "debuginfostore.h"
-#include "constrainedexecutionregion.h"
 #include "security.h"
 #include "safemath.h"
 #include "threadstatics.h"
@@ -63,9 +62,7 @@
 #include "gccover.h"
 #endif // HAVE_GCCOVER
 
-#ifdef FEATURE_CORECLR
 #include "runtimehandles.h"
-#endif
 
 //========================================================================
 //
@@ -5415,7 +5412,6 @@ HCIMPL1(void, IL_Throw,  Object* obj)
             EEPolicy::HandleOutOfMemory();
         }
 
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
         // If the flag indicating ForeignExceptionRaise has been set,
         // then do not clear the "_stackTrace" field of the exception object.
         if (GetThread()->GetExceptionState()->IsRaisingForeignException())
@@ -5423,7 +5419,6 @@ HCIMPL1(void, IL_Throw,  Object* obj)
             ((EXCEPTIONREF)oref)->SetStackTraceString(NULL);
         }
         else
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
         {
             ((EXCEPTIONREF)oref)->ClearStackTracePreservingRemoteStackTrace();
         }
@@ -5830,13 +5825,11 @@ HCIMPL2(void, JIT_DelegateSecurityCheck, CORINFO_CLASS_HANDLE delegateHnd, CORIN
 {
     FCALL_CONTRACT;
 
-#ifdef FEATURE_CORECLR
     // If we're in full trust, then we don't enforce the delegate binding rules
     if (GetAppDomain()->GetSecurityDescriptor()->IsFullyTrusted())
     {
         return;
     }
-#endif // FEATURE_CORECLR
 
     // Tailcall to the real implementation
     ENDFORBIDGC();
@@ -6043,9 +6036,6 @@ NOINLINE HCIMPL2(void, JIT_Security_Prolog_Framed, CORINFO_METHOD_HANDLE methHnd
         if ((pCurrent->IsInterceptedForDeclSecurity() &&
             !(pCurrent->IsInterceptedForDeclSecurityCASDemandsOnly() &&
                 SecurityStackWalk::HasFlagsOrFullyTrusted(0)))
-#ifdef FEATURE_COMPRESSEDSTACK
-                || SecurityStackWalk::MethodIsAnonymouslyHostedDynamicMethodWithCSToEvaluate(pCurrent)
-#endif //FEATURE_COMPRESSEDSTACK
                 )
         {
             MethodSecurityDescriptor MDSecDesc(pCurrent);
@@ -6107,16 +6097,9 @@ NOINLINE HCIMPL1(void, JIT_VerificationRuntimeCheck_Internal, CORINFO_METHOD_HAN
     
     HELPER_METHOD_FRAME_BEGIN_NOPOLL();
     {
-#ifdef FEATURE_CORECLR
         // Transparent methods that contains unverifiable code is not allowed.
         MethodDesc *pMethod = GetMethod(methHnd_);
         SecurityTransparent::ThrowMethodAccessException(pMethod);
-#else // FEATURE_CORECLR        
-    //
-    // inject a full-demand for unmanaged code permission at runtime
-    // around methods in transparent assembly that contains unverifiable code
-        Security::SpecialDemand(SSWT_DECLARATIVE_DEMAND, SECURITY_UNMANAGED_CODE);
-#endif // FEATURE_CORECLR
     }
     HELPER_METHOD_FRAME_END_POLL();
 }
diff --git a/src/vm/jitinterface.cpp b/src/vm/jitinterface.cpp
index 0b3c9f2605..64471249fc 100644
--- a/src/vm/jitinterface.cpp
+++ b/src/vm/jitinterface.cpp
@@ -51,7 +51,6 @@
 #include "genericdict.h"
 #include "array.h"
 #include "debuginfostore.h"
-#include "constrainedexecutionregion.h"
 #include "security.h"
 #include "safemath.h"
 #include "runtimehandles.h"
@@ -112,8 +111,6 @@ GARY_IMPL(VMHELPDEF, hlpDynamicFuncTable, DYNAMIC_CORINFO_HELP_COUNT);
 LARGE_INTEGER g_lastTimeInJitCompilation;
 #endif
 
-BOOL canReplaceMethodOnStack(MethodDesc* pReplaced, MethodDesc* pDeclaredReplacer, MethodDesc* pExactReplacer);
-
 /*********************************************************************/
 
 inline CORINFO_MODULE_HANDLE GetScopeHandle(MethodDesc* method) 
@@ -162,24 +159,16 @@ BOOL ModifyCheckForDynamicMethod(DynamicResolver *pResolver,
     {
         *pAccessCheckType = AccessCheckOptions::kRestrictedMemberAccess;
 
-#ifdef FEATURE_CORECLR
         // For compatibility, don't do transparency checks from dynamic methods in FT CoreCLR.
         if (GetAppDomain()->GetSecurityDescriptor()->IsFullyTrusted())
             *pAccessCheckType = AccessCheckOptions::kRestrictedMemberAccessNoTransparency;
-#endif // FEATURE_CORECLR
 
-#ifdef FEATURE_COMPRESSEDSTACK
-        if (dwSecurityFlags & DynamicResolver::HasCreationContext)
-            *ppAccessContext = pResolver;
-#endif // FEATURE_COMPRESSEDSTACK
     }
     else
     {
-#ifdef FEATURE_CORECLR
         // For compatibility, don't do transparency checks from dynamic methods in FT CoreCLR.
         if (GetAppDomain()->GetSecurityDescriptor()->IsFullyTrusted())
             *pAccessCheckType = AccessCheckOptions::kNormalAccessNoTransparency;
-#endif // FEATURE_CORECLR
     }
 
     return doAccessCheck;
@@ -539,14 +528,12 @@ CEEInfo::ConvToJitSig(
         IfFailThrow(sig.GetCallingConvInfo(&data));
         sigRet->callConv = (CorInfoCallConv) data;
 
-#if defined(FEATURE_CORECLR)
         if ((isCallConv(sigRet->callConv, IMAGE_CEE_CS_CALLCONV_VARARG)) ||
             (isCallConv(sigRet->callConv, IMAGE_CEE_CS_CALLCONV_NATIVEVARARG)))
         {
             // This signature corresponds to a method that uses varargs, which are not supported.
              COMPlusThrow(kInvalidProgramException, IDS_EE_VARARG_NOT_SUPPORTED);
         }
-#endif // FEATURE_CORECLR        
 
         // Skip number of type arguments
         if (sigRet->callConv & IMAGE_CEE_CS_CALLCONV_GENERIC)
@@ -2296,11 +2283,18 @@ static unsigned ComputeGCLayout(MethodTable * pMT, BYTE* gcPtrs)
 
     // TODO: TypedReference should ideally be implemented as a by-ref-like struct containing a ByReference<T> field, in which
     // case the check for g_TypedReferenceMT below would not be necessary
-    if (pMT == g_TypedReferenceMT)
+    if (pMT == g_TypedReferenceMT || pMT->HasSameTypeDefAs(g_pByReferenceClass))
     {
-        gcPtrs[0] = TYPE_GC_BYREF;
-        gcPtrs[1] = TYPE_GC_NONE;
-        return 1;
+        if (gcPtrs[0] == TYPE_GC_NONE)
+        {
+            gcPtrs[0] = TYPE_GC_BYREF;
+            result++;
+        }
+        else if (gcPtrs[0] != TYPE_GC_BYREF)
+        {
+            COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
+        }
+        return result;
     }
 
     ApproxFieldDescIterator fieldIterator(pMT, ApproxFieldDescIterator::INSTANCE_FIELDS);
@@ -2326,22 +2320,7 @@ static unsigned ComputeGCLayout(MethodTable * pMT, BYTE* gcPtrs)
         else
         {
             MethodTable * pFieldMT = pFD->GetApproxFieldTypeHandleThrowing().AsMethodTable();
-            if (pFieldMT->HasSameTypeDefAs(g_pByReferenceClass))
-            {
-                if (gcPtrs[fieldStartIndex] == TYPE_GC_NONE)
-                {
-                    gcPtrs[fieldStartIndex] = TYPE_GC_BYREF;
-                    result++;
-                }
-                else if (gcPtrs[fieldStartIndex] != TYPE_GC_BYREF)
-                {
-                    COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
-                }
-            }
-            else
-            {
-                result += ComputeGCLayout(pFieldMT, gcPtrs + fieldStartIndex);
-            }
+            result += ComputeGCLayout(pFieldMT, gcPtrs + fieldStartIndex);
         }
     }
     return result;
@@ -5102,29 +5081,6 @@ void CEEInfo::getCallInfo(
     }
 
 
-#ifdef FEATURE_CER
-    if (pMD == g_pPrepareConstrainedRegionsMethod && !isVerifyOnly())
-    {
-        MethodDesc * methodFromContext = GetMethodFromContext(pResolvedToken->tokenContext);
-
-        if (methodFromContext != NULL && methodFromContext->IsIL())
-        {
-            SigTypeContext typeContext;
-            GetTypeContext(pResolvedToken->tokenContext, &typeContext);
-
-            // If the method whose context we're in is attempting a call to PrepareConstrainedRegions() then we've found the root
-            // method in a Constrained Execution Region (CER). Prepare the call graph of the critical parts of that method now so
-            // they won't fail because of us at runtime.
-            MethodCallGraphPreparer mcgp(methodFromContext, &typeContext, false, false);
-            bool fMethodHasCallsWithinExplicitCer = mcgp.Run();
-            if (! g_pConfig->ProbeForStackOverflow() || ! fMethodHasCallsWithinExplicitCer)
-            {
-                // if the method does not contain any CERs that call out, we can optimize the probe away
-                pMD = MscorlibBinder::GetMethod(METHOD__RUNTIME_HELPERS__PREPARE_CONSTRAINED_REGIONS_NOOP);
-            }
-        }
-    }
-#endif // FEATURE_CER
 
     TypeHandle exactType = TypeHandle(pResolvedToken->hClass);
 
@@ -5180,6 +5136,14 @@ void CEEInfo::getCallInfo(
             {
                 // Pretend this was a "constrained. UnderlyingType" instruction prefix
                 constrainedType = TypeHandle(MscorlibBinder::GetElementType(constrainedType.GetVerifierCorElementType()));
+
+                // Native image signature encoder will use this field. It needs to match that pretended type, a bogus signature
+                // would be produced otherwise.
+                pConstrainedResolvedToken->hClass = (CORINFO_CLASS_HANDLE)constrainedType.AsPtr();
+
+                // Clear the token and typespec because of they do not match hClass anymore.
+                pConstrainedResolvedToken->token = mdTokenNil;
+                pConstrainedResolvedToken->pTypeSpec = NULL;
             }
         }
 
@@ -5590,11 +5554,9 @@ void CEEInfo::getCallInfo(
         //This just throws.
         if (pCalleeForSecurity->RequiresLinktimeCheck())
         {
-#ifdef FEATURE_CORECLR
             //hostProtectionAttribute(HPA) can be removed for coreclr mscorlib.dll
             //So if the call to LinktimeCheckMethod() is only b'coz of HPA then skip it
             if (!pCalleeForSecurity->RequiresLinkTimeCheckHostProtectionOnly())
-#endif
                 Security::LinktimeCheckMethod(pCallerForSecurity->GetAssembly(), pCalleeForSecurity);
         }
 
@@ -5632,11 +5594,7 @@ void CEEInfo::getCallInfo(
                                                      pCalleeForSecurity,
                                                      NULL,
                                                      accessCheckOptions,
-#ifdef FEATURE_CORECLR
                                                      FALSE,
-#else
-                                                     TRUE,
-#endif //FEATURE_CORECLR
                                                      TRUE
                                                     );
 
@@ -5693,7 +5651,6 @@ void CEEInfo::getCallInfo(
             {
                 BOOL fNeedsTransparencyCheck = TRUE;
 
-#ifdef FEATURE_CORECLR
                 // All LCG methods are transparent in CoreCLR. When we switch from PT
                 // to FT most user assemblies will become opportunistically critical.
                 // If a LCG method calls a method in such an assembly it will stop working.
@@ -5706,7 +5663,6 @@ void CEEInfo::getCallInfo(
                 // See also AccessCheckOptions::DemandMemberAccess.
                 if (GetAppDomain()->GetSecurityDescriptor()->IsFullyTrusted() && pCallerForSecurity->IsLCGMethod())
                     fNeedsTransparencyCheck = FALSE;
-#endif // FEATURE_CORECLR
 
                 if (fNeedsTransparencyCheck)
                 {
@@ -5820,9 +5776,7 @@ BOOL CEEInfo::canAccessFamily(CORINFO_METHOD_HANDLE hCaller,
         doCheck = ModifyCheckForDynamicMethod(GetMethod(hCaller)->AsDynamicMethodDesc()->GetResolver(),
                                               &accessingType, &accessCheckOptions, &pIgnored);
         if (accessCheckOptions == AccessCheckOptions::kRestrictedMemberAccess 
-#ifdef FEATURE_CORECLR
             || accessCheckOptions == AccessCheckOptions::kRestrictedMemberAccessNoTransparency
-#endif //FEATURE_CORECLR
             )
             doCheck = FALSE;
     }
@@ -6664,12 +6618,6 @@ DWORD CEEInfo::getMethodAttribsInternal (CORINFO_METHOD_HANDLE ftn)
     if (pMD->IsLCGMethod()) 
     {
 #ifndef CROSSGEN_COMPILE
-#ifdef FEATURE_COMPRESSEDSTACK
-        if(SecurityStackWalk::MethodIsAnonymouslyHostedDynamicMethodWithCSToEvaluate(pMD))
-        {
-            return CORINFO_FLG_STATIC | CORINFO_FLG_DONT_INLINE | CORINFO_FLG_SECURITYCHECK;
-        }
-#endif // FEATURE_COMPRESSEDSTACK
 #endif // !CROSSGEN_COMPILE
 
         return CORINFO_FLG_STATIC | CORINFO_FLG_DONT_INLINE | CORINFO_FLG_NOSECURITYWRAP;
@@ -6734,39 +6682,27 @@ DWORD CEEInfo::getMethodAttribsInternal (CORINFO_METHOD_HANDLE ftn)
         result |= CORINFO_FLG_NOSECURITYWRAP;
     }
 
+    if (IsMdRequireSecObject(attribs))
+    {
+        // Assume all methods marked as DynamicSecurity are
+        // marked that way because they use StackCrawlMark to identify
+        // the caller.
+        // See comments in canInline or canTailCall
+        result |= CORINFO_FLG_DONT_INLINE_CALLER;
+    }
 
     // Check for an inlining directive.
     if (pMD->IsNotInline())
     {
         /* Function marked as not inlineable */
         result |= CORINFO_FLG_DONT_INLINE;
-
-        if (pMD->IsIL() && (IsMdRequireSecObject(attribs) ||
-            (pMD->GetModule()->IsSystem() && IsMiNoInlining(pMD->GetImplAttrs()))))
-        {
-            // Assume all methods marked as NoInline inside mscorlib are
-            // marked that way because they use StackCrawlMark to identify
-            // the caller (not just the security info).
-            // See comments in canInline or canTailCall
-            result |= CORINFO_FLG_DONT_INLINE_CALLER;
-        }
     }
-
     // AggressiveInlining only makes sense for IL methods.
     else if (pMD->IsIL() && IsMiAggressiveInlining(pMD->GetImplAttrs()))
     {
         result |= CORINFO_FLG_FORCEINLINE;
     }
 
-
-    if (!pMD->IsRuntimeSupplied())
-    {
-        if (IsMdRequireSecObject(attribs))
-        {
-            result |= CORINFO_FLG_SECURITYCHECK;
-        }
-    }
-
     if (pMT->IsDelegate() && ((DelegateEEClass*)(pMT->GetClass()))->m_pInvokeMethod == pMD)
     {
         // This is now used to emit efficient invoke code for any delegate invoke,
@@ -6990,7 +6926,6 @@ bool getILIntrinsicImplementation(MethodDesc * ftn,
             return true;
         }
     }
-#ifdef FEATURE_SPAN_OF_T
     else if (tk == MscorlibBinder::GetMethod(METHOD__JIT_HELPERS__BYREF_LESSTHAN)->GetMemberDef())
     {
         // Compare the two arguments
@@ -7022,39 +6957,10 @@ bool getILIntrinsicImplementation(MethodDesc * ftn,
         methInfo->options = (CorInfoOptions)0;
         return true;
     }
-    else if (tk == MscorlibBinder::GetMethod(METHOD__JIT_HELPERS__CONTAINSREFERENCES)->GetMemberDef())
-    {
-        _ASSERTE(ftn->HasMethodInstantiation());
-        Instantiation inst = ftn->GetMethodInstantiation();
-
-        _ASSERTE(ftn->GetNumGenericMethodArgs() == 1);
-        TypeHandle typeHandle = inst[0];
-        MethodTable * methodTable = typeHandle.GetMethodTable();
-
-        static const BYTE returnTrue[] = { CEE_LDC_I4_1, CEE_RET };
-        static const BYTE returnFalse[] = { CEE_LDC_I4_0, CEE_RET };
-
-        if (!methodTable->IsValueType() || methodTable->ContainsPointers())
-        {
-            methInfo->ILCode = const_cast<BYTE*>(returnTrue);
-        }
-        else
-        {
-            methInfo->ILCode = const_cast<BYTE*>(returnFalse);
-        }
-
-        methInfo->ILCodeSize = sizeof(returnTrue);
-        methInfo->maxStack = 1;
-        methInfo->EHcount = 0;
-        methInfo->options = (CorInfoOptions)0;
-        return true;
-    }
-#endif // FEATURE_SPAN_OF_T
 
     return false;
 }
 
-#ifdef FEATURE_SPAN_OF_T
 bool getILIntrinsicImplementationForUnsafe(MethodDesc * ftn,
                                            CORINFO_METHOD_INFO * methInfo)
 {
@@ -7144,10 +7050,19 @@ bool getILIntrinsicImplementationForUnsafe(MethodDesc * ftn,
         methInfo->options = (CorInfoOptions)0;
         return true;
     }
+    else if (tk == MscorlibBinder::GetMethod(METHOD__UNSAFE__BYREF_INIT_BLOCK_UNALIGNED)->GetMemberDef())
+    {
+        static const BYTE ilcode[] = { CEE_LDARG_0, CEE_LDARG_1, CEE_LDARG_2, CEE_PREFIX1, (CEE_UNALIGNED & 0xFF), 0x01, CEE_PREFIX1, (CEE_INITBLK & 0xFF), CEE_RET };
+        methInfo->ILCode = const_cast<BYTE*>(ilcode);
+        methInfo->ILCodeSize = sizeof(ilcode);
+        methInfo->maxStack = 3;
+        methInfo->EHcount = 0;
+        methInfo->options = (CorInfoOptions)0;
+        return true;
+    }
 
     return false;
 }
-#endif // FEATURE_SPAN_OF_T
 
 bool getILIntrinsicImplementationForVolatile(MethodDesc * ftn,
                                              CORINFO_METHOD_INFO * methInfo)
@@ -7292,6 +7207,47 @@ bool getILIntrinsicImplementationForInterlocked(MethodDesc * ftn,
     return true;
 }
 
+bool getILIntrinsicImplementationForRuntimeHelpers(MethodDesc * ftn,
+    CORINFO_METHOD_INFO * methInfo)
+{
+    STANDARD_VM_CONTRACT;
+
+    // Precondition: ftn is a method in mscorlib 
+    _ASSERTE(ftn->GetModule()->IsSystem());
+
+    mdMethodDef tk = ftn->GetMemberDef();
+
+    if (tk == MscorlibBinder::GetMethod(METHOD__RUNTIME_HELPERS__IS_REFERENCE_OR_CONTAINS_REFERENCES)->GetMemberDef())
+    {
+        _ASSERTE(ftn->HasMethodInstantiation());
+        Instantiation inst = ftn->GetMethodInstantiation();
+
+        _ASSERTE(ftn->GetNumGenericMethodArgs() == 1);
+        TypeHandle typeHandle = inst[0];
+        MethodTable * methodTable = typeHandle.GetMethodTable();
+
+        static const BYTE returnTrue[] = { CEE_LDC_I4_1, CEE_RET };
+        static const BYTE returnFalse[] = { CEE_LDC_I4_0, CEE_RET };
+
+        if (!methodTable->IsValueType() || methodTable->ContainsPointers())
+        {
+            methInfo->ILCode = const_cast<BYTE*>(returnTrue);
+        }
+        else
+        {
+            methInfo->ILCode = const_cast<BYTE*>(returnFalse);
+        }
+
+        methInfo->ILCodeSize = sizeof(returnTrue);
+        methInfo->maxStack = 1;
+        methInfo->EHcount = 0;
+        methInfo->options = (CorInfoOptions)0;
+        return true;
+    }
+
+    return false;
+}
+
 //---------------------------------------------------------------------------------------
 // 
 //static
@@ -7329,12 +7285,10 @@ getMethodInfoHelper(
         {
             fILIntrinsic = getILIntrinsicImplementation(ftn, methInfo);
         }
-#ifdef FEATURE_SPAN_OF_T
         else if (MscorlibBinder::IsClass(pMT, CLASS__UNSAFE))
         {
             fILIntrinsic = getILIntrinsicImplementationForUnsafe(ftn, methInfo);
         }
-#endif
         else if (MscorlibBinder::IsClass(pMT, CLASS__INTERLOCKED))
         {
             fILIntrinsic = getILIntrinsicImplementationForInterlocked(ftn, methInfo);
@@ -7343,6 +7297,10 @@ getMethodInfoHelper(
         {
             fILIntrinsic = getILIntrinsicImplementationForVolatile(ftn, methInfo);
         }
+        else if (MscorlibBinder::IsClass(pMT, CLASS__RUNTIME_HELPERS))
+        {
+            fILIntrinsic = getILIntrinsicImplementationForRuntimeHelpers(ftn, methInfo);
+        }
 
         if (!fILIntrinsic)
         {
@@ -7631,28 +7589,6 @@ CorInfoInline CEEInfo::canInline (CORINFO_METHOD_HANDLE hCaller,
     _ASSERTE(!(CORINFO_FLG_DONT_INLINE & getMethodAttribsInternal(hCallee)));
 #endif
 
-    // Returns TRUE: if caller and callee are from the same assembly or the callee
-    //               is part of the system assembly.
-    //
-    // If the caller and callee have the same Critical state and the same Grant (and refuse) sets, then the
-    // callee may always be inlined into the caller.
-    //
-    // If they differ, then the callee is marked as INLINE_RESPECT_BOUNDARY.  The Jit may only inline the
-    // callee when any of the following are true.
-    //  1) the callee is a leaf method.
-    //  2) the callee does not call any Boundary Methods.
-    //
-    // Conceptually, a Boundary method is a method that needs to accurately find the permissions of its
-    // caller.  Boundary methods are:
-    //
-    //  1) A method that calls anything that creates a StackCrawlMark to look for its caller.  In this code
-    //      this is approximated as "in mscorlib and is marked as NoInlining".
-    //  2) A method that calls a method which calls Demand.  These methods must be marked as
-    //      IsMdRequireSecObject.
-    //  3) Calls anything that is virtual.  This is because the virtual method could be #1 or #2.
-    //
-    // In CoreCLR, all public Critical methods of mscorlib are considered Boundary Method
-
     MethodDesc* pCaller = GetMethod(hCaller);
     MethodDesc* pCallee = GetMethod(hCallee);
 
@@ -7716,7 +7652,7 @@ CorInfoInline CEEInfo::canInline (CORINFO_METHOD_HANDLE hCaller,
     if (IsMdRequireSecObject(pCallee->GetAttrs())) 
     {
         result = INLINE_NEVER;
-        szFailReason = "Inlinee requires a security object (calls Demand/Assert/Deny)";
+        szFailReason = "Inlinee requires a security object (or contains StackCrawlMark)";
         goto exit;
     }
 
@@ -7747,7 +7683,7 @@ CorInfoInline CEEInfo::canInline (CORINFO_METHOD_HANDLE hCaller,
 
 #ifdef _DEBUG
         //
-        // Make sure that all methods with StackCrawlMark are marked as non-inlineable
+        // Make sure that all methods with StackCrawlMark are marked as IsMdRequireSecObject
         //
         if (pCalleeAssembly->IsSystem())
         {
@@ -7790,11 +7726,6 @@ CorInfoInline CEEInfo::canInline (CORINFO_METHOD_HANDLE hCaller,
         }
 #endif  // FEATURE_PREJIT
 
-        if (!canReplaceMethodOnStack(pCallee, NULL, pCaller))
-        {
-            dwRestrictions |= INLINE_RESPECT_BOUNDARY;
-        }
-
         // TODO: We can probably be smarter here if the caller is jitted, as we will
         // know for sure if the inlinee has really no string interning active (currently
         // it's only on in the ngen case (besides requiring the attribute)), but this is getting
@@ -8173,159 +8104,6 @@ CorInfoInstantiationVerification
     return result;
 }
 
-// This function returns true if we can replace pReplaced on the stack with
-// pReplacer.  In the case of inlining this means that pReplaced is the inlinee
-// and pReplacer is the inliner.  In the case of tail calling, pReplacer is the
-// tail callee and pReplaced is the tail caller.
-//
-// It's possible for pReplacer to be NULL.  This means that it's an unresolved
-// callvirt for a tail call.  This is legal, but we make the static decision
-// based on pReplaced only (assuming that pReplacer is from a different
-// assembly that is a different partial trust).
-//
-// The general logic is this:
-//   1) You can replace anything that is full trust (since full trust doesn't
-//      cause a demand to fail).
-//   2) You can coalesce all stack frames that have the same permission set
-//      down to a single stack frame.
-//
-// You'll see three patterns in the code below:
-//   1) There is only one permission set per assembly
-//   2) Comparing grant sets is prohibitively expensive.  Therefore we use the
-//      the fact that, "a homogenous app domain has only one partial trust
-//      permission set" to infer that two grant sets are equal.
-//   3) Refuse sets are rarely used and too complex to handle correctly, so
-//      they generally just torpedo all of the logic in here.
-//
-BOOL canReplaceMethodOnStack(MethodDesc* pReplaced, MethodDesc* pDeclaredReplacer, MethodDesc* pExactReplacer)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_PREEMPTIVE; //Called from PREEMPTIVE functions
-    } CONTRACTL_END;
-
-    OBJECTREF refused = NULL;
-    Assembly * pReplacedAssembly = pReplaced->GetAssembly();
-
-    _ASSERTE(Security::IsResolved(pReplacedAssembly));
-
-    // The goal of this code is to ensure that we never allow a unique non-full
-    // trust grant set to be eliminated from the stack.
-
-    Assembly * pReplacerAssembly = NULL;
-    if (pExactReplacer != NULL)
-    {
-        pReplacerAssembly = pExactReplacer->GetAssembly();
-        _ASSERTE(Security::IsResolved(pReplacerAssembly));
-
-        // If two methods are from the same assembly, they must have the same grant set.
-        if (pReplacerAssembly == pReplacedAssembly)
-        {
-            // When both methods are in the same assembly, then it is always safe to
-            // coalesce them for the purposes of security.
-            return TRUE;
-        }
-    }
-
-    if ( pDeclaredReplacer != NULL &&
-         pReplacedAssembly->GetDomainAssembly() == GetAppDomain()->GetAnonymouslyHostedDynamicMethodsAssembly() &&
-         SystemDomain::IsReflectionInvocationMethod(pDeclaredReplacer) )
-    {
-        // When an anonymously hosted dynamic method invokes a method through reflection invocation,
-        // the dynamic method is the true caller. If we replace it on the stack we would be doing 
-        // security check against its caller rather than the dynamic method itself. 
-        // We should do this check against pDeclaredReplacer rather than pExactReplacer because the
-        // latter is NULL is the former if virtual, e.g. MethodInfo.Invoke(...).
-        return FALSE;
-    }
-
-    // It is always safe to remove a full trust stack frame from the stack.
-    IAssemblySecurityDescriptor * pReplacedDesc = pReplacedAssembly->GetSecurityDescriptor();
-
-#ifdef FEATURE_APTCA
-    if (GetAppDomain()->IsCompilationDomain())
-    {
-        // If we're NGENing assemblies, we don't want to inline code out of a conditionally APTCA assembly,
-        // since we need to ensure that the dependency is loaded and checked to ensure that it is condtional
-        // APTCA.  We only need to do this if the replaced caller is transparent, since a critical caller
-        // will be allowed to use the conditional APTCA disabled assembly anyway.
-        if (pReplacedAssembly != pReplacerAssembly && Security::IsMethodTransparent(pReplaced))
-        {
-            ModuleSecurityDescriptor *pReplacedMSD = ModuleSecurityDescriptor::GetModuleSecurityDescriptor(pReplacedAssembly);
-            if (pReplacedMSD->GetTokenFlags() & TokenSecurityDescriptorFlags_ConditionalAPTCA)
-            {
-                return FALSE;
-            }
-        }
-    }
-#endif // FEATURE_APTCA
-
-    if (pReplacedDesc->IsFullyTrusted())
-    {
-        GCX_COOP(); // Required for GetGrantedPermissionSet
-        (void)pReplacedDesc->GetGrantedPermissionSet(&refused);
-        if (refused != NULL)
-        {
-            // This is full trust with a Refused set.  That means that it is partial
-            // trust.  However, even in a homogeneous app domain, it could be a
-            // different partial trust from any other partial trust, and since
-            // pExactReplacer is either unknown or from a different assembly, we assume
-            // the worst: that is is a different partial trust.
-            return FALSE;
-        }
-        return TRUE;
-    }
-
-    // pReplaced is partial trust and pExactReplacer is either unknown or from a
-    // different assembly than pReplaced.
-
-    if (pExactReplacer == NULL)
-    {
-        // This is the unresolved callvirt case.  Since we're partial trust,
-        // we can't tail call.
-        return FALSE;
-    }
-
-    // We're replacing a partial trust stack frame.  We can only do this with a
-    // matching grant set. We know pReplaced is partial trust.  Make sure both
-    // pExactReplacer and pReplaced are the same partial trust.
-    IAssemblySecurityDescriptor * pReplacerDesc = pReplacerAssembly->GetSecurityDescriptor();
-    if (pReplacerDesc->IsFullyTrusted())
-    {
-        return FALSE; // Replacing partial trust with full trust.
-    }
-
-    // At this point both pExactReplacer and pReplaced are partial trust.  We can
-    // only do this if the grant sets are equal.  Since comparing grant sets
-    // requires calling up into managed code, we will infer that the two grant
-    // sets are equal if the domain is homogeneous.
-    IApplicationSecurityDescriptor * adSec = GetAppDomain()->GetSecurityDescriptor();
-    if (adSec->IsHomogeneous())
-    {
-        // We're homogeneous, but the two descriptors could have refused sets.
-        // Bail if they do.
-        GCX_COOP(); // Required for GetGrantedPermissionSet
-        (void)pReplacedDesc->GetGrantedPermissionSet(&refused);
-        if (refused != NULL)
-        {
-            return FALSE;
-        }
-
-        (void)pReplacerDesc->GetGrantedPermissionSet(&refused);
-        if (refused != NULL)
-            return FALSE;
-
-        return TRUE;
-    }
-
-    // pExactReplacer and pReplaced are from 2 different assemblies.  Both are partial
-    // trust, and the app domain is not homogeneous, so we just have to
-    // assume that they have different grant or refuse sets, and thus cannot
-    // safely be replaced.
-    return FALSE;
-}
-
 /*************************************************************
  * Similar to above, but perform check for tail call
  * eligibility. The callee can be passed as NULL if not known
@@ -8382,16 +8160,6 @@ bool CEEInfo::canTailCall (CORINFO_METHOD_HANDLE hCaller,
         goto exit;
     }
 
-    // The jit already checks and doesn't allow the tail caller to use imperative security.
-    _ASSERTE(pCaller->IsRuntimeSupplied() || !IsMdRequireSecObject(pCaller->GetAttrs()));
-
-    if (!canReplaceMethodOnStack(pCaller, pDeclaredCallee, pExactCallee))
-    {
-        result = false;
-        szFailReason = "Different security";
-        goto exit;
-    }
-
     if (!fIsTailPrefix)        
     {
         mdMethodDef callerToken = pCaller->GetMemberDef();
@@ -8423,37 +8191,18 @@ bool CEEInfo::canTailCall (CORINFO_METHOD_HANDLE hCaller,
 
         // Methods with StackCrawlMark depend on finding their caller on the stack.
         // If we tail call one of these guys, they get confused.  For lack of
-        // a better way of identifying them, we look for methods marked as NoInlining
-        // inside mscorlib (StackCrawlMark is private), and assume it is one of these
-        // methods.  We have an assert in canInline that ensures all StackCrawlMark
+        // a better way of identifying them, we use DynamicSecurity attribute to identify
+        // them. We have an assert in canInline that ensures all StackCrawlMark
         // methods are appropriately marked.
         //
-        // NOTE that this is *NOT* a security issue because we check to ensure that
-        // the callee has the *SAME* security properties as the caller, it just might
-        // be from a different assembly which messes up APIs like Type.GetType, which
-        // for back-compat uses the assembly of it's caller to resolve unqualified
-        // typenames.
-        if ((pExactCallee != NULL) && pExactCallee->GetModule()->IsSystem() && pExactCallee->IsIL())
+        if ((pExactCallee != NULL) && IsMdRequireSecObject(pExactCallee->GetAttrs()))
         {
-            if (IsMiNoInlining(pExactCallee->GetImplAttrs()))
-            {
-                result = false;
-                szFailReason = "Callee might have a StackCrawlMark.LookForMyCaller";
-                goto exit;
-            }
+            result = false;
+            szFailReason = "Callee might have a StackCrawlMark.LookForMyCaller";
+            goto exit;
         }
     }
 
-#ifdef FEATURE_CER
-    // We cannot tail call from a root CER method, the thread abort algorithm to
-    // detect CERs depends on seeing such methods on the stack.
-    if (IsCerRootMethod(pCaller))
-    {
-        result = false;
-        szFailReason = "Caller is a CER root";
-        goto exit;
-    }
-#endif // FEATURE_CER
 
     result = true;
 
@@ -9105,10 +8854,15 @@ CorInfoType CEEInfo::getFieldTypeInternal (CORINFO_FIELD_HANDLE fieldHnd,
     // <REVISIT_TODO>TODO should not burn the time to do this for anything but Value Classes</REVISIT_TODO>
     _ASSERTE(type != ELEMENT_TYPE_BYREF);
 
-    // For verifying code involving generics, use the class instantiation
-    // of the optional owner (to provide exact, not representative,
-    // type information)
-    SigTypeContext typeContext(field, (TypeHandle) owner);
+    if (type == ELEMENT_TYPE_I)
+    {
+        PTR_MethodTable enclosingMethodTable = field->GetApproxEnclosingMethodTable();
+        if (enclosingMethodTable->IsByRefLike() && enclosingMethodTable->HasSameTypeDefAs(g_pByReferenceClass))
+        {
+            _ASSERTE(field->GetOffset() == 0);
+            return CORINFO_TYPE_BYREF;
+        }
+    }
 
     if (!CorTypeInfo::IsPrimitiveType(type))
     {
@@ -9118,11 +8872,16 @@ CorInfoType CEEInfo::getFieldTypeInternal (CORINFO_FIELD_HANDLE fieldHnd,
 
         field->GetSig(&sig, &sigCount);
 
-         conv = (CorCallingConvention) CorSigUncompressCallingConv(sig);
+        conv = (CorCallingConvention)CorSigUncompressCallingConv(sig);
         _ASSERTE(isCallConv(conv, IMAGE_CEE_CS_CALLCONV_FIELD));
 
         SigPointer ptr(sig, sigCount);
 
+        // For verifying code involving generics, use the class instantiation
+        // of the optional owner (to provide exact, not representative,
+        // type information)
+        SigTypeContext typeContext(field, (TypeHandle)owner);
+
         clsHnd = ptr.GetTypeHandleThrowing(field->GetModule(), &typeContext);
         _ASSERTE(!clsHnd.IsNull());
 
@@ -9966,11 +9725,7 @@ void CEEInfo::getEEInfo(CORINFO_EE_INFO *pEEInfoOut)
 
     pEEInfoOut->osPageSize = OS_PAGE_SIZE;
     pEEInfoOut->maxUncheckedOffsetForNullObject = MAX_UNCHECKED_OFFSET_FOR_NULL_OBJECT;
-#if defined(FEATURE_CORECLR)
     pEEInfoOut->targetAbi = CORINFO_CORECLR_ABI;
-#else
-    pEEInfoOut->targetAbi = CORINFO_DESKTOP_ABI;
-#endif
 
     OSVERSIONINFO   sVerInfo;
     sVerInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
@@ -11985,10 +11740,6 @@ CorJitResult invokeCompileMethodHelper(EEJitManager *jitMgr,
 
     CorJitResult ret = CORJIT_SKIPPED;   // Note that CORJIT_SKIPPED is an error exit status code
 
-#if !defined(FEATURE_CORECLR)
-    // Ask the JIT to generate desktop-quirk-compatible code.
-    jitFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_DESKTOP_QUIRKS);
-#endif
 
     comp->setJitFlags(jitFlags);
 
@@ -12000,14 +11751,6 @@ CorJitResult invokeCompileMethodHelper(EEJitManager *jitMgr,
 
     BEGIN_SO_TOLERANT_CODE(GetThread());
 
-#if defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)
-    ret = getJit()->compileMethod( comp,
-                                   info,
-                                   CORJIT_FLAGS::CORJIT_FLAG_CALL_GETJITFLAGS,
-                                   nativeEntry,
-                                   nativeSizeOfCode);
-
-#else // defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)
 
 #if defined(ALLOW_SXS_JIT) && !defined(CROSSGEN_COMPILE)
     if (FAILED(ret) && jitMgr->m_alternateJit
@@ -12105,7 +11848,6 @@ CorJitResult invokeCompileMethodHelper(EEJitManager *jitMgr,
     }
 #endif // !defined(CROSSGEN_COMPILE)
     
-#endif // defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)
 
 #if defined(FEATURE_GDBJIT)
     if (SUCCEEDED(ret) && *nativeEntry != NULL)
@@ -12312,12 +12054,10 @@ CORJIT_FLAGS GetDebuggerCompileFlags(Module* pModule, CORJIT_FLAGS flags)
 {
     STANDARD_VM_CONTRACT;
 
-#ifdef FEATURE_CORECLR
     //Right now if we don't have a debug interface on CoreCLR, we can't generate debug info.  So, in those
     //cases don't attempt it.
     if (!g_pDebugInterface)
         return flags;
-#endif //FEATURE_CORECLR
 
 #ifdef DEBUGGING_SUPPORTED
 
diff --git a/src/vm/jitinterface.h b/src/vm/jitinterface.h
index 6cc3a05fba..d6dd5d2e65 100644
--- a/src/vm/jitinterface.h
+++ b/src/vm/jitinterface.h
@@ -391,8 +391,7 @@ void ValidateWriteBarrierHelpers();
 
 extern "C"
 {
-#ifdef _TARGET_X86_
-    // UNIXTODO: Disable JIT_EndCatch after revising the jitter not to use this (for x86/Linux)
+#ifndef WIN64EXCEPTIONS
     void STDCALL JIT_EndCatch();               // JIThelp.asm/JIThelp.s
 #endif // _TARGET_X86_
 
@@ -414,59 +413,11 @@ extern "C"
     void STDCALL JIT_ProfilerEnterLeaveTailcallStub(UINT_PTR ProfilerHandle);
 };
 
-#ifndef FEATURE_CORECLR
-//
-// Obfluscators that are hacking into the JIT expect certain methods to exist in certain places of CEEInfo vtable. Add artifical slots 
-// to the vtable to avoid breaking apps by .NET 4.5 in-place update.
-//
-
-class ICorMethodInfo_Hack
-{
-public:
-    virtual const char* __stdcall ICorMethodInfo_Hack_getMethodName (CORINFO_METHOD_HANDLE ftnHnd, const char** scopeName) = 0;
-};
-
-class ICorModuleInfo_Hack
-{
-public:
-    virtual void ICorModuleInfo_Hack_dummy() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
-};
-
-class ICorClassInfo_Hack
-{
-public:
-    virtual void ICorClassInfo_Hack_dummy1() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
-    virtual void ICorClassInfo_Hack_dummy2() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
-    virtual void ICorClassInfo_Hack_dummy3() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
-    virtual void ICorClassInfo_Hack_dummy4() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
-    virtual void ICorClassInfo_Hack_dummy5() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
-    virtual void ICorClassInfo_Hack_dummy6() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
-    virtual void ICorClassInfo_Hack_dummy7() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
-    virtual void ICorClassInfo_Hack_dummy8() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
-    virtual void ICorClassInfo_Hack_dummy9() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
-    virtual void ICorClassInfo_Hack_dummy10() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
-    virtual void ICorClassInfo_Hack_dummy11() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
-    virtual void ICorClassInfo_Hack_dummy12() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
-    virtual void ICorClassInfo_Hack_dummy13() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
-    virtual void ICorClassInfo_Hack_dummy14() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
-
-    virtual mdMethodDef __stdcall ICorClassInfo_Hack_getMethodDefFromMethod(CORINFO_METHOD_HANDLE hMethod) = 0;
-};
-
-class ICorStaticInfo_Hack : public virtual ICorMethodInfo_Hack, public virtual ICorModuleInfo_Hack, public virtual ICorClassInfo_Hack
-{
-    virtual void ICorStaticInfo_Hack_dummy() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
-};
-
-#endif // FEATURE_CORECLR
 
 
 /*********************************************************************/
 /*********************************************************************/
 class CEEInfo : public ICorJitInfo
-#ifndef FEATURE_CORECLR
-    , public virtual ICorStaticInfo_Hack
-#endif
 {
     friend class CEEDynamicCodeInfo;
     
diff --git a/src/vm/mda.cpp b/src/vm/mda.cpp
deleted file mode 100644
index 77c26a993e..0000000000
--- a/src/vm/mda.cpp
+++ /dev/null
@@ -1,4017 +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.
-
-
-#include "common.h"
-#include "eeconfig.h"
-#include "eeconfigfactory.h"
-#include "corhlpr.h"
-#include <xmlparser.h>
-#include <mscorcfg.h>
-#include <holder.h>
-#include <dbginterface.h>
-#include "wrappers.h"
-#include "mda.h"
-#include "mdaassistants.h"
-#include "sstring.h"
-#include "util.hpp"
-#include "debugdebugger.h"
-
-#ifdef MDA_SUPPORTED
-
-//
-// MdaHashtable
-//
-
-BOOL MdaLockOwner(LPVOID) { LIMITED_METHOD_CONTRACT; return TRUE; }
-
-BOOL IsJustMyCode(MethodDesc* pMethodDesc)
-{
-    CONTRACT(BOOL)
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACT_END;
-
-    if (!ManagedDebuggingAssistants::IsManagedDebuggerAttached())
-        return TRUE;
-
-    BOOL bIsJMC = FALSE;
-
-    EX_TRY
-    {
-        if (g_pDebugInterface && g_pDebugInterface->IsJMCMethod(pMethodDesc->GetModule(), pMethodDesc->GetMemberDef()))
-            bIsJMC = TRUE;
-    }
-    EX_CATCH
-    {
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-
-    RETURN bIsJMC;
-}
-
-
-//
-// ManagedDebuggingAssistants
-//
-
-const bool g_mdaAssistantIsSwitch[] =
-{
-#define MDA_ASSISTANT_IS_SWITCH
-#include "mdaschema.inl"
-#undef MDA_ASSISTANT_IS_SWITCH
-    false
-};
-
-void ManagedDebuggingAssistants::Initialize()
-{
-    CONTRACT_VOID
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACT_END;
-
-    EX_TRY
-    {
-        //
-        // Initialize
-        //
-        m_pSwitchActivationXml = NULL;
-        m_pMdaXmlIndustry = new MdaXmlIndustry();
-
-        MdaSchema::Initialize();
-
-        //
-        // Create AssistantSchema
-        //
-        m_pAssistantSchema = new MdaAssistantSchema();
-
-        //
-        // Create AssistantMsgSchema
-        //
-        m_pAssistantMsgSchema = new MdaAssistantMsgSchema();
-
-        //
-        // Create SchemaSchema
-        //
-        m_pSchemaSchema = new MdaSchemaSchema();
-
-        //
-        // InvalidConfigFile
-        //
-        g_mdaStaticHeap.m_mdaInvalidConfigFile.Enable();
-
-#ifdef _DEBUG
-        StackSString sszValidateFramework(CLRConfig::GetConfigValue(CLRConfig::INTERNAL_MDAValidateFramework));
-        if (!sszValidateFramework.IsEmpty() && sszValidateFramework.Equals(W("1")))
-            DebugInitialize();
-#endif
-    }
-    EX_CATCH
-    {
-        // MDA State corrupted, unable to initialize, runtime still OK
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-
-    RETURN;
-}
-
-MdaEnvironment::~MdaEnvironment()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (m_pStringFactory)
-        delete m_pStringFactory;
-
-    if (m_pGroups)
-        delete m_pGroups;
-
-    if (m_szMda)
-        delete m_szMda;
-}
-
-MdaEnvironment::MdaEnvironment()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    m_bDisable = TRUE;
-    m_szMda = CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_MDA);
-    m_pStringFactory = NULL;
-    m_pGroups = NULL;
-
-    if (ManagedDebuggingAssistants::IsManagedDebuggerAttached())
-    {
-        if (m_pStringFactory == NULL)
-            m_pStringFactory = new MdaFactory<StackSString>();
-
-        if (m_pGroups == NULL)
-            m_pGroups = new SArray<SString*>();
-
-        SString* pStr = m_pStringFactory->Create();
-        pStr->Set(W("managedDebugger"));
-        m_pGroups->Append(pStr);
-        m_bDisable = FALSE;
-    }
-
-    if (ManagedDebuggingAssistants::IsUnmanagedDebuggerAttached())
-    {
-        if (m_pStringFactory == NULL)
-            m_pStringFactory = new MdaFactory<StackSString>();
-
-        if (m_pGroups == NULL)
-            m_pGroups = new SArray<SString*>();
-
-        SString* pStr = m_pStringFactory->Create();
-        pStr->Set(W("unmanagedDebugger"));
-        m_pGroups->Append(pStr);
-        m_bDisable = FALSE;
-    }
-
-    if (m_szMda)
-    {
-        if (m_pStringFactory == NULL)
-            m_pStringFactory = new MdaFactory<StackSString>();
-
-        if (m_pGroups == NULL)
-            m_pGroups = new SArray<SString*>();
-
-        StackSString sszMda(m_szMda);
-        SString::Iterator s = sszMda.Begin();
-        SString::Iterator e = s;
-
-        while (true)
-        {
-            if (!sszMda.Find(e, W(';')))
-                e = sszMda.End();
-            SString* psszGroup = m_pStringFactory->Create();
-            psszGroup->Set(sszMda, s, e);
-
-            if (psszGroup->Equals(W("0")))
-            {
-                m_pGroups->Clear();
-                m_bDisable = TRUE;
-            }
-            else
-            {
-                m_pGroups->Append(psszGroup);
-                
-                m_bDisable = FALSE;
-            }
-
-            if (e == sszMda.End())
-                break;
-            s = ++e;
-        }
-    }
-
-    if (m_bDisable == FALSE)
-    {
-        // If we get here, m_pStringFactory should already have been created.
-        _ASSERTE(m_pStringFactory != NULL);
-
-        WCHAR szExe[_MAX_PATH];
-        if (!WszGetModuleFileName(NULL, szExe, _MAX_PATH))
-            return;
-
-        // Construct file name of the config file
-        m_psszConfigFile = m_pStringFactory->Create();
-        m_psszConfigFile->Set(szExe);
-        m_psszConfigFile->Append(W(".config"));
-
-        // Construct file name of mda config file
-        m_psszMdaConfigFile = m_pStringFactory->Create();
-        m_psszMdaConfigFile->Set(szExe);
-        m_psszMdaConfigFile->Append(W(".mda.config"));
-    }
-}
-
-void ManagedDebuggingAssistants::EEStartupActivation()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    //
-    // Read environment variable, then registry settings
-    //
-    MdaEnvironment env;
-
-    if (env.IsDisabled())
-        return;
-
-    AllocateManagedDebuggingAssistants();
-
-    //
-    // ConfigFile Activation
-    //
-    g_mdaStaticHeap.m_pMda->EnvironmentActivation(&env);
-}
-
-#ifdef _DEBUG
-void ManagedDebuggingAssistants::DebugInitialize()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        SO_INTOLERANT;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    //
-    // Validate MDA output on Debug builds
-    //
-    m_bValidateOutput = TRUE;
-
-    //
-    // XmlValidationError
-    //
-    g_mdaStaticHeap.m_mdaXmlValidationError.Enable();
-
-    MdaSchema::ValidationResult validationResult;
-
-    //
-    // Validate SchemaScheam
-    //
-    MdaXmlElement* pXmlSchemaSchema = m_pSchemaSchema->ToXml(m_pMdaXmlIndustry);
-    if (m_pSchemaSchema->Validate(pXmlSchemaSchema, &validationResult)->ValidationFailed())
-    {
-        MDA_TRIGGER_ASSISTANT(XmlValidationError, ReportError(&validationResult));
-        UNREACHABLE();
-    }
-
-    //
-    // Validate AssistantSchema
-    //
-    MdaXmlElement* pXmlAssistantSchema = m_pAssistantSchema->ToXml(m_pMdaXmlIndustry);
-    if (m_pSchemaSchema->Validate(pXmlAssistantSchema, &validationResult)->ValidationFailed())
-    {
-        MDA_TRIGGER_ASSISTANT(XmlValidationError, ReportError(&validationResult));
-        ASSERT(!W("You're modifications to MdaAssistantSchema for assistant input don't conform to XSD"));
-    }
-
-    //
-    // Validate AssistantMsgSchema
-    //
-    MdaXmlElement* pXmlAssistantMsgSchema = m_pAssistantMsgSchema->ToXml(m_pMdaXmlIndustry);
-    if (m_pSchemaSchema->Validate(pXmlAssistantMsgSchema, &validationResult)->ValidationFailed())
-    {
-        MDA_TRIGGER_ASSISTANT(XmlValidationError, ReportError(&validationResult));
-        ASSERT(!W("You're modifications to MdaAssistantSchema for assistant output don't conform to XSD"));
-    }
-}
-#endif
-
-void ManagedDebuggingAssistants::ConfigFileActivation(LPCWSTR szConfigFile, MdaXmlIndustry* pXmlIndustry, MdaHashtable<MdaXmlElement*>* pMdaXmlPairs)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    // Parse
-    MdaSchema::ValidationResult validationResult;
-    MdaXmlElement* pMdaConfig = MdaConfigFactory::ParseXmlStream(pXmlIndustry, szConfigFile);
-    if (!pMdaConfig)
-        return;
-
-    // Validate
-    if (m_pAssistantSchema->Validate(pMdaConfig, &validationResult)->ValidationFailed())
-    {
-        MDA_TRIGGER_ASSISTANT(InvalidConfigFile, ReportError(MdaElemDef(MdaConfig)));
-        g_mdaStaticHeap.DisableAll();
-        return;
-    }
-
-    // Activate
-    InlineSArray<MdaXmlElement*, MdaElemDef(Max)> xmlMdaConfigs;
-    MdaXPath::FindElements(pMdaConfig, W("/mdaConfig/assistants/*"), &xmlMdaConfigs);
-    for(COUNT_T i = 0; i < xmlMdaConfigs.GetCount(); i ++)
-    {
-        MdaXmlElement* pXmlMdaConfig = xmlMdaConfigs[i];
-        if (pXmlMdaConfig->GetAttribute(MdaAttrDecl(Enable))->GetValueAsBool())
-        {
-            pMdaXmlPairs->Set(pXmlMdaConfig->GetName(), xmlMdaConfigs[i]);
-        }
-        else
-        {
-            if (pMdaXmlPairs->HasKey(pXmlMdaConfig->GetName()))
-                pMdaXmlPairs->DeleteValue(pXmlMdaConfig->GetName());
-        }
-    }
-}
-
-MdaXmlElement* ManagedDebuggingAssistants::GetSwitchActivationXml(MdaElemDeclDef mda)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (g_mdaAssistantIsSwitch[mda])
-    {
-        MdaXmlElement* pXml = m_pMdaXmlIndustry->CreateElement()->SetDeclDef(mda);
-        pXml->AddAttributeBool(MdaAttrDecl(Enable), TRUE);
-        return pXml;
-    }
-    else
-    {
-        if (!m_pSwitchActivationXml)
-        {
-            MdaXmlElement* pXmlMdaConfig = m_pMdaXmlIndustry->CreateElement()->SetDeclDef(MdaElemDef(MdaConfig));
-            m_pSwitchActivationXml = pXmlMdaConfig->AddChild(MdaElemDecl(Assistants));
-
-            for (COUNT_T i = 0; i < MdaElemDef(AssistantMax); i ++)
-                m_pSwitchActivationXml->AddChild((MdaElemDeclDef)i);
-
-            MdaSchema::ValidationResult validationResult;
-
-            // Validating the schema has the side-effect of initializing the default XML attributes
-            if (m_pAssistantSchema->Validate(pXmlMdaConfig, &validationResult)->ValidationFailed())
-               ASSERT(!W("MDA Assistant must allow <Assistant /> form."));
-        }
-
-        return m_pSwitchActivationXml->GetChild(mda);
-    }
-}
-
-void ManagedDebuggingAssistants::ActivateGroup(LPCWSTR groupName, SArray<MdaElemDeclDef>* pGroupMdaXmlParis, MdaHashtable<MdaXmlElement*>* pActivationMdaXmlPairs)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    StackSString sszGroupName(groupName);
-    BOOL bIsManagedDebuggerSet = sszGroupName.EqualsCaseInsensitive(W("managedDebugger"));
-    
-    SArray<MdaElemDeclDef>& groupMdaXmlParis = *pGroupMdaXmlParis;
-
-    for (COUNT_T i = 0; i < groupMdaXmlParis.GetCount(); i++)
-    {
-        MdaElemDeclDef mda = groupMdaXmlParis[i];
-        MdaXmlElement* pSwitchActivationXml = GetSwitchActivationXml(mda);
-
-        PREFIX_ASSUME(pSwitchActivationXml != NULL);
-            
-        pSwitchActivationXml->AddAttributeBool(MdaAttrDecl(SuppressDialog), bIsManagedDebuggerSet);
-        
-        pActivationMdaXmlPairs->Set(MdaSchema::g_arElementNames[mda], pSwitchActivationXml);
-    }
-}
-
-LPCWSTR ToLowerFirstChar(LPCWSTR name, MdaFactory<SString>* pSstringFactory)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    ASSERT(*name >= 'A' && *name <= 'Z');
-
-    SString* pOutput = pSstringFactory->Create();
-    pOutput->Clear();
-    pOutput->Append(*name - W('A') + W('a'));
-    pOutput->Append(&name[1]);
-    return pOutput->GetUnicode();
-}
-
-void ManagedDebuggingAssistants::EnvironmentActivation(MdaEnvironment* pEnvironment)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (pEnvironment->GetActivationMechanisms().GetCount() == 0)
-        return;
-
-    MdaFactory<StackSArray<MdaElemDeclDef> > arrayFactory;
-    MdaFactory<SString> sstringFactory;
-    MdaHashtable<MdaXmlElement*> mdaXmlPairs;
-
-    // Activate
-    SArray<SString*>& aActivationMechanisms = pEnvironment->GetActivationMechanisms();
-    SArray<MdaElemDeclDef>* pGroup = NULL;
-    StackSArray<SArray<MdaElemDeclDef>* > aGroups;
-
-#define MDA_DEFINE_GROUPS
-#include "mdaschema.inl"
-#undef MDA_DEFINE_GROUPS
-
-    // Match COMPlus_MDA env var to group
-    for (COUNT_T i = 0; i < aActivationMechanisms.GetCount(); i++)
-    {
-        SString& sszActivationMechanism = *aActivationMechanisms[i];
-
-        if (sszActivationMechanism.EqualsCaseInsensitive(W("ConfigFile")) || sszActivationMechanism.EqualsCaseInsensitive(W("1")))
-        {
-            ConfigFileActivation(pEnvironment->GetMdaConfigFile(), m_pMdaXmlIndustry, &mdaXmlPairs);
-        }
-        else
-        {
-            COUNT_T cGroup = 0;
-
-#define MDA_ACTIVATE_GROUPS
-#include "mdaschema.inl"
-#undef MDA_ACTIVATE_GROUPS
-
-#define MDA_ACTIVATE_SINGLTON_GROUPS
-#include "mdaschema.inl"
-#undef MDA_ACTIVATE_SINGLTON_GROUPS
-
-        }
-    }
-
-    if (mdaXmlPairs.GetCount() == 0)
-        return;
-
-    // Create
-    MdaXmlElement* pXmlAssistant = NULL;
-
-#define MDA_ASSISTANT_CREATION
-#include "mdaschema.inl"
-#undef MDA_ASSISTANT_CREATION
-}
-
-typedef enum
-{
-    MDA_MSGBOX_NONE = 0,
-    MDA_MSGBOX_RETRY = 4,
-    MDA_MSGBOX_CANCLE = 2,
-} MsgBoxResult;
-
-BOOL ManagedDebuggingAssistants::IsUnmanagedDebuggerAttached()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (IsDebuggerPresent())
-        return TRUE;
-
-    return FALSE;
-}
-
-BOOL ManagedDebuggingAssistants::IsManagedDebuggerAttached()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-#if DEBUGGING_SUPPORTED
-    if (CORDebuggerAttached())
-        return TRUE;
-#endif
-
-    return FALSE;
-}
-
-BOOL ManagedDebuggingAssistants::IsDebuggerAttached()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    return IsUnmanagedDebuggerAttached() || IsManagedDebuggerAttached();
-}
-
-MdaXmlElement* ManagedDebuggingAssistants::GetRootElement(MdaXmlElement* pMdaXmlRoot)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-    
-    pMdaXmlRoot->SetDeclDef(MdaElemDef(Msg));
-    pMdaXmlRoot->AddAttributeSz(MdaAttrDecl(Xmlns), MDA_TARGET_NAMESPACE)->SetNs(W("mda"));
-    return pMdaXmlRoot;
-}
-
-
-
-//
-// MdaXmlMessage
-//
-BOOL IsFormatChar(WCHAR c) { LIMITED_METHOD_CONTRACT; return (c == W('\\') || c == W('!') || c == W('+') || c == W('.') || c == W(':') || c == W('-')); }
-
-// Logic copied from /fx/src/Xml/System/Xml/Core/XmlRawTextWriterGenerator.cxx::WriteAttributeTextBlock
-SString& MdaXmlEscape(SString& sszBuffer, const SString& sszXml, BOOL bEscapeComment = FALSE)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    sszBuffer.Clear();
-
-    SString::CIterator itr = sszXml.Begin();
-    SString::CIterator end = sszXml.End();
-
-    while (itr != end)
-    {
-        WCHAR c = *itr;
-
-        switch(c)
-        {
-            case W('-'):
-                if (*(itr+1) == W('-') && bEscapeComment)
-                    sszBuffer.Append(W("- "));
-                else
-                    sszBuffer.Append(W("-"));
-                break;
-            case W('&'):
-                sszBuffer.Append(W("&amp;"));
-                break;
-            case W('<'):
-                sszBuffer.Append(W("&lt;"));
-                break;
-            case W('>'):
-                sszBuffer.Append(W("&gt;"));
-                break;
-            case W('"'):
-                sszBuffer.Append(W("&quote;"));
-                break;
-            default:
-                sszBuffer.Append(c);
-        }
-
-        itr++;
-    }
-
-    return sszBuffer;
-}
-
-SString* WrapString(SString& buffer, SString& sszString, SCOUNT_T cWidth, SCOUNT_T cIndent = 0, SCOUNT_T cPostIndent = 0)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    StackSString sszEscapedString;
-    MdaXmlEscape(sszEscapedString, sszString, TRUE);
-
-    StackSString sszIndent;
-    for (SCOUNT_T i = 0; i < cIndent; i ++)
-        sszIndent.Append(W(" "));
-
-    StackSString sszPostIndent;
-    for (SCOUNT_T i = 0; i < cPostIndent; i ++)
-        sszPostIndent.Append(W(" "));
-
-    buffer.Append(sszIndent);
-
-    SString::CIterator itr = sszEscapedString.Begin();
-    SString::CIterator lineStart = sszEscapedString.Begin();
-    SString::CIterator lineEnd = sszEscapedString.Begin();
-    SString::CIterator lastFormatChar = sszEscapedString.Begin();
-    SString::CIterator end = sszEscapedString.End();
-
-    while (itr != end)
-    {
-        if (*itr == W(' '))
-            lineEnd = itr;
-
-        // Keep track of reasonable breaks in member and file names...
-        if (IsFormatChar(*itr) && itr - lineStart < cWidth)
-            lastFormatChar = itr;
-
-        if (itr - lineStart >= cWidth || *itr == W('\n'))
-        {
-            if (*itr == W('\n'))
-                lineEnd = itr;
-
-            // If we didn't find a space or wrapping at found space wraps less than 3/5 of the line...
-            else if (lineEnd == end || itr - lineEnd > cWidth * 3 / 5)
-            {
-                // ...then if we found a format char, start the wrap there...
-                if (lastFormatChar != end)
-                    lineEnd = lastFormatChar + 1;
-                // ...else just do a simple wrap...
-                else
-                    lineEnd = itr;
-            }
-
-            SString sszLine(sszEscapedString, lineStart, lineEnd);
-            buffer.Append(sszLine);
-            buffer.Append(sszPostIndent);
-            buffer.Append(W("\n"));
-            buffer.Append(sszIndent);
-
-            lineStart = lineEnd;
-
-            // If we wrapped on a space or a return than skip over that character as we already replaced it with a \n.
-            if (*lineEnd == W(' ') || *lineEnd == W('\n'))
-                lineStart++;
-
-            lineEnd = end;
-            lastFormatChar = end;
-        }
-
-        itr++;
-    }
-
-    SString sszLine(sszEscapedString, lineStart, itr);
-    buffer.Append(sszLine);
-
-    return &buffer;
-}
-
-LPCWSTR ToUpperFirstChar(SString& buffer, LPCWSTR name)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    ASSERT(*name >= 'a' && *name <= 'z');
-
-    buffer.Clear();
-    buffer.Append(*name - W('a') + W('A'));
-    buffer.Append(&name[1]);
-    return buffer.GetUnicode();
-}
-
-MdaXmlMessage::MdaXmlMessage(MdaAssistant* pAssistant, BOOL bBreak, MdaXmlElement** ppMdaXmlRoot)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(g_mdaStaticHeap.m_pMda));
-    }
-    CONTRACTL_END;
-
-    m_pMdaAssistant = pAssistant;
-    m_bBreak = (pAssistant->GetSuppressDialog()) ? FALSE : bBreak;
-    m_pMdaXmlRoot = g_mdaStaticHeap.m_pMda->GetRootElement(m_mdaXmlIndustry.CreateElement());
-    *ppMdaXmlRoot = m_pAssistantXmlRoot = pAssistant->GetRootElement(m_mdaXmlIndustry.CreateElement(), bBreak);
-}
-
-MdaXmlMessage::MdaXmlMessage(MdaXmlElement** ppMdaXmlRoot) : m_bBreak(FALSE)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(g_mdaStaticHeap.m_pMda));
-    }
-    CONTRACTL_END;
-    
-    *ppMdaXmlRoot = m_pMdaXmlRoot = g_mdaStaticHeap.m_pMda->GetRootElement(m_mdaXmlIndustry.CreateElement());
-}
-
-BOOL MdaXmlMessage::ShouldLogToManagedDebugger()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    BOOL bUnmanagedDebuggerAttached = FALSE;
-    BOOL bManagedDebuggerAttached = FALSE;
-    BOOL bManagedDebugLoggingEnabled = FALSE;
-
-    bUnmanagedDebuggerAttached = IsUnmanagedDebuggerAttached();
-
-#if DEBUGGING_SUPPORTED
-    bManagedDebuggerAttached = IsManagedDebuggerAttached();
-    bManagedDebugLoggingEnabled = (g_pDebugInterface && g_pDebugInterface->IsLoggingEnabled());
-#endif
-
-    return (!bUnmanagedDebuggerAttached && bManagedDebuggerAttached && bManagedDebugLoggingEnabled);
-}
-
-// Send an event for this MDA.
-void MdaXmlMessage::SendEvent()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (IsHostRegisteredForEvent(Event_MDAFired))
-    {
-        // A host is registered for the MDA fired event so let's start by notifying the
-        // debugger is on is attached.
-        if (IsManagedDebuggerAttached() || IsUnmanagedDebuggerAttached())
-        {
-            SendDebugEvent();
-        }
-
-        // Now that the debugger has been notified and continued, let's notify the host
-        // so it can take any action it deems neccessary based on the MDA that fired.
-        SendHostEvent();
-    }
-    else
-    {
-        // We aren't hosted or no host registered for the MDA fired event so let's simply
-        // send the MDA to the debubber. Note that as opposed to the hosted case, we
-        // will force a JIT attach if no debugger is present.
-        SendDebugEvent();
-    }
-}
-
-// Send an event for this MDA.
-void MdaXmlMessage::SendHostEvent()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    MDAInfo info;
-    SString strStackTrace;
-
-    EX_TRY
-    {
-        // Retrieve the textual representation of the managed stack trace and add it to
-        // the MDA information we give the host.
-        GetManagedStackTraceString(TRUE, strStackTrace);
-    }
-    EX_CATCH
-    {
-        // We failed to get the stack trace string. This isn't fatal, we will simply not be
-        // able to provide this information as part of the notification.
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-
-    // Set up the information and invoke the host to process the MDA fired event.
-    info.lpMDACaption = m_pMdaAssistant->GetName();
-    info.lpStackTrace = strStackTrace;
-    info.lpMDAMessage = m_localizedMessage;
-    ProcessEventForHost(Event_MDAFired, &info);
-
-    // If the host initiated a thread abort, we want to raise it immediatly to
-    // prevent any further code inside the VM from running and potentially
-    // crashing the process.
-    Thread *pThread = GetThread();
-    TESTHOOKCALL(AppDomainCanBeUnloaded(pThread->GetDomain()->GetId().m_dwId,FALSE));    
-    
-    if (pThread && pThread->IsAbortInitiated())
-        pThread->HandleThreadAbort(TRUE);
-}
-
-// Send a managed debug event for this MDA.
-// This will block until the debugger continues us. This means the debugger could to things like run callstacks
-// and change debuggee state.
-void MdaXmlMessage::SendDebugEvent()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(g_mdaStaticHeap.m_pMda));
-    }
-    CONTRACTL_END;
-    
-    // Simple check to avoid getting XML string if we're not going to actually use it.
-    if (!IsManagedDebuggerAttached() && !IsUnmanagedDebuggerAttached() && !m_bBreak)
-    {
-        return;
-    }
-
-    EX_TRY
-    {
-        StackSString sszXml;
-        LPCWSTR ns = NULL;
-
-        MdaSchema * pSchema = g_mdaStaticHeap.m_pMda->m_pAssistantSchema;
-        ns = pSchema->SetRootAttributes(m_pMdaXmlRoot);
-        m_pMdaXmlRoot->ToXml(&sszXml, ns);
-
-        // For managed + interop cases, send a managed debug event.
-        // If m_bBreak is true and no unmanaged debugger is attached trigger a jit-attach.
-        if (IsManagedDebuggerAttached() || (m_bBreak && !IsUnmanagedDebuggerAttached()))
-        {
-            // Get MDA name (this is the type)
-            StackSString sszMdaName;
-            ToUpperFirstChar(sszMdaName, m_pMdaAssistant->GetName());
-            // SendMDANotification needs to be called in preemptive GC mode.
-            GCX_PREEMP();
-
-            // This will do two things:
-            // 1. If a managed debugger is attached, it will send the managed debug event for the MDA.
-            // 2. If it's a m_bBreak, we'll try to do a managed jit-attach.
-            // This blocks until continued. Since we're not slipping, we don't need the MDA_FLAG_SLIP flag.
-            g_pDebugInterface->SendMDANotification(
-                GetThread(),
-                &sszMdaName,
-                &m_localizedMessage,
-                &sszXml,
-                ((CorDebugMDAFlags) 0 ),
-                RunningInteractive() ? m_bBreak : FALSE);        
-        }
-
-        if (IsUnmanagedDebuggerAttached() && !IsManagedDebuggerAttached())
-        {
-            // For native case, sent native debug event for logging.
-            WszOutputDebugString(sszXml.GetUnicode());
-
-            if (m_bBreak)
-                RetailBreak();
-        }
-    }
-    EX_CATCH
-    {
-        // No global MDA state modified in TRY
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-}
-
-void MdaXmlMessage::SendMessagef(int resourceID, ...)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    StackSString sszResourcef;
-    sszResourcef.LoadResource(CCompRC::DesktopCLR, resourceID );
-    ASSERT(!sszResourcef.IsEmpty());
-
-    va_list argItr;
-    va_start(argItr, resourceID);
-    m_localizedMessage.PVPrintf(sszResourcef, argItr);
-    va_end(argItr);
-
-    SendMessage();
-}
-
-
-void MdaXmlMessage::SendMessage(int resourceID)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    SendMessagef(resourceID);
-}
-
-void MdaXmlMessage::SendMessage(LPCWSTR szMessage)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    m_localizedMessage.Set(szMessage);
-
-    SendMessage();
-}
-
-void MdaXmlMessage::SendMessage()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(g_mdaStaticHeap.m_pMda));
-    }
-    CONTRACTL_END;
-
-#if _DEBUG
-    if (g_mdaStaticHeap.m_pMda->m_bValidateOutput)
-    {
-        MdaSchema::ValidationResult validationResult;
-        if (g_mdaStaticHeap.m_pMda->m_pAssistantMsgSchema->Validate(m_pAssistantXmlRoot, &validationResult)->ValidationFailed())
-        {
-            MDA_TRIGGER_ASSISTANT(XmlValidationError, ReportError(&validationResult));
-            ASSERT(W("Your MDA assistant's output did not match its output schema."));
-        }
-    }
-#endif
-
-    if (!m_localizedMessage.IsEmpty())
-    {
-        StackSString sszComment(m_localizedMessage);
-        StackSString sszWrappedComment(W("\n"));
-        WrapString(sszWrappedComment, sszComment, 80, 7);
-        sszWrappedComment.Append(W("\n  "));
-        m_pMdaXmlRoot->AddChildComment(sszWrappedComment.GetUnicode());
-    }
-
-    m_pMdaXmlRoot->AddChild(m_pAssistantXmlRoot);
-
-    // Send applicable debug event (managed, native, interop) for this MDA.
-    // If this is a severe probe, it may trigger a jit-attach
-    SendEvent();
-}
-
-
-//
-// MdaXPath::FindXXX
-//
-
-void MdaXPath::Find(SArray<MdaXPathVariable>& args, SString* pWildCard, va_list argItr)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    for (COUNT_T i = 0; i < GetArgCount(); i ++)
-    {
-        XPathVarType varType = m_argTypes[i];
-
-        if (varType == XPathVarElemDeclDef)
-            args[i].m_u.m_elemDeclDef = va_arg(argItr, MdaElemDeclDef);
-
-        else if (varType == XPathVarAttrDeclDef)
-            args[i].m_u.m_attrDeclDef = va_arg(argItr, MdaAttrDeclDef);
-
-        else if (varType == XPathVarAttrBool)
-            args[i].m_u.m_bool = va_arg(argItr, BOOL);
-
-        else if (varType == XPathVarAttrINT32)
-            args[i].m_u.m_int32 = va_arg(argItr, INT32);
-
-        else if (varType == XPathVarAttrSString)
-        {
-            SString* pSString = va_arg(argItr, SString*);
-            ASSERT(CheckPointer(pSString, NULL_OK));
-            if (!pSString)
-                pSString = pWildCard;
-            args[i].m_u.m_pSstr = pSString;
-        }
-
-        else { UNREACHABLE(); }
-    }
-}
-
-MdaXmlElement* MdaXPath::FindElement(MdaXmlElement* pRoot, ...)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (!pRoot)
-        return NULL;
-
-    va_list argItr;
-    va_start(argItr, pRoot);
-
-    SString wildCard;
-    InlineSArray<MdaXPathVariable, 20> args;
-    Find(args, &wildCard, argItr);
-
-    MdaXPathResult result(&args);
-    m_pCompiledQuery->Run(pRoot, &result);
-
-    va_end(argItr);
-    return result.GetXmlElement();
-}
-
-MdaXmlAttribute* MdaXPath::FindAttribute(MdaXmlElement* pRoot, ...)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (!pRoot)
-        return NULL;
-
-    va_list argItr;
-    va_start(argItr, pRoot);
-
-    SString wildCard;
-    InlineSArray<MdaXPathVariable, 20> args;
-    Find(args, &wildCard, argItr);
-
-    MdaXPathResult result(&args);
-    m_pCompiledQuery->Run(pRoot, &result);
-
-    va_end(argItr);
-    return result.GetXmlAttribute();
-}
-
-SArray<MdaXmlElement*>* MdaXPath::FindElements(MdaXmlElement* pRoot, SArray<MdaXmlElement*>* pResult, ...)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (!pRoot)
-        return NULL;
-
-    va_list argItr;
-    va_start(argItr, pResult);
-
-    SString wildCard;
-    InlineSArray<MdaXPathVariable, 20> args;
-    Find(args, &wildCard, argItr);
-
-    MdaXPathResult result(pResult, &args);
-    m_pCompiledQuery->Run(pRoot, &result);
-
-    va_end(argItr);
-    return pResult;
-}
-
-SArray<MdaXmlAttribute*>* MdaXPath::FindAttributes(MdaXmlElement* pRoot, SArray<MdaXmlAttribute*>* pResult, ...)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (!pRoot)
-        return NULL;
-
-    va_list argItr;
-    va_start(argItr, pResult);
-
-    SString wildCard;
-    InlineSArray<MdaXPathVariable, 20> args;
-    Find(args, &wildCard, argItr);
-
-    MdaXPathResult result(pResult, &args);
-    m_pCompiledQuery->Run(pRoot, &result);
-
-    va_end(argItr);
-    return pResult;
-}
-
-
-//
-// MdaXPath::MdaXPathCompiler -- Lexifier
-//
-
-#define ISWHITE(ch) (ch == W(' ') || ch == W('\t') || ch == W('\n'))
-#define ISRESERVED(ch) (wcschr(W("./()[]&|=@*?':"), ch) != NULL)
-#define ISMDAID(ch) (!ISWHITE(ch) && !ISRESERVED(ch))
-
-MdaXPath::MdaXPathCompiler::MdaXPathTokens MdaXPath::MdaXPathCompiler::LexAToken()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (*m_itr == W('\0'))
-        return MdaXPathEnd;
-
-    if (ISWHITE(*m_itr))
-    {
-        m_itr++;
-        return LexAToken();
-    }
-
-    if (ISMDAID(*m_itr))
-    {
-        m_identifier.Clear();
-
-        do
-        {
-            m_identifier.Append(*m_itr);
-            m_itr++;
-        }
-        while(ISMDAID(*m_itr));
-
-        m_identifier.Append(W("\0"));
-        return MdaXPathIdentifier;
-    }
-
-    if (*m_itr == W('\''))
-    {
-        m_identifier.Clear();
-
-        m_itr++;
-
-        while(*m_itr != W('\''))
-        {
-            m_identifier.Append(*m_itr);
-            m_itr++;
-        }
-
-        m_identifier.Append(W("\0"));
-
-        m_itr++;
-        return MdaXPathQuotedString;
-    }
-
-    WCHAR c = *m_itr;
-    m_itr++;
-    switch(c)
-    {
-        case W('.'): return MdaXPathDot;
-        case W('/'): return MdaXPathSlash;
-        case W('('): return MdaXPathOpenParen;
-        case W(')'): return MdaXPathCloseParen;
-        case W('['): return MdaXPathOpenSqBracket;
-        case W(']'): return MdaXPathCloseSqBracket;
-        case W('&'): return MdaXPathLogicalAnd;
-        case W('|'): return MdaXPathLogicalOr;
-        case W('='): return MdaXPathEquals;
-        case W('@'): return MdaXPathAtSign;
-        case W('*'): return MdaXPathAstrix;
-        case W('?'): return MdaXPathQMark;
-    }
-
-    UNREACHABLE();
-}
-
-
-//
-// MdaXPath::MdaXPathCompiler -- Parser
-//
-
-//  XPATH
-//      '/' ELEMENT_EXPR end
-//      '/' ELEMENT_EXPR XPATH
-//      '/' ATTRIBUTE end
-MdaXPath::MdaXPathBase* MdaXPath::MdaXPathCompiler::XPATH()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-    PRECONDITION(TokenIs(MdaXPathXPATH));
-
-    MdaXPathElement* pElementExpr = NULL;
-
-    NextToken();
-    if (TokenIs(MdaXPathELEMENT_EXPR))
-        pElementExpr = ELEMENT_EXPR();
-
-    else if (TokenIs(MdaXPathATTRIBUTE))
-    {
-        MdaXPathAttribute* pAttr = ATTRIBUTE();
-        pAttr->MarkAsTarget();
-        NextToken();
-        ASSERT(TokenIs(MdaXPathEnd));
-        return pAttr;
-    }
-
-    else { UNREACHABLE(); }
-
-
-    if (TokenIs(MdaXPathEnd))
-        return pElementExpr->MarkAsTarget();
-
-    else if (TokenIs(MdaXPathXPATH))
-        return pElementExpr->SetChild(XPATH());
-
-    else { UNREACHABLE(); }
-}
-
-//  ATTRIBUTE
-//      '@' id
-//      '@' '?'
-MdaXPath::MdaXPathAttribute* MdaXPath::MdaXPathCompiler::ATTRIBUTE()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-    PRECONDITION(TokenIs(MdaXPathATTRIBUTE));
-
-    MdaXPathAttribute* pAttr = NULL;
-
-    NextToken();
-    if (TokenIs(MdaXPathQMark))
-    {
-        pAttr = m_pXPath->m_attrFactory.Create()->SetName(++m_pXPath->m_cArgs);
-        *m_pXPath->m_argTypes.Append() = XPathVarAttrDeclDef;
-    }
-
-    else if (TokenIs(MdaXPathIdentifier))
-    {
-        pAttr = m_pXPath->m_attrFactory.Create()->SetName(MdaSchema::GetAttributeType(GetIdentifier()));
-    }
-
-    else { UNREACHABLE(); }
-
-    NextToken();
-    return pAttr;
-}
-
-//  ELEMENT_EXPR
-//      ELEMENT '[' FILTER_EXPR ']'
-//      ELEMENT
-MdaXPath::MdaXPathElement* MdaXPath::MdaXPathCompiler::ELEMENT_EXPR()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-    PRECONDITION(TokenIs(MdaXPathELEMENT_EXPR));
-
-    MdaXPathElement* pElement = ELEMENT();
-
-    if (TokenIs(MdaXPathOpenSqBracket))
-    {
-        NextToken();
-        pElement->SetQualifier(FILTER_EXPR());
-        ASSERT(TokenIs(MdaXPathCloseSqBracket));
-
-        NextToken();
-    }
-
-    return pElement;
-}
-
-//  FILTER_EXPR
-//      FILTER
-//      '(' FILTER ')'
-//      FILTER '&' FILTER
-//      FILTER '|' FILTER
-MdaXPath::MdaXPathBase* MdaXPath::MdaXPathCompiler::FILTER_EXPR()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-    PRECONDITION(TokenIs(MdaXPathFILTER_EXPR));
-
-    // '(' FILTER ')'
-    if (TokenIs(MdaXPathOpenParen))
-    {
-        MdaXPath::MdaXPathBase* pFilter = FILTER();
-        ASSERT(TokenIs(MdaXPathCloseParen));
-
-        NextToken();
-        return pFilter;
-    }
-
-    if (TokenIs(MdaXPathFILTER))
-    {
-        MdaXPath::MdaXPathBase* pFilter = FILTER();
-
-        // FILTER '&' FILTER
-        if (TokenIs(MdaXPathLogicalAnd))
-        {
-            NextToken();
-            return m_pXPath->m_logicalOpFactory.Create()->Initialize(TRUE, pFilter, FILTER());
-        }
-
-        // FILTER '|' FILTER
-        if (TokenIs(MdaXPathLogicalOr))
-        {
-            NextToken();
-            return m_pXPath->m_logicalOpFactory.Create()->Initialize(FALSE, pFilter, FILTER());
-        }
-
-        // FILTER
-        return pFilter;
-    }
-
-    UNREACHABLE();
-}
-
-//  FILTER
-//      ELEMENT_EXPR
-//      ATTRIBUTE_FILTER
-//      ELEMENT_EXPR ATTRIBUTE_FILTER
-MdaXPath::MdaXPathBase* MdaXPath::MdaXPathCompiler::FILTER()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-    PRECONDITION(TokenIs(MdaXPathFILTER));
-
-    if (TokenIs(MdaXPathELEMENT_EXPR))
-    {
-        MdaXPathElement* pElementExpr = ELEMENT_EXPR();
-
-        if (TokenIs(MdaXPathATTRIBUTE_FILTER))
-            pElementExpr->SetQualifier(ATTRIBUTE_FILTER());
-
-        return pElementExpr;
-    }
-
-    if (TokenIs(MdaXPathATTRIBUTE_FILTER))
-        return ATTRIBUTE_FILTER();
-
-    UNREACHABLE();
-}
-
-//  ELEMENT
-//      id
-//      '*'
-//      '?'
-MdaXPath::MdaXPathElement* MdaXPath::MdaXPathCompiler::ELEMENT()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-    PRECONDITION(TokenIs(MdaXPathELEMENT));
-
-    MdaXPathElement* pElement = m_pXPath->m_elementFactory.Create();
-
-    if (TokenIs(MdaXPathAstrix))
-        pElement->Initialize();
-
-    else if (TokenIs(MdaXPathIdentifier))
-        pElement->Initialize(MdaSchema::GetElementType(GetIdentifier()));
-
-    else if (TokenIs(MdaXPathQMark))
-    {
-        pElement->Initialize(++m_pXPath->m_cArgs);
-        *m_pXPath->m_argTypes.Append() = XPathVarElemDeclDef;
-    }
-
-    else { UNREACHABLE(); }
-
-    NextToken();
-    return pElement;
-}
-
-//  ATTRIBUTE_FILTER();
-//      ATTRIBUTE
-//      ATTRIBUTE '=' ''' id '''
-//      ATTRIBUTE '=' '?'
-MdaXPath::MdaXPathAttribute* MdaXPath::MdaXPathCompiler::ATTRIBUTE_FILTER()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-    PRECONDITION(TokenIs(MdaXPathATTRIBUTE_FILTER));
-
-    MdaXPathAttribute* pAttr = ATTRIBUTE();
-
-    if (TokenIs(MdaXPathEquals))
-    {
-        NextToken();
-
-        if (TokenIs(MdaXPathQuotedString))
-        {
-            NextToken();
-            pAttr->SetValue(GetIdentifier());
-
-            NextToken();
-            ASSERT(TokenIs(MdaXPathQuotedString));
-        }
-        else if (TokenIs(MdaXPathQMark))
-        {
-            pAttr->SetValue(++m_pXPath->m_cArgs);
-            *m_pXPath->m_argTypes.Append() = XPathVarAttrSString;
-        }
-        else { UNREACHABLE(); }
-    }
-
-    NextToken();
-    return pAttr;
-}
-
-
-//
-// MdaXPath::Elements::Run() -- The search engine
-//
-
-BOOL MdaXPath::MdaXPathElement::Run(MdaXmlElement* pElement, MdaXPathResult* pResult)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    BOOL bAnyPass = FALSE;
-    if (pResult->IsRoot())
-    {
-        bAnyPass |= RunOnChild(pElement, pResult);
-    }
-    else
-    {
-        SArray<MdaXmlElement*>& children = pElement->GetChildren();
-
-        for (UINT32 i = 0; i < children.GetCount(); i ++)
-        {
-            bAnyPass |= RunOnChild(children[i], pResult);
-        }
-    }
-
-    return bAnyPass;
-}
-
-BOOL MdaXPath::MdaXPathElement::RunOnChild(MdaXmlElement* pElement, MdaXPathResult* pResult)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    MdaElemDeclDef name = m_nameArg == NOT_VARIABLE ? m_name : pResult->GetArgs()[m_nameArg].m_u.m_elemDeclDef;
-
-    if (name != MdaElemUndefined && name != pElement->GetDeclDef())
-        return FALSE;
-
-    if (m_pQualifier && !m_pQualifier->Run(pElement, pResult))
-        return FALSE;
-
-    if (m_pChild && !m_pChild->Run(pElement, pResult))
-        return FALSE;
-
-    if (m_bIsTarget)
-    {
-        ASSERT(!m_pChild);
-        pResult->AddMatch(pElement);
-    }
-
-    return TRUE;
-}
-
-BOOL MdaXPath::MdaXPathAttribute::Run(MdaXmlElement* pElement, MdaXPathResult* pResult)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    MdaAttrDeclDef name = m_nameArg == NOT_VARIABLE ? m_name : pResult->GetArgs()[m_nameArg].m_u.m_attrDeclDef;
-    SString& value = m_valueArg == NOT_VARIABLE ? m_value : *pResult->GetArgs()[m_valueArg].m_u.m_pSstr;
-
-    MdaXmlAttribute* pAttr = pElement->GetAttribute(name);
-    if (!pAttr)
-        return FALSE;
-
-    LPCWSTR szAttrValue = pAttr->GetValue();
-    if (!value.IsEmpty() && *szAttrValue != W('*') && !value.Equals(szAttrValue))
-        return FALSE;
-
-    if (m_bIsTarget)
-        pResult->AddMatch(pElement);
-
-    return TRUE;
-}
-
-BOOL MdaXPath::MdaXPathLogicalOp::Run(MdaXmlElement* pParent, MdaXPathResult* pResult)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (m_andOp)
-        return m_pLhs->Run(pParent, pResult) && m_pRhs->Run(pParent, pResult);
-
-    return m_pLhs->Run(pParent, pResult) || m_pRhs->Run(pParent, pResult);
-}
-
-
-//
-// MdaSchema
-//
-
-MdaHashtable<MdaElemDeclDef>* MdaSchema::g_pHtElementType;
-MdaHashtable<MdaAttrDeclDef>* MdaSchema::g_pHtAttributeType;
-LPCWSTR MdaSchema::g_arElementNames[MdaElemEnd];
-LPCWSTR MdaSchema::g_arAttributeNames[MdaAttrEnd];
-MdaFactory<SString>* MdaSchema::g_pSstringFactory;
-MdaElemDeclDef MdaSchema::MdaSchemaTypeToElemDef[MdaSchema::MdaSchemaTypeEnd];
-MdaSchema::MdaSchemaMetaType MdaSchema::MdaSchemaTypeToMetaType[MdaSchema::MdaSchemaTypeEnd];
-
-LPCWSTR MdaSchema::ToLowerFirstChar(LPCWSTR name)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    return ::ToLowerFirstChar(name, g_pSstringFactory);
-}
-
-void MdaSchema::Initialize()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    g_pHtElementType = new MdaHashtable<MdaElemDeclDef>();
-    g_pHtAttributeType = new MdaHashtable<MdaAttrDeclDef>();
-    g_pSstringFactory = new MdaFactory<SString>();
-
-    COUNT_T i = 0;
-    MdaSchemaTypeToElemDef[i++] = MdaElemDef(Sequence);         // MdaSchemaSequenceType
-    MdaSchemaTypeToElemDef[i++] = MdaElemDef(Choice);           // MdaSchemaChoiceType
-    MdaSchemaTypeToElemDef[i++] = MdaElemDef(Group);            // MdaSchemaGroupType
-    MdaSchemaTypeToElemDef[i++] = MdaElemDef(Group);            // MdaSchemaGroupRefType
-    MdaSchemaTypeToElemDef[i++] = MdaElemDef(Schema);           // MdaSchemaRootType
-    MdaSchemaTypeToElemDef[i++] = MdaElemDef(Attribute);        // MdaSchemaAttributeType
-    MdaSchemaTypeToElemDef[i++] = MdaElemDef(Element);          // MdaSchemaElementType
-    MdaSchemaTypeToElemDef[i++] = MdaElemDef(ComplexType);      // MdaSchemaComplexTypeType
-    MdaSchemaTypeToElemDef[i++] = MdaElemDef(ComplexType);      // MdaSchemaComplexTypeDefType
-    MdaSchemaTypeToElemDef[i++] = MdaElemDef(Element);          // MdaSchemaElementRefTyp
-    MdaSchemaTypeToElemDef[i++] = MdaElemDef(Extension);        // MdaSchemaExtensionType
-    MdaSchemaTypeToElemDef[i++] = MdaElemDef(Element);          // MdaSchemaElementRefTypeType
-    MdaSchemaTypeToElemDef[i++] = MdaElemDef(ComplexContent);   // MdaSchemaComplexContentType
-    MdaSchemaTypeToElemDef[i++] = MdaElemDef(Element);          // MdaSchemaElementAnyType
-
-    i = 0;
-    MdaSchemaTypeToMetaType[i++] = MdaSchemaMataTypePattern;    // MdaSchemaSequenceType
-    MdaSchemaTypeToMetaType[i++] = MdaSchemaMataTypePattern;    // MdaSchemaChoiceType
-    MdaSchemaTypeToMetaType[i++] = (MdaSchemaMetaType)(MdaSchemaMataTypePattern | MdaSchemaMataTypeDeclDef); // MdaSchemaGroupType
-    MdaSchemaTypeToMetaType[i++] = (MdaSchemaMetaType)(MdaSchemaMataTypePattern | MdaSchemaMataTypeRef); // MdaSchemaGroupRefType
-    MdaSchemaTypeToMetaType[i++] = MdaSchemaMataNone;           // MdaSchemaRootType
-    MdaSchemaTypeToMetaType[i++] = MdaSchemaMataNone;           // MdaSchemaAttributeType
-    MdaSchemaTypeToMetaType[i++] = MdaSchemaMataTypeDeclDef;    // MdaSchemaElementType
-    MdaSchemaTypeToMetaType[i++] = (MdaSchemaMetaType)(MdaSchemaMataNone | MdaSchemaMataMayHaveAttributes); // MdaSchemaComplexTypeType
-    MdaSchemaTypeToMetaType[i++] = (MdaSchemaMetaType)(MdaSchemaMataTypeDeclDef | MdaSchemaMataMayHaveAttributes); // MdaSchemaComplexTypeDefType
-    MdaSchemaTypeToMetaType[i++] = MdaSchemaMataTypeRef;        // MdaSchemaElementRefTyp
-    MdaSchemaTypeToMetaType[i++] = (MdaSchemaMetaType)(MdaSchemaMataTypeRef | MdaSchemaMataMayHaveAttributes); // MdaSchemaExtensionType
-    MdaSchemaTypeToMetaType[i++] = (MdaSchemaMetaType)(MdaSchemaMataTypeDeclDef | MdaSchemaMataTypeRef); // MdaSchemaElementRefTypeType
-    MdaSchemaTypeToMetaType[i++] = MdaSchemaMataNone;           // MdaSchemaComplexContentType
-    MdaSchemaTypeToMetaType[i++] = MdaSchemaMataTypeDeclDef;    // MdaSchemaElementAnyType
-
-    i = 0;
-#define MDA_MAP_ASSISTANT_DEFINITION_TO_NAME
-#include "mdaschema.inl"
-#undef MDA_MAP_ASSISTANT_DEFINITION_TO_NAME
-    g_arElementNames[i++] = NULL;
-#define MDA_MAP_ELEMENT_DEFINITION_TO_NAME
-#include "mdaschema.inl"
-#undef MDA_MAP_ELEMENT_DEFINITION_TO_NAME
-    g_arElementNames[i++] = NULL;
-#define MDA_MAP_ELEMENT_DECLARATION_TO_NAME
-#include "mdaschema.inl"
-#undef MDA_MAP_ELEMENT_DECLARATION_TO_NAME
-    g_arElementNames[i++] = NULL; // Max
-    g_arElementNames[i++] = W("!--"); // Comment
-    g_arElementNames[i++] = NULL; // Undefined
-
-    i = 0;
-#define MDA_MAP_ATTRIBUTE_DECLARATION_TO_NAME
-#include "mdaschema.inl"
-#undef MDA_MAP_ATTRIBUTE_DECLARATION_TO_NAME
-
-#define MDA_MAP_ASSISTANT_NAME_TO_DEFINITION
-#include "mdaschema.inl"
-#undef MDA_MAP_ASSISTANT_NAME_TO_DEFINITION
-
-#define MDA_MAP_ELEMENT_NAME_TO_DEFINITION
-#include "mdaschema.inl"
-#undef MDA_MAP_ELEMENT_NAME_TO_DEFINITION
-
-#define MDA_MAP_ELEMENT_NAME_TO_DECLARATION
-#include "mdaschema.inl"
-#undef MDA_MAP_ELEMENT_NAME_TO_DECLARATION
-
-#define MDA_MAP_ATTRIBUTE_NAME_TO_DECLARATION
-#include "mdaschema.inl"
-#undef MDA_MAP_ATTRIBUTE_NAME_TO_DECLARATION
-}
-
-MdaElemDeclDef MdaSchema::GetElementType(LPCWSTR name, BOOL bAssertDefined)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    MdaElemDeclDef type;
-
-    if (!g_pHtElementType->Get(name, &type))
-    {
-        ASSERT(!bAssertDefined);
-        return MdaElemUndefined;
-    }
-
-    return type;
-}
-
-LPCWSTR MdaSchema::GetElementName(MdaElemDeclDef type)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    PRECONDITION(type >= 0 && type < MdaElemUndefined);
-    return g_arElementNames[type];
-}
-
-MdaAttrDeclDef MdaSchema::GetAttributeType(LPCWSTR name, BOOL bAssertDefined)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    MdaAttrDeclDef type;
-
-    if (!g_pHtAttributeType->Get(name, &type))
-    {
-        ASSERT(!bAssertDefined);
-        return MdaAttrUndefined;
-    }
-
-    return type;
-}
-
-LPCWSTR MdaSchema::GetAttributeName(MdaAttrDeclDef type)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    return g_arAttributeNames[type];
-}
-
-// TODO: Validation error reporting needs work
-MdaSchema::ValidationResult* MdaSchema::Validate(MdaXmlElement* pRoot, ValidationResult* pResult)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    pResult->Initialize(this, pRoot);
-
-    MdaSchemaBase* pXsd = *GetDef(pRoot->GetDeclDef());
-    ASSERT((CheckPointer(pXsd) || (pRoot->GetDeclDef() > MdaElemDecl(Max))) && W("You likley did not include a MDA_DEFINE_OUTPUT section in your schema!"));
-
-    BOOL bValidationSucceeded = pXsd ? pXsd->Validate(pRoot, pResult) : FALSE;
-
-    if (bValidationSucceeded)
-        pResult->ResetResult();
-    else
-        pResult->SetError();
-
-    ASSERT(pResult->ValidationFailed() == !bValidationSucceeded);
-    return pResult;
-}
-
-MdaSchema::MdaSchema()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    for(COUNT_T i = 0; i < MdaElemEnd; i ++)
-        m_definitions[i] = NULL;
-}
-
-
-//
-// MdaAssistantSchema
-//
-
-MdaAssistantSchema::MdaAssistantSchema()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-#define MDA_DEFINE_ASSISTANT_SCHEMA
-#include "mdaschema.inl"
-#undef MDA_DEFINE_ASSISTANT_SCHEMA
-
-#define MDA_DEFINE_MDA_ASSISTANT_CONFIG_GROUP
-#include "mdaschema.inl"
-#undef MDA_DEFINE_MDA_ASSISTANT_CONFIG_GROUP
-}
-
-LPCWSTR MdaAssistantSchema::SetRootAttributes(MdaXmlElement* pXml)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    //pXml->AddAttribute(W("xmlns:") MDA_SCHEMA_PREFIX, MDA_TARGET_NAMESPACE);
-    //pXml->AddAttribute(W("xmlns:xsi"), W("http://www.w3.org/2001/XMLSchema-instance"));
-    return MDA_SCHEMA_PREFIX;
-}
-
-
-//
-// MdaAssistantMsgSchema
-//
-
-MdaAssistantMsgSchema::MdaAssistantMsgSchema()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-#define MDA_DEFINE_ASSISTANT_MSG_SCHEMA
-#include "mdaschema.inl"
-#undef MDA_DEFINE_ASSISTANT_MSG_SCHEMA
-
-#define MDA_DEFINE_MDA_ASSISTANT_MSG_GROUP
-#include "mdaschema.inl"
-#undef MDA_DEFINE_MDA_ASSISTANT_MSG_GROUP
-}
-
-LPCWSTR MdaAssistantMsgSchema::SetRootAttributes(MdaXmlElement* pXml)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    //pXml->AddAttribute(W("xmlns:") MDA_SCHEMA_PREFIX, MDA_TARGET_NAMESPACE);
-    //pXml->AddAttribute(W("xmlns:xsi"), W("http://www.w3.org/2001/XMLSchema-instance"));
-    return MDA_SCHEMA_PREFIX;
-}
-
-
-//
-// MdaSchemaSchema
-//
-
-MdaSchemaSchema::MdaSchemaSchema()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-#define MDA_DEFINE_SCHEMA_SCHEMA
-#include "mdaschema.inl"
-#undef MDA_DEFINE_SCHEMA_SCHEMA
-}
-
-LPCWSTR MdaSchemaSchema::SetRootAttributes(MdaXmlElement* pXml)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    pXml->AddAttributeSz(MdaAttrDecl(TargetNamespace), MDA_TARGET_NAMESPACE);
-    pXml->AddAttributeSz(MdaAttrDecl(Xmlns), W("http://www.w3.org/2001/XMLSchema"))->SetNs(W("xs"));
-    pXml->AddAttributeSz(MdaAttrDecl(Xmlns), MDA_TARGET_NAMESPACE);
-    return W("xs");
-}
-
-
-//
-// MdaSchema::MdaSchemaXXX
-//
-MdaXmlElement* MdaSchema::MdaSchemaBase::ToXml(MdaXmlIndustry* pMdaXmlIndustry, MdaSchemaBase* pViolation)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    return ToXml(pMdaXmlIndustry->CreateElement(), pViolation);
-}
-
-MdaXmlElement* MdaSchema::MdaSchemaBase::ToXml(MdaXmlElement* pXmlRoot, MdaSchemaBase* pViolation)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    LPCWSTR debugName = GetName();
-
-    MdaXmlElement* pXml = pXmlRoot->AddChild(GetSchemaDeclDef());
-    SetAttributes(pXml);
-
-//    if (this == pViolation)
-//        pXml->AddAttributeSz(MdaAttrDecl(Violated), W("---- THIS XSD ELEMENT VIOLATED -----"));
-
-    if (m_children.GetCount() == 1 &&
-        m_children[0]->GetSchemaDeclDef() == MdaElemDef(ComplexType) &&
-        m_children[0]->m_children.GetCount() == 0 &&
-        (!MayHaveAttr(m_children[0]) ||
-         m_children[0]->GetAttributes().GetCount() == 0))
-    {
-        // Convert <Element><ComplexType/><Element> to <Element/>
-        return pXml;
-    }
-
-    for(COUNT_T i = 0; i < m_children.GetCount(); i ++)
-    {
-        debugName = m_children[i]->GetName();
-        m_children[i]->ToXml(pXml, pViolation);
-    }
-
-    if (MayHaveAttr(this))
-    {
-        SArray<MdaSchemaAttribute*>& attributes = GetAttributes();
-        for(COUNT_T j = 0; j < attributes.GetCount(); j ++)
-        {
-            debugName = attributes[j]->GetName();
-            attributes[j]->ToXml(pXml, pViolation);
-        }
-    }
-
-    return pXml;
-}
-
-
-void MdaSchema::MdaSchemaBase::AddChild(MdaSchemaBase* pElement)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (pElement->GetSchemaDeclDef() == MdaElemDef(Attribute))
-        *GetAttributes().Append() = (MdaSchemaAttribute*)pElement;
-    else
-        *m_children.Append() = pElement;
-}
-
-//
-// Validation
-//
-
-#define CpdXsdIfFailGo(EXPR) do { if (!(EXPR)) { goto Fail; } } while (0)
-#define CpdXsdTest(EXPR) do { if (!(EXPR)) { pResult->SetError(this, pElement); goto Fail; } } while (0)
-#define MDA_XSD_VERIFY_OK return TRUE;
-#define MDA_XSD_VERIFY_FAIL Fail: return FALSE;
-
-BOOL MdaSchema::MdaSchemaElement::Validate(MdaXmlElement* pElement, ValidationResult* pResult)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    StackSString buffer;
-    LPCWSTR debug = pElement->DebugToString(&buffer);
-
-    CpdXsdTest(pElement->GetDeclDef() == GetDeclDef());
-
-    for(COUNT_T i = 0; i < m_children.GetCount(); i++)
-        CpdXsdIfFailGo(m_children[i]->Validate(pElement, pResult));
-
-    MDA_XSD_VERIFY_OK;
-    MDA_XSD_VERIFY_FAIL;
-}
-
-BOOL MdaSchema::MdaSchemaSequence::ValidatePattern(MdaXmlElement* pElement, ValidationResult* pResult, COUNT_T* pCount)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    StackSString buffer;
-    LPCWSTR debug = pElement->DebugToString(&buffer);
-
-    COUNT_T cPeriod = m_children.GetCount();
-    COUNT_T cChildren = pElement->GetChildren().GetCount();
-    COUNT_T cCurrent = *pCount;
-    COUNT_T cCount = cCurrent;
-    COUNT_T cMatches = 0;
-
-    if (cPeriod == 0)
-        return TRUE;
-
-    while(cCurrent <= cChildren)
-    {
-        MdaSchemaBase* pXsd = m_children[cMatches % cPeriod];
-        if (pXsd->GetSchemaDeclDef() == MdaElemDef(Element))
-        {
-            if (cCurrent == cChildren)
-                break;
-
-            if (!pXsd->Validate(pElement->GetChildren()[cCurrent], pResult))
-                break;
-
-            cCurrent++;
-        }
-        else
-        {
-            ASSERT(IsPattern(pXsd));
-            if (!pXsd->ValidatePattern(pElement, pResult, &cCurrent))
-                break;
-        }
-
-        cMatches++;
-
-        // One period matched
-        if (cMatches % cPeriod == 0)
-            cCount = cCurrent;
-
-        // Maximum periods matcheds
-        if (cMatches / cPeriod == m_max)
-            break;
-    }
-
-    // Test if the minumum number periods have been matched
-    if (cMatches / cPeriod < m_min)
-        return FALSE;
-
-    // Update the position past the matched elements
-    *pCount = cCount;
-
-    return TRUE;
-}
-
-BOOL MdaSchema::MdaSchemaChoice::ValidatePattern(MdaXmlElement* pElement, ValidationResult* pResult, COUNT_T* pCount)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    StackSString buffer;
-    LPCWSTR debug = pElement->DebugToString(&buffer);
-
-    BOOL bFound = FALSE;
-    COUNT_T cCurrent = *pCount;
-    COUNT_T cChildren = pElement->GetChildren().GetCount();
-
-    for(COUNT_T cXsd = 0; cXsd < m_children.GetCount(); cXsd++)
-    {
-        MdaSchemaBase* pXsd = m_children[cXsd];
-
-        if (IsPattern(pXsd))
-        {
-            COUNT_T cOldCurrent = cCurrent;
-            if (pXsd->ValidatePattern(pElement, pResult, &cCurrent))
-            {
-                // "Empty matches" only allowed in choice pattern if there are no children to match
-                if (cOldCurrent != cCurrent || cChildren == 0)
-                {
-                    bFound = TRUE;
-                    break;
-                }
-            }
-        }
-        else
-        {
-            if (cCurrent == cChildren)
-                break;
-
-            if (pXsd->Validate(pElement->GetChildren()[cCurrent], pResult))
-            {
-                cCurrent++;
-                bFound = TRUE;
-                break;
-            }
-        }
-    }
-
-    CpdXsdIfFailGo(bFound);
-
-    *pCount = cCurrent;
-
-    MDA_XSD_VERIFY_OK;
-    MDA_XSD_VERIFY_FAIL;
-}
-
-#define this pThis
-BOOL MdaSchema::Validate(MdaSchemaAttribute* pThis, MdaXmlElement* pElement, ValidationResult* pResult)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    StackSString sszValue;
-    MdaXmlAttribute* pAttr = (MdaXmlAttribute*)pElement->GetAttribute(pThis->m_declDef);
-
-    if (!pAttr && !pThis->m_szDefault.IsEmpty())
-    {
-        pAttr = pElement->AddDefaultAttribute(pThis->m_declDef, pThis->m_szDefault.GetUnicode());
-    }
-
-    if (!pAttr)
-    {
-        CpdXsdTest(!pThis->m_bRequired);
-        return TRUE;
-    }
-
-#ifdef _DEBUG
-    // Only necessary for validation of assistant output
-    if (pAttr->m_type != MdaSchemaPrimitiveUnknown)
-    {
-        CpdXsdTest(pAttr->m_type == pThis->m_type);
-        return TRUE;
-    }
-#endif
-
-    LPCWSTR szValue = pAttr->GetValue();
-    sszValue.Set(szValue);
-
-    if (pThis->m_type == MdaSchemaPrimitiveSString)
-    {
-        /* accept all strings? */
-    }
-    else if (pThis->m_type == MdaSchemaPrimitiveINT32)
-    {
-        CpdXsdTest(!sszValue.IsEmpty() && sszValue.GetCount() != 0);
-
-        for (COUNT_T i = 0; i < sszValue.GetCount(); i ++)
-        {
-            if (i == 0 && *szValue == W('-') && sszValue.GetCount() > 1)
-                continue;
-
-            CpdXsdTest(IS_DIGIT(szValue[i]));
-        }
-
-        pAttr->SetINT32(_wtoi(szValue));
-    }
-    else if (pThis->m_type == MdaSchemaPrimitiveBOOL)
-    {
-        CpdXsdTest(!sszValue.IsEmpty() && sszValue.GetCount() != 0);
-
-        if (sszValue.Equals(W("true")))
-            pAttr->SetBOOL(true);
-        else if (sszValue.Equals(W("false")))
-            pAttr->SetBOOL(false);
-        else
-            CpdXsdTest(FALSE);
-    }
-
-    MDA_XSD_VERIFY_OK;
-    MDA_XSD_VERIFY_FAIL;
-}
-#undef this
-
-BOOL MdaSchema::MdaSchemaBase::Validate(MdaXmlElement* pElement, ValidationResult* pResult)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    COUNT_T count = 0;
-
-    CpdXsdTest(ValidatePattern(pElement, pResult, &count));
-
-    CpdXsdTest(count == pElement->GetChildren().GetCount());
-
-    MDA_XSD_VERIFY_OK;
-    MDA_XSD_VERIFY_FAIL;
-}
-
-BOOL MdaSchema::MdaSchemaRoot::Validate(MdaXmlElement* pElement, ValidationResult* pResult)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    for(COUNT_T i = 0; i < m_children.GetCount(); i++)
-        CpdXsdIfFailGo(m_children[i]->Validate(pElement, pResult));
-
-    MDA_XSD_VERIFY_OK;
-    MDA_XSD_VERIFY_FAIL;
-}
-
-BOOL MdaSchema::MdaSchemaComplexType::Validate(MdaXmlElement* pElement, ValidationResult* pResult)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    for(COUNT_T i = 0; i < m_children.GetCount(); i++)
-        CpdXsdIfFailGo(m_children[i]->Validate(pElement, pResult));
-
-    for(COUNT_T i = 0; i < m_attributes.GetCount(); i++)
-        CpdXsdIfFailGo(m_attributes[i]->Validate(pElement, pResult));
-
-    MDA_XSD_VERIFY_OK;
-    MDA_XSD_VERIFY_FAIL;
-}
-
-BOOL MdaSchema::MdaSchemaComplexTypeDef::Validate(MdaXmlElement* pElement, ValidationResult* pResult)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    for(COUNT_T i = 0; i < m_children.GetCount(); i++)
-        CpdXsdIfFailGo(m_children[i]->Validate(pElement, pResult));
-
-    for(COUNT_T i = 0; i < m_attributes.GetCount(); i++)
-        CpdXsdIfFailGo(m_attributes[i]->Validate(pElement, pResult));
-
-    MDA_XSD_VERIFY_OK;
-    MDA_XSD_VERIFY_FAIL;
-}
-
-BOOL MdaSchema::MdaSchemaComplexContent::Validate(MdaXmlElement* pElement, ValidationResult* pResult)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    for(COUNT_T i = 0; i < m_children.GetCount(); i++)
-        CpdXsdIfFailGo(m_children[i]->Validate(pElement, pResult));
-
-    MDA_XSD_VERIFY_OK;
-    MDA_XSD_VERIFY_FAIL;
-}
-
-BOOL MdaSchema::MdaSchemaGroup::ValidatePattern(MdaXmlElement* pElement, ValidationResult* pResult, COUNT_T* pCount)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    for(COUNT_T i = 0; i < m_children.GetCount(); i++)
-    {
-        ASSERT(IsPattern(m_children[i]));
-        CpdXsdIfFailGo(m_children[i]->ValidatePattern(pElement, pResult, pCount));
-    }
-
-    MDA_XSD_VERIFY_OK;
-    MDA_XSD_VERIFY_FAIL;
-}
-
-BOOL MdaSchema::MdaSchemaGroupRef::ValidatePattern(MdaXmlElement* pElement, ValidationResult* pResult, COUNT_T* pCount)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    MdaSchemaBase* pReference = GetRef();
-    LPCWSTR debug = GetRefName();
-    ASSERT(IsPattern(this));
-    return pReference->ValidatePattern(pElement, pResult, pCount);
-}
-
-BOOL MdaSchema::MdaSchemaExtension::Validate(MdaXmlElement* pElement, ValidationResult* pResult)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    ASSERT(GetRef()->GetSchemaType() == MdaSchemaComplexTypeDefType);
-    MdaSchemaComplexTypeDef* pReference = (MdaSchemaComplexTypeDef*)GetRef();
-
-    MdaSchemaSequence sequence;
-    sequence.Initialize(1, 1);
-
-    MdaSchemaBase* pXsd = pReference;
-    while(true)
-    {
-        if (MayHaveAttr(pXsd))
-        {
-            for(COUNT_T i = 0; i < pXsd->GetAttributes().GetCount(); i++)
-                CpdXsdIfFailGo(pXsd->GetAttributes()[i]->Validate(pElement, pResult));
-        }
-
-        if (pXsd->GetSchemaType() == MdaSchemaExtensionType)
-        {
-            pXsd = ((MdaSchemaComplexTypeDef*)pXsd)->GetRef();
-            continue;
-        }
-
-        if (pXsd->m_children.GetCount() == 0)
-            break;
-
-        pXsd = pXsd->m_children[0];
-
-        if (IsPattern(pXsd))
-        {
-            sequence.AddChild(pXsd);
-            break;
-        }
-    }
-
-    if (m_children.GetCount() == 1)
-    {
-        ASSERT(IsPattern(m_children[0]));
-        sequence.AddChild(m_children[0]);
-    }
-
-    CpdXsdIfFailGo(sequence.Validate(pElement, pResult));
-
-    for(COUNT_T i = 0; i < m_attributes.GetCount(); i++)
-        CpdXsdIfFailGo(m_attributes[i]->Validate(pElement, pResult));
-
-    MDA_XSD_VERIFY_OK;
-    MDA_XSD_VERIFY_FAIL;
-}
-
-BOOL MdaSchema::MdaSchemaElementRefType::Validate(MdaXmlElement* pElement, ValidationResult* pResult)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    CpdXsdIfFailGo(GetRef()->Validate(pElement, pResult));
-
-    MDA_XSD_VERIFY_OK;
-    MDA_XSD_VERIFY_FAIL;
-}
-
-BOOL MdaSchema::MdaSchemaElementAny::Validate(MdaXmlElement* pElement, ValidationResult* pResult)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    StackSString buffer;
-    LPCWSTR debug = pElement->DebugToString(&buffer);
-
-    CpdXsdTest(pElement->GetDeclDef() == GetDeclDef());
-
-    MDA_XSD_VERIFY_OK;
-    MDA_XSD_VERIFY_FAIL;
-}
-
-BOOL MdaSchema::MdaSchemaElementRef::Validate(MdaXmlElement* pElement, ValidationResult* pResult)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    LPCWSTR debug = GetRefName();
-    CpdXsdIfFailGo(GetRef()->Validate(pElement, pResult));
-
-    MDA_XSD_VERIFY_OK;
-    MDA_XSD_VERIFY_FAIL;
-}
-
-
-//
-// MdaSchema::XXX::SetAttributes()
-//
-
-void MdaSchema::MdaSchemaSequence::SetAttributes(MdaXmlElement* pXml)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    SmallStackSString ssBound;
-
-    ssBound.Printf(W("%d"), m_min);
-    pXml->AddAttributeSz(MdaAttrDecl(MinOccurs), ssBound.GetUnicode());
-
-    if (m_max == -1)
-    {
-        pXml->AddAttributeSz(MdaAttrDecl(MaxOccurs), W("unbounded"));
-    }
-    else
-    {
-        ssBound.Printf(W("%d"), m_max);
-        pXml->AddAttributeSz(MdaAttrDecl(MaxOccurs), ssBound.GetUnicode());
-    }
-}
-
-void MdaSchema::MdaSchemaAttribute::SetAttributes(MdaXmlElement* pXml)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    pXml->AddAttributeSz(MdaAttrDecl(Name), GetAttributeName(m_declDef));
-
-    LPCWSTR szType = NULL;
-    if (m_type == MdaSchemaPrimitiveBOOL)
-        szType = W("xs:boolean");
-    else if (m_type == MdaSchemaPrimitiveINT32)
-        szType = W("xs:int");
-    else if (m_type == MdaSchemaPrimitiveSString)
-        szType = W("xs:string");
-    else { UNREACHABLE(); }
-
-    pXml->AddAttributeSz(MdaAttrDecl(Type), szType);
-    pXml->AddAttributeSz(MdaAttrDecl(Use), m_bRequired ? W("required") : W("optional"));
-
-    if (!m_szDefault.IsEmpty())
-        pXml->AddAttributeSz(MdaAttrDecl(Default), m_szDefault);
-}
-
-void MdaSchema::MdaSchemaDeclDefRef::SetAttributes(MdaXmlElement* pXml)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    LPCWSTR szDeclDef = NULL;
-    LPCWSTR szRef = NULL;
-
-    if (IsDeclDef(this))
-        szDeclDef = GetDeclDefName();
-
-    if (IsRef(this))
-        szRef = GetRefName();
-
-    switch (GetSchemaType())
-    {
-        case MdaSchemaGroupRefType:
-        case MdaSchemaElementRefTyp:
-            pXml->AddAttributeSz(MdaAttrDecl(Ref), szRef);
-            break;
-
-        case MdaSchemaExtensionType:
-            pXml->AddAttributeSz(MdaAttrDecl(Base), szRef);
-            break;
-
-        case MdaSchemaElementRefTypeType:
-            pXml->AddAttributeSz(MdaAttrDecl(Name), szDeclDef);
-            pXml->AddAttributeSz(MdaAttrDecl(Type), szRef);
-            break;
-
-        case MdaSchemaElementAnyType:
-            pXml->AddAttributeSz(MdaAttrDecl(Name), szDeclDef);
-            pXml->AddAttributeSz(MdaAttrDecl(Type), W("xs:anyType"));
-            break;
-
-        case MdaSchemaGroupType:
-        case MdaSchemaElementType:
-        case MdaSchemaComplexTypeDefType:
-            pXml->AddAttributeSz(MdaAttrDecl(Name), szDeclDef);
-            break;
-
-        default:
-            UNREACHABLE();
-    }
-}
-
-//
-// MdaAssistant
-//
-void MdaAssistant::Initialize(MdaXmlElement* pXmlInput) 
-{ 
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (pXmlInput->GetAttribute(MdaAttrDecl(SuppressDialog)))
-        m_bSuppressDialog = !!pXmlInput->GetAttributeValueAsBool(MdaAttrDecl(SuppressDialog));
-}
-
-LPCWSTR MdaAssistant::GetName()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    return MdaSchema::GetElementName(m_assistantDeclDef);
-}
-
-MdaXmlElement* MdaAssistant::GetRootElement(MdaXmlElement* pRoot, BOOL bBreak)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    MdaXmlElement* pXmlAssistant = pRoot->AddChild(GetAssistantMsgDeclDef());
-
-    if (bBreak)
-        pXmlAssistant->AddAttributeSz(MdaAttrDecl(Break), W("true"));
-
-    return pXmlAssistant;
-}
-
-BOOL MdaAssistant::IsAssistantActive(MdaXmlElement* pXml)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    return TRUE;
-}
-
-MdaXmlElement* MdaAssistant::OutputThread(Thread* pThread, MdaXmlElement* pXml)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    _ASSERTE(pThread);
-    pXml->AddAttributeInt(MdaAttrDecl(OsId), pThread->GetOSThreadId());
-    pXml->AddAttributeInt(MdaAttrDecl(ManagedId), pThread->GetThreadId());
-
-    return pXml;
-}
-
-MdaXmlElement* MdaAssistant::OutputMethodTable(MethodTable* pMT, MdaXmlElement* pXml)
-{
-    CONTRACT (MdaXmlElement*)
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pMT));
-        PRECONDITION(CheckPointer(pXml));
-        POSTCONDITION(CheckPointer(RETVAL));
-    }
-    CONTRACT_END;
-
-    static WCHAR szTemplateMsg[] = {W("Failed to QI for interface %s because it does not have a COM proxy stub registered.")};
-
-    DefineFullyQualifiedNameForClassWOnStack();
-    pXml->AddAttributeSz(MdaAttrDecl(Name), GetFullyQualifiedNameForClassW(pMT));
-
-    RETURN pXml;
-}
-
-void MdaAssistant::ToString(TypeHandle typeHandle, SString* psszFullname, SString* psszNamespace)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    StackSString ssz;;
-
-    psszFullname->Clear();
-
-    LPCSTR szDeclTypeName, szNamespace;
-    InlineSArray<mdTypeDef, 32> nesting;
-
-    mdTypeDef tkTypeDef = typeHandle.GetCl();
-    Module* pModule = typeHandle.GetModule();
-    IMDInternalImport* pImport = pModule->GetMDImport();
-
-    // Get tkTypeDef tokens for declaring type and its nested classes
-    nesting.Append(tkTypeDef);
-    while (S_OK == pImport->GetNestedClassProps(tkTypeDef, &tkTypeDef))
-        nesting.Append(tkTypeDef);
-
-    // Append the namespace
-    COUNT_T i = nesting.GetCount() - 1;
-    if (FAILED(pImport->GetNameOfTypeDef(nesting[i], &szDeclTypeName, &szNamespace)))
-    {
-        szNamespace = NULL;
-        szDeclTypeName = NULL;
-    }
-    if (szNamespace && *szNamespace != W('\0'))
-    {
-        if (psszNamespace)
-            psszNamespace->SetUTF8(szNamespace);
-
-        psszFullname->SetUTF8(szNamespace);
-        psszFullname->Append(W("."));
-    }
-
-    // Append the nested classes
-    for(; i > 0; i --)
-    {
-        IfFailThrow(pImport->GetNameOfTypeDef(nesting[i], &szDeclTypeName, &szNamespace));
-        ssz.SetUTF8(szDeclTypeName);
-        psszFullname->Append(ssz);
-        psszFullname->Append(W("+"));
-    }
-
-    // Append the declaring type name
-    IfFailThrow(pImport->GetNameOfTypeDef(nesting[i], &szDeclTypeName, &szNamespace));
-    ssz.SetUTF8(szDeclTypeName);
-    psszFullname->Append(ssz);
-}
-
-SString& MdaAssistant::ToString(SString& sszBuffer, Module* pModule)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    sszBuffer.AppendUTF8(pModule->GetSimpleName());
-    return sszBuffer;
-}
-
-SString& MdaAssistant::ToString(SString& sszBuffer, TypeHandle typeHandle)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    StackSString sszScratch;
-    ToString(sszBuffer, typeHandle.GetModule()).GetUnicode();
-    sszBuffer.Append(W("!"));
-    ToString(typeHandle, &sszScratch, NULL);
-    sszBuffer.Append(sszScratch);
-    return sszBuffer;
-}
-
-SString& MdaAssistant::ToString(SString& sszBuffer, MethodDesc* pMethodDesc)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    ToString(sszBuffer, pMethodDesc->GetMethodTable()).GetUnicode();
-    sszBuffer.Append(W("::"));
-    StackSString ssz;
-    ssz.SetUTF8(pMethodDesc->GetName());
-    sszBuffer.Append(ssz);
-    return sszBuffer;
-}
-
-SString& MdaAssistant::ToString(SString& sszBuffer, FieldDesc* pFieldDesc)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    ToString(sszBuffer, pFieldDesc->GetEnclosingMethodTable()).GetUnicode();
-    sszBuffer.Append(W("::"));
-    StackSString ssz;
-    ssz.SetUTF8(pFieldDesc->GetName());
-    sszBuffer.Append(ssz);
-    return sszBuffer;
-}
-
-MdaXmlElement* MdaAssistant::OutputParameter(SString parameterName, USHORT sequence, MethodDesc* pMethodDesc, MdaXmlElement* pXml)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    TypeHandle declType(pMethodDesc->GetMethodTable());
-    Module* pDeclModule = declType.GetModule();
-
-    pXml->AddAttributeSz(MdaAttrDecl(Name), parameterName);
-    pXml->AddAttributeInt(MdaAttrDecl(Index), sequence);
-
-    OutputMethodDesc(pMethodDesc, pXml->AddChild(MdaElemDecl(DeclaringMethod)));
-
-    return pXml;
-}
-
-MdaXmlElement* MdaAssistant::OutputMethodDesc(MethodDesc* pMethodDesc, MdaXmlElement* pXml)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    TypeHandle declType(pMethodDesc->GetMethodTable());
-    Module* pDeclModule = declType.GetModule();
-
-    StackSString sszMethod;
-
-    pXml->AddAttributeSz(MdaAttrDecl(Name), ToString(sszMethod, pMethodDesc).GetUnicode());
-
-    return pXml;
-}
-
-MdaXmlElement* MdaAssistant::OutputFieldDesc(FieldDesc* pFieldDesc, MdaXmlElement* pXml)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    StackSString sszField;
-
-    pXml->AddAttributeSz(MdaAttrDecl(Name), ToString(sszField, pFieldDesc).GetUnicode());
-
-    return pXml;
-}
-
-MdaXmlElement* MdaAssistant::OutputTypeHandle(TypeHandle typeHandle, MdaXmlElement* pXml)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    StackSString sszTypeName;
-
-    // Set Attribute
-    pXml->AddAttributeSz(MdaAttrDecl(Name), ToString(sszTypeName, typeHandle.GetMethodTable()).GetUnicode());
-
-    return pXml;
-}
-
-MdaXmlElement* MdaAssistant::OutputModule(Module* pModule, MdaXmlElement* pXml)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    pXml->AddAttributeSz(MdaAttrDecl(Name), pModule->GetSimpleName());
-
-    return pXml;
-}
-
-MdaXmlElement* MdaAssistant::OutputCallsite(MethodDesc *pMethodDesc, DWORD dwOffset, MdaXmlElement* pXml)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    StackSString sszMethod;
-    pXml->AddAttributeSz(MdaAttrDecl(Name), ToString(sszMethod, pMethodDesc).GetUnicode());
-
-    StackSString sszOffset;
-    sszOffset.Printf(W("0x%04X"), dwOffset);
-    pXml->AddAttributeSz(MdaAttrDecl(Offset), sszOffset.GetUnicode());
-
-    return pXml;
-}
-
-MdaXmlElement* MdaAssistant::OutputException(OBJECTREF *pExceptionObj, MdaXmlElement* pXml)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    OutputTypeHandle((*pExceptionObj)->GetTypeHandle(), pXml->AddChild(MdaElemDecl(Type)));
-
-    StackSString message;
-    GetExceptionMessage(*pExceptionObj, message);
-
-    pXml->AddAttributeSz(MdaAttrDecl(Message), message);
-
-    return pXml;
-}
-
-//
-// MdaQuery::CompiledQueries
-//
-BOOL MdaQuery::CompiledQueries::Test(MethodDesc* pMethodDesc)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    for (COUNT_T i = 0; i < m_queries.GetCount(); i ++)
-    {
-        if (m_queries[i]->Test(pMethodDesc))
-            return TRUE;
-    }
-
-    return FALSE;
-}
-
-BOOL MdaQuery::CompiledQueries::Test(FieldDesc* pFieldDesc)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    for (COUNT_T i = 0; i < m_queries.GetCount(); i ++)
-    {
-        if (m_queries[i]->Test(pFieldDesc))
-            return TRUE;
-    }
-
-    return FALSE;
-}
-
-BOOL MdaQuery::CompiledQueries::Test(MethodTable* pMethodTable)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    for (COUNT_T i = 0; i < m_queries.GetCount(); i ++)
-    {
-        if (m_queries[i]->Test(pMethodTable))
-            return TRUE;
-    }
-
-    return FALSE;
-}
-
-MdaQuery::CompiledQuery* MdaQuery::CompiledQueries::AddQuery()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    CompiledQuery* pQuery = m_factory.Create();
-    m_queries.Append(pQuery);
-    return pQuery;
-}
-
-
-//
-// MdaQuery::CompiledQuery
-//
-void MdaQuery::Compile(MdaXmlElement* pXmlFilters, CompiledQueries* pCompiledQueries)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    SArray<MdaXmlElement*>& children = pXmlFilters->GetChildren();
-    BOOL bJmc = pXmlFilters->GetAttribute(MdaAttrDecl(JustMyCode))->GetValueAsBool();
-
-    for (COUNT_T i = 0; i < children.GetCount(); i ++)
-    {
-        MdaXmlElement* pXmlFilter = children[i];
-        SString* psszName = pXmlFilter->GetAttribute(MdaAttrDecl(Name))->GetValueAsCSString();
-        MdaXmlAttribute* pJmcOptAttr = pXmlFilter->GetAttribute(MdaAttrDecl(JustMyCode));
-        if (pJmcOptAttr)
-            bJmc = pJmcOptAttr->GetValueAsBool();
-        Compiler compiler;
-        CompiledQuery* pQuery = pCompiledQueries->AddQuery();
-        compiler.Compile(psszName, pQuery);
-        if (bJmc)
-            pQuery->SetJustMyCode();
-    }
-}
-
-MdaQuery::CompiledQuery::CompiledQuery()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    m_bJustMyCode = FALSE;
-    m_bAnyMember = FALSE;
-    m_bAnyType = FALSE;
-    m_sszFullname.Clear();
-    m_sszMember.Clear();
-}
-
-BOOL StartsWith(SString* psszString, SString* psszSubstring)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    StackSString sszString(*psszString);
-    if (psszString->GetCount() < psszSubstring->GetCount())
-        return FALSE;
-    sszString.Truncate(sszString.Begin() + psszSubstring->GetCount());
-    return sszString.Equals(*psszSubstring);
-}
-
-BOOL MdaQuery::CompiledQuery::Test(MethodDesc* pMethodDesc)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    StackSString sszName(SString::Utf8, pMethodDesc->GetName());
-
-    if (pMethodDesc->IsLCGMethod() || pMethodDesc->IsILStub())
-        return FALSE;
-
-    if (!Test(&sszName, pMethodDesc->GetMethodTable()))
-        return FALSE;
-
-    if (!m_bJustMyCode)
-        return TRUE;
-
-    if (IsJustMyCode(pMethodDesc))
-        return TRUE;
-
-    return FALSE;
-}
-
-BOOL MdaQuery::CompiledQuery::Test(FieldDesc* pFieldDesc)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    StackSString sszName(SString::Utf8, pFieldDesc->GetName());
-    if (!Test(&sszName, pFieldDesc->GetApproxEnclosingMethodTable()))
-        return FALSE;
-
-    if (!m_bJustMyCode)
-        return TRUE;
-
-    return TRUE;
-}
-
-BOOL MdaQuery::CompiledQuery::Test(SString* psszName, MethodTable* pMethodTable)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (!m_sszMember.IsEmpty())
-    {
-        if (!m_sszMember.Equals(*psszName))
-            return FALSE;
-
-        if (m_sszMember.GetCount() == m_sszFullname.GetCount())
-            return TRUE;
-    }
-    else if (!m_bAnyMember)
-        return FALSE;
-
-    return Test(pMethodTable);
-}
-
-BOOL MdaQuery::CompiledQuery::Test(MethodTable* pMethodTable)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (!pMethodTable)
-        return FALSE;
-
-    if (m_sszFullname.IsEmpty())
-        return TRUE;
-
-    StackSString sszNamespace, sszFullName;
-    MdaAssistant::ToString(pMethodTable, &sszFullName, &sszNamespace);
-
-    if (m_bAnyType && StartsWith(&m_sszFullname, &sszNamespace))
-        return TRUE;
-
-    if (m_bAnyMember && StartsWith(&m_sszFullname, &sszFullName))
-        return TRUE;
-
-    return m_sszFullname.Equals(sszFullName);
-}
-
-void MdaQuery::CompiledQuery::SetName(LPCWSTR name)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (!m_sszFullname.IsEmpty())
-    {
-        m_sszFullname.Append(W("."));
-        m_sszMember.Clear();
-    }
-    else
-    {
-        m_sszMember.Set(name);
-    }
-
-    m_sszFullname.Append(name);
-
-}
-
-void MdaQuery::CompiledQuery::SetNestedTypeName(LPCWSTR name)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    m_sszMember.Clear();
-
-    if (!m_sszFullname.IsEmpty())
-        m_sszFullname.Append(W("+"));
-
-    m_sszFullname.Append(name);
-}
-
-void MdaQuery::CompiledQuery::SetAnyMember()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    m_bAnyMember = TRUE;
-    m_sszMember.Clear();
-}
-
-void MdaQuery::CompiledQuery::SetAnyType()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    m_bAnyType = TRUE;
-    m_sszMember.Clear();
-
-    if (m_sszFullname.IsEmpty())
-        m_bAnyMember = TRUE;
-}
-
-
-//
-// MdaQuery::CompiledQuery
-//
-
-MdaQuery::Compiler::Token MdaQuery::Compiler::LexAToken()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (*m_itr == W('\0'))
-        return MdaFilterEnd;
-
-    if (ISWHITE(*m_itr))
-    {
-        m_itr++;
-        return LexAToken();
-    }
-
-    if (ISMDAID(*m_itr))
-    {
-        m_identifier.Clear();
-
-        do
-        {
-            m_identifier.Append(*m_itr);
-            m_itr++;
-        }
-        while(ISMDAID(*m_itr));
-
-        m_identifier.Append(W("\0"));
-        return MdaFilterIdentifier;
-    }
-
-    WCHAR c = *m_itr;
-    m_itr++;
-    switch(c)
-    {
-        case W('.'): return MdaFilterDot;
-        case W(':'): return MdaFilterColon;
-        case W('*'): return MdaFilterAstrix;
-        case W('+'): return MdaFilterPlus;
-    }
-
-    return MdaFilterEnd;
-}
-
-//
-// MdaXPath::MdaXPathCompiler -- Parser
-//
-BOOL MdaQuery::Compiler::Compile(SString* sszQuery, CompiledQuery* pAst)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    m_itr = sszQuery->Begin();
-
-    NextToken();
-    BOOL bResult = NAME(pAst);
-
-    return bResult;
-}
-
-//  NAME
-//      '*'
-//      id
-//      id '.' NAME
-//      id '+' NESTNAME
-//      id ':' ':' NESTNAME
-BOOL MdaQuery::Compiler::NAME(CompiledQuery* pAst)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (TokenIs(MdaFilterIdentifier))
-    {
-        pAst->SetName(GetIdentifier());
-
-        NextToken();
-        if (TokenIs(MdaFilterDot))
-        {
-            NextToken();
-            return NAME(pAst);
-        }
-        else if (TokenIs(MdaFilterPlus))
-        {
-            NextToken();
-            return NESTNAME(pAst);
-        }
-        else if (TokenIs(MdaFilterColon))
-        {
-            NextToken();
-            if (!TokenIs(MdaFilterColon))
-                return FALSE;
-
-            NextToken();
-            return MEMBERNAME(pAst);
-        }
-    }
-    else if (TokenIs(MdaFilterAstrix))
-    {
-        pAst->SetAnyType();
-        NextToken();
-    }
-    else return FALSE;
-
-    return TRUE;
-}
-
-//  NESTNAME
-//      id '+' NESTNAME
-//      id ':' ':' NESTNAME
-BOOL MdaQuery::Compiler::NESTNAME(CompiledQuery* pAst)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (!TokenIs(MdaFilterIdentifier))
-        return FALSE;
-
-    pAst->SetNestedTypeName(GetIdentifier());
-
-    NextToken();
-
-    if (TokenIs(MdaFilterPlus))
-    {
-        NextToken();
-        return NESTNAME(pAst);
-    }
-    else if (TokenIs(MdaFilterColon))
-    {
-        NextToken();
-        if (!TokenIs(MdaFilterColon))
-            return FALSE;
-
-        NextToken();
-        return MEMBERNAME(pAst);
-    }
-    else return FALSE;
-}
-
-//  MEMBERNAME
-//      '*'
-//      id
-BOOL MdaQuery::Compiler::MEMBERNAME(CompiledQuery* pAst)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (TokenIs(MdaFilterIdentifier))
-        pAst->SetMemberName(GetIdentifier());
-
-    else if (TokenIs(MdaFilterAstrix))
-        pAst->SetAnyMember();
-
-    else return FALSE;
-
-    NextToken();
-    return TRUE;
-}
-
-
-//
-// MdaXmlElement
-//
-MdaXmlElement* MdaXmlElement::GetChild(MdaElemDeclDef declDef)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    for(COUNT_T i = 0; i < m_children.GetCount(); i ++)
-    {
-        if (m_children[i]->GetDeclDef() == declDef)
-            return m_children[i];
-    }
-
-    return NULL;
-}
-
-SString* MdaXmlElement::ToXml(SString* pXml, LPCWSTR ns, INT32 depth)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        PRECONDITION(depth < 60); // Trap for recursion
-    }
-    CONTRACTL_END;
-
-    // Indent
-    for (INT32 i = 0; i < depth; i ++)
-        pXml->Append(W("  "));
-
-    pXml->Append(W("<"));
-    if (ns && IsDefinition()) { pXml->Append(ns); pXml->Append(W(":")); }
-    pXml->Append(GetName());
-
-    if (m_attributes.GetCount() != 0)
-    {
-        for (COUNT_T i = 0; i < m_defaultAttrIndex && i < m_attributes.GetCount(); i ++)
-        {
-            pXml->Append(W(" "));
-            m_attributes[i]->ToXml(pXml);
-        }
-    }
-
-    if (m_children.GetCount() == 0)
-    {
-        if (GetDeclDef() == MdaElemComment)
-        {
-            pXml->Append(W(" "));
-            pXml->Append(m_szName.GetUnicode());
-            pXml->Append(W(" -->\n"));
-        }
-        else
-            pXml->Append(W("/>\n"));
-    }
-    else
-    {
-        pXml->Append(W(">"));
-
-        SArray<MdaXmlElement*>::Iterator itr = m_children.Begin();
-        SArray<MdaXmlElement*>::Iterator end = m_children.End();
-
-        pXml->Append(W("\n"));
-        while (itr != end)
-        {
-            (*itr)->ToXml(pXml, ns, depth + 1);
-            itr++;
-        }
-
-        // Indent
-        for (INT32 i = 0; i < depth; i ++)
-            pXml->Append(W("  "));
-
-        pXml->Append(W("</"));
-        if (ns && IsDefinition()) { pXml->Append(ns); pXml->Append(W(":")); }
-        pXml->Append(GetName());
-        pXml->Append(W(">\n"));
-    }
-
-
-    return pXml;
-}
-
-LPCWSTR MdaXmlElement::DebugToString(SString* pBuffer)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    pBuffer->Append(W("<"));
-    pBuffer->Append(GetName());
-
-    for(COUNT_T i = 0; i < GetAttributes().GetCount(); i++)
-    {
-        pBuffer->Append(W(" "));
-        GetAttributes()[i]->ToXml(pBuffer);
-    }
-
-    pBuffer->Append(W("/>"));
-    return pBuffer->GetUnicode();
-}
-
-MdaXmlElement* MdaXmlElement::SetName(LPCWSTR name, BOOL bAssertDefined)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    SetDeclDef(MdaSchema::GetElementType(name, bAssertDefined));
-
-    if (GetDeclDef() == MdaElemUndefined)
-        m_szName.Set(name);
-
-    return this;
-}
-
-MdaXmlAttribute* MdaXmlElement::AddAttribute(MdaAttrDeclDef declDef)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    return AddAttribute(m_pXmlIndustry->CreateAttribute()->SetDeclDef(declDef));
-}
-
-MdaXmlAttribute* MdaXmlElement::AddAttribute(LPCWSTR szName, LPCWSTR szValue)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    return AddAttribute(m_pXmlIndustry->CreateAttribute()->Initialize(szName, szValue));
-}
-
-MdaXmlAttribute* MdaXmlElement::AddDefaultAttribute(MdaAttrDeclDef attrDeclDef, LPCWSTR szValue)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (m_defaultAttrIndex == -1)
-        m_defaultAttrIndex = m_attributes.GetCount();
-    MdaXmlAttribute* pAttr = AddAttribute(attrDeclDef)->SetSString(szValue);
-    pAttr->m_type = MdaSchemaPrimitiveUnknown;
-    return pAttr;
-}
-
-MdaXmlElement* MdaXmlElement::AddChild(MdaXmlElement* pChild)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    //PRECONDITION(m_elemDeclDef != MdaElemUndefined);
-    PRECONDITION(CheckPointer(pChild));
-    PRECONDITION(CheckPointer(pChild->m_pXmlIndustry));
-
-    *m_children.Append() = pChild;
-    return pChild;
-}
-
-MdaXmlElement* MdaXmlElement::AddChild(LPCWSTR name, BOOL bAssertDefined)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    return AddChild(m_pXmlIndustry->CreateElement())->SetName(name, bAssertDefined);
-}
-
-MdaXmlElement* MdaXmlElement::AddChild(MdaElemDeclDef type)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    return AddChild(m_pXmlIndustry->CreateElement()->SetDeclDef(type));
-}
-
-LPCWSTR MdaXmlElement::GetName()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (GetDeclDef() == MdaElemUndefined)
-        return m_szName.GetUnicode();
-
-    return MdaSchema::GetElementName(m_elemDeclDef);
-}
-
-MdaXmlAttribute* MdaXmlElement::GetAttribute(MdaAttrDeclDef attrDeclDef)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-
-    for(UINT32 i = 0; i < m_attributes.GetCount(); i++)
-    {
-        if (attrDeclDef == m_attributes[i]->GetDeclDef())
-            return m_attributes[i];
-    }
-
-    return NULL;
-}
-
-BOOL MdaXmlElement::GetAttributeValueAsBool(MdaAttrDeclDef attrDeclDef, BOOL bDefault)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    MdaXmlAttribute* pAttr = GetAttribute(attrDeclDef);
-
-    if (!pAttr)
-        return bDefault;
-
-    return pAttr->GetValueAsBool();
-}
-
-BOOL MdaXmlElement::GetAttributeValueAsBool(MdaAttrDeclDef attrDeclDef)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    MdaXmlAttribute* pAttr = GetAttribute(attrDeclDef);
-    PREFIX_ASSUME(pAttr != NULL);
-    ASSERT(pAttr);
-    return pAttr->GetValueAsBool();
-}
-
-//
-// MdaXmlAttribute
-//
-
-SString* MdaXmlAttribute::ToXml(SString* xml)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    SString sszBuffer;
-
-    xml->Append(GetName());
-    if (!m_szNs.IsEmpty())
-    {
-        xml->Append(W(":"));
-        xml->Append(m_szNs.GetUnicode());
-    }
-
-    xml->Append(W("=\""));
-    if (m_type == MdaSchemaPrimitiveSString)
-        xml->Append(MdaXmlEscape(sszBuffer, m_value));
-    else if (m_type == MdaSchemaPrimitiveBOOL)
-        xml->Append(m_bool ? W("true") : W("false"));
-    else if (m_type == MdaSchemaPrimitiveINT32)
-    {
-        StackSString sszOutput;
-        sszOutput.Printf(W("%d"), m_int);
-        xml->Append(sszOutput);
-    }
-    xml->Append(W("\""));
-    return xml;
-}
-
-LPCWSTR MdaXmlAttribute::GetName()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (m_declDef != MdaAttrUndefined)
-        return MdaSchema::GetAttributeName(m_declDef);
-
-    return m_szName.GetUnicode();
-}
-
-MdaXmlAttribute* MdaXmlAttribute::Initialize(LPCWSTR szName, LPCWSTR szValue)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    m_type = MdaSchemaPrimitiveUnknown;
-    m_value.Set(szValue);
-
-    SetDeclDef(MdaSchema::GetAttributeType(szName, FALSE));
-    if (m_declDef == MdaAttrUndefined)
-        m_szName.Set(szName);
-
-    return this;
-}
-
-
-//
-// MdaConfigFactory
-//
-STDAPI GetXMLObjectEx(IXMLParser **ppv);
-
-MdaXmlElement* MdaConfigFactory::ParseXmlStream(MdaXmlIndustry* pXmlIndustry, LPCWSTR pszFileName)
-{
-    CONTRACT(MdaXmlElement*)
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACT_END;
-
-    HRESULT hr = S_OK;
-    MdaXmlElement* pRoot = NULL;
-
-    EX_TRY
-    {
-    {
-        if (!pszFileName)
-            goto Exit;
-
-        NonVMComHolder<IXMLParser> pIXMLParser(NULL);
-        NonVMComHolder<IStream> pFile(NULL);
-
-        hr = CreateConfigStream(pszFileName, &pFile);
-        if(FAILED(hr)) goto Exit;
-
-        hr = GetXMLObjectEx(&pIXMLParser);
-        if(FAILED(hr)) goto Exit;
-
-        hr = pIXMLParser->SetInput(pFile); // filestream's RefCount=2
-        if ( ! SUCCEEDED(hr))
-            goto Exit;
-
-        pRoot = pXmlIndustry->CreateElement()->SetDeclDef(MdaElemDef(Dummy));
-        MdaConfigFactory mdaConfigFactory(pRoot);
-
-        hr = pIXMLParser->SetFactory(&mdaConfigFactory); // factory's RefCount=2
-        if (!SUCCEEDED(hr))
-            goto Exit;
-
-        hr = pIXMLParser->Run(-1);
-
-        if (pRoot->GetChildren().GetCount() == 1)
-            pRoot = pRoot->GetChildren()[0];
-        else
-            pRoot = NULL;
-    }
-    Exit: ;
-    }
-    EX_CATCH
-    {
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-
-        if (hr == (HRESULT)XML_E_MISSINGROOT)
-            hr = S_OK;
-        else if (Assembly::FileNotFound(hr))
-            hr = S_FALSE;
-
-    RETURN pRoot;
-}
-
-HRESULT STDMETHODCALLTYPE MdaConfigFactory::CreateNode(
-    IXMLNodeSource* pSource,
-    PVOID pNodeParent,
-    USHORT cNumRecs,
-    XML_NODE_INFO** apNodeInfo)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    m_pMdaXmlElement = NULL;
-
-    for(INT32 i = 0; i < cNumRecs; i++)
-    {
-        DWORD dwType = apNodeInfo[i]->dwType;
-
-        if(dwType == XML_ELEMENT || dwType == XML_ATTRIBUTE)
-        {
-            StackSString sszName((WCHAR*)apNodeInfo[i]->pwcText, apNodeInfo[i]->ulLen);
-
-            if (dwType == XML_ELEMENT)
-            {
-                m_pMdaXmlElement = m_stack.Tos()->AddChild(sszName, FALSE);
-            }
-            else if (dwType == XML_ATTRIBUTE)
-            {
-                i++;
-                InlineSString<MDA_BUFFER_SIZE> szValue((WCHAR*)apNodeInfo[i]->pwcText, apNodeInfo[i]->ulLen);
-
-                if (m_pMdaXmlElement)
-                    m_pMdaXmlElement->AddAttribute(sszName.GetUnicode(), szValue);
-            }
-        }
-    }
-
-    return S_OK;
-}
-
-HRESULT STDMETHODCALLTYPE MdaConfigFactory::BeginChildren(
-    IXMLNodeSource* pSource,
-    XML_NODE_INFO* pNodeInfo)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    m_stack.Push(m_pMdaXmlElement);
-
-    return S_OK;
-}
-
-HRESULT STDMETHODCALLTYPE MdaConfigFactory::EndChildren(
-    IXMLNodeSource* pSource,
-    BOOL fEmptyNode,
-    XML_NODE_INFO* pNodeInfo)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-
-    if (fEmptyNode)
-        return S_OK;
-
-    m_stack.Pop();
-
-    return S_OK;
-}
-
-HRESULT STDMETHODCALLTYPE MdaConfigFactory::NotifyEvent(
-    IXMLNodeSource* pSource,
-    XML_NODEFACTORY_EVENT iEvt)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    return S_OK;
-}
-
-HRESULT STDMETHODCALLTYPE MdaConfigFactory::Error(
-    IXMLNodeSource* pSource,
-    HRESULT hrErrorCode,
-    USHORT cNumRecs,
-    XML_NODE_INFO** apNodeInfo)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    return E_FAIL;
-}
-
-#endif
diff --git a/src/vm/mda.h b/src/vm/mda.h
index b52bd00d42..c711e8ae7f 100644
--- a/src/vm/mda.h
+++ b/src/vm/mda.h
@@ -295,7 +295,6 @@ private:
     friend class MdaXmlMessage;
     friend class MdaXmlIndustry;
     friend class MdaConfigFactory;
-    friend class EEConfigFactory;
     friend class MdaFramework;
     friend void EEStartupHelper(COINITIEE fFlags);
 
diff --git a/src/vm/mdaassistants.cpp b/src/vm/mdaassistants.cpp
index e52e8ff8ec..eb9a448a3a 100644
--- a/src/vm/mdaassistants.cpp
+++ b/src/vm/mdaassistants.cpp
@@ -139,7 +139,6 @@ void TriggerGCForMDAInternal()
     {
         GCHeapUtilities::GetGCHeap()->GarbageCollect();
 
-#ifdef FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
         //
         // It is very dangerous to wait for finalizer thread here if we are inside a wait 
         // operation, as the wait operation might call into interop which calls this MDA
@@ -150,7 +149,6 @@ void TriggerGCForMDAInternal()
         // So, if we are inside a SyncContext.Wait, don't call out to FinalizerThreadWait
         //
         if (!GetThread()->HasThreadStateNC(Thread::TSNC_InsideSyncContextWait))
-#endif // FEATURE_SYNCHRONIZATIONCONTEXT_WAIT            
             // It is possible that user code run as part of finalization will wait for this thread.
             // To avoid deadlocks, we limit the wait time to 10 seconds (an arbitrary number).
             FinalizerThread::FinalizerThreadWait(10 * 1000);
diff --git a/src/vm/mdadac.cpp b/src/vm/mdadac.cpp
deleted file mode 100644
index 95be6bff60..0000000000
--- a/src/vm/mdadac.cpp
+++ /dev/null
@@ -1,48 +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.
-
-
-#include "common.h"
-#include "mda.h"
-#include "mdaassistants.h"
-#include "sstring.h"
-#include "daccess.h"
-
-#ifdef MDA_SUPPORTED
-MdaStaticHeap g_mdaStaticHeap = 
-{ 
-    { 0 },  // m_assistants[]
-    0,      // m_pMda
-    { 0 },  // m_mda[]
-
-#define MDA_ASSISTANT_STATIC_INIT
-#include "mdaschema.inl"
-#undef MDA_ASSISTANT_STATIC_INIT
-};
-
-
-//
-// MdaManagedDebuggingAssistants
-//
-void ManagedDebuggingAssistants::AllocateManagedDebuggingAssistants()
-{
-    WRAPPER_NO_CONTRACT;
-    g_mdaStaticHeap.m_pMda = new (&g_mdaStaticHeap.m_mda) ManagedDebuggingAssistants();
-}
-
-ManagedDebuggingAssistants::ManagedDebuggingAssistants()
-{
-    WRAPPER_NO_CONTRACT;
-
-#ifndef DACCESS_COMPILE
-    Initialize();
-#endif
-}
-#endif // MDA_SUPPORTED
-
-
-
-
-
-
diff --git a/src/vm/message.cpp b/src/vm/message.cpp
deleted file mode 100644
index 093f9a2629..0000000000
--- a/src/vm/message.cpp
+++ /dev/null
@@ -1,1171 +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.
-
-/*============================================================
-**
-** File:    message.cpp
-**
-** Purpose: Encapsulates a function call frame into a message
-**          object with an interface that can enumerate the
-**          arguments of the message
-**
-**
-
-===========================================================*/
-#include "common.h"
-
-#ifdef FEATURE_REMOTING
-
-#include "comdelegate.h"
-#include "excep.h"
-#include "message.h"
-#include "remoting.h"
-#include "field.h"
-#include "eeconfig.h"
-#include "invokeutil.h"
-#include "callingconvention.h"
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CMessage::GetArgCount public
-//
-//  Synopsis:   Returns number of arguments in the method call
-// 
-//+----------------------------------------------------------------------------
-FCIMPL1(INT32, CMessage::GetArgCount, MessageObject * pMessage)
-{
-    CONTRACTL
-    {
-        FCALL_CHECK;
-        PRECONDITION(CheckPointer(pMessage));
-    }
-    CONTRACTL_END;
-
-    LOG((LF_REMOTING, LL_INFO10, "CMessage::GetArgCount IN pMsg:0x%x\n", pMessage));
-
-    // Get the frame pointer from the object
-    MetaSig *pSig = pMessage->GetResetMetaSig();
-
-    // scan the sig for the argument count
-    INT32 ret = pSig->NumFixedArgs();
-
-    if (pMessage->GetDelegateMD())
-        ret -= 2;
-
-    LOG((LF_REMOTING, LL_INFO10, "CMessage::GetArgCount OUT ret:0x%x\n", ret));
-    return ret;
-}
-FCIMPLEND
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CMessage::GetArg public
-//
-//  Synopsis:   Use to enumerate a call's arguments
-// 
-//+----------------------------------------------------------------------------
-FCIMPL2(Object*, CMessage::GetArg, MessageObject* pMessageUNSAFE, INT32 argNum)
-{
-    CONTRACTL
-    {
-        FCALL_CHECK;
-        PRECONDITION(pMessageUNSAFE != NULL);
-    }
-    CONTRACTL_END;
-
-    struct _gc {
-        OBJECTREF refRetVal;
-        MESSAGEREF pMessage;
-    } gc;
-
-    gc.refRetVal = NULL;
-    gc.pMessage = (MESSAGEREF) pMessageUNSAFE;
-
-    HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc);
-
-    LOG((LF_REMOTING, LL_INFO10, "CMessage::GetArgCount IN\n"));
-
-    MetaSig *pSig = gc.pMessage->GetResetMetaSig();
-
-    if ((UINT)argNum >= pSig->NumFixedArgs())
-        COMPlusThrow(kTargetParameterCountException);
-
-    for (INT32 i = 0; i < argNum; i++)
-        pSig->NextArg();
-
-    BOOL fIsByRef = FALSE;
-    CorElementType eType = pSig->NextArg();
-    TypeHandle ty = TypeHandle();
-    if (eType == ELEMENT_TYPE_BYREF)
-    {
-        fIsByRef = TRUE;
-        TypeHandle tycopy;
-        eType = pSig->GetByRefType(&tycopy);
-        if (eType == ELEMENT_TYPE_VALUETYPE)
-            ty = tycopy;
-    }
-    else
-    {
-        if (eType == ELEMENT_TYPE_VALUETYPE)
-        {
-            ty = pSig->GetLastTypeHandleThrowing();
-
-#ifdef ENREGISTERED_PARAMTYPE_MAXSIZE
-            if (ArgIterator::IsArgPassedByRef(ty))
-                fIsByRef = TRUE;
-#endif
-        }
-    }
-
-    if (eType == ELEMENT_TYPE_PTR)
-        COMPlusThrow(kRemotingException, W("Remoting_CantRemotePointerType"));
-
-    GetObjectFromStack(&gc.refRetVal,
-        GetStackPtr(argNum, gc.pMessage->GetFrame(), gc.pMessage->GetResetMetaSig()),
-        eType,
-        ty,        
-        fIsByRef,
-        gc.pMessage->GetFrame());
-
-    LOG((LF_REMOTING, LL_INFO10, "CMessage::GetArg OUT\n"));
-
-    HELPER_METHOD_FRAME_END();
-    return OBJECTREFToObject(gc.refRetVal);
-}
-FCIMPLEND
-
-FCIMPL1(Object*, CMessage::GetArgs, MessageObject* pMessageUNSAFE)
-{
-    CONTRACTL
-    {
-        FCALL_CHECK;
-        PRECONDITION(pMessageUNSAFE != NULL);
-    }
-    CONTRACTL_END;
-
-    struct _gc {
-        PTRARRAYREF refRetVal;
-        MESSAGEREF pMessage;
-        OBJECTREF arg;
-    } gc;
-
-    gc.refRetVal = NULL;
-    gc.pMessage = (MESSAGEREF) pMessageUNSAFE;
-    gc.arg = NULL;
-
-    HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc);
-
-    LOG((LF_REMOTING, LL_INFO10, "CMessage::GetArgCount IN\n"));
-
-    MetaSig *pSig = gc.pMessage->GetResetMetaSig();
-
-    // scan the sig for the argument count
-    INT32 numArgs = pSig->NumFixedArgs();
-    if (gc.pMessage->GetDelegateMD())
-        numArgs -= 2;
-
-    // Allocate an object array
-    gc.refRetVal = (PTRARRAYREF) AllocateObjectArray(numArgs, g_pObjectClass);
-
-    ArgIterator iter(pSig);
-
-    for (int index = 0; index < numArgs; index++)
-    {
-        BOOL fIsByRef = FALSE;
-        CorElementType eType;
-        PVOID addr;
-        eType = pSig->PeekArg();
-        addr = (LPBYTE) gc.pMessage->GetFrame()->GetTransitionBlock() + GetStackOffset(gc.pMessage->GetFrame(), &iter, pSig);
-
-        TypeHandle ty = TypeHandle();
-        if (eType == ELEMENT_TYPE_BYREF)
-        {
-            fIsByRef = TRUE;
-            TypeHandle tycopy;
-            // If this is a by-ref arg, GetObjectFromStack() will dereference "addr" to
-            // get the real argument address. Dereferencing now will open a gc hole if "addr"
-            // points into the gc heap, and we trigger gc between here and the point where
-            // we return the arguments.
-            //addr = *((PVOID *) addr);
-            eType = pSig->GetByRefType(&tycopy);
-            if (eType == ELEMENT_TYPE_VALUETYPE)
-                ty = tycopy;
-        }
-        else
-        {
-            if (eType == ELEMENT_TYPE_VALUETYPE)
-            {
-                ty = pSig->GetLastTypeHandleThrowing();
-
-#ifdef ENREGISTERED_PARAMTYPE_MAXSIZE
-                if (ArgIterator::IsArgPassedByRef(ty))
-                    fIsByRef = TRUE;
-#endif
-            }
-        }
-
-        if (eType == ELEMENT_TYPE_PTR)
-            COMPlusThrow(kRemotingException, W("Remoting_CantRemotePointerType"));
-
-        GetObjectFromStack(&gc.arg,
-            addr,
-            eType,
-            ty,            
-            fIsByRef,
-            gc.pMessage->GetFrame());
-
-        gc.refRetVal->SetAt(index, gc.arg);
-    }
-
-    LOG((LF_REMOTING, LL_INFO10, "CMessage::GetArgs OUT\n"));
-
-    HELPER_METHOD_FRAME_END();
-    return OBJECTREFToObject(gc.refRetVal);
-}
-FCIMPLEND
-
-//static
-void CMessage::GetObjectFromStack(OBJECTREF* ppDest, PVOID val, const CorElementType eType, TypeHandle ty, BOOL fIsByRef, FramedMethodFrame *pFrame)
-{
-    CONTRACT_VOID
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM());
-        PRECONDITION(CheckPointer(ppDest));
-        PRECONDITION(CheckPointer(val));
-    }
-    CONTRACT_END;
-
-        // Value types like Nullable<T> have special unboxing semantics, 
-        // 
-    if (eType == ELEMENT_TYPE_VALUETYPE)
-    {
-        //
-        // box the value class
-        //
-
-        _ASSERTE(ty.GetMethodTable()->IsValueType() || ty.GetMethodTable()->IsEnum());
-
-        _ASSERTE(!GCHeapUtilities::GetGCHeap()->IsHeapPointer((BYTE *) ppDest) ||
-             !"(pDest) can not point to GC Heap");
-        MethodTable* pMT = ty.GetMethodTable();
-
-        if (pMT->IsByRefLike())
-            COMPlusThrow(kRemotingException, W("Remoting_TypeCantBeRemoted"));
-
-        PVOID* pVal;
-        if (fIsByRef)
-            pVal = (PVOID *)val;
-        else {
-            val = StackElemEndianessFixup(val, pMT->GetNumInstanceFieldBytes());
-            pVal = &val;
-        }
-
-        *ppDest = pMT->FastBox(pVal);
-        RETURN;
-     }
-
-    switch (CorTypeInfo::GetGCType(eType))
-    {
-        case TYPE_GC_NONE:
-        {
-            if(ELEMENT_TYPE_PTR == eType)
-            {
-                COMPlusThrow(kNotSupportedException);
-            }
-
-            MethodTable *pMT = MscorlibBinder::GetElementType(eType);
-
-            OBJECTREF pObj = pMT->Allocate();
-            if (fIsByRef)
-                val = *((PVOID *)val);
-            else
-                val = StackElemEndianessFixup(val, CorTypeInfo::Size(eType));
-
-            void *pDest = pObj->UnBox();
-
-#ifdef COM_STUBS_SEPARATE_FP_LOCATIONS
-            if (   !fIsByRef
-                && (   ELEMENT_TYPE_R4 == eType
-                    || ELEMENT_TYPE_R8 == eType)
-                && pFrame
-                && !TransitionBlock::IsStackArgumentOffset(static_cast<int>((TADDR) val - pFrame->GetTransitionBlock())))
-            {
-                if (ELEMENT_TYPE_R4 == eType)
-                    *(UINT32*)pDest = (UINT32)FPSpillToR4(val);
-                else
-                    *(UINT64*)pDest = (UINT64)FPSpillToR8(val);
-            }
-            else
-#endif // COM_STUBS_SEPARATE_FP_LOCATIONS
-            {
-                memcpyNoGCRefs(pDest, val, CorTypeInfo::Size(eType));
-            }
-
-            *ppDest = pObj;
-        }
-        break;
-        case TYPE_GC_REF:
-            if (fIsByRef)
-                val = *((PVOID *)val);
-            *ppDest = ObjectToOBJECTREF(*(Object **)val);
-            break;
-        default:
-            COMPlusThrow(kRemotingException, W("Remoting_TypeCantBeRemoted"));
-    }
-
-    RETURN;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CMessage::PropagateOutParameters private
-//
-//  Synopsis:   Copy back data for in/out parameters and the return value
-// 
-//+----------------------------------------------------------------------------
-FCIMPL3(void, CMessage::PropagateOutParameters, MessageObject* pMessageUNSAFE, ArrayBase* pOutPrmsUNSAFE, Object* RetValUNSAFE)
-{
-    CONTRACTL
-    {
-        FCALL_CHECK;
-        PRECONDITION(pMessageUNSAFE != NULL);
-    }
-    CONTRACTL_END;
-
-    struct _gc
-    {
-        MESSAGEREF pMessage;
-        BASEARRAYREF pOutPrms;
-        OBJECTREF RetVal;
-        OBJECTREF param;
-    } gc;
-    gc.pMessage = (MESSAGEREF) pMessageUNSAFE;
-    gc.pOutPrms = (BASEARRAYREF) pOutPrmsUNSAFE;
-    gc.RetVal = (OBJECTREF) RetValUNSAFE;
-    gc.param = NULL;
-    HELPER_METHOD_FRAME_BEGIN_PROTECT(gc);
-
-    LOG((LF_REMOTING, LL_INFO10, "CMessage::PropogateOutParameters IN\n"));
-
-    // Retrieve the message's flags.
-    INT32 flags = gc.pMessage->GetFlags();
-
-    // Construct an ArgIterator from the message's frame and sig.
-    MetaSig *pSig = gc.pMessage->GetResetMetaSig();
-    FramedMethodFrame *pFrame = gc.pMessage->GetFrame();
-    ArgIterator argit(pSig);
-
-    // move into object to return to client
-
-    // Propagate the return value only if the pMsg is not a Ctor message
-    // Check if the return type has a return buffer associated with it
-    if ((flags& MSGFLG_CTOR) == 0  && pSig->GetReturnType() != ELEMENT_TYPE_VOID)
-    {
-        if (argit.HasRetBuffArg())
-        {
-            // Copy from RetVal into the retBuff.
-            INT64 retVal =  CopyOBJECTREFToStack(
-                                *(void**)(pFrame->GetTransitionBlock() + argit.GetRetBuffArgOffset()),
-                                &gc.RetVal,
-                                pSig->GetReturnType(),
-                                TypeHandle(),
-                                pSig,
-                                TRUE);  // copy class contents
-
-            // Copy the return value
-            *(ARG_SLOT *)(gc.pMessage->GetFrame()->GetReturnValuePtr()) = retVal;
-        }
-        else
-        {
-#ifdef ENREGISTERED_RETURNTYPE_MAXSIZE
-            if (argit.HasNonStandardByvalReturn())
-            {
-                //
-                // in these cases, we put the pointer to the return buffer into the frame's
-                // return value slot
-                //
-                CopyOBJECTREFToStack(gc.pMessage->GetFrame()->GetReturnValuePtr(),
-                                     &gc.RetVal,
-                                     pSig->GetReturnType(),
-                                     TypeHandle(),
-                                     pSig,
-                                     TRUE);                 // copy class contents
-            }
-            else
-#endif // ENREGISTERED_RETURNTYPE_MAXSIZE
-            {
-                // There is no separate return buffer, the retVal should fit in
-                // an INT64.
-                INT64 retVal = CopyOBJECTREFToStack(
-                                    NULL,                   //no return buff
-                                    &gc.RetVal,
-                                    pSig->GetReturnType(),
-                                    TypeHandle(),
-                                    pSig,
-                                    FALSE);                 //don't copy class contents
-
-                // Copy the return value
-                *(ARG_SLOT *)(gc.pMessage->GetFrame()->GetReturnValuePtr()) = retVal;
-            }
-        }
-    }
-
-    // Refetch all the variables as GC could have happened after call to
-    // CopyOBJECTREFToStack
-    UINT32  cOutParams = (gc.pOutPrms != NULL) ? gc.pOutPrms->GetNumComponents() : 0;
-    if (cOutParams > 0)
-    {
-        PVOID *argAddr;
-        UINT32 i = 0;
-        MetaSig syncSig(gc.pMessage->GetMethodDesc());
-        MetaSig *pSyncSig = NULL;
-
-        if (flags & MSGFLG_ENDINVOKE)
-        {
-            pSyncSig = &syncSig;
-        }
-
-        for (i=0; i<cOutParams; i++)
-        {
-            if (pSyncSig)
-            {
-                CorElementType typ = pSyncSig->NextArg();
-                if (typ == ELEMENT_TYPE_END)
-                {
-                    break;
-                }
-
-                if (typ != ELEMENT_TYPE_BYREF)
-                {
-                    continue;
-                }
-
-                argAddr = (PVOID *)(pFrame->GetTransitionBlock() + argit.GetNextOffset());
-            }
-            else
-            {
-                int ofs = argit.GetNextOffset();
-                if (ofs == TransitionBlock::InvalidOffset)
-                {
-                    break;
-                }
-
-                if (argit.GetArgType() != ELEMENT_TYPE_BYREF)
-                {
-                    continue;
-                }
-
-                argAddr = (PVOID *)(pFrame->GetTransitionBlock() + ofs);
-            }
-
-            TypeHandle ty = TypeHandle();
-            CorElementType brType = pSig->GetByRefType(&ty);
-
-            gc.param = ((OBJECTREF *) gc.pOutPrms->GetDataPtr())[i];
-
-            CopyOBJECTREFToStack(
-                *argAddr,
-                &gc.param,
-                brType,
-                ty,
-                pSig,
-                ty.IsNull() ? FALSE : ty.IsValueType());
-        }
-
-    }
-
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-
-INT64 CMessage::CopyOBJECTREFToStack(PVOID pvDest, OBJECTREF *pSrc, CorElementType typ, TypeHandle ty, MetaSig *pSig, BOOL fCopyClassContents)
-{
-    INT64 ret = 0;
-
-    CONTRACT(INT64)
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM());
-        PRECONDITION(CheckPointer(pvDest, NULL_OK));
-        PRECONDITION(CheckPointer(pSrc));
-        PRECONDITION(typ != ELEMENT_TYPE_VOID);
-        PRECONDITION(CheckPointer(pSig));
-    }
-    CONTRACT_END;
-
-    if (fCopyClassContents)
-    {
-        // We have to copy the contents of a value class to pvDest
-
-        // write unboxed version back to memory provided by the client
-        if (pvDest)
-        {
-            if (ty.IsNull())
-                ty = pSig->GetRetTypeHandleThrowing();
-
-            if (*pSrc == NULL && !Nullable::IsNullableType(ty))
-                COMPlusThrow(kRemotingException, W("Remoting_Message_BadRetValOrOutArg"));
-
-            ty.GetMethodTable()->UnBoxIntoUnchecked(pvDest, *pSrc);            
-
-            // return the object so it can be stored in the frame and
-            // propagated to the root set
-            // pSrc may not be doubleword aligned!
-            *(OBJECTREF*)&ret  = *pSrc;
-        }
-    }
-    else
-    {
-        // We have either a real OBJECTREF or something that does not have
-        // a return buffer associated
-
-        // Check if it is an ObjectRef (from the GC heap)
-        if (CorTypeInfo::IsObjRef(typ))
-        {
-            if ((*pSrc!=NULL) && ((*pSrc)->IsTransparentProxy()))
-            {
-                if (ty.IsNull())
-                    ty = pSig->GetRetTypeHandleThrowing();
-
-                // CheckCast ensures that the returned object (proxy) gets
-                // refined to the level expected by the caller of the method
-                if (!CRemotingServices::CheckCast(*pSrc, ty))
-                    COMPlusThrow(kInvalidCastException, W("Arg_ObjObj"));
-            }
-            if (pvDest)
-                SetObjectReferenceUnchecked((OBJECTREF *)pvDest, *pSrc);
-
-            // pSrc may not be double-word aligned!
-            *(OBJECTREF*)&ret  = *pSrc;
-        }
-        else
-        {
-            // Note: this assert includes VALUETYPE because for Enums
-            // HasRetBuffArg() returns false since the normalized type is I4
-            // so we end up here ... but GetReturnType() returns VALUETYPE
-            // Almost all VALUETYPEs will go through the fCopyClassContents
-            // codepath instead of here.
-            // Also, IsPrimitiveType() does not check for IntPtr, UIntPtr etc
-            // there is a note in siginfo.hpp about that ... hence we have
-            // ELEMENT_TYPE_I, ELEMENT_TYPE_U.
-            _ASSERTE(
-                CorTypeInfo::IsPrimitiveType(typ)
-                || (typ == ELEMENT_TYPE_VALUETYPE)
-                || (typ == ELEMENT_TYPE_I)
-                || (typ == ELEMENT_TYPE_U)
-                || (typ == ELEMENT_TYPE_FNPTR)
-                );
-
-            // REVIEW: For a "ref int" arg, if a nasty sink replaces the boxed
-            // int with a null OBJECTREF, this is where we check. We need to be
-            // uniform in our policy w.r.t. this (throw v/s ignore)
-            // The 'if' block above throws, CallFieldAccessor also has this
-            // problem.
-            if (*pSrc != NULL)
-            {
-                PVOID pvSrcData = (*pSrc)->GetData();
-                int cbsize = gElementTypeInfo[typ].m_cbSize;
-                INT64 retBuff;
-
-                // ElementTypeInfo.m_cbSize can be less that zero for cases that need 
-                // special handling (e.g. value types) to be sure of size (see 
-                // siginfo.cpp).  Luckily, the type handle has the actual byte count,
-                // so we look there for such cases.
-                if (cbsize < 0)
-                {
-                    if (ty.IsNull())
-                        ty = pSig->GetRetTypeHandleThrowing();
-
-                    _ASSERTE(!ty.IsNull());
-                    cbsize = ty.GetSize();
-                    
-                        // we are returning this value class in an INT64 so it better be small enough
-                    _ASSERTE(cbsize <= (int) sizeof(INT64));
-                        // Unbox it into a local buffer, This coveres the Nullable<T> case
-                        // then do the endianness morph below
-                     ty.GetMethodTable()->UnBoxIntoUnchecked(&retBuff, *pSrc);
-
-                    pvSrcData = &retBuff;
-                }
-
-                if (pvDest)
-                {
-                    memcpyNoGCRefs(pvDest, pvSrcData, cbsize);
-                }
-
-                // need to sign-extend signed types
-                bool fEndianessFixup = false;
-                switch (typ) {                    
-                case ELEMENT_TYPE_I1:
-                    ret = *(INT8*)pvSrcData;
-                    fEndianessFixup = true;
-                    break;
-                case ELEMENT_TYPE_I2:
-                    ret = *(INT16*)pvSrcData;
-                    fEndianessFixup = true;
-                    break;
-                case ELEMENT_TYPE_I4:
-                    ret = *(INT32*)pvSrcData;
-                    fEndianessFixup = true;
-                    break;
-                default:
-                    memcpyNoGCRefs(StackElemEndianessFixup(&ret, cbsize), pvSrcData, cbsize);
-                    break;
-                }
-
-#if !defined(_WIN64) && BIGENDIAN
-                if (fEndianessFixup)
-                    ret <<= 32;
-#endif
-            }
-        }
-    }
-
-    RETURN(ret);
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CMessage::GetReturnValue
-//
-//  Synopsis:   Pull return value off the stack
-// 
-//+----------------------------------------------------------------------------
-FCIMPL1(Object*, CMessage::GetReturnValue, MessageObject* pMessageUNSAFE)
-{
-    CONTRACTL
-    {
-        FCALL_CHECK;
-        PRECONDITION(pMessageUNSAFE != NULL);
-    }
-    CONTRACTL_END;
-
-    struct _gc {
-        OBJECTREF refRetVal;
-        MESSAGEREF pMessage;
-    } gc;
-
-    gc.refRetVal = NULL;
-    gc.pMessage = (MESSAGEREF) pMessageUNSAFE;
-
-    HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc);
-
-    MetaSig* pSig = gc.pMessage->GetResetMetaSig();
-    FramedMethodFrame* pFrame = gc.pMessage->GetFrame();
-
-    ArgIterator argit(pSig);
-
-    PVOID pvRet;
-    if (argit.HasRetBuffArg())
-    {
-        pvRet = *(PVOID *)(pFrame->GetTransitionBlock() + argit.GetRetBuffArgOffset());
-    }
-    else
-    {
-        pvRet = pFrame->GetReturnValuePtr();
-    }
-
-    CorElementType eType = pSig->GetReturnType();
-    TypeHandle ty;
-    if (eType == ELEMENT_TYPE_VALUETYPE)
-    {
-        ty = pSig->GetRetTypeHandleThrowing();
-    }
-    else
-    {
-        ty = TypeHandle();
-    }
-
-    GetObjectFromStack(&gc.refRetVal,
-        pvRet,
-        eType,
-        ty);
-
-    HELPER_METHOD_FRAME_END();
-    return OBJECTREFToObject(gc.refRetVal);
-}
-FCIMPLEND
-
-
-
-FCIMPL2(FC_BOOL_RET, CMessage::Dispatch, MessageObject* pMessageUNSAFE, Object* pServerUNSAFE)
-{
-    CONTRACTL
-    {
-        FCALL_CHECK;
-        PRECONDITION(pMessageUNSAFE != NULL);
-        PRECONDITION(pServerUNSAFE != NULL);
-    }
-    CONTRACTL_END;
-
-    BOOL fDispatched = FALSE;
-    MESSAGEREF pMessage = (MESSAGEREF) pMessageUNSAFE;
-    OBJECTREF pServer = (OBJECTREF) pServerUNSAFE;
-    HELPER_METHOD_FRAME_BEGIN_RET_2(pMessage, pServer);
-
-    MetaSig *pSig = pMessage->GetResetMetaSig();
-
-    if (pMessage->GetFlags() & (MSGFLG_BEGININVOKE | MSGFLG_ENDINVOKE | MSGFLG_ONEWAY))
-    {
-        fDispatched = FALSE;
-        goto lExit;
-    }
-
-    {
-    ArgIterator argit(pSig);
-
-    UINT nStackBytes;
-    MethodDesc *pMD;
-    PCODE pTarget;
-
-    nStackBytes = argit.SizeOfFrameArgumentArray();
-    pMD = pMessage->GetMethodDesc();
-
-    // Get the address of the code
-    pTarget = pMD->GetCallTarget(&(pServer));
-
-#ifdef PROFILING_SUPPORTED
-    // If we're profiling, notify the profiler that we're about to invoke the remoting target
-    {
-        BEGIN_PIN_PROFILER(CORProfilerTrackRemoting());
-        GCX_PREEMP();
-        g_profControlBlock.pProfInterface->RemotingServerInvocationStarted();
-        END_PIN_PROFILER();
-    }        
-#endif // PROFILING_SUPPORTED
-
-#ifdef CALLDESCR_FPARGREGS
-    // @TODO: This code badly needs refactorization. It's largely shared with MethodDesc::CallDescr in
-    // method.cpp and CallDescrWithObjectArray in stackbuildersync.cpp.
-
-    FloatArgumentRegisters *pFloatArgumentRegisters = NULL;
-
-    // Iterate through all the args looking for floating point values that will be passed in (FP) argument
-    // registers.
-    int ofs;
-    while ((ofs = argit.GetNextOffset()) != TransitionBlock::InvalidOffset)
-    {
-        if (TransitionBlock::HasFloatRegister(ofs, argit.GetArgLocDescForStructInRegs()))
-        {
-            // Found a floating point argument register. The first time we find this we point
-            // pFloatArgumentRegisters to the part of the frame where these values were spilled (we don't do
-            // this unconditionally since the call worker can optimize out the copy of the floating point
-            // registers if none are involved at all.
-            pFloatArgumentRegisters = (FloatArgumentRegisters*)(pMessage->GetFrame()->GetTransitionBlock() +
-                                                                TransitionBlock::GetOffsetOfFloatArgumentRegisters());
-
-            // That's all we need to do, CallDescrWorkerWithHandler will automatically pick up all the
-            // floating point argument values now.
-            break;
-        }
-    }
-#endif // CALLDESCR_FPARGREGS
-
-#if defined(CALLDESCR_REGTYPEMAP) || defined(COM_STUBS_SEPARATE_FP_LOCATIONS)
-    DWORD_PTR   dwRegTypeMap    = 0;
-
-    {
-        int ofs;
-        while ((ofs = argit.GetNextOffset()) != TransitionBlock::InvalidOffset)
-        {
-            int regArgNum = TransitionBlock::GetArgumentIndexFromOffset(ofs);
-
-            if (regArgNum >= NUM_ARGUMENT_REGISTERS)
-                break;
-
-            CorElementType argTyp = argit.GetArgType();
-
-#ifdef CALLDESCR_REGTYPEMAP
-            FillInRegTypeMap(ofs, argTyp, (BYTE*)&dwRegTypeMap);
-#endif
-
-#ifdef COM_STUBS_SEPARATE_FP_LOCATIONS
-            // If this is a floating point argument, it was stored in a
-            // separate area of the frame.  Copy it into the argument array.
-            if (ELEMENT_TYPE_R4 == argTyp || ELEMENT_TYPE_R8 == argTyp)
-            {
-                TADDR pTransitionBlock = pMessage->GetFrame()->GetTransitionBlock();
-
-                PVOID pDest = (PVOID)(pTransitionBlock + ofs);
-                PVOID pSrc = (PVOID)(pTransitionBlock + pMessage->GetFrame()->GetFPArgOffset(regArgNum));
-
-                ARG_SLOT val;
-                if (ELEMENT_TYPE_R4 == argTyp)
-                    val = FPSpillToR4(pSrc);
-                else
-                    val = FPSpillToR8(pSrc);
-
-                *(ARG_SLOT*)pDest = val;
-            }
-#endif
-        }
-    }
-#endif // CALLDESCR_REGTYPEMAP || COM_STUBS_SEPARATE_FP_LOCATIONS
-
-    CallDescrData callDescrData;
-
-    callDescrData.pSrc = (BYTE*)pMessage->GetFrame()->GetTransitionBlock() + sizeof(TransitionBlock);
-    callDescrData.numStackSlots = nStackBytes / STACK_ELEM_SIZE;
-#ifdef CALLDESCR_ARGREGS
-    callDescrData.pArgumentRegisters = (ArgumentRegisters*)(pMessage->GetFrame()->GetTransitionBlock() + TransitionBlock::GetOffsetOfArgumentRegisters());
-#endif
-#ifdef CALLDESCR_FPARGREGS
-    callDescrData.pFloatArgumentRegisters = pFloatArgumentRegisters;
-#endif
-#ifdef CALLDESCR_REGTYPEMAP
-    callDescrData.dwRegTypeMap = dwRegTypeMap;
-#endif
-    callDescrData.fpReturnSize = argit.GetFPReturnSize();
-    callDescrData.pTarget = pTarget;
-
-    CallDescrWorkerWithHandler(&callDescrData);
-
-#ifdef PROFILING_SUPPORTED
-    // If we're profiling, notify the profiler that we're about to invoke the remoting target
-    {
-        BEGIN_PIN_PROFILER(CORProfilerTrackRemoting());
-        GCX_PREEMP();
-        g_profControlBlock.pProfInterface->RemotingServerInvocationReturned();
-        END_PIN_PROFILER();
-    }
-#endif // PROFILING_SUPPORTED
-
-    memcpyNoGCRefs(pMessage->GetFrame()->GetReturnValuePtr(), &callDescrData.returnValue, sizeof(callDescrData.returnValue));
-
-    fDispatched = TRUE;
-    }
-
-lExit: ;
-    HELPER_METHOD_FRAME_END();
-    FC_RETURN_BOOL(fDispatched);
-}
-FCIMPLEND
-
-void CMessage::AppendAssemblyName(CQuickBytes &out, const CHAR* str)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM());
-        PRECONDITION(CheckPointer(str));
-    }
-    CONTRACTL_END;
-
-    SIZE_T len = strlen(str) * sizeof(CHAR);
-    SIZE_T oldSize = out.Size();
-    out.ReSizeThrows(oldSize + len + 2);
-    CHAR * cur = (CHAR *) ((BYTE *) out.Ptr() + oldSize - 1);
-    if (*cur)
-        cur++;
-
-    *cur = ASSEMBLY_SEPARATOR_CHAR;
-    memcpy(cur + 1, str, len);
-    cur += (len + 1);
-    *cur = '\0';
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CMessage::GetAsyncBeginInfo
-//
-//  Synopsis:   Pull the AsyncBeginInfo object from an async call
-// 
-//+----------------------------------------------------------------------------
-FCIMPL3(void, CMessage::GetAsyncBeginInfo, MessageObject* pMessageUNSAFE, OBJECTREF* ppACBD, OBJECTREF* ppState)
-{
-    CONTRACTL
-    {
-        FCALL_CHECK;
-        PRECONDITION(pMessageUNSAFE != NULL);
-    }
-    CONTRACTL_END;
-
-    MESSAGEREF pMessage = (MESSAGEREF) pMessageUNSAFE;
-    _ASSERTE(pMessage->GetFlags() & MSGFLG_BEGININVOKE);
-
-    HELPER_METHOD_FRAME_BEGIN_1(pMessage);
-
-    LOG((LF_REMOTING, LL_INFO10, "CMessage::GetAsyncBeginInfo IN\n"));
-
-    if (pMessage == NULL)
-        COMPlusThrow(kNullReferenceException, W("NullReference_This"));
-
-    MetaSig *pSig = pMessage->GetResetMetaSig();
-
-    FramedMethodFrame * pFrame = pMessage->GetFrame();
-    ArgIterator argit(pSig);
-
-    if ((ppACBD != NULL) || (ppState != NULL))
-    {
-        int ofs;
-        int last = TransitionBlock::InvalidOffset, secondtolast = TransitionBlock::InvalidOffset;
-        while ((ofs = argit.GetNextOffset()) != TransitionBlock::InvalidOffset)
-        {
-            secondtolast = last;
-            last = ofs;
-        }
-        _ASSERTE(secondtolast != TransitionBlock::InvalidOffset);
-        if (secondtolast != TransitionBlock::InvalidOffset && ppACBD != NULL)
-            SetObjectReferenceUnchecked(ppACBD, ObjectToOBJECTREF(*(Object **)(pFrame->GetTransitionBlock() + secondtolast)));
-        PREFIX_ASSUME(last != TransitionBlock::InvalidOffset);
-        if (ppState != NULL)
-            SetObjectReferenceUnchecked(ppState, ObjectToOBJECTREF(*(Object **)(pFrame->GetTransitionBlock() + last)));
-    }
-
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CMessage::GetAsyncResult
-//
-//  Synopsis:   Pull the AsyncResult from an async call
-// 
-//+----------------------------------------------------------------------------
-FCIMPL1(LPVOID, CMessage::GetAsyncResult, MessageObject* pMessageUNSAFE)
-{
-    CONTRACTL
-    {
-        FCALL_CHECK;
-        PRECONDITION(pMessageUNSAFE != NULL);
-    }
-    CONTRACTL_END;
-
-    LPVOID retVal = NULL;
-    MESSAGEREF pMessage = (MESSAGEREF) pMessageUNSAFE;
-    _ASSERTE(pMessage->GetFlags() & MSGFLG_ENDINVOKE);
-
-    HELPER_METHOD_FRAME_BEGIN_RET_1(pMessage);
-
-    LOG((LF_REMOTING, LL_INFO10, "CMessage::GetAsyncResult IN\n"));
-
-    retVal = GetLastArgument(&pMessage);
-
-    HELPER_METHOD_FRAME_END();
-    return retVal;
-}
-FCIMPLEND
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CMessage::GetAsyncObject
-//
-//  Synopsis:   Pull the AsyncObject from an async call
-// 
-//+----------------------------------------------------------------------------
-FCIMPL1(Object*, CMessage::GetAsyncObject, MessageObject* pMessageUNSAFE)
-{
-    CONTRACTL
-    {
-        FCALL_CHECK;
-        PRECONDITION(pMessageUNSAFE != NULL);
-    }
-    CONTRACTL_END;
-
-    Object* pobjRetVal = NULL;
-    MESSAGEREF pMessage = (MESSAGEREF) pMessageUNSAFE;
-    HELPER_METHOD_FRAME_BEGIN_RET_1(pMessage);
-
-    LOG((LF_REMOTING, LL_INFO10, "CMessage::GetAsyncObject IN\n"));
-
-    FramedMethodFrame *pFrame = pMessage->GetFrame();
-    MetaSig *pSig = pMessage->GetResetMetaSig();
-    ArgIterator argit(pSig);
-
-    pobjRetVal = *(Object**)(pFrame->GetTransitionBlock() + argit.GetThisOffset());
-
-    HELPER_METHOD_FRAME_END();
-    return pobjRetVal;
-}
-FCIMPLEND
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CMessage::GetLastArgument private
-//
-//  Synopsis:   Pull the last argument of 4 bytes off the stack
-// 
-//+----------------------------------------------------------------------------
-LPVOID CMessage::GetLastArgument(MESSAGEREF *pMsg)
-{
-    CONTRACT(LPVOID)
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(CheckPointer(pMsg));
-        POSTCONDITION(*pMsg != NULL); // CheckPointer doesn't seem to work here.
-        POSTCONDITION(CheckPointer(RETVAL, NULL_OK));
-    }
-    CONTRACT_END;
-
-    FramedMethodFrame *pFrame = (*pMsg)->GetFrame();
-    MetaSig *pSig = (*pMsg)->GetResetMetaSig();
-
-    ArgIterator argit(pSig);
-    int arg;
-    int backadder = TransitionBlock::InvalidOffset;
-    while ((arg = argit.GetNextOffset()) != TransitionBlock::InvalidOffset)
-        backadder = arg;
-
-    _ASSERTE(backadder != TransitionBlock::InvalidOffset);
-
-    RETURN *(LPVOID *)(pFrame->GetTransitionBlock() + backadder);
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CMessage::DebugOut public
-//
-//  Synopsis:   temp Debug out until the classlibs have one.
-// 
-//+----------------------------------------------------------------------------
-FCIMPL1(void, CMessage::DebugOut, StringObject* pOutUNSAFE)
-{
-    CONTRACTL
-    {
-        FCALL_CHECK;
-        PRECONDITION(pOutUNSAFE != NULL);
-    }
-    CONTRACTL_END;
-
-#ifdef _DEBUG
-    STRINGREF pOut = (STRINGREF) pOutUNSAFE;
-    HELPER_METHOD_FRAME_BEGIN_1(pOut);
-
-    static int fMessageDebugOut = 0;
-
-    if (fMessageDebugOut == 0)
-        fMessageDebugOut = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_MessageDebugOut) ? 1 : -1;
-
-    if (fMessageDebugOut == 1)
-        WszOutputDebugString(pOut->GetBuffer());
-
-    HELPER_METHOD_FRAME_END();
-#endif
-
-    FCUnique(0x76);
-}
-FCIMPLEND
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CMessage::HasVarArgs public
-//
-//  Synopsis:   Return TRUE if the method is a VarArgs Method
-// 
-//+----------------------------------------------------------------------------
-FCIMPL1(FC_BOOL_RET, CMessage::HasVarArgs, MessageObject * pMessage)
-{
-    CONTRACTL
-    {
-        FCALL_CHECK;
-        PRECONDITION(CheckPointer(pMessage));
-    }
-    CONTRACTL_END;
-
-    BOOL result;
-
-    // Need entire path to be SO_TOLERANT or put a Hard SO probe here as
-    // no failure path.
-    CONTRACT_VIOLATION(SOToleranceViolation);
-
-    result = pMessage->GetMethodDesc()->IsVarArg();
-
-    FC_RETURN_BOOL(result);
-}
-FCIMPLEND
-
-
-//static
-int CMessage::GetStackOffset (FramedMethodFrame *pFrame, ArgIterator *pArgIter, MetaSig *pSig)
-{
-    CONTRACT(int)
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM());
-        PRECONDITION(CheckPointer(pFrame));
-        PRECONDITION(CheckPointer(pArgIter));
-        PRECONDITION(CheckPointer(pSig));
-    }
-    CONTRACT_END;
-
-    LOG((LF_REMOTING, LL_INFO100,
-         "CMessage::GetStackOffset pFrame:0x%x, pArgIter:0x%x\n",
-         pFrame, pArgIter));
-
-    int ret = pArgIter->GetNextOffset();
-
-#ifdef COM_STUBS_SEPARATE_FP_LOCATIONS
-    int typ = pArgIter->GetArgType();
-    // REVISIT_TODO do we need to handle this?
-    if ((ELEMENT_TYPE_R4 == typ || ELEMENT_TYPE_R8 == typ) &&
-        TransitionBlock::IsArgumentRegisterOffset(ret))
-    {
-        int iFPArg = TransitionBlock::GetArgumentIndexFromOffset(ret);
-
-        ret = static_cast<int>(pFrame->GetFPArgOffset(iFPArg));
-    }
-#endif // COM_STUBS_SEPARATE_FP_LOCATIONS
-
-    RETURN ret;
-}
-
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CMessage::GetStackPtr private
-//
-//  Synopsis:   Figure out where on the stack a parameter is stored
-//
-//  Parameters: ndx     - the parameter index (zero-based)
-//              pFrame  - stack frame pointer (FramedMethodFrame)
-//              pSig    - method signature, used to determine parameter sizes
-// 
-//
-//<REVISIT_TODO>
-//  CODEWORK:   Currently we assume all parameters to be 32-bit intrinsics
-//              or 32-bit pointers.  Value classes are not handled correctly.
-//</REVISIT_TODO>
-//+----------------------------------------------------------------------------
-PVOID CMessage::GetStackPtr(INT32 ndx, FramedMethodFrame *pFrame, MetaSig *pSig)
-{
-    CONTRACT(PVOID)
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM());
-        PRECONDITION(CheckPointer(pFrame));
-        PRECONDITION(CheckPointer(pSig));
-        POSTCONDITION(CheckPointer(RETVAL, NULL_OK));
-    }
-    CONTRACT_END;
-
-    LOG((LF_REMOTING, LL_INFO100,
-         "CMessage::GetStackPtr IN ndx:0x%x, pFrame:0x%x, pSig:0x%x\n",
-         ndx, pFrame, pSig));
-
-    ArgIterator iter(pSig);
-    PVOID ret = NULL;
-
-    // <REVISIT_TODO>CODEWORK:: detect and optimize for sequential access</REVISIT_TODO>
-    _ASSERTE((UINT)ndx < pSig->NumFixedArgs());
-    for (int i=0; i<=ndx; i++)
-        ret = (BYTE*)pFrame->GetTransitionBlock() + GetStackOffset(pFrame, &iter, pSig);
-
-    RETURN ret;
-}
-
-#endif //FEATURE_REMOTING
diff --git a/src/vm/metasig.h b/src/vm/metasig.h
index a8404615a1..71e4acc554 100644
--- a/src/vm/metasig.h
+++ b/src/vm/metasig.h
@@ -32,7 +32,6 @@
 //   r  -- Ref  -- a byref
 //         Ret  -- indicates function return type
 //
-//         PMS  -- PermissionSet
 //         Var  -- Variant
 //
 //   b  -- Byte -- (unsigned) byte
@@ -306,8 +305,6 @@ DEFINE_METASIG_T(SM(Exception_RetInt, C(EXCEPTION), i))
 DEFINE_METASIG_T(SM(ContextBoundObject_RetObj, C(CONTEXT_BOUND_OBJECT), j))
 #endif
 
-DEFINE_METASIG_T(SM(PMS_PMS_RetInt, C(PERMISSION_SET) C(PERMISSION_SET), i))
-
 DEFINE_METASIG(SM(IntPtr_RetVoid, I, v))
 DEFINE_METASIG(SM(IntPtr_Bool_RetVoid, I F, v))
 DEFINE_METASIG(SM(IntPtr_UInt_IntPtr_RetVoid, I K I, v))
@@ -342,51 +339,10 @@ DEFINE_METASIG_T(SM(RefDateTimeOffset_RefDateTimeNative_RetVoid, r(g(DATE_TIME_O
 DEFINE_METASIG_T(SM(RealProxy_Class_RetBool, C(REAL_PROXY) C(CLASS), F))
 #endif
 
-DEFINE_METASIG_T(SM(IPermission_RetPermissionToken, C(IPERMISSION), C(PERMISSION_TOKEN)))
-DEFINE_METASIG_T(SM(FrameSecurityDescriptor_IPermission_PermissionToken_RuntimeMethodHandleInternal_RetBool, \
-                 C(FRAME_SECURITY_DESCRIPTOR) C(IPERMISSION) C(PERMISSION_TOKEN) g(METHOD_HANDLE_INTERNAL), F))
-DEFINE_METASIG_T(SM(FrameSecurityDescriptor_PMS_OutPMS_RuntimeMethodHandleInternal_RetBool, \
-                 C(FRAME_SECURITY_DESCRIPTOR) C(PERMISSION_SET) r(C(PERMISSION_SET)) g(METHOD_HANDLE_INTERNAL), F))
-DEFINE_METASIG_T(SM(FrameSecurityDescriptor_RetInt, C(FRAME_SECURITY_DESCRIPTOR), i))
-DEFINE_METASIG_T(SM(DynamicResolver_IPermission_PermissionToken_RuntimeMethodHandleInternal_RetBool, \
-                 C(DYNAMICRESOLVER) C(IPERMISSION) C(PERMISSION_TOKEN) g(METHOD_HANDLE_INTERNAL), F))
-DEFINE_METASIG_T(SM(DynamicResolver_PMS_OutPMS_RuntimeMethodHandleInternal_RetBool, \
-                 C(DYNAMICRESOLVER) C(PERMISSION_SET) r(C(PERMISSION_SET)) g(METHOD_HANDLE_INTERNAL), F))
-DEFINE_METASIG_T(SM(PermissionListSet_PMS_PMS_RetPermissionListSet, \
-                 C(PERMISSION_LIST_SET) C(PERMISSION_SET) C(PERMISSION_SET), C(PERMISSION_LIST_SET)))
-DEFINE_METASIG_T(SM(PMS_IntPtr_RuntimeMethodHandleInternal_Assembly_SecurityAction_RetVoid, C(PERMISSION_SET) I g(METHOD_HANDLE_INTERNAL) C(ASSEMBLY) g(SECURITY_ACTION), v))
-#ifdef FEATURE_COMPRESSEDSTACK
-DEFINE_METASIG_T(SM(CS_PMS_PMS_CodeAccessPermission_PermissionToken_RuntimeMethodHandleInternal_Assembly_SecurityAction_RetVoid, \
-                 C(COMPRESSED_STACK) C(PERMISSION_SET) C(PERMISSION_SET) C(CODE_ACCESS_PERMISSION) C(PERMISSION_TOKEN) g(METHOD_HANDLE_INTERNAL) C(ASSEMBLY) g(SECURITY_ACTION), v))
-DEFINE_METASIG_T(SM(CS_PMS_PMS_PMS_RuntimeMethodHandleInternal_Assembly_SecurityAction_RetVoid, C(COMPRESSED_STACK) C(PERMISSION_SET) C(PERMISSION_SET) C(PERMISSION_SET) g(METHOD_HANDLE_INTERNAL) C(ASSEMBLY) g(SECURITY_ACTION), v))
-#else // #ifdef FEATURE_COMPRESSEDSTACK
-DEFINE_METASIG_T(SM(CS_PMS_PMS_CodeAccessPermission_PermissionToken_RuntimeMethodHandleInternal_Assembly_SecurityAction_RetVoid, \
-                 j C(PERMISSION_SET) C(PERMISSION_SET) C(CODE_ACCESS_PERMISSION) C(PERMISSION_TOKEN) g(METHOD_HANDLE_INTERNAL) C(ASSEMBLY) g(SECURITY_ACTION), v))
-DEFINE_METASIG_T(SM(CS_PMS_PMS_PMS_RuntimeMethodHandleInternal_Assembly_SecurityAction_RetVoid, j C(PERMISSION_SET) C(PERMISSION_SET) C(PERMISSION_SET) g(METHOD_HANDLE_INTERNAL) C(ASSEMBLY) g(SECURITY_ACTION), v))
-#endif // #ifdef FEATURE_COMPRESSEDSTACK
-DEFINE_METASIG_T(SM(Evidence_RefInt_Bool_RetPMS, C(EVIDENCE) r(i) F, C(PERMISSION_SET)))
-#ifdef FEATURE_APTCA
-DEFINE_METASIG_T(SM(Assembly_PMS_PMS_RuntimeMethodHandleInternal_SecurityAction_Obj_IPermission_RetVoid, C(ASSEMBLY) C(PERMISSION_SET) C(PERMISSION_SET) g(METHOD_HANDLE_INTERNAL) g(SECURITY_ACTION) j C(IPERMISSION), v))
-#endif // FEATURE_APTCA
-DEFINE_METASIG_T(SM(Evidence_PMS_PMS_PMS_PMS_int_Bool_RetPMS, \
-                 C(EVIDENCE) C(PERMISSION_SET) C(PERMISSION_SET) C(PERMISSION_SET) r(C(PERMISSION_SET)) r(i) F, C(PERMISSION_SET)))
-DEFINE_METASIG_T(SM(Int_PMS_RetVoid, i C(PERMISSION_SET), v))
-DEFINE_METASIG_T(SM(Int_PMS_Resolver_RetVoid, i C(PERMISSION_SET) C(RESOLVER), v))
-DEFINE_METASIG_T(SM(PMS_RetVoid, C(PERMISSION_SET), v))
-
-#ifndef FEATURE_CORECLR
-DEFINE_METASIG_T(SM(ExecutionContext_ContextCallback_Object_Bool_RetVoid, \
-                 C(EXECUTIONCONTEXT) C(CONTEXTCALLBACK) j F, v))
-#endif
-#if defined(FEATURE_IMPERSONATION) || defined(FEATURE_COMPRESSEDSTACK)
+#if defined(FEATURE_IMPERSONATION)
 DEFINE_METASIG_T(SM(SecurityContext_ContextCallback_Object_RetVoid, \
                  C(SECURITYCONTEXT) C(CONTEXTCALLBACK) j, v))
-#endif // #if defined(FEATURE_IMPERSONATION) || defined(FEATURE_COMPRESSEDSTACK)                 
-#ifdef FEATURE_COMPRESSEDSTACK
-DEFINE_METASIG_T(SM(CompressedStack_ContextCallback_Object_RetVoid, \
-                 C(COMPRESSED_STACK) C(CONTEXTCALLBACK) j, v))
-DEFINE_METASIG_T(SM(IntPtr_RetDCS, I, C(DOMAIN_COMPRESSED_STACK)))                 
-#endif // #ifdef FEATURE_COMPRESSEDSTACK
+#endif // #if defined(FEATURE_IMPERSONATION) 
 DEFINE_METASIG(SM(Str_RetInt, s, i))
 DEFINE_METASIG_T(SM(Str_RetICustomMarshaler, s, C(ICUSTOM_MARSHALER)))
 DEFINE_METASIG(SM(Int_Str_RetIntPtr, i s, I))
@@ -402,25 +358,13 @@ DEFINE_METASIG(SM(ArrByte_RetObj, a(b), j))
 DEFINE_METASIG(SM(ArrByte_Bool_RetObj, a(b) F, j))
 DEFINE_METASIG(SM(ArrByte_ArrByte_RefObj_RetObj, a(b) a(b) r(j), j))
 DEFINE_METASIG_T(SM(PtrSByt_Int_Int_Encoding_RetStr, P(B) i i C(ENCODING), s))
-DEFINE_METASIG_T(SM(ArrObj_Bool_RefArrByte_OutPMS_HostProtectionResource_Bool_RetArrByte, a(j) F r(a(b)) r(C(PERMISSION_SET)) g(HOST_PROTECTION_RESOURCE) F, a(b)))
 DEFINE_METASIG_T(SM(Evidence_RetEvidence, C(EVIDENCE), C(EVIDENCE)))
-#ifdef FEATURE_CAS_POLICY
-DEFINE_METASIG_T(SM(PEFile_Evidence_RetEvidence, C(SAFE_PEFILE_HANDLE) C(EVIDENCE), C(EVIDENCE)))
-#endif // FEATURE_CAS_POLICY
 DEFINE_METASIG_T(SM(Evidence_Asm_RetEvidence, C(EVIDENCE) C(ASSEMBLY), C(EVIDENCE)))
 DEFINE_METASIG_T(IM(Evidence_RetVoid, C(EVIDENCE), v))
 
 DEFINE_METASIG_T(SM(Void_RetRuntimeTypeHandle, _, g(RT_TYPE_HANDLE)))
 DEFINE_METASIG(SM(Void_RetIntPtr, _, I))
 
-#ifdef FEATURE_CAS_POLICY
-#ifdef FEATURE_NONGENERIC_COLLECTIONS 
-DEFINE_METASIG_T(SM(CS_PMS_PMS_ArrayList_ArrayList_RetVoid, \
-                 C(COMPRESSED_STACK) C(PERMISSION_SET) C(PERMISSION_SET) C(ARRAY_LIST) C(ARRAY_LIST), v))
-#else
-#error Need replacement for GetZoneAndOriginHelper
-#endif // FEATURE_NONGENERIC_COLLECTIONS 
-#endif // #ifdef FEATURE_CAS_POLICY
 DEFINE_METASIG_T(SM(UInt_UInt_PtrNativeOverlapped_RetVoid, K K P(g(NATIVEOVERLAPPED)), v))
 #ifdef FEATURE_REMOTING
 DEFINE_METASIG_T(SM(CrossContextDelegate_ArrObj_RetObj, C(CROSS_CONTEXT_DELEGATE) a(j), j))
@@ -449,9 +393,6 @@ DEFINE_METASIG(IM(RetBool, _, F))
 DEFINE_METASIG(IM(RetArrByte, _, a(b)))
 DEFINE_METASIG_T(IM(RetArrParameterInfo, _, a(C(PARAMETER))))
 DEFINE_METASIG_T(IM(RetCultureInfo, _, C(CULTURE_INFO)))
-#ifdef FEATURE_CAS_POLICY
-DEFINE_METASIG_T(IM(RetSecurityElement, _, C(SECURITY_ELEMENT)))
-#endif // FEATURE_CAS_POLICY
 
 DEFINE_METASIG_T(SM(RetThread, _, C(THREAD)))
 
@@ -495,9 +436,6 @@ DEFINE_METASIG_T(IM(Obj_UnhandledExceptionEventArgs_RetVoid, j C(UNHANDLED_EVENT
 DEFINE_METASIG_T(IM(Assembly_RetVoid, C(ASSEMBLY), v))
 DEFINE_METASIG_T(IM(Assembly_RetBool, C(ASSEMBLY), F))
 DEFINE_METASIG_T(IM(AssemblyBase_RetBool, C(ASSEMBLYBASE), F))
-#ifdef FEATURE_COMINTEROP_REGISTRATION
-DEFINE_METASIG_T(IM(AssemblyBase_AssemblyRegistrationFlags_RetBool, C(ASSEMBLYBASE) g(ASSEMBLY_REGISTRATION_FLAGS), F))
-#endif
 DEFINE_METASIG_T(IM(Exception_RetVoid, C(EXCEPTION), v))
 
 DEFINE_METASIG(IM(IntPtr_RetObj, I, j))
@@ -526,15 +464,8 @@ DEFINE_METASIG_T(IM(Obj_Obj_BindingFlags_Binder_CultureInfo_RetVoid, j j g(BINDI
 DEFINE_METASIG_T(IM(Obj_Obj_BindingFlags_Binder_ArrObj_CultureInfo_RetVoid, j j g(BINDING_FLAGS) C(BINDER) a(j) C(CULTURE_INFO), v))
 DEFINE_METASIG_T(IM(Obj_BindingFlags_Binder_ArrObj_CultureInfo_RetObj, j g(BINDING_FLAGS) C(BINDER) a(j) C(CULTURE_INFO), j))
 DEFINE_METASIG_T(IM(Obj_Type_CultureInfo_RetObj, j C(TYPE) C(CULTURE_INFO), j))
-DEFINE_METASIG_T(IM(IPrincipal_RetVoid, C(IPRINCIPAL), v))
 DEFINE_METASIG_T(IM(MemberInfo_RetVoid, C(MEMBER), v))
 DEFINE_METASIG(IM(IntPtr_ArrObj_Obj_RefArrObj_RetObj, I a(j) j r(a(j)), j))
-DEFINE_METASIG_T(IM(CodeAccessPermission_RetBool, C(CODE_ACCESS_PERMISSION), F))
-DEFINE_METASIG_T(IM(IPermission_RetIPermission, C(IPERMISSION), C(IPERMISSION)))
-DEFINE_METASIG_T(IM(IPermission_RetBool, C(IPERMISSION), F))
-DEFINE_METASIG_T(IM(PMS_RetVoid, C(PERMISSION_SET), v))
-DEFINE_METASIG_T(IM(PMS_RetPMS, C(PERMISSION_SET), C(PERMISSION_SET)))
-DEFINE_METASIG_T(IM(PMS_RetBool, C(PERMISSION_SET), F))
 DEFINE_METASIG(IM(RefObject_RetBool, r(j), F))
 DEFINE_METASIG_T(IM(Class_RetObj, C(CLASS), j))
 DEFINE_METASIG(IM(Int_VoidPtr_RetVoid, i P(v), v))
@@ -592,7 +523,6 @@ DEFINE_METASIG_T(IM(BindingFlags_RetArrMemberInfo, g(BINDING_FLAGS), a(C(MEMBER)
 DEFINE_METASIG_T(IM(BindingFlags_RetArrMethodInfo, g(BINDING_FLAGS), a(C(METHOD_INFO))))
 DEFINE_METASIG_T(IM(BindingFlags_RetArrPropertyInfo, g(BINDING_FLAGS), a(C(PROPERTY_INFO))))
 DEFINE_METASIG(IM(ArrByte_RetVoid, a(b), v))
-DEFINE_METASIG_T(IM(ArrByte_HostProtectionResource_HostProtectionResource_RetBool, a(b) g(HOST_PROTECTION_RESOURCE) g(HOST_PROTECTION_RESOURCE), F))
 DEFINE_METASIG(IM(ArrChar_RetVoid, a(u), v))
 DEFINE_METASIG(IM(ArrChar_Int_Int_RetVoid, a(u) i i, v))
 DEFINE_METASIG_T(IM(ArrType_ArrException_Str_RetVoid, a(C(TYPE)) a(C(EXCEPTION)) s, v))
@@ -602,10 +532,6 @@ DEFINE_METASIG_T(IM(RuntimeType_RetVoid, C(CLASS) , v))
 DEFINE_METASIG_T(SM(ArrException_PtrInt_RetVoid, a(C(EXCEPTION)) P(i), v))
 
 DEFINE_METASIG_T(IM(RuntimeArgumentHandle_PtrVoid_RetVoid, g(ARGUMENT_HANDLE) P(v), v))
-DEFINE_METASIG_T(IM(SecurityPermissionFlag_RetVoid, g(SECURITY_PERMISSION_FLAG), v))
-DEFINE_METASIG_T(IM(PermissionState_RetVoid, g(PERMISSION_STATE), v))
-DEFINE_METASIG_T(IM(SecurityAction_RetVoid, g(SECURITY_ACTION), v))
-DEFINE_METASIG_T(IM(ReflectionPermissionFlag_RetVoid, g(REFLECTION_PERMISSION_FLAG), v))
 DEFINE_METASIG_T(IM(LicenseInteropHelper_GetCurrentContextInfo, r(i) r(I) g(RT_TYPE_HANDLE), v))
 DEFINE_METASIG(IM(LicenseInteropHelper_SaveKeyInCurrentContext, I, v))
 DEFINE_METASIG_T(SM(LicenseInteropHelper_AllocateAndValidateLicense, g(RT_TYPE_HANDLE) I i, j))
@@ -620,9 +546,6 @@ DEFINE_METASIG_T(SM(Str_Evidence_AppDomainSetup_RetAppDomain, s C(EVIDENCE) C(AP
 DEFINE_METASIG_T(SM(Str_Evidence_Str_Str_Bool_RetAppDomain, s C(EVIDENCE) s s F, C(APP_DOMAIN)))
 DEFINE_METASIG_T(SM(Str_RetAppDomain, s, C(APP_DOMAIN)))
 DEFINE_METASIG_T(SM(Str_AppDomainSetup_Evidence_Evidence_IntPtr_Str_ArrStr_ArrStr_RetObj, s C(APPDOMAIN_SETUP) C(EVIDENCE) C(EVIDENCE) I s a(s) a(s), j))
-#ifdef FEATURE_APTCA
-DEFINE_METASIG(IM(PtrChar_Int_PtrByte_Int_RetBool, P(u) i P(b) i, F))
-#endif //FEATURE_APTCA
 #ifdef FEATURE_COMINTEROP
 // System.AppDomain.OnReflectionOnlyNamespaceResolveEvent
 DEFINE_METASIG_T(IM(Assembly_Str_RetArrAssembly, C(ASSEMBLY) s, a(C(ASSEMBLY))))
@@ -638,21 +561,15 @@ DEFINE_METASIG_T(SM(Obj_ArrStr_ArrObj_OutStreamingContext_RetSerializationInfo,
 #endif // FEATURE_SERIALIZATION
 DEFINE_METASIG(SM(Obj_OutStr_OutStr_OutArrStr_OutArrObj_RetObj, j r(s) r(s) r(a(s)) r(a(j)), j))
 
-#ifdef FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
 // Execution Context
 DEFINE_METASIG_T(SM(SyncCtx_ArrIntPtr_Bool_Int_RetInt, C(SYNCHRONIZATION_CONTEXT) a(I) F i, i))
-#endif // #ifdef FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
-// HostProtectionException
-DEFINE_METASIG_T(IM(HPR_HPR_RetVoid, g(HOST_PROTECTION_RESOURCE) g(HOST_PROTECTION_RESOURCE), v))
 
 #ifdef FEATURE_COMINTEROP
 // The signature of the method System.Runtime.InteropServices.ICustomQueryInterface.GetInterface
 DEFINE_METASIG_T(IM(RefGuid_OutIntPtr_RetCustomQueryInterfaceResult, r(g(GUID)) r(I), g(CUSTOMQUERYINTERFACERESULT)))
 #endif //FEATURE_COMINTEROP
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 DEFINE_METASIG_T(SM(IntPtr_AssemblyName_RetAssemblyBase, I C(ASSEMBLY_NAME), C(ASSEMBLYBASE)))
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
 // ThreadPool
 DEFINE_METASIG(SM(Obj_Bool_RetVoid, j F, v))
diff --git a/src/vm/method.cpp b/src/vm/method.cpp
index 07636d6950..12eeb60c96 100644
--- a/src/vm/method.cpp
+++ b/src/vm/method.cpp
@@ -31,9 +31,6 @@
 #include "jitinterface.h"
 #include "runtimehandles.h"
 #include "eventtrace.h"
-#ifndef FEATURE_CORECLR
-#include "fxretarget.h"
-#endif
 #include "interoputil.h"
 #include "prettyprintsig.h"
 #include "formattype.h"
@@ -2470,12 +2467,10 @@ BOOL MethodDesc::IsFCallOrIntrinsic()
     if (IsFCall() || IsArray())
         return TRUE;
 
-#ifdef FEATURE_SPAN_OF_T
     // Intrinsic methods on ByReference<T> or Span<T>
     MethodTable * pMT = GetMethodTable();
     if (pMT->IsByRefLike() && pMT->GetModule()->IsSystem())
         return TRUE;
-#endif
 
     return FALSE;
 }
@@ -3260,15 +3255,6 @@ bool MethodDesc::CanSkipDoPrestub (
         return false;
     }
 
-#ifdef FEATURE_CER
-    // Can't hard bind to a method which contains one or more Constrained Execution Region roots (we need to force the prestub to
-    // execute for such methods).
-    if (ContainsPrePreparableCerRoot(this))
-    {
-        *pReason = CORINFO_INDIRECT_CALL_CER;
-        return false;
-    }
-#endif // FEATURE_CER
 
     // Check whether our methoddesc needs restore
     if (NeedsRestore(GetAppDomain()->ToCompilationDomain()->GetTargetImage(), TRUE))
@@ -5227,36 +5213,6 @@ LPVOID NDirectMethodDesc::FindEntryPoint(HINSTANCE hMod) const
     DWORD nbytes = (DWORD)(strlen(GetEntrypointName()) + 1);
     szAnsiEntrypointName[nbytes] = '\0'; // Add an extra '\0'.
 
-#if !defined(FEATURE_CORECLR) && defined(_WIN64)
-    //
-    // Forward {Get|Set}{Window|Class}Long to their corresponding Ptr version
-    //
-
-    // LONG      SetWindowLong(   HWND hWnd, int nIndex, LONG     dwNewLong);
-    // LONG_PTR  SetWindowLongPtr(HWND hWnd, int nIndex, LONG_PTR dwNewLong);
-    // 
-    // LONG      GetWindowLong(   HWND hWnd, int nIndex);
-    // LONG_PTR  GetWindowLongPtr(HWND hWnd, int nIndex);
-    // 
-    // DWORD     GetClassLong(    HWND hWnd, int nIndex);
-    // ULONG_PTR GetClassLongPtr( HWND hWnd, int nIndex);
-    // 
-    // DWORD     SetClassLong(    HWND hWnd, int nIndex, LONG     dwNewLong);
-    // ULONG_PTR SetClassLongPtr( HWND hWnd, int nIndex, LONG_PTR dwNewLong);
-
-    if (!SString::_stricmp(GetEntrypointName(), "SetWindowLong") ||
-        !SString::_stricmp(GetEntrypointName(), "GetWindowLong") ||
-        !SString::_stricmp(GetEntrypointName(), "SetClassLong") ||
-        !SString::_stricmp(GetEntrypointName(), "GetClassLong"))
-    {
-        szAnsiEntrypointName[nbytes-1] = 'P';
-        szAnsiEntrypointName[nbytes+0] = 't';
-        szAnsiEntrypointName[nbytes+1] = 'r';
-        szAnsiEntrypointName[nbytes+2] = '\0';
-        szAnsiEntrypointName[nbytes+3] = '\0';
-        nbytes += 3;
-    }
-#endif // !FEATURE_CORECLR && _WIN64
 
     // If the program wants the ANSI api or if Unicode APIs are unavailable.
     if (IsNativeAnsi())
@@ -5279,25 +5235,6 @@ LPVOID NDirectMethodDesc::FindEntryPoint(HINSTANCE hMod) const
 
     if (!pFunc)
     {
-#if !defined(FEATURE_CORECLR)
-        if (hMod == CLRGetModuleHandle(W("kernel32.dll")))
-        {
-            szAnsiEntrypointName[nbytes-1] = '\0';
-            if (0==strcmp(szAnsiEntrypointName, "MoveMemory") ||
-                0==strcmp(szAnsiEntrypointName, "CopyMemory"))
-            {
-                pFunc = GetProcAddress(hMod, funcName = "RtlMoveMemory");
-            }
-            else if (0==strcmp(szAnsiEntrypointName, funcName = "FillMemory"))
-            {
-                pFunc = GetProcAddress(hMod, funcName = "RtlFillMemory");
-            }
-            else if (0==strcmp(szAnsiEntrypointName, funcName = "ZeroMemory"))
-            {
-                pFunc = GetProcAddress(hMod, funcName = "RtlZeroMemory");
-            }
-        }
-#endif // !FEATURE_CORECLR
 
 #if defined(_TARGET_X86_)
         /* try mangled names only for __stdcalls */
@@ -5365,29 +5302,6 @@ void MethodDesc::ComputeSuppressUnmanagedCodeAccessAttr(IMDInternalImport *pImpo
     }
     CONTRACTL_END;
 
-#ifndef FEATURE_CORECLR
-    // We only care about this bit for NDirect and ComPlusCall
-    if (!IsNDirect() && !IsComPlusCall())
-        return;
-
-    BOOL hasAttr = FALSE;
-    HRESULT hr = pImport->GetCustomAttributeByName(GetMemberDef(),
-                                                    COR_SUPPRESS_UNMANAGED_CODE_CHECK_ATTRIBUTE_ANSI,
-                                                    NULL,
-                                                    NULL);
-    IfFailThrow(hr);
-    hasAttr = (hr == S_OK);
-
-
-    if (IsNDirect())
-        ((NDirectMethodDesc*)this)->SetSuppressUnmanagedCodeAccessAttr(hasAttr);
-
-#ifdef FEATURE_COMINTEROP
-    if (IsComPlusCall())
-        ((ComPlusCallMethodDesc*)this)->SetSuppressUnmanagedCodeAccessAttr(hasAttr);
-#endif
-
-#endif // FEATURE_COMINTEROP
 }
 
 //*******************************************************************************
@@ -5402,7 +5316,6 @@ BOOL MethodDesc::HasNativeCallableAttribute()
     }
     CONTRACTL_END;
 
-#ifdef FEATURE_CORECLR
     HRESULT hr = GetMDImport()->GetCustomAttributeByName(GetMemberDef(),
         g_NativeCallableAttribute,
         NULL,
@@ -5411,7 +5324,6 @@ BOOL MethodDesc::HasNativeCallableAttribute()
     {
         return TRUE;
     }
-#endif //FEATURE_CORECLR
 
     return FALSE;
 }
@@ -5421,27 +5333,7 @@ BOOL MethodDesc::HasSuppressUnmanagedCodeAccessAttr()
 {
     LIMITED_METHOD_CONTRACT;
 
-#ifdef FEATURE_CORECLR
     return TRUE;
-#else // FEATURE_CORECLR
-
-    // In AppX processes, there is only one full trust AppDomain, so there is never any need to do a security
-    // callout on interop stubs
-    if (AppX::IsAppXProcess())
-    {
-        return TRUE;
-    }
-
-    if (IsNDirect())
-        return ((NDirectMethodDesc*)this)->HasSuppressUnmanagedCodeAccessAttr();
-#ifdef FEATURE_COMINTEROP
-    else if (IsComPlusCall())
-        return ((ComPlusCallMethodDesc*)this)->HasSuppressUnmanagedCodeAccessAttr();
-#endif  // FEATURE_COMINTEROP
-    else
-        return FALSE;
-
-#endif // FEATURE_CORECLR
 }
 
 #ifdef FEATURE_COMINTEROP
diff --git a/src/vm/method.hpp b/src/vm/method.hpp
index 499112d149..75ff246dc3 100644
--- a/src/vm/method.hpp
+++ b/src/vm/method.hpp
@@ -2673,22 +2673,6 @@ public:
         return (ndirect.m_wFlags & kNativeNoMangle) != 0;
     }
 
-#ifndef FEATURE_CORECLR
-    BOOL HasSuppressUnmanagedCodeAccessAttr() const
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        return (ndirect.m_wFlags & kHasSuppressUnmanagedCodeAccess) != 0;
-    }
-
-    void SetSuppressUnmanagedCodeAccessAttr(BOOL value)
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        if (value)
-            ndirect.m_wFlags |= kHasSuppressUnmanagedCodeAccess;
-    }
-#endif
 
     DWORD GetECallID() const
     {
@@ -3101,32 +3085,6 @@ public:
         return m_pComPlusCallInfo->m_pEventProviderMD;
     }
 
-#ifndef FEATURE_CORECLR
-
-    BOOL HasSuppressUnmanagedCodeAccessAttr()
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        if (m_pComPlusCallInfo != NULL)
-        {
-            return (m_pComPlusCallInfo->m_flags & ComPlusCallInfo::kHasSuppressUnmanagedCodeAccess) != 0;
-        }
-        
-        // it is possible that somebody will call this before we initialized m_pComPlusCallInfo
-        return (GetMDImport()->GetCustomAttributeByName(GetMemberDef(),
-                                                        COR_SUPPRESS_UNMANAGED_CODE_CHECK_ATTRIBUTE_ANSI,
-                                                        NULL,
-                                                        NULL) == S_OK);
-    }
-
-    void SetSuppressUnmanagedCodeAccessAttr(BOOL value)
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        if (value)
-            FastInterlockOr(reinterpret_cast<DWORD *>(&m_pComPlusCallInfo->m_flags), ComPlusCallInfo::kHasSuppressUnmanagedCodeAccess);
-    }
-#endif // FEATURE_CORECLR
 
     BOOL RequiresArgumentWrapping()
     {
diff --git a/src/vm/methodtable.cpp b/src/vm/methodtable.cpp
index 52a2ce4d98..44f047e528 100644
--- a/src/vm/methodtable.cpp
+++ b/src/vm/methodtable.cpp
@@ -60,8 +60,6 @@
 #include "zapsig.h"
 #endif //FEATURE_PREJIT
 
-#include "hostexecutioncontext.h"
-
 #ifdef FEATURE_COMINTEROP
 #include "comcallablewrapper.h"
 #include "clrtocomcall.h"
@@ -2404,6 +2402,12 @@ bool MethodTable::ClassifyEightBytesWithManagedLayout(SystemVStructRegisterPassi
     FieldDesc *pField = GetApproxFieldDescListRaw();
     FieldDesc *pFieldEnd = pField + numIntroducedFields;
 
+    // System types are loaded before others, so ByReference<T> would be loaded before Span<T> or any other type that has a
+    // ByReference<T> field. ByReference<T> is the first by-ref-like system type to be loaded (see
+    // SystemDomain::LoadBaseSystemClasses), so if the current method table is marked as by-ref-like and g_pByReferenceClass is
+    // null, it must be the initial load of ByReference<T>.
+    bool isThisByReferenceOfT = IsByRefLike() && (g_pByReferenceClass == nullptr || HasSameTypeDefAs(g_pByReferenceClass));
+
     for (; pField < pFieldEnd; pField++)
     {
 #ifdef _DEBUG
@@ -2425,7 +2429,19 @@ bool MethodTable::ClassifyEightBytesWithManagedLayout(SystemVStructRegisterPassi
 
         CorElementType fieldType = pField->GetFieldType();
 
-        SystemVClassificationType fieldClassificationType = CorInfoType2UnixAmd64Classification(fieldType);
+        SystemVClassificationType fieldClassificationType;
+        if (isThisByReferenceOfT)
+        {
+            // ByReference<T> is a special type whose single IntPtr field holds a by-ref potentially interior pointer to GC
+            // memory, so classify its field as such
+            _ASSERTE(numIntroducedFields == 1);
+            _ASSERTE(fieldType == CorElementType::ELEMENT_TYPE_I);
+            fieldClassificationType = SystemVClassificationTypeIntegerByRef;
+        }
+        else
+        {
+            fieldClassificationType = CorInfoType2UnixAmd64Classification(fieldType);
+        }
 
 #ifdef _DEBUG
         LPCUTF8 fieldName;
@@ -3947,10 +3963,6 @@ void MethodTable::CallFinalizer(Object *obj)
         return;
     }
 
-#ifdef FEATURE_CAS_POLICY
-    // Notify the host to setup the restricted context before finalizing each object
-    HostExecutionContextManager::SetHostRestrictedContext();
-#endif // FEATURE_CAS_POLICY
 
     // Determine if the object has a critical or normal finalizer.
     BOOL fCriticalFinalizer = pMT->HasCriticalFinalizer();
@@ -9767,23 +9779,7 @@ bool MethodTable::ClassRequiresUnmanagedCodeCheck()
 {
     LIMITED_METHOD_CONTRACT;
     
-#ifdef FEATURE_CORECLR
     return false;
-#else
-    // all WinRT types have an imaginary [SuppressUnmanagedCodeSecurity] attribute on them
-    if (IsProjectedFromWinRT())
-        return false;
-        
-    // In AppX processes, there is only one full trust AppDomain, so there is never any need to do a security
-    // callout on interop stubs
-    if (AppX::IsAppXProcess())
-        return false;
-
-    return GetMDImport()->GetCustomAttributeByName(GetCl(),
-                                                 COR_SUPPRESS_UNMANAGED_CODE_CHECK_ATTRIBUTE_ANSI,
-                                                 NULL,
-                                                 NULL) == S_FALSE;
-#endif // FEATURE_CORECLR
 }
 
 #endif // !DACCESS_COMPILE
diff --git a/src/vm/methodtable.inl b/src/vm/methodtable.inl
index d91d52ca6e..cf79ffe2e0 100644
--- a/src/vm/methodtable.inl
+++ b/src/vm/methodtable.inl
@@ -373,26 +373,18 @@ inline BOOL MethodTable::HasFieldsWhichMustBeInited()
 inline BOOL MethodTable::SupportsAutoNGen()
 {
     LIMITED_METHOD_CONTRACT;
-#ifndef FEATURE_CORECLR
-    return GetAssembly()->SupportsAutoNGen();
-#else
     return FALSE;
-#endif
 }
 
 //==========================================================================================
 inline BOOL MethodTable::RunCCTorAsIfNGenImageExists()
 {
     LIMITED_METHOD_CONTRACT;
-#ifndef FEATURE_CORECLR
-    return this->SupportsAutoNGen();
-#else
 #ifdef FEATURE_CORESYSTEM
     return TRUE; // On our coresystem builds we will always be using triton in the customer scenario.
 #else
     return FALSE;
 #endif
-#endif
 }
 
 //==========================================================================================
diff --git a/src/vm/methodtablebuilder.cpp b/src/vm/methodtablebuilder.cpp
index 4a8b0c758f..1389f8f0b5 100644
--- a/src/vm/methodtablebuilder.cpp
+++ b/src/vm/methodtablebuilder.cpp
@@ -15,7 +15,6 @@
 
 #include "methodtablebuilder.h"
 
-#include "constrainedexecutionregion.h"
 #include "sigbuilder.h"
 #include "dllimport.h"
 #include "fieldmarshaler.h"
@@ -30,9 +29,6 @@
 #endif
 
 #ifdef FEATURE_COMINTEROP
-#ifdef FEATURE_FUSION	
-#include "policy.h"
-#endif
 #endif
 
 //*******************************************************************************
@@ -191,18 +187,6 @@ MethodTableBuilder::CreateClass( Module *pModule,
         pEEClass->GetSecurityProperties()->SetFlags(dwSecFlags, dwNullDeclFlags);
     }
 
-#ifdef FEATURE_CER
-    // Cache class level reliability contract info.
-    DWORD dwReliabilityContract = ::GetReliabilityContract(pInternalImport, cl);
-    if (dwReliabilityContract != RC_NULL)
-    {
-        // Reliability contract is an optional field. If we have a non-default value we need to ensure the
-        // optional field descriptor has been allocated.
-        EnsureOptionalFieldsAreAllocated(pEEClass, pamTracker, pAllocator->GetLowFrequencyHeap());
-        
-        pEEClass->SetReliabilityContract(dwReliabilityContract);
-    }
-#endif // FEATURE_CER
 
     if (fHasLayout)
         pEEClass->SetHasLayout();
@@ -217,13 +201,6 @@ MethodTableBuilder::CreateClass( Module *pModule,
         // On CoreCLR, however, we do allow non-FX assemblies to have this attribute. This enables scenarios where we can
         // activate 3rd-party WinRT components outside AppContainer - 1st party WinRT components are already allowed
         // to be activated outside AppContainer (on both Desktop and CoreCLR).
-#ifdef FEATURE_FUSION
-        if (!pAssembly->IsWinMD() &&
-             Fusion::Util::IsAnyFrameworkAssembly(pAssembly->GetFusionAssemblyName()) != S_OK)
-        {
-            pAssembly->ThrowTypeLoadException(pModule->GetMDImport(), cl, IDS_EE_WINRT_TYPE_IN_ORDINARY_ASSEMBLY);
-        }
-#endif
 
         pEEClass->SetProjectedFromWinRT();
     }
@@ -5154,25 +5131,13 @@ void MethodTableBuilder::SetSecurityFlagsOnMethod(bmtRTMethod* pParentMethod,
     // for linktime checks on these.
     // Also place linktime checks on all P/Invoke calls.
     if (
-#ifndef FEATURE_CORECLR 
-        (IsInterface() &&
-        (GetMDImport()->GetCustomAttributeByName(GetCl(),
-                                                                COR_SUPPRESS_UNMANAGED_CODE_CHECK_ATTRIBUTE_ANSI,
-                                                                NULL,
-                                                                NULL) == S_OK ||
-         GetMDImport()->GetCustomAttributeByName(pNewMD->GetMemberDef(),
-                                                                COR_SUPPRESS_UNMANAGED_CODE_CHECK_ATTRIBUTE_ANSI,
-                                                                NULL,
-                                                                NULL) == S_OK) ) ||
-
-#endif  // !FEATURE_CORECLR
         pNewMD->IsNDirect() ||
         (pNewMD->IsComPlusCall() && !IsInterface()))
     {
         pNewMD->SetRequiresLinktimeCheck();
     }
 
-#if defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM) 
+#if defined(FEATURE_CORESYSTEM)
     // All public methods on public types will do a link demand of
     // full trust, unless AllowUntrustedCaller attribute is set
     if (
@@ -5200,7 +5165,7 @@ void MethodTableBuilder::SetSecurityFlagsOnMethod(bmtRTMethod* pParentMethod,
                 pNewMD->SetRequiresLinktimeCheck();
         }
     }
-#endif //  defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM)
+#endif //  defined(FEATURE_CORESYSTEM)
 
     // If it's a delegate BeginInvoke, we need to do a HostProtection check for synchronization
     if(!pNewMD->RequiresLinktimeCheck() && IsDelegate())
@@ -10220,16 +10185,22 @@ void MethodTableBuilder::CheckForSystemTypes()
     // We can exit early for generic types - there are just a few cases to check for.
     if (bmtGenerics->HasInstantiation() && g_pNullableClass != NULL)
     {
-#ifdef FEATURE_SPAN_OF_T
         _ASSERTE(g_pByReferenceClass != NULL);
         _ASSERTE(g_pByReferenceClass->IsByRefLike());
 
         if (GetCl() == g_pByReferenceClass->GetCl())
         {
             pMT->SetIsByRefLike();
+#ifdef _TARGET_X86_
+            // x86 by default treats the type of ByReference<T> as the actual type of its IntPtr field, see calls to
+            // ComputeInternalCorElementTypeForValueType in this file. This is a special case where the struct needs to be
+            // treated as a value type so that its field can be considered as a by-ref pointer.
+            _ASSERTE(pMT->GetFlag(MethodTable::enum_flag_Category_Mask) == MethodTable::enum_flag_Category_PrimitiveValueType);
+            pMT->ClearFlag(MethodTable::enum_flag_Category_Mask);
+            pMT->SetInternalCorElementType(ELEMENT_TYPE_VALUETYPE);
+#endif
             return;
         }
-#endif
 
         _ASSERTE(g_pNullableClass->IsNullable());
 
@@ -10285,12 +10256,18 @@ void MethodTableBuilder::CheckForSystemTypes()
         {
             pMT->SetIsNullable();
         }
-#ifdef FEATURE_SPAN_OF_T
         else if (strcmp(name, g_ByReferenceName) == 0)
         {
             pMT->SetIsByRefLike();
-        }
+#ifdef _TARGET_X86_
+            // x86 by default treats the type of ByReference<T> as the actual type of its IntPtr field, see calls to
+            // ComputeInternalCorElementTypeForValueType in this file. This is a special case where the struct needs to be
+            // treated as a value type so that its field can be considered as a by-ref pointer.
+            _ASSERTE(pMT->GetFlag(MethodTable::enum_flag_Category_Mask) == MethodTable::enum_flag_Category_PrimitiveValueType);
+            pMT->ClearFlag(MethodTable::enum_flag_Category_Mask);
+            pMT->SetInternalCorElementType(ELEMENT_TYPE_VALUETYPE);
 #endif
+        }
         else if (strcmp(name, g_ArgIteratorName) == 0)
         {
             // Mark the special types that have embeded stack poitners in them
@@ -12178,19 +12155,6 @@ VOID MethodTableBuilder::VerifyClassInheritanceSecurityHelper(
     // This method throws on failure.
     Security::ClassInheritanceCheck(pChildMT, pParentMT);
 
-#ifndef FEATURE_CORECLR
-    // Check the entire parent chain for inheritance permission demands.
-    while (pParentMT != NULL)
-    {
-        if (pParentMT->GetClass()->RequiresInheritanceCheck())
-        {
-            // This method throws on failure.
-            Security::ClassInheritanceCheck(pChildMT, pParentMT);
-        }
-
-        pParentMT = pParentMT->GetParentMethodTable();
-    }
-#endif // !FEATURE_CORECLR
 }
 
 //*******************************************************************************
@@ -12209,74 +12173,6 @@ VOID MethodTableBuilder::VerifyMethodInheritanceSecurityHelper(
 
     Security::MethodInheritanceCheck(pChildMD, pParentMD);
 
-#ifndef FEATURE_CORECLR
-
-    // If no inheritance checks are required, just return.
-    if (!pParentMD->RequiresInheritanceCheck() &&
-        !pParentMD->ParentRequiresInheritanceCheck())
-    {
-        return;
-    }
-
-    DWORD dwSlot = pParentMD->GetSlot();
-
-#ifdef _DEBUG 
-    // Get the name and signature for the method so we can find the new parent method desc.
-    // We use the parent MethodDesc for this because the child could actually have a very
-    // different name in the case that the child is MethodImpling the parent.
-
-    // Get the name.
-    LPCUTF8            szName;
-    szName = pParentMD->GetName();
-
-    // Get the signature.
-    PCCOR_SIGNATURE    pSignature;
-    DWORD              cSignature;
-    pParentMD->GetSig(&pSignature, &cSignature);
-    Module            *pModule = pParentMD->GetModule();
-#endif // _DEBUG
-
-    do
-    {
-        if (pParentMD->RequiresInheritanceCheck())
-        {
-            Security::MethodInheritanceCheck(pChildMD, pParentMD);
-        }
-
-        if (pParentMD->ParentRequiresInheritanceCheck())
-        {
-            MethodTable *pGrandParentMT = pParentMD->GetMethodTable()->GetParentMethodTable();
-            CONSISTENCY_CHECK(CheckPointer(pGrandParentMT));
-
-            // Find this method in the parent.
-            // If it does exist in the parent, it would be at the same vtable slot.
-            if (dwSlot >= pGrandParentMT->GetNumVirtuals())
-            {
-                // Parent does not have this many vtable slots, so it doesn't exist there
-                pParentMD = NULL;
-            }
-            else
-            {
-                // It is in the vtable of the parent
-                pParentMD = pGrandParentMT->GetMethodDescForSlot(dwSlot);
-                _ASSERTE(pParentMD != NULL);
-
-#ifdef _DEBUG 
-                _ASSERTE(pParentMD == MemberLoader::FindMethod(pGrandParentMT,
-                    szName,
-                    pSignature,
-                    cSignature,
-                    pModule));
-#endif // _DEBUG
-            }
-        }
-        else
-        {
-            pParentMD = NULL;
-        }
-    } while (pParentMD != NULL);
-
-#endif // !FEATURE_CORECLR
 }
 
 //*******************************************************************************
@@ -12521,7 +12417,6 @@ void MethodTableBuilder::VerifyInheritanceSecurity()
     // permission demands on the current class. If these first checks
     // succeeded, then the cached declared method list is scanned for
     // methods that have inheritance permission demands.
-#ifdef FEATURE_CORECLR
     //
     // If we are transparent, and every class up the inheritence chain is also entirely transparent,
     // that means that no inheritence rules could be broken.  If that's the case, we don't need to check
@@ -12552,12 +12447,9 @@ void MethodTableBuilder::VerifyInheritanceSecurity()
 
         }
     }
-#endif // FEATURE_CORECLR
 
     if (GetParentMethodTable() != NULL
-#if FEATURE_CORECLR
         && !fInheritenceChainTransparent
-#endif // FEATURE_CORECLR
         )
     {
         // Check the parent for inheritance permission demands.
@@ -12642,18 +12534,10 @@ void MethodTableBuilder::VerifyInheritanceSecurity()
             MethodTable *pCurItfMT = itfIt.GetInterface();
             CONSISTENCY_CHECK(CheckPointer(pCurItfMT));
 
-#ifdef FEATURE_CORECLR
             if (fNeedTransparencyInheritanceCheck && 
                 !(Security::IsTypeAllTransparent(itfIt.GetInterface()) &&
                     fCurrentTypeAllTransparent) 
                 )
-#else // FEATURE_CORECLR
-            EEClass * pCurItfCls = pCurItfMT->GetClass();
-            if (fNeedTransparencyInheritanceCheck ||
-                fNeedPartialTrustInterfaceMappingCheck ||
-                pCurItfCls->RequiresInheritanceCheck() ||
-                pCurItfCls->SomeMethodsRequireInheritanceCheck())
-#endif // !FEATURE_CORECLR
             {
                 // An interface is introduced by this type either if it is explicitly declared on the
                 // type's interface list or if one of the type's explicit interfaces requires the
diff --git a/src/vm/mixedmode.cpp b/src/vm/mixedmode.cpp
deleted file mode 100644
index 32d4368363..0000000000
--- a/src/vm/mixedmode.cpp
+++ /dev/null
@@ -1,236 +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.
-// ===========================================================================
-// File: MIXEDMODE.CPP
-// 
-
-//
-
-// MIXEDMODE deals with mixed-mode binaries support
-// ===========================================================================
-
-
-
-#include "common.h"
-
-#include "mixedmode.hpp"
-
-#include "dllimportcallback.h"
-
-#ifdef FEATURE_MIXEDMODE
-
-
-IJWNOADThunk::IJWNOADThunk(HMODULE pModulebase, DWORD dwIndex, mdToken Token)
-{
-    LIMITED_METHOD_CONTRACT;
-    m_pModulebase=pModulebase;
-    m_dwIndex=dwIndex;
-    m_Token=Token;
-    m_fAccessingCache = 0;
-
-    for (int i=0; i < IJWNOADThunkStubCacheSize; i++)
-    {
-        m_cache[i].m_AppDomainID = (ADID)-1;
-        m_cache[i].m_CodeAddr = 0;
-    }
-
-#ifdef _TARGET_X86_ 
-    m_code.Encode((BYTE*)GetEEFuncEntryPoint(IJWNOADThunkJumpTarget), this);
-#else // !_TARGET_X86_
-    m_code.Encode((BYTE*)GetEEFuncEntryPoint(MakeCall), this);
-#endif // !_TARGET_X86_
-};
-
-#define E_PROCESS_SHUTDOWN_REENTRY    HRESULT_FROM_WIN32(ERROR_PROCESS_ABORTED)
-
-
-#ifdef _TARGET_X86_ 
-// Slow path lookup...called from stub
-extern "C" LPCVOID __stdcall IJWNOADThunkJumpTargetHelper(IJWNOADThunk* pThunk)
-{
-    WRAPPER_NO_CONTRACT;
-
-    return pThunk->FindThunkTarget();
-}
-#endif // _TARGET_X86_
-
-LPCVOID IJWNOADThunk::FindThunkTarget()
-{
-    CONTRACT(LPCVOID)
-    {
-        INSTANCE_CHECK;
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-        SO_TOLERANT;
-        POSTCONDITION(CheckPointer(RETVAL));
-    }
-    CONTRACT_END;
-
-    // We don't plan on fixing this in Whidbey...the IJW scenario has always assumed throwing is "ok" here.
-    CONTRACT_VIOLATION(ThrowsViolation);
-
-    LPCVOID      pvTargetCode = NULL;
-
-    AppDomain*  pDomain;
-
-    Thread* pThread = SetupThread();
-
-    // Ensure that we're in preemptive mode.
-    //  We only need this check for a newly created
-    //  CLR thread - it defaults to COOP mode from here.
-    GCX_PREEMP_NO_DTOR();
-
-    pDomain = GetAppDomain();
-
-    if (NULL == pDomain)
-    {
-        _ASSERTE(!"Appdomain should've been set up by SetupThread");
-        pDomain = SystemDomain::System()->DefaultDomain();
-    }
-
-
-    if (NULL != pDomain)
-    {
-        // Get a local copy so we don't have to deal with a race condition.
-        LPCVOID pCacheTarget = NULL;
-        GetCachedInfo(pDomain->GetId(), &pvTargetCode);
-
-        // Cache miss.
-        if (pvTargetCode==NULL)
-        {
-            INSTALL_UNWIND_AND_CONTINUE_HANDLER;
-            BEGIN_SO_INTOLERANT_CODE(pThread);
-            {
-                Module* pModule;
-
-                pModule = pDomain->GetIJWModule(m_pModulebase);
-                if (NULL == pModule)
-                {
-                    // New for Whidbey: In V1.1, we just gave up and raised an exception if the target assembly wasn't already loaded
-                    // into the current appdomain. We now force-inject the assembly.
-
-                    PEAssemblyHolder pFile(pDomain->BindExplicitAssembly(m_pModulebase, FALSE));
-                    pDomain->LoadAssembly(NULL, pFile, FILE_ACTIVE);
-
-                    // Now, try the lookup again. The LoadAssembly() either worked or it didn't. If it didn't, it is probably
-                    // due to lack of memory and all we can do is raise an exception and hope the IJW caller does something reasonable.
-                    // Otherwise, we should now succeed in finding the current domain's instantiation of the target module.
-                    pModule = pDomain->GetIJWModule(m_pModulebase);
-                }
-
-                if (NULL != pModule)
-                {
-                    pModule->EnsureActive();
-
-                    UMEntryThunk* pThunkTable;
-
-                    pThunkTable  = pModule->GetADThunkTable();
-                    pvTargetCode = (LPVOID)GetEEFuncEntryPoint((LPVOID)pThunkTable[m_dwIndex].GetCode());
-
-                    // Populate the cache with our latest info.
-                    SetCachedInfo(pDomain->GetId(), pvTargetCode);
-                }
-            }
-            END_SO_INTOLERANT_CODE;
-            UNINSTALL_UNWIND_AND_CONTINUE_HANDLER;
-        }
-    }
-
-    if(pvTargetCode==NULL)
-        pvTargetCode=(LPVOID)GetEEFuncEntryPoint(SafeNoModule);
-
-    RETURN (LPCVOID)pvTargetCode;
-}
-
-#ifdef _TARGET_X86_ 
-
-#ifdef _MSC_VER 
-#pragma warning(push)
-#pragma warning (disable : 4740) // There is inline asm code in this function, which disables
-                                 // global optimizations.
-#endif // _MSC_VER
-
-__declspec(naked)  void _cdecl IJWNOADThunk::MakeCall()
-{
-    WRAPPER_NO_CONTRACT;
-    struct
-    {
-        LPVOID This;
-        LPCVOID RetAddr;
-    } Vars;
-    #define LocalsSize 8
-
-    _asm enter LocalsSize+4,0;
-    _asm push ebx;
-    _asm push ecx;
-    _asm push edx;
-    _asm push esi;
-    _asm push edi;
-
-    _asm mov Vars.This, eax;
-
-    //careful above this point
-    _ASSERTE(sizeof(Vars)<=LocalsSize);
-
-    Vars.RetAddr = ((IJWNOADThunk*)Vars.This)->FindThunkTarget();
-
-    _ASSERTE(NULL != Vars.RetAddr);
-
-    _asm pop edi;
-    _asm pop esi;
-    _asm pop edx;
-    _asm pop ecx;
-    _asm pop ebx;
-    _asm mov eax,Vars.RetAddr;
-    _asm leave;
-    _asm jmp eax;
-};
-
-#if defined(_MSC_VER) 
-#pragma warning(pop)
-#endif
-
-#elif defined(_TARGET_AMD64_)
-// Implemented in AMD64\UMThunkStub.asm
-#elif defined(_TARGET_ARM_)
-// Implemented in Arm\asmhelpers.asm
-#else
-void __cdecl IJWNOADThunk::MakeCall()
-{
-    LIMITED_METHOD_CONTRACT;
-    PORTABILITY_ASSERT("IJWNOADThunk::MakeCall");
-}
-#endif
-
-void IJWNOADThunk::SafeNoModule()
-{
-    STATIC_CONTRACT_THROWS;
-    STATIC_CONTRACT_GC_TRIGGERS;
-
-    if (!CanRunManagedCode())
-    {
-        Thread* pThread=GetThread();
-
-        // DO NOT IMPROVE THIS EXCEPTION!  It cannot be a managed exception.  It
-        // cannot be a real exception object because we cannot execute any managed
-        // code here.
-        if(pThread)
-            pThread->m_fPreemptiveGCDisabled = 0;
-        COMPlusThrowBoot(E_PROCESS_SHUTDOWN_REENTRY);
-    }
-    NoModule();
-}
-
-void IJWNOADThunk::NoModule()
-{
-    WRAPPER_NO_CONTRACT;
-    INSTALL_UNWIND_AND_CONTINUE_HANDLER;
-    //<TODO>This should give the file name as part of the exception message!</TODO>
-    COMPlusThrowHR(COR_E_DLLNOTFOUND);
-    UNINSTALL_UNWIND_AND_CONTINUE_HANDLER;
-}
-
-#endif // FEATURE_MIXEDMODE
-
diff --git a/src/vm/mixedmode.hpp b/src/vm/mixedmode.hpp
index 9d5037af8d..0010410f36 100644
--- a/src/vm/mixedmode.hpp
+++ b/src/vm/mixedmode.hpp
@@ -2,11 +2,11 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 // ===========================================================================
-// File: mixedmode.H
+// File: mixedmode.hpp
 // 
 
 //
-// MIXEDMODE.H defines classes to support mixed mode dlls
+// MIXEDMODE.HPP defines classes to support mixed mode dlls
 // ===========================================================================
 
 
diff --git a/src/vm/mlinfo.cpp b/src/vm/mlinfo.cpp
index 74bd536969..e5138db97f 100644
--- a/src/vm/mlinfo.cpp
+++ b/src/vm/mlinfo.cpp
@@ -52,19 +52,11 @@
     DEFINE_ASM_QUAL_TYPE_NAME(URI_ASM_QUAL_TYPE_NAME, g_SystemUriClassName, g_SystemRuntimeAsmName, VER_ASSEMBLYVERSION_STR, g_FXKeyToken);
 
     DEFINE_ASM_QUAL_TYPE_NAME(NCCEVENTARGS_ASM_QUAL_TYPE_NAME, g_NotifyCollectionChangedEventArgsName, g_ObjectModelAsmName, VER_ASSEMBLYVERSION_STR, g_FXKeyToken);
-#ifdef FEATURE_CORECLR
     DEFINE_ASM_QUAL_TYPE_NAME(NCCEVENTARGS_MARSHALER_ASM_QUAL_TYPE_NAME, g_NotifyCollectionChangedEventArgsMarshalerName, g_SystemRuntimeWindowsRuntimeAsmName, VER_ASSEMBLYVERSION_STR, g_ECMAKeyToken);
-#else
-    DEFINE_ASM_QUAL_TYPE_NAME(NCCEVENTARGS_MARSHALER_ASM_QUAL_TYPE_NAME, g_NotifyCollectionChangedEventArgsMarshalerName, g_SystemAsmName, VER_ASSEMBLYVERSION_STR, g_ECMAKeyToken);
-#endif
 
 
     DEFINE_ASM_QUAL_TYPE_NAME(PCEVENTARGS_ASM_QUAL_TYPE_NAME, g_PropertyChangedEventArgsName, g_ObjectModelAsmName, VER_ASSEMBLYVERSION_STR, g_FXKeyToken);
-#ifdef FEATURE_CORECLR
     DEFINE_ASM_QUAL_TYPE_NAME(PCEVENTARGS_MARSHALER_ASM_QUAL_TYPE_NAME, g_PropertyChangedEventArgsMarshalerName, g_SystemRuntimeWindowsRuntimeAsmName, VER_ASSEMBLYVERSION_STR, g_ECMAKeyToken);
-#else
-    DEFINE_ASM_QUAL_TYPE_NAME(PCEVENTARGS_MARSHALER_ASM_QUAL_TYPE_NAME, g_PropertyChangedEventArgsMarshalerName, g_SystemAsmName, VER_ASSEMBLYVERSION_STR, g_ECMAKeyToken);
-#endif
 
 
     #define OLECOLOR_TO_SYSTEMCOLOR_METH_NAME   "FromOle"
@@ -1523,9 +1515,6 @@ MarshalInfo::MarshalInfo(Module* pModule,
 
     CorNativeType nativeType        = NATIVE_TYPE_DEFAULT;
     Assembly *pAssembly             = pModule->GetAssembly();
-#ifndef FEATURE_CORECLR
-    BOOL fNeedsCopyCtor             = FALSE;
-#endif //  !FEATURE_CORECLR
     m_BestFit                       = BestFit;
     m_ThrowOnUnmappableChar         = ThrowOnUnmappableChar;
     m_ms                            = ms;
@@ -1636,23 +1625,6 @@ MarshalInfo::MarshalInfo(Module* pModule,
         IfFailGoto(sig.GetElemType(NULL), lFail);
         mtype = sig.PeekElemTypeNormalized(pModule, pTypeContext); 
 
-#ifndef FEATURE_CORECLR // no copy ctor support in CoreCLR
-        // Check for Copy Constructor Modifier - peek closed elem type here to prevent ELEMENT_TYPE_VALUETYPE
-        // turning into a primitive.
-        if (sig.PeekElemTypeClosed(pModule, pTypeContext) == ELEMENT_TYPE_VALUETYPE) 
-        {
-            // Skip ET_BYREF
-            IfFailGoto(sigtmp.GetByte(NULL), lFail);
-            
-            if (sigtmp.HasCustomModifier(pModule, "Microsoft.VisualC.NeedsCopyConstructorModifier", ELEMENT_TYPE_CMOD_REQD) ||
-                sigtmp.HasCustomModifier(pModule, "System.Runtime.CompilerServices.IsCopyConstructed", ELEMENT_TYPE_CMOD_REQD) )
-            {
-                mtype = ELEMENT_TYPE_VALUETYPE;
-                fNeedsCopyCtor = TRUE;
-                m_byref = FALSE;
-            }
-        }
-#endif // !FEATURE_CORECLR
     }
     else
     {
@@ -1695,21 +1667,6 @@ MarshalInfo::MarshalInfo(Module* pModule,
                     IfFailGoto(E_FAIL, lFail);
                 }
 
-#ifndef FEATURE_CORECLR
-                // Check for Copy Constructor Modifier
-                if (sigtmp.HasCustomModifier(pModule, "Microsoft.VisualC.NeedsCopyConstructorModifier", ELEMENT_TYPE_CMOD_REQD) ||
-                    sigtmp.HasCustomModifier(pModule, "System.Runtime.CompilerServices.IsCopyConstructed", ELEMENT_TYPE_CMOD_REQD) )
-                {
-                    mtype = mtype2;
-
-                    // Keep the sig pointer in sync with mtype (skip ELEMENT_TYPE_PTR) because for the rest
-                    // of this method we are pretending that the parameter is a value type passed by-value.
-                    IfFailGoto(sig.GetElemType(NULL), lFail);
-
-                    fNeedsCopyCtor = TRUE;
-                    m_byref = FALSE;
-                }
-#endif // !FEATURE_CORECLR
             }
         }
         else
@@ -2804,29 +2761,6 @@ MarshalInfo::MarshalInfo(Module* pModule,
                     }
                     else
                     {
-#ifndef FEATURE_CORECLR
-                        if (fNeedsCopyCtor)
-                        {
-                            if (m_ms == MARSHAL_SCENARIO_WINRT)
-                            {
-                                // our WinRT-optimized GetCOMIPFromRCW helpers don't support copy
-                                // constructor stubs so make sure that this marshaler will not be used
-                                m_resID = IDS_EE_BADMARSHAL_WINRT_COPYCTOR;
-                                IfFailGoto(E_FAIL, lFail);
-                            }
-
-                            MethodDesc *pCopyCtor;
-                            MethodDesc *pDtor;
-                            FindCopyCtor(pModule, m_pMT, &pCopyCtor);
-                            FindDtor(pModule, m_pMT, &pDtor);
-
-                            m_args.mm.m_pMT = m_pMT;
-                            m_args.mm.m_pCopyCtor = pCopyCtor;
-                            m_args.mm.m_pDtor = pDtor;
-                            m_type = MARSHAL_TYPE_BLITTABLEVALUECLASSWITHCOPYCTOR;
-                        }
-                        else
-#endif // !FEATURE_CORECLR
 #ifdef _TARGET_X86_
                         // JIT64 is not aware of normalized value types and this optimization
                         // (returning small value types by value in registers) is already done in JIT64.
@@ -2908,7 +2842,6 @@ MarshalInfo::MarshalInfo(Module* pModule,
 
 lExit:
 #ifdef FEATURE_COMINTEROP
-#ifdef FEATURE_CORECLR
 //Field scenario is not blocked here because we don't want to block loading structs that 
 //have the types which we are blocking, but never pass it to Interop.
 
@@ -2948,7 +2881,6 @@ lExit:
             COMPlusThrow(kPlatformNotSupportedException, m_resID);
 
     }
-#endif // FEATURE_CORECLR
     
     if (IsWinRTScenario() && !IsSupportedForWinRT(m_type))
     {
@@ -3559,9 +3491,6 @@ UINT16 MarshalInfo::GetNativeSize(MarshalType mtype, MarshalScenario ms)
         {
             case MARSHAL_TYPE_BLITTABLEVALUECLASS:
             case MARSHAL_TYPE_VALUECLASS:
-#ifndef FEATURE_CORECLR
-            case MARSHAL_TYPE_BLITTABLEVALUECLASSWITHCOPYCTOR:
-#endif // !FEATURE_CORECLR
                 return (UINT16) m_pMT->GetNativeSize();
 
             default:
@@ -4213,9 +4142,6 @@ DispParamMarshaler *MarshalInfo::GenerateDispParamMarshaler()
         case MARSHAL_TYPE_BLITTABLEVALUECLASS:
         case MARSHAL_TYPE_BLITTABLEPTR:
         case MARSHAL_TYPE_LAYOUTCLASSPTR:
-#ifndef FEATURE_CORECLR
-        case MARSHAL_TYPE_BLITTABLEVALUECLASSWITHCOPYCTOR:
-#endif
             pDispParamMarshaler = new DispParamRecordMarshaler(m_pMT);
             break;
 
@@ -4519,11 +4445,6 @@ VOID MarshalInfo::MarshalTypeToString(SString& strMarshalType, BOOL fSizeIsSpeci
             case MARSHAL_TYPE_ARGITERATOR:
                 strRetVal = W("ArgIterator");
                 break;
-#ifndef FEATURE_CORECLR
-            case MARSHAL_TYPE_BLITTABLEVALUECLASSWITHCOPYCTOR:
-                strRetVal = W("blittable value class with copy constructor");
-                break;
-#endif // FEATURE_CORECLR
 #ifdef FEATURE_COMINTEROP
             case MARSHAL_TYPE_OBJECT:
                 strRetVal = W("VARIANT");
@@ -5269,7 +5190,6 @@ void ArrayMarshalInfo::InitElementInfo(CorNativeType arrayNativeType, MarshalInf
         }
     }
 
-#ifdef FEATURE_CORECLR
    // Avoid throwing exceptions for any managed structs that have layouts and have types of fields that gets default to those banned types by default 
    // We don't know if they will be passed to native code anyway, and the right place to make the check is in the marshallers
    if (AppX::IsAppXProcess() && ms != MarshalInfo::MARSHAL_SCENARIO_FIELD)
@@ -5286,7 +5206,6 @@ void ArrayMarshalInfo::InitElementInfo(CorNativeType arrayNativeType, MarshalInf
         if (set_error)
             COMPlusThrow(kPlatformNotSupportedException, m_resID);
     }
-#endif // FEATURE_CORECLR
 
     // If we are exporting, we need to substitute the VTHACK_* VARTYPE with the actual
     // types as expressed in the type library.
diff --git a/src/vm/mlinfo.h b/src/vm/mlinfo.h
index f66c9c6bd8..d1b46065e4 100644
--- a/src/vm/mlinfo.h
+++ b/src/vm/mlinfo.h
@@ -301,14 +301,6 @@ public:
         return m_pWinRTPCEventArgsToSystemPCEventArgsMD;
     }
 
-#if defined(_DEBUG) && !defined(FEATURE_CORECLR)
-    BOOL IsEventArgsHelperMethod(MethodDesc *pMD)
-    {
-        LIMITED_METHOD_CONTRACT;
-        return (pMD == m_pSystemNCCEventArgsToWinRTNCCEventArgsMD || pMD == m_pWinRTNCCEventArgsToSystemNCCEventArgsMD ||
-                pMD == m_pSystemPCEventArgsToWinRTPCEventArgsMD   || pMD == m_pWinRTPCEventArgsToSystemPCEventArgsMD);
-    }
-#endif // #if defined(_DEBUG) && !defined(FEATURE_CORECLR)
 
 private:
     TypeHandle m_hndSystemNCCEventArgsType;
@@ -384,13 +376,6 @@ public:
         return m_SystemUriOriginalStringGetterMD;
     }
 
-#if defined(_DEBUG) && !defined(FEATURE_CORECLR)
-    BOOL IsUriHelperMethod(MethodDesc *pMD)
-    {
-        LIMITED_METHOD_CONTRACT;
-        return pMD == m_SystemUriCtorMD || pMD == m_SystemUriOriginalStringGetterMD;
-    }
-#endif // #if defined(_DEBUG) && !defined(FEATURE_CORECLR)
 
 private:
     TypeHandle m_hndSystemUriType;
@@ -429,13 +414,6 @@ public:
         return m_SystemColorToOleColorMD;
     }
 
-#if defined(_DEBUG) && !defined(FEATURE_CORECLR)
-    BOOL IsOleColorHelperMethod(MethodDesc *pMD)
-    {
-        LIMITED_METHOD_CONTRACT;
-        return pMD == m_OleColorToSystemColorMD || pMD == m_SystemColorToOleColorMD;
-    }
-#endif // #if defined(_DEBUG) && !defined(FEATURE_CORECLR)
 
 private:
     TypeHandle  m_hndColorType;
@@ -470,25 +448,6 @@ public:
     UriMarshalingInfo *GetUriMarshalingInfo();
     EventArgsMarshalingInfo *GetEventArgsMarshalingInfo();
 
-#if defined(_DEBUG) && !defined(FEATURE_CORECLR)
-    BOOL IsOleColorHelperMethod(MethodDesc *pMD)
-    {
-        LIMITED_METHOD_CONTRACT;
-        return m_pOleColorInfo != NULL && m_pOleColorInfo->IsOleColorHelperMethod(pMD);
-    }
-
-    BOOL IsUriHelperMethod(MethodDesc *pMD)
-    {
-        LIMITED_METHOD_CONTRACT;
-        return m_pUriInfo != NULL && m_pUriInfo->IsUriHelperMethod(pMD);
-    }
-
-    BOOL IsEventArgsHelperMethod(MethodDesc *pMD)
-    {
-        LIMITED_METHOD_CONTRACT;
-        return m_pEventArgsInfo != NULL && m_pEventArgsInfo->IsEventArgsHelperMethod(pMD);
-    }
-#endif // #if defined(_DEBUG) && !defined(FEATURE_CORECLR)
 
 #endif // FEATURE_COMINTEROP
 
diff --git a/src/vm/mscorlib.cpp b/src/vm/mscorlib.cpp
index b6fef9eaaa..53a9ec6fc1 100644
--- a/src/vm/mscorlib.cpp
+++ b/src/vm/mscorlib.cpp
@@ -27,13 +27,12 @@
 #include "arraynative.h"
 #include "stringnative.h"
 #include "stringbuffer.h"
-#include "securityimperative.h"
-#include "securitystackwalk.h"
 #include "objectnative.h"
 #include "comdelegate.h"
 #include "customattribute.h"
 #include "comdynamic.h"
-#include "commethodrental.h"
+#include "excep.h"
+#include "fcall.h"
 #include "nlsinfo.h"
 #include "calendardata.h"
 #include "commodule.h"
@@ -47,7 +46,6 @@
 #include "currency.h"
 #include "comdatetime.h"
 #include "comisolatedstorage.h"
-#include "securityconfig.h"
 #include "number.h"
 #include "compatibilityswitch.h"
 #ifdef FEATURE_REMOTING
@@ -71,41 +69,20 @@
 #include "reflectioninvocation.h"
 #include "managedmdimport.hpp"
 #include "synchronizationcontextnative.h"
-#include "newcompressedstack.h"
 #include "commemoryfailpoint.h"
 #include "typestring.h"
 #include "comdependenthandle.h"
 #include "weakreferencenative.h"
 #include "varargsnative.h"
 
-#ifndef FEATURE_CORECLR
-#include "confighelper.h"
-#include "console.h"
-#endif
-
 #ifdef MDA_SUPPORTED 
 #include "mdaassistants.h"
 #endif
 
-#ifdef FEATURE_CRYPTO
-#include "cryptography.h"
-#endif // FEATURE_CRYPTO
-
-#ifndef FEATURE_CORECLR
-#include "securityprincipal.h"
-#endif // !FEATURE_CORECLR
-
-#ifdef FEATURE_X509
-#include "x509certificate.h"
-#endif // FEATURE_X509
-
 #include "coverage.h"
 
 #ifdef FEATURE_COMINTEROP
 #include "variant.h"
-#ifdef FEATURE_COMINTEROP_TLB_SUPPORT
-#include "comtypelibconverter.h"
-#endif
 #include "oavariant.h"
 #include "registration.h"
 #include "mngstdinterfaces.h"
@@ -115,13 +92,11 @@
 #include "stubhelpers.h"
 #include "ilmarshalers.h"
 
-#include "hostexecutioncontext.h"
-
 #ifdef FEATURE_MULTICOREJIT
 #include "multicorejit.h"
 #endif
 
-#ifdef FEATURE_COMINTEROP
+#if defined(FEATURE_COMINTEROP) && defined(FEATURE_REFLECTION_ONLY_LOAD)
 #include "clrprivtypecachereflectiononlywinrt.h"
 #endif
 
diff --git a/src/vm/mscorlib.h b/src/vm/mscorlib.h
index bd40a7d279..f466c2f20c 100644
--- a/src/vm/mscorlib.h
+++ b/src/vm/mscorlib.h
@@ -82,31 +82,16 @@ DEFINE_FIELD_U(ReflectionOnlyAssemblyResolve,  AppDomainBaseObject, m_pReflectio
 #ifdef FEATURE_REMOTING
 DEFINE_FIELD_U(_DefaultContext,            AppDomainBaseObject, m_pDefaultContext)
 #endif
-#if defined(FEATURE_CLICKONCE)
-DEFINE_FIELD_U(_activationContext,         AppDomainBaseObject, m_pActivationContext)
-DEFINE_FIELD_U(_applicationIdentity,       AppDomainBaseObject, m_pApplicationIdentity)
-#endif
 DEFINE_FIELD_U(_applicationTrust,          AppDomainBaseObject, m_pApplicationTrust)
-#ifdef FEATURE_IMPERSONATION
-DEFINE_FIELD_U(_DefaultPrincipal,          AppDomainBaseObject, m_pDefaultPrincipal)
-#endif // FEATURE_IMPERSONATION
 #ifdef FEATURE_REMOTING
 DEFINE_FIELD_U(_RemotingData,              AppDomainBaseObject, m_pURITable)
 #endif
 DEFINE_FIELD_U(_processExit,               AppDomainBaseObject, m_pProcessExitEventHandler)
 DEFINE_FIELD_U(_domainUnload,              AppDomainBaseObject, m_pDomainUnloadEventHandler)
 DEFINE_FIELD_U(_unhandledException,        AppDomainBaseObject, m_pUnhandledExceptionEventHandler)
-#ifdef FEATURE_APTCA
-DEFINE_FIELD_U(_aptcaVisibleAssemblies,  AppDomainBaseObject, m_aptcaVisibleAssemblies)
-#endif
 DEFINE_FIELD_U(_compatFlags,              AppDomainBaseObject, m_compatFlags)
-#ifdef FEATURE_EXCEPTION_NOTIFICATIONS
 DEFINE_FIELD_U(_firstChanceException,      AppDomainBaseObject, m_pFirstChanceExceptionHandler)
-#endif // FEATURE_EXCEPTION_NOTIFICATIONS
 DEFINE_FIELD_U(_pDomain,                   AppDomainBaseObject, m_pDomain)
-#ifdef FEATURE_CAS_POLICY
-DEFINE_FIELD_U(_PrincipalPolicy,           AppDomainBaseObject, m_iPrincipalPolicy)
-#endif 
 DEFINE_FIELD_U(_HasSetPolicy,                     AppDomainBaseObject, m_bHasSetPolicy)
 DEFINE_FIELD_U(_IsFastFullTrustDomain,            AppDomainBaseObject, m_bIsFastFullTrustDomain)
 DEFINE_FIELD_U(_compatFlagsInitialized,           AppDomainBaseObject, m_compatFlagsInitialized)
@@ -129,15 +114,8 @@ DEFINE_METHOD(APP_DOMAIN,           ENABLE_RESOLVE_ASSEMBLIES_FOR_INTROSPECTION,
 DEFINE_METHOD(APP_DOMAIN,           ON_DESIGNER_NAMESPACE_RESOLVE, OnDesignerNamespaceResolveEvent, IM_Str_RetArrStr)
 #endif //FEATURE_COMINTEROP
 DEFINE_METHOD(APP_DOMAIN,           SETUP_DOMAIN,           SetupDomain,                IM_Bool_Str_Str_ArrStr_ArrStr_RetVoid)
-#ifdef FEATURE_FUSION
-DEFINE_METHOD(APP_DOMAIN,           SETUP_LOADER_OPTIMIZATION,SetupLoaderOptimization,  IM_LoaderOptimization_RetVoid)
-DEFINE_METHOD(APP_DOMAIN,           SET_DOMAIN_CONTEXT,     InternalSetDomainContext,       IM_Str_RetVoid)
-#endif // FEATURE_FUSION
 #ifdef FEATURE_REMOTING
 DEFINE_METHOD(APP_DOMAIN,           CREATE_DOMAIN,          CreateDomain,               SM_Str_Evidence_AppDomainSetup_RetAppDomain)
-#ifdef FEATURE_CAS_POLICY
-DEFINE_METHOD(APP_DOMAIN,           CREATE_DOMAINEX,        CreateDomain,               SM_Str_Evidence_Str_Str_Bool_RetAppDomain)
-#endif // FEATURE_CAS_POLICY
 DEFINE_METHOD(APP_DOMAIN,           VAL_CREATE_DOMAIN,      InternalCreateDomain,       SM_Str_RetAppDomain)
 #endif
 #ifdef FEATURE_REMOTING
@@ -146,26 +124,9 @@ DEFINE_METHOD(APP_DOMAIN,           MARSHAL_OBJECTS,        MarshalObjects,
 DEFINE_METHOD(APP_DOMAIN,           UNMARSHAL_OBJECT,       UnmarshalObject,            SM_ArrByte_RetObj)
 DEFINE_METHOD(APP_DOMAIN,           UNMARSHAL_OBJECTS,      UnmarshalObjects,           SM_ArrByte_ArrByte_RefObj_RetObj)
 #endif
-#ifdef FEATURE_FUSION
-DEFINE_METHOD(APP_DOMAIN,           TURN_ON_BINDING_REDIRECTS, TurnOnBindingRedirects,     IM_RetVoid)
-#endif // FEATURE_FUSION
 DEFINE_METHOD(APP_DOMAIN,           CREATE_APP_DOMAIN_MANAGER, CreateAppDomainManager,  IM_RetVoid)
 DEFINE_METHOD(APP_DOMAIN,           INITIALIZE_COMPATIBILITY_FLAGS, InitializeCompatibilityFlags,  IM_RetVoid)
 DEFINE_METHOD(APP_DOMAIN,           INITIALIZE_DOMAIN_SECURITY, InitializeDomainSecurity, IM_Evidence_Evidence_Bool_IntPtr_Bool_RetVoid)
-#ifdef FEATURE_CLICKONCE
-DEFINE_METHOD(APP_DOMAIN,           SETUP_DEFAULT_CLICKONCE_DOMAIN, SetupDefaultClickOnceDomain, IM_Str_ArrStr_ArrStr_RetVoid)
-DEFINE_METHOD(APP_DOMAIN,           ACTIVATE_APPLICATION,   ActivateApplication,        IM_RetInt)
-#endif // FEATURE_CLICKONCE
-#ifdef FEATURE_APTCA
-DEFINE_METHOD(APP_DOMAIN,           IS_ASSEMBLY_ON_APTCA_VISIBLE_LIST, IsAssemblyOnAptcaVisibleList, IM_Assembly_RetBool)
-DEFINE_METHOD(APP_DOMAIN,           IS_ASSEMBLY_ON_APTCA_VISIBLE_LIST_RAW, IsAssemblyOnAptcaVisibleListRaw, IM_PtrChar_Int_PtrByte_Int_RetBool)
-#endif // FEATURE_APTCA
-#ifndef FEATURE_CORECLR
-DEFINE_METHOD(APP_DOMAIN,           PAUSE, Pause, SM_RetVoid)
-DEFINE_METHOD(APP_DOMAIN,           RESUME, Resume, SM_RetVoid)
-DEFINE_CLASS(APPDOMAIN_MANAGER,     System,                 AppDomainManager)
-DEFINE_PROPERTY(APPDOMAIN_MANAGER,  ENTRY_ASSEMBLY,         EntryAssembly,          AssemblyBase)
-#endif // FEATURE_CORECLR
 
 DEFINE_CLASS(CLEANUP_WORK_LIST,     StubHelpers,            CleanupWorkList)
 
@@ -180,49 +141,19 @@ DEFINE_FIELD_U(typeKind,        TypeNameNative,             typeKind)
 
 #endif
 
-DEFINE_CLASS_U(Policy,                 ApplicationTrust,            ApplicationTrustObject)
-
-#ifdef FEATURE_CLICKONCE
-DEFINE_FIELD_U(m_appId,                ApplicationTrustObject,     _appId)
-DEFINE_FIELD_U(m_extraInfo,            ApplicationTrustObject,     _extraInfo)
-DEFINE_FIELD_U(m_elExtraInfo,          ApplicationTrustObject,     _elExtraInfo)
-#endif // FEATURE_CLICKONCE
-
-DEFINE_FIELD_U(m_psDefaultGrant,       ApplicationTrustObject,     _psDefaultGrant)
-DEFINE_FIELD_U(m_fullTrustAssemblies,  ApplicationTrustObject,     _fullTrustAssemblies)
-DEFINE_FIELD_U(m_grantSetSpecialFlags, ApplicationTrustObject,     _grantSetSpecialFlags)
-
-#ifdef FEATURE_CLICKONCE
-DEFINE_FIELD_U(m_appTrustedToRun,      ApplicationTrustObject,     _appTrustedToRun)
-DEFINE_FIELD_U(m_persist,              ApplicationTrustObject,     _persist)
-#endif // FEATURE_CLICKONCE
-
-DEFINE_CLASS_U(Policy,                 PolicyStatement,             PolicyStatementObject)
-DEFINE_FIELD_U(m_permSet,              PolicyStatementObject,      _permSet)
-DEFINE_FIELD_U(m_attributes,           PolicyStatementObject,      _attributes)
-
 DEFINE_CLASS(APPDOMAIN_SETUP,       System,                 AppDomainSetup)
 DEFINE_CLASS_U(System,       AppDomainSetup,                 AppDomainSetupObject)
 DEFINE_FIELD_U(_Entries,                           AppDomainSetupObject,   m_Entries)
 DEFINE_FIELD_U(_AppBase,                           AppDomainSetupObject,   m_AppBase)
 DEFINE_FIELD_U(_AppDomainInitializer,              AppDomainSetupObject,   m_AppDomainInitializer)
 DEFINE_FIELD_U(_AppDomainInitializerArguments,     AppDomainSetupObject,   m_AppDomainInitializerArguments)
-#ifdef FEATURE_CLICKONCE
-DEFINE_FIELD_U(_ActivationArguments,               AppDomainSetupObject,   m_ActivationArguments)
-#endif // FEATURE_CLICKONCE
 DEFINE_FIELD_U(_ApplicationTrust,                  AppDomainSetupObject,   m_ApplicationTrust)
 DEFINE_FIELD_U(_ConfigurationBytes,                AppDomainSetupObject,   m_ConfigurationBytes)
 DEFINE_FIELD_U(_AppDomainManagerAssembly,          AppDomainSetupObject,   m_AppDomainManagerAssembly)
 DEFINE_FIELD_U(_AppDomainManagerType,              AppDomainSetupObject,   m_AppDomainManagerType)
-#if FEATURE_APTCA
-DEFINE_FIELD_U(_AptcaVisibleAssemblies,            AppDomainSetupObject,   m_AptcaVisibleAssemblies)
-#endif
 DEFINE_FIELD_U(_CompatFlags,                       AppDomainSetupObject,   m_CompatFlags)
 DEFINE_FIELD_U(_TargetFrameworkName,               AppDomainSetupObject,   m_TargetFrameworkName)
 DEFINE_FIELD_U(_LoaderOptimization,                AppDomainSetupObject,   m_LoaderOptimization)
-#ifndef FEATURE_CORECLR
-DEFINE_FIELD_U(_AppDomainSortingSetupInfo,         AppDomainSetupObject,   m_AppDomainSortingSetupInfo)
-#endif // FEATURE_CORECLR
 #ifdef FEATURE_COMINTEROP
 DEFINE_FIELD_U(_DisableInterfaceCache,             AppDomainSetupObject,   m_DisableInterfaceCache)
 #endif // FEATURE_COMINTEROP
@@ -276,9 +207,6 @@ DEFINE_FIELD_U(_Flags,                     AssemblyNameBaseObject, m_Flags)
 DEFINE_CLASS(ASSEMBLY_NAME,         Reflection,             AssemblyName)
 DEFINE_METHOD(ASSEMBLY_NAME,        INIT,                   Init,                      IM_Str_ArrB_ArrB_Ver_CI_AHA_AVC_Str_ANF_SNKP_RetV)
 DEFINE_METHOD(ASSEMBLY_NAME,        SET_PROC_ARCH_INDEX,    SetProcArchIndex,          IM_PEK_IFM_RetV)
-#ifdef FEATURE_APTCA
-DEFINE_METHOD(ASSEMBLY_NAME,        GET_NAME_WITH_PUBLIC_KEY, GetNameWithPublicKey,    IM_RetStr)
-#endif // FEATURE_APTCA
 
 DEFINE_CLASS_U(System,                 Version,                    VersionBaseObject)
 DEFINE_FIELD_U(_Major,                     VersionBaseObject,    m_Major)
@@ -301,31 +229,10 @@ DEFINE_FIELD_U(_ModuleResolve,             AssemblyBaseObject,     m_pModuleEven
 DEFINE_FIELD_U(m_fullname,                 AssemblyBaseObject,     m_fullname)
 DEFINE_FIELD_U(m_syncRoot,                 AssemblyBaseObject,     m_pSyncRoot)
 DEFINE_FIELD_U(m_assembly,                 AssemblyBaseObject,     m_pAssembly)
-#ifndef FEATURE_CORECLR
-DEFINE_FIELD_U(m_flags,                    AssemblyBaseObject,     m_flags)
-#endif
 DEFINE_CLASS(ASSEMBLY,              Reflection,             RuntimeAssembly)
 DEFINE_FIELD(ASSEMBLY,              HANDLE,                 m_assembly)
 DEFINE_METHOD(ASSEMBLY,             GET_NAME,               GetName,                    IM_RetAssemblyName)
-#ifdef FEATURE_APTCA
-DEFINE_METHOD(ASSEMBLY,             GET_NAME_FOR_CONDITIONAL_APTCA, GetNameForConditionalAptca, IM_RetStr)
-#endif // FEATURE_APTCA
-#ifdef FEATURE_FUSION
-DEFINE_METHOD(ASSEMBLY,             LOAD_WITH_PARTIAL_NAME_HACK,  LoadWithPartialNameHack, SM_Str_Bool_RetAssembly)
-#endif // FEATURE_FUSION
 DEFINE_METHOD(ASSEMBLY,             ON_MODULE_RESOLVE,      OnModuleResolveEvent,       IM_Str_RetModule)
-#ifdef FEATURE_FUSION
-DEFINE_METHOD(ASSEMBLY,             DEMAND_PERMISSION,      DemandPermission,           SM_Str_Bool_Int_RetV)
-#endif
-
-#ifdef FEATURE_CAS_POLICY
-DEFINE_CLASS(ASSEMBLY_EVIDENCE_FACTORY, Policy,             AssemblyEvidenceFactory)
-DEFINE_METHOD(ASSEMBLY_EVIDENCE_FACTORY, UPGRADE_SECURITY_IDENTITY, UpgradeSecurityIdentity, SM_Evidence_Asm_RetEvidence)
-#endif // FEATURE_CAS_POLICY
-
-#ifdef FEATURE_COMINTEROP_REGISTRATION
-DEFINE_CLASS(ASSEMBLY_REGISTRATION_FLAGS, Interop,          AssemblyRegistrationFlags)
-#endif // FEATURE_COMINTEROP_REGISTRATION
 
 #ifdef FEATURE_REMOTING
 DEFINE_CLASS(ACTIVATION_SERVICES,   Activation,             ActivationServices)
@@ -372,8 +279,6 @@ DEFINE_METHOD(CLASS,                GET_PROPERTY_INFO,      GetPropertyInfo,
 
 DEFINE_CLASS(CLASS_INTROSPECTION_ONLY, System,              ReflectionOnlyType)
 
-DEFINE_CLASS(CODE_ACCESS_PERMISSION, Security,              CodeAccessPermission)
-
 #ifdef FEATURE_COMINTEROP
 DEFINE_CLASS_U(System,                 __ComObject,            ComObject)
 DEFINE_FIELD_U(m_ObjectToDataMap,      ComObject,              m_ObjectToDataMap)
@@ -383,11 +288,6 @@ DEFINE_METHOD(COM_OBJECT,           GET_EVENT_PROVIDER,     GetEventProvider,
 
 DEFINE_CLASS(RUNTIME_CLASS,                  WinRT,         RuntimeClass)
 
-#ifdef FEATURE_COMINTEROP_TLB_SUPPORT
-DEFINE_CLASS(ITYPE_LIB_IMPORTER_NOTIFY_SINK, Interop,       ITypeLibImporterNotifySink)
-DEFINE_CLASS(ITYPE_LIB_EXPORTER_NOTIFY_SINK, Interop,       ITypeLibExporterNotifySink)
-#endif //FEATURE_COMINTEROP_TLB_SUPPORT
-
 #endif // FEATURE_COMINTEROP
 
 DEFINE_CLASS_U(Interop,                CriticalHandle,             CriticalHandle)
@@ -466,32 +366,6 @@ DEFINE_METHOD(CONTEXT,              RESERVE_SLOT,           ReserveSlot,
 DEFINE_CLASS(CONTEXT_BOUND_OBJECT,  System,                 ContextBoundObject)
 #endif
 
-#ifdef FEATURE_CRYPTO
-DEFINE_CLASS(CSP_PARAMETERS,        Cryptography,           CspParameters)
-
-DEFINE_FIELD(CSP_PARAMETERS,        PROVIDER_TYPE,          ProviderType)
-DEFINE_FIELD(CSP_PARAMETERS,        PROVIDER_NAME,          ProviderName)
-DEFINE_FIELD(CSP_PARAMETERS,        KEY_CONTAINER_NAME,     KeyContainerName)
-DEFINE_FIELD(CSP_PARAMETERS,        FLAGS,                  m_flags)
-#endif //FEATURE_CRYPTO
-
-#if defined(FEATURE_X509) || defined(FEATURE_CRYPTO)
-DEFINE_CLASS(CRYPTO_EXCEPTION,      Cryptography,           CryptographicException)
-DEFINE_METHOD(CRYPTO_EXCEPTION,     THROW,                  ThrowCryptographicException, SM_Int_RetVoid)
-#endif // FEATURE_X509 || FEATURE_CRYPTO
-
-#ifndef FEATURE_CORECLR
-DEFINE_CLASS_U(Globalization,          AppDomainSortingSetupInfo,           AppDomainSortingSetupInfoObject)
-DEFINE_FIELD_U(_pfnIsNLSDefinedString,             AppDomainSortingSetupInfoObject,   m_pfnIsNLSDefinedString)
-DEFINE_FIELD_U(_pfnCompareStringEx,                AppDomainSortingSetupInfoObject,   m_pfnCompareStringEx)
-DEFINE_FIELD_U(_pfnLCMapStringEx,                  AppDomainSortingSetupInfoObject,   m_pfnLCMapStringEx)
-DEFINE_FIELD_U(_pfnFindNLSStringEx,                AppDomainSortingSetupInfoObject,   m_pfnFindNLSStringEx)
-DEFINE_FIELD_U(_pfnCompareStringOrdinal,           AppDomainSortingSetupInfoObject,   m_pfnCompareStringOrdinal)
-DEFINE_FIELD_U(_pfnGetNLSVersionEx,                AppDomainSortingSetupInfoObject,   m_pfnGetNLSVersionEx)
-DEFINE_FIELD_U(_pfnFindStringOrdinal,              AppDomainSortingSetupInfoObject,   m_pfnFindStringOrdinal)
-DEFINE_FIELD_U(_useV2LegacySorting,                AppDomainSortingSetupInfoObject,   m_useV2LegacySorting)
-DEFINE_FIELD_U(_useV4LegacySorting,                AppDomainSortingSetupInfoObject,   m_useV4LegacySorting)
-#endif // FEATURE_CORECLR
 
 #ifndef FEATURE_COREFX_GLOBALIZATION
 DEFINE_CLASS_U(Globalization,          CultureData,           CultureDataBaseObject)
@@ -668,9 +542,7 @@ DEFINE_CLASS(ENUM,                  System,                 Enum)
 
 DEFINE_CLASS(ENVIRONMENT,           System,                 Environment)
 DEFINE_METHOD(ENVIRONMENT,       GET_RESOURCE_STRING_LOCAL, GetResourceStringLocal,     SM_Str_RetStr)
-#ifdef FEATURE_CORECLR
 DEFINE_METHOD(ENVIRONMENT,       SET_COMMAND_LINE_ARGS,     SetCommandLineArgs,         SM_ArrStr_RetVoid)
-#endif
 
 #ifdef FEATURE_COMINTEROP
 DEFINE_CLASS(ERROR_WRAPPER,         Interop,                ErrorWrapper)
@@ -685,11 +557,6 @@ DEFINE_CLASS(EVENT_HANDLERGENERIC,  System,                 EventHandler`1)
 DEFINE_CLASS(EVENT_INFO,            Reflection,             EventInfo)
 
 DEFINE_CLASS(EVIDENCE,              Policy,                 Evidence)
-#ifdef FEATURE_CAS_POLICY
-// .ctor support for ICorRuntimeHost::CreateEvidence
-DEFINE_METHOD(EVIDENCE,             CTOR,                   .ctor, IM_RetVoid)
-DEFINE_METHOD(EVIDENCE,             WAS_STRONGNAME_EVIDENCE_USED, WasStrongNameEvidenceUsed, IM_RetBool)
-#endif // FEATURE_CAS_POLICY
 
 DEFINE_CLASS_U(System,                 Exception,      ExceptionObject)
 DEFINE_FIELD_U(_className,         ExceptionObject,    _className)
@@ -726,12 +593,10 @@ DEFINE_METHOD(EXCEPTION,            ADD_EXCEPTION_DATA_FOR_RESTRICTED_ERROR_INFO
 DEFINE_METHOD(EXCEPTION,            TRY_GET_RESTRICTED_LANGUAGE_ERROR_OBJECT,     TryGetRestrictedLanguageErrorObject, IM_RefObject_RetBool)
 #endif // FEATURE_COMINTEROP
 
-#ifdef FEATURE_CORECLR
 
 DEFINE_CLASS(CROSSAPPDOMAINMARSHALEDEXCEPTION,  System,      CrossAppDomainMarshaledException)
 DEFINE_METHOD(CROSSAPPDOMAINMARSHALEDEXCEPTION, STR_INT_CTOR, .ctor, IM_Str_Int_RetVoid)
 
-#endif //FEATURE_CORECLR
 
 
 DEFINE_CLASS(SYSTEM_EXCEPTION,      System,                 SystemException)
@@ -771,33 +636,6 @@ DEFINE_CLASS(I_RT_FIELD_INFO,       System,                 IRuntimeFieldInfo)
 
 DEFINE_CLASS(FIELD_INFO,            Reflection,             FieldInfo)
 
-#ifndef FEATURE_CORECLR
-DEFINE_CLASS_U(IO,               FileStreamAsyncResult, AsyncResultBase)
-DEFINE_FIELD_U(_userCallback,          AsyncResultBase,    _userCallback)
-DEFINE_FIELD_U(_userStateObject,       AsyncResultBase,    _userStateObject)
-DEFINE_FIELD_U(_waitHandle,            AsyncResultBase,    _waitHandle)
-DEFINE_FIELD_U(_handle,                AsyncResultBase,    _fileHandle)
-DEFINE_FIELD_U(_overlapped,            AsyncResultBase,    _overlapped)
-DEFINE_FIELD_U(_EndXxxCalled,          AsyncResultBase,    _EndXxxCalled)
-DEFINE_FIELD_U(_numBytes,              AsyncResultBase,    _numBytes)
-DEFINE_FIELD_U(_errorCode,             AsyncResultBase,    _errorCode)
-DEFINE_FIELD_U(_numBufferedBytes,      AsyncResultBase,    _numBufferedBytes)
-DEFINE_FIELD_U(_isWrite,               AsyncResultBase,    _isWrite)
-DEFINE_FIELD_U(_isComplete,            AsyncResultBase,    _isComplete)
-DEFINE_FIELD_U(_completedSynchronously, AsyncResultBase, _completedSynchronously)
-DEFINE_CLASS(FILESTREAM_ASYNCRESULT, IO,               FileStreamAsyncResult)
-#endif // !FEATURE_CORECLR
-
-DEFINE_CLASS_U(Security,           FrameSecurityDescriptor, FrameSecurityDescriptorBaseObject)
-DEFINE_FIELD_U(m_assertions,       FrameSecurityDescriptorBaseObject,  m_assertions)
-DEFINE_FIELD_U(m_denials,          FrameSecurityDescriptorBaseObject,  m_denials)
-DEFINE_FIELD_U(m_restriction,      FrameSecurityDescriptorBaseObject,  m_restriction)
-DEFINE_FIELD_U(m_AssertFT,         FrameSecurityDescriptorBaseObject,  m_assertFT)
-DEFINE_FIELD_U(m_assertAllPossible,FrameSecurityDescriptorBaseObject,  m_assertAllPossible)
-DEFINE_FIELD_U(m_DeclarativeAssertions,       FrameSecurityDescriptorBaseObject,  m_DeclarativeAssertions)
-DEFINE_FIELD_U(m_DeclarativeDenials,          FrameSecurityDescriptorBaseObject,  m_DeclarativeDenials)
-DEFINE_FIELD_U(m_DeclarativeRestrictions,      FrameSecurityDescriptorBaseObject,  m_DeclarativeRestrictions)
-DEFINE_CLASS(FRAME_SECURITY_DESCRIPTOR, Security,           FrameSecurityDescriptor)
 
 DEFINE_CLASS(GUID,                  System,                 Guid)
 
@@ -880,10 +718,6 @@ DEFINE_CLASS(IEXPANDO,              Expando,                IExpando)
 DEFINE_METHOD(IEXPANDO,             ADD_FIELD,              AddField,                   IM_Str_RetFieldInfo)
 DEFINE_METHOD(IEXPANDO,             REMOVE_MEMBER,          RemoveMember,               IM_MemberInfo_RetVoid)
 
-DEFINE_CLASS(IPERMISSION,           Security,               IPermission)
-
-DEFINE_CLASS(IPRINCIPAL,            Principal,              IPrincipal)
-
 DEFINE_CLASS(IREFLECT,              Reflection,             IReflect)
 DEFINE_METHOD(IREFLECT,             GET_PROPERTIES,         GetProperties,              IM_BindingFlags_RetArrPropertyInfo)
 DEFINE_METHOD(IREFLECT,             GET_FIELDS,             GetFields,                  IM_BindingFlags_RetArrFieldInfo)
@@ -1048,11 +882,9 @@ DEFINE_FIELD(NULL,                  VALUE,          Value)
 
 DEFINE_CLASS(NULLABLE,              System,                 Nullable`1)
 
-#ifdef FEATURE_SPAN_OF_T
 DEFINE_CLASS(BYREFERENCE,           System,                 ByReference`1)
 DEFINE_CLASS(SPAN,                  System,                 Span`1)
 DEFINE_CLASS(READONLY_SPAN,         System,                 ReadOnlySpan`1)
-#endif
 
 // Keep this in sync with System.Globalization.NumberFormatInfo
 DEFINE_CLASS_U(Globalization,       NumberFormatInfo,   NumberFormatInfo)
@@ -1162,66 +994,6 @@ DEFINE_CLASS(PARAMETER,             Reflection,             ParameterInfo)
 
 DEFINE_CLASS(PARAMETER_MODIFIER,    Reflection,             ParameterModifier)
 
-// Keep this in sync with System.Security.PermissionSet
-DEFINE_CLASS_U(Security,               PermissionSet,      PermissionSetObject)
-DEFINE_FIELD_U(m_permSet,                  PermissionSetObject, _permSet)
-DEFINE_FIELD_U(m_Unrestricted,             PermissionSetObject, _Unrestricted)
-DEFINE_FIELD_U(m_allPermissionsDecoded,    PermissionSetObject, _allPermissionsDecoded)
-#ifdef FEATURE_CAS_POLICY
-DEFINE_FIELD_U(m_canUnrestrictedOverride,PermissionSetObject, _canUnrestrictedOverride)
-#endif // FEATURE_CAS_POLICY
-DEFINE_FIELD_U(m_ignoreTypeLoadFailures, PermissionSetObject, _ignoreTypeLoadFailures)
-DEFINE_FIELD_U(m_CheckedForNonCas,         PermissionSetObject, _CheckedForNonCas)
-DEFINE_FIELD_U(m_ContainsCas,              PermissionSetObject, _ContainsCas)
-DEFINE_FIELD_U(m_ContainsNonCas,           PermissionSetObject, _ContainsNonCas)
-
-DEFINE_CLASS(PERMISSION_SET,        Security,               PermissionSet)
-DEFINE_METHOD(PERMISSION_SET,       CTOR,                   .ctor,                      IM_Bool_RetVoid)
-DEFINE_METHOD(PERMISSION_SET,       CREATE_SERIALIZED,      CreateSerialized,           SM_ArrObj_Bool_RefArrByte_OutPMS_HostProtectionResource_Bool_RetArrByte)
-#ifdef FEATURE_CAS_POLICY
-DEFINE_METHOD(PERMISSION_SET,       SETUP_SECURITY,         SetupSecurity,              SM_RetVoid)
-#endif // FEATURE_CAS_POLICY
-#ifdef FEATURE_CAS_POLICY
-DEFINE_METHOD(PERMISSION_SET,       DECODE_XML,             DecodeXml,                  IM_ArrByte_HostProtectionResource_HostProtectionResource_RetBool)
-DEFINE_METHOD(PERMISSION_SET,       ENCODE_XML,             EncodeXml,                  IM_RetArrByte)
-#endif // FEATURE_CAS_POLICY
-DEFINE_METHOD(PERMISSION_SET,       CONTAINS,               Contains,                   IM_IPermission_RetBool)
-DEFINE_METHOD(PERMISSION_SET,       DEMAND,                 Demand,                     IM_RetVoid)
-DEFINE_METHOD(PERMISSION_SET,       DEMAND_NON_CAS,         DemandNonCAS,               IM_RetVoid)
-DEFINE_METHOD(PERMISSION_SET,       IS_UNRESTRICTED,        IsUnrestricted,             IM_RetBool)
-#ifdef FEATURE_CAS_POLICY
-DEFINE_METHOD(PERMISSION_SET,       IS_SUBSET_OF,           IsSubsetOf,                 IM_PMS_RetBool)
-DEFINE_METHOD(PERMISSION_SET,       INTERSECT,              Intersect,                  IM_PMS_RetPMS)
-#endif // #ifdef FEATURE_CAS_POLICY
-DEFINE_METHOD(PERMISSION_SET,       INPLACE_UNION,          InplaceUnion,               IM_PMS_RetVoid)
-DEFINE_METHOD(PERMISSION_SET,       UNION,                  Union,                      IM_PMS_RetPMS)
-DEFINE_METHOD(PERMISSION_SET,       IS_EMPTY,               IsEmpty,                    IM_RetBool)
-DEFINE_METHOD(PERMISSION_SET,       ADD_PERMISSION,         AddPermission,              IM_IPermission_RetIPermission)
-
-DEFINE_CLASS(NAMEDPERMISSION_SET,      Security,               NamedPermissionSet)
-
-#ifdef FEATURE_CAS_POLICY
-DEFINE_CLASS(PEFILE_EVIDENCE_FACTORY,   Policy,             PEFileEvidenceFactory)
-DEFINE_METHOD(PEFILE_EVIDENCE_FACTORY,  CREATE_SECURITY_IDENTITY, CreateSecurityIdentity, SM_PEFile_Evidence_RetEvidence)
-#endif // FEATURE_CAS_POLICY
-
-DEFINE_CLASS_U(Security,             PermissionListSet,     PermissionListSetObject)
-DEFINE_FIELD_U(m_firstPermSetTriple,  PermissionListSetObject, _firstPermSetTriple)
-DEFINE_FIELD_U(m_permSetTriples,      PermissionListSetObject, _permSetTriples)
-#ifdef FEATURE_COMPRESSEDSTACK
-DEFINE_FIELD_U(m_zoneList,            PermissionListSetObject, _zoneList)
-DEFINE_FIELD_U(m_originList,          PermissionListSetObject, _originList)
-#endif // FEAUTRE_COMPRESSEDSTACK
-DEFINE_CLASS(PERMISSION_LIST_SET,   Security,               PermissionListSet)
-DEFINE_METHOD(PERMISSION_LIST_SET,  CTOR,                   .ctor,                      IM_RetVoid)
-DEFINE_METHOD(PERMISSION_LIST_SET,  CHECK_DEMAND_NO_THROW,  CheckDemandNoThrow,         IM_CodeAccessPermission_RetBool)
-DEFINE_METHOD(PERMISSION_LIST_SET,  CHECK_SET_DEMAND_NO_THROW, CheckSetDemandNoThrow,   IM_PMS_RetBool)
-DEFINE_METHOD(PERMISSION_LIST_SET,  UPDATE,                  Update,                     IM_PMS_RetVoid)
-
-DEFINE_CLASS(PERMISSION_STATE,      Permissions,            PermissionState)
-
-DEFINE_CLASS(PERMISSION_TOKEN,      Security,               PermissionToken)
-
 DEFINE_CLASS(POINTER,               Reflection,             Pointer)
 
 DEFINE_CLASS_U(Reflection, Pointer, ReflectionPointer)
@@ -1260,17 +1032,6 @@ DEFINE_METHOD(REAL_PROXY,           SUPPORTSINTERFACE,      SupportsInterface,
 #endif // FEATURE_COMINTEROP
 #endif // FEATURE_REMOTING
 
-DEFINE_CLASS(REFLECTION_PERMISSION, Permissions,            ReflectionPermission)
-DEFINE_METHOD(REFLECTION_PERMISSION,  CTOR,                   .ctor,                    IM_ReflectionPermissionFlag_RetVoid)
-
-DEFINE_CLASS(REFLECTION_PERMISSION_FLAG, Permissions,       ReflectionPermissionFlag)
-
-#ifdef FEATURE_COMINTEROP_REGISTRATION
-DEFINE_CLASS(REGISTRATION_SERVICES, Interop,                RegistrationServices)
-DEFINE_METHOD(REGISTRATION_SERVICES,REGISTER_ASSEMBLY,      RegisterAssembly,           IM_AssemblyBase_AssemblyRegistrationFlags_RetBool)
-DEFINE_METHOD(REGISTRATION_SERVICES,UNREGISTER_ASSEMBLY,    UnregisterAssembly,         IM_AssemblyBase_RetBool)
-#endif // FEATURE_COMINTEROP_REGISTRATION
-
 #ifdef FEATURE_RWLOCK
 DEFINE_CLASS_U(Threading,              ReaderWriterLock,           CRWLock)
 DEFINE_FIELD_U(_hWriterEvent,              CRWLock, _hWriterEvent)
@@ -1326,6 +1087,7 @@ DEFINE_CLASS(RUNTIME_HELPERS,       CompilerServices,       RuntimeHelpers)
 DEFINE_METHOD(RUNTIME_HELPERS,      PREPARE_CONSTRAINED_REGIONS, PrepareConstrainedRegions, SM_RetVoid)
 DEFINE_METHOD(RUNTIME_HELPERS,      PREPARE_CONSTRAINED_REGIONS_NOOP, PrepareConstrainedRegionsNoOP, SM_RetVoid)
 DEFINE_METHOD(RUNTIME_HELPERS,      EXECUTE_BACKOUT_CODE_HELPER, ExecuteBackoutCodeHelper, SM_Obj_Obj_Bool_RetVoid)
+DEFINE_METHOD(RUNTIME_HELPERS,      IS_REFERENCE_OR_CONTAINS_REFERENCES, IsReferenceOrContainsReferences, NoSig)
 
 DEFINE_CLASS(JIT_HELPERS,           CompilerServices,       JitHelpers)
 #ifdef _DEBUG
@@ -1339,20 +1101,16 @@ DEFINE_METHOD(JIT_HELPERS,          UNSAFE_ENUM_CAST,       UnsafeEnumCast, NoSi
 DEFINE_METHOD(JIT_HELPERS,          UNSAFE_ENUM_CAST_LONG,  UnsafeEnumCastLong, NoSig)
 DEFINE_METHOD(JIT_HELPERS,          UNSAFE_CAST_TO_STACKPTR,UnsafeCastToStackPointer, NoSig)
 #endif // _DEBUG
-#ifdef FEATURE_SPAN_OF_T
 DEFINE_METHOD(JIT_HELPERS,          BYREF_LESSTHAN,         ByRefLessThan, NoSig)
 DEFINE_METHOD(JIT_HELPERS,          GET_ARRAY_DATA,         GetArrayData, NoSig)
-DEFINE_METHOD(JIT_HELPERS,          CONTAINSREFERENCES,     ContainsReferences, NoSig)
-#endif
 
-#ifdef FEATURE_SPAN_OF_T
 DEFINE_CLASS(UNSAFE,                CompilerServices,       Unsafe)
 DEFINE_METHOD(UNSAFE,               AS_POINTER,             AsPointer, NoSig)
 DEFINE_METHOD(UNSAFE,               SIZEOF,                 SizeOf, NoSig)
 DEFINE_METHOD(UNSAFE,               BYREF_AS,               As, NoSig)
 DEFINE_METHOD(UNSAFE,               BYREF_ADD,              Add, NoSig)
 DEFINE_METHOD(UNSAFE,               BYREF_ARE_SAME,         AreSame, NoSig)
-#endif
+DEFINE_METHOD(UNSAFE,               BYREF_INIT_BLOCK_UNALIGNED, InitBlockUnaligned, NoSig)
 
 DEFINE_CLASS(INTERLOCKED,           Threading,              Interlocked)
 DEFINE_METHOD(INTERLOCKED,          COMPARE_EXCHANGE_T,     CompareExchange, GM_RefT_T_T_RetT)
@@ -1361,10 +1119,8 @@ DEFINE_METHOD(INTERLOCKED,          COMPARE_EXCHANGE_OBJECT,CompareExchange, SM_
 DEFINE_CLASS(PINNING_HELPER,        CompilerServices,       PinningHelper)
 DEFINE_FIELD(PINNING_HELPER,        M_DATA,                 m_data)
 
-#ifdef FEATURE_SPAN_OF_T
 DEFINE_CLASS(ARRAY_PINNING_HELPER,  CompilerServices,       ArrayPinningHelper)
 DEFINE_FIELD(ARRAY_PINNING_HELPER,  M_ARRAY_DATA,           m_arrayData)
-#endif
 
 DEFINE_CLASS(RUNTIME_WRAPPED_EXCEPTION, CompilerServices,   RuntimeWrappedException)
 DEFINE_METHOD(RUNTIME_WRAPPED_EXCEPTION, OBJ_CTOR,          .ctor,                      IM_Obj_RetVoid)
@@ -1382,101 +1138,15 @@ DEFINE_METHOD(SAFE_HANDLE,          RELEASE_HANDLE,         ReleaseHandle,
 DEFINE_METHOD(SAFE_HANDLE,          DISPOSE,                Dispose,                    IM_RetVoid)
 DEFINE_METHOD(SAFE_HANDLE,          DISPOSE_BOOL,           Dispose,                    IM_Bool_RetVoid)
 
-#ifdef FEATURE_CAS_POLICY
-DEFINE_CLASS(SAFE_PEFILE_HANDLE,    SafeHandles,            SafePEFileHandle)
-#endif // FEATURE_CAS_POLICY
-
-#ifndef FEATURE_CORECLR
-DEFINE_CLASS(SAFE_TOKENHANDLE, SafeHandles, SafeAccessTokenHandle)
-#endif
 
 DEFINE_CLASS(SAFE_TYPENAMEPARSER_HANDLE,    System,         SafeTypeNameParserHandle)
 
-#ifdef FEATURE_COMPRESSEDSTACK
-DEFINE_CLASS(SAFE_CSHANDLE, Threading, SafeCompressedStackHandle)
-#endif // #ifdef FEATURE_COMPRESSEDSTACK
-
-
-DEFINE_CLASS(SECURITY_ACTION,       Permissions,            SecurityAction)
-DEFINE_CLASS(HOST_PROTECTION_RESOURCE, Permissions,         HostProtectionResource)
-
-#ifdef FEATURE_CAS_POLICY
-DEFINE_CLASS(SECURITY_ATTRIBUTE,    Permissions,            SecurityAttribute)
-DEFINE_METHOD(SECURITY_ATTRIBUTE, FIND_SECURITY_ATTRIBUTE_TYPE_HANDLE, FindSecurityAttributeTypeHandle, SM_Str_RetIntPtr)
-#endif
-
-#ifdef FEATURE_CAS_POLICY
-DEFINE_CLASS(SECURITY_ELEMENT,      Security,               SecurityElement)
-DEFINE_METHOD(SECURITY_ELEMENT,     TO_STRING,              ToString,                   IM_RetStr)
-#endif // FEATURE_CAS_POLICY
-
-DEFINE_CLASS(SECURITY_ENGINE,       Security,               CodeAccessSecurityEngine)
-DEFINE_METHOD(SECURITY_ENGINE,      CHECK_HELPER,           CheckHelper,                SM_CS_PMS_PMS_CodeAccessPermission_PermissionToken_RuntimeMethodHandleInternal_Assembly_SecurityAction_RetVoid)
-DEFINE_METHOD(SECURITY_ENGINE,      CHECK_SET_HELPER,       CheckSetHelper,             SM_CS_PMS_PMS_PMS_RuntimeMethodHandleInternal_Assembly_SecurityAction_RetVoid)
-#ifdef FEATURE_APTCA
-DEFINE_METHOD(SECURITY_ENGINE,      THROW_SECURITY_EXCEPTION, ThrowSecurityException,   SM_Assembly_PMS_PMS_RuntimeMethodHandleInternal_SecurityAction_Obj_IPermission_RetVoid)
-#endif // FEATURE_APTCA
-#ifdef FEATURE_CAS_POLICY
-DEFINE_METHOD(SECURITY_ENGINE,      RESOLVE_GRANT_SET,      ResolveGrantSet,            SM_Evidence_RefInt_Bool_RetPMS)
-DEFINE_METHOD(SECURITY_ENGINE,      PRE_RESOLVE,            PreResolve,                 SM_RefBool_RefBool_RetVoid)
-#endif // FEATURE_CAS_POLICY
-
-#ifdef FEATURE_PLS
-DEFINE_METHOD(SECURITY_ENGINE,      UPDATE_APPDOMAIN_PLS,   UpdateAppDomainPLS,         SM_PermissionListSet_PMS_PMS_RetPermissionListSet)
-#endif // FEATURE_PLS
-
-#ifdef FEATURE_CAS_POLICY
-#ifdef FEATURE_NONGENERIC_COLLECTIONS 
-DEFINE_METHOD(SECURITY_ENGINE,      GET_ZONE_AND_ORIGIN_HELPER, GetZoneAndOriginHelper, SM_CS_PMS_PMS_ArrayList_ArrayList_RetVoid)
-#else
-#error Need replacement for GetZoneAndOriginHelper
-#endif // FEATURE_NONGENERIC_COLLECTIONS 
-DEFINE_METHOD(SECURITY_ENGINE,      REFLECTION_TARGET_DEMAND_HELPER,    ReflectionTargetDemandHelper,    SM_Int_PMS_RetVoid)
-DEFINE_METHOD(SECURITY_ENGINE,      REFLECTION_TARGET_DEMAND_HELPER_WITH_CONTEXT, ReflectionTargetDemandHelper,    SM_Int_PMS_Resolver_RetVoid)
-DEFINE_METHOD(SECURITY_ENGINE,      CHECK_GRANT_SET_HELPER, CheckGrantSetHelper,        SM_PMS_RetVoid)
-#endif // FEATURE_CAS_POLICY
-
 DEFINE_CLASS(SECURITY_EXCEPTION,    Security,               SecurityException)
-#ifdef FEATURE_CAS_POLICY
-DEFINE_METHOD(SECURITY_EXCEPTION,   CTOR,                   .ctor,                      IM_Str_Type_Str_RetVoid)
-#endif // FEATURE_CAS_POLICY
-
-#ifdef FEATURE_CAS_POLICY
-DEFINE_CLASS(HOST_PROTECTION_EXCEPTION, Security,         HostProtectionException)
-DEFINE_METHOD(HOST_PROTECTION_EXCEPTION, CTOR,            .ctor,                        IM_HPR_HPR_RetVoid)
-#endif // FEATURE_CAS_POLICY
-
-DEFINE_CLASS(SECURITY_MANAGER,      Security,               SecurityManager)
-#ifdef FEATURE_CAS_POLICY
-DEFINE_METHOD(SECURITY_MANAGER,     RESOLVE_CAS_POLICY,     ResolveCasPolicy,           SM_Evidence_PMS_PMS_PMS_PMS_int_Bool_RetPMS)
-#endif
-
-DEFINE_CLASS(SECURITY_PERMISSION,   Permissions,            SecurityPermission)
-DEFINE_METHOD(SECURITY_PERMISSION,  CTOR,                   .ctor,                      IM_SecurityPermissionFlag_RetVoid)
-#ifdef FEATURE_CAS_POLICY
-DEFINE_METHOD(SECURITY_PERMISSION,  TOXML,                  ToXml,                      IM_RetSecurityElement)
-#endif // FEATURE_CAS_POLICY
-
-DEFINE_CLASS(SECURITY_PERMISSION_FLAG,Permissions,          SecurityPermissionFlag)
-
-DEFINE_CLASS(SECURITY_RUNTIME,      Security,               SecurityRuntime)
-DEFINE_METHOD(SECURITY_RUNTIME,     FRAME_DESC_HELPER,      FrameDescHelper,            SM_FrameSecurityDescriptor_IPermission_PermissionToken_RuntimeMethodHandleInternal_RetBool)
-DEFINE_METHOD(SECURITY_RUNTIME,     FRAME_DESC_SET_HELPER,  FrameDescSetHelper,         SM_FrameSecurityDescriptor_PMS_OutPMS_RuntimeMethodHandleInternal_RetBool)
-#ifdef FEATURE_COMPRESSEDSTACK
-DEFINE_METHOD(SECURITY_RUNTIME,     CHECK_DYNAMIC_METHOD_HELPER,      CheckDynamicMethodHelper,    SM_DynamicResolver_IPermission_PermissionToken_RuntimeMethodHandleInternal_RetBool)
-DEFINE_METHOD(SECURITY_RUNTIME,     CHECK_DYNAMIC_METHOD_SET_HELPER,  CheckDynamicMethodSetHelper, SM_DynamicResolver_PMS_OutPMS_RuntimeMethodHandleInternal_RetBool)
-#endif // FEATURE_COMPRESSEDSTACK
 
 #ifdef FEATURE_REMOTING
 DEFINE_CLASS(SERVER_IDENTITY,       Remoting,               ServerIdentity)
 DEFINE_FIELD(SERVER_IDENTITY,       SERVER_CONTEXT,         _srvCtx)
 #endif // FEATURE_REMOTING
-#ifdef FEATURE_COMPRESSEDSTACK
-DEFINE_CLASS(DOMAIN_COMPRESSED_STACK, Threading, DomainCompressedStack)
-DEFINE_METHOD(DOMAIN_COMPRESSED_STACK, CREATE_MANAGED_OBJECT, CreateManagedObject, SM_IntPtr_RetDCS)
-DEFINE_CLASS(COMPRESSED_STACK, Threading, CompressedStack)
-DEFINE_METHOD(COMPRESSED_STACK,    RUN,                   Run,                SM_CompressedStack_ContextCallback_Object_RetVoid)
-#endif // FEATURE_COMPRESSEDSTACK            
 
 DEFINE_CLASS(SHARED_STATICS,        System,                 SharedStatics)
 DEFINE_FIELD(SHARED_STATICS,        SHARED_STATICS,         _sharedStatics)
@@ -1502,9 +1172,7 @@ DEFINE_FIELD_U(rgiMethodToken,             StackFrameHelper,   rgiMethodToken)
 DEFINE_FIELD_U(rgFilename,                 StackFrameHelper,   rgFilename)
 DEFINE_FIELD_U(rgiLineNumber,              StackFrameHelper,   rgiLineNumber)
 DEFINE_FIELD_U(rgiColumnNumber,            StackFrameHelper,   rgiColumnNumber)
-#if defined(FEATURE_EXCEPTIONDISPATCHINFO)
 DEFINE_FIELD_U(rgiLastFrameFromForeignExceptionStackTrace,            StackFrameHelper,   rgiLastFrameFromForeignExceptionStackTrace)
-#endif // defined(FEATURE_EXCEPTIONDISPATCHINFO)
 DEFINE_FIELD_U(getSourceLineInfo,          StackFrameHelper,   getSourceLineInfo)
 DEFINE_FIELD_U(iFrameCount,                StackFrameHelper,   iFrameCount)
 
@@ -1555,54 +1223,14 @@ DEFINE_METHOD(STRING_BUILDER,       REPLACE_BUFFER_INTERNAL,ReplaceBufferInterna
 DEFINE_METHOD(STRING_BUILDER,       REPLACE_BUFFER_ANSI_INTERNAL,ReplaceBufferAnsiInternal, IM_PtrSByt_Int_RetVoid)
 
 DEFINE_CLASS(STRONG_NAME_KEY_PAIR,  Reflection,             StrongNameKeyPair)
-#ifndef FEATURE_CORECLR
-DEFINE_METHOD(STRONG_NAME_KEY_PAIR, GET_KEY_PAIR,           GetKeyPair,                 IM_RefObject_RetBool) 
-#endif
 
-#ifdef FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
 DEFINE_CLASS_U(Threading,              SynchronizationContext, SynchronizationContextObject)
 DEFINE_FIELD_U(_props, SynchronizationContextObject, _props)
 DEFINE_CLASS(SYNCHRONIZATION_CONTEXT,    Threading,              SynchronizationContext)
 DEFINE_METHOD(SYNCHRONIZATION_CONTEXT,  INVOKE_WAIT_METHOD_HELPER, InvokeWaitMethodHelper, SM_SyncCtx_ArrIntPtr_Bool_Int_RetInt)
-#endif // FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
-
-#ifdef FEATURE_COMINTEROP_TLB_SUPPORT
-DEFINE_CLASS(TCE_EVENT_ITF_INFO,    InteropTCE,             EventItfInfo)
-DEFINE_METHOD(TCE_EVENT_ITF_INFO,   CTOR,                   .ctor,                      IM_Str_Str_Str_Assembly_Assembly_RetVoid)
-#endif // FEATURE_COMINTEROP_TLB_SUPPORT
 
 DEFINE_CLASS(CONTEXTCALLBACK,       Threading,       ContextCallback)
 
-#if defined(FEATURE_IMPERSONATION) || defined(FEATURE_COMPRESSEDSTACK)
-DEFINE_CLASS_U(Security,           SecurityContext,        SecurityContextObject)
-DEFINE_FIELD_U(_executionContext,      SecurityContextObject,      _executionContext)
-#if defined(FEATURE_IMPERSONATION)
-DEFINE_FIELD_U(_windowsIdentity,       SecurityContextObject,      _windowsIdentity)
-#endif
-DEFINE_FIELD_U(_compressedStack,       SecurityContextObject,      _compressedStack)
-DEFINE_FIELD_U(_disableFlow,           SecurityContextObject,      _disableFlow)
-DEFINE_FIELD_U(isNewCapture,           SecurityContextObject,      _isNewCapture)
-DEFINE_CLASS(SECURITYCONTEXT,     Security,           SecurityContext)
-DEFINE_METHOD(SECURITYCONTEXT,               RUN,                   Run,                SM_SecurityContext_ContextCallback_Object_RetVoid)
-#endif // #if defined(FEATURE_IMPERSONATION) || defined(FEATURE_COMPRESSEDSTACK)
-
-#ifndef FEATURE_CORECLR
-DEFINE_CLASS_U(Threading,                  ExecutionContext,       ExecutionContextObject)
-#ifdef FEATURE_CAS_POLICY
-DEFINE_FIELD_U(_hostExecutionContext,  ExecutionContextObject,     _hostExecutionContext)
-#endif // FEATURE_CAS_POLICY
-DEFINE_FIELD_U(_syncContext,           ExecutionContextObject,     _syncContext)
-#if defined(FEATURE_IMPERSONATION) || defined(FEATURE_COMPRESSEDSTACK)
-DEFINE_FIELD_U(_securityContext,       ExecutionContextObject,     _securityContext)
-#endif // #if defined(FEATURE_IMPERSONATION) || defined(FEATURE_COMPRESSEDSTACK)
-#ifdef FEATURE_REMOTING
-DEFINE_FIELD_U(_logicalCallContext,    ExecutionContextObject,     _logicalCallContext)
-DEFINE_FIELD_U(_illogicalCallContext,  ExecutionContextObject,     _illogicalCallContext)
-#endif // #ifdef FEATURE_REMOTING
-DEFINE_CLASS(EXECUTIONCONTEXT,          Threading,                  ExecutionContext)
-DEFINE_METHOD(EXECUTIONCONTEXT,               RUN,                   Run,                SM_ExecutionContext_ContextCallback_Object_Bool_RetVoid)
-#endif //FEATURE_CORECLR
-
 #ifdef _DEBUG
 DEFINE_CLASS(STACKCRAWMARK,         Threading,       StackCrawlMark)
 #endif
@@ -1613,9 +1241,6 @@ DEFINE_CLASS_U(Threading,              Thread,                     ThreadBaseObj
 #ifdef FEATURE_REMOTING
 DEFINE_FIELD_U(m_Context,                  ThreadBaseObject,   m_ExposedContext)
 #endif
-#ifndef FEATURE_CORECLR
-DEFINE_FIELD_U(m_ExecutionContext,         ThreadBaseObject,   m_ExecutionContext)
-#endif
 DEFINE_FIELD_U(m_Name,                     ThreadBaseObject,   m_Name)
 DEFINE_FIELD_U(m_Delegate,                 ThreadBaseObject,   m_Delegate)
 #ifdef FEATURE_LEAK_CULTURE_INFO 
@@ -1630,9 +1255,6 @@ DEFINE_CLASS(THREAD,                Threading,              Thread)
 DEFINE_FIELD(THREAD,                CULTURE,                m_CurrentCulture)
 DEFINE_FIELD(THREAD,                UI_CULTURE,             m_CurrentUICulture)
 #endif
-#ifdef FEATURE_IMPERSONATION
-DEFINE_METHOD(THREAD,               SET_PRINCIPAL_INTERNAL, SetPrincipalInternal,       IM_IPrincipal_RetVoid)
-#endif
 #ifdef FEATURE_REMOTING
 DEFINE_STATIC_PROPERTY(THREAD,      CURRENT_CONTEXT,        CurrentContext,             Context)
 #endif
@@ -1676,26 +1298,17 @@ DEFINE_PROPERTY(TYPE,               IS_IMPORT,              IsImport,
 
 DEFINE_CLASS(TYPE_DELEGATOR,        Reflection,             TypeDelegator)
 
-DEFINE_CLASS(UI_PERMISSION,         Permissions,            UIPermission)
-DEFINE_METHOD(UI_PERMISSION,        CTOR,                   .ctor,                      IM_PermissionState_RetVoid)
-
 DEFINE_CLASS(UNHANDLED_EVENTARGS,   System,                 UnhandledExceptionEventArgs)
 DEFINE_METHOD(UNHANDLED_EVENTARGS,  CTOR,                   .ctor,                      IM_Obj_Bool_RetVoid)
 
-#ifdef FEATURE_EXCEPTION_NOTIFICATIONS
 DEFINE_CLASS(FIRSTCHANCE_EVENTARGS,   ExceptionServices,      FirstChanceExceptionEventArgs)
 DEFINE_METHOD(FIRSTCHANCE_EVENTARGS,  CTOR,                   .ctor,                      IM_Exception_RetVoid)
-#endif // FEATURE_EXCEPTION_NOTIFICATIONS
-
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
 DEFINE_CLASS(ASSEMBLYLOADCONTEXT,  Loader,                AssemblyLoadContext)    
 DEFINE_METHOD(ASSEMBLYLOADCONTEXT,  RESOLVE,          Resolve,                      SM_IntPtr_AssemblyName_RetAssemblyBase)
 DEFINE_METHOD(ASSEMBLYLOADCONTEXT,  RESOLVEUNMANAGEDDLL,          ResolveUnmanagedDll,                      SM_Str_IntPtr_RetIntPtr)
 DEFINE_METHOD(ASSEMBLYLOADCONTEXT,  RESOLVEUSINGEVENT,          ResolveUsingResolvingEvent,                      SM_IntPtr_AssemblyName_RetAssemblyBase)
 
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
-
 DEFINE_CLASS(LAZY,              System,     Lazy`1)
 
 DEFINE_CLASS(LAZY_INITIALIZER,  Threading,  LazyInitializer)
@@ -1711,15 +1324,6 @@ DEFINE_CLASS(VALUE_TYPE,            System,                 ValueType)
 DEFINE_CLASS(VARIANT_WRAPPER,       Interop,                VariantWrapper)
 #endif // FEATURE_COMINTEROP
 
-#ifdef FEATURE_IMPERSONATION
-DEFINE_CLASS(WINDOWS_IDENTITY,      Principal,              WindowsIdentity)
-DEFINE_METHOD(WINDOWS_IDENTITY,     SERIALIZATION_CTOR,     .ctor,                      IM_SerInfo_RetVoid)
-#endif
-#ifdef FEATURE_X509
-DEFINE_CLASS(X509_CERTIFICATE,      X509,                   X509Certificate)
-DEFINE_METHOD(X509_CERTIFICATE,     CTOR,                   .ctor,                      IM_ArrByte_RetVoid)
-#endif // FEATURE_X509
-
 DEFINE_CLASS(GC,                    System,                 GC)
 DEFINE_METHOD(GC,                   KEEP_ALIVE,             KeepAlive,                  SM_Obj_RetVoid)
 DEFINE_METHOD(GC,                   COLLECT,                Collect,                    SM_RetVoid)
@@ -1745,9 +1349,6 @@ DEFINE_METHOD(BUFFER,               MEMCPY,                 Memcpy,
 DEFINE_CLASS(WINDOWSRUNTIMEMARSHAL, WinRT,  WindowsRuntimeMarshal)
 #ifdef FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION
 DEFINE_METHOD(WINDOWSRUNTIMEMARSHAL, GET_ACTIVATION_FACTORY_FOR_TYPE, GetActivationFactoryForType, SM_Type_RetIntPtr)
-#ifdef FEATURE_COMINTEROP_WINRT_DESKTOP_HOST
-DEFINE_METHOD(WINDOWSRUNTIMEMARSHAL, GET_CLASS_ACTIVATOR_FOR_APPLICATION, GetClassActivatorForApplication, SM_Str_RetIntPtr)
-#endif // FEATURE_COMINTEROP_WINRT_DESKTOP_HOST
 #endif // FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION
 
 DEFINE_CLASS(IACTIVATIONFACTORY,    WinRT,  IActivationFactory)
@@ -1761,13 +1362,6 @@ DEFINE_METHOD(STUBHELPERS,          IS_QCALL,               IsQCall,
 DEFINE_METHOD(STUBHELPERS,          INIT_DECLARING_TYPE,    InitDeclaringType,          SM_IntPtr_RetVoid)
 DEFINE_METHOD(STUBHELPERS,          GET_NDIRECT_TARGET,     GetNDirectTarget,           SM_IntPtr_RetIntPtr)
 DEFINE_METHOD(STUBHELPERS,          GET_DELEGATE_TARGET,    GetDelegateTarget,          SM_Delegate_RefIntPtr_RetIntPtr)
-#ifndef FEATURE_CORECLR // CAS
-DEFINE_METHOD(STUBHELPERS,          DEMAND_PERMISSION,      DemandPermission,           SM_IntPtr_RetVoid)
-#ifdef _TARGET_X86_
-DEFINE_METHOD(STUBHELPERS,          SET_COPY_CTOR_COOKIE_CHAIN, SetCopyCtorCookieChain, SM_IntPtr_IntPtr_Int_IntPtr_RetVoid)
-DEFINE_FIELD(STUBHELPERS,           COPY_CTOR_STUB_DESC,    s_copyCtorStubDesc)
-#endif // _TARGET_X86_
-#endif // !FEATURE_CORECLR
 #ifdef FEATURE_COMINTEROP
 DEFINE_METHOD(STUBHELPERS,          GET_COM_HR_EXCEPTION_OBJECT,              GetCOMHRExceptionObject,            SM_Int_IntPtr_Obj_RetException)
 DEFINE_METHOD(STUBHELPERS,          GET_COM_HR_EXCEPTION_OBJECT_WINRT,        GetCOMHRExceptionObject_WinRT,      SM_Int_IntPtr_Obj_RetException)
@@ -1786,13 +1380,11 @@ DEFINE_METHOD(STUBHELPERS,          GET_OUTER_INSPECTABLE,                    Ge
 DEFINE_METHOD(STUBHELPERS,          TRIGGER_EXCEPTION_SWALLOWED_MDA,          TriggerExceptionSwallowedMDA,       SM_Exception_IntPtr_RetException)
 #endif // MDA_SUPPORTED
 #endif // FEATURE_COMINTEROP
-#if defined(MDA_SUPPORTED) || (defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR))
+#if defined(MDA_SUPPORTED)
 DEFINE_METHOD(STUBHELPERS,          CHECK_COLLECTED_DELEGATE_MDA, CheckCollectedDelegateMDA, SM_IntPtr_RetVoid)
 #endif // MDA_SUPPORTED
 DEFINE_METHOD(STUBHELPERS,          SET_LAST_ERROR,         SetLastError,               SM_RetVoid)
-#ifdef FEATURE_CORECLR
 DEFINE_METHOD(STUBHELPERS,          CLEAR_LAST_ERROR,       ClearLastError,             SM_RetVoid)
-#endif
 
 DEFINE_METHOD(STUBHELPERS,          THROW_INTEROP_PARAM_EXCEPTION, ThrowInteropParamException,   SM_Int_Int_RetVoid)
 DEFINE_METHOD(STUBHELPERS,          ADD_TO_CLEANUP_LIST,    AddToCleanupList,           SM_RefCleanupWorkList_SafeHandle_RetIntPtr)
@@ -1837,12 +1429,6 @@ DEFINE_METHOD(STUBHELPERS,          ARRAY_TYPE_CHECK,    ArrayTypeCheck,
 DEFINE_METHOD(STUBHELPERS,          MULTICAST_DEBUGGER_TRACE_HELPER,    MulticastDebuggerTraceHelper,    SM_Obj_Int_RetVoid)
 #endif
 
-#if defined(_TARGET_X86_) && !defined(FEATURE_CORECLR)
-DEFINE_CLASS(COPYCTORSTUBCOOKIE,    StubHelpers,            CopyCtorStubCookie)
-DEFINE_METHOD(COPYCTORSTUBCOOKIE,   SET_DATA,               SetData,                    IM_IntPtr_UInt_IntPtr_IntPtr_RetVoid)
-DEFINE_METHOD(COPYCTORSTUBCOOKIE,   SET_NEXT,               SetNext,                    IM_IntPtr_RetVoid)
-#endif // _TARGET_X86_ && !FEATURE_CORECLR
-
 DEFINE_CLASS(ANSICHARMARSHALER,     StubHelpers,            AnsiCharMarshaler)
 DEFINE_METHOD(ANSICHARMARSHALER,    CONVERT_TO_NATIVE,      ConvertToNative,            SM_Char_Bool_Bool_RetByte)
 DEFINE_METHOD(ANSICHARMARSHALER,    CONVERT_TO_MANAGED,     ConvertToManaged,           SM_Byte_RetChar)
@@ -2191,28 +1777,6 @@ DEFINE_FIELD_U(_Kind,               ContractExceptionObject,    _Kind)
 DEFINE_FIELD_U(_UserMessage,        ContractExceptionObject,    _UserMessage)
 DEFINE_FIELD_U(_Condition,          ContractExceptionObject,    _Condition)
 
-// The COM interfaces for the reflection types.
-#if defined(FEATURE_COMINTEROP) && !defined(FEATURE_CORECLR)
-DEFINE_CLASS(IAPPDOMAIN,        System,              _AppDomain)
-DEFINE_CLASS(ITYPE,             InteropServices,     _Type)
-DEFINE_CLASS(IASSEMBLY,         InteropServices,     _Assembly)
-DEFINE_CLASS(IMEMBERINFO,       InteropServices,     _MemberInfo)
-DEFINE_CLASS(IMETHODBASE,       InteropServices,     _MethodBase)
-DEFINE_CLASS(IMETHODINFO,       InteropServices,     _MethodInfo)
-DEFINE_CLASS(ICONSTRUCTORINFO,  InteropServices,     _ConstructorInfo)
-DEFINE_CLASS(IFIELDINFO,        InteropServices,     _FieldInfo)
-DEFINE_CLASS(IPROPERTYINFO,     InteropServices,     _PropertyInfo)
-DEFINE_CLASS(IEVENTINFO,        InteropServices,     _EventInfo)
-DEFINE_CLASS(IPARAMETERINFO,    InteropServices,     _ParameterInfo)
-DEFINE_CLASS(IMODULE,           InteropServices,     _Module)
-#endif // FEATURE_COMINTEROP && !FEATURE_CORECLR
-
-#ifdef FEATURE_COMPRESSEDSTACK
-DEFINE_CLASS_U(Security,           FrameSecurityDescriptorWithResolver, FrameSecurityDescriptorWithResolverBaseObject)
-DEFINE_FIELD_U(m_resolver,         FrameSecurityDescriptorWithResolverBaseObject,  m_resolver)
-DEFINE_CLASS(FRAME_SECURITY_DESCRIPTOR_WITH_RESOLVER, Security, FrameSecurityDescriptorWithResolver)
-#endif // FEATURE_COMPRESSEDSTACK
-
 #ifdef FEATURE_COMINTEROP
 DEFINE_CLASS(ASYNC_TRACING_EVENT_ARGS,       WindowsFoundationDiag,         TracingStatusChangedEventArgs)
 DEFINE_CLASS(IASYNC_TRACING_EVENT_ARGS,      WindowsFoundationDiag,         ITracingStatusChangedEventArgs)
diff --git a/src/vm/mtypes.h b/src/vm/mtypes.h
index 603409b3dc..1a14760372 100644
--- a/src/vm/mtypes.h
+++ b/src/vm/mtypes.h
@@ -56,11 +56,11 @@ DEFINE_MARSHALER_TYPE(MARSHAL_TYPE_LPWSTR_BUFFER,   WSTRBufferMarshaler,
 DEFINE_MARSHALER_TYPE(MARSHAL_TYPE_LPSTR_BUFFER,    CSTRBufferMarshaler,                 false)
 DEFINE_MARSHALER_TYPE(MARSHAL_TYPE_UTF8_BUFFER,     UTF8BufferMarshaler,                 false)
 
-#if defined(FEATURE_COMINTEROP) || !defined(FEATURE_CORECLR)
+#if defined(FEATURE_COMINTEROP)
 // CoreCLR doesn't have any support for marshalling interface pointers.
 // Not even support for fake CCWs.
 DEFINE_MARSHALER_TYPE(MARSHAL_TYPE_INTERFACE,       InterfaceMarshaler,                  true)
-#endif // defined(FEATURE_COMINTEROP) || !defined(FEATURE_CORECLR)
+#endif // defined(FEATURE_COMINTEROP) 
 
 #ifdef FEATURE_COMINTEROP
 DEFINE_MARSHALER_TYPE(MARSHAL_TYPE_SAFEARRAY,       SafeArrayMarshaler,                  false)
@@ -89,9 +89,6 @@ DEFINE_MARSHALER_TYPE(MARSHAL_TYPE_VALUECLASS,                      ValueClassMa
 DEFINE_MARSHALER_TYPE(MARSHAL_TYPE_REFERENCECUSTOMMARSHALER,        ReferenceCustomMarshaler,      false)
 DEFINE_MARSHALER_TYPE(MARSHAL_TYPE_ARGITERATOR,                     ArgIteratorMarshaler,          false)
 
-#ifndef FEATURE_CORECLR
-DEFINE_MARSHALER_TYPE(MARSHAL_TYPE_BLITTABLEVALUECLASSWITHCOPYCTOR, BlittableValueClassWithCopyCtorMarshaler, false)
-#endif // !FEATURE_CORECLR
 
 #ifdef FEATURE_COMINTEROP
 DEFINE_MARSHALER_TYPE(MARSHAL_TYPE_OBJECT,                          ObjectMarshaler,               false)
diff --git a/src/vm/multicorejit.cpp b/src/vm/multicorejit.cpp
index 7660fd1895..4ad5447950 100644
--- a/src/vm/multicorejit.cpp
+++ b/src/vm/multicorejit.cpp
@@ -33,49 +33,6 @@
 
 const wchar_t * AppxProfile    = W("Application.Profile");
 
-#if defined(FEATURE_APPX_BINDER)
-
-//static 
-bool MulticoreJitManager::IsLoadOkay(Module * pModule)
-{
-    CONTRACTL
-    {
-        THROWS;
-        SO_INTOLERANT;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    if (pModule->GetAssembly()->GetManifestFile()->IsWindowsRuntime())
-    {
-        PEFile * pFile = pModule->GetFile();
-    
-        ICLRPrivAssembly * pHostAsm = pFile->GetHostAssembly();
-
-        // Allow first party WinMD to load in multicore JIT background thread
-        if (pHostAsm != NULL)
-        {
-            BOOL shared = FALSE;
-
-            if (SUCCEEDED(pHostAsm->IsShareable(& shared)))
-            {
-                if (shared)
-                {
-                    LPCUTF8 simpleName = pModule->GetSimpleName();
-
-                    if (IsWindowsNamespace(simpleName))
-                    {
-                        return true;
-                    }
-                }
-            }
-        }
-    }
-
-    return false;
-}
-
-#endif
 
 
 void MulticoreJitFireEtw(const wchar_t * pAction, const wchar_t * pTarget, int p1, int p2, int p3)
@@ -327,14 +284,6 @@ bool ModuleVersion::GetModuleVersion(Module * pModule)
         }
 
         // If the load context is LOADFROM, store it in the flags.
-#ifdef FEATURE_FUSION
-        Assembly * pAssembly = pModule->GetAssembly();
-        LOADCTX_TYPE loadCtx = pAssembly->GetManifestFile()->GetLoadContext();
-        if(LOADCTX_TYPE_LOADFROM == loadCtx)
-        {
-            versionFlags |= VERSIONFLAG_LOADCTX_LOADFROM;
-        }
-#endif
     }
     EX_CATCH
     {
@@ -356,12 +305,8 @@ ModuleRecord::ModuleRecord(unsigned lenName, unsigned lenAsmName)
     wLoadLevel = 0;
     // Extra data
     lenModuleName = (unsigned short) lenName;
-#if defined(FEATURE_CORECLR)
     lenAssemblyName = (unsigned short) lenAsmName;
     recordID += RoundUp(lenModuleName) + RoundUp(lenAssemblyName);
-#else
-    recordID += RoundUp(lenModuleName);
-#endif
 }
 
 
@@ -375,7 +320,6 @@ bool RecorderModuleInfo::SetModule(Module * pMod)
     unsigned lenModuleName = (unsigned) strlen(pModuleName);
     simpleName.Set((const BYTE *) pModuleName, lenModuleName); // SBuffer::Set copies over name
 
-#if defined(FEATURE_CORECLR)
     SString sAssemblyName;
     StackScratchBuffer scratch;
     pMod->GetAssembly()->GetManifestFile()->GetDisplayName(sAssemblyName);
@@ -383,17 +327,7 @@ bool RecorderModuleInfo::SetModule(Module * pMod)
     LPCUTF8 pAssemblyName = sAssemblyName.GetUTF8(scratch);
     unsigned lenAssemblyName = sAssemblyName.GetCount();
     assemblyName.Set((const BYTE *) pAssemblyName, lenAssemblyName);
-#endif
-
-#if defined(FEATURE_APPX_BINDER)
-
-    // Allow certain modules to load on background thread
-    if (AppX::IsAppXProcess() && MulticoreJitManager::IsLoadOkay(pMod))
-    {
-        flags |= FLAG_LOADOKAY;
-    }
 
-#endif
 
     return  moduleVersion.GetModuleVersion(pMod);
 }
@@ -422,12 +356,8 @@ HRESULT MulticoreJitRecorder::WriteModuleRecord(IStream * pStream, const Recorde
     const void * pModuleName = module.simpleName;
     unsigned lenModuleName = module.simpleName.GetSize();
 
-#if defined(FEATURE_CORECLR)
     const void * pAssemblyName = module.assemblyName;
     unsigned lenAssemblyName = module.assemblyName.GetSize();
-#else
-    unsigned lenAssemblyName = 0;
-#endif
 
     ModuleRecord mod(lenModuleName, lenAssemblyName);
     
@@ -442,12 +372,10 @@ HRESULT MulticoreJitRecorder::WriteModuleRecord(IStream * pStream, const Recorde
     {
         hr = WriteString(pModuleName, lenModuleName, pStream);
 
-#if defined(FEATURE_CORECLR)
         if (SUCCEEDED(hr))
         {
             hr = WriteString(pAssemblyName, lenAssemblyName, pStream);
         }
-#endif
     }
 
     return hr;
@@ -719,9 +647,6 @@ HRESULT MulticoreJitModuleEnumerator::EnumerateLoadedModules(AppDomain * pDomain
 
     while (appIt.Next(pDomainAssembly.This()) && SUCCEEDED(hr))
     {
-#if !defined(FEATURE_CORECLR)
-        if (! pDomainAssembly->IsSystem())
-#endif
         {
             hr = HandleAssembly(pDomainAssembly);
         }
@@ -731,60 +656,6 @@ HRESULT MulticoreJitModuleEnumerator::EnumerateLoadedModules(AppDomain * pDomain
 }
 
 
-#if defined(FEATURE_APPX_BINDER)
-// ProfileName = ProcessName_CoreAppId.Profile   ; for server process, always use it for output
-//               ProcessName.Profile
-
-void AppendAppxProfileName(SString & name)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-    } CONTRACTL_END;
-
-    {
-        WCHAR wszProcessName[_MAX_PATH];
-
-        if (WszGetModuleFileName(NULL, wszProcessName, _MAX_PATH) != 0)
-        {
-            WCHAR * pNameOnly = wcsrchr(wszProcessName, W('\\'));
-     
-            if (pNameOnly == NULL)
-            {
-                pNameOnly = wszProcessName;
-            }
-            else
-            {
-                pNameOnly ++;
-            }
-
-            WCHAR * pExt = wcsrchr(pNameOnly, W('.')); // last .
-
-            if (pExt != NULL)
-            {
-                * pExt = 0;
-            }
-
-            // Use process name only
-            name.Append(pNameOnly);
-            name.Append(W("_"));
-        }
-    }
-
-    LPCWSTR pAppId = NULL;
-    if (SUCCEEDED(AppX::GetApplicationId(pAppId)))
-    {
-        name.Append(pAppId);
-        name.Append(W(".Profile"));
-
-        return;
-    }
-
-    // default name
-    name.Append(AppxProfile);
-}
-#endif
 
 // static: single instace within a process
 
@@ -811,25 +682,6 @@ MulticoreJitRecorder::WriteMulticoreJitProfiler(PTP_CALLBACK_INSTANCE pInstance,
 
     if (pRecorder != NULL)
     {
-#if defined(FEATURE_APPX_BINDER)
-        if (pRecorder->m_fAppxMode)
-        {
-            const wchar_t * pOutputDir = NULL;
-
-            HRESULT hr = Clr::Util::GetLocalAppDataDirectory(&pOutputDir);
-
-            if (SUCCEEDED(hr))
-            {
-                pRecorder->m_fullFileName = pOutputDir;
-                pRecorder->m_fullFileName.Append(W("\\"));
-
-                AppendAppxProfileName(pRecorder->m_fullFileName);
-
-                pRecorder->StopProfile(false);
-            }
-        }
-        else
-#endif
         {
             pRecorder->StopProfile(false);
         }
@@ -854,9 +706,6 @@ void MulticoreJitRecorder::PreRecordFirstMethod()
 
     // When running under Appx or CoreCLR for K, AppDomain is normally not shut down properly (CLR in hybrid case, or Alt-F4 shutdown), 
     // So we only allow writing out after profileWriteTimeout seconds
-#if !defined(FEATURE_CORECLR)
-    if (m_fAppxMode)
-#endif
     {
         // Get the timeout in seconds.
         int profileWriteTimeout = (int)CLRConfig::GetConfigValue(CLRConfig::INTERNAL_MultiCoreJitProfileWriteDelay);
@@ -1061,11 +910,7 @@ HRESULT MulticoreJitRecorder::StartProfile(const wchar_t * pRoot, const wchar_t
 
         NewHolder<MulticoreJitProfilePlayer> player(new (nothrow) MulticoreJitProfilePlayer(
             m_pDomain,
-#if defined(FEATURE_CORECLR)
             m_pBinderContext,
-#else
-            NULL,
-#endif
             nSession,
             m_fAppxMode));
 
@@ -1235,11 +1080,7 @@ void MulticoreJitManager::StartProfile(AppDomain * pDomain, ICLRPrivBinder *pBin
     {
         MulticoreJitRecorder * pRecorder = new (nothrow) MulticoreJitRecorder(
             pDomain,
-#if defined(FEATURE_CORECLR)
             pBinderContext,
-#else
-            NULL,
-#endif
             m_fAppxMode);
 
         if (pRecorder != NULL)
@@ -1386,48 +1227,6 @@ void MulticoreJitManager::AutoStartProfile(AppDomain * pDomain)
     }
 }
 
-#if defined(FEATURE_APPX_BINDER)
-
-// Called from CorHost2::ExecuteMain
-void MulticoreJitManager::AutoStartProfileAppx(AppDomain * pDomain)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_PREEMPTIVE;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    if (InterlockedCompareExchange(& m_fAutoStartCalled, SETPROFILEROOTCALLED, 0) == 0) // Only allow the first call
-    {
-        WCHAR wzFilePath[_MAX_PATH];
-
-        UINT32 cchFilePath = NumItems(wzFilePath);
-
-        SString profileName;
-
-        // Try to find ProcessName_AppId.Profile
-        AppendAppxProfileName(profileName);
-
-        // Search for Application.Profile within the package
-        HRESULT hr = AppX::FindFileInCurrentPackage(profileName, &cchFilePath, wzFilePath);
-
-        if (SUCCEEDED(hr))
-        {
-            m_fAppxMode = true;
-            SetProfileRoot(pDomain, W("")); // Fake a SetProfileRoot call
-            StartProfile(pDomain, NULL, wzFilePath);
-        }
-        else
-        {
-            _FireEtwMulticoreJit(W("AUTOSTARTPROFILEAPPX"), profileName, hr, 0, 0);
-        }
-    }
-}
-
-#endif
 
 // Constructor
 
@@ -1473,17 +1272,6 @@ void MulticoreJitManager::RecordModuleLoad(Module * pModule, FileLoadLevel loadL
     STANDARD_VM_CONTRACT;
 
 
-#if defined(FEATURE_APPX_BINDER) && !defined(FEATURE_CORECLR)
-    // When running under Appx, allow framework assembly / first party winmd to load
-    // load-level change not allowed in the background thread, unless for resource DLL (loaded for exception throwing), but this could still happen.
-    _ASSERTE(! GetThread()->HasThreadStateNC(Thread::TSNC_CallingManagedCodeDisabled) || ModuleHasNoCode(pModule)
-             || m_fAppxMode && IsLoadOkay(pModule));
-
-#elif !defined(FEATURE_CORECLR)
-
-    _ASSERTE(! GetThread()->HasThreadStateNC(Thread::TSNC_CallingManagedCodeDisabled) || ModuleHasNoCode(pModule));
-
-#endif
 
     if (m_fRecorderActive)
     {
diff --git a/src/vm/multicorejit.h b/src/vm/multicorejit.h
index 19458944bb..b7a0951ee1 100644
--- a/src/vm/multicorejit.h
+++ b/src/vm/multicorejit.h
@@ -200,12 +200,6 @@ public:
         return m_fSetProfileRootCalled == 0;
     }
 
-#if defined(FEATURE_APPX_BINDER)
-
-    // Check for file appx.prof to automatically start multicore JIT
-    void AutoStartProfileAppx(AppDomain * pDomain);
-
-#endif
 
     // Check for environment variable to automatically start multicore JIT
     void AutoStartProfile(AppDomain * pDomain);
@@ -255,11 +249,6 @@ public:
 
     static bool ModuleHasNoCode(Module * pModule);
 
-#if defined(FEATURE_APPX_BINDER)
-
-    static bool IsLoadOkay(Module * pModule);
-
-#endif
 
 };
 
diff --git a/src/vm/multicorejitimpl.h b/src/vm/multicorejitimpl.h
index 58a9df7827..9d20adceef 100644
--- a/src/vm/multicorejitimpl.h
+++ b/src/vm/multicorejitimpl.h
@@ -179,9 +179,7 @@ public:
     unsigned short flags;
     unsigned short wLoadLevel;
     unsigned short lenModuleName;
-#if defined(FEATURE_CORECLR)
     unsigned short lenAssemblyName;
-#endif
 
     ModuleRecord(unsigned lenName = 0, unsigned lenAssemblyName = 0);
 
@@ -201,7 +199,6 @@ public:
         return (const char *) (this + 1); // after this record
     }
 
-#if defined(FEATURE_CORECLR)
     unsigned AssemblyNameLen() const
     {
         LIMITED_METHOD_CONTRACT;
@@ -213,7 +210,6 @@ public:
     {
         return GetModuleName() + RoundUp(lenModuleName); // after the module name
     }
-#endif
 
     void SetLoadLevel(FileLoadLevel loadLevel)
     {
@@ -250,9 +246,7 @@ friend class MulticoreJitRecorder;
 
 private:
     ADID                               m_DomainID;
-#if defined(FEATURE_CORECLR)
     ICLRPrivBinder * m_pBinderContext;
-#endif
     LONG                               m_nMySession;
     unsigned                           m_nStartTime;
     BYTE                             * m_pFileBuffer;
@@ -300,9 +294,7 @@ private:
 
     HRESULT ReadCheckFile(const wchar_t * pFileName);
 
-#if defined(FEATURE_CORECLR)
     DomainAssembly * LoadAssembly(SString & assemblyName);
-#endif
 
 public:
 
@@ -344,9 +336,7 @@ class MulticoreJitRecorder
 {
 private:
     AppDomain               * m_pDomain;            // AutoStartProfile could be called from SystemDomain
-#if defined(FEATURE_CORECLR)
     ICLRPrivBinder * m_pBinderContext;
-#endif
     SString                   m_fullFileName;
     MulticoreJitPlayerStat  & m_stats;
 
@@ -393,9 +383,7 @@ public:
         LIMITED_METHOD_CONTRACT;
 
         m_pDomain           = pDomain;
-#if defined(FEATURE_CORECLR)
         m_pBinderContext    = pBinderContext;
-#endif
         m_JitInfoCount      = 0;
         m_ModuleCount       = 0;
         m_ModuleDepCount    = 0;
@@ -404,10 +392,6 @@ public:
         m_fAborted          = false;
         m_fAppxMode         = fAppxMode;
 
-#if defined(FEATURE_APPX_BINDER)
-
-        s_delayedWriteTimer = NULL;
-#endif
 
         m_stats.Clear();
     }
diff --git a/src/vm/multicorejitplayer.cpp b/src/vm/multicorejitplayer.cpp
index 7d13bbc462..69868578d9 100644
--- a/src/vm/multicorejitplayer.cpp
+++ b/src/vm/multicorejitplayer.cpp
@@ -373,9 +373,7 @@ MulticoreJitProfilePlayer::MulticoreJitProfilePlayer(AppDomain * pDomain, ICLRPr
     LIMITED_METHOD_CONTRACT;
 
     m_DomainID           = pDomain->GetId();
-#if defined(FEATURE_CORECLR)
     m_pBinderContext     = pBinderContext;
-#endif
     m_nMySession         = nSession;
     m_moduleCount        = 0;
     m_headerModuleCount  = 0;
@@ -464,12 +462,10 @@ bool MulticoreJitManager::IsSupportedModule(Module * pModule, bool fMethodJit, b
         return false;
     }
 
-#if defined(FEATURE_CORECLR)
     if (pFile->GetPath().IsEmpty()) // Ignore in-memory modules
     {
         return false;
     }
-#endif
 
 
     if (! fMethodJit)
@@ -482,29 +478,9 @@ bool MulticoreJitManager::IsSupportedModule(Module * pModule, bool fMethodJit, b
     
     Assembly * pAssembly = pModule->GetAssembly();
     
-#ifdef FEATURE_FUSION
-    
-    LOADCTX_TYPE context = pAssembly->GetManifestFile()->GetLoadContext();
-
-#if defined(FEATURE_APPX_BINDER)
-
-    if (fAppx)
-    {
-        if (context == LOADCTX_TYPE_HOSTED)
-        {
-            return true;
-        }
-    }
-
-#endif
-
-    return ((context == LOADCTX_TYPE_DEFAULT) || (context == LOADCTX_TYPE_LOADFROM));
-
-#else
 
     return true;
 
-#endif
 }
 
 
@@ -550,10 +526,8 @@ bool MulticoreJitProfilePlayer::CompileMethodDesc(Module * pModule, MethodDesc *
 
         m_stats.m_nTryCompiling ++;
 
-#if defined(FEATURE_CORECLR)
         // Reset the flag to allow managed code to be called in multicore JIT background thread from this routine
         ThreadStateNCStackHolder holder(-1, Thread::TSNC_CallingManagedCodeDisabled);
-#endif
 
         // MakeJitWorker calls back to MulticoreJitCodeStorage::StoreMethodCode under MethodDesc lock
         pMD->MakeJitWorker(& header, CORJIT_FLAGS(CORJIT_FLAGS::CORJIT_FLAG_MCJIT_BACKGROUND));
@@ -886,7 +860,6 @@ bool MulticoreJitProfilePlayer::HandleModuleDependency(unsigned jitInfo)
 
         PlayerModuleInfo & mod = m_pModules[moduleTo];
 
-#if defined(FEATURE_CORECLR)
         // Load the module if necessary.
         if (!mod.m_pModule)
         {
@@ -927,7 +900,6 @@ bool MulticoreJitProfilePlayer::HandleModuleDependency(unsigned jitInfo)
                 }
             }
         }
-#endif
 
         if (mod.UpdateNeedLevel((FileLoadLevel) level))
         {
@@ -941,7 +913,6 @@ bool MulticoreJitProfilePlayer::HandleModuleDependency(unsigned jitInfo)
     return true;
 }
 
-#if defined(FEATURE_CORECLR)
 DomainAssembly * MulticoreJitProfilePlayer::LoadAssembly(SString & assemblyName)
 {
     STANDARD_VM_CONTRACT;
@@ -992,7 +963,6 @@ DomainAssembly * MulticoreJitProfilePlayer::LoadAssembly(SString & assemblyName)
 
     return pDomainAssembly;
 }
-#endif
 
 
 inline bool MethodJifInfo(unsigned inst)
@@ -1052,17 +1022,6 @@ HRESULT MulticoreJitProfilePlayer::HandleMethodRecord(unsigned * buffer, int cou
                 }
                 else
                 {
-#if !defined(FEATURE_CORECLR)
-                    if (m_nBlockingCount != 0)
-                    {
-                        if (! GroupWaitForModuleLoad(m_stats.m_nTotalMethod + pos)) // wait for blocking modules
-                        { 
-                            goto Abort;
-                        }
-
-                        _ASSERTE(m_nBlockingCount == 0);
-                    }
-#endif
 
                     //  To reduce contention with foreground thread, walk backward within the group of methods Jittable methods, not broken apart by dependency
                     {
@@ -1093,11 +1052,7 @@ HRESULT MulticoreJitProfilePlayer::HandleMethodRecord(unsigned * buffer, int cou
 
                             PlayerModuleInfo & mod = m_pModules[inst >> 24];
 
-#if defined(FEATURE_CORECLR)
                             _ASSERTE(mod.IsModuleLoaded());
-#else
-                            _ASSERTE(mod.IsModuleLoaded() && ! mod.IsLowerLevel());
-#endif
 
                             if (mod.m_enableJit)
                             {
@@ -1313,9 +1268,7 @@ HRESULT MulticoreJitProfilePlayer::PlayProfile()
                 const ModuleRecord * pRec = (const ModuleRecord * ) pBuffer;
 
                 if (((unsigned)(pRec->lenModuleName
-#if defined(FEATURE_CORECLR)
                     + pRec->lenAssemblyName
-#endif
                     ) > (rcdLen - sizeof(ModuleRecord))) || 
                     (m_moduleCount >= m_headerModuleCount))
                 {
diff --git a/src/vm/namespace.h b/src/vm/namespace.h
index e679fb5fe4..824226b418 100644
--- a/src/vm/namespace.h
+++ b/src/vm/namespace.h
@@ -74,10 +74,6 @@
 
 #define g_WindowsFoundationDiagNS    "Windows.Foundation.Diagnostics"
 
-#if defined(FEATURE_CORRUPTING_EXCEPTIONS) || defined(FEATURE_EXCEPTION_NOTIFICATIONS)
 #define g_ExceptionServicesNS         g_RuntimeNS ".ExceptionServices"
-#endif // defined(FEATURE_CORRUPTING_EXCEPTION) || defined(FEATURE_EXCEPTION_NOTIFICATIONS)
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 #define g_LoaderNS         g_RuntimeNS ".Loader" 
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
diff --git a/src/vm/nativeoverlapped.cpp b/src/vm/nativeoverlapped.cpp
index d0afbb648a..1f622275c6 100644
--- a/src/vm/nativeoverlapped.cpp
+++ b/src/vm/nativeoverlapped.cpp
@@ -61,13 +61,6 @@ FCIMPL3(void, CheckVMForIOPacket, LPOVERLAPPED* lpOverlapped, DWORD* errorCode,
         // no user delegate to callback
         _ASSERTE((overlapped->m_iocbHelper == NULL) || !"This is benign, but should be optimized");
 
-#ifndef FEATURE_CORECLR
-        if (g_pAsyncFileStream_AsyncResultClass)
-        {
-            SetAsyncResultProperties(overlapped, *errorCode, *numBytes);
-        }
-        else
-#endif // !FEATURE_CORECLR
         {
             //We're not initialized yet, go back to the Vm, and process the packet there.
             ThreadpoolMgr::StoreOverlappedInfoInThread(pThread, *errorCode, *numBytes, key, *lpOverlapped);
diff --git a/src/vm/newcompressedstack.cpp b/src/vm/newcompressedstack.cpp
deleted file mode 100644
index 5957dc37f4..0000000000
--- a/src/vm/newcompressedstack.cpp
+++ /dev/null
@@ -1,1074 +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.
-// 
-
-
-// 
-
-#include "common.h"
-#ifdef FEATURE_COMPRESSEDSTACK
-
-#include "newcompressedstack.h"
-#include "security.h"
-#ifdef FEATURE_REMOTING
-#include "appdomainhelper.h"
-#endif
-#include "securitystackwalk.h"
-#include "appdomainstack.inl"
-#include "appdomain.inl"
-
-
-DomainCompressedStack::DomainCompressedStack(ADID domainID)
-:   m_DomainID(domainID),
-    m_ignoreAD(FALSE),
-    m_dwOverridesCount(0),
-    m_dwAssertCount(0),
-    m_Homogeneous(FALSE)
-{
-    WRAPPER_NO_CONTRACT;    
-}
-
-BOOL DomainCompressedStack::IsAssemblyPresent(ISharedSecurityDescriptor* ssd)
-{
-    CONTRACTL 
-    {
-        MODE_ANY;
-        GC_NOTRIGGER;
-        NOTHROW;
-    }CONTRACTL_END;
-
-
-    // Only checks the first level and does not recurse into compressed stacks
-    void* pEntry = NULL;
-
-    if (m_EntryList.GetCount() == 0)
-        return FALSE;
-    
-    // Quick check the last entry we added - common case
-    pEntry = m_EntryList.Get(m_EntryList.GetCount() - 1);
-    if (pEntry == (void *)SET_LOW_BIT(ssd))
-        return TRUE;
-
-    // Go thru the whole list now - is this optimal?
-    ArrayList::Iterator iter = m_EntryList.Iterate();
-
-    while (iter.Next())
-    {
-        pEntry = iter.GetElement();
-        if (pEntry == (void *)SET_LOW_BIT(ssd))
-            return TRUE;
-    }
-    return FALSE;
-}    
-
-void DomainCompressedStack::AddEntry(void * ptr)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    IfFailThrow(m_EntryList.Append(ptr));
-    
-}
-VOID FrameSecurityDescriptorCopyFrom(FRAMESECDESCREF newFsdRef, FRAMESECDESCREF fsd)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-    newFsdRef->SetImperativeAssertions(fsd->GetImperativeAssertions());
-    newFsdRef->SetImperativeDenials(fsd->GetImperativeDenials());
-    newFsdRef->SetImperativeRestrictions(fsd->GetImperativeRestrictions());
-    newFsdRef->SetDeclarativeAssertions(fsd->GetDeclarativeAssertions());
-    newFsdRef->SetDeclarativeDenials(fsd->GetDeclarativeDenials());
-    newFsdRef->SetDeclarativeRestrictions(fsd->GetDeclarativeRestrictions());
-    newFsdRef->SetAssertAllPossible(fsd->HasAssertAllPossible());
-    newFsdRef->SetAssertFT(fsd->HasAssertFT()); 
-}
-
-void DomainCompressedStack::AddFrameEntry(AppDomain *pAppDomain, FRAMESECDESCREF fsdRef, BOOL bIsAHDMFrame, OBJECTREF dynamicResolverRef)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-
-    ENTER_DOMAIN_PTR(pAppDomain,ADV_RUNNINGIN) //have it on the stack
-    {
-        struct gc
-        {
-            OBJECTREF fsdRef;
-            OBJECTREF newFsdRef;
-            OBJECTREF dynamicResolverRef;
-        } gc;
-        ZeroMemory( &gc, sizeof( gc ) );
-        gc.fsdRef = (OBJECTREF)fsdRef;
-        gc.dynamicResolverRef = dynamicResolverRef;
-        
-        GCPROTECT_BEGIN(gc);
-
-        static MethodTable* pMethFrameSecDesc = NULL;
-        if (pMethFrameSecDesc == NULL)
-            pMethFrameSecDesc = MscorlibBinder::GetClass(CLASS__FRAME_SECURITY_DESCRIPTOR);
-
-        static MethodTable* pMethFrameSecDescWCS = NULL;
-        if (pMethFrameSecDescWCS == NULL)
-            pMethFrameSecDescWCS = MscorlibBinder::GetClass(CLASS__FRAME_SECURITY_DESCRIPTOR_WITH_RESOLVER);
-
-        if(!bIsAHDMFrame)
-        {
-            gc.newFsdRef = AllocateObject(pMethFrameSecDesc);
-        }
-        else
-        {
-            gc.newFsdRef = AllocateObject(pMethFrameSecDescWCS);
-        }
-
-        // We will not call the ctor and instead patch up the object based on the fsdRef passed in
-        FRAMESECDESCREF newFsdRef = (FRAMESECDESCREF)gc.newFsdRef;
-        FRAMESECDESCREF fsdRef1 = (FRAMESECDESCREF)gc.fsdRef;
-        if(fsdRef1 != NULL)
-        {
-            FrameSecurityDescriptorCopyFrom(newFsdRef, fsdRef1);
-        }
-        if(bIsAHDMFrame)
-        {
-            _ASSERTE(gc.dynamicResolverRef != NULL);
-            ((FRAMESECDESWITHRESOLVERCREF)newFsdRef)->SetDynamicMethodResolver(gc.dynamicResolverRef);
-        }
-        OBJECTHANDLEHolder  tmpHnd(pAppDomain->CreateHandle(gc.newFsdRef)); 
-    
-        AddEntry((void*)tmpHnd);
-        tmpHnd.SuppressRelease();
-        GCPROTECT_END();
-    
-    }
-    END_DOMAIN_TRANSITION;
-
-}
-
-
-void DomainCompressedStack::Destroy(void)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    // Clear Domain info (handles etc.) if the AD has not been unloaded.
-    ClearDomainInfo();
-    return;
-}
-
-FCIMPL1(DWORD, DomainCompressedStack::GetDescCount, DomainCompressedStack* dcs)
-{
-    FCALL_CONTRACT;
-
-    FCUnique(0x42);
-
-    return dcs->m_EntryList.GetCount();
-}
-FCIMPLEND
-
-FCIMPL3(void, DomainCompressedStack::GetDomainPermissionSets, DomainCompressedStack* dcs, OBJECTREF* ppGranted, OBJECTREF* ppDenied)
-{
-    FCALL_CONTRACT;
-
-    HELPER_METHOD_FRAME_BEGIN_0();
-
-    *ppGranted = NULL;
-    *ppDenied  = NULL;
-
-    AppDomain* appDomain = SystemDomain::GetAppDomainFromId(dcs->GetMyDomain(),ADV_RUNNINGIN);
-    if (appDomain == NULL)
-    {
-        // this might be the unloading AD
-        AppDomain *pUnloadingDomain = SystemDomain::System()->AppDomainBeingUnloaded();
-        if (pUnloadingDomain && pUnloadingDomain->GetId() == dcs->m_DomainID)
-        {
-#ifdef _DEBUG
-            CheckADValidity(pUnloadingDomain, ADV_RUNNINGIN);
-#endif
-            appDomain = pUnloadingDomain;
-        }
-    }
-    _ASSERTE(appDomain != NULL);
-    if (appDomain != NULL)
-    {
-        IApplicationSecurityDescriptor * pAppSecDesc = appDomain->GetSecurityDescriptor();
-        _ASSERTE(pAppSecDesc != NULL);
-        if (pAppSecDesc != NULL)
-        {
-            *ppGranted = pAppSecDesc->GetGrantedPermissionSet(ppDenied);
-        }
-    }
-
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-    
-FCIMPL6(FC_BOOL_RET, DomainCompressedStack::GetDescriptorInfo, DomainCompressedStack* dcs, DWORD index, OBJECTREF* ppGranted, OBJECTREF* ppDenied, OBJECTREF* ppAssembly, OBJECTREF* ppFSD)
-{
-    FCALL_CONTRACT;
-
-    _ASSERTE(dcs != NULL);
-    AppDomain* pCurrentDomain = GetAppDomain();
-    BOOL bRetVal = FALSE;
-
-    HELPER_METHOD_FRAME_BEGIN_RET_0()
-    *ppGranted = NULL;
-    *ppDenied  = NULL;
-    *ppAssembly = NULL;
-    *ppFSD = NULL;
-    void* pEntry = dcs->m_EntryList.Get(index);
-    _ASSERTE(pEntry != NULL);
-    if (IS_LOW_BIT_SET(pEntry))
-    {
-        // Assembly found
-        SharedSecurityDescriptor* pSharedSecDesc = (SharedSecurityDescriptor* )UNSET_LOW_BIT(pEntry);
-        Assembly* pAssembly = pSharedSecDesc->GetAssembly();
-        IAssemblySecurityDescriptor* pAsmSecDesc = pAssembly->GetSecurityDescriptor( pCurrentDomain );
-        *ppGranted = pAsmSecDesc->GetGrantedPermissionSet(ppDenied);
-        *ppAssembly = pAssembly->GetExposedObject();
-    }
-    else
-    {
-        //FSD
-        OBJECTHANDLE objHnd = (OBJECTHANDLE)pEntry;
-        if (objHnd == NULL)
-        {
-            // throw an ADUnloaded exception which we will catch and then look at the serializedBlob
-           COMPlusThrow(kAppDomainUnloadedException);
-        }
-        *ppFSD = ObjectFromHandle(objHnd);
-        bRetVal = TRUE;
-    }
-    HELPER_METHOD_FRAME_END();
-    
-    FC_RETURN_BOOL(bRetVal);
-}
-FCIMPLEND
-
-FCIMPL1(FC_BOOL_RET, DomainCompressedStack::IgnoreDomain, DomainCompressedStack* dcs)
-{
-    FCALL_CONTRACT;
-    
-    _ASSERTE(dcs != NULL);
-    
-    FC_RETURN_BOOL(dcs->IgnoreDomainInternal());
-}
-FCIMPLEND
-
-BOOL DomainCompressedStack::IgnoreDomainInternal()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_COOPERATIVE;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    if (m_ignoreAD)
-        return TRUE;
-
-    AppDomainFromIDHolder appDomain(GetMyDomain(), TRUE);
-    if (!appDomain.IsUnloaded())
-    {
-        IApplicationSecurityDescriptor *pAppSecDesc = appDomain->GetSecurityDescriptor();
-        _ASSERTE(pAppSecDesc != NULL);
-        if (pAppSecDesc != NULL)
-        {
-            return pAppSecDesc->IsDefaultAppDomain() || pAppSecDesc->IsInitializationInProgress();
-        }
-    }
-    
-    return FALSE;
-}
-
-
-/*
-    Note that this function is called only once: when the managed PLS is being created.
-    It's possible that 2 threads could race at that point: only downside of that is that they will both do the work. No races.
-    Also, we'll never be operating on a DCS whose domain is not on the current callstack. This eliminates all kinds of ADU/demand eval races.
-*/
-OBJECTREF DomainCompressedStack::GetDomainCompressedStackInternal(AppDomain *pDomain)
-{
-     CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-
-    // If  we are going to skip this AppDomain, and there is nothing to compress, then we can skip building the DCS.
-    if (m_EntryList.GetCount() == 0 && IgnoreDomainInternal())
-        return NULL;
-
-    AppDomain* pCurrentDomain = GetAppDomain();
-
-    NewArrayHolder<BYTE> pbtmpSerializedObject(NULL);
-#ifndef FEATURE_CORECLR
-    DWORD cbtmpSerializedObject = 0;
-#endif
-
-        struct gc
-        {
-            OBJECTREF refRetVal;
-        } gc;
-        ZeroMemory( &gc, sizeof( gc ) );
-        
-    GCPROTECT_BEGIN( gc );
-
-    // Create object
-    ENTER_DOMAIN_ID (GetMyDomain()) //on the stack
-    {
-
-        // Go ahead and create the object
-#ifdef FEATURE_CORECLR // ignore other appdomains
-        if (GetAppDomain() == pCurrentDomain)
-#endif        
-        {
-        MethodDescCallSite createManagedObject(METHOD__DOMAIN_COMPRESSED_STACK__CREATE_MANAGED_OBJECT);
-        ARG_SLOT args[] = {PtrToArgSlot(this)};
-        gc.refRetVal = createManagedObject.Call_RetOBJECTREF(args);
-        }
-
-#ifndef FEATURE_CORECLR 
-                // Do we want to marshal this object also?
-        if (GetAppDomain() != pCurrentDomain)
-        {
-                    // Serialize to a blob;
-                    AppDomainHelper::MarshalObject(GetAppDomain(), &gc.refRetVal, &pbtmpSerializedObject, &cbtmpSerializedObject);
-            if (pbtmpSerializedObject == NULL)
-            {
-                // this is an error: possibly an OOM prevented the blob from getting created.
-                // We could return null and let the managed code use a fully restricted object or throw here.
-                // Let's throw here...
-                COMPlusThrow(kSecurityException);
-            }
-        }
-#endif
-                    
-    }
-    END_DOMAIN_TRANSITION
-
-#ifndef FEATURE_CORECLR // should never happen for core clr
-    if (GetMyDomain() != pCurrentDomain->GetId())
-    {
-        AppDomainHelper::UnmarshalObject(pCurrentDomain,pbtmpSerializedObject, cbtmpSerializedObject, &gc.refRetVal);
-    }
-#endif
-
-    GCPROTECT_END();
-   
-    return gc.refRetVal;
-}
-
-
-void DomainCompressedStack::ClearDomainInfo(void)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-
-    // So, assume mutual exclusion holds and no races occur here
-
-
-    // Now it is time to go NULL out any ObjectHandle we're using in the list of entries
-    ArrayList::Iterator iter = m_EntryList.Iterate();
-
-    while (iter.Next())
-    {
-        void* pEntry = iter.GetElement();
-        if (!IS_LOW_BIT_SET(pEntry))
-        {
-            DestroyHandle((OBJECTHANDLE)pEntry);
-        }
-        pEntry = NULL;         
-    }
-
-
-    // Always clear the index into the domain object list and the domainID.
-    m_DomainID = ADID(INVALID_APPDOMAIN_ID);    
-    return;
-}
-
-NewCompressedStack::NewCompressedStack()
-:     m_DCSListCount(0),
-      m_currentDCS(NULL),
-      m_pCtxTxFrame(NULL),
-      m_CSAD(ADID(INVALID_APPDOMAIN_ID)),      
-      m_ADStack(GetThread()->GetAppDomainStack()),
-      m_dwOverridesCount(0),
-      m_dwAssertCount(0)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    _ASSERTE(m_ADStack.GetNumDomains() > 0);
-    m_ADStack.InitDomainIteration(&adStackIndex);
-    m_DCSList = new DomainCompressedStack*[m_ADStack.GetNumDomains()];
-    memset(m_DCSList, 0, (m_ADStack.GetNumDomains()*sizeof(DomainCompressedStack*)));
-    
-}
-
-
-void NewCompressedStack::Destroy( CLR_BOOL bEntriesOnly )
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-    
-    if (m_DCSList != NULL)
-    {
-        m_currentDCS = NULL;
-        m_pCtxTxFrame = NULL;
-        for (DWORD i=0; i< m_ADStack.GetNumDomains(); i++)
-        {
-            DomainCompressedStack* dcs = m_DCSList[i];
-            if (dcs != NULL)
-            {
-                dcs->Destroy();
-                delete dcs;
-            }
-        }
-        delete[] m_DCSList;
-        m_DCSList = NULL;
-    }
-    if (!bEntriesOnly)
-        delete this;
-
-}
-
-
-void NewCompressedStack::ProcessAppDomainTransition(void)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    // Get the current adstack entry. Note that the first time we enter this function, adStackIndex will 
-    // equal the size of the adstack array (similar to what happens in IEnumerator).
-    // So the initial pEntry will be NULL
-    AppDomainStackEntry *pEntry = 
-        (adStackIndex == m_ADStack.GetNumDomains() ? NULL : m_ADStack.GetCurrentDomainEntryOnStack(adStackIndex));
-
-    // Updated the value on the ADStack for current domain
-    if (pEntry != NULL)
-    {
-        DWORD domainOverrides_measured = (m_currentDCS == NULL?0:m_currentDCS->GetOverridesCount());
-        DWORD domainAsserts_measured = (m_currentDCS == NULL?0:m_currentDCS->GetAssertCount());
-        if (pEntry->m_dwOverridesCount != domainOverrides_measured || pEntry->m_dwAsserts != domainAsserts_measured)
-        {
-            m_ADStack.UpdateDomainOnStack(adStackIndex, domainAsserts_measured, domainOverrides_measured);
-            GetThread()->UpdateDomainOnStack(adStackIndex, domainAsserts_measured, domainOverrides_measured);
-        }
-    }
-
-    // Move the domain index forward if this is not the last entry
-    if (adStackIndex > 0)
-    m_ADStack.GetNextDomainEntryOnStack(&adStackIndex);
-    m_currentDCS = NULL;
-
-    return;
-    
-}
-DWORD NewCompressedStack::ProcessFrame(AppDomain* pAppDomain, Assembly* pAssembly, MethodDesc* pFunc, ISharedSecurityDescriptor* pSsd, FRAMESECDESCREF* pFsdRef)
-{
-    // This function will be called each time we hit a new stack frame in a stack walk.
-
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(CheckPointer(pAppDomain));
-        PRECONDITION(CheckPointer(pSsd));
-    } CONTRACTL_END;
-
-    // Get the current adstack entry. Note that the first time we enter this function, adStackIndex will 
-    // equal the size of the adstack array (similar to what happens in IEnumerator).
-    // So the initial pEntry will be NULL
-    AppDomainStackEntry *pEntry = 
-        (adStackIndex == m_ADStack.GetNumDomains() ? NULL : m_ADStack.GetCurrentDomainEntryOnStack(adStackIndex));
-
-
-    _ASSERTE(pEntry != NULL);
-    PREFIX_ASSUME(pEntry != NULL);
-    FRAMESECDESCREF FsdRef = (pFsdRef!=NULL?*pFsdRef:NULL);
-    DWORD dwFlags = 0;
-    if (FsdRef != NULL)
-    {
-            
-        if (FsdRef->HasAssertFT())
-            dwFlags |= CORSEC_FT_ASSERT;
-    }
-
-    BOOL bIsAHDMFrame = FALSE;
-    
-    if((pFunc != NULL) && !CLRConfig::GetConfigValue(CLRConfig::UNSUPPORTED_Security_DisableAnonymouslyHostedDynamicMethodCreatorSecurityCheck))
-    {
-        ENTER_DOMAIN_PTR(pAppDomain, ADV_RUNNINGIN)
-        {
-            bIsAHDMFrame = SecurityStackWalk::MethodIsAnonymouslyHostedDynamicMethodWithCSToEvaluate(pFunc);
-        }
-        END_DOMAIN_TRANSITION;
-    }
-
-    if (!bIsAHDMFrame && ((pEntry->IsFullyTrustedWithNoStackModifiers()) ||
-        (m_currentDCS != NULL && m_currentDCS->m_Homogeneous)))
-    {
-        // Nothing to do in this entire AD. 
-        return dwFlags;
-    }
-    
-    ADID dNewDomainID = pAppDomain->GetId();
-    BOOL bAddSSD = (!pSsd->IsSystem() && !IsAssemblyPresent(dNewDomainID, pSsd));
-    BOOL bHasStackModifiers = FALSE;
-    DWORD overridesCount = 0;
-    DWORD assertCount = 0;
-
-    
-    if (FsdRef != NULL)
-    {
-        overridesCount += FsdRef->GetOverridesCount();
-        assertCount += FsdRef->GetAssertCount();
-    }
-
-    // If this is an AHDM frame with a CS to evaluate, it may have overrides or asserts,
-    // so treat it as if it does
-    if(bIsAHDMFrame)
-    {
-        overridesCount++;
-        assertCount++;
-    }
-
-    bHasStackModifiers = ( (assertCount + overridesCount) > 0);
-
-    //
-    // We need to add a new DCS if we don't already have one for this AppDomain.  If we've reached this
-    // point, either:
-    //   * the AppDomain is partially trusted
-    //   * the AppDomain is fully trusted, but may have stack modifiers in play
-    //   * we're running in legacy mode where FullTrust doesn't mean FullTrust
-    //   
-    // If the domain is partially trusted, we'll always need to capture it. If we got this far due to a
-    // fully trusted domain that might have stack modifiers, we only have to capture if there really were
-    // stack walk modifiers.  In the legacy mode case, we need to capture the domain if we had stack
-    // modifiers or we needed to add the shared security descriptor.
-    //
-
-    BOOL bCreateDCS = (m_currentDCS == NULL || m_currentDCS->m_DomainID != dNewDomainID);
-    if (pAppDomain->GetSecurityDescriptor()->IsFullyTrusted())
-    {
-        bCreateDCS &= (bAddSSD || bHasStackModifiers);
-    }
-
-    if (bCreateDCS)
-    {
-        CreateDCS(dNewDomainID);
-    }
-
-     // Add the ISharedSecurityDescriptor (Assembly) to the list if it is not already present in the list
-    if (bAddSSD)
-    {
-        m_currentDCS->AddEntry((void*)SET_LOW_BIT(pSsd));
-        if (pEntry->IsHomogeneousWithNoStackModifiers())
-            m_currentDCS->m_Homogeneous = TRUE;
-    }    
-    if (bHasStackModifiers)
-    {
-        OBJECTREF dynamicResolverRef = NULL;
-        if(bIsAHDMFrame)
-        {            
-            _ASSERTE(pFunc->IsLCGMethod());
-            dynamicResolverRef = pFunc->AsDynamicMethodDesc()->GetLCGMethodResolver()->GetManagedResolver();
-        }
-
-        // We need to add the FSD entry here 
-        m_currentDCS->AddFrameEntry(pAppDomain, FsdRef, bIsAHDMFrame, dynamicResolverRef);
-        m_currentDCS->m_dwOverridesCount += overridesCount;
-        m_currentDCS->m_dwAssertCount += assertCount;
-        m_dwOverridesCount += overridesCount;
-        m_dwAssertCount += assertCount;
-    }
-    return dwFlags;
-}
-
-// Build a CompressedStack given that all domains on the stack are homogeneous with no stack modifiers
-FCIMPL1(void, NewCompressedStack::FCallGetHomogeneousPLS, Object* hgPLSUnsafe)
-{
-    FCALL_CONTRACT;
-    
-    OBJECTREF refHomogeneousPLS = (OBJECTREF)hgPLSUnsafe;
-
-    HELPER_METHOD_FRAME_BEGIN_1(refHomogeneousPLS); 
-
-
-    // Walk the adstack and update the grantSetUnion
-    AppDomainStack* pADStack = GetThread()->GetAppDomainStackPointer();
-    DWORD dwAppDomainIndex;
-    pADStack->InitDomainIteration(&dwAppDomainIndex);
-
-#ifdef FEATURE_REMOTING // without remoting we need only current appdomain
-    while (dwAppDomainIndex != 0)
-#endif        
-    {
-        AppDomainStackEntry* pEntry = pADStack->GetNextDomainEntryOnStack(&dwAppDomainIndex);
-        _ASSERTE(pEntry != NULL);
-        
-        pEntry->UpdateHomogeneousPLS(&refHomogeneousPLS);
-    }
-    
-        
-    HELPER_METHOD_FRAME_END();
-    return ;
-}
-FCIMPLEND;
-
-// Special case of ProcessFrame called with the CS at the base of the thread
-void NewCompressedStack::ProcessCS(AppDomain* pAppDomain, COMPRESSEDSTACKREF csRef, Frame *pFrame)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(CheckPointer(pAppDomain));
-    } CONTRACTL_END;
-
-    _ASSERTE(csRef != NULL && "Shouldn't call this function if CS is NULL");
-    ADID dNewDomainID = pAppDomain->GetId();
-    NewCompressedStack* pCS = (NewCompressedStack* )csRef->GetUnmanagedCompressedStack();
-    if (csRef->IsEmptyPLS() && (pCS == NULL || pCS->GetDCSListCount() == 0))
-    {
-        // Do nothing - empty inner CS
-        return;
-    }
-
-    // Let's special case the 1-domain CS that has no inner CSs here
-    // Check for:
-    // 1. == 1 DCS 
-    // 2. DCS is in correct AD (it's possible that pCS is AD-X and it has only one DCS in AD-Y, because AD-X has only mscorlib frames
-    // 3. No inner CS
-    if ( pCS != NULL &&
-         pCS->GetDCSListCount() == 1 &&
-         pCS->m_DCSList != NULL &&
-         pCS->m_currentDCS != NULL &&
-         pCS->m_currentDCS->m_DomainID == dNewDomainID &&
-         pCS->m_CSAD == ADID(INVALID_APPDOMAIN_ID))
-    {
-        ProcessSingleDomainNCS(pCS, pAppDomain);
-    }
-    else
-    {
-
-        // set flag to ignore Domain grant set if the current DCS is the same as the one with the CS
-        if (m_currentDCS != NULL && m_currentDCS->m_DomainID == dNewDomainID)
-        {
-            m_currentDCS->m_ignoreAD = TRUE;
-        }
-
-        // Update overrides/asserts
-        if (pCS != NULL)
-        {
-            m_dwOverridesCount += pCS->GetOverridesCount();
-            m_dwAssertCount += pCS->GetAssertCount();
-        }
-        
-
-        // Do we need to store the CtxTransitionFrame or did we get the CS from the thread?
-        if (pFrame != NULL)
-        {
-            _ASSERTE(csRef == SecurityStackWalk::GetCSFromContextTransitionFrame(pFrame));
-            // Use data from the CtxTxFrame
-            m_pCtxTxFrame = pFrame;
-        }
-        m_CSAD = dNewDomainID;
-    }
-
-}
-void NewCompressedStack::ProcessSingleDomainNCS(NewCompressedStack *pCS, AppDomain* pAppDomain)
-{
-    
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(CheckPointer(pAppDomain));
-    } CONTRACTL_END;
-
-    _ASSERTE(pCS->GetDCSListCount() <= 1 && pCS->m_CSAD == ADID(INVALID_APPDOMAIN_ID));
-    ADID newDomainID = pAppDomain->GetId();
-    DomainCompressedStack* otherDCS = pCS->m_currentDCS;
-
-    if (otherDCS == NULL)
-        return;
-    if (m_currentDCS == NULL)
-        CreateDCS(newDomainID);
-
-
-    // Iterate thru the entryList in the current DCS
-    ArrayList::Iterator iter = otherDCS->m_EntryList.Iterate();
-    while (iter.Next())
-    {
-        void* pEntry = iter.GetElement();
-        if (IS_LOW_BIT_SET(pEntry))
-        {
-            if (!IsAssemblyPresent(newDomainID, (ISharedSecurityDescriptor*)UNSET_LOW_BIT(pEntry)))
-            {
-                //Add the assembly
-                m_currentDCS->AddEntry(pEntry);
-            }
-        }
-        else
-        {
-            // FrameSecurityDescriptor 
-            OBJECTHANDLE objHnd = (OBJECTHANDLE)pEntry;
-            OBJECTREF fsdRef = ObjectFromHandle(objHnd);
-            OBJECTHANDLEHolder  tmpHnd(pAppDomain->CreateHandle(fsdRef)); 
-
-            m_currentDCS->AddEntry((void*)tmpHnd);
-            tmpHnd.SuppressRelease();
-            
-        }
-            
-    }    
-
-    m_currentDCS->m_dwOverridesCount += pCS->m_dwOverridesCount;
-    m_currentDCS->m_dwAssertCount += pCS->m_dwAssertCount;
-    m_dwOverridesCount += pCS->m_dwOverridesCount;
-    m_dwAssertCount += pCS->m_dwAssertCount;    
-}
-void NewCompressedStack::CreateDCS(ADID domainID)
-{
-    CONTRACTL {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    } CONTRACTL_END;
-
-    _ASSERTE(adStackIndex < m_ADStack.GetNumDomains());
-    _ASSERTE (m_DCSList != NULL);
-    m_DCSList[adStackIndex] = new DomainCompressedStack(domainID);
-    m_currentDCS = m_DCSList[adStackIndex];
-    m_DCSListCount++;
-
-    return;
-}
-
-
-BOOL NewCompressedStack::IsAssemblyPresent(ADID domainID, ISharedSecurityDescriptor* pSsd)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    _ASSERTE(domainID != ADID(INVALID_APPDOMAIN_ID) && "Don't pass invalid domain");
-
-    BOOL bEntryPresent = FALSE;
-    
-    for(DWORD i=0; i < m_ADStack.GetNumDomains(); i++)
-    {
-
-        DomainCompressedStack* pTmpDCS = m_DCSList[i];
-        
-        if (pTmpDCS != NULL && pTmpDCS->m_DomainID == domainID && pTmpDCS->IsAssemblyPresent(pSsd))
-        {
-            bEntryPresent = TRUE;
-            break;
-        }
-    }
-    return bEntryPresent;
-}
-
-
-BOOL NewCompressedStack::IsDCSContained(DomainCompressedStack *pDCS)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    // return FALSE if no DCS or DCS is for a domain that has been unloaded
-    if (pDCS == NULL || pDCS->m_DomainID == ADID(INVALID_APPDOMAIN_ID))
-        return FALSE;
-    
-
-    
-    // Iterate thru the entryList in the current DCS
-    ArrayList::Iterator iter = pDCS->m_EntryList.Iterate();
-    while (iter.Next())
-    {
-        void* pEntry = iter.GetElement();
-        if (IS_LOW_BIT_SET(pEntry))
-        {
-            // We only check Assemblies.
-            if (!IsAssemblyPresent(pDCS->m_DomainID, (ISharedSecurityDescriptor*)UNSET_LOW_BIT(pEntry)))
-            return FALSE;
-        }    
-    }    
-    return TRUE;
-}
-
-BOOL NewCompressedStack::IsNCSContained(NewCompressedStack *pCS)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    // Check if the first level of pCS is contained in this.
-    if (pCS == NULL)
-        return TRUE;
-
-    // Return FALSE if there are any overrides or asserts
-    if (pCS->GetOverridesCount() > 0)
-        return FALSE;
-    // Return FALSE if there is an inner CS
-    if (pCS->m_CSAD != ADID(INVALID_APPDOMAIN_ID))
-        return FALSE;
-     
-     for(DWORD i=0; i < m_ADStack.GetNumDomains(); i++)
-     {
-         DomainCompressedStack *pDCS = (DomainCompressedStack *) m_DCSList[i];
-         if (!IsDCSContained(pDCS))
-            return FALSE;
-     }
-     return TRUE;
-     
-}
-
-
-// If there is a compressed stack present in the captured CompressedStack, return that CS in the current domain
-OBJECTREF NewCompressedStack::GetCompressedStackInner()
-{
-    _ASSERTE(m_CSAD != ADID(INVALID_APPDOMAIN_ID));
-
-    AppDomain* pCurrentDomain = GetAppDomain();
-    NewArrayHolder<BYTE> pbtmpSerializedObject(NULL);
-
-
-    OBJECTREF refRetVal = NULL;
-
-    if (pCurrentDomain->GetId()== m_CSAD)
-    {
-        // we're in the right domain already 
-        if (m_pCtxTxFrame == NULL)
-        {
-            // Get CS from the thread
-            refRetVal = GetThread()->GetCompressedStack();
-        }
-        else
-        {
-            // Get CS from a Ctx transition frame
-            refRetVal = (OBJECTREF)SecurityStackWalk::GetCSFromContextTransitionFrame(m_pCtxTxFrame);
-            _ASSERTE(refRetVal != NULL); //otherwise we would not have saved the frame in the CB data
-        }
-    }
-    else
-#ifndef FEATURE_CORECLR // should never happen for core clr        
-    {
-        DWORD cbtmpSerializedObject = 0;
-        GCPROTECT_BEGIN (refRetVal);          
-        // need to marshal the CS over into the current AD
-        ENTER_DOMAIN_ID(m_CSAD);
-        {
-            if (m_pCtxTxFrame == NULL)
-            {
-
-                // Get CS from the thread
-                refRetVal = GetThread()->GetCompressedStack();
-            }
-            else
-            {
-                // Get CS from a Ctx transition frame
-                refRetVal = (OBJECTREF)SecurityStackWalk::GetCSFromContextTransitionFrame(m_pCtxTxFrame);
-                _ASSERTE(refRetVal != NULL); //otherwise we would not have saved the frame in the CB data
-            }
-            AppDomainHelper::MarshalObject(GetAppDomain(), &refRetVal, &pbtmpSerializedObject, &cbtmpSerializedObject);
-        }
-        END_DOMAIN_TRANSITION
-        refRetVal = NULL;
-        AppDomainHelper::UnmarshalObject(pCurrentDomain,pbtmpSerializedObject, cbtmpSerializedObject, &refRetVal);
-        GCPROTECT_END ();
-        _ASSERTE(refRetVal != NULL); //otherwise we would not have saved the frame in the CB data
-    }
-#else 
-    {
-        UNREACHABLE();
-    }
-#endif // !FEATURE_CORECLR
-
-    return refRetVal;
-
-}
-
-// == Now begin the functions used in building Demand evaluation of a compressed stack
-FCIMPL1(DWORD, NewCompressedStack::FCallGetDCSCount, SafeHandle* hcsUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    DWORD dwRet = 0;
-    if (hcsUNSAFE != NULL)
-    {
-        SAFEHANDLE hcsSAFE = (SAFEHANDLE) hcsUNSAFE;
-
-        HELPER_METHOD_FRAME_BEGIN_RET_1(hcsSAFE);     
-
-        NewCompressedStack* ncs = (NewCompressedStack *)hcsSAFE->GetHandle();
-        
-        dwRet = ncs->m_ADStack.GetNumDomains();
-        HELPER_METHOD_FRAME_END();
-    }
-
-    return dwRet;
-    
-}
-FCIMPLEND
-
-
-FCIMPL2(FC_BOOL_RET, NewCompressedStack::FCallIsImmediateCompletionCandidate, SafeHandle* hcsUNSAFE, OBJECTREF *innerCS)
-{
-    FCALL_CONTRACT;
-
-    BOOL bRet = FALSE;
-    if (hcsUNSAFE != NULL)
-    {
-        SAFEHANDLE hcsSAFE = (SAFEHANDLE) hcsUNSAFE;
-
-        HELPER_METHOD_FRAME_BEGIN_RET_1(hcsSAFE); 
-
-        *innerCS = NULL;
-
-        NewCompressedStack* ncs = (NewCompressedStack *)hcsSAFE->GetHandle();
-
-        if (ncs != NULL)
-        {
-            // Non-FT case
-
-            // Is there an inner CS?
-            BOOL bHasCS = (ncs->m_CSAD != ADID(INVALID_APPDOMAIN_ID));
-
-            // Is there is a DCS not in the current AD
-            BOOL bHasOtherAppDomain = FALSE;
-            if (ncs->m_DCSList != NULL)
-            {
-                for(DWORD i=0; i < ncs->m_ADStack.GetNumDomains(); i++)
-                {
-                    DomainCompressedStack* dcs = ncs->m_DCSList[i];
-                    if (dcs != NULL && dcs->GetMyDomain() != GetAppDomain()->GetId())
-                    {
-                        bHasOtherAppDomain = TRUE;
-                        break;
-                    }
-                }
-            }
-            if (bHasCS)
-            {
-
-
-                *innerCS = ncs->GetCompressedStackInner();
-                ncs->m_pCtxTxFrame = NULL; // Clear the CtxTxFrame ASAP
-         
-            }
-            bRet = bHasOtherAppDomain||bHasCS;
-        }
-        
-        HELPER_METHOD_FRAME_END();
-    }
-    
-    FC_RETURN_BOOL(bRet);
-}
-FCIMPLEND
-
-
-FCIMPL2(Object*, NewCompressedStack::GetDomainCompressedStack, SafeHandle* hcsUNSAFE, DWORD index)
-{
-    FCALL_CONTRACT;
-
-    OBJECTREF refRetVal = NULL;
-    if (hcsUNSAFE != NULL)
-    {
-        SAFEHANDLE hcsSAFE = (SAFEHANDLE) hcsUNSAFE;
-
-        HELPER_METHOD_FRAME_BEGIN_RET_2(refRetVal, hcsSAFE); 
-
-
-
-        NewCompressedStack* ncs = (NewCompressedStack *)hcsSAFE->GetHandle();
-
-        // First we check to see if the DCS at index i has a blob. If so, deserialize it into the current AD and return it. Else try create it
-        DomainCompressedStack* dcs = ncs->m_DCSList[index];
-        if (dcs != NULL)
-        {
-            refRetVal = dcs->GetDomainCompressedStackInternal(NULL);
-        }
-        
-        HELPER_METHOD_FRAME_END();
-    }
-
-    return OBJECTREFToObject(refRetVal);
-   
-}
-FCIMPLEND
-
-FCIMPL1(void, NewCompressedStack::DestroyDCSList, SafeHandle* hcsUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    SAFEHANDLE hcsSAFE = (SAFEHANDLE) hcsUNSAFE;
-
-    HELPER_METHOD_FRAME_BEGIN_1(hcsSAFE); 
-
-    NewCompressedStack* ncs = (NewCompressedStack *)hcsSAFE->GetHandle();
-
-    ncs->Destroy(TRUE);
-
-    HELPER_METHOD_FRAME_END();
-
-}
-FCIMPLEND
-#endif // #ifdef FEATURE_COMPRESSEDSTACK    
diff --git a/src/vm/newcompressedstack.h b/src/vm/newcompressedstack.h
deleted file mode 100644
index e3a639353d..0000000000
--- a/src/vm/newcompressedstack.h
+++ /dev/null
@@ -1,197 +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.
-// 
-
-
-//
-
-#ifndef __newcompressedstack_h__
-#define __newcompressedstack_h__
-#ifdef FEATURE_COMPRESSEDSTACK
-
-#include "objectlist.h"
-// Returns true if the low bit in the ptr argument is set to 1
-#define IS_LOW_BIT_SET(ptr) (((UINT_PTR)ptr) & 1)
-// Sets the low bit in the ptr passed in
-#define SET_LOW_BIT(ptr) (((UINT_PTR)ptr)|1)
-// Reset the low bit to 0
-#define UNSET_LOW_BIT(ptr) (((UINT_PTR)ptr)& ~((size_t)1))
-
-class DomainCompressedStack;
-class NewCompressedStack;
-
-
-
-// This is the class that will contain an array of entries.
-// All the entries will be for a single AppDomain
-class DomainCompressedStack
-{
-    friend class NewCompressedStack;
-public:
-    ADID GetMyDomain()
-    {
-        // It is OK if m_DomainID gets set to -1 by ADU code and we return a valid AD.
-        // (what that means is that tmp_adid is not invalid, but m_DomainID is set to invalid by ADU code
-        // after we cached it)
-        // Two cases:
-        // 1. AD has set NoEnter
-        // 1.a) current thread is finalizer: it will be allowed to enter the AD, but Destroy() takes a lock and checks again. So we're good
-        // 1.b) current thread is not finalizer: it will not be allowed to enter AD and the value returned here will be NULL
-        // 2. AD has not set NoEnter, but is in the process of CS processing at ADU
-        //    A valid AD pointer is returned, which is all that this function is required to do. Since ADU unload is done handling this DCS, we'll not 
-        //    enter that AD, but use the blob in the DCS.
-        CONTRACTL
-        {
-            NOTHROW;
-            GC_NOTRIGGER;
-            MODE_COOPERATIVE;
-            SO_TOLERANT;
-        } 
-        CONTRACTL_END;
-
-        return m_DomainID;
-    }
-    // Construction and maintenence
-    DomainCompressedStack(ADID domainID); //ctor
-    BOOL IsAssemblyPresent(ISharedSecurityDescriptor* ssd);
-    void AddEntry(void *ptr);
-#ifndef DACCESS_COMPILE
-    void AddFrameEntry(AppDomain * pAppDomain, FRAMESECDESCREF fsdRef, BOOL bIsAHDMFrame, OBJECTREF dynamicResolverRef);
-#endif
-    void Destroy(void);
-
-    // Demand evaluation
-    static FCDECL1(DWORD, GetDescCount, DomainCompressedStack* dcs);
-    static FCDECL3(void, GetDomainPermissionSets, DomainCompressedStack* dcs, OBJECTREF* ppGranted, OBJECTREF* ppDenied);
-    static FCDECL6(FC_BOOL_RET, GetDescriptorInfo, DomainCompressedStack* dcs, DWORD index, OBJECTREF* ppGranted, OBJECTREF* ppDenied, OBJECTREF* ppAssembly, OBJECTREF* ppFSD);
-    static FCDECL1(FC_BOOL_RET, IgnoreDomain, DomainCompressedStack* dcs);
-    OBJECTREF GetDomainCompressedStackInternal(AppDomain *pDomain);
-
-    // AppDomain unload
-    void ClearDomainInfo(void);
-    static void AllHandleAppDomainUnload(AppDomain* pDomain, ADID domainId, ObjectList* list );
-    static void ReleaseDomainCompressedStack( DomainCompressedStack* dcs ) { 
-        WRAPPER_NO_CONTRACT;
-        dcs->Destroy(); 
-    };
-    static DomainCompressedStack* GetNextEntryFromADList(AppDomain* pDomain, ObjectList::Iterator iter);
-    void AppDomainUnloadDone(AppDomain* pDomain);
-
-
-
-private:
-    ArrayList m_EntryList;
-    ADID m_DomainID; // either a valid domain ID or INVALID_APPDOMAIN_ID (set by unloading AppDomain to that value)
-    BOOL m_ignoreAD; // Do not look at domain grant set since we have a CS at the threadbaseobject.
-    DWORD m_dwOverridesCount;    
-    DWORD m_dwAssertCount;
-    BOOL m_Homogeneous;
-    
-    DWORD GetOverridesCount( void )
-    {
-        LIMITED_METHOD_CONTRACT;
-        return m_dwOverridesCount;
-    }
-    
-    DWORD GetAssertCount( void )
-    {
-        LIMITED_METHOD_CONTRACT;
-        return m_dwAssertCount;
-    }
-
-    BOOL IgnoreDomainInternal();
-};
-typedef Holder<DomainCompressedStack*, DoNothing< DomainCompressedStack* >, DomainCompressedStack::ReleaseDomainCompressedStack > DomainCompressedStackHolder;
-
-class NewCompressedStack
-{
-    
-private:
-        DomainCompressedStack** m_DCSList;
-        DWORD m_DCSListCount;
-        DomainCompressedStack *m_currentDCS;
-        Frame *m_pCtxTxFrame; // Be super careful where you use this. Remember that this is a stack location and is not always valid.
-        ADID m_CSAD;
-        AppDomainStack m_ADStack;
-        DWORD adStackIndex;
-        DWORD m_dwOverridesCount;
-        DWORD m_dwAssertCount;
-
-        
-        void CreateDCS(ADID domainID);
-        BOOL IsAssemblyPresent(ADID domainID, ISharedSecurityDescriptor* pSsd);
-        BOOL IsDCSContained(DomainCompressedStack *pDCS);
-        BOOL IsNCSContained(NewCompressedStack *pCS);
-        void ProcessSingleDomainNCS(NewCompressedStack *pCS, AppDomain* pAppDomain);
-public:
-    DWORD GetDCSListCount(void)
-    {
-        // Returns # of non-NULL DCSList entries;
-        LIMITED_METHOD_CONTRACT;
-        return m_DCSListCount;
-    }
-    void Destroy( CLR_BOOL bEntriesOnly = FALSE);
-
-    static void DestroyCompressedStack( NewCompressedStack* stack ) { 
-        WRAPPER_NO_CONTRACT;
-        stack->Destroy(); 
-    };
-    
-    AppDomainStack& GetAppDomainStack( void )
-    {
-        LIMITED_METHOD_CONTRACT;
-        return m_ADStack;
-    }
-
-    DWORD GetOverridesCount( void )
-    {
-        LIMITED_METHOD_CONTRACT;
-        return m_dwOverridesCount;
-    }
-    
-    DWORD GetAssertCount( void )
-    {
-        LIMITED_METHOD_CONTRACT;
-        return m_dwAssertCount;
-    }
-    DWORD GetInnerAppDomainOverridesCount(void)
-    {
-        WRAPPER_NO_CONTRACT;
-        return m_ADStack.GetInnerAppDomainOverridesCount();
-    }
-    DWORD GetInnerAppDomainAssertCount(void)
-    {
-        WRAPPER_NO_CONTRACT;
-        return m_ADStack.GetInnerAppDomainAssertCount();
-    }
-    
-    // This is called every time we hit a stack frame on a stack walk. it will be called with ASD, SSD, FSDs and this func will determine what
-    // (if any) action needs to be performed. 
-    // For example:
-    // on seeing a new SSD, we'll add an entry to the current DCS
-    // on seeing an SSD we've already seen, we'll do nothing
-    // on seeing a new ASD, a new DCS will be created on this CS
-#ifndef DACCESS_COMPILE
-    void ProcessAppDomainTransition(void);
-    DWORD ProcessFrame(AppDomain* pAppDomain, Assembly* pAssembly, MethodDesc* pFunc, ISharedSecurityDescriptor* pSsd, FRAMESECDESCREF* pFsdRef);
-    void ProcessCS(AppDomain* pAppDomain, COMPRESSEDSTACKREF csRef, Frame *pFrame);
-
-#endif 
-    // ctor
-    NewCompressedStack();
-    OBJECTREF GetCompressedStackInner();
-
-    // FCALLS
-    static FCDECL1(DWORD, FCallGetDCSCount, SafeHandle* hcsUNSAFE);
-    static FCDECL2(FC_BOOL_RET, FCallIsImmediateCompletionCandidate, SafeHandle* hcsUNSAFE, OBJECTREF *innerCS);
-    static FCDECL2(Object*, GetDomainCompressedStack, SafeHandle* hcsUNSAFE, DWORD index);
-    static FCDECL1(void, DestroyDCSList, SafeHandle* hcsUNSAFE);
-    static FCDECL1(void, FCallGetHomogeneousPLS, Object* hgPLSUnsafe);
-
-};
-typedef Holder<NewCompressedStack*, DoNothing< NewCompressedStack* >, NewCompressedStack::DestroyCompressedStack > NewCompressedStackHolder;
-#endif // #ifdef FEATURE_COMPRESSEDSTACK
-#endif /* __newcompressedstack_h__ */
-
-
diff --git a/src/vm/ngenoptout.cpp b/src/vm/ngenoptout.cpp
deleted file mode 100644
index b192c4a5f0..0000000000
--- a/src/vm/ngenoptout.cpp
+++ /dev/null
@@ -1,37 +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.
-// ngenoptout.cpp
-//
-
-//
-// 
-// Contains functionality to reject native images at runtime
-
-
-#include "common.h"
-#ifndef FEATURE_CORECLR
-#include "ngenoptout.h"
-#include "assemblynamelist.h"
-
-AssemblyNameList g_NgenOptoutList;
-
-BOOL IsNativeImageOptedOut(IAssemblyName* pName)
-{
-    WRAPPER_NO_CONTRACT
-    return g_NgenOptoutList.Lookup(pName) != NULL;
-}
-
-void AddNativeImageOptOut(IAssemblyName* pName)
-{
-    WRAPPER_NO_CONTRACT
-    pName->AddRef();
-    g_NgenOptoutList.Add(pName);
-}
-// HRESULT
-HRESULT RuntimeIsNativeImageOptedOut(IAssemblyName* pName)
-{
-    WRAPPER_NO_CONTRACT
-    return IsNativeImageOptedOut(pName) ? S_OK :S_FALSE;
-}
-#endif // FEATURE_CORECLR
diff --git a/src/vm/ngenoptout.h b/src/vm/ngenoptout.h
deleted file mode 100644
index dbcc9b1f90..0000000000
--- a/src/vm/ngenoptout.h
+++ /dev/null
@@ -1,34 +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.
-// ngenoptout.h
-//
-
-//
-// 
-// Contains functionality to reject native images at runtime
-
-
-#ifndef NGENOPTOUT_H
-#define NGENOPTOUT_H
-
-#include "assemblynamesconfigfactory.h"
-
-// throwing
-BOOL IsNativeImageOptedOut(IAssemblyName* pName);
-void AddNativeImageOptOut(IAssemblyName* pName);
-
-// HRESULT
-HRESULT RuntimeIsNativeImageOptedOut(IAssemblyName* pName);
-
-
-class NativeImageOptOutConfigFactory : public AssemblyNamesConfigFactory
-{
-    virtual void AddAssemblyName(IAssemblyName* pName) 
-    {
-        WRAPPER_NO_CONTRACT;
-        AddNativeImageOptOut(pName);
-    }
-};
-
-#endif // NGENOPTOUT_H
diff --git a/src/vm/object.cpp b/src/vm/object.cpp
index b219eb9e50..23f46edb3c 100644
--- a/src/vm/object.cpp
+++ b/src/vm/object.cpp
@@ -25,13 +25,6 @@
 #include "gcscan.h"
 #include "argdestination.h"
 
-#ifdef FEATURE_COMPRESSEDSTACK
-void* CompressedStackObject::GetUnmanagedCompressedStack()
-{
-    LIMITED_METHOD_CONTRACT;  
-    return ((m_compressedStackHandle != NULL)?m_compressedStackHandle->GetHandle():NULL);
-}
-#endif // FEATURE_COMPRESSEDSTACK
 
 SVAL_IMPL(INT32, ArrayBase, s_arrayBoundsZero);
 
@@ -1393,9 +1386,6 @@ void Object::ValidateHeap(Object *from, BOOL bDeep)
 #ifdef FEATURE_REMOTING                      
                       this == OBJECTREFToObject(((ThreadBaseObject *)from)->m_ExposedContext) ||
 #endif                      
-#ifndef FEATURE_CORECLR
-                        this == OBJECTREFToObject(((ThreadBaseObject *)from)->m_ExecutionContext) ||
-#endif
                         false))
             {  
                 if (((ThreadBaseObject *)from)->m_InternalThread)
@@ -1737,9 +1727,10 @@ VOID Object::ValidateInner(BOOL bDeep, BOOL bVerifyNextHeader, BOOL bVerifySyncB
         AVInRuntimeImplOkayHolder avOk;
 
         MethodTable *pMT = GetGCSafeMethodTable();
+
         lastTest = 1;
 
-        CHECK_AND_TEAR_DOWN(pMT->Validate());
+        CHECK_AND_TEAR_DOWN(pMT && pMT->Validate());
         lastTest = 2;
 
         bool noRangeChecks =
diff --git a/src/vm/object.h b/src/vm/object.h
index 9a2c817ac1..900438392a 100644
--- a/src/vm/object.h
+++ b/src/vm/object.h
@@ -1508,10 +1508,6 @@ class PermissionListSetObject: public Object
 private:
     OBJECTREF _firstPermSetTriple;
     OBJECTREF _permSetTriples;
-#ifdef FEATURE_COMPRESSEDSTACK
-    OBJECTREF _zoneList;
-    OBJECTREF _originList;
-#endif // FEATURE_COMPRESSEDSTACK
 
 public:
     BOOL IsEmpty() 
@@ -1519,10 +1515,6 @@ public:
         LIMITED_METHOD_CONTRACT;
         return (_firstPermSetTriple == NULL &&
                 _permSetTriples == NULL
-#ifdef FEATURE_COMPRESSEDSTACK
-                && _zoneList == NULL &&
-                _originList == NULL
-#endif // FEATURE_COMPRESSEDSTACK
                 );
     }
 };
@@ -1532,36 +1524,8 @@ typedef REF<PermissionListSetObject> PERMISSIONLISTSETREF;
 #else
 typedef PermissionListSetObject*     PERMISSIONLISTSETREF;
 #endif
-#ifdef FEATURE_COMPRESSEDSTACK
-class CompressedStackObject: public Object
-{
-    friend class MscorlibBinder;
-
-private:
-    // These field are also defined in the managed representation.  (CompressedStack.cs)If you
-    // add or change these field you must also change the managed code so that
-    // it matches these.  This is necessary so that the object is the proper
-    // size. 
-    PERMISSIONLISTSETREF m_pls;
-    SAFEHANDLEREF m_compressedStackHandle;
-
-public:
-    void* GetUnmanagedCompressedStack();
-    BOOL IsEmptyPLS() 
-    {
-        LIMITED_METHOD_CONTRACT;
-        return (m_pls == NULL || m_pls->IsEmpty());
-    }
-};
-
-#ifdef USE_CHECKED_OBJECTREFS
-typedef REF<CompressedStackObject> COMPRESSEDSTACKREF;
-#else
-typedef CompressedStackObject*     COMPRESSEDSTACKREF;
-#endif
-#endif // #ifdef FEATURE_COMPRESSEDSTACK
     
-#if defined(FEATURE_IMPERSONATION) || defined(FEATURE_COMPRESSEDSTACK)
+#if defined(FEATURE_IMPERSONATION)
 class SecurityContextObject: public Object
 {
     friend class MscorlibBinder;
@@ -1577,19 +1541,9 @@ private:
 #ifdef FEATURE_IMPERSONATION
     OBJECTREF               _windowsIdentity;
 #endif // FEATURE_IMPERSONATION
-#ifdef FEATURE_COMPRESSEDSTACK
-    COMPRESSEDSTACKREF      _compressedStack;
-#endif // FEATURE_COMPRESSEDSTACK
     INT32                   _disableFlow;
     CLR_BOOL                _isNewCapture;
 public:
-#ifdef FEATURE_COMPRESSEDSTACK    
-    COMPRESSEDSTACKREF GetCompressedStack()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return _compressedStack;
-    }
-#endif // #ifdef FEATURE_COMPRESSEDSTACK
 };
 
 #ifdef USE_CHECKED_OBJECTREFS
@@ -1597,9 +1551,8 @@ typedef REF<SecurityContextObject> SECURITYCONTEXTREF;
 #else
 typedef SecurityContextObject*     SECURITYCONTEXTREF;
 #endif
-#endif // #if defined(FEATURE_IMPERSONATION) || defined(FEATURE_COMPRESSEDSTACK)
+#endif // #if defined(FEATURE_IMPERSONATION)
 
-#ifdef FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
 #define SYNCCTXPROPS_REQUIRESWAITNOTIFICATION 0x1 // Keep in sync with SynchronizationContext.cs SynchronizationContextFlags
 class ThreadBaseObject;
 class SynchronizationContextObject: public Object
@@ -1620,7 +1573,6 @@ public:
         return FALSE;
     }
 };
-#endif // FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
 
 #ifdef FEATURE_REMOTING
 class CallContextRemotingDataObject : public Object
@@ -1731,99 +1683,19 @@ typedef LogicalCallContextObject*     LOGICALCALLCONTEXTREF;
 
 #endif // FEATURE_REMOTING
 
-#ifndef FEATURE_CORECLR
-class ExecutionContextObject : public Object
-{
-    friend class MscorlibBinder;
-    
-    // These fields are also defined in the managed representation.  (ExecutionContext.cs) If you
-    // add or change these fields you must also change the managed code so that
-    // it matches these.  This is necessary so that the object is the proper
-    // size.
-private :
-#ifdef FEATURE_CAS_POLICY
-    OBJECTREF               _hostExecutionContext;
-#endif // FEATURE_CAS_POLICY
-    OBJECTREF               _syncContext;
-    OBJECTREF               _syncContextNoFlow;
-#if defined(FEATURE_IMPERSONATION) || defined(FEATURE_COMPRESSEDSTACK)
-    SECURITYCONTEXTREF      _securityContext;
-#endif // #if defined(FEATURE_IMPERSONATION) || defined(FEATURE_COMPRESSEDSTACK)
-#ifdef FEATURE_REMOTING
-    LOGICALCALLCONTEXTREF   _logicalCallContext;
-    OBJECTREF               _illogicalCallContext;
-#endif // #ifdef FEATURE_REMOTING
-    INT32                   _flags;
-    OBJECTREF               _localValues;
-    OBJECTREF               _localChangeNotifications;
-
-public:
-    OBJECTREF GetSynchronizationContext()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return _syncContext;
-    }   
-#if defined(FEATURE_IMPERSONATION) || defined(FEATURE_COMPRESSEDSTACK)    
-    SECURITYCONTEXTREF GetSecurityContext()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return _securityContext;
-    }
-#endif // #if defined(FEATURE_IMPERSONATION) || defined(FEATURE_COMPRESSEDSTACK)
-#ifdef FEATURE_REMOTING
-    LOGICALCALLCONTEXTREF GetLogicalCallContext()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return _logicalCallContext;
-    }
-    void SetLogicalCallContext(LOGICALCALLCONTEXTREF ref)
-    { 
-        WRAPPER_NO_CONTRACT;
-        SetObjectReferenceUnchecked((OBJECTREF*)&_logicalCallContext, (OBJECTREF)ref);
-    }
-    OBJECTREF GetIllogicalCallContext()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return _illogicalCallContext;
-    }
-    void SetIllogicalCallContext(OBJECTREF ref)
-    { 
-        WRAPPER_NO_CONTRACT;
-        SetObjectReferenceUnchecked((OBJECTREF*)&_illogicalCallContext, ref);
-    }
-#endif //#ifdef FEATURE_REMOTING
-#ifdef FEATURE_COMPRESSEDSTACK    
-    COMPRESSEDSTACKREF GetCompressedStack()
-    {
-        WRAPPER_NO_CONTRACT;
-        if (_securityContext != NULL)
-            return _securityContext->GetCompressedStack();
-        return NULL;
-    }
-#endif // #ifdef FEATURE_COMPRESSEDSTACK
-        
-};
-#endif //FEATURE_CORECLR
 
 
 
 typedef DPTR(class CultureInfoBaseObject) PTR_CultureInfoBaseObject;
 
 #ifdef USE_CHECKED_OBJECTREFS
-#ifdef FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
 typedef REF<SynchronizationContextObject> SYNCHRONIZATIONCONTEXTREF;
-#endif // FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
 typedef REF<ExecutionContextObject> EXECUTIONCONTEXTREF;
 typedef REF<CultureInfoBaseObject> CULTUREINFOBASEREF;
 typedef REF<ArrayBase> ARRAYBASEREF;
 
 #else
-#ifdef FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
 typedef SynchronizationContextObject*     SYNCHRONIZATIONCONTEXTREF;
-#endif // FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
-#ifndef FEATURE_CORECLR
-typedef ExecutionContextObject*     EXECUTIONCONTEXTREF;
-#endif
 typedef CultureInfoBaseObject*     CULTUREINFOBASEREF;
 typedef PTR_ArrayBase ARRAYBASEREF;
 #endif
@@ -1849,9 +1721,6 @@ class CultureInfoBaseObject : public Object
 private:
     OBJECTREF compareInfo;
     OBJECTREF textInfo;
-#ifndef FEATURE_CORECLR
-    OBJECTREF regionInfo;
-#endif // !FEATURE_CORECLR
     OBJECTREF numInfo;
     OBJECTREF dateTimeInfo;
     OBJECTREF calendar;
@@ -2064,12 +1933,8 @@ private:
 #ifdef FEATURE_REMOTING    
     OBJECTREF     m_ExposedContext;
 #endif    
-#ifdef FEATURE_CORECLR
     OBJECTREF     m_ExecutionContext;
     OBJECTREF     m_SynchronizationContext;
-#else
-    EXECUTIONCONTEXTREF     m_ExecutionContext;
-#endif
     OBJECTREF     m_Name;
     OBJECTREF     m_Delegate;
 #ifdef FEATURE_LEAK_CULTURE_INFO
@@ -2192,47 +2057,12 @@ public:
     }
 #endif // FEATURE_LEAK_CULTURE_INFO
 
-#ifdef FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
-#ifdef FEATURE_CORECLR
     OBJECTREF GetSynchronizationContext()
     {
         LIMITED_METHOD_CONTRACT;
         return m_SynchronizationContext;
     }
-#else // !FEATURE_CORECLR
-    OBJECTREF GetSynchronizationContext()
-    {
-        LIMITED_METHOD_CONTRACT;
-        if (m_ExecutionContext != NULL)
-        {
-            return m_ExecutionContext->GetSynchronizationContext();
-        }
-        return NULL;
-    }
-#endif // FEATURE_CORECLR
-#endif // FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
 
-#ifndef FEATURE_CORECLR
-    OBJECTREF GetExecutionContext()
-    { 
-        LIMITED_METHOD_CONTRACT; 
-        return (OBJECTREF)m_ExecutionContext;
-    }
-    void SetExecutionContext(OBJECTREF ref)
-    { 
-        LIMITED_METHOD_CONTRACT;
-        SetObjectReferenceUnchecked((OBJECTREF*)&m_ExecutionContext, ref);
-    }
-#endif //!FEATURE_CORECLR
-#ifdef FEATURE_COMPRESSEDSTACK    
-    COMPRESSEDSTACKREF GetCompressedStack()
-    {
-        WRAPPER_NO_CONTRACT;
-        if (m_ExecutionContext != NULL)
-            return m_ExecutionContext->GetCompressedStack();
-        return NULL;
-    }
-#endif // #ifdef FEATURE_COMPRESSEDSTACK
     // SetDelegate is our "constructor" for the pathway where the exposed object is
     // created first.  InitExisting is our "constructor" for the pathway where an
     // existing physical thread is later exposed.
@@ -2388,10 +2218,6 @@ class AppDomainBaseObject : public MarshalByRefObjectBaseObject
 #ifdef FEATURE_REMOTING
     OBJECTREF    m_pDefaultContext;     // Default managed context for this AD.
 #endif    
-#ifdef FEATURE_CLICKONCE
-    OBJECTREF    m_pActivationContext;   // ClickOnce ActivationContext.
-    OBJECTREF    m_pApplicationIdentity; // App ApplicationIdentity.
-#endif    
     OBJECTREF    m_pApplicationTrust;    // App ApplicationTrust.
 #ifdef FEATURE_IMPERSONATION
     OBJECTREF    m_pDefaultPrincipal;  // Lazily computed default principle object used by threads
@@ -2402,20 +2228,12 @@ class AppDomainBaseObject : public MarshalByRefObjectBaseObject
     OBJECTREF    m_pProcessExitEventHandler; // Delegate for 'process exit' event.  Only used in Default appdomain.
     OBJECTREF    m_pDomainUnloadEventHandler; // Delegate for 'about to unload domain' event
     OBJECTREF    m_pUnhandledExceptionEventHandler; // Delegate for 'unhandled exception' event
-#ifdef FEATURE_APTCA
-    OBJECTREF    m_aptcaVisibleAssemblies;  // array of conditional APTCA assembly names that should be APTCA visible
-#endif
 
     OBJECTREF    m_compatFlags;
 
-#ifdef FEATURE_EXCEPTION_NOTIFICATIONS
     OBJECTREF    m_pFirstChanceExceptionHandler; // Delegate for 'FirstChance Exception' event
-#endif // FEATURE_EXCEPTION_NOTIFICATIONS
 
     AppDomain*   m_pDomain;            // Pointer to the BaseDomain Structure
-#ifdef FEATURE_CAS_POLICY
-    INT32        m_iPrincipalPolicy;   // Type of principal to create by default
-#endif    
     CLR_BOOL     m_bHasSetPolicy;               // SetDomainPolicy has been called for this domain
     CLR_BOOL     m_bIsFastFullTrustDomain;      // We know for sure that this is a homogeneous full trust domain.  
     CLR_BOOL     m_compatFlagsInitialized;
@@ -2461,13 +2279,6 @@ class AppDomainBaseObject : public MarshalByRefObjectBaseObject
         return !!m_bIsFastFullTrustDomain;
     }
 
-#ifdef FEATURE_APTCA
-    OBJECTREF GetPartialTrustVisibleAssemblies()
-    {
-        LIMITED_METHOD_CONTRACT
-        return m_aptcaVisibleAssemblies;
-    }
-#endif // FEATURE_APTCA
 
     // Ref needs to be a PTRARRAYREF
     void SetPolicies(OBJECTREF ref)
@@ -2488,15 +2299,7 @@ class AppDomainBaseObject : public MarshalByRefObjectBaseObject
         return m_bHasSetPolicy;
     }
 
-#ifdef FEATURE_CLICKONCE
-    BOOL HasActivationContext()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return m_pActivationContext != NULL;
-    }
-#endif // FEATURE_CLICKONCE
 
-#ifdef FEATURE_EXCEPTION_NOTIFICATIONS
     // Returns the reference to the delegate of the first chance exception notification handler
     OBJECTREF GetFirstChanceExceptionNotificationHandler()
     {
@@ -2504,49 +2307,8 @@ class AppDomainBaseObject : public MarshalByRefObjectBaseObject
 
         return m_pFirstChanceExceptionHandler;
     }
-#endif // FEATURE_EXCEPTION_NOTIFICATIONS
 };
 
-#ifndef FEATURE_CORECLR
-// The managed definition of AppDomainSortingSetupInfo is in BCL\System\Globalization\AppDomainSortingSetupInfo.cs
-class AppDomainSortingSetupInfoObject : public Object
-{
-    friend class MscorlibBinder;
-
-  protected:
-    INT_PTR m_pfnIsNLSDefinedString;
-    INT_PTR m_pfnCompareStringEx;
-    INT_PTR m_pfnLCMapStringEx;
-    INT_PTR m_pfnFindNLSStringEx;
-    INT_PTR m_pfnCompareStringOrdinal;
-    INT_PTR m_pfnGetNLSVersionEx;
-    INT_PTR m_pfnFindStringOrdinal;
-    CLR_BOOL m_useV2LegacySorting;
-    CLR_BOOL m_useV4LegacySorting;
-
-  protected:
-    AppDomainSortingSetupInfoObject() { LIMITED_METHOD_CONTRACT; }
-   ~AppDomainSortingSetupInfoObject() { LIMITED_METHOD_CONTRACT; }
-
-  public:
-    CLR_BOOL UseV2LegacySorting() { LIMITED_METHOD_CONTRACT; return m_useV2LegacySorting; }
-    CLR_BOOL UseV4LegacySorting() { LIMITED_METHOD_CONTRACT; return m_useV4LegacySorting; }
-
-    INT_PTR GetPFNIsNLSDefinedString() { LIMITED_METHOD_CONTRACT; return m_pfnIsNLSDefinedString; }
-    INT_PTR GetPFNCompareStringEx() { LIMITED_METHOD_CONTRACT; return m_pfnCompareStringEx; }
-    INT_PTR GetPFNLCMapStringEx() { LIMITED_METHOD_CONTRACT; return m_pfnLCMapStringEx; }
-    INT_PTR GetPFNFindNLSStringEx() { LIMITED_METHOD_CONTRACT; return m_pfnFindNLSStringEx; }
-    INT_PTR GetPFNCompareStringOrdinal() { LIMITED_METHOD_CONTRACT; return m_pfnCompareStringOrdinal; }
-    INT_PTR GetPFNGetNLSVersionEx() { LIMITED_METHOD_CONTRACT; return m_pfnGetNLSVersionEx; }
-    INT_PTR GetPFNFindStringOrdinal() { LIMITED_METHOD_CONTRACT; return m_pfnFindStringOrdinal; }
-};
-typedef DPTR(AppDomainSortingSetupInfoObject) PTR_AppDomainSortingSetupInfoObject;
-#ifdef USE_CHECKED_OBJECTREFS
-typedef REF<AppDomainSortingSetupInfoObject> APPDOMAINSORTINGSETUPINFOREF;
-#else
-typedef AppDomainSortingSetupInfoObject*     APPDOMAINSORTINGSETUPINFOREF;
-#endif // USE_CHECKED_OBJECTREFS
-#endif // FEATURE_CORECLR
 
 // The managed definition of AppDomainSetup is in BCL\System\AppDomainSetup.cs
 class AppDomainSetupObject : public Object
@@ -2558,21 +2320,12 @@ class AppDomainSetupObject : public Object
     STRINGREF m_AppBase;
     OBJECTREF m_AppDomainInitializer;
     PTRARRAYREF m_AppDomainInitializerArguments;
-#ifdef FEATURE_CLICKONCE
-    OBJECTREF m_ActivationArguments;
-#endif // FEATURE_CLICKONCE
     STRINGREF m_ApplicationTrust;
     I1ARRAYREF m_ConfigurationBytes;
     STRINGREF m_AppDomainManagerAssembly;
     STRINGREF m_AppDomainManagerType;
-#if FEATURE_APTCA
-    PTRARRAYREF m_AptcaVisibleAssemblies;
-#endif
     OBJECTREF m_CompatFlags;
     STRINGREF m_TargetFrameworkName;
-#ifndef FEATURE_CORECLR
-    APPDOMAINSORTINGSETUPINFOREF m_AppDomainSortingSetupInfo;
-#endif // FEATURE_CORECLR
     INT32 m_LoaderOptimization;
 #ifdef FEATURE_COMINTEROP
     CLR_BOOL m_DisableInterfaceCache;
@@ -2588,9 +2341,6 @@ class AppDomainSetupObject : public Object
    ~AppDomainSetupObject() { LIMITED_METHOD_CONTRACT; }
 
   public:
-#ifndef FEATURE_CORECLR
-    APPDOMAINSORTINGSETUPINFOREF GetAppDomainSortingSetupInfo() { LIMITED_METHOD_CONTRACT; return m_AppDomainSortingSetupInfo; }
-#endif // FEATURE_CORECLR
 #ifdef FEATURE_RANDOMIZED_STRING_HASHING
     BOOL UseRandomizedStringHashing() { LIMITED_METHOD_CONTRACT; return (BOOL) m_UseRandomizedStringHashing; }
 #endif // FEATURE_RANDOMIZED_STRING_HASHING
@@ -2878,20 +2628,6 @@ class FrameSecurityDescriptorBaseObject : public Object
     }
 };
 
-#ifdef FEATURE_COMPRESSEDSTACK
-class FrameSecurityDescriptorWithResolverBaseObject : public FrameSecurityDescriptorBaseObject
-{
-public:
-    OBJECTREF m_resolver;
-
-public:
-    void SetDynamicMethodResolver(OBJECTREF resolver)
-    {
-        LIMITED_METHOD_CONTRACT;
-        SetObjectReference(&m_resolver, resolver, this->GetAppDomain());
-    }
-};
-#endif // FEATURE_COMPRESSEDSTACK
 
 class WeakReferenceObject : public Object
 {
@@ -2925,9 +2661,6 @@ typedef REF<VersionBaseObject> VERSIONREF;
 
 typedef REF<FrameSecurityDescriptorBaseObject> FRAMESECDESCREF;
 
-#ifdef FEATURE_COMPRESSEDSTACK
-typedef REF<FrameSecurityDescriptorWithResolverBaseObject> FRAMESECDESWITHRESOLVERCREF;
-#endif // FEATURE_COMPRESSEDSTACK
 
 typedef REF<WeakReferenceObject> WEAKREFERENCEREF;
 
@@ -2980,9 +2713,6 @@ typedef MarshalByRefObjectBaseObject* MARSHALBYREFOBJECTBASEREF;
 typedef VersionBaseObject* VERSIONREF;
 typedef FrameSecurityDescriptorBaseObject* FRAMESECDESCREF;
 
-#ifdef FEATURE_COMPRESSEDSTACK
-typedef FrameSecurityDescriptorWithResolverBaseObject* FRAMESECDESWITHRESOLVERCREF;
-#endif // FEATURE_COMPRESSEDSTACK
 
 typedef WeakReferenceObject* WEAKREFERENCEREF;
 #endif // #ifndef DACCESS_COMPILE
@@ -3803,217 +3533,6 @@ typedef REF<DelegateObject> DELEGATEREF;
 typedef DelegateObject* DELEGATEREF;
 #endif // USE_CHECKED_OBJECTREFS
 
-// This class corresponds to PermissionSet on the managed side.
-class PermissionSetObject : public Object
-{
-    friend class MscorlibBinder;
-
-public:
-    BOOL AllPermissionsDecoded()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return _allPermissionsDecoded == TRUE;
-    }
-
-    BOOL ContainsCas()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return _ContainsCas == TRUE;
-    }
-
-    BOOL ContainsNonCas()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return _ContainsNonCas == TRUE;
-    }
-
-    BOOL CheckedForNonCas()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return _CheckedForNonCas == TRUE;
-    }
-
-    BOOL IsUnrestricted()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return _Unrestricted == TRUE;
-    }
-
-    OBJECTREF GetTokenBasedSet()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return _permSet;
-    }
-
-
-    // README:
-    // If you modify the order of these fields, make sure to update the definition in 
-    // BCL for this object.
-private:
-    // Order of the fields is important as it mirrors the layout of PermissionSet
-    // to access the fields directly from unmanaged code given an OBJECTREF. 
-    // Please keep them in sync when you make changes to the fields. 
-    OBJECTREF _permSet;
-    STRINGREF _serializedPermissionSet;
-    OBJECTREF _permSetSaved;
-    OBJECTREF _unrestrictedPermSet;
-    OBJECTREF _normalPermSet;
-    CLR_BOOL _Unrestricted;
-    CLR_BOOL _allPermissionsDecoded;
-    CLR_BOOL _ignoreTypeLoadFailures;
-    CLR_BOOL _CheckedForNonCas;
-    CLR_BOOL _ContainsCas;
-    CLR_BOOL _ContainsNonCas;
-    CLR_BOOL _Readable;
-#ifdef FEATURE_CAS_POLICY
-    CLR_BOOL _canUnrestrictedOverride;
-#endif // FEATURE_CAS_POLICY
-};
-
-#ifdef USE_CHECKED_OBJECTREFS
-typedef REF<PermissionSetObject> PERMISSIONSETREF;
-#else // USE_CHECKED_OBJECTREFS
-typedef PermissionSetObject* PERMISSIONSETREF;
-#endif // USE_CHECKED_OBJECTREFS
-
-// This class corresponds to TokenBasedSet on the managed side.
-class TokenBasedSetObject : public Object
-{
-public:
-    INT32 GetNumElements () {
-        LIMITED_METHOD_CONTRACT;
-        return _cElt;
-    }
-
-    OBJECTREF GetPermSet () {
-        LIMITED_METHOD_CONTRACT;
-        return _Obj;
-    }
-
-private:
-    // If you modify the order of these fields, make sure
-    // to update the definition in BCL for this object.
-    OBJECTREF _objSet;
-    OBJECTREF _Obj;
-    OBJECTREF _Set;
-    INT32 _initSize;
-    INT32 _increment;
-    INT32 _cElt;
-    INT32 _maxIndex;
-};
-
-#ifdef USE_CHECKED_OBJECTREFS
-typedef REF<TokenBasedSetObject> TOKENBASEDSETREF;
-#else // USE_CHECKED_OBJECTREFS
-typedef TokenBasedSetObject* TOKENBASEDSETREF;
-#endif // USE_CHECKED_OBJECTREFS
-
-// This class corresponds to PolicyStatement on the managed side.
-class PolicyStatementObject : public Object
-{
-    friend class MscorlibBinder;
-private:
-    PERMISSIONSETREF _permSet;
-#ifdef FEATURE_CAS_POLICY
-    OBJECTREF _dependentEvidence;
-#endif // FEATURE_CAS_POLICY
-    INT32 _attributes;
-
-public:
-    PERMISSIONSETREF GetPermissionSet()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return _permSet;
-    }
-};
-#ifdef USE_CHECKED_OBJECTREFS
-typedef REF<PolicyStatementObject> POLICYSTATEMENTREF;
-#else // USE_CHECKED_OBJECTREFS
-typedef PolicyStatementObject* POLICYSTATEMENTREF;
-#endif // USE_CHECKED_OBJECTREFS
-
-// This class corresponds to ApplicationTrust on the managed side.
-class ApplicationTrustObject : public Object
-{
-    friend class MscorlibBinder;
-private:
-#ifdef FEATURE_CLICKONCE
-    OBJECTREF _appId;
-    OBJECTREF _extraInfo;
-    OBJECTREF _elExtraInfo;
-#endif // FEATURE_CLICKONCE
-    POLICYSTATEMENTREF _psDefaultGrant;
-    OBJECTREF _fullTrustAssemblies;
-    DWORD _grantSetSpecialFlags;
-#ifdef FEATURE_CLICKONCE
-    CLR_BOOL _appTrustedToRun;
-    CLR_BOOL _persist;
-#endif // FEATURE_CLICKONCE
-
-public:
-    POLICYSTATEMENTREF GetPolicyStatement()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return _psDefaultGrant;
-    }
-
-    // The grant set special flags are mapped in the BCL for the DefaultGrantSet of the ApplicationTrust. 
-    // Since ApplicationTrust provides a reference to its DefaultGrantSet rather than a copy, the flags may
-    // not be in sync if user code can ever get a hold of the ApplicationTrust object.  Therefore, these
-    // flags should only be used in code paths where we are sure that only trusted code can ever get a
-    // reference to the ApplicationTrust (such as the ApplicationTrust created when setting up a homogenous
-    // AppDomain).
-    DWORD GetGrantSetSpecialFlags()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return _grantSetSpecialFlags;
-    }
-};
-#ifdef USE_CHECKED_OBJECTREFS
-typedef REF<ApplicationTrustObject> APPLICATIONTRUSTREF;
-#else // USE_CHECKED_OBJECTREFS
-typedef ApplicationTrustObject* APPLICATIONTRUSTREF;
-#endif // USE_CHECKED_OBJECTREFS
-
-// This class corresponds to SecurityPermission on the managed side.
-class SecurityPermissionObject : public Object
-{
-public:
-    DWORD GetFlags () {
-        LIMITED_METHOD_CONTRACT;
-        return _flags;
-    }
-
-private:
-    // If you modify the order of these fields, make sure
-    // to update the definition in BCL for this object.
-    DWORD _flags;
-};
-
-#ifdef USE_CHECKED_OBJECTREFS
-typedef REF<SecurityPermissionObject> SECURITYPERMISSIONREF;
-#else // USE_CHECKED_OBJECTREFS
-typedef SecurityPermissionObject* SECURITYPERMISSIONREF;
-#endif // USE_CHECKED_OBJECTREFS
-
-// This class corresponds to ReflectionPermission on the managed side.
-class ReflectionPermissionObject : public Object
-{
-public:
-    DWORD GetFlags () {
-        LIMITED_METHOD_CONTRACT;
-        return _flags;
-    }
-
-private:
-    DWORD _flags;
-};
-
-#ifdef USE_CHECKED_OBJECTREFS
-typedef REF<ReflectionPermissionObject> REFLECTIONPERMISSIONREF;
-#else // USE_CHECKED_OBJECTREFS
-typedef ReflectionPermissionObject* REFLECTIONPERMISSIONREF;
-#endif // USE_CHECKED_OBJECTREFS
 
 struct StackTraceElement;
 class ClrDataAccess;
diff --git a/src/vm/objectclone.cpp b/src/vm/objectclone.cpp
deleted file mode 100644
index b4ad314165..0000000000
--- a/src/vm/objectclone.cpp
+++ /dev/null
@@ -1,3865 +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.
-//
-// File: ObjectClone.cpp
-// 
-
-//
-
-
-#include "common.h"
-
-#ifdef FEATURE_REMOTING
-#include "objectclone.h"
-#include "frames.h"
-#include "assembly.hpp"
-#include "field.h"
-#include "security.h"
-#include "virtualcallstub.h"
-#include "crossdomaincalls.h"
-#include "callhelpers.h"
-#include "jitinterface.h"
-#include "typestring.h"
-#include "typeparse.h"
-#include "runtimehandles.h"
-#include "appdomain.inl"
-
-// Define the following to re-enable object cloner strict mode (where we require source fields for non-optional destination fields
-// and don't attempt to load assemblies we can't find via display via partial names instead).
-//#define OBJECT_CLONER_STRICT_MODE
-
-void MakeIDeserializationCallback(OBJECTREF refTarget);
-
-MethodDesc *GetInterfaceMethodImpl(MethodTable *pMT, MethodTable *pItfMT, WORD wSlot)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-    } CONTRACTL_END;
-
-    MethodDesc *pMeth = NULL;
-    DispatchSlot slot(pMT->FindDispatchSlot(pItfMT->GetTypeID(), (UINT32)wSlot));
-    CONSISTENCY_CHECK(!slot.IsNull());
-    pMeth = slot.GetMethodDesc();
-    return pMeth;
-}
-
-// Given a FieldDesc which may be representative and an object which contains said field, return the actual type of the field. This
-// works even when called from a different appdomain from which the type was loaded (though naturally it is the caller's
-// responsbility to ensure such an appdomain cannot be unloaded during the processing of this method).
-TypeHandle LoadExactFieldType(FieldDesc *pFD, OBJECTREF orefParent, AppDomain *pDomain)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    MethodTable *pEnclosingMT = orefParent->GetMethodTable();
-
-    // Set up a field signature with the owning type providing a type context for any type variables.
-    MetaSig sig(pFD, TypeHandle(pEnclosingMT));
-    sig.NextArg();
-
-    // If the enclosing type is resident to this domain or domain neutral and loaded in this domain then we can simply go get it.
-    // The logic is trickier (and more expensive to calculate) for generic types, so skip the optimization there.
-    if (pEnclosingMT->GetDomain() == GetAppDomain() ||
-        (pEnclosingMT->IsDomainNeutral() &&
-         !pEnclosingMT->HasInstantiation() &&
-         pEnclosingMT->GetAssembly()->FindDomainAssembly(GetAppDomain())))
-        return sig.GetLastTypeHandleThrowing();
-
-    TypeHandle retTH;
-
-    // Otherwise we have to do this the expensive way -- switch to the home domain for the type lookup.
-    ENTER_DOMAIN_PTR(pDomain, ADV_RUNNINGIN); 
-    retTH = sig.GetLastTypeHandleThrowing();
-    END_DOMAIN_TRANSITION;
-
-    return retTH;
-}
-
-extern TypeHandle GetTypeByName( _In_opt_z_ LPUTF8 szFullClassName,
-                                BOOL bThrowOnError, 
-                                BOOL bIgnoreCase, 
-                                StackCrawlMark *stackMark,
-                                BOOL *pbAssemblyIsLoading);
-
-#ifndef DACCESS_COMPILE
-#define CUSTOM_GCPROTECT_BEGIN(context)           do {                      \
-                FrameWithCookie<GCSafeCollectionFrame> __gcframe(context);  \
-                /* work around unreachable code warning */                  \
-                if (true) { DEBUG_ASSURE_NO_RETURN_BEGIN(GCPROTECT)
-
-#define CUSTOM_GCPROTECT_END()                                              \
-                DEBUG_ASSURE_NO_RETURN_END(GCPROTECT) }                     \
-                __gcframe.Pop(); } while(0)
-
-#else // #ifndef DACCESS_COMPILE
-
-#define CUSTOM_GCPROTECT_BEGIN(context)
-#define CUSTOM_GCPROTECT_END()
-
-#endif // #ifndef DACCESS_COMPILE
-
-int GCSafeObjectHashTable::HasID(OBJECTREF refObj, OBJECTREF *newObj)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        THROWS;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END
-
-    BOOL seenBefore = FALSE;
-    *newObj = NULL;
-    int index = FindElement(refObj, seenBefore);
-
-    if (seenBefore)
-    {
-        _ASSERTE(index < (int)m_currArraySize);
-        *newObj = m_newObjects[index];
-        return m_ids[index];
-    }
-
-    return -1;
-}
-
-// returns the object id
-int GCSafeObjectHashTable::AddObject(OBJECTREF refObj, OBJECTREF newObj)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        THROWS;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END
-
-    int index = -1;
-    GCPROTECT_BEGIN(refObj);
-    GCPROTECT_BEGIN(newObj);
-    
-    if (m_count > m_currArraySize / 2)
-    {
-        Resize();
-    }
-
-    BOOL seenBefore = FALSE;
-    index = FindElement(refObj, seenBefore);
-
-    _ASSERTE(index >= 0 && index < (int)m_currArraySize);
-    if (seenBefore)
-    {
-        _ASSERTE(!"Adding an object thats already present");
-    }
-    else
-    {
-        m_objects[index] = refObj;
-        m_newObjects[index] = newObj;
-        m_ids[index] = ++m_count;
-    }
-
-    GCPROTECT_END();
-    GCPROTECT_END();
-
-    return m_ids[index];
-}
-
-// returns the object id
-int GCSafeObjectHashTable::UpdateObject(OBJECTREF refObj, OBJECTREF newObj)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        THROWS;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END
-
-    int index = -1;
-    GCPROTECT_BEGIN(refObj);
-    GCPROTECT_BEGIN(newObj);
-    
-    BOOL seenBefore = FALSE;
-    index = FindElement(refObj, seenBefore);
-
-    _ASSERTE(index >= 0 && index < (int)m_currArraySize);
-    if (!seenBefore)
-    {
-        _ASSERTE(!"An object has to exist in the table, to update it");
-    }
-    else
-    {
-        _ASSERTE(m_objects[index] == refObj);
-        m_newObjects[index] = newObj;
-    }
-
-    GCPROTECT_END();
-    GCPROTECT_END();
-
-    return m_ids[index];
-}
-
-// returns index into array where obj was found or will fit in
-int GCSafeObjectHashTable::FindElement(OBJECTREF refObj, BOOL &seenBefore)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        THROWS;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END
-
-    int currentNumBuckets = m_currArraySize / NUM_SLOTS_PER_BUCKET;
-    int hashcode = 0;
-    GCPROTECT_BEGIN(refObj);
-    hashcode = refObj->GetHashCodeEx();
-    GCPROTECT_END();
-    
-    hashcode &= 0x7FFFFFFF; // ignore sign bit
-    int hashIncrement = (1+((hashcode)%(currentNumBuckets-2)));        
-#ifdef _DEBUG 
-    int numLoops = 0;
-#endif
-
-    do
-    {
-        int index = ((unsigned)hashcode % currentNumBuckets) * NUM_SLOTS_PER_BUCKET;
-        _ASSERTE(index >= 0 && index < (int)m_currArraySize);
-        for (int i = index; i < index + NUM_SLOTS_PER_BUCKET; i++)
-        {
-            if (m_objects[i] == refObj)
-            {
-                seenBefore = TRUE;
-                return i;
-            }
-
-            if (m_objects[i] == NULL)
-            {
-                seenBefore = FALSE;
-                return i;
-            }
-        }
-        hashcode += hashIncrement;
-#ifdef _DEBUG 
-        if (++numLoops > currentNumBuckets)
-            _ASSERTE(!"Looped too many times, trying to find object in hashtable. If hitting ignore doesnt seem to help, then contact Ashok");
-#endif
-    }while (true);
-
-    _ASSERTE(!"Not expected to reach here in GCSafeObjectHashTable::FindElement");
-    return -1;
-}
-
-void GCSafeObjectHashTable::Resize()
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        THROWS;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END
-    // Allocate new space
-    DWORD newSize = m_currArraySize * 2;
-    for (int i = 0; (DWORD) i < sizeof(g_rgPrimes)/sizeof(DWORD); i++)
-    {
-        if (g_rgPrimes[i] > newSize)
-        {
-            newSize = g_rgPrimes[i];
-            break;
-        }
-    }
-
-    newSize *= NUM_SLOTS_PER_BUCKET;
-    NewArrayHolder<OBJECTREF> refTemp (new OBJECTREF[newSize]);
-    ZeroMemory((void *)refTemp, sizeof(OBJECTREF) * newSize);
-
-    NewArrayHolder<OBJECTREF> refTempNewObj (new OBJECTREF[newSize]);
-#ifdef USE_CHECKED_OBJECTREFS
-    ZeroMemory((void *)refTempNewObj, sizeof(OBJECTREF) * newSize);
-#endif
-
-    NewArrayHolder<int> bTemp (new int[newSize]);
-    ZeroMemory((void *)bTemp, sizeof(int) * newSize);
-
-    // Copy over objects and data
-    NewArrayHolder<OBJECTREF> refOldObj (m_objects);
-    NewArrayHolder<OBJECTREF> refOldNewObj (m_newObjects);
-    NewArrayHolder<int> oldIds (m_ids);
-    DWORD oldArrSize = m_currArraySize;
-
-    if (oldIds == (int *)&m_dataOnStack[0])
-    {
-        refOldObj.SuppressRelease();
-        refOldNewObj.SuppressRelease();
-        oldIds.SuppressRelease();
-    }
-    
-    refTemp.SuppressRelease();
-    refTempNewObj.SuppressRelease();
-    bTemp.SuppressRelease();
-    
-    m_ids = bTemp;
-    m_objects = refTemp;
-    m_newObjects = refTempNewObj;
-    m_currArraySize = newSize;
-    
-    for (DWORD i = 0; i < oldArrSize; i++)
-    {
-        if (refOldObj[i] == NULL)
-            continue;
-
-        BOOL seenBefore = FALSE;
-        int newIndex = FindElement(refOldObj[i], seenBefore);
-
-        if (!seenBefore)
-        {
-            _ASSERTE(newIndex < (int)m_currArraySize);
-            m_objects[newIndex] = refOldObj[i];
-            m_newObjects[newIndex] = refOldNewObj[i];
-            m_ids[newIndex] = oldIds[i];
-        }
-        else
-            _ASSERTE(!"Object seen twice while rehashing");
-    }
-
-#ifdef USE_CHECKED_OBJECTREFS
-    for(DWORD i = 0; i < m_currArraySize; i++)
-        Thread::ObjectRefProtected(&m_objects[i]);
-    for(DWORD i = 0; i < m_currArraySize; i++)
-        Thread::ObjectRefProtected(&m_newObjects[i]);
-#endif
-
-}
-
-void GCSafeObjectTable::Push(OBJECTREF refObj, OBJECTREF refParent, OBJECTREF refAux, QueuedObjectInfo * pQOI)
-{
-    CONTRACTL
-    {
-        THROWS;
-        MODE_COOPERATIVE;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END
-    _ASSERTE(refObj != NULL);
-    _ASSERTE(m_QueueType == LIFO_QUEUE);
-    _ASSERTE(m_head == 0 && m_dataHead == 0);
-    
-    // First find the size of the object info
-    DWORD size = pQOI->GetSize();
-
-    // Check if resize is needed
-    EnsureSize(size);
-
-    // Push on the stack, first the objects
-    DWORD index = m_count;
-    if (m_Objects1)
-        m_Objects1[index] = refObj;
-#ifdef _DEBUG
-    else
-        _ASSERTE(refObj == NULL);
-#endif    
-    if (m_Objects2)
-        m_Objects2[index] = refParent;
-#ifdef _DEBUG
-    else
-        _ASSERTE(refParent == NULL);
-#endif    
-    if (m_Objects3)
-        m_Objects3[index] = refAux;
-#ifdef _DEBUG
-    else
-        _ASSERTE(refAux == NULL);
-#endif    
-
-    // then the info
-    if (m_dataIndices)
-        m_dataIndices[index] = m_numDataBytes;
-    BYTE *pData = &m_data[m_numDataBytes]; 
-    memcpy(pData, (VOID*)pQOI, size);
-
-    m_numDataBytes += size;
-    m_count++;
-}
-
-OBJECTREF GCSafeObjectTable::Pop(OBJECTREF *refParent, OBJECTREF *refAux, QueuedObjectInfo ** pQOI)
-{
-    LIMITED_METHOD_CONTRACT;
-    _ASSERTE(m_QueueType == LIFO_QUEUE);
-    _ASSERTE(m_head == 0 && m_dataHead == 0);
-    _ASSERTE(m_dataIndices != NULL);
-    
-    *pQOI = NULL;
-    OBJECTREF refRet = NULL;
-    *refParent = NULL;
-    *refAux = NULL;
-    if (m_count == 0)
-        return NULL;
-
-    m_count--;
-    refRet = m_Objects1[m_count];
-    if (m_Objects2)
-        *refParent = m_Objects2[m_count];
-    if (m_Objects3)
-        *refAux = m_Objects3[m_count];
-    *pQOI = (QueuedObjectInfo *) &m_data[m_dataIndices[m_count]];
-
-    m_numDataBytes -= (*pQOI)->GetSize();
-    return refRet;
-}
-
-void GCSafeObjectTable::SetAt(DWORD index, OBJECTREF refObj, OBJECTREF refParent, OBJECTREF refAux, QueuedObjectInfo * pQOI)
-{
-    CONTRACTL
-    {
-        THROWS;
-        MODE_COOPERATIVE;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END
-    _ASSERTE(refObj != NULL);
-#ifdef _DEBUG
-    if (m_QueueType == LIFO_QUEUE)
-        _ASSERTE(index >= 0 && index < m_count);
-    else
-        _ASSERTE(index < m_currArraySize);
-#endif
-    
-    // First find the size of the object info
-    DWORD size = pQOI->GetSize();
-
-    // Push on the stack, first the objects
-    m_Objects1[index] = refObj;
-    if (m_Objects2)
-        m_Objects2[index] = refParent;
-    if (m_Objects3)
-        m_Objects3[index] = refAux;
-
-    // then the info
-    _ASSERTE(m_dataIndices != NULL);
-    
-    QueuedObjectInfo *pData = (QueuedObjectInfo *)&m_data[m_dataIndices[index]]; 
-    _ASSERTE(pData->GetSize() == size);
-    
-    memcpy(pData, (VOID*)pQOI, size);
-}
-
-OBJECTREF GCSafeObjectTable::GetAt(DWORD index, OBJECTREF *refParent, OBJECTREF *refAux, QueuedObjectInfo ** pQOI)
-{
-    LIMITED_METHOD_CONTRACT;
-#ifdef _DEBUG
-    if (m_QueueType == LIFO_QUEUE)
-        _ASSERTE(index >= 0 && index < m_count);
-    else
-        _ASSERTE(index < m_currArraySize);
-#endif
-
-    OBJECTREF refRet = m_Objects1[index];
-    if (m_Objects2)
-        *refParent = m_Objects2[index];
-    else
-        *refParent = NULL;
-    if (m_Objects3)
-        *refAux = m_Objects3[index];
-    else
-        *refAux = NULL;
-
-    _ASSERTE(m_dataIndices != NULL);
-    
-    *pQOI = (QueuedObjectInfo *) &m_data[m_dataIndices[index]];
-
-    return refRet;
-}
-
-void GCSafeObjectTable::Enqueue(OBJECTREF refObj, OBJECTREF refParent, OBJECTREF refAux, QueuedObjectInfo *pQOI)
-{
-    CONTRACTL
-    {
-        THROWS;
-        MODE_COOPERATIVE;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END
-        
-    _ASSERTE(refObj != NULL);
-    _ASSERTE(m_QueueType == FIFO_QUEUE);
-    
-    // First find the size of the object info
-    DWORD size = pQOI ? pQOI->GetSize() : 0;
-
-    // Check if resize is needed
-    EnsureSize(size);
-
-    // Append to queue, first the objects
-    DWORD index = (m_head + m_count) % m_currArraySize;
-    m_Objects1[index] = refObj;
-    if (m_Objects2)
-        m_Objects2[index] = refParent;
-    if (m_Objects3)
-        m_Objects3[index] = refAux;
-
-    // then the info
-    if (pQOI)
-    {
-        DWORD dataIndex = (m_dataHead + m_numDataBytes) % (m_currArraySize * MAGIC_FACTOR);
-        BYTE *pData = &m_data[dataIndex];
-        memcpy(pData, (VOID*)pQOI, size);
-
-        if (m_dataIndices)
-            m_dataIndices[index] = dataIndex;
-        m_numDataBytes += size;
-    }
-
-    m_count++;
-}
-
-OBJECTREF GCSafeObjectTable::Dequeue(OBJECTREF *refParent, OBJECTREF *refAux, QueuedObjectInfo ** pQOI)
-{
-    LIMITED_METHOD_CONTRACT;
-    
-    _ASSERTE(m_QueueType == FIFO_QUEUE);
-    
-    if (pQOI)
-        *pQOI = NULL;
-    OBJECTREF refRet = NULL;
-    *refParent = NULL;
-    *refAux = NULL;
-    if (m_count == 0)
-        return NULL;
-
-    refRet = m_Objects1[m_head];
-    if (m_Objects2)
-        *refParent = m_Objects2[m_head];
-    if (m_Objects3)
-        *refAux = m_Objects3[m_head];
-    
-    if (pQOI)
-    {
-        *pQOI = (QueuedObjectInfo *) &m_data[m_dataHead];
-
-        m_dataHead = (m_dataHead + (*pQOI)->GetSize()) % (m_currArraySize * MAGIC_FACTOR);
-
-        m_numDataBytes -= (*pQOI)->GetSize();
-    }
-
-    m_head = (m_head + 1) % m_currArraySize;
-    m_count--;
-    return refRet;
-}
-
-OBJECTREF GCSafeObjectTable::Peek(OBJECTREF *refParent, OBJECTREF *refAux, QueuedObjectInfo **pQOI)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-    
-   *pQOI = NULL;
-    *refParent = NULL;
-    *refAux = NULL;
-    if (m_count == 0)
-        return NULL;
-
-    DWORD indexToPeek;
-    if (m_QueueType == LIFO_QUEUE)
-    {
-        indexToPeek = m_count;
-        return GetAt(indexToPeek, refParent, refAux, pQOI);
-    }
-    else
-    {
-        indexToPeek = m_head;
-        if (m_Objects2)
-            *refParent = m_Objects2[m_head];
-        if (m_Objects3)
-            *refParent = m_Objects3[m_head];
-        *pQOI = (QueuedObjectInfo *) &m_data[m_dataHead];
-        return m_Objects1[m_head];
-    }
-
-}
-
-void GCSafeObjectTable::EnsureSize(DWORD requiredDataSize)
-{
-    CONTRACTL
-    {
-        THROWS;
-        MODE_COOPERATIVE;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END
-    // Check if the object queue is sized enough
-    if (m_count == m_currArraySize)
-    {
-        Resize();
-        return;
-    }
-
-    // Check if the data array size is enough 
-    if (m_numDataBytes + requiredDataSize > m_currArraySize * MAGIC_FACTOR)
-    {
-        Resize();
-        return;
-    }
-
-    if (m_QueueType == FIFO_QUEUE)
-    {
-        // Will current QueuedObjectInfo go beyond the edge of the array ?
-        if (m_dataHead + m_numDataBytes + requiredDataSize > m_currArraySize * MAGIC_FACTOR)
-        {
-            Resize();
-            return;
-        }
-    }
-}
-
-void GCSafeObjectTable::Resize()
-{
-    CONTRACTL
-    {
-        THROWS;
-        MODE_COOPERATIVE;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END
-    // Allocate new space
-    DWORD newSize = m_currArraySize * 2;
-    NewArrayHolder<OBJECTREF> refTemp (NULL);
-    NewArrayHolder<OBJECTREF> refParentTemp (NULL);
-    NewArrayHolder<OBJECTREF> refAuxTemp (NULL);
-
-    refTemp = new OBJECTREF[newSize];
-    if (m_Objects2)
-        refParentTemp = new OBJECTREF[newSize];
-    if (m_Objects3)
-        refAuxTemp = new OBJECTREF[newSize];
-
-#ifdef USE_CHECKED_OBJECTREFS
-    ZeroMemory((void *)refTemp, sizeof(OBJECTREF) * newSize);
-    if (m_Objects2)
-        ZeroMemory((void *)refParentTemp, sizeof(OBJECTREF) * newSize);
-    if (m_Objects3)
-        ZeroMemory((void *)refAuxTemp, sizeof(OBJECTREF) * newSize);
-#endif
-
-    NewArrayHolder<BYTE> bTemp (NULL);
-    NewArrayHolder<DWORD> dwIndicesTemp (NULL);
-
-    bTemp = new BYTE[newSize * MAGIC_FACTOR];
-    if (m_dataIndices)
-        dwIndicesTemp = new DWORD[newSize];
-
-    // Copy over objects and data
-    if (m_QueueType == LIFO_QUEUE || (m_QueueType == FIFO_QUEUE && m_head == 0))
-    {
-        void *pSrc = (void *)&m_Objects1[0];
-        void *pDest = (void *)&refTemp[0];
-        memcpyUnsafe(pDest, pSrc, m_count * sizeof(OBJECTREF));
-
-        if (m_Objects2)
-        {
-            pSrc = (void *)&m_Objects2[0];
-            pDest = (void *)&refParentTemp[0];
-            memcpyUnsafe(pDest, pSrc, m_count * sizeof(OBJECTREF));
-        }
-
-        if (m_Objects3)
-        {
-            pSrc = (void *)&m_Objects3[0];
-            pDest = (void *)&refAuxTemp[0];
-            memcpyUnsafe(pDest, pSrc, m_count * sizeof(OBJECTREF));
-        }
-
-        pSrc = (void *)&m_data[0];
-        pDest = (void *)&bTemp[0];
-        memcpyNoGCRefs(pDest, pSrc, m_numDataBytes);
-
-        if (m_dataIndices)
-        {
-            pSrc = (void *)&m_dataIndices[0];
-            pDest = (void *)&dwIndicesTemp[0];
-            memcpyNoGCRefs(pDest, pSrc, m_count * sizeof(DWORD));
-        }
-
-    }
-    else
-    {
-        _ASSERTE(m_QueueType == FIFO_QUEUE && m_head != 0);
-        _ASSERTE(m_currArraySize > m_head);
-        DWORD numObjRefsToCopy = (m_count > m_currArraySize - m_head ? m_currArraySize - m_head : m_count);
-
-        void *pSrc = (void *)&m_Objects1[m_head];
-        void *pDest = (void *)&refTemp[0];
-        memcpyUnsafe(pDest, pSrc, numObjRefsToCopy * sizeof(OBJECTREF));
-        pSrc = (void *)&m_Objects1[0];
-        pDest = (void *)&refTemp[numObjRefsToCopy];
-        memcpyUnsafe(pDest, pSrc, (m_count - numObjRefsToCopy) * sizeof(OBJECTREF));
-
-        if (m_Objects2)
-        {
-            pSrc = (void *)&m_Objects2[m_head];
-            pDest = (void *)&refParentTemp[0];
-            memcpyUnsafe(pDest, pSrc, numObjRefsToCopy * sizeof(OBJECTREF));
-            pSrc = (void *)&m_Objects2[0];
-            pDest = (void *)&refParentTemp[numObjRefsToCopy];
-            memcpyUnsafe(pDest, pSrc, (m_count - numObjRefsToCopy) * sizeof(OBJECTREF));
-        }
-
-        if (m_Objects3)
-        {
-            pSrc = (void *)&m_Objects3[m_head];
-            pDest = (void *)&refAuxTemp[0];
-            memcpyUnsafe(pDest, pSrc, numObjRefsToCopy * sizeof(OBJECTREF));
-            pSrc = (void *)&m_Objects3[0];
-            pDest = (void *)&refAuxTemp[numObjRefsToCopy];
-            memcpyUnsafe(pDest, pSrc, (m_count - numObjRefsToCopy) * sizeof(OBJECTREF));
-        }
-
-        if (m_dataIndices)
-        {
-            pSrc = (void *)&m_dataIndices[m_head];
-            pDest = (void *)&dwIndicesTemp[0];
-            memcpyUnsafe(pDest, pSrc, numObjRefsToCopy * sizeof(DWORD));
-            pSrc = (void *)&m_dataIndices[0];
-            pDest = (void *)&dwIndicesTemp[numObjRefsToCopy];
-            memcpyUnsafe(pDest, pSrc, (m_count - numObjRefsToCopy) * sizeof(DWORD));
-        }
-
-        DWORD numBytesToCopy = (m_numDataBytes > ((m_currArraySize * MAGIC_FACTOR) - m_dataHead) ? ((m_currArraySize * MAGIC_FACTOR) - m_dataHead) : m_numDataBytes);//(m_currArraySize * MAGIC_FACTOR) - m_dataHead;
-        memcpyNoGCRefs((void *)bTemp, (void *) &m_data[m_dataHead], numBytesToCopy);
-        memcpyNoGCRefs((void *) &bTemp[numBytesToCopy], (void *)m_data, (m_numDataBytes - numBytesToCopy)); 
-    }
-    
-    // Delete old allocation
-    if (m_usingHeap)
-    {
-        delete[] m_data;
-        delete[] m_Objects1;
-        delete[] m_Objects2;
-        delete[] m_Objects3;
-        delete[] m_dataIndices;
-    }
-
-    refTemp.SuppressRelease();
-    refParentTemp.SuppressRelease();
-    refAuxTemp.SuppressRelease();
-    dwIndicesTemp.SuppressRelease();
-    bTemp.SuppressRelease();
-    
-    m_currArraySize = newSize;
-    m_Objects1 = refTemp;
-    m_Objects2 = refParentTemp;
-    m_Objects3 = refAuxTemp;
-    m_dataIndices = dwIndicesTemp;
-    m_data = bTemp;
-    m_head = 0;
-    m_dataHead = 0;
-
-    m_usingHeap = TRUE;
-#ifdef USE_CHECKED_OBJECTREFS
-    for(DWORD i = 0; i < m_currArraySize; i++)
-    {
-        Thread::ObjectRefProtected(&m_Objects1[i]);
-        if (m_Objects2)
-            Thread::ObjectRefProtected(&m_Objects2[i]);
-        if (m_Objects3)
-            Thread::ObjectRefProtected(&m_Objects3[i]);
-    }
-#endif
-}
-
-
-VOID GCScanRootsInCollection(promote_func *fn, ScanContext* sc, void *context)
-{
-    STATIC_CONTRACT_SO_TOLERANT;
-    GCSafeCollection *pObjCollection = (GCSafeCollection *)context;
-    pObjCollection->ReportGCRefs(fn, sc);
-}
-
-VOID
-BeginCloning(ObjectClone *pOC)
-{
-    pOC->Init(FALSE);
-}
-
-VOID
-EndCloning(ObjectClone *pOC)
-{
-    pOC->Cleanup(FALSE);
-}
-
-typedef Holder<ObjectClone*, BeginCloning, EndCloning> ObjectCloneHolder;
-
-
-OBJECTREF ObjectClone::Clone(OBJECTREF refObj, TypeHandle expectedType, AppDomain* fromDomain, AppDomain* toDomain, OBJECTREF refExecutionContext)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        THROWS;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END
-
-    if (refObj == NULL)
-        return NULL;
-
-    if (m_context != ObjectFreezer && refObj->GetMethodTable() == g_pStringClass)
-        return refObj;
-    
-    ObjectCloneHolder ocHolder(this);
-    
-    m_fromDomain = fromDomain;
-    m_toDomain = toDomain;
-
-    m_currObject = refObj;
-    GCPROTECT_BEGIN(m_currObject);
-    m_topObject = NULL;
-    GCPROTECT_BEGIN(m_topObject);
-    m_fromExecutionContext = refExecutionContext;
-    GCPROTECT_BEGIN(m_fromExecutionContext);
-
-    // Enter the domain we're cloning into, if we're not already there
-    ENTER_DOMAIN_PTR(toDomain,ADV_RUNNINGIN);
-    
-    if (!m_securityChecked)
-    {
-        Security::SpecialDemand(SSWT_DEMAND_FROM_NATIVE, SECURITY_SERIALIZATION);
-        m_securityChecked = TRUE;
-    }
-    
-#ifdef _DEBUG
-    DefineFullyQualifiedNameForClass();
-    LOG((LF_REMOTING, LL_INFO100, "Clone. Cloning instance of type %s.\n", 
-        GetFullyQualifiedNameForClassNestedAware(m_currObject->GetMethodTable())));
-#endif
-
-    m_newObject = NULL;
-    GCPROTECT_BEGIN(m_newObject);
-    PTRARRAYREF refValues = NULL;
-    GCPROTECT_BEGIN(refValues);
-    OBJECTREF refParent = NULL;
-    GCPROTECT_BEGIN(refParent);
-
-    QueuedObjectInfo    *currObjFixupInfo = NULL;
-    // For some dynamically sized stack objects
-    void *pTempStackSpace = NULL;
-    DWORD dwCurrStackSpaceSize = 0;
-    
-    // Initialize QOM
-    QueuedObjectInfo topObj;
-    OBJECTREF dummy1, dummy2;
-    QOM.Enqueue(m_currObject, NULL, NULL, (QueuedObjectInfo *)&topObj);
-
-    while ((m_currObject = QOM.Dequeue(&dummy1, &dummy2, &currObjFixupInfo)) != NULL)
-    {
-        m_newObject = NULL;
-        MethodTable *newMT = NULL;
-        
-        BOOL repeatObject = FALSE;
-        BOOL isISerializable = FALSE, isIObjRef = FALSE, isBoxed = FALSE;
-        DWORD ISerializableTSOIndex = (DWORD) -1;
-        DWORD IObjRefTSOIndex = (DWORD) -1;
-        DWORD BoxedValTSOIndex = (DWORD) -1;
-        m_skipFieldScan = FALSE;
-
-        // ALLOCATE PHASE
-
-        // Was currObject seen before ?
-        int currID = TOS.HasID(m_currObject, &m_newObject);
-        if (currID != -1)
-        {
-            // Yes
-            repeatObject = TRUE;
-            m_skipFieldScan = TRUE;
-            newMT = m_newObject->GetMethodTable();
-
-            if (m_cbInterface->IsISerializableType(newMT))
-            {
-                currObjFixupInfo->SetIsISerializableInstance();
-                isISerializable = TRUE;
-                ISerializableTSOIndex = FindObjectInTSO(currID, ISerializable);
-            }
-
-#ifdef _DEBUG
-            LOG((LF_REMOTING, LL_INFO1000, "Clone. Object of type %s with id %d seen before.\n",
-                GetFullyQualifiedNameForClassNestedAware(m_currObject->GetMethodTable()), currID));
-#endif
-        }
-        else
-        {
-#ifdef _DEBUG
-            LOG((LF_REMOTING, LL_INFO1000, "Clone. Object of type %s not seen before.\n",
-                GetFullyQualifiedNameForClassNestedAware(m_currObject->GetMethodTable())));
-#endif
-            // No
-            MethodTable *currMT = m_currObject->GetMethodTable();
-            
-            // Check whether object is serializable
-            m_cbInterface->ValidateFromType(currMT);
-
-            // Add current object to table of seen objects and get an id
-            currID = TOS.AddObject(m_currObject, m_newObject);
-            LOG((LF_REMOTING, LL_INFO1000, "Clone. Current object added to Table of Objects Seen. Given id %d.\n", currID));
-
-            if ( m_cbInterface->IsRemotedType(currMT, m_fromDomain, m_toDomain))
-            {
-                refValues = AllocateISerializable(currID, TRUE);
-                isISerializable = TRUE;
-                ISerializableTSOIndex = TSO.GetCount() - 1;
-                currObjFixupInfo->SetIsISerializableInstance();
-                if (refValues == NULL)
-                {
-                    // We found a smugglable objref. No field scanning needed
-                    m_skipFieldScan = TRUE;
-                }
-            }
-            else if( m_cbInterface->IsISerializableType(currMT))
-            {
-                InvokeVtsCallbacks(m_currObject, RemotingVtsInfo::VTS_CALLBACK_ON_SERIALIZING, fromDomain);
-                if (HasVtsCallbacks(m_currObject->GetMethodTable(), RemotingVtsInfo::VTS_CALLBACK_ON_SERIALIZED))
-                    VSC.Enqueue(m_currObject, NULL, NULL, NULL);
-
-                refValues = AllocateISerializable(currID, FALSE);
-                isISerializable = TRUE;
-                ISerializableTSOIndex = TSO.GetCount() - 1;
-                currObjFixupInfo->SetIsISerializableInstance();
-            }
-            else if (currMT->IsArray())
-            {
-                AllocateArray();
-            }
-            else
-            {
-                // This is a regular object
-                InvokeVtsCallbacks(m_currObject, RemotingVtsInfo::VTS_CALLBACK_ON_SERIALIZING, fromDomain);
-                if (HasVtsCallbacks(m_currObject->GetMethodTable(), RemotingVtsInfo::VTS_CALLBACK_ON_SERIALIZED))
-                    VSC.Enqueue(m_currObject, NULL, NULL, NULL);
-
-                AllocateObject();
-
-                if (m_cbInterface->IsISerializableType(m_newObject->GetMethodTable()))
-                {
-                    // We have a situation where the serialized instnce was not ISerializable, 
-                    // but the target instance is. So we make the from object look like a ISerializable
-                    refValues = MakeObjectLookLikeISerializable(currID);
-                    isISerializable = TRUE;
-                    ISerializableTSOIndex = TSO.GetCount() - 1;
-                    currObjFixupInfo->SetIsISerializableInstance();
-                }
-            }
-
-            _ASSERTE(m_newObject != NULL);
-            newMT = m_newObject->GetMethodTable();
-            
-            // Check whether new object is serializable
-            m_cbInterface->ValidateToType(newMT);
-            
-            // Update the TOS, to include the new object
-            int retId;
-            retId = TOS.UpdateObject(m_currObject, m_newObject);
-            _ASSERTE(retId == currID);
-        }
-        _ASSERTE(m_newObject != NULL);
-
-        // FIXUP PHASE
-        // Get parent to be fixed up
-        ParentInfo *parentInfo;
-        refParent = QOF.Peek(&dummy1, &dummy2, (QueuedObjectInfo **)&parentInfo);
-        MethodTable *pParentMT = NULL;
-        
-        if (refParent == NULL)
-        {
-            LOG((LF_REMOTING, LL_INFO1000, "Clone. No parent found. This is the top object.\n"));
-            // This is the top object
-            _ASSERTE(m_topObject == NULL);
-            m_topObject = m_newObject;
-        }
-        else
-        {
-#ifdef _DEBUG
-            LOG((LF_REMOTING, LL_INFO1000, "Clone. Parent is of type %s.\n",
-                GetFullyQualifiedNameForClassNestedAware(m_currObject->GetMethodTable())));
-#endif
-            pParentMT = refParent->GetMethodTable();
-        }
-
-        if (IsDelayedFixup(newMT, currObjFixupInfo))
-        {
-            // New object is IObjRef or a boxed object
-            if (m_cbInterface->IsIObjectReferenceType(newMT))
-            {
-                LOG((LF_REMOTING, LL_INFO1000, "Clone. This is an IObjectReference. Delaying fixup.\n"));
-                DWORD size = sizeof(IObjRefInstanceInfo) + (currObjFixupInfo ? currObjFixupInfo->GetSize() : 0);
-                if (size > dwCurrStackSpaceSize)
-                {
-                    pTempStackSpace = _alloca(size);
-                    dwCurrStackSpaceSize = size;
-                }
-                IObjRefInstanceInfo *pIORInfo = new (pTempStackSpace) IObjRefInstanceInfo(currID, 0, 0);
-                if (currObjFixupInfo)
-                    pIORInfo->SetFixupInfo(currObjFixupInfo);
-                // Check if this instance is ISerializable also
-                if (isISerializable)
-                {
-                    LOG((LF_REMOTING, LL_INFO1000, "Clone. This is also an ISerializable type at index %d in TSO.\n", ISerializableTSOIndex));
-                    _ASSERTE(ISerializableTSOIndex != (DWORD) -1);
-                    pIORInfo->SetISerTSOIndex(ISerializableTSOIndex);
-                }
-
-                if (repeatObject)
-                    pIORInfo->SetIsRepeatObject();
-                
-                // Add to TSO
-                TSO.Push(m_newObject, m_currObject, refParent, pIORInfo);
-
-                isIObjRef = TRUE;
-                IObjRefTSOIndex = TSO.GetCount() - 1;
-
-                LOG((LF_REMOTING, LL_INFO1000, "Clone. Added to TSO at index %d.\n", IObjRefTSOIndex));
-                // Any special object parent, would wait till the current object is resolved
-                if (parentInfo)
-                {
-                    parentInfo->IncrementSpecialMembers();
-                    TMappings.Add(IObjRefTSOIndex);
-                }
-
-            }
-            if (currObjFixupInfo->NeedsUnboxing())
-            {
-                LOG((LF_REMOTING, LL_INFO1000, "Clone. This is a boxed value type. Delaying fixup.\n"));
-                DWORD size = sizeof(ValueTypeInfo) + currObjFixupInfo->GetSize();
-                if (size > dwCurrStackSpaceSize)
-                {
-                    pTempStackSpace = _alloca(size);
-                    dwCurrStackSpaceSize = size;
-                }
-                ValueTypeInfo *valInfo = new (pTempStackSpace) ValueTypeInfo(currID, currObjFixupInfo);
-                // If the value type is also ISer or IObj, then it has to wait till those interfaces are addressed
-                if (isISerializable)
-                {
-                    LOG((LF_REMOTING, LL_INFO1000, "Clone. This is also an ISerializable type at index %d in TSO.\n", ISerializableTSOIndex));
-                    valInfo->SetISerTSOIndex(ISerializableTSOIndex);
-                }
-                if (isIObjRef)
-                {
-                    LOG((LF_REMOTING, LL_INFO1000, "Clone. This is also an IObjectReference type at index %d in TSO.\n", IObjRefTSOIndex));
-                    valInfo->SetIObjRefTSOIndex(IObjRefTSOIndex);
-                }
-
-                // Add to TSO
-                TSO.Push(m_newObject, refParent, NULL, valInfo);
-
-                isBoxed = TRUE;
-                BoxedValTSOIndex = TSO.GetCount() - 1;
-
-                LOG((LF_REMOTING, LL_INFO1000, "Clone. Added to TSO at index %d.\n", BoxedValTSOIndex));
-                // An IObjRef parent, or a parent itself boxed, would wait till the current object is resolved
-                if (parentInfo && (parentInfo->NeedsUnboxing() || parentInfo->IsIObjRefInstance()))
-                {
-                    parentInfo->IncrementSpecialMembers();
-                    TMappings.Add(BoxedValTSOIndex);
-                }
-            }
-        }
-
-        if (refParent != NULL)
-        {
-            if (!IsDelayedFixup(newMT, currObjFixupInfo))
-                Fixup(m_newObject, refParent, currObjFixupInfo);
-            
-            // If currObj is ISer, then an IObjRef parent would wait till the current object is resolved
-            if (currObjFixupInfo->IsISerializableInstance() && 
-                parentInfo->IsIObjRefInstance())
-            {
-                parentInfo->IncrementSpecialMembers();
-                TMappings.Add(ISerializableTSOIndex);
-            }
-        }
-
-        // If we are done with this parent, remove it from QOF
-        if (parentInfo && parentInfo->DecrementFixupCount() == 0)
-        {
-            LOG((LF_REMOTING, LL_INFO1000, "Clone. All children fixed up. Removing parent from QOF.\n", BoxedValTSOIndex));
-            LOG((LF_REMOTING, LL_INFO1000, "Clone. Parent has %d special member objects.\n", parentInfo->GetNumSpecialMembers()));
-            OBJECTREF refTemp;
-            ParentInfo *pFITemp;
-            refTemp = QOF.Dequeue(&dummy1, &dummy2, (QueuedObjectInfo **)&pFITemp);
-            _ASSERTE(refTemp == refParent);
-            _ASSERTE(pFITemp == parentInfo);
-
-            // If parent is a special object, then we need to know how many special members it has
-            if ((parentInfo->IsIObjRefInstance() || 
-                parentInfo->IsISerializableInstance() || 
-                parentInfo->NeedsUnboxing()) 
-                && parentInfo->GetNumSpecialMembers() > 0)
-            {
-                // Make a note in TSO that this parent has non-zero special members
-                DWORD index[3];
-                index[0] = parentInfo->GetIObjRefIndexIntoTSO();
-                index[1] = parentInfo->GetISerIndexIntoTSO();
-                index[2] = parentInfo->GetBoxedValIndexIntoTSO();
-
-                for (DWORD count = 0; count < 3; count++)
-                {
-                    OBJECTREF refIser, refNames, refValuesTemp;
-                    SpecialObjectInfo *pISerInfo;
-
-                    if (index[count] == (DWORD) -1)
-                        continue;
-                    
-                    refIser = TSO.GetAt(index[count], &refNames, &refValuesTemp, (QueuedObjectInfo **)&pISerInfo);
-                    _ASSERTE(refIser == refParent);
-                    
-                    DWORD numSpecialObjects = parentInfo->GetNumSpecialMembers();
-                    pISerInfo->SetNumSpecialMembers(numSpecialObjects);
-
-                    _ASSERTE(TMappings.GetCount() >= numSpecialObjects);
-                    pISerInfo->SetMappingTableIndex(TMappings.GetCount() - numSpecialObjects);
-                }
-            }
-        }
-
-        // FIELD SCAN PHASE
-        if (!m_skipFieldScan)
-        {
-            if (m_currObject->GetMethodTable()->IsArray())
-                ScanArrayMembers();
-            else if (isISerializable)
-                ScanISerializableMembers(IObjRefTSOIndex, ISerializableTSOIndex, BoxedValTSOIndex, refValues);
-            else
-                ScanMemberFields(IObjRefTSOIndex, BoxedValTSOIndex);
-        }
-
-    } // While there are objects in QOM
-
-    // OBJECT COMPLETION PHASE
-    CompleteSpecialObjects();
-
-    // Deliver VTS OnDeserialized callbacks.
-    CompleteVtsOnDeserializedCallbacks();
-
-    CompleteIDeserializationCallbacks();
-
-    _ASSERTE(m_topObject != NULL);
-    // If a type check was requested, see if the returned object is of the expected type
-    if (!expectedType.IsNull()
-        && !ObjIsInstanceOf(OBJECTREFToObject(m_topObject), expectedType))
-        COMPlusThrow(kArgumentException,W("Arg_ObjObj"));
-    
-    GCPROTECT_END(); // refParent
-    GCPROTECT_END(); // refValues 
-    
-    GCPROTECT_END(); // m_newObject
-    
-    END_DOMAIN_TRANSITION;
-
-    // Deliver VTS OnSerialized callbacks.
-    CompleteVtsOnSerializedCallbacks();
-
-    GCPROTECT_END(); // m_fromExecutionContext
-    GCPROTECT_END(); // m_topObject
-    GCPROTECT_END(); // m_currObject 
-
-    return m_topObject;
-}
-
-// IObjRef and value types boxed by us, need to be fixed up towards the end
-BOOL ObjectClone::IsDelayedFixup(MethodTable *newMT, QueuedObjectInfo *pCurrInfo)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END
-    if (m_cbInterface->IsIObjectReferenceType(newMT) ||
-        pCurrInfo->NeedsUnboxing())
-        return TRUE;
-    else
-        return FALSE;
-}
-
-void ObjectClone::Fixup(OBJECTREF newObj, OBJECTREF refParent, QueuedObjectInfo *pFixupInfo)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END
-    MethodTable *pParentMT = refParent->GetMethodTable();
-    
-    if (pFixupInfo->IsISerializableMember())
-    {
-        HandleISerializableFixup(refParent, pFixupInfo);
-    }
-    else if (pParentMT->IsArray())
-    {
-        HandleArrayFixup(refParent, pFixupInfo);
-    }
-    else
-    {
-        HandleObjectFixup(refParent, pFixupInfo);
-    }
-}
-
-PTRARRAYREF ObjectClone::MakeObjectLookLikeISerializable(int objectId)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        THROWS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END
-
-    _ASSERTE(m_context != ObjectFreezer);
-    
-    LOG((LF_REMOTING, LL_INFO1000, "MakeObjectLookLikeISerializable. Target object is ISerializable, so making from object look ISerializable\n"));
-    MethodTable *pCurrMT = m_currObject->GetMethodTable();
-    DWORD numFields = pCurrMT->GetNumInstanceFields();
-
-    PTRARRAYREF fieldNames = NULL;
-    PTRARRAYREF fieldValues = NULL;
-
-    GCPROTECT_BEGIN(fieldNames);
-    GCPROTECT_BEGIN(fieldValues);
-
-    // Go back to from domain
-    ENTER_DOMAIN_PTR(m_fromDomain,ADV_RUNNINGIN);
-
-    // Reset the execution context to the original state it was in when we first
-    // left the from domain (this will automatically be popped once we return
-    // from this domain again).
-    Thread *pThread = GetThread();
-    if (pThread->IsExposedObjectSet())
-    {
-        THREADBASEREF refThread = (THREADBASEREF)pThread->GetExposedObjectRaw();
-        refThread->SetExecutionContext(m_fromExecutionContext);
-    }
-
-    fieldNames = (PTRARRAYREF)AllocateObjectArray(numFields, g_pStringClass, FALSE);
-    fieldValues = (PTRARRAYREF)AllocateObjectArray(numFields, g_pObjectClass, FALSE);
-
-    DWORD fieldIndex = 0;
-    while (pCurrMT)
-    {
-
-        DWORD numInstanceFields = pCurrMT->GetNumIntroducedInstanceFields();
-
-        FieldDesc *pFields = pCurrMT->GetApproxFieldDescListRaw();
-        
-        for (DWORD i = 0; i < numInstanceFields; i++)
-        {
-            if (pFields[i].IsNotSerialized())
-            {
-                LOG((LF_REMOTING, LL_INFO1000, "MakeObjectLookLikeISerializable. Field %s is marked NonSerialized. Skipping.\n", pFields[i].GetName()));
-                continue;
-            }
-            
-            CorElementType typ = pFields[i].GetFieldType();
-            DWORD offset = pFields[i].GetOffset();
-
-            LPCUTF8 szFieldName = pFields[i].GetName();
-            STRINGREF refName = StringObject::NewString(szFieldName);
-            _ASSERTE(refName != NULL);
-
-            fieldNames->SetAt(fieldIndex, refName);
-            
-            switch (typ)
-            {
-                case ELEMENT_TYPE_BOOLEAN:
-                case ELEMENT_TYPE_I1:
-                case ELEMENT_TYPE_U1:
-                case ELEMENT_TYPE_I2:
-                case ELEMENT_TYPE_U2:
-                case ELEMENT_TYPE_CHAR:
-                case ELEMENT_TYPE_I4:
-                case ELEMENT_TYPE_U4:
-                case ELEMENT_TYPE_I8:
-                case ELEMENT_TYPE_U8:
-                case ELEMENT_TYPE_I:
-                case ELEMENT_TYPE_U:
-                case ELEMENT_TYPE_R4:
-                case ELEMENT_TYPE_R8:
-                {
-                    MethodTable *pFldMT = MscorlibBinder::GetElementType(typ);
-                    void *pData = m_currObject->GetData() + offset;
-                    OBJECTREF refBoxed = pFldMT->Box(pData);
-
-                    fieldValues->SetAt(fieldIndex, refBoxed);
-                    break;
-                }
-                case ELEMENT_TYPE_VALUETYPE:
-                case ELEMENT_TYPE_PTR: 
-                case ELEMENT_TYPE_FNPTR:
-                {
-                    TypeHandle th = LoadExactFieldType(&pFields[i], m_currObject, m_fromDomain);
-                    _ASSERTE(!th.AsMethodTable()->IsByRefLike() && "Field types cannot contain stack pointers.");
-
-                    OBJECTREF refBoxed = BoxValueTypeInWrongDomain(m_currObject, offset, th.AsMethodTable());
-
-                    fieldValues->SetAt(fieldIndex, refBoxed);
-                    break;
-                }
-                case ELEMENT_TYPE_SZARRAY:          // Single Dim
-                case ELEMENT_TYPE_ARRAY:            // General Array
-                case ELEMENT_TYPE_CLASS:            // Class
-                case ELEMENT_TYPE_OBJECT:
-                case ELEMENT_TYPE_STRING:           // System.String
-                case ELEMENT_TYPE_VAR:
-                {
-                    OBJECTREF refField = *((OBJECTREF *) m_currObject->GetData() + offset);
-                    fieldValues->SetAt(fieldIndex, refField);
-                    break;
-                }
-                default:
-                    _ASSERTE(!"Unknown element type in MakeObjectLookLikeISerializalbe");
-            }
-
-            fieldIndex++;
-        }
-
-        pCurrMT = pCurrMT->GetParentMethodTable();
-    }
-
-    // Back to original domain      
-    END_DOMAIN_TRANSITION;
-
-    // Add object to TSO
-    ISerializableInstanceInfo iserInfo(objectId, 0);
-    TSO.Push(m_newObject, fieldNames, NULL, (QueuedObjectInfo *)&iserInfo);
-
-    LOG((LF_REMOTING, LL_INFO1000, "MakeObjectLookLikeISerializable. Added to TSO at index %d.\n", TSO.GetCount() - 1));
-    GCPROTECT_END();
-    GCPROTECT_END();
-
-    return fieldValues;
-}
-
-PTRARRAYREF ObjectClone::AllocateISerializable(int objectId, BOOL bIsRemotingObject)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        THROWS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END
-        
-    _ASSERTE(m_context != ObjectFreezer);
-
-    // Go back to from domain
-    StackSString ssAssemName;
-    StackSString ssTypeName;
-
-    struct _gc {
-        STRINGREF   typeName;
-        STRINGREF   assemblyName;
-        PTRARRAYREF fieldNames;
-        PTRARRAYREF fieldValues;
-        OBJECTREF   refObjRef;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc);
-    
-    ENTER_DOMAIN_PTR(m_fromDomain,ADV_RUNNINGIN);
-
-    // Reset the execution context to the original state it was in when we first
-    // left the from domain (this will automatically be popped once we return
-    // from this domain again).
-    Thread *pThread = GetThread();
-    if (pThread->IsExposedObjectSet())
-    {
-        THREADBASEREF refThread = (THREADBASEREF)pThread->GetExposedObjectRaw();
-        refThread->SetExecutionContext(m_fromExecutionContext);
-    }
-
-    // Call GetObjectData on the interface
-
-    LOG((LF_REMOTING, LL_INFO1000, "AllocateISerializable. Instance is ISerializable type. Calling GetObjectData.\n"));
-
-    PREPARE_NONVIRTUAL_CALLSITE(METHOD__OBJECTCLONEHELPER__GET_OBJECT_DATA);
-
-    DECLARE_ARGHOLDER_ARRAY(args, 5);
-
-    args[ARGNUM_0]    = OBJECTREF_TO_ARGHOLDER(m_currObject);
-    args[ARGNUM_1]    = PTR_TO_ARGHOLDER(&gc.typeName);
-    args[ARGNUM_2] = PTR_TO_ARGHOLDER(&gc.assemblyName);
-    args[ARGNUM_3] = PTR_TO_ARGHOLDER(&gc.fieldNames);
-    args[ARGNUM_4] = PTR_TO_ARGHOLDER(&gc.fieldValues);
-
-    CATCH_HANDLER_FOUND_NOTIFICATION_CALLSITE;
-    CALL_MANAGED_METHOD_RETREF(gc.refObjRef, OBJECTREF, args);
-
-    if (!bIsRemotingObject || gc.refObjRef == NULL)
-    {
-        ssAssemName.Set(gc.assemblyName->GetBuffer());
-        ssTypeName.Set(gc.typeName->GetBuffer());
-    }
-
-    // Back to original domain      
-    END_DOMAIN_TRANSITION;
-
-    // if its a remoting object we are dealing with, we may already have the smugglable objref
-    if (bIsRemotingObject && gc.refObjRef != NULL)
-    {
-        m_newObject = gc.refObjRef;
-        // Add object to TSO. We dont need a ISerializable record, because we are smuggling the ObjRef
-        // and so, technically the ISerializable ctor can be considered already called. But we still make an entry in 
-        // TSO and mark it "processed", so repeat references to the same remoting object work correctly
-        ISerializableInstanceInfo iserInfo(objectId, 0);
-        iserInfo.SetHasBeenProcessed();
-        TSO.Push(m_newObject, NULL, NULL, (QueuedObjectInfo *)&iserInfo);
-
-        LOG((LF_REMOTING, LL_INFO1000, "AllocateISerializable. GetObjectData returned smugglable ObjRef. Added dummy record to TSO at index %d.\n", TSO.GetCount() - 1));
-    }
-    else
-    {
-        // Find the type (and choke on any exotics such as arrays, function pointers or generic type definitions).
-        TypeHandle th = GetType(ssTypeName, ssAssemName);
-        if (th.IsTypeDesc() || th.ContainsGenericVariables())
-        {
-            StackSString ssBeforeTypeName, ssAfterTypeName;
-            TypeString::AppendType(ssBeforeTypeName, m_currObject->GetTypeHandle(), TypeString::FormatNamespace | TypeString::FormatFullInst);
-            TypeString::AppendType(ssAfterTypeName, th, TypeString::FormatNamespace | TypeString::FormatFullInst);
-            COMPlusThrow(kSerializationException, IDS_SERIALIZATION_BAD_ISER_TYPE, ssBeforeTypeName.GetUnicode(), ssAfterTypeName.GetUnicode());
-        }
-        MethodTable *pSrvMT = th.AsMethodTable();
-        _ASSERTE(pSrvMT);
-
-#ifdef _DEBUG
-        {
-            DefineFullyQualifiedNameForClass();
-            LPCUTF8 __szTypeName = GetFullyQualifiedNameForClassNestedAware(pSrvMT);
-            LOG((LF_REMOTING, LL_INFO1000, "AllocateISerializable. Allocating instance of type %s.\n", &__szTypeName[0]));
-        }
-#endif
-        // Allocate the object
-        m_newObject = m_cbInterface->AllocateObject(m_currObject, pSrvMT);
-
-        // Add object to TSO
-        ISerializableInstanceInfo iserInfo(objectId, 0);
-        
-        // Check if the target object is ISerializable. If not, we need to treat construction of this object differently
-        if (!m_cbInterface->IsISerializableType(pSrvMT))
-        {
-            iserInfo.SetTargetNotISerializable();
-        }
-        TSO.Push(m_newObject, gc.fieldNames, NULL, (QueuedObjectInfo *)&iserInfo);
-
-        LOG((LF_REMOTING, LL_INFO1000, "AllocateISerializable. Added to TSO at index %d.\n", TSO.GetCount() - 1));
-    }
-    GCPROTECT_END();
-
-    return gc.fieldValues;
-}
-
-void ObjectClone::AllocateArray()
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-        THROWS;
-    }
-    CONTRACTL_END
-
-    LOG((LF_REMOTING, LL_INFO1000, "AllocateArray. Instance is an array type.\n"));
-    MethodTable *pCurrMT = m_currObject->GetMethodTable();
-    _ASSERTE(pCurrMT->IsArray());
-
-    BASEARRAYREF refArray = (BASEARRAYREF)m_currObject;
-    GCPROTECT_BEGIN(refArray);
-        
-    TypeHandle elemTh = refArray->GetArrayElementTypeHandle();
-    CorElementType elemType = refArray->GetArrayElementType();
-    DWORD numComponents = refArray->GetNumComponents();
-
-    TypeHandle __elemTh = GetCorrespondingTypeForTargetDomain(elemTh);
-    _ASSERTE(!__elemTh.IsNull());
-
-    unsigned __rank = pCurrMT->GetRank();
-    TypeHandle __arrayTh = ClassLoader::LoadArrayTypeThrowing(__elemTh, __rank == 1 ? ELEMENT_TYPE_SZARRAY : ELEMENT_TYPE_ARRAY, __rank);
-
-    DWORD __numArgs =  __rank*2;
-    INT32* __args = (INT32*) _alloca(sizeof(INT32)*__numArgs);
-
-    if (__arrayTh.AsArray()->GetInternalCorElementType() == ELEMENT_TYPE_ARRAY)
-    {
-        const INT32* bounds = refArray->GetBoundsPtr();
-        const INT32* lowerBounds = refArray->GetLowerBoundsPtr();
-        for(unsigned int i=0; i < __rank; i++) 
-        {
-            __args[2*i]   = lowerBounds[i];
-            __args[2*i+1] = bounds[i];
-        }
-    }
-    else
-    {
-        __numArgs = 1;
-        __args[0] = numComponents;
-    }
-    m_newObject = m_cbInterface->AllocateArray(m_currObject, __arrayTh, __args, __numArgs, FALSE);
-
-    // Treat pointer as a primitive type (we shallow copy the bits).
-    if (CorTypeInfo::IsPrimitiveType(elemType) || elemType == ELEMENT_TYPE_PTR)
-    {
-        LOG((LF_REMOTING, LL_INFO1000, "AllocateArray. Instance is an array of primitive type. Copying contents.\n"));
-        // Copy contents. 
-        SIZE_T numBytesToCopy = refArray->GetComponentSize() * numComponents;
-        I1ARRAYREF refI1Arr = (I1ARRAYREF)m_newObject;
-        BYTE *pDest = (BYTE *)refI1Arr->GetDirectPointerToNonObjectElements();
-        I1ARRAYREF refFromArr = (I1ARRAYREF)refArray;
-        BYTE *pSrc = (BYTE *)refFromArr->GetDirectPointerToNonObjectElements();
-
-        memcpyNoGCRefs(pDest, pSrc, numBytesToCopy);
-        m_skipFieldScan = TRUE;
-    }
-    else if (elemType == ELEMENT_TYPE_VALUETYPE)
-    {
-        if (!__elemTh.GetMethodTable()->HasFieldsWhichMustBeInited() && RemotableMethodInfo::TypeIsConduciveToBlitting(elemTh.AsMethodTable(), __elemTh.GetMethodTable()))
-        {
-            LOG((LF_REMOTING, LL_INFO1000, "AllocateArray. Instance is an array of value type with no embedded GC type. Copying contents.\n"));
-            // Copy contents. 
-            SIZE_T numBytesToCopy = refArray->GetComponentSize() * numComponents;
-            I1ARRAYREF refI1Arr = (I1ARRAYREF)m_newObject;
-            BYTE *pDest = (BYTE *)refI1Arr->GetDirectPointerToNonObjectElements();
-            I1ARRAYREF refFromArr = (I1ARRAYREF)refArray;
-            BYTE *pSrc = (BYTE *)refFromArr->GetDirectPointerToNonObjectElements();
-
-            memcpyNoGCRefs(pDest, pSrc, numBytesToCopy);
-            m_skipFieldScan = TRUE;
-        }
-    }
-    GCPROTECT_END();
-}
-
-void ObjectClone::AllocateObject()
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-        THROWS;
-    }
-    CONTRACTL_END
-        
-    LOG((LF_REMOTING, LL_INFO1000, "AllocateObject. Instance is a regular object.\n"));
-    MethodTable *pCurrMT = m_currObject->GetMethodTable();
-    _ASSERTE(!pCurrMT->IsArray());
-    _ASSERTE(!pCurrMT->IsMarshaledByRef() && !pCurrMT->IsTransparentProxy());
-    _ASSERTE(!m_cbInterface->IsISerializableType(pCurrMT));
-
-    MethodTable *pCorrespondingMT = GetCorrespondingTypeForTargetDomain(pCurrMT);
-    _ASSERTE(pCorrespondingMT);
-
-    pCorrespondingMT->EnsureInstanceActive();
-    
-    m_newObject =  m_cbInterface->AllocateObject(m_currObject, pCorrespondingMT);
-
-    InvokeVtsCallbacks(m_newObject, RemotingVtsInfo::VTS_CALLBACK_ON_DESERIALIZING, m_toDomain);
-}
-
-// Use this wrapper when the type handle can't be represented as a raw MethodTable (i.e. it's a pointer or array type).
-TypeHandle ObjectClone::GetCorrespondingTypeForTargetDomain(TypeHandle thCli)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-        THROWS;
-    }
-    CONTRACTL_END
-
-    TypeHandle thBaseType = thCli;
-    TypeHandle thSrvType;
-
-    // Strip off any pointer information (and record the depth). We'll put this back later (when we've translated the base type).
-    DWORD dwPointerDepth = 0;
-    while (thBaseType.IsPointer())
-    {
-        dwPointerDepth++;
-        thBaseType = thBaseType.AsTypeDesc()->GetTypeParam();
-    }
-
-    // If we hit an array then we'll recursively translate the element type then build an array type out of it.
-    if (thBaseType.IsArray())
-    {
-        ArrayTypeDesc *atd = (ArrayTypeDesc *)thBaseType.AsTypeDesc();
-        thSrvType = GetCorrespondingTypeForTargetDomain(atd->GetArrayElementTypeHandle());
-        
-        thSrvType = ClassLoader::LoadArrayTypeThrowing(thSrvType, atd->GetInternalCorElementType(), atd->GetRank());
-    }
-    else
-    {
-        // We should have only unshared types if we get here.
-        _ASSERTE(!thBaseType.IsTypeDesc());
-        thSrvType = GetCorrespondingTypeForTargetDomain(thBaseType.AsMethodTable());
-    }
-
-    // Match the level of pointer indirection from the original client type.
-    while (dwPointerDepth--)
-    {
-        thSrvType = thSrvType.MakePointer();
-    }
-
-    return thSrvType;
-}
-
-MethodTable * ObjectClone::GetCorrespondingTypeForTargetDomain(MethodTable *pCliMT)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-        THROWS;
-    }
-    CONTRACTL_END
-        
-    MethodTable *pSrvMT = NULL;
-    if (m_fromDomain == m_toDomain)
-        return pCliMT;
-
-    _ASSERTE(m_context != ObjectFreezer);
-#ifdef _DEBUG
-    SString __ssTypeName;
-    StackScratchBuffer __scratchBuf;
-    if (pCliMT->IsArray())
-        pCliMT->_GetFullyQualifiedNameForClass(__ssTypeName);
-    else
-        pCliMT->_GetFullyQualifiedNameForClassNestedAware(__ssTypeName);
-#endif
-
-    // Take benefit of shared types. If a type is shared, and its assembly has been loaded
-    // in the target domain, go ahead and use the same MT ptr.
-    // The logic is trickier (and more expensive to calculate) for generic types, so skip the optimization there.
-    if (pCliMT->IsDomainNeutral() && !pCliMT->HasInstantiation())
-    {
-        if (pCliMT->GetAssembly()->FindDomainAssembly(m_toDomain))
-        {
-            LOG((LF_REMOTING, LL_INFO1000,
-                "GetCorrespondingTypeForTargetDomain. Type %s is shared. Using same MethodTable.\n", __ssTypeName.GetUTF8(__scratchBuf)));
-            return pCliMT;
-        }
-    }
-
-    pSrvMT = CrossDomainTypeMap::GetMethodTableForDomain(pCliMT, m_fromDomain, m_toDomain);
-    if (pSrvMT)
-    {
-        LOG((LF_REMOTING, LL_INFO1000,
-            "GetCorrespondingTypeForTargetDomain. Found matching type for %s in domain %d from cache.\n", __ssTypeName.GetUTF8(__scratchBuf), m_toDomain));
-        return pSrvMT;
-    }
-    
-    // Need to find the name and lookup in target domain
-    SString ssCliTypeName;
-    if (pCliMT->IsArray())
-    {
-        pCliMT->_GetFullyQualifiedNameForClass(ssCliTypeName);
-    }
-    else if (pCliMT->HasInstantiation())
-    {
-        TypeString::AppendType(ssCliTypeName, TypeHandle(pCliMT), TypeString::FormatNamespace | TypeString::FormatFullInst);
-    }
-    else
-    {
-        pCliMT->_GetFullyQualifiedNameForClassNestedAware(ssCliTypeName);
-    }
-
-    
-    SString ssAssemblyName;
-    pCliMT->GetAssembly()->GetDisplayName(ssAssemblyName);
-
-    // Get the assembly
-    TypeHandle th = GetType(ssCliTypeName, ssAssemblyName);
-
-    if (!pCliMT->IsArray())
-    {
-        pSrvMT = th.AsMethodTable();
-    }  
-    else
-    {
-        _ASSERTE(th.IsArray());
-        TypeDesc *td = th.AsTypeDesc();
-        pSrvMT = td->GetMethodTable();
-    }
-    CrossDomainTypeMap::SetMethodTableForDomain(pCliMT, m_fromDomain, pSrvMT, m_toDomain);
-    LOG((LF_REMOTING, LL_INFO1000,
-        "GetCorrespondingTypeForTargetDomain. Loaded matching type for %s in domain %d. Added to cache.\n", __ssTypeName.GetUTF8(__scratchBuf), m_toDomain));
-    return pSrvMT;
-}
-
-TypeHandle ObjectClone::GetType(const SString &ssTypeName, const SString &ssAssemName)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END;
-
-    Assembly *pAssembly = NULL;
-
-#ifndef OBJECT_CLONER_STRICT_MODE
-    EX_TRY
-#endif
-    {
-        AssemblySpec spec;
-        StackScratchBuffer scratchBuf;
-        HRESULT hr = spec.Init(ssAssemName.GetUTF8(scratchBuf)); 
-        if (SUCCEEDED(hr)) 
-        {
-            pAssembly = spec.LoadAssembly(FILE_ACTIVE);
-        }
-        else
-        {
-            COMPlusThrowHR(hr);
-        }
-    }
-#ifndef OBJECT_CLONER_STRICT_MODE
-    EX_CATCH
-    {
-        if (GET_EXCEPTION()->IsTransient())
-        {
-            EX_RETHROW;
-        }
-
-        DomainAssembly *pDomainAssembly = NULL;
-#ifdef FEATURE_FUSION
-        // If the normal load fails then try loading from a partial assembly name (relaxed serializer rules).
-        pDomainAssembly = LoadAssemblyFromPartialNameHack((SString*)&ssAssemName, TRUE);
-#endif // FEATURE_FUSION
-        if (pDomainAssembly == NULL)
-            COMPlusThrow(kSerializationException, IDS_SERIALIZATION_UNRESOLVED_TYPE,
-                         ssTypeName.GetUnicode(), ssAssemName.GetUnicode());
-        else
-            pAssembly = pDomainAssembly->GetAssembly();
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-#endif
-
-    _ASSERTE(pAssembly);
-
-    TypeHandle th = TypeName::GetTypeFromAssembly(ssTypeName.GetUnicode(), pAssembly);
-
-    if (th.IsNull())
-    {
-        COMPlusThrow(kSerializationException, IDS_SERIALIZATION_UNRESOLVED_TYPE,
-                     ssTypeName.GetUnicode(), ssAssemName.GetUnicode());
-    }
-
-    LOG((LF_REMOTING, LL_INFO1000, "GetType. Loaded type %S from assembly %S in domain %d. \n",
-        ssTypeName.GetUnicode(), ssAssemName.GetUnicode(), m_toDomain->GetId().m_dwId));
-
-    return th;
-}
-
-void ObjectClone::HandleISerializableFixup(OBJECTREF refParent, QueuedObjectInfo *currObjFixupInfo)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-    
-    _ASSERTE(m_context != ObjectFreezer);
-
-    ISerializableMemberInfo *pIsInfo = (ISerializableMemberInfo *)currObjFixupInfo;
-    OBJECTREF refNames, refValues;
-    ISerializableInstanceInfo *dummy;
-    OBJECTREF parent;
-    parent = TSO.GetAt(pIsInfo->GetTableIndex(), &refNames, &refValues, (QueuedObjectInfo **)&dummy);
-    _ASSERTE(parent == refParent);
-    _ASSERTE(dummy->IsISerializableInstance());
-
-    PTRARRAYREF refFields = (PTRARRAYREF)refValues;
-    _ASSERTE(pIsInfo->GetFieldIndex() < refFields->GetNumComponents());
-    refFields->SetAt(pIsInfo->GetFieldIndex(), m_newObject);
-    
-    LOG((LF_REMOTING, LL_INFO1000, "HandleISerializableFixup. Parent is ISerializable. Added field #%d to TSO record at index %d\n", pIsInfo->GetFieldIndex(), pIsInfo->GetTableIndex()));
-}
-
-void ObjectClone::HandleArrayFixup(OBJECTREF refParent, QueuedObjectInfo *currObjFixupInfo)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        THROWS;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END
-        
-    _ASSERTE(refParent->GetMethodTable()->IsArray());    
-    BASEARRAYREF refParentArray = (BASEARRAYREF) refParent;
-    GCPROTECT_BEGIN(refParentArray);
-
-    NDimArrayMemberInfo *pArrInfo = (NDimArrayMemberInfo *)currObjFixupInfo;
-    DWORD *pIndices = pArrInfo->GetIndices();
-
-    TypeHandle arrayElementType = refParentArray->GetArrayElementTypeHandle();
-    MethodTable *pArrayMT = refParentArray->GetMethodTable();
-
-    DWORD Rank                  = pArrayMT->GetRank();
-    SIZE_T Offset               = 0;
-    SIZE_T Multiplier           = 1;
-
-    _ASSERTE(Rank == pArrInfo->GetNumDimensions());
-    
-    for (int i = Rank-1; i >= 0; i--) {
-        INT32 curIndex = pIndices[i];        
-        const INT32 *pBoundsPtr      = refParentArray->GetBoundsPtr();
-        
-        // Bounds check each index
-        // Casting to unsigned allows us to use one compare for [0..limit-1]
-        _ASSERTE((UINT32) curIndex < (UINT32) pBoundsPtr[i]);
-
-        Offset     += curIndex * Multiplier;
-        Multiplier *= pBoundsPtr[i];
-    }
-
-    // The follwing code is loosely based on COMArrayInfo::SetValue
-
-    if (!arrayElementType.IsValueType())
-    {
-        if (!ObjIsInstanceOf(OBJECTREFToObject(m_newObject), arrayElementType))
-            COMPlusThrow(kInvalidCastException,W("InvalidCast_StoreArrayElement"));
-
-        OBJECTREF* pElem = (OBJECTREF*)(refParentArray->GetDataPtr() + (Offset * pArrayMT->GetComponentSize()));
-        SetObjectReference(pElem,m_newObject,GetAppDomain());
-    }
-    else
-    {
-        // value class or primitive type
-        OBJECTREF* pElem = (OBJECTREF*)(refParentArray->GetDataPtr() + (Offset * pArrayMT->GetComponentSize()));
-       if (!arrayElementType.GetMethodTable()->UnBoxInto(pElem, m_newObject))
-                COMPlusThrow(kInvalidCastException, W("InvalidCast_StoreArrayElement"));
-    }
-
-    LOG((LF_REMOTING, LL_INFO1000, "HandleArrayFixup. Parent is an array. Added element at offset %d\n", Offset));
-    GCPROTECT_END();
-}
-
-void ObjectClone::HandleObjectFixup(OBJECTREF refParent, QueuedObjectInfo *currObjFixupInfo)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-        THROWS;
-    }
-    CONTRACTL_END
-    ObjectMemberInfo *pObjInfo = (ObjectMemberInfo *)currObjFixupInfo;
-    FieldDesc *pTargetField = pObjInfo->GetFieldDesc();
-    DWORD offset = pTargetField->GetOffset();
-
-#ifdef _DEBUG
-    MethodTable *pTemp = refParent->GetMethodTable();
-    _ASSERTE(offset < pTemp->GetBaseSize());
-#endif
-
-    GCPROTECT_BEGIN(refParent);
-
-    TypeHandle fldType = LoadExactFieldType(pTargetField, refParent, m_toDomain);
-
-    if (!ObjIsInstanceOf(OBJECTREFToObject(m_newObject), fldType))
-        COMPlusThrow(kArgumentException,W("Arg_ObjObj"));
-
-    OBJECTREF *pDest = (OBJECTREF *) (refParent->GetData() + offset);
-    _ASSERTE(GetAppDomain()==m_toDomain);
-    SetObjectReference(pDest, m_newObject, GetAppDomain());
-
-    GCPROTECT_END();
-    
-    LOG((LF_REMOTING, LL_INFO1000, "HandleObjectFixup. Parent is a regular object. Added field at offset %d\n", offset));
-}
-
-#ifdef OBJECT_CLONER_STRICT_MODE
-static void DECLSPEC_NORETURN ThrowMissingFieldException(FieldDesc *pFD)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-        THROWS;
-    }
-    CONTRACTL_END;
-
-    StackSString szField(SString::Utf8, pFD->GetName());
-
-    StackSString szType;
-    TypeString::AppendType(szType, TypeHandle(pFD->GetApproxEnclosingMethodTable()));
-
-    COMPlusThrow(kSerializationException, 
-                 IDS_SERIALIZATION_MISSING_FIELD,
-                 szField.GetUnicode(),
-                 szType.GetUnicode());
-}
-#endif
-
-void ObjectClone::ScanMemberFields(DWORD IObjRefTSOIndex, DWORD BoxedValTSOIndex)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-        THROWS;
-    }
-    CONTRACTL_END
-    _ASSERTE(m_currObject != NULL);
-    _ASSERTE(m_newObject != NULL);
-    
-    MethodTable *pMT = m_currObject->GetMethodTable();
-    _ASSERTE(!pMT->IsMarshaledByRef() && !pMT->IsTransparentProxy());
-    _ASSERTE(!pMT->IsArray());
-    MethodTable *pTargetMT = m_newObject->GetMethodTable();
-
-    DWORD numFixupsNeeded = 0;
-    
-    if (RemotableMethodInfo::TypeIsConduciveToBlitting(pMT, pTargetMT))
-    {
-        _ASSERTE(pMT->GetAlignedNumInstanceFieldBytes() == pTargetMT->GetAlignedNumInstanceFieldBytes());
-        DWORD numBytes = pMT->GetNumInstanceFieldBytes();
-        BYTE *pFrom = m_currObject->GetData();
-        BYTE *pTo = m_newObject->GetData(); 
-        memcpyNoGCRefs(pTo, pFrom, numBytes);
-        LOG((LF_REMOTING, LL_INFO1000, "ScanMemberFields. Object has no reference type fields. Blitting contents.\n"));
-    }
-    else if (AreTypesEmittedIdentically(pMT, pTargetMT))
-    {
-        LOG((LF_REMOTING, LL_INFO1000, "ScanMemberFields. Object not blittable but types are layed out for easy cloning .\n"));
-        MethodTable *pCurrMT = pMT;
-        MethodTable *pCurrTargetMT = pTargetMT;
-        while (pCurrMT)
-        {
-            DWORD numInstanceFields = pCurrMT->GetNumIntroducedInstanceFields();
-            _ASSERTE(pCurrTargetMT->GetNumIntroducedInstanceFields() == numInstanceFields);
-
-            FieldDesc *pFields = pCurrMT->GetApproxFieldDescListRaw();
-            FieldDesc *pTargetFields = pCurrTargetMT->GetApproxFieldDescListRaw();
-            
-            for (DWORD i = 0; i < numInstanceFields; i++)
-            {
-                if (pFields[i].IsNotSerialized())
-                {
-                    LOG((LF_REMOTING, LL_INFO1000, "ScanMemberFields. Field %s is marked NonSerialized. Skipping.\n", pFields[i].GetName()));
-                    continue;
-                }
-
-                numFixupsNeeded += CloneField(&pFields[i], &pTargetFields[i]);
-            }
-
-            pCurrMT = pCurrMT->GetParentMethodTable();
-            pCurrTargetMT = pCurrTargetMT->GetParentMethodTable();
-        }
-    }
-    else
-    {
-        LOG((LF_REMOTING, LL_INFO1000, "ScanMemberFields. Object type layout is different.\n"));
-
-        // The object types between source and destination have significant differences (some fields may be added, removed or
-        // re-ordered, the type hierarchy may have had layers added or removed). We can still clone the object if every non-optional
-        // field in the destination object can be found and serialized in a type with the same name in the source object. We ignore
-        // fields and entire type layers that have been added in the source object and also any fields or layers that have been
-        // removed as long as they don't include any fields that are mandatory in the destination object. We allow the fields within
-        // a type layer to move around (we key the field by name only, the latter stage of cloning will check type equivalency and
-        // as above we will widen primitive types if necessary). Since it requires significant effort to calculate whether the
-        // objects can be cloned (and then locate corresponding fields in order to do so) we cache a mapping of source object fields
-        // to destination object fields.
-
-        // The following call will return such a mapping (it's an array where each entry is a pointer to a source object field desc
-        // and the entries are in destination field index order, most derived type first, followed by second most derived type
-        // etc.). If a mapping is impossible the method will throw.
-        FieldDesc **pFieldMap = CrossDomainFieldMap::LookupOrCreateFieldMapping(pTargetMT, pMT);
-        DWORD dwMapIndex = 0;
-
-        MethodTable *pDstMT = pTargetMT;
-        while (pDstMT)
-        {
-            FieldDesc *pDstFields = pDstMT->GetApproxFieldDescListRaw();
-            DWORD numInstanceFields = pDstMT->GetNumIntroducedInstanceFields();
-
-            for (DWORD i = 0; i < numInstanceFields; i++)
-            {
-                FieldDesc *pSrcField = pFieldMap[dwMapIndex++];
-
-                // Non-serialized fields in the destination type (or optional fields where the source type doesn't have an
-                // equivalent) don't have a source field desc.
-                if (pSrcField == NULL)
-                    continue;
-
-                numFixupsNeeded += CloneField(pSrcField, &pDstFields[i]);
-            }
-
-            pDstMT = pDstMT->GetParentMethodTable();
-        }
-
-        _ASSERTE(dwMapIndex == pTargetMT->GetNumInstanceFields());
-    }
-
-    if (numFixupsNeeded > 0)
-    {
-        ParentInfo fxInfo(numFixupsNeeded);
-        if (IObjRefTSOIndex != (DWORD) -1)
-        {
-            _ASSERTE(m_cbInterface->IsIObjectReferenceType(pMT));
-            fxInfo.SetIsIObjRefInstance();
-            fxInfo.SetIObjRefIndexIntoTSO(IObjRefTSOIndex);
-        }
-        if (BoxedValTSOIndex != (DWORD) -1)
-        {
-            _ASSERTE(pMT->IsValueType());
-            fxInfo.SetNeedsUnboxing();
-            fxInfo.SetBoxedValIndexIntoTSO(BoxedValTSOIndex);
-        }
-        QOF.Enqueue(m_newObject, NULL, NULL, (QueuedObjectInfo *)&fxInfo);
-        LOG((LF_REMOTING, LL_INFO1000, "ScanMemberFields. Current object had total of %d reference type fields. Adding to QOF.\n", numFixupsNeeded));
-        // Delay calling any OnDeserialized callbacks until the end of the cloning operation (it's difficult to tell when all the
-        // children have been deserialized).
-        if (HasVtsCallbacks(m_newObject->GetMethodTable(), RemotingVtsInfo::VTS_CALLBACK_ON_DESERIALIZED))
-            VDC.Enqueue(m_newObject, NULL, NULL, NULL);
-        if (m_cbInterface->RequiresDeserializationCallback(m_newObject->GetMethodTable()))
-        {
-            LOG((LF_REMOTING, LL_INFO1000, "ScanMemberFields. Adding object to Table of IDeserialization Callbacks\n"));
-            QueuedObjectInfo noInfo;
-            TDC.Enqueue(m_newObject, NULL, NULL, &noInfo);
-        }
-    }
-    else
-    {
-        // This is effectively a leaf node (no complex children) so if the type has a callback for OnDeserialized we'll deliver it
-        // now. This fixes callback ordering for a few more edge cases (e.g. VSW 415611) and is reasonably cheap. We can never do a
-        // perfect job (in the presence of object graph cycles) and a near perfect job (intuitively ordered callbacks for acyclic
-        // object graphs) is prohibitively expensive; so we're stuck with workarounds like this.
-        InvokeVtsCallbacks(m_newObject, RemotingVtsInfo::VTS_CALLBACK_ON_DESERIALIZED, m_toDomain);
-        if (m_cbInterface->RequiresDeserializationCallback(m_newObject->GetMethodTable()))
-            MakeIDeserializationCallback(m_newObject);
-    }
-}
-
-DWORD ObjectClone::CloneField(FieldDesc *pSrcField, FieldDesc *pDstField)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-        THROWS;
-    }
-    CONTRACTL_END;
-
-    BOOL bFixupNeeded = FALSE;
-
-    CorElementType srcType = pSrcField->GetFieldType();
-    CorElementType dstType = pDstField->GetFieldType();
-    DWORD srcOffset = pSrcField->GetOffset();
-    DWORD dstOffset = pDstField->GetOffset();
-
-    BOOL bUseWidenedValue = FALSE;
-    ARG_SLOT fieldData = 0;
-    if (srcType != dstType)
-    {
-        void *pData = m_currObject->GetData() + srcOffset;
-
-        MethodTable *pSrcFieldMT = NULL;
-        if (CorTypeInfo::IsPrimitiveType(srcType))
-            pSrcFieldMT = MscorlibBinder::GetElementType(srcType);
-        else
-            pSrcFieldMT = LoadExactFieldType(pSrcField, m_currObject, m_fromDomain).AsMethodTable();
-
-        LOG((LF_REMOTING, LL_INFO1000, "ScanMemberFields. Field %s has differing types at source and destination. Will try to convert.\n", pSrcField->GetName()));
-        fieldData = HandleFieldTypeMismatch(dstType, srcType, pData, pSrcFieldMT);
-        bUseWidenedValue = TRUE;
-    }
-                
-    switch (dstType)
-    {
-    case ELEMENT_TYPE_I1:
-    case ELEMENT_TYPE_U1:
-    case ELEMENT_TYPE_BOOLEAN:
-        {
-            BYTE *pDest = m_newObject->GetData() + dstOffset;
-            if (bUseWidenedValue)
-                *pDest = (unsigned char) fieldData;
-            else
-            {
-                BYTE *pByte = m_currObject->GetData() + srcOffset;
-                *pDest = *pByte;
-            }
-        }
-        break;
-    case ELEMENT_TYPE_I2:
-    case ELEMENT_TYPE_U2:
-    case ELEMENT_TYPE_CHAR:
-        {
-            WORD *pDest = (WORD*)(m_newObject->GetData() + dstOffset);
-            if (bUseWidenedValue)
-                *pDest = (short) fieldData;
-            else
-            {
-                WORD *pWord = (WORD*)(m_currObject->GetData() + srcOffset);
-                *(pDest) = *pWord;
-            }
-        }
-        break;
-    case ELEMENT_TYPE_I4:
-    case ELEMENT_TYPE_U4:
-    case ELEMENT_TYPE_R4:
-    IN_WIN32(case ELEMENT_TYPE_FNPTR:)
-    IN_WIN32(case ELEMENT_TYPE_I:)
-    IN_WIN32(case ELEMENT_TYPE_U:)
-        {
-            DWORD *pDest = (DWORD*)(m_newObject->GetData() + dstOffset);
-            if (bUseWidenedValue)
-                *pDest = (int) fieldData;
-            else
-            {
-                DWORD *pDword = (DWORD*)(m_currObject->GetData() + srcOffset);
-                *(pDest) = *pDword;
-            }
-        }
-        break;
-    case ELEMENT_TYPE_R8:
-    case ELEMENT_TYPE_I8:
-    case ELEMENT_TYPE_U8:
-    IN_WIN64(case ELEMENT_TYPE_FNPTR:)
-    IN_WIN64(case ELEMENT_TYPE_I:)
-    IN_WIN64(case ELEMENT_TYPE_U:)
-        {
-            INT64 *pDest = (INT64*)(m_newObject->GetData() + dstOffset);
-            if (bUseWidenedValue)
-                *pDest = fieldData;
-            else
-            {
-                INT64 *pLong = (INT64*)(m_currObject->GetData() + srcOffset);
-                *(pDest) = *pLong;
-            }
-        }
-        break;
-    case ELEMENT_TYPE_PTR:
-        {
-            void **pDest = (void**)(m_newObject->GetData() + dstOffset);
-            void **pPtr = (void**)(m_currObject->GetData() + srcOffset);
-            *(pDest) = *pPtr;
-        }
-        break;
-    case ELEMENT_TYPE_STRING:
-    case ELEMENT_TYPE_CLASS: // objectrefs
-    case ELEMENT_TYPE_OBJECT:
-    case ELEMENT_TYPE_SZARRAY:      // single dim, zero
-    case ELEMENT_TYPE_ARRAY:        // all other arrays
-        {
-            OBJECTREF *pSrc = (OBJECTREF *)(m_currObject->GetData() + srcOffset);
-            OBJECTREF *pDest = (OBJECTREF *)(m_newObject->GetData() + dstOffset);
-
-            if ((*pSrc) == NULL)
-                break;
-
-            // If no deep copy is required, just copy the reference
-            if (!m_cbInterface->RequiresDeepCopy(*pSrc))
-            {
-                _ASSERTE(GetAppDomain()==m_toDomain);
-                SetObjectReference(pDest, *pSrc, GetAppDomain());
-                break;
-            }
-                            
-            // Special case String
-            if ((*pSrc)->GetMethodTable() == g_pStringClass)
-            {
-                // Better check the destination really expects a string (or maybe an object).
-                TypeHandle thDstField = LoadExactFieldType(pDstField, m_newObject, m_toDomain);
-                if (thDstField != TypeHandle(g_pStringClass) && thDstField != TypeHandle(g_pObjectClass))
-                    COMPlusThrow(kArgumentException, W("Arg_ObjObj"));
-
-                STRINGREF refStr = (STRINGREF) *pSrc;
-                refStr = m_cbInterface->AllocateString(refStr);
-                // Get dest addr again, as a GC might have occurred
-                pDest = (OBJECTREF *)(m_newObject->GetData() + dstOffset);
-                _ASSERTE(GetAppDomain()==m_toDomain);
-                SetObjectReference(pDest, refStr, GetAppDomain());
-                                
-                break;
-            }
-
-            // Add the object to QOM
-            LOG((LF_REMOTING, LL_INFO1000, "ScanMemberFields. Adding object in field %s to Queue of Objects to be Marshalled.\n", pSrcField->GetName()));
-            ObjectMemberInfo objInfo(pDstField);
-            bFixupNeeded = TRUE;
-            QOM.Enqueue(*pSrc, NULL, NULL, (QueuedObjectInfo *)&objInfo);
-        }
-        break;
-                    
-    case ELEMENT_TYPE_VALUETYPE:
-        {
-            TypeHandle th = LoadExactFieldType(pSrcField, m_currObject, m_fromDomain);
-            _ASSERTE(!th.AsMethodTable()->IsByRefLike() && "Field types cannot contain stack pointers.");
-
-            TypeHandle thTarget = LoadExactFieldType(pDstField, m_newObject, m_toDomain);
-
-            MethodTable *pValueClassMT = th.AsMethodTable();
-            MethodTable *pValueClassTargetMT = thTarget.AsMethodTable();
-            if (!RemotableMethodInfo::TypeIsConduciveToBlitting(pValueClassMT, pValueClassTargetMT))
-            {
-                // Needs marshalling
-                // We're allocating an object in the "to" domain 
-                // using a type from the "from" domain. 
-                OBJECTREF refTmpBox = BoxValueTypeInWrongDomain(m_currObject, srcOffset, pValueClassMT);
-
-                // Nullable<T> might return null here.  In that case we don't need to do anything
-                // and the null value otherwise confuxes the fixup queue. 
-                if (refTmpBox != NULL) 
-                {
-                    // Add the object to QOM
-                    ObjectMemberInfo objInfo(pDstField);
-                    objInfo.SetNeedsUnboxing();
-                    bFixupNeeded = TRUE;
-                    QOM.Enqueue(refTmpBox, NULL, NULL, (QueuedObjectInfo *)&objInfo);
-                    LOG((LF_REMOTING, LL_INFO1000, "ScanMemberFields. Value type field %s has reference type contents. Boxing and adding to QOM.\n", pSrcField->GetName()));
-                }
-            }
-            else
-            {
-                DWORD numBytesToCopy = th.AsMethodTable()->GetNumInstanceFieldBytes();
-                BYTE *pByte = m_currObject->GetData() + srcOffset;
-                BYTE *pDest = m_newObject->GetData() + dstOffset; 
-                memcpyNoGCRefs(pDest, pByte, numBytesToCopy);
-                LOG((LF_REMOTING, LL_INFO1000, "ScanMemberFields. Value type field %s has no reference type contents. Blitting.\n", pSrcField->GetName()));
-            }
-        }
-        break;
-    default:
-        _ASSERTE(!"Unknown element type seen in ObjectClone::ScanMemberFields");
-        break;
-    }            
-
-    return bFixupNeeded ? 1 : 0;
-}
-
-BOOL ObjectClone::AreTypesEmittedIdentically(MethodTable *pMT1, MethodTable *pMT2)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    // Identical here means that both types have the same hierarchy (depth and names match) and that each level of the hierarchy has
-    // the same fields (by name) at the same index.
-    // We're going to be called quite frequently (once per call to ScanMemberFields) so until we're convinced that caching this
-    // information is worth it we'll just compute the fast cases here and let the rest fall through to the slower technique. The
-    // fast check is that the types are shared and identical or that they're loaded from the same file (in which case we have to be
-    // a little more paranoid and check up the hierarchy).
-    if (pMT1 == pMT2)
-        return TRUE;
-
-    // While the current level of the type is loaded from the same file...
-    // Note that we used to check that the assemblies were the same; now we're more paranoid and check the actual modules scoping
-    // the type are identical. This closes a security hole where identically named types in different modules of the same assembly
-    // could cause the wrong type to be loaded in the server context allowing violation of the type system.
-    while (pMT1->GetModule()->GetFile()->Equals(pMT2->GetModule()->GetFile()))
-    {
-        // Inspect the parents.
-        pMT1 = pMT1->GetParentMethodTable();
-        pMT2 = pMT2->GetParentMethodTable();
-
-        // If the parents are the same shared type (e.g. Object), then we've found a match.
-        if (pMT1 == pMT2)
-            return TRUE;
-
-        // Else check if one of the hierarchies has run out before the other (and therefore can't be equivalent).
-        if (pMT1 == NULL || pMT2 == NULL)
-            return FALSE;
-    }
-
-    return FALSE;
-}
-
-BOOL AreTypesEquivalent(MethodTable *pMT1, MethodTable *pMT2)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-        THROWS;
-    }
-    CONTRACTL_END;
-
-    // Equivalent here is quite a weak predicate. All it means is that the types have the same (fully assembly qualified) name. The
-    // derivation hierarchy is not inspected at all.
-    StackSString szType1;
-    StackSString szType2;
-
-    TypeString::AppendType(szType1, TypeHandle(pMT1), TypeString::FormatNamespace |
-                                                      TypeString::FormatFullInst |
-                                                      TypeString::FormatAssembly |
-                                                      TypeString::FormatNoVersion);
-    TypeString::AppendType(szType2, TypeHandle(pMT2), TypeString::FormatNamespace |
-                                                      TypeString::FormatFullInst |
-                                                      TypeString::FormatAssembly |
-                                                      TypeString::FormatNoVersion);
-
-    return szType1.Equals(szType2);
-}
-
-PtrHashMap *CrossDomainFieldMap::s_pFieldMap = NULL;
-SimpleRWLock *CrossDomainFieldMap::s_pFieldMapLock = NULL;
-
-BOOL CrossDomainFieldMap::CompareFieldMapEntry(UPTR val1, UPTR val2)
-{
-    CONTRACTL {
-        MODE_ANY;
-        NOTHROW;
-        GC_NOTRIGGER;
-        SO_TOLERANT;           
-    }
-    CONTRACTL_END;
-
-    CrossDomainFieldMap::FieldMapEntry *pEntry1 = (CrossDomainFieldMap::FieldMapEntry *)(val1 << 1);
-    CrossDomainFieldMap::FieldMapEntry *pEntry2 = (CrossDomainFieldMap::FieldMapEntry *)val2;
-
-    if (pEntry1->m_pSrcMT == pEntry2->m_pSrcMT &&
-        pEntry1->m_pDstMT == pEntry2->m_pDstMT)
-        return TRUE;
-
-    return FALSE;
-}
-
-CrossDomainFieldMap::FieldMapEntry::FieldMapEntry(MethodTable *pSrcMT, MethodTable *pDstMT, FieldDesc **pFieldMap)
-{
-    WRAPPER_NO_CONTRACT;
-    
-    m_pSrcMT = pSrcMT;
-    m_pDstMT = pDstMT;
-    m_pFieldMap = pFieldMap;
-    BaseDomain *pSrcDomain = pSrcMT->GetDomain();
-    m_dwSrcDomain = pSrcDomain->IsAppDomain() ? ((AppDomain*)pSrcDomain)->GetId() : ADID(0);
-    BaseDomain *pDstDomain = pDstMT->GetDomain();
-    m_dwDstDomain = pDstDomain->IsAppDomain() ? ((AppDomain*)pDstDomain)->GetId() : ADID(0);
-}
-
-static BOOL IsOwnerOfRWLock(LPVOID lock)
-{
-    // @TODO - SimpleRWLock does not have knowledge of which thread gets the writer 
-    // lock, so no way to verify
-    return TRUE;
-}
-
-// Remove any entries in the table that refer to an appdomain that is no longer live.
-void CrossDomainFieldMap::FlushStaleEntries()
-{
-    if (s_pFieldMapLock == NULL || s_pFieldMap == NULL)
-        return;
-
-    SimpleWriteLockHolder swlh(s_pFieldMapLock);
-
-    bool fDeletedEntry = false;
-    PtrHashMap::PtrIterator iter = s_pFieldMap->begin();
-    while (!iter.end())
-    {
-        FieldMapEntry *pEntry = (FieldMapEntry *)iter.GetValue();
-        AppDomainFromIDHolder adFrom(pEntry->m_dwSrcDomain, TRUE);
-        AppDomainFromIDHolder adTo(pEntry->m_dwDstDomain, TRUE);
-        if (adFrom.IsUnloaded() ||
-            adTo.IsUnloaded()) //we do not use ptr for anything
-        {
-#ifdef _DEBUG
-            LPVOID pDeletedEntry =
-#endif
-                s_pFieldMap->DeleteValue(pEntry->GetHash(), pEntry);
-            _ASSERTE(pDeletedEntry == pEntry);
-            delete pEntry;
-            fDeletedEntry = true;
-        }
-        ++iter;
-    }
-
-    if (fDeletedEntry)
-        s_pFieldMap->Compact();
-}
-
-FieldDesc **CrossDomainFieldMap::LookupOrCreateFieldMapping(MethodTable *pDstMT, MethodTable *pSrcMT)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-        THROWS;
-    }
-    CONTRACTL_END;
-
-    // We lazily allocate the reader/writer lock we synchronize access to the hash with.
-    if (s_pFieldMapLock == NULL)
-    {
-        void *pLockSpace = SystemDomain::GetGlobalLoaderAllocator()->GetLowFrequencyHeap()->AllocMem(S_SIZE_T(sizeof(SimpleRWLock)));
-        SimpleRWLock *pLock = new (pLockSpace) SimpleRWLock(COOPERATIVE_OR_PREEMPTIVE, LOCK_TYPE_DEFAULT);
-        
-        if (FastInterlockCompareExchangePointer(&s_pFieldMapLock, pLock, NULL) != NULL)
-            // We lost the race, give up our copy.
-            SystemDomain::GetGlobalLoaderAllocator()->GetLowFrequencyHeap()->BackoutMem(pLockSpace, sizeof(SimpleRWLock));
-    }
-
-    // Now we have a lock we can use to synchronize the remainder of the init.
-    if (s_pFieldMap == NULL)
-    {
-        SimpleWriteLockHolder swlh(s_pFieldMapLock);
-
-        if (s_pFieldMap == NULL)
-        {
-            PtrHashMap *pMap = new (SystemDomain::GetGlobalLoaderAllocator()->GetLowFrequencyHeap()) PtrHashMap();
-            LockOwner lock = {s_pFieldMapLock, IsOwnerOfRWLock};
-            pMap->Init(32, CompareFieldMapEntry, TRUE, &lock);
-            s_pFieldMap = pMap;
-        }
-    }
-    else
-    {
-        // Try getting an existing value first.
-
-        FieldMapEntry sEntry(pSrcMT, pDstMT, NULL);
-
-        SimpleReadLockHolder srlh(s_pFieldMapLock);
-        FieldMapEntry *pFound = (FieldMapEntry *)s_pFieldMap->LookupValue(sEntry.GetHash(), (LPVOID)&sEntry);
-        if (pFound != (FieldMapEntry *)INVALIDENTRY)
-            return pFound->m_pFieldMap;
-    }
-
-    // We couldn't find an existing entry in the hash. Now we must go through the painstaking process of matching fields in the
-    // destination object to their counterparts in the source object. We build an array of pointers to source field descs ordered by
-    // destination type field index (all the fields for the most derived type first, then all the fields for the second most derived
-    // type etc.).
-    NewArrayHolder<FieldDesc*> pFieldMap(new FieldDesc*[pDstMT->GetNumInstanceFields()]);
-    DWORD dwMapIndex = 0;
-
-    // We start with the source and destination types for the object (which we know are equivalent at least in type name). For each
-    // layer of the type hierarchy for the destination object (from the instance type through to Object) we attempt to locate the
-    // corresponding source type in the hierarchy. This is non-trivial since either source or destination type hierarchies may have
-    // added or removed layers. We ignore extra type layers in the source hierarchy and just concentrate on destination type layers
-    // that introduce instance fields that are not marked NotSerializable. For each such layer we first locate the corresponding
-    // source layer (via fully qualified type name) and then map each serialized (and possibly optional) destination field to the
-    // corresponding source field (again by name). We don't allow a field to move around the type hierarchy (i.e. a field defined in
-    // the base class in one version can't move to a derived type in later versions and be recognized as the original field).
-    // Allowing this would introduce all sorts of ambiguity problems (consider the case of private fields all with the same name
-    // implemented at every layer of the type hierarchy).
-
-    bool fFirstPass = true;
-    MethodTable *pCurrDstMT = pDstMT;
-    MethodTable *pCurrSrcMT = pSrcMT;
-    while (pCurrDstMT)
-    {
-        DWORD numInstanceFields = pCurrDstMT->GetNumIntroducedInstanceFields();
-
-        // Skip destination types with no instance fields to clone.
-        if (numInstanceFields == 0)
-        {
-            pCurrDstMT = pCurrDstMT->GetParentMethodTable();
-            // Only safe to skip the source type as well on the first pass (the source version may have eliminated this level of
-            // the type hierarchy).
-            if (fFirstPass)
-                pCurrSrcMT = pCurrSrcMT->GetParentMethodTable();
-            fFirstPass = false;
-            continue;
-        }
-
-        // We need to synchronize the source type with the destination type. This means skipping any source types in the
-        // hierarchy that the destination doesn't know about.
-        MethodTable *pCandidateMT = pCurrSrcMT;
-        while (pCandidateMT)
-        {
-            if (fFirstPass || pCandidateMT == pCurrDstMT || AreTypesEquivalent(pCandidateMT, pCurrDstMT))
-            {
-                // Skip intermediate source types (the destination type didn't know anything about them, so they're surplus
-                // to requirements).
-                pCurrSrcMT = pCandidateMT;
-                break;
-            }
-
-            pCandidateMT = pCandidateMT->GetParentMethodTable();
-        }
-
-#ifdef OBJECT_CLONER_STRICT_MODE
-        // If there's no candidate source type equivalent to the current destination type we need to prove that the destination
-        // type has no mandatory instance fields or throw an exception (since there's no place to fetch the field values from).
-        if (pCandidateMT == NULL)
-        {
-            FieldDesc *pFields = pCurrDstMT->GetApproxFieldDescListRaw();
-            
-            for (DWORD i = 0; i < numInstanceFields; i++)
-            {
-                if (pFields[i].IsNotSerialized() || pFields[i].IsOptionallySerialized())
-                {
-                    pFieldMap[dwMapIndex++] = NULL;
-                    continue;
-                }
-
-                // We've found a field that must be cloned but have no corresponding source-side type to clone it from. Raise an
-                // exception.
-                ThrowMissingFieldException(&pFields[i]);
-            }
-
-            // If we get here we know the current destination type level was effectively a no-op. Move onto the next level.
-            pCurrDstMT = pCurrDstMT->GetParentMethodTable();
-            fFirstPass = false;
-            continue;
-        }
-#else
-        // In lax matching mode we can ignore all fields, even those not marked optional. So the lack of an equivalent type in the
-        // source hierarchy doesn't bother us. Mark all fields as having a default value and then move onto the next level in the
-        // type hierarchy.
-        if (pCandidateMT == NULL)
-        {
-            for (DWORD i = 0; i < numInstanceFields; i++)
-                pFieldMap[dwMapIndex++] = NULL;
-
-            pCurrDstMT = pCurrDstMT->GetParentMethodTable();
-            fFirstPass = false;
-            continue;
-        }
-#endif
-
-        // If we get here we have equivalent types in pCurrDstMT and pCurrSrcMT. Now we need to locate the source field desc
-        // corresponding to every mandatory (and possibly optional) field in the destination type and record it in the field map.
-        DWORD numSrcFields = pCurrSrcMT->GetNumIntroducedInstanceFields();
-        DWORD numDstFields = pCurrDstMT->GetNumIntroducedInstanceFields();
-
-        FieldDesc *pDstFields = pCurrDstMT->GetApproxFieldDescListRaw();
-        FieldDesc *pSrcFields = pCurrSrcMT->GetApproxFieldDescListRaw();
-
-        for (DWORD i = 0; i < numDstFields; i++)
-        {
-            // Non-serialized destination fields aren't filled in from source types.
-            if (pDstFields[i].IsNotSerialized())
-            {
-                pFieldMap[dwMapIndex++] = NULL;
-                continue;
-            }
-
-            // Go look for a field in the source type with the same name.
-            LPCUTF8 szDstFieldName = pDstFields[i].GetName();
-            DWORD j;
-            for (j = 0; j < numSrcFields; j++)
-            {
-                LPCUTF8 szSrcFieldName = pSrcFields[j].GetName();
-                if (strcmp(szDstFieldName, szSrcFieldName) == 0)
-                {
-                    // Check that the field isn't marked NotSerialized (if it is then it's invisible to the cloner).
-                    if (pSrcFields[j].IsNotSerialized())
-                        j = numSrcFields;
-                    break;
-                }
-            }
-
-#ifdef OBJECT_CLONER_STRICT_MODE
-            // If we didn't find a corresponding field it might not be fatal; the field could be optionally serializable from the
-            // destination type's point of view.
-            if (j == numSrcFields)
-            {
-                if (pDstFields[i].IsOptionallySerialized())
-                {
-                    pFieldMap[dwMapIndex++] = NULL;
-                    continue;
-                }
-                // The field was required. Throw an exception.
-                ThrowMissingFieldException(&pDstFields[i]);
-            }
-#else
-            // In lax matching mode we can ignore all fields, even those not marked optional. Simply mark this field as having the
-            // default value.
-            if (j == numSrcFields)
-            {
-                pFieldMap[dwMapIndex++] = NULL;
-                continue;
-            }
-#endif
-
-            // Otherwise we found matching fields (in name at least, type processing is done later).
-            pFieldMap[dwMapIndex++] = &pSrcFields[j];
-        }
-
-        pCurrDstMT = pCurrDstMT->GetParentMethodTable();
-        pCurrSrcMT = pCurrSrcMT->GetParentMethodTable();
-        fFirstPass = false;
-    }
-
-    _ASSERTE(dwMapIndex == pDstMT->GetNumInstanceFields());
-
-    // Now we have a field map we should insert it into the hash.
-    NewHolder<FieldMapEntry> pEntry(new FieldMapEntry(pSrcMT, pDstMT, pFieldMap));
-    PREFIX_ASSUME(pEntry != NULL);
-    pFieldMap.SuppressRelease();
-
-    SimpleWriteLockHolder swlh(s_pFieldMapLock);
-
-    UPTR key = pEntry->GetHash();
-
-    FieldMapEntry *pFound = (FieldMapEntry *)s_pFieldMap->LookupValue(key, (LPVOID)pEntry);
-    if (pFound == (FieldMapEntry *)INVALIDENTRY)
-    {
-        s_pFieldMap->InsertValue(key, (LPVOID)pEntry);
-        pEntry.SuppressRelease();
-        return pFieldMap;
-    }
-    else
-        return pFound->m_pFieldMap;
-}
-
-ARG_SLOT ObjectClone::HandleFieldTypeMismatch(CorElementType dstType, CorElementType srcType, void *pData, MethodTable *pSrcMT)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-        THROWS;
-    }
-    CONTRACTL_END
-    _ASSERTE(m_context != ObjectFreezer);
-    ARG_SLOT data = 0;
-    InvokeUtil::CreatePrimitiveValue(dstType, srcType, pData, pSrcMT, &data);
-    return data;
-}
-
-void ObjectClone::ScanISerializableMembers(DWORD IObjRefTSOIndex, DWORD ISerTSOIndex, DWORD BoxedValTSOIndex, PTRARRAYREF refValues)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-        THROWS;
-    }
-    CONTRACTL_END
-        
-    _ASSERTE(m_context != ObjectFreezer);
-    // Queue the non-primitive types
-    DWORD       numFieldsToBeMarshalled = 0;
-    PTRARRAYREF refNewValues = NULL;
-
-    LOG((LF_REMOTING, LL_INFO1000, "ScanISerializableMembers. Scanning members of ISerializable type object.\n"));
-    GCPROTECT_BEGIN(refValues);
-    
-    refNewValues = (PTRARRAYREF) AllocateObjectArray(refValues->GetNumComponents(), g_pObjectClass, FALSE);
-
-    _ASSERTE(refNewValues != NULL);
-    
-    for (DWORD index = 0; index < refValues->GetNumComponents(); index++)
-    {
-        OBJECTREF refField = refValues->GetAt(index);
-        if (refField == NULL)
-            continue;
-        
-        if (CorTypeInfo::IsPrimitiveType(refField->GetTypeHandle().GetSignatureCorElementType()) ||
-            refField->GetMethodTable() == g_pStringClass)
-        {
-            refNewValues->SetAt(index, refField);
-            continue;
-        }
-
-        ISerializableMemberInfo isInfo(ISerTSOIndex, index);
-        QOM.Enqueue(refField, NULL, NULL, (QueuedObjectInfo *) &isInfo);
-        numFieldsToBeMarshalled++;
-        refNewValues->SetAt(index, NULL);
-        LOG((LF_REMOTING, LL_INFO1000, "ScanISerializableMembers. Member at index %d is reference type. Adding to QOM.\n", index));
-    }
-    GCPROTECT_END();
-    
-    // Update TSO
-    OBJECTREF refNames = NULL, refFields = NULL;
-    QueuedObjectInfo *pDummy;
-    OBJECTREF newObj;
-    newObj = TSO.GetAt(ISerTSOIndex, &refNames, &refFields, &pDummy);
-    _ASSERTE(newObj == m_newObject);
-    
-    TSO.SetAt(ISerTSOIndex, m_newObject, refNames, refNewValues, pDummy);
-
-    if (numFieldsToBeMarshalled > 0)
-    {
-        ParentInfo fxInfo(numFieldsToBeMarshalled);
-        fxInfo.SetIsISerializableInstance();
-        fxInfo.SetIObjRefIndexIntoTSO(IObjRefTSOIndex);
-        fxInfo.SetISerIndexIntoTSO(ISerTSOIndex);
-        fxInfo.SetBoxedValIndexIntoTSO(BoxedValTSOIndex);
-        QOF.Enqueue(m_newObject, NULL, NULL, (QueuedObjectInfo *) &fxInfo);
-        LOG((LF_REMOTING, LL_INFO1000, "ScanISerializableMembers. Current object had total of %d reference type fields. Adding to QOF.\n", numFieldsToBeMarshalled));
-        // Delay calling any OnDeserialized callbacks until the end of the cloning operation (it's difficult to tell when all the
-        // children have been deserialized).
-        if (HasVtsCallbacks(m_newObject->GetMethodTable(), RemotingVtsInfo::VTS_CALLBACK_ON_DESERIALIZED))
-            VDC.Enqueue(m_newObject, NULL, NULL, NULL);
-        if (m_cbInterface->RequiresDeserializationCallback(m_newObject->GetMethodTable()))
-        {
-            LOG((LF_REMOTING, LL_INFO1000, "ScanISerializableMembers. Adding object to Table of IDeserialization Callbacks\n"));
-            QueuedObjectInfo noInfo;
-            TDC.Enqueue(m_newObject, NULL, NULL, &noInfo);
-        }
-    }
-    else
-    {
-        // This is effectively a leaf node (no complex children) so if the type has a callback for OnDeserialized we'll deliver it
-        // now. This fixes callback ordering for a few more edge cases (e.g. VSW 415611) and is reasonably cheap. We can never do a
-        // perfect job (in the presence of object graph cycles) and a near perfect job (intuitively ordered callbacks for acyclic
-        // object graphs) is prohibitively expensive; so we're stuck with workarounds like this.
-        InvokeVtsCallbacks(m_newObject, RemotingVtsInfo::VTS_CALLBACK_ON_DESERIALIZED, m_toDomain);
-        if (m_cbInterface->RequiresDeserializationCallback(m_newObject->GetMethodTable()))
-            MakeIDeserializationCallback(m_newObject);
-    }
-}
-
-void ObjectClone::ScanArrayMembers()
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-        THROWS;
-    }
-    CONTRACTL_END
-#ifdef _DEBUG
-    MethodTable *pCurrMT = m_currObject->GetMethodTable();
-    _ASSERTE(pCurrMT && pCurrMT->IsArray());
-    MethodTable *pNewMT = m_newObject->GetMethodTable();
-    _ASSERTE(pNewMT && pNewMT->IsArray());
-#endif
-
-    LOG((LF_REMOTING, LL_INFO1000, "ScanArrayMembers. Scanning members of array object.\n"));
-    BASEARRAYREF refFromArray = (BASEARRAYREF) m_currObject;
-    BASEARRAYREF refToArray = (BASEARRAYREF) m_newObject;
-
-    GCPROTECT_BEGIN(refFromArray);
-    GCPROTECT_BEGIN(refToArray);
-    
-    TypeHandle toArrayElementType = refToArray->GetArrayElementTypeHandle();
-    DWORD numComponents = refFromArray->GetNumComponents();
-    MethodTable *pArrayMT = refFromArray->GetMethodTable();
-
-    DWORD rank                   = pArrayMT->GetRank();
-    DWORD dwOffset               = 0;
-
-    DWORD *pIndices = (DWORD*) _alloca(sizeof(DWORD) * rank);
-    VOID *pTemp = _alloca(sizeof(NDimArrayMemberInfo) + rank * sizeof(DWORD));
-    NDimArrayMemberInfo *pArrInfo = new (pTemp) NDimArrayMemberInfo(rank);
-    
-    bool boxingObjects = (pArrayMT->GetArrayElementType() == ELEMENT_TYPE_VALUETYPE);
-
-    // Must enter the from domain if we are going to be allocating any non-agile boxes
-    ENTER_DOMAIN_PTR_PREDICATED(m_fromDomain,ADV_RUNNINGIN,boxingObjects);
-
-    if (boxingObjects)
-    {
-        pArrInfo->SetNeedsUnboxing();
-
-        // We may be required to activate value types of array elements, since we 
-        // are going to box them.  Hoist out the required domain transition and 
-        // activation.
-
-        MethodTable *pMT = ((BASEARRAYREF)m_currObject)->GetArrayElementTypeHandle().GetMethodTable();
-        pMT->EnsureInstanceActive();
-    }
-
-    DWORD numFixupsNeeded = 0;
-    for (DWORD i = 0; i < numComponents; i++) 
-    {
-        // The array could be huge. To avoid keeping a pending GC waiting (and maybe timing out) we're going to pulse the GC mode
-        // every so often. Do this more freqeuntly in debug builds, where each iteration through this loop takes considerably
-        // longer.
-#ifdef _DEBUG
-#define COPY_CYCLES 1024
-#else
-#define COPY_CYCLES 8192
-#endif
-        if ((i % COPY_CYCLES) == (COPY_CYCLES - 1))
-            GetThread()->PulseGCMode();
-
-        const INT32 *pBoundsPtr      = refFromArray->GetBoundsPtr();
-        DWORD findIndices = i;
-        for (DWORD rankIndex = rank; rankIndex > 0; rankIndex--)
-        {
-            DWORD numElementsInDimension = pBoundsPtr[rankIndex - 1]; 
-            DWORD quotient = findIndices / numElementsInDimension;
-            DWORD remainder = findIndices % numElementsInDimension;
-            pIndices[rankIndex - 1] = remainder;
-            findIndices = quotient;
-        }
-        
-        pArrInfo->SetIndices(pIndices);
-
-        Object *rv = GetObjectFromArray((BASEARRAYREF *)&m_currObject, dwOffset);
-        if (rv != NULL)
-        {
-            OBJECTREF oRef = ObjectToOBJECTREF(rv);
-
-            if (oRef->GetMethodTable() == g_pStringClass && m_context != ObjectFreezer)
-            {
-                OBJECTREF* pElem = (OBJECTREF*)(refToArray->GetDataPtr() + (dwOffset * pArrayMT->GetComponentSize()));
-                SetObjectReference(pElem,oRef,GetAppDomain());
-            }
-            else
-            {
-                // Add the object to QOM
-                numFixupsNeeded++;
-                QOM.Enqueue(oRef, NULL, NULL, pArrInfo);
-                LOG((LF_REMOTING, LL_INFO1000, "ScanArrayMembers. Element at offset %d is reference type. Adding to QOM.\n", dwOffset));
-            }
-        }
-        dwOffset ++;
-    }
-
-    if (numFixupsNeeded > 0)
-    {
-        ParentInfo fxInfo(numFixupsNeeded);
-        QOF.Enqueue(m_newObject, NULL, NULL, (QueuedObjectInfo *)&fxInfo);
-        LOG((LF_REMOTING, LL_INFO1000, "ScanArrayMembers. Current object had total of %d reference type fields. Adding to QOF.\n", numFixupsNeeded));
-    }
-
-    END_DOMAIN_TRANSITION;
-
-    GCPROTECT_END();
-    GCPROTECT_END();
-}
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4244)
-#endif // _MSC_VER
-Object *ObjectClone::GetObjectFromArray(BASEARRAYREF* arrObj, DWORD dwOffset)
-{
-    CONTRACTL {
-        THROWS;
-        if ((*arrObj)->GetArrayElementTypeHandle().GetMethodTable()->IsValueType()) GC_TRIGGERS; else GC_NOTRIGGER;
-    } CONTRACTL_END;
-
-    // Get the type of the element...
-    switch ((*arrObj)->GetArrayElementType()) {
-
-    case ELEMENT_TYPE_VOID:
-        return NULL;
-
-    case ELEMENT_TYPE_CLASS:        // Class
-    case ELEMENT_TYPE_SZARRAY:      // Single Dim, Zero
-    case ELEMENT_TYPE_ARRAY:        // General Array
-    case ELEMENT_TYPE_STRING:
-    case ELEMENT_TYPE_OBJECT:
-        {
-            _ASSERTE((*arrObj)->GetComponentSize() == sizeof(OBJECTREF));
-            BYTE* pData = ((BYTE*)(*arrObj)->GetDataPtr()) + (dwOffset * sizeof(OBJECTREF));
-            return *(Object **)pData;
-        }
-
-    case ELEMENT_TYPE_VALUETYPE:
-        {
-            MethodTable *pMT = (*arrObj)->GetArrayElementTypeHandle().GetMethodTable();
-            WORD wComponentSize = (*arrObj)->GetComponentSize();
-            BYTE* pData = ((BYTE*)(*arrObj)->GetDataPtr()) + (dwOffset * wComponentSize);
-            return OBJECTREFToObject(pMT->Box(pData));
-        }
-    case ELEMENT_TYPE_BOOLEAN:      // boolean
-    case ELEMENT_TYPE_I1:           // sbyte
-    case ELEMENT_TYPE_U1:
-    case ELEMENT_TYPE_I2:           // short
-    case ELEMENT_TYPE_U2:
-    case ELEMENT_TYPE_CHAR:         // char
-    case ELEMENT_TYPE_I4:           // int
-    case ELEMENT_TYPE_I:
-    case ELEMENT_TYPE_U:
-    case ELEMENT_TYPE_U4:
-    case ELEMENT_TYPE_I8:           // long
-    case ELEMENT_TYPE_U8:
-    case ELEMENT_TYPE_R4:           // float
-    case ELEMENT_TYPE_R8:           // double
-    case ELEMENT_TYPE_PTR:
-        {
-            // Note that this is a cloned version of the value class case above for performance
-
-            // Watch for GC here.  We allocate the object and then
-            //  grab the void* to the data we are going to copy.
-            MethodTable *pMT = (*arrObj)->GetArrayElementTypeHandle().GetMethodTable();
-            OBJECTREF obj = ::AllocateObject(pMT);
-            WORD wComponentSize = (*arrObj)->GetComponentSize();
-            BYTE* pData = ((BYTE*)(*arrObj)->GetDataPtr()) + (dwOffset * wComponentSize);
-            CopyValueClassUnchecked(obj->UnBox(), pData, (*arrObj)->GetArrayElementTypeHandle().GetMethodTable());
-            return OBJECTREFToObject(obj);
-        }
-
-    case ELEMENT_TYPE_END:
-    default:
-        _ASSERTE(!"Unknown array element type");
-    }
-
-    _ASSERTE(!"Should never get here");
-    return NULL;
-}
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif // _MSC_VER: warning C4244
-
-
-void ObjectClone::CompleteValueTypeFields(OBJECTREF newObj, OBJECTREF refParent, QueuedObjectInfo *objInfo)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-        THROWS;
-    }
-    CONTRACTL_END
-
-#ifdef _DEBUG
-    {
-        SString ssTypeName;
-        SString ssParentTypeName;
-        newObj->GetMethodTable()->_GetFullyQualifiedNameForClassNestedAware(ssTypeName);
-        refParent->GetMethodTable()->_GetFullyQualifiedNameForClassNestedAware(ssParentTypeName);
-        LOG((LF_REMOTING, LL_INFO1000, "CompleteValueTypeFields. Fixing up value type field of type %S into parent of type %S.\n",
-            ssTypeName.GetUnicode(), ssParentTypeName.GetUnicode()));
-    }
-#endif
-
-    ValueTypeInfo *pValTypeInfo = (ValueTypeInfo *)objInfo;
-    QueuedObjectInfo *pFixupInfo = pValTypeInfo->GetFixupInfo();
-    PREFIX_ASSUME(pFixupInfo != NULL);
-    
-    _ASSERTE(pFixupInfo->NeedsUnboxing());
-    if (pFixupInfo->IsArray())
-    {
-        m_newObject = newObj;
-        HandleArrayFixup(refParent, pFixupInfo);
-    }
-    else
-    {
-        GCPROTECT_BEGIN(refParent);
-        GCPROTECT_BEGIN(newObj);
-        ObjectMemberInfo *pObjInfo = (ObjectMemberInfo *)pFixupInfo;
-        FieldDesc *pTargetField = pObjInfo->GetFieldDesc();
-
-        TypeHandle fldType = LoadExactFieldType(pTargetField, refParent, m_toDomain);
-        void *pDest = refParent->GetData() + pTargetField->GetOffset();    
-        _ASSERTE(GetAppDomain()==m_toDomain);
-
-        if (!fldType.GetMethodTable()->UnBoxInto(pDest, newObj))
-            COMPlusThrow(kArgumentException,W("Arg_ObjObj"));
-    
-        GCPROTECT_END();
-        GCPROTECT_END();
-    }
-    pValTypeInfo->SetHasBeenProcessed();
-}
-
-void ObjectClone::CompleteSpecialObjects()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-    
-    OBJECTREF nextObj = NULL;
-    OBJECTREF refNames = NULL;
-    OBJECTREF refValues = NULL;
-    SpecialObjectInfo *pObjInfo = NULL;
-
-    GCPROTECT_BEGIN(refNames);
-    GCPROTECT_BEGIN(refValues);
-    
-    DWORD skippedObjects = 0;
-    DWORD numLoops = 0;
-
-    if (TSO.GetCount() == 0)
-        goto EarlyExit;
-
-    LOG((LF_REMOTING, LL_INFO1000, "CompleteSpecialObjects. Beginning.\n"));
-    do
-    {
-        skippedObjects = 0;
-        numLoops++;
-        DWORD index = 0;
-        TSO.BeginEnumeration(&index);
-        while((nextObj = TSO.GetNext(&index, &refNames, &refValues, (QueuedObjectInfo **)&pObjInfo)) != NULL)
-        {
-            if (pObjInfo->HasBeenProcessed())
-                continue;
-            
-            if (pObjInfo->IsISerializableInstance())
-            {
-                _ASSERTE(m_context != ObjectFreezer);
-                
-                LOG((LF_REMOTING, LL_INFO1000, "CompleteSpecialObjects. ISerializable instance at index %d.\n", index));
-                ISerializableInstanceInfo *iserInfo = (ISerializableInstanceInfo *)pObjInfo;
-                if (iserInfo->GetNumSpecialMembers() > 0)
-                {
-                    if (CheckForUnresolvedMembers(iserInfo))
-                    {
-                        LOG((LF_REMOTING, LL_INFO1000, "CompleteSpecialObjects. Skipping ISerializable instance due to unresolved members.\n"));
-                        skippedObjects++;
-                        continue;
-                    }
-                }
-                CompleteISerializableObject(nextObj, refNames, refValues, iserInfo);
-            }
-            else if (pObjInfo->IsIObjRefInstance())
-            {
-                _ASSERTE(m_context != ObjectFreezer);
-                
-                LOG((LF_REMOTING, LL_INFO1000, "CompleteSpecialObjects. IObjectReference instance at index %d.\n", index));
-                IObjRefInstanceInfo *iorInfo = (IObjRefInstanceInfo *)pObjInfo;
-                if (iorInfo->GetNumSpecialMembers() > 0 || 
-                    iorInfo->GetISerTSOIndex() != (DWORD) -1)
-                {
-                    if (CheckForUnresolvedMembers(iorInfo))
-                    {
-                        LOG((LF_REMOTING, LL_INFO1000, "CompleteSpecialObjects. Skipping IObjectReference instance due to unresolved members.\n"));
-                        skippedObjects++;
-                        continue;
-                    }
-                }
-                if (!CompleteIObjRefObject(nextObj, index, iorInfo))
-                    skippedObjects++;
-            }
-            else
-            {
-                _ASSERTE(pObjInfo->IsBoxedObject());
-                LOG((LF_REMOTING, LL_INFO1000, "CompleteSpecialObjects. Boxed valuetype instance at index %d.\n", index));
-                ValueTypeInfo *valTypeInfo = (ValueTypeInfo *)pObjInfo;
-                if (valTypeInfo->GetNumSpecialMembers() > 0 ||
-                    valTypeInfo->GetISerTSOIndex() != (DWORD) -1 ||
-                    valTypeInfo->GetIObjRefTSOIndex() != (DWORD) -1)
-                {
-                    if (CheckForUnresolvedMembers(valTypeInfo))
-                    {
-                        LOG((LF_REMOTING, LL_INFO1000, "CompleteSpecialObjects. Skipping boxed value instance due to unresolved members.\n"));
-                        skippedObjects++;
-                        continue;
-                    }
-                }
-                // If we were waiting on an IObjRef fixup then the target object will have changed.
-                if (valTypeInfo->GetIObjRefTSOIndex() != (DWORD) -1)
-                {
-                    OBJECTREF dummy1, dummy2;
-                    QueuedObjectInfo *dummy3;
-                    nextObj = TSO.GetAt(valTypeInfo->GetIObjRefTSOIndex(), &dummy1, &dummy2, &dummy3);
-                }
-                CompleteValueTypeFields(nextObj, refNames, valTypeInfo);
-            }
-            
-        };
-    } while (skippedObjects > 0 && numLoops < 100);
-
-    if (skippedObjects > 0 && numLoops >= 100)
-    {
-        COMPlusThrow(kSerializationException, IDS_SERIALIZATION_UNRESOLVED_SPECIAL_OBJECT);
-    }
-EarlyExit: ;
-    GCPROTECT_END();
-    GCPROTECT_END();
-}
-
-BOOL ObjectClone::CheckForUnresolvedMembers(SpecialObjectInfo *splInfo)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-    
-    BOOL foundUnresolvedMember = FALSE;
-
-    DWORD mappingIndex = splInfo->GetMappingTableIndex();
-    for (DWORD count = 0; count < splInfo->GetNumSpecialMembers(); count++)
-    {
-        DWORD memberIndex = TMappings.GetAt(mappingIndex++);
-        SpecialObjectInfo *pMemberInfo;
-        OBJECTREF dummy1, dummy2, dummy3;
-        dummy1 = TSO.GetAt(memberIndex, &dummy2, &dummy3, (QueuedObjectInfo **)&pMemberInfo);
-        // An unresolved IObjRef member is a blocker for any special object parent
-        if (pMemberInfo->IsIObjRefInstance() && !pMemberInfo->HasBeenProcessed())
-        {
-            LOG((LF_REMOTING, LL_INFO1000, "CheckForUnresolvedMembers. Found unresolved IObjectReference member at index %d.\n", memberIndex));
-            foundUnresolvedMember = TRUE;
-            break;
-        }
-
-        // An unresolved ISer member is a blocker for IObjRef parent
-        if (pMemberInfo->IsISerializableInstance() && 
-            !pMemberInfo->HasBeenProcessed() &&
-            splInfo->IsIObjRefInstance())
-        {
-            LOG((LF_REMOTING, LL_INFO1000, "CheckForUnresolvedMembers. Found unresolved ISerializable member at index %d.\n", memberIndex));
-            foundUnresolvedMember = TRUE;
-            break;
-        }
-
-        // An unresolved boxed object is a blocker for a boxed parent or an IObjRef parent
-        if (pMemberInfo->IsBoxedObject() && 
-            !pMemberInfo->HasBeenProcessed() &&
-            (splInfo->IsIObjRefInstance() || splInfo->IsBoxedObject()))
-        {
-            LOG((LF_REMOTING, LL_INFO1000, "CheckForUnresolvedMembers. Found unresolved boxed valuetype member at index %d.\n", memberIndex));
-            foundUnresolvedMember = TRUE;
-            break;
-        }
-    }
-
-    // Done checking members. Now check if this instance itself needs some processing
-    // If an instance is both ISer and IObj, then ISer should be processed before IObjRef
-    if (!foundUnresolvedMember && splInfo->IsIObjRefInstance())
-    {
-        IObjRefInstanceInfo *pObjRefInfo = (IObjRefInstanceInfo *)splInfo;
-        if (pObjRefInfo->GetISerTSOIndex() != (DWORD) -1)
-        {
-            // Check if the ISer requirements have been met
-            SpecialObjectInfo *pMemberInfo;
-            OBJECTREF dummy1, dummy2, dummy3;
-            dummy1 = TSO.GetAt(pObjRefInfo->GetISerTSOIndex(), &dummy2, &dummy3, (QueuedObjectInfo **)&pMemberInfo);
-            if (!pMemberInfo->HasBeenProcessed())
-            {
-                LOG((LF_REMOTING, LL_INFO1000, "CheckForUnresolvedMembers. This instance is also ISerializable at index %d. Not resolved yet.\n", pObjRefInfo->GetISerTSOIndex()));
-                foundUnresolvedMember = TRUE;
-            }
-        }
-    }
-
-    // If an instance is ISer, IObj and a boxed value type, then ISer,IObj should be processed before unboxing
-    if (!foundUnresolvedMember && splInfo->IsBoxedObject())
-    {
-        ValueTypeInfo *pValTypeInfo = (ValueTypeInfo *)splInfo;
-        if (pValTypeInfo->GetISerTSOIndex() != (DWORD) -1)
-        {
-            // Check if the ISer requirements have been met
-            SpecialObjectInfo *pMemberInfo;
-            OBJECTREF dummy1, dummy2, dummy3;
-            dummy1 = TSO.GetAt(pValTypeInfo->GetISerTSOIndex(), &dummy2, &dummy3, (QueuedObjectInfo **)&pMemberInfo);
-            if (!pMemberInfo->HasBeenProcessed())
-            {
-                LOG((LF_REMOTING, LL_INFO1000, "CheckForUnresolvedMembers. This instance is also ISerializable at index %d. Not resolved yet.\n", pValTypeInfo->GetISerTSOIndex()));
-                foundUnresolvedMember = TRUE;
-            }
-        }
-        if (!foundUnresolvedMember && pValTypeInfo->GetIObjRefTSOIndex() != (DWORD) -1)
-        {
-            // Check if the ISer requirements have been met
-            SpecialObjectInfo *pMemberInfo;
-            OBJECTREF dummy1, dummy2, dummy3;
-            dummy1 = TSO.GetAt(pValTypeInfo->GetIObjRefTSOIndex(), &dummy2, &dummy3, (QueuedObjectInfo **)&pMemberInfo);
-            if (!pMemberInfo->HasBeenProcessed())
-            {
-                LOG((LF_REMOTING, LL_INFO1000, "CheckForUnresolvedMembers. This instance is also IObjectReference at index %d. Not resolved yet.\n", pValTypeInfo->GetIObjRefTSOIndex()));
-                foundUnresolvedMember = TRUE;
-            }
-        }
-    }
-    return foundUnresolvedMember;
-}
-
-void ObjectClone::CompleteISerializableObject(OBJECTREF IserObj, OBJECTREF refNames, OBJECTREF refValues, ISerializableInstanceInfo *iserInfo)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END
-
-    _ASSERTE(m_context != ObjectFreezer);
-    
-    struct _gc {
-        OBJECTREF   IserObj;
-        OBJECTREF   refNames;
-        OBJECTREF   refValues;
-        OBJECTREF   refSerInfo;
-    } gc;
-
-    gc.IserObj = IserObj;
-    gc.refNames = refNames;
-    gc.refValues = refValues;
-    gc.refSerInfo = NULL;
-
-    GCPROTECT_BEGIN(gc);
-
-#ifdef _DEBUG
-    {
-        DefineFullyQualifiedNameForClass();
-        LOG((LF_REMOTING, LL_INFO1000, "CompleteISerializableObject. Completing ISerializable object of type %s.\n",
-            GetFullyQualifiedNameForClassNestedAware(gc.IserObj->GetMethodTable())));
-    }
-#endif
-
-    BOOL    bIsBoxed = gc.IserObj->GetMethodTable()->IsValueType();
-
-    // StreamingContextData is an out parameter of the managed callback, so it's passed by reference on all platforms.
-    RuntimeMethodHandle::StreamingContextData context = {0}; 
-    
-    PREPARE_NONVIRTUAL_CALLSITE(METHOD__OBJECTCLONEHELPER__PREPARE_DATA);
-
-    DECLARE_ARGHOLDER_ARRAY(args, 4);
-
-    args[ARGNUM_0]    = OBJECTREF_TO_ARGHOLDER(gc.IserObj);
-    args[ARGNUM_1]    = OBJECTREF_TO_ARGHOLDER(gc.refNames);
-    args[ARGNUM_2] = OBJECTREF_TO_ARGHOLDER(gc.refValues);
-    args[ARGNUM_3] = PTR_TO_ARGHOLDER(&context);
-
-    CATCH_HANDLER_FOUND_NOTIFICATION_CALLSITE;
-    CALL_MANAGED_METHOD_RETREF(gc.refSerInfo, OBJECTREF, args);
-
-    if (iserInfo->IsTargetNotISerializable())
-    {
-        // Prepare data would have constructed the object already
-        _ASSERTE(gc.refSerInfo == NULL);
-    }
-    else
-    {
-        _ASSERTE(gc.refSerInfo != NULL);
-        MethodTable *pMT = gc.IserObj->GetMethodTable();
-        _ASSERTE(pMT);
-
-        MethodDesc * pCtor;
-
-#ifdef FEATURE_IMPERSONATION
-        // Deal with the WindowsIdentity class specially by calling an internal
-        // serialization constructor; the public one has a security demand that
-        // breaks partial trust scenarios and is too expensive to assert for.
-        if (MscorlibBinder::IsClass(pMT, CLASS__WINDOWS_IDENTITY))
-            pCtor = MscorlibBinder::GetMethod(METHOD__WINDOWS_IDENTITY__SERIALIZATION_CTOR);
-        else
-#endif
-            pCtor = MemberLoader::FindConstructor(pMT, &gsig_IM_SerInfo_StrContext_RetVoid);
-        
-        if (pCtor == NULL)
-        {
-            DefineFullyQualifiedNameForClassW();
-            COMPlusThrow(kSerializationException, IDS_SERIALIZATION_CTOR_NOT_FOUND,
-                         GetFullyQualifiedNameForClassNestedAwareW(pMT));
-        }
-
-        MethodDescCallSite ctor(pCtor);
-
-        ARG_SLOT argSlots[3];
-            // Nullable<T> does not implement ISerializable.  
-        _ASSERTE(!Nullable::IsNullableType(gc.IserObj->GetMethodTable()));
-        argSlots[0] = (bIsBoxed ? (ARG_SLOT)(SIZE_T)(gc.IserObj->UnBox()) : ObjToArgSlot(gc.IserObj));
-        argSlots[1] = ObjToArgSlot(gc.refSerInfo);
-#if defined(_TARGET_X86_) || defined(_TARGET_ARM_)
-        static_assert_no_msg(sizeof(context) == sizeof(ARG_SLOT));
-        argSlots[2] = *(ARG_SLOT*)(&context);           // StreamingContext is passed by value on x86 and ARM
-#elif defined(_WIN64)
-        static_assert_no_msg(sizeof(context) >  sizeof(ARG_SLOT));
-        argSlots[2] = PtrToArgSlot(&context);           // StreamingContext is passed by reference on WIN64
-#else  // !_TARGET_X86_ && !_WIN64 && !_TARGET_ARM_
-        PORTABILITY_ASSERT("ObjectClone::CompleteISerializableObject() - NYI on this platform");
-#endif // !_TARGET_X86_ && !_WIN64 && !_TARGET_ARM_
-        ctor.CallWithValueTypes(&argSlots[0]);
-    }
-    iserInfo->SetHasBeenProcessed();
-
-    GCPROTECT_END();
-
-}
-
-// FALSE means the object could not be resolved and need to perform more iterations
-BOOL ObjectClone::CompleteIObjRefObject(OBJECTREF IObjRef, DWORD tsoIndex, IObjRefInstanceInfo *iorInfo)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END
-
-    BOOL bResult = FALSE;
-
-    struct _gc {
-        OBJECTREF   IObjRef;
-        OBJECTREF   newObj;
-        OBJECTREF   refParent;
-        OBJECTREF   refFromObj;
-        OBJECTREF   resolvedObject;
-    } gc;
-
-    gc.IObjRef = IObjRef;
-    gc.newObj = NULL;
-    gc.refParent = NULL;
-    gc.refFromObj = NULL;
-    gc.resolvedObject = NULL;
-
-    GCPROTECT_BEGIN(gc);
-
-    _ASSERTE(m_context != ObjectFreezer);
-    // First check if this is a repeat object
-    if (iorInfo->IsRepeatObject())
-    {
-        OBJECTREF dummy;
-        dummy = TSO.GetAt(tsoIndex, &gc.refFromObj, &gc.refParent, (QueuedObjectInfo **)&iorInfo);
-        PREFIX_ASSUME(gc.refFromObj != NULL);
-
-        // Look in the Table of Seen objects whether this IObjRef has been resolved
-        int currId;
-        currId = TOS.HasID(gc.refFromObj, &gc.resolvedObject);
-        _ASSERTE(currId != -1);
-
-        MethodTable *pResolvedMT = gc.resolvedObject->GetMethodTable();
-        if (!pResolvedMT->IsTransparentProxy() && 
-            m_cbInterface->IsIObjectReferenceType(pResolvedMT))
-        {
-            bResult = FALSE;
-        }
-        else
-        {
-#ifdef _DEBUG
-            {
-                DefineFullyQualifiedNameForClass();
-                LOG((LF_REMOTING, LL_INFO1000, "CompleteIObjRefObject. Found IObjectReference object of type %s already resolved.\n",
-                    GetFullyQualifiedNameForClassNestedAware(gc.IObjRef->GetMethodTable())));
-            }
-#endif
-
-            // Yes, its been resolved. 
-            // Fix the object into its parent (unless it requires unboxing, in which case there's another entry in the TSO ready to
-            // do that).
-            QueuedObjectInfo *pFixupInfo = (QueuedObjectInfo *)iorInfo->GetFixupInfo();
-            PREFIX_ASSUME(pFixupInfo != NULL);
-            if (pFixupInfo->NeedsUnboxing())
-            {
-                TSO.SetAt(tsoIndex, gc.resolvedObject, gc.refFromObj, gc.refParent, iorInfo);
-                iorInfo->SetHasBeenProcessed();
-                bResult = TRUE;
-            }
-            else
-            {
-                if (gc.refParent == NULL)
-                    m_topObject = gc.resolvedObject;
-                else
-                {
-                    m_newObject = gc.resolvedObject;
-                    if (pFixupInfo->NeedsUnboxing())
-                        CompleteValueTypeFields(gc.resolvedObject, gc.refParent, pFixupInfo);
-                    else
-                        Fixup(gc.resolvedObject, gc.refParent, pFixupInfo);
-                }
-                iorInfo->SetHasBeenProcessed();
-                bResult = TRUE;
-            }
-        }
-    }
-    else
-    {
-        MethodTable *pMT = gc.IObjRef->GetMethodTable();
-        _ASSERTE(pMT);
-
-        MethodTable *pItf = MscorlibBinder::GetClass(CLASS__IOBJECTREFERENCE);
-        MethodDesc *pMeth = GetInterfaceMethodImpl(pMT, pItf, 0);
-        MethodDescCallSite method(pMeth, &gc.IObjRef);
-   
-        // Ensure Streamingcontext type is loaded. Do not delete this line
-        MethodTable *pMTStreamingContext;
-        pMTStreamingContext = MscorlibBinder::GetClass(CLASS__STREAMING_CONTEXT);
-        _ASSERTE(pMTStreamingContext);
-
-        ARG_SLOT arg[2];
-        arg[0] = ObjToArgSlot(gc.IObjRef);
-
-        RuntimeMethodHandle::StreamingContextData context = { NULL, GetStreamingContextState() };
-#ifdef _WIN64
-        static_assert_no_msg(sizeof(context) > sizeof(ARG_SLOT));
-        arg[1] = PtrToArgSlot(&context);
-#else
-        static_assert_no_msg(sizeof(context) <= sizeof(ARG_SLOT));
-        arg[1] = *(ARG_SLOT*)(&context);
-#endif
-
-        gc.newObj = method.CallWithValueTypes_RetOBJECTREF(&arg[0]);
-
-        INDEBUG(DefineFullyQualifiedNameForClass();)
-
-        _ASSERTE(gc.newObj != NULL);
-        MethodTable *pNewMT = gc.newObj->GetMethodTable();
-        if (!pNewMT->IsTransparentProxy() && 
-            gc.newObj != gc.IObjRef &&
-            m_cbInterface->IsIObjectReferenceType(pNewMT))
-        {
-#ifdef _DEBUG
-            LOG((LF_REMOTING, LL_INFO1000,
-                "CompleteIObjRefObject. GetRealObject on object of type %s returned another IObjectReference. Adding back to TSO.\n",
-                GetFullyQualifiedNameForClassNestedAware(gc.IObjRef->GetMethodTable())));
-#endif
-
-            // Put this back into the table
-            OBJECTREF dummy;
-            dummy = TSO.GetAt(tsoIndex, &gc.refFromObj, &gc.refParent, (QueuedObjectInfo **)&iorInfo);
-            TSO.SetAt(tsoIndex, gc.newObj, gc.refFromObj, gc.refParent, iorInfo);
-            bResult = FALSE;
-        }
-        else
-        {
-#ifdef _DEBUG
-            LOG((LF_REMOTING, LL_INFO1000,
-                "CompleteIObjRefObject. Called GetRealObject on object of type %s. Fixing it up into its parent.\n",
-                GetFullyQualifiedNameForClassNestedAware(gc.IObjRef->GetMethodTable())));
-#endif
-            // Fix the object into its parent (unless it requires unboxing, in which case there's another entry in the TSO ready to
-            // do that).
-            QueuedObjectInfo *pFixupInfo = (QueuedObjectInfo *)iorInfo->GetFixupInfo();
-            OBJECTREF dummy;
-            dummy = TSO.GetAt(tsoIndex, &gc.refFromObj, &gc.refParent, (QueuedObjectInfo **)&iorInfo);
-            if (pFixupInfo->NeedsUnboxing())
-            {
-                TSO.SetAt(tsoIndex, gc.newObj, gc.refFromObj, gc.refParent, iorInfo);
-                iorInfo->SetHasBeenProcessed();
-                bResult = TRUE;
-            }
-            else
-            {
-                if (gc.refParent == NULL)
-                    m_topObject = gc.newObj;
-                else
-                {
-                    m_newObject = gc.newObj;
-                    Fixup(gc.newObj, gc.refParent, pFixupInfo);
-                }
-
-                // Update Table of Seen objects, so that any repeat objects can be updated too
-                TOS.UpdateObject(gc.refFromObj, gc.newObj);
-                iorInfo->SetHasBeenProcessed();
-                bResult = TRUE;
-            }
-        }
-    }
-
-    GCPROTECT_END();
-    return bResult;
-}
-
-void MakeIDeserializationCallback(OBJECTREF refTarget)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END;
-
-    struct _gc {
-        OBJECTREF   refTarget;
-    } gc;
-    gc.refTarget = refTarget;
-
-    GCPROTECT_BEGIN(gc);
-
-    MethodTable *pMT = gc.refTarget->GetMethodTable();
-    _ASSERTE(pMT);
-
-    MethodTable *pItf = MscorlibBinder::GetClass(CLASS__IDESERIALIZATIONCB);
-    MethodDesc *pMeth = GetInterfaceMethodImpl(pMT, pItf, 0);
-    PCODE pCode = pMeth->GetSingleCallableAddrOfCode();
-
-    PREPARE_NONVIRTUAL_CALLSITE_USING_CODE(pCode);
-
-    DECLARE_ARGHOLDER_ARRAY(args, 2);
-
-    args[ARGNUM_0]    = OBJECTREF_TO_ARGHOLDER(gc.refTarget);
-    args[ARGNUM_1]    = NULL;
-
-    CATCH_HANDLER_FOUND_NOTIFICATION_CALLSITE;
-    CALL_MANAGED_METHOD_NORET(args);
-
-    GCPROTECT_END();
-}
-
-void ObjectClone::CompleteIDeserializationCallbacks()
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END
-    OBJECTREF Dummy1 = NULL, Dummy2 = NULL;
-    QueuedObjectInfo *pObjInfo = NULL;
-
-    if (TDC.GetCount() == 0)
-        return;
-    
-    LOG((LF_REMOTING, LL_INFO1000, "CompleteIDeserializationCallbacks. Beginning.\n"));
-
-    OBJECTREF nextObj;
-    while ((nextObj = TDC.Dequeue(&Dummy1, &Dummy2, &pObjInfo)) != NULL)
-    {
-        MakeIDeserializationCallback(nextObj);
-    }
-}
-
-void ObjectClone::CompleteVtsOnDeserializedCallbacks()
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END;
-
-    OBJECTREF nextObj = NULL, Dummy1 = NULL, Dummy2 = NULL;
-
-    if (VDC.GetCount() == 0)
-        return;
-    
-    LOG((LF_REMOTING, LL_INFO1000, "CompleteVtsOnDeserializedCallbacks. Beginning.\n"));
-
-    GCPROTECT_BEGIN(nextObj);
-
-    while ((nextObj = VDC.Dequeue(&Dummy1, &Dummy2, NULL)) != NULL)
-        InvokeVtsCallbacks(nextObj, RemotingVtsInfo::VTS_CALLBACK_ON_DESERIALIZED, m_toDomain);
-
-    GCPROTECT_END();
-}
-
-void ObjectClone::CompleteVtsOnSerializedCallbacks()
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END;
-
-    OBJECTREF nextObj = NULL, Dummy1 = NULL, Dummy2 = NULL;
-
-    if (VSC.GetCount() == 0)
-        return;
-    
-    LOG((LF_REMOTING, LL_INFO1000, "CompleteVtsOnSerializedCallbacks. Beginning.\n"));
-
-    GCPROTECT_BEGIN(nextObj);
-
-    while ((nextObj = VSC.Dequeue(&Dummy1, &Dummy2, NULL)) != NULL)
-        InvokeVtsCallbacks(nextObj, RemotingVtsInfo::VTS_CALLBACK_ON_SERIALIZED, m_fromDomain);
-
-    GCPROTECT_END();
-}
-
-// Does a binary search to find the object with given id, and record of given kind
-DWORD ObjectClone::FindObjectInTSO(int objId, SpecialObjects kind)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        GC_NOTRIGGER;
-        NOTHROW;
-    }
-    CONTRACTL_END
-
-    DWORD lowIndex = 0;
-    DWORD highIndex = TSO.GetCount();
-    DWORD midIndex = highIndex / 2;
-    DWORD firstMatch;
-
-    if (highIndex == 0)
-    {
-        _ASSERTE(!"Special Object unexpectedly not found for given object id\n");
-        return 0; // throw ?
-    }
-
-    SpecialObjectInfo *splInfo = NULL;
-    while (true)
-    {
-        OBJECTREF refParent, refFromObj;
-        OBJECTREF dummy;
-        dummy = TSO.GetAt(midIndex, &refFromObj, &refParent, (QueuedObjectInfo **)&splInfo);
-
-        if (objId < splInfo->GetObjectId())
-        {
-            highIndex = midIndex;
-        }
-        else
-        {
-            if (objId == splInfo->GetObjectId())
-                break;
-            lowIndex = midIndex;
-        }
-
-        DWORD oldIndex = midIndex;
-        midIndex = lowIndex + (highIndex - lowIndex)/2;
-        if (oldIndex == midIndex)
-        {
-            // Binary search failed. See comments below
-            goto LinearSearch;
-        }
-    }
-
-    // Found match at midIndex
-    // Find the first record for this obj id
-    firstMatch = midIndex;
-    while(midIndex != 0)
-    {
-        midIndex -= 1;
-        SpecialObjectInfo *pTemp;
-        OBJECTREF refParent, refFromObj;
-        OBJECTREF dummy;
-        dummy = TSO.GetAt(midIndex, &refFromObj, &refParent, (QueuedObjectInfo **)&pTemp);
-        if (pTemp->GetObjectId() != objId)
-            break;
-        else
-            firstMatch = midIndex;
-    };
-
-    // Now look for the right kind of record
-    do
-    {
-        OBJECTREF refParent, refFromObj;
-        OBJECTREF dummy;
-        dummy = TSO.GetAt(firstMatch, &refFromObj, &refParent, (QueuedObjectInfo **)&splInfo);
-        
-        if (splInfo->GetObjectId() == objId)
-        {
-            switch(kind)
-            {
-                case ISerializable:
-                    if (splInfo->IsISerializableInstance())
-                        return firstMatch;
-                    break;
-                case IObjectReference:
-                    if (splInfo->IsIObjRefInstance())
-                        return firstMatch;
-                    break;
-                case BoxedValueType:
-                    if (splInfo->IsBoxedObject())
-                        return firstMatch;
-                    break;
-                default:
-                    _ASSERTE(!"Unknown enum value in FindObjectInTSO");
-            };
-        }
-
-        firstMatch++;
-        
-    }while(firstMatch < TSO.GetCount());
-
-LinearSearch:
-    // If there are multiple objects that are ISer/IObj, and some of them repeat in a certain fashion,
-    // then the entries in TSO are not in sorted order. In such a case binary search will fail. Lets do a linear search
-    // in such a case for now. This is probably reasonable since the TSO should usually be short and in-order (and presumably
-    // cheaper than trying to keep the list in sorted order at all times).
-    DWORD currIndex = 0;
-    for (; currIndex < TSO.GetCount(); currIndex++)
-    {
-        OBJECTREF refParent, refFromObj;
-        OBJECTREF dummy;
-        dummy = TSO.GetAt(currIndex, &refFromObj, &refParent, (QueuedObjectInfo **)&splInfo);
-
-        SpecialObjects foundKind = ISerializable;
-        if (splInfo->IsIObjRefInstance())
-            foundKind = IObjectReference;
-        else if (splInfo->IsBoxedObject())
-            foundKind = BoxedValueType;
-        else
-            _ASSERTE(splInfo->IsISerializableInstance());
-        
-        if (objId == splInfo->GetObjectId()
-        && kind == foundKind)
-            return currIndex;
-    }
-
-
-    _ASSERTE(!"Special Object unexpectedly not found for given object id\n");
-    return 0; // throw ?
-}
-
-// This function is effectively a replica of MethodTable::Box. Its replicated to avoid "GCPROTECT_INTERIOR" that Box uses
-// and causes some leak detection asserts to go off. This is a controlled leak situation, where we know we're leaking stuff
-// and dont want the asserts.
-OBJECTREF ObjectClone::BoxValueTypeInWrongDomain(OBJECTREF refParent, DWORD offset, MethodTable *pValueTypeMT)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(pValueTypeMT->IsValueType());
-        PRECONDITION(!pValueTypeMT->IsByRefLike());
-    }
-    CONTRACTL_END;
-
-    OBJECTREF ref = NULL;
-    void* pSrc = refParent->GetData() + offset;
-    GCPROTECT_BEGININTERIOR(pSrc);
-    
-    // We must enter the target domain if we are boxing a non-agile type.  This of course has some overhead
-    // so we want to avoid it if possible.  GetLoaderModule() == mscorlib && CanBeBlittedByObjectCloner is a
-    // conservative first approximation of agile types.
-    ENTER_DOMAIN_PTR_PREDICATED(m_fromDomain, ADV_RUNNINGIN,
-        !pValueTypeMT->GetLoaderModule()->IsSystem() || pValueTypeMT->GetClass()->CannotBeBlittedByObjectCloner());
-
-    ref = pValueTypeMT->FastBox(&pSrc);
-
-    END_DOMAIN_TRANSITION;
-    
-    GCPROTECT_END();
-    return ref;
-}
-
-// Returns whether or not a given type requires VTS callbacks of the specified kind.
-BOOL ObjectClone::HasVtsCallbacks(MethodTable *pMT, RemotingVtsInfo::VtsCallbackType eCallbackType)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    while (pMT)
-    {
-        if (pMT->HasRemotingVtsInfo())
-        {
-            PTR_RemotingVtsInfo pVtsInfo = pMT->GetRemotingVtsInfo();
-            _ASSERTE(pVtsInfo != NULL);
-
-            if (!pVtsInfo->m_pCallbacks[eCallbackType].IsNull())
-                return TRUE;
-        }
-        pMT = pMT->GetParentMethodTable();
-    }
-
-    return FALSE;
-}
-
-// Calls all of the VTS event methods for a given callback type on the object instance provided (starting at the base class).
-void ObjectClone::InvokeVtsCallbacks(OBJECTREF refTarget, RemotingVtsInfo::VtsCallbackType eCallbackType, AppDomain* pDomain)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-
-    GCPROTECT_BEGIN(refTarget);
-
-    // Quickly walk the target's type hierarchy and determine the number of methods we'll need to call.
-    DWORD cMethods = 0;
-    MethodDesc *pLastCallback;
-    MethodTable *pMT = refTarget->GetMethodTable();
-    while (pMT)
-    {
-        if (pMT->HasRemotingVtsInfo())
-        {
-            PTR_RemotingVtsInfo pVtsInfo = pMT->GetRemotingVtsInfo();
-            _ASSERTE(pVtsInfo != NULL);
-      
-            if (!pVtsInfo->m_pCallbacks[eCallbackType].IsNull())
-            {
-                cMethods++;
-
-#ifdef FEATURE_PREJIT
-                // Might have to restore cross module method pointers.
-                Module::RestoreMethodDescPointer(&pVtsInfo->m_pCallbacks[eCallbackType]);
-#endif
-
-                pLastCallback = pVtsInfo->m_pCallbacks[eCallbackType].GetValue();
-            }
-        }
-        pMT = pMT->GetParentMethodTable();
-    }
-
-    // Maybe there's no work to do.
-    if (cMethods == 0)
-        goto Done;
-
-    // Allocate an array to hold the methods to invoke (we do this because the invocation order is the opposite way round from the
-    // way we can easily scan for the methods). We can easily optimize this for the single callback case though.
-    MethodDesc **pCallbacks = cMethods == 1 ? &pLastCallback : (MethodDesc**)_alloca(cMethods * sizeof(MethodDesc*));
-
-    if (cMethods > 1)
-    {
-        // Walk the type hierarchy again, and this time fill in the methods to call in the correct slot of our callback table.
-        DWORD dwSlotIndex = cMethods;
-        pMT = refTarget->GetMethodTable();
-        while (pMT)
-        {
-            if (pMT->HasRemotingVtsInfo())
-            {
-                PTR_RemotingVtsInfo pVtsInfo = pMT->GetRemotingVtsInfo();
-                _ASSERTE(pVtsInfo != NULL);
-
-                if (!pVtsInfo->m_pCallbacks[eCallbackType].IsNull())
-                    pCallbacks[--dwSlotIndex] = pVtsInfo->m_pCallbacks[eCallbackType].GetValue();
-            }
-            pMT = pMT->GetParentMethodTable();
-        }
-        _ASSERTE(dwSlotIndex == 0);
-    }
-
-    bool fSwitchDomains = pDomain != GetAppDomain();
-
-    ENTER_DOMAIN_PTR(pDomain,ADV_RUNNINGIN);
-
-    // If we're calling back into the from domain then reset the execution context to its original state (this will automatically be
-    // popped once we return from this domain again).
-    if (pDomain == m_fromDomain && fSwitchDomains)
-    {
-        Thread *pThread = GetThread();
-        if (pThread->IsExposedObjectSet())
-        {
-            THREADBASEREF refThread = (THREADBASEREF)pThread->GetExposedObjectRaw();
-            refThread->SetExecutionContext(m_fromExecutionContext);
-        }
-    }
-
-    // Remember to adjust this pointer for boxed value types.
-    BOOL bIsBoxed = refTarget->GetMethodTable()->IsValueType();
-
-    RuntimeMethodHandle::StreamingContextData sContext = { NULL, GetStreamingContextState() }; 
-
-    // Ensure Streamingcontext type is loaded. Do not delete this line
-    MethodTable *pMTStreamingContext;
-    pMTStreamingContext = MscorlibBinder::GetClass(CLASS__STREAMING_CONTEXT);
-    _ASSERTE(pMTStreamingContext);
-    
-    // Now go and call each method in order.
-    for (DWORD i = 0; i < cMethods; i++)
-    {
-        MethodDescCallSite callback(pCallbacks[i], &refTarget);
-
-        ARG_SLOT argSlots[2];
-
-            // Nullable<T> does not have any VTS functions 
-        _ASSERTE(!Nullable::IsNullableType(refTarget->GetMethodTable()));
-
-        argSlots[0] = (bIsBoxed ? (ARG_SLOT)(SIZE_T)(refTarget->UnBox()) : ObjToArgSlot(refTarget));
-#if defined(_TARGET_X86_) || defined(_TARGET_ARM_)
-        static_assert_no_msg(sizeof(sContext) == sizeof(ARG_SLOT));
-        argSlots[1] = *(ARG_SLOT*)(&sContext);           // StreamingContext is passed by value on x86 and ARM
-#elif defined(_WIN64)
-        static_assert_no_msg(sizeof(sContext) >  sizeof(ARG_SLOT));
-        argSlots[1] = PtrToArgSlot(&sContext);           // StreamingContext is passed by reference on WIN64
-#else  // !_TARGET_X86_ && !_WIN64 && !_TARGET_ARM_
-        PORTABILITY_ASSERT("ObjectClone::InvokeVtsCallbacks() - NYI on this platform");
-#endif // !_TARGET_X86_ && !_WIN64 && !_TARGET_ARM_
-
-        callback.CallWithValueTypes(&argSlots[0]);
-    }
-
-    END_DOMAIN_TRANSITION;
-
-Done: ;
-    GCPROTECT_END();
-}
-
-#endif //  FEATURE_REMOTING
diff --git a/src/vm/olevariant.cpp b/src/vm/olevariant.cpp
index 75483fd5fe..a15a1979e2 100644
--- a/src/vm/olevariant.cpp
+++ b/src/vm/olevariant.cpp
@@ -2729,12 +2729,10 @@ void OleVariant::MarshalOleVariantForObject(OBJECTREF * const & pObj, VARIANT *p
     }
     CONTRACTL_END;
 
-#ifdef FEATURE_CORECLR
     if (AppX::IsAppXProcess())
     { 
         COMPlusThrow(kPlatformNotSupportedException, IDS_EE_BADMARSHAL_TYPE_VARIANTASOBJECT);
     }
-#endif // FEATURE_CORECLR
     
     SafeVariantClear(pOle);
 
@@ -2859,12 +2857,10 @@ void OleVariant::MarshalOleRefVariantForObject(OBJECTREF *pObj, VARIANT *pOle)
     }
     CONTRACTL_END;
 
-#ifdef FEATURE_CORECLR
    if (AppX::IsAppXProcess())
    { 
        COMPlusThrow(kPlatformNotSupportedException, IDS_EE_BADMARSHAL_TYPE_VARIANTASOBJECT);
    }
-#endif // FEATURE_CORECLR
 
     HRESULT hr = MarshalCommonOleRefVariantForObject(pObj, pOle);
 
@@ -3084,12 +3080,10 @@ void OleVariant::MarshalObjectForOleVariant(const VARIANT * pOle, OBJECTREF * co
     }
     CONTRACT_END;
 
-#ifdef FEATURE_CORECLR
     if (AppX::IsAppXProcess())
     { 
         COMPlusThrow(kPlatformNotSupportedException, IDS_EE_BADMARSHAL_TYPE_VARIANTASOBJECT);
     }
-#endif // FEATURE_CORECLR
 
 #ifdef MDA_SUPPORTED
     MdaInvalidVariant* pProbe = MDA_GET_ASSISTANT(InvalidVariant);
diff --git a/src/vm/pefile.cpp b/src/vm/pefile.cpp
index 86785e2417..f833a17c36 100644
--- a/src/vm/pefile.cpp
+++ b/src/vm/pefile.cpp
@@ -15,10 +15,6 @@
 #include "eecontract.h"
 #include "apithreadstress.h"
 #include "eeconfig.h"
-#ifdef FEATURE_FUSION
-#include "fusionpriv.h"
-#include "shlwapi.h"
-#endif
 #include "product_version.h"
 #include "eventtrace.h"
 #include "security.h"
@@ -32,18 +28,11 @@
 #endif
 #include "strongnameinternal.h"
 
-#ifdef FEATURE_VERSIONING
 #include "../binder/inc/applicationcontext.hpp"
-#endif
 
-#ifndef FEATURE_FUSION
 #include "clrprivbinderutil.h"
 #include "../binder/inc/coreclrbindercommon.h"
-#endif
 
-#ifdef FEATURE_CAS_POLICY
-#include <wintrust.h>
-#endif
 
 #ifdef FEATURE_PREJIT
 #include "compile.h"
@@ -55,11 +44,6 @@ SVAL_IMPL_INIT(DWORD, PEFile, s_NGENDebugFlags, 0);
 
 #include "sha1.h"
 
-#if defined(FEATURE_FUSION)
-#include "clrprivbinderfusion.h"
-#include "clrprivbinderappx.h"
-#include "clrprivbinderloadfile.h" 
-#endif
 
 #ifndef DACCESS_COMPILE
 
@@ -83,25 +67,13 @@ PEFile::PEFile(PEImage *identity, BOOL fCheckAuthenticodeSignature/*=TRUE*/) :
     m_pMDImport(NULL),
     m_pImporter(NULL),
     m_pEmitter(NULL),
-#ifndef FEATURE_CORECLR
-    m_pAssemblyImporter(NULL),
-    m_pAssemblyEmitter(NULL),
-#endif
     m_pMetadataLock(::new SimpleRWLock(PREEMPTIVE, LOCK_TYPE_DEFAULT)),
     m_refCount(1),
     m_hash(NULL),
     m_flags(0),
     m_fStrongNameVerified(FALSE)
-#ifdef FEATURE_CAS_POLICY
-    ,m_certificate(NULL),
-    m_fCheckedCertificate(FALSE)
-    ,m_pSecurityManager(NULL)
-    ,m_securityManagerLock(CrstPEFileSecurityManager)
-#endif // FEATURE_CAS_POLICY
     ,m_pHostAssembly(nullptr)
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
     ,m_pFallbackLoadContextBinder(nullptr)
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 {
     CONTRACTL
     {
@@ -126,12 +98,6 @@ PEFile::PEFile(PEImage *identity, BOOL fCheckAuthenticodeSignature/*=TRUE*/) :
     }
 
 
-#ifdef FEATURE_CAS_POLICY
-    if (fCheckAuthenticodeSignature)
-    {
-        CheckAuthenticodeSignature();
-    }
-#endif // FEATURE_CAS_POLICY
 }
 
 
@@ -168,14 +134,6 @@ PEFile::~PEFile()
         m_identity->Release();
     if (m_pMetadataLock)
         delete m_pMetadataLock;
-#ifdef FEATURE_CAS_POLICY
-    if (m_pSecurityManager) {
-        m_pSecurityManager->Release();
-        m_pSecurityManager = NULL;
-    }
-    if (m_certificate && !g_pCertificateCache->Contains(m_certificate))
-        CoTaskMemFree(m_certificate);
-#endif // FEATURE_CAS_POLICY
 
     if (m_pHostAssembly != NULL)
     {
@@ -839,86 +797,6 @@ void PEFile::GetCodeBaseOrName(SString &result)
         result.SetUTF8(GetSimpleName());
 }
 
-#ifdef FEATURE_CAS_POLICY
-
-// Returns security information for the assembly based on the codebase
-void PEFile::GetSecurityIdentity(SString &codebase, SecZone *pdwZone, DWORD dwFlags, BYTE *pbUniqueID, DWORD *pcbUniqueID)
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        THROWS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pdwZone));
-        PRECONDITION(CheckPointer(pbUniqueID));
-        PRECONDITION(CheckPointer(pcbUniqueID));
-    }
-    CONTRACTL_END;
-
-    if (IsAssembly())
-    {
-        ((PEAssembly*)this)->GetCodeBase(codebase);
-    }
-    else if (m_identity != NULL && !m_identity->GetPath().IsEmpty())
-    {
-        codebase.Set(W("file:///"));
-        codebase.Append(m_identity->GetPath());
-    }
-    else
-    {
-        _ASSERTE( !"Unable to determine security identity" );
-    }
-
-    GCX_PREEMP();
-
-    if(!codebase.IsEmpty())
-    {
-        *pdwZone = NoZone;
-
-        InitializeSecurityManager();
-
-        // We have a class name, return a class factory for it
-        _ASSERTE(sizeof(SecZone) == sizeof(DWORD));
-        IfFailThrow(m_pSecurityManager->MapUrlToZone(codebase,
-                                                     reinterpret_cast<DWORD *>(pdwZone),
-                                                     dwFlags));
-
-        if (*pdwZone>=NumZones)            
-            IfFailThrow(SecurityPolicy::ApplyCustomZoneOverride(pdwZone));
-        
-        IfFailThrow(m_pSecurityManager->GetSecurityId(codebase,
-                                                      pbUniqueID,
-                                                      pcbUniqueID,
-                                                      0));
-    }
-}
-
-void PEFile::InitializeSecurityManager()
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        THROWS;
-        CAN_TAKE_LOCK;
-        MODE_PREEMPTIVE;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-    if(m_pSecurityManager == NULL)
-    {
-        CrstHolder holder(&m_securityManagerLock);
-        if (m_pSecurityManager == NULL)
-        {
-                IfFailThrow(CoInternetCreateSecurityManager(NULL,
-                                                            &m_pSecurityManager,
-                                                            0));
-        }
-    }
-}
-
-#endif // FEATURE_CAS_POLICY
 
 // ------------------------------------------------------------
 // Checks
@@ -945,42 +823,6 @@ CHECK PEFile::CheckLoaded(BOOL bAllowNativeSkip/*=TRUE*/)
     CHECK_OK;
 }
 
-#ifndef FEATURE_CORECLR
-// ------------------------------------------------------------
-// Hash support
-// ------------------------------------------------------------
-
-#ifndef SHA1_HASH_SIZE
-#define SHA1_HASH_SIZE 20
-#endif
-
-void PEFile::GetSHA1Hash(SBuffer &result)
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        PRECONDITION(CheckValue(result));
-        THROWS;
-        MODE_ANY;
-        GC_TRIGGERS;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    // Cache the SHA1 hash in a buffer
-    if (m_hash == NULL)
-    {
-        // We shouldn't have to compute a SHA1 hash in any scenarios
-        // where the image opening should be suppressed.
-        EnsureImageOpened();
-
-        m_hash = new InlineSBuffer<SHA1_HASH_SIZE>();
-        GetILimage()->ComputeHash(CALG_SHA1, *m_hash);
-    }
-
-    result.Set(*m_hash);
-}
-#endif // FEATURE_CORECLR
 
 // ------------------------------------------------------------
 // Metadata access
@@ -1242,9 +1084,7 @@ void PEFile::OpenMDImport_Unsafe()
         return;
 #ifdef FEATURE_PREJIT    
     if (m_nativeImage != NULL
-#ifdef FEATURE_CORECLR
         && m_nativeImage->GetMDImport() != NULL
-#endif
         )
     {
         // Use native image for metadata
@@ -1297,58 +1137,6 @@ void PEFile::OpenEmitter()
         pIMDEmit->Release();
 }
 
-#ifndef FEATURE_CORECLR
-void PEFile::OpenAssemblyImporter()
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    // Make sure internal MD is in RW format.
-    ConvertMDInternalToReadWrite();
-
-    // Get the interface
-    IMetaDataAssemblyImport *pIMDAImport = NULL;
-    IfFailThrow(GetMetaDataPublicInterfaceFromInternal((void*)GetPersistentMDImport(), 
-                                                       IID_IMetaDataAssemblyImport, 
-                                                       (void **)&pIMDAImport));
-
-    // Atomically swap it into the field (release it if we lose the race)
-    if (FastInterlockCompareExchangePointer(&m_pAssemblyImporter, pIMDAImport, NULL) != NULL)
-        pIMDAImport->Release();
-}
-
-void PEFile::OpenAssemblyEmitter()
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    // Make sure internal MD is in RW format.
-    ConvertMDInternalToReadWrite();
-
-    IMetaDataAssemblyEmit *pIMDAssemblyEmit = NULL;
-    IfFailThrow(GetMetaDataPublicInterfaceFromInternal((void*)GetPersistentMDImport(),
-                                                       IID_IMetaDataAssemblyEmit,
-                                                       (void **)&pIMDAssemblyEmit));
-
-    // Atomically swap it into the field (release it if we lose the race)
-    if (FastInterlockCompareExchangePointer(&m_pAssemblyEmitter, pIMDAssemblyEmit, NULL) != NULL)
-        pIMDAssemblyEmit->Release();
-}
-#endif // FEATURE_CORECLR
 
 void PEFile::ReleaseMetadataInterfaces(BOOL bDestructor, BOOL bKeepNativeData/*=FALSE*/)
 {
@@ -1362,18 +1150,6 @@ void PEFile::ReleaseMetadataInterfaces(BOOL bDestructor, BOOL bKeepNativeData/*=
     }
     CONTRACTL_END;
     _ASSERTE(bDestructor || !m_bHasPersistentMDImport);
-#ifndef FEATURE_CORECLR
-    if (m_pAssemblyImporter != NULL)
-    {
-        m_pAssemblyImporter->Release();
-        m_pAssemblyImporter = NULL;
-    }
-    if(m_pAssemblyEmitter)
-    {
-        m_pAssemblyEmitter->Release();
-        m_pAssemblyEmitter=NULL;
-    }
-#endif
 
     if (m_pImporter != NULL)
     {
@@ -1393,161 +1169,6 @@ void PEFile::ReleaseMetadataInterfaces(BOOL bDestructor, BOOL bKeepNativeData/*=
      }
 }
 
-#ifdef FEATURE_CAS_POLICY
-
-void PEFile::CheckAuthenticodeSignature()
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    // Check any security signature in the header.
-
-    // This publisher data can potentially be cached and passed back in via
-    // PEAssembly::CreateDelayed.
-    //
-    // HOWEVER - even if we cache it, the certificate still may need to be verified at
-    // load time.  The only real caching can be done when the COR_TRUST certificate is
-    // ABSENT.
-    //
-    // (In the case where it is present, we could still theoretically
-    // cache the certificate and re-verify it and at least avoid touching the image
-    // again, however this path is not implemented yet, so this is TBD if we decide
-    // it is an important case to optimize for.)
-
-    if (!HasSecurityDirectory())
-    {
-        LOG((LF_SECURITY, LL_INFO1000, "No certificates found in module\n"));
-    }
-    else if(g_pConfig->GeneratePublisherEvidence())
-    {
-        // <TODO>@todo: Just because we don't have a file path, doesn't mean we can't have a certicate (does it?)</TODO>
-        if (!GetPath().IsEmpty())
-        {
-            GCX_PREEMP();
-
-            // Ignore any errors here - if we fail to validate a certificate, we just don't
-            // include it as evidence.
-
-            DWORD size;
-            CoTaskNewHolder<COR_TRUST> pCor = NULL;
-            // Failing to find a signature is OK.
-            LPWSTR pFileName = (LPWSTR) GetPath().GetUnicode();
-            DWORD dwAuthFlags = COR_NOUI|COR_NOPOLICY;
-#ifndef FEATURE_CORECLR
-            // Authenticode Verification Start
-            FireEtwAuthenticodeVerificationStart_V1(dwAuthFlags, 0, pFileName, GetClrInstanceId());            
-#endif // !FEATURE_CORECLR
-
-            HRESULT hr = ::GetPublisher(pFileName,
-                                          NULL,
-                                          dwAuthFlags,
-                                          &pCor,
-                                          &size);
-
-#ifndef FEATURE_CORECLR
-            // Authenticode Verification End
-            FireEtwAuthenticodeVerificationStop_V1(dwAuthFlags, (ULONG)hr, pFileName, GetClrInstanceId());            
-#endif // !FEATURE_CORECLR
-
-            if( SUCCEEDED(hr) ) { 
-                DWORD index = 0;
-                EnumCertificateAdditionFlags dwFlags = g_pCertificateCache->AddEntry(pCor, &index);
-                switch (dwFlags) {
-                case CacheSaturated:
-                    pCor.SuppressRelease();
-                    m_certificate = pCor.GetValue();
-                    break;
-
-                case Success:
-                    pCor.SuppressRelease();
-                    // falling through
-                case AlreadyExists:
-                    m_certificate = g_pCertificateCache->GetEntry(index);
-                    _ASSERTE(m_certificate);
-                    break;
-                }
-            }
-        }
-    }
-    else 
-    {
-        LOG((LF_SECURITY, LL_INFO1000, "Assembly has an Authenticode signature, but Publisher evidence has been disabled.\n"));
-    }
-
-    m_fCheckedCertificate = TRUE;
-}
-
-HRESULT STDMETHODCALLTYPE
-GetPublisher(__in __in_z IN LPWSTR pwsFileName,      // File name, this is required even with the handle
-             IN HANDLE hFile,            // Optional file name
-             IN DWORD  dwFlags,          // COR_NOUI or COR_NOPOLICY
-             OUT PCOR_TRUST *pInfo,      // Returns a PCOR_TRUST (Use FreeM)
-             OUT DWORD      *dwInfo)     // Size of pInfo.                           
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-    
-    GUID gV2 = COREE_POLICY_PROVIDER;
-    COR_POLICY_PROVIDER sCorPolicy;
-    
-    WINTRUST_DATA      sWTD;
-    WINTRUST_FILE_INFO sWTFI;
-    
-    // Set up the COR trust provider
-    memset(&sCorPolicy, 0, sizeof(COR_POLICY_PROVIDER));
-    sCorPolicy.cbSize = sizeof(COR_POLICY_PROVIDER);
-    
-    // Set up the winverify provider structures
-    memset(&sWTD, 0x00, sizeof(WINTRUST_DATA));
-    memset(&sWTFI, 0x00, sizeof(WINTRUST_FILE_INFO));
-    
-    sWTFI.cbStruct      = sizeof(WINTRUST_FILE_INFO);
-    sWTFI.hFile         = hFile;
-    sWTFI.pcwszFilePath = pwsFileName;
-    
-    sWTD.cbStruct       = sizeof(WINTRUST_DATA);
-    sWTD.pPolicyCallbackData = &sCorPolicy; // Add in the cor trust information!!
-    if (dwFlags & COR_NOUI)
-    {
-        sWTD.dwUIChoice     = WTD_UI_NONE;        // No bad UI is overridden in COR TRUST provider
-    }
-    else
-    {
-        sWTD.dwUIChoice     = WTD_UI_ALL;        // No bad UI is overridden in COR TRUST provider
-    }
-    sWTD.dwUnionChoice  = WTD_CHOICE_FILE;
-    sWTD.pFile          = &sWTFI;
-    
-    // Set the policies for the VM (we have stolen VMBased and use it like a flag)
-    if (dwFlags != 0)
-        sCorPolicy.VMBased = dwFlags;
-    
-    LeaveRuntimeHolder holder((size_t)WinVerifyTrust);
-    
-    // WinVerifyTrust calls mscorsecimpl.dll to do the policy check
-    hr = WinVerifyTrust(GetFocus(), &gV2, &sWTD);
-    
-    *pInfo  = sCorPolicy.pbCorTrust;
-    *dwInfo = sCorPolicy.cbCorTrust;
-    
-    return hr;
-} // GetPublisher
-
-#endif // FEATURE_CAS_POLICY
 
 // ------------------------------------------------------------
 // PE file access
@@ -1699,19 +1320,6 @@ static void RuntimeVerifyVLog(DWORD level, LoggableAssembly *pLogAsm, const WCHA
         WszOutputDebugString(W("\n"));
     }
 
-#ifdef FEATURE_FUSION
-    IFusionBindLog *pFusionBindLog = pLogAsm->FusionBindLog();
-    if (pFusionBindLog)
-    {
-        pFusionBindLog->LogMessage(0, FUSION_BIND_LOG_CATEGORY_NGEN, message);
-
-        if (level == LL_ERROR) {
-            pFusionBindLog->SetResultCode(FUSION_BIND_LOG_CATEGORY_NGEN, E_FAIL);
-            pFusionBindLog->Flush(g_dwLogLevel, FUSION_BIND_LOG_CATEGORY_NGEN);
-            pFusionBindLog->Flush(g_dwLogLevel, FUSION_BIND_LOG_CATEGORY_DEFAULT);
-        }
-    }
-#endif //FEATURE_FUSION
 }
 
 
@@ -1725,9 +1333,6 @@ static void RuntimeVerifyLog(DWORD level, LoggableAssembly *pLogAsm, const WCHAR
     // Avoid calling RuntimeVerifyVLog unless logging is on
     if (   ((level == LL_ERROR) && IsDebuggerPresent()) 
         || LoggingOn(LF_ZAP, level)
-#ifdef FEATURE_FUSION
-        || (pLogAsm->FusionBindLog() != NULL)
-#endif
        ) 
     {
         va_list args;
@@ -1743,17 +1348,10 @@ static void RuntimeVerifyLog(DWORD level, LoggableAssembly *pLogAsm, const WCHAR
 
 static const LPCWSTR CorCompileRuntimeDllNames[NUM_RUNTIME_DLLS] =
 {
-#ifdef FEATURE_CORECLR
     MAKEDLLNAME_W(W("coreclr")),
-#else
-    MAKEDLLNAME_W(W("CLR")),
-#endif
     MAKEDLLNAME_W(W("clrjit"))
 };
 
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-static LPCWSTR s_ngenCompilerDllName = NULL;
-#endif //!FEATURE_CORECLR && !CROSSGEN_COMPILE
 
 LPCWSTR CorCompileGetRuntimeDllName(CorCompileRuntimeDlls id)
 {
@@ -1767,36 +1365,6 @@ LPCWSTR CorCompileGetRuntimeDllName(CorCompileRuntimeDlls id)
     }
     CONTRACTL_END;
 
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-    if (id == NGEN_COMPILER_INFO)
-    {
-        // The NGen compiler needs to be handled differently as it can be customized,
-        // unlike the other runtime DLLs.
-
-        if (s_ngenCompilerDllName == NULL)
-        {
-            // Check if there is an override for the compiler DLL
-            LPCWSTR ngenCompilerOverride = CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_NGen_JitName);
-
-            if (ngenCompilerOverride == NULL)
-            {
-                s_ngenCompilerDllName = DEFAULT_NGEN_COMPILER_DLL_NAME;
-            }
-            else
-            {
-                if (wcsstr(ngenCompilerOverride, W(".dll")) == NULL)
-                {
-                    EEPOLICY_HANDLE_FATAL_ERROR_WITH_MESSAGE(COR_E_EXECUTIONENGINE,
-                        NGEN_COMPILER_OVERRIDE_KEY W(" should have a .DLL suffix"));
-                }
-
-                s_ngenCompilerDllName = ngenCompilerOverride;
-            }
-        }
-
-        return s_ngenCompilerDllName;
-    }
-#endif //!FEATURE_CORECLR && !CROSSGEN_COMPILE
 
     return CorCompileRuntimeDllNames[id];
 }
@@ -1823,33 +1391,17 @@ extern HMODULE CorCompileGetRuntimeDll(CorCompileRuntimeDlls id)
     CONTRACTL_END;
 
     // Currently special cased for every entry.
-#ifdef FEATURE_CORECLR
     static_assert_no_msg(NUM_RUNTIME_DLLS == 2);
     static_assert_no_msg(CORECLR_INFO == 0);
-#else // !FEATURE_CORECLR
-    static_assert_no_msg(NUM_RUNTIME_DLLS == 2);
-    static_assert_no_msg(CLR_INFO == 0);
-    static_assert_no_msg(NGEN_COMPILER_INFO == 1);
-#endif // else FEATURE_CORECLR
 
     HMODULE hMod = NULL;
 
     // Try to load the correct DLL
     switch (id)
     {
-#ifdef FEATURE_CORECLR
     case CORECLR_INFO:
         hMod = GetCLRModule();
         break;
-#else // !FEATURE_CORECLR
-    case CLR_INFO:
-        hMod = GetCLRModule();
-        break;
-
-    case NGEN_COMPILER_INFO:
-        hMod = s_ngenCompilerDll;
-        break;
-#endif // else FEATURE_CORECLR
 
     default:
         COMPlusThrowNonLocalized(kExecutionEngineException,
@@ -1869,68 +1421,6 @@ static BOOL RuntimeVerifyNativeImageTimestamps(const CORCOMPILE_VERSION_INFO *in
 {
     STANDARD_VM_CONTRACT;
 
-#if !defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)
-    //
-    // We will automatically fail any zap files which were compiled with different runtime dlls.
-    // This is so that we don't load bad ngen images after recompiling or patching the runtime.
-    //
-
-    for (DWORD index = 0; index < NUM_RUNTIME_DLLS; index++)
-    {
-        HMODULE hMod = CorCompileGetRuntimeDll((CorCompileRuntimeDlls)index);
-
-        if (hMod == NULL)
-        {
-            // Unless this is an NGen worker process, we don't want to load JIT compiler just to do a timestamp check.
-            // In an ideal case, all assemblies have native images, and JIT compiler never needs to be loaded at runtime.
-            // Loading JIT compiler just to check its timestamp would reduce the benefits of have native images.
-            // Since CLR and JIT are intended to be serviced together, the possibility of accidentally using native
-            // images created by an older JIT is very small, and is deemed an acceptable risk.
-            // Note that when multiple JIT compilers are used (e.g., clrjit.dll and compatjit.dll on x64 in .NET 4.6),
-            // they must all be in the same patch family.
-            if (!IsCompilationProcess())
-                continue;
-
-            // If we are doing ngen, then eagerly make sure all the system
-            // dependencies are loaded. Else ICorCompileInfo::CheckAssemblyZap()
-            // will not work correctly.
-
-            LPCWSTR wszDllName = CorCompileGetRuntimeDllName((CorCompileRuntimeDlls)index);
-            if (FAILED(g_pCLRRuntime->LoadLibrary(wszDllName, &hMod)))
-            {
-                EEPOLICY_HANDLE_FATAL_ERROR_WITH_MESSAGE(COR_E_EXECUTIONENGINE, W("Unable to load CLR DLL during ngen"));
-            }
-        }
-
-        _ASSERTE(hMod != NULL);
-
-        PEDecoder pe(hMod);
-
-        // Match NT header timestamp and checksum to test DLL identity
-
-        if ((info->runtimeDllInfo[index].timeStamp == pe.GetTimeDateStamp()
-             || info->runtimeDllInfo[index].timeStamp == 0)
-            && (info->runtimeDllInfo[index].virtualSize == pe.GetVirtualSize()
-                || info->runtimeDllInfo[index].virtualSize == 0))
-        {
-            continue;
-        }
-
-        {
-            // set "ComPlus_CheckNGenImageTimeStamp" to 0 to ignore time-stamp-checking
-            static ConfigDWORD checkNGenImageTimeStamp;
-            BOOL enforceCheck = checkNGenImageTimeStamp.val(CLRConfig::EXTERNAL_CheckNGenImageTimeStamp);
-
-            RuntimeVerifyLog(enforceCheck ? LL_ERROR : LL_WARNING,
-                             pLogAsm,
-                             W("Compiled with different CLR DLL (%s). Exact match expected."),
-                             CorCompileGetRuntimeDllName((CorCompileRuntimeDlls)index));
-
-            if (enforceCheck)
-                return FALSE;
-        }
-    }
-#endif // !CROSSGEN_COMPILE && !FEATURE_CORECLR
 
     return TRUE;
 }
@@ -1955,12 +1445,8 @@ BOOL PEAssembly::CheckNativeImageVersion(PEImage *peimage)
 
     if (!image->CheckNativeHeaderVersion())
     {
-#ifdef FEATURE_CORECLR
         // Wrong native image version is fatal error on CoreCLR
         ThrowHR(COR_E_NI_AND_RUNTIME_VERSION_MISMATCH);
-#else
-        return FALSE;
-#endif
     }
 
     CORCOMPILE_VERSION_INFO *info = image->GetNativeVersionInfo();
@@ -1970,15 +1456,10 @@ BOOL PEAssembly::CheckNativeImageVersion(PEImage *peimage)
     LoggablePEAssembly logAsm(this);
     if (!RuntimeVerifyNativeImageVersion(info, &logAsm))
     {
-#ifdef FEATURE_CORECLR
         // Wrong native image version is fatal error on CoreCLR
         ThrowHR(COR_E_NI_AND_RUNTIME_VERSION_MISMATCH);
-#else
-        return FALSE;
-#endif
     }
 
-#ifdef FEATURE_CORECLR
     CorCompileConfigFlags configFlags = PEFile::GetNativeImageConfigFlagsWithOverrides();
 
     if (IsSystem())
@@ -1999,36 +1480,10 @@ BOOL PEAssembly::CheckNativeImageVersion(PEImage *peimage)
     {
         return FALSE;
     }
-#else
-    //
-    // Check image flavor. Skip this check in RuntimeVerifyNativeImageVersion called from fusion - fusion is responsible for choosing the right flavor.
-    //
-    if (!RuntimeVerifyNativeImageFlavor(info, &logAsm))
-    {
-        return FALSE;
-    }
-#endif
 
     return TRUE;
 }
 
-#ifndef FEATURE_CORECLR
-//===========================================================================================================
-// Validates that an NI matches the required flavor (debug, instrumented, etc.)
-//
-//===========================================================================================================
-BOOL RuntimeVerifyNativeImageFlavor(const CORCOMPILE_VERSION_INFO *info, LoggableAssembly *pLogAsm)
-{
-    STANDARD_VM_CONTRACT;
-
-    CorCompileConfigFlags configFlags = PEFile::GetNativeImageConfigFlagsWithOverrides();
-
-    if ((info->wConfigFlags & configFlags) != configFlags)
-        return FALSE;
-
-    return TRUE;
-}
-#endif
 
 //===========================================================================================================
 // Validates that an NI matches the running CLR, OS, CPU, etc.
@@ -2100,18 +1555,6 @@ BOOL RuntimeVerifyNativeImageVersion(const CORCOMPILE_VERSION_INFO *info, Loggab
     }
 #endif // CROSSGEN_COMPILE
 
-#if defined(_TARGET_AMD64_) && !defined(FEATURE_CORECLR)
-    //
-    // Check the right JIT compiler
-    //
-
-    bool nativeImageBuiltWithRyuJit = ((info->wCodegenFlags & CORCOMPILE_CODEGEN_USE_RYUJIT) != 0);
-    if (UseRyuJit() != nativeImageBuiltWithRyuJit)
-    {
-        RuntimeVerifyLog(LL_ERROR, pLogAsm, W("JIT compiler used to generate native image doesn't match current JIT compiler."));
-        return FALSE;
-    }
-#endif
 
     //
     // The zap is up to date.
@@ -2240,15 +1683,6 @@ BOOL RuntimeVerifyNativeImageDependency(const CORCOMPILE_NGEN_SIGNATURE &ngenSig
                          W("Rejecting native image because native image dependency %s ")
                          W("had a different identity than expected"),
                          displayString.GetUnicode());
-#if (defined FEATURE_PREJIT) && (defined FEATURE_FUSION)
-        if (pLogAsm->FusionBindLog())
-        {
-            if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context, TRACE_LEVEL_INFORMATION, CLR_PRIVATEFUSION_KEYWORD))
-            { 
-                pLogAsm->FusionBindLog()->ETWTraceLogMessage(ETW::BinderLog::BinderStructs::NGEN_BIND_DEPENDENCY_HAS_DIFFERENT_IDENTITY, pLogAsm->FusionAssemblyName());
-            }
-        }
-#endif
 
         return FALSE;
     }
@@ -2765,39 +2199,6 @@ ULONG PEFile::GetILImageTimeDateStamp()
     return GetLoadedIL()->GetTimeDateStamp();
 }
 
-#ifdef FEATURE_CAS_POLICY
-
-//---------------------------------------------------------------------------------------
-//
-// Get a SafePEFileHandle for this PEFile
-//
-
-SAFEHANDLE PEFile::GetSafeHandle()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-
-    SAFEHANDLE objSafeHandle = NULL;
-
-    GCPROTECT_BEGIN(objSafeHandle);
-
-    objSafeHandle = (SAFEHANDLE)AllocateObject(MscorlibBinder::GetClass(CLASS__SAFE_PEFILE_HANDLE));
-    CallDefaultConstructor(objSafeHandle);
-
-    this->AddRef();
-    objSafeHandle->SetHandle(this);
-
-    GCPROTECT_END();
-
-    return objSafeHandle;
-}
-
-#endif // FEATURE_CAS_POLICY
 
 // ================================================================================
 // PEAssembly class - a PEFile which represents an assembly
@@ -2810,169 +2211,6 @@ void PEAssembly::Attach()
     STANDARD_VM_CONTRACT;
 }
 
-#ifdef FEATURE_FUSION
-PEAssembly::PEAssembly(PEImage *image,
-                       IMetaDataEmit *pEmit,
-                       IAssembly *pIAssembly,
-                       IBindResult *pNativeFusionAssembly,
-                       PEImage *pPEImageNI,
-                       IFusionBindLog *pFusionLog,
-                       IHostAssembly *pIHostAssembly,
-                       PEFile *creator,
-                       BOOL system,
-                       BOOL introspectionOnly/*=FALSE*/,
-                       ICLRPrivAssembly * pHostAssembly)
-      : PEFile(image, FALSE),
-        m_creator(NULL),
-        m_pFusionAssemblyName(NULL),
-        m_pFusionAssembly(NULL),
-        m_pFusionLog(NULL),
-        m_bFusionLogEnabled(TRUE),
-        m_pIHostAssembly(NULL),
-        m_pNativeAssemblyLocation(NULL),
-        m_pNativeImageClosure(NULL),
-        m_fStrongNameBypassed(FALSE)
-{
-    CONTRACTL
-    {
-        CONSTRUCTOR_CHECK;
-        PRECONDITION(CheckPointer(image, NULL_OK));
-        PRECONDITION(CheckPointer(pEmit, NULL_OK));
-        PRECONDITION(image != NULL || pEmit != NULL);
-        PRECONDITION(CheckPointer(pIAssembly, NULL_OK));
-        PRECONDITION(CheckPointer(pFusionLog, NULL_OK));
-        PRECONDITION(CheckPointer(pIHostAssembly, NULL_OK));
-        PRECONDITION(CheckPointer(creator, NULL_OK));
-        STANDARD_VM_CHECK;
-    }
-    CONTRACTL_END;    
-
-    if (introspectionOnly)
-    {
-        if (!system)  // Implementation restriction: mscorlib.dll cannot be loaded as introspection. The architecture depends on there being exactly one mscorlib.
-        {
-            m_flags |= PEFILE_INTROSPECTIONONLY;
-#ifdef FEATURE_PREJIT
-            SetCannotUseNativeImage();
-#endif // FEATURE_PREJIT
-        }
-    }
-
-    if (pIAssembly)
-    {
-        m_pFusionAssembly = pIAssembly;
-        pIAssembly->AddRef();
-
-        IfFailThrow(pIAssembly->GetAssemblyNameDef(&m_pFusionAssemblyName));
-    }
-    else if (pIHostAssembly)
-    {
-        m_flags |= PEFILE_ISTREAM;
-#ifdef FEATURE_PREJIT
-        m_fCanUseNativeImage = FALSE;
-#endif // FEATURE_PREJIT
-
-        m_pIHostAssembly = pIHostAssembly;
-        pIHostAssembly->AddRef();
-
-        IfFailThrow(pIHostAssembly->GetAssemblyNameDef(&m_pFusionAssemblyName));
-    }
-
-    if (pFusionLog)
-    {
-        m_pFusionLog = pFusionLog;
-        pFusionLog->AddRef();
-    }
-
-    if (creator)
-    {
-        m_creator = creator;
-        creator->AddRef();
-    }
-
-    m_flags |= PEFILE_ASSEMBLY;
-    if (system)
-        m_flags |= PEFILE_SYSTEM;
-
-#ifdef FEATURE_PREJIT
-    // Find the native image
-    if (pIAssembly)
-    {
-        if (pNativeFusionAssembly != NULL)
-            SetNativeImage(pNativeFusionAssembly);
-    }
-    // Only one of pNativeFusionAssembly and pPEImageNI may be set.
-    _ASSERTE(!(pNativeFusionAssembly && pPEImageNI));
-
-    if (pPEImageNI != NULL)
-        this->PEFile::SetNativeImage(pPEImageNI);
-#endif  // FEATURE_PREJIT
-
-    // If we have no native image, we require a mapping for the file.
-    if (!HasNativeImage() || !IsILOnly())
-        EnsureImageOpened();
-
-    // Open metadata eagerly to minimize failure windows
-    if (pEmit == NULL)
-        OpenMDImport_Unsafe(); //constructor, cannot race with anything
-    else
-    {
-        _ASSERTE(!m_bHasPersistentMDImport);
-        IfFailThrow(GetMetaDataInternalInterfaceFromPublic(pEmit, IID_IMDInternalImport,
-                                                           (void **)&m_pMDImport));
-        m_pEmitter = pEmit;
-        pEmit->AddRef();
-        m_bHasPersistentMDImport=TRUE;
-        m_MDImportIsRW_Debugger_Use_Only = TRUE;
-    }
-
-    // m_pMDImport can be external
-    // Make sure this is an assembly
-    if (!m_pMDImport->IsValidToken(TokenFromRid(1, mdtAssembly)))
-        ThrowHR(COR_E_ASSEMBLYEXPECTED);
-
-    // Make sure we perform security checks after we've obtained IMDInternalImport interface
-    DoLoadSignatureChecks();
-
-    // Verify name eagerly
-    LPCUTF8 szName = GetSimpleName();
-    if (!*szName)
-    {
-        ThrowHR(COR_E_BADIMAGEFORMAT, BFA_EMPTY_ASSEMDEF_NAME);
-    }
-
-#ifdef FEATURE_PREJIT
-    if (IsResource() || IsDynamic())
-        m_fCanUseNativeImage = FALSE;
-#endif // FEATURE_PREJIT
-
-    if (m_pFusionAssembly)
-    {
-        m_loadContext = m_pFusionAssembly->GetFusionLoadContext();
-        m_pFusionAssembly->GetAssemblyLocation(&m_dwLocationFlags);
-    }
-    else if (pHostAssembly != nullptr)
-    {
-        m_loadContext = LOADCTX_TYPE_HOSTED;
-        m_dwLocationFlags = ASMLOC_UNKNOWN;
-        m_pHostAssembly = clr::SafeAddRef(pHostAssembly); // Should use SetHostAssembly(pHostAssembly) here
-    }
-    else
-    {
-        m_loadContext = LOADCTX_TYPE_UNKNOWN;
-        m_dwLocationFlags = ASMLOC_UNKNOWN;
-    }
-
-    TESTHOOKCALL(CompletedNativeImageBind(image,szName,HasNativeImage()));
-
-#if _DEBUG
-    GetCodeBaseOrName(m_debugName);
-    m_debugName.Normalize();
-    m_pDebugName = m_debugName;
-#endif
-}
-
-#else // FEATURE_FUSION
 
 PEAssembly::PEAssembly(
                 CoreBindResult* pBindResultInfo, 
@@ -2990,11 +2228,7 @@ PEAssembly::PEAssembly(
     m_creator(clr::SafeAddRef(creator)),
     m_bIsFromGAC(FALSE),
     m_bIsOnTpaList(FALSE)
-#ifdef FEATURE_CORECLR
     ,m_fProfileAssembly(0)
-#else
-    ,m_fStrongNameBypassed(FALSE)
-#endif
 {
     CONTRACTL
     {
@@ -3099,58 +2333,8 @@ PEAssembly::PEAssembly(
                               m_sTextualIdentity);
 #endif
 }
-#endif // FEATURE_FUSION
-
-
-#ifdef FEATURE_FUSION
-
-PEAssembly *PEAssembly::Open(
-    PEAssembly *pParentAssembly,
-    PEImage *pPEImageIL,
-    BOOL isIntrospectionOnly)
-{
-    STANDARD_VM_CONTRACT;
-    PEAssembly * pPEAssembly = new PEAssembly(
-        pPEImageIL, // PEImage
-        nullptr,    // IMetaDataEmit
-        nullptr,    // IAssembly
-        nullptr,    // IBindResult pNativeFusionAssembly
-        nullptr,    // PEImage *pNIImage
-        nullptr,    // IFusionBindLog
-        nullptr,    // IHostAssembly
-        pParentAssembly,    // creator
-        FALSE,      // isSystem
-        isIntrospectionOnly,      // isIntrospectionOnly
-        NULL);
-
-    return pPEAssembly;
-}
 
-PEAssembly *PEAssembly::Open(
-    PEAssembly *       pParent,
-    PEImage *          pPEImageIL, 
-    PEImage *          pPEImageNI, 
-    ICLRPrivAssembly * pHostAssembly, 
-    BOOL               fIsIntrospectionOnly)
-{
-    STANDARD_VM_CONTRACT;
-    PEAssembly * pPEAssembly = new PEAssembly(
-        pPEImageIL, // PEImage
-        nullptr,    // IMetaDataEmit
-        nullptr,    // IAssembly
-        nullptr,    // IBindResult pNativeFusionAssembly
-        pPEImageNI, // Native Image PEImage
-        nullptr,    // IFusionBindLog
-        nullptr,    // IHostAssembly
-        pParent,    // creator
-        FALSE,      // isSystem
-        fIsIntrospectionOnly, 
-        pHostAssembly);
-
-    return pPEAssembly;
-}
 
-#else //FEATURE_FUSION
 
 PEAssembly *PEAssembly::Open(
     PEAssembly *       pParent,
@@ -3174,7 +2358,6 @@ PEAssembly *PEAssembly::Open(
     return pPEAssembly;
 }
 
-#endif // FEATURE_FUSION
 
 PEAssembly::~PEAssembly()
 {
@@ -3188,22 +2371,6 @@ PEAssembly::~PEAssembly()
     CONTRACTL_END;
 
     GCX_PREEMP();
-#ifdef FEATURE_FUSION    
-    if (m_pFusionAssemblyName != NULL)
-        m_pFusionAssemblyName->Release();
-    if (m_pFusionAssembly != NULL)
-        m_pFusionAssembly->Release();
-    if (m_pIHostAssembly != NULL)
-        m_pIHostAssembly->Release();
-    if (m_pNativeAssemblyLocation != NULL)
-    {
-        m_pNativeAssemblyLocation->Release();
-    }
-    if (m_pNativeImageClosure!=NULL)
-        m_pNativeImageClosure->Release();
-    if (m_pFusionLog != NULL)
-        m_pFusionLog->Release();
-#endif // FEATURE_FUSION
     if (m_creator != NULL)
         m_creator->Release();
 
@@ -3222,35 +2389,6 @@ void PEAssembly::ReleaseIL()
     CONTRACTL_END;
 
     GCX_PREEMP();
-#ifdef FEATURE_FUSION
-    if (m_pFusionAssemblyName != NULL)
-    {
-        m_pFusionAssemblyName->Release();
-        m_pFusionAssemblyName=NULL;
-    }
-    if (m_pFusionAssembly != NULL)
-    {
-        m_pFusionAssembly->Release();
-        m_pFusionAssembly=NULL;
-    }
-    if (m_pIHostAssembly != NULL)
-    {
-        m_pIHostAssembly->Release();
-        m_pIHostAssembly=NULL;
-    }
-    if (m_pNativeAssemblyLocation != NULL)
-    {
-        m_pNativeAssemblyLocation->Release();
-        m_pNativeAssemblyLocation=NULL;
-    }
-    _ASSERTE(m_pNativeImageClosure==NULL);
-    
-    if (m_pFusionLog != NULL)
-    {
-        m_pFusionLog->Release();
-        m_pFusionLog=NULL;
-    }
-#endif // FEATURE_FUSION
     if (m_creator != NULL)
     {
         m_creator->Release();
@@ -3263,11 +2401,7 @@ void PEAssembly::ReleaseIL()
 
 /* static */
 
-#ifdef FEATURE_FUSION
-PEAssembly *PEAssembly::OpenSystem(IApplicationContext * pAppCtx)
-#else
 PEAssembly *PEAssembly::OpenSystem(IUnknown * pAppCtx)
-#endif
 {
     STANDARD_VM_CONTRACT;
 
@@ -3292,11 +2426,7 @@ PEAssembly *PEAssembly::OpenSystem(IUnknown * pAppCtx)
 }
 
 /* static */
-#ifdef FEATURE_FUSION
-PEAssembly *PEAssembly::DoOpenSystem(IApplicationContext * pAppCtx)
-#else
 PEAssembly *PEAssembly::DoOpenSystem(IUnknown * pAppCtx)
-#endif
 {
     CONTRACT(PEAssembly *)
     {
@@ -3305,84 +2435,6 @@ PEAssembly *PEAssembly::DoOpenSystem(IUnknown * pAppCtx)
     }
     CONTRACT_END;
 
-#ifdef FEATURE_FUSION
-    SafeComHolder<IAssemblyName> pName;
-    IfFailThrow(CreateAssemblyNameObject(&pName, W("mscorlib"), 0, NULL));
-
-    UINT64 publicKeyValue = I64(CONCAT_MACRO(0x, VER_ECMA_PUBLICKEY));
-    BYTE publicKeyToken[8] =
-        {
-            (BYTE) (publicKeyValue>>56),
-            (BYTE) (publicKeyValue>>48),
-            (BYTE) (publicKeyValue>>40),
-            (BYTE) (publicKeyValue>>32),
-            (BYTE) (publicKeyValue>>24),
-            (BYTE) (publicKeyValue>>16),
-            (BYTE) (publicKeyValue>>8),
-            (BYTE) (publicKeyValue),
-        };
-
-    IfFailThrow(pName->SetProperty(ASM_NAME_PUBLIC_KEY_TOKEN, publicKeyToken, sizeof(publicKeyToken)));
-
-    USHORT version = VER_ASSEMBLYMAJORVERSION;
-    IfFailThrow(pName->SetProperty(ASM_NAME_MAJOR_VERSION, &version, sizeof(version)));
-    version = VER_ASSEMBLYMINORVERSION;
-    IfFailThrow(pName->SetProperty(ASM_NAME_MINOR_VERSION, &version, sizeof(version)));
-    version = VER_ASSEMBLYBUILD;
-    IfFailThrow(pName->SetProperty(ASM_NAME_BUILD_NUMBER, &version, sizeof(version)));
-    version = VER_ASSEMBLYBUILD_QFE;
-    IfFailThrow(pName->SetProperty(ASM_NAME_REVISION_NUMBER, &version, sizeof(version)));
-
-    IfFailThrow(pName->SetProperty(ASM_NAME_CULTURE, W(""), sizeof(WCHAR)));
-
-#ifdef FEATURE_PREJIT
-#ifdef PROFILING_SUPPORTED
-    if (NGENImagesAllowed())
-    {
-        // Binding flags, zap string
-        CorCompileConfigFlags configFlags = PEFile::GetNativeImageConfigFlagsWithOverrides();
-        IfFailThrow(pName->SetProperty(ASM_NAME_CONFIG_MASK, &configFlags, sizeof(configFlags)));
-
-        LPCWSTR configString = g_pConfig->ZapSet();
-        IfFailThrow(pName->SetProperty(ASM_NAME_CUSTOM, (PVOID)configString,
-                                        (DWORD) (wcslen(configString)+1)*sizeof(WCHAR)));
-
-        // @TODO: Need some fuslogvw logging here
-    }
-#endif //PROFILING_SUPPORTED
-#endif // FEATURE_PREJIT
-
-    SafeComHolder<IAssembly> pIAssembly;
-    SafeComHolder<IBindResult> pNativeFusionAssembly;
-    SafeComHolder<IFusionBindLog> pFusionLog;
-
-    {
-        ETWOnStartup (FusionBinding_V1, FusionBindingEnd_V1);
-        IfFailThrow(BindToSystem(pName, SystemDomain::System()->SystemDirectory(), NULL, pAppCtx, &pIAssembly, &pNativeFusionAssembly, &pFusionLog));
-    }
-
-    StackSString path;
-    FusionBind::GetAssemblyManifestModulePath(pIAssembly, path);
-
-    // Open the image with no required mapping.  This will be
-    // promoted to a real open if we don't have a native image.
-    PEImageHolder image (PEImage::OpenImage(path));
-
-    PEAssembly* pPEAssembly = new PEAssembly(image, NULL, pIAssembly,pNativeFusionAssembly, NULL, pFusionLog, NULL, NULL, TRUE, FALSE);
-
-#ifdef FEATURE_APPX_BINDER
-    if (AppX::IsAppXProcess())
-    {
-        // Since mscorlib is loaded as a special case, create and assign an ICLRPrivAssembly for the new PEAssembly here.
-        CLRPrivBinderAppX *   pBinder = CLRPrivBinderAppX::GetOrCreateBinder();
-        CLRPrivBinderFusion * pFusionBinder = pBinder->GetFusionBinder();
-        
-        pFusionBinder->BindMscorlib(pPEAssembly);
-    }
-#endif
-    
-    RETURN pPEAssembly;
-#else // FEATURE_FUSION
     ETWOnStartup (FusionBinding_V1, FusionBindingEnd_V1);
     CoreBindResult bindResult;
     ReleaseHolder<ICLRPrivAssembly> pPrivAsm;
@@ -3393,153 +2445,8 @@ PEAssembly *PEAssembly::DoOpenSystem(IUnknown * pAppCtx)
     }
 
     RETURN new PEAssembly(&bindResult, NULL, NULL, TRUE, FALSE);
-#endif // FEATURE_FUSION
 }
 
-#ifdef FEATURE_FUSION
-/* static */
-PEAssembly *PEAssembly::Open(IAssembly *pIAssembly,
-                             IBindResult *pNativeFusionAssembly,
-                             IFusionBindLog *pFusionLog/*=NULL*/,
-                             BOOL isSystemAssembly/*=FALSE*/,
-                             BOOL isIntrospectionOnly/*=FALSE*/)
-{
-    STANDARD_VM_CONTRACT;
-
-    PEAssembly *result = NULL;
-    EX_TRY
-    {
-        result = DoOpen(pIAssembly, pNativeFusionAssembly, pFusionLog, isSystemAssembly, isIntrospectionOnly);
-    }
-    EX_HOOK
-    {
-        Exception *ex = GET_EXCEPTION();
-
-        // Rethrow non-transient exceptions as file load exceptions with proper
-        // context
-        if (!ex->IsTransient())
-            EEFileLoadException::Throw(pIAssembly, NULL, ex->GetHR(), ex);
-    }
-    EX_END_HOOK;
-
-    return result;
-}
-
-// Thread stress
-class DoOpenIAssemblyStress : APIThreadStress
-{
-public:
-    IAssembly *pIAssembly;
-    IBindResult *pNativeFusionAssembly;
-    IFusionBindLog *pFusionLog;
-    DoOpenIAssemblyStress(IAssembly *pIAssembly, IBindResult *pNativeFusionAssembly, IFusionBindLog *pFusionLog)
-          : pIAssembly(pIAssembly), pNativeFusionAssembly(pNativeFusionAssembly),pFusionLog(pFusionLog) {LIMITED_METHOD_CONTRACT;}
-    void Invoke()
-    {
-        WRAPPER_NO_CONTRACT;
-        PEAssemblyHolder result (PEAssembly::Open(pIAssembly, pNativeFusionAssembly, pFusionLog, FALSE, FALSE));
-    }
-};
-
-/* static */
-PEAssembly *PEAssembly::DoOpen(IAssembly *pIAssembly,
-                               IBindResult *pNativeFusionAssembly,
-                               IFusionBindLog *pFusionLog,
-                               BOOL isSystemAssembly,
-                               BOOL isIntrospectionOnly/*=FALSE*/)
-{
-    CONTRACT(PEAssembly *)
-    {
-        PRECONDITION(CheckPointer(pIAssembly));
-        POSTCONDITION(CheckPointer(RETVAL));
-        STANDARD_VM_CHECK;
-    }
-    CONTRACT_END;
-
-    DoOpenIAssemblyStress ts(pIAssembly,pNativeFusionAssembly,pFusionLog);
-
-    PEImageHolder image;
-
-    StackSString path;
-    FusionBind::GetAssemblyManifestModulePath(pIAssembly, path);
-
-    // Open the image with no required mapping.  This will be
-    // promoted to a real open if we don't have a native image.
-    image = PEImage::OpenImage(path, MDInternalImport_NoCache); // "identity" does not need to be cached 
-
-    PEAssemblyHolder assembly (new PEAssembly(image, NULL, pIAssembly, pNativeFusionAssembly, NULL, pFusionLog,
-                                               NULL, NULL, isSystemAssembly, isIntrospectionOnly));
-
-    RETURN assembly.Extract();
-}
-
-/* static */
-PEAssembly *PEAssembly::Open(IHostAssembly *pIHostAssembly, BOOL isSystemAssembly, BOOL isIntrospectionOnly)
-{
-    STANDARD_VM_CONTRACT;
-
-    PEAssembly *result = NULL;
-
-    EX_TRY
-    {
-        result = DoOpen(pIHostAssembly, isSystemAssembly, isIntrospectionOnly);
-    }
-    EX_HOOK
-    {
-        Exception *ex = GET_EXCEPTION();
-
-        // Rethrow non-transient exceptions as file load exceptions with proper
-        // context
-
-        if (!ex->IsTransient())
-            EEFileLoadException::Throw(NULL, pIHostAssembly, ex->GetHR(), ex);
-    }
-    EX_END_HOOK;
-    return result;
-}
-
-// Thread stress
-class DoOpenIHostAssemblyStress : APIThreadStress
-{
-public:
-    IHostAssembly *pIHostAssembly;
-    DoOpenIHostAssemblyStress(IHostAssembly *pIHostAssembly) :
-        pIHostAssembly(pIHostAssembly) {LIMITED_METHOD_CONTRACT;}
-    void Invoke()
-    {
-        WRAPPER_NO_CONTRACT;
-        PEAssemblyHolder result (PEAssembly::Open(pIHostAssembly, FALSE, FALSE));
-    }
-};
-
-/* static */
-PEAssembly *PEAssembly::DoOpen(IHostAssembly *pIHostAssembly, BOOL isSystemAssembly,
-                               BOOL isIntrospectionOnly)
-{
-    CONTRACT(PEAssembly *)
-    {
-        PRECONDITION(CheckPointer(pIHostAssembly));
-        POSTCONDITION(CheckPointer(RETVAL));
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACT_END;
-
-    DoOpenIHostAssemblyStress ts(pIHostAssembly);
-
-    UINT64 AssemblyId;
-    IfFailThrow(pIHostAssembly->GetAssemblyId(&AssemblyId));
-
-    PEImageHolder image(PEImage::FindById(AssemblyId, 0));
-
-    PEAssemblyHolder assembly (new PEAssembly(image, NULL, NULL, NULL, NULL, NULL,
-                                              pIHostAssembly, NULL, isSystemAssembly, isIntrospectionOnly));
-
-    RETURN assembly.Extract();
-}
-#endif // FEATURE_FUSION
 
 #ifndef CROSSGEN_COMPILE
 /* static */
@@ -3621,29 +2528,13 @@ PEAssembly *PEAssembly::DoOpenMemory(
     if (!image->CheckILFormat())
         ThrowHR(COR_E_BADIMAGEFORMAT, BFA_BAD_IL);
 
-#if !defined(FEATURE_CORECLR)
-    if(pBinderToUse != NULL && !isIntrospectionOnly)
-    {
-        ReleaseHolder<ICLRPrivAssembly> pAsm;
-        ReleaseHolder<IAssemblyName> pAssemblyName;
-        IfFailThrow(pBinderToUse->BindAssemblyExplicit(image, &pAssemblyName, &pAsm));
-        PEAssembly* pFile = nullptr;
-        IfFailThrow(GetAppDomain()->BindHostedPrivAssembly(pParentAssembly, pAsm, pAssemblyName, &pFile));
-        _ASSERTE(pFile);
-        RETURN pFile;
-    }
-#endif // !FEATURE_CORECLR
 
-#ifdef FEATURE_FUSION    
-    RETURN new PEAssembly(image, NULL, NULL, NULL, NULL, NULL, NULL, pParentAssembly, FALSE, isIntrospectionOnly);
-#else
     CoreBindResult bindResult;
     ReleaseHolder<ICLRPrivAssembly> assembly;
     IfFailThrow(CCoreCLRBinderHelper::GetAssemblyFromImage(image, NULL, &assembly));
     bindResult.Init(assembly,FALSE,FALSE);
 
     RETURN new PEAssembly(&bindResult, NULL, pParentAssembly, FALSE, isIntrospectionOnly);
-#endif
 }
 #endif // !CROSSGEN_COMPILE
 
@@ -3728,7 +2619,6 @@ PEAssembly *PEAssembly::DoOpenHMODULE(HMODULE hMod,
 #endif // FEATURE_MIXEDMODE && !CROSSGEN_COMPILE
 
 
-#ifndef FEATURE_FUSION
 PEAssembly* PEAssembly::Open(CoreBindResult* pBindResult,
                                    BOOL isSystem, BOOL isIntrospectionOnly)
 {
@@ -3736,7 +2626,6 @@ PEAssembly* PEAssembly::Open(CoreBindResult* pBindResult,
     return new PEAssembly(pBindResult,NULL,NULL,isSystem,isIntrospectionOnly);
 
 };
-#endif
 
 /* static */
 PEAssembly *PEAssembly::Create(PEAssembly *pParentAssembly,
@@ -3756,99 +2645,14 @@ PEAssembly *PEAssembly::Create(PEAssembly *pParentAssembly,
     // we have.)
     SafeComHolder<IMetaDataEmit> pEmit;
     pAssemblyEmit->QueryInterface(IID_IMetaDataEmit, (void **)&pEmit);
-#ifdef FEATURE_FUSION
-    ReleaseHolder<ICLRPrivAssembly> pPrivAssembly;
-    if (pParentAssembly->HasHostAssembly())
-    {
-        // Dynamic assemblies in AppX use their parent's ICLRPrivAssembly as the binding context.
-        pPrivAssembly = clr::SafeAddRef(new CLRPrivBinderUtil::CLRPrivBinderAsAssemblyWrapper(
-            pParentAssembly->GetHostAssembly()));
-    }
-
-    PEAssemblyHolder pFile(new PEAssembly(
-        NULL, pEmit, NULL, NULL, NULL, NULL, NULL, pParentAssembly,
-        FALSE, bIsIntrospectionOnly,
-        pPrivAssembly));
-#else
     PEAssemblyHolder pFile(new PEAssembly(NULL, pEmit, pParentAssembly, FALSE, bIsIntrospectionOnly));
-#endif
     RETURN pFile.Extract();
 }
 
 
 #ifdef FEATURE_PREJIT
 
-#ifdef FEATURE_FUSION
-BOOL PEAssembly::HasEqualNativeClosure(DomainAssembly * pDomainAssembly)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        THROWS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pDomainAssembly));
-    }
-    CONTRACTL_END;
-    if (IsSystem())
-        return TRUE;
-    HRESULT hr = S_OK;
-
-
-    if (m_pNativeImageClosure == NULL)
-        return FALSE;
-
-    // ensure theclosures are walked
-    IAssemblyBindingClosure * pClosure = pDomainAssembly->GetAssemblyBindingClosure(LEVEL_COMPLETE);
-    _ASSERTE(pClosure != NULL);
-
-    if (m_pNativeImageClosure->HasBeenWalked(LEVEL_COMPLETE) != S_OK )
-    {
-        GCX_COOP();
-
-        ENTER_DOMAIN_PTR(SystemDomain::System()->DefaultDomain(),ADV_DEFAULTAD);
-        {
-            GCX_PREEMP();
-            IfFailThrow(m_pNativeImageClosure->EnsureWalked(GetFusionAssembly(),GetAppDomain()->GetFusionContext(),LEVEL_COMPLETE));
-        }
-        END_DOMAIN_TRANSITION;
-    }
-
-
-    hr = pClosure->IsEqual(m_pNativeImageClosure);
-    IfFailThrow(hr);
-    return (hr == S_OK);
-}
-#endif //FEATURE_FUSION
-
-#ifdef FEATURE_FUSION
-void PEAssembly::SetNativeImage(IBindResult *pNativeFusionAssembly)
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        STANDARD_VM_CHECK;
-    }
-    CONTRACTL_END;
-
-    StackSString path;
-    WCHAR pwzPath[MAX_LONGPATH];
-    DWORD dwCCPath = MAX_LONGPATH;
-    ReleaseHolder<IAssemblyLocation> pIAssemblyLocation;
-
-    IfFailThrow(pNativeFusionAssembly->GetAssemblyLocation(&pIAssemblyLocation));
-    IfFailThrow(pIAssemblyLocation->GetPath(pwzPath, &dwCCPath));
-    path.Set(pwzPath);
 
-    PEImageHolder image(PEImage::OpenImage(path));
-    image->Load();
-
-    // For desktop dev11, this verification is now done at native binding time.
-    _ASSERTE(CheckNativeImageVersion(image));
-
-    PEFile::SetNativeImage(image);
-    IfFailThrow(pNativeFusionAssembly->GetAssemblyLocation(&m_pNativeAssemblyLocation));
-}
-#else //FEATURE_FUSION
 void PEAssembly::SetNativeImage(PEImage * image)
 {
     CONTRACTL
@@ -3891,243 +2695,23 @@ void PEAssembly::SetNativeImage(PEImage * image)
         ExternalLog(LL_WARNING, "Native image is not correct version.");
     }
 }
-#endif //FEATURE_FUSION
 
-#ifdef FEATURE_FUSION
-void PEAssembly::ClearNativeImage()
-{
-    CONTRACT_VOID
-    {
-        INSTANCE_CHECK;
-        PRECONDITION(HasNativeImage());
-        POSTCONDITION(!HasNativeImage());
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACT_END;
-
-    PEFile::ClearNativeImage();
-
-    if (m_pNativeAssemblyLocation != NULL)
-        m_pNativeAssemblyLocation->Release();
-    m_pNativeAssemblyLocation = NULL;
-    if (m_pNativeImageClosure != NULL)
-        m_pNativeImageClosure->Release();
-    m_pNativeImageClosure = NULL;
-    RETURN;
-}
-#endif //FEATURE_FUSION
 #endif  // FEATURE_PREJIT
 
 
-#ifdef FEATURE_FUSION
-BOOL PEAssembly::IsBindingCodeBase()
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    if (m_pIHostAssembly != NULL)
-        return FALSE;
-
-    if (m_pFusionAssembly == NULL)
-        return (!GetPath().IsEmpty());
-
-    if (m_dwLocationFlags == ASMLOC_UNKNOWN)
-        return FALSE;
-
-    return ((m_dwLocationFlags & ASMLOC_CODEBASE_HINT) != 0);
-}
-
-BOOL PEAssembly::IsSourceGAC()
-{
-    LIMITED_METHOD_CONTRACT;
-
-    if ((m_pIHostAssembly != NULL) || (m_pFusionAssembly == NULL))
-    {
-        return FALSE;
-    }
-
-    return ((m_dwLocationFlags & ASMLOC_LOCATION_MASK) == ASMLOC_GAC);
-}
-
-BOOL PEAssembly::IsSourceDownloadCache()
-{
-    LIMITED_METHOD_CONTRACT;
-
-    if ((m_pIHostAssembly != NULL) || (m_pFusionAssembly == NULL))
-    {
-        return FALSE;
-    }
-    
-    return ((m_dwLocationFlags & ASMLOC_LOCATION_MASK) == ASMLOC_DOWNLOAD_CACHE);
-}
-
-#else // FEATURE_FUSION
 BOOL PEAssembly::IsSourceGAC()
 {
     WRAPPER_NO_CONTRACT;
     return m_bIsFromGAC;
 };
 
-#endif // FEATURE_FUSION
 
 #endif // #ifndef DACCESS_COMPILE
 
-#ifdef FEATURE_FUSION
-BOOL PEAssembly::IsContextLoad()
-{
-    LIMITED_METHOD_CONTRACT;
-    if ((m_pIHostAssembly != NULL) || (m_pFusionAssembly == NULL))
-    {
-        return FALSE;
-    }
-    return (IsSystem() || (m_loadContext == LOADCTX_TYPE_DEFAULT));
-}
-
-LOADCTX_TYPE PEAssembly::GetLoadContext()
-{
-    LIMITED_METHOD_CONTRACT;
-
-    return m_loadContext;
-}
-
-DWORD PEAssembly::GetLocationFlags()
-{
-    LIMITED_METHOD_CONTRACT;
-
-    return m_dwLocationFlags;
-}
-
-#endif
 
 
 #ifndef DACCESS_COMPILE
 
-#ifdef FEATURE_FUSION
-PEKIND PEAssembly::GetFusionProcessorArchitecture()
-{
-    CONTRACTL
-    {
-        THROWS;
-        MODE_ANY;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-
-    PEImage * pImage = NULL;
-
-#ifdef FEATURE_PREJIT 
-    pImage = m_nativeImage;
-#endif
-
-    if (pImage == NULL)
-        pImage = GetILimage();
-
-    return pImage->GetFusionProcessorArchitecture();
-}
-
-IAssemblyName * PEAssembly::GetFusionAssemblyName()
-{
-    CONTRACT(IAssemblyName *)
-    {
-        INSTANCE_CHECK;
-        POSTCONDITION(CheckPointer(RETVAL));
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACT_END;
-
-    if (m_pFusionAssemblyName == NULL)
-    {
-        AssemblySpec spec;
-        spec.InitializeSpec(this);
-        PEImage * pImage = GetILimage();
-
-#ifdef FEATURE_PREJIT 
-        if ((pImage != NULL) && !pImage->MDImportLoaded())
-            pImage = m_nativeImage;
-#endif
-
-        if (pImage != NULL)
-        {
-            spec.SetPEKIND(pImage->GetFusionProcessorArchitecture());
-        }
-
-        GCX_PREEMP();
-
-        IfFailThrow(spec.CreateFusionName(&m_pFusionAssemblyName, FALSE));
-    }
-
-    RETURN m_pFusionAssemblyName;
-}
-
-// This version of GetFusionAssemlyName that can be used to return the reference in a
-// NOTHROW/NOTRIGGER fashion. This is useful for scenarios where you dont want to invoke the THROWS/GCTRIGGERS
-// version when you know the name would have been created and is available.
-IAssemblyName * PEAssembly::GetFusionAssemblyNameNoCreate()
-{
-    LIMITED_METHOD_CONTRACT;
-
-    return m_pFusionAssemblyName;
-}
-
-IAssembly *PEAssembly::GetFusionAssembly()
-{
-    CONTRACT(IAssembly *)
-    {
-        INSTANCE_CHECK;
-        POSTCONDITION(CheckPointer(RETVAL, NULL_OK));
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACT_END;
-
-    RETURN m_pFusionAssembly;
-}
-
-IHostAssembly *PEAssembly::GetIHostAssembly()
-{
-    CONTRACT(IHostAssembly *)
-    {
-        INSTANCE_CHECK;
-        POSTCONDITION(CheckPointer(RETVAL, NULL_OK));
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACT_END;
-
-    RETURN m_pIHostAssembly;
-}
-
-IAssemblyLocation *PEAssembly::GetNativeAssemblyLocation()
-{
-    CONTRACT(IAssemblyLocation *)
-    {
-        INSTANCE_CHECK;
-        PRECONDITION(HasNativeImage());
-        POSTCONDITION(CheckPointer(RETVAL));
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACT_END;
-
-    RETURN m_pNativeAssemblyLocation;
-}
-#endif // FEATURE_FUSION
 
 // ------------------------------------------------------------
 // Hash support
@@ -4151,13 +2735,8 @@ void PEAssembly::VerifyStrongName()
         return;
     }
 
-#ifdef FEATURE_FUSION
-    // System and dynamic assemblies don't need hash checks
-    if (IsSystem() || IsDynamic())
-#else
     // Without FUSION/GAC, we need to verify SN on all assemblies, except dynamic assemblies.
     if (IsDynamic())
-#endif
     {
 
         m_flags |= PEFILE_SKIP_MODULE_HASH_CHECKS;
@@ -4166,72 +2745,18 @@ void PEAssembly::VerifyStrongName()
     }
 
     // Next, verify the strong name, if necessary
-#ifdef FEATURE_FUSION
-    // See if the assembly comes from a secure location
-    IAssembly *pFusionAssembly = GetAssembly()->GetFusionAssembly();
-    if (pFusionAssembly)
-    {
-        DWORD dwLocation;
-        IfFailThrow(pFusionAssembly->GetAssemblyLocation(&dwLocation));
-
-        switch (dwLocation & ASMLOC_LOCATION_MASK)
-        {
-        case ASMLOC_GAC:
-        case ASMLOC_DOWNLOAD_CACHE:
-        case ASMLOC_DEV_OVERRIDE:
-            // Assemblies from the GAC or download cache have
-            // already been verified by Fusion.
-            m_flags |= PEFILE_SKIP_MODULE_HASH_CHECKS;
-            m_fStrongNameVerified = TRUE;
-            return;
-
-        case ASMLOC_RUN_FROM_SOURCE:
-        case ASMLOC_UNKNOWN:
-            // For now, just verify these every time, we need to
-            // cache the fact that at least one verification has
-            // been performed (if strong name policy permits
-            // caching of verification results)
-            break;
-
-        default:
-            UNREACHABLE();
-        }
-    }
-#endif
 
     // Check format of image. Note we must delay this until after the GAC status has been
     // checked, to handle the case where we are not loading m_image.
     EnsureImageOpened();
 
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-    if (IsWindowsRuntime())
-    {
-        // Winmd files are always loaded in full trust.
-        m_flags |= PEFILE_SKIP_MODULE_HASH_CHECKS;
-        m_fStrongNameVerified = TRUE;        
-        return;
-    }
-#endif
 
-#if defined(FEATURE_CORECLR) || defined(CROSSGEN_COMPILE)
     if (m_nativeImage == NULL && !GetILimage()->IsTrustedNativeImage())
-#else
-    if (!GetILimage()->IsTrustedNativeImage())
-#endif
     {
         if (!GetILimage()->CheckILFormat())
             ThrowHR(COR_E_BADIMAGEFORMAT);
     }
 
-#if defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)
-    // Do not validate strong name signature during CrossGen. This is necessary
-    // to make build-lab scenarios to work.
-    if (IsCompilationProcess())
-    {
-        m_flags |= PEFILE_SKIP_MODULE_HASH_CHECKS;
-    }
-    else
-#endif
     // Check the strong name if present.
     if (IsIntrospectionOnly())
     {
@@ -4239,59 +2764,16 @@ void PEAssembly::VerifyStrongName()
         // need to do module hash checks.
         m_flags |= PEFILE_SKIP_MODULE_HASH_CHECKS;
     }
-#if !defined(FEATURE_CORECLR)    
-    //We do this to early out for WinMD files that are unsigned but have NI images as well.
-    else if (!HasStrongNameSignature())
-    {
-#ifdef FEATURE_CAS_POLICY
-        // We only check module hashes if there is a strong name or Authenticode signature
-        if (m_certificate == NULL)
-        {
-            m_flags |= PEFILE_SKIP_MODULE_HASH_CHECKS;
-        }
-#endif
-    }
-#endif // !defined(FEATURE_CORECLR)    
     else
     {
-#ifdef FEATURE_CORECLR
         // Runtime policy on CoreCLR is to skip verification of ALL assemblies
         m_flags |= PEFILE_SKIP_MODULE_HASH_CHECKS;
         m_fStrongNameVerified = TRUE;
-#else
-        DWORD verifyOutputFlags = 0;
-        HRESULT hr = GetILimage()->VerifyStrongName(&verifyOutputFlags);
-
-        if (SUCCEEDED(hr))
-        {
-            // Strong name verified or delay sign OK'ed.
-            // We will skip verification of modules in the delay signed case.
-
-            if ((verifyOutputFlags & SN_OUTFLAG_WAS_VERIFIED) == 0)
-                m_flags |= PEFILE_SKIP_MODULE_HASH_CHECKS;
-        }
-        else
-        {
-            // Strong name missing or error.  Throw in the latter case.
-            if (hr != CORSEC_E_MISSING_STRONGNAME)
-                ThrowHR(hr);
-
-#ifdef FEATURE_CAS_POLICY
-            // Since we are not strong named, don't check module hashes.
-            // (Unless we have a security certificate, in which case check anyway.)
-
-            if (m_certificate == NULL)
-                m_flags |= PEFILE_SKIP_MODULE_HASH_CHECKS;
-#endif
-        }
-
-#endif // FEATURE_CORECLR
     }
 
     m_fStrongNameVerified = TRUE;
 }
 
-#ifdef FEATURE_CORECLR
 BOOL PEAssembly::IsProfileAssembly()
 {
     CONTRACTL
@@ -4324,7 +2806,6 @@ BOOL PEAssembly::IsProfileAssembly()
     m_fProfileAssembly = bProfileAssembly ? 1 : -1;
     return bProfileAssembly;
 }
-#endif // FEATURE_CORECLR
 
 // ------------------------------------------------------------
 // Descriptive strings
@@ -4374,29 +2855,6 @@ void PEAssembly::GetCodeBase(SString &result, BOOL fCopiedName/*=FALSE*/)
         INJECT_FAULT(COMPlusThrowOM(););
     }
     CONTRACTL_END;
-#ifdef FEATURE_FUSION
-    // For a copied name, we always use the actual file path rather than the fusion info
-    if (!fCopiedName && m_pFusionAssembly)
-    {
-        if ( ((m_dwLocationFlags & ASMLOC_LOCATION_MASK) == ASMLOC_RUN_FROM_SOURCE) ||
-             ((m_dwLocationFlags & ASMLOC_LOCATION_MASK) == ASMLOC_DOWNLOAD_CACHE) )
-        {
-            // Assemblies in the download cache or run from source should have
-            // a proper codebase set in them.
-            FusionBind::GetAssemblyNameStringProperty(GetFusionAssemblyName(),
-                                                      ASM_NAME_CODEBASE_URL,
-                                                      result);
-            return;
-        }
-    }
-    else if (m_pIHostAssembly)
-    {
-        FusionBind::GetAssemblyNameStringProperty(GetFusionAssemblyName(),
-                                                  ASM_NAME_CODEBASE_URL,
-                                                  result);
-        return;
-    }
-#endif    
 
     // All other cases use the file path.
     result.Set(GetEffectivePath());
@@ -4512,21 +2970,6 @@ void PEAssembly::ExternalVLog(DWORD facility, DWORD level, const WCHAR *fmt, va_
 
     PEFile::ExternalVLog(facility, level, fmt, args);
 
-#ifdef FEATURE_FUSION
-    if (FusionLoggingEnabled())
-    {
-        DWORD dwLogCategory = (facility == LF_ZAP ? FUSION_BIND_LOG_CATEGORY_NGEN : FUSION_BIND_LOG_CATEGORY_DEFAULT);
-
-        StackSString message;
-        message.VPrintf(fmt, args);
-        m_pFusionLog->LogMessage(0, dwLogCategory, message);
-
-        if (level == LL_ERROR) {
-            m_pFusionLog->SetResultCode(dwLogCategory, E_FAIL);
-            FlushExternalLog();
-        }
-    }
-#endif //FEATURE_FUSION
 
     RETURN;
 }
@@ -4540,12 +2983,6 @@ void PEAssembly::FlushExternalLog()
     }
     CONTRACT_END;
 
-#ifdef FEATURE_FUSION
-    if (FusionLoggingEnabled()) {
-        m_pFusionLog->Flush(g_dwLogLevel,  FUSION_BIND_LOG_CATEGORY_NGEN);
-        m_pFusionLog->Flush(g_dwLogLevel,  FUSION_BIND_LOG_CATEGORY_DEFAULT);
-    }
-#endif //FEATURE_FUSION
 
     RETURN;
 }
@@ -4822,22 +3259,6 @@ PEModule *PEModule::DoOpen(PEAssembly *assembly, mdFile token,
     IfFailThrow(assembly->GetPersistentMDImport()->GetFileProps(token, NULL, NULL, NULL, &flags));
     
     PEImageHolder image;
-#ifdef FEATURE_FUSION
-    if (assembly->IsIStream())
-    {
-        SafeComHolder<IHostAssemblyModuleImport> pModuleImport;
-        IfFailThrow(assembly->GetIHostAssembly()->GetModuleByName(fileName, &pModuleImport));
-        
-        SafeComHolder<IStream> pIStream;
-        IfFailThrow(pModuleImport->GetModuleStream(&pIStream));
-        
-        DWORD dwModuleId;
-        IfFailThrow(pModuleImport->GetModuleId(&dwModuleId));
-        image = PEImage::OpenImage(pIStream, assembly->m_identity->m_StreamAsmId,
-                                   dwModuleId, (flags & ffContainsNoMetaData));
-    }
-    else
-#endif
     {
         image = PEImage::OpenImage(fileName);
     }
@@ -5097,26 +3518,6 @@ LPCWSTR PEFile::GetPathForErrorMessages()
     }
 }
 
-#ifndef FEATURE_CORECLR
-BOOL PEAssembly::IsReportedToUsageLog()
-{
-    LIMITED_METHOD_CONTRACT;
-    BOOL fReported = TRUE;
-
-    if (!IsDynamic())
-        fReported = m_identity->IsReportedToUsageLog();
-
-    return fReported;
-}
-
-void PEAssembly::SetReportedToUsageLog()
-{
-    LIMITED_METHOD_CONTRACT;
-
-    if (!IsDynamic())
-        m_identity->SetReportedToUsageLog();
-}
-#endif // !FEATURE_CORECLR
 
 #ifdef DACCESS_COMPILE
 TADDR PEFile::GetMDInternalRWAddress()
@@ -5149,12 +3550,10 @@ PTR_ICLRPrivBinder PEFile::GetBindingContext()
     
     PTR_ICLRPrivBinder pBindingContext = NULL;
     
-#if defined(FEATURE_CORECLR)    
     // Mscorlib is always bound in context of the TPA Binder. However, since it gets loaded and published
     // during EEStartup *before* TPAbinder is initialized, we dont have a binding context to publish against.
     // Thus, we will always return NULL for its binding context.
     if (!IsSystem())
-#endif // defined(FEATURE_CORECLR)    
     {
         pBindingContext = dac_cast<PTR_ICLRPrivBinder>(GetHostAssembly());
     }
diff --git a/src/vm/pefile.h b/src/vm/pefile.h
index 413d08c185..697ce03749 100644
--- a/src/vm/pefile.h
+++ b/src/vm/pefile.h
@@ -26,11 +26,6 @@
 #include "loaderheap.h"
 #include "sstring.h"
 #include "ex.h"
-#ifdef FEATURE_FUSION
-#include <fusion.h>
-#include <fusionbind.h>
-#include "binderngen.h"
-#endif
 #include "assemblyspecbase.h"
 #include "eecontract.h"
 #include "metadatatracker.h"
@@ -194,9 +189,6 @@ public:
     BOOL Equals(PEImage *pImage);
 #endif // DACCESS_COMPILE
 
-#ifndef FEATURE_CORECLR
-    BOOL  IsShareable();
-#endif
 
     void GetMVID(GUID *pMvid);
 
@@ -291,9 +283,6 @@ public:
     LPCSTR GetLocale();
     DWORD GetFlags();
     HRESULT GetFlagsNoTrigger(DWORD * pdwFlags);
-#ifdef FEATURE_CAS_POLICY
-    COR_TRUST *GetAuthenticodeSignature();
-#endif
     // ------------------------------------------------------------
     // PE file access
     // ------------------------------------------------------------
@@ -347,9 +336,6 @@ public:
 
     ULONG GetILImageTimeDateStamp();
 
-#ifdef FEATURE_CAS_POLICY
-    SAFEHANDLE GetSafeHandle();
-#endif // FEATURE_CAS_POLICY
 
     // ------------------------------------------------------------
     // Image memory access
@@ -520,10 +506,6 @@ protected:
     void ConvertMDInternalToReadWrite();
     void ReleaseMetadataInterfaces(BOOL bDestructor, BOOL bKeepNativeData=FALSE);
 
-#ifdef FEATURE_CAS_POLICY
-    // Check the Authenticode signature of a PE file
-    void CheckAuthenticodeSignature();
-#endif // FEATURE_CAS_POLICY
 
     friend class Module;
 #ifdef FEATURE_PREJIT
@@ -572,21 +554,11 @@ protected:
 #endif
     IMetaDataImport2        *m_pImporter;
     IMetaDataEmit           *m_pEmitter;
-#ifndef FEATURE_CORECLR
-    IMetaDataAssemblyImport *m_pAssemblyImporter;
-    IMetaDataAssemblyEmit   *m_pAssemblyEmitter;
-#endif
     SimpleRWLock            *m_pMetadataLock;
     Volatile<LONG>           m_refCount;
     SBuffer                 *m_hash;                   // cached SHA1 hash value
     int                     m_flags;
     BOOL                    m_fStrongNameVerified;
-#ifdef FEATURE_CAS_POLICY
-    COR_TRUST               *m_certificate;
-    BOOL                    m_fCheckedCertificate;
-    IInternetSecurityManager    *m_pSecurityManager;
-    Crst                         m_securityManagerLock;
-#endif // FEATURE_CAS_POLICY
 
 #ifdef DEBUGGING_SUPPORTED
 #ifdef FEATURE_PREJIT
@@ -659,7 +631,6 @@ public:
 protected:
     PTR_ICLRPrivAssembly m_pHostAssembly;
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
     // For certain assemblies, we do not have m_pHostAssembly since they are not bound using an actual binder.
     // An example is Ref-Emitted assemblies. Thus, when such assemblies trigger load of their dependencies, 
     // we need to ensure they are loaded in appropriate load context.
@@ -668,13 +639,10 @@ protected:
     // assembly that created the dynamic assembly. If the creator assembly is dynamic itself, then its fallback
     // load context would be propagated to the assembly being dynamically generated.
     ICLRPrivBinder *m_pFallbackLoadContextBinder;
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
 protected:
 
-    friend class CLRPrivBinderFusion;
 #ifndef DACCESS_COMPILE
-    // CLRPrivBinderFusion calls this for Fusion-bound assemblies in AppX processes.
     void SetHostAssembly(ICLRPrivAssembly * pHostAssembly)
     { LIMITED_METHOD_CONTRACT; m_pHostAssembly = clr::SafeAddRef(pHostAssembly); }
 #endif //DACCESS_COMPILE
@@ -696,7 +664,6 @@ public:
     bool CanUseWithBindingCache()
     { LIMITED_METHOD_CONTRACT; return !HasHostAssembly(); }
 
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
     void SetFallbackLoadContextBinder(ICLRPrivBinder *pFallbackLoadContextBinder)
     { 
         LIMITED_METHOD_CONTRACT; 
@@ -709,7 +676,6 @@ public:
 
         return m_pFallbackLoadContextBinder;
     }
-#endif //defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 };  // class PEFile
 
 
@@ -728,19 +694,6 @@ class PEAssembly : public PEFile
     // Public API
     // ------------------------------------------------------------
 
-#if !defined(FEATURE_CORECLR)
-    static PEAssembly * Open(
-        PEAssembly *       pParentAssembly,
-        PEImage *          pPEImageIL, 
-        PEImage *          pPEImageNI, 
-        ICLRPrivAssembly * pHostAssembly, 
-        BOOL               fIsIntrospectionOnly);
-    
-    static PEAssembly * Open(
-        PEAssembly * pParentAssembly, 
-        PEImage *    pPEImageIL, 
-        BOOL         isIntrospectionOnly = FALSE);
-#else //!FEATURE_CORECLR
     // CoreCLR's PrivBinder PEAssembly creation entrypoint
     static PEAssembly * Open(
         PEAssembly *       pParent,
@@ -748,69 +701,17 @@ class PEAssembly : public PEFile
         PEImage *          pPEImageNI, 
         ICLRPrivAssembly * pHostAssembly, 
         BOOL               fIsIntrospectionOnly = FALSE);
-#endif //!FEATURE_CORECLR
 
     // This opens the canonical mscorlib.dll
-#ifdef FEATURE_FUSION
-    static PEAssembly *OpenSystem(IApplicationContext *pAppCtx);
-#else
     static PEAssembly *OpenSystem(IUnknown *pAppCtx);
-#endif
 #ifdef DACCESS_COMPILE
     virtual void EnumMemoryRegions(CLRDataEnumMemoryFlags flags);
 #endif
 
-#ifdef FEATURE_FUSION
-    static PEAssembly *Open(
-        IAssembly *pIAssembly,
-        IBindResult *pNativeFusionAssembly,
-        IFusionBindLog *pFusionLog = NULL,
-        BOOL isSystemAssembly = FALSE,
-        BOOL isIntrospectionOnly = FALSE);
-
-    static PEAssembly *Open(
-        IHostAssembly *pIHostAssembly,
-        BOOL isSystemAssembly = FALSE,
-        BOOL isIntrospectionOnly = FALSE);
-
-#ifdef FEATURE_MIXEDMODE
-    // Use for main exe loading
-    // NOTE: This may also be used for "spontaneous" (IJW) dll loading where
-    //      we need to deliver DllMain callbacks, but we should eliminate this case
-
-    static PEAssembly *OpenHMODULE(
-        HMODULE hMod,
-        IAssembly *pFusionAssembly,
-        IBindResult *pNativeFusionAssembly,
-        IFusionBindLog *pFusionLog = NULL,
-        BOOL isIntrospectionOnly = FALSE);
-#endif // FEATURE_MIXEDMODE
-
-    static PEAssembly *DoOpen(
-        IAssembly *pIAssembly,
-        IBindResult *pNativeFusionAssembly,
-        IFusionBindLog *pFusionLog,
-        BOOL isSystemAssembly,
-        BOOL isIntrospectionOnly = FALSE);
-
-    static PEAssembly *DoOpen(
-        IHostAssembly *pIHostAssembly,
-        BOOL isSystemAssembly,
-        BOOL isIntrospectionOnly = FALSE);
-#ifdef FEATURE_MIXEDMODE
-    static PEAssembly *DoOpenHMODULE(
-        HMODULE hMod,
-        IAssembly *pFusionAssembly,
-        IBindResult *pNativeFusionAssembly,
-        IFusionBindLog *pFusionLog,
-        BOOL isIntrospectionOnly = FALSE);
-#endif // FEATURE_MIXEDMODE
-#else
     static PEAssembly *Open(
         CoreBindResult* pBindResult,
         BOOL isSystem,
         BOOL isIntrospectionOnly);
-#endif // FEATURE_FUSION
 
     static PEAssembly *Create(
         PEAssembly *pParentAssembly,
@@ -833,11 +734,7 @@ class PEAssembly : public PEFile
 
   private:
     // Private helpers for crufty exception handling reasons
-#ifdef FEATURE_FUSION
-    static PEAssembly *DoOpenSystem(IApplicationContext *pAppCtx);
-#else
     static PEAssembly *DoOpenSystem(IUnknown *pAppCtx);
-#endif
 
   public:
 
@@ -846,50 +743,9 @@ class PEAssembly : public PEFile
     // ------------------------------------------------------------
 
     BOOL IsSourceGAC();
-#ifdef FEATURE_CORECLR
     BOOL IsProfileAssembly();
-#endif // FEATURE_CORECLR
 
     ULONG HashIdentity();
-#ifdef FEATURE_FUSION
-
-    BOOL FusionLoggingEnabled() 
-    {
-        LIMITED_METHOD_CONTRACT;
-        return m_bFusionLogEnabled && (m_pFusionLog != NULL);
-    };
-    void DisableFusionLogging()
-    {
-        m_bFusionLogEnabled = FALSE;
-    };
-
-    IFusionBindLog *GetFusionBindLog()
-    {
-        LIMITED_METHOD_CONTRACT;
-#ifdef FEATURE_FUSION
-        return (m_bFusionLogEnabled && (m_pFusionLog != NULL)) ? m_pFusionLog : NULL;
-#else
-        return NULL;
-#endif 
-    }
-
-
-    BOOL IsBindingCodeBase();
-
-    BOOL IsSourceDownloadCache();
-
-    LOADCTX_TYPE GetLoadContext();
-    BOOL IsContextLoad();
-
-    // Can we avoid exposing these?
-    IAssembly *GetFusionAssembly(); 
-    IHostAssembly *GetIHostAssembly(); 
-    IAssemblyName *GetFusionAssemblyName();
-    IAssemblyName *GetFusionAssemblyNameNoCreate();
-    IAssemblyLocation* GetNativeAssemblyLocation();
-    DWORD GetLocationFlags();
-    PEKIND GetFusionProcessorArchitecture();
-#endif
 
 #ifndef  DACCESS_COMPILE
     virtual void ReleaseIL();
@@ -947,49 +803,12 @@ class PEAssembly : public PEFile
 #ifdef FEATURE_PREJIT
     void ExternalVLog(DWORD facility, DWORD level, const WCHAR *fmt, va_list args) DAC_EMPTY();
     void FlushExternalLog() DAC_EMPTY();
-#ifdef FEATURE_FUSION
-    void ETWTraceLogMessage(DWORD dwETWLogCategory, PEAssembly *pAsm)
-    {
-        LIMITED_METHOD_CONTRACT
-        if (FusionLoggingEnabled() && 
-            (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context, TRACE_LEVEL_INFORMATION, CLR_PRIVATEFUSION_KEYWORD)))
-        { 
-            m_pFusionLog->ETWTraceLogMessage(dwETWLogCategory, (pAsm?pAsm->m_pFusionAssemblyName:NULL));
-        }
-    }
-    ULONGLONG GetBindingID()
-    {
-        LIMITED_METHOD_CONTRACT;
-        ULONGLONG ullBindingID = 0;
-        if (FusionLoggingEnabled())
-            m_pFusionLog->GetBindingID(&ullBindingID);
-        return ullBindingID;
-    }
-#endif
 #endif
 
-#ifndef FEATURE_CORECLR
-    BOOL IsReportedToUsageLog();
-    void SetReportedToUsageLog();
-#endif // !FEATURE_CORECLR
 
   protected:
 
 #ifndef DACCESS_COMPILE
-#ifdef FEATURE_FUSION
-    PEAssembly(
-        PEImage *image,
-        IMetaDataEmit *pEmit,
-        IAssembly *pIAssembly,
-        IBindResult *pNativeFusionAssembly,
-        PEImage *pNIImage,
-        IFusionBindLog *pFusionLog,
-        IHostAssembly *pIHostAssembly,
-        PEFile *creator,
-        BOOL system,
-        BOOL introspectionOnly = FALSE,
-        ICLRPrivAssembly * pHostAssembly = NULL);
-#else
     PEAssembly(
         CoreBindResult* pBindResultInfo, 
         IMetaDataEmit *pEmit,
@@ -1000,7 +819,6 @@ class PEAssembly : public PEFile
         PEImage * pPEImageNI = NULL,
         ICLRPrivAssembly * pHostAssembly = NULL
         );
-#endif
     virtual ~PEAssembly();
 #endif
 
@@ -1011,28 +829,11 @@ class PEAssembly : public PEFile
     friend class DomainAssembly;
 #ifdef FEATURE_PREJIT
 
-#ifdef FEATURE_FUSION
-    void SetNativeImage(IBindResult *pNativeFusionAssembly);
-#else
     void SetNativeImage(PEImage *image);
-#endif
 
     BOOL CheckNativeImageVersion(PEImage *image);
 
 
-#ifdef FEATURE_FUSION
-    void ClearNativeImage();    
-    void SetNativeImageClosure(IAssemblyBindingClosure *pClosure)
-    {
-        LIMITED_METHOD_CONTRACT;
-        if (m_pNativeImageClosure!=NULL)
-            m_pNativeImageClosure->Release();
-        if (pClosure)
-            pClosure->AddRef();
-        m_pNativeImageClosure=pClosure;
-    };
-    BOOL HasEqualNativeClosure(DomainAssembly* pDomainAssembly);
-#endif //FEATURE_FUSION
 
 #endif  // FEATURE_PREJIT
 
@@ -1049,29 +850,13 @@ class PEAssembly : public PEFile
     // ------------------------------------------------------------
 
     PTR_PEFile               m_creator;
-#ifdef FEATURE_FUSION
-    IAssemblyName           *m_pFusionAssemblyName;
-    IAssembly               *m_pFusionAssembly;
-    IFusionBindLog          *m_pFusionLog;
-    BOOL                     m_bFusionLogEnabled;
-    IHostAssembly           *m_pIHostAssembly;
-    IAssemblyLocation       *m_pNativeAssemblyLocation;
-    IAssemblyBindingClosure *m_pNativeImageClosure; //present only for shared 
-    LOADCTX_TYPE             m_loadContext;
-    DWORD                    m_dwLocationFlags;
-#else
     BOOL m_bIsFromGAC;
     BOOL m_bIsOnTpaList;
     // Using a separate entry and not m_pHostAssembly because otherwise
     // HasHostAssembly becomes true that trips various other code paths resulting in bad
     // things
     SString                  m_sTextualIdentity;
-#endif
-#ifdef FEATURE_CORECLR
     int                      m_fProfileAssembly; // Tri-state cache
-#else
-    BOOL                     m_fStrongNameBypassed;
-#endif
 
   public:
     PTR_PEFile GetCreator()
@@ -1090,11 +875,7 @@ class PEAssembly : public PEFile
     inline bool CanUseWithBindingCache()
     {
             STATIC_CONTRACT_WRAPPER;
-#if !defined(FEATURE_APPX_BINDER)
             return (HasBindableIdentity());
-#else
-            return (PEFile::CanUseWithBindingCache() && HasBindableIdentity());
-#endif // FEATURE_CORECLR
     }
 };
 
@@ -1199,21 +980,6 @@ class LoggablePEAssembly : public LoggableAssembly
         return m_peAssembly->GetPath();
     }
 
-#ifdef FEATURE_FUSION
-    virtual IAssemblyName* FusionAssemblyName()
-    {
-        STANDARD_VM_CONTRACT;
-
-        return m_peAssembly->GetFusionAssemblyName();
-    }
-
-    virtual IFusionBindLog* FusionBindLog()
-    {
-        STANDARD_VM_CONTRACT;
-
-        return m_peAssembly->GetFusionBindLog();
-    }
-#endif // FEATURE_FUSION
 
     LoggablePEAssembly(PEAssembly *peAssembly)
     {
diff --git a/src/vm/pefile.inl b/src/vm/pefile.inl
index 09cb89f548..3d5e946110 100644
--- a/src/vm/pefile.inl
+++ b/src/vm/pefile.inl
@@ -12,9 +12,6 @@
 
 #include "strongname.h"
 #include "strongnameholders.h"
-#ifdef FEATURE_FUSION
-#include "fusionbind.h"
-#endif
 #include "check.h"
 #include "simplerwlock.hpp"
 #include "eventtrace.h"
@@ -106,19 +103,7 @@ inline ULONG PEAssembly::HashIdentity()
         GC_TRIGGERS;
     }
     CONTRACTL_END;
-#ifdef FEATURE_VERSIONING
     return BINDER_SPACE::GetAssemblyFromPrivAssemblyFast(m_pHostAssembly)->GetAssemblyName()->Hash(BINDER_SPACE::AssemblyName::INCLUDE_VERSION);
-#else
-    if (!m_identity->HasID())
-    {
-        if (!IsLoaded())
-            return 0;
-        else
-            return (ULONG) dac_cast<TADDR>(GetLoaded()->GetBase());
-    }
-    else
-        return m_identity->GetIDHash();
-#endif
 }
 
 inline void PEFile::ValidateForExecution()
@@ -179,23 +164,6 @@ inline BOOL PEFile::IsMarkedAsContentTypeWindowsRuntime()
     return (IsAfContentType_WindowsRuntime(GetFlags()));
 }
 
-#ifndef FEATURE_CORECLR
-inline BOOL PEFile::IsShareable()
-{
-    CONTRACTL
-    {
-        PRECONDITION(CheckPointer(m_identity));
-        MODE_ANY;
-        THROWS;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-
-    if (!m_identity->HasID())
-        return FALSE;
-    return TRUE ;
-}
-#endif
 
 inline void PEFile::GetMVID(GUID *pMvid)
 {
@@ -525,9 +493,6 @@ inline IMDInternalImport* PEFile::GetPersistentMDImport()
     CONTRACT_END;
 */
     SUPPORTS_DAC;
-#ifndef FEATURE_CORECLR
-_ASSERTE(m_bHasPersistentMDImport);
-#endif
 #if !defined(__GNUC__)
 
     _ASSERTE(!IsResource());
@@ -624,46 +589,6 @@ inline IMetaDataEmit *PEFile::GetEmitter()
     RETURN m_pEmitter;
 }
 
-#ifndef FEATURE_CORECLR
-inline IMetaDataAssemblyImport *PEFile::GetAssemblyImporter()
-{
-    CONTRACT(IMetaDataAssemblyImport *) 
-    {
-        INSTANCE_CHECK;
-        MODE_ANY;
-        GC_NOTRIGGER;
-        PRECONDITION(!IsResource());
-        POSTCONDITION(CheckPointer(RETVAL));
-        PRECONDITION(m_bHasPersistentMDImport);
-        THROWS;
-    }
-    CONTRACT_END;
-
-    if (m_pAssemblyImporter == NULL)
-        OpenAssemblyImporter();
-
-    RETURN m_pAssemblyImporter;
-}
-
-inline IMetaDataAssemblyEmit *PEFile::GetAssemblyEmitter()
-{
-    CONTRACT(IMetaDataAssemblyEmit *) 
-    {
-        INSTANCE_CHECK;
-        MODE_ANY;
-        GC_NOTRIGGER;
-        PRECONDITION(!IsResource());
-        POSTCONDITION(CheckPointer(RETVAL));
-        PRECONDITION(m_bHasPersistentMDImport);
-    }
-    CONTRACT_END;
-
-    if (m_pAssemblyEmitter == NULL)
-        OpenAssemblyEmitter();
-
-    RETURN m_pAssemblyEmitter;
-}
-#endif // FEATURE_CORECLR
 
 #endif // DACCESS_COMPILE
 
@@ -1391,7 +1316,7 @@ inline BOOL PEFile::IsPtrInILImage(PTR_CVOID data)
 
     if (HasOpenedILimage())
     {
-#if defined(FEATURE_PREJIT) && defined(FEATURE_CORECLR)
+#if defined(FEATURE_PREJIT)
         if (m_openedILimage == m_nativeImage)
         {
             // On Apollo builds, we sometimes open the native image into the slot
@@ -1405,7 +1330,7 @@ inline BOOL PEFile::IsPtrInILImage(PTR_CVOID data)
             TADDR taddrILMetadata = dac_cast<TADDR>(pDecoder->GetMetadata(&cbILMetadata));
             return ((taddrILMetadata <= taddrData) && (taddrData < taddrILMetadata + cbILMetadata));
         }
-#endif // defined(FEATURE_PREJIT) && defined(FEATURE_CORECLR)
+#endif // defined(FEATURE_PREJIT)
         return GetOpenedILimage()->IsPtrInImage(data);
     }
     else
@@ -1704,9 +1629,6 @@ inline void PEAssembly::GetDisplayName(SString &result, DWORD flags)
  
 #ifndef DACCESS_COMPILE
 
-#ifdef FEATURE_FUSION
-    FusionBind::GetAssemblyNameDisplayName(GetFusionAssemblyName(), result, flags);
-#else
     if ((flags == (ASM_DISPLAYF_VERSION | ASM_DISPLAYF_CULTURE | ASM_DISPLAYF_PUBLIC_KEY_TOKEN)) &&
         !m_sTextualIdentity.IsEmpty())
     {
@@ -1718,7 +1640,6 @@ inline void PEAssembly::GetDisplayName(SString &result, DWORD flags)
         spec.InitializeSpec(this);
         spec.GetFileOrDisplayName(flags, result);
     }
-#endif // FEATURE_FUSION
 
 #else
     IMDInternalImport *pImport = GetMDImport();
@@ -1868,25 +1789,6 @@ inline HRESULT PEFile::GetFlagsNoTrigger(DWORD * pdwFlags)
     return GetPersistentMDImport()->GetAssemblyProps(TokenFromRid(1, mdtAssembly), NULL, NULL, NULL, NULL, NULL, pdwFlags);
 }
 
-#ifdef FEATURE_CAS_POLICY
-inline COR_TRUST *PEFile::GetAuthenticodeSignature()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_PREEMPTIVE;
-    }
-    CONTRACTL_END;
-
-    if (!m_fCheckedCertificate && HasSecurityDirectory())
-    {
-        CheckAuthenticodeSignature();
-    }
-
-    return m_certificate;
-}
-#endif
 
 // ------------------------------------------------------------
 // Hash support
@@ -1946,77 +1848,7 @@ inline BOOL PEAssembly::IsFullySigned()
     }
 }
 
-#ifndef FEATURE_CORECLR
-//---------------------------------------------------------------------------------------
-//
-// Mark that an assembly has had its strong name verification bypassed
-//
-
-inline void PEAssembly::SetStrongNameBypassed()
-{
-    LIMITED_METHOD_CONTRACT;
-    m_fStrongNameBypassed = TRUE;
-}
-
-inline BOOL PEAssembly::NeedsModuleHashChecks()
-{
-    LIMITED_METHOD_CONTRACT;
-
-    return ((m_flags & PEFILE_SKIP_MODULE_HASH_CHECKS) == 0) && !m_fStrongNameBypassed;
-}
-#endif // FEATURE_CORECLR
-
-#ifdef FEATURE_CAS_POLICY
-//---------------------------------------------------------------------------------------
-//
-// Verify the Authenticode and strong name signatures of an assembly during the assembly
-// load code path.  To verify the strong name signature outside of assembly load, use the
-// VefifyStrongName method instead.
-// 
-// If the applicaiton is using strong name bypass, then this method may not cause a real
-// strong name verification, delaying the assembly's strong name load until we know that
-// the verification is required.  If the assembly must be forced to have its strong name
-// verified, then the VerifyStrongName method should also be chosen.
-// 
-// See code:AssemblySecurityDescriptor::ResolveWorker#StrongNameBypass
-//
-
-inline void PEAssembly::DoLoadSignatureChecks()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS; // Fusion uses crsts on AddRef/Release
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    ETWOnStartup(SecurityCatchCall_V1, SecurityCatchCallEnd_V1);
-
-    // If this isn't mscorlib or a dynamic assembly, verify the Authenticode signature.
-    if (IsSystem() || IsDynamic())
-    {
-        // If it was a dynamic module (or mscorlib), then we don't want to be doing module hash checks on it
-        m_flags |= PEFILE_SKIP_MODULE_HASH_CHECKS;
-    }
-
-    // Check strong name signature. We only want to do this now if the application is not using the strong
-    // name bypass feature.  Otherwise we'll delay strong name verification until we figure out how trusted
-    // the assembly is.
-    // 
-    // For more information see code:AssemblySecurityDescriptor::ResolveWorker#StrongNameBypass
 
-    // Make sure m_pMDImport is initialized as we need to call VerifyStrongName which calls GetFlags
-    // BypassTrustedAppStrongNames = false is a relatively uncommon scenario so we need to make sure 
-    // the initialization order is always correct and we don't miss this uncommon case
-    _ASSERTE(GetMDImport());
-
-    if (!g_pConfig->BypassTrustedAppStrongNames())
-    { 
-        VerifyStrongName();
-    }
-}
-#endif // FEATURE_CAS_POLICY
 
 // ------------------------------------------------------------
 // Metadata access
diff --git a/src/vm/pefingerprint.cpp b/src/vm/pefingerprint.cpp
index 775966663f..b02e8a30bb 100644
--- a/src/vm/pefingerprint.cpp
+++ b/src/vm/pefingerprint.cpp
@@ -33,330 +33,6 @@
 #include "pefile.h"
 #include "pefingerprint.h"
 
-#ifdef FEATURE_FUSION
-
-static VOID ThrowTornState(LPCWSTR path);
-static void FetchILTimestampAndSize(LPCWSTR path, FILETIME *pTimestamp, DWORD *pSize, HANDLE hFileHandleIfOpen = INVALID_HANDLE_VALUE);
-
-
-const size_t PEFingerprint::s_offsets[] =
-{
-    offsetof(PEFingerprint, m_timeStamp),
-    offsetof(PEFingerprint, m_size),
-    offsetof(PEFingerprint, m_mvid),
-};
-
-const DWORD PEFingerprint::s_sizes[] =
-{
-    sizeof(((PEFingerprint *)NULL)->m_timeStamp),
-    sizeof(((PEFingerprint *)NULL)->m_size),
-    sizeof(((PEFingerprint *)NULL)->m_mvid),
-};
-
-
-
-//---------------------------------------------------------------
-// Ctor
-//---------------------------------------------------------------
-PEFingerprint::PEFingerprint(PEImage *owner) :
-   m_pcrst(NULL)
-  ,m_peimage(owner)
-  ,m_commitMask(0)
-  ,m_alreadyLoaded(FALSE)
-  ,m_priorLockAndLoadFailure(S_OK)
-{
-
-    LIMITED_METHOD_CONTRACT;
-
-    _ASSERTE(owner);
-
-    memset(&m_timeStamp, 0xcc, sizeof(m_timeStamp));
-    memset(&m_size, 0xcc, sizeof(m_size));
-    memset(&m_mvid, 0xcc, sizeof(m_mvid));
-
-    return;
-}
-
-
-//---------------------------------------------------------------
-// PEFingerprint factory
-//---------------------------------------------------------------
-/*static*/ PEFingerprint *PEFingerprint::CreatePEFingerprint(PEImage *owner)
-{
-    CONTRACTL
-    {
-        THROWS; 
-        GC_TRIGGERS;
-        MODE_ANY;
-        SO_INTOLERANT;
-        INJECT_FAULT(COMPlusThrowOM();); 
-    }
-    CONTRACTL_END
-
-    NewHolder<PEFingerprint> pPEFingerprint = new PEFingerprint(owner);
-    pPEFingerprint->m_pcrst = new Crst(CrstLeafLock);
-
-    //---------------------------------------------------------------
-    // Since obtaining the timestamp is cheap and doesn't need to open the
-    // file, go ahead and get it now and commit into the fingerprint.
-    //
-    // @review: Would it be better to lock the file right now to
-    // prevent overwriter for the life of the fingerprint?
-    //---------------------------------------------------------------
-    LPCWSTR path = pPEFingerprint->m_peimage->GetPath();
-    _ASSERTE(path);
-
-    FILETIME lastWriteTime;
-    DWORD size;
-    FetchILTimestampAndSize(path, &lastWriteTime, &size);
-
-    ILFingerprintComponent components[] =
-    {
-        { ILFTagTimestamp, &lastWriteTime },
-        { ILFTagSize, &size },
-    };
-    BOOL success = pPEFingerprint->CommitAndCompareMulti(COUNTOF(components), components);
-    _ASSERTE(success);  // No way this commit can fail - we own the only pointer!
-    return pPEFingerprint.Extract();
-}
-
-
-
-//---------------------------------------------------------------
-// Dtor
-//---------------------------------------------------------------
-PEFingerprint::~PEFingerprint()
-{
-    LIMITED_METHOD_CONTRACT;
-    delete m_pcrst;
-    return;
-}
-
-//---------------------------------------------------------------
-// AddRef
-//---------------------------------------------------------------
-ULONG PEFingerprint::AddRef()
-{
-    LIMITED_METHOD_CONTRACT;
-    return m_peimage->AddRef();
-}
-
-//---------------------------------------------------------------
-// Release
-//---------------------------------------------------------------
-ULONG PEFingerprint::Release()
-{
-    LIMITED_METHOD_CONTRACT;
-    STATIC_CONTRACT_GC_TRIGGERS;
-    STATIC_CONTRACT_CAN_TAKE_LOCK;
-    return m_peimage->Release();
-}
-
-//---------------------------------------------------------------------------------------------
-// Convenience fcn: equivalent to calling CommitAndCompareMulti() with one component.
-//---------------------------------------------------------------------------------------------
-BOOL PEFingerprint::CommitAndCompare(ILFingerprintTag componentType, LPCVOID data)
-{
-    CONTRACTL
-    {
-        THROWS; 
-        GC_TRIGGERS;
-        MODE_ANY;
-        SO_INTOLERANT;
-        INJECT_FAULT(COMPlusThrowOM();); 
-    }
-    CONTRACTL_END
-
-    ILFingerprintComponent c = {componentType, data};
-    return CommitAndCompareMulti(1, &c);
-}
-
-
- //---------------------------------------------------------------------------------------------
- // CommitAndCompareMulti(): Atomically commits one or more fingerprint components into
- // the fingerprint. Once a component is committed, its value can never change.
- //
- // An attempt to commit a component succeeds only if the component was not already committed
- // or the prior value maches the new one exactly.
- //
- // Calling CommitAndCompare() multiple times is not equivalent to calling CommitAndCompareMulti().
- // CommitAndCompareMulti() is atomic - either all the commits happen or none of them do.
- //
- // Returns:
- //    TRUE:  All passed components committed successful.
- //    FALSE: At leat one component failed to commit successfully.
- //---------------------------------------------------------------------------------------------
-BOOL PEFingerprint::CommitAndCompareMulti(UINT numComponents, const ILFingerprintComponent *pComponents)
-{
-    CONTRACTL
-    {
-        THROWS; 
-        GC_TRIGGERS;
-        MODE_ANY;
-        SO_INTOLERANT;
-        INJECT_FAULT(COMPlusThrowOM();); 
-    }
-    CONTRACTL_END
-
-    //------------------------------------------------------------------------------
-    // See "Dev11 note on timing of torn state detection". This step should not be
-    // here but this is how we "verify" the MVID/SNHash on IL open. We wait until
-    // the first time someone attempts a commit on an opened file to do the check.
-    // The caller will think we did the check at file open time, even though we
-    // actually left a window of vulnerability.
-    //------------------------------------------------------------------------------
-    if (!m_alreadyLoaded)
-    {
-        PEImageHolder pOpenedILimage;
-        m_peimage->Clone(MDInternalImport_OnlyLookInCache,&pOpenedILimage);
-
-        if(pOpenedILimage != NULL && pOpenedILimage->IsOpened())
-        {
-
-            for (UINT j = 0; j < numComponents; j++)
-            {
-                // Don't open if we're just checking timestamp (forecloses possible reentrancy problems
-                // due to timestamp commits occurring within PEImage itself.)
-                ILFingerprintTag tag = pComponents[j]._tag;
-                if (tag == ILFTagMvid)
-                {
-                    this->LockAndLoadIL();
-                    break;
-                }
-
-            }
-        }
-    }
-
-    //------------------------------------------------------------------------------
-    // Inside the crit section, make sure all the components can successfully commit
-    // before commitng any of them.
-    //------------------------------------------------------------------------------
-    CrstHolder ch(m_pcrst);
-    UINT i;
-    for (i = 0; i < numComponents; i++)
-    {
-        ILFingerprintTag tag = pComponents[i]._tag;
-        if (IsComponentCommitted(tag))
-        {
-            if (0 != memcmp(pComponents[i]._data, TagDataStart(tag), TagDataSize(tag)))
-                return FALSE;
-        }
-    }
-    for (i = 0; i < numComponents; i++)
-    {
-        ILFingerprintTag tag = pComponents[i]._tag;
-        if (!IsComponentCommitted(tag))
-        {
-            memcpy(TagDataStart(tag), pComponents[i]._data, TagDataSize(tag));
-            SetComponentCommitted(tag);
-        }
-    }
-
-    return TRUE;
-}
-
-
-
-//---------------------------------------------------------------------------------------------
-// LockAndLoadIL()
-//
-//   Forces the runtime to open the IL file and lock it against future overwrites. This
-//   is bad for working set so this should be avoided.
-//
-//   Once opened and locked, this method extracts the actual fingerprint from the IL file
-//   and attempts to commit it into the ILFingerprint. If successful, all future commits
-//   will now be compared against this trusted data. If unsuccessful, this is a torn state
-//   situation and LockAndLoadIL() throws the torn state exception.
-//---------------------------------------------------------------------------------------------
-void PEFingerprint::LockAndLoadIL()
-{
-    CONTRACTL
-    {
-        THROWS; 
-        GC_TRIGGERS;
-        MODE_ANY;
-        SO_INTOLERANT;
-        INJECT_FAULT(COMPlusThrowOM();); 
-    }
-    CONTRACTL_END
-
-    //----------------------------------------------------------------------------------
-    // If already loaded, return the prior result.
-    //----------------------------------------------------------------------------------
-    if (m_alreadyLoaded)
-    {
-        if (FAILED(m_priorLockAndLoadFailure))
-        {
-            ThrowHR(m_priorLockAndLoadFailure);
-        }
-        else
-        {
-            return;
-        }
-    }
-    PEImageHolder pOpenedILimage;
-    m_peimage->Clone(MDInternalImport_Default,&pOpenedILimage);
-    HRESULT hr = S_OK;
-    {
-        GCX_PREEMP();
-        IfFailThrow(m_peimage->TryOpenFile());
-    }
-    //----------------------------------------------------------------------------------
-    // Force the file open (by requesting a metadata pointer to it.)
-    //----------------------------------------------------------------------------------
-    IMDInternalImport *pMDImport = NULL;
-    EX_TRY
-    {
-        pMDImport = pOpenedILimage->GetMDImport();
-        hr = S_OK;
-    }
-    EX_CATCH_HRESULT(hr);
-    if (Exception::IsTransient(hr))
-        ThrowHR(hr);
-    if (FAILED(hr))
-    {
-        m_priorLockAndLoadFailure = hr;
-        m_alreadyLoaded = TRUE;
-        ThrowHR(hr);
-    }
-
-    m_alreadyLoaded = TRUE;
-
-    //------------------------------------------------------------------------------
-    // See "Dev11 note on timing of torn state detection". This step should not be
-    // here as the "right" design is to extract the actual MVID before we officially
-    // open the file. But since we don't do that in the current implementation, we do
-    // it now.
-    //------------------------------------------------------------------------------
-    GUID mvid;
-    pOpenedILimage->GetMVID(&mvid);
-
-    BOOL success = this->CommitAndCompare(ILFTagMvid, &mvid);
-    if (!success)
-        ThrowTornState(m_peimage->GetPath());
-}
-
-
-//==================================================================================
-// Helper for throwing a torn state exception.
-//==================================================================================
-static VOID ThrowTornState(LPCWSTR path)
-{
-    CONTRACTL
-    {
-        THROWS; 
-        GC_TRIGGERS;
-        MODE_ANY;
-        SO_INTOLERANT;
-        INJECT_FAULT(COMPlusThrowOM();); 
-    }
-    CONTRACTL_END
-
-    COMPlusThrow(kFileLoadException, IDS_EE_TORNSTATE, path);
-}
-
-#endif // FEATURE_FUSION
 
 
 
@@ -384,240 +60,7 @@ PEFingerprintVerificationHolder::PEFingerprintVerificationHolder(PEImage *owner)
     }
     CONTRACTL_END
 
-#ifdef FEATURE_FUSION
-    if (owner->IsTrustedNativeImage())
-        return;   // Waste of cycles to check timestamps for NI images.
-
-
-    LPCWSTR path = owner->GetPath();
-    _ASSERTE(path);
-
-    if (owner->IsOpened()) 
-        return;   // Not the first layout to be opened - no need to repeat the work in that case.
-
-    // First, lock the file and verify that the timestamp hasn't changed.
-    TESTHOOKCALL(AboutToLockImage(path, IsCompilationProcess())); 
-    m_fileHandle = WszCreateFile(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
-    if (m_fileHandle == INVALID_HANDLE_VALUE)
-    {
-        // @review: If this call to open the file fails, it sounds a bit risky to fail the PE open altogether
-        //          just to do a torn state check. Let the torn state detection bake a bit before we take this step.
-        return;
-    }
-
-    FILETIME lastWriteTime;
-    DWORD size;
-    FetchILTimestampAndSize(path, &lastWriteTime, &size, m_fileHandle);
-    ReleaseHolder<IILFingerprint> fingerPrint;
-    ILFingerprintComponent components[] =
-    {
-        { ILFTagTimestamp, &lastWriteTime },
-        { ILFTagSize, &size },
-    };
-    IfFailThrow(owner->GetILFingerprint(&fingerPrint));
-    if (!fingerPrint->CommitAndCompareMulti(COUNTOF(components), components))
-        ThrowTornState(path);
-
-
-    // Now, verify that the MVID/SNHash/TPBand hasn't changed.
-    // Oh wait, where that'd code go? See "Dev11 note on timing of torn state detection".
-#endif // FEATURE_FUSION
-    return;
-}
-
-#ifdef FEATURE_FUSION
-#ifndef DACCESS_COMPILE
-class CachingILFingerprintFactory : public IILFingerprintFactory
-{
-private:
-    LONG m_refCount;
-    Crst m_lock;
-
-    // Hash Type ... NOTE! This is a case sensitive hash of a filename to an IL fingerprint.
-    // This is acceptable as duplicates are not errors, and chosen as case insensitive hashes
-    // are somewhat slower, and most hash lookups will actually match in case. If this is not
-    // the case, converting to a case-insensitive hash should be trivial.
-    typedef StringSHashWithCleanup< IILFingerprint, WCHAR > ILFingerprintHash;
-    typedef StringHashElement< IILFingerprint, WCHAR > ILFingerprintHashElement;
-
-    ILFingerprintHash m_hash;
-
-    ~CachingILFingerprintFactory()
-    {
-    }
-
-public:
-
-    CachingILFingerprintFactory() : m_refCount(1), m_lock(CrstILFingerprintCache)
-    {
-        CONTRACTL
-        {
-            THROWS;
-            GC_TRIGGERS;
-        }
-        CONTRACTL_END;
-    }
-
-    STDMETHOD_(ULONG, AddRef)()
-    {
-        CONTRACT(ULONG)
-        {
-            PRECONDITION(m_refCount>0 && m_refCount < COUNT_T_MAX);
-            NOTHROW;
-            GC_NOTRIGGER;
-        }
-        CONTRACT_END;
-
-        RETURN (static_cast<ULONG>(FastInterlockIncrement(&m_refCount)));
-    }
-
-    STDMETHOD_(ULONG, Release)()
-    {
-        CONTRACTL
-        {
-            DESTRUCTOR_CHECK;
-            NOTHROW;
-            MODE_ANY;
-            FORBID_FAULT;
-        }
-        CONTRACTL_END;
-
-        ULONG result = 0;
-        result=FastInterlockDecrement(&m_refCount);
-        if (result == 0)
-            delete this;
-
-        return result;
-    }
-
-    STDMETHOD(GetILFingerprintForPath)(
-        LPCWSTR pwzPath, 
-        IILFingerprint **ppFingerprint)
-    {
-        CONTRACTL
-        {
-            NOTHROW;
-            GC_TRIGGERS;
-        }
-        CONTRACTL_END;
-        HRESULT hr = S_OK;
-
-        EX_TRY
-        {
-            CrstHolder ch(&m_lock);
-            // Lookup in cache
-            ILFingerprintHashElement *pCacheElement = m_hash.Lookup(pwzPath);
-
-            // If that fails, run the parser, and populate the cache
-            if (pCacheElement != NULL)
-            {
-                *ppFingerprint = clr::SafeAddRef(pCacheElement->Object);
-            }
-            else
-            {
-                // Create new assembly name object;
-                ReleaseHolder<IILFingerprint> pFingerprint;
-                NewArrayHolder<WCHAR> pwzPathCopy;
-                IfFailThrow(RuntimeGetILFingerprintForPath(pwzPath, &pFingerprint));
-
-                // Create hash element object
-                NewHolder<ILFingerprintHashElement> pHashElem = new ILFingerprintHashElement();
-                pwzPathCopy = DuplicateStringThrowing(pwzPath);
-                pHashElem->String = pwzPathCopy;
-                pHashElem->Object = pFingerprint;
-
-                // Insert into hash table
-                m_hash.Add(pHashElem);
-
-                *ppFingerprint = clr::SafeAddRef(pFingerprint);
-
-                // Prevent disastrous cleanup
-                pwzPathCopy.SuppressRelease();
-                pHashElem.SuppressRelease();
-                pFingerprint.SuppressRelease();
-            }
-        }
-        EX_CATCH_HRESULT(hr);
-
-        return hr;
-    }
-};
-
-HRESULT RuntimeCreateCachingILFingerprintFactory(IILFingerprintFactory **ppILFingerprintFactory)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-    HRESULT hr = S_OK;
-
-    EX_TRY
-    {
-        *ppILFingerprintFactory = new CachingILFingerprintFactory();
-    }
-    EX_CATCH_HRESULT(hr);
-
-    return hr;
-}
-
-//-------------------------------------------------------------------------------------------------------------
-// Common routine to fetch the IL file's timestamp and size. If the caller already has an open file handle, it should
-// pass that as "hFileHandleIfOpen" to avoid the overhead of opening the file again.
-//-------------------------------------------------------------------------------------------------------------
-static void FetchILTimestampAndSize(LPCWSTR path, FILETIME *pTimestamp, DWORD *pSize, HANDLE hFileHandleIfOpen /* = INVALID_HANDLE_VALUE*/)
-{
-    CONTRACTL
-    {
-        THROWS; 
-        GC_TRIGGERS;
-        MODE_ANY;
-        SO_INTOLERANT;
-        INJECT_FAULT(COMPlusThrowOM();); 
-    }
-    CONTRACTL_END
-
-    _ASSERTE(pTimestamp != NULL && pSize != NULL);
-
-    if (hFileHandleIfOpen != INVALID_HANDLE_VALUE)
-    {
-        BY_HANDLE_FILE_INFORMATION info;
-        if (!GetFileInformationByHandle(hFileHandleIfOpen, &info))
-            ThrowLastError();
-        *pTimestamp = info.ftLastWriteTime;
-        *pSize = info.nFileSizeLow;
-        return;
-    }
-
-    // For normal files, we can obtain the timestamp without opening the file - attempt to do so.
-    WIN32_FILE_ATTRIBUTE_DATA wfd;
-    if (!WszGetFileAttributesEx(path, GetFileExInfoStandard, &wfd))
-        ThrowLastError();
-    if (!(wfd.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT))
-    {
-        *pTimestamp = wfd.ftLastWriteTime;
-        *pSize = wfd.nFileSizeLow;
-        return;
-    }
-
-    // If we got here, the original path pointed to a symbolic or some other form of reparse point. In such cases, GetFileAttributesEx
-    // may not return the same timestamp as GetFileInformationByHandle. (E.g. in the symbolic link case, GetFileAttributeEx returns
-    // the symbolic link's timestamp rather than the target's timestamp.)
-    //
-    // Since this is the uncommon case, we can justify the perf hit of opening the file so we get the timestamp
-    // on the actual target. 
-    HandleHolder hFile(WszCreateFile(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL));
-    if (hFile == INVALID_HANDLE_VALUE)
-        ThrowLastError();
-    BY_HANDLE_FILE_INFORMATION info;
-    if (!GetFileInformationByHandle(hFile, &info))
-        ThrowLastError();
-    *pTimestamp = info.ftLastWriteTime;
-    *pSize = info.nFileSizeLow;
     return;
 }
 
-#endif // !DACCESS_COMPILE
-#endif // FEATURE_FUSION
 
diff --git a/src/vm/pefingerprint.h b/src/vm/pefingerprint.h
index 357351f4ae..8db8df729a 100644
--- a/src/vm/pefingerprint.h
+++ b/src/vm/pefingerprint.h
@@ -11,95 +11,6 @@
 #define PEFINGERPRINT_H_
 
 
-#ifdef FEATURE_FUSION
-
-#include "corcompile.h"
-
-class PEImage;
-
-//==================================================================================
-// This is the implementation of IILFingerprint object maintained by PEImage objects.
-// IILFingerprint is described in detail in IILFingerprint.h
-//==================================================================================
-class PEFingerprint : public IILFingerprint
-{
-  public:
-  //----------------------------------------------------------------
-  // IILFingerprint methods
-  //----------------------------------------------------------------
-    STDMETHOD_(ULONG, AddRef)();
-    STDMETHOD_(ULONG, Release)();
-    STDMETHOD_(BOOL, CommitAndCompare)(ILFingerprintTag componentType, LPCVOID data);
-    STDMETHOD_(BOOL, CommitAndCompareMulti)(UINT numComponents, const ILFingerprintComponent *pComponents);
-    STDMETHOD_(void, LockAndLoadIL)();
-
-  //----------------------------------------------------------------
-  // Non-interface public methods.
-  //----------------------------------------------------------------
-  public:
-    static PEFingerprint* PEFingerprint::CreatePEFingerprint(PEImage *owner);
-    virtual ~PEFingerprint();
-
-  private:
-    PEFingerprint(PEImage *owner);
-
-  //----------------------------------------------------------------
-  // Private methods.
-  //----------------------------------------------------------------
-  private:
-
-    BOOL IsComponentCommitted(ILFingerprintTag tag)
-    {
-        LIMITED_METHOD_CONTRACT;
-        _ASSERTE(tag < ILFTagCount);
-        return 0 != (m_commitMask & (1 << tag));
-    }
-
-    void SetComponentCommitted(ILFingerprintTag tag)
-    {
-        LIMITED_METHOD_CONTRACT;
-        _ASSERTE(tag < ILFTagCount);
-        m_commitMask |= (1 << tag);
-    }
-
-    LPVOID TagDataStart(ILFingerprintTag tag)
-    {
-        LIMITED_METHOD_CONTRACT;
-        _ASSERTE(tag < ILFTagCount);
-        return (LPVOID)(((LPBYTE)this) + s_offsets[tag]);
-    }
-
-    DWORD TagDataSize(ILFingerprintTag tag)
-    {
-        LIMITED_METHOD_CONTRACT;
-        _ASSERTE(tag < ILFTagCount);
-        return s_sizes[tag];
-    }
-
-
-  //----------------------------------------------------------------
-  // Private instance data
-  //----------------------------------------------------------------
-  private:
-    Crst                            *m_pcrst;                              // Synchronizes updates to fingerprint
-    PEImage                         *m_peimage;                            // Backpointer to PEImage (for ref-counting purposes, the PEImage and PEFingerprint have the same identity)
-    DWORD                            m_commitMask;                         // Bitmask to indicate which components have been committed ( fCommitted =  (m_commitMask & (1 << tag)) )
-    FILETIME                         m_timeStamp;                          // Component: File system lastwrite Timestamp
-    DWORD                            m_size;                               // Component: File size
-    GUID                             m_mvid;                               // Component: Mvid
-
-    BOOL                             m_alreadyLoaded;                      // Turns repeated attempts to LockAndLoadIL() into NOP's
-    HRESULT                          m_priorLockAndLoadFailure;            // If LockAndLoadIL() failed the first time, return the same failure on subsequent attempts.
-
-  //----------------------------------------------------------------
-  // Private static data
-  //----------------------------------------------------------------
-  private:
-    const static size_t              s_offsets[ILFTagCount];               // static: Maps tags to offsets within PEFingerprint
-    const static DWORD               s_sizes[ILFTagCount];                 // static: Maps tag to expected data size
-};
-
-#endif // FEATURE_FUSION
 
 
 //==================================================================================
diff --git a/src/vm/peimage.cpp b/src/vm/peimage.cpp
index 583c5e3144..ed1c77b203 100644
--- a/src/vm/peimage.cpp
+++ b/src/vm/peimage.cpp
@@ -65,13 +65,11 @@ void PEImage::Startup()
     s_ijwFixupDataHash->Init(CompareIJWDataBase, FALSE, &ijwLock);
 #endif
     PEImageLayout::Startup();
-#ifndef FEATURE_FUSION
 #ifdef FEATURE_USE_LCID
     g_lcid = MAKELCID(LOCALE_INVARIANT, SORT_DEFAULT);
 #else // FEATURE_USE_LCID
     g_lcid = NULL; // invariant
 #endif //FEATURE_USE_LCID
-#endif
     END_SO_INTOLERANT_CODE;
 
     RETURN;
@@ -226,9 +224,6 @@ PEImage::~PEImage()
         m_pMDTracker->Deactivate();
 #endif // METADATATRACKER_ENABLED
 
-#ifdef FEATURE_FUSION
-    delete m_pILFingerprint;
-#endif // FEATURE_FUSION
 }
 
 #ifdef FEATURE_MIXEDMODE
@@ -444,12 +439,6 @@ BOOL PEImage::CompareImage(UPTR u1, UPTR u2)
     // This is the value stored in the table
     PEImage *pImage = (PEImage *) u2;
 
-#ifdef FEATURE_FUSION
-    if (pLocator->m_fIsIStream)
-    {
-        return pImage->m_fIsIStream && (pLocator->m_StreamAsmId == pImage->m_StreamAsmId) && (pLocator->m_dwStreamModuleId == pImage->m_dwStreamModuleId);
-    }
-#endif
 
     BOOL ret = FALSE;
     HRESULT hr;
@@ -475,103 +464,13 @@ BOOL PEImage::Equals(PEImage *pImage)
     }
     CONTRACTL_END;
 
-#ifdef FEATURE_CORECLR
     // PEImage is always unique on CoreCLR so a simple pointer check is sufficient
     _ASSERTE(m_bInHashMap || GetPath().IsEmpty());
     _ASSERTE(pImage->m_bInHashMap || pImage->GetPath().IsEmpty());
 
     return dac_cast<TADDR>(pImage) == dac_cast<TADDR>(this);
-#else // FEATURE_CORECLR
-    if (pImage == this)
-        return TRUE;
-
-    if (GetPath().IsEmpty())
-    {
-#ifdef FEATURE_FUSION
-        if (m_fIsIStream && pImage->m_fIsIStream)
-        {
-            return (m_StreamAsmId == pImage->m_StreamAsmId) && (m_dwStreamModuleId == pImage->m_dwStreamModuleId);
-        }
-#endif
-
-        return FALSE;
-    }
-    else
-    {
-        BOOL ret = FALSE;
-        HRESULT hr;
-        EX_TRY
-        {
-            if (PathEquals(GetPath(), pImage->GetPath()))
-                ret = TRUE;
-        }
-        EX_CATCH_HRESULT(hr); //<TODO>ignores failure!</TODO>
-        return ret;
-    }
-#endif // FEATURE_CORECLR
 }
 
-#ifndef FEATURE_CORECLR
-void PEImage::ComputeHash(ALG_ID algorithm, SBuffer &result)
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        PRECONDITION(CheckStartup());
-        PRECONDITION(CheckValue(result));
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    PEImageLayoutHolder pview(GetLayout(PEImageLayout::LAYOUT_FLAT,PEImage::LAYOUT_CREATEIFNEEDED));
-
-    if (algorithm == CALG_SHA1)
-    {
-        SHA1Hash hasher;
-        hasher.AddData((BYTE *) pview->GetBase(), pview->GetSize());
-        result.Set(hasher.GetHash(), SHA1_HASH_SIZE);
-        return;
-    }
-
-    DWORD size = 0;
-    if(!StrongNameHashSize(algorithm, &size))
-    {
-        ThrowHR(StrongNameErrorInfo());
-    }
-
-    BYTE *buffer = result.OpenRawBuffer(size);
-    
-    DWORD hashSize;
-    IfFailThrow(GetHashFromBlob((BYTE *) pview->GetBase(), pview->GetSize(), &algorithm, buffer, size, &hashSize));
-
-    _ASSERTE(size == hashSize);
-
-    result.CloseRawBuffer(hashSize);
-}
-
-CHECK PEImage::CheckHash(ALG_ID algorithm, const void *pbHash, COUNT_T cbHash)
-{
-    CONTRACT_CHECK
-    {
-        INSTANCE_CHECK;
-        PRECONDITION(CheckStartup());
-        INSTANCE_CHECK;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACT_CHECK_END;
-
-    StackSBuffer hash;
-    ComputeHash(algorithm, hash);
-
-    CHECK(hash.Equals((const BYTE *) pbHash, cbHash));
-
-    CHECK_OK;
-}
-#endif // FEATURE_CORECLR
 
 IMDInternalImport* PEImage::GetMDImport()
 {
@@ -833,297 +732,6 @@ void DECLSPEC_NORETURN PEImage::ThrowFormat(HRESULT hrError)
     EEFileLoadException::Throw(m_path, hrError);
 }
 
-#ifdef FEATURE_FUSION
-// --------------------------------------------------------------------------------
-// Exports for the metadata APIs for fusion.
-// --------------------------------------------------------------------------------
-
-HRESULT STDMETHODCALLTYPE RuntimeOpenImage(LPCWSTR pszFileName, HCORMODULE* hHandle)
-{
-    WRAPPER_NO_CONTRACT;
-    return RuntimeOpenImageInternal(pszFileName, hHandle, NULL, MDInternalImport_Default);
-}
-
-HRESULT STDMETHODCALLTYPE RuntimeOpenImageInternal(LPCWSTR pszFileName, HCORMODULE* hHandle, DWORD *pdwLength, MDInternalImportFlags flags, HANDLE hFile)
-{
-    STATIC_CONTRACT_NOTHROW;
-    STATIC_CONTRACT_SO_INTOLERANT;
-    HRESULT hr = S_OK;
-    ETWOnStartup (LoaderCatchCall_V1,LoaderCatchCallEnd_V1);
-    EX_TRY
-    {
-        PEImage::Startup();
-        PEImageHolder pFile(PEImage::OpenImage(pszFileName, flags));
-        if (hFile != INVALID_HANDLE_VALUE)
-        {
-            pFile->SetFileHandle(hFile);
-        }
-        if (pdwLength)
-        {
-            PEImageLayoutHolder pLayout(pFile->GetLayout(PEImageLayout::LAYOUT_MAPPED,PEImage::LAYOUT_CREATEIFNEEDED));
-            pFile->CachePEKindAndMachine();
-            *pdwLength = pLayout->GetSize();
-        }
-        *hHandle = (HCORMODULE)pFile.Extract();        
-    }
-    EX_CATCH_HRESULT(hr);
-    return hr;
-}
-
-HRESULT STDMETHODCALLTYPE RuntimeOpenImageByStream(IStream* pIStream, UINT64 AssemblyId,
-                                                   DWORD dwModuleId,
-                                                   HCORMODULE* hHandle, DWORD *pdwLength, MDInternalImportFlags flags)
-{
-    STATIC_CONTRACT_NOTHROW;
-    HRESULT hr = S_OK;
-
-    BEGIN_SO_INTOLERANT_CODE_NO_THROW_CHECK_THREAD(return COR_E_STACKOVERFLOW);
-    EX_TRY
-    {
-        PEImage::Startup();
-
-        PEImageHolder pFile(PEImage::OpenImage(pIStream, AssemblyId, dwModuleId, FALSE, flags));
-        *hHandle = (HCORMODULE) pFile.Extract();
-        if (pdwLength)
-        {
-            PEImageLayoutHolder pImage(pFile->GetLayout(PEImageLayout::LAYOUT_ANY,0));
-            pFile->CachePEKindAndMachine();
-            *pdwLength = pImage->GetSize();
-        }
-    }
-    EX_CATCH_HRESULT(hr);
-    END_SO_INTOLERANT_CODE;
-
-    return hr;
-}
-
-HRESULT STDMETHODCALLTYPE RuntimeReleaseHandle(HCORMODULE hHandle)
-{
-    STATIC_CONTRACT_NOTHROW;
-    HRESULT hr = S_OK;
-
-    PEImage *pImage = (PEImage*)hHandle;
-
-    if (pImage != NULL)
-        pImage->Release();
-
-    return hr;     
-}
-
-void RuntimeAddRefHandle(HCORMODULE hHandle)
-{
-    STATIC_CONTRACT_NOTHROW;
-
-    PEImage *pImage = (PEImage*)hHandle;
-
-    if (pImage != NULL)
-        pImage->AddRef();
-}
-
-HRESULT STDMETHODCALLTYPE RuntimeGetMDInternalImport(HCORMODULE hHandle, MDInternalImportFlags flags, IMDInternalImport** ppMDImport)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-    PEImage* pImage=(PEImage*)hHandle;
-    HRESULT hr=S_OK;
-
-    BEGIN_SO_INTOLERANT_CODE_NO_THROW_CHECK_THREAD(return COR_E_STACKOVERFLOW);
-    EX_TRY
-    {
-        if (!pImage->HasNTHeaders() || !pImage->HasCorHeader())
-            hr=HRESULT_FROM_WIN32(ERROR_FILE_INVALID);
-        else
-        {
-#ifdef FEATURE_PREJIT
-            if (pImage->HasNativeHeader())
-            {
-                if (!pImage->CheckNativeFormat())
-                    hr=COR_E_BADIMAGEFORMAT;
-                else
-                {
-                    if (flags & MDInternalImport_ILMetaData)
-                        goto OPEN_IL_METADATA;
-
-                    *ppMDImport=pImage->GetNativeMDImport();
-                    if (*ppMDImport)
-                        (*ppMDImport)->AddRef();
-                    else
-                        hr=COR_E_BADIMAGEFORMAT;
-                }
-            }
-            else
-#endif  //FEATURE_PREJIT
-            {
-                if (!pImage->CheckILFormat())
-                    hr=COR_E_BADIMAGEFORMAT;
-                else
-                {
-#ifdef FEATURE_PREJIT                    
-                OPEN_IL_METADATA:
-#endif                    
-                    *ppMDImport=pImage->GetMDImport();
-                    if (*ppMDImport)
-                        (*ppMDImport)->AddRef();
-                    else
-                        hr=COR_E_BADIMAGEFORMAT;
-                }
-            }
-        }
-    }
-    EX_CATCH_HRESULT(hr);
-    END_SO_INTOLERANT_CODE;
-
-    return hr;
-}
-
-HRESULT STDMETHODCALLTYPE RuntimeGetImageBase(HCORMODULE hHandle,LPVOID* base, BOOL bMapped, COUNT_T* dwSize)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-    HRESULT hr=S_FALSE;
-
-    BEGIN_SO_INTOLERANT_CODE_NO_THROW_CHECK_THREAD(return COR_E_STACKOVERFLOW);
-    EX_TRY
-    {
-        PEImage* pImage=(PEImage*)hHandle;
-        *base=NULL;
-        if (!pImage->HasLoadedLayout())
-        {
-            PEImageLayoutHolder pLayout(pImage->GetLayout(bMapped
-                                                            ?PEImageLayout::LAYOUT_MAPPED
-                                                            :PEImageLayout::LAYOUT_FLAT,0));
-            if (pLayout!=NULL)
-            {
-                if(dwSize)
-                    *dwSize=pLayout->GetSize();
-                *base=pLayout->GetBase();
-                hr=S_OK;
-            }
-        }
-
-        if (hr==S_FALSE && pImage->HasLoadedLayout())
-        {
-            BOOL bIsMapped=pImage->GetLoadedLayout()->IsMapped();
-            if ((bIsMapped && bMapped) || (!bIsMapped && !bMapped))
-            {
-                //the one we want
-                *base=pImage->GetLoadedLayout()->GetBase();
-                if (dwSize)
-                    *dwSize=pImage->GetLoadedLayout()->GetSize();
-                hr=S_OK;
-            }
-        }
-    }
-    EX_CATCH_HRESULT(hr);
-    END_SO_INTOLERANT_CODE;
-
-    return hr;
-}
-
-HRESULT STDMETHODCALLTYPE RuntimeGetImageKind(HCORMODULE hHandle,DWORD* pdwKind, DWORD* pdwMachine)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-    HRESULT hr=S_FALSE;
-
-    PEImage* pImage=(PEImage*)hHandle;
-
-    BEGIN_SO_INTOLERANT_CODE_NO_THROW_CHECK_THREAD(return COR_E_STACKOVERFLOW);
-    EX_TRY
-    {
-        pImage->GetPEKindAndMachine(pdwKind, pdwMachine);
-        hr = S_OK;
-    }
-    EX_CATCH_HRESULT(hr);
-    END_SO_INTOLERANT_CODE;
-    return hr;
-}
-
-HRESULT STDMETHODCALLTYPE RuntimeOSHandle(HCORMODULE hHandle, HMODULE* hModule)
-{
-    LIMITED_METHOD_CONTRACT;
-    if(hHandle==NULL || hModule == NULL)
-        return E_POINTER;
-    PEImage* pImage= (PEImage*) hHandle;
-    if (!pImage->HasLoadedLayout())
-        return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
-    *hModule=(HMODULE)pImage->GetLoadedLayout()->GetBase();
-    return S_OK;
-}
-
-HRESULT RuntimeGetAssemblyStrongNameHashForModule(HCORMODULE   hModule,
-                                                  IMetaDataImport * pMDImport,
-                                                  BYTE        *pbSNHash,
-                                                  DWORD       *pcbSNHash)
-{
-    STATIC_CONTRACT_NOTHROW;
-    HRESULT hr = S_OK;
-
-    PEImage* pImage = (PEImage*)hModule;
-
-    BEGIN_SO_INTOLERANT_CODE_NO_THROW_CHECK_THREAD(return COR_E_STACKOVERFLOW);
-    EX_TRY
-    {
-
-        if (pImage->HasStrongNameSignature())
-        {
-            if (pImage->IsStrongNameSigned())
-            {
-                SBuffer signature;
-                pImage->GetHashedStrongNameSignature(signature);
-                *pcbSNHash = min(signature.GetSize(), *pcbSNHash);
-                signature.Copy(pbSNHash, signature.Begin(), *pcbSNHash);
-            }
-            else
-            {
-                // This assembly is delay signed (in this limited scenario).
-                // We'll use the assembly MVID as the hash and leave assembly verification
-                // up to the loader to determine if delay signed assemblies are allowed.
-                // This allows us to fix the perf degrade observed with the hashing code and
-                // detailed in BUG 126760.
-
-                // <TODO>@TODO:workaround: This is a workaround because Fusion is expecting at least 20 bytes of data.</TODO>
-                if (max(sizeof(GUID), 20) <= *pcbSNHash)
-                {
-                    memset(pbSNHash, 0, *pcbSNHash);
-                    hr = pMDImport->GetScopeProps(NULL, 0, NULL, (GUID *) pbSNHash);
-                }
-                else
-                    hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
-
-                *pcbSNHash = max(sizeof(GUID), 20);
-            }
-        }
-        else
-        {
-            hr = CORSEC_E_MISSING_STRONGNAME;
-        }
-    }
-    EX_CATCH_HRESULT(hr);
-    END_SO_INTOLERANT_CODE;
-
-    return hr;
-}
-
-#endif // FEATURE_FUSION
 
 
 #if defined(FEATURE_MIXEDMODE) && !defined(CROSSGEN_COMPILE)
@@ -1269,45 +877,6 @@ void PEImage::UnloadIJWModule(void *pBase)
 
 #endif // FEATURE_MIXEDMODE && !CROSSGEN_COMPILE
 
-#ifdef FEATURE_FUSION
-void PEImage::Init(IStream* pIStream, UINT64 uAsmStreamId,
-                   DWORD dwModuleId, BOOL resourceFile)
-{
-    CONTRACT_VOID
-    {
-        CONSTRUCTOR_CHECK;
-        PRECONDITION(CheckStartup());
-        STANDARD_VM_CHECK;
-    }
-    CONTRACT_END;
-
-    m_StreamAsmId = uAsmStreamId;
-    m_dwStreamModuleId = dwModuleId;
-    m_fIsIStream = TRUE;
-
-    LOG((LF_LOADER, LL_INFO100, "PEImage: Opening flat stream\n"));
-
-    if (!pIStream)
-        ThrowHR(COR_E_FILELOAD);
-
-    // Just copy bytes.
-
-    PEImageLayoutHolder pFlatLayout(PEImageLayout::CreateFromStream(pIStream, this));
-
-    if (!resourceFile) {
-        if (!pFlatLayout->CheckCORFormat())
-            ThrowFormat(COR_E_BADIMAGEFORMAT);
-
-        if (!CheckLayoutFormat(pFlatLayout))
-            ThrowHR(COR_E_NOTSUPPORTED);
-    }
-
-    pFlatLayout.SuppressRelease();
-    SetLayout(IMAGE_FLAT, pFlatLayout);
-
-    RETURN;
-}
-#endif // FEATURE_FUSION
 
 #endif // #ifndef DACCESS_COMPILE
 
@@ -1419,34 +988,20 @@ PEImage::PEImage():
     m_bIsTrustedNativeImage(FALSE),
     m_bIsNativeImageInstall(FALSE),
     m_bPassiveDomainOnly(FALSE),
-#ifndef FEATURE_CORECLR
-    m_fReportedToUsageLog(FALSE),
-#endif // !FEATURE_CORECLR
     m_bInHashMap(FALSE),
 #ifdef METADATATRACKER_DATA
     m_pMDTracker(NULL),
 #endif // METADATATRACKER_DATA
     m_pMDImport(NULL),
     m_pNativeMDImport(NULL),
-#ifdef FEATURE_FUSION
-    m_StreamAsmId(0),
-    m_dwStreamModuleId(0),
-    m_fIsIStream(FALSE),
-#endif
     m_hFile(INVALID_HANDLE_VALUE),
     m_bOwnHandle(true),
     m_bSignatureInfoCached(FALSE),
     m_hrSignatureInfoStatus(E_UNEXPECTED),
     m_dwSignatureInfo(0),
-#ifdef FEATURE_FUSION
-    m_pILFingerprint(NULL),
-#endif //FEATURE_FUSION
     m_dwPEKind(0),
     m_dwMachine(0),
     m_fCachedKindAndMachine(FALSE)
-#ifdef FEATURE_APTCA
-    , m_fMayBeConditionalAptca(TRUE)
-#endif // FEATURE_APTCA
 #ifdef FEATURE_LAZY_COW_PAGES
     ,m_bAllocatedLazyCOWPages(FALSE)
 #endif // FEATURE_LAZY_COW_PAGES
@@ -1526,34 +1081,12 @@ PTR_PEImageLayout PEImage::GetLayoutInternal(DWORD imageLayoutMask,DWORD flags)
         {
             PEImageLayout * pLoadLayout = NULL;
 
-#ifdef FEATURE_CORECLR
             if (m_bIsTrustedNativeImage || IsFile())
             {
                 // For CoreCLR, try to load all files via LoadLibrary first. If LoadLibrary did not work, retry using 
                 // regular mapping - but not for native images.
                 pLoadLayout = PEImageLayout::Load(this, TRUE /* bNTSafeLoad */, m_bIsTrustedNativeImage /* bThrowOnError */);
             }
-#else
-            if (m_bIsTrustedNativeImage)
-            {
-                pLoadLayout = PEImageLayout::Load(this, FALSE);
-            }
-            else if (m_bIsNativeImageInstall)
-            {
-                // When ESB (extended secure boot) is enabled, a native image that is being installed can
-                // only be loaded flat.
-                PEImageLayout* pFlatLayout=PEImageLayout::LoadFlat(GetFileHandle(),this);
-                SetLayout(IMAGE_FLAT,pFlatLayout);
-                pLoadLayout = new ConvertedImageLayout(pFlatLayout);
-            }
-#ifdef FEATURE_READYTORUN
-            else if (ReadyToRunInfo::IsReadyToRunEnabled() && IsFile())
-            {
-                pLoadLayout = PEImageLayout::Load(this, FALSE, FALSE);
-            }
-#endif // FEATURE_READYTORUN
-
-#endif // FEATURE_CORECLR
 
             if (pLoadLayout != NULL)
             {
@@ -1572,46 +1105,9 @@ PTR_PEImageLayout PEImage::GetLayoutInternal(DWORD imageLayoutMask,DWORD flags)
                 // since LoadLibrary is needed if we are to actually load code.  
                 if (pLayout->HasCorHeader() && pLayout->IsILOnly())
                 {    
-#ifdef FEATURE_CORECLR
                     // For CoreCLR, IL only images will always be mapped. We also dont bother doing the conversion of PE header on 64bit,
                     // as done below for the desktop case, as there is no appcompat burden for CoreCLR on 64bit to have that conversion done.
                     fMarkAnyCpuImageAsLoaded = true;
-#else // !FEATURE_CORECLR
-
-#ifdef _WIN64
-                    // When attempting to load an assembly using LoadLibrary on x64,
-                    // the execution will go via the shell-shim that will try to determine
-                    // if the assembly is ILOnly with Pe32 header (i.e. built as anycpu). If it is,
-                    // it will convert the in-memory PEheader of the image to be PE32+ (i.e. mark it as 64bit image).
-                    //
-                    // Since we are trying to avoid mapping twice for ILOnly images by simply memory mapping them,
-                    // we should emulate the shell-shim behaviour for 64bit. This will allow inproc-components (e.g. ASP.NET),
-                    // which check for Pe32+ header, to continue working as expected.
-                    //
-                    // If we fail for some reason to change the header, in retail build, we will simply fallback to the double-loading behaviour without
-                    // any functional problems.
-                    if (pLayout->Has32BitNTHeaders())
-                    {
-                        fMarkAnyCpuImageAsLoaded = pLayout->ConvertILOnlyPE32ToPE64();
-                    }
-                    else
-                    {
-                        // Before assuming that PE32+ file can be loaded, confirm that
-                        // it is the expected machine type. This will ensure AMD64 does not load ARM64 or IA64 assemblies (and likewise).
-                        // If the machine type does not match, the Loader will fail the load at a later point.
-                        if (pLayout->GetMachine() == IMAGE_FILE_MACHINE_NATIVE)
-                        {
-                            fMarkAnyCpuImageAsLoaded = true; // PE32+ (aka native 64bit) binaries dont require any extra processing.
-                        }
-                    }
-#else // !_WIN64
-                    // Why can we not blindly assume that on 32bit OS, image should always be loaded? This is because it is possible to load
-                    // PE32+ image and map it to the 32bit process in WOW64.
-                    if (pLayout->Has32BitNTHeaders())
-                        fMarkAnyCpuImageAsLoaded = true;
-#endif // _WIN64
-
-#endif // FEATURE_CORECLR
                 }
 
                 pLayout.SuppressRelease();
@@ -1636,9 +1132,6 @@ PTR_PEImageLayout PEImage::GetLayoutInternal(DWORD imageLayoutMask,DWORD flags)
         else
         if (imageLayoutMask&PEImageLayout::LAYOUT_FLAT)
         {
-#ifdef FEATURE_FUSION
-            _ASSERTE(!m_fIsIStream); //images created from streams should always have this one
-#endif
             pRetVal=PEImageLayout::LoadFlat(GetFileHandle(),this);
             m_pLayouts[IMAGE_FLAT]=pRetVal;
         }
@@ -1720,36 +1213,8 @@ void PEImage::Load()
     }
     else
     {
-#ifdef FEATURE_CORECLR
         if(m_pLayouts[IMAGE_LOADED]==NULL)
             SetLayout(IMAGE_LOADED,PEImageLayout::Load(this,TRUE));
-#else
-
-        //as part of Load() call we may initialize loaded image in DllMain
-        //so we have to leave the lock and be prepared that when PEImageLayout::Load returns
-        //m_pLayouts[IMAGE_LOADED] is set to something else
-        lock.Release();
-
-        FileHandleHolder pProtect=GetProtectingFileHandle(FALSE);
-
-        // if the image is IL-only, try to load it in the safe manner 
-        
-        // using the Internal function here because we are under the writer lock
-        PEImageLayoutHolder pLayout=GetLayoutInternal(PEImageLayout::LAYOUT_ANY,0);
-        BOOL bPreferSafeLoad=(pLayout && pLayout->IsILOnly());
-
-        // Always use safe load during NGen to avoid running unmanaged code in IJW assemblies
-        if (IsCompilationProcess())
-            bPreferSafeLoad = TRUE;
-
-        PEImageLayoutHolder pLoaded(PEImageLayout::Load(this,bPreferSafeLoad)); 
-
-        lock.Acquire();
-
-        if(m_pLayouts[IMAGE_LOADED]==NULL)
-            SetLayout(IMAGE_LOADED,pLoaded.Extract());
-
-#endif // FEATURE_CORECLR
     }
 }
 
@@ -1867,38 +1332,6 @@ LPCWSTR PEImage::GetPathForErrorMessages()
     return m_path;
 }
 
-#ifdef FEATURE_FUSION
-PEKIND PEImage::GetFusionProcessorArchitecture()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    DWORD dwPEKind, dwMachine;
-    GetPEKindAndMachine(&dwPEKind, &dwMachine);
-
-    DWORD dwAssemblyFlags = 0;
-
-    IfFailThrow(m_pMDImport->GetAssemblyProps(TokenFromRid(1, mdtAssembly),
-                                              NULL, NULL, NULL,
-                                              NULL, NULL, &dwAssemblyFlags));
-
-    PEKIND retval;
-    if (FAILED(TranslatePEToArchitectureType(
-            (CorPEKind)dwPEKind,
-            dwMachine,
-            dwAssemblyFlags,
-            &retval)))
-    {
-        return peInvalid;
-    }
-    return retval;
-}
-#endif //FEATURE_FUSION
 
 HANDLE PEImage::GetFileHandle()
 {
@@ -2040,67 +1473,6 @@ BOOL PEImage::IsPtrInImage(PTR_CVOID data)
     return FALSE;
 }
 
-#ifdef FEATURE_FUSION
-#ifndef DACCESS_COMPILE
-HRESULT PEImage::GetILFingerprint(IILFingerprint **ppFingerprint)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-    *ppFingerprint = NULL;
-    if (m_pILFingerprint == NULL)
-    {
-        HRESULT hr = S_OK;
-        NewHolder<PEFingerprint> pNewFingerprint;
-        EX_TRY
-        {
-            pNewFingerprint = PEFingerprint::CreatePEFingerprint(this);
-            hr = S_OK;
-        }
-        EX_CATCH_HRESULT(hr);
-        if (FAILED(hr))
-        {
-            return hr;
-        }
-
-        if (InterlockedCompareExchangeT(&m_pILFingerprint, (PEFingerprint*)(pNewFingerprint.GetValue()), NULL) == NULL)
-        {
-            pNewFingerprint.SuppressRelease(); // Won the race
-        }
-    }
-
-    *ppFingerprint = m_pILFingerprint;
-    (*ppFingerprint)->AddRef();
-    return S_OK;
-}
-
-// NOTE: Performance critical codepaths should cache the result of this function.
-HRESULT RuntimeGetILFingerprintForPath(LPCWSTR path, IILFingerprint **ppFingerprint)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr;
-    HCORMODULE hCorModule;
-    IfFailGo(RuntimeOpenImageInternal(path, &hCorModule, NULL, MDInternalImport_NoCache));
-    {
-        ReleaseHolder<PEImage> peImage((PEImage*)hCorModule);
-        IfFailGo(peImage->GetILFingerprint(ppFingerprint));
-    }
-    hr = S_OK;
- ErrExit:
-    return hr;
-}
-
-#endif //!DACCESS_COMPILE
-#endif //FEATURE_FUSION
 
 #if !defined(DACCESS_COMPILE)
 PEImage * PEImage::OpenImage(
@@ -2136,18 +1508,6 @@ PEImage * PEImage::OpenImage(
         pPEImage = PEImage::LoadImage(hMod);
     }
 #endif // !FEATURE_PAL    
-#ifdef FEATURE_FUSION
-    else if (iidResource == __uuidof(ICLRPrivResourceStream))
-    {
-        ReleaseHolder<ICLRPrivResourceStream> pIResourceStream;
-        IfFailThrow(pIResource->QueryInterface(__uuidof(ICLRPrivResourceStream), (LPVOID*)&pIResourceStream));
-        ReleaseHolder<IStream> pStream;
-        IfFailThrow(pIResourceStream->GetStream(__uuidof(IStream), (LPVOID*)&pStream));
-        UINT64 i64AssemblyId = static_cast<UINT64>(reinterpret_cast<UINT_PTR>(reinterpret_cast<ICLRPrivAssembly*>(pIResource)));
-        DWORD dwModuleId = static_cast<DWORD>(i64AssemblyId);
-        pPEImage = PEImage::OpenImage(pStream, i64AssemblyId, FALSE, dwModuleId, flags);
-    }
-#endif
     else
     {
         ThrowHR(COR_E_BADIMAGEFORMAT);
diff --git a/src/vm/peimage.h b/src/vm/peimage.h
index 12a4dd763e..4acd544155 100644
--- a/src/vm/peimage.h
+++ b/src/vm/peimage.h
@@ -111,14 +111,6 @@ public:
         LPCWSTR pPath,
         MDInternalImportFlags flags = MDInternalImport_Default);
 
-#ifdef FEATURE_FUSION
-    static PTR_PEImage OpenImage(
-        IStream *pIStream,
-        UINT64 uStreamAsmId,
-        DWORD dwModuleId,
-        BOOL resourceFile,
-        MDInternalImportFlags flags = MDInternalImport_Default);
-#endif
 
     // clones the image with new flags (this is pretty much about cached / noncached difference)
     void Clone(MDInternalImportFlags flags, PTR_PEImage* ppImage)
@@ -261,13 +253,6 @@ public:
     void VerifyIsAssembly();
     void VerifyIsNIAssembly();
 
-#ifndef FEATURE_CORECLR
-    BOOL IsReportedToUsageLog();
-    void SetReportedToUsageLog();
-#ifndef DACCESS_COMPILE
-    HRESULT GetILFingerprint(IILFingerprint **ppFingerprint);
-#endif //!DACCESS_COMPILE
-#endif //!FEATURE_CORECLR
 
     static void GetAll(SArray<PEImage*> &images);
 
@@ -293,33 +278,9 @@ private:
 
     struct PEImageLocator
     {
-#ifdef FEATURE_FUSION
-        BOOL m_fIsIStream;
-        DWORD m_dwStreamModuleId;
-        UINT64 m_StreamAsmId;
-#endif
 
         LPCWSTR m_pPath;
 
-#ifdef FEATURE_FUSION
-        PEImageLocator(LPCWSTR pPath)
-            : m_fIsIStream(FALSE), m_pPath(pPath)
-        {
-        }
-
-        PEImageLocator(UINT64 uStreamAsmId, DWORD dwModuleId)
-            : m_fIsIStream(TRUE), m_dwStreamModuleId(dwModuleId), m_StreamAsmId(uStreamAsmId)
-        {
-        }
-
-        PEImageLocator(PEImage * pImage)
-            : m_fIsIStream(pImage->m_fIsIStream),
-              m_dwStreamModuleId(pImage->m_dwStreamModuleId),
-              m_StreamAsmId(pImage->m_StreamAsmId),
-              m_pPath(pImage->m_path.GetUnicode())
-        {
-        }
-#else // FEATURE_FUSION
         PEImageLocator(LPCWSTR pPath)
             : m_pPath(pPath)
         {
@@ -329,7 +290,6 @@ private:
             : m_pPath(pImage->m_path.GetUnicode())
         {
         }
-#endif // FEATURE_FUSION
     };
 
     static BOOL CompareImage(UPTR image1, UPTR image2);
@@ -359,9 +319,6 @@ private:
     BOOL        m_bIsTrustedNativeImage;
     BOOL        m_bIsNativeImageInstall;
     BOOL        m_bPassiveDomainOnly;
-#ifndef FEATURE_CORECLR
-    BOOL        m_fReportedToUsageLog;
-#endif // !FEATURE_CORECLR
 #ifdef FEATURE_LAZY_COW_PAGES
     BOOL        m_bAllocatedLazyCOWPages;
 #endif // FEATURE_LAZY_COW_PAGES
@@ -392,11 +349,6 @@ protected:
     IMDInternalImport* m_pMDImport;
     IMDInternalImport* m_pNativeMDImport;
 
-#ifdef FEATURE_FUSION
-    UINT64      m_StreamAsmId;
-    DWORD       m_dwStreamModuleId;
-    BOOL        m_fIsIStream;
-#endif
 
 private:
 
@@ -463,25 +415,12 @@ private:
     DWORD m_dwMachine;
     BOOL  m_fCachedKindAndMachine;
 
-#ifdef FEATURE_APTCA
-    BOOL  m_fMayBeConditionalAptca;
-#endif // FEATURE_APTCA
 
-#ifdef FEATURE_FUSION
-    PEFingerprint *m_pILFingerprint; // has to be the real type (as opposed to an interface) so we can delete it
-#endif // FEATURE_FUSION
 
 public:
     void CachePEKindAndMachine();
     void GetPEKindAndMachine(DWORD* pdwKind, DWORD* pdwMachine);
-#ifdef FEATURE_FUSION	
-    PEKIND GetFusionProcessorArchitecture();
-#endif
 
-#ifdef FEATURE_APTCA
-    inline BOOL MayBeConditionalAptca();
-    inline void SetIsNotConditionalAptca();
-#endif // FEATURE_APTCA
 };
 
 FORCEINLINE void PEImageRelease(PEImage *i)
diff --git a/src/vm/peimage.inl b/src/vm/peimage.inl
index 2f4d7d4f31..954d8872f6 100644
--- a/src/vm/peimage.inl
+++ b/src/vm/peimage.inl
@@ -405,47 +405,6 @@ inline const BOOL PEImage::HasStrongNameSignature()
 
 #ifndef DACCESS_COMPILE
 
-#if !defined(FEATURE_CORECLR)
-inline const HRESULT PEImage::VerifyStrongName(DWORD* verifyOutputFlags)  
-{
-    WRAPPER_NO_CONTRACT;
-    _ASSERTE(verifyOutputFlags);
-    if (m_bSignatureInfoCached)
-    {
-        if (SUCCEEDED(m_hrSignatureInfoStatus))
-            *verifyOutputFlags=m_dwSignatureInfo;
-        return m_hrSignatureInfoStatus;
-    }
-
-    BOOL result = FALSE;
-
-    PEImageLayoutHolder pLayout(GetLayout(PEImageLayout::LAYOUT_FLAT,0));
-    if(pLayout!=NULL)
-    {
-        result = StrongNameSignatureVerificationFromImage((BYTE *) pLayout->GetBase(), pLayout->GetSize(), 
-                                                            SN_INFLAG_INSTALL|SN_INFLAG_ALL_ACCESS, 
-                                                            verifyOutputFlags);
-    }
-    else
-    {
-        CONSISTENCY_CHECK(!GetPath().IsEmpty());
-        _ASSERTE(IsFileLocked());
-        result = StrongNameSignatureVerification(GetPath(),
-                                                    SN_INFLAG_INSTALL|SN_INFLAG_ALL_ACCESS|SN_INFLAG_RUNTIME,
-                                                    verifyOutputFlags);
-    }
-
-    HRESULT hr=result?S_OK: StrongNameErrorInfo();
-
-    if (SUCCEEDED(hr) || !Exception::IsTransient(hr))
-    {
-        m_hrSignatureInfoStatus=hr;
-        m_dwSignatureInfo=*verifyOutputFlags;
-        m_bSignatureInfoCached=TRUE;
-    }
-    return hr;
-}    
-#endif // !FEATURE_CORECLR
 
 #endif // !DACCESS_COMPILE
 
@@ -579,59 +538,6 @@ inline void  PEImage::Init(LPCWSTR pPath)
 }
 #ifndef DACCESS_COMPILE
 
-#if !defined(FEATURE_CORECLR)
-/*static*/
-inline PTR_PEImage PEImage::FindByLongPath(LPCWSTR pPath)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(s_hashLock.OwnedByCurrentThread());
-    }
-    CONTRACTL_END;
-
-    PathString sLongPath;
-    COUNT_T nLen = WszGetLongPathName(pPath, sLongPath);
-   
-    // Check for any kind of error other than an insufficient buffer result.
-    if (nLen == 0)
-    {
-        HRESULT hr=HRESULT_FROM_WIN32(GetLastError());
-        if(Exception::IsTransient(hr))
-            ThrowHR(hr);
-        return (PEImage*)INVALIDENTRY;
-    }
-    return FindByPath(sLongPath.GetUnicode());
-}
-
-/*static*/
-inline PTR_PEImage PEImage::FindByShortPath(LPCWSTR pPath)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(s_hashLock.OwnedByCurrentThread());
-    }
-    CONTRACTL_END;
-
-    PathString sShortPath;
-    COUNT_T nLen = WszGetShortPathName(pPath, sShortPath);
-
-    // Check for any kind of error other than an insufficient buffer result.
-    if (nLen == 0)
-    {
-        HRESULT hr=HRESULT_FROM_WIN32(GetLastError());
-        if(Exception::IsTransient(hr))
-            ThrowHR(hr);
-        return (PEImage*)INVALIDENTRY;
-    }
-    return FindByPath(sShortPath.GetUnicode());
-}
-#endif // !FEATURE_CORECLR
 
 /*static*/
 inline PTR_PEImage PEImage::FindByPath(LPCWSTR pPath)
@@ -673,13 +579,6 @@ inline PTR_PEImage PEImage::OpenImage(LPCWSTR pPath, MDInternalImportFlags flags
     
     PEImage* found = FindByPath(pPath);
 
-#if !defined(FEATURE_CORECLR)
-    if(found == (PEImage*) INVALIDENTRY && (flags & MDInternalImport_CheckLongPath))
-         found=FindByLongPath(pPath);
-
-    if(found == (PEImage*) INVALIDENTRY && (flags & MDInternalImport_CheckShortPath))
-         found=FindByShortPath(pPath);
-#endif
 
     if (found == (PEImage*) INVALIDENTRY)
     {
@@ -716,49 +615,6 @@ inline BOOL PEImage::IsFileLocked()
 
 #ifndef DACCESS_COMPILE
 
-#ifdef FEATURE_FUSION
-/* static */
-inline PTR_PEImage PEImage::FindById(UINT64 uStreamAsmId, DWORD dwModuleId)
-{
-    PEImageLocator locator(uStreamAsmId, dwModuleId);
-    CrstHolder holder(&s_hashLock);
-    PEImage* found = (PEImage *) s_Images->LookupValue(HashStreamIds(uStreamAsmId, dwModuleId), &locator);
-    if (found == (PEImage*) INVALIDENTRY)
-        return NULL;
-    found->AddRef();
-    return dac_cast<PTR_PEImage>(found);
-}
-
-/* static */
-inline PTR_PEImage PEImage::OpenImage(IStream *pIStream, UINT64 uStreamAsmId,
-                                      DWORD dwModuleId, BOOL resourceFile, MDInternalImportFlags flags /* = MDInternalImport_Default */)  
-{
-    BOOL fUseCache = !((flags & MDInternalImport_NoCache) == MDInternalImport_NoCache);
-
-    if (!fUseCache)
-    {
-        PEImageHolder pImage(new PEImage());
-        pImage->Init(pIStream, uStreamAsmId, dwModuleId, resourceFile);
-        return dac_cast<PTR_PEImage>(pImage.Extract());
-    }
-
-    
-    DWORD hash = HashStreamIds(uStreamAsmId, dwModuleId);
-    PEImageLocator locator(uStreamAsmId,dwModuleId);
-    CrstHolder holder(&s_hashLock);
-    PEImage* found = (PEImage *) s_Images->LookupValue(hash, &locator);
-    if (found != (PEImage*) INVALIDENTRY)
-    {
-        found->AddRef();
-        return dac_cast<PTR_PEImage>(found);
-    }
-    PEImageHolder pImage(new PEImage());
-    pImage->Init(pIStream, uStreamAsmId, dwModuleId, resourceFile);
-
-    pImage->AddToHashMap();
-    return dac_cast<PTR_PEImage>(pImage.Extract());
-}
-#endif // FEATURE_FUSION
 
 inline void PEImage::AddToHashMap()
 {
@@ -796,10 +652,6 @@ inline BOOL PEImage::HasID()
 {
     LIMITED_METHOD_CONTRACT;
 
-#ifdef FEATURE_FUSION
-    if (m_fIsIStream)
-        return TRUE;
-#endif
 
     return !GetPath().IsEmpty();
 }
@@ -815,10 +667,6 @@ inline ULONG PEImage::GetIDHash()
     }
     CONTRACT_END;
 
-#ifdef FEATURE_FUSION
-    if (m_fIsIStream)
-        RETURN HashStreamIds(m_StreamAsmId, m_dwStreamModuleId);
-#endif
 
 #ifdef FEATURE_CASE_SENSITIVE_FILESYSTEM
     RETURN m_path.Hash();
@@ -873,33 +721,7 @@ inline void  PEImage::GetPEKindAndMachine(DWORD* pdwKind, DWORD* pdwMachine)
         *pdwMachine = m_dwMachine;
 }
 
-#ifdef FEATURE_APTCA
-inline BOOL PEImage::MayBeConditionalAptca()
-{
-    LIMITED_METHOD_CONTRACT;
-    return m_fMayBeConditionalAptca;
-}
 
-inline void PEImage::SetIsNotConditionalAptca()
-{
-    LIMITED_METHOD_CONTRACT;
-    m_fMayBeConditionalAptca = FALSE;
-}
-#endif // FEATURE_APTCA
-
-#ifndef FEATURE_CORECLR
-inline BOOL PEImage::IsReportedToUsageLog()
-{
-    LIMITED_METHOD_CONTRACT;
-    return m_fReportedToUsageLog;
-}
-
-inline void PEImage::SetReportedToUsageLog()
-{
-    LIMITED_METHOD_CONTRACT;
-    m_fReportedToUsageLog = TRUE;
-}
-#endif // !FEATURE_CORECLR
 
 #ifndef DACCESS_COMPILE
 inline void PEImage::AllocateLazyCOWPages()
diff --git a/src/vm/peimagelayout.cpp b/src/vm/peimagelayout.cpp
index 2b50adefb8..9e258f4e8a 100644
--- a/src/vm/peimagelayout.cpp
+++ b/src/vm/peimagelayout.cpp
@@ -17,13 +17,6 @@ PEImageLayout* PEImageLayout::CreateFlat(const void *flat, COUNT_T size,PEImage*
     return new RawImageLayout(flat,size,pOwner);
 }
 
-#ifdef FEATURE_FUSION
-PEImageLayout* PEImageLayout::CreateFromStream(IStream* pIStream,PEImage* pOwner)
-{
-    STANDARD_VM_CONTRACT;
-    return new StreamImageLayout(pIStream,pOwner);
-}
-#endif
 
 PEImageLayout* PEImageLayout::CreateFromHMODULE(HMODULE hModule,PEImage* pOwner, BOOL bTakeOwnership)
 {
@@ -258,47 +251,6 @@ void PEImageLayout::ApplyBaseRelocations()
 }
 #endif // FEATURE_PREJIT
 
-#ifndef FEATURE_CORECLR
-// Event Tracing for Windows is used to log data for performance and functional testing purposes.
-// The events in this structure are used to measure the time taken by PE image mapping. This is useful to reliably measure the
-// performance of the assembly loader by subtracting the time taken by the possibly I/O-intensive work of PE image mapping.
-struct ETWLoaderMappingPhaseHolder { // Special-purpose holder structure to ensure the LoaderMappingPhaseEnd ETW event is fired when returning from a function.
-    StackSString ETWCodeBase;
-    DWORD _dwAppDomainId;
-    BOOL initialized;
-
-    ETWLoaderMappingPhaseHolder(){
-        LIMITED_METHOD_CONTRACT;
-        _dwAppDomainId = ETWAppDomainIdNotAvailable;
-        initialized = FALSE;
-        }
-
-    void Init(DWORD dwAppDomainId, SString wszCodeBase) {
-        _dwAppDomainId = dwAppDomainId;
-
-        EX_TRY
-        {
-            ETWCodeBase.Append(wszCodeBase);
-            ETWCodeBase.Normalize(); // Ensures that the later cast to LPCWSTR does not throw.
-        }
-        EX_CATCH
-        {
-            ETWCodeBase.Clear();
-        }
-        EX_END_CATCH(RethrowTransientExceptions)            
-
-        FireEtwLoaderMappingPhaseStart(_dwAppDomainId, ETWLoadContextNotAvailable, ETWFieldUnused, ETWLoaderLoadTypeNotAvailable, ETWCodeBase.IsEmpty() ? NULL : (LPCWSTR)ETWCodeBase, NULL, GetClrInstanceId());
-
-        initialized = TRUE;
-    }
-
-    ~ETWLoaderMappingPhaseHolder() {
-        if (initialized) {
-            FireEtwLoaderMappingPhaseEnd(_dwAppDomainId, ETWLoadContextNotAvailable, ETWFieldUnused, ETWLoaderLoadTypeNotAvailable, ETWCodeBase.IsEmpty() ? NULL : (LPCWSTR)ETWCodeBase, NULL, GetClrInstanceId());
-        }
-    }
-};
-#endif // FEATURE_CORECLR
 
 RawImageLayout::RawImageLayout(const void *flat, COUNT_T size,PEImage* pOwner)
 {
@@ -316,12 +268,6 @@ RawImageLayout::RawImageLayout(const void *flat, COUNT_T size,PEImage* pOwner)
 
     PEFingerprintVerificationHolder verifyHolder(pOwner);  // Do not remove: This holder ensures the IL file hasn't changed since the runtime started making assumptions about it.
 
-#ifndef FEATURE_CORECLR
-    ETWLoaderMappingPhaseHolder loaderMappingPhaseHolder;
-    if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context, TRACE_LEVEL_INFORMATION, CLR_PRIVATEBINDING_KEYWORD)) {
-        loaderMappingPhaseHolder.Init(GetAppDomain() ? GetAppDomain()->GetId().m_dwId : ETWAppDomainIdNotAvailable, GetPath());
-    }
-#endif // FEATURE_CORECLR
 
     if (size)
     {
@@ -355,12 +301,6 @@ RawImageLayout::RawImageLayout(const void *mapped, PEImage* pOwner, BOOL bTakeOw
 
     PEFingerprintVerificationHolder verifyHolder(pOwner);  // Do not remove: This holder ensures the IL file hasn't changed since the runtime started making assumptions about it.
 
-#ifndef FEATURE_CORECLR
-    ETWLoaderMappingPhaseHolder loaderMappingPhaseHolder;
-    if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context, TRACE_LEVEL_INFORMATION, CLR_PRIVATEBINDING_KEYWORD)) {
-        loaderMappingPhaseHolder.Init(GetAppDomain() ? GetAppDomain()->GetId().m_dwId : ETWAppDomainIdNotAvailable, GetPath());
-    }
-#endif // FEATURE_CORECLR
 
     if (bTakeOwnership)
     {
@@ -392,12 +332,6 @@ ConvertedImageLayout::ConvertedImageLayout(PEImageLayout* source)
 
     PEFingerprintVerificationHolder verifyHolder(source->m_pOwner);  // Do not remove: This holder ensures the IL file hasn't changed since the runtime started making assumptions about it.
 
-#ifndef FEATURE_CORECLR
-    ETWLoaderMappingPhaseHolder loaderMappingPhaseHolder;
-    if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context, TRACE_LEVEL_INFORMATION, CLR_PRIVATEBINDING_KEYWORD)) {
-        loaderMappingPhaseHolder.Init(GetAppDomain() ? GetAppDomain()->GetId().m_dwId : ETWAppDomainIdNotAvailable, GetPath());
-    }
-#endif // FEATURE_CORECLR
     
     if (!source->HasNTHeaders())
         EEFileLoadException::Throw(GetPath(), COR_E_BADIMAGEFORMAT);
@@ -447,12 +381,6 @@ MappedImageLayout::MappedImageLayout(HANDLE hFile, PEImage* pOwner)
 
 #ifndef FEATURE_PAL
 
-#ifndef FEATURE_CORECLR
-    ETWLoaderMappingPhaseHolder loaderMappingPhaseHolder;
-    if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context, TRACE_LEVEL_INFORMATION, CLR_PRIVATEBINDING_KEYWORD)) {
-        loaderMappingPhaseHolder.Init(GetAppDomain() ? GetAppDomain()->GetId().m_dwId : ETWAppDomainIdNotAvailable, GetPath());
-    }
-#endif // FEATURE_CORECLR
 
     // Let OS map file for us
 
@@ -461,23 +389,12 @@ MappedImageLayout::MappedImageLayout(HANDLE hFile, PEImage* pOwner)
     if (m_FileMap == NULL)
     {
 #ifndef CROSSGEN_COMPILE
-#ifdef FEATURE_CORECLR
 
         // There is no reflection-only load on CoreCLR and so we can always throw an error here.
         // It is important on Windows Phone. All assemblies that we load must have SEC_IMAGE set
         // so that the OS can perform signature verification.
         ThrowLastError();
 
-#else // FEATURE_CORECLR
-
-        // We need to ensure any signature validation errors are caught if Extended Secure Boot (ESB) is on.
-        // Also, we have to always throw here during NGen to ensure that the signature validation is never skipped.
-        if (GetLastError() != ERROR_BAD_EXE_FORMAT || IsCompilationProcess())
-        {
-            ThrowLastError();
-        }
-
-#endif // FEATURE_CORECLR
 #endif // CROSSGEN_COMPILE
 
         return;
@@ -624,12 +541,6 @@ LoadedImageLayout::LoadedImageLayout(PEImage* pOwner, BOOL bNTSafeLoad, BOOL bTh
 
     PEFingerprintVerificationHolder verifyHolder(pOwner);  // Do not remove: This holder ensures the IL file hasn't changed since the runtime started making assumptions about it.
 
-#ifndef FEATURE_CORECLR
-    ETWLoaderMappingPhaseHolder loaderMappingPhaseHolder;
-    if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context, TRACE_LEVEL_INFORMATION, CLR_PRIVATEBINDING_KEYWORD)) {
-        loaderMappingPhaseHolder.Init(GetAppDomain() ? GetAppDomain()->GetId().m_dwId : ETWAppDomainIdNotAvailable, GetPath());
-    }
-#endif // FEATURE_CORECLR
 
     DWORD dwFlags = GetLoadWithAlteredSearchPathFlag();
     if (bNTSafeLoad)
@@ -667,12 +578,6 @@ FlatImageLayout::FlatImageLayout(HANDLE hFile, PEImage* pOwner)
 
     PEFingerprintVerificationHolder verifyHolder(pOwner);  // Do not remove: This holder ensures the IL file hasn't changed since the runtime started making assumptions about it.
 
-#ifndef FEATURE_CORECLR
-    ETWLoaderMappingPhaseHolder loaderMappingPhaseHolder;
-    if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context, TRACE_LEVEL_INFORMATION, CLR_PRIVATEBINDING_KEYWORD)) {
-        loaderMappingPhaseHolder.Init(GetAppDomain() ? GetAppDomain()->GetId().m_dwId : ETWAppDomainIdNotAvailable, GetPath());
-    }
-#endif // FEATURE_CORECLR
 
     COUNT_T size = SafeGetFileSize(hFile, NULL);
     if (size == 0xffffffff && GetLastError() != NOERROR)
@@ -695,57 +600,6 @@ FlatImageLayout::FlatImageLayout(HANDLE hFile, PEImage* pOwner)
     Init(m_FileView, size);
 }
 
-#ifdef FEATURE_FUSION
-StreamImageLayout::StreamImageLayout(IStream* pIStream,PEImage* pOwner)
-{
-    CONTRACTL
-    {
-        CONSTRUCTOR_CHECK;
-        STANDARD_VM_CHECK;
-    }
-    CONTRACTL_END;
-    
-    m_Layout=LAYOUT_FLAT;
-    m_pOwner=pOwner;
-
-    PEFingerprintVerificationHolder verifyHolder(pOwner);  // Do not remove: This holder ensures the IL file hasn't changed since the runtime started making assumptions about it.
-
-#ifndef FEATURE_CORECLR
-    ETWLoaderMappingPhaseHolder loaderMappingPhaseHolder;
-    if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context, TRACE_LEVEL_INFORMATION, CLR_PRIVATEBINDING_KEYWORD)) {
-        loaderMappingPhaseHolder.Init(GetAppDomain() ? GetAppDomain()->GetId().m_dwId : ETWAppDomainIdNotAvailable, GetPath());
-    }
-#endif // FEATURE_CORECLR
-    
-    STATSTG statStg;
-    IfFailThrow(pIStream->Stat(&statStg, STATFLAG_NONAME));
-    if (statStg.cbSize.u.HighPart > 0)
-        ThrowHR(COR_E_FILELOAD);
-
-    DWORD cbRead = 0;
-
-    // Resources files may have zero length (and would be mapped as FLAT)
-    if (statStg.cbSize.u.LowPart) {
-         m_FileMap.Assign(WszCreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 
-                                                   statStg.cbSize.u.LowPart, NULL));
-        if (m_FileMap == NULL)
-            ThrowWin32(GetLastError());
-
-        m_FileView.Assign(CLRMapViewOfFile(m_FileMap, FILE_MAP_ALL_ACCESS, 0, 0, 0));
-        
-        if (m_FileView == NULL)
-            ThrowWin32(GetLastError());
-        
-        HRESULT hr = pIStream->Read(m_FileView, statStg.cbSize.u.LowPart, &cbRead);
-        if (hr == S_FALSE)
-            hr = COR_E_FILELOAD;
-
-        IfFailThrow(hr);
-    }
-    TESTHOOKCALL(ImageMapped(GetPath(),m_FileView,IM_FLAT));        
-    Init(m_FileView,(COUNT_T)cbRead);
-}
-#endif // FEATURE_FUSION
 
 #endif // !DACESS_COMPILE
 
diff --git a/src/vm/peimagelayout.h b/src/vm/peimagelayout.h
index 68d6315be4..d3949edc7a 100644
--- a/src/vm/peimagelayout.h
+++ b/src/vm/peimagelayout.h
@@ -176,20 +176,6 @@ public:
 
 };
 
-#ifdef FEATURE_FUSION
-class StreamImageLayout: public PEImageLayout
-{
-    VPTR_VTABLE_CLASS(StreamImageLayout,PEImageLayout)
-    VPTR_UNIQUE(0x71)
-protected:
-    HandleHolder m_FileMap;
-    CLRMapViewHolder m_FileView;
-public:
-#ifndef DACCESS_COMPILE    
-    StreamImageLayout(IStream* pIStream,PEImage* pOwner);   
-#endif
-};
-#endif // FEATURE_FUSION
 
 
 #endif  // PEIMAGELAYOUT_H_
diff --git a/src/vm/prestub.cpp b/src/vm/prestub.cpp
index 9fd7c52446..723e6b68f2 100644
--- a/src/vm/prestub.cpp
+++ b/src/vm/prestub.cpp
@@ -24,7 +24,6 @@
 #include "listlock.inl"
 #include "stubgen.h"
 #include "eventtrace.h"
-#include "constrainedexecutionregion.h"
 #include "array.h"
 #include "compile.h"
 #include "ecall.h"
@@ -1233,12 +1232,6 @@ PCODE MethodDesc::DoPrestub(MethodTable *pDispatchingMT)
         RETURN GetStableEntryPoint();
     }
 
-#if defined(FEATURE_PREJIT) && defined(FEATURE_CER)
-    // If this method is the root of a CER call graph and we've recorded this fact in the ngen image then we're in the prestub in
-    // order to trip any runtime level preparation needed for this graph (P/Invoke stub generation/library binding, generic
-    // dictionary prepopulation etc.).
-    GetModule()->RestoreCer(this);
-#endif // FEATURE_PREJIT && FEATURE_CER
 
 #ifdef FEATURE_COMINTEROP 
     /**************************   INTEROP   *************************/
diff --git a/src/vm/profilinghelper.cpp b/src/vm/profilinghelper.cpp
index 1dd60b47e1..b1fb228acb 100644
--- a/src/vm/profilinghelper.cpp
+++ b/src/vm/profilinghelper.cpp
@@ -138,9 +138,6 @@
 #include "profilinghelper.inl"
 #include "eemessagebox.h"
 
-#if defined(FEATURE_PROFAPI_EVENT_LOGGING) && !defined(FEATURE_CORECLR)
-#include <eventmsg.h>
-#endif // FEATURE_PROFAPI_EVENT_LOGGING) && !FEATURE_CORECLR
 
 #ifdef FEATURE_PROFAPI_ATTACH_DETACH 
 #include "profattach.h"
@@ -398,30 +395,8 @@ void ProfilingAPIUtility::LogProfEventVA(
 
     AppendSupplementaryInformation(iStringResourceID, &messageToLog);
 
-#if defined(FEATURE_CORECLR)
     // CoreCLR on Windows ouputs debug strings for diagnostic messages.
     WszOutputDebugString(messageToLog);
-#else
-    // Get the user SID for the current process, so it can be provided to the event
-    // logging API, which will then fill out the "User" field in the event log entry. If
-    // this fails, that's not fatal. We can just pass NULL for the PSID, and the "User"
-    // field will be left blank.
-    PSID psid = NULL;
-    HRESULT hr = GetCurrentProcessUserSid(&psid);
-    if (FAILED(hr))
-    {
-        // No biggie.  Just pass in a NULL psid, and the User field will be empty
-        _ASSERTE(psid == NULL);
-    }
-
-    // On desktop CLR builds, the profiling API uses the event log for end-user-friendly
-    // diagnostic messages.
-    ReportEventCLR(wEventType,             // wType
-                   0,                      // wCategory
-                   COR_Profiler,           // dwEventID
-                   psid,                   // lpUserSid
-                   &messageToLog);         // uh duh
-#endif // FEATURE_CORECLR
 
 #endif // FEATURE_PROFAPI_EVENT_LOGGING
 }
@@ -732,11 +707,7 @@ HRESULT ProfilingAPIUtility::AttemptLoadProfilerForStartup()
     // Find out if profiling is enabled
     DWORD fProfEnabled = 0;
 
-#ifdef FEATURE_CORECLR
     fProfEnabled = CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CORECLR_ENABLE_PROFILING);
-#else //FEATURE_CORECLR
-    fProfEnabled = CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_COR_ENABLE_PROFILING);
-#endif //FEATURE_CORECLR
 
     // If profiling is not enabled, return.
     if (fProfEnabled == 0)
@@ -751,7 +722,6 @@ HRESULT ProfilingAPIUtility::AttemptLoadProfilerForStartup()
     NewArrayHolder<WCHAR> wszClsid(NULL);
     NewArrayHolder<WCHAR> wszProfilerDLL(NULL);
 
-#ifdef FEATURE_CORECLR
     IfFailRet(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CORECLR_PROFILER, &wszClsid));
 
 #if defined(_TARGET_X86_)
@@ -763,19 +733,6 @@ HRESULT ProfilingAPIUtility::AttemptLoadProfilerForStartup()
     {
         IfFailRet(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_CORECLR_PROFILER_PATH, &wszProfilerDLL));
     }
-#else // FEATURE_CORECLR
-    IfFailRet(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_COR_PROFILER, &wszClsid));
-    
-#if defined(_TARGET_X86_)
-    IfFailRet(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_COR_PROFILER_PATH_32, &wszProfilerDLL));
-#elif defined(_TARGET_AMD64_)
-    IfFailRet(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_COR_PROFILER_PATH_64, &wszProfilerDLL));
-#endif 
-    if(wszProfilerDLL == NULL)
-    {    
-        IfFailRet(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_COR_PROFILER_PATH, &wszProfilerDLL));
-    }
-#endif // FEATURE_CORECLR
     
     // If the environment variable doesn't exist, profiling is not enabled.
     if (wszClsid == NULL)
diff --git a/src/vm/proftoeeinterfaceimpl.cpp b/src/vm/proftoeeinterfaceimpl.cpp
index 6a50c62309..18702d7b60 100644
--- a/src/vm/proftoeeinterfaceimpl.cpp
+++ b/src/vm/proftoeeinterfaceimpl.cpp
@@ -4727,16 +4727,10 @@ HRESULT ProfToEEInterfaceImpl::SetILInstrumentedCodeMap(FunctionID functionId,
     if (!pMethodDesc ->IsRestored())
         return CORPROF_E_DATAINCOMPLETE;
 
-#ifdef FEATURE_CORECLR
     if (g_pDebugInterface == NULL)
     {
         return CORPROF_E_DEBUGGING_DISABLED;
     }
-#else
-    // g_pDebugInterface is initialized on startup on desktop CLR, regardless of whether a debugger
-    // or profiler is loaded.  So it should always be available.
-    _ASSERTE(g_pDebugInterface != NULL);
-#endif // FEATURE_CORECLR
 
     COR_IL_MAP * rgNewILMapEntries = new (nothrow) COR_IL_MAP[cILMapEntries];
 
@@ -5181,16 +5175,10 @@ HRESULT ProfToEEInterfaceImpl::GetILToNativeMapping2(FunctionID functionId,
         return E_INVALIDARG;
     }
 
-#ifdef FEATURE_CORECLR
     if (g_pDebugInterface == NULL)
     {
         return CORPROF_E_DEBUGGING_DISABLED;
     }
-#else
-    // g_pDebugInterface is initialized on startup on desktop CLR, regardless of whether a debugger
-    // or profiler is loaded.  So it should always be available.
-    _ASSERTE(g_pDebugInterface != NULL);
-#endif // FEATURE_CORECLR
 
     return (g_pDebugInterface->GetILToNativeMapping(pMD, cMap, pcMap, map));
 #else
@@ -7411,7 +7399,7 @@ Loop:
                 REGDISPLAY rd;
                 ZeroMemory(&rd, sizeof(rd));
 
-                rd.pEbp = &ctxCur.Ebp;
+                rd.SetEbpLocation(&ctxCur.Ebp);
                 rd.SP = ctxCur.Esp;
                 rd.ControlPC = ctxCur.Eip;
 
@@ -7422,7 +7410,7 @@ Loop:
                     &codeManState, 
                     NULL);
 
-                ctxCur.Ebp = *(rd.pEbp);
+                ctxCur.Ebp = *rd.GetEbpLocation();
                 ctxCur.Esp = rd.SP;
                 ctxCur.Eip = rd.ControlPC;
             }
@@ -8681,11 +8669,7 @@ HRESULT ProfToEEInterfaceImpl::GetRuntimeInformation(USHORT * pClrInstanceId,
 
     if (pRuntimeType != NULL)
     {
-#ifdef FEATURE_CORECLR
         *pRuntimeType = COR_PRF_CORE_CLR;
-#else // FEATURE_CORECLR
-        *pRuntimeType = COR_PRF_DESKTOP_CLR;
-#endif // FEATURE_CORECLR
     }
 
     if (pMajorVersion != NULL)
diff --git a/src/vm/readytoruninfo.cpp b/src/vm/readytoruninfo.cpp
index a0e44ceaf3..b1be026a6c 100644
--- a/src/vm/readytoruninfo.cpp
+++ b/src/vm/readytoruninfo.cpp
@@ -491,13 +491,8 @@ PTR_ReadyToRunInfo ReadyToRunInfo::Initialize(Module * pModule, AllocMemTracker
 
     if (!pLayout->IsNativeMachineFormat())
     {
-#ifdef FEATURE_CORECLR
         // For CoreCLR, be strict about disallowing machine mismatches.
         COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
-#else
-        DoLog("Ready to Run disabled - mismatched architecture");
-        return NULL;
-#endif
     }
 
 #ifdef FEATURE_NATIVE_IMAGE_GENERATION
diff --git a/src/vm/reflectclasswriter.h b/src/vm/reflectclasswriter.h
index 486a25a78f..afd33c067b 100644
--- a/src/vm/reflectclasswriter.h
+++ b/src/vm/reflectclasswriter.h
@@ -91,11 +91,6 @@ public:
         m_pOnDiskEmitter = pOnDiskEmitter;
     }
 
-#ifndef FEATURE_CORECLR
-    //HRESULT EnsureCeeFileGenCreated(DWORD corhFlags = COMIMAGE_FLAGS_ILONLY, DWORD peFlags = ICEE_CREATE_FILE_PURE_IL);
-    HRESULT EnsureCeeFileGenCreated(DWORD corhFlags, DWORD peFlags);
-    HRESULT DestroyCeeFileGen();
-#endif
 
 	~RefClassWriter();
 };
diff --git a/src/vm/reflectioninvocation.cpp b/src/vm/reflectioninvocation.cpp
index 4edecdd2c6..1c93d23946 100644
--- a/src/vm/reflectioninvocation.cpp
+++ b/src/vm/reflectioninvocation.cpp
@@ -22,7 +22,6 @@
 #include "contractimpl.h"
 #include "virtualcallstub.h"
 #include "comdelegate.h"
-#include "constrainedexecutionregion.h"
 #include "generics.h"
 
 #ifdef FEATURE_COMINTEROP
@@ -234,13 +233,6 @@ FCIMPL5(void, ReflectionInvocation::PerformVisibilityCheckOnField, FieldDesc *pF
     }
     CONTRACTL_END;
 
-#ifndef FEATURE_CORECLR
-    // Security checks are expensive as they involve stack walking. Avoid them if we can.
-    // In immersive we don't allow private reflection to framework code. So we need to perform
-    // the access check even if all the domains on the stack are fully trusted.
-    if (Security::AllDomainsOnStackFullyTrusted() && !AppX::IsAppXProcess())
-        return;
-#endif
 
     REFLECTCLASSBASEREF refDeclaringType = (REFLECTCLASSBASEREF)ObjectToOBJECTREF(pDeclaringTypeUNSAFE);
 
@@ -262,9 +254,6 @@ FCIMPL5(void, ReflectionInvocation::PerformVisibilityCheckOnField, FieldDesc *pF
 
         bool targetRemoted = FALSE;
 
-#ifndef FEATURE_CORECLR
-        targetRemoted = targetObj != NULL && InvokeUtil::IsTargetRemoted(pFieldDesc, targetObj->GetMethodTable());
-#endif //FEATURE_CORECLR
 
         RefSecContext sCtx(InvokeUtil::GetInvocationAccessCheckType(targetRemoted));
 
@@ -593,16 +582,6 @@ FCIMPL6(Object*, RuntimeTypeHandle::CreateInstance, ReflectClassBaseObject* refT
 
             if (!securityOff)
             {
-#ifndef FEATURE_CORECLR
-                // Security checks are expensive as they involve stack walking. Avoid them if we can.
-                // In immersive we don't allow private reflection to framework code. So we need to perform
-                // the access check even if all the domains on the stack are fully trusted.
-                if (Security::AllDomainsOnStackFullyTrusted() && !AppX::IsAppXProcess())
-                {
-                    bNeedAccessCheck = false;
-                }
-                else
-#endif //FEATURE_CORECLR
                 {
                     // Public critical types cannot be accessed by transparent callers
                     bNeedAccessCheck = !pVMT->IsExternallyVisible() || Security::TypeRequiresTransparencyCheck(pVMT);
@@ -871,109 +850,6 @@ FCIMPL1(DWORD, ReflectionInvocation::GetSpecialSecurityFlags, ReflectMethodObjec
 }
 FCIMPLEND
 
-#ifndef FEATURE_CORECLR
-
-// Can not inline this function.
-#ifdef _MSC_VER
-__declspec(noinline)
-#endif
-void PerformSecurityCheckHelper(Object *targetUnsafe, MethodDesc *pMeth, MethodTable* pParentMT, DWORD dwFlags)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-
-        PRECONDITION(CheckPointer(pMeth));
-    }
-    CONTRACTL_END;
-
-    OBJECTREF target (targetUnsafe);
-    GCPROTECT_BEGIN (target);
-    FrameWithCookie<DebuggerSecurityCodeMarkFrame> __dbgSecFrame;
-
-    bool targetRemoted = false;
-
-#ifndef FEATURE_CORECLR
-    targetRemoted = target != NULL && InvokeUtil::IsTargetRemoted(pMeth, target->GetMethodTable());
-#endif //FEATURE_CORECLR
-
-    RefSecContext sCtx(InvokeUtil::GetInvocationAccessCheckType(targetRemoted));
-
-    MethodTable* pInstanceMT = NULL;
-    if (target != NULL) {
-        if (!target->GetTypeHandle().IsTypeDesc())
-            pInstanceMT = target->GetTypeHandle().AsMethodTable();
-    }
-
-#ifdef FEATURE_CORECLR
-    if (dwFlags & (INVOCATION_FLAGS_RISKY_METHOD|INVOCATION_FLAGS_IS_DELEGATE_CTOR))
-    {
-        // On CoreCLR we assert that "dangerous" methods (see IsDangerousMethods) can only
-        // be reflection-invoked by platform code (C or SC).
-
-        // Also, for delegates, in desktop we used to demand unmanaged
-        // code permission for this since it's hard to validate the target address.
-        // Here we just restrict access to Critical code.
-        MethodDesc *pCallerMD = sCtx.GetCallerMethod();
-
-        if (pCallerMD && Security::IsMethodTransparent(pCallerMD))
-        {
-            ThrowMethodAccessException(pCallerMD, pMeth, FALSE, IDS_E_TRANSPARENT_REFLECTION);
-        }
-    }
-
-    if (dwFlags & (INVOCATION_FLAGS_NEED_SECURITY|INVOCATION_FLAGS_CONSTRUCTOR_INVOKE))
-#endif 
-    {
-
-        if (dwFlags & INVOCATION_FLAGS_CONSTRUCTOR_INVOKE)
-            InvokeUtil::CanAccessMethod(pMeth,
-                                        pParentMT,
-                                        pInstanceMT,
-                                        &sCtx,
-                                        TRUE /*fCriticalToFullDemand*/);
-        else
-            InvokeUtil::CanAccessMethod(pMeth,
-                                        pParentMT,
-                                        pInstanceMT,
-                                        &sCtx,
-                                        TRUE /*fCriticalToFullDemand*/,
-                                        (dwFlags & INVOCATION_FLAGS_IS_CTOR) != 0 /*checkSkipVer*/);
-    }
-
-    __dbgSecFrame.Pop();
-    GCPROTECT_END();
-}
-
-FCIMPL4(void, ReflectionInvocation::PerformSecurityCheck, Object *target, MethodDesc *pMeth, ReflectClassBaseObject *pParentUNSAFE, DWORD dwFlags) {
-    CONTRACTL {
-        FCALL_CHECK;
-        PRECONDITION(CheckPointer(pMeth));
-    }
-    CONTRACTL_END;
-    
-#ifndef FEATURE_CORECLR
-    // Security checks are expensive as they involve stack walking. Avoid them if we can.
-    // In immersive we don't allow private reflection to framework code. So we need to perform
-    // the access check even if all the domains on the stack are fully trusted.
-    if (Security::AllDomainsOnStackFullyTrusted() && !AppX::IsAppXProcess())
-        return;
-#endif
-
-    REFLECTCLASSBASEREF refParent = (REFLECTCLASSBASEREF)ObjectToOBJECTREF(pParentUNSAFE);
-
-    HELPER_METHOD_FRAME_BEGIN_1(refParent);
-    //CAUTION: PerformSecurityCheckHelper could trigger GC!
-    
-    TypeHandle parent = refParent != NULL ? refParent->GetType() : TypeHandle();
-    PerformSecurityCheckHelper(target,pMeth,parent.GetMethodTable(),dwFlags);
-
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-
-#endif // FEATURE_CORECLR
 
 /****************************************************************************/
 /* boxed Nullable<T> are represented as a boxed T, so there is no unboxed
@@ -1207,9 +1083,7 @@ void DECLSPEC_NORETURN ThrowInvokeMethodException(MethodDesc * pMethod, OBJECTRE
     GCPROTECT_BEGIN(targetException);
 
 #if defined(_DEBUG) && !defined(FEATURE_PAL)
-#ifdef FEATURE_CORECLR
     if (IsWatsonEnabled())
-#endif // FEATURE_CORECLR
     {
         if (!CLRException::IsPreallocatedExceptionObject(targetException))
         {
@@ -1258,9 +1132,7 @@ void DECLSPEC_NORETURN ThrowInvokeMethodException(MethodDesc * pMethod, OBJECTRE
     OBJECTREF except = InvokeUtil::CreateTargetExcept(&targetException);
 
 #ifndef FEATURE_PAL
-#ifdef FEATURE_CORECLR
     if (IsWatsonEnabled())
-#endif // FEATURE_CORECLR
     {
         struct 
         {
@@ -1961,9 +1833,6 @@ FCIMPL4(Object*, RuntimeFieldHandle::GetValueDirect, ReflectFieldObject *pFieldU
 
         bool targetRemoted = false;
 
-#ifndef FEATURE_CORECLR
-        targetRemoted = !targetType.IsNull() && InvokeUtil::IsTargetRemoted(pField, targetType.AsMethodTable());
-#endif //FEATURE_CORECLR
 
         RefSecContext sCtx(InvokeUtil::GetInvocationAccessCheckType(targetRemoted));
 
@@ -2144,9 +2013,6 @@ FCIMPL5(void, RuntimeFieldHandle::SetValueDirect, ReflectFieldObject *pFieldUNSA
             // security and consistency checks
 
             bool targetRemoted = false;
-#ifndef FEATURE_CORECLR
-            targetRemoted = targetType.IsNull() && InvokeUtil::IsTargetRemoted(pField, targetType.AsMethodTable());
-#endif //FEATURE_CORECLR
 
             RefSecContext sCtx(InvokeUtil::GetInvocationAccessCheckType(targetRemoted));
 
@@ -2344,10 +2210,8 @@ FCIMPL1(void, ReflectionInvocation::RunClassConstructor, ReflectClassBaseObject
         HELPER_METHOD_FRAME_BEGIN_1(refType);
 
         // We perform the access check only on CoreCLR for backward compatibility.
-#ifdef FEATURE_CORECLR
         RefSecContext sCtx(InvokeUtil::GetInvocationAccessCheckType());
         InvokeUtil::CanAccessClass(&sCtx, pMT);
-#endif //FEATURE_CORECLR
 
         pMT->CheckRestore();
         pMT->EnsureInstanceActive();
@@ -2389,116 +2253,6 @@ FCIMPL1(void, ReflectionInvocation::RunModuleConstructor, ReflectModuleBaseObjec
 }
 FCIMPLEND
 
-#ifndef FEATURE_CORECLR
-// This method triggers a given method to be jitted
-FCIMPL3(void, ReflectionInvocation::PrepareMethod, ReflectMethodObject* pMethodUNSAFE, TypeHandle *pInstantiation, UINT32 cInstantiation)
-{
-    CONTRACTL {
-        FCALL_CHECK;
-        PRECONDITION(CheckPointer(pMethodUNSAFE, NULL_OK));
-        PRECONDITION(CheckPointer(pInstantiation, NULL_OK));
-    }
-    CONTRACTL_END;
-    
-    REFLECTMETHODREF refMethod = (REFLECTMETHODREF)ObjectToOBJECTREF(pMethodUNSAFE);
-
-    if (refMethod == NULL)
-        FCThrowArgumentVoidEx(kArgumentException, NULL, W("InvalidOperation_HandleIsNotInitialized"));
-
-    MethodDesc *pMD = refMethod->GetMethod();
-    
-    HELPER_METHOD_FRAME_BEGIN_1(refMethod);
-
-    if (pMD->IsAbstract())
-        COMPlusThrowArgumentNull(W("method"), W("Argument_CannotPrepareAbstract"));
-
-    pMD->CheckRestore();
-
-    MethodTable * pExactMT = pMD->GetMethodTable();
-    if (pInstantiation != NULL)
-    {
-        // We were handed an instantiation, check that the method expects it and the right number of types has been provided (the
-        // caller supplies one array containing the class instantiation immediately followed by the method instantiation).
-        if (cInstantiation != (pMD->GetNumGenericMethodArgs() + pMD->GetNumGenericClassArgs()))
-            COMPlusThrow(kArgumentException, W("Argument_InvalidGenericInstantiation"));
-
-        // We need to find the actual class and/or method instantiations, even though we've been passed them. This is an issue of
-        // lifetime -- the instantiation passed in will go away at some point whereas preparation of the method has the potential to
-        // persist a copy of the instantiation pointer. By finding the actual instantiation we get a stable pointer whose lifetime
-        // is at least as long as the data generated by preparation.
-
-        // Check we've got a reasonable looking instantiation.
-        if (!Generics::CheckInstantiation(Instantiation(pInstantiation, cInstantiation)))
-            COMPlusThrow(kArgumentException, W("Argument_InvalidGenericInstantiation"));
-        for (ULONG i = 0; i < cInstantiation; i++)
-            if (pInstantiation[i].ContainsGenericVariables())
-                COMPlusThrow(kArgumentException, W("Argument_InvalidGenericInstantiation"));
-
-        // Load the exact type of the method if it needs to be instantiated (because it's a generic type definition, e.g. C<T>, or a
-        // shared type instantiation, e.g. C<Object>).
-        if (pExactMT->IsGenericTypeDefinition() || pExactMT->IsSharedByGenericInstantiations())
-        {
-            TypeHandle thExactType = ClassLoader::LoadGenericInstantiationThrowing(pMD->GetModule(),
-                                                                                   pMD->GetMethodTable()->GetCl(),
-                                                                                   Instantiation(pInstantiation, pMD->GetNumGenericClassArgs()));
-            pExactMT = thExactType.AsMethodTable();
-        }
-
-        // As for the class we might need to find a method desc with an exact instantiation if the one we have is too vague.
-        // Note: IsGenericMethodDefinition implies ContainsGenericVariables so there's no need to check it separately.
-        if (pMD->IsSharedByGenericInstantiations() || pMD->ContainsGenericVariables())
-            pMD = MethodDesc::FindOrCreateAssociatedMethodDesc(pMD,
-                                                               pExactMT,
-                                                               FALSE,
-                                                               Instantiation(&pInstantiation[pMD->GetNumGenericClassArgs()], pMD->GetNumGenericMethodArgs()),
-                                                               FALSE);
-    }
-    else
-    {
-        // No instantiation provided, the method better not be expecting one.
-
-        // Methods that are generic definitions (e.g. C.Foo<U>) and those that are shared (e.g. C<Object>.Foo, C.Foo<Object>) need
-        // extra instantiation data.
-        // Note: IsGenericMethodDefinition implies ContainsGenericVariables so there's no need to check it separately.
-        if (pMD->IsSharedByGenericInstantiations() || pMD->ContainsGenericVariables())
-            COMPlusThrow(kArgumentException, W("Argument_InvalidGenericInstantiation"));
-
-        // The rest of the cases (non-generics related methods, instantiating stubs, methods instantiated over non-shared types
-        // etc.) should be able to provide their instantiation for us as necessary.
-    }
-
-    // Go prepare the method at the specified instantiation.
-    PrepareMethodDesc(pMD, pExactMT->GetInstantiation(), pMD->GetMethodInstantiation());
-
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-
-// This method triggers a given delegate to be prepared.  This involves preparing the
-// delegate's Invoke method and preparing the target of that Invoke.  In the case of
-// a multi-cast delegate, we rely on the fact that each individual component was prepared
-// prior to the Combine.  If our event sinks perform the Combine, this is always true.
-// If the client calls Combine himself, he is responsible for his own preparation.
-FCIMPL1(void, ReflectionInvocation::PrepareDelegate, Object* delegateUNSAFE)
-{
-    CONTRACTL {
-        FCALL_CHECK;
-        PRECONDITION(CheckPointer(delegateUNSAFE, NULL_OK));
-    }
-    CONTRACTL_END;
-    
-    if (delegateUNSAFE == NULL)
-        return;
-
-    OBJECTREF delegate = ObjectToOBJECTREF(delegateUNSAFE);
-    HELPER_METHOD_FRAME_BEGIN_1(delegate);
-
-    PrepareDelegateHelper(&delegate, FALSE);
-
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-#endif // !FEATURE_CORECLR
 
 FCIMPL1(void, ReflectionInvocation::PrepareContractedDelegate, Object * delegateUNSAFE)
 {
@@ -2508,103 +2262,9 @@ FCIMPL1(void, ReflectionInvocation::PrepareContractedDelegate, Object * delegate
     }
     CONTRACTL_END;
     
-#ifdef FEATURE_CER
-    if (delegateUNSAFE == NULL)
-        return;
-
-    OBJECTREF delegate = ObjectToOBJECTREF(delegateUNSAFE);
-    HELPER_METHOD_FRAME_BEGIN_1(delegate);
-
-    PrepareDelegateHelper(&delegate, TRUE);
-
-    HELPER_METHOD_FRAME_END();
-#endif // FEATURE_CER
 }
 FCIMPLEND
 
-#ifdef FEATURE_CER
-void ReflectionInvocation::PrepareDelegateHelper(OBJECTREF *pDelegate, BOOL onlyContractedMethod)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(CheckPointer(pDelegate));
-        PRECONDITION(CheckPointer(OBJECTREFToObject(*pDelegate)));
-    }
-    CONTRACTL_END;
-    
-    // Make sure the delegate subsystem itself is prepared.
-    // Force the immediate creation of any global stubs required. This is platform specific.
-#ifdef _TARGET_X86_
-    {
-        GCX_PREEMP();
-        COMDelegate::TheDelegateInvokeStub();
-    }
-#endif
-
-    MethodDesc *pMDTarget = COMDelegate::GetMethodDesc(*pDelegate);
-    MethodDesc *pMDInvoke = COMDelegate::FindDelegateInvokeMethod((*pDelegate)->GetMethodTable());
-
-    // If someone does give us a multicast delegate, then both MDs will be the same -- they
-    // will both be the Delegate's Invoke member.  Normally, pMDTarget points at the method
-    // the delegate is wrapping, of course.
-    if (pMDTarget == pMDInvoke)
-    {
-        pMDTarget->CheckRestore();
-
-        // The invoke method itself is never generic, but the delegate class itself might be.
-        PrepareMethodDesc(pMDInvoke,
-                          pMDInvoke->GetExactClassInstantiation((*pDelegate)->GetTypeHandle()),
-                          Instantiation(),
-                          onlyContractedMethod);
-    }
-    else
-    {
-        pMDTarget->CheckRestore();
-        pMDInvoke->CheckRestore();
-
-        // Prepare the eventual target method first.
-
-        // Load the exact type of the method if it needs to be instantiated (because it's a generic type definition, e.g. C<T>, or a
-        // shared type instantiation, e.g. C<Object>).
-        MethodTable *pExactMT = pMDTarget->GetMethodTable();
-        if (pExactMT->IsGenericTypeDefinition() || pExactMT->IsSharedByGenericInstantiations())
-        {
-            OBJECTREF targetObj = COMDelegate::GetTargetObject(*pDelegate);
-
-#ifdef FEATURE_REMOTING
-            // We prepare the delegate for the sole purpose of reliability (CER).
-            // If the target is a transparent proxy, we cannot guarantee reliability anyway.
-            if (CRemotingServices::IsTransparentProxy(OBJECTREFToObject(targetObj)))
-                return;
-#endif //FEATURE_REMOTING
-
-            pExactMT = targetObj->GetMethodTable();
-        }
-
-
-        // For delegates with generic target methods it must be the case that we are passed an instantiating stub -- there's no
-        // other way the necessary method instantiation information can be passed to us.
-        // The target MD may be shared by generic instantiations as long as it does not require extra instantiation arguments.
-        // We have the actual target object so we can extract the exact class instantiation from it.
-        _ASSERTE(!pMDTarget->RequiresInstArg() &&
-                 !pMDTarget->ContainsGenericVariables());
-
-        PrepareMethodDesc(pMDTarget,
-                          pMDTarget->GetExactClassInstantiation(TypeHandle(pExactMT)),
-                          pMDTarget->GetMethodInstantiation(),
-                          onlyContractedMethod);
-
-        // Now prepare the delegate invoke method.
-        // The invoke method itself is never generic, but the delegate class itself might be.
-        PrepareMethodDesc(pMDInvoke,
-                          pMDInvoke->GetExactClassInstantiation((*pDelegate)->GetTypeHandle()),
-                          Instantiation(),
-                          onlyContractedMethod);
-    }
-}
-#endif // FEATURE_CER
 
 FCIMPL0(void, ReflectionInvocation::ProbeForSufficientStack)
 {
@@ -2851,18 +2511,6 @@ FCIMPL3(void, ReflectionInvocation::ExecuteCodeWithGuaranteedCleanup, Object* co
     if (gc.backoutDelegate == NULL)
         COMPlusThrowArgumentNull(W("backoutCode"));
 
-#ifdef FEATURE_CER
-    if (!IsCompilationProcess())
-    {
-        // Delegates are prepared as part of the ngen process, so only prepare the backout 
-        // delegate for non-ngen processes. 
-        PrepareDelegateHelper((OBJECTREF *)&gc.backoutDelegate, FALSE);
-
-        // Make sure the managed backout code helper function has been prepared before we 
-        // attempt to run the backout code.
-        PrepareMethodDesc(g_pExecuteBackoutCodeHelperMethod, Instantiation(), Instantiation(), FALSE, TRUE);
-    }
-#endif // FEATURE_CER
 
     ExecuteCodeWithGuaranteedCleanupHelper(&gc);
 
@@ -3333,27 +2981,6 @@ FCIMPL1(Object*, ReflectionSerialization::GetSafeUninitializedObject, ReflectCla
         COMPlusThrow(kNotSupportedException, W("NotSupported_ManagedActivation"));
 #endif // FEATURE_COMINTEROP
 
-#ifdef FEATURE_APTCA
-    if (!pMT->GetAssembly()->AllowUntrustedCaller()) {
-        OBJECTREF permSet = NULL;
-        Security::GetPermissionInstance(&permSet, SECURITY_FULL_TRUST);
-        Security::DemandSet(SSWT_LATEBOUND_LINKDEMAND, permSet);
-    }
-#endif // FEATURE_APTCA
-
-#ifdef FEATURE_CAS_POLICY 
-    if (pMT->GetClass()->RequiresLinktimeCheck()) {
-        OBJECTREF refClassNonCasDemands = NULL;
-        OBJECTREF refClassCasDemands = NULL;
-
-        refClassCasDemands = TypeSecurityDescriptor::GetLinktimePermissions(pMT, &refClassNonCasDemands);
-
-        if (refClassCasDemands != NULL)
-            Security::DemandSet(SSWT_LATEBOUND_LINKDEMAND, refClassCasDemands);
-
-    }
-#endif // FEATURE_CAS_POLICY
-
     // If it is a nullable, return the underlying type instead.  
     if (Nullable::IsNullableType(pMT)) 
         pMT = pMT->GetInstantiation()[0].GetMethodTable();
diff --git a/src/vm/reflectioninvocation.h b/src/vm/reflectioninvocation.h
index 7f72b61cd8..a05a202e87 100644
--- a/src/vm/reflectioninvocation.h
+++ b/src/vm/reflectioninvocation.h
@@ -50,10 +50,6 @@ public:
 
     static FCDECL1(void, RunClassConstructor, ReflectClassBaseObject *pTypeUNSAFE);
     static FCDECL1(void, RunModuleConstructor, ReflectModuleBaseObject *pModuleUNSAFE);
-#ifndef FEATURE_CORECLR
-    static FCDECL3(void, PrepareMethod, ReflectMethodObject* pMethodUNSAFE, TypeHandle *pInstantiation, UINT32 cInstantiation);
-    static FCDECL1(void, PrepareDelegate, Object* delegateUNSAFE);
-#endif // !FEATURE_CORECLR
     static FCDECL1(void, PrepareContractedDelegate, Object* delegateUNSAFE);
     static FCDECL0(void, ProbeForSufficientStack);    
     static FCDECL0(void, EnsureSufficientExecutionStack);
diff --git a/src/vm/rejit.cpp b/src/vm/rejit.cpp
index 0b6e922831..7bbd0e2f71 100644
--- a/src/vm/rejit.cpp
+++ b/src/vm/rejit.cpp
@@ -447,16 +447,10 @@ HRESULT ProfilerFunctionControl::SetILInstrumentedCodeMap(ULONG cILMapEntries, C
         return E_INVALIDARG;
     }
 
-#ifdef FEATURE_CORECLR
     if (g_pDebugInterface == NULL)
     {
         return CORPROF_E_DEBUGGING_DISABLED;
     }
-#else
-    // g_pDebugInterface is initialized on startup on desktop CLR, regardless of whether a debugger
-    // or profiler is loaded.  So it should always be available.
-    _ASSERTE(g_pDebugInterface != NULL);
-#endif // FEATURE_CORECLR
 
 
     // copy the il map and il map entries into the corresponding fields.
diff --git a/src/vm/remoting.cpp b/src/vm/remoting.cpp
deleted file mode 100644
index 1b65323bb6..0000000000
--- a/src/vm/remoting.cpp
+++ /dev/null
@@ -1,3773 +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.
-// 
-// File: remoting.cpp
-// 
-
-//
-// Purpose: Defines various remoting related objects such as
-//          proxies
-//
-
-// 
-
-
-#include "common.h"
-
-#ifdef FEATURE_REMOTING
-#include "virtualcallstub.h"
-#include "excep.h"
-#include "comdelegate.h"
-#include "remoting.h"
-#include "field.h"
-#include "siginfo.hpp"
-#include "stackbuildersink.h"
-#include "eehash.h"
-#include "profilepriv.h"
-#include "message.h"
-#include "eeconfig.h"
-#include "comcallablewrapper.h"
-#include "interopconverter.h"
-#include "asmconstants.h"
-#include "crossdomaincalls.h"
-#include "contractimpl.h"
-#include "typestring.h"
-#include "generics.h"
-#include "appdomain.inl"
-#include "dbginterface.h"
-
-#ifndef DACCESS_COMPILE
-
-// These hold label offsets into non-virtual thunks. They are used by
-// CNonVirtualThunkMgr::DoTraceStub and ::TraceManager to help the
-// debugger figure out where the thunk is going to go.
-DWORD g_dwNonVirtualThunkRemotingLabelOffset = 0;
-DWORD g_dwNonVirtualThunkReCheckLabelOffset = 0;
-
-// Statics
-
-MethodTable *CRemotingServices::s_pMarshalByRefObjectClass;    
-MethodTable *CRemotingServices::s_pServerIdentityClass;
-
-MethodDesc *CRemotingServices::s_pRPPrivateInvoke;
-MethodDesc *CRemotingServices::s_pRPInvokeStatic;
-MethodDesc *CRemotingServices::s_pWrapMethodDesc;
-MethodDesc *CRemotingServices::s_pIsCurrentContextOK;
-MethodDesc *CRemotingServices::s_pCheckCast;
-MethodDesc *CRemotingServices::s_pFieldSetterDesc;
-MethodDesc *CRemotingServices::s_pFieldGetterDesc;
-MethodDesc *CRemotingServices::s_pObjectGetTypeDesc;
-MethodDesc *CRemotingServices::s_pGetTypeDesc;
-MethodDesc *CRemotingServices::s_pProxyForDomainDesc;
-MethodDesc *CRemotingServices::s_pServerContextForProxyDesc;
-MethodDesc *CRemotingServices::s_pServerDomainIdForProxyDesc;
-DWORD CRemotingServices::s_dwServerOffsetInRealProxy;
-DWORD CRemotingServices::s_dwSrvIdentityOffsetInRealProxy;
-DWORD CRemotingServices::s_dwIdOffset;
-DWORD CRemotingServices::s_dwTPOrObjOffsetInIdentity;
-DWORD CRemotingServices::s_dwMBRIDOffset;
-DWORD CRemotingServices::s_dwLeaseOffsetInIdentity;
-DWORD CRemotingServices::s_dwURIOffsetInIdentity;
-CrstStatic CRemotingServices::s_RemotingCrst;
-BOOL CRemotingServices::s_fRemotingStarted;
-MethodDesc *CRemotingServices::s_pRenewLeaseOnCallDesc;
-
-
-#ifdef FEATURE_COMINTEROP
-MethodDesc *CRemotingServices::s_pCreateObjectForCom;
-#endif
-
-// CTPMethodTable Statics
-DWORD CTPMethodTable::s_dwCommitedTPSlots;
-DWORD CTPMethodTable::s_dwReservedTPSlots;
-DWORD CTPMethodTable::s_dwReservedTPIndirectionSlotSize;
-DWORD CTPMethodTable::s_dwGCInfoBytes;
-DWORD CTPMethodTable::s_dwMTDataSlots;
-MethodTable *CTPMethodTable::s_pRemotingProxyClass;
-CrstStatic CTPMethodTable::s_TPMethodTableCrst;
-EEThunkHashTable *CTPMethodTable::s_pThunkHashTable;
-BOOL CTPMethodTable::s_fTPTableFieldsInitialized;
-
-#endif // !DACCESS_COMPILE
-
-
-SPTR_IMPL(MethodTable, CTPMethodTable, s_pThunkTable);
-
-#ifndef DACCESS_COMPILE
-
-// CVirtualThunks statics
-CVirtualThunks *CVirtualThunks::s_pVirtualThunks;
-
-// CVirtualThunkMgr statics                                                     
-CVirtualThunkMgr *CVirtualThunkMgr::s_pVirtualThunkMgr;
-
-#ifndef HAS_REMOTING_PRECODE
-// CNonVirtualThunk statics
-CNonVirtualThunk *CNonVirtualThunk::s_pNonVirtualThunks;
-SimpleRWLock* CNonVirtualThunk::s_pNonVirtualThunksListLock;
-
-// CNonVirtualThunkMgr statics
-CNonVirtualThunkMgr *CNonVirtualThunkMgr::s_pNonVirtualThunkMgr;
-#endif
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::Initialize    public
-//
-//  Synopsis:   Initialized remoting state
-//  
-//+----------------------------------------------------------------------------
-VOID CRemotingServices::Initialize()
-{
-    STANDARD_VM_CONTRACT;
-
-    // Initialize the remoting services critical section
-    s_RemotingCrst.Init(CrstRemoting, CrstFlags(CRST_REENTRANCY|CRST_HOST_BREAKABLE));
-
-    CTPMethodTable::Initialize();
-}
-
-INT32 CRemotingServices::IsTransparentProxy(Object* orTP)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_COOPERATIVE;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-    
-    INT32 fIsTPMT = FALSE;
-
-    if(orTP != NULL)
-    {
-        // Check if the supplied object has transparent proxy method table
-        MethodTable *pMT = orTP->GetMethodTable();
-        fIsTPMT = pMT->IsTransparentProxy() ? TRUE : FALSE;
-    }
-
-    LOG((LF_REMOTING, LL_EVERYTHING, "!IsTransparentProxyEx(0x%x) returning %s",
-         orTP, fIsTPMT ? "TRUE" : "FALSE"));
-
-    return(fIsTPMT);
-}
-
-
-Object* CRemotingServices::GetRealProxy(Object* objTP)
-{   
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_COOPERATIVE;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-    
-    OBJECTREF rv = NULL;
-
-    if ((objTP != NULL) && (IsTransparentProxy(objTP)))
-    {
-        _ASSERTE(s_fRemotingStarted);
-        rv = CTPMethodTable::GetRP(OBJECTREF(objTP));
-    }
-
-    LOG((LF_REMOTING, LL_INFO100, "!GetRealProxy(0x%x) returning 0x%x\n", objTP, OBJECTREFToObject(rv)));
-
-    return OBJECTREFToObject(rv);
-}
-
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::EnsureRemotingStarted
-//
-//  Synopsis:   Startup the remoting services.
-//
-// 
-//+----------------------------------------------------------------------------
-VOID CRemotingServices::EnsureRemotingStarted()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-    
-    if (!CRemotingServices::s_fRemotingStarted)
-        CRemotingServices::StartRemoting();
-
-    if (!CTPMethodTable::s_fTPTableFieldsInitialized)
-        CTPMethodTable::EnsureFieldsInitialized();
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::StartRemoting    private
-//
-//  Synopsis:   Initialize the static fields of CRemotingServices class
-//
-// 
-//+----------------------------------------------------------------------------
-VOID CRemotingServices::StartRemoting()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    // Acquire the remoting lock before initializing fields
-    GCX_PREEMP();
-
-    CrstHolder ch(&s_RemotingCrst);
-
-    // Make sure that no other thread has initialized the fields
-    if (!s_fRemotingStarted)
-    {
-        InitActivationServicesClass();
-        InitRealProxyClass();
-        InitRemotingProxyClass();
-        InitIdentityClass();
-        InitServerIdentityClass();
-        InitMarshalByRefObjectClass();
-        InitRemotingServicesClass();
-        InitObjectClass();
-        InitLeaseClass();
-
-        // *********   NOTE   ************ 
-        // This must always be the last statement in this block to prevent races
-        // 
-        VolatileStore(&s_fRemotingStarted, TRUE);
-        // ********* END NOTE ************        
-    }
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::InitActivationServicesClass    private
-//
-//  Synopsis:   Extract the method descriptors and fields of ActivationServices class
-//
-// 
-//+----------------------------------------------------------------------------
-VOID CRemotingServices::InitActivationServicesClass()
-{
-    STANDARD_VM_CONTRACT;
-    
-    s_pIsCurrentContextOK = MscorlibBinder::GetMethod(METHOD__ACTIVATION_SERVICES__IS_CURRENT_CONTEXT_OK);
-#ifdef FEATURE_COMINTEROP
-    s_pCreateObjectForCom = MscorlibBinder::GetMethod(METHOD__ACTIVATION_SERVICES__CREATE_OBJECT_FOR_COM);
-#endif
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::InitRealProxyClass    private
-//
-//  Synopsis:   Extract the method descriptors and fields of Real Proxy class
-//
-// 
-//+----------------------------------------------------------------------------
-VOID CRemotingServices::InitRealProxyClass()
-{
-    STANDARD_VM_CONTRACT;
-    
-    // Now store the methoddesc of the PrivateInvoke method on the RealProxy class
-    s_pRPPrivateInvoke = MscorlibBinder::GetMethod(METHOD__REAL_PROXY__PRIVATE_INVOKE);
-
-    // Now find the offset to the _identity field inside the 
-    // RealProxy  class
-    s_dwIdOffset = RealProxyObject::GetOffsetOfIdentity() - Object::GetOffsetOfFirstField();
-
-    s_dwServerOffsetInRealProxy = RealProxyObject::GetOffsetOfServerObject() - Object::GetOffsetOfFirstField();
-
-    s_dwSrvIdentityOffsetInRealProxy = RealProxyObject::GetOffsetOfServerIdentity() - Object::GetOffsetOfFirstField();
-    
-    return;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::InitRemotingProxyClass    private
-//
-//  Synopsis:   Extract the method descriptors and fields of RemotingProxy class
-//
-// 
-//+----------------------------------------------------------------------------
-VOID CRemotingServices::InitRemotingProxyClass()
-{
-    STANDARD_VM_CONTRACT;
-    
-    s_pRPInvokeStatic = MscorlibBinder::GetMethod(METHOD__REMOTING_PROXY__INVOKE);
-
-    // Note: We cannot do this inside TPMethodTable::InitializeFields ..
-    // that causes recursions if in some situation only the latter is called
-    // If you do this you will see Asserts when running any process under CorDbg
-    // This is because jitting of NV methods on MBR objects calls 
-    // InitializeFields and when actually doing that we should not need to
-    // JIT another NV method on some MBR object.
-    CTPMethodTable::s_pRemotingProxyClass = MscorlibBinder::GetClass(CLASS__REMOTING_PROXY);
-    _ASSERTE(CTPMethodTable::s_pRemotingProxyClass);
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::InitServerIdentityClass    private
-//
-//  Synopsis:   Extract the method descriptors and fields of ServerIdentity class
-//
-// 
-//+----------------------------------------------------------------------------
-VOID CRemotingServices::InitServerIdentityClass()
-{
-    STANDARD_VM_CONTRACT;
-    
-    s_pServerIdentityClass = MscorlibBinder::GetClass(CLASS__SERVER_IDENTITY);
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::InitIdentityClass    private
-//
-//  Synopsis:   Extract the method descriptors and fields of Identity class
-//
-// 
-//+----------------------------------------------------------------------------
-VOID CRemotingServices::InitIdentityClass()
-{
-    STANDARD_VM_CONTRACT;
-    
-    s_dwTPOrObjOffsetInIdentity = MscorlibBinder::GetFieldOffset(FIELD__IDENTITY__TP_OR_OBJECT);
-
-    s_dwLeaseOffsetInIdentity = MscorlibBinder::GetFieldOffset(FIELD__IDENTITY__LEASE);
-
-    s_dwURIOffsetInIdentity = MscorlibBinder::GetFieldOffset(FIELD__IDENTITY__OBJURI);
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::InitMarshalByRefObjectClass    private
-//
-//  Synopsis:   Extract the method descriptors and fields of MarshalByRefObject class
-//
-// 
-//+----------------------------------------------------------------------------
-VOID CRemotingServices::InitMarshalByRefObjectClass()
-{
-    STANDARD_VM_CONTRACT;
-    
-    s_pMarshalByRefObjectClass = MscorlibBinder::GetClass(CLASS__MARSHAL_BY_REF_OBJECT);
-    s_dwMBRIDOffset = MarshalByRefObjectBaseObject::GetOffsetOfServerIdentity() - Object::GetOffsetOfFirstField();
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::InitRemotingServicesClass    private
-//
-//  Synopsis:   Extract the method descriptors and fields of RemotingServices class
-//
-// 
-//+----------------------------------------------------------------------------
-VOID CRemotingServices::InitRemotingServicesClass()
-{
-    STANDARD_VM_CONTRACT;
-    
-    s_pCheckCast = MscorlibBinder::GetMethod(METHOD__REMOTING_SERVICES__CHECK_CAST);
-
-    // Need these to call wrap/unwrap from the VM (message.cpp).
-    // Also used by JIT helpers to wrap/unwrap
-    s_pWrapMethodDesc = MscorlibBinder::GetMethod(METHOD__REMOTING_SERVICES__WRAP);
-    s_pProxyForDomainDesc = MscorlibBinder::GetMethod(METHOD__REMOTING_SERVICES__CREATE_PROXY_FOR_DOMAIN);
-    s_pServerContextForProxyDesc = MscorlibBinder::GetMethod(METHOD__REMOTING_SERVICES__GET_SERVER_CONTEXT_FOR_PROXY);
-    s_pServerDomainIdForProxyDesc = MscorlibBinder::GetMethod(METHOD__REMOTING_SERVICES__GET_SERVER_DOMAIN_ID_FOR_PROXY);
-    s_pGetTypeDesc = MscorlibBinder::GetMethod(METHOD__REMOTING_SERVICES__GET_TYPE);
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::InitObjectClass    private
-//
-//  Synopsis:   Extract the method descriptors and fields of Object class
-//
-// 
-//+----------------------------------------------------------------------------
-VOID CRemotingServices::InitObjectClass()
-{
-    STANDARD_VM_CONTRACT;
-    
-    s_pFieldSetterDesc = MscorlibBinder::GetMethod(METHOD__OBJECT__FIELD_SETTER);
-    s_pFieldGetterDesc = MscorlibBinder::GetMethod(METHOD__OBJECT__FIELD_GETTER);
-    s_pObjectGetTypeDesc = MscorlibBinder::GetMethod(METHOD__OBJECT__GET_TYPE);
-}
-
-VOID CRemotingServices::InitLeaseClass()
-{
-    STANDARD_VM_CONTRACT;
-
-    s_pRenewLeaseOnCallDesc = MscorlibBinder::GetMethod(METHOD__LEASE__RENEW_ON_CALL);
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::RequiresManagedActivation    private
-//
-//  Synopsis:   Determine if a config file has been parsed or if there
-//              are any attributes on the class that would require us
-//              to go into the managed activation codepath.
-//              
-//
-//  Note:       Called by CreateProxyOrObject (JIT_NewCrossContext)
-// 
-//+----------------------------------------------------------------------------
-ManagedActivationType __stdcall CRemotingServices::RequiresManagedActivation(TypeHandle ty)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        SO_TOLERANT;
-        PRECONDITION(!ty.IsNull());
-    }
-    CONTRACTL_END;
-    
-    MethodTable* pMT = ty.GetMethodTable();
-
-    PREFIX_ASSUME(pMT != NULL);
-    if (!pMT->MayRequireManagedActivation())
-        return NoManagedActivation;
-
-#ifdef _DEBUG
-   
-    ManagedActivationType bManaged = NoManagedActivation;
-    if (pMT->IsRemotingConfigChecked())
-    {
-        // We have done work to figure this out in the past ... 
-        // use the cached result
-        bManaged = pMT->RequiresManagedActivation() ? ManagedActivation : NoManagedActivation;
-    } 
-    else if (pMT->IsContextful() || pMT->GetClass()->HasRemotingProxyAttribute()) 
-    {
-        // Contextful and classes that have a remoting proxy attribute 
-        // (whether they are MarshalByRef or ContextFul) always take the slow 
-        // path of managed activation
-        bManaged = ManagedActivation;
-    }
-    else
-    {
-        // If we have parsed a config file that might have configured
-        // this Type to be activated remotely 
-        if (GetAppDomain()->IsRemotingConfigured())
-        {
-            bManaged = ManagedActivation;
-            // We will remember if the activation is actually going
-            // remote based on if the managed call to IsContextOK returned us
-            // a proxy or not
-        }
-
-#ifdef FEATURE_COMINTEROP
-        else if (pMT->IsComObjectType())
-        {
-            bManaged = ComObjectType;
-        }
-#endif // FEATURE_COMINTEROP
-
-    }
-
-#endif // _DEBUG
-
-    if (pMT->RequiresManagedActivation()) 
-    {
-        // Contextful and classes that have a remoting proxy attribute 
-        // (whether they are MarshalByRef or ContextFul) always take the slow 
-        // path of managed activation
-        _ASSERTE(bManaged == ManagedActivation);
-        return ManagedActivation;
-    }
-    
-    ManagedActivationType bMng = NoManagedActivation;
-    if (!pMT->IsRemotingConfigChecked())
-    {
-        g_IBCLogger.LogMethodTableAccess(pMT);
-
-        // If we have parsed a config file that might have configured
-        // this Type to be activated remotely   
-        if (GetAppDomain()->IsRemotingConfigured())
-        {
-            bMng = ManagedActivation;
-            // We will remember if the activation is actually going
-            // remote based on if the managed call to IsContextOK returned us
-            // a proxy or not
-        }
-        
-#ifdef FEATURE_COMINTEROP
-        else if (pMT->IsComObjectType())
-        {
-            bMng = ComObjectType;
-        }
-#endif // FEATURE_COMINTEROP
-        
-        if (bMng == NoManagedActivation)
-        {
-            pMT->TrySetRemotingConfigChecked();
-        }
-    }
-
-    _ASSERTE(bManaged == bMng);
-    return bMng;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::CreateProxyOrObject    public
-//
-//  Synopsis:   Determine if the current context is appropriate
-//              for activation. If the current context is OK then it creates 
-//              an object else it creates a proxy.
-//              
-//
-//  Note:       Called by JIT_NewCrossContext 
-// 
-//+----------------------------------------------------------------------------
-OBJECTREF CRemotingServices::CreateProxyOrObject(MethodTable* pMT, 
-    BOOL fIsCom /*default:FALSE*/, BOOL fIsNewObj /*default:FALSE*/)
-    /* fIsCom == Did we come here through CoCreateInstance */
-    /* fIsNewObj == Did we come here through Jit_NewCrossContext (newObj) */
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(CheckPointer(pMT));
-        PRECONDITION(!pMT->IsTransparentProxy());
-
-        // By the time we reach here, we have already checked that the class may require
-        // managed activation. This check is made either through the JIT_NewCrossContext helper
-        // or Activator.CreateInstance codepath.
-        PRECONDITION(pMT->MayRequireManagedActivation());
-    }
-    CONTRACTL_END;
-    
-    // Ensure remoting has been started.
-    EnsureRemotingStarted();
-
-    // Get the address of IsCurrentContextOK in managed code
-    MethodDesc* pTargetMD = NULL;
-    Object *pServer = NULL;
-
-#ifdef FEATURE_COMINTEROP
-    if(fIsCom)
-    {
-        pTargetMD = CRemotingServices::MDofCreateObjectForCom();
-    }
-    else
-#endif // FEATURE_COMINTEROP
-    {
-        pTargetMD = CRemotingServices::MDofIsCurrentContextOK();
-    }
-
-    // Arrays are not created by JIT_NewCrossContext
-    _ASSERTE(!pMT->IsArray());
-
-    // Get the type seen by reflection
-    REFLECTCLASSBASEREF reflectType = (REFLECTCLASSBASEREF) pMT->GetManagedClassObject();
-    LPVOID pvType = NULL;
-    *(REFLECTCLASSBASEREF *)&pvType = reflectType;
-
-    // This will return either an uninitialized object or a proxy
-    pServer = (Object *)CTPMethodTable::CallTarget(pTargetMD, pvType, NULL, (LPVOID)(size_t)(fIsNewObj?1:0));
-
-    if (!pMT->IsContextful() && !pMT->IsComObjectType())
-    {   
-        // Cache the result of the activation attempt ... 
-        // if a strictly MBR class is not configured for remote 
-        // activation we will not go 
-        // through this slow path next time! 
-        // (see RequiresManagedActivation)
-        if (IsTransparentProxy(pServer))
-        {
-            // Set the flag that this class is remote activate
-            // which means activation will go to managed code.
-            pMT->SetRequiresManagedActivation();
-        }
-        else
-        {
-            // Set only the flag that no managed checks are required
-            // for this class next time.
-            pMT->SetRemotingConfigChecked();
-        }
-    }
-
-    LOG((LF_REMOTING, LL_INFO1000, "CreateProxyOrObject returning 0x%p\n", pServer));
-    if (pMT->IsContextful())
-    {
-        COUNTER_ONLY(GetPerfCounters().m_Context.cObjAlloc++);
-    }
-    return ObjectToOBJECTREF(pServer);
-}
-
-
-#ifndef HAS_REMOTING_PRECODE
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::GetStubForNonVirtualMethod   public
-//
-//  Synopsis:   Get a stub for a non virtual method. 
-//
-// 
-//+----------------------------------------------------------------------------
-Stub* CRemotingServices::GetStubForNonVirtualMethod(MethodDesc* pMD, LPVOID pvAddrOfCode, Stub* pInnerStub)
-{
-    CONTRACT (Stub*)
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pMD));
-        PRECONDITION(CheckPointer(pvAddrOfCode));
-        PRECONDITION(CheckPointer(pInnerStub, NULL_OK));
-        POSTCONDITION(CheckPointer(RETVAL));
-    }
-    CONTRACT_END;
-    
-    CPUSTUBLINKER sl;
-    Stub* pStub = CTPMethodTable::CreateStubForNonVirtualMethod(pMD, &sl, pvAddrOfCode, pInnerStub);
-    
-    RETURN pStub;
-}
-#endif // HAS_REMOTING_PRECODE
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::GetNonVirtualEntryPointForVirtualMethod   public
-//
-//  Synopsis:   Get a thunk for a non-virtual call to a virtual method.
-//              Virtual methods do not normally get thunked in the vtable. This
-//              is because virtual calls use the object's vtable, and proxied objects
-//              would use the proxy's vtable. Hence local object (which would
-//              have the real vtable) can make virtual calls without going through
-//              the thunk.
-//              However, if the virtual function is called non-virtually, we have
-//              a problem (since this would bypass the proxy's vtable). Since this
-//              is not a common case, we fix it by using a stub in such cases.
-//
-// 
-//+----------------------------------------------------------------------------
-PCODE CRemotingServices::GetNonVirtualEntryPointForVirtualMethod(MethodDesc* pMD)
-{
-    CONTRACT (PCODE)
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pMD));
-        PRECONDITION(pMD->IsRemotingInterceptedViaVirtualDispatch());
-        POSTCONDITION(RETVAL != NULL);
-    }
-    CONTRACT_END;
-
-#ifdef HAS_REMOTING_PRECODE
-    RETURN pMD->GetLoaderAllocator()->GetFuncPtrStubs()->GetFuncPtrStub(pMD, PRECODE_REMOTING);
-#else
-    GCX_PREEMP();
-    RETURN *CTPMethodTable::GetOrCreateNonVirtualSlotForVirtualMethod(pMD);
-#endif
-}
-
-#ifndef HAS_REMOTING_PRECODE
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::DestroyThunk   public
-//
-//  Synopsis:   Destroy the thunk for the non virtual method. 
-//
-// 
-//+----------------------------------------------------------------------------
-void CRemotingServices::DestroyThunk(MethodDesc* pMD)
-{
-    WRAPPER_NO_CONTRACT;
-    
-    // Delegate to a helper routine
-    CTPMethodTable::DestroyThunk(pMD);
-} 
-#endif // HAS_REMOTING_PRECODE
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::GetDispatchInterfaceHelper   public
-//
-//  Synopsis:   Returns helper for dispatching interface call into the remoting system
-//              with exact MethodDesc. Used for remoting of calls on generic interfaces.
-//              The returned helper has MethodDesc calling convention
-//+----------------------------------------------------------------------------
-PCODE CRemotingServices::GetDispatchInterfaceHelper(MethodDesc* pMD)
-{
-    WRAPPER_NO_CONTRACT;
-
-    return GetEEFuncEntryPoint(CRemotingServices__DispatchInterfaceCall);
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::CheckCast   public
-//
-//  Synopsis:   Checks either 
-//              (1) If the object type supports the given interface OR
-//              (2) If the given type is present in the hierarchy of the 
-//              object type
-// 
-//+----------------------------------------------------------------------------
-BOOL CRemotingServices::CheckCast(OBJECTREF orTP, TypeHandle objTy, TypeHandle ty)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(orTP != NULL);
-        PRECONDITION(!objTy.IsNull());
-        PRECONDITION(!ty.IsNull());
-
-        // Object class can never be an interface. We use a separate cached
-        // entry for storing interfaces that the proxy supports.
-        PRECONDITION(!objTy.IsInterface());
-    }
-    CONTRACTL_END;
-    
-    // Early out if someone's trying to cast us to a type desc (such as a byref,
-    // array or function pointer).
-    if (ty.IsTypeDesc())
-        return FALSE;
-
-    BOOL fCastOK = FALSE;    
-
-    // (1) We are trying to cast to an interface 
-    if (ty.IsInterface())
-    {
-        // Do a quick check for interface cast by comparing it against the
-        // cached entry
-        MethodTable *pItfMT = ((TRANSPARENTPROXYREF)orTP)->GetInterfaceMethodTable();
-        if (NULL != pItfMT)
-        {
-            if(pItfMT == ty.GetMethodTable())
-                fCastOK = TRUE;
-            else
-                fCastOK = pItfMT->CanCastToInterface(ty.GetMethodTable());
-        }
-
-        if(!fCastOK)
-            fCastOK = objTy.GetMethodTable()->CanCastToInterface(ty.GetMethodTable());        
-    }
-    // (2) Everything else...
-    else
-    {
-        // Walk up the class hierarchy and find a matching class
-        while (ty != objTy)
-        {
-            if (objTy.IsNull())
-            {
-                // Oh-oh, the cast did not succeed. Maybe we have to refine
-                // the proxy to match the clients view
-                break;
-            }            
-
-            // Continue searching
-            objTy = objTy.GetParent();
-        }
-
-        if(objTy == ty)
-            fCastOK = TRUE;
-    }
-
-    return fCastOK;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::CheckCast   public
-//
-//  Synopsis:   Refine the type hierarchy that the proxy represents to match
-//              the client view. If the client is trying to cast the proxy
-//              to a type not supported by the server object then we 
-//              return NULL
-//
-// 
-//+----------------------------------------------------------------------------
-BOOL CRemotingServices::CheckCast(OBJECTREF orTP, TypeHandle ty)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(orTP != NULL);
-        PRECONDITION(!ty.IsNull());
-    }
-    CONTRACTL_END;
-
-    BOOL fCastOK = FALSE;
-    
-    GCPROTECT_BEGIN(orTP);
-
-    // Make sure the type being cast to has been restored.
-    ty.CheckRestore();
-    
-    MethodTable *pMT = orTP->GetMethodTable();
-
-    // Make sure that we have a transparent proxy
-    _ASSERTE(pMT->IsTransparentProxy());
-
-    pMT = orTP->GetTrueMethodTable();
-
-    // Do a cast check without taking a lock
-    fCastOK = CheckCast(orTP, TypeHandle(pMT), ty);
-
-    if (!fCastOK && !ty.IsTypeDesc())
-    {
-        // We reach here only if any of the types in the current type hierarchy
-        // represented by the proxy does not match the given type.     
-        // Call a helper routine in managed RemotingServices to find out 
-        // whether the server object supports the given type
-        MethodDesc* pTargetMD = MDofCheckCast();
-        fCastOK = CTPMethodTable::CheckCast(pTargetMD, (TRANSPARENTPROXYREF)orTP, ty);
-    }
-
-    if (fCastOK)
-    {
-        // Do the type equivalence tests
-        CRealProxy::UpdateOptFlags(orTP);
-    }
-
-    GCPROTECT_END();
-    
-    LOG((LF_REMOTING, LL_INFO100, "CheckCast returning %s for object 0x%x and class 0x%x \n", (fCastOK ? "TRUE" : "FALSE")));
-
-    return (fCastOK);
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::FieldAccessor   public
-//
-//  Synopsis:   Sets/Gets the value of the field given an instance or a proxy
-// 
-//+----------------------------------------------------------------------------
-void CRemotingServices::FieldAccessor(FieldDesc* pFD, OBJECTREF o, LPVOID pVal, BOOL fIsGetter)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(CheckPointer(pFD));
-        PRECONDITION(o != NULL);
-        PRECONDITION(CheckPointer(pVal, NULL_OK));
-        PRECONDITION(o->IsTransparentProxy() || o->GetMethodTable()->IsMarshaledByRef());
-    }
-    CONTRACTL_END;
-
-    MethodTable *pMT = o->GetMethodTable();
-    TypeHandle fldClass;
-    TypeHandle thRealObjectType;
-
-    GCPROTECT_BEGIN(o);
-    GCPROTECT_BEGININTERIOR(pVal);
-
-    // If the field descriptor type is not exact (i.e. it's a representative
-    // descriptor for a generic field) then we need to be more careful
-    // determining the properties of the field.
-    if (pFD->IsSharedByGenericInstantiations())
-    {
-        // We need to resolve the field type in the context of the actual object
-        // it belongs to. If we've been handed a proxy we have to go grab the
-        // proxied type for this to work.
-        thRealObjectType = o->GetTrueTypeHandle();
-        
-        // Evaluate the field signature in the type context of the parent object.
-        MetaSig sig(pFD, thRealObjectType);
-        sig.NextArg();
-        fldClass = sig.GetLastTypeHandleThrowing();
-    }
-    else
-    {
-        fldClass = pFD->GetFieldTypeHandleThrowing();
-    }
-
-    GCPROTECT_END();
-    GCPROTECT_END();
-
-    CorElementType fieldType = fldClass.GetSignatureCorElementType();
-    UINT cbSize = GetSizeForCorElementType(fieldType);
-    BOOL fIsGCRef = CorTypeInfo::IsObjRef(fieldType);
-    BOOL fIsByValue = fieldType == ELEMENT_TYPE_VALUETYPE;
-
-    if(pMT->IsMarshaledByRef())
-    {
-        GCX_FORBID();
-        
-        _ASSERTE(!o->IsTransparentProxy());
-    
-        // This is a reference to a real object. Get/Set the field value
-        // and return
-        LPVOID pFieldAddress = pFD->GetAddress((LPVOID)OBJECTREFToObject(o));
-        LPVOID pDest = (fIsGetter ? pVal : pFieldAddress);
-        LPVOID pSrc  = (fIsGetter ? pFieldAddress : pVal);
-        if(fIsGCRef && !fIsGetter)
-        {
-            SetObjectReference((OBJECTREF*)pDest, ObjectToOBJECTREF(*(Object **)pSrc), o->GetAppDomain());
-        }
-        else if(fIsByValue) 
-        {
-            CopyValueClass(pDest, pSrc, fldClass.AsMethodTable(), o->GetAppDomain());
-        }
-        else
-        {    
-            CopyDestToSrc(pDest, pSrc, cbSize);
-        }
-    }
-    else
-    {
-        // Call the managed code to start the field access call
-        CallFieldAccessor(pFD, o, pVal, fIsGetter, fIsByValue, fIsGCRef, thRealObjectType, fldClass, fieldType, cbSize);        
-    }
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::CopyDestToSrc   private
-//
-//  Synopsis:   Copies the specified number of bytes from the src to dest
-//
-// 
-//+----------------------------------------------------------------------------
-VOID CRemotingServices::CopyDestToSrc(LPVOID pDest, LPVOID pSrc, UINT cbSize)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pDest));
-        PRECONDITION(CheckPointer(pSrc));
-    }
-    CONTRACTL_END;
-
-    switch (cbSize)
-    {
-        case 1:
-            VolatileStore((INT8*)pDest, *(INT8*)pSrc);
-            break;
-    
-        case 2:
-            VolatileStore((INT16*)pDest, *(INT16*)pSrc);
-            break;
-    
-        case 4:
-            VolatileStore((INT32*)pDest, *(INT32*)pSrc);
-            break;
-    
-        case 8:
-            VolatileStore((INT64*)pDest, *(INT64*)pSrc);
-            break;
-    
-        default:
-            UNREACHABLE();
-            break;
-    }
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::CallFieldAccessor   private
-//
-//  Synopsis:   Sets up the arguments and calls RealProxy::FieldAccessor
-//
-// 
-//+----------------------------------------------------------------------------
-VOID CRemotingServices::CallFieldAccessor(FieldDesc* pFD,
-                                          OBJECTREF o, 
-                                          VOID* pVal, 
-                                          BOOL fIsGetter, 
-                                          BOOL fIsByValue, 
-                                          BOOL fIsGCRef,
-                                          TypeHandle ty,
-                                          TypeHandle fldTy,
-                                          CorElementType fieldType, 
-                                          UINT cbSize)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(CheckPointer(pFD));
-        PRECONDITION(o != NULL);
-        PRECONDITION(CheckPointer(pVal));
-    }
-    CONTRACTL_END;
-    
-    //****************************WARNING******************************
-    // GC Protect all non-primitive variables
-    //*****************************************************************
-    
-    FieldArgs fieldArgs;
-    fieldArgs.obj = NULL;
-    fieldArgs.val = NULL;
-    fieldArgs.typeName = NULL;
-    fieldArgs.fieldName = NULL;    
-
-    GCPROTECT_BEGIN(fieldArgs);
-    GCPROTECT_BEGININTERIOR(pVal);
-
-    fieldArgs.obj = o;
-
-    // protect the field value if it is a gc-ref type
-    if(fIsGCRef)
-        fieldArgs.val = ObjectToOBJECTREF(*(Object **)pVal);
-
-
-    // Set up the arguments
-    
-    // Argument 1: String typeName
-    // Argument 2: String fieldName
-    // Get the type name and field name strings
-    GetTypeAndFieldName(&fieldArgs, pFD, ty);
-    
-    // Argument 3: Object val
-    OBJECTREF val = NULL;
-    if(!fIsGetter)
-    {
-        // If we are setting a field value then we create a variant data 
-        // structure to hold the field value        
-        // Extract the field from the gc protected structure if it is an object
-        // else use the value passed to the function
-        LPVOID pvFieldVal = (fIsGCRef ? (LPVOID)&(fieldArgs.val) : pVal);
-        // <REVISIT_TODO>: This can cause a GC. We need some way to protect the variant
-        // data</REVISIT_TODO>
-        OBJECTREF *lpVal = &val;
-        GCPROTECT_BEGININTERIOR (pvFieldVal);
-        CMessage::GetObjectFromStack(lpVal, &pvFieldVal, fieldType, fldTy, TRUE); 
-        GCPROTECT_END ();
-    }
-        
-    // Get the method descriptor of the call
-    MethodDesc *pMD = (fIsGetter ? MDofFieldGetter() : MDofFieldSetter());
-            
-    // Call the field accessor function 
-    //////////////////////////////// GETTER ///////////////////////////////////
-    if(fIsGetter)
-    {       
-        // Set up the return value
-        OBJECTREF oRet = NULL;
-
-        GCPROTECT_BEGIN (oRet);
-        CRemotingServices__CallFieldGetter(pMD, 
-                             (LPVOID)OBJECTREFToObject(fieldArgs.obj),
-                             (LPVOID)OBJECTREFToObject(fieldArgs.typeName),
-                             (LPVOID)OBJECTREFToObject(fieldArgs.fieldName),
-                             (LPVOID)&(oRet));
-
-        // If we are getting a field value then extract the field value
-        // based on the type of the field    
-        if(fIsGCRef)
-        {
-            // Do a check cast to ensure that the field type and the 
-            // return value are compatible
-            OBJECTREF orRet = oRet;
-            OBJECTREF orSaved = orRet;
-            if(IsTransparentProxy(OBJECTREFToObject(orRet)))
-            {
-                GCPROTECT_BEGIN(orRet);
-
-                if(!CheckCast(orRet, fldTy))
-                    COMPlusThrow(kInvalidCastException, W("Arg_ObjObj"));
-
-                orSaved = orRet;
-
-                GCPROTECT_END();
-            }
-
-            *(OBJECTREF *)pVal = orSaved;
-        }
-        else if (fIsByValue) 
-        {       
-            // Copy from the source to the destination
-            if (oRet != NULL) 
-            {
-                fldTy.GetMethodTable()->UnBoxIntoUnchecked(pVal, oRet);
-            }
-        }
-        else
-        {
-            if (oRet != NULL)
-                CopyDestToSrc(pVal, oRet->UnBox(), cbSize);
-        }    
-        GCPROTECT_END ();
-    }
-    ///////////////////////// SETTER //////////////////////////////////////////
-    else
-    {    
-        CRemotingServices__CallFieldSetter(pMD,
-                             (LPVOID)OBJECTREFToObject(fieldArgs.obj), 
-                             (LPVOID)OBJECTREFToObject(fieldArgs.typeName), 
-                             (LPVOID)OBJECTREFToObject(fieldArgs.fieldName),
-                             (LPVOID)OBJECTREFToObject(val));
-    }
-
-    GCPROTECT_END(); // pVal
-    GCPROTECT_END(); // fieldArgs
-}
-  
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::GetTypeAndFieldName   private
-//
-//  Synopsis:   Get the type name and field name of the 
-//
-// 
-//+----------------------------------------------------------------------------
-VOID CRemotingServices::GetTypeAndFieldName(FieldArgs *pArgs, FieldDesc *pFD, TypeHandle thEnclosingClass)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(CheckPointer(pArgs));
-        PRECONDITION(CheckPointer(pFD));
-    }
-    CONTRACTL_END;
-
-    TypeHandle thDeclaringType = !thEnclosingClass.IsNull() ?
-        pFD->GetExactDeclaringType(thEnclosingClass.AsMethodTable()) : pFD->GetEnclosingMethodTable();
-    _ASSERTE(!thDeclaringType.IsNull());
-
-    // Extract the type name and field name string
-    // <REVISIT_TODO>FUTURE: Put this in the reflection data structure cache TarunA 11/26/00</REVISIT_TODO>
-    StackSString ss;    
-    TypeString::AppendType(ss, thDeclaringType, TypeString::FormatNamespace | TypeString::FormatFullInst);
-    pArgs->typeName = StringObject::NewString(ss);
-
-    pArgs->fieldName = StringObject::NewString(pFD->GetName());
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::MatchField   private
-//
-//  Synopsis:   Find out whether the given field name is the same as the name
-//              of the field descriptor field name.
-//
-// 
-//+----------------------------------------------------------------------------
-BOOL CRemotingServices::MatchField(FieldDesc* pCurField, LPCUTF8 szFieldName)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pCurField));
-        PRECONDITION(CheckPointer(szFieldName));
-    }
-    CONTRACTL_END;
-    
-    // Get the name of the field
-    LPCUTF8 szCurFieldName;
-    if (FAILED(pCurField->GetName_NoThrow(&szCurFieldName)))
-    {
-        return FALSE;
-    }
-    
-    return strcmp(szCurFieldName, szFieldName) == 0;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::Wrap   public
-//
-//  Synopsis:   Wrap a contextful object to create a proxy
-//              Delegates to a helper method to do the actual work
-//
-// 
-//+----------------------------------------------------------------------------
-OBJECTREF CRemotingServices::Wrap(OBJECTREF obj)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-
-    // Basic sanity check
-    VALIDATEOBJECTREF(obj);
-
-    // ******************* WARNING ********************************************
-    // Do not throw any exceptions or provoke GC without setting up a frame.
-    // At present its the callers responsibility to setup a frame that can 
-    // handle exceptions.
-    // ************************************************************************    
-    OBJECTREF orProxy = obj;
-    if(obj != NULL && (obj->GetMethodTable()->IsContextful()))       
-    {
-        if(!IsTransparentProxy(OBJECTREFToObject(obj)))
-        {
-            // See if we can extract the proxy from the object
-            orProxy = GetProxyFromObject(obj);
-            if(orProxy == NULL)
-            {
-                // ask the remoting services to wrap the object
-                orProxy = CRemotingServices::WrapHelper(obj);
-            }
-        }
-    }
-
-    return orProxy;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::WrapHelper   public
-//
-//  Synopsis:   Wrap an object to return a proxy. This function assumes that 
-//              a fcall frame is already setup.
-// 
-//+----------------------------------------------------------------------------
-OBJECTREF CRemotingServices::WrapHelper(OBJECTREF obj)
-{
-    // Basic sanity check
-    VALIDATEOBJECTREF(obj);
-    
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(obj != NULL);
-        PRECONDITION(!IsTransparentProxy(OBJECTREFToObject(obj)));
-        PRECONDITION(obj->GetMethodTable()->IsContextful());
-    }
-    CONTRACTL_END;
-    
-
-    // Default return value indicates an error
-    OBJECTREF newobj = NULL;
-    MethodDesc* pTargetMD = NULL;
-    
-    // Ensure remoting has been started.
-    EnsureRemotingStarted();
-
-    // Get the address of wrap in managed code        
-    pTargetMD = CRemotingServices::MDofWrap();
-
-    // call the managed method to wrap
-    newobj = ObjectToOBJECTREF( (Object *)CTPMethodTable::CallTarget(pTargetMD,
-                                            (LPVOID)OBJECTREFToObject(obj),
-                                            NULL));    
-
-    return newobj;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::GetProxyFromObject   public
-//
-//  Synopsis:   Extract the proxy from the field in the 
-//              ContextBoundObject class
-//              
-// 
-//+----------------------------------------------------------------------------
-OBJECTREF CRemotingServices::GetProxyFromObject(OBJECTREF obj)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_COOPERATIVE;
-        PRECONDITION(obj != NULL);
-    }
-    CONTRACTL_END;
-
-    // Basic sanity check
-    VALIDATEOBJECTREF(obj);
-
-    // We can derive a proxy for contextful types only.
-    _ASSERTE(obj->GetMethodTable()->IsContextful());
-
-    OBJECTREF srvID = (OBJECTREF)(Object*)obj->GetPtrOffset(s_dwMBRIDOffset);
-    OBJECTREF orProxy = NULL;
-    
-    if (srvID != NULL)
-        orProxy = (OBJECTREF)(Object*)srvID->GetPtrOffset(s_dwTPOrObjOffsetInIdentity);
-
-    // This should either be null or a proxy type
-    _ASSERTE((orProxy == NULL) || IsTransparentProxy(OBJECTREFToObject(orProxy)));
-
-    return orProxy;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::IsProxyToRemoteObject   public
-//
-//  Synopsis:   Check if the proxy is to a remote object
-//              (1) TRUE : if object is non local (ie outside this PROCESS) otherwise
-//              (2) FALSE 
-// 
-//+----------------------------------------------------------------------------
-BOOL CRemotingServices::IsProxyToRemoteObject(OBJECTREF obj)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(obj != NULL);
-    }
-    CONTRACTL_END;
-    
-    // Basic sanity check
-    VALIDATEOBJECTREF(obj);
- 
-    // If remoting is not started, for now let us just return FALSE
-    if(!s_fRemotingStarted)
-        return FALSE;
- 
-    if(!obj->IsTransparentProxy())
-        return FALSE;
-    
-    // so it is a transparent proxy
-    AppDomain *pDomain = GetServerDomainForProxy(obj);
-    if(pDomain != NULL)
-        return TRUE;
-
-    return FALSE;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::GetObjectFromProxy   public
-//
-//  Synopsis:   Extract the object given a proxy. 
-//
-// 
-//+----------------------------------------------------------------------------
-OBJECTREF CRemotingServices::GetObjectFromProxy(OBJECTREF obj)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_COOPERATIVE;
-        PRECONDITION(obj != NULL);
-        PRECONDITION(s_fRemotingStarted);
-        PRECONDITION(IsTransparentProxy(OBJECTREFToObject(obj)));
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    // Basic sanity check
-    VALIDATEOBJECTREF(obj);
-
-    OBJECTREF oref = NULL;
-    if (CTPMethodTable__GenericCheckForContextMatch(OBJECTREFToObject(obj)))
-    {
-        OBJECTREF objRef = ObjectToOBJECTREF(GetRealProxy(OBJECTREFToObject(obj)));
-        oref = (OBJECTREF)(Object*)objRef->GetPtrOffset(s_dwServerOffsetInRealProxy);
-        if (oref != NULL)
-            obj = oref; 
-    }
-
-    return obj;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::GetServerIdentityFromProxy   private
-//
-//  Synopsis:   Gets the server identity (if one exists) from a proxy
-//              
-//              
-//              
-// 
-//+----------------------------------------------------------------------------
-OBJECTREF CRemotingServices::GetServerIdentityFromProxy(OBJECTREF obj)
-{    
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(obj != NULL);
-        PRECONDITION(IsTransparentProxy(OBJECTREFToObject(obj)));
-    }
-    CONTRACTL_END;
-
-
-    // Extract the real proxy underlying the transparent proxy
-    OBJECTREF pObj = ObjectToOBJECTREF(GetRealProxy(OBJECTREFToObject(obj)));
-
-    OBJECTREF id = NULL;
-        
-    // Extract the identity object
-    pObj = (OBJECTREF)(Object*)pObj->GetPtrOffset(s_dwIdOffset);
-
-    // Extract the _identity from the real proxy only if it is an instance of 
-    // remoting proxy
-    if((pObj != NULL) && IsInstanceOfServerIdentity(pObj->GetMethodTable()))
-        id = pObj;
-
-    return id;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::GetServerDomainForProxy public
-//
-//  Synopsis:   Returns the AppDomain corresponding to the server
-//              if the proxy and the server are in the same process.
-//              
-// 
-//+----------------------------------------------------------------------------
-AppDomain *CRemotingServices::GetServerDomainForProxy(OBJECTREF proxy)
-{
-    CONTRACT (AppDomain*)
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(proxy != NULL);
-        POSTCONDITION(CheckPointer(RETVAL, NULL_OK));
-    }
-    CONTRACT_END;
-    
-    // call the managed method 
-    Context *pContext = (Context *)GetServerContextForProxy(proxy);
-    if (pContext)
-        RETURN pContext->GetDomain();
-    else 
-        RETURN NULL; 
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::GetServerDomainIdForProxy public
-//
-//  Synopsis:   Returns the AppDomain ID corresponding to the server
-//              if the proxy and the server are in the same process.
-//              Returns 0 if it cannot determine.
-//              
-// 
-//+----------------------------------------------------------------------------
-int CRemotingServices::GetServerDomainIdForProxy(OBJECTREF proxy)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(proxy != NULL);
-        PRECONDITION(IsTransparentProxy(OBJECTREFToObject(proxy)));
-    }
-    CONTRACTL_END;
-
-    // Get the address of GetDomainIdForProxy in managed code
-    MethodDesc* pTargetMD = CRemotingServices::MDofGetServerDomainIdForProxy();
-
-    // This will just read the appDomain ID from the marshaled data
-    // for the proxy. It returns 0 if the proxy is to a server in another
-    // process. It may also return 0 if it cannot determine the server
-    // domain ID (eg. for Well Known Object proxies).
-
-    // call the managed method
-    // <REVISIT_TODO>This cast to Int32 actually causes a potential loss
-    // of data.</REVISIT_TODO>
-    return (int)(INT_PTR)CTPMethodTable::CallTarget(
-                pTargetMD,
-                (LPVOID)OBJECTREFToObject(proxy),
-                NULL);
-}
-
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::GetServerContextForProxy public
-//
-//  Synopsis:   Returns the AppDomain corresponding to the server
-//              if the proxy and the server are in the same process.
-//              
-// 
-//+----------------------------------------------------------------------------
-Context *CRemotingServices::GetServerContextForProxy(OBJECTREF proxy)
-{
-    CONTRACT (Context*)
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(proxy != NULL);
-        PRECONDITION(IsTransparentProxy(OBJECTREFToObject(proxy)));
-        POSTCONDITION(CheckPointer(RETVAL, NULL_OK));
-    }
-    CONTRACT_END;
- 
-    // Get the address of GetAppDomainForProxy in managed code        
-    MethodDesc* pTargetMD = CRemotingServices::MDofGetServerContextForProxy();
-    
-    // This will return the correct VM Context object for the server if 
-    // the proxy is true cross domain proxy to a server in another domain 
-    // in the same process. The managed method will Assert if called on a proxy
-    // which is either half-built or does not have an ObjRef ... which may
-    // happen for eg. if the proxy and the server are in the same appdomain.
-
-    // we return NULL if the server object for the proxy is in another 
-    // process or if the appDomain for the server is invalid or if we cannot
-    // determine the context (eg. well known object proxies).
-
-    // call the managed method 
-    RETURN (Context *)CTPMethodTable::CallTarget(
-                            pTargetMD,
-                            (LPVOID)OBJECTREFToObject(proxy),
-                            NULL);    
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::CreateProxyForDomain   public
-//
-//  Synopsis:   Create a proxy for the app domain object by calling marshal
-//              inside the newly created domain and unmarshaling in the old
-//              domain
-//              
-// 
-//+----------------------------------------------------------------------------
-OBJECTREF CRemotingServices::CreateProxyForDomain(AppDomain* pDomain)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(CheckPointer(pDomain));
-    }
-    CONTRACTL_END;
-
-    // Ensure remoting has been started.
-    EnsureRemotingStarted();
-
-    MethodDesc* pTargetMD = MDOfCreateProxyForDomain();
-
-    // Call the managed method which will marshal and unmarshal the 
-    // appdomain object to create the proxy
-
-    // We pass the ContextID of the default context of the new appDomain
-    // object. This helps the boot-strapping! (i.e. entering the new domain
-    // to marshal itself out).
-
-    Object *proxy = (Object *)CTPMethodTable::CallTarget(
-                                    pTargetMD, 
-                                    (LPVOID)(DWORD_PTR)pDomain->GetId().m_dwId,
-                                    (LPVOID)pDomain->GetDefaultContext());
-    return ObjectToOBJECTREF(proxy);
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::GetClass   public
-//
-//  Synopsis:   Extract the true class of the object whose proxy is given.
-//              
-//              
-// 
-//+----------------------------------------------------------------------------
-REFLECTCLASSBASEREF CRemotingServices::GetClass(OBJECTREF pThis)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM());
-        PRECONDITION(pThis != NULL);
-    }
-    CONTRACTL_END;
-    
-    REFLECTCLASSBASEREF refClass = NULL;
-    MethodTable *pMT = NULL;
-
-    GCPROTECT_BEGIN(pThis);
-
-    // For proxies to objects in the same appdomain, we always know the
-    // correct type
-    if(GetServerIdentityFromProxy(pThis) != NULL)
-    {
-        pMT = pThis->GetTrueMethodTable();
-    }
-    else
-    {   
-        // For everything else either we have refined the proxy to its correct type
-        // or we have to consult the objref to get the true type
-
-        MethodDesc* pTargetMD = CRemotingServices::MDofGetType();
-
-        refClass = (REFLECTCLASSBASEREF)(ObjectToOBJECTREF((Object *)CTPMethodTable::CallTarget(pTargetMD, 
-            (LPVOID)OBJECTREFToObject(pThis), NULL)));
-
-        if(refClass == NULL)
-        {
-            // There was no objref associated with the proxy or it is a proxy
-            // that we do not understand. 
-            // In this case, we return the class that is stored in the proxy
-            pMT = pThis->GetTrueMethodTable();
-        }
-
-        _ASSERTE(refClass != NULL || pMT != NULL);
-
-        // Refine the proxy to the class just retrieved
-        if(refClass != NULL)
-        {
-            CTPMethodTable::RefineProxy((TRANSPARENTPROXYREF)pThis, refClass->GetType());
-        }
-    }    
-
-    if (refClass == NULL)
-    {
-        PREFIX_ASSUME(pMT != NULL);
-        refClass = (REFLECTCLASSBASEREF)pMT->GetManagedClassObject();
-    }
-
-    GCPROTECT_END();
-
-    _ASSERTE(refClass != NULL);
-    return refClass;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRealProxy::SetStubData   public
-//
-//  Synopsis:   Set the stub data in the transparent proxy
-// 
-//+----------------------------------------------------------------------------
-FCIMPL2(VOID, CRealProxy::SetStubData, Object* orRPUNSAFE, Object* orStubDataUNSAFE)
-{
-    CONTRACTL
-    {
-        FCALL_CHECK;
-    }
-    CONTRACTL_END;
-    
-    BOOL fThrow = FALSE;
-    REALPROXYREF orRP = (REALPROXYREF)ObjectToOBJECTREF(orRPUNSAFE);
-    OBJECTREF orStubData = ObjectToOBJECTREF(orStubDataUNSAFE);
-
-    if (orRP != NULL && orStubData != NULL)
-    {
-        TRANSPARENTPROXYREF orTP = orRP->GetTransparentProxy();
-        if (orTP != NULL)
-        {
-            orTP->SetStubData(orStubData);
-        }
-        else
-        {
-            fThrow = TRUE;
-        }
-    }
-    else
-    {
-        fThrow = TRUE;
-    }
-    
-    if(fThrow)
-        FCThrowVoid(kArgumentNullException);
-}
-FCIMPLEND
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRealProxy::GetStubData   public
-//
-//  Synopsis:   Get the stub data in the transparent proxy
-// 
-//+----------------------------------------------------------------------------
-FCIMPL1(Object*, CRealProxy::GetStubData, Object* orRPUNSAFE)
-{
-    CONTRACTL
-    {
-        FCALL_CHECK;
-    }
-    CONTRACTL_END;
-        
-    BOOL fThrow = FALSE;
-    REALPROXYREF orRP = (REALPROXYREF)ObjectToOBJECTREF(orRPUNSAFE);
-    OBJECTREF orRet = NULL;
-
-    if (orRP != NULL)
-    {
-        TRANSPARENTPROXYREF orTP = orRP->GetTransparentProxy();
-        if (orTP != NULL)
-            orRet = orTP->GetStubData();
-        else
-            fThrow = TRUE;
-    }
-    else
-    {
-        fThrow = TRUE;
-    }
-    
-    if(fThrow)
-        FCThrow(kArgumentNullException);
-
-    return OBJECTREFToObject(orRet);
-}
-FCIMPLEND
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRealProxy::GetDefaultStub   public
-//
-//  Synopsis:   Get the default stub implemented by us which matches contexts
-// 
-//+----------------------------------------------------------------------------
-FCIMPL0(LPVOID, CRealProxy::GetDefaultStub)
-{
-    FCALL_CONTRACT;
-
-    return (LPVOID)CRemotingServices__CheckForContextMatch;
-}
-FCIMPLEND
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRealProxy::GetStub   public
-//
-//  Synopsis:   Get the stub pointer in the transparent proxy 
-// 
-//+----------------------------------------------------------------------------
-FCIMPL1(LPVOID, CRealProxy::GetStub, Object* orRPUNSAFE)
-{
-    CONTRACTL
-    {
-        FCALL_CHECK;
-        PRECONDITION(CheckPointer(orRPUNSAFE));
-    }
-    CONTRACTL_END;
-    
-    REALPROXYREF orRP = (REALPROXYREF)ObjectToOBJECTREF(orRPUNSAFE);    
-    TRANSPARENTPROXYREF orTP = orRP->GetTransparentProxy();
-
-    return orTP->GetStub();
-}
-FCIMPLEND
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRealProxy::GetProxiedType   public
-//
-//  Synopsis:   Get the type that is represented by the transparent proxy 
-// 
-//+----------------------------------------------------------------------------
-FCIMPL1(Object*, CRealProxy::GetProxiedType, Object* orRPUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    REFLECTCLASSBASEREF refClass = NULL;
-    REALPROXYREF orRP = (REALPROXYREF)ObjectToOBJECTREF(orRPUNSAFE);
-    HELPER_METHOD_FRAME_BEGIN_RET_1(orRP);
-
-    TRANSPARENTPROXYREF orTP = orRP->GetTransparentProxy();
-
-    refClass = CRemotingServices::GetClass(orTP);
-    _ASSERTE(refClass != NULL);
-
-    HELPER_METHOD_FRAME_END();
-    return OBJECTREFToObject(refClass);
-}
-FCIMPLEND
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CTPMethodTable::Initialize   public
-//
-//  Synopsis:   Initialized data structures needed for managing tranparent
-//              proxies
-// 
-//+----------------------------------------------------------------------------
-VOID CTPMethodTable::Initialize()
-{
-    STANDARD_VM_CONTRACT;
-
-    s_TPMethodTableCrst.Init(CrstTPMethodTable);
-}
-
-//+----------------------------------------------------------------------------
-
-PCODE CTPMethodTable::GetTPStubEntryPoint()
-{
-    LIMITED_METHOD_CONTRACT;
-    return GetEEFuncEntryPoint(TransparentProxyStub);
-}
-
-PCODE CTPMethodTable::GetDelegateStubEntryPoint()
-{
-    LIMITED_METHOD_CONTRACT;
-    return GetEEFuncEntryPoint(TransparentProxyStub_CrossContext);
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CTPMethodTable::EnsureFieldsInitialized    private
-//
-//  Synopsis:   Initialize the static fields of CTPMethodTable class
-//              and the thunk manager classes
-//
-// 
-//+----------------------------------------------------------------------------
-void CTPMethodTable::EnsureFieldsInitialized()
-{
-    CONTRACT_VOID
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        POSTCONDITION(s_fTPTableFieldsInitialized);
-    }
-    CONTRACT_END;
-
-    if (!s_fTPTableFieldsInitialized)
-    {
-        GCX_PREEMP();
-
-        // Load Tranparent proxy class (do this before we enter the critical section)
-        MethodTable* pTPMT = MscorlibBinder::GetClass(CLASS__TRANSPARENT_PROXY);
-        _ASSERTE(pTPMT->IsTransparentProxy());
-
-        CrstHolder ch(&s_TPMethodTableCrst);
-
-        if(!s_fTPTableFieldsInitialized)
-        {
-            // Obtain size of GCInfo stored above the method table
-            CGCDesc *pGCDesc = CGCDesc::GetCGCDescFromMT(pTPMT);
-            BYTE *pGCTop = (BYTE *) pGCDesc->GetLowestSeries();
-            s_dwGCInfoBytes = (DWORD)(((BYTE *) pTPMT) - pGCTop);
-            _ASSERTE((s_dwGCInfoBytes & 3) == 0);
-
-            // Obtain the number of bytes to be copied for creating the TP
-            // method tables containing thunks
-            _ASSERTE(((s_dwGCInfoBytes + sizeof(MethodTable)) & (sizeof(PCODE)-1)) == 0);
-            s_dwMTDataSlots = ((s_dwGCInfoBytes + sizeof(MethodTable)) / sizeof(PCODE));
-            _ASSERTE(sizeof(MethodTable) == MethodTable::GetVtableOffset());
-
-            // We rely on the number of interfaces implemented by the
-            // Transparent proxy being 0, so that InterfaceInvoke hints
-            // fail and trap to InnerFailStub which also fails and
-            // in turn traps to FailStubWorker. In FailStubWorker, we
-            // determine the class being proxied and return correct slot.
-            _ASSERTE(pTPMT->GetNumInterfaces() == 0);
-
-            CVirtualThunkMgr::InitVirtualThunkManager();
-
-            // Create the global thunk table and set the cycle between
-            // the transparent proxy class and the global thunk table
-            CreateTPMethodTable(pTPMT);
-
-#ifdef HAS_REMOTING_PRECODE
-            // Activate the remoting precode helper
-            ActivatePrecodeRemotingThunk();
-#endif // HAS_REMOTING_PRECODE
-
-            // NOTE: This must always be the last statement in this block
-            // to prevent races
-            // Load Tranparent proxy class
-            s_fTPTableFieldsInitialized = TRUE;
-        }
-    }
-    
-    RETURN;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CTPMethodTable::GetRP       public
-//
-//  Synopsis:   Get the real proxy backing the transparent proxy
-//
-//+----------------------------------------------------------------------------
-REALPROXYREF CTPMethodTable::GetRP(OBJECTREF orTP)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_COOPERATIVE;
-        PRECONDITION(orTP != NULL);
-        PRECONDITION(orTP->IsTransparentProxy());
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    return (REALPROXYREF)(((TRANSPARENTPROXYREF)orTP)->GetRealProxy());
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CTPMethodTable::GetMethodTableBeingProxied       public
-//
-//  Synopsis:   Get the real type backing the transparent proxy
-//
-//+----------------------------------------------------------------------------
-MethodTable * CTPMethodTable::GetMethodTableBeingProxied(OBJECTREF orTP)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_COOPERATIVE;
-        SO_TOLERANT;
-        PRECONDITION(orTP != NULL);
-        PRECONDITION(orTP->IsTransparentProxy());
-    }
-    CONTRACTL_END;
-
-    return ((TRANSPARENTPROXYREF)orTP)->GetMethodTableBeingProxied();
-}
-
-#define PAGE_ROUND_UP(cb) (((cb) + g_SystemInfo.dwAllocationGranularity) & ~(g_SystemInfo.dwAllocationGranularity - 1))
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CTPMethodTable::CreateTPMethodTable   private
-//
-//  Synopsis:   (1) Reserves a transparent proxy method table that is large 
-//              enough to support the largest vtable
-//              (2) Commits memory for the GC info of the global thunk table and
-//              sets the cycle between the transparent proxy class and the 
-//              globale thunk table.
-// 
-//+----------------------------------------------------------------------------
-
-void CTPMethodTable::CreateTPMethodTable(MethodTable* pTPMT)
-{
-    CONTRACT_VOID {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        POSTCONDITION(CheckPointer(s_pThunkTable));
-    } CONTRACT_END;
-
-    // The largest possible vtable size 64K
-    DWORD dwMaxSlots = 64*1024;
-
-    // Allocate virtual memory that is big enough to hold a method table
-    // of the maximum possible size
-    DWORD dwReserveSize = 0;
-    DWORD dwMethodTableReserveSize = (DWORD)(s_dwMTDataSlots * sizeof(PCODE));
-    s_dwReservedTPIndirectionSlotSize = MethodTable::GetNumVtableIndirections(dwMaxSlots) * sizeof(PTR_PCODE);
-    dwMethodTableReserveSize += s_dwReservedTPIndirectionSlotSize;
-    
-    dwMethodTableReserveSize += (DWORD)(dwMaxSlots * sizeof(PCODE));
-    dwReserveSize = PAGE_ROUND_UP(dwMethodTableReserveSize);
-
-    void *pAlloc = ::ClrVirtualAlloc(0, dwReserveSize, MEM_RESERVE | MEM_TOP_DOWN, PAGE_EXECUTE_READWRITE);
-    
-    if (pAlloc)
-    {
-        BOOL bFailed = TRUE;
-
-        // Make sure that we have not created the one and only
-        // transparent proxy method table before
-        _ASSERTE(NULL == s_pThunkTable);
-
-        // Commit the required amount of memory
-        DWORD dwCommitSize = 0;
-
-        // MethodTable memory
-        DWORD dwMethodTableCommitSize = (s_dwMTDataSlots) * sizeof(PCODE);
-        if (!ClrSafeInt<DWORD>::addition(0, dwMethodTableCommitSize, dwCommitSize))
-        {
-           COMPlusThrowHR(COR_E_OVERFLOW);
-        }
-
-        if (::ClrVirtualAlloc(pAlloc, dwCommitSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE))
-        {
-            // Copy the fixed portion from the true TP Method Table
-            memcpy(pAlloc,MTToAlloc(pTPMT, s_dwGCInfoBytes), (dwMethodTableCommitSize));
-
-            // Initialize the transparent proxy method table
-            InitThunkTable(0, dwMaxSlots, AllocToMT((BYTE *) pAlloc, s_dwGCInfoBytes));
-
-            // At this point the transparent proxy class points to the
-            // the true TP Method Table and not the transparent 
-            // proxy method table. We do not use the true method table
-            // any more. Instead we use the transparent proxy method table
-            // for allocating transparent proxies. So, we have to make the
-            // transparent proxy class point to the one and only transparent 
-            // proxy method table
-            pTPMT->GetClass()->SetMethodTableForTransparentProxy(s_pThunkTable);
-
-            // Allocate the slots of the Object class method table because
-            // we can reflect on the __Transparent proxy class even though 
-            // we never intend to use remoting.
-            _ASSERTE(NULL != g_pObjectClass);
-            _ASSERTE(0 == GetCommitedTPSlots());
-            if(ExtendCommitedSlots(g_pObjectClass->GetNumMethods()))
-                bFailed = FALSE;
-        }
-        else
-        {
-            ClrVirtualFree(pAlloc, 0, MEM_RELEASE);
-        }
-        
-        if(bFailed)
-            DestroyThunkTable();
-    }
-    else {
-        if (pAlloc != NULL)
-            ::ClrVirtualFree(pAlloc, 0, MEM_RELEASE);
-    }
-
-    // Note that the thunk table is set to null on any failure path
-    // via DestroyThunkTable
-    if (!s_pThunkTable)
-        COMPlusThrowOM();
-
-    RETURN;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CTPMethodTable::ExtendCommitedSlots   private
-//
-//  Synopsis:   Extends the commited slots of transparent proxy method table to
-//              the desired number
-// 
-//+----------------------------------------------------------------------------
-BOOL CTPMethodTable::ExtendCommitedSlots(_In_range_(1,64*1024) DWORD dwSlots)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        INJECT_FAULT(return FALSE);
-        PRECONDITION(s_dwCommitedTPSlots <= dwSlots);
-        PRECONDITION(dwSlots <= s_dwReservedTPSlots);
-        PRECONDITION((CVirtualThunks::GetVirtualThunks() == NULL) || 
-                (s_dwCommitedTPSlots == CVirtualThunks::GetVirtualThunks()->_dwCurrentThunk));
-        
-        // Either we have initialized everything or we are asked to allocate
-        // some slots during initialization
-        PRECONDITION(s_fTPTableFieldsInitialized || (0 == s_dwCommitedTPSlots));
-    }
-    CONTRACTL_END;
-    
-    // Commit memory for TPMethodTable
-    BOOL bAlloc = FALSE;
-    void *pAlloc = MTToAlloc(s_pThunkTable, s_dwGCInfoBytes);
-    ClrSafeInt<DWORD> dwCommitSize;
-    dwCommitSize += s_dwMTDataSlots * sizeof(PCODE);
-    dwCommitSize += MethodTable::GetNumVtableIndirections(dwSlots) * sizeof(PTR_PCODE);
-
-    DWORD dwLastIndirectionSlot = s_pThunkTable->GetIndexOfVtableIndirection(s_pThunkTable->GetNumVirtuals() - 1);
-    DWORD dwSlotsCommitSize = dwSlots * sizeof(PCODE);
-    PCODE *pAllocSlots = (PCODE*)(((BYTE*)s_pThunkTable) + s_dwMTDataSlots * sizeof(PCODE) + s_dwReservedTPIndirectionSlotSize);
-
-    if (dwCommitSize.IsOverflow())
-    {
-       return FALSE; // error condition
-    }
-
-    if (::ClrVirtualAlloc(pAlloc, dwCommitSize.Value(), MEM_COMMIT, PAGE_EXECUTE_READWRITE) && 
-        ::ClrVirtualAlloc(pAllocSlots, dwSlotsCommitSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE))
-    {
-        _ASSERTE(FitsIn<WORD>(dwSlots));
-        s_pThunkTable->SetNumVirtuals((WORD)dwSlots);
-
-        MethodTable::VtableIndirectionSlotIterator it = s_pThunkTable->IterateVtableIndirectionSlotsFrom(dwLastIndirectionSlot);
-        do
-        {
-            it.SetIndirectionSlot(&pAllocSlots[it.GetStartSlot()]);
-        }
-        while (it.Next());
-
-        bAlloc = AllocateThunks(dwSlots, dwCommitSize.Value());
-    }
-
-    return bAlloc;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CTPMethodTable::AllocateThunks   private
-//
-//  Synopsis:   Allocates the desired number of thunks for virtual methods
-// 
-//+----------------------------------------------------------------------------
-BOOL CTPMethodTable::AllocateThunks(DWORD dwSlots, DWORD dwCommitSize)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-    // Check for existing thunks
-    DWORD dwCommitThunks = 0;
-    DWORD dwAllocThunks = dwSlots;
-    MethodTable *pThunkTable = s_pThunkTable;
-    
-    CVirtualThunks* pThunks = CVirtualThunks::GetVirtualThunks();
-    if (pThunks)
-    {
-        // Compute the sizes of memory to be commited and allocated
-        BOOL fCommit;
-        if (dwSlots < pThunks->_dwReservedThunks)
-        {
-            fCommit = TRUE;
-            dwCommitThunks = dwSlots;
-            dwAllocThunks = 0;
-        } 
-        else
-        {
-            fCommit = (pThunks->_dwCurrentThunk != pThunks->_dwReservedThunks);
-            dwCommitThunks = pThunks->_dwReservedThunks;
-            dwAllocThunks = dwSlots - pThunks->_dwReservedThunks;
-        }
-
-        // Commit memory if needed
-        if (fCommit)
-        {
-            DWORD dwCommitSizeTmp = (sizeof(CVirtualThunks) - ConstVirtualThunkSize) +
-                                 ((dwCommitThunks - pThunks->_dwStartThunk) * ConstVirtualThunkSize);
-            
-            if (!::ClrVirtualAlloc(pThunks, dwCommitSizeTmp, MEM_COMMIT, PAGE_EXECUTE_READWRITE))
-                return(NULL);
-
-            // Generate thunks that push slot number and jump to TP stub
-            DWORD dwStartSlot = pThunks->_dwStartThunk;
-            DWORD dwCurrentSlot = pThunks->_dwCurrentThunk;
-            while (dwCurrentSlot < dwCommitThunks)
-            {
-                PCODE pCode = CreateThunkForVirtualMethod(dwCurrentSlot, (BYTE *)&pThunks->ThunkCode[dwCurrentSlot-dwStartSlot]);
-                pThunkTable->SetSlot(dwCurrentSlot, pCode);
-                ++dwCurrentSlot;
-            }
-
-            ClrFlushInstructionCache(&pThunks->ThunkCode[pThunks->_dwCurrentThunk-dwStartSlot], 
-                                     (dwCommitThunks-pThunks->_dwCurrentThunk)*ConstVirtualThunkSize);
-
-            s_dwCommitedTPSlots = dwCommitThunks;
-            pThunks->_dwCurrentThunk = dwCommitThunks;
-        }
-    }
-
-    // <REVISIT_TODO>
-    // Check for the avialability of a TP method table that is no longer being
-    // reused </REVISIT_TODO>
-
-    // Allocate memory if necessary
-    if (dwAllocThunks)
-    {
-        DWORD dwReserveSize = ((sizeof(CVirtualThunks) - ConstVirtualThunkSize) +
-                               ((dwAllocThunks << 1) * ConstVirtualThunkSize) +
-                               g_SystemInfo.dwAllocationGranularity) & ~((size_t) g_SystemInfo.dwAllocationGranularity - 1);
-        
-        void *pAlloc = ::ClrVirtualAlloc(0, dwReserveSize,
-                                      MEM_RESERVE | MEM_TOP_DOWN,
-                                      PAGE_EXECUTE_READWRITE);
-        if (pAlloc)
-        {
-            // Commit the required amount of memory
-            DWORD dwCommitSizeTmp = (sizeof(CVirtualThunks) - ConstVirtualThunkSize) +
-                                 (dwAllocThunks * ConstVirtualThunkSize);
-            
-            if (::ClrVirtualAlloc(pAlloc, dwCommitSizeTmp, MEM_COMMIT, PAGE_EXECUTE_READWRITE))
-            {
-                ((CVirtualThunks *) pAlloc)->_pNext = pThunks;
-                pThunks = CVirtualThunks::SetVirtualThunks((CVirtualThunks *) pAlloc);
-                pThunks->_dwReservedThunks = (dwReserveSize -
-                                             (sizeof(CVirtualThunks) - ConstVirtualThunkSize)) /
-                                                 ConstVirtualThunkSize;
-                pThunks->_dwStartThunk = dwCommitThunks;
-                pThunks->_dwCurrentThunk = dwCommitThunks;
-
-                // Generate thunks that push slot number and jump to TP stub
-                DWORD dwStartSlot = pThunks->_dwStartThunk;
-                DWORD dwCurrentSlot = pThunks->_dwCurrentThunk;
-                while (dwCurrentSlot < dwSlots)
-                {
-                    PCODE pCode = CreateThunkForVirtualMethod(dwCurrentSlot, (BYTE *)&pThunks->ThunkCode[dwCurrentSlot-dwStartSlot]);
-                    pThunkTable->SetSlot(dwCurrentSlot, pCode);
-                    ++dwCurrentSlot;
-                }
-
-                ClrFlushInstructionCache(&pThunks->ThunkCode[pThunks->_dwCurrentThunk-dwStartSlot], 
-                                         (dwSlots-pThunks->_dwCurrentThunk)*ConstVirtualThunkSize);
-
-                s_dwCommitedTPSlots = dwSlots;
-                pThunks->_dwCurrentThunk = dwSlots;
-            }
-            else
-            {
-                ::ClrVirtualFree(pAlloc, 0, MEM_RELEASE);
-                return FALSE;
-            }
-        }
-        else
-        {
-            return FALSE;
-        }
-    }
-
-    return TRUE;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CTPMethodTable::CreateTPOfClassForRP   private
-//
-//  Synopsis:   Creates a transparent proxy that behaves as an object of the
-//              supplied class
-// 
-//+----------------------------------------------------------------------------
-void CTPMethodTable::CreateTPOfClassForRP(TypeHandle ty, REALPROXYREF *pRP, TRANSPARENTPROXYREF *pTP)
-{
-    CONTRACT_VOID
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM());
-        PRECONDITION(!ty.IsNull());
-        PRECONDITION(pRP != NULL);
-        PRECONDITION(*pRP != NULL);
-        PRECONDITION(pTP != NULL);
-        POSTCONDITION(*pTP != NULL);
-    }
-    CONTRACT_END;
-
-    // Ensure remoting is started.
-    EnsureFieldsInitialized();
-
-    MethodTable * pMT = ty.GetMethodTable();
-
-    // Get the size of the VTable for the class to proxy
-    DWORD dwSlots = pMT->GetNumVirtuals();
-
-    if (dwSlots == 0)
-        dwSlots = 1;
-
-    // The global thunk table must have been initialized
-    _ASSERTE(s_pThunkTable != NULL);
-
-    // Check for the need to extend existing TP method table
-    if (dwSlots > GetCommitedTPSlots())
-    {
-        CrstHolder ch(&s_TPMethodTableCrst);
-
-        if (dwSlots > GetCommitedTPSlots())
-        {
-            if (!ExtendCommitedSlots(dwSlots))
-                COMPlusThrowOM();
-        }
-    }
-
-    // Create a TP Object
-    IfNullThrow(*pTP = (TRANSPARENTPROXYREF) AllocateObject(GetMethodTable()));
-
-    // Create the cycle between TP and RP
-    (*pRP)->SetTransparentProxy(*pTP);
-
-    // Make the TP behave as an object of supplied class
-    (*pTP)->SetRealProxy(*pRP);
-
-    // If we are creating a proxy for an interface then the class
-    // is the object class else it is the class supplied
-    if (pMT->IsInterface())
-    {
-        _ASSERTE(NULL != g_pObjectClass);
-
-        (*pTP)->SetMethodTableBeingProxied(CRemotingServices::GetMarshalByRefClass());
-
-        // Set the cached interface method table to the given interface
-        // method table
-        (*pTP)->SetInterfaceMethodTable(pMT);
-    }
-    else
-    {
-        (*pTP)->SetMethodTableBeingProxied(pMT);
-    }
-
-    RETURN;
-}
-
-Signature InitMessageData(messageData *msgData, 
-                          FramedMethodFrame *pFrame, 
-                          Module **ppModule, 
-                          SigTypeContext *pTypeContext)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(CheckPointer(msgData));
-        PRECONDITION(CheckPointer(pFrame));
-        PRECONDITION(CheckPointer(ppModule));
-        PRECONDITION(CheckPointer(pTypeContext));
-    }
-    CONTRACTL_END;
-    
-    msgData->pFrame = pFrame;
-    msgData->iFlags = 0;
-
-    MethodDesc *pMD = pFrame->GetFunction();
-    _ASSERTE(!pMD->ContainsGenericVariables());
-    _ASSERTE(pMD->IsRuntimeMethodHandle());
-
-    TypeHandle thGoverningType;
-    BOOL fIsDelegate = pMD->GetMethodTable()->IsDelegate();
-
-    // We want to calculate and store a governing type for the method since
-    // sometimes the parent method table might be representative. We get the
-    // exact type context from the this reference we're calling on (adjusting
-    // for the fact it's a TP).
-
-    // But cope with the common cases first for speed:
-    // * If the method is not on a generic type and this is not the async
-    //   delegate case (which requires us to unwrap the delegate and have a
-    //   look) then we know the method desc's parent method table will be exact.
-    // * We require method descs to be exact for the interface case as well (since
-    //   the target object doesn't help us resolve the interface type at all).
-    // * COM interop can use this code path, but that doesn't support generics so
-    //   we can use the quick logic for that too.
-    if ((!pMD->HasClassInstantiation() && !fIsDelegate) ||
-        pMD->IsInterface() ||
-        pMD->IsComPlusCall())
-    {
-        thGoverningType = TypeHandle(pMD->GetMethodTable());
-    }
-    else
-    {
-        MethodDesc *pTargetMD;
-        MethodTable *pTargetMT;
-        if (fIsDelegate)
-        {
-            // Async delegates are also handled differently in that the method and the
-            // this are delegate wrappers round the real method and target.
-            pTargetMD = COMDelegate::GetMethodDesc(pFrame->GetThis());
-
-            // Delegates on static methods don't have a useful target instance.
-            // But in that case the target method is guaranteed to have exact
-            // type information.
-            if (pTargetMD->IsStatic())
-                pTargetMT = pTargetMD->GetMethodTable();
-            else
-            {
-                OBJECTREF refDelegateTarget = COMDelegate::GetTargetObject(pFrame->GetThis());
-                pTargetMT = refDelegateTarget->GetTrueMethodTable();
-            }
-        }
-        else
-        {
-            pTargetMD = pMD;
-            pTargetMT = CTPMethodTable::GetMethodTableBeingProxied(pFrame->GetThis());
-        }
-
-        // One last check to see if we can optimize the delegate case now we've
-        // unwrapped it.
-        if (fIsDelegate && !pTargetMD->HasClassInstantiation() && !pTargetMT->IsDelegate())
-        {
-            thGoverningType = TypeHandle(pTargetMD->GetMethodTable());
-        }
-        else
-        {
-            // Not quite done yet, we need to get the type that declares the method,
-            // which may be a superclass of the type we're calling on.
-            MethodTable *pDeclaringMT = pTargetMD->GetMethodTable();
-            thGoverningType = ClassLoader::LoadGenericInstantiationThrowing(pDeclaringMT->GetModule(),
-                                                                            pDeclaringMT->GetCl(),
-                                                                            pTargetMD->GetExactClassInstantiation(TypeHandle(pTargetMT)));
-        }
-    }
-
-    msgData->thGoverningType = thGoverningType;
-
-    if (fIsDelegate)
-    {
-        DelegateEEClass* delegateCls = (DelegateEEClass*) pMD->GetMethodTable()->GetClass();
-
-        _ASSERTE(pFrame->GetThis()->GetMethodTable()->IsDelegate());
-
-        msgData->pDelegateMD = pMD;
-        msgData->pMethodDesc = COMDelegate::GetMethodDesc(pFrame->GetThis());
-        
-        _ASSERTE(msgData->pMethodDesc != NULL);
-        _ASSERTE(!msgData->pMethodDesc->ContainsGenericVariables());
-        _ASSERTE(msgData->pMethodDesc->IsRuntimeMethodHandle());
-
-        if (pMD == delegateCls->m_pBeginInvokeMethod)
-        {
-            msgData->iFlags |= MSGFLG_BEGININVOKE;
-        }
-        else
-        {
-            _ASSERTE(pMD == delegateCls->m_pEndInvokeMethod);
-            msgData->iFlags |= MSGFLG_ENDINVOKE;
-        }
-    }
-    else
-    {
-        msgData->pDelegateMD = NULL;
-        msgData->pMethodDesc = pMD;
-        _ASSERTE(msgData->pMethodDesc->IsRuntimeMethodHandle());
-    }
-
-    if (msgData->pMethodDesc->IsOneWay())
-    {
-        msgData->iFlags |= MSGFLG_ONEWAY;
-    }
-
-    if (msgData->pMethodDesc->IsCtor())
-    {
-        msgData->iFlags |= MSGFLG_CTOR;
-    }
-
-    Signature signature;
-    Module *pModule;
-
-    if (msgData->pDelegateMD)
-    {
-        signature = msgData->pDelegateMD->GetSignature();
-        pModule = msgData->pDelegateMD->GetModule();
-
-        // If the delegate is generic, pDelegateMD may not represent the exact instantiation so we recover it from 'this'.
-        SigTypeContext::InitTypeContext(pFrame->GetThis()->GetMethodTable()->GetInstantiation(), Instantiation(), pTypeContext);
-    }
-    else if (msgData->pMethodDesc->IsVarArg()) 
-    {
-        VASigCookie *pVACookie = pFrame->GetVASigCookie();
-        signature = pVACookie->signature;
-        pModule = pVACookie->pModule;
-        SigTypeContext::InitTypeContext(pTypeContext);
-
-    }
-    else 
-    {
-        signature = msgData->pMethodDesc->GetSignature();
-        pModule = msgData->pMethodDesc->GetModule();
-        SigTypeContext::InitTypeContext(msgData->pMethodDesc, thGoverningType, pTypeContext);
-    }
-
-    *ppModule = pModule;
-    return signature;
-}
-
-VOID CRealProxy::UpdateOptFlags(OBJECTREF refTP)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END
-        
-    DWORD hierarchyDepth = 0;
-    REALPROXYREF refRP = CTPMethodTable::GetRP(refTP);
-   
-    OBJECTHANDLE hServerIdentity = (OBJECTHANDLE)refRP->GetPtrOffset(CRemotingServices::GetOffsetOfSrvIdentityInRP());
-    if (hServerIdentity == NULL)
-        return;
-
-    // Check if the proxy has already been marked as not equivalent.
-    // In which case, it can never get marked as anything else
-    RealProxyObject *rpTemp = (RealProxyObject *)OBJECTREFToObject(refRP);
-    
-    DWORD domainID = rpTemp->GetDomainID();
-    AppDomainFromIDHolder ad((ADID)domainID, TRUE);
-    if (domainID == 0 || ad.IsUnloaded()) //we do not use ptr
-        return;  // The appdomain the server belongs to, has been unloaded
-    ad.Release();
-    DWORD optFlag = rpTemp->GetOptFlags();
-    if ((optFlag & OPTIMIZATION_FLAG_INITTED) &&
-        !(optFlag & OPTIMIZATION_FLAG_PROXY_EQUIVALENT))
-        return;
-    
-    OBJECTREF refSrvIdentity = ObjectFromHandle(hServerIdentity);
-    // Is this a disconnected proxy ?
-    if (refSrvIdentity == NULL)
-        return;
-    
-    OBJECTREF refSrvObject = ObjectToOBJECTREF((Object *)refSrvIdentity->GetPtrOffset(CRemotingServices::GetOffsetOfTPOrObjInIdentity()));
-
-    MethodTable *pCliMT = CTPMethodTable::GetMethodTableBeingProxied(refTP);
-
-    BOOL bProxyQualifies = FALSE;
-    BOOL bCastToSharedType = FALSE;
-
-    // Check if modules are physically the same
-
-    // Check the inheritance hierarchy of the server object, to find the type
-    // that corresponds to the type the proxy is being cast to
-    // @TODO - If being cast to an interface, currently the proxy doesnt get marked equivalent
-    // @TODO - Need to check equivalency of the interface being cast to, and then reuse interface slot # on other side
-    LPCUTF8 szCliTypeName, szCliNameSpace;
-    szCliTypeName = pCliMT->GetFullyQualifiedNameInfo(&szCliNameSpace);
-    PREFIX_ASSUME(szCliTypeName != NULL);
-
-    MethodTable *pSrvHierarchy = refSrvObject->GetMethodTable();
-
-    GCPROTECT_BEGIN(refRP);
-    while (pSrvHierarchy)
-    {
-        LPCUTF8 szSrvTypeName, szSrvNameSpace;
-        szSrvTypeName = pSrvHierarchy->GetFullyQualifiedNameInfo(&szSrvNameSpace);
-        PREFIX_ASSUME(szSrvNameSpace != NULL);
-
-        if (!strcmp(szCliTypeName, szSrvTypeName) && !strcmp(szCliNameSpace, szSrvNameSpace))
-        {
-            // Check if the types are shared. If they are, no further check neccesary
-            if (pSrvHierarchy == pCliMT)
-            {
-                bProxyQualifies = TRUE;
-                bCastToSharedType = TRUE;
-            }
-            else
-            {
-                bProxyQualifies = CRealProxy::ProxyTypeIdentityCheck(pCliMT, pSrvHierarchy);
-            }
-            break;
-        }
-
-        pSrvHierarchy = pSrvHierarchy->GetParentMethodTable();
-        hierarchyDepth++;
-    }
-    GCPROTECT_END();
-
-    optFlag = 0;
-    if (bProxyQualifies && hierarchyDepth < OPTIMIZATION_FLAG_DEPTH_MASK)
-    {
-        optFlag = OPTIMIZATION_FLAG_INITTED | OPTIMIZATION_FLAG_PROXY_EQUIVALENT;
-        if (bCastToSharedType)
-            optFlag |= OPTIMIZATION_FLAG_PROXY_SHARED_TYPE;
-        optFlag |= (hierarchyDepth & OPTIMIZATION_FLAG_DEPTH_MASK);
-    }
-    else
-        optFlag = OPTIMIZATION_FLAG_INITTED;
-
-    RealProxyObject *rpUNSAFE = (RealProxyObject *)OBJECTREFToObject(refRP);
-    rpUNSAFE->SetOptFlags(optFlag);
-}
-
-BOOL CRealProxy::ProxyTypeIdentityCheck(MethodTable *pCliHierarchy, MethodTable *pSrvHierarchy)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        THROWS;
-    }
-    CONTRACTL_END
-    // We have found the server side type that corresponds to the most derived type
-    // on client side, that the proxy is cast to
-    // Now do identity check on the server type hierarchy to see if there is an exact match
-
-    BOOL bProxyQualifies = FALSE;
-    do
-    {
-        LPCUTF8 szCliTypeName, szCliNameSpace;
-        LPCUTF8 szSrvTypeName, szSrvNameSpace;
-        szCliTypeName = pCliHierarchy->GetFullyQualifiedNameInfo(&szCliNameSpace);
-        szSrvTypeName = pSrvHierarchy->GetFullyQualifiedNameInfo(&szSrvNameSpace);
-        PREFIX_ASSUME(szCliTypeName != NULL);
-        PREFIX_ASSUME(szSrvNameSpace != NULL);
-    
-        // If type names are different, there is no match
-        if (strcmp(szCliTypeName, szSrvTypeName) ||
-            strcmp(szCliNameSpace, szSrvNameSpace))
-        {
-            bProxyQualifies = FALSE;
-            return bProxyQualifies;
-        }
-
-        PEAssembly *pClientPE = pCliHierarchy->GetAssembly()->GetManifestFile();
-        PEAssembly *pServerPE = pSrvHierarchy->GetAssembly()->GetManifestFile();
-        // If the PE files are different, there is no match
-        if (!pClientPE->Equals(pServerPE))
-        {
-            bProxyQualifies = FALSE;
-            return bProxyQualifies;
-        }
-
-        // If the number of interfaces implemented are different, there is no match
-        if (pSrvHierarchy->GetNumInterfaces() != pCliHierarchy->GetNumInterfaces())
-        {
-            bProxyQualifies = FALSE;
-            return bProxyQualifies;
-        }
-
-        MethodTable::InterfaceMapIterator srvItfIt = pSrvHierarchy->IterateInterfaceMap();
-        MethodTable::InterfaceMapIterator cliItfIt = pCliHierarchy->IterateInterfaceMap();
-        while (srvItfIt.Next())
-        {
-            BOOL succeeded;
-            succeeded = cliItfIt.Next();
-            CONSISTENCY_CHECK(succeeded);
-            if (!ProxyTypeIdentityCheck(srvItfIt.GetInterface(), cliItfIt.GetInterface()))
-            {
-                bProxyQualifies = FALSE;
-                return bProxyQualifies;
-            }
-        }
-        
-        pSrvHierarchy = pSrvHierarchy->GetParentMethodTable();
-        pCliHierarchy = pCliHierarchy->GetParentMethodTable();
-    }
-    while (pSrvHierarchy && pCliHierarchy);
-
-    if (pSrvHierarchy || pCliHierarchy)
-    {
-        bProxyQualifies = FALSE;
-        return bProxyQualifies;
-    }
-    
-    bProxyQualifies = TRUE;
-    return bProxyQualifies;
-
-}
-
-ProfilerRemotingClientCallbackHolder::ProfilerRemotingClientCallbackHolder()
-{
-#ifdef PROFILING_SUPPORTED
-    // If profiling is active, notify it that remoting stuff is kicking in
-    BEGIN_PIN_PROFILER(CORProfilerTrackRemoting());
-    GCX_PREEMP();
-    g_profControlBlock.pProfInterface->RemotingClientInvocationStarted();
-    END_PIN_PROFILER();
-#endif // PROFILING_SUPPORTED
-}
-
-ProfilerRemotingClientCallbackHolder::~ProfilerRemotingClientCallbackHolder()
-{
-#ifdef PROFILING_SUPPORTED
-    // If profiling is active, tell profiler we've made the call, received the
-    // return value, done any processing necessary, and now remoting is done.
-    BEGIN_PIN_PROFILER(CORProfilerTrackRemoting());
-    GCX_PREEMP();
-    g_profControlBlock.pProfInterface->RemotingClientInvocationFinished();
-    END_PIN_PROFILER();
-#endif // PROFILING_SUPPORTED
-}
-
-enum
-{
-    CALLTYPE_INVALIDCALL        = 0x0,          // Important:: sync this with RealProxy.cs
-    CALLTYPE_METHODCALL         = 0x1,          // Important:: sync this with RealProxy.cs
-    CALLTYPE_CONSTRUCTORCALL    = 0x2           // Important:: sync this with RealProxy.cs
-};
-
-extern "C" void STDCALL TransparentProxyStubPatch();
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     TransparentProxyStubWorker
-//
-//  Synopsis:   This function gets control in two situations
-//              (1) When a call is made on the transparent proxy it delegates to              
-//              PrivateInvoke method on the real proxy
-//              (2) When a call is made on the constructor it again delegates to the 
-//              PrivateInvoke method on the real proxy.
-//              
-// 
-//+----------------------------------------------------------------------------
-extern "C" UINT32 STDCALL TransparentProxyStubWorker(TransitionBlock * pTransitionBlock, TADDR pMethodDescOrSlot)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        ENTRY_POINT;
-        PRECONDITION(CheckPointer(pTransitionBlock));
-    }
-    CONTRACTL_END;
-
-    UINT fpRetSize = 0;
-
-    FrameWithCookie<TPMethodFrame> frame(pTransitionBlock);
-    TPMethodFrame * pFrame = &frame;
-
-    //we need to zero out the return value buffer because we will report it during GC
-#ifdef ENREGISTERED_RETURNTYPE_MAXSIZE
-    ZeroMemory (pFrame->GetReturnValuePtr(), ENREGISTERED_RETURNTYPE_MAXSIZE);
-#else
-    *(ARG_SLOT *)pFrame->GetReturnValuePtr() = 0;
-#endif
-
-    // For virtual calls the slot number is pushed but for 
-    // non virtual calls/interface invoke the method descriptor is already 
-    // pushed
-    MethodDesc * pMD;
-    if ((pMethodDescOrSlot >> 16) == 0)
-    {
-        // The frame is not completly setup at this point.
-        // Do not throw exceptions or provoke GC
-        MethodTable* pMT = CTPMethodTable::GetMethodTableBeingProxied(pFrame->GetThis());
-        _ASSERTE(pMT);
-        
-        // Replace the slot number with the method descriptor on the stack
-        pMD = pMT->GetMethodDescForSlot((WORD)pMethodDescOrSlot);
-    }
-    else
-    {
-        pMD = dac_cast<PTR_MethodDesc>(pMethodDescOrSlot);
-    }
-    pFrame->SetFunction(pMD);
-
-    pFrame->Push();
-
-    // Give debugger opportunity to stop here now that we know the MethodDesc *
-    TransparentProxyStubPatch();
-
-    INSTALL_UNWIND_AND_CONTINUE_HANDLER;
-
-    if (g_pConfig->UseNewCrossDomainRemoting())
-    {
-        BOOL bOptSuccess = FALSE;
-        CrossDomainChannel cdc;
-        bOptSuccess = cdc.CheckCrossDomainCall(pFrame); 
-        if (bOptSuccess)
-        {
-            fpRetSize = cdc.GetFPReturnSize();
-            goto Done;
-        }
-    }
-
-    {
-        messageData msgData;
-        Module *pModule = NULL;
-        SigTypeContext inst;
-        Signature signature = InitMessageData(&msgData, pFrame, &pModule, &inst);
-
-        _ASSERTE(!signature.IsEmpty() && pModule);
-
-        // Allocate metasig on the stack
-        MetaSig mSig(signature, pModule, &inst);
-        msgData.pSig = &mSig; 
-
-        MethodDesc *pMD = pFrame->GetFunction();    
-        if (pMD->GetMethodTable()->IsDelegate())
-        {
-            // check that there is only one target
-            if (COMDelegate::IsTrueMulticastDelegate(pFrame->GetThis()))
-            {
-                COMPlusThrow(kArgumentException, W("Remoting_Delegate_TooManyTargets"));
-            }
-        }
-
-        {
-            ProfilerRemotingClientCallbackHolder profilerHolder;
-
-            OBJECTREF pThisPointer = NULL;
-
-            if (pMD->GetMethodTable()->IsDelegate())
-            {
-                // this is an async call
-                _ASSERTE(pFrame->GetThis()->GetMethodTable()->IsDelegate());
-
-                pThisPointer = COMDelegate::GetTargetObject(pFrame->GetThis());
-            }
-            else
-            {
-                pThisPointer = pFrame->GetThis();
-            }
-
-            OBJECTREF firstParameter;
-            MethodDesc* pTargetMD = NULL;
-            size_t callType = CALLTYPE_INVALIDCALL;
-            
-            // We are invoking either the constructor or a method on the object
-            if(pMD->IsCtor())
-            {
-                // Get the address of PrivateInvoke in managed code
-                pTargetMD = CRemotingServices::MDofPrivateInvoke();
-                _ASSERTE(pThisPointer->IsTransparentProxy());
-                
-                firstParameter = CTPMethodTable::GetRP(pThisPointer);
-
-                // Set a field to indicate that it is a constructor call
-                callType = CALLTYPE_CONSTRUCTORCALL;
-            }
-            else
-            {
-                // Set a field to indicate that it is a method call
-                callType = CALLTYPE_METHODCALL;
-
-                if (pThisPointer->IsTransparentProxy())
-                {
-                    // Extract the real proxy underlying the transparent proxy
-                    firstParameter = CTPMethodTable::GetRP(pThisPointer);
-
-                    // Get the address of PrivateInvoke in managed code
-                    pTargetMD = CRemotingServices::MDofPrivateInvoke();
-                    _ASSERTE(pTargetMD);
-                }
-                else 
-                {
-                    // must be async if this is not a TP 
-                    _ASSERTE(pMD->GetMethodTable()->IsDelegate());
-                    firstParameter = NULL;
-                    
-                    // Get the address of PrivateInvoke in managed code
-                    pTargetMD = CRemotingServices::MDofInvokeStatic();
-                }
-
-                // Go ahead and call PrivateInvoke on Real proxy. There is no need to 
-                // catch exceptions thrown by it
-                // See RealProxy.cs
-            }
-
-            _ASSERTE(pTargetMD);
-
-            // Call the appropriate target
-            CTPMethodTable::CallTarget(pTargetMD, (LPVOID)OBJECTREFToObject(firstParameter), (LPVOID)&msgData, (LPVOID)callType);
-
-            // Check for the need to trip thread
-            if (GetThread()->CatchAtSafePointOpportunistic())
-            {
-                // There is no need to GC protect the return object as
-                // TPFrame is GC protecting it
-                CommonTripThread();
-            }
-        }  // ProfilerClientCallbackHolder
-
-        {
-            mSig.Reset();
-
-            ArgIterator argit(&mSig);
-
-#ifdef _TARGET_X86_
-            // Set the number of bytes to pop for x86
-            pFrame->SetCbStackPop(argit.CbStackPop());
-#endif // _TARGET_X86_
-        
-            fpRetSize = argit.GetFPReturnSize();
-        }
-    }
-
-Done: ;
-
-    pFrame->Pop();
-
-    UNINSTALL_UNWIND_AND_CONTINUE_HANDLER;
-
-    return fpRetSize;
-}
-
-
-// Helper due to inability to combine SEH with anything interesting.
-BOOL CTPMethodTable::CheckCastHelper(MethodDesc* pTargetMD, LPVOID pFirst, LPVOID pSecond)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(CheckPointer(pTargetMD));
-        PRECONDITION(CheckPointer(pFirst, NULL_OK));
-        PRECONDITION(CheckPointer(pSecond, NULL_OK));
-    }
-    CONTRACTL_END;
-
-    // Actual return type is a managed 'bool', so only look at a CLR_BOOL-sized
-    // result.  The high bits are undefined on AMD64.  (Note that a narrowing
-    // cast to CLR_BOOL will not work since it is the same as checking the
-    // size_t result != 0.)
-    LPVOID ret = CallTarget(pTargetMD, pFirst, pSecond);
-    return *(CLR_BOOL*)StackElemEndianessFixup(&ret, sizeof(CLR_BOOL));
-}
-
-
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CTPMethodTable::CheckCast   private
-//
-//  Synopsis:   Call the managed checkcast method to determine whether the 
-//              server type can be cast to the given type
-//              
-//              
-// 
-//+----------------------------------------------------------------------------
-BOOL CTPMethodTable::CheckCast(MethodDesc* pTargetMD, TRANSPARENTPROXYREF orTP, TypeHandle ty)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(CheckPointer(pTargetMD));
-        PRECONDITION(orTP != NULL);
-        PRECONDITION(!ty.IsNull());
-    }
-    CONTRACTL_END;
-    
-    REFLECTCLASSBASEREF reflectType = NULL;
-    LPVOID pvType = NULL;    
-    BOOL fCastOK = FALSE;
-    
-    typedef struct _GCStruct
-    {
-        TRANSPARENTPROXYREF orTP;
-        REALPROXYREF orRP;
-    } GCStruct;
-
-    GCStruct gcValues;
-    gcValues.orTP = orTP;
-    gcValues.orRP = GetRP(orTP);
-
-    GCPROTECT_BEGIN (gcValues);
-
-    reflectType = (REFLECTCLASSBASEREF) ty.GetMethodTable()->GetManagedClassObject();
-    *(REFLECTCLASSBASEREF *)&pvType = reflectType;
-
-    fCastOK = CheckCastHelper(pTargetMD, 
-                              (LPVOID)OBJECTREFToObject(gcValues.orRP),
-                              pvType);    
-
-    if (fCastOK)
-    {
-        _ASSERTE(s_fTPTableFieldsInitialized);
-
-        // The cast succeeded. Replace the current type in the proxy
-        // with the given type. 
-
-        CrstHolder ch(&s_TPMethodTableCrst);
-        
-        if (ty.IsInterface())
-        {
-            // We replace the cached interface method table with the interface
-            // method table that we are trying to cast to. This will ensure that
-            // casts to this interface, which are likely to happen, will succeed.
-            gcValues.orTP->SetInterfaceMethodTable(ty.GetMethodTable());
-        }
-        else
-        {
-            MethodTable *pCurrent = gcValues.orTP->GetMethodTableBeingProxied();
-
-            BOOL fDerivedClass = FALSE;
-            // Check whether this class derives from the current class
-            fDerivedClass = CRemotingServices::CheckCast(gcValues.orTP, ty,
-                                                         TypeHandle(pCurrent));
-            // We replace the current method table only if we cast to a more 
-            // derived class
-            if (fDerivedClass)
-            {
-                // Set the method table in the proxy to the given method table
-                RefineProxy(gcValues.orTP, ty);
-            }
-        }
-    }
-
-    GCPROTECT_END();
-    return fCastOK;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CTPMethodTable::RefineProxy   public
-//
-//  Synopsis:   Set the method table in the proxy to the given class' method table.
-//              Additionally, expand the TP method table to the required number of slots.
-//              
-// 
-//+----------------------------------------------------------------------------
-void CTPMethodTable::RefineProxy(TRANSPARENTPROXYREF orTP, TypeHandle ty)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM());
-        PRECONDITION(orTP != NULL);
-        PRECONDITION(!ty.IsNull());
-    }
-    CONTRACTL_END;
-    
-    // Do the expansion only if necessary
-    MethodTable *pMT = ty.GetMethodTable();
-    
-    if (pMT != orTP->GetMethodTableBeingProxied())
-    {
-        orTP->SetMethodTableBeingProxied(pMT);
-
-        // Extend the vtable if necessary
-        DWORD dwSlots = pMT->GetNumVirtuals();
-
-        if (dwSlots == 0)
-            dwSlots = 1;
-    
-        if((dwSlots > GetCommitedTPSlots()) && !ExtendCommitedSlots(dwSlots))
-        {
-            // We failed to extend the committed slots. Out of memory.
-            COMPlusThrowOM();
-        }
-
-    }
-}
-
-#ifndef HAS_REMOTING_PRECODE
-//+----------------------------------------------------------------------------
-//
-//  Method:     CTPMethodTable::GetOrCreateNonVirtualSlotForVirtualMethod private
-//
-//  Synopsis:   Get a slot for a non-virtual call to a virtual method.
-//
-//+----------------------------------------------------------------------------
-PTR_PCODE CTPMethodTable::GetOrCreateNonVirtualSlotForVirtualMethod(MethodDesc* pMD)
-{
-    CONTRACT (PTR_PCODE)
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pMD));
-        PRECONDITION(pMD->IsRemotingInterceptedViaVirtualDispatch());
-        POSTCONDITION(CheckPointer(RETVAL));
-    }
-    CONTRACT_END;
-
-    // Ensure the TP MethodTable's fields have been initialized.
-    EnsureFieldsInitialized();
-
-    PTR_PCODE pSlot;
-
-    {
-        // Create the thunk in a thread safe manner
-        CrstHolder ch(&s_TPMethodTableCrst);
-
-        // NOTE: CNonVirtualThunk::SetNonVirtualThunks() depends on the lock being initialized
-        CNonVirtualThunk::InitializeListLock();
-
-        // Create hash table if we do not have one yet
-        if (s_pThunkHashTable == NULL)
-        {
-            NewHolder <EEThunkHashTable> pTempHash(new EEThunkHashTable());
-
-            LockOwner lock = {&s_TPMethodTableCrst, IsOwnerOfCrst};
-            IfNullThrow(pTempHash->Init(23,&lock));
-
-            s_pThunkHashTable = pTempHash.Extract();
-        }
-
-        if (!s_pThunkHashTable->GetValue(pMD, (HashDatum *)&pSlot))
-        {
-            PCODE pThunkCode = CreateNonVirtualThunkForVirtualMethod(pMD);
-
-            _ASSERTE(CNonVirtualThunkMgr::IsThunkByASM(pThunkCode));
-            _ASSERTE(CNonVirtualThunkMgr::GetMethodDescByASM(pThunkCode));
-
-            // Set the generated thunk once and for all..            
-            CNonVirtualThunk *pThunk = CNonVirtualThunk::SetNonVirtualThunks((BYTE*)pThunkCode);
-
-            // Remember the thunk address in a hash table 
-            // so that we dont generate it again
-            pSlot = (PTR_PCODE)pThunk->GetAddrOfCode();
-            s_pThunkHashTable->InsertValue(pMD, (HashDatum)pSlot);
-        }
-    }
-
-    RETURN pSlot;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CTPMethodTable::DestroyThunk   public
-//
-//  Synopsis:   Destroy the thunk for the non virtual method. 
-//
-// 
-//+----------------------------------------------------------------------------
-void CTPMethodTable::DestroyThunk(MethodDesc* pMD)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pMD));
-    }
-    CONTRACTL_END;
-    
-    if(s_pThunkHashTable)
-    {
-        CrstHolder ch(&s_TPMethodTableCrst);
-
-        LPVOID pvCode = NULL;
-        s_pThunkHashTable->GetValue(pMD, (HashDatum *)&pvCode);
-        CNonVirtualThunk *pThunk = NULL;
-        if(NULL != pvCode)
-        {
-            pThunk = CNonVirtualThunk::AddrToThunk(pvCode);
-            delete pThunk;
-            s_pThunkHashTable->DeleteValue(pMD);
-        }
-    }
-} 
-#endif // HAS_REMOTING_PRECODE
-
-static LPVOID CallTargetWorker1(MethodDesc* pTargetMD,
-                                            LPVOID pvFirst,
-                                            LPVOID pvSecond)
-{
-    STATIC_CONTRACT_THROWS;
-    STATIC_CONTRACT_GC_TRIGGERS;
-    STATIC_CONTRACT_MODE_COOPERATIVE;
-    STATIC_CONTRACT_SO_INTOLERANT;
-
-    LPVOID ret = NULL;
-    PCODE pTarget = pTargetMD->GetSingleCallableAddrOfCode();
-
-#if defined(DEBUGGING_SUPPORTED)
-    if (CORDebuggerTraceCall())
-    {
-        g_pDebugInterface->TraceCall((const BYTE*)pTarget);
-    }
-#endif // DEBUGGING_SUPPORTED
-
-
-    BEGIN_CALL_TO_MANAGED();
-
-    ret = CTPMethodTable__CallTargetHelper2((const BYTE*)pTarget, pvFirst, pvSecond);
-
-    END_CALL_TO_MANAGED();
-
-    return ret;
-}  
-
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CTPMethodTable::CallTarget   private
-//
-//  Synopsis:   Calls the target method on the given object
-// 
-//+----------------------------------------------------------------------------
-LPVOID __stdcall CTPMethodTable::CallTarget (MethodDesc* pTargetMD,
-                                            LPVOID pvFirst,
-                                            LPVOID pvSecond)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        SO_INTOLERANT;
-        PRECONDITION(CheckPointer(pTargetMD));
-        PRECONDITION(CheckPointer(pvFirst, NULL_OK));
-        PRECONDITION(CheckPointer(pvSecond, NULL_OK));
-    }
-    CONTRACTL_END;
-    
-#ifdef _DEBUG
-
-    Thread* curThread = GetThread();
-    
-    Object* ObjRefTable[OBJREF_TABSIZE];
-
-    if (curThread)
-        memcpy(ObjRefTable, curThread->dangerousObjRefs, sizeof(curThread->dangerousObjRefs));
-    
-#endif // _DEBUG
-
-    LPVOID ret = CallTargetWorker1(pTargetMD, pvFirst, pvSecond);
-    
-#ifdef _DEBUG
-    // Restore dangerousObjRefs when we return back to EE after call
-    if (curThread)
-        memcpy(curThread->dangerousObjRefs, ObjRefTable, sizeof(curThread->dangerousObjRefs));
-
-    ENABLESTRESSHEAP ();
-#endif // _DEBUG
-
-    return ret;
-}
-
-
-static LPVOID CallTargetWorker2(MethodDesc* pTargetMD,
-                                    LPVOID pvFirst,
-                                    LPVOID pvSecond,
-                                    LPVOID pvThird)
-{
-    STATIC_CONTRACT_THROWS;
-    STATIC_CONTRACT_GC_TRIGGERS;
-    STATIC_CONTRACT_MODE_COOPERATIVE;
-    STATIC_CONTRACT_SO_INTOLERANT;
-
-    LPVOID ret = NULL;
-    PCODE pTarget = pTargetMD->GetSingleCallableAddrOfCode();
-
-#if defined(DEBUGGING_SUPPORTED)
-    if (CORDebuggerTraceCall())
-    {
-        g_pDebugInterface->TraceCall((const BYTE*)pTarget);
-    }
-#endif // DEBUGGING_SUPPORTED
-
-    BEGIN_CALL_TO_MANAGED();
-
-    ret = CTPMethodTable__CallTargetHelper3((const BYTE*)pTarget, pvFirst, pvSecond, pvThird);
-
-    END_CALL_TO_MANAGED();
-    return ret;
-
-}
-
-LPVOID __stdcall CTPMethodTable::CallTarget (MethodDesc* pTargetMD,
-                                            LPVOID pvFirst,
-                                            LPVOID pvSecond,
-                                            LPVOID pvThird)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        SO_INTOLERANT;
-        PRECONDITION(CheckPointer(pTargetMD));
-        PRECONDITION(CheckPointer(pvFirst, NULL_OK));
-        PRECONDITION(CheckPointer(pvSecond, NULL_OK));
-        PRECONDITION(CheckPointer(pvThird, NULL_OK));
-    }
-    CONTRACTL_END;
-    
-#ifdef _DEBUG
-    Thread* curThread = GetThread();
-    
-    Object* ObjRefTable[OBJREF_TABSIZE];
-    if (curThread)
-        memcpy(ObjRefTable, curThread->dangerousObjRefs, sizeof(curThread->dangerousObjRefs));
-    
-#endif // _DEBUG
-
-    LPVOID ret = CallTargetWorker2(pTargetMD, pvFirst, pvSecond, pvThird);
-    
-#ifdef _DEBUG
-    // Restore dangerousObjRefs when we return back to EE after call
-    if (curThread)
-        memcpy(curThread->dangerousObjRefs, ObjRefTable, sizeof(curThread->dangerousObjRefs));
-
-    ENABLESTRESSHEAP ();
-#endif // _DEBUG
-    
-    return ret;
-}
-
-
-#ifndef HAS_REMOTING_PRECODE
-//+----------------------------------------------------------------------------
-//
-//  Method:     CNonVirtualThunk::SetNextThunk   public
-//
-//  Synopsis:   Creates a thunk for the given address and adds it to the global
-//              list
-// 
-//+----------------------------------------------------------------------------
-CNonVirtualThunk* CNonVirtualThunk::SetNonVirtualThunks(const BYTE* pbCode)
-{    
-    CONTRACT (CNonVirtualThunk*)
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM());
-        PRECONDITION(CheckPointer(pbCode));
-        POSTCONDITION(CheckPointer(RETVAL));
-    }
-    CONTRACT_END;
-    
-    CNonVirtualThunk *pThunk = new CNonVirtualThunk(pbCode);            
-
-    // Put the generated thunk in a global list
-    // Note: this is called when a NV thunk is being created ..
-    // The TPMethodTable critsec is held at this point
-    pThunk->SetNextThunk();
-
-    // Set up the stub manager if necessary
-    CNonVirtualThunkMgr::InitNonVirtualThunkManager();
-
-    RETURN pThunk;
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CNonVirtualThunk::~CNonVirtualThunk   public
-//
-//  Synopsis:   Deletes the thunk from the global list of thunks
-//              
-// 
-//+----------------------------------------------------------------------------
-CNonVirtualThunk::~CNonVirtualThunk()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(s_pNonVirtualThunks));
-    }
-    CONTRACTL_END;
-
-    CNonVirtualThunk* pCurr = s_pNonVirtualThunks;
-    CNonVirtualThunk* pPrev = NULL;
-    BOOL found = FALSE;
-
-    // Note: This is called with the TPMethodTable critsec held
-    while(!found && (NULL != pCurr))
-    {
-        if(pCurr == this)
-        {
-            found = TRUE;
-            SimpleRWLock::SimpleWriteLockHolder swlh(s_pNonVirtualThunksListLock);
-            
-            // Unlink from the chain 
-            if(NULL != pPrev)
-            {                    
-                pPrev->_pNext = pCurr->_pNext;
-            }
-            else
-            {
-               // First entry needs to be deleted
-                s_pNonVirtualThunks = pCurr->_pNext;
-            }
-        }
-        pPrev = pCurr;
-        pCurr = pCurr->_pNext;
-    }
-
-    _ASSERTE(found);
-}
-#endif // HAS_REMOTING_PRECODE
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CVirtualThunkMgr::InitVirtualThunkManager   public
-//
-//  Synopsis:   Adds the stub manager to aid debugger in stepping into calls
-//              
-// 
-//+----------------------------------------------------------------------------
-void CVirtualThunkMgr::InitVirtualThunkManager()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM());
-    }
-    CONTRACTL_END;
-    
-    // This is function is already threadsafe since this method is called from within a 
-    // critical section  
-    if(NULL == s_pVirtualThunkMgr)
-    {
-        // Add the stub manager for vtable calls
-        s_pVirtualThunkMgr =  new CVirtualThunkMgr();
-    
-        StubManager::AddStubManager(s_pVirtualThunkMgr);
-    }
-
-}
-
-#endif // !DACCESS_COMPILE
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CVirtualThunkMgr::CheckIsStub_Internal   public
-//
-//  Synopsis:   Returns TRUE if the given address is the starting address of
-//              the transparent proxy stub
-// 
-//+----------------------------------------------------------------------------
-BOOL CVirtualThunkMgr::CheckIsStub_Internal(PCODE stubStartAddress)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        SUPPORTS_DAC;
-    }
-    CONTRACTL_END;
-
-    BOOL bIsStub = FALSE;
-
-#ifndef DACCESS_COMPILE
-    if (!IsThunkByASM(stubStartAddress))
-        return FALSE;
-    if(NULL != FindThunk((const BYTE *) stubStartAddress))
-        bIsStub = TRUE;
-#endif // !DACCESS_COMPILE
-
-    return bIsStub;
-}
-
-#ifndef DACCESS_COMPILE
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CVirtualThunkMgr::Entry2MethodDesc   public
-//
-//  Synopsis:   Convert a starting address to a MethodDesc
-// 
-//+----------------------------------------------------------------------------
-MethodDesc *CVirtualThunkMgr::Entry2MethodDesc(PCODE StubStartAddress, MethodTable *pMT)
-{
-    CONTRACT (MethodDesc*)
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pMT, NULL_OK));
-        POSTCONDITION(CheckPointer(RETVAL, NULL_OK));
-    }
-    CONTRACT_END;
-    
-    if (s_pVirtualThunkMgr == NULL)
-        RETURN NULL;
-
-    if (!pMT)
-        RETURN NULL;
-
-    if (!s_pVirtualThunkMgr->CheckIsStub_Internal(StubStartAddress))
-        RETURN NULL;
-
-    RETURN GetMethodDescByASM(StubStartAddress, pMT);
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CVirtualThunkMgr::FindThunk   private
-//
-//  Synopsis:   Finds a thunk that matches the given starting address
-// 
-//+----------------------------------------------------------------------------
-LPBYTE CVirtualThunkMgr::FindThunk(const BYTE *stubStartAddress)
-{
-    CONTRACT (LPBYTE)
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(stubStartAddress, NULL_OK));
-        POSTCONDITION(CheckPointer(RETVAL, NULL_OK));
-        SO_TOLERANT;
-    }
-    CONTRACT_END;
-
-    CVirtualThunks* pThunks = CVirtualThunks::GetVirtualThunks();
-    LPBYTE pThunkAddr = NULL;
-
-    while(NULL != pThunks)
-    {
-        DWORD dwStartSlot = pThunks->_dwStartThunk;
-        DWORD dwCurrSlot = pThunks->_dwStartThunk;
-        DWORD dwMaxSlot = pThunks->_dwCurrentThunk;        
-        while (dwCurrSlot < dwMaxSlot)
-        {
-            LPBYTE pStartAddr =  pThunks->ThunkCode[dwCurrSlot-dwStartSlot].pCode;
-            if((stubStartAddress >= pStartAddr) &&
-               (stubStartAddress <  (pStartAddr + ConstVirtualThunkSize)))
-            {
-                pThunkAddr = pStartAddr;
-                break;
-            }            
-            ++dwCurrSlot;
-        }
-
-        pThunks = pThunks->GetNextThunk();            
-     }
-
-     RETURN pThunkAddr;
-}
-
-#endif // !DACCESS_COMPILE
-
-#ifndef HAS_REMOTING_PRECODE
-
-#ifndef DACCESS_COMPILE
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CNonVirtualThunkMgr::InitNonVirtualThunkManager   public
-//
-//  Synopsis:   Adds the stub manager to aid debugger in stepping into calls
-//              
-// 
-//+----------------------------------------------------------------------------
-void CNonVirtualThunkMgr::InitNonVirtualThunkManager()
-{   
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM());
-    }
-    CONTRACTL_END;
-
-    // This function is already thread safe since this method is called from within a 
-    // critical section
-    if(NULL == s_pNonVirtualThunkMgr)
-    {
-        // Add the stub manager for non vtable calls
-        s_pNonVirtualThunkMgr = new CNonVirtualThunkMgr();
-        
-        StubManager::AddStubManager(s_pNonVirtualThunkMgr);
-    }
-}
-
-#endif // !DACCESS_COMPILE
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CNonVirtualThunkMgr::CheckIsStub_Internal   public
-//
-//  Synopsis:   Returns TRUE if the given address is the starting address of
-//              one of our thunks
-// 
-//+----------------------------------------------------------------------------
-BOOL CNonVirtualThunkMgr::CheckIsStub_Internal(PCODE stubStartAddress)
-{
-    WRAPPER_NO_CONTRACT;
-    
-    BOOL bIsStub = FALSE;
-
-#ifndef DACCESS_COMPILE
-    if (!IsThunkByASM(stubStartAddress))
-        return FALSE;
-    if(NULL != FindThunk((const BYTE *) stubStartAddress))
-        bIsStub = TRUE;       
-#endif // !DACCESS_COMPILE
-
-    return bIsStub;
-}
-
-#ifndef DACCESS_COMPILE
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CNonVirtualThunkMgr::Entry2MethodDesc   public
-//
-//  Synopsis:   Convert a starting address to a MethodDesc
-// 
-//+----------------------------------------------------------------------------
-MethodDesc *CNonVirtualThunkMgr::Entry2MethodDesc(PCODE StubStartAddress, MethodTable *pMT)
-{
-    CONTRACT (MethodDesc*)
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pMT, NULL_OK));
-        POSTCONDITION(CheckPointer(RETVAL, NULL_OK));
-    }
-    CONTRACT_END;
-
-    if (s_pNonVirtualThunkMgr == NULL)
-        RETURN NULL;
-    
-    if (!s_pNonVirtualThunkMgr->CheckIsStub_Internal(StubStartAddress))
-        RETURN NULL;
-
-    RETURN GetMethodDescByASM(StubStartAddress);
-}
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CNonVirtualThunkMgr::FindThunk   private
-//
-//  Synopsis:   Finds a thunk that matches the given starting address
-// 
-//+----------------------------------------------------------------------------
-CNonVirtualThunk* CNonVirtualThunkMgr::FindThunk(const BYTE *stubStartAddress)
-{
-    CONTRACT (CNonVirtualThunk*)
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(stubStartAddress, NULL_OK));
-        POSTCONDITION(CheckPointer(RETVAL, NULL_OK));
-        SO_TOLERANT;
-    }
-    CONTRACT_END;
-    
-    SimpleRWLock::SimpleReadLockHolder srlh(CNonVirtualThunk::GetThunksListLock());
-    CNonVirtualThunk* pThunk = CNonVirtualThunk::GetNonVirtualThunks();
-
-    while(NULL != pThunk)
-    {
-        if(stubStartAddress == pThunk->GetThunkCode())           
-            break;
-
-        pThunk = pThunk->GetNextThunk();            
-    }
-
-    RETURN pThunk;
-}
-
-#endif // !DACCESS_COMPILE
-
-#endif // HAS_REMOTING_PRECODE
-
-
-#ifndef DACCESS_COMPILE
-
-//+----------------------------------------------------------------------------
-//+- HRESULT MethodDescDispatchHelper(MethodDesc* pMD, ARG_SLOT[] args, ARG_SLOT *pret)
-//+----------------------------------------------------------------------------
-HRESULT MethodDescDispatchHelper(MethodDescCallSite* pMethodCallSite, ARG_SLOT args[], ARG_SLOT *pret)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(CheckPointer(pMethodCallSite));
-        PRECONDITION(CheckPointer(args));
-        PRECONDITION(CheckPointer(pret));
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-    EX_TRY
-    {
-        *pret = pMethodCallSite->Call_RetArgSlot(args);
-    }
-    EX_CATCH_HRESULT(hr);
-
-    return hr;
-}
-
-
-#ifdef FEATURE_COMINTEROP
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     VOID  CRemotingServices::CallSetDCOMProxy(OBJECTREF realProxy, IUnknown* pUnk)
-//
-//+----------------------------------------------------------------------------
-
-VOID CRemotingServices::CallSetDCOMProxy(OBJECTREF realProxy, IUnknown* pUnk)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(realProxy != NULL);
-        PRECONDITION(CheckPointer(pUnk, NULL_OK));
-    }
-    CONTRACTL_END;
-
-    GCPROTECT_BEGIN(realProxy);
-
-    MethodDescCallSite setDCOMProxy(METHOD__REAL_PROXY__SETDCOMPROXY, &realProxy);
-    
-    ARG_SLOT args[] =
-    {
-        ObjToArgSlot(realProxy),
-        (ARG_SLOT)pUnk
-    };
-
-    ARG_SLOT ret;
-    MethodDescDispatchHelper(&setDCOMProxy, args, &ret);
-    
-    GCPROTECT_END();
-}
-
-
-BOOL CRemotingServices::CallSupportsInterface(OBJECTREF realProxy, REFIID iid, ARG_SLOT* pret)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(realProxy != NULL);
-        PRECONDITION(CheckPointer(pret));
-    }
-    CONTRACTL_END;
-    
-    BOOL    fResult = TRUE;
-    
-    GCPROTECT_BEGIN(realProxy);
-    
-    MethodDescCallSite supportsInterface(METHOD__REAL_PROXY__SUPPORTSINTERFACE, &realProxy);
-
-    ARG_SLOT args[] =
-    {
-        ObjToArgSlot(realProxy),
-        (ARG_SLOT)&iid
-    };
-
-    HRESULT hr = MethodDescDispatchHelper(&supportsInterface, args, pret);
-
-    // It is allowed for the managed code to return a NULL interface pointer without returning
-    // a failure HRESULT. This is done for performance to avoid having to throw an exception.
-    // If this occurs, we need to return E_NOINTERFACE.
-    if ((*(IUnknown**)pret) == NULL)
-        hr = E_NOINTERFACE;
-
-    if (FAILED(hr))
-        fResult = FALSE;
-
-    GCPROTECT_END();
-    return fResult;
-}
-#endif // FEATURE_COMINTEROP
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CRemotingServices::GetStubForInterfaceMethod
-//
-//  Synopsis:   Given the exact interface method we wish to invoke on, return
-//              the entry point of a stub that will correctly transition into
-//              the remoting system passing it this method.
-//              The stubs is just another kind of precode. They are cached
-//              in per appdomain hash.
-//
-// 
-//+----------------------------------------------------------------------------
-PCODE CRemotingServices::GetStubForInterfaceMethod(MethodDesc *pItfMD)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pItfMD));
-        PRECONDITION(pItfMD->IsInterface() && !pItfMD->IsStatic());
-    }
-    CONTRACTL_END;
-
-    return pItfMD->GetLoaderAllocator()->GetFuncPtrStubs()->GetFuncPtrStub(pItfMD, PRECODE_STUB);
-}
-
-#endif // !DACCESS_COMPILE
-#endif // FEATURE_REMOTING
diff --git a/src/vm/rexcep.h b/src/vm/rexcep.h
index 3ff4963996..32a9d038fb 100644
--- a/src/vm/rexcep.h
+++ b/src/vm/rexcep.h
@@ -109,12 +109,8 @@
 //
 
 DEFINE_EXCEPTION(g_ReflectionNS,       AmbiguousMatchException,        false,  COR_E_AMBIGUOUSMATCH)
-#ifdef FEATURE_CORECLR
 // ApplicationException is removed in CoreCLR
 #define kApplicationException kException 
-#else
-DEFINE_EXCEPTION(g_SystemNS,           ApplicationException,           false,  COR_E_APPLICATION)
-#endif // FEATURE_CORECLR
 DEFINE_EXCEPTION(g_SystemNS,           AppDomainUnloadedException,     false,  COR_E_APPDOMAINUNLOADED)
 DEFINE_EXCEPTION(g_SystemNS,           ArithmeticException,            false,  COR_E_ARITHMETIC)
 
@@ -142,12 +138,8 @@ DEFINE_EXCEPTION(g_SystemNS,       BadImageFormatException,        true,
                  META_E_BAD_SIGNATURE,
                  COR_E_LOADING_WINMD_REFERENCE_ASSEMBLY)
 
-#ifdef FEATURE_CORECLR
 // CannotUnloadAppDomainException is removed in CoreCLR
 #define kCannotUnloadAppDomainException kException 
-#else
-DEFINE_EXCEPTION(g_SystemNS,           CannotUnloadAppDomainException, false,  COR_E_CANNOTUNLOADAPPDOMAIN)
-#endif // FEATURE_CORECLR
 
 DEFINE_EXCEPTION(g_CodeContractsNS,    ContractException,              false,  COR_E_CODECONTRACTFAILED)
 
@@ -157,12 +149,9 @@ DEFINE_EXCEPTION(g_SystemNS,           ContextMarshalException,        false,  C
 
 DEFINE_EXCEPTION(g_ReflectionNS,       CustomAttributeFormatException, false,  COR_E_CUSTOMATTRIBUTEFORMAT)
 
-#if defined(FEATURE_X509) || defined(FEATURE_CRYPTO)
+#if defined(FEATURE_X509)
 DEFINE_EXCEPTION(g_CryptographyNS,     CryptographicException,         false,  CORSEC_E_CRYPTO)
-#endif // FEATURE_X509 || FEATURE_CRYPTO
-#ifndef FEATURE_CORECLR
-DEFINE_EXCEPTION(g_CryptographyNS,     CryptographicUnexpectedOperationException, false,  CORSEC_E_CRYPTO_UNEX_OPER)
-#endif // FEATURE_CORECLR
+#endif // FEATURE_X509
 
 DEFINE_EXCEPTION(g_SystemNS,           DataMisalignedException,        false,  COR_E_DATAMISALIGNED)
 
@@ -315,10 +304,6 @@ DEFINE_EXCEPTION(g_SystemNS,           UnauthorizedAccessException,    true,   C
 
 DEFINE_EXCEPTION(g_SecurityNS,         VerificationException,          false,  COR_E_VERIFICATION)
 
-#ifdef FEATURE_CAS_POLICY
-DEFINE_EXCEPTION(g_PolicyNS,           PolicyException,                true,   CORSEC_E_POLICY_EXCEPTION, CORSEC_E_NO_EXEC_PERM, CORSEC_E_MIN_GRANT_FAIL)
-DEFINE_EXCEPTION(g_SecurityNS,         XmlSyntaxException,             false,  CORSEC_E_XMLSYNTAX)
-#endif // FEATURE_CAS_POLICY
 
 DEFINE_EXCEPTION(g_InteropNS,          COMException,                   false,  E_FAIL)
 DEFINE_EXCEPTION(g_InteropNS,          ExternalException,              false,  E_FAIL)
@@ -327,9 +312,7 @@ DEFINE_EXCEPTION(g_SystemNS,           NotImplementedException,        false,  E
 
 DEFINE_EXCEPTION(g_SystemNS,           OutOfMemoryException,           false,  E_OUTOFMEMORY, CTL_E_OUTOFMEMORY, STD_CTL_SCODE(31001))
 
-#ifdef FEATURE_CORECLR
 DEFINE_EXCEPTION(g_SystemNS,           CrossAppDomainMarshaledException, false, E_FAIL)
-#endif //FEATURE_CORECLR
 
 #ifdef FEATURE_ISOSTORE
 DEFINE_EXCEPTION(g_IsolatedStorageNS,  IsolatedStorageException,       true,
diff --git a/src/vm/runtimecallablewrapper.cpp b/src/vm/runtimecallablewrapper.cpp
index 359b6896bc..93b5c2c38a 100644
--- a/src/vm/runtimecallablewrapper.cpp
+++ b/src/vm/runtimecallablewrapper.cpp
@@ -41,7 +41,6 @@ class Object;
 #include "mdaassistants.h"
 #include "olevariant.h"
 #include "interopconverter.h"
-#include "constrainedexecutionregion.h"
 #include "typestring.h"
 #ifdef FEATURE_REMOTING
 #include "crossdomaincalls.h"
@@ -541,49 +540,9 @@ IClassFactory *ComClassFactory::GetIClassFactory()
             StackSString ssServer;
             if (FAILED(Clr::Util::Com::FindServerUsingCLSID(m_rclsid, ssServer)))
             {
-#ifndef FEATURE_CORECLR
-                // If there is no server entry, then that implies the CLSID could be implemented by CLR.DLL itself,
-                // if the CLSID is one of the special ones implemented by the CLR. We need to check against the
-                // specific list of CLSIDs here because CLR.DLL-implemented CLSIDs and managed class-implemented
-                // CLSIDs look the same until you start interating the subkeys. For now, the set of CLSIDs implemented
-                // by CLR.DLL is a short and tractable list, but at some point it might become worthwhile to move over
-                // to the more generalized solution of looking for the entries that identify when the CLSID is
-                // implemented by a managed type to avoid having to maintain the hardcoded list.
-                if (IsClrHostedLegacyComObject(m_rclsid))
-                {
-                    PDllGetClassObject pFN = NULL;
-                    hr = g_pCLRRuntime->GetProcAddress("DllGetClassObjectInternal", reinterpret_cast<void**>(&pFN));
-
-                    if (FAILED(hr))
-                        hr = g_pCLRRuntime->GetProcAddress("DllGetClassObject", reinterpret_cast<void**>(&pFN));
-
-                    if (SUCCEEDED(hr))
-                        hr = pFN(m_rclsid, IID_IClassFactory, (void**)&pClassFactory);
-                }
-#endif
             }
             else
             {   
-#ifndef FEATURE_CORECLR
-                // @CORESYSTODO: ?
-                
-                // There is a SxS DLL that implements this CLSID.
-                // NOTE: It is standard practise for RCWs and P/Invokes to leak their module handles,
-                //       as there is no automated mechanism for the runtime to call CanUnloadDllNow.
-                HMODULE hServer = NULL;
-                if (SUCCEEDED(hr = g_pCLRRuntime->LoadLibrary(ssServer.GetUnicode(), &hServer)))
-                {
-                    PDllGetClassObject pFN = reinterpret_cast<PDllGetClassObject>(GetProcAddress(hServer, "DllGetClassObject"));
-                    if (pFN != NULL)
-                    {
-                        hr = pFN(m_rclsid, IID_IClassFactory, (void**)&pClassFactory);
-                    }
-                    else
-                    {
-                        hr = HRESULT_FROM_GetLastError();
-                    }
-                }
-#endif
             }
         }
 #endif // FEATURE_CLASSIC_COMINTEROP
@@ -3109,12 +3068,10 @@ IUnknown *RCW::GetWellKnownInterface(REFIID riid)
 // make sure it is on the right thread
 IDispatch *RCW::GetIDispatch()
 {
-#ifdef FEATURE_CORECLR
     if (AppX::IsAppXProcess())
     { 
         COMPlusThrow(kPlatformNotSupportedException, IDS_EE_ERROR_IDISPATCH);
     }
-#endif // FEATURE_CORECLR
 
     WRAPPER_NO_CONTRACT;
     return (IDispatch *)GetWellKnownInterface(IID_IDispatch);
@@ -4576,9 +4533,7 @@ bool RCW::SupportsMngStdInterface(MethodTable *pItfMT)
         if (pItfMT == MscorlibBinder::GetExistingClass(CLASS__IENUMERABLE))
         {
             SafeComHolder<IDispatch> pDisp = NULL;
-#ifdef FEATURE_CORECLR
             if  (!AppX::IsAppXProcess())
-#endif // FEATURE_CORECLR
             {
                  // Get the IDispatch on the current thread.
                  pDisp = GetIDispatch();
diff --git a/src/vm/runtimehandles.cpp b/src/vm/runtimehandles.cpp
index 68ad24c8f6..32a9674da5 100644
--- a/src/vm/runtimehandles.cpp
+++ b/src/vm/runtimehandles.cpp
@@ -352,13 +352,6 @@ FCIMPL3(void, RuntimeMethodHandle::CheckLinktimeDemands, ReflectMethodObject *pM
             }
         }
 
-#ifndef FEATURE_CORECLR    
-        if (pCallee->RequiresLinktimeCheck())
-        {
-            Module *pModule = refModule->GetModule();
-            Security::LinktimeCheckMethod(pDecoratedModule->GetAssembly(), pCallee);
-        }
-#endif // !FEATURE_CORECLR
     }
     HELPER_METHOD_FRAME_END();
 }
@@ -568,43 +561,6 @@ FCIMPLEND
 
 
 
-#ifndef FEATURE_CORECLR
-FCIMPL2(FC_BOOL_RET, RuntimeTypeHandle::IsEquivalentTo, ReflectClassBaseObject *rtType1UNSAFE, ReflectClassBaseObject *rtType2UNSAFE)
-{
-    FCALL_CONTRACT;
-
-    BOOL bResult = FALSE;
-
-    REFLECTCLASSBASEREF rtType1 = (REFLECTCLASSBASEREF)ObjectToOBJECTREF(rtType1UNSAFE);
-    REFLECTCLASSBASEREF rtType2 = (REFLECTCLASSBASEREF)ObjectToOBJECTREF(rtType2UNSAFE);
-
-    HELPER_METHOD_FRAME_BEGIN_RET_2(rtType1, rtType2);
-    if (rtType1 == NULL)
-        COMPlusThrowArgumentNull(W("rtType1"));
-    if (rtType2 == NULL)
-        COMPlusThrowArgumentNull(W("rtType2"));
-
-    bResult = rtType1->GetType().IsEquivalentTo(rtType2->GetType());
-    HELPER_METHOD_FRAME_END();
-
-    FC_RETURN_BOOL(bResult);
-}
-FCIMPLEND
-
-FCIMPL1(FC_BOOL_RET, RuntimeTypeHandle::IsEquivalentType, ReflectClassBaseObject *rtTypeUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    BOOL bResult = FALSE;
-
-    TypeHandle typeHandle = rtTypeUNSAFE->GetType();
-    if (!typeHandle.IsTypeDesc())
-        bResult = typeHandle.AsMethodTable()->GetClass()->IsEquivalentType();
-
-    FC_RETURN_BOOL(bResult);
-}
-FCIMPLEND
-#endif // !FEATURE_CORECLR
 
 #ifdef FEATURE_COMINTEROP
 FCIMPL1(FC_BOOL_RET, RuntimeTypeHandle::IsWindowsRuntimeObjectType, ReflectClassBaseObject *rtTypeUNSAFE)
@@ -3263,36 +3219,6 @@ FCIMPL1(INT32, AssemblyHandle::GetToken, AssemblyBaseObject* pAssemblyUNSAFE) {
 }
 FCIMPLEND
 
-#ifdef FEATURE_APTCA
-FCIMPL2(FC_BOOL_RET, AssemblyHandle::AptcaCheck, AssemblyBaseObject* pTargetAssemblyUNSAFE,  AssemblyBaseObject* pSourceAssemblyUNSAFE) 
-{
-    FCALL_CONTRACT;
-
-    ASSEMBLYREF refTargetAssembly = (ASSEMBLYREF)ObjectToOBJECTREF(pTargetAssemblyUNSAFE);
-    ASSEMBLYREF refSourceAssembly = (ASSEMBLYREF)ObjectToOBJECTREF(pSourceAssemblyUNSAFE);
-    
-    if ((refTargetAssembly == NULL) || (refSourceAssembly == NULL))
-        FCThrowRes(kArgumentNullException, W("Arg_InvalidHandle"));
-
-    DomainAssembly *pTargetAssembly = refTargetAssembly->GetDomainAssembly();
-    DomainAssembly *pSourceAssembly = refSourceAssembly->GetDomainAssembly();
-    
-    if (pTargetAssembly == pSourceAssembly)
-        FC_RETURN_BOOL(TRUE);
-
-    BOOL bResult = TRUE;
-    
-    HELPER_METHOD_FRAME_BEGIN_RET_2(refSourceAssembly, refTargetAssembly);
-    {
-        bResult = ( pTargetAssembly->GetAssembly()->AllowUntrustedCaller() || // target assembly allows untrusted callers unconditionally
-                    pSourceAssembly->GetSecurityDescriptor()->IsFullyTrusted());
-    }
-    HELPER_METHOD_FRAME_END();
-
-    FC_RETURN_BOOL(bResult);
-}
-FCIMPLEND
-#endif // FEATURE_APTCA
     
 void QCALLTYPE ModuleHandle::GetPEKind(QCall::ModuleHandle pModule, DWORD* pdwPEKind, DWORD* pdwMachine)
 {
diff --git a/src/vm/runtimehandles.h b/src/vm/runtimehandles.h
index afe1902359..2450a2b971 100644
--- a/src/vm/runtimehandles.h
+++ b/src/vm/runtimehandles.h
@@ -12,7 +12,6 @@
 #include "fcall.h"
 #include "field.h"
 #include "typectxt.h"
-#include "constrainedexecutionregion.h"
 
 typedef void* EnregisteredTypeHandle;
 class SignatureNative;
@@ -158,10 +157,6 @@ public:
     static FCDECL2(FC_BOOL_RET, TypeEQ, Object* left, Object* right);
     static FCDECL2(FC_BOOL_RET, TypeNEQ, Object* left, Object* right);
 
-#ifndef FEATURE_CORECLR
-    static FCDECL2(FC_BOOL_RET, IsEquivalentTo, ReflectClassBaseObject *rtType1UNSAFE, ReflectClassBaseObject *rtType2UNSAFE);
-    static FCDECL1(FC_BOOL_RET, IsEquivalentType, ReflectClassBaseObject *rtTypeUNSAFE);
-#endif // !FEATURE_CORECLR
 
 #ifdef FEATURE_COMINTEROP
     static FCDECL1(FC_BOOL_RET, IsWindowsRuntimeObjectType, ReflectClassBaseObject *rtTypeUNSAFE);
@@ -462,9 +457,6 @@ public:
     static FCDECL1(ReflectModuleBaseObject*, GetManifestModule, AssemblyBaseObject *pAssemblyUNSAFE);
 
     static FCDECL1(INT32, GetToken, AssemblyBaseObject *pAssemblyUNSAFE);   
-#ifdef FEATURE_APTCA
-    static FCDECL2(FC_BOOL_RET, AptcaCheck, AssemblyBaseObject *pTargetAssemblyUNSAFE, AssemblyBaseObject *pSourceAssemblyUNSAFE);
-#endif // FEATURE_APTCA
 };
 
 class SignatureNative;
diff --git a/src/vm/rwlock.cpp b/src/vm/rwlock.cpp
deleted file mode 100644
index 9d8233d140..0000000000
--- a/src/vm/rwlock.cpp
+++ /dev/null
@@ -1,2952 +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.
-//
-
-// 
-//+-------------------------------------------------------------------
-//
-//  File:       RWLock.cpp
-//
-//  Contents:   Reader writer lock implementation that supports the
-//              following features
-//                  1. Cheap enough to be used in large numbers
-//                     such as per object synchronization.
-//                  2. Supports timeout. This is a valuable feature
-//                     to detect deadlocks
-//                  3. Supports caching of events. This allows
-//                     the events to be moved from least contentious
-//                     regions to the most contentious regions.
-//                     In other words, the number of events needed by
-//                     Reader-Writer lockls is bounded by the number
-//                     of threads in the process.
-//                  4. Supports nested locks by readers and writers
-//                  5. Supports spin counts for avoiding context switches
-//                     on  multi processor machines.
-//                  6. Supports functionality for upgrading to a writer
-//                     lock with a return argument that indicates
-//                     intermediate writes. Downgrading from a writer
-//                     lock restores the state of the lock.
-//                  7. Supports functionality to Release Lock for calling
-//                     app code. RestoreLock restores the lock state and
-//                     indicates intermediate writes.
-//                  8. Recovers from most common failures such as creation of
-//                     events. In other words, the lock mainitains consistent
-//                     internal state and remains usable
-//
-//
-//  Classes:    CRWLock
-// 
-//--------------------------------------------------------------------
-
-
-#include "common.h"
-#include "rwlock.h"
-#include "corhost.h"
-
-#ifdef FEATURE_RWLOCK
-
-// Reader increment
-#define READER                 0x00000001
-// Max number of readers
-#define READERS_MASK           0x000003FF
-// Reader being signaled
-#define READER_SIGNALED        0x00000400
-// Writer being signaled
-#define WRITER_SIGNALED        0x00000800
-#define WRITER                 0x00001000
-// Waiting reader increment
-#define WAITING_READER         0x00002000
-// Note size of waiting readers must be less
-// than or equal to size of readers
-#define WAITING_READERS_MASK   0x007FE000
-#define WAITING_READERS_SHIFT  13
-// Waiting writer increment
-#define WAITING_WRITER         0x00800000
-// Max number of waiting writers
-#define WAITING_WRITERS_MASK   0xFF800000
-// Events are being cached
-#define CACHING_EVENTS         (READER_SIGNALED | WRITER_SIGNALED)
-
-// Cookie flags
-#define UPGRADE_COOKIE         0x02000
-#define RELEASE_COOKIE         0x04000
-#define COOKIE_NONE            0x10000
-#define COOKIE_WRITER          0x20000
-#define COOKIE_READER          0x40000
-#define INVALID_COOKIE         (~(UPGRADE_COOKIE | RELEASE_COOKIE |            \
-                                  COOKIE_NONE | COOKIE_WRITER | COOKIE_READER))
-#define RWLOCK_MAX_ACQUIRE_COUNT 0xFFFF
-
-// globals
-Volatile<LONGLONG> CRWLock::s_mostRecentLockID = 0;
-CrstStatic CRWLock::s_RWLockCrst;
-
-// Default values
-#ifdef _DEBUG
-DWORD gdwDefaultTimeout = 120000;
-#else //!_DEBUG
-DWORD gdwDefaultTimeout = INFINITE;
-#endif //_DEBUG
-const DWORD gdwReasonableTimeout = 120000;
-DWORD gdwDefaultSpinCount = 0;
-BOOL fBreakOnErrors = FALSE; // Temporarily break on errors
-
-// <REVISIT_TODO> REVISIT_TODO: Bad practise</REVISIT_TODO>
-#define HEAP_SERIALIZE                   0
-#define RWLOCK_RECOVERY_FAILURE          (0xC0000227L)
-
-// Catch GC holes
-#if _DEBUG
-#define VALIDATE_LOCK(pRWLock)                ((Object *) (pRWLock))->Validate();
-#else // !_DEBUG
-#define VALIDATE_LOCK(pRWLock)
-#endif // _DEBUG
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::ProcessInit     public
-//
-//  Synopsis:   Reads default values from registry and intializes 
-//              process wide data structures
-// 
-//+-------------------------------------------------------------------
-void CRWLock::ProcessInit()
-{
-    CONTRACTL
-    {
-        THROWS; // From Crst.Init()
-        GC_NOTRIGGER;
-        PRECONDITION((g_SystemInfo.dwNumberOfProcessors != 0));
-    }
-    CONTRACTL_END;
-
-    gdwDefaultSpinCount = (g_SystemInfo.dwNumberOfProcessors != 1) ? 500 : 0;
-
-    PPEB peb = (PPEB) ClrTeb::GetProcessEnvironmentBlock();
-    DWORD dwTimeout = (DWORD)(peb->CriticalSectionTimeout.QuadPart/-10000000);
-    if (dwTimeout)
-    {
-        gdwDefaultTimeout = dwTimeout;
-    }
-
-    // Initialize the critical section used by the lock
-    // Can throw out of memory here.
-    s_RWLockCrst.Init(CrstRWLock, CRST_UNSAFE_ANYMODE);
-}
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::CRWLock     public
-//
-//  Synopsis:   Constructor
-// 
-//+-------------------------------------------------------------------
-CRWLock::CRWLock()
-:   _hWriterEvent(NULL),
-    _hReaderEvent(NULL),
-    _dwState(0),
-    _dwWriterID(0),
-    _dwWriterSeqNum(1),
-    _wWriterLevel(0)
-#ifdef RWLOCK_STATISTICS
-    ,
-    _dwReaderEntryCount(0),
-    _dwReaderContentionCount(0),
-    _dwWriterEntryCount(0),
-    _dwWriterContentionCount(0),
-    _dwEventsReleasedCount(0)
-#endif
-{
-
-    CONTRACT_VOID
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        POSTCONDITION((_dwLLockID > 0));
-    }
-    CONTRACT_END;
-
-    LONGLONG qwLockID = s_mostRecentLockID;
-    while (true)
-    {
-        LONGLONG qwNextLockID = qwLockID + 1;
-        if (static_cast<LONG>(qwNextLockID) == 0)
-        {
-            // A value of zero for the lower half of the ID is reserved to identify that a thread does not own any RW locks,
-            // regardless of the upper half of the ID
-            ++qwNextLockID;
-        }
-
-        LONGLONG qwLockIDBeforeExchange = RWInterlockedCompareExchange64(&s_mostRecentLockID, qwNextLockID, qwLockID);
-        if (qwLockIDBeforeExchange == qwLockID)
-        {
-            qwLockID = qwNextLockID;
-            break;
-        }
-
-        qwLockID = qwLockIDBeforeExchange;
-    }
-
-    _dwLLockID = static_cast<LONG>(qwLockID);
-    _dwULockID = static_cast<LONG>(qwLockID >> 32);
-
-    RETURN;
-}
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::Cleanup    public
-//
-//  Synopsis:   Cleansup state
-// 
-//+-------------------------------------------------------------------
-void CRWLock::Cleanup()
-{
-
-    CONTRACTL
-    {
-        NOTHROW;           
-        GC_NOTRIGGER;
-        PRECONDITION((_dwState == 0));        // sanity checks
-        PRECONDITION((_dwWriterID == 0));
-        PRECONDITION((_wWriterLevel == 0));
-    }
-    CONTRACTL_END;
-
-    if(_hWriterEvent) {
-        delete _hWriterEvent;
-        _hWriterEvent = NULL;
-    }
-    if(_hReaderEvent) {
-        delete _hReaderEvent;
-        _hReaderEvent = NULL;
-    }
-
-    return;
-}
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::ChainEntry     private
-//
-//  Synopsis:   Chains the given lock entry into the chain
-// 
-//+-------------------------------------------------------------------
-inline void CRWLock::ChainEntry(Thread *pThread, LockEntry *pLockEntry)
-{
-    CONTRACTL
-    {
-        NOTHROW;           
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    // This is to synchronize with finalizer thread and deadlock detection.
-    CrstHolder rwl(&s_RWLockCrst);
-    LockEntry *pHeadEntry = pThread->m_pHead;
-    pLockEntry->pNext = pHeadEntry;
-    pLockEntry->pPrev = pHeadEntry->pPrev;
-    pLockEntry->pPrev->pNext = pLockEntry;
-    pHeadEntry->pPrev = pLockEntry;
-
-    return;
-}
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::GetLockEntry     private
-//
-//  Synopsis:   Gets lock entry from TLS
-// 
-//+-------------------------------------------------------------------
-inline LockEntry *CRWLock::GetLockEntry(Thread* pThread)
-{
-    CONTRACTL
-    {
-        NOTHROW;           
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    if (pThread == NULL) {
-        pThread = GetThread();
-    }
-    LockEntry *pHeadEntry = pThread->m_pHead;
-    LockEntry *pLockEntry = pHeadEntry;
-    do
-    {
-        if((pLockEntry->dwLLockID == _dwLLockID) && (pLockEntry->dwULockID == _dwULockID))
-            return(pLockEntry);
-        pLockEntry = pLockEntry->pNext;
-    } while(pLockEntry != pHeadEntry);
-
-    return(NULL);
-}
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::FastGetOrCreateLockEntry     private
-//
-//  Synopsis:   The fast path for getting a lock entry from TLS
-// 
-//+-------------------------------------------------------------------
-inline LockEntry *CRWLock::FastGetOrCreateLockEntry()
-{
-
-    CONTRACTL
-    {
-        THROWS;               //   SlowGetOrCreateLockEntry can throw out of memory exception       
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    Thread *pThread = GetThread();
-    _ASSERTE(pThread);
-    LockEntry *pLockEntry = pThread->m_pHead;
-    if(pLockEntry->dwLLockID == 0)
-    {
-        _ASSERTE(pLockEntry->wReaderLevel == 0);
-        pLockEntry->dwLLockID = _dwLLockID;
-        pLockEntry->dwULockID = _dwULockID;
-        return(pLockEntry);
-    }
-    else if((pLockEntry->dwLLockID == _dwLLockID) && (pLockEntry->dwULockID == _dwULockID))
-    {
-        // Note, StaticAcquireReaderLock can have reentry via pumping while it's blocking
-        // so no assertions about pLockEntry->wReaderLevel's state
-        return(pLockEntry);
-    }
-
-    return(SlowGetOrCreateLockEntry(pThread));
-}
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::SlowGetorCreateLockEntry     private
-//
-//  Synopsis:   The slow path for getting a lock entry from TLS
-// 
-//+-------------------------------------------------------------------
-LockEntry *CRWLock::SlowGetOrCreateLockEntry(Thread *pThread)
-{
-
-    CONTRACTL
-    {
-        THROWS;               // memory allocation can throw out of memory exception       
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    LockEntry *pFreeEntry = NULL;
-    LockEntry *pHeadEntry = pThread->m_pHead;
-
-    // Search for an empty entry or an entry belonging to this lock
-    LockEntry *pLockEntry = pHeadEntry->pNext;
-    while(pLockEntry != pHeadEntry)
-    {
-         if(pLockEntry->dwLLockID && 
-            ((pLockEntry->dwLLockID != _dwLLockID) || (pLockEntry->dwULockID != _dwULockID)))
-         {
-             // Move to the next entry
-             pLockEntry = pLockEntry->pNext;
-         }
-         else
-         {
-             // Prepare to move it to the head
-             pFreeEntry = pLockEntry;
-             pLockEntry->pPrev->pNext = pLockEntry->pNext;
-             pLockEntry->pNext->pPrev = pLockEntry->pPrev;
-
-             break;
-         }
-    }
-
-    if(pFreeEntry == NULL)
-    {
-        pFreeEntry = new LockEntry;
-        pFreeEntry->wReaderLevel = 0;
-    }
-
-    if(pFreeEntry)
-    {
-        _ASSERTE((pFreeEntry->dwLLockID != 0) || (pFreeEntry->wReaderLevel == 0));
-        _ASSERTE((pFreeEntry->wReaderLevel == 0) || 
-                 ((pFreeEntry->dwLLockID == _dwLLockID) && (pFreeEntry->dwULockID == _dwULockID)));
-
-        // Chain back the entry
-        ChainEntry(pThread, pFreeEntry);
-
-        // Move this entry to the head
-        pThread->m_pHead = pFreeEntry;
-
-        // Mark the entry as belonging to this lock
-        pFreeEntry->dwLLockID = _dwLLockID;
-        pFreeEntry->dwULockID = _dwULockID;
-    }
-
-    return pFreeEntry;
-}
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::FastRecycleLockEntry     private
-//
-//  Synopsis:   Fast path for recycling the lock entry that is used
-//              when the thread is the next few instructions is going
-//              to call FastGetOrCreateLockEntry again
-// 
-//+-------------------------------------------------------------------
-inline void CRWLock::FastRecycleLockEntry(LockEntry *pLockEntry)
-{
-
-    CONTRACTL
-    {
-        NOTHROW;         
-        GC_NOTRIGGER;
-
-        // Sanity checks
-        PRECONDITION(pLockEntry->wReaderLevel == 0);
-        PRECONDITION((pLockEntry->dwLLockID == _dwLLockID) && (pLockEntry->dwULockID == _dwULockID));
-        PRECONDITION(pLockEntry == GetThread()->m_pHead);
-    }
-    CONTRACTL_END;
-
-
-    pLockEntry->dwLLockID = 0;
-}
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::RecycleLockEntry     private
-//
-//  Synopsis:   Fast path for recycling the lock entry
-// 
-//+-------------------------------------------------------------------
-inline void CRWLock::RecycleLockEntry(LockEntry *pLockEntry)
-{
-
-    CONTRACTL
-    {
-        NOTHROW;         
-        GC_NOTRIGGER;
-
-        // Sanity check
-        PRECONDITION(pLockEntry->wReaderLevel == 0);
-    }
-    CONTRACTL_END;
-
-    // Move the entry to tail
-    Thread *pThread = GetThread();
-    LockEntry *pHeadEntry = pThread->m_pHead;
-    if(pLockEntry == pHeadEntry)
-    {
-        pThread->m_pHead = pHeadEntry->pNext;
-    }
-    else if(pLockEntry->pNext->dwLLockID)
-    {
-        // Prepare to move the entry to tail
-        pLockEntry->pPrev->pNext = pLockEntry->pNext;
-        pLockEntry->pNext->pPrev = pLockEntry->pPrev;
-
-        // Chain back the entry
-        ChainEntry(pThread, pLockEntry);
-    }
-
-    // The entry does not belong to this lock anymore
-    pLockEntry->dwLLockID = 0;
-    return;
-}
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::StaticIsWriterLockHeld    public
-//
-//  Synopsis:   Return TRUE if writer lock is held
-// 
-//+-------------------------------------------------------------------
-FCIMPL1(FC_BOOL_RET, CRWLock::StaticIsWriterLockHeld, CRWLock *pRWLock)
-{
-    FCALL_CONTRACT;
-
-    if (pRWLock == NULL)
-    {
-        FCThrow(kNullReferenceException);
-    }
-
-    if(pRWLock->_dwWriterID == GetThread()->GetThreadId())
-        FC_RETURN_BOOL(TRUE);
-
-    FC_RETURN_BOOL(FALSE);
-}
-FCIMPLEND
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::StaticIsReaderLockHeld    public
-//
-//  Synopsis:   Return TRUE if reader lock is held
-// 
-//+-------------------------------------------------------------------
-FCIMPL1(FC_BOOL_RET, CRWLock::StaticIsReaderLockHeld, CRWLock *pRWLock)
-{
-    FCALL_CONTRACT;
-
-    if (pRWLock == NULL)
-    {
-        FCThrow(kNullReferenceException);
-    }
-    
-    LockEntry *pLockEntry = pRWLock->GetLockEntry();
-    if(pLockEntry)
-    {
-        FC_RETURN_BOOL(pLockEntry->wReaderLevel > 0);
-    }
-
-    FC_RETURN_BOOL(FALSE);
-}
-FCIMPLEND
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::AssertWriterLockHeld    public
-//
-//  Synopsis:   Asserts that writer lock is held
-// 
-//+-------------------------------------------------------------------
-#ifdef _DEBUG
-BOOL CRWLock::AssertWriterLockHeld()
-{
-    CONTRACTL
-    {
-        NOTHROW;         
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    if(_dwWriterID == GetThread()->GetThreadId())
-        return(TRUE);
-
-    _ASSERTE(!"Writer lock not held by the current thread");
-    return(FALSE);
-}
-#endif
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::AssertWriterLockNotHeld    public
-//
-//  Synopsis:   Asserts that writer lock is not held
-// 
-//+-------------------------------------------------------------------
-#ifdef _DEBUG
-BOOL CRWLock::AssertWriterLockNotHeld()
-{
-    CONTRACTL
-    {
-        NOTHROW;         
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    if(_dwWriterID != GetThread()->GetThreadId())
-        return(TRUE);
-
-    _ASSERTE(!"Writer lock held by the current thread");
-    return(FALSE);
-}
-#endif
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::AssertReaderLockHeld    public
-//
-//  Synopsis:   Asserts that reader lock is held
-// 
-//+-------------------------------------------------------------------
-#ifdef _DEBUG
-BOOL CRWLock::AssertReaderLockHeld()
-{
-    CONTRACTL
-    {
-        NOTHROW;         
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    LockEntry *pLockEntry = GetLockEntry();
-    if(pLockEntry)
-    {
-        _ASSERTE(pLockEntry->wReaderLevel);
-        return(TRUE);
-    }
-
-    _ASSERTE(!"Reader lock not held by the current thread");
-    return(FALSE);
-}
-#endif
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::AssertReaderLockNotHeld    public
-//
-//  Synopsis:   Asserts that writer lock is not held
-// 
-//+-------------------------------------------------------------------
-#ifdef _DEBUG
-BOOL CRWLock::AssertReaderLockNotHeld()
-{
-    CONTRACTL
-    {
-        NOTHROW;         
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    LockEntry *pLockEntry = GetLockEntry();
-    if(pLockEntry == NULL)
-        return(TRUE);
-
-    _ASSERTE(pLockEntry->wReaderLevel);
-    _ASSERTE(!"Reader lock held by the current thread");
-
-    return(FALSE);
-}
-#endif
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::AssertReaderOrWriterLockHeld   public
-//
-//  Synopsis:   Asserts that writer lock is not held
-// 
-//+-------------------------------------------------------------------
-#ifdef _DEBUG
-BOOL CRWLock::AssertReaderOrWriterLockHeld()
-{
-    CONTRACTL
-    {
-        NOTHROW;         
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    if(_dwWriterID == GetThread()->GetThreadId())
-    {
-        return(TRUE);
-    }
-    else
-    {
-        LockEntry *pLockEntry = GetLockEntry();
-        if(pLockEntry)
-        {
-            _ASSERTE(pLockEntry->wReaderLevel);
-            return(TRUE);
-        }
-    }
-
-    _ASSERTE(!"Neither Reader nor Writer lock held");
-    return(FALSE);
-}
-#endif
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::RWSetEvent    private
-//
-//  Synopsis:   Helper function for setting an event
-// 
-//+-------------------------------------------------------------------
-inline void CRWLock::RWSetEvent(CLREvent* event)
-{
-    CONTRACTL
-    {
-        THROWS;         
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-
-    if(!event->Set())
-    {
-        _ASSERTE(!"SetEvent failed");
-        if(fBreakOnErrors) // fBreakOnErrors == FALSE so will be optimized out.
-            DebugBreak();
-        COMPlusThrowWin32(E_UNEXPECTED);
-    }
-}
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::RWResetEvent    private
-//
-//  Synopsis:   Helper function for resetting an event
-// 
-//+-------------------------------------------------------------------
-inline void CRWLock::RWResetEvent(CLREvent* event)
-{
-    CONTRACTL
-    {
-      THROWS;         
-      GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-
-    if(!event->Reset())
-    {
-        _ASSERTE(!"ResetEvent failed");
-        if(fBreakOnErrors) // fBreakOnErrors == FALSE so will be optimized out.
-            DebugBreak();
-        COMPlusThrowWin32(E_UNEXPECTED);
-    }
-}
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::RWWaitForSingleObject    public
-//
-//  Synopsis:   Helper function for waiting on an event
-// 
-//+-------------------------------------------------------------------
-inline DWORD CRWLock::RWWaitForSingleObject(CLREvent* event, DWORD dwTimeout)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-
-    DWORD status = WAIT_FAILED;
-    EX_TRY
-    {
-        status = event->Wait(dwTimeout,TRUE);
-    }
-    EX_CATCH
-    {
-        status = GET_EXCEPTION()->GetHR();
-        if (status == S_OK)
-        {
-            status = WAIT_FAILED;
-        }
-    }
-    EX_END_CATCH(SwallowAllExceptions);  // The caller will rethrow the exception
-
-    return status;
-}
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::RWSleep    public
-//
-//  Synopsis:   Helper function for calling Sleep
-// 
-//+-------------------------------------------------------------------
-inline void CRWLock::RWSleep(DWORD dwTime)
-{
-    CONTRACTL
-    {
-        NOTHROW;         
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    ClrSleepEx(dwTime, TRUE);
-}
-
-
-#undef volatile
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::RWInterlockedCompareExchange    public
-//
-//  Synopsis:   Helper function for calling intelockedCompareExchange
-// 
-//+-------------------------------------------------------------------
-inline LONG CRWLock::RWInterlockedCompareExchange(LONG volatile *pvDestination,
-                                                   LONG dwExchange,
-                                                   LONG dwComparand)
-{
-    CONTRACTL
-    {
-        NOTHROW;         
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    return  FastInterlockCompareExchange(pvDestination, 
-                                         dwExchange, 
-                                         dwComparand);
-}
-
-inline LONGLONG CRWLock::RWInterlockedCompareExchange64(LONGLONG volatile *pvDestination,
-                                                        LONGLONG qwExchange,
-                                                        LONGLONG qwComparand)
-{
-    CONTRACTL
-    {
-        NOTHROW;         
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    return  FastInterlockCompareExchangeLong(pvDestination, qwExchange, qwComparand);
-}
-
-inline void* CRWLock::RWInterlockedCompareExchangePointer(PVOID volatile *pvDestination,
-                                                   void* pExchange,
-                                                   void* pComparand)
-{
-    CONTRACTL
-    {
-        NOTHROW;         
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    return  FastInterlockCompareExchangePointer(pvDestination, 
-                                            pExchange, 
-                                            pComparand);
-}
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::RWInterlockedExchangeAdd    public
-//
-//  Synopsis:   Helper function for adding state
-// 
-//+-------------------------------------------------------------------
-inline LONG CRWLock::RWInterlockedExchangeAdd(LONG volatile *pvDestination,
-                                               LONG dwAddToState)
-{
-    CONTRACTL
-    {
-        NOTHROW;         
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    return FastInterlockExchangeAdd(pvDestination, dwAddToState);
-}
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::RWInterlockedIncrement    public
-//
-//  Synopsis:   Helper function for incrementing a pointer
-// 
-//+-------------------------------------------------------------------
-inline LONG CRWLock::RWInterlockedIncrement(LONG volatile *pdwState)
-{
-    CONTRACTL
-    {
-        NOTHROW;         
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    return FastInterlockIncrement(pdwState);
-}
-
-#define volatile DoNotUserVolatileKeyword
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::ReleaseEvents    public
-//
-//  Synopsis:   Helper function for caching events
-// 
-//+-------------------------------------------------------------------
-void CRWLock::ReleaseEvents()
-{
-    CONTRACTL
-    {
-        NOTHROW;         
-        GC_TRIGGERS;
-        PRECONDITION(((_dwState & CACHING_EVENTS) == CACHING_EVENTS));        // Ensure that reader and writers have been stalled
-
-    }
-    CONTRACTL_END;
-
-    // Save writer event
-    CLREvent *hWriterEvent = _hWriterEvent;
-    _hWriterEvent = NULL;
-
-    // Save reader event
-    CLREvent *hReaderEvent = _hReaderEvent;
-    _hReaderEvent = NULL;
-
-    // Allow readers and writers to continue
-    RWInterlockedExchangeAdd(&_dwState, -(CACHING_EVENTS));
-
-    // Cache events
-    // <REVISIT_TODO>: 
-    //         I am closing events for now. What is needed
-    //         is an event cache to which the events are
-    //         released using InterlockedCompareExchange64</REVISIT_TODO>
-    if(hWriterEvent)
-    {
-        LOG((LF_SYNC, LL_INFO10, "Releasing writer event\n"));
-        delete hWriterEvent;
-    }
-    if(hReaderEvent)
-    {
-        LOG((LF_SYNC, LL_INFO10, "Releasing reader event\n"));
-        delete hReaderEvent;
-    }
-#ifdef RWLOCK_STATISTICS
-    RWInterlockedIncrement(&_dwEventsReleasedCount);
-#endif
-
-    return;
-}
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::GetWriterEvent    public
-//
-//  Synopsis:   Helper function for obtaining a auto reset event used
-//              for serializing writers. It utilizes event cache
-// 
-//+-------------------------------------------------------------------
-CLREvent* CRWLock::GetWriterEvent(HRESULT *pHR)
-{
-    CONTRACTL
-    {
-        NOTHROW;   
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-
-    *pHR = S_OK;
-    //GC could happen in ~CLREvent or EH. "this" is a GC object so it could be moved
-    //during GC. So we need to cache the field before GC could happen
-    CLREvent * result = _hWriterEvent;
-    
-    if(_hWriterEvent == NULL)
-    {
-        EX_TRY
-        {
-            CLREvent *pEvent = new CLREvent();
-            NewHolder<CLREvent> hWriterEvent (pEvent);
-            hWriterEvent->CreateRWLockWriterEvent(FALSE,this);
-            if(hWriterEvent)
-            {
-                if(RWInterlockedCompareExchangePointer((PVOID*) &_hWriterEvent,
-                                                hWriterEvent.GetValue(),        
-                                                NULL) == NULL)
-                {
-                    hWriterEvent.SuppressRelease();
-                }
-                //GC could happen in ~CLREvent or EH. "this" is a GC object so it could be moved
-                //during GC. So we need to cache the field before GC could happen.
-                result = _hWriterEvent;                
-            }
-        }
-        EX_CATCH
-        {
-            *pHR = GET_EXCEPTION()->GetHR();
-        }
-        EX_END_CATCH(SwallowAllExceptions);
-    }
-
-    return(result);
-}
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::GetReaderEvent    public
-//
-//  Synopsis:   Helper function for obtaining a manula reset event used
-//              by readers to wait when a writer holds the lock.
-//              It utilizes event cache
-// 
-//+-------------------------------------------------------------------
-CLREvent* CRWLock::GetReaderEvent(HRESULT *pHR)
-{
-    CONTRACTL
-    {
-        NOTHROW;   
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-
-    *pHR = S_OK;
-    //GC could happen in ~CLREvent or EH. "this" is a GC object so it could be moved
-    //during GC. So we need to cache the field before GC could happen
-    CLREvent * result = _hReaderEvent;
-
-    if(_hReaderEvent == NULL)
-    {
-        EX_TRY
-        {
-            CLREvent *pEvent = new CLREvent();
-            NewHolder<CLREvent> hReaderEvent (pEvent);
-            hReaderEvent->CreateRWLockReaderEvent(FALSE, this);
-            if(hReaderEvent)
-            {
-                if(RWInterlockedCompareExchangePointer((PVOID*) &_hReaderEvent,
-                                                hReaderEvent.GetValue(),
-                                                NULL) == NULL)
-                {
-                    hReaderEvent.SuppressRelease();
-                }                
-                //GC could happen in ~CLREvent or EH. "this" is a GC object so it could be moved
-                //during GC. So we need to cache the field before GC could happen
-                result = _hReaderEvent;                
-            }
-        }
-        EX_CATCH
-        {
-            *pHR = GET_EXCEPTION()->GetHR();
-        }
-        EX_END_CATCH(SwallowAllExceptions);
-    }
-
-    return(result);
-}
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::StaticRecoverLock    public
-//
-//  Synopsis:   Helper function to restore the lock to 
-//              the original state
-//
-
-//
-//+-------------------------------------------------------------------
-void CRWLock::StaticRecoverLock(
-    CRWLock **ppRWLock, 
-    LockCookie *pLockCookie,
-    DWORD dwFlags)
-{
-    CONTRACTL
-    {
-      THROWS;               // StaticAcquireWriterLock can throw exception     
-      GC_TRIGGERS;
-      CAN_TAKE_LOCK;
-    }
-    CONTRACTL_END;
-        
-    DWORD dwTimeout = (gdwDefaultTimeout > gdwReasonableTimeout)
-                        ? gdwDefaultTimeout
-                        : gdwReasonableTimeout;
-
-    Thread *pThread = GetThread();
-    _ASSERTE (pThread);
-
-    EX_TRY
-    {
-        // Check if the thread was a writer
-        if(dwFlags & COOKIE_WRITER)
-        {
-            // Acquire writer lock
-            StaticAcquireWriterLock(ppRWLock, dwTimeout);
-            _ASSERTE (pThread->m_dwLockCount >= (*ppRWLock)->_wWriterLevel);
-            ASSERT_UNLESS_NO_DEBUG_STATE(__pClrDebugState->GetLockCount(kDbgStateLockType_User) >= (*ppRWLock)->_wWriterLevel);
-            pThread->m_dwLockCount -= (*ppRWLock)->_wWriterLevel;
-            USER_LOCK_RELEASED_MULTIPLE((*ppRWLock)->_wWriterLevel, GetPtrForLockContract(ppRWLock));
-            (*ppRWLock)->_wWriterLevel = pLockCookie->wWriterLevel;
-            pThread->m_dwLockCount += (*ppRWLock)->_wWriterLevel;
-            USER_LOCK_TAKEN_MULTIPLE((*ppRWLock)->_wWriterLevel, GetPtrForLockContract(ppRWLock));
-        }
-        // Check if the thread was a reader
-        else if(dwFlags & COOKIE_READER)
-        {
-            StaticAcquireReaderLock(ppRWLock, dwTimeout);
-            LockEntry *pLockEntry = (*ppRWLock)->GetLockEntry();
-            _ASSERTE(pLockEntry);
-            _ASSERTE (pThread->m_dwLockCount >= pLockEntry->wReaderLevel);
-            ASSERT_UNLESS_NO_DEBUG_STATE(__pClrDebugState->GetLockCount(kDbgStateLockType_User) >= pLockEntry->wReaderLevel);
-            pThread->m_dwLockCount -= pLockEntry->wReaderLevel;
-            USER_LOCK_RELEASED_MULTIPLE(pLockEntry->wReaderLevel, GetPtrForLockContract(ppRWLock));
-            pLockEntry->wReaderLevel = pLockCookie->wReaderLevel;
-            pThread->m_dwLockCount += pLockEntry->wReaderLevel;
-            USER_LOCK_TAKEN_MULTIPLE(pLockEntry->wReaderLevel, GetPtrForLockContract(ppRWLock));
-        }
-    }
-    EX_CATCH
-    {
-        // Removed an assert here. This error is expected in case of
-        // ThreadAbort.
-        COMPlusThrowWin32(RWLOCK_RECOVERY_FAILURE);
-    }
-    EX_END_CATCH_UNREACHABLE
-}
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::StaticAcquireReaderLockPublic    public
-//
-//  Synopsis:   Public access to StaticAcquireReaderLock
-//
-//+-------------------------------------------------------------------
-FCIMPL2(void, CRWLock::StaticAcquireReaderLockPublic, CRWLock *pRWLockUNSAFE, DWORD dwDesiredTimeout)
-{
-    FCALL_CONTRACT;
-
-    if (pRWLockUNSAFE == NULL)
-    {
-        FCThrowVoid(kNullReferenceException);
-    }
-
-    OBJECTREF pRWLock = ObjectToOBJECTREF((Object*)pRWLockUNSAFE);
-    HELPER_METHOD_FRAME_BEGIN_1(pRWLock);
-
-    StaticAcquireReaderLock((CRWLock**)&pRWLock, dwDesiredTimeout);
-
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::StaticAcquireReaderLock    private
-//
-//  Synopsis:   Makes the thread a reader. Supports nested reader locks.
-// 
-//+-------------------------------------------------------------------
-
-void CRWLock::StaticAcquireReaderLock(
-    CRWLock **ppRWLock, 
-    DWORD dwDesiredTimeout)
-{
-
-    CONTRACTL
-    {
-        THROWS;               
-        GC_TRIGGERS;            // CLREvent::Wait is GC_TRIGGERS
-        CAN_TAKE_LOCK;
-        PRECONDITION(CheckPointer(ppRWLock));
-        PRECONDITION(CheckPointer(*ppRWLock));
-    }
-    CONTRACTL_END;
-
-    TESTHOOKCALL(AppDomainCanBeUnloaded(GetThread()->GetDomain()->GetId().m_dwId,FALSE));    
-
-    if (GetThread()->IsAbortRequested()) {
-        GetThread()->HandleThreadAbort();
-    }
-
-    LockEntry *pLockEntry = (*ppRWLock)->FastGetOrCreateLockEntry();
-    if (pLockEntry == NULL)
-    {
-        COMPlusThrowWin32(STATUS_NO_MEMORY);
-    }
-    
-    DWORD dwStatus = WAIT_OBJECT_0;
-    // Check for the fast path
-    if(RWInterlockedCompareExchange(&(*ppRWLock)->_dwState, READER, 0) == 0)
-    {
-        _ASSERTE(pLockEntry->wReaderLevel == 0);
-    }
-    // Check for nested reader
-    else if(pLockEntry->wReaderLevel != 0)
-    {
-        _ASSERTE((*ppRWLock)->_dwState & READERS_MASK);
-
-        if (pLockEntry->wReaderLevel == RWLOCK_MAX_ACQUIRE_COUNT) {
-            COMPlusThrow(kOverflowException, W("Overflow_UInt16"));        
-        }
-        ++pLockEntry->wReaderLevel;
-        INCTHREADLOCKCOUNT();
-        USER_LOCK_TAKEN(GetPtrForLockContract(ppRWLock));
-        return;
-    }
-    // Check if the thread already has writer lock
-    else if((*ppRWLock)->_dwWriterID == GetThread()->GetThreadId())
-    {
-        StaticAcquireWriterLock(ppRWLock, dwDesiredTimeout);
-        (*ppRWLock)->FastRecycleLockEntry(pLockEntry);
-        return;
-    }
-    else
-    {
-        DWORD dwSpinCount;
-        DWORD dwCurrentState, dwKnownState;
-        
-        // Initialize
-        dwSpinCount = 0;
-        dwCurrentState = (*ppRWLock)->_dwState;
-        do
-        {
-            dwKnownState = dwCurrentState;
-
-            // Reader need not wait if there are only readers and no writer
-            if((dwKnownState < READERS_MASK) ||
-                (((dwKnownState & READER_SIGNALED) && ((dwKnownState & WRITER) == 0)) &&
-                 (((dwKnownState & READERS_MASK) +
-                   ((dwKnownState & WAITING_READERS_MASK) >> WAITING_READERS_SHIFT)) <=
-                  (READERS_MASK - 2))))
-            {
-                // Add to readers
-                dwCurrentState = RWInterlockedCompareExchange(&(*ppRWLock)->_dwState,
-                                                              (dwKnownState + READER),
-                                                              dwKnownState);
-                if(dwCurrentState == dwKnownState)
-                {
-                    // One more reader
-                    break;
-                }
-            }
-            // Check for too many Readers or waiting readers or signaling in progress
-            else if(((dwKnownState & READERS_MASK) == READERS_MASK) ||
-                    ((dwKnownState & WAITING_READERS_MASK) == WAITING_READERS_MASK) ||
-                    ((dwKnownState & CACHING_EVENTS) == READER_SIGNALED))
-            {
-                //  Sleep
-                GetThread()->UserSleep(1000);
-                
-                // Update to latest state
-                dwSpinCount = 0;
-                dwCurrentState = (*ppRWLock)->_dwState;
-            }
-            // Check if events are being cached
-            else if((dwKnownState & CACHING_EVENTS) == CACHING_EVENTS)
-            {
-                if(++dwSpinCount > gdwDefaultSpinCount)
-                {
-                    RWSleep(1);
-                    dwSpinCount = 0;
-                }
-                dwCurrentState = (*ppRWLock)->_dwState;
-            }
-            // Check spin count
-            else if(++dwSpinCount <= gdwDefaultSpinCount)
-            {
-                dwCurrentState = (*ppRWLock)->_dwState;
-            }
-            else
-            {
-                // Add to waiting readers
-                dwCurrentState = RWInterlockedCompareExchange(&(*ppRWLock)->_dwState,
-                                                              (dwKnownState + WAITING_READER),
-                                                              dwKnownState);
-                if(dwCurrentState == dwKnownState)
-                {
-                    CLREvent* hReaderEvent;
-                    DWORD dwModifyState;
-
-                    // One more waiting reader
-#ifdef RWLOCK_STATISTICS
-                    RWInterlockedIncrement(&(*ppRWLock)->_dwReaderContentionCount);
-#endif
-                    HRESULT hr;
-                    hReaderEvent = (*ppRWLock)->GetReaderEvent(&hr);
-                    if(hReaderEvent)
-                    {
-                        dwStatus = RWWaitForSingleObject(hReaderEvent, dwDesiredTimeout);
-                        VALIDATE_LOCK(*ppRWLock);
-
-                        // StaticAcquireReaderLock can have reentry via pumping while waiting for 
-                        // hReaderEvent, which may change pLockEntry's state from underneath us.
-                        if ((pLockEntry->dwLLockID != (*ppRWLock)->_dwLLockID) || 
-                            (pLockEntry->dwULockID != (*ppRWLock)->_dwULockID))
-                        {
-                            pLockEntry = (*ppRWLock)->FastGetOrCreateLockEntry();
-                            if (pLockEntry == NULL)
-                            {
-                                COMPlusThrowWin32(STATUS_NO_MEMORY);
-                            }
-                        }
-                    }
-                    else
-                    {
-                        LOG((LF_SYNC, LL_WARNING,
-                            "AcquireReaderLock failed to create reader "
-                            "event for RWLock 0x%x\n", *ppRWLock));
-                        dwStatus = E_FAIL;
-                    }
-
-                    if(dwStatus == WAIT_OBJECT_0)
-                    {
-                        _ASSERTE((*ppRWLock)->_dwState & READER_SIGNALED);
-                        _ASSERTE(((*ppRWLock)->_dwState & READERS_MASK) < READERS_MASK);
-                        dwModifyState = READER - WAITING_READER;
-                    }
-                    else
-                    {
-                        dwModifyState = (DWORD) -WAITING_READER;
-                        if(dwStatus == WAIT_TIMEOUT)
-                        {
-                            LOG((LF_SYNC, LL_WARNING,
-                                "Timed out trying to acquire reader lock "
-                                "for RWLock 0x%x\n", *ppRWLock));
-                            hr = HRESULT_FROM_WIN32(ERROR_TIMEOUT);
-                        }
-                        else if(dwStatus == WAIT_IO_COMPLETION)
-                        {
-                            LOG((LF_SYNC, LL_WARNING,
-                                "Thread interrupted while trying to acquire reader lock "
-                                "for RWLock 0x%x\n", *ppRWLock));
-                            hr = COR_E_THREADINTERRUPTED;
-                        }
-                        else if (dwStatus == WAIT_FAILED)
-                        {
-                            if (SUCCEEDED(hr))
-                            {
-                                dwStatus = GetLastError();
-                                if (dwStatus == WAIT_OBJECT_0)
-                                {
-                                    dwStatus = WAIT_FAILED;
-                                }
-                                hr = HRESULT_FROM_WIN32(dwStatus);
-                                LOG((LF_SYNC, LL_WARNING,
-                                    "WaitForSingleObject on Event 0x%x failed for "
-                                    "RWLock 0x%x with status code 0x%x\n",
-                                    hReaderEvent, *ppRWLock, dwStatus));
-                            }
-                        }
-                    }
-
-                    // One less waiting reader and he may have become a reader
-                    dwKnownState = RWInterlockedExchangeAdd(&(*ppRWLock)->_dwState, dwModifyState);
-
-                    // Check for last signaled waiting reader
-                    if(dwStatus == WAIT_OBJECT_0)
-                    {
-                        _ASSERTE(dwKnownState & READER_SIGNALED);
-                        _ASSERTE((dwKnownState & READERS_MASK) < READERS_MASK);
-                        if((dwKnownState & WAITING_READERS_MASK) == WAITING_READER)
-                        {
-                            // Reset the event and lower reader signaled flag
-                            RWResetEvent(hReaderEvent);
-                            RWInterlockedExchangeAdd(&(*ppRWLock)->_dwState, -READER_SIGNALED);
-                        }
-                    }
-                    else
-                    {
-                        if(((dwKnownState & WAITING_READERS_MASK) == WAITING_READER) &&
-                           (dwKnownState & READER_SIGNALED))
-                        {
-                            HRESULT hr1;
-                            if(hReaderEvent == NULL)
-                                hReaderEvent = (*ppRWLock)->GetReaderEvent(&hr1);
-                            _ASSERTE(hReaderEvent);
-
-                            // Ensure the event is signalled before resetting it.
-                            DWORD dwTemp;
-                            dwTemp = hReaderEvent->Wait(INFINITE, FALSE);
-                            _ASSERTE(dwTemp == WAIT_OBJECT_0);
-                            _ASSERTE(((*ppRWLock)->_dwState & READERS_MASK) < READERS_MASK);
-                            
-                            // Reset the event and lower reader signaled flag
-                            RWResetEvent(hReaderEvent);
-                            RWInterlockedExchangeAdd(&(*ppRWLock)->_dwState, (READER - READER_SIGNALED));
-
-                            // Honor the orginal status
-                            ++pLockEntry->wReaderLevel;
-                            INCTHREADLOCKCOUNT();
-                            USER_LOCK_TAKEN(GetPtrForLockContract(ppRWLock));
-                            StaticReleaseReaderLock(ppRWLock);
-                        }
-                        else
-                        {
-                            (*ppRWLock)->FastRecycleLockEntry(pLockEntry);
-                        }
-                        
-                        _ASSERTE((pLockEntry == NULL) ||
-                                 ((pLockEntry->dwLLockID == 0) &&
-                                  (pLockEntry->wReaderLevel == 0)));
-                        if(fBreakOnErrors)  // fBreakOnErrors == FALSE so will be optimized out.
-                        {
-                            _ASSERTE(!"Failed to acquire reader lock");
-                            DebugBreak();
-                        }
-                        
-                        // Prepare the frame for throwing an exception
-                        if ((DWORD)HOST_E_DEADLOCK == dwStatus)
-                        {
-                            // So that the error message is in the exception.
-                            RaiseDeadLockException();
-                        } else if ((DWORD)COR_E_THREADINTERRUPTED == dwStatus) {
-                            COMPlusThrow(kThreadInterruptedException);
-                        }
-                        else
-                        {
-                            COMPlusThrowWin32 (hr);
-                        }
-                    }
-
-                    // Sanity check
-                    _ASSERTE(dwStatus == WAIT_OBJECT_0);
-                    break;                        
-                }
-            }
-            YieldProcessor();           // Indicate to the processor that we are spining
-        } while(TRUE);
-    }
-
-    // Success
-    _ASSERTE(dwStatus == WAIT_OBJECT_0);
-    _ASSERTE(((*ppRWLock)->_dwState & WRITER) == 0);
-    _ASSERTE((*ppRWLock)->_dwState & READERS_MASK);
-    ++pLockEntry->wReaderLevel;
-    INCTHREADLOCKCOUNT();
-    USER_LOCK_TAKEN(GetPtrForLockContract(ppRWLock));
-#ifdef RWLOCK_STATISTICS
-    RWInterlockedIncrement(&(*ppRWLock)->_dwReaderEntryCount);
-#endif
-    return;
-}
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::StaticAcquireWriterLockPublic    public
-//
-//  Synopsis:   Public access to StaticAcquireWriterLock
-//
-//+-------------------------------------------------------------------
-FCIMPL2(void, CRWLock::StaticAcquireWriterLockPublic, CRWLock *pRWLockUNSAFE, DWORD dwDesiredTimeout)
-{
-    FCALL_CONTRACT;
-
-    if (pRWLockUNSAFE == NULL)
-    {
-        FCThrowVoid(kNullReferenceException);
-    }
-
-    OBJECTREF pRWLock = ObjectToOBJECTREF((Object*)pRWLockUNSAFE);
-    HELPER_METHOD_FRAME_BEGIN_1(pRWLock);
-
-    StaticAcquireWriterLock((CRWLock**)&pRWLock, dwDesiredTimeout);
-
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::StaticAcquireWriterLock    private
-//
-//  Synopsis:   Makes the thread a writer. Supports nested writer
-//              locks
-// 
-//+-------------------------------------------------------------------
-
-void CRWLock::StaticAcquireWriterLock(
-    CRWLock **ppRWLock, 
-    DWORD dwDesiredTimeout)
-{
-    CONTRACTL
-    {
-        THROWS;               
-        GC_TRIGGERS;            // CLREvent::Wait can trigger GC
-        CAN_TAKE_LOCK;
-        PRECONDITION((CheckPointer(ppRWLock)));
-        PRECONDITION((CheckPointer(*ppRWLock)));
-    }
-    CONTRACTL_END;
-
-    TESTHOOKCALL(AppDomainCanBeUnloaded(GetThread()->GetDomain()->GetId().m_dwId,FALSE));    
-    if (GetThread()->IsAbortRequested()) {
-        GetThread()->HandleThreadAbort();
-    }
-
-    // Declare locals needed for setting up frame
-    DWORD dwThreadID = GetThread()->GetThreadId();
-    DWORD dwStatus;
-
-    // Check for the fast path
-    if(RWInterlockedCompareExchange(&(*ppRWLock)->_dwState, WRITER, 0) == 0)
-    {
-        _ASSERTE(((*ppRWLock)->_dwState & READERS_MASK) == 0);
-    }
-    // Check if the thread already has writer lock
-    else if((*ppRWLock)->_dwWriterID == dwThreadID)
-    {
-        if ((*ppRWLock)->_wWriterLevel == RWLOCK_MAX_ACQUIRE_COUNT) {
-            COMPlusThrow(kOverflowException, W("Overflow_UInt16"));        
-        }
-        ++(*ppRWLock)->_wWriterLevel;
-        INCTHREADLOCKCOUNT();
-        USER_LOCK_TAKEN(GetPtrForLockContract(ppRWLock));
-        return;
-    }
-    else
-    {
-        DWORD dwCurrentState, dwKnownState;
-        DWORD dwSpinCount;
-
-        // Initialize
-        dwSpinCount = 0;
-        dwCurrentState = (*ppRWLock)->_dwState;
-        do
-        {
-            dwKnownState = dwCurrentState;
-
-            // Writer need not wait if there are no readers and writer
-            if((dwKnownState == 0) || (dwKnownState == CACHING_EVENTS))
-            {
-                // Can be a writer
-                dwCurrentState = RWInterlockedCompareExchange(&(*ppRWLock)->_dwState,
-                                                              (dwKnownState + WRITER),
-                                                              dwKnownState);
-                if(dwCurrentState == dwKnownState)
-                {
-                    // Only writer
-                    break;
-                }
-            }
-            // Check for too many waiting writers
-            else if(((dwKnownState & WAITING_WRITERS_MASK) == WAITING_WRITERS_MASK))
-            {
-                // Sleep
-                GetThread()->UserSleep(1000);
-                
-                // Update to latest state
-                dwSpinCount = 0;
-                dwCurrentState = (*ppRWLock)->_dwState;
-            }
-            // Check if events are being cached
-            else if((dwKnownState & CACHING_EVENTS) == CACHING_EVENTS)
-            {
-                if(++dwSpinCount > gdwDefaultSpinCount)
-                {
-                    RWSleep(1);
-                    dwSpinCount = 0;
-                }
-                dwCurrentState = (*ppRWLock)->_dwState;
-            }
-            // Check spin count
-            else if(++dwSpinCount <= gdwDefaultSpinCount)
-            {
-                dwCurrentState = (*ppRWLock)->_dwState;
-            }
-            else
-            {
-                // Add to waiting writers
-                dwCurrentState = RWInterlockedCompareExchange(&(*ppRWLock)->_dwState,
-                                                              (dwKnownState + WAITING_WRITER),
-                                                              dwKnownState);
-                if(dwCurrentState == dwKnownState)
-                {
-                    CLREvent* hWriterEvent;
-                    DWORD dwModifyState;
-
-                    // One more waiting writer
-#ifdef RWLOCK_STATISTICS
-                    RWInterlockedIncrement(&(*ppRWLock)->_dwWriterContentionCount);
-#endif
-                    HRESULT hr;
-                    hWriterEvent = (*ppRWLock)->GetWriterEvent(&hr);
-                    if(hWriterEvent)
-                    {
-                        dwStatus = RWWaitForSingleObject(hWriterEvent, dwDesiredTimeout);
-                        VALIDATE_LOCK(*ppRWLock);
-                    }
-                    else
-                    {
-                        LOG((LF_SYNC, LL_WARNING,
-                            "AcquireWriterLock failed to create writer "
-                            "event for RWLock 0x%x\n", *ppRWLock));
-                        dwStatus = WAIT_FAILED;
-                    }
-
-                    if(dwStatus == WAIT_OBJECT_0)
-                    {
-                        _ASSERTE((*ppRWLock)->_dwState & WRITER_SIGNALED);
-                        dwModifyState = WRITER - WAITING_WRITER - WRITER_SIGNALED;
-                    }
-                    else
-                    {
-                        dwModifyState = (DWORD) -WAITING_WRITER;
-                        if(dwStatus == WAIT_TIMEOUT)
-                        {
-                            LOG((LF_SYNC, LL_WARNING,
-                                "Timed out trying to acquire writer "
-                                "lock for RWLock 0x%x\n", *ppRWLock));
-                            hr = HRESULT_FROM_WIN32 (ERROR_TIMEOUT);
-                        }
-                        else if(dwStatus == WAIT_IO_COMPLETION)
-                        {
-                            LOG((LF_SYNC, LL_WARNING,
-                                "Thread interrupted while trying to acquire writer lock "
-                                "for RWLock 0x%x\n", *ppRWLock));
-                            hr = COR_E_THREADINTERRUPTED;
-                        }
-                        else if (dwStatus == WAIT_FAILED)
-                        {
-                            if (SUCCEEDED(hr))
-                            {
-                                dwStatus = GetLastError();
-                                if (dwStatus == WAIT_OBJECT_0)
-                                {
-                                    dwStatus = WAIT_FAILED;
-                                }
-                                hr = HRESULT_FROM_WIN32(dwStatus);
-                                LOG((LF_SYNC, LL_WARNING,
-                                    "WaitForSingleObject on Event 0x%x failed for "
-                                    "RWLock 0x%x with status code 0x%x",
-                                    hWriterEvent, *ppRWLock, dwStatus));
-                            }
-                        }
-                    }
-
-                    // One less waiting writer and he may have become a writer
-                    dwKnownState = RWInterlockedExchangeAdd(&(*ppRWLock)->_dwState, dwModifyState);
-
-                    // Check for last timing out signaled waiting writer
-                    if(dwStatus == WAIT_OBJECT_0)
-                    {
-                        // Common case
-                    }
-                    else
-                    {
-                        if((dwKnownState & WRITER_SIGNALED) &&
-                           ((dwKnownState & WAITING_WRITERS_MASK) == WAITING_WRITER))
-                        {
-                            HRESULT hr1;
-                            if(hWriterEvent == NULL)
-                                hWriterEvent = (*ppRWLock)->GetWriterEvent(&hr1);
-                            _ASSERTE(hWriterEvent);
-                            do
-                            {
-                                dwKnownState = (*ppRWLock)->_dwState;
-                                if((dwKnownState & WRITER_SIGNALED) &&
-                                   ((dwKnownState & WAITING_WRITERS_MASK) == 0))
-                                {
-                                    DWORD dwTemp = hWriterEvent->Wait(10, FALSE);
-                                    if(dwTemp == WAIT_OBJECT_0)
-                                    {
-                                        dwKnownState = RWInterlockedExchangeAdd(&(*ppRWLock)->_dwState, (WRITER - WRITER_SIGNALED));
-                                        _ASSERTE(dwKnownState & WRITER_SIGNALED);
-                                        _ASSERTE((dwKnownState & WRITER) == 0);
-
-                                        // Honor the orginal status
-                                        (*ppRWLock)->_dwWriterID = dwThreadID;
-                                        Thread *pThread = GetThread();
-                                        _ASSERTE (pThread);
-                                        _ASSERTE ((*ppRWLock)->_wWriterLevel == 0);
-                                        pThread->m_dwLockCount ++;
-                                        USER_LOCK_TAKEN(GetPtrForLockContract(ppRWLock));
-                                        (*ppRWLock)->_wWriterLevel = 1;
-                                        StaticReleaseWriterLock(ppRWLock);
-                                        break;
-                                    }
-                                    // else continue;
-                                }
-                                else
-                                    break;
-                            }while(TRUE);
-                        }
-
-                        if(fBreakOnErrors) // fBreakOnErrors == FALSE so will be optimized out.
-                        {
-                            _ASSERTE(!"Failed to acquire writer lock");
-                            DebugBreak();
-                        }
-                        
-                        // Prepare the frame for throwing an exception
-                        if ((DWORD)HOST_E_DEADLOCK == dwStatus)
-                        {
-                            // So that the error message is in the exception.
-                            RaiseDeadLockException();
-                        } else if ((DWORD)COR_E_THREADINTERRUPTED == dwStatus) {
-                            COMPlusThrow(kThreadInterruptedException);
-                        }
-                        else
-                        {
-                            COMPlusThrowWin32(hr);
-                        }
-                    }
-
-                    // Sanity check
-                    _ASSERTE(dwStatus == WAIT_OBJECT_0);
-                    break;
-                }
-            }
-            YieldProcessor();       // indicate to the processor that we are spinning 
-        } while(TRUE);
-    }
-
-    // Success
-    _ASSERTE((*ppRWLock)->_dwState & WRITER);
-    _ASSERTE(((*ppRWLock)->_dwState & READERS_MASK) == 0);
-    _ASSERTE((*ppRWLock)->_dwWriterID == 0);
-
-    // Save threadid of the writer
-    (*ppRWLock)->_dwWriterID = dwThreadID;
-    (*ppRWLock)->_wWriterLevel = 1;
-    INCTHREADLOCKCOUNT();
-    USER_LOCK_TAKEN(GetPtrForLockContract(ppRWLock));
-    ++(*ppRWLock)->_dwWriterSeqNum;
-#ifdef RWLOCK_STATISTICS
-    ++(*ppRWLock)->_dwWriterEntryCount;
-#endif
-    return;
-}
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::StaticReleaseWriterLockPublic    public
-//
-//  Synopsis:   Public access to StaticReleaseWriterLock
-//
-//+-------------------------------------------------------------------
-FCIMPL1(void, CRWLock::StaticReleaseWriterLockPublic, CRWLock *pRWLockUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    if (pRWLockUNSAFE == NULL)
-    {
-        FCThrowVoid(kNullReferenceException);
-    }
-
-    OBJECTREF pRWLock = ObjectToOBJECTREF((Object*)pRWLockUNSAFE);
-
-    HELPER_METHOD_FRAME_BEGIN_ATTRIB_1(Frame::FRAME_ATTR_NO_THREAD_ABORT, pRWLock);
-
-    // We don't want to block thread abort when we need to construct exception in
-    // unwind-continue handler.
-    // note that we cannot use this holder in FCALLs outside our HMF since it breaks the epilog walker on x86!
-    ThreadPreventAbortHolder preventAbortIn;
-
-    StaticReleaseWriterLock((CRWLock**)&pRWLock);
-
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::StaticReleaseWriterLock    private
-//
-//  Synopsis:   Removes the thread as a writer if not a nested
-//              call to release the lock
-// 
-//+-------------------------------------------------------------------
-void CRWLock::StaticReleaseWriterLock(
-    CRWLock **ppRWLock)
-{
-
-    CONTRACTL
-    {
-        THROWS;               
-        GC_TRIGGERS;
-        PRECONDITION((CheckPointer(ppRWLock)));
-        PRECONDITION((CheckPointer(*ppRWLock)));
-    }
-    CONTRACTL_END;
-
-    DWORD dwThreadID = GetThread()->GetThreadId();
-
-    // Check validity of caller
-    if((*ppRWLock)->_dwWriterID == dwThreadID)
-    {
-        DECTHREADLOCKCOUNT();
-        USER_LOCK_RELEASED(GetPtrForLockContract(ppRWLock));
-        // Check for nested release
-        if(--(*ppRWLock)->_wWriterLevel == 0)
-        {
-            DWORD dwCurrentState, dwKnownState, dwModifyState;
-            BOOL fCacheEvents;
-            CLREvent* hReaderEvent = NULL, *hWriterEvent = NULL;
-
-            // Not a writer any more
-            (*ppRWLock)->_dwWriterID = 0;
-            dwCurrentState = (*ppRWLock)->_dwState;
-            do
-            {
-                dwKnownState = dwCurrentState;
-                dwModifyState = (DWORD) -WRITER;
-                fCacheEvents = FALSE;
-                if(dwKnownState & WAITING_READERS_MASK)
-                {
-                    HRESULT hr;
-                    hReaderEvent = (*ppRWLock)->GetReaderEvent(&hr);
-                    if(hReaderEvent == NULL)
-                    {
-                        LOG((LF_SYNC, LL_WARNING,
-                            "ReleaseWriterLock failed to create "
-                            "reader event for RWLock 0x%x\n", *ppRWLock));
-                        RWSleep(100);
-                        dwCurrentState = (*ppRWLock)->_dwState;
-                        dwKnownState = 0;
-                        _ASSERTE(dwCurrentState != dwKnownState);
-                        continue;
-                    }
-                    dwModifyState += READER_SIGNALED;
-                }
-                else if(dwKnownState & WAITING_WRITERS_MASK)
-                {
-                    HRESULT hr;
-                    hWriterEvent = (*ppRWLock)->GetWriterEvent(&hr);
-                    if(hWriterEvent == NULL)
-                    {
-                        LOG((LF_SYNC, LL_WARNING,
-                            "ReleaseWriterLock failed to create "
-                            "writer event for RWLock 0x%x\n", *ppRWLock));
-                        RWSleep(100);
-                        dwCurrentState = (*ppRWLock)->_dwState;
-                        dwKnownState = 0;
-                        _ASSERTE(dwCurrentState != dwKnownState);
-                        continue;
-                    }
-                    dwModifyState += WRITER_SIGNALED;
-                }
-                else if(((*ppRWLock)->_hReaderEvent || (*ppRWLock)->_hWriterEvent) &&
-                        (dwKnownState == WRITER))
-                {
-                    fCacheEvents = TRUE;
-                    dwModifyState += CACHING_EVENTS;
-                }
-
-                // Sanity checks
-                _ASSERTE((dwKnownState & READERS_MASK) == 0);
-
-                dwCurrentState = RWInterlockedCompareExchange(&(*ppRWLock)->_dwState,
-                                                              (dwKnownState + dwModifyState),
-                                                              dwKnownState);
-            } while(dwCurrentState != dwKnownState);
-
-            // Check for waiting readers
-            if(dwKnownState & WAITING_READERS_MASK)
-            {
-                _ASSERTE((*ppRWLock)->_dwState & READER_SIGNALED);
-                _ASSERTE(hReaderEvent);
-                RWSetEvent(hReaderEvent);
-            }
-            // Check for waiting writers
-            else if(dwKnownState & WAITING_WRITERS_MASK)
-            {
-                _ASSERTE((*ppRWLock)->_dwState & WRITER_SIGNALED);
-                _ASSERTE(hWriterEvent);
-                RWSetEvent(hWriterEvent);
-            }
-            // Check for the need to release events
-            else if(fCacheEvents)
-            {
-                (*ppRWLock)->ReleaseEvents();
-            }
-            
-            Thread *pThread = GetThread();
-            TESTHOOKCALL(AppDomainCanBeUnloaded(pThread->GetDomain()->GetId().m_dwId,FALSE));    
-            if (pThread->IsAbortRequested()) {
-                pThread->HandleThreadAbort();
-            }
-
-        }
-    }
-    else
-    {
-        if(fBreakOnErrors) // fBreakOnErrors == FALSE so will be optimized out.
-        {
-            _ASSERTE(!"Attempt to release writer lock on a wrong thread");
-            DebugBreak();
-        }
-        COMPlusThrowWin32(ERROR_NOT_OWNER);
-    }
-
-    return;
-}
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::StaticReleaseReaderLockPublic    public
-//
-//  Synopsis:   Public access to StaticReleaseReaderLock
-//
-//+-------------------------------------------------------------------
-FCIMPL1(void, CRWLock::StaticReleaseReaderLockPublic, CRWLock *pRWLockUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    if (pRWLockUNSAFE == NULL)
-    {
-        FCThrowVoid(kNullReferenceException);
-    }
-
-    OBJECTREF pRWLock = ObjectToOBJECTREF((Object*)pRWLockUNSAFE);
-    
-    HELPER_METHOD_FRAME_BEGIN_ATTRIB_1(Frame::FRAME_ATTR_NO_THREAD_ABORT, pRWLock);
-
-    // note that we cannot use this holder in FCALLs outside our HMF since it breaks the epilog walker on x86!
-    ThreadPreventAbortHolder preventAbortIn;
-
-    StaticReleaseReaderLock((CRWLock**)&pRWLock);
-
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::StaticReleaseReaderLock    private
-//
-//  Synopsis:   Removes the thread as a reader
-// 
-//+-------------------------------------------------------------------
-
-void CRWLock::StaticReleaseReaderLock(
-    CRWLock **ppRWLock)
-{
-    CONTRACTL
-    {
-        THROWS;               
-        GC_TRIGGERS;
-        PRECONDITION((CheckPointer(ppRWLock)));
-        PRECONDITION((CheckPointer(*ppRWLock)));
-    }
-    CONTRACTL_END;
-
-    // Check if the thread has writer lock
-    if((*ppRWLock)->_dwWriterID == GetThread()->GetThreadId())
-    {
-        StaticReleaseWriterLock(ppRWLock);
-    }
-    else
-    {
-        LockEntry *pLockEntry = (*ppRWLock)->GetLockEntry();
-        if(pLockEntry)
-        {
-            --pLockEntry->wReaderLevel;
-            DECTHREADLOCKCOUNT();
-            USER_LOCK_RELEASED(GetPtrForLockContract(ppRWLock));
-            if(pLockEntry->wReaderLevel == 0)
-            {
-                DWORD dwCurrentState, dwKnownState, dwModifyState;
-                BOOL fLastReader, fCacheEvents = FALSE;
-                CLREvent* hReaderEvent = NULL, *hWriterEvent = NULL;
-
-                // Sanity checks
-                _ASSERTE(((*ppRWLock)->_dwState & WRITER) == 0);
-                _ASSERTE((*ppRWLock)->_dwState & READERS_MASK);
-
-                // Not a reader any more
-                dwCurrentState = (*ppRWLock)->_dwState;
-                do
-                {
-                    dwKnownState = dwCurrentState;
-                    dwModifyState = (DWORD) -READER;
-                    if((dwKnownState & (READERS_MASK | READER_SIGNALED)) == READER)
-                    {
-                        fLastReader = TRUE;
-                        fCacheEvents = FALSE;
-                        if(dwKnownState & WAITING_WRITERS_MASK)
-                        {
-                            HRESULT hr;
-                            hWriterEvent = (*ppRWLock)->GetWriterEvent(&hr);
-                            if(hWriterEvent == NULL)
-                            {
-                                LOG((LF_SYNC, LL_WARNING,
-                                    "ReleaseReaderLock failed to create "
-                                    "writer event for RWLock 0x%x\n", *ppRWLock));
-                                RWSleep(100);
-                                dwCurrentState = (*ppRWLock)->_dwState;
-                                dwKnownState = 0;
-                                _ASSERTE(dwCurrentState != dwKnownState);
-                                continue;
-                            }
-                            dwModifyState += WRITER_SIGNALED;
-                        }
-                        else if(dwKnownState & WAITING_READERS_MASK)
-                        {
-                            HRESULT hr;
-                            hReaderEvent = (*ppRWLock)->GetReaderEvent(&hr);
-                            if(hReaderEvent == NULL)
-                            {
-                                LOG((LF_SYNC, LL_WARNING,
-                                    "ReleaseReaderLock failed to create "
-                                    "reader event\n", *ppRWLock));
-                                RWSleep(100);
-                                dwCurrentState = (*ppRWLock)->_dwState;
-                                dwKnownState = 0;
-                                _ASSERTE(dwCurrentState != dwKnownState);
-                                continue;
-                            }
-                            dwModifyState += READER_SIGNALED;
-                        }
-                        else if(((*ppRWLock)->_hReaderEvent || (*ppRWLock)->_hWriterEvent) &&
-                                (dwKnownState == READER))
-                        {
-                            fCacheEvents = TRUE;
-                            dwModifyState += CACHING_EVENTS;
-                        }
-                    }
-                    else
-                    {
-                        fLastReader = FALSE;
-                    }
-
-                    // Sanity checks
-                    _ASSERTE((dwKnownState & WRITER) == 0);
-                    _ASSERTE(dwKnownState & READERS_MASK);
-
-                    dwCurrentState = RWInterlockedCompareExchange(&(*ppRWLock)->_dwState,
-                                                                  (dwKnownState + dwModifyState),
-                                                                  dwKnownState);
-                } while(dwCurrentState != dwKnownState);
-
-                // Check for last reader
-                if(fLastReader)
-                {
-                    // Check for waiting writers
-                    if(dwKnownState & WAITING_WRITERS_MASK)
-                    {
-                        _ASSERTE((*ppRWLock)->_dwState & WRITER_SIGNALED);
-                        _ASSERTE(hWriterEvent);
-                        RWSetEvent(hWriterEvent);
-                    }
-                    // Check for waiting readers
-                    else if(dwKnownState & WAITING_READERS_MASK)
-                    {
-                        _ASSERTE((*ppRWLock)->_dwState & READER_SIGNALED);
-                        _ASSERTE(hReaderEvent);
-                        RWSetEvent(hReaderEvent);
-                    }
-                    // Check for the need to release events
-                    else if(fCacheEvents)
-                    {
-                        (*ppRWLock)->ReleaseEvents();
-                    }
-                }
-
-                // Recycle lock entry
-                RecycleLockEntry(pLockEntry);
-                
-                Thread *pThread = GetThread();
-                TESTHOOKCALL(AppDomainCanBeUnloaded(pThread->GetDomain()->GetId().m_dwId,FALSE));    
-                
-                if (pThread->IsAbortRequested()) {
-                    pThread->HandleThreadAbort();
-                }
-            }
-        }
-        else
-        {
-            if(fBreakOnErrors)  // fBreakOnErrors == FALSE so will be optimized out.
-            {
-                _ASSERTE(!"Attempt to release reader lock on a wrong thread");
-                DebugBreak();
-            }
-            COMPlusThrowWin32(ERROR_NOT_OWNER);
-        }
-    }
-
-    return;
-}
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::StaticDoUpgradeToWriterLockPublic    private
-//
-//  Synopsis:   Public Access to StaticUpgradeToWriterLockPublic
-//
-// 
-//+-------------------------------------------------------------------
-FCIMPL3(void, CRWLock::StaticDoUpgradeToWriterLockPublic, CRWLock *pRWLockUNSAFE, LockCookie * pLockCookie, DWORD dwDesiredTimeout)
-{
-    FCALL_CONTRACT;
-
-    if (pRWLockUNSAFE == NULL)
-    {
-        FCThrowVoid(kNullReferenceException);
-    }
-
-    OBJECTREF pRWLock = ObjectToOBJECTREF((Object*)pRWLockUNSAFE);
-    HELPER_METHOD_FRAME_BEGIN_1(pRWLock);
-    GCPROTECT_BEGININTERIOR (pLockCookie)
-
-    StaticUpgradeToWriterLock((CRWLock**)&pRWLock, pLockCookie, dwDesiredTimeout);
-
-    GCPROTECT_END ();
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::StaticUpgradeToWriterLock    Private
-//
-//  Synopsis:   Upgrades to a writer lock. It returns a BOOL that
-//              indicates intervening writes.
-//
-
-//
-//+-------------------------------------------------------------------
-
-void CRWLock::StaticUpgradeToWriterLock(
-    CRWLock **ppRWLock, 
-    LockCookie *pLockCookie, 
-    DWORD dwDesiredTimeout)
-
-{
-    CONTRACTL
-    {
-        THROWS;               
-        GC_TRIGGERS;
-        CAN_TAKE_LOCK;
-    }
-    CONTRACTL_END;
-
-    DWORD dwThreadID = GetThread()->GetThreadId();
-
-    // Check if the thread is already a writer
-    if((*ppRWLock)->_dwWriterID == dwThreadID)
-    {
-        // Update cookie state
-        pLockCookie->dwFlags = UPGRADE_COOKIE | COOKIE_WRITER;
-        pLockCookie->wWriterLevel = (*ppRWLock)->_wWriterLevel;
-
-        // Acquire the writer lock again
-        StaticAcquireWriterLock(ppRWLock, dwDesiredTimeout);
-    }
-    else
-    {
-        BOOL fAcquireWriterLock;
-        LockEntry *pLockEntry = (*ppRWLock)->GetLockEntry();
-        if(pLockEntry == NULL)
-        {
-            fAcquireWriterLock = TRUE;
-            pLockCookie->dwFlags = UPGRADE_COOKIE | COOKIE_NONE;
-        }
-        else
-        {
-            // Sanity check
-            _ASSERTE((*ppRWLock)->_dwState & READERS_MASK);
-            _ASSERTE(pLockEntry->wReaderLevel);
-
-            // Save lock state in the cookie
-            pLockCookie->dwFlags = UPGRADE_COOKIE | COOKIE_READER;
-            pLockCookie->wReaderLevel = pLockEntry->wReaderLevel;
-            pLockCookie->dwWriterSeqNum = (*ppRWLock)->_dwWriterSeqNum;
-
-            // If there is only one reader, try to convert reader to a writer
-            DWORD dwKnownState = RWInterlockedCompareExchange(&(*ppRWLock)->_dwState,
-                                                              WRITER,
-                                                              READER);
-            if(dwKnownState == READER)
-            {
-                // Thread is no longer a reader
-                Thread* pThread = GetThread();
-                _ASSERTE (pThread);
-                _ASSERTE (pThread->m_dwLockCount >= pLockEntry->wReaderLevel);
-                ASSERT_UNLESS_NO_DEBUG_STATE(__pClrDebugState->GetLockCount(kDbgStateLockType_User) >= pLockEntry->wReaderLevel);
-                pThread->m_dwLockCount -= pLockEntry->wReaderLevel;
-                USER_LOCK_RELEASED_MULTIPLE(pLockEntry->wReaderLevel, GetPtrForLockContract(ppRWLock));
-                pLockEntry->wReaderLevel = 0;
-                RecycleLockEntry(pLockEntry);
-
-                // Thread is a writer
-                (*ppRWLock)->_dwWriterID = dwThreadID;
-                (*ppRWLock)->_wWriterLevel = 1;
-                INCTHREADLOCKCOUNT();
-                USER_LOCK_TAKEN(GetPtrForLockContract(ppRWLock));
-                ++(*ppRWLock)->_dwWriterSeqNum;
-                fAcquireWriterLock = FALSE;
-
-                // No intevening writes
-#if RWLOCK_STATISTICS
-                ++(*ppRWLock)->_dwWriterEntryCount;
-#endif
-            }
-            else
-            {
-                // Release the reader lock
-                Thread *pThread = GetThread();
-                _ASSERTE (pThread);
-                _ASSERTE (pThread->m_dwLockCount >= (DWORD)(pLockEntry->wReaderLevel - 1));
-                ASSERT_UNLESS_NO_DEBUG_STATE(__pClrDebugState->GetLockCount(kDbgStateLockType_User) >= 
-                                             (DWORD)(pLockEntry->wReaderLevel - 1));
-                pThread->m_dwLockCount -= (pLockEntry->wReaderLevel - 1);
-                USER_LOCK_RELEASED_MULTIPLE(pLockEntry->wReaderLevel - 1, GetPtrForLockContract(ppRWLock));
-                pLockEntry->wReaderLevel = 1;
-                StaticReleaseReaderLock(ppRWLock);
-                fAcquireWriterLock = TRUE;
-            }
-        }
-
-        // Check for the need to acquire the writer lock
-        if(fAcquireWriterLock)
-        {
-
-            // Declare and Setup the frame as we are aware of the contention
-            // on the lock and the thread will most probably block
-            // to acquire writer lock
-
-            EX_TRY
-            {
-                StaticAcquireWriterLock(ppRWLock, dwDesiredTimeout);
-            }
-            EX_CATCH
-            {
-                // Invalidate cookie
-                DWORD dwFlags = pLockCookie->dwFlags; 
-                pLockCookie->dwFlags = INVALID_COOKIE;
-
-                StaticRecoverLock(ppRWLock, pLockCookie, dwFlags & COOKIE_READER);
-
-                EX_RETHROW;
-            }
-            EX_END_CATCH_UNREACHABLE
-        }
-    }
-
-
-    // Update the validation fields of the cookie 
-    pLockCookie->dwThreadID = dwThreadID;
-
-    return;
-}
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::StaticDowngradeFromWriterLock   public
-//
-//  Synopsis:   Downgrades from a writer lock.
-// 
-//+-------------------------------------------------------------------
-
-inline CRWLock* GetLock(OBJECTREF orLock)
-{
-    CONTRACTL
-    {
-        NOTHROW;               
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    return (CRWLock*)OBJECTREFToObject(orLock);
-}
-
-FCIMPL2(void, CRWLock::StaticDowngradeFromWriterLock, CRWLock *pRWLockUNSAFE, LockCookie* pLockCookie)
-{
-    FCALL_CONTRACT;
-    STATIC_CONTRACT_CAN_TAKE_LOCK;
-
-    DWORD dwThreadID = GetThread()->GetThreadId();
-
-    if (pRWLockUNSAFE == NULL)
-    {
-        FCThrowVoid(kNullReferenceException);
-    }
-
-    if( NULL == pLockCookie) {
-        FCThrowVoid(kNullReferenceException);
-    }
-
-    OBJECTREF pRWLock = ObjectToOBJECTREF((Object*)pRWLockUNSAFE);
-    HELPER_METHOD_FRAME_BEGIN_1(pRWLock);
-
-    if (GetLock(pRWLock)->_dwWriterID != dwThreadID)
-    {
-        COMPlusThrowWin32(ERROR_NOT_OWNER);
-    }
-
-    // Validate cookie
-    DWORD dwStatus;
-    if(((pLockCookie->dwFlags & INVALID_COOKIE) == 0) && 
-       (pLockCookie->dwThreadID == dwThreadID))
-    {
-        DWORD dwFlags = pLockCookie->dwFlags;
-        pLockCookie->dwFlags = INVALID_COOKIE;
-        
-        // Check if the thread was a reader
-        if(dwFlags & COOKIE_READER)
-        {
-            // Sanity checks
-            _ASSERTE(GetLock(pRWLock)->_wWriterLevel == 1);
-    
-            LockEntry *pLockEntry = GetLock(pRWLock)->FastGetOrCreateLockEntry();
-            if(pLockEntry)
-            {
-                DWORD dwCurrentState, dwKnownState, dwModifyState;
-                CLREvent* hReaderEvent = NULL;
-    
-                // Downgrade to a reader
-                GetLock(pRWLock)->_dwWriterID = 0;
-                GetLock(pRWLock)->_wWriterLevel = 0;
-                DECTHREADLOCKCOUNT ();
-                USER_LOCK_RELEASED(GetPtrForLockContract((CRWLock**)&pRWLock));
-                dwCurrentState = GetLock(pRWLock)->_dwState;
-                do
-                {
-                    dwKnownState = dwCurrentState;
-                    dwModifyState = READER - WRITER;
-                    if(dwKnownState & WAITING_READERS_MASK)
-                    {
-                        HRESULT hr;
-                        hReaderEvent = GetLock(pRWLock)->GetReaderEvent(&hr);
-                        if(hReaderEvent == NULL)
-                        {
-                            LOG((LF_SYNC, LL_WARNING,
-                                "DowngradeFromWriterLock failed to create "
-                                "reader event for RWLock 0x%x\n", GetLock(pRWLock)));
-                            RWSleep(100);
-                            dwCurrentState = GetLock(pRWLock)->_dwState;
-                            dwKnownState = 0;
-                            _ASSERTE(dwCurrentState != dwKnownState);
-                            continue;
-                        }
-                        dwModifyState += READER_SIGNALED;
-                    }
-    
-                    // Sanity checks
-                    _ASSERTE((dwKnownState & READERS_MASK) == 0);
-    
-                    dwCurrentState = RWInterlockedCompareExchange(&GetLock(pRWLock)->_dwState,
-                                                                  (dwKnownState + dwModifyState),
-                                                                  dwKnownState);
-                } while(dwCurrentState != dwKnownState);
-    
-                // Check for waiting readers
-                if(dwKnownState & WAITING_READERS_MASK)
-                {
-                    _ASSERTE(GetLock(pRWLock)->_dwState & READER_SIGNALED);
-                    _ASSERTE(hReaderEvent);
-                    RWSetEvent(hReaderEvent);
-                }
-    
-                // Restore reader nesting level
-                Thread *pThread = GetThread();
-                _ASSERTE (pThread);
-                _ASSERTE (pThread->m_dwLockCount >= pLockEntry->wReaderLevel);
-                ASSERT_UNLESS_NO_DEBUG_STATE(__pClrDebugState->GetLockCount(kDbgStateLockType_User) >= 
-                                             pLockEntry->wReaderLevel);
-                pThread->m_dwLockCount -= pLockEntry->wReaderLevel;
-                USER_LOCK_RELEASED_MULTIPLE(pLockEntry->wReaderLevel, GetPtrForLockContract((CRWLock**)&pRWLock));
-                pLockEntry->wReaderLevel = pLockCookie->wReaderLevel;
-                pThread->m_dwLockCount += pLockEntry->wReaderLevel;
-                USER_LOCK_TAKEN_MULTIPLE(pLockEntry->wReaderLevel, GetPtrForLockContract((CRWLock**)&pRWLock));
-    #ifdef RWLOCK_STATISTICS
-                RWInterlockedIncrement(&GetLock(pRWLock)->_dwReaderEntryCount);
-    #endif
-            }
-            else
-            {
-                // Removed assert, as thread abort can occur normally
-                dwStatus = RWLOCK_RECOVERY_FAILURE;
-                goto ThrowException;
-            }
-        }
-        else if(dwFlags & (COOKIE_WRITER | COOKIE_NONE))
-        {
-            // Release the writer lock
-            StaticReleaseWriterLock((CRWLock**)&pRWLock);
-            _ASSERTE((GetLock(pRWLock)->_dwWriterID != GetThread()->GetThreadId()) ||
-                     (dwFlags & COOKIE_WRITER));
-        }
-    }
-    else
-    {
-        dwStatus = E_INVALIDARG;
-ThrowException:        
-        COMPlusThrowWin32(dwStatus);
-    }
-
-    HELPER_METHOD_FRAME_END();
-
-    // Update the validation fields of the cookie 
-    pLockCookie->dwThreadID = dwThreadID;
-    
-}
-FCIMPLEND
-
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::StaticDoReleaseLock    private
-//
-//  Synopsis:   Releases the lock held by the current thread
-// 
-//+-------------------------------------------------------------------
-
-FCIMPL2(void, CRWLock::StaticDoReleaseLock, CRWLock *pRWLockUNSAFE, LockCookie * pLockCookie)
-{
-    FCALL_CONTRACT;
-
-    if (pRWLockUNSAFE == NULL)
-    {
-        FCThrowVoid(kNullReferenceException);
-    }
-
-    DWORD dwThreadID = GetThread()->GetThreadId();
-
-    OBJECTREF pRWLock = ObjectToOBJECTREF((Object*)pRWLockUNSAFE);
-
-    HELPER_METHOD_FRAME_BEGIN_ATTRIB_1(Frame::FRAME_ATTR_NO_THREAD_ABORT, pRWLock);
-
-    // note that we cannot use this holder in FCALLs outside our HMF since it breaks the epilog walker on x86!
-    ThreadPreventAbortHolder preventAbortIn;
-
-    GCPROTECT_BEGININTERIOR (pLockCookie)
-
-    // Check if the thread is a writer
-    if(GetLock(pRWLock)->_dwWriterID == dwThreadID)
-    {
-        // Save lock state in the cookie
-        pLockCookie->dwFlags = RELEASE_COOKIE | COOKIE_WRITER;
-        pLockCookie->dwWriterSeqNum = GetLock(pRWLock)->_dwWriterSeqNum;
-        pLockCookie->wWriterLevel = GetLock(pRWLock)->_wWriterLevel;
-
-        // Release the writer lock
-        Thread *pThread = GetThread();
-        _ASSERTE (pThread);
-        _ASSERTE (pThread->m_dwLockCount >= (DWORD)(GetLock(pRWLock)->_wWriterLevel - 1));
-        ASSERT_UNLESS_NO_DEBUG_STATE(__pClrDebugState->GetLockCount(kDbgStateLockType_User) >=
-                                     (DWORD)(GetLock(pRWLock)->_wWriterLevel - 1));
-        pThread->m_dwLockCount -= (GetLock(pRWLock)->_wWriterLevel - 1);
-        USER_LOCK_RELEASED_MULTIPLE(GetLock(pRWLock)->_wWriterLevel - 1, GetPtrForLockContract((CRWLock**)&pRWLock));
-        GetLock(pRWLock)->_wWriterLevel = 1;
-        StaticReleaseWriterLock((CRWLock**)&pRWLock);
-    }
-    else
-    {
-        LockEntry *pLockEntry = GetLock(pRWLock)->GetLockEntry();
-        if(pLockEntry)
-        {
-            // Sanity check
-            _ASSERTE(GetLock(pRWLock)->_dwState & READERS_MASK);
-            _ASSERTE(pLockEntry->wReaderLevel);
-
-            // Save lock state in the cookie
-            pLockCookie->dwFlags = RELEASE_COOKIE | COOKIE_READER;
-            pLockCookie->wReaderLevel = pLockEntry->wReaderLevel;
-            pLockCookie->dwWriterSeqNum = GetLock(pRWLock)->_dwWriterSeqNum;
-
-            // Release the reader lock
-            Thread *pThread = GetThread();
-            _ASSERTE (pThread);
-            _ASSERTE (pThread->m_dwLockCount >= (DWORD)(pLockEntry->wReaderLevel - 1));
-            ASSERT_UNLESS_NO_DEBUG_STATE(__pClrDebugState->GetLockCount(kDbgStateLockType_User) >= 
-                                         (DWORD)(pLockEntry->wReaderLevel - 1));
-            pThread->m_dwLockCount -= (pLockEntry->wReaderLevel - 1);
-            USER_LOCK_RELEASED_MULTIPLE(pLockEntry->wReaderLevel - 1, GetPtrForLockContract((CRWLock**)&pRWLock));
-            pLockEntry->wReaderLevel = 1;
-            StaticReleaseReaderLock((CRWLock**)&pRWLock);
-        }
-        else
-        {
-            pLockCookie->dwFlags = RELEASE_COOKIE | COOKIE_NONE;
-        }
-    }
-
-    GCPROTECT_END ();
-
-    HELPER_METHOD_FRAME_END();
-
-    // Update the validation fields of the cookie 
-    pLockCookie->dwThreadID = dwThreadID;
-}
-FCIMPLEND
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::StaticRestoreLockPublic    public
-//
-//  Synopsis:   Public Access to StaticRestoreLock
-//
-// 
-//+-------------------------------------------------------------------
-
-FCIMPL2(void, CRWLock::StaticRestoreLockPublic, CRWLock *pRWLockUNSAFE, LockCookie* pLockCookie)
-{
-    FCALL_CONTRACT;
-
-    if (pRWLockUNSAFE == NULL) {
-        FCThrowVoid(kNullReferenceException);
-    }
-
-    if( NULL == pLockCookie) {
-        FCThrowVoid(kNullReferenceException);
-    }
-
-    OBJECTREF pRWLock = ObjectToOBJECTREF((Object*)pRWLockUNSAFE);
-    HELPER_METHOD_FRAME_BEGIN_1(pRWLock);
-
-    StaticRestoreLock((CRWLock**)&pRWLock, pLockCookie);
-    
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-
-//+-------------------------------------------------------------------
-//
-//  Method:     CRWLock::StaticRestoreLock  Private
-//
-//  Synopsis:   Restore the lock held by the current thread
-//
-
-//
-//+-------------------------------------------------------------------
-
-void CRWLock::StaticRestoreLock(
-    CRWLock **ppRWLock, 
-    LockCookie *pLockCookie)
-{
-    CONTRACTL
-    {
-        THROWS;     
-        CAN_TAKE_LOCK;
-        GC_TRIGGERS;           // CRWLock::StaticAquireWriterLock can trigger GC
-    }
-    CONTRACTL_END;
-
-    // Validate cookie
-    DWORD dwThreadID = GetThread()->GetThreadId();
-    DWORD dwFlags = pLockCookie->dwFlags;
-    if(pLockCookie->dwThreadID == dwThreadID)
-    {
-        if (((*ppRWLock)->_dwWriterID == dwThreadID) || ((*ppRWLock)->GetLockEntry() != NULL))
-        {
-            COMPlusThrow(kSynchronizationLockException, W("Arg_RWLockRestoreException"));
-        }
-    
-        // Check for the no contention case
-        pLockCookie->dwFlags = INVALID_COOKIE;
-        if(dwFlags & COOKIE_WRITER)
-        {
-            if(RWInterlockedCompareExchange(&(*ppRWLock)->_dwState, WRITER, 0) == 0)
-            {
-                // Restore writer nesting level
-                (*ppRWLock)->_dwWriterID = dwThreadID;
-                Thread *pThread = GetThread();
-                _ASSERTE (pThread);
-                _ASSERTE (pThread->m_dwLockCount >= (*ppRWLock)->_wWriterLevel);
-                ASSERT_UNLESS_NO_DEBUG_STATE(__pClrDebugState->GetLockCount(kDbgStateLockType_User) >=
-                                             (*ppRWLock)->_wWriterLevel);
-                pThread->m_dwLockCount -= (*ppRWLock)->_wWriterLevel;
-                USER_LOCK_RELEASED_MULTIPLE((*ppRWLock)->_wWriterLevel, GetPtrForLockContract(ppRWLock));
-                (*ppRWLock)->_wWriterLevel = pLockCookie->wWriterLevel;
-                pThread->m_dwLockCount += (*ppRWLock)->_wWriterLevel;
-                USER_LOCK_TAKEN_MULTIPLE((*ppRWLock)->_wWriterLevel, GetPtrForLockContract(ppRWLock));
-                ++(*ppRWLock)->_dwWriterSeqNum;
-#ifdef RWLOCK_STATISTICS
-                ++(*ppRWLock)->_dwWriterEntryCount;
-#endif
-                goto LNormalReturn;
-            }
-        }
-        else if(dwFlags & COOKIE_READER)
-        {
-            LockEntry *pLockEntry = (*ppRWLock)->FastGetOrCreateLockEntry();
-            if(pLockEntry)
-            {
-                // This thread should not already be a reader
-                // else bad things can happen
-                _ASSERTE(pLockEntry->wReaderLevel == 0);
-                DWORD dwKnownState = (*ppRWLock)->_dwState;
-                if(dwKnownState < READERS_MASK)
-                {
-                    DWORD dwCurrentState = RWInterlockedCompareExchange(&(*ppRWLock)->_dwState,
-                                                                        (dwKnownState + READER),
-                                                                        dwKnownState);
-                    if(dwCurrentState == dwKnownState)
-                    {
-                        // Restore reader nesting level
-                        Thread *pThread = GetThread();
-                        _ASSERTE (pThread);
-                        pLockEntry->wReaderLevel = pLockCookie->wReaderLevel;
-                        pThread->m_dwLockCount += pLockEntry->wReaderLevel;
-                        USER_LOCK_TAKEN_MULTIPLE(pLockEntry->wReaderLevel, GetPtrForLockContract(ppRWLock));
-#ifdef RWLOCK_STATISTICS
-                        RWInterlockedIncrement(&(*ppRWLock)->_dwReaderEntryCount);
-#endif
-                        goto LNormalReturn;
-                    }
-                }
-    
-                // Recycle the lock entry for the slow case
-                (*ppRWLock)->FastRecycleLockEntry(pLockEntry);
-            }
-            else
-            {
-                // Ignore the error and try again below. May be thread will luck
-                // out the second time
-            }
-        }
-        else if(dwFlags & COOKIE_NONE) 
-        {
-            goto LNormalReturn;
-        }
-
-        // Declare and Setup the frame as we are aware of the contention
-        // on the lock and the thread will most probably block
-        // to acquire lock below
-ThrowException:        
-        if((dwFlags & INVALID_COOKIE) == 0)
-        {
-            StaticRecoverLock(ppRWLock, pLockCookie, dwFlags);
-        }
-        else
-        {
-            COMPlusThrowWin32(E_INVALIDARG);
-        }
-
-        goto LNormalReturn;
-    }
-    else
-    {
-        dwFlags = INVALID_COOKIE;
-        goto ThrowException;
-    }
-
-LNormalReturn:
-    return;
-}
-
-
-//+-------------------------------------------------------------------
-//
-//  Class:      CRWLock::StaticPrivateInitialize
-//
-//  Synopsis:   Initialize lock
-// 
-//+-------------------------------------------------------------------
-FCIMPL1(void, CRWLock::StaticPrivateInitialize, CRWLock *pRWLock)
-{
-    FCALL_CONTRACT;
-
-    HELPER_METHOD_FRAME_BEGIN_1(pRWLock);
-
-    // Run the constructor on the GC allocated space
-    // CRWLock's constructor can throw exception
-#ifndef _PREFAST_
-    // Prefast falsely complains of memory leak.
-    CRWLock *pTemp;
-    pTemp = new (pRWLock) CRWLock();
-    _ASSERTE(pTemp == pRWLock);
-#endif
-
-    // Catch GC holes
-    VALIDATE_LOCK(pRWLock);
-
-    HELPER_METHOD_FRAME_END();
-    return;
-}
-FCIMPLEND
-
-
-//+-------------------------------------------------------------------
-//
-//  Class:      CRWLock::StaticPrivateDestruct
-//
-//  Synopsis:   Destruct lock
-//+-------------------------------------------------------------------
-FCIMPL1(void, CRWLock::StaticPrivateDestruct, CRWLock *pRWLock)
-{
-    FCALL_CONTRACT;
-
-    HELPER_METHOD_FRAME_BEGIN_ATTRIB_1(Frame::FRAME_ATTR_NO_THREAD_ABORT, pRWLock);
-
-    // Fixing one handle recycling security hole by
-    // ensuring we don't delete the events more than once.
-    // After deletion (for now, assuming ONE FINALIZER THREAD)
-    // make the object essentially unusable by setting handle to 
-    // INVALID_HANDLE_VALUE (unusable) versus NULL (uninitialized)
-    
-    if ((pRWLock->_hWriterEvent != INVALID_HANDLE_VALUE) && (pRWLock->_hReaderEvent != INVALID_HANDLE_VALUE))
-    {
-        // Note, this still allows concurrent event consumers (such as StaticAcquireReaderLock)
-        // to Set and/or Wait on non-events.  There still exists a security hole here.
-        if(pRWLock->_hWriterEvent)
-        {
-            CLREvent *h = (CLREvent *) FastInterlockExchangePointer((PVOID *)&(pRWLock->_hWriterEvent), INVALID_HANDLE_VALUE);
-            delete h;
-        }
-        if(pRWLock->_hReaderEvent)
-        {
-            CLREvent *h = (CLREvent *) FastInterlockExchangePointer((PVOID *)&(pRWLock->_hReaderEvent), INVALID_HANDLE_VALUE);
-            delete h;
-        }
-
-        // There is no LockEntry for this lock.
-        if (pRWLock->_dwState != 0)
-        {
-            // Recycle LockEntry on threads
-            ThreadStoreLockHolder tsl;
-
-            // Take ThreadStore lock and walk over every thread in the process
-            Thread *thread = NULL;
-            while ((thread = ThreadStore::s_pThreadStore->GetAllThreadList(thread, 
-                            Thread::TS_Unstarted|Thread::TS_Dead|Thread::TS_Detached, 0))
-                != NULL) 
-            {
-                LockEntry *pLockEntry;
-                {
-                    CrstHolder rwl(&s_RWLockCrst);
-                    pLockEntry = pRWLock->GetLockEntry(thread);
-                }
-                if (pLockEntry)
-                {
-                    // The entry does not belong to this lock anymore
-                    pLockEntry->dwLLockID = 0;
-                    pLockEntry->wReaderLevel = 0;
-                }
-            }
-        }
-    }
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-
-
-//+-------------------------------------------------------------------
-//
-//  Class:      CRWLock::StaticGetWriterSeqNum
-//
-//  Synopsis:   Returns the current sequence number
-// 
-//+-------------------------------------------------------------------
-FCIMPL1(INT32, CRWLock::StaticGetWriterSeqNum, CRWLock *pRWLock)
-{
-    FCALL_CONTRACT;
-
-    if (pRWLock == NULL)
-    {
-        FCThrow(kNullReferenceException);
-    }
-
-    return(pRWLock->_dwWriterSeqNum);
-}    
-FCIMPLEND
-
-
-//+-------------------------------------------------------------------
-//
-//  Class:      CRWLock::StaticAnyWritersSince
-//
-//  Synopsis:   Returns TRUE if there were writers since the given
-//              sequence number
-// 
-//+-------------------------------------------------------------------
-FCIMPL2(FC_BOOL_RET, CRWLock::StaticAnyWritersSince, CRWLock *pRWLock, DWORD dwSeqNum)
-{
-    FCALL_CONTRACT;
-
-    if (pRWLock == NULL)
-    {
-        FCThrow(kNullReferenceException);
-    }
-    
-
-    if(pRWLock->_dwWriterID == GetThread()->GetThreadId())
-        ++dwSeqNum;
-
-    FC_RETURN_BOOL(pRWLock->_dwWriterSeqNum > dwSeqNum);
-}
-FCIMPLEND
-
-struct RWLockIterator
-{
-    IHostTask **m_Owner;
-    DWORD  m_Capacity;
-    DWORD  m_index;
-};
-
-OBJECTHANDLE CRWLock::GetObjectHandle()
-{
-    CONTRACTL
-    {
-        THROWS;
-        MODE_COOPERATIVE;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    if (_hObjectHandle == NULL)
-    {
-        OBJECTREF obj = ObjectToOBJECTREF((Object*)this);
-        OBJECTHANDLE handle = GetAppDomain()->CreateLongWeakHandle(obj);
-        if (RWInterlockedCompareExchangePointer((PVOID*)&_hObjectHandle, handle, NULL) != NULL)
-        {
-            DestroyLongWeakHandle(handle);
-        }
-    }
-    return _hObjectHandle;
-}
-
-// CRWLock::CreateOwnerIterator can return E_OUTOFMEMORY
-//
-HRESULT CRWLock::CreateOwnerIterator(SIZE_T *pIterator)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        MODE_PREEMPTIVE;
-        GC_NOTRIGGER;
-        SO_INTOLERANT;
-    }
-    CONTRACTL_END;
-
-    *pIterator = 0;
-    if (_dwState == 0) {
-        return S_OK;
-    }
-    NewHolder<RWLockIterator> IteratorHolder(new (nothrow) RWLockIterator);
-    RWLockIterator *pRWLockIterator = IteratorHolder;
-    if (pRWLockIterator == NULL) {
-        return E_OUTOFMEMORY;
-    }
-    // Writer can be handled fast
-    if (_dwState & WRITER) {
-        DWORD writerID = _dwWriterID;
-        if (writerID != 0)
-        {
-            pRWLockIterator->m_Capacity = 1;
-            pRWLockIterator->m_index = 0;
-            pRWLockIterator->m_Owner = new (nothrow) IHostTask*[1];
-            if (pRWLockIterator->m_Owner == NULL) {
-                return E_OUTOFMEMORY;
-            }
-            Thread *pThread = g_pThinLockThreadIdDispenser->IdToThreadWithValidation(writerID);
-            if (pThread == NULL)
-            {
-                return S_OK;
-            }
-            IteratorHolder.SuppressRelease();
-            pRWLockIterator->m_Owner[0] = pThread->GetHostTaskWithAddRef();
-            *pIterator = (SIZE_T)pRWLockIterator;
-            return S_OK;
-        }
-    }
-    if (_dwState == 0) {
-        return S_OK;
-    }
-    pRWLockIterator->m_Capacity = 4;
-    pRWLockIterator->m_index = 0;
-    pRWLockIterator->m_Owner = new (nothrow) IHostTask*[pRWLockIterator->m_Capacity];
-    if (pRWLockIterator->m_Owner == NULL) {
-        return E_OUTOFMEMORY;
-    }
-
-    HRESULT hr = S_OK;
-    
-    NewArrayHolder<IHostTask*> OwnerHolder(pRWLockIterator->m_Owner);
-
-    // Take ThreadStore lock and walk over every thread in the process
-    Thread *thread = NULL;
-    while ((thread = ThreadStore::s_pThreadStore->GetAllThreadList(thread, 
-                                                      Thread::TS_Unstarted|Thread::TS_Dead|Thread::TS_Detached, 0))
-           != NULL) 
-    {
-        LockEntry *pLockEntry;
-        {
-            CrstHolder rwl(&s_RWLockCrst);
-            pLockEntry = GetLockEntry(thread);
-        }
-        if (pLockEntry && pLockEntry->wReaderLevel >= 1) {
-            if (pRWLockIterator->m_index == pRWLockIterator->m_Capacity) {
-                IHostTask** newArray = new (nothrow) IHostTask*[2*pRWLockIterator->m_Capacity];
-                if (newArray == NULL) {
-                    hr = E_OUTOFMEMORY;
-                    break;
-                }
-                memcpy (newArray,pRWLockIterator->m_Owner,pRWLockIterator->m_Capacity*sizeof(IHostTask*));
-                pRWLockIterator->m_Owner = newArray;
-                pRWLockIterator->m_Capacity *= 2;
-                OwnerHolder = pRWLockIterator->m_Owner;
-            }
-            IHostTask *pHostTask = thread->GetHostTaskWithAddRef();
-            if (pHostTask)
-            {
-                pRWLockIterator->m_Owner[pRWLockIterator->m_index++] = pHostTask;
-            }
-        }
-    }
-    if (FAILED(hr))
-    {
-        for (DWORD i = 0; i < pRWLockIterator->m_index; i ++)
-        {
-            if (pRWLockIterator->m_Owner[i])
-            {
-                pRWLockIterator->m_Owner[i]->Release();
-            }
-        }
-    }
-    if (SUCCEEDED(hr)) {
-        IteratorHolder.SuppressRelease();
-        OwnerHolder.SuppressRelease();
-        pRWLockIterator->m_Capacity = pRWLockIterator->m_index;
-        pRWLockIterator->m_index = 0;
-        *pIterator = (SIZE_T)pRWLockIterator;
-    }
-    
-    return hr;
-}
-
-void CRWLock::GetNextOwner(SIZE_T Iterator, IHostTask **ppOwnerHostTask)
-{
-    CONTRACTL
-    {
-        NOTHROW;    
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    *ppOwnerHostTask = NULL;
-    if (Iterator) {
-        RWLockIterator* tmp = (RWLockIterator*)Iterator;
-        if (tmp->m_index < tmp->m_Capacity) {
-            *ppOwnerHostTask = tmp->m_Owner[tmp->m_index];
-            tmp->m_index ++;
-        }
-    }
-}
-
-void CRWLock::DeleteOwnerIterator(SIZE_T Iterator)
-{
-    CONTRACTL
-    {
-        NOTHROW;    
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-
-    if (Iterator) {
-        RWLockIterator* pIterator = (RWLockIterator*)Iterator;
-        while (pIterator->m_index < pIterator->m_Capacity) {
-            IHostTask *pHostTask = pIterator->m_Owner[pIterator->m_index];
-            if (pHostTask)
-            {
-                pHostTask->Release();
-            }
-            pIterator->m_index ++;
-        }
-        delete[] pIterator->m_Owner;
-        delete pIterator;
-    }
-}
-#endif // FEATURE_RWLOCK
diff --git a/src/vm/rwlock.h b/src/vm/rwlock.h
index dc8e67e6fb..908e007169 100644
--- a/src/vm/rwlock.h
+++ b/src/vm/rwlock.h
@@ -67,220 +67,6 @@ typedef struct {
     DWORD dwThreadID;
 } LockCookie;
 
-//+-------------------------------------------------------------------
-//
-//  Class:      CRWLock
-//
-//  Synopsis:   Class the implements the reader writer locks. 
-// 
-//+-------------------------------------------------------------------
-class CRWLock : public Object
-{
-    friend class MscorlibBinder;
-
-public:
-    // Constuctor
-    CRWLock();
-
-    // Cleanup
-    void Cleanup();
-
-    OBJECTHANDLE GetObjectHandle();
-    HRESULT CreateOwnerIterator(SIZE_T *pIterator);
-    static void GetNextOwner(SIZE_T Iterator, IHostTask **ppOwnerHostTask);
-    static void DeleteOwnerIterator(SIZE_T Iterator);
-
-    // Statics that do the core work
-    static FCDECL1 (void, StaticPrivateInitialize, CRWLock *pRWLock);
-    static FCDECL1 (void, StaticPrivateDestruct, CRWLock *pRWLock);
-    static FCDECL2 (void, StaticAcquireReaderLockPublic, CRWLock *pRWLock, DWORD dwDesiredTimeout);
-    static FCDECL2 (void, StaticAcquireWriterLockPublic, CRWLock *pRWLock, DWORD dwDesiredTimeout);
-    static FCDECL1 (void, StaticReleaseReaderLockPublic, CRWLock *pRWLock);
-    static FCDECL1 (void, StaticReleaseWriterLockPublic, CRWLock *pRWLock);
-    static FCDECL3 (void, StaticDoUpgradeToWriterLockPublic, CRWLock *pRWLock, LockCookie * pLockCookie, DWORD dwDesiredTimeout);
-    static FCDECL2 (void, StaticDowngradeFromWriterLock, CRWLock *pRWLock, LockCookie* pLockCookie);
-    static FCDECL2 (void, StaticDoReleaseLock, CRWLock *pRWLock, LockCookie * pLockCookie);
-    static FCDECL2 (void, StaticRestoreLockPublic, CRWLock *pRWLock, LockCookie* pLockCookie);
-    static FCDECL1 (FC_BOOL_RET, StaticIsReaderLockHeld, CRWLock *pRWLock);
-    static FCDECL1 (FC_BOOL_RET, StaticIsWriterLockHeld, CRWLock *pRWLock);
-    static FCDECL1 (INT32, StaticGetWriterSeqNum, CRWLock *pRWLock);
-    static FCDECL2 (FC_BOOL_RET, StaticAnyWritersSince, CRWLock *pRWLock, DWORD dwSeqNum);
-private:
-    static void StaticAcquireReaderLock(CRWLock **ppRWLock, DWORD dwDesiredTimeout);
-    static void StaticAcquireWriterLock(CRWLock **ppRWLock, DWORD dwDesiredTimeout);
-    static void StaticReleaseReaderLock(CRWLock **ppRWLock);
-    static void StaticReleaseWriterLock(CRWLock **ppRWLock);
-    static void StaticRecoverLock(CRWLock **ppRWLock, LockCookie *pLockCookie, DWORD dwFlags);
-    static void StaticRestoreLock(CRWLock **ppRWLock, LockCookie *pLockCookie);
-    static void StaticUpgradeToWriterLock(CRWLock **ppRWLock, LockCookie *pLockCookie, DWORD dwDesiredTimeout);
-public:
-    // Assert functions
-#ifdef _DEBUG
-    BOOL AssertWriterLockHeld();
-    BOOL AssertWriterLockNotHeld();
-    BOOL AssertReaderLockHeld();
-    BOOL AssertReaderLockNotHeld();
-    BOOL AssertReaderOrWriterLockHeld();
-    void AssertHeld()
-    { 
-        WRAPPER_NO_CONTRACT; 
-        AssertWriterLockHeld(); 
-    }
-    void AssertNotHeld()
-    { 
-        WRAPPER_NO_CONTRACT;
-        AssertWriterLockNotHeld();
-        AssertReaderLockNotHeld(); 
-    }
-#else
-    void AssertWriterLockHeld()                  { LIMITED_METHOD_CONTRACT; }
-    void AssertWriterLockNotHeld()               { LIMITED_METHOD_CONTRACT; }
-    void AssertReaderLockHeld()                  { LIMITED_METHOD_CONTRACT; }
-    void AssertReaderLockNotHeld()               { LIMITED_METHOD_CONTRACT; }
-    void AssertReaderOrWriterLockHeld()          { LIMITED_METHOD_CONTRACT; }
-    void AssertHeld()                            { LIMITED_METHOD_CONTRACT; }
-    void AssertNotHeld()                         { LIMITED_METHOD_CONTRACT; }
-#endif
-
-    // Helper functions
-#ifdef RWLOCK_STATISTICS
-    DWORD GetReaderEntryCount()                  
-    { 
-        LIMITED_METHOD_CONTRACT;
-        return(_dwReaderEntryCount); 
-    }
-    DWORD GetReaderContentionCount()             { LIMITED_METHOD_CONTRACT; return(_dwReaderContentionCount); }
-    DWORD GetWriterEntryCount()                  { LIMITED_METHOD_CONTRACT; return(_dwWriterEntryCount); }
-    DWORD GetWriterContentionCount()             { LIMITED_METHOD_CONTRACT; return(_dwWriterContentionCount); }
-#endif
-    // Static functions
-    static void *operator new(size_t size)       
-    { 
-        CONTRACTL
-        {
-            THROWS;
-            GC_NOTRIGGER;
-        }
-        CONTRACTL_END;
-
-        return ::operator new(size); 
-    }
-    static void ProcessInit();
-
-    static void SetTimeout(DWORD dwTimeout)      
-    { 
-        LIMITED_METHOD_CONTRACT;
-
-        gdwDefaultTimeout = dwTimeout; 
-    }
-    static DWORD GetTimeout()                    
-    { 
-        LIMITED_METHOD_CONTRACT; 
-        return(gdwDefaultTimeout); 
-    }
-    static void SetSpinCount(DWORD dwSpinCount)  
-    { 
-        LIMITED_METHOD_CONTRACT;
-
-        gdwDefaultSpinCount = g_SystemInfo.dwNumberOfProcessors > 1
-                                                    ? dwSpinCount
-                                                    : 0; 
-    }
-    static DWORD GetSpinCount()                  { LIMITED_METHOD_CONTRACT; return(gdwDefaultSpinCount); }
-
-private:
-    // Private helpers
-    static void ChainEntry(Thread *pThread, LockEntry *pLockEntry);
-    LockEntry *GetLockEntry(Thread *pThread = NULL);
-    LockEntry *FastGetOrCreateLockEntry();
-    LockEntry *SlowGetOrCreateLockEntry(Thread *pThread);
-    void FastRecycleLockEntry(LockEntry *pLockEntry);
-    static void RecycleLockEntry(LockEntry *pLockEntry);
-
-    CLREvent* GetReaderEvent(HRESULT *pHR);
-    CLREvent* GetWriterEvent(HRESULT *pHR);
-    void ReleaseEvents();
-
-    static LONG RWInterlockedCompareExchange(LONG RAW_KEYWORD(volatile) *pvDestination,
-                                              LONG dwExchange,
-                                              LONG dwComperand);
-    static LONGLONG RWInterlockedCompareExchange64(LONGLONG RAW_KEYWORD(volatile) *pvDestination,
-                                                   LONGLONG qwExchange,
-                                                   LONGLONG qwComparand);
-    static void* RWInterlockedCompareExchangePointer(PVOID RAW_KEYWORD(volatile) *pvDestination,
-                                                   PVOID pExchange,
-                                                   PVOID pComparand);
-    static LONG RWInterlockedExchangeAdd(LONG RAW_KEYWORD(volatile) *pvDestination, LONG dwAddState);
-    static LONG RWInterlockedIncrement(LONG RAW_KEYWORD(volatile) *pdwState);
-
-    static DWORD RWWaitForSingleObject(CLREvent* event, DWORD dwTimeout);
-    static void RWSetEvent(CLREvent* event);
-    static void RWResetEvent(CLREvent* event);
-    static void RWSleep(DWORD dwTime);
-
-#if defined(ENABLE_CONTRACTS_IMPL)
-    // The LOCK_TAKEN/RELEASED macros need a "pointer" to the lock object to do
-    // comparisons between takes & releases (and to provide debugging info to the
-    // developer).  We can't use "this" (*ppRWLock), because CRWLock is an Object and thus
-    // can move.  So we use _dwLLockID instead.  It's not exactly unique, but it's
-    // good enough--worst that can happen is if a thread takes RWLock A and erroneously
-    // releases RWLock B (instead of A), we'll fail to catch that if their _dwLLockID's
-    // are the same.  On 64 bits, we can use both _dwULockID & _dwLLockID and be unique
-    static void * GetPtrForLockContract(CRWLock ** ppRWLock)
-    {
-#if defined(_WIN64)
-        return (void *)
-            (
-                (
-                    ((__int64) ((*ppRWLock)->_dwULockID)) << 32
-                )
-                |
-                (
-                    (__int64) ((*ppRWLock)->_dwLLockID)
-                )
-            );
-#else //defined(_WIN64)
-            return LongToPtr((*ppRWLock)->_dwLLockID);
-#endif //defined(_WIN64)
-    }
-#endif //defined(ENABLE_CONTRACTS_IMPL)
-
-    // private new
-    static void *operator new(size_t size, void *pv)   { LIMITED_METHOD_CONTRACT;  return(pv); }
-
-    // Private data
-    CLREvent *_hWriterEvent;
-    CLREvent *_hReaderEvent;
-    OBJECTHANDLE _hObjectHandle;
-    Volatile<LONG> _dwState;
-    LONG _dwULockID;
-    LONG _dwLLockID;
-    DWORD _dwWriterID;
-    DWORD _dwWriterSeqNum;
-    WORD _wWriterLevel;
-#ifdef RWLOCK_STATISTICS
-    // WARNING: You must explicitly #define RWLOCK_STATISTICS when you build
-    // in both the VM and BCL directories, as the managed class must also 
-    // contain these fields!
-    Volatile<LONG> _dwReaderEntryCount;
-    Volatile<LONG> _dwReaderContentionCount;
-    Volatile<LONG> _dwWriterEntryCount;
-    Volatile<LONG> _dwWriterContentionCount;
-    Volatile<LONG> _dwEventsReleasedCount;
-#endif
-
-    // Static data
-    static Volatile<LONGLONG> s_mostRecentLockID;
-    static CrstStatic       s_RWLockCrst;
-};
-
-#ifdef USE_CHECKED_OBJECTREFS
-typedef REF<CRWLock> RWLOCKREF;
-
-#else
-typedef CRWLock*     RWLOCKREF;
-#endif
-
 #endif // _RWLOCK_H_
 
 #endif // FEATURE_RWLOCK
diff --git a/src/vm/security.cpp b/src/vm/security.cpp
index 95c16bf5cd..2afb946467 100644
--- a/src/vm/security.cpp
+++ b/src/vm/security.cpp
@@ -41,31 +41,13 @@ void Security::DeleteSharedSecurityDescriptor(ISharedSecurityDescriptor *descrip
     delete static_cast<SharedSecurityDescriptor *>(descriptor);
 }
 
-#ifndef FEATURE_CORECLR
-IPEFileSecurityDescriptor* Security::CreatePEFileSecurityDescriptor(AppDomain* pDomain, PEFile *pPEFile)
-{
-    WRAPPER_NO_CONTRACT;
-
-    return static_cast<IPEFileSecurityDescriptor*>(new PEFileSecurityDescriptor(pDomain, pPEFile));
-}
-#endif
 
 BOOL Security::IsTransparencyEnforcementEnabled()
 {
     LIMITED_METHOD_CONTRACT;
 
-#ifdef FEATURE_CORECLR
     // No transparency enforcement in .NET Core
     return FALSE;
-#else
-
-#ifdef _DEBUG
-    if (g_pConfig->DisableTransparencyEnforcement())
-        return FALSE;
-#endif
-
-    return TRUE;
-#endif // FEATURE_CORECLR
 }
 
 //---------------------------------------------------------------------------------------
diff --git a/src/vm/security.h b/src/vm/security.h
index 2238279cd7..7f42c4b10b 100644
--- a/src/vm/security.h
+++ b/src/vm/security.h
@@ -14,12 +14,8 @@
 #include "securityattributes.h"
 #include "securitydeclarativecache.h"
 #include "securitydeclarative.h"
-#include "securityimperative.h"
 #include "securitytransparentassembly.h"
 
-#ifdef FEATURE_APTCA
-#include "aptca.h"
-#endif
 
 class IAssemblySecurityDescriptor;
 class IApplicationSecurityDescriptor;
@@ -72,10 +68,6 @@ namespace Security
     inline void SaveCache();
 
     // Policy
-#ifdef FEATURE_CAS_POLICY
-    inline bool IsProcessWideLegacyCasPolicyEnabled();
-    inline bool CanLoadFromRemoteSources();
-#endif // FEATURE_CAS_POLICY
 
     BOOL IsTransparencyEnforcementEnabled();
 
@@ -126,7 +118,6 @@ namespace Security
 #endif // #ifndef DACCESS_COMPILE
     inline BOOL MethodIsVisibleOutsideItsAssembly(MethodDesc * pMD);
     inline BOOL MethodIsVisibleOutsideItsAssembly(DWORD dwMethodAttr, DWORD dwClassAttr, BOOL fIsGlobalClass);
-    inline void CheckBeforeAllocConsole(AppDomain* pDomain, Assembly* pAssembly);
 
     // ----------------------------------------
     // SecurityStackWalk
@@ -134,17 +125,8 @@ namespace Security
 
     // other CAS Actions
     inline void Demand(SecurityStackWalkType eType, OBJECTREF demand) ;
-#ifdef FEATURE_CAS_POLICY
-    inline void DemandGrantSet(IAssemblySecurityDescriptor *psdAssembly);
-#endif // FEATURE_CAS_POLICY
     inline void DemandSet(SecurityStackWalkType eType, OBJECTREF demand) ;
     inline void DemandSet(SecurityStackWalkType eType, PsetCacheEntry *pPCE, DWORD dwAction) ;
-#ifdef FEATURE_CAS_POLICY
-    inline void ReflectionTargetDemand(DWORD dwPermission, IAssemblySecurityDescriptor *psdTarget);
-    inline void ReflectionTargetDemand(DWORD dwPermission,
-                                       IAssemblySecurityDescriptor *psdTarget,
-                                       DynamicResolver * pAccessContext);
-#endif // FEATURE_CAS_POLICY
     inline void SpecialDemand(SecurityStackWalkType eType, DWORD whatPermission) ;
 
     inline void InheritanceLinkDemandCheck(Assembly *pTargetAssembly, MethodDesc * pMDLinkDemand);
@@ -153,10 +135,6 @@ namespace Security
     inline void FullTrustLinkDemand(Assembly *pTargetAssembly);
 
     // Compressed Stack
-#ifdef FEATURE_COMPRESSEDSTACK
-    inline COMPRESSEDSTACKREF GetCSFromContextTransitionFrame(Frame *pFrame) ;
-    inline BOOL IsContextTransitionFrameWithCS(Frame *pFrame);
-#endif // #ifdef FEATURE_COMPRESSEDSTACK
 
     // Misc - todo: put these in better categories
     
@@ -165,9 +143,6 @@ namespace Security
     IAssemblySecurityDescriptor* CreateAssemblySecurityDescriptor(AppDomain *pDomain, DomainAssembly *pAssembly, LoaderAllocator *pLoaderAllocator);
     ISharedSecurityDescriptor* CreateSharedSecurityDescriptor(Assembly* pAssembly);
     void DeleteSharedSecurityDescriptor(ISharedSecurityDescriptor *descriptor);
-#ifndef FEATURE_CORECLR
-    IPEFileSecurityDescriptor* CreatePEFileSecurityDescriptor(AppDomain* pDomain, PEFile *pPEFile);
-#endif
     inline void SetDefaultAppDomainProperty(IApplicationSecurityDescriptor* pASD);
     inline void SetDefaultAppDomainEvidenceProperty(IApplicationSecurityDescriptor* pASD);
 
@@ -226,15 +201,6 @@ namespace Security
     // security enforcement
     inline BOOL ContainsBuiltinCASPermsOnly(CORSEC_ATTRSET* pAttrSet);
 
-#ifdef FEATURE_APTCA
-    inline BOOL IsUntrustedCallerCheckNeeded(MethodDesc *pCalleeMD, Assembly *pCallerAssem = NULL) ;
-    inline void DoUntrustedCallerChecks(Assembly *pCaller, MethodDesc *pCalee, BOOL fFullStackWalk) ;
-
-    inline bool NativeImageHasValidAptcaDependencies(PEImage *pNativeImage, DomainAssembly *pDomainAssembly);
-
-    inline SString GetAptcaKillBitAccessExceptionContext(Assembly *pTargetAssembly);
-    inline SString GetConditionalAptcaAccessExceptionContext(Assembly *pTargetAssembly);
-#endif // FEATURE_APTCA
 
     inline bool SecurityCalloutQuickCheck(MethodDesc *pCallerMD);
 
@@ -260,11 +226,6 @@ public:
     virtual void Resolve() = 0;
     virtual BOOL IsResolved() const = 0;
 
-#ifdef FEATURE_CAS_POLICY
-    virtual OBJECTREF GetEvidence() = 0;
-    virtual BOOL IsEvidenceComputed() const = 0;
-    virtual void SetEvidence(OBJECTREF evidence) = 0;
-#endif // FEATURE_CAS_POLICY
 
     virtual OBJECTREF GetGrantedPermissionSet(OBJECTREF* RefusedPermissions = NULL) = 0;
 #endif // !DACCESS_COMPILE
@@ -301,16 +262,7 @@ public:
     // or if unmanaged code access is allowed at this time
     virtual DWORD GetDomainWideSpecialFlag() const = 0;
 
-#ifdef FEATURE_CAS_POLICY
-    virtual void SetLegacyCasPolicyEnabled() = 0;
-    virtual BOOL IsLegacyCasPolicyEnabled() = 0;
-    virtual BOOL AllowsLoadsFromRemoteSources() = 0;
-#endif // FEATURE_CAS_POLICY
 
-#ifdef FEATURE_APTCA
-    virtual ConditionalAptcaCache *GetConditionalAptcaCache() = 0;
-    virtual void SetCanonicalConditionalAptcaList(LPCWSTR wszCanonicalConditionalAptcaList) = 0;
-#endif // FEATURE_APTCA
 #endif // !DACCESS_COMPILE
 };
 
@@ -333,22 +285,9 @@ public:
 
     virtual void ResolvePolicy(ISharedSecurityDescriptor *pSharedDesc, BOOL fShouldSkipPolicyResolution) = 0;
 
-#ifdef FEATURE_CAS_POLICY
-    virtual HRESULT LoadSignature( COR_TRUST **ppSignature = NULL) = 0;
-
-    virtual void SetRequestedPermissionSet(OBJECTREF RequiredPermissionSet, OBJECTREF OptionalPermissionSet, OBJECTREF DeniedPermissionSet) = 0;
-
-    virtual void SetAdditionalEvidence(OBJECTREF evidence) = 0;
-    virtual BOOL HasAdditionalEvidence() = 0;
-    virtual OBJECTREF GetAdditionalEvidence()  = 0;
-    virtual void SetEvidenceFromPEFile(IPEFileSecurityDescriptor *pPEFileSecDesc) = 0;
-#endif // FEATURE_CAS_POLICY
 
     virtual void PropagatePermissionSet(OBJECTREF GrantedPermissionSet, OBJECTREF DeniedPermissionSet, DWORD dwSpecialFlags) = 0;
 
-#ifndef FEATURE_CORECLR 
-    virtual BOOL AllowApplicationSpecifiedAppDomainManager() = 0;
-#endif
 
     // Check to make sure that security will allow this assembly to load.  Throw an exception if the
     // assembly should be forbidden from loading for security related purposes
@@ -365,13 +304,6 @@ public:
     virtual Assembly* GetAssembly() = 0;
 };
 
-#ifndef FEATURE_CORECLR
-class IPEFileSecurityDescriptor : public ISecurityDescriptor
-{
-public:
-    virtual BOOL AllowBindingRedirects() = 0;
-};
-#endif
 
 #include "security.inl"
 #include "securitydeclarative.inl"
diff --git a/src/vm/security.inl b/src/vm/security.inl
index 2f1f96cca8..f2d7d7d683 100644
--- a/src/vm/security.inl
+++ b/src/vm/security.inl
@@ -25,59 +25,10 @@ inline  void Security::Stop()
     WRAPPER_NO_CONTRACT;
     SecurityPolicy::Stop();
 }
-#ifdef FEATURE_CAS_POLICY
-inline void Security::SaveCache() 
-{
-    WRAPPER_NO_CONTRACT;
-    SecurityPolicy::SaveCache();
-}
-#endif
 // ----------------------------------------
 // SecurityPolicy
 // ----------------------------------------
 
-#ifdef FEATURE_CAS_POLICY
-
-//---------------------------------------------------------------------------------------
-//
-// Determine if the entire process is running with CAS policy enabled for legacy
-// compatibility.  If this value is false, the CLR does not apply any security policy.
-// Instead, it defers to a host if one is present or grants assemblies full trust.
-//
-
-inline bool Security::IsProcessWideLegacyCasPolicyEnabled()
-{
-    LIMITED_METHOD_CONTRACT;
-
-    // APPX precludes the use of legacy CAS policy
-    if (AppX::IsAppXProcess())
-    {
-        return false;
-    }
-
-    return CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_Security_LegacyCasPolicy) ||
-           CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_Security_NetFx40LegacySecurityPolicy);
-}
-
-//---------------------------------------------------------------------------------------
-//
-// In pre-v4 versions of the CLR, doing a LoadFrom for a file in a remote location would
-// implicitly sandbox that assembly.  If CAS policy is disabled, then these applications
-// will suddenly be granting full trust to assemblies they expected to be sandboxed.  In
-// order to prevent this, these LoadFroms are disabled unless the application has explcitly
-// configured itself to allow them.
-// 
-// This method returns the a value that indicates if the application has indicated that it
-// is safe to LoadFrom remote locations and that the CLR should not block these loads.
-//
-
-inline bool Security::CanLoadFromRemoteSources()
-{
-    WRAPPER_NO_CONTRACT;
-    return !!CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_Security_LoadFromRemoteSources);
-}
-
-#endif // FEATURE_CAS_POLICY
 
 inline BOOL Security::CanCallUnmanagedCode(Module *pModule) 
 {
@@ -173,15 +124,11 @@ inline LinktimeCheckReason Security::GetLinktimeCheckReason(MethodDesc *pMD,
 inline void Security::CheckLinkDemandAgainstAppDomain(MethodDesc *pMD) 
 {
     WRAPPER_NO_CONTRACT; 
-#ifdef FEATURE_CAS_POLICY
-    SecurityDeclarative::CheckLinkDemandAgainstAppDomain(pMD); 
-#endif
 }
 
 inline void Security::LinktimeCheckMethod(Assembly *pCaller, MethodDesc *pCallee) 
 {
     WRAPPER_NO_CONTRACT; 
-    SecurityDeclarative::LinktimeCheckMethod(pCaller, pCallee); 
 }
 
 inline void Security::ClassInheritanceCheck(MethodTable *pClass, MethodTable *pParent) 
@@ -196,27 +143,15 @@ inline void Security::MethodInheritanceCheck(MethodDesc *pMethod, MethodDesc *pP
     SecurityDeclarative::MethodInheritanceCheck(pMethod, pParent); 
 }
 
-inline void Security::GetPermissionInstance(OBJECTREF *perm, int index) 
-{
-    WRAPPER_NO_CONTRACT; 
-    SecurityDeclarative::GetPermissionInstance(perm, index); 
-}
-
 inline void Security::DoDeclarativeActions(MethodDesc *pMD, DeclActionInfo *pActions, LPVOID pSecObj, MethodSecurityDescriptor *pMSD) 
 {
     WRAPPER_NO_CONTRACT; 
-#ifdef FEATURE_CAS_POLICY
-    SecurityDeclarative::DoDeclarativeActions(pMD, pActions, pSecObj, pMSD); 
-#endif
 }
 
 #ifndef DACCESS_COMPILE
 inline void Security::CheckNonCasDemand(OBJECTREF *prefDemand) 
 {
     WRAPPER_NO_CONTRACT;
-#ifdef FEATURE_CAS_POLICY
-    SecurityDeclarative::CheckNonCasDemand(prefDemand); 
-#endif
 }
 #endif // #ifndef DACCESS_COMPILE
 
@@ -232,14 +167,6 @@ inline BOOL Security::MethodIsVisibleOutsideItsAssembly(DWORD dwMethodAttr, DWOR
     return SecurityDeclarative::MethodIsVisibleOutsideItsAssembly(dwMethodAttr, dwClassAttr, fIsGlobalClass);
 }
 
-inline void Security::CheckBeforeAllocConsole(AppDomain* pDomain, Assembly* pAssembly) 
-{
-    WRAPPER_NO_CONTRACT; 
-#ifdef FEATURE_CAS_POLICY
-    SecurityRuntime::CheckBeforeAllocConsole(pDomain, pAssembly); 
-#endif
-}
-
 // ----------------------------------------
 // SecurityStackWalk
 // ----------------------------------------
@@ -248,18 +175,8 @@ inline void Security::CheckBeforeAllocConsole(AppDomain* pDomain, Assembly* pAss
 inline void Security::Demand(SecurityStackWalkType eType, OBJECTREF demand) 
 {
     WRAPPER_NO_CONTRACT;
-#ifdef FEATURE_CAS_POLICY
-    SecurityStackWalk::Demand(eType, demand); 
-#endif
 }
 
-#ifdef FEATURE_CAS_POLICY
-inline void Security::DemandGrantSet(IAssemblySecurityDescriptor *psdAssembly)
-{
-    WRAPPER_NO_CONTRACT;
-    SecurityStackWalk::DemandGrantSet(static_cast<AssemblySecurityDescriptor*>(psdAssembly));
-}
-#endif // FEATURE_CAS_POLICY
 
 inline void Security::DemandSet(SecurityStackWalkType eType, OBJECTREF demand) 
 {
@@ -270,82 +187,34 @@ inline void Security::DemandSet(SecurityStackWalkType eType, OBJECTREF demand)
         MODE_COOPERATIVE;
     }
     CONTRACTL_END;
-#ifdef FEATURE_CAS_POLICY
-    SecurityStackWalk::DemandSet(eType, demand); 
-#endif
 }
 
 inline void Security::DemandSet(SecurityStackWalkType eType, PsetCacheEntry *pPCE, DWORD dwAction) 
 {
     WRAPPER_NO_CONTRACT;
-#ifdef FEATURE_CAS_POLICY
-    SecurityStackWalk::DemandSet(eType, pPCE, dwAction); 
-#endif
 }
 
-#ifdef FEATURE_CAS_POLICY
-inline void Security::ReflectionTargetDemand(DWORD dwPermission, IAssemblySecurityDescriptor *psdTarget)
-{
-    WRAPPER_NO_CONTRACT;
-    SecurityStackWalk::ReflectionTargetDemand(dwPermission, static_cast<AssemblySecurityDescriptor*>(psdTarget));
-}
-
-inline void Security::ReflectionTargetDemand(DWORD dwPermission,
-                                             IAssemblySecurityDescriptor *psdTarget,
-                                             DynamicResolver * pAccessContext)
-{
-    WRAPPER_NO_CONTRACT;
-    SecurityStackWalk::ReflectionTargetDemand(dwPermission, static_cast<AssemblySecurityDescriptor*>(psdTarget), pAccessContext);
-}
-#endif // FEATURE_CAS_POLICY
 
 inline void Security::SpecialDemand(SecurityStackWalkType eType, DWORD whatPermission) 
 {
     WRAPPER_NO_CONTRACT;
-#ifdef FEATURE_CAS_POLICY
-    SecurityStackWalk::SpecialDemand(eType, whatPermission);
-#endif
 }
 
 inline void Security::InheritanceLinkDemandCheck(Assembly *pTargetAssembly, MethodDesc * pMDLinkDemand)
 {
     WRAPPER_NO_CONTRACT;
-#ifdef FEATURE_CAS_POLICY
-    SecurityDeclarative::InheritanceLinkDemandCheck(pTargetAssembly, pMDLinkDemand);
-#endif
 }
 
 inline void Security::FullTrustInheritanceDemand(Assembly *pTargetAssembly)
 {
     WRAPPER_NO_CONTRACT;
-#ifdef FEATURE_CAS_POLICY
-    SecurityDeclarative::FullTrustInheritanceDemand(pTargetAssembly);
-#endif
 }
 
 inline void Security::FullTrustLinkDemand(Assembly *pTargetAssembly)
 {
     WRAPPER_NO_CONTRACT;
-#ifdef FEATURE_CAS_POLICY
-    SecurityDeclarative::FullTrustLinkDemand(pTargetAssembly);
-#endif
-}
-
-#ifdef FEATURE_COMPRESSEDSTACK
-// Compressed Stack
-
-inline COMPRESSEDSTACKREF Security::GetCSFromContextTransitionFrame(Frame *pFrame) 
-{
-    WRAPPER_NO_CONTRACT; 
-    return SecurityStackWalk::GetCSFromContextTransitionFrame(pFrame); 
 }
 
-inline BOOL Security::IsContextTransitionFrameWithCS(Frame *pFrame) 
-{
-    WRAPPER_NO_CONTRACT;
-    return SecurityStackWalk::IsContextTransitionFrameWithCS(pFrame); 
-}
-#endif // #ifdef FEATURE_COMPRESSEDSTACK
 // Misc - todo: put these in better categories
 
 FORCEINLINE  VOID Security::IncrementSecurityPerfCounter() 
@@ -550,43 +419,8 @@ inline BOOL Security::CanSkipVerification(MethodDesc * pMD)
     }
     CONTRACTL_END;
 
-#ifdef FEATURE_CORECLR
     // Always skip verification on CoreCLR
     return TRUE;
-#else
-
-    // Special case the System.Object..ctor:
-    // System.Object..ctor is not verifiable according to current verifier rules (that require to call the base 
-    // class ctor). But since we want System.Object..ctor() to be marked transparent, it cannot be unverifiable
-    // (v4 security rules prohibit transparent code from being unverifiable)
-
-#ifndef DACCESS_COMPILE
-    if (g_pObjectCtorMD == pMD)
-        return TRUE;
-#endif
-
-    // In AppX, all dynamic code (dynamic assemblies and dynamic methods) should be verified..
-    if (AppX::IsAppXProcess() && !AppX::IsAppXDesignMode())
-    {
-        if (pMD->IsLCGMethod() || pMD->GetAssembly()->IsDynamic())
-            return FALSE;
-    }
-
-    BOOL fCanSkipVerification = Security::CanSkipVerification(pMD->GetAssembly()->GetDomainAssembly()); 
-    if (fCanSkipVerification)
-    {
-        // check for transparency
-        if (SecurityTransparent::IsMethodTransparent(pMD))
-        {
-            ModuleSecurityDescriptor *pModuleSecDesc = ModuleSecurityDescriptor::GetModuleSecurityDescriptor(pMD->GetAssembly());
-            if (!pModuleSecDesc->CanTransparentCodeSkipVerification())
-            {
-                return FALSE;
-            }
-        }
-    }
-   return fCanSkipVerification;
-#endif // !FEATURE_CORECLR
 }
 #endif //!DACCESS_COMPILE
 
@@ -615,38 +449,6 @@ inline BOOL Security::ContainsBuiltinCASPermsOnly(CORSEC_ATTRSET* pAttrSet)
     return SecurityAttributes::ContainsBuiltinCASPermsOnly(pAttrSet); 
 }
 
-#ifdef FEATURE_APTCA
-inline BOOL Security::IsUntrustedCallerCheckNeeded(MethodDesc *pCalleeMD, Assembly *pCallerAssem)
-{ 
-    WRAPPER_NO_CONTRACT; 
-    return SecurityDeclarative::IsUntrustedCallerCheckNeeded(pCalleeMD, pCallerAssem); 
-}
- 
-inline void Security::DoUntrustedCallerChecks(Assembly *pCaller, MethodDesc *pCalee, BOOL fFullStackWalk) 
-{
-    WRAPPER_NO_CONTRACT;
-    SecurityDeclarative::DoUntrustedCallerChecks(pCaller, pCalee, fFullStackWalk); 
-}
-
-inline bool Security::NativeImageHasValidAptcaDependencies(PEImage *pNativeImage, DomainAssembly *pDomainAssembly)
-{
-    WRAPPER_NO_CONTRACT;
-    return ::NativeImageHasValidAptcaDependencies(pNativeImage, pDomainAssembly);
-}
-
-inline SString Security::GetAptcaKillBitAccessExceptionContext(Assembly *pTargetAssembly)
-{
-    WRAPPER_NO_CONTRACT;
-    return ::GetAptcaKillBitAccessExceptionContext(pTargetAssembly);
-}
-
-inline SString Security::GetConditionalAptcaAccessExceptionContext(Assembly *pTargetAssembly)
-{
-    WRAPPER_NO_CONTRACT;
-    return ::GetConditionalAptcaAccessExceptionContext(pTargetAssembly);
-}
-
-#endif // FEATURE_APTCA
 
 inline bool Security::SecurityCalloutQuickCheck(MethodDesc *pCallerMD)
 {
@@ -658,12 +460,6 @@ inline bool Security::CanShareAssembly(DomainAssembly *pAssembly)
 {
     WRAPPER_NO_CONTRACT;
 
-#ifdef FEATURE_APTCA
-    if (!DomainCanShareAptcaAssembly(pAssembly))
-    {
-        return false;
-    }
-#endif // FEATURE_APTCA
 
     return true;
 }
@@ -686,34 +482,7 @@ FORCEINLINE BOOL SecurityStackWalk::HasFlagsOrFullyTrustedIgnoreMode (DWORD flag
     }
     CONTRACTL_END;
 
-#ifndef FEATURE_CAS_POLICY
     return TRUE;
-#else
-    // either the desired flag (often 0) or fully trusted will do
-    flags |= (1<<SECURITY_FULL_TRUST);
-  
-    // in order for us to use the threadwide state it has to be the case that there have been no
-    // overrides since the evaluation (e.g. no denies)  We keep the state up-to-date by updating 
-    // it whenever a new AppDomainStackEntry is pushed on the AppDomainStack attached to the thread.
-    // When we evaluate the demand, we always intersect the current thread state with the AppDomain
-    // wide flags, which are updated anytime a new Assembly is loaded into that domain.
-    //
-    // note if the flag is clear we still might be able to satisfy the demand if we do the full 
-    // stackwalk.
-    //
-    // this code is very perf sensitive, do not make changes here without running 
-    // a lot of interop and declarative security benchmarks
-    //
-    // it's important that we be able to do these checks without having to touch objects
-    // other than the thread itself -- that's where a big part of the speed comes from
-    // L1 cache misses are at a premium on this code path -- never mind L2...
-    // main memory is right out :)
-  
-    Thread* pThread = GetThread();
-    return ((pThread->GetOverridesCount() == 0) &&
-            pThread->CheckThreadWideSpecialFlag(flags) &&
-            static_cast<ApplicationSecurityDescriptor*>(pThread->GetDomain()->GetSecurityDescriptor())->CheckDomainWideSpecialFlag(flags));
-#endif
 }
 
 // Returns true if everyone is fully trusted or has the indicated flags AND we're not in legacy CAS mode
diff --git a/src/vm/securityattributes.cpp b/src/vm/securityattributes.cpp
index 0facbbbfb3..798d8099a5 100644
--- a/src/vm/securityattributes.cpp
+++ b/src/vm/securityattributes.cpp
@@ -21,133 +21,6 @@ HRESULT BlobToAttributeSet(BYTE* pBuffer, ULONG cbBuffer, CORSEC_ATTRSET* pAttrS
 
 #ifndef CROSSGEN_COMPILE
 
-OBJECTREF SecurityAttributes::CreatePermissionSet(BOOL fTrusted)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    OBJECTREF pPermSet = NULL;
-    GCPROTECT_BEGIN(pPermSet);
-
-    MethodTable* pMT = MscorlibBinder::GetClass(CLASS__PERMISSION_SET);
-    pPermSet = (OBJECTREF) AllocateObject(pMT);
-
-    ARG_SLOT fStatus = (fTrusted) ? 1 : 0;
-
-    MethodDescCallSite ctor(METHOD__PERMISSION_SET__CTOR);
-
-    ARG_SLOT arg[2] = { 
-        ObjToArgSlot(pPermSet),
-        BoolToArgSlot(fStatus)
-    };
-    ctor.Call(arg);
-    
-    GCPROTECT_END();
-
-    return pPermSet;
-}
-
-#ifdef FEATURE_CAS_POLICY
-
-// todo: remove the non-cas parameters (because they're bogus now anyway)
-void SecurityAttributes::XmlToPermissionSet(PBYTE pbXmlBlob,
-                                DWORD cbXmlBlob,
-                                OBJECTREF* pPermSet,
-                                OBJECTREF* pEncoding,
-                                PBYTE pbNonCasXmlBlob,
-                                DWORD cbNonCasXmlBlob,
-                                OBJECTREF* pNonCasPermSet,
-                                OBJECTREF* pNonCasEncoding)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(IsProtectedByGCFrame (pPermSet));
-        PRECONDITION(IsProtectedByGCFrame (pEncoding));
-        PRECONDITION(IsProtectedByGCFrame (pNonCasPermSet));
-        PRECONDITION(IsProtectedByGCFrame (pNonCasEncoding));
-    } CONTRACTL_END;
-
-    // Get Host Protection Flags
-    EApiCategories eProtectedCategories = GetHostProtectionManager()->GetProtectedCategories();
-
-    MethodDescCallSite decodeXML(METHOD__PERMISSION_SET__DECODE_XML, pPermSet); // can trigger GC
-
-    // Deserialize the CAS PermissionSet
-    if(pbXmlBlob && cbXmlBlob > 0)
-    {
-        _ASSERTE(*pbXmlBlob != LAZY_DECL_SEC_FLAG);
-
-        // Create a new (empty) permission set.
-        *pPermSet = SecurityAttributes::CreatePermissionSet(FALSE);
-
-        // Buffer in managed space.
-        SecurityAttributes::CopyEncodingToByteArray(pbXmlBlob, cbXmlBlob, pEncoding);
-
-        ARG_SLOT args[] = { 
-            ObjToArgSlot(*pPermSet),
-            ObjToArgSlot(*pEncoding),
-            (ARG_SLOT)eProtectedCategories,
-            (ARG_SLOT)0,
-        };
-
-        // Deserialize into a managed object.
-        BOOL success = FALSE;
-        EX_TRY
-        {
-            // Elevate thread's allowed loading level.  This can cause load failures if assemblies loaded from this point on require
-            // any assemblies currently being loaded.
-            OVERRIDE_LOAD_LEVEL_LIMIT(FILE_ACTIVE);
-            OVERRIDE_TYPE_LOAD_LEVEL_LIMIT(CLASS_LOADED);
-            success = decodeXML.Call_RetBool(args);
-        }
-        EX_SWALLOW_NONTERMINAL
-
-        if (!success)
-            COMPlusThrow(kSecurityException, IDS_ENCODEDPERMSET_DECODEFAILURE);
-    }
-
-    // Deserialize the non-CAS PermissionSet
-    if(pbNonCasXmlBlob && cbNonCasXmlBlob > 0)
-    {
-        _ASSERTE(*pbNonCasXmlBlob != LAZY_DECL_SEC_FLAG);
-
-        // Create a new (empty) permission set.
-        *pNonCasPermSet = SecurityAttributes::CreatePermissionSet(FALSE);
-
-        // Buffer in managed space.
-        SecurityAttributes::CopyEncodingToByteArray(pbNonCasXmlBlob, cbNonCasXmlBlob, pNonCasEncoding);
-
-        ARG_SLOT args[] = { 
-            ObjToArgSlot(*pNonCasPermSet),
-            ObjToArgSlot(*pNonCasEncoding),
-            (ARG_SLOT)eProtectedCategories,
-            (ARG_SLOT)0,
-        };
-
-        // Deserialize into a managed object.
-        BOOL success = FALSE;
-        EX_TRY
-        {
-            // Elevate thread's allowed loading level.  This can cause load failures if assemblies loaded from this point on require
-            // any assemblies currently being loaded.
-            OVERRIDE_LOAD_LEVEL_LIMIT(FILE_ACTIVE);
-            OVERRIDE_TYPE_LOAD_LEVEL_LIMIT(CLASS_LOADED);
-            success = decodeXML.Call_RetBool(args);
-        }
-        EX_SWALLOW_NONTERMINAL
-
-        if (!success)
-            COMPlusThrow(kSecurityException, IDS_ENCODEDPERMSET_DECODEFAILURE);
-    }
-}
-
-#endif // FEATURE_CAS_POLICY
-
 //
 // Determine if a security action allows an optimization where an empty permission set can be represented as
 // NULL. Some VM optimizations kick in if an empty permission set can be represented as NULL; however since
@@ -177,70 +50,6 @@ bool SecurityAttributes::ActionAllowsNullPermissionSet(CorDeclSecurity action)
     return action != dclPermitOnly && action != dclRequestOptional;
 }
 
-#ifdef FEATURE_CAS_POLICY
-
-PsetCacheEntry* SecurityAttributes::MergePermissionSets(IN PsetCacheEntry *pPCE1, IN PsetCacheEntry *pPCE2, IN bool fIntersect, DWORD dwAction)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    SecurityDeclarativeCache *pSDC;
-    PsetCacheEntry* pMergedPCE;
-
-    struct _gc {
-        OBJECTREF orSet1;
-        OBJECTREF orSet2;
-        OBJECTREF orMergedSet;
-    } gc;
-    memset(&gc, '\0', sizeof(gc));
-    GCPROTECT_BEGIN(gc);
-    {
-        // Union or Intersect the two PermissionSets
-        gc.orSet1 = pPCE1->CreateManagedPsetObject (dwAction);
-        
-        if(gc.orSet1 == NULL)
-            pMergedPCE = fIntersect ? pPCE1 : pPCE2;
-        else
-        {
-            gc.orSet2 = pPCE2->CreateManagedPsetObject (dwAction);
-            if(gc.orSet2 == NULL)
-                pMergedPCE = fIntersect ? pPCE2 : pPCE1;
-            else
-            {
-                BinderMethodID methID = (fIntersect ? METHOD__PERMISSION_SET__INTERSECT : METHOD__PERMISSION_SET__UNION);
-                MethodDescCallSite mergeMethod(methID, &gc.orSet1);
-
-                ARG_SLOT args[2] = {
-                    ObjToArgSlot(gc.orSet1),
-                    ObjToArgSlot(gc.orSet2),
-                };
-                gc.orMergedSet = mergeMethod.Call_RetOBJECTREF(args);
-
-                if(gc.orMergedSet == NULL)
-                    gc.orMergedSet = CreatePermissionSet(false);
-
-                // Convert to XML blob
-                PBYTE pbData;
-                DWORD cbData;
-                EncodePermissionSet(&gc.orMergedSet, &pbData, &cbData);
-
-                // Store XML blob and obtain an index to reference it
-                pSDC = &(GetAppDomain()->m_pSecContext->m_pSecurityDeclarativeCache);
-                pMergedPCE = pSDC->CreateAndCachePset (pbData, cbData);
-
-            }
-        }
-    }
-    GCPROTECT_END();
-
-    return pMergedPCE;
-}
-
-#endif // FEATURE_CAS_POLICY
-
 void SecurityAttributes::CopyEncodingToByteArray(IN PBYTE   pbData,
                                                 IN DWORD   cbData,
                                                 OUT OBJECTREF* pArray)
@@ -280,1077 +89,6 @@ void SecurityAttributes::CopyByteArrayToEncoding(IN U1ARRAYREF* pArray,
     CopyMemory(*ppbData, (*pArray)->GetDirectPointerToNonObjectElements(), size);
 }
 
-#ifdef FEATURE_CAS_POLICY
-void SecurityAttributes::EncodePermissionSet(IN OBJECTREF* pRef,
-                                         OUT PBYTE* ppbData,
-                                         OUT DWORD* pcbData)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(IsProtectedByGCFrame (pRef));
-    } CONTRACTL_END;
-
-    MethodDescCallSite encodeXML(METHOD__PERMISSION_SET__ENCODE_XML);
-
-    // Encode up the result
-    ARG_SLOT args1[1];
-    args1[0] = ObjToArgSlot(*pRef);
-    OBJECTREF pByteArray = NULL;
-    pByteArray = encodeXML.Call_RetOBJECTREF(args1);
-        
-    SecurityAttributes::CopyByteArrayToEncoding((U1ARRAYREF*) &pByteArray,
-                                            ppbData,
-                                            pcbData);
-}
-
-static void SetupRestrictSecAttributes()
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    EX_TRY
-    {
-        MethodDescCallSite setupSecurity(METHOD__PERMISSION_SET__SETUP_SECURITY);
-           
-        setupSecurity.Call(NULL);
-    }
-    EX_CATCH
-    {
-        // There is a possibility that we've already set the appdomain policy
-        // level for this process.  In that case we'll get a policy exception
-        // that we are free to ignore.
-        OBJECTREF pThrowable = GET_THROWABLE();
-        DefineFullyQualifiedNameForClassOnStack();
-        LPCUTF8 szClass = GetFullyQualifiedNameForClass(pThrowable->GetMethodTable());
-        if (strcmp(g_PolicyExceptionClassName, szClass) != 0)
-            COMPlusThrow(pThrowable);
-    }
-    EX_END_CATCH(RethrowTerminalExceptions)
-}
-
-Assembly* SecurityAttributes::LoadAssemblyFromToken(IMetaDataAssemblyImport *pImport, mdAssemblyRef tkAssemblyRef)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    _ASSERTE(TypeFromToken(tkAssemblyRef) == mdtAssemblyRef);
-
-    // Find all the details needed to name an assembly for loading.
-    ASSEMBLYMETADATA            sContext;
-    BYTE                       *pbPublicKeyOrToken;
-    DWORD                       cbPublicKeyOrToken;
-    DWORD                       dwFlags;
-    LPWSTR                      wszName;
-    DWORD                       cchName;
-
-    // Initialize ASSEMBLYMETADATA structure.
-    ZeroMemory(&sContext, sizeof(ASSEMBLYMETADATA));
-
-    // Retrieve size of assembly name.
-    HRESULT hr = pImport->GetAssemblyRefProps(tkAssemblyRef,          // [IN] The AssemblyRef for which to get the properties.
-                                        NULL,                 // [OUT] Pointer to the public key or token.
-                                        NULL,                 // [OUT] Count of bytes in the public key or token.
-                                        NULL,                 // [OUT] Buffer to fill with name.
-                                        NULL,                 // [IN] Size of buffer in wide chars.
-                                        &cchName,             // [OUT] Actual # of wide chars in name.
-                                        &sContext,            // [OUT] Assembly MetaData.
-                                        NULL,                 // [OUT] Hash blob.
-                                        NULL,                 // [OUT] Count of bytes in the hash blob.
-                                        NULL);                // [OUT] Flags.
-    _ASSERTE(SUCCEEDED(hr));
-
-    // Allocate the necessary buffers.
-    wszName = (LPWSTR)_alloca(cchName * sizeof(WCHAR));
-    sContext.szLocale = (LPWSTR)_alloca(sContext.cbLocale * sizeof(WCHAR));
-    sContext.rProcessor = (DWORD *)_alloca(sContext.ulProcessor * sizeof(DWORD));
-    sContext.rOS = (OSINFO *)_alloca(sContext.ulOS * sizeof(OSINFO));
-
-    // Get the assembly name and rest of naming properties.
-    hr = pImport->GetAssemblyRefProps(tkAssemblyRef,
-                                        (const void **)&pbPublicKeyOrToken,
-                                        &cbPublicKeyOrToken,
-                                        wszName,
-                                        cchName,
-                                        &cchName,
-                                        &sContext,
-                                        NULL,
-                                        NULL,
-                                        &dwFlags);
-    _ASSERTE(SUCCEEDED(hr));
-
-    // We've got the details of the assembly, just need to load it.
-
-    // Convert assembly name to UTF8.
-    MAKE_UTF8PTR_FROMWIDE(uszAssemblyName, wszName);
-
-    // Unfortunately we've got an ASSEMBLYMETADATA structure, but we need
-    // an AssemblyMetaDataInternal
-    AssemblyMetaDataInternal internalContext;
-
-    // Initialize the structure.
-    ZeroMemory(&internalContext, sizeof(AssemblyMetaDataInternal));
-
-    internalContext.usMajorVersion = sContext.usMajorVersion;
-    internalContext.usMinorVersion = sContext.usMinorVersion;
-    internalContext.usBuildNumber = sContext.usBuildNumber;
-    internalContext.usRevisionNumber = sContext.usRevisionNumber;
-    internalContext.rProcessor = sContext.rProcessor;
-    internalContext.ulProcessor = sContext.ulProcessor;
-    internalContext.rOS = sContext.rOS;
-    internalContext.ulOS = sContext.ulOS;
-    if(sContext.cbLocale)
-    {
-        MAKE_UTF8PTR_FROMWIDE(pLocale, sContext.szLocale);
-        internalContext.szLocale = pLocale;
-    }
-    else
-    {
-        internalContext.szLocale = "";
-    }
-
-    Assembly* pAssembly = NULL;
-    {
-        // Elevate thread's allowed loading level.  This can cause load failures if assemblies loaded from this point on require
-        // any assemblies currently being loaded.
-        OVERRIDE_LOAD_LEVEL_LIMIT(FILE_ACTIVE);
-        pAssembly = AssemblySpec::LoadAssembly(uszAssemblyName, 
-                                               &internalContext,
-                                               pbPublicKeyOrToken,
-                                               cbPublicKeyOrToken,
-                                               dwFlags);
-    }
-
-    // @todo: Add CORSECATTR_E_ASSEMBLY_LOAD_FAILED_EX context to this exception path?
-
-    return pAssembly;
-}
-
-TypeHandle FindSecurityAttributeHandle(LPCWSTR wszTypeName)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-    } CONTRACTL_END;
-
-    TypeHandle hType;
-    MethodDescCallSite findSecurityAttributeTypeHandle(METHOD__SECURITY_ATTRIBUTE__FIND_SECURITY_ATTRIBUTE_TYPE_HANDLE);
-
-    struct _gc {
-        STRINGREF str;
-    } gc;
-    
-    ZeroMemory(&gc, sizeof(gc));
-    
-    GCPROTECT_BEGIN(gc);
-    gc.str = StringObject::NewString(wszTypeName);
-    ARG_SLOT arg[1] = {
-        ObjToArgSlot(gc.str)
-    };
-
-    TypeHandle th = TypeHandle::FromPtr(findSecurityAttributeTypeHandle.Call_RetLPVOID(arg));
-    hType = th;
-    GCPROTECT_END();
-
-    return hType;
-}
-
-// @TODO: replace this method with a call to the reflection code that decodes CA blobs
-// and instantiates managed attribute objects.  Currently the most significant perf
-// cost of this method is due to TypeName::GetTypeWorker which it calls via
-// GetTypeFromAssemblyQualifiedName, and GetTypeUsingCASearchRules
-HRESULT SecurityAttributes::AttributeSetToManaged(OBJECTREF* /*OUT*/obj, CORSEC_ATTRSET* pAttrSet, OBJECTREF* pThrowable, DWORD* pdwErrorIndex, bool bLazy)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        // Assumption: if the first obj is protected, the whole array is protected
-        if (pAttrSet->dwAttrCount > 0) {PRECONDITION(IsProtectedByGCFrame (obj));}
-    } CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-    DWORD i;
-    TypeHandle hType;
-    MethodTable *pMT = NULL;
-    MethodDesc *pMD = NULL;
-
-    // Elevate the allowed loading level
-    // Elevate thread's allowed loading level.  This can cause load failures if assemblies loaded from this point on require any assemblies currently being loaded.  
-    OVERRIDE_LOAD_LEVEL_LIMIT(FILE_ACTIVE); 
-    OVERRIDE_TYPE_LOAD_LEVEL_LIMIT(CLASS_LOADED);
-
-    for (i = 0; i < pAttrSet->dwAttrCount; i++)
-    {
-        CORSEC_ATTRIBUTE *pAttr = &pAttrSet->pAttrs[i];
-
-        if (pdwErrorIndex)
-            *pdwErrorIndex = pAttr->dwIndex;
-
-        // Find the assembly that contains the security attribute class.
-        _ASSERTE(pAttr->pName);
-        Assembly *pAssembly;
-        
-        if (bLazy)
-        {
-            // Convert type name to Unicode
-            MAKE_WIDEPTR_FROMUTF8(wszTypeName, pAttr->pName);
-
-            {
-                // Load the type
-                {
-                    DWORD error = (DWORD)-1;
-                    NewHolder<TypeName> pTypeName = new TypeName(wszTypeName, &error);
-                    
-                    if (error == (DWORD)(-1) && !(pTypeName->GetAssembly()->IsEmpty()))
-                    {
-                        hType = pTypeName->GetTypeFromAsm(FALSE);
-                    }
-                    else
-                    {
-                        hType = TypeName::GetTypeFromAssembly(wszTypeName, SystemDomain::SystemAssembly());
-                    }
-                }
-
-                // Special workaround for if the compile-time version of the attribute is no longer available
-                if (hType.IsNull() || hType.GetMethodTable() == NULL)
-                    hType = FindSecurityAttributeHandle(wszTypeName);
-            }
-        }
-        else
-        {
-            if (!IsNilToken(pAttr->tkAssemblyRef) && TypeFromToken(pAttr->tkAssemblyRef) == mdtAssemblyRef)
-            {
-                // Load from AssemblyRef token stored in the CORSEC_ATTRSET
-                pAssembly = LoadAssemblyFromToken(pAttrSet->pImport, pAttr->tkAssemblyRef);
-            }
-            else
-            {
-                // Load from MSCORLIB.
-                pAssembly = SystemDomain::SystemAssembly();
-            }
-            _ASSERTE(pAssembly && "Failed to find assembly with declarative attribute");
-
-            EX_TRY
-            {
-                hType = ClassLoader::LoadTypeByNameThrowing(pAssembly, NULL, pAttr->pName);
-            }
-            EX_CATCH_THROWABLE(pThrowable);
-        }
-
-        // Load the security attribute class.
-        if (hType.IsNull() || (pMT = hType.GetMethodTable()) == NULL)
-        {
-            MAKE_WIDEPTR_FROMUTF8(wszTemp, pAttr->pName);
-            SString sMessage;
-            GetExceptionMessage(*pThrowable, sMessage);
-            if (!sMessage.IsEmpty())
-                hr = VMPostError(CORSECATTR_E_TYPE_LOAD_FAILED_EX, wszTemp, sMessage.GetUnicode());
-            else
-                hr = VMPostError(CORSECATTR_E_TYPE_LOAD_FAILED, wszTemp);
-            return hr;
-        }
-
-        // Make sure it's not abstract.
-        if (pMT->IsAbstract())
-            return VMPostError(CORSECATTR_E_ABSTRACT);
-
-#ifdef _DEBUG
-        // Make sure it's really a security attribute class
-        /*{
-            MethodTable *pParentMT = pMT->GetParentMethodTable();
-            CHAR       *szClass;
-            DefineFullyQualifiedNameForClassOnStack();
-            while (pParentMT) {
-                szClass = GetFullyQualifiedNameForClass(pParentMT->GetClass());
-                if (stricmpUTF8(szClass, COR_BASE_SECURITY_ATTRIBUTE_CLASS_ANSI) == 0)
-                    break;
-                pParentMT = pParentMT->GetParentMethodTable();
-            }
-            _ASSERTE(pParentMT && "Security attribute not derived from COR_BASE_SECURITY_ATTRIBUTE_CLASS");
-        }*/
-#endif
-
-        // Instantiate an instance.
-        obj[i] = pMT->Allocate();
-
-        // Find and call the constructor.
-        pMD = MemberLoader::FindConstructor(pMT, &gsig_IM_SecurityAction_RetVoid);
-        if (pMD == NULL)
-            return VMPostError(CORSECATTR_E_MISSING_CONSTRUCTOR);
-        MethodDescCallSite ctor(pMD);
-        ARG_SLOT args[] = {
-            ObjToArgSlot(obj[i]),
-            (ARG_SLOT)pAttrSet->dwAction
-        };
-        ctor.Call(args);
-
-        // Set the attributes and properties
-        hr = SetAttrFieldsAndProperties(pAttr, pThrowable, pMT, &obj[i]);
-        if (FAILED(hr))
-            return hr;
-    }
-
-    return hr;
-}
-
-
-HRESULT SecurityAttributes::SetAttrFieldsAndProperties(CORSEC_ATTRIBUTE *pAttr, OBJECTREF* pThrowable, MethodTable* pMT, OBJECTREF* pObj)
-{
-    // Setup fields and properties on the object, as specified by the
-    // serialized data passed to us.
-    BYTE   *pbBuffer = pAttr->pbValues;
-    SIZE_T  cbBuffer = pAttr->cbValues;
-    BYTE   *pbBufferEnd = pbBuffer + cbBuffer;
-    DWORD j;
-    HRESULT hr = S_OK;
-
-    EX_TRY
-    {
-        for (j = 0; j < pAttr->wValues; j++)
-        {
-            DWORD       dwType = 0;
-            BOOL        bIsField = FALSE;
-            BYTE       *pbName;
-            DWORD       cbName;
-            DWORD       dwLength;
-            NewArrayHolder<CHAR> szName(NULL);
-            TypeHandle      hEnum;
-            CorElementType  eEnumType = ELEMENT_TYPE_END;
-
-            // Check we've got at least the field/property specifier and the
-            // type code.
-            if(cbBuffer < (sizeof(BYTE) + sizeof(BYTE)))
-            {
-                hr = VMPostError(CORSECATTR_E_TRUNCATED);
-                goto Error;
-            }
-
-            // Grab the field/property specifier.
-            bIsField = *(BYTE*)pbBuffer == SERIALIZATION_TYPE_FIELD;
-            if(!bIsField && *(BYTE*)pbBuffer != SERIALIZATION_TYPE_PROPERTY)
-            {
-                hr = VMPostError(CORSECATTR_E_TRUNCATED);
-                goto Error;
-            }
-            pbBuffer += sizeof(BYTE);
-            cbBuffer -= sizeof(BYTE);
-
-            // Grab the value type.
-            dwType = *(BYTE*)pbBuffer;
-            pbBuffer += sizeof(BYTE);
-            cbBuffer -= sizeof(BYTE);
-
-            // If it's a type that needs further specification, get that information
-            switch (dwType)
-            {
-            case SERIALIZATION_TYPE_ENUM:
-                // Immediately after the enum type token is the fully
-                // qualified name of the value type used to represent
-                // the enum.
-                if (FAILED(CPackedLen::SafeGetData((BYTE const *)pbBuffer,
-                                                   (BYTE const *)pbBufferEnd,
-                                                   &cbName,
-                                                   (BYTE const **)&pbName)))
-                {
-                    hr = VMPostError(CORSECATTR_E_TRUNCATED);
-                    goto Error;
-                }
-
-                // SafeGetData ensured that the name is within the buffer
-                _ASSERTE(FitsIn<DWORD>((pbName - pbBuffer) + cbName));
-                dwLength = static_cast<DWORD>((pbName - pbBuffer) + cbName);
-                pbBuffer += dwLength;
-                cbBuffer -= dwLength;
-
-                // Buffer the name and nul terminate it.
-                szName = new (nothrow) CHAR[cbName + 1];
-                if (szName == NULL)
-                {
-                    hr = E_OUTOFMEMORY;
-                    goto Error;
-                }
-                memcpy(szName, pbName, cbName);
-                szName[cbName] = '\0';
-
-                // Lookup the type (possibly loading an assembly containing
-                // the type).
-                hEnum = TypeName::GetTypeUsingCASearchRules(szName, NULL);
- 
-                //If we couldn't find the type, post an error
-                if (hEnum.IsNull())
-                {
-                    MAKE_WIDEPTR_FROMUTF8(wszTemp, szName);
-                    SString sMessage;
-                    GetExceptionMessage(*pThrowable, sMessage);
-                    if (!sMessage.IsEmpty())
-                        hr = VMPostError(CORSECATTR_E_TYPE_LOAD_FAILED_EX, wszTemp, sMessage.GetUnicode());
-                    else
-                        hr = VMPostError(CORSECATTR_E_TYPE_LOAD_FAILED, wszTemp);
-                    goto Error;
-                }
-
-                // Calculate the underlying primitive type of the
-                // enumeration.
-                eEnumType = hEnum.GetInternalCorElementType();
-                break;
-            case SERIALIZATION_TYPE_SZARRAY:
-            case SERIALIZATION_TYPE_TYPE:
-                // Can't deal with these yet.
-                hr = VMPostError(CORSECATTR_E_UNSUPPORTED_TYPE);
-                goto Error;
-            }
-
-            // Grab the field/property name and length.
-            if (FAILED(CPackedLen::SafeGetData((BYTE const *)pbBuffer,
-                                               (BYTE const *)pbBufferEnd,
-                                               &cbName,
-                                               (BYTE const **)&pbName)))
-            {
-                hr = VMPostError(CORSECATTR_E_TRUNCATED);
-                goto Error;
-            }
-
-            // SafeGetData ensured that the name is within the buffer
-            _ASSERTE(FitsIn<DWORD>((pbName - pbBuffer) + cbName));
-            dwLength = static_cast<DWORD>((pbName - pbBuffer) + cbName);
-            pbBuffer += dwLength;
-            cbBuffer -= dwLength;
-
-            // Buffer the name and null terminate it.
-            szName = new (nothrow) CHAR[cbName + 1];
-            if (szName == NULL)
-            {
-                hr = E_OUTOFMEMORY;
-                goto Error;
-            }
-            memcpy(szName, pbName, cbName);
-            szName[cbName] = '\0';
-
-            // Set the field or property
-            if (bIsField)
-                hr = SetAttrField(&pbBuffer, &cbBuffer, dwType, hEnum, pMT, szName, pObj, dwLength, pbName, cbName, eEnumType);
-            else
-                hr = SetAttrProperty(&pbBuffer, &cbBuffer, pMT, dwType, szName, pObj, dwLength, pbName, cbName, eEnumType);
-        }
-    }
-Error:;
-    EX_CATCH
-    {
-        hr = GET_EXCEPTION()->GetHR();
-        if (pThrowable)
-        {
-            *pThrowable = GET_THROWABLE();
-        }
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-    return hr;
-}
-
-HRESULT SecurityAttributes::SetAttrField(BYTE** ppbBuffer, SIZE_T* pcbBuffer, DWORD dwType, TypeHandle hEnum, MethodTable* pMT, __in_z LPSTR szName, OBJECTREF* pObj, DWORD dwLength, BYTE* pbName, DWORD cbName, CorElementType eEnumType)
-{
-    DWORD cbSig = 0;
-    NewArrayHolder<BYTE> pbSig(new (nothrow) BYTE[128]);
-    if (pbSig == NULL)
-        return E_OUTOFMEMORY;
-
-    BYTE *pbBufferEnd = *ppbBuffer + *pcbBuffer;
-
-    // Build the field signature.
-    cbSig += CorSigCompressData((ULONG)IMAGE_CEE_CS_CALLCONV_FIELD, &pbSig[cbSig]);
-    switch (dwType)
-    {
-    case SERIALIZATION_TYPE_BOOLEAN:
-    case SERIALIZATION_TYPE_I1:
-    case SERIALIZATION_TYPE_I2:
-    case SERIALIZATION_TYPE_I4:
-    case SERIALIZATION_TYPE_I8:
-    case SERIALIZATION_TYPE_U1:
-    case SERIALIZATION_TYPE_U2:
-    case SERIALIZATION_TYPE_U4:
-    case SERIALIZATION_TYPE_U8:
-    case SERIALIZATION_TYPE_R4:
-    case SERIALIZATION_TYPE_R8:
-    case SERIALIZATION_TYPE_CHAR:
-        static_assert_no_msg(SERIALIZATION_TYPE_BOOLEAN == (CorSerializationType)ELEMENT_TYPE_BOOLEAN);
-        static_assert_no_msg(SERIALIZATION_TYPE_I1 == (CorSerializationType)ELEMENT_TYPE_I1);
-        static_assert_no_msg(SERIALIZATION_TYPE_I2 == (CorSerializationType)ELEMENT_TYPE_I2);
-        static_assert_no_msg(SERIALIZATION_TYPE_I4 == (CorSerializationType)ELEMENT_TYPE_I4);
-        static_assert_no_msg(SERIALIZATION_TYPE_I8 == (CorSerializationType)ELEMENT_TYPE_I8);
-        static_assert_no_msg(SERIALIZATION_TYPE_U1 == (CorSerializationType)ELEMENT_TYPE_U1);
-        static_assert_no_msg(SERIALIZATION_TYPE_U2 == (CorSerializationType)ELEMENT_TYPE_U2);
-        static_assert_no_msg(SERIALIZATION_TYPE_U4 == (CorSerializationType)ELEMENT_TYPE_U4);
-        static_assert_no_msg(SERIALIZATION_TYPE_U8 == (CorSerializationType)ELEMENT_TYPE_U8);
-        static_assert_no_msg(SERIALIZATION_TYPE_R4 == (CorSerializationType)ELEMENT_TYPE_R4);
-        static_assert_no_msg(SERIALIZATION_TYPE_R8 == (CorSerializationType)ELEMENT_TYPE_R8);
-        static_assert_no_msg(SERIALIZATION_TYPE_CHAR == (CorSerializationType)ELEMENT_TYPE_CHAR);
-            cbSig += CorSigCompressData(dwType, &pbSig[cbSig]);
-        break;
-    case SERIALIZATION_TYPE_STRING:
-            cbSig += CorSigCompressData((ULONG)ELEMENT_TYPE_STRING, &pbSig[cbSig]);
-        break;
-    case SERIALIZATION_TYPE_ENUM:
-        // To avoid problems when the field and enum are defined
-        // in different scopes (we'd have to go hunting for
-        // typerefs), we build a signature with a special type
-        // (ELEMENT_TYPE_INTERNAL, which contains a TypeHandle).
-        // This compares loaded types for indentity.
-            cbSig += CorSigCompressData((ULONG)ELEMENT_TYPE_INTERNAL, &pbSig[cbSig]);
-            cbSig += CorSigCompressPointer(hEnum.AsPtr(), &pbSig[cbSig]);
-        break;
-    default:
-        return VMPostError(CORSECATTR_E_UNSUPPORTED_TYPE);
-    }
-
-
-    // Locate a field desc.
-    FieldDesc* pFD = MemberLoader::FindField(pMT, szName, (PCCOR_SIGNATURE)pbSig,
-                                     cbSig, pMT->GetModule());
-    if (pFD == NULL)
-    {
-        MAKE_WIDEPTR_FROMUTF8(wszTemp, szName);
-        return VMPostError(CORSECATTR_E_NO_FIELD, wszTemp);
-    }
-
-    // Set the field value.
-    LPSTR szString;
-    switch (dwType)
-    {
-    case SERIALIZATION_TYPE_BOOLEAN:
-    case SERIALIZATION_TYPE_I1:
-    case SERIALIZATION_TYPE_U1:
-            if(*pcbBuffer < sizeof(BYTE))
-                return VMPostError(CORSECATTR_E_TRUNCATED);
-        pFD->SetValue8(*pObj, *(BYTE*)(*ppbBuffer));
-        (*ppbBuffer) += sizeof(BYTE);
-        (*pcbBuffer) -= sizeof(BYTE);
-        break;
-    case SERIALIZATION_TYPE_CHAR:
-    case SERIALIZATION_TYPE_I2:
-    case SERIALIZATION_TYPE_U2:
-            if(*pcbBuffer < sizeof(WORD))
-                return VMPostError(CORSECATTR_E_TRUNCATED);
-        pFD->SetValue16(*pObj, GET_UNALIGNED_VAL16(*ppbBuffer));
-        (*ppbBuffer) += sizeof(WORD);
-        (*pcbBuffer) -= sizeof(WORD);
-        break;
-    case SERIALIZATION_TYPE_I4:
-    case SERIALIZATION_TYPE_U4:
-    case SERIALIZATION_TYPE_R4:
-            if(*pcbBuffer < sizeof(DWORD))
-                return VMPostError(CORSECATTR_E_TRUNCATED);
-        pFD->SetValue32(*pObj, GET_UNALIGNED_VAL32(*ppbBuffer));
-        (*ppbBuffer) += sizeof(DWORD);
-        (*pcbBuffer) -= sizeof(DWORD);
-        break;
-    case SERIALIZATION_TYPE_I8:
-    case SERIALIZATION_TYPE_U8:
-    case SERIALIZATION_TYPE_R8:
-            if(*pcbBuffer < sizeof(INT64))
-                return VMPostError(CORSECATTR_E_TRUNCATED);
-        pFD->SetValue64(*pObj, GET_UNALIGNED_VAL64(*ppbBuffer));
-        (*ppbBuffer) += sizeof(INT64);
-        (*pcbBuffer) -= sizeof(INT64);
-        break;
-    case SERIALIZATION_TYPE_STRING:
-        // Ensures special case 'null' check below does not overrun buffer
-        if(*ppbBuffer >= pbBufferEnd) {
-            return VMPostError(CORSECATTR_E_TRUNCATED);
-        }
-        // Special case 'null' (represented as a length byte of '0xFF').
-        if (*(*ppbBuffer) == 0xFF) {
-            szString = NULL;
-            dwLength = sizeof(BYTE);
-        } else {
-            if (FAILED(CPackedLen::SafeGetData((BYTE const *)*ppbBuffer,
-                                               (BYTE const *)pbBufferEnd,
-                                               &cbName,
-                                               (BYTE const **)&pbName)))
-            {
-                return VMPostError(CORSECATTR_E_TRUNCATED);
-            }
-
-            // SafeGetData will ensure the name is within the buffer
-            _ASSERTE(FitsIn<DWORD>((pbName - *ppbBuffer) + cbName));
-            dwLength = static_cast<DWORD>((pbName - *ppbBuffer) + cbName);
-
-            DWORD allocLen = cbName + 1;
-            // Buffer and nul terminate it.
-            szString = (LPSTR)_alloca(allocLen);
-            memcpy(szString, pbName, cbName);
-            szString[cbName] = '\0';
-
-        }
-
-        // Allocate and initialize a managed version of the string.
-        {
-            STRINGREF orString;
-            if (szString)
-            {
-                orString = StringObject::NewString(szString, cbName);
-                if (orString == NULL)
-                    COMPlusThrowOM();
-            }
-            else
-                orString = NULL;
-
-            pFD->SetRefValue(*pObj, (OBJECTREF)orString);
-        }
-
-        (*ppbBuffer) += dwLength;
-        (*pcbBuffer) -= dwLength;
-        break;
-    case SERIALIZATION_TYPE_ENUM:
-        // Get the underlying primitive type.
-        switch (eEnumType)
-        {
-        case ELEMENT_TYPE_I1:
-        case ELEMENT_TYPE_U1:
-                    if(*pcbBuffer < sizeof(BYTE))
-                        return VMPostError(CORSECATTR_E_TRUNCATED);
-            pFD->SetValue8(*pObj, *(BYTE*)(*ppbBuffer));
-            (*ppbBuffer) += sizeof(BYTE);
-            (*pcbBuffer) -= sizeof(BYTE);
-            break;
-        case ELEMENT_TYPE_I2:
-        case ELEMENT_TYPE_U2:
-                    if(*pcbBuffer < sizeof(WORD))
-                        return VMPostError(CORSECATTR_E_TRUNCATED);
-            pFD->SetValue16(*pObj, GET_UNALIGNED_VAL16(*ppbBuffer));
-            (*ppbBuffer) += sizeof(WORD);
-            (*pcbBuffer) -= sizeof(WORD);
-            break;
-        case ELEMENT_TYPE_I4:
-        case ELEMENT_TYPE_U4:
-                    if(*pcbBuffer < sizeof(DWORD))
-                        return VMPostError(CORSECATTR_E_TRUNCATED);
-            pFD->SetValue32(*pObj, GET_UNALIGNED_VAL32(*ppbBuffer));
-            (*ppbBuffer) += sizeof(DWORD);
-            (*pcbBuffer) -= sizeof(DWORD);
-            break;
-        default:
-            return VMPostError(CORSECATTR_E_UNSUPPORTED_ENUM_TYPE);
-        }
-        break;
-    default:
-        return VMPostError(CORSECATTR_E_UNSUPPORTED_TYPE);
-    }
-    return S_OK;
-}
-
-HRESULT SecurityAttributes::SetAttrProperty(BYTE** ppbBuffer, SIZE_T* pcbBuffer, MethodTable* pMT, DWORD dwType, __in_z LPSTR szName, OBJECTREF* pObj, DWORD dwLength, BYTE* pbName, DWORD cbName, CorElementType eEnumType)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        PRECONDITION(IsProtectedByGCFrame (pObj));
-    } CONTRACTL_END;
-
-    // Locate the property setter.
-    MethodDesc* pMD = MemberLoader::FindPropertyMethod(pMT, szName, PropertySet);
-    if (pMD == NULL)
-    {
-        MAKE_WIDEPTR_FROMUTF8(wszTemp, szName);
-        return VMPostError(CORSECATTR_E_NO_PROPERTY, wszTemp);
-    }
-
-    MethodDescCallSite propSet(pMD);
-
-    // Build the argument list.
-    ARG_SLOT args[2] = { NULL, NULL };
-    LPSTR szString;
-    NewHolder<BYTE> tmpLargeStringHolder (NULL);
-
-    switch (dwType)
-    {
-    case SERIALIZATION_TYPE_BOOLEAN:
-    case SERIALIZATION_TYPE_I1:
-    case SERIALIZATION_TYPE_U1:
-        if(*pcbBuffer < sizeof(BYTE))
-            return VMPostError(CORSECATTR_E_TRUNCATED);
-        args[1] = (ARG_SLOT)*(BYTE*)(*ppbBuffer);
-        (*ppbBuffer) += sizeof(BYTE);
-        (*pcbBuffer) -= sizeof(BYTE);
-        break;
-    case SERIALIZATION_TYPE_CHAR:
-    case SERIALIZATION_TYPE_I2:
-    case SERIALIZATION_TYPE_U2:
-        if(*pcbBuffer < sizeof(WORD))
-            return VMPostError(CORSECATTR_E_TRUNCATED);
-        args[1] = (ARG_SLOT)GET_UNALIGNED_VAL16(*ppbBuffer);
-        (*ppbBuffer) += sizeof(WORD);
-        (*pcbBuffer) -= sizeof(WORD);
-        break;
-    case SERIALIZATION_TYPE_I4:
-    case SERIALIZATION_TYPE_U4:
-    case SERIALIZATION_TYPE_R4:
-        if(*pcbBuffer < sizeof(DWORD))
-            return VMPostError(CORSECATTR_E_TRUNCATED);
-        args[1] = (ARG_SLOT)GET_UNALIGNED_VAL32(*ppbBuffer);
-        (*ppbBuffer) += sizeof(DWORD);
-        (*pcbBuffer) -= sizeof(DWORD);
-        break;
-    case SERIALIZATION_TYPE_I8:
-    case SERIALIZATION_TYPE_U8:
-    case SERIALIZATION_TYPE_R8:
-        if(*pcbBuffer < sizeof(INT64))
-            return VMPostError(CORSECATTR_E_TRUNCATED);
-        args[1] = (ARG_SLOT)GET_UNALIGNED_VAL64(*ppbBuffer);
-        (*ppbBuffer) += sizeof(INT64);
-        (*pcbBuffer) -= sizeof(INT64);
-        break;
-    case SERIALIZATION_TYPE_STRING:
-        // Ensures special case 'null' check below does not overrun buffer
-        if(*pcbBuffer < sizeof(BYTE)) {
-            return VMPostError(CORSECATTR_E_TRUNCATED);
-        }
-        // Special case 'null' (represented as a length byte of '0xFF').
-        if (*(*ppbBuffer) == 0xFF) {
-            szString = NULL;
-            dwLength = sizeof(BYTE);
-            if(*pcbBuffer < sizeof(BYTE))
-                return VMPostError(CORSECATTR_E_TRUNCATED);
-        } else {
-
-            if (FAILED(CPackedLen::SafeGetData((BYTE const *)(*ppbBuffer),
-                                               (BYTE const *)(*ppbBuffer + *pcbBuffer),
-                                               &cbName,
-                                               (BYTE const **)&pbName)))
-            {
-                return VMPostError(CORSECATTR_E_TRUNCATED);
-            }
-
-            // Used below - SafeGetData ensures that name is within the buffer
-            _ASSERTE(FitsIn<DWORD>((pbName - *ppbBuffer) + cbName));
-            dwLength = static_cast<DWORD>((pbName - *ppbBuffer) + cbName);
-            
-            DWORD allocLen = cbName + 1;
-
-            // 
-            // For smaller size strings allocate from stack, use heap otherwise
-            //
-
-            if ((pbName - *ppbBuffer) < 4) {
-                // Buffer and nul terminate it.
-                szString = (LPSTR)_alloca(allocLen);
-            } else {
-                tmpLargeStringHolder = new BYTE[allocLen];                
-                szString = (LPSTR) ((BYTE*)tmpLargeStringHolder);
-            }
-
-            memcpy(szString, pbName, cbName);
-            szString[cbName] = '\0';
-        }
-
-        // Allocate and initialize a managed version of the string.
-        {
-            STRINGREF orString;
-
-            if (szString) {
-                orString = StringObject::NewString(szString, cbName);
-                if (orString == NULL)
-                    COMPlusThrowOM();
-            } else
-                orString = NULL;
-
-            args[1] = ObjToArgSlot(orString);
-        }
-
-        (*ppbBuffer) += dwLength;
-        (*pcbBuffer) -= dwLength;
-        break;
-    case SERIALIZATION_TYPE_ENUM:
-        // Get the underlying primitive type.
-        switch (eEnumType)
-        {
-        case ELEMENT_TYPE_I1:
-        case ELEMENT_TYPE_U1:
-                if(*pcbBuffer < sizeof(BYTE))
-                    return VMPostError(CORSECATTR_E_TRUNCATED);
-            args[1] = (ARG_SLOT)*(BYTE*)(*ppbBuffer);
-            (*ppbBuffer) += sizeof(BYTE);
-            (*pcbBuffer) -= sizeof(BYTE);
-            break;
-        case ELEMENT_TYPE_I2:
-        case ELEMENT_TYPE_U2:
-                if(*pcbBuffer < sizeof(WORD))
-                    return VMPostError(CORSECATTR_E_TRUNCATED);
-            args[1] = (ARG_SLOT)GET_UNALIGNED_VAL16(*ppbBuffer);
-            (*ppbBuffer) += sizeof(WORD);
-            (*pcbBuffer) -= sizeof(WORD);
-            break;
-        case ELEMENT_TYPE_I4:
-        case ELEMENT_TYPE_U4:
-                if(*pcbBuffer < sizeof(DWORD))
-                    return VMPostError(CORSECATTR_E_TRUNCATED);
-            args[1] = (ARG_SLOT)GET_UNALIGNED_VAL32(*ppbBuffer);
-            (*ppbBuffer) += sizeof(DWORD);
-            (*pcbBuffer) -= sizeof(DWORD);
-            break;
-        default:
-            return VMPostError(CORSECATTR_E_UNSUPPORTED_ENUM_TYPE);
-        }
-        break;
-    default:
-        return VMPostError(CORSECATTR_E_UNSUPPORTED_TYPE);
-    }
-
-
-    // ! don't move this up, StringObject::NewString
-    // ! inside the switch causes a GC
-    args[0] = ObjToArgSlot(*pObj);
-
-    // Call the setter.
-    propSet.Call(args);
-
-    return S_OK;
-}
-
-
-void SecurityAttributes::AttrSetBlobToPermissionSets(
-                                            IN BYTE* pbRawPermissions, 
-                                            IN DWORD cbRawPermissions,
-                                            OUT OBJECTREF* pObj,
-                                            DWORD dwAction)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-    } CONTRACTL_END;
-
-    _ASSERTE(pbRawPermissions);
-    _ASSERTE(cbRawPermissions > 0);
-    _ASSERTE(pbRawPermissions[0] == LAZY_DECL_SEC_FLAG);
-
-    HRESULT hr = S_OK;
-    CORSEC_ATTRSET pset;
-
-    // Deserialize the CORSEC_ATTRSET
-    hr = BlobToAttributeSet(pbRawPermissions, cbRawPermissions, &pset, dwAction);
-    if(FAILED(hr))
-        COMPlusThrowHR(hr);
-
-    OBJECTREF throwable = NULL;
-    GCPROTECT_BEGIN(throwable);
-    {
-        // allocate and GC-protect an array of objectrefs to reference the permissions
-        OBJECTREF* attrArray = (OBJECTREF*)_alloca(pset.dwAttrCount * sizeof(OBJECTREF));
-        memset(attrArray, 0, pset.dwAttrCount * sizeof(OBJECTREF));
-        GCPROTECT_ARRAY_BEGIN(*attrArray, pset.dwAttrCount);
-        {
-            // Convert to a managed array of attribute objects
-            DWORD dwErrorIndex;
-            hr = AttributeSetToManaged(/*OUT*/attrArray, &pset, &throwable, &dwErrorIndex, true);
-
-            // Convert the array of attribute objects to a serialized PermissionSet
-            if (SUCCEEDED(hr))
-            {
-                BYTE* pbXmlBlob = NULL;
-                DWORD cbXmlBlob = 0;
-                BYTE* pbNonCasXmlBlob = NULL;
-                DWORD cbNonCasXmlBlob = 0;
-
-                AttrArrayToPermissionSet(attrArray,
-                                         false,
-                                         pset.dwAttrCount,
-                                         &pbXmlBlob,
-                                         &cbXmlBlob,
-                                         &pbNonCasXmlBlob,
-                                         &cbNonCasXmlBlob,
-                                         ActionAllowsNullPermissionSet(static_cast<CorDeclSecurity>(dwAction)),
-                                         pObj);
-
-                _ASSERTE(pbXmlBlob == NULL && cbXmlBlob == 0 && pbNonCasXmlBlob == NULL && cbNonCasXmlBlob == 0);
-            }
-        }
-        GCPROTECT_END();
-    }
-    GCPROTECT_END();
-
-    if(FAILED(hr))
-        COMPlusThrowHR(hr);
-}
-
-HRESULT SecurityAttributes::TranslateSecurityAttributesHelper(
-                            CORSEC_ATTRSET    *pAttrSet,
-                            BYTE          **ppbOutput,
-                            DWORD          *pcbOutput,
-                            BYTE          **ppbNonCasOutput,
-                            DWORD          *pcbNonCasOutput,
-                            DWORD          *pdwErrorIndex)
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    HRESULT                     hr = S_OK;
-    OBJECTREF                  *attrArray;
-    DWORD                       dwGlobalError = 0;
-
-    EX_TRY
-    {
-        if (pdwErrorIndex)
-            dwGlobalError = *pdwErrorIndex;
-
-        // Get into the context of the special compilation appdomain (which has an
-        // AppBase set to the current directory).
-        ComCallWrapper *pWrap = ComCallWrapper::GetWrapperFromIP(pAttrSet->pAppDomain);
-
-        ENTER_DOMAIN_ID(pWrap->GetDomainID())
-        {
-            struct _gc {
-                OBJECTREF throwable;
-                OBJECTREF orPermSet;
-            } gc;
-            ZeroMemory(&gc, sizeof(gc));
-            GCPROTECT_BEGIN(gc);
-            {
-                // we need to setup special security settings that we use during compilation
-                SetupRestrictSecAttributes();
-
-                // allocate and protect an array of objectrefs to reference the permissions
-                attrArray = (OBJECTREF*)_alloca(pAttrSet->dwAttrCount * sizeof(OBJECTREF));
-                memset(attrArray, 0, pAttrSet->dwAttrCount * sizeof(OBJECTREF));
-                GCPROTECT_ARRAY_BEGIN(*attrArray, pAttrSet->dwAttrCount);
-                {
-                    // Convert to an array of attributes, and then serialize to XML
-                    hr = AttributeSetToManaged(/*OUT*/attrArray, pAttrSet, &gc.throwable, pdwErrorIndex, false);
-                    if (SUCCEEDED(hr))
-                    {
-                        if (pdwErrorIndex)
-                            *pdwErrorIndex = dwGlobalError;
-
-                        // Convert the array of attribute objects to a serialized PermissionSet or PermissionSetCollection
-                        AttrArrayToPermissionSet(attrArray,
-                                                 true,
-                                                 pAttrSet->dwAttrCount,
-                                                 ppbOutput,
-                                                 pcbOutput,
-                                                 ppbNonCasOutput,
-                                                 pcbNonCasOutput,
-                                                 ActionAllowsNullPermissionSet(static_cast<CorDeclSecurity>(pAttrSet->dwAction)),
-                                                 &gc.orPermSet);
-                    }
-                }
-                GCPROTECT_END();
-            }
-            GCPROTECT_END(); // for throwable
-        }
-        END_DOMAIN_TRANSITION;   
-    }
-    EX_CATCH_HRESULT(hr);
-    return hr;
-}
-
-// Call into managed code to group permissions into a PermissionSet and serialize it to XML
-void SecurityAttributes::AttrArrayToPermissionSet(OBJECTREF* attrArray,
-                                                  bool fSerialize,
-                                                  DWORD attrCount,
-                                                  BYTE **ppbOutput,
-                                                  DWORD *pcbOutput,
-                                                  BYTE **ppbNonCasOutput,
-                                                  DWORD *pcbNonCasOutput,
-                                                  bool fAllowEmptyPermissionSet,
-                                                  OBJECTREF* pPermSet)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    EApiCategories eProtectedCategories = (EApiCategories)(GetHostProtectionManager()->GetProtectedCategories());
-
-    MethodDescCallSite createSerialized(METHOD__PERMISSION_SET__CREATE_SERIALIZED);
-
-    // Allocate a managed array of security attribute objects for input to the function.
-    PTRARRAYREF orInput = (PTRARRAYREF) AllocateObjectArray(attrCount, g_pObjectClass);
-
-    // Copy over the permission objects references.
-    DWORD i;
-    for (i = 0; i < attrCount; i++)
-    {
-        orInput->SetAt(i, attrArray[i]);
-    }
-
-    // Call the routine.
-    struct _gc {
-        U1ARRAYREF orNonCasOutput;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-    GCPROTECT_BEGIN(gc);
-
-    ARG_SLOT args[] = { 
-        ObjToArgSlot(orInput),
-        BoolToArgSlot(fSerialize),
-        PtrToArgSlot(&gc.orNonCasOutput),
-        PtrToArgSlot(pPermSet),
-        (ARG_SLOT)eProtectedCategories,
-        BoolToArgSlot(fAllowEmptyPermissionSet)
-    };
-    U1ARRAYREF orOutput = NULL;
-
-    {
-        // Elevate the allowed loading level
-        // Elevate thread's allowed loading level.  This can cause load failures if assemblies loaded from this point on require any assemblies currently being loaded.
-        OVERRIDE_LOAD_LEVEL_LIMIT(FILE_ACTIVE); 
-        OVERRIDE_TYPE_LOAD_LEVEL_LIMIT(CLASS_LOADED);
-
-        orOutput = (U1ARRAYREF) createSerialized.Call_RetOBJECTREF(args);
-    }
-
-    // Buffer the managed output in a native binary blob.
-    // Special case the empty blob. We might get a second blob output if
-    // there were any non-CAS permissions present.
-    NewArrayHolder<BYTE> TempOutput(NULL);
-    NewArrayHolder<BYTE> TempNonCasOutput(NULL);
-
-    if (orOutput == NULL)
-    {
-        *pcbOutput = 0;
-    }
-    else
-    {
-        BYTE   *pbArray = orOutput->GetDataPtr();
-        DWORD   cbArray = orOutput->GetNumComponents();
-        TempOutput = new BYTE[cbArray];
-        memcpy(TempOutput, pbArray, cbArray);
-        *pcbOutput = cbArray;
-    }
-
-    if (gc.orNonCasOutput == NULL)
-    {
-        *pcbNonCasOutput = 0;
-    }
-    else
-    {
-        BYTE   *pbArray = gc.orNonCasOutput->GetDataPtr();
-        DWORD   cbArray = gc.orNonCasOutput->GetNumComponents();
-        TempNonCasOutput = new BYTE[cbArray];
-        memcpy(TempNonCasOutput, pbArray, cbArray);
-        *pcbNonCasOutput = cbArray;
-    }
-
-    *ppbOutput = TempOutput;
-    *ppbNonCasOutput = TempNonCasOutput;
-
-    TempOutput.SuppressRelease();
-    TempNonCasOutput.SuppressRelease();
-
-    GCPROTECT_END();
-}
-#endif // FEATURE_CAS_POLICY
-
 //
 // This is a public exported method
 //
@@ -1363,27 +101,7 @@ HRESULT STDMETHODCALLTYPE TranslateSecurityAttributes(CORSEC_ATTRSET    *pAttrSe
                             DWORD          *pcbNonCasOutput,
                             DWORD          *pdwErrorIndex)
 {
-#ifdef FEATURE_CAS_POLICY
-    CONTRACTL {
-        NOTHROW;
-        GC_TRIGGERS;
-        ENTRY_POINT;    
-        MODE_ANY;
-    } CONTRACTL_END;
-    HRESULT hr = S_OK;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    GCX_COOP(); // because it calls into managed code to instantiate the PermissionSet objects
-    hr = SecurityAttributes::TranslateSecurityAttributesHelper(pAttrSet, ppbOutput, pcbOutput, 
-                ppbNonCasOutput, pcbNonCasOutput, pdwErrorIndex);        
-
-    END_ENTRYPOINT_NOTHROW;
-
-    return hr;
-#else
     return E_NOTIMPL;
-#endif
 }
 
 
@@ -2068,110 +786,12 @@ HRESULT GetFullyQualifiedTypeName(SString* pString, mdAssemblyRef tkAssemblyRef,
     (*pString) += W(", ");
 
     DWORD dwDisplayFlags = ASM_DISPLAYF_VERSION | ASM_DISPLAYF_PUBLIC_KEY_TOKEN | ASM_DISPLAYF_CULTURE;
-#ifdef FEATURE_FUSION // why is Security  accessing Fusion interfaces bypassing Loader?
-    // Retrieve size of assembly name
-    ASSEMBLYMETADATA sContext;
-    ZeroMemory(&sContext, sizeof(ASSEMBLYMETADATA));
-    HRESULT hr = S_OK;
-    LPWSTR wszAssemblyName = NULL;
-    BYTE *pbPublicKeyOrToken = NULL;
-    DWORD cbPublicKeyOrToken = 0;
-    DWORD dwFlags = 0;
-    if(TypeFromToken(tkAssemblyRef) == mdtAssembly)
-    {
-        DWORD cchName;
-        hr = pImport->GetAssemblyProps(tkAssemblyRef,    // [IN] The Assembly for which to get the properties.
-                                            NULL,        // [OUT] Pointer to the public key or token.
-                                            NULL,        // [OUT] Count of bytes in the public key or token.
-                                            NULL,        // [OUT] Hash Algorithm
-                                            NULL,        // [OUT] Buffer to fill with name.
-                                            NULL,        // [IN] Size of buffer in wide chars.
-                                            &cchName,    // [OUT] Actual # of wide chars in name.
-                                            &sContext,   // [OUT] Assembly MetaData.
-                                            NULL);       // [OUT] Flags.
-        if(FAILED(hr))
-            return hr;
-
-        // Get the assembly name other naming properties
-        wszAssemblyName = (LPWSTR)_alloca(cchName * sizeof(WCHAR));
-        hr = pImport->GetAssemblyProps(tkAssemblyRef,
-                                            (const void **)&pbPublicKeyOrToken,
-                                            &cbPublicKeyOrToken,
-                                            NULL,
-                                            wszAssemblyName,
-                                            cchName,
-                                            &cchName,
-                                            &sContext,
-                                            &dwFlags);
-        if(FAILED(hr))
-            return hr;
-    }
-    else if(TypeFromToken(tkAssemblyRef) == mdtAssemblyRef)
-    {
-        DWORD cchName;
-        hr = pImport->GetAssemblyRefProps(tkAssemblyRef, // [IN] The AssemblyRef for which to get the properties.
-                                            NULL,        // [OUT] Pointer to the public key or token.
-                                            NULL,        // [OUT] Count of bytes in the public key or token.
-                                            NULL,        // [OUT] Buffer to fill with name.
-                                            NULL,        // [IN] Size of buffer in wide chars.
-                                            &cchName,    // [OUT] Actual # of wide chars in name.
-                                            &sContext,   // [OUT] Assembly MetaData.
-                                            NULL,        // [OUT] Hash blob.
-                                            NULL,        // [OUT] Count of bytes in the hash blob.
-                                            NULL);       // [OUT] Flags.
-        if(FAILED(hr))
-            return hr;
-
-        // Get the assembly name other naming properties
-        wszAssemblyName = (LPWSTR)_alloca(cchName * sizeof(WCHAR));
-        hr = pImport->GetAssemblyRefProps(tkAssemblyRef,
-                                            (const void **)&pbPublicKeyOrToken,
-                                            &cbPublicKeyOrToken,
-                                            wszAssemblyName,
-                                            cchName,
-                                            &cchName,
-                                            &sContext,
-                                            NULL,
-                                            NULL,
-                                            &dwFlags);
-        if(FAILED(hr))
-            return hr;
-    }
-    else
-    {
-        _ASSERTE(false && "unexpected token");
-    }
-
-    // Convert to an AssemblyNameObject
-    ReleaseHolder<IAssemblyName> pAssemblyNameObj;
-    hr = CreateAssemblyNameObject(&pAssemblyNameObj, wszAssemblyName, CANOF_PARSE_DISPLAY_NAME, NULL);
-    if(FAILED(hr))
-        return hr;
-    _ASSERTE(pAssemblyNameObj && "assembly name object shouldn't be NULL");
-    pAssemblyNameObj->SetProperty(ASM_NAME_MAJOR_VERSION, &sContext.usMajorVersion, sizeof(WORD));
-    pAssemblyNameObj->SetProperty(ASM_NAME_MINOR_VERSION, &sContext.usMinorVersion, sizeof(WORD));
-    pAssemblyNameObj->SetProperty(ASM_NAME_BUILD_NUMBER, &sContext.usBuildNumber, sizeof(WORD));
-    pAssemblyNameObj->SetProperty(ASM_NAME_REVISION_NUMBER, &sContext.usRevisionNumber, sizeof(WORD));
-    pAssemblyNameObj->SetProperty(ASM_NAME_CULTURE, W(""), sizeof(WCHAR));
-    if(pbPublicKeyOrToken && cbPublicKeyOrToken > 0)
-    {
-        if(dwFlags & afPublicKey)
-            pAssemblyNameObj->SetProperty(ASM_NAME_PUBLIC_KEY, pbPublicKeyOrToken, cbPublicKeyOrToken);
-        else
-            pAssemblyNameObj->SetProperty(ASM_NAME_PUBLIC_KEY_TOKEN, pbPublicKeyOrToken, cbPublicKeyOrToken);
-    }
-
-    // Convert assembly name to an ole string
-    StackSString name;
-    FusionBind::GetAssemblyNameDisplayName(pAssemblyNameObj, name, dwDisplayFlags);
-#else // FEATURE_FUSION
     HRESULT hr;
     AssemblySpec spec;
     StackSString name;
 
     IfFailRet(spec.Init((mdToken)tkAssemblyRef,pImport));
     spec.GetFileOrDisplayName(dwDisplayFlags,name);
-#endif // FEATURE_FUSION
     _ASSERTE(!name.IsEmpty() && "the assembly name should not be empty here");
 
     (*pString) += name;
diff --git a/src/vm/securityattributes.h b/src/vm/securityattributes.h
index 5bcff51ec9..8408309b0a 100644
--- a/src/vm/securityattributes.h
+++ b/src/vm/securityattributes.h
@@ -38,22 +38,12 @@ namespace SecurityAttributes
     // Creates a new permission set
     OBJECTREF CreatePermissionSet(BOOL fTrusted);
 
-#ifdef FEATURE_CAS_POLICY
-    // Takes two PermissionSets (referenced by index) and merges them (unions or intersects
-    // depending on fIntersect) and returns the index of the merged PermissionSet
-    PsetCacheEntry* MergePermissionSets(IN PsetCacheEntry *pPCE1, IN PsetCacheEntry *pPCE2, IN bool fIntersect, IN DWORD dwAction);
-#endif // FEATURE_CAS_POLICY
 
     // Uses new to create the byte array that is returned.
     void CopyByteArrayToEncoding(IN U1ARRAYREF* pArray,
                                         OUT PBYTE* pbData,
                                         OUT DWORD* cbData);
 
-#ifdef FEATURE_CAS_POLICY
-    void EncodePermissionSet(IN OBJECTREF* pRef,
-                                    OUT PBYTE* ppbData,
-                                    OUT DWORD* pcbData);
-#endif // FEATURE_CAS_POLICY
 
     // Generic routine, use with encoding calls that 
     // use the EncodePermission client data
@@ -125,16 +115,6 @@ namespace SecurityAttributes
     void AttrArrayToPermissionSet(OBJECTREF* attrArray, bool fSerialize, DWORD attrCount, BYTE **ppbOutput, DWORD *pcbOutput, BYTE **ppbNonCasOutput, DWORD *pcbNonCasOutput, bool fAllowEmptyPermissionSet, OBJECTREF* pPermSet);
     void AttrSetBlobToPermissionSets(IN BYTE* pbRawPermissions, IN DWORD cbRawPermissions, OUT OBJECTREF* pObj, IN DWORD dwAction);
 
-#ifdef FEATURE_CAS_POLICY
-    void XmlToPermissionSet(PBYTE pbXmlBlob,
-                                    DWORD cbXmlBlob,
-                                    OBJECTREF* pPermSet,
-                                    OBJECTREF* pEncoding,
-                                    PBYTE pbNonCasXmlBlob,
-                                    DWORD cbNonCasXmlBlob,
-                                    OBJECTREF* pNonCasPermSet,
-                                    OBJECTREF* pNonCasEncoding);
-#endif // FEATURE_CAS_POLICY
 
 
     bool ActionAllowsNullPermissionSet(CorDeclSecurity action);
diff --git a/src/vm/securityconfig.cpp b/src/vm/securityconfig.cpp
deleted file mode 100644
index 9c7970db8c..0000000000
--- a/src/vm/securityconfig.cpp
+++ /dev/null
@@ -1,2181 +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.
-//
-// File: SecurityConfig.cpp
-//
-
-//
-//   Native implementation for security config access and manipulation
-//
-
-
-// #SecurityConfigFormat
-// 
-// The security config system resides outside of the rest
-// of the config system since our needs are different.  The
-// unmanaged portion of the security config system is only
-// concerned with data file/cache file pairs, not what they
-// are used for.  It performs all the duties of reading data
-// from the disk, saving data back to the disk, and maintaining
-// the policy and quick cache data structures.
-//
-// FILE FORMAT
-//
-// The data file is a purely opaque blob for the unmanaged
-// code; however, the cache file is constructed and maintained
-// completely in the unmanaged code.  It's format is as follows:
-//
-// CacheHeader
-//  |
-//  +-- dummyFileTime (FILETIME, 8 bytes) = this exists to make sure we don't read old format cache files. Must be set to {1, 0}.
-//  |
-//  +-- version (DWORD) = The version of this config file.
-//  |
-//  +-- configFileTime (FILETIME, 8 bytes) = The file time of the config file associated with this cache file.
-//  |
-//  +-- isSecurityOn (DWORD, 4 bytes) = This is currently not used.
-//  |
-//  +-- quickCache (DWORD, 4 bytes) = Used as a bitfield to maintain the information for the QuickCache.  See the QuickCache section for more details.
-//  |
-//  +-- registryExtensionsInfo (struct RegistryExtensionsInfo) = Indicates whether this cache file was generated in the presence of registry extensions.
-//  |
-//  +-- numEntries (DWORD, 4 bytes) = The number of policy cache entries in the latter portion of this cache file.
-//  |
-//  +-- sizeConfig (DWORD, 4 bytes) = The size of the config information stored in the latter portion of this cache file.
-//
-// Config Data (if any)
-//     The cache file can include an entire copy of this
-//     information in the adjoining config file.  This is
-//     necessary since the cache often allows us to make
-//     policy decisions without having parsed the data in 
-//     the config file.  In order to guarantee that the config
-//     data used by this process is not altered in the
-//     meantime, we need to store the data in a readonly
-//     location.  Due to the design of the caching system
-//     the cache file is locked when it is opened and therefore
-//     is the perfect place to store this information.  The
-//     other alternative is to hold it in memory, but since
-//     this can amount to many kilobytes of data we decided
-//     on this design.
-//
-// List of CacheEntries
-//  |
-//  +-- CacheEntry
-//  |    |
-//  |    +-- numItemsInKey (DWORD, 4 bytes) = The number of evidence objects serialized in the key blob
-//  |    |
-//  |    +-- keySize (DWORD, 4 bytes) = The number of bytes in the key blob.
-//  |    |
-//  |    +-- dataSize (DWORD, 4 bytes) = The number of bytes in the data blob.
-//  |    |     
-//  |    +-- keyBlob (raw) = A raw blob representing the serialized evidence.
-//  |    |
-//  |    +-- dataBlob (raw) = A raw blob representing an XML serialized PolicyStatement
-//  |
-//  +-- ...
-
-#include "common.h"
-
-#ifdef FEATURE_CAS_POLICY
-
-#include "securityconfig.h"
-
-// Header version of the cache file.
-#define CONFIG_VERSION 2
-// This controls the maximum size of the cache file.
-#define MAX_CACHEFILE_SIZE (1 << 20)
-
-#define SIZE_OF_ENTRY( X )   sizeof( CacheEntryHeader ) + X->header.keySize + X->header.dataSize
-#define MAX_NUM_LENGTH 16
-
-WCHAR* SecurityConfig::wcscatDWORD( __out_ecount(cchdst) __out_z WCHAR* dst, size_t cchdst, DWORD num )
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END
-
-    _ASSERTE( SecurityConfig::dataLock_.OwnedByCurrentThread() );
-
-    static WCHAR buffer[MAX_NUM_LENGTH];
-
-    buffer[MAX_NUM_LENGTH-1] = W('\0');
-
-    size_t index = MAX_NUM_LENGTH-2;
-
-    if (num == 0)
-    {
-        buffer[index--] = W('0');
-    }
-    else
-    {
-        while (num != 0)
-        {
-            buffer[index--] = (WCHAR)(W('0') + (num % 10));
-            num = num / 10;
-        }
-    }
-
-    wcscat_s( dst, cchdst, buffer + index + 1 );
-
-    return dst;
-}
-
-inline WCHAR * Wszdup(const WCHAR * str)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    size_t len = wcslen(str) + 1;
-    WCHAR * ret = new WCHAR[len];
-    wcscpy_s(ret, len, str);
-    return ret;
-}
-
-struct CacheHeader
-{
-    FILETIME dummyFileTime;
-    DWORD version;
-    FILETIME configFileTime;
-    DWORD isSecurityOn, quickCache;
-    SecurityConfig::RegistryExtensionsInfo registryExtensionsInfo;
-    DWORD numEntries, sizeConfig;
-
-    CacheHeader() : isSecurityOn( (DWORD) -1 ), quickCache( 0 ), numEntries( 0 ), sizeConfig( 0 )
-    {
-        WRAPPER_NO_CONTRACT;
-        memset( &this->configFileTime, 0, sizeof( configFileTime ) );
-        dummyFileTime.dwLowDateTime = 1;
-        dummyFileTime.dwHighDateTime = 0;
-        version = CONFIG_VERSION;
-        memset(&registryExtensionsInfo, 0, sizeof(registryExtensionsInfo));
-        _ASSERTE( IsValid() && "CacheHeader constructor should make it valid" );
-    };
-
-    bool IsValid()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return dummyFileTime.dwLowDateTime == 1 &&
-               dummyFileTime.dwHighDateTime == 0 &&
-               version == CONFIG_VERSION;
-    }
-};
-
-struct CacheEntryHeader
-{
-    DWORD numItemsInKey;
-    DWORD keySize;
-    DWORD dataSize;
-};
-
-struct CacheEntry
-{
-    CacheEntryHeader header;
-    BYTE* key;
-    BYTE* data;
-    DWORD cachePosition;
-    BOOL used;
-
-    CacheEntry() : key( NULL ), data( NULL ), used( FALSE ) 
-    {
-        LIMITED_METHOD_CONTRACT;
-    };
-
-    ~CacheEntry( void )
-    {
-        WRAPPER_NO_CONTRACT;
-        delete [] key;
-        delete [] data;
-    }
-};
-
-struct Data
-{
-    enum State
-    {
-        None = 0x0,
-        UsingCacheFile = 0x1,
-        CopyCacheFile = 0x2,
-        CacheUpdated = 0x4,
-        UsingConfigFile = 0x10,
-        CacheExhausted = 0x20,
-        NewConfigFile = 0x40
-    };
-
-    INT32 id;
-    WCHAR* configFileName;
-    WCHAR* cacheFileName;
-    WCHAR* cacheFileNameTemp;
-
-    LPBYTE configData;
-    DWORD  configDataSize;
-    FILETIME configFileTime;
-    FILETIME cacheFileTime;
-    CacheHeader header;
-    ArrayList* oldCacheEntries;
-    ArrayList* newCacheEntries;
-    State state;
-    DWORD cacheCurrentPosition;
-    HANDLE cache;
-    PBYTE configBuffer;
-    DWORD  sizeConfig;
-    SecurityConfig::ConfigRetval initRetval;
-    DWORD newEntriesSize;
-
-    Data( INT32 id )
-        : id( id ),
-          configFileName( NULL ),
-          cacheFileName( NULL ),
-          configData( NULL ),
-          oldCacheEntries( new ArrayList ),
-          newCacheEntries( new ArrayList ),
-          state( Data::None ),
-          cache( INVALID_HANDLE_VALUE ),
-          configBuffer( NULL ),
-          newEntriesSize( 0 )
-    {
-        LIMITED_METHOD_CONTRACT;
-    }
-
-    Data( INT32 id, STRINGREF* configFile )
-        : id( id ),
-          cacheFileName( NULL ),
-          configData( NULL ),
-          oldCacheEntries( new ArrayList ),
-          newCacheEntries( new ArrayList ),
-          state( Data::None ),
-          cache( INVALID_HANDLE_VALUE ),
-          configBuffer( NULL ),
-          newEntriesSize( 0 )
-    {
-        CONTRACTL {
-            THROWS;
-            GC_NOTRIGGER;
-            MODE_ANY;
-            PRECONDITION(*configFile != NULL);
-        } CONTRACTL_END;
-
-        configFileName = Wszdup( (*configFile)->GetBuffer() );
-        cacheFileName = NULL;
-        cacheFileNameTemp = NULL;
-    }
-
-    Data( INT32 id, STRINGREF* configFile, STRINGREF* cacheFile )
-        : id( id ),
-          configData( NULL ),
-          oldCacheEntries( new ArrayList ),
-          newCacheEntries( new ArrayList ),
-          state( Data::None ),
-          cache( INVALID_HANDLE_VALUE ),
-          configBuffer( NULL ),
-          newEntriesSize( 0 )
-    {
-        CONTRACTL {
-            THROWS;
-            GC_NOTRIGGER;
-            MODE_ANY;
-            PRECONDITION(*configFile != NULL);
-        } CONTRACTL_END;
-
-        configFileName = Wszdup( (*configFile)->GetBuffer() );
-
-        if (cacheFile != NULL)
-        {
-            // Since temp cache files can stick around even after the process that
-            // created them, we want to make sure they are fairly unique (if they
-            // aren't, we'll just fail to save cache information, which is not good
-            // but it won't cause anyone to crash or anything).  The unique name
-            // algorithm used here is to append the process id and tick count to
-            // the name of the cache file.
-
-            cacheFileName = Wszdup( (*cacheFile)->GetBuffer() );
-            size_t len = wcslen( cacheFileName ) + 1 + 2 * MAX_NUM_LENGTH;
-            cacheFileNameTemp = new WCHAR[len];
-            wcscpy_s( cacheFileNameTemp, len, cacheFileName );
-            wcscat_s( cacheFileNameTemp, len, W(".") );
-            SecurityConfig::wcscatDWORD( cacheFileNameTemp, len, GetCurrentProcessId() );
-            wcscat_s( cacheFileNameTemp, len, W(".") );
-            SecurityConfig::wcscatDWORD( cacheFileNameTemp, len, GetTickCount() );
-        }
-        else
-        {
-            cacheFileName = NULL;
-            cacheFileNameTemp = NULL;
-        }
-    }
-
-    Data( INT32 id, const WCHAR* configFile, const WCHAR* cacheFile )
-        : id( id ),
-          configData( NULL ),
-          oldCacheEntries( new ArrayList ),
-          newCacheEntries( new ArrayList ),
-          state( Data::None ),
-          cache( INVALID_HANDLE_VALUE ),
-          configBuffer( NULL ),
-          newEntriesSize( 0 )
-
-    {
-        CONTRACTL {
-            THROWS;
-            GC_NOTRIGGER;
-            MODE_ANY;
-            PRECONDITION(*configFile != NULL);
-        } CONTRACTL_END;
-
-        configFileName = Wszdup( configFile );
-
-        if (cacheFile != NULL)
-        {
-            cacheFileName = Wszdup( cacheFile );
-            size_t len = wcslen( cacheFileName ) + 1 + 2 * MAX_NUM_LENGTH;
-            cacheFileNameTemp = new WCHAR[len];
-            wcscpy_s( cacheFileNameTemp, len, cacheFileName );
-            wcscat_s( cacheFileNameTemp, len, W(".") );
-            SecurityConfig::wcscatDWORD( cacheFileNameTemp, len, GetCurrentProcessId() );
-            wcscat_s( cacheFileNameTemp, len, W(".") );
-            SecurityConfig::wcscatDWORD( cacheFileNameTemp, len, GetTickCount() );
-        }
-        else
-        {
-            cacheFileName = NULL;
-            cacheFileNameTemp = NULL;
-        }
-    }
-
-    void Reset( void )
-    {
-        CONTRACTL {
-            THROWS;
-            GC_NOTRIGGER;
-            MODE_ANY;
-        } CONTRACTL_END;
-
-        delete [] configBuffer;
-        configBuffer = NULL;
-
-        if (cache != INVALID_HANDLE_VALUE)
-        {
-            CloseHandle( cache );
-            cache = INVALID_HANDLE_VALUE;
-        }
-
-        if (cacheFileNameTemp != NULL)
-        {
-            // Note: we don't check a return value here as the worst thing that
-            // happens is we leave a spurious cache file.
-
-            WszDeleteFile( cacheFileNameTemp );
-        }
-
-        if (configData != NULL)
-            delete [] configData;
-        configData = NULL;
-
-        DeleteAllEntries();
-        header = CacheHeader();
-
-        oldCacheEntries = new ArrayList();
-        newCacheEntries = new ArrayList();
-
-    }
-
-    void Cleanup( void )
-    {
-        CONTRACTL {
-            NOTHROW;
-            GC_NOTRIGGER;
-            MODE_ANY;
-        } CONTRACTL_END;
-
-        if (cache != INVALID_HANDLE_VALUE)
-        {
-            CloseHandle( cache );
-            cache = INVALID_HANDLE_VALUE;
-        }
-
-        if (cacheFileNameTemp != NULL)
-        {
-            // Note: we don't check a return value here as the worst thing that
-            // happens is we leave a spurious cache file.
-
-            WszDeleteFile( cacheFileNameTemp );
-        }
-    }
-
-    ~Data( void )
-    {
-        CONTRACTL {
-            NOTHROW;
-            GC_NOTRIGGER;
-            MODE_ANY;
-        } CONTRACTL_END;
-
-        Cleanup();
-        delete [] configBuffer;
-
-        delete [] configFileName;
-        delete [] cacheFileName;
-        delete [] cacheFileNameTemp;
-
-        if (configData != NULL)
-            delete [] configData;
-        DeleteAllEntries();
-    }
-
-    void DeleteAllEntries( void );
-};
-
-void Data::DeleteAllEntries( void )
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    } CONTRACTL_END;
-
-    ArrayList::Iterator iter;
-
-    if (oldCacheEntries != NULL)
-    {
-        iter = oldCacheEntries->Iterate();
-
-        while (iter.Next())
-        {
-            delete (CacheEntry*) iter.GetElement();
-        }
-
-        delete oldCacheEntries;
-        oldCacheEntries = NULL;
-    }
-
-    if (newCacheEntries != NULL)
-    {
-        iter = newCacheEntries->Iterate();
-
-        while (iter.Next())
-        {
-            delete (CacheEntry*) iter.GetElement();
-        }
-
-        delete newCacheEntries;
-        newCacheEntries = NULL;
-    }
-}
-
-void* SecurityConfig::GetData( INT32 id )
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END
-
-    ArrayList::Iterator iter = entries_.Iterate();
-
-    while (iter.Next())
-    {
-        Data* data = (Data*)iter.GetElement();
-
-        if (data->id == id)
-        {
-            return data;
-        }
-    }
-
-    return NULL;
-}
-
-static BOOL CacheOutOfDate( FILETIME* configFileTime, __in_z WCHAR* configFileName, __in_z_opt WCHAR* cacheFileName )
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_PREEMPTIVE;
-    }
-    CONTRACTL_END
-
-    BOOL retval = TRUE;
-    BOOL deleteFile = FALSE;
-
-    HandleHolder config(WszCreateFile( configFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ));
-
-    if (config.GetValue() == INVALID_HANDLE_VALUE)
-    {
-        goto CLEANUP;
-    }
-
-    // Get the last write time for both files.
-
-    FILETIME newConfigTime;
-
-    if (!GetFileTime( config.GetValue(), NULL, NULL, &newConfigTime ))
-    {
-        goto CLEANUP;
-    }
-
-    if (CompareFileTime( configFileTime, &newConfigTime ) != 0)
-    {
-        // Cache is dated.  Delete the cache.
-        deleteFile = TRUE;
-        goto CLEANUP;
-    }
-
-    retval = FALSE;
-
-CLEANUP:
-    // Note: deleting this file is a perf optimization so that
-    // we don't have to do this file time comparison next time.
-    // Therefore, if it fails for some reason we just loss a
-    // little perf.
-
-    if (deleteFile && cacheFileName != NULL)
-        WszDeleteFile( cacheFileName );
-
-    return retval;
-}
-
-static BOOL CacheOutOfDate( FILETIME* cacheFileTime, HANDLE cache, __in_z_opt WCHAR* cacheFileName )
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_PREEMPTIVE;
-    }
-    CONTRACTL_END
-
-    BOOL retval = TRUE;
-
-    // Get the last write time for both files.
-
-    FILETIME newCacheTime;
-
-    if (!GetFileTime( cache, NULL, NULL, &newCacheTime ))
-    {
-        goto CLEANUP;
-    }
-
-    if (CompareFileTime( cacheFileTime, &newCacheTime ) != 0)
-    {
-        // Cache is dated.  Delete the cache.
-        // Note: deleting this file is a perf optimization so that
-        // we don't have to do this file time comparison next time.
-        // Therefore, if it fails for some reason we just loss a
-        // little perf.
-
-        if (cacheFileName != NULL)
-        {
-            CloseHandle( cache );
-            WszDeleteFile( cacheFileName );
-        }
-        goto CLEANUP;
-    }
-
-    retval = FALSE;
-
-CLEANUP:
-    return retval;
-}
-
-static BOOL CacheOutOfDate( FILETIME* configTime, FILETIME* cachedConfigTime )
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_PREEMPTIVE;
-    }
-    CONTRACTL_END
-
-    DWORD result = CompareFileTime( configTime, cachedConfigTime );
-
-    return result != 0;
-}
-
-static DWORD GetShareFlags()
-{
-    LIMITED_METHOD_CONTRACT;
-
-    return FILE_SHARE_READ | FILE_SHARE_DELETE;
-}
-
-static DWORD WriteFileData( HANDLE file, LPCBYTE data, DWORD size )
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END
-
-    DWORD totalBytesWritten = 0;
-    DWORD bytesWritten;
-
-    do
-    {
-        if (WriteFile( file, data, size - totalBytesWritten, &bytesWritten, NULL ) == 0)
-        {
-            return E_FAIL;
-        }
-        if (bytesWritten == 0)
-        {
-            return E_FAIL;
-        }
-        totalBytesWritten += bytesWritten;
-    } while (totalBytesWritten < size);
-
-    return S_OK;
-}
-
-// the data argument to this function can be a pointer to GC heap. 
-// We do ensure cooperative mode before we call this function using a pointer to GC heap,
-// so we can't change GC mode inside this function. 
-// Greg will look into the ways to pin the object.
-
-static DWORD ReadFileData( HANDLE file, PBYTE data, DWORD size )
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END
-
-    DWORD totalBytesRead = 0;
-    DWORD bytesRead;
-    do
-    {
-        if (ReadFile( file, data, size - totalBytesRead, &bytesRead, NULL ) == 0)
-        {
-            return E_FAIL;
-        }
-
-        if (bytesRead == 0)
-        {
-            return E_FAIL;
-        }
-        
-        totalBytesRead += bytesRead;
-        
-    } while (totalBytesRead < size);
-    
-    return S_OK;
-}
-
-SecurityConfig::ConfigRetval SecurityConfig::InitData( INT32 id, const WCHAR* configFileName, const WCHAR* cacheFileName )
-{
-    STANDARD_VM_CONTRACT;
-
-    Data* data = (Data*)GetData( id );
-    if (data != NULL)
-    {
-        return data->initRetval;
-    }
-
-    if (configFileName == NULL || wcslen( configFileName ) == 0)
-    {
-        return NoFile;
-    }
-
-    {
-        CrstHolder ch( &dataLock_ );
-        data = new (nothrow) Data( id, configFileName, cacheFileName );
-    }
-
-    if (data == NULL)
-    {
-         return NoFile;
-    }
-
-    return InitData( data, TRUE );
-}
-
-
-SecurityConfig::ConfigRetval SecurityConfig::InitData( void* configDataParam, BOOL addToList )
-{
-    STANDARD_VM_CONTRACT;
-
-    _ASSERTE( configDataParam != NULL );
-
-    Data* data = (Data*) configDataParam;
-    DWORD cacheSize;
-    DWORD configSize;
-    ConfigRetval retval = NoFile;
-    DWORD shareFlags;
-
-    shareFlags = GetShareFlags();
-
-    // Crack open the config file.
-
-    HandleHolder config(WszCreateFile( data->configFileName, GENERIC_READ, shareFlags, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ));
-    if (config == INVALID_HANDLE_VALUE || !GetFileTime( config, NULL, NULL, &data->configFileTime ))
-    {
-        memset( &data->configFileTime, 0, sizeof( data->configFileTime ) );
-    }
-    else
-    {
-        data->state = (Data::State)(Data::UsingConfigFile | data->state);
-    }
-
-    // If we want a cache file, try to open that up.
-    // Note: we do not use a holder for data->cache because the new holder for data will
-    // delete the entire data structure which includes closing this handle as necessary.
-
-    if (data->cacheFileName != NULL)
-        data->cache = WszCreateFile( data->cacheFileName, GENERIC_READ, shareFlags, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
-    
-    if (data->cache == INVALID_HANDLE_VALUE)
-    {
-        goto READ_DATA;
-    }
-
-    // Validate that the cache file is in a good form by checking
-    // that it is at least big enough to contain a header.
-
-    cacheSize = SafeGetFileSize( data->cache, NULL );
-    
-    if (cacheSize == 0xFFFFFFFF)
-    {
-        goto READ_DATA;
-    }
-    
-    if (cacheSize < sizeof( CacheHeader ))
-    {
-        goto READ_DATA;
-    }
-
-    // Finally read the data from the file into the buffer.
-    
-    if (ReadFileData( data->cache, (BYTE*)&data->header, sizeof( CacheHeader ) ) != S_OK)
-    {
-        goto READ_DATA;
-    }
-
-    if (!data->header.IsValid())
-    {
-        goto READ_DATA;
-    }
-
-    // Check to make sure the cache file and the config file
-    // match up by comparing the actual file time of the config
-    // file and the config file time stored in the cache file.
-
-    if (CacheOutOfDate( &data->configFileTime, &data->header.configFileTime ))
-    {
-        goto READ_DATA;
-    }
-
-    if (!GetFileTime( data->cache, NULL, NULL, &data->cacheFileTime ))
-    {
-        goto READ_DATA;
-    }
-
-    // Set the file pointer to after both the header and config data (if any) so
-    // that we are ready to read cache entries.
-
-    if (SetFilePointer( data->cache, sizeof( CacheHeader ) + data->header.sizeConfig, NULL, FILE_BEGIN ) == INVALID_SET_FILE_POINTER)
-    {
-        goto READ_DATA;
-    }
-
-    data->cacheCurrentPosition = sizeof( CacheHeader ) + data->header.sizeConfig;
-    data->state = (Data::State)(Data::UsingCacheFile | Data::CopyCacheFile | data->state);
-
-    retval = (ConfigRetval)(retval | CacheFile);
-
-READ_DATA:
-    // If we are not using the cache file but we successfully opened it, we need
-    // to close it now.  In addition, we need to reset the cache information
-    // stored in the Data object to make sure there is no spill over.
-
-    if (data->cache != INVALID_HANDLE_VALUE && (data->state & Data::UsingCacheFile) == 0)
-    {
-        CloseHandle( data->cache );
-        data->header = CacheHeader();
-        data->cache = INVALID_HANDLE_VALUE;
-    }
-
-    if (config != INVALID_HANDLE_VALUE)
-    {
-        configSize = SafeGetFileSize( config, NULL );
-    
-        if (configSize == 0xFFFFFFFF)
-        {
-            goto ADD_DATA;
-        }
-
-        // Be paranoid and only use the cache file version if we find that it has the correct sized
-        // blob in it.
-
-        if ((data->state & Data::UsingCacheFile) != 0 && configSize == data->header.sizeConfig)
-        {
-            goto ADD_DATA;
-        }
-        else
-        {
-            if (data->cache != INVALID_HANDLE_VALUE)
-            {
-                CloseHandle( data->cache );
-                data->header = CacheHeader();
-                data->cache = INVALID_HANDLE_VALUE;
-                data->state = (Data::State)(data->state & ~(Data::UsingCacheFile));
-            }
-
-            data->configData = new BYTE[configSize];
-            if (ReadFileData( config, data->configData, configSize ) != S_OK)
-            {
-                goto ADD_DATA;
-            }
-            data->configDataSize = configSize;
-        }
-        retval = (ConfigRetval)(retval | ConfigFile);
-    }
-
-ADD_DATA:
-    {
-        CrstHolder ch(&dataLock_);
-
-        if (addToList)
-        {
-            IfFailThrow(entries_.Append(data));
-        }
-    }
-
-    _ASSERTE( data );
-    data->initRetval = retval;
-
-    return retval;
-
-};
-
-static CacheEntry* LoadNextEntry( HANDLE cache, Data* data )
-{
-    STANDARD_VM_CONTRACT;
-
-    if ((data->state & Data::CacheExhausted) != 0)
-        return NULL;
-
-    NewHolder<CacheEntry> entry(new CacheEntry());
-
-    if (SetFilePointer( cache, data->cacheCurrentPosition, NULL, FILE_BEGIN ) == INVALID_SET_FILE_POINTER)
-    {
-        return NULL;
-    }
-
-        if (ReadFileData( cache, (BYTE*)&entry.GetValue()->header, sizeof( CacheEntryHeader ) ) != S_OK)
-    {
-        return NULL;
-    }
-
-    entry.GetValue()->cachePosition = data->cacheCurrentPosition + sizeof( entry.GetValue()->header );
-
-    data->cacheCurrentPosition += sizeof( entry.GetValue()->header ) + entry.GetValue()->header.keySize + entry.GetValue()->header.dataSize;
-
-    if (SetFilePointer( cache, entry.GetValue()->header.keySize + entry->header.dataSize, NULL, FILE_CURRENT ) == INVALID_SET_FILE_POINTER)
-    {
-        return NULL;
-    }
-
-    // We append a partially populated entry. CompareEntry is robust enough to handle this.
-    IfFailThrow(data->oldCacheEntries->Append( entry ));
-
-    return entry.Extract();
-}
-
-static BOOL WriteEntry( HANDLE cache, CacheEntry* entry, HANDLE oldCache = NULL )
-{
-    STANDARD_VM_CONTRACT;
-
-    if (WriteFileData( cache, (BYTE*)&entry->header, sizeof( CacheEntryHeader ) ) != S_OK)
-    {
-        return FALSE;
-    }
-
-    if (entry->key == NULL)
-    {
-        _ASSERTE (oldCache != NULL);
-
-        // We were lazy in reading the entry. Read the key now.
-        entry->key = new BYTE[entry->header.keySize];
-
-        _ASSERTE (cache != INVALID_HANDLE_VALUE);
-
-        if (SetFilePointer( oldCache, entry->cachePosition, NULL, FILE_BEGIN ) == INVALID_SET_FILE_POINTER)
-            return NULL;
-
-        if (ReadFileData( oldCache, entry->key, entry->header.keySize ) != S_OK)
-        {
-            return NULL;
-        }
-
-        entry->cachePosition += entry->header.keySize;
-    }
-
-    _ASSERTE( entry->key != NULL );
-
-    if (entry->data == NULL)
-    {
-        _ASSERTE (oldCache != NULL);
-
-        // We were lazy in reading the entry. Read the data also.
-        entry->data = new BYTE[entry->header.dataSize];
-
-        if (SetFilePointer( oldCache, entry->cachePosition, NULL, FILE_BEGIN ) == INVALID_SET_FILE_POINTER)
-            return NULL;
-
-        if (ReadFileData( oldCache, entry->data, entry->header.dataSize ) != S_OK)
-            return NULL;
-
-        entry->cachePosition += entry->header.dataSize;
-    }
-
-    _ASSERT( entry->data != NULL );
-
-    if (WriteFileData( cache, entry->key, entry->header.keySize ) != S_OK)
-    {
-        return FALSE;
-    }
-
-    if (WriteFileData( cache, entry->data, entry->header.dataSize ) != S_OK)
-    {
-        return FALSE;
-    }
-
-    return TRUE;
-}
-
-BOOL SecurityConfig::SaveCacheData( INT32 id )
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END
-
-    GCX_PREEMP();
-
-    // Note: this function should only be called at EEShutdown time.
-    // This is because we need to close the current cache file in
-    // order to delete it.  If it ever became necessary to do
-    // cache saves while a process we still executing managed code
-    // it should be possible to create a locking scheme for usage
-    // of the cache handle with very little reordering of the below
-    // (as it should always be possible for us to have a live copy of
-    // the file and yet still be making the swap).
-
-    HandleHolder cache;
-    HandleHolder config;
-    CacheHeader header;
-    BOOL retval = FALSE;
-    BOOL fWriteSucceeded = FALSE;
-    DWORD numEntriesWritten = 0;
-    DWORD amountWritten = 0;
-    DWORD sizeConfig = 0;
-    NewHolder<BYTE> configBuffer;
-    BOOL useConfigData = FALSE;
-
-    Data* data = (Data*)GetData( id );
-
-    // If there is not data by the id or there is no
-    // cache file name associated with the data, then fail.
-
-    if (data == NULL || data->cacheFileName == NULL)
-        return FALSE;
-
-    // If we haven't added anything new to the cache
-    // then just return success.
-
-    if ((data->state & Data::CacheUpdated) == 0)
-        return TRUE;
-
-    // If the config file has changed since the process started
-    // then our cache data is no longer valid.  We'll just
-    // return success in this case.
-
-    if ((data->state & Data::UsingConfigFile) != 0 && CacheOutOfDate( &data->configFileTime, data->configFileName, NULL ))
-        return TRUE;
-
-    DWORD fileNameLength = (DWORD)wcslen( data->cacheFileName );
-
-    NewArrayHolder<WCHAR> newFileName(new WCHAR[fileNameLength + 5]);
-
-    swprintf_s( newFileName.GetValue(), fileNameLength + 5, W("%s%s"), data->cacheFileName, W(".new") );
-
-    cache.Assign( WszCreateFile( newFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL ) ); 
-
-    for (DWORD RetryCount = 0; RetryCount < 5; RetryCount++)
-    {
-        if (cache != INVALID_HANDLE_VALUE)
-        {
-            break;
-        }
-        else
-        {
-            DWORD error = GetLastError();
-
-            if (error == ERROR_PATH_NOT_FOUND)
-            {
-                // The directory does not exist, iterate through and try to create it.
-
-                WCHAR* currentChar = newFileName;
-
-                // Skip the first backslash
-
-                while (*currentChar != W('\0'))
-                {
-                    if (*currentChar == W('\\') || *currentChar == W('/'))
-                    {
-                        currentChar++;
-                        break;
-                    }
-                    currentChar++;
-                }
-
-                // Iterate through trying to create each subdirectory.
-
-                while (*currentChar != W('\0'))
-                {
-                    if (*currentChar == W('\\') || *currentChar == W('/'))
-                    {
-                        *currentChar = W('\0');
-
-                        if (!WszCreateDirectory( newFileName, NULL ))
-                        {
-                            error = GetLastError();
-
-                            if (error != ERROR_ACCESS_DENIED && error != ERROR_INVALID_NAME && error != ERROR_ALREADY_EXISTS)
-                            {
-                                goto CLEANUP;
-                            }
-                        }
-
-                        *currentChar = W('\\');
-                    }
-                    currentChar++;
-                }
-
-                // Try the file creation again
-                continue;
-            }
-        }
-
-        // CreateFile failed.  Sleep a little and retry, in case a
-        // virus scanner caused the creation to fail.
-        ClrSleepEx(10, FALSE);
-    }
-
-    if (cache.GetValue() == INVALID_HANDLE_VALUE)
-        goto CLEANUP;
-
-    // This code seems complicated only because of the
-    // number of cases that we are trying to handle.  All we
-    // are trying to do is determine the amount of space to
-    // leave for the config information.
-
-    // If we saved out a new config file during this run, use
-    // the config size stored in the Data object itself.
-
-        if (data->configData != NULL)
-        {
-            useConfigData = TRUE;
-        }
-
-    if ((data->state & Data::NewConfigFile) != 0)
-    {
-        sizeConfig = data->sizeConfig;
-    }
-
-    // If we have a cache file, then use the size stored in the
-    // cache header.
-
-    else if ((data->state & Data::UsingCacheFile) != 0)
-    {
-        sizeConfig = data->header.sizeConfig;
-    }
-
-    // If we read in the config data, use the size of the
-    // managed byte array that it is stored in.
-
-    else if (useConfigData)
-    {
-        sizeConfig = data->configDataSize;
-    }
-
-    // Otherwise, check the config file itself to get the size.
-
-    else
-    {
-        DWORD shareFlags;
-
-        shareFlags = GetShareFlags();
-
-        config.Assign( WszCreateFile( data->configFileName, GENERIC_READ, shareFlags, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ) );
-
-        if (config == INVALID_HANDLE_VALUE)
-        {
-            sizeConfig = 0;
-        }
-        else
-        {
-            sizeConfig = SafeGetFileSize( config, NULL );
-
-            if (sizeConfig == 0xFFFFFFFF)
-            {
-                sizeConfig = 0;
-            }
-        }
-    }
-
-    // First write the entries.
-
-    if (SetFilePointer( cache, sizeof( CacheHeader ) + sizeConfig, NULL, FILE_BEGIN ) == INVALID_SET_FILE_POINTER)
-    {
-        goto CLEANUP;
-    }
-
-    // We're going to write out the cache entries in a modified
-    // least recently used order, throwing out any that end up
-    // taking us past our hardcoded max file size.
-
-    {
-        // First, write the entries from the cache file that were used.
-        // We do this because presumably these are system assemblies
-        // and other assemblies used by a number of applications.
-
-        ArrayList::Iterator iter;
-
-        if ((data->state & Data::UsingCacheFile) != 0)
-        {
-            iter = data->oldCacheEntries->Iterate();
-
-            while (iter.Next() && amountWritten < MAX_CACHEFILE_SIZE)
-            {
-                CacheEntry* currentEntry = (CacheEntry*)iter.GetElement();
-
-                if (currentEntry->used)
-                {
-                    if(!WriteEntry( cache, currentEntry, data->cache ))
-                    {
-                        goto CLEANUP;
-                    }
-
-                    amountWritten += SIZE_OF_ENTRY( currentEntry );
-                    numEntriesWritten++;
-                }
-            }
-        }
-
-        // Second, write any new cache entries to the file.  These are
-        // more likely to be assemblies specific to this app.
-
-        iter = data->newCacheEntries->Iterate();
-
-        while (iter.Next() && amountWritten < MAX_CACHEFILE_SIZE)
-        {
-            CacheEntry* currentEntry = (CacheEntry*)iter.GetElement();
-
-            if (!WriteEntry( cache, currentEntry ))
-            {
-                goto CLEANUP;
-            }
-
-            amountWritten += SIZE_OF_ENTRY( currentEntry );
-            numEntriesWritten++;
-        }
-
-        // Third, if we are using the cache file, write the old entries
-        // that were not used this time around.
-
-        if ((data->state & Data::UsingCacheFile) != 0)
-        {
-            // First, write the ones that we already have partially loaded
-
-            iter = data->oldCacheEntries->Iterate();
-
-            while (iter.Next() && amountWritten < MAX_CACHEFILE_SIZE)
-            {
-                CacheEntry* currentEntry = (CacheEntry*)iter.GetElement();
-
-                if (!currentEntry->used)
-                {
-                    if(!WriteEntry( cache, currentEntry, data->cache ))
-                    {
-                        goto CLEANUP;
-                    }
-
-                    amountWritten += SIZE_OF_ENTRY( currentEntry );
-                    numEntriesWritten++;
-                }
-            }
-
-            while (amountWritten < MAX_CACHEFILE_SIZE)
-            {
-                CacheEntry* entry = LoadNextEntry( data->cache, data );
-
-                if (entry == NULL)
-                    break;
-
-                if (!WriteEntry( cache, entry, data->cache ))
-                {
-                    goto CLEANUP;
-                }
-
-                amountWritten += SIZE_OF_ENTRY( entry );
-                numEntriesWritten++;
-            }
-        }
-
-        fWriteSucceeded = TRUE;
-    }
-
-
-    if (!fWriteSucceeded)
-    {
-        CloseHandle( cache.GetValue() );
-        cache.SuppressRelease();
-        WszDeleteFile( newFileName );
-        goto CLEANUP;
-    }
-
-    // End with writing the header.
-
-    header.configFileTime = data->configFileTime;
-    header.isSecurityOn = 1;
-    header.numEntries = numEntriesWritten;
-    header.quickCache = data->header.quickCache;
-    header.sizeConfig = sizeConfig;
-
-    if (SetFilePointer( cache, 0, NULL, FILE_BEGIN ) == INVALID_SET_FILE_POINTER)
-    {
-        // Couldn't move to the beginning of the file
-        goto CLEANUP;
-    }
-
-    if (WriteFileData( cache, (PBYTE)&header, sizeof( header ) ) != S_OK)
-    {
-        // Couldn't write header info.
-        goto CLEANUP;
-    }
-
-    if (sizeConfig != 0)
-    {
-        if ((data->state & Data::NewConfigFile) != 0)
-        {
-            if (WriteFileData( cache, data->configBuffer, sizeConfig ) != S_OK)
-            {
-                goto CLEANUP;
-            }
-        }
-        else
-        {
-            if (data->configData != NULL)
-            {
-                if (WriteFileData( cache, data->configData, sizeConfig ) != S_OK)
-                {
-                    goto CLEANUP;
-                }
-            }
-            else if ((data->state & Data::UsingCacheFile) != 0)
-            {
-                configBuffer.Assign( new BYTE[sizeConfig] );
-
-                if (SetFilePointer( data->cache, sizeof( CacheHeader ), NULL, FILE_BEGIN ) == INVALID_SET_FILE_POINTER)
-                {
-                    goto CLEANUP;
-                }
-
-                if (ReadFileData( data->cache, configBuffer.GetValue(), sizeConfig ) != S_OK)
-                {
-                    goto CLEANUP;
-                }
-
-                if (WriteFileData( cache, configBuffer.GetValue(), sizeConfig ) != S_OK)
-                {
-                    goto CLEANUP;
-                }
-            }
-            else
-            {
-                configBuffer.Assign( new BYTE[sizeConfig] );
-
-                if (SetFilePointer( config, 0, NULL, FILE_BEGIN ) == INVALID_SET_FILE_POINTER)
-                {
-                    goto CLEANUP;
-                }
-
-                if (ReadFileData( config, configBuffer.GetValue(), sizeConfig ) != S_OK)
-                {
-                    goto CLEANUP;
-                }
-
-                if (WriteFileData( cache, configBuffer.GetValue(), sizeConfig ) != S_OK)
-                {
-                    goto CLEANUP;
-                }
-            }
-        }
-    }
-
-    // Flush the file buffers to make sure
-    // we get full write through.
-
-    FlushFileBuffers( cache.GetValue() );
-
-    CloseHandle( cache );
-    cache.SuppressRelease();
-    CloseHandle( data->cache );
-    data->cache = INVALID_HANDLE_VALUE;
-
-    // Move the existing file out of the way
-    // Note: use MoveFile because we know it will never cross
-    // device boundaries.
-
-    // Note: the delete file can fail, but we can't really do anything
-    // if it does so just ignore any failures.
-    WszDeleteFile( data->cacheFileNameTemp );
-
-    // Try to move the existing cache file out of the way.  However, if we can't
-    // then try to delete it.  If it can't be deleted then just bail out.
-    if (!WszMoveFile( data->cacheFileName, data->cacheFileNameTemp ) &&
-        (!Assembly::FileNotFound(HRESULT_FROM_WIN32(GetLastError()))) &&
-        !WszDeleteFile( data->cacheFileName ))
-    {
-        if (!Assembly::FileNotFound(HRESULT_FROM_WIN32(GetLastError())))
-            goto CLEANUP;
-    }
-
-    // Move the new file into position
-
-    if (!WszMoveFile( newFileName, data->cacheFileName ))
-    {
-        goto CLEANUP;
-    }
-
-    retval = TRUE;
-
-CLEANUP:
-    if (retval)
-        cache.SuppressRelease();
-
-    return retval;
-
-}
-
-void QCALLTYPE SecurityConfig::ResetCacheData(INT32 id)
-{
-    QCALL_CONTRACT;
-
-    BEGIN_QCALL;
-
-    Data* data = (Data*)GetData( id );
-
-    if (data != NULL)
-    {
-        CrstHolder ch(&dataLock_);
-
-        data->DeleteAllEntries();
-
-        data->oldCacheEntries = new ArrayList;
-        data->newCacheEntries = new ArrayList;
-
-        data->header = CacheHeader();
-        data->state = (Data::State)(~(Data::CopyCacheFile | Data::UsingCacheFile) & data->state);
-
-        HandleHolder config(WszCreateFile( data->configFileName, GENERIC_READ, GetShareFlags(), NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ));
-
-        if (config.GetValue() != INVALID_HANDLE_VALUE)
-        {
-        VERIFY(GetFileTime( config, NULL, NULL, &data->configFileTime ));
-        VERIFY(GetFileTime( config, NULL, NULL, &data->header.configFileTime ));
-    }
-}
-
-    END_QCALL;
-}
-
-HRESULT QCALLTYPE SecurityConfig::SaveDataByte(LPCWSTR wszConfigPath, LPCBYTE pbData, DWORD cbData)
-{
-    QCALL_CONTRACT;
-
-    HRESULT retval = E_FAIL;
-
-    BEGIN_QCALL;
-
-    HandleHolder newFile(INVALID_HANDLE_VALUE);
-
-    int RetryCount;
-    DWORD error = 0;
-    DWORD fileNameLength = (DWORD) wcslen(wszConfigPath);
-
-    NewArrayHolder<WCHAR> newFileName(new WCHAR[fileNameLength + 5]);
-    NewArrayHolder<WCHAR> oldFileName(new WCHAR[fileNameLength + 5]);
-
-    swprintf_s( newFileName.GetValue(), fileNameLength + 5, W("%s%s"), wszConfigPath, W(".new") );
-    swprintf_s( oldFileName.GetValue(), fileNameLength + 5, W("%s%s"), wszConfigPath, W(".old") );
-
-    // Create the new file.
-    for (RetryCount = 0; RetryCount < 5; RetryCount++) {
-        newFile.Assign( WszCreateFile( newFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL ) );
-    
-        if (newFile != INVALID_HANDLE_VALUE)
-            break;
-        else
-        {
-            error = GetLastError();
-
-            if (error == ERROR_PATH_NOT_FOUND)
-            {
-                // The directory does not exist, iterate through and try to create it.
-
-                WCHAR* currentChar = newFileName;
-
-                // Skip the first backslash
-
-                while (*currentChar != W('\0'))
-                {
-                    if (*currentChar == W('\\') || *currentChar == W('/'))
-                    {
-                        currentChar++;
-                        break;
-                    }
-                    currentChar++;
-                }
-
-                // Iterate through trying to create each subdirectory.
-
-                while (*currentChar != W('\0'))
-                {
-                    if (*currentChar == W('\\') || *currentChar == W('/'))
-                    {
-                        *currentChar = W('\0');
-
-                        if (!WszCreateDirectory( newFileName, NULL ))
-                        {
-                            error = GetLastError();
-
-                            if (error != ERROR_ACCESS_DENIED && error != ERROR_ALREADY_EXISTS)
-                            {
-                                goto CLEANUP;
-                            }
-                        }
-
-                        *currentChar = W('\\');
-                    }
-                    currentChar++;
-                }
-
-                // Try the file creation again
-                continue;
-            }
-        }
-
-        // CreateFile failed.  Sleep a little and retry, in case a
-        // virus scanner caused the creation to fail.
-        ClrSleepEx(10, FALSE);
-    }
-
-    if (newFile == INVALID_HANDLE_VALUE) {
-        goto CLEANUP;
-    }
-
-    // Write the data into it.
-    if ((retval = WriteFileData(newFile.GetValue(), pbData, cbData)) != S_OK)
-    {
-        // Write failed, destroy the file and bail.
-        // Note: if the delete fails, we always do a CREATE_NEW
-        // for this file so that should take care of it.  If not
-        // we'll fail to write out future cache files.
-        CloseHandle( newFile.GetValue() );
-        newFile.SuppressRelease();
-        WszDeleteFile( newFileName );
-        goto CLEANUP;
-    }
-
-    if (!FlushFileBuffers(newFile.GetValue()))
-    {
-        error = GetLastError();
-        goto CLEANUP;
-    }
-
-    CloseHandle( newFile.GetValue() );
-    newFile.SuppressRelease();
-
-    // Move the existing file out of the way
-    if (!WszMoveFileEx( wszConfigPath, oldFileName, MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED ))
-    {
-        // If move fails for a reason other than not being able to find the file, bail out.
-        // Also, if the old file didn't exist, we have no need to delete it.
-        HRESULT hrMove = HRESULT_FROM_WIN32(GetLastError()); 
-        if (!Assembly::FileNotFound(hrMove))
-        {
-            retval = hrMove;
-            WszDeleteFile(wszConfigPath);
-                goto CLEANUP;
-        }
-    }
-
-    // Move the new file into position
-
-    if (!WszMoveFileEx( newFileName, wszConfigPath, MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED ))
-    {
-        error = GetLastError();
-        goto CLEANUP;
-    }
-
-    retval = S_OK;
-
-CLEANUP:
-    if (retval == E_FAIL && error != 0)
-        retval = HRESULT_FROM_WIN32(error);
-
-    END_QCALL;
-
-    return retval;
-}
-
-BOOL QCALLTYPE SecurityConfig::RecoverData(INT32 id)
-    {
-    QCALL_CONTRACT;
-
-    BOOL retval = FALSE;
-
-    BEGIN_QCALL;
-
-    Data* data = (Data*)GetData( id );
-
-    if (data == NULL)
-        goto CLEANUP;
-
-    {
-        DWORD fileNameLength = (DWORD)wcslen( data->configFileName );
-
-        NewArrayHolder<WCHAR> tempFileName(new WCHAR[fileNameLength + 10]);
-        NewArrayHolder<WCHAR> oldFileName(new WCHAR[fileNameLength + 5]);
-
-        swprintf_s( tempFileName.GetValue(), fileNameLength + 10, W("%s%s"), data->configFileName, W(".old.temp") );
-        swprintf_s( oldFileName.GetValue(), fileNameLength + 5, W("%s%s"), data->configFileName, W(".old") );
-
-        HandleHolder oldFile(WszCreateFile( oldFileName, 0, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ));
-
-        if (oldFile.GetValue() == INVALID_HANDLE_VALUE)
-        {
-            goto CLEANUP;
-        }
-
-        CloseHandle( oldFile );
-        oldFile.SuppressRelease();
-
-        if (!WszMoveFile( data->configFileName, tempFileName ))
-        {
-            goto CLEANUP;
-        }
-
-        if (!WszMoveFile( oldFileName, data->configFileName ))
-        {
-            goto CLEANUP;
-        }
-
-        if (!WszMoveFile( tempFileName, oldFileName ))
-        {
-            goto CLEANUP;
-        }
-    }
-
-    // We need to do some work to reset the unmanaged data object
-    // so that the managed side of things behaves like you'd expect.
-    // This basically means cleaning up the open resources and
-    // doing the work to init on a different set of files.
-
-    data->Reset();
-    InitData( data, FALSE );
-
-    retval = TRUE;
-
-CLEANUP:
-    END_QCALL;
-
-    return retval;
-}
-
-BOOL SecurityConfig::GetQuickCacheEntry( INT32 id, QuickCacheEntryType type )
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END
-
-    //
-    // If there is no config file for this level, then we'll assume the default
-    // security policy is in effect. This could happen for example if there is
-    // user profile loaded or if the config file is not present.
-    //
-
-    Data* data = (Data*)GetData( id );
-    if (data == NULL || ((data->state & Data::UsingConfigFile) == 0))
-        return (type == FullTrustZoneMyComputer); // MyComputer gets FT by default.
-
-    if ((data->state & Data::UsingCacheFile) == 0)
-        return FALSE;
-
-    return (data->header.quickCache & type);
-}
-
-void QCALLTYPE SecurityConfig::SetQuickCache(INT32 id, QuickCacheEntryType type)
-{
-    QCALL_CONTRACT;
-
-    BEGIN_QCALL;
-
-    Data* data = (Data*)GetData( id );
-
-    if (data != NULL && (DWORD) type != data->header.quickCache)
-    {
-        CrstHolder ch(&dataLock_);
-
-        data->state = (Data::State)(Data::CacheUpdated | data->state);
-        data->header.quickCache = type;
-    }
-
-    END_QCALL;
-}
-
-static HANDLE OpenCacheFile( Data* data )
-{
-    STANDARD_VM_CONTRACT;
-
-    CrstHolder ch(&SecurityConfig::dataLock_);
-
-    if (data->cache != INVALID_HANDLE_VALUE)
-        return data->cache;
-
-    _ASSERTE( FALSE && "This case should never happen" );
-
-    data->cache = WszCreateFile( data->cacheFileName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
-    if (data->cache == INVALID_HANDLE_VALUE)
-        return NULL;
-
-    // Check whether the cache has changed since we first looked at it.
-    // If it has but the config file hasn't, then we need to start fresh.
-    // However, if the config file has changed then we have to ignore it.
-
-    if (CacheOutOfDate( &data->cacheFileTime, data->cache, NULL ))
-    {
-        if (CacheOutOfDate( &data->configFileTime, data->configFileName, NULL ))
-            return NULL;
-
-        if (ReadFileData( data->cache, (BYTE*)&data->header, sizeof( CacheHeader ) ) != S_OK)
-            return NULL;
-
-        data->cacheCurrentPosition = sizeof( CacheHeader );
-
-        if (data->oldCacheEntries != NULL)
-        {
-            ArrayList::Iterator iter = data->oldCacheEntries->Iterate();
-            while (iter.Next())
-            {
-                delete (CacheEntry*)iter.GetElement();
-            }
-            delete data->oldCacheEntries;
-            data->oldCacheEntries = new ArrayList();
-        }
-    }
-
-    return data->cache;
-}
-
-static BYTE* CompareEntry( CacheEntry* entry, DWORD numEvidence, DWORD evidenceSize, LPCBYTE evidenceBlock, HANDLE cache, DWORD* size)
-{
-    STANDARD_VM_CONTRACT;
-
-    _ASSERTE (entry);
-
-    if (entry->header.numItemsInKey == numEvidence &&
-        entry->header.keySize == evidenceSize)
-    {
-        if (entry->key == NULL)
-        {
-            // We were lazy in reading the entry. Read the key now.
-            entry->key = new BYTE[entry->header.keySize];
-
-            _ASSERTE (cache != INVALID_HANDLE_VALUE);
-
-            if (SetFilePointer( cache, entry->cachePosition, NULL, FILE_BEGIN ) == INVALID_SET_FILE_POINTER)
-                return NULL;
-
-            if (ReadFileData( cache, entry->key, entry->header.keySize ) != S_OK)
-                return NULL;
-
-            entry->cachePosition += entry->header.keySize;
-        }
-
-        _ASSERTE (entry->key);
-
-        if (memcmp( entry->key, evidenceBlock, entry->header.keySize ) == 0)
-        {
-            if (entry->data == NULL)
-            {
-                // We were lazy in reading the entry. Read the data also.
-                entry->data = new BYTE[entry->header.dataSize];
-
-                if (SetFilePointer( cache, entry->cachePosition, NULL, FILE_BEGIN ) == INVALID_SET_FILE_POINTER)
-                    return NULL;
-
-                if (ReadFileData( cache, entry->data, entry->header.dataSize ) != S_OK)
-                    return NULL;
-
-                entry->cachePosition += entry->header.dataSize;
-            }
-
-            entry->used = TRUE;
-            *size = entry->header.dataSize;
-
-            return entry->data;
-        }
-    }
-    return NULL;
-}
-
-BOOL QCALLTYPE SecurityConfig::GetCacheEntry(INT32 id, DWORD numEvidence, LPCBYTE pEvidence, DWORD cbEvidence, QCall::ObjectHandleOnStack retPolicy)
-{
-    QCALL_CONTRACT;
-
-    BOOL success = FALSE;
-
-    BEGIN_QCALL;
-
-    HANDLE cache = INVALID_HANDLE_VALUE;
-
-    BYTE* retval = NULL;
-    DWORD size = (DWORD) -1;
-
-    Data* data = (Data*)GetData( id );
-
-    if (data == NULL)
-    {
-        goto CLEANUP;
-    }
-
-    {
-
-        ArrayList::Iterator iter;
-
-        if ((data->state & Data::UsingCacheFile) == 0)
-        {
-            // We know we don't have anything in the config file, so
-            // let's just look through the new entries to make sure we
-            // aren't getting any repeats.
-
-            // Then try the existing new entries
-
-            iter = data->newCacheEntries->Iterate();
-
-            while (iter.Next())
-            {
-                // newCacheEntries do not need the cache file so pass in NULL.
-                retval = CompareEntry( (CacheEntry*)iter.GetElement(), numEvidence, cbEvidence, pEvidence, NULL, &size );
-
-                if (retval != NULL)
-                {
-                    success = TRUE;
-                    goto CLEANUP;
-                }
-            }
-
-            goto CLEANUP;
-        }
-
-        // Its possible that the old entries were not read in completely
-        // so we keep the cache file open before iterating through the
-        // old entries.
-
-        cache = OpenCacheFile( data );
-
-        if ( cache == NULL )
-        {
-            goto CLEANUP;
-        }
-
-        // First, iterator over the old entries
-
-        {
-            CrstHolder ch(&dataLock_);
-
-            iter = data->oldCacheEntries->Iterate();
-            while (iter.Next())
-            {
-                retval = CompareEntry( (CacheEntry*)iter.GetElement(), numEvidence, cbEvidence, pEvidence, cache, &size );
-                if (retval != NULL)
-                {
-                    success = TRUE;
-                    goto CLEANUP;
-                }
-            }
-
-            // LockHolder goes out of scope here
-        }
-
-        // Then try the existing new entries
-        iter = data->newCacheEntries->Iterate();
-        while (iter.Next())
-        {
-            // newCacheEntries do not need the cache file so pass in NULL.
-            retval = CompareEntry( (CacheEntry*)iter.GetElement(), numEvidence, cbEvidence, pEvidence, NULL, &size );
-            if (retval != NULL)
-            {
-                success = TRUE;
-                goto CLEANUP;
-            }
-        }
-
-        // Finally, try loading existing entries from the file
-
-        {
-            CrstHolder ch(&dataLock_);
-
-            if (SetFilePointer( cache, data->cacheCurrentPosition, NULL, FILE_BEGIN ) == INVALID_SET_FILE_POINTER)
-            {
-                goto CLEANUP;
-            }
-
-            do
-            {
-                CacheEntry* entry = LoadNextEntry( cache, data );
-                if (entry == NULL)
-                {
-                    data->state = (Data::State)(Data::CacheExhausted | data->state);
-                    break;
-                }
-
-                retval = CompareEntry( entry, numEvidence, cbEvidence, pEvidence, cache, &size );
-                if (retval != NULL)
-                {
-                    success = TRUE;
-                    break;
-                }
-            } while (TRUE);
-
-            // LockHolder goes out of scope here
-        }
-    }
-
-CLEANUP:
-    if (success && retval != NULL)
-    {
-        _ASSERTE( size != (DWORD) -1 );
-        retPolicy.SetByteArray(retval, size);
-    }
-
-    END_QCALL;
-
-    return success;
-}
-
-void QCALLTYPE SecurityConfig::AddCacheEntry(INT32 id, DWORD numEvidence, LPCBYTE pEvidence, DWORD cbEvidence, LPCBYTE pPolicy, DWORD cbPolicy)
-{
-    QCALL_CONTRACT;
-
-    BEGIN_QCALL;
-
-    Data* data = (Data*)GetData( id );
-
-    DWORD sizeOfEntry = 0;
-    NewHolder<CacheEntry> entry;
-
-    if (data == NULL)
-    {
-        goto lExit;
-    }
-
-    // In order to limit how large a long running app can become,
-    // we limit the total memory held by the new cache entries list.
-    // For now this limit corresponds with how large the max cache file
-    // can be.
-
-    sizeOfEntry = cbEvidence + cbPolicy + sizeof( CacheEntryHeader );
-
-    if (data->newEntriesSize + sizeOfEntry >= MAX_CACHEFILE_SIZE)
-    {
-        goto lExit;
-    }
-
-    entry = new CacheEntry();
-
-    entry->header.numItemsInKey = numEvidence;
-    entry->header.keySize = cbEvidence;
-    entry->header.dataSize = cbPolicy;
-
-    entry->key = new BYTE[entry->header.keySize];
-    entry->data = new BYTE[entry->header.dataSize];
-
-    memcpyNoGCRefs(entry->key, pEvidence, cbEvidence);
-    memcpyNoGCRefs(entry->data, pPolicy, cbPolicy);
-
-    {
-        CrstHolder ch(&dataLock_);
-
-        // Check the size again to handle the race.
-        if (data->newEntriesSize + sizeOfEntry < MAX_CACHEFILE_SIZE)
-        {
-            data->state = (Data::State)(Data::CacheUpdated | data->state);
-            IfFailThrow(data->newCacheEntries->Append( entry.GetValue() ));
-            entry.SuppressRelease();
-            data->newEntriesSize += sizeOfEntry;
-        }
-    }
-
-lExit: ;
-
-    END_QCALL;
-}
-
-ArrayListStatic SecurityConfig::entries_;
-CrstStatic      SecurityConfig::dataLock_;
-
-void SecurityConfig::Init( void )
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END
-
-    dataLock_.Init(CrstSecurityPolicyCache);
-    entries_.Init();
-}
-
-void SecurityConfig::Cleanup( void )
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END
-
-    ArrayList::Iterator iter = entries_.Iterate();
-
-    GCX_PREEMP();
-
-    CrstHolder ch(&dataLock_);
-
-    while (iter.Next())
-    {
-        ((Data*) iter.GetElement())->Cleanup();
-    }
-}
-
-void SecurityConfig::Delete( void )
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END
-
-    ArrayList::Iterator iter = entries_.Iterate();
-
-    while (iter.Next())
-    {
-        delete (Data*) iter.GetElement();
-    }
-
-    entries_.Destroy();
-    dataLock_.Destroy();
-}
-
-void QCALLTYPE SecurityConfig::_GetMachineDirectory(QCall::StringHandleOnStack retDirectory)
-{
-    QCALL_CONTRACT;
-
-    BEGIN_QCALL;
-
-    WCHAR machine[MAX_LONGPATH];
-
-    HRESULT hr = GetMachineDirectory(machine, MAX_LONGPATH);
-    if (FAILED(hr))
-        ThrowHR(hr);
-
-    retDirectory.Set(machine);
-
-    END_QCALL;
-}
-
-void QCALLTYPE SecurityConfig::_GetUserDirectory(QCall::StringHandleOnStack retDirectory)
-{
-    QCALL_CONTRACT;
-
-    BEGIN_QCALL;
-
-    WCHAR user[MAX_LONGPATH];
-
-    BOOL result = GetUserDirectory(user, MAX_LONGPATH);
-    if (result)
-        retDirectory.Set(user);
-
-    END_QCALL;
-}
-
-HRESULT SecurityConfig::GetMachineDirectory(__out_ecount(bufferCount) __out_z WCHAR* buffer, size_t bufferCount)
-{
-    STANDARD_VM_CONTRACT;
-
-    HRESULT hr;
-
-    DWORD length = (DWORD)bufferCount;
-    hr = GetInternalSystemDirectory(buffer, &length);
-    if (FAILED(hr))
-        return hr;
-    
-    // Make sure we have enough buffer to concat the string.
-    // Note the length including the terminating zero. 
-    if((bufferCount - wcslen(buffer) - 1) < wcslen(W("config\\")))
-        return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
-
-    wcscat_s(buffer, bufferCount, W("config\\"));
-
-    return S_OK;
-}
-
-BOOL SecurityConfig::GetVIUserDirectory(__out_ecount(bufferCount) __out_z WCHAR* buffer, size_t bufferCount)
-{
-    STANDARD_VM_CONTRACT;
-
-    WCHAR scratchBuffer[MAX_LONGPATH];
-    BOOL retval = FALSE;
-
-    DWORD size = MAX_LONGPATH;
-
-    if (!GetUserDir(buffer, bufferCount, TRUE))
-        goto CLEANUP;
-
-    wcscpy_s( scratchBuffer, COUNTOF(scratchBuffer), W("\\Microsoft\\CLR Security Config\\") );
-
-    if (bufferCount < wcslen( buffer ) + wcslen( scratchBuffer ) + 1)
-    {
-        goto CLEANUP;
-    }
-
-    wcscat_s( buffer, bufferCount, scratchBuffer );
-
-    retval = TRUE;
-
-CLEANUP:
-    return retval;
-}
-
-BOOL SecurityConfig::GetUserDirectory(__out_ecount(bufferCount) __out_z WCHAR* buffer, size_t bufferCount)
-{
-    STANDARD_VM_CONTRACT;
-
-    StackSString ssScratchBuffer;
-    BOOL retval = FALSE;
-
-    WCHAR* wszScratchBuffer = ssScratchBuffer.OpenUnicodeBuffer( (COUNT_T)bufferCount );
-    retval = GetVIUserDirectory(wszScratchBuffer, bufferCount);
-    ssScratchBuffer.CloseBuffer( (COUNT_T)wcslen( wszScratchBuffer ) );
-
-    if (!retval)
-        return retval;
-
-    ssScratchBuffer.Append( W("v") );
-    ssScratchBuffer.Append( VER_PRODUCTVERSION_NO_QFE_STR_L );
-    ssScratchBuffer.Append( W("\\") );
-
-#ifdef _WIN64
-    ssScratchBuffer.Append( W("64bit\\") );
-#endif // _WIN64
-
-    if (ssScratchBuffer.GetCount() + 1 > bufferCount)
-        return FALSE;
-
-    wcscpy_s( buffer, bufferCount, ssScratchBuffer.GetUnicode() );
-
-    return TRUE;
-}
-
-BOOL QCALLTYPE SecurityConfig::WriteToEventLog(LPCWSTR wszMessage)
-{
-    QCALL_CONTRACT;
-
-    BOOL retVal = FALSE;
-
-    BEGIN_QCALL;
-
-    retVal = ReportEventCLR(
-                EVENTLOG_WARNING_TYPE,      // event type 
-                0,                          // category 
-                (DWORD)1000,                // event identifier 
-                NULL,                       // no user security identifier 
-                &StackSString(wszMessage)); // message to log
-
-    END_QCALL
-
-    return retVal;
-}
-
-#ifdef _DEBUG
-HRESULT QCALLTYPE SecurityConfig::DebugOut(LPCWSTR wszFileName, LPCWSTR wszMessage)
-{
-    HRESULT retVal = E_FAIL;
-
-    QCALL_CONTRACT;
-
-    BEGIN_QCALL;
-
-    HandleHolder file(WszCreateFile( wszFileName, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL ));
-
-    if (file == INVALID_HANDLE_VALUE)
-    {
-        goto lExit;
-    }
-
-    SetFilePointer( file, 0, NULL, FILE_END );
-
-    DWORD cbMessage;
-    DWORD cbWritten;
-
-    cbMessage = (DWORD)wcslen(wszMessage) * sizeof(WCHAR);
-    if (!WriteFile( file, wszMessage, cbMessage, &cbWritten, NULL ))
-    {
-        goto lExit;
-    }
-
-    if (cbMessage != cbWritten)
-    {
-        goto lExit;
-    }
-
-    retVal = S_OK;
-
-lExit: ;
-    END_QCALL;
-
-    return retVal;
-}
-#endif
-
-#endif // FEATURE_CAS_POLICY
diff --git a/src/vm/securityconfig.h b/src/vm/securityconfig.h
deleted file mode 100644
index e7517c517e..0000000000
--- a/src/vm/securityconfig.h
+++ /dev/null
@@ -1,122 +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.
-//
-// File: SecurityConfig.h
-// 
-
-// 
-// Native implementation for security config access and manipulation
-//
-
-
-#ifndef _COMSecurityConfig_H_
-#define _COMSecurityConfig_H_
-#ifdef FEATURE_CAS_POLICY
-
-#include "qcall.h"
-
-class SecurityConfig
-{
-friend struct CacheHeader;
-
-private:
-    // These structures can be removed in the next SxS runtime version when we won't have to potentially read
-    // config files generated by an in-place runtime that used to include them in the header.
-    enum RegistryExtensionsAccessStatus {
-        Unknown         = 0,
-        NoExtensions    = 1,
-        AccessFailure   = 2,
-        AccessSuccess   = 3
-    };
-
-    struct RegistryExtensionsInfo {
-        RegistryExtensionsAccessStatus  eStatus;
-        FILETIME                        ftLastWriteTime;
-    };
-
-public:
-    // Duplicated in System.Security.Util.Config.cs
-    enum ConfigId
-    {
-        None                    = 0,
-        MachinePolicyLevel      = 1,
-        UserPolicyLevel         = 2,
-        EnterprisePolicyLevel   = 3,
-    };
-
-    // Duplicated in System.Security.Util.Config.cs
-    enum QuickCacheEntryType
-    {
-        FullTrustZoneMyComputer = 0x1000000,
-        FullTrustZoneIntranet   = 0x2000000,
-        FullTrustZoneInternet   = 0x4000000,
-        FullTrustZoneTrusted    = 0x8000000,
-        FullTrustZoneUntrusted  = 0x10000000,
-        FullTrustAll            = 0x20000000,
-    };
-
-    // Duplicated in System.Security.Util.Config.cs
-    enum ConfigRetval
-    {
-        NoFile = 0,
-        ConfigFile = 1,
-        CacheFile = 2
-    };
-
-    static ConfigRetval InitData( INT32 id, const WCHAR* configFileName, const WCHAR* cacheFileName );
-    static ConfigRetval InitData( void* configData, BOOL addToList );
-
-    static BOOL SaveCacheData( INT32 id );
-
-    static
-    void QCALLTYPE ResetCacheData(INT32 id);
-
-    static
-    HRESULT QCALLTYPE SaveDataByte(LPCWSTR wszConfigPath, LPCBYTE pbData, DWORD cbData);
-
-    static
-    BOOL QCALLTYPE RecoverData(INT32 id);
-
-    static 
-    void QCALLTYPE SetQuickCache(INT32 id, QuickCacheEntryType type);
-
-    static
-    BOOL QCALLTYPE GetCacheEntry(INT32 id, DWORD numEvidence, LPCBYTE pEvidence, DWORD cbEvidence, QCall::ObjectHandleOnStack retPolicy);
-
-    static
-    void QCALLTYPE AddCacheEntry(INT32 id, DWORD numEvidence, LPCBYTE pEvidence, DWORD cbEvidence, LPCBYTE pPolicy, DWORD cbPolicy);
-
-    static
-    void QCALLTYPE _GetMachineDirectory(QCall::StringHandleOnStack retDirectory);
-
-    static
-    void QCALLTYPE _GetUserDirectory(QCall::StringHandleOnStack retDirectory);
-
-    static HRESULT GetMachineDirectory (__out_ecount(bufferCount) __out_z WCHAR* buffer, size_t bufferCount);
-    static BOOL GetUserDirectory(__out_ecount(bufferCount) __out_z WCHAR* buffer, size_t bufferCount);
-    static BOOL GetVIUserDirectory(__out_ecount(bufferCount) __out_z WCHAR* buffer, size_t bufferCount);
-
-    static
-    BOOL QCALLTYPE WriteToEventLog(LPCWSTR wszMessage);
-
-#ifdef _DEBUG
-    static
-    HRESULT QCALLTYPE DebugOut(LPCWSTR wszFileName, LPCWSTR wszMessage);
-#endif
-
-    static void Init( void );
-    static void Cleanup( void );
-    static void Delete( void );
-
-    static BOOL GetQuickCacheEntry( INT32 id, QuickCacheEntryType type );
-
-    static void* GetData( INT32 id );
-
-    static ArrayListStatic  entries_;
-    static CrstStatic       dataLock_;
-
-    static WCHAR* wcscatDWORD( __out_ecount(cchdst) __out_z WCHAR* dst, size_t cchdst, DWORD num );
-};
-#endif // FEATURE_CAS_POLICY
-#endif
diff --git a/src/vm/securitydeclarative.cpp b/src/vm/securitydeclarative.cpp
index 25418d03e8..0673e534b4 100644
--- a/src/vm/securitydeclarative.cpp
+++ b/src/vm/securitydeclarative.cpp
@@ -198,19 +198,11 @@ void SecurityDeclarative::AddDeclAction(CorDeclSecurity action, PsetCacheEntry *
         break;
 
     case DS_UNION:
-#ifdef FEATURE_CAS_POLICY
-        LinkNewDeclAction(ppActionList, action, SecurityAttributes::MergePermissionSets(pClassPCE, pMethodPCE, false, action), pMeth);
-#else // FEATURE_CAS_POLICY
         _ASSERTE(!"Declarative permission sets may not be unioned together in CoreCLR. Are you attempting to have a declarative demand or deny on both a method and its enclosing class?");
-#endif // FEATURE_CAS_POLICY
         break;
 
     case DS_INTERSECT:
-#ifdef FEATURE_CAS_POLICY
-        LinkNewDeclAction(ppActionList, action, SecurityAttributes::MergePermissionSets(pClassPCE, pMethodPCE, true, action), pMeth);
-#else // FEATURE_CAS_POLICY
         _ASSERTE(!"Declarative permission sets may not be intersected in CoreCLR. Are you attempting to have a declarative permit only on both a method and its enclosing class?");
-#endif // FEATURE_CAS_POLICY
         break;
 
     case DS_APPLY_METHOD_THEN_CLASS:
@@ -269,14 +261,7 @@ DeclActionInfo* SecurityDeclarative::DetectDeclActions(MethodDesc *pMeth, DWORD
 
             if (pClass->HasSuppressUnmanagedCodeAccessAttr())
             {
-#ifdef FEATURE_CORECLR
                 hr = S_OK;
-#else
-                hr = pInternalImport->GetCustomAttributeByName(pMT->GetCl(),
-                                                               COR_SUPPRESS_UNMANAGED_CODE_CHECK_ATTRIBUTE_ANSI,
-                                                               NULL,
-                                                               NULL);
-#endif // FEATURE_CORECLR
                 if (hr != S_OK)
                 {
                     g_IBCLogger.LogEEClassCOWTableAccess(pMT);
@@ -536,15 +521,7 @@ HRESULT SecurityDeclarative::GetDeclarationFlags(IMDInternalImport *pInternalImp
     BOOL hasSuppressUnmanagedCodeAccessAttr;
     if (pfHasSuppressUnmanagedCodeAccessAttr == NULL)
     {
-#ifdef FEATURE_CORECLR
         hasSuppressUnmanagedCodeAccessAttr = TRUE;
-#else
-        hasSuppressUnmanagedCodeAccessAttr = 
-          (pInternalImport->GetCustomAttributeByName(token,
-                                                     COR_SUPPRESS_UNMANAGED_CODE_CHECK_ATTRIBUTE_ANSI,
-                                                     NULL,
-                                                     NULL) == S_OK);
-#endif
     }
     else
         hasSuppressUnmanagedCodeAccessAttr = *pfHasSuppressUnmanagedCodeAccessAttr;
@@ -596,109 +573,6 @@ void SecurityDeclarative::MethodInheritanceCheck(MethodDesc *pMethod, MethodDesc
     MDSecDesc.InvokeInheritanceChecks(pMethod);
 }
 
-//---------------------------------------------------------
-// Invoke linktime checks on the caller if demands exist
-// for the callee.
-//---------------------------------------------------------
-/*static*/
-void SecurityDeclarative::LinktimeCheckMethod(Assembly *pCaller, MethodDesc *pCallee)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    } CONTRACTL_END;
-
-#ifdef FEATURE_CAS_POLICY
-    // Do a fulltrust check on the caller if the callee is fully trusted         
-    if (FullTrustCheckForLinkOrInheritanceDemand(pCaller))
-    {
-        return;
-    }
-
-#ifdef CROSSGEN_COMPILE
-    CrossGenNotSupported("SecurityDeclarative::LinktimeCheckMethod");
-#else
-    GCX_COOP();
-
-    MethodTable *pTargetMT = pCallee->GetMethodTable();
-
-    // If it's a delegate BeginInvoke, we need to perform a HostProtection check for synchronization
-    if(pTargetMT->IsDelegate())
-    {
-        DelegateEEClass* pDelegateClass = (DelegateEEClass*)pTargetMT->GetClass();
-        if(pCallee == pDelegateClass->m_pBeginInvokeMethod)
-        {
-            EApiCategories eProtectedCategories = GetHostProtectionManager()->GetProtectedCategories();
-            if((eProtectedCategories & eSynchronization) == eSynchronization)
-            {
-                if(!pCaller->GetSecurityDescriptor()->IsFullyTrusted())
-                {
-                    ThrowHPException(eProtectedCategories, eSynchronization);
-                }
-            }
-        }
-    }
-
-    // the rest of the LinkDemand checks
-    {
-        // Track perfmon counters. Linktime security checkes.
-        COUNTER_ONLY(GetPerfCounters().m_Security.cLinkChecks++);
-
-#ifdef FEATURE_APTCA
-        // APTCA check
-        SecurityDeclarative::DoUntrustedCallerChecks(pCaller, pCallee, FALSE);
-#endif // FEATURE_APTCA
-
-        // If the class has its own linktime checks, do them first...
-        if (pTargetMT->GetClass()->RequiresLinktimeCheck())
-        {
-            TypeSecurityDescriptor::InvokeLinktimeChecks(pTargetMT, pCaller);
-        }
-
-        // If the previous check passed, check the method for
-        // method-specific linktime checks...
-        if (IsMdHasSecurity(pCallee->GetAttrs()) &&
-            (TokenMightHaveDeclarations(pTargetMT->GetMDImport(),
-                                  pCallee->GetMemberDef(),
-                                  dclLinktimeCheck) ||
-             TokenMightHaveDeclarations(pTargetMT->GetMDImport(),
-                                  pCallee->GetMemberDef(),
-                                  dclNonCasLinkDemand) ))
-        {
-            MethodSecurityDescriptor::InvokeLinktimeChecks(pCallee, pCaller);
-        }
-
-        // We perform automatic linktime checks for UnmanagedCode in three cases:
-        //   o  P/Invoke calls
-        //   o  Calls through an interface that have a suppress runtime check
-        //      attribute on them (these are almost certainly interop calls).
-        //   o  Interop calls made through method impls.
-        if (pCallee->IsNDirect() ||
-            (pTargetMT->IsInterface() &&
-             (pTargetMT->GetMDImport()->GetCustomAttributeByName(pTargetMT->GetCl(),
-                                                                   COR_SUPPRESS_UNMANAGED_CODE_CHECK_ATTRIBUTE_ANSI,
-                                                                   NULL,
-                                                                   NULL) == S_OK ||
-              pTargetMT->GetMDImport()->GetCustomAttributeByName(pCallee->GetMemberDef(),
-                                                                   COR_SUPPRESS_UNMANAGED_CODE_CHECK_ATTRIBUTE_ANSI,
-                                                                   NULL,
-                                                                   NULL) == S_OK) ) ||
-            (pCallee->IsComPlusCall() && !pCallee->IsInterface()))
-        {
-            if (!pCaller->GetSecurityDescriptor()->CanCallUnmanagedCode())
-            {
-                Security::ThrowSecurityException(g_SecurityPermissionClassName, SPFLAGSUNMANAGEDCODE);
-            }
-        }
-    }
-
-#endif // !CROSSGEN_COMPILE
-
-#endif // FEATURE_CAS_POLICY
-}
-
 #ifndef CROSSGEN_COMPILE
 //-----------------------------------------------------------------------------
 //
@@ -708,222 +582,10 @@ void SecurityDeclarative::LinktimeCheckMethod(Assembly *pCaller, MethodDesc *pCa
 //
 //-----------------------------------------------------------------------------
 
-void SecurityDeclarative::_GetSharedPermissionInstance(OBJECTREF *perm, int index)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    _ASSERTE(index < (int) NUM_PERM_OBJECTS);
-
-    AppDomain *pDomain = GetAppDomain();
-    SharedPermissionObjects *pShared = &pDomain->m_pSecContext->m_rPermObjects[index];
-
-    if (pShared->hPermissionObject == NULL) {
-        pShared->hPermissionObject = pDomain->CreateHandle(NULL);
-        *perm = NULL;
-    }
-    else
-        *perm = ObjectFromHandle(pShared->hPermissionObject);
-
-    if (*perm == NULL)
-    {
-        MethodTable *pMT = NULL;
-        OBJECTREF p = NULL;
-
-        GCPROTECT_BEGIN(p);
-
-        pMT = MscorlibBinder::GetClass(pShared->idClass);
-        MethodDescCallSite  ctor(pShared->idConstructor);
-
-        p = AllocateObject(pMT);
-
-        ARG_SLOT argInit[2] =
-        {
-            ObjToArgSlot(p),
-            (ARG_SLOT) pShared->dwPermissionFlag
-        };
-
-        ctor.Call(argInit);
-
-        StoreObjectInHandle(pShared->hPermissionObject, p);
-        *perm = p;
-
-        GCPROTECT_END();
-    }
-}
-
-#ifdef FEATURE_APTCA
-void DECLSPEC_NORETURN SecurityDeclarative::ThrowAPTCAException(Assembly *pCaller, MethodDesc *pCallee)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM(););
-    } CONTRACTL_END;
-
-        MethodDescCallSite throwSecurityException(METHOD__SECURITY_ENGINE__THROW_SECURITY_EXCEPTION);
-
-        OBJECTREF callerObj = NULL;
-        if (pCaller != NULL && pCaller->GetDomain() == GetAppDomain())
-            callerObj = pCaller->GetExposedObject();
-
-        ARG_SLOT args[7];
-        args[0] = ObjToArgSlot(callerObj);
-        args[1] = ObjToArgSlot(NULL);
-        args[2] = ObjToArgSlot(NULL);
-        args[3] = PtrToArgSlot(pCallee);
-        args[4] = (ARG_SLOT)dclLinktimeCheck;
-        args[5] = ObjToArgSlot(NULL);
-        args[6] = ObjToArgSlot(NULL);
-        throwSecurityException.Call(args);
-
-    UNREACHABLE();
-}
-#endif // FEATURE_APTCA
-
-#ifdef FEATURE_CAS_POLICY
-void DECLSPEC_NORETURN SecurityDeclarative::ThrowHPException(EApiCategories protectedCategories, EApiCategories demandedCategories)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM(););
-    } CONTRACTL_END;
-
-    OBJECTREF hpException = NULL;
-    GCPROTECT_BEGIN(hpException);
-
-    MethodTable* pMT = MscorlibBinder::GetClass(CLASS__HOST_PROTECTION_EXCEPTION);
-    hpException = (OBJECTREF) AllocateObject(pMT);
-
-
-    MethodDescCallSite ctor(METHOD__HOST_PROTECTION_EXCEPTION__CTOR);
-
-    ARG_SLOT arg[3] = { 
-        ObjToArgSlot(hpException),
-        protectedCategories,
-        demandedCategories
-    };
-    ctor.Call(arg);
-    
-    COMPlusThrow(hpException);
-
-    GCPROTECT_END();
-}
-#endif // FEATURE_CAS_POLICY
-
-#ifdef FEATURE_APTCA
-BOOL SecurityDeclarative::IsUntrustedCallerCheckNeeded(MethodDesc *pCalleeMD, Assembly *pCallerAssem)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    Assembly *pCalleeAssembly = pCalleeMD->GetAssembly();
-    _ASSERTE(pCalleeAssembly != NULL);
-
-    // ATPCA is only enforced for cross-assembly calls, so if the target is not accessable from outside
-    // the assembly, or if the caller and callee are both within the same assembly, we do not need to
-    // do any APTCA checks
-    if (pCallerAssem == pCalleeAssembly)
-    {
-        return FALSE;
-    }
-
-    if (!MethodIsVisibleOutsideItsAssembly(pCalleeMD))
-    {
-        return FALSE;
-    }
-
-    // If the target assembly allows untrusted callers unconditionally, then the call should be allowed
-    if (pCalleeAssembly->AllowUntrustedCaller())
-    {
-        return FALSE;
-    }
-
-    // Otherwise, we need to ensure the caller is fully trusted
-    return TRUE;
-}
-#endif // FEATURE_APTCA
-
-
-#ifdef FEATURE_APTCA
-// Do a fulltrust check on the caller if the callee is fully trusted and
-// callee did not enable AllowUntrustedCallerChecks
-/*static*/
-void SecurityDeclarative::DoUntrustedCallerChecks(
-        Assembly *pCaller, MethodDesc *pCallee, 
-        BOOL fFullStackWalk)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM(););
-    } CONTRACTL_END;
-
-    BOOL fRet = TRUE;
-
-#ifdef _DEBUG
-    if (!g_pConfig->Do_AllowUntrustedCaller_Checks())
-        return;
-#endif
 
-    if (!IsUntrustedCallerCheckNeeded(pCallee, pCaller))
-        return;
 
-    // Expensive calls after this point, this could end up resolving policy
 
-    if (fFullStackWalk)
-    {
-        // It is possible that wrappers like VBHelper libraries that are
-        // fully trusted, make calls to public methods that do not have
-        // safe for Untrusted caller custom attribute set.
-        // Like all other link demand that gets transformed to a full stack
-        // walk for reflection, calls to public methods also gets
-        // converted to full stack walk
-
-        OBJECTREF permSet = NULL;
-        GCPROTECT_BEGIN(permSet);
-
-        GetPermissionInstance(&permSet, SECURITY_FULL_TRUST);
-        EX_TRY
-        {
-            SecurityStackWalk::DemandSet(SSWT_LATEBOUND_LINKDEMAND, permSet);
-        }
-        EX_CATCH
-        {
-            fRet = FALSE;
-        }
-        EX_END_CATCH(RethrowTerminalExceptions);
 
-        GCPROTECT_END();
-    }
-    else
-    {
-        _ASSERTE(pCaller);
-
-        // Link Demand only, no full stack walk here
-        if (!pCaller->GetSecurityDescriptor()->IsFullyTrusted())
-            fRet = FALSE;
-    }
-
-    if (!fRet)
-    {
-        ThrowAPTCAException(pCaller, pCallee);
-    }
-}
-
-#endif // FEATURE_APTCA
 
 // Retrieve all linktime demands sets for a method. This includes both CAS and
 // non-CAS sets for LDs at the class and the method level, so we could get up to
@@ -941,17 +603,6 @@ void SecurityDeclarative::RetrieveLinktimeDemands(MethodDesc  *pMD,
         INJECT_FAULT(COMPlusThrowOM(););
     } CONTRACTL_END;
 
-#ifdef FEATURE_CAS_POLICY
-    MethodTable * pMT = pMD->GetMethodTable();
-
-    // Class level first.
-    if (pMT->GetClass()->RequiresLinktimeCheck())
-        *pClassCas = TypeSecurityDescriptor::GetLinktimePermissions(pMT, pClassNonCas);
-
-    // Then the method level.
-    if (IsMdHasSecurity(pMD->GetAttrs()))
-        *pMethodCas = MethodSecurityDescriptor::GetLinktimePermissions(pMD,  pMethodNonCas);
-#endif
 }
 
 //
@@ -991,7 +642,7 @@ LinktimeCheckReason SecurityDeclarative::GetLinktimeCheckReason(MethodDesc *pMD,
 
     LinktimeCheckReason reason = LinktimeCheckReason_None;
 
-#if defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM)
+#if defined(FEATURE_CORESYSTEM)
     ModuleSecurityDescriptor *pMSD = ModuleSecurityDescriptor::GetModuleSecurityDescriptor(pMD->GetAssembly());
 
     // If the method does not allow partially trusted callers, then the check is because we need to ensure all
@@ -1000,7 +651,7 @@ LinktimeCheckReason SecurityDeclarative::GetLinktimeCheckReason(MethodDesc *pMD,
     {
         reason |= LinktimeCheckReason_AptcaCheck;
     }
-#endif // defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM)
+#endif // defined(FEATURE_CORESYSTEM)
 
     //
     // If the method has a LinkDemand on it for either CAS or non-CAS permissions, get those and set the
@@ -1102,688 +753,5 @@ LinktimeCheckReason SecurityDeclarative::GetLinktimeCheckReason(MethodDesc *pMD,
     return reason;
 }
 
-#ifdef FEATURE_CAS_POLICY
-// Issue an inheritance demand against the target assembly
-
-// static
-void SecurityDeclarative::InheritanceDemand(Assembly *pTargetAssembly, OBJECTREF refDemand)
-{
-    CONTRACTL
-    {
-        THROWS;
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-        PRECONDITION(CheckPointer(pTargetAssembly));
-        PRECONDITION(refDemand != NULL);
-    }
-    CONTRACTL_END;
-
-    struct
-    {
-        OBJECTREF refDemand;
-    }
-    gc;
-    ZeroMemory(&gc, sizeof(gc));
-    gc.refDemand = refDemand;
-
-    GCPROTECT_BEGIN(gc);
-
-    IAssemblySecurityDescriptor *pTargetASD = pTargetAssembly->GetSecurityDescriptor();
-    SecurityStackWalk::LinkOrInheritanceCheck(pTargetASD,
-                                              gc.refDemand,
-                                              pTargetAssembly,
-                                              dclInheritanceCheck);
-    GCPROTECT_END();
-}
-
-// static
-void SecurityDeclarative::InheritanceLinkDemandCheck(Assembly *pTargetAssembly, MethodDesc * pMDLinkDemand)
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pTargetAssembly));
-        PRECONDITION(CheckPointer(pMDLinkDemand));
-    }
-    CONTRACTL_END;
-
-    GCX_COOP();
-    struct
-    {
-        OBJECTREF refClassCas;
-        OBJECTREF refClassNonCas;
-        OBJECTREF refMethodCas;
-        OBJECTREF refMethodNonCas;
-    }
-    gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc);
-
-    Security::RetrieveLinktimeDemands(pMDLinkDemand,
-                                        &gc.refClassCas,
-                                        &gc.refClassNonCas,
-                                        &gc.refMethodCas,
-                                        &gc.refMethodNonCas);
-
-    if (gc.refClassCas != NULL)
-    {
-        InheritanceDemand(pTargetAssembly, gc.refClassCas);
-    }
-
-    if (gc.refMethodCas != NULL)
-    {
-        InheritanceDemand(pTargetAssembly, gc.refMethodCas);
-    }
-
-    GCPROTECT_END();
-}
-
-// Issue a FullTrust inheritance demand against the target assembly
-
-// static
-void SecurityDeclarative::FullTrustInheritanceDemand(Assembly *pTargetAssembly)
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pTargetAssembly));
-    }
-    CONTRACTL_END;
-
-    GCX_COOP();
-
-    struct
-    {
-        OBJECTREF refFullTrust;
-    }
-    gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc);
-
-    gc.refFullTrust = Security::CreatePermissionSet(TRUE);
-    InheritanceDemand(pTargetAssembly, gc.refFullTrust);
-
-    GCPROTECT_END();
-}
-
-// Issue a FullTrust link demand against the target assembly
-
-// static
-void SecurityDeclarative::FullTrustLinkDemand(Assembly *pTargetAssembly)
-{
-    CONTRACTL
-    {
-        THROWS;
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-        PRECONDITION(CheckPointer(pTargetAssembly));
-    }
-    CONTRACTL_END;
-
-    struct
-    {
-        OBJECTREF refFullTrust;
-    }
-    gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc);
-
-    gc.refFullTrust = Security::CreatePermissionSet(TRUE);
-    IAssemblySecurityDescriptor *pTargetASD = pTargetAssembly->GetSecurityDescriptor();
-    SecurityStackWalk::LinkOrInheritanceCheck(pTargetASD,
-                                              gc.refFullTrust,
-                                              pTargetAssembly,
-                                              dclLinktimeCheck);
-    GCPROTECT_END();
-}
-
-// Used by interop to simulate the effect of link demands when the caller is
-// in fact script constrained by an appdomain setup by IE.
-void SecurityDeclarative::CheckLinkDemandAgainstAppDomain(MethodDesc *pMD)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM(););
-    } CONTRACTL_END;
-
-    if (!pMD->RequiresLinktimeCheck())
-        return;
-
-    // Find the outermost (closest to caller) appdomain. This
-    // represents the domain in which the unmanaged caller is
-    // considered to "live" (or, at least, be constrained by).
-    AppDomain *pDomain = GetThread()->GetInitialDomain();
-
-    // The link check is only performed if this app domain has
-    // security permissions associated with it, which will be
-    // the case for all IE scripting callers that have got this
-    // far because we automatically reported our managed classes
-    // as "safe for scripting".
-    // 
-    // We also can't do the check if the AppDomain isn't fully
-    // setup yet, since we might not have a domain grant set.
-    // This is acceptable, since the only code that should run
-    // during AppDomain creation is fully trusted.
-    IApplicationSecurityDescriptor *pSecDesc = pDomain->GetSecurityDescriptor();
-    if (pSecDesc == NULL || pSecDesc->IsInitializationInProgress() || pSecDesc->IsDefaultAppDomain())
-        return;
-
-    struct _gc
-    {
-        OBJECTREF refGrant;
-        OBJECTREF refRefused;
-        OBJECTREF refClassNonCasDemands;
-        OBJECTREF refClassCasDemands;
-        OBJECTREF refMethodNonCasDemands;
-        OBJECTREF refMethodCasDemands;
-        OBJECTREF refAssembly;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc);
-
-#ifdef FEATURE_APTCA
-    // Do a fulltrust check on the caller if the callee did not enable
-    // AllowUntrustedCallerChecks. Pass a NULL caller assembly:
-    // DoUntrustedCallerChecks needs to be able to cope with this.
-    SecurityDeclarative::DoUntrustedCallerChecks(NULL, pMD, TRUE);
-#endif // FEATURE_APTCA
-
-    // Fetch link demand sets from all the places in metadata where we might
-    // find them (class and method). These might be split into CAS and non-CAS
-    // sets as well.
-    SecurityDeclarative::RetrieveLinktimeDemands(pMD,
-                                      &gc.refClassCasDemands,
-                                      &gc.refClassNonCasDemands,
-                                      &gc.refMethodCasDemands,
-                                      &gc.refMethodNonCasDemands);
-
-    // Check CAS link demands.
-    bool fGotGrantSet = false;
-    if (gc.refClassCasDemands != NULL || gc.refMethodCasDemands != NULL)
-    {
-        // Get grant (and possibly denied) sets from the app
-        // domain.
-        gc.refGrant = pSecDesc->GetGrantedPermissionSet(NULL);
-        fGotGrantSet = true;
-        gc.refAssembly = pMD->GetAssembly()->GetExposedObject();
-
-        if (gc.refClassCasDemands != NULL)
-            SecurityStackWalk::CheckSetHelper(&gc.refClassCasDemands,
-                                                        &gc.refGrant,
-                                                        &gc.refRefused,
-                                                        pDomain,
-                                                        pMD,
-                                                        &gc.refAssembly,
-                                                        dclLinktimeCheck);
-
-        if (gc.refMethodCasDemands != NULL)
-            SecurityStackWalk::CheckSetHelper(&gc.refMethodCasDemands,
-                                                        &gc.refGrant,
-                                                        &gc.refRefused,
-                                                        pDomain,
-                                                        pMD,
-                                                        &gc.refAssembly,
-                                                        dclLinktimeCheck);
-
-    }
-
-    // Non-CAS demands are not applied against a grant
-    // set, they're standalone.
-    if (gc.refClassNonCasDemands != NULL)
-        CheckNonCasDemand(&gc.refClassNonCasDemands);
-
-    if (gc.refMethodNonCasDemands != NULL)
-        CheckNonCasDemand(&gc.refMethodNonCasDemands);
-
-#ifndef FEATURE_CORECLR   
-    // On CORECLR, we do this from the JIT callouts if the caller is transparent: if caller is critical, no checks needed
-
-    // We perform automatic linktime checks for UnmanagedCode in three cases:
-    //   o  P/Invoke calls (shouldn't get these here, but let's be paranoid).
-    //   o  Calls through an interface that have a suppress runtime check
-    //      attribute on them (these are almost certainly interop calls).
-    //   o  Interop calls made through method impls.
-    // Just walk the stack in these cases, they'll be extremely rare and the
-    // perf delta isn't that huge.
-    if (pMD->IsNDirect() ||
-        (pMD->IsInterface() &&
-         (pMD->GetMDImport()->GetCustomAttributeByName(pMD->GetMethodTable()->GetCl(),
-                                                      COR_SUPPRESS_UNMANAGED_CODE_CHECK_ATTRIBUTE_ANSI,
-                                                      NULL,
-                                                      NULL) == S_OK ||
-          pMD->GetMDImport()->GetCustomAttributeByName(pMD->GetMemberDef(),
-                                                      COR_SUPPRESS_UNMANAGED_CODE_CHECK_ATTRIBUTE_ANSI,
-                                                      NULL,
-                                                      NULL) == S_OK) ) ||
-        (pMD->IsComPlusCall() && !pMD->IsInterface()))
-        SecurityStackWalk::SpecialDemand(SSWT_LATEBOUND_LINKDEMAND, SECURITY_UNMANAGED_CODE);
-#endif // FEATURE_CORECLR
-
-    GCPROTECT_END();
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-//-----------------------------------------------------------------------------
-//
-//
-//     CODE FOR PERFORMING RUN-TIME CHECKS
-//
-//
-//-----------------------------------------------------------------------------
-
-void SecurityDeclarative::EnsureAssertAllowed(MethodDesc *pMeth, MethodSecurityDescriptor *pMSD)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM(););
-        PRECONDITION(CheckPointer(pMeth));
-        PRECONDITION(pMSD == NULL || pMSD->GetMethod() == pMeth);
-    } CONTRACTL_END;
-
-    // Check if this Assembly has permission to assert 
-    if (pMSD == NULL || !pMSD->CanAssert()) // early out if we have an MSD and we already have checked this permission
-    {
-        Module* pModule = pMeth->GetModule();
-        PREFIX_ASSUME_MSG(pModule != NULL, "Should be a Module pointer here");
-
-        if (!Security::CanAssert(pModule))
-            SecurityPolicy::ThrowSecurityException(g_SecurityPermissionClassName, SPFLAGSASSERTION);
-    }
-
-    // Check if the Method is allowed to assert based on transparent/critical classification
-    if (!SecurityTransparent::IsAllowedToAssert(pMeth) && Security::IsTransparencyEnforcementEnabled())
-    {
-#ifdef _DEBUG
-        if (g_pConfig->LogTransparencyErrors())
-        {
-            SecurityTransparent::LogTransparencyError(pMeth, "Transparent method using a security assert");
-        }
-#endif // _DEBUG
-        // if assembly is transparent fail the ASSERT operations
-        COMPlusThrow(kInvalidOperationException, W("InvalidOperation_AssertTransparentCode"));
-    }
-
-    return;
-}
-
-void SecurityDeclarative::InvokeDeclarativeActions (MethodDesc *pMeth, DeclActionInfo *pActions, MethodSecurityDescriptor *pMSD)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM(););
-    } CONTRACTL_END;
-
-    OBJECTREF       refPermSet = NULL;
-    ARG_SLOT           arg = 0;
-
-    // If we get a real PermissionSet, then invoke the action.
-    switch (pActions->dwDeclAction)
-    {
-    case DECLSEC_DEMANDS:
-        SecurityStackWalk::DemandSet(SSWT_DECLARATIVE_DEMAND, pActions->pPCE, dclDemand);
-        break;
-
-    case DECLSEC_ASSERTIONS:
-        EnsureAssertAllowed(pMeth, pMSD);
-        GetThread()->IncrementAssertCount();
-                break;
-
-    case DECLSEC_DENIALS:
-    case DECLSEC_PERMITONLY:
-        GetThread()->IncrementOverridesCount();
-        break;
-
-    case DECLSEC_NONCAS_DEMANDS:
-        refPermSet = pActions->pPCE->CreateManagedPsetObject (dclNonCasDemand);
-        if (refPermSet == NULL)
-            break;
-        if(!((PERMISSIONSETREF)refPermSet)->CheckedForNonCas() ||((PERMISSIONSETREF)refPermSet)->ContainsNonCas())
-        {
-            GCPROTECT_BEGIN(refPermSet);
-            MethodDescCallSite demand(METHOD__PERMISSION_SET__DEMAND_NON_CAS, &refPermSet);
-
-            arg = ObjToArgSlot(refPermSet);
-            demand.Call(&arg);
-            GCPROTECT_END();
-        }
-        break;
-
-    default:
-        _ASSERTE(!"Unknown action requested in InvokeDeclarativeActions");
-        break;
-
-    } // switch
-}
-
-
-//
-// CODE FOR PERFORMING RUN-TIME CHECKS
-//
-extern LPVOID GetSecurityObjectForFrameInternal(StackCrawlMark *stackMark, INT32 create, OBJECTREF *pRefSecDesc);    
-
-namespace 
-{
-    inline void UpdateFrameSecurityObj(DWORD dwAction, OBJECTREF *refPermSet, OBJECTREF * pSecObj)
-    {
-        CONTRACTL {
-            THROWS;
-            GC_TRIGGERS;
-            MODE_COOPERATIVE;
-            INJECT_FAULT(COMPlusThrowOM(););
-        } CONTRACTL_END;
-
-        GetSecurityObjectForFrameInternal(NULL, true, pSecObj);
-
-        FRAMESECDESCREF fsdRef = (FRAMESECDESCREF)*pSecObj;
-        switch (dwAction)
-        {
-        // currently we require declarative security to store the data in both the fields in the FSD
-            case dclAssert:
-                fsdRef->SetDeclarativeAssertions(*refPermSet);  
-                {
-                    PERMISSIONSETREF psRef = (PERMISSIONSETREF)*refPermSet;
-                    if (psRef != NULL && psRef->IsUnrestricted())
-                        fsdRef->SetAssertFT(TRUE);
-                }
-                break;
-
-            case dclDeny:
-                fsdRef->SetDeclarativeDenials(*refPermSet);
-                break;
-
-            case dclPermitOnly:            
-                fsdRef->SetDeclarativeRestrictions(*refPermSet);
-                break;
-
-            default:
-                _ASSERTE(0 && "Unreached, add code to handle if reached here...");
-                break;
-        }
-    }
-}
-
-void SecurityDeclarative::InvokeDeclarativeStackModifiers(MethodDesc * pMeth, DeclActionInfo * pActions, OBJECTREF * pSecObj)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM(););
-    } CONTRACTL_END;
-
-    OBJECTREF       refPermSet = NULL;
-
-    // If we get a real PermissionSet, then invoke the action.
-    switch (pActions->dwDeclAction)
-    {
-    case DECLSEC_DEMANDS:
-    case DECLSEC_NONCAS_DEMANDS:
-        // Nothing to do for demands
-        break;
-
-    case DECLSEC_ASSERTIONS:
-        refPermSet = pActions->pPCE->CreateManagedPsetObject (dclAssert);
-        if (refPermSet == NULL)
-            break;
-        GCPROTECT_BEGIN(refPermSet);
-        // Now update the frame security object
-        UpdateFrameSecurityObj(dclAssert, &refPermSet, pSecObj);
-        GCPROTECT_END();
-        break;
-
-    case DECLSEC_DENIALS:
-        // Update the frame security object
-        refPermSet = pActions->pPCE->CreateManagedPsetObject (dclDeny);
- 
-        if (refPermSet == NULL)
-            break;
-
-        GCPROTECT_BEGIN(refPermSet);
-
-#ifdef FEATURE_CAS_POLICY
-        // Deny is only valid if we're in legacy CAS mode
-        IApplicationSecurityDescriptor *pSecDesc = GetAppDomain()->GetSecurityDescriptor();
-        if (!pSecDesc->IsLegacyCasPolicyEnabled())
-        {
-            COMPlusThrow(kNotSupportedException, W("NotSupported_CasDeny"));
-        }
-#endif // FEATURE_CAS_POLICY
-
-        UpdateFrameSecurityObj(dclDeny, &refPermSet, pSecObj);
-
-        GCPROTECT_END();
-        break;
-
-    case DECLSEC_PERMITONLY:
-        // Update the frame security object
-        refPermSet = pActions->pPCE->CreateManagedPsetObject (dclPermitOnly);
-
-        if (refPermSet == NULL)
-            break;
-        GCPROTECT_BEGIN(refPermSet);
-        UpdateFrameSecurityObj(dclPermitOnly, &refPermSet, pSecObj);
-        GCPROTECT_END();
-        break;
-
-
-    default:
-        _ASSERTE(!"Unknown action requested in InvokeDeclarativeStackModifiers");
-        break;
-
-    } // switch
-}
-
-void SecurityDeclarative::DoDeclarativeActions(MethodDesc *pMeth, DeclActionInfo *pActions, LPVOID pSecObj, MethodSecurityDescriptor *pMSD)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM(););
-    } CONTRACTL_END;
-
-#ifndef FEATURE_CAS_POLICY
-    // In the CoreCLR, we don't support CAS actions outside mscorlib.
-    // However, we do have to expose certain types in mscorlib due to compiler requirements 
-    // (c# compiler requires us to expose SecurityPermission/SecurityAction etc so that it can
-    // insert a RequestMinimum for SkipVerification).
-    // This means that code outside mscorlib could construct IL that has declarative security
-    // in it. This is not a security issue - even if they try to create IL that asserts for
-    // permissions they don't have, it's not going to work for the same reasons it didn't in the desktop.
-    // However, we could have bugs like DDB 120109 where they can cause Demands to fail etc.
-    // So for goodness, we're not going to do any runtime declarative work on assemblies other than mscorlib.
-    if (!pMeth->GetModule()->IsSystem())
-    {
-        // Non-mscorlib code reached... exit
-        return;
-    }
-#endif //!FEATURE_CAS_POLICY
-    
-
-    // --------------------------------------------------------------------------- //
-    //          D E C L A R A T I V E   S E C U R I T Y   D E M A N D S            //
-    // --------------------------------------------------------------------------- //
-    // The frame is now fully formed, arguments have been copied into place,
-    // and synchronization monitors have been entered if necessary.  At this
-    // point, we are prepared for something to throw an exception, so we may
-    // check for declarative security demands and execute them.  We need a
-    // well-formed frame and synchronization domain to accept security excep-
-    // tions thrown by the SecurityManager.  We MAY need argument values in
-    // the frame so that the arguments may be finalized if security throws an
-    // exception across them (unknown).  
-    if (pActions != NULL && pActions->dwDeclAction == DECLSEC_UNMNGD_ACCESS_DEMAND &&
-        pActions->pNext == NULL)
-    {
-        /* We special-case the security check on single pinvoke/interop calls
-           so we can avoid setting up the GCFrame */
-
-        SecurityStackWalk::SpecialDemand(SSWT_DECLARATIVE_DEMAND, SECURITY_UNMANAGED_CODE);
-        return;
-    }
-    else
-    {
-#ifdef FEATURE_COMPRESSEDSTACK
-        // If this is an anonymously hosted dynamic method, there aren't any direct modifiers, but if it has a compressed stack that
-        // might have modifiers, mark that there are modifiers so we make sure to do a stack walk
-        if(SecurityStackWalk::MethodIsAnonymouslyHostedDynamicMethodWithCSToEvaluate(pMeth)) 
-        {
-            // We don't know how many asserts or overrides might be in the compressed stack,
-            // but we just need to increment the counters to ensure optimizations don't skip CS evaluation
-            GetThread()->IncrementAssertCount();
-            GetThread()->IncrementOverridesCount();
-        }
-#endif // FEATURE_COMPRESSEDSTACK
-
-        for (/**/; pActions; pActions = pActions->pNext)
-        {
-            if (pActions->dwDeclAction == DECLSEC_UNMNGD_ACCESS_DEMAND)
-            {
-                SecurityStackWalk::SpecialDemand(SSWT_DECLARATIVE_DEMAND, SECURITY_UNMANAGED_CODE);
-            }
-            else
-            {
-                InvokeDeclarativeActions(pMeth, pActions, pMSD);
-            }
-        }
-
-    }
-}
-void SecurityDeclarative::DoDeclarativeStackModifiers(MethodDesc *pMeth, AppDomain* pAppDomain, LPVOID pSecObj)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM(););
-    } CONTRACTL_END;
-
-#ifndef FEATURE_CAS_POLICY
-    // In the CoreCLR, we don't support CAS actions outside mscorlib.
-    // However, we do have to expose certain types in mscorlib due to compiler requirements 
-    // (c# compiler requires us to expose SecurityPermission/SecurityAction etc so that it can
-    // insert a RequestMinimum for SkipVerification).
-    // This means that code outside mscorlib could construct IL that has declarative security
-    // in it. This is not a security issue - even if they try to create IL that asserts for
-    // permissions they don't have, it's not going to work for the same reasons it didn't in the desktop.
-    // However, we could have bugs like DDB 120109 where they can cause Demands to fail etc.
-    // So for goodness, we're not going to do any runtime declarative work on assemblies other than mscorlib.
-    if (!pMeth->GetModule()->IsSystem())
-    {
-        // Non-mscorlib code reached... exit
-        return;
-    }
-#endif //!FEATURE_CAS_POLICY
-        
-    
-    AppDomain* pCurrentDomain = GetAppDomain();
-    
-    if (pCurrentDomain != pAppDomain)
-    {
-        ENTER_DOMAIN_PTR(pAppDomain, ADV_RUNNINGIN)
-        {
-            DoDeclarativeStackModifiersInternal(pMeth, pSecObj);
-        }
-        END_DOMAIN_TRANSITION;
-    }
-    else
-    {
-        DoDeclarativeStackModifiersInternal(pMeth, pSecObj);
-            }
-        }
-
-void SecurityDeclarative::DoDeclarativeStackModifiersInternal(MethodDesc *pMeth, LPVOID pSecObj)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM(););
-    } CONTRACTL_END;
-
-    Object** ppSecObject = (Object**) pSecObj;
-    _ASSERTE(pMeth->IsInterceptedForDeclSecurity() && !pMeth->IsInterceptedForDeclSecurityCASDemandsOnly());
-
-    MethodSecurityDescriptor MDSecDesc(pMeth);
-    MethodSecurityDescriptor::LookupOrCreateMethodSecurityDescriptor(&MDSecDesc);
-    DeclActionInfo* pActions = MDSecDesc.GetRuntimeDeclActionInfo();
-
-    OBJECTREF fsdRef = ObjectToOBJECTREF(*ppSecObject);
-    GCPROTECT_BEGIN(fsdRef);
-
-    for (/**/; pActions; pActions = pActions->pNext)
-    {
-        InvokeDeclarativeStackModifiers(pMeth, pActions, &fsdRef);
-    }
-    // If we had just NON-CAS demands, we'd come here but not create an FSD.
-    if (fsdRef != NULL)
-    {
-        ((FRAMESECDESCREF)(fsdRef))->SetDeclSecComputed(TRUE);
-
-        if (*ppSecObject == NULL)
-        {
-            // we came in with a NULL FSD and the FSD got created here...so we need to copy it back
-            // If we had come in with a non-NULL FSD, that would have been updated and this (shallow/pointer) copy
-            // would not be necessary
-            *ppSecObject = OBJECTREFToObject(fsdRef);
-    }
-}
-
-    GCPROTECT_END();
-}
-
-
-void SecurityDeclarative::CheckNonCasDemand(OBJECTREF *prefDemand)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(IsProtectedByGCFrame (prefDemand));
-    } CONTRACTL_END;
-
-    if(((PERMISSIONSETREF)*prefDemand)->CheckedForNonCas())
-    {
-        if(!((PERMISSIONSETREF)*prefDemand)->ContainsNonCas())
-            return;
-    }
-    MethodDescCallSite demand(METHOD__PERMISSION_SET__DEMAND_NON_CAS, prefDemand);
-    ARG_SLOT arg = ObjToArgSlot(*prefDemand);
-    demand.Call(&arg);
-}
-
-#endif // FEATURE_CAS_POLICY
 
 #endif // CROSSGEN_COMPILE
diff --git a/src/vm/securitydeclarative.h b/src/vm/securitydeclarative.h
index 625e6840b9..9874148326 100644
--- a/src/vm/securitydeclarative.h
+++ b/src/vm/securitydeclarative.h
@@ -42,9 +42,6 @@ inline LinktimeCheckReason operator&=(LinktimeCheckReason &lhs, LinktimeCheckRea
 
 namespace SecurityDeclarative
 {
-    // Returns an instance of a well-known permission.  (It caches them, so each permission is created only once.)
-    void _GetSharedPermissionInstance(OBJECTREF *perm, int index);
-
     // Perform the declarative actions
     //   Callers:
     //     DoDeclarativeSecurity
@@ -129,20 +126,6 @@ namespace SecurityDeclarative
     inline BOOL FullTrustCheckForLinkOrInheritanceDemand(Assembly *pAssembly);
 
 
-#ifdef FEATURE_APTCA
-    // Returns TRUE if an APTCA check is necessary
-    //   Callers:
-    //     CanAccess
-    BOOL IsUntrustedCallerCheckNeeded(MethodDesc *pCalleeMD, Assembly *pCallerAssem = NULL);
-
-    // Perform the APTCA check
-    //   Callers:
-    //     CanAccess
-    //     Security::CheckLinkDemandAgainstAppDomain
-    void DoUntrustedCallerChecks(
-        Assembly *pCaller, MethodDesc *pCalee,
-        BOOL fFullStackWalk);
-#endif // FEATURE_APTCA
 
 #ifndef DACCESS_COMPILE
     // Calls PermissionSet.Demand
@@ -169,15 +152,6 @@ namespace SecurityDeclarative
 
     inline BOOL ClassIsVisibleOutsideItsAssembly(DWORD dwClassAttr, BOOL fIsGlobalClass);
 
-#ifdef FEATURE_APTCA
-    // Returns an instance of a SecurityException with the message "This method doesn't allow partially trusted callers"
-    //   Callers:
-    //     DoUntrustedCallerChecks
-    void DECLSPEC_NORETURN ThrowAPTCAException(Assembly *pCaller, MethodDesc *pCallee);
-#endif // FEATURE_APTCA
-#ifdef FEATURE_CAS_POLICY
-    void DECLSPEC_NORETURN ThrowHPException(EApiCategories protectedCategories, EApiCategories demandedCategories);
-#endif // FEATURE_CAS_POLICY
 
     // Add a declarative action and PermissionSet index to the linked list
     void AddDeclAction(CorDeclSecurity action, PsetCacheEntry *pClassPCE, PsetCacheEntry *pMethodPCE, DeclActionInfo** ppActionList, MethodDesc *pMeth);
diff --git a/src/vm/securitydeclarative.inl b/src/vm/securitydeclarative.inl
index f4034bfb15..1d14c9886f 100644
--- a/src/vm/securitydeclarative.inl
+++ b/src/vm/securitydeclarative.inl
@@ -38,12 +38,6 @@ inline LinktimeCheckReason operator&=(LinktimeCheckReason &lhs, LinktimeCheckRea
     return lhs;
 }
 
-inline void SecurityDeclarative::GetPermissionInstance(OBJECTREF *perm, int index)
-{ 
-    WRAPPER_NO_CONTRACT;
-    _GetSharedPermissionInstance(perm, index);
-}
-
 inline BOOL SecurityDeclarative::FullTrustCheckForLinkOrInheritanceDemand(Assembly *pAssembly)
 {
     WRAPPER_NO_CONTRACT;
diff --git a/src/vm/securitydeclarativecache.cpp b/src/vm/securitydeclarativecache.cpp
index dcfc1e0c4d..202c016459 100644
--- a/src/vm/securitydeclarativecache.cpp
+++ b/src/vm/securitydeclarativecache.cpp
@@ -75,65 +75,7 @@ OBJECTREF PsetCacheEntry::CreateManagedPsetObject(DWORD dwAction, bool createEmp
         MODE_COOPERATIVE;
     } CONTRACTL_END;
 
-#ifdef FEATURE_CAS_POLICY
-    OBJECTREF orRet;
-
-    orRet = GetManagedPsetObject();
-    if (orRet != NULL) {
-        return orRet;
-    }
-
-    if (!createEmptySet && m_fEmptyPermissionSet) {
-        return NULL;
-    }
-
-    struct _gc {
-        OBJECTREF pset;
-        OBJECTREF encoding;
-        OBJECTREF nonCasPset;
-        OBJECTREF orNonCasPset;
-        OBJECTREF orNonCasEncoding;
-    } gc;
-    memset(&gc, 0, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc);
-
-    if ( (m_pKey->m_cbPset > 0) && (m_pKey->m_pbPset[0] == LAZY_DECL_SEC_FLAG) ) {
-
-        SecurityAttributes::AttrSetBlobToPermissionSets(m_pKey->m_pbPset, 
-                                                        m_pKey->m_cbPset, 
-                                                        &gc.pset, 
-                                                        dwAction);
-        
-    } else {
-
-        SecurityAttributes::XmlToPermissionSet(m_pKey->m_pbPset,
-                                               m_pKey->m_cbPset,  
-                                               &gc.pset, 
-                                               &gc.encoding, 
-                                               NULL, 
-                                               0, 
-                                               &gc.orNonCasPset, 
-                                               &gc.orNonCasEncoding);
-    }
-
-    StoreFirstObjectInHandle(m_handle, gc.pset);
-
-    if (gc.pset == NULL)
-        m_fEmptyPermissionSet = true;
-
-    GCPROTECT_END();
-    
-    //
-    // Some other thread may have won the race, and stored away a different
-    // object in the handle.
-    //
-
-    orRet = GetManagedPsetObject();
-    return orRet;
-#else
     return NULL;
-#endif
 }
 #endif // CROSSGEN_COMPILE
 
diff --git a/src/vm/securitydescriptor.cpp b/src/vm/securitydescriptor.cpp
index a91022fa67..2ff1823bb5 100644
--- a/src/vm/securitydescriptor.cpp
+++ b/src/vm/securitydescriptor.cpp
@@ -56,65 +56,9 @@ OBJECTREF SecurityDescriptor::GetGrantedPermissionSet(OBJECTREF* pRefusedPermiss
 //
 // Returns TRUE if the given zone has the given special permission.
 //
-#ifdef FEATURE_CAS_POLICY
-BOOL SecurityDescriptor::CheckQuickCache(SecurityConfig::QuickCacheEntryType all, DWORD dwZone)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(m_pAppDomain->GetSecurityDescriptor()->IsLegacyCasPolicyEnabled());
-        PRECONDITION(SecurityPolicy::s_fPolicyInitialized);
-    } CONTRACTL_END;
-
-    static const SecurityConfig::QuickCacheEntryType zoneTable[] =
-    {
-        SecurityConfig::FullTrustZoneMyComputer,
-        SecurityConfig::FullTrustZoneIntranet,
-        SecurityConfig::FullTrustZoneTrusted,
-        SecurityConfig::FullTrustZoneInternet,
-        SecurityConfig::FullTrustZoneUntrusted
-    };
-
-    // If an additional evidence was provided, then perform the normal
-    // policy resolution. This is true for all AppDomains and also for
-    // assemblies loaded with a specific additional evidence. Note that
-    // for the default AppDomain, the policy resolution code paths short
-    // circuits the parsing of the security XML files by granting FullTrust
-    // to the default AppDomain.
-
-    if (m_hAdditionalEvidence != NULL)
-        return FALSE;
-
-    BOOL fMachine = SecurityConfig::GetQuickCacheEntry(SecurityConfig::MachinePolicyLevel, all);
-    BOOL fUser = SecurityConfig::GetQuickCacheEntry(SecurityConfig::UserPolicyLevel, all);
-    BOOL fEnterprise = SecurityConfig::GetQuickCacheEntry(SecurityConfig::EnterprisePolicyLevel, all);
-
-    if (fMachine && fUser && fEnterprise)
-        return TRUE;
-
-    // If we can't match for all, try for our zone.
-    if (dwZone == 0xFFFFFFFF)
-        return FALSE;
-
-    fMachine = SecurityConfig::GetQuickCacheEntry(SecurityConfig::MachinePolicyLevel, zoneTable[dwZone]);
-    fUser = SecurityConfig::GetQuickCacheEntry(SecurityConfig::UserPolicyLevel, zoneTable[dwZone]);
-    fEnterprise = SecurityConfig::GetQuickCacheEntry(SecurityConfig::EnterprisePolicyLevel, zoneTable[dwZone]);
-
-    return (fMachine && fUser && fEnterprise);
-}
-#endif // FEATURE_CAS_POLICY
 
 #endif // DACCESS_COMPILE
 
-#ifdef FEATURE_CAS_POLICY
-BOOL SecurityDescriptor::IsEvidenceComputed() const
-{
-    LIMITED_METHOD_CONTRACT;
-    return m_fEvidenceComputed;
-}
-#endif //FEATURE_CAS_POLICY
 
 //
 // This method will return TRUE if this object is fully trusted.
@@ -179,25 +123,6 @@ void SecurityDescriptor::SetGrantedPermissionSet(OBJECTREF GrantedPermissionSet,
 }
 
 
-#ifdef FEATURE_CAS_POLICY
-void SecurityDescriptor::SetEvidence(OBJECTREF evidence)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(evidence != NULL);
-    }
-    CONTRACTL_END;
-
-    if (evidence != NULL)
-    {
-        StoreObjectInLazyHandle(m_hAdditionalEvidence, evidence, m_pLoaderAllocator);
-        SetEvidenceComputed();
-    }
-}
-#endif // FEATURE_CAS_POLICY
 #endif // !DACCESS_COMPILE
 
 AppDomain* SecurityDescriptor::GetDomain() const
@@ -208,271 +133,6 @@ AppDomain* SecurityDescriptor::GetDomain() const
 
 #ifndef DACCESS_COMPILE
 
-#ifdef FEATURE_CAS_POLICY
-
-//---------------------------------------------------------------------------------------
-//
-// Build an evidence collection which can generate evidence about a PEFile
-//
-// Arguments:
-//    pPEFile                 - PEFile the evidence collection will generate evidence for
-//    objHostSuppliedEvidence - additional evidence to merge into the collection supplied by the host
-//
-// Return Value:
-//    Evidence collection which targets this PEFile
-//
-// Notes:
-//    Calls System.Security.Policy.PEFileEvidenceFactory.CreateSecurityIdentity
-//
-
-// static
-OBJECTREF PEFileSecurityDescriptor::BuildEvidence(PEFile *pPEFile, const OBJECTREF& objHostSuppliedEvidence)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(CheckPointer(pPEFile));
-    }
-    CONTRACTL_END;
-
-    struct
-    {
-        SAFEHANDLE objPEFile;
-        OBJECTREF objHostSuppliedEvidence;
-        OBJECTREF objEvidence;
-    }
-    gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc);
-    BEGIN_SO_INTOLERANT_CODE(GetThread());
-
-    gc.objPEFile = pPEFile->GetSafeHandle();
-    gc.objHostSuppliedEvidence = objHostSuppliedEvidence;
-
-    MethodDescCallSite createSecurityIdentity(METHOD__PEFILE_EVIDENCE_FACTORY__CREATE_SECURITY_IDENTITY);
-
-    ARG_SLOT args[] =
-    {
-        ObjToArgSlot(gc.objPEFile),
-        ObjToArgSlot(gc.objHostSuppliedEvidence)
-    };
-
-    gc.objEvidence = createSecurityIdentity.Call_RetOBJECTREF(args);
-
-    END_SO_INTOLERANT_CODE;
-    GCPROTECT_END();
-
-    return gc.objEvidence;
-}
-
-#endif // FEATURE_CAS_POLICY
-
-#ifndef FEATURE_CORECLR
-BOOL PEFileSecurityDescriptor::QuickIsFullyTrusted()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-#ifdef CROSSGEN_COMPILE
-    return TRUE;
-#else
-    if (!m_pAppDomain->GetSecurityDescriptor()->IsLegacyCasPolicyEnabled())
-    {
-        return TRUE;
-    }
-    else if (m_pAppDomain->IsCompilationDomain())
-    {
-        return TRUE;
-    }
-    else
-    {
-        return CheckQuickCache(SecurityConfig::FullTrustAll, GetZone());
-    }
-#endif
-}
-
-#ifndef CROSSGEN_COMPILE
-//---------------------------------------------------------------------------------------
-//
-// Get the evidence for this PE file
-//
-
-OBJECTREF PEFileSecurityDescriptor::GetEvidence()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(m_pAppDomain == GetAppDomain());
-        INJECT_FAULT(COMPlusThrowOM());
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    // If we already have evidence, then just return that
-    if (IsEvidenceComputed())
-        return ObjectFromLazyHandle(m_hAdditionalEvidence, m_pLoaderAllocator);
-
-    struct
-    {
-        OBJECTREF objHostProvidedEvidence;
-        OBJECTREF objEvidence;
-    }
-    gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc);
-    BEGIN_SO_INTOLERANT_CODE(GetThread());
-
-#if CHECK_APP_DOMAIN_LEAKS
-    if (g_pConfig->AppDomainLeaks())
-        _ASSERTE(gc.objHostProvidedEvidence == NULL || GetAppDomain() == gc.objHostProvidedEvidence->GetAppDomain());
-#endif // CHECK_APP_DOMAIN_LEAKS
-
-    gc.objHostProvidedEvidence = ObjectFromLazyHandle(m_hAdditionalEvidence, m_pLoaderAllocator);
-    gc.objEvidence = PEFileSecurityDescriptor::BuildEvidence(m_pPEFile, gc.objHostProvidedEvidence);
-    SetEvidence(gc.objEvidence);
-
-#if CHECK_APP_DOMAIN_LEAKS
-    if (g_pConfig->AppDomainLeaks())
-        _ASSERTE(gc.objEvidence == NULL || GetAppDomain() == gc.objEvidence->GetAppDomain());
-#endif // CHECK_APP_DOMAIN_LEAKS
-
-    END_SO_INTOLERANT_CODE;
-
-    GCPROTECT_END();
-
-    return gc.objEvidence;
-}
-
-DWORD PEFileSecurityDescriptor::GetZone()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-        PRECONDITION(m_pAppDomain->GetSecurityDescriptor()->IsLegacyCasPolicyEnabled());
-    }
-    CONTRACTL_END;
-
-    SecZone       dwZone = NoZone;
-    BEGIN_SO_INTOLERANT_CODE(GetThread());
-
-    StackSString    codebase;
-    BYTE        rbUniqueID[MAX_SIZE_SECURITY_ID];
-    DWORD       cbUniqueID = sizeof(rbUniqueID);
-
-    m_pPEFile->GetSecurityIdentity(codebase, &dwZone, 0, rbUniqueID, &cbUniqueID);
-    END_SO_INTOLERANT_CODE;
-    return dwZone;
-}
-#endif // !CROSSGEN_COMPILE
-
-void PEFileSecurityDescriptor::Resolve()
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM(););
-    } CONTRACTL_END;
-
-    if (IsResolved())
-        return;
-    ResolveWorker();
-}
-
-void PEFileSecurityDescriptor::ResolveWorker()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    if (NingenEnabled()) {
-        SetGrantedPermissionSet(NULL, NULL, 0xFFFFFFFF);
-    }
-
-#ifndef CROSSGEN_COMPILE
-    struct _gc
-    {
-        OBJECTREF evidence;         // Object containing evidence
-        OBJECTREF granted;          // Policy based Granted Permission
-        OBJECTREF grantdenied;      // Policy based explicitly Denied Permissions
-    }
-    gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc);
-
-    DWORD dwSpecialFlags = 0;
-    if (QuickIsFullyTrusted())
-    {
-        Security::GetPermissionInstance(&gc.granted, SECURITY_FULL_TRUST);
-        dwSpecialFlags = 0xFFFFFFFF;
-    }
-    else
-    {
-        if (IsEvidenceComputed())
-        {
-            gc.evidence = ObjectFromLazyHandle(m_hAdditionalEvidence, m_pLoaderAllocator);
-        }
-        else
-        {
-            gc.evidence = GetEvidence();
-        }
-
-        if (!m_pAppDomain->GetSecurityDescriptor()->IsLegacyCasPolicyEnabled())
-        {
-            gc.granted = SecurityPolicy::ResolveGrantSet(gc.evidence, &dwSpecialFlags, FALSE);
-        }
-        else
-        {
-            gc.granted = SecurityPolicy::ResolveCasPolicy(gc.evidence,
-                                                          NULL,
-                                                          NULL,
-                                                          NULL,
-                                                          &gc.grantdenied,
-                                                          &dwSpecialFlags,
-                                                          FALSE);
-        }
-    }
-
-    SetGrantedPermissionSet(gc.granted, NULL, dwSpecialFlags);
-
-    GCPROTECT_END();
-#endif // CROSSGEN_COMPILE
-}
-
-BOOL PEFileSecurityDescriptor::AllowBindingRedirects()
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(IsResolved());
-    } CONTRACTL_END;
-
-    ETWOnStartup (AllowBindingRedirs_V1, AllowBindingRedirsEnd_V1);
-
-    return CheckSpecialFlag(1 << SECURITY_BINDING_REDIRECTS);
-}
 
-#endif // FEATURE_CORECLR
 
 #endif // !DACCESS_COMPILE
diff --git a/src/vm/securitydescriptor.h b/src/vm/securitydescriptor.h
index 06c096f4ee..eb1c287b4b 100644
--- a/src/vm/securitydescriptor.h
+++ b/src/vm/securitydescriptor.h
@@ -9,7 +9,6 @@
 #ifndef __SECURITYDESCRIPTOR_H__
 #define __SECURITYDESCRIPTOR_H__
 
-#include "securityconfig.h"
 #include "securityattributes.h"
 #include "securitypolicy.h"
 
@@ -68,9 +67,6 @@ inline void StoreObjectInLazyHandle(LOADERHANDLE& handle, OBJECTREF ref, LoaderA
 class SecurityDescriptor
 {
 protected:
-#ifdef FEATURE_CAS_POLICY
-    LOADERHANDLE m_hAdditionalEvidence;     // Evidence Object
-#endif // FEATURE_CAS_POLICY
 
     // The unmanaged DomainAssembly object
     DomainAssembly     *m_pAssem;
@@ -82,9 +78,6 @@ protected:
     AppDomain*   m_pAppDomain;
 
     BOOL         m_fSDResolved;
-#ifdef FEATURE_CAS_POLICY
-    BOOL         m_fEvidenceComputed;
-#endif // FEATURE_CAS_POLICY
 
     DWORD        m_dwSpecialFlags;
     LoaderAllocator *m_pLoaderAllocator;
@@ -102,15 +95,6 @@ public:
     AppDomain* GetDomain() const;
     BOOL CanCallUnmanagedCode() const;
 	
-#ifdef FEATURE_CAS_POLICY
-
-#ifndef DACCESS_COMPILE
-    void SetEvidence(OBJECTREF evidence);
-    BOOL CheckQuickCache(SecurityConfig::QuickCacheEntryType all, DWORD dwZone);
-#endif // FEATURE_CAS_POLICY
-    BOOL IsEvidenceComputed() const;
-    inline void SetEvidenceComputed();
-#endif // FEATURE_CAS_POLICY
 
 #ifndef DACCESS_COMPILE
     void SetGrantedPermissionSet(OBJECTREF GrantedPermissionSet,
@@ -156,44 +140,12 @@ public:
 
     virtual BOOL IsResolved() const { return SecurityDescriptor::IsResolved(); }
 
-#ifdef FEATURE_CAS_POLICY
-    virtual BOOL IsEvidenceComputed() const { return SecurityDescriptor::IsEvidenceComputed(); }
-#ifndef DACCESS_COMPILE
-    virtual void SetEvidence(OBJECTREF evidence) { SecurityDescriptor::SetEvidence(evidence); }
-#endif // DACCESS_COMPILE
-#endif // FEATURE_CAS_POLICY
 
 #ifndef DACCESS_COMPILE
     virtual OBJECTREF GetGrantedPermissionSet(OBJECTREF* RefusedPermissions = NULL) { return SecurityDescriptor::GetGrantedPermissionSet(RefusedPermissions); }
 #endif
 };
 
-#ifndef FEATURE_CORECLR
-class PEFileSecurityDescriptor : public SecurityDescriptorBase<IPEFileSecurityDescriptor>
-{
-public:
-	virtual BOOL AllowBindingRedirects();
-    BOOL QuickIsFullyTrusted();
-    virtual VOID Resolve();
-
-#ifndef DACCESS_COMPILE
-    inline PEFileSecurityDescriptor(AppDomain* pDomain, PEFile *pPEFile);
-#endif
-	
-#ifdef FEATURE_CAS_POLICY
-    virtual OBJECTREF GetEvidence();
-    DWORD GetZone();
-#endif // FEATURE_CAS_POLICY
-    
-
-#ifdef FEATURE_CAS_POLICY
-    static
-    OBJECTREF BuildEvidence(PEFile *pPEFile, const OBJECTREF& objHostSuppliedEvidence);
-#endif // FEATURE_CAS_POLICY
-private:
-	VOID ResolveWorker();
-};
-#endif // !FEATURE_CORECLR
 
 #include "securitydescriptor.inl"
 
diff --git a/src/vm/securitydescriptor.inl b/src/vm/securitydescriptor.inl
index 8d571f9fa1..f894831db6 100644
--- a/src/vm/securitydescriptor.inl
+++ b/src/vm/securitydescriptor.inl
@@ -38,16 +38,10 @@ inline SecurityDescriptor::SecurityDescriptor(AppDomain *pAppDomain,
                                               DomainAssembly *pAssembly,
                                               PEFile* pPEFile,
                                               LoaderAllocator *pLoaderAllocator) :
-#ifdef FEATURE_CAS_POLICY
-    m_hAdditionalEvidence(NULL),
-#endif // FEATURE_CAS_POLICY
     m_pAssem(pAssembly),
     m_pPEFile(pPEFile),
     m_pAppDomain(pAppDomain),
     m_fSDResolved(FALSE),
-#ifdef FEATURE_CAS_POLICY
-    m_fEvidenceComputed(FALSE),
-#endif // FEATURE_CAS_POLICY
     m_dwSpecialFlags(0),
     m_pLoaderAllocator(pLoaderAllocator)
 #ifndef CROSSGEN_COMPILE
@@ -59,14 +53,6 @@ inline SecurityDescriptor::SecurityDescriptor(AppDomain *pAppDomain,
 }
 #endif // !DACCESS_COMPILE
 
-#ifdef FEATURE_CAS_POLICY
-inline void SecurityDescriptor::SetEvidenceComputed()
-{
-    LIMITED_METHOD_CONTRACT;
-    m_fEvidenceComputed = TRUE;
-}
-
-#endif // FEATURE_CAS_POLICY
 
 // Checks for one of the special security flags such as FullTrust or UnmanagedCode
 FORCEINLINE BOOL SecurityDescriptor::CheckSpecialFlag (DWORD flags) const
@@ -94,16 +80,5 @@ inline SecurityDescriptorBase<IT>::SecurityDescriptorBase(AppDomain *pAppDomain,
 }
 #endif // !DACCESS_COMPILE
 
-#ifndef FEATURE_CORECLR
-
-#ifndef DACCESS_COMPILE
-inline PEFileSecurityDescriptor::PEFileSecurityDescriptor(AppDomain* pDomain, PEFile *pPEFile) :
-    SecurityDescriptorBase<IPEFileSecurityDescriptor>(pDomain, NULL,pPEFile, pDomain->GetLoaderAllocator())
-{
-    LIMITED_METHOD_CONTRACT
-}
-#endif // !DACCESS_COMPILE
-
-#endif // !FEATURE_CORECLR
 
 #endif // #define __SECURITYDESCRIPTOR_INL__
diff --git a/src/vm/securitydescriptorappdomain.cpp b/src/vm/securitydescriptorappdomain.cpp
index bf51d1d39b..e50db588f0 100644
--- a/src/vm/securitydescriptorappdomain.cpp
+++ b/src/vm/securitydescriptorappdomain.cpp
@@ -16,83 +16,6 @@
 
 #ifndef DACCESS_COMPILE
 
-#ifndef FEATURE_CORECLR
-BOOL ApplicationSecurityDescriptor::QuickIsFullyTrusted()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-
-#ifdef CROSSGEN_COMPILE
-    return TRUE;
-#else
-    if (IsDefaultAppDomain())
-    {
-        return TRUE;
-    }
-
-    // NGEN is always done in full trust
-    if (m_pAppDomain->IsCompilationDomain())
-    {
-        return TRUE;
-    }
-
-    // Check if we need to call the HostSecurityManager.
-    if (CallHostSecurityManager())
-    {
-        return FALSE;
-    }
-
-    APPDOMAINREF adRef = static_cast<APPDOMAINREF>(m_pAppDomain->GetExposedObject());
-
-    // - If this AppDomain is a standard domain (full trust homogeneous), we are full trust
-    // - If this is a homogeneous case, get the PermissionSet from managed code
-    // - If CAS policy is not enabled, then we are fully trusted
-    // - Otherwise, check the quick cache
-    if (adRef->GetIsFastFullTrustDomain())
-    {
-        return TRUE;
-    }
-    else if (IsHomogeneous())
-    {
-        // A homogenous domain will be fully trusted if its grant set is full trust
-        APPLICATIONTRUSTREF appTrustRef = static_cast<APPLICATIONTRUSTREF>(adRef->GetApplicationTrust());
-        POLICYSTATEMENTREF psRef = static_cast<POLICYSTATEMENTREF>(appTrustRef->GetPolicyStatement());
-        PERMISSIONSETREF grantSetRef = psRef->GetPermissionSet();
-        return grantSetRef->IsUnrestricted();
-    }
-    else if (!IsLegacyCasPolicyEnabled())
-    {
-        return TRUE;
-    }
-    else
-    {
-        return CheckQuickCache(SecurityConfig::FullTrustAll, GetZone());
-    }
-#endif // CROSSGEN_COMPILE
-}
-#endif // FEATURE_CORECLR
-
-#ifdef FEATURE_CAS_POLICY
-OBJECTREF ApplicationSecurityDescriptor::GetEvidence()
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(m_pAppDomain == GetAppDomain());
-        INJECT_FAULT(COMPlusThrowOM(););
-    } CONTRACTL_END;
-
-    OBJECTREF retval = ObjectFromLazyHandle(m_hAdditionalEvidence, m_pLoaderAllocator);
-    return retval;
-}
-#endif // FEATURE_CAS_POLICY
-
 void ApplicationSecurityDescriptor::Resolve()
 {
     CONTRACTL {
@@ -106,200 +29,10 @@ void ApplicationSecurityDescriptor::Resolve()
     if (IsResolved())
         return;
 
-#ifndef CROSSGEN_COMPILE
-    ResolveWorker();
-#else
     SetGrantedPermissionSet(NULL, NULL, 0xFFFFFFFF);
-#endif
 }
 
 #ifndef CROSSGEN_COMPILE
-void ApplicationSecurityDescriptor::ResolveWorker()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM(););
-    } CONTRACTL_END;
-
-    struct _gc
-    {
-        OBJECTREF evidence;         // Object containing evidence
-        OBJECTREF granted;          // Policy based Granted Permission
-        OBJECTREF grantdenied;      // Policy based explicitly Denied Permissions
-    }
-    gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc);
-    DWORD dwSpecialFlags;
-
-    // On debug builds do a pre-resolution so that we can validate pre-resolve and post-resolve match up
-    // assuming no host interference.
-#ifdef _DEBUG
-    // We shouldn't be causing the first pre-resolution if we needed to cache this state for the host
-    _ASSERTE(m_fIsPreResolved || 
-             (GetAppDomain()->GetAppDomainManagerInitializeNewDomainFlags() & eInitializeNewDomainFlags_NoSecurityChanges) == eInitializeNewDomainFlags_None);
-
-    BOOL fPreResolveFullTrust = FALSE;
-    BOOL fPreResolveHomogeneous = FALSE;
-    PreResolve(&fPreResolveFullTrust, &fPreResolveHomogeneous);
-#endif // _DEBUG
-
-#ifdef FEATURE_CORECLR
-    // coreclr has 2 kinds of AppDomains - sandboxed or not. If sandboxed, then the homogeneous flag is set. If not, then it is a full-trust appdomain.
-    if (!IsHomogeneous())
-    {
-        Security::GetPermissionInstance(&gc.granted, SECURITY_FULL_TRUST);
-        dwSpecialFlags = 0xFFFFFFFF;
-    }
-    else
-    {
-        APPDOMAINREF adRef = (APPDOMAINREF)m_pAppDomain->GetExposedObject();
-        if (adRef->GetIsFastFullTrustDomain())
-        {
-            Security::GetPermissionInstance(&gc.granted, SECURITY_FULL_TRUST);
-            dwSpecialFlags = 0xFFFFFFFF;
-        }
-        else
-        {
-            APPLICATIONTRUSTREF appTrustRef = (APPLICATIONTRUSTREF)adRef->GetApplicationTrust();
-            POLICYSTATEMENTREF psRef = appTrustRef->GetPolicyStatement();
-            gc.granted = (OBJECTREF)psRef->GetPermissionSet();
-
-            // We can trust the grant set special flags, since only mscorlib can access the root
-            // ApplicationTrust reference.
-            dwSpecialFlags = appTrustRef->GetGrantSetSpecialFlags();
-        }
-    }
-
-#else
-    if (QuickIsFullyTrusted())
-    {
-        Security::GetPermissionInstance(&gc.granted, SECURITY_FULL_TRUST);
-        dwSpecialFlags = 0xFFFFFFFF;
-    }
-    // We need to check the homogeneous flag directly rather than going through the accessor method, since
-    // that method also considers the presence of a HostSecurityManager.  The HostSecurityManager should not
-    // affect the domain's grant set at this point however, as it does not have any domain policy resolution
-    // callbacks and if it wanted customize the homogenous domain grant set it needed to do that when we called 
-    // its InitializeNewDomain.  Longer term IsHomogenous should not consider the HostSecurityManager at all.
-    else if (m_fHomogeneous)
-    {
-        // Homogeneous AppDomain case 
-        
-        APPDOMAINREF adRef = (APPDOMAINREF)m_pAppDomain->GetExposedObject();
-        _ASSERTE( adRef != NULL);
-
-        if (adRef->GetIsFastFullTrustDomain())
-        {
-            Security::GetPermissionInstance(&gc.granted, SECURITY_FULL_TRUST);
-            dwSpecialFlags = 0xFFFFFFFF;
-        }
-        else
-        {
-            APPLICATIONTRUSTREF appTrustRef = (APPLICATIONTRUSTREF)adRef->GetApplicationTrust();
-            _ASSERTE(appTrustRef != NULL);
-            POLICYSTATEMENTREF psRef = appTrustRef->GetPolicyStatement();
-            _ASSERTE(psRef != NULL);
-            gc.granted = (OBJECTREF)psRef->GetPermissionSet();
-
-            // We can trust the grant set special flags, since only mscorlib can access the root
-            // ApplicationTrust reference.
-            dwSpecialFlags = appTrustRef->GetGrantSetSpecialFlags();
-        }
-    }
-    else
-    {
-        // Regular AppDomain policy resolution based on AppDomain evidence
-        if (IsEvidenceComputed())
-        {
-            gc.evidence = ObjectFromLazyHandle(m_hAdditionalEvidence, m_pLoaderAllocator);
-        }
-        else
-        {
-            gc.evidence = GetEvidence();
-        }
-
-        if (!IsLegacyCasPolicyEnabled())
-        {
-            // Either we have a host security manager or a homogenous AppDomain that could make this domain be
-            // partially trusted.  Call out to managed to get the grant set.
-            gc.granted = SecurityPolicy::ResolveGrantSet(gc.evidence, &dwSpecialFlags, FALSE);
-        }
-        else
-        {
-            // Legacy CAS policy is enabled, so do a full CAS resolve
-            gc.granted = SecurityPolicy::ResolveCasPolicy(gc.evidence,
-                                                          NULL,
-                                                          NULL,
-                                                          NULL,
-                                                          &gc.grantdenied,
-                                                          &dwSpecialFlags,
-                                                          FALSE);
-        }
-    }
-#endif    
-
-    SetGrantedPermissionSet(gc.granted, NULL, dwSpecialFlags);
-
-#ifdef FEATURE_CAS_POLICY
-    // If the host promised not to modify the security of the AppDomain, throw an InvalidOperationException
-    // if it did.  We specifically want to check the cached version of this state on the security
-    // descriptor, rather than any version calculated earlier on in this method since the domain manager has
-    // already run by the time ResolveWorker is entered.
-    if (GetAppDomain()->GetAppDomainManagerInitializeNewDomainFlags() & eInitializeNewDomainFlags_NoSecurityChanges)
-    {
-        _ASSERTE(m_fIsPreResolved);
-
-        if (!!m_fPreResolutionFullTrust != !!IsFullyTrusted())
-        {
-            COMPlusThrow(kInvalidOperationException, W("InvalidOperation_HostModifiedSecurityState"));
-        }
-
-        if (!!m_fPreResolutionHomogeneous != !!IsHomogeneous())
-        {
-            COMPlusThrow(kInvalidOperationException, W("InvalidOperation_HostModifiedSecurityState"));
-        }
-    }
-#endif // FEATURE_CAS_POLICY
-
-#if defined(_DEBUG) && !defined(FEATURE_CORECLR)
-    // Make sure that that our PreResolve routine is consistent with our actual resolution results.  This is
-    // only required to be true in the absence of an AppDomainManager.
-    // 
-    // If any assert fires in this block, it means that PreResolve isn't correctly figuring out what the
-    // incoming security state of an AppDomain is going to resolve into.
-    if (!GetAppDomain()->HasAppDomainManagerInfo())
-    {
-#ifdef FEATURE_CLICKONCE
-        if (GetAppDomain()->IsClickOnceAppDomain())
-        {
-            _ASSERTE(!!IsHomogeneous() == !!fPreResolveHomogeneous);
-            // We don't check grant set since we don't attempt to pre-resolve that - pre-resolution should
-            // have always come back partial trust
-            _ASSERTE(!fPreResolveFullTrust);
-        }
-        else
-#endif // FEATURE_CLICKONCE
-        if (IsHomogeneous())
-        {
-            _ASSERTE(!!IsHomogeneous() == !!fPreResolveHomogeneous);
-            _ASSERTE(!!IsFullyTrusted() == !!fPreResolveFullTrust);
-        }
-        else
-        {
-            _ASSERTE(!!IsHomogeneous() == !!fPreResolveHomogeneous);
-            // We don't check grant sets on heterogeneous domains since they are never attempted to be pre-resolved.
-        }
-    }
-#endif // _DEBUG && !FEATURE_CORECLR
-
-    GCPROTECT_END();
-}
-
 //---------------------------------------------------------------------------------------
 //
 // Determine the security state of an AppDomain before the domain is fully configured.
@@ -332,140 +65,16 @@ void ApplicationSecurityDescriptor::PreResolve(BOOL *pfIsFullyTrusted, BOOL *pfI
 
     GCX_COOP();
 
-#ifdef FEATURE_CORECLR
     // On CoreCLR all domains are partial trust homogenous
     m_fPreResolutionFullTrust = FALSE;
     m_fPreResolutionHomogeneous = TRUE;
 
-#else // !FEATURE_CORECLR
-    if (GetAppDomain()->IsClickOnceAppDomain())
-    {
-        // In the ClickOnce case we can't pre-resolve the grant set because it's entirely in the control of
-        // the ApplicationSecurityManager.  We conservatively assume that it will be partial trust; however
-        // we always know that the domain will be homogenous
-        m_fPreResolutionFullTrust = FALSE;
-        m_fPreResolutionHomogeneous = TRUE;
-    }
-    else if (GetAppDomain()->IsCompilationDomain())
-    {
-        // NGEN is always full trust and homogenous
-        m_fPreResolutionFullTrust = TRUE;
-        m_fPreResolutionHomogeneous = TRUE;
-    }
-    else if (GetAppDomain()->IsDefaultDomain())
-    {
-        // Barring any shenanigans from the AppDomainManager, we know that the default domain will be fully
-        // trusted and homogenous in the standard case, but heterogenous in the legacy CAS policy case.
-        m_fPreResolutionFullTrust = TRUE;
-        m_fPreResolutionHomogeneous = !Security::IsProcessWideLegacyCasPolicyEnabled();
-    }
-    else
-    {
-        // In all other AppDomains we need to consult the incoming AppDomainSetup in order to figure out if
-        // the domain is being setup as full or partial trust.
-        CLR_BOOL fPreResolutionFullTrust = FALSE;
-        CLR_BOOL fPreResolutionHomogeneous = FALSE;
-
-        MethodDescCallSite preResolve(METHOD__SECURITY_ENGINE__PRE_RESOLVE);
-
-        ARG_SLOT args[] =
-        {
-            PtrToArgSlot(&fPreResolutionFullTrust),
-            PtrToArgSlot(&fPreResolutionHomogeneous)
-        };
-
-        preResolve.Call(args);
-
-        m_fPreResolutionFullTrust = !!fPreResolutionFullTrust;
-        m_fPreResolutionHomogeneous = !!fPreResolutionHomogeneous;
-    }
-#endif // FEATURE_CORECLR
-
     *pfIsFullyTrusted = m_fPreResolutionFullTrust;
     *pfIsHomogeneous = m_fPreResolutionHomogeneous;
     m_fIsPreResolved = TRUE;
 }
 #endif // CROSSGEN_COMPILE
 
-#ifdef FEATURE_CAS_POLICY
-//---------------------------------------------------------------------------------------
-//
-// Determine if an AppDomain should allow an assembly to be LoadFrom-ed a remote location.
-// Since pre-v4 versions of the CLR would implicitly sandbox this load, we only want to
-// allow this if the application has either acknowledged it to be safe, or if the application
-// has taken control of sandboxing itself.
-// 
-// This method returns true if the load should be allowed, false if it should be blocked
-// from a remote location.
-// 
-
-BOOL ApplicationSecurityDescriptor::AllowsLoadsFromRemoteSources()
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        THROWS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    // If the application has explicitly enabled remote LoadFroms then we should allow the load
-    if (Security::CanLoadFromRemoteSources())
-    {
-        return true;
-    }
-
-    // Otherwise, we only allow the load if the assembly is going to be sandboxed (or explicitly not sandboxed
-    // by a host).  That can happen if we've got legacy CAS polcy enabled, if we're in a homogenous AppDomain,
-    // or if there is a HostSecurityManager that cares about assembly policy.
-    // 
-    // Note that we don't allow LoadFrom a remote source in a domain that had its ApplicationTrust supplied by
-    // the CLR, since that domain would have implicitly sandboxed the LoadFrom in CLR v2. Instead, these
-    // domains require that there be a HostSecurityManager present which setup the sandbox.
-
-    if (IsHomogeneous() && !m_fRuntimeSuppliedHomogenousGrantSet)
-    {
-        return true;
-    }
-
-    if (IsLegacyCasPolicyEnabled())
-    {
-        return true;
-    }
-
-    return false;
-}
-
-DWORD ApplicationSecurityDescriptor::GetZone()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-        PRECONDITION(IsLegacyCasPolicyEnabled());
-    }
-    CONTRACTL_END;
-
-    SecZone dwZone = NoZone; 
-    if (m_pAppDomain->GetRootAssembly() != NULL && m_pAppDomain->IsDefaultDomain())
-    {
-        LPCWSTR wszAsmPath = m_pAppDomain->GetRootAssembly()->GetManifestFile()->GetPath();
-
-        if (wszAsmPath)
-        {
-            StackSString ssPath( W("file://") );
-            ssPath.Append( wszAsmPath );
-
-            dwZone = SecurityPolicy::MapUrlToZone(ssPath.GetUnicode());
-        }
-    }
-
-    return dwZone;
-}
-#endif // FEATURE_CAS_POLICY
-
 
 //
 // PLS (PermissionListSet) optimization Implementation
@@ -712,9 +321,6 @@ BOOL ApplicationSecurityDescriptor::IsDefaultAppDomain() const
 {
     LIMITED_METHOD_CONTRACT;
     return  m_fIsDefaultAppdomain
-#ifndef FEATURE_CORECLR
-            && !m_fHomogeneous
-#endif // FEATURE_CORECLR
             ;
 }
 
@@ -737,27 +343,6 @@ BOOL ApplicationSecurityDescriptor::ContainsAnyRefusedPermissions()
     return m_fContainsAnyRefusedPermissions;
 }
 
-#ifdef FEATURE_CAS_POLICY
-void ApplicationSecurityDescriptor::SetLegacyCasPolicyEnabled()
-{
-    STANDARD_VM_CONTRACT;
-
-    // APPX precludes the use of legacy CAS policy
-    if (!AppX::IsAppXProcess())
-    {
-        SecurityPolicy::InitPolicyConfig();
-        m_fLegacyCasPolicy = TRUE;
-    }
-}
-
-BOOL ApplicationSecurityDescriptor::IsLegacyCasPolicyEnabled()
-{
-    LIMITED_METHOD_CONTRACT;
-    return m_fLegacyCasPolicy && !AppX::IsAppXProcess();
-}
-
-#endif // FEATURE_CAS_POLICY
-
 // Is it possible for the AppDomain to contain partial trust code.  This method may return true even if the
 // domain does not currently have partial trust code in it - a true value simply means that it is possible
 // for partial trust code to eventually end up in the domain.
@@ -767,19 +352,6 @@ BOOL ApplicationSecurityDescriptor::DomainMayContainPartialTrustCode()
     return !m_fHomogeneous || !IsFullyTrusted();
 }
 
-#ifdef FEATURE_APTCA
-ConditionalAptcaCache *ApplicationSecurityDescriptor::GetConditionalAptcaCache()
-{
-    LIMITED_METHOD_CONTRACT;
-    return m_pConditionalAptcaCache;
-}
-
-void ApplicationSecurityDescriptor::SetCanonicalConditionalAptcaList(LPCWSTR wszCanonicalConditionalAptcaList)
-{
-    WRAPPER_NO_CONTRACT;
-    return this->GetConditionalAptcaCache()->SetCanonicalConditionalAptcaList(wszCanonicalConditionalAptcaList);
-}
-#endif // FEATURE_APTCA
 
 #endif // !DACCESS_COMPILE
 
diff --git a/src/vm/securitydescriptorappdomain.h b/src/vm/securitydescriptorappdomain.h
index ff5bbda616..432e0e391f 100644
--- a/src/vm/securitydescriptorappdomain.h
+++ b/src/vm/securitydescriptorappdomain.h
@@ -76,9 +76,6 @@ private:
                                         // exists on the AppDomain. (In the managed world: AppDomain._SecurityIdentity != null)
     BOOL m_fHomogeneous;                // This AppDomain has an ApplicationTrust
     BOOL m_fRuntimeSuppliedHomogenousGrantSet; // This AppDomain is homogenous only because the v4 CLR defaults to creating homogenous domains, and would not have been homogenous in v2
-#ifdef FEATURE_CAS_POLICY
-    BOOL m_fLegacyCasPolicy;            // This AppDomain is using legacy CAS policy
-#endif // FEATURE_CAS_POLICY
     DWORD m_dwHostSecurityManagerFlags; // Flags indicating what decisions the host wants to participate in.
     BOOL m_fContainsAnyRefusedPermissions;
 
@@ -86,9 +83,6 @@ private:
     BOOL m_fPreResolutionFullTrust;     // Was the domain pre-resolved to be full trust
     BOOL m_fPreResolutionHomogeneous;   // Was the domain pre-resolved to be homogenous
     
-#ifdef FEATURE_APTCA
-    ConditionalAptcaCache*   m_pConditionalAptcaCache;    // Cache of known conditional APTCA assemblies in this domain
-#endif // FEATURE_APTCA
 
 #ifndef DACCESS_COMPILE
 public:
@@ -100,9 +94,6 @@ public:
     //--------------------
     // Destructor
     //--------------------
-#ifdef FEATURE_APTCA  //  The destructor only deletes the ConditionalAptcaCache
-    inline ~ApplicationSecurityDescriptor();
-#endif // FEATURE_APTCA
 
 public:
     // Indicates whether the initialization phase is in progress.
@@ -131,20 +122,12 @@ public:
     inline void SetHomogeneousFlag(BOOL fRuntimeSuppliedHomogenousGrantSet);
     virtual BOOL IsHomogeneous() const;
 
-#ifdef FEATURE_CAS_POLICY
-    virtual BOOL IsLegacyCasPolicyEnabled();
-    virtual void SetLegacyCasPolicyEnabled();
-#endif // FEATURE_CAS_POLICY
     
     virtual BOOL ContainsAnyRefusedPermissions();
 
     // Should the HSM be consulted for security decisions in this AppDomain.
     virtual BOOL CallHostSecurityManager();
 
-#ifdef FEATURE_CAS_POLICY
-    // Does the domain's HSM need to be consulted for assemblies loaded into the domain
-    inline BOOL CallHostSecurityManagerForAssemblies();
-#endif // FEATURE_CAS_POLICY
 
     // Initialize the PLS on the AppDomain.
     void InitializePLS();
@@ -163,21 +146,11 @@ public:
     inline BOOL CheckDomainWideSpecialFlag(DWORD flags) const;
     virtual DWORD GetDomainWideSpecialFlag() const;
 
-#ifdef FEATURE_CAS_POLICY
-    virtual OBJECTREF GetEvidence();
-    DWORD GetZone();
-
-    virtual BOOL AllowsLoadsFromRemoteSources();
-#endif // FEATURE_CAS_POLICY
 
     virtual BOOL DomainMayContainPartialTrustCode();
 
     BOOL QuickIsFullyTrusted();
 
-#ifdef FEATURE_APTCA
-    virtual ConditionalAptcaCache *GetConditionalAptcaCache();
-    virtual void SetCanonicalConditionalAptcaList(LPCWSTR wszCanonicalConditionalAptcaList);
-#endif // FEATURE_APTCA
 #endif // #ifndef DACCESS_COMPILE
 };
 
diff --git a/src/vm/securitydescriptorappdomain.inl b/src/vm/securitydescriptorappdomain.inl
index fdb8b3faef..f3fdde2b12 100644
--- a/src/vm/securitydescriptorappdomain.inl
+++ b/src/vm/securitydescriptorappdomain.inl
@@ -21,17 +21,11 @@ inline ApplicationSecurityDescriptor::ApplicationSecurityDescriptor(AppDomain *p
     m_fIsDefaultAppdomainEvidence(FALSE),
     m_fHomogeneous(FALSE),
     m_fRuntimeSuppliedHomogenousGrantSet(FALSE),
-#ifdef FEATURE_CAS_POLICY
-    m_fLegacyCasPolicy(Security::IsProcessWideLegacyCasPolicyEnabled()),
-#endif // FEATURE_CAS_POLICY
     m_dwHostSecurityManagerFlags(HOST_NONE),
     m_fContainsAnyRefusedPermissions(FALSE),
     m_fIsPreResolved(FALSE),
     m_fPreResolutionFullTrust(FALSE),
     m_fPreResolutionHomogeneous(FALSE)
-#ifdef FEATURE_APTCA
-    ,m_pConditionalAptcaCache(new ConditionalAptcaCache(pAppDomain))
-#endif // FEATURE_APTCA
 {
     CONTRACTL
     {
@@ -45,20 +39,6 @@ inline ApplicationSecurityDescriptor::ApplicationSecurityDescriptor(AppDomain *p
     return;
 }
 
-#ifdef FEATURE_APTCA
-inline ApplicationSecurityDescriptor::~ApplicationSecurityDescriptor()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        MODE_ANY;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-
-    delete m_pConditionalAptcaCache;
-}
-#endif // FEATURE_APTCA
 
 inline void ApplicationSecurityDescriptor::ResetInitializationInProgress()
 {
@@ -93,34 +73,6 @@ inline void ApplicationSecurityDescriptor::SetHomogeneousFlag(BOOL fRuntimeSuppl
     m_fRuntimeSuppliedHomogenousGrantSet = fRuntimeSuppliedHomogenousGrantSet;
 }
 
-#ifdef FEATURE_CAS_POLICY
-
-// Does the domain's HSM need to be consulted for assemblies loaded into the domain
-inline BOOL ApplicationSecurityDescriptor::CallHostSecurityManagerForAssemblies()
-{
-    LIMITED_METHOD_CONTRACT;
-
-    // We always need to call the HSM if it wants to specify the assembly's grant set
-    if (m_dwHostSecurityManagerFlags & HOST_RESOLVE_POLICY)
-    {
-        return TRUE;
-    }
-
-    // In legacy CAS mode, we also need to call the HSM if it wants to supply evidence or if we have an
-    // AppDomain policy level
-    if (IsLegacyCasPolicyEnabled())
-    {
-        if ((m_dwHostSecurityManagerFlags & HOST_ASM_EVIDENCE) ||
-            (m_dwHostSecurityManagerFlags & HOST_POLICY_LEVEL))
-        {
-            return TRUE;
-        }
-    }
-
-    return FALSE;
-}
-
-#endif // FEATURE_CAS_POLICY
 
 #endif // #ifndef DACCESS_COMPILE
 
diff --git a/src/vm/securitydescriptorassembly.cpp b/src/vm/securitydescriptorassembly.cpp
index c2aef22019..383d62c3e3 100644
--- a/src/vm/securitydescriptorassembly.cpp
+++ b/src/vm/securitydescriptorassembly.cpp
@@ -15,14 +15,6 @@ AssemblySecurityDescriptor::AssemblySecurityDescriptor(AppDomain *pDomain, Domai
     m_dwNumPassedDemands(0),
     m_pSignature(NULL),
     m_pSharedSecDesc(NULL),
-#ifdef FEATURE_CAS_POLICY
-    m_hRequiredPermissionSet(NULL),
-    m_hOptionalPermissionSet(NULL),
-    m_hDeniedPermissionSet(NULL),
-    m_fAdditionalEvidence(FALSE),
-    m_fIsSignatureLoaded(FALSE),
-    m_fAssemblyRequestsComputed(FALSE),
-#endif
     m_fMicrosoftPlatform(FALSE),
     m_fAllowSkipVerificationInFullTrust(TRUE)
 {
@@ -34,82 +26,6 @@ AssemblySecurityDescriptor::AssemblySecurityDescriptor(AppDomain *pDomain, Domai
     } CONTRACTL_END;
 }
 
-#ifdef FEATURE_CAS_POLICY
-OBJECTREF AssemblySecurityDescriptor::GetRequestedPermissionSet(OBJECTREF *pOptionalPermissionSet,
-                                                                OBJECTREF *pDeniedPermissionSet)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(m_pAppDomain == GetAppDomain());
-        PRECONDITION(CheckPointer(pOptionalPermissionSet));
-        PRECONDITION(CheckPointer(pDeniedPermissionSet));
-        PRECONDITION(m_pAppDomain->GetSecurityDescriptor()->IsLegacyCasPolicyEnabled());
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    OBJECTREF req = NULL;
-    GCPROTECT_BEGIN(req);
-
-    if (!IsAssemblyRequestsComputed())
-    {
-        ReleaseHolder<IMDInternalImport> pImport (m_pAssem->GetFile()->GetMDImportWithRef());
-
-        // Try to load permission requests from assembly first.
-        SecurityAttributes::LoadPermissionRequestsFromAssembly(pImport,
-                                                               &req,
-                                                               pOptionalPermissionSet,
-                                                               pDeniedPermissionSet);
-
-        SetRequestedPermissionSet(req, *pOptionalPermissionSet, *pDeniedPermissionSet);
-    }
-    else
-    {
-        *pOptionalPermissionSet = ObjectFromLazyHandle(m_hOptionalPermissionSet, m_pLoaderAllocator);
-        *pDeniedPermissionSet = ObjectFromLazyHandle(m_hDeniedPermissionSet, m_pLoaderAllocator);
-        req = ObjectFromLazyHandle(m_hRequiredPermissionSet, m_pLoaderAllocator);
-    }
-
-    GCPROTECT_END();
-    return req;
-}
-
-void AssemblySecurityDescriptor::SetRequestedPermissionSet(OBJECTREF RequiredPermissionSet,
-                                                                  OBJECTREF OptionalPermissionSet,
-                                                                  OBJECTREF DeniedPermissionSet)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-
-    struct _gc
-    {
-        OBJECTREF RequiredPermissionSet;
-        OBJECTREF OptionalPermissionSet;
-        OBJECTREF DeniedPermissionSet;
-    } gc;
-
-    gc.RequiredPermissionSet = RequiredPermissionSet;
-    gc.OptionalPermissionSet = OptionalPermissionSet;
-    gc.DeniedPermissionSet = DeniedPermissionSet;
-
-    GCPROTECT_BEGIN(gc);
-    StoreObjectInLazyHandle(m_hRequiredPermissionSet, gc.RequiredPermissionSet, m_pLoaderAllocator);
-    StoreObjectInLazyHandle(m_hOptionalPermissionSet, gc.OptionalPermissionSet, m_pLoaderAllocator);
-    StoreObjectInLazyHandle(m_hDeniedPermissionSet, gc.DeniedPermissionSet, m_pLoaderAllocator);
-    GCPROTECT_END();
-
-    m_fAssemblyRequestsComputed = TRUE;
-}
-#endif // FEATURE_CAS_POLICY
-
 //
 // This method will return TRUE if this assembly is allowed to skip verification.
 //
@@ -227,48 +143,6 @@ BOOL AssemblySecurityDescriptor::QuickIsFullyTrusted()
 
     if (IsSystem())
         return TRUE;
-#ifdef FEATURE_CAS_POLICY
-
-    // NGEN is always done in full trust
-    if (m_pAppDomain->IsCompilationDomain())
-    {
-        return TRUE;
-    }
-
-    // If the assembly is in the GAC then it gets FullTrust.
-    if (m_pAssem->GetFile()->IsSourceGAC())
-        return TRUE;
-
-    // quickly detect if we've got a request refused or a request optional.
-    if (m_pAppDomain->GetSecurityDescriptor()->IsLegacyCasPolicyEnabled())
-    {
-        ReleaseHolder<IMDInternalImport> pImport(m_pAssem->GetFile()->GetMDImportWithRef());
-        if (SecurityAttributes::RestrictiveRequestsInAssembly(pImport))
-            return FALSE;
-    }
-
-    // Check if we need to call the HostSecurityManager.
-    ApplicationSecurityDescriptor* pAppSecDesc = static_cast<ApplicationSecurityDescriptor*>(m_pAppDomain->GetSecurityDescriptor());
-    if (pAppSecDesc->CallHostSecurityManagerForAssemblies())
-        return FALSE;
-
-    // - If the AppDomain is homogeneous, we currently simply detect the FT case
-    // - Not having CAS on implies full trust.  We can get here if we're still in the process of setting up
-    //   the AppDomain and the CLR hasn't yet setup the homogenous flag.
-    // - Otherwise, check the quick cache
-    if (pAppSecDesc->IsHomogeneous())
-    {
-        return m_pAppDomain->GetSecurityDescriptor()->IsFullyTrusted();
-    }
-    else if (!m_pAppDomain->GetSecurityDescriptor()->IsLegacyCasPolicyEnabled())
-    {
-        return TRUE;
-    }
-    else if (CheckQuickCache(SecurityConfig::FullTrustAll, GetZone()))
-    {
-        return TRUE;
-    }
-#endif
 
     // See if we've already determined that the assembly is FT
     // in another AppDomain, in case this is a shared assembly.
@@ -307,115 +181,6 @@ void AssemblySecurityDescriptor::PropagatePermissionSet(OBJECTREF GrantedPermiss
     Resolve();
 }
 
-#ifdef FEATURE_CAS_POLICY
-//-----------------------------------------------------------------------------------------------------------
-//
-// Use the evidence already generated for this assembly's PEFile as the evidence for the assembly
-//
-// Arguments:
-//    pPEFileSecDesc - PEFile security descriptor contining the already generated evidence
-//
-void AssemblySecurityDescriptor::SetEvidenceFromPEFile(IPEFileSecurityDescriptor *pPEFileSecDesc)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(CheckPointer(pPEFileSecDesc));
-        PRECONDITION(GetPEFile()->Equals(static_cast<PEFileSecurityDescriptor*>(pPEFileSecDesc)->GetPEFile()));
-    }
-    CONTRACTL_END;
-
-    // If we couldn't determine the assembly was fully trusted without first generating evidence for it,
-    // then we cannot reuse the PEFile's evidence.  In that case we'll just use what we've generated for the
-    // assembly, and discard the PEFile's version.
-    if (!IsEvidenceComputed())
-    {
-        struct
-        {
-            OBJECTREF objPEFileEvidence;
-            OBJECTREF objEvidence;
-        }
-        gc;
-        ZeroMemory(&gc, sizeof(gc));
-
-        GCPROTECT_BEGIN(gc);
-
-        gc.objPEFileEvidence = pPEFileSecDesc->GetEvidence();
-        gc.objEvidence = UpgradePEFileEvidenceToAssemblyEvidence(gc.objPEFileEvidence);
-        SetEvidence(gc.objEvidence);
-
-        GCPROTECT_END();
-    }
-}
-
-//---------------------------------------------------------------------------------------
-//
-// Get the evidence collection for this Assembly
-//
-//
-OBJECTREF AssemblySecurityDescriptor::GetEvidence()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(m_pAppDomain == GetAppDomain());
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    // If we already have evidence, then just return that
-    if (IsEvidenceComputed())
-        return ObjectFromLazyHandle(m_hAdditionalEvidence, m_pLoaderAllocator);
-
-    struct
-    {
-        OBJECTREF objHostProvidedEvidence;
-        OBJECTREF objPEFileEvidence;
-        OBJECTREF objEvidence;
-    }
-    gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc);
-    BEGIN_SO_INTOLERANT_CODE(GetThread());
-
-    gc.objHostProvidedEvidence = ObjectFromLazyHandle(m_hAdditionalEvidence, m_pLoaderAllocator);
-
-#if CHECK_APP_DOMAIN_LEAKS
-    if (g_pConfig->AppDomainLeaks())
-    {
-        _ASSERTE(gc.objPEFileEvidence == NULL || GetAppDomain() == gc.objPEFileEvidence->GetAppDomain());
-        _ASSERTE(gc.objHostProvidedEvidence == NULL || GetAppDomain() == gc.objHostProvidedEvidence->GetAppDomain());
-    }
-#endif  // CHECK_APP_DOMAIN_LEAKS
-
-    //
-    // First get an evidence collection which targets our PEFile, then upgrade it to use this assembly as a
-    // target.  We create a new Evidence for the PEFile here, which means that any evidence that PEFile may
-    // have already had is not used in this upgrade.  If an existing PEFileSecurityDescriptor exists for the
-    // PEFile, then that should be upgraded directly, rather than going through this code path.
-    // 
-    
-    gc.objPEFileEvidence = PEFileSecurityDescriptor::BuildEvidence(m_pPEFile, gc.objHostProvidedEvidence);
-    gc.objEvidence = UpgradePEFileEvidenceToAssemblyEvidence(gc.objPEFileEvidence);
-    SetEvidence(gc.objEvidence);
-
-#if CHECK_APP_DOMAIN_LEAKS
-    if (g_pConfig->AppDomainLeaks())
-        _ASSERTE(gc.objEvidence == NULL || GetAppDomain() == gc.objEvidence->GetAppDomain());
-#endif // CHECK_APP_DOMAIN_LEAKS
-
-    END_SO_INTOLERANT_CODE;
-
-    GCPROTECT_END();
-
-    return gc.objEvidence;
-}
-#endif // FEATURE_CAS_POLICY
 #endif // !DACCESS_COMPILE
 
 BOOL AssemblySecurityDescriptor::IsSystem()
@@ -445,36 +210,6 @@ void AssemblySecurityDescriptor::Resolve()
         pSharedSecDesc->Resolve(this);
 }
 
-#ifdef FEATURE_CAS_POLICY
-// This routine is called when we have determined that it that there is no SECURITY reason
-// to verify an image, but we may want to do so anyway to insure that 3rd parties don't 
-// accidentally ship delay signed dlls because the application happens to be full trust.  
-//
-static bool DontNeedToFlagAccidentalDelaySigning(PEAssembly* assem)
-{
-    WRAPPER_NO_CONTRACT;
-
-    // If the file has a native image, then either it is strongly named and can be considered
-    // fully signed (see additional comments in code:PEAssembly::IsFullySigned), or it is not
-    // strong named and thus can't be delay signed. Either way no check is needed.
-    // If the file fully signed, then people did not accidentally forget, so no check is needed
-    if (assem->HasNativeImage() || assem->IsFullySigned())
-        return true;
-
-    // If mscorlib itself is not signed, this is not an offical CLR, you don't need to 
-    // to do the checking in this case either because 3rd parties should not be running this way.
-    // This is useful because otherwise when we run perf runs on normal CLR lab builds we don't
-    // measure the performance that we get for a offical runtime (since official runtimes will
-    // be signed).   
-    PEAssembly* mscorlib = SystemDomain::SystemFile();
-    if (!mscorlib->HasNativeImage())
-        return false;
-    if ((mscorlib->GetLoadedNative()->GetNativeHeader()->COR20Flags & COMIMAGE_FLAGS_STRONGNAMESIGNED) == 0)
-        return true;
-
-    return false;
-}
-#endif // FEATURE_CAS_POLICY
 
 void AssemblySecurityDescriptor::ResolveWorker()
 {
@@ -485,160 +220,7 @@ void AssemblySecurityDescriptor::ResolveWorker()
         INJECT_FAULT(COMPlusThrowOM(););
     } CONTRACTL_END;
 
-#ifdef FEATURE_CORECLR
     SetGrantedPermissionSet(NULL, NULL, 0xFFFFFFFF);
-#else
-    if (CanSkipPolicyResolution() || NingenEnabled()) {
-        SetGrantedPermissionSet(NULL, NULL, 0xFFFFFFFF);
-        m_pAssem->GetFile()->SetStrongNameBypassed();
-        return;
-    }
-
-#ifndef CROSSGEN_COMPILE
-    struct _gc {
-        OBJECTREF reqdPset;         // Required Requested Permissions
-        OBJECTREF optPset;          // Optional Requested Permissions
-        OBJECTREF denyPset;         // Denied Permissions
-        OBJECTREF evidence;         // Object containing evidence
-        OBJECTREF granted;          // Policy based Granted Permission
-        OBJECTREF grantdenied;      // Policy based explicitly Denied Permissions
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-   
-    // Policy resolution can cause string comparisons that trigger .nlp module loads. (Specifically,
-    // FileIOPermission can trigger this).  At this point mscorlib is already loaded, so we can
-    // override the load levels here to allow the .nlp module loads.   
-    OVERRIDE_LOAD_LEVEL_LIMIT(FILE_ACTIVE);
-    OVERRIDE_TYPE_LOAD_LEVEL_LIMIT(CLASS_LOADED);
-
-    // Resolve is one of the few SecurityDescriptor routines that may be called
-    // from the wrong appdomain context. If that's the case we will transition
-    // into the correct appdomain for the duration of the call.
-    
-    ENTER_DOMAIN_PTR_PREDICATED(m_pAppDomain,ADV_RUNNINGIN,!IsSystem())
-    {
-        GCPROTECT_BEGIN(gc);
-
-        //
-        // GAC assemblies with no RequestRefuse get FullTrust
-        // Also AppDomains with an AppTrust that are fully trusted are
-        // homogeneous and so every assembly that does not have a RequestRefuse
-        // will also get FullTrust.
-        //
-
-        DWORD dwSpecialFlags;
-
-        if (QuickIsFullyTrusted())
-        {
-            Security::GetPermissionInstance(&gc.granted, SECURITY_FULL_TRUST);
-            dwSpecialFlags = 0xFFFFFFFF;
-        }
-        else
-        {
-            // We couldn't quickly figure out that the assembly was fully trusted, so gather its evidence and
-            // call managed code to get the final grant set.
-            if (IsEvidenceComputed())
-            {
-                gc.evidence = ObjectFromLazyHandle(m_hAdditionalEvidence, m_pLoaderAllocator);
-            }
-            else
-            {
-                gc.evidence = GetEvidence();
-            }
-
-            if (!m_pAppDomain->GetSecurityDescriptor()->IsLegacyCasPolicyEnabled())
-            {
-                // Either we have a host security manager or a homogenous AppDomain that could make this
-                // assembly be partially trusted.  Call out to managed to get the grant set.
-                gc.granted = SecurityPolicy::ResolveGrantSet(gc.evidence, &dwSpecialFlags, TRUE);
-            }
-            else
-            {
-                // Legacy CAS policy is enabled, so do a full CAS resolve
-                gc.reqdPset = GetRequestedPermissionSet(&gc.optPset, &gc.denyPset);
-                gc.granted = SecurityPolicy::ResolveCasPolicy(gc.evidence,
-                                                              gc.reqdPset,
-                                                              gc.optPset,
-                                                              gc.denyPset,
-                                                              &gc.grantdenied,
-                                                              &dwSpecialFlags,
-                                                              TRUE);
-            }
-        }
-
-        SetGrantedPermissionSet(gc.granted, gc.denyPset, dwSpecialFlags);
-
-#ifdef FEATURE_CAS_POLICY
-        // If we're delaying verification of the assembly's strong name, check to see if we need to force a
-        // verification at this point.
-        if (!m_pAssem->IsSystem() && 
-            !m_pAssem->GetFile()->IsSourceGAC() &&
-            !m_pAssem->GetFile()->IsStrongNameVerified())
-        {
-            //
-            // #StrongNameBypass
-            //
-            // If the application has opted into the strong name bypass feature, then we will attempt to
-            // load its assemblies without verifying their strong names.  We can get away with avoiding the
-            // strong name verification in the case where all of the following apply.
-            // 
-            //   1. The application has asked for strong name bypass
-            //   2. The machine administrator has not disabled strong name bypass for the machine
-            //   3. The assembly being loaded is fully trusted, and this trust is not soley based upon its
-            //      strong name.
-            //   4. The AppDomain the assembly is being loaded into is fully trusted
-            //   5. The assembly is fully signed
-            //   6. The appdomain is not attempting to run ngen.
-            //   
-            // Condition #3 requires that the grant set of the assembly not be obtained via the strong name
-            // evidence of the assembly.  Note that this requirement does not forbid matching a code group
-            // with a strong name membership condition, as long as that code group and any children code
-            // groups produce a grant set which was less than or equal to the grant set produced by other
-            // code groups.  For instance, in standard security policy:
-            // 
-            //   1.1 MyComputer -> FullTrust
-            //      1.1.1 Microsoft Strong Name -> FullTrust
-            //      
-            // In this case, an assembly loaded from the local machine with the Microsoft strong name is
-            // still eligable for strong name bypass via condition #3, since the MyComputer FullTrust grant
-            // set unioned with the StrongName FullTrust grant set will produce the same results as if we
-            // didn't evaluate the StrongName code group.
-            // 
-            // Note that strong name bypass is not the same thing as strong name skip verification.  Skip
-            // verification is a development time feature which enables developers to test privately built
-            // assemblies that do not have a full signature yet.  It is not intended for use at runtime on
-            // non-developer machines, nor is it intended for use on assemblies with valid strong names.
-            // 
-            // In contrast strong name bypass is intended to be used on assemblies with valid strong names
-            // that are deployed to end users machines.  It's a performance feature which enables assemblies
-            // that were not gaining any benefit from having their strong name validated to avoid having to
-            // pay the expense of a full signature verification. This is why ngen does not skip. There
-            // are potential ways to use the ngen cache to skip strong name verification if ngen participates
-            // in strong name bypass, and the startup performance concern of the application is not a concern
-            // when running at ngen time.
-            //
-
-            if (IsFullyTrusted() && 
-                GetDomain()->GetSecurityDescriptor()->IsFullyTrusted() &&
-                !SecurityPolicy::WasStrongNameEvidenceUsed(gc.evidence) &&
-                DontNeedToFlagAccidentalDelaySigning(m_pAssem->GetFile()) &&
-                !IsCompilationProcess())
-            {
-                m_pAssem->GetFile()->SetStrongNameBypassed();
-            }
-            else
-            {
-                m_pAssem->GetFile()->VerifyStrongName();
-            }
-        }
-#endif // FEATURE_CAS_POLICY
-
-        GCPROTECT_END();
-    }
-    END_DOMAIN_TRANSITION;
-#endif // CROSSGEN_COMPILE
-
-#endif // FEATURE_CORECLR
 }
 
 void AssemblySecurityDescriptor::ResolvePolicy(ISharedSecurityDescriptor *pSharedSecDesc, BOOL fShouldSkipPolicyResolution)
@@ -692,27 +274,6 @@ void AssemblySecurityDescriptor::ResolvePolicy(ISharedSecurityDescriptor *pShare
     __dcimf.Pop();
 }
 
-#ifdef FEATURE_CAS_POLICY
-DWORD AssemblySecurityDescriptor::GetZone()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-        PRECONDITION(m_pAppDomain->GetSecurityDescriptor()->IsLegacyCasPolicyEnabled());
-    } CONTRACTL_END;
-
-    StackSString    codebase;
-    SecZone         dwZone = NoZone;
-    BYTE            rbUniqueID[MAX_SIZE_SECURITY_ID];
-    DWORD           cbUniqueID = sizeof(rbUniqueID);
-
-    m_pAssem->GetSecurityIdentity(codebase, &dwZone, 0, rbUniqueID, &cbUniqueID);
-    return dwZone;
-}
-#endif // FEATURE_CAS_POLICY
 
 Assembly* AssemblySecurityDescriptor::GetAssembly()
 {
@@ -727,130 +288,7 @@ BOOL AssemblySecurityDescriptor::CanSkipPolicyResolution()
 }
 
 
-#ifdef FEATURE_CAS_POLICY
-//-----------------------------------------------------------------------------------------------------------
-//
-// Upgrade the evidence used for resolving a PEFile to be targeted at the Assembly the PEFile represents
-//
-// Arguments:
-//    objPEFileEvidence - 
-//    
-// Notes:
-//    During CLR startup we may need to resolve policy against a PEFile before we have the associated
-//    Assembly.  Once we have the Assembly we don't want to recompute potenially expensive evidence, so this
-//    method can be used to upgrade the evidence who's target was the PEFile to target the assembly instead.
-//    
-//    Will call into System.Reflection.Assembly.UpgradeSecurityIdentity
-//
-
-OBJECTREF AssemblySecurityDescriptor::UpgradePEFileEvidenceToAssemblyEvidence(const OBJECTREF& objPEFileEvidence)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(objPEFileEvidence != NULL);
-    }
-    CONTRACTL_END;
-
-    struct
-    {
-        OBJECTREF objAssembly;
-        OBJECTREF objEvidence;
-        OBJECTREF objUpgradedEvidence;
-    }
-    gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc);
-
-    gc.objAssembly = m_pAssem->GetExposedAssemblyObject();
-    gc.objEvidence = objPEFileEvidence;
-
-    MethodDescCallSite upgradeSecurityIdentity(METHOD__ASSEMBLY_EVIDENCE_FACTORY__UPGRADE_SECURITY_IDENTITY);
-
-    ARG_SLOT args[] = 
-    {
-        ObjToArgSlot(gc.objEvidence),
-        ObjToArgSlot(gc.objAssembly)
-    };
-
-    gc.objUpgradedEvidence = upgradeSecurityIdentity.Call_RetOBJECTREF(args);
-
-    GCPROTECT_END();
-
-    return gc.objUpgradedEvidence;
-}
-
-HRESULT AssemblySecurityDescriptor::LoadSignature(COR_TRUST **ppSignature)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    } CONTRACTL_END;
-
-    if (IsSignatureLoaded())
-    {
-        if (ppSignature)
-        {
-            *ppSignature = m_pSignature;
-        }
-
-        return S_OK;
-    }
-
-    GCX_PREEMP();
-    m_pSignature = m_pAssem->GetFile()->GetAuthenticodeSignature();
-
-    SetSignatureLoaded();
-
-    if (ppSignature)
-    {
-        *ppSignature = m_pSignature;
-    }
-
-    return S_OK;
-}
-
-void AssemblySecurityDescriptor::SetAdditionalEvidence(OBJECTREF evidence)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-
-    StoreObjectInLazyHandle(m_hAdditionalEvidence, evidence, m_pLoaderAllocator);
-    m_fAdditionalEvidence = TRUE;
-}
-
-BOOL AssemblySecurityDescriptor::HasAdditionalEvidence()
-{
-    LIMITED_METHOD_CONTRACT;
-    return m_fAdditionalEvidence;
-}
-
-OBJECTREF AssemblySecurityDescriptor::GetAdditionalEvidence()
-{
-    WRAPPER_NO_CONTRACT;
-    return ObjectFromLazyHandle(m_hAdditionalEvidence, m_pLoaderAllocator);
-}
-#endif // FEATURE_CAS_POLICY
-
-#ifndef FEATURE_CORECLR 
-BOOL AssemblySecurityDescriptor::AllowApplicationSpecifiedAppDomainManager()
-{
-    WRAPPER_NO_CONTRACT;
 
-    // Only fully trusted assemblies are allowed to specify their AppDomainManager in a config file
-    return this->IsFullyTrusted();
-}
-#endif // FEATURE_CORECLR
 
 // Check to make sure that security will allow this assembly to load.  Throw an exception if the assembly
 // should be forbidden from loading for security related purposes
diff --git a/src/vm/securitydescriptorassembly.h b/src/vm/securitydescriptorassembly.h
index 15bc83eef6..d414de033d 100644
--- a/src/vm/securitydescriptorassembly.h
+++ b/src/vm/securitydescriptorassembly.h
@@ -65,15 +65,6 @@ private:
     COR_TRUST                                *m_pSignature;            // Contains the publisher, requested permission
     SharedSecurityDescriptor                 *m_pSharedSecDesc;        // Shared state for assemblies loaded into multiple appdomains
 
-#ifdef FEATURE_CAS_POLICY
-    LOADERHANDLE m_hRequiredPermissionSet;  // Required Requested Permissions
-    LOADERHANDLE m_hOptionalPermissionSet;  // Optional Requested Permissions
-    LOADERHANDLE m_hDeniedPermissionSet;    // Denied Permissions
-
-    BOOL                m_fAdditionalEvidence;
-    BOOL                m_fIsSignatureLoaded;
-    BOOL                m_fAssemblyRequestsComputed;
-#endif // FEATURE_CAS_POLICY
 
     BOOL                m_fMicrosoftPlatform;
     BOOL                m_fAllowSkipVerificationInFullTrust;
@@ -108,28 +99,7 @@ public:
     virtual void PropagatePermissionSet(OBJECTREF GrantedPermissionSet, OBJECTREF DeniedPermissionSet, DWORD dwSpecialFlags);
 #endif	// !DACCESS_COMPILE
 
-#ifdef FEATURE_CAS_POLICY
-    virtual HRESULT LoadSignature(COR_TRUST **ppSignature = NULL);
-    virtual OBJECTREF GetEvidence();
-    DWORD GetZone();
-
-    OBJECTREF GetRequestedPermissionSet(OBJECTREF *pOptionalPermissionSet, OBJECTREF *pDeniedPermissionSet);
-
-    virtual void SetRequestedPermissionSet(OBJECTREF RequiredPermissionSet,
-                                          OBJECTREF OptionalPermissionSet,
-                                          OBJECTREF DeniedPermissionSet);
-
-#ifndef DACCESS_COMPILE
-    virtual void SetAdditionalEvidence(OBJECTREF evidence);
-    virtual BOOL HasAdditionalEvidence();
-    virtual OBJECTREF GetAdditionalEvidence();
-    virtual void SetEvidenceFromPEFile(IPEFileSecurityDescriptor *pPEFileSecDesc);
-#endif	// !DACCESS_COMPILE
-#endif // FEATURE_CAS_POLICY
 	
-#ifndef FEATURE_CORECLR 
-    virtual BOOL AllowApplicationSpecifiedAppDomainManager();
-#endif // !FEATURE_CORECLR
 
     virtual void CheckAllowAssemblyLoad();
 
@@ -139,18 +109,7 @@ private:
 
     void ResolveWorker();
 
-#ifdef FEATURE_CAS_POLICY
-    inline BOOL IsAssemblyRequestsComputed();
-    inline BOOL IsSignatureLoaded();
-    inline void SetSignatureLoaded();
-#endif
 
-#ifdef FEATURE_APTCA
-    // If you think you need to call this method, you're probably wrong.  We shouldn't be making any
-    // security enforcement decisions based upon this result -- it's strictly for ensuring that we load
-    // conditional APTCA assemblies correctly.
-    inline BOOL IsConditionalAptca();
-#endif // FEATURE_APTCA
 
 #endif // #ifndef DACCESS_COMPILE
 };
diff --git a/src/vm/securitydescriptorassembly.inl b/src/vm/securitydescriptorassembly.inl
index 44b49a32c9..e12a6c5963 100644
--- a/src/vm/securitydescriptorassembly.inl
+++ b/src/vm/securitydescriptorassembly.inl
@@ -35,38 +35,7 @@ inline void AssemblySecurityDescriptor::TryCachePassedDemand(PsetCacheEntry *pCa
         m_arrPassedLinktimeDemands[m_dwNumPassedDemands++] = pCasDemands;
 }
 
-#ifdef FEATURE_CAS_POLICY
 
-inline BOOL AssemblySecurityDescriptor::IsAssemblyRequestsComputed() 
-{
-    LIMITED_METHOD_CONTRACT;
-    return m_fAssemblyRequestsComputed;
-}
-
-inline BOOL AssemblySecurityDescriptor::IsSignatureLoaded()
-{
-    LIMITED_METHOD_CONTRACT;
-    return m_fIsSignatureLoaded;
-}
-
-inline void AssemblySecurityDescriptor::SetSignatureLoaded()
-{
-    LIMITED_METHOD_CONTRACT;
-    m_fIsSignatureLoaded = TRUE;
-}
-
-#endif // FEATURE_CAS_POLICY
-
-#ifdef FEATURE_APTCA
-
-inline BOOL AssemblySecurityDescriptor::IsConditionalAptca()
-{
-    WRAPPER_NO_CONTRACT;
-    ModuleSecurityDescriptor *pMSD = ModuleSecurityDescriptor::GetModuleSecurityDescriptor(m_pAssem->GetAssembly());
-    return (pMSD->GetTokenFlags() & TokenSecurityDescriptorFlags_ConditionalAPTCA) == TokenSecurityDescriptorFlags_ConditionalAPTCA;
-}
-
-#endif // FEATURE_APTCA
 
 #endif // !DACCESS_COMPILE
 
diff --git a/src/vm/securityhostprotection.cpp b/src/vm/securityhostprotection.cpp
deleted file mode 100644
index 45825135ae..0000000000
--- a/src/vm/securityhostprotection.cpp
+++ /dev/null
@@ -1,102 +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.
-// 
-
-//
-
-
-#include "common.h"
-#include "securityattributes.h"
-#include "security.h"
-#include "eeconfig.h"
-#include "corhost.h"
-
-CorHostProtectionManager::CorHostProtectionManager()
-{
-    CONTRACTL 
-    {
-        MODE_ANY;
-        GC_NOTRIGGER;
-        NOTHROW;
-    }CONTRACTL_END;
-
-    m_eProtectedCategories = eNoChecks;
-    m_fEagerSerializeGrantSet = false;
-    m_fFrozen = false;
-}
-
-HRESULT CorHostProtectionManager::QueryInterface(REFIID id, void **pInterface)
-{
-    WRAPPER_NO_CONTRACT;
-    STATIC_CONTRACT_SO_TOLERANT;
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES
-    if (id == IID_ICLRHostProtectionManager)
-    {
-        *pInterface = GetHostProtectionManager();
-        return S_OK;
-    }
-#endif // FEATURE_INCLUDE_ALL_INTERFACES
-    return E_NOINTERFACE;
-}
-
-ULONG CorHostProtectionManager::AddRef()
-{
-    LIMITED_METHOD_CONTRACT;
-    return 1;
-}
-
-ULONG CorHostProtectionManager::Release()
-{
-    LIMITED_METHOD_CONTRACT;
-    return 1;
-}
-
-void CorHostProtectionManager::Freeze()
-{
-    LIMITED_METHOD_CONTRACT;
-    m_fFrozen = true;
-}
-
-HRESULT CorHostProtectionManager::SetProtectedCategories(EApiCategories eProtectedCategories)
-{
-    LIMITED_METHOD_CONTRACT;
-    STATIC_CONTRACT_SO_TOLERANT;
-
-    if(m_fFrozen)
-        return E_FAIL;
-    if((eProtectedCategories | eAll) != eAll)
-        return E_FAIL;
-    m_eProtectedCategories = eProtectedCategories;
-    return S_OK;
-}
-
-EApiCategories CorHostProtectionManager::GetProtectedCategories()
-{
-    WRAPPER_NO_CONTRACT;
-
-    Freeze();
-    return m_eProtectedCategories;
-}
-
-bool CorHostProtectionManager::GetEagerSerializeGrantSets() const
-{
-    LIMITED_METHOD_CONTRACT;
-
-    // To provide more context about this flag in the hosting API, this is the case where, 
-    // during the unload of an appdomain, we need to serialize a grant set for a shared assembly 
-    // that has resolved policy in order to maintain the invariant that the same assembly loaded 
-    // into another appdomain created in the future will be granted the same permissions
-    // (since the current policy is potentially burned into the jitted code of the shared assembly already).
-
-    return m_fEagerSerializeGrantSet;
-}
-
-HRESULT CorHostProtectionManager::SetEagerSerializeGrantSets()
-{
-    LIMITED_METHOD_CONTRACT;
-    STATIC_CONTRACT_SO_TOLERANT;
-
-    m_fEagerSerializeGrantSet = true;
-    return S_OK;
-}
diff --git a/src/vm/securityhostprotection.h b/src/vm/securityhostprotection.h
deleted file mode 100644
index 11e814a976..0000000000
--- a/src/vm/securityhostprotection.h
+++ /dev/null
@@ -1,14 +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.
-// 
-
-//
-
-
-#ifndef __SECURITYHOSTPROTECTION_H__
-#define __SECURITYHOSTPROTECTION_H__
-
-class CorHostProtectionManager;
-
-#endif // __SECURITYHOSTPROTECTION_H__
diff --git a/src/vm/securityimperative.cpp b/src/vm/securityimperative.cpp
deleted file mode 100644
index 677fd3c6da..0000000000
--- a/src/vm/securityimperative.cpp
+++ /dev/null
@@ -1,119 +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.
-// 
-
-
-//
-
-#include "common.h"
-#include "security.h"
-
-//-----------------------------------------------------------+
-// P R I V A T E   H E L P E R S
-//-----------------------------------------------------------+
-
-LPVOID GetSecurityObjectForFrameInternal(StackCrawlMark *stackMark, INT32 create, OBJECTREF *pRefSecDesc)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    // This is a package protected method. Assumes correct usage.
-
-    Thread *pThread = GetThread();
-    AppDomain * pAppDomain = pThread->GetDomain();
-
-    if (pRefSecDesc == NULL)
-    {
-        if (!Security::SkipAndFindFunctionInfo(stackMark, NULL, &pRefSecDesc, &pAppDomain))
-            return NULL;
-    }
-
-    if (pRefSecDesc == NULL)
-        return NULL;
-
-    // Is security object frame in a different context?
-    bool fSwitchContext;
-    fSwitchContext = pAppDomain != pThread->GetDomain();
-
-    if (create && *pRefSecDesc == NULL)
-    {
-        // If necessary, shift to correct context to allocate security object.
-        _ASSERTE(pAppDomain == GetAppDomain());
-        MethodTable* pMethFrameSecDesc = MscorlibBinder::GetClass(CLASS__FRAME_SECURITY_DESCRIPTOR);
-        *pRefSecDesc = AllocateObject(pMethFrameSecDesc);
-    }
-
-    // If we found or created a security object in a different context, make a
-    // copy in the current context.
-    LPVOID rv;
-    if (fSwitchContext && *pRefSecDesc != NULL)
-        *((OBJECTREF*)&rv) = AppDomainHelper::CrossContextCopyFrom(pAppDomain, pRefSecDesc);
-    else
-        *((OBJECTREF*)&rv) = *pRefSecDesc;
-
-    return rv;
-}
-
-FCIMPL2(Object*, SecurityRuntime::GetSecurityObjectForFrame, StackCrawlMark* stackMark, CLR_BOOL create)
-{
-    FCALL_CONTRACT;
-
-    OBJECTREF refRetVal = NULL;
-
-    HELPER_METHOD_FRAME_BEGIN_RET_0();
-
-    refRetVal = ObjectToOBJECTREF((Object*)GetSecurityObjectForFrameInternal(stackMark, create, NULL));
-
-    HELPER_METHOD_FRAME_END();
-    return OBJECTREFToObject(refRetVal);
-}
-FCIMPLEND
-
-void SecurityRuntime::CheckBeforeAllocConsole(AppDomain* pDomain, Assembly* pAssembly)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    // Tell the debugger not to start on any managed code that we call in this method    
-    FrameWithCookie<DebuggerSecurityCodeMarkFrame> __dbgSecFrame;
-
-    // Check that the assembly is granted unrestricted UIPermission
-    IAssemblySecurityDescriptor* pSecDesc = pAssembly->GetSecurityDescriptor(pDomain);
-    _ASSERTE(pSecDesc != NULL);
-    if (!pSecDesc->HasUnrestrictedUIPermission())
-    {
-        struct _gc {
-            OBJECTREF orDemand;
-            OBJECTREF orRefused;
-            OBJECTREF orGranted;
-        } gc;
-        ZeroMemory(&gc, sizeof(_gc));
-        GCPROTECT_BEGIN(gc);
-        {
-            // Get the necessary managed objects
-            gc.orGranted = pSecDesc->GetGrantedPermissionSet(&gc.orRefused);
-            SecurityDeclarative::_GetSharedPermissionInstance(&gc.orDemand, UI_PERMISSION);
-
-            // Check that the assembly is granted the necessary permission
-            SecurityStackWalk sw(SSWT_DEMAND_FROM_NATIVE, NULL);
-            sw.m_objects.SetObjects(gc.orDemand, NULL);
-            sw.CheckPermissionAgainstGrants(NULL, gc.orGranted, gc.orRefused, pDomain, NULL, pAssembly);
-        }
-        GCPROTECT_END();
-    }
-
-    // Now do a demand against everything on the stack for unrestricted UIPermission
-    Security::SpecialDemand(SSWT_DEMAND_FROM_NATIVE, UI_PERMISSION);
-
-    // Pop the debugger frame
-    __dbgSecFrame.Pop();
-}
-
-
diff --git a/src/vm/securityimperative.h b/src/vm/securityimperative.h
deleted file mode 100644
index f161f57cb1..0000000000
--- a/src/vm/securityimperative.h
+++ /dev/null
@@ -1,36 +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.
-// 
-
-
-//
-
-
-#ifndef __ComSecurityRuntime_h__
-#define __ComSecurityRuntime_h__
-
-#include "common.h"
-
-#include "object.h"
-#include "util.hpp"
-
-// Forward declarations to avoid pulling in too many headers.
-class Frame;
-enum StackWalkAction;
-
-//-----------------------------------------------------------
-// The SecurityRuntime implements all the native methods
-// for the managed class System.Security.SecurityRuntime
-//-----------------------------------------------------------
-namespace SecurityRuntime
-{
-//public:
-    // private helper for getting a security object
-    FCDECL2(Object*, GetSecurityObjectForFrame, StackCrawlMark* stackMark, CLR_BOOL create);
-//protected:
-    void CheckBeforeAllocConsole(AppDomain* pDomain, Assembly* pAssembly);
-};
-
-#endif /* __ComSecurityRuntime_h__ */
-
diff --git a/src/vm/securitymeta.cpp b/src/vm/securitymeta.cpp
index 980958d49f..7cc8b65426 100644
--- a/src/vm/securitymeta.cpp
+++ b/src/vm/securitymeta.cpp
@@ -21,7 +21,6 @@
 #include "security.h"
 
 #include "perfcounters.h"
-#include "nlstable.h"
 #include "frames.h"
 #include "dllimport.h"
 #include "strongname.h"
@@ -30,11 +29,9 @@
 #include "threads.h"
 #include "eventtrace.h"
 #ifdef FEATURE_REMOTING
-#include "appdomainhelper.h"
 #include "objectclone.h"
 #endif //FEATURE_REMOTING
 #include "typestring.h"
-#include "stackcompressor.h"
 #include "securitydeclarative.h"
 #include "customattribute.h"
 #include "../md/compiler/custattr.h"
@@ -57,9 +54,6 @@ void FieldSecurityDescriptor::VerifyDataComputed()
         return;
     }
 
-#ifndef FEATURE_CORECLR
-    FieldSecurityDescriptorTransparencyEtwEvents etw(this);
-#endif // !FEATURE_CORECLR
 
 #ifdef _DEBUG
     // If we've setup a breakpoint when we compute the transparency of this field, then stop in the debugger
@@ -284,9 +278,6 @@ void MethodSecurityDescriptor::ComputeCriticalTransparentInfo()
     }
     CONTRACTL_END;
 
-#ifndef FEATURE_CORECLR
-    MethodSecurityDescriptorTransparencyEtwEvents etw(this);
-#endif // !FEATURE_CORECLR
 
     MethodTable* pMT = m_pMD->GetMethodTable();
 
@@ -740,72 +731,6 @@ void MethodSecurityDescriptor::InvokeInheritanceChecks(MethodDesc *pChildMD)
         }
     }
 
-#ifndef FEATURE_CORECLR
-    // Check CAS Inheritance
-
-    // Early out if we're fully trusted
-    if (SecurityDeclarative::FullTrustCheckForLinkOrInheritanceDemand(pChildMD->GetAssembly()))
-    {
-        return;
-    }
-
-    if (HasInheritanceDeclarativeSecurity())
-    {
-#ifdef CROSSGEN_COMPILE
-        // NGen is always full trust. This path should be unreachable.
-        CrossGenNotSupported("HasInheritanceDeclarativeSecurity()");
-#else // CROSSGEN_COMPILE
-        GCX_COOP();
-
-        OBJECTREF refCasDemands = NULL;
-        PsetCacheEntry* pCasDemands = NULL;
-
-        HRESULT hr = GetDeclaredPermissionsWithCache(dclInheritanceCheck, &refCasDemands, &pCasDemands);
-        if (refCasDemands != NULL)
-        {
-            _ASSERTE(pCasDemands != NULL);
-
-            // See if inheritor's assembly has passed this demand before
-            AssemblySecurityDescriptor *pInheritorAssem = static_cast<AssemblySecurityDescriptor*>(pChildMD->GetAssembly()->GetSecurityDescriptor());
-            BOOL fSkipCheck = pInheritorAssem->AlreadyPassedDemand(pCasDemands);
-
-            if (!fSkipCheck)
-            {
-                GCPROTECT_BEGIN(refCasDemands);
-
-                // Perform the check (it's really just a LinkDemand)
-                SecurityStackWalk::LinkOrInheritanceCheck(pChildMD->GetAssembly()->GetSecurityDescriptor(), refCasDemands, pChildMD->GetAssembly(), dclInheritanceCheck);
-
-                // Demand passed. Add it to the Inheritor's assembly's list of passed demands
-                pInheritorAssem->TryCachePassedDemand(pCasDemands);
-
-                GCPROTECT_END();
-            }
-        }
-
-        // @todo -- non cas shouldn't be used for inheritance demands... 
-
-        // Check non-CAS Inheritance
-        OBJECTREF refNonCasDemands = NULL;
-        hr = GetDeclaredPermissionsWithCache( dclNonCasInheritance, &refNonCasDemands, NULL);
-        if (refNonCasDemands != NULL)
-        {
-            _ASSERTE(((PERMISSIONSETREF)refNonCasDemands)->CheckedForNonCas() && "Declarative permissions should have been checked for nonCAS in PermissionSet.CreateSerialized");
-            if (((PERMISSIONSETREF)refNonCasDemands)->ContainsNonCas())
-            {
-                GCPROTECT_BEGIN(refNonCasDemands);
-
-                // Perform the check
-                MethodDescCallSite demand(METHOD__PERMISSION_SET__DEMAND_NON_CAS, &refNonCasDemands);
-                ARG_SLOT arg = ObjToArgSlot(refNonCasDemands);
-                demand.Call(&arg);
-
-                GCPROTECT_END();
-            }
-        }
-#endif // CROSSGEN_COMPILE
-    }
-#endif // FEATURE_CORECLR
 }
 
 MethodSecurityDescriptor::MethodImplementationIterator::MethodImplementationIterator(MethodDesc *pMD)
@@ -978,117 +903,6 @@ TypeSecurityDescriptor* TypeSecurityDescriptor::GetTypeSecurityDescriptor(Method
     return pTypeSecurityDesc;
 }
 
-#if !defined(CROSSGEN_COMPILE) && defined(FEATURE_CAS_POLICY)
-HRESULT TokenDeclActionInfo::GetDeclaredPermissionsWithCache(
-    IN CorDeclSecurity action,
-    OUT OBJECTREF *pDeclaredPermissions,
-                                OUT PsetCacheEntry **pPCE)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-    HRESULT         hr = S_OK;
-    DWORD dwActionFlag = DclToFlag((CorDeclSecurity)action);
-
-    PsetCacheEntry *ptempPCE=NULL;
-    TokenDeclActionInfo* pCurrentAction = this;
-    for (;
-        pCurrentAction;
-        pCurrentAction = pCurrentAction->pNext)
-    {
-        if (pCurrentAction->dwDeclAction == dwActionFlag)
-        {
-                ptempPCE = pCurrentAction->pPCE;
-            break;
-        }
-    }
-    if (pDeclaredPermissions && pCurrentAction)
-    {
-        *pDeclaredPermissions = ptempPCE->CreateManagedPsetObject (action);
-    }
-    if (pPCE && pCurrentAction)
-    {
-        *pPCE = ptempPCE;
-    }
-
-    return hr;
-}
-
-OBJECTREF TokenDeclActionInfo::GetLinktimePermissions(OBJECTREF *prefNonCasDemands)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-
-    OBJECTREF refCasDemands = NULL;
-    GCPROTECT_BEGIN(refCasDemands);
-
-    GetDeclaredPermissionsWithCache(
-        dclLinktimeCheck,
-        &refCasDemands, NULL);
-
-    TokenDeclActionInfo::GetDeclaredPermissionsWithCache(
-        dclNonCasLinkDemand,
-        prefNonCasDemands, NULL);
-
-    GCPROTECT_END();
-    return refCasDemands;    
-}
-
-void TokenDeclActionInfo::InvokeLinktimeChecks(Assembly* pCaller)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        INJECT_FAULT(COMPlusThrowOM(););
-        PRECONDITION(CheckPointer(pCaller));
-    }
-    CONTRACTL_END;
-
-#ifdef FEATURE_MULTICOREJIT
-    
-    // Reset the flag to allow managed code to be called in multicore JIT background thread from this routine
-    ThreadStateNCStackHolder holder(-1, Thread::TSNC_CallingManagedCodeDisabled);
-
-#endif
-
-    struct gc
-    {
-        OBJECTREF refNonCasDemands;
-        OBJECTREF refCasDemands;
-    }
-    gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc);
-
-    // CAS LinkDemands
-    GetDeclaredPermissionsWithCache(dclLinktimeCheck,
-                                    &gc.refCasDemands,
-                                    NULL);
-
-    if (gc.refCasDemands != NULL)
-    {
-        SecurityStackWalk::LinkOrInheritanceCheck(pCaller->GetSecurityDescriptor(), gc.refCasDemands, pCaller, dclLinktimeCheck);
-    }
-
-    // NON CAS LinkDEMANDS (we shouldn't support this).
-    GetDeclaredPermissionsWithCache(dclNonCasLinkDemand,
-                                    &gc.refNonCasDemands,
-                                    NULL);
-
-    GCPROTECT_END();
-}
-#endif // !CROSSGEN_COMPILE && FEATURE_CAS_POLICY
 
 void TypeSecurityDescriptor::ComputeCriticalTransparentInfo()
 {
@@ -1100,9 +914,6 @@ void TypeSecurityDescriptor::ComputeCriticalTransparentInfo()
     }
     CONTRACTL_END;
 
-#ifndef FEATURE_CORECLR
-    TypeSecurityDescriptorTransparencyEtwEvents etw(this);
-#endif // !FEATURE_CORECLR
 
 #ifdef _DEBUG
     // If we've setup a breakpoint when we compute the transparency of this type, then stop in the debugger now
@@ -1241,9 +1052,6 @@ void TypeSecurityDescriptor::ComputeCriticalTransparentInfo()
     // Update the cached values in the EE Class.
     g_IBCLogger.LogEEClassCOWTableAccess(m_pMT);
     pClass->SetCriticalTransparentInfo(
-#ifndef FEATURE_CORECLR
-                                        typeFlags & (TypeSecurityDescriptorFlags_IsCritical | TypeSecurityDescriptorFlags_IsAllCritical),
-#endif // FEATURE_CORECLR
                                         typeFlags & TypeSecurityDescriptorFlags_IsTreatAsSafe,
                                         typeFlags & TypeSecurityDescriptorFlags_IsAllTransparent,
                                         typeFlags & TypeSecurityDescriptorFlags_IsAllCritical);
@@ -1485,73 +1293,6 @@ void TypeSecurityDescriptor::InvokeInheritanceChecks(MethodTable* pChildMT)
         }
     }
 
-#ifndef FEATURE_CORECLR
-    // Fast path check
-    if (SecurityDeclarative::FullTrustCheckForLinkOrInheritanceDemand(pChildMT->GetAssembly()))
-    {
-        return;
-    }
-
-    if (HasInheritanceDeclarativeSecurity())
-    {
-#ifdef CROSSGEN_COMPILE
-        // NGen is always full trust. This path should be unreachable.
-        CrossGenNotSupported("HasInheritanceDeclarativeSecurity()");
-#else // CROSSGEN_COMPILE
-        GCX_COOP();
-
-        // If we have a class that requires inheritance checks,
-        // then we require a thread to perform the checks.
-        // We won't have a thread when some of the system classes
-        // are preloaded, so make sure that none of them have
-        // inheritance checks.
-        _ASSERTE(GetThread() != NULL);
-
-        struct
-        {
-            OBJECTREF refCasDemands;
-            OBJECTREF refNonCasDemands;
-        }
-        gc;
-        ZeroMemory(&gc, sizeof(gc));
-
-        GCPROTECT_BEGIN(gc);        
-
-        EEClass *pClass = m_pMT->GetClass();
-        if (pClass->RequiresCasInheritanceCheck())
-        {
-            GetDeclaredPermissionsWithCache(dclInheritanceCheck, &gc.refCasDemands, NULL);
-        }
-
-        if (pClass->RequiresNonCasInheritanceCheck())
-        {
-            GetDeclaredPermissionsWithCache(dclNonCasInheritance, &gc.refNonCasDemands, NULL);
-        }
-
-        if (gc.refCasDemands != NULL)
-        {
-            SecurityStackWalk::LinkOrInheritanceCheck(pChildMT->GetAssembly()->GetSecurityDescriptor(),
-                                                      gc.refCasDemands,
-                                                      pChildMT->GetAssembly(),
-                                                      dclInheritanceCheck);
-        }
-
-        if (gc.refNonCasDemands != NULL)
-        {
-            _ASSERTE(((PERMISSIONSETREF)gc.refNonCasDemands)->CheckedForNonCas() && "Declarative permissions should have been checked for nonCAS in PermissionSet.CreateSerialized");
-            if(((PERMISSIONSETREF)gc.refNonCasDemands)->ContainsNonCas())
-            {
-                MethodDescCallSite demand(METHOD__PERMISSION_SET__DEMAND_NON_CAS, &gc.refNonCasDemands);
-
-                ARG_SLOT arg = ObjToArgSlot(gc.refNonCasDemands);
-                demand.Call(&arg);
-            }
-        }
-
-        GCPROTECT_END();
-#endif // CROSSGEN_COMPILE
-    }
-#endif // FEATURE_CORECLR        
 }
 
 // Module security descriptor contains static security information about the module
@@ -1572,9 +1313,6 @@ void ModuleSecurityDescriptor::VerifyDataComputed()
         return;    
     }
 
-#ifndef FEATURE_CORECLR
-    ModuleSecurityDescriptorTransparencyEtwEvents etw(this);
-#endif // !FEATURE_CORECLR
 
     // Read the security attributes from the assembly
     Assembly *pAssembly = m_pModule->GetAssembly();
@@ -1584,24 +1322,7 @@ void ModuleSecurityDescriptor::VerifyDataComputed()
     // choosing.
     TokenSecurityDescriptorFlags tokenFlags = GetTokenFlags();
 
-#ifdef FEATURE_APTCA
-    // We need to post-process the APTCA bits on the token security descriptor to handle:
-    //  1. Conditional APTCA assemblies, which should appear as either APTCA-enabled or APTCA-disabled
-    //  2. APTCA killbitted assemblies, which should appear as APTCA-disabled
-    tokenFlags = ProcessAssemblyAptcaFlags(pAssembly->GetDomainAssembly(), tokenFlags);
-#endif // FEATURE_APTCA
 
-#ifndef FEATURE_CORECLR
-    // Make sure we understand the security rule set being asked for
-    if (GetSecurityRuleSet() < SecurityRuleSet_Min || GetSecurityRuleSet() > SecurityRuleSet_Max)
-    {
-        // Unknown rule set - fail to load this module
-        SString strAssemblyName;
-        pAssembly->GetDisplayName(strAssemblyName);
-        COMPlusThrow(kFileLoadException, IDS_E_UNKNOWN_SECURITY_RULESET, strAssemblyName.GetUnicode());
-    }
-
-#endif // !FEATURE_CORECLR
 
     // Get a transparency behavior object for the assembly.
     const SecurityTransparencyBehavior *pTransparencyBehavior =
@@ -1692,14 +1413,6 @@ void ModuleSecurityDescriptor::VerifyDataComputed()
         }
     }
 
-#ifdef FEATURE_APTCA
-    // If the security model implies that unsigned assemblies are APTCA, then check to see if we're unsigned
-    // and set the APTCA bit.
-    if (pTransparencyBehavior->DoesUnsignedImplyAPTCA() && !pAssembly->IsStrongNamed())
-    {
-        moduleFlags |= ModuleSecurityDescriptorFlags_IsAPTCA;
-    }
-#endif // FEATURE_APTCA
 
 #ifdef _DEBUG
     // If we're being forced to generate native code for this assembly which can be used in a partial trust
@@ -1722,40 +1435,6 @@ void ModuleSecurityDescriptor::VerifyDataComputed()
     _ASSERTE(m_flags == moduleFlags);
 }
 
-#ifndef FEATURE_CORECLR
-
-// Determine if this assembly was build against a version of the runtime that only supported legacy transparency
-BOOL ModuleSecurityDescriptor::AssemblyVersionRequiresLegacyTransparency()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        SO_INTOLERANT;
-    }
-    CONTRACTL_END;
-
-    BOOL fIsLegacyAssembly = FALSE;
-
-    // Check the manifest version number to see if we're a v1 or v2 assembly.  We specifically check for the
-    // manifest version to come back as a string that starts with either v1 or v2; if we get anything
-    // unexpected, we'll just use the default transparency implementation
-    LPCSTR szVersion = NULL;
-    IMDInternalImport *pmdImport = m_pModule->GetAssembly()->GetManifestImport();
-    if (SUCCEEDED(pmdImport->GetVersionString(&szVersion)))
-    {
-        if (szVersion != NULL && strlen(szVersion) > 2)
-        {
-            fIsLegacyAssembly = szVersion[0] == 'v' &&
-                                (szVersion[1] == '1' || szVersion[1] == '2');
-        }
-    }
-
-    return fIsLegacyAssembly;
-}
-
-#endif // !FEATURE_CORECLR
 
 ModuleSecurityDescriptor* ModuleSecurityDescriptor::GetModuleSecurityDescriptor(Assembly *pAssembly)
 {
@@ -1787,7 +1466,7 @@ VOID ModuleSecurityDescriptor::Fixup(DataImage *image)
 }
 #endif
 
-#if defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM)
+#if defined(FEATURE_CORESYSTEM)
 
 //---------------------------------------------------------------------------------------
 //
@@ -1830,7 +1509,7 @@ TokenSecurityDescriptorFlags ParseAptcaAttribute(const BYTE *pbAptcaBlob, DWORD
     return aptcaFlags;
 }
 
-#endif // defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM)
+#endif // defined(FEATURE_CORESYSTEM)
 
 //---------------------------------------------------------------------------------------
 //
@@ -1936,7 +1615,7 @@ TokenSecurityDescriptorFlags TokenSecurityDescriptor::ReadSecurityAttributes(IMD
             szAttributeNamespace != NULL &&
             strcmp(g_SecurityNS, szAttributeNamespace) == 0)
         {
-#if defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM)
+#if defined(FEATURE_CORESYSTEM)
             if (strcmp(g_SecurityAPTCA + sizeof(g_SecurityNS), szAttributeName) == 0)
             {
                 // Check the visibility parameter
@@ -1952,36 +1631,11 @@ TokenSecurityDescriptorFlags TokenSecurityDescriptor::ReadSecurityAttributes(IMD
                 flags |= aptcaFlags;
             }
             else
-#endif // defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM)
+#endif // defined(FEATURE_CORESYSTEM)
             if (strcmp(g_SecurityCriticalAttribute + sizeof(g_SecurityNS), szAttributeName) == 0)
             {
                 flags |= TokenSecurityDescriptorFlags_Critical;
 
-#ifndef FEATURE_CORECLR
-                // Check the SecurityCriticalScope parameter
-                const BYTE *pbAttributeBlob;
-                ULONG cbAttributeBlob;
-                
-                if (FAILED(pmdImport->GetCustomAttributeAsBlob(
-                    currentAttribute, 
-                    reinterpret_cast<const void **>(&pbAttributeBlob), 
-                    &cbAttributeBlob)))
-                {
-                    continue;
-                }
-                CustomAttributeParser cap(pbAttributeBlob, cbAttributeBlob);
-                if (SUCCEEDED(cap.SkipProlog()))
-                {
-                    UINT32 dwCriticalFlags;
-                    if (SUCCEEDED(cap.GetU4(&dwCriticalFlags)))
-                    {
-                        if (dwCriticalFlags == SecurityCriticalFlags_All)
-                        {
-                            flags |= TokenSecurityDescriptorFlags_AllCritical;
-                        }
-                    }
-                }
-#endif // !FEATURE_CORECLR
             }
             else if (strcmp(g_SecuritySafeCriticalAttribute + sizeof(g_SecurityNS), szAttributeName) == 0)
             {
@@ -1991,30 +1645,6 @@ TokenSecurityDescriptorFlags TokenSecurityDescriptor::ReadSecurityAttributes(IMD
             {
                 flags |= TokenSecurityDescriptorFlags_Transparent;
             }
-#ifndef FEATURE_CORECLR
-            else if (strcmp(g_SecurityRulesAttribute + sizeof(g_SecurityNS), szAttributeName) == 0)
-            {
-                const BYTE *pbAttributeBlob;
-                ULONG cbAttributeBlob;
-                
-                if (FAILED(pmdImport->GetCustomAttributeAsBlob(
-                    currentAttribute, 
-                    reinterpret_cast<const void **>(&pbAttributeBlob), 
-                    &cbAttributeBlob)))
-                {
-                    continue;
-                }
-                
-                TokenSecurityDescriptorFlags securityRulesFlags = 
-                    ParseSecurityRulesAttribute(pbAttributeBlob, cbAttributeBlob);
-                
-                flags |= securityRulesFlags;
-            }
-            else if (strcmp(g_SecurityTreatAsSafeAttribute + sizeof(g_SecurityNS), szAttributeName) == 0)
-            {
-                flags |= TokenSecurityDescriptorFlags_TreatAsSafe;
-            }
-#endif // !FEATURE_CORECLR
         }
     }
 
@@ -2042,9 +1672,6 @@ void TokenSecurityDescriptor::VerifySemanticDataComputed()
         return;
     }
 
-#ifndef FEATURE_CORECLR
-    TokenSecurityDescriptorTransparencyEtwEvents etw(this);
-#endif // !FEATURE_CORECLR
 
     bool fIsSemanticallyCritical = false;
     bool fIsSemanticallyTreatAsSafe = false;
diff --git a/src/vm/securitymeta.h b/src/vm/securitymeta.h
index d78b7bde54..8247204e56 100644
--- a/src/vm/securitymeta.h
+++ b/src/vm/securitymeta.h
@@ -158,10 +158,6 @@ inline SecurityRuleSet GetSecurityRuleSet(TokenSecurityDescriptorFlags flags);
 // Encode a security rule set into token flags - this reverses GetSecurityRuleSet
 inline TokenSecurityDescriptorFlags EncodeSecurityRuleSet(SecurityRuleSet ruleSet);
 
-#ifdef FEATURE_APTCA
-TokenSecurityDescriptorFlags ParseAptcaAttribute(const BYTE *pbAptcaBlob,
-                                                 DWORD cbAptcaBlob);
-#endif // FEATURE_APTCA
 
 TokenSecurityDescriptorFlags ParseSecurityRulesAttribute(const BYTE *pbSecurityRulesBlob,
                                                          DWORD cbSecurityRulesBlob);
@@ -575,9 +571,6 @@ inline ModuleSecurityDescriptorFlags operator&=(ModuleSecurityDescriptorFlags& l
 
 inline ModuleSecurityDescriptorFlags operator~(ModuleSecurityDescriptorFlags flags);
 
-#ifdef FEATURE_APTCA
-BOOL CheckAssemblyHasBeenKillBitted(LPASSEMBLYNAME pAssemblyName, ULARGE_INTEGER uliFileVersion);
-#endif
 
 // Module security descriptor, this class contains static security information about the module
 // this information will get persisted in the NGen image
@@ -636,19 +629,12 @@ public:
     // Get the rule set the assembly uses
     inline SecurityRuleSet GetSecurityRuleSet();
 
-#ifndef FEATURE_CORECLR
-    // Can fully trusted transparent code bypass verification
-    inline BOOL CanTransparentCodeSkipVerification();
-#endif // !FEATURE_CORECLR
 
-#if defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM)
+#if defined(FEATURE_CORESYSTEM)
     // Does the assembly allow partially trusted callers
     inline BOOL IsAPTCA();
-#endif // defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM)
+#endif // defined(FEATURE_CORESYSTEM)
 
-#ifndef FEATURE_CORECLR
-    BOOL AssemblyVersionRequiresLegacyTransparency();
-#endif // !FEATURE_CORECLR
 
 private:
     // Helper class which fires transparency calculation begin/end ETW events
diff --git a/src/vm/securitymeta.inl b/src/vm/securitymeta.inl
index adb6faa5ac..59525d783a 100644
--- a/src/vm/securitymeta.inl
+++ b/src/vm/securitymeta.inl
@@ -411,30 +411,8 @@ inline BOOL MethodSecurityDescriptor::IsDeclSecurityCASDemandsOnly(DWORD dwMethD
     }
     CONTRACTL_END;
 
-#ifdef FEATURE_CORECLR
     // Non-CAS demands are not supported in CoreCLR
     return TRUE;
-#else
-    GCX_COOP();
-
-    PsetCacheEntry *tokenSetIndexes[dclMaximumValue + 1];
-    SecurityDeclarative::DetectDeclActionsOnToken(_mdToken, dwMethDeclFlags, tokenSetIndexes, pInternalImport);
-    SecurityProperties sp(dwMethDeclFlags);
-    if (!sp.FDemandsOnly())
-        return FALSE;
-        
-    DWORD dwLocalAction;
-    bool builtInCASPermsOnly = true;
-    for (dwLocalAction = 0; dwLocalAction <= dclMaximumValue && builtInCASPermsOnly; dwLocalAction++)
-    {
-        if (tokenSetIndexes[dwLocalAction] != NULL)
-        {
-            builtInCASPermsOnly = builtInCASPermsOnly && (tokenSetIndexes[dwLocalAction]->ContainsBuiltinCASPermsOnly(dwLocalAction));
-        }
-    }
-
-    return (builtInCASPermsOnly); // we only get here if there are only demands...so it suffices to return this value directly
-#endif
 }
 
 #ifndef DACCESS_COMPILE
@@ -632,9 +610,6 @@ inline BOOL TypeSecurityDescriptor::IsCritical()
     }
 
     return  pClass->IsAllCritical()
-#ifndef FEATURE_CORECLR
-            || pClass->IsCritical()
-#endif // !FEATURE_CORECLR
             ;
 }
 
@@ -1101,25 +1076,15 @@ inline BOOL ModuleSecurityDescriptor::IsMixedTransparency()
     return !IsAllCritical() && !IsAllTransparent();
 }
 
-#ifndef FEATURE_CORECLR
 
-inline BOOL ModuleSecurityDescriptor::CanTransparentCodeSkipVerification()
-{
-    WRAPPER_NO_CONTRACT;
-    VerifyDataComputed();
-    return !!(m_flags & ModuleSecurityDescriptorFlags_SkipFullTrustVerification);
-}
-
-#endif // !FEATURE_CORECLR
-
-#if defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM)
+#if defined(FEATURE_CORESYSTEM)
 inline BOOL ModuleSecurityDescriptor::IsAPTCA()
 {
     WRAPPER_NO_CONTRACT;
     VerifyDataComputed();
     return !!(m_flags & ModuleSecurityDescriptorFlags_IsAPTCA);
 }
-#endif // defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM)
+#endif // defined(FEATURE_CORESYSTEM)
 
 // Get the set of security rules that the assembly is using
 inline SecurityRuleSet ModuleSecurityDescriptor::GetSecurityRuleSet()
@@ -1139,12 +1104,6 @@ inline SecurityRuleSet ModuleSecurityDescriptor::GetSecurityRuleSet()
     {
         return ::GetSecurityRuleSet(tokenFlags);
     }
-#ifndef FEATURE_CORECLR
-    else if (AssemblyVersionRequiresLegacyTransparency())
-    {
-        return SecurityRuleSet_Level1;
-    }
-#endif // !FEATURE_CORECLR
     else
     {
         // The assembly hasn't specified the rule set that it needs to use.  We'll just use the default rule
diff --git a/src/vm/securitypolicy.cpp b/src/vm/securitypolicy.cpp
index fe1da90b8d..e9eb4e3aed 100644
--- a/src/vm/securitypolicy.cpp
+++ b/src/vm/securitypolicy.cpp
@@ -30,66 +30,6 @@ void SecurityProperties::operator delete(void *pMem)
     // No action required
 }
 
-#ifdef FEATURE_CAS_POLICY
-
-// static
-CrstStatic SecurityPolicy::s_crstPolicyInit;
-
-// static
-bool SecurityPolicy::s_fPolicyInitialized = false;
-
-void SecurityPolicy::InitPolicyConfig()
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    } CONTRACTL_END;
-
-    GCX_PREEMP();
-
-    CrstHolder initializePolicy(&s_crstPolicyInit);
-
-    if (!s_fPolicyInitialized)
-    {
-        // Note: These buffers should be at least as big as the longest possible
-        // string that will be placed into them by the code below.
-        const size_t cchcache = MAX_LONGPATH + sizeof( W("defaultusersecurity.config.cch") ) / sizeof( WCHAR ) + 1;
-        const size_t cchconfig = MAX_LONGPATH + sizeof( W("defaultusersecurity.config.cch") ) / sizeof( WCHAR ) + 1;
-        NewArrayHolder<WCHAR> cache(new WCHAR[cchcache]);
-        NewArrayHolder<WCHAR> config(new WCHAR[cchconfig]);
-
-        HRESULT hr = SecurityConfig::GetMachineDirectory(config, MAX_LONGPATH);
-        if (FAILED(hr))
-            ThrowHR(hr);
-
-        wcscat_s( config, cchconfig, W("security.config") );
-        wcscpy_s( cache, cchcache, config );
-        wcscat_s( cache, cchcache, W(".cch") );
-        SecurityConfig::InitData( SecurityConfig::MachinePolicyLevel, config, cache );
-
-        hr = SecurityConfig::GetMachineDirectory(config, MAX_LONGPATH);
-        if (FAILED(hr))
-            ThrowHR(hr);
-
-        wcscat_s( config, cchconfig, W("enterprisesec.config") );
-        wcscpy_s( cache, cchcache, config );
-        wcscat_s( cache, cchcache, W(".cch") );
-        SecurityConfig::InitData( SecurityConfig::EnterprisePolicyLevel, config, cache );
-
-        BOOL result = SecurityConfig::GetUserDirectory(config, MAX_LONGPATH);
-        if (result) {
-            wcscat_s( config, cchconfig, W("security.config") );
-            wcscpy_s( cache, cchcache, config );
-            wcscat_s( cache, cchcache, W(".cch") );
-            SecurityConfig::InitData( SecurityConfig::UserPolicyLevel, config, cache );
-        }
-
-        s_fPolicyInitialized = true;
-    }
-}
-#endif // FEATURE_CAS_POLICY
 
 void SecurityPolicy::Start()
 {
@@ -109,18 +49,6 @@ void SecurityPolicy::Start()
     _ASSERTE(URLZONE_UNTRUSTED == Untrusted);
 #endif // !FEATURE_PAL
 
-#ifdef FEATURE_CAS_POLICY
-    s_crstPolicyInit.Init(CrstSecurityPolicyInit);
-
-    SecurityConfig::Init();
-
-    if (Security::IsProcessWideLegacyCasPolicyEnabled())
-    {
-        SecurityPolicy::InitPolicyConfig();
-    }
-
-    g_pCertificateCache = new CertificateCache();
-#endif // FEATURE_CAS_POLICY
 }
 
 void SecurityPolicy::Stop()
@@ -134,50 +62,6 @@ void SecurityPolicy::Stop()
 
 }
 
-#ifdef FEATURE_CAS_POLICY
-void SecurityPolicy::SaveCache()
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    } CONTRACTL_END;
-
-    Thread *pThread = GetThread();
-    if (pThread == NULL)
-    {
-        BOOL fRet = FALSE;
-        EX_TRY
-        {
-            // If CLR is hosted, a host can deny a thread during SetupThread call.
-            if (IsShutdownSpecialThread())
-            {
-                SetupInternalThread();
-            }
-            else
-            {
-                SetupThread();
-            }
-        }
-        EX_CATCH
-        {
-            fRet = TRUE;
-        }
-        EX_END_CATCH(SwallowAllExceptions);
-        if (fRet)
-        {
-            return;
-        }
-    }
-
-    SecurityConfig::SaveCacheData( SecurityConfig::MachinePolicyLevel );
-    SecurityConfig::SaveCacheData( SecurityConfig::UserPolicyLevel );
-    SecurityConfig::SaveCacheData( SecurityConfig::EnterprisePolicyLevel );
-
-    SecurityConfig::Cleanup();
-}
-#endif
 
 void QCALLTYPE SecurityPolicy::GetGrantedPermissions(QCall::ObjectHandleOnStack retGranted, QCall::ObjectHandleOnStack retDenied, QCall::StackCrawlMarkHandle stackmark)
 {
@@ -228,58 +112,6 @@ void SecurityPolicy::CreateSecurityException(__in_z const char *szDemandClass, D
 
     MethodTable * pMT = MscorlibBinder::GetClass(CLASS__SECURITY_EXCEPTION);
 
-#ifdef FEATURE_CAS_POLICY
-    MethodTable * pMTSecPerm = MscorlibBinder::GetClass(CLASS__SECURITY_PERMISSION);
-
-    struct _gc {
-        STRINGREF strDemandClass;
-        OBJECTREF secPerm;
-        STRINGREF strPermState;
-        OBJECTREF secPermType;
-        OBJECTREF secElement;
-    } gc;
-    memset(&gc, 0, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc);
-
-    gc.strDemandClass = StringObject::NewString(wszDemandClass);
-    if (gc.strDemandClass == NULL) COMPlusThrowOM();
-    // Get the type seen by reflection
-    gc.secPermType = pMTSecPerm->GetManagedClassObject();
-    // Allocate the security exception object
-    *pThrowable = AllocateObject(pMT);
-    // Allocate the security permission object
-    gc.secPerm = AllocateObject(pMTSecPerm);
-
-    // Call the construtor with the correct flag
-    MethodDescCallSite ctor(METHOD__SECURITY_PERMISSION__CTOR);
-    ARG_SLOT arg3[2] = {
-        ObjToArgSlot(gc.secPerm),
-        (ARG_SLOT)dwFlags
-    };
-    ctor.Call(arg3);
-
-    // Now, get the ToXml method
-    MethodDescCallSite toXML(METHOD__SECURITY_PERMISSION__TOXML, &gc.secPerm);
-    ARG_SLOT arg4 = ObjToArgSlot(gc.secPerm);
-    gc.secElement = toXML.Call_RetOBJECTREF(&arg4);
-
-    MethodDescCallSite toString(METHOD__SECURITY_ELEMENT__TO_STRING, &gc.secElement);
-    ARG_SLOT arg5 = ObjToArgSlot(gc.secElement);
-    gc.strPermState = toString.Call_RetSTRINGREF(&arg5);
-
-    MethodDescCallSite exceptionCtor(METHOD__SECURITY_EXCEPTION__CTOR);
-
-    ARG_SLOT arg6[4] = {
-        ObjToArgSlot(*pThrowable),
-        ObjToArgSlot(gc.strDemandClass),
-        ObjToArgSlot(gc.secPermType),
-        ObjToArgSlot(gc.strPermState),
-    };
-    exceptionCtor.Call(arg6);
-
-    GCPROTECT_END();
-#else // FEATURE_CAS_POLICY
 
 	UNREFERENCED_PARAMETER(szDemandClass);
 	UNREFERENCED_PARAMETER(dwFlags);
@@ -288,7 +120,6 @@ void SecurityPolicy::CreateSecurityException(__in_z const char *szDemandClass, D
 	*pThrowable = AllocateObject(pMT);
 	CallDefaultConstructor(*pThrowable);
 
-#endif // FEATURE_CAS_POLICY
 }
 
 DECLSPEC_NORETURN void SecurityPolicy::ThrowSecurityException(__in_z const char *szDemandClass, DWORD dwFlags)
@@ -315,137 +146,6 @@ DECLSPEC_NORETURN void SecurityPolicy::ThrowSecurityException(__in_z const char
     GCPROTECT_END();
 }
 
-#ifdef FEATURE_CAS_POLICY
-//-----------------------------------------------------------------------------------------
-//
-// Fire an ETW event to indicate that an evidence object has been generated for an assembly
-//
-// Arguments:
-//    type    - Type of evidence that was generated
-//    pPEFile - PEFile for the assembly the evidence was for
-//
-
-// static
-void SecurityPolicy::TraceEvidenceGeneration(EvidenceType type, PEFile *pPEFile)
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pPEFile));
-        PRECONDITION(type >= kAssemblySupplied && type <= kZone);
-    }
-    CONTRACTL_END;
-
-    const SString& strPath = pPEFile->GetILimage()->GetPath();
-    FireEtwEvidenceGenerated(type,
-                             GetThread()->GetDomain()->GetId().m_dwId,
-                             strPath.IsEmpty() ? W("") : strPath.GetUnicode(),
-                             GetClrInstanceId());
-}
-
-// Called if CAS policy is not enabled, but we either have a host or a simple sandbox domain which will
-// determine the grant set of some evidence.
-OBJECTREF SecurityPolicy::ResolveGrantSet(OBJECTREF evidence, DWORD *pdwSpecialFlags, BOOL fCheckExecutionPermission)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(!GetAppDomain()->GetSecurityDescriptor()->IsLegacyCasPolicyEnabled());
-        PRECONDITION(CheckPointer(pdwSpecialFlags));
-    }
-    CONTRACTL_END;
-
-    struct
-    {
-        OBJECTREF evidence;
-        OBJECTREF grantSet;
-    }
-    gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    gc.evidence = evidence;
-
-    GCPROTECT_BEGIN(gc);
-
-    MethodDescCallSite resolve(METHOD__SECURITY_ENGINE__RESOLVE_GRANT_SET);
-    
-    ARG_SLOT args[3];
-    args[0] = ObjToArgSlot(gc.evidence);
-    args[1] = PtrToArgSlot(pdwSpecialFlags);
-    args[2] = BoolToArgSlot(fCheckExecutionPermission);
-
-    gc.grantSet = resolve.Call_RetOBJECTREF(args);
-
-    GCPROTECT_END();
-
-    return gc.grantSet;
-}
-
-// Resolve legacy CAS policy
-OBJECTREF SecurityPolicy::ResolveCasPolicy(OBJECTREF evidence,
-                                           OBJECTREF reqdPset,
-                                           OBJECTREF optPset,
-                                           OBJECTREF denyPset,
-                                           OBJECTREF* grantdenied,
-                                           DWORD* dwSpecialFlags,
-                                           BOOL checkExecutionPermission)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM(););
-        PRECONDITION(GetAppDomain()->GetSecurityDescriptor()->IsLegacyCasPolicyEnabled());
-        PRECONDITION(SecurityPolicy::s_fPolicyInitialized);
-        PRECONDITION(CheckPointer(dwSpecialFlags));
-    } CONTRACTL_END;
-
-
-    OVERRIDE_TYPE_LOAD_LEVEL_LIMIT(CLASS_LOADED);
-
-    // If we got here, then we are going to do at least one security
-    // check. Make sure security is initialized.
-
-    struct _gc {
-        OBJECTREF reqdPset;         // Required Requested Permissions
-        OBJECTREF optPset;          // Optional Requested Permissions
-        OBJECTREF denyPset;         // Denied Permissions
-        OBJECTREF evidence;         // Object containing evidence
-        OBJECTREF refRetVal;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-    gc.evidence = evidence;
-    gc.reqdPset = reqdPset;
-    gc.denyPset = denyPset;
-    gc.optPset = optPset;
-
-    GCPROTECT_BEGIN(gc);
-
-    MethodDescCallSite resolvePolicy(METHOD__SECURITY_MANAGER__RESOLVE_CAS_POLICY);
-
-    ARG_SLOT args[7];
-    args[0] = ObjToArgSlot(gc.evidence);
-    args[1] = ObjToArgSlot(gc.reqdPset);
-    args[2] = ObjToArgSlot(gc.optPset);
-    args[3] = ObjToArgSlot(gc.denyPset);
-    args[4] = PtrToArgSlot(grantdenied);
-    args[5] = PtrToArgSlot(dwSpecialFlags);
-    args[6] = BoolToArgSlot(checkExecutionPermission);
-
-    {
-        // Elevate thread's allowed loading level.  This can cause load failures if assemblies loaded from this point on require
-        // any assemblies currently being loaded.
-       OVERRIDE_LOAD_LEVEL_LIMIT(FILE_ACTIVE);
-        // call policy resolution routine in managed code
-        gc.refRetVal = resolvePolicy.Call_RetOBJECTREF(args);
-    }
-
-    GCPROTECT_END();
-    return gc.refRetVal;
-}
-#endif // FEATURE_CAS_POLICY
 
 #endif // CROSSGEN_COMPILE
 
@@ -501,139 +201,6 @@ BOOL SecurityPolicy::CanCallUnmanagedCode(Module *pModule)
 
 #ifndef CROSSGEN_COMPILE
 
-#ifdef FEATURE_CAS_POLICY
-SecZone QCALLTYPE SecurityPolicy::CreateFromUrl(LPCWSTR wszUrl)
-{
-    QCALL_CONTRACT;
-
-    SecZone dwZone = NoZone;
-
-    BEGIN_QCALL;
-
-    if (wszUrl != NULL)
-    {
-        dwZone = SecurityPolicy::MapUrlToZone(wszUrl);
-    }
-
-    END_QCALL;
-
-    return dwZone;
-}
-
-HRESULT
-GetSecurityPolicyRegKey(
-    __out WCHAR **ppszSecurityPolicy)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        INJECT_FAULT(return E_OUTOFMEMORY);
-    }
-    CONTRACTL_END;
-    
-    DWORD dwLen = 0;
-
-    HRESULT hr = g_pCLRRuntime->GetVersionString(NULL, &dwLen);
-    if (hr != HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER))
-        return hr;
-    
-    size_t bufSize = _countof(FRAMEWORK_REGISTRY_KEY_W) + 1 + dwLen + _countof(KEY_COM_SECURITY_POLICY);
-    NewArrayHolder<WCHAR> key(new(nothrow) WCHAR[bufSize]);
-    if (key == NULL)
-        return E_OUTOFMEMORY;
-    wcscpy_s(key, bufSize, FRAMEWORK_REGISTRY_KEY_W W("\\"));
-
-    hr = g_pCLRRuntime->GetVersionString(key + NumItems(FRAMEWORK_REGISTRY_KEY_W), &dwLen);
-    if (FAILED(hr))
-        return hr;
-    
-    size_t offset = _countof(FRAMEWORK_REGISTRY_KEY_W)+dwLen-1;
-    wcscpy_s(key + offset, bufSize - offset, KEY_COM_SECURITY_POLICY);
-    key.SuppressRelease();
-    *ppszSecurityPolicy = key;
-    return S_OK;
-} // GetSecurityPolicyRegKey
-
-HRESULT SecurityPolicy::ApplyCustomZoneOverride(SecZone *pdwZone)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        PRECONDITION(*pdwZone >= NumZones); 
-        INJECT_FAULT(return E_OUTOFMEMORY);
-    }
-    CONTRACTL_END;
-    
-    NewArrayHolder<WCHAR> key(NULL);
-    HRESULT hr = GetSecurityPolicyRegKey(&key);
-    if (FAILED(hr))
-        return hr;
-    if (REGUTIL::GetLong(KEY_COM_SECURITY_ZONEOVERRIDE, 0, key, HKEY_POLICY_ROOT) == 1)
-        *pdwZone=Internet;
-    return S_OK;
-} // ApplyCustomZoneOverride
-
-//---------------------------------------------------------------------------------------
-//
-// Determine which security zone a URL belongs to
-//
-// Arguments:
-//    wszUrl - URL to get zone information about
-//
-// Return Value:
-//    Security zone the URL belongs to
-//
-// Notes:
-//    If the runtime cannot map the URL, we'll return NoZone. A mapping to a zone that the VM doesn't
-//    know about will cause us to check the TreatCustomZonesAsInternetZone registry key and potentially
-//    map it back to the Internet zone.
-//
-
-// static
-SecZone SecurityPolicy::MapUrlToZone(__in_z LPCWSTR wszUrl)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(wszUrl != NULL);
-    }
-    CONTRACTL_END;
-
-    SecZone dwZone = NoZone;
-
-    ReleaseHolder<IInternetSecurityManager> securityManager = NULL;
-    HRESULT hr = CoInternetCreateSecurityManager(NULL, &securityManager, 0);
-
-    if (SUCCEEDED(hr))
-    {
-        _ASSERTE(sizeof(SecZone) == sizeof(DWORD));
-        hr = securityManager->MapUrlToZone(wszUrl, reinterpret_cast<DWORD *>(&dwZone), 0);
-
-        if (SUCCEEDED(hr))
-        {
-            // if this is a custom zone, see if the user wants us to map it back to the Internet zone
-            if (dwZone >= NumZones)
-            {
-                SecZone dwMappedZone = dwZone;
-                hr = ApplyCustomZoneOverride(&dwMappedZone);
-                if (SUCCEEDED(hr))
-                {
-                    dwZone = dwMappedZone;
-                }
-            }
-        }
-        else
-        {
-            dwZone = NoZone;
-        }
-    }
-
-    return dwZone;
-}
-#endif //FEATURE_CAS_POLICY
 
 BOOL QCALLTYPE SecurityPolicy::IsLocalDrive(LPCWSTR wszPath)
 {
@@ -790,130 +357,8 @@ void QCALLTYPE SecurityPolicy::GetDeviceName(LPCWSTR wszDriveLetter, QCall::Stri
 {
     QCALL_CONTRACT;
 
-#if !defined(FEATURE_CORECLR)
-    BEGIN_QCALL;
-
-    WCHAR networkName[MAX_LONGPATH];
-    DWORD networkNameSize = MAX_LONGPATH;
-    ZeroMemory( networkName, sizeof( networkName ) );
-
-    UINT driveType = WszGetDriveType( wszDriveLetter );
-    if (driveType == DRIVE_REMOVABLE ||
-        driveType == DRIVE_FIXED ||
-        driveType == DRIVE_CDROM ||
-        driveType == DRIVE_RAMDISK)
-    {
-        retDeviceName.Set( wszDriveLetter );
-        goto lExit;
-    }
-
-    if (WszWNetGetConnection(wszDriveLetter, networkName, &networkNameSize) != NO_ERROR)
-    {
-        goto lExit;
-    }
-
-    retDeviceName.Set( networkName );
-
-lExit: ;
-
-    END_QCALL;
-#endif // !FEATURE_CORECLR
-}
-
-#ifdef FEATURE_CAS_POLICY
-
-//
-// Fire the ETW event that signals that a specific type of evidence has been created
-// 
-// Arguments:
-//    pPEFile - PEFile the evidence was generated for
-//    type    - type of evidence generated
-//
-
-// static
-void QCALLTYPE SecurityPolicy::FireEvidenceGeneratedEvent(PEFile *pPEFile,
-                                                          EvidenceType type)
-{
-    CONTRACTL
-    {
-        QCALL_CHECK;
-        PRECONDITION(CheckPointer(pPEFile));
-    }
-    CONTRACTL_END;
-
-    BEGIN_QCALL;
-
-    TraceEvidenceGeneration(type, pPEFile);
-
-    END_QCALL;
-}
-
-// static
-
-void QCALLTYPE SecurityPolicy::GetEvidence(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retEvidence)
-{
-    QCALL_CONTRACT;
-
-    BEGIN_QCALL;
-
-    IAssemblySecurityDescriptor *pSecDesc = pAssembly->GetSecurityDescriptor();
-
-    _ASSERTE(pSecDesc->GetDomain() == GetAppDomain());
-
-    GCX_COOP();
-    if (pSecDesc->IsEvidenceComputed())
-        retEvidence.Set(pSecDesc->GetAdditionalEvidence());
-        else
-        retEvidence.Set(pSecDesc->GetEvidence());
-    
-    END_QCALL;
 }
 
-//---------------------------------------------------------------------------------------
-//
-// Determine if an evidence collection has a delay generated strong name evidence object
-// which was used during the process of demand evaluation.
-//
-// Arguments:
-//    orEvidence - evidence collection to examine
-//
-// Return Value:
-//    true if orEvidence contains unverified strong name evidence which has been used to generate a grant,
-//    false if orEvidence does not contain strong name evidence or that evidence was verified / not used
-//
-
-// static
-BOOL SecurityPolicy::WasStrongNameEvidenceUsed(OBJECTREF orEvidence)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-
-    // If we don't have any evidence, then there isn't any strong name evidence, and therefore it couldn't
-    // have been used.
-    if (orEvidence == NULL)
-    {
-        return FALSE;
-    }
-
-    BOOL fStrongNameEvidenceWasUsed = FALSE;
-
-    GCPROTECT_BEGIN(orEvidence);
-
-    MethodDescCallSite wasSnEvidenceUsed(METHOD__EVIDENCE__WAS_STRONGNAME_EVIDENCE_USED);
-
-    ARG_SLOT args[] = { ObjToArgSlot(orEvidence) };
-    fStrongNameEvidenceWasUsed = !!wasSnEvidenceUsed.Call_RetBool(args);
-    
-    GCPROTECT_END();
-
-    return fStrongNameEvidenceWasUsed;
-}
-#endif // FEATURE_CAS_POLICY
 
 FCIMPL0(void, SecurityPolicy::IncrementOverridesCount)
 {
@@ -951,269 +396,7 @@ FCIMPL0(void, SecurityPolicy::DecrementAssertCount)
 }
 FCIMPLEND
 
-#ifdef FEATURE_CAS_POLICY
-//
-// Evidence QCalls
-// 
-
-//---------------------------------------------------------------------------------------
-//
-// Get the assembly level permission requests
-//
-// Arguments:
-//    pAssembly              - Assembly to get the declarative security of
-//    retMinimumPermissions  - [out] RequestMinimum set of the assembly
-//    retOptionalPermissions - [out] RequestOptional set of the assembly
-//    retRefusedPermissions  - [out] RequestRefuse set of the assembly
-//
-
-// static
-void QCALLTYPE SecurityPolicy::GetAssemblyPermissionRequests(QCall::AssemblyHandle pAssembly,
-                                                             QCall::ObjectHandleOnStack retMinimumPermissions,
-                                                             QCall::ObjectHandleOnStack retOptionalPermissions,
-                                                             QCall::ObjectHandleOnStack retRefusedPermissions)
-{
-    QCALL_CONTRACT;
 
-    BEGIN_QCALL;
-
-
-    TraceEvidenceGeneration(kPermissionRequest, pAssembly->GetFile());
-    AssemblySecurityDescriptor *pSecurityDescriptor = static_cast<AssemblySecurityDescriptor*>(pAssembly->GetSecurityDescriptor());
-    
-    _ASSERTE(pSecurityDescriptor->GetDomain()->GetSecurityDescriptor()->IsLegacyCasPolicyEnabled());
-
-    struct
-    {
-        OBJECTREF objMinimumPermissions;
-        OBJECTREF objOptionalPermissions;
-        OBJECTREF objRefusedPermissions;
-    }
-    gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCX_COOP();
-    GCPROTECT_BEGIN(gc);
-
-    gc.objMinimumPermissions = pSecurityDescriptor->GetRequestedPermissionSet(&gc.objOptionalPermissions,
-                                                                              &gc.objRefusedPermissions);
-
-    retMinimumPermissions.Set(gc.objMinimumPermissions);
-    retOptionalPermissions.Set(gc.objOptionalPermissions);
-    retRefusedPermissions.Set(gc.objRefusedPermissions);
-
-    GCPROTECT_END();
-
-    END_QCALL;
-}
-
-//---------------------------------------------------------------------------------------
-//
-// Get the serialized evidence stream from an assembly
-//
-// Arguments:
-//    pPEFile               - PEFile to load the evidence stream from
-//    retSerializedEvidence - [out] contents of the serialized evidence
-//
-
-// static
-void QCALLTYPE SecurityPolicy::GetAssemblySuppliedEvidence(PEFile *pPEFile,
-                                                           QCall::ObjectHandleOnStack retSerializedEvidence)
-{
-    CONTRACTL
-    {
-        QCALL_CHECK;
-        PRECONDITION(CheckPointer(pPEFile));
-    }
-    CONTRACTL_END;
-
-    BEGIN_QCALL;
-
-    DWORD cbResource;
-    BYTE *pbResource;
-
-    // Load the resource from the PE file. We do not need to free this memory, since we're getting a direct
-    // pointer into the PE contents rather than a buffer.
-    TraceEvidenceGeneration(kAssemblySupplied, pPEFile);
-    BOOL fFoundSerializedEvidence = pPEFile->GetResource("Security.Evidence",
-                                                         &cbResource,
-                                                         &pbResource,
-                                                         NULL,
-                                                         NULL,
-                                                         NULL,
-                                                         NULL,
-                                                         FALSE,
-                                                         TRUE,
-                                                         NULL,
-                                                         NULL);
-
-    if (fFoundSerializedEvidence)
-    {
-        retSerializedEvidence.SetByteArray(pbResource, cbResource);
-    }
-
-    END_QCALL;
-}
-
-//---------------------------------------------------------------------------------------
-//
-// Get the zone and URL that the PEFile was loaded from
-//
-// Arguments:
-//    pPEFile  - PEFile to load the evidence stream from
-//    pZone    - [out] SecurityZone the file was loaded from
-//    retUrl   - [out] URL the file was loaded from
-
-// static
-void QCALLTYPE SecurityPolicy::GetLocationEvidence(PEFile *pPEFile,
-                                                   SecZone *pZone,
-                                                   QCall::StringHandleOnStack retUrl)
-{
-    CONTRACTL
-    {
-        QCALL_CHECK;
-        PRECONDITION(CheckPointer(pPEFile));
-    }
-    CONTRACTL_END;
-
-    BEGIN_QCALL;
-
-    StackSString ssCodeBase;
-    BYTE pbUniqueID[MAX_SIZE_SECURITY_ID];
-    DWORD cbUniqueID = COUNTOF(pbUniqueID);
-
-    // The location information is used to create Site, Url, and Zone evidence so fire all three events
-    TraceEvidenceGeneration(kSite, pPEFile);
-    TraceEvidenceGeneration(kUrl, pPEFile);
-    TraceEvidenceGeneration(kZone, pPEFile);
-
-    pPEFile->GetSecurityIdentity(ssCodeBase, pZone, 0, pbUniqueID, &cbUniqueID);
-    
-    retUrl.Set(ssCodeBase);
-    
-    END_QCALL;
-}
-
-//---------------------------------------------------------------------------------------
-//
-// Get the X.509 certificate that the PE file's Authenticode signature was created with
-//
-// Arguments:
-//    pPEFile        - PEFile to load the evidence stream from
-//    retCertificate - [out] certificate that signed the file
-
-// static
-void QCALLTYPE SecurityPolicy::GetPublisherCertificate(PEFile *pPEFile,
-                                                       QCall::ObjectHandleOnStack retCertificate)
-{
-    CONTRACTL
-    {
-        QCALL_CHECK;
-        PRECONDITION(CheckPointer(pPEFile));
-    }
-    CONTRACTL_END;
-
-    BEGIN_QCALL;
-
-    TraceEvidenceGeneration(kPublisher, pPEFile);
-    COR_TRUST *pAuthenticodeSignature = pPEFile->GetAuthenticodeSignature();
-    if (pAuthenticodeSignature != NULL && pAuthenticodeSignature->pbSigner != NULL)
-    {
-        retCertificate.SetByteArray(pAuthenticodeSignature->pbSigner, pAuthenticodeSignature->cbSigner);
-    }
-
-    END_QCALL;
-}
-
-//---------------------------------------------------------------------------------------
-//
-// Get the components of an assembly's strong name to generate strong name evidence with
-//
-// Arguments:
-//    pAssembly        - assembly to get the strong name of
-//    retPublicKeyBlob - [out] public component of the key the assembly is signed with
-//    retSimpleName    - [out] simple name of the file
-//    piMajorVersion   - [out] major version
-//    piMinorVersion   - [out] minor version
-//    piBuild          - [out] build
-//    piRevision       - [out] revision
-//
-// Notes:
-//    retPublicKeyBlob will be null for a simply named assembly
-//
-
-// static
-void QCALLTYPE SecurityPolicy::GetStrongNameInformation(QCall::AssemblyHandle pAssembly,
-                                                        QCall::ObjectHandleOnStack retPublicKeyBlob,
-                                                        QCall::StringHandleOnStack retSimpleName,
-                                                        USHORT *piMajorVersion,
-                                                        USHORT *piMinorVersion,
-                                                        USHORT *piBuild,
-                                                        USHORT *piRevision)
-{
-    CONTRACTL
-    {
-        QCALL_CHECK;
-        PRECONDITION(CheckPointer(piMajorVersion));
-        PRECONDITION(CheckPointer(piMinorVersion));
-        PRECONDITION(CheckPointer(piBuild));
-        PRECONDITION(CheckPointer(piRevision));
-    }
-    CONTRACTL_END;
-
-    BEGIN_QCALL;
-
-    PEAssembly *pPEAssembly = pAssembly->GetFile();
-    TraceEvidenceGeneration(kStrongName, pPEAssembly);
-
-    DWORD cbPublicKey;
-    const BYTE *pbPublicKey = reinterpret_cast<const BYTE*>(pPEAssembly->GetPublicKey(&cbPublicKey));
-
-    if (pbPublicKey != NULL && cbPublicKey > 0)
-    {
-        pPEAssembly->GetVersion(piMajorVersion, piMinorVersion, piBuild, piRevision);
-        retPublicKeyBlob.SetByteArray(pbPublicKey, cbPublicKey);
-        retSimpleName.Set(pPEAssembly->GetSimpleName());
-    }
-    else
-    {
-        GCX_COOP();
-        retPublicKeyBlob.Set(NULL);
-    }
-
-    END_QCALL;
-}
-
-#endif // FEATURE_CAS_POLICY
-
-#ifdef FEATURE_FUSION 
-static void GetFusionNameFromAssemblyQualifiedTypeName(LPCWSTR pAssemblyQualifedTypeName, IAssemblyName ** ppFusionName)
-{
-    STANDARD_VM_CONTRACT;
-
-    StackSString ssAssemblyQualifedTypeName(pAssemblyQualifedTypeName);
-    StackSString ssAssemblyName;
-
-    SString::Iterator iter = ssAssemblyQualifedTypeName.Begin();
-
-    if (ssAssemblyQualifedTypeName.Find( iter, ',' ))
-    {
-    iter++;
-    while (*iter == ' ' )
-        iter++;
-
-    ssAssemblyName.Set( ssAssemblyQualifedTypeName,
-                        iter,
-                        ssAssemblyQualifedTypeName.End() );
-}
-
-    StackScratchBuffer sBuffer;
-    AssemblySpec spec;
-    spec.Init(ssAssemblyName.GetANSI(sBuffer));
-
-    IfFailThrow(spec.CreateFusionName(ppFusionName));
-}
-#endif // FEATURE_FUSION 
 
 BOOL QCALLTYPE SecurityPolicy::IsSameType(LPCWSTR pLeft, LPCWSTR pRight)
 {
@@ -1225,36 +408,7 @@ BOOL QCALLTYPE SecurityPolicy::IsSameType(LPCWSTR pLeft, LPCWSTR pRight)
 
 // @telesto: Is this #ifdef-#else-#endif required anymore? Used to be needed when security was bypassing
 // loader and accessing Fusion interfaces. Seems like that's been fixed to use GetFusionNameFrom...
-#ifdef FEATURE_FUSION 
-
-    AppDomain* pDomain = GetAppDomain();
-    IApplicationContext* pAppCtx = pDomain->GetFusionContext();
-
-    _ASSERTE( pAppCtx != NULL && "Fusion context not setup yet" );
-
-    SafeComHolderPreemp<IAssemblyName> pAssemblyNameLeft;
-    SafeComHolderPreemp<IAssemblyName> pAssemblyNameRight;
-    
-    GetFusionNameFromAssemblyQualifiedTypeName(pLeft, &pAssemblyNameLeft);
-    GetFusionNameFromAssemblyQualifiedTypeName(pRight, &pAssemblyNameRight);
-
-    SafeComHolderPreemp<IAssemblyName> pAssemblyNamePostPolicyLeft;
-    SafeComHolderPreemp<IAssemblyName> pAssemblyNamePostPolicyRight;
-
-    if (FAILED(PreBindAssembly(pAppCtx, pAssemblyNameLeft,  NULL, &pAssemblyNamePostPolicyLeft,  NULL)) ||
-        FAILED(PreBindAssembly(pAppCtx, pAssemblyNameRight, NULL, &pAssemblyNamePostPolicyRight, NULL)))
-    {
-        // version-agnostic comparison.
-        bEqual = pAssemblyNameLeft->IsEqual(pAssemblyNameRight, ASM_CMPF_NAME | ASM_CMPF_PUBLIC_KEY_TOKEN | ASM_CMPF_CULTURE) == S_OK;
-    }
-    else
-    {
-        // version-agnostic comparison.
-        bEqual = pAssemblyNamePostPolicyLeft->IsEqual(pAssemblyNamePostPolicyRight, ASM_CMPF_NAME | ASM_CMPF_PUBLIC_KEY_TOKEN | ASM_CMPF_CULTURE) == S_OK;
-    }
-#else // FEATURE_FUSION
     bEqual=TRUE;
-#endif // FEATURE_FUSION
 
     END_QCALL;
 
diff --git a/src/vm/securitypolicy.h b/src/vm/securitypolicy.h
index ba77bcbda8..90b41324ad 100644
--- a/src/vm/securitypolicy.h
+++ b/src/vm/securitypolicy.h
@@ -36,9 +36,6 @@ class SystemNative;
 class NDirect;
 class SystemDomain;
 class AssemblySecurityDescriptor;
-#ifndef FEATURE_CORECLR
-class PEFileSecurityDescriptor;
-#endif
 class SharedSecurityDescriptor;
 class SecurityStackWalkData;
 class DemandStackWalk;
@@ -80,9 +77,6 @@ namespace SecurityPolicy
 #endif // #ifdef FEATURE_IMPERSONATION
 
     FCDECL0(FC_BOOL_RET, IsDefaultThreadSecurityInfo);
-#ifdef FEATURE_CAS_POLICY
-    SecZone QCALLTYPE CreateFromUrl(LPCWSTR wszUrl);
-#endif // FEATURE_CAS_POLICY
     void QCALLTYPE _GetLongPathName(LPCWSTR wszPath, QCall::StringHandleOnStack retLongPath);
     
     BOOL QCALLTYPE IsLocalDrive(LPCWSTR wszPath);
@@ -97,35 +91,6 @@ namespace SecurityPolicy
 
     FCDECL0(VOID, DecrementAssertCount);
 
-#ifdef FEATURE_CAS_POLICY
-    //
-    // Evidence QCalls
-    // 
-
-//public:
-    void QCALLTYPE FireEvidenceGeneratedEvent(PEFile *pPEFile, EvidenceType type);
-
-    void QCALLTYPE GetEvidence(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retEvidence);
-
-    void QCALLTYPE GetAssemblyPermissionRequests(QCall::AssemblyHandle pAssembly,
-                                                 QCall::ObjectHandleOnStack retMinimumPermissions,
-                                                 QCall::ObjectHandleOnStack retOptionalPermissions,
-                                                 QCall::ObjectHandleOnStack retRefusedPermissions);
-
-    void QCALLTYPE GetAssemblySuppliedEvidence(PEFile *pPEFile, QCall::ObjectHandleOnStack retSerializedEvidence);
-
-    void QCALLTYPE GetLocationEvidence(PEFile *pPEFile, SecZone *pZone, QCall::StringHandleOnStack retUrl);
-
-    void QCALLTYPE GetPublisherCertificate(PEFile *pPEFile, QCall::ObjectHandleOnStack retCertificate);
-
-    void QCALLTYPE GetStrongNameInformation(QCall::AssemblyHandle pAssembly,
-                                            QCall::ObjectHandleOnStack retPublicKeyBlob,
-                                            QCall::StringHandleOnStack retSimpleName,
-                                            USHORT *piMajorVersion,
-                                            USHORT *piMinorVersion,
-                                            USHORT *piBuild,
-                                            USHORT *piRevision);
-#endif // FEATURE_CAS_POLICY
 
 //private:
     // -----------------------------------------------------------
@@ -142,12 +107,6 @@ namespace SecurityPolicy
     //     <currently unused> @TODO: shouldn't EEShutDownHelper call this?
     void Stop();
 
-#ifdef FEATURE_CAS_POLICY
-    // Saves security cache data
-    //   Callers:
-    //     EEShutDownHelper
-    void SaveCache();
-#endif
 
 
     // -----------------------------------------------------------
@@ -169,41 +128,9 @@ namespace SecurityPolicy
 
     BOOL CanSkipVerification(DomainAssembly * pAssembly);
 
-#ifdef FEATURE_CAS_POLICY
-    void TraceEvidenceGeneration(EvidenceType type, PEFile *pPEFile);
-
-    // Map a URL to a zone, applying any user supplied policy
-    SecZone MapUrlToZone(__in_z LPCWSTR wszUrl);
-
-    // Apply user supplied policy to a zone
-    HRESULT ApplyCustomZoneOverride(SecZone *pdwZone);
-
-    // Determine what the grant set of an assembly is
-    OBJECTREF ResolveGrantSet(OBJECTREF evidence, OUT DWORD *pdwSpecialFlags, BOOL fcheckExecutionPermission);
-
-    // Resolve legacy CAS policy on the assembly
-    //   Callers:
-    //     SecurityDescriptor::ResolveWorker
-    OBJECTREF ResolveCasPolicy(OBJECTREF evidence,
-                                      OBJECTREF reqdPset,
-                                      OBJECTREF optPset,
-                                      OBJECTREF denyPset,
-                                      OBJECTREF* grantdenied,
-                                      DWORD* pdwSpecialFlags,
-                                      BOOL checkExecutionPermission);
-
-    // Load the policy config/cache files at EE startup
-    void InitPolicyConfig();
-
-    BOOL WasStrongNameEvidenceUsed(OBJECTREF evidence);
-#endif
     // Like WszGetLongPathName, but it works with nonexistant files too
     size_t GetLongPathNameHelper( const WCHAR* wszShortPath, SString& wszBuffer);
 
-#ifdef FEATURE_CAS_POLICY
-    extern CrstStatic s_crstPolicyInit;
-    extern bool s_fPolicyInitialized;
-#endif // FEATURE_CAS_POLICY
 }
 
 struct SharedPermissionObjects
@@ -234,20 +161,6 @@ struct SharedPermissionObjects
 // PermissionState.Unrestricted
 #define PERMISSION_STATE_UNRESTRICTED               1      // PermissionState.cs
 
-SELECTANY const SharedPermissionObjects g_rPermObjectsTemplate[] =
-{
-    {NULL, CLASS__SECURITY_PERMISSION, METHOD__SECURITY_PERMISSION__CTOR, SECURITY_PERMISSION_UNMANAGEDCODE },
-    {NULL, CLASS__SECURITY_PERMISSION, METHOD__SECURITY_PERMISSION__CTOR, SECURITY_PERMISSION_SKIPVERIFICATION },
-    {NULL, CLASS__REFLECTION_PERMISSION, METHOD__REFLECTION_PERMISSION__CTOR, REFLECTION_PERMISSION_TYPEINFO },
-    {NULL, CLASS__SECURITY_PERMISSION, METHOD__SECURITY_PERMISSION__CTOR, SECURITY_PERMISSION_ASSERTION },
-    {NULL, CLASS__REFLECTION_PERMISSION, METHOD__REFLECTION_PERMISSION__CTOR, REFLECTION_PERMISSION_MEMBERACCESS },
-    {NULL, CLASS__SECURITY_PERMISSION, METHOD__SECURITY_PERMISSION__CTOR, SECURITY_PERMISSION_SERIALIZATIONFORMATTER},
-    {NULL, CLASS__REFLECTION_PERMISSION, METHOD__REFLECTION_PERMISSION__CTOR, REFLECTION_PERMISSION_RESTRICTEDMEMBERACCESS},
-    {NULL, CLASS__PERMISSION_SET, METHOD__PERMISSION_SET__CTOR, PERMISSION_STATE_UNRESTRICTED},
-    {NULL, CLASS__SECURITY_PERMISSION, METHOD__SECURITY_PERMISSION__CTOR, SECURITY_PERMISSION_BINDINGREDIRECTS },
-    {NULL, CLASS__UI_PERMISSION, METHOD__UI_PERMISSION__CTOR, PERMISSION_STATE_UNRESTRICTED },
-};
-
 // Array index in SharedPermissionObjects array
 // Note: these should all be permissions that implement IUnrestrictedPermission.
 // Any changes to these must be reflected in bcl\system\security\codeaccesssecurityengine.cs and the above table
@@ -282,8 +195,6 @@ SELECTANY const SharedPermissionObjects g_rPermObjectsTemplate[] =
 // Class holding a grab bag of security stuff we need on a per-appdomain basis.
 struct SecurityContext
 {
-    SharedPermissionObjects     m_rPermObjects[NUM_PERM_OBJECTS];
-
     // Cached declarative permissions per method
     EEPtrHashTable m_pCachedMethodPermissionsHash;
     SimpleRWLock * m_prCachedMethodPermissionsLock;
@@ -299,7 +210,6 @@ struct SecurityContext
             GC_TRIGGERS;
             MODE_ANY;
         } CONTRACTL_END;
-        memcpy(m_rPermObjects, g_rPermObjectsTemplate, sizeof(m_rPermObjects));
         
         // initialize cache of method-level declarative security permissions
         // Note that the method-level permissions are stored elsewhere
diff --git a/src/vm/securityprincipal.cpp b/src/vm/securityprincipal.cpp
deleted file mode 100644
index 5f31d3a24d..0000000000
--- a/src/vm/securityprincipal.cpp
+++ /dev/null
@@ -1,227 +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.
-
-#include "common.h"
-
-#include "securityprincipal.h"
-#include "corhost.h"
-#include "security.h"
-
-#ifndef FEATURE_CORECLR
-INT32 QCALLTYPE COMPrincipal::ImpersonateLoggedOnUser(HANDLE hToken)
-{
-    QCALL_CONTRACT;
-
-    HRESULT hr = S_OK;
-
-    BEGIN_QCALL;
-
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES
-        IHostSecurityManager *pSM = CorHost2::GetHostSecurityManager();
-        if (pSM) {
-            BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread());
-            hr = pSM->ImpersonateLoggedOnUser(hToken);
-            END_SO_TOLERANT_CODE_CALLING_HOST;
-        }
-        else 
-#endif // FEATURE_INCLUDE_ALL_INTERFACES
-        {
-            if (!::ImpersonateLoggedOnUser(hToken))
-                hr = HRESULT_FROM_GetLastError();
-        }
-
-    STRESS_LOG2(LF_SECURITY, LL_INFO100, "COMPrincipal::ImpersonateLoggedOnUser called with hTokenSAFE = %d. Returning 0x%x\n",hToken,hr);
-
-    END_QCALL;
-
-    return hr;
-}
-
-FCIMPL3(INT32, COMPrincipal::OpenThreadToken, DWORD dwDesiredAccess, DWORD dwOpenAs, SafeHandle** phThreadTokenUNSAFE)
-{
-    CONTRACTL {
-        FCALL_CHECK;
-        PRECONDITION(CheckPointer(phThreadTokenUNSAFE));
-    } CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-    HELPER_METHOD_FRAME_BEGIN_RET_0();
-
-    SafeHandle** phThreadTokenSAFE = phThreadTokenUNSAFE;
-    GCPROTECT_BEGININTERIOR(phThreadTokenSAFE);
-
-    *phThreadTokenUNSAFE = NULL;
-    HandleHolder hThreadToken;
-    {
-        GCX_PREEMP();
-        BOOL bOpenAsSelf = TRUE;
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES
-        IHostSecurityManager *pSM = CorHost2::GetHostSecurityManager();
-        if (pSM) {
-            if (dwOpenAs == WINSECURITYCONTEXT_THREAD)
-                bOpenAsSelf = FALSE;
-
-            BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread());
-            hr = pSM->OpenThreadToken(dwDesiredAccess, bOpenAsSelf, &hThreadToken);
-            END_SO_TOLERANT_CODE_CALLING_HOST;
-            if (FAILED(hr) && dwOpenAs == WINSECURITYCONTEXT_BOTH) {
-                bOpenAsSelf = FALSE;
-                BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread());
-                hr = pSM->OpenThreadToken(dwDesiredAccess, bOpenAsSelf, &hThreadToken);
-                END_SO_TOLERANT_CODE_CALLING_HOST;
-            }
-        }
-        else 
-#endif // FEATURE_INCLUDE_ALL_INTERFACES
-        {
-            if (dwOpenAs == WINSECURITYCONTEXT_THREAD)
-                bOpenAsSelf = FALSE;
-
-            if (!::OpenThreadToken(::GetCurrentThread(), dwDesiredAccess, bOpenAsSelf, &hThreadToken)) {
-                if (dwOpenAs == WINSECURITYCONTEXT_BOTH) {
-                    bOpenAsSelf = FALSE;
-                    hr = S_OK;
-                    if (!::OpenThreadToken(::GetCurrentThread(), dwDesiredAccess, bOpenAsSelf, &hThreadToken))
-                        hr = HRESULT_FROM_GetLastError();
-                }
-                else
-                    hr = HRESULT_FROM_GetLastError();
-            }
-        }
-    }
-
-    if (SUCCEEDED(hr)) {
-        struct _gc {
-            SAFEHANDLE pSafeTokenHandle;
-        } gc;
-        gc.pSafeTokenHandle = NULL;
-
-        GCPROTECT_BEGIN(gc);
-        // Allocate a SafeHandle here
-        MethodTable *pMT = MscorlibBinder::GetClass(CLASS__SAFE_TOKENHANDLE);
-        gc.pSafeTokenHandle = (SAFEHANDLE) AllocateObject(pMT);
-        CallDefaultConstructor(gc.pSafeTokenHandle);
-        gc.pSafeTokenHandle->SetHandle((void*) hThreadToken);
-        hThreadToken.SuppressRelease();
-
-        SetObjectReference((OBJECTREF*) phThreadTokenSAFE, (OBJECTREF) gc.pSafeTokenHandle, gc.pSafeTokenHandle->GetAppDomain());
-        GCPROTECT_END();
-    }
-
-    GCPROTECT_END();
-
-    HELPER_METHOD_FRAME_END();
-    return hr;
-}
-FCIMPLEND
-
-INT32 QCALLTYPE COMPrincipal::RevertToSelf()
-{
-    QCALL_CONTRACT;
-
-    HRESULT hr = S_OK;
-
-    BEGIN_QCALL;
-
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES
-        IHostSecurityManager *pSM = CorHost2::GetHostSecurityManager();
-        if (pSM) {
-            BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread());
-            hr = pSM->RevertToSelf();
-            END_SO_TOLERANT_CODE_CALLING_HOST;
-        }
-        else 
-#endif // FEATURE_INCLUDE_ALL_INTERFACES
-        {
-            if (!::RevertToSelf())
-                hr = HRESULT_FROM_GetLastError();
-        }
-
-    STRESS_LOG1(LF_SECURITY, LL_INFO100, "COMPrincipal::RevertToSelf returning 0x%x\n",hr);
-
-    END_QCALL;
-
-    return hr;
-}
-
-INT32 QCALLTYPE COMPrincipal::SetThreadToken(HANDLE hToken)
-{
-    QCALL_CONTRACT;
-
-    HRESULT hr = S_OK;
-
-    BEGIN_QCALL;
-
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES
-    IHostSecurityManager *pSM = CorHost2::GetHostSecurityManager();
-    if (pSM)
-    {
-        BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread());
-        hr = pSM->SetThreadToken(hToken);
-        END_SO_TOLERANT_CODE_CALLING_HOST;
-    }
-    else
-#endif // FEATURE_INCLUDE_ALL_INTERFACES
-    {
-        if (!::SetThreadToken(NULL, hToken))
-            hr = HRESULT_FROM_GetLastError();
-    }
-
-    END_QCALL;
-
-    return hr;
-}
-#endif // !FEATURE_CORECLR
-
-void COMPrincipal::CLR_ImpersonateLoggedOnUser(HANDLE hToken)
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_TRIGGERS; 
-        MODE_ANY;
-    } CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    {
-        GCX_PREEMP();
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES
-        IHostSecurityManager *pSM = CorHost2::GetHostSecurityManager();
-        if (pSM) {
-            hr = pSM->RevertToSelf();
-            if (hr != S_OK)
-            {
-                // FailFast
-                STRESS_LOG2(LF_EH, LL_INFO100, "CLR_ImpersonateLoggedOnUser failed for hImpersonateToken = %d with error:0x%x\n",hToken, hr);
-                EEPOLICY_HANDLE_FATAL_ERROR(COR_E_SECURITY);
-            }
-            if (hToken != NULL)
-                hr = pSM->ImpersonateLoggedOnUser(hToken);
-        }
-        else 
-#endif // FEATURE_INCLUDE_ALL_INTERFACES
-        {
-            if (!::RevertToSelf())
-                hr = HRESULT_FROM_GetLastError();
-            if (hr != S_OK)
-            {
-                // FailFast
-                STRESS_LOG2(LF_EH, LL_INFO100, "CLR_ImpersonateLoggedOnUser failed for hImpersonateToken = %d with error:0x%x\n",hToken, hr);
-                EEPOLICY_HANDLE_FATAL_ERROR(COR_E_SECURITY);
-            }            
-            if (hToken != NULL && !::ImpersonateLoggedOnUser(hToken))
-                hr = HRESULT_FROM_GetLastError();
-        }
-        
-        if (hr != S_OK)
-        {
-            // FailFast
-            STRESS_LOG2(LF_EH, LL_INFO100, "CLR_ImpersonateLoggedOnUser failed for hImpersonateToken = %d with error:0x%x\n",hToken, hr);
-            EEPOLICY_HANDLE_FATAL_ERROR(COR_E_SECURITY);
-        }
-    }
-
-    return;
-}
-
diff --git a/src/vm/securityprincipal.h b/src/vm/securityprincipal.h
deleted file mode 100644
index 5d6b522a27..0000000000
--- a/src/vm/securityprincipal.h
+++ /dev/null
@@ -1,33 +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.
-
-#pragma once
-
-// keep in sync with windowsidentity.cs
-#define WINSECURITYCONTEXT_THREAD 1
-#define WINSECURITYCONTEXT_PROCESS 2
-#define WINSECURITYCONTEXT_BOTH 3
-
-
-
-#ifndef FEATURE_PAL
-class COMPrincipal
-{
-public:
-#ifndef FEATURE_CORECLR
-    static
-    INT32 QCALLTYPE ImpersonateLoggedOnUser(HANDLE hToken);
-
-    static FCDECL3(INT32, OpenThreadToken, DWORD dwDesiredAccess, DWORD dwOpenAs, SafeHandle** phThreadTokenUNSAFE);
-
-    static
-    INT32 QCALLTYPE RevertToSelf();
-
-    static
-    INT32 QCALLTYPE SetThreadToken(HANDLE hToken);
-#endif // !FEATURE_CORECLR
-
-    static void CLR_ImpersonateLoggedOnUser(HANDLE hToken);
-};
-#endif // FEATURE_PAL
diff --git a/src/vm/securitystackwalk.cpp b/src/vm/securitystackwalk.cpp
deleted file mode 100644
index 9b8b150f68..0000000000
--- a/src/vm/securitystackwalk.cpp
+++ /dev/null
@@ -1,2439 +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.
-//
-
-
-//
-
-
-#include "common.h"
-
-#include "security.h"
-#include "perfcounters.h"
-#include "stackcompressor.h"
-#ifdef FEATURE_REMOTING
-#include "crossdomaincalls.h"
-#else
-#include "callhelpers.h"
-#endif
-#include "appdomain.inl"
-#include "appdomainstack.inl"
-
-COUNTER_ONLY(PERF_COUNTER_TIMER_PRECISION g_TotalTimeInSecurityRuntimeChecks = 0);
-COUNTER_ONLY(PERF_COUNTER_TIMER_PRECISION g_LastTimeInSecurityRuntimeChecks = 0);
-COUNTER_ONLY(UINT32 g_SecurityChecksIterations=0);
-
-bool SecurityStackWalk::IsSpecialRunFrame(MethodDesc* pMeth)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    } CONTRACTL_END;
-
-#ifndef FEATURE_CORECLR
-    if (pMeth == MscorlibBinder::GetMethod(METHOD__EXECUTIONCONTEXT__RUN))
-        return true;
-
-#if defined(FEATURE_IMPERSONATION) || defined(FEATURE_COMPRESSEDSTACK)    
-    if (pMeth == MscorlibBinder::GetMethod(METHOD__SECURITYCONTEXT__RUN))
-        return true;
-#endif // #if defined(FEATURE_IMPERSONATION) || defined(FEATURE_COMPRESSEDSTACK)
-
-#ifdef FEATURE_COMPRESSEDSTACK
-    if (pMeth == MscorlibBinder::GetMethod(METHOD__COMPRESSED_STACK__RUN))
-        return true;
-#endif // FEATURE_COMPRESSEDSTACK
-
-#endif // !FEATURE_CORECLR
-
-    return false;
-}
-
-void SecurityStackWalk::CheckPermissionAgainstGrants(OBJECTREF refCS, OBJECTREF refGrants, OBJECTREF refRefused, AppDomain *pDomain, MethodDesc* pMethod, Assembly* pAssembly)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    struct _gc {
-        OBJECTREF orCS;
-        OBJECTREF orGranted;
-        OBJECTREF orRefused;
-        OBJECTREF orDemand;
-        OBJECTREF orToken;
-        OBJECTREF orAssembly;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-    gc.orCS = refCS;
-    gc.orGranted = refGrants;
-    gc.orRefused = refRefused;
-
-    GCPROTECT_BEGIN(gc);
-
-    // Switch into the destination context if necessary.
-    ENTER_DOMAIN_PTR(pDomain,ADV_RUNNINGIN)  //have it on the stack
-    {
-        // Fetch input objects that might originate from a different appdomain,
-        // marshalling if necessary.
-        gc.orDemand = m_objects.GetObjects(pDomain, &gc.orToken);
-        if(pAssembly)
-            gc.orAssembly = pAssembly->GetExposedObject();
-
-        PREPARE_NONVIRTUAL_CALLSITE(METHOD__SECURITY_ENGINE__CHECK_HELPER);
-
-        DECLARE_ARGHOLDER_ARRAY(helperArgs, 8);
-        helperArgs[ARGNUM_0] = OBJECTREF_TO_ARGHOLDER(gc.orCS);
-        helperArgs[ARGNUM_1] = OBJECTREF_TO_ARGHOLDER(gc.orGranted);
-        helperArgs[ARGNUM_2] = OBJECTREF_TO_ARGHOLDER(gc.orRefused);
-        helperArgs[ARGNUM_3] = OBJECTREF_TO_ARGHOLDER(gc.orDemand);
-        helperArgs[ARGNUM_4] = OBJECTREF_TO_ARGHOLDER(gc.orToken);
-        helperArgs[ARGNUM_5] = PTR_TO_ARGHOLDER(pMethod);
-        helperArgs[ARGNUM_6] = OBJECTREF_TO_ARGHOLDER(gc.orAssembly);
-        helperArgs[ARGNUM_7] = DWORD_TO_ARGHOLDER(dclDemand);
-
-        CATCH_HANDLER_FOUND_NOTIFICATION_CALLSITE;
-        CALL_MANAGED_METHOD_NORET(helperArgs);
-        
-    }
-    END_DOMAIN_TRANSITION;
-
-    GCPROTECT_END();
-}
-
-
-void SecurityStackWalk::CheckSetAgainstGrants(OBJECTREF refCS, OBJECTREF refGrants, OBJECTREF refRefused, AppDomain *pDomain, MethodDesc* pMethod, Assembly* pAssembly)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    struct _gc {
-        OBJECTREF orCS;
-        OBJECTREF orGranted;
-        OBJECTREF orRefused;
-        OBJECTREF orDemand;
-        OBJECTREF orAssembly;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-    gc.orCS = refCS;
-    gc.orGranted = refGrants;
-    gc.orRefused = refRefused;
-
-    GCPROTECT_BEGIN(gc);
-
-    // Switch into the destination context if necessary.
-    ENTER_DOMAIN_PTR(pDomain,ADV_RUNNINGIN) //have it on the stack
-    {
-        // Fetch input objects that might originate from a different appdomain,
-        // marshalling if necessary.
-        gc.orDemand = m_objects.GetObject(pDomain);
-        if(pAssembly)
-            gc.orAssembly = pAssembly->GetExposedObject();
-
-        PREPARE_NONVIRTUAL_CALLSITE(METHOD__SECURITY_ENGINE__CHECK_SET_HELPER);
-
-        DECLARE_ARGHOLDER_ARRAY(helperArgs, 7);
-        helperArgs[ARGNUM_0] = OBJECTREF_TO_ARGHOLDER(gc.orCS);
-        helperArgs[ARGNUM_1] = OBJECTREF_TO_ARGHOLDER(gc.orGranted);
-        helperArgs[ARGNUM_2] = OBJECTREF_TO_ARGHOLDER(gc.orRefused);
-        helperArgs[ARGNUM_3] = OBJECTREF_TO_ARGHOLDER(gc.orDemand);
-        helperArgs[ARGNUM_4] = PTR_TO_ARGHOLDER(pMethod);
-        helperArgs[ARGNUM_5] = OBJECTREF_TO_ARGHOLDER(gc.orAssembly);
-        helperArgs[ARGNUM_6] = DWORD_TO_ARGHOLDER(dclDemand);
-
-        CATCH_HANDLER_FOUND_NOTIFICATION_CALLSITE;
-        CALL_MANAGED_METHOD_NORET(helperArgs);
-    }
-    END_DOMAIN_TRANSITION;
-        
-    GCPROTECT_END();
-}
-
-void SecurityStackWalk::GetZoneAndOriginGrants(OBJECTREF refCS, OBJECTREF refGrants, OBJECTREF refRefused, AppDomain *pDomain, MethodDesc* pMethod, Assembly* pAssembly)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    Thread *pThread = GetThread();
-
-    struct _gc {
-        OBJECTREF orCS;
-        OBJECTREF orGranted;
-        OBJECTREF orRefused;
-        OBJECTREF orZoneList;
-        OBJECTREF orOriginList;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-    gc.orCS = refCS;
-    gc.orGranted = refGrants;
-    gc.orRefused = refRefused;
-
-    GCPROTECT_BEGIN(gc);
-
-    // Fetch input objects that might originate from a different appdomain,
-    // marshalling if necessary.
-    gc.orZoneList = m_objects.GetObjects(pDomain, &gc.orOriginList);
-
-    // Switch into the destination context if necessary.
-    ENTER_DOMAIN_PTR(pDomain,ADV_RUNNINGIN) //have it on the stack
-    {
-
-        BOOL inProgress = pThread->IsSecurityStackwalkInProgess();
-
-        // We turn security stackwalk in progress off which turns security back
-        // on for a thread.  This means that if the managed call throws an exception
-        // we are already in the proper state so we don't need to do anything.
-
-        if (inProgress)
-            pThread->SetSecurityStackwalkInProgress(FALSE);
-
-        MethodDescCallSite getZoneAndOriginHelper(METHOD__SECURITY_ENGINE__GET_ZONE_AND_ORIGIN_HELPER);
-
-        ARG_SLOT helperArgs[5];
-
-        helperArgs[0] = ObjToArgSlot(gc.orCS);
-        helperArgs[1] = ObjToArgSlot(gc.orGranted);
-        helperArgs[2] = ObjToArgSlot(gc.orRefused);
-        helperArgs[3] = ObjToArgSlot(gc.orZoneList);
-        helperArgs[4] = ObjToArgSlot(gc.orOriginList);
-
-        getZoneAndOriginHelper.Call(&(helperArgs[0]));
-
-        if (inProgress)
-            pThread->SetSecurityStackwalkInProgress(TRUE);
-    }
-    END_DOMAIN_TRANSITION;
-
-    GCPROTECT_END();
-}
-
-BOOL SecurityStackWalk::CheckPermissionAgainstFrameData(OBJECTREF refFrameData, AppDomain* pDomain, MethodDesc* pMethod)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    CLR_BOOL ret = FALSE;
-
-    struct _gc {
-        OBJECTREF orFrameData;
-        OBJECTREF orDemand;
-        OBJECTREF orToken;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-    gc.orFrameData = refFrameData;
-
-    GCPROTECT_BEGIN(gc);
-
-    // Fetch input objects that might originate from a different appdomain,
-    // marshalling if necessary.
-    gc.orDemand = m_objects.GetObjects(pDomain, &gc.orToken);
-
-    // Switch into the destination context if necessary.
-    ENTER_DOMAIN_PTR(pDomain,ADV_RUNNINGIN) //have it on the stack
-    {
-        PREPARE_NONVIRTUAL_CALLSITE(METHOD__SECURITY_RUNTIME__FRAME_DESC_HELPER);
-
-        DECLARE_ARGHOLDER_ARRAY(args, 4);
-        args[ARGNUM_0]  = OBJECTREF_TO_ARGHOLDER(gc.orFrameData);    // arg 0
-        args[ARGNUM_1]  = OBJECTREF_TO_ARGHOLDER(gc.orDemand);       // arg 1 
-        args[ARGNUM_2]  = OBJECTREF_TO_ARGHOLDER(gc.orToken);        // arg 2
-        args[ARGNUM_3]  = PTR_TO_ARGHOLDER(pMethod);                 // arg 3 
-
-        CATCH_HANDLER_FOUND_NOTIFICATION_CALLSITE;
-        CALL_MANAGED_METHOD(ret, CLR_BOOL, args);
-
-    }
-    END_DOMAIN_TRANSITION;
-
-    GCPROTECT_END();
-
-    return ret;
-}
-
-BOOL SecurityStackWalk::CheckSetAgainstFrameData(OBJECTREF refFrameData, AppDomain* pDomain, MethodDesc* pMethod)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    CLR_BOOL ret = FALSE;
-
-    struct _gc {
-        OBJECTREF orFrameData;
-        OBJECTREF orDemand;
-        OBJECTREF orPermSetOut;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-    gc.orFrameData = refFrameData;
-
-    GCPROTECT_BEGIN(gc);
-
-    // Fetch input objects that might originate from a different appdomain,
-    // marshalling if necessary.
-    gc.orDemand = m_objects.GetObject(pDomain);
-
-    // Switch into the destination context if necessary.
-    ENTER_DOMAIN_PTR(pDomain,ADV_RUNNINGIN) //have it on the stack
-    {
-        PREPARE_NONVIRTUAL_CALLSITE(METHOD__SECURITY_RUNTIME__FRAME_DESC_SET_HELPER);
-
-        DECLARE_ARGHOLDER_ARRAY(args, 4);
-        args[ARGNUM_0] = OBJECTREF_TO_ARGHOLDER(gc.orFrameData);
-        args[ARGNUM_1] = OBJECTREF_TO_ARGHOLDER(gc.orDemand);
-        args[ARGNUM_2] = PTR_TO_ARGHOLDER(&gc.orPermSetOut);
-        args[ARGNUM_3] = PTR_TO_ARGHOLDER(pMethod);
-
-        CATCH_HANDLER_FOUND_NOTIFICATION_CALLSITE;
-        CALL_MANAGED_METHOD(ret, CLR_BOOL, args);
-        
-        if (gc.orPermSetOut != NULL) {
-            // Update the cached object.
-            m_objects.UpdateObject(pDomain, gc.orPermSetOut);
-        }
-    }
-    END_DOMAIN_TRANSITION;
-
-    GCPROTECT_END();
-
-    return ret;
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-// -------------------------------------------------------------------------------
-//
-//                                 DemandStackWalk
-//
-// -------------------------------------------------------------------------------
-
-class DemandStackWalk : public SecurityStackWalk
-{
-public:
-    enum DemandType
-    {
-        DT_PERMISSION = 1,
-        DT_SET = 2,
-        DT_ZONE_AND_URL = 3,
-    };
-
-protected:
-    Frame*                  m_pCtxTxFrame;
-    AppDomain *             m_pPrevAppDomain;
-    AppDomain*              m_pSkipAppDomain;
-    Assembly *              m_pPrevAssembly;
-    StackCrawlMark *        m_pStackMark;
-    DemandType              m_eDemandType;
-    bool                    m_bHaveFoundStartingFrameYet;
-    BOOL                    m_bFoundStackMark;
-    DWORD                   m_dwdemandFlags;
-    DWORD                   m_adStackIndex;
-    AppDomainStack*         m_pThreadADStack;
-
-public:
-    DemandStackWalk(SecurityStackWalkType eType, DWORD flags, StackCrawlMark* stackMark, DemandType eDemandType, DWORD demandFlags)
-        : SecurityStackWalk(eType, flags)
-    {
-        WRAPPER_NO_CONTRACT;
-        m_pCtxTxFrame = NULL;
-        m_pPrevAppDomain = NULL;
-        m_pSkipAppDomain = NULL;
-        m_pPrevAssembly = NULL;
-        m_eDemandType = eDemandType;
-        m_bHaveFoundStartingFrameYet = false;
-        m_pStackMark = stackMark;
-        m_bFoundStackMark = FALSE;
-        m_dwdemandFlags = demandFlags;
-        m_pThreadADStack = GetThread()->GetAppDomainStackPointer();
-        m_pThreadADStack->InitDomainIteration(&m_adStackIndex);
-    }
-
-    void DoStackWalk();
-    StackWalkAction WalkFrame(CrawlFrame* pCf);
-
-protected:
-    bool IsStartingFrame(CrawlFrame* pCf);
-    bool IsSpecialRunFrame(MethodDesc* pMeth)
-    {
-        return SecurityStackWalk::IsSpecialRunFrame(pMeth);
-    }
-    void CheckGrant(OBJECTREF refCS, OBJECTREF refGrants, OBJECTREF refRefused, AppDomain *pDomain, MethodDesc* pMethod, Assembly* pAssembly);
-    BOOL CheckFrame(OBJECTREF refFrameData, AppDomain* pDomain, MethodDesc* pMethod);
-
-private:
-    FORCEINLINE BOOL QuickCheck(OBJECTREF refCS, OBJECTREF refGrants, OBJECTREF refRefused)
-    {
-        if (refCS == NULL && refRefused == NULL && refGrants != NULL)
-        {
-            // if we have a FT grant and nothing else, and our demand is for something that FT can satisfy, we're done
-            PERMISSIONSETREF permSetRef = (PERMISSIONSETREF)refGrants;
-            return permSetRef->IsUnrestricted();
-        }
-        return FALSE;
-    }
-    void ProcessAppDomainTransition(AppDomain * pAppDomain, bool bCheckPrevAppDomain);
-#ifdef _DEBUG   
-    BOOL IsValidReturnFromWalkFrame(StackWalkAction retVal, CrawlFrame* pCF)
-    {
-        CONTRACTL {
-            THROWS;
-            GC_TRIGGERS;
-            MODE_ANY;
-        } CONTRACTL_END;
-
-        // This function checks that when we hit a Special frame, we are indeed returning the action to stop the stackwalk
-        MethodDesc *pFunc = pCF->GetFunction();
-        if (pFunc != NULL && IsSpecialRunFrame(pFunc))
-        {
-            return (retVal == SWA_ABORT);
-        }
-        return TRUE; 
-    }
-#endif // _DEBUG
-
-#ifdef FEATURE_COMPRESSEDSTACK
-	BOOL CheckAnonymouslyHostedDynamicMethodCompressedStack(OBJECTREF refDynamicResolver, AppDomain* pDomain, MethodDesc* pMethod);
-	BOOL CheckAnonymouslyHostedDynamicMethodCompressedStackPermission(OBJECTREF refDynamicResolver, AppDomain* pDomain, MethodDesc* pMethod);
-	BOOL CheckAnonymouslyHostedDynamicMethodCompressedStackPermissionSet(OBJECTREF refDynamicResolver, AppDomain* pDomain, MethodDesc* pMethod);
-#endif // FEATURE_COMPRESSEDSTACK
-};
-
-void DemandStackWalk::CheckGrant(OBJECTREF refCS, OBJECTREF refGrants, OBJECTREF refRefused, AppDomain *pDomain, MethodDesc* pMethod, Assembly* pAssembly)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-    switch(m_eDemandType)
-    {
-        case DT_PERMISSION:
-            // Test early out scenario (quickcheck) before calling into managed code
-            if (!QuickCheck(refCS, refGrants, refRefused))
-            CheckPermissionAgainstGrants(refCS, refGrants, refRefused, pDomain, pMethod, pAssembly);
-            break;
-
-        case DT_SET:
-            // Test early out scenario (quickcheck) before calling into managed code
-            if (!QuickCheck(refCS, refGrants, refRefused))
-            CheckSetAgainstGrants(refCS, refGrants, refRefused, pDomain, pMethod, pAssembly);
-            break;
-        case DT_ZONE_AND_URL:
-            GetZoneAndOriginGrants(refCS, refGrants, refRefused, pDomain, pMethod, pAssembly);
-            break;
-        default:
-            _ASSERTE(!"unexpected demand type");
-            break;
-    }
-}
-
-BOOL DemandStackWalk::CheckFrame(OBJECTREF refFrameData, AppDomain* pDomain, MethodDesc* pMethod)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-    switch(m_eDemandType)
-    {
-        case DT_PERMISSION:
-            return CheckPermissionAgainstFrameData(refFrameData, pDomain, pMethod);
-
-        case DT_SET:
-            return CheckSetAgainstFrameData(refFrameData, pDomain, pMethod);
-        case DT_ZONE_AND_URL:
-            return TRUE; //Nothing to do here since CS cannot live on a Frame anymore.
-        default:
-            _ASSERTE(!"unexpected demand type");
-    }
-    return TRUE;
-}
-
-bool DemandStackWalk::IsStartingFrame(CrawlFrame* pCf)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    } CONTRACTL_END;
-
-    switch(m_eStackWalkType)
-    {
-        case SSWT_DECLARATIVE_DEMAND: // Begin after the security stub(s)
-            _ASSERTE(m_pStackMark == NULL);
-            // skip the current method that has decl sec
-            if (m_bFoundStackMark)
-                return true;
-            else
-            {
-                m_bFoundStackMark = true;
-                return false;            
-            }
-
-        case SSWT_IMPERATIVE_DEMAND: // Begin where the StackMark says to
-        case SSWT_GET_ZONE_AND_URL: // Begin where the StackMark says to
-            _ASSERTE(*m_pStackMark == LookForMyCaller || *m_pStackMark == LookForMyCallersCaller);
-
-            // See if we've passed the stack mark yet
-            if (!pCf->IsInCalleesFrames(m_pStackMark))
-                return false;
-
-            // Skip the frame after the stack mark as well.
-            if(*m_pStackMark == LookForMyCallersCaller && !m_bFoundStackMark)
-            {
-                m_bFoundStackMark = TRUE;
-                return false;
-            }
-
-            return true;
-
-        case SSWT_LATEBOUND_LINKDEMAND: // Begin immediately
-        case SSWT_DEMAND_FROM_NATIVE:
-            _ASSERTE(m_pStackMark == NULL);
-            return true;
-
-        default:
-            _ASSERTE(FALSE); // Unexpected stack walk type
-            break;
-    }
-    return true;
-}
-void DemandStackWalk::ProcessAppDomainTransition(AppDomain* pAppDomain, bool bCheckPrevAppDomain)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-    _ASSERTE(pAppDomain != m_pPrevAppDomain);
-
-    if (m_pPrevAppDomain != NULL && bCheckPrevAppDomain)
-    {
-        // We have not checked the previous AppDomain. Check it now.
-        if (m_pSkipAppDomain != m_pPrevAppDomain)
-        {
-            ApplicationSecurityDescriptor *pSecDesc = 
-                static_cast<ApplicationSecurityDescriptor*>(m_pPrevAppDomain->GetSecurityDescriptor());
-
-            // Only process AppDomains which have completed security initialization.  If the domain is not
-            // yet fully initialized then only fully trusted code can be running in the domain, so we're
-            // safe to ignore the transition.  The domain may also not yet have a sane grant set setup on it
-            // yet if the demand is coming out of AppDomainManager code.
-            if (pSecDesc && !pSecDesc->IsInitializationInProgress())
-            {
-                DBG_TRACE_STACKWALK("            Checking appdomain...\n", true);
-
-                if (!pSecDesc->IsDefaultAppDomain() &&
-                    !pSecDesc->IsFullyTrusted() &&
-                    !pSecDesc->CheckSpecialFlag(m_dwdemandFlags))
-                {
-                    OBJECTREF orRefused;
-                    OBJECTREF orGranted = pSecDesc->GetGrantedPermissionSet(&orRefused);
-                    CheckGrant(NULL, orGranted, orRefused, m_pPrevAppDomain, NULL, m_pPrevAssembly);
-                }
-            }
-            else
-            {
-                DBG_TRACE_STACKWALK("            Skipping appdomain...\n", true);
-            }
-        }
-    }
-    // Move the domain index forward 
-    m_pThreadADStack->GetNextDomainEntryOnStack(&m_adStackIndex);
-
-    // At the end of the stack walk, do a check on the grants of
-    // the m_pPrevAppDomain by the stackwalk caller if needed.
-    m_pPrevAppDomain = pAppDomain;
-
-    // Check if we can skip the entire pAppDomain. If so, assign m_pSkipAppDomain
-    // TODO: Can Check the AppDomain PLS also here.
-    if ((m_pThreadADStack->GetCurrentDomainEntryOnStack(m_adStackIndex))->HasFlagsOrFullyTrustedWithNoStackModifiers(m_dwdemandFlags))
-        m_pSkipAppDomain = pAppDomain;
-    else
-        m_pSkipAppDomain = NULL;
-
-
-    
-}
-StackWalkAction DemandStackWalk::WalkFrame(CrawlFrame* pCf)
-{
-    CONTRACT (StackWalkAction) {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        POSTCONDITION(IsValidReturnFromWalkFrame(RETVAL, pCf));
-    } CONTRACT_END;
-
-    StackWalkAction ret = SWA_CONTINUE;
-
-#ifdef FEATURE_REMOTING
-#ifdef FEATURE_COMPRESSEDSTACK
-
-    // Save the CtxTxFrame if this is one
-    if (m_pCtxTxFrame == NULL)
-    {
-        Frame *pFrame = pCf->GetFrame();
-        if (SecurityStackWalk::IsContextTransitionFrameWithCS(pFrame))
-        {
-
-            m_pCtxTxFrame = pFrame;
-        }
-    }
-#endif // #ifdef FEATURE_COMPRESSEDSTACK    
-#endif // FEATURE_REMOTING
-
-    MethodDesc * pFunc = pCf->GetFunction();
-    Assembly * pAssem = pCf->GetAssembly();
-    // Get the current app domain.
-    AppDomain *pAppDomain = pCf->GetAppDomain();
-    if (pAppDomain != m_pPrevAppDomain)
-    {
-#ifndef FEATURE_REMOTING
-        BOOL bRealAppDomainTransition = (m_pPrevAppDomain != NULL);
-#endif
-        ProcessAppDomainTransition(pAppDomain, m_bHaveFoundStartingFrameYet);
-    
-#ifndef FEATURE_REMOTING        
-        // The first AppDomain transition is the transition from NULL to current domain. We should not stop on that.
-        // We should stop on the first "real" appdomain transition - which is a transition out of the current domain.
-        if (bRealAppDomainTransition)
-        {
-            // without remoting other appdomains do not matter (can be only createdomain call anyhow) so stop the stack walk
-            m_dwFlags |= CORSEC_STACKWALK_HALTED;
-            RETURN SWA_ABORT; 
-        }
-#endif
-    }
-    
-    if ((pFunc == NULL && pAssem == NULL) || (pFunc && pFunc->IsILStub()))
-        RETURN ret; // Not a function
-
-    // Skip until the frame where the stackwalk should begin
-    if (!m_bHaveFoundStartingFrameYet)
-    {
-        if (IsStartingFrame(pCf))
-            m_bHaveFoundStartingFrameYet = true;
-        else
-            RETURN ret;
-    }
-
-    //
-    // Now check the current frame!
-    //
-    // If this is a *.Run method, then we need to terminate the stackwalk after considering this frame
-    if (pFunc && IsSpecialRunFrame(pFunc))
-    {
-        DBG_TRACE_STACKWALK("            Halting stackwalk for .Run.\n", false);
-        // Dont mark the CORSEC_STACKWALK_HALTED in m_dwFlags because we still need to look at the CS 
-        ret = SWA_ABORT;
-    }    
-
-    DBG_TRACE_STACKWALK("        Checking granted permissions for current method...\n", true);
-    
-    // Reached here imples we walked atleast a single frame.
-    COUNTER_ONLY(GetPerfCounters().m_Security.stackWalkDepth++);
-
-
-    // Get the previous assembly
-    Assembly *pPrevAssem = m_pPrevAssembly;
-
-
-    // Check if we can skip the entire appdomain
-    if (m_pSkipAppDomain == pAppDomain)
-    {
-        RETURN ret;
-    }
-        
-    // Keep track of the last module checked. If we have just checked the
-    // permissions on the module, we don't need to do it again.
-    if (pAssem != pPrevAssem)
-    {
-        DBG_TRACE_STACKWALK("            Checking grants for current assembly.\n", true);
-
-        // Get the security descriptor for the current assembly and pass it to
-        // the interpreted helper.
-        AssemblySecurityDescriptor * pSecDesc = static_cast<AssemblySecurityDescriptor*>(pAssem->GetSecurityDescriptor(pAppDomain));
-        _ASSERTE(pSecDesc != NULL);
-
-        // We have to check the permissions if we are not fully trusted or
-        // we cannot be overrided by full trust.  Plus we always skip checks
-        // on system classes.
-        if (!pSecDesc->IsSystem() &&
-            !pSecDesc->IsFullyTrusted() &&
-            !pSecDesc->CheckSpecialFlag(m_dwdemandFlags))
-        {
-            OBJECTREF orRefused;
-            OBJECTREF orGranted = pSecDesc->GetGrantedPermissionSet(&orRefused);
-            CheckGrant(NULL, orGranted, orRefused, pAppDomain, pFunc, pAssem);
-        }
-
-        m_pPrevAssembly = pAssem;
-    }
-    else
-    {
-        DBG_TRACE_STACKWALK("            Current assembly same as previous. Skipping check.\n", true);
-    }
-
-
-    // Passed initial check. See if there is security info on this frame.
-    OBJECTREF *pFrameObjectSlot = pCf->GetAddrOfSecurityObject();
-    if (pFrameObjectSlot != NULL)
-    {
-        SecurityDeclarative::DoDeclarativeSecurityAtStackWalk(pFunc, pAppDomain, pFrameObjectSlot);
-        if (*pFrameObjectSlot != NULL)
-        {
-            DBG_TRACE_STACKWALK("        + Frame-specific security info found. Checking...\n", false);
-
-            if(!CheckFrame(*pFrameObjectSlot, pAppDomain, pFunc))
-            {
-                DBG_TRACE_STACKWALK("            Halting stackwalk for assert.\n", false);
-                m_dwFlags |= CORSEC_STACKWALK_HALTED;
-                ret = SWA_ABORT;
-            }
-        }
-    }
-
-#if FEATURE_COMPRESSEDSTACK
-    // If this frame is an anonymously hosted dynamic assembly, we need to run the demand against its compressed stack
-    // to ensure the creator had the permissions for this demand
-    if(pAssem != NULL && pAppDomain != NULL && pAssem->GetDomainAssembly(pAppDomain) == pAppDomain->GetAnonymouslyHostedDynamicMethodsAssembly() &&
-        !CLRConfig::GetConfigValue(CLRConfig::UNSUPPORTED_Security_DisableAnonymouslyHostedDynamicMethodCreatorSecurityCheck))
-    {
-        _ASSERTE(pFunc->IsLCGMethod());
-        OBJECTREF dynamicResolver = pFunc->AsDynamicMethodDesc()->GetLCGMethodResolver()->GetManagedResolver();
-        if(!CheckAnonymouslyHostedDynamicMethodCompressedStack(dynamicResolver, pAppDomain, pFunc))
-        {
-            m_dwFlags |= CORSEC_STACKWALK_HALTED;
-            ret = SWA_ABORT;
-        }
-    }
-#endif // FEATURE_COMPRESSEDSTACK
-
-    DBG_TRACE_STACKWALK("        Check passes for this method.\n", true);
-
-
-    // Passed all the checks, return current value of ret (could be SWA_ABORT of SWA_CONTINUE based on above checks)
-    RETURN ret;
-}
-
-static
-StackWalkAction CodeAccessCheckStackWalkCB(CrawlFrame* pCf, VOID* pData)
-{
-    WRAPPER_NO_CONTRACT;
-    DemandStackWalk *pCBdata = (DemandStackWalk*)pData;
-    return pCBdata->WalkFrame(pCf);
-}
-
-void DemandStackWalk::DoStackWalk()
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    // Get the current thread.
-    Thread *pThread = GetThread();
-    _ASSERTE(pThread != NULL);
-
-    // Don't allow recursive security stackwalks. Note that this implies that
-    // *no* untrusted code must ever be called during a security stackwalk.
-    if (pThread->IsSecurityStackwalkInProgess())
-        return;
-
-    // NOTE: Initialize the stack depth. Note that if more that one thread tries
-    // to perform stackwalk then these counters gets stomped upon. 
-    COUNTER_ONLY(GetPerfCounters().m_Security.stackWalkDepth = 0);
-
-    // Walk the thread.
-    EX_TRY
-    {
-        pThread->SetSecurityStackwalkInProgress( TRUE );
-
-        DBG_TRACE_STACKWALK("Code-access security check invoked.\n", false);
-        // LIGHTUNWIND flag: allow using stackwalk cache for security stackwalks
-        pThread->StackWalkFrames(CodeAccessCheckStackWalkCB, this, SKIPFUNCLETS | LIGHTUNWIND);
-        DBG_TRACE_STACKWALK("\tCode-access stackwalk completed.\n", false);
-
-        // check the last app domain or CompressedStack at the thread base
-        if (((m_dwFlags & CORSEC_STACKWALK_HALTED) == 0) /*&& m_cCheck != 0*/)
-        {
-            AppDomain *pAppDomain = m_pPrevAppDomain;
-#ifdef FEATURE_COMPRESSEDSTACK            
-            OBJECTREF orCS = pThread->GetCompressedStack();
-
-            if (orCS == NULL)
-            {
-                // There may have been an AD transition and we shd look at the CB data to see if this is the case
-                if (m_pCtxTxFrame != NULL)
-                {
-                    orCS = (OBJECTREF)SecurityStackWalk::GetCSFromContextTransitionFrame(m_pCtxTxFrame);
-                    pAppDomain = m_pCtxTxFrame->GetReturnDomain();
-                }
-            }
-            
-
-            if (orCS != NULL)
-            {
-                // We have a CS at the thread base - just look at that. Dont look at the last AD
-                DBG_TRACE_STACKWALK("\tChoosing CompressedStack check.\n", true);
-                DBG_TRACE_STACKWALK("\tChecking CompressedStack...\n", true);
-                
-                CheckGrant(orCS, NULL, NULL, pAppDomain, NULL, NULL);
-                DBG_TRACE_STACKWALK("\tCompressedStack check passed.\n", true);
-            }
-            else
-#endif // FEATURE_COMPRESSEDSTACK
-            {
-                // No CS at thread base - must look at the last AD
-                DBG_TRACE_STACKWALK("\tChoosing appdomain check.\n", true);
-
-                ApplicationSecurityDescriptor *pSecDesc = static_cast<ApplicationSecurityDescriptor*>(pAppDomain->GetSecurityDescriptor());
-        
-                if (pSecDesc != NULL)
-                {
-                    // Note: the order of these calls is important since you have to have done a
-                    // GetEvidence() on the security descriptor before you check for the
-                    // CORSEC_DEFAULT_APPDOMAIN property.  IsFullyTrusted calls Resolve so
-                    // we're all good.
-                    if (!pSecDesc->IsDefaultAppDomain() &&
-                        !pSecDesc->IsFullyTrusted() &&
-                        !pSecDesc->CheckSpecialFlag(m_dwdemandFlags))
-                    {
-                        DBG_TRACE_STACKWALK("\tChecking appdomain...\n", true);
-                        OBJECTREF orRefused;
-                        OBJECTREF orGranted = pSecDesc->GetGrantedPermissionSet(&orRefused);
-                        CheckGrant(NULL, orGranted, orRefused, pAppDomain, NULL, NULL);
-                        DBG_TRACE_STACKWALK("\tappdomain check passed.\n", true);
-                    }
-                }
-                else
-                {
-                    DBG_TRACE_STACKWALK("\tSkipping appdomain check.\n", true);
-                }
-            }
-        }
-        else
-        {
-            DBG_TRACE_STACKWALK("\tSkipping CS/appdomain check.\n", true);
-        }
-
-        pThread->SetSecurityStackwalkInProgress( FALSE );
-    }
-    EX_CATCH
-    {
-        // We catch exceptions and rethrow like this to ensure that we've
-        // established an exception handler on the fs:[0] chain (managed
-        // exception handlers won't do this). This in turn guarantees that
-        // managed exception filters in any of our callers won't be found,
-        // otherwise they could get to execute untrusted code with security
-        // turned off.
-        pThread->SetSecurityStackwalkInProgress( FALSE );
-
-        EX_RETHROW;
-    }
-    EX_END_CATCH_UNREACHABLE
-    
-
-    DBG_TRACE_STACKWALK("Code-access check passed.\n", false);
-}
-
-#ifdef FEATURE_COMPRESSEDSTACK
-BOOL DemandStackWalk::CheckAnonymouslyHostedDynamicMethodCompressedStack(OBJECTREF refDynamicResolver, AppDomain* pDomain, MethodDesc* pMethod)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    BOOL ret = TRUE;
-
-    switch(m_eDemandType)
-    {
-    case DT_PERMISSION:
-        ret = CheckAnonymouslyHostedDynamicMethodCompressedStackPermission(refDynamicResolver, pDomain, pMethod);
-        break;
-
-    case DT_SET:
-        ret = CheckAnonymouslyHostedDynamicMethodCompressedStackPermissionSet(refDynamicResolver, pDomain, pMethod);
-        break;
-
-    case DT_ZONE_AND_URL:
-        // Not needed for compressed stack
-        break;
-
-    default:
-        _ASSERTE(!"unexpected demand type");
-        break;
-    }
-
-    return ret;
-}
-
-BOOL DemandStackWalk::CheckAnonymouslyHostedDynamicMethodCompressedStackPermissionSet(OBJECTREF refDynamicResolver, AppDomain* pDomain, MethodDesc* pMethod)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    CLR_BOOL ret = FALSE;
-
-
-    struct _gc {
-        OBJECTREF orDynamicResolver;
-        OBJECTREF orDemandSet;
-        OBJECTREF orPermSetOut;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-    gc.orDynamicResolver = refDynamicResolver;
-
-    GCPROTECT_BEGIN(gc);
-
-    // Fetch input objects that might originate from a different appdomain,
-    // marshalling if necessary.
-    gc.orDemandSet = m_objects.GetObject(pDomain);
-
-    // Switch into the destination context if necessary.
-    ENTER_DOMAIN_PTR(pDomain,ADV_RUNNINGIN) //have it on the stack
-    {
-        PREPARE_NONVIRTUAL_CALLSITE(METHOD__SECURITY_RUNTIME__CHECK_DYNAMIC_METHOD_SET_HELPER);
-
-        DECLARE_ARGHOLDER_ARRAY(args, 4);
-        args[ARGNUM_0] = OBJECTREF_TO_ARGHOLDER(gc.orDynamicResolver);
-        args[ARGNUM_1] = OBJECTREF_TO_ARGHOLDER(gc.orDemandSet);
-        args[ARGNUM_2] = PTR_TO_ARGHOLDER(&gc.orPermSetOut);
-        args[ARGNUM_3] = PTR_TO_ARGHOLDER(pMethod);
-
-        CATCH_HANDLER_FOUND_NOTIFICATION_CALLSITE;
-        CALL_MANAGED_METHOD(ret, CLR_BOOL, args);
-
-        if (gc.orPermSetOut != NULL) {
-            // Update the cached object.
-            m_objects.UpdateObject(pDomain, gc.orPermSetOut);
-        }
-    }
-    END_DOMAIN_TRANSITION;
-
-    GCPROTECT_END();
-
-    return ret;
-}
-
-
-BOOL DemandStackWalk::CheckAnonymouslyHostedDynamicMethodCompressedStackPermission(OBJECTREF refDynamicResolver, AppDomain* pDomain, MethodDesc* pMethod)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    CLR_BOOL ret = FALSE;
-
-
-    struct _gc {
-        OBJECTREF orDynamicResolver;
-        OBJECTREF orDemand;
-        OBJECTREF orToken;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-    gc.orDynamicResolver = refDynamicResolver;
-
-    GCPROTECT_BEGIN(gc);
-
-    // Fetch input objects that might originate from a different appdomain,
-    // marshalling if necessary.
-    gc.orDemand = m_objects.GetObjects(pDomain, &gc.orToken);
-
-    // Switch into the destination context if necessary.
-    ENTER_DOMAIN_PTR(pDomain,ADV_RUNNINGIN) //have it on the stack
-    {
-        PREPARE_NONVIRTUAL_CALLSITE(METHOD__SECURITY_RUNTIME__CHECK_DYNAMIC_METHOD_HELPER);
-
-        DECLARE_ARGHOLDER_ARRAY(args, 4);
-        args[ARGNUM_0] = OBJECTREF_TO_ARGHOLDER(gc.orDynamicResolver);
-        args[ARGNUM_1] = OBJECTREF_TO_ARGHOLDER(gc.orDemand);
-        args[ARGNUM_2] = OBJECTREF_TO_ARGHOLDER(gc.orToken);
-        args[ARGNUM_3] = PTR_TO_ARGHOLDER(pMethod);
-
-        CATCH_HANDLER_FOUND_NOTIFICATION_CALLSITE;
-        CALL_MANAGED_METHOD(ret, CLR_BOOL, args);
-    }
-    END_DOMAIN_TRANSITION;
-
-    GCPROTECT_END();
-
-    return ret;
-}
-#endif // FEATURE_COMPRESSEDSTACK
-
-
-
-
-// -------------------------------------------------------------------------------
-//
-//                                 AssertStackWalk
-//
-// -------------------------------------------------------------------------------
-
-class AssertStackWalk : public SecurityStackWalk
-{
-protected:
-    StackCrawlMark *        m_pStackMark;
-    bool                    m_bHaveFoundStartingFrameYet;
-    INT_PTR                 m_cCheck;
-
-public:
-    OBJECTREF*              m_pSecurityObject;
-    AppDomain*              m_pSecurityObjectDomain;
-
-    AssertStackWalk(SecurityStackWalkType eType, DWORD dwFlags, StackCrawlMark* stackMark)
-        : SecurityStackWalk(eType, dwFlags)
-    {
-        LIMITED_METHOD_CONTRACT;
-        m_pStackMark = stackMark;
-        m_bHaveFoundStartingFrameYet = false;
-        m_cCheck = 1;
-        m_pSecurityObject = NULL;
-        m_pSecurityObjectDomain = NULL;
-    }
-
-    void DoStackWalk();
-    StackWalkAction WalkFrame(CrawlFrame* pCf);
-};
-
-StackWalkAction AssertStackWalk::WalkFrame(CrawlFrame* pCf)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    DBG_TRACE_METHOD(pCf);
-
-    MethodDesc * pFunc = pCf->GetFunction();
-    _ASSERTE(pFunc != NULL); // we requested functions only!
-    _ASSERTE(m_eStackWalkType == SSWT_IMPERATIVE_ASSERT);
-    _ASSERTE(*m_pStackMark == LookForMyCaller);
-
-    // Skip until we pass the StackMark
-    if (!m_bHaveFoundStartingFrameYet)
-    {
-        if (pCf->IsInCalleesFrames(m_pStackMark))
-            m_bHaveFoundStartingFrameYet = true;
-        else
-            return SWA_CONTINUE;
-    }
-
-    // Check if we've visited the maximum number of frames
-    if (m_cCheck >= 0)
-    {
-        if (m_cCheck == 0)
-        {
-            m_dwFlags |= CORSEC_STACKWALK_HALTED;
-            return SWA_ABORT;
-        }
-        else
-            --m_cCheck;
-    }
-
-    // Reached here imples we walked atleast a single frame.
-    COUNTER_ONLY(GetPerfCounters().m_Security.stackWalkDepth++);
-
-    DBG_TRACE_STACKWALK("            Checking grants for current assembly.\n", true);
-
-    // Get the security descriptor for the current assembly and pass it to
-    // the interpreted helper.
-    // Get the current assembly
-    Assembly *pAssem = pFunc->GetModule()->GetAssembly();
-    AppDomain *pAppDomain = pCf->GetAppDomain();
-    IAssemblySecurityDescriptor * pSecDesc = pAssem->GetSecurityDescriptor(pAppDomain);
-    _ASSERTE(pSecDesc != NULL);
-     
-    
-    if (!SecurityTransparent::IsAllowedToAssert(pFunc))
-    {
-        // Transparent method can't have the permission to Assert
-        COMPlusThrow(kInvalidOperationException,W("InvalidOperation_AssertTransparentCode"));
-    }
-
-    if (!pSecDesc->IsSystem() && !pSecDesc->IsFullyTrusted())
-    {
-        OBJECTREF orRefused;
-        OBJECTREF orGranted = pSecDesc->GetGrantedPermissionSet(&orRefused);
-        CheckPermissionAgainstGrants(NULL, orGranted, orRefused, pAppDomain, pFunc, pAssem);  
-    }
-
-    // Passed initial check. See if there is security info on this frame.
-    m_pSecurityObject = pCf->GetAddrOfSecurityObject();
-    m_pSecurityObjectDomain = pAppDomain;
-
-    DBG_TRACE_STACKWALK("        Check Immediate passes for this method.\n", true);
-
-    // Passed all the checks, so continue.
-    return SWA_ABORT;
-}
-
-static
-StackWalkAction CheckNReturnSOStackWalkCB(CrawlFrame* pCf, VOID* pData)
-{
-    WRAPPER_NO_CONTRACT;
-    AssertStackWalk *pCBdata = (AssertStackWalk*)pData;
-    return pCBdata->WalkFrame(pCf);
-}
-
-FCIMPL4(Object*, SecurityStackWalk::CheckNReturnSO, Object* permTokenUNSAFE, Object* permUNSAFE, StackCrawlMark* stackMark, INT32 create)
-{
-    FCALL_CONTRACT;
-
-    OBJECTREF refRetVal = NULL;
-    OBJECTREF permToken = (OBJECTREF) permTokenUNSAFE;
-    OBJECTREF perm      = (OBJECTREF) permUNSAFE;
-    HELPER_METHOD_FRAME_BEGIN_RET_2(permToken, perm);
-    
-    _ASSERTE((permToken != NULL) && (perm != NULL));
-
-    // Track perfmon counters. Runtime security checkes.
-    IncrementSecurityPerfCounter();
-
-#if defined(ENABLE_PERF_COUNTERS)
-    // Perf Counter "%Time in Runtime check" support
-    PERF_COUNTER_TIMER_PRECISION _startPerfCounterTimer = GET_CYCLE_COUNT();
-#endif
-
-    // Initialize callback data.
-    DWORD dwFlags = 0;
-    AssertStackWalk walkData(SSWT_IMPERATIVE_ASSERT, dwFlags, stackMark);
-    walkData.m_objects.SetObjects(perm, permToken);
-
-    // Protect the object references in the callback data.
-    GCPROTECT_BEGIN(walkData.m_objects.m_sGC);
-
-    walkData.DoStackWalk();
-
-    GCPROTECT_END();
-
-#if defined(ENABLE_PERF_COUNTERS)
-    // Accumulate the counter
-    PERF_COUNTER_TIMER_PRECISION _stopPerfCounterTimer = GET_CYCLE_COUNT();
-    g_TotalTimeInSecurityRuntimeChecks += _stopPerfCounterTimer - _startPerfCounterTimer;
-
-    // Report the accumulated counter only after NUM_OF_TERATIONS
-    if (g_SecurityChecksIterations++ > PERF_COUNTER_NUM_OF_ITERATIONS)
-    {
-        GetPerfCounters().m_Security.timeRTchecks = static_cast<DWORD>(g_TotalTimeInSecurityRuntimeChecks);
-        GetPerfCounters().m_Security.timeRTchecksBase = static_cast<DWORD>(_stopPerfCounterTimer - g_LastTimeInSecurityRuntimeChecks);
-        
-        g_TotalTimeInSecurityRuntimeChecks = 0;
-        g_LastTimeInSecurityRuntimeChecks = _stopPerfCounterTimer;
-        g_SecurityChecksIterations = 0;
-    }
-#endif // #if defined(ENABLE_PERF_COUNTERS)
-
-    if (walkData.m_pSecurityObject == NULL)
-    {
-        goto lExit;
-    }
-
-    // Is security object frame in a different context?
-    Thread *pThread;
-    pThread = GetThread();
-    bool fSwitchContext;
-    
-    fSwitchContext = walkData.m_pSecurityObjectDomain != pThread->GetDomain();
-    if (create && *walkData.m_pSecurityObject == NULL)
-    {
-        // If necessary, shift to correct context to allocate security object.
-        ENTER_DOMAIN_PTR(walkData.m_pSecurityObjectDomain,ADV_RUNNINGIN) //on the stack
-        {
-            MethodTable* pMethFrameSecDesc = MscorlibBinder::GetClass(CLASS__FRAME_SECURITY_DESCRIPTOR);
-
-            *walkData.m_pSecurityObject = AllocateObject(pMethFrameSecDesc);
-        }
-        END_DOMAIN_TRANSITION;
-    }
-
-    // If we found or created a security object in a different context, make a
-    // copy in the current context.
-#ifndef FEATURE_CORECLR   // should not happen in core clr     
-    if (fSwitchContext && *walkData.m_pSecurityObject != NULL)
-        refRetVal = AppDomainHelper::CrossContextCopyFrom(walkData.m_pSecurityObjectDomain, 
-                                                                walkData.m_pSecurityObject);
-    else
-#else
-    _ASSERTE(!fSwitchContext);
-#endif
-
-    refRetVal = *walkData.m_pSecurityObject;
-
-lExit: ;
-    HELPER_METHOD_FRAME_END();
-    return OBJECTREFToObject(refRetVal);
-}
-FCIMPLEND
-
-
-void AssertStackWalk::DoStackWalk()
-{
-    // Get the current thread.
-    Thread *pThread = GetThread();
-    _ASSERTE(pThread != NULL);
-
-    // NOTE: Initialize the stack depth. Note that if more that one thread tries
-    // to perform stackwalk then these counters gets stomped upon. 
-    COUNTER_ONLY(GetPerfCounters().m_Security.stackWalkDepth = 0);
-
-    // Walk the thread.
-    DBG_TRACE_STACKWALK("Code-access security check immediate invoked.\n", false);
-    // LIGHTUNWIND flag: allow using stackwalk cache for security stackwalks
-    pThread->StackWalkFrames(CheckNReturnSOStackWalkCB, this, FUNCTIONSONLY | SKIPFUNCLETS | LIGHTUNWIND);
-
-    DBG_TRACE_STACKWALK("\tCode-access stackwalk completed.\n", false);
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-// -------------------------------------------------------------------------------
-//
-//                                 CountOverridesStackWalk
-//
-// -------------------------------------------------------------------------------
-
-typedef struct _SkipFunctionsData
-{
-    INT32           cSkipFunctions;
-    StackCrawlMark* pStackMark;
-    BOOL            bUseStackMark;
-    BOOL            bFoundCaller;
-    MethodDesc*     pFunction;
-    OBJECTREF*      pSecurityObject;
-    AppDomain*      pSecurityObjectAppDomain;
-} SkipFunctionsData;
-
-static StackWalkAction SkipFunctionsCB(CrawlFrame* pCf, VOID* pData)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    } CONTRACTL_END;
-    SkipFunctionsData *skipData = (SkipFunctionsData*)pData;
-    _ASSERTE(skipData != NULL);
-
-    MethodDesc *pFunc = pCf->GetFunction();
-
-#ifdef _DEBUG
-    // Get the interesting info now, so we can get a trace
-    // while debugging...
-    OBJECTREF  *pSecObj;
-    pSecObj = pCf->GetAddrOfSecurityObject();
-#endif
-
-    _ASSERTE(skipData->bUseStackMark && "you must specify a stackmark");
-
-    // First check if the walk has skipped the required frames. The check
-    // here is between the address of a local variable (the stack mark) and a
-    // pointer to the EIP for a frame (which is actually the pointer to the
-    // return address to the function from the previous frame). So we'll
-    // actually notice which frame the stack mark was in one frame later. This
-    // is fine for our purposes since we're always looking for the frame of the
-    // caller of the method that actually created the stack mark.
-    if ((skipData->pStackMark != NULL) &&
-        !pCf->IsInCalleesFrames(skipData->pStackMark))
-
-        return SWA_CONTINUE;
-
-    skipData->pFunction                 = pFunc;
-    skipData->pSecurityObject           = pCf->GetAddrOfSecurityObject();
-    skipData->pSecurityObjectAppDomain  = pCf->GetAppDomain();
-    return SWA_ABORT; // This actually indicates success.
-}
-
-// Version of the above method that looks for a stack mark (the address of a
-// local variable in a frame called by the target frame).
-BOOL SecurityStackWalk::SkipAndFindFunctionInfo(StackCrawlMark* stackMark, MethodDesc ** ppFunc, OBJECTREF ** ppObj, AppDomain ** ppAppDomain)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    } CONTRACTL_END;
-    _ASSERTE(ppFunc != NULL || ppObj != NULL || !"Why was this function called?!");
-
-    SkipFunctionsData walkData;
-    walkData.pStackMark = stackMark;
-    walkData.bUseStackMark = TRUE;
-    walkData.bFoundCaller = FALSE;
-    walkData.pFunction = NULL;
-    walkData.pSecurityObject = NULL;
-    // LIGHTUNWIND flag: allow using stackwalk cache for security stackwalks
-    StackWalkAction action = GetThread()->StackWalkFrames(SkipFunctionsCB, &walkData, FUNCTIONSONLY | SKIPFUNCLETS | LIGHTUNWIND);
-    if (action == SWA_ABORT)
-    {
-        if (ppFunc != NULL)
-            *ppFunc = walkData.pFunction;
-        if (ppObj != NULL)
-        {
-            *ppObj = walkData.pSecurityObject;
-            if (ppAppDomain != NULL)
-                *ppAppDomain = walkData.pSecurityObjectAppDomain;
-        }
-        return TRUE;
-    }
-    else
-    {
-        return FALSE;
-    }
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-// -------------------------------------------------------------------------------
-//
-//                                 CountOverridesStackWalk
-//
-// -------------------------------------------------------------------------------
-
-class CountOverridesStackWalk
-{
-public:
-    DWORD           numOverrides; // Can be removed
-    DWORD           numAsserts; // Can be removed
-    DWORD           numDomainOverrides;
-    DWORD           numDomainAsserts;
-    AppDomain*      prev_AppDomain;
-    Frame*          pCtxTxFrame;
-    DWORD           adStackIndex;
-
-    CountOverridesStackWalk()
-    {
-	    LIMITED_METHOD_CONTRACT;
-        numOverrides = 0;
-        numAsserts = 0;
-        numDomainAsserts = 0;
-        numDomainOverrides = 0;
-        prev_AppDomain = NULL;
-        pCtxTxFrame = NULL;
-        GetThread()->InitDomainIteration(&adStackIndex);
-    }
-    bool IsSpecialRunFrame(MethodDesc* pMeth)
-    {
-        return SecurityStackWalk::IsSpecialRunFrame(pMeth);
-    }
-};
-
-static 
-StackWalkAction UpdateOverridesCountCB(CrawlFrame* pCf, void *pData)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    DBG_TRACE_METHOD(pCf);
-
-    CountOverridesStackWalk *pCBdata = static_cast<CountOverridesStackWalk *>(pData);
-
-
-    // First check if the walk has skipped the required frames. The check
-    // here is between the address of a local variable (the stack mark) and a
-    // pointer to the EIP for a frame (which is actually the pointer to the
-    // return address to the function from the previous frame). So we'll
-    // actually notice which frame the stack mark was in one frame later. This
-    // is fine for our purposes since we're always looking for the frame of the
-    // caller (or the caller's caller) of the method that actually created the
-    // stack mark.
-
-#ifdef FEATURE_REMOTING
-#ifdef FEATURE_COMPRESSEDSTACK
-
-    // Save the CtxTxFrame if this is one
-    if (pCBdata->pCtxTxFrame == NULL)
-    {
-        Frame *pFrame = pCf->GetFrame();
-        if (SecurityStackWalk::IsContextTransitionFrameWithCS(pFrame))
-        {
-            pCBdata->pCtxTxFrame = pFrame;
-        }
-    }
-#endif // #ifdef FEATURE_COMPRESSEDSTACK    
-#endif // FEATURE_REMOTING
-    MethodDesc* pMeth = pCf->GetFunction();
-    if (pMeth == NULL || pMeth->IsILStub())
-        return SWA_CONTINUE; // not a function frame and not a security stub.
-                             // Since we were just looking for CtxTransitionFrames, resume the stackwalk...
-        
-
-
-
-    AppDomain* pAppDomain = pCf->GetAppDomain();
-    if (pCBdata->prev_AppDomain == NULL)
-    {
-        pCBdata->prev_AppDomain = pAppDomain; //innermost AD
-    }
-    else if (pCBdata->prev_AppDomain != pAppDomain)
-    {
-        // AppDomain Transition
-        // Update the values in the ADStack for the current AD
-        Thread *t = GetThread();
-        t->GetNextDomainOnStack(&pCBdata->adStackIndex, NULL, NULL);
-        t->UpdateDomainOnStack(pCBdata->adStackIndex, pCBdata->numDomainAsserts, pCBdata->numDomainOverrides);
-
-        // Update CBdata values
-        pCBdata->numAsserts+= pCBdata->numDomainAsserts;
-        pCBdata->numOverrides += pCBdata->numDomainOverrides;
-        pCBdata->numDomainAsserts = 0;
-        pCBdata->numDomainOverrides = 0;
-        pCBdata->prev_AppDomain = pAppDomain;
-        
-    }
-    // Get the security object for this function...
-    OBJECTREF* pRefSecDesc = pCf->GetAddrOfSecurityObject();
-    if (pRefSecDesc != NULL)
-    {
-        SecurityDeclarative::DoDeclarativeSecurityAtStackWalk(pMeth, pAppDomain, pRefSecDesc);
-        FRAMESECDESCREF refFSD = *((FRAMESECDESCREF*)pRefSecDesc);
-        if (refFSD != NULL)
-        {
-        
-            INT32       ret = refFSD->GetOverridesCount();
-            pCBdata->numDomainAsserts+= refFSD->GetAssertCount();
-            
-            if (ret > 0)
-            {
-                DBG_TRACE_STACKWALK("       SecurityDescriptor with overrides FOUND.\n", false);
-                pCBdata->numDomainOverrides += ret;
-            }
-            else
-            {
-                DBG_TRACE_STACKWALK("       SecurityDescriptor with no override found.\n", false);
-            }
-        }
-        
-    }
-
-#ifdef FEATURE_COMPRESSEDSTACK
-    if(SecurityStackWalk::MethodIsAnonymouslyHostedDynamicMethodWithCSToEvaluate(pMeth))
-    {
-        pCBdata->numDomainAsserts++;
-        pCBdata->numDomainOverrides++;
-    }
-#endif // FEATURE_COMPRESSEDSTACK
-
-    // If this is a *.Run method, 
-    // or if it has a CompressedStack then we need to terminate the stackwalk
-    if (pCBdata->IsSpecialRunFrame(pMeth))
-    {
-        DBG_TRACE_STACKWALK("            Halting stackwalk for .Run.\n", false);
-        return SWA_ABORT;
-    }
-    
-    return SWA_CONTINUE;
-}
-
-VOID SecurityStackWalk::UpdateOverridesCount()
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    //
-    // Initialize the callback data on the stack.
-    //
-
-    CountOverridesStackWalk walkData;
-
-    // Get the current thread that we're to walk.
-    Thread * t = GetThread();
-
-    
-    // Don't allow recursive security stackwalks. Note that this implies that
-    // *no* untrusted code must ever be called during a security stackwalk.
-    if (t->IsSecurityStackwalkInProgess())
-        return;
-    
-    EX_TRY
-    {
-        t->SetSecurityStackwalkInProgress( TRUE );
-
-        //
-        // Begin the stack walk
-        //
-        DBG_TRACE_STACKWALK(" Update Overrides Count invoked .\n", false);
-        // LIGHTUNWIND flag: allow using stackwalk cache for security stackwalks
-        t->StackWalkFrames(UpdateOverridesCountCB, &walkData, SKIPFUNCLETS | LIGHTUNWIND);
-#ifdef FEATURE_COMPRESSEDSTACK
-        COMPRESSEDSTACKREF csRef = (COMPRESSEDSTACKREF)t->GetCompressedStack();
-
-        // There may have been an AD transition and we shd look at the CB data to see if this is the case
-        if (csRef == NULL && walkData.pCtxTxFrame != NULL)
-        {
-            csRef = SecurityStackWalk::GetCSFromContextTransitionFrame(walkData.pCtxTxFrame);
-        }
-
-        // Use CS if found
-        if (csRef != NULL)
-        {
-
-            walkData.numDomainOverrides += StackCompressor::GetCSInnerAppDomainOverridesCount(csRef);
-            walkData.numDomainAsserts += StackCompressor::GetCSInnerAppDomainAssertCount(csRef);
-        }
-#endif // #ifdef FEATURE_COMPRESSEDSTACK        
-        t->GetNextDomainOnStack(&walkData.adStackIndex, NULL, NULL);
-        t->UpdateDomainOnStack(walkData.adStackIndex, walkData.numDomainAsserts, walkData.numDomainOverrides);
-        walkData.numAsserts += walkData.numDomainAsserts;
-        walkData.numOverrides += walkData.numDomainOverrides;
-
-        t->SetSecurityStackwalkInProgress( FALSE );
-    }
-    EX_CATCH
-    {
-        // We catch exceptions and rethrow like this to ensure that we've
-        // established an exception handler on the fs:[0] chain (managed
-        // exception handlers won't do this). This in turn guarantees that
-        // managed exception filters in any of our callers won't be found,
-        // otherwise they could get to execute untrusted code with security
-        // turned off.
-        t->SetSecurityStackwalkInProgress( FALSE );
-
-        EX_RETHROW;
-    }
-    EX_END_CATCH_UNREACHABLE
-
-
-    
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-// -------------------------------------------------------------------------------
-//
-//                                 COMCodeAccessSecurityEngine
-//
-// -------------------------------------------------------------------------------
-#ifdef FEATURE_COMPRESSEDSTACK
-COMPRESSEDSTACKREF SecurityStackWalk::GetCSFromContextTransitionFrame(Frame *pFrame)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-    EXECUTIONCONTEXTREF ecRef = NULL;
-
-    if (pFrame != NULL)
-        ecRef = (EXECUTIONCONTEXTREF)pFrame->GetReturnExecutionContext();
-    if (ecRef != NULL)
-        return (ecRef->GetCompressedStack());
-    
-    return NULL;
-}
-
-#endif // #ifdef FEATURE_COMPRESSEDSTACK
-
-//-----------------------------------------------------------+
-// Helper used to check a demand set against a provided grant
-// and possibly denied set. Grant and denied set might be from
-// another domain.
-//-----------------------------------------------------------+
-void SecurityStackWalk::CheckSetHelper(OBJECTREF *prefDemand,
-                                                 OBJECTREF *prefGrant,
-                                                 OBJECTREF *prefRefused,
-                                                 AppDomain *pGrantDomain,
-                                                 MethodDesc *pMethod,
-                                                 OBJECTREF *pAssembly,
-                                                 CorDeclSecurity action)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(IsProtectedByGCFrame (prefDemand));
-        PRECONDITION(IsProtectedByGCFrame (prefGrant));
-        PRECONDITION(IsProtectedByGCFrame (prefRefused));
-        PRECONDITION(IsProtectedByGCFrame (pAssembly));
-    } CONTRACTL_END;
-
-    // We might need to marshal the grant and denied sets into the current
-    // domain.
-#ifndef FEATURE_CORECLR   // should not happen in core clr         
-    if (pGrantDomain != GetAppDomain())
-    {
-        *prefGrant = AppDomainHelper::CrossContextCopyFrom(pGrantDomain, prefGrant);
-        if (*prefRefused != NULL)
-            *prefRefused = AppDomainHelper::CrossContextCopyFrom(pGrantDomain, prefRefused);
-    }
-#else
-    _ASSERTE(pGrantDomain == GetAppDomain());
-#endif
-    MethodDescCallSite checkSetHelper(METHOD__SECURITY_ENGINE__CHECK_SET_HELPER);
-
-    ARG_SLOT args[] = {
-        ObjToArgSlot(NULL),
-        ObjToArgSlot(*prefGrant),
-        ObjToArgSlot(*prefRefused),
-        ObjToArgSlot(*prefDemand),
-        PtrToArgSlot(pMethod),
-        ObjToArgSlot(*pAssembly),
-        (ARG_SLOT)action
-    };
-
-    checkSetHelper.Call(args);
-}
-
-
-
-
-
-FCIMPL0(FC_BOOL_RET, SecurityStackWalk::FCallQuickCheckForAllDemands)
-{
-    FCALL_CONTRACT;
-    // This function collides with SecurityPolicy::IsDefaultThreadSecurityInfo    
-    FCUnique(0x17);
-    FC_RETURN_BOOL(QuickCheckForAllDemands(0));
-
-}
-FCIMPLEND
-
-FCIMPL0(FC_BOOL_RET, SecurityStackWalk::FCallAllDomainsHomogeneousWithNoStackModifiers)
-{
-    FCALL_CONTRACT;
-
-    Thread* t = GetThread();
-    FC_RETURN_BOOL(t->AllDomainsHomogeneousWithNoStackModifiers());
-
-}
-FCIMPLEND
-
-//-----------------------------------------------------------
-// Native implementation for code-access security check.
-// Checks that callers on the stack have the permission
-// specified in the arguments or checks for unrestricted
-// access if the permission is null.
-//-----------------------------------------------------------
-FCIMPL3(void, SecurityStackWalk::Check, Object* permOrPermSetUNSAFE, StackCrawlMark* stackMark, CLR_BOOL isPermSet)
-{
-    FCALL_CONTRACT;
-
-    if (QuickCheckForAllDemands(0))
-        return;
-    
-    FC_INNER_RETURN_VOID(CheckFramed(permOrPermSetUNSAFE, stackMark, isPermSet));
-}
-FCIMPLEND
-    
-NOINLINE void SecurityStackWalk::CheckFramed(Object* permOrPermSetUNSAFE, 
-                                            StackCrawlMark* stackMark, 
-                                            CLR_BOOL isPermSet)
-{
-    CONTRACTL {
-        THROWS;
-        DISABLED(GC_TRIGGERS); // FCALLS with HELPER frames have issues with GC_TRIGGERS
-        MODE_COOPERATIVE;
-        SO_TOLERANT;
-    } CONTRACTL_END;
-
-    FC_INNER_PROLOG(SecurityStackWalk::Check);
-
-    OBJECTREF permOrPermSet      = (OBJECTREF) permOrPermSetUNSAFE;
-    HELPER_METHOD_FRAME_BEGIN_ATTRIB_1(Frame::FRAME_ATTR_CAPTURE_DEPTH_2, permOrPermSet);
-
-    Check_PLS_SW(isPermSet, SSWT_IMPERATIVE_DEMAND, &permOrPermSet, stackMark);
-
-    HELPER_METHOD_FRAME_END();
-    FC_INNER_EPILOG();
-}
-
-
-void SecurityStackWalk::Check_PLS_SW(BOOL isPermSet,
-                                     SecurityStackWalkType eType, 
-                                     OBJECTREF* permOrPermSet, 
-                                     StackCrawlMark* stackMark)
-{
-    
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    if (!PreCheck(permOrPermSet, isPermSet))
-    {
-        Check_StackWalk(eType, permOrPermSet, stackMark, isPermSet);
-    }
-}
-void SecurityStackWalk::Check_PLS_SW_GC( BOOL isPermSet,
-                                         SecurityStackWalkType eType, 
-                                         OBJECTREF permOrPermSet, 
-                                         StackCrawlMark* stackMark)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-    GCPROTECT_BEGIN(permOrPermSet);
-    Check_PLS_SW(isPermSet, eType, &permOrPermSet, stackMark);
-    GCPROTECT_END();
-}
-
-void SecurityStackWalk::Check_StackWalk(SecurityStackWalkType eType, 
-                                        OBJECTREF* pPermOrPermSet, 
-                                        StackCrawlMark* stackMark, 
-                                        BOOL isPermSet)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(*pPermOrPermSet != NULL);
-    } CONTRACTL_END;
-
-#if defined(ENABLE_PERF_COUNTERS)
-    // Perf Counter "%Time in Runtime check" support
-    PERF_COUNTER_TIMER_PRECISION _startPerfCounterTimer = GET_CYCLE_COUNT();
-#endif
-
-    if (GetThread()->GetOverridesCount() != 0)
-    {
-        // First let's make sure the overrides count is OK.
-        UpdateOverridesCount();
-        // Once the overrides count has been fixes, let's see if we really need to stackwalk
-        // This is an additional cost if we do need to walk, but can remove an unnecessary SW otherwise.
-        // Pick your poison.
-        if (QuickCheckForAllDemands(0))
-            return; // 
-    }
-    // Initialize callback data.
-    DWORD dwFlags = 0;
-    DWORD demandFlags = GetPermissionSpecialFlags(pPermOrPermSet);
-
-    DemandStackWalk walkData(eType, dwFlags, stackMark, (isPermSet?DemandStackWalk::DT_SET:DemandStackWalk::DT_PERMISSION), demandFlags);
-    walkData.m_objects.SetObject(*pPermOrPermSet);
-
-    // Protect the object references in the callback data.
-    GCPROTECT_BEGIN(walkData.m_objects.m_sGC);
-
-    walkData.DoStackWalk();
-
-    GCPROTECT_END();
-
-#if defined(ENABLE_PERF_COUNTERS)
-    // Accumulate the counter
-    PERF_COUNTER_TIMER_PRECISION _stopPerfCounterTimer = GET_CYCLE_COUNT();
-    g_TotalTimeInSecurityRuntimeChecks += _stopPerfCounterTimer - _startPerfCounterTimer;
-
-    // Report the accumulated counter only after NUM_OF_TERATIONS
-    if (g_SecurityChecksIterations++ > PERF_COUNTER_NUM_OF_ITERATIONS)
-    {
-        GetPerfCounters().m_Security.timeRTchecks = static_cast<DWORD>(g_TotalTimeInSecurityRuntimeChecks);
-        GetPerfCounters().m_Security.timeRTchecksBase = static_cast<DWORD>(_stopPerfCounterTimer - g_LastTimeInSecurityRuntimeChecks);
-        
-        g_TotalTimeInSecurityRuntimeChecks = 0;
-        g_LastTimeInSecurityRuntimeChecks = _stopPerfCounterTimer;
-        g_SecurityChecksIterations = 0;
-    }
-#endif // #if defined(ENABLE_PERF_COUNTERS)
-}
-
-FCIMPL3(void, SecurityStackWalk::GetZoneAndOrigin, Object* pZoneListUNSAFE, Object* pOriginListUNSAFE, StackCrawlMark* stackMark)
-{
-    FCALL_CONTRACT;
-
-    OBJECTREF zoneList    = (OBJECTREF) pZoneListUNSAFE;
-    OBJECTREF originList  = (OBJECTREF) pOriginListUNSAFE;
-    HELPER_METHOD_FRAME_BEGIN_2(zoneList, originList);
-
-    // Initialize callback data.
-    DWORD dwFlags = 0;
-    DemandStackWalk walkData(SSWT_GET_ZONE_AND_URL, dwFlags, stackMark, DemandStackWalk::DT_ZONE_AND_URL, 0);
-    walkData.m_objects.SetObjects(zoneList, originList);
-
-    GCPROTECT_BEGIN(walkData.m_objects.m_sGC);
-
-    walkData.DoStackWalk();
-
-    GCPROTECT_END();
-
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-
-
-#ifdef FEATURE_COMPRESSEDSTACK
-FCIMPL1(VOID, SecurityStackWalk::FcallDestroyDelayedCompressedStack, void *compressedStack) 
-{
-    FCALL_CONTRACT;
-
-    HELPER_METHOD_FRAME_BEGIN_0();
-
-    StackCompressor::Destroy(compressedStack);
-
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-#endif // FEATURE_COMPRESSEDSTACK
-//
-// This method checks a few special demands in case we can 
-// avoid looking at the real PLS object.
-//
-
-DWORD SecurityStackWalk::GetPermissionSpecialFlags (OBJECTREF* orDemand)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM(););
-    } CONTRACTL_END;
-
-    MethodTable* pMethPermissionSet = MscorlibBinder::GetClass(CLASS__PERMISSION_SET);
-    MethodTable* pMethNamedPermissionSet = MscorlibBinder::GetClass(CLASS__NAMEDPERMISSION_SET);
-    MethodTable* pMethReflectionPermission = MscorlibBinder::GetClass(CLASS__REFLECTION_PERMISSION);
-    MethodTable* pMethSecurityPermission = MscorlibBinder::GetClass(CLASS__SECURITY_PERMISSION);
-
-    DWORD dwSecurityPermissionFlags = 0, dwReflectionPermissionFlags = 0;
-    MethodTable* pMeth = (*orDemand)->GetMethodTable();
-    if (pMeth == pMethPermissionSet || pMeth == pMethNamedPermissionSet) {
-        // NamedPermissionSet derives from PermissionSet and we're interested only
-        // in the fields in PermissionSet: so it's OK to cast to the unmanaged 
-        // equivalent of PermissionSet even for a NamedPermissionSet object
-        PERMISSIONSETREF permSet = (PERMISSIONSETREF) *orDemand;
-        
-        if (permSet->IsUnrestricted()) {
-            return (1 << SECURITY_FULL_TRUST);
-        }
-        TOKENBASEDSETREF tokenBasedSet = (TOKENBASEDSETREF) permSet->GetTokenBasedSet();
-        if (tokenBasedSet != NULL && tokenBasedSet->GetNumElements() == 1 && tokenBasedSet->GetPermSet() != NULL) {
-            pMeth = (tokenBasedSet->GetPermSet())->GetMethodTable();
-
-            if (pMeth == pMethReflectionPermission) {
-                dwReflectionPermissionFlags = ((REFLECTIONPERMISSIONREF) tokenBasedSet->GetPermSet())->GetFlags();
-            }
-            else if (pMeth == pMethSecurityPermission) {
-                dwSecurityPermissionFlags = ((SECURITYPERMISSIONREF) tokenBasedSet->GetPermSet())->GetFlags();
-            }
-        }
-    }
-    else {        
-        if (pMeth == pMethReflectionPermission)
-            dwReflectionPermissionFlags = ((REFLECTIONPERMISSIONREF) (*orDemand))->GetFlags();
-        else if (pMeth == pMethSecurityPermission)
-            dwSecurityPermissionFlags = ((SECURITYPERMISSIONREF) (*orDemand))->GetFlags();
-    }
-
-    if (pMeth == pMethReflectionPermission) {
-        switch (dwReflectionPermissionFlags) {
-        case REFLECTION_PERMISSION_TYPEINFO:
-            return (1 << REFLECTION_TYPE_INFO);
-        case REFLECTION_PERMISSION_MEMBERACCESS:
-            return (1 << REFLECTION_MEMBER_ACCESS);
-        case REFLECTION_PERMISSION_RESTRICTEDMEMBERACCESS:
-            return (1 << REFLECTION_RESTRICTED_MEMBER_ACCESS);
-        default:
-            return 0; // There is no mapping for this reflection permission flag
-        }
-    } else if (pMeth == pMethSecurityPermission) {
-        switch (dwSecurityPermissionFlags) {
-        case SECURITY_PERMISSION_ASSERTION:
-            return (1 << SECURITY_ASSERT);
-        case SECURITY_PERMISSION_UNMANAGEDCODE:
-            return (1 << SECURITY_UNMANAGED_CODE);
-        case SECURITY_PERMISSION_SKIPVERIFICATION:
-            return (1 << SECURITY_SKIP_VER);
-        case SECURITY_PERMISSION_SERIALIZATIONFORMATTER:
-            return (1 << SECURITY_SERIALIZATION);
-        case SECURITY_PERMISSION_BINDINGREDIRECTS:
-            return (1 << SECURITY_BINDING_REDIRECTS);
-        case SECURITY_PERMISSION_CONTROLEVIDENCE:
-            return (1 << SECURITY_CONTROL_EVIDENCE);
-        case SECURITY_PERMISSION_CONTROLPRINCIPAL:
-            return (1 << SECURITY_CONTROL_PRINCIPAL);
-        default:
-            return 0; // There is no mapping for this security permission flag
-        }
-    }
-
-    // We couldn't find an exact match for the permission, so we'll just return no flags.
-    return 0;
-}
-
-// check is a stackwalk is needed to evaluate the demand
-BOOL SecurityStackWalk::PreCheck (OBJECTREF* orDemand, BOOL fDemandSet)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    // Track perfmon counters. Runtime security checks.
-    IncrementSecurityPerfCounter();
-
-    Thread* pThread = GetThread();
-    // The PLS optimization does not support overrides.
-    if (pThread->GetOverridesCount() > 0)
-        return FALSE;
-
-    DWORD dwDemandSpecialFlags = GetPermissionSpecialFlags(orDemand);
-
-    // If we were able to map the demand to an exact permission special flag, and we know that all code on
-    // this stack has been granted that permission, then we can take the fast path and allow the demand to
-    // succeed.
-    if (dwDemandSpecialFlags != 0)
-    {
-        return  SecurityStackWalk::HasFlagsOrFullyTrustedIgnoreMode(dwDemandSpecialFlags);
-    }
-
-#ifdef FEATURE_PLS
-    // If we know there is only one AppDomain, then there is
-    // no need to walk the AppDomainStack structure.
-    if (pThread->GetNumAppDomainsOnThread() == 1)
-    {
-        ApplicationSecurityDescriptor* pASD = static_cast<ApplicationSecurityDescriptor*>(GetAppDomain()->GetSecurityDescriptor());
-        return pASD->CheckPLS(orDemand, dwDemandSpecialFlags, fDemandSet);
-    }
-
-    // Walk all AppDomains in the stack and check the PLS on each one of them
-    DWORD dwAppDomainIndex = 0;
-    pThread->InitDomainIteration(&dwAppDomainIndex);
-    _ASSERT(SystemDomain::System() && "SystemDomain not yet created!");
-    while (dwAppDomainIndex != 0) {
-        AppDomainFromIDHolder appDomain(pThread->GetNextDomainOnStack(&dwAppDomainIndex, NULL, NULL), FALSE);
-        if (appDomain.IsUnloaded())
-            // appdomain has been unloaded, so we can just continue on the loop
-            continue;
-
-        ApplicationSecurityDescriptor* pAppSecDesc = static_cast<ApplicationSecurityDescriptor*>(appDomain->GetSecurityDescriptor());
-        appDomain.Release();
-
-        if (!pAppSecDesc->CheckPLS(orDemand, dwDemandSpecialFlags, fDemandSet))
-            return FALSE;
-    }
-    return TRUE;
-#else
-    return FALSE;
-#endif // FEATURE_PLS
-}
-
-//-----------------------------------------------------------+
-// Unmanaged version of CodeAccessSecurityEngine.Demand() in BCL
-// Any change there may have to be propagated here
-// This call has to be virtual, unlike DemandSet
-//-----------------------------------------------------------+
-void
-SecurityStackWalk::Demand(SecurityStackWalkType eType, OBJECTREF demand)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    if (QuickCheckForAllDemands(0))
-        return;
-
-    Check_PLS_SW_GC(FALSE, eType, demand, NULL);
-}
-
-//
-// Demand which succeeds if either a demand for a single well known permission or restricted member access is
-// granted and a demand for the permission set of the target of a reflection operation would have suceeded.
-//
-// Arguments:
-//    dwPermission     - Permission input to the demand (See SecurityPolicy.h)
-//    psdTarget        - Security descriptor for the target assembly
-//
-// Return Value:
-//    None, a SecurityException is thrown if the demands fail.
-//
-// Notes:
-//    This is used by Reflection to implement partial trust reflection, where demands should succeed if either
-//    a single permission demand, such as MemberAccess, would succeed for compatibility reasons, or if a
-//    demand for the permission set of the target assembly would succeed.
-//
-//    The intent is to allow reflection in partial trust when reflecting within the same permission set. Note
-//    that this is inexact, since in the face of RequestRefuse, the target assembly may fail the demand even
-//    within the same permission set.
-
-// static
-void SecurityStackWalk::ReflectionTargetDemand(DWORD dwPermission,
-                                               AssemblySecurityDescriptor *psdTarget)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(dwPermission != 0);
-        PRECONDITION(CheckPointer(psdTarget));
-    }
-    CONTRACTL_END;
-
-    // If everybody on the stack has the special permission, the disjunctive demand will succeed.
-    if (QuickCheckForAllDemands(1 << dwPermission))
-        return;
-
-    // In the simple sandbox case, we know the disjunctive demand will succeed if:
-    //   * we are granted restricted member access
-    //   * we are not reflecting on a FullTrust assembly
-    //   * every other AppDomain in the call stack is fully trusted
-    Thread *pCurrentThread = GetThread();
-    AppDomainStack appDomains = pCurrentThread->GetAppDomainStack();
-
-    if (QuickCheckForAllDemands(1 << REFLECTION_RESTRICTED_MEMBER_ACCESS) &&
-        !psdTarget->IsFullyTrusted() &&
-        pCurrentThread->GetDomain()->GetSecurityDescriptor()->IsHomogeneous() &&
-        !pCurrentThread->GetDomain()->GetSecurityDescriptor()->ContainsAnyRefusedPermissions() &&
-        appDomains.GetOverridesCount() == 0)
-    {
-        DWORD dwCurrentDomain;
-        appDomains.InitDomainIteration(&dwCurrentDomain);
-
-        bool fFullTrustStack = true;
-        while (dwCurrentDomain != 0 && fFullTrustStack)
-        {
-            AppDomainStackEntry *pCurrentDomain = appDomains.GetNextDomainEntryOnStack(&dwCurrentDomain);
-            fFullTrustStack = pCurrentDomain->m_domainID == pCurrentThread->GetDomain()->GetId() ||
-                              pCurrentDomain->IsFullyTrustedWithNoStackModifiers();
-        }
-
-        if (fFullTrustStack)
-            return;
-    }
-
-    OBJECTREF objTargetRefusedSet;
-    OBJECTREF objTargetGrantSet = psdTarget->GetGrantedPermissionSet(&objTargetRefusedSet);
-
-    GCPROTECT_BEGIN(objTargetGrantSet);
-
-    MethodDescCallSite reflectionTargetDemandHelper(METHOD__SECURITY_ENGINE__REFLECTION_TARGET_DEMAND_HELPER);
-    ARG_SLOT ilargs[] = 
-    {
-        static_cast<ARG_SLOT>(dwPermission),
-        ObjToArgSlot(objTargetGrantSet)
-    };
-
-    reflectionTargetDemandHelper.Call(ilargs);
-
-    GCPROTECT_END();
-}
-
-//
-// Similar to a standard refelection target demand, however the demand is done against a captured compressed
-// stack instead of the current callstack
-//
-// Arguments:
-//    dwPermission     - Permission input to the demand (See SecurityPolicy.h)
-//    psdTarget        - Security descriptor for the target assembly
-//    securityContext  - Compressed stack to perform the demand against
-//
-// Return Value:
-//    None, a SecurityException is thrown if the demands fail.
-//
-
-// static
-void SecurityStackWalk::ReflectionTargetDemand(DWORD dwPermission,
-                                               AssemblySecurityDescriptor *psdTarget,
-                                               DynamicResolver * pAccessContext)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(dwPermission >= 0 && dwPermission < 32);
-        PRECONDITION(CheckPointer(psdTarget));
-    }
-    CONTRACTL_END;
-
-    struct
-    {
-        OBJECTREF objTargetRefusedSet;
-        OBJECTREF objTargetGrantSet;
-        OBJECTREF objAccessContextObject;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-
-    GCPROTECT_BEGIN(gc);
-
-    gc.objTargetGrantSet = psdTarget->GetGrantedPermissionSet(&(gc.objTargetRefusedSet));
-
-    _ASSERTE(pAccessContext->GetDynamicMethod()->IsLCGMethod());
-    gc.objAccessContextObject = ((LCGMethodResolver *)pAccessContext)->GetManagedResolver();
-
-    MethodDescCallSite reflectionTargetDemandHelper(METHOD__SECURITY_ENGINE__REFLECTION_TARGET_DEMAND_HELPER_WITH_CONTEXT);
-    ARG_SLOT ilargs[] = 
-    {
-        static_cast<ARG_SLOT>(dwPermission),
-        ObjToArgSlot(gc.objTargetGrantSet),
-        ObjToArgSlot(gc.objAccessContextObject)
-    };
-
-    reflectionTargetDemandHelper.Call(ilargs);
-
-    GCPROTECT_END();
-}
-
-//-----------------------------------------------------------+
-// Special case of Demand(). This remembers the result of the 
-// previous demand, and reuses it if new assemblies have not
-// been added since then
-//-----------------------------------------------------------+
-void SecurityStackWalk::SpecialDemand(SecurityStackWalkType eType, DWORD whatPermission, StackCrawlMark* stackMark)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    if (QuickCheckForAllDemands(1<<whatPermission))
-    {
-        // Track perfmon counters. Runtime security checks.
-        IncrementSecurityPerfCounter();
-        return;
-    }
-    OBJECTREF demand = NULL;
-    GCPROTECT_BEGIN(demand);
-
-    SecurityDeclarative::GetPermissionInstance(&demand, whatPermission);
-    Check_PLS_SW(IS_SPECIAL_FLAG_PERMISSION_SET(whatPermission), eType, &demand, stackMark);
-
-    GCPROTECT_END();
-
-}
-
-// Do a demand for a special permission type
-FCIMPL2(void, SecurityStackWalk::FcallSpecialDemand, DWORD whatPermission, StackCrawlMark* stackMark)
-{
-    FCALL_CONTRACT;
-
-    HELPER_METHOD_FRAME_BEGIN_0();
-
-    SpecialDemand(SSWT_IMPERATIVE_DEMAND, whatPermission, stackMark);
-
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-
-//-----------------------------------------------------------+
-// Unmanaged version of PermissionSet.Demand()
-//-----------------------------------------------------------+
-void SecurityStackWalk::DemandSet(SecurityStackWalkType eType, OBJECTREF demand)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-
-    // Though the PermissionSet may contain non-CAS permissions, we are considering it as a CAS permission set only
-    // at this point and so it's safe to check for the FT and if FTmeansFT and return
-    if (QuickCheckForAllDemands(0))
-        return;
-
-    // Do further checks (PLS/SW) only if this set contains CAS perms
-    if(((PERMISSIONSETREF)demand)->CheckedForNonCas() && !((PERMISSIONSETREF)demand)->ContainsCas())
-        return;
-
-    Check_PLS_SW_GC(TRUE, eType, demand, NULL);
-}
-
-void SecurityStackWalk::DemandSet(SecurityStackWalkType eType, PsetCacheEntry *pPCE, DWORD dwAction)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-
-    // Though the PermissionSet may contain non-CAS permissions, we are considering it as a CAS permission set only
-    // at this point and so it's safe to check for the FT and if FTmeansFT and return
-    if (QuickCheckForAllDemands(0))
-        return;
-
-    OBJECTREF refPermSet = pPCE->CreateManagedPsetObject (dwAction);
-
-    if(refPermSet != NULL)
-    {
-        // Do further checks (PLS/SW) only if this set contains CAS perms
-        if(((PERMISSIONSETREF)refPermSet)->CheckedForNonCas() && !((PERMISSIONSETREF)refPermSet)->ContainsCas())
-            return;
-        
-        Check_PLS_SW_GC(TRUE, eType, refPermSet, NULL);
-        
-    }
-}
-
-//
-// Demand for the grant set of an assembly, without any identity permissions
-//
-// Arguments:
-//    psdAssembly - assembly security descriptor to demand the grant set of
-//
-// Return Value:
-//    None, a SecurityException is thrown if the demands fail.
-//
-
-// static
-void SecurityStackWalk::DemandGrantSet(AssemblySecurityDescriptor *psdAssembly)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        PRECONDITION(CheckPointer(psdAssembly));
-    }
-    CONTRACTL_END;
-
-    OBJECTREF objRefusedSet;
-    OBJECTREF objGrantSet = psdAssembly->GetGrantedPermissionSet(&objRefusedSet);
-
-    GCPROTECT_BEGIN(objGrantSet);
-
-    if (OBJECTREFToObject(objGrantSet) != NULL)
-    {
-        MethodDescCallSite checkWithoutIdentityPermissions(METHOD__SECURITY_ENGINE__CHECK_GRANT_SET_HELPER);
-        ARG_SLOT ilargs[] = 
-        {
-            ObjToArgSlot(objGrantSet)
-        };
-
-        checkWithoutIdentityPermissions.Call(ilargs);
-    }
-    else
-    {
-        // null grant set means full trust (mscorlib or anything created by it)
-        StackCrawlMark scm = LookForMyCaller;
-        SpecialDemand(SSWT_IMPERATIVE_DEMAND, SECURITY_FULL_TRUST, &scm);
-    }
-
-    GCPROTECT_END();
-}
-
-//-----------------------------------------------------------+
-// L I N K /I N H E R I T A N C E T I M E   C H E C K
-//-----------------------------------------------------------+
-void SecurityStackWalk::LinkOrInheritanceCheck(IAssemblySecurityDescriptor *pSecDesc, OBJECTREF refDemands, Assembly* pAssembly, CorDeclSecurity action)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    // MSCORLIB is not subject to inheritance checks
-    if (pAssembly->IsSystem())
-        return;
-
-    struct _gc {
-        OBJECTREF refDemands;
-        OBJECTREF refExposedAssemblyObject;
-        OBJECTREF refRefused;
-        OBJECTREF refGranted;
-    } gc;
-    ZeroMemory(&gc, sizeof(gc));
-    
-    gc.refDemands = refDemands;
-    gc.refExposedAssemblyObject = NULL;
-
-    GCPROTECT_BEGIN(gc);
-
-
-    OVERRIDE_TYPE_LOAD_LEVEL_LIMIT(CLASS_LOADED);
-
-    // We only do LinkDemands if the assembly is not fully trusted or if the demand contains permissions that don't implement IUnrestricted
-    if (!pAssembly->GetSecurityDescriptor()->IsFullyTrusted())
-    {
-        if (pAssembly) 
-            gc.refExposedAssemblyObject = pAssembly->GetExposedObject();
-
-        if (!pSecDesc->IsFullyTrusted())
-        {
-            MethodDescCallSite checkSetHelper(METHOD__SECURITY_ENGINE__CHECK_SET_HELPER);
-            gc.refGranted = pSecDesc->GetGrantedPermissionSet(&(gc.refRefused));
-            ARG_SLOT ilargs[7];
-            ilargs[0] = ObjToArgSlot(NULL);
-            ilargs[1] = ObjToArgSlot(gc.refGranted);
-            ilargs[2] = ObjToArgSlot(gc.refRefused);
-            ilargs[3] = ObjToArgSlot(gc.refDemands);
-            ilargs[4] = PtrToArgSlot(NULL);
-            ilargs[5] = ObjToArgSlot(gc.refExposedAssemblyObject);
-            ilargs[6] = (ARG_SLOT)action;
-            checkSetHelper.Call(ilargs);
-        }
-    }
-    GCPROTECT_END();
-}
-
-
-//-----------------------------------------------------------+
-// S T A C K   C O M P R E S S I O N FCALLS
-//-----------------------------------------------------------+
-
-
-
-#ifdef FEATURE_COMPRESSEDSTACK
-FCIMPL2(Object*, SecurityStackWalk::EcallGetDelayedCompressedStack, StackCrawlMark* stackMark, CLR_BOOL fWalkStack)
-{
-    FCALL_CONTRACT;
-
-    OBJECTREF rv = NULL;
-
-    // No need to GC-protect stackMark as it a byref on the stack
-    _ASSERTE(PVOID(stackMark) < GetThread()->GetCachedStackBase() &&
-             PVOID(stackMark) > PVOID(&rv));
-
-    HELPER_METHOD_FRAME_BEGIN_RET_0();
-
-    rv = StackCompressor::GetCompressedStack(stackMark, fWalkStack);
-
-    HELPER_METHOD_FRAME_END();
-    return OBJECTREFToObject(rv);
-
-}
-FCIMPLEND
-#endif // #ifdef FEATURE_COMPRESSEDSTACK
-
-#ifdef FEATURE_COMPRESSEDSTACK
-BOOL SecurityStackWalk::MethodIsAnonymouslyHostedDynamicMethodWithCSToEvaluate(MethodDesc* pMeth)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    } CONTRACTL_END;
-
-    if (!pMeth->IsLCGMethod()) 
-    {
-        return FALSE;
-    }
-    Assembly* pAssembly = pMeth->GetAssembly();
-    AppDomain* pAppDomain = GetAppDomain();
-    if(pAssembly != NULL && pAppDomain != NULL && pAssembly->GetDomainAssembly(pAppDomain) == pAppDomain->GetAnonymouslyHostedDynamicMethodsAssembly())
-    {
-        GCX_COOP();
-        DynamicResolver::SecurityControlFlags dwSecurityFlags = DynamicResolver::Default;
-        TypeHandle dynamicOwner; // not used
-        pMeth->AsDynamicMethodDesc()->GetLCGMethodResolver()->GetJitContextCoop(&dwSecurityFlags, &dynamicOwner);
-        if((dwSecurityFlags & DynamicResolver::CanSkipCSEvaluation) == 0)
-        {
-            return TRUE;
-        }
-    }
-
-    return FALSE;
-}
-#endif // FEATURE_COMPRESSEDSTACK
diff --git a/src/vm/securitystackwalk.h b/src/vm/securitystackwalk.h
index aa6c1c1e6a..f59c958145 100644
--- a/src/vm/securitystackwalk.h
+++ b/src/vm/securitystackwalk.h
@@ -19,13 +19,8 @@
 #include "security.h"
 #include "holder.h"
 #ifdef FEATURE_REMOTING
-#include "appdomainhelper.h"
 #endif
 
-#ifdef FEATURE_COMPRESSEDSTACK
-class NewCompressedStack;
-class DomainCompressedStack;
-#endif // FEATURE_COMPRESSEDSTACK
 class ApplicationSecurityDescriptor;
 class DemandStackWalk;
 class CountOverridesStackWalk;
@@ -169,9 +164,6 @@ public:
     //   Callers:
     //     CanAccess (ReflectionInvocation)
     //     ReflectionSerialization::GetSafeUninitializedObject
-#ifdef FEATURE_APTCA
-    //     SecurityDeclarative::DoUntrustedCallerChecks
-#endif // FEATURE_APTCA
     static void DemandSet(SecurityStackWalkType eType, OBJECTREF demand);
 
     // Native version of PermissionSet.Demand() that delays instantiating the PermissionSet object
@@ -211,25 +203,6 @@ public:
     // Compressed Stack
     // ----------------------------------------------------
 public:
-#ifdef FEATURE_COMPRESSEDSTACK
-    static FCDECL2(Object*, EcallGetDelayedCompressedStack, StackCrawlMark* stackMark, CLR_BOOL fWalkStack);
-    static FCDECL1(VOID, FcallDestroyDelayedCompressedStack, void *compressedStack);
-    static COMPRESSEDSTACKREF GetCSFromContextTransitionFrame(Frame *pFrame);
-    static BOOL IsContextTransitionFrameWithCS(Frame *pFrame)
-    {
-        CONTRACTL
-        {
-            NOTHROW;
-            GC_NOTRIGGER;
-            SO_TOLERANT;
-            MODE_COOPERATIVE;
-        }
-        CONTRACTL_END;
-        return (GetCSFromContextTransitionFrame(pFrame) != NULL);
-    }
-    static BOOL MethodIsAnonymouslyHostedDynamicMethodWithCSToEvaluate(MethodDesc* pMeth);
-
-#endif // #ifdef FEATURE_COMPRESSEDSTACK
 
 #ifndef DACCESS_COMPILE
     FORCEINLINE static BOOL HasFlagsOrFullyTrustedIgnoreMode (DWORD flags);   
diff --git a/src/vm/securitytransparentassembly.cpp b/src/vm/securitytransparentassembly.cpp
index 4a23c276d8..b48451f41c 100644
--- a/src/vm/securitytransparentassembly.cpp
+++ b/src/vm/securitytransparentassembly.cpp
@@ -233,20 +233,6 @@ static void ConvertCriticalMethodToLinkDemand(MethodDesc *pCallerMD)
     }
     CONTRACTL_END;
 
-#if !defined(CROSSGEN_COMPILE) && defined(FEATURE_CAS_POLICY)
-    if (NingenEnabled())
-        return;
-
-    GCX_COOP();
-
-    OBJECTREF permSet = NULL;
-    GCPROTECT_BEGIN(permSet);
-
-    Security::GetPermissionInstance(&permSet, SECURITY_FULL_TRUST);
-    Security::DemandSet(SSWT_LATEBOUND_LINKDEMAND, permSet);
-
-    GCPROTECT_END();
-#endif // !CROSSGEN_COMPILE && FEATURE_CAS_POLICY
 }
 
 // static
@@ -324,7 +310,6 @@ BOOL SecurityTransparent::CheckCriticalAccess(AccessCheckContext* pContext,
             return TRUE;
         }
 
-#ifdef FEATURE_CORECLR
         // On the coreCLR, a method can be transparent even if the containing type is marked Critical.
         // This will happen when that method is an override of a base transparent method, and the type that
         // contains the override is marked Critical. And that's the only case it can happen.
@@ -334,7 +319,6 @@ BOOL SecurityTransparent::CheckCriticalAccess(AccessCheckContext* pContext,
         {
             return TRUE;
         }
-#endif // FEATURE_CORECLR
     	
         // an attached profiler may wish to have these checks suppressed
         if (Security::BypassSecurityChecksForProfiler(pCurrentMD))
@@ -395,41 +379,9 @@ BOOL SecurityTransparent::IsAllowedToAssert(MethodDesc *pMD)
         return TRUE;
     }
     
-#ifdef FEATURE_CORECLR
     // On CoreCLR only critical code may ever assert - there are no compatibility reasons to allow
     // transparent asserts.
     return FALSE;
-#else // !FEATURE_CORECLR
-    // We must be in a heterogenous AppDomain for transparent asserts to work
-    if (GetAppDomain()->GetSecurityDescriptor()->IsHomogeneous())
-    {
-        return FALSE;
-    }
-
-    ModuleSecurityDescriptor *pMSD = ModuleSecurityDescriptor::GetModuleSecurityDescriptor(pMD->GetAssembly());
-    
-    // Only assemblies whose version requires them to use legacy transparency (rather than assemblies which
-    // get legacy transparency via RuleSet.Level1) can assert from transparent code 
-    if (!pMSD->AssemblyVersionRequiresLegacyTransparency())
-    {
-        return FALSE;
-    }
-
-    // Finally, the assembly must not have had any of the transparency attributes on it
-    const TokenSecurityDescriptorFlags transparencyAwareFlags = 
-        TokenSecurityDescriptorFlags_AllCritical    | // [SecurityCritical(SecurityCriticalScope.All)]
-        TokenSecurityDescriptorFlags_Critical       | // [SecurityCritical]
-        TokenSecurityDescriptorFlags_SafeCritical   | // [SecuritySafeCritical]
-        TokenSecurityDescriptorFlags_Transparent    | // [SecurityTransparent]
-        TokenSecurityDescriptorFlags_TreatAsSafe;     // [SecurityTreatAsSafe]
-    TokenSecurityDescriptorFlags moduleAttributes = pMSD->GetTokenFlags();
-    if ((moduleAttributes & transparencyAwareFlags) != TokenSecurityDescriptorFlags_None)
-    {
-        return FALSE;
-    }
-
-    return TRUE;
-#endif // FEATURE_CORECLR
 }
 
 // Functor class to aid in determining if a type requires a transparency check
@@ -528,40 +480,6 @@ CorInfoCanSkipVerificationResult SecurityTransparent::JITCanSkipVerification(Met
 
     CorInfoCanSkipVerificationResult canSkipVerif = hasSkipVerificationPermisson ? CORINFO_VERIFICATION_CAN_SKIP : CORINFO_VERIFICATION_CANNOT_SKIP;
 
-#ifndef FEATURE_CORECLR
-    // also check to see if the method is marked transparent
-    if (hasSkipVerificationPermisson)
-    { 
-        if (pDomainAssembly == GetAppDomain()->GetAnonymouslyHostedDynamicMethodsAssembly())
-        {
-            // This assembly is FullTrust. However, it cannot contain unverifiable code.
-            // The JIT compiler is not hardened to deal with invalid code. Hence, we cannot
-            // return CORINFO_VERIFICATION_RUNTIME_CHECK for IL that could have been generated
-            // by a low-trust assembly.
-            canSkipVerif = CORINFO_VERIFICATION_CANNOT_SKIP;
-        }
-        // also check to see if the method is marked transparent
-        else if (SecurityTransparent::IsMethodTransparent(pMD))
-        {
-            // If the assembly requested that even its transparent members not be verified, then we can skip
-            // verification.  Otherwise, we need to either inject a runtime demand in the v2 model, or fail
-            // verification in the v4 model.
-            ModuleSecurityDescriptor *pModuleSecDesc = ModuleSecurityDescriptor::GetModuleSecurityDescriptor(pMD->GetAssembly());
-            if (pModuleSecDesc->CanTransparentCodeSkipVerification())
-            {
-                canSkipVerif = CORINFO_VERIFICATION_CAN_SKIP;
-            }
-            else if (pMD->GetAssembly()->GetSecurityTransparencyBehavior()->CanTransparentCodeSkipVerification())
-            {
-                canSkipVerif = CORINFO_VERIFICATION_RUNTIME_CHECK;
-            }
-            else
-            {
-                canSkipVerif = CORINFO_VERIFICATION_CANNOT_SKIP;
-            }
-        }
-    }
-#endif //FEATURE_CORECLR
 
     return canSkipVerif;
 }
@@ -587,14 +505,6 @@ CorInfoCanSkipVerificationResult SecurityTransparent::JITCanSkipVerification(Dom
     {
       // In CoreCLR, do not enable transparency checks here.  We depend on this method being "honest" in
       // JITCanSkipVerification to skip transparency checks on profile assemblies.
-#ifndef FEATURE_CORECLR
-        ModuleSecurityDescriptor *pMsd = ModuleSecurityDescriptor::GetModuleSecurityDescriptor(pAssembly->GetAssembly());
-        if (pMsd->IsAllTransparent() &&
-            pAssembly->GetAssembly()->GetSecurityTransparencyBehavior()->CanTransparentCodeSkipVerification())
-        {
-            canSkipVerif = CORINFO_VERIFICATION_RUNTIME_CHECK;
-        }
-#endif // !FEATURE_CORECLR
     }
 
     return canSkipVerif;			
@@ -620,34 +530,6 @@ bool SecurityTransparent::SecurityCalloutQuickCheck(MethodDesc *pCallerMD)
     // In coreclr, we modified the logic in the callout to also do some transparency method access checks
     // These checks need to happen regardless of trust level and we shouldn't be bailing out early 
     // just because we happen to be in Full Trust
-#ifndef FEATURE_CORECLR
-    // See if we need to process this callout for real, or if we can bail out early before setting up a HMF,
-    // and spending a lot of time processing the transparency evaluation.  The simplest case where we can do
-    // this is if the caller is critical.  In that case, we know that the caller is allowed to do whatever
-    // it wants, so we quit out.
-    // 
-    // Additionally, if the caller is using SecurityRuleSet.Level1, which turns transparency violations into
-    // security demands, we can bail out early if we know for sure all demands will succeed on the current
-    // call stack.  (Note: this remains true as long as we don't start generating callouts for transparent
-    // level 1 calling critical level 1, or transparent level 1 doing an assert, which are the only two
-    // violations which do not succeed in the face of a successful demand).
-    if (pCallerMD->IsCritical())
-    {
-        return true;
-    }
-    else
-    {
-        // The caller is transparent, so let's see if demands can cause transparency violations to succeed,
-        // and also if all demands issued from this context will succeed.
-        const SecurityTransparencyBehavior *pCallerTransparency = pCallerMD->GetAssembly()->TryGetSecurityTransparencyBehavior();
-        if (pCallerTransparency != NULL &&
-            pCallerTransparency->CanTransparentCodeCallLinkDemandMethods() &&
-            SecurityStackWalk::HasFlagsOrFullyTrustedIgnoreMode(0))
-        {
-            return true;
-        }
-    }
-#endif // !FEATURE_CORECLR
 
     return false;
 }
@@ -690,11 +572,7 @@ CorInfoIsAccessAllowedResult SecurityTransparent::RequiresTransparentCodeChecks(
         // Check to see if the callee has a LinkDemand, if so we may need to intercept the call.
         if (pCalleeMD->RequiresLinktimeCheck())
         {
-            if (pCalleeMD->RequiresLinkTimeCheckHostProtectionOnly()
-#ifndef CROSSGEN_COMPILE
-                && GetHostProtectionManager()->GetProtectedCategories() == eNoChecks
-#endif // CROSSGEN_COMPILE
-                )
+            if (pCalleeMD->RequiresLinkTimeCheckHostProtectionOnly())
             {
                 // exclude HPA which are marked as LinkDemand and there is no HostProtection enabled currently
                 return CORINFO_ACCESS_ALLOWED;
@@ -728,44 +606,6 @@ VOID SecurityTransparent::PerformTransparencyChecksForLoadByteArray(MethodDesc*
     }
     CONTRACTL_END
 
-#ifdef FEATURE_CAS_POLICY
-	GCX_COOP();
-	// check to see if the method that does the Load(byte[] ) is transparent
-	if (IsMethodTransparent(pCallerMD))
-	{		
-		Assembly* pLoadedAssembly = pLoadedSecDesc->GetAssembly();
-		// check to see if the byte[] being loaded is critical, i.e. not Transparent
-		if (!ModuleSecurityDescriptor::IsMarkedTransparent(pLoadedAssembly))
-		{
-			// if transparent code loads a byte[] that is critical, need to inject appropriate demands
-			if (pLoadedSecDesc->IsFullyTrusted()) // if the loaded code is full-trust
-			{
-				// do a full-demand for Full-Trust				
-				OBJECTREF permSet = NULL;
-				GCPROTECT_BEGIN(permSet);
-        			Security::GetPermissionInstance(&permSet, SECURITY_FULL_TRUST);
-					Security::DemandSet(SSWT_LATEBOUND_LINKDEMAND, permSet);
-				GCPROTECT_END();// do a full-demand for Full-Trust				
-			}
-			else
-			{
-				// otherwise inject a Demand for permissions being granted?
-				struct _localGC {
-                			OBJECTREF granted;
-                			OBJECTREF denied;
-            			} localGC;
-            	ZeroMemory(&localGC, sizeof(localGC));
-
-            	GCPROTECT_BEGIN(localGC);
-				{
-					localGC.granted = pLoadedSecDesc->GetGrantedPermissionSet(&(localGC.denied));
-					Security::DemandSet(SSWT_LATEBOUND_LINKDEMAND, localGC.granted);
-            	}
-				GCPROTECT_END();
-			}
-		}		
-	}	
-#endif // FEATURE_CAS_POLICY
 }
 
 static void ConvertLinkDemandToFullDemand(MethodDesc* pCallerMD, MethodDesc* pCalleeMD) 
@@ -816,44 +656,6 @@ static void ConvertLinkDemandToFullDemand(MethodDesc* pCallerMD, MethodDesc* pCa
                                                                                &gc.refMethodCasDemands,
                                                                                &gc.refMethodNonCasDemands);
 
-#ifdef FEATURE_APTCA
-    BOOL fCallerIsAPTCA = pCallerMD->GetAssembly()->AllowUntrustedCaller();
-
-    if ((linktimeCheckReason & LinktimeCheckReason_AptcaCheck))
-    {
-        if (fCallerIsAPTCA &&    
-            Security::IsUntrustedCallerCheckNeeded(pCalleeMD, pCallerMD->GetAssembly()))
-        {
-#ifdef _DEBUG
-            if (g_pConfig->LogTransparencyErrors())
-            {
-                SecurityTransparent::LogTransparencyError(pCallerMD, "Transparent method calling an APTCA protected assembly", pCalleeMD);
-            }
-            if (!g_pConfig->DisableTransparencyEnforcement())
-#endif // _DEBUG
-            {
-                // Depending on the transparency model, we need to either fail the attempt to call a method
-                // protected with the APTCA link demand, or conver it to a full demand.  Note that we need to
-                // upgrade to a full demand if either the caller of callee are in v2 mode, the APTCA check is
-                // conceptually a link demand, and for link demands we do the conversion if either assembly is
-                // using the v2 rules.
-                if (pCallerMD->GetAssembly()->GetSecurityTransparencyBehavior()->CanTransparentCodeCallLinkDemandMethods() ||
-                    pCalleeMD->GetAssembly()->GetSecurityTransparencyBehavior()->CanTransparentCodeCallLinkDemandMethods())
-                {
-                    OBJECTREF permSet = NULL;
-                    GCPROTECT_BEGIN(permSet);
-                    Security::GetPermissionInstance(&permSet, SECURITY_FULL_TRUST);
-                    Security::DemandSet(SSWT_LATEBOUND_LINKDEMAND, permSet);
-                    GCPROTECT_END();
-                }
-                else
-                {
-                    ::ThrowMethodAccessException(pCallerMD, pCalleeMD, FALSE, IDS_E_TRANSPARENT_CALL_LINKDEMAND);
-                }
-            }
-        }
-    }
-#endif // FEATURE_APTCA
 
             
     // The following logic turns link demands on the target method into full stack walks
@@ -909,15 +711,6 @@ static void ConvertLinkDemandToFullDemand(MethodDesc* pCallerMD, MethodDesc* pCa
 
         if (pCallerMD->GetAssembly()->GetSecurityTransparencyBehavior()->CanTransparentCodeCallUnmanagedCode())
         {
-#ifdef FEATURE_APTCA
-            if (fCallerIsAPTCA)
-            {
-                // if the caller assembly is APTCA, then only inject this demand, for NON-APTCA we will allow
-                // calls to native code
-                // NOTE: the JIT would have already performed the LinkDemand for this anyways
-                Security::SpecialDemand(SSWT_LATEBOUND_LINKDEMAND, SECURITY_UNMANAGED_CODE);        
-            }
-#endif // FEATURE_APTCA
         }
         else
         {
@@ -998,7 +791,6 @@ VOID SecurityTransparent::EnforceTransparentDelegateChecks(MethodTable* pDelegat
     } 
     CONTRACTL_END;
 
-#ifdef FEATURE_CORECLR
     // We only enforce delegate binding rules in partial trust
     if (GetAppDomain()->GetSecurityDescriptor()->IsFullyTrusted())
         return;
@@ -1009,7 +801,6 @@ VOID SecurityTransparent::EnforceTransparentDelegateChecks(MethodTable* pDelegat
     TypeString::AppendType(strDelegateType, pDelegateMT, TypeString::FormatNamespace | TypeString::FormatAngleBrackets| TypeString::FormatSignature);
 
     COMPlusThrowHR(COR_E_METHODACCESS, IDS_E_DELEGATE_BINDING_TRANSPARENCY, strDelegateType.GetUnicode(), strMethod.GetUnicode());
-#endif // FEATURE_CORECLR
 }
 
 #endif // CROSSGEN_COMPILE
@@ -1447,12 +1238,12 @@ public:
 
         ModuleSecurityDescriptorFlags moduleFlags = ModuleSecurityDescriptorFlags_None;
 
-#if defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM)
+#if defined(FEATURE_CORESYSTEM)
         if (tokenFlags & TokenSecurityDescriptorFlags_APTCA)
         {
             moduleFlags |= ModuleSecurityDescriptorFlags_IsAPTCA;
         }
-#endif // defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM)
+#endif // defined(FEATURE_CORESYSTEM)
 
         if (tokenFlags & TokenSecurityDescriptorFlags_Critical)
         {
@@ -1535,202 +1326,6 @@ public:
     }
 };
 
-#ifndef FEATURE_CORECLR
-
-//---------------------------------------------------------------------------------------
-//
-// Transparency behavior implementation for v2 assemblies
-//
-
-class LegacyTransparencyBehaviorImpl : public ISecurityTransparencyImpl
-{
-public:
-    // Get bits that indicate how transparency should behave in different situations
-    virtual SecurityTransparencyBehaviorFlags GetBehaviorFlags() const
-    {
-        LIMITED_METHOD_CONTRACT;
-        return SecurityTransparencyBehaviorFlags_IntroducedCriticalsMayAddTreatAsSafe |
-               SecurityTransparencyBehaviorFlags_OpportunisticIsSafeCriticalMethods |
-               SecurityTransparencyBehaviorFlags_PartialTrustImpliesAllTransparent |
-               SecurityTransparencyBehaviorFlags_PublicImpliesTreatAsSafe |
-               SecurityTransparencyBehaviorFlags_TransparentCodeCanCallLinkDemand |
-               SecurityTransaprencyBehaviorFlags_TransparentCodeCanCallUnmanagedCode |
-               SecurityTransparencyBehaviorFlags_TransparentCodeCanSkipVerification |
-               SecurityTransparencyBehaviorFlags_UnsignedImpliesAPTCA;
-    }
-
-    // Legacy transparency field behavior mappings:
-    //  Attribute                         Behavior
-    //  -----------------------------------------------------
-    //  Critical (any)                    Critical
-    //  SafeCritical                      Safe critical
-    //  TAS (no critical)                 No effect
-    //  TAS (with any critical)           Safe critical
-    virtual FieldSecurityDescriptorFlags MapFieldAttributes(TokenSecurityDescriptorFlags tokenFlags) const
-    {
-        WRAPPER_NO_CONTRACT;
-
-        // Legacy transparency behaves the same for fields as the current transparency model, so we just forward
-        // this call to that implementation.
-        TransparencyBehaviorImpl forwardImpl;
-        return forwardImpl.MapFieldAttributes(tokenFlags);
-    }
-
-
-    // Legacy transparency method behavior mappings:
-    //  Attribute                         Behavior
-    //  -----------------------------------------------------
-    //  Critical (any)                    Critical
-    //  SafeCritical                      Safe critical
-    //  TAS (no critical)                 No effect
-    //  TAS (with any critical)           Safe critical
-    virtual MethodSecurityDescriptorFlags MapMethodAttributes(TokenSecurityDescriptorFlags tokenFlags) const
-    {
-        WRAPPER_NO_CONTRACT;
-
-        // Legacy transparency behaves the same for methods as the current transparency model, so we just forward
-        // this call to that implementation.
-        TransparencyBehaviorImpl forwardImpl;
-        return forwardImpl.MapMethodAttributes(tokenFlags);
-    }
-
-    // Legacy transparency module behavior mappings:
-    //  Attribute                         Behavior
-    //  -----------------------------------------------------
-    //  APTCA                             APTCA
-    //  ConditionlAPTCA                   Exception
-    //  Critical (scoped)                 Mixed transparency
-    //  Critical (all)                    All critical
-    //  SafeCritical                      All safe critical
-    //  TAS (no critical)                 No effect
-    //  TAS (with scoped critical)        No effect
-    //  TAS (with all critical)           All safe critical
-    //  Transparent                       All transparent
-    //
-    // Having no transparent, critical, or safe critical attributes means that the assembly should have all
-    // transparent types and all safe critical methods.
-    virtual ModuleSecurityDescriptorFlags MapModuleAttributes(TokenSecurityDescriptorFlags tokenFlags) const
-    {
-        CONTRACTL
-        {
-            THROWS;
-            GC_TRIGGERS;
-            SO_INTOLERANT;
-        }
-        CONTRACTL_END;
-
-        ModuleSecurityDescriptorFlags moduleFlags = ModuleSecurityDescriptorFlags_None;
-        bool fShouldBeOpportunisticallyCritical = true;
-
-#if defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM)
-        if (tokenFlags & TokenSecurityDescriptorFlags_APTCA)
-        {
-            moduleFlags |= ModuleSecurityDescriptorFlags_IsAPTCA;
-        }
-#endif // defined(FEATURE_APTCA) || defined(FEATURE_CORESYSTEM)
-
-        if (tokenFlags & TokenSecurityDescriptorFlags_Transparent)
-        {
-            moduleFlags |= ModuleSecurityDescriptorFlags_IsAllTransparent;
-            fShouldBeOpportunisticallyCritical = false;
-        }
-
-        if (tokenFlags & TokenSecurityDescriptorFlags_Critical)
-        {
-            fShouldBeOpportunisticallyCritical = false;
-
-            // If we're critical, but not all critical that means we're mixed.
-            if (tokenFlags & TokenSecurityDescriptorFlags_AllCritical)
-            {
-                moduleFlags |= ModuleSecurityDescriptorFlags_IsAllCritical;
-
-                // If we're all critical and treat as safe, that means we're safe critical
-                if (tokenFlags & TokenSecurityDescriptorFlags_TreatAsSafe)
-                {
-                    moduleFlags |= ModuleSecurityDescriptorFlags_IsTreatAsSafe;
-                }
-            }
-        }
-
-        // SafeCritical always means Critical + TreatAsSafe; we can get in this case for legacy assemblies if the
-        // assembly is actually a v4 assembly which is using the Legacy attribute.
-        if (tokenFlags & TokenSecurityDescriptorFlags_SafeCritical)
-        {
-            moduleFlags |= ModuleSecurityDescriptorFlags_IsAllCritical |
-                           ModuleSecurityDescriptorFlags_IsTreatAsSafe;
-            fShouldBeOpportunisticallyCritical = false;
-        }
-
-        // If we didn't find an attribute that indicates the assembly cares about transparency, then it is
-        // opportunistically critical.
-        if (fShouldBeOpportunisticallyCritical)
-        {
-            _ASSERTE(!(moduleFlags & ModuleSecurityDescriptorFlags_IsAllTransparent));
-            _ASSERTE(!(moduleFlags & ModuleSecurityDescriptorFlags_IsAllCritical));
-
-            moduleFlags |= ModuleSecurityDescriptorFlags_IsOpportunisticallyCritical;
-        }
-
-        // If the token asks to not have IL verification done in full trust, propigate that to the module
-        if (tokenFlags & TokenSecurityDescriptorFlags_SkipFullTrustVerification)
-        {
-            moduleFlags |= ModuleSecurityDescriptorFlags_SkipFullTrustVerification;
-        }
-
-        return moduleFlags;
-    }
-
-    // Legacy transparency type behavior mappings:
-    //  Attribute                         Behavior
-    //  -----------------------------------------------------
-    //  Critical (scoped)                 Critical, but not all critical
-    //  Critical (all)                    All critical
-    //  SafeCritical                      All safe critical
-    //  TAS (no critical)                 No effect on the type, but save TAS bit for members of the type
-    //  TAS (with scoped critical)        SafeCritical, but not all critical
-    //  TAS (with all critical)           All SafeCritical
-    virtual TypeSecurityDescriptorFlags MapTypeAttributes(TokenSecurityDescriptorFlags tokenFlags) const
-    {
-        CONTRACTL
-        {
-            THROWS;
-            GC_TRIGGERS;
-            SO_INTOLERANT;
-        }
-        CONTRACTL_END;
-
-        TypeSecurityDescriptorFlags typeFlags = TypeSecurityDescriptorFlags_None;
-
-        if (tokenFlags & TokenSecurityDescriptorFlags_Critical)
-        {
-            typeFlags |= TypeSecurityDescriptorFlags_IsCritical;
-
-            // We only consider all critical if the critical attribute was present
-            if (tokenFlags & TokenSecurityDescriptorFlags_AllCritical)
-            {
-                typeFlags |= TypeSecurityDescriptorFlags_IsAllCritical;
-            }
-        }
-
-        // SafeCritical always means all critical + TAS
-        if (tokenFlags & TokenSecurityDescriptorFlags_SafeCritical)
-        {
-            typeFlags |= TypeSecurityDescriptorFlags_IsCritical |
-                         TypeSecurityDescriptorFlags_IsAllCritical |
-                         TypeSecurityDescriptorFlags_IsTreatAsSafe;
-        }
-
-        if (tokenFlags & TokenSecurityDescriptorFlags_TreatAsSafe)
-        {
-            typeFlags |= TypeSecurityDescriptorFlags_IsTreatAsSafe;
-        }
-
-        return typeFlags;
-    }
-};
-
-#endif // !FEATURE_CORECLR
-
 //
 // Shared transparency behavior objects
 //
@@ -1775,13 +1370,6 @@ const SecurityTransparencyBehavior *GetOrCreateTransparencyBehavior(SecurityTran
 // static
 SecurityTransparencyBehavior *SecurityTransparencyBehavior::s_pStandardTransparencyBehavior = NULL;
 
-#ifndef FEATURE_CORECLR
-
-// Transpraency behavior object for v2 transparent assemblies
-// static
-SecurityTransparencyBehavior *SecurityTransparencyBehavior::s_pLegacyTransparencyBehavior = NULL;
-
-#endif // !FEATURE_CORECLR
 
 //---------------------------------------------------------------------------------------
 //
@@ -1804,14 +1392,6 @@ const SecurityTransparencyBehavior *SecurityTransparencyBehavior::GetTransparenc
     }
     CONTRACT_END;
 
-#ifndef FEATURE_CORECLR
-    if (ruleSet == SecurityRuleSet_Level1)
-    {
-		// Level 1 rules - v2.0 behavior
-        RETURN(GetOrCreateTransparencyBehavior<LegacyTransparencyBehaviorImpl>(&s_pLegacyTransparencyBehavior));
-    }
-    else
-#endif // FEATURE_CORECLR;
     {
 		// Level 2 rules - v4.0 behavior
         RETURN(GetOrCreateTransparencyBehavior<TransparencyBehaviorImpl>(&s_pStandardTransparencyBehavior));
diff --git a/src/vm/sha1.h b/src/vm/sha1.h
index 0dd70f64a7..23ea8d2c3e 100644
--- a/src/vm/sha1.h
+++ b/src/vm/sha1.h
@@ -3,7 +3,6 @@
 // See the LICENSE file in the project root for more information.
 // 
 
-#if defined(FEATURE_CORECLR)
 #ifndef SHA1_H_
 #define SHA1_H_
 
@@ -49,6 +48,3 @@ public:
 };
 
 #endif  // SHA1_H_
-#else // !defined(FEATURE_CORECLR)
-#include "crypto/sha1.h"
-#endif // defined(FEATURE_CORECLR)
diff --git a/src/vm/siginfo.cpp b/src/vm/siginfo.cpp
index 2c2c4f4b80..b9955eca68 100644
--- a/src/vm/siginfo.cpp
+++ b/src/vm/siginfo.cpp
@@ -5028,20 +5028,18 @@ void ReportPointersFromValueTypeArg(promote_func *fn, ScanContext *sc, PTR_Metho
 {
     WRAPPER_NO_CONTRACT;
 
-    if(pMT->ContainsPointers())
+    if (!pMT->ContainsPointers() && !pMT->IsByRefLike())
     {
-#if defined(UNIX_AMD64_ABI) && defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)    
-        if (pSrc->IsStructPassedInRegs())
-        {
-            pSrc->ReportPointersFromStructInRegisters(fn, sc, pMT->GetNumInstanceFieldBytes());
-            return;
-        }
-#endif // UNIX_AMD64_ABI && FEATURE_UNIX_AMD64_STRUCT_PASSING
+        return;
     }
-    else if (!pMT->IsByRefLike())
+
+#if defined(UNIX_AMD64_ABI) && defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)    
+    if (pSrc->IsStructPassedInRegs())
     {
+        pSrc->ReportPointersFromStructInRegisters(fn, sc, pMT->GetNumInstanceFieldBytes());
         return;
     }
+#endif // UNIX_AMD64_ABI && FEATURE_UNIX_AMD64_STRUCT_PASSING
 
     ReportPointersFromValueType(fn, sc, pMT, pSrc->GetDestinationAddress());
 }
diff --git a/src/vm/stackbuildersink.cpp b/src/vm/stackbuildersink.cpp
deleted file mode 100644
index 2e363f2802..0000000000
--- a/src/vm/stackbuildersink.cpp
+++ /dev/null
@@ -1,702 +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.
-// 
-// File: StackBuilderSink.cpp
-// 
-
-//
-// Purpose: Native implementation for System.Runtime.Remoting.Messaging.StackBuilderSink
-//
-
-
-#include "common.h"
-
-#ifdef FEATURE_REMOTING
-
-#include "excep.h"
-#include "message.h"
-#include "stackbuildersink.h"
-#include "dbginterface.h"
-#include "remoting.h"
-#include "profilepriv.h"
-#include "class.h"
-
-struct ArgInfo
-{
-    PBYTE             dataLocation;
-    INT32             dataSize;
-    TypeHandle        dataTypeHandle;
-    BYTE              dataType;
-    BYTE              byref;
-};
-
-
-//+----------------------------------------------------------------------------
-//
-//  Method:     CStackBuilderSink::PrivateProcessMessage, public
-//
-//  Synopsis:   Builds the stack and calls an object
-// 
-//
-//+----------------------------------------------------------------------------
-FCIMPL5(Object*, CStackBuilderSink::PrivateProcessMessage,
-                                        Object* pSBSinkUNSAFE,
-                                        MethodDesc* pMD,
-                                        PTRArray* pArgsUNSAFE,
-                                        Object* pServerUNSAFE,
-                                        PTRARRAYREF* ppVarOutParams)
-{
-    CONTRACTL
-    {
-        FCALL_CHECK;
-        PRECONDITION(CheckPointer(pMD));
-        PRECONDITION(!pMD->IsGenericMethodDefinition());
-        PRECONDITION(pMD->IsRuntimeMethodHandle());
-    }
-    CONTRACTL_END;
-
-    struct _gc
-    {
-        PTRARRAYREF pArgs;
-        OBJECTREF pServer;
-        OBJECTREF pSBSink;
-        OBJECTREF ret;
-    } gc;
-    gc.pArgs = (PTRARRAYREF) pArgsUNSAFE;
-    gc.pServer = (OBJECTREF) pServerUNSAFE;
-    gc.pSBSink = (OBJECTREF) pSBSinkUNSAFE;
-    gc.ret = NULL;
-
-    HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc);
-
-    // pMD->IsStatic() is SO_INTOLERANT.
-    // Either pServer is non-null or the method is static (but not both)
-    _ASSERTE( (pServerUNSAFE!=NULL) == !(pMD->IsStatic()) );
-
-    LOG((LF_REMOTING, LL_INFO10, "CStackBuilderSink::PrivateProcessMessage\n"));
-
-    MethodDesc *pResolvedMD = pMD;
-    // Check if this is an interface invoke, if yes, then we have to find the
-    // real method descriptor on the class of the server object.
-    if(pMD->GetMethodTable()->IsInterface())
-    {
-        _ASSERTE(gc.pServer != NULL);
-
-        // NOTE: This method can trigger GC
-        // The last parameter (true) causes the method to take into account that
-        // the object passed in is a TP and try to resolve the interface MD into
-        // a server MD anyway (normally the call short circuits thunking objects
-        // and just returns the interface MD unchanged).
-        MethodTable *pRealMT = gc.pServer->GetTrueMethodTable();
-
-#ifdef FEATURE_COMINTEROP
-        if (pRealMT->IsComObjectType())
-            pResolvedMD = pRealMT->GetMethodDescForComInterfaceMethod(pMD, true);
-        else
-#endif // FEATURE_COMINTEROP
-        {
-            if (pRealMT->ImplementsInterface(pMD->GetMethodTable()))
-            {
-                pResolvedMD = pRealMT->GetMethodDescForInterfaceMethod(TypeHandle(pMD->GetMethodTable()), pMD);
-
-                // If the method is generic then we have more work to do --
-                // we'll get back the generic method descriptor and we'll have
-                // to load the version with the right instantiation (get the
-                // instantiation from the interface method).
-                if (pResolvedMD->HasMethodInstantiation())
-                {
-                    _ASSERTE(pResolvedMD->IsGenericMethodDefinition());
-                    _ASSERTE(pMD->GetNumGenericMethodArgs() == pResolvedMD->GetNumGenericMethodArgs());
-
-                    pResolvedMD = MethodDesc::FindOrCreateAssociatedMethodDesc(pResolvedMD,
-                                                                               pRealMT,
-                                                                               FALSE,
-                                                                               pMD->GetMethodInstantiation(),
-                                                                               FALSE);
-
-                    _ASSERTE(!pResolvedMD->ContainsGenericVariables());
-                }
-            }
-            else
-                pResolvedMD = NULL;
-        }
-
-        if(!pResolvedMD)
-        {
-            MAKE_WIDEPTR_FROMUTF8(wName, pMD->GetName());
-            COMPlusThrow(kMissingMethodException, IDS_EE_MISSING_METHOD, wName);
-        }
-    }
-
-    // <TODO>This looks a little dodgy for generics: pResolvedMD has been interface-resolved but not
-    // virtual-resolved.  So we seem to be taking the signature of a 
-    // half-resolved-virtual-call.  But the MetaSig
-    // is only used for GC purposes, and thus is probably OK: although the
-    // metadata for the signature of a call may be different
-    // as we move to base classes, the instantiated version 
-    // of the signature will still be the same
-    // at both the callsite and the target). </TODO>
-    MetaSig mSig(pResolvedMD);
-
-    // get the target depending on whether the method is virtual or non-virtual
-    // like a constructor, private or final method
-    PCODE pTarget = pResolvedMD->GetCallTarget(&(gc.pServer));
-
-    VASigCookie *pCookie = NULL;
-    _ASSERTE(NULL != pTarget);
-
-        // this function does the work
-    ::CallDescrWithObjectArray(
-            gc.pServer,
-            pResolvedMD,
-            //pRM,
-            pTarget,
-            &mSig,
-            pCookie,
-            gc.pArgs,
-            &gc.ret,
-            ppVarOutParams);
-
-    LOG((LF_REMOTING, LL_INFO10, "CStackBuilderSink::PrivateProcessMessage OUT\n"));
-
-    HELPER_METHOD_FRAME_END();
-    
-    return OBJECTREFToObject(gc.ret);
-}
-FCIMPLEND
-
-class ProfilerServerCallbackHolder
-{
-public:
-    ProfilerServerCallbackHolder(Thread* pThread) : m_pThread(pThread)
-    {
-#ifdef PROFILING_SUPPORTED
-        // If we're profiling, notify the profiler that we're about to invoke the remoting target
-        {
-            BEGIN_PIN_PROFILER(CORProfilerTrackRemoting());
-            GCX_PREEMP();
-            g_profControlBlock.pProfInterface->RemotingServerInvocationStarted();
-            END_PIN_PROFILER();
-        }
-#endif // PROFILING_SUPPORTED
-    }
-
-    ~ProfilerServerCallbackHolder()
-    {
-#ifdef PROFILING_SUPPORTED
-        // If profiling is active, tell profiler we've made the call, received the
-        // return value, done any processing necessary, and now remoting is done.
-        {
-            BEGIN_PIN_PROFILER(CORProfilerTrackRemoting());
-            GCX_PREEMP();
-            g_profControlBlock.pProfInterface->RemotingServerInvocationReturned();
-            END_PIN_PROFILER();
-        }
-#endif // PROFILING_SUPPORTED
-    }
-
-private:
-    Thread* m_pThread;
-};
-
-//+----------------------------------------------------------------------------
-//
-//  Function:   CallDescrWithObjectArray, private
-//
-//  Synopsis:   Builds the stack from a object array and call the object
-// 
-//
-// Note this function triggers GC and assumes that pServer, pArguments, pVarRet, and ppVarOutParams are
-// all already protected!!
-//+----------------------------------------------------------------------------
-void CallDescrWithObjectArray(OBJECTREF& pServer,
-                  //ReflectMethod *pRM,
-                  MethodDesc *pMeth,
-                  PCODE pTarget,
-                  MetaSig* sig,
-                  VASigCookie *pCookie,
-                  PTRARRAYREF& pArgArray,
-                  OBJECTREF *pVarRet,
-                  PTRARRAYREF *ppVarOutParams)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        INJECT_FAULT(COMPlusThrowOM());
-    }
-    CONTRACTL_END;
-
-    LOG((LF_REMOTING, LL_INFO10, "CallDescrWithObjectArray IN\n"));
-
-#ifdef _PREFAST_
-#pragma warning(push)
-#pragma warning(disable:6263) // "Suppress PREFast warning about _alloca in a loop"
-    // _alloca is called within a loop in a number of places within this method
-    // (as an ultra fast means of acquiring temporary storage). This can be a
-    // problem in some scenarios (swiftly drive us to stack overflow). But in
-    // this case the allocations are tightly bounded (by the number of arguments
-    // in the target method) and the allocations themselves are small (no worse
-    // really than calling the method an extra time).
-#endif
-
-    ByRefInfo *pByRefs = NULL;
-    FrameWithCookie<ProtectValueClassFrame> *pProtectValueClassFrame = NULL;
-    FrameWithCookie<ProtectByRefsFrame> *pProtectionFrame = NULL;
-    UINT  nStackBytes = 0;
-    LPBYTE pAlloc = 0;
-    LPBYTE pTransitionBlock = 0;
-    UINT32 numByRef = 0;
-    //DWORD attr = pRM->dwFlags;
-#ifdef _DEBUG
-    //MethodDesc *pMD = pRM->pMethod;
-#endif
-    ValueClassInfo *pValueClasses = NULL;
-    
-    // check the calling convention
-
-    BYTE callingconvention = sig->GetCallingConvention();
-    if (!isCallConv(callingconvention, IMAGE_CEE_CS_CALLCONV_DEFAULT))
-    {
-        _ASSERTE(!"This calling convention is not supported.");
-        COMPlusThrow(kInvalidProgramException);
-    }
-
-    // Make sure we are properly loaded
-    CONSISTENCY_CHECK(GetAppDomain()->CheckCanExecuteManagedCode(pMeth));
-
-    // Note this is redundant with the above but we do it anyway for safety
-    pMeth->EnsureActive();
-
-#ifdef DEBUGGING_SUPPORTED
-    // debugger goo What does this do? can someone put a comment here?
-    if (CORDebuggerTraceCall())
-    {
-        g_pDebugInterface->TraceCall((const BYTE *)pTarget);
-    }
-#endif // DEBUGGING_SUPPORTED
-
-    Thread * pThread = GetThread();
-
-    {
-        ProfilerServerCallbackHolder profilerHolder(pThread);
-
-    ArgIterator argit(sig);
-
-    // Create a fake FramedMethodFrame on the stack.
-    nStackBytes = argit.SizeOfFrameArgumentArray();
-
-    UINT32 cbAlloc = 0;
-    if (!ClrSafeInt<UINT32>::addition(TransitionBlock::GetNegSpaceSize(), sizeof(TransitionBlock), cbAlloc))
-        COMPlusThrow(kArgumentException);
-    if (!ClrSafeInt<UINT32>::addition(cbAlloc, nStackBytes, cbAlloc))
-        COMPlusThrow(kArgumentException);
-
-    pAlloc = (LPBYTE)_alloca(cbAlloc);
-    pTransitionBlock = pAlloc + TransitionBlock::GetNegSpaceSize();
-
-    // cycle through the parameters and see if there are byrefs
-    BOOL   fHasByRefs = FALSE;
-
-    //if (attr & RM_ATTR_BYREF_FLAG_SET)
-    //    fHasByRefs = attr & RM_ATTR_HAS_BYREF_ARG;
-    //else
-    {
-        sig->Reset();
-        CorElementType typ;
-        while ((typ = sig->NextArg()) != ELEMENT_TYPE_END)
-        {
-            if (typ == ELEMENT_TYPE_BYREF)
-            {
-                fHasByRefs = TRUE;
-                //attr |= RM_ATTR_HAS_BYREF_ARG;
-                break;
-            }
-        }
-        //attr |= RM_ATTR_BYREF_FLAG_SET;
-        //pRM->dwFlags = attr;
-        sig->Reset();
-    }
-
-    UINT32 nFixedArgs = sig->NumFixedArgs();
-    // To avoid any security problems with integer overflow/underflow we're
-    // going to validate the number of args here (we're about to _alloca an
-    // array of ArgInfo structures and maybe a managed object array as well
-    // based on this count).
-    _ASSERTE(sizeof(Object*) <= sizeof(ArgInfo));
-    UINT32 nMaxArgs = UINT32_MAX / sizeof(ArgInfo);
-    if (nFixedArgs > nMaxArgs)
-        COMPlusThrow(kArgumentException);
-
-    // if there are byrefs allocate and array for the out parameters
-    if (fHasByRefs)
-    {
-        *ppVarOutParams = PTRARRAYREF(AllocateObjectArray(sig->NumFixedArgs(), g_pObjectClass));
-
-        // Null out the array
-        memset(&(*ppVarOutParams)->m_Array, 0, sizeof(OBJECTREF) * sig->NumFixedArgs());
-    }
-
-    OBJECTREF *ppThis = NULL;
-    
-    if (sig->HasThis())
-    {
-        ppThis = (OBJECTREF*)(pTransitionBlock + argit.GetThisOffset());
-
-        // *ppThis is not GC protected. It will be set to the right value
-        // after all object allocations are made.
-        *ppThis = NULL;
-    }
-
-    // if we have the Value Class return, we need to allocate that class and place a pointer to it on the stack.
-
-    *pVarRet = NULL;
-    TypeHandle retType = sig->GetRetTypeHandleThrowing();
-    // Note that we want the unnormalized (signature) type because GetStackObject
-    // boxes as the element type, which if we normalized it would loose information.
-    CorElementType retElemType = sig->GetReturnType(); 
-
-    // The MethodTable pointer of the return type, if that's a struct
-    MethodTable* pStructRetTypeMT = NULL;
-    
-        // Allocate a boxed struct instance to hold the return value in any case.
-    if (retElemType == ELEMENT_TYPE_VALUETYPE) 
-    {
-        pStructRetTypeMT = retType.GetMethodTable();
-        *pVarRet = pStructRetTypeMT->Allocate();
-    }
-    else  {
-        _ASSERTE(!argit.HasRetBuffArg());
-    }
-
-#ifdef CALLDESCR_REGTYPEMAP
-    UINT64  dwRegTypeMap    = 0;
-    BYTE*   pMap            = (BYTE*)&dwRegTypeMap;
-#endif // CALLDESCR_REGTYPEMAP
-
-#ifdef CALLDESCR_FPARGREGS
-    FloatArgumentRegisters *pFloatArgumentRegisters = NULL;
-#endif // CALLDESCR_FPARGREGS
-
-    // gather data about the parameters by iterating over the sig:
-    UINT32 arg = 0;
-    int    ofs = 0;
-
-    // REVIEW: need to use actual arg count if VarArgs are supported
-    ArgInfo* pArgInfoStart = (ArgInfo*) _alloca(nFixedArgs*sizeof(ArgInfo));
-
-#ifdef _DEBUG
-    // We expect to write useful data over every part of this so need
-    // not do this in retail!
-    memset((void *)pArgInfoStart, 0, sizeof(ArgInfo)*nFixedArgs);
-#endif
-
-    for (; TransitionBlock::InvalidOffset != (ofs = argit.GetNextOffset()); arg++)
-    {
-        CONSISTENCY_CHECK(arg < nFixedArgs);
-        ArgInfo* pArgInfo = pArgInfoStart + arg;
-
-#ifdef CALLDESCR_REGTYPEMAP
-        FillInRegTypeMap(ofs, argit.GetArgType(), pMap);
-#endif
-
-#ifdef CALLDESCR_FPARGREGS
-        // Under CALLDESCR_FPARGREGS we can have arguments in floating point registers. If we have at
-        // least one such argument we point the call worker at the floating point area of the frame (we leave
-        // it null otherwise since the worker can perform a useful optimization if it knows no floating point
-        // registers need to be set up).
-        if (TransitionBlock::HasFloatRegister(ofs, argit.GetArgLocDescForStructInRegs()) && 
-            (pFloatArgumentRegisters == NULL))
-        {
-            pFloatArgumentRegisters = (FloatArgumentRegisters*)(pTransitionBlock +
-                                                                TransitionBlock::GetOffsetOfFloatArgumentRegisters());
-        }
-#endif
-
-        if (argit.GetArgType() == ELEMENT_TYPE_BYREF)
-        {
-            TypeHandle ty = TypeHandle();
-            CorElementType brType = sig->GetByRefType(&ty);
-            if (CorIsPrimitiveType(brType))
-            {
-                pArgInfo->dataSize = gElementTypeInfo[brType].m_cbSize;
-            }
-            else if (ty.IsValueType())
-            {
-                pArgInfo->dataSize = ty.GetMethodTable()->GetNumInstanceFieldBytes();
-                numByRef ++;
-            }
-            else
-            {
-                pArgInfo->dataSize = sizeof(Object *);
-                numByRef ++;
-            }
-
-            ByRefInfo *brInfo = (ByRefInfo *) _alloca(offsetof(ByRefInfo,data) + pArgInfo->dataSize);
-            brInfo->argIndex = arg;
-            brInfo->typ = brType;
-            brInfo->typeHandle = ty;
-            brInfo->pNext = pByRefs;
-            pByRefs = brInfo;
-            pArgInfo->dataLocation = (BYTE*)brInfo->data;
-            *((void**)(pTransitionBlock + ofs)) = (void*)pArgInfo->dataLocation;
-            pArgInfo->dataTypeHandle = ty;
-            pArgInfo->dataType = static_cast<BYTE>(brType);
-            pArgInfo->byref = TRUE;
-        }
-        else
-        {
-            pArgInfo->dataLocation = pTransitionBlock + ofs;
-            pArgInfo->dataSize = argit.GetArgSize();
-            pArgInfo->dataTypeHandle = sig->GetLastTypeHandleThrowing(); // this may cause GC!
-            pArgInfo->dataType = (BYTE)argit.GetArgType();
-            pArgInfo->byref = FALSE;
-        }
-    }
-
-
-    if (ppThis)
-    {
-        // If this isn't a value class, verify the objectref
-#ifdef _DEBUG
-        //if (pMD->GetMethodTable()->IsValueType() == FALSE)
-        //{
-        //    VALIDATEOBJECTREF(pServer);
-        //}
-#endif //_DEBUG
-        *ppThis = pServer;
-    }
-
-    PVOID pRetBufStackData = NULL;
-    
-    if (argit.HasRetBuffArg())
-    {
-        // If the return buffer *must* be a stack-allocated object, allocate it.
-        PVOID pRetBufData = NULL;
-        if (pStructRetTypeMT->IsStructRequiringStackAllocRetBuf())
-        {
-            SIZE_T sz = pStructRetTypeMT->GetNumInstanceFieldBytes();
-            pRetBufData = pRetBufStackData = _alloca(sz);
-            memset(pRetBufData, 0, sz);
-            pValueClasses = new (_alloca(sizeof(ValueClassInfo))) ValueClassInfo(pRetBufStackData, pStructRetTypeMT, pValueClasses);
-        }
-        else
-        {
-            pRetBufData = (*pVarRet)->GetData();
-        }
-        *((LPVOID*) (pTransitionBlock + argit.GetRetBuffArgOffset())) = pRetBufData;
-    }
-
-    // There should be no GC when we fill up the stack with parameters, as we don't protect them
-    // Assignment of "*ppThis" above triggers the point where we become unprotected.
-    {
-        GCX_FORBID();
-
-        PBYTE             dataLocation;
-        INT32             dataSize;
-        TypeHandle        dataTypeHandle;
-        BYTE              dataType;
-
-        OBJECTREF* pArguments = pArgArray->m_Array;
-        UINT32 i;
-        for (i=0; i<nFixedArgs; i++)
-        {
-            ArgInfo* pArgInfo = pArgInfoStart + i;
-
-            dataSize = pArgInfo->dataSize;
-            dataLocation = pArgInfo->dataLocation;
-            dataTypeHandle = pArgInfo->dataTypeHandle;
-            dataType = pArgInfo->dataType;
-
-                // Nullable<T> needs special treatment, even if it is 1, 2, 4, or 8 bytes
-            if (dataType == ELEMENT_TYPE_VALUETYPE)
-                goto DEFAULT_CASE;
-
-            switch (dataSize)
-            {
-                case 1:
-                    // This "if" statement is necessary to make the assignement big-endian aware
-                    if (pArgInfo->byref)
-                        *((INT8*)dataLocation) = *((INT8*)pArguments[i]->GetData());
-                    else
-                        *(StackElemType*)dataLocation = (StackElemType)*((INT8*)pArguments[i]->GetData());
-                    break;
-                case 2:
-                    // This "if" statement is necessary to make the assignement big-endian aware
-                    if (pArgInfo->byref)
-                    *((INT16*)dataLocation) = *((INT16*)pArguments[i]->GetData());
-                    else
-                        *(StackElemType*)dataLocation = (StackElemType)*((INT16*)pArguments[i]->GetData());
-                    break;
-                case 4:
-#ifndef _WIN64
-                    if ((dataType == ELEMENT_TYPE_STRING)  ||
-                        (dataType == ELEMENT_TYPE_OBJECT)  ||
-                        (dataType == ELEMENT_TYPE_CLASS)   ||
-                        (dataType == ELEMENT_TYPE_SZARRAY) ||
-                        (dataType == ELEMENT_TYPE_ARRAY))
-                    {
-                        *(OBJECTREF *)dataLocation = pArguments[i];
-                    }
-                    else
-                    {
-                        *(StackElemType*)dataLocation = (StackElemType)*((INT32*)pArguments[i]->GetData());
-                    }
-#else // !_WIN64
-                    // This "if" statement is necessary to make the assignement big-endian aware
-                    if (pArgInfo->byref)
-                        *(INT32*)dataLocation = *((INT32*)pArguments[i]->GetData());
-                    else
-                        *(StackElemType*)dataLocation = (StackElemType)*((INT32*)pArguments[i]->GetData());
-#endif // !_WIN64
-                    break;
-
-                case 8:
-#ifdef _WIN64
-                    if ((dataType == ELEMENT_TYPE_STRING)  ||
-                        (dataType == ELEMENT_TYPE_OBJECT)  ||
-                        (dataType == ELEMENT_TYPE_CLASS)   ||
-                        (dataType == ELEMENT_TYPE_SZARRAY) ||
-                        (dataType == ELEMENT_TYPE_ARRAY))
-                    {
-                        *(OBJECTREF *)dataLocation = pArguments[i];
-                    }
-                    else
-                    {
-                        *((INT64*)dataLocation) = *((INT64*)pArguments[i]->GetData());
-                    }
-#else // _WIN64
-                    *((INT64*)dataLocation) = *((INT64*)pArguments[i]->GetData());
-#endif // _WIN64
-                    break;
-
-                default:
-                {
-                DEFAULT_CASE:
-                    MethodTable * pMT = dataTypeHandle.GetMethodTable();
-
-#ifdef ENREGISTERED_PARAMTYPE_MAXSIZE
-                    // We do not need to allocate a buffer if the argument is already passed by reference.
-                    if (!pArgInfo->byref && ArgIterator::IsArgPassedByRef(dataTypeHandle))
-                    {
-                        PVOID pvArg = _alloca(dataSize);
-                        pMT->UnBoxIntoUnchecked(pvArg, pArguments[i]);
-                        *(PVOID*)dataLocation = pvArg;
-
-                        pValueClasses = new (_alloca(sizeof(ValueClassInfo))) ValueClassInfo(pvArg, pMT, pValueClasses);
-                    }
-                    else
-#endif
-                    {
-                        pMT->UnBoxIntoUnchecked(dataLocation, pArguments[i]);
-                    }
-                }
-            }
-        }
-
-#ifdef _DEBUG
-        // Should not be using this any more
-        memset((void *)pArgInfoStart, 0, sizeof(ArgInfo)*nFixedArgs);
-#endif
-
-        // if there were byrefs, push a protection frame
-        if (pByRefs && numByRef > 0)
-        {
-            char *pBuffer = (char*)_alloca (sizeof (FrameWithCookie<ProtectByRefsFrame>));
-            pProtectionFrame = new (pBuffer) FrameWithCookie<ProtectByRefsFrame>(pThread, pByRefs);
-        }
-
-        // If there were any value classes that must be protected by the
-        // caller, push a ProtectValueClassFrame.
-        if (pValueClasses)
-        {
-            char *pBuffer = (char*)_alloca (sizeof (FrameWithCookie<ProtectValueClassFrame>));
-            pProtectValueClassFrame = new (pBuffer) FrameWithCookie<ProtectValueClassFrame>(pThread, pValueClasses);
-        }
-
-    } // GCX_FORBID
-
-    UINT fpReturnSize = argit.GetFPReturnSize();
-
-    CallDescrData callDescrData;
-
-    callDescrData.pSrc = pTransitionBlock + sizeof(TransitionBlock);
-    callDescrData.numStackSlots = nStackBytes / STACK_ELEM_SIZE;
-#ifdef CALLDESCR_ARGREGS
-    callDescrData.pArgumentRegisters = (ArgumentRegisters*)(pTransitionBlock + TransitionBlock::GetOffsetOfArgumentRegisters());
-#endif
-#ifdef CALLDESCR_FPARGREGS
-    callDescrData.pFloatArgumentRegisters = pFloatArgumentRegisters;
-#endif
-#ifdef CALLDESCR_REGTYPEMAP
-    callDescrData.dwRegTypeMap = dwRegTypeMap;
-#endif
-    callDescrData.fpReturnSize = fpReturnSize;
-    callDescrData.pTarget = pTarget;
-
-    CallDescrWorkerWithHandler(&callDescrData);
-
-        // It is still illegal to do a GC here.  The return type might have/contain GC pointers.
-    if (retElemType == ELEMENT_TYPE_VALUETYPE) 
-    {
-        _ASSERTE(*pVarRet != NULL);            // we have already allocated a return object
-        PVOID pVarRetData = (*pVarRet)->GetData();
-
-        // If the return result was passed back in registers, then copy it into the return object
-        if (!argit.HasRetBuffArg())
-        {
-            CopyValueClass(pVarRetData, &callDescrData.returnValue, (*pVarRet)->GetMethodTable(), (*pVarRet)->GetAppDomain());
-        }
-        else if (pRetBufStackData != NULL)
-        {
-            // Copy the stack-allocated ret buff to the heap-allocated one.
-            CopyValueClass(pVarRetData, pRetBufStackData, (*pVarRet)->GetMethodTable(), (*pVarRet)->GetAppDomain());
-        }
-
-        // If the return is a Nullable<T>, box it using Nullable<T> conventions.
-        // TODO: this double allocates on constructions which is wasteful
-        if (!retType.IsNull())
-            *pVarRet = Nullable::NormalizeBox(*pVarRet);
-    }
-    else 
-        CMessage::GetObjectFromStack(pVarRet, &callDescrData.returnValue, retElemType, retType);
-
-        // You can now do GCs if you want to
-
-    if (pProtectValueClassFrame)
-        pProtectValueClassFrame->Pop(pThread);
-
-    // extract the out args from the byrefs
-    if (pByRefs)
-    {
-        do
-        {
-            // Always extract the data ptr every time we enter this loop because
-            // calls to GetObjectFromStack below can cause a GC.
-            // Even this is not enough, because that we are passing a pointer to GC heap
-            // to GetObjectFromStack .  If GC happens, nobody is protecting the passed in pointer.
-
-            OBJECTREF pTmp = NULL;
-            void* dataLocation = pByRefs->data;
-            CMessage::GetObjectFromStack(&pTmp, &dataLocation, pByRefs->typ, pByRefs->typeHandle, TRUE);
-            (*ppVarOutParams)->SetAt(pByRefs->argIndex, pTmp);
-            pByRefs = pByRefs->pNext;
-        }
-        while (pByRefs);
-
-        if (pProtectionFrame)
-            pProtectionFrame->Pop(pThread);
-    }
-
-    }  // ProfilerServerCallbackHolder
-
-#ifdef _PREFAST_
-#pragma warning(pop)
-#endif
-
-    LOG((LF_REMOTING, LL_INFO10, "CallDescrWithObjectArray OUT\n"));
-}
-
-#endif // FEATURE_REMOTING
diff --git a/src/vm/stackcompressor.cpp b/src/vm/stackcompressor.cpp
deleted file mode 100644
index 01f2a3d67f..0000000000
--- a/src/vm/stackcompressor.cpp
+++ /dev/null
@@ -1,378 +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.
-// 
-
-
-// 
-
-
-#include "common.h"
-
-#ifdef FEATURE_COMPRESSEDSTACK
-
-#include "stackcompressor.h"
-#include "securitystackwalk.h"
-#include "appdomainstack.inl"
-#include "comdelegate.h"
-
-//-----------------------------------------------------------
-// Stack walk callback data structure for stack compress.
-//-----------------------------------------------------------
-typedef struct _StackCompressData
-{
-    void*    compressedStack;
-    StackCrawlMark *    stackMark;
-    DWORD               dwFlags;
-    Assembly *          prevAssembly; // Previously checked assembly.
-    AppDomain *         prevAppDomain;
-    Frame* pCtxTxFrame;
-} StackCompressData;
-
-
-void TurnSecurityStackWalkProgressOn( Thread* pThread ) 
-{ 
-    WRAPPER_NO_CONTRACT;
-    pThread->SetSecurityStackwalkInProgress( TRUE ); 
-}
-void TurnSecurityStackWalkProgressOff( Thread* pThread ) 
-{ 
-    WRAPPER_NO_CONTRACT;
-    pThread->SetSecurityStackwalkInProgress( FALSE ); 
-}
-typedef Holder< Thread*, TurnSecurityStackWalkProgressOn, TurnSecurityStackWalkProgressOff > StackWalkProgressEnableHolder;
-
-
-
-DWORD StackCompressor::GetCSInnerAppDomainOverridesCount(COMPRESSEDSTACKREF csRef)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-    //csRef can be NULL - that implies that we set the CS, then crossed an AD. So we would already have counted the overrides when we hit the
-    // ctxTxFrame. Nothing to do here
-    if (csRef != NULL)
-    {
-        NewCompressedStack* cs = (NewCompressedStack*)csRef->GetUnmanagedCompressedStack();
-        if (cs != NULL)
-            return cs->GetInnerAppDomainOverridesCount();
-    }
-    return 0;
-}
-DWORD StackCompressor::GetCSInnerAppDomainAssertCount(COMPRESSEDSTACKREF csRef)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        SO_TOLERANT;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-    //csRef can be NULL - that implies that we set the CS, then crossed an AD. So we would already have counted the overrides when we hit the
-    // ctxTxFrame. Nothing to do here
-    if (csRef != NULL)
-    {
-        NewCompressedStack* cs = (NewCompressedStack*)csRef->GetUnmanagedCompressedStack();
-        if (cs != NULL)
-            return cs->GetInnerAppDomainAssertCount();
-    }
-    return 0;
-}
-
-void* StackCompressor::SetAppDomainStack(Thread* pThread, void* curr)
-{
-    CONTRACTL
-    {
-        MODE_ANY;
-        GC_NOTRIGGER;
-        THROWS;
-    } CONTRACTL_END;
-
-    NewCompressedStack* unmanagedCompressedStack = (NewCompressedStack *)curr;
-
-    AppDomainStack* pRetADStack = NULL;
-       
-    if (unmanagedCompressedStack != NULL)
-    {
-        pRetADStack = new AppDomainStack(pThread->GetAppDomainStack());
-        pThread->SetAppDomainStack(unmanagedCompressedStack->GetAppDomainStack() );
-    }
-    else
-    {
-        if (!pThread->IsDefaultSecurityInfo())    /* Do nothing for the single domain/FT/no overrides case */
-        {
-            pRetADStack = new AppDomainStack(pThread->GetAppDomainStack());            
-            pThread->ResetSecurityInfo(); 
-        }
-    }
-    return (void*)pRetADStack;
-}
-
-void StackCompressor::RestoreAppDomainStack(Thread* pThread, void* appDomainStack)
-{
-    WRAPPER_NO_CONTRACT;
-    _ASSERTE(appDomainStack != NULL);
-    AppDomainStack* pADStack = (AppDomainStack*)appDomainStack;
-    pThread->SetAppDomainStack(*pADStack);
-    delete pADStack;
-}
-
-void StackCompressor::Destroy(void *stack)
-{
-    WRAPPER_NO_CONTRACT;
-    _ASSERTE(stack != NULL && "Don't pass NULL");
-    NewCompressedStack* ncs = (NewCompressedStack*)stack;
-    ncs->Destroy();
-}
-
-
-/* Forward declarations of the new CS stackwalking implementation */
-static void NCS_GetCompressedStackWorker(Thread *t, void *pData);
-static StackWalkAction NCS_CompressStackCB(CrawlFrame* pCf, void *pData);
-
-OBJECTREF StackCompressor::GetCompressedStack( StackCrawlMark* stackMark, BOOL fWalkStack )
-{
-   
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-        SO_INTOLERANT;// Not an entry point
-    } CONTRACTL_END;
-
-    // Get the current thread that we're to walk.
-    Thread * t = GetThread();    
-
-    NewCompressedStackHolder csHolder(new NewCompressedStack());
-
-        
-    if (fWalkStack)
-    {
-        //
-        // Initialize the callback data on the stack...        
-        //
-
-        StackCompressData walkData;
-        
-        walkData.dwFlags = 0;
-        walkData.prevAssembly = NULL;
-        walkData.prevAppDomain = NULL;
-        walkData.stackMark = stackMark;
-        walkData.pCtxTxFrame = NULL;
-
-
-        walkData.compressedStack = (void*)csHolder.GetValue();
-        NCS_GetCompressedStackWorker(t, &walkData);
-    }
-
-    struct _gc {
-        SAFEHANDLE pSafeCSHandle;
-    } gc;
-    gc.pSafeCSHandle = NULL;
-    
-    GCPROTECT_BEGIN(gc);
-    
-    gc.pSafeCSHandle = (SAFEHANDLE) AllocateObject(MscorlibBinder::GetClass(CLASS__SAFE_CSHANDLE));
-    CallDefaultConstructor(gc.pSafeCSHandle);
-    gc.pSafeCSHandle->SetHandle((void*) csHolder.GetValue());
-    csHolder.SuppressRelease();
-    
-    GCPROTECT_END();
-    return (OBJECTREF) gc.pSafeCSHandle;
-}
-
-    
-void NCS_GetCompressedStackWorker(Thread *t, void *pData)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    StackCompressData *pWalkData = (StackCompressData*)pData;
-    NewCompressedStack* compressedStack = (NewCompressedStack*) pWalkData->compressedStack;
-
-    _ASSERTE( t != NULL );
-
-    {
-        StackWalkProgressEnableHolder holder( t );
-
-        //
-        // Begin the stack walk...
-        //
-        // LIGHTUNWIND flag: allow using stackwalk cache for security stackwalks
-        // SKIPFUNCLETS flag: stop processing the stack after completing the current funclet (for instance
-        // only process the catch block on x64, not the throw block)
-        t->StackWalkFrames(NCS_CompressStackCB, pWalkData, SKIPFUNCLETS | LIGHTUNWIND);
-
-
-        // Ignore CS (if present) when we hit a FT assert
-        if (pWalkData->dwFlags & CORSEC_FT_ASSERT)
-            return;
-        
-        // Check if there is a CS at the top of the thread
-        COMPRESSEDSTACKREF csRef = (COMPRESSEDSTACKREF)t->GetCompressedStack();
-        AppDomain *pAppDomain = t->GetDomain();
-        Frame *pFrame = NULL;
-#ifdef FEATURE_REMOTING
-        if (csRef == NULL)
-        {
-            // There may have been an AD transition and we shd look at the CB data to see if this is the case
-            if (pWalkData->pCtxTxFrame != NULL)
-            {
-                pFrame = pWalkData->pCtxTxFrame;
-                csRef = Security::GetCSFromContextTransitionFrame(pFrame);
-                _ASSERTE(csRef != NULL); //otherwise we would not have saved the frame in the CB data
-                pAppDomain = pWalkData->pCtxTxFrame->GetReturnDomain();
-            }
-        }
-#endif // FEATURE_REMOTING
-
-        if (csRef != NULL)
-        {
-            
-
-            compressedStack->ProcessCS(pAppDomain, csRef, pFrame);
-        }
-        else
-        {
-            compressedStack->ProcessAppDomainTransition(); // just to update domain overrides/assert count at the end of stackwalk
-        }
-
-
-    }
-
-    return;      
-}
-
-StackWalkAction NCS_CompressStackCB(CrawlFrame* pCf, void *pData)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    StackCompressData *pCBdata = (StackCompressData*)pData;
-    NewCompressedStack* compressedStack = (NewCompressedStack*) pCBdata->compressedStack;
-
-    // First check if the walk has skipped the required frames. The check
-    // here is between the address of a local variable (the stack mark) and a
-    // pointer to the EIP for a frame (which is actually the pointer to the
-    // return address to the function from the previous frame). So we'll
-    // actually notice which frame the stack mark was in one frame later. This
-    // is fine for our purposes since we're always looking for the frame of the
-    // caller of the method that actually created the stack mark. 
-    _ASSERTE((pCBdata->stackMark == NULL) || (*pCBdata->stackMark == LookForMyCaller));
-    if ((pCBdata->stackMark != NULL) &&
-        !pCf->IsInCalleesFrames(pCBdata->stackMark))
-        return SWA_CONTINUE;
-
-    Frame *pFrame = pCf->GetFrame();
-
-#ifdef FEATURE_REMOTING
-    // Save the CtxTxFrame if this is one
-    if (pCBdata->pCtxTxFrame == NULL)
-    {
-        if (Security::IsContextTransitionFrameWithCS(pFrame))
-        {
-            pCBdata->pCtxTxFrame = pFrame;
-        }
-    }
-#endif // FEATURE_REMOTING
-
-    //  Handle AppDomain transitions:
-    AppDomain *pAppDomain = pCf->GetAppDomain();
-    if (pCBdata->prevAppDomain != pAppDomain)
-    {
-#ifndef FEATURE_REMOTING
-        BOOL bRealAppDomainTransition = (pCBdata->prevAppDomain != NULL);
-
-        // For a "real" appdomain transition, we can stop the stackwalk since there's no managed AD transitions
-        // without remoting. The "real" here denotes that this is not the first appdomain transition (from NULL to current)
-        // that happens on the first crawlframe we see on a stackwalk. Also don't do the final ad transition here (that'll happen 
-        // outside the callback)
-        if (bRealAppDomainTransition)
-        {
-            return SWA_ABORT;
-        }
-        else
-#endif // !FEATURE_REMOTING
-        {
-            compressedStack->ProcessAppDomainTransition();    
-            pCBdata->prevAppDomain = pAppDomain;
-        }
-            
-    }
-
-
-    if (pCf->GetFunction() == NULL)
-        return SWA_CONTINUE; // not a function frame, so we were just looking for CtxTransitionFrames. Resume the stackwalk...
-        
-    // Get the security object for this function...
-    OBJECTREF* pRefSecDesc = pCf->GetAddrOfSecurityObject();
-
-    MethodDesc * pFunc = pCf->GetFunction();
-
-    _ASSERTE(pFunc != NULL); // we requested methods!
-
-    Assembly * pAssem = pCf->GetAssembly();
-    _ASSERTE(pAssem != NULL);
-    PREFIX_ASSUME(pAssem != NULL);
-
-
-
-    
-    if (pRefSecDesc != NULL)
-        SecurityDeclarative::DoDeclarativeSecurityAtStackWalk(pFunc, pAppDomain, pRefSecDesc);
-
-    
-    
-    if (pFunc->GetMethodTable()->IsDelegate())
-    {
-        DelegateEEClass* delegateCls = (DelegateEEClass*) pFunc->GetMethodTable()->GetClass();
-        if (pFunc == delegateCls->m_pBeginInvokeMethod)
-        {
-            // Async delegate case: we may need to insert the creator frame into the CS 
-            DELEGATEREF dRef = (DELEGATEREF) ((FramedMethodFrame *)pFrame)->GetThis();
-            _ASSERTE(dRef);
-            if (COMDelegate::IsSecureDelegate(dRef))
-            {
-                if (!dRef->IsWrapperDelegate())
-                {
-                    MethodDesc* pCreatorMethod = (MethodDesc*) dRef->GetMethodPtrAux();
-                    Assembly* pCreatorAssembly = pCreatorMethod->GetAssembly();
-                    compressedStack->ProcessFrame(pAppDomain,
-                                                  NULL,
-                                                  NULL,
-                                                  pCreatorAssembly->GetSharedSecurityDescriptor(), 
-                                                  NULL) ; // ignore return value - No FSD being passed in.
-                }
-            }
-            
-        }
-    }
-        
-
-    DWORD retFlags = compressedStack->ProcessFrame(pAppDomain, 
-                                                   pAssem,
-                                                   pFunc,
-                                                   pAssem->GetSharedSecurityDescriptor(), 
-                                                   (FRAMESECDESCREF *) pRefSecDesc) ;
-    
-    pCBdata->dwFlags |= (retFlags & CORSEC_FT_ASSERT);
-    // ProcessFrame returns TRUE if we should stop stackwalking
-   if (retFlags != 0 || Security::IsSpecialRunFrame(pFunc))
-        return SWA_ABORT;
-   
-    return SWA_CONTINUE;
-
-}
-#endif // #ifdef FEATURE_COMPRESSEDSTACK
diff --git a/src/vm/stackcompressor.h b/src/vm/stackcompressor.h
deleted file mode 100644
index 062d2f4a9c..0000000000
--- a/src/vm/stackcompressor.h
+++ /dev/null
@@ -1,39 +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.
-// 
-
-
-// 
-
-
-#ifndef __stackcompressor_h__
-#define __stackcompressor_h__
-#ifdef FEATURE_COMPRESSEDSTACK
-
-#include "common.h"
-
-
-#include "newcompressedstack.h"
-
-#ifndef DACCESS_COMPILE
-
-class StackCompressor
-{
-       
-public:
-    static DWORD StackCompressor::GetCSInnerAppDomainAssertCount(COMPRESSEDSTACKREF csRef);
-    static DWORD StackCompressor::GetCSInnerAppDomainOverridesCount(COMPRESSEDSTACKREF csRef);
-    static void* SetAppDomainStack(Thread* pThread, void* curr);
-    static void RestoreAppDomainStack(Thread* pThread, void* appDomainStack);
-
-    static void Destroy(void *stack);
-    static OBJECTREF GetCompressedStack( StackCrawlMark* stackMark = NULL, BOOL fWalkStack = TRUE );
-    
-    
-};
-#endif // DACCESS_COMPILE
-#endif // #ifdef FEATURE_COMPRESSEDSTACK
-
-#endif // __stackcompressor_h__
-
diff --git a/src/vm/stackwalk.cpp b/src/vm/stackwalk.cpp
index 2cac5d9104..ffcd453cd7 100644
--- a/src/vm/stackwalk.cpp
+++ b/src/vm/stackwalk.cpp
@@ -20,6 +20,10 @@
 #include "interpreter.h"
 #endif // FEATURE_INTERPRETER
 
+#ifdef WIN64EXCEPTIONS
+#define PROCESS_EXPLICIT_FRAME_BEFORE_MANAGED_FRAME
+#endif
+
 #ifdef _DEBUG
 void* forceFrame;   // Variable used to force a local variable to the frame
 #endif
@@ -48,6 +52,7 @@ Assembly* CrawlFrame::GetAssembly()
     return pAssembly;
 }
 
+#ifndef DACCESS_COMPILE
 OBJECTREF* CrawlFrame::GetAddrOfSecurityObject()
 {
     CONTRACTL {
@@ -94,6 +99,7 @@ OBJECTREF* CrawlFrame::GetAddrOfSecurityObject()
     }
     return NULL;
 }
+#endif
 
 BOOL CrawlFrame::IsInCalleesFrames(LPVOID stackPointer)
 {
@@ -652,20 +658,7 @@ PCODE Thread::VirtualUnwindCallFrame(T_CONTEXT* pContext,
     return uControlPc;
 }
 
-#ifdef DACCESS_COMPILE
-
-PCODE Thread::VirtualUnwindLeafCallFrame(T_CONTEXT* pContext)
-{
-    DacNotImpl();
-    return 0;
-}
-UINT_PTR Thread::VirtualUnwindToFirstManagedCallFrame(T_CONTEXT* pContext)
-{
-    DacNotImpl();
-    return 0;
-}
-
-#else  // !DACCESS_COMPILE
+#ifndef DACCESS_COMPILE
 
 // static
 PCODE Thread::VirtualUnwindLeafCallFrame(T_CONTEXT* pContext)
@@ -790,7 +783,7 @@ UINT_PTR Thread::VirtualUnwindToFirstManagedCallFrame(T_CONTEXT* pContext)
     return uControlPc;
 }
 
-#endif // DACCESS_COMPILE
+#endif // !DACCESS_COMPILE
 #endif // WIN64EXCEPTIONS
 
 #ifdef _DEBUG
@@ -1343,7 +1336,7 @@ BOOL StackFrameIterator::ResetRegDisp(PREGDISPLAY pRegDisp,
     {
         TADDR curSP = GetRegdisplaySP(m_crawl.pRD);
 
-#if !defined(_TARGET_X86_)
+#ifdef PROCESS_EXPLICIT_FRAME_BEFORE_MANAGED_FRAME
         if (m_crawl.IsFrameless())
         {
             // On 64-bit and ARM, we stop at the explicit frames contained in a managed stack frame 
@@ -1351,7 +1344,7 @@ BOOL StackFrameIterator::ResetRegDisp(PREGDISPLAY pRegDisp,
             EECodeManager::EnsureCallerContextIsValid(m_crawl.pRD, NULL);
             curSP = GetSP(m_crawl.pRD->pCallerContext);
         }
-#endif // !_TARGET_X86_
+#endif // PROCESS_EXPLICIT_FRAME_BEFORE_MANAGED_FRAME
 
 #if defined(_TARGET_X86_)
         // special processing on x86; see below for more information
@@ -2368,7 +2361,7 @@ StackWalkAction StackFrameIterator::NextRaw(void)
         }
         else
         {
-#if defined(_TARGET_X86_)
+#ifndef PROCESS_EXPLICIT_FRAME_BEFORE_MANAGED_FRAME
             // On x86, we process a managed stack frame before processing any explicit frames contained in it.
             // So when we are done with the skipped explicit frame, we have already processed the managed
             // stack frame, and it is time to move onto the next stack frame.
@@ -2377,7 +2370,7 @@ StackWalkAction StackFrameIterator::NextRaw(void)
             {
                 goto Cleanup;
             }
-#else // _TARGET_X86_
+#else // !PROCESS_EXPLICIT_FRAME_BEFORE_MANAGED_FRAME
             // We are done handling the skipped explicit frame at this point.  So move on to the 
             // managed stack frame.
             m_crawl.isFrameless = true;
@@ -2387,7 +2380,7 @@ StackWalkAction StackFrameIterator::NextRaw(void)
 
             PreProcessingForManagedFrames();
             goto Cleanup;
-#endif // _TARGET_X86_
+#endif // PROCESS_EXPLICIT_FRAME_BEFORE_MANAGED_FRAME
         }
     }
     else if (m_frameState == SFITER_FRAMELESS_METHOD)
@@ -2460,7 +2453,7 @@ StackWalkAction StackFrameIterator::NextRaw(void)
              DBG_ADDR(GetRegdisplaySP(m_crawl.pRD)), 
              DBG_ADDR(GetControlPC(m_crawl.pRD))));
 
-#if !defined(DACCESS_COMPILE)
+#if !defined(DACCESS_COMPILE) && defined(HAS_QUICKUNWIND)
         StackwalkCacheEntry *pCacheEntry = m_crawl.GetStackwalkCacheEntry();
         if (pCacheEntry != NULL)
         {
@@ -2470,7 +2463,7 @@ StackWalkAction StackFrameIterator::NextRaw(void)
             EECodeManager::QuickUnwindStackFrame(m_crawl.pRD, pCacheEntry, EECodeManager::UnwindCurrentStackFrame);
         }
         else
-#endif // !DACCESS_COMPILE
+#endif // !DACCESS_COMPILE && HAS_QUICKUNWIND
         {
 #if !defined(DACCESS_COMPILE)
             // non-optimized stack unwind schema, doesn't use StackwalkCache
@@ -2572,14 +2565,14 @@ StackWalkAction StackFrameIterator::NextRaw(void)
         m_crawl.hasFaulted    = FALSE;
         m_crawl.isIPadjusted  = FALSE;
 
-#if defined(_TARGET_X86_)
+#ifndef PROCESS_EXPLICIT_FRAME_BEFORE_MANAGED_FRAME
         // remember, x86 handles the managed stack frame before the explicit frames contained in it
         if (CheckForSkippedFrames())
         {
             _ASSERTE(m_frameState == SFITER_SKIPPED_FRAME_FUNCTION);
             goto Cleanup;
         }
-#endif // _TARGET_X86_
+#endif // !PROCESS_EXPLICIT_FRAME_BEFORE_MANAGED_FRAME
 
         PostProcessingForManagedFrames();
         if (m_frameState == SFITER_NATIVE_MARKER_FRAME)
@@ -2668,12 +2661,11 @@ StackWalkAction StackFrameIterator::NextRaw(void)
 #endif // !_TARGET_X86_
 
 
+#if defined(_DEBUG) && !defined(DACCESS_COMPILE) && !defined(WIN64EXCEPTIONS)
                 // We are transitioning from unmanaged code to managed code... lets do some validation of our
                 // EH mechanism on platforms that we can.
-#if defined(_DEBUG)  && !defined(DACCESS_COMPILE) && (defined(_TARGET_X86_) && !defined(FEATURE_PAL)) && !defined(WIN64EXCEPTIONS)               
-                // TODO: Revise this once we enable WIN64EXCEPTIONS for x86/Linux
                 VerifyValidTransitionFromManagedCode(m_crawl.pThread, &m_crawl);
-#endif // _DEBUG && !DACCESS_COMPILE && _TARGET_X86_ && !WIN64EXCEPTIONS
+#endif // _DEBUG && !DACCESS_COMPILE &&  !WIN64EXCEPTIONS
             }
         }
 
@@ -2966,7 +2958,7 @@ void StackFrameIterator::ProcessCurrentFrame(void)
             // Cache values which may be updated by CheckForSkippedFrames()
             m_cachedCodeInfo = m_crawl.codeInfo;
 
-#if !defined(_TARGET_X86_)
+#ifdef PROCESS_EXPLICIT_FRAME_BEFORE_MANAGED_FRAME
             // On non-X86, we want to process the skipped explicit frames before the managed stack frame
             // containing them.
             if (CheckForSkippedFrames())
@@ -2974,7 +2966,7 @@ void StackFrameIterator::ProcessCurrentFrame(void)
                 _ASSERTE(m_frameState == SFITER_SKIPPED_FRAME_FUNCTION);
             }
             else
-#endif // !_TARGET_X86_
+#endif // PROCESS_EXPLICIT_FRAME_BEFORE_MANAGED_FRAME
             {
                 PreProcessingForManagedFrames();
                 _ASSERTE(m_frameState == SFITER_FRAMELESS_METHOD);
@@ -3021,9 +3013,9 @@ BOOL StackFrameIterator::CheckForSkippedFrames(void)
     // Can the caller handle skipped frames;
     fHandleSkippedFrames = (m_flags & HANDLESKIPPEDFRAMES);
 
-#if defined(_TARGET_X86_)
+#ifndef PROCESS_EXPLICIT_FRAME_BEFORE_MANAGED_FRAME
     pvReferenceSP = GetRegdisplaySP(m_crawl.pRD);
-#else // _TARGET_X86_
+#else // !PROCESS_EXPLICIT_FRAME_BEFORE_MANAGED_FRAME
     // Order the Frames relative to the caller SP of the methods
     // this makes it so that any Frame that is in a managed call
     // frame will be reported before its containing method.
@@ -3031,7 +3023,7 @@ BOOL StackFrameIterator::CheckForSkippedFrames(void)
     // This should always succeed!  If it doesn't, it's a bug somewhere else!
     EECodeManager::EnsureCallerContextIsValid(m_crawl.pRD, m_crawl.GetStackwalkCacheEntry(), &m_cachedCodeInfo);
     pvReferenceSP = GetSP(m_crawl.pRD->pCallerContext);
-#endif // _TARGET_X86_
+#endif // PROCESS_EXPLICIT_FRAME_BEFORE_MANAGED_FRAME
 
     if ( !( (m_crawl.pFrame != FRAME_TOP) && 
             (dac_cast<TADDR>(m_crawl.pFrame) < pvReferenceSP) )
diff --git a/src/vm/stackwalk.h b/src/vm/stackwalk.h
index f8bd519106..3de8c6acef 100644
--- a/src/vm/stackwalk.h
+++ b/src/vm/stackwalk.h
@@ -107,6 +107,7 @@ public:
 
     BOOL IsInCalleesFrames(LPVOID stackPointer);
 
+#ifndef DACCESS_COMPILE
     /* Returns address of the securityobject stored in the current function (method?)
        Returns NULL if
             - not a function OR
@@ -114,6 +115,7 @@ public:
               (which is an error)
      */
     OBJECTREF * GetAddrOfSecurityObject();
+#endif // DACCESS_COMPILE
 
     // Fetch the extra type argument passed in some cases
     PTR_VOID GetParamTypeArg();
diff --git a/src/vm/stdinterfaces.cpp b/src/vm/stdinterfaces.cpp
index c80ec3fe22..5fd8455b2a 100644
--- a/src/vm/stdinterfaces.cpp
+++ b/src/vm/stdinterfaces.cpp
@@ -27,9 +27,6 @@
 #include "threads.h"
 #include "interoputil.h"
 #include "tlbexport.h"
-#ifdef FEATURE_COMINTEROP_TLB_SUPPORT
-#include "comtypelibconverter.h"
-#endif
 #include "comdelegate.h"
 #include "olevariant.h"
 #include "eeconfig.h"
@@ -626,219 +623,8 @@ HRESULT GetITypeLibForAssembly(Assembly *pAssembly, ITypeLib **ppTLB, int bAutoC
     }
     CONTRACTL_END;
     
-#ifdef FEATURE_CORECLR
     //@CORESYSTODO: what to do?
     return E_FAIL;
-#else
-
-    HRESULT     hr = S_OK;              // A result.
-    CQuickWSTRBase  rName;              // Library (scope) or file name.
-    int         bResize=false;          // If true, had to resize the buffer to hold the name.
-    LPCWSTR     szModule=0;             // The module name.
-    GUID        guid;                   // A GUID.
-    ITypeLib    *pITLB=0;               // The TypeLib.
-    Module      *pModule;               // The assembly's module.
-    WCHAR       rcDrive[_MAX_DRIVE];    // Module's drive letter.
-    WCHAR       rcDir[_MAX_DIR];        // Module's directory.
-    WCHAR       rcFname[_MAX_FNAME];    // Module's file name.
-    USHORT      wMajor;                 // Major version number.
-    USHORT      wMinor;                 // Minor version number.
-
-    rName.Init();
-
-    // Check to see if we have a cached copy.
-    pITLB = pAssembly->GetTypeLib();
-    if (pITLB)
-    {
-        // Check to see if the cached value is -1. This indicate that we tried
-        // to export the typelib but that the export failed.
-        if (pITLB == (ITypeLib*)-1)
-        {
-            hr = E_FAIL;
-            goto ReturnHR;
-        }
-
-        // We have a cached copy so return it.
-        *ppTLB = pITLB;
-        hr = S_OK;
-        goto ReturnHR;
-    }
-
-    // Retrieve the name of the module.
-    pModule = pAssembly->GetManifestModule();
-
-    EX_TRY
-    {
-        // SString::ConvertToUnicode is THROW_UNLESS_NORMALIZED
-        szModule = pModule->GetPath();
-    }
-    EX_CATCH_HRESULT(hr);
-    IfFailGo(hr);
-
-    // Retrieve the guid for typelib that would be generated from the assembly.
-    IfFailGo(GetTypeLibGuidForAssembly(pAssembly, &guid));
-
-    // If the typelib is for the runtime library, we'd better know where it is.
-    if (guid == LIBID_ComPlusRuntime)
-    {
-        ULONG dwSize = (ULONG)rName.MaxSize();
-        while (FAILED(GetInternalSystemDirectory(rName.Ptr(), &dwSize)))
-        {
-            IfFailGo(rName.ReSizeNoThrow(dwSize=(ULONG)rName.MaxSize()*2));
-        }
-
-        IfFailGo(rName.ReSizeNoThrow(dwSize + wcslen(g_pwBaseLibraryTLB) + 3));
-        wcscat_s(rName.Ptr(), rName.Size(), g_pwBaseLibraryTLB);
-        hr = LoadTypeLibExWithFlags(rName.Ptr(), flags, &pITLB);
-        goto ErrExit;       
-    }
-
-    // Retrieve the major and minor version number.
-    IfFailGo(GetTypeLibVersionForAssembly(pAssembly, &wMajor, &wMinor));
-
-    // Maybe the module was imported from COM, and we can get the libid of the existing typelib.
-    if (pAssembly->IsImportedFromTypeLib())
-    {
-        hr = LoadRegTypeLibWithFlags(guid, wMajor, wMinor, flags, &pITLB);
-        if (SUCCEEDED(hr))
-            goto ErrExit;
-
-        // Try just the Assembly version
-        pAssembly->GetVersion(&wMajor, &wMinor, NULL, NULL);
-        hr = LoadRegTypeLibWithFlags(guid, wMajor, wMinor, flags, &pITLB);
-        if (SUCCEEDED(hr))
-            goto ErrExit;
-
-        // Try loading the highest registered version.
-        hr = LoadRegTypeLibWithFlags(guid, -1, -1, flags, &pITLB);
-        if (SUCCEEDED(hr))
-            goto ErrExit;
-
-        // The module is known to be imported, so no need to try conversion.
-
-        // Set the error info for most callers.
-        VMPostError(TLBX_E_CIRCULAR_EXPORT2, szModule);
-
-        // Set the hr for the case where we're trying to load a type library to
-        // resolve a type reference from another library.  The error message will
-        // be posted where more information is available.
-        if (hr == TYPE_E_LIBNOTREGISTERED)
-            hr = TLBX_W_LIBNOTREGISTERED;
-        else
-            hr = TLBX_E_CANTLOADLIBRARY;
-
-        IfFailGo(hr);
-    }
-
-    // Try to load the registered typelib.
-    hr = LoadRegTypeLibWithFlags(guid, wMajor, wMinor, flags, &pITLB);
-    if(hr == S_OK)
-        goto ErrExit;
-
-    // Try just the Assembly version
-    pAssembly->GetVersion(&wMajor, &wMinor, NULL, NULL);
-    hr = LoadRegTypeLibWithFlags(guid, wMajor, wMinor, flags, &pITLB);
-    if (SUCCEEDED(hr))
-        goto ErrExit;
-
-    // If that fails, try loading the highest registered version.
-    hr = LoadRegTypeLibWithFlags(guid, -1, -1, flags, &pITLB);
-    if(hr == S_OK)
-        goto ErrExit;
-
-    // If caller only wants registered typelibs, exit now, with error from prior call.
-    if (flags & TlbExporter_OnlyReferenceRegistered)
-        goto ErrExit;
-    
-    // If we haven't managed to find the typelib so far try and load the typelib by name.
-    hr = LoadTypeLibExWithFlags(szModule, flags, &pITLB);
-    if(hr == S_OK)
-    {
-        // Check libid.
-        TLIBATTR *pTlibAttr;
-        int     bMatch;
-        
-        IfFailGo(pITLB->GetLibAttr(&pTlibAttr));
-        bMatch = pTlibAttr->guid == guid;
-        pITLB->ReleaseTLibAttr(pTlibAttr);
-        
-        if (bMatch)
-        {
-            goto ErrExit;
-        }
-        else
-        {
-            SafeReleasePreemp(pITLB);
-            pITLB = NULL;
-            hr = TLBX_E_CANTLOADLIBRARY;
-        }
-    }
-
-    // Add a ".tlb" extension and try again.
-    IfFailGo(rName.ReSizeNoThrow((int)(wcslen(szModule) + 5)));
-    // Check if szModule already has an extension.
-    LPCWSTR ext;
-    size_t extSize;
-    SplitPathInterior(szModule, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, &ext, &extSize);
-    if (ext != nullptr)
-    {
-        // szModule already has an extension. Make a copy without the extension.
-        wcsncpy_s(rName.Ptr(), rName.Size(), szModule, ext - szModule);
-    }
-    else
-    {
-        // szModule does not have an extension. Copy the whole string.
-        wcscpy_s(rName.Ptr(), rName.Size(), szModule);
-    }
-    wcscat_s(rName.Ptr(), rName.Size(), W(".tlb"));
-    
-    hr = LoadTypeLibExWithFlags(rName.Ptr(), flags, &pITLB);
-    if(hr == S_OK)
-    {   
-        // Check libid.
-        TLIBATTR *pTlibAttr;
-        int     bMatch;
-        IfFailGo(pITLB->GetLibAttr(&pTlibAttr));
-        bMatch = pTlibAttr->guid == guid;
-        pITLB->ReleaseTLibAttr(pTlibAttr);
-        if (bMatch)
-        {
-            goto ErrExit;
-        }
-        else
-        {
-            SafeReleasePreemp(pITLB);
-            pITLB = NULL;
-            hr = TLBX_E_CANTLOADLIBRARY;
-        }
-    }
-
-    // If the auto create flag is set then try and export the typelib from the module.
-    if (bAutoCreate)
-    {
-        // Try to export the typelib right now.
-        // This is FTL export (Fractionally Too Late).
-        hr = ExportTypeLibFromLoadedAssemblyNoThrow(pAssembly, 0, &pITLB, 0, flags);
-        if (FAILED(hr))
-        {
-            // If the export failed then remember it failed by setting the typelib
-            // to -1 on the assembly.
-            pAssembly->SetTypeLib((ITypeLib *)-1);
-            IfFailGo(hr);
-        }
-    }   
-
-ErrExit:
-    // If we successfully opened (or created) the typelib, cache a pointer, and return it to caller.
-    if (pITLB)
-    {
-        pAssembly->SetTypeLib(pITLB);
-        *ppTLB = pITLB;
-    }
-ReturnHR:
-    rName.Destroy();
-    return hr;
-#endif //FEATURE_CORECLR
 } // HRESULT GetITypeLibForAssembly()
 
 
@@ -2764,13 +2550,6 @@ HRESULT GetSpecialMarshaler(IMarshal* pMarsh, SimpleComCallWrapper* pSimpleWrap,
     // In case of APPX process we always use the standard marshaller.
     // In Non-APPX process use standard marshalling for everything except in-proc servers.
     // In case of CoreCLR, we always use the standard marshaller as well.
-#if !defined(FEATURE_CORECLR)
-    if (!AppX::IsAppXProcess() && (dwDestContext == MSHCTX_INPROC))
-    {
-        *ppMarshalRet = NULL;
-        return S_OK;
-    }
-#endif // !FEATURE_CORECLR
     
     SafeComHolderPreemp<IUnknown> pMarshalerObj = NULL;
     IfFailRet(CoCreateFreeThreadedMarshaler(NULL, &pMarshalerObj));
@@ -3084,49 +2863,8 @@ HRESULT __stdcall ManagedObject_GetSerializedBuffer(IManagedObject *pManaged,
     }
     CONTRACTL_END;
 
-#ifdef FEATURE_CORECLR
     _ASSERTE(!"NYI");
     return E_NOTIMPL;
-#else // FEATURE_CORECLR
-
-    HRESULT hr = S_OK;
-    if (pBStr == NULL)
-        return E_POINTER;
-
-    *pBStr = NULL;
-
-    BEGIN_EXTERNAL_ENTRYPOINT(&hr)
-    {
-        GCX_COOP_THREAD_EXISTS(GET_THREAD());
-
-        SimpleComCallWrapper *pSimpleWrap = SimpleComCallWrapper::GetWrapperFromIP( pManaged );
-        ComCallWrapper *pComCallWrap = pSimpleWrap->GetMainWrapper();
-        
-        _ASSERTE(pComCallWrap != NULL);
-        
-         //@todo don't allow serialization of Configured objects through DCOM
-        _ASSERTE(GetThread()->GetDomain()->GetId() == pSimpleWrap->GetDomainID());
-
-        BOOL fLegacyMode = (GetAppDomain()->GetComOrRemotingFlag() == COMorRemoting_LegacyMode);
-        
-        OBJECTREF oref = pComCallWrap->GetObjectRef();
-        GCPROTECT_BEGIN(oref)
-        {
-            // GetSerializedBuffer is only called in cross-runtime/cross-process scenarios so we pass
-            // fCrossRuntime=TRUE unless we are in legacy mode
-            if (!ConvertObjectToBSTR(&oref, !fLegacyMode, pBStr))
-            {
-                // ConvertObjectToBSTR returning FALSE is equivalent to throwing SerializationException
-                hr = COR_E_SERIALIZATION;
-            }
-        }
-        GCPROTECT_END();
-    }
-    END_EXTERNAL_ENTRYPOINT;    
-
-    return hr;
-
-#endif // FEATURE_CORECLR
 }
 
 //------------------------------------------------------------------------------------------
diff --git a/src/vm/stubhelpers.cpp b/src/vm/stubhelpers.cpp
index cbe1d37c94..20f76cdc5e 100644
--- a/src/vm/stubhelpers.cpp
+++ b/src/vm/stubhelpers.cpp
@@ -373,42 +373,6 @@ FORCEINLINE static void *GetCOMIPFromRCW_GetTarget(IUnknown *pUnk, ComPlusCallIn
 {
     LIMITED_METHOD_CONTRACT;
 
-#ifndef FEATURE_CORECLR
-#ifdef _TARGET_X86_
-    // m_pInterceptStub is either NULL if we never called on this method, -1 if we're not
-    // hosted, or the host hook stub if we are hosted. The stub will extract the real target
-    // from the 'this' argument.
-    PVOID pInterceptStub = VolatileLoadWithoutBarrier(&pComInfo->m_pInterceptStub);
-
-    if (pInterceptStub != (LPVOID)-1)
-    {
-        if (pInterceptStub != NULL)
-        {
-            return pInterceptStub;
-        }
-
-        if (NDirect::IsHostHookEnabled() || pComInfo->HasCopyCtorArgs())
-        {
-            return NULL;
-        }
-
-        if (!EnsureWritablePagesNoThrow(&pComInfo->m_pInterceptStub, sizeof(pComInfo->m_pInterceptStub)))
-        {
-            return NULL;
-        }
-   
-        pComInfo->m_pInterceptStub = (LPVOID)-1;
-    }
-#else // _TARGET_X86_
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES 
-    if (NDirect::IsHostHookEnabled())
-    {
-        // There's one static stub on !_TARGET_X86_.
-        return (LPVOID)GetEEFuncEntryPoint(PInvokeStubForHost);
-    }
-#endif // FEATURE_INCLUDE_ALL_INTERFACES 
-#endif // _TARGET_X86_
-#endif // FEATURE_CORECLR
 
     LPVOID *lpVtbl = *(LPVOID **)pUnk;
     return lpVtbl[pComInfo->m_cachedComSlot];
@@ -435,44 +399,6 @@ NOINLINE static IUnknown* GetCOMIPFromRCWHelper(LPVOID pFCall, OBJECTREF pSrc, M
         pRetUnk.Release();
     }
 
-#ifndef FEATURE_CORECLR
-#ifdef _TARGET_X86_
-    GCX_PREEMP();
-    Stub *pInterceptStub = NULL;
-
-    if (pComInfo->m_pInterceptStub == NULL)
-    {
-        if (pComInfo->HasCopyCtorArgs())
-        {
-            // static stub that gets its arguments in a thread-static field
-            pInterceptStub = NDirect::GetStubForCopyCtor();
-        }
-
-        if (NDirect::IsHostHookEnabled())
-        {
-            pInterceptStub = pComInfo->GenerateStubForHost(
-                pMD->GetDomain()->GetLoaderAllocator()->GetStubHeap(),
-                pInterceptStub);
-        }
-
-        EnsureWritablePages(&pComInfo->m_pInterceptStub);
-
-        if (pInterceptStub != NULL)
-        {
-            if (InterlockedCompareExchangeT(&pComInfo->m_pInterceptStub,
-                                            (LPVOID)pInterceptStub->GetEntryPoint(),
-                                            NULL) != NULL)
-            {
-                pInterceptStub->DecRef();
-            }
-        }
-        else
-        {
-            pComInfo->m_pInterceptStub = (LPVOID)-1;
-        }
-    }
-#endif // _TARGET_X86_
-#endif // !FEATURE_CORECLR
 
     *ppTarget = GetCOMIPFromRCW_GetTarget(pRetUnk, pComInfo);
     _ASSERTE(*ppTarget != NULL);
@@ -1285,109 +1211,7 @@ FCIMPL2(void*, StubHelpers::GetDelegateTarget, DelegateObject *pThisUNSAFE, UINT
 }
 FCIMPLEND
 
-#ifndef FEATURE_CORECLR // CAS
-static void DoDeclarativeActionsForPInvoke(MethodDesc* pCurrent)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        GC_TRIGGERS;
-        THROWS;
-        SO_INTOLERANT;
-    }
-    CONTRACTL_END;
-
-    MethodSecurityDescriptor MDSecDesc(pCurrent);
-    MethodSecurityDescriptor::LookupOrCreateMethodSecurityDescriptor(&MDSecDesc);
-
-    DeclActionInfo* pRuntimeDeclActionInfo = MDSecDesc.GetRuntimeDeclActionInfo();
-    if (pRuntimeDeclActionInfo != NULL)
-    {
-         // Tell the debugger not to start on any managed code that we call in this method    
-        FrameWithCookie<DebuggerSecurityCodeMarkFrame> __dbgSecFrame;
-
-        Security::DoDeclarativeActions(pCurrent, pRuntimeDeclActionInfo, NULL, &MDSecDesc);
-
-        // Pop the debugger frame
-        __dbgSecFrame.Pop();
-    }
-}
-#endif // FEATURE_CORECLR
-
-#ifndef FEATURE_CORECLR
-#ifndef _WIN64
-FCIMPL3(void*, StubHelpers::GetFinalStubTarget, LPVOID pStubArg, LPVOID pUnmngThis, DWORD dwFlags)
-{
-    CONTRACTL
-    {
-        FCALL_CHECK;
-        PRECONDITION(SF_IsForwardStub(dwFlags));
-    }
-    CONTRACTL_END;
-
-    if (SF_IsCALLIStub(dwFlags))
-    {
-        // stub argument is the target
-        return pStubArg;
-    }
-    else if (SF_IsDelegateStub(dwFlags))
-    {
-        // stub argument is not used but we pass _methodPtrAux which is the target
-        return pStubArg;
-    }
-    else if (SF_IsCOMStub(dwFlags))
-    {
-        // stub argument is a ComPlusCallMethodDesc
-        ComPlusCallMethodDesc *pCMD = (ComPlusCallMethodDesc *)pStubArg;
-        LPVOID *lpVtbl = *(LPVOID **)pUnmngThis;
-        return lpVtbl[pCMD->m_pComPlusCallInfo->m_cachedComSlot];
-    }
-    else // P/Invoke
-    {
-        // secret stub argument is an NDirectMethodDesc
-        NDirectMethodDesc *pNMD = (NDirectMethodDesc *)pStubArg;
-        return pNMD->GetNativeNDirectTarget();
-    }
-}
-FCIMPLEND
-#endif // !_WIN64
-
-FCIMPL1(void, StubHelpers::DemandPermission, NDirectMethodDesc *pNMD)
-{
-    FCALL_CONTRACT;
 
-    // ETWOnStartup (SecurityCatchCall, SecurityCatchCallEnd); // this is messing up HMF below
-
-    if (pNMD != NULL)
-    {
-        g_IBCLogger.LogMethodDescAccess(pNMD);
-
-        if (pNMD->IsInterceptedForDeclSecurity())
-        {
-            if (pNMD->IsInterceptedForDeclSecurityCASDemandsOnly() &&
-                SecurityStackWalk::HasFlagsOrFullyTrusted(1 << SECURITY_UNMANAGED_CODE))
-            {
-                // Track perfmon counters. Runtime security checks.
-                Security::IncrementSecurityPerfCounter();
-            }
-            else
-            {
-                HELPER_METHOD_FRAME_BEGIN_0();
-                DoDeclarativeActionsForPInvoke(pNMD);
-                HELPER_METHOD_FRAME_END();
-            }
-        }
-    }
-    else
-    {
-        // This is either CLR->COM or delegate P/Invoke (we don't call this helper for CALLI).
-        HELPER_METHOD_FRAME_BEGIN_0();
-        SecurityStackWalk::SpecialDemand(SSWT_DECLARATIVE_DEMAND, SECURITY_UNMANAGED_CODE);
-        HELPER_METHOD_FRAME_END();
-    }
-}
-FCIMPLEND
-#endif // !FEATURE_CORECLR
 
 FCIMPL2(void, StubHelpers::ThrowInteropParamException, UINT resID, UINT paramIdx)
 {
diff --git a/src/vm/stubhelpers.h b/src/vm/stubhelpers.h
index b64d2868d8..f7577d7a44 100644
--- a/src/vm/stubhelpers.h
+++ b/src/vm/stubhelpers.h
@@ -95,12 +95,6 @@ public:
     static FCDECL1(void*,           GetNDirectTarget,       NDirectMethodDesc* pNMD);
     static FCDECL2(void*,           GetDelegateTarget,      DelegateObject *pThisUNSAFE, UINT_PTR *ppStubArg);
 
-#ifndef FEATURE_CORECLR
-#ifndef _WIN64
-    static FCDECL3(void*,           GetFinalStubTarget, LPVOID pStubArg, LPVOID pUnmngThis, DWORD dwFlags);
-#endif // !_WIN64
-    static FCDECL1(void,            DemandPermission, NDirectMethodDesc *pNMD);
-#endif // !FEATURE_CORECLR
 
     static FCDECL2(void,            ThrowInteropParamException, UINT resID, UINT paramIdx);
     static FCDECL1(Object*,         GetHRExceptionObject,   HRESULT hr);
diff --git a/src/vm/syncblk.cpp b/src/vm/syncblk.cpp
index 171a8d3bb7..826507e535 100644
--- a/src/vm/syncblk.cpp
+++ b/src/vm/syncblk.cpp
@@ -3298,10 +3298,6 @@ bool AwareLock::Contention(INT32 timeOut)
 
     COUNTER_ONLY(GetPerfCounters().m_LocksAndThreads.cContention++);
 
-#ifndef FEATURE_CORECLR
-    // Fire a contention start event for a managed contention
-    FireEtwContentionStart_V1(ETW::ContentionLog::ContentionStructs::ManagedContention, GetClrInstanceId());
-#endif // !FEATURE_CORECLR
 
     LogContention();
     Thread      *pCurThread = GetThread();
@@ -3406,9 +3402,6 @@ entered: ;
         Enter();
         bEntered = TRUE;
     }
-#ifndef FEATURE_CORECLR
-    FireEtwContentionStop(ETW::ContentionLog::ContentionStructs::ManagedContention, GetClrInstanceId());
-#endif // !FEATURE_CORECLR
     return bEntered;
 }
 
diff --git a/src/vm/synchronizationcontextnative.cpp b/src/vm/synchronizationcontextnative.cpp
index 4c37b75c73..ac67f39349 100644
--- a/src/vm/synchronizationcontextnative.cpp
+++ b/src/vm/synchronizationcontextnative.cpp
@@ -20,7 +20,6 @@
 #endif
 #include "synchronizationcontextnative.h"
 
-#ifdef FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
 FCIMPL3(DWORD, SynchronizationContextNative::WaitHelper, PTRArray *handleArrayUNSAFE, CLR_BOOL waitAll, DWORD millis)
 {
     FCALL_CONTRACT;
@@ -46,7 +45,6 @@ FCIMPL3(DWORD, SynchronizationContextNative::WaitHelper, PTRArray *handleArrayUN
     return ret;
 }
 FCIMPLEND
-#endif // #ifdef FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
     
 #ifdef FEATURE_APPX
 
diff --git a/src/vm/synchronizationcontextnative.h b/src/vm/synchronizationcontextnative.h
index ebbcc2faf9..917d3a0afb 100644
--- a/src/vm/synchronizationcontextnative.h
+++ b/src/vm/synchronizationcontextnative.h
@@ -19,9 +19,7 @@ class SynchronizationContextNative
 {
 public:    
 
-#ifdef FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
     static FCDECL3(DWORD, WaitHelper, PTRArray *handleArrayUNSAFE, CLR_BOOL waitAll, DWORD millis);
-#endif
 
 #ifdef FEATURE_APPX
     static void* QCALLTYPE GetWinRTDispatcherForCurrentThread();
diff --git a/src/vm/threads.cpp b/src/vm/threads.cpp
index 392b262673..81bf023568 100644
--- a/src/vm/threads.cpp
+++ b/src/vm/threads.cpp
@@ -31,15 +31,11 @@
 #include "appdomainstack.inl"
 #include "eventtrace.h"
 #ifdef FEATURE_REMOTING
-#include "appdomainhelper.h"
 #endif
 #include "comutilnative.h"
 #include "finalizerthread.h"
 #include "threadsuspend.h"
 
-#ifdef FEATURE_FUSION
-#include "fusion.h"
-#endif
 #include "wrappers.h"
 
 #include "nativeoverlapped.h"
@@ -72,7 +68,6 @@ CLREvent *ThreadStore::s_pWaitForStackCrawlEvent;
 
 #ifndef DACCESS_COMPILE
 
-#include "constrainedexecutionregion.h"
 
 
 BOOL Thread::s_fCleanFinalizedThread = FALSE;
@@ -612,14 +607,6 @@ void Thread::ChooseThreadCPUGroupAffinity()
     if (!CPUGroupInfo::CanEnableGCCPUGroups() || !CPUGroupInfo::CanEnableThreadUseAllCpuGroups()) 
          return;
 
-#ifndef FEATURE_CORECLR
-    // We only handle the non-hosted case here. If CLR is hosted, the hosting 
-    // process controls the physical OS Threads. If CLR is not hosted, we can 
-    // set thread group affinity on OS threads directly.
-    HostComHolder<IHostTask> pHostTask (GetHostTaskWithAddRef());
-    if (pHostTask != NULL)
-        return;
-#endif //!FEATURE_CORECLR
 
     //Borrow the ThreadStore Lock here: Lock ThreadStore before distributing threads
     ThreadStoreLockHolder TSLockHolder(TRUE);
@@ -652,14 +639,6 @@ void Thread::ClearThreadCPUGroupAffinity()
     if (!CPUGroupInfo::CanEnableGCCPUGroups() || !CPUGroupInfo::CanEnableThreadUseAllCpuGroups()) 
          return;
 
-#ifndef FEATURE_CORECLR
-    // We only handle the non-hosted case here. If CLR is hosted, the hosting 
-    // process controls the physical OS Threads. If CLR is not hosted, we can 
-    // set thread group affinity on OS threads directly.
-    HostComHolder<IHostTask> pHostTask (GetHostTaskWithAddRef());
-    if (pHostTask != NULL)
-        return;
-#endif //!FEATURE_CORECLR
 
     ThreadStoreLockHolder TSLockHolder(TRUE);
 
@@ -1919,11 +1898,6 @@ Thread::Thread()
 
     m_dwLockCount = 0;
     m_dwBeginLockCount = 0;
-#ifndef FEATURE_CORECLR
-    m_dwBeginCriticalRegionCount = 0;
-    m_dwCriticalRegionCount = 0;
-    m_dwThreadAffinityCount = 0;
-#endif // !FEATURE_CORECLR
 
 #ifdef _DEBUG
     dbg_m_cSuspendedThreads = 0;
@@ -2898,106 +2872,6 @@ HANDLE Thread::CreateUtilityThread(Thread::StackSizeBucket stackSizeBucket, LPTH
     return hThread;
 }
 
-#ifndef FEATURE_CORECLR
-/*
-    The following are copied from MSDN:
-        http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dllproc/base/thread_stack_size.asp
-
-    To change the initially committed stack space, use the dwStackSize parameter of the CreateThread,
-    CreateRemoteThread, or CreateFiber function. This value is rounded up to the nearest page.
-    Generally, the reserve size is the default reserve size specified in the executable header.
-    However, if the initially committed size specified by dwStackSize is larger than the default reserve size,
-    the reserve size is this new commit size rounded up to the nearest multiple of 1 MB.
-
-    To change the reserved stack size, set the dwCreationFlags parameter of CreateThread or CreateRemoteThread
-    to STACK_SIZE_PARAM_IS_A_RESERVATION and use the dwStackSize parameter. In this case, the initially
-    committed size is the default size specified in the executable header.
-
-*/
-BOOL Thread::CheckThreadStackSize(SIZE_T *pSizeToCommitOrReserve,
-                                  BOOL   isSizeToReserve    // When TRUE, the previous argument is the stack size to reserve.
-                                                            // Otherwise, it is the size to commit.
-                                 )
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    //g_SystemInfo is global pointer to SYSTEM_INFO struct
-    SIZE_T dwAllocSize = (SIZE_T)g_SystemInfo.dwAllocationGranularity;
-    SIZE_T dwPageSize = (SIZE_T)g_SystemInfo.dwPageSize;
-
-    //Don't want users creating threads
-    //     with a stackSize request < 256K
-    //This value may change up or down as we see fit so don't doc to user
-    //
-    if(isSizeToReserve && 0x40000 > (*pSizeToCommitOrReserve))
-    {
-        *pSizeToCommitOrReserve = 0x40000;
-    }
-
-    *pSizeToCommitOrReserve = ALIGN(*pSizeToCommitOrReserve, dwAllocSize);
-
-    //
-    // Let's get the stack sizes from the PE file that started process.
-    //
-    SIZE_T ExeSizeOfStackReserve = 0;
-    SIZE_T ExeSizeOfStackCommit = 0;
-
-    if (!GetProcessDefaultStackSize(&ExeSizeOfStackReserve, &ExeSizeOfStackCommit))
-        return FALSE;
-
-    // Now let's decide which sizes OS are going to use.
-    SIZE_T sizeToReserve = 0;
-    SIZE_T sizeToCommit  = 0;
-
-    if (isSizeToReserve) {
-        // The passed-in *pSizeToCommitOrReserve is the stack size to reserve.
-        sizeToReserve = *pSizeToCommitOrReserve;
-        // OS will use ExeSizeOfStackCommit as the commited size.
-        sizeToCommit = ExeSizeOfStackCommit;
-    }
-    else {
-        // The passed-in *pSizeToCommitOrReserve is the stack size to commit.
-        sizeToCommit  = *pSizeToCommitOrReserve;
-        // OS will use ExeSizeOfStackReserve as the reserved size.
-        sizeToReserve = ExeSizeOfStackReserve;
-
-        // However, if the initially committed size specified by dwStackSize is larger than
-        // the default reserve size, the reserve size is this new commit size rounded up to
-        // the nearest multiple of 1 MB.
-        if (sizeToCommit > ExeSizeOfStackReserve) {
-            sizeToReserve = ALIGN(sizeToCommit, 0x1000000);
-        }
-
-        if (!g_pConfig->GetDisableCommitThreadStack())
-        {
-            // We will commit the full stack when a thread starts.  But if the PageFile is full, we may hit
-            // stack overflow at random places during startup.
-            // Therefore if we are unlikely to obtain space from PageFile, we will fail creation of a thread.
-
-            *pSizeToCommitOrReserve = sizeToReserve - HARD_GUARD_REGION_SIZE;
-
-            // OS's behavior is not consistent on if guard page is marked when we ask OS to commit the stack
-            // up to 2nd to last page.
-            // On Win2k3, the 2nd to last page is marked with guard bit.
-            // On WinXP, the 2nd to last page is not marked with guard bit.
-            // To be safe, we will not commit the 2nd to last page.
-            *pSizeToCommitOrReserve -= HARD_GUARD_REGION_SIZE;
-            // To make it more interesting, on X64, if we request to commit stack except the last two pages,
-            // OS commit the whole stack, and mark the last two pages as guard page.
-            *pSizeToCommitOrReserve -= 2*HARD_GUARD_REGION_SIZE;
-        }
-    }
-
-    // Ok, we now know what sizes OS will use to create the thread.
-    // Check to see if we have the room for guard pages.
-    return ThreadWillCreateGuardPage(sizeToReserve, sizeToCommit);
-}
-#endif // FEATURE_CORECLR
 
 BOOL Thread::GetProcessDefaultStackSize(SIZE_T* reserveSize, SIZE_T* commitSize)
 {
@@ -3059,31 +2933,16 @@ BOOL Thread::CreateNewOSThread(SIZE_T sizeToCommitOrReserve, LPTHREAD_START_ROUT
     HANDLE  h = NULL;
     DWORD dwCreationFlags = CREATE_SUSPENDED;
 
-#ifdef FEATURE_CORECLR
-    dwCreationFlags |=  STACK_SIZE_PARAM_IS_A_RESERVATION;
-#else
-    if(sizeToCommitOrReserve != 0)
-    {
-        dwCreationFlags |=  STACK_SIZE_PARAM_IS_A_RESERVATION;
+    dwCreationFlags |= STACK_SIZE_PARAM_IS_A_RESERVATION;
 
-        //
-        // In this case we also force CommitThreadStack to commit the whole stack, even if we're configured not to do so.
-        // The config value is used to reduce the resource usage for default stack allocations; for non-default allocations,
-        // we assume the user has given us the correct size (and they're really going to need it).  This way we don't
-        // need to offer a Thread constructor that takes a confusing "stack size param is a commit size" parameter.
-        //
-        SetThreadStateNC(TSNC_ForceStackCommit);
-    }
-
-    // Check that we will have (reserved and never committed) guard pages at the end of the stack.
-    // If this call returns false then it will lead to an OOM exception on return.
-    // This is reasonable since a large stack was requested and we couldn't get it.
-    if(!CheckThreadStackSize(&sizeToCommitOrReserve, 
-        (sizeToCommitOrReserve != 0)))
+#ifndef FEATURE_PAL // the PAL does its own adjustments as necessary
+    if (sizeToCommitOrReserve != 0 && sizeToCommitOrReserve <= OS_PAGE_SIZE)
     {
-        return FALSE;
+        // On Windows, passing a value that is <= one page size bizarrely causes the OS to use the default stack size instead of
+        // a minimum, which is undesirable. This adjustment fixes that issue to use a minimum stack size (typically 64 KB).
+        sizeToCommitOrReserve = OS_PAGE_SIZE + 1;
     }
-#endif
+#endif // !FEATURE_PAL
 
     intermediateThreadParam* lpThreadArgs = new (nothrow) intermediateThreadParam;
     if (lpThreadArgs == NULL)
@@ -4227,10 +4086,6 @@ DWORD MsgWaitHelper(int numWaiters, HANDLE* phEvent, BOOL bWaitAll, DWORD millis
         // So on CoreCLR (where FEATURE_COMINTEROP is not currently defined) we can actually reach this point.
         // We can't fix this, because it's a breaking change, so we just won't assert here.
         // The result is that WaitAll on an STA thread in CoreCLR will behave stragely, as described above.
-#if defined(FEATURE_COMINTEROP) && !defined(FEATURE_CORECLR)
-        else
-            _ASSERTE(!"WaitAll in an STA with more than one handle will deadlock");
-#endif
     }
 
     if (bWaitAll)
@@ -4381,7 +4236,6 @@ DWORD Thread::DoAppropriateWaitWorker(int countHandles, HANDLE *handles, BOOL wa
     DWORD ret = 0;
 
     BOOL alertable = (mode & WaitMode_Alertable) != 0;
-#ifdef FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
     // Waits from SynchronizationContext.WaitHelper are always just WaitMode_IgnoreSyncCtx.
     // So if we defer to a sync ctx, we will lose any extra bits.  We must therefore not
     // defer to a sync ctx if doing any non-default wait.  
@@ -4423,7 +4277,6 @@ DWORD Thread::DoAppropriateWaitWorker(int countHandles, HANDLE *handles, BOOL wa
         if (fSyncCtxPresent)
             return ret;
     }
-#endif // #ifdef FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
 
     // Before going to pre-emptive mode the thread needs to be flagged as waiting for
     // the debugger. This used to be accomplished by the TS_Interruptible flag but that
@@ -4847,7 +4700,6 @@ WaitCompleted:
 }
 #endif // !FEATURE_PAL
 
-#ifdef FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
 DWORD Thread::DoSyncContextWait(OBJECTREF *pSyncCtxObj, int countHandles, HANDLE *handles, BOOL waitAll, DWORD millis)
 {
     CONTRACTL
@@ -4877,7 +4729,6 @@ DWORD Thread::DoSyncContextWait(OBJECTREF *pSyncCtxObj, int countHandles, HANDLE
     
     return invokeWaitMethodHelper.Call_RetI4(args);
 }
-#endif // #ifdef FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
 
 // Called out of SyncBlock::Wait() to block this thread until the Notify occurs.
 BOOL Thread::Block(INT32 timeOut, PendingSync *syncState)
@@ -7316,11 +7167,25 @@ BOOL Thread::SetStackLimits(SetStackLimitScope scope)
             return FALSE;
         }
 
-        // Compute the limit used by EnsureSufficientExecutionStack and cache it on the thread. The limit
-        // is currently set at 50% of the stack, which should be sufficient to allow the average Framework
-        // function to run, and to allow us to throw and dispatch an exception up a reasonable call chain.
-        m_CacheStackSufficientExecutionLimit = reinterpret_cast<UINT_PTR>(m_CacheStackBase) - 
-            (reinterpret_cast<UINT_PTR>(m_CacheStackBase) - reinterpret_cast<UINT_PTR>(m_CacheStackLimit)) / 2;
+        // Compute the limit used by EnsureSufficientExecutionStack and cache it on the thread. This minimum stack size should
+        // be sufficient to allow a typical non-recursive call chain to execute, including potential exception handling and
+        // garbage collection. Used for probing for available stack space through RuntimeImports.EnsureSufficientExecutionStack,
+        // among other things.
+#ifdef BIT64
+        const UINT_PTR MinExecutionStackSize = 128 * 1024;
+#else // !BIT64
+        const UINT_PTR MinExecutionStackSize = 64 * 1024;
+#endif // BIT64
+        _ASSERTE(m_CacheStackBase >= m_CacheStackLimit);
+        if ((reinterpret_cast<UINT_PTR>(m_CacheStackBase) - reinterpret_cast<UINT_PTR>(m_CacheStackLimit)) >
+            MinExecutionStackSize)
+        {
+            m_CacheStackSufficientExecutionLimit = reinterpret_cast<UINT_PTR>(m_CacheStackLimit) + MinExecutionStackSize;
+        }
+        else
+        {
+            m_CacheStackSufficientExecutionLimit = reinterpret_cast<UINT_PTR>(m_CacheStackBase);
+        }
     }
 
     // Ensure that we've setup the stack guarantee properly before we cache the stack limits
@@ -7684,81 +7549,6 @@ __declspec(noinline) void AllocateSomeStack(){
 BOOL Thread::CommitThreadStack(Thread* pThreadOptional)
 {
 
-#ifndef FEATURE_CORECLR
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    if (FAILED(CLRSetThreadStackGuarantee(STSGuarantee_Force)))
-        return FALSE;
-
-    if (g_pConfig->GetDisableCommitThreadStack() && (pThreadOptional == NULL || !pThreadOptional->HasThreadStateNC(TSNC_ForceStackCommit)))
-        return TRUE;
-
-
-    // This is a temporary fix for VSWhidbey 259155.  In CommitThreadStack() we determine the bounds of the
-    // region between the guard page and the hard guard region for a thread's stack and then commit that
-    // region.  Sometimes we cross a page boundary while calculating the bounds or doing the commit (in
-    // VirtualQuery or VirtualAlloc), such that the guard page is moved after we've already gotten it's
-    // location.  When that happens we commit too many pages and destroy the guard page.  To fix this we
-    // do a small stack allocation that ensures that we have enough stack space for all of the
-    // CommitThreadStack() work
-
-    AllocateSomeStack();
-
-    // Grab the info about the first region of the stack. First, we grab the region where we are now (&tmpMBI),
-    // then we use the allocation base of that to grab the first region.
-    MEMORY_BASIC_INFORMATION tmpMBI;
-    SIZE_T dwRes;
-
-    dwRes = ClrVirtualQuery((const void *)&tmpMBI, &tmpMBI, sizeof(MEMORY_BASIC_INFORMATION));
-
-    if (sizeof(MEMORY_BASIC_INFORMATION) != dwRes)
-    {
-        return FALSE;
-    }
-
-    dwRes = ClrVirtualQuery((const void *)((BYTE*)tmpMBI.AllocationBase + HARD_GUARD_REGION_SIZE), &tmpMBI, sizeof(MEMORY_BASIC_INFORMATION));
-
-    if (sizeof(MEMORY_BASIC_INFORMATION) != dwRes)
-    {
-        return FALSE;
-    }
-
-    // We commit the reserved part of the stack, if necessary, minus one page for the "hard" guard page.
-    if (tmpMBI.State == MEM_RESERVE)
-    {
-        // Note: we leave the "hard" guard region uncommitted.
-        void *base = (BYTE*)tmpMBI.AllocationBase + HARD_GUARD_REGION_SIZE;
-
-        // We are committing a page on stack.  If we call host for this operation,
-        // host needs to avoid adding it to the memory consumption.  Therefore
-        // we call into OS directly.
-#undef VirtualAlloc
-        void *p = VirtualAlloc(base,
-                               tmpMBI.RegionSize,
-                               MEM_COMMIT,
-                               PAGE_READWRITE);
-#define VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect) \
-        Dont_Use_VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect)
-
-        if (p != base )
-        {
-            DWORD err = GetLastError();
-            STRESS_LOG2(LF_EH, LL_ALWAYS,
-                        "Thread::CommitThreadStack: failed to commit stack for TID 0x%x with error 0x%x\n",
-                        ::GetCurrentThreadId(), err);
-
-            return FALSE;
-        }
-    }
-
-    INDEBUG(DebugLogStackMBIs());
-
-#endif 
     return TRUE;
 }
 
@@ -8779,10 +8569,6 @@ void Thread::EnterContextRestricted(Context *pContext, ContextTransitionFrame *p
     {
         pFrame->SetLockCount(m_dwBeginLockCount);
         m_dwBeginLockCount = m_dwLockCount;
-#ifndef FEATURE_CORECLR
-        pFrame->SetCriticalRegionCount(m_dwBeginCriticalRegionCount);
-        m_dwBeginCriticalRegionCount = m_dwCriticalRegionCount;
-#endif // !FEATURE_CORECLR
     }
 
     if (m_Context == pContext) {
@@ -8826,22 +8612,6 @@ void Thread::EnterContextRestricted(Context *pContext, ContextTransitionFrame *p
         PushDomain(pDomain->GetId());
         STRESS_LOG1(LF_APPDOMAIN, LL_INFO100000, "Entering into ADID=%d\n", pDomain->GetId().m_dwId);
 
-#ifndef FEATURE_CORECLR
-        //
-        // Push execution contexts (that could contain call context) into frame to avoid leaks
-        //
-
-        if (IsExposedObjectSet())
-        {
-            THREADBASEREF ref = (THREADBASEREF) ObjectFromHandle(m_ExposedObject);
-            _ASSERTE(ref != NULL);
-            if (ref->GetExecutionContext() != NULL)
-            {
-                pFrame->SetReturnExecutionContext(ref->GetExecutionContext());
-                ref->SetExecutionContext(NULL);
-            }
-        }
-#endif //!FEATURE_CORECLR
 
         //
         // Store the last thrown object in the ContextTransitionFrame before we null it out
@@ -8966,10 +8736,6 @@ void Thread::ReturnToContext(ContextTransitionFrame *pFrame)
 
         m_dwLockCount = m_dwBeginLockCount;
         m_dwBeginLockCount = pFrame->GetLockCount();
-#ifndef FEATURE_CORECLR
-        m_dwCriticalRegionCount = m_dwBeginCriticalRegionCount;
-        m_dwBeginCriticalRegionCount = pFrame->GetCriticalRegionCount();
-#endif // !FEATURE_CORECLR
 
     }
 
@@ -9045,18 +8811,6 @@ void Thread::ReturnToContext(ContextTransitionFrame *pFrame)
 
     if (fChangedDomains)
     {
-#ifndef FEATURE_CORECLR
-        //
-        // Pop execution contexts (could contain call context) from frame if applicable
-        //
-
-        if (IsExposedObjectSet())
-        {
-            THREADBASEREF ref = (THREADBASEREF) ObjectFromHandle(m_ExposedObject);
-            _ASSERTE(ref != NULL);
-            ref->SetExecutionContext(pFrame->GetReturnExecutionContext());
-        }
-#endif //!FEATURE_CORECLR
 
         // Do this last so that thread is not labeled as out of the domain until all cleanup is done.
         ADID adid=pCurrentDomain->GetId();
@@ -9169,11 +8923,9 @@ void Thread::RaiseCrossContextExceptionHelper(Exception* pEx, ContextTransitionF
     // Ensure that IP for WatsonBucketing has been collected if the exception is preallocated.
 #ifdef _DEBUG
 
-#ifdef FEATURE_CORECLR
     // On CoreCLR, Watson may not be enabled. Thus, we should
     // skip this.
     if (IsWatsonEnabled())
-#endif // FEATURE_CORECLR
     {
         if (CLRException::IsPreallocatedExceptionObject(CLRException::GetThrowableFromException(pEx)))
         {
@@ -9468,11 +9220,7 @@ void DECLSPEC_NORETURN Thread::RaiseCrossContextException(Exception* pExOrig, Co
             switch (kind)
             {
             case kLastException:
-#ifdef FEATURE_CORECLR
                 gc.pMarshaledThrowable = gc.orBlob;
-#else
-                AppDomainHelper::UnmarshalObject(GetAppDomain(), &gc.orBlob, &gc.pMarshaledThrowable);
-#endif //FEATURE_CORECLR
 
                 break;
             case kOutOfMemoryException:
@@ -10202,7 +9950,6 @@ static LONG ThreadBaseRedirectingFilter(PEXCEPTION_POINTERS pExceptionInfo, LPVO
     {
         _ASSERTE(flags == MTCSF_NormalBase);
 
-#ifdef FEATURE_CORECLR
         if(!IsSingleAppDomain())
         {
             // This assert shouldnt be hit in CoreCLR since:
@@ -10216,11 +9963,9 @@ static LONG ThreadBaseRedirectingFilter(PEXCEPTION_POINTERS pExceptionInfo, LPVO
             // So, if this is hit, something is not right!
             _ASSERTE(!"How come a managed thread in CoreCLR has suffered unhandled exception in DefaultDomain?");
         }
-#endif // FEATURE_CORECLR
 
         LOG((LF_EH, LL_INFO100, "ThreadBaseRedirectingFilter: setting TSNC_ProcessedUnhandledException\n"));
 
-#if defined(FEATURE_CORECLR)
         //
         // In the default domain, when an exception goes unhandled on a managed thread whose threadbase is in the VM (e.g. explicitly spawned threads, 
         //    ThreadPool threads, finalizer thread, etc), CLR can end up in the unhandled exception processing path twice.
@@ -10248,7 +9993,6 @@ static LONG ThreadBaseRedirectingFilter(PEXCEPTION_POINTERS pExceptionInfo, LPVO
         // will fail to honor the host policy (e.g. swallow unhandled exception). Thus, the 2nd unhandled exception may end up crashing the app when it should not.
         //
         if (IsSingleAppDomain() && (ret != EXCEPTION_EXECUTE_HANDLER))
-#endif // defined(FEATURE_CORECLR)
         {
             // Since we have already done unhandled exception processing for it, we dont want it 
             // to happen again if our UEF gets invoked upon returning back to the OS.
@@ -10298,9 +10042,7 @@ static void ManagedThreadBase_DispatchOuter(ManagedThreadCallState *pCallState)
         TryParam *pTryParam;
         Thread *pThread;
 
-#ifdef FEATURE_CORECLR
         BOOL *pfHadException; 
-#endif // FEATURE_CORECLR
 
 #ifdef WIN64EXCEPTIONS
         Frame *pFrame;
@@ -10310,10 +10052,8 @@ static void ManagedThreadBase_DispatchOuter(ManagedThreadCallState *pCallState)
     args.pTryParam = &param;
     args.pThread = pThread;
 
-#ifdef FEATURE_CORECLR
     BOOL fHadException = TRUE;
     args.pfHadException = &fHadException;
-#endif // FEATURE_CORECLR
 
 #ifdef WIN64EXCEPTIONS
     args.pFrame = pFrame;
@@ -10345,13 +10085,10 @@ static void ManagedThreadBase_DispatchOuter(ManagedThreadCallState *pCallState)
         }
         PAL_ENDTRY;
 
-#ifdef FEATURE_CORECLR
         *(pArgs->pfHadException) = FALSE;
-#endif // FEATURE_CORECLR
     }
     PAL_FINALLY
     {
-#ifdef FEATURE_CORECLR
         // If we had a breakpoint exception that has gone unhandled,
         // then switch to the correct AD context. Its fine to do this
         // here because:
@@ -10363,7 +10100,6 @@ static void ManagedThreadBase_DispatchOuter(ManagedThreadCallState *pCallState)
         {
             ReturnToPreviousAppDomain();
         }
-#endif // FEATURE_CORECLR
         catchFrame.Pop();
     }
     PAL_ENDTRY;
@@ -11697,13 +11433,6 @@ void Thread::InternalReset(BOOL fFull, BOOL fNotFinalizerThread, BOOL fThreadObj
         FullResetThread();
     }
 
-#ifndef FEATURE_CORECLR
-    _ASSERTE (m_dwCriticalRegionCount == 0);
-    m_dwCriticalRegionCount = 0;
-
-    _ASSERTE (m_dwThreadAffinityCount == 0);
-    m_dwThreadAffinityCount = 0;
-#endif // !FEATURE_CORECLR
 
     //m_MarshalAlloc.Collapse(NULL);
 
@@ -11827,9 +11556,6 @@ HRESULT Thread::Reset(BOOL fFull)
 
         ResetThreadStateNC(TSNC_UnbalancedLocks);
         m_dwLockCount = 0;
-#ifndef FEATURE_CORECLR
-        m_dwCriticalRegionCount = 0;
-#endif // !FEATURE_CORECLR
 
     InternalSwitchOut();
     m_OSThreadId = SWITCHED_OUT_FIBER_OSID;
@@ -12204,9 +11930,6 @@ HRESULT Thread::LocksHeld(SIZE_T *pLockCount)
     LIMITED_METHOD_CONTRACT;
 
     *pLockCount = m_dwLockCount;
-#ifndef FEATURE_CORECLR
-    *pLockCount += m_dwCriticalRegionCount;
-#endif // !FEATURE_CORECLR
     return S_OK;
 }
 
@@ -12800,37 +12523,6 @@ void Thread::BeginThreadAffinity()
 {
     LIMITED_METHOD_CONTRACT;
 
-#ifndef FEATURE_CORECLR
-    if (!CLRTaskHosted())
-    {
-        return;
-    }
-
-    if (IsGCSpecialThread() || IsDbgHelperSpecialThread())
-    {
-        return;
-    }
-
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES
-    IHostTaskManager *pManager = CorHost2::GetHostTaskManager();
-
-    HRESULT hr;
-
-    BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread());
-    hr = pManager->BeginThreadAffinity();
-    END_SO_TOLERANT_CODE_CALLING_HOST;
-    _ASSERTE (hr == S_OK);
-    Thread *pThread = GetThread();
-
-    if (pThread)
-    {
-        pThread->IncThreadAffinityCount();
-#ifdef _DEBUG
-        pThread->AddFiberInfo(Thread::ThreadTrackInfo_Affinity);
-#endif
-    }
-#endif // FEATURE_INCLUDE_ALL_INTERFACES
-#endif // !FEATURE_CORECLR
 }
 
 
@@ -12839,40 +12531,6 @@ void Thread::EndThreadAffinity()
 {
     LIMITED_METHOD_CONTRACT;
 
-#ifndef FEATURE_CORECLR
-    if (!CLRTaskHosted())
-    {
-        return;
-    }
-
-    if (IsGCSpecialThread() || IsDbgHelperSpecialThread())
-    {
-        return;
-    }
-
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES
-    IHostTaskManager *pManager = CorHost2::GetHostTaskManager();
-#endif // FEATURE_INCLUDE_ALL_INTERFACES
-
-    Thread *pThread = GetThread();
-    if (pThread)
-    {
-        pThread->DecThreadAffinityCount ();
-#ifdef _DEBUG
-        pThread->AddFiberInfo(Thread::ThreadTrackInfo_Affinity);
-#endif
-    }
-
-#ifdef FEATURE_INCLUDE_ALL_INTERFACES
-    HRESULT hr = S_OK;
-
-    BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread());
-    hr = pManager->EndThreadAffinity();
-    END_SO_TOLERANT_CODE_CALLING_HOST;
-
-    _ASSERTE (hr == S_OK);
-#endif // FEATURE_INCLUDE_ALL_INTERFACES
-#endif // !FEATURE_CORECLR
 }
 
 void Thread::SetupThreadForHost()
diff --git a/src/vm/threads.h b/src/vm/threads.h
index 51116e1ad6..d461b09ca4 100644
--- a/src/vm/threads.h
+++ b/src/vm/threads.h
@@ -585,12 +585,7 @@ inline Thread* GetThreadNULLOk()
 #endif
 
 //***************************************************************************
-#if defined(_DEBUG) && defined(_TARGET_X86_) && !defined(FEATURE_CORECLR)
- #define HAS_TRACK_CXX_EXCEPTION_CODE_HACK 1
- #define TRACK_CXX_EXCEPTION_CODE_HACK
-#else
  #define HAS_TRACK_CXX_EXCEPTION_CODE_HACK 0
-#endif
 
 // manifest constant for waiting in the exposed classlibs
 const INT32 INFINITE_TIMEOUT = -1;
@@ -1274,9 +1269,7 @@ public:
                                                       // effort.
                                                       // 
                                                       // Once we are completely independent of the OS UEF, we could remove this.
-#ifdef FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
         TSNC_InsideSyncContextWait      = 0x02000000, // Whether we are inside DoSyncContextWait
-#endif // FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
         TSNC_DebuggerSleepWaitJoin      = 0x04000000, // Indicates to the debugger that this thread is in a sleep wait or join state
                                                       // This almost mirrors the TS_Interruptible state however that flag can change
                                                       // during GC-preemptive mode whereas this one cannot.
@@ -1641,13 +1634,6 @@ public:
     // in the object header to store it.
     DWORD                m_ThreadId;
 
-    #if HAS_TRACK_CXX_EXCEPTION_CODE_HACK // do we have C++ exception code tracking?
-        // It's very hard to deal with SEH properly using C++ catch handlers.  The
-        // following field is updated with the correct SEH exception whenever a C++
-        // __CxxFrameHandler3 call is made on this thread.  If you grab it at the
-        // top of a C++ catch(...), it's likely to be correct.
-        DWORD               m_LastCxxSEHExceptionCode;
-    #endif // HAS_TRACK_CXX_EXCEPTION_CODE_HACK
 
     // RWLock state
     LockEntry           *m_pHead;
@@ -1790,12 +1776,6 @@ public:
 
 private:
     DWORD m_dwBeginLockCount;  // lock count when the thread enters current domain
-#ifndef FEATURE_CORECLR
-    DWORD m_dwBeginCriticalRegionCount;  // lock count when the thread enters current domain
-    DWORD m_dwCriticalRegionCount;
-
-    DWORD m_dwThreadAffinityCount;
-#endif // !FEATURE_CORECLR
 
 #ifdef _DEBUG
     DWORD dbg_m_cSuspendedThreads;
@@ -1888,68 +1868,19 @@ public:
         LIMITED_METHOD_CONTRACT;
 
         _ASSERTE(m_dwLockCount >= m_dwBeginLockCount);
-#ifndef FEATURE_CORECLR
-        _ASSERTE(m_dwCriticalRegionCount >= m_dwBeginCriticalRegionCount);
-#endif // !FEATURE_CORECLR
 
         // Equivalent to (m_dwLockCount != m_dwBeginLockCount ||
         //                m_dwCriticalRegionCount ! m_dwBeginCriticalRegionCount),
         // but without branching instructions
         BOOL fHasLock = (m_dwLockCount ^ m_dwBeginLockCount);
-#ifndef FEATURE_CORECLR
-        fHasLock |= (m_dwCriticalRegionCount ^ m_dwBeginCriticalRegionCount);
-#endif // !FEATURE_CORECLR
 
         return fHasLock; 
     }
-#ifndef FEATURE_CORECLR
-    inline void BeginCriticalRegion()
-    {
-        LIMITED_METHOD_CONTRACT;
-        _ASSERTE (GetThread() == this);
-        if (CLRHosted())
-        {
-            m_dwCriticalRegionCount ++;
-            _ASSERTE (m_dwCriticalRegionCount != 0);
-        }
-    }
-
-    inline void EndCriticalRegion()
-    {
-        LIMITED_METHOD_CONTRACT;
-        _ASSERTE (GetThread() == this);
-        if (CLRHosted())
-        {
-            _ASSERTE (m_dwCriticalRegionCount > 0);
-            m_dwCriticalRegionCount --;
-        }
-    }
-
-    inline void BeginCriticalRegion_NoCheck()
-    {
-        LIMITED_METHOD_CONTRACT;
-        _ASSERTE (GetThread() == this);
-        m_dwCriticalRegionCount ++;
-        _ASSERTE (m_dwCriticalRegionCount != 0);
-    }
-
-    inline void EndCriticalRegion_NoCheck()
-    {
-        LIMITED_METHOD_CONTRACT;
-        _ASSERTE (GetThread() == this);
-        _ASSERTE (m_dwCriticalRegionCount > 0);
-        m_dwCriticalRegionCount --;
-    }
-#endif // !FEATURE_CORECLR
 
     inline BOOL HasCriticalRegion()
     {
         LIMITED_METHOD_CONTRACT;
-#ifndef FEATURE_CORECLR
-        return m_dwCriticalRegionCount != 0;
-#else 
         return FALSE;        
-#endif
     }
 
     inline DWORD GetNewHashCode()
@@ -2000,45 +1931,11 @@ public:
     static void BeginThreadAffinity();
     static void EndThreadAffinity();
 
-#ifndef FEATURE_CORECLR
-    inline void IncThreadAffinityCount()
-    {
-        LIMITED_METHOD_CONTRACT;
-        _ASSERTE (GetThread() == this);
-        m_dwThreadAffinityCount++;
-        _ASSERTE (m_dwThreadAffinityCount > 0);
-    }
-    inline void DecThreadAffinityCount()
-    {
-        LIMITED_METHOD_CONTRACT;
-        _ASSERTE (GetThread() == this);
-        _ASSERTE (m_dwThreadAffinityCount > 0);
-        m_dwThreadAffinityCount --;
-    }
-
-    static void BeginThreadAffinityAndCriticalRegion()
-    {
-        LIMITED_METHOD_CONTRACT;
-        BeginThreadAffinity();
-        GetThread()->BeginCriticalRegion();
-    }
-
-    static void EndThreadAffinityAndCriticalRegion()
-    {
-        LIMITED_METHOD_CONTRACT;
-        GetThread()->EndCriticalRegion();
-        EndThreadAffinity();
-    }
-#endif // !FEATURE_CORECLR
 
     BOOL HasThreadAffinity()
     {
         LIMITED_METHOD_CONTRACT;
-#ifndef FEATURE_CORECLR
-        return m_dwThreadAffinityCount > 0;
-#else
         return FALSE;
-#endif
     }
 
  private:
@@ -2636,11 +2533,7 @@ private:
     //
     // In Telesto, we don't support true appdomain marshaling so the "orBlob" is in fact an
     // agile wrapper object whose ToString() echoes the original exception's ToString().
-#ifdef FEATURE_CORECLR
     typedef OBJECTREF  ORBLOBREF;
-#else
-    typedef U1ARRAYREF ORBLOBREF;
-#endif
 
     RaiseCrossContextResult TryRaiseCrossContextException(Exception **ppExOrig,
                                                           Exception *pException,
@@ -2797,7 +2690,6 @@ public:
         return (ObjectFromHandle(m_ExposedObject) != NULL) ;
     }
 
-#ifdef FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
     void GetSynchronizationContext(OBJECTREF *pSyncContextObj)
     {
         CONTRACTL
@@ -2815,24 +2707,7 @@ public:
         if (ExposedThreadObj != NULL)
             *pSyncContextObj = ExposedThreadObj->GetSynchronizationContext();
     }
-#endif // FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
 
-#ifdef FEATURE_COMPRESSEDSTACK    
-    OBJECTREF GetCompressedStack()
-    {
-        CONTRACTL
-        {
-            MODE_COOPERATIVE;
-            GC_NOTRIGGER;
-            NOTHROW;
-        }
-        CONTRACTL_END;
-        THREADBASEREF ExposedThreadObj = (THREADBASEREF)GetExposedObjectRaw();
-        if (ExposedThreadObj != NULL)
-            return (OBJECTREF)(ExposedThreadObj->GetCompressedStack());
-        return NULL;
-    }
-#endif // #ifdef FEATURE_COMPRESSEDSTACK
 
     // When we create a managed thread, the thread is suspended.  We call StartThread to get
     // the thread start.
@@ -3007,10 +2882,6 @@ public:
     static bool    SysStartSuspendForDebug(AppDomain *pAppDomain);
     static bool    SysSweepThreadsForDebug(bool forceSync);
     static void    SysResumeFromDebug(AppDomain *pAppDomain);
-#ifndef FEATURE_CORECLR
-    void           UserSuspendThread();
-    BOOL           UserResumeThread();
-#endif // FEATURE_CORECLR
 
     void           UserSleep(INT32 time);
 
@@ -3515,9 +3386,7 @@ private:
     DWORD          DoSignalAndWaitWorker(HANDLE* pHandles, DWORD millis,BOOL alertable);
 #endif // !FEATURE_PAL
     DWORD          DoAppropriateAptStateWait(int numWaiters, HANDLE* pHandles, BOOL bWaitAll, DWORD timeout, WaitMode mode);
-#ifdef FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
     DWORD          DoSyncContextWait(OBJECTREF *pSyncCtxObj, int countHandles, HANDLE *handles, BOOL waitAll, DWORD millis);
-#endif // #ifdef FEATURE_SYNCHRONIZATIONCONTEXT_WAIT
 public:
 
     //************************************************************************
@@ -3615,10 +3484,12 @@ public:
     static PCODE VirtualUnwindCallFrame(T_CONTEXT* pContext, T_KNONVOLATILE_CONTEXT_POINTERS* pContextPointers = NULL,
                                            EECodeInfo * pCodeInfo = NULL);
     static UINT_PTR VirtualUnwindCallFrame(PREGDISPLAY pRD, EECodeInfo * pCodeInfo = NULL);
+#ifndef DACCESS_COMPILE
     static PCODE VirtualUnwindLeafCallFrame(T_CONTEXT* pContext);
     static PCODE VirtualUnwindNonLeafCallFrame(T_CONTEXT* pContext, T_KNONVOLATILE_CONTEXT_POINTERS* pContextPointers = NULL,
         PT_RUNTIME_FUNCTION pFunctionEntry = NULL, UINT_PTR uImageBase = NULL);
     static UINT_PTR VirtualUnwindToFirstManagedCallFrame(T_CONTEXT* pContext);
+#endif // DACCESS_COMPILE
 #endif // WIN64EXCEPTIONS
 
     // During a <clinit>, this thread must not be asynchronously
@@ -3981,9 +3852,6 @@ private:
 
     // For getting a thread to a safe point.  A client waits on the event, which is
     // set by the thread when it reaches a safe spot.
-#ifndef FEATURE_CORECLR
-    void    FinishSuspendingThread();
-#endif // FEATURE_CORECLR
     void    SetSafeEvent();
 
 public:
@@ -5603,10 +5471,6 @@ public:
 
 LCID GetThreadCultureIdNoThrow(Thread *pThread, BOOL bUICulture);
 
-#ifndef FEATURE_CORECLR
-// Request/Remove Thread Affinity for the current thread
-typedef StateHolder<Thread::BeginThreadAffinityAndCriticalRegion, Thread::EndThreadAffinityAndCriticalRegion> ThreadAffinityAndCriticalRegionHolder;
-#endif // !FEATURE_CORECLR
 typedef StateHolder<Thread::BeginThreadAffinity, Thread::EndThreadAffinity> ThreadAffinityHolder;
 
 typedef Thread::ForbidSuspendThreadHolder ForbidSuspendThreadHolder;
diff --git a/src/vm/threadsuspend.cpp b/src/vm/threadsuspend.cpp
index 0c8314d295..dd8bb48df9 100644
--- a/src/vm/threadsuspend.cpp
+++ b/src/vm/threadsuspend.cpp
@@ -754,29 +754,6 @@ static StackWalkAction TAStackCrawlCallBackWorker(CrawlFrame* pCf, StackCrawlCon
     }
     #undef METHODNAME
 
-#ifdef FEATURE_CER
-    // If we're asking about CERs and we don't yet have a definite answer either way then take a closer look at the current method.
-    if (pData->eType & StackCrawlContext::SCC_CheckWithinCer && !pData->fUnprotectedCode && !pData->fWithinCer)
-    {
-        // Check for CER root methods (these are never inlined). If we've found one of these at the root of a bunch of potential CER
-        // methods (i.e. those with a compatible reliability contract) then we're executing in a CER.
-        if (IsCerRootMethod(pMD))
-            pData->fWithinCer = true;
-
-        // Only need to look deeper if we couldn't decide if we're in a CER yet.
-        if (!pData->fWithinCer)
-        {
-            // IL stubs are transparent to CERs.
-            if (!pMD->IsILStub())
-                // Check for reliability contracts on the method (and class and assembly). If it's high enough level to be included
-                // in a CER then we can continue (hopefully finding a CER root method further down the stack). Otherwise we've got
-                // at least one method that's not part of a CER on the top of the stack so we're definitely not executing within a
-                // CER.
-                if (CheckForReliabilityContract(pMD) < RCL_BASIC_CONTRACT)
-                    pData->fUnprotectedCode = true;
-        }
-    }
-#endif // FEATURE_CER
 
     // If we weren't asked about EH clauses then we can return now (stop the stack trace if we have a definitive answer on the CER
     // question, move to the next frame otherwise).
@@ -816,7 +793,7 @@ static StackWalkAction TAStackCrawlCallBackWorker(CrawlFrame* pCf, StackCrawlCon
     EE_ILEXCEPTION_CLAUSE EHClause;
 
     StackWalkAction action = SWA_CONTINUE;
-#ifdef _TARGET_X86_
+#ifndef WIN64EXCEPTIONS
     // On X86, the EH encoding for catch clause is completely mess.
     // If catch clause is in its own basic block, the end of catch includes everything in the basic block.
     // For nested catch, the end of catch may include several jmp instructions after JIT_EndCatch call.
@@ -830,7 +807,7 @@ static StackWalkAction TAStackCrawlCallBackWorker(CrawlFrame* pCf, StackCrawlCon
         fAtJitEndCatch = TRUE;
         offs -= 1;
     }
-#endif  // _TARGET_X86_
+#endif  // !WIN64EXCEPTIONS
 
 #if _TARGET_AMD64_ 
     STRESS_LOG1(LF_EH, LL_INFO10, "AMD64 - in TAStackCrawlCallBack 0x%x offset\n", offs);
@@ -898,7 +875,7 @@ static StackWalkAction TAStackCrawlCallBackWorker(CrawlFrame* pCf, StackCrawlCon
         if (offs >= EHClause.HandlerStartPC &&
             offs < EHClause.HandlerEndPC)
         {
-#ifdef _TARGET_X86_
+#ifndef WIN64EXCEPTIONS
             if (fAtJitEndCatch)
             {
                 // On X86, JIT's EH info may include the instruction after JIT_EndCatch inside the same catch
@@ -911,7 +888,7 @@ static StackWalkAction TAStackCrawlCallBackWorker(CrawlFrame* pCf, StackCrawlCon
                     continue;
                 }
             }
-#endif
+#endif // !WIN64EXCEPTIONS
             pData->fWithinEHClause = true;
             // We're within an EH clause. If we're asking about CERs too then stop the stack walk if we've reached a conclusive
             // result or continue looking otherwise. Else we can stop the stackwalk now.
@@ -927,14 +904,14 @@ static StackWalkAction TAStackCrawlCallBackWorker(CrawlFrame* pCf, StackCrawlCon
     }
     }
 
-#ifdef _TARGET_X86_
+#ifndef WIN64EXCEPTIONS
 #ifdef _DEBUG
     if (fAtJitEndCatch)
     {
         _ASSERTE (countInCatch > 0);
     }
 #endif   // _DEBUG
-#endif   // _TARGET_X86_
+#endif   // !WIN64EXCEPTIONS_
     return action;
 }
 
@@ -1124,50 +1101,6 @@ struct CerStackCrawlContext
     bool        m_fWithinCer;           // The result
 };
 
-#ifdef FEATURE_CER
-// Callback used on the stack crawl described above.
-StackWalkAction CerStackCrawlCallBack(CrawlFrame *pCf, void *pData)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    CerStackCrawlContext *pCtx = (CerStackCrawlContext *)pData;
-
-    // Skip initial frame which should be our target.
-    if (pCtx->m_fFirstFrame)
-    {
-        _ASSERTE(pCtx->m_pStartMethod == pCf->GetFunction());
-        pCtx->m_fFirstFrame = false;
-        return SWA_CONTINUE;
-    }
-
-    // If we get this far we've located the target method and are scanning the calling tree to see if we have a chain of methods
-    // marked with strong reliability contracts terminated by a CER root method.
-    MethodDesc *pMD = pCf->GetFunction();
-    _ASSERTE(pMD != NULL);
-
-    // If the current method is the root of a CER then we can say the target method was executing in a CER and terminate the stack
-    // walk.
-    // @TODO: Need to be more specific than this: only certain areas of the root method are actually in the CER.
-    if (IsCerRootMethod(pMD))
-    {
-        pCtx->m_fWithinCer = true;
-        return SWA_ABORT;
-    }
-
-    // Now look at reliability contracts on the current method. If they're missing or very weak then the chain is broken and the
-    // target method cannot possibly be in a CER.
-    if (CheckForReliabilityContract(pMD) < RCL_BASIC_CONTRACT)
-        return SWA_ABORT;
-
-    // Otherwise everything looks OK so far and we need to investigate the next frame.
-    return SWA_CONTINUE;
-}
-#endif // FEATURE_CER
 
 // Determine whether the method at the given depth in the thread's execution stack is executing within a CER.
 BOOL Thread::IsWithinCer(CrawlFrame *pCf)
@@ -1179,126 +1112,7 @@ BOOL Thread::IsWithinCer(CrawlFrame *pCf)
     }
     CONTRACTL_END;
 
-#ifndef FEATURE_CER
     return FALSE;
-#else
-    // There had better be a method associated with this frame.
-    MethodDesc *pMD = pCf->GetFunction();
-    _ASSERTE(pMD != NULL);
-
-    // Try the cheap checks first (before resorting to an actual stackwalk).
-
-    // Handle IL stubs specially. We get called for these guys and they always appear to have a strong reliability contract (due to
-    // the System.StubHelpers class they're placed in) but the stack walking logic we have below will skip them (messing up our
-    // accounting). For simplicitly and speed we'll just always say these guys are in a CER (we trust the code and it won't block
-    // indefinitely so it's a safe guess).
-    if (pMD->IsILStub())
-        return TRUE;
-
-    // If the method is itself the root of a CER then we say yes immediately.
-    // @TODO: Need to be more specific than this: only certain areas of the root method are actually in the CER.
-    if (IsCerRootMethod(pMD))
-        return TRUE;
-
-    // Now look at reliability contracts on the method. If they're missing or very weak then this method cannot possibly be in a
-    // CER.
-    if (CheckForReliabilityContract(pMD) < RCL_BASIC_CONTRACT)
-        return FALSE;
-
-    // No way around it: this method has a good reliability contract but is not the root of a CER. We'll have to have to walk the
-    // stack to determine whether it was called from a good root.
-
-    // Now things get really tricky. We want to perform a recursive stackwalk (we're called as part of an ongoing stackwalk and we
-    // wish to recursively look at one or more of the callers of the current frame).
-    //
-    // On x86 this is relatively straightforward -- we make a copy of the current crawl frame context (since walking the stack
-    // updates the context) and build a new regdisplay around it. We can then start a new crawl from that context (ignoring the
-    // first frame of course, because that's this frame).
-    //
-    // 64-bit is trickier because the context provided by the OS might not be (from our point of view) a valid current context. In
-    // particular IA64 provides a mostly valid context except that the SP is from the caller. AMD64 on the other hand will always
-    // provide a consistent context, but it may belong to either the current or caller frame. As noted above though, we're really
-    // not all that interested in the current context, so as long as we can get to a consistent caller context we're happy.
-    //
-    // So for AMD64 we'll either have a complete current context and we'll use the the x86 algorithm or we have a complete caller
-    // context and we can use more or less the x86 algorithm except we don't need to skip the first frame on the stackwalk callback.
-    //
-    // IA64 is trickier since it doesn't always give us a consistent context (current or caller). Here we'll have to bite the bullet
-    // and perform a full stackwalk to build the context we're after. We'll use a combination of the caller SP and the current BSP
-    // as a discriminator (to determine when the full stackwalk has synchronized with this frame and the real walk can begin, it's
-    // the same discriminator the OS uses).
-    //
-    // <REVISIT_TODO> We will want to try and cache the context we eventually arrive at from this stack walk, since we're likely to see
-    // further calls to IsWithinCer further down the stack and we can use the end context as a much faster way to sync to a valid
-    // context in those cases. The chief technical difficulty there is cache management since the OS is handling the actual
-    // exception walk (so we're not sure when to invalidate our cached data, which presumably we'd store on the Thread). Look into
-    // hooking into the ExceptionTracker mechanism for this.</REVISIT_TODO>
-
-    REGDISPLAY *pCurrentRd = pCf->GetRegisterSet();
-    REGDISPLAY  rd;
-    CONTEXT     ctx;
-    CerStackCrawlContext sContext = { pMD, true, false };
-
-#if defined(_TARGET_AMD64_) || defined(_TARGET_ARM_)
-    // This check is similar to the one in ExceptionTracker::InitializeCrawlFrame. 
-    //
-    // However, on ARM, we can easily check if we have the caller context (or not) by 
-    // checking the IsCallerContextValid field of RegDisplay, which is set during
-    // the first pass of exception dispatch since the OS always passes us the caller
-    // context in that scenario (refer to ExceptionTracker::InitializeCrawlFrame
-    // implementation for details).
-    if (ARM_ONLY(pCurrentRd->IsCallerContextValid) NOT_ARM(GetControlPC(pCurrentRd) != GetIP(pCurrentRd->pCurrentContext)))
-    {
-        // This is the case on AMD64, or ARM, where the OS has handed us the caller context. Build a regdisplay around that (pretending that
-        // it's the current context) and reset our first frame flag so the stack walk we're about to do thinks we've already
-        // processed the current frame.
-        ctx = *pCurrentRd->pCallerContext;
-        FillRegDisplay(&rd, &ctx);
-        sContext.m_fFirstFrame = false;
-    }
-    else
-#endif // defined(_TARGET_AMD64_) || defined(_TARGET_ARM_)
-    {
-        // On x86, ARM or AMD64, where the OS gave us the current context, we just copy that into a new regdisplay (our stackwalking
-        // callback will skip the first (current) frame for us).
-        CopyRegDisplay(pCurrentRd, &rd, &ctx);
-    }
-
-    // The stackwalker requires a starting frame as input. If we're currently inspecting an explicit frame then it's easy -- we just
-    // pass that. Otherwise (we're on some frameless managed method) we look at all of the frames for the current thread and choose
-    // the one that would synchronize us for walking to the next frame.
-    Frame *pFrame;
-    if (pCf->IsFrameless())
-    {
-#if defined(_TARGET_X86_)
-        TADDR limitSP = GetRegdisplaySP(&rd);
-#else
-        TADDR limitSP = (TADDR)( EECodeManager::GetCallerSp(&rd) );
-#endif
-        pFrame = GetFrame();
-        while (pFrame && (TADDR)(pFrame) < limitSP)
-            pFrame = pFrame->Next();
-    }
-    else
-    {
-        pFrame = pCf->GetFrame();
-
-#ifdef _TARGET_X86_
-        if (pFrame->GetVTablePtr() == InlinedCallFrame::GetMethodFrameVPtr())
-        {
-            // If we walk from an ICF, the function will not be reported again because X86 stack walker handles managed stack frame
-            // before explicit frames contained in it.
-            sContext.m_fFirstFrame = false;
-        }
-#endif // _TARGET_X86_
-    }
-
-    StackWalkFramesEx(&rd, CerStackCrawlCallBack, &sContext, QUICKUNWIND | FUNCTIONSONLY, pFrame);
-
-    _ASSERTE(!sContext.m_fFirstFrame);
-
-    return sContext.m_fWithinCer;
-#endif // FEATURE_CER
 }
 
 #if defined(_TARGET_AMD64_) && defined(FEATURE_HIJACK)
@@ -3328,32 +3142,6 @@ void Thread::RareDisablePreemptiveGC()
 #endif // PROFILING_SUPPORTED
 
 
-#if !defined(FEATURE_CORECLR) // simple hosting
-                    // First, check to see if there's an IDbgThreadControl interface that needs
-                    // notification of the suspension
-                    if (m_State & TS_DebugSuspendPending)
-                    {
-                        IDebuggerThreadControl *pDbgThreadControl = CorHost::GetDebuggerThreadControl();
-
-                        if (pDbgThreadControl)
-                            pDbgThreadControl->ThreadIsBlockingForDebugger();
-
-                    }
-
-                    if (CLRGCHosted())
-                    {
-                        BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread());
-                        CorHost2::GetHostGCManager()->ThreadIsBlockingForSuspension();
-                        END_SO_TOLERANT_CODE_CALLING_HOST;
-                    }
-
-                    // If not, check to see if there's an IGCThreadControl interface that needs
-                    // notification of the suspension
-                    IGCThreadControl *pGCThreadControl = CorHost::GetGCThreadControl();
-
-                    if (pGCThreadControl)
-                        pGCThreadControl->ThreadIsBlockingForSuspension();
-#endif // !defined(FEATURE_CORECLR)
 
                     DWORD status = S_OK;
                     SetThreadStateNC(TSNC_WaitUntilGCFinished);
@@ -3453,32 +3241,6 @@ void Thread::RareDisablePreemptiveGC()
 #endif // PROFILING_SUPPORTED
 
 
-#if !defined(FEATURE_CORECLR) // simple hosting
-        // First, check to see if there's an IDbgThreadControl interface that needs
-        // notification of the suspension
-        if (m_State & TS_DebugSuspendPending)
-        {
-            IDebuggerThreadControl *pDbgThreadControl = CorHost::GetDebuggerThreadControl();
-
-            if (pDbgThreadControl)
-                pDbgThreadControl->ThreadIsBlockingForDebugger();
-
-        }
-
-        if (CLRGCHosted())
-        {
-            BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread());
-            CorHost2::GetHostGCManager()->ThreadIsBlockingForSuspension();
-            END_SO_TOLERANT_CODE_CALLING_HOST;
-        }
-
-        // If not, check to see if there's an IGCThreadControl interface that needs
-        // notification of the suspension
-        IGCThreadControl *pGCThreadControl = CorHost::GetGCThreadControl();
-
-        if (pGCThreadControl)
-            pGCThreadControl->ThreadIsBlockingForSuspension();
-#endif // !defined(FEATURE_CORECLR)
 
         // The thread is blocked for shutdown.  We do not concern for GC violation.
         CONTRACT_VIOLATION(GCViolation);
@@ -3819,34 +3581,12 @@ void Thread::RareEnablePreemptiveGC()
             // Life's much simpler this way...
 
 
-#if !defined(FEATURE_CORECLR) // simple hosting
-            // Check to see if there's an IDbgThreadControl interface that needs
-            // notification of the suspension
-            if (m_State & TS_DebugSuspendPending)
-            {
-                IDebuggerThreadControl *pDbgThreadControl = CorHost::GetDebuggerThreadControl();
-
-                if (pDbgThreadControl)
-                    pDbgThreadControl->ThreadIsBlockingForDebugger();
-
-            }
-#endif // !defined(FEATURE_CORECLR)
 #endif // DEBUGGING_SUPPORTED
 
 #ifdef LOGGING
-#if !defined(FEATURE_CORECLR) // simple hosting
-            if (!CorHost::IsDebuggerSpecialThread(GetThreadId()))
-#endif // !defined(FEATURE_CORECLR)
             {
                 LOG((LF_CORDB, LL_INFO1000, "[0x%x] SUSPEND: suspended while enabling gc.\n", GetThreadId()));
             }
-#if !defined(FEATURE_CORECLR) // simple hosting
-            else
-            {
-                LOG((LF_CORDB, LL_INFO1000,
-                     "[0x%x] ALERT: debugger special thread did not suspend while enabling gc.\n", GetThreadId()));
-            }
-#endif // !defined(FEATURE_CORECLR)
 #endif
 
             WaitSuspendEvents(); // sets bits, too
@@ -4186,20 +3926,8 @@ void __stdcall Thread::RedirectedHandledJITCase(RedirectReason reason)
             // Notify the interface of the pending suspension
             switch (reason) {
             case RedirectReason_GCSuspension:
-#if !defined(FEATURE_CORECLR) // simple hosting
-                if (CorHost::GetGCThreadControl())
-                    CorHost::GetGCThreadControl()->ThreadIsBlockingForSuspension();
-                if (CLRGCHosted())
-                {
-                    NotifyHostOnGCSuspension();
-                }
-#endif // !defined(FEATURE_CORECLR)
                 break;
             case RedirectReason_DebugSuspension:
-#if !defined(FEATURE_CORECLR) // simple hosting
-                if (CorHost::GetDebuggerThreadControl() && CorHost::IsDebuggerSpecialThread(pThread->GetThreadId()))
-                    CorHost::GetDebuggerThreadControl()->ThreadIsBlockingForDebugger();
-#endif // !defined(FEATURE_CORECLR)
                 break;
             case RedirectReason_UserSuspension:
                 // Do nothing;
@@ -4857,21 +4585,6 @@ HRESULT ThreadSuspend::SuspendRuntime(ThreadSuspend::SUSPEND_REASON reason)
 
     STRESS_LOG1(LF_SYNC, LL_INFO1000, "Thread::SuspendRuntime(reason=0x%x)\n", reason);
 
-#if !defined(FEATURE_CORECLR) // simple hosting
-    // Alert the host that a GC is starting, in case the host is scheduling threads
-    // for non-runtime tasks during GC.
-    IGCThreadControl    *pGCThreadControl = CorHost::GetGCThreadControl();
-
-    if (pGCThreadControl)
-        pGCThreadControl->SuspensionStarting();
-
-    if (CLRGCHosted())
-    {
-        BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread());
-        CorHost2::GetHostGCManager()->SuspensionStarting();
-        END_SO_TOLERANT_CODE_CALLING_HOST;
-    }
-#endif // !defined(FEATURE_CORECLR)
 
 #ifdef PROFILING_SUPPORTED
     // If the profiler desires information about GCs, then let it know that one
@@ -5562,33 +5275,6 @@ void ThreadSuspend::ResumeRuntime(BOOL bFinishedGC, BOOL SuspendSucceded)
     // Notify everyone who cares, that this suspension is over, and this thread is going to go do other things.
     //
 
-#if !defined(FEATURE_CORECLR) // simple hosting
-    // Alert the host that a GC is ending, in case the host is scheduling threads
-    // for non-runtime tasks during GC.
-    IGCThreadControl    *pGCThreadControl = CorHost::GetGCThreadControl();
-
-    if (pGCThreadControl)
-    {
-        // If we the suspension was for a GC, tell the host what generation GC.
-        DWORD   Generation = (bFinishedGC
-                              ? GCHeapUtilities::GetGCHeap()->GetCondemnedGeneration()
-                              : ~0U);
-
-        pGCThreadControl->SuspensionEnding(Generation);
-    }
-
-    if (CLRGCHosted())
-    {
-        // If we the suspension was for a GC, tell the host what generation GC.
-        DWORD   Generation = (bFinishedGC
-                              ? GCHeapUtilities::GetGCHeap()->GetCondemnedGeneration()
-                              : ~0U);
-
-        BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread());
-        CorHost2::GetHostGCManager()->SuspensionEnding(Generation);
-        END_SO_TOLERANT_CODE_CALLING_HOST;
-    }
-#endif // !defined(FEATURE_CORECLR)
 
 #ifdef PROFILING_SUPPORTED
     // Need to give resume event for the GC thread
@@ -5961,13 +5647,6 @@ bool Thread::SysStartSuspendForDebug(AppDomain *pAppDomain)
     // Caller is expected to be holding the ThreadStore lock
     _ASSERTE(ThreadStore::HoldingThreadStore() || IsAtProcessExit());
 
-#if !defined(FEATURE_CORECLR) // simple hosting
-    // If there is a debugging thread control object, tell it we're suspending the Runtime.
-    IDebuggerThreadControl *pDbgThreadControl = CorHost::GetDebuggerThreadControl();
-
-    if (pDbgThreadControl)
-        pDbgThreadControl->StartBlockingForDebugger(0);
-#endif // !defined(FEATURE_CORECLR)
 
     // NOTE::NOTE::NOTE::NOTE::NOTE
     // This function has parallel logic in SuspendRuntime.  Please make
@@ -6341,16 +6020,6 @@ void Thread::SysResumeFromDebug(AppDomain *pAppDomain)
 
     LOG((LF_CORDB, LL_INFO1000, "RESUME: starting resume AD:0x%x.\n", pAppDomain));
 
-#if !defined(FEATURE_CORECLR) // simple hosting
-    // Notify the client that it should release any threads that it had doing work
-    // while the runtime was debugger-suspended.
-    IDebuggerThreadControl *pIDTC = CorHost::GetDebuggerThreadControl();
-    if (pIDTC)
-    {
-        LOG((LF_CORDB, LL_INFO1000, "RESUME: notifying IDebuggerThreadControl client.\n"));
-        pIDTC->ReleaseAllRuntimeThreads();
-    }
-#endif // !defined(FEATURE_CORECLR)
 
     // Make sure we completed the previous sync
     _ASSERTE(m_DebugWillSyncCount == -1);
@@ -6407,321 +6076,6 @@ void Thread::SysResumeFromDebug(AppDomain *pAppDomain)
     LOG((LF_CORDB, LL_INFO1000, "RESUME: resume complete. Trap count: %d\n", g_TrapReturningThreads.Load()));
 }
 
-#ifndef FEATURE_CORECLR
-
-// Suspend a thread at the system level.  We distinguish between user suspensions,
-// and system suspensions so that a VB program cannot resume a thread we have
-// suspended for GC.
-//
-// This service won't return until the suspension is complete.  This deserves some
-// explanation.  The thread is considered to be suspended if it can make no further
-// progress within the EE.  For example, a thread that has exited the EE via
-// COM Interop or N/Direct is considered suspended -- if we've arranged it so that
-// the thread cannot return back to the EE without blocking.
-void Thread::UserSuspendThread()
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-
-    // Read the general comments on thread suspension earlier, to understand why we
-    // take these locks.
-
-    // GC can occur in here:
-    STRESS_LOG0(LF_SYNC, LL_INFO100, "UserSuspendThread obtain lock\n");
-    ThreadStoreLockHolder tsl;
-
-    // User suspensions (e.g. from VB and C#) are distinguished from internal
-    // suspensions so a poorly behaved program cannot resume a thread that the system
-    // has suspended for GC.
-    if (m_State & TS_UserSuspendPending)
-    {
-        // This thread is already experiencing a user suspension, so ignore the
-        // new request.
-        _ASSERTE(!ThreadStore::HoldingThreadStore(this));
-    }
-    else
-    if (this != GetThread())
-    {
-        // First suspension of a thread other than the current one.
-        if (m_State & TS_Unstarted)
-        {
-            // There is an important window in here.  T1 can call T2.Start() and then
-            // T2.Suspend().  Suspend is disallowed on an unstarted thread.  But from T1's
-            // point of view, T2 is started.  In reality, T2 hasn't been scheduled by the
-            // OS, so it is still an unstarted thread.  We don't want to perform a normal
-            // suspension on it in this case, because it is currently contributing to the
-            // PendingThreadCount.  We want to get it fully started before we suspend it.
-            // This is particularly important if its background status is changing
-            // underneath us because otherwise we might not detect that the process should
-            // be exited at the right time.
-            //
-            // It turns out that this is a simple situation to implement.  We are holding
-            // the ThreadStoreLock.  TransferStartedThread will likewise acquire that
-            // lock.  So if we detect it, we simply set a bit telling the thread to
-            // suspend itself.  This is NOT the normal suspension request because we don't
-            // want the thread to suspend until it has fully started.
-            FastInterlockOr((ULONG *) &m_State, TS_SuspendUnstarted);
-        }
-        else if (m_State & (TS_Detached | TS_Dead))
-        {
-            return;
-        }
-        else
-        {
-            // We just want to trap this thread if it comes back into cooperative mode
-            SetupForSuspension(TS_UserSuspendPending);
-            m_SafeEvent.Reset();
-
-            // Pause it so we can operate on it without it squirming under us.
-RetrySuspension:
-            // We can not allocate memory after we suspend a thread.
-            // Otherwise, we may deadlock the process when CLR is hosted.
-            ThreadStore::AllocateOSContext();
-
-            SuspendThreadResult str = SuspendThread();
-
-            // The only safe place to suspend a thread asynchronously is if it is in
-            // fully interruptible cooperative JIT code.  Preemptive mode can hold all
-            // kinds of locks that make it unsafe to suspend.  All other cases are
-            // handled somewhat synchronously (e.g. through hijacks, GC mode toggles, etc.)
-            //
-            // For example, on a SMP if the thread is blocked waiting for the ThreadStore
-            // lock, it can cause a deadlock if we suspend it (even though it is in
-            // preemptive mode).
-            //
-            // If a thread is in preemptive mode (including the tricky optimized N/Direct
-            // case), we can just mark it for suspension.  It will make no further progress
-            // in the EE.
-            if (str == STR_NoStressLog)
-            {
-                // We annot assume anything about the thread's current state.
-                goto RetrySuspension;
-            }
-            else if (!m_fPreemptiveGCDisabled)
-            {
-                MarkForSuspension(TS_UserSuspendPending);
-
-                // Let the thread run until it reaches a safe spot.
-                if (str == STR_Success)
-                {
-                    ResumeThread();
-                }
-            }
-            else if (str == STR_Failure || str == STR_UnstartedOrDead)
-            {
-                // The thread cannot be unstarted, as we have already
-                // checked for that above.
-                _ASSERTE(!(m_State & TS_Unstarted));
-
-                // Nothing to do if the thread has already terminated.
-            }
-            else if (str == STR_SwitchedOut)
-            {
-                goto RetrySuspension;
-            }
-            else
-            {
-                _ASSERTE(str == STR_Success);
-#if defined(FEATURE_HIJACK) && !defined(PLATFORM_UNIX)
-                WorkingOnThreadContextHolder workingOnThreadContext(this);
-                if (workingOnThreadContext.Acquired() && HandledJITCase())
-                {
-                    _ASSERTE(m_fPreemptiveGCDisabled);
-                    // Redirect thread so we can capture a good thread context
-                    // (GetThreadContext is not sufficient, due to an OS bug).
-                    // If we don't succeed (should only happen on Win9X, due to
-                    // a different OS bug), we must resume the thread and try
-                    // again.
-                    if (!CheckForAndDoRedirectForUserSuspend())
-                    {
-                        ResumeThread();
-                        goto RetrySuspension;
-                    }
-                }
-#endif // FEATURE_HIJACK && !PLATFORM_UNIX
-
-                // Thread is executing in cooperative mode.  We're going to have to
-                // move it to a safe spot.
-                MarkForSuspension(TS_UserSuspendPending);
-
-                // Let the thread run until it reaches a safe spot.
-                ResumeThread();
-
-                // wait until it leaves cooperative GC mode or is JIT suspended
-                FinishSuspendingThread();
-            }
-        }
-    }
-    else
-    {
-        GCX_PREEMP();
-        SetupForSuspension(TS_UserSuspendPending);
-        MarkForSuspension(TS_UserSuspendPending);
-
-        // prepare to block ourselves
-        tsl.Release();
-        _ASSERTE(!ThreadStore::HoldingThreadStore(this));
-
-        WaitSuspendEvents();
-    }
-}
-
-
-// if the only suspension of this thread is user imposed, resume it.  But don't
-// resume from any system suspensions (like GC).
-BOOL Thread::UserResumeThread()
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-
-    // If we are attempting to resume when we aren't in a user suspension,
-    // its an error.
-    BOOL    res = FALSE;
-
-    // Note that the model does not count.  In other words, you can call Thread.Suspend()
-    // five times and Thread.Resume() once.  The result is that the thread resumes.
-
-    STRESS_LOG0(LF_SYNC, INFO3, "UserResumeThread obtain lock\n");
-    ThreadStoreLockHolder TSLockHolder;
-
-    // If we have marked a thread for suspension, while that thread is still starting
-    // up, simply remove the bit to resume it.
-    if (m_State & TS_SuspendUnstarted)
-    {
-        _ASSERTE((m_State & TS_UserSuspendPending) == 0);
-        FastInterlockAnd((ULONG *) &m_State, ~TS_SuspendUnstarted);
-        res = TRUE;
-    }
-
-    // If we are still trying to suspend the thread, forget about it.
-    if (m_State & TS_UserSuspendPending)
-    {
-        ReleaseFromSuspension(TS_UserSuspendPending);
-        SetSafeEvent();
-        res = TRUE;
-    }
-
-    return res;
-}
-
-
-// We are asynchronously trying to suspend this thread.  Stay here until we achieve
-// that goal (in fully interruptible JIT code), or the thread dies, or it leaves
-// the EE (in which case the Pending flag will cause it to synchronously suspend
-// itself later, or if the thread tells us it is going to synchronously suspend
-// itself because of hijack activity, etc.
-void Thread::FinishSuspendingThread()
-{
-    CONTRACTL {
-        NOTHROW;
-        if (GetThread()) {GC_TRIGGERS;} else {DISABLED(GC_NOTRIGGER);}
-    }
-    CONTRACTL_END;
-
-    DWORD   res;
-
-    // There are two threads of interest -- the current thread and the thread we are
-    // going to wait for.  Since the current thread is about to wait, it's important
-    // that it be in preemptive mode at this time.
-
-#if _DEBUG
-    DWORD   dbgTotalTimeout = 0;
-#endif
-
-    // Wait for us to enter the ping period, then check if we are in interruptible
-    // JIT code.
-    while (TRUE)
-    {
-        ThreadSuspend::UnlockThreadStore();
-        res = m_SafeEvent.Wait(PING_JIT_TIMEOUT,FALSE);
-        STRESS_LOG0(LF_SYNC, INFO3, "FinishSuspendingThread obtain lock\n");
-        ThreadSuspend::LockThreadStore(ThreadSuspend::SUSPEND_OTHER);
-
-        if (res == WAIT_TIMEOUT)
-        {
-#ifdef _DEBUG
-            if ((dbgTotalTimeout += PING_JIT_TIMEOUT) >= g_pConfig->SuspendDeadlockTimeout())
-            {
-                _ASSERTE(!"Timeout detected trying to synchronously suspend a thread");
-                dbgTotalTimeout = 0;
-            }
-#endif
-            // Suspend the thread and see if we are in interruptible code (placing
-            // a hijack if warranted).
-#if defined(FEATURE_HIJACK) && !defined(PLATFORM_UNIX)
-        RetrySuspension:
-#endif
-            // The thread is detached/dead.  Suspend is no op.
-            if (m_State & (TS_Detached | TS_Dead))
-            {
-                return;
-            }
-
-            // We can not allocate memory after we suspend a thread.
-            // Otherwise, we may deadlock the process when CLR is hosted.
-            ThreadStore::AllocateOSContext();
-
-            SuspendThreadResult str = SuspendThread();
-
-            if (m_fPreemptiveGCDisabled && str == STR_Success)
-            {
-#if defined(FEATURE_HIJACK) && !defined(PLATFORM_UNIX)
-                WorkingOnThreadContextHolder workingOnThreadContext(this);
-                if (workingOnThreadContext.Acquired() && HandledJITCase())
-                {
-                    _ASSERTE(m_State & TS_UserSuspendPending);
-                    // Redirect thread so we can capture a good thread context
-                    // (GetThreadContext is not sufficient, due to an OS bug).
-                    // If we don't succeed (should only happen on Win9X, due to
-                    // a different OS bug), we must resume the thread and try
-                    // again.
-                    if (!CheckForAndDoRedirectForUserSuspend())
-                    {
-                        ResumeThread();
-                        goto RetrySuspension;
-                    }
-                }
-#endif // FEATURE_HIJACK && !PLATFORM_UNIX
-                // Keep trying...
-                ResumeThread();
-            }
-            else if (!m_fPreemptiveGCDisabled)
-            {
-                // The thread has transitioned out of the EE.  It can't get back in
-                // without synchronously suspending itself.  We can now return to our
-                // caller since this thread cannot make further progress within the
-                // EE.
-                if (str == STR_Success)
-                {
-                    ResumeThread();
-                }
-                break;
-            }
-            else if (str == STR_SwitchedOut)
-            {
-                // The task has been switched out while in Cooperative GC mode.
-                // We will wait for the thread again.
-            }
-        }
-        else
-        {
-            // SafeEvent has been set so we don't need to actually suspend.  Either
-            // the thread died, or it will enter a synchronous suspension based on
-            // the UserSuspendPending bit.
-            _ASSERTE(res == WAIT_OBJECT_0);
-            _ASSERTE(!ThreadStore::HoldingThreadStore(this));
-            break;
-        }
-    }
-}
-
-#endif // FEATURE_CORECLR
 
 
 void Thread::SetSafeEvent()
@@ -7018,7 +6372,7 @@ StackWalkAction SWCB_GetExecutionState(CrawlFrame *pCF, VOID *pData)
                 // return address for hijacking.
                 if (!pES->m_IsInterruptible)
                 {
-#if defined(_TARGET_AMD64_) || defined(_TARGET_ARM_) || defined(_TARGET_ARM64_) 
+#ifdef WIN64EXCEPTIONS
                     PREGDISPLAY pRDT = pCF->GetRegisterSet();
                     _ASSERTE(pRDT != NULL);
 
@@ -7075,15 +6429,17 @@ StackWalkAction SWCB_GetExecutionState(CrawlFrame *pCF, VOID *pData)
                             // in the caller of the current non-interruptible frame.
                             pES->m_ppvRetAddrPtr = (void **) pRDT->pCallerContextPointers->Lr;
                         }
-#else
-                        pES->m_ppvRetAddrPtr = (void **) ((size_t)GetSP(pRDT->pCallerContext) - sizeof(void*));
-#endif
+#elif defined(_TARGET_X86_) || defined(_TARGET_AMD64_)
+                        pES->m_ppvRetAddrPtr = (void **) (EECodeManager::GetCallerSp(pRDT) - sizeof(void*));
+#else // _TARGET_X86_ || _TARGET_AMD64_
+                        PORTABILITY_ASSERT("Platform NYI");
+#endif // _TARGET_???_
                     }
-#else
+#else // WIN64EXCEPTIONS
                     // peel off the next frame to expose the return address on the stack
                     pES->m_FirstPass = FALSE;
                     action = SWA_CONTINUE;
-#endif // _TARGET_AMD64_ || _TARGET_ARM_ || _TARGET_ARM64_
+#endif // !WIN64EXCEPTIONS
                 }
 #endif // HIJACK_NONINTERRUPTIBLE_THREADS
             }
@@ -7112,7 +6468,7 @@ StackWalkAction SWCB_GetExecutionState(CrawlFrame *pCF, VOID *pData)
     }
     else
     {
-#ifdef _TARGET_X86_
+#if defined(_TARGET_X86_) && !defined(WIN64EXCEPTIONS)
         // Second pass, looking for the address of the return address so we can
         // hijack:
 
diff --git a/src/vm/tlbexport.cpp b/src/vm/tlbexport.cpp
deleted file mode 100644
index 01f5239620..0000000000
--- a/src/vm/tlbexport.cpp
+++ /dev/null
@@ -1,6344 +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.
-//===========================================================================
-// File: TlbExport.CPP
-//
-
-//
-// Notes: Create a TypeLib from COM+ metadata.
-//---------------------------------------------------------------------------
-
-#include "common.h"
-
-#include "comcallablewrapper.h"
-#include "field.h"
-#include "dllimport.h"
-#include "fieldmarshaler.h"
-#include "eeconfig.h"
-#include "comdelegate.h"
-#include <nsutilpriv.h>
-#include <tlbimpexp.h>
-#include <mlang.h>
-#include "tlbexport.h"
-#include "commtmemberinfomap.h"
-#include <corerror.h>
-#include "posterror.h"
-#include "typeparse.h"
-
-#if defined(VALUE_MASK)
-#undef VALUE_MASK
-#endif
-
-#include <guidfromname.h>
-#include <stgpool.h>
-#include <siginfo.hpp>
-#include <typestring.h>
-#include "perfcounters.h"
-#include "comtypelibconverter.h"
-#include "caparser.h"
-
-// Define to export an empty dispinterface for an AutoDispatch IClassX
-#define EMPTY_DISPINTERFACE_ICLASSX
-#ifndef S_USEIUNKNOWN
-#define S_USEIUNKNOWN (HRESULT)2
-#endif
-
-#if defined(_DEBUG) && defined(_TRACE)
-#define TRACE printf
-#else
-#define TRACE NullFn
-inline void NullFn(const char *pf,...) {}
-#endif
-
-#if defined(_DEBUG)
-#define IfFailReport(expr) \
-    do { if(FAILED(hr = (expr))) { DebBreakHr(hr); ReportError(hr); } } while (0)    
-#else
-#define IfFailReport(expr) \
-    do { if(FAILED(hr = (expr))) { ReportError(hr); } } while (0)    
-#endif
-
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-// This value determines whether, by default, we add the TYPEFLAG_FPROXY bit 
-//  to exported interfaces.  If the value is true, Automation proxy is the 
-//  default, and we do not set the bit.  If the value is false, no Automation
-//  proxy is the default and we DO set the bit.
-#define DEFAULT_AUTOMATION_PROXY_VALUE TRUE
-//-----------------------------------------------------------------------------                                     
-
-//*****************************************************************************
-// Constants.
-//*****************************************************************************
-static const WCHAR szRetVal[] = W("pRetVal");
-static const WCHAR szTypeLibExt[] = W(".TLB");
-
-static const WCHAR szTypeLibKeyName[] = W("TypeLib");
-static const WCHAR szClsidKeyName[] = W("CLSID");
-
-static const WCHAR szIClassX[] = W("_%ls");
-static const int cbIClassX = 1;
-static const WCHAR cIClassX = W('_');
-
-static const WCHAR szAlias[] = W("_MIDL_COMPAT_%ls");
-static const int cbAlias = lengthof(szAlias) - 1;
-static const WCHAR szParamName[] = W("p%d");
-
-static const WCHAR szGuidName[]         = W("GUID");
-
-static const CHAR szObjectClass[]       = "Object";
-static const CHAR szArrayClass[]        = "Array";
-static const CHAR szDateTimeClass[]     = "DateTime";
-static const CHAR szDecimalClass[]      = "Decimal";
-static const CHAR szGuidClass[]         = "Guid";
-static const CHAR szStringClass[]       = g_StringName;
-static const CHAR szStringBufferClass[] = g_StringBufferName;
-static const CHAR szIEnumeratorClass[]  = "IEnumerator";
-static const CHAR szColor[]             = "Color";
-
-static const char szRuntime[]       = {"System."};
-static const size_t cbRuntime       = (lengthof(szRuntime)-1);
-
-static const char szText[]          = {"System.Text."};
-static const size_t cbText          = (lengthof(szText)-1);
-
-static const char szCollections[]   = {"System.Collections."};
-static const size_t cbCollections   = (lengthof(szCollections)-1);
-
-static const char szDrawing[]       = {"System.Drawing."};
-static const size_t cbDrawing       = (lengthof(szDrawing)-1);
-
-// The length of the following string(w/o the terminator): "HKEY_CLASSES_ROOT\\CLSID\\{00000000-0000-0000-0000-000000000000}".
-static const int cCOMCLSIDRegKeyLength = 62;
-
-// The length of the following string(w/o the terminator): "{00000000-0000-0000-0000-000000000000}".
-static const int cCLSIDStrLength = 38;
-
-// {17093CC8-9BD2-11cf-AA4F-304BF89C0001}
-static const GUID GUID_TRANS_SUPPORTED     = {0x17093CC8,0x9BD2,0x11cf,{0xAA,0x4F,0x30,0x4B,0xF8,0x9C,0x00,0x01}};
-
-// {00020430-0000-0000-C000-000000000046}
-static const GUID LIBID_STDOLE2 = { 0x00020430, 0x0000, 0x0000, { 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 } };
-
-// {66504301-BE0F-101A-8BBB-00AA00300CAB}
-static const GUID GUID_OleColor = { 0x66504301, 0xBE0F, 0x101A, { 0x8B, 0xBB, 0x00, 0xAA, 0x00, 0x30, 0x0C, 0xAB } };
-
-// LIBID mscoree
-static const GUID LIBID_MSCOREE = {0x5477469e,0x83b1,0x11d2,{0x8b,0x49,0x00,0xa0,0xc9,0xb7,0xc9,0xc4}};
-
-static const char XXX_DESCRIPTION_TYPE[] = {"System.ComponentModel.DescriptionAttribute"};
-static const char XXX_ASSEMBLY_DESCRIPTION_TYPE[] = {"System.Reflection.AssemblyDescriptionAttribute"};
-
-//*****************************************************************************
-// Table to map COM+ calling conventions to TypeLib calling conventions.
-//*****************************************************************************
-CALLCONV Clr2TlbCallConv[] =
-{
-    CC_STDCALL,         //  IMAGE_CEE_CS_CALLCONV_DEFAULT   = 0x0,  
-    CC_CDECL,           //  IMAGE_CEE_CS_CALLCONV_C         = 0x1,  
-    CC_STDCALL,         //  IMAGE_CEE_CS_CALLCONV_STDCALL   = 0x2,  
-    CC_STDCALL,         //  IMAGE_CEE_CS_CALLCONV_THISCALL  = 0x3,  
-    CC_FASTCALL,        //  IMAGE_CEE_CS_CALLCONV_FASTCALL  = 0x4,  
-    CC_CDECL,           //  IMAGE_CEE_CS_CALLCONV_VARARG    = 0x5,  
-    CC_MAX              //  IMAGE_CEE_CS_CALLCONV_FIELD     = 0x6,  
-                        //  IMAGE_CEE_CS_CALLCONV_MAX       = 0x7   
-};
-
-
-
-// Forward declarations.
-extern HRESULT _FillVariant(MDDefaultValue *pMDDefaultValue, VARIANT *pvar); 
-extern HRESULT _FillMDDefaultValue(BYTE bType, void const *pValue, MDDefaultValue *pMDDefaultValue);
-
-//*****************************************************************************
-// Stolen from classlib.
-//*****************************************************************************
-double _TicksToDoubleDate(const __int64 ticks)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-    
-    const INT64     MillisPerSecond     = 1000;
-    const INT64     MillisPerDay        = MillisPerSecond * 60 * 60 * 24;
-    const INT64     TicksPerMillisecond = 10000;
-    const INT64     TicksPerSecond      = TicksPerMillisecond * 1000;
-    const INT64     TicksPerMinute      = TicksPerSecond * 60;
-    const INT64     TicksPerHour        = TicksPerMinute * 60;
-    const INT64     TicksPerDay         = TicksPerHour * 24;
-    const int       DaysPer4Years       = 365 * 4 + 1;
-    const int       DaysPer100Years     = DaysPer4Years * 25 - 1;
-    const int       DaysPer400Years     = DaysPer100Years * 4 + 1;
-    const int       DaysTo1899          = DaysPer400Years * 4 + DaysPer100Years * 3 - 367;
-    const INT64     DoubleDateOffset    = DaysTo1899 * TicksPerDay;
-    const int       DaysTo10000         = DaysPer400Years * 25 - 366;
-    const INT64     MaxMillis           = DaysTo10000 * MillisPerDay;
-    const int       DaysPerYear         = 365; // non-leap year
-    const INT64     OADateMinAsTicks    = (DaysPer100Years - DaysPerYear) * TicksPerDay;
-
-    // Returns OleAut's zero'ed date ticks.
-    if (ticks == 0)
-         return 0.0;
-         
-    if (ticks < OADateMinAsTicks)
-         return 0.0;
-
-     // Currently, our max date == OA's max date (12/31/9999), so we don't 
-     // need an overflow check in that direction.
-     __int64 millis = (ticks  - DoubleDateOffset) / TicksPerMillisecond;
-     if (millis < 0) 
-     {
-         __int64 frac = millis % MillisPerDay;
-         if (frac != 0) millis -= (MillisPerDay + frac) * 2;
-     }
-     
-     return (double)millis / MillisPerDay;
-} // double _TicksToDoubleDate()
-
-
-//*****************************************************************************
-// Get the name of a typelib or typeinfo, add it to error text.
-//*****************************************************************************
-void PostTypeLibError(
-    IUnknown    *pUnk,                  // An interface on the typeinfo.
-    HRESULT     hrT,                    // The TypeInfo error.
-    HRESULT     hrX)                    // The Exporter error.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pUnk));
-    }
-    CONTRACTL_END;
-
-    HRESULT     hr;                     // A result.
-    WCHAR       rcErr[1024];            // Buffer for error message.
-
-    SafeComHolder<ITypeInfo> pITI=0;             // The ITypeInfo * on the typeinfo.
-    SafeComHolder<ITypeLib> pITLB=0;             // The ITypeLib *.
-    BSTRHolder               name=0;             // The name of the TypeInfo.
-
-    // Try to get a name.
-    hr = SafeQueryInterface(pUnk, IID_ITypeInfo, (IUnknown**)&pITI);
-    if (SUCCEEDED(hr))
-    {
-        IfFailThrow(pITI->GetDocumentation(MEMBERID_NIL, &name, 0,0,0));
-    }
-    else
-    {
-        hr = SafeQueryInterface(pUnk, IID_ITypeLib, (IUnknown**)&pITLB);
-        if (SUCCEEDED(hr))
-            IfFailThrow(pITLB->GetDocumentation(MEMBERID_NIL, &name, 0,0,0));
-    }
-
-    if (name == NULL)
-    {
-        name = SysAllocString(W("???"));
-        if (name == NULL)
-            COMPlusThrowHR(E_OUTOFMEMORY);
-    }
-
-    // Format the typelib error.
-    FormatRuntimeError(rcErr, lengthof(rcErr), hrT);
-
-    SString strHRHex;
-    strHRHex.Printf("%.8x", hrX);
-
-    COMPlusThrowHR(hrX, hrX, strHRHex, name, rcErr);
-} // void PostTypeLibError()
-
-
-
-
-void ExportTypeLibFromLoadedAssembly(
-    Assembly    *pAssembly,             // The assembly.
-    LPCWSTR     szTlb,                  // The typelib name.
-    ITypeLib    **ppTlb,                // If not null, also return ITypeLib here.
-    ITypeLibExporterNotifySink *pINotify,// Notification callback.
-    int         flags)                  // Export flags.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pAssembly));
-        PRECONDITION(CheckPointer(szTlb, NULL_OK));
-        PRECONDITION(CheckPointer(ppTlb));
-        PRECONDITION(CheckPointer(pINotify, NULL_OK));
-    }
-    CONTRACTL_END;
-
-    HRESULT     hr = S_OK;
-
-    TypeLibExporter exporter;           // Exporter object.
-    LPCWSTR     szModule=0;             // Module filename.
-    StackSString ssDrive;
-    StackSString ssDir;
-    StackSString ssFile;
-    size_t      cchDrive;
-    size_t      cchDir;
-    size_t      cchFile;
-    CQuickWSTR  rcTlb;     // Buffer for the tlb filename.
-    int         bDynamic=0;             // If true, dynamic module.
-    Module      *pModule;               // The Assembly's SecurityModule.
-    
-    pModule = pAssembly->GetManifestModule();
-    _ASSERTE(pModule);
-
-    // Retrieve the module filename.
-    szModule = pModule->GetPath();   
-    PREFIX_ASSUME(szModule != NULL);
-    
-    // Make sure the assembly has not been imported from COM.
-    if (pAssembly->IsImportedFromTypeLib())
-        COMPlusThrowHR(TLBX_E_CIRCULAR_EXPORT, (UINT)TLBX_E_CIRCULAR_EXPORT, W(""), szModule, NULL);
-
-    // If the module is dynamic then it will not have a file name.  We
-    //  assign a dummy name for typelib name (if the scope does not have
-    //  a name), but won't create a typelib on disk.
-    if (*szModule == 0)
-    {
-        bDynamic = TRUE;
-        szModule = W("Dynamic");
-    }
-
-    // Create the typelib name, if none provided.  Don't create one for Dynamic modules.
-    if (!szTlb || !*szTlb)
-    {
-        if (bDynamic)
-            szTlb = W("");
-        else
-        {
-            SplitPath(szModule, &ssDrive, &ssDir, &ssFile, nullptr);
-            MakePath(rcTlb, ssDrive.GetUnicode(), ssDir.GetUnicode(), ssFile.GetUnicode(), szTypeLibExt);
-            szTlb = rcTlb.Ptr();
-        }
-    }
-
-    // Do the conversion.  
-    exporter.Convert(pAssembly, szTlb, pINotify, flags);
-
-    // Get a copy of the ITypeLib*
-    IfFailThrow(exporter.GetTypeLib(IID_ITypeLib, (IUnknown**)ppTlb));
-} // void ExportTypeLibFromLoadedAssemblyInternal()
-
-
-HRESULT ExportTypeLibFromLoadedAssemblyNoThrow(
-    Assembly    *pAssembly,             // The assembly.
-    LPCWSTR     szTlb,                  // The typelib name.
-    ITypeLib    **ppTlb,                // If not null, also return ITypeLib here.
-    ITypeLibExporterNotifySink *pINotify,// Notification callback.
-    int         flags)                  // Export flags.
-{
-    CONTRACTL
-    {
-        DISABLED(NOTHROW);
-        GC_TRIGGERS;
-        MODE_PREEMPTIVE;
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-
-    EX_TRY
-    {
-        ExportTypeLibFromLoadedAssembly(pAssembly, 
-                                                szTlb,
-                                                ppTlb,
-                                                pINotify,
-                                                flags);
-    }
-    EX_CATCH_HRESULT(hr);
-
-    return hr;
-}
-
-//*****************************************************************************
-// Default notification class.
-//*****************************************************************************
-class CDefaultNotify : public ITypeLibExporterNotifySink
-{
-public:
-    virtual HRESULT __stdcall ReportEvent(
-        ImporterEventKind EventKind,        // Type of event.
-        long        EventCode,              // HR of event.
-        BSTR        EventMsg)               // Text message for event.
-    {
-        LIMITED_METHOD_CONTRACT;
-        return S_OK;
-    } // virtual HRESULT __stdcall ReportEvent()
-    
-    //-------------------------------------------------------------------------
-    virtual HRESULT __stdcall ResolveRef(
-        IUnknown    *Asm, 
-        IUnknown    **pRetVal) 
-    {
-        CONTRACTL
-        {
-            DISABLED(NOTHROW);
-            GC_TRIGGERS;
-            MODE_PREEMPTIVE;
-            SO_TOLERANT;
-            PRECONDITION(CheckPointer(Asm));
-            PRECONDITION(CheckPointer(pRetVal));
-        }
-        CONTRACTL_END;
-        
-        HRESULT     hr = S_OK;              // A result.
-        Assembly    *pAssembly=0;           // The referenced Assembly.
-        ITypeLib    *pTLB=0;                // The created TypeLib.
-        MethodTable *pAssemblyClass = NULL; //@todo -- get this.
-        LPVOID      RetObj = NULL;          // The object to return.
-
-        BEGIN_EXTERNAL_ENTRYPOINT(&hr)
-        {
-            {
-                GCX_COOP_THREAD_EXISTS(GET_THREAD());
-                // Get the Referenced Assembly from the IUnknown.
-                ASSEMBLYREF asmRef = NULL;
-                GCPROTECT_BEGIN(asmRef);
-                GetObjectRefFromComIP((OBJECTREF*)&asmRef, Asm, pAssemblyClass);
-                pAssembly = asmRef->GetAssembly();
-                GCPROTECT_END();
-            }
-            
-            // Default resolution provides no notification, flags are 0.
-            ExportTypeLibFromLoadedAssembly(pAssembly, 0, &pTLB, 0 /*pINotify*/, 0 /* flags*/);
-        }
-        END_EXTERNAL_ENTRYPOINT;
-
-        *pRetVal = pTLB;
-        
-        return hr;
-    } // virtual HRESULT __stdcall ResolveRef()
-    
-    //-------------------------------------------------------------------------
-    virtual HRESULT STDMETHODCALLTYPE QueryInterface(// S_OK or E_NOINTERFACE
-        REFIID      riid,                   // Desired interface.
-        void        **ppvObject)            // Put interface pointer here.
-    {
-        CONTRACTL
-        {
-            NOTHROW;
-            GC_TRIGGERS;
-            MODE_PREEMPTIVE;
-            SO_TOLERANT;
-            PRECONDITION(CheckPointer(ppvObject));
-        }
-        CONTRACTL_END;
-
-        *ppvObject = 0;
-        if (riid == IID_IUnknown || riid == IID_ITypeLibExporterNotifySink)
-        {
-            *ppvObject = this;
-            return S_OK;
-        }
-        return E_NOINTERFACE;
-    } // virtual HRESULT QueryInterface()
-    
-    //-------------------------------------------------------------------------
-    virtual ULONG STDMETHODCALLTYPE AddRef(void) 
-    {
-        LIMITED_METHOD_CONTRACT;
-        return 1;
-    } // virtual ULONG STDMETHODCALLTYPE AddRef()
-    
-    //-------------------------------------------------------------------------
-    virtual ULONG STDMETHODCALLTYPE Release(void) 
-    {
-        LIMITED_METHOD_CONTRACT;
-        return 1;
-    } // virtual ULONG STDMETHODCALLTYPE Release()
-};
-
-static CDefaultNotify g_Notify;
-
-//*****************************************************************************
-// CTOR/DTOR.  
-//*****************************************************************************
-TypeLibExporter::TypeLibExporter()
- :  m_pICreateTLB(0), 
-    m_pIUnknown(0), 
-    m_pIDispatch(0),
-    m_pGuid(0),
-    m_hIUnknown(-1)
-{
-    LIMITED_METHOD_CONTRACT;
-
-#if defined(_DEBUG)
-    static int i;
-    ++i;    // So a breakpoint can be set.
-#endif
-} // TypeLibExporter::TypeLibExporter()
-
-TypeLibExporter::~TypeLibExporter()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-    
-    ReleaseResources();
-} // TypeLibExporter::~TypeLibExporter()
-
-//*****************************************************************************
-// Get an interface pointer from the ICreateTypeLib interface.
-//*****************************************************************************
-HRESULT TypeLibExporter::GetTypeLib(
-    REFGUID     iid,
-    IUnknown    **ppITypeLib)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(ppITypeLib));
-    }
-    CONTRACTL_END;
-
-    return SafeQueryInterface(m_pICreateTLB, iid, (IUnknown**)ppITypeLib);
-} // HRESULT TypeLibExporter::GetTypeLib()
-
-//*****************************************************************************
-// LayOut a TypeLib.  Call LayOut on all ICreateTypeInfo2s first.
-//*****************************************************************************
-void TypeLibExporter::LayOut()       // S_OK or error.
-{
-    STANDARD_VM_CONTRACT;
-
-    HRESULT     hr = S_OK;              // A result.
-    int         cTypes;                 // Count of exported types.
-    int         ix;                     // Loop control.
-    CExportedTypesInfo *pData;          // For iterating the entries.
-
-    cTypes = m_Exports.Count();
-    
-    // Call LayOut on all ICreateTypeInfo2*s.
-    for (ix=0; ix<cTypes; ++ix)
-    {
-        pData = m_Exports[ix];
-        if (pData->pCTI && FAILED(hr = pData->pCTI->LayOut()))
-            PostTypeLibError(pData->pCTI, hr, TLBX_E_LAYOUT_ERROR);
-    }
-    
-    for (ix=0; ix<cTypes; ++ix)
-    {
-        pData = m_Exports[ix];
-        if (pData->pCTIClassItf && FAILED(hr = pData->pCTIClassItf->LayOut()))
-            PostTypeLibError(pData->pCTIClassItf, hr, TLBX_E_LAYOUT_ERROR);
-    }
-    
-    // Repeat for injected types.
-    cTypes = m_InjectedExports.Count();
-    for (ix=0; ix<cTypes; ++ix)
-    {
-        pData = m_InjectedExports[ix];
-        if (pData->pCTI && FAILED(hr = pData->pCTI->LayOut()))
-            PostTypeLibError(pData->pCTI, hr, TLBX_E_LAYOUT_ERROR);
-    }
-    
-    for (ix=0; ix<cTypes; ++ix)
-    {
-        pData = m_InjectedExports[ix];
-        if (pData->pCTIClassItf && FAILED(hr = pData->pCTIClassItf->LayOut()))
-            PostTypeLibError(pData->pCTIClassItf, hr, TLBX_E_LAYOUT_ERROR);
-    }
-} // HRESULT TypeLibExporter::LayOut()
-
-//*****************************************************************************
-// Release all pointers.
-//*****************************************************************************
-void TypeLibExporter::ReleaseResources()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    // Release the ITypeInfo* pointers.
-    m_Exports.Clear();
-    m_InjectedExports.Clear();
-
-    // Clean up the created TLB.
-    SafeRelease(m_pICreateTLB);
-    m_pICreateTLB = 0;
-
-    // Clean up the ITypeInfo*s for well-known interfaces.
-    SafeRelease(m_pIUnknown);
-    m_pIUnknown = 0;
-
-    SafeRelease(m_pIDispatch);
-    m_pIDispatch = 0;
-
-    SafeRelease(m_pGuid);
-    m_pGuid = 0;
-} // void TypeLibExporter::ReleaseResources()
-
-//*****************************************************************************
-// Enumerate the Types in a Module, add to the list.
-//*****************************************************************************
-void TypeLibExporter::AddModuleTypes(
-    Module     *pModule)                // The module to convert.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pModule));
-    }
-    CONTRACTL_END;
-
-    HRESULT     hr;
-    ULONG       cTD;                    // Count of typedefs.
-    mdTypeDef   td;                     // A TypeDef.
-    MethodTable     *pClass;            // A MethodTable for a TypeDef.
-    ULONG       ix;                     // Loop control.
-    CExportedTypesInfo *pExported;      // For adding classes to the exported types cache.
-    CExportedTypesInfo sExported;       // For adding classes to the exported types cache.
-    
-
-    // Convert all the types visible to COM.
-    // Get an enumerator on TypeDefs in the scope.
-    HENUMInternalHolder eTD(pModule->GetMDImport());
-    eTD.EnumTypeDefInit();
-    cTD = pModule->GetMDImport()->EnumTypeDefGetCount(&eTD);
-
-    // Add all the classes to the hash.
-    for (ix=0; ix<cTD; ++ix)
-    {
-        ZeroHolder  zhType = &m_ErrorContext.m_pScope;              // Clear error reporting info.
-        
-        // Get the TypeDef.
-        if (!pModule->GetMDImport()->EnumTypeDefNext(&eTD, &td))
-            IfFailReport(E_UNEXPECTED);
-        
-        IMDInternalImport* pInternalImport = pModule->GetMDImport();
-
-        // Error reporting info.
-        m_ErrorContext.m_tkType = td;
-        m_ErrorContext.m_pScope = pModule->GetMDImport();
-
-        // Get the class, perform the step.
-        pClass = LoadClass(pModule, td);
-        
-        // Enumerate the formal type parameters
-        HENUMInternal   hEnumGenericPars;
-        hr = pInternalImport->EnumInit(mdtGenericParam, td, &hEnumGenericPars);
-        if (SUCCEEDED(hr))
-        {
-            DWORD numGenericArgs = pInternalImport->EnumGetCount(&hEnumGenericPars);            
-            // skip generic classes
-            if( numGenericArgs  > 0 )
-            {
-                // We'll only warn if the type is marked ComVisible.
-                if (SpecialIsGenericTypeVisibleFromCom(TypeHandle(pClass)))
-                    ReportWarning(TLBX_I_GENERIC_TYPE, TLBX_I_GENERIC_TYPE);
-                
-                continue; 
-            }
-        }           
-    
-        // If the flag to not ignore non COM visible types in name decoration is set, then 
-        // add the ComVisible(false) types to our list of exported types by skipping this check.
-        if ((m_flags & TlbExporter_OldNames) == 0)
-        {            
-            // If the type isn't visible from COM, don't add it to the list of exports.
-            if (!IsTypeVisibleFromCom(TypeHandle(pClass)))
-                continue;
-        }
-
-        // See if this class is already in the list.
-        sExported.pClass = pClass;
-        pExported = m_Exports.Find(&sExported);
-        if (pExported != 0)
-            continue;
-        
-        // New class, add to list.
-        pExported = m_Exports.Add(&sExported);
-        if (!pExported)
-            IfFailReport(E_OUTOFMEMORY);
-        
-        // Prefix can't tell that IfFailReport will actually throw an exception if pExported is NULL so
-        // let's tell it explicitly that if we reach this point pExported will not be NULL.
-        PREFIX_ASSUME(pExported != NULL);        
-        pExported->pClass = pClass;
-        pExported->pCTI = 0;
-        pExported->pCTIClassItf = 0;
-    }
-} // HRESULT TypeLibExporter::AddModuleTypes()
-
-//*****************************************************************************
-// Enumerate the Modules in an assembly, add the types to the list.
-//*****************************************************************************
-void TypeLibExporter::AddAssemblyTypes(
-    Assembly    *pAssembly)              // The assembly to convert.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pAssembly));
-    }
-    CONTRACTL_END;
-
-    Module      *pManifestModule;       // A module in the assembly.
-    mdFile      mf;                     // A file token.
-
-    if (pAssembly->GetManifestImport())
-    {
-        // Enumerator over the modules of the assembly.
-        HENUMInternalHolder phEnum(pAssembly->GetManifestImport());
-        phEnum.EnumInit(mdtFile, mdTokenNil);
-
-        // Get the module for the assembly.
-        pManifestModule = pAssembly->GetManifestModule();
-        AddModuleTypes(pManifestModule);
-        
-        while (pAssembly->GetManifestImport()->EnumNext(&phEnum, &mf))
-        {
-            DomainFile *pDomainFile = pAssembly->GetManifestModule()->LoadModule(GetAppDomain(), mf, FALSE);
-
-            if (pDomainFile != NULL && !pDomainFile->GetFile()->IsResource())
-                AddModuleTypes(pDomainFile->GetModule());
-        }
-    }
-} // HRESULT TypeLibExporter::AddAssemblyTypes()
-    
-//*****************************************************************************
-// Convert COM+ metadata to a typelib.
-//*****************************************************************************
-void TypeLibExporter::Convert(
-    Assembly    *pAssembly,             // The Assembly to convert
-    LPCWSTR     szTlbName,              // Name of resulting TLB
-    ITypeLibExporterNotifySink *pNotify,// Notification callback.
-    int         flags)                  // Conversion flags
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pAssembly));
-        PRECONDITION(CheckPointer(szTlbName));
-        PRECONDITION(CheckPointer(pNotify, NULL_OK));
-    }
-    CONTRACTL_END;
-
-    HRESULT     hr = S_OK;              // A result.
-    ULONG       i;                      // Loop control.
-    SString     sName;                  // Library name.
-    GUID        guid;                   // Library guid.
-    VARIANT     vt = {0};               // Variant for ExportedFromComPlus.
-    CQuickArray<WCHAR> qLocale;         // Wide string for locale.
-    LCID        lcid;                   // LCID for typelib, default 0.
-    
-    // Set PerfCounters
-    COUNTER_ONLY(GetPerfCounters().m_Interop.cTLBExports++);
-
-    SafeComHolder<IMultiLanguage> pIML=0;     // For locale->lcid conversion.
-    SafeComHolder<ITypeLib> pITLB=0;          // TypeLib for IUnknown, IDispatch.
-    BSTRHolder              szTIName=0;       // Name of a TypeInfo.
-    BSTRHolder              szDescription=0;  // Assembly Description.
-
-    // Error reporting information.
-    m_ErrorContext.m_szAssembly = pAssembly->GetSimpleName();
-    
-    m_flags = flags;
-    
-    // Set the callback.
-    m_pNotify = pNotify ? pNotify : &g_Notify;
-
-    // If we haven't set 32-bit or 64-bit export yet, set it now with defaults.
-    UpdateBitness(pAssembly);
-
-    // Check the bitness of the assembly against our output bitness
-    IfFailReport(CheckBitness(pAssembly));
-    
-    // Get some well known TypeInfos.
-    GCX_PREEMP();
-    
-    BSTR wzPath;// = SysAllocStringLen(NULL, _MAX_PATH);
-    IfFailReport(QueryPathOfRegTypeLib(LIBID_STDOLE2, -1, -1, 0, &wzPath));
-
-    if (IsExportingAs64Bit())
-    {
-        hr = LoadTypeLibEx(wzPath, (REGKIND)(REGKIND_NONE | LOAD_TLB_AS_64BIT), &pITLB);       
-    }
-    else
-    {
-        hr = LoadTypeLibEx(wzPath, (REGKIND)(REGKIND_NONE | LOAD_TLB_AS_32BIT), &pITLB);
-    }
-
-    // If we failed to load StdOle2.tlb, then we're probably on a downlevel platform (< XP)
-    //  so we'll just load whatever we have...note that at this point, cross-compile is not an option.
-    if (FAILED(hr))
-    {
-        IfFailReport(LoadRegTypeLib(LIBID_STDOLE2, -1, -1, 0, &pITLB));
-    }
-    
-    IfFailReport(pITLB->GetTypeInfoOfGuid(IID_IUnknown, &m_pIUnknown));
-    IfFailReport(pITLB->GetTypeInfoOfGuid(IID_IDispatch, &m_pIDispatch));
-    
-    // Look for GUID (which unfortunately has no GUID).
-    for (i=0; i<pITLB->GetTypeInfoCount() && !m_pGuid; ++i)
-    {
-        IfFailReport(pITLB->GetDocumentation(i, &szTIName, 0, 0, 0));
-        if (SString::_wcsicmp(szTIName, szGuidName) == 0)
-            IfFailReport(pITLB->GetTypeInfo(i, &m_pGuid));
-    }
-
-    // Create the output typelib.
-
-    // Win2K: passing in too long a filename triggers a nasty buffer overrun bug
-    // when the SaveAll() method is called. We'll avoid triggering this here.
-    // 
-    if (wcslen(szTlbName) > MAX_PATH_FNAME)
-        IfFailReport(HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE));
-
-    // Reverting to old behavior here until we can fix up the vtable offsets as well.
-    // Set the SYSKIND based on the 64bit/32bit switches  
-    if (IsExportingAs64Bit())
-    {
-        IfFailReport(CreateTypeLib2(SYS_WIN64, szTlbName, &m_pICreateTLB));
-    }
-    else
-    {
-        IfFailReport(CreateTypeLib2(SYS_WIN32, szTlbName, &m_pICreateTLB));
-    }
-
-    // Set the typelib GUID.
-    IfFailReport(GetTypeLibGuidForAssembly(pAssembly, &guid));
-    IfFailReport(m_pICreateTLB->SetGuid(guid));
-
-    // Retrieve the type library's version number.
-    USHORT usMaj, usMin;
-    IfFailReport(GetTypeLibVersionForAssembly(pAssembly, &usMaj, &usMin));
-
-    // Set the TLB's version number.
-    IfFailReport(m_pICreateTLB->SetVersion(usMaj, usMin));
-
-    // Set the LCID.  If no locale, set to 0, otherwise typelib defaults to 409.
-    lcid = 0;
-    LPCUTF8 pLocale = pAssembly->GetLocale();
-    if (pLocale && *pLocale)
-    {
-        // Have to build a BSTR, not just a unicode string (i.e. allocate a
-        // DWORD of length information at a negative offset from the string
-        // start).        
-        _ASSERTE((sizeof(WCHAR) * 2) == sizeof(DWORD));
-        hr = qLocale.ReSizeNoThrow(sizeof(DWORD));
-        if (SUCCEEDED(hr))
-            hr = Utf2Quick(pLocale, qLocale, 2);
-        if (SUCCEEDED(hr))
-        {
-            *(DWORD*)qLocale.Ptr() = (DWORD)wcslen(&qLocale.Ptr()[2]);
-            hr = ::CoCreateInstance(CLSID_CMultiLanguage, NULL, CLSCTX_INPROC_SERVER, IID_IMultiLanguage, (void**)&pIML);
-        }
-        if (SUCCEEDED(hr))
-            pIML->GetLcidFromRfc1766(&lcid, (BSTR)&qLocale.Ptr()[2]);
-    }
-    HRESULT hr2 = m_pICreateTLB->SetLcid(lcid);
-    if (hr2 == TYPE_E_UNKNOWNLCID)
-    {
-        ReportWarning(TYPE_E_UNKNOWNLCID, TYPE_E_UNKNOWNLCID);
-        hr2 = m_pICreateTLB->SetLcid(0);
-    }
-    IfFailReport(hr2);
-
-    // Get the list of types in the assembly.
-    AddAssemblyTypes(pAssembly);
-    m_Exports.InitArray();
-
-    // Get the assembly value for AutomationProxy.
-    m_bAutomationProxy = DEFAULT_AUTOMATION_PROXY_VALUE;
-    GetAutomationProxyAttribute(pAssembly->GetManifestImport(), TokenFromRid(1, mdtAssembly), &m_bAutomationProxy);
-
-    // Pre load any caller-specified names into the typelib namespace.
-    PreLoadNames();
-
-    // Convert all the types.
-    ConvertAllTypeDefs();
-
-    // Set library level properties.
-    sName.AppendUTF8(pAssembly->GetSimpleName());
-    
-    // Make it a legal typelib name.
-    SString replaceChar = SL(W("_"));
-
-    SString::Iterator iter = sName.Begin();
-    while (sName.Find(iter, W(".")))
-        sName.Replace(iter, 1, replaceChar);
-
-    iter = sName.Begin();
-    while (sName.Find(iter, W(" ")))
-        sName.Replace(iter, 1, replaceChar);
-    
-    IfFailReport(m_pICreateTLB->SetName((LPOLESTR)sName.GetUnicode()));
-
-    // If the assembly has a description CA, set that as the library Doc string.
-    if (GetStringCustomAttribute(pAssembly->GetManifestImport(), XXX_ASSEMBLY_DESCRIPTION_TYPE, TokenFromRid(mdtAssembly, 1), (BSTR &)szDescription))
-        m_pICreateTLB->SetDocString((LPWSTR)szDescription);
-
-    // Mark this typelib as exported.
-    LPCWSTR pszFullName;
-    {
-        //@todo:  exceptions?
-        StackSString name;
-        pAssembly->GetDisplayName(name);
-        pszFullName = name.GetUnicode();
-
-        vt.vt = VT_BSTR;
-        vt.bstrVal = SysAllocString(pszFullName);
-        if (vt.bstrVal == NULL)
-            IfFailReport(E_OUTOFMEMORY);
-    }
-    
-    //WszMultiByteToWideChar(CP_ACP,0, (char*)rBuf.Ptr(), (DWORD)rBuf.Size(), vt.bstrVal, (DWORD)rBuf.Size());
-    IfFailReport(m_pICreateTLB->SetCustData(GUID_ExportedFromComPlus, &vt));
-     
-    // Lay out the TypeInfos.
-    LayOut();
-
-    if(vt.bstrVal)
-    {
-        SysFreeString(vt.bstrVal);
-        vt.bstrVal = NULL;
-    }
-    
-} // HRESULT TypeLibExporter::Convert()
-
-
-void TypeLibExporter::UpdateBitness(Assembly* pAssembly)
-{
-    WRAPPER_NO_CONTRACT;
-    
-    // If one has already been set, just return.
-    if ((TlbExportAs64Bit(m_flags)) || (TlbExportAs32Bit(m_flags)))
-        return;
-
-    // If we are exporting a dynamic assembly, just go with the machine type we're running on.
-    if (pAssembly->IsDynamic())
-    {
-#ifdef _WIN64
-        m_flags |= TlbExporter_ExportAs64Bit;
-#else
-        m_flags |= TlbExporter_ExportAs32Bit;
-#endif
-        return;
-    }
-
-    // Get the assembly info
-    PEFile* pPEFile = pAssembly->GetDomainAssembly()->GetFile();
-    _ASSERTE(pPEFile);
-
-    DWORD PEKind, MachineKind;
-    pPEFile->GetPEKindAndMachine(&PEKind, &MachineKind);
-
-    // Based on the assembly flags, determine a bitness to export with.
-    // Algorithm base copied from ComputeProcArchFlags() in bcl\system\reflection\assembly.cs
-    if ((PEKind & pe32Plus) == pe32Plus)
-    {
-        switch (MachineKind)
-        {
-            case IMAGE_FILE_MACHINE_IA64:
-            case IMAGE_FILE_MACHINE_AMD64:
-                m_flags |= TlbExporter_ExportAs64Bit;
-                break;
-
-            case IMAGE_FILE_MACHINE_I386:
-                if ((PEKind & peILonly) == peILonly)
-                {
-#ifdef _WIN64
-                    m_flags |= TlbExporter_ExportAs64Bit;
-#else
-                    m_flags |= TlbExporter_ExportAs32Bit;
-#endif
-                }
-                else
-                {
-                    _ASSERTE(!"Invalid MachineKind / PEKind pair on the assembly!");
-                }
-                break;
-
-            default:
-                _ASSERTE(!"Unknown MachineKind!");
-        }
-    }
-    else if (MachineKind == IMAGE_FILE_MACHINE_I386)
-    {
-        if ((PEKind & pe32BitRequired) == pe32BitRequired)
-        {
-            m_flags |= TlbExporter_ExportAs32Bit;
-        }
-        else if ((PEKind & peILonly) == peILonly)
-        {
-#ifdef _WIN64
-            m_flags |= TlbExporter_ExportAs64Bit;
-#else
-            m_flags |= TlbExporter_ExportAs32Bit;
-#endif
-        }
-        else
-        {
-            m_flags |= TlbExporter_ExportAs32Bit;
-        }
-    }
-    else if (MachineKind == IMAGE_FILE_MACHINE_ARMNT)
-    {
-        m_flags |= TlbExporter_ExportAs32Bit;
-    }
-    else
-    {
-#ifdef _WIN64
-        m_flags |= TlbExporter_ExportAs64Bit;
-#else
-        m_flags |= TlbExporter_ExportAs32Bit;
-#endif
-    }
-}
-
-
-// Find out if our assembly / bitness combination is valid.
-HRESULT TypeLibExporter::CheckBitness(Assembly* pAssembly)
-{
-    WRAPPER_NO_CONTRACT;
-
-    if (pAssembly->IsDynamic())
-        return S_OK;
-
-    PEFile* pPEFile = pAssembly->GetDomainAssembly()->GetFile();
-    if (pPEFile == NULL)
-        return TLBX_E_BITNESS_MISMATCH;
-
-    DWORD PEKind, MachineKind;
-    pPEFile->GetPEKindAndMachine(&PEKind, &MachineKind);
-
-    // Neutral assembly?
-    if ((PEKind & peILonly) == peILonly)
-        return S_OK;
-
-    if (IsExportingAs64Bit())
-    {
-        if ((MachineKind == IMAGE_FILE_MACHINE_IA64) || (MachineKind == IMAGE_FILE_MACHINE_AMD64))
-            return S_OK;
-    }
-    else
-    {
-        if ((MachineKind == IMAGE_FILE_MACHINE_I386) || (MachineKind == IMAGE_FILE_MACHINE_ARMNT))
-            return S_OK;
-    }
-
-    return TLBX_E_BITNESS_MISMATCH;
-}
-
-
-//*****************************************************************************
-//*****************************************************************************
-void TypeLibExporter::PreLoadNames()
-{
-    STANDARD_VM_CONTRACT;
-
-    SafeComHolder<ITypeLibExporterNameProvider>  pINames = 0;
-    HRESULT     hr = S_OK;              // A result.
-    SafeArrayHolder pNames = 0;         // Names provided by caller.
-    VARTYPE     vt;                     // Type of data.
-    int        lBound, uBound, ix;     // Loop control.
-    BSTR        name;
-
-    // Look for names provider, but don't require it.
-    hr = SafeQueryInterface(m_pNotify, IID_ITypeLibExporterNameProvider, (IUnknown**)&pINames);
-    if (FAILED(hr))
-        return;
-
-    // There is a provider, so get the list of names.
-    IfFailReport(pINames->GetNames(&pNames));
-
-    // Better have a single dimension array of strings.
-    if (pNames == 0)
-        IfFailReport(TLBX_E_BAD_NAMES);
-    
-    if (SafeArrayGetDim(pNames) != 1)
-        IfFailReport(TLBX_E_BAD_NAMES);
-    
-    IfFailReport(SafeArrayGetVartype(pNames, &vt));
-    if (vt != VT_BSTR)
-        IfFailReport(TLBX_E_BAD_NAMES);
-
-    // Get names bounds.
-    IfFailReport(SafeArrayGetLBound(pNames, 1, (LONG*)&lBound));
-    IfFailReport(SafeArrayGetUBound(pNames, 1, (LONG*)&uBound));
-
-    // Enumerate the names.
-    for (ix=lBound; ix<=uBound; ++ix)
-    {
-        IfFailReport(SafeArrayGetElement(pNames, (LONG*)&ix, (void*)&name));
-        m_pICreateTLB->SetName(name);
-    }
-}
-
-//*****************************************************************************
-//*****************************************************************************
-void TypeLibExporter::FormatErrorContextString(
-    CErrorContext *pContext,            // The context to format.
-    SString       *pOut)                // Buffer to format into.
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pContext));
-        PRECONDITION(CheckPointer(pOut));
-    }
-    CONTRACTL_END;
-    
-    HRESULT  hr;
-    SString *pBuf;
-    SString  ssInternal;
-    
-    // Nested contexts?
-    if (pContext->m_prev == 0)
-    {   // No, just convert into caller's buffer.
-        pBuf = pOut;
-    }
-    else
-    {   // Yes, convert locally, then concatenate.
-        pBuf = &ssInternal;
-    }
-    
-    // More?
-    if (pContext->m_pScope)
-    {   
-        // Check whether type is nested (which requires more formatting).
-        DWORD dwFlags;
-        IfFailReport(pContext->m_pScope->GetTypeDefProps(pContext->m_tkType, &dwFlags, 0));
-        
-        if (IsTdNested(dwFlags))
-        {
-            TypeNameBuilder tnb(pBuf, TypeNameBuilder::ParseStateNAME);
-            TypeString::AppendNestedTypeDef(tnb, pContext->m_pScope, pContext->m_tkType);
-        }
-        else
-            TypeString::AppendTypeDef(*pBuf, pContext->m_pScope, pContext->m_tkType);
-
-        // Member?
-        if (pContext->m_szMember)
-        {
-            pBuf->Append(NAMESPACE_SEPARATOR_WSTR);
-            
-            pBuf->AppendUTF8(pContext->m_szMember);
-
-            // Param?
-            if (pContext->m_szParam)
-            {
-                pBuf->Append(W("("));
-                pBuf->AppendUTF8(pContext->m_szParam);
-                pBuf->Append(W(")"));
-            }
-            else if (pContext->m_ixParam > -1)
-            {
-                pBuf->AppendPrintf(W("(#%d)"), pContext->m_ixParam);
-            }
-        } // member
-
-        pBuf->Append(ASSEMBLY_SEPARATOR_WSTR);
-    } // Type name
-    
-    pBuf->AppendUTF8(pContext->m_szAssembly);
-    
-    // If there is a nested context, put it all together.
-    if (pContext->m_prev)
-    {
-        // Format the context this one was nested inside.
-        SString ssOuter;
-        FormatErrorContextString(pContext->m_prev, &ssOuter);
-
-        // Put them together with text.
-        LPWSTR pUnicodeBuffer = pOut->OpenUnicodeBuffer(1024);
-        FormatRuntimeError(pUnicodeBuffer, 1024, TLBX_E_CTX_NESTED, pBuf->GetUnicode(), ssOuter.GetUnicode());
-        pOut->CloseBuffer((COUNT_T)wcslen(pUnicodeBuffer));
-    }
-} // HRESULT TypeLibExporter::FormatErrorContextString()
-
-//*****************************************************************************
-//*****************************************************************************
-void TypeLibExporter::FormatErrorContextString(
-    SString    *pBuf)                   // Buffer to format into.
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(CheckPointer(pBuf));
-    }
-    CONTRACTL_END;
-
-    FormatErrorContextString(&m_ErrorContext, pBuf);
-} // HRESULT TypeLibExporter::FormatErrorContextString()
-
-//*****************************************************************************
-// Event reporting helper.
-//*****************************************************************************
-void TypeLibExporter::ReportError(HRESULT hrRpt)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    WCHAR      rcErr[1024];
-    SString    ssName;
-    SafeComHolder<IErrorInfo> pErrorInfo;
-    BSTRHolder bstrDescription = NULL;
-
-    // Format the error message.
-    if (SafeGetErrorInfo(&pErrorInfo) != S_OK)
-        pErrorInfo = NULL;
-
-    // If we retrieved and IErrorInfo then retrieve the description.
-    if (pErrorInfo)
-    {
-        if (FAILED(pErrorInfo->GetDescription(&bstrDescription)))
-            bstrDescription = NULL;
-    }
-
-    if (bstrDescription)
-    {
-        // Use the description as the error message.
-        wcsncpy_s(rcErr, COUNTOF(rcErr), bstrDescription, _TRUNCATE);
-    }
-    else
-    {
-        // Format the error message.
-        FormatRuntimeError(rcErr, lengthof(rcErr), hrRpt);
-    }
-
-    // Format the context.
-    FormatErrorContextString(&ssName);
-
-    // Post the error to the errorinfo object.
-    VMPostError(TLBX_E_ERROR_MESSAGE, ssName.GetUnicode(), rcErr);
-
-    // Throw the exception, including context info.
-    COMPlusThrowHR(TLBX_E_ERROR_MESSAGE, kGetErrorInfo);
-} // void TypeLibExporter::ReportError()
-
-//*****************************************************************************
-// Event reporting helper.
-//*****************************************************************************
-void TypeLibExporter::ReportEvent(   // Returns the original HR.
-    int         ev,                  // The event kind.
-    int         hr,                  // HR.
-    ...)                             // Variable args.
-{
-    STANDARD_VM_CONTRACT;
-
-    WCHAR       rcMsg[1024];            // Buffer for message.
-    va_list     marker;                 // User text.
-    BSTRHolder  bstrMsg=0;              // BSTR for message.
-    
-    // Format the message.
-    va_start(marker, hr);
-    hr = FormatRuntimeErrorVa(rcMsg, lengthof(rcMsg), hr, marker);
-    va_end(marker);
-    
-    // Convert to a BSTR.
-    bstrMsg = SysAllocString(rcMsg);
-    
-    // Display it, and clean up.
-    if (bstrMsg != NULL)
-        m_pNotify->ReportEvent(static_cast<ImporterEventKind>(ev), hr, bstrMsg);
-
-} // HRESULT CImportTlb::ReportEvent()
-
-//*****************************************************************************
-// Warning reporting helper.
-//*****************************************************************************
-void TypeLibExporter::ReportWarning( // Original error code.
-    HRESULT hrReturn,                   // HR to return.
-    HRESULT hrRpt,                      // Error code.
-    ...)                                // Args to message.
-{
-    STANDARD_VM_CONTRACT;
-
-    WCHAR       rcErr[1024];            // Buffer for error message.
-    SString     ssName;                 // Buffer for context.
-    va_list     marker;                 // User text.
-    BSTRHolder  bstrMsg=0;              // BSTR for message.
-    BSTRHolder  bstrBuf=0;              // Buffer for message.
-    UINT        iLen;                   // Length of allocated buffer.
-    
-    // Format the message.
-    va_start(marker, hrRpt);
-    FormatRuntimeErrorVa(rcErr, lengthof(rcErr), hrRpt, marker);
-    va_end(marker);
-    
-    // Format the context.
-    FormatErrorContextString(&ssName);
-                        
-    // Put them together.
-    iLen = (UINT)(wcslen(rcErr) + ssName.GetCount() + 200);
-    bstrBuf = SysAllocStringLen(0, iLen);
-    
-    if (bstrBuf != NULL)
-    {
-        FormatRuntimeError(bstrBuf, iLen, TLBX_W_WARNING_MESSAGE, ssName.GetUnicode(), rcErr);
-        
-        // Have to copy to another BSTR, because the runtime will also print the trash after the 
-        //  terminating nul.
-        bstrMsg = SysAllocString(bstrBuf);
-        
-        if (bstrMsg != NULL)
-            m_pNotify->ReportEvent(NOTIF_CONVERTWARNING, hrRpt, bstrMsg);
-    }
-
-} // void TypeLibExporter::ReportWarning()
-    
-// Throws exceptions encountered during type exportation.
-// Wrapped with ThrowHRWithContext.
-void TypeLibExporter::InternalThrowHRWithContext(HRESULT hrRpt, ...)
-{
-    STANDARD_VM_CONTRACT;
-
-    WCHAR   rcErr[2048];
-    SString ssName;
-    va_list marker;  
-
-    // Format the error message.
-    va_start(marker, hrRpt);
-    FormatRuntimeErrorVa(rcErr, lengthof(rcErr), hrRpt, marker);
-    va_end(marker);
-
-    // Format the context.
-    FormatErrorContextString(&ssName);
-
-    // Post the error to the errorinfo object.
-    VMPostError(TLBX_E_ERROR_MESSAGE, ssName.GetUnicode(), rcErr);
-
-    // Throw the exception, including context info.
-    COMPlusThrowHR(TLBX_E_ERROR_MESSAGE, kGetErrorInfo);
-} // void TypeLibExporter::InternalThrowHRWithContext()
-
-//*****************************************************************************
-// Post a class load error on failure.
-//*****************************************************************************
-void TypeLibExporter::PostClassLoadError(
-    LPCUTF8     pszName,                // Name of the class.
-    SString&    message)                // Exception message of class load failure.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pszName));
-    }
-    CONTRACTL_END;
-
-    // See if we got anything back.
-    if (!message.IsEmpty())
-        InternalThrowHRWithContext(TLBX_E_CLASS_LOAD_EXCEPTION, pszName, message.GetUnicode());
-    else
-        InternalThrowHRWithContext(TLBX_E_CANT_LOAD_CLASS, pszName);
-} // HRESULT TypeLibExporter::PostClassLoadError()
-
-//*****************************************************************************
-// Determine the type, if any, of auto-interface for a class.
-//  May be none, dispatch, or dual.
-//*****************************************************************************
-void TypeLibExporter::ClassHasIClassX(  
-    MethodTable           *pClass,                // The class.
-    CorClassIfaceAttr *pClassItfType)         // None, dual, dispatch
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pClass));
-        PRECONDITION(!pClass->IsInterface());
-        PRECONDITION(CheckPointer(pClassItfType));
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = S_OK;
-    ComMethodTable *pClassComMT = NULL;
-
-    *pClassItfType = clsIfNone;
-
-    // If the class is a COM import or if it isn't COM visible, then from the 
-    // exporter's perspective, it doens't have an IClassX.
-    if (!pClass->IsComImport())
-    {
-        ComCallWrapperTemplate *pTemplate = ComCallWrapperTemplate::GetTemplate(pClass);
-        if (pTemplate->SupportsIClassX())
-        {
-            pClassComMT = ComCallWrapperTemplate::SetupComMethodTableForClass(pClass, FALSE);
-            _ASSERTE(pClassComMT);
-
-            if (pClassComMT->IsComVisible())
-                *pClassItfType = pClassComMT->GetClassInterfaceType();
-        }
-    }
-} // HRESULT TypeLibExporter::ClassHasIClassX()
-
-//*****************************************************************************
-// Load a class by token, post an error on failure.
-//*****************************************************************************
-MethodTable * TypeLibExporter::LoadClass(
-    Module      *pModule,               // Module with Loader to use to load the class.
-    mdToken     tk)                     // The token to load.
-{
-    CONTRACT(MethodTable *)
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pModule));
-        POSTCONDITION(CheckPointer(RETVAL));
-    }
-    CONTRACT_END;
-
-    // Get the MethodTable for the token.        
-    TypeHandle th;
-    SString exceptionMessage;
-
-    EX_TRY
-    {            
-        th = ClassLoader::LoadTypeDefOrRefThrowing(pModule, tk,
-                                                  ClassLoader::ThrowIfNotFound, 
-                                                  ClassLoader::PermitUninstDefOrRef);
-    }
-    EX_CATCH
-    {
-        GET_EXCEPTION()->GetMessage(exceptionMessage);
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-
-    if (th.IsNull())
-    {
-        // Format a hopefully useful error message.
-        LPCUTF8 pNS, pName;
-        SString sName;
-            
-        if (TypeFromToken(tk) == mdtTypeDef)
-        {
-            if (FAILED(pModule->GetMDImport()->GetNameOfTypeDef(tk, &pName, &pNS)))
-            {
-                pName = pNS = "Invalid TypeDef record";
-            }
-        }
-        else
-        {
-            _ASSERTE(TypeFromToken(tk) == mdtTypeRef);
-            if (FAILED(pModule->GetMDImport()->GetNameOfTypeRef(tk, &pNS, &pName)))
-            {
-                pNS = pName = "Invalid TypeRef record";
-            }
-        }
-
-        if (pNS && *pNS)
-        {
-            sName.AppendUTF8(pNS);
-            sName.AppendUTF8(NAMESPACE_SEPARATOR_STR);
-        }
-            
-        sName.AppendUTF8(pName);
-            
-        StackScratchBuffer scratch;
-        PostClassLoadError(sName.GetUTF8(scratch), exceptionMessage);
-    }
-
-    RETURN (th.AsMethodTable());
-    
-} // void TypeLibExporter::LoadClass()
-
-//*****************************************************************************
-// Load a class by name, post an error on failure.
-//*****************************************************************************
-TypeHandle TypeLibExporter::LoadClass(
-    Module      *pModule,               // Module with Loader to use to load the class.
-    LPCUTF8     pszName)                // Name of class to load.
-{
-    CONTRACT(TypeHandle)
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pModule));
-        PRECONDITION(CheckPointer(pszName));
-        POSTCONDITION(!RETVAL.IsNull());
-    }
-    CONTRACT_END;
-
-    TypeHandle th;
-    SString exceptionMessage;
-
-    EX_TRY
-    {            
-        th = TypeName::GetTypeUsingCASearchRules(pszName, pModule->GetAssembly());
-        _ASSERTE(!th.IsNull());
-    }
-    EX_CATCH
-    {
-        GET_EXCEPTION()->GetMessage(exceptionMessage);
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-
-    if (th.IsNull())
-    {
-        PostClassLoadError(pszName, exceptionMessage);
-    }
-
-    RETURN th;
-
-} // void TypeLibExporter::LoadClass()
-
-
-//*****************************************************************************
-// Enumerate the TypeDefs and convert them to TypeInfos.
-//*****************************************************************************
-void TypeLibExporter::ConvertAllTypeDefs()
-{
-    STANDARD_VM_CONTRACT;
-
-    HRESULT     hr = S_OK;              // A result.
-    CExportedTypesInfo *pData;          // For iterating the entries.
-    int         cTypes;                 // Count of types.
-    int         ix;                     // Loop control.
-    
-    LPCSTR pName1, pNS1;                // Names of a type.
-    LPCSTR pName2, pNS2;                // Names of another type.
-    MethodTable     *pc1;                   // A Type.
-    MethodTable     *pc2;                   // Another type.
-    CQuickArray<BYTE> bNamespace;       // Array of flags for namespace decoration.
-        
-    cTypes = m_Exports.Count();
-
-    // If there are no types in the assembly, then we are done.
-    if (cTypes <= 0)
-        return;
-    
-    // Order by name, then look for duplicates.
-    m_Exports.SortByName();                    
-    
-    // Resize the array for namespace flags now, but use the ICreateTypeInfo*, so that
-    //  the flags will be sorted.
-    bNamespace.ReSizeThrows(cTypes);
-    
-    // Get names of first type.
-    pc1 = m_Exports[0]->pClass;
-    IfFailReport(pc1->GetMDImport()->GetNameOfTypeDef(pc1->GetCl(), &pName1, &pNS1));
-    
-    // Iterate through the types, looking for duplicate type names.
-    for (ix=0; ix<cTypes-1; ++ix)
-    {
-        // Get the Type pointers and the types' names.
-        pc2 = m_Exports[ix+1]->pClass;
-        IfFailReport(pc2->GetMDImport()->GetNameOfTypeDef(pc2->GetCl(), &pName2, &pNS2));
-        
-        // If the types match (case insensitive). mark both types for namespace
-        //  decoration.  
-        if (stricmpUTF8(pName1, pName2) == 0)
-        {
-            m_Exports[ix]->pCTI = reinterpret_cast<ICreateTypeInfo2*>(1);
-            m_Exports[ix+1]->pCTI = reinterpret_cast<ICreateTypeInfo2*>(1);
-        }
-        else
-        {   // Didn't match, so advance "class 1" pointer.
-            pc1 = pc2;
-            pName1 = pName2;
-            pNS1 = pNS2;
-        }
-    }
-    
-    // Put into token order for actual creation.
-    m_Exports.SortByToken();
-    
-    // Fill the flag array, from the ICreateTypeInfo* pointers.
-    memset(bNamespace.Ptr(), 0, bNamespace.Size()*sizeof(BYTE));
-    for (ix=0; ix<cTypes; ++ix)
-    {
-        if (m_Exports[ix]->pCTI)
-            bNamespace[ix] = 1, m_Exports[ix]->pCTI = 0;
-    }
-    
-    // Pass 1.  Create the TypeInfos.
-    // There are four steps in the process:
-    //  a) Creates the TypeInfos for the types themselves.  When a duplicate
-    //     is encountered, skip the type until later, so that we don't create
-    //     a decorated name that will conflict with a subsequent non-decorated
-    //     name.  We want to preserve a type's given name as much as possible.
-    //  b) Create the TypeInfos for the types that were duplicates in step a.
-    //     Perform decoration of the names as necessary to eliminate duplicates.
-    //  c) Create the TypeInfos for the IClassXs.  When there is a duplicate,
-    //     skip, as in step a.
-    //  d) Create the remaining TypeInfos for IClassXs.  Perform decoration of 
-    //     the names as necessary to eliminate duplicates.
-    
-    // Step a, Create the TypeInfos for the TypeDefs, no decoration.
-    for (ix=0; ix<cTypes; ++ix)
-    {
-        int     bAutoProxy = m_bAutomationProxy;
-        pData = m_Exports[ix];
-        pData->tkind = TKindFromClass(pData->pClass);
-        GetAutomationProxyAttribute(pData->pClass->GetMDImport(), pData->pClass->GetCl(), &bAutoProxy);
-        pData->bAutoProxy = (bAutoProxy != 0);
-        
-        CreateITypeInfo(pData, (bNamespace[ix]!=0), false);
-    }
-    // Step b, Create the TypeInfos for the TypeDefs, decoration as needed.
-    for (ix=0; ix<cTypes; ++ix)
-    {
-        pData = m_Exports[ix];
-        if (pData->pCTI == 0)
-            CreateITypeInfo(pData, (bNamespace[ix]!=0), true);
-    }
-    
-    // Step c, Create the TypeInfos for the IClassX interfaces.  No decoration.
-    for (ix=0; ix<cTypes; ++ix)
-    {
-        pData = m_Exports[ix];
-        CreateIClassXITypeInfo(pData, (bNamespace[ix]!=0), false);
-    }
-    // Step d, Create the TypeInfos for the IClassX interfaces.  Decoration as required.
-    for (ix=0; ix<cTypes; ++ix)
-    {
-        pData = m_Exports[ix];
-        if (pData->pCTIClassItf == 0)
-            CreateIClassXITypeInfo(pData, (bNamespace[ix]!=0), true);
-    }
-    
-    // Pass 2, add the ImplTypes to the CoClasses.
-    for (ix=0; ix<cTypes; ++ix)
-    {
-        pData = m_Exports[ix];
-        ConvertImplTypes(pData);
-    }
-    
-    // Pass 3, fill in the TypeInfo details...
-    for (ix=0; ix<cTypes; ++ix)
-    {
-        pData = m_Exports[ix];
-        ConvertDetails(pData);
-    }
-    
-    hr = S_OK;
-} // void TypeLibExporter::ConvertAllTypeDefs()
-
-//*****************************************************************************
-// Convert one TypeDef.  Useful for one-off TypeDefs in other scopes where 
-//  that other scope's typelib doesn't contain a TypeInfo.  This happens
-//  for the event information with imported typelibs.
-//*****************************************************************************
-HRESULT TypeLibExporter::ConvertOneTypeDef(
-    MethodTable     *pClass)                // The one class to convert.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pClass));
-    }
-    CONTRACTL_END;
-
-    HRESULT     hr = S_OK;              // A result.
-    ICreateTypeInfo2 *pCTI=0;           // The TypeInfo to create.
-    ICreateTypeInfo2 *pDefault=0;       // A possible IClassX TypeInfo.
-    CErrorContext SavedContext;         // Previous error context.
-    CExportedTypesInfo *pExported;      // For adding classes to the exported types cache.
-    CExportedTypesInfo sExported;       // For adding classes to the exported types cache.
-
-    // Save error reporting context.
-    SavedContext = m_ErrorContext;
-    m_ErrorContext.m_szAssembly  = pClass->GetAssembly()->GetSimpleName();
-    m_ErrorContext.m_tkType      = mdTypeDefNil;
-    m_ErrorContext.m_pScope      = 0;
-    m_ErrorContext.m_szMember    = 0;
-    m_ErrorContext.m_szParam     = 0;
-    m_ErrorContext.m_ixParam     = -1;
-    m_ErrorContext.m_prev = &SavedContext;
-    
-    // See if this class is already in the list.
-    sExported.pClass = pClass;
-    pExported = m_InjectedExports.Find(&sExported);
-    if (pExported == 0)
-    {
-        // Get the AutoProxy value for an isolated class.
-        int     bAutoProxy = DEFAULT_AUTOMATION_PROXY_VALUE;
-        if (FALSE == GetAutomationProxyAttribute(pClass->GetMDImport(), pClass->GetCl(), &bAutoProxy))
-            GetAutomationProxyAttribute(pClass->GetAssembly()->GetManifestImport(), TokenFromRid(1, mdtAssembly), &bAutoProxy);
-
-        // New class, add to list.
-        if (NULL == (pExported = m_InjectedExports.Add(&sExported)))
-            IfFailReport(E_OUTOFMEMORY);
-        m_InjectedExports.UpdateArray();
-        
-        // Prefix can't tell that IfFailReport will actually throw an exception if pExported is NULL so
-        // let's tell it explicitly that if we reach this point pExported will not be NULL.
-        PREFIX_ASSUME(pExported != NULL);        
-        pExported->pClass = pClass;
-        pExported->pCTI = 0;
-        pExported->pCTIClassItf = 0;
-        pExported->tkind = TKindFromClass(pClass);
-        pExported->bAutoProxy = (bAutoProxy != 0);
-
-        // Step 1, Create the TypeInfos for the TypeDefs.
-        CreateITypeInfo(pExported);
-    
-        // Step 1a, Create the TypeInfos for the IClassX interfaces.
-        CreateIClassXITypeInfo(pExported);
-    
-        // Step 2, add the ImplTypes to the CoClasses.
-        ConvertImplTypes(pExported);
-    
-        // Step 3, fill in the TypeInfo details...
-        ConvertDetails(pExported);
-    }
-    
-    // Restore error reporting context.
-    m_ErrorContext = SavedContext;
-    
-    return (hr);
-} // HRESULT TypeLibExporter::ConvertOneTypeDef()
-
-
-//*****************************************************************************
-// Create the ITypeInfo for a type.  Well, sort of.  This function will create
-//  the first of possibly two typeinfos for the type.  If the type is a class
-//  we will create a COCLASS typeinfo now, and an INTERFACE typeinfo later,
-//  which typeinfo will be the default interface for the coclass.  If this
-//  typeinfo needs to be aliased, we will create the ALIAS now (with the 
-//  real name) and the aliased typeinfo later, with the real attributes, but
-//  with a mangled name. 
-//*****************************************************************************
-void TypeLibExporter::CreateITypeInfo(
-    CExportedTypesInfo *pData,          // Conversion data.
-    bool        bNamespace,             // If true, use namespace + name
-    bool        bResolveDup)            // If true, decorate name to resolve dups.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pData));
-    }
-    CONTRACTL_END;
-
-    HRESULT     hr = S_OK;              // A result.
-    LPCUTF8     pName;                  // Name in UTF8.
-    LPCUTF8     pNS;                    // Namespace in UTF8.
-    SString     sName;                  // Name of the TypeDef.
-    TYPEKIND    tkind;                  // The TYPEKIND of a TypeDef.
-    GUID        clsid;                  // A TypeDef's clsid.
-    DWORD       dwFlags;                // A TypeDef's flags.
-    int         iSuffix = 0;            // Counter for suffix.
-    mdTypeDef   td;                     // Token for the class.
-
-    VariantHolder vt;                                 // For defining custom attribute.   
-    SafeComHolder<ICreateTypeInfo> pCTITemp=0;        // For creating a typeinfo.
-    SafeComHolder<ICreateTypeInfo2> pCTI2=0;          // For creating the typeinfo.
-    SafeComHolder<ITypeLib> pITLB=0;                  // For dup IID reporting.   
-    SafeComHolder<ITypeInfo> pITIDup=0;               // For dup IID reporting.
-    BSTRHolder  bstrDup=0;                            // For dup IID reporting.
-    BSTRHolder  bstrDescr=0;                          // For description.
-    ZeroHolder  zhType = &m_ErrorContext.m_pScope;    // Clear error reporting info.
-    CorClassIfaceAttr classItfType = clsIfNone;       // For class interface type.
-    TypeHandle  thClass = TypeHandle(pData->pClass);  // TypeHandle representing the class.
-
-    DefineFullyQualifiedNameForClassW();
-
-    // Get the TypeDef and some info about it.
-    td = pData->pClass->GetCl();
-    IfFailReport(pData->pClass->GetMDImport()->GetTypeDefProps(td, &dwFlags, 0));
-    tkind = pData->tkind;
-    
-    // Error reporting info.
-    m_ErrorContext.m_tkType = td;
-    m_ErrorContext.m_pScope = pData->pClass->GetMDImport();
-    
-    pData->pCTI = 0;
-    pData->pCTIClassItf = 0;
-
-    // If it is ComImport or WindowsRuntimeImport, do not export it.
-    if (IsTdImport(dwFlags) || pData->pClass->IsProjectedFromWinRT())
-        return;
-
-    // Check to see if the type is supposed to be visible from COM. If it
-    // is not then we go to the next type.
-    if (!IsTypeVisibleFromCom(TypeHandle(pData->pClass)))
-        return;
-
-    // Get the GUID for the class.  Will generate from name if no defined GUID,
-    //  will also use signatures if interface.
-    pData->pClass->GetGuid(&clsid, TRUE);
-
-    // Get the name.
-    IfFailReport(pData->pClass->GetMDImport()->GetNameOfTypeDef(td, &pName, &pNS));
-    
-    // Warn about exporting AutoLayout valueclasses
-    if ( (pData->pClass->IsValueType()) && (!pData->pClass->IsEnum()) && (IsTdAutoLayout(pData->pClass->GetAttrClass())))
-        ReportWarning(TLBX_W_EXPORTING_AUTO_LAYOUT, TLBX_W_EXPORTING_AUTO_LAYOUT, pName);
-
-    // Warn about exporting generic classes.
-    if (pData->pClass->GetNumGenericArgs() != 0)
-        ReportWarning(TLBX_I_GENERIC_TYPE, TLBX_I_GENERIC_TYPE);
-
-    // Classes that derive from generic classes can be COM visible, however we don't
-    // expose a class interface for them. Give a warning to the user about this.
-    if (pData->pClass->HasGenericClassInstantiationInHierarchy())
-    {
-        if (!pData->pClass->IsComImport() && IsTypeVisibleFromCom(thClass))
-        {
-            // Note that we can't call ClassHasIClassX here since it would return
-            // classIfNone if the type has generic parents in it's hierarchy.
-            if (ReadClassInterfaceTypeCustomAttribute(thClass) != clsIfNone)
-                ReportWarning(TLBX_I_GENERIC_BASE_TYPE, TLBX_I_GENERIC_BASE_TYPE);        
-        }
-    }
-        
-    // Warn about exporting reference types as structs.
-    if ((pData->tkind == TKIND_RECORD || pData->tkind == TKIND_UNION) && !pData->pClass->IsValueType())
-        ReportWarning(TLBX_I_REF_TYPE_AS_STRUCT, TLBX_I_REF_TYPE_AS_STRUCT);
-
-    // workaround for microsoft.wfc.interop.dll -- skip their IDispatch.
-    if (clsid == IID_IDispatch || clsid == IID_IUnknown)
-    {
-        ReportEvent(NOTIF_CONVERTWARNING, TLBX_S_NOSTDINTERFACE, pName);
-        return;
-    }
-
-    if (bNamespace)
-    {
-        sName.MakeFullNamespacePath(SString(SString::Utf8, pNS), SString(SString::Utf8, pName));
-
-        SString replaceChar = SL(W("_"));
-
-        SString::Iterator iter = sName.Begin();
-        while (sName.Find(iter, W(".")))
-            sName.Replace(iter, 1, replaceChar);
-    }
-    else
-    {   // Convert name to wide chars.
-        sName.AppendUTF8(pName);
-    }
-
-    // Create the typeinfo for this typedef.
-    for (;;)
-    {
-        // Attempt to create the TypeDef.
-        hr = m_pICreateTLB->CreateTypeInfo((LPOLESTR)sName.GetUnicode(), tkind, &pCTITemp);
-        
-        // If a name conflict, decorate, otherwise, done.
-        if (hr != TYPE_E_NAMECONFLICT)
-            break;
-            
-        if (!bResolveDup)
-        {
-            hr = S_FALSE;
-            return;
-        }
-
-        if (iSuffix == 0)
-        {           
-            iSuffix = 2;
-        }
-        else
-        {
-            sName.Delete(sName.End()-=2, 2);            
-        }
-
-        SString sDup;
-        sDup.Printf(szDuplicateDecoration, iSuffix++);
-
-        sName.Append(sDup);
-    }
-    
-    IfFailReport(hr);
-    IfFailReport(SafeQueryInterface(pCTITemp, IID_ICreateTypeInfo2, (IUnknown**)&pCTI2));
-    
-    // Set the guid.
-    _ASSERTE(clsid != GUID_NULL);
-    hr = pCTI2->SetGuid(clsid);
-    if (FAILED(hr))
-    {
-        if (hr == TYPE_E_DUPLICATEID)
-        {
-            IfFailReport(SafeQueryInterface(m_pICreateTLB, IID_ITypeLib, (IUnknown**)&pITLB));
-            IfFailReport(pITLB->GetTypeInfoOfGuid(clsid, &pITIDup));
-            IfFailReport(pITIDup->GetDocumentation(MEMBERID_NIL, &bstrDup, 0,0,0));
-            InternalThrowHRWithContext(TLBX_E_DUPLICATE_IID, sName.GetUnicode(), (BSTR)bstrDup);
-        }
-        return;
-    }
-    TRACE("TypeInfo %x: %ls, {%08x-%04x-%04x-%04x-%02x%02x%02x%02x}\n", pCTI2, sName, 
-        clsid.Data1, clsid.Data2, clsid.Data3, clsid.Data4[0]<<8|clsid.Data4[1], clsid.Data4[2], clsid.Data4[3], clsid.Data4[4], clsid.Data4[5]); 
-
-    IfFailReport(pCTI2->SetVersion(1, 0));
-
-    // Record the fully qualified type name in a custom attribute.
-    // If the TypelibImportClassAttribute exists, use that instead.
-    SString sName2;
-    hr = GetTypeLibImportClassName(pData->pClass, sName2);
-    if (hr == S_OK)
-    {      
-        V_BSTR(&vt) = ::SysAllocString(sName2.GetUnicode());
-        if (V_BSTR(&vt) == NULL)
-            IfFailReport(E_OUTOFMEMORY);
-
-        V_VT(&vt) = VT_BSTR;
-    }
-    else
-    {
-        // Default to the real name.
-        LPCWSTR pszName = GetFullyQualifiedNameForClassNestedAwareW(pData->pClass);
-
-        V_BSTR(&vt) = ::SysAllocString(pszName);
-        if (V_BSTR(&vt) == NULL)
-            IfFailReport(E_OUTOFMEMORY);
-
-        V_VT(&vt) = VT_BSTR;
-    }
-    
-    IfFailReport(pCTI2->SetCustData(GUID_ManagedName, &vt));
-
-    // If the class is decorated with a description, apply it to the typelib.
-    if (GetDescriptionString(pData->pClass, td, (BSTR &)bstrDescr))
-        IfFailReport(pCTI2->SetDocString(bstrDescr));
-    
-    // Transfer ownership of the pointer.
-    pData->pCTI = pCTI2;
-    pCTI2.SuppressRelease();
-    pCTI2 = 0;
-} // void TypeLibExporter::CreateITypeInfo()
-
-HRESULT TypeLibExporter::GetTypeLibImportClassName(
-    MethodTable*pClass,
-    SString&    szName)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-    _ASSERTE(NULL != pClass);
-
-    HRESULT hr = S_OK;
-
-    // Check for the presence of the TypelibImportClassAttribute.
-    const char*       pvData;           // Pointer to a custom attribute data.
-    ULONG             cbData;           // Size of custom attribute data.
-
-    hr = pClass->GetMDImport()->GetCustomAttributeByName(pClass->GetCl(),
-                                                         INTEROP_TYPELIBIMPORTCLASS_TYPE,
-                                                         reinterpret_cast<const void**>(&pvData),
-                                                         &cbData);
-
-    if (hr == S_OK && cbData > 5 && pvData[0] == 1 && pvData[1] == 0)
-    {       
-        CustomAttributeParser cap(pvData, cbData);
-        VERIFY(SUCCEEDED(cap.ValidateProlog())); // Validated above, just ensure consistency.
-
-        LPCUTF8 szString;
-        ULONG   cbString;
-        if (SUCCEEDED(cap.GetNonNullString(&szString, &cbString)))
-        {
-            // Set the string and null terminate it.
-            szName.SetUTF8(szString, cbString);
-            szName.AppendASCII("\0");
-
-            // We successfully retrieved the string.
-            return S_OK;
-        }
-    }
-
-    return S_FALSE;
-}
-
-
-
-//*****************************************************************************
-// See if an object has a Description, and get it as a BSTR.
-//*****************************************************************************
-BOOL TypeLibExporter::GetDescriptionString(
-    MethodTable     *pClass,                // Class containing the token.
-    mdToken     tk,                     // Token of the object.
-    BSTR        &bstrDescr)             // Put description here.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pClass));
-    }
-    CONTRACTL_END;
-
-    // Check for a description custom attribute.
-    return GetStringCustomAttribute(pClass->GetMDImport(), XXX_DESCRIPTION_TYPE, tk, bstrDescr);
-
-} // HRESULT TypeLibExporter::GetDescriptionString()
-
-//*****************************************************************************
-// See if an object has a custom attribute, and get it as a BSTR.
-//*****************************************************************************
-BOOL TypeLibExporter::GetStringCustomAttribute(
-    IMDInternalImport *pImport, 
-    LPCSTR     szName, 
-    mdToken     tk, 
-    BSTR        &bstrDescr)
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pImport));
-        PRECONDITION(CheckPointer(szName));
-    }
-    CONTRACTL_END;
-
-    HRESULT     hr;                     // A result.
-    const void  *pvData;                // Pointer to a custom attribute data.
-    ULONG       cbData;                 // Size of custom attribute data.
-    
-    // Look for the desired custom attribute.
-    IfFailReport(pImport->GetCustomAttributeByName(tk, szName,  &pvData,&cbData));
-    if (hr == S_OK && cbData > 2)
-    {
-        CustomAttributeParser cap(pvData, cbData);
-        IfFailReport(cap.SkipProlog());
-
-        LPCUTF8 szString;
-        ULONG   cbString;
-        IfFailReport(cap.GetString(&szString, &cbString));
-
-        bstrDescr = SysAllocStringLen(0, cbString); // allocates cbString+1 characters (appends '\0')
-        if (bstrDescr == NULL)
-            IfFailReport(E_OUTOFMEMORY);
-
-        if (cbString > 0)
-        {
-            ULONG cch = WszMultiByteToWideChar(CP_UTF8, 0, szString, cbString, bstrDescr, cbString);
-            bstrDescr[cch] = W('\0');
-        }
-
-        return TRUE;
-    }
-    
-    return FALSE;
-} // HRESULT GetStringCustomAttribute()
-
-//*****************************************************************************
-// Get the value for AutomationProxy for an object.  Return the default
-//  if there is no attribute.
-//*****************************************************************************
-BOOL TypeLibExporter::GetAutomationProxyAttribute(
-    IMDInternalImport *pImport, 
-    mdToken     tk, 
-    int         *bValue)
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pImport));
-        PRECONDITION(CheckPointer(bValue));
-    }
-    CONTRACTL_END;
-
-    HRESULT     hr;                     // A result.
-    const void  *pvData;                // Pointer to a custom attribute data.
-    ULONG       cbData;                 // Size of custom attribute data.
-
-    IfFailReport(pImport->GetCustomAttributeByName(tk, INTEROP_AUTOPROXY_TYPE, &pvData, &cbData));
-    if (hr == S_OK && cbData > 2)
-    {
-        CustomAttributeParser cap(pvData, cbData);
-        if (FAILED(cap.SkipProlog()))
-            return FALSE;
-
-        UINT8 u1;
-        if (FAILED(cap.GetU1(&u1)))
-            return FALSE;
-
-        *bValue = u1 != 0;
-    }
-
-    if (hr == S_OK)
-        return TRUE;
-
-    return FALSE;
-} // void TypeLibExporter::GetAutomationProxyAttribute()
-
-//*****************************************************************************
-// Create the IClassX ITypeInfo.
-//*****************************************************************************
-void TypeLibExporter::CreateIClassXITypeInfo(
-    CExportedTypesInfo *pData,          // Conversion data.
-    bool        bNamespace,             // If true, use namespace + name
-    bool        bResolveDup)            // If true, decorate name to resolve dups.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pData));
-    }
-    CONTRACTL_END;
-    
-    HRESULT     hr = S_OK;              // A result.
-    LPCUTF8     pName;                  // Name in UTF8.
-    LPCUTF8     pNS;                    // Namespace in UTF8.
-    SString     sName;                  // Name of the TypeDef.
-    SString     sNameTypeInfo;          // Name of the IClassX.
-    TYPEKIND    tkind;                  // The TYPEKIND of a TypeDef.
-    GUID        clsid;                  // A TypeDef's clsid.
-    DWORD       dwFlags;                // A TypeDef's flags.
-    LPWSTR      pSuffix;                // Pointer into the name.
-    int         iSuffix = 0;            // Counter for suffix.
-    GUID        guid = {0};             // A default interface's IID.
-    HREFTYPE    href;                   // href of base interface of IClassX.
-    mdTypeDef   td;                     // Token for the class.
-    CorClassIfaceAttr classItfType = clsIfNone; // For class interface type.
-    
-    VariantHolder vt;                           // For defining custom attribute.
-    SafeComHolder<ICreateTypeInfo> pCTITemp=0;  // For creating a typeinfo.
-    SafeComHolder<ITypeInfo>       pITemp=0;    // An ITypeInfo to get a name.
-    SafeComHolder<ITypeLib>        pITLB=0;     // For dup IID reporting.
-    SafeComHolder<ITypeInfo>       pITIDup=0;   // For dup IID reporting.
-    SafeComHolder<ICreateTypeInfo2> pCTI2=0;    // For creating the typeinfo.
-    BSTRHolder                     bstrName=0;     // An ITypeInfo's name.
-    BSTRHolder                     bstrDescr=0; // For description.
-    BSTRHolder                     bstrDup=0;   // For dup IID reporting.
-    ZeroHolder  zhType = &m_ErrorContext.m_pScope;              // Clear error reporting info.
-    
-    MethodTable* pClassOuter = pData->pClass;
-    
-    DefineFullyQualifiedNameForClassW();
-        
-    // Get the TypeDef and some info about it.
-    td = pData->pClass->GetCl();
-    IfFailReport(pData->pClass->GetMDImport()->GetTypeDefProps(td, &dwFlags, 0));
-    tkind = pData->tkind;
-    
-    // Error reporting info.
-    m_ErrorContext.m_tkType = td;
-    m_ErrorContext.m_pScope = pData->pClass->GetMDImport();
-    
-    // A CoClass needs an IClassX, and an alias kind needs an alias.
-    if (tkind != TKIND_COCLASS)
-        return;
-    
-    // Check to see if the type is supposed to be visible from COM. If it
-    // is not then we go to the next type.
-    if (!IsTypeVisibleFromCom(TypeHandle(pClassOuter)))
-        return;
-    
-    // Imported types don't need an IClassX.
-    if (IsTdImport(dwFlags))
-        return;
-    
-    // Check to see if we need to set up an IClassX for the class.
-    ClassHasIClassX(pData->pClass, &classItfType);
-    if (classItfType == clsIfNone)
-        return;
-    
-    // Get full name from metadata.
-    IfFailReport(pData->pClass->GetMDImport()->GetNameOfTypeDef(td, &pName, &pNS));
-    
-    // Get the GUID for the class.  Used to generate IClassX guid.
-    pData->pClass->GetGuid(&clsid, TRUE);
-
-    // Get the name of the class.  Use the ITypeInfo if there is one, except don't 
-    //  use the typeinfo for types which are Aliased.
-    if (pData->pCTI)
-    {
-        IfFailReport(SafeQueryInterface(pData->pCTI, IID_ITypeInfo, (IUnknown**)&pITemp));
-        IfFailReport(pITemp->GetDocumentation(MEMBERID_NIL, &bstrName, 0,0,0));
-        sName.Append(bstrName);
-    }
-    else
-    {
-        sName.AppendUTF8(pName);
-    }
-
-    // Create the typeinfo name for the IClassX
-    sNameTypeInfo.Set(cIClassX);
-    sNameTypeInfo.Append(sName);
-    
-    tkind = TKIND_INTERFACE;
-    pSuffix = 0;
-    for (;;)
-    {
-        // Try to create the TypeInfo.
-        hr = m_pICreateTLB->CreateTypeInfo((LPOLESTR)sNameTypeInfo.GetUnicode(), tkind, &pCTITemp);
-        
-        // If a name conflict, decorate, otherwise, done.
-        if (hr != TYPE_E_NAMECONFLICT)
-            break;
-            
-        if (!bResolveDup)
-        {
-            hr = S_FALSE;
-            return;
-        }
-                
-        if (iSuffix == 0)
-        {           
-            iSuffix = 2;
-        }
-        else
-        {
-            sNameTypeInfo.Delete(sNameTypeInfo.End()-=2, 2);            
-        }
-
-        SString sDup;
-        sDup.Printf(szDuplicateDecoration, iSuffix++);
-
-        sNameTypeInfo.Append(sDup);
-    }
-    
-    IfFailReport(hr);
-    IfFailReport(SafeQueryInterface(pCTITemp, IID_ICreateTypeInfo2, (IUnknown**)&pCTI2));
-    
-    // Generate the "IClassX" UUID and set it.
-    GenerateClassItfGuid(TypeHandle(pData->pClass), &guid);
-    hr = pCTI2->SetGuid(guid);
-    if (FAILED(hr))
-    {
-        if (hr == TYPE_E_DUPLICATEID)
-        {
-            IfFailReport(SafeQueryInterface(m_pICreateTLB, IID_ITypeLib, (IUnknown**)&pITLB));
-            IfFailReport(pITLB->GetTypeInfoOfGuid(guid, &pITIDup));
-            IfFailReport(pITIDup->GetDocumentation(MEMBERID_NIL, &bstrDup, 0,0,0));
-            InternalThrowHRWithContext(TLBX_E_DUPLICATE_IID, sNameTypeInfo.GetUnicode(), (BSTR)bstrDup);
-        }
-        return;
-    }
-
-    // Adding methods may cause an href to this typeinfo, which will cause it to be layed out.
-    //  Set the inheritance, so that nesting will be correct when that layout happens.
-    // Add IDispatch as impltype 0.
-    GetRefTypeInfo(pCTI2, m_pIDispatch, &href);
-    IfFailReport(pCTI2->AddImplType(0, href));
-
-    // Record the fully qualified type name in a custom attribute.
-    LPCWSTR szName = GetFullyQualifiedNameForClassNestedAwareW(pData->pClass);
-    V_VT(&vt) = VT_BSTR;
-    V_BSTR(&vt) = SysAllocString(szName);
-    if (V_BSTR(&vt) == NULL)
-        IfFailReport(E_OUTOFMEMORY);
-
-    IfFailReport(pCTI2->SetCustData(GUID_ManagedName, &vt));
-
-    TRACE("IClassX  %x: %ls, {%08x-%04x-%04x-%04x-%02x%02x%02x%02x}\n", pCTI2, sName, 
-        guid.Data1, guid.Data2, guid.Data3, guid.Data4[0]<<8|guid.Data4[1], guid.Data4[2], guid.Data4[3], guid.Data4[4], guid.Data4[5]); 
-
-    // If the class is decorated with a description, apply it to the typelib.
-    if(GetDescriptionString(pData->pClass, td, (BSTR &)bstrDescr))
-        IfFailReport(pCTI2->SetDocString(bstrDescr));
-    
-    // Transfer ownership of the pointer.
-    _ASSERTE(pData->pCTIClassItf == 0);
-    pData->pCTIClassItf = pCTI2;
-    pCTI2.SuppressRelease();
-    pCTI2 = 0;
-} // HRESULT TypeLibExporter::CreateIClassXITypeInfo()
-
-//*****************************************************************************
-// Add the impltypes to an ITypeInfo.
-//*****************************************************************************
-void TypeLibExporter::ConvertImplTypes(
-    CExportedTypesInfo *pData)          // Conversion data.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pData));
-    }
-    CONTRACTL_END;
-    
-    HRESULT     hr = S_OK;              // A result.
-    DWORD       dwFlags;                // A TypeDef's flags.
-    mdTypeDef   td;                     // Token for the class.
-    ZeroHolder  zhType = &m_ErrorContext.m_pScope;              // Clear error reporting info.
-    
-    // Get the TypeDef and some info about it.
-    td = pData->pClass->GetCl();
-    IfFailReport(pData->pClass->GetMDImport()->GetTypeDefProps(td, &dwFlags, 0));
-    
-    // Error reporting info.
-    m_ErrorContext.m_tkType = td;
-    m_ErrorContext.m_pScope = pData->pClass->GetMDImport();
-    
-    // If there is no ITypeInfo, skip it.
-    if (pData->pCTI == 0)
-        return;
-    
-    // Check to see if the type is supposed to be visible from COM. If it
-    // is not then we go to the next type.
-    if (!IsTypeVisibleFromCom(TypeHandle(pData->pClass)))
-        return;
-    
-    // Add the ImplTypes to the CoClass.
-    switch (pData->tkind)
-    {
-    case TKIND_INTERFACE:
-    case TKIND_DISPATCH:
-        // Add the base type to the interface.
-            ConvertInterfaceImplTypes(pData->pCTI, pData->pClass);
-        break;
-            
-    case TKIND_RECORD:
-    case TKIND_UNION:
-    case TKIND_ENUM:
-        // Nothing to do at this step.
-        break;
-            
-    case TKIND_COCLASS:
-        // Add the ImplTypes to the CoClass.
-            ConvertClassImplTypes(pData->pCTI, pData->pCTIClassItf, pData->pClass);
-        break;
-            
-    default:
-        _ASSERTE(!"Unknown TYPEKIND");
-            IfFailReport(E_INVALIDARG);
-        break;
-    }
-} // HRESULT TypeLibExporter::ConvertImplTypes()
-
-//*****************************************************************************
-// Convert the details (members) of an ITypeInfo.
-//*****************************************************************************
-void TypeLibExporter::ConvertDetails(
-    CExportedTypesInfo *pData)          // Conversion data.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pData));
-    }
-    CONTRACTL_END;
-    
-    HRESULT     hr = S_OK;              // A result.
-    DWORD       dwFlags;                // A TypeDef's flags.
-    mdTypeDef   td;                     // Token for the class.
-    ZeroHolder  zhType = &m_ErrorContext.m_pScope;              // Clear error reporting info.
-    
-    // Get the TypeDef and some info about it.
-    td = pData->pClass->GetCl();
-    IfFailReport(pData->pClass->GetMDImport()->GetTypeDefProps(td, &dwFlags, 0));
-    
-    // Error reporting info.
-    m_ErrorContext.m_tkType = td;
-    m_ErrorContext.m_pScope = pData->pClass->GetMDImport();
-    
-    // If there is no TypeInfo, skip it, but for CoClass need to populate IClassX.
-    if (pData->pCTI == 0 && pData->tkind != TKIND_COCLASS)
-        return;
-    
-    // Check to see if the type is supposed to be visible from COM. If it
-    // is not then we go to the next type.
-    if (!IsTypeVisibleFromCom(TypeHandle(pData->pClass)))
-        return;
-    
-    // Fill in the rest of the typeinfo for this typedef.
-    switch (pData->tkind)
-    {
-    case TKIND_INTERFACE:
-    case TKIND_DISPATCH:
-            ConvertInterfaceDetails(pData->pCTI, pData->pClass, pData->bAutoProxy);
-        break;
-            
-    case TKIND_RECORD:
-    case TKIND_UNION:
-            ConvertRecord(pData);
-        break;
-            
-    case TKIND_ENUM:
-            ConvertEnum(pData->pCTI, pData->pClass);
-        break;
-            
-    case TKIND_COCLASS:
-        // Populate the methods on the IClassX interface.
-            ConvertClassDetails(pData->pCTI, pData->pCTIClassItf, pData->pClass, pData->bAutoProxy);
-        break;
-            
-    default:
-        _ASSERTE(!"Unknown TYPEKIND");
-            IfFailReport(E_INVALIDARG);
-        break;
-    } // Switch (tkind)
-
-    // Report that this type has been converted.
-    SString ssType;
-    if (IsTdNested(dwFlags))
-    {
-        TypeNameBuilder tnb(&ssType, TypeNameBuilder::ParseStateNAME);
-        TypeString::AppendNestedTypeDef(tnb, m_ErrorContext.m_pScope, m_ErrorContext.m_tkType);
-    }
-    else
-        TypeString::AppendTypeDef(ssType, m_ErrorContext.m_pScope, m_ErrorContext.m_tkType);
-    ReportEvent(NOTIF_TYPECONVERTED, TLBX_I_TYPE_EXPORTED, ssType.GetUnicode());
-} // void TypeLibExporter::ConvertDetails()
-    
-//*****************************************************************************
-// Add the ImplTypes to the TypeInfo.
-//*****************************************************************************
-void TypeLibExporter::ConvertInterfaceImplTypes(
-    ICreateTypeInfo2 *pThisTypeInfo,    // The typeinfo being created.
-    MethodTable     *pClass)                // MethodTable for the TypeInfo.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pThisTypeInfo));
-        PRECONDITION(CheckPointer(pClass));
-    }
-    CONTRACTL_END;
-
-    HRESULT     hr = S_OK;
-    ULONG       ulIface;                // Is this interface [dual]?
-    HREFTYPE    href;                   // href of base interface.
-
-    // IDispatch or IUnknown derived?
-    IfFailReport(pClass->GetMDImport()->GetIfaceTypeOfTypeDef(pClass->GetCl(), &ulIface));
-
-    // Parent interface.
-    if (IsDispatchBasedItf((CorIfaceAttr)ulIface))
-    {
-        // Get the HREFTYPE for IDispatch.
-        GetRefTypeInfo(pThisTypeInfo, m_pIDispatch, &href);
-    }
-    else
-    {
-        // Get the HREFTYPE for IUnknown.
-        GetRefTypeInfo(pThisTypeInfo, m_pIUnknown, &href);
-    }
-
-    // Add the HREF as an interface.
-    IfFailReport(pThisTypeInfo->AddImplType(0, href));
-} // void TypeLibExporter::ConvertInterfaceImplTypes()
-
-
-//*****************************************************************************
-// Create the TypeInfo for an interface by iterating over functions.
-//*****************************************************************************
-void TypeLibExporter::ConvertInterfaceDetails (
-    ICreateTypeInfo2 *pThisTypeInfo,    // The typeinfo being created.
-    MethodTable     *pMT,                // MethodTable for the TypeInfo.
-    int         bAutoProxy)             // If true, oleaut32 is the interface's marshaller.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pThisTypeInfo));
-        PRECONDITION(CheckPointer(pMT));
-    }
-    CONTRACTL_END;
-    
-    HRESULT     hr = S_OK;
-    ULONG       ulIface;                // Is this interface [dual]?
-    DWORD       dwTIFlags=0;            // TypeLib flags.
-    int         cVisibleMembers = 0;    // The count of methods that are visible to COM.
-
-    // Retrieve the map of members.
-    ComMTMemberInfoMap MemberMap(pMT);
-
-    // IDispatch or IUnknown derived?
-    IfFailReport(pMT->GetMDImport()->GetIfaceTypeOfTypeDef(pMT->GetCl(), &ulIface));
-    
-    if (IsDispatchBasedItf((CorIfaceAttr)ulIface))
-    {
-        // IDispatch derived.
-        dwTIFlags |= TYPEFLAG_FDISPATCHABLE;
-        
-        if (ulIface == ifDual)
-            dwTIFlags |= TYPEFLAG_FDUAL | TYPEFLAG_FOLEAUTOMATION;
-        else
-            _ASSERTE(ulIface == ifDispatch);
-    }
-    else
-    {
-        // IUnknown derived.
-        dwTIFlags |= TYPEFLAG_FOLEAUTOMATION;
-    }
-    
-    if (!bAutoProxy)
-        dwTIFlags |= TYPEFLAG_FPROXY;
-
-    // Set appropriate flags.
-    IfFailReport(pThisTypeInfo->SetTypeFlags(dwTIFlags));
-
-    // Retrieve the method properties.
-    size_t sizeOfPtr = IsExportingAs64Bit() ? 8 : 4;
-    
-    MemberMap.Init(sizeOfPtr);
-    if (MemberMap.HadDuplicateDispIds())
-        ReportWarning(TLBX_I_DUPLICATE_DISPID, TLBX_I_DUPLICATE_DISPID);
-
-    // We need a scope to bypass the inialization skipped by goto ErrExit 
-    // compiler error.
-    {
-        CQuickArray<ComMTMethodProps> &rProps = MemberMap.GetMethods();
-
-        // Now add the methods to the TypeInfo.
-        MethodTable::MethodIterator it(pMT);
-        for (; it.IsValid(); it.Next())
-        {
-            if (it.IsVirtual())
-            {
-            // Only convert the method if it is visible from COM.
-                if (rProps[it.GetSlotNumber()].bMemberVisible)
-            {
-                    if (ConvertMethod(pThisTypeInfo, &rProps[it.GetSlotNumber()], cVisibleMembers, ulIface))
-                    cVisibleMembers++;
-                }
-            }
-        }
-    }
-} // void TypeLibExporter::ConvertInterfaceDetails()
-
-//*****************************************************************************
-// Export a Record to a TypeLib.
-//*****************************************************************************
-void TypeLibExporter::ConvertRecordBaseClass(
-    CExportedTypesInfo *pData,          // Conversion data.
-    MethodTable     *pSubMT,             // The base class.
-    ULONG       &ixVar)                 // Variable index in the typelib.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pData));
-        PRECONDITION(CheckPointer(pSubMT));
-    }
-    CONTRACTL_END;
-    
-    // The typeinfo being created.
-    ICreateTypeInfo2 *pThisTypeInfo = pData->pCTI;
-
-    HRESULT     hr = S_OK;              // A result.
-    mdFieldDef  fd;                     // A Field def.
-    ULONG       iFD;                    // Loop control.
-    ULONG       cFD;                    // Count of total MemberDefs.
-    DWORD       dwFlags;                // Field flags.
-    LPCUTF8     szName;                 // Name in UTF8.
-    LPCUTF8     szNamespace;            // A Namespace in UTF8.
-    SString     sName;                  // Name
-
-    // To enum fields.
-    HENUMInternalHolder eFDi(pSubMT->GetMDImport());
-
-    // If there is no class here, or if the class is Object, don't add members.
-    if (pSubMT == 0 ||
-        pSubMT == g_pObjectClass) 
-        return;
-
-    // If this class has a base class, export those members first.
-    ConvertRecordBaseClass(pData, pSubMT->GetParentMethodTable(), ixVar);
-
-    // Build the member name prefix.
-    IfFailReport(pSubMT->GetMDImport()->GetNameOfTypeDef(pSubMT->GetCl(), &szName, &szNamespace));
-    
-    sName.SetUTF8(szName);
-    sName.Append(W("_"));
-        
-    // Get an enumerator for the MemberDefs in the TypeDef.
-    eFDi.EnumInit(mdtFieldDef, pSubMT->GetCl());
-    cFD = pSubMT->GetMDImport()->EnumGetCount(&eFDi);
-
-    SString sNameMember;
-    // For each MemberDef...
-    for (iFD=0; iFD<cFD; ++iFD)
-    {
-        // Get the next field.
-        if (!pSubMT->GetMDImport()->EnumNext(&eFDi, &fd))
-        {
-            IfFailReport(E_UNEXPECTED);
-        }
-        
-        IfFailReport(pSubMT->GetMDImport()->GetFieldDefProps(fd, &dwFlags));
-        
-        // Only non-static fields.
-        if (!IsFdStatic(dwFlags))
-        {
-            IfFailReport(pSubMT->GetMDImport()->GetNameOfFieldDef(fd, &szName));
-            
-            sNameMember.Set(sName);
-            sNameMember.AppendUTF8(szName);
-            if (ConvertVariable(pThisTypeInfo, pSubMT, fd, sNameMember, ixVar))
-                ixVar++;
-        }
-    }
-} // void TypeLibExporter::ConvertRecordBaseClass()
-
-void TypeLibExporter::ConvertRecord(
-    CExportedTypesInfo *pData)          // Conversion data.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pData));
-    }
-    CONTRACTL_END;
-    
-    ICreateTypeInfo2 *pThisTypeInfo=pData->pCTI;     // The typeinfo being created.
-    MethodTable     *pMT=pData->pClass;               // MethodTable for the TypeInfo.
-
-    HRESULT     hr = S_OK;              // A result.
-    mdFieldDef  fd;                     // A Field def.
-    ULONG       iFD;                    // Loop control.
-    ULONG       ixVar=0;                // Index of current var converted.
-    ULONG       cFD;                    // Count of total MemberDefs.
-    DWORD       dwFlags;                // Field flags.
-    DWORD       dwPack;                 // Class pack size.
-    mdToken     tkExtends;              // A class's parent.
-    LPCUTF8     szName;                 // Name in UTF8.
-    SString     sName;                  // Name.
-
-    // To enum fields.
-    HENUMInternalHolder eFDi(pMT->GetMDImport());
-
-    // If the type is a struct, but it has explicit layout, don't export the members, 
-    //  because we can't export them accurately (unless they're really sequential).
-    if (pData->tkind == TKIND_RECORD)
-    {
-        IfFailReport(pMT->GetMDImport()->GetTypeDefProps(pMT->GetCl(), &dwFlags, &tkExtends));
-        
-        if (IsTdExplicitLayout(dwFlags))
-        {
-            ReportWarning(S_OK, TLBX_I_NONSEQUENTIALSTRUCT);
-            return;
-        }
-    }
-
-    // Set the packing size, if there is one.
-    dwPack = 0;
-    if (FAILED(pMT->GetMDImport()->GetClassPackSize(pMT->GetCl(), &dwPack)))
-    {
-        dwPack = 0;
-    }
-    if (dwPack == 0)
-    {
-        dwPack = DEFAULT_PACKING_SIZE;
-    }
-    
-    IfFailReport(pThisTypeInfo->SetAlignment((USHORT)dwPack));
-
-    // Haven't seen any non-public members yet.
-    m_bWarnedOfNonPublic = FALSE;
-
-    // If this class has a base class, export those members first.
-    ConvertRecordBaseClass(pData, pMT->GetParentMethodTable(), ixVar);
-
-    // Get an enumerator for the MemberDefs in the TypeDef.
-    eFDi.EnumInit(mdtFieldDef, pMT->GetCl());
-    cFD = pMT->GetMDImport()->EnumGetCount(&eFDi);
-
-    // For each MemberDef...
-    for (iFD=0; iFD<cFD; ++iFD)
-    {
-        // Get the next field.
-        if (!pMT->GetMDImport()->EnumNext(&eFDi, &fd))
-        {
-            IfFailReport(E_UNEXPECTED);
-        }
-        
-        IfFailReport(pMT->GetMDImport()->GetFieldDefProps(fd, &dwFlags));
-        
-        // Skip static fields.
-        if (IsFdStatic(dwFlags) == 0)
-        {
-            IfFailReport(pMT->GetMDImport()->GetNameOfFieldDef(fd, &szName));
-            
-            sName.SetUTF8(szName);
-            if (ConvertVariable(pThisTypeInfo, pMT, fd, sName, ixVar))
-                ixVar++;
-        }
-    }
-} // HRESULT TypeLibExporter::ConvertRecord()
-
-//*****************************************************************************
-// Export an Enum to a typelib.
-//*****************************************************************************
-void TypeLibExporter::ConvertEnum(
-    ICreateTypeInfo2 *pThisTypeInfo,    // The typeinfo being created.
-    MethodTable     *pMT)                // MethodTable for the TypeInfo.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pThisTypeInfo));
-        PRECONDITION(CheckPointer(pMT));
-    }
-    CONTRACTL_END;
-
-    HRESULT     hr = S_OK;              // A result.
-    mdFieldDef  fd;                     // A Field def.
-    DWORD       dwTIFlags=0;            // TypeLib flags.
-    ULONG       dwFlags;                // A field's flags.
-    ULONG       iFD;                    // Loop control.
-    ULONG       cFD;                    // Count of total MemberDefs.
-    ULONG       iVar=0;                 // Count of vars actually converted.
-    LPCUTF8     szName;                 // Name in UTF8.
-    SString     sName;                  // Name.
-    SafeComHolder<ITypeInfo> pThisTI=0; // TypeInfo for this ICreateITypeInfo.
-    BSTRHolder        szThisTypeInfo=0; // Name of this ITypeInfo.
-
-    IMDInternalImport* pImport = pMT->GetMDImport();
-
-    // To enum fields.    
-    HENUMInternalHolder eFDi(pImport);
-   
-    // Explicitly set the flags.
-    IfFailReport(pThisTypeInfo->SetTypeFlags(dwTIFlags));
-
-    // Get an enumerator for the MemberDefs in the TypeDef.
-    eFDi.EnumInit(mdtFieldDef, pMT->GetCl());
-    cFD = pImport->EnumGetCount(&eFDi);
-
-    // Build the member name prefix.  If generating an enum, get the real name from the default interface.
-    IfFailReport(SafeQueryInterface(pThisTypeInfo, IID_ITypeInfo, (IUnknown**)&pThisTI));
-    IfFailReport(pThisTI->GetDocumentation(MEMBERID_NIL, &szThisTypeInfo, 0,0,0));
-
-    sName.Set(szThisTypeInfo);
-    sName.Append(W("_"));
-
-    SString sNameMember;
-    // For each MemberDef...
-    for (iFD=0; iFD<cFD; ++iFD)
-    {
-        // Get the next field.
-        if (!pImport->EnumNext(&eFDi, &fd))
-        {
-            IfFailReport(E_UNEXPECTED);
-        }
-        
-        // Only convert static fields.
-        IfFailReport(pImport->GetFieldDefProps(fd, &dwFlags));
-        
-        if (IsFdStatic(dwFlags) == 0)
-        {
-            continue;
-        }
-        
-        // Skip ComVisible(false) members
-        if (!IsMemberVisibleFromCom(pMT, fd, mdTokenNil))
-        {
-            continue;
-        }
-
-        sNameMember.Set(sName);
-        IfFailReport(pImport->GetNameOfFieldDef(fd, &szName));
-        
-        sNameMember.AppendUTF8(szName);
-        
-        if (ConvertEnumMember(pThisTypeInfo, pMT, fd, sNameMember, iVar))
-        {
-            iVar++;
-        }
-    }
-} // void TypeLibExporter::ConvertEnum()
-
-//*****************************************************************************
-// Does a class have a default ctor?
-//*****************************************************************************
-BOOL TypeLibExporter::HasDefaultCtor(
-    MethodTable     *pMT)                // The class in question.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pMT));
-    }
-    CONTRACTL_END;
-
-    HRESULT     hr;                     // A result.
-    mdMethodDef md;                     // A method of the type.
-    DWORD       dwFlags;                // Method's flags.
-    ULONG       cMD;                    // Count of returned tokens.
-    ULONG       iMD;                    // Loop control.
-    PCCOR_SIGNATURE pSig;               // The signature.
-    ULONG       ixSig;                  // Index into signature.
-    ULONG       cbSig;                  // Size of the signature.
-    ULONG       callconv;               // Method's calling convention.
-    ULONG       cParams;                // Method's count of parameters.
-    BOOL        rslt=FALSE;             // Was one found?
-    LPCUTF8     pName;                  // Method name.
-
-    IMDInternalImport* pImport = pMT->GetMDImport();
-    
-    // To enum methods.
-    HENUMInternalHolder eMDi(pImport);
-
-    // Get an enumerator for the MemberDefs in the TypeDef.
-    eMDi.EnumInit(mdtMethodDef, pMT->GetCl());
-    cMD = pImport->EnumGetCount(&eMDi);
-
-    // For each MemberDef...
-    for (iMD=0; iMD<cMD; ++iMD)
-    {
-        // Get the next field.
-        if (!pImport->EnumNext(&eMDi, &md))
-        {
-            IfFailReport(E_UNEXPECTED);
-        }
-        
-        // Is the name special?  Is the method public?
-        IfFailReport(pImport->GetMethodDefProps(md, &dwFlags));
-        
-        if (!IsMdRTSpecialName(dwFlags) || !IsMdPublic(dwFlags))
-            continue;
-        
-        // Yes, is the name a ctor?
-        IfFailReport(pImport->GetNameOfMethodDef(md, &pName));
-        
-        if (!IsMdInstanceInitializer(dwFlags, pName))
-            continue;
-        
-        // It is a ctor.  Is it a default ctor?
-        IfFailReport(pImport->GetSigOfMethodDef(md, &cbSig, &pSig));
-        
-        // Skip the calling convention, and get the param count.
-        ixSig = CorSigUncompressData(pSig, &callconv);
-        CorSigUncompressData(&pSig[ixSig], &cParams);
-        
-        // Default ctor has zero params.
-        if (cParams == 0)
-        {
-            rslt = TRUE;
-            break;
-        }
-    }
-
-    return rslt;
-} // BOOL TypeLibExporter::HasDefaultCtor()
-
-//*****************************************************************************
-// Export a class to a TypeLib.
-//*****************************************************************************
-void TypeLibExporter::ConvertClassImplTypes(
-    ICreateTypeInfo2 *pThisTypeInfo,    // The typeinfo being created.
-    ICreateTypeInfo2 *pClassItfTypeInfo,// The ICLassX for the TypeInfo.
-    MethodTable     *pMT)                // MethodTable for the TypeInfo.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pThisTypeInfo, NULL_OK));
-        PRECONDITION(CheckPointer(pClassItfTypeInfo, NULL_OK));
-        PRECONDITION(CheckPointer(pMT));
-    }
-    CONTRACTL_END;
-    
-    HRESULT     hr = S_OK;
-    HREFTYPE    href;                   // HREF to a TypeInfo.
-    DWORD       dwFlags;                // Metadata flags.
-    int         flags=0;                // Flags for the interface impl or CoClass.
-    UINT        iImpl=0;                // Current Impl index.
-    MethodTable     *pIDefault = 0;         // Default interface, if any.
-    MethodTable *pDefItfMT = 0;         // Default interface method table, if any.
-    CQuickArray<MethodTable *> SrcItfList; // List of event sources.
-    CorClassIfaceAttr classItfType = clsIfNone; // For class interface type.
-    DefaultInterfaceType DefItfType;
-    TypeHandle hndDefItfClass;
-
-    SafeComHolder<ITypeInfo> pTI=0;                 // TypeInfo for default dispinterface.
-    SafeComHolder<ICreateTypeInfo2> pCTI2 = NULL;   // The ICreateTypeInfo2 interface used to define custom data.
-
-    // We should never be converting the class impl types of COM imported CoClasses.
-    _ASSERTE(!pMT->IsComImport());
-    
-    if (pThisTypeInfo)
-    {   
-        IfFailReport(pMT->GetMDImport()->GetTypeDefProps(pMT->GetCl(), &dwFlags, 0));
-        
-        // If abstract class, or no default ctor, don't make it creatable.
-        if (!IsTdAbstract(dwFlags) && HasDefaultCtor(pMT))
-            flags |= TYPEFLAG_FCANCREATE;
-        
-        // PreDeclid as appropriate.
-        IfFailReport(pThisTypeInfo->SetTypeFlags(flags));
-    }    
-
-    // Retrieve the MethodTable that represents the default interface.
-    DefItfType = GetDefaultInterfaceForClassWrapper(TypeHandle(pMT), &hndDefItfClass);
-
-    // Remember the MethodTable of the default interface.
-    pIDefault = hndDefItfClass.GetMethodTable();
-
-    // For some classes we synthesize an IClassX.  We don't do that for 
-    // configured class, classes imported from COM, 
-    // or for classes with an explicit default interface.
-    if (pClassItfTypeInfo)
-    {   
-        // Set the interface as the default for the class.
-        IfFailReport(SafeQueryInterface(pClassItfTypeInfo, IID_ITypeInfo, (IUnknown**)&pTI));
-        GetRefTypeInfo(pThisTypeInfo, pTI, &href);
-        IfFailReport(pThisTypeInfo->AddImplType(iImpl, href));
-
-        // If the class interface is the default interface, mark it as such.
-        if (pMT == pIDefault)
-            IfFailReport(pThisTypeInfo->SetImplTypeFlags(iImpl, IMPLTYPEFLAG_FDEFAULT));
-
-        // Increment the impl count.
-        ++iImpl;
-    }
-
-    // Go up the class hierarchy and add the IClassX's of the parent classes 
-    // as interfaces implemented by the COM component.
-    MethodTable *pParentClass = pMT->GetComPlusParentMethodTable();
-    while (pParentClass)
-    {
-        // If the parent class has an IClassX interface then add it.
-        ClassHasIClassX(pParentClass, &classItfType);
-        if (classItfType == clsIfAutoDual)
-        {
-            hr = EEClassToHref(pThisTypeInfo, pParentClass, FALSE, &href);
-
-            // If not IUnknown, add the HREF as an interface.
-            if (hr != S_USEIUNKNOWN)
-            {
-                IfFailReport(pThisTypeInfo->AddImplType(iImpl, href));
-                if (pParentClass == pIDefault)
-                    IfFailReport(pThisTypeInfo->SetImplTypeFlags(iImpl, IMPLTYPEFLAG_FDEFAULT));
-
-                ++iImpl;
-            }
-        }
-
-        // Process the next class up the hierarchy.
-        pParentClass = pParentClass->GetComPlusParentMethodTable();
-    }
-
-    ComCallWrapperTemplate *pClassTemplate = ComCallWrapperTemplate::GetTemplate(TypeHandle(pMT));
-    MethodTable::InterfaceMapIterator it = pMT->IterateInterfaceMap();
-    while (it.Next())
-    {
-        flags = 0;
-        
-        // Get the MethodTable for an implemented interface.
-        MethodTable *pIClass = it.GetInterface();
-        
-        // Retrieve the ComMethodTable for the interface.
-        ComMethodTable *pItfComMT = pClassTemplate->GetComMTForItf(pIClass);
-
-        // If the interface is visible from COM, add it.
-        if (IsTypeVisibleFromCom(TypeHandle(pIClass)) && !pItfComMT->IsComClassItf())
-        {
-#if defined(_DEBUG)
-            TRACE("Class %s implements %s\n", pMT->GetDebugClassName(), pIClass->GetDebugClassName());
-#endif
-            // Get an href for the managed class.
-            hr = EEClassToHref(pThisTypeInfo, pIClass, FALSE, &href);
-            
-            // If not IUnknown, add the HREF as an interface.
-            if (hr != S_USEIUNKNOWN)
-            {
-                if (pIClass == pIDefault)
-                    flags |= IMPLTYPEFLAG_FDEFAULT;
-
-                IfFailReport(pThisTypeInfo->AddImplType(iImpl, href));
-                IfFailReport(pThisTypeInfo->SetImplTypeFlags(iImpl, flags));
-                ++iImpl;
-            }
-        }
-        else if (!IsTypeVisibleFromCom(TypeHandle(pIClass)) && (pIClass == pIDefault))
-        {
-            // Report a warning if the default interface is not COM visible
-            ReportWarning(TLBX_W_DEFAULT_INTF_NOT_VISIBLE, TLBX_W_DEFAULT_INTF_NOT_VISIBLE);
-        }
-    }
-    
-    // Retrieve the list of COM source interfaces for the managed class.
-    GetComSourceInterfacesForClass(pMT, SrcItfList);
-        
-    // Add all the source interfaces to the CoClass.
-    flags = IMPLTYPEFLAG_FSOURCE | IMPLTYPEFLAG_FDEFAULT;
-    for (UINT i = 0; i < SrcItfList.Size(); i++)
-    {
-        hr = EEClassToHref(pThisTypeInfo, SrcItfList[i], FALSE, &href);
-
-        // If not IUnknown, add the HREF as an interface.
-        if (hr != S_USEIUNKNOWN)
-        {
-            IfFailReport(pThisTypeInfo->AddImplType(iImpl, href));
-            IfFailReport(pThisTypeInfo->SetImplTypeFlags(iImpl, flags));
-            ++iImpl;
-            flags = IMPLTYPEFLAG_FSOURCE;
-        }
-    }
-} // void TypeLibExporter::ConvertClassImplTypes()
-        
-//*****************************************************************************
-// Export a class to a TypeLib.
-//*****************************************************************************
-void TypeLibExporter::ConvertClassDetails(
-    ICreateTypeInfo2 *pThisTypeInfo,    // The typeinfo being created.
-    ICreateTypeInfo2 *pDefaultTypeInfo, // The ICLassX for the TypeInfo.
-    MethodTable     *pMT,                // MethodTable for the TypeInfo.
-    int         bAutoProxy)             // If true, oleaut32 is the proxy.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pThisTypeInfo, NULL_OK));
-        PRECONDITION(CheckPointer(pDefaultTypeInfo, NULL_OK));
-        PRECONDITION(CheckPointer(pMT));
-    }
-    CONTRACTL_END;
-
-    HRESULT             hr = S_OK;
-    CorClassIfaceAttr   classItfType = clsIfNone; 
-    
-    ClassHasIClassX(pMT, &classItfType);
-    if (classItfType == clsIfAutoDual)
-    {
-        // Set up the IClassX interface.
-        ConvertIClassX(pDefaultTypeInfo, pMT, bAutoProxy);
-    }
-    else if (pDefaultTypeInfo)
-    {
-        DWORD dwTIFlags = TYPEFLAG_FDUAL | TYPEFLAG_FOLEAUTOMATION | TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FHIDDEN;
-        if (!bAutoProxy)
-            dwTIFlags |= TYPEFLAG_FPROXY;
-        IfFailReport(pDefaultTypeInfo->SetTypeFlags(dwTIFlags));
-    }
-} // void TypeLibExporter::ConvertClassDetails()
-
-//*****************************************************************************
-// Create the DispInterface for the vtable that describes an entire class.
-//*****************************************************************************
-void TypeLibExporter::ConvertIClassX(
-    ICreateTypeInfo2 *pThisTypeInfo,     // The TypeInfo for the IClassX.
-    MethodTable     *pMT,                // The MethodTable object for the class.
-    int         bAutoProxy)             // If true, oleaut32 is the proxy.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pThisTypeInfo));
-        PRECONDITION(CheckPointer(pMT));
-    }
-    CONTRACTL_END;
-
-    HRESULT     hr = S_OK;              // A result.
-    DWORD       dwTIFlags=0;            // TypeLib flags.
-    DWORD       nSlots;                 // Number of vtable slots.
-    UINT        i;                      // Loop control.
-    int         cVisibleMembers = 0;    // The count of methods that are visible to COM.
-    ComMTMemberInfoMap MemberMap(pMT); // The map of members.
-
-    // Should be an actual class.
-    _ASSERTE(!pMT->IsInterface());
-
-    // Retrieve the method properties.
-    size_t sizeOfPtr = IsExportingAs64Bit() ? 8 : 4;
-    
-    MemberMap.Init(sizeOfPtr);
-    if (MemberMap.HadDuplicateDispIds())
-        ReportWarning(TLBX_I_DUPLICATE_DISPID, TLBX_I_DUPLICATE_DISPID);
-
-    // We need a scope to bypass the inialization skipped by goto ErrExit 
-    // compiler error.
-    {
-        CQuickArray<ComMTMethodProps> &rProps = MemberMap.GetMethods();
-        nSlots = (DWORD)rProps.Size();
-
-        dwTIFlags |= TYPEFLAG_FDUAL | TYPEFLAG_FOLEAUTOMATION | TYPEFLAG_FDISPATCHABLE | TYPEFLAG_FHIDDEN | TYPEFLAG_FNONEXTENSIBLE;
-        if (!bAutoProxy)
-            dwTIFlags |= TYPEFLAG_FPROXY;
-        IfFailReport(pThisTypeInfo->SetTypeFlags(dwTIFlags));
-
-        // Assign slot numbers.
-        for (i=0; i<nSlots; ++i)
-            rProps[i].oVft = (short)((7 + i) * sizeOfPtr);
-
-        // Now add the methods to the TypeInfo.
-        for (i=0; i<nSlots; ++i)
-        {
-            TRACE("[%d] %10ls pMeth:%08x, prop:%d, semantic:%d, dispid:0x%x, oVft:%d\n", i, rProps[i].pName, rProps[i].pMeth, 
-                    rProps[i].property, rProps[i].semantic, rProps[i].dispid, rProps[i].oVft);
-            if (rProps[i].bMemberVisible)
-            {
-                if (rProps[i].semantic < FieldSemanticOffset)
-                {
-                    if (ConvertMethod(pThisTypeInfo, &rProps[i], cVisibleMembers, ifDual))
-                        cVisibleMembers++;
-                }
-                else
-                {
-                    if (ConvertFieldAsMethod(pThisTypeInfo, &rProps[i], cVisibleMembers))
-                        cVisibleMembers++;
-                }
-            }
-        }
-    }
-} // void TypeLibExporter::ConvertIClassX()
-
-
-//*****************************************************************************
-// Export a Method's metadata to a typelib.
-//*****************************************************************************
-#ifdef _PREFAST_
-#pragma warning(push)
-#pragma warning(disable:21000) // Suppress PREFast warning about overly large function
-#endif
-BOOL TypeLibExporter::ConvertMethod(
-    ICreateTypeInfo2 *pCTI,             // ICreateTypeInfo2 to get the method.
-    ComMTMethodProps *pProps,           // Some properties of the method.
-    ULONG       iMD,                    // Index of the member
-    ULONG       ulIface)                // Is this interface : IUnknown, [dual], or DISPINTERFACE?
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pCTI));
-        PRECONDITION(CheckPointer(pProps));
-    }
-    CONTRACTL_END;
-
-    HRESULT     hr = S_OK;              // A result.
-    HRESULT     hrSignature = S_OK;     // A failure HR;
-    LPCUTF8     pszName;                // Name in UTF8.
-    SString     sName;                  // Holds name.
-    ULONG       dwImplFlags;            // The function's impl flags.
-    PCCOR_SIGNATURE pbSig;              // Pointer to Cor signature.
-    ULONG       cbSig;                  // Size of Cor signature.
-    ULONG       ixSig;                  // Index into signature.
-    ULONG       cbElem;                 // Size of an element in the signature.
-    ULONG       callconv;               // A member's calling convention.
-    ULONG       ret;                    // The return type.
-    ULONG       elem;                   // A signature element.
-    TYPEDESC    *pRetVal=0;             // Return type's TYPEDESC.
-    ULONG       cSrcParams;             // Count of source params.
-    ULONG       cDestParams = 0;        // Count of dest parameters.
-    USHORT      iSrcParam;              // Loop control, over params.
-    USHORT      iDestParam;             // Loop control, over params.
-    USHORT      iLCIDParam;             // The index of the LCID param.
-    ULONG       dwParamFlags;           // A parameter's flags.
-    CDescPool   sPool;                  // Pool of memory in which to build funcdesc.
-    CDescPool   sVariants;              // Pool of variants for default values.
-    PARAMDESCEX *pParamDesc;            // Pointer to one param default value.
-    int         bHrMunge=true;          // Munge return type to HRESULT?
-    CQuickArray<BSTR> rNames;           // Array of names to function and parameters.
-    ULONG       cNames=0;               // Count of function and parameter names.
-    FUNCDESC    *pfunc = NULL;          // A funcdesc.
-    MethodDesc  *pMeth;                 // A MethodDesc.
-    IMDInternalImport *pInternalImport; // Internal interface containing the method.
-    MDDefaultValue defaultValue;        // place holder for default value
-    PCCOR_SIGNATURE pvNativeType;       // native parameter type
-    ULONG           cbNativeType = 0;   // native parameter type length
-    MethodTable     *pMT;                // Class containing the method.
-    int         bHasOptorDefault=false; // If true, the method has optional params or default values -- no vararg
-    const void  *pvData;                // Pointer to a custom attribute.
-    ULONG       cbData;                 // Size of custom attribute.
-    BOOL        bByRef;                 // Is a parameter byref?
-    BSTRHolder        bstrDescr=0;             // Description of the method.
-    VariantHolder vtManagedName;        // Variant used to set the managed name of the member.
-    
-    ZeroHolder  zhParam = &m_ErrorContext.m_szParam;    // Clear error reporting info.
-    ZeroHolder  zhMember = &m_ErrorContext.m_szMember;  // Clear error reporting info.
-
-    // Get info about the method.
-    pMeth = pProps->pMeth;
-    pMeth->GetSig(&pbSig, &cbSig);
-    pInternalImport = pMeth->GetMDImport();
-    pMT = pMeth->GetMethodTable();
-    IfFailReport(pInternalImport->GetMethodImplProps(pMeth->GetMemberDef(), 0, &dwImplFlags));
-    
-    // Error reporting info.
-    IfFailReport(pInternalImport->GetNameOfMethodDef(pMeth->GetMemberDef(), &m_ErrorContext.m_szMember));
-    
-    // Allocate one variant.
-    pParamDesc = reinterpret_cast<PARAMDESCEX*>(sVariants.AllocZero(sizeof(PARAMDESCEX)));
-    if(NULL == pParamDesc)
-        IfFailReport(E_OUTOFMEMORY);
-
-    // Prepare to parse signature and build the FUNCDESC.
-    pfunc = reinterpret_cast<FUNCDESC*>(sPool.AllocZero(sizeof(FUNCDESC)));
-    if (pfunc == NULL)
-        IfFailReport(E_OUTOFMEMORY);
-    
-    ixSig = 0;
-
-    // Get the calling convention.
-    ixSig += CorSigUncompressData(&pbSig[ixSig], &callconv);
-    _ASSERTE((callconv & IMAGE_CEE_CS_CALLCONV_MASK) != IMAGE_CEE_CS_CALLCONV_FIELD);
-    pfunc->callconv = Clr2TlbCallConv[callconv & IMAGE_CEE_CS_CALLCONV_MASK];
-
-    // vtable offset.
-    pfunc->oVft = pProps->oVft;
-
-    // Get the argument count.  Allow for an extra in case of [retval].
-    ixSig += CorSigUncompressData(&pbSig[ixSig], &cSrcParams);
-    cDestParams = cSrcParams;
-    rNames.ReSizeThrows(cDestParams+3);
-    memset(rNames.Ptr(), 0, (cDestParams+3) * sizeof(BSTR));
-
-    // Set some method properties.
-    pfunc->memid = pProps->dispid;
-    if (pfunc->memid == -11111) //@todo: fix for msvbalib.dll
-        pfunc->memid = -1;
-    pfunc->funckind = FUNC_PUREVIRTUAL;
-
-    // Set the invkind based on whether the function is an accessor.
-    if (pProps->semantic == 0)
-        pfunc->invkind = INVOKE_FUNC;
-    else if (pProps->semantic == msGetter)
-        pfunc->invkind = INVOKE_PROPERTYGET;
-    else if (pProps->semantic == msSetter)
-        pfunc->invkind = INVOKE_PROPERTYPUTREF;
-    else if (pProps->semantic == msOther)
-        pfunc->invkind = INVOKE_PROPERTYPUT;
-    else
-        pfunc->invkind = INVOKE_FUNC; // non-accessor property function.
-
-    rNames[0] = pProps->pName;
-    cNames = 1;
-    
-    // Convert return type to elemdesc.  If we are doing HRESULT munging, we need to 
-    //  examine the return type, and if it is not VOID, create an additional final 
-    //  parameter as a pointer to the type.
-
-    // Get the return type.  
-    cbElem = CorSigUncompressData(&pbSig[ixSig], &ret);
-
-    // Error reporting info.
-    m_ErrorContext.m_ixParam = 0;
-    
-    // Get native type of return if available
-    mdParamDef pdParam;
-    pvNativeType = NULL;
-    hr = pInternalImport->FindParamOfMethod(pMeth->GetMemberDef(), 0, &pdParam);
-    if (hr == S_OK)
-    {
-        hr = pInternalImport->GetFieldMarshal(pdParam, &pvNativeType, &cbNativeType);
-        if (hr != CLDB_E_RECORD_NOTFOUND)
-        {
-            IfFailReport(hr);
-        }
-    }
-    
-    // Determine if we need to do HRESULT munging.
-    bHrMunge = !IsMiPreserveSig(dwImplFlags);
-    
-    // Reset some properties for DISPINTERFACES.
-    if (ulIface == ifDispatch)
-    {
-        pfunc->callconv = CC_STDCALL;
-        pfunc->funckind = FUNC_DISPATCH;
-        
-        // Never munge a dispinterface.
-        bHrMunge = false;
-    }
-    
-    if (bHrMunge)
-    {
-        // Munge the return type into a new last param, set return type to HRESULT.
-        pfunc->elemdescFunc.tdesc.vt = VT_HRESULT;
-        
-        // Does the function actually return anything?
-        if (ret == ELEMENT_TYPE_VOID)
-        {
-            // Skip over the return value, no [retval].
-            pRetVal = 0;
-            ixSig += cbElem;
-        }
-        else
-        {
-            // Allocate a TYPEDESC to be pointed to, convert type into it.
-            pRetVal = reinterpret_cast<TYPEDESC*>(sPool.AllocZero(sizeof(TYPEDESC)));       
-            if (pRetVal == NULL)
-                IfFailReport(E_OUTOFMEMORY);
-            
-            hr = CorSigToTypeDesc(pCTI, pMT, &pbSig[ixSig], pvNativeType, cbNativeType, &cbElem, pRetVal, &sPool, TRUE);
-            if (FAILED(hr))
-                return FALSE;
-            
-            ixSig += cbElem;
-
-            ++cDestParams;
-            // It is pretty weird for a property putter to return something, but apparenly legal.
-            //_ASSERTE(pfunc->invkind != INVOKE_PROPERTYPUT && pfunc->invkind != INVOKE_PROPERTYPUTREF);
-
-            // Todo:  When the C compiler tries to import a typelib with a C 
-            // array return type (even if it's a retval), 
-            // it generates a wrapper method with a signature like "int [] foo()", 
-            // which isn't valid C, so it barfs.  So, we'll change the return type 
-            // to a pointer by hand.
-            if (pRetVal->vt == VT_CARRAY)
-            {
-                pRetVal->vt = VT_PTR;
-                pRetVal->lptdesc = &pRetVal->lpadesc->tdescElem;
-            }
-        }
-    }
-    else
-    {
-        // No munging, convert return type.
-        pRetVal = 0;
-        hr = CorSigToTypeDesc(pCTI, pMT, &pbSig[ixSig], pvNativeType, cbNativeType, &cbElem, &pfunc->elemdescFunc.tdesc, &sPool, TRUE);
-        if (FAILED(hr))
-            return FALSE;
-        
-        ixSig += cbElem;
-    }
-
-    // Error reporting info.
-    m_ErrorContext.m_ixParam = -1;
-    
-    // Check to see if there is an LCIDConversion attribute on the method.
-    iLCIDParam = (USHORT)GetLCIDParameterIndex(pMeth);
-    if (iLCIDParam != (USHORT)-1)
-    {
-        BOOL bValidLCID = TRUE;
-
-        // Make sure the parameter index is valid.
-        if (iLCIDParam > cSrcParams)
-        {
-            ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_INVALIDLCIDPARAM);
-            bValidLCID = FALSE;
-        }
-
-        // LCID's are not allowed on pure dispatch interfaces.
-        if (ulIface == ifDispatch)
-        {
-            ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_LCIDONDISPONLYITF);
-            bValidLCID = FALSE;
-        }
-
-        if (bValidLCID)
-        {
-            // Take the LCID parameter into account in the exported method.
-            ++cDestParams;
-        }
-        else
-        {
-            // The LCID is invalid so we will ignore it.
-            iLCIDParam = -1;
-        }
-    }
-
-    // for each parameter
-    pfunc->lprgelemdescParam = reinterpret_cast<ELEMDESC*>(sPool.AllocZero(cDestParams * sizeof(ELEMDESC)));
-    if (pfunc->lprgelemdescParam == NULL)
-        IfFailReport(E_OUTOFMEMORY);
-    
-    // Holds the allocated strings so we can deallocate on function exit.
-    //  Only need +1 as we don't clean up the first and last names (function name and retval)
-    NewArrayHolder<BSTRHolder> namesHolder = new BSTRHolder[cDestParams+1];
-    
-    // Variant array used to hold default value data
-    NewArrayHolder<VariantPtrHolder> vtDefaultValues = new VariantPtrHolder[cDestParams];
-
-    pfunc->cParams = static_cast<short>(cDestParams);
-    for (iSrcParam=1, iDestParam=0; iDestParam<cDestParams; ++iSrcParam, ++iDestParam)
-    {   
-        // Check to see if we need to insert the LCID param before the current param.
-        if (iLCIDParam == iDestParam)
-        {
-            // Set the flags and the type of the parameter.
-            pfunc->lprgelemdescParam[iDestParam].paramdesc.wParamFlags = PARAMFLAG_FIN | PARAMFLAG_FLCID;
-            pfunc->lprgelemdescParam[iDestParam].tdesc.vt = VT_I4;
-
-            // Generate a parameter name.
-            sName.Printf(szParamName, iDestParam + 1);
-
-            rNames[iDestParam + 1] = SysAllocString(sName.GetUnicode());
-            if (rNames[iDestParam + 1] == NULL)
-                IfFailReport(E_OUTOFMEMORY);
-
-            namesHolder[iDestParam+1] = rNames[iDestParam + 1];
-            
-            ++cNames;
-
-            // Increment the current destination parameter.
-            ++iDestParam;
-        }
-
-        // If we are past the end of the source parameters then we are done.
-        if (iSrcParam > cSrcParams)
-            break;
-
-        // Get additional parameter metadata.
-        dwParamFlags = 0;
-        sName.Clear();
-
-        // Error reporting info.
-        m_ErrorContext.m_ixParam = iSrcParam;
-        
-        // See if there is a ParamDef for this param.
-        hr = pInternalImport->FindParamOfMethod(pMeth->GetMemberDef(), iSrcParam, &pdParam);
-
-        pvNativeType = NULL;
-        if (hr == S_OK)
-        {   
-            // Get info about the param.        
-            IfFailReport(pInternalImport->GetParamDefProps(pdParam, &iSrcParam, &dwParamFlags, &pszName));
-            
-            // Error reporting info.
-            m_ErrorContext.m_szParam = pszName;
-            
-            // Turn off reserved (internal use) bits.
-            dwParamFlags &= ~pdReservedMask;
-
-            // Convert name from UTF8 to unicode.
-            sName.SetUTF8(pszName);
-
-            // Param default value, if any.
-            IfFailReport(pInternalImport->GetDefaultValue(pdParam, &defaultValue));
-            IfFailReport(_FillVariant(&defaultValue, &pParamDesc->varDefaultValue));
-
-            // If no default value, check for decimal custom attribute.
-            if (pParamDesc->varDefaultValue.vt == VT_EMPTY)
-            {
-                IfFailReport(pMT->GetMDImport()->GetCustomAttributeByName(pdParam, INTEROP_DECIMALVALUE_TYPE,  &pvData,&cbData));
-                if (hr == S_OK && cbData >= (2 + sizeof(BYTE)+sizeof(BYTE)+sizeof(UINT)+sizeof(UINT)+sizeof(UINT)))
-                {
-                    const BYTE *pbData = (const BYTE *)pvData;
-                    pParamDesc->varDefaultValue.vt = VT_DECIMAL;
-                    pParamDesc->varDefaultValue.decVal.scale = *(BYTE*)(pbData+2);
-                    pParamDesc->varDefaultValue.decVal.sign= *(BYTE*)(pbData+3);
-                    pParamDesc->varDefaultValue.decVal.Hi32= GET_UNALIGNED_32(pbData+4);
-                    pParamDesc->varDefaultValue.decVal.Mid32= GET_UNALIGNED_32(pbData+8);
-                    pParamDesc->varDefaultValue.decVal.Lo32= GET_UNALIGNED_32(pbData+12);
-                }
-            }
-            // If still no default value, check for date time custom attribute.
-            if (pParamDesc->varDefaultValue.vt == VT_EMPTY)
-            {
-                IfFailReport(pMT->GetMDImport()->GetCustomAttributeByName(pdParam, INTEROP_DATETIMEVALUE_TYPE,  &pvData,&cbData));
-                if (hr == S_OK && cbData >= (2 + sizeof(__int64)))
-                {
-                    const BYTE *pbData = (const BYTE *)pvData;
-                    pParamDesc->varDefaultValue.vt = VT_DATE;
-                    pParamDesc->varDefaultValue.date = _TicksToDoubleDate(GET_UNALIGNED_64(pbData+2));
-                }
-            }
-            // If still no default value, check for IDispatch custom attribute.
-            if (pParamDesc->varDefaultValue.vt == VT_EMPTY)
-            {
-                IfFailReport(pMT->GetMDImport()->GetCustomAttributeByName(pdParam, INTEROP_IDISPATCHVALUE_TYPE,  &pvData,&cbData));
-                if (hr == S_OK)
-                {
-                    pParamDesc->varDefaultValue.vt = VT_DISPATCH;
-                    pParamDesc->varDefaultValue.pdispVal = 0;
-                }
-            }
-            // If still no default value, check for IUnknown custom attribute.
-            if (pParamDesc->varDefaultValue.vt == VT_EMPTY)
-            {
-                IfFailReport(pMT->GetMDImport()->GetCustomAttributeByName(pdParam, INTEROP_IUNKNOWNVALUE_TYPE,  &pvData,&cbData));
-                if (hr == S_OK)
-                {
-                    pParamDesc->varDefaultValue.vt = VT_UNKNOWN;
-                    pParamDesc->varDefaultValue.punkVal = 0;
-                }
-            }
-            
-            if (pParamDesc->varDefaultValue.vt != VT_EMPTY)
-            {
-                // Copy the variant into the holder object so we release on function exit.
-                vtDefaultValues[iDestParam] = (VARIANT*)&pParamDesc->varDefaultValue;
-                
-                pfunc->lprgelemdescParam[iDestParam].paramdesc.pparamdescex = pParamDesc;
-                dwParamFlags |= PARAMFLAG_FHASDEFAULT;
-
-                // Allocate another paramdesc.
-                pParamDesc = reinterpret_cast<PARAMDESCEX*>(sVariants.AllocZero(sizeof(PARAMDESCEX)));
-                if (pParamDesc == NULL)
-                    IfFailReport(E_OUTOFMEMORY);
-                
-                bHasOptorDefault = true;
-            }
-
-            // native marshal type, if any.
-            hr = pInternalImport->GetFieldMarshal(pdParam, &pvNativeType, &cbNativeType);
-            if (hr != CLDB_E_RECORD_NOTFOUND)
-            {
-                IfFailReport(hr);
-            }
-            
-            // Remember if there are optional params.
-            if (dwParamFlags & PARAMFLAG_FOPT)
-                bHasOptorDefault = true;
-        }
-        else
-        {
-            pdParam = 0, m_ErrorContext.m_szParam = 0;
-        }
-        
-        // Do we need a name for this parameter?
-        if ((pfunc->invkind & (INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF)) == 0 ||
-            iSrcParam < cSrcParams)
-        {
-            // Yes, so make one up if we don't have one.
-            if (sName.GetCount() == 0) 
-            {
-                sName.Printf(szParamName, iDestParam + 1);
-            }
-
-            rNames[iDestParam + 1] = SysAllocString(sName.GetUnicode());
-            if (rNames[iDestParam + 1] == NULL)
-                IfFailReport(E_OUTOFMEMORY);
-
-            namesHolder[iDestParam+1] = rNames[iDestParam + 1];
-            
-            ++cNames;
-        }
-
-        // Save the element type.
-        CorSigUncompressData(&pbSig[ixSig], &elem);
-        
-        // Convert the param info to elemdesc.
-        bByRef = FALSE;
-        hr = CorSigToTypeDesc(pCTI, pMT, &pbSig[ixSig], pvNativeType, cbNativeType, &cbElem,
-                            &pfunc->lprgelemdescParam[iDestParam].tdesc, &sPool, TRUE, &bByRef);
-        if (FAILED(hr))
-            return FALSE;
-        
-        ixSig += cbElem;
-
-        // If there is no [in,out], set one, based on the parameter.
-        if ((dwParamFlags & (PARAMFLAG_FOUT | PARAMFLAG_FIN)) == 0)
-        {
-            // If param is by reference, make in/out
-            if (bByRef)
-                dwParamFlags |= PARAMFLAG_FIN | PARAMFLAG_FOUT;
-            else
-                dwParamFlags |= PARAMFLAG_FIN;
-        }
-
-        // If this is the last param, and it an array of objects, and has a ParamArrayAttribute,
-        //  the function is varargs.
-        if ((iSrcParam == cSrcParams) && !IsNilToken(pdParam) && !bHasOptorDefault) 
-        {
-            if (pfunc->lprgelemdescParam[iDestParam].tdesc.vt == VT_SAFEARRAY &&
-                pfunc->lprgelemdescParam[iDestParam].tdesc.lpadesc->tdescElem.vt == VT_VARIANT)
-            {
-                if (pInternalImport->GetCustomAttributeByName(pdParam, INTEROP_PARAMARRAY_TYPE, 0,0) == S_OK)
-                    pfunc->cParamsOpt = -1;
-            }
-        }
-        
-        pfunc->lprgelemdescParam[iDestParam].paramdesc.wParamFlags = static_cast<USHORT>(dwParamFlags);
-    }
-
-    // Is there a [retval]?
-    if (pRetVal)
-    {
-        // Error reporting info.
-        m_ErrorContext.m_ixParam = 0;
-        m_ErrorContext.m_szParam = 0;
-        
-        _ASSERTE(bHrMunge);
-        _ASSERTE(cDestParams > cSrcParams);
-        pfunc->lprgelemdescParam[cDestParams-1].tdesc.vt = VT_PTR;
-        pfunc->lprgelemdescParam[cDestParams-1].tdesc.lptdesc = pRetVal;
-        pfunc->lprgelemdescParam[cDestParams-1].paramdesc.wParamFlags = PARAMFLAG_FOUT | PARAMFLAG_FRETVAL;
-
-        // no need to allocate a new string for this.  rather use the constant szRetVal
-        rNames[cDestParams] = (LPWSTR)szRetVal;
-
-        ++cNames;
-    }
-
-    // Error reporting info.
-    m_ErrorContext.m_ixParam = -1;
-    
-    // Was there a signature error?  If so, exit now that all sigs have been reported.
-    IfFailReport(hrSignature);
-    
-    IfFailReport(pCTI->AddFuncDesc(iMD, pfunc));
-
-    IfFailReport(pCTI->SetFuncAndParamNames(iMD, rNames.Ptr(), cNames));
-
-    if (pProps->bFunction2Getter)
-    {
-        VARIANT vtOne;
-        vtOne.vt = VT_I4;
-        vtOne.lVal = 1;
-        IfFailReport(pCTI->SetFuncCustData(iMD, GUID_Function2Getter, &vtOne));
-    }
-
-    // If the managed name of the method is different from the unmanaged name, then
-    // we need to capture the managed name in a custom value. We only apply this
-    // attribute for methods since properties cannot be overloaded.
-    if (pProps->semantic == 0)
-    {
-        sName.SetUTF8(pMeth->GetName());
-        if (sName.Compare(SString(pProps->pName)) != 0)
-        {
-            V_VT(&vtManagedName) = VT_BSTR;
-
-            if (NULL == (V_BSTR(&vtManagedName) = SysAllocString(sName.GetUnicode())))
-                IfFailReport(E_OUTOFMEMORY);
-
-            IfFailReport(pCTI->SetFuncCustData(iMD, GUID_ManagedName, &vtManagedName));
-        }
-    }
-
-    // Check for a description.
-    if(GetDescriptionString(pMT, pMeth->GetMemberDef(), (BSTR &)bstrDescr))
-        IfFailReport(pCTI->SetFuncDocString(iMD, bstrDescr));
-    
-
-    // Error reporting info.
-    m_ErrorContext.m_szMember = 0;
-    m_ErrorContext.m_szParam = 0;
-    m_ErrorContext.m_ixParam = -1;
-
-    return TRUE;
-} // void TypeLibExporter::ConvertMethod()
-#ifdef _PREFAST_
-#pragma warning(pop)
-#endif
-    
-//*****************************************************************************
-// Export a Field as getter/setter method's to a typelib.
-//*****************************************************************************
-BOOL TypeLibExporter::ConvertFieldAsMethod(
-    ICreateTypeInfo2 *pCTI,             // ICreateTypeInfo2 to get the method.
-    ComMTMethodProps *pProps,           // Some properties of the method.
-    ULONG       iMD)                    // Index of the member
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pCTI));
-        PRECONDITION(CheckPointer(pProps));
-    }
-    CONTRACTL_END;
-
-    HRESULT     hr = S_OK;              // A result.
-    PCCOR_SIGNATURE pbSig;              // Pointer to Cor signature.
-    ULONG       cbSig;                  // Size of Cor signature.
-    ULONG       ixSig;                  // Index into signature.
-    ULONG       cbElem;                 // Size of an element in the signature.
-
-    ULONG       callconv;               // A member's calling convention.
-    TYPEDESC    *pType;                 // TYPEDESC for the field type.
-    CDescPool   sPool;                  // Pool of memory in which to build funcdesc.
-    BSTR        rNames[2];              // Array of names to function and parameters.
-    ULONG       cNames;                 // Count of function and parameter names.
-    FUNCDESC    *pfunc;                 // A funcdesc.
-    ComCallMethodDesc   *pFieldMeth;    // A MethodDesc for a field call.
-    FieldDesc   *pField;                // A FieldDesc.
-    IMDInternalImport *pInternalImport; // Internal interface containing the field.
-    PCCOR_SIGNATURE pvNativeType;       // native field type
-    ULONG           cbNativeType;       // native field type length
-    MethodTable     *pMT;                // Class containing the field.
-    BSTRHolder  bstrDescr=0;            // Description of the method.
-
-    // Get info about the method.
-    pFieldMeth = reinterpret_cast<ComCallMethodDesc*>(pProps->pMeth);
-    pField = pFieldMeth->GetFieldDesc();
-    pField->GetSig(&pbSig, &cbSig);
-    pInternalImport = pField->GetMDImport();
-    pMT = pField->GetEnclosingMethodTable();
-
-    // Error reporting info.
-    IfFailReport(pMT->GetMDImport()->GetNameOfFieldDef(pField->GetMemberDef(), &m_ErrorContext.m_szMember));
-    
-    // Prepare to parse signature and build the FUNCDESC.
-    pfunc = reinterpret_cast<FUNCDESC*>(sPool.AllocZero(sizeof(FUNCDESC)));
-    if (NULL == pfunc)
-        IfFailReport(E_OUTOFMEMORY);
-    ixSig = 0;
-
-    // Get the calling convention.
-    ixSig += CorSigUncompressData(&pbSig[ixSig], &callconv);
-    _ASSERTE(callconv == IMAGE_CEE_CS_CALLCONV_FIELD);
-    pfunc->callconv = CC_STDCALL;
-
-    // vtable offset.
-    pfunc->oVft = pProps->oVft;
-
-    // Set some method properties.
-    pfunc->memid = pProps->dispid;
-    pfunc->funckind = FUNC_PUREVIRTUAL;
-
-    // Set the invkind based on whether the function is an accessor.
-    if ((pProps->semantic - FieldSemanticOffset) == msGetter)
-        pfunc->invkind = INVOKE_PROPERTYGET;
-    else if ((pProps->semantic - FieldSemanticOffset) == msSetter)
-    {
-        if (IsVbRefType(&pbSig[ixSig], pInternalImport))
-            pfunc->invkind = INVOKE_PROPERTYPUTREF;
-        else
-            pfunc->invkind = INVOKE_PROPERTYPUT;
-    }
-    else
-        _ASSERTE(!"Incorrect semantic in ConvertFieldAsMethod");
-
-    // Name of the function.
-    rNames[0] = pProps->pName;
-    cNames = 1;
-
-    // Return type is HRESULT.
-    pfunc->elemdescFunc.tdesc.vt = VT_HRESULT;
-
-    // Set up the one and only parameter.
-    pfunc->lprgelemdescParam = reinterpret_cast<ELEMDESC*>(sPool.AllocZero(sizeof(ELEMDESC)));
-    if (NULL == pfunc->lprgelemdescParam)
-        IfFailReport(E_OUTOFMEMORY);
-    pfunc->cParams = 1;
-
-    // Do we need a name for the parameter?  If PROPERTYGET, we do.
-    if (pfunc->invkind == INVOKE_PROPERTYGET)
-    {
-        // Yes, so make one up.
-        rNames[1] = (WCHAR*)szRetVal;
-        ++cNames;
-    }
-
-    // If Getter, convert param as ptr, otherwise convert directly.
-    if (pfunc->invkind == INVOKE_PROPERTYGET)
-    {
-        pType = reinterpret_cast<TYPEDESC*>(sPool.AllocZero(sizeof(TYPEDESC)));
-        if (NULL == pType)
-            IfFailReport(E_OUTOFMEMORY);
-
-        pfunc->lprgelemdescParam[0].tdesc.vt = VT_PTR;
-        pfunc->lprgelemdescParam[0].tdesc.lptdesc = pType;
-        pfunc->lprgelemdescParam[0].paramdesc.wParamFlags = PARAMFLAG_FOUT | PARAMFLAG_FRETVAL;
-    }
-    else
-    {
-        pType = &pfunc->lprgelemdescParam[0].tdesc;
-        pfunc->lprgelemdescParam[0].paramdesc.wParamFlags = PARAMFLAG_FIN;
-    }
-
-    // Get native field type
-    pvNativeType = NULL;
-    hr = pInternalImport->GetFieldMarshal(
-        pField->GetMemberDef(), 
-        &pvNativeType, 
-        &cbNativeType);
-    if (hr != CLDB_E_RECORD_NOTFOUND)
-    {
-        IfFailReport(hr);
-    }
-    
-    // Convert the field type to elemdesc.
-    hr = CorSigToTypeDesc(pCTI, pMT, &pbSig[ixSig], pvNativeType, cbNativeType, &cbElem, pType, &sPool, TRUE);
-    if (FAILED(hr))
-        return FALSE;
-
-    ixSig += cbElem;
-
-    // It is unfortunate that we can not handle this better.  Fortunately
-    //  this should be very rare.
-    // This is a weird case - if we're getting a CARRAY, we cannot add
-    // a VT_PTR in the sig, as it will cause the C getter to return an
-    // array, which is bad.  So we omit the extra pointer, which at least
-    // makes the compiler happy.
-    if (pfunc->invkind == INVOKE_PROPERTYGET
-        && pType->vt == VT_CARRAY)
-    {
-        pfunc->lprgelemdescParam[0].tdesc.vt = pType->vt;
-        pfunc->lprgelemdescParam[0].tdesc.lptdesc = pType->lptdesc;
-    }
-
-    // A property put of an object should be a propertyputref
-    if (pfunc->invkind == INVOKE_PROPERTYPUT &&
-        (pType->vt == VT_UNKNOWN || pType->vt == VT_DISPATCH))
-    {
-        pfunc->invkind = INVOKE_PROPERTYPUTREF;
-    }
-    
-    IfFailReport(pCTI->AddFuncDesc(iMD, pfunc));
-
-    IfFailReport(pCTI->SetFuncAndParamNames(iMD, rNames, cNames));
-
-    // Check for a description.
-    if(GetDescriptionString(pMT, pField->GetMemberDef(), (BSTR &)bstrDescr))
-        IfFailReport(pCTI->SetFuncDocString(iMD, bstrDescr));
-    
-    // Error reporting info.
-    m_ErrorContext.m_szMember = 0;
-
-    return TRUE;
-} // void TypeLibExporter::ConvertFieldAsMethod()
-
-//*****************************************************************************
-// Export a variable's metadata to a typelib.
-//*****************************************************************************
-BOOL TypeLibExporter::ConvertVariable(
-    ICreateTypeInfo2 *pCTI,             // ICreateTypeInfo2 to get the variable.
-    MethodTable     *pMT,                // The class containing the variable.
-    mdFieldDef  md,                     // The member definition.
-    SString&    sName,                  // Name of the member.
-    ULONG       iMD)                    // Index of the member
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pCTI));
-        PRECONDITION(CheckPointer(pMT));
-    }
-    CONTRACTL_END;
-
-    HRESULT     hr = S_OK;              // A result.
-    PCCOR_SIGNATURE pbSig;              // Pointer to Cor signature.
-    ULONG       cbSig;                  // Size of Cor signature.
-    ULONG       ixSig;                  // Index into signature.
-    ULONG       cbElem;                 // Size of an element in the signature.
-    DWORD       dwFlags;                // A member's flags.
-    ULONG       callconv;               // A member's calling convention.
-    MDDefaultValue defaultValue;        // default value
-    ULONG       dispid=DISPID_UNKNOWN;  // The variable's dispid.
-    CDescPool   sPool;                  // Pool of memory in which to build vardesc.
-    VARDESC     *pvar;                  // A vardesc.
-    PCCOR_SIGNATURE pvNativeType;       // native field type
-    ULONG           cbNativeType;       // native field type length
-    const void  *pvData;                // Pointer to a custom attribute.
-    ULONG       cbData;                 // Size of custom attribute.
-    LPWSTR      pSuffix;                // Pointer into the name.
-    int         iSuffix = 0;            // Counter for suffix.
-    BSTRHolder  bstrDescr=0;            // Description of the method.
-
-    VARIANT       vtTemp;
-    VariantPtrHolder vtVariant = &vtTemp;
-
-    SafeVariantInit(vtVariant);
-
-    // Error reporting info.
-    IfFailReport(pMT->GetMDImport()->GetNameOfFieldDef(md, &m_ErrorContext.m_szMember));
-    
-    // Get info about the field.
-    IfFailReport(pMT->GetMDImport()->GetDispIdOfMemberDef(md, &dispid));
-    IfFailReport(pMT->GetMDImport()->GetFieldDefProps(md, &dwFlags));
-    if (IsFdHasDefault(dwFlags))
-    {
-        IfFailReport(pMT->GetMDImport()->GetDefaultValue(md, &defaultValue));
-        IfFailReport( _FillVariant(&defaultValue, vtVariant) ); 
-    }
-
-    // If exporting a non-public member of a struct, warn the user.
-    if (!IsFdPublic(dwFlags) && !m_bWarnedOfNonPublic)
-    {
-        m_bWarnedOfNonPublic = TRUE;
-        ReportWarning(TLBX_E_NONPUBLIC_FIELD, TLBX_E_NONPUBLIC_FIELD);
-    }
-
-    IfFailReport(pMT->GetMDImport()->GetSigOfFieldDef(md, &cbSig, &pbSig));
-    
-    // Prepare to parse signature and build the VARDESC.
-    pvar = reinterpret_cast<VARDESC*>(sPool.AllocZero(sizeof(VARDESC)));
-    if(pvar == NULL)
-        IfFailReport(E_OUTOFMEMORY);
-    ixSig = 0;
-
-    // Get the calling convention.
-    ixSig += CorSigUncompressData(&pbSig[ixSig], &callconv);
-    _ASSERTE(callconv == IMAGE_CEE_CS_CALLCONV_FIELD);
-
-    // Get native field type
-    pvNativeType = NULL;
-    hr = pMT->GetMDImport()->GetFieldMarshal(md, &pvNativeType, &cbNativeType);
-    if (hr != CLDB_E_RECORD_NOTFOUND)
-    {
-        IfFailReport(hr);
-    }
-    
-    // Convert the type to elemdesc.
-    hr = CorSigToTypeDesc(pCTI, pMT, &pbSig[ixSig], pvNativeType, cbNativeType, &cbElem, &pvar->elemdescVar.tdesc, &sPool, FALSE);
-    if (FAILED(hr))
-        return FALSE;
-
-    ixSig += cbElem;
-
-    pvar->wVarFlags = 0;
-    pvar->varkind = VAR_PERINSTANCE;
-    pvar->memid = dispid;
-
-    // Constant value.
-    if (vtVariant->vt != VT_EMPTY)
-        pvar->lpvarValue = vtVariant;
-    else
-    {
-        IfFailReport(pMT->GetMDImport()->GetCustomAttributeByName(md, INTEROP_DECIMALVALUE_TYPE,  &pvData,&cbData));
-        if (hr == S_OK && cbData >= (2 + sizeof(BYTE)+sizeof(BYTE)+sizeof(UINT)+sizeof(UINT)+sizeof(UINT)))
-        {
-            const BYTE *pbData = (const BYTE *)pvData;
-            vtVariant->vt = VT_DECIMAL;
-            vtVariant->decVal.scale = *(BYTE*)(pbData+2);
-            vtVariant->decVal.sign= *(BYTE*)(pbData+3);
-            vtVariant->decVal.Hi32= GET_UNALIGNED_32(pbData+4);
-            vtVariant->decVal.Mid32= GET_UNALIGNED_32(pbData+8);
-            vtVariant->decVal.Lo32= GET_UNALIGNED_32(pbData+12);
-            pvar->lpvarValue = vtVariant;
-        }
-        // If still no default value, check for date time custom attribute.
-        if (vtVariant->vt == VT_EMPTY)
-        {
-            IfFailReport(pMT->GetMDImport()->GetCustomAttributeByName(md, INTEROP_DATETIMEVALUE_TYPE,  &pvData,&cbData));
-            if (hr == S_OK && cbData >= (2 + sizeof(__int64)))
-            {
-                const BYTE *pbData = (const BYTE *)pvData;
-                vtVariant->vt = VT_DATE;
-                vtVariant->date = _TicksToDoubleDate(GET_UNALIGNED_64(pbData+2));
-            }
-        }
-        // If still no default value, check for IDispatch custom attribute.
-        if (vtVariant->vt == VT_EMPTY)
-        {
-            IfFailReport(pMT->GetMDImport()->GetCustomAttributeByName(md, INTEROP_IDISPATCHVALUE_TYPE,  &pvData,&cbData));
-            if (hr == S_OK)
-            {
-                vtVariant->vt = VT_DISPATCH;
-                vtVariant->pdispVal = 0;
-            }
-        }
-        // If still no default value, check for IUnknown custom attribute.
-        if (vtVariant->vt == VT_EMPTY)
-        {
-            IfFailReport(pMT->GetMDImport()->GetCustomAttributeByName(md, INTEROP_IUNKNOWNVALUE_TYPE,  &pvData,&cbData));
-            if (hr == S_OK)
-            {
-                vtVariant->vt = VT_UNKNOWN;
-                vtVariant->punkVal = 0;
-            }
-        }
-    }
-
-    IfFailReport(pCTI->AddVarDesc(iMD, pvar));
-    
-    // Set the name for the member; decorate if necessary.
-    pSuffix = 0;
-    for (;;)
-    {
-        // Attempt to set the name.
-        hr = pCTI->SetVarName(iMD, (LPOLESTR)sName.GetUnicode());
-        
-        // If a name conflict, decorate, otherwise, done.
-        if (hr != TYPE_E_AMBIGUOUSNAME)
-            break;
-
-        if (iSuffix == 0)
-        {
-            iSuffix = 2;
-        }
-        else
-        {
-            sName.Delete(sName.End()-=2, 2);
-        }
-
-        SString sDup;
-        sDup.Printf(szDuplicateDecoration, iSuffix++);
-        
-        sName.Append(sDup);
-    }
-    IfFailReport(hr);
-
-    // Check for a description.
-    if(GetDescriptionString(pMT, md, (BSTR &)bstrDescr))
-        IfFailReport(pCTI->SetVarDocString(iMD, bstrDescr));
-    
-    // Error reporting info.
-    m_ErrorContext.m_szMember = 0;
-
-    return TRUE;
-} // HRESULT TypeLibExporter::ConvertVariable()
-
-//*****************************************************************************
-// Export a variable's metadata to a typelib.
-//*****************************************************************************
-BOOL TypeLibExporter::ConvertEnumMember(
-    ICreateTypeInfo2 *pCTI,              // ICreateTypeInfo2 to get the variable.
-    MethodTable     *pMT,                // The Class containing the member.
-    mdFieldDef  md,                     // The member definition.
-    SString&    sName,                  // Name of the member.
-    ULONG       iMD)                    // Index of the member
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pCTI));
-        PRECONDITION(CheckPointer(pMT));
-    }
-    CONTRACTL_END;
-
-    HRESULT     hr = S_OK;              // A result.
-    LPCUTF8     pName, pNS;             // To format name.
-    DWORD       dwFlags;                // A member's flags.
-    VARIANT     vtVariant;              // A Variant.
-    MDDefaultValue defaultValue;        // default value
-    ULONG       dispid=DISPID_UNKNOWN;  // The variable's dispid.
-    CDescPool   sPool;                  // Pool of memory in which to build vardesc.
-    VARDESC     *pvar;                  // A vardesc.
-    BSTRHolder  bstrDescr=0;            // Description of the method.
-
-    vtVariant.vt = VT_EMPTY;
-
-    // Error reporting info.
-    IfFailReport(pMT->GetMDImport()->GetNameOfFieldDef(md, &m_ErrorContext.m_szMember));
-    
-    // Get info about the field.
-    IfFailReport(pMT->GetMDImport()->GetDispIdOfMemberDef(md, &dispid));
-    IfFailReport(pMT->GetMDImport()->GetFieldDefProps(md, &dwFlags));
-    
-    // We do not need to handle decimal's here since enum's can only be integral types.
-    IfFailReport(pMT->GetMDImport()->GetDefaultValue(md, &defaultValue));
-
-    // Prepare to parse signature and build the VARDESC.
-    pvar = reinterpret_cast<VARDESC*>(sPool.AllocZero(sizeof(VARDESC)));
-    if (NULL == pvar)
-        IfFailReport(E_OUTOFMEMORY);
-
-    IfFailReport( _FillVariant(&defaultValue, &vtVariant) ); 
-
-    // Don't care what the metadata says the type is -- the type is I4 in the typelib.
-    pvar->elemdescVar.tdesc.vt = VT_I4;
-
-    pvar->wVarFlags = 0;
-    pvar->varkind = VAR_CONST;
-    pvar->memid = dispid;
-
-    // Constant value.
-    if (vtVariant.vt != VT_EMPTY)
-    {
-        pvar->lpvarValue = &vtVariant;
-        
-        // If this is an I8 or UI8, do the conversion manually, because some 
-        //  systems' oleaut32 don't support 64-bit integers.
-        if (vtVariant.vt == VT_I8)
-        {  
-            // If withing range of 32-bit signed number, OK.
-            if (vtVariant.llVal <= LONG_MAX && vtVariant.llVal >= LONG_MIN)
-                vtVariant.vt = VT_I4, hr = S_OK;
-            else
-                hr = E_FAIL;
-        }
-        else if (vtVariant.vt == VT_UI8)
-        {
-            // If withing range of 32-bit unsigned number, OK.
-            if (vtVariant.ullVal <= ULONG_MAX)
-                vtVariant.vt = VT_UI4, hr = S_OK;
-            else
-                hr = E_FAIL;
-        }
-        else
-        {
-            hr = SafeVariantChangeTypeEx(&vtVariant, &vtVariant, 0, 0, VT_I4);
-        }
-        
-        if (FAILED(hr))
-        {
-            if (FAILED(pMT->GetMDImport()->GetNameOfTypeDef(pMT->GetCl(), &pName, &pNS)))
-            {
-                pName = pNS = "Invalid TypeDef record";
-            }
-            ReportWarning(TLBX_W_ENUM_VALUE_TOOBIG, TLBX_W_ENUM_VALUE_TOOBIG, pName, sName.GetUnicode());
-            return FALSE;
-        }
-    }
-    else
-    {   // No value assigned, use 0.
-        pvar->lpvarValue = &vtVariant;
-        vtVariant.vt = VT_I4;
-        vtVariant.lVal = 0;
-    }
-
-    IfFailReport(pCTI->AddVarDesc(iMD, pvar));
-    IfFailReport(pCTI->SetVarName(iMD, (LPOLESTR)sName.GetUnicode()));
-
-    // Check for a description.
-    if(GetDescriptionString(pMT, md, (BSTR &)bstrDescr))
-        IfFailReport(pCTI->SetVarDocString(iMD, bstrDescr));
-    
-    // Error reporting info.
-    m_ErrorContext.m_szMember = 0;
-
-    return TRUE;
-} // void TypeLibExporter::ConvertEnumMember()
-
-//*****************************************************************************
-// Given a COM+ signature of a field or property, determine if it should
-//  be a PROPERTYPUT or PROPERTYPUTREF.
-//*****************************************************************************
-BOOL TypeLibExporter::IsVbRefType(
-    PCCOR_SIGNATURE pbSig,
-    IMDInternalImport *pInternalImport)
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pInternalImport));
-    }
-    CONTRACTL_END;
-
-    ULONG       elem=0;                 // An element from a COM+ signature.
-    ULONG       cbElem=0;
-
-    cbElem = CorSigUncompressData(pbSig, &elem);
-    if (elem == ELEMENT_TYPE_PTR || elem == ELEMENT_TYPE_BYREF)
-    {
-        return IsVbRefType(&pbSig[cbElem], pInternalImport);
-    }
-    else
-    {
-        switch (elem)
-        {
-            // For documentation -- arrays are NOT ref types here.
-            //case ELEMENT_TYPE_SDARRAY:
-            //case ELEMENT_TYPE_ARRAY:
-            //case ELEMENT_TYPE_SZARRAY:
-            // Look for variant.
-            case ELEMENT_TYPE_VALUETYPE:
-                return FALSE;
-
-            case ELEMENT_TYPE_CLASS:
-                return TRUE;
-                
-            case ELEMENT_TYPE_OBJECT:
-                return FALSE;
-
-            default:
-                break;
-        }
-    }
-
-    return FALSE;
-} // BOOL TypeLibExporter::IsVbRefType()
-
-BOOL TypeLibExporter::IsExportingAs64Bit()
-{  
-    LIMITED_METHOD_CONTRACT;
-    if (TlbExportAs64Bit(m_flags))
-    {
-         return TRUE;
-    }
-    else if (TlbExportAs32Bit(m_flags))
-    {
-        return FALSE;
-    }
-    else
-    {
-#ifdef _WIN64
-        return TRUE;
-#else
-        return FALSE;
-#endif
-    }
-} // BOOL TypeLibExporter::IsExportingAs64Bit()
-
-void TypeLibExporter::ArrayToTypeDesc(ICreateTypeInfo2 *pCTI, CDescPool *ppool, ArrayMarshalInfo *pArrayMarshalInfo, TYPEDESC *ptdesc)
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pCTI));
-        PRECONDITION(CheckPointer(ppool));
-        PRECONDITION(CheckPointer(pArrayMarshalInfo));
-        PRECONDITION(CheckPointer(ptdesc));
-    }
-    CONTRACTL_END;
-
-    HRESULT hr = E_FAIL;
-    VARTYPE vtElement = pArrayMarshalInfo->GetElementVT();
-    TypeHandle thElement = pArrayMarshalInfo->GetElementTypeHandle();
-
-    if (vtElement == VT_RECORD)
-    {
-        // We are dealing with an array of embedded structures.
-        ptdesc->vt = VT_USERDEFINED;                                
-        EEClassToHref(pCTI, thElement.GetMethodTable(), FALSE, &ptdesc->hreftype);
-    }
-    else if ((vtElement == VT_UNKNOWN || vtElement == VT_DISPATCH) && !thElement.IsObjectType())
-    {
-        if (!thElement.IsValueType() && !pArrayMarshalInfo->IsSafeArraySubTypeExplicitlySpecified())
-        {
-            // We are dealing with an array of user defined interfaces.
-            ptdesc->vt = VT_PTR;
-            ptdesc->lptdesc = reinterpret_cast<TYPEDESC*>(ppool->AllocZero(sizeof(TYPEDESC)));
-            if (ptdesc->lptdesc == NULL)
-                IfFailReport(E_OUTOFMEMORY);
-                    
-            ptdesc->lptdesc->vt = VT_USERDEFINED;
-            EEClassToHref(pCTI, thElement.GetMethodTable(), FALSE, &ptdesc->lptdesc->hreftype);        
-        }
-        else
-        {
-            // The user specified that the array of value classes be converted to an 
-            // array of IUnknown or IDispatch pointers. 
-            ptdesc->vt = vtElement;
-        }
-    }
-    else if (pArrayMarshalInfo->IsPtr())
-    {
-        ptdesc->vt = VT_PTR;
-        ptdesc->lptdesc = reinterpret_cast<TYPEDESC*>(ppool->AllocZero(sizeof(TYPEDESC)));
-        if (ptdesc->lptdesc == NULL)
-            IfFailReport(E_OUTOFMEMORY);
-
-        ptdesc->lptdesc->vt = vtElement;
-    }
-    else
-    {
-        // We are dealing with an array of primitive types.
-        ptdesc->vt = vtElement;
-    }
-}
-// HRESULT ArrayToTypeDesc(ArrayMarshalInfo *pArrayMarshalInfo, TYPEDESC *pElementTypeDesc)
-
-VARTYPE TypeLibExporter::GetVtForIntPtr()
-{
-    WRAPPER_NO_CONTRACT;
-
-    return static_cast<VARTYPE>(IsExportingAs64Bit() ? VT_I8 : VT_I4);
-} // VARTYPE TypeLibExporter::GetVtForIntPtr()
-
-VARTYPE TypeLibExporter::GetVtForUIntPtr()
-{
-    WRAPPER_NO_CONTRACT;
-
-    return static_cast<VARTYPE>(IsExportingAs64Bit() ? VT_UI8 : VT_UI4);
-} // VARTYPE TypeLibExporter::GetVtForUIntPtr()
-
-/*
-BOOL TypeLibExporter::ValidateSafeArrayElemVT(VARTYPE vt)
-{
-    switch(vt)
-    {
-        case VT_I2:
-        case VT_I4:
-        case VT_R4:
-        case VT_R8:
-        case VT_CY:
-        case VT_DATE:
-        case VT_BSTR:
-        case VT_DISPATCH:
-        case VT_ERROR:
-        case VT_BOOL:
-        case VT_VARIANT:
-        case VT_UNKNOWN:
-        case VT_DECIMAL:
-        case VT_RECORD:
-        case VT_I1:
-        case VT_UI1:
-        case VT_UI2:
-        case VT_UI4:
-        case VT_INT:
-        case VT_UINT:
-            return TRUE;
-
-        default:
-            return FALSE;
-    }
-}
-*/
-
-//*****************************************************************************
-// Read a COM+ signature element and create a TYPEDESC that corresponds 
-//  to it.
-//*****************************************************************************
-#ifdef _PREFAST_
-#pragma warning(push)
-#pragma warning(disable:21000) // Suppress PREFast warning about overly large function
-#endif
-HRESULT TypeLibExporter::CorSigToTypeDesc(
-    ICreateTypeInfo2 *pCTI,              // Typeinfo being created.
-    MethodTable     *pMT,                // MethodTable with the token.
-    PCCOR_SIGNATURE pbSig,              // Pointer to the Cor Signature.
-    PCCOR_SIGNATURE pbNativeSig,        // Pointer to the native sig, if any
-    ULONG       cbNativeSig,            // Count of bytes in native sig.
-    ULONG       *pcbElem,               // Put # bytes consumed here.
-    TYPEDESC    *ptdesc,                // Build the typedesc here.
-    CDescPool   *ppool,                 // Pool for additional storage as required.
-    BOOL        bMethodSig,             // TRUE if the sig is for a method, FALSE for a field.
-    BOOL        *pbByRef)               // If not null, and the type is byref, set to true.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pCTI));
-        PRECONDITION(CheckPointer(pMT));
-        PRECONDITION(CheckPointer(pcbElem));
-        PRECONDITION(CheckPointer(ptdesc));
-        PRECONDITION(CheckPointer(ppool));
-        PRECONDITION(CheckPointer(pbByRef, NULL_OK));
-    }
-    CONTRACTL_END;
-
-    HRESULT     hr=S_OK;
-    ULONG       elem = 0;               // The element type.
-    ULONG       cbElem = 0;             // Bytes in the element.
-    ULONG       cb;                     // Bytes in a sub-element.
-    ULONG       cbNativeElem = 0;       // # of bytes parsed off of native type.
-    ULONG       nativeElem = 0;         // The native element type
-    ULONG       nativeCount;            // The native element size
-    mdToken     tkTypeRef;              // Token for a TypeRef/TypeDef
-    SString     sName;                  // Buffer to build a name from NS/Name.
-    LPCUTF8     pclsname;               // Class name for ELEMENT_TYPE_CLASS.
-    HREFTYPE    hRef = 0;               // HREF to some type.
-    IMDInternalImport *pInternalImport; // Internal interface containing the signature.
-    Module*     pModule = NULL;         // Module containing the signature.
-    int         i;                      // Loop control.
-    SigTypeContext emptyTypeContext;    // an empty type context is sufficient: all methods should be non-generic
-    ULONG       dwTypeFlags = 0;        // The type flags.
-    BOOL        fAnsi = FALSE;          // Is the structure marked as CharSet=Ansi.
-    BOOL        fIsStringBuilder = FALSE;
-    LPCUTF8     pNS;
-
-
-    pInternalImport = pMT->GetMDImport();
-    pModule = pMT->GetModule();
-
-    // Just be sure the count is zero if the pointer is.
-    if (pbNativeSig == NULL)
-        cbNativeSig = 0;
-
-    // Grab the native marshaling type.
-    if (cbNativeSig > 0)
-    {
-        cbNativeElem = CorSigUncompressData(pbNativeSig, &nativeElem);
-        pbNativeSig += cbNativeElem;
-        cbNativeSig -= cbNativeElem;
-
-        // AsAny makes no sense for COM Interop.  Ignore it.
-        if (nativeElem == NATIVE_TYPE_ASANY)
-        {
-            ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_ASANY);
-            nativeElem = 0;
-        }
-    }
-
-    // If we are dealing with a struct, determine if it is marked as CharSet=Ansi.
-    if (!bMethodSig)
-    {
-        // Make sure one of Auto, Ansi or Unicode is specified.
-        if (!IsTdAnsiClass(dwTypeFlags) && !IsTdAutoClass(dwTypeFlags) && !IsTdUnicodeClass(dwTypeFlags))
-        {
-            _ASSERTE(!"Bad stringformat value in wrapper class.");
-            ReportWarning(TLBX_E_BAD_SIGNATURE, E_FAIL);  // bad metadata
-            hr = TLBX_E_BAD_SIGNATURE;
-            goto ExitFunc;
-        }
-        
-        if (FAILED(pInternalImport->GetTypeDefProps(pMT->GetCl(), &dwTypeFlags, NULL)))
-        {
-            ReportWarning(TLBX_E_BAD_SIGNATURE, E_FAIL);
-            hr = TLBX_E_BAD_SIGNATURE;
-            goto ExitFunc;
-        }
-        fAnsi = IsTdAnsiClass(dwTypeFlags);
-    }
-    
-    // Get the element type.
-TryAgain:
-    cbElem += CorSigUncompressData(pbSig+cbElem, &elem);
-
-    // Handle the custom marshaler native type separately.
-    if (elem != ELEMENT_TYPE_BYREF && nativeElem == NATIVE_TYPE_CUSTOMMARSHALER)
-    {
-        switch(elem)
-        {
-            case ELEMENT_TYPE_VAR:
-            case ELEMENT_TYPE_CLASS:
-            case ELEMENT_TYPE_OBJECT:
-                // @TODO(DM): Ask the custom marshaler for the ITypeInfo to use for the unmanaged type.
-                ptdesc->vt = VT_UNKNOWN;
-                break;
-
-            case ELEMENT_TYPE_STRING:
-            case ELEMENT_TYPE_SZARRAY:
-            case ELEMENT_TYPE_ARRAY:
-                ptdesc->vt = GetVtForIntPtr();
-                break;
-
-            default:
-                ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_BAD_NATIVETYPE);
-                return(TLBX_E_BAD_SIGNATURE);
-            break;
-        }
-
-        // Eat the rest of the signature.  The extra -1's are to account
-        // for the byte parsed off above.
-        SigPointer p(&pbSig[cbElem-1]);
-        IfFailThrow(p.SkipExactlyOne());
-        cbElem += (ULONG)(p.GetPtr() - &pbSig[cbElem]);  // Note I didn't use -1 here.
-        goto ExitFunc;
-    }
-
-// This label is used to try again with a new element type, but without consuming more signature.
-//  Usage is to set 'elem' to a new value, goto this label.
-TryWithElemType:
-    switch (elem)
-    {
-    case ELEMENT_TYPE_END:            // 0x0,
-            ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_UNKNOWN_SIGNATURE);
-            return(TLBX_E_BAD_SIGNATURE);
-        break;
-            
-    case ELEMENT_TYPE_VOID:           // 0x1,
-        ptdesc->vt = VT_VOID;  
-        break;
-
-    case ELEMENT_TYPE_BOOLEAN:        // 0x2,
-        switch (nativeElem)
-        {
-        case 0:
-            ptdesc->vt = static_cast<VARTYPE>(bMethodSig ? VT_BOOL : VT_I4);
-            break;
-
-        case NATIVE_TYPE_VARIANTBOOL:
-            ptdesc->vt = VT_BOOL;
-            break;
-
-        case NATIVE_TYPE_BOOLEAN:
-            ptdesc->vt = VT_I4;
-            break;
-
-        case NATIVE_TYPE_U1:
-        case NATIVE_TYPE_I1:
-            ptdesc->vt = VT_UI1;
-            break;
-                    
-        default:
-            DEBUG_STMT(DbgWriteEx(W("Bad Native COM attribute specified!\n")));
-                    ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_BAD_NATIVETYPE);
-                    return(TLBX_E_BAD_SIGNATURE);
-        }   
-        break;
-            
-    case ELEMENT_TYPE_CHAR:           // 0x3,
-        if (nativeElem == 0)
-        {
-            if (!bMethodSig && IsTdAutoClass(dwTypeFlags))
-            {
-                // Types with a char set of auto and that would be represented differently
-                // on different platforms are not allowed to be exported to COM.
-                DefineFullyQualifiedNameForClassW();
-                LPCWSTR szName = GetFullyQualifiedNameForClassW(pMT);
-                _ASSERTE(szName);
-
-                ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_AUTO_CS_NOT_ALLOWED, szName);
-                hr = TLBX_E_BAD_SIGNATURE;
-                goto ExitFunc;
-            }
-
-            ptdesc->vt = static_cast<VARTYPE>(fAnsi ? VT_UI1 : VT_UI2);
-        }
-        else
-        {
-            switch (nativeElem)
-            {
-            case 0:
-            case NATIVE_TYPE_U2:
-            case NATIVE_TYPE_I2:
-                ptdesc->vt = VT_UI2;
-                break;
-                                
-            case NATIVE_TYPE_U1:
-            case NATIVE_TYPE_I1:
-                ptdesc->vt = VT_UI1;
-                break;
-                                
-            default:
-                DEBUG_STMT(DbgWriteEx(W("Bad Native COM attribute specified!\n")));
-                ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_BAD_NATIVETYPE);
-                hr = TLBX_E_BAD_SIGNATURE;
-                goto ExitFunc;
-            }
-        }
-        break;
-
-    case ELEMENT_TYPE_I1:             // 0x4,
-        ptdesc->vt = VT_I1;
-        break;
-                
-    case ELEMENT_TYPE_U1:             // 0x5,
-        ptdesc->vt = VT_UI1;
-        break;
-                
-    case ELEMENT_TYPE_I2:             // 0x6,
-        ptdesc->vt = VT_I2;
-        break;
-                
-    case ELEMENT_TYPE_U2:             // 0x7,
-        ptdesc->vt = VT_UI2;
-        break;
-                
-    case ELEMENT_TYPE_I4:             // 0x8,
-        switch (nativeElem)
-        {
-        case 0:
-        case NATIVE_TYPE_I4:
-        case NATIVE_TYPE_U4: case NATIVE_TYPE_INTF: //@todo: Fix Microsoft.Win32.Interop.dll and remove this line.
-            ptdesc->vt = VT_I4;
-            break;
-                    
-        case NATIVE_TYPE_ERROR:
-            ptdesc->vt = VT_HRESULT;
-            break;
-                            
-        default:
-            DEBUG_STMT(DbgWriteEx(W("Bad Native COM attribute specified!\n")));
-            ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_BAD_NATIVETYPE);
-            hr = TLBX_E_BAD_SIGNATURE;
-            goto ExitFunc;
-        }
-        break;
-            
-    case ELEMENT_TYPE_U4:             // 0x9,
-        switch (nativeElem)
-        {
-        case 0:
-        case NATIVE_TYPE_U4:
-            ptdesc->vt = VT_UI4;
-            break;
-                            
-        case NATIVE_TYPE_ERROR:
-            ptdesc->vt = VT_HRESULT;
-            break;
-                            
-        default:
-            DEBUG_STMT(DbgWriteEx(W("Bad Native COM attribute specified!\n")));
-            ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_BAD_NATIVETYPE);
-            hr = TLBX_E_BAD_SIGNATURE;
-            goto ExitFunc;
-        }
-        break;
-            
-    case ELEMENT_TYPE_I8:             // 0xa,
-        ptdesc->vt = VT_I8;
-        break;
-                
-    case ELEMENT_TYPE_U8:             // 0xb,
-        ptdesc->vt = VT_UI8;
-        break;
-                
-    case ELEMENT_TYPE_R4:             // 0xc,
-        ptdesc->vt = VT_R4;
-        break;
-                
-    case ELEMENT_TYPE_R8:             // 0xd,
-        ptdesc->vt = VT_R8;
-        break;
-                
-    case ELEMENT_TYPE_OBJECT:
-        goto IsObject;
-            
-    case ELEMENT_TYPE_STRING:         // 0xe,
-    IsString:
-        if (nativeElem == 0)
-        {            
-            if (bMethodSig)
-            {
-                ptdesc->vt = VT_BSTR;
-            }
-            else
-            {
-                if (IsTdAutoClass(dwTypeFlags))
-                {
-                    // Types with a char set of auto and that would be represented differently
-                    // on different platforms are not allowed to be exported to COM.
-                    DefineFullyQualifiedNameForClassW();
-                    LPCWSTR szName = GetFullyQualifiedNameForClassW(pMT);
-                    _ASSERTE(szName);
-
-                    ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_AUTO_CS_NOT_ALLOWED, szName);
-                    hr = TLBX_E_BAD_SIGNATURE;
-                    goto ExitFunc;
-                }
-
-                ptdesc->vt = static_cast<VARTYPE>(fAnsi ? VT_LPSTR : VT_LPWSTR);
-            }
-        }
-        else
-        {
-            switch (nativeElem)
-            {
-            case NATIVE_TYPE_BSTR:
-                if (fIsStringBuilder)
-                {
-                    ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_BAD_NATIVETYPE);
-                    hr = TLBX_E_BAD_SIGNATURE;
-                    goto ExitFunc;
-                }
-                ptdesc->vt = VT_BSTR;
-                break;
-                        
-            case NATIVE_TYPE_LPSTR:
-                ptdesc->vt = VT_LPSTR;
-                break;
-                                
-            case NATIVE_TYPE_LPWSTR:
-                ptdesc->vt = VT_LPWSTR;
-                break;
-                                
-            case NATIVE_TYPE_LPTSTR:
-                {
-                    // NATIVE_TYPE_LPTSTR is not allowed to be exported to COM.
-                    DefineFullyQualifiedNameForClassW();
-                    LPCWSTR szName = GetFullyQualifiedNameForClassW(pMT);
-                    _ASSERTE(szName);
-                    ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_LPTSTR_NOT_ALLOWED, szName);
-                    hr = TLBX_E_BAD_SIGNATURE;
-                    goto ExitFunc;
-                }
-            case NATIVE_TYPE_FIXEDSYSSTRING:
-                // NATIVE_TYPE_FIXEDSYSSTRING is only allowed on fields.
-                if (bMethodSig)
-                {
-                    ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_BAD_NATIVETYPE);
-                    hr = TLBX_E_BAD_SIGNATURE;
-                    goto ExitFunc;
-                }
-
-                // Retrieve the count of characters.
-                if (cbNativeSig != 0)
-                {
-                    cb = CorSigUncompressData(pbNativeSig, &nativeCount);
-                    pbNativeSig += cb;
-                    cbNativeSig -= cb;
-                }
-                else
-                {
-                    nativeCount = 0;
-                }
-
-                // Fixed strings become embedded array's of characters.
-                ptdesc->vt = VT_CARRAY;
-                ptdesc->lpadesc = reinterpret_cast<ARRAYDESC*>(ppool->AllocZero(sizeof(ARRAYDESC)));
-                if (ptdesc->lpadesc == NULL)
-                    IfFailReport(E_OUTOFMEMORY);
-
-                // Set the count of characters.
-                ptdesc->lpadesc->cDims = 1;
-                ptdesc->lpadesc->rgbounds[0].cElements = nativeCount;
-                ptdesc->lpadesc->rgbounds[0].lLbound = 0;
-
-                if (IsTdAutoClass(dwTypeFlags))
-                {
-                    // Types with a char set of auto and that would be represented differently
-                    // on different platforms are not allowed to be exported to COM.
-                    DefineFullyQualifiedNameForClassW();
-                    LPCWSTR szName = GetFullyQualifiedNameForClassW(pMT);
-                    _ASSERTE(szName);
-
-                    ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_AUTO_CS_NOT_ALLOWED, szName);
-                    hr = TLBX_E_BAD_SIGNATURE;
-                    goto ExitFunc;
-                }
-
-                ptdesc->lpadesc->tdescElem.vt = static_cast<VARTYPE>(fAnsi ? VT_UI1 : VT_UI2);
-                break;
-
-            default:
-                DEBUG_STMT(DbgWriteEx(W("Bad Native COM attribute specified!\n")));
-                ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_BAD_NATIVETYPE);
-                hr = TLBX_E_BAD_SIGNATURE;
-                goto ExitFunc;
-            }   
-        }
-        break;
-
-    // every type above PTR will be simple type
-    case ELEMENT_TYPE_PTR:            // 0xf,
-    case ELEMENT_TYPE_BYREF:          // 0x10,
-        // TYPEDESC is a pointer.
-        ptdesc->vt = VT_PTR;
-        if (pbByRef)
-            *pbByRef = TRUE;
-                
-        // Pointer to what?
-        ptdesc->lptdesc = reinterpret_cast<TYPEDESC*>(ppool->AllocZero(sizeof(TYPEDESC)));
-        if (ptdesc->lptdesc == NULL)
-            IfFailReport(E_OUTOFMEMORY);
-            
-        hr = CorSigToTypeDesc(pCTI, pMT, &pbSig[cbElem], pbNativeSig-cbNativeElem, 
-                    cbNativeSig+cbNativeElem, &cb, ptdesc->lptdesc, ppool, bMethodSig);
-        cbElem += cb;
-            
-        if (FAILED(hr))
-            goto ExitFunc;
-        
-        break;
-
-    case ELEMENT_TYPE_CLASS:          // 0x12,
-    case ELEMENT_TYPE_VALUETYPE:
-        // Get the TD/TR.
-        cb = CorSigUncompressToken(&pbSig[cbElem], &tkTypeRef);
-        cbElem += cb;
-        
-        if (TypeFromToken(tkTypeRef) == mdtTypeDef)
-        {
-            // Get the name of the TypeDef.
-            if (FAILED(pInternalImport->GetNameOfTypeDef(tkTypeRef, &pclsname, &pNS)))
-            {
-                IfFailReport(COR_E_BADIMAGEFORMAT);
-            }
-        }
-        else
-        {
-            // Get the name of the TypeRef.
-            _ASSERTE(TypeFromToken(tkTypeRef) == mdtTypeRef);
-            IfFailReport(pInternalImport->GetNameOfTypeRef(tkTypeRef, &pNS, &pclsname));
-        }
-
-        if (pNS)
-        {
-            sName.MakeFullNamespacePath(SString(SString::Utf8, pNS), SString(SString::Utf8, pclsname));
-            StackScratchBuffer scratch;
-            pclsname = sName.GetUTF8(scratch);
-        }
-
-        _ASSERTE(strlen(szRuntime) == cbRuntime);  // If you rename System, fix this invariant.
-        _ASSERTE(strlen(szText) == cbText);  // If you rename System.Text, fix this invariant.
-
-        // Is it System.something? 
-        if (SString::_strnicmp(pclsname, szRuntime, cbRuntime) == 0)
-        {   
-            // Which one?
-            LPCUTF8 pcls; pcls = pclsname + cbRuntime;
-            if (stricmpUTF8(pcls, szStringClass) == 0)
-            {
-                goto IsString;
-            }
-            else if (stricmpUTF8(pcls, szDateTimeClass) == 0)
-            {
-                ptdesc->vt = VT_DATE;
-                goto ExitFunc;
-            }
-            else if (stricmpUTF8(pcls, szDecimalClass) == 0)
-            {
-                switch (nativeElem)
-                {
-                    case NATIVE_TYPE_CURRENCY:
-                        // Make this a currency.
-                        ptdesc->vt = VT_CY;
-                        break;
-                                
-                    case 0:
-                        // Make this a decimal
-                        ptdesc->vt = VT_DECIMAL;
-                        break;
-                                
-                    default:
-                        DEBUG_STMT(DbgWriteEx(W("Bad Native COM attribute specified!\n")));
-                        ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_BAD_NATIVETYPE);
-                        hr = TLBX_E_BAD_SIGNATURE;
-                        goto ExitFunc;
-                }
-                goto ExitFunc;
-            }
-            else if (stricmpUTF8(pcls, szGuidClass) == 0)
-            {
-                switch (nativeElem)
-                {
-                    case NATIVE_TYPE_LPSTRUCT:
-                        // Make this a pointer to . . .
-                        ptdesc->vt = VT_PTR;
-                        if (pbByRef)
-                            *pbByRef = TRUE;
-                                
-                        ptdesc->lptdesc = reinterpret_cast<TYPEDESC*>(ppool->AllocZero(sizeof(TYPEDESC)));
-                        if (ptdesc->lptdesc == NULL)
-                            IfFailReport(E_OUTOFMEMORY);
-                                
-                        // . . . a user defined type for GUID
-                        ptdesc->lptdesc->vt = VT_USERDEFINED;
-                        GetRefTypeInfo(pCTI, m_pGuid, &ptdesc->lptdesc->hreftype);
-                        break;
-                                
-                    case 0:
-                    case NATIVE_TYPE_STRUCT:
-                        // a user defined type for GUID
-                        ptdesc->vt = VT_USERDEFINED;
-                        GetRefTypeInfo(pCTI, m_pGuid, &ptdesc->hreftype);
-                        break;
-                                
-                    default:
-                        DEBUG_STMT(DbgWriteEx(W("Bad Native COM attribute specified!\n")));
-                        ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_BAD_NATIVETYPE);
-                        hr = TLBX_E_BAD_SIGNATURE;
-                        goto ExitFunc;
-                }
-                goto ExitFunc;
-            }
-            else if (stricmpUTF8(pcls, szArrayClass) == 0)
-            {
-                // If no native type is specified then assume its a NATIVE_TYPE_INTF.
-                if (nativeElem == 0)
-                    nativeElem = NATIVE_TYPE_INTF;
-
-                if (nativeElem == NATIVE_TYPE_SAFEARRAY)
-                {
-                    // Compat: If no safe array used def subtype was specified we will map it to a SAFEARRAY of VARIANTs.
-                    ULONG vtElement = VT_VARIANT;
-                    TypeHandle thElement = TypeHandle(g_pObjectClass);
-                    
-                    if (cbNativeSig > 0)
-                    {
-                        // Retrieve the safe array sub type.
-                        cb = CorSigUncompressData(pbNativeSig, &vtElement);
-                        pbNativeSig += cb;
-                        cbNativeSig -= cb;    
-
-                        // Get the type name if specified.
-                        if (cbNativeSig > 0)
-                        {
-                            ULONG cbClass = 0;
-                            
-                            cb = CorSigUncompressData(pbNativeSig, &cbClass);
-                            pbNativeSig += cb;
-                            cbNativeSig -= cb;
-
-                            if (cbClass > 0)
-                            {
-                                // Load the type. Use an SString for the string since we need to NULL terminate the string
-                                // that comes from the metadata.
-                                StackScratchBuffer utf8Name;
-                                SString safeArrayUserDefTypeName(SString::Utf8, (LPUTF8)pbNativeSig, cbClass);
-                                thElement = LoadClass(pMT->GetModule(), safeArrayUserDefTypeName.GetUTF8(utf8Name));
-                            }
-                        }                        
-                    }
-                    else
-                    {
-                        if (!bMethodSig)
-                        {
-                            // The field marshaller converts these to SAFEARRAYs of the type specified
-                            // at runtime by the array. This isn't expressible in a type library 
-                            // so provide a warning.
-                            ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_W_BAD_SAFEARRAYFIELD_NO_ELEMENTVT);
-                        }
-                    }
-
-                    ArrayMarshalInfo arrayMarshalInfo(IsExportingAs64Bit() ? amiExport64Bit : amiExport32Bit);
-                    MarshalInfo::MarshalScenario ms = bMethodSig ? MarshalInfo::MARSHAL_SCENARIO_COMINTEROP : MarshalInfo::MARSHAL_SCENARIO_FIELD;
-                    arrayMarshalInfo.InitForSafeArray(ms, thElement, (VARTYPE)vtElement, fAnsi);
-
-                    if (!arrayMarshalInfo.IsValid())
-                    {
-                        ReportWarning(TLBX_E_BAD_SIGNATURE, arrayMarshalInfo.GetErrorResourceId());
-                        hr = TLBX_E_BAD_SIGNATURE;
-                        goto ExitFunc;
-                    }
-    
-                    // TYPEDESC is an array.
-                    ptdesc->vt = VT_SAFEARRAY;
-                    ptdesc->lptdesc = reinterpret_cast<TYPEDESC*>(ppool->AllocZero(sizeof(TYPEDESC)));
-                    if (ptdesc->lptdesc == NULL)
-                        IfFailReport(E_OUTOFMEMORY);
-
-                    ArrayToTypeDesc(pCTI, ppool, &arrayMarshalInfo, ptdesc->lptdesc);
-                    
-                    goto ExitFunc;
-                }
-                else if (nativeElem == NATIVE_TYPE_FIXEDARRAY)
-                {               
-                    // NATIVE_TYPE_FIXEDARRAY is only allowed on fields.
-                    if (bMethodSig)
-                    {
-                        ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_BAD_NATIVETYPE);
-                        hr = TLBX_E_BAD_SIGNATURE;
-                        goto ExitFunc;
-                    }
-                    
-                    // Retrieve the size of the fixed array. This is required.
-                    if (cbNativeSig == 0)
-                    {
-                        ReportWarning(TLBX_E_BAD_SIGNATURE, IDS_EE_BADMARSHALFIELD_FIXEDARRAY_NOSIZE);
-                        hr = TLBX_E_BAD_SIGNATURE;
-                        goto ExitFunc;
-                    }
-
-                    cb = CorSigUncompressData(pbNativeSig, &nativeCount);
-                    pbNativeSig += cb;
-                    cbNativeSig -= cb;
-
-                    // A size const of 0 isn't supported.
-                    if (nativeCount == 0)
-                    {
-                        ReportWarning(TLBX_E_BAD_SIGNATURE, IDS_EE_BADMARSHALFIELD_FIXEDARRAY_ZEROSIZE);
-                        hr = TLBX_E_BAD_SIGNATURE;
-                        goto ExitFunc;
-                    }
-
-                    // Since these always export to arrays of BSTRs, we don't need to fetch the native type.
-
-                    // Set the data
-                    ptdesc->vt = VT_CARRAY;
-                    ptdesc->lpadesc = NULL;
-                    ptdesc->lpadesc = reinterpret_cast<ARRAYDESC*>(ppool->AllocZero(sizeof(ARRAYDESC)));
-                    if (ptdesc->lpadesc == NULL)
-                        IfFailReport(E_OUTOFMEMORY);
-
-                    // Compat: FixedArrays of System.Arrays map to fixed arrays of BSTRs.
-                    ptdesc->lpadesc->tdescElem.vt = VT_BSTR;
-                    ptdesc->lpadesc->cDims = 1;
-                    ptdesc->lpadesc->rgbounds->cElements = nativeCount;
-                    ptdesc->lpadesc->rgbounds->lLbound = 0;
-
-                    goto ExitFunc;
-                }
-                else if (nativeElem != NATIVE_TYPE_INTF)
-                {
-                    ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_BAD_NATIVETYPE);
-                    hr = TLBX_E_BAD_SIGNATURE;
-                    goto ExitFunc;
-                }
-
-                // If the native type is NATIVE_TYPE_INTF then we fall through and convert 
-                // System.Array to its IClassX interface.
-            }
-            else if (stricmpUTF8(pcls, szObjectClass) == 0)
-            {
-    IsObject:
-                // This next statement is to work around a "feature" that marshals an object inside
-                //  a struct as an interface, instead of as a variant.  fieldmarshal metadata
-                //  can override that.
-                if (nativeElem == 0 && !bMethodSig)
-                    nativeElem = NATIVE_TYPE_IUNKNOWN;
-
-                switch (nativeElem)
-                {
-                    case NATIVE_TYPE_INTF:
-                    case NATIVE_TYPE_IUNKNOWN:
-                        // an IUnknown based interface.
-                        ptdesc->vt = VT_UNKNOWN;
-                        break;
-                                        
-                    case NATIVE_TYPE_IDISPATCH:
-                        // an IDispatch based interface.
-                        ptdesc->vt = VT_DISPATCH;
-                        break;
-                                
-                    case 0:
-                    case NATIVE_TYPE_STRUCT:
-                        // a VARIANT
-                        ptdesc->vt = VT_VARIANT;
-                        break;
-                                
-                    default:
-                        ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_BAD_NATIVETYPE);
-                        hr = TLBX_E_BAD_SIGNATURE;
-                        goto ExitFunc;
-                }
-                goto ExitFunc;
-            }
-        } // System
-            
-        if (SString::_strnicmp(pclsname, szText, cbText) == 0)
-        {
-            LPCUTF8 pcls; pcls = pclsname + cbText;
-            if (stricmpUTF8(pcls, szStringBufferClass) == 0)
-            {
-                fIsStringBuilder = TRUE;
-                        
-                // If there is no fieldmarshal information, marshal as a LPWSTR
-                if (nativeElem == 0)
-                    nativeElem = NATIVE_TYPE_LPWSTR;
-                        
-                // Marshaller treats stringbuilders as [in, out] by default.
-                if (pbByRef)
-                    *pbByRef = TRUE;
-                        
-                goto IsString;
-            }
-        } // System.Text
-            
-        if (SString::_strnicmp(pclsname, szCollections, cbCollections) == 0)
-        {
-            LPCUTF8 pcls; pcls = pclsname + cbCollections;
-            if (stricmpUTF8(pcls, szIEnumeratorClass) == 0)
-            {
-                StdOleTypeToHRef(pCTI, IID_IEnumVARIANT, &hRef);
-                ptdesc->vt = VT_PTR;
-                ptdesc->lptdesc = reinterpret_cast<TYPEDESC*>(ppool->AllocZero(sizeof(TYPEDESC)));
-                if (ptdesc->lptdesc == NULL)
-                    IfFailReport(E_OUTOFMEMORY);
-                        
-                ptdesc->lptdesc->vt = VT_USERDEFINED;
-                ptdesc->lptdesc->hreftype = hRef;
-                goto ExitFunc;
-            }
-        } // System.Collections
-            
-        if (SString::_strnicmp(pclsname, szDrawing, cbDrawing) == 0)
-        {
-            LPCUTF8 pcls; pcls = pclsname + cbDrawing;
-            if (stricmpUTF8(pcls, szColor) == 0)
-            {
-                StdOleTypeToHRef(pCTI, GUID_OleColor, &hRef);
-                ptdesc->vt = VT_USERDEFINED;
-                ptdesc->hreftype = hRef;
-                goto ExitFunc;
-            }
-        } // System.Drawing
-
-        // It is not a built-in VT type, so build the typedesc.
-
-        // Determine whether the type is a reference type (IUnknown derived) or a struct type.
-        // Get the MethodTable for the referenced class.
-        MethodTable     *pRefdClass;            // MethodTable object for referenced TypeDef.
-        pRefdClass = LoadClass(pMT->GetModule(), tkTypeRef);
-
-        // Is the type a ref type or a struct type.  Note that a ref type that has layout
-        //  is exported as a TKIND_RECORD but is referenced as a **Foo, whereas a
-        //  value type is also exported as a TKIND_RECORD but is referenced as a *Foo.
-        if (elem == ELEMENT_TYPE_CLASS)
-        {           
-            // Check if it is a delegate (which can be marshaled as a function pointer).
-            if (COMDelegate::IsDelegate(pRefdClass))
-            {
-                if (nativeElem == NATIVE_TYPE_FUNC)
-                {
-                    ptdesc->vt = GetVtForIntPtr();
-                    goto ExitFunc;
-                }
-                else if (nativeElem != 0 && nativeElem != NATIVE_TYPE_INTF)
-                {
-                    ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_BAD_NATIVETYPE);
-                    hr = TLBX_E_BAD_SIGNATURE;
-                    goto ExitFunc;
-                }
-            }
-            else if (TypeHandle(pRefdClass).CanCastTo(TypeHandle(MscorlibBinder::GetClass(CLASS__SAFE_HANDLE))))
-            {
-                ptdesc->vt = GetVtForIntPtr();
-                goto ExitFunc;
-            }
-            else if (TypeHandle(pRefdClass).CanCastTo(TypeHandle(MscorlibBinder::GetClass(CLASS__CRITICAL_HANDLE))))
-            {
-                ptdesc->vt = GetVtForIntPtr();
-                goto ExitFunc;
-            }
-
-            if (pRefdClass->HasLayout())
-            {
-                if (nativeElem == NATIVE_TYPE_INTF)
-                {
-                    // Classes with layout are exported as structs. Because of this, we can't export field or 
-                    // parameters of these types marked with [MarshalAs(UnmanagedType.Interface)] as interface
-                    // pointers of the actual type. The best we can do is make them IUnknown pointers and 
-                    // provide a warning.
-                    ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_W_LAYOUTCLASS_AS_INTERFACE);
-                    ptdesc->vt = VT_UNKNOWN;
-                    goto ExitFunc;                
-                }
-                else if (!bMethodSig)
-                {
-                    // Classes with layout inside structures must be either marked with [MarshalAs(UnmanagedType.Interface)],
-                    // [MarshalAs(UnmanagedType.Struct)] or not have any MarshalAs information.
-                    if ((nativeElem != 0) && (nativeElem != NATIVE_TYPE_STRUCT))
-                    {
-                        ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_BAD_NATIVETYPE);
-                        hr = TLBX_E_BAD_SIGNATURE;
-                        goto ExitFunc;                                                            
-                    }
-
-                    // These types are embedded structures so we can treat them as value classes.
-                    goto IsStructWithLayout;
-                }
-                else
-                {
-                    // Classes with layout as parameters must be either marked with [MarshalAs(UnmanagedType.Interface)]
-                    // [MarshalAs(UnmanagedType.LPStruct)] or not have any MarshalAs information.
-                    if ((nativeElem != 0) && (nativeElem != NATIVE_TYPE_LPSTRUCT))
-                    {
-                        ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_BAD_NATIVETYPE);
-                        hr = TLBX_E_BAD_SIGNATURE;
-                        goto ExitFunc;                                                            
-                    }                    
-                }
-            }
-
-            // A reference to some non-system-defined/non delegate derived type.  Get the reference to the
-            //  type, unless it is an imported COM type, in which case, we'll just use
-            //  IUnknown.
-            // If the type is not visible from COM then we return S_USEIUNKNOWN.
-            if (!IsTypeVisibleFromCom(TypeHandle(pRefdClass)))
-                hr = S_USEIUNKNOWN;
-            else
-                hr = EEClassToHref(pCTI, pRefdClass, TRUE, &hRef);
-                
-            if (hr == S_USEIUNKNOWN)
-            {   
-                // Not a known type, so use IUnknown
-                ptdesc->vt = VT_UNKNOWN;
-                goto ExitFunc;
-            }
-       
-            // Not a known class, so make this a pointer to . . .
-            ptdesc->vt = VT_PTR;
-            ptdesc->lptdesc = reinterpret_cast<TYPEDESC*>(ppool->AllocZero(sizeof(TYPEDESC)));
-            if (ptdesc->lptdesc == NULL)
-                IfFailReport(E_OUTOFMEMORY);
-                
-            // . . . a user defined type . . .
-            ptdesc->lptdesc->vt = VT_USERDEFINED;
-            // . . . based on the token.
-            ptdesc->lptdesc->hreftype = hRef;
-        }
-        else  // It's a value type.
-        {   
-IsStructWithLayout:    
-            // If it is an enum, check the underlying type.  All COM enums are 32 bits,
-            //  so if the .Net enum is not a 32 bit enum, convert to the underlying type
-            //  instead of the enum type.
-            if (pRefdClass->IsEnum())
-            {
-                // Get the element type of the underlying type.
-                CorElementType et = pRefdClass->GetInternalCorElementType();
-                // If it is not a 32-bit type or MarshalAs is specified, convert as the
-                // underlying type.
-                if ((et != ELEMENT_TYPE_I4 && et != ELEMENT_TYPE_U4) ||
-                    (nativeElem != 0))
-                {
-                    elem = et;
-                    goto TryWithElemType;
-                }
-                // Fall through to convert as the enum type.
-            }
-            else
-            {
-                // Value classes must be either marked with [MarshalAs(UnmanagedType.Struct)]
-                // or not have any MarshalAs information.
-                if ((nativeElem != 0) && (nativeElem != NATIVE_TYPE_STRUCT))
-                {
-                    ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_BAD_NATIVETYPE);
-                    hr = TLBX_E_BAD_SIGNATURE;
-                    goto ExitFunc;                                                            
-                }
-            }
-                    
-            // A reference to some non-system-defined type. Get the reference to the
-            // type. Since this is a value class we must get a valid href. Otherwise
-            // we fail the conversion.
-            hr = TokenToHref(pCTI, pMT, tkTypeRef, FALSE, &hRef);
-            if (hr == S_USEIUNKNOWN)
-            {
-                SString sClsName;
-                sClsName.SetUTF8(pclsname);
-
-                LPCWSTR szVCName = sClsName.GetUnicode();
-                if (NAMESPACE_SEPARATOR_WCHAR == *szVCName)
-                    szVCName++;
-
-                ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_NONVISIBLEVALUECLASS, szVCName);
-                hr = TLBX_E_BAD_SIGNATURE;
-                goto ExitFunc;
-            }
-
-            // Value class is like other UserDefined types, except passed by value, ie
-            //  on the stack, instead of by pointer.
-            // . . . a user defined type . . .
-            ptdesc->vt = VT_USERDEFINED;
-            // . . . based on the token.
-            ptdesc->hreftype = hRef;
-        }
-        break;
-
-    case ELEMENT_TYPE_SZARRAY:          
-    case ELEMENT_TYPE_ARRAY:
-    {
-        SigPointer sig(&pbSig[cbElem]);
-
-        // Retrieve the type handle for the array elements.
-        TypeHandle thElement = sig.GetTypeHandleThrowing(pModule, &emptyTypeContext);            
-        _ASSERTE(!thElement.IsNull());        
-
-        // Update the index into the managed signature array.
-        IfFailThrow(sig.SkipExactlyOne());
-        cbElem += static_cast<ULONG>(sig.GetPtr() - &pbSig[cbElem]);
-
-        switch (nativeElem)
-        {
-        case 0:
-        case NATIVE_TYPE_SAFEARRAY:
-        {
-            ULONG vtElement = VT_EMPTY;
-
-            // Retrieve the safe array element type.
-            if (cbNativeSig != 0)
-            {
-                cb = CorSigUncompressData(pbNativeSig, &vtElement);
-                pbNativeSig += cb;
-                cbNativeSig -= cb;
-            }
-
-            ArrayMarshalInfo arrayMarshalInfo(IsExportingAs64Bit() ? amiExport64Bit : amiExport32Bit);
-            MarshalInfo::MarshalScenario ms = bMethodSig ? MarshalInfo::MARSHAL_SCENARIO_COMINTEROP : MarshalInfo::MARSHAL_SCENARIO_FIELD;
-            arrayMarshalInfo.InitForSafeArray(ms, thElement, (VARTYPE)vtElement, fAnsi);
-
-            if (!arrayMarshalInfo.IsValid())
-            {
-                ReportWarning(TLBX_E_BAD_SIGNATURE, arrayMarshalInfo.GetErrorResourceId());
-                hr = TLBX_E_BAD_SIGNATURE;
-                goto ExitFunc;
-            }
-
-            // TYPEDESC is an array.
-            ptdesc->vt = VT_SAFEARRAY;
-            ptdesc->lptdesc = reinterpret_cast<TYPEDESC*>(ppool->AllocZero(sizeof(TYPEDESC)));
-            if (ptdesc->lptdesc == NULL)
-                IfFailReport(E_OUTOFMEMORY);
-
-            ArrayToTypeDesc(pCTI, ppool, &arrayMarshalInfo, ptdesc->lptdesc);
-        }
-        break;
-
-        case NATIVE_TYPE_FIXEDARRAY:
-        {
-            ULONG ntElement = NATIVE_TYPE_DEFAULT;
-            
-            // NATIVE_TYPE_FIXEDARRAY is only allowed on fields.
-            if (bMethodSig)
-            {
-                ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_BAD_NATIVETYPE);
-                hr = TLBX_E_BAD_SIGNATURE;
-                goto ExitFunc;
-            }
-           
-            // Retrieve the size of the fixed array. This is required.
-            if (cbNativeSig == 0)
-            {
-                ReportWarning(TLBX_E_BAD_SIGNATURE, IDS_EE_BADMARSHALFIELD_FIXEDARRAY_NOSIZE);
-                hr = TLBX_E_BAD_SIGNATURE;
-                goto ExitFunc;
-            }
-
-            cb = CorSigUncompressData(pbNativeSig, &nativeCount);
-            pbNativeSig += cb;
-            cbNativeSig -= cb;
-
-            // A size const of 0 isn't supported.
-            if (nativeCount == 0)
-            {
-                ReportWarning(TLBX_E_BAD_SIGNATURE, IDS_EE_BADMARSHALFIELD_FIXEDARRAY_ZEROSIZE);
-                hr = TLBX_E_BAD_SIGNATURE;
-                goto ExitFunc;
-            }
-
-            // Read the optional array sub type if specified. 
-            if (cbNativeSig != 0)
-            {
-                cb = CorSigUncompressData(pbNativeSig, &ntElement);
-                pbNativeSig += cb;
-                cbNativeSig -= cb;
-            }
-
-            ArrayMarshalInfo arrayMarshalInfo(IsExportingAs64Bit() ? amiExport64Bit : amiExport32Bit);
-            arrayMarshalInfo.InitForFixedArray(thElement, (CorNativeType)ntElement, fAnsi);
-
-            if (!arrayMarshalInfo.IsValid())
-            {
-                ReportWarning(TLBX_E_BAD_SIGNATURE, arrayMarshalInfo.GetErrorResourceId());
-                hr = TLBX_E_BAD_SIGNATURE;
-                goto ExitFunc;
-            }
-
-            // Set the data
-            ptdesc->vt = VT_CARRAY;
-            ptdesc->lpadesc = reinterpret_cast<ARRAYDESC*>(ppool->AllocZero(sizeof(ARRAYDESC)));
-            if (ptdesc->lpadesc == NULL)
-                IfFailReport(E_OUTOFMEMORY);
-
-            ArrayToTypeDesc(pCTI, ppool, &arrayMarshalInfo, &ptdesc->lpadesc->tdescElem);
-
-            ptdesc->lpadesc->cDims = 1;
-            ptdesc->lpadesc->rgbounds->cElements = nativeCount;
-            ptdesc->lpadesc->rgbounds->lLbound = 0;
-        }
-        break;
-
-        case NATIVE_TYPE_ARRAY:
-        {
-            ULONG ntElement = NATIVE_TYPE_DEFAULT;
-
-            // NATIVE_TYPE_ARRAY is not allowed on fields.
-            if (!bMethodSig)
-            {
-                ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_ARRAY_NEEDS_NT_FIXED);
-                hr = TLBX_E_BAD_SIGNATURE;
-                goto ExitFunc;
-            }
-            
-            // Read the optional array sub type if specified. 
-            if (cbNativeSig != 0)
-            {
-                cb = CorSigUncompressData(pbNativeSig, &ntElement);
-                pbNativeSig += cb;
-                cbNativeSig -= cb;
-            }
-
-            ArrayMarshalInfo arrayMarshalInfo(IsExportingAs64Bit() ? amiExport64Bit : amiExport32Bit);
-            arrayMarshalInfo.InitForNativeArray(MarshalInfo::MARSHAL_SCENARIO_COMINTEROP, thElement, (CorNativeType)ntElement, fAnsi);
-
-            if (!arrayMarshalInfo.IsValid())
-            {
-                ReportWarning(TLBX_E_BAD_SIGNATURE, arrayMarshalInfo.GetErrorResourceId());
-                hr = TLBX_E_BAD_SIGNATURE;
-                goto ExitFunc;
-            }
-    
-            ptdesc->vt = VT_PTR;
-            ptdesc->lptdesc = reinterpret_cast<TYPEDESC*>(ppool->AllocZero(sizeof(TYPEDESC)));
-            if(ptdesc->lptdesc == NULL)
-                IfFailReport(E_OUTOFMEMORY);
-
-            ArrayToTypeDesc(pCTI, ppool, &arrayMarshalInfo, ptdesc->lptdesc);
-        }
-        break;
-
-        default:
-            ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_BAD_NATIVETYPE);
-            hr = TLBX_E_BAD_SIGNATURE;
-            goto ExitFunc;
-        }
-
-        // If we are dealing with an ELEMENT_TYPE_ARRAY, we need to eat the array description.
-        if (elem == ELEMENT_TYPE_ARRAY)
-        {
-            // Eat the rank.
-            cbElem += CorSigUncompressData(pbSig+cbElem, &elem);
-                                                
-            // Count of ubounds, ubounds.
-            cbElem += CorSigUncompressData(pbSig+cbElem, &elem);
-            for (i=elem; i>0; --i)
-                cbElem += CorSigUncompressData(pbSig+cbElem, &elem);
-
-            // Count of lbounds, lbounds.
-            cbElem += CorSigUncompressData(pbSig+cbElem, &elem);
-            for (i=elem; i>0; --i)
-                cbElem += CorSigUncompressData(pbSig+cbElem, &elem);
-        }
-
-        break;
-    }
-
-    case ELEMENT_TYPE_TYPEDBYREF:       // 0x16
-        ptdesc->vt = VT_VARIANT;
-        break;
-
-    //------------------------------------------
-    // This really should be the commented out 
-    //  block following.
-    case ELEMENT_TYPE_I:              // 0x18,
-        ptdesc->vt = GetVtForIntPtr();
-        break;
-                
-    case ELEMENT_TYPE_U:              // 0x19,
-        ptdesc->vt = GetVtForUIntPtr();
-        break;
-
-    case ELEMENT_TYPE_CMOD_REQD:        // 0x1F     // required C modifier : E_T_CMOD_REQD <mdTypeRef/mdTypeDef>
-        ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_UNKNOWN_SIGNATURE);
-        hr = TLBX_E_BAD_SIGNATURE;
-        goto ExitFunc;
-
-    case ELEMENT_TYPE_SENTINEL:
-        goto TryAgain;
-
-    case ELEMENT_TYPE_CMOD_OPT:         // 0x20     // optional C modifier : E_T_CMOD_OPT <mdTypeRef/mdTypeDef>
-        cb = CorSigUncompressToken(&pbSig[cbElem], &tkTypeRef);
-        cbElem += cb;
-        goto TryAgain;
-
-    case ELEMENT_TYPE_FNPTR:
-        {
-        ptdesc->vt = GetVtForIntPtr();
-
-        // Eat the rest of the signature.
-        SigPointer p(&pbSig[cbElem-1]);
-        IfFailThrow(p.SkipExactlyOne());
-        cbElem += (ULONG)(p.GetPtr() - &pbSig[cbElem]);  // Note I didn't use -1 here.
-        break;
-    }
-
-    case ELEMENT_TYPE_GENERICINST: 
-        ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_GENERICINST_SIGNATURE);
-        hr = TLBX_E_BAD_SIGNATURE;
-        goto ExitFunc;
-        break;
-
-    case ELEMENT_TYPE_VAR: 
-    case ELEMENT_TYPE_MVAR: 
-        ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_GENERICPAR_SIGNATURE);
-        hr = TLBX_E_BAD_SIGNATURE;
-        goto ExitFunc;
-        break;
-
-    default:
-        ReportWarning(TLBX_E_BAD_SIGNATURE, TLBX_E_UNKNOWN_SIGNATURE);
-        hr = TLBX_E_BAD_SIGNATURE;
-        goto ExitFunc;
-        break;
-    }
-
-ExitFunc:
-        *pcbElem = cbElem;
-
-    if (hr == S_USEIUNKNOWN)
-        hr = S_OK;
-
-    return hr;
-} // TypeLibExporter::CorSigToTypeDesc
-#ifdef _PREFAST_
-#pragma warning(pop)
-#endif
-
-//*****************************************************************************
-// Get an HREFTYPE for an ITypeInfo, in the context of a ICreateTypeInfo2.
-//*****************************************************************************
-HRESULT TypeLibExporter::TokenToHref(
-    ICreateTypeInfo2 *pCTI,              // Typeinfo being created.
-    MethodTable     *pMT,                // MethodTable with the token.
-    mdToken     tk,                     // The TypeRef to resolve.
-    BOOL        bWarnOnUsingIUnknown,   // A flag indicating if we should warn on substituting IUnknown.
-    HREFTYPE    *pHref)                 // Put HREFTYPE here.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pCTI));
-        PRECONDITION(CheckPointer(pMT));
-        PRECONDITION(CheckPointer(pHref));
-    }
-    CONTRACTL_END;
-
-    MethodTable     *pRefdClass;            // MethodTable object for referenced TypeDef.
-
-    // Get the MethodTable for the referenced class, and see if it is being converted.
-    pRefdClass = LoadClass(pMT->GetModule(), tk);
-
-    // If the type is not visible from COM then we return S_USEIUNKNOWN.
-    if (!IsTypeVisibleFromCom(TypeHandle(pRefdClass)))
-        return S_USEIUNKNOWN;
-
-    return EEClassToHref(pCTI, pRefdClass, bWarnOnUsingIUnknown, pHref);
-} // HRESULT TypeLibExporter::TokenToHref()
-
-//*****************************************************************************
-// Call the resolver to export the typelib for an assembly.
-//*****************************************************************************
-void TypeLibExporter::ExportReferencedAssembly(
-    Assembly    *pAssembly)
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pAssembly));
-    }
-    CONTRACTL_END;
-    
-    HRESULT     hr = S_OK;              // A result.
-    ITypeLib    *pTLB = 0;              // Exported typelib.
-
-    // Assembly as IP.
-    SafeComHolder<IUnknown> pIAssembly = 0;
-    
-    {
-        // Switch to cooperative to get an object ref.
-        GCX_COOP();
-        
-        // Invoke the callback to resolve the reference.
-        OBJECTREF orAssembly=0;
-        GCPROTECT_BEGIN(orAssembly)
-        {
-            orAssembly = pAssembly->GetExposedObject();
-
-            pIAssembly = GetComIPFromObjectRef(&orAssembly, MscorlibBinder::GetClass(CLASS__IASSEMBLY));
-        }
-        GCPROTECT_END();
-    }
-        
-    IfFailReport(m_pNotify->ResolveRef((IUnknown*)pIAssembly, (IUnknown**)&pTLB));
-    
-    // If we got a typelib, store it on the assembly.
-    if (pTLB)
-        pAssembly->SetTypeLib(pTLB);
-} // void TypeLibExporter::ExportReferencedAssembly()
-
-//*****************************************************************************
-// Determine if a class represents a well-known interface, and return that
-//  interface (from its real typelib) if it does.
-//*****************************************************************************
-void TypeLibExporter::GetWellKnownInterface(
-    MethodTable     *pMT,                // MethodTable to check.
-    ITypeInfo   **ppTI)                 // Put ITypeInfo here, if found.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pMT));
-        PRECONDITION(CheckPointer(ppTI));
-    }
-    CONTRACTL_END;
-
-    HRESULT     hr;                     // A result.
-    GUID        guid;                   // The MethodTable guid.
-    WCHAR       wzGuid[40];             // Guid in string format.
-    LONG        cbGuid;                 // Size of guid buffer.
-    GUID        guidTlb;                // The typelib guid.
-    DWORD       dwError;                // Note: HRESULT_FROM_WIN32 macro evaluates the argument 3x times
-
-    
-    HKEYHolder  hInterface;             // Registry key HKCR/Interface
-    HKEYHolder  hGuid;                  // Registry key of .../{xxx...xxx}
-    HKEYHolder  hTlb;                   // Registry key of .../TypeLib
-        
-    // The ITypeLib.
-    SafeComHolder<ITypeLib> pTLB=0;
-
-    // Get the GUID for the class.  Will generate from name if no defined GUID,
-    //  will also use signatures if interface.
-    pMT->GetGuid(&guid, TRUE);
-
-    GuidToLPWSTR(guid, wzGuid, lengthof(wzGuid));
-
-    // Look up that interface in the registry.
-    dwError = WszRegOpenKeyEx(HKEY_CLASSES_ROOT, W("Interface"),0,KEY_READ, &hInterface);
-    hr = HRESULT_FROM_WIN32(dwError);
-    if (FAILED(hr))
-        return;
-
-    dwError = WszRegOpenKeyEx((HKEY)hInterface, wzGuid, 0, KEY_READ, &hGuid);
-    hr = HRESULT_FROM_WIN32(dwError);
-    if (FAILED(hr))
-        return;
-
-    dwError = WszRegOpenKeyEx((HKEY)hGuid, W("TypeLib"), 0, KEY_READ, &hTlb);
-    hr = HRESULT_FROM_WIN32(dwError);
-    if (FAILED(hr))
-        return;
-    
-    cbGuid = sizeof(wzGuid);
-    dwError = WszRegQueryValue((HKEY)hTlb, W(""), wzGuid, &cbGuid);
-    hr = HRESULT_FROM_WIN32(dwError);
-    if (FAILED(hr))
-        return;
-    
-    CLSIDFromString(wzGuid, &guidTlb);
-
-    // Retrieve the major and minor version number.
-    USHORT wMajor;
-    USHORT wMinor;
-    Assembly *pAssembly = pMT->GetAssembly();
-
-    hr = GetTypeLibVersionForAssembly(pAssembly,&wMajor, &wMinor);
-    if (SUCCEEDED(hr))
-    {
-        hr = LoadRegTypeLib(guidTlb, wMajor, wMinor, 0, &pTLB);
-    }
-    if (FAILED(hr))
-    {
-        pAssembly->GetVersion(&wMajor, &wMinor, NULL, NULL);
-
-        hr = LoadRegTypeLib(guidTlb, wMajor, wMinor, 0, &pTLB);
-        if (FAILED(hr))
-        {
-            hr = LoadRegTypeLib(guidTlb, -1, -1, 0, &pTLB);
-            if (FAILED(hr))
-            {
-                return;
-            }
-        }
-    }
-    
-
-    hr = pTLB->GetTypeInfoOfGuid(guid, ppTI);
-} // void TypeLibExporter::GetWellKnownInterface()
-    
-//*****************************************************************************
-// Get an HREFTYPE for an ITypeInfo, in the context of a ICreateTypeInfo2.
-//*****************************************************************************
-HRESULT TypeLibExporter::EEClassToHref( // S_OK or error.
-    ICreateTypeInfo2 *pCTI,             // Typeinfo being created.
-    MethodTable     *pClass,                // The MethodTable * to resolve.
-    BOOL        bWarnOnUsingIUnknown,   // A flag indicating if we should warn on substituting IUnknown.
-    HREFTYPE    *pHref)                 // Put HREFTYPE here.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pCTI));
-        PRECONDITION(CheckPointer(pClass));
-        PRECONDITION(CheckPointer(pHref));
-    }
-    CONTRACTL_END;
-    
-    HRESULT     hr=S_OK;                // A result.
-    int         bUseIUnknown=false;     // Use IUnknown (if so, don't release pTI)?
-    int         bUseIUnknownWarned=false; // If true, used IUnknown, but already issued a more specific warning.
-    CExportedTypesInfo sExported;       // Cached ICreateTypeInfo pointers.
-    CExportedTypesInfo *pExported;      // Pointer to found or new cached pointers.
-    CHrefOfClassHashKey sLookup;        // Hash structure to lookup.
-    CHrefOfClassHashKey *pFound;        // Found structure.
-    bool        bImportedAssembly;      // The assembly containing pClass is imported.
-    bool        bForceResolveCallback;  // Type library resolution should always be handled by caller first.
-
-    // A different typeinfo; default for pTI.
-    SafeComHolder<ITypeInfo> pTIDef=0;
-
-    // A TypeInfo; maybe for TypeDef, maybe for TypeRef.
-    SafeComHolder<ITypeInfo> pTI=0;
-
-
-    // See if we already know this MethodTable' href.
-    sLookup.pClass = pClass;
-    if ((pFound=m_HrefOfClassHash.Find(&sLookup)) != NULL)
-    {
-        *pHref = pFound->href;
-        if (*pHref == m_hIUnknown)
-            return S_USEIUNKNOWN;
-        return S_OK;
-    }
-
-    // See if the class is in the export list.
-    sExported.pClass = pClass;
-    pExported = m_Exports.Find(&sExported);
-
-    // If not in the exported assembly, possibly it was injected?
-    if (pExported == 0)
-    {
-        pExported = m_InjectedExports.Find(&sExported);
-    }
-    
-    // Is there an export for this class?
-    if (pExported)
-    {   
-        // Yes, For interfaces and value types (and enums), just use the typeinfo.
-        if (pClass->IsValueType() || pClass->IsEnum() || pClass->HasLayout())
-        {
-            // No default interface, so use the class itself.     
-            if (pExported->pCTI)
-                IfFailReport(SafeQueryInterface(pExported->pCTI, IID_ITypeInfo, (IUnknown**)&pTI));
-        }
-        else
-        if (!pClass->IsInterface())
-        {   
-            // If there is an explicit default interface, get the class for it.
-            TypeHandle hndDefItfClass;
-            DefaultInterfaceType DefItfType;
-            DefItfType = GetDefaultInterfaceForClassWrapper(TypeHandle(pClass), &hndDefItfClass);
-            switch (DefItfType)
-            {
-                case DefaultInterfaceType_Explicit:
-                {
-                    _ASSERTE(!hndDefItfClass.IsNull());
-
-                    // Recurse to get the href for the default interface class.
-                    hr = EEClassToHref(pCTI, hndDefItfClass.GetMethodTable(), bWarnOnUsingIUnknown, pHref);
-                    // Done.  Note that the previous call will have cached the href for 
-                    //  the default interface class.  As this function exits, it will
-                    //  also cache the SAME href for this class.
-                    goto ErrExit;
-                }
-
-                case DefaultInterfaceType_AutoDispatch:
-                case DefaultInterfaceType_AutoDual:
-                {
-                    _ASSERTE(!hndDefItfClass.IsNull());
-
-                    if (hndDefItfClass.GetMethodTable() != pClass)
-                    {
-                        // Recurse to get the href for the default interface class.
-                        hr = EEClassToHref(pCTI, hndDefItfClass.GetMethodTable(), bWarnOnUsingIUnknown, pHref);
-                        // Done.  Note that the previous call will have cached the href for 
-                        //  the default interface class.  As this function exits, it will
-                        //  also cache the SAME href for this class.
-                        goto ErrExit;
-                    }
-
-                    // Return the class interface.
-                    _ASSERTE(pExported->pCTIClassItf);
-                    IfFailReport(SafeQueryInterface(pExported->pCTIClassItf, IID_ITypeInfo, (IUnknown**)&pTI));
-                    break;
-                }
-
-                case DefaultInterfaceType_IUnknown:
-                case DefaultInterfaceType_BaseComClass:
-                {
-                    pTI = m_pIUnknown;
-                    bUseIUnknown=true;
-                    SafeAddRef(pTI);
-                    break;
-                }
-
-                default:
-                {
-                    _ASSERTE(!"Invalid default interface type!");
-                    hr = E_FAIL;
-                    break;
-                }
-            }
-        }
-        else
-        {   // This is an interface, so use the typeinfo for the interface, if there is one.
-            if (pExported->pCTI)
-                IfFailReport(SafeQueryInterface(pExported->pCTI, IID_ITypeInfo, (IUnknown**)&pTI));
-        }
-
-        if ((IUnknown*)pTI == 0)
-        {
-            // This is a class from the module/assembly, yet it is not being exported.
-            
-            // Whatever happens, the result is OK.
-            hr = S_OK;
-            
-            if (pClass->IsComImport())
-            {
-                // If it is an imported type, get an href to it.
-                GetWellKnownInterface(pClass, &pTI);
-            }
-            
-            // If still didn't get a TypeInfo, use IUnknown.
-            if ((IUnknown*)pTI == 0)
-            {
-                pTI = m_pIUnknown;
-                bUseIUnknown=true;
-                SafeAddRef(pTI);
-            }
-        }
-    }
-    else
-    {   // Not local.  Try to get from the class' module's typelib.
-        // If the caller wants to get a chance to resolve type library references themselves (before we go probing the assembly),
-        // we'll skip the next step and go directly to the notify sink callback.
-        bForceResolveCallback = (m_flags & TlbExporter_CallerResolvedReferences) != 0;
-        if (!bForceResolveCallback)
-            hr = GetITypeInfoForEEClass(pClass, &pTI, false/* interface, not coclass */, false/* do not create */, m_flags);
-
-        // If getting the typeinfo from the class itself failed, there are 
-        //  several possibilities:
-        //  - typelib didn't exist, and couldn't be created.
-        //  - typelib did exist, but didn't contain the typeinfo.
-        // We can create a local (to the exported typelib) copy of the 
-        //  typeinfo, and get a reference to that.
-        // However, we don't want to export the whole tree into this typelib,
-        //  so we only create the typeinfo if the typelib existed  but the
-        // typeinfo wasn't found and the assembly is not an imported assembly.
-        bImportedAssembly = pClass->GetAssembly()->IsImportedFromTypeLib();
-
-        if (bForceResolveCallback || (FAILED(hr) && hr != TYPE_E_ELEMENTNOTFOUND && !bImportedAssembly))
-        {
-            // Invoke the callback to resolve the reference.
-            
-            Assembly *pAssembly = pClass->GetAssembly();
-            
-            ExportReferencedAssembly(pAssembly);
-            
-            hr = GetITypeInfoForEEClass(pClass, &pTI, false/* interface, not coclass */, false/* do not create */, m_flags);
-        }
-        
-        if (hr == TYPE_E_ELEMENTNOTFOUND)
-        {   
-            if (pClass->IsComImport())
-            {
-                // If it is an imported type, get an href to it.
-                
-                // Whatever happens, the result is OK.
-                hr = S_OK;
-
-                GetWellKnownInterface(pClass, &pTI);
-                
-                // If still didn't get a TypeInfo, use IUnknown.
-                if ((IUnknown*)pTI == 0)
-                {
-                    pTI = m_pIUnknown;
-                    bUseIUnknown=true;
-                    SafeAddRef(pTI);
-                }
-            }
-            else
-            {
-                // Convert the single typedef from the other scope.
-                ConvertOneTypeDef(pClass);
-                
-                // Now that the type has been injected, recurse to let the default-interface code run.
-                hr = EEClassToHref(pCTI, pClass, bWarnOnUsingIUnknown, pHref);
-                
-                // This class should already have been cached by the recursive call.  Don't want to add
-                //  it again.
-                goto ErrExit2;
-            }
-        }
-        else if (FAILED(hr))
-        {
-            DefineFullyQualifiedNameForClassWOnStack();
-            LPCWSTR szName = GetFullyQualifiedNameForClassNestedAwareW(pClass);
-            if (hr == TLBX_W_LIBNOTREGISTERED)
-            {
-                // The imported typelib is not registered on this machine.  Give a warning, and substitute IUnknown.
-                ReportEvent(NOTIF_CONVERTWARNING, hr, szName, (LPCWSTR) pClass->GetAssembly()->GetManifestModule()->GetPath());
-                hr = S_OK;
-                pTI = m_pIUnknown;
-                bUseIUnknown = true;
-                SafeAddRef(pTI);
-                bUseIUnknownWarned = true;
-            }
-            else if (hr == TLBX_E_CANTLOADLIBRARY)
-            {
-                // The imported typelib is registered, but can't be loaded.  Corrupt?  Missing?
-                InternalThrowHRWithContext(TLBX_E_CANTLOADLIBRARY, szName, (LPCWSTR) pClass->GetAssembly()->GetManifestModule()->GetPath());
-            }
-            IfFailReport(hr);
-        }
-    }
-
-    // Make sure we could resolve the typeinfo.
-    if (!(IUnknown*)pTI)
-        IfFailReport(TYPE_E_ELEMENTNOTFOUND);
-
-    // Assert that the containing typelib for pContainer is the typelib being created.
-#if defined(_DEBUG)
-    {
-        SafeComHolder<ITypeInfo> pTI=0;
-        SafeComHolder<ITypeLib> pTL=0;
-        SafeComHolder<ITypeLib> pTLMe=0;
-        UINT ix;
-        SafeQueryInterface(pCTI, IID_ITypeInfo, (IUnknown**)&pTI);
-        SafeQueryInterface(m_pICreateTLB, IID_ITypeLib, (IUnknown**)&pTLMe);
-        pTI->GetContainingTypeLib(&pTL, &ix);
-        _ASSERTE(pTL == pTLMe);
-    }
-#endif
-
-    // If there is an ITypeInfo, convert to HREFTYPE.
-    if ((IUnknown*)pTI)
-    {
-        if ((IUnknown*)pTI != m_pIUnknown)
-        {
-            // Resolve to default.
-            if (pTIDef)
-                hr = S_OK;  // Already have default.
-            else
-            {
-                // TypeLib API has a issue (sort of by design):
-                // Before a type (and its dependencies) is completely created (all members added), 
-                // if you call Layout(), or anything that will lead to Layout(), such as ITypeInfo::GetTypeAttr
-                // it will give the type an incorrect size. Ideally TypeLib API should fail in this case.
-                // Anyway, we only need to avoid calling Layout() directly or indirectly until we have
-                // completely created all types. 
-                // In this case, we are calling ITypeInfo::GetTypeAttr() in the function below, which is only
-                // needed for coclasses. Fortunately, coclass doesn't have a size problem, as it don't have any members
-                // So, we skip calling GetDefaultInterfaceForCoclass unless the class is an coclass.
-                if (TKindFromClass(pClass) == TKIND_COCLASS)
-                    IfFailReport(GetDefaultInterfaceForCoclass(pTI, &pTIDef));
-                else
-                    hr = S_FALSE;
-            }
-            
-            if (hr == S_OK)
-                hr = pCTI->AddRefTypeInfo(pTIDef, pHref);
-            else
-                hr = pCTI->AddRefTypeInfo(pTI, pHref);
-        }
-        else
-        {   // pTI == m_pIUnknown
-            if (m_hIUnknown == -1)
-                hr = pCTI->AddRefTypeInfo(pTI, &m_hIUnknown);
-            *pHref = m_hIUnknown;
-        }
-    }
-    
-ErrExit:
-    // If we got the href...
-    if (hr == S_OK)
-    {
-        // Save for later use.
-        if ( NULL == (pFound=m_HrefOfClassHash.Add(&sLookup)))
-            IfFailReport(E_OUTOFMEMORY);
-        
-        pFound->pClass = pClass;
-        pFound->href = *pHref;
-    }
-
-    // If substituting IUnknown, give a warning.
-    if (hr == S_OK && bUseIUnknown && bWarnOnUsingIUnknown && !bUseIUnknownWarned)
-    {
-        DefineFullyQualifiedNameForClassWOnStack();
-        LPCWSTR szName = GetFullyQualifiedNameForClassNestedAwareW(pClass);
-        ReportWarning(S_OK, TLBX_I_USEIUNKNOWN, szName);
-    }
-    
-ErrExit2:    
-    if (hr == S_OK && bUseIUnknown)
-        hr = S_USEIUNKNOWN;
-
-    return hr;
-} // HRESULT TypeLibExporter::EEClassToHref()
-
-//*****************************************************************************
-// Retrieve an HRef to the a type defined in StdOle.
-//*****************************************************************************
-void TypeLibExporter::StdOleTypeToHRef(ICreateTypeInfo2 *pCTI, REFGUID rGuid, HREFTYPE *pHref)
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pCTI));
-        PRECONDITION(CheckPointer(pHref));
-    }
-    CONTRACTL_END;
-    
-    HRESULT hr = S_OK;
-    SafeComHolder<ITypeLib> pITLB = NULL;
-    SafeComHolder<ITypeInfo> pITI = NULL;
-    MEMBERID MemID = 0;
-    USHORT cFound = 0;
-
-    IfFailReport(LoadRegTypeLib(LIBID_STDOLE2, -1, -1, 0, &pITLB));
-    IfFailReport(pITLB->GetTypeInfoOfGuid(rGuid, &pITI));
-    IfFailReport(pCTI->AddRefTypeInfo(pITI, pHref));
-} // void TypeLibExporter::ColorToHRef()
-
-//*****************************************************************************
-// Given a TypeDef's flags, determine the proper TYPEKIND.
-//*****************************************************************************
-TYPEKIND TypeLibExporter::TKindFromClass(
-    MethodTable     *pClass)                // MethodTable.
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pClass));
-    }
-    CONTRACTL_END;
-    
-    HRESULT hr;
-    ULONG ulIface = ifDual;       // Is this interface [dual], IUnknown, or DISPINTERFACE.
-    
-    if (pClass->IsInterface())
-    {
-        // IDispatch or IUnknown derived?
-        IfFailReport(pClass->GetMDImport()->GetIfaceTypeOfTypeDef(pClass->GetCl(), &ulIface));
-        if (ulIface == ifDispatch)
-            return TKIND_DISPATCH;
-        
-        return TKIND_INTERFACE;
-    }
-    
-    if (pClass->IsEnum())
-        return TKIND_ENUM;
-
-    if (pClass->IsValueType() || pClass->HasLayout())
-    {
-        TYPEKIND    tkResult=TKIND_RECORD;  // The resulting typekind.
-        mdFieldDef  fd;                     // A Field def.
-        ULONG       cFD;                    // Count of fields.
-        ULONG       iFD=0;                  // Loop control.
-        ULONG       ulOffset;               // Field offset.
-        bool        bNonZero=false;         // Found any non-zero?
-        MD_CLASS_LAYOUT sLayout;            // For enumerating layouts.
-
-        // To enum fields.
-        HENUMInternalHolder eFDi(pClass->GetMDImport());
-        eFDi.EnumInit(mdtFieldDef, pClass->GetCl());
-        
-        // Get an enumerator for the FieldDefs in the TypeDef.  Only need the counts.
-        cFD = pClass->GetMDImport()->EnumGetCount(&eFDi);
-
-        // Get an enumerator for the class layout.
-        IfFailReport(pClass->GetMDImport()->GetClassLayoutInit(pClass->GetCl(), &sLayout));
-
-        // Enumerate the layout.
-        while (pClass->GetMDImport()->GetClassLayoutNext(&sLayout, &fd, &ulOffset) == S_OK)
-        {
-            if (ulOffset != 0)
-            {
-                bNonZero = true;
-                break;
-            }
-            ++iFD;
-        }
-
-        // If there were fields, all had layout, and all layouts are zero, call it a union.
-        if (cFD > 0 && iFD == cFD && !bNonZero)
-            tkResult = TKIND_UNION;
-
-        return tkResult;
-    }
-    
-    return TKIND_COCLASS;
-} // TYPEKIND TypeLibExporter::TKindFromClass()
-
-//*****************************************************************************
-// Generate a HREFTYPE in the output TypeLib for a TypeInfo.
-//*****************************************************************************
-void TypeLibExporter::GetRefTypeInfo(
-    ICreateTypeInfo2   *pContainer, 
-    ITypeInfo   *pReferenced, 
-    HREFTYPE    *pHref)
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(pContainer));
-        PRECONDITION(CheckPointer(pReferenced));
-        PRECONDITION(CheckPointer(pHref));
-    }
-    CONTRACTL_END;
-
-    HRESULT     hr;                     // A result.
-    CHrefOfTIHashKey sLookup;               // Hash structure to lookup.
-    CHrefOfTIHashKey *pFound;               // Found structure.
-
-    // See if we already know this TypeInfo.
-    sLookup.pITI = pReferenced;
-    if ((pFound=m_HrefHash.Find(&sLookup)) != NULL)
-    {
-        *pHref = pFound->href;
-        return;
-    }
-
-    // Assert that the containing typelib for pContainer is the typelib being created.
-#if defined(_DEBUG)
-    {
-        SafeComHolder<ITypeInfo> pTI=0;
-        SafeComHolder<ITypeLib> pTL=0;
-        SafeComHolder<ITypeLib> pTLMe=0;
-    UINT ix;
-        
-        SafeQueryInterface(pContainer, IID_ITypeInfo, (IUnknown**)&pTI);
-        SafeQueryInterface(m_pICreateTLB, IID_ITypeLib, (IUnknown**)&pTLMe);
-    pTI->GetContainingTypeLib(&pTL, &ix);
-    _ASSERTE(pTL == pTLMe);
-    }
-#endif
-
-    // Haven't seen it -- add the href.
-    // NOTE: This code assumes that hreftypes are per-typelib.
-    IfFailReport(pContainer->AddRefTypeInfo(pReferenced, pHref));
-
-    // Save for later use.
-    pFound=m_HrefHash.Add(&sLookup);
-    if (pFound == NULL)
-        IfFailReport(E_OUTOFMEMORY);
-    
-    // Prefix can't tell that IfFailReport will actually throw an exception if pFound is NULL so
-    // let's tell it explicitly that if we reach this point pFound will not be NULL.
-    PREFIX_ASSUME(pFound != NULL);        
-    pFound->pITI = pReferenced;
-    pFound->href = *pHref;
-    pReferenced->AddRef();
-} // HRESULT TypeLibExporter::GetRefTypeInfo()
-
-//*****************************************************************************
-// Implementation of a hashed ITypeInfo to HREFTYPE association.
-//*****************************************************************************
-void TypeLibExporter::CHrefOfTIHash::Clear()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-    
-    CHrefOfTIHashKey *p;
-    for (p=GetFirst();  p;  p=GetNext(p))
-    {
-        SafeRelease(p->pITI);
-    }
-    
-    CClosedHash<class CHrefOfTIHashKey>::Clear();
-} // void TypeLibExporter::CHrefOfTIHash::Clear()
-
-unsigned int TypeLibExporter::CHrefOfTIHash::Hash(const CHrefOfTIHashKey *pData)
-{
-    LIMITED_METHOD_CONTRACT;
-    
-#ifndef _WIN64
-    // The pointers are at least 4-byte aligned, so ignore bottom two bits.
-    return (unsigned int) (((size_t)(pData->pITI))>>2);
-#else
-    // @TODO IA64: Is this a good hashing mechanism on IA64?
-    return (unsigned int) (((size_t)(pData->pITI))>>3);
-#endif
-} // unsigned long TypeLibExporter::CHrefOfTIHash::Hash()
-
-unsigned int TypeLibExporter::CHrefOfTIHash::Compare(const CHrefOfTIHashKey *p1, CHrefOfTIHashKey *p2)
-{
-    LIMITED_METHOD_CONTRACT;
-    
-    if (p1->pITI == p2->pITI)
-        return (0);
-    return (1);
-} // unsigned long TypeLibExporter::CHrefOfTIHash::Compare()
-
-TypeLibExporter::CHrefOfTIHash::ELEMENTSTATUS TypeLibExporter::CHrefOfTIHash::Status(CHrefOfTIHashKey *p)
-{
-    LIMITED_METHOD_CONTRACT;
-    if (p->pITI == reinterpret_cast<ITypeInfo*>(FREE))
-        return (FREE);
-    if (p->pITI == reinterpret_cast<ITypeInfo*>(DELETED))
-        return (DELETED);
-    return (USED);
-} // TypeLibExporter::CHrefOfTIHash::ELEMENTSTATUS TypeLibExporter::CHrefOfTIHash::Status()
-
-void TypeLibExporter::CHrefOfTIHash::SetStatus(CHrefOfTIHashKey *p, ELEMENTSTATUS s)
-{
-    LIMITED_METHOD_CONTRACT;
-    
-    p->pITI = reinterpret_cast<ITypeInfo*>(s);
-} // void TypeLibExporter::CHrefOfTIHash::SetStatus()
-
-void *TypeLibExporter::CHrefOfTIHash::GetKey(CHrefOfTIHashKey *p)
-{
-    LIMITED_METHOD_CONTRACT;
-    
-    return &p->pITI;
-} // void *TypeLibExporter::CHrefOfTIHash::GetKey()
-
-
-//*****************************************************************************
-// Implementation of a hashed MethodTable* to HREFTYPE association.
-//*****************************************************************************
-void TypeLibExporter::CHrefOfClassHash::Clear()
-{
-    WRAPPER_NO_CONTRACT;
-    CClosedHash<class CHrefOfClassHashKey>::Clear();
-} // void TypeLibExporter::CHrefOfClassHash::Clear()
-
-unsigned int TypeLibExporter::CHrefOfClassHash::Hash(const CHrefOfClassHashKey *pData)
-{
-    LIMITED_METHOD_CONTRACT;
-    
-#ifndef _WIN64
-    // Tbe pointers are at least 4-byte aligned, so ignore bottom two bits.
-    return (unsigned int) (((size_t)(pData->pClass))>>2);
-#else
-    // @TODO IA64: Is this a good hashing mechanism on IA64?
-    return (unsigned int) (((size_t)(pData->pClass))>>3);
-#endif
-} // unsigned long TypeLibExporter::CHrefOfClassHash::Hash()
-
-unsigned int TypeLibExporter::CHrefOfClassHash::Compare(const CHrefOfClassHashKey *p1, CHrefOfClassHashKey *p2)
-{
-    LIMITED_METHOD_CONTRACT;
-    
-    if (p1->pClass == p2->pClass)
-        return (0);
-    return (1);
-} // unsigned long TypeLibExporter::CHrefOfClassHash::Compare()
-
-TypeLibExporter::CHrefOfClassHash::ELEMENTSTATUS TypeLibExporter::CHrefOfClassHash::Status(CHrefOfClassHashKey *p)
-{
-    LIMITED_METHOD_CONTRACT;
-    
-    if (p->pClass == reinterpret_cast<MethodTable*>(FREE))
-        return (FREE);
-    if (p->pClass == reinterpret_cast<MethodTable*>(DELETED))
-        return (DELETED);
-    return (USED);
-} // TypeLibExporter::CHrefOfClassHash::ELEMENTSTATUS TypeLibExporter::CHrefOfClassHash::Status()
-
-void TypeLibExporter::CHrefOfClassHash::SetStatus(CHrefOfClassHashKey *p, ELEMENTSTATUS s)
-{
-    LIMITED_METHOD_CONTRACT;
-    
-    p->pClass = reinterpret_cast<MethodTable*>(s);
-} // void TypeLibExporter::CHrefOfClassHash::SetStatus()
-
-void *TypeLibExporter::CHrefOfClassHash::GetKey(CHrefOfClassHashKey *p)
-{
-    LIMITED_METHOD_CONTRACT;
-    
-    return &p->pClass;
-} // void *TypeLibExporter::CHrefOfClassHash::GetKey()
-
-
-//*****************************************************************************
-// Implementation of a hashed MethodTable* to conversion information association.
-//*****************************************************************************
-void TypeLibExporter::CExportedTypesHash::Clear()
-{
-    WRAPPER_NO_CONTRACT;
-
-    // Iterate over entries and free pointers.
-    CExportedTypesInfo *pData;
-    pData = GetFirst();
-    while (pData)
-    {
-        SetStatus(pData, DELETED);
-        pData = GetNext(pData);
-    }
-
-    CClosedHash<class CExportedTypesInfo>::Clear();
-} // void TypeLibExporter::CExportedTypesHash::Clear()
-
-unsigned int TypeLibExporter::CExportedTypesHash::Hash(const CExportedTypesInfo *pData)
-{
-    LIMITED_METHOD_CONTRACT;    
-    
-#ifndef _WIN64
-    // Tbe pointers are at least 4-byte aligned, so ignore bottom two bits.
-    return (unsigned int) (((size_t)(pData->pClass))>>2);
-#else
-    // @TODO IA64: Is this a good hashing mechanism on IA64?
-    return (unsigned int) (((size_t)(pData->pClass))>>3);
-#endif
-} // unsigned long TypeLibExporter::CExportedTypesHash::Hash()
-
-unsigned int TypeLibExporter::CExportedTypesHash::Compare(const CExportedTypesInfo *p1, CExportedTypesInfo *p2)
-{
-    LIMITED_METHOD_CONTRACT;
-    
-    if (p1->pClass == p2->pClass)
-        return (0);
-    return (1);
-} // unsigned long TypeLibExporter::CExportedTypesHash::Compare()
-
-TypeLibExporter::CExportedTypesHash::ELEMENTSTATUS TypeLibExporter::CExportedTypesHash::Status(CExportedTypesInfo *p)
-{
-    LIMITED_METHOD_CONTRACT;
-    
-    if (p->pClass == reinterpret_cast<MethodTable*>(FREE))
-        return (FREE);
-    if (p->pClass == reinterpret_cast<MethodTable*>(DELETED))
-        return (DELETED);
-    return (USED);
-} // TypeLibExporter::CExportedTypesHash::ELEMENTSTATUS TypeLibExporter::CExportedTypesHash::Status()
-
-void TypeLibExporter::CExportedTypesHash::SetStatus(CExportedTypesInfo *p, ELEMENTSTATUS s)
-{
-    WRAPPER_NO_CONTRACT;
-    
-    // If deleting a used entry, free the pointers.
-    if (s == DELETED && Status(p) == USED)
-    {
-        if (p->pCTI) p->pCTI->Release(), p->pCTI=0;
-        if (p->pCTIClassItf) p->pCTIClassItf->Release(), p->pCTIClassItf=0;
-    }
-    p->pClass = reinterpret_cast<MethodTable*>(s);
-} // void TypeLibExporter::CExportedTypesHash::SetStatus()
-
-void *TypeLibExporter::CExportedTypesHash::GetKey(CExportedTypesInfo *p)
-{
-    LIMITED_METHOD_CONTRACT;
-    
-    return &p->pClass;
-} // void *TypeLibExporter::CExportedTypesHash::GetKey()
-
-void TypeLibExporter::CExportedTypesHash::InitArray()
-{
-    STANDARD_VM_CONTRACT;
-    
-    // For iterating the entries.
-    CExportedTypesInfo *pData = 0;
-    
-    // Make room for the data.
-    m_iCount = 0;
-    m_Array = new CExportedTypesInfo*[Base::Count()];
-    
-    // Fill the array.
-    pData = GetFirst();
-    while (pData)
-    {
-        m_Array[m_iCount++] = pData;
-        pData = GetNext(pData);
-    }
-} // void TypeLibExporter::CExportedTypesHash::InitArray()
-
-void TypeLibExporter::CExportedTypesHash::UpdateArray()
-{
-    STANDARD_VM_CONTRACT;
-    
-    // For iterating the entries.
-    CExportedTypesInfo *pData = 0;
-
-    // Clear the old data.
-    if (m_Array)
-        delete[] m_Array;
-    
-    // Make room for the data.
-    m_iCount = 0;
-    m_Array = new CExportedTypesInfo*[Base::Count()];
-    
-    // Fill the array.
-    pData = GetFirst();
-    while (pData)
-    {
-        m_Array[m_iCount++] = pData;
-        pData = GetNext(pData);
-    }
-} // void TypeLibExporter::CExportedTypesHash::UpdateArray()
-
-void TypeLibExporter::CExportedTypesHash::SortByName()
-{
-    WRAPPER_NO_CONTRACT;
-    
-    CSortByName sorter(m_Array, (int)m_iCount);
-    sorter.Sort();
-} // void TypeLibExporter::CExportedTypesHash::SortByName()
-
-void TypeLibExporter::CExportedTypesHash::SortByToken()
-{
-    WRAPPER_NO_CONTRACT;
-    
-    CSortByToken sorter(m_Array, (int)m_iCount);
-    sorter.Sort();
-} // void TypeLibExporter::CExportedTypesHash::SortByToken()
-
-int TypeLibExporter::CExportedTypesHash::CSortByToken::Compare(
-    CExportedTypesInfo **p1,
-    CExportedTypesInfo **p2)
-{
-    LIMITED_METHOD_CONTRACT;
-
-    MethodTable *pC1 = (*p1)->pClass;
-    MethodTable *pC2 = (*p2)->pClass;
-    // Compare scopes.
-    if (pC1->GetMDImport() < pC2->GetMDImport())
-        return -1;
-    if (pC1->GetMDImport() > pC2->GetMDImport())
-        return 1;
-    // Same scopes, compare tokens.
-    if (pC1->GetTypeDefRid() < pC2->GetTypeDefRid())
-        return -1;
-    if (pC1->GetTypeDefRid() > pC2->GetTypeDefRid())
-        return 1;
-    // Hmmm.  Same class.
-    return 0;
-} // int TypeLibExporter::CExportedTypesHash::CSortByToken::Compare()
-
-int TypeLibExporter::CExportedTypesHash::CSortByName::Compare(
-    CExportedTypesInfo **p1,
-    CExportedTypesInfo **p2)
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(p1));
-        PRECONDITION(CheckPointer(p2));
-        PRECONDITION(CheckPointer(*p1));
-        PRECONDITION(CheckPointer(*p2));
-    }
-    CONTRACTL_END;
-    
-    int iRslt;                          // A compare result.
-    
-    MethodTable *pC1 = (*p1)->pClass;
-    MethodTable *pC2 = (*p2)->pClass;
-    
-    // Ignore scopes.  Need to see name collisions across scopes.
-    // Same scopes, compare names.
-    LPCSTR pName1, pNS1;
-    LPCSTR pName2, pNS2;
-    IfFailThrow(pC1->GetMDImport()->GetNameOfTypeDef(pC1->GetCl(), &pName1, &pNS1));
-    IfFailThrow(pC2->GetMDImport()->GetNameOfTypeDef(pC2->GetCl(), &pName2, &pNS2));
-    
-    // Compare case-insensitive, because we want different capitalizations to sort together.
-    SString sName1(SString::Utf8, pName1);
-    SString sName2(SString::Utf8, pName2);
-
-    iRslt = sName1.CompareCaseInsensitive(sName2);
-    if (iRslt)
-        return iRslt;
-    
-    // If names are spelled the same, ignoring capitalization, sort by namespace.
-    //  We will attempt to use namespace for disambiguation.
-    SString sNS1(SString::Utf8, pNS1);
-    SString sNS2(SString::Utf8, pNS2);
-    
-    iRslt = sNS1.CompareCaseInsensitive(sNS2);
-    return iRslt;
-} // int TypeLibExporter::CExportedTypesHash::CSortByName::Compare()
-
diff --git a/src/vm/typeparse.cpp b/src/vm/typeparse.cpp
index 28521f1839..68ff76273d 100644
--- a/src/vm/typeparse.cpp
+++ b/src/vm/typeparse.cpp
@@ -1570,15 +1570,6 @@ TypeHandle TypeName::GetTypeFromAsm(BOOL bForIntrospection)
         _ASSERTE(!"You must pass either a asm-qualified typename or an actual Assembly.");
     }
 
-#ifdef FEATURE_FUSION
-    if (th.IsNull() && bLoadTypeFromPartialNameHack && GetAssembly() && !GetAssembly()->IsEmpty())
-    {
-        DomainAssembly* pPartialBindAssemblyHack = LoadAssemblyFromPartialNameHack(GetAssembly());
-
-        if (pPartialBindAssemblyHack)
-            th = GetTypeHaveAssembly(pPartialBindAssemblyHack->GetAssembly(), bThrowIfNotFound, bIgnoreCase, NULL);
-    }
-#endif // FEATURE_FUSION
 
     if (!th.IsNull() && (!m_genericArguments.IsEmpty() || !m_signature.IsEmpty()))
     {
@@ -1819,46 +1810,6 @@ TypeName::GetTypeHaveAssemblyHelper(
     return th;
 } // TypeName::GetTypeHaveAssemblyHelper
 
-#ifdef FEATURE_FUSION
-DomainAssembly* LoadAssemblyFromPartialNameHack(SString* psszAssemblySpec, BOOL fCropPublicKey)
-{
-    CONTRACTL
-    {
-        MODE_COOPERATIVE;
-        THROWS;
-        GC_TRIGGERS;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-    
-    MethodDescCallSite loadWithPartialNameHack(METHOD__ASSEMBLY__LOAD_WITH_PARTIAL_NAME_HACK);   
-    ARG_SLOT args[2];
-    STRINGREF mszAssembly = NULL;
-    DomainAssembly* pPartialBindAssemblyHack = NULL;
-    GCPROTECT_BEGIN(mszAssembly);
-    {
-        mszAssembly = StringObject::NewString(psszAssemblySpec->GetUnicode());
-        args[0] = ObjToArgSlot(mszAssembly);
-        args[1] = BoolToArgSlot(fCropPublicKey);
-
-        ASSEMBLYREF assembly = (ASSEMBLYREF)loadWithPartialNameHack.Call_RetOBJECTREF(args);
-        
-        if (assembly != NULL)
-        {
-            pPartialBindAssemblyHack = (DomainAssembly*) assembly->GetDomainAssembly();
-
-            if (pPartialBindAssemblyHack->GetAssembly()->IsCollectible())
-            {
-                // Should not be possible to reach
-                COMPlusThrow(kNotSupportedException, W("NotSupported_CollectibleAssemblyResolve"));
-            }
-        }
-    }
-    GCPROTECT_END();
-
-    return pPartialBindAssemblyHack;
-}
-#endif // FEATURE_FUSION
 
 DomainAssembly * LoadDomainAssembly(
     SString *  psszAssemblySpec, 
@@ -1902,7 +1853,6 @@ DomainAssembly * LoadDomainAssembly(
         spec.SetParentAssembly(pRequestingAssembly->GetDomainAssembly());
     }
     
-#if defined(FEATURE_HOST_ASSEMBLY_RESOLVER)    
     // If the requesting assembly has Fallback LoadContext binder available,
     // then set it up in the AssemblySpec.
     if (pRequestingAssembly != NULL)
@@ -1910,7 +1860,6 @@ DomainAssembly * LoadDomainAssembly(
         PEFile *pRequestingAssemblyManifestFile = pRequestingAssembly->GetManifestFile();
         spec.SetFallbackLoadContextBinderForRequestingAssembly(pRequestingAssemblyManifestFile->GetFallbackLoadContextBinder());
     }
-#endif // defined(FEATURE_HOST_ASSEMBLY_RESOLVER)
 
     if (bThrowIfNotFound)
     {
diff --git a/src/vm/typeparse.h b/src/vm/typeparse.h
index 00a3349ce2..bf5b010a62 100644
--- a/src/vm/typeparse.h
+++ b/src/vm/typeparse.h
@@ -44,9 +44,6 @@ bool inline IsTypeNameReservedChar(WCHAR ch)
     }
 }
 
-#ifdef FEATURE_FUSION
-DomainAssembly* LoadAssemblyFromPartialNameHack(SString* psszAssemblySpec, BOOL fCropPublicKey = FALSE);
-#endif // FEATURE_FUSION
 
 DomainAssembly * LoadDomainAssembly(
     SString *  psszAssemblySpec, 
diff --git a/src/vm/util.cpp b/src/vm/util.cpp
index 2cf6f7f31c..cc52b917e3 100644
--- a/src/vm/util.cpp
+++ b/src/vm/util.cpp
@@ -2536,13 +2536,6 @@ HMODULE CLRGetCurrentModuleHandle()
     return hMod;
 }
 
-#ifndef FEATURE_CORECLR
-static ICLRRuntimeInfo *GetCLRRuntime()
-{
-    LIMITED_METHOD_CONTRACT;
-    return g_pCLRRuntime;
-}
-#endif // !FEATURE_CORECLR
 
 #endif // !FEATURE_PAL
 
@@ -2567,12 +2560,6 @@ void * __stdcall GetCLRFunction(LPCSTR FunctionName)
     {
         func = (void*)EEHeapFreeInProcessHeap;
     }
-#ifndef FEATURE_CORECLR
-    else if (strcmp(FunctionName, "GetCLRRuntime") == 0)
-    {
-        func = (void*)GetCLRRuntime;
-    }
-#endif // !FEATURE_CORECLR
     else if (strcmp(FunctionName, "ShutdownRuntimeWithoutExiting") == 0)
     {
         func = (void*)ShutdownRuntimeWithoutExiting;
diff --git a/src/vm/util.hpp b/src/vm/util.hpp
index d81eedb0df..4a213b7e75 100644
--- a/src/vm/util.hpp
+++ b/src/vm/util.hpp
@@ -1294,35 +1294,7 @@ public:
 
 extern LONG g_OLEAUT32_Loaded;
 
-#ifndef FEATURE_CORECLR
-#define ENSURE_OLEAUT32_LOADED()                                            \
-{                                                                           \
-    /* Should only be used in FCALL */                                      \
-    _ASSERTE (__me != 0);                                                   \
-    if (g_OLEAUT32_Loaded == 0)                                             \
-    {                                                                       \
-        /* CLRLoadLibrary/CLRFreeLibrary claim they trigger, but this */    \
-        /* isn't really true in this case because we're loading oleaut32 */ \
-        /* which we know doesn't contain any managed code in its DLLMain */ \
-        CONTRACT_VIOLATION(GCViolation|SOToleranceViolation);               \
-        HMODULE hMod = CLRLoadLibrary(W("oleaut32"));                         \
-        if (hMod == NULL)                                                   \
-        {                                                                   \
-            __FCThrow(__me, kOutOfMemoryException, 0, 0, 0, 0);             \
-        }                                                                   \
-        else                                                                \
-        {                                                                   \
-            if (FastInterlockExchange(&g_OLEAUT32_Loaded, 1) == 1)          \
-            {                                                               \
-                CLRFreeLibrary(hMod);                                       \
-            }                                                               \
-        }                                                                   \
-    }                                                                       \
-}                                                                           \
-INDEBUG(DisableDelayLoadCheckForOleaut32 _disableOleaut32Check);
-#else // !FEATURE_CORECLR
 #define ENSURE_OLEAUT32_LOADED()
-#endif // !FEATURE_CORECLR
 
 BOOL DbgIsExecutable(LPVOID lpMem, SIZE_T length);
 
diff --git a/src/vm/validator.cpp b/src/vm/validator.cpp
deleted file mode 100644
index 54f6ecdb2b..0000000000
--- a/src/vm/validator.cpp
+++ /dev/null
@@ -1,946 +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: Provide IValidate implementation.
- *          IValidate is used to validate PE stub, Metadata and IL.
- *
- */
-
-#include "common.h"
-
-#include "corerror.h"
-#include "vererror.h"
-#include "ivalidator.h"
-#include "securityattributes.h"
-#include "corhost.h"
-#include "verifier.hpp"
-#include "pedecoder.h"
-#include "comcallablewrapper.h"
-#include "../dlls/mscorrc/resource.h"
-#include "posterror.h"
-#include "comcallablewrapper.h"
-#include "eeconfig.h"
-#include "corhost.h"
-#include "security.h"
-#include "appdomain.inl"
-
-typedef void (*VerifyErrorHandler)(void* pThis, HRESULT hrError, struct VerErrorStruct* pError);
-
-// Declare global variables
-#define DECLARE_DATA
-#include "veropcodes.hpp"
-#undef DECLARE_DATA
-
-class CValidator
-{
-public:
-    CValidator(IVEHandler *veh) : m_veh(veh) 
-    {
-        LIMITED_METHOD_CONTRACT;
-    }
-    HRESULT VerifyAllMethodsForClass(Module *pModule, mdTypeDef cl, ValidateWorkerArgs* pArgs);
-    HRESULT VerifyAllGlobalFunctions(Module *pModule, ValidateWorkerArgs* pArgs);
-    HRESULT VerifyAssembly(Assembly *pAssembly, ValidateWorkerArgs* pArgs);
-    HRESULT VerifyModule(Module* pModule, ValidateWorkerArgs* pArgs);
-    HRESULT ReportError(HRESULT hr, ValidateWorkerArgs* pArgs, mdToken tok=0);
-    HRESULT VerifyMethod(COR_ILMETHOD_DECODER* pILHeader, IVEHandler* pVEHandler, WORD wFlags, ValidateWorkerArgs* pArgs);
-    HRESULT VerifyExportedType(
-        Module *             pModule, 
-        mdToken              tkExportedType, 
-        ValidateWorkerArgs * pArgs);
-    void HandleError(HRESULT hrError, struct VerErrorStruct* pError);
-
-private:
-    IVEHandler *m_veh;
-    ValidateWorkerArgs* m_pArgs;
-};  // class CValidator
-
-HRESULT CValidator::ReportError(HRESULT hr, ValidateWorkerArgs* pArgs, mdToken tok /* = 0 */)
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-    } CONTRACTL_END;
-
-    if (m_veh == NULL)
-        return hr;
-
-    HRESULT hr2 = E_FAIL;
-    BEGIN_SO_INTOLERANT_CODE_NOTHROW(GetThread(), return COR_E_STACKOVERFLOW);
-    VEContext vec;
-
-    memset(&vec, 0, sizeof(VEContext));
-
-    if (tok != 0)
-    {
-        vec.flags = VER_ERR_TOKEN;
-        vec.Token = tok;
-    }
-
-    hr2 =  Verifier::ReportError(m_veh, hr, &vec, pArgs);
-    END_SO_INTOLERANT_CODE;
-    return hr2;
-} // CValidator::ReportError
-
-// Separate method since EX_TRY uses _alloca and is in a loop below.
-COR_ILMETHOD* GetILHeader(MethodDesc *pMD)
-{
-    STANDARD_VM_CONTRACT;
-
-    COR_ILMETHOD *pILHeader = NULL;
-
-    EX_TRY
-    {
-        pILHeader = pMD->GetILHeader();
-    }
-    EX_CATCH
-    {
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-
-    return pILHeader;
-}
-
-HRESULT CValidator::VerifyAllMethodsForClass(Module *pModule, mdTypeDef cl, ValidateWorkerArgs* pArgs)
-{
-    STANDARD_VM_CONTRACT;
-
-    HRESULT hr = S_OK;
-    MethodTable *pMT = NULL;
-     
-    // In the case of COR_GLOBAL_PARENT_TOKEN (i.e. global functions), it is guaranteed
-    // that the module has a method table or our caller will have skipped this step.
-    TypeHandle th;
-    {
-        // <REVISIT>
-        // Although there's no assert to disable here, we need to improve OOM reliability here. We are ignoring the HRESULT from the loader here.
-        // That could cause an OOM failure to be disguised as something else. OOM's
-        // need to be handled or propagated up to the caller.
-        // </REVISIT>
-        CONTRACT_VIOLATION(0);
-        
-        EX_TRY {
-            th = ClassLoader::LoadTypeDefOrRefThrowing(pModule, cl,
-                                             ClassLoader::ReturnNullIfNotFound, 
-                                             ClassLoader::PermitUninstDefOrRef);
-        }
-        EX_CATCH_HRESULT(hr);
-
-        if (FAILED(hr)) {
-            if ((hr==COR_E_TYPELOAD) || (hr==VER_E_TYPELOAD)) {
-                hr = ReportError(hr, pArgs,cl);
-            } else {
-                hr = ReportError(hr, pArgs);
-            }
-            goto Exit;
-        }
-    }
-
-    pMT = th.GetMethodTable();
-    if (pMT == NULL)
-    {
-        hr = ReportError(VER_E_TYPELOAD, pArgs, cl);
-        goto Exit;
-    }
-
-    g_fVerifierOff = false;
-
-    {
-        // Verify all methods in class - excluding inherited methods
-        MethodTable::MethodIterator it(pMT);
-        for (; it.IsValid(); it.Next())
-        {
-            pArgs->pMethodDesc = it.GetMethodDesc();
-
-            bool fVerifyTransparentMethod = true;
-            if (pArgs->fTransparentMethodsOnly)
-            {
-                MethodSecurityDescriptor msd(pArgs->pMethodDesc);
-                fVerifyTransparentMethod = !msd.IsCritical();
-            }
-
-            if (pArgs->pMethodDesc && 
-                pArgs->pMethodDesc->GetMethodTable() == pMT &&
-                pArgs->pMethodDesc->IsIL() && 
-                !pArgs->pMethodDesc->IsAbstract() && 
-                !pArgs->pMethodDesc->IsUnboxingStub() &&
-                fVerifyTransparentMethod)
-            {
-                COR_ILMETHOD* pILHeader = GetILHeader(pArgs->pMethodDesc);
-
-                if (pILHeader != NULL)
-                {
-                    COR_ILMETHOD_DECODER::DecoderStatus status;
-                    COR_ILMETHOD_DECODER ILHeader(pILHeader, 
-                                                  pArgs->pMethodDesc->GetMDImport(), &status); 
-
-                    if (status == COR_ILMETHOD_DECODER::SUCCESS)
-                    {
-                        hr = VerifyMethod(&ILHeader, m_veh, VER_FORCE_VERIFY, pArgs);
-                        if (hr == VER_E_INTERNAL) // this probably means peverify.dll was missing
-                        {
-                            goto Exit;
-                        }
-                    }
-                    else if (status == COR_ILMETHOD_DECODER::VERIFICATION_ERROR)
-                    {
-                        hr = COR_E_VERIFICATION;
-                    }
-                    else if (status == COR_ILMETHOD_DECODER::FORMAT_ERROR)
-                    {
-                        hr = COR_E_BADIMAGEFORMAT;
-                    }
-                    else
-                    {
-                        _ASSERTE(!"Unhandled status from COR_ILMETHOD_DECODER");
-                    }
-                }
-                else
-                {
-                    hr = COR_E_BADIMAGEFORMAT;
-                }
-
-                if (FAILED(hr))
-                    hr = ReportError(hr, pArgs);
-
-                if (FAILED(hr))
-                    goto Exit;
-            }
-            // We should ideally have an API to yield to the host,
-            // but this is not critical for Whidbey.
-            if (CLRTaskHosted())
-                ClrSleepEx(0, FALSE);
-        }
-    }
-
-Exit:
-    pArgs->pMethodDesc = NULL;
-    return hr;
-} // CValidator::VerifyAllMethodsForClass
-
-//---------------------------------------------------------------------------------------
-// 
-void 
-MethodDescAndCorILMethodDecoderToCorInfoMethodInfo(
-    MethodDesc *           ftn, 
-    COR_ILMETHOD_DECODER * ILHeader, 
-    CORINFO_METHOD_INFO *  pMethodInfo)
-{
-    STANDARD_VM_CONTRACT;
-
-    pMethodInfo->ftn = CORINFO_METHOD_HANDLE(ftn);
-    pMethodInfo->scope = CORINFO_MODULE_HANDLE(ftn->GetModule());
-    pMethodInfo->ILCode = const_cast<BYTE*>(ILHeader->Code);
-    pMethodInfo->ILCodeSize = ILHeader->GetCodeSize();
-    pMethodInfo->maxStack = ILHeader->GetMaxStack();
-    pMethodInfo->EHcount = ILHeader->EHCount();
-    pMethodInfo->options =
-        (CorInfoOptions)
-        (((ILHeader->GetFlags() & CorILMethod_InitLocals) ? CORINFO_OPT_INIT_LOCALS : 0) |
-         (ftn->AcquiresInstMethodTableFromThis() ? CORINFO_GENERICS_CTXT_FROM_THIS : 0) |
-         (ftn->RequiresInstMethodTableArg() ? CORINFO_GENERICS_CTXT_FROM_METHODTABLE : 0) |
-         (ftn->RequiresInstMethodDescArg() ? CORINFO_GENERICS_CTXT_FROM_METHODDESC : 0));
-
-    PCCOR_SIGNATURE pSigToConvert;
-    DWORD           cbSigToConvert;
-    ftn->GetSig(&pSigToConvert, &cbSigToConvert);
-    CONSISTENCY_CHECK(NULL != pSigToConvert);
-    // fetch the method signature
-    CEEInfo::ConvToJitSig(
-        pSigToConvert, 
-        cbSigToConvert, 
-        pMethodInfo->scope, 
-        mdTokenNil, 
-        &pMethodInfo->args, 
-        ftn, 
-        false);
-
-    //@GENERICS:
-    // Shared generic methods and shared methods on generic structs take an extra argument representing their instantiation
-    if (ftn->RequiresInstArg())
-        pMethodInfo->args.callConv = (CorInfoCallConv) (pMethodInfo->args.callConv | CORINFO_CALLCONV_PARAMTYPE);
-
-    // method attributes and signature are consistant
-    _ASSERTE(!!ftn->IsStatic() == ((pMethodInfo->args.callConv & CORINFO_CALLCONV_HASTHIS) == 0));
-
-    // And its local variables
-    CEEInfo::ConvToJitSig(
-        ILHeader->LocalVarSig, 
-        ILHeader->cbLocalVarSig, 
-        pMethodInfo->scope, 
-        mdTokenNil, 
-        &pMethodInfo->locals, 
-        ftn, 
-        true);
-} // MethodDescAndCorILMethodDecoderToCorInfoMethodInfo
-
-//---------------------------------------------------------------------------------------
-// 
-void PEVerifyErrorHandler(void* pThis, HRESULT hrError, struct VerErrorStruct* pError)
-{
-    WRAPPER_NO_CONTRACT;
-    STATIC_CONTRACT_SO_TOLERANT;
-    ((CValidator*)pThis)->HandleError(hrError, pError);
-}
-
-void CValidator::HandleError(HRESULT hrError, struct VerErrorStruct* pError)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        SO_TOLERANT;
-    }
-    CONTRACTL_END;
-
-    BEGIN_SO_INTOLERANT_CODE(GetThread());
-    _ASSERTE(sizeof(VEContext) == sizeof(struct VerErrorStruct));
-    Verifier::ReportError(m_veh, hrError, (VEContext*)pError, m_pArgs);
-    END_SO_INTOLERANT_CODE;
-}
-typedef void (__stdcall* VerifyFunc)(ICorJitInfo* pJitInfo, CORINFO_METHOD_INFO* pMethodInfo, VerifyErrorHandler pErrorHandler, void* pThis);
-static void VerifyMethodHelper(VerifyFunc pVerFunc, CEEJitInfo* pJI, CORINFO_METHOD_INFO* pMethodInfo, void* pThis)
-{
-    // Helper method to allow us to use SO_TOLERANT_CODE macro
-    STATIC_CONTRACT_SO_INTOLERANT;
-    WRAPPER_NO_CONTRACT;
-
-    BEGIN_SO_TOLERANT_CODE(GetThread());
-    // Verify the method
-    pVerFunc(pJI, pMethodInfo, PEVerifyErrorHandler, pThis);
-    END_SO_TOLERANT_CODE;
-    
-}
-
-static Volatile<VerifyFunc> g_pVerFunc = NULL;
-
-HRESULT CValidator::VerifyMethod(COR_ILMETHOD_DECODER* pILHeader, IVEHandler* pVEHandler, WORD wFlags, ValidateWorkerArgs* pArgs)
-{
-    STANDARD_VM_CONTRACT;
-
-    HRESULT hr = S_OK;
-    EX_TRY
-    {
-        // Find the DLL entrypoint
-        m_pArgs = pArgs;
-        if (g_pVerFunc.Load() == NULL)
-        {
-            HINSTANCE hJit64 = NULL;
-            if (SUCCEEDED(g_pCLRRuntime->LoadLibrary(W("peverify.dll"), &hJit64)))
-            {
-                typedef void (__stdcall* psxsPeVerifyStartup) (CoreClrCallbacks);
-                psxsPeVerifyStartup sxsPeVerifyStartup = (psxsPeVerifyStartup) GetProcAddress(hJit64, "sxsPeVerifyStartup");
-
-                if(sxsPeVerifyStartup)
-                {
-                    CoreClrCallbacks cccallbacks = GetClrCallbacks();
-                    (*sxsPeVerifyStartup) (cccallbacks);
-                    g_pVerFunc = (VerifyFunc)GetProcAddress(hJit64, "VerifyMethod");
-                }
-            }
-        }
-
-        if(!g_pVerFunc)
-        {
-            _ASSERTE(!"Failed to load peverify.dll or find VerifyMethod proc address");
-            hr = VER_E_INTERNAL;
-        }
-        else
-        {
-            Thread *pThread = GetThread();
-            if (pThread->IsAbortRequested())
-            {
-                pThread->HandleThreadAbort();
-            }
-            // Prepare the args
-            MethodDesc* ftn = pArgs->pMethodDesc;
-            CEEJitInfo ji(pArgs->pMethodDesc, pILHeader, NULL, true /* verify only */);
-            CORINFO_METHOD_INFO methodInfo;
-            MethodDescAndCorILMethodDecoderToCorInfoMethodInfo(ftn, pILHeader, &methodInfo);
-
-            // Verify the method
-            VerifyMethodHelper(g_pVerFunc, &ji, &methodInfo, this);
-        }
-    }
-    EX_CATCH
-    {
-        // Catch and report any errors that peverify.dll lets fall through (ideally that should never happen)
-        hr = GET_EXCEPTION()->GetHR();
-        hr = ReportError(hr, pArgs);
-    }
-    EX_END_CATCH(RethrowTerminalExceptions)
-
-    return hr;
-} // CValidator::VerifyMethod
-
-// Helper function to verify the global functions
-HRESULT CValidator::VerifyAllGlobalFunctions(Module *pModule, ValidateWorkerArgs* pArgs)
-{
-    STANDARD_VM_CONTRACT;
-
-    HRESULT hr = S_OK;
-    // Is there anything worth verifying?
-    if (pModule->GetGlobalMethodTable())
-        hr =  VerifyAllMethodsForClass(pModule, COR_GLOBAL_PARENT_TOKEN, pArgs);
-    return hr;
-} // CValidator::VerifyAllGlobalFunctions
-
-HRESULT CValidator::VerifyModule(Module* pModule, ValidateWorkerArgs* pArgs)
-{
-    STANDARD_VM_CONTRACT;
-    
-    // Get a count of all the classdefs and enumerate them.
-    HRESULT             hr = S_OK;
-    IMDInternalImport * pMDI = NULL;
-    
-    if (pModule == NULL)
-    {
-        IfFailGo(VER_E_BAD_MD);
-    }
-    
-    pMDI = pModule->GetMDImport();
-    if (pMDI == NULL)
-    {
-        IfFailGo(VER_E_BAD_MD);
-    }
-        
-    // First verify all global functions - if there are any
-    IfFailGoto(
-        VerifyAllGlobalFunctions(pModule, pArgs), 
-        ErrExit_SkipReportError);
-
-    {
-        HENUMTypeDefInternalHolder hTypeDefEnum(pMDI);
-
-        IfFailGo(hTypeDefEnum.EnumTypeDefInitNoThrow());  
-
-        // Verify all TypeDefs
-        mdTypeDef tkTypeDef;
-        while (pMDI->EnumTypeDefNext(&hTypeDefEnum, &tkTypeDef))
-        {
-            IfFailGoto(
-                VerifyAllMethodsForClass(pModule, tkTypeDef, pArgs), 
-                ErrExit_SkipReportError);
-        }
-    }
-
-    {
-        HENUMInternalHolder hExportedTypeEnum(pMDI);
-
-        IfFailGo(hExportedTypeEnum.EnumInitNoThrow(
-            mdtExportedType, 
-            mdTokenNil));
-
-        // Verify all ExportedTypes
-        mdToken tkExportedType;
-        while (pMDI->EnumNext(&hExportedTypeEnum, &tkExportedType))
-        {
-            IfFailGoto(
-                VerifyExportedType(pModule, tkExportedType, pArgs), 
-                ErrExit_SkipReportError);
-        }
-    }
-    
-ErrExit:
-    if (FAILED(hr))
-    {
-        hr = ReportError(hr, pArgs);
-    }
-
-ErrExit_SkipReportError:    
-    return hr;
-} // CValidator::VerifyModule
-
-HRESULT CValidator::VerifyAssembly(Assembly *pAssembly, ValidateWorkerArgs* pArgs)
-{
-    STANDARD_VM_CONTRACT;
-
-    HRESULT hr;
-
-    _ASSERTE(pAssembly->GetManifestImport());
-
-    // Verify the module containing the manifest. There is no
-    // FileRefence so will no show up in the list.
-    hr = VerifyModule(pAssembly->GetManifestModule(), pArgs);
-    if (FAILED(hr))
-        goto Exit;
-
-    {
-        IMDInternalImport* pManifestImport = pAssembly->GetManifestImport();
-
-        HENUMInternalHolder hEnum(pManifestImport);
-
-        mdToken mdFile;
-        hr = hEnum.EnumInitNoThrow(mdtFile, mdTokenNil);
-        if (FAILED(hr)) 
-        {
-            hr = ReportError(hr, pArgs);
-            goto Exit;
-        }
-
-        while(pManifestImport->EnumNext(&hEnum, &mdFile)) 
-        {
-            DomainFile* pModule = pAssembly->GetManifestModule()->LoadModule(GetAppDomain(), mdFile, FALSE);
-
-            if (pModule != NULL)
-            {
-                hr = VerifyModule(pModule->GetModule(), pArgs);
-                if (FAILED(hr)) 
-                    goto Exit;
-            }
-        }
-    }
-
-Exit:
-    return hr;
-} // CValidator::VerifyAssembly
-
-HRESULT 
-CValidator::VerifyExportedType(
-    Module *             pModule, 
-    mdToken              tkExportedType, 
-    ValidateWorkerArgs * pArgs)
-{
-    STANDARD_VM_CONTRACT;
-    
-    HRESULT    hr;
-    TypeHandle th;
-    NameHandle nameHandle(pModule, tkExportedType);
-    
-    LPCSTR szNamespace;
-    LPCSTR szName;
-    IfFailGo(pModule->GetMDImport()->GetExportedTypeProps(
-        tkExportedType, 
-        &szNamespace, 
-        &szName, 
-        NULL,   // tkImplementation
-        NULL,   // tkTypeDefId
-        NULL)); // dwExportedTypeFlags
-    
-    nameHandle.SetName(szNamespace, szName);
-    
-    EX_TRY
-    {
-        th = pModule->GetClassLoader()->LoadTypeHandleThrowing(
-            &nameHandle, 
-            CLASS_LOADED, 
-            pModule);
-        hr = S_OK;
-    }
-    EX_CATCH
-    {
-        hr = GET_EXCEPTION()->GetHR();
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-    
-    IfFailGo(hr);
-    if (th.GetMethodTable() == NULL)
-    {
-        IfFailGo(VER_E_TYPELOAD);
-    }
-    
-ErrExit:
-    if (FAILED(hr))
-    {
-        hr = ReportError(hr, pArgs, tkExportedType);
-    }
-    
-    return hr;
-} // CValidator::VerifyExportedType
-
-static void ValidateWorker(LPVOID /* ValidateWorker_Args */ ptr)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_COOPERATIVE;
-    } CONTRACTL_END;
-
-    ValidateWorkerArgs *args = (ValidateWorkerArgs *) ptr;
-    AppDomain *pDomain = GetThread()->GetDomain();
-    
-    StackSString ssFile(args->wszFileName);
-    StackSString ssFileDir;
-    StackSString ssDirectory;
-    
-    // Fill ssDirectory with just drive of the file (e.g. 'C:')
-    SplitPath(ssFile, &ssDirectory, &ssFileDir, NULL, NULL);
-    // Now apped directory from the file name (incl. leading and trailing '/' or '\')
-    ssDirectory.Append(ssFileDir);
-    
-    {
-        // Set up the domain to resolve all dependency assemblies for introspection
-        struct _gc {
-            OBJECTREF orAppDomain;
-            STRINGREF refDirectory;
-        } gc;
-        ZeroMemory(&gc, sizeof(gc));
-
-        GCPROTECT_BEGIN(gc);
-
-        gc.orAppDomain = pDomain->GetExposedObject();
-        if (!ssDirectory.IsEmpty())
-        {
-            gc.refDirectory = StringObject::NewString(ssDirectory);
-        }
-        
-        MethodDescCallSite meth(METHOD__APP_DOMAIN__ENABLE_RESOLVE_ASSEMBLIES_FOR_INTROSPECTION, &gc.orAppDomain);
-        ARG_SLOT args[2] = 
-        {
-            ObjToArgSlot(gc.orAppDomain), 
-            ObjToArgSlot(gc.refDirectory)
-        };
-        meth.Call(args);
-        
-        GCPROTECT_END();
-    }
-
-    GCX_PREEMP();
-
-    Assembly *pAssembly;
-    if (args->wszFileName)
-    {
-        // Load the primary assembly for introspection
-        AssemblySpec spec;
-        spec.SetCodeBase(args->wszFileName);
-        spec.SetIntrospectionOnly(TRUE);
-        pAssembly = spec.LoadAssembly(FILE_LOADED);
-    }
-    else
-    {
-        // TODO: This is a workaround to get SQLCLR running.
-        //       Our loader requires that a parent assembly is specified in order to load an
-        //       assembly from byte array.  But here we do not know the parent.
-        PEAssemblyHolder pFile(PEAssembly::OpenMemory(SystemDomain::System()->SystemFile(),
-                                                      args->pe, args->size, TRUE));
-        pAssembly = pDomain->LoadAssembly(NULL, pFile, FILE_LOADED);
-    }
-
-    // Verify the assembly
-    args->hr = args->val->VerifyAssembly(pAssembly, args);
-}
-
-
-static HRESULT ValidateHelper(
-        IVEHandler        *veh,
-        IUnknown          *pAppDomain,
-        DWORD              ulAppDomainId,
-        BOOL               UseId,
-        unsigned long      ulFlags,
-        unsigned long      ulMaxError,
-        unsigned long      token,
-        __in_z LPWSTR             fileName,
-        BYTE               *pe,
-        unsigned long      ulSize)
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-        SO_TOLERANT;
-    } CONTRACTL_END;
-
-    Thread  *pThread = GetThread();
-
-    if (pe == NULL)
-        return E_POINTER;
-
-    HRESULT hr = S_OK;
-    BEGIN_SO_INTOLERANT_CODE_NOTHROW(pThread, return COR_E_STACKOVERFLOW);
-    ADID pDomain;
-    ValidateWorkerArgs args;
-    CValidator val(veh);
-    AppDomainFromIDHolder ad;
-
-    BOOL Chk = FALSE;
-    BOOL UnloadDomain = FALSE;
-
-    GCX_COOP();
-
-    EX_TRY {
-        PEDecoder pev(pe, (COUNT_T)ulSize);
-
-        args.wszFileName = fileName;
-        args.fVerbose = (ulFlags & VALIDATOR_EXTRA_VERBOSE) ? true : false;
-        args.fShowSourceLines = (ulFlags & VALIDATOR_SHOW_SOURCE_LINES) ? true : false;
-        args.fTransparentMethodsOnly = (ulFlags & VALIDATOR_TRANSPARENT_ONLY) ? true : false;
-        args.val = &val;
-        args.pe = pe;
-        args.size = ulSize;
-
-        if((ulFlags & VALIDATOR_NOCHECK_PEFORMAT) == 0)
-        {
-            // Verify the PE header / native stubs first
-            // <REVISIT> This validation is not performed on non-manifest modules. </REVISIT>
-            Chk = ((ulFlags & VALIDATOR_CHECK_ILONLY) != 0) ? (BOOL) pev.CheckILOnlyFormat() :
-                                                              (BOOL) pev.CheckILFormat();
-            if (!Chk)
-            {
-                hr = val.ReportError(VER_E_BAD_PE, &args);
-
-                if (FAILED(hr))
-                    goto End;
-            }
-        }
-        if((ulFlags & VALIDATOR_CHECK_PEFORMAT_ONLY) != 0)
-            goto End;
-
-        if (fileName)
-        {
-            AppDomain* pAD = AppDomain::CreateDomainContext(fileName);
-            UnloadDomain = TRUE;
-            pAD->SetPassiveDomain();
-            pDomain=pAD->GetId();
-        }
-        else if (UseId)
-        {
-            pDomain = (ADID)ulAppDomainId;
-        }
-        else
-        {
-            SystemDomain::LockHolder lh;
-            ComCallWrapper* pWrap = GetCCWFromIUnknown(pAppDomain, FALSE);
-            if (pWrap == NULL)
-            {
-                hr = COR_E_APPDOMAINUNLOADED;
-                goto End;
-            }
-            pDomain = pWrap->GetDomainID();
-        }
-
-        if (FAILED(hr)) 
-        {
-            hr = val.ReportError(hr, &args);
-            goto End;
-        }
-
-        ad.Assign(pDomain, TRUE);
-        if (ad.IsUnloaded())
-            COMPlusThrow(kAppDomainUnloadedException);
-        if (ad->IsIllegalVerificationDomain())
-            COMPlusThrow(kFileLoadException, IDS_LOADINTROSPECTION_DISALLOWED);
-        ad->SetVerificationDomain();
-        ad.Release();
-
-        args.val = &val;
-
-        // We need a file path here.  This is to do a fusion bind, and also
-        // to make sure we can find any modules in the assembly.  We assume
-        // that the path points to the same place the bytes came from, which is true
-        // with PEVerify, but perhaps not with other clients.
-
-        if (pDomain != pThread->GetDomain()->GetId())
-        {
-            pThread->DoADCallBack(
-                pDomain, ValidateWorker, &args);
-        }
-        else
-        {
-            ValidateWorker(&args);
-        }
-
-        if (FAILED(args.hr))
-            hr = val.ReportError(args.hr, &args);
-
-        // Only Unload the domain if we created it.
-        if (UnloadDomain)
-            AppDomain::UnloadById(pDomain,TRUE);
-End:;
-
-    }
-    EX_CATCH
-    {
-        hr = GET_EXCEPTION()->GetHR();
-        hr = val.ReportError(hr, &args);
-    }
-    EX_END_CATCH(RethrowSOExceptions)
-
-    END_SO_INTOLERANT_CODE;
-    return hr;
-}
-
-void GetFormattingErrorMsg(__out_ecount(ulMaxLength) __out_z LPWSTR msg, unsigned int ulMaxLength)
-{
-    CONTRACTL {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(ulMaxLength >= 30);
-    } CONTRACTL_END;
-
-    EX_TRY
-    {
-        SString s;
-        s.LoadResource(CCompRC::Debugging, IDS_VER_E_FORMATTING);
-        wcsncpy_s(msg, ulMaxLength, s.GetUnicode(), _TRUNCATE);
-    }
-    EX_CATCH
-    {
-        wcscpy_s(msg, ulMaxLength, W("Error loading resource string"));
-    }
-    EX_END_CATCH(SwallowAllExceptions)
-}
-
-static HRESULT FormatEventInfoHelper(
-        HRESULT            hVECode,
-        VEContext          Context,
-         __out_ecount(ulMaxLength) __out_z LPWSTR msg,
-        unsigned int      ulMaxLength,
-        SAFEARRAY          *psa)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(ulMaxLength >= 30);
-        SO_TOLERANT;
-    } CONTRACTL_END;
-
-    BEGIN_SO_INTOLERANT_CODE(GetThread());
-
-    VerError err;
-    memcpy(&err, &Context, sizeof(VerError));
-
-    ValidateWorkerArgs argsDefault;
-    ValidateWorkerArgs* pArgs = &argsDefault;
-
-    // We passed a pointer to the ValidateWorkerArgs object through
-    // the SAFEARRAY casted as a UINT because there was no room left in the
-    // interface to pass information through it.
-    {
-        UINT dim;
-        LONG l;
-#ifdef _WIN64
-        VARTYPE vt;
-#endif // _WIN64
-        VARIANT var;
-
-        if(!psa) {
-            goto lDone;
-        }
-
-        dim = SafeArrayGetDim(psa);            
-        if (dim != 1) {
-            _ASSERTE(!"There should be one element in the SafeArray");
-            goto lDone;
-        }
-
-        if (FAILED(SafeArrayGetLBound(psa, 1, &l))) {
-            _ASSERTE(false);
-            goto lDone;
-        }
-        if (l != 0) {
-            _ASSERTE(!"expected the lower bound to be zero");
-            goto lDone;
-        }
-
-        if (FAILED(SafeArrayGetUBound(psa, 1, &l))) {
-            _ASSERTE(false);
-            goto lDone;
-        }
-        if (l != 0) {
-            _ASSERTE(!"expected the upper bound to be zero");
-            goto lDone;
-        }
-#ifdef _WIN64
-        // This check fails on Win2K when it should pass
-        SafeArrayGetVartype(psa, &vt);
-        if(vt != VT_VARIANT) {
-            _ASSERTE(!"expected the ElementType to be a VT_VARIANT");
-            goto lDone;
-        }
-#endif // _WIN64
-        l = 0;
-        SafeArrayGetElement(psa, &l, &var);
-
-#ifdef _WIN64
-        if (V_VT(&var) != VT_UI8) { // We expect the VarType to be a VT_UI8 (VT_UI8 is not supported on Windows 2000)
-            _ASSERTE(false);
-            goto lDone;
-        }
-
-        pArgs = (ValidateWorkerArgs*)(size_t)V_UI8(&var);
-#else
-        // We don't check that the type is V_UINT here because that check fails on Win2K when it should pass
-        pArgs = (ValidateWorkerArgs*)(size_t)V_UINT(&var);
-#endif
-
-    }
-lDone: ;
-
-    EX_TRY
-    {
-        Verifier::GetErrorMsg(hVECode, err, msg, ulMaxLength, pArgs);
-    }
-    EX_CATCH
-    {
-        GetFormattingErrorMsg(msg, ulMaxLength);
-    }
-    EX_END_CATCH(SwallowAllExceptions)
-
-    END_SO_INTOLERANT_CODE;
-    return S_OK;
-}
-
-HRESULT CorValidator::Validate(
-        IVEHandler        *veh,
-        IUnknown          *pAppDomain,
-        unsigned long      ulFlags,
-        unsigned long      ulMaxError,
-        unsigned long      token,
-        __in_z LPWSTR             fileName,
-        BYTE               *pe,
-        unsigned long      ulSize)
-{
-    WRAPPER_NO_CONTRACT;
-    STATIC_CONTRACT_SO_TOLERANT;
-    return ValidateHelper(veh, pAppDomain, 0, FALSE, ulFlags, ulMaxError,
-                          token, fileName, pe, ulSize);
-}
-
-HRESULT CLRValidator::Validate(
-        IVEHandler        *veh,
-        unsigned long      ulAppDomainId,
-        unsigned long      ulFlags,
-        unsigned long      ulMaxError,
-        unsigned long      token,
-        __in_z LPWSTR             fileName,
-        BYTE               *pe,
-        unsigned long      ulSize)
-{
-    WRAPPER_NO_CONTRACT;
-    STATIC_CONTRACT_SO_TOLERANT;
-    return ValidateHelper(veh, NULL, ulAppDomainId, TRUE, ulFlags, ulMaxError,
-                          token, fileName, pe, ulSize);
-}
-
-HRESULT CorValidator::FormatEventInfo(
-        HRESULT            hVECode,
-        VEContext          Context,
-        __out_ecount(ulMaxLength) LPWSTR             msg,
-        unsigned long      ulMaxLength,
-        SAFEARRAY          *psa)
-{
-    WRAPPER_NO_CONTRACT;
-    return FormatEventInfoHelper(hVECode, Context, msg, ulMaxLength, psa);
-}
-
-HRESULT CLRValidator::FormatEventInfo(
-        HRESULT            hVECode,
-        VEContext          Context,
-        __out_ecount(ulMaxLength) LPWSTR             msg,
-        unsigned long      ulMaxLength,
-        SAFEARRAY          *psa)
-{
-    WRAPPER_NO_CONTRACT;
-    STATIC_CONTRACT_SO_TOLERANT;
-    return FormatEventInfoHelper(hVECode, Context, msg, ulMaxLength, psa);
-}
-
-
diff --git a/src/vm/vars.cpp b/src/vm/vars.cpp
index 2ca77aec5b..165d172e74 100644
--- a/src/vm/vars.cpp
+++ b/src/vm/vars.cpp
@@ -69,9 +69,7 @@ GPTR_IMPL(MethodTable,      g_pStringClass);
 GPTR_IMPL(MethodTable,      g_pArrayClass);
 GPTR_IMPL(MethodTable,      g_pSZArrayHelperClass);
 GPTR_IMPL(MethodTable,      g_pNullableClass);
-#ifdef FEATURE_SPAN_OF_T
 GPTR_IMPL(MethodTable,      g_pByReferenceClass);
-#endif
 GPTR_IMPL(MethodTable,      g_pExceptionClass);
 GPTR_IMPL(MethodTable,      g_pThreadAbortExceptionClass);
 GPTR_IMPL(MethodTable,      g_pOutOfMemoryExceptionClass);
@@ -82,12 +80,6 @@ GPTR_IMPL(MethodTable,      g_pMulticastDelegateClass);
 GPTR_IMPL(MethodTable,      g_pValueTypeClass);
 GPTR_IMPL(MethodTable,      g_pEnumClass);
 GPTR_IMPL(MethodTable,      g_pThreadClass);
-#ifdef FEATURE_CER
-GPTR_IMPL(MethodTable,      g_pCriticalFinalizerObjectClass);
-#endif
-#ifndef FEATURE_CORECLR
-GPTR_IMPL(MethodTable,      g_pAsyncFileStream_AsyncResultClass);
-#endif // !FEATURE_CORECLR
 GPTR_IMPL(MethodTable,      g_pFreeObjectMethodTable);
 GPTR_IMPL(MethodTable,      g_pOverlappedDataClass);
 
@@ -105,9 +97,6 @@ GPTR_IMPL(MethodTable,      g_pICastableInterface);
 #endif // FEATURE_ICASTABLE
 
 
-#ifdef FEATURE_CER
-GPTR_IMPL(MethodDesc,       g_pPrepareConstrainedRegionsMethod);
-#endif
 GPTR_IMPL(MethodDesc,       g_pExecuteBackoutCodeHelperMethod);
 
 GPTR_IMPL(MethodDesc,       g_pObjectCtorMD);
@@ -138,9 +127,6 @@ GPTR_IMPL(RCWCleanupList,g_pRCWCleanupList);
 // <TODO> @TODO Remove eventually - </TODO> determines whether the verifier throws an exception when something fails
 bool                g_fVerifierOff;
 
-#ifndef FEATURE_CORECLR
-IAssemblyUsageLog   *g_pIAssemblyUsageLogGac;
-#endif
 
 // <TODO> @TODO - PROMOTE. </TODO>
 OBJECTHANDLE         g_pPreallocatedOutOfMemoryException;
@@ -151,10 +137,6 @@ OBJECTHANDLE         g_pPreallocatedThreadAbortException;
 OBJECTHANDLE         g_pPreallocatedSentinelObject;
 OBJECTHANDLE         g_pPreallocatedBaseException;
 
-#ifdef FEATURE_CAS_POLICY
-CertificateCache *g_pCertificateCache = NULL;
-#endif
-
 // 
 //
 // Global System Info
diff --git a/src/vm/vars.hpp b/src/vm/vars.hpp
index 167d8e0d14..34d430e2d8 100644
--- a/src/vm/vars.hpp
+++ b/src/vm/vars.hpp
@@ -66,17 +66,10 @@ typedef unsigned short wchar_t;
 #include <corpriv.h>
 #include <cordbpriv.h>
 
-#ifndef FEATURE_CORECLR
-#include <metahost.h>
-#endif // !FEATURE_CORECLR
 
 #include "eeprofinterfaces.h"
 #include "eehash.h"
 
-#ifdef FEATURE_CAS_POLICY
-#include "certificatecache.h"
-#endif
-
 #include "profilepriv.h"
 
 class ClassLoader;
@@ -184,12 +177,9 @@ class OBJECTREF {
         class TransparentProxyObject* m_asTP;
 
         class ReflectClassBaseObject* m_asReflectClass;
-#ifdef FEATURE_COMPRESSEDSTACK        
-        class CompressedStackObject* m_asCompressedStack;
-#endif // #ifdef FEATURE_COMPRESSEDSTACK
-#if defined(FEATURE_IMPERSONATION) || defined(FEATURE_COMPRESSEDSTACK)
+#if defined(FEATURE_IMPERSONATION)
         class SecurityContextObject* m_asSecurityContext;
-#endif // #if defined(FEATURE_IMPERSONATION) || defined(FEATURE_COMPRESSEDSTACK)
+#endif // #if defined(FEATURE_IMPERSONATION)
         class ExecutionContextObject* m_asExecutionContext;
         class AppDomainBaseObject* m_asAppDomainBase;
         class PermissionSetObject* m_asPermissionSetObject;
@@ -402,9 +392,7 @@ GPTR_DECL(MethodTable,      g_pStringClass);
 GPTR_DECL(MethodTable,      g_pArrayClass);
 GPTR_DECL(MethodTable,      g_pSZArrayHelperClass);
 GPTR_DECL(MethodTable,      g_pNullableClass);
-#ifdef FEATURE_SPAN_OF_T
 GPTR_DECL(MethodTable,      g_pByReferenceClass);
-#endif
 GPTR_DECL(MethodTable,      g_pExceptionClass);
 GPTR_DECL(MethodTable,      g_pThreadAbortExceptionClass);
 GPTR_DECL(MethodTable,      g_pOutOfMemoryExceptionClass);
@@ -417,12 +405,6 @@ GPTR_DECL(MethodTable,      g_pFreeObjectMethodTable);
 GPTR_DECL(MethodTable,      g_pValueTypeClass);
 GPTR_DECL(MethodTable,      g_pEnumClass);
 GPTR_DECL(MethodTable,      g_pThreadClass);
-#ifdef FEATURE_CER
-GPTR_DECL(MethodTable,      g_pCriticalFinalizerObjectClass);
-#endif
-#ifndef FEATURE_CORECLR
-GPTR_DECL(MethodTable,      g_pAsyncFileStream_AsyncResultClass);
-#endif // !FEATURE_CORECLR
 GPTR_DECL(MethodTable,      g_pOverlappedDataClass);
 
 GPTR_DECL(MethodTable,      g_TypedReferenceMT);
@@ -438,9 +420,6 @@ GPTR_DECL(MethodTable,      g_pBaseRuntimeClass);
 GPTR_DECL(MethodTable,      g_pICastableInterface);
 #endif // FEATURE_ICASTABLE
 
-#ifdef FEATURE_CER
-GPTR_DECL(MethodDesc,       g_pPrepareConstrainedRegionsMethod);
-#endif
 GPTR_DECL(MethodDesc,       g_pExecuteBackoutCodeHelperMethod);
 
 GPTR_DECL(MethodDesc,       g_pObjectCtorMD);
@@ -449,9 +428,6 @@ GPTR_DECL(MethodDesc,       g_pObjectFinalizerMD);
 //<TODO> @TODO Remove eventually - determines whether the verifier throws an exception when something fails</TODO>
 EXTERN bool                 g_fVerifierOff;
 
-#ifndef FEATURE_CORECLR
-EXTERN IAssemblyUsageLog   *g_pIAssemblyUsageLogGac;
-#endif
 
 // Global System Information
 extern SYSTEM_INFO g_SystemInfo;
@@ -493,10 +469,6 @@ typedef DPTR(RCWCleanupList) PTR_RCWCleanupList;
 GPTR_DECL(RCWCleanupList,g_pRCWCleanupList);
 #endif // FEATURE_COMINTEROP
 
-#ifdef FEATURE_CAS_POLICY
-EXTERN CertificateCache *g_pCertificateCache;
-#endif 
-
 #ifdef FEATURE_IPCMAN
 // support for IPCManager
 typedef DPTR(IPCWriterInterface) PTR_IPCWriterInterface;
@@ -575,12 +547,6 @@ EXTERN Volatile<BOOL> g_fEEStarted;
 EXTERN BOOL g_fComStarted;
 #endif
 
-#if !defined(FEATURE_CORECLR) && !defined(CROSSGEN_COMPILE)
-//
-// Pointer to the activated CLR interface provided by the shim.
-//
-EXTERN ICLRRuntimeInfo *g_pCLRRuntime;
-#endif
 
 //
 // Global state variables indicating which stage of shutdown we are in
diff --git a/src/zap/common.h b/src/zap/common.h
index b3db657f87..0abb2ce751 100644
--- a/src/zap/common.h
+++ b/src/zap/common.h
@@ -32,9 +32,6 @@
 #include "jithost.h"
 #include "corcompile.h"
 #include "iceefilegen.h"
-#ifdef FEATURE_FUSION
-#include "fusionbind.h"
-#endif
 #include "corpriv.h"
 
 #include "holder.h"
@@ -50,9 +47,6 @@
 #include "guidfromname.h"
 #include "../dlls/mscorrc/resource.h"
 #include "zaplog.h"
-#ifndef FEATURE_CORECLR
-#include "eventmsg.h"
-#endif // FEATURE_CORECLR
 #include "ndpversion.h"
 
 #include "loaderheap.h"
diff --git a/src/zap/svcworker.cpp b/src/zap/svcworker.cpp
index 001345ce1c..eb7d8d92ac 100644
--- a/src/zap/svcworker.cpp
+++ b/src/zap/svcworker.cpp
@@ -25,9 +25,6 @@ NGenWorkerEmbedding() -- called when COM invoked the COM server with
 
 #include "common.h"
 
-#ifdef FEATURE_FUSION
-#include "binderngen.h"
-#endif
 
 #ifdef FEATURE_APPX
 #include "AppXUtil.h"
@@ -201,60 +198,6 @@ ICorSvcLogger* SvcLogger::GetSvcLogger()
     return pCorSvcLogger;
 }
 
-#ifndef FEATURE_CORECLR
-
-void InitNGenOptions(NGenOptions *ngo,
-                     NGenPrivateAttributes ngenPrivateAttributes,                     
-                     OptimizationScenario optScenario = ScenarioDefault,
-                     LPCWSTR lpszRepositoryDir = NULL, RepositoryFlags repositoryFlags = RepositoryDefault)
-{
-    ULONG_PTR pScenario = (ULONG_PTR) optScenario;
-
-    ngo->dwSize = sizeof(NGenOptions);
-        
-    // V1
-    //
-    ngo->fDebug      = (pScenario & ScenarioDebug)                ? true : false;
-    ngo->fDebugOpt   = false;
-    ngo->fProf       = (pScenario & ScenarioProfile)              ? true : false;
-    ngo->fSilent = false;
-    ngo->lpszExecutableFileName = NULL;
-
-    // V2 (Whidbey) 
-    //
-    ngo->fInstrument = (pScenario & ScenarioTuningDataCollection) ? true : false;
-    ngo->fWholeProgram = false;
-    ngo->fProfInfo   = (pScenario & ScenarioProfileInfo)          ? true : false;
-
-    ngo->lpszRepositoryDir = lpszRepositoryDir;
-    ngo->repositoryFlags = repositoryFlags;
-
-    ngo->dtRequested = DT_NIL;
-    ngo->lpszDebugDir = NULL;
-
-    ngo->fNoInstall  = false;
-    ngo->fEmitFixups = false;
-    ngo->fFatHeaders = false;
-    ngo->fVerbose    = false;
-    
-    // This should be a value from the StatOptions enumeration
-    ngo->uStats = ngenPrivateAttributes.ZapStats;
-    ngo->dtRequested = (ngenPrivateAttributes.Flags & DbgTypePdb) ? DT_PDB : DT_NIL;
-    ngo->lpszDebugDir = ngenPrivateAttributes.DbgDir;
-
-
-    // V4 
-    //
-    ngo->fNgenLastRetry = (pScenario & ScenarioNgenLastRetry)     ? true : false;
-
-    // V4.5
-    ngo->fAutoNGen = (pScenario & ScenarioAutoNGen)               ? true : false;
-
-    // Blue
-    ngo->fRepositoryOnly = (pScenario & ScenarioRepositoryOnly)   ? true : false;
-}
-
-#endif // !FEATURE_CORECLR
 
 namespace
 {
@@ -288,769 +231,3 @@ void SetSvcLogger(ICorSvcLogger *pCorSvcLogger)
 }
 #endif
 
-#ifndef FEATURE_CORECLR
-
-//*****************************************************************************
-// ICorSvcDependencies is used to enumerate the dependencies of an
-// IL image.  It is used by the native image service.
-//*****************************************************************************[
-class CCorSvcDependencies : public ICorSvcDependencies
-{
-public:
-    CCorSvcDependencies()
-    {
-        _cRef = 0;
-        zapper = NULL;
-       
-        g_pLocalServerLifetime->AddRefServerProcess();
-    }
-
-    ~CCorSvcDependencies() 
-    {
-        if (zapper != NULL)
-        {
-            delete zapper;
-        }
-
-        g_pLocalServerLifetime->ReleaseServerProcess();
-    }
-
-    void Initialize(BSTR pApplicationName, OptimizationScenario scenario)
-    {
-        NGenOptions opt = {0};
-        NGenPrivateAttributesClass ngenPrivateAttributesClass;
-        InitNGenOptions(&opt, ngenPrivateAttributesClass, scenario);
-        opt.lpszExecutableFileName = pApplicationName;
-        zapper = Zapper::NewZapper(&opt, true);
-        zapper->CreateDependenciesLookupDomain();
-    }
-
-    STDMETHOD (GetAssemblyDependencies)(
-        BSTR pAssemblyName, 
-        SAFEARRAY **pDependencies,
-        DWORD *assemblyNGenSetting,
-        BSTR *pNativeImageIdentity,
-        BSTR *pAssemblyDisplayName,
-        SAFEARRAY **pDependencyLoadSetting,
-        SAFEARRAY **pDependencyNGenSetting
-    )
-    {
-        SO_NOT_MAINLINE_FUNCTION;
-        
-        _ASSERTE(zapper != NULL);
-        _ASSERTE(pNativeImageIdentity);
-
-        HRESULT hr = S_OK;
-        EX_TRY
-        {
-            GUID nativeImageSign = INVALID_NGEN_SIGNATURE;
-            zapper->ComputeDependencies(pAssemblyName, &nativeImageSign);
-            
-            BSTRHolder displayNameHolder(::SysAllocString(zapper->m_assemblyDependencies.GetDisplayName()));
-               
-            *pDependencies          = zapper->m_assemblyDependencies.GetSAFEARRAY();
-            *assemblyNGenSetting    = zapper->m_assemblyDependencies.GetNGenHint();
-            *pDependencyLoadSetting = zapper->m_assemblyDependencies.GetLoadHintSAFEARRAY();
-            *pDependencyNGenSetting = zapper->m_assemblyDependencies.GetNGenHintSAFEARRAY();
-        
-            if (nativeImageSign != INVALID_NGEN_SIGNATURE)
-            {
-                WCHAR szGuid[64];
-                if (GuidToLPWSTR(nativeImageSign, szGuid, sizeof(szGuid) / sizeof(WCHAR)) == 0)
-                {
-                    ThrowHR(E_UNEXPECTED);
-                }
-                *pNativeImageIdentity = ::SysAllocString(szGuid);
-            }
-
-            *pAssemblyDisplayName = displayNameHolder.Extract();
-        }
-        EX_CATCH_HRESULT_AND_NGEN_CLEAN(hr);
-
-        return hr;
-    }
-
-    STDMETHODIMP_(ULONG)    AddRef()
-    {                               
-        return InterlockedIncrement (&_cRef);
-    }
-
-    STDMETHODIMP_(ULONG)    Release()
-    {
-        SO_NOT_MAINLINE_FUNCTION;
-        
-        ULONG lRet = InterlockedDecrement (&_cRef);
-        if (!lRet)
-            delete this;
-        return lRet;
-    }
-
-    STDMETHODIMP QueryInterface(REFIID riid,void ** ppv)
-    {
-        SO_NOT_MAINLINE_FUNCTION;
-
-        if (!ppv)
-            return E_POINTER;
-
-        if (IsEqualIID(riid, IID_IUnknown) ||
-            IsEqualIID(riid, IID_ICorSvcDependencies))
-        {
-            *ppv = static_cast<ICorSvcDependencies*> (this);
-            AddRef();
-            return S_OK;
-        }
-        else
-        {
-            *ppv = NULL;
-            return E_NOINTERFACE;
-        }
-    }
-
-private:
-    LONG _cRef;
-    Zapper *zapper;
-};
-
-//*****************************************************************************
-// CCorSvcCreatePdbWorker is used to load the CLR, initialize an appdomain,
-// load the given assembly and create a PDB for it.
-//*****************************************************************************
-class CCorSvcCreatePdbWorker {
-
-public:
-
-    CCorSvcCreatePdbWorker()
-        : m_pZapper(NULL)
-    {
-    }
-
-    ~CCorSvcCreatePdbWorker()
-    {
-        if (m_pZapper)
-            delete m_pZapper;
-    }
-
-    void Initialize(BSTR pAppBaseOrConfig, OptimizationScenario scenario)
-    {
-        _ASSERTE(m_pZapper == NULL);
-
-        NGenOptions options = {0};
-        NGenPrivateAttributesClass privateAttributesClass;
-
-        InitNGenOptions(&options, privateAttributesClass, scenario);
-        options.lpszExecutableFileName = pAppBaseOrConfig;
-        m_pZapper = Zapper::NewZapper(&options, true);
-        m_pZapper->CreateDependenciesLookupDomain();
-    }
-
-
-    HRESULT CreatePdb(BSTR pAssemblyName, BSTR pNativeImagePath, BSTR pPdbPath, BOOL pdbLines, BSTR pManagedPdbSearchPath)
-    {
-        SO_NOT_MAINLINE_FUNCTION;
-        _ASSERTE(m_pZapper);
-
-        HRESULT hr = S_OK;
-        EX_TRY {
-
-            m_pZapper->CreatePdb(pAssemblyName, pNativeImagePath, pPdbPath, pdbLines, pManagedPdbSearchPath);
-
-        } EX_CATCH_HRESULT_AND_NGEN_CLEAN(hr);
-
-        return hr;
-    }
-
-private:
-
-    Zapper *m_pZapper;
-
-};
-
-#ifdef _DEBUG
-    inline void DoFreeEnvironmentStrings(LPTCH lpszEnvironmentBlock)
-    {
-        WszFreeEnvironmentStrings(lpszEnvironmentBlock);
-    }
-    typedef Wrapper<LPTCH, DoNothing, DoFreeEnvironmentStrings> EnvHolder;
-#endif //_DEBUG    
-
-//*****************************************************************************
-// ICorSvcWorker contains methods for generating native images and enumerating
-// their dependencies.
-//*****************************************************************************[  
-class CCorSvcWorker : 
-    public ICorSvcWorker3,
-    public ICorSvcRepository,
-    public ICorSvcSetPrivateAttributes,
-#ifdef FEATURE_APPX
-    public ICorSvcAppX,
-#endif
-    public ICorSvcPooledWorker
-{
-public:
-    CCorSvcWorker() :
-        _cRef(0),
-        repositoryDir(NULL),
-        repositoryFlags(RepositoryDefault),
-        ngenPrivateAttributesClass()
-
-#ifdef FEATURE_FUSION
-        ,
-        pAssemblyCache(NULL)
-#endif
-    {
-        g_pLocalServerLifetime->AddRefServerProcess();
-    }
-
-    ~CCorSvcWorker() 
-    {
-#ifdef FEATURE_FUSION
-        if (pAssemblyCache != NULL)
-        {
-            pAssemblyCache->Release();
-            pAssemblyCache = NULL;
-        }
-#endif
-
-        GetSvcLogger()->ReleaseLogger();
-
-        g_pLocalServerLifetime->ReleaseServerProcess();
-    }
-
-    STDMETHOD (SetPriority)(
-            /*[in]*/ SvcWorkerPriority priority
-        )
-    {
-        HRESULT hr = E_FAIL;
-        
-        // Set ourselves to the priority 
-        if (::SetPriorityClass(GetCurrentProcess(),  priority.dwPriorityClass) == FALSE)
-        {
-            hr = HRESULT_FROM_WIN32(GetLastError());
-            goto DONE;
-        }
-
-        hr = S_OK;
-    DONE:
-        return hr;            
-    }
-    
-#ifdef _DEBUG
-    void Debug_CheckPPLProcessStatus(
-        LPCWSTR wszAssemblyName)
-    {
-        size_t cchAssemblyName = wcslen(wszAssemblyName);
-        
-        // Check if we are in PPL (Protected Process Lightweight) by checking existence of LOCALAPPDATA env. var. (it is not present in PPL)
-        BOOL fIsProcessPPL = TRUE;
-        EnvHolder pEnvironmentStrings(WszGetEnvironmentStrings());
-        for (LPTCH pEnv = pEnvironmentStrings; ((pEnv != NULL) && (*pEnv != W('\0'))); pEnv += wcslen(pEnv) + 1)
-        {
-            static const WCHAR  const_wszLocalAppData[] = W("LOCALAPPDATA=");
-            static const size_t const_cchLocalAppData = _countof(const_wszLocalAppData) - 1;
-            if (_wcsnicmp(pEnv, const_wszLocalAppData, const_cchLocalAppData) == 0)
-            {   // LOCALAPPDATA is never set in PPL process
-                fIsProcessPPL = FALSE;
-                break;
-            }
-        }
-        
-        // Semicolon-separated list of names that should assert a failure
-        NewArrayHolder<WCHAR> wszAssertList = NULL;
-        if (fIsProcessPPL)
-        {   // If we are in PPL, we should assert for assemblies that are fobidden to be ngen'd in PPL
-            CLRConfig::GetConfigValue(CLRConfig::INTERNAL_NGenProtectedProcess_ForbiddenList, &wszAssertList);
-        }
-        else
-        {   // If we are not in PPL, we should assert for assemblies that require to be ngen'd in PPL
-            CLRConfig::GetConfigValue(CLRConfig::INTERNAL_NGenProtectedProcess_RequiredList, &wszAssertList);
-        }
-        
-        if ((wszAssertList != NULL) && (*wszAssertList != W('\0')))
-        {
-            LPCWSTR pAssertListName = wszAssertList;
-            for (;;)
-            {
-                LPCWSTR pAssertListNameEnd = wcschr(pAssertListName, W(';'));
-                size_t  cchAssertListName;
-                if (pAssertListNameEnd == NULL)
-                {   // There is not another semicolon
-                    cchAssertListName = wcslen(pAssertListName);
-                }
-                else
-                {
-                    cchAssertListName = pAssertListNameEnd - pAssertListName;
-                }
-
-                if ((cchAssertListName > 0) && (cchAssertListName <= cchAssemblyName))
-                {
-                    // Check prefix or suffix of assembly name (which is either file name or assembly identity name)
-                    if ((_wcsnicmp(wszAssemblyName, pAssertListName, cchAssertListName) == 0) || 
-                        (_wcsnicmp(wszAssemblyName + cchAssemblyName - cchAssertListName, pAssertListName, cchAssertListName) == 0))
-                    {
-                        if (fIsProcessPPL)
-                        {
-                            _ASSERTE_MSG(FALSE, "Assembly that is in NGenProtectedProcess_ForbiddenList is ngen'd in PPL process!");
-                        }
-                        else
-                        {
-                            _ASSERTE_MSG(FALSE, "Assembly that is in NGenProtectedProcess_RequiredList is ngen'd in normal (non-PPL) process!");
-                        }
-                    }
-                }
-
-                if (pAssertListNameEnd == NULL)
-                {   // There are no more names in the semicolon-separated list
-                    break;
-                }
-
-                // Move to next item in the semicolon-separated list (skip also the semicolon)
-                pAssertListName = pAssertListNameEnd + 1;
-            }
-        }
-    } // Debug_CheckPPLProcessStatus
-#endif //_DEBUG
-    
-    STDMETHOD (OptimizeAssembly)(
-        BSTR pAssemblyName, 
-        BSTR pApplicationName, 
-        OptimizationScenario scenario,
-        SAFEARRAY *loadAlwaysList,
-        SAFEARRAY *loadSometimesList,
-        SAFEARRAY *loadNeverList,
-        BSTR *pNativeImageIdentity
-        ) 
-    {
-        SO_NOT_MAINLINE_FUNCTION;
-        
-        INDEBUG(Debug_CheckPPLProcessStatus(pAssemblyName);)
-        
-        HRESULT hr = S_OK;
-        EX_TRY
-        {
-#if defined(_DEBUG) || defined(ALLOW_LOCAL_WORKER)
-            // Make sure optimize is called only once per process
-            static int OptimizeCount = 0;
-#ifdef ALLOW_LOCAL_WORKER
-            if (OptimizeCount != 0)
-            {
-                GetSvcLogger()->Printf(W("You cannot call OptimizeAssembly twice.  If you are using COMPlus_NgenLocalWorker, make sure you are only optimizing one assembly.\r\n"));
-                ThrowHR(E_FAIL);
-            }
-#else // _DEBUG
-            _ASSERTE(OptimizeCount == 0);
-#endif
-            OptimizeCount++;
-#endif
-
-            NGenOptions opt = {0};
-            InitNGenOptions(&opt, ngenPrivateAttributesClass, scenario, repositoryDir, repositoryFlags);
-            opt.lpszExecutableFileName = pApplicationName;
-
-            GUID nativeImageSign;
-            bool hasProfileData;
-
-            hr = ZapperCompileWrapper(pAssemblyName, &opt, &nativeImageSign,
-                                      loadAlwaysList, loadSometimesList, loadNeverList,
-                                      true, &hasProfileData);
-#if 0
-            // Unfotunately we can't perform a retry here as the Zapper currently
-            // allocates and initializes some things once CompilationDomain and
-            // thus some of this stuff will leak from the failed complation.
-            //
-            if (FAILED(hr) && hasProfileData  && retryNgenFailures)
-            {
-                hr = ZapperCompileWrapper(pAssemblyName, &opt, &nativeImageSign,
-                                          loadAlwaysList, loadSometimesList, loadNeverList,
-                                          false, NULL);
-                if (SUCCEEDED(hr))
-                {
-                    StackSString msg;
-                    msg.Printf(W("The compile failed when the profile data was used and ")
-                               W("the compile succeeded when the profile data was ignored."));
-                    GetSvcLogger()->Log(msg, LogLevel_Info);
-                }
-            }
-#endif
-            IfFailThrow(hr);
-
-            _ASSERTE(nativeImageSign != INVALID_NGEN_SIGNATURE || opt.fRepositoryOnly);
-
-            _ASSERTE(pNativeImageIdentity);
-            if (nativeImageSign != INVALID_NGEN_SIGNATURE)
-            {
-                WCHAR szGuid[64];
-                if (GuidToLPWSTR(nativeImageSign, szGuid, sizeof(szGuid) / sizeof(WCHAR)) == 0)
-                    ThrowHR(E_UNEXPECTED);
-                *pNativeImageIdentity = ::SysAllocString(szGuid);
-            }
-            else
-            {
-                *pNativeImageIdentity = NULL;
-            }
-        }
-        EX_CATCH_HRESULT_AND_NGEN_CLEAN(hr);
-
-        return hr;
-    }
-
-    STDMETHOD (DeleteNativeImage)(
-        BSTR pAssemblyName,
-        BSTR pNativeImage
-        ) 
-    {
-        // The caller must either specify both parameters, or specify neither.
-        _ASSERTE((pAssemblyName == NULL && pNativeImage == NULL) ||
-                 (pAssemblyName != NULL && pNativeImage != NULL));
-
-        HRESULT hr = S_OK;
-        EX_TRY
-        {
-            NGenOptions opt = {0};
-            InitNGenOptions(&opt, ngenPrivateAttributesClass);
-            NewHolder<Zapper> zapper = Zapper::NewZapper(&opt, true);
-            _ASSERTE(zapper != NULL);
-
-            GUID *pNativeImageMVID = NULL;
-            GUID nativeImageMVID;
-
-            if (pNativeImage)
-            {
-                StackSString nativeImageString(pNativeImage);
-                StackScratchBuffer buffer;
-                LPCSTR pstr = nativeImageString.GetANSI(buffer);
-                IfFailThrow(LPCSTRToGuid((LPCSTR) pstr, &nativeImageMVID));
-                pNativeImageMVID = &nativeImageMVID;
-            }
-
-#ifdef FEATURE_FUSION
-            if (pAssemblyName != NULL && pNativeImageMVID != NULL)
-            {
-                // Deleting a specific native image.
-                zapper->DeleteFusionCacheEntry(pAssemblyName, pNativeImageMVID);
-            }
-            else if (pAssemblyName != NULL || pNativeImageMVID != NULL)
-            {
-                hr = E_UNEXPECTED;
-            }
-            else
-            {
-                // Not deleting a specific native image.  Need to enumerate NIC.
-                IfFailThrow(zapper->EnumerateFusionCache(NULL, false, true, NULL));
-            }
-#else //FEATURE_FUSION
-            _ASSERTE(!"NYI");
-#endif //FEATURE_FUSION
-        }
-        EX_CATCH_HRESULT_AND_NGEN_CLEAN(hr);
-
-        return hr;
-    }
-
-    STDMETHOD (DisplayNativeImages)(BSTR pAssemblyName) 
-    {
-#ifdef FEATURE_FUSION
-        HRESULT hr = S_OK;
-        EX_TRY
-        {
-            NGenOptions opt = {0};
-            InitNGenOptions(&opt, ngenPrivateAttributesClass);
-            NewHolder<Zapper> zapper = Zapper::NewZapper(&opt, true);
-            _ASSERTE(zapper != NULL);
-        
-            IfFailThrow(zapper->EnumerateFusionCache(pAssemblyName, true, false, NULL));
-        }
-        EX_CATCH_HRESULT_AND_NGEN_CLEAN(hr);
-
-        return hr;
-#else //FEATURE_FUSION
-        return E_NOTIMPL;
-#endif //FEATURE_FUSION
-    }
-
-    STDMETHOD(GetCorSvcDependencies)(
-        BSTR pApplicationName,
-        OptimizationScenario scenario,
-        ICorSvcDependencies **ppCorSvcDependencies
-        )
-    {
-        SO_NOT_MAINLINE_FUNCTION;
-        
-        HRESULT hr = S_OK;
-        EX_TRY
-        {
-            NewHolder<CCorSvcDependencies> pCorSvcDependencies(new CCorSvcDependencies());
-            pCorSvcDependencies->Initialize(pApplicationName, scenario);
-            IfFailThrow(pCorSvcDependencies->QueryInterface(IID_ICorSvcDependencies, (void **) ppCorSvcDependencies));
-            pCorSvcDependencies.SuppressRelease();
-        }
-        EX_CATCH_HRESULT_AND_NGEN_CLEAN(hr);
-
-        return hr;
-    }
-
-    STDMETHOD(Stop)() 
-    {
-        return S_OK;
-    }
-
-    STDMETHOD(CreatePdb)(__in BSTR pAssemblyName, 
-                         __in BSTR pAppBaseOrConfig,
-                         __in OptimizationScenario scenario,
-                         __in BSTR pNativeImagePath,
-                         __in BSTR pPdbPath)
-    {
-        return CreatePdb2(
-            pAssemblyName, 
-            pAppBaseOrConfig,
-            scenario,
-            pNativeImagePath,
-            pPdbPath,
-            FALSE,
-            NULL);
-    }
-
-    STDMETHOD(CreatePdb2)(__in BSTR pAssemblyName, 
-                         __in BSTR pAppBaseOrConfig,
-                         __in OptimizationScenario scenario,
-                         __in BSTR pNativeImagePath,
-                         __in BSTR pPdbPath,
-                         __in BOOL pdbLines,
-                         __in BSTR pManagedPdbSearchPath)
-    {
-        SO_NOT_MAINLINE_FUNCTION;
-
-        HRESULT hr = S_OK;
-
-        EX_TRY {
-
-            CCorSvcCreatePdbWorker worker;
-            worker.Initialize(pAppBaseOrConfig, scenario);
-            hr = worker.CreatePdb(pAssemblyName, pNativeImagePath, pPdbPath, pdbLines, pManagedPdbSearchPath);
-
-        } EX_CATCH_HRESULT_AND_NGEN_CLEAN(hr);
-
-        return hr;
-    }
-
-#ifdef FEATURE_APPX
-    STDMETHOD(SetPackage)(__in BSTR pPackageFullName)
-    {
-        return AppX::SetCurrentPackageForNGen(pPackageFullName);
-    }
-
-    STDMETHOD(SetLocalAppDataDirectory)(__in BSTR pLocalAppDataDirectory)
-    {
-        return Clr::Util::SetLocalAppDataDirectory(pLocalAppDataDirectory);
-    }
-#endif
-
-    STDMETHOD (SetRepository)(
-        BSTR pRepositoryDir,
-        RepositoryFlags flags
-        )
-    {
-        _ASSERTE(repositoryFlags == RepositoryDefault);
-        _ASSERTE(repositoryDir == NULL);
-
-        repositoryDir = ::SysAllocString(pRepositoryDir);
-        repositoryFlags = flags;
-
-        return S_OK;
-    }
-
-    STDMETHOD (SetNGenPrivateAttributes)(
-        NGenPrivateAttributes ngenPrivateAttributes
-        )
-    {
-        _ASSERTE(ngenPrivateAttributesClass.Flags == 0);
-        _ASSERTE(ngenPrivateAttributesClass.ZapStats == 0);
-
-        ngenPrivateAttributesClass.Flags = ngenPrivateAttributes.Flags;
-        ngenPrivateAttributesClass.ZapStats = ngenPrivateAttributes.ZapStats;
-        
-        if (ngenPrivateAttributes.DbgDir)
-        {
-            _ASSERTE(ngenPrivateAttributesClass.DbgDir == NULL);
-            ngenPrivateAttributesClass.DbgDir = ::SysAllocString(ngenPrivateAttributes.DbgDir);
-        }
-        
-        return S_OK;
-    }
-
-    STDMETHOD (CanReuseProcess)(
-        OptimizationScenario scenario,
-        ICorSvcLogger *pCorSvcLogger,
-        BOOL *pCanContinue)
-    {
-        SO_NOT_MAINLINE_FUNCTION;
-
-        HRESULT hr = S_OK;
-
-        _ASSERTE(pCanContinue != NULL);
-        *pCanContinue = FALSE;
-
-        return hr;
-    }
-
-    static HRESULT CreateObject(REFIID riid, void **ppUnk)
-    {
-        HRESULT     hr;
-        CCorSvcWorker *pCorSvcWorker = new (nothrow) CCorSvcWorker();
-
-        if (pCorSvcWorker == 0)
-            return (E_OUTOFMEMORY);
-
-        hr = pCorSvcWorker->QueryInterface(riid, ppUnk);
-        if (FAILED(hr))
-            delete pCorSvcWorker;
-        return (hr);
-    }
-
-    STDMETHODIMP_(ULONG)    AddRef()
-    {                               
-        return InterlockedIncrement (&_cRef);
-    }
-
-    STDMETHODIMP_(ULONG)    Release()
-    {
-        ULONG lRet = InterlockedDecrement (&_cRef);
-        if (!lRet)
-            delete this;
-        return lRet;
-    }
-
-    STDMETHODIMP QueryInterface(REFIID riid,void ** ppv)
-    {
-        if (!ppv)
-            return E_POINTER;
-
-        if (IsEqualIID(riid, IID_IUnknown) ||
-            IsEqualIID(riid, IID_ICorSvcWorker))
-        {
-            *ppv = static_cast<ICorSvcWorker*> (this);
-            AddRef();
-            return S_OK;
-        }
-        else if (IsEqualIID(riid, IID_ICorSvcWorker2))
-        {
-            *ppv = static_cast<ICorSvcWorker2 *>(this);
-            AddRef();
-            return S_OK;
-        }
-        else if (IsEqualIID(riid, IID_ICorSvcWorker3))
-        {
-            *ppv = static_cast<ICorSvcWorker3 *>(this);
-            AddRef();
-            return S_OK;
-        }
-        else if (IsEqualIID(riid, IID_ICorSvcRepository))
-        {
-            *ppv = static_cast<ICorSvcRepository*> (this);
-            AddRef();
-            return S_OK;
-        }
-        else if (IsEqualIID(riid, IID_ICorSvcSetPrivateAttributes)) 
-        {
-            *ppv = static_cast<ICorSvcSetPrivateAttributes *> (this);
-            AddRef();
-            return S_OK;
-        }
-#ifdef FEATURE_APPX
-        else if (IsEqualIID(riid, IID_ICorSvcAppX)) 
-        {
-            *ppv = static_cast<ICorSvcAppX *> (this);
-            AddRef();
-            return S_OK;
-        }
-#endif
-        else if (IsEqualIID(riid, IID_ICorSvcPooledWorker))
-        {
-            *ppv = static_cast<ICorSvcPooledWorker *> (this);
-            AddRef();
-            return S_OK;
-        }
-        else
-        {
-            *ppv = NULL;
-            return E_NOINTERFACE;
-        }
-    }
-
-private:
-    HRESULT ZapperCompileWrapper(BSTR          pAssemblyName, 
-                                 NGenOptions * pOpt,
-                                 GUID *        pNativeImageSign,
-                                 SAFEARRAY *   loadAlwaysList,
-                                 SAFEARRAY *   loadSometimesList,
-                                 SAFEARRAY *   loadNeverList,
-                                 bool          useProfileData,
-                                 bool *        pHasProfileData)
-    {
-        NewHolder<Zapper> zapper(Zapper::NewZapper(pOpt, true));
-
-        *pNativeImageSign = INVALID_NGEN_SIGNATURE;
-
-        // Push the load lists to the zapper
-        zapper->SetLoadLists(loadAlwaysList, loadSometimesList, loadNeverList);
-        if (useProfileData == false)
-        {
-            zapper->DontUseProfileData();
-        }
-
-        HRESULT hr = zapper->Compile(pAssemblyName, pNativeImageSign);
-
-        if (pHasProfileData != NULL)
-        {
-            *pHasProfileData = zapper->HasProfileData();
-        }
-
-        if (!FAILED(hr) && (*pNativeImageSign == INVALID_NGEN_SIGNATURE) && !pOpt->fRepositoryOnly)
-        {
-            // Unfortunately we can get a passing HR when an EE exception was
-            // thrown because the zapper EH logic can't get the correct HR
-            // out of the EE exception.  This will be fixed, but for now we
-            // should also return E_FAIL in that case.
-
-            hr = E_FAIL;
-        }
-
-        return hr;
-    }
-
-private:
-    LONG _cRef;
-
-    BSTRHolder      repositoryDir;
-    RepositoryFlags repositoryFlags;
- 
-    NGenPrivateAttributesClass ngenPrivateAttributesClass;
-
-#ifdef FEATURE_FUSION
-    IAssemblyCache *pAssemblyCache;
-#endif // FEATURE_FUSION
-};
-
-STDAPI NGenCreateNGenWorker(ICorSvcWorker **pCorSvcWorker, ILocalServerLifetime *pLocalServerLifetime, ICorSvcLogger *pCorSvcLogger)
-{
-
-    HRESULT hr = S_OK;
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    EX_TRY
-    {
-        _ASSERTE(pLocalServerLifetime);
-        //_ASSERTE(g_pLocalServerLifetime == NULL);
-
-        g_pLocalServerLifetime = pLocalServerLifetime;
-
-        GetSvcLogger()->SetSvcLogger(pCorSvcLogger);
- 
-        IfFailThrow(CCorSvcWorker::CreateObject(IID_ICorSvcWorker, (void **) pCorSvcWorker));
-    }
-    EX_CATCH_HRESULT_AND_NGEN_CLEAN(hr);
-    END_ENTRYPOINT_NOTHROW;
-
-    return hr;
-}
-
-#endif // !FEATURE_CORECLR
diff --git a/src/zap/zapimage.cpp b/src/zap/zapimage.cpp
index f39b8f8f54..24f081a6f9 100644
--- a/src/zap/zapimage.cpp
+++ b/src/zap/zapimage.cpp
@@ -41,10 +41,6 @@ ZapImage::ZapImage(Zapper *zapper)
   : m_zapper(zapper)
     /* Everything else is initialized to 0 by default */
 {
-#ifndef FEATURE_CORECLR
-    if (m_zapper->m_pOpt->m_statOptions)
-        m_stats = new ZapperStats();
-#endif
 }
 
 ZapImage::~ZapImage()
@@ -57,10 +53,6 @@ ZapImage::~ZapImage()
     //
     // Clean up.
     //
-#ifndef FEATURE_CORECLR
-    if (m_stats != NULL)
-        delete m_stats;
-#endif
 
     if (m_pModuleFileName != NULL)
         delete [] m_pModuleFileName;
@@ -172,9 +164,7 @@ void ZapImage::InitializeSections()
 
     m_pHelperThunks = new (GetHeap()) ZapNode * [CORINFO_HELP_COUNT];
 
-#ifdef FEATURE_CORECLR
     if (!m_zapper->m_pOpt->m_fNoMetaData)
-#endif
     {
         m_pILMetaData = new (GetHeap()) ZapILMetaData(this);
         m_pILMetaDataSection->Place(m_pILMetaData);
@@ -226,11 +216,7 @@ void ZapImage::InitializeSectionsForReadyToRun()
     m_pHeaderSection->Place(m_pImportSectionsTable);
 
     {
-#ifdef FEATURE_CORECLR
 #define COMPILER_NAME "CoreCLR"
-#else
-#define COMPILER_NAME "CLR"
-#endif
 
         const char * pCompilerIdentifier = COMPILER_NAME " " FX_FILEVERSION_STR " " QUOTE_MACRO(__BUILDMACHINE__);
         ZapBlob * pCompilerIdentifierBlob = new (GetHeap()) ZapBlobPtr((PVOID)pCompilerIdentifier, strlen(pCompilerIdentifier) + 1);
@@ -1090,75 +1076,6 @@ HANDLE ZapImage::GenerateFile(LPCWSTR wszOutputFileName, CORCOMPILE_NGEN_SIGNATU
     return hFile;
 }
 
-#ifdef FEATURE_FUSION
-#define WOF_PROVIDER_FILE           (0x00000002)
-
-typedef BOOL (WINAPI *WofShouldCompressBinaries_t) (
-    __in LPCWSTR Volume,
-    __out PULONG Algorithm
-    );
-
-typedef HRESULT (WINAPI *WofSetFileDataLocation_t) (
-    __in HANDLE hFile,
-    __in ULONG Provider,
-    __in PVOID FileInfo,
-    __in ULONG Length
-    );
-
-typedef struct _WOF_FILE_COMPRESSION_INFO {
-    ULONG Algorithm;
-} WOF_FILE_COMPRESSION_INFO, *PWOF_FILE_COMPRESSION_INFO;
-
-// Check if files on the volume identified by volumeLetter should be compressed.
-// If yes, compress the file associated with hFile.
-static void CompressFile(WCHAR volumeLetter, HANDLE hFile)
-{
-    if (IsNgenOffline())
-    {
-        return;
-    }
-
-    // Wofutil.dll is available on Windows 8.1 and above. Return on platforms without wofutil.dll.
-    HModuleHolder wofLibrary(WszLoadLibraryEx(L"wofutil.dll", NULL, LOAD_LIBRARY_SEARCH_SYSTEM32));
-    if (wofLibrary == nullptr)
-    {
-        return;
-    }
-
-    // WofShouldCompressBinaries is available on Windows 10 and above.
-    // Windows 8.1 version of wofutil.dll does not have this function.
-    WofShouldCompressBinaries_t WofShouldCompressBinaries
-        = (WofShouldCompressBinaries_t)GetProcAddress(wofLibrary, "WofShouldCompressBinaries");
-    if (WofShouldCompressBinaries == nullptr)
-    {
-        return;
-    }
-
-    WCHAR volume[4] = L"X:\\";
-    volume[0] = volumeLetter;
-    ULONG algorithm = 0;
-
-    bool compressionSuitable = (WofShouldCompressBinaries(volume, &algorithm) == TRUE);
-    if (compressionSuitable)
-    {
-        // WofSetFileDataLocation is available on Windows 8.1 and above, however, Windows 8.1 version
-        // of WofSetFileDataLocation works for WIM only, and Windows 10 is required for compression of
-        // normal files.  This isn't a problem for us, since the check for WofShouldCompressBinaries
-        // above should have already returned on Windows 8.1.
-        WofSetFileDataLocation_t WofSetFileDataLocation = 
-            (WofSetFileDataLocation_t)GetProcAddress(wofLibrary, "WofSetFileDataLocation");
-        if (WofSetFileDataLocation == nullptr)
-        {
-            return;
-        }
-
-        WOF_FILE_COMPRESSION_INFO fileInfo;
-        fileInfo.Algorithm = algorithm;
-
-        WofSetFileDataLocation(hFile, WOF_PROVIDER_FILE, &fileInfo, sizeof(WOF_FILE_COMPRESSION_INFO));
-    }
-}
-#endif
 
 HANDLE ZapImage::SaveImage(LPCWSTR wszOutputFileName, CORCOMPILE_NGEN_SIGNATURE * pNativeImageSig)
 {
@@ -1186,14 +1103,7 @@ HANDLE ZapImage::SaveImage(LPCWSTR wszOutputFileName, CORCOMPILE_NGEN_SIGNATURE
 
     HANDLE hFile = GenerateFile(wszOutputFileName, pNativeImageSig);
 
-#ifndef FEATURE_CORECLR
-    if (m_stats != NULL)
-        PrintStats(wszOutputFileName);
-#endif
 
-#ifdef FEATURE_FUSION
-    CompressFile(wszOutputFileName[0], hFile);
-#endif
 
     return hFile;
 }
@@ -1354,10 +1264,6 @@ void ZapImage::CalculateZapBaseAddress()
         //
         // CoreCLR currently always loads both the IL and the native image, so
         // move the native image out of the way.
-#ifndef FEATURE_CORECLR
-        if (!m_ModuleDecoder.IsDll() ||     // exes always get loaded to their preferred base address
-            !m_ModuleDecoder.IsILOnly())    // since the IL (IJW) image will be loaded first
-#endif // !FEATURE_CORECLR
         {
             baseAddress += m_ModuleDecoder.GetVirtualSize();
         }
@@ -1414,28 +1320,6 @@ void ZapImage::Open(CORINFO_MODULE_HANDLE hModule,
 
     m_ModuleDecoder = *m_zapper->m_pEECompileInfo->GetModuleDecoder(hModule);
 
-#ifdef FEATURE_FUSION
-    // If TranslatePEToArchitectureType fails then we have an invalid format
-    DWORD dwPEKind, dwMachine;
-    m_ModuleDecoder.GetPEKindAndMachine(&dwPEKind, &dwMachine);
-
-    PEKIND PeKind;
-    IfFailThrow(TranslatePEToArchitectureType((CorPEKind)dwPEKind, dwMachine, &PeKind));
-    
-    // Valid images for this platform are peMSIL and the native image for the platform
-    if (!(PeKind == peMSIL
-#if defined(_TARGET_AMD64_)
-          || PeKind == peAMD64
-#elif defined(_TARGET_X86_)
-          || PeKind == peI386
-#elif defined(_TARGET_ARM_)
-          || PeKind == peARM
-#endif
-        ))
-    {
-        ThrowHR(NGEN_E_EXE_MACHINE_TYPE_MISMATCH);
-    }
-#endif // FEATURE_FUSION
 
     //
     // Get file name, and base address from module
@@ -1498,54 +1382,6 @@ void ZapImage::Open(CORINFO_MODULE_HANDLE hModule,
     CalculateZapBaseAddress();
 }
 
-#if !defined(FEATURE_CORECLR)
-
-#if (_WIN32_WINNT < _WIN32_WINNT_WIN8)
-
-typedef struct _WIN32_MEMORY_RANGE_ENTRY {
-
-    PVOID VirtualAddress;
-    SIZE_T NumberOfBytes;
-
-} WIN32_MEMORY_RANGE_ENTRY, *PWIN32_MEMORY_RANGE_ENTRY;
-
-#endif
-
-typedef BOOL  
-(WINAPI *PfnPrefetchVirtualMemory)(  
-    _In_ HANDLE hProcess,  
-    _In_ ULONG_PTR NumberOfEntries,  
-    _In_reads_(NumberOfEntries) PWIN32_MEMORY_RANGE_ENTRY VirtualAddresses,  
-    _In_ ULONG Flags  
-    );  
-  
-
-void PrefetchVM(void * pStartAddress, SIZE_T size)
-{
-    static PfnPrefetchVirtualMemory s_pfnPrefetchVirtualMemory = NULL;  
-
-    if (s_pfnPrefetchVirtualMemory == NULL)
-    {
-        s_pfnPrefetchVirtualMemory = (PfnPrefetchVirtualMemory) GetProcAddress(WszGetModuleHandle(WINDOWS_KERNEL32_DLLNAME_W), "PrefetchVirtualMemory");  
-
-        if (s_pfnPrefetchVirtualMemory == NULL)
-        {
-            s_pfnPrefetchVirtualMemory = (PfnPrefetchVirtualMemory) (1);
-        }
-    }
-
-    if (s_pfnPrefetchVirtualMemory > (PfnPrefetchVirtualMemory) (1))
-    {
-        WIN32_MEMORY_RANGE_ENTRY range;
-
-        range.VirtualAddress = pStartAddress;
-        range.NumberOfBytes  = size;
-
-        s_pfnPrefetchVirtualMemory(GetCurrentProcess(), 1, & range, 0);
-    }
-}
-
-#endif
 
 
 
@@ -1555,10 +1391,6 @@ void PrefetchVM(void * pStartAddress, SIZE_T size)
 
 void ZapImage::Preload()
 {
-#if !defined(FEATURE_CORECLR)
-    // Prefetch the whole IL image into memory to avoid small reads (usually 16kb blocks)
-    PrefetchVM(m_ModuleDecoder.GetBase(), m_ModuleDecoder.GetSize());
-#endif
 
     CorProfileData *  pProfileData = NewProfileData();
     m_pPreloader = m_zapper->m_pEECompileInfo->PreloadModule(m_hModule, this, pProfileData);
@@ -1698,14 +1530,6 @@ void ZapImage::OutputTables()
 
     if (IsReadyToRunCompilation())
     {
-#ifndef FEATURE_CORECLR
-        // Some older versions of Windows (e.g., Win7) can incorrectly fixup
-        // relocations if IsDll is not set. In CoreCLR, we handle this by
-        // always using the default value of IsDll, which is true. We can't
-        // use the same fix in desktop CLR, since in this case the ReadyToRun
-        // image can be used to create processes.
-        SetIsDll(m_ModuleDecoder.IsDll());
-#endif
 
         SetSizeOfStackReserve(m_ModuleDecoder.GetSizeOfStackReserve());
         SetSizeOfStackCommit(m_ModuleDecoder.GetSizeOfStackCommit());
@@ -1714,7 +1538,7 @@ void ZapImage::OutputTables()
 #if defined(FEATURE_PAL)
     // PAL library requires native image sections to align to page bounaries.
     SetFileAlignment(0x1000);
-#elif defined(_TARGET_ARM_) && defined(FEATURE_CORECLR) && defined(FEATURE_CORESYSTEM)
+#elif defined(_TARGET_ARM_) && defined(FEATURE_CORESYSTEM)
     if (!IsReadyToRunCompilation())
     {
         // On ARM CoreSys builds, crossgen will use 4k file alignment, as requested by Phone perf team
@@ -2627,15 +2451,6 @@ HRESULT ZapImage::parseProfileData()
     }
 
     // CoreCLR should never be presented with V1 IBC data.
-#ifndef FEATURE_CORECLR
-    if ((fileHeader->Version == CORBBTPROF_V1_VERSION) && CanConvertIbcData())
-    {
-        // Read and convert V1 data
-        m_zapper->Info(W("Converting V1 IBC data to latest format.\n"));
-        convertFromV1 = true;
-    }
-    else
-#endif
     if (fileHeader->Version == CORBBTPROF_V3_VERSION)
     {
         CORBBTPROF_FILE_OPTIONAL_HEADER *optionalHeader =
@@ -3576,23 +3391,17 @@ void ZapImage::FileNotFoundError(LPCWSTR pszMessage)
     level = CORZAP_LOGLEVEL_ERROR;
 #endif
 
-#ifndef FEATURE_CORECLR
-    m_zapper->Print(level, W("Warning: %s. If this assembly is found during runtime of an application, then the native image currently being generated will not be used.\n"), pszMessage);
-#else
     m_zapper->Print(level, W("Warning: %s.\n"), pszMessage);
-#endif
 
     fileNotFoundErrorsTable.Append(message);
 }
 
 void ZapImage::Error(mdToken token, HRESULT hr, LPCWSTR message)
 {
-#if defined(FEATURE_CORECLR) || defined(CROSSGEN_COMPILE)
     // Missing dependencies are reported as fatal errors in code:CompilationDomain::BindAssemblySpec.
     // Avoid printing redundant error message for them.
     if (FAILED(g_hrFatalError))
         ThrowHR(g_hrFatalError);
-#endif
 
     CorZapLogLevel level = CORZAP_LOGLEVEL_ERROR;
 
diff --git a/src/zap/zapimport.cpp b/src/zap/zapimport.cpp
index 47d0def2c1..3e4e45d0c7 100644
--- a/src/zap/zapimport.cpp
+++ b/src/zap/zapimport.cpp
@@ -351,7 +351,7 @@ ZapGenericSignature * ZapImportTable::GetGenericSignature(PVOID signature, BOOL
 // At ngen time Zapper::CompileModule PlaceFixups called from
 //     code:ZapSig.GetSignatureForTypeHandle
 //
-/*static*/ DWORD __stdcall ZapImportTable::EncodeModuleHelper( LPVOID compileContext,
+/*static*/ DWORD ZapImportTable::EncodeModuleHelper( LPVOID compileContext,
                                                 CORINFO_MODULE_HANDLE referencedModule)
 {
     ZapImportTable * pTable = (ZapImportTable *)compileContext;
diff --git a/src/zap/zapimport.h b/src/zap/zapimport.h
index 34a673ecf5..3ab9a2734e 100644
--- a/src/zap/zapimport.h
+++ b/src/zap/zapimport.h
@@ -301,7 +301,7 @@ class ZapImportTable : public ZapNode
 
     ModuleReferenceEntry * GetModuleReference(CORINFO_MODULE_HANDLE handle);
 
-    static DWORD __stdcall EncodeModuleHelper(LPVOID referencingModule, CORINFO_MODULE_HANDLE referencedModule);
+    static DWORD EncodeModuleHelper(LPVOID referencingModule, CORINFO_MODULE_HANDLE referencedModule);
 
     ImportTable m_imports;          // Interned ZapImport *
     SHash< NoRemoveSHashTraits < ZapBlob::SHashTraits > > m_blobs; // Interned ZapBlos for signatures and fixups
diff --git a/src/zap/zapinfo.cpp b/src/zap/zapinfo.cpp
index d2362d4b90..4b2f39a264 100644
--- a/src/zap/zapinfo.cpp
+++ b/src/zap/zapinfo.cpp
@@ -466,10 +466,6 @@ void ZapInfo::CompileMethod()
             return;
     }
 
-#if !defined(FEATURE_CORECLR)
-    // Ask the JIT to generate desktop-quirk-compatible code.
-    m_jitFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_DESKTOP_QUIRKS);
-#endif
 
     if (m_pImage->m_stats)
     {
@@ -1239,9 +1235,6 @@ int ZapInfo::canHandleException(struct _EXCEPTION_POINTERS *pExceptionPointers)
 
 int ZapInfo::doAssert(const char* szFile, int iLine, const char* szExpr)
 {
-#if defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)
-    ThrowHR(COR_E_INVALIDPROGRAM);
-#else
 
 #if defined(_DEBUG)
     return(_DbgBreakCheck(szFile, iLine, szExpr));
@@ -1249,7 +1242,6 @@ int ZapInfo::doAssert(const char* szFile, int iLine, const char* szExpr)
     return(true);       // break into debugger
 #endif
 
-#endif
 }
 void ZapInfo::reportFatalError(CorJitResult result)
 {
@@ -2574,9 +2566,6 @@ void ZapInfo::recordRelocation(void *location, void *target,
         break;
 
     case IMAGE_REL_BASED_PTR:
-#if defined(_TARGET_AMD64_) && !defined(FEATURE_CORECLR)
-        _ASSERTE(!"Why we are not using RIP relative address?");
-#endif
         *(UNALIGNED TADDR *)location = (TADDR)targetOffset;
         break;
 
@@ -3277,15 +3266,6 @@ size_t ZapInfo::getClassModuleIdForStatics(CORINFO_CLASS_HANDLE cls, CORINFO_MOD
         // if the fixups were exclusively based on the moduleforstatics lookup
         cls = NULL;
 
-#ifndef FEATURE_CORECLR
-
-        // Is this mscorlib.dll (which has ModuleDomainId of 0 (tagged == 1), then you don't need a fixup
-        if (moduleId == (size_t) 1)
-        {
-            *ppIndirection = NULL;
-            return (size_t) 1;
-        }
-#endif
 
         if (module == m_pImage->m_hModule)
         {
@@ -3643,15 +3623,6 @@ void ZapInfo::reportInliningDecision (CORINFO_METHOD_HANDLE inlinerHnd,
                                                 const char * reason)
 {
 
-#ifndef FEATURE_CORECLR
-    if (!dontInline(inlineResult) && inlineeHnd != NULL)
-    {
-        // We deliberately report  m_currentMethodHandle (not inlinerHnd) as inliner, because
-        // if m_currentMethodHandle != inlinerHnd, it simply means that inlinerHnd is intermediate link 
-        // in inlining into m_currentMethodHandle, and we have no interest to track those intermediate links now.
-        m_pImage->m_pPreloader->ReportInlining(m_currentMethodHandle, inlineeHnd);
-    }
-#endif //FEATURE_CORECLR
 
     return m_pEEJitInfo->reportInliningDecision(inlinerHnd, inlineeHnd, inlineResult, reason);
 }
diff --git a/src/zap/zapper.cpp b/src/zap/zapper.cpp
index 2c7023a400..502e5935f6 100644
--- a/src/zap/zapper.cpp
+++ b/src/zap/zapper.cpp
@@ -5,27 +5,15 @@
 
 #include "common.h"
 
-#ifdef FEATURE_FUSION
-#include "binderngen.h"
-#endif
 
 #ifndef FEATURE_MERGE_JIT_AND_ENGINE
 #include "metahost.h"
 #endif
 
-#if defined(FEATURE_APPX) && !defined(FEATURE_CORECLR)
-#include "AppXUtil.h"
-#include "AssemblyUsageLogManager.h"
-#endif
 
-#if defined(FEATURE_CORECLR) || defined(CROSSGEN_COMPILE)
 #include "coregen.h"
-#endif
 
 #include "clr/fs/dir.h"
-#ifdef FEATURE_FUSION
-#include "ngenparser.inl"
-#endif
 
 /* --------------------------------------------------------------------------- *
  * Error Macros
@@ -44,9 +32,6 @@ BOOL g_fForceDebug, g_fForceProfile, g_fForceInstrument;
 #endif
 
 
-#ifdef FEATURE_FUSION
-extern "C" HRESULT STDMETHODCALLTYPE InitializeFusion();
-#endif
 
 #pragma warning(push)
 #pragma warning(disable: 4995)
@@ -55,21 +40,14 @@ extern "C" HRESULT STDMETHODCALLTYPE InitializeFusion();
 
 extern const WCHAR g_pwBaseLibrary[];
 extern bool g_fAllowNativeImages;
-#if defined(FEATURE_CORECLR) || defined(CROSSGEN_COMPILE)
 bool g_fNGenMissingDependenciesOk;
-#endif
 bool g_fNGenWinMDResilient;
-#if !defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)
-extern int g_ningenState;
-#endif
 
 #ifdef FEATURE_READYTORUN_COMPILER
 bool g_fReadyToRunCompilation;
 #endif
 
-#ifdef FEATURE_CORECLR
 static bool s_fNGenNoMetaData;
-#endif
 
 // Event logging helper
 void Zapper::ReportEventNGEN(WORD wType, DWORD dwEventID, LPCWSTR format, ...)
@@ -97,38 +75,6 @@ void Zapper::ReportEventNGEN(WORD wType, DWORD dwEventID, LPCWSTR format, ...)
         Warning(W("%s\n"), s.GetUnicode());
 }
 
-#ifdef FEATURE_FUSION
-static HRESULT GetAssemblyName(
-    ICorCompileInfo * pCCI,
-    CORINFO_ASSEMBLY_HANDLE hAssembly,
-    SString & str,
-    DWORD dwFlags)
-{
-    DWORD dwSize = 0;
-    LPWSTR buffer = NULL;
-    COUNT_T allocation = str.GetUnicodeAllocation();
-    if (allocation > 0)
-    {
-        // pass in the buffer if we got one
-        dwSize = allocation + 1;
-        buffer = str.OpenUnicodeBuffer(allocation);
-    }
-    HRESULT hr = pCCI->GetAssemblyName(hAssembly, dwFlags, buffer, &dwSize);
-    if (hr == HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER))
-    {
-        if (buffer != NULL) 
-            str.CloseBuffer(0);
-        buffer = str.OpenUnicodeBuffer(dwSize-1);
-        hr = pCCI->GetAssemblyName(hAssembly, dwFlags, buffer, &dwSize);
-    }
-    if (buffer != NULL)
-    {
-        str.CloseBuffer((SUCCEEDED(hr) && dwSize >= 1) ? (dwSize-1) : 0);
-    }
-
-    return hr;
-}
-#endif // FEATURE_FUSION
 
 /* --------------------------------------------------------------------------- *
  * Private fusion entry points
@@ -140,7 +86,6 @@ static HRESULT GetAssemblyName(
 // For side by side issues, it's best to use the exported API calls to generate a
 // Zapper Object instead of creating one on your own.
 
-#if defined(FEATURE_CORECLR) || defined(CROSSGEN_COMPILE)
 
 STDAPI NGenWorker(LPCWSTR pwzFilename, DWORD dwFlags, LPCWSTR pwzPlatformAssembliesPaths, LPCWSTR pwzTrustedPlatformAssemblies, LPCWSTR pwzPlatformResourceRoots, LPCWSTR pwzAppPaths, LPCWSTR pwzOutputFilename=NULL, LPCWSTR pwzPlatformWinmdPaths=NULL, ICorSvcLogger *pLogger = NULL, LPCWSTR pwszCLRJITPath = nullptr)
 {    
@@ -185,9 +130,7 @@ STDAPI NGenWorker(LPCWSTR pwzFilename, DWORD dwFlags, LPCWSTR pwzPlatformAssembl
 
         ngo.fNgenLastRetry = false;
 
-#ifdef FEATURE_CORECLR
         s_fNGenNoMetaData = (dwFlags & NGENWORKER_FLAGS_NO_METADATA) != 0;
-#endif
 
         zap = Zapper::NewZapper(&ngo);
 
@@ -209,10 +152,10 @@ STDAPI NGenWorker(LPCWSTR pwzFilename, DWORD dwFlags, LPCWSTR pwzPlatformAssembl
         if (pwzPlatformWinmdPaths != nullptr)
             zap->SetPlatformWinmdPaths(pwzPlatformWinmdPaths);
 
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#if !defined(FEATURE_MERGE_JIT_AND_ENGINE)
         if (pwszCLRJITPath != nullptr)
             zap->SetCLRJITPath(pwszCLRJITPath);
-#endif // defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#endif // !defined(FEATURE_MERGE_JIT_AND_ENGINE)
 
         zap->SetForceFullTrust(!!(dwFlags & NGENWORKER_FLAGS_FULLTRUSTDOMAIN));
 
@@ -255,9 +198,9 @@ STDAPI CreatePDBWorker(LPCWSTR pwzAssemblyPath, LPCWSTR pwzPlatformAssembliesPat
 
         zap = Zapper::NewZapper(&ngo);
 
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#if !defined(FEATURE_MERGE_JIT_AND_ENGINE)
         zap->SetDontLoadJit();
-#endif // defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#endif // !defined(FEATURE_MERGE_JIT_AND_ENGINE)
 
         if (pwzPlatformAssembliesPaths != nullptr)
             zap->SetPlatformAssembliesPaths(pwzPlatformAssembliesPaths);
@@ -277,10 +220,10 @@ STDAPI CreatePDBWorker(LPCWSTR pwzAssemblyPath, LPCWSTR pwzPlatformAssembliesPat
         if (pwzPlatformWinmdPaths != nullptr)
             zap->SetPlatformWinmdPaths(pwzPlatformWinmdPaths);
 
-#if defined(FEATURE_CORECLR) && !defined(NO_NGENPDB)
+#if !defined(NO_NGENPDB)
         if (pwzDiasymreaderPath != nullptr)
             zap->SetDiasymreaderPath(pwzDiasymreaderPath);
-#endif // defined(FEATURE_CORECLR) && !defined(NO_NGENPDB)
+#endif // !defined(NO_NGENPDB)
 
         // Avoid unnecessary security failures, since permissions are irrelevant when
         // generating NGEN PDBs
@@ -310,100 +253,6 @@ STDAPI CreatePDBWorker(LPCWSTR pwzAssemblyPath, LPCWSTR pwzPlatformAssembliesPat
     return hr;
 }
 
-#else // FEATURE_CORECLR || CROSSGEN_COMPILE
-
-STDAPI LegacyNGenCreateZapper(HANDLE* hZapper, NGenOptions* opt)
-{
-    if (hZapper == NULL)
-        return E_POINTER;
-
-    HRESULT hr = S_OK;
-    Zapper* zap = NULL;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-
-    EX_TRY
-    {
-        zap = Zapper::NewZapper(opt);
-    }
-    EX_CATCH_HRESULT(hr);
-
-    END_ENTRYPOINT_NOTHROW;
-
-    IfFailRet(hr);
-
-    if (zap == NULL)
-        return E_OUTOFMEMORY;
-
-    zap->SetLegacyMode();
-
-    *hZapper = (HANDLE)zap;
-
-    return S_OK;
-}// NGenCreateZapper
-
-STDAPI LegacyNGenFreeZapper(HANDLE hZapper)
-{
-    if (hZapper == NULL || hZapper == INVALID_HANDLE_VALUE)
-        return E_HANDLE;
-
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    Zapper *zapper = (Zapper*)hZapper;
-    delete zapper;
-    END_ENTRYPOINT_NOTHROW;
-
-    return S_OK;
-}// NGenFreeZapper
-
-#ifdef FEATURE_FUSION
-STDAPI LegacyNGenTryEnumerateFusionCache(HANDLE hZapper, LPCWSTR assemblyName, bool fPrint, bool fDelete)
-{
-
-    HRESULT hr = S_OK;
-    if (hZapper == NULL || hZapper == INVALID_HANDLE_VALUE)
-        return E_HANDLE;
-    
-    BEGIN_ENTRYPOINT_NOTHROW;
-
-    Zapper *zapper = (Zapper*)hZapper;
-    hr =  zapper->TryEnumerateFusionCache(assemblyName, fPrint, fDelete);
-    END_ENTRYPOINT_NOTHROW;
-
-    return hr;
-
-}// NGenTryEnumerateFusionCache
-#endif //FEATURE_FUSION
-
-STDAPI_(BOOL) LegacyNGenCompile(HANDLE hZapper, LPCWSTR path)
-{
-    CONTRACTL{
-        ENTRY_POINT;
-    }
-    CONTRACTL_END;
-
-    if (hZapper == NULL || hZapper == INVALID_HANDLE_VALUE)
-        return FALSE;
-
-    HRESULT hr = S_OK;
-
-    BEGIN_ENTRYPOINT_VOIDRET;
-
-    Zapper *zapper = (Zapper*)hZapper;
-
-    EX_TRY
-    {
-        hr = zapper->Compile(path);
-    }
-    EX_CATCH_HRESULT(hr);
-
-    END_ENTRYPOINT_VOIDRET;
-
-    return (hr == S_OK) ? TRUE : FALSE;
-}// NGenCompile
-
-#endif // FEATURE_CORECLR || CROSSGEN_COMPILE
 
 /* --------------------------------------------------------------------------- *
  * Options class
@@ -427,9 +276,7 @@ ZapperOptions::ZapperOptions() :
   m_fNGenLastRetry(false),
   m_compilerFlags(),
   m_legacyMode(false)
-#ifdef FEATURE_CORECLR
   ,m_fNoMetaData(s_fNGenNoMetaData)
-#endif
 {
     m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_RELOC);
     m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_PREJIT);
@@ -539,47 +386,6 @@ Zapper::Zapper(NGenOptions *pOptions, bool fromDllHost)
         zo->m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_PROF_ENTERLEAVE);
     }
 
-#ifdef FEATURE_FUSION
-    if (pOptions->lpszRepositoryDir != NULL && pOptions->lpszRepositoryDir[0] != '\0')
-    {
-        size_t buflen = wcslen(pOptions->lpszRepositoryDir) + 1;
-        LPWSTR lpszDir = new WCHAR[buflen];
-        wcscpy_s(lpszDir, buflen, pOptions->lpszRepositoryDir);
-        zo->m_repositoryDir = lpszDir;
-    }
-    else
-    {
-        zo->m_repositoryDir = CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_RepositoryDir);
-    }
-
-    if (pOptions->repositoryFlags != RepositoryDefault)
-    {
-        zo->m_repositoryFlags = pOptions->repositoryFlags;
-    }
-    else
-    {
-        zo->m_repositoryFlags = (RepositoryFlags)REGUTIL::GetConfigDWORD_DontUse_(CLRConfig::EXTERNAL_RepositoryFlags, RepositoryDefault);
-    }
-
-    // The default location of the repository is "repository" folder under framework version directory
-    if (zo->m_repositoryDir == NULL)
-    {
-        DWORD lgth = _MAX_PATH + 1;
-        WCHAR wszRepositoryDir[_MAX_PATH + 1];
-        IfFailThrow(GetInternalSystemDirectory(wszRepositoryDir, &lgth));
-
-        wcscat_s(wszRepositoryDir, COUNTOF(wszRepositoryDir), W("repository"));
-
-        size_t buflen = wcslen(wszRepositoryDir) + 1;
-        LPWSTR lpszDir = new WCHAR[buflen];
-        wcscpy_s(lpszDir, buflen, wszRepositoryDir);
-        zo->m_repositoryDir = lpszDir;
-
-        // Move the images by default
-        if (zo->m_repositoryFlags == RepositoryDefault)
-            zo->m_repositoryFlags = MoveFromRepository;
-    }
-#endif //FEATURE_FUSION
 
     if (pOptions->fInstrument)
         zo->m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_BBINSTR);
@@ -686,14 +492,10 @@ void Zapper::Init(ZapperOptions *pOptions, bool fFreeZapperOptions)
     hr = m_pMetaDataDispenser->SetOption(MetaDataCheckDuplicatesFor, &opt);
     _ASSERTE(SUCCEEDED(hr));
 
-#ifdef FEATURE_FUSION
-    hr = InitializeFusion();
-    _ASSERTE(SUCCEEDED(hr));
-#endif
 
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#if !defined(FEATURE_MERGE_JIT_AND_ENGINE)
     m_fDontLoadJit = false;
-#endif // defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#endif // !defined(FEATURE_MERGE_JIT_AND_ENGINE)
 
     m_fForceFullTrust = false;
 }
@@ -719,13 +521,12 @@ void Zapper::LoadAndInitializeJITForNgen(LPCWSTR pwzJitName, OUT HINSTANCE* phJi
 
     HRESULT hr = E_FAIL;
 
-#if defined(FEATURE_CORECLR) || defined(FEATURE_MERGE_JIT_AND_ENGINE)
     // Note: FEATURE_MERGE_JIT_AND_ENGINE is defined for the Desktop crossgen compilation as well.
     //
     PathString CoreClrFolder;
     extern HINSTANCE g_hThisInst;
 
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#if !defined(FEATURE_MERGE_JIT_AND_ENGINE)
     if (m_fDontLoadJit)
     {
         return;
@@ -738,7 +539,7 @@ void Zapper::LoadAndInitializeJITForNgen(LPCWSTR pwzJitName, OUT HINSTANCE* phJi
         hr = S_OK;
     }
     else 
-#endif // defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#endif // !defined(FEATURE_MERGE_JIT_AND_ENGINE)
     if (WszGetModuleFileName(g_hThisInst, CoreClrFolder))
     {
         hr = CopySystemDirectory(CoreClrFolder, CoreClrFolder);
@@ -761,9 +562,6 @@ void Zapper::LoadAndInitializeJITForNgen(LPCWSTR pwzJitName, OUT HINSTANCE* phJi
             hr = S_OK;
         }
     }
-#else
-    hr = g_pCLRRuntime->LoadLibrary(pwzJitName, phJit);
-#endif
 
     if (FAILED(hr))
     {
@@ -771,7 +569,7 @@ void Zapper::LoadAndInitializeJITForNgen(LPCWSTR pwzJitName, OUT HINSTANCE* phJi
         ThrowLastError();
     }
 
-#if (defined(FEATURE_CORECLR) || !defined(SELF_NO_HOST)) && !defined(CROSSGEN_COMPILE)
+#if !defined(CROSSGEN_COMPILE)
     typedef void (__stdcall* pSxsJitStartup) (CoreClrCallbacks const & cccallbacks);
     pSxsJitStartup sxsJitStartupFn = (pSxsJitStartup) GetProcAddress(*phJit, "sxsJitStartup");
     if (sxsJitStartupFn == NULL)
@@ -898,39 +696,11 @@ void Zapper::InitEE(BOOL fForceDebug, BOOL fForceProfile, BOOL fForceInstrument)
 
     CorCompileRuntimeDlls ngenDllId;
 
-#if !defined(FEATURE_CORECLR)    
-    ngenDllId = NGEN_COMPILER_INFO;
-#else // FEATURE_CORECLR
     ngenDllId = CROSSGEN_COMPILER_INFO;
-#endif
 
     LPCWSTR pwzJitName = CorCompileGetRuntimeDllName(ngenDllId);
     LoadAndInitializeJITForNgen(pwzJitName, &m_hJitLib, &m_pJitCompiler);
     
-#if defined(_TARGET_AMD64_) && !defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)
-    // For reasons related to servicing, and RyuJIT rollout on .NET 4.6 and beyond, we only use RyuJIT when the registry
-    // value UseRyuJIT (type DWORD), under key HKLM\SOFTWARE\Microsoft\.NETFramework, is set to 1. Otherwise, we fall back
-    // to JIT64.
-    //
-    // See the document "RyuJIT Compatibility Fallback Specification.docx" for details.
-    //
-    // Also see the code and comments in EEJitManager::LoadJIT().
-
-    if (!UseRyuJit())        // Do we need to fall back to JIT64 for NGEN?
-    {
-        LPCWSTR pwzJitName = MAKEDLLNAME_W(L"compatjit");
-
-        // Note: if the compatjit fails to load, we ignore it, and continue to use the main JIT for
-        // everything. You can imagine a policy where if the user requests the compatjit, and we fail
-        // to load it, that we fail noisily. We don't do that currently.
-        ICorJitCompiler* fallbackICorJitCompiler;
-        LoadAndInitializeJITForNgen(pwzJitName, &m_hJitLegacy, &fallbackICorJitCompiler);
-
-        // Tell the main JIT to fall back to the "fallback" JIT compiler, in case some
-        // obfuscator tries to directly call the main JIT's getJit() function.
-        m_pJitCompiler->setRealJit(fallbackICorJitCompiler);
-    }
-#endif // defined(_TARGET_AMD64_) && !defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)
 #endif // FEATURE_MERGE_JIT_AND_ENGINE
 
 #ifdef ALLOW_SXS_JIT_NGEN
@@ -1057,277 +827,6 @@ void Zapper::CleanupAssembly()
     }
 }
 
-#ifdef FEATURE_FUSION
-HRESULT Zapper::TryEnumerateFusionCache(LPCWSTR name, bool fPrint, bool fDelete)
-{
-    HRESULT hr = S_OK;
-
-    EX_TRY
-    {
-        if (EnumerateFusionCache(name, fPrint, fDelete) == 0)
-            hr = S_FALSE;
-    }
-    EX_CATCH_HRESULT(hr);
-
-    return hr;
-}
-
-#define MAX_ZAP_STRING_SIZE 4
-
-int Zapper::EnumerateFusionCache(
-        LPCWSTR name,
-        bool fPrint, bool fDelete,
-        CORCOMPILE_NGEN_SIGNATURE * pNativeImageSig)
-{
-    _ASSERTE(pNativeImageSig == NULL || (*pNativeImageSig) != INVALID_NGEN_SIGNATURE);
-
-    int count = 0;
-
-    NonVMComHolder<IAssemblyName> pName;
-
-    //
-    // Decide whether the name is a file or assembly name
-    //
-
-    DWORD attributes = -1;
-
-    if (name != NULL)
-        attributes = WszGetFileAttributes(name);
-
-    if (attributes == -1)
-    {
-        IfFailThrow(CreateAssemblyNameObject(&pName, name,
-                                             name == NULL ? 0 :
-                                             CANOF_PARSE_DISPLAY_NAME, NULL));
-    }
-    else if (attributes & FILE_ATTRIBUTE_DIRECTORY)
-    {
-        ClrDirectoryEnumerator de(name);
-
-        while (de.Next())
-        {
-            StackSString fullName;
-            fullName.Set(name, W("\\"), de.GetFileName());
-
-            if (de.GetFileAttributes() & FILE_ATTRIBUTE_DIRECTORY)
-            {
-                count += EnumerateFusionCache(fullName, fPrint, fDelete);
-            }
-            else 
-            if (IsAssembly(fullName))
-            {
-                if (TryEnumerateFusionCache(fullName, fPrint, fDelete) == S_OK)
-                    count++;
-            }
-        }
-    }
-    else
-    {
-        NonVMComHolder<IMetaDataAssemblyImport> pAssemblyImport;
-        IfFailThrow(m_pMetaDataDispenser->OpenScope(name, ofRead,
-                                                    IID_IMetaDataAssemblyImport,
-                                                    (IUnknown**)&pAssemblyImport));
-
-        pName = GetAssemblyFusionName(pAssemblyImport);
-    }
-
-    if (pName != NULL)
-    {
-        pName->SetProperty(ASM_NAME_CUSTOM, NULL, 0);
-
-        NonVMComHolder<IAssemblyEnum> pEnum;
-        HRESULT hr = CreateAssemblyEnum(&pEnum, NULL, pName, ASM_CACHE_ZAP, 0);
-        IfFailThrow(hr);
-
-        pName.Clear();
-
-        if (hr == S_OK)
-        {
-            //
-            // Scope the iteration by the zap set
-            //
-
-            LPCWSTR zapPrefix = m_pOpt->m_zapSet;
-            size_t zapPrefixSize = (zapPrefix != NULL) ? wcslen(zapPrefix) : 0;
-
-            for (;;)
-            {
-                NonVMComHolder<IApplicationContext> pContext;
-                NonVMComHolder<IAssemblyName> pEntryName;
-
-                if (pEnum->GetNextAssembly(&pContext, &pEntryName, 0) != S_OK)
-                    break;
-
-                //
-                // Only consider assemblies which have the proper zap string
-                // prefix.
-                //
-                if (zapPrefix != NULL)
-                {
-                    WCHAR zapString[MAX_ZAP_STRING_SIZE];
-                    DWORD zapStringSize = sizeof(zapString);
-
-                    hr = pEntryName->GetProperty(ASM_NAME_CUSTOM, (void*) zapString, &zapStringSize);
-                    if (hr != S_OK
-                        || wcslen(zapString) < zapPrefixSize
-                        || wcsncmp(zapString, zapPrefix, zapPrefixSize) != 0)
-                    {
-                        continue;
-                    }
-                }
-
-                count++;
-
-                if (pNativeImageSig)
-                {
-                    // If we are looking for a specific native image,
-                    // check that the signatures match.
-
-                    CORCOMPILE_NGEN_SIGNATURE sign;
-                    DWORD cbSign = sizeof(sign);
-
-                    IfFailThrow(pEntryName->GetProperty(ASM_NAME_MVID, &sign, &cbSign));
-                    _ASSERTE(cbSign == sizeof(sign));
-
-                    if (cbSign != sizeof(sign) || *pNativeImageSig != sign)
-                        continue;
-                }
-
-                if (fPrint)
-                {
-                    PrintFusionCacheEntry(LogLevel_Success, pEntryName);
-                }
-
-                if (fDelete)
-                {
-                    DeleteFusionCacheEntry(pEntryName);
-                }
-            }
-        }
-
-    }
-
-    return count;
-}
-
-void Zapper::PrintFusionCacheEntry(CorSvcLogLevel logLevel, IAssemblyName *pName)
-{
-    StackSString ss;
-    FusionBind::GetAssemblyNameDisplayName(pName, ss, 
-        ASM_DISPLAYF_VERSION | ASM_DISPLAYF_CULTURE | ASM_DISPLAYF_PUBLIC_KEY_TOKEN);
-
-    GetSvcLogger()->Printf(logLevel, W("%s"), ss.GetUnicode());
-
-    // Get the custom string
-    WCHAR zapString[MAX_ZAP_STRING_SIZE];
-    DWORD zapStringSize = sizeof(zapString);
-
-    HRESULT hr = pName->GetProperty(ASM_NAME_CUSTOM, (void*) zapString, &zapStringSize);
-    IfFailThrow(hr);
-    IfFailThrow((zapStringSize != 0) ? S_OK : E_FAIL);
-
-    // Get the config mask
-
-    DWORD mask = 0;
-    DWORD maskSize = sizeof(mask);
-
-    hr = pName->GetProperty(ASM_NAME_CONFIG_MASK, (void*) &mask, &maskSize);
-    IfFailThrow(hr);
-
-    // Pretty-print the custom string and the config mask
-
-    if (hr == S_OK)
-    {
-        DWORD maskStringLength;
-        IfFailThrow(GetNativeImageDescription(zapString, mask, NULL, &maskStringLength));
-
-        CQuickWSTR buffer;
-        buffer.ReSizeThrows(maskStringLength * sizeof(WCHAR));
-        IfFailThrow(GetNativeImageDescription(zapString, mask, buffer.Ptr(), &maskStringLength));
-
-        GetSvcLogger()->Printf(logLevel, W("%s"), buffer.Ptr());
-    }
-
-    GetSvcLogger()->Printf(logLevel, W("\n"));
-
-    StackSString s;
-    PrintAssemblyVersionInfo(pName, s);
-
-    GetSvcLogger()->Log(s.GetUnicode(), LogLevel_Info);
-}
-
-void Zapper::DeleteFusionCacheEntry(IAssemblyName *pName)
-{
-    IfFailThrow(UninstallNativeAssembly(pName, GetSvcLogger()->GetSvcLogger()));
-}
-
-void Zapper::DeleteFusionCacheEntry(LPCWSTR assemblyName, CORCOMPILE_NGEN_SIGNATURE *pNativeImageSig)
-{
-    _ASSERTE(assemblyName != NULL && pNativeImageSig != NULL);
-    _ASSERTE(*pNativeImageSig != INVALID_NGEN_SIGNATURE);
-    // assemblyName must be a display name, not a file name.
-    _ASSERTE(WszGetFileAttributes(assemblyName) == INVALID_FILE_ATTRIBUTES);
-
-    NonVMComHolder<IAssemblyName> pEntryName;
-    IfFailThrow(CreateAssemblyNameObject(&pEntryName, assemblyName, CANOF_PARSE_DISPLAY_NAME, NULL));
-
-    // Native Binder requires ASM_NAME_CUSTOM (zapset) not to be NULL while deleting a native image.
-    LPCWSTR zapSet = m_pOpt->m_zapSet != NULL ? m_pOpt->m_zapSet : W("");
-    pEntryName->SetProperty(ASM_NAME_CUSTOM, zapSet, DWORD(sizeof(WCHAR) * (wcslen(zapSet) + 1)));
-
-    pEntryName->SetProperty(ASM_NAME_MVID, pNativeImageSig, sizeof(*pNativeImageSig));
-
-    DeleteFusionCacheEntry(pEntryName);
-}
-
-// @TODO: Use the default flags like CORCOMPILE_CONFIG_DEBUG_DEFAULT
-
-__success(SUCCEEDED(return))
-STDAPI GetNativeImageDescription(__in_z LPCWSTR customString,
-                                 DWORD dwConfigMask,
-                                 __inout_ecount(*pdwLength) LPWSTR pwzString,
-                                 LPDWORD pdwLength)
-{
-    _ASSERTE(pdwLength);
-    //_ASSERTE(pwzString == NULL || (pwzString[(*pdwLength) - 1], true));
-
-    #define ZAP_STRING_DEBUG            W("<debug>")
-    #define ZAP_STRING_PROFILING        W("<profiling>")
-    #define ZAP_STRING_INSTRUMENTED     W("<instrumented>")
-
-    StackSString ssBuff;
-
-    if (customString[0] != W('\0'))
-    {
-        ssBuff.Append(W(" (set "));
-        ssBuff.Append(customString);
-        ssBuff.Append(W(')'));
-    }
-
-    if (dwConfigMask & CORCOMPILE_CONFIG_DEBUG)
-        ssBuff.Append(W(" ") ZAP_STRING_DEBUG);
-
-    if (dwConfigMask & CORCOMPILE_CONFIG_PROFILING)
-        ssBuff.Append(W(" ") ZAP_STRING_PROFILING);
-
-    if (dwConfigMask & CORCOMPILE_CONFIG_INSTRUMENTATION)
-        ssBuff.Append(W(" ") ZAP_STRING_INSTRUMENTED);
-
-    DWORD length = (DWORD) ssBuff.GetCount() + 1; // +1 for the null terminating character
-    DWORD inputLength = *pdwLength;
-
-    *pdwLength = length;
-    if (pwzString)
-    {
-        wcsncpy_s(pwzString, inputLength, ssBuff.GetUnicode(), _TRUNCATE);
-
-        if (length > inputLength)
-            return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
-    }
-
-    return S_OK;
-}
-#endif // FEATURE_FUSION
 
 //**********************************************************************
 // Copy of vm\i386\cgenCpu.h
@@ -1358,529 +857,6 @@ BOOL Runtime_Test_For_SSE2();
 
 #endif
 
-#ifdef FEATURE_FUSION
-void Zapper::PrintDependencies(
-        IMetaDataAssemblyImport * pAssemblyImport,
-        CORCOMPILE_DEPENDENCY * pDependencies,
-        COUNT_T cDependencies,
-        SString &s)
-{
-    if (cDependencies == 0)
-    {
-        s.AppendPrintf("\tNo dependencies\n");
-        return;
-    }
-
-    s.AppendASCII("\tDependencies:\n");
-
-    CORCOMPILE_DEPENDENCY *pDepsEnd = pDependencies + cDependencies;
-    for(CORCOMPILE_DEPENDENCY *pDeps = pDependencies; pDeps < pDepsEnd; pDeps++)
-    {
-        mdAssemblyRef assem = pDeps->dwAssemblyDef;
-        if (assem == mdAssemblyRefNil)
-            assem = pDeps->dwAssemblyRef;
-
-        NonVMComHolder<IAssemblyName> pNameHolder =
-                GetAssemblyRefFusionName(pAssemblyImport, assem);
-
-        StackSString ss;
-        FusionBind::GetAssemblyNameDisplayName(pNameHolder, ss, ASM_DISPLAYF_FULL);
-
-        s.AppendPrintf(W("\t\t%s:\n"), ss.GetUnicode());
-
-        if (pDeps->dwAssemblyDef == mdAssemblyRefNil)
-        {
-            s.AppendASCII("\t\t\t** Missing dependency assembly **\n");
-            continue;
-        }
-
-        //
-        // Dependency MVID/HASH
-        //
-
-        WCHAR szGuid[64];
-        GuidToLPWSTR(pDeps->signAssemblyDef.mvid, szGuid, NumItems(szGuid));
-        s.AppendPrintf(W("\t\t\tGuid:%s\n"), szGuid);
-
-        if (pDeps->dwAssemblyRef != pDeps->dwAssemblyDef)
-        {
-            // If there is a redirect, display the original dependency version
-
-            NonVMComHolder<IAssemblyName> pOrigName =
-              GetAssemblyRefFusionName(pAssemblyImport, pDeps->dwAssemblyRef);
-
-            StackSString ss;
-            FusionBind::GetAssemblyNameDisplayName(pOrigName, ss, ASM_DISPLAYF_VERSION);
-
-            s.AppendPrintf(W("\t\t\tOriginal Ref: %s\n"), ss.GetUnicode());
-        }
-
-        if (pDeps->signNativeImage != INVALID_NGEN_SIGNATURE)
-        {
-            GuidToLPWSTR(pDeps->signNativeImage, szGuid, NumItems(szGuid));
-            s.AppendPrintf(W("\t\t\tHardbound Guid:%s\n"), szGuid);
-        }
-    }
-
-    s.AppendASCII("\n");
-}
-
-
-BOOL Zapper::VerifyDependencies(
-        IMDInternalImport * pAssemblyImport,
-        CORCOMPILE_DEPENDENCY * pDependencies,
-        COUNT_T cDependencies)
-{
-    CORCOMPILE_DEPENDENCY *pDepsEnd = pDependencies + cDependencies;
-    for(CORCOMPILE_DEPENDENCY *pDeps = pDependencies; pDeps < pDepsEnd; pDeps++)
-    {
-        mdAssemblyRef assem = pDeps->dwAssemblyDef;
-
-        // TODO: Better support for images with unresolved dependencies?
-        if (assem == mdAssemblyRefNil)
-            continue;
-
-        CORINFO_ASSEMBLY_HANDLE hAssemblyRef;
-        if (m_pEECompileInfo->LoadAssemblyRef(pAssemblyImport, assem, &hAssemblyRef) != S_OK)
-            return FALSE;
-
-        CORCOMPILE_VERSION_INFO sourceVersionInfo;
-        IfFailThrow(m_pEECompileInfo->GetAssemblyVersionInfo(hAssemblyRef,
-                                                            &sourceVersionInfo));
-
-        // check the soft bound dependency
-        CORCOMPILE_ASSEMBLY_SIGNATURE * pSign1 = &pDeps->signAssemblyDef;
-        CORCOMPILE_ASSEMBLY_SIGNATURE * pSign2 = &sourceVersionInfo.sourceAssembly;
-
-        if (   (pSign1->mvid != pSign2->mvid)
-            || (pSign1->timeStamp != pSign2->timeStamp)
-            || (pSign1->ilImageSize != pSign2->ilImageSize) )
-        {
-            return FALSE;
-        }
-
-        if (pDeps->signNativeImage != INVALID_NGEN_SIGNATURE)
-        {
-            // check the hardbound dependency
-            CORCOMPILE_NGEN_SIGNATURE nativeImageSig;
-
-            if (!CheckAssemblyUpToDate(hAssemblyRef, &nativeImageSig))
-                return FALSE;
-
-            if (pDeps->signNativeImage != nativeImageSig)
-                return FALSE;
-        }
-    }
-
-    return TRUE;
-}
-
-void Zapper::PrintAssemblyVersionInfo(IAssemblyName *pName, SString &s)
-{
-    //
-    // Bind zap assembly to a path
-    //
-
-    WCHAR szGuid[64];
-    WCHAR path[MAX_LONGPATH];
-    DWORD cPath = MAX_LONGPATH;
-
-    IfFailThrow(QueryNativeAssemblyInfo(pName, path, &cPath));
-
-    // The LoadLibrary call fails occasionally in the lab due to sharing violation.  Retry when needed.
-    const int SHARING_VIOLATION_RETRY_TIMES = 10;
-    const DWORD SHARING_VIOLATION_RETRY_WAITING_TIME = 100;
-    HModuleHolder hMod;
-    DWORD err;
-    for (int i = 0; i < SHARING_VIOLATION_RETRY_TIMES; i++)
-    {
-        hMod = ::WszLoadLibrary(path);
-        if (! hMod.IsNull())
-            break;
-        // Save last error before ClrSleepEx overwrites it.
-        err = GetLastError();
-        ClrSleepEx(SHARING_VIOLATION_RETRY_WAITING_TIME, FALSE);
-    }
-    if (hMod.IsNull())
-        ThrowWin32(err);
-
-    PEDecoder pedecoder(hMod);
-
-    CORCOMPILE_VERSION_INFO *pVersionInfo = pedecoder.GetNativeVersionInfo();
-
-    COUNT_T cMeta;
-    const void *pMeta = pedecoder.GetNativeManifestMetadata(&cMeta);
-
-    NonVMComHolder<IMetaDataAssemblyImport> pAssemblyImport;
-    IfFailThrow(m_pMetaDataDispenser->OpenScopeOnMemory(pMeta, cMeta, ofRead,
-                                    IID_IMetaDataAssemblyImport,
-                                    (IUnknown**)&pAssemblyImport));
-
-    NonVMComHolder<IMetaDataImport> pImport;
-    IfFailThrow(pAssemblyImport->QueryInterface(IID_IMetaDataImport,
-                                                (void**)&pImport));
-
-    //
-    // Source MVID
-    //
-
-    GuidToLPWSTR(pVersionInfo->sourceAssembly.mvid, szGuid, NumItems(szGuid));
-    s.AppendPrintf(W("\tSource MVID:\t%s\n"), szGuid);
-
-    //
-    // Signature of generated ngen image
-    //
-
-    GuidToLPWSTR(pVersionInfo->signature, szGuid, NumItems(szGuid));
-    s.AppendPrintf(W("\tNGen GUID sign:\t%s\n"), szGuid);
-
-
-    s.AppendASCII("\tOS:\t\t");
-    switch (pVersionInfo->wOSPlatformID)
-    {
-    case VER_PLATFORM_WIN32_NT:
-        s.AppendASCII("WinNT");
-        break;
-    default:
-        s.AppendPrintf("<unknown> (%d)", pVersionInfo->wOSPlatformID);
-        break;
-    }
-    s.AppendASCII("\n");
-
-    //
-    // Processor
-    //
-
-    s.AppendASCII("\tProcessor:\t");
-
-    CORINFO_CPU cpuInfo = pVersionInfo->cpuInfo;
-
-    switch (pVersionInfo->wMachine)
-    {
-    case IMAGE_FILE_MACHINE_I386:
-    {
-        s.AppendASCII("x86");
-        DWORD cpuType = cpuInfo.dwCPUType;
-#ifdef _TARGET_X86_
-
-        //
-        // Specific processor ID
-        //
-
-        switch (CPU_X86_FAMILY(cpuType))
-        {
-        case CPU_X86_486:
-            s.AppendASCII("(486)");
-            break;
-
-        case CPU_X86_PENTIUM:
-            s.AppendASCII("(Pentium)");
-            break;
-
-        case CPU_X86_PENTIUM_PRO:
-            if(CPU_X86_MODEL(cpuType) == CPU_X86_MODEL_PENTIUM_PRO_BANIAS)
-            {
-                s.AppendASCII("(Pentium M)");
-            }
-            else
-            {
-                s.AppendASCII("(PentiumPro)");
-            }
-            break;
-
-        case CPU_X86_PENTIUM_4:
-            s.AppendASCII("(Pentium 4)");
-            break;
-
-        default:
-            s.AppendPrintf("(Family %d, Model %d (%03x))",
-                   CPU_X86_FAMILY(cpuType), CPU_X86_MODEL(cpuType), cpuType);
-            break;
-        }
-
-        s.AppendPrintf(" (features: %08x)", cpuInfo.dwFeatures);
-
-        break;
-
-#endif // _TARGET_X86_
-    }
-
-    case IMAGE_FILE_MACHINE_IA64:
-        s.AppendASCII("ia64");
-        break;
-
-    case IMAGE_FILE_MACHINE_AMD64:
-        s.AppendASCII("amd64");
-        break;
-
-    case IMAGE_FILE_MACHINE_ARMNT:
-        s.AppendASCII("arm");
-        break;
-    }
-    s.AppendASCII("\n");
-
-    //
-    // EE version
-    //
-
-    s.AppendPrintf("\tRuntime:\t%d.%d.%.d.%d\n",
-           pVersionInfo->wVersionMajor, pVersionInfo->wVersionMinor,
-           pVersionInfo->wVersionBuildNumber, pVersionInfo->wVersionPrivateBuildNumber);
-
-    s.AppendPrintf("\tclr.dll:\tTimeStamp=%08X, VirtualSize=%08X\n",
-           pVersionInfo->runtimeDllInfo[CLR_INFO].timeStamp,
-           pVersionInfo->runtimeDllInfo[CLR_INFO].virtualSize);
-
-    //
-    // Flags
-    //
-
-    s.AppendASCII("\tFlags:\t\t");
-    if (pVersionInfo->wBuild == CORCOMPILE_BUILD_CHECKED)
-    {
-        s.AppendASCII("<checked> ");
-    }
-
-    if (pVersionInfo->wCodegenFlags & CORCOMPILE_CODEGEN_PROFILING)
-    {
-        s.AppendASCII("<profiling> ");
-    }
-    else if ((pVersionInfo->wCodegenFlags & CORCOMPILE_CODEGEN_DEBUGGING))
-    {
-        s.AppendASCII("<debug> ");
-    }
-
-    if (pVersionInfo->wCodegenFlags & CORCOMPILE_CODEGEN_PROF_INSTRUMENTING)
-    {
-        s.AppendASCII("<instrumenting> ");
-    }
-    s.AppendASCII("\n");
-
-    //
-    // Config
-    //
-
-    s.AppendASCII("\tScenarios:\t\t");
-
-    if (pVersionInfo->wConfigFlags & CORCOMPILE_CONFIG_DEBUG_NONE)
-    {
-        s.AppendASCII("<no debug info> ");
-    }
-    if (pVersionInfo->wConfigFlags & CORCOMPILE_CONFIG_DEBUG)
-    {
-        s.AppendASCII("<debugger> ");
-    }
-    if (pVersionInfo->wConfigFlags & CORCOMPILE_CONFIG_DEBUG_DEFAULT)
-    {
-        s.AppendASCII("<no debugger> ");
-    }
-
-    if (pVersionInfo->wConfigFlags & CORCOMPILE_CONFIG_PROFILING_NONE)
-    {
-        s.AppendASCII("<no profiler> ");
-    }
-    if (pVersionInfo->wConfigFlags & CORCOMPILE_CONFIG_PROFILING)
-    {
-        s.AppendASCII("<instrumenting profiler> ");
-    }
-
-    if (pVersionInfo->wConfigFlags & CORCOMPILE_CONFIG_INSTRUMENTATION_NONE)
-    {
-        s.AppendASCII("<no instrumentation> ");
-    }
-
-    if (pVersionInfo->wConfigFlags & CORCOMPILE_CONFIG_INSTRUMENTATION)
-    {
-        s.AppendASCII("<block instrumentation> ");
-    }
-
-    s.AppendASCII("\n");
-
-    //
-    // Native image file name
-    //
-
-    s.AppendPrintf(W("\tFile:\t\t%s\n"), path);
-
-    //
-    // Dependencies
-    //
-
-    COUNT_T cDependencies;
-    CORCOMPILE_DEPENDENCY *pDependencies = pedecoder.GetNativeDependencies(&cDependencies);
-
-    PrintDependencies(pAssemblyImport, pDependencies, cDependencies, s);
-}
-
-IAssemblyName *Zapper::GetAssemblyFusionName(IMetaDataAssemblyImport *pImport)
-{
-    IAssemblyName *pName;
-
-    mdAssembly a;
-    IfFailThrow(pImport->GetAssemblyFromScope(&a));
-
-    ASSEMBLYMETADATA md = {0};
-    LPWSTR szName;
-    ULONG cbName = 0;
-    const void *pbPublicKeyToken;
-    ULONG cbPublicKeyToken;
-    DWORD dwFlags;
-
-    IfFailThrow(pImport->GetAssemblyProps(a,
-                                          NULL, NULL, NULL,
-                                          NULL, 0, &cbName,
-                                          &md,
-                                          NULL));
-
-    szName = (LPWSTR) _alloca(cbName * sizeof(WCHAR));
-    md.szLocale = (LPWSTR) _alloca(md.cbLocale * sizeof(WCHAR));
-    md.rProcessor = (DWORD *) _alloca(md.ulProcessor * sizeof(DWORD));
-    md.rOS = (OSINFO *) _alloca(md.ulOS * sizeof(OSINFO));
-
-    IfFailThrow(pImport->GetAssemblyProps(a,
-                                          &pbPublicKeyToken, &cbPublicKeyToken, NULL,
-                                          szName, cbName, &cbName,
-                                          &md,
-                                          &dwFlags));
-
-    IfFailThrow(CreateAssemblyNameObject(&pName, szName, 0, NULL));
-
-    if (md.usMajorVersion != -1)
-        IfFailThrow(pName->SetProperty(ASM_NAME_MAJOR_VERSION,
-                                       &md.usMajorVersion,
-                                       sizeof(USHORT)));
-    if (md.usMinorVersion != -1)
-        IfFailThrow(pName->SetProperty(ASM_NAME_MINOR_VERSION,
-                                       &md.usMinorVersion,
-                                       sizeof(USHORT)));
-    if (md.usBuildNumber != -1)
-        IfFailThrow(pName->SetProperty(ASM_NAME_BUILD_NUMBER,
-                                       &md.usBuildNumber,
-                                       sizeof(USHORT)));
-    if (md.usRevisionNumber != -1)
-        IfFailThrow(pName->SetProperty(ASM_NAME_REVISION_NUMBER,
-                                       &md.usRevisionNumber,
-                                       sizeof(USHORT)));
-    if (md.ulProcessor > 0)
-        IfFailThrow(pName->SetProperty(ASM_NAME_PROCESSOR_ID_ARRAY,
-                                       &md.rProcessor,
-                                       md.ulProcessor*sizeof(DWORD)));
-    if (md.ulOS > 0)
-        IfFailThrow(pName->SetProperty(ASM_NAME_OSINFO_ARRAY,
-                                       &md.rOS,
-                                       md.ulOS*sizeof(OSINFO)));
-    if (md.cbLocale > 0)
-        IfFailThrow(pName->SetProperty(ASM_NAME_CULTURE,
-                                       md.szLocale,
-                                       md.cbLocale*sizeof(WCHAR)));
-
-    if (cbPublicKeyToken > 0)
-    {
-        if (!StrongNameTokenFromPublicKey((BYTE*)pbPublicKeyToken, cbPublicKeyToken,
-                                          (BYTE**)&pbPublicKeyToken, &cbPublicKeyToken))
-            IfFailThrow(StrongNameErrorInfo());
-
-        IfFailThrow(pName->SetProperty(ASM_NAME_PUBLIC_KEY_TOKEN,
-                                       (void*)pbPublicKeyToken,
-                                       cbPublicKeyToken));
-
-        StrongNameFreeBuffer((BYTE*)pbPublicKeyToken);
-    }
-
-    return pName;
-}
-
-IAssemblyName *Zapper::GetAssemblyRefFusionName(IMetaDataAssemblyImport *pImport,
-                                                mdAssemblyRef ar)
-{
-    IAssemblyName *pName;
-
-    ASSEMBLYMETADATA md = {0};
-    LPWSTR szName;
-    ULONG cbName = 0;
-    const void *pbPublicKeyOrToken;
-    ULONG cbPublicKeyOrToken;
-    DWORD dwFlags;
-
-    IfFailThrow(pImport->GetAssemblyRefProps(ar,
-                                             NULL, NULL,
-                                             NULL, 0, &cbName,
-                                             &md,
-                                             NULL, NULL,
-                                             NULL));
-
-    szName = (LPWSTR) _alloca(cbName * sizeof(WCHAR));
-    md.szLocale = (LPWSTR) _alloca(md.cbLocale * sizeof(WCHAR));
-    md.rProcessor = (DWORD *) _alloca(md.ulProcessor * sizeof(DWORD));
-    md.rOS = (OSINFO *) _alloca(md.ulOS * sizeof(OSINFO));
-
-    IfFailThrow(pImport->GetAssemblyRefProps(ar,
-                                             &pbPublicKeyOrToken, &cbPublicKeyOrToken,
-                                             szName, cbName, &cbName,
-                                             &md,
-                                             NULL, NULL,
-                                             &dwFlags));
-
-    IfFailThrow(CreateAssemblyNameObject(&pName, szName, 0, NULL));
-
-    if (md.usMajorVersion != -1)
-        IfFailThrow(pName->SetProperty(ASM_NAME_MAJOR_VERSION,
-                                       &md.usMajorVersion,
-                                       sizeof(USHORT)));
-    if (md.usMinorVersion != -1)
-        IfFailThrow(pName->SetProperty(ASM_NAME_MINOR_VERSION,
-                                       &md.usMinorVersion,
-                                       sizeof(USHORT)));
-    if (md.usBuildNumber != -1)
-        IfFailThrow(pName->SetProperty(ASM_NAME_BUILD_NUMBER,
-                                       &md.usBuildNumber,
-                                       sizeof(USHORT)));
-    if (md.usRevisionNumber != -1)
-        IfFailThrow(pName->SetProperty(ASM_NAME_REVISION_NUMBER,
-                                       &md.usRevisionNumber,
-                                       sizeof(USHORT)));
-    if (md.ulProcessor > 0)
-        IfFailThrow(pName->SetProperty(ASM_NAME_PROCESSOR_ID_ARRAY,
-                                       &md.rProcessor,
-                                       md.ulProcessor*sizeof(DWORD)));
-    if (md.ulOS > 0)
-        IfFailThrow(pName->SetProperty(ASM_NAME_OSINFO_ARRAY,
-                                       &md.rOS,
-                                       md.ulOS*sizeof(OSINFO)));
-    if (md.cbLocale > 0)
-        IfFailThrow(pName->SetProperty(ASM_NAME_CULTURE,
-                                       md.szLocale,
-                                       md.cbLocale*sizeof(WCHAR)));
-
-    if (cbPublicKeyOrToken > 0)
-    {
-        if (dwFlags & afPublicKey)
-            IfFailThrow(pName->SetProperty(ASM_NAME_PUBLIC_KEY,
-                                           (void*)pbPublicKeyOrToken,
-                                           cbPublicKeyOrToken));
-        else
-            IfFailThrow(pName->SetProperty(ASM_NAME_PUBLIC_KEY_TOKEN,
-                                           (void*)pbPublicKeyOrToken,
-                                           cbPublicKeyOrToken));
-    }
-    else
-    {
-        IfFailThrow(pName->SetProperty(ASM_NAME_NULL_PUBLIC_KEY_TOKEN,
-                                       NULL, 0));
-    }
-
-    // See if the assemblyref is retargetable (ie, for a generic assembly).
-    if (IsAfRetargetable(dwFlags))
-    {
-        BOOL bTrue = TRUE;
-        IfFailThrow(pName->SetProperty(ASM_NAME_RETARGET,
-                                       &bTrue,
-                                       sizeof(bTrue)));
-    }
-
-    return pName;
-}
-#endif //FEATURE_FUSION
 
 BOOL Zapper::IsAssembly(LPCWSTR path)
 {
@@ -2029,21 +1005,11 @@ void Zapper::CreateDependenciesLookupDomainInCurrentDomain()
     SetContextInfo();
 }
 
-#if defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)
-void ZapperSetPlatformAssembliesPaths(SString &platformAssembliesPaths);
-#endif
 
-#ifdef FEATURE_CORECLR
 void ZapperSetBindingPaths(ICorCompilationDomain *pDomain, SString &trustedPlatformAssemblies, SString &platformResourceRoots, SString &appPaths, SString &appNiPaths);
-#endif
 
 void Zapper::CreateCompilationDomain()
 {
-#if defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)
-    // Platform assemblies paths have to be set before appdomain is setup so that
-    // mscorlib.dll can be loaded from them.
-    ZapperSetPlatformAssembliesPaths(m_platformAssembliesPaths);
-#endif
 
     BOOL fForceDebug = FALSE;
     if (!m_pOpt->m_autodebug)
@@ -2069,7 +1035,6 @@ void Zapper::CreateCompilationDomain()
     IfFailThrow(m_pDomain->SetPlatformWinmdPaths(m_platformWinmdPaths));
 #endif
 
-#ifdef FEATURE_CORECLR
     // we support only TPA binding on CoreCLR
 
     if (!m_trustedPlatformAssemblies.IsEmpty())
@@ -2078,7 +1043,6 @@ void Zapper::CreateCompilationDomain()
         // Add the trusted paths and apppath to the binding list
         ZapperSetBindingPaths(m_pDomain, m_trustedPlatformAssemblies, m_platformResourceRoots, m_appPaths, m_appNiPaths);
     }
-#endif
 }
 
 void Zapper::CreateDependenciesLookupDomain()
@@ -2156,64 +1120,6 @@ void Zapper::CreatePdbInCurrentDomain(BSTR pAssemblyPathOrName, BSTR pNativeImag
 
         m_pEECompileInfo->SetIsGeneratingNgenPDB(TRUE);
 
-#ifdef FEATURE_FUSION
-        ReleaseHolder<IAssemblyName> pAssemblyName(NULL);	
-        HRESULT hr;
-
-        if (pAssemblyPathOrName == NULL)
-        {
-            // No root was found, so we don't have an IL assembly path yet. Get IAssemblyName
-            // from the aux file next to pNativeImagePath, and load from that IAssemblyName
-            IfFailThrow(GetAssemblyNameFromNIPath(pNativeImagePath, &pAssemblyName));
-            IfFailThrow(m_pEECompileInfo->LoadAssemblyByIAssemblyName(pAssemblyName, &hAssembly));
-        }
-        else
-        {
-            DWORD attributes = WszGetFileAttributes(pAssemblyPathOrName);
-            if (attributes == INVALID_FILE_ATTRIBUTES || 
-                ((attributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY))
-            {
-                // pAssemblyPathOrName doesn't map to a valid file, so assume it's an
-                // assembly name that we can parse and generate an IAssemblyName from, and
-                // then load from the IAssemblyName
-
-                IfFailThrow(m_pEECompileInfo->LoadAssemblyByName(pAssemblyPathOrName, &hAssembly));
-
-            }
-            else
-            {
-                // pAssemblyPathOrName DOES map to a valid file, so load it directly.
-                IfFailThrow(m_pEECompileInfo->LoadAssemblyByPath(pAssemblyPathOrName, 
-                    // fExplicitBindToNativeImage: On the phone, a path to the NI is specified
-                    // explicitly (even with .ni. in the name). All other callers specify a path to
-                    // the IL, and the NI is inferred, so this is normally FALSE in those other
-                    // cases.
-                    FALSE,
-                    &hAssembly));
-            }
-        }
-
-        // Now is a good time to make sure pNativeImagePath is the same native image
-        // fusion loaded
-        {
-            WCHAR wzZapImagePath[MAX_LONGPATH] = {0};
-            DWORD dwZapImagePathLength = MAX_LONGPATH;
-
-            hr = E_FAIL;
-            if (m_pEECompileInfo->CheckAssemblyZap(hAssembly, wzZapImagePath, &dwZapImagePathLength))
-            {
-                if (_wcsicmp(wzZapImagePath, pNativeImagePath) != 0)
-                {
-                    GetSvcLogger()->Printf(
-                        W("Unable to load '%s'.  Please ensure that it is a native image and is up to date.  Perhaps you meant to specify this native image instead: '%s'\n"),
-                        pNativeImagePath,
-                        wzZapImagePath);
-
-                    ThrowHR(E_FAIL);
-                }
-            }
-        }
-#else // FEATURE_FUSION
         IfFailThrow(m_pEECompileInfo->LoadAssemblyByPath(
             pAssemblyPathOrName, 
 
@@ -2224,7 +1130,6 @@ void Zapper::CreatePdbInCurrentDomain(BSTR pAssemblyPathOrName, BSTR pNativeImag
             TRUE, 
 
             &hAssembly));
-#endif // FEATURE_FUSION
 
 
         // Ensure all modules belonging to this assembly get loaded.  The CreatePdb() call
@@ -2249,12 +1154,12 @@ void Zapper::CreatePdbInCurrentDomain(BSTR pAssemblyPathOrName, BSTR pNativeImag
         }
 
         LPCWSTR pDiasymreaderPath = nullptr;
-#if defined(FEATURE_CORECLR) && !defined(NO_NGENPDB)
+#if !defined(NO_NGENPDB)
         if (m_DiasymreaderPath.GetCount() > 0)
         {
             pDiasymreaderPath = m_DiasymreaderPath.GetUnicode();
         }
-#endif // defined(FEATURE_CORECLR) && !defined(NO_NGENPDB)
+#endif //!defined(NO_NGENPDB)
 
         IfFailThrow(::CreatePdb(hAssembly, pNativeImagePath, pPdbPath, pdbLines, pManagedPdbSearchPath, pDiasymreaderPath));
     }
@@ -2272,302 +1177,8 @@ void Zapper::CreatePdbInCurrentDomain(BSTR pAssemblyPathOrName, BSTR pNativeImag
 
 void Zapper::ComputeDependencies(LPCWSTR pAssemblyName, CORCOMPILE_NGEN_SIGNATURE * pNativeImageSig)
 {
-#ifdef FEATURE_FUSION
-    class Callback : public DomainCallback
-    {
-    public:
-        Callback(Zapper *pZapper, LPCWSTR pAssemblyName, CORCOMPILE_NGEN_SIGNATURE * pNativeImageSig)
-        {
-            this->pZapper         = pZapper;
-            this->pAssemblyName   = pAssemblyName;
-            this->pNativeImageSig = pNativeImageSig;
-        }
-
-        virtual void doCallback()
-        {
-            pZapper->ComputeDependenciesInCurrentDomain(pAssemblyName, pNativeImageSig);
-        }
-
-        Zapper* pZapper;
-        LPCWSTR pAssemblyName;
-        CORCOMPILE_NGEN_SIGNATURE * pNativeImageSig;
-    };
-
-    _ASSERTE(m_pDomain);
-    Callback callback(this, pAssemblyName, pNativeImageSig);
-    InvokeDomainCallback(&callback);
-#endif // FEATURE_FUSION
-}
-
-#ifdef FEATURE_FUSION
-
-void Zapper::ComputeDependenciesInCurrentDomain(LPCWSTR pAssemblyString, CORCOMPILE_NGEN_SIGNATURE * pNativeImageSig)
-{
-    //
-    // Load the assembly.
-    //
-    // "string" may be a path or assembly display name.
-    // To decide, we see if it is the name of a valid file.
-    //
-
-    CORINFO_ASSEMBLY_HANDLE hAssembly;
-    HRESULT                 hr;
-
-    DWORD attributes = WszGetFileAttributes(pAssemblyString);
-    if (attributes == INVALID_FILE_ATTRIBUTES || ((attributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY))
-    {
-        IfFailThrow(m_pEECompileInfo->LoadAssemblyByName(pAssemblyString,
-                                                         &hAssembly));
-    }
-    else
-    {
-#if defined(FEATURE_APPX) && !defined(FEATURE_CORECLR)
-        if (m_pOpt->m_fAutoNGen)
-        {
-            // Make sure we're not been spoofed into loading an assembly that might be unsafe to load.
-            // Loading by path so we better be AppX or a WinMD
-            StackSString s(pAssemblyString);
-            SString literalWinMD(SString::Literal, W(".winmd"));
-            BOOL isWinMD = (s.GetCount() > 6) && s.MatchCaseInsensitive(s.End() - 6, literalWinMD);
-            if (!AppX::IsAppXProcess() && !isWinMD)
-            {
-                Error(W("Cannot load assembly %s for automatic NGen.\n"), pAssemblyString);
-                ThrowHR(E_FAIL);
-            }
-
-            // Is AppX NGen disabled?
-            if ((AssemblyUsageLogManager::GetUsageLogFlags() & AssemblyUsageLogManager::ASSEMBLY_USAGE_LOG_FLAGS_APPLOCALNGENDISABLED) != 0)
-            {
-                memset(pNativeImageSig, 0, sizeof(*pNativeImageSig));   // Fake NI signature to disable NGen.
-                Warning(W("NGen disabled for this application.\n"));
-                return;
-            }
-        }
-#endif
-
-        hr = m_pEECompileInfo->LoadAssemblyByPath(pAssemblyString,
-                                                  FALSE,  // fExplicitBindToNativeImage
-                                                  &hAssembly);
-        if (hr == CLR_E_BIND_TYPE_NOT_FOUND)
-        {   // This means we are ngen'ing WinMD file which does not have any public WinRT type - therefore cannot be ever used
-            // Note: It's comming from call to code:GetFirstWinRTTypeDef
-            
-            // Let's not create the ngen image
-            if (pNativeImageSig != NULL)
-            {
-                memset(pNativeImageSig, 0, sizeof(*pNativeImageSig));   // Fake NI signature to disable NGen.
-            }
-            Warning(W("NGen is not supported for empty WinMD files.\n"));
-            return;
-        }
-        IfFailThrow(hr);
-    }
-
-#ifndef FEATURE_CORECLR
-    if (m_pOpt->m_fAutoNGen && !m_pEECompileInfo->SupportsAutoNGen(hAssembly))
-    {
-        Error(W("Assembly %s does not support automatic NGen.\n"), pAssemblyString);
-        ThrowHR(E_FAIL);
-    }
-#endif // FEATURE_CORECLR
-
-    //
-    // Check if we have a native image already, and if so get its GUID
-    //
-
-    WCHAR zapManifestPath[MAX_LONGPATH];
-    DWORD cZapManifestPath = MAX_LONGPATH;
-    if (pNativeImageSig &&
-        m_pEECompileInfo->CheckAssemblyZap(hAssembly, zapManifestPath, &cZapManifestPath))
-    {
-        NonVMComHolder<INativeImageInstallInfo> pNIInstallInfo;
-
-        IfFailThrow(GetAssemblyMDInternalImport(
-            zapManifestPath,
-            IID_INativeImageInstallInfo,
-            (IUnknown **)&pNIInstallInfo));
-
-        IfFailThrow(pNIInstallInfo->GetSignature(pNativeImageSig));
-    }
-
-    //
-    // Set the display name for the assembly
-    //
-
-    StackSString ss;
-    GetAssemblyName(m_pEECompileInfo, hAssembly, ss, ICorCompileInfo::GANF_Default);
-
-    m_assemblyDependencies.SetDisplayName(ss.GetUnicode());
-
-    ComputeAssemblyDependencies(hAssembly);
-}
-
-void Zapper::ComputeAssemblyDependencies(CORINFO_ASSEMBLY_HANDLE hAssembly)
-{
-    HRESULT hr = S_OK;
-    NonVMComHolder<IMDInternalImport> pAssemblyImport = m_pEECompileInfo->GetAssemblyMetaDataImport(hAssembly);
-
-    EX_TRY
-    {
-        //
-        // Enumerate the dependencies
-        //
-
-        HENUMInternalHolder hEnum(pAssemblyImport);
-        hEnum.EnumAllInit(mdtAssemblyRef);
-
-        // Need to reinitialize the dependencies list, since we could have been called for other assemblies
-        // belonging to the same root.  Zapper::ComputeAssemblyDependencies is first called for the root
-        // assembly, then called for each hard dependencies, and called for each soft dependencies unless
-        // /nodependencies switch is used.
-        m_assemblyDependencies.Reinitialize();
-
-        if (!CLRConfig::GetConfigValue(CLRConfig::INTERNAL_NgenAllowMscorlibSoftbind))
-        {
-            // Force all assemblies (other than mscorlib itself) to hardbind to mscorlib.
-            // This ensures that mscorlib is NGen'ed before all other assemblies.
-            CORINFO_ASSEMBLY_HANDLE hAssemblyMscorlib = m_pEECompileInfo->GetModuleAssembly(m_pEECompileInfo->GetLoaderModuleForMscorlib());
-            if (hAssembly != hAssemblyMscorlib)
-            {
-                StackSString ss;
-                GetAssemblyName(m_pEECompileInfo, hAssemblyMscorlib, ss, ICorCompileInfo::GANF_Default);
-    
-                m_assemblyDependencies.Append(ss.GetUnicode(), LoadAlways, NGenDefault);
-            }
-        }
-
-        mdAssembly token;
-        mdMethodDef md;
-        while (pAssemblyImport->EnumNext(&hEnum, &token))
-        {
-            CORINFO_ASSEMBLY_HANDLE hAssemblyRef;
-            HRESULT hrLoad = m_pEECompileInfo->LoadAssemblyRef(pAssemblyImport, token, &hAssemblyRef);
-            if (FAILED(hrLoad))
-            {
-                // Failed to load a dependency.  Print a warning and move to the next dependency.
-
-                LPCSTR pszName;
-                IfFailThrow(pAssemblyImport->GetAssemblyRefProps(token, NULL, NULL,
-                                                         &pszName, NULL,
-                                                         NULL, NULL, NULL));
-
-                StackSString sName(SString::Utf8, pszName);
-
-                StackSString hrMsg;
-                GetHRMsg(hrLoad, hrMsg);
-
-                Warning(W("Failed to load dependency %s of assembly %s because of the following error : %s\n"),
-                        sName.GetUnicode(),
-                        m_assemblyDependencies.GetDisplayName(),
-                        hrMsg.GetUnicode());
-                continue;
-            }
-            else if (hrLoad == S_OK)
-            {
-                _ASSERTE(hAssemblyRef != NULL);
-
-                StackSString ss;
-                GetAssemblyName(m_pEECompileInfo, hAssemblyRef, ss, ICorCompileInfo::GANF_Default);
-
-                LoadHintEnum loadHint = LoadDefault;
-                IfFailThrow(m_pEECompileInfo->GetLoadHint(hAssembly, hAssemblyRef, &loadHint));
-
-                NGenHintEnum ngenHint = NGenDefault;
-                // Not supported
-                //IfFailThrow(m_pEECompileInfo->GetNGenHint(hAssemblyRef, &ngenHint));
-                m_assemblyDependencies.Append(ss.GetUnicode(), loadHint, ngenHint);
-            }
-        }
-
-#ifdef FEATURE_COMINTEROP
-        HENUMInternalHolder hTypeRefEnum(pAssemblyImport);
-        hTypeRefEnum.EnumAllInit(mdtTypeRef);
-
-        mdTypeRef tkTypeRef;
-        while(pAssemblyImport->EnumNext(&hTypeRefEnum, &tkTypeRef))
-        {
-            CORINFO_ASSEMBLY_HANDLE hAssemblyRef;
-            HRESULT hrLoad = m_pEECompileInfo->LoadTypeRefWinRT(pAssemblyImport, tkTypeRef, &hAssemblyRef);
-            if (FAILED(hrLoad))
-            {
-                // Failed to load a dependency.  Print a warning and move to the next dependency.
-                LPCSTR psznamespace;
-                LPCSTR pszname;
-                pAssemblyImport->GetNameOfTypeRef(tkTypeRef, &psznamespace, &pszname);
-                
-                StackSString sName(SString::Utf8, pszname);
-                StackSString sNamespace(SString::Utf8, psznamespace);
-                StackSString hrMsg;
-                GetHRMsg(hrLoad, hrMsg);
-
-                Warning(W("Failed to load WinRT type dependency %s.%s of assembly %s because of the following error : %s\n"),
-                        sNamespace.GetUnicode(),
-                        sName.GetUnicode(),
-                        m_assemblyDependencies.GetDisplayName(),
-                        hrMsg.GetUnicode());
-                continue;
-            }
-            else if (hrLoad == S_OK)
-            {
-                _ASSERTE(hAssemblyRef != NULL);
-                StackSString ss;
-
-                CORINFO_MODULE_HANDLE hModule = m_pEECompileInfo->GetAssemblyModule(hAssemblyRef);
-                m_pEECompileInfo->GetModuleFileName(hModule, ss);
-
-                LoadHintEnum loadHint = LoadDefault;
-                IfFailThrow(m_pEECompileInfo->GetLoadHint(hAssembly, hAssemblyRef, &loadHint));
-
-                NGenHintEnum ngenHint = NGenDefault;
-                
-                // Append verifies no duplicates
-                m_assemblyDependencies.Append(ss.GetUnicode(), loadHint, ngenHint);
-            }
-        }
-#endif
-        //
-        // Get the default NGen setting for the assembly
-        //
-
-        NGenHintEnum ngenHint = NGenDefault;
-        // Not supported
-        // IfFailThrow(m_pEECompileInfo->GetNGenHint(hAssembly, &ngenHint));
-        m_assemblyDependencies.SetNGenHint(ngenHint);
-    }
-    EX_CATCH
-    {
-        hr = GET_EXCEPTION()->GetHR();
-        RetailAssertIfExpectedClean();
-    }
-    EX_END_CATCH(SwallowAllExceptions);
-
-    IfFailThrow(hr);
-
-    HangWorker(W("NGenDependencyWorkerHang"), W("NGenDependencyWorkerInsideHang"));
 }
 
-void Zapper::HangWorker(LPCWSTR hangKey, LPCWSTR insideHangKey)
-{
-    if (REGUTIL::GetConfigDWORD_DontUse_(hangKey, 0) != 1)
-    {
-        return;
-    }
-
-    RegKeyHolder hKey;
-    if (WszRegCreateKeyEx(HKEY_LOCAL_MACHINE, FRAMEWORK_REGISTRY_KEY_W, 0,
-        NULL, 0, KEY_WRITE, NULL, &hKey, NULL) == ERROR_SUCCESS)
-    {
-        DWORD dwValue = 1;
-        WszRegSetValueEx(hKey, insideHangKey, 0, REG_DWORD,
-            reinterpret_cast<BYTE *>(&dwValue), sizeof(dwValue));
-    }
-
-    while (true)
-    {
-        ClrSleepEx(1000, FALSE);
-    }
-}
-#endif // FEATURE_FUSION
 
 //
 // Compile a module by name
@@ -2603,25 +1214,8 @@ HRESULT Zapper::Compile(LPCWSTR string, CORCOMPILE_NGEN_SIGNATURE * pNativeImage
     {
         fMscorlib = true;
     }
-#ifndef FEATURE_CORECLR
-    else
-    if (_wcsnicmp(fileName, W("mscorlib"), 8) == 0 && (wcslen(fileName) == 8 || fileName[8] == W(',')))
-    {
-        fMscorlib = true;
-    }
-#endif
 
-#if !defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)
-    if (fMscorlib)
-    {
-        //
-        // Enable ningen by default for mscorlib to get identical images between ngen and crossgen
-        //
-        g_ningenState = 1;
-    }
-#endif
 
-#if defined(CROSSGEN_COMPILE) || defined(FEATURE_CORECLR)
     if (fMscorlib)
     {
         //
@@ -2629,7 +1223,6 @@ HRESULT Zapper::Compile(LPCWSTR string, CORCOMPILE_NGEN_SIGNATURE * pNativeImage
         //
         g_fAllowNativeImages = false;
     }
-#endif
 
     // the errors in CreateCompilationDomain are fatal - propogate them up
     CreateCompilationDomain();
@@ -2680,16 +1273,7 @@ void Zapper::CompileInCurrentDomain(__in LPCWSTR string, CORCOMPILE_NGEN_SIGNATU
     
     BEGIN_ENTRYPOINT_VOIDRET;
 
-#ifndef FEATURE_CORECLR
-    // Set the hard binding list.  This needs to be done early, before we attempt to use any
-    // softbound native images, in order to ensure NGen determinism.
-    SetAssemblyHardBindList();
-#endif // !FEATURE_CORECLR
 
-#ifdef FEATURE_FUSION
-    // Set the context info for the current domain
-    SetContextInfo(string);
-#endif
 
     //
     // Load the assembly.
@@ -2701,71 +1285,10 @@ void Zapper::CompileInCurrentDomain(__in LPCWSTR string, CORCOMPILE_NGEN_SIGNATU
     _ASSERTE(m_hAssembly == NULL);
 
     //without fusion, this has to be a file name
-#ifdef FEATURE_FUSION
-    DWORD attributes = WszGetFileAttributes(string);
-    if (attributes == INVALID_FILE_ATTRIBUTES || ((attributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY))
-    {
-        IfFailThrow(m_pEECompileInfo->LoadAssemblyByName(string, &m_hAssembly));
-
-        /* @TODO: If this is the first input, check if it is an EXE
-           using m_pEECompileInfo->GetAssemblyCodeBase(), and print a
-           warning that its better to use the EXE file name on the
-           command-line instead of the full assembly name, so that we
-           will pick the right runtime version from its config file
-           (if present). We could make this work even for full assembly name,
-           but that does not currently work, and this will not be an
-           issue once we require only one platform-runtime version
-           on the machine
-        */
-        StackSString codeBase;
-        m_pEECompileInfo->GetAssemblyCodeBase(m_hAssembly, codeBase);
-        if (codeBase.GetCount() > 4)
-        {
-            SString::Iterator i = codeBase.End() - 4;
-            if (codeBase.MatchCaseInsensitive(i, SL(".exe")))
-                Warning(W("Specify the input as a .EXE for ngen to pick up the config-file\n"));
-        }
-    }
-    else
-#endif //FEATURE_FUSION
     {
         IfFailThrow(m_pEECompileInfo->LoadAssemblyByPath(string, FALSE /* fExplicitBindToNativeImage */, &m_hAssembly));
     }
 
-#ifdef FEATURE_FUSION
-    //
-    // Skip the compilation if the assembly is up to date
-    //
-    if (CheckAssemblyUpToDate(m_hAssembly, pNativeImageSig))
-    {
-        Info(W("Assembly %s is up to date.\n"), string);
-        goto Exit;
-    }
-
-    //
-    // Try to install native image from repository
-    //
-    if (TryToInstallFromRepository(m_hAssembly, pNativeImageSig))
-    {
-        Success(W("Installed native image for assembly %s from repository.\n"), string);
-        goto Exit;
-    }
-
-    if (m_pOpt->m_fRepositoryOnly)
-    {
-        Info(W("Unable to find native image for assembly %s in repository, skipping.\n"), string);
-        goto Exit;
-    }
-
-    //
-    // Testing aid
-    //
-    if (CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_NativeImageRequire) != 0)
-    {
-        Error(W("Failed to find native image for assembly %s in repository.\n"), string);
-        ThrowHR(E_FAIL);
-    }
-#endif //FEATURE_FUSION
 
     //
     // Compile the assembly
@@ -2780,524 +1303,6 @@ Exit:
     return;
 }
 
-#ifdef FEATURE_FUSION
-BOOL Zapper::CheckAssemblyUpToDate(CORINFO_ASSEMBLY_HANDLE hAssembly, CORCOMPILE_NGEN_SIGNATURE * pNativeImageSig)
-{
-    WCHAR zapManifestPath[MAX_LONGPATH];
-    DWORD cZapManifestPath = MAX_LONGPATH;
-
-    if (!m_pEECompileInfo->CheckAssemblyZap(
-        hAssembly,
-        zapManifestPath, &cZapManifestPath))
-        return FALSE;
-
-    if (pNativeImageSig)
-    {
-        NonVMComHolder<INativeImageInstallInfo> pNIInstallInfo;
-
-        IfFailThrow(GetAssemblyMDInternalImport(
-            zapManifestPath,
-            IID_INativeImageInstallInfo,
-            (IUnknown **)&pNIInstallInfo));
-
-        IfFailThrow(pNIInstallInfo->GetSignature(pNativeImageSig));
-    }
-
-    return TRUE;
-}
-
-BOOL Zapper::TryToInstallFromRepository(CORINFO_ASSEMBLY_HANDLE hAssembly, CORCOMPILE_NGEN_SIGNATURE * pNativeImageSig)
-{
-    BOOL fHitMismatchedVersion = FALSE;
-    BOOL fHitMismatchedDependencies = FALSE;
-
-    if (!m_pOpt->m_repositoryDir || (m_pOpt->m_repositoryFlags & IgnoreRepository) != 0)
-    {
-        // No repository
-        return FALSE;
-    }
-
-    StackSString strSimpleName;
-    GetAssemblyName(m_pEECompileInfo, hAssembly, strSimpleName, ICorCompileInfo::GANF_Simple);
-
-    // First see if the NI is available in a folder named "NGen" under the CLR location.
-    // This folder is used by CBS to store build lab generated NIs.  Moving files out of
-    // this folder might confuse CBS, so we hard link NIs from this folder into the NIC.
-    WCHAR wszNGenPath[MAX_LONGPATH];
-    DWORD dwNGenPathLen = COUNTOF(wszNGenPath);
-    IfFailThrow(GetInternalSystemDirectory(wszNGenPath, &dwNGenPathLen));
-
-    wcscat_s(wszNGenPath, COUNTOF(wszNGenPath), W("NativeImages"));
-    if (TryToInstallFromRepositoryDir(StackSString(wszNGenPath), strSimpleName,
-                                      pNativeImageSig, &fHitMismatchedVersion, &fHitMismatchedDependencies, TRUE))
-    {
-        return TRUE;
-    }
-
-    // If we are moving files from repository, first try to look for the native image in the
-    // top-level directory of the repository. This is designed for scenarios where it is convenient
-    // to put all native images in a flat directory. We don't support this with CopyFromRepository
-    // switch, since it is tricky to figure out which files to copy.
-    if ((m_pOpt->m_repositoryFlags & MoveFromRepository) != 0 &&
-        TryToInstallFromRepositoryDir(StackSString(m_pOpt->m_repositoryDir), strSimpleName,
-                                      pNativeImageSig, &fHitMismatchedVersion, &fHitMismatchedDependencies))
-    {
-        // Try to remove the repository directory in case it has become empty.
-        // (Note that attempt to remove non-empty directory fails)
-        WszRemoveDirectory(m_pOpt->m_repositoryDir);
-        return TRUE;
-    }
-
-    // Copied from fusion\asmcache\cacheUtils.cpp
-    // TODO: Clean this up
-#define MAX_ZAP_NAME_LENGTH     20
-#define ZAP_ABBR_END_CHAR       W('#')
-    StackSString strSubDirName;
-    if (strSimpleName.GetCount() > MAX_ZAP_NAME_LENGTH)
-    {
-        strSubDirName.Set(strSimpleName.GetUnicode(), MAX_ZAP_NAME_LENGTH-1);
-        strSubDirName.Append(ZAP_ABBR_END_CHAR);           
-    }
-    else
-        strSubDirName.Set(strSimpleName);
-
-    StackSString strRepositorySubDir(StackSString(m_pOpt->m_repositoryDir), SL(W("\\")), strSubDirName);
-
-    DWORD attributes = WszGetFileAttributes(strRepositorySubDir);
-    if (attributes == INVALID_FILE_ATTRIBUTES || ((attributes & FILE_ATTRIBUTE_DIRECTORY) == 0))
-    {
-       return FALSE;
-    }
-
-    ClrDirectoryEnumerator de(strRepositorySubDir);
-   
-    //
-    // Try to find a matching native image
-    //
-    while (de.Next())
-    {
-        StackSString strNativeImageDir;
-        strNativeImageDir.Set(strRepositorySubDir, SL("\\"), de.GetFileName());
-
-        if (TryToInstallFromRepositoryDir(strNativeImageDir, strSimpleName,
-                                          pNativeImageSig, &fHitMismatchedVersion, &fHitMismatchedDependencies))
-        {
-            if (m_pOpt->m_repositoryFlags & MoveFromRepository)
-            {
-                // Close the iterator so that the directory can be deleted below
-                de.Close();
-
-                // Try to remove empty directories that are not needed anymore.
-                // (Note that attempt to remove non-empty directory fails)
-                if (WszRemoveDirectory(strNativeImageDir))
-                {
-                    if (WszRemoveDirectory(strRepositorySubDir))
-                    {
-                        WszRemoveDirectory(m_pOpt->m_repositoryDir);
-                    }
-                }
-            }
-
-            return TRUE;
-        }
-    }
-
-    if (fHitMismatchedVersion)
-    {
-        ReportEventNGEN(EVENTLOG_WARNING_TYPE, NGEN_REPOSITORY, W("Version or flavor did not match with repository: %s"), strSimpleName.GetUnicode());
-    }
-
-    if (fHitMismatchedDependencies)
-    {
-        ReportEventNGEN(EVENTLOG_WARNING_TYPE, NGEN_REPOSITORY, W("Dependencies did not match with repository: %s"), strSimpleName.GetUnicode());
-    }
-
-    return FALSE;
-}
-
-BOOL Zapper::TryToInstallFromRepositoryDir(
-    SString &strNativeImageDir, SString &strSimpleName,
-    CORCOMPILE_NGEN_SIGNATURE *pNativeImageSig, BOOL *pfHitMismatchedVersion, BOOL *pfHitMismatchedDependencies, BOOL useHardLink)
-{
-    StackSString strNativeImageName;
-    StackSString strNativeImagePath;
-
-    // probe for both .exe and .dll
-    static const LPCWSTR c_Suffixes[] = { W(".dll"), W(".exe"), W(".ni.dll"), W(".ni.exe") };
-
-    int suffix;
-    for (suffix = 0; suffix < NumItems(c_Suffixes); suffix++)
-    {
-        strNativeImageName.Set(strSimpleName, SL(c_Suffixes[suffix]));
-        strNativeImagePath.Set(strNativeImageDir, SL("\\"), strNativeImageName);
-
-        if (WszGetFileAttributes(strNativeImagePath) != INVALID_FILE_ATTRIBUTES)
-        {
-            break;
-        }
-    }
-    if (suffix == NumItems(c_Suffixes))
-    {
-        // No matching file
-        return FALSE;
-    }
-
-    // Make sure the native image is unmapped before we try to install it
-    {
-        HModuleHolder hMod(::WszLoadLibrary(strNativeImagePath));
-        if (hMod.IsNull())
-        {
-            // Corrupted image or something
-            return FALSE;
-        }
-
-        PEDecoder pedecoder(hMod);
-
-        if (!pedecoder.CheckNativeHeader())
-        {
-            // Corrupted image
-            return FALSE;
-        }
-
-        class LoggableNativeImage : public LoggableAssembly
-        {
-            LPCWSTR m_lpszNativeImage;
-
-        public:
-            LoggableNativeImage(LPCWSTR lpszNativeImage)
-                : m_lpszNativeImage(lpszNativeImage)
-            {
-            }
-
-            virtual SString DisplayString() { return m_lpszNativeImage; }
-#ifdef FEATURE_FUSION
-            virtual IAssemblyName*  FusionAssemblyName() { return NULL; }
-            virtual IFusionBindLog* FusionBindLog() { return NULL; }
-#endif // FEATURE_FUSION
-        }
-        loggableNativeImage(strNativeImagePath);
-
-        // Does the version info of the native image match what we are looking for?
-        CORCOMPILE_VERSION_INFO *pVersionInfo = pedecoder.GetNativeVersionInfo();
-        if (!RuntimeVerifyNativeImageVersion(pVersionInfo, &loggableNativeImage) ||
-            !RuntimeVerifyNativeImageFlavor(pVersionInfo, &loggableNativeImage))
-        {
-            // Version info does not match
-            *pfHitMismatchedVersion = TRUE;
-            return FALSE;
-        }
-
-        COUNT_T cDependencies;
-        CORCOMPILE_DEPENDENCY *pDependencies = pedecoder.GetNativeDependencies(&cDependencies);
-
-        COUNT_T cMeta;
-        const void *pMeta = pedecoder.GetNativeManifestMetadata(&cMeta);
-
-        NonVMComHolder<IMDInternalImport> pAssemblyImport;
-
-        IfFailThrow(GetMetaDataInternalInterface((void *) pMeta,
-                                                 cMeta,
-                                                 ofRead,
-                                                 IID_IMDInternalImport,
-                                                 (void **) &pAssemblyImport));
-
-        if (!VerifyDependencies(pAssemblyImport, pDependencies, cDependencies))
-        {
-            // Dependencies does not match
-            *pfHitMismatchedDependencies = TRUE;
-            return FALSE;
-        }
-    }
-
-    if (m_pOpt->m_repositoryFlags & MoveFromRepository && !useHardLink)
-    {
-        // Move files to save I/O bandwidth
-        InstallFromRepository(strNativeImagePath.GetUnicode(), pNativeImageSig);
-    }
-    else
-    {
-        // Copy files
-        CopyAndInstallFromRepository(strNativeImageDir.GetUnicode(), strNativeImageName.GetUnicode(), pNativeImageSig, useHardLink);
-    }
-
-    ReportEventNGEN(EVENTLOG_SUCCESS, NGEN_REPOSITORY, W("Installed from repository: %s"), strSimpleName.GetUnicode());
-    return TRUE;
-}
-
-void Zapper::InstallFromRepository(LPCWSTR lpszNativeImage, 
-                                   CORCOMPILE_NGEN_SIGNATURE * pNativeImageSig)
-{
-    //
-    // Get the zap string.
-    //
-    HRESULT hr = S_OK;
-
-    NonVMComHolder<IAssemblyName> pName;
-    NonVMComHolder<IAssemblyLocation> pAssemblyLocation;
-
-    ReleaseHolder<IBindContext> pBindCtx;
-    if (FAILED(hr = m_pDomain->GetIBindContext(&pBindCtx)))
-    {
-        Error(W("Failed to get binding context.\n"));
-        ThrowHR(hr);
-    }
-
-    HRESULT hrInstallCustomAssembly = InstallNativeAssembly(lpszNativeImage, INVALID_HANDLE_VALUE, m_pOpt->m_zapSet, pBindCtx, &pName, &pAssemblyLocation);
-    if (FAILED(hrInstallCustomAssembly))
-    {
-        Error(W("Failed to install native image %s from repository.\n"), lpszNativeImage);
-        ThrowHR(hrInstallCustomAssembly);
-    }
-
-    // TODO: It would be nice to verify that the native image works by calling CheckAssemblyUpToDate.
-    // Unfortunately, it does not work since we have loaded the non-ngened image in this appdomain 
-    // already in CompileInCurrentDomain. We would need to create a new appdomain for the verification. 
-
-    //
-    // Print a success message
-    //
-    if (!m_pOpt->m_silent)
-    {
-        PrintFusionCacheEntry(LogLevel_Info, pName);
-    }
-
-    WCHAR zapManifestPath[MAX_LONGPATH];
-    DWORD cPath = MAX_LONGPATH;
-    IfFailThrow(pAssemblyLocation->GetPath(zapManifestPath, &cPath));
-
-    if (pNativeImageSig)
-    {
-        NonVMComHolder<INativeImageInstallInfo> pNIInstallInfo;
-
-        IfFailThrow(GetAssemblyMDInternalImport(
-            zapManifestPath,
-            IID_INativeImageInstallInfo,
-            (IUnknown **)&pNIInstallInfo));
-
-        IfFailThrow(pNIInstallInfo->GetSignature(pNativeImageSig));
-    }
-}
-
-void Zapper::CleanDirectory(LPCWSTR path)
-{
-    // Handle the case when we are given file instead of directory
-    DWORD dwAttributes = WszGetFileAttributes(path);
-    if (dwAttributes == INVALID_FILE_ATTRIBUTES)
-    {
-        // Directory does not exist
-        return;
-    }
-
-    if (!(dwAttributes & FILE_ATTRIBUTE_DIRECTORY))
-    {
-        if (dwAttributes & FILE_ATTRIBUTE_READONLY)
-            WszSetFileAttributes(path, dwAttributes&~FILE_ATTRIBUTE_READONLY);
-
-        if (!WszDeleteFile(path))
-        {
-            Warning(W("Cannot delete file %s\n"), path);
-            ThrowLastError();
-        }
-        return;
-    }
-
-    {
-        ClrDirectoryEnumerator de(path);
-
-        while (de.Next())
-        {
-            StackSString fullName;
-            fullName.Set(path, W("\\"), de.GetFileName());
-
-            if (de.GetFileAttributes() & FILE_ATTRIBUTE_DIRECTORY)
-            {
-                CleanDirectory(fullName);
-            }
-            else
-            {
-                if (de.GetFileAttributes() & FILE_ATTRIBUTE_READONLY)
-                    WszSetFileAttributes(fullName, de.GetFileAttributes()&~FILE_ATTRIBUTE_READONLY);
-
-                if (!WszDeleteFile(fullName))
-                {
-                    Warning(W("Cannot delete file %s\n"), fullName.GetUnicode());
-                    ThrowLastError();
-                }
-            }
-        }
-    }
-
-    if (!WszRemoveDirectory(path))
-    {
-        Warning(W("Cannot remove directory %s\n"), path);
-        ThrowLastError();
-    }
-}
-
-void Zapper::TryCleanDirectory(LPCWSTR path)
-{
-    EX_TRY
-    {
-        CleanDirectory(path);
-    }
-    EX_SWALLOW_NONTERMINAL;
-}
-
-//------------------------------------------------------------------------------
-
-// static
-void Zapper::TryCleanDirectory(Zapper * pZapper)
-{
-    // @CONSIDER: If this fails, block for some time, and try again.
-    // This will give more time for programs like Anti-virus software
-    // to release the file handle.
-    pZapper->TryCleanDirectory(pZapper->m_outputPath);
-}
-
-typedef Wrapper<Zapper*, DoNothing<Zapper*>, Zapper::TryCleanDirectory, NULL>
-    TryCleanDirectoryHolder;
-
-//------------------------------------------------------------------------------
-// Sets Zapper::m_outputPath to the folder where we should create the
-// ngen images.
-//------------------------------------------------------------------------------
-
-void Zapper::GetOutputFolder()
-{
-    /* We create a temporary folder in the NativeImageCache (NIC) instead of using
-       WszGetTempPath(). This is because WszGetTempPath() is a private folder
-       for the current user. Files created in there will have ACLs allowing
-       accesses only to the current user. Later InstallCustomAssembly()
-       will move the files to the NIC preserving the security attributes.
-       Now other users cannot use the ngen images, which is bad.
-    */
-    WCHAR tempFolder[MAX_LONGPATH];
-    DWORD tempFolderLen = NumItems(tempFolder);
-    IfFailThrow(GetCachePath(ASM_CACHE_ZAP, tempFolder, &tempFolderLen));
-
-    // Create the folder "NIC"
-
-    IfFailThrow(clr::fs::Dir::CreateRecursively(tempFolder));
-
-    // Create the folder "NIC\Temp"
-
-    StackSString tempPath(tempFolder);
-    tempPath += W("\\Temp");
-    if (!WszCreateDirectory(tempPath, NULL))
-    {
-        if (GetLastError() != ERROR_ALREADY_EXISTS)
-            ThrowLastError();
-    }
-
-    // Create the folder "NIC\Temp\P-N", where P is the current process ID, and NN is a serial number. 
-    // Start with N=0.  If that directory name is already in use, clean up that directory (it can't be in
-    // active use because process ID is unique), increment N, and try again.  Give up if N gets too large.
-    for (DWORD n = 0; ; n++)
-    {
-        m_outputPath.Printf(W("%s\\%x-%x"), (LPCWSTR)tempPath, GetCurrentProcessId(), n);
-        if (WszCreateDirectory(m_outputPath, NULL))
-            break;
-
-        if (GetLastError() != ERROR_ALREADY_EXISTS)
-            ThrowLastError();
-
-        TryCleanDirectory(m_outputPath);
-
-        if (n >= 255)
-        {
-            Error(W("Unable to create working directory"));
-            ThrowHR(E_FAIL);
-        }
-    }
-}
-
-//------------------------------------------------------------------------------
-
-void Zapper::CopyAndInstallFromRepository(LPCWSTR lpszNativeImageDir,
-                                          LPCWSTR lpszNativeImageName, 
-                                          CORCOMPILE_NGEN_SIGNATURE * pNativeImageSig,
-                                          BOOL useHardLink)
-{
-    GetOutputFolder();
-
-    // Note that we do not want to fail if we cannot clean up the TEMP files.
-    // We have seen many issues where the Indexing service or AntiVirus software
-    // open the temporary files, and seem to hold onto them. We have been
-    // told that if ngen completes too fast, these other softwares may
-    // not be able to process the file fast enough, and may close the file
-    // sometime after we have tried to delete it.
-    TryCleanDirectoryHolder outputPathHolder(this);
-
-    StackSString strTempNativeImage;
-    
-    //local variable fixes gcc overload resolution.
-    SString literalPathSep(SString::Literal, "\\");
-    strTempNativeImage.Set(m_outputPath, literalPathSep, lpszNativeImageName);
-
-    if (useHardLink)
-    {
-        // Don't support multi-module assemblies. The useHardLink flag is used in
-        // scenarios where the source directory has multiple native images, and we
-        // want to avoid the need to figure out which files are needed.
-        StackSString strSource(lpszNativeImageDir, literalPathSep, lpszNativeImageName);
-
-        // Try to create hard link first. If that fails, try again with copy.
-        if (!WszCreateHardLink(strTempNativeImage.GetUnicode(), strSource.GetUnicode(), NULL) &&
-            !WszCopyFile(strSource.GetUnicode(), strTempNativeImage.GetUnicode(), TRUE))
-        {
-            ThrowLastError();
-        }
-    }
-    else
-    {
-        // Copy everything in the directory over. Blindly copying everything over
-        // saves us from dealing with external modules.
-        CopyDirectory(lpszNativeImageDir, m_outputPath);
-    }
-
-    InstallFromRepository(strTempNativeImage.GetUnicode(), pNativeImageSig);
-}
-
-//------------------------------------------------------------------------------
-
-void Zapper::CopyDirectory(LPCWSTR srcPath, LPCWSTR dstPath)
-{
-    ClrDirectoryEnumerator de(srcPath);
-
-    while (de.Next())
-    {
-        StackSString srcFile;
-        SString literalPathSep(SString::Literal, "\\");
-        srcFile.Set(srcPath, literalPathSep, de.GetFileName());
-        
-        StackSString dstFile;
-        dstFile.Set(dstPath, literalPathSep, de.GetFileName());
-        
-        if (CLRConfig::GetConfigValue(CLRConfig::INTERNAL_NGenCopyFromRepository_SetCachedSigningLevel) != 0)
-        {
-            // The user wants the destination file to be vouched for. It would be a security hole to copy the file
-            // and then actually vouch for it. So we create a hard link instead. If the original file has the EA,
-            // the new link will also see the EA as it points to the same physical file. Note that the argument
-            // order is different between CreateHardLink and CopyFile.
-            if (WszCreateHardLink(dstFile.GetUnicode(), srcFile.GetUnicode(), NULL))
-            {
-                continue;
-            }
-
-            // If creation of hard link failed, issue an warning and fall back to copying.
-            HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
-            _ASSERTE(FAILED(hr));
-            if (IsExeOrDllOrWinMD(srcFile.GetUnicode()))
-            {   // Print the warning for executables for easier troubleshooting
-                Warning(W("CreateHardLink failed with HRESULT 0x%08x for file %s\n"), hr, srcFile.GetUnicode());
-            }
-        }
-
-        if (!WszCopyFile(srcFile.GetUnicode(), dstFile.GetUnicode(), TRUE))
-            ThrowLastError();
-    }
-}
-#endif // FEATURE_FUSION
 
 //------------------------------------------------------------------------------
 
@@ -3382,15 +1387,8 @@ void Zapper::InitializeCompilerFlags(CORCOMPILE_VERSION_INFO * pVersionInfo)
         m_pOpt->m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_USE_FCOMI);
     }
 
-#if !defined(FEATURE_CORECLR)
-    if (CPU_X86_USE_SSE2(pVersionInfo->cpuInfo.dwFeatures))
-    {
-        m_pOpt->m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_USE_SSE2);
-    }
-#else
     // .NET Core requires SSE2.
     m_pOpt->m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_USE_SSE2);
-#endif // !defined(FEATURE_CORECLR)
 
 #endif // _TARGET_X86_
 
@@ -3457,13 +1455,6 @@ void Zapper::DefineOutputAssembly(SString& strAssemblyName, ULONG * pHashAlgId)
     // GenerateFile() will fail later on.
     // VerifyBindingString is a Runtime requirement, but StringHasLegalFileNameChars
     // is a ngen restriction.
-#ifdef FEATURE_FUSION
-    if (!FusionBind::VerifyBindingStringW(wszAssemblyName))
-    {
-        Error(W("Error: Assembly name \"%s\" contains path separator and/or extension.\n"), wszAssemblyName); // VLDTR_E_AS_BADNAME
-        ThrowHR(HRESULT_FROM_WIN32(ERROR_INVALID_NAME));
-    }
-#endif //FEATURE_FUSION
 
     if (!StringHasLegalFileNameChars(wszAssemblyName))
     {
@@ -3512,17 +1503,6 @@ void Zapper::CompileAssembly(CORCOMPILE_NGEN_SIGNATURE * pNativeImageSig)
     // Set up the output path.
     //
 
-#ifdef FEATURE_FUSION
-    GetOutputFolder();
-
-    // Note that we do not want to fail if we cannot clean up the TEMP files.
-    // We have seen many issues where the Indexing service or AntiVirus software
-    // open the temporary files, and seem to hold onto them. We have been
-    // told that if ngen completes too fast, these other softwares may
-    // not be able to process the file fast enough, and may close the file
-    // sometime after we have tried to delete it.
-    TryCleanDirectoryHolder outputPathHolder(this);
-#else // FEATURE_FUSION
     //
     // If we don't have fusion, we just create the file right at the target.  No need to do an install.
     //
@@ -3545,7 +1525,6 @@ void Zapper::CompileAssembly(CORCOMPILE_NGEN_SIGNATURE * pNativeImageSig)
             m_outputPath.Set(W(".") DIRECTORY_SEPARATOR_STR_W);
         }
     }
-#endif // FEATURE_FUSION
 
     //
     // Get the manifest metadata.
@@ -3603,10 +1582,6 @@ void Zapper::CompileAssembly(CORCOMPILE_NGEN_SIGNATURE * pNativeImageSig)
         }
 
         // Write the main assembly module
-#ifdef FEATURE_FUSION
-        strNativeImagePath.Set(m_outputPath, SL(DIRECTORY_SEPARATOR_STR_W), strAssemblyName, 
-            pAssemblyModule->m_ModuleDecoder.IsDll() ? SL(W(".dll")) : SL(W(".exe")));
-#else // FEATURE_FUSION
         strNativeImagePath = GetOutputFileName();
 
         if (strNativeImagePath.IsEmpty())
@@ -3614,7 +1589,6 @@ void Zapper::CompileAssembly(CORCOMPILE_NGEN_SIGNATURE * pNativeImageSig)
             strNativeImagePath.Set(m_outputPath, SL(DIRECTORY_SEPARATOR_STR_W), strAssemblyName, 
                 pAssemblyModule->m_ModuleDecoder.IsDll() ? SL(W(".ni.dll")) : SL(W(".ni.exe")));
         }
-#endif // FEATURE_FUSION
 
         pAssemblyModule->SetPdbFileName(SString(strAssemblyName, SL(W(".ni.pdb"))));
 
@@ -3625,21 +1599,6 @@ void Zapper::CompileAssembly(CORCOMPILE_NGEN_SIGNATURE * pNativeImageSig)
     if (FAILED(g_hrFatalError))
         ThrowHR(g_hrFatalError);
 
-#ifdef FEATURE_FUSION
-    InstallCompiledAssembly(strAssemblyName.GetUnicode(), strNativeImagePath.GetUnicode(), hFile, hFiles);
-    
-    // 
-    // Once we return from InstallCompiledAssembly, we're in a window where the native image file
-    // has been placed into the NIC, but none of the Ngen rootstore data structures have been set
-    // to indicate there is a native image for this assembly.  Therefore, we MUST return to the
-    // Ngen process now without throwing an exception.
-    // If you need to add code below here before returning it cannot throw an exception or return 
-    // failure.  If it does, you must make sure the native image get uninstalled from disk before 
-    // returning so we do not leak the NI file.
-    // 
-    return;
-
-#else // FEATURE_FUSION
 
     // Close the file
     CloseHandle(hFile);
@@ -3652,7 +1611,6 @@ void Zapper::CompileAssembly(CORCOMPILE_NGEN_SIGNATURE * pNativeImageSig)
     {
         GetSvcLogger()->Printf(W("Native image %s generated successfully.\n"), strNativeImagePath.GetUnicode());
     }
-#endif // FEATURE_FUSION
 
 }
 
@@ -3855,107 +1813,6 @@ ZapImage * Zapper::CompileModule(CORINFO_MODULE_HANDLE hModule,
     return module.Extract();
 }
 
-#ifdef FEATURE_FUSION
-void Zapper::InstallCompiledAssembly(LPCWSTR szAssemblyName, LPCWSTR szNativeImagePath, HANDLE hFile, SArray<HANDLE> &hFiles)
-{
-    HRESULT hr = S_OK;
-
-    if ((m_pOpt->m_repositoryFlags & CopyToRepository) && m_pOpt->m_repositoryDir)
-    {
-        //
-        // Copy the native images back to repository. We require RepositoryDir itself to exists.
-        //
-
-        StackSString strSimpleName(szAssemblyName);
-        StackSString strSubDirName;
-
-        // Get subdirectory name from the assembly name
-        if (strSimpleName.GetCount() > MAX_ZAP_NAME_LENGTH)
-        {
-            strSubDirName.Set(strSimpleName.GetUnicode(), MAX_ZAP_NAME_LENGTH-1);
-            strSubDirName.Append(ZAP_ABBR_END_CHAR);           
-        }
-        else
-            strSubDirName.Set(strSimpleName);
-
-        StackSString destPath;
-        destPath.Set(m_pOpt->m_repositoryDir, SL(W("\\")), strSubDirName);
-
-        if (!WszCreateDirectory(destPath, NULL))
-        {
-            if (GetLastError() != ERROR_ALREADY_EXISTS)
-                ThrowLastError();
-        }
-
-        // Get unique subdirectory name from native image sig
-        GUID unique;
-        IfFailThrow(CoCreateGuid(&unique));
-        static_assert_no_msg(sizeof(unique) == 16);
-        destPath.AppendPrintf(W("\\%08x%08x%08x%08x"), 
-            ((LONG*)&unique)[0], ((LONG*)&unique)[1],
-            ((LONG*)&unique)[2], ((LONG*)&unique)[3]);
-
-        if (!WszCreateDirectory(destPath, NULL))
-            ThrowLastError();
-
-        CopyDirectory(m_outputPath, destPath);
-    }
-
-    NonVMComHolder<IAssemblyName> pName;
-    NonVMComHolder<IAssemblyLocation> pAssemblyLocation;
-
-    // If the NGenCompileWorkerHang key is set, we want to loop forever.  This helps testing
-    // of termination of compilation workers on fast machines (where the compilation can finish
-    // before the worker has been terminated).
-    HangWorker(W("NGenCompileWorkerHang"), W("NGenCompileWorkerInsideHang"));
-
-    ReleaseHolder<IBindContext> pBindCtx;
-    if (FAILED(hr = m_pDomain->GetIBindContext(&pBindCtx)))
-    {
-        Error(W("Failed to get binding context.\n"));
-        ThrowHR(hr);
-    }
-    if (FAILED(hr = InstallNativeAssembly(szNativeImagePath, hFile, m_pOpt->m_zapSet, pBindCtx, &pName, &pAssemblyLocation)))
-    {
-        Warning(W("Failed to install image to native image cache.\n"));
-        ThrowHR(hr);
-    }
-    
-    //
-    // The native image is now installed in the NIC.  Any exception thrown before the end of this method
-    // will result in the native image being leaked but the rootstore being cleaned up, orphaning the NI.
-    //
-    EX_TRY
-    {
-        // Ignore errors if they happen
-        (void)m_pEECompileInfo->SetCachedSigningLevel(hFile, hFiles.GetElements(), hFiles.GetCount());
-    
-        CloseHandle(hFile);
-        for (SArray<HANDLE>::Iterator i = hFiles.Begin(); i != hFiles.End(); ++i)
-        {
-            CloseHandle(*i);
-        }
-
-        //
-        // Print a success message
-        //
-
-        if (!m_pOpt->m_silent)
-        {
-            PrintFusionCacheEntry(LogLevel_Info, pName);
-        }
-    }
-    EX_CATCH
-    {
-        // Uninstall the native image and rethrow. Ignore all errors from UninstallNativeAssembly; we 
-        // tried our best not to leak a native image and want to surface to original reason for 
-        // failing anyway.
-        (void)UninstallNativeAssembly(pName, GetSvcLogger()->GetSvcLogger());
-        EX_RETHROW;
-    }
-    EX_END_CATCH_UNREACHABLE;
-} // Zapper::InstallCompiledAssembly
-#endif // FEATURE_FUSION
 
 void Zapper::Success(LPCWSTR format, ...)
 {
@@ -4079,7 +1936,7 @@ void Zapper::PrintErrorMessage(CorZapLogLevel level, HRESULT hr)
     Print(level, W("%s"), message.GetUnicode());
 }
 
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#if !defined(FEATURE_MERGE_JIT_AND_ENGINE)
 void Zapper::SetCLRJITPath(LPCWSTR pwszCLRJITPath)
 {
     m_CLRJITPath.Set(pwszCLRJITPath);
@@ -4089,16 +1946,15 @@ void Zapper::SetDontLoadJit()
 {
     m_fDontLoadJit = true;
 }
-#endif // defined(FEATURE_CORECLR) && !defined(FEATURE_MERGE_JIT_AND_ENGINE)
+#endif // !defined(FEATURE_MERGE_JIT_AND_ENGINE)
 
-#if defined(FEATURE_CORECLR) && !defined(NO_NGENPDB)
+#if !defined(NO_NGENPDB)
 void Zapper::SetDiasymreaderPath(LPCWSTR pwzDiasymreaderPath)
 {
     m_DiasymreaderPath.Set(pwzDiasymreaderPath);
 }
-#endif // defined(FEATURE_CORECLR) && !defined(NO_NGENPDB)
+#endif // !defined(NO_NGENPDB)
 
-#if defined(FEATURE_CORECLR) || defined(CROSSGEN_COMPILE)
 
 void Zapper::SetPlatformAssembliesPaths(LPCWSTR pwzPlatformAssembliesPaths)
 {
@@ -4135,7 +1991,6 @@ void Zapper::SetForceFullTrust(bool val)
     m_fForceFullTrust = val;
 }
 
-#endif // FEATURE_CORECLR || CROSSGEN_COMPILE
 
 
 void Zapper::SetOutputFilename(LPCWSTR pwzOutputFilename)
diff --git a/sync.cmd b/sync.cmd
index 094d0c1a71..f63315559d 100644
--- a/sync.cmd
+++ b/sync.cmd
@@ -7,7 +7,6 @@ if /I [%1] == [-help] goto Usage
 @if [%1]==[] set __args=-p
 
  @call %~dp0run.cmd sync %__args% %*
- @call %~dp0run.cmd sync -PublishTestNativeBins %__args% %*
 @exit /b %ERRORLEVEL%
 
 :Usage
@@ -27,6 +26,13 @@ echo                 -BuildMajor
 echo                 -BuildMinor
 echo              To download from a specific container, specify:
 echo                 -Container="container name"
+echo     -n     - Downloads test native binaries from the specified container
+echo              The following properties are required:
+echo                 -AzureAccount="Account name"
+echo                 -AzureToken="Access token"
+echo                 -Container="Container name"
+echo                 -RuntimeId="RID" (Needs to match what's in the container)
+echo.
 echo.
 echo.
 echo If no option is specified then sync.cmd -p is implied.
\ No newline at end of file
diff --git a/tests/arm64/fails.testlist b/tests/arm64/fails.testlist
new file mode 100644
index 0000000000..5013739521
--- /dev/null
+++ b/tests/arm64/fails.testlist
@@ -0,0 +1,60 @@
+// Optimization failure, divrem fails
+// https://github.com/dotnet/coreclr/issues/8155
+JIT/Methodical/divrem/div/decimaldiv_cs_do/decimaldiv_cs_do.sh
+JIT/Methodical/divrem/div/decimaldiv_cs_ro/decimaldiv_cs_ro.sh
+JIT/Methodical/divrem/div/i4div_cs_do/i4div_cs_do.sh
+JIT/Methodical/divrem/div/i4div_cs_ro/i4div_cs_ro.sh
+JIT/Methodical/divrem/div/i8div_cs_do/i8div_cs_do.sh
+JIT/Methodical/divrem/div/i8div_cs_ro/i8div_cs_ro.sh
+JIT/Methodical/divrem/div/overlddiv_cs_do/overlddiv_cs_do.sh
+JIT/Methodical/divrem/div/overlddiv_cs_ro/overlddiv_cs_ro.sh
+JIT/Methodical/divrem/div/r4div_cs_do/r4div_cs_do.sh
+JIT/Methodical/divrem/div/r4div_cs_ro/r4div_cs_ro.sh
+JIT/Methodical/divrem/div/r8div_cs_do/r8div_cs_do.sh
+JIT/Methodical/divrem/div/r8div_cs_ro/r8div_cs_ro.sh
+JIT/Methodical/divrem/div/u4div_cs_do/u4div_cs_do.sh
+JIT/Methodical/divrem/div/u4div_cs_ro/u4div_cs_ro.sh
+JIT/Methodical/divrem/div/u8div_cs_do/u8div_cs_do.sh
+JIT/Methodical/divrem/div/u8div_cs_ro/u8div_cs_ro.sh
+JIT/Methodical/divrem/rem/decimalrem_cs_do/decimalrem_cs_do.sh
+JIT/Methodical/divrem/rem/decimalrem_cs_ro/decimalrem_cs_ro.sh
+JIT/Methodical/divrem/rem/r4rem_cs_do/r4rem_cs_do.sh
+JIT/Methodical/divrem/rem/r4rem_cs_ro/r4rem_cs_ro.sh
+JIT/Methodical/divrem/rem/r8rem_cs_do/r8rem_cs_do.sh
+JIT/Methodical/divrem/rem/r8rem_cs_ro/r8rem_cs_ro.sh
+
+// Optimization failure, System.ArgumentException: Decimal byte array constructor requires an array of length four containing valid decimal bytes.
+// https://github.com/dotnet/coreclr/issues/8154
+JIT/Methodical/divrem/rem/i4rem_cs_do/i4rem_cs_do.sh
+JIT/Methodical/divrem/rem/i4rem_cs_ro/i4rem_cs_ro.sh
+JIT/Methodical/divrem/rem/i8rem_cs_do/i8rem_cs_do.sh
+JIT/Methodical/divrem/rem/i8rem_cs_ro/i8rem_cs_ro.sh
+JIT/Methodical/divrem/rem/overldrem_cs_do/overldrem_cs_do.sh
+JIT/Methodical/divrem/rem/overldrem_cs_ro/overldrem_cs_ro.sh
+JIT/Methodical/divrem/rem/u4rem_cs_do/u4rem_cs_do.sh
+JIT/Methodical/divrem/rem/u4rem_cs_ro/u4rem_cs_ro.sh
+JIT/Methodical/divrem/rem/u8rem_cs_do/u8rem_cs_do.sh
+JIT/Methodical/divrem/rem/u8rem_cs_ro/u8rem_cs_ro.sh
+
+// Optimization failure, Unhandled Exception: System.OverflowException: Value was either too large or too small for an Int32
+// https://github.com/dotnet/coreclr/issues/8153
+JIT/Methodical/fp/exgen/1000w1d_cs_do/1000w1d_cs_do.sh
+JIT/Methodical/fp/exgen/1000w1d_cs_ro/1000w1d_cs_ro.sh
+JIT/Methodical/fp/exgen/10w5d_cs_do/10w5d_cs_do.sh
+JIT/Methodical/fp/exgen/10w5d_cs_ro/10w5d_cs_ro.sh
+
+// Optimization failure, No exception thrown
+JIT/Regression/JitBlue/DevDiv_359736/DevDiv_359736_do/DevDiv_359736_do.sh
+JIT/Regression/JitBlue/DevDiv_359736/DevDiv_359736_ro/DevDiv_359736_ro.sh
+
+// Assertion failed 'initBlkNode->gtRsvdRegs == RBM_ARG_2'
+JIT/Regression/JitBlue/DevDiv_278371/DevDiv_278371/DevDiv_278371.sh
+
+// Unhandled Exception: System.InvalidProgramException: Common Language Runtime detected an invalid program.
+JIT/Methodical/tailcall_v4/smallFrame/smallFrame.sh
+
+// Failed to catch an exception
+Exceptions/ForeignThread/ForeignThreadExceptions/ForeignThreadExceptions.sh
+
+// Expected: 0x43e08b2a2c280290
+JIT/Regression/JitBlue/GitHub_3449/GitHub_3449/GitHub_3449.sh
diff --git a/tests/dir.props b/tests/dir.props
index dcaee88fc3..329e4bcc60 100644
--- a/tests/dir.props
+++ b/tests/dir.props
@@ -39,12 +39,19 @@
     <RootBinDir Condition="'$(__RootBinDir)'==''">$(ProjectDir)bin\</RootBinDir>
   </PropertyGroup>
 
+<!-- Default Test platform to deploy the netstandard compiled tests to -->
+  <PropertyGroup>
+    <!-- we default TestTFM and FilterToTestTFM to netcoreapp1.0 if they are not explicity defined -->
+    <DefaultTestTFM Condition="'$(DefaultTestTFM)'==''">netcoreapp1.0</DefaultTestTFM>
+    <TestTFM Condition="'$(TestTFM)'==''">$(DefaultTestTFM)</TestTFM>
+    <FilterToTestTFM Condition="'$(FilterToTestTFM)'==''">$(DefaultTestTFM)</FilterToTestTFM>
+  </PropertyGroup>
+
   <!-- Output paths -->
   <PropertyGroup>
     <BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)' == ''">$(RootBinDir)obj\</BaseIntermediateOutputPath>
     <IntermediateOutputPath Condition="'$(IntermediateOutputPath)' == ''">$(BaseIntermediateOutputPath)\$(BuildOS).$(BuildArch).$(BuildType)</IntermediateOutputPath>
     <OutputPath Condition="'$(OutputPath)' == ''">$(BaseIntermediateOutputPath)\$(BuildOS).$(BuildArch).$(BuildType)</OutputPath>
-    <FinalOutputPath Condition="'$(FinalOutputPath)' == ''">$(BinDir)</FinalOutputPath>
   </PropertyGroup>
 
   <Import Condition="Exists('$(ToolsDir)BuildVersion.targets')" Project="$(ToolsDir)BuildVersion.targets" />
diff --git a/tests/helixprep.proj b/tests/helixprep.proj
new file mode 100644
index 0000000000..ea71dbadae
--- /dev/null
+++ b/tests/helixprep.proj
@@ -0,0 +1,155 @@
+<Project ToolsVersion="12.0" DefaultTargets="ArchiveAll" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+
+  <UsingTask TaskName="ZipFileCreateFromDirectory" AssemblyFile="$(ToolsDir)\net45\Microsoft.DotNet.Build.Tasks.dll"/>
+  
+  <Import Project="dir.props" />
+  <Import Project="..\dir.props" />
+
+  <PropertyGroup>
+    <DiscoveryDirectory>$(TestWorkingDir)</DiscoveryDirectory>
+    <CoreRootDir Condition="'$(RuntimeID)' == '' ">$(CORE_ROOT)</CoreRootDir>
+    <CoreRootDir Condition="'$(RuntimeID)' != '' ">$(CORE_OVERLAY)</CoreRootDir>
+    <CoreRootName Condition="'$(RuntimeID)' == '' ">Core_Root_Windows_NT-$(__BuildArch)</CoreRootName>
+    <CoreRootName Condition="'$(RuntimeID)' != '' ">Core_Root_$(RuntimeID)</CoreRootName>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <TestCmds Include="$(DiscoveryDirectory)\**\*.cmd" ></TestCmds>
+    <XunitDlls Include="$(DiscoveryDirectory)\*\*.XUnitWrapper.dll" ></XunitDlls>
+    <RequiresSigningFilesToDelete Include="$(DiscoveryDirectory)\**\*.requires_signing" />
+  </ItemGroup>
+
+  <!-- Build the platform-specific wrapper to run an individual xunit wrapper -->
+
+  <Target Name="GenerateWrapperExecutables"
+    Inputs="@(XunitDlls)"
+    Outputs="$(TestWorkingDir)*\runtests.cmd" >
+
+    <MSBuild Projects="helixprep.proj"
+             Properties="BuildPath=%(XunitDlls.RootDir)%(XunitDlls.Directory);ProjectName=%(XunitDlls.Filename)%(XunitDlls.Extension)"
+             Targets="GenerateWrapperCmd" />
+
+    <MSBuild Projects="helixprep.proj"
+             Properties="BuildPath=%(XunitDlls.RootDir)%(XunitDlls.Directory);ProjectName=%(XunitDlls.Filename)%(XunitDlls.Extension)"
+             Targets="GenerateWrapperSh" />
+  </Target>
+
+  <!-- Zip each top-level test folder to send to Helix -->
+
+  <Target Name="ArchiveTests"
+    Inputs="@(XunitDlls)"
+    Outputs="$(TestWorkingDir)archive\**" >
+    
+    <Copy SourceFiles="$(CORE_ROOT)\xunit.console.netcore.exe"
+          DestinationFolder="%(XunitDlls.RootDir)%(XunitDlls.Directory)"
+    />
+    <Message Text="Deleting '.requires_signing' files to avoid file name lengths exceeding MAX_PATH" Importance="Low" />
+    <Delete Files="@(RequiresSigningFilesToDelete)" />
+    <MSBuild Projects="helixprep.proj"
+             Properties="BuildPath=%(XunitDlls.RootDir)%(XunitDlls.Directory);ProjectName=%(XunitDlls.Filename);BuildArchiveDir=$(TestWorkingDir)archive\tests\"
+             Targets="ArchiveBuild" />
+  </Target>
+
+  <!-- Zip Core_Root & Packages payload to send to Helix -->
+
+  <Target Name="ArchiveCoreRoot"
+    Inputs="$(CoreRootDir)"
+    Outputs="$(TestWorkingDir)archive\Core_Root" >
+    <MSBuild Projects="helixprep.proj"
+             Properties="BuildPath=$(CoreRootDir);ProjectName=$(CoreRootName);BuildArchiveDir=$(TestWorkingDir)archive\Core_Root\"
+             Targets="ArchiveBuild" />
+
+    <!-- Make dummy packages.zip to upload to Helix -->
+    <PropertyGroup>
+      <DummyDir>$(TestWorkingDir)\archive\dummy</DummyDir>
+      <DummyPackageDir>$(TestWorkingDir)\archive\packages</DummyPackageDir>
+    </PropertyGroup>
+
+    <MakeDir Directories="$(DummyDir)" />
+    <MakeDir Directories="$(DummyPackageDir)" />
+    <ZipFileCreateFromDirectory SourceDirectory="$(DummyDir)" DestinationArchive="$(DummyPackageDir)\Packages.zip" OverwriteDestination="true" />
+  </Target>
+
+  <!-- Generate wrapper .cmd file for an Xunit wrapper -->
+  <Target Name="GenerateWrapperCmd"
+    Condition="'$(RuntimeID)' == '' ">
+
+    <PropertyGroup>
+      <WrapperCmdContents>
+        <![CDATA[
+@ECHO OFF
+setlocal ENABLEDELAYEDEXPANSION
+pushd %~dp0
+
+set CORE_ROOT=%HELIX_CORRELATION_PAYLOAD%
+
+ECHO BEGIN EXECUTION
+ECHO %HELIX_CORRELATION_PAYLOAD%\CoreRun.exe %HELIX_WORKITEM_PAYLOAD%\xunit.console.netcore.exe %HELIX_WORKITEM_PAYLOAD%\$(ProjectName) -noshadow -xml testResults.xml -notrait category=outerloop -notrait category=failing
+%HELIX_CORRELATION_PAYLOAD%\CoreRun.exe %HELIX_WORKITEM_PAYLOAD%\xunit.console.netcore.exe %HELIX_WORKITEM_PAYLOAD%\$(ProjectName) -noshadow -xml testResults.xml -notrait category=outerloop -notrait category=failing
+
+echo Finished running tests. Exit code = %ERRORLEVEL%
+EXIT /B %ERRORLEVEL%
+
+        ]]>
+      </WrapperCmdContents>
+    </PropertyGroup>
+
+    <!-- Write the file -->
+    <WriteLinesToFile
+      File="$(BuildPath)\runtests.cmd"
+      Lines="$(WrapperCmdContents)"
+      Overwrite="true" />
+
+  </Target>
+
+  <Target Name="GenerateWrapperSh"
+    Condition="'$(RuntimeID)' != '' ">
+
+    <!-- Need to force in Unix line endings for Shell script -->
+    <PropertyGroup>
+      <WrapperShContents>#!/bin/sh%0a</WrapperShContents>
+      <WrapperShContents>$(WrapperShContents)%0a</WrapperShContents> 
+      <WrapperShContents>$(WrapperShContents)export CORE_ROOT="$HELIX_CORRELATION_PAYLOAD"%0a</WrapperShContents>
+      <WrapperShContents>$(WrapperShContents)%0a</WrapperShContents>
+      <WrapperShContents>$(WrapperShContents)for scriptFilePath in %24(find . -type f -iname '%2A.sh' ! -iname "runtests.sh" | sort)%0a</WrapperShContents>
+      <WrapperShContents>$(WrapperShContents)do%0a</WrapperShContents>
+      <WrapperShContents>$(WrapperShContents) perl -pi -e 's/\r\n|\n|\r/\n/g' "%24scriptFilePath"%0a</WrapperShContents>
+      <WrapperShContents>$(WrapperShContents)done%0a</WrapperShContents>
+      <WrapperShContents>$(WrapperShContents)%0a</WrapperShContents>
+      <WrapperShContents>$(WrapperShContents)echo BEGIN EXECUTION%0a</WrapperShContents>
+      <WrapperShContents>$(WrapperShContents)echo "%24{HELIX_CORRELATION_PAYLOAD}/corerun" %24HELIX_WORKITEM_PAYLOAD/xunit.console.netcore.exe %24HELIX_WORKITEM_PAYLOAD/$(ProjectName) -noshadow -xml testResults.xml -notrait category=outerloop -notrait category=failing%0a</WrapperShContents>
+      <WrapperShContents>$(WrapperShContents)"%24{HELIX_CORRELATION_PAYLOAD}/corerun" %24HELIX_WORKITEM_PAYLOAD/xunit.console.netcore.exe %24HELIX_WORKITEM_PAYLOAD/$(ProjectName) -noshadow -xml testResults.xml -notrait category=outerloop -notrait category=failing%0a</WrapperShContents>
+      <WrapperShContents>$(WrapperShContents)ErrorLevel=%24%3F%0a</WrapperShContents>
+      <WrapperShContents>$(WrapperShContents)%0a</WrapperShContents>
+      <WrapperShContents>$(WrapperShContents)echo Finished running tests. Exit code = %24ErrorLevel%0a</WrapperShContents>
+      <WrapperShContents>$(WrapperShContents)exit %24ErrorLevel%0a</WrapperShContents>
+
+    </PropertyGroup>
+
+    <!-- Write the file -->
+    <WriteLinesToFile
+      File="$(BuildPath)\runtests.sh"
+      Lines="$(WrapperShContents)"
+      Overwrite="true" />
+
+  </Target>
+
+  <!-- archive the test binaries along with some supporting files -->
+  <Target Name="ArchiveBuild">
+    <PropertyGroup Condition="'$(ProjectName)'==''">
+      <TestProjectName>$(MSBuildProjectName)</TestProjectName>
+    </PropertyGroup>
+
+    <!-- the project json and runner script files need to be included in the archive -->
+    <MakeDir Directories="$(BuildArchiveDir)" />
+    <ZipFileCreateFromDirectory SourceDirectory="$(BuildPath)" DestinationArchive="$(BuildArchiveDir)$(ProjectName).zip" OverwriteDestination="true" />
+  </Target>
+
+  <!-- Default target to run - builds executables & archives everything needed for Helix run -->
+
+  <Target Name="ArchiveAll" >
+    <MSBuild Projects="helixprep.proj"
+             Targets="GenerateWrapperExecutables;ArchiveTests;ArchiveCoreRoot" />
+  </Target>
+
+</Project>
\ No newline at end of file
diff --git a/tests/helixpublish.proj b/tests/helixpublish.proj
new file mode 100644
index 0000000000..aa967f1d48
--- /dev/null
+++ b/tests/helixpublish.proj
@@ -0,0 +1,67 @@
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  
+  <PropertyGroup>
+    <__BuildType>$(ConfigurationGroup)</__BuildType>
+  </PropertyGroup>
+
+  <Import Project="..\dir.props" />
+  <Import Project="$(ToolsDir)CloudTest.targets" Condition="Exists('$(ToolsDir)CloudTest.targets')" />
+
+  <!-- Define test payload & Correlation (Core_Root) payload -->
+  <ItemGroup>
+    <TestList Include="$(TestWorkingDir)\archive\tests\*" ></TestList>
+    <CoreRootUri Include="$(TestWorkingDir)\archive\Core_Root*\*.zip" ></CoreRootUri>
+    <DummyPackages Include="$(TestWorkingDir)\archive\packages\*" ></DummyPackages>
+    <ForUpload Include="@(TestList)" ></ForUpload>
+    <ForUpload Include="@(CoreRootUri)" ></ForUpload>
+    <SupplementalPayload Include="@(DummyPackages)" >
+      <RelativeBlobPath>$(Platform)$(ConfigurationGroup)/Packages.zip</RelativeBlobPath>
+    </SupplementalPayload>
+  </ItemGroup>
+
+  <!-- Define name & location of test JSON blob -->
+  <PropertyGroup>
+    <PayloadTestListFilename>Tests.$(ConfigurationGroup).json</PayloadTestListFilename>
+    <PayloadTestListFile>$(TestWorkingDir)$(PayloadTestListFilename)</PayloadTestListFile>
+    <SkipArchive>true</SkipArchive>
+  </PropertyGroup>
+
+  <Target Name="CreateTestListJson"
+          DependsOnTargets="CreateAzureStorage">
+
+    <!-- Define Correlation Payload as a property -->
+    <PropertyGroup>
+      <CoreRootUris>$(DropUri)$(Platform)$(ConfigurationGroup)/Tests/$([System.String]::Copy('%(RecursiveDir)').Replace('\', '/'))%(CoreRootUri.Filename)%(CoreRootUri.Extension)$(DropUriReadOnlyToken)</CoreRootUris>
+      <CorrelationPayloadProperty>$(CorrelationPayloadUris);$(CoreRootUris)</CorrelationPayloadProperty>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <TestList>
+        <Command Condition="'$(TargetsWindows)' == 'true'">$(HelixPythonPath) $(RunnerScript) --script %HELIX_WORKITEM_PAYLOAD%\runtests.cmd</Command>
+        <Command Condition="'$(TargetsWindows)' != 'true'">chmod +x $HELIX_WORKITEM_PAYLOAD/runtests.sh &amp;&amp; $(HelixPythonPath) $(RunnerScript) --script $HELIX_WORKITEM_PAYLOAD/runtests.sh</Command>
+        <CorrelationPayloadUris>[$(CorrelationPayloadProperty)]</CorrelationPayloadUris>
+        <PayloadUri>$(DropUri)$(Platform)$(ConfigurationGroup)/Tests/$([System.String]::Copy('%(RecursiveDir)').Replace('\', '/'))%(Filename)%(Extension)$(DropUriReadOnlyToken)</PayloadUri>
+        <WorkItemId>%(Filename)</WorkItemId>
+        <TimeoutInSeconds>$(TimeoutInSeconds)</TimeoutInSeconds>
+      </TestList>
+    </ItemGroup>
+    <WriteItemsToJson JsonFileName="$(PayloadTestListFile)" Items="@(TestList)" />
+    <!-- add test lists to the list of items for upload -->
+    <ItemGroup>
+      <ForUpload Include="$(PayloadTestListFile)">
+        <RelativeBlobPath>$(PayloadTestListFilename)</RelativeBlobPath>
+      </ForUpload>
+    </ItemGroup>
+    <!-- for completion event -->
+    <ItemGroup>
+      <TestListFile Include="$(PayloadTestListFile)">
+        <BuildCompleteJson>$(TestWorkingDir)$(OSPlatformConfig)/FuncBuildComplete.json</BuildCompleteJson>
+        <OfficialBuildJson>$(TestWorkingDir)$(OSPlatformConfig)/FuncOfficialBuild.json</OfficialBuildJson>
+        <HelixJobUploadCompletePath>$(TestWorkingDir)$(OSPlatformConfig)/helixjobuploadcomplete.sem</HelixJobUploadCompletePath>
+      </TestListFile>
+    </ItemGroup>
+  </Target>
+
+  <Target Name="Build" />
+
+</Project>
\ No newline at end of file
diff --git a/tests/issues.targets b/tests/issues.targets
index 632105c6c7..f24bc774c6 100644
--- a/tests/issues.targets
+++ b/tests/issues.targets
@@ -190,6 +190,9 @@
         <ExcludeList Include="$(XunitTestBinBase)\JIT\opt\perf\doublealign\Locals\*">
             <Issue>8418</Issue>
         </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\JitBlue\DevDiv_377155\DevDiv_377155\*">
+            <Issue>9282</Issue>
+        </ExcludeList>
     </ItemGroup>
 
     <!-- The following are x86 failures -->
@@ -392,4 +395,1347 @@
             <Issue>needs triage</Issue>
         </ExcludeList>
     </ItemGroup>
+
+    <!-- The following are tests that fail when building tests against packages -->
+
+    <ItemGroup Condition="'$(XunitTestBinBase)' != '' and '$(BuildTestsAgainstPackages)' == 'true'">
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\superpmi\superpmicollect\superpmicollect.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Performance\CodeQuality\BenchmarksGame\k-nucleotide\k-nucleotide\k-nucleotide.cmd">
+            <Issue>9314</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Performance\CodeQuality\BenchmarksGame\regexdna\regexdna\regexdna.cmd">
+            <Issue>9314</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Performance\CodeQuality\BenchmarksGame\revcomp\revcomp\revcomp.cmd">
+            <Issue>9314</Issue>
+        </ExcludeList>
+    </ItemGroup>
+
+    <!-- The following are tests that fail on non-Windows, which we must not run when building against packages -->
+
+    <ItemGroup Condition="'$(XunitTestBinBase)' != '' and '$(BuildTestsAgainstPackages)' == 'true' and '$(RuntimeID)' != ''">
+        <ExcludeList Include="$(XunitTestBinBase)\CoreMangLib\cti\system\byte\ByteToString3\ByteToString3.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\CoreMangLib\cti\system\convert\ConvertToInt32_4\ConvertToInt32_4.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\CoreMangLib\cti\system\decimal\DecimalToInt32\DecimalToInt32.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\CoreMangLib\cti\system\double\DoubleToString3\DoubleToString3.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\CoreMangLib\cti\system\double\DoubleToString4\DoubleToString4.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\CoreMangLib\cti\system\int64\Int64ToString3\Int64ToString3.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\CoreMangLib\cti\system\int\Int32ToString3\Int32ToString3.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\CoreMangLib\cti\system\multicastdelegate\MulticastDelegateCtor\MulticastDelegateCtor.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\CoreMangLib\cti\system\runtime\interopservices\marshal\MarshalGetLastWin32Error_PSC\MarshalGetLastWin32Error_PSC.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\CoreMangLib\cti\system\string\StringCompare15\StringCompare15.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\CoreMangLib\cti\system\string\StringCompare1\StringCompare1.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\CoreMangLib\cti\system\string\StringCompare2\StringCompare2.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\CoreMangLib\cti\system\uint16\UInt16ToString3\UInt16ToString3.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\CoreMangLib\cti\system\uint16\UInt16ToString4\UInt16ToString4.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\CoreMangLib\cti\system\uint32\UInt32ToString2\UInt32ToString2.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\CoreMangLib\system\collections\generic\hashset\Regression_Dev10_609271\Regression_Dev10_609271.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\CoreMangLib\system\collections\generic\hashset\Regression_Dev10_624201\Regression_Dev10_624201.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\GC\Coverage\271010\271010.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\GC\Coverage\smalloom\smalloom.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\GC\Features\BackgroundGC\foregroundgc\foregroundgc.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\GC\Features\LOHFragmentation\lohfragmentation\lohfragmentation.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\GC\Features\SustainedLowLatency\scenario\scenario.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\GC\LargeMemory\API\gc\collect\collect.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\GC\LargeMemory\API\gc\getgeneration\getgeneration.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\GC\LargeMemory\API\gc\reregisterforfinalize\reregisterforfinalize.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\GC\LargeMemory\Allocation\finalizertest\finalizertest.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\GC\LargeMemory\Allocation\largeexceptiontest\largeexceptiontest.cmd">
+            <Issue>3392</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\GC\LargeMemory\API\gc\gettotalmemory\gettotalmemory.cmd">
+            <Issue>3392</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\GC\LargeMemory\API\gc\keepalive\keepalive.cmd">
+            <Issue>3392</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\GC\LargeMemory\API\gc\suppressfinalize\suppressfinalize.cmd">
+            <Issue>3392</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\GC\Regressions\dev10bugs\536168\536168\536168.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\GC\Scenarios\BaseFinal\basefinal\basefinal.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\GC\Scenarios\DoublinkList\doublinknoleak\doublinknoleak.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\GC\Stress\Framework\ReliabilityFramework\ReliabilityFramework.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\Interop\MarshalAPI\GetNativeVariantForObject\GetNativeVariantForObject\GetNativeVariantForObject.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\Interop\MarshalAPI\GetObjectForNativeVariant\GetObjectForNativeVariant\GetObjectForNativeVariant.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\Interop\MarshalAPI\GetObjectsForNativeVariants\GetObjectsForNativeVariants\GetObjectsForNativeVariants.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\Interop\MarshalAPI\IUnknown\IUnknownTest\IUnknownTest.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\Interop\SizeConst\SizeConstTest\SizeConstTest.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\Interop\StructMarshalling\PInvoke\MarshalStructAsLayoutExp\MarshalStructAsLayoutExp.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\IL\PInvokeTail\PInvokeTail\PInvokeTail.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\IL\PInvokeTail\TailWinApi\TailWinApi.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\PREFIX\unaligned\1\arglist\arglist.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\PREFIX\unaligned\2\arglist\arglist.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\PREFIX\unaligned\4\arglist\arglist.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\PREFIX\volatile\1\arglist\arglist.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\RVAInit\extended\extended.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\RVAInit\overlap\overlap.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\StructABI\StructABI\StructABI.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\UnrollLoop\loop2_cs_d\loop2_cs_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\UnrollLoop\loop2_cs_do\loop2_cs_do.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\UnrollLoop\loop2_cs_r\loop2_cs_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\UnrollLoop\loop2_cs_ro\loop2_cs_ro.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\UnrollLoop\loop6_cs_d\loop6_cs_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\UnrollLoop\loop6_cs_do\loop6_cs_do.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\UnrollLoop\loop6_cs_r\loop6_cs_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\UnrollLoop\loop6_cs_ro\loop6_cs_ro.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\coverage\importer\Desktop\bleref_il_d\bleref_il_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\coverage\importer\Desktop\bleref_il_r\bleref_il_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\coverage\importer\Desktop\ldelemnullarr1_il_d\ldelemnullarr1_il_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\coverage\importer\Desktop\ldelemnullarr1_il_r\ldelemnullarr1_il_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\coverage\importer\Desktop\nonrefsdarr_il_d\nonrefsdarr_il_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\coverage\importer\Desktop\nonrefsdarr_il_r\nonrefsdarr_il_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\coverage\oldtests\Desktop\callipinvoke_il_d\callipinvoke_il_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\coverage\oldtests\Desktop\callipinvoke_il_r\callipinvoke_il_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\coverage\oldtests\callipinvoke\callipinvoke.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\intrinsic\interlocked\rva_rvastatic1\rva_rvastatic1.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\intrinsic\interlocked\rva_rvastatic2\rva_rvastatic2.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\intrinsic\interlocked\rva_rvastatic3\rva_rvastatic3.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\intrinsic\interlocked\rva_rvastatic4\rva_rvastatic4.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\pinning\object-pin\object-pin\object-pin.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\pinvoke\calli_excep\calli_excep.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\pinvoke\jump\jump.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\pinvoke\pinvoke-bug\pinvoke-bug.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\pinvoke\preemptive_cooperative\preemptive_cooperative.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\pinvoke\sin\sin.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\pinvoke\sysinfo_cs\sysinfo_cs.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\pinvoke\sysinfo_il\sysinfo_il.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\pinvoke\tail\tail.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\rvastatics\rvastatic1\rvastatic1.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\rvastatics\rvastatic2\rvastatic2.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\rvastatics\rvastatic3\rvastatic3.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\rvastatics\rvastatic4\rvastatic4.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\rvastatics\rvastatic5\rvastatic5.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\tls\mutualrecurthd-tls\mutualrecurthd-tls.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Directed\tls\test-tls\test-tls.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Generics\Fields\getclassfrommethodparam\getclassfrommethodparam.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Generics\pinvoke\instance01\instance01.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Generics\pinvoke\instance02\instance02.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Generics\pinvoke\instance03\instance03.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Generics\pinvoke\static01\static01.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Generics\pinvoke\static02\static02.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\Boxing\xlang\_dbgsin_cs_il\_dbgsin_cs_il.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\Boxing\xlang\_dbgsin_il_cs\_dbgsin_il_cs.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\Boxing\xlang\_dbgsin_il_il\_dbgsin_il_il.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\Boxing\xlang\_odbgsin_cs_il\_odbgsin_cs_il.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\Boxing\xlang\_odbgsin_il_cs\_odbgsin_il_cs.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\Boxing\xlang\_odbgsin_il_il\_odbgsin_il_il.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\Boxing\xlang\_orelsin_cs_il\_orelsin_cs_il.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\Boxing\xlang\_orelsin_il_cs\_orelsin_il_cs.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\Boxing\xlang\_orelsin_il_il\_orelsin_il_il.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\Boxing\xlang\_relsin_cs_il\_relsin_cs_il.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\Boxing\xlang\_relsin_il_cs\_relsin_il_cs.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\Boxing\xlang\_relsin_il_il\_relsin_il_il.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\Coverage\arglist_pos\arglist_pos.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\cctor\misc\global_il_d\global_il_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\cctor\misc\global_il_r\global_il_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\cctor\xassem\xprecise3_cs_d\xprecise3_cs_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\cctor\xassem\xprecise3_cs_do\xprecise3_cs_do.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\cctor\xassem\xprecise3_cs_r\xprecise3_cs_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\cctor\xassem\xprecise3_cs_ro\xprecise3_cs_ro.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\delegate\_XModuledeleg1_d\_XModuledeleg1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\delegate\_XModuledeleg1_do\_XModuledeleg1_do.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\delegate\_XModuledeleg1_r\_XModuledeleg1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\delegate\_XModuledeleg1_ro\_XModuledeleg1_ro.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\delegate\_XModuledeleg2_d\_XModuledeleg2_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\delegate\_XModuledeleg2_do\_XModuledeleg2_do.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\delegate\_XModuledeleg2_r\_XModuledeleg2_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\delegate\_XModuledeleg2_ro\_XModuledeleg2_ro.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\eh\deadcode\badcodeafterfinally_d\badcodeafterfinally_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\eh\deadcode\badcodeafterfinally_r\badcodeafterfinally_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_byte_1_d\expl_byte_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_byte_1_r\expl_byte_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_double_1_d\expl_double_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_double_1_r\expl_double_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_float_1_d\expl_float_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_float_1_r\expl_float_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_gc_byte_1_d\expl_gc_byte_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_gc_byte_1_r\expl_gc_byte_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_gc_double_1_d\expl_gc_double_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_gc_double_1_r\expl_gc_double_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_gc_float_1_d\expl_gc_float_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_gc_float_1_r\expl_gc_float_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_gc_int_1_d\expl_gc_int_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_gc_int_1_r\expl_gc_int_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_gc_long_1_d\expl_gc_long_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_gc_long_1_r\expl_gc_long_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_gc_obj_1_d\expl_gc_obj_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_gc_obj_1_r\expl_gc_obj_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_gc_short_1_d\expl_gc_short_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_gc_short_1_r\expl_gc_short_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_gc_val_1_d\expl_gc_val_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_gc_val_1_r\expl_gc_val_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_int_1_d\expl_int_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_int_1_r\expl_int_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_long_1_d\expl_long_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_long_1_r\expl_long_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_obj_1_d\expl_obj_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_obj_1_r\expl_obj_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_short_1_d\expl_short_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_short_1_r\expl_short_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_val_1_d\expl_val_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\expl_val_1_r\expl_val_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_byte_1_d\seq_byte_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_byte_1_r\seq_byte_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_double_1_d\seq_double_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_double_1_r\seq_double_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_float_1_d\seq_float_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_float_1_r\seq_float_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_gc_byte_1_d\seq_gc_byte_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_gc_byte_1_r\seq_gc_byte_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_gc_double_1_d\seq_gc_double_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_gc_double_1_r\seq_gc_double_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_gc_float_1_d\seq_gc_float_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_gc_float_1_r\seq_gc_float_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_gc_int_1_d\seq_gc_int_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_gc_int_1_r\seq_gc_int_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_gc_long_1_d\seq_gc_long_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_gc_long_1_r\seq_gc_long_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_gc_obj_1_d\seq_gc_obj_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_gc_obj_1_r\seq_gc_obj_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_gc_short_1_d\seq_gc_short_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_gc_short_1_r\seq_gc_short_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_gc_val_1_d\seq_gc_val_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_gc_val_1_r\seq_gc_val_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_int_1_d\seq_int_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_int_1_r\seq_int_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_long_1_d\seq_long_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_long_1_r\seq_long_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_obj_1_d\seq_obj_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_obj_1_r\seq_obj_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_short_1_d\seq_short_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_short_1_r\seq_short_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_val_1_d\seq_val_1_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\explicit\coverage\seq_val_1_r\seq_val_1_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\refany\_dbgstress1\_dbgstress1.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\refany\_dbgstress3\_dbgstress3.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\refany\_il_dbgseq\_il_dbgseq.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\refany\_il_relseq\_il_relseq.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\refany\_relstress1\_relstress1.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\refany\_relstress3\_relstress3.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\refany\_speed_dbgstress1\_speed_dbgstress1.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\refany\_speed_dbgstress3\_speed_dbgstress3.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\refany\_speed_relstress1\_speed_relstress1.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\refany\_speed_relstress3\_speed_relstress3.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\tailcall\_il_dbgpointer\_il_dbgpointer.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\tailcall\_il_dbgpointer_i\_il_dbgpointer_i.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\tailcall\_il_relpointer\_il_relpointer.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\tailcall\_il_relpointer_i\_il_relpointer_i.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\varargs\callconv\gc_ctor_il_d\gc_ctor_il_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\varargs\callconv\gc_ctor_il_r\gc_ctor_il_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\varargs\callconv\val_ctor_il_d\val_ctor_il_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\varargs\callconv\val_ctor_il_r\val_ctor_il_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\varargs\misc\Dev10_615402\Dev10_615402.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\varargs\seh\fault_il_d\fault_il_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\varargs\seh\fault_il_r\fault_il_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\varargs\seh\filter_il_d\filter_il_d.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\varargs\seh\filter_il_r\filter_il_r.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\xxobj\operand\_il_dbglocalloc\_il_dbglocalloc.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Methodical\xxobj\operand\_il_rellocalloc\_il_rellocalloc.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-EJIT\V1-M12-Beta2\b26323\b26323\b26323.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-EJIT\v1-m10\b07847\b07847\b07847.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1-M09.5-PDC\b16423\b16423\b16423.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1-M09.5-PDC\b26324\b26324a\b26324a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1-M09.5-PDC\b26324\b26324b\b26324b.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1-M09.5-PDC\b28901\b28901\b28901.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1-M09.5-PDC\b30838\b30838\b30838.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1-M09.5-PDC\b30864\b30864\b30864.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1-M09.5-PDC\b32374\b32374\b32374.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1-M11-Beta1\b35784\b35784\b35784.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1-M11-Beta1\b36472\b36472\b36472.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1-M11-Beta1\b37598\b37598\b37598.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1-M11-Beta1\b41391\b41391\b41391.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1-M11-Beta1\b46867\b46867\b46867.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1-M11-Beta1\b49644\b49644\b49644.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1-M12-Beta2\b31745\b31745\b31745.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1-M12-Beta2\b31746\b31746\b31746.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1-M12-Beta2\b37646\b37646\b37646.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1-M12-Beta2\b41852\b41852\b41852.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1-M12-Beta2\b66533\b66533\b66533.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1-M12-Beta2\b79250\b79250\b79250.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1-M13-RTM\b88793\b88793\b88793.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1-M13-RTM\b91248\b91248\b91248.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1.2-Beta1\b102637\b102637\b102637.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1.2-M01\b03689\b03689\b03689.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1.2-M01\b07493\b07493\b07493.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1.2-M01\b08046\b08046\b08046.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V1.2-M02\b20785\b20785\b20785.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V2.0-Beta2\b409748\b409748\b409748.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\CLR-x86-JIT\V2.0-Beta2\b427411\Desktop\b427411\b427411.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\Dev11\dev10_865840\dev10_865840\dev10_865840.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\VS-ia64-JIT\V1.2-Beta1\b302509\b302509\b302509.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\VS-ia64-JIT\V1.2-M01\b15632\b15632\b15632.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\VS-ia64-JIT\V1.2-M02\b12011\b12011\b12011.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\VS-ia64-JIT\V2.0-Beta2\b410474\b410474\b410474.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\VS-ia64-JIT\V2.0-RTM\b286991\b286991\b286991.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\clr-x64-JIT\v2.1\b173569\b173569\b173569.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\clr-x64-JIT\v4.0\devdiv374539\DevDiv_374539\DevDiv_374539.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\gc\misc\funclet\funclet.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\localloc\verify\verify01_dynamic\verify01_dynamic.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\localloc\verify\verify01_large\verify01_large.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\localloc\verify\verify01_small\verify01_small.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i00\mcc_i00.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i01\mcc_i01.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i02\mcc_i02.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i03\mcc_i03.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i04\mcc_i04.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i05\mcc_i05.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i06\mcc_i06.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i07\mcc_i07.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i10\mcc_i10.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i11\mcc_i11.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i12\mcc_i12.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i13\mcc_i13.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i14\mcc_i14.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i15\mcc_i15.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i16\mcc_i16.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i17\mcc_i17.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i30\mcc_i30.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i31\mcc_i31.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i32\mcc_i32.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i33\mcc_i33.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i34\mcc_i34.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i35\mcc_i35.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i36\mcc_i36.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i37\mcc_i37.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i50\mcc_i50.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i51\mcc_i51.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i52\mcc_i52.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i53\mcc_i53.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i54\mcc_i54.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i55\mcc_i55.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i56\mcc_i56.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i57\mcc_i57.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i60\mcc_i60.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i61\mcc_i61.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i62\mcc_i62.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i63\mcc_i63.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i64\mcc_i64.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i65\mcc_i65.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i66\mcc_i66.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i67\mcc_i67.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i70\mcc_i70.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i71\mcc_i71.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i72\mcc_i72.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i73\mcc_i73.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i74\mcc_i74.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i75\mcc_i75.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i76\mcc_i76.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i77\mcc_i77.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i80\mcc_i80.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i81\mcc_i81.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i82\mcc_i82.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i83\mcc_i83.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i84\mcc_i84.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i85\mcc_i85.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i86\mcc_i86.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\mcc\interop\mcc_i87\mcc_i87.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\regress\ndpw\21220\b21220\b21220.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\jit64\regress\vsw\286991\test\test.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\opt\Inline\tests\security\security.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\opt\Inline\tests\xmodb\xmodb.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\opt\Tailcall\TailcallVerifyWithPrefix\TailcallVerifyWithPrefix.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\JIT\opt\perf\doublealign\Locals\Locals.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\Loader\NativeLibs\FromNativePaths\FromNativePaths.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\Loader\classloader\TypeGeneratorTests\TypeGeneratorTest612\Generated612\Generated612.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\Loader\classloader\TypeGeneratorTests\TypeGeneratorTest613\Generated613\Generated613.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\Loader\classloader\TypeGeneratorTests\TypeGeneratorTest614\Generated614\Generated614.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\Loader\classloader\TypeGeneratorTests\TypeGeneratorTest681\Generated681\Generated681.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\Loader\classloader\TypeGeneratorTests\TypeGeneratorTest682\Generated682\Generated682.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\Loader\classloader\TypeGeneratorTests\TypeGeneratorTest683\Generated683\Generated683.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\Regressions\coreclr\0584\Test584\Test584.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\exceptions\regressions\Dev11\147911\test147911\test147911.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\exceptions\regressions\V1\SEH\VJ\UnmanagedToManaged\UnmanagedToManaged.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\commitstackonlyasneeded\DefaultStackCommit\DefaultStackCommit.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\interlocked\compareexchange\compareexchangetneg\compareexchangetneg.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\monitor\pulse\monitorpulse02\monitorpulse02.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\monitor\tryenter\negativetestharness\negativetestharness.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\mutex\abandonedmutex\am04waitany\am04waitany.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\mutex\abandonedmutex\am05waitanymutex\am05waitanymutex.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\mutex\abandonedmutex\am06abandonall\am06abandonall.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\mutex\abandonedmutex\am07abandonmultiplemutex\am07abandonmultiplemutex.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\mutex\abandonedmutex\am08mixedarray\am08mixedarray.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\mutex\abandonedmutex\am09threadabort\am09threadabort.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\mutex\openexisting\openmutexneg1\openmutexneg1.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\mutex\openexisting\openmutexneg2\openmutexneg2.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\mutex\openexisting\openmutexneg3\openmutexneg3.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\mutex\openexisting\openmutexneg4\openmutexneg4.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\mutex\openexisting\openmutexneg5\openmutexneg5.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\mutex\openexisting\openmutexneg6\openmutexneg6.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\mutex\openexisting\openmutexneg7\openmutexneg7.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\mutex\openexisting\openmutexneg8\openmutexneg8.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\mutex\openexisting\openmutexpos1\openmutexpos1.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\mutex\openexisting\openmutexpos2\openmutexpos2.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\mutex\openexisting\openmutexpos3\openmutexpos3.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\mutex\openexisting\openmutexpos4\openmutexpos4.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\paramthreadstart\ThreadStartString_1\ThreadStartString_1.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\readerwriterlockslim\ensurelockordering\ensurelockordering.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\regressions\135972\oswaitinlock\oswaitinlock.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\regressions\135972\oswaitinsleep\oswaitinsleep.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\regressions\beta1\322338\322338.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\regressions\beta2\417296_abort\417296_abort.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\regressions\m2\91848\91848.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\regressions\m2\tastaticconst\tastaticconst.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\regressions\whidbey_m3\105019\105019.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\semaphore\ctoropen\semaphorector2\semaphorector2.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\semaphore\ctoropen\semaphorector3\semaphorector3.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\semaphore\ctoropen\semaphorector4\semaphorector4.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\semaphore\ctoropen\semaphorector5\semaphorector5.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\semaphore\ctoropen\semaphoreopenneg1\semaphoreopenneg1.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\semaphore\ctoropen\semaphoreopenneg2\semaphoreopenneg2.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\semaphore\ctoropen\semaphoreopenneg3\semaphoreopenneg3.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\semaphore\ctoropen\semaphoreopenneg4\semaphoreopenneg4.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\semaphore\ctoropen\semaphoreopenneg5\semaphoreopenneg5.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\semaphore\ctoropen\semaphoreopenneg6\semaphoreopenneg6.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\semaphore\ctoropen\semaphoreopenneg7\semaphoreopenneg7.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\semaphore\unit\semtest\semtest.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\exceptioninfinally\argumentexception\argumentexception.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\exceptioninfinally\dividebyzero\dividebyzero.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\exceptioninfinally\nullrefexception\nullrefexception.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\rudeposnonhosted\rudenonhostedone\rudenonhostedone.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\rudeposnonhosted\rudenonhostedthree\rudenonhostedthree.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\rudeposnonhosted\rudenonhostedtwo\rudenonhostedtwo.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\rudethreadpool\rudeabortrepeat\rudeabortrepeat.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta001a\ta001a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta001b\ta001b.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta002a\ta002a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta002b\ta002b.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta003a\ta003a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta003b\ta003b.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta004a\ta004a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta004b\ta004b.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta005a\ta005a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta005b\ta005b.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta006a\ta006a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta007a\ta007a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta007b\ta007b.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta008a\ta008a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta009a\ta009a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta010a\ta010a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta011a\ta011a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta012a\ta012a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta012b\ta012b.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta013a\ta013a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta014a\ta014a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta015a\ta015a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta016a\ta016a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta017a\ta017a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta017b\ta017b.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta018a\ta018a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta019a\ta019a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\ta020a\ta020a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\threadabort\threadabort.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadabort\tasuite\threadstarttwice\threadstarttwice.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadpool\bindhandle\bindhandle1\bindhandle1.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadpool\bindhandle\bindhandleinvalid3\bindhandleinvalid3.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadpool\bindhandle\bindhandleinvalid4\bindhandleinvalid4.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadpool\bindhandle\bindhandleinvalid5\bindhandleinvalid5.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadpool\bindhandle\bindhandleinvalid6\bindhandleinvalid6.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\threadpool\bindhandle\bindhandleinvalid\bindhandleinvalid.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\volatile\atomictest\atomictest.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\abandonedmutexscenarios\threadabort\threadabort.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitall\waitallex10\waitallex10.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitall\waitallex11\waitallex11.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitall\waitallex1\waitallex1.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitall\waitallex2\waitallex2.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitall\waitallex3\waitallex3.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitall\waitallex4\waitallex4.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitall\waitallex5\waitallex5.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitall\waitallex6\waitallex6.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitall\waitallex7\waitallex7.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitall\waitallex8\waitallex8.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitall\waitallex8a\waitallex8a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitall\waitallex9\waitallex9.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitany\waitanyex10\waitanyex10.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitany\waitanyex1\waitanyex1.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitany\waitanyex2\waitanyex2.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitany\waitanyex3\waitanyex3.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitany\waitanyex4\waitanyex4.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitany\waitanyex5\waitanyex5.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitany\waitanyex6\waitanyex6.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitany\waitanyex7\waitanyex7.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitany\waitanyex8\waitanyex8.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitany\waitanyex8a\waitanyex8a.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitany\waitanyex9\waitanyex9.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitone\waitoneex1\waitoneex1.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitone\waitoneex2\waitoneex2.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitone\waitoneex3\waitoneex3.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\baseservices\threading\waithandle\waitone\waitoneex4\waitoneex4.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)\managed\Compilation\Compilation\Compilation.cmd">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
+    </ItemGroup>
+    
 </Project>
diff --git a/tests/longRunningGcTests.txt b/tests/longRunningGcTests.txt
index 0c31ec9f82..9a38363ee0 100644
--- a/tests/longRunningGcTests.txt
+++ b/tests/longRunningGcTests.txt
@@ -8,3 +8,4 @@ GC/Features/PartialCompaction/partialcompactionwloh/partialcompactionwloh.sh
 GC/Features/SustainedLowLatency/sustainedlowlatency_race_reverse/sustainedlowlatency_race_reverse.sh
 GC/Features/SustainedLowLatency/sustainedlowlatency_race/sustainedlowlatency_race.sh
 GC/Regressions/v2.0-beta2/462651/462651/462651.sh
+GC/Coverage/delete_next_card_table/delete_next_card_table.sh
diff --git a/tests/publishdependency.targets b/tests/publishdependency.targets
index 9e286fc3ba..f9b1321698 100644
--- a/tests/publishdependency.targets
+++ b/tests/publishdependency.targets
@@ -42,7 +42,6 @@
   <PropertyGroup>
     <ProductDestination>$(ProjectDir)\..\bin\Product\$(BuildOS).$(BuildArch).$(BuildType)</ProductDestination>
     <RefDestination>$(ProductDestination)\ref</RefDestination>
-    <CoreOverlay>$(CORE_ROOT)\..\coreoverlay</CoreOverlay>
   </PropertyGroup>
 
   <Target Name="CopyDependecyToCoreRoot"
@@ -92,7 +91,7 @@
 
   <Target Name="CopyNonWindowsDependecyToCoreRoot"
     Inputs="@(NonWindowsProjectLockJsonFiles)"
-    Outputs="$(CoreOverlay)\*.*">
+    Outputs="$(CORE_OVERLAY)\*.*">
 
     <MSBuild Projects="$(SourceDir)Common\test_runtime\test_runtime.csproj"/>
 
@@ -114,7 +113,7 @@
       <Output TaskParameter="ResolvedCopyLocalItems" ItemName="RunTimeCopyLocal" />
     </PrereleaseResolveNuGetPackageAssets>
     <ItemGroup>
-      <RunTimeDependecyExclude Include="$(CoreOverlay)\**\*.*"  />
+      <RunTimeDependecyExclude Include="$(CORE_OVERLAY)\**\*.*"  />
       <RunTimeDependecyExcludeFiles Include="@(RunTimeDependecyExclude -> '%(FileName)%(Extension)')" />
       <RunTimeDependecyExcludeFiles Include="@(RunTimeDependecyExclude -> '%(FileName).ni%(Extension)')" />
       <RunTimeDependecyExcludeFiles Include="@(RunTimeDependecyExclude -> '%(FileName).pdb')" />
@@ -127,7 +126,7 @@
     
     <Copy
       SourceFiles="@(RunTimeDependecyCopyLocal)"
-      DestinationFolder="$(CoreOverlay)"
+      DestinationFolder="$(CORE_OVERLAY)"
       SkipUnchangedFiles="$(SkipCopyUnchangedFiles)"
       OverwriteReadOnlyFiles="$(OverwriteReadOnlyFiles)"
       Retries="$(CopyRetryCount)"
@@ -142,7 +141,7 @@
 
     <Copy
       SourceFiles="@(NonWindowsCrossGenFiles)"
-      DestinationFolder="$(CoreOverlay)"
+      DestinationFolder="$(CORE_OVERLAY)"
       SkipUnchangedFiles="$(SkipCopyUnchangedFiles)"
       OverwriteReadOnlyFiles="$(OverwriteReadOnlyFiles)"
       Retries="$(CopyRetryCount)"
@@ -218,7 +217,7 @@
   </Target>
 
   <Target Name="CopyCrossgenToProduct"
-    Outputs="$(ProductDestination)\crossgen.exe;$(CoreOverlay)\crossgen.exe">
+    Outputs="$(ProductDestination)\crossgen.exe;$(CORE_OVERLAY)\crossgen.exe">
 
     <Copy
       SourceFiles="@(CrossGenFiles)"
diff --git a/tests/runparallel.sh b/tests/runparallel.sh
new file mode 100755
index 0000000000..697d3a0019
--- /dev/null
+++ b/tests/runparallel.sh
@@ -0,0 +1,213 @@
+#!/usr/bin/env bash
+
+function print_usage {
+    echo ''
+    echo 'CoreCLR parallel test runner script.'
+    echo ''
+    echo 'Required arguments:'
+    echo '  --testRootDir=<path>             : Root directory of the test build (e.g. coreclr/bin/tests/Windows_NT.x64.Debug).'
+    echo '  --coreOverlayDir=<path>          : Directory containing core binaries and test dependencies. If not specified, the'
+    echo '                                     default is testRootDir/Tests/coreoverlay. This switch overrides --coreClrBinDir,'
+    echo '                                     --mscorlibDir, --coreFxBinDir, and --coreFxNativeBinDir.'
+    echo '  --playlist=<path>                : Run only the tests that are specified in the file at <path>, in the same format as'
+    echo ''
+    echo 'Optional arguments:'
+    echo '  -h|--help                        : Show usage information.'
+    echo '  --test-env                       : Script to set environment variables for tests'
+    echo ''
+}
+
+function print_results {
+    echo -e \
+       "Results @ $(date +%r)\n\t"\
+       "Pass:$countPassedTests\t"\
+       "Fail:$countFailedTests\n\t"\
+       "Finish:$countFinishedTests\t"\
+       "Incomplete: $countIncompleteTests\n\t"\
+       "Total: $countTotalTests"
+}
+
+function update_results {
+    # Initialize counters for bookkeeping.
+    countTotalTests=$(wc -l < $playlistFile)
+
+    countFinishedTests=$(cd results.int; grep -r 'RUN_TEST_EXIT_CODE' . | wc -l)
+    countPassedTests=$(cd results.int; grep -r 'RUN_TEST_EXIT_CODE=0' . | wc -l)
+    countFailedTests=$((countFinishedTests - countPassedTests))
+    countIncompleteTests=$((countTotalTests - countFinishedTests))
+
+    print_results
+}
+
+function print_elapsed_time {
+    time_end=$(date +"%s")
+    time_diff=$(($time_end-$time_start))
+    echo "$(($time_diff / 60)) minutes and $(($time_diff % 60)) seconds taken to run CoreCLR tests."
+}
+
+
+
+# Handle Ctrl-C. We will stop execution and print the results that
+# we gathered so far.
+function handle_ctrl_c {
+    local errorSource='handle_ctrl_c'
+
+    echo ""
+    echo "*** Stopping... ***"
+
+    update_results
+    echo "$errorSource" "Test run aborted by Ctrl+C."
+
+    print_elapsed_time
+
+    exit 1
+}
+
+function cleanup
+{
+    kill -TERM % >/dev/null
+    mv results.int results.$(date +%F_%I%M%p)
+}
+
+
+prep_test() {
+    # This function runs in a background process. It should not echo anything, and should not use global variables.
+
+    #remove any NI
+    rm -f $(dirname "$1")/*.ni.*
+}
+
+run_test() {
+    # This function runs in a background process. It should not echo anything, and should not use global variables.
+
+    local scriptFilePath=$1
+
+    local scriptFileName=$(basename "$scriptFilePath")
+    local outputFileName=$PWD/results.int/${scriptFilePath////.}
+
+    nice "$scriptFilePath" -debug=$(which time) >"$outputFileName" 2>&1
+
+    echo RUN_TEST_EXIT_CODE="$?" >>"$outputFileName"
+}
+
+# Argument variables
+testRootDir=
+coreOverlayDir=
+testEnv=
+playlistFile=
+
+for i in "$@"
+do
+    case $i in
+        -h|--help)
+            print_usage
+            exit $EXIT_CODE_SUCCESS
+            ;;
+        --coreOverlayDir=*)# Exit code constants
+            coreOverlayDir=${i#*=}
+            ;;
+        --playlist=*)
+            playlistFile=${i#*=}
+            ;;
+        --testRootDir=*)
+            testRootDir=${i#*=}
+            ;;
+        --test-env=*)
+            testEnv=${i#*=}
+            ;;
+        *)
+            echo "Unknown switch: $i"
+            print_usage
+            exit $EXIT_CODE_SUCCESS
+            ;;
+    esac
+done
+
+if [ -z "$coreOverlayDir" ]; then
+    echo "--coreOverlayDir is required."
+    print_usage
+    exit $EXIT_CODE_EXCEPTION
+fi
+
+if [ ! -d "$coreOverlayDir" ]; then
+    echo "Directory specified by --coreOverlayDir does not exist: $coreOverlayDir"
+    exit $EXIT_CODE_EXCEPTION
+fi
+
+if [ -z "$playlistFile" ]; then
+    echo "--playlist is required."
+    print_usage
+    exit $EXIT_CODE_EXCEPTION
+fi
+
+if [ ! -e "$playlistFile" ]; then
+    echo "File specified by --playlist does not exist: $playlistFile"
+    exit $EXIT_CODE_EXCEPTION
+fi
+
+if [ -z "$testRootDir" ]; then
+    echo "--testRootDir is required."
+    print_usage
+    exit $EXIT_CODE_EXCEPTION
+fi
+
+if [ ! -d "$testRootDir" ]; then
+    echo "Directory specified by --testRootDir does not exist: $testRootDir"
+    exit $EXIT_CODE_EXCEPTION
+fi
+
+if [ ! -z "$testEnv" ] && [ ! -e "$testEnv" ]; then
+    echo "File specified by --playlist does not exist: $testEnv"
+    exit $EXIT_CODE_EXCEPTION
+fi
+
+export CORE_ROOT="$coreOverlayDir"
+export __TestEnv=$testEnv
+
+
+# Variables for running tests in the background
+if [ `uname` = "NetBSD" ]; then
+    NumProc=$(getconf NPROCESSORS_ONLN)
+else
+    NumProc=$(getconf _NPROCESSORS_ONLN)
+fi
+
+export TIME='<Command time="%U %S %e" mem="%M %t %K" swap="%W %c %w" fault="%F %R %k %r %s" IO="%I %O" exit="%x"/>'
+
+export -f prep_test
+export -f run_test
+
+cd $testRootDir
+time_start=$(date +"%s")
+
+rm -rf results.int/* results.int
+
+echo "Prepping tests $(date +%r)"
+xargs -d "\n" -P $NumProc -I{} bash -c prep_test  {} < $playlistFile
+
+
+trap cleanup EXIT
+mkdir results.int
+echo $$ > results.int/pid
+cp $testEnv results.int
+
+trap handle_ctrl_c INT TERM
+
+xargs -d "\n" -P $NumProc -I{} bash -c 'run_test "{}" >/dev/null 2>&1' < $playlistFile &
+
+while true
+do
+    update_results
+    sleep 20 &
+    wait -n %
+    if (( $(jobs %xargs 2>/dev/null | wc -l) == 0 )) ;
+    then
+        break
+    fi
+
+    jobs -p > /dev/null
+done
+
+update_results
+
+print_elapsed_time
diff --git a/tests/runtest.cmd b/tests/runtest.cmd
index 23b4bb5f42..cfe2c3db41 100644
--- a/tests/runtest.cmd
+++ b/tests/runtest.cmd
@@ -24,9 +24,6 @@ set "__ProjectFilesDir=%__ProjectDir%"
 set "__RootBinDir=%__ProjectDir%\..\bin"
 set "__LogsDir=%__RootBinDir%\Logs"
 
-:: Default __Exclude to issues.targets
-set __Exclude0=%~dp0\issues.targets
-
 set __Sequential=
 set __msbuildExtraArgs=
 set __LongGCTests=
@@ -55,9 +52,6 @@ if /i "%1" == "checked"               (set __BuildType=Checked&shift&goto Arg_Lo
 if /i "%1" == "vs2013"                (set __VSVersion=%1&shift&goto Arg_Loop)
 if /i "%1" == "vs2015"                (set __VSVersion=%1&shift&goto Arg_Loop)
 
-if /i "%1" == "SkipWrapperGeneration" (set __SkipWrapperGeneration=true&shift&goto Arg_Loop)
-if /i "%1" == "Exclude"               (set __Exclude=%2&shift&shift&goto Arg_Loop)
-if /i "%1" == "Exclude0"              (set __Exclude0=%2&shift&shift&goto Arg_Loop)
 if /i "%1" == "TestEnv"               (set __TestEnv=%2&shift&shift&goto Arg_Loop)
 if /i "%1" == "AgainstPackages"       (set __AgainstPackages=1&shift&goto Arg_Loop)
 if /i "%1" == "sequential"            (set __Sequential=1&shift&goto Arg_Loop)
@@ -69,8 +63,8 @@ if /i "%1" == "jitstressregs"         (set COMPlus_JitStressRegs=%2&shift&shift&
 if /i "%1" == "jitminopts"            (set COMPlus_JITMinOpts=1&shift&shift&goto Arg_Loop)
 if /i "%1" == "jitforcerelocs"        (set COMPlus_ForceRelocs=1&shift&shift&goto Arg_Loop)
 if /i "%1" == "jitdisasm"             (set __JitDisasm=1&shift&goto Arg_Loop)
-if /i "%1" == "GenerateLayoutOnly"    (set __GenerateLayoutOnly=1&set __SkipWrapperGeneration=true&shift&goto Arg_Loop)
-if /i "%1" == "PerfTests"             (set __PerfTests=true&set __SkipWrapperGeneration=true&shift&goto Arg_Loop)
+if /i "%1" == "GenerateLayoutOnly"    (set __GenerateLayoutOnly=1&shift&goto Arg_Loop)
+if /i "%1" == "PerfTests"             (set __PerfTests=true&shift&goto Arg_Loop)
 if /i "%1" == "runcrossgentests"      (set RunCrossGen=true&shift&goto Arg_Loop)
 REM change it to COMPlus_GCStress when we stop using xunit harness
 if /i "%1" == "gcstresslevel"         (set __GCSTRESSLEVEL=%2&set __TestTimeout=1800000&shift&shift&goto Arg_Loop)
@@ -170,7 +164,6 @@ xcopy /s "%__BinDir%" "%CORE_ROOT%"
 :SkipCoreRootSetup
 
 
-if defined __Exclude (if not exist %__Exclude% echo %__MsgPrefix%Error: Exclusion file %__Exclude% not found && exit /b 1)
 if defined __TestEnv (if not exist %__TestEnv% echo %__MsgPrefix%Error: Test Environment script %__TestEnv% not found && exit /b 1)
 
 REM These log files are created automatically by the test run process. Q: what do they depend on being set?
@@ -179,13 +172,6 @@ set __TestRunXmlLog=%__LogsDir%\TestRun_%__BuildOS%__%__BuildArch%__%__BuildType
 
 
 if "%__PerfTests%"=="true" goto RunPerfTests
-if "%__SkipWrapperGeneration%"=="true" goto SkipWrapperGeneration
-
-set __BuildLogRootName=Tests_XunitWrapper
-call :msbuild "%__ProjectFilesDir%\runtest.proj" /p:BuildWrappers=true
-if errorlevel 1 exit /b 1
-
-:SkipWrapperGeneration
 
 call :ResolveDependecies
 
@@ -385,6 +371,7 @@ if errorlevel 1 (
     exit /b 1
 )
 echo %__MsgPrefix%Created the runtime layout with all dependencies in %CORE_ROOT%
+
 exit /b 0
 
 
@@ -392,16 +379,12 @@ exit /b 0
 :Usage
 echo.
 echo Usage:
-echo   %0 BuildArch BuildType [SkipWrapperGeneration] [Exclude EXCLUSION_TARGETS] [TestEnv TEST_ENV_SCRIPT] [VSVersion] CORE_ROOT
+echo   %0 BuildArch BuildType [TestEnv TEST_ENV_SCRIPT] [VSVersion] CORE_ROOT
 echo where:
 echo.
 echo./? -? /h -h /help -help: view this message.
 echo BuildArch- Optional parameter - x64 or x86 ^(default: x64^).
 echo BuildType- Optional parameter - Debug, Release, or Checked ^(default: Debug^).
-echo SkipWrapperGeneration- Optional parameter - this will run the same set of tests as the last time it was run
-echo Exclude0- Optional parameter - specify location of default exclusion file (defaults to issues.targets if not specified)
-echo                                Set to "" to disable default exclusion file.
-echo Exclude-  Optional parameter - this will exclude individual tests from running, specified by ExcludeList ItemGroup in an .targets file.
 echo TestEnv- Optional parameter - this will run a custom script to set custom test environment settings.
 echo VSVersion- Optional parameter - VS2013 or VS2015 ^(default: VS2015^)
 echo AgainstPackages - Optional parameter - this indicates that we are running tests that were built against packages
diff --git a/tests/runtest.proj b/tests/runtest.proj
index acc4545d92..45f2bb7702 100644
--- a/tests/runtest.proj
+++ b/tests/runtest.proj
@@ -44,12 +44,10 @@
 
   </Target>
 
-
-  <Import Project="$(__Exclude0)" Condition="'$(__Exclude0)' != '' AND '$(XunitTestBinBase)' != ''" /> 
   <Import Project="$(__Exclude)" Condition="'$(__Exclude)' != '' AND '$(XunitTestBinBase)' != ''" /> 
   <PropertyGroup>
     <HaveExcludes>False</HaveExcludes>
-    <HaveExcludes Condition="('$(__Exclude0)' != '') Or ('$(__Exclude)' != '')">True</HaveExcludes>
+    <HaveExcludes Condition="'$(__Exclude)' != ''">True</HaveExcludes>
   </PropertyGroup>
 
   <Target Name="CreateXunitWrapper" DependsOnTargets="CreateXunitFacts">
@@ -77,8 +75,8 @@ $(_XunitEpilog)
     <SchemaVersion>2.0</SchemaVersion>
     <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
     <OutputType>Library</OutputType>
-    <TargetFrameworkIdentifier>.NETFramework</TargetFrameworkIdentifier>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <TargetFrameworkIdentifier Condition ="'$(BuildTestsAgainstPackages)' != 'true'">.NETFramework</TargetFrameworkIdentifier>
+    <TargetFrameworkVersion Condition ="'$(BuildTestsAgainstPackages)' != 'true'">v4.5</TargetFrameworkVersion>
     <IsXunitWrapperProject>true</IsXunitWrapperProject>
     <SkipSigning>true</SkipSigning>
     <AppDesignerFolder>Properties</AppDesignerFolder>
@@ -88,8 +86,8 @@ $(_XunitEpilog)
     <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
     <CLRTestKind>BuildOnly</CLRTestKind>
     <IsTestProject>true</IsTestProject>
-    <ProjectJson>%24(TestWrappersPackagesConfigFileDirectory)project.json</ProjectJson>
-    <ProjectLockJson>%24(TestWrappersPackagesConfigFileDirectory)project.lock.json</ProjectLockJson>
+    <ProjectJson Condition="'$(BuildTestsAgainstPackages)' != 'true'">%24(TestWrappersPackagesConfigFileDirectory)project.json</ProjectJson>
+    <ProjectLockJson Condition="'$(BuildTestsAgainstPackages)' != 'true'">%24(TestWrappersPackagesConfigFileDirectory)project.lock.json</ProjectLockJson>
   </PropertyGroup>
   <!-- Default configurations to help VS understand the configurations -->
   <PropertyGroup Condition=" '%24(Configuration)|%24(Platform)' == 'Debug|AnyCPU' ">
@@ -103,7 +101,11 @@ $(_XunitEpilog)
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
    <ItemGroup>
-    <ProjectReference Include="$(SourceDir)Common\Desktop.Coreclr.TestWrapper\Desktop.Coreclr.TestWrapper.csproj">
+    <ProjectReference Include="$(SourceDir)Common\Desktop.Coreclr.TestWrapper\Desktop.Coreclr.TestWrapper.csproj" Condition="'$(BuildTestsAgainstPackages)' != 'true'">
+      <Project>{8ffe99c0-22f8-4462-b839-970eac1b3472}</Project>
+      <Name>coreclr</Name>
+    </ProjectReference>
+    <ProjectReference Include="$(SourceDir)Common\Coreclr.TestWrapper\Coreclr.TestWrapper.csproj" Condition="'$(BuildTestsAgainstPackages)' == 'true'">
       <Project>{8ffe99c0-22f8-4462-b839-970eac1b3472}</Project>
       <Name>coreclr</Name>
     </ProjectReference>
@@ -114,10 +116,6 @@ $(_XunitEpilog)
     <Reference Include="System.Runtime" />
     <Reference Include="mscorlib" />
   </ItemGroup>
-  <PropertyGroup>
-    <ProjectJson>%24(TestWrappersPackagesConfigFileDirectory)project.json</ProjectJson>
-    <ProjectLockJson>%24(TestWrappersPackagesConfigFileDirectory)project.lock.json</ProjectLockJson>
-  </PropertyGroup>
   <Import Project="$(SourceDir)dir.targets" />
   <PropertyGroup>
      <OutDir>$(XunitTestBinBase)\$(Category)\</OutDir>
@@ -195,7 +193,8 @@ namespace $([System.String]::Copy($(Category)).Replace(".","_").Replace("\","").
                     throw new ArgumentException("Environment variable CORE_ROOT is not set")%3B
                 }
 
-                runningInWindows = System.Environment.GetEnvironmentVariable("OS").StartsWith("Windows")%3B
+                string operatingSystem = System.Environment.GetEnvironmentVariable("OS")%3B
+                runningInWindows = (operatingSystem != null && operatingSystem.StartsWith("Windows"))%3B
             }
         }
 
@@ -214,6 +213,10 @@ namespace $([System.String]::Copy($(Category)).Replace(".","_").Replace("\","").
       <CanonicalExcludeList Include="%(ExcludeList.FullPath)" Condition="$(HaveExcludes)"/>
     </ItemGroup>
 
+    <PropertyGroup>
+      <TestExecutableReplacement Condition="'$(RuntimeID)' != '' ">testExecutable = testExecutable.Replace("\\", "/")%3B</TestExecutableReplacement>
+    </PropertyGroup>
+
     <ItemGroup>
       <AllCMDsPresent Include="$(_CMDDIR)\**\*.cmd" />
       <AllCMDExcludeFilter Include="@(CanonicalExcludeList)" Condition="$(HaveExcludes)"/>
@@ -244,6 +247,7 @@ namespace $([System.String]::Copy($(Category)).Replace(".","_").Replace("\","").
                   outputFile = System.IO.Path.GetFullPath(_Global.reportBase + testSubfolder + @"%(AllCMDs.FileName).output.txt")%3B
                   errorFile = System.IO.Path.GetFullPath(_Global.reportBase + testSubfolder + @"%(AllCMDs.FileName).error.txt")%3B
                   testExecutable = System.IO.Path.GetFullPath(_Global.testBinaryBase + @"$([System.String]::Copy('%(AllCMDs.FullPath)').Replace("$(_CMDDIR)",''))")%3B
+                  $(TestExecutableReplacement)
 
                   if (!_Global.runningInWindows) {
                       testExecutable = testExecutable.Replace(".cmd", ".sh")%3B
diff --git a/tests/runtest.sh b/tests/runtest.sh
index b48cffb4a6..743e14eb99 100755
--- a/tests/runtest.sh
+++ b/tests/runtest.sh
@@ -11,8 +11,7 @@ function print_usage {
     echo '    --testNativeBinDir="coreclr/bin/obj/Linux.x64.Debug/tests"'
     echo '    --coreClrBinDir="coreclr/bin/Product/Linux.x64.Debug"'
     echo '    --mscorlibDir="windows/coreclr/bin/Product/Linux.x64.Debug"'
-    echo '    --coreFxBinDir="corefx/bin/Linux.AnyCPU.Debug"'
-    echo '    --coreFxNativeBinDir="corefx/bin/Linux.x64.Debug"'
+    echo '    --coreFxBinDir="corefx/bin/runtime/netcoreapp-Linux-Debug-x64'
     echo ''
     echo 'Required arguments:'
     echo '  --testRootDir=<path>             : Root directory of the test build (e.g. coreclr/bin/tests/Windows_NT.x64.Debug).'
@@ -22,14 +21,13 @@ function print_usage {
     echo 'Optional arguments:'
     echo '  --coreOverlayDir=<path>          : Directory containing core binaries and test dependencies. If not specified, the'
     echo '                                     default is testRootDir/Tests/coreoverlay. This switch overrides --coreClrBinDir,'
-    echo '                                     --mscorlibDir, --coreFxBinDir, and --coreFxNativeBinDir.'
+    echo '                                     --mscorlibDir, and --coreFxBinDir.'
     echo '  --coreClrBinDir=<path>           : Directory of the CoreCLR build (e.g. coreclr/bin/Product/Linux.x64.Debug).'
     echo '  --mscorlibDir=<path>             : Directory containing the built mscorlib.dll. If not specified, it is expected to be'
     echo '                                       in the directory specified by --coreClrBinDir.'
-    echo '  --coreFxBinDir="<path>[;<path>]" : List of one or more directories with CoreFX build outputs (semicolon-delimited)'
-    echo '                                     (e.g. "corefx/bin/Linux.AnyCPU.Debug;corefx/bin/Unix.AnyCPU.Debug;corefx/bin/AnyOS.AnyCPU.Debug").'
+    echo '  --coreFxBinDir="<path>"          : Directory with CoreFX build outputs'
+    echo '                                     (e.g. "corefx/bin/runtime/netcoreapp-Linux-Debug-x64")'
     echo '                                     If files with the same name are present in multiple directories, the first one wins.'
-    echo '  --coreFxNativeBinDir=<path>      : Directory of the CoreFX native build (e.g. corefx/bin/Linux.x64.Debug).'
     echo '  --testDir=<path>                 : Run tests only in the specified directory. The path is relative to the directory'
     echo '                                     specified by --testRootDir. Multiple of this switch may be specified.'
     echo '  --testDirFile=<path>             : Run tests only in the directories specified by the file at <path>. Paths are listed'
@@ -97,6 +95,7 @@ xunitOutputPath=
 xunitTestOutputPath=
 
 # libExtension determines extension for dynamic library files
+# runtimeName determines where CoreFX Runtime files will be located
 OSName=$(uname -s)
 libExtension=
 case $OSName in
@@ -353,12 +352,6 @@ function create_core_overlay {
     if [ -z "$coreFxBinDir" ]; then
         exit_with_error "$errorSource" "One of --coreOverlayDir or --coreFxBinDir must be specified." "$printUsage"
     fi
-    if [ -z "$coreFxNativeBinDir" ]; then
-        exit_with_error "$errorSource" "One of --coreOverlayDir or --coreFxBinDir must be specified." "$printUsage"
-    fi
-    if [ ! -d "$coreFxNativeBinDir/Native" ]; then
-        exit_with_error "$errorSource" "Directory specified by --coreNativeFxBinDir does not exist: $coreFxNativeBinDir/Native"
-    fi
 
     # Create the overlay
     coreOverlayDir=$testRootDir/Tests/coreoverlay
@@ -368,21 +361,7 @@ function create_core_overlay {
     fi
     mkdir "$coreOverlayDir"
 
-    while IFS=';' read -ra coreFxBinDirectories; do
-        for currDir in "${coreFxBinDirectories[@]}"; do
-            if [ ! -d "$currDir" ]; then
-                exit_with_error "$errorSource" "Directory specified in --coreFxBinDir does not exist: $currDir"
-            fi
-            pushd $currDir > /dev/null
-            for dirName in $(find . -iname '*.dll' \! -iwholename '*test*' \! -iwholename '*/ToolRuntime/*' \! -iwholename '*/RemoteExecutorConsoleApp/*' \! -iwholename '*/net*' \! -iwholename '*aot*' -exec dirname {} \; | uniq | sed 's/\.\/\(.*\)/\1/g'); do
-                cp -n -v "$currDir/$dirName/$dirName.dll" "$coreOverlayDir/"
-            done
-            popd $currDur > /dev/null
-        done
-    done <<< $coreFxBinDir
-
-    cp -f -v "$coreFxNativeBinDir/Native/"*."$libExtension" "$coreOverlayDir/" 2>/dev/null
-
+    cp -f -v "$coreFxBinDir/"* "$coreOverlayDir/" 2>/dev/null
     cp -f -v "$coreClrBinDir/"* "$coreOverlayDir/" 2>/dev/null
     cp -f -v "$mscorlibDir/mscorlib.dll" "$coreOverlayDir/" 2>/dev/null
     if [ -d "$mscorlibDir/bin" ]; then
@@ -409,8 +388,7 @@ function precompile_overlay_assemblies {
         for fileToPrecompile in ${filesToPrecompile}
         do
             local filename=${fileToPrecompile}
-            if [ $jitdisasm == 1]; then
-
+            if [ $jitdisasm == 1 ]; then
                 $overlayDir/corerun $overlayDir/jit-dasm.dll --crossgen $overlayDir/crossgen --platform $overlayDir --output $testRootDir/dasm $filename
                 local exitCode=$?
                 if [ $exitCode != 0 ]; then
@@ -613,7 +591,7 @@ function print_info_from_core_file {
 
 function download_dumpling_script {
     echo "Downloading latest version of dumpling script."
-    wget "https://raw.githubusercontent.com/Microsoft/dotnet-reliability/master/src/triage.python/dumpling.py"
+    wget "https://dumpling.azurewebsites.net/api/client/dumpling.py"
 
     local dumpling_script="dumpling.py"
     chmod +x $dumpling_script
@@ -644,8 +622,11 @@ function upload_core_file_to_dumpling {
         paths_to_add=$coreClrBinDir
     fi
 
+    # Ensure the script has Unix line endings
+    perl -pi -e 's/\r\n|\n|\r/\n/g' "$dumpling_script"
+
     # The output from this will include a unique ID for this dump.
-    ./$dumpling_script "--corefile" "$core_file_name" "upload" "--addpaths" $paths_to_add "--squelch" | tee -a $dumpling_file
+    ./$dumpling_script "upload" "--dumppath" "$core_file_name" "--incpaths" $paths_to_add "--properties" "Project=CoreCLR" "--squelch" | tee -a $dumpling_file
 }
 
 function preserve_core_file {
@@ -968,7 +949,6 @@ coreOverlayDir=
 coreClrBinDir=
 mscorlibDir=
 coreFxBinDir=
-coreFxNativeBinDir=
 coreClrObjs=
 coreClrSrc=
 coverageOutputDir=
@@ -1035,9 +1015,6 @@ do
         --coreFxBinDir=*)
             coreFxBinDir=${i#*=}
             ;;
-        --coreFxNativeBinDir=*)
-            coreFxNativeBinDir=${i#*=}
-            ;;
         --testDir=*)
             testDirectories[${#testDirectories[@]}]=${i#*=}
             ;;
@@ -1207,7 +1184,10 @@ then
     scriptPath=$(dirname $0)
     ${scriptPath}/setup-runtime-dependencies.sh --outputDir=$coreOverlayDir
 else
-    echo "Skip preparing for GC stress test. Dependent package is not supported on this architecture."
+    if [ "$ARCH" != "arm64" ]
+    then
+        echo "Skip preparing for GC stress test. Dependent package is not supported on this architecture."
+    fi
 fi
 
 export __TestEnv=$testEnv
diff --git a/tests/scripts/format.py b/tests/scripts/format.py
index 9736c033b2..4c84cb532b 100644
--- a/tests/scripts/format.py
+++ b/tests/scripts/format.py
@@ -84,13 +84,13 @@ def main(argv):
 
     print("Downloading .Net CLI")
     if platform == 'Linux':
-        dotnetcliUrl = "https://go.microsoft.com/fwlink/?LinkID=809129"
+        dotnetcliUrl = "https://go.microsoft.com/fwlink/?linkid=839628"
         dotnetcliFilename = os.path.join(dotnetcliPath, 'dotnetcli-jitutils.tar.gz')
     elif platform == 'OSX':
-        dotnetcliUrl = "https://go.microsoft.com/fwlink/?LinkID=809128"
+        dotnetcliUrl = "https://go.microsoft.com/fwlink/?linkid=839641"
         dotnetcliFilename = os.path.join(dotnetcliPath, 'dotnetcli-jitutils.tar.gz')
     elif platform == 'Windows_NT':
-        dotnetcliUrl = "https://go.microsoft.com/fwlink/?LinkID=809126"
+        dotnetcliUrl = "https://go.microsoft.com/fwlink/?linkid=839634"
         dotnetcliFilename = os.path.join(dotnetcliPath, 'dotnetcli-jitutils.zip')
     else:
         print('Unknown os ', os)
@@ -160,7 +160,7 @@ def main(argv):
 
     # Run bootstrap
 
-    my_env["PATH"] += os.pathsep + dotnetcliPath
+    my_env["PATH"] = dotnetcliPath + os.pathsep + my_env["PATH"]
     if platform == 'Linux' or platform == 'OSX':
         print("Running bootstrap")
         proc = subprocess.Popen(['bash', bootstrapPath], env=my_env)
@@ -173,7 +173,7 @@ def main(argv):
 
     returncode = 0
     jitutilsBin = os.path.join(coreclr, "jitutils", "bin")
-    my_env["PATH"] += os.pathsep + jitutilsBin
+    my_env["PATH"] = jitutilsBin + os.pathsep + my_env["PATH"]
     current_dir = os.getcwd()
 
     if not os.path.isdir(jitutilsBin):
diff --git a/tests/scripts/perf-prep.sh b/tests/scripts/perf-prep.sh
index 3f16f3852b..effdc0a615 100755
--- a/tests/scripts/perf-prep.sh
+++ b/tests/scripts/perf-prep.sh
@@ -68,6 +68,7 @@ curl https://ci.dot.net/job/dotnet_corefx/job/master/job/ubuntu14.04_release/las
 # Unpack the corefx binaries
 pushd corefx > /dev/null
 tar -xf build.tar.gz
+rm build.tar.gz
 popd > /dev/null
 
 # Unzip the tests first.  Exit with 0
diff --git a/tests/scripts/run-corefx-tests.py b/tests/scripts/run-corefx-tests.py
index b65fa5e033..f0111da19c 100644
--- a/tests/scripts/run-corefx-tests.py
+++ b/tests/scripts/run-corefx-tests.py
@@ -17,6 +17,7 @@
 ##########################################################################
 
 import argparse
+import distutils.dir_util
 import os
 import re
 import shutil
@@ -118,7 +119,7 @@ def validate_args(args):
     validate_arg(fx_branch, lambda item: True)
 
     if fx_commit is None:
-        fx_commit = '551fe49174378adcbf785c0ab12fc69355cef6e8' if fx_branch == 'master' else 'HEAD'
+        fx_commit = 'HEAD'
 
     if clr_root is None:
         clr_root = nth_dirname(os.path.abspath(sys.argv[0]), 3)
@@ -148,7 +149,6 @@ def validate_args(args):
 
     return args
 
-
 def nth_dirname(path, n):
     """ Find the Nth parent directory of the given path
     Args:
@@ -188,7 +188,6 @@ def log(message):
 
     print '[%s]: %s' % (sys.argv[0], message)
 
-
 ##########################################################################
 # Main
 ##########################################################################
@@ -197,6 +196,8 @@ def main(args):
     global Corefx_url
     global Unix_name_map
 
+    testing = False
+
     arch, build_type, clr_root, fx_root, fx_branch, fx_commit, env_script = validate_args(
         args)
 
@@ -212,95 +213,112 @@ def main(args):
     # To delete the files with non-ascii characters, when rmtree fails due to those
     # files, we then will call rd on Windows.
 
-    if os.path.exists(fx_root):
+    if not testing and os.path.exists(fx_root):
         if Is_windows:
-            vbcscompiler_running = True
-            while vbcscompiler_running:
+            while True:
                 res = subprocess.check_output(['tasklist'])
                 if not 'VBCSCompiler.exe' in res:
-                    vbcscompiler_running = False
+                   break                
         os.chdir(fx_root)
         os.system('git clean -fxd')
         os.chdir(clr_root)
         shutil.rmtree(fx_root, onerror=del_rw)
 
+    # Clone the corefx branch
+
     command = 'git clone -b %s --single-branch %s %s' % (
         fx_branch, Corefx_url, fx_root)
-
     log(command)
-
-    testing = False
-
     if testing:
-        os.makedirs(fx_root)
+        if not os.path.exists(fx_root):
+            os.makedirs(fx_root)
         returncode = 0
     else:
         returncode = os.system(command)
 
-    if returncode != 0:
-        sys.exit(returncode)
+    # Change directory to the corefx root
 
+    cwd = os.getcwd()
+    log('[cd] ' + fx_root)
+    os.chdir(fx_root)
 
-    command = "git -C %s checkout %s" % (
-        fx_root, fx_commit)
+    # Checkout the appropriate corefx commit
 
+    command = "git checkout %s" % fx_commit
     log(command)
-
-    if testing:
-        returncode = 0
-    else:
-        returncode = os.system(command)
-
-    if returncode != 0:
+    returncode = 0 if testing else os.system(command)
+    if not returncode == 0:
         sys.exit(returncode)
 
-    cwd = os.getcwd()
-    log('cd ' + fx_root)
-    os.chdir(fx_root)
+    # On Unix, coreFx build.sh requires HOME to be set, and it isn't by default
+    # under our CI system, so set it now.
 
-    if Is_windows:
-        command = '.\\build.cmd'
-        if env_script is not None:
-            command = ('cmd /c %s&&' % env_script) + command
-    else:
-        # CoreFx build.sh requires HOME to be set, and it isn't by default
-        # under our CI.
+    if not Is_windows:
         fx_home = os.path.join(fx_root, 'tempHome')
         if not os.path.exists(fx_home):
             os.makedirs(fx_home)
         os.putenv('HOME', fx_home)
         log('HOME=' + fx_home)
 
-        command = './build.sh'
-        if env_script is not None:
-            command = ('. %s;' % env_script) + command
-
+    # Determine the RID to specify the to corefix build scripts.  This seems to
+    # be way harder than it ought to be.
+ 
     if testing:
         rid_os = dotnet_rid_os('')
     else:
-        if clr_os == "Windows_NT":
+        if Is_windows:
             rid_os = "win7"
         else:
             rid_os = dotnet_rid_os(os.path.join(clr_root, 'Tools', 'dotnetcli'))
 
+    # Gather up some arguments to pass to both build and build-tests.
+
+    config_args = '-Release -RuntimeOS=%s -ArchGroup=%s' % (rid_os, arch)
+
+    # Run the primary (non-test) corefx build
+
+    command = ' '.join(('build.cmd' if Is_windows else './build.sh', config_args))
+    log(command)
+    returncode = 0 if testing else os.system(command)
+    if returncode != 0:
+        sys.exit(returncode)
+
+    # Copy the coreclr runtime we wish to run tests against.  This is the recommended
+    # hack until a full-stack test solution is ready.  This assumes there is a single
+    # directory under <fx_root>/bin/runtime into which we copy coreclr binaries.  We
+    # assume the appropriate coreclr has already been built.
+
+    fx_runtime_dir = os.path.join(fx_root, 'bin', 'runtime')
+    overlay_dest = os.path.join(fx_runtime_dir, os.listdir(fx_runtime_dir)[0])
+    log('[overlay] %s -> %s' % (core_root, overlay_dest))
+    if not testing:
+        distutils.dir_util.copy_tree(core_root, overlay_dest)
+
+    # Build the build-tests command line.
+
+    if Is_windows:
+        command = 'build-tests.cmd'
+        if env_script is not None:
+            command = ('cmd /c %s&&' % env_script) + command
+    else:
+        command = './build-tests.sh'
+        if env_script is not None:
+            command = ('. %s;' % env_script) + command
+
     command = ' '.join((
         command,
-        '-Release',
-        '-TestNugetRuntimeId=%s-%s' % (rid_os, arch),
+        config_args,
         '--',
-        '/p:BUILDTOOLS_OVERRIDE_RUNTIME="%s"' % core_root,
         '/p:WithoutCategories=IgnoreForCI'
     ))
 
     if not Is_windows:
         command += ' /p:TestWithLocalNativeLibraries=true'
 
-    log(command)
+    # Run the corefx test build and run the tests themselves.
 
-    if testing:
-        returncode = 0
-    else:
-        returncode = os.system(command)
+    log(command)
+    returncode = 0 if testing else os.system(command)
 
     sys.exit(returncode)
 
diff --git a/tests/scripts/run-xunit-perf.cmd b/tests/scripts/run-xunit-perf.cmd
index a7d3c410d7..060ba33171 100644
--- a/tests/scripts/run-xunit-perf.cmd
+++ b/tests/scripts/run-xunit-perf.cmd
@@ -65,12 +65,16 @@ goto :EOF
 
 :DOIT
 set BENCHNAME=%~n1
+set BENCHDIR=%~p1
 set PERFOUT=perf-%BENCHNAME%
 set XMLOUT=%PERFOUT%-summary.xml
 
 echo --- Running %BENCHNAME%
 
+@rem copy benchmark and any input files
+
 xcopy /s %1 . >> %RUNLOG%
+xcopy /s %BENCHDIR%*.txt . >> %RUNLOG%
 
 set CORE_ROOT=%CORECLR_REPO%\sandbox
 
diff --git a/tests/scripts/run-xunit-perf.sh b/tests/scripts/run-xunit-perf.sh
index b6f4ac133d..27f84c2011 100755
--- a/tests/scripts/run-xunit-perf.sh
+++ b/tests/scripts/run-xunit-perf.sh
@@ -12,7 +12,6 @@ function print_usage {
     echo '    --coreClrBinDir="coreclr/bin/Product/Linux.x64.Debug"'
     echo '    --mscorlibDir="windows/coreclr/bin/Product/Linux.x64.Debug"'
     echo '    --coreFxBinDir="corefx/bin/Linux.AnyCPU.Debug"'
-    echo '    --coreFxNativeBinDir="corefx/bin/Linux.x64.Debug"'
     echo ''
     echo 'Required arguments:'
     echo '  --testRootDir=<path>             : Root directory of the test build (e.g. coreclr/bin/tests/Windows_NT.x64.Debug).'
@@ -22,14 +21,11 @@ function print_usage {
     echo 'Optional arguments:'
     echo '  --coreOverlayDir=<path>          : Directory containing core binaries and test dependencies. If not specified, the'
     echo '                                     default is testRootDir/Tests/coreoverlay. This switch overrides --coreClrBinDir,'
-    echo '                                     --mscorlibDir, --coreFxBinDir, and --coreFxNativeBinDir.'
+    echo '                                     --mscorlibDir, and --coreFxBinDir.'
     echo '  --coreClrBinDir=<path>           : Directory of the CoreCLR build (e.g. coreclr/bin/Product/Linux.x64.Debug).'
     echo '  --mscorlibDir=<path>             : Directory containing the built mscorlib.dll. If not specified, it is expected to be'
     echo '                                       in the directory specified by --coreClrBinDir.'
-    echo '  --coreFxBinDir="<path>[;<path>]" : List of one or more directories with CoreFX build outputs (semicolon-delimited)'
-    echo '                                     (e.g. "corefx/bin/Linux.AnyCPU.Debug;corefx/bin/Unix.AnyCPU.Debug;corefx/bin/AnyOS.AnyCPU.Debug").'
-    echo '                                     If files with the same name are present in multiple directories, the first one wins.'
-    echo '  --coreFxNativeBinDir=<path>      : Directory of the CoreFX native build (e.g. corefx/bin/Linux.x64.Debug).'
+    echo '  --coreFxBinDir="<path>"          : The path to the unpacked runtime folder that is produced as part of a CoreFX build'
 	echo '  --uploadToBenchview              : Specify this flag in order to have the results of the run uploaded to Benchview.'
 	echo '                                     This also requires that the os flag and runtype flag to be set.  Lastly you must'
 	echo '                                     also have the BV_UPLOAD_SAS_TOKEN set to a SAS token for the Benchview upload container'
@@ -210,12 +206,6 @@ function create_core_overlay {
     if [ -z "$coreFxBinDir" ]; then
         exit_with_error "$errorSource" "One of --coreOverlayDir or --coreFxBinDir must be specified." "$printUsage"
     fi
-    if [ -z "$coreFxNativeBinDir" ]; then
-        exit_with_error "$errorSource" "One of --coreOverlayDir or --coreFxBinDir must be specified." "$printUsage"
-    fi
-    if [ ! -d "$coreFxNativeBinDir/Native" -a ! -d "$coreFxNativeBinDir/native" ]; then
-        exit_with_error "$errorSource" "Directory specified by --coreNativeFxBinDir does not exist: $coreFxNativeBinDir/Native"
-    fi
 
     # Create the overlay
     coreOverlayDir=$testRootDir/Tests/coreoverlay
@@ -225,21 +215,7 @@ function create_core_overlay {
     fi
     mkdir "$coreOverlayDir"
 
-    while IFS=';' read -ra coreFxBinDirectories; do
-        for currDir in "${coreFxBinDirectories[@]}"; do
-            if [ ! -d "$currDir" ]; then
-                exit_with_error "$errorSource" "Directory specified in --coreFxBinDir does not exist: $currDir"
-            fi
-            pushd $currDir > /dev/null
-            for dirName in $(find . -iname '*.dll' \! -iwholename '*test*' \! -iwholename '*/ToolRuntime/*' \! -iwholename '*/RemoteExecutorConsoleApp/*' \! -iwholename '*/net*' \! -iwholename '*aot*' -exec dirname {} \; | uniq | sed 's/\.\/\(.*\)/\1/g'); do
-                cp -n -v "$currDir/$dirName/$dirName.dll" "$coreOverlayDir/"
-            done
-            popd $currDur > /dev/null
-        done
-    done <<< $coreFxBinDir
-
-    cp -f -v "$coreFxNativeBinDir/Native/"*."$libExtension" "$coreOverlayDir/" 2>/dev/null
-
+	cp -f -v "$coreFxBinDir"/* "$coreOverlayDir/" 2>/dev/null
     cp -f -v "$coreClrBinDir/"* "$coreOverlayDir/" 2>/dev/null
     cp -f -v "$mscorlibDir/mscorlib.dll" "$coreOverlayDir/"
     cp -n -v "$testDependenciesDir"/* "$coreOverlayDir/" 2>/dev/null
@@ -251,7 +227,7 @@ function create_core_overlay {
 
 function precompile_overlay_assemblies {
 
-    if [ $doCrossgen == 1 ]; then
+    if [ "$doCrossgen" == "1" ]; then
 
         local overlayDir=$CORE_ROOT
 
@@ -315,7 +291,6 @@ coreOverlayDir=
 coreClrBinDir=
 mscorlibDir=
 coreFxBinDir=
-coreFxNativeBinDir=
 uploadToBenchview=
 benchViewOS=
 runType=
@@ -345,9 +320,6 @@ do
         --coreFxBinDir=*)
             coreFxBinDir=${i#*=}
             ;;
-        --coreFxNativeBinDir=*)
-            coreFxNativeBinDir=${i#*=}
-            ;;
 		--benchViewOS=*)
             benchViewOS=${i#*=}
             ;;
@@ -421,6 +393,7 @@ test=$(basename $testcase)
 testname=$(basename $testcase .exe)
 echo "....Running $testname"
 cp $testcase .
+cp $testcase-*.txt .
 
 chmod u+x ./corerun
 echo "./corerun Microsoft.DotNet.xunit.performance.runner.cli.dll $test -runner xunit.console.netcore.exe -runnerhost ./corerun -verbose -runid perf-$testname"
diff --git a/tests/src/CLRTest.Execute.Bash.targets b/tests/src/CLRTest.Execute.Bash.targets
index 60270a14da..04ab5fe2df 100644
--- a/tests/src/CLRTest.Execute.Bash.targets
+++ b/tests/src/CLRTest.Execute.Bash.targets
@@ -109,7 +109,7 @@ $(BashCLRTestEnvironmentCompatibilityCheck)
 if [ ! -z "$COMPlus_GCStress" ]
 then
   echo SKIPPING EXECUTION BECAUSE COMPlus_GCStress IS SET
-  exit 0
+  exit 2
 fi
       ]]></BashCLRTestEnvironmentCompatibilityCheck>
       <BashCLRTestEnvironmentCompatibilityCheck Condition="'$(JitOptimizationSensitive)' == 'true'"><![CDATA[
@@ -117,7 +117,7 @@ $(BashCLRTestEnvironmentCompatibilityCheck)
 if [ \( ! -z "$COMPlus_JitStress" \) -o \( ! -z "$COMPlus_JitStressRegs" \) -o \( ! -z "$COMPlus_JITMinOpts" \) ]
 then
   echo "SKIPPING EXECUTION BECAUSE ONE OR MORE OF (COMPlus_JitStress, COMPlus_JitStressRegs, COMPlus_JITMinOpts) IS SET"
-  exit 0
+  exit 2
 fi
       ]]></BashCLRTestEnvironmentCompatibilityCheck>
       <BashCLRTestEnvironmentCompatibilityCheck Condition="'$(HeapVerifyIncompatible)' == 'true'"><![CDATA[
@@ -125,7 +125,7 @@ $(BashCLRTestEnvironmentCompatibilityCheck)
 if [ ! -z "$COMPlus_HeapVerify" ]
 then
   echo SKIPPING EXECUTION BECAUSE COMPlus_HeapVerify IS SET
-  exit 0
+  exit 2
 fi
       ]]></BashCLRTestEnvironmentCompatibilityCheck>
 
@@ -274,6 +274,7 @@ $(BashCLRTestArgPrep)
       <!-- NOTE! semicolons must be escaped with %3B boooo -->
       <_CLRTestExecutionScriptText>
         <![CDATA[
+%23%21/usr/bin/env bash
 TakeLock()
 {
     echo "in takeLock"
diff --git a/tests/src/CLRTest.GC.targets b/tests/src/CLRTest.GC.targets
index 90b9398a40..b102a06b2b 100644
--- a/tests/src/CLRTest.GC.targets
+++ b/tests/src/CLRTest.GC.targets
@@ -23,7 +23,7 @@ WARNING:   When setting properties based on their current state (for example:
 if [ ! -z $RunningLongGCTests ]
 then
     echo "Skipping execution because this is not a long-running GC test"
-    exit 0
+    exit 2
 fi
         ]]></GCLongGCTestBashScript>
         <GCLongGCTestBashScript Condition="'$(IsLongRunningGCTest)' == 'true'"><![CDATA[
@@ -31,7 +31,7 @@ fi
 if [ -z $RunningLongGCTests ]
 then
     echo "Skipping execution because long-running GC tests are not enabled"
-    exit 0
+    exit 2
 fi
         ]]></GCLongGCTestBashScript>
 
@@ -41,7 +41,7 @@ fi
 if [ ! -z $RunningGCSimulatorTests ]
 then
     echo "Skipping execution because this is not a GCSimulator test"
-    exit 0
+    exit 2
 fi
         ]]></GCSimulatorTestBashScript>
         <GCSimulatorTestBashScript Condition="'$(IsGCSimulatorTest)' == 'true'"><![CDATA[
@@ -49,7 +49,7 @@ fi
 if [ -z $RunningGCSimulatorTests ]
 then
     echo "Skipping execution because GCSimulator tests are not enabled"
-    exit 0
+    exit 2
 fi
         ]]></GCSimulatorTestBashScript>
 
diff --git a/tests/src/Common/Coreclr.TestWrapper/CoreclrTestWrapperLib.cs b/tests/src/Common/Coreclr.TestWrapper/CoreclrTestWrapperLib.cs
index dbdfc0ef94..ddb905087b 100644
--- a/tests/src/Common/Coreclr.TestWrapper/CoreclrTestWrapperLib.cs
+++ b/tests/src/Common/Coreclr.TestWrapper/CoreclrTestWrapperLib.cs
@@ -35,6 +35,10 @@ namespace CoreclrTestLib
 
             string gcstressVar = Environment.GetEnvironmentVariable(GC_STRESS_LEVEL);
 
+            // Check if we are running in Windows
+            string operatingSystem = System.Environment.GetEnvironmentVariable("OS");
+            bool runningInWindows = (operatingSystem != null && operatingSystem.StartsWith("Windows"));
+
             var outputStream = new FileStream(outputFile, FileMode.Create);
             var errorStream = new FileStream(errorFile, FileMode.Create);
 
@@ -49,7 +53,18 @@ namespace CoreclrTestLib
                     process.StartInfo.EnvironmentVariables["COMPlus_GCStress"] = gcstressVar;
                 }
 
-                process.StartInfo.FileName = executable;
+                // Windows can run the executable implicitly
+                if (runningInWindows)
+                {
+                    process.StartInfo.FileName = executable;
+                }
+                // Non-windows needs to be told explicitly to run through /bin/bash shell
+                else
+                {
+                    process.StartInfo.FileName = "/bin/bash";
+                    process.StartInfo.Arguments = executable;
+                }
+
                 process.StartInfo.UseShellExecute = false;
                 process.StartInfo.RedirectStandardOutput = true;
                 process.StartInfo.RedirectStandardError = true;
diff --git a/tests/src/Common/build_against_pkg_dependencies/project.json b/tests/src/Common/build_against_pkg_dependencies/project.json
index bb323fb8e6..98362af813 100644
--- a/tests/src/Common/build_against_pkg_dependencies/project.json
+++ b/tests/src/Common/build_against_pkg_dependencies/project.json
@@ -1,10 +1,10 @@
 {
   "dependencies": {
-    "Microsoft.NETCore.ILAsm": "1.2.0-beta-24924-01",
-    "Microsoft.NETCore.ILDAsm": "1.2.0-beta-24924-01",
-    "Microsoft.NETCore.Jit": "1.2.0-beta-24924-01",
-    "Microsoft.NETCore.Runtime.CoreCLR": "1.2.0-beta-24924-01",
-    "Microsoft.NETCore.TestHost": "1.2.0-beta-24924-01"
+    "Microsoft.NETCore.ILAsm": "2.0.0-beta-25007-01",
+    "Microsoft.NETCore.ILDAsm": "2.0.0-beta-25007-01",
+    "Microsoft.NETCore.Jit": "2.0.0-beta-25007-01",
+    "Microsoft.NETCore.Runtime.CoreCLR": "2.0.0-beta-25007-01",
+    "Microsoft.NETCore.TestHost": "2.0.0-beta-25007-01"
   },
   "frameworks": {
     "netcoreapp1.1": {
@@ -26,7 +26,6 @@
     "rhel.7-x64": {},
     "debian.8-x64": {},
     "fedora.23-x64": {},
-    "opensuse.13.2-x64": {},
     "opensuse.42.1-x64": {}
   }
 }
diff --git a/tests/src/Common/empty/project.json b/tests/src/Common/empty/project.json
index 1954111901..82a0b7f3de 100644
--- a/tests/src/Common/empty/project.json
+++ b/tests/src/Common/empty/project.json
@@ -8,9 +8,12 @@
     "win7-x86": {},
     "win7-x64": {},
     "ubuntu.14.04-x64": {},
+    "ubuntu.16.04-x64": {},
+    "ubuntu.16.10-x64": {},
     "osx.10.10-x64": {},
     "centos.7-x64": {},
     "rhel.7-x64": {},
-    "debian.8-x64": {}
+    "debian.8-x64": {},
+    "fedora.23-x64": {}
   }
 }
diff --git a/tests/src/Common/netcoreapp/project.json b/tests/src/Common/netcoreapp/project.json
index 92226849a1..ab1528282e 100644
--- a/tests/src/Common/netcoreapp/project.json
+++ b/tests/src/Common/netcoreapp/project.json
@@ -1,74 +1,9 @@
 {
-  "version": "1.0.0-*",
-  "buildOptions": {
-    "debugType": "portable",
-    "emitEntryPoint": true
-  },
   "dependencies": {
-    "Microsoft.NETCore.Platforms": "2.0.0-beta-24924-02",
-    "Microsoft.NETCore.Targets": "1.2.0-beta-24913-02",
-    "System.Threading.Thread": "4.4.0-beta-24913-02",
-    "System.Collections": "4.4.0-beta-24913-02",
-    "System.Xml.XmlSerializer": "4.4.0-beta-24913-02",
-    "System.Collections.Concurrent": "4.4.0-beta-24913-02",
-    "System.ObjectModel": "4.4.0-beta-24913-02",
-    "System.Runtime.Numerics": "4.4.0-beta-24913-02",
-    "System.Collections.NonGeneric": "4.4.0-beta-24913-02",
-    "System.Collections.Specialized": "4.4.0-beta-24913-02",
-    "System.ComponentModel": "4.4.0-beta-24913-02",
-    "System.Reflection.Emit.Lightweight": "4.4.0-beta-24913-02",
-    "System.Reflection.TypeExtensions": "4.4.0-beta-24913-02",
-    "System.Console": "4.4.0-beta-24913-02",
-    "System.Diagnostics.Contracts": "4.4.0-beta-24913-02",
-    "System.Diagnostics.Debug": "4.4.0-beta-24913-02",
-    "System.Diagnostics.Process": "4.4.0-beta-24913-02",
-    "System.Diagnostics.Tools": "4.4.0-beta-24913-02",
-    "System.Diagnostics.Tracing": "4.4.0-beta-24913-02",
-    "System.Dynamic.Runtime": "4.4.0-beta-24913-02",
-    "System.Globalization": "4.4.0-beta-24913-02",
-    "System.Globalization.Calendars": "4.4.0-beta-24913-02",
-    "System.IO": "4.4.0-beta-24913-02",
-    "System.IO.FileSystem": "4.4.0-beta-24913-02",
-    "System.IO.FileSystem.Primitives": "4.4.0-beta-24913-02",
-    "System.Linq": "4.4.0-beta-24913-02",
-    "System.Linq.Queryable": "4.4.0-beta-24913-02",
-    "System.Linq.Expressions": "4.4.0-beta-24913-02",
-    "System.Reflection": "4.4.0-beta-24913-02",
-    "System.Reflection.Extensions": "4.4.0-beta-24913-02",
-    "System.Resources.ResourceManager": "4.4.0-beta-24913-02",
-    "System.Runtime": "4.4.0-beta-24913-02",
-    "System.Runtime.CompilerServices.Unsafe": "4.4.0-beta-24913-02",
-    "System.Runtime.Extensions": "4.4.0-beta-24913-02",
-    "System.Runtime.Handles": "4.4.0-beta-24913-02",
-    "System.Runtime.InteropServices": "4.4.0-beta-24913-02",
-    "System.Runtime.InteropServices.RuntimeInformation": "4.4.0-beta-24913-02",
-    "System.Runtime.Loader": "4.4.0-beta-24913-02",
-    "System.Security.Cryptography.Algorithms": "4.4.0-beta-24913-02",
-    "System.Text.Encoding": "4.4.0-beta-24913-02",
-    "System.Text.Encoding.Extensions": "4.4.0-beta-24913-02",
-    "System.Text.RegularExpressions": "4.4.0-beta-24913-02",
-    "System.Threading": "4.4.0-beta-24913-02",
-    "System.Threading.AccessControl": "4.4.0-beta-24913-02",
-    "System.Threading.Overlapped": "4.4.0-beta-24913-02",
-    "System.Threading.Tasks": "4.4.0-beta-24913-02",
-    "System.Threading.Tasks.Parallel": "4.4.0-beta-24913-02",
-    "System.Threading.ThreadPool": "4.4.0-beta-24913-02",
-    "System.Threading.Timer": "4.4.0-beta-24913-02",
-    "System.Xml.ReaderWriter": "4.4.0-beta-24913-02",
-    "System.Xml.XDocument": "4.4.0-beta-24913-02",
-    "System.Xml.XmlDocument": "4.4.0-beta-24913-02",
-    "System.Xml.XPath": "4.4.0-beta-24913-02",
-    "System.Xml.XPath.XmlDocument": "4.4.0-beta-24913-02",
-    "System.Numerics.Vectors": "4.4.0-beta-24913-02"
+    "Microsoft.NETCore.App": "2.0.0-beta-001494-00",
+    "System.Runtime.CompilerServices.Unsafe": "4.4.0-beta-24913-02"
   },
   "frameworks": {
-    "netcoreapp1.1": {
-      "dependencies": {
-        "Microsoft.NETCore.Runtime.CoreCLR": "1.2.0-beta-24924-01"
-      }
-    }
-  },
-  "runtimes": {
-    "win7-x64": {}
+    "netcoreapp2.0": { }
   }
 }
diff --git a/tests/src/Common/targeting_pack_ref/project.json b/tests/src/Common/targeting_pack_ref/project.json
index 252fe84e36..2ab60359e1 100644
--- a/tests/src/Common/targeting_pack_ref/project.json
+++ b/tests/src/Common/targeting_pack_ref/project.json
@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "Microsoft.TargetingPack.Private.CoreCLR": "1.2.0-beta-24924-01"
+    "Microsoft.TargetingPack.Private.CoreCLR": "2.0.0-beta-25007-01"
   },
   "frameworks": {
     "netcoreapp1.1": {
@@ -14,9 +14,12 @@
     "win7-x86": {},
     "win7-x64": {},
     "ubuntu.14.04-x64": {},
+    "ubuntu.16.04-x64": {},
+    "ubuntu.16.10-x64": {},
     "osx.10.10-x64": {},
     "centos.7-x64": {},
     "rhel.7-x64": {},
-    "debian.8-x64": {}
+    "debian.8-x64": {},
+    "fedora.23-x64": {}
   }
 }
diff --git a/tests/src/Common/test_dependencies/project.json b/tests/src/Common/test_dependencies/project.json
index fa7c1c2522..4f08ce1d6a 100644
--- a/tests/src/Common/test_dependencies/project.json
+++ b/tests/src/Common/test_dependencies/project.json
@@ -9,7 +9,7 @@
     "Microsoft.DotNet.xunit.performance.runner.Windows": "1.0.0-alpha-build0040",
     "Microsoft.Win32.Primitives": "4.4.0-beta-24913-02",
     "Newtonsoft.Json": "8.0.3",
-    "Microsoft.NETCore.Platforms": "2.0.0-beta-24924-02",
+    "Microsoft.NETCore.Platforms": "2.0.0-beta-25007-01",
     "Microsoft.NETCore.Targets": "1.2.0-beta-24913-02",
     "System.Collections.Immutable": "1.4.0-beta-24913-02",
     "System.Threading.Thread": "4.4.0-beta-24913-02",
@@ -82,9 +82,12 @@
     "win7-x86": {},
     "win7-x64": {},
     "ubuntu.14.04-x64": {},
+    "ubuntu.16.04-x64": {},
+    "ubuntu.16.10-x64": {},
     "osx.10.10-x64": {},
     "centos.7-x64": {},
     "rhel.7-x64": {},
-    "debian.8-x64": {}
+    "debian.8-x64": {},
+    "fedora.23-x64": {}
   }
 }
diff --git a/tests/src/Common/test_runtime/project.json b/tests/src/Common/test_runtime/project.json
index 7c65ce1017..4429a9c1b6 100644
--- a/tests/src/Common/test_runtime/project.json
+++ b/tests/src/Common/test_runtime/project.json
@@ -1,5 +1,6 @@
 {
   "dependencies": {
+    "Microsoft.NETCore.Platforms": "2.0.0-beta-25007-01",
     "Microsoft.DotNet.CoreCLR.TestDependencies": "1.0.0-prerelease",
     "jit-dasm": "0.0.1.4",
     "cijobs": "0.0.1.2",
@@ -8,7 +9,7 @@
   "frameworks": {
     "netcoreapp1.1": {
       "imports": [
-        "dnxcore50",  
+        "dnxcore50",
         "portable-net45+win8"
       ]
     }
@@ -17,9 +18,12 @@
     "win7-x86": {},
     "win7-x64": {},
     "ubuntu.14.04-x64": {},
+    "ubuntu.16.04-x64": {},
+    "ubuntu.16.10-x64": {},
     "osx.10.10-x64": {},
     "centos.7-x64": {},
     "rhel.7-x64": {},
-    "debian.8-x64": {}
+    "debian.8-x64": {},
+    "fedora.23-x64": {}
   }
 }
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeCtor3.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeCtor3.csproj
deleted file mode 100644
index 7b149234e7..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeCtor3.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimector3.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeCtor4.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeCtor4.csproj
deleted file mode 100644
index 54149adfc8..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeCtor4.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimector4.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeCtor6.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeCtor6.csproj
deleted file mode 100644
index cda720830e..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeCtor6.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimector6.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeCtor7.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeCtor7.csproj
deleted file mode 100644
index 655768292a..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeCtor7.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimector7.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeDate.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeDate.csproj
deleted file mode 100644
index 369a383c6c..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeDate.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimedate.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeGetHashCode.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeGetHashCode.csproj
deleted file mode 100644
index 4096884fd3..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeGetHashCode.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimegethashcode.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeHour.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeHour.csproj
deleted file mode 100644
index 8546ca6d70..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeHour.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimehour.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeMaxValue.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeMaxValue.csproj
deleted file mode 100644
index c588f8ce0b..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeMaxValue.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimemaxvalue.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeMillisecond.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeMillisecond.csproj
deleted file mode 100644
index 25fde7941b..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeMillisecond.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimemillisecond.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeMinValue.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeMinValue.csproj
deleted file mode 100644
index 060e586ee9..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeMinValue.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeminvalue.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeMinute.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeMinute.csproj
deleted file mode 100644
index ec37820d25..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeMinute.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeminute.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeParse1.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeParse1.csproj
deleted file mode 100644
index 5a3249701c..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeParse1.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeparse1.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeParse2.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeParse2.csproj
deleted file mode 100644
index 1126dcdef5..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeParse2.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeparse2.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeParse3.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeParse3.csproj
deleted file mode 100644
index 007ac1ba58..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeParse3.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeparse3.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeParseExact1.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeParseExact1.csproj
deleted file mode 100644
index 1c62be7593..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeParseExact1.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeparseexact1.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeParseExact2.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeParseExact2.csproj
deleted file mode 100644
index d08a7742f1..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeParseExact2.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeparseexact2.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeParseExact3.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeParseExact3.csproj
deleted file mode 100644
index 5df4c9f572..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeParseExact3.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeparseexact3.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeSecond.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeSecond.csproj
deleted file mode 100644
index 347cae3ff9..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeSecond.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimesecond.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeSubtract1.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeSubtract1.csproj
deleted file mode 100644
index 6c421e788b..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeSubtract1.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimesubtract1.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeSubtract2.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeSubtract2.csproj
deleted file mode 100644
index eb699f4bdc..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeSubtract2.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimesubtract2.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeTicks.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeTicks.csproj
deleted file mode 100644
index 015a0c089a..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeTicks.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeticks.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeTimeOfDay.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeTimeOfDay.csproj
deleted file mode 100644
index a4272cbf1e..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeTimeOfDay.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimetimeofday.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeToFileTime.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeToFileTime.csproj
deleted file mode 100644
index 7d0ba1bbe2..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeToFileTime.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimetofiletime.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeToFileTimeUtc.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeToFileTimeUtc.csproj
deleted file mode 100644
index 3fbd0d2c38..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeToFileTimeUtc.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimetofiletimeutc.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeToLocalTime.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeToLocalTime.csproj
deleted file mode 100644
index a26bc57f46..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeToLocalTime.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimetolocaltime.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeToString1.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeToString1.csproj
deleted file mode 100644
index b16d7d324e..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeToString1.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimetostring1.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeToString2.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeToString2.csproj
deleted file mode 100644
index 3d5b4700d7..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeToString2.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimetostring2.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeToString3.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeToString3.csproj
deleted file mode 100644
index 30ebd40cf2..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeToString3.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimetostring3.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeUtcNow.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimeUtcNow.csproj
deleted file mode 100644
index 4ba6627610..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeUtcNow.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeutcnow.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimetoday.csproj b/tests/src/CoreMangLib/cti/system/datetime/DateTimetoday.csproj
deleted file mode 100644
index 0b8f18605b..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimetoday.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimetoday.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/cfdatetimetools.cs b/tests/src/CoreMangLib/cti/system/datetime/cfdatetimetools.cs
deleted file mode 100644
index 0d7c8653f2..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/cfdatetimetools.cs
+++ /dev/null
@@ -1,142 +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.
-using System;
-using TestLibrary;
-using System.Runtime.InteropServices;
-
-// utility functions for accessing DateTime functions in CoreFoundation for validation purposes
-
-// Important Notes:
-//    CF reference types are passed as IntPtrs. In the declarations, the actual type name is given within C-style comments:
-//                IntPtr /* CFTypeRef */ tr
-//    many function signatures contain an allocator of type CFAllocatorRef. To use the default allocator pass in IntPtr.Zero.
-
-public class CFDateTimeTools
-{
-
-    // Basic tools (should be factored out eventually, as not DateTime-specific)
-    [DllImport("/Developer/SDKs/MacOSX10.4u.sdk/System/Library/Frameworks/CoreFoundation.framework/Versions/Current/CoreFoundation")]
-    protected static extern string CFStringGetCStringPtr(IntPtr /* CFStringRef */ theString, CFStringEncoding encoding);
-
-    public enum CFStringEncoding : uint
-    {
-        kCFStringEncodingMacRoman = 0,
-        kCFStringEncodingWindowsLatin1 = 0x0500,
-        kCFStringEncodingISOLatin1 = 0x0201,
-        kCFStringEncodingNextStepLatin = 0x0B01,
-        kCFStringEncodingASCII = 0x0600,
-        kCFStringEncodingUnicode = 0x0100,
-        kCFStringEncodingUTF8 = 0x08000100,
-        kCFStringEncodingNonLossyASCII = 0x0BFF,
-
-        // The following constants are available
-        // only on Mac OS X v10.4 and later,
-        kCFStringEncodingUTF16 = 0x0100,
-        kCFStringEncodingUTF16BE = 0x10000100,
-        kCFStringEncodingUTF16LE = 0x14000100,
-        kCFStringEncodingUTF32 = 0x0c000100,
-        kCFStringEncodingUTF32BE = 0x18000100,
-        kCFStringEncodingUTF32LE = 0x1c000100
-    }
-    [DllImport("/Developer/SDKs/MacOSX10.4u.sdk/System/Library/Frameworks/CoreFoundation.framework/Versions/Current/CoreFoundation")]
-    protected static extern IntPtr /* CFStringRef */ CFStringCreateWithCString(IntPtr /* CFAllocatorRef */ alloc,
-                                string cStr,
-                                CFStringEncoding encoding);
-
-
-    [System.Security.SecuritySafeCritical]
-    public static string CFStringToSystemString(IntPtr /* CFStringRef */ theString)
-    {
-        return CFStringGetCStringPtr(theString, CFStringEncoding.kCFStringEncodingMacRoman);
-    }
-
-    [System.Security.SecuritySafeCritical]
-    public static IntPtr /* CFStringRef */ SystemStringToCFString(string theString)
-    {
-        return CFStringCreateWithCString(IntPtr.Zero, theString, CFStringEncoding.kCFStringEncodingMacRoman);
-    }
-
-    [System.Security.SecuritySafeCritical]
-    public static string GetOSFormattedDate(DateTime d, bool getLocale)
-    {
-        IntPtr cfDateRef = CFDateTimeTools.DateTimeToCFDateRef(d);
-        IntPtr cfLocaleRef = (getLocale ? CFDateTimeTools.CFLocaleCopyCurrent() : IntPtr.Zero);
-        IntPtr cfDateFmtr = CFDateFormatterCreate(IntPtr.Zero, cfLocaleRef,
-        CFDateFormatterStyle.kCFDateFormatterLongStyle,
-        CFDateFormatterStyle.kCFDateFormatterLongStyle); // 3 for long style
-
-        IntPtr cfStr = CFDateFormatterCreateStringWithDate(IntPtr.Zero, cfDateFmtr, cfDateRef);
-        return CFStringToSystemString(cfStr);
-    }
-
-    /// CFLocale
-    /// --------
-
-    [DllImport("/Developer/SDKs/MacOSX10.4u.sdk/System/Library/Frameworks/CoreFoundation.framework/Versions/Current/CoreFoundation")]
-    public static extern IntPtr /* CFLocaleRef */ CFLocaleCopyCurrent();
-
-    /// CFDate tools
-    /// ------------
-
-    [DllImport("/Developer/SDKs/MacOSX10.4u.sdk/System/Library/Frameworks/CoreFoundation.framework/Versions/Current/CoreFoundation")]
-    public static extern /* CFDateRef */ IntPtr CFDateCreate(IntPtr /* CFAllocatorRef */ allocator,
-                        double /* CFAbsoluteTime */ at);
-
-    // convert between CLR DateTime and CoreFoundation CFAbsoluteTime (== double) and CFDateRef types
-    private static DateTime CFAbsoluteTimeZero = new DateTime(2001, 1, 1, 0, 0, 0, DateTimeKind.Utc);
-
-    public static double DateTimeToCFAbsoluteTime(DateTime d)
-    {
-        return d.Subtract(CFAbsoluteTimeZero).TotalSeconds;
-    }
-
-    [System.Security.SecuritySafeCritical]
-    public static IntPtr /* CFDateRef */ DateTimeToCFDateRef(DateTime d)
-    {
-        return CFDateCreate(IntPtr.Zero,
-            DateTimeToCFAbsoluteTime(d));
-    }
-
-
-    /// CFDateTimeFormatter
-    /// -------------------
-
-    public enum CFDateFormatterStyle : int
-    {
-        kCFDateFormatterNoStyle = 0,
-        kCFDateFormatterShortStyle = 1,
-        kCFDateFormatterMediumStyle = 2,
-        kCFDateFormatterLongStyle = 3,
-        kCFDateFormatterFullStyle = 4
-    };
-
-
-    [DllImport("/Developer/SDKs/MacOSX10.4u.sdk/System/Library/Frameworks/CoreFoundation.framework/Versions/Current/CoreFoundation")]
-    public static extern IntPtr /* CFDateFormatterRef */ CFDateFormatterCreate(IntPtr /* CFAllocatorRef */ alloc,
-          IntPtr /* CFLocaleRef */ locale, CFDateFormatterStyle dateStyle, CFDateFormatterStyle timeStyle);
-
-
-    [DllImport("/Developer/SDKs/MacOSX10.4u.sdk/System/Library/Frameworks/CoreFoundation.framework/Versions/Current/CoreFoundation")]
-    public static extern /* CFStringRef */ IntPtr CFDateFormatterCreateStringWithDate(IntPtr /* CFAllocatorRef */ alloc,
-          IntPtr /* CFDateFormatterRef */ formatter, IntPtr /* CFDateRef */ date);
-
-    /// CFTimeZone 
-    /// -----------
-
-    [DllImport("/Developer/SDKs/MacOSX10.4u.sdk/System/Library/Frameworks/CoreFoundation.framework/Versions/Current/CoreFoundation")]
-    public extern static IntPtr /* CFTimeZoneRef */ CFTimeZoneCopySystem();
-
-    [DllImport("/Developer/SDKs/MacOSX10.4u.sdk/System/Library/Frameworks/CoreFoundation.framework/Versions/Current/CoreFoundation")]
-    public extern static IntPtr /* CFStringRef */ CFTimeZoneGetName(IntPtr /* CFTimeZoneRef */ tz);
-
-    [System.Security.SecuritySafeCritical]
-    public static string GetOSTimeZoneName(IntPtr /* CFTimeZoneRef */ tz)
-    {
-        return CFStringToSystemString(CFTimeZoneGetName(tz));
-    }
-
-    [DllImport("/Developer/SDKs/MacOSX10.4u.sdk/System/Library/Frameworks/CoreFoundation.framework/Versions/Current/CoreFoundation")]
-    public extern static bool CFTimeZoneIsDaylightSavingTime(IntPtr /* CFTimeZoneRef */ tz,
-                                double /* CFAbsoluteTime */ at);
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimecompare.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimecompare.cs
deleted file mode 100644
index 088f8b2932..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimecompare.cs
+++ /dev/null
@@ -1,250 +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.
-using System;
-
-/// <summary>
-/// Compare(System.DateTime,System.DateTime)
-/// </summary>
-public class DateTimeCompare
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Compare a datetime instance with itself");
-
-        try
-        {
-            DateTime t1 = new DateTime(2006, 9, 21, 10, 54, 56, 888);
-
-            if (DateTime.Compare(t1, t1) != 0)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Compare a datetime instance with itself does not return 0");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: Compare a datetime instance with a datetime instance less than it");
-
-        try
-        {
-            DateTime t1 = new DateTime(2006, 9, 21, 10, 54, 56, 888);
-            DateTime t2 = new DateTime(2006, 9, 21, 10, 54, 56, 887);
-
-            if (DateTime.Compare(t1, t2) <= 0)
-            {
-                TestLibrary.TestFramework.LogError("002.1", "Compare a datetime instance with a datetime instance less than it does not greater than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2006, 9, 21, 10, 54, 55, 888);
-
-            if (DateTime.Compare(t1, t2) <= 0)
-            {
-                TestLibrary.TestFramework.LogError("002.2", "Compare a datetime instance with a datetime instance less than it does not greater than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2006, 9, 21, 10, 53, 56, 888);
-
-            if (DateTime.Compare(t1, t2) <= 0)
-            {
-                TestLibrary.TestFramework.LogError("002.3", "Compare a datetime instance with a datetime instance less than it does not greater than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2006, 9, 21, 9, 54, 56, 888);
-
-            if (DateTime.Compare(t1, t2) <= 0)
-            {
-                TestLibrary.TestFramework.LogError("002.4", "Compare a datetime instance with a datetime instance less than it does not greater than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2006, 9, 20, 10, 54, 56, 888);
-
-            if (DateTime.Compare(t1, t2) <= 0)
-            {
-                TestLibrary.TestFramework.LogError("002.5", "Compare a datetime instance with a datetime instance less than it does not greater than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2006, 8, 21, 10, 54, 56, 888);
-
-            if (DateTime.Compare(t1, t2) <= 0)
-            {
-                TestLibrary.TestFramework.LogError("002.6", "Compare a datetime instance with a datetime instance less than it does not greater than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2005, 9, 21, 10, 54, 56, 888);
-
-            if (DateTime.Compare(t1, t2) <= 0)
-            {
-                TestLibrary.TestFramework.LogError("002.7", "Compare a datetime instance with a datetime instance less than it does not greater than 0");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: Compare a datetime instance equal to it");
-
-        try
-        {
-            DateTime t1 = new DateTime(2006, 9, 21, 10, 54, 56, 888);
-            DateTime t2 = new DateTime(2006, 9, 21, 10, 54, 56, 888);
-
-            if (DateTime.Compare(t1, t2) != 0)
-            {
-                TestLibrary.TestFramework.LogError("003.1", "Compare a datetime instance  equal to it does not return 0");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("003.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest4()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest4: Compare a datetime instance with a datetime instance greater than it");
-
-        try
-        {
-            DateTime t1 = new DateTime(2006, 9, 21, 10, 54, 56, 888);
-            DateTime t2 = new DateTime(2006, 9, 21, 10, 54, 56, 889);
-
-            if (DateTime.Compare(t1, t2) >= 0)
-            {
-                TestLibrary.TestFramework.LogError("004.1", "Compare a datetime instance with a datetime instance greater than it does not less than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2006, 9, 21, 10, 54, 57, 888);
-
-            if (DateTime.Compare(t1, t2) >= 0)
-            {
-                TestLibrary.TestFramework.LogError("004.1", "Compare a datetime instance with a datetime instance greater than it does not less than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2006, 9, 21, 10, 55, 56, 888);
-
-            if (DateTime.Compare(t1, t2) >= 0)
-            {
-                TestLibrary.TestFramework.LogError("004.1", "Compare a datetime instance with a datetime instance greater than it does not less than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2006, 9, 21, 11, 54, 56, 888);
-
-            if (DateTime.Compare(t1, t2) >= 0)
-            {
-                TestLibrary.TestFramework.LogError("004.1", "Compare a datetime instance with a datetime instance greater than it does not less than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2006, 9, 22, 10, 54, 56, 888);
-
-            if (DateTime.Compare(t1, t2) >= 0)
-            {
-                TestLibrary.TestFramework.LogError("004.1", "Compare a datetime instance with a datetime instance greater than it does not less than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2006, 10, 21, 10, 54, 56, 888);
-
-            if (DateTime.Compare(t1, t2) >= 0)
-            {
-                TestLibrary.TestFramework.LogError("004.1", "Compare a datetime instance with a datetime instance greater than it does not less than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2007, 9, 21, 10, 54, 56, 888);
-
-            if (DateTime.Compare(t1, t2) >= 0)
-            {
-                TestLibrary.TestFramework.LogError("004.1", "Compare a datetime instance with a datetime instance greater than it does not less than 0");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeCompare test = new DateTimeCompare();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeCompare");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimecompareto1.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimecompareto1.cs
deleted file mode 100644
index 1bb2ca2db2..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimecompareto1.cs
+++ /dev/null
@@ -1,250 +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.
-using System;
-
-/// <summary>
-/// CompareTo(System.DateTime)
-/// </summary>
-public class DateTimeCompareTo1
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Compare a datetime instance with itself");
-
-        try
-        {
-            DateTime t = new DateTime(2006, 9, 21, 10, 54, 56, 888);
-
-            if (t.CompareTo(t) != 0)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Compare a datetime instance with itself does not return 0");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: Compare a datetime instance with a datetime instance less than it");
-
-        try
-        {
-            DateTime t1 = new DateTime(2006, 9, 21, 10, 54, 56, 888);
-            DateTime t2 = new DateTime(2006, 9, 21, 10, 54, 56, 887);
-
-            if (t1.CompareTo(t2) <= 0)
-            {
-                TestLibrary.TestFramework.LogError("002.1", "Compare a datetime instance with a datetime instance less than it does not greater than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2006, 9, 21, 10, 54, 55, 888);
-
-            if (t1.CompareTo(t2) <= 0)
-            {
-                TestLibrary.TestFramework.LogError("002.2", "Compare a datetime instance with a datetime instance less than it does not greater than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2006, 9, 21, 10, 53, 56, 888);
-
-            if (t1.CompareTo(t2) <= 0)
-            {
-                TestLibrary.TestFramework.LogError("002.3", "Compare a datetime instance with a datetime instance less than it does not greater than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2006, 9, 21, 9, 54, 56, 888);
-
-            if (t1.CompareTo(t2) <= 0)
-            {
-                TestLibrary.TestFramework.LogError("002.4", "Compare a datetime instance with a datetime instance less than it does not greater than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2006, 9, 20, 10, 54, 56, 888);
-
-            if (t1.CompareTo(t2) <= 0)
-            {
-                TestLibrary.TestFramework.LogError("002.5", "Compare a datetime instance with a datetime instance less than it does not greater than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2006, 8, 21, 10, 54, 56, 888);
-
-            if (t1.CompareTo(t2) <= 0)
-            {
-                TestLibrary.TestFramework.LogError("002.6", "Compare a datetime instance with a datetime instance less than it does not greater than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2005, 9, 21, 10, 54, 56, 888);
-
-            if (t1.CompareTo(t2) <= 0)
-            {
-                TestLibrary.TestFramework.LogError("002.7", "Compare a datetime instance with a datetime instance less than it does not greater than 0");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: Compare a datetime instance equal to it");
-
-        try
-        {
-            DateTime t1 = new DateTime(2006, 9, 21, 10, 54, 56, 888);
-            DateTime t2 = new DateTime(2006, 9, 21, 10, 54, 56, 888);
-
-            if (t1.CompareTo(t2) != 0)
-            {
-                TestLibrary.TestFramework.LogError("003.1", "Compare a datetime instance  equal to it does not return 0");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("003.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest4()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest4: Compare a datetime instance with a datetime instance greater than it");
-
-        try
-        {
-            DateTime t1 = new DateTime(2006, 9, 21, 10, 54, 56, 888);
-            DateTime t2 = new DateTime(2006, 9, 21, 10, 54, 56, 889);
-
-            if (t1.CompareTo(t2) >= 0)
-            {
-                TestLibrary.TestFramework.LogError("004.1", "Compare a datetime instance with a datetime instance greater than it does not less than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2006, 9, 21, 10, 54, 57, 888);
-
-            if (t1.CompareTo(t2) >= 0)
-            {
-                TestLibrary.TestFramework.LogError("004.1", "Compare a datetime instance with a datetime instance greater than it does not less than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2006, 9, 21, 10, 55, 56, 888);
-
-            if (t1.CompareTo(t2) >= 0)
-            {
-                TestLibrary.TestFramework.LogError("004.1", "Compare a datetime instance with a datetime instance greater than it does not less than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2006, 9, 21, 11, 54, 56, 888);
-
-            if (t1.CompareTo(t2) >= 0)
-            {
-                TestLibrary.TestFramework.LogError("004.1", "Compare a datetime instance with a datetime instance greater than it does not less than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2006, 9, 22, 10, 54, 56, 888);
-
-            if (t1.CompareTo(t2) >= 0)
-            {
-                TestLibrary.TestFramework.LogError("004.1", "Compare a datetime instance with a datetime instance greater than it does not less than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2006, 10, 21, 10, 54, 56, 888);
-
-            if (t1.CompareTo(t2) >= 0)
-            {
-                TestLibrary.TestFramework.LogError("004.1", "Compare a datetime instance with a datetime instance greater than it does not less than 0");
-                retVal = false;
-            }
-
-            t2 = new DateTime(2007, 9, 21, 10, 54, 56, 888);
-
-            if (t1.CompareTo(t2) >= 0)
-            {
-                TestLibrary.TestFramework.LogError("004.1", "Compare a datetime instance with a datetime instance greater than it does not less than 0");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeCompareTo1 test = new DateTimeCompareTo1();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeCompareTo1");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimector1.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimector1.cs
deleted file mode 100644
index 41e4c0c39d..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimector1.cs
+++ /dev/null
@@ -1,342 +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.
-using System;
-
-/// <summary>
-/// ctor(System.Int32,System.Int32,System.Int32)
-/// </summary>
-public class DateTimeCtor1
-{
-    #region Private Fields
-    private int m_ErrorNo = 0;
-    #endregion
-
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-
-        TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-        retVal = NegTest2() && retVal;
-        retVal = NegTest3() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: We can call ctor(System.Int32,System.Int32,System.Int32) to constructor a new DateTime instance by using valid value");
-
-        try
-        {
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28);
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: We can call ctor(System.Int32,System.Int32,System.Int32) to constructor a new DateTime instance by using MAX/MIN values");
-
-        try
-        {
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1);
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31);
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31);
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1);
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29);
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28);
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30);
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: We can call ctor(System.Int32,System.Int32,System.Int32) to constructor a new DateTime instance by using correct day/month pair");
-
-        try
-        {
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29);
-            retVal = retVal && VerifyDateTimeHelper(2006, 2, 28);
-            retVal = retVal && VerifyDateTimeHelper(2006, 4, 30);
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    public bool NegTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: ArgumentOutOfRangeException should be thrown when year is less than 1 or greater than 9999.");
-
-        try
-        {
-            DateTime value = new DateTime(0, 1, 1);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when year is less than 1");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            DateTime value = new DateTime(10000, 1, 1);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when year is greater than 9999");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest2: ArgumentOutOfRangeException should be thrown when month is less than 1 or greater than 12");
-
-        try
-        {
-            DateTime value = new DateTime(2006, 0, 1);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when month is less than 1");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            DateTime value = new DateTime(2006, 13, 1);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when month is greater than 12");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest3: ArgumentOutOfRangeException should be thrown when day is less than 1 or greater than the number of days in month");
-
-        try
-        {
-            DateTime value = new DateTime(2006, 1, 0);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when day is less than 1");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            DateTime value = new DateTime(2006, 1, 32);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when day is greater than the number of days in month");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            DateTime value = new DateTime(2006, 2, 29);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when day is greater than the number of days in month");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            DateTime value = new DateTime(2006, 4, 31);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when day is greater than the number of days in month");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeCtor1 test = new DateTimeCtor1();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeCtor1");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    #region Private Methods
-    private bool VerifyDateTimeHelper(int desiredYear, int desiredMonth, int desiredDay)
-    {
-        bool retVal = true;
-
-        DateTime value = new DateTime(desiredYear, desiredMonth, desiredDay);
-        m_ErrorNo++;
-        if ((desiredYear != value.Year) || (desiredMonth != value.Month) || (desiredDay != value.Day))
-        {
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "We can call ctor(System.Int32,System.Int32,System.Int32) to constructor a wrong DateTime instance by using valid value");
-            TestLibrary.TestFramework.LogInformation("[LOCAL VARIABLES] desiredYear = " + desiredYear.ToString() + ", desiredMonth = " + desiredMonth.ToString() + ", desiredDay = " + desiredDay.ToString() + ", actualYear = " + value.Year.ToString() + ", actualMonth = " + value.Month.ToString() + ", actualDay = " + value.Day.ToString());
-            retVal = false;
-        }
-
-        m_ErrorNo++;
-        if ((value.Hour != 0) || (value.Minute != 0) || (value.Second != 0))
-        {
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "We can call ctor(System.Int32,System.Int32,System.Int32) to constructor a wrong DateTime instance by using valid value");
-            TestLibrary.TestFramework.LogInformation("[LOCAL VARIABLES] desiredHour = 0, desiredMinute = 0, desiredSecond = 0, actualHour = " + value.Hour.ToString() + ", actualMinute = " + value.Minute.ToString() + ", actualSecond = " + value.Second.ToString());
-            retVal = false;
-        }
-
-        m_ErrorNo++;
-        if (value.Kind != DateTimeKind.Unspecified)
-        {
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "We can call ctor(System.Int32,System.Int32,System.Int32) to constructor a wrong DateTime instance by using valid value");
-            TestLibrary.TestFramework.LogInformation("[LOCAL VARIABLES] desiredKind = DateTimeKind.Unspecified" + ", actualKind = " + value.Kind.ToString());
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimector3.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimector3.cs
deleted file mode 100644
index 8943fa3f23..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimector3.cs
+++ /dev/null
@@ -1,521 +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.
-using System;
-
-/// <summary>
-/// ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)
-/// </summary>
-public class DateTimeCtor3
-{
-    #region Private Fields
-    private int m_ErrorNo = 0;
-    #endregion
-
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-
-        TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-        retVal = NegTest2() && retVal;
-        retVal = NegTest3() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: We can call ctor to constructor a new DateTime instance by using valid value");
-
-        try
-        {
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 16, 7, 43);
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 4, 7, 43);
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 12, 0, 0);
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 12, 56, 56);
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: We can call ctor to constructor a new DateTime instance by using MAX/MIN values");
-
-        try
-        {
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 16, 7, 43);
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 23, 59, 59);
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 0, 0, 0);
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 0, 59, 59);
-
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 16, 7, 43);
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 23, 59, 59);
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 0, 0, 0);
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 0, 59, 59);
-
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 16, 7, 43);
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 23, 59, 59);
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 0, 0, 0);
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 0, 59, 59);
-
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 16, 7, 43);
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 23, 59, 59);
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 0, 0, 0);
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 0, 59, 59);
-
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 16, 7, 43);
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 23, 59, 59);
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 0, 0, 0);
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 0, 59, 59);
-
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 16, 7, 43);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 23, 59, 59);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 0, 0, 0);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 0, 59, 59);
-
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 16, 7, 43);
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 23, 59, 59);
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 0, 0, 0);
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 0, 59, 59);
-
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 16, 7, 43);
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 23, 59, 59);
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 0, 0, 0);
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 0, 59, 59);
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: We can call ctor to constructor a new DateTime instance by using correct day/month pair");
-
-        try
-        {
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 16, 7, 43);
-            retVal = retVal && VerifyDateTimeHelper(2006, 2, 28, 12, 0, 0);
-            retVal = retVal && VerifyDateTimeHelper(2006, 4, 30, 16, 7, 43);
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    public bool NegTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: ArgumentOutOfRangeException should be thrown when year is less than 1 or greater than 9999.");
-
-        try
-        {
-            DateTime value = new DateTime(0, 1, 1, 1, 1, 1);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when year is less than 1");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            DateTime value = new DateTime(10000, 1, 1, 1, 1, 1);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when year is greater than 9999");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest2: ArgumentOutOfRangeException should be thrown when month is less than 1 or greater than 12");
-
-        try
-        {
-            DateTime value = new DateTime(2006, 0, 1, 1, 1, 1);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when month is less than 1");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            DateTime value = new DateTime(2006, 13, 1, 1, 1, 1);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when month is greater than 12");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest3: ArgumentOutOfRangeException should be thrown when day is less than 1 or greater than the number of days in month");
-
-        try
-        {
-            DateTime value = new DateTime(2006, 1, 0, 1, 1, 1);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when day is less than 1");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            DateTime value = new DateTime(2006, 1, 32, 1, 1, 1);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when day is greater than the number of days in month");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            DateTime value = new DateTime(2006, 2, 29, 1, 1, 1);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when day is greater than the number of days in month");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            DateTime value = new DateTime(2006, 4, 31, 1, 1, 1);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when day is greater than the number of days in month");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest4()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest4: ArgumentOutOfRangeException should be thrown when hour is less than 0 or greater than 23");
-
-        try
-        {
-            DateTime value = new DateTime(2006, 1, 1, -1, 1, 1);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when hour is less than 0");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            DateTime value = new DateTime(2006, 1, 1, 24, 1, 1);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when hour is greater than 23");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest5()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest5: ArgumentOutOfRangeException should be thrown when minute is less than 0 or greater than 59");
-
-        try
-        {
-            DateTime value = new DateTime(2006, 1, 1, 1, -1, 1);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown minute year is less than 0");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            DateTime value = new DateTime(2006, 1, 1, 1, 60, 1);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when minute is greater than 59");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest6()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest6: ArgumentOutOfRangeException should be thrown when second is less than 0 or greater than 59");
-
-        try
-        {
-            DateTime value = new DateTime(2006, 1, 1, 1, 1, -1);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when second is less than 0");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            DateTime value = new DateTime(2006, 1, 1, 1, 1, 60);
-
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when second is greater than 59");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            m_ErrorNo++;
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeCtor3 test = new DateTimeCtor3();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeCtor3");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    #region Private Methods
-    private bool VerifyDateTimeHelper(int desiredYear, int desiredMonth, int desiredDay, int desiredHour, int desiredMinute, int desiredSecond)
-    {
-        bool retVal = true;
-
-        DateTime value = new DateTime(desiredYear, desiredMonth, desiredDay, desiredHour, desiredMinute, desiredSecond);
-        m_ErrorNo++;
-        if ((desiredYear != value.Year) || (desiredMonth != value.Month) || (desiredDay != value.Day) ||
-            (desiredHour != value.Hour) || (desiredMinute != value.Minute) || (desiredSecond != value.Second))
-        {
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "We can call ctor(System.Int32,System.Int32,System.Int32) to constructor a wrong DateTime instance by using valid value");
-            TestLibrary.TestFramework.LogInformation("[LOCAL VARIABLES] desiredYear = " + desiredYear.ToString() +
-                                                                                             ", desiredMonth = " + desiredMonth.ToString() + 
-                                                                                             ", desiredDay = " + desiredDay.ToString() + 
-                                                                                             ", desiredHour = " + desiredHour.ToString() +
-                                                                                             ", desiredMinute = " + desiredMinute.ToString() +
-                                                                                             ", desiredSecond = " + desiredSecond.ToString() +
-                                                                                             ", actualYear = " + value.Year.ToString() + 
-                                                                                             ", actualMonth = " + value.Month.ToString() + 
-                                                                                             ", actualDay = " + value.Day.ToString() + 
-                                                                                             ", actualHour = " + value.Hour.ToString() +
-                                                                                             ", actualMinute = " + value.Minute.ToString() +
-                                                                                             ", actualSecond = " + value.Second.ToString());
-            retVal = false;
-        }
-
-        m_ErrorNo++;
-        if (value.Kind != DateTimeKind.Unspecified)
-        {
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "We can call ctor(System.Int32,System.Int32,System.Int32) to constructor a wrong DateTime instance by using valid value");
-            TestLibrary.TestFramework.LogInformation("[LOCAL VARIABLES] desiredKind = DateTimeKind.Unspecified" + ", actualKind = " + value.Kind.ToString());
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimector4.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimector4.cs
deleted file mode 100644
index 4035254ad2..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimector4.cs
+++ /dev/null
@@ -1,638 +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.
-using System;
-
-/// <summary>
-/// ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.DateTimeKind)
-/// </summary>
-public class DateTimeCtor4
-{
-    #region Private Fields
-    private int m_ErrorNo = 0;
-    #endregion
-
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-
-        TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-        retVal = NegTest2() && retVal;
-        retVal = NegTest3() && retVal;
-        retVal = NegTest4() && retVal;
-        retVal = NegTest5() && retVal;
-        retVal = NegTest6() && retVal;
-        retVal = NegTest7() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: We can call ctor to constructor a new DateTime instance by using valid value");
-
-        try
-        {
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 16, 7, 43, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 4, 7, 43, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 12, 0, 0, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 12, 0, 0, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 12, 0, 0, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 12, 56, 56, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 12, 56, 56, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 12, 56, 56, DateTimeKind.Utc);
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: We can call ctor to constructor a new DateTime instance by using MAX/MIN values");
-
-        try
-        {
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 16, 7, 43, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 23, 59, 59, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 0, 0, 0, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 0, 59, 59, DateTimeKind.Local);
-
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 16, 7, 43, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 23, 59, 59, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 0, 0, 0, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 0, 59, 59, DateTimeKind.Utc);
-
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 0, 0, 0, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 0, 59, 59, DateTimeKind.Unspecified);
-
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 16, 7, 43, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 23, 59, 59, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 0, 0, 0, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 0, 59, 59, DateTimeKind.Local);
-
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 16, 7, 43, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 23, 59, 59, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 0, 0, 0, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 0, 59, 59, DateTimeKind.Utc);
-
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 0, 0, 0, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 0, 59, 59, DateTimeKind.Unspecified);
-
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 16, 7, 43, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 23, 59, 59, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 0, 0, 0, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 0, 59, 59, DateTimeKind.Local);
-
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 16, 7, 43, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 23, 59, 59, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 0, 0, 0, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 0, 59, 59, DateTimeKind.Utc);
-
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 0, 0, 0, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 0, 59, 59, DateTimeKind.Unspecified);
-
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 16, 7, 43, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 23, 59, 59, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 0, 0, 0, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 0, 59, 59, DateTimeKind.Local);
-
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 16, 7, 43, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 23, 59, 59, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 0, 0, 0, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 0, 59, 59, DateTimeKind.Utc);
-
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 0, 0, 0, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 0, 59, 59, DateTimeKind.Unspecified);
-
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 16, 7, 43, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 23, 59, 59, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 0, 0, 0, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 0, 59, 59, DateTimeKind.Local);
-
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 16, 7, 43, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 23, 59, 59, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 0, 0, 0, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 0, 59, 59, DateTimeKind.Utc);
-
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 0, 0, 0, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 0, 59, 59, DateTimeKind.Unspecified);
-
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 16, 7, 43, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 23, 59, 59, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 0, 0, 0, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 0, 59, 59, DateTimeKind.Local);
-
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 16, 7, 43, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 23, 59, 59, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 0, 0, 0, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 0, 59, 59, DateTimeKind.Utc);
-
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 0, 0, 0, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 0, 59, 59, DateTimeKind.Unspecified);
-
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 16, 7, 43, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 23, 59, 59, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 0, 0, 0, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 0, 59, 59, DateTimeKind.Local);
-
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 16, 7, 43, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 23, 59, 59, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 0, 0, 0, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 0, 59, 59, DateTimeKind.Utc);
-
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 0, 0, 0, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 0, 59, 59, DateTimeKind.Unspecified);
-
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 16, 7, 43, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 23, 59, 59, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 0, 0, 0, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 0, 59, 59, DateTimeKind.Local);
-
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 16, 7, 43, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 23, 59, 59, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 0, 0, 0, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 0, 59, 59, DateTimeKind.Utc);
-
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 0, 0, 0, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 0, 59, 59, DateTimeKind.Unspecified);
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: We can call ctor to constructor a new DateTime instance by using correct day/month pair");
-
-        try
-        {
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 16, 7, 43, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 16, 7, 43, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 16, 7, 43, DateTimeKind.Utc);
-
-            retVal = retVal && VerifyDateTimeHelper(2006, 2, 28, 12, 0, 0, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2006, 2, 28, 12, 0, 0, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(2006, 2, 28, 12, 0, 0, DateTimeKind.Utc);
-
-            retVal = retVal && VerifyDateTimeHelper(2006, 4, 30, 16, 7, 43, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2006, 4, 30, 16, 7, 43, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(2006, 4, 30, 16, 7, 43, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2006, 4, 30, 16, 7, 43, DateTimeKind.Utc | DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(2006, 4, 30, 16, 7, 43, DateTimeKind.Local | DateTimeKind.Unspecified);
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("003.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    public bool NegTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: ArgumentOutOfRangeException should be thrown when year is less than 1 or greater than 9999.");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(0, 1, 1, 1, 1, 1, DateTimeKind.Local);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when year is less than 1");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("101.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(10000, 1, 1, 1, 1, 1, DateTimeKind.Utc);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when year is greater than 9999");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("101.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest2: ArgumentOutOfRangeException should be thrown when month is less than 1 or greater than 12");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 0, 1, 1, 1, 1, DateTimeKind.Utc);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when month is less than 1");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("102.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 13, 1, 1, 1, 1, DateTimeKind.Local);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when month is greater than 12");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("102.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest3: ArgumentOutOfRangeException should be thrown when day is less than 1 or greater than the number of days in month");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 0, 1, 1, 1, DateTimeKind.Local);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when day is less than 1");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("103.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 32, 1, 1, 1, DateTimeKind.Utc);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when day is greater than the number of days in month");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("103.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 2, 29, 1, 1, 1, DateTimeKind.Utc);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when day is greater than the number of days in month");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("103.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 4, 31, 1, 1, 1, DateTimeKind.Local);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when day is greater than the number of days in month");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("103.3", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest4()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest4: ArgumentOutOfRangeException should be thrown when hour is less than 0 or greater than 23");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, -1, 1, 1, DateTimeKind.Local);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when hour is less than 0");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("104.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 24, 1, 1, DateTimeKind.Local);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when hour is greater than 23");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("104.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest5()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest5: ArgumentOutOfRangeException should be thrown when minute is less than 0 or greater than 59");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 1, -1, 1, DateTimeKind.Local);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown minute year is less than 0");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("105.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 1, 60, 1, DateTimeKind.Local);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when minute is greater than 59");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("105.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest6()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest6: ArgumentOutOfRangeException should be thrown when second is less than 0 or greater than 59");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 1, 1, -1, DateTimeKind.Utc);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when second is less than 0");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("106.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 1, 1, 60, DateTimeKind.Local);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when second is greater than 59");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("106.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest7()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest7: ArgumentException should be thrown when kind is not one of the DateTimeKind values.");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 1, 1, 1, DateTimeKind.Utc | DateTimeKind.Local);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentException is not thrown when kind is DateTimeKind.Utc | DateTimeKind.Local");
-            retVal = false;
-        }
-        catch (ArgumentException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("107.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 1, 1, 1, (DateTimeKind)(-1));
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentException is not thrown when kind is DateTimeKind.Local | DateTimeKind.Unspecified");
-            retVal = false;
-        }
-        catch (ArgumentException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("107.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeCtor4 test = new DateTimeCtor4();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeCtor4");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    #region Private Methods
-    private bool VerifyDateTimeHelper(int desiredYear, 
-        int desiredMonth, 
-        int desiredDay, 
-        int desiredHour, 
-        int desiredMinute, 
-        int desiredSecond,
-        DateTimeKind desiredKind)
-    {
-        bool retVal = true;
-
-        DateTime value = new DateTime(desiredYear, desiredMonth, desiredDay, 
-            desiredHour, desiredMinute, desiredSecond, desiredKind);
-
-        m_ErrorNo++;
-        if ((desiredYear != value.Year) || 
-            (desiredMonth != value.Month) || 
-            (desiredDay != value.Day) ||
-            (desiredHour != value.Hour) || 
-            (desiredMinute != value.Minute) || 
-            (desiredSecond != value.Second) ||
-            (desiredKind != value.Kind))
-        {
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Calling ctor constructors a wrong DateTime instance by using valid value");
-            TestLibrary.TestFramework.LogInformation("[LOCAL VARIABLES] desiredYear = " + desiredYear.ToString() +
-                                                                                             ", desiredMonth = " + desiredMonth.ToString() +
-                                                                                             ", desiredDay = " + desiredDay.ToString() +
-                                                                                             ", desiredHour = " + desiredHour.ToString() +
-                                                                                             ", desiredMinute = " + desiredMinute.ToString() +
-                                                                                             ", desiredSecond = " + desiredSecond.ToString() +
-                                                                                             ", desiredKind = " + desiredKind.ToString() +
-                                                                                             ", actualYear = " + value.Year.ToString() +
-                                                                                             ", actualMonth = " + value.Month.ToString() +
-                                                                                             ", actualDay = " + value.Day.ToString() +
-                                                                                             ", actualHour = " + value.Hour.ToString() +
-                                                                                             ", actualMinute = " + value.Minute.ToString() +
-                                                                                             ", actualSecond = " + value.Second.ToString() +
-                                                                                             ", actualKind = " + value.Kind.ToString());
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimector6.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimector6.cs
deleted file mode 100644
index 8f644bd9ba..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimector6.cs
+++ /dev/null
@@ -1,570 +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.
-using System;
-
-/// <summary>
-/// ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)
-/// </summary>
-public class DateTimeCtor6
-{
-    #region Private Fields
-    private int m_ErrorNo = 0;
-    #endregion
-
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-
-        TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-        retVal = NegTest2() && retVal;
-        retVal = NegTest3() && retVal;
-        retVal = NegTest4() && retVal;
-        retVal = NegTest5() && retVal;
-        retVal = NegTest6() && retVal;
-        retVal = NegTest7() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: We can call ctor to constructor a new DateTime instance by using valid value");
-
-        try
-        {
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 16, 7, 43, 500);
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 12, 0, 0, 500);
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 12, 56, 56, 900);
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: We can call ctor to constructor a new DateTime instance by using MAX/MIN values");
-
-        try
-        {
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 16, 7, 43, 500);
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 23, 59, 59, 999);
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 0, 0, 0, 0);
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 0, 59, 59, 999);
-
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 16, 7, 43, 500);
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 23, 59, 59, 999);
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 0, 0, 0, 999);
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 0, 59, 59, 0);
-
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 16, 7, 43, 500);
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 23, 59, 59, 999);
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 0, 0, 0, 999);
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 0, 59, 59, 0);
-
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 16, 7, 43, 500);
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 23, 59, 59, 999);
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 0, 0, 0, 0);
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 0, 59, 59, 999);
-
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 16, 7, 43, 500);
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 23, 59, 59, 999);
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 0, 0, 0, 0);
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 0, 59, 59, 999);
-
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 16, 7, 43, 500);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 23, 59, 59, 999);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 0, 0, 0, 999);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 0, 59, 59, 0);
-
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 16, 7, 43, 500);
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 23, 59, 59, 999);
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 0, 0, 0, 0);
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 0, 59, 59, 999);
-
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 16, 7, 43, 500);
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 23, 59, 59, 999);
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 0, 0, 0, 999);
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 0, 59, 59, 0);
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: We can call ctor to constructor a new DateTime instance by using correct day/month pair");
-
-        try
-        {
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 16, 7, 43, 500);
-            retVal = retVal && VerifyDateTimeHelper(2006, 2, 28, 12, 0, 0, 0);
-            retVal = retVal && VerifyDateTimeHelper(2006, 4, 30, 16, 7, 43, 100);
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("003.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-
-    #region Nagetive Test Cases
-    public bool NegTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: ArgumentOutOfRangeException should be thrown when year is less than 1 or greater than 9999.");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(0, 1, 1, 1, 1, 1, 1);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when year is less than 1");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("101.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(10000, 1, 1, 1, 1, 1, 1);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when year is greater than 9999");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("101.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest2: ArgumentOutOfRangeException should be thrown when month is less than 1 or greater than 12");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 0, 1, 1, 1, 1, 1);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when month is less than 1");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("102.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 13, 1, 1, 1, 1, 1);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when month is greater than 12");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("102.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest3: ArgumentOutOfRangeException should be thrown when day is less than 1 or greater than the number of days in month");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 0, 1, 1, 1, 1);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when day is less than 1");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("103.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 32, 1, 1, 1, 1);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when day is greater than the number of days in month");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("103.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 2, 29, 1, 1, 1, 1);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when day is greater than the number of days in month");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("103.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 4, 31, 1, 1, 1, 1);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when day is greater than the number of days in month");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("103.3", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest4()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest4: ArgumentOutOfRangeException should be thrown when hour is less than 0 or greater than 23");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, -1, 1, 1, 1);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when hour is less than 0");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("104.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 24, 1, 1, 1);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when hour is greater than 23");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("104.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest5()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest5: ArgumentOutOfRangeException should be thrown when minute is less than 0 or greater than 59");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 1, -1, 1, 1);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown minute year is less than 0");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("105.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 1, 60, 1, 1);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when minute is greater than 59");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("105.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest6()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest6: ArgumentOutOfRangeException should be thrown when second is less than 0 or greater than 59");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 1, 1, -1, 1);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when second is less than 0");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("106.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 1, 1, 60, 1);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when second is greater than 59");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("106.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest7()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest7: ArgumentOutOfRangeException should be thrown when millisecond is less than 0 or greater than 999");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 1, 1, 1, -1);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when millisecond is less than 0");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("107.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 1, 1, 1, 1000);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when millisecond is greater than 999");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("107.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeCtor6 test = new DateTimeCtor6();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeCtor6");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    #region Private Methods
-    private bool VerifyDateTimeHelper(int desiredYear,
-        int desiredMonth,
-        int desiredDay,
-        int desiredHour,
-        int desiredMinute,
-        int desiredSecond,
-        int desiredMillisecond)
-    {
-        bool retVal = true;
-
-        DateTime value = new DateTime(desiredYear, desiredMonth, desiredDay,
-            desiredHour, desiredMinute, desiredSecond, desiredMillisecond);
-
-        m_ErrorNo++;
-        if ((desiredYear != value.Year) ||
-            (desiredMonth != value.Month) ||
-            (desiredDay != value.Day) ||
-            (desiredHour != value.Hour) ||
-            (desiredMinute != value.Minute) ||
-            (desiredSecond != value.Second) ||
-            (desiredMillisecond != value.Millisecond) )
-        {
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Calling ctor constructors a wrong DateTime instance by using valid value");
-            TestLibrary.TestFramework.LogInformation("[LOCAL VARIABLES] desiredYear = " + desiredYear.ToString() +
-                                                                                             ", desiredMonth = " + desiredMonth.ToString() +
-                                                                                             ", desiredDay = " + desiredDay.ToString() +
-                                                                                             ", desiredHour = " + desiredHour.ToString() +
-                                                                                             ", desiredMinute = " + desiredMinute.ToString() +
-                                                                                             ", desiredSecond = " + desiredSecond.ToString() +
-                                                                                             ", desiredMillisecond = " + desiredMillisecond.ToString() +
-                                                                                             ", actualYear = " + value.Year.ToString() +
-                                                                                             ", actualMonth = " + value.Month.ToString() +
-                                                                                             ", actualDay = " + value.Day.ToString() +
-                                                                                             ", actualHour = " + value.Hour.ToString() +
-                                                                                             ", actualMinute = " + value.Minute.ToString() +
-                                                                                             ", actualSecond = " + value.Second.ToString() +
-                                                                                             ", actualMillisecond = " + value.Millisecond.ToString());
-            retVal = false;
-        }
-
-        m_ErrorNo++;
-        if (value.Kind != DateTimeKind.Unspecified)
-        {
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Calling ctor constructors a wrong DateTime instance by using valid value");
-            TestLibrary.TestFramework.LogInformation("[LOCAL VARIABLES] desiredKind = DateTimeKind.Unspecified" + ", actualKind = " + value.Kind.ToString());
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimector7.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimector7.cs
deleted file mode 100644
index 3e839662fb..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimector7.cs
+++ /dev/null
@@ -1,689 +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.
-using System;
-
-/// <summary>
-/// ctor(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.DateTimeKind)
-/// </summary>
-public class DateTimeCtor7
-{
-    #region Private Fields
-    private int m_ErrorNo = 0;
-    #endregion
-
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-
-        TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-        retVal = NegTest2() && retVal;
-        retVal = NegTest3() && retVal;
-        retVal = NegTest4() && retVal;
-        retVal = NegTest5() && retVal;
-        retVal = NegTest6() && retVal;
-        retVal = NegTest7() && retVal;
-        retVal = NegTest8() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: We can call ctor to constructor a new DateTime instance by using valid value");
-
-        try
-        {
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 16, 7, 43, 500, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 4, 7, 43, 100, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 12, 0, 0, 1, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 12, 0, 0, 998, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 12, 0, 0, 2, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 12, 56, 56, 100, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 12, 56, 56, 200, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(2006, 8, 28, 12, 56, 56, 300, DateTimeKind.Utc);
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: We can call ctor to constructor a new DateTime instance by using MAX/MIN values");
-
-        try
-        {
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 16, 7, 43, 0, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 23, 59, 59, 999, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 0, 59, 59, 0, DateTimeKind.Local);
-
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 16, 7, 43, 500, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 23, 59, 59, 999, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 0, 59, 59, 59, DateTimeKind.Utc);
-
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(1, 1, 1, 0, 59, 59, 99, DateTimeKind.Unspecified);
-
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 16, 7, 43, 500, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 23, 59, 59, 999, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 0, 0, 0, 0, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 0, 59, 59, 0, DateTimeKind.Local);
-
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 16, 7, 43, 1, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 23, 59, 59, 998, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 0, 0, 0, 999, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 0, 59, 59, 0, DateTimeKind.Utc);
-
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 0, 0, 0, 1, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(9999, 12, 31, 0, 59, 59, 999, DateTimeKind.Unspecified);
-
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 16, 7, 43, 1, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 23, 59, 59, 998, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 0, 0, 0, 0, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 0, 59, 59, 999, DateTimeKind.Local);
-
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 16, 7, 43, 1, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 23, 59, 59, 998, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 0, 0, 0, 0, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 0, 59, 59, 999, DateTimeKind.Utc);
-
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 0, 0, 0, 0, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(1, 12, 31, 0, 59, 59, 999, DateTimeKind.Unspecified);
-
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 16, 7, 43, 1, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 23, 59, 59, 998, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 0, 0, 0, 0, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 0, 59, 59, 999, DateTimeKind.Local);
-
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 16, 7, 43, 1, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 23, 59, 59, 998, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 0, 59, 59, 999, DateTimeKind.Utc);
-
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(9999, 1, 1, 0, 59, 59, 999, DateTimeKind.Unspecified);
-
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 16, 7, 43, 1, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 23, 59, 59, 998, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 0, 0, 0, 0, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 0, 59, 59, 999, DateTimeKind.Local);
-
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 16, 7, 43, 1, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 23, 59, 59, 998, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 0, 0, 0, 0, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 0, 59, 59, 999, DateTimeKind.Utc);
-
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 0, 0, 0, 0, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(2000, 1, 31, 0, 59, 59, 999, DateTimeKind.Unspecified);
-
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 16, 7, 43, 1, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 23, 59, 59, 998, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 0, 0, 0, 0, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 0, 59, 59, 999, DateTimeKind.Local);
-
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 16, 7, 43, 1, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 23, 59, 59, 998, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 0, 0, 0, 0, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 0, 59, 59, 999, DateTimeKind.Utc);
-
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 0, 0, 0, 0, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 0, 59, 59, 999, DateTimeKind.Unspecified);
-
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 16, 7, 43, 1, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 23, 59, 59, 998, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 0, 0, 0, 0, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 0, 59, 59, 999, DateTimeKind.Local);
-
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 16, 7, 43, 1, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 23, 59, 59, 998, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 0, 0, 0, 0, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 0, 59, 59, 999, DateTimeKind.Utc);
-
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 0, 0, 0, 0, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(2001, 2, 28, 0, 59, 59, 999, DateTimeKind.Unspecified);
-
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 16, 7, 43, 1, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 23, 59, 59, 998, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 0, 0, 0, 0, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 0, 59, 59, 999, DateTimeKind.Local);
-
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 16, 7, 43, 1, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 23, 59, 59, 998, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 0, 0, 0, 0, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 0, 59, 59, 999, DateTimeKind.Utc);
-
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 0, 0, 0, 0, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(2001, 4, 30, 0, 59, 59, 999, DateTimeKind.Unspecified);
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: We can call ctor to constructor a new DateTime instance by using correct day/month pair");
-
-        try
-        {
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 16, 7, 43, 1, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 16, 7, 43, 999, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(2000, 2, 29, 16, 7, 43, 998, DateTimeKind.Utc);
-
-            retVal = retVal && VerifyDateTimeHelper(2006, 2, 28, 12, 0, 0, 0, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2006, 2, 28, 12, 0, 0, 0, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(2006, 2, 28, 12, 0, 0, 0, DateTimeKind.Utc);
-
-            retVal = retVal && VerifyDateTimeHelper(2006, 4, 30, 16, 7, 43, 1, DateTimeKind.Local);
-            retVal = retVal && VerifyDateTimeHelper(2006, 4, 30, 16, 7, 43, 1, DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(2006, 4, 30, 16, 7, 43, 1, DateTimeKind.Utc);
-            retVal = retVal && VerifyDateTimeHelper(2006, 4, 30, 16, 7, 43, 1, DateTimeKind.Utc | DateTimeKind.Unspecified);
-            retVal = retVal && VerifyDateTimeHelper(2006, 4, 30, 16, 7, 43, 1, DateTimeKind.Local | DateTimeKind.Unspecified);
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("003.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-
-    #region Nagetive Test Cases
-    public bool NegTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: ArgumentOutOfRangeException should be thrown when year is less than 1 or greater than 9999.");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(0, 1, 1, 1, 1, 1, 1, DateTimeKind.Local);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when year is less than 1");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("101.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(10000, 1, 1, 1, 1, 1, 1, DateTimeKind.Utc);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when year is greater than 9999");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("101.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest2: ArgumentOutOfRangeException should be thrown when month is less than 1 or greater than 12");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 0, 1, 1, 1, 1, 1, DateTimeKind.Utc);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when month is less than 1");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("102.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 13, 1, 1, 1, 1, 1, DateTimeKind.Local);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when month is greater than 12");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("102.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest3: ArgumentOutOfRangeException should be thrown when day is less than 1 or greater than the number of days in month");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 0, 1, 1, 1, 1, DateTimeKind.Local);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when day is less than 1");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("103.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 32, 1, 1, 1, 1, DateTimeKind.Utc);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when day is greater than the number of days in month");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("103.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 2, 29, 1, 1, 1, 1, DateTimeKind.Utc);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when day is greater than the number of days in month");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("103.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 4, 31, 1, 1, 1, 1, DateTimeKind.Local);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when day is greater than the number of days in month");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("103.3", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest4()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest4: ArgumentOutOfRangeException should be thrown when hour is less than 0 or greater than 23");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, -1, 1, 1, 1, DateTimeKind.Local);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when hour is less than 0");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("104.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 24, 1, 1, 1, DateTimeKind.Local);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when hour is greater than 23");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("104.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest5()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest5: ArgumentOutOfRangeException should be thrown when minute is less than 0 or greater than 59");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 1, -1, 1, 1, DateTimeKind.Local);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown minute year is less than 0");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("105.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 1, 60, 1, 1, DateTimeKind.Local);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when minute is greater than 59");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("105.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest6()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest6: ArgumentOutOfRangeException should be thrown when second is less than 0 or greater than 59");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 1, 1, -1, 1, DateTimeKind.Utc);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when second is less than 0");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("106.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 1, 1, 60, 1, DateTimeKind.Local);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when second is greater than 59");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("106.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest7()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest7: ArgumentException should be thrown when kind is not one of the DateTimeKind values.");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 1, 1, 1, 1, DateTimeKind.Utc | DateTimeKind.Local);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentException is not thrown when kind is DateTimeKind.Utc | DateTimeKind.Local");
-            retVal = false;
-        }
-        catch (ArgumentException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("107.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 1, 1, 1, 1, (DateTimeKind)(-1));
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentException is not thrown when kind is DateTimeKind.Local | DateTimeKind.Unspecified");
-            retVal = false;
-        }
-        catch (ArgumentException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("107.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest8()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest8: ArgumentOutOfRangeException should be thrown when millisecond is less than 0 or greater than 999");
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 1, 1, 1, -1, DateTimeKind.Utc);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when millisecond is less than 0");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("108.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            m_ErrorNo++;
-            DateTime value = new DateTime(2006, 1, 1, 1, 1, 1, 1000, DateTimeKind.Local);
-
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "ArgumentOutOfRangeException is not thrown when millisecond is greater than 999");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("108.1", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeCtor7 test = new DateTimeCtor7();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeCtor7");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    #region Private Methods
-    private bool VerifyDateTimeHelper(int desiredYear,
-        int desiredMonth,
-        int desiredDay,
-        int desiredHour,
-        int desiredMinute,
-        int desiredSecond,
-        int desiredMillisecond,
-        DateTimeKind desiredKind)
-    {
-        bool retVal = true;
-
-        DateTime value = new DateTime(desiredYear, desiredMonth, desiredDay,
-            desiredHour, desiredMinute, desiredSecond, desiredMillisecond, desiredKind);
-
-        m_ErrorNo++;
-        if ((desiredYear != value.Year) ||
-            (desiredMonth != value.Month) ||
-            (desiredDay != value.Day) ||
-            (desiredHour != value.Hour) ||
-            (desiredMinute != value.Minute) ||
-            (desiredSecond != value.Second) ||
-            (desiredMillisecond != value.Millisecond) ||
-            (desiredKind != value.Kind))
-        {
-            TestLibrary.TestFramework.LogError(m_ErrorNo.ToString(), "Calling ctor constructors a wrong DateTime instance by using valid value");
-            TestLibrary.TestFramework.LogInformation("[LOCAL VARIABLES] desiredYear = " + desiredYear.ToString() +
-                                                                                             ", desiredMonth = " + desiredMonth.ToString() +
-                                                                                             ", desiredDay = " + desiredDay.ToString() +
-                                                                                             ", desiredHour = " + desiredHour.ToString() +
-                                                                                             ", desiredMinute = " + desiredMinute.ToString() +
-                                                                                             ", desiredSecond = " + desiredSecond.ToString() +
-                                                                                             ", desiredMillisecond = " + desiredMillisecond.ToString() +
-                                                                                             ", desiredKind = " + desiredKind.ToString() +
-                                                                                             ", actualYear = " + value.Year.ToString() +
-                                                                                             ", actualMonth = " + value.Month.ToString() +
-                                                                                             ", actualDay = " + value.Day.ToString() +
-                                                                                             ", actualHour = " + value.Hour.ToString() +
-                                                                                             ", actualMinute = " + value.Minute.ToString() +
-                                                                                             ", actualSecond = " + value.Second.ToString() +
-                                                                                             ", actualMillisecond = " + value.Millisecond.ToString() +
-                                                                                             ", actualKind = " + value.Kind.ToString());
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimedate.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimedate.cs
deleted file mode 100644
index cfa1db7630..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimedate.cs
+++ /dev/null
@@ -1,144 +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.
-using System;
-using System.Collections.Generic;
-using System.Threading;
-using System.Globalization;
-
-/// <summary>
-/// System.DateTime.Date
-/// </summary>
-public class DateTimeDate
-{
-    public static int Main(string[] args)
-    {
-        DateTimeDate date = new DateTimeDate();
-        TestLibrary.TestFramework.BeginTestCase("Testing System.DateTime.Date property...");
-
-        if (date.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-
-        return retVal;
-    }
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Verify Date property when the created DateTime instance just is assigned to year,month and day...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(1978, 08, 29);
-            DateTime myDate = myDateTime.Date;
-
-            if (myDateTime.Year != myDate.Year || myDateTime.Month != myDate.Month || myDateTime.Day != myDate.Day)
-            {
-                TestLibrary.TestFramework.LogError("001", "The Date is wrong!");
-                retVal = false;
-            }
-            else
-            {
-                if (myDate.Hour != 0 || myDate.Minute != 0 || myDate.Second != 0)
-                {
-                    TestLibrary.TestFramework.LogError("002", "The initial time value is not equal to minnight!");
-                    retVal = false;
-                }
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("003", "Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Verify Date property when created DateTime instance's time value is less than 12:00:00...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(1978, 08, 29, 03, 00, 00);
-            DateTime myDate = myDateTime.Date;
-
-            if (myDate.Year != myDateTime.Year || myDate.Month != myDateTime.Month || myDate.Day != myDateTime.Day)
-            {
-                TestLibrary.TestFramework.LogError("004", "The Date is wrong!");
-                retVal = false;
-            }
-            else if (myDate.Hour != 0 || myDate.Minute != 0 || myDate.Second != 0)
-            {
-                TestLibrary.TestFramework.LogError("005", "The initial time value is not equal to minnight!");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Verify Date property when created DateTime instance's time value is more than 12:00:00...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(1978, 08, 29, 23, 00, 00);
-            DateTime myDate = myDateTime.Date;
-
-            if (myDateTime.Year != myDate.Year || myDateTime.Month != myDateTime.Month || myDateTime.Day != myDate.Day)
-            {
-                TestLibrary.TestFramework.LogError("007", "The Date is wrong!");
-                retVal = false;
-            }
-            else if (myDate.Hour != 0 || myDate.Minute != 0 || myDate.Second != 0)
-            {
-                TestLibrary.TestFramework.LogError("008", "The initial time value is not equal to minnight!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("009", "Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimegethashcode.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimegethashcode.cs
deleted file mode 100644
index e5d5c07d16..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimegethashcode.cs
+++ /dev/null
@@ -1,141 +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.
-using System;
-
-/// <summary>
-/// GetHashCode
-/// </summary>
-public class DateTimeGetHashCode
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Call GetHashCode on a valid instance");
-
-        try
-        {
-            DateTime t = new DateTime(2006, 9, 25, 14, 15, 59, 999);
-            int hashCode1 = t.GetHashCode();
-            int hashCode2 = t.GetHashCode();
-            if (hashCode1 != hashCode2)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Call GetHashCode on a valid instance twice does not return the same hash code");
-                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLES] hashCode1 = " + hashCode1 + ", hashCode2 = " + hashCode2);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: Call GetHashCode on a boundary value");
-
-        try
-        {
-            DateTime t = DateTime.MaxValue;
-            int hashCode1 = t.GetHashCode();
-            int hashCode2 = t.GetHashCode();
-            if (hashCode1 != hashCode2)
-            {
-                TestLibrary.TestFramework.LogError("002.1", "Call GetHashCode on a valid instance twice does not return the same hash code");
-                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLES] hashCode1 = " + hashCode1 + ", hashCode2 = " + hashCode2);
-                retVal = false;
-            }
-
-            t = DateTime.MinValue;
-            hashCode1 = t.GetHashCode();
-            hashCode2 = t.GetHashCode();
-            if (hashCode1 != hashCode2)
-            {
-                TestLibrary.TestFramework.LogError("002.2", "Call GetHashCode on a valid instance twice does not return the same hash code");
-                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLES] hashCode1 = " + hashCode1 + ", hashCode2 = " + hashCode2);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: Hash code should be the same for the same date time");
-
-        try
-        {
-            DateTime t1 = new DateTime(2006, 9, 25, 14, 15, 59, 999);
-            DateTime t2 = new DateTime(2006, 9, 25, 14, 15, 59, 999);
-            int hashCode1 = t1.GetHashCode();
-            int hashCode2 = t2.GetHashCode();
-            if (hashCode1 != hashCode2)
-            {
-                TestLibrary.TestFramework.LogError("003.1", "Call GetHashCode on a valid instance twice does not return the same hash code");
-                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLES] hashCode1 = " + hashCode1 + ", hashCode2 = " + hashCode2);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("003.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeGetHashCode test = new DateTimeGetHashCode();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeGetHashCode");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimehour.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimehour.cs
deleted file mode 100644
index b7d367f3f9..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimehour.cs
+++ /dev/null
@@ -1,99 +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.
-using System;
-using System.Collections;
-using System.Threading;
-using System.Globalization;
-
-
-/// <summary>
-/// System.DateTime.Hour
-/// </summary>
-public class DateTimeHour
-{
-    public static int Main(string[] args)
-    {
-        DateTimeHour hour = new DateTimeHour();
-        TestLibrary.TestFramework.BeginTestCase("Testing System.DateTime.Hour property...");
-
-        if (hour.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-
-        return retVal;
-    }
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Verify DateTime.Hour property when DateTime instance's hour is assigned...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(0978, 08, 29, 03, 00, 00);
-            int hour = myDateTime.Hour;
-
-            if (hour != 3)
-            {
-                TestLibrary.TestFramework.LogError("001","The hour is not correct!");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002","Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Verify DateTime.Hour property When DateTime instance is only assigned year month and day...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(1978,08,29);
-            int hour = myDateTime.Hour;
-
-            if (hour != 0)
-            {
-                TestLibrary.TestFramework.LogError("003","The hour is not zero when no value is assigned at init time!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("", "");
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimekind.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimekind.cs
deleted file mode 100644
index b797d038e3..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimekind.cs
+++ /dev/null
@@ -1,221 +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.
-using System;
-using System.Collections.Generic;
-using System.Threading;
-using System.Globalization;
-
-
-/// <summary>
-/// System.DateTime.Kind
-/// </summary>
-public class DateTimeKind
-{
-    public static int Main(string[] args)
-    {
-        DateTimeKind kind = new DateTimeKind();
-        TestLibrary.TestFramework.BeginScenario("Testing System.DateTime.Kind property...");
-
-        if (kind.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-        retVal = PosTest5() && retVal;
-        retVal = PosTest6() && retVal;
-
-        return retVal;
-    }
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Check Kind property when create an instance using Utc...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(1978, 08, 29, 03, 00, 00, System.DateTimeKind.Utc);
-
-            if (myDateTime.Kind != System.DateTimeKind.Utc)
-            {
-                TestLibrary.TestFramework.LogError("001", "The kind is wrong!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Check Kind property when create an instance using local...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(1978, 08, 29, 03, 00, 00, System.DateTimeKind.Local);
-
-            if (myDateTime.Kind != System.DateTimeKind.Local)
-            {
-                TestLibrary.TestFramework.LogError("003", "The kind is wrong!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Check Kind property when create an instance using Unspecified...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(1978, 08, 29, 03, 00, 00, System.DateTimeKind.Unspecified);
-
-            if (myDateTime.Kind != System.DateTimeKind.Unspecified)
-            {
-                TestLibrary.TestFramework.LogError("005", "The kind is wrong!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest4()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Check toUniversalTime is equal to original when create an instance using Utc...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(1978, 08, 29, 03, 00, 00, System.DateTimeKind.Utc);
-            DateTime toUniversal = myDateTime.ToUniversalTime();
-
-            if (myDateTime != toUniversal)
-            {
-                TestLibrary.TestFramework.LogError("007", "The two instances are not equal!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("008", "Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest5()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Check toLocalTime is equal to original when create an instance using local...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(1978, 08, 29, 03, 00, 00, System.DateTimeKind.Local);
-            DateTime toLocal = myDateTime.ToLocalTime();
-
-            if (myDateTime != toLocal)
-            {
-                TestLibrary.TestFramework.LogError("009", "The kind is wrong!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("010", "Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest6()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Check an instance created by Unspecified, then compare to local and universal...");
-
-        try
-        {
-            if (TimeZoneInfo.Local.BaseUtcOffset == TimeSpan.Zero) // any TZ has same alignment with UTC
-            {
-                // if we are on UTC zone, then the following test wil not make sense because all date conversion will produce the same original date value
-                return retVal;
-            }
-
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(1978, 08, 29, 03, 00, 00, System.DateTimeKind.Unspecified);
-
-            DateTime toLocal = myDateTime.ToLocalTime();
-            DateTime toUniversal = myDateTime.ToUniversalTime();
-
-            if (myDateTime == toLocal)
-            {
-                string errorMessage = String.Format("The Unspecified myDateTime is regard as local by default!\nTZ: '{0}'\nmyDateTime: '{1}'\ntoLocal: '{2}'", TimeZoneInfo.Local.DisplayName, myDateTime, toLocal);
-                TestLibrary.TestFramework.LogError("011", errorMessage);
-                retVal = false;
-            }
-            else if (myDateTime == toUniversal)
-            {
-                string errorMessage = String.Format("Unexpected exception occurs!\nTZ: '{0}'\nmyDateTime: '{1}'\ntoUniversal: '{2}'", TimeZoneInfo.Local.DisplayName, myDateTime, toUniversal);
-                TestLibrary.TestFramework.LogError("012", errorMessage);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("013", "Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimemaxvalue.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimemaxvalue.cs
deleted file mode 100644
index d6a04de363..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimemaxvalue.cs
+++ /dev/null
@@ -1,73 +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.
-using System;
-
-/// <summary>
-/// MaxValue
-/// </summary>
-public class DateTimeMaxValue
-{
-    #region Private Fields
-    private const long DATETIME_MAX_VALUE_TICKS = 3155378975999999999;
-    #endregion
-
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: DateTime.MaxValue should be 23:59:59.9999999, December 31, 9999");
-
-        try
-        {
-            DateTime desiredValue = new DateTime(DATETIME_MAX_VALUE_TICKS);
-            if (!desiredValue.Equals(DateTime.MaxValue))
-            {
-                TestLibrary.TestFramework.LogError("001", "DateTime.MaxValue is not 23:59:59.9999999, December 31, 9999");
-                retVal = false;
-            } 
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeMaxValue test = new DateTimeMaxValue();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeMaxValue");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimemillisecond.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimemillisecond.cs
deleted file mode 100644
index dd54de864d..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimemillisecond.cs
+++ /dev/null
@@ -1,124 +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.
-using System;
-using System.Collections;
-using System.Threading;
-using System.Globalization;
-
-
-public class DateTimeMillisecond
-{
-    public static int Main(string[] args)
-    {
-        DateTimeMillisecond milliSecond = new DateTimeMillisecond();
-        TestLibrary.TestFramework.BeginScenario("Testing System.DateTime.Millisecond property...");
-
-        if (milliSecond.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-
-        return retVal;
-    }
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Verify DateTime.Milliscond property when DateTime instance's Millisecond is assigned...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(0978, 08, 29, 03, 00, 00,666);
-            int myMillisecond = myDateTime.Millisecond;
-
-            if (myMillisecond != 666)
-            {
-                TestLibrary.TestFramework.LogError("001", "The Millisecond is not correct!");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Verify DateTime.Millisecond property When DateTime instance is only assigned year month and day...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(1978, 08, 29);
-            int myMillisecond = myDateTime.Millisecond;
-
-            if (myMillisecond != 0)
-            {
-                TestLibrary.TestFramework.LogError("003", "The millisecond is not zero when no value is assigned at init time!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3() 
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Verify DateTime.Millisecond property When DateTime instance is only assigned year,month,day,hour,minute and second...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(1978, 08, 29, 03, 00, 00);
-            int myMillisecond = myDateTime.Millisecond;
-
-            if (myMillisecond != 0)
-            {
-                TestLibrary.TestFramework.LogError("005", "The millisecond is not zero when no value is assigned at init time!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimeminute.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimeminute.cs
deleted file mode 100644
index 78256cc5dc..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimeminute.cs
+++ /dev/null
@@ -1,95 +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.
-using System;
-using System.Collections;
-using System.Threading;
-using System.Globalization;
-
-public class DateTimeMinute
-{
-    public static int Main(string[] args)
-    {
-        DateTimeMinute minute = new DateTimeMinute();
-        TestLibrary.TestFramework.BeginScenario("Testing System.DateTime.Minute...");
-
-        if (minute.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-
-        return retVal;
-    }
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Verify DateTime.Minute property when DateTime instance's minute is assigned...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(0978, 08, 29, 03, 29, 00);
-            int minute = myDateTime.Minute;
-
-            if (minute != 29)
-            {
-                TestLibrary.TestFramework.LogError("001", "The minute is not correct!");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Verify DateTime.Minute property When DateTime instance is only assigned year month and day...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(1978, 08, 29);
-            int minute = myDateTime.Minute;
-
-            if (minute != 0)
-            {
-                TestLibrary.TestFramework.LogError("003", "The minute is not zero when no value is assigned at init time!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimeminvalue.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimeminvalue.cs
deleted file mode 100644
index ebe7f75b74..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimeminvalue.cs
+++ /dev/null
@@ -1,73 +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.
-using System;
-
-/// <summary>
-/// MinValue
-/// </summary>
-public class DateTimeMinValue
-{
-    #region Private Fields
-    private const long DATETIME_MIN_VALUE_TICKS = 0;
-    #endregion
-
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: DateTime.MinValue should be 00:00:00.0000000, January 1, 0001");
-
-        try
-        {
-            DateTime desiredValue = new DateTime(DATETIME_MIN_VALUE_TICKS);
-            if (!desiredValue.Equals(DateTime.MinValue))
-            {
-                TestLibrary.TestFramework.LogError("001", "DateTime.MinValue is not 00:00:00.0000000, January 1, 0001");
-                retVal = false;
-            } 
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeMinValue test = new DateTimeMinValue();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeMinValue");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimenow.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimenow.cs
deleted file mode 100644
index b9c9c8ceb7..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimenow.cs
+++ /dev/null
@@ -1,93 +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.
-using System;
-using System.Collections;
-using System.Threading;
-
-public class DateTimeNow
-{
-    public static int Main(string[] args)
-    {
-        DateTimeNow now = new DateTimeNow();
-        TestLibrary.TestFramework.BeginTestCase("Testing System.DateTime.Now property...");
-
-        if (now.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-
-        return retVal; 
-    }
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginTestCase("Verify DateTime.Now is local kind...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new System.Globalization.CultureInfo("");
-            DateTime myDateTime = DateTime.Now;
-            Type typeOfNow = myDateTime.GetType();
-            DateTime toLocal = myDateTime.ToLocalTime();
-
-            if (myDateTime != toLocal)
-            {
-                TestLibrary.TestFramework.LogError("001","The kind of Now property is not local!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002","Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginTestCase("Verify the type of Now property is DateTime...");
-
-        try
-        {
-            DateTime myDateTime = DateTime.Now;
-            Type typeOfNow = myDateTime.GetType();
-
-            if (typeOfNow.ToString() != "System.DateTime")
-            {
-                TestLibrary.TestFramework.LogError("003","The type of Now property is wrong!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004","Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimeparse1.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimeparse1.cs
deleted file mode 100644
index d759d4fa3e..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimeparse1.cs
+++ /dev/null
@@ -1,828 +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.
-using System;
-using System.Globalization;
-
-public class DateTimeParse1
-{
-    private CultureInfo CurrentCulture = TestLibrary.Utilities.CurrentCulture;
-    private const  int c_MIN_STRING_LEN = 1;
-    private const  int c_MAX_STRING_LEN = 2048;
-    private const  int c_NUM_LOOPS      = 100;
-    //new string[12] {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"};
-    private static string[] c_MONTHS    = CultureInfo.InvariantCulture.DateTimeFormat.AbbreviatedMonthNames;
-    //new string[12] {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
-    private static string[] c_MONTHS_SH = CultureInfo.InvariantCulture.DateTimeFormat.AbbreviatedMonthGenitiveNames;
-    //new string[7]  {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
-    private static string[] c_DAYS_SH   = CultureInfo.InvariantCulture.DateTimeFormat.AbbreviatedDayNames;
-
-    public static int Main()
-    {
-        DateTimeParse1 test = new DateTimeParse1();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeParse1");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        TestLibrary.Utilities.CurrentCulture = CultureInfo.InvariantCulture;
-
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-        retVal = PosTest5() && retVal;
-        retVal = PosTest6() && retVal;
-        retVal = PosTest7() && retVal;
-        retVal = PosTest8() && retVal;
-        retVal = PosTest9() && retVal;
-        retVal = PosTest10() && retVal;
-        retVal = PosTest11() && retVal;
-        retVal = PosTest12() && retVal;
-        retVal = PosTest13() && retVal;
-        retVal = PosTest14() && retVal;
-
-        TestLibrary.Utilities.CurrentCulture = CurrentCulture;
-
-        TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-        retVal = NegTest2() && retVal;
-        retVal = NegTest3() && retVal;
-
-        return retVal;
-    }
-
-    public bool PosTest1()
-    {
-        bool     retVal = true;
-        string   dateBefore = "";
-        DateTime dateAfter;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: DateTime.Parse(DateTime.Now)");
-
-        try
-        {
-            dateBefore = DateTime.Now.ToString();
-
-            dateAfter = DateTime.Parse( dateBefore );
-
-            if (!dateBefore.Equals(dateAfter.ToString()))
-            {
-                TestLibrary.TestFramework.LogError("001", "DateTime.Parse(" + dateBefore + ") did not equal " + dateAfter.ToString());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool     retVal = true;
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      day;    // 1 - 29
-        int      year;   // 1900 - 2000
-        int      month;  // 1 - 12
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: DateTime.Parse(M/d/yyyy (ShortDatePattern ex: 1/3/2002))");
-
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                day    = (TestLibrary.Generator.GetInt32(-55) % 28)  + 1;
-                year   = (TestLibrary.Generator.GetInt32(-55) % 100) + 1900;
-                month  = (TestLibrary.Generator.GetInt32(-55) % 12)  + 1;
-
-                dateBefore = month + "/" + day + "/" + year;
-                dateAfter  = DateTime.Parse( dateBefore );
-
-                if (month != dateAfter.Month || day != dateAfter.Day || year != dateAfter.Year)
-                {
-                    TestLibrary.TestFramework.LogError("003", "DateTime.Parse(" + dateBefore + ") did not equal " + dateAfter.ToString());
-                    retVal = false;
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("004", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool     retVal = true;
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      dayOfWeek; // 0 - 6
-        int      day;       // 1 - 28
-        int      year;      // 1900 - 2000
-        int      month;     // 0 - 11
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: DateTime.Parse(dddd, MMMM dd, yyyy (LongDatePattern ex: Thursday, January 03, 2002))");
-
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                day       = (TestLibrary.Generator.GetInt32(-55) % 27) + 1;
-                year      = (TestLibrary.Generator.GetInt32(-55) % 100) + 1900;
-                month     = (TestLibrary.Generator.GetInt32(-55) % 12);
-
-		// cheat and get day of the week
-                dateAfter = DateTime.Parse( (month+1) + "/" + day + "/" + year);
-                dayOfWeek = (int)dateAfter.DayOfWeek;
-
-                // parse the date
-                dateBefore = (DayOfWeek)dayOfWeek + ", " + c_MONTHS[month] + " " + day + ", " + year;
-                dateAfter  = DateTime.Parse( dateBefore );
-
-                if ((month+1) != dateAfter.Month || day != dateAfter.Day || year != dateAfter.Year || (DayOfWeek)dayOfWeek != dateAfter.DayOfWeek)
-                {
-                    TestLibrary.TestFramework.LogError("005", "DateTime.Parse(" + dateBefore + ") did not equal (" + dateAfter.DayOfWeek + ", " + c_MONTHS[dateAfter.Month-1] + " " + dateAfter.Day + ", " + dateAfter.Year + ")");
-                    retVal = false;
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("006", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest4()
-    {
-        bool     retVal = true;
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      dayOfWeek; // 0 - 6
-        int      day;       // 1 - 28
-        int      year;      // 1900 - 2000
-        int      month;     // 0 - 11
-        int      hour;      // 0 - 11
-        int      minute;    // 0 - 59
-        int      timeOfDay; // 0 -1
-        string[] twelveHour = new string[2] {"AM", "PM"};
-
-        TestLibrary.TestFramework.BeginScenario("PosTest4: DateTime.Parse(ex: Thursday, January 03, 2002 12:00 AM)");
-
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                day       = (TestLibrary.Generator.GetInt32(-55) % 27) + 1;
-                year      = (TestLibrary.Generator.GetInt32(-55) % 100) + 1900;
-                month     = (TestLibrary.Generator.GetInt32(-55) % 12);
-                hour      = (TestLibrary.Generator.GetInt32(-55) % 12);
-                minute    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                timeOfDay = (TestLibrary.Generator.GetInt32(-55) % 2);
-
-		// cheat and get day of the week
-                dateAfter = DateTime.Parse( (month+1) + "/" + day + "/" + year);
-                dayOfWeek = (int)dateAfter.DayOfWeek;
-
-                // parse the date
-                dateBefore = (DayOfWeek)dayOfWeek + ", " + c_MONTHS[month] + " " + day + ", " + year + " " + hour + ":" + minute + " " + twelveHour[timeOfDay];
-                dateAfter  = DateTime.Parse( dateBefore );
-
-                if ((month+1) != dateAfter.Month 
-                       || day != dateAfter.Day 
-                       || year != dateAfter.Year 
-                       || (DayOfWeek)dayOfWeek != dateAfter.DayOfWeek 
-                       || (hour + timeOfDay*12) != dateAfter.Hour
-                       || minute != dateAfter.Minute)
-                {
-                    TestLibrary.TestFramework.LogError("007", "DateTime.Parse(" + dateBefore + ") did not equal (" + dateAfter.DayOfWeek + ", " + c_MONTHS[dateAfter.Month-1] + " " + dateAfter.Day + ", " + dateAfter.Year + " " + dateAfter.Hour + ":" + dateAfter.Minute + ")");
-                    retVal = false;
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("008", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("008", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest5()
-    {
-        bool     retVal = true;
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      dayOfWeek; // 0 - 6
-        int      day;       // 1 - 28
-        int      year;      // 1900 - 2000
-        int      month;     // 0 - 11
-        int      hour;      // 0 - 11
-        int      minute;    // 0 - 59
-        int      second;    // 0 - 59
-        int      timeOfDay; // 0 -1
-        string[] twelveHour = new string[2] {"AM", "PM"};
-
-        TestLibrary.TestFramework.BeginScenario("PosTest5: DateTime.Parse(dddd, MMMM dd, yyyy h:mm:ss tt (FullDateTimePattern ex: Thursday, January 03, 2002 12:00:00 AM))");
-
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                day       = (TestLibrary.Generator.GetInt32(-55) % 27) + 1;
-                year      = (TestLibrary.Generator.GetInt32(-55) % 100) + 1900;
-                month     = (TestLibrary.Generator.GetInt32(-55) % 12);
-                hour      = (TestLibrary.Generator.GetInt32(-55) % 12);
-                minute    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                second    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                timeOfDay = (TestLibrary.Generator.GetInt32(-55) % 2);
-
-		// cheat and get day of the week
-                dateAfter = DateTime.Parse( (month+1) + "/" + day + "/" + year);
-                dayOfWeek = (int)dateAfter.DayOfWeek;
-
-                // parse the date
-                dateBefore = (DayOfWeek)dayOfWeek + ", " + c_MONTHS[month] + " " + day + ", " + year + " " + hour + ":" + minute + ":" + second + " " + twelveHour[timeOfDay];
-                dateAfter  = DateTime.Parse( dateBefore );
-
-                if ((month+1) != dateAfter.Month 
-                       || day != dateAfter.Day 
-                       || year != dateAfter.Year 
-                       || (DayOfWeek)dayOfWeek != dateAfter.DayOfWeek 
-                       || (hour + timeOfDay*12) != dateAfter.Hour
-                       || minute != dateAfter.Minute
-                       || second != dateAfter.Second)
-                {
-                    TestLibrary.TestFramework.LogError("009", "DateTime.Parse(" + dateBefore + ") did not equal (" + dateAfter.DayOfWeek + ", " + c_MONTHS[dateAfter.Month-1] + " " + dateAfter.Day + ", " + dateAfter.Year + " " + dateAfter.Hour + ":" + dateAfter.Minute + ":" + dateAfter.Second + ")");
-                    retVal = false;
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("010", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("010", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest6()
-    {
-        bool     retVal = true;
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      day;       // 1 - 28
-        int      month;     // 1 - 12
-        int      year;      // 1900 - 2000
-        int      hour;      // 0 - 11
-        int      minute;    // 0 - 59
-        int      timeOfDay; // 0 -1
-        string[] twelveHour = new string[2] {"AM", "PM"};
-
-        TestLibrary.TestFramework.BeginScenario("PosTest6: DateTime.Parse(ex: 1/3/2002 12:00 AM)");
-
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                day       = (TestLibrary.Generator.GetInt32(-55) % 27) + 1;
-                year      = (TestLibrary.Generator.GetInt32(-55) % 100) + 1900;
-                month     = (TestLibrary.Generator.GetInt32(-55) % 12) + 1;
-                hour      = (TestLibrary.Generator.GetInt32(-55) % 12);
-                minute    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                timeOfDay = (TestLibrary.Generator.GetInt32(-55) % 2);
-
-                // parse the date
-                dateBefore = month + "/" + day + "/" + year + " " + hour + ":" + minute + " " + twelveHour[timeOfDay];
-                dateAfter  = DateTime.Parse( dateBefore );
-
-                if (month != dateAfter.Month 
-                       || day != dateAfter.Day 
-                       || year != dateAfter.Year 
-                       || (hour + timeOfDay*12) != dateAfter.Hour
-                       || minute != dateAfter.Minute)
-                {
-                    TestLibrary.TestFramework.LogError("011", "DateTime.Parse(" + dateBefore + ") did not equal (" + dateAfter.Month + "/" + dateAfter.Day + "/" + dateAfter.Year + " " + dateAfter.Hour + ":" + dateAfter.Minute + ")");
-                    retVal = false;
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("012", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("012", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest7()
-    {
-        bool     retVal = true;
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      day;       // 1 - 28
-        int      month;     // 1 - 12
-        int      year;      // 1900 - 2000
-        int      hour;      // 0 - 11
-        int      minute;    // 0 - 59
-        int      second;    // 0 - 59
-        int      timeOfDay; // 0 -1
-        string[] twelveHour = new string[2] {"AM", "PM"};
-
-        TestLibrary.TestFramework.BeginScenario("PosTest7: DateTime.Parse(ex: 1/3/2002 12:00:00 AM)");
-
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                day       = (TestLibrary.Generator.GetInt32(-55) % 27) + 1;
-                year      = (TestLibrary.Generator.GetInt32(-55) % 100) + 1900;
-                month     = (TestLibrary.Generator.GetInt32(-55) % 12) + 1;
-                hour      = (TestLibrary.Generator.GetInt32(-55) % 12);
-                minute    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                second    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                timeOfDay = (TestLibrary.Generator.GetInt32(-55) % 2);
-
-                // parse the date
-                dateBefore = month + "/" + day + "/" + year + " " + hour + ":" + minute + ":" + second + " " + twelveHour[timeOfDay];
-                dateAfter  = DateTime.Parse( dateBefore );
-
-                if (month != dateAfter.Month 
-                       || day != dateAfter.Day 
-                       || year != dateAfter.Year 
-                       || (hour + timeOfDay*12) != dateAfter.Hour
-                       || minute != dateAfter.Minute
-                       || second != dateAfter.Second)
-                {
-                    TestLibrary.TestFramework.LogError("013", "DateTime.Parse(" + dateBefore + ") did not equal (" + dateAfter.Month + "/" + dateAfter.Day + "/" + dateAfter.Year + " " + dateAfter.Hour + ":" + dateAfter.Minute + ":" + dateAfter.Second + ")");
-                    retVal = false;
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("014", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("014", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest8()
-    {
-        bool     retVal = true;
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      day;       // 1 - 28
-        int      month;     // 0 - 11
-
-        TestLibrary.TestFramework.BeginScenario("PosTest8: DateTime.Parse(MMMM dd (MonthDayPattern ex: January 03))");
-
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                day       = (TestLibrary.Generator.GetInt32(-55) % 27) + 1;
-                month     = (TestLibrary.Generator.GetInt32(-55) % 12);
-
-                // parse the date
-                dateBefore = c_MONTHS[month] + " " + day;
-                dateAfter  = DateTime.Parse( dateBefore );
-
-                if ((month+1) != dateAfter.Month 
-                       || day != dateAfter.Day)
-                {
-                    TestLibrary.TestFramework.LogError("015", "DateTime.Parse(" + dateBefore + ") did not equal (" + c_MONTHS[dateAfter.Month-1] + " " + dateAfter.Day + ")");
-                    retVal = false;
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("016", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("016", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest9()
-    {
-        bool     retVal = true;
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      dayOfWeek; // 0 - 6
-        int      day;       // 1 - 28
-        int      year;      // 1900 - 2000
-        int      month;     // 0 - 11
-        int      hour;      // 12 - 23
-        int      minute;    // 0 - 59
-        int      second;    // 0 - 59
-
-        TestLibrary.TestFramework.BeginScenario("PosTest9: DateTime.Parse(ddd, dd MMM yyyy HH':'mm':'ss 'GMT' (RFC1123Pattern ex: Thu, 03 Jan 2002 00:00:00 GMT))");
-
-        DateTime now = DateTime.Now;
-        int hourshift;
-        if (now - now.ToUniversalTime() < TimeSpan.Zero) // western hemisphere
-            hourshift = +12;
-        else
-            hourshift = 0;
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                day       = (TestLibrary.Generator.GetInt32(-55) % 27) + 1;
-                year      = (TestLibrary.Generator.GetInt32(-55) % 100) + 1900;
-                month     = (TestLibrary.Generator.GetInt32(-55) % 12);
-                hour      = (TestLibrary.Generator.GetInt32(-55) % 12) + hourshift;	// Parse will convert perform GMT -> Local conversion
-                minute    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                second    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                dayOfWeek = (TestLibrary.Generator.GetInt32(-55) % 7);
-
-		// cheat and get day of the week
-                dateAfter = DateTime.Parse( (month+1) + "/" + day + "/" + year);
-                dayOfWeek = (int)dateAfter.DayOfWeek;
-
-                // parse the date
-                dateBefore = c_DAYS_SH[dayOfWeek] + ", " + day + " " + c_MONTHS_SH[month] + " " + year + " " + hour + ":" + minute + ":" + second + " GMT";
-                dateAfter  = DateTime.Parse( dateBefore );
-
-                if ((month+1) != dateAfter.Month
-                       || day != dateAfter.Day
-                       || year != dateAfter.Year 
-                       || (DayOfWeek)dayOfWeek != dateAfter.DayOfWeek 
-                       || second != dateAfter.Second)
-                {
-                    TestLibrary.TestFramework.LogError("017", "DateTime.Parse(" + dateBefore + ") did not equal (" + c_DAYS_SH[(int)dateAfter.DayOfWeek] + ", " + dateAfter.Day + " " + c_MONTHS_SH[dateAfter.Month-1] + " " + dateAfter.Year + " " + dateAfter.Hour + ":" + dateAfter.Minute + ":" + dateAfter.Second + " " + dateAfter.Kind + ")");
-                    retVal = false;
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("018", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("018", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest10()
-    {
-        bool     retVal = true;
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      day;       // 1 - 28
-        int      month;     // 1 - 12
-        int      year;      // 1900 - 2000
-        int      hour;      // 0 - 23
-        int      minute;    // 0 - 59
-        int      second;    // 0 - 59
-
-        TestLibrary.TestFramework.BeginScenario("PosTest10: DateTime.Parse(yyyy'-'MM'-'dd'T'HH':'mm':'ss (SortableDateTimePattern ex: 2002-01-03T00:00:00))");
-
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                day       = (TestLibrary.Generator.GetInt32(-55) % 27) + 1;
-                year      = (TestLibrary.Generator.GetInt32(-55) % 100) + 1900;
-                month     = (TestLibrary.Generator.GetInt32(-55) % 12) + 1;
-                hour      = (TestLibrary.Generator.GetInt32(-55) % 24);
-                minute    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                second    = (TestLibrary.Generator.GetInt32(-55) % 60);
-
-                // parse the date
-                dateBefore = year + "-" + month + "-" + day + "T" + ((10 > hour) ? "0" : "") + hour + ":" + ((10 > minute) ? "0" : "") + minute + ":" + ((10 > second) ? "0" : "") + second;
-                dateAfter  = DateTime.Parse( dateBefore );
-
-                if (month != dateAfter.Month 
-                       || day != dateAfter.Day 
-                       || year != dateAfter.Year 
-                       || hour != dateAfter.Hour
-                       || minute != dateAfter.Minute
-                       || second != dateAfter.Second)
-                {
-                    TestLibrary.TestFramework.LogError("019", "DateTime.Parse(" + dateBefore + ") did not equal (" + dateAfter.Year + "-" + dateAfter.Month + "-" + dateAfter.Day + "T" + dateAfter.Hour + ":" + dateAfter.Minute + ":" + dateAfter.Second + ")");
-                    retVal = false;
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("020", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("020", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest11()
-    {
-        bool     retVal = true;
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      hour;      // 0 - 11
-        int      minute;    // 0 - 59
-        int      timeOfDay; // 0 -1
-        string[] twelveHour = new string[2] {"AM", "PM"};
-
-        TestLibrary.TestFramework.BeginScenario("PosTest11: DateTime.Parse(h:mm tt (ShortTimePattern ex: 12:00 AM))");
-
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                hour      = (TestLibrary.Generator.GetInt32(-55) % 12);
-                minute    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                timeOfDay = (TestLibrary.Generator.GetInt32(-55) % 2);
-
-                // parse the date
-                dateBefore = hour + ":" + minute + " " + twelveHour[timeOfDay];
-                dateAfter  = DateTime.Parse( dateBefore );
-
-                if ((hour + timeOfDay*12) != dateAfter.Hour
-                       || minute != dateAfter.Minute)
-                {
-                    TestLibrary.TestFramework.LogError("021", "DateTime.Parse(" + dateBefore + ") did not equal (" + dateAfter.Hour + ":" + dateAfter.Minute + ")");
-                    retVal = false;
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("022", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("022", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest12()
-    {
-        bool     retVal = true;
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      hour;      // 0 - 11
-        int      minute;    // 0 - 59
-        int      second;    // 0 - 59
-        int      timeOfDay; // 0 -1
-        string[] twelveHour = new string[2] {"AM", "PM"};
-
-        TestLibrary.TestFramework.BeginScenario("PosTest12: DateTime.Parse(h:mm:ss tt (LongTimePattern ex: 12:00:00 AM))");
-
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                hour      = (TestLibrary.Generator.GetInt32(-55) % 12);
-                minute    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                second    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                timeOfDay = (TestLibrary.Generator.GetInt32(-55) % 2);
-
-                // parse the date
-                dateBefore = hour + ":" + minute + ":" + second + " " + twelveHour[timeOfDay];
-                dateAfter  = DateTime.Parse( dateBefore );
-
-                if ((hour + timeOfDay*12) != dateAfter.Hour
-                       || minute != dateAfter.Minute
-                       || second != dateAfter.Second)
-                {
-                    TestLibrary.TestFramework.LogError("023", "DateTime.Parse(" + dateBefore + ") did not equal (" + dateAfter.Hour + ":" + dateAfter.Minute + ":" + dateAfter.Second + ")");
-                    retVal = false;
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("024", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("024", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest13()
-    {
-        bool     retVal = true;
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      day;       // 1 - 28
-        int      month;     // 1 - 12
-        int      year;      // 1900 - 2000
-        int      hour;      // 12 - 23
-        int      minute;    // 0 - 59
-        int      second;    // 0 - 59
-
-        TestLibrary.TestFramework.BeginScenario("PosTest13: DateTime.Parse(yyyy'-'MM'-'dd HH':'mm':'ss'Z' (UniversalSortableDateTimePattern ex: 2002-01-03 00:00:00Z))");
-
-        DateTime now = DateTime.Now;
-        int hourshift;
-        if (now - now.ToUniversalTime() < TimeSpan.Zero) // western hemisphere
-            hourshift = +12;
-        else
-            hourshift = 0;
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                day       = (TestLibrary.Generator.GetInt32(-55) % 27) + 1;
-                year      = (TestLibrary.Generator.GetInt32(-55) % 100) + 1900;
-                month     = (TestLibrary.Generator.GetInt32(-55) % 12) + 1;
-                hour      = (TestLibrary.Generator.GetInt32(-55) % 12) + hourshift;	// conversion
-                minute    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                second    = (TestLibrary.Generator.GetInt32(-55) % 60);
-
-                // parse the date
-                dateBefore = year + "-" + month + "-" + day + " " + ((10 > hour) ? "0" : "") + hour + ":" + ((10 > minute) ? "0" : "") + minute + ":" + ((10 > second) ? "0" : "") + second +"Z";
-                dateAfter  = DateTime.Parse( dateBefore );
-
-                if (month != dateAfter.Month 
-                       || day != dateAfter.Day 
-                       || year != dateAfter.Year 
-                       || second != dateAfter.Second)
-                {
-                    TestLibrary.TestFramework.LogError("025", "DateTime.Parse(" + dateBefore + ") did not equal (" + dateAfter.Year + "-" + dateAfter.Month + "-" + dateAfter.Day + " " + dateAfter.Hour + ":" + dateAfter.Minute + ":" + dateAfter.Second + " " + dateAfter.Kind + ")");
-                    retVal = false;
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("026", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("026", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest14()
-    {
-        bool     retVal = true;
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      year;      // 1900 - 2000
-        int      month;     // 0 - 11
-
-        TestLibrary.TestFramework.BeginScenario("PosTest14: DateTime.Parse(MMMM, yyyy (YearMonthPattern ex: January, 2002))");
-
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                year      = (TestLibrary.Generator.GetInt32(-55) % 100) + 1900;
-                month     = (TestLibrary.Generator.GetInt32(-55) % 12);
-
-                // parse the date
-                dateBefore = c_MONTHS[month] + ", " + year;
-                dateAfter  = DateTime.Parse( dateBefore );
-
-                if ((month+1) != dateAfter.Month
-                        || year != dateAfter.Year)
-                {
-                    TestLibrary.TestFramework.LogError("027", "DateTime.Parse(" + dateBefore + ") did not equal (" + c_MONTHS[dateAfter.Month-1] + ", " + dateAfter.Year + ")");
-                    retVal = false;
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("028", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("028", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest1()
-    {
-        bool      retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: DateTime.Parse(null)");
-
-        try
-        {
-            DateTime.Parse(null);
-
-            TestLibrary.TestFramework.LogError("029", "DateTime.Parse(null) should have thrown");
-            retVal = false;
-        }
-        catch (ArgumentNullException)
-        {
-            // expected
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("030", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest2()
-    {
-        bool      retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest2: DateTime.Parse(String.Empty)");
-
-        try
-        {
-            DateTime.Parse(String.Empty);
-
-            TestLibrary.TestFramework.LogError("031", "DateTime.Parse(String.Empty) should have thrown");
-            retVal = false;
-        }
-        catch (FormatException)
-        {
-            // expected
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("032", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest3()
-    {
-        bool     retVal = true;
-        string   strDateTime = "";
-        DateTime dateAfter;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest3: DateTime.Parse(<garbage>)");
-
-        try
-        {
-            for (int i=0; i<c_NUM_LOOPS; i++)
-            {
-                try
-                {
-                    strDateTime = TestLibrary.Generator.GetString(-55, false, c_MIN_STRING_LEN, c_MAX_STRING_LEN);
-                    dateAfter = DateTime.Parse(strDateTime);
-
-                    TestLibrary.TestFramework.LogError("033", "DateTime.Parse(" + strDateTime + ") should have thrown (" + dateAfter + ")");
-                    retVal = false;
-                }
-                catch (FormatException)
-                {
-                    // expected
-                }
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("034", "Failing date: " + strDateTime);
-            TestLibrary.TestFramework.LogError("034", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimeparse2.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimeparse2.cs
deleted file mode 100644
index f5b8bb5aea..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimeparse2.cs
+++ /dev/null
@@ -1,216 +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.
-using System;
-
-public class DateTimeParse2
-{
-    private const  int c_MIN_STRING_LEN = 1;
-    private const  int c_MAX_STRING_LEN = 2048;
-    private const  int c_NUM_LOOPS      = 100;
-
-    public static int Main()
-    {
-        DateTimeParse2 test = new DateTimeParse2();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeParse2");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-
-        TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-        retVal = NegTest2() && retVal;
-        retVal = NegTest3() && retVal;
-
-        return retVal;
-    }
-
-    public bool PosTest1()
-    {
-        bool     retVal = true;
-        string   dateBefore = "";
-        DateTime dateAfter;
-        MyFormater formater = new MyFormater();
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: DateTime.Parse(DateTime.Now, formater)");
-
-        try
-        {
-            dateBefore = DateTime.Now.ToString();
-
-            dateAfter = DateTime.Parse( dateBefore, formater);
-
-            if (!dateBefore.Equals(dateAfter.ToString()))
-            {
-                TestLibrary.TestFramework.LogError("001", "DateTime.Parse(" + dateBefore + ") did not equal " + dateAfter.ToString());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool     retVal = true;
-        string   dateBefore = "";
-        DateTime dateAfter;
-        MyFormater formater = new MyFormater();
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: DateTime.Parse(DateTime.Now, null)");
-
-        try
-        {
-            dateBefore = DateTime.Now.ToString();
-
-            dateAfter = DateTime.Parse( dateBefore, null);
-
-            if (!dateBefore.Equals(dateAfter.ToString()))
-            {
-                TestLibrary.TestFramework.LogError("009", "DateTime.Parse(" + dateBefore + ") did not equal " + dateAfter.ToString());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("010", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("010", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest1()
-    {
-        bool      retVal = true;
-        MyFormater formater = new MyFormater();
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: DateTime.Parse(null, formater)");
-
-        try
-        {
-            DateTime.Parse(null, formater);
-
-            TestLibrary.TestFramework.LogError("003", "DateTime.Parse(null) should have thrown");
-            retVal = false;
-        }
-        catch (ArgumentNullException)
-        {
-            // expected
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest2()
-    {
-        bool      retVal = true;
-        MyFormater formater = new MyFormater();
-
-        TestLibrary.TestFramework.BeginScenario("NegTest2: DateTime.Parse(String.Empty, formater)");
-
-        try
-        {
-            DateTime.Parse(String.Empty, formater);
-
-            TestLibrary.TestFramework.LogError("005", "DateTime.Parse(String.Empty) should have thrown");
-            retVal = false;
-        }
-        catch (FormatException)
-        {
-            // expected
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest3()
-    {
-        bool     retVal = true;
-        MyFormater formater = new MyFormater();
-        string   strDateTime = "";
-        DateTime dateAfter;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest3: DateTime.Parse(<garbage>, formater)");
-
-        try
-        {
-            for (int i=0; i<c_NUM_LOOPS; i++)
-            {
-                try
-                {
-                    strDateTime = TestLibrary.Generator.GetString(-55, false, c_MIN_STRING_LEN, c_MAX_STRING_LEN);
-                    dateAfter = DateTime.Parse(strDateTime, formater);
-
-                    TestLibrary.TestFramework.LogError("007", "DateTime.Parse(" + strDateTime + ") should have thrown (" + dateAfter + ")");
-                    retVal = false;
-                }
-                catch (FormatException)
-                {
-                    // expected
-                }
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("008", "Failing date: " + strDateTime);
-            TestLibrary.TestFramework.LogError("008", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-}
-
-public class MyFormater : IFormatProvider
-{
-    public object GetFormat(Type formatType)
-    {
-        if (typeof(IFormatProvider) == formatType)
-        {
-            return this;
-        }
-        else
-        {
-            return null;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimeparse3.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimeparse3.cs
deleted file mode 100644
index 135fb8f167..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimeparse3.cs
+++ /dev/null
@@ -1,274 +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.
-using System;
-using System.Globalization ;
-
-public class DateTimeParse3
-{
-    private const  int c_MIN_STRING_LEN = 1;
-    private const  int c_MAX_STRING_LEN = 2048;
-    private const  int c_NUM_LOOPS      = 100;
-
-    public static int Main()
-    {
-        DateTimeParse3 test = new DateTimeParse3();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeParse3");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        // The NoCurrentDateDefault value is the only value that is useful with 
-        //   the DateTime.Parse method, because DateTime.Parse always ignores leading, 
-        //   trailing, and inner white-space characters.
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-
-        TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-        retVal = NegTest2() && retVal;
-        retVal = NegTest3() && retVal;
-
-        return retVal;
-    }
-
-    public bool PosTest1()
-    {
-        bool     retVal = true;
-        string   dateBefore = "";
-        DateTime dateAfter;
-        MyFormater formater = new MyFormater();
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: DateTime.Parse(DateTime.Now, formater, DateTimeStyles.NoCurrentDateDefault)");
-
-        try
-        {
-            dateBefore = DateTime.Now.ToString();
-
-            dateAfter = DateTime.Parse( dateBefore, formater, DateTimeStyles.NoCurrentDateDefault);
-
-            if (!dateBefore.Equals(dateAfter.ToString()))
-            {
-                TestLibrary.TestFramework.LogError("001", "DateTime.Parse(" + dateBefore + ") did not equal " + dateAfter.ToString());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool     retVal = true;
-        string   dateBefore = "";
-        DateTime dateAfter;
-        MyFormater formater = new MyFormater();
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: DateTime.Parse(DateTime.Now, null, DateTimeStyles.NoCurrentDateDefault)");
-
-        try
-        {
-            dateBefore = DateTime.Now.ToString();
-
-            dateAfter = DateTime.Parse( dateBefore, null, DateTimeStyles.NoCurrentDateDefault);
-
-            if (!dateBefore.Equals(dateAfter.ToString()))
-            {
-                TestLibrary.TestFramework.LogError("009", "DateTime.Parse(" + dateBefore + ") did not equal " + dateAfter.ToString());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("010", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("010", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool     retVal = true;
-        string   dateBefore = "";
-        DateTime dateAfter;
-        MyFormater formater = new MyFormater();
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: DateTime.Parse(DateTime.Now, null, <invalid DateTimeStyles>)");
-
-        try
-        {
-            for(int i=-1024; i<1024; i++)
-            {
-                try
-                {
-                    // skip the valid values
-                    if (0 == (i & (int)DateTimeStyles.AdjustToUniversal)
-                        && 0 == (i & (int)DateTimeStyles.AssumeUniversal)
-                        && 0 == (i & (int)DateTimeStyles.AllowInnerWhite)
-                        && 0 == (i & (int)DateTimeStyles.AllowLeadingWhite)
-                        && 0 == (i & (int)DateTimeStyles.AllowTrailingWhite)
-                        && 0 == (i & (int)DateTimeStyles.AllowWhiteSpaces)
-                        && 0 == (i & (int)DateTimeStyles.NoCurrentDateDefault)
-                        && i != (int)DateTimeStyles.None
-                       )
-                    {
-                        dateBefore = DateTime.Now.ToString();
-
-                        dateAfter = DateTime.Parse( dateBefore, null, (DateTimeStyles)i);
-
-                        if (!dateBefore.Equals(dateAfter.ToString()))
-                        {
-                           TestLibrary.TestFramework.LogError("011", "DateTime.Parse(" + dateBefore + ", " + (DateTimeStyles)i + ") did not equal " + dateAfter.ToString());
-                            retVal = false;
-                        }
-                    }
-                }
-                catch (System.ArgumentException)
-                {
-                    //
-                }
-           }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("012", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("012", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest1()
-    {
-        bool      retVal = true;
-        MyFormater formater = new MyFormater();
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: DateTime.Parse(null, formater, DateTimeStyles.NoCurrentDateDefault)");
-
-        try
-        {
-            DateTime.Parse(null, formater, DateTimeStyles.NoCurrentDateDefault);
-
-            TestLibrary.TestFramework.LogError("003", "DateTime.Parse(null) should have thrown");
-            retVal = false;
-        }
-        catch (ArgumentNullException)
-        {
-            // expected
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest2()
-    {
-        bool      retVal = true;
-        MyFormater formater = new MyFormater();
-
-        TestLibrary.TestFramework.BeginScenario("NegTest2: DateTime.Parse(String.Empty, formater, DateTimeStyles.NoCurrentDateDefault)");
-
-        try
-        {
-            DateTime.Parse(String.Empty, formater, DateTimeStyles.NoCurrentDateDefault);
-
-            TestLibrary.TestFramework.LogError("005", "DateTime.Parse(String.Empty) should have thrown");
-            retVal = false;
-        }
-        catch (FormatException)
-        {
-            // expected
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest3()
-    {
-        bool   retVal = true;
-        MyFormater formater = new MyFormater();
-        string strDateTime = "";
-        DateTime dateAfter;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest3: DateTime.Parse(<garbage>, formater, DateTimeStyles.NoCurrentDateDefault)");
-
-        try
-        {
-            for (int i=0; i<c_NUM_LOOPS; i++)
-            {
-                try
-                {
-                    strDateTime = TestLibrary.Generator.GetString(-55, false, c_MIN_STRING_LEN, c_MAX_STRING_LEN);
-                    dateAfter = DateTime.Parse(strDateTime, formater, DateTimeStyles.NoCurrentDateDefault);
-
-                    TestLibrary.TestFramework.LogError("007", "DateTime.Parse(" + strDateTime + ") should have thrown (" + dateAfter + ")");
-                    retVal = false;
-                }
-                catch (FormatException)
-                {
-                    // expected
-                }
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("008", "Failing date: " + strDateTime);
-            TestLibrary.TestFramework.LogError("008", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-}
-
-public class MyFormater : IFormatProvider
-{
-    public object GetFormat(Type formatType)
-    {
-        if (typeof(IFormatProvider) == formatType)
-        {
-            return this;
-        }
-        else
-        {
-            return null;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimeparseexact1.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimeparseexact1.cs
deleted file mode 100644
index b249da69a6..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimeparseexact1.cs
+++ /dev/null
@@ -1,964 +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.
-using System;
-using System.Globalization;
-
-public class DateTimeParseExact1
-{
-    private const  int c_MIN_STRING_LEN = 1;
-    private const  int c_MAX_STRING_LEN = 2048;
-    private const  int c_NUM_LOOPS      = 100;
-    private static CultureInfo CurrentCulture = TestLibrary.Utilities.CurrentCulture;
-    private static CultureInfo EnglishCulture = new CultureInfo("en-US");
-    private static string[] c_MONTHS = EnglishCulture.DateTimeFormat.MonthGenitiveNames;
-    private static string[] c_MONTHS_SH = EnglishCulture.DateTimeFormat.AbbreviatedMonthGenitiveNames;
-    private static string[] c_DAYS_SH = EnglishCulture.DateTimeFormat.AbbreviatedDayNames;
-
-    public static int Main()
-    {
-        DateTimeParseExact1 test = new DateTimeParseExact1();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeParseExact1");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest15() && retVal;
-
-        TestLibrary.Utilities.CurrentCulture = EnglishCulture;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest5() && retVal;
-        retVal = PosTest7() && retVal;
-        retVal = PosTest8() && retVal;
-        retVal = PosTest9() && retVal;
-        retVal = PosTest10() && retVal;
-        retVal = PosTest12() && retVal;
-        retVal = PosTest13() && retVal;
-        retVal = PosTest14() && retVal;
-        TestLibrary.Utilities.CurrentCulture = CurrentCulture;
-
-        TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-        retVal = NegTest2() && retVal;
-        retVal = NegTest3() && retVal;
-        retVal = NegTest4() && retVal;
-        retVal = NegTest5() && retVal;
-
-        return retVal;
-    }
-
-    public bool PosTest1()
-    {
-        bool     retVal = true;
-        MyFormater formater = new MyFormater();
-        string   dateBefore = "";
-        DateTime dateAfter;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: DateTime.ParseExact(G, DateTime.Now)");
-
-        try
-        {
-            dateBefore = DateTime.Now.ToString();
-
-            dateAfter = DateTime.ParseExact( dateBefore, "G", formater );
-
-            if (!dateBefore.Equals(dateAfter.ToString()))
-            {
-                TestLibrary.TestFramework.LogError("001", "DateTime.ParseExact(" + dateBefore + ") did not equal " + dateAfter.ToString());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool     retVal = true;
-        MyFormater formater = new MyFormater();
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      day;    // 1 - 29
-        int      year;   // 1900 - 2000
-        int      month;  // 1 - 12
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: DateTime.ParseExact(d, M/d/yyyy (ShortDatePattern ex: 1/3/2002))");
-
-        // Skipping test because format 'd' on some platforms represents the year using two digits, 
-        // this cause extrange results. Some dates are shifted 1 hour backward. See DDB 173277 - MAC bug
-        // Culture could be customized and dateseparator may be different than / or MM is used in the format
-        if (String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.ShortDatePattern, "M/d/yyyy", StringComparison.Ordinal) != 0)
-        {
-            TestLibrary.TestFramework.LogInformation("Skipping test case, ShortDatePattern: " + TestLibrary.Utilities.CurrentCulture.DateTimeFormat.ShortDatePattern);
-            return retVal;
-        }
-
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                day    = (TestLibrary.Generator.GetInt32(-55) % 28)  + 1;
-                year   = (TestLibrary.Generator.GetInt32(-55) % 100) + 1900;
-                month  = (TestLibrary.Generator.GetInt32(-55) % 12)  + 1;
-
-                dateBefore = month + "/" + day + "/" + year;
-                dateAfter  = DateTime.ParseExact( dateBefore, "d", formater);
-
-                if (month != dateAfter.Month || day != dateAfter.Day || year != dateAfter.Year)
-                {
-                    TestLibrary.TestFramework.LogError("003", "DateTime.ParseExact(" + dateBefore + ") did not equal " + dateAfter.ToString() + ".  Got M="+dateAfter.Month+", d="+dateAfter.Day+", y="+dateAfter.Year);
-                    retVal = false;
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("004", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool     retVal = true;
-        MyFormater formater = new MyFormater();
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      dayOfWeek; // 0 - 6
-        int      day;       // 1 - 28
-        int      year;      // 1900 - 2000
-        int      month;     // 0 - 11
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: DateTime.ParseExact(D, dddd, MMMM dd, yyyy (LongDatePattern ex: Thursday, January 03, 2002))");
-        // Culture could be customized
-        if (String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.LongDatePattern, "dddd, MMMM dd, yyyy", StringComparison.Ordinal) != 0 &&
-            String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.LongDatePattern, "dddd, MMMM d, yyyy", StringComparison.Ordinal) != 0)
-        {
-            TestLibrary.TestFramework.LogInformation("Skipping test case, LongDatePattern: " + TestLibrary.Utilities.CurrentCulture.DateTimeFormat.LongDatePattern);
-            return retVal;
-        }
-
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                day       = (TestLibrary.Generator.GetInt32(-55) % 27) + 1;
-                year      = (TestLibrary.Generator.GetInt32(-55) % 100) + 1900;
-                month     = (TestLibrary.Generator.GetInt32(-55) % 12);
-
-		        // cheat and get day of the week
-                dateAfter = DateTime.Parse( (month+1) + "/" + day + "/" + year);
-                dayOfWeek = (int)dateAfter.DayOfWeek;
-
-                // parse the date
-                dateBefore = (DayOfWeek)dayOfWeek + ", " + c_MONTHS[month] + " " +
-                            (String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.LongDatePattern, "dddd, MMMM dd, yyyy", StringComparison.Ordinal) == 0 && 10 > day ? "0" : "") + day + ", " + year;
-                dateAfter  = DateTime.ParseExact( dateBefore, "D", formater );
-
-                if ((month+1) != dateAfter.Month || day != dateAfter.Day || year != dateAfter.Year || (DayOfWeek)dayOfWeek != dateAfter.DayOfWeek)
-                {
-                    TestLibrary.TestFramework.LogError("005", "DateTime.ParseExact(" + dateBefore + ") did not equal (" + dateAfter.DayOfWeek + ", " + c_MONTHS[dateAfter.Month-1] + " " + dateAfter.Day + ", " + dateAfter.Year + ")");
-                    retVal = false;
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("006", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest5()
-    {
-        bool     retVal = true;
-        MyFormater formater = new MyFormater();
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      dayOfWeek; // 0 - 6
-        int      day;       // 1 - 28
-        int      year;      // 1900 - 2000
-        int      month;     // 0 - 11
-        int      hour;      // 0 - 11
-        int      minute;    // 0 - 59
-        int      second;    // 0 - 59
-        int      timeOfDay; // 0 -1
-        string[] twelveHour = new string[2] {"AM", "PM"};
-        DateTime dateBeforeForValidity;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest5: DateTime.ParseExact(F, dddd, MMMM dd, yyyy h:mm:ss tt (FullDateTimePattern ex: Thursday, January 03, 2002 12:00:00 AM))");
-
-        // Culture could be customized
-        if (!((String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.LongDatePattern, "dddd, MMMM dd, yyyy", StringComparison.Ordinal) == 0 ||
-               String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.LongDatePattern, "dddd, MMMM d, yyyy", StringComparison.Ordinal) == 0) && 
-              (String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.LongTimePattern, "hh:mm:ss tt", StringComparison.Ordinal) == 0 ||
-               String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.LongTimePattern, "h:mm:ss tt", StringComparison.Ordinal) == 0)))
-
-        {
-            TestLibrary.TestFramework.LogInformation("Skipping test case, " +
-                                                     " LongDatePattern: " + TestLibrary.Utilities.CurrentCulture.DateTimeFormat.LongDatePattern +
-                                                     " LongTimePattern: " + TestLibrary.Utilities.CurrentCulture.DateTimeFormat.LongTimePattern);
-            return retVal;
-        }
-
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                day       = (TestLibrary.Generator.GetInt32(-55) % 27) + 1;
-                year      = (TestLibrary.Generator.GetInt32(-55) % 100) + 1900;
-                month     = (TestLibrary.Generator.GetInt32(-55) % 12);
-                hour      = (TestLibrary.Generator.GetInt32(-55) % 12);
-                minute    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                second    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                timeOfDay = (TestLibrary.Generator.GetInt32(-55) % 2);
-
-                dateBeforeForValidity = new DateTime(year, month + 1, day, hour, minute, second);
-
-        		// cheat and get day of the week
-                dateAfter = DateTime.Parse( (month+1) + "/" + day + "/" + year);
-                dayOfWeek = (int)dateAfter.DayOfWeek;
-
-                // parse the date
-                dateBefore = (DayOfWeek)dayOfWeek + ", " + 
-                             c_MONTHS[month] + " " +
-                             (String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.LongDatePattern, "dddd, MMMM dd, yyyy", StringComparison.Ordinal) == 0 && 10 > day ? "0" : "") + day + ", " + 
-                             year + " " +
-                             (String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.LongTimePattern, "hh:mm:ss tt", StringComparison.Ordinal) == 0 && 10 > hour ? "0" : "") + hour + ":" + 
-                             (10 > minute ? "0" : "") + minute + ":" + 
-                             (10 > second ? "0" : "") + second + " " + twelveHour[timeOfDay];
-
-                if (!TestLibrary.Utilities.IsWindows)
-                {
-                    dateAfter = DateTime.Parse(dateBefore);
-                    TimeSpan span = dateAfter - dateAfter.ToUniversalTime();
-                    String strSpan = (span.Duration()==span ? "+" : "-") + 
-                        (10 > span.Duration().Hours ? "0" : "") + span.Duration().Hours + 
-                        ":" + (10 > span.Minutes ? "0" : "") + span.Minutes;
-                    dateBefore += " " + strSpan;
-                }
-                
-                dateAfter  = DateTime.ParseExact( dateBefore, "F", formater );
-                
-                //Dev10 Bug 686124: For mac, the ambiguous and invalid points in time on the Mac
-                if (false == TimeZoneInfo.Local.IsInvalidTime(dateBeforeForValidity))
-                {
-                    if ((month + 1) != dateAfter.Month
-                           || day != dateAfter.Day
-                           || year != dateAfter.Year
-                           || (DayOfWeek)dayOfWeek != dateAfter.DayOfWeek
-                           || (hour + timeOfDay * 12) != dateAfter.Hour
-                           || minute != dateAfter.Minute
-                           || second != dateAfter.Second)
-                    {
-                        TestLibrary.TestFramework.LogError("009", "DateTime.ParseExact(" + dateBefore + ") did not equal (" + dateAfter.DayOfWeek + ", " + c_MONTHS[dateAfter.Month - 1] + " " + dateAfter.Day + ", " + dateAfter.Year + " " + dateAfter.Hour + ":" + dateAfter.Minute + ":" + dateAfter.Second + ")");
-                        retVal = false;
-                    }
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("010", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("010", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest7()
-    {
-        bool     retVal = true;
-        MyFormater formater = new MyFormater();
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      day;       // 1 - 28
-        int      month;     // 1 - 12
-        int      year;      // 1900 - 2000
-        int      hour;      // 0 - 11
-        int      minute;    // 0 - 59
-        int      second;    // 0 - 59
-        int      timeOfDay; // 0 -1
-        string[] twelveHour = new string[2] {"AM", "PM"};
-
-        DateTime dateBeforeForValidity;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest7: DateTime.ParseExact(G, ex: 1/3/2002 12:00:00 AM)");
-
-        // Culture could be customized
-        if (!(String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.ShortDatePattern, "M/d/yyyy", StringComparison.Ordinal) == 0 &&
-              (String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.LongTimePattern, "hh:mm:ss tt", StringComparison.Ordinal) == 0 ||
-               String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.LongTimePattern, "h:mm:ss tt", StringComparison.Ordinal) == 0)))
-        {
-            TestLibrary.TestFramework.LogInformation("Skipping test case, " +
-                                                     " ShortDatePattern: " + TestLibrary.Utilities.CurrentCulture.DateTimeFormat.ShortDatePattern +
-                                                     " LongTimePattern: " + TestLibrary.Utilities.CurrentCulture.DateTimeFormat.LongTimePattern);
-            return retVal;
-        }
-
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                day       = (TestLibrary.Generator.GetInt32(-55) % 27) + 1;
-                year      = (TestLibrary.Generator.GetInt32(-55) % 100) + 1930;
-                month     = (TestLibrary.Generator.GetInt32(-55) % 12) + 1;
-                hour      = (TestLibrary.Generator.GetInt32(-55) % 12);
-                minute    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                second    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                timeOfDay = (TestLibrary.Generator.GetInt32(-55) % 2);
-                dateBeforeForValidity = new DateTime(year, month, day, hour, minute, second);
-
-                // parse the date
-                dateBefore =  month + "/" + + day + "/" + year + " " +
-                              (String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.LongTimePattern, "hh:mm:ss tt", StringComparison.Ordinal) == 0 && 10 > hour ? "0" : "") + hour + ":" + 
-                              (10 > minute ? "0" : "") + minute + ":" + (10 > second ? "0" : "") + second + " " + twelveHour[timeOfDay];
-
-                if (!TestLibrary.Utilities.IsWindows)
-                {
-                    dateAfter = DateTime.Parse(dateBefore);
-                    TimeSpan span = dateAfter - dateAfter.ToUniversalTime();
-                    String strSpan = (span.Duration()==span ? "+" : "-") + 
-                        (10 > span.Duration().Hours ? "0" : "") + span.Duration().Hours + 
-                        ":" + (10 > span.Minutes ? "0" : "") + span.Minutes;
-                    dateBefore += " " + strSpan;
-                }
-
-                dateAfter = DateTime.ParseExact(dateBefore, "G", formater);
-
-                //Dev10 Bug 686124: For mac, the ambiguous and invalid points in time on the Mac
-                if (false == TimeZoneInfo.Local.IsInvalidTime(dateBeforeForValidity))
-                {
-                    if (month != dateAfter.Month
-                           || day != dateAfter.Day
-                           || year != dateAfter.Year
-                           || (hour + timeOfDay * 12) != dateAfter.Hour
-                           || minute != dateAfter.Minute
-                           || second != dateAfter.Second)
-                    {
-                        TestLibrary.TestFramework.LogError("013", "DateTime.ParseExact(" + dateBefore + ") did not equal (" + dateAfter.Month + "/" + dateAfter.Day + "/" + dateAfter.Year + " " + dateAfter.Hour + ":" + dateAfter.Minute + ":" + dateAfter.Second + ")");
-                        retVal = false;
-                    }
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("014", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("014", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest8()
-    {
-        bool     retVal = true;
-        MyFormater formater = new MyFormater();
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      day;       // 1 - 28
-        int      month;     // 0 - 11
-
-        TestLibrary.TestFramework.BeginScenario("PosTest8: DateTime.ParseExact(m, MMMM dd (MonthDayPattern ex: January 03))");
-
-        // Culture could be customized
-        if (String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.MonthDayPattern, "MMMM dd", StringComparison.Ordinal) != 0)
-        {
-            TestLibrary.TestFramework.LogInformation("Skipping test case, MonthDayPattern: " + TestLibrary.Utilities.CurrentCulture.DateTimeFormat.MonthDayPattern);
-            return retVal;
-        }
-
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                day       = (TestLibrary.Generator.GetInt32(-55) % 27) + 1;
-                month     = (TestLibrary.Generator.GetInt32(-55) % 12);
-
-                // parse the date
-                dateBefore = c_MONTHS[month] + " " + (10>day?"0":"") + day;
-                dateAfter  = DateTime.ParseExact( dateBefore, "m", formater );
-
-                if ((month+1) != dateAfter.Month 
-                       || day != dateAfter.Day)
-                {
-                    TestLibrary.TestFramework.LogError("015", "DateTime.ParseExact(" + dateBefore + ") did not equal (" + c_MONTHS[dateAfter.Month-1] + " " + dateAfter.Day + ")");
-                    retVal = false;
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("016", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("016", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest9()
-    {
-        bool     retVal = true;
-        MyFormater formater = new MyFormater();
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      dayOfWeek; // 0 - 6
-        int      day;       // 1 - 28
-        int      year;      // 1900 - 2000
-        int      month;     // 0 - 11
-        int      hour;      // 12 - 23
-        int      minute;    // 0 - 59
-        int      second;    // 0 - 59
-        DateTime dateBeforeForValidity;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest9: DateTime.ParseExact(R, ddd, dd MMM yyyy HH':'mm':'ss 'GMT' (RFC1123Pattern ex: Thu, 03 Jan 2002 00:00:00 GMT))");
-
-        // if there is any change in RFC1123Pattern, this test case would fail. The formatting should be updated!!!
-        if (String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.RFC1123Pattern, "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'", StringComparison.Ordinal) != 0)
-        {
-            TestLibrary.TestFramework.LogError("PosTest9", "Skipping test case, RFC1123Pattern: " + TestLibrary.Utilities.CurrentCulture.DateTimeFormat.RFC1123Pattern);
-            return false;
-        }
-
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                day       = (TestLibrary.Generator.GetInt32(-55) % 27) + 1;
-                year      = (TestLibrary.Generator.GetInt32(-55) % 100) + 1900;
-                month     = (TestLibrary.Generator.GetInt32(-55) % 12);
-                hour      = (TestLibrary.Generator.GetInt32(-55) % 12) + 12;	// Parse will convert perform GMT -> PST conversion
-                minute    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                second    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                dayOfWeek = (TestLibrary.Generator.GetInt32(-55) % 7);
-
-                dateBeforeForValidity = new DateTime(year, month + 1, day, hour, minute, second);
-
-		// cheat and get day of the week
-                dateAfter = DateTime.Parse( (month+1) + "/" + day + "/" + year);
-                dayOfWeek = (int)dateAfter.DayOfWeek;
-
-                // parse the date
-                dateBefore = c_DAYS_SH[dayOfWeek] + ", " + (10>day?"0":"") + day + " " + c_MONTHS_SH[month] + " " + year + " " + (10>hour?"0":"") + hour + ":" + (10>minute?"0":"") + minute + ":" + (10>second?"0":"") + second + " GMT";
-                dateAfter  = DateTime.ParseExact( dateBefore, "R", formater );
-
-                //Dev10 Bug 686124: For mac, the ambiguous and invalid points in time on the Mac
-                if (false == TimeZoneInfo.Local.IsInvalidTime(dateBeforeForValidity))
-                {
-                    if ((month + 1) != dateAfter.Month
-                           || day != dateAfter.Day
-                           || year != dateAfter.Year
-                           || (DayOfWeek)dayOfWeek != dateAfter.DayOfWeek
-                           || minute != dateAfter.Minute
-                           || second != dateAfter.Second)
-                    {
-                        TestLibrary.TestFramework.LogError("017", "DateTime.ParseExact(" + dateBefore + ") did not equal (" + c_DAYS_SH[(int)dateAfter.DayOfWeek] + ", " + dateAfter.Day + " " + c_MONTHS_SH[dateAfter.Month - 1] + " " + dateAfter.Year + " " + dateAfter.Hour + ":" + dateAfter.Minute + ":" + dateAfter.Second + " GMT)");
-                        retVal = false;
-                    }
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("018", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("018", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest10()
-    {
-        bool     retVal = true;
-        MyFormater formater = new MyFormater();
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      day;       // 1 - 28
-        int      month;     // 1 - 12
-        int      year;      // 1900 - 2000
-        int      hour;      // 0 - 23
-        int      minute;    // 0 - 59
-        int      second;    // 0 - 59
-        DateTime dateBeforeForValidity;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest10: DateTime.ParseExact(s, yyyy'-'MM'-'dd'T'HH':'mm':'ss (SortableDateTimePattern ex: 2002-01-03T00:00:00))");
-        // if there is any change in SortableDateTimePattern, this test case would fail, The formatting should be updated!!!
-        if (String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.SortableDateTimePattern, "yyyy'-'MM'-'dd'T'HH':'mm':'ss", StringComparison.Ordinal) != 0)
-        {
-            TestLibrary.TestFramework.LogError("PosTest10", "Skipping test case, SortableDateTimePattern: " + TestLibrary.Utilities.CurrentCulture.DateTimeFormat.SortableDateTimePattern);
-            return false;
-        }
-
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                day       = (TestLibrary.Generator.GetInt32(-55) % 27) + 1;
-                year      = (TestLibrary.Generator.GetInt32(-55) % 100) + 1900;
-                month     = (TestLibrary.Generator.GetInt32(-55) % 12) + 1;
-                hour      = (TestLibrary.Generator.GetInt32(-55) % 24);
-                minute    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                second    = (TestLibrary.Generator.GetInt32(-55) % 60);
-
-                dateBeforeForValidity = new DateTime(year, month, day, hour, minute, second);
-
-                // parse the date
-                dateBefore = year + "-" + (10>month?"0":"") + month + "-" + (10>day?"0":"") + day + "T" + ((10 > hour) ? "0" : "") + hour + ":" + ((10 > minute) ? "0" : "") + minute + ":" + ((10 > second) ? "0" : "") + second;
-                dateAfter  = DateTime.ParseExact( dateBefore, "s", formater );
-
-                //Dev10 Bug 686124: For mac, the ambiguous and invalid points in time on the Mac
-                if (false == TimeZoneInfo.Local.IsInvalidTime(dateBeforeForValidity))
-                {
-                    if (month != dateAfter.Month
-                           || day != dateAfter.Day
-                           || year != dateAfter.Year
-                           || hour != dateAfter.Hour
-                           || minute != dateAfter.Minute
-                           || second != dateAfter.Second)
-                    {
-                        TestLibrary.TestFramework.LogError("019", "DateTime.ParseExact(" + dateBefore + ") did not equal (" + dateAfter.Year + "-" + dateAfter.Month + "-" + dateAfter.Day + "T" + dateAfter.Hour + ":" + dateAfter.Minute + ":" + dateAfter.Second + ")");
-                        retVal = false;
-                    }
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("020", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("020", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest12()
-    {
-        bool     retVal = true;
-        MyFormater formater = new MyFormater();
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      hour;      // 0 - 11
-        int      minute;    // 0 - 59
-        int      second;    // 0 - 59
-        int      timeOfDay; // 0 -1
-        string[] twelveHour = new string[2] {"AM", "PM"};
-
-        TestLibrary.TestFramework.BeginScenario("PosTest12: DateTime.ParseExact(T, h:mm:ss tt (LongTimePattern ex: 12:00:00 AM))");
-
-        // Culture could be customized
-        if (String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.LongTimePattern, "hh:mm:ss tt", StringComparison.Ordinal) != 0 &&
-            String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.LongTimePattern, "h:mm:ss tt", StringComparison.Ordinal) != 0)
-        {
-            TestLibrary.TestFramework.LogInformation("Skipping test case, " + " LongTimePattern: " + TestLibrary.Utilities.CurrentCulture.DateTimeFormat.LongTimePattern);
-            return retVal;
-        }
-
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                hour      = (TestLibrary.Generator.GetInt32(-55) % 12);
-                minute    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                second    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                timeOfDay = (TestLibrary.Generator.GetInt32(-55) % 2);
-
-                // parse the date
-                int newHour = hour==0?12:hour;
-                dateBefore = (String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.LongTimePattern, "hh:mm:ss tt", StringComparison.Ordinal) == 0 && 10 > newHour ? "0" : "") + newHour + 
-                             ":" + (10 > minute ? "0" : "") + minute + ":" + (10 > second ? "0" : "") + second + " " + twelveHour[timeOfDay];
-                if (!TestLibrary.Utilities.IsWindows)
-                {
-                    dateAfter = DateTime.Parse(dateBefore);
-                    TimeSpan span = dateAfter - dateAfter.ToUniversalTime();
-                    String strSpan = (span.Duration()==span ? "+" : "-") + 
-                        (10 > span.Duration().Hours ? "0" : "") + span.Duration().Hours + 
-                        ":" + (10 > span.Minutes ? "0" : "") + span.Minutes;
-                    dateBefore += " " + strSpan;
-                }
-
-                dateAfter = DateTime.ParseExact(dateBefore, "T", formater);
-
-                if ((hour + timeOfDay*12) != dateAfter.Hour
-                       || minute != dateAfter.Minute
-                       || second != dateAfter.Second)
-                {
-                    TestLibrary.TestFramework.LogError("023", "DateTime.ParseExact(" + dateBefore + ") did not equal (" + dateAfter.Hour + ":" + dateAfter.Minute + ":" + dateAfter.Second + ")");
-                    retVal = false;
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("024", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("024", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest13()
-    {
-        bool     retVal = true;
-        MyFormater formater = new MyFormater();
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      day;       // 1 - 28
-        int      month;     // 1 - 12
-        int      year;      // 1900 - 2000
-        int      hour;      // 12 - 23
-        int      minute;    // 0 - 59
-        int      second;    // 0 - 59
-        DateTime dateBeforeForValidity;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest13: DateTime.ParseExact(u, yyyy'-'MM'-'dd HH':'mm':'ss'Z' (UniversalSortableDateTimePattern ex: 2002-01-03 00:00:00Z))");
-        
-        // if there is any change in SortableDateTimePattern, this test case would fail, The formatting should be updated!!!
-        if (String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.UniversalSortableDateTimePattern, "yyyy'-'MM'-'dd HH':'mm':'ss'Z'", StringComparison.Ordinal) != 0)
-        {
-            TestLibrary.TestFramework.LogError("PosTest13", "Skipping test case, UniversalSortableDateTimePattern: " + TestLibrary.Utilities.CurrentCulture.DateTimeFormat.UniversalSortableDateTimePattern);
-            return false;
-        }
-
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                day       = (TestLibrary.Generator.GetInt32(-55) % 27) + 1;
-                year      = (TestLibrary.Generator.GetInt32(-55) % 100) + 1900;
-                month     = (TestLibrary.Generator.GetInt32(-55) % 12) + 1;
-                hour      = (TestLibrary.Generator.GetInt32(-55) % 12) + 12;	// conversion
-                minute    = (TestLibrary.Generator.GetInt32(-55) % 60);
-                second    = (TestLibrary.Generator.GetInt32(-55) % 60);
-
-                dateBeforeForValidity = new DateTime(year, month, day, hour, minute, second);
-
-                // parse the date
-                dateBefore = year + "-" + (10>month?"0":"") + month + "-" + (10>day?"0":"") + day + " " + ((10 > hour) ? "0" : "") + hour + ":" + ((10 > minute) ? "0" : "") + minute + ":" + ((10 > second) ? "0" : "") + second +"Z";
-                dateAfter  = DateTime.ParseExact( dateBefore, "u", formater );
-
-                //Dev10 Bug 686124: For mac, the ambiguous and invalid points in time on the Mac
-                if (false == TimeZoneInfo.Local.IsInvalidTime(dateBeforeForValidity))
-                {
-                    if (month != dateAfter.Month
-                           || day != dateAfter.Day
-                           || year != dateAfter.Year
-                           || minute != dateAfter.Minute
-                           || second != dateAfter.Second)
-                    {
-                        TestLibrary.TestFramework.LogError("025", "DateTime.ParseExact(" + dateBefore + ") did not equal (" + dateAfter.Year + "-" + dateAfter.Month + "-" + dateAfter.Day + " " + dateAfter.Hour + ":" + dateAfter.Minute + ":" + dateAfter.Second + "Z)");
-                        retVal = false;
-                    }
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("026", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("026", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest14()
-    {
-        bool     retVal = true;
-        MyFormater formater = new MyFormater();
-        DateTime dateAfter;
-        string   dateBefore = "";
-        int      year;      // 1900 - 2000
-        int      month;     // 0 - 11
-
-        TestLibrary.TestFramework.BeginScenario("PosTest14: DateTime.ParseExact(y, MMMM, yyyy (YearMonthPattern ex: January, 2002))");
-        
-        // Culture could be customized
-        if (String.Compare(TestLibrary.Utilities.CurrentCulture.DateTimeFormat.YearMonthPattern, "MMMM, yyyy", StringComparison.Ordinal) != 0 )
-        {
-            TestLibrary.TestFramework.LogInformation("Skipping test case, YearMonthPattern: " + TestLibrary.Utilities.CurrentCulture.DateTimeFormat.YearMonthPattern);
-            return retVal;
-        }
-
-        try
-        {
-            for(int i=0; i<c_NUM_LOOPS; i++)
-            {
-                year      = (TestLibrary.Generator.GetInt32(-55) % 100) + 1900;
-                month     = (TestLibrary.Generator.GetInt32(-55) % 12);
-
-                dateBefore = c_MONTHS[month] + ", " + year;
-                dateAfter = DateTime.ParseExact(dateBefore, "y", formater);
-
-                if ((month+1) != dateAfter.Month
-                        || year != dateAfter.Year)
-                {
-                    TestLibrary.TestFramework.LogError("027", "DateTime.ParseExact(" + dateBefore + ") did not equal (" + c_MONTHS[dateAfter.Month-1] + ", " + dateAfter.Year + ")-("+dateAfter.ToString()+")-DST("+dateAfter.IsDaylightSavingTime()+")");
-                    retVal = false;
-                }
-             }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("028", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("028", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest15()
-    {
-        bool     retVal = true;
-        MyFormater formater = new MyFormater();
-        string   dateBefore = "";
-        DateTime dateAfter;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest15: DateTime.ParseExact(G, DateTime.Now, null)");
-
-        try
-        {
-            dateBefore = DateTime.Now.ToString();
-
-            dateAfter = DateTime.ParseExact( dateBefore, "G", null );
-
-            if (!dateBefore.Equals(dateAfter.ToString()))
-            {
-                TestLibrary.TestFramework.LogError("101", "DateTime.ParseExact(" + dateBefore + ") did not equal " + dateAfter.ToString());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("102", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("102", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest1()
-    {
-        bool      retVal = true;
-        MyFormater formater = new MyFormater();
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: DateTime.ParseExact(null)");
-
-        try
-        {
-            DateTime.ParseExact(null, "d", formater);
-
-            TestLibrary.TestFramework.LogError("029", "DateTime.ParseExact(null) should have thrown");
-            retVal = false;
-        }
-        catch (ArgumentNullException)
-        {
-            // expected
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("030", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest2()
-    {
-        bool      retVal = true;
-        MyFormater formater = new MyFormater();
-
-        TestLibrary.TestFramework.BeginScenario("NegTest2: DateTime.ParseExact(String.Empty)");
-
-        try
-        {
-            DateTime.ParseExact(String.Empty, "d", formater);
-
-            TestLibrary.TestFramework.LogError("031", "DateTime.ParseExact(String.Empty) should have thrown");
-            retVal = false;
-        }
-        catch (FormatException)
-        {
-            // expected
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("032", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest3()
-    {
-        bool   retVal = true;
-        MyFormater formater = new MyFormater();
-        string strDateTime = "";
-        DateTime dateAfter;
-        string[] formats = new string[17] {"d", "D", "f", "F", "g", "G", "m", "M", "r", "R", "s", "t", "T", "u", "U", "y", "Y"};
-        string   format;
-        int      formatIndex;
-       
-
-        TestLibrary.TestFramework.BeginScenario("NegTest3: DateTime.ParseExact(<garbage>)");
-
-        try
-        {
-            for (int i=0; i<c_NUM_LOOPS; i++)
-            {
-                try
-                {
-                    formatIndex = TestLibrary.Generator.GetInt32(-55) % 34;
-
-                    if (0 <= formatIndex && formatIndex < 17)
-                    {
-                        format = formats[formatIndex];
-                    }
-                    else
-                    {
-                        format = TestLibrary.Generator.GetChar(-55) + "";
-                    }
-
-                    strDateTime = TestLibrary.Generator.GetString(-55, false, c_MIN_STRING_LEN, c_MAX_STRING_LEN);
-                    dateAfter = DateTime.ParseExact(strDateTime, format, formater);
-
-                    TestLibrary.TestFramework.LogError("033", "DateTime.ParseExact(" + strDateTime + ", "+ format + ") should have thrown (" + dateAfter + ")");
-                    retVal = false;
-                }
-                catch (FormatException)
-                {
-                    // expected
-                }
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("034", "Failing date: " + strDateTime);
-            TestLibrary.TestFramework.LogError("034", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest4()
-    {
-        bool     retVal = true;
-        MyFormater formater = new MyFormater();
-        string   dateBefore = "";
-        DateTime dateAfter;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest4: DateTime.ParseExact(\"\", DateTime.Now, formater)");
-
-        try
-        {
-            dateBefore = DateTime.Now.ToString();
-
-            dateAfter = DateTime.ParseExact( dateBefore, "", formater );
-
-            TestLibrary.TestFramework.LogError("103", "DateTime.ParseExact(" + dateBefore + ") should have thrown " + dateAfter.ToString());
-            retVal = false;
-        }
-        catch (System.FormatException)
-        {
-            // expected
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("104", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("104", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest5()
-    {
-        bool     retVal = true;
-        MyFormater formater = new MyFormater();
-        string   dateBefore = "";
-        DateTime dateAfter;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest5: DateTime.ParseExact(null, DateTime.Now, formater)");
-
-        try
-        {
-            dateBefore = DateTime.Now.ToString();
-
-            dateAfter = DateTime.ParseExact( dateBefore, null, formater );
-
-            TestLibrary.TestFramework.LogError("105", "DateTime.ParseExact(" + dateBefore + ") should have thrown " + dateAfter.ToString());
-            retVal = false;
-        }
-        catch (System.ArgumentNullException)
-        {
-            // expected
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("106", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("106", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-}
-
-public class MyFormater : IFormatProvider
-{
-    public object GetFormat(Type formatType)
-    {
-        if (typeof(IFormatProvider) == formatType)
-        {
-            return this;
-        }
-        else
-        {
-            return null;
-        }
-    }
-}
-
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimeparseexact2.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimeparseexact2.cs
deleted file mode 100644
index 53ee48b932..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimeparseexact2.cs
+++ /dev/null
@@ -1,285 +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.
-using System;
-using System.Globalization;
-
-public class DateTimeParseExact2
-{
-    private const  int c_MIN_STRING_LEN = 1;
-    private const  int c_MAX_STRING_LEN = 2048;
-    private const  int c_NUM_LOOPS      = 100;
-    private static DateTimeStyles[] c_STYLES = new DateTimeStyles[7] {DateTimeStyles.AdjustToUniversal, DateTimeStyles.AllowInnerWhite, DateTimeStyles.AllowLeadingWhite, DateTimeStyles.AllowTrailingWhite , DateTimeStyles.AllowWhiteSpaces, DateTimeStyles.NoCurrentDateDefault, DateTimeStyles.None };
-
-
-    public static int Main()
-    {
-        DateTimeParseExact2 test = new DateTimeParseExact2();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeParseExact2");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-
-        TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-        retVal = NegTest2() && retVal;
-        retVal = NegTest3() && retVal;
-
-        return retVal;
-    }
-
-    public bool PosTest1()
-    {
-        bool     retVal = true;
-        MyFormater formater = new MyFormater();
-        string   dateBefore = "";
-        DateTime dateAfter;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: DateTime.ParseExact(DateTime.Now)");
-
-        try
-        {
-            for(int i=0; i<c_STYLES.Length; i++)
-            {
-                dateBefore = DateTime.Now.ToString();
-
-                dateAfter = DateTime.ParseExact( dateBefore, "G", formater, c_STYLES[i] );
-
-                if (!TestLibrary.Utilities.IsWindows && 
-                    (c_STYLES[i]==DateTimeStyles.AdjustToUniversal)) // Mac prints offset
-                {
-                    dateAfter = dateAfter.ToLocalTime();
-                }
-
-                if (!dateBefore.Equals(dateAfter.ToString()))
-                {
-                   TestLibrary.TestFramework.LogError("001", "DateTime.ParseExact(" + dateBefore + ", G, " + c_STYLES[i] + ") did not equal " + dateAfter.ToString());
-                   retVal = false;
-               }
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-
-    public bool PosTest2()
-    {
-        bool     retVal = true;
-        string   dateBefore = "";
-        DateTime dateAfter;
-        MyFormater formater = new MyFormater();
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: DateTime.ParseExact(DateTime.Now, g, formater, <invalid DateTimeStyles>)");
-
-        try
-        {
-            for(int i=-1024; i<1024; i++)
-            {
-                try
-                {
-                    // skip the valid values
-                    if (0 == (i & (int)DateTimeStyles.AdjustToUniversal)
-                        && 0 == (i & (int)DateTimeStyles.AssumeUniversal)
-                        && 0 == (i & (int)DateTimeStyles.AllowInnerWhite)
-                        && 0 == (i & (int)DateTimeStyles.AllowLeadingWhite)
-                        && 0 == (i & (int)DateTimeStyles.AllowTrailingWhite)
-                        && 0 == (i & (int)DateTimeStyles.AllowWhiteSpaces)
-                        && 0 == (i & (int)DateTimeStyles.NoCurrentDateDefault)
-                        && i != (int)DateTimeStyles.None
-                       )
-                    {
-                        dateBefore = DateTime.Now.ToString();
-
-                        dateAfter = DateTime.ParseExact( dateBefore, "G", formater, (DateTimeStyles)i);
-
-                        if (!dateBefore.Equals(dateAfter.ToString()))
-                        {
-                           TestLibrary.TestFramework.LogError("011", "DateTime.ParseExact(" + dateBefore + ", " + (DateTimeStyles)i + ") did not equal " + dateAfter.ToString());
-                            retVal = false;
-                        }
-                    }
-                }
-                catch (System.ArgumentException)
-                {
-                    //
-                }
-           }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("012", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("012", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest1()
-    {
-        bool      retVal = true;
-        MyFormater formater = new MyFormater();
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: DateTime.ParseExact(null)");
-
-        try
-        {
-            try
-            {
-                for(int i=0; i<c_STYLES.Length; i++)
-                {
-                     DateTime.ParseExact(null, "d", formater, c_STYLES[i]);
-
-                     TestLibrary.TestFramework.LogError("029", "DateTime.ParseExact(null, d, " + c_STYLES[i] + ") should have thrown");
-                     retVal = false;
-                }
-            }
-            catch (ArgumentNullException)
-            {
-                // expected
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("030", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest2()
-    {
-        bool      retVal = true;
-        MyFormater formater = new MyFormater();
-
-        TestLibrary.TestFramework.BeginScenario("NegTest2: DateTime.ParseExact(String.Empty)");
-
-        try
-        {
-            try
-            {
-                for(int i=0; i<c_STYLES.Length; i++)
-                {
-                     DateTime.ParseExact(String.Empty, "d", formater, c_STYLES[i]);
-
-                     TestLibrary.TestFramework.LogError("029", "DateTime.ParseExact(String.Empty, d, " + c_STYLES[i] + ") should have thrown");
-                     retVal = false;
-                }
-            }
-            catch (ArgumentNullException)
-            {
-                // expected
-            }
-        }
-        catch (FormatException)
-        {
-            // expected
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("032", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest3()
-    {
-        bool   retVal = true;
-        MyFormater formater = new MyFormater();
-        string strDateTime = "";
-        DateTime dateAfter;
-        string[] formats = new string[17] {"d", "D", "f", "F", "g", "G", "m", "M", "r", "R", "s", "t", "T", "u", "U", "y", "Y"};
-        string   format;
-        int      formatIndex;
-       
-
-        TestLibrary.TestFramework.BeginScenario("NegTest3: DateTime.ParseExact(<garbage>)");
-
-        try
-        {
-            for (int i=0; i<c_NUM_LOOPS; i++)
-            {
-                for(int j=0; j<c_STYLES.Length; j++)
-                {
-                    try
-                    {
-                        formatIndex = TestLibrary.Generator.GetInt32(-55) % 34;
-
-                        if (0 <= formatIndex && formatIndex < 17)
-                        {
-                            format = formats[formatIndex];
-                        }
-                        else
-                        {
-                            format = TestLibrary.Generator.GetChar(-55) + "";
-                        }
-
-                        strDateTime = TestLibrary.Generator.GetString(-55, false, c_MIN_STRING_LEN, c_MAX_STRING_LEN);
-                        dateAfter = DateTime.ParseExact(strDateTime, format, formater, c_STYLES[j]);
-
-                        TestLibrary.TestFramework.LogError("033", "DateTime.ParseExact(" + strDateTime + ", "+ format + ", " + c_STYLES[j] + ") should have thrown (" + dateAfter + ")");
-                        retVal = false;
-                    }
-                    catch (FormatException)
-                    {
-                        // expected
-                    }
-                }
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("034", "Failing date: " + strDateTime);
-            TestLibrary.TestFramework.LogError("034", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-}
-
-public class MyFormater : IFormatProvider
-{
-    public object GetFormat(Type formatType)
-    {
-        if (typeof(IFormatProvider) == formatType)
-        {
-            return this;
-        }
-        else
-        {
-            return null;
-        }
-    }
-}
-
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimeparseexact3.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimeparseexact3.cs
deleted file mode 100644
index 6f08e378bd..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimeparseexact3.cs
+++ /dev/null
@@ -1,318 +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.
-using System;
-using System.Globalization;
-
-public class DateTimeParseExact2
-{
-    private const  int c_MIN_STRING_LEN = 1;
-    private const  int c_MAX_STRING_LEN = 2048;
-    private const  int c_NUM_LOOPS      = 100;
-    private static DateTimeStyles[] c_STYLES = new DateTimeStyles[7] {DateTimeStyles.AdjustToUniversal, DateTimeStyles.AllowInnerWhite, DateTimeStyles.AllowLeadingWhite, DateTimeStyles.AllowTrailingWhite , DateTimeStyles.AllowWhiteSpaces, DateTimeStyles.NoCurrentDateDefault, DateTimeStyles.None };
-
-
-    public static int Main()
-    {
-        DateTimeParseExact2 test = new DateTimeParseExact2();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeParseExact2");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-
-        TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-        retVal = NegTest2() && retVal;
-        retVal = NegTest3() && retVal;
-        retVal = NegTest4() && retVal;
-
-        return retVal;
-    }
-
-    public bool PosTest1()
-    {
-        bool     retVal = true;
-        MyFormater formater = new MyFormater();
-        string   dateBefore = "";
-        DateTime dateAfter;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: DateTime.ParseExact(DateTime.Now)");
-
-        try
-        {
-            for(int i=0; i<c_STYLES.Length; i++)
-            {
-                dateBefore = DateTime.Now.ToString();
-
-                dateAfter = DateTime.ParseExact( dateBefore, new string[] {"G"}, formater, c_STYLES[i] );
-
-                if (!TestLibrary.Utilities.IsWindows && 
-                    (c_STYLES[i]==DateTimeStyles.AdjustToUniversal)) // Mac prints offset
-                {
-                    dateAfter = dateAfter.ToLocalTime();
-                }
-
-                if (!dateBefore.Equals(dateAfter.ToString()))
-                {
-                   TestLibrary.TestFramework.LogError("001", "DateTime.ParseExact(" + dateBefore + ", G, " + c_STYLES[i] + ") did not equal " + dateAfter.ToString());
-                   retVal = false;
-               }
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool     retVal = true;
-        string   dateBefore = "";
-        DateTime dateAfter;
-        MyFormater formater = new MyFormater();
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: DateTime.ParseExact(DateTime.Now, g, formater, <invalid DateTimeStyles>)");
-
-        try
-        {
-            for(int i=-1024; i<1024; i++)
-            {
-                try
-                {
-                    // skip the valid values
-                    if (0 == (i & (int)DateTimeStyles.AdjustToUniversal)
-                        && 0 == (i & (int)DateTimeStyles.AssumeUniversal)
-                        && 0 == (i & (int)DateTimeStyles.AllowInnerWhite)
-                        && 0 == (i & (int)DateTimeStyles.AllowLeadingWhite)
-                        && 0 == (i & (int)DateTimeStyles.AllowTrailingWhite)
-                        && 0 == (i & (int)DateTimeStyles.AllowWhiteSpaces)
-                        && 0 == (i & (int)DateTimeStyles.NoCurrentDateDefault)
-                        && i != (int)DateTimeStyles.None
-                       )
-                    {
-                        dateBefore = DateTime.Now.ToString();
-
-                        dateAfter = DateTime.ParseExact( dateBefore, new string[] {"G"}, formater, (DateTimeStyles)i);
-
-                        if (!dateBefore.Equals(dateAfter.ToString()))
-                        {
-                           TestLibrary.TestFramework.LogError("011", "DateTime.ParseExact(" + dateBefore + ", " + (DateTimeStyles)i + ") did not equal " + dateAfter.ToString());
-                            retVal = false;
-                        }
-                    }
-                }
-                catch (System.ArgumentException)
-                {
-                    //
-                }
-           }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("012", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("012", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest1()
-    {
-        bool      retVal = true;
-        MyFormater formater = new MyFormater();
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: DateTime.ParseExact(null)");
-
-        try
-        {
-            try
-            {
-                for(int i=0; i<c_STYLES.Length; i++)
-                {
-                     DateTime.ParseExact(null, new string[] {"d"}, formater, c_STYLES[i]);
-
-                     TestLibrary.TestFramework.LogError("029", "DateTime.ParseExact(null, d, " + c_STYLES[i] + ") should have thrown");
-                     retVal = false;
-                }
-            }
-            catch (ArgumentNullException)
-            {
-                // expected
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("030", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest2()
-    {
-        bool      retVal = true;
-        MyFormater formater = new MyFormater();
-
-        TestLibrary.TestFramework.BeginScenario("NegTest2: DateTime.ParseExact(String.Empty)");
-
-        try
-        {
-            try
-            {
-                for(int i=0; i<c_STYLES.Length; i++)
-                {
-                     DateTime.ParseExact(String.Empty, new string[] {"d"}, formater, c_STYLES[i]);
-
-                     TestLibrary.TestFramework.LogError("029", "DateTime.ParseExact(String.Empty, d, " + c_STYLES[i] + ") should have thrown");
-                     retVal = false;
-                }
-            }
-            catch (ArgumentNullException)
-            {
-                // expected
-            }
-        }
-        catch (FormatException)
-        {
-            // expected
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("032", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest3()
-    {
-        bool   retVal = true;
-        MyFormater formater = new MyFormater();
-        string strDateTime = "";
-        DateTime dateAfter;
-        string[] formats = new string[17] {"d", "D", "f", "F", "g", "G", "m", "M", "r", "R", "s", "t", "T", "u", "U", "y", "Y"};
-        string   format;
-        int      formatIndex;
-       
-
-        TestLibrary.TestFramework.BeginScenario("NegTest3: DateTime.ParseExact(<garbage>)");
-
-        try
-        {
-            for (int i=0; i<c_NUM_LOOPS; i++)
-            {
-                for(int j=0; j<c_STYLES.Length; j++)
-                {
-                    try
-                    {
-                        formatIndex = TestLibrary.Generator.GetInt32(-55) % 34;
-
-                        if (0 <= formatIndex && formatIndex < 17)
-                        {
-                            format = formats[formatIndex];
-                        }
-                        else
-                        {
-                            format = TestLibrary.Generator.GetChar(-55) + "";
-                        }
-
-                        strDateTime = TestLibrary.Generator.GetString(-55, false, c_MIN_STRING_LEN, c_MAX_STRING_LEN);
-                        dateAfter = DateTime.ParseExact(strDateTime, new string[] {format}, formater, c_STYLES[j]);
-
-                        TestLibrary.TestFramework.LogError("033", "DateTime.ParseExact(" + strDateTime + ", "+ format + ", " + c_STYLES[j] + ") should have thrown (" + dateAfter + ")");
-                        retVal = false;
-                    }
-                    catch (FormatException)
-                    {
-                        // expected
-                    }
-                }
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("034", "Failing date: " + strDateTime);
-            TestLibrary.TestFramework.LogError("034", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest4()
-    {
-        bool     retVal = true;
-        MyFormater formater = new MyFormater();
-        string   dateBefore = "";
-        DateTime dateAfter;
-        string[] formats = null;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest4: DateTime.ParseExact(DateTime.Now, null)");
-
-        try
-        {
-            dateBefore = DateTime.Now.ToString();
-
-            dateAfter = DateTime.ParseExact( dateBefore, formats, formater, DateTimeStyles.NoCurrentDateDefault );
-
-            TestLibrary.TestFramework.LogError("035", "DateTime.ParseExact(" + dateBefore + ", null, " + DateTimeStyles.NoCurrentDateDefault  + ") should have thrown " + dateAfter.ToString());
-            retVal = false;
-        }
-        catch (System.ArgumentNullException)
-        {
-            // expected
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("036", "Failing date: " + dateBefore);
-            TestLibrary.TestFramework.LogError("036", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-}
-
-public class MyFormater : IFormatProvider
-{
-    public object GetFormat(Type formatType)
-    {
-        if (typeof(IFormatProvider) == formatType)
-        {
-            return this;
-        }
-        else
-        {
-            return null;
-        }
-    }
-}
-
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimesecond.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimesecond.cs
deleted file mode 100644
index f6928c9d88..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimesecond.cs
+++ /dev/null
@@ -1,98 +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.
-using System;
-using System.Collections.Generic;
-using System.Threading;
-using System.Globalization;
-
-
-public class DateTimeSecond
-{
-    public static int Main(string[] args)
-    {
-        DateTimeSecond second = new DateTimeSecond();
-        TestLibrary.TestFramework.BeginTestCase("Testing System.DateTime.Second property...");
-
-        if (second.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-
-        return retVal;
-    }
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Verify DateTime.Second property when DateTime instance's second is assigned...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(0978, 08, 29, 03, 29, 22);
-            int second = myDateTime.Second;
-
-            if (second != 22)
-            {
-                TestLibrary.TestFramework.LogError("001", "The second is not correct!");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Verify DateTime.Second property When DateTime instance is only assigned year month and day...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(1978, 08, 29);
-            int second = myDateTime.Second;
-
-            if (second != 0)
-            {
-                TestLibrary.TestFramework.LogError("003", "The second is not zero when no value is assigned at init time!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimesubtract1.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimesubtract1.cs
deleted file mode 100644
index 953dd9f3d5..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimesubtract1.cs
+++ /dev/null
@@ -1,205 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// DateTime.Subtract(DateTime)
-/// </summary>
-public class DateTimeSubtract1
-{
-    public static int Main()
-    {
-        DateTimeSubtract1 dtsub1 = new DateTimeSubtract1();
-        TestLibrary.TestFramework.BeginTestCase("DataTimeSubtract1");
-        if (dtsub1.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[PosTest]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-        retVal = PosTest5() && retVal;
-        retVal = PosTest6() && retVal;
-        //TestLibrary.TestFramework.LogInformation("[NegTest]");
-        //retVal = NegTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TimeSpan resultTime;
-        TestLibrary.TestFramework.BeginScenario("PosTest1: The TimeSpan is in the range of MinValue and MaxValue 1");
-        try
-        {
-            DateTime date1 = new DateTime(1,1,1);
-            DateTime date2 = DateTime.MinValue.AddYears(1).AddMonths(1).AddDays(1);
-            resultTime = date2.Subtract(date1);
-            if (resultTime.Days != 397)
-            {
-                TestLibrary.TestFramework.LogError("001", "Expected: 397 days, actual: "+resultTime.Days);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TimeSpan resultTime;
-        TestLibrary.TestFramework.BeginScenario("PosTest2: The TimeSpan is in the range of MinValue and MaxValue 2");
-        try
-        {
-            DateTime date1 = new DateTime(1999, 1, 1).ToLocalTime();
-            DateTime date2 = new DateTime(2000, 1, 1).ToLocalTime();
-            resultTime = date2.Subtract(date1);
-            if (resultTime.Days != 365)
-            {
-                TestLibrary.TestFramework.LogError("003", "The ActualResult is not the ExpectResult");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest3()
-    {
-        bool retVal = true;
-        TimeSpan resultTime;
-        TestLibrary.TestFramework.BeginScenario("PosTest3: The TimeSpan is in the range of MinValue and MaxValue 3");
-        try
-        {
-            DateTime date1 = new DateTime(2000, 1, 1).ToLocalTime();
-            DateTime date2 = new DateTime(2001, 1, 1).ToLocalTime();
-            resultTime = date2.Subtract(date1);
-            if (resultTime.Days != 366)
-            {
-                TestLibrary.TestFramework.LogError("005", "The ActualResult is not the ExpectResult");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest4()
-    {
-        bool retVal = true;
-        TimeSpan resultTime;
-        TestLibrary.TestFramework.BeginScenario("PosTest4: The TimeSpan is in the range of MinValue and MaxValue 4");
-        try
-        {
-            DateTime date1 = new DateTime(2001, 1, 1).ToLocalTime();
-            DateTime date2 = new DateTime(2000, 1, 1).ToLocalTime();
-            resultTime = date2.Subtract(date1);
-            if (resultTime.Days != -366)
-            {
-                TestLibrary.TestFramework.LogError("007", "The ActualResult is not the ExpectResult");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("008", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest5()
-    {
-        bool retVal = true;
-        TimeSpan resultTime;
-        TestLibrary.TestFramework.BeginScenario("PosTest5: The TimeSpan is in the range of MinValue and MaxValue 5");
-        try
-        {
-            DateTime date1 = new DateTime(2000, 1, 1).ToLocalTime();
-            DateTime date2 = new DateTime(1999, 1, 1).ToLocalTime();
-            resultTime = date2.Subtract(date1);
-            if (resultTime.Days != -365)
-            {
-                TestLibrary.TestFramework.LogError("009", "The ActualResult is not the ExpectResult");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("010", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest6()
-    {
-        bool retVal = true;
-        TimeSpan resultTime;
-        TestLibrary.TestFramework.BeginScenario("PosTest6: The TimeSpan is in the range of MinValue and MaxValue 6");
-        try
-        {
-            DateTime date1 = new DateTime(2000, 1, 1).ToLocalTime();
-            DateTime date2 = new DateTime(2000, 1, 1).ToLocalTime();
-            resultTime = date2.Subtract(date1);
-            if (resultTime.Days != 0)
-            {
-                TestLibrary.TestFramework.LogError("011", "The ActualResult is not the ExpectResult");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("012", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-    #region NegativeTest
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-    //    TimeSpan resultTime;
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: The TimeSpan is less than DateTime MinValue");
-    //    try
-    //    {
-    //        DateTime date1 = DateTime.MinValue.ToLocalTime();
-    //        DateTime date2 = DateTime.MaxValue.ToLocalTime();
-    //        resultTime = date1.Subtract(date2);
-    //        retVal = false;
-    //        TestLibrary.TestFramework.LogError("N001", "the TimeSpan is less DateTime MinValue but not throw exception");
-    //    }
-    //    catch (ArgumentOutOfRangeException) { }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("N002", "Unexpect exception:" + e);
-    //        retVal = false;
-    //    }
-    //    return retVal;
-    //}
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimesubtract2.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimesubtract2.cs
deleted file mode 100644
index 90e4a5ce38..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimesubtract2.cs
+++ /dev/null
@@ -1,225 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// DateTime.Subtract(TimeSpan)
-/// </summary>
-public class DateTimeSubtract2
-{
-    public static int Main()
-    {
-        DateTimeSubtract2 dtsub2 = new DateTimeSubtract2();
-        TestLibrary.TestFramework.BeginTestCase("DataTimeSubtract2");
-        if (dtsub2.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[PosTest]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-        retVal = PosTest5() && retVal;
-        TestLibrary.TestFramework.LogInformation("[NegTest]");
-        retVal = NegTest1() && retVal;
-        retVal = NegTest2() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        DateTime resultTime;
-        TestLibrary.TestFramework.BeginScenario("PosTest1: The return dateTime is in the range of MinValue and MaxValue 1");
-        try
-        {
-            DateTime date1 = new DateTime(2000, 1, 1).ToLocalTime();
-            TimeSpan timeSpan = new TimeSpan(365, 0, 0, 0);
-            resultTime = date1.Subtract(timeSpan);
-            if (resultTime!= new DateTime(1999,1,1).ToLocalTime())
-            {
-                TestLibrary.TestFramework.LogError("001", "The ActualResult is not the ExpectResult");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        DateTime resultTime;
-        TestLibrary.TestFramework.BeginScenario("PosTest2: The return dateTime is in the range of MinValue and MaxValue 2");
-        try
-        {
-            DateTime date1 = new DateTime(1999, 1, 1).ToLocalTime();
-            TimeSpan timeSpan = new TimeSpan(-365, 0, 0, 0);
-            resultTime = date1.Subtract(timeSpan);
-            if (resultTime != new DateTime(2000, 1, 1).ToLocalTime())
-            {
-                TestLibrary.TestFramework.LogError("003", "The ActualResult is not the ExpectResult");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest3()
-    {
-        bool retVal = true;
-        DateTime resultTime;
-        TestLibrary.TestFramework.BeginScenario("PosTest3: The return dateTime is in the range of MinValue and MaxValue 3");
-        try
-        {
-            DateTime date1 = new DateTime(this.GetInt32(1,9999),this.GetInt32(1,12),this.GetInt32(1,28)).ToLocalTime();
-            TimeSpan timeSpan = new TimeSpan(0, 0, 0, 0);
-            resultTime = date1.Subtract(timeSpan);
-            if (resultTime != date1)
-            {
-                TestLibrary.TestFramework.LogError("005", "The ActualResult is not the ExpectResult");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest4()
-    {
-        bool retVal = true;
-        DateTime resultTime;
-        TestLibrary.TestFramework.BeginScenario("PosTest4: The return dateTime is in the range of MinValue and MaxValue 4");
-        try
-        {
-            DateTime date1 = new DateTime(2001, 1, 1).ToLocalTime();
-            TimeSpan timeSpan = new TimeSpan(366, 0, 0, 0);
-            resultTime = date1.Subtract(timeSpan);
-            if (resultTime != new DateTime(2000, 1, 1).ToLocalTime())
-            {
-                TestLibrary.TestFramework.LogError("007", "The ActualResult is not the ExpectResult");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("008", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest5()
-    {
-        bool retVal = true;
-        DateTime resultTime;
-        TestLibrary.TestFramework.BeginScenario("PosTest5: The return dateTime is in the range of MinValue and MaxValue 5");
-        try
-        {
-            DateTime date1 = new DateTime(2000, 1, 1).ToLocalTime();
-            TimeSpan timeSpan = new TimeSpan(-366, 0, 0, 0);
-            resultTime = date1.Subtract(timeSpan);
-            if (resultTime != new DateTime(2001, 1, 1).ToLocalTime())
-            {
-                TestLibrary.TestFramework.LogError("009", "The ActualResult is not the ExpectResult");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("010", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-    #region NegativeTest
-    public bool NegTest1()
-    {
-        bool retVal = true;
-        DateTime resultTime;
-        TestLibrary.TestFramework.BeginScenario("NegTest1: The return dateTime is out the range of MinValue and MaxValue 1");
-        try
-        {
-            DateTime date1 = DateTime.MinValue.ToLocalTime();
-            TimeSpan timeSpan = new TimeSpan(365, 0, 0, 0);
-            resultTime = date1.Subtract(timeSpan);
-            TestLibrary.TestFramework.LogError("N001", "The return datetime is less than MinValue but not throw exception");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException) { }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("N002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool NegTest2()
-    {
-        bool retVal = true;
-        DateTime resultTime;
-        TestLibrary.TestFramework.BeginScenario("NegTest2: The return dateTime is out the range of MinValue and MaxValue 1");
-        try
-        {
-            DateTime date1 = DateTime.MaxValue.ToLocalTime();
-            TimeSpan timeSpan = new TimeSpan(-365, 0, 0, 0);
-            resultTime = date1.Subtract(timeSpan);
-            retVal = false;
-            TestLibrary.TestFramework.LogError("N003", "The return datetime is greater than MaxValue but not throw exception");
-        }
-        catch (ArgumentOutOfRangeException) { }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("N004", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-    #region HelpMethod
-    private Int32 GetInt32(Int32 minValue, Int32 maxValue)
-    {
-        try
-        {
-            if (minValue == maxValue)
-            {
-                return minValue;
-            }
-            if (minValue < maxValue)
-            {
-                return minValue + TestLibrary.Generator.GetInt32(-55) % (maxValue - minValue);
-            }
-        }
-        catch
-        {
-            throw;
-        }
-
-        return minValue;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimeticks.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimeticks.cs
deleted file mode 100644
index 198c20ccde..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimeticks.cs
+++ /dev/null
@@ -1,99 +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.
-using System;
-using System.Collections;
-using System.Threading;
-
-
-/// <summary>
-/// System.DateTime.Ticks
-/// </summary>
-public class DateTimeTicks
-{
-    public static int Main(string[] args)
-    {
-        DateTimeTicks ticks = new DateTimeTicks();
-        TestLibrary.TestFramework.BeginTestCase("Testing System.DateTime.Ticks property...");
-
-        if (ticks.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        //retVal = PosTest3() && retVal;
-
-        return retVal;
-    }
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Verify ticks when DateTime instance is midnight, January 1, 0001...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new System.Globalization.CultureInfo("");
-            DateTime myDateTime = new DateTime(0001,01,01,00,00,00);
-            long ticks = myDateTime.Ticks;
-
-            if (ticks != 0)
-            {
-                TestLibrary.TestFramework.LogError("001", "The ticks is not zero when the DateTime instance is midnight, January 1, 0001...");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002","Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Verify ticks when DateTime instance is larger than midnight, January 1, 0001");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new System.Globalization.CultureInfo("");
-            DateTime myDateTime = new DateTime(1978,08,29,03,29,22);
-            long ticks = myDateTime.Ticks;
-
-            if (ticks <= 0)
-            {
-                TestLibrary.TestFramework.LogError("003","The ticks is wrong!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004","Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-}
-
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimetimeofday.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimetimeofday.cs
deleted file mode 100644
index 744242ee63..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimetimeofday.cs
+++ /dev/null
@@ -1,98 +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.
-using System;
-using System.Collections;
-using System.Threading;
-
-/// <summary>
-/// System.DateTime.TimeOfDay
-/// </summary>
-public class DateTimeTimeOfDay
-{
-    public static int Main(string[] args)
-    {
-        DateTimeTimeOfDay timeOfDay = new DateTimeTimeOfDay();
-        TestLibrary.TestFramework.BeginTestCase("Testing System.DateTime.TimeOfDay property...");
-
-        if (timeOfDay.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-
-        return retVal;
-    }
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Verify TimeOfDay when created instance is assigned time...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new System.Globalization.CultureInfo("");
-            DateTime myDateTime = new DateTime(1978,08,29,03,29,22);
-            TimeSpan myTimeSpan = myDateTime.TimeOfDay;
-
-            if (myTimeSpan.Days != 0 && myTimeSpan.Hours != 03 && myTimeSpan.Minutes != 29
-                && myTimeSpan.Seconds != 22 && myTimeSpan.Milliseconds != 0)
-            {
-                TestLibrary.TestFramework.LogError("001","The TimeSpan is wrong!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002","Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Verify TimeOfDay when created instance is not assigned time...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new System.Globalization.CultureInfo("");
-            DateTime myDateTime = new DateTime(1978,08,29);
-            TimeSpan myTimeSpan = myDateTime.TimeOfDay;
-
-            if (myTimeSpan.Hours != 0 && myTimeSpan.Minutes != 0 && myTimeSpan.Seconds != 0)
-            {
-                TestLibrary.TestFramework.LogError("003","The initial timeSpan is wrong!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004","Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-}
-
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimetoday.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimetoday.cs
deleted file mode 100644
index d2f372732d..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimetoday.cs
+++ /dev/null
@@ -1,95 +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.
-using System;
-using System.Collections.Generic;
-using System.Threading;
-
-
-/// <summary>
-/// System.DateTime.Today
-/// </summary>
-public class DateTimeToday
-{
-    public static int Main(string[] args)
-    {
-        DateTimeToday today = new DateTimeToday();
-        TestLibrary.TestFramework.BeginTestCase("Testing System.DateTime.Today property...");
-
-        if (today.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-
-        return retVal; 
-    }
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Verify the value of hour minute and second in Today property...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new System.Globalization.CultureInfo("");
-            DateTime today = DateTime.Today;
-
-            if (today.Hour != 0 && today.Minute != 0 && today.Second != 0)
-            {
-                TestLibrary.TestFramework.LogError("001","The initial value of today is wrong!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002","Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Verify the type of today property is System.DateTime...");
-
-        try
-        {
-            DateTime today = DateTime.Today;
-            Type typeOfToday = today.GetType();
-
-            if (typeOfToday.ToString() != "System.DateTime")
-            {
-                TestLibrary.TestFramework.LogError("003","The type of Today property is wrong!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004","Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimetofiletime.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimetofiletime.cs
deleted file mode 100644
index 36653c9b71..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimetofiletime.cs
+++ /dev/null
@@ -1,126 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// System.DateTime.ToFileTime()
-/// </summary>
-public class DateTimeToFileTime
-{
-    public static int Main()
-    {
-        DateTimeToFileTime dttft = new DateTimeToFileTime();
-        TestLibrary.TestFramework.BeginTestCase("DataTimeToFileTime");
-        if (dttft.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[PosTest]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        TestLibrary.TestFramework.LogInformation("[NegTest]");
-        retVal = NegTest1() && retVal;
-        retVal = NegTest2() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1: The current dateTime equals 1601/1/1");
-        try
-        {
-            DateTime date1 = new DateTime(1601, 1, 1).ToLocalTime().ToUniversalTime();
-            long result = date1.ToFileTime();
-            if (result != 0)
-            {
-                TestLibrary.TestFramework.LogError("001", "The ActualResult is not the ExpectResult");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest2: The current dateTime lager 1601/1/1");
-        try
-        {
-            DateTime date1 = new DateTime(1999, 1, 1).ToLocalTime().ToUniversalTime();
-            DateTime date2 = new DateTime(1601, 1, 1).ToLocalTime().ToUniversalTime();
-            TimeSpan timeSpan = date1.Subtract(date2);
-            long result = date1.ToFileTime();
-            long expect = timeSpan.Days * 864000000000; //8640000000 = 24*3600*1000*1000*1000/100
-            if (result != expect)
-            {
-                TestLibrary.TestFramework.LogError("003", "The ActualResult is not the ExpectResult");
-                retVal = false;
-            }                      
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-    #region NegativeTest
-    public bool NegTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("NegTest1: The current dateTime less than 1601/1/1 1");
-        try
-        {
-            DateTime date1 = DateTime.MinValue.ToLocalTime().ToUniversalTime();
-            long result = date1.ToFileTime();
-            retVal = false;
-            TestLibrary.TestFramework.LogError("N001", "The current dateTime is less than 1601/1/1 but not throw exception");
-        }
-        catch (ArgumentOutOfRangeException) { }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("N002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool NegTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("NegTest2: The current dateTime less than 1601/1/1 2");
-        try
-        {
-            DateTime date1 = new DateTime(1600, 1, 1).ToLocalTime().ToUniversalTime();
-            long result = date1.ToFileTime();
-            retVal = false;
-            TestLibrary.TestFramework.LogError("N003", "The current dateTime is less than 1601/1/1 but not throw exception");
-        }
-        catch (ArgumentOutOfRangeException) { }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("N004", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimetofiletimeutc.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimetofiletimeutc.cs
deleted file mode 100644
index c3d3321636..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimetofiletimeutc.cs
+++ /dev/null
@@ -1,126 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// System.DateTime.ToFileTimeUtc()
-/// </summary>
-public class DateTimeToFileTimeUtc
-{
-    public static int Main()
-    {
-        DateTimeToFileTimeUtc dttftu = new DateTimeToFileTimeUtc();
-        TestLibrary.TestFramework.BeginTestCase("DataTimeToFileTimeUtc");
-        if (dttftu.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[PosTest]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        TestLibrary.TestFramework.LogInformation("[NegTest]");
-        retVal = NegTest1() && retVal;
-        retVal = NegTest2() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1: The current dateTime equals 1601/1/1");
-        try
-        {
-            DateTime date1 = new DateTime(1601, 1, 1).ToLocalTime().ToUniversalTime();
-            long result = date1.ToFileTime();
-            if (result != 0)
-            {
-                TestLibrary.TestFramework.LogError("001", "The ActualResult is not the ExpectResult");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest2: The current dateTime lager 1601/1/1");
-        try
-        {
-            DateTime date1 = new DateTime(1999, 1, 1).ToLocalTime().ToUniversalTime();
-            DateTime date2 = new DateTime(1601, 1, 1).ToLocalTime().ToUniversalTime();
-            TimeSpan timeSpan = date1.Subtract(date2);
-            long result = date1.ToFileTime();
-            long expect = timeSpan.Days * 864000000000; //8640000000 = 24*3600*1000*1000*1000/100
-            if (result != expect)
-            {
-                TestLibrary.TestFramework.LogError("003", "The ActualResult is not the ExpectResult");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-    #region NegativeTest
-    public bool NegTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("NegTest1: The current dateTime less than 1601/1/1 1");
-        try
-        {
-            DateTime date1 = DateTime.MinValue.ToLocalTime().ToUniversalTime();
-            long result = date1.ToFileTime();
-            retVal = false;
-            TestLibrary.TestFramework.LogError("N001", "The current dateTime is less than 1601/1/1 but not throw exception");
-        }
-        catch (ArgumentOutOfRangeException) { }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("N002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool NegTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("NegTest2: The current dateTime less than 1601/1/1 2");
-        try
-        {
-            DateTime date1 = new DateTime(1600, 1, 1).ToLocalTime().ToUniversalTime();
-            long result = date1.ToFileTime();
-            retVal = false;
-            TestLibrary.TestFramework.LogError("N003", "The current dateTime is less than 1601/1/1 but not throw exception");
-        }
-        catch (ArgumentOutOfRangeException) { }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("N004", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimetolocaltime.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimetolocaltime.cs
deleted file mode 100644
index e79453f571..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimetolocaltime.cs
+++ /dev/null
@@ -1,66 +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.
-using System;
-using System.Collections;
-
-/// <summary>
-/// System.DateTime.ToLocalTime
-/// </summary>
-public class DateTimeToLocalTime
-{
-    public static int Main(string[] args)
-    {
-        DateTimeToLocalTime toLocalTime = new DateTimeToLocalTime();
-        TestLibrary.TestFramework.BeginTestCase("Testing DateTime.ToLocalTime...");
-
-        if (toLocalTime.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-
-        return retVal;
-    }
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Verify convvert DateTime to utc then convert back is equal to original...");
-
-        try
-        {
-            DateTime myTime = DateTime.Now;
-            DateTime myUtcTime = myTime.ToUniversalTime();
-            DateTime utcToLocal = myUtcTime.ToLocalTime();
-            
-            if (myTime != utcToLocal)
-            {
-                TestLibrary.TestFramework.LogError("001","The DateTime change back to local should be equal to original!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002","Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimetostring1.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimetostring1.cs
deleted file mode 100644
index 3fd204fe73..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimetostring1.cs
+++ /dev/null
@@ -1,122 +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.
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Threading;
-
-
-/// <summary>
-/// System.DateTime.ToString
-/// </summary>
-public class DateTimeToString1
-{
-    public static int Main(string[] args)
-    {
-        DateTimeToString1 toString = new DateTimeToString1();
-        TestLibrary.TestFramework.BeginTestCase("Testing System.DateTime.ToString method...");
-
-        if (toString.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-
-        return retVal;
-    }
-
-    public bool PosTest1() 
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Testing DateTime.ToString() when DateTime instance is created by ctor(int year,int month,int day)...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(1978,08,29);
-            string dateString = myDateTime.ToString();
-            char[] splitors = {'/',' ',':'};
-            string[] parts = dateString.Split(splitors);
-
-            if (parts.Length != 6)
-            {
-                TestLibrary.TestFramework.LogError("001", "The component parts are not correct!");
-                retVal = false;
-            }
-            else
-            {
-                if (parts[0] != "1978" && parts[1] != "08" && parts[2] != "29" && parts[3] != "00"
-                    && parts[4] != "00" && parts[5] != "00")
-                {
-                    TestLibrary.TestFramework.LogError("002","The content is not correct!");
-                    retVal = false;
-                }
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002","Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    /// <summary>
-    /// new added scenario
-    /// </summary>
-    /// <returns></returns>
-    public bool PosTest2() 
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Testing DateTime.ToString() when DateTime instance is created by ctor(int year,int month,int day,int hour,int minute,int second)...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(1978,08,29,01,10,10);
-            string dateString = myDateTime.ToString();
-            char[] splitors = { '/', ' ', ':' };
-            string[] parts = dateString.Split(splitors);
-
-            if (parts.Length != 6)
-            {
-                TestLibrary.TestFramework.LogError("001", "The component parts are not correct!");
-                retVal = false;
-            }
-            else
-            {
-                if (parts[0] != "1978" && parts[1] != "08" && parts[2] != "29" && parts[3] != "01"
-                    && parts[4] != "10" && parts[5] != "10")
-                {
-                    TestLibrary.TestFramework.LogError("002", "The content is not correct!");
-                    retVal = false;
-                }
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimetostring2.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimetostring2.cs
deleted file mode 100644
index d4cd95a296..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimetostring2.cs
+++ /dev/null
@@ -1,118 +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.
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Threading;
-
-
-/// <summary>
-/// System.DateTime.ToString(System.IFormatProvider)
-/// </summary>
-public class DateTimeToString2
-{
-    public static int Main(string[] args)
-    {
-        DateTimeToString2 toString = new DateTimeToString2();
-        TestLibrary.TestFramework.BeginTestCase("Testing System.DateTime.ToString(System.IFormatProvider)...");
-
-        if (toString.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-
-        return retVal;
-    }
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Testing DateTime.ToString(System.IFormatProvider) when DateTimeFormatInfo is CurrentInfo...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(1978, 08, 29);
-            string dateString = myDateTime.ToString(DateTimeFormatInfo.CurrentInfo);
-            char[] splitors = { '/', ' ', ':' };
-            string[] parts = dateString.Split(splitors);
-
-            if (parts.Length != 6)
-            {
-                TestLibrary.TestFramework.LogError("001", "The component parts are not correct!");
-                retVal = false;
-            }
-            else
-            {
-                if (parts[0] != "1978" && parts[1] != "08" && parts[2] != "29" && parts[3] != "00"
-                    && parts[4] != "00" && parts[5] != "00")
-                {
-                    TestLibrary.TestFramework.LogError("002", "The content is not correct!");
-                    retVal = false;
-                }
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Testing DateTime.ToString(System.IFormatProvider) when when DateTimeFormatInfo is InvariantInfo...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            DateTime myDateTime = new DateTime(1978, 08, 29, 01, 10, 10);
-            string dateString = myDateTime.ToString(DateTimeFormatInfo.InvariantInfo);
-            char[] splitors = { '/', ' ', ':' };
-            string[] parts = dateString.Split(splitors);
-
-            if (parts.Length != 6)
-            {
-                TestLibrary.TestFramework.LogError("001", "The component parts are not correct!");
-                retVal = false;
-            }
-            else
-            {
-                if (parts[0] != "1978" && parts[1] != "08" && parts[2] != "29" && parts[3] != "01"
-                    && parts[4] != "10" && parts[5] != "10")
-                {
-                    TestLibrary.TestFramework.LogError("002", "The content is not correct!");
-                    retVal = false;
-                }
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimetostring3.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimetostring3.cs
deleted file mode 100644
index 79c8a31683..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimetostring3.cs
+++ /dev/null
@@ -1,588 +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.
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Threading;
-
-/// <summary>
-/// System.DateTime.ToString(System.String)
-/// </summary>
-public class DateTimeToString3
-{
-    public static int Main(string[] args)
-    {
-        DateTimeToString3 myDateTime = new DateTimeToString3();
-        TestLibrary.TestFramework.BeginTestCase("Testing System.DateTime.ToString(System.String)...");
-
-        if (myDateTime.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-        retVal = PosTest5() && retVal;
-        retVal = PosTest6() && retVal;
-        retVal = PosTest7() && retVal;
-        retVal = PosTest8() && retVal;
-        retVal = PosTest9() && retVal;
-        retVal = PosTest10() && retVal;
-        retVal = PosTest11() && retVal;
-        retVal = PosTest12() && retVal;
-        retVal = PosTest13() && retVal;
-        retVal = PosTest14() && retVal;
-        retVal = PosTest15() && retVal;
-        retVal = PosTest16() && retVal;
-        retVal = PosTest17() && retVal;
-
-        return retVal;
-    }
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Testing DateTime.ToString(System.String) using format as M/d/yyyy hh:mm:ss tt...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            string format = @"M/d/yyyy hh:mm:ss tt";
-            DateTime myDateTime = new DateTime(1978, 08, 29);
-            string dateString = myDateTime.ToString(format);
-            char[] splitors = { '/', ' ', ':' };
-            string[] parts = dateString.Split(splitors);
-
-            if (parts.Length != 7)
-            {
-                TestLibrary.TestFramework.LogError("001", "The component parts are not correct!");
-                retVal = false;
-            }
-            else
-            {
-                if (parts[0] != "1978" && parts[1] != "08" && parts[2] != "29" && parts[3] != "00"
-                    && parts[4] != "00" && parts[5] != "00" && parts[6]!="AM")
-                {
-                    TestLibrary.TestFramework.LogError("002", "The content is not correct!");
-                    retVal = false;
-                }
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("003", "Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Testing DateTime.ToString(System.String) using format as M-d-yyyy hh:mm:ss tt...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            string format = @"M-d-yyyy hh:mm:ss tt";
-            DateTime myDateTime = new DateTime(1978, 08, 29);
-            string dateString = myDateTime.ToString(format);
-            char[] splitors = { '-', ' ', ':' };
-            string[] parts = dateString.Split(splitors);
-
-            if (parts.Length != 7)
-            {
-                TestLibrary.TestFramework.LogError("004", "The component parts are not correct!");
-                retVal = false;
-            }
-            else
-            {
-                if (parts[0] != "1978" && parts[1] != "08" && parts[2] != "29" && parts[3] != "00"
-                    && parts[4] != "00" && parts[5] != "00" && parts[6]!="AM")
-                {
-                    TestLibrary.TestFramework.LogError("005", "The content is not correct!");
-                    retVal = false;
-                }
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3() 
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Testing DateTime.ToString(System.String) using format as M-d-yyyy hh:mm:ss...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            string format = @"M-d-yyyy hh:mm:ss";
-            DateTime myDateTime = new DateTime(1978, 08, 29);
-            string dateString = myDateTime.ToString(format);
-            char[] splitors = { '-', ' ', ':' };
-            string[] parts = dateString.Split(splitors);
-
-            if (parts.Length != 6)
-            {
-                TestLibrary.TestFramework.LogError("007", "The component parts are not correct!");
-                retVal = false;
-            }
-            else
-            {
-                if (parts[0] != "1978" && parts[1] != "08" && parts[2] != "29" && parts[3] != "00"
-                    && parts[4] != "00" && parts[5] != "00")
-                {
-                    TestLibrary.TestFramework.LogError("008", "The content is not correct!");
-                    retVal = false;
-                }
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("009", "Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest4() 
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Testing DateTime.ToString(System.String) using format as d...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            string format = @"d";
-            DateTime myDateTime = new DateTime(1978, 08, 29);
-            string dateString = myDateTime.ToString(format);
-            char[] splitors = { '/'};
-            string[] parts = dateString.Split(splitors);
-
-            if (parts.Length != 3)
-            {
-                TestLibrary.TestFramework.LogError("010", "The component parts are not correct!");
-                retVal = false;
-            }
-            else
-            {
-                if (parts[0] != "29" && parts[1] != "08" && parts[2] != "1978")
-                {
-                    TestLibrary.TestFramework.LogError("011", "The content is not correct!");
-                    retVal = false;
-                }
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("012", "Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest5() 
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Testing DateTime.ToString(System.String) using format as D...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            string format = @"D";
-            DateTime myDateTime = DateTime.Now;
-            string dateString = myDateTime.ToString(format);
-            char[] splitors = { ' ' };
-            string[] parts = dateString.Split(splitors);
-
-            if (parts.Length != 4)
-            {
-                TestLibrary.TestFramework.LogError("013", "The component parts are not correct!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("014", "Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest6()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Testing DateTime.ToString(System.String) using format as f...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            string format = @"f";
-            DateTime myDateTime = DateTime.Now;
-            string dateString = myDateTime.ToString(format);
-            char[] splitors = { ' ',':' };
-            string[] parts = dateString.Split(splitors);
-
-            if (parts.Length != 6)
-            {
-                TestLibrary.TestFramework.LogError("015", "The component parts are not correct!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("016", "Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest7() 
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Testing DateTime.ToString(System.String) using format as F...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            string format = @"F";
-            DateTime myDateTime = DateTime.Now;
-            string dateString = myDateTime.ToString(format);
-            char[] splitors = { ' ', ':' };
-            string[] parts = dateString.Split(splitors);
-
-            if (parts.Length != 7)
-            {
-                TestLibrary.TestFramework.LogError("017", "The component parts are not correct!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("018", "Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest8() 
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Testing DateTime.ToString(System.String) using format as g...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            string format = @"g";
-            DateTime myDateTime = DateTime.Now;
-            string dateString = myDateTime.ToString(format);
-            char[] splitors = { '/',' ', ':' };
-            string[] parts = dateString.Split(splitors);
-
-            if (parts.Length != 5)
-            {
-                TestLibrary.TestFramework.LogError("019", "The component parts are not correct!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("020", "Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest9() 
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Testing DateTime.ToString(System.String) using format as G...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            string format = @"G";
-            DateTime myDateTime = DateTime.Now;
-            string dateString = myDateTime.ToString(format);
-            char[] splitors = { '/', ' ', ':' };
-            string[] parts = dateString.Split(splitors);
-
-            if (parts.Length != 6)
-            {
-                TestLibrary.TestFramework.LogError("021", "The component parts are not correct!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("022", "Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest10() 
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Testing DateTime.ToString(System.String) using format as m...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            string format = @"m";
-            DateTime myDateTime = DateTime.Now;
-            string dateString = myDateTime.ToString(format);
-            char[] splitors = {' '};
-            string[] parts = dateString.Split(splitors);
-
-            if (parts.Length != 2)
-            {
-                TestLibrary.TestFramework.LogError("023", "The component parts are not correct!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("024", "Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest11() 
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Testing DateTime.ToString(System.String) using format as r...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            string format = @"r";
-            DateTime myDateTime = DateTime.Now;
-            string dateString = myDateTime.ToString(format);
-            char[] splitors = { ',',' ',':' };
-            string[] parts = dateString.Split(splitors);
-
-            if (parts.Length != 9)
-            {
-                TestLibrary.TestFramework.LogError("025", "The component parts are not correct!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("026", "Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest12()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Testing DateTime.ToString(System.String) using format as s...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            string format = @"s";
-            DateTime myDateTime = DateTime.Now;
-            string dateString = myDateTime.ToString(format);
-            char[] splitors = { '-', 'T', ':' };
-            string[] parts = dateString.Split(splitors);
-
-            if (parts.Length != 6)
-            {
-                TestLibrary.TestFramework.LogError("027", "The component parts are not correct!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("028", "Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest13()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Testing DateTime.ToString(System.String) using format as t...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            string format = @"t";
-            DateTime myDateTime = DateTime.Now;
-            string dateString = myDateTime.ToString(format);
-            char[] splitors = {':' };
-            string[] parts = dateString.Split(splitors);
-
-            if (parts.Length != 2)
-            {
-                TestLibrary.TestFramework.LogError("029", "The component parts are not correct!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("030", "Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest14()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Testing DateTime.ToString(System.String) using format as T...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            string format = @"T";
-            DateTime myDateTime = DateTime.Now;
-            string dateString = myDateTime.ToString(format);
-            char[] splitors = { ':' };
-            string[] parts = dateString.Split(splitors);
-
-            if (parts.Length != 3)
-            {
-                TestLibrary.TestFramework.LogError("031", "The component parts are not correct!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("032", "Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest15() 
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Testing DateTime.ToString(System.String) using format as u...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            string format = @"u";
-            DateTime myDateTime = DateTime.Now;
-            string dateString = myDateTime.ToString(format);
-            char[] splitors = {'-',' ', ':' };
-            string[] parts = dateString.Split(splitors);
-
-            if (parts.Length != 6)
-            {
-                TestLibrary.TestFramework.LogError("033", "The component parts are not correct!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("034", "Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest16() 
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Testing DateTime.ToString(System.String) using format as U...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            string format = @"U";
-            DateTime myDateTime = DateTime.Now;
-            string dateString = myDateTime.ToString(format);
-            char[] splitors = {' ', ':' };
-            string[] parts = dateString.Split(splitors);
-
-            if (parts.Length != 7)
-            {
-                TestLibrary.TestFramework.LogError("035", "The component parts are not correct!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("036", "Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest17() 
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("Testing DateTime.ToString(System.String) using format as y...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new CultureInfo("");
-            string format = @"y";
-            DateTime myDateTime = DateTime.Now;
-            string dateString = myDateTime.ToString(format);
-            char[] splitors = { ' '};
-            string[] parts = dateString.Split(splitors);
-
-            if (parts.Length != 2)
-            {
-                TestLibrary.TestFramework.LogError("037", "The component parts are not correct!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("038", "Unexpected exception occurs: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/datetimeutcnow.cs b/tests/src/CoreMangLib/cti/system/datetime/datetimeutcnow.cs
deleted file mode 100644
index 668e71f6e0..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetime/datetimeutcnow.cs
+++ /dev/null
@@ -1,93 +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.
-using System;
-using System.Collections;
-using System.Threading;
-
-public class DateTimeUtcNow
-{
-    public static int Main(string[] args)
-    {
-        DateTimeUtcNow utcNow = new DateTimeUtcNow();
-        TestLibrary.TestFramework.BeginTestCase("Testing System.DateTime.UtcNow property...");
-
-        if (utcNow.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-
-        return retVal; 
-    }
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginTestCase("Verify DateTime.UtcNow is Universal kind...");
-
-        try
-        {
-            TestLibrary.Utilities.CurrentCulture = new System.Globalization.CultureInfo("");
-            DateTime myDateTime = DateTime.UtcNow;
-            Type typeOfNow = myDateTime.GetType();
-            DateTime toUniversal = myDateTime.ToUniversalTime();
-
-            if (myDateTime != toUniversal)
-            {
-                TestLibrary.TestFramework.LogError("001", "The kind of UtcNow property is not local!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginTestCase("Verify the type of UtcNow property is DateTime...");
-
-        try
-        {
-            DateTime myDateTime = DateTime.UtcNow;
-            Type typeOfNow = myDateTime.GetType();
-
-            if (typeOfNow.ToString() != "System.DateTime")
-            {
-                TestLibrary.TestFramework.LogError("003", "The type of Now property is wrong!");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpected exception occurs: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetimekind/DateTimeKindLocal.csproj b/tests/src/CoreMangLib/cti/system/datetimekind/DateTimeKindLocal.csproj
deleted file mode 100644
index 8887078638..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetimekind/DateTimeKindLocal.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimekindlocal.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetimekind/DateTimeKindUnspecified.csproj b/tests/src/CoreMangLib/cti/system/datetimekind/DateTimeKindUnspecified.csproj
deleted file mode 100644
index 68b0c2373c..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetimekind/DateTimeKindUnspecified.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimekindunspecified.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetimekind/DateTimeKindUtc.csproj b/tests/src/CoreMangLib/cti/system/datetimekind/DateTimeKindUtc.csproj
deleted file mode 100644
index c4ff4dc298..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetimekind/DateTimeKindUtc.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimekindutc.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetimekind/datetimekindlocal.cs b/tests/src/CoreMangLib/cti/system/datetimekind/datetimekindlocal.cs
deleted file mode 100644
index 5970677acb..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetimekind/datetimekindlocal.cs
+++ /dev/null
@@ -1,69 +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.
-using System;
-
-///<summary>
-///System.DateTimeKind.Local
-///</summary>
-
-public class DateTimeKindLocal
-{
-
-    public static int Main()
-    {
-        DateTimeKindLocal testObj = new DateTimeKindLocal();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.DateTimeKind.Local");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-       return retVal;
-    }
-
-
-    #region Test Logic
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        int expectedValue = 2;
-        int actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get DateTimeKind.Local");
-        try
-        {
-            actualValue = (int)DateTimeKind.Local;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetimekind/datetimekindunspecified.cs b/tests/src/CoreMangLib/cti/system/datetimekind/datetimekindunspecified.cs
deleted file mode 100644
index 9a278fbfda..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetimekind/datetimekindunspecified.cs
+++ /dev/null
@@ -1,69 +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.
-using System;
-
-///<summary>
-///System.DateTimeKind.Unspecified
-///</summary>
-
-public class DateTimeKindUnspecified
-{
-
-    public static int Main()
-    {
-        DateTimeKindUnspecified testObj = new DateTimeKindUnspecified();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.DateTimeKind.Unspecified");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        int expectedValue = 0;
-        int actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get DateTimeKind.Unspecified");
-        try
-        {
-            actualValue = (int)DateTimeKind.Unspecified;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/datetimekind/datetimekindutc.cs b/tests/src/CoreMangLib/cti/system/datetimekind/datetimekindutc.cs
deleted file mode 100644
index 2c19aeeb00..0000000000
--- a/tests/src/CoreMangLib/cti/system/datetimekind/datetimekindutc.cs
+++ /dev/null
@@ -1,69 +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.
-using System;
-
-///<summary>
-///System.DateTimeKind.Utc
-///</summary>
-
-public class DateTimeKindUtc
-{
-
-    public static int Main()
-    {
-        DateTimeKindUtc testObj = new DateTimeKindUtc();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.DateTimeKind.Utc");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        int expectedValue = 1;
-        int actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get DateTimeKind.Utc");
-        try
-        {
-            actualValue = (int)DateTimeKind.Utc;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") != ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/calendarweekrule/CalendarWeekRuleFirstDay.csproj b/tests/src/CoreMangLib/cti/system/globalization/calendarweekrule/CalendarWeekRuleFirstDay.csproj
deleted file mode 100644
index a225d5eb2b..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/calendarweekrule/CalendarWeekRuleFirstDay.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="calendarweekrulefirstday.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/calendarweekrule/CalendarWeekRuleFirstFourDayWeek.csproj b/tests/src/CoreMangLib/cti/system/globalization/calendarweekrule/CalendarWeekRuleFirstFourDayWeek.csproj
deleted file mode 100644
index 99a9c8edda..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/calendarweekrule/CalendarWeekRuleFirstFourDayWeek.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="calendarweekrulefirstfourdayweek.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/calendarweekrule/CalendarWeekRuleFirstFullWeek.csproj b/tests/src/CoreMangLib/cti/system/globalization/calendarweekrule/CalendarWeekRuleFirstFullWeek.csproj
deleted file mode 100644
index 3ba9a7f199..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/calendarweekrule/CalendarWeekRuleFirstFullWeek.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="calendarweekrulefirstfullweek.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/calendarweekrule/calendarweekrulefirstday.cs b/tests/src/CoreMangLib/cti/system/globalization/calendarweekrule/calendarweekrulefirstday.cs
deleted file mode 100644
index fa911175e1..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/calendarweekrule/calendarweekrulefirstday.cs
+++ /dev/null
@@ -1,70 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.CalendarWeekRule.FirstDay
-///</summary>
-
-public class CalendarWeekRuleFirstDay
-{
-
-    public static int Main()
-    {
-        CalendarWeekRuleFirstDay testObj = new CalendarWeekRuleFirstDay();
-        TestLibrary.TestFramework.BeginTestCase("for the System.CalendarWeekRule.FirstDay");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        int expectedValue = 0;
-        int actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get CalendarWeekRule.FirstDay");
-        try
-        {
-            actualValue = (int)CalendarWeekRule.FirstDay;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/calendarweekrule/calendarweekrulefirstfourdayweek.cs b/tests/src/CoreMangLib/cti/system/globalization/calendarweekrule/calendarweekrulefirstfourdayweek.cs
deleted file mode 100644
index a8c3975dcf..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/calendarweekrule/calendarweekrulefirstfourdayweek.cs
+++ /dev/null
@@ -1,70 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.CalendarWeekRule.FirstFourDayWeek
-///</summary>
-
-public class CalendarWeekRuleFirstFourDayWeek
-{
-
-    public static int Main()
-    {
-        CalendarWeekRuleFirstFourDayWeek testObj = new CalendarWeekRuleFirstFourDayWeek();
-        TestLibrary.TestFramework.BeginTestCase("for the System.CalendarWeekRule.FirstDay");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        int expectedValue = 2;
-        int actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get CalendarWeekRule.FirstFourDayWeek");
-        try
-        {
-            actualValue = (int)CalendarWeekRule.FirstFourDayWeek;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/calendarweekrule/calendarweekrulefirstfullweek.cs b/tests/src/CoreMangLib/cti/system/globalization/calendarweekrule/calendarweekrulefirstfullweek.cs
deleted file mode 100644
index 69258ffc1c..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/calendarweekrule/calendarweekrulefirstfullweek.cs
+++ /dev/null
@@ -1,70 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.CalendarWeekRule.FirstFullWeek
-///</summary>
-
-public class CalendarWeekRuleFirstFullWeek
-{
-
-    public static int Main()
-    {
-        CalendarWeekRuleFirstFullWeek testObj = new CalendarWeekRuleFirstFullWeek();
-        TestLibrary.TestFramework.BeginTestCase("for the System.CalendarWeekRule.FirstDay");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        int expectedValue = 1;
-        int actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get CalendarWeekRule.FirstFullWeek");
-        try
-        {
-            actualValue = (int)CalendarWeekRule.FirstFullWeek;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/CharUnicodeInfoGetNumericValue1.csproj b/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/CharUnicodeInfoGetNumericValue1.csproj
deleted file mode 100644
index 7ee428d34e..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/CharUnicodeInfoGetNumericValue1.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="charunicodeinfogetnumericvalue1.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/CharUnicodeInfoGetNumericValue2.csproj b/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/CharUnicodeInfoGetNumericValue2.csproj
deleted file mode 100644
index 61274599c8..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/CharUnicodeInfoGetNumericValue2.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="charunicodeinfogetnumericvalue2.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/CharUnicodeInfoGetUnicodeCategory1.csproj b/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/CharUnicodeInfoGetUnicodeCategory1.csproj
deleted file mode 100644
index b9b9088b6b..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/CharUnicodeInfoGetUnicodeCategory1.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="charunicodeinfogetunicodecategory1.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/CharUnicodeInfoGetUnicodeCategory2.csproj b/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/CharUnicodeInfoGetUnicodeCategory2.csproj
deleted file mode 100644
index 716b0f9ccf..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/CharUnicodeInfoGetUnicodeCategory2.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="charunicodeinfogetunicodecategory2.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/charunicodeinfogetnumericvalue1.cs b/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/charunicodeinfogetnumericvalue1.cs
deleted file mode 100644
index 01926ba435..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/charunicodeinfogetnumericvalue1.cs
+++ /dev/null
@@ -1,226 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.CharUnicodeInfo.GetNumericValue(Char)
-///</summary>
-
-public class CharUnicodeInfoGetNumericValue
-{
-
-    public static int Main()
-    {
-        CharUnicodeInfoGetNumericValue testObj = new CharUnicodeInfoGetNumericValue();
-        TestLibrary.TestFramework.BeginTestCase("for method of System.Globalization.CharUnicodeInfo.GetNumericValue");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-        retVal = PosTest5() && retVal;
-        retVal = PosTest6() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        Char ch = '\0';
-
-        Double expectedValue = -1;
-
-        Double actualValue;
-
-        TestLibrary.TestFramework.BeginScenario(@"PosTest1:Test the method with '\0'");
-        try
-        {
-            actualValue = CharUnicodeInfo.GetNumericValue(ch);
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        Char ch = '0';
-
-        Double expectedValue = 0;
-
-        Double actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Test the method with char '0'");
-        try
-        {
-            actualValue = CharUnicodeInfo.GetNumericValue(ch);
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("003", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        Char ch = '9';
-
-        Double expectedValue = 9;
-
-        Double actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Test the method with char '9'");
-        try
-        {
-            actualValue = CharUnicodeInfo.GetNumericValue(ch);
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("005", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    public bool PosTest4()
-    {
-        bool retVal = true;
-
-        Char ch = '\u3289';
-
-        Double expectedValue = 10;
-
-        Double actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Test the method with char '\\u3289'");
-        try
-        {
-            actualValue = CharUnicodeInfo.GetNumericValue(ch);
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("007", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("008", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    public bool PosTest5()
-    {
-        bool retVal = true;
-
-        Char ch = 'a';
-
-        Double expectedValue = -1;
-
-        Double actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Test the method with char 'a'");
-        try
-        {
-            actualValue = CharUnicodeInfo.GetNumericValue(ch);
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("009", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("010", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    public bool PosTest6()
-    {
-        bool retVal = true;
-
-        Char ch = 'Z';
-
-        Double expectedValue = -1;
-
-        Double actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Test the method with char 'Z'");
-        try
-        {
-            actualValue = CharUnicodeInfo.GetNumericValue(ch);
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("011", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("012", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/charunicodeinfogetnumericvalue2.cs b/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/charunicodeinfogetnumericvalue2.cs
deleted file mode 100644
index 2e7403e65a..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/charunicodeinfogetnumericvalue2.cs
+++ /dev/null
@@ -1,310 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.CharUnicodeInfo.GetNumericValue(System.String,System.Int32)
-///</summary>
-
-public class CharUnicodeInfoGetNumericValue
-{
-
-    public static int Main()
-    {
-        CharUnicodeInfoGetNumericValue testObj = new CharUnicodeInfoGetNumericValue();
-        TestLibrary.TestFramework.BeginTestCase("for method of System.Globalization.CharUnicodeInfo.GetNumericValue");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-        retVal = PosTest5() && retVal;
-        retVal = PosTest6() && retVal;
-        retVal = NegTest1() && retVal;
-        retVal = NegTest2() && retVal;
-        retVal = NegTest3() && retVal;
-
-        return retVal;
-    }
-
-
-    #region Positive Test Logic
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        String str = "\009aZ\u0f33";
-
-        Double expectedValue = -1;
-
-        Double actualValue;
-
-        TestLibrary.TestFramework.BeginScenario(@"PosTest1:Test the method with '\0'");
-        try
-        {
-            actualValue = CharUnicodeInfo.GetNumericValue(str,0);
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        String str = "\009aZ\u0f33";
-
-        Double expectedValue = 0;
-
-        Double actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Test the method with char '0'");
-        try
-        {
-            actualValue = CharUnicodeInfo.GetNumericValue(str,1);
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("003", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        String str = "\009aZ\u0f33";
-
-        Double expectedValue = 9;
-
-        Double actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Test the method with char '9'");
-        try
-        {
-            actualValue = CharUnicodeInfo.GetNumericValue(str,2);
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("005", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    public bool PosTest4()
-    {
-        bool retVal = true;
-
-        String str = "\009aZ\u0f33";
-
-        Double expectedValue = -1;
-
-        Double actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Test the method with char 'a'");
-        try
-        {
-            actualValue = CharUnicodeInfo.GetNumericValue(str,3);
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("007", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("008", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    public bool PosTest5()
-    {
-        bool retVal = true;
-
-        String str = "\009aZ\u0f33";
-
-        Double expectedValue = -1;
-
-        Double actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Test the method with char 'Z'");
-        try
-        {
-            actualValue = CharUnicodeInfo.GetNumericValue(str,4);
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("009", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("010", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    public bool PosTest6()
-    {
-        bool retVal = true;
-
-        String str = "\009aZ\u0f33";
-
-        Double expectedValue = -0.5;
-
-        Double actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Test the method with char '\\u0f33'");
-        try
-        {
-            actualValue = CharUnicodeInfo.GetNumericValue(str,5);
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("011", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("012", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    #endregion
-
-    #region Negative Test Logic
-
-    public bool NegTest1()
-    {
-        bool retVal = true;
-
-        String str = null;
-        Double actureValue = 0;
-        
-        TestLibrary.TestFramework.BeginScenario("NegTest1:Invoke the method with null string");
-        try
-        {
-            actureValue = CharUnicodeInfo.GetNumericValue(str, 0);
-            TestLibrary.TestFramework.LogError("013", "No ArgumentNullExcepthion thrown out expected.");
-            retVal = false;
-        }
-        catch (ArgumentNullException)
-        {
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("014", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool NegTest2()
-    {
-        bool retVal = true;
-
-        String str = TestLibrary.Generator.GetString(-55, false,1,5);
-        Double actureValue = 0;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1:Invoke the method with index out of left range");
-        try
-        {
-            actureValue = CharUnicodeInfo.GetNumericValue(str, -1);
-            TestLibrary.TestFramework.LogError("014", "No ArgumentNullExcepthion thrown out expected.");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("015", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool NegTest3()
-    {
-        bool retVal = true;
-
-        String str = TestLibrary.Generator.GetString(-55, false, 1, 5);
-        Double actureValue = 0;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1:Invoke the method with index out of right range");
-        try
-        {
-            actureValue = CharUnicodeInfo.GetNumericValue(str, 5);
-            TestLibrary.TestFramework.LogError("014", "No ArgumentNullExcepthion thrown out expected.");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("015", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/charunicodeinfogetunicodecategory1.cs b/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/charunicodeinfogetunicodecategory1.cs
deleted file mode 100644
index ee79c21e2a..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/charunicodeinfogetunicodecategory1.cs
+++ /dev/null
@@ -1,944 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.CharUnicodeInfo.GetUnicodeCategory(System.Char)
-///</summary>
-
-public class CharUnicodeInfoGetUnicodeCategory
-{
-
-    public static int Main()
-    {
-        CharUnicodeInfoGetUnicodeCategory testObj = new CharUnicodeInfoGetUnicodeCategory();
-        TestLibrary.TestFramework.BeginTestCase("for method of System.Globalization.CharUnicodeInfo.GetUnicodeCategory");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-        retVal = PosTest5() && retVal;
-        retVal = PosTest6() && retVal;
-        retVal = PosTest7() && retVal;
-        retVal = PosTest8() && retVal;
-        retVal = PosTest9() && retVal;
-        retVal = PosTest10() && retVal;
-        retVal = PosTest11() && retVal;
-        retVal = PosTest12() && retVal;
-        retVal = PosTest13() && retVal;
-        retVal = PosTest14() && retVal;
-        retVal = PosTest15() && retVal;
-        retVal = PosTest16() && retVal;
-        retVal = PosTest17() && retVal;
-        retVal = PosTest18() && retVal;
-        retVal = PosTest19() && retVal;
-        retVal = PosTest20() && retVal;
-        retVal = PosTest21() && retVal;
-        retVal = PosTest22() && retVal;
-        retVal = PosTest23() && retVal;
-        retVal = PosTest24() && retVal;
-        retVal = PosTest25() && retVal;
-        retVal = PosTest26() && retVal;
-        retVal = PosTest27() && retVal;
-        retVal = PosTest28() && retVal;
-        retVal = PosTest29() && retVal;
-        retVal = PosTest30() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        Char ch = 'A';
-
-        int expectedValue = (int)UnicodeCategory.UppercaseLetter;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Test the method with upper letter");
-
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ") when char is '" + ch + "'" );
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        Char ch = 'a';
-
-        int expectedValue = (int)UnicodeCategory.LowercaseLetter;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2:Test the method with low case char");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("003", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        Char ch = '\u1fa8';   //this char is a TitlecaseLetter char
-
-        int expectedValue = (int)UnicodeCategory.TitlecaseLetter;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3:Test the method with '\\0'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("005", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    public bool PosTest4()
-    {
-        bool retVal = true;
-
-        Char ch = '\u02b0';
-
-        int expectedValue = (int)UnicodeCategory.ModifierLetter;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest4:Test the method with '\\u02b0'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("007", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("008", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest5()
-    {
-        bool retVal = true;
-
-        Char ch = '\u404e';
-
-        int expectedValue = (int)UnicodeCategory.OtherLetter;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest5:Test the method with '\\u404e'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("009", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("010", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest6()
-    {
-        bool retVal = true;
-
-        Char ch = '\u0300';
-
-        int expectedValue = (int)UnicodeCategory.NonSpacingMark;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest6:Test the method with '\\u0300'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("011", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("012", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest7()
-    {
-        bool retVal = true;
-
-        Char ch = '\u0903';
-
-        int expectedValue = (int)UnicodeCategory.SpacingCombiningMark;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest7:Test the method with '\\u0903'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("013", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("014", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest8()
-    {
-        bool retVal = true;
-
-        Char ch = '\u0488';
-
-        int expectedValue = (int)UnicodeCategory.EnclosingMark;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest8:Test the method with '\\u0488'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("017", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("018", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest9()
-    {
-        bool retVal = true;
-
-        Char ch = '0';
-
-        int expectedValue = (int)UnicodeCategory.DecimalDigitNumber;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest9:Test the method with '0'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("017", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("018", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest10()
-    {
-        bool retVal = true;
-
-        Char ch = '\u16ee';
-
-        int expectedValue = (int)UnicodeCategory.LetterNumber;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest10:Test the method with '\\u16ee'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("019", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("020", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest11()
-    {
-        bool retVal = true;
-
-        Char ch = '\u00b2';
-
-        int expectedValue = (int)UnicodeCategory.OtherNumber;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest11:Test the method with '\\u00b2'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("021", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("022", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest12()
-    {
-        bool retVal = true;
-
-        Char ch = '\u0020';
-
-        int expectedValue = (int)UnicodeCategory.SpaceSeparator;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest12:Test the method with '\\u0020'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("023", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("024", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest13()
-    {
-        bool retVal = true;
-
-        Char ch = '\u2028';
-
-        int expectedValue = (int)UnicodeCategory.LineSeparator;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest13:Test the method with '\\u2028'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("025", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("026", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest14()
-    {
-        bool retVal = true;
-
-        Char ch = '\u2029';
-
-        int expectedValue = (int)UnicodeCategory.ParagraphSeparator;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest14:Test the method with '\\u2029'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("027", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("028", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest15()
-    {
-        bool retVal = true;
-
-        Char ch = '\0';
-
-        int expectedValue = (int)UnicodeCategory.Control;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest15:Test the method with '\\0'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("029", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("030", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest16()
-    {
-        bool retVal = true;
-
-        Char ch = '\u00ad';
-
-        int expectedValue = (int)UnicodeCategory.Format;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest16:Test the method with '\\u00ad'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("031", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("032", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest17()
-    {
-        bool retVal = true;
-
-        Char ch = '\ud800';
-
-        int expectedValue = (int)UnicodeCategory.Surrogate;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest17:Test the method with '\\ud800'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("033", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("034", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest18()
-    {
-        bool retVal = true;
-
-        Char ch = '\ue000';
-
-        int expectedValue = (int)UnicodeCategory.PrivateUse;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest18:Test the method with '\\ue000'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("035", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("036", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest19()
-    {
-        bool retVal = true;
-
-        Char ch = '\u005f';
-
-        int expectedValue = (int)UnicodeCategory.ConnectorPunctuation;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest19:Test the method with '\\u005f'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("037", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("038", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest20()
-    {
-        bool retVal = true;
-
-        Char ch = '-';
-
-        int expectedValue = (int)UnicodeCategory.DashPunctuation;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest20:Test the method with '-'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("039", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("040", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest21()
-    {
-        bool retVal = true;
-
-        Char ch = '(';
-
-        int expectedValue = (int)UnicodeCategory.OpenPunctuation;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest21:Test the method with '('");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("041", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("042", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest22()
-    {
-        bool retVal = true;
-
-        Char ch = ')';
-
-        int expectedValue = (int)UnicodeCategory.ClosePunctuation;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest22:Test the method with ')'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("043", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("044", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest23()
-    {
-        bool retVal = true;
-
-        Char ch = '\u00ab';
-
-        int expectedValue = (int)UnicodeCategory.InitialQuotePunctuation;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest23:Test the method with '\\u00ab'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("045", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("046", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest24()
-    {
-        bool retVal = true;
-
-        Char ch = '\u00bb';
-
-        int expectedValue = (int)UnicodeCategory.FinalQuotePunctuation;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest24:Test the method with '\\u00bb'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("047", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("048", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest25()
-    {
-        bool retVal = true;
-
-        Char ch = '!';
-
-        int expectedValue = (int)UnicodeCategory.OtherPunctuation;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest25:Test the method with '!'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("049", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("050", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest26()
-    {
-        bool retVal = true;
-
-        Char ch = '+';
-
-        int expectedValue = (int)UnicodeCategory.MathSymbol;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest26:Test the method with '+'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("051", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("052", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest27()
-    {
-        bool retVal = true;
-
-        Char ch = '$';
-
-        int expectedValue = (int)UnicodeCategory.CurrencySymbol;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest27:Test the method with '$'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("053", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("054", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest28()
-    {
-        bool retVal = true;
-
-        Char ch = '^';
-
-        int expectedValue = (int)UnicodeCategory.ModifierSymbol;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest28:Test the method with '^'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("055", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("056", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest29()
-    {
-        bool retVal = true;
-
-        Char ch = '\u00a6';
-
-        int expectedValue = (int)UnicodeCategory.OtherSymbol;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest29:Test the method with '\\u00a6'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("057", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("058", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest30()
-    {
-        bool retVal = true;
-
-        Char ch = '\u0242';
-
-        int expectedValue = (int)UnicodeCategory.LowercaseLetter;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest30:Test the method with '\\u0242'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(ch));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("059", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("060", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/charunicodeinfogetunicodecategory2.cs b/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/charunicodeinfogetunicodecategory2.cs
deleted file mode 100644
index 200ece2abc..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/charunicodeinfo/charunicodeinfogetunicodecategory2.cs
+++ /dev/null
@@ -1,1040 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.CharUnicodeInfo.GetUnicodeCategory(System.String,System.Int32)
-///</summary>
-
-public class CharUnicodeInfoGetUnicodeCategory
-{
-    public  String str = "Aa\u1fa8\u02b0\u404e\u0300\u0903\u0488\u0030\u16ee\u00b2\u0020\u2028\u2029\0\u00ad\ud800\ue000\u005f\u002d()\u00ab\u00bb!+$^\u00a6\u0242";
-
-    public static int Main()
-    {
-        CharUnicodeInfoGetUnicodeCategory testObj = new CharUnicodeInfoGetUnicodeCategory();
-        TestLibrary.TestFramework.BeginTestCase("for method of System.Globalization.CharUnicodeInfo.GetUnicodeCategory");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-        retVal = PosTest5() && retVal;
-        retVal = PosTest6() && retVal;
-        retVal = PosTest7() && retVal;
-        retVal = PosTest8() && retVal;
-        retVal = PosTest9() && retVal;
-        retVal = PosTest10() && retVal;
-        retVal = PosTest11() && retVal;
-        retVal = PosTest12() && retVal;
-        retVal = PosTest13() && retVal;
-        retVal = PosTest14() && retVal;
-        retVal = PosTest15() && retVal;
-        retVal = PosTest16() && retVal;
-        retVal = PosTest17() && retVal;
-        retVal = PosTest18() && retVal;
-        retVal = PosTest19() && retVal;
-        retVal = PosTest20() && retVal;
-        retVal = PosTest21() && retVal;
-        retVal = PosTest22() && retVal;
-        retVal = PosTest23() && retVal;
-        retVal = PosTest24() && retVal;
-        retVal = PosTest25() && retVal;
-        retVal = PosTest26() && retVal;
-        retVal = PosTest27() && retVal;
-        retVal = PosTest28() && retVal;
-        retVal = PosTest29() && retVal;
-        retVal = PosTest30() && retVal;
-
-        retVal = NegTest1() && retVal;
-        retVal = NegTest2() && retVal;
-        retVal = NegTest3() && retVal;
-        return retVal;
-    }
-
-
-    #region Positive Test Logic
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        Char ch = 'A';
-
-        int expectedValue = (int)UnicodeCategory.UppercaseLetter;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Test the method with upper letter");
-
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,0));
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ") when char is '" + ch + "'");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        Char ch = 'a';
-
-        int expectedValue = (int)UnicodeCategory.LowercaseLetter;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2:Test the method with low case char");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,1));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("003", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        Char ch = '\0';
-
-        int expectedValue = (int)UnicodeCategory.TitlecaseLetter;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3:Test the method with '\\0'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,2));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("005", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    public bool PosTest4()
-    {
-        bool retVal = true;
-
-        Char ch = '\u02b0';
-
-        int expectedValue = (int)UnicodeCategory.ModifierLetter;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest4:Test the method with '\\u02b0'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,3));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("007", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("008", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest5()
-    {
-        bool retVal = true;
-
-        Char ch = '\u404e';
-
-        int expectedValue = (int)UnicodeCategory.OtherLetter;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest5:Test the method with '\\u404e'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,4));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("009", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("010", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest6()
-    {
-        bool retVal = true;
-
-        Char ch = '\u0300';
-
-        int expectedValue = (int)UnicodeCategory.NonSpacingMark;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest6:Test the method with '\\u0300'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,5));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("011", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("012", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest7()
-    {
-        bool retVal = true;
-
-        Char ch = '\u0903';
-
-        int expectedValue = (int)UnicodeCategory.SpacingCombiningMark;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest7:Test the method with '\\u0903'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,6));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("013", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("014", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest8()
-    {
-        bool retVal = true;
-
-        Char ch = '\u0488';
-
-        int expectedValue = (int)UnicodeCategory.EnclosingMark;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest8:Test the method with '\\u0488'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,7));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("017", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("018", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest9()
-    {
-        bool retVal = true;
-
-        Char ch = '0';
-
-        int expectedValue = (int)UnicodeCategory.DecimalDigitNumber;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest9:Test the method with '0'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,8));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("017", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("018", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest10()
-    {
-        bool retVal = true;
-
-        Char ch = '\u16ee';
-
-        int expectedValue = (int)UnicodeCategory.LetterNumber;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest10:Test the method with '\\u16ee'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,9));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("019", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("020", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest11()
-    {
-        bool retVal = true;
-
-        Char ch = '\u00b2';
-
-        int expectedValue = (int)UnicodeCategory.OtherNumber;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest11:Test the method with '\\u00b2'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,10));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("021", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("022", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest12()
-    {
-        bool retVal = true;
-
-        Char ch = '\u0020';
-
-        int expectedValue = (int)UnicodeCategory.SpaceSeparator;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest12:Test the method with '\\u0020'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,11));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("023", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("024", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest13()
-    {
-        bool retVal = true;
-
-        Char ch = '\u2028';
-
-        int expectedValue = (int)UnicodeCategory.LineSeparator;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest13:Test the method with '\\u2028'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,12));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("025", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("026", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest14()
-    {
-        bool retVal = true;
-
-        Char ch = '\u2029';
-
-        int expectedValue = (int)UnicodeCategory.ParagraphSeparator;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest14:Test the method with '\\u2029'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,13));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("027", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("028", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest15()
-    {
-        bool retVal = true;
-
-        Char ch = '\0';
-
-        int expectedValue = (int)UnicodeCategory.Control;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest15:Test the method with '\\0'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,14));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("029", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("030", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest16()
-    {
-        bool retVal = true;
-
-        Char ch = '\u00ad';
-
-        int expectedValue = (int)UnicodeCategory.Format;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest16:Test the method with '\\u00ad'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,15));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("031", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("032", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest17()
-    {
-        bool retVal = true;
-
-        Char ch = '\ud800';
-
-        int expectedValue = (int)UnicodeCategory.Surrogate;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest17:Test the method with '\\ud800'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,16));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("033", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("034", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest18()
-    {
-        bool retVal = true;
-
-        Char ch = '\ue000';
-
-        int expectedValue = (int)UnicodeCategory.PrivateUse;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest18:Test the method with '\\ue000'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,17));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("035", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("036", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest19()
-    {
-        bool retVal = true;
-
-        Char ch = '\u005f';
-
-        int expectedValue = (int)UnicodeCategory.ConnectorPunctuation;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest19:Test the method with '\\u005f'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,18));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("037", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("038", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest20()
-    {
-        bool retVal = true;
-
-        Char ch = '-';
-
-        int expectedValue = (int)UnicodeCategory.DashPunctuation;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest20:Test the method with '-'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,19));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("039", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("040", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest21()
-    {
-        bool retVal = true;
-
-        Char ch = '(';
-
-        int expectedValue = (int)UnicodeCategory.OpenPunctuation;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest21:Test the method with '('");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,20));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("041", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("042", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest22()
-    {
-        bool retVal = true;
-
-        Char ch = ')';
-
-        int expectedValue = (int)UnicodeCategory.ClosePunctuation;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest22:Test the method with ')'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,21));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("043", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("044", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest23()
-    {
-        bool retVal = true;
-
-        Char ch = '\u00ab';
-
-        int expectedValue = (int)UnicodeCategory.InitialQuotePunctuation;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest23:Test the method with '\\u00ab'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,22));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("045", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("046", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest24()
-    {
-        bool retVal = true;
-
-        Char ch = '\u00bb';
-
-        int expectedValue = (int)UnicodeCategory.FinalQuotePunctuation;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest24:Test the method with '\\u00bb'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,23));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("047", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("048", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest25()
-    {
-        bool retVal = true;
-
-        Char ch = '!';
-
-        int expectedValue = (int)UnicodeCategory.OtherPunctuation;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest25:Test the method with '!'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,24));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("049", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("050", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest26()
-    {
-        bool retVal = true;
-
-        Char ch = '+';
-
-        int expectedValue = (int)UnicodeCategory.MathSymbol;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest26:Test the method with '+'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,25));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("051", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("052", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest27()
-    {
-        bool retVal = true;
-
-        Char ch = '$';
-
-        int expectedValue = (int)UnicodeCategory.CurrencySymbol;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest27:Test the method with '$'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,26));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("053", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("054", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest28()
-    {
-        bool retVal = true;
-
-        Char ch = '^';
-
-        int expectedValue = (int)UnicodeCategory.ModifierSymbol;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest28:Test the method with '^'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,27));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("055", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("056", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest29()
-    {
-        bool retVal = true;
-
-        Char ch = '\u00a6';
-
-        int expectedValue = (int)UnicodeCategory.OtherSymbol;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest29:Test the method with '\\u00a6'");
-        try
-        {
-            actualValue = (int)(CharUnicodeInfo.GetUnicodeCategory(str,28));
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("057", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("058", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest30()
-    {
-        bool retVal = true;
-
-        Char ch = '\u0242';
-
-        // The values 0242 thru 024F on the Mac PPC (which is unicode 4.0) are OtherNotAssigned
-        // On Whidbey (QFE branch), Telesto and Intel Mac this 0242 has the value of LowercaseLetter
-        int expectedValue = (int)UnicodeCategory.LowercaseLetter;
-        if ((!TestLibrary.Utilities.IsWindows) && (TestLibrary.Utilities.IsBigEndian))
-        {
-            expectedValue = (int)UnicodeCategory.OtherNotAssigned;
-        }
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest30:Test the method with '\\u0242'");
-        try
-        {
-            actualValue = (int) CharUnicodeInfo.GetUnicodeCategory(str,29);
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("059", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("060", "when char is '" + ch + "',Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-
-    #region Negative Test Logic
-
-    public bool NegTest1()
-    {
-        bool retVal = true;
-
-        String testStr = null;
-
-        int actualValue;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1:Invoke the method with null string");
-        try
-        {
-            actualValue = (int)CharUnicodeInfo.GetUnicodeCategory(testStr, 0);
-            TestLibrary.TestFramework.LogError("061", "No ArgumentNullExcepthion thrown out expected.");
-            retVal = false;
-        }
-        catch (ArgumentNullException)
-        {
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("062", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool NegTest2()
-    {
-        bool retVal = true;
-
-        int actualValue;
-
-        String testStr = TestLibrary.Generator.GetString(-55, false,1,5);
-
-        TestLibrary.TestFramework.BeginScenario("NegTest2:Invoke the method with index out of left range.");
-        try
-        {
-            actualValue = (int)CharUnicodeInfo.GetUnicodeCategory(testStr, -1);
-            TestLibrary.TestFramework.LogError("063", "No ArgumentNullExcepthion thrown out expected.");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("064", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool NegTest3()
-    {
-        bool retVal = true;
-
-        int actualValue;
-
-        String testStr = TestLibrary.Generator.GetString(-55, false,1,5);
-
-        TestLibrary.TestFramework.BeginScenario("NegTest3:Invoke the method with index out of right range");
-        try
-        {
-            actualValue = (int)CharUnicodeInfo.GetUnicodeCategory(testStr, 6);
-            TestLibrary.TestFramework.LogError("065", "No ArgumentNullExcepthion thrown out expected.");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("066", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareinfo/CompareInfoCompare2.csproj b/tests/src/CoreMangLib/cti/system/globalization/compareinfo/CompareInfoCompare2.csproj
deleted file mode 100644
index 4f954662f2..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareinfo/CompareInfoCompare2.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="compareinfocompare2.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareinfo/CompareInfoIndexOf2.csproj b/tests/src/CoreMangLib/cti/system/globalization/compareinfo/CompareInfoIndexOf2.csproj
deleted file mode 100644
index e0e2211392..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareinfo/CompareInfoIndexOf2.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="compareinfoindexof2.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareinfo/compareinfocompare2.cs b/tests/src/CoreMangLib/cti/system/globalization/compareinfo/compareinfocompare2.cs
deleted file mode 100644
index f8c05e97b8..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareinfo/compareinfocompare2.cs
+++ /dev/null
@@ -1,218 +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.
-using System;
-using System.Text;
-using System.Globalization;
-using TestLibrary;
-
-public class CompareInfoCompare
-{
-    public static string[] InterestingStrings = new string[] { null, "", "a", "1", "-", "A", "!", "abc", "aBc", "a\u0400Bc", "I", "i", "\u0130", "\u0131", "A", "\uFF21", "\uFE57"};
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-        return retVal;
-    }
-
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Compare interesting strings ordinally");
-
-        try
-        {
-            foreach (string s in InterestingStrings)
-            {
-                foreach (string r in InterestingStrings)
-                {
-                    retVal &= TestStrings(s, r);
-                }
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: Compare many characters");
-
-        try
-        {
-            for (int i = 0; i < 40; i++)  // Ok, 40 isn't that many... but this takes way too long
-            {
-                char c = Generator.GetChar(-55);
-                if (Utilities.CurrentCulture.CompareInfo.Compare(new string(new char[] { c }), new string(new char[] { c }), CompareOptions.Ordinal) != 0)
-                {
-                    TestLibrary.TestFramework.LogError("002.1", "Character " + i.ToString() + " is not equal to itself ordinally!");
-                    retVal = false;
-                }
-
-                for (int j = 0; j < (int)c; j++)
-                {
-                    int compareResult = Utilities.CurrentCulture.CompareInfo.Compare(new string(new char[] { c }), new string(new char[] { (char)j }), CompareOptions.Ordinal);
-                    if (compareResult != 0) compareResult = compareResult / Math.Abs(compareResult);
-                    if (compareResult != 1)
-                    {
-                        TestLibrary.TestFramework.LogError("002.2", "Character " + ((int)c).ToString() + " is not greater than character " + j.ToString() + ", Compare result: " + compareResult.ToString());
-                        retVal = false;
-                    }
-                }
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002.4", "Unexpected exception: " + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: Compare many strings");
-
-        try
-        {
-            for (int i = 0; i < 1000; i++) 
-            {
-                string str1 = Generator.GetString(-55, false, 5, 20);
-                string str2 = Generator.GetString(-55, false, 5, 20);
-                if (Utilities.CurrentCulture.CompareInfo.Compare(str1, str1, CompareOptions.Ordinal) != 0)
-                {
-                    TestLibrary.TestFramework.LogError("003.1", "Comparison not as expected! Acutal result: " + Utilities.CurrentCulture.CompareInfo.Compare(str1, str1, CompareOptions.Ordinal).ToString() + ", Expected result: 0");
-                    TestLibrary.TestFramework.LogInformation("String 1: <" + str1 + "> : " + BytesFromString(str1) + "\nString 2: <" + str1 + "> : " + BytesFromString(str1));
-                    retVal = false;
-                }
-                if (Utilities.CurrentCulture.CompareInfo.Compare(str2, str2, CompareOptions.Ordinal) != 0)
-                {
-                    TestLibrary.TestFramework.LogError("003.2", "Comparison not as expected! Acutal result: " + Utilities.CurrentCulture.CompareInfo.Compare(str2, str2, CompareOptions.Ordinal).ToString() + ", Expected result: 0");
-                    TestLibrary.TestFramework.LogInformation("String 1: <" + str2 + "> : " + BytesFromString(str2) + "\nString 2: <" + str2 + "> : " + BytesFromString(str2));
-                    retVal = false;
-                }
-                TestStrings(str1, str2);
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("003.4", "Unexpected exception: " + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest4()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest4: Specific regression cases");
-
-        try
-        {
-            CultureInfo oldCi = Utilities.CurrentCulture;
-            Utilities.CurrentCulture = new CultureInfo("hu-HU");
-            retVal &= TestStrings("dzsdzs", "ddzs");
-            Utilities.CurrentCulture = oldCi;
-
-            retVal &= TestStrings("\u00C0nimal", "A\u0300nimal");
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004.2", "Unexpected exception: " + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public static int Main()
-    {
-        CompareInfoCompare test = new CompareInfoCompare();
-
-        TestLibrary.TestFramework.BeginTestCase("CompareInfoCompare");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    private bool TestStrings(string str1, string str2)
-    {
-        bool retVal = true;
-
-        int expectValue = PredictValue(str1, str2);
-        int actualValue = Utilities.CurrentCulture.CompareInfo.Compare(str1, str2, CompareOptions.Ordinal);
-        if (expectValue != 0) expectValue = expectValue / Math.Abs(expectValue);
-        if (actualValue != 0) actualValue = actualValue / Math.Abs(actualValue);
-
-        if (actualValue != expectValue)
-        {
-            TestLibrary.TestFramework.LogError("001.1", "Comparison not as expected! Acutal result: " + actualValue + ", Expected result: " + expectValue);
-            TestLibrary.TestFramework.LogInformation("String 1: <" + str1 + "> : " + BytesFromString(str1) + "\nString 2: <" + str2 + "> : " + BytesFromString(str2));
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    int PredictValue(string str1, string str2)
-    {
-        if (str1 == null)
-        {
-            if (str2 == null) return 0;
-            else return -1;
-        }
-        if (str2 == null) return 1;
-
-        for (int i = 0; i < str1.Length; i++)
-        {
-            if (i >= str2.Length) return 1;
-            if ((int)str1[i] > (int)str2[i]) return 1;
-            if ((int)str1[i] < (int)str2[i]) return -1;
-        }
-
-        if (str2.Length > str1.Length) return -1;
-
-        return 0;
-    }
-
-    private static string BytesFromString(string str)
-    {
-        if (str == null) return string.Empty;
-        StringBuilder output = new StringBuilder();
-        for (int i = 0; i < str.Length; i++)
-        {
-            output.Append(Utilities.ByteArrayToString(BitConverter.GetBytes(str[i])));
-            if (i != (str.Length - 1)) output.Append(", ");
-        }
-        return output.ToString();
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareinfo/compareinfoindexof2.cs b/tests/src/CoreMangLib/cti/system/globalization/compareinfo/compareinfoindexof2.cs
deleted file mode 100644
index 4a653b8bc9..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareinfo/compareinfoindexof2.cs
+++ /dev/null
@@ -1,185 +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.
-using System;
-using System.Text;
-using System.Globalization;
-using TestLibrary;
-
-public class CompareInfoIndexOf
-{
-    public static string[] InterestingStrings = new string[] { "", "a", "1", "-", "A", "!", "abc", "aBc", "a\u0400Bc", "I", "i", "\u0130", "\u0131", "A", "\uFF21", "\uFE57"};
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        return retVal;
-    }
-
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Compare interesting strings ordinally");
-
-        try
-        {
-            foreach (string s in InterestingStrings)
-            {
-                foreach (string r in InterestingStrings)
-                {
-                    retVal &= TestStrings(s, r);
-                }
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: Compare many strings");
-
-        try
-        {
-            for (int i = 0; i < 1000; i++) 
-            {
-                string str1 = Generator.GetString(-55, false, 5, 20);
-                string str2 = Generator.GetString(-55, false, 5, 20);
-                if (Utilities.CurrentCulture.CompareInfo.IndexOf(str1, str1, CompareOptions.Ordinal) != 0)
-                {
-                    TestLibrary.TestFramework.LogError("003.1", "Comparison not as expected! Actual result: " + Utilities.CurrentCulture.CompareInfo.IndexOf(str1, str1, CompareOptions.Ordinal).ToString() + ", Expected result: 0");
-                    TestLibrary.TestFramework.LogInformation("String 1: <" + str1 + "> : " + BytesFromString(str1) + "\nString 2: <" + str1 + "> : " + BytesFromString(str1));
-                    retVal = false;
-                }
-                if (Utilities.CurrentCulture.CompareInfo.IndexOf(str2, str2, CompareOptions.Ordinal) != 0)
-                {
-                    TestLibrary.TestFramework.LogError("003.2", "Comparison not as expected! Actual result: " + Utilities.CurrentCulture.CompareInfo.IndexOf(str2, str2, CompareOptions.Ordinal).ToString() + ", Expected result: 0");
-                    TestLibrary.TestFramework.LogInformation("String 1: <" + str2 + "> : " + BytesFromString(str2) + "\nString 2: <" + str2 + "> : " + BytesFromString(str2));
-                    retVal = false;
-                }
-                TestStrings(str1, str2);
-                TestStrings(str1 + str2, str2);
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("003.4", "Unexpected exception: " + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: Specific regression cases");
-
-        try
-        {
-            CultureInfo oldCi = Utilities.CurrentCulture;
-            Utilities.CurrentCulture = new CultureInfo("hu-HU");
-            retVal &= TestStrings("Foodzsdzsbar", "ddzs");
-            Utilities.CurrentCulture = oldCi;
-
-            retVal &= TestStrings("\u00C0nimal", "A\u0300");
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004.2", "Unexpected exception: " + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public static int Main()
-    {
-        CompareInfoIndexOf test = new CompareInfoIndexOf();
-
-        TestLibrary.TestFramework.BeginTestCase("CompareInfoIndexOf");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    private bool TestStrings(string str1, string str2)
-    {
-        bool retVal = true;
-
-        int expectValue = PredictValue(str1, str2);
-        int actualValue = Utilities.CurrentCulture.CompareInfo.IndexOf(str1, str2, CompareOptions.Ordinal);
-
-        if (actualValue != expectValue)
-        {
-            TestLibrary.TestFramework.LogError("001.1", "Comparison not as expected! Actual result: " + actualValue + ", Expected result: " + expectValue);
-            TestLibrary.TestFramework.LogInformation("String 1: <" + str1 + "> : " + BytesFromString(str1) + "\nString 2: <" + str2 + "> : " + BytesFromString(str2));
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    int PredictValue(string str1, string str2)
-    {
-        if (str1 == null)
-        {
-            if (str2 == null) return 0;
-            else return -1;
-        }
-        if (str2 == null) return -1;
-
-        if (str2.Length > str1.Length) return -1;
-        
-        for (int i = 0; i <= str1.Length - str2.Length; i++)
-        {
-            bool match = true;
-            for (int j = 0; j < str2.Length; j++)
-            {
-                if ((int)str1[i + j] != (int)str2[j])
-                {
-                    match = false;
-                    break;
-                }
-            }
-            if (match) return i;
-        }
-        return -1;
-    }
-
-    private static string BytesFromString(string str)
-    {
-        if (str == null) return string.Empty;
-        StringBuilder output = new StringBuilder();
-        for (int i = 0; i < str.Length; i++)
-        {
-            output.Append(Utilities.ByteArrayToString(BitConverter.GetBytes(str[i])));
-            if (i != (str.Length - 1)) output.Append(", ");
-        }
-        return output.ToString();
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsIgnoreCase.csproj b/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsIgnoreCase.csproj
deleted file mode 100644
index 4786f6a0f0..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsIgnoreCase.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="compareoptionsignorecase.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsIgnoreKanaType.csproj b/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsIgnoreKanaType.csproj
deleted file mode 100644
index e281e195aa..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsIgnoreKanaType.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="compareoptionsignorekanatype.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsIgnoreNonSpace.csproj b/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsIgnoreNonSpace.csproj
deleted file mode 100644
index 1ef959adfe..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsIgnoreNonSpace.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="compareoptionsignorenonspace.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsIgnoreSymbols.csproj b/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsIgnoreSymbols.csproj
deleted file mode 100644
index 692ab099e8..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsIgnoreSymbols.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="compareoptionsignoresymbols.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsIgnoreWidth.csproj b/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsIgnoreWidth.csproj
deleted file mode 100644
index 79afcada8e..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsIgnoreWidth.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="compareoptionsignorewidth.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsNone.csproj b/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsNone.csproj
deleted file mode 100644
index 0657d01721..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsNone.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="compareoptionsnone.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsOrdinal.csproj b/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsOrdinal.csproj
deleted file mode 100644
index 9884209bb5..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsOrdinal.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="compareoptionsordinal.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsOrdinalIgoreCase.csproj b/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsOrdinalIgoreCase.csproj
deleted file mode 100644
index 719a7f491e..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsOrdinalIgoreCase.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="compareoptionsordinaligorecase.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsStringSort.csproj b/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsStringSort.csproj
deleted file mode 100644
index 339c0bb9fc..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/CompareOptionsStringSort.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="compareoptionsstringsort.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsignorecase.cs b/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsignorecase.cs
deleted file mode 100644
index 7217e6d487..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsignorecase.cs
+++ /dev/null
@@ -1,73 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.CompareOptions.IgnoreCase
-///</summary>
-
-public class CompareOptionsIgnoreCase
-{
-
-    public static int Main()
-    {
-        CompareOptionsIgnoreCase testObj = new CompareOptionsIgnoreCase();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.Globalization.CompareOptions.IgnoreCase");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-       return retVal;
-    }
-
-
-    #region Test Logic
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        UInt64 expectedValue = 0x00000001;
-        UInt64 actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get CompareOptions.IgnoreCase");
-        try
-        {
-            actualValue = (UInt64)CompareOptions.IgnoreCase;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsignorekanatype.cs b/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsignorekanatype.cs
deleted file mode 100644
index 47031cd2a0..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsignorekanatype.cs
+++ /dev/null
@@ -1,73 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.CompareOptions.IgnoreKanaType
-///</summary>
-
-public class CompareOptionsIgnoreKanaType
-{
-
-    public static int Main()
-    {
-        CompareOptionsIgnoreKanaType testObj = new CompareOptionsIgnoreKanaType();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.Globalization.CompareOptions.IgnoreKanaType");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        UInt64 expectedValue = 0x00000008;
-        UInt64 actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get CompareOptions.IgnoreKanaType");
-        try
-        {
-            actualValue = (UInt64)CompareOptions.IgnoreKanaType;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsignorenonspace.cs b/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsignorenonspace.cs
deleted file mode 100644
index 6a561951d8..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsignorenonspace.cs
+++ /dev/null
@@ -1,73 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.CompareOptions.IgnoreNonSpace
-///</summary>
-
-public class CompareOptionsIgnoreNonSpace
-{
-
-    public static int Main()
-    {
-        CompareOptionsIgnoreNonSpace testObj = new CompareOptionsIgnoreNonSpace();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.Globalization.CompareOptions.IgnoreNonSpace");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        UInt64 expectedValue = 0x00000002;
-        UInt64 actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get CompareOptions.IgnoreNonSpace");
-        try
-        {
-            actualValue = (UInt64)CompareOptions.IgnoreNonSpace;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsignoresymbols.cs b/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsignoresymbols.cs
deleted file mode 100644
index 39ebfd22ce..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsignoresymbols.cs
+++ /dev/null
@@ -1,73 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.CompareOptions.IgnoreSymbols
-///</summary>
-
-public class CompareOptionsIgnoreSymbols
-{
-
-    public static int Main()
-    {
-        CompareOptionsIgnoreSymbols testObj = new CompareOptionsIgnoreSymbols();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.Globalization.CompareOptions.IgnoreSymbols");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        UInt64 expectedValue = 0x00000004;
-        UInt64 actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get CompareOptions.IgnoreSymbols");
-        try
-        {
-            actualValue = (UInt64)CompareOptions.IgnoreSymbols;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsignorewidth.cs b/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsignorewidth.cs
deleted file mode 100644
index abedd43452..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsignorewidth.cs
+++ /dev/null
@@ -1,73 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.CompareOptions.IgnoreWidth
-///</summary>
-
-public class CompareOptionsIgnoreWidth
-{
-
-    public static int Main()
-    {
-        CompareOptionsIgnoreWidth testObj = new CompareOptionsIgnoreWidth();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.Globalization.CompareOptions.IgnoreWidth");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        UInt64 expectedValue = 0x00000010;
-        UInt64 actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get CompareOptions.IgnoreWidth");
-        try
-        {
-            actualValue = (UInt64)CompareOptions.IgnoreWidth;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsnone.cs b/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsnone.cs
deleted file mode 100644
index 5fe1b92c4d..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsnone.cs
+++ /dev/null
@@ -1,73 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.CompareOptions.None
-///</summary>
-
-public class CompareOptionsNone
-{
-
-    public static int Main()
-    {
-        CompareOptionsNone testObj = new CompareOptionsNone();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.Globalization.CompareOptions.None");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        UInt64 expectedValue = 0x00000000;
-        UInt64 actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get CompareOptions.None");
-        try
-        {
-            actualValue = (UInt64)CompareOptions.None;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsordinal.cs b/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsordinal.cs
deleted file mode 100644
index 991754c1e8..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsordinal.cs
+++ /dev/null
@@ -1,73 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.CompareOptions.Ordinal
-///</summary>
-
-public class CompareOptionsOrdinal
-{
-
-    public static int Main()
-    {
-        CompareOptionsOrdinal testObj = new CompareOptionsOrdinal();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.Globalization.CompareOptions.Ordinal");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        UInt64 expectedValue = 0x40000000;
-        UInt64 actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get CompareOptions.Ordinal");
-        try
-        {
-            actualValue = (UInt64)CompareOptions.Ordinal;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsordinaligorecase.cs b/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsordinaligorecase.cs
deleted file mode 100644
index cdcc9175df..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsordinaligorecase.cs
+++ /dev/null
@@ -1,73 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.CompareOptions.OrdinalIgnoreCase
-///</summary>
-
-public class CompareOptionsOrdinalIgnoreCase
-{
-
-    public static int Main()
-    {
-        CompareOptionsOrdinalIgnoreCase testObj = new CompareOptionsOrdinalIgnoreCase();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.Globalization.CompareOptions.OrdinalIgnoreCase");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        UInt64 expectedValue = 0x10000000;
-        UInt64 actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get CompareOptions.OrdinalIgnoreCase");
-        try
-        {
-            actualValue = (UInt64)CompareOptions.OrdinalIgnoreCase;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsstringsort.cs b/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsstringsort.cs
deleted file mode 100644
index 15868acbf6..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/compareoptions/compareoptionsstringsort.cs
+++ /dev/null
@@ -1,73 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.CompareOptions.StringSort
-///</summary>
-
-public class CompareOptionsStringSort
-{
-
-    public static int Main()
-    {
-        CompareOptionsStringSort testObj = new CompareOptionsStringSort();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.Globalization.CompareOptions.StringSort");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        UInt64 expectedValue = 0x20000000;
-        UInt64 actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get CompareOptions.StringSort");
-        try
-        {
-            actualValue = (UInt64)CompareOptions.StringSort;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoClone.csproj b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoClone.csproj
deleted file mode 100644
index 3114583b30..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoClone.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="cultureinfoclone.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoEnglishName.csproj b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoEnglishName.csproj
deleted file mode 100644
index c4ad0843ad..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoEnglishName.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="cultureinfoenglishname.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoEquals.csproj b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoEquals.csproj
deleted file mode 100644
index f102f04769..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoEquals.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="cultureinfoequals.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoGetCultureInfo2.csproj b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoGetCultureInfo2.csproj
deleted file mode 100644
index 849865924c..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoGetCultureInfo2.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="cultureinfogetcultureinfo2.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoGetHashCode.csproj b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoGetHashCode.csproj
deleted file mode 100644
index 635338451f..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoGetHashCode.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="cultureinfogethashcode.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoInvariantCulture.csproj b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoInvariantCulture.csproj
deleted file mode 100644
index 47c0e85e3c..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoInvariantCulture.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="cultureinfoinvariantculture.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoIsNeutralCulture.csproj b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoIsNeutralCulture.csproj
deleted file mode 100644
index 2b4a504c11..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoIsNeutralCulture.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="cultureinfoisneutralculture.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoName.csproj b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoName.csproj
deleted file mode 100644
index a923906f7f..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoName.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="cultureinfoname.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoNativeName.csproj b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoNativeName.csproj
deleted file mode 100644
index fd8eeafc8b..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoNativeName.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="cultureinfonativename.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoParent.csproj b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoParent.csproj
deleted file mode 100644
index 91b9dee20f..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoParent.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="cultureinfoparent.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoReadOnly.csproj b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoReadOnly.csproj
deleted file mode 100644
index c86f59799e..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoReadOnly.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="cultureinforeadonly.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoTextInfo.csproj b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoTextInfo.csproj
deleted file mode 100644
index 77aaf35c39..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoTextInfo.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="cultureinfotextinfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoToString.csproj b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoToString.csproj
deleted file mode 100644
index a70c9acf42..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoToString.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="cultureinfotostring.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoTwoLetterISOLanguageName.csproj b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoTwoLetterISOLanguageName.csproj
deleted file mode 100644
index 113a11d68a..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/CultureInfoTwoLetterISOLanguageName.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="cultureinfotwoletterisolanguagename.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfoclone.cs b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfoclone.cs
deleted file mode 100644
index 3fb2ec0434..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfoclone.cs
+++ /dev/null
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfoenglishname.cs b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfoenglishname.cs
deleted file mode 100644
index 0d7244e608..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfoenglishname.cs
+++ /dev/null
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfoequals.cs b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfoequals.cs
deleted file mode 100644
index de2c612a3a..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfoequals.cs
+++ /dev/null
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfogetcultureinfo2.cs b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfogetcultureinfo2.cs
deleted file mode 100644
index 187bdd9794..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfogetcultureinfo2.cs
+++ /dev/null
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfogethashcode.cs b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfogethashcode.cs
deleted file mode 100644
index 14b746047a..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfogethashcode.cs
+++ /dev/null
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfoinvariantculture.cs b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfoinvariantculture.cs
deleted file mode 100644
index c325160b00..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfoinvariantculture.cs
+++ /dev/null
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfoisneutralculture.cs b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfoisneutralculture.cs
deleted file mode 100644
index 53770fba4d..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfoisneutralculture.cs
+++ /dev/null
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfoname.cs b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfoname.cs
deleted file mode 100644
index 83dd460d10..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfoname.cs
+++ /dev/null
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfonativename.cs b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfonativename.cs
deleted file mode 100644
index b42972a706..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfonativename.cs
+++ /dev/null
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfoparent.cs b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfoparent.cs
deleted file mode 100644
index 079d6c79e7..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfoparent.cs
+++ /dev/null
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinforeadonly.cs b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinforeadonly.cs
deleted file mode 100644
index 2df3f6c921..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinforeadonly.cs
+++ /dev/null
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfotextinfo.cs b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfotextinfo.cs
deleted file mode 100644
index 973a349441..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfotextinfo.cs
+++ /dev/null
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfotostring.cs b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfotostring.cs
deleted file mode 100644
index 250b9949e2..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfotostring.cs
+++ /dev/null
diff --git a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfotwoletterisolanguagename.cs b/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfotwoletterisolanguagename.cs
deleted file mode 100644
index 1b990e69ed..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/cultureinfo/cultureinfotwoletterisolanguagename.cs
+++ /dev/null
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoClone.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoClone.csproj
deleted file mode 100644
index b5aaef7ee3..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoClone.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeformatinfoclone.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoCurrentInfo.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoCurrentInfo.csproj
deleted file mode 100644
index 25a21a208a..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoCurrentInfo.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeformatinfocurrentinfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoGetAbbreviatedMonthName.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoGetAbbreviatedMonthName.csproj
deleted file mode 100644
index a1c4a8c122..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoGetAbbreviatedMonthName.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeformatinfogetabbreviatedmonthname.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoGetFormat.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoGetFormat.csproj
deleted file mode 100644
index b6b29fd2d0..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoGetFormat.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeformatinfogetformat.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoGetInstance.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoGetInstance.csproj
deleted file mode 100644
index c78d2041ae..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoGetInstance.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeformatinfogetinstance.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoGetMonthName.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoGetMonthName.csproj
deleted file mode 100644
index 772207d5cd..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoGetMonthName.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeformatinfogetmonthname.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoInvariantInfo.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoInvariantInfo.csproj
deleted file mode 100644
index 0667522ae3..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoInvariantInfo.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeformatinfoinvariantinfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoIsReadOnly.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoIsReadOnly.csproj
deleted file mode 100644
index ea61dda12b..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoIsReadOnly.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeformatinfoisreadonly.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoRFC1123Pattern.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoRFC1123Pattern.csproj
deleted file mode 100644
index deb0f8c023..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoRFC1123Pattern.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeformatinforfc1123pattern.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoReadOnly.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoReadOnly.csproj
deleted file mode 100644
index b1f30a1e98..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoReadOnly.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeformatinforeadonly.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoSortableDateTimePattern.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoSortableDateTimePattern.csproj
deleted file mode 100644
index ae1af29c3e..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/DateTimeFormatInfoSortableDateTimePattern.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeformatinfosortabledatetimepattern.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/UniversalSortableDateTimePattern.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/UniversalSortableDateTimePattern.csproj
deleted file mode 100644
index 3ef122ca51..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/UniversalSortableDateTimePattern.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimeformatinfouniversalsortabledatetimepattern.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfoclone.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfoclone.cs
deleted file mode 100644
index 49137b156b..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfoclone.cs
+++ /dev/null
@@ -1,239 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// Clone
-/// </summary>
-public class DateTimeFormatInfoClone
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Call Clone method on a instance created from Ctor");
-
-        try
-        {
-            DateTimeFormatInfo expected = new DateTimeFormatInfo();
-
-            retVal = VerificationHelper(expected, expected.Clone(), "001.1") && retVal;
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: Call Clone method on a instance created from several cultures");
-
-        try
-        {
-            DateTimeFormatInfo expected = new CultureInfo("en-us").DateTimeFormat;
-            retVal = VerificationHelper(expected, expected.Clone(), "002.1") && retVal;
-            
-            expected = new CultureInfo("fr-FR").DateTimeFormat;
-            retVal = VerificationHelper(expected, expected.Clone(), "002.2") && retVal;
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: Call Clone method on a readonly instance created from several cultures");
-
-        try
-        {
-            DateTimeFormatInfo expected = CultureInfo.InvariantCulture.DateTimeFormat;
-            retVal = VerificationHelper(expected, expected.Clone(), "003.1") && retVal;
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("003.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeFormatInfoClone test = new DateTimeFormatInfoClone();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeFormatInfoClone");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    #region Private Methods
-    private bool VerificationHelper(DateTimeFormatInfo expected, Object obj, string errorno)
-    {
-        bool retval = true;
-
-        if (!(obj is DateTimeFormatInfo))
-        {
-            TestLibrary.TestFramework.LogError(errorno + ".1", "Calling Clone method does not return an DateTimeFormatInfo copy");
-            retval = false;
-        }
-
-        DateTimeFormatInfo actual = obj as DateTimeFormatInfo;
-        if ( actual.IsReadOnly )
-        {
-            TestLibrary.TestFramework.LogError(errorno + ".2", "Calling Clone method makes DateTimeFormatInfo copy read only");
-            retval = false;
-        }
-
-        retval =
-            IsEquals(actual.AbbreviatedDayNames, expected.AbbreviatedDayNames, errorno + ".3") &&
-            IsEquals(actual.AbbreviatedMonthGenitiveNames, expected.AbbreviatedMonthGenitiveNames, errorno + ".4") &&
-            IsEquals(actual.AbbreviatedMonthNames, expected.AbbreviatedMonthNames, errorno + ".5") &&
-            IsEquals(actual.DayNames, expected.DayNames, errorno + ".6") &&
-            IsEquals(actual.MonthGenitiveNames, expected.MonthGenitiveNames, errorno + ".7") &&
-            IsEquals(actual.MonthNames, expected.MonthNames, errorno + ".8") &&
-            IsEquals(actual.ShortestDayNames, expected.ShortestDayNames, errorno + ".9") &&
-            IsEquals(actual.AMDesignator, expected.AMDesignator, errorno + ".10") &&
-			//DateTimeFormatInfo.DateSeparator property has been removed
-            IsEquals(actual.FullDateTimePattern, expected.FullDateTimePattern, errorno + ".12") &&
-            IsEquals(actual.LongDatePattern, expected.LongDatePattern, errorno + ".13") &&
-            IsEquals(actual.LongTimePattern, expected.LongTimePattern, errorno + ".14") &&
-            IsEquals(actual.MonthDayPattern, expected.MonthDayPattern, errorno + ".15") &&
-            IsEquals(actual.PMDesignator, expected.PMDesignator, errorno + ".17") &&
-            IsEquals(actual.RFC1123Pattern, expected.RFC1123Pattern, errorno + ".18") &&
-            IsEquals(actual.ShortDatePattern, expected.ShortDatePattern, errorno + ".19") &&
-            IsEquals(actual.ShortTimePattern, expected.ShortTimePattern, errorno + ".20") &&
-            IsEquals(actual.SortableDateTimePattern, expected.SortableDateTimePattern, errorno + ".21") &&
-			//DateTimeFormatInfo.TimeSeparator property has been removed
-			IsEquals(actual.UniversalSortableDateTimePattern, expected.UniversalSortableDateTimePattern, errorno + ".23") &&
-            IsEquals(actual.YearMonthPattern, expected.YearMonthPattern, errorno + ".24") &&
-            IsEquals(actual.CalendarWeekRule, expected.CalendarWeekRule, errorno + ".25") &&
-            IsEquals(actual.FirstDayOfWeek, expected.FirstDayOfWeek, errorno + ".26") &&
-            retval;
-
-        return retval;
-    }
-
-    private bool IsEquals(string str1, string str2, string errorno)
-    {
-        bool retVal = true;
-
-        if (str1 != str2)
-        {
-            TestLibrary.TestFramework.LogError(errorno, "Two string are not equal");
-            TestLibrary.TestFramework.LogInformation("WARNING[LOCAL VARIABLES] str1 = " + str1 + ", str2 = " + str2);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    private bool IsEquals(DayOfWeek value1, DayOfWeek value2, string errorno)
-    {
-        bool retVal = true;
-
-        if (value1 != value2)
-        {
-            TestLibrary.TestFramework.LogError(errorno, "Two values are not equal");
-            TestLibrary.TestFramework.LogInformation("WARNING[LOCAL VARIABLES] value1 = " + value1 + ", value2 = " + value2);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    private bool IsEquals(CalendarWeekRule value1, CalendarWeekRule value2, string errorno)
-    {
-        bool retVal = true;
-
-        if (value1 != value2)
-        {
-            TestLibrary.TestFramework.LogError(errorno, "Two values are not equal");
-            TestLibrary.TestFramework.LogInformation("WARNING[LOCAL VARIABLES] value1 = " + value1 + ", value2 = " + value2);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    private bool IsEquals(string[] array1, string[] array2, string errorno)
-    {
-        bool retval = true;
-
-        if ((array1 == null) && (array2 == null))
-        {
-            return true;
-        }
-        if ((array1 == null) && (array2 != null))
-        {
-            return false;
-        }
-        if ((array1 != null) && (array2 == null))
-        {
-            return false;
-        }
-        if (array1.Length != array2.Length)
-        {
-            return false;
-        }
-
-        for (int i = 0; i < array1.Length; i++)
-        {
-            if (array1[i] != array2[i])
-            {
-                TestLibrary.TestFramework.LogError(errorno, "Two arrays are not equal");
-                TestLibrary.TestFramework.LogInformation("WARNING[LOCAL VARIABLES] array1[i] = " + array1[i] + ", array2[i] = " + array2[i] + ", i = " + i);
-                retval = false;
-                break;
-            }
-        }
-
-        return retval;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfocurrentinfo.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfocurrentinfo.cs
deleted file mode 100644
index dbe3e8a81a..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfocurrentinfo.cs
+++ /dev/null
@@ -1,70 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// CurrentInfo
-/// </summary>
-public class DateTimeFormatInfoCurrentInfo
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Call CurrentInfo to get a read only DateTimeFormatInfo based on the CultureInfo of the current thread");
-
-        try
-        {
-            DateTimeFormatInfo info = DateTimeFormatInfo.CurrentInfo;
-            if (!info.IsReadOnly)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Calling CurrentInfo returns a writable instance");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeFormatInfoCurrentInfo test = new DateTimeFormatInfoCurrentInfo();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeFormatInfoCurrentInfo");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfogetabbreviatedmonthname.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfogetabbreviatedmonthname.cs
deleted file mode 100644
index 97877e73c3..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfogetabbreviatedmonthname.cs
+++ /dev/null
@@ -1,277 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// GetAbbreviatedMonthName(System.Int32)
-/// </summary>
-public class DateTimeFormatInfoGetAbbreviatedMonthName
-{
-    #region Private Fields
-    private const int c_MIN_MONTH_VALUE = 1;
-    private const int c_MAX_MONTH_VALUE = 13;
-    #endregion
-
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-
-        TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Call GetAbbreviatedDayName on default invariant DateTimeFormatInfo instance");
-
-        try
-        {
-            DateTimeFormatInfo info = CultureInfo.InvariantCulture.DateTimeFormat;
-            string[] expected = new string[] {
-                "",
-                "Jan",
-                "Feb", 
-                "Mar",
-                "Apr",
-                "May",
-                "Jun",
-                "Jul",
-                "Aug",
-                "Sep",
-                "Oct",
-                "Nov",
-                "Dec",
-                "",
-            };
-
-            retVal = VerificationHelper(info, expected, "001.1") && retVal;
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: Call GetAbbreviatedDayName on en-us culture DateTimeFormatInfo instance");
-
-        try
-        {
-            DateTimeFormatInfo info = new CultureInfo("en-us").DateTimeFormat;
-            string[] expected = new string[] {
-                "",
-                "Jan",
-                "Feb", 
-                "Mar",
-                "Apr",
-                "May",
-                "Jun",
-                "Jul",
-                "Aug",
-                "Sep",
-                "Oct",
-                "Nov",
-                "Dec",
-                "",
-            };
-
-            retVal = VerificationHelper(info, expected, "002.1") && retVal;
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: Call GetAbbreviatedDayName on fr-FR culture DateTimeFormatInfo instance");
-
-        try
-        {
-            DateTimeFormatInfo info = new CultureInfo("fr-FR").DateTimeFormat;
-            string[] expected = new string[] {
-                "",
-                "janv.",
-                "f\u00e9vr.", 
-                "mars",
-                "avr.",
-                "mai",
-                "juin",
-                "juil.",
-                "ao\u00fbt",
-                "sept.",
-                "oct.",
-                "nov.",
-                "d\u00e9c.",
-                "",
-            };
-
-            retVal = VerificationHelper(info, expected, "003.1") && retVal;
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("003.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest4()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest4: Call GetAbbreviatedDayName on DateTimeFormatInfo instance created from ctor");
-
-        try
-        {
-            DateTimeFormatInfo info = new DateTimeFormatInfo();
-            string[] expected = new string[] {
-                "",
-                "Jan",
-                "Feb", 
-                "Mar",
-                "Apr",
-                "May",
-                "Jun",
-                "Jul",
-                "Aug",
-                "Sep",
-                "Oct",
-                "Nov",
-                "Dec",
-                "",
-            };
-
-            retVal = VerificationHelper(info, expected, "004.1") && retVal;
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    public bool NegTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: ArgumentOutOfRangeException should be thrown when dayofweek is not a valid System.DayOfWeek value. ");
-
-        try
-        {
-            DateTimeFormatInfo info = new DateTimeFormatInfo();
-
-            info.GetAbbreviatedMonthName(c_MIN_MONTH_VALUE - 1);
-
-            TestLibrary.TestFramework.LogError("101.1", "ArgumentOutOfRangeException is not thrown");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("101.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            DateTimeFormatInfo info = new DateTimeFormatInfo();
-
-            info.GetAbbreviatedMonthName(c_MAX_MONTH_VALUE + 1);
-
-            TestLibrary.TestFramework.LogError("101.3", "ArgumentOutOfRangeException is not thrown");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("101.4", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeFormatInfoGetAbbreviatedMonthName test = new DateTimeFormatInfoGetAbbreviatedMonthName();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeFormatInfoGetAbbreviatedMonthName");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    #region Private Methods
-    private bool VerificationHelper(DateTimeFormatInfo info, string[] expected, string errorno)
-    {
-        bool retval = true;
-
-        for (int i = c_MIN_MONTH_VALUE; i <= c_MAX_MONTH_VALUE; ++i)
-        {
-            string actual = info.GetAbbreviatedMonthName(i);
-            if (actual != expected[i])
-            {
-                TestLibrary.TestFramework.LogError(errorno, "GetAbbreviatedDayName returns wrong value");
-                TestLibrary.TestFramework.LogInformation("WARNING[LOCAL VARIABLES] i = " + i + ", expected[i] = " + expected[i] + ", actual = " + actual);
-                retval = false;
-            }
-        }
-
-        return retval;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfogetformat.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfogetformat.cs
deleted file mode 100644
index d8a569b080..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfogetformat.cs
+++ /dev/null
@@ -1,105 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// GetFormat(System.Type)
-/// </summary>
-public class DateTimeFormatInfoGetFormat
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Call GetFormat to to get an valid DateTimeFormatInfo instance");
-
-        try
-        {
-            DateTimeFormatInfo expected = new DateTimeFormatInfo();
-            object obj = expected.GetFormat(typeof(DateTimeFormatInfo));
-
-            if (!(obj is DateTimeFormatInfo))
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Calling GetFormat returns a non DateTimeFormatInfo instance");
-                retVal = false;
-            }
-
-            DateTimeFormatInfo actual = obj as DateTimeFormatInfo;
-            if (actual != expected)
-            {
-                TestLibrary.TestFramework.LogError("001.2", "Calling GetFormat returns wrong instance");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: If the format type is not supported, null reference should be return");
-
-        try
-        {
-            DateTimeFormatInfo info = new DateTimeFormatInfo();
-            if (info.GetFormat(typeof(Object)) != null)
-            {
-                TestLibrary.TestFramework.LogError("002.1", "If the format type is not supported, null reference is not returned");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeFormatInfoGetFormat test = new DateTimeFormatInfoGetFormat();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeFormatInfoGetFormat");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfogetinstance.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfogetinstance.cs
deleted file mode 100644
index 6be081cc07..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfogetinstance.cs
+++ /dev/null
@@ -1,195 +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.
-using System;
-using System.Globalization;
-
-public class TestIFormatProviderClass : IFormatProvider
-{
-    public object GetFormat(Type formatType)
-    {
-        return this;
-    }
-}
-
-public class TestIFormatProviderClass2 : IFormatProvider
-{
-    public object GetFormat(Type formatType)
-    {
-        return new DateTimeFormatInfo();
-    }
-}
-
-/// <summary>
-/// GetInstance(System.IFormatProvider)
-/// </summary>
-public class DateTimeFormatInfoGetInstance
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-        retVal = PosTest5() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Call GetInstance to get an DateTimeFormatInfo instance when provider is an CultureInfo instance");
-
-        try
-        {
-            DateTimeFormatInfo info = DateTimeFormatInfo.GetInstance(new CultureInfo("en-us"));
-
-            if (info == null)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Calling GetInstance to get an DateTimeFormatInfo instance when provider is an CultureInfo instance returns null reference");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: Call GetInstance to get an DateTimeFormatInfo instance when provider is null reference");
-
-        try
-        {
-            DateTimeFormatInfo info = DateTimeFormatInfo.GetInstance(null);
-
-            if (info != DateTimeFormatInfo.CurrentInfo)
-            {
-                TestLibrary.TestFramework.LogError("002.1", "Calling GetInstance to get an DateTimeFormatInfo instance when provider is null reference does not return CurrentInfo");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: Call GetInstance to get an DateTimeFormatInfo instance when provider is a DateTimeFormatInfo instance");
-
-        try
-        {
-            DateTimeFormatInfo info = DateTimeFormatInfo.GetInstance(new DateTimeFormatInfo());
-
-            if (info == null)
-            {
-                TestLibrary.TestFramework.LogError("003.1", "Calling GetInstance to get an DateTimeFormatInfo instance when provider is a DateTimeFormatInfo instance returns null reference");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("003.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest4()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest4: Call GetInstance to get an DateTimeFormatInfo instance when provider.GetFormat method supports a DateTimeFormatInfo instance");
-
-        try
-        {
-            DateTimeFormatInfo info = DateTimeFormatInfo.GetInstance(new TestIFormatProviderClass2());
-
-            if (info == null)
-            {
-                TestLibrary.TestFramework.LogError("004.1", "Calling GetInstance to get an DateTimeFormatInfo instance when provider.GetFormat method supports a DateTimeFormatInfo instance returns null reference");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest5()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest5: Call GetInstance to get an DateTimeFormatInfo instance when provider.GetFormat method does not support a DateTimeFormatInfo instance");
-
-        try
-        {
-            DateTimeFormatInfo info = DateTimeFormatInfo.GetInstance(new TestIFormatProviderClass());
-
-            if (info != DateTimeFormatInfo.CurrentInfo)
-            {
-                TestLibrary.TestFramework.LogError("005.1", "Calling GetInstance to get an DateTimeFormatInfo instance when provider.GetFormat method does not support a DateTimeFormatInfo instance does not return CurrentInfo");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("005.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeFormatInfoGetInstance test = new DateTimeFormatInfoGetInstance();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeFormatInfoGetInstance");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfogetmonthname.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfogetmonthname.cs
deleted file mode 100644
index 5bdf5937c7..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfogetmonthname.cs
+++ /dev/null
@@ -1,277 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// GetMonthName(System.Int32)
-/// </summary>
-public class DateTimeFormatInfoGetMonthName
-{
-    #region Private Fields
-    private const int c_MIN_MONTH_VALUE = 1;
-    private const int c_MAX_MONTH_VALUE = 13;
-    #endregion
-
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-
-        TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Call GetAbbreviatedDayName on default invariant DateTimeFormatInfo instance");
-
-        try
-        {
-            DateTimeFormatInfo info = CultureInfo.InvariantCulture.DateTimeFormat;
-            string[] expected = new string[] {
-                "",
-                "January",
-                "February", 
-                "March",
-                "April",
-                "May",
-                "June",
-                "July",
-                "August",
-                "September",
-                "October",
-                "November",
-                "December",
-                "",
-            };
-
-            retVal = VerificationHelper(info, expected, "001.1") && retVal;
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: Call GetAbbreviatedDayName on en-us culture DateTimeFormatInfo instance");
-
-        try
-        {
-            DateTimeFormatInfo info = new CultureInfo("en-us").DateTimeFormat;
-            string[] expected = new string[] {
-                "",
-                "January",
-                "February", 
-                "March",
-                "April",
-                "May",
-                "June",
-                "July",
-                "August",
-                "September",
-                "October",
-                "November",
-                "December",
-                "",
-            };
-
-            retVal = VerificationHelper(info, expected, "002.1") && retVal;
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: Call GetAbbreviatedDayName on fr-FR culture DateTimeFormatInfo instance");
-
-        try
-        {
-            DateTimeFormatInfo info = new CultureInfo("fr-FR").DateTimeFormat;
-            string[] expected = new string[] {
-                "",
-                "janvier",
-                "f\u00e9vrier", 
-                "mars",
-                "avril",
-                "mai",
-                "juin",
-                "juillet",
-                "ao\u00fbt",
-                "septembre",
-                "octobre",
-                "novembre",
-                "d\u00e9cembre",
-                "",
-            };
-
-            retVal = VerificationHelper(info, expected, "003.1") && retVal;
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("003.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest4()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest4: Call GetAbbreviatedDayName on DateTimeFormatInfo instance created from ctor");
-
-        try
-        {
-            DateTimeFormatInfo info = new DateTimeFormatInfo();
-            string[] expected = new string[] {
-                "",
-                "January",
-                "February", 
-                "March",
-                "April",
-                "May",
-                "June",
-                "July",
-                "August",
-                "September",
-                "October",
-                "November",
-                "December",
-                "",
-            };
-
-            retVal = VerificationHelper(info, expected, "004.1") && retVal;
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    public bool NegTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: ArgumentOutOfRangeException should be thrown when dayofweek is not a valid System.DayOfWeek value. ");
-
-        try
-        {
-            DateTimeFormatInfo info = new DateTimeFormatInfo();
-
-            info.GetMonthName(c_MIN_MONTH_VALUE - 1);
-
-            TestLibrary.TestFramework.LogError("101.1", "ArgumentOutOfRangeException is not thrown");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("101.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        try
-        {
-            DateTimeFormatInfo info = new DateTimeFormatInfo();
-
-            info.GetMonthName(c_MAX_MONTH_VALUE + 1);
-
-            TestLibrary.TestFramework.LogError("101.3", "ArgumentOutOfRangeException is not thrown");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("101.4", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeFormatInfoGetMonthName test = new DateTimeFormatInfoGetMonthName();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeFormatInfoGetMonthName");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    #region Private Methods
-    private bool VerificationHelper(DateTimeFormatInfo info, string[] expected, string errorno)
-    {
-        bool retval = true;
-
-        for (int i = c_MIN_MONTH_VALUE; i <= c_MAX_MONTH_VALUE; ++i)
-        {
-            string actual = info.GetMonthName(i);
-            if (actual != expected[i])
-            {
-                TestLibrary.TestFramework.LogError(errorno + "." + i, "GetAbbreviatedDayName returns wrong value");
-                TestLibrary.TestFramework.LogInformation("WARNING[LOCAL VARIABLES] i = " + i + ", expected[i] = " + expected[i] + ", actual = " + actual);
-                retval = false;
-            }
-        }
-
-        return retval;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfoinvariantinfo.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfoinvariantinfo.cs
deleted file mode 100644
index f93379c3af..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfoinvariantinfo.cs
+++ /dev/null
@@ -1,70 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// InvariantInfo
-/// </summary>
-public class DateTimeFormatInfoInvariantInfo
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: InvariantInfo should return a read-only DateTimeFormatInfo");
-
-        try
-        {
-            DateTimeFormatInfo info = DateTimeFormatInfo.InvariantInfo;
-            if (!info.IsReadOnly)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "InvariantInfo does not return a read-only DateTimeFormatInfo");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeFormatInfoInvariantInfo test = new DateTimeFormatInfoInvariantInfo();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeFormatInfoInvariantInfo");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfoisreadonly.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfoisreadonly.cs
deleted file mode 100644
index 082a70ab14..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfoisreadonly.cs
+++ /dev/null
@@ -1,122 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// IsReadOnly
-/// </summary>
-public class DateTimeFormatInfoIsReadOnly
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: IsReadOnly should return false for DateTimeFormatInfo created from non invariant culture");
-
-        try
-        {
-            DateTimeFormatInfo info = new CultureInfo("en-us").DateTimeFormat;
-            if (info.IsReadOnly)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "IsReadOnly returns true for DateTimeFormatInfo created from non invariant culture");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: IsReadOnly should return true for DateTimeFormatInfo created from invariant culture");
-
-        try
-        {
-            DateTimeFormatInfo info = DateTimeFormatInfo.InvariantInfo;
-            if (!info.IsReadOnly)
-            {
-                TestLibrary.TestFramework.LogError("002.1", "IsReadOnly returns false for DateTimeFormatInfo created from non invariant culture");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: IsReadOnly should return true for DateTimeFormatInfo created by ReadOnly method");
-
-        try
-        {
-            DateTimeFormatInfo info = DateTimeFormatInfo.ReadOnly(new CultureInfo("en-us").DateTimeFormat);
-            if (!info.IsReadOnly)
-            {
-                TestLibrary.TestFramework.LogError("003.1", "IsReadOnly returns false for DateTimeFormatInfo created by ReadOnly method");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("003.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeFormatInfoIsReadOnly test = new DateTimeFormatInfoIsReadOnly();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeFormatInfoIsReadOnly");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinforeadonly.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinforeadonly.cs
deleted file mode 100644
index d52985d328..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinforeadonly.cs
+++ /dev/null
@@ -1,131 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// ReadOnly(System.Globalization.DateTimeFormatInfo)
-/// </summary>
-public class DateTimeFormatInfoReadOnly
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-
-        TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Call ReadOnly on a writable DateTimeFormatInfo instance");
-
-        try
-        {
-            DateTimeFormatInfo info = new DateTimeFormatInfo();
-            DateTimeFormatInfo actual = DateTimeFormatInfo.ReadOnly(info);
-
-            if (!actual.IsReadOnly)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Calling ReadOnly on a writable DateTimeFormatInfo instance does not make the instance read only");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: Call ReadOnly on a read only DateTimeFormatInfo instance");
-
-        try
-        {
-            DateTimeFormatInfo info = DateTimeFormatInfo.InvariantInfo;
-            DateTimeFormatInfo actual = DateTimeFormatInfo.ReadOnly(info);
-
-            if (!actual.IsReadOnly)
-            {
-                TestLibrary.TestFramework.LogError("002.1", "Calling ReadOnly on a read only DateTimeFormatInfo instance does not make the instance read only");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    public bool NegTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: ArgumentNullException should be thrown when dtfi is a null reference");
-
-        try
-        {
-            DateTimeFormatInfo.ReadOnly(null);
-
-            TestLibrary.TestFramework.LogError("101.1", "ArgumentNullException is not thrown when dtfi is a null reference");
-            retVal = false;
-        }
-        catch (ArgumentNullException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("101.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeFormatInfoReadOnly test = new DateTimeFormatInfoReadOnly();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeFormatInfoReadOnly");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinforfc1123pattern.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinforfc1123pattern.cs
deleted file mode 100644
index b590b306aa..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinforfc1123pattern.cs
+++ /dev/null
@@ -1,92 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// RFC1123Pattern
-/// </summary>
-public class DateTimeFormatInfoRFC1123Pattern
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Call RFC1123Pattern getter method should return correct value for InvariantInfo");
-
-        try
-        {
-            retVal = VerificationHelper(DateTimeFormatInfo.InvariantInfo, "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'", "001.1") && retVal;
-            retVal = VerificationHelper(new CultureInfo("en-us").DateTimeFormat, "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'", "001.2") && retVal;
-			try
-			{
-				retVal = VerificationHelper(new CultureInfo("ja-jp").DateTimeFormat, "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'", "001.3") && retVal;
-			}
-			catch (ArgumentException)
-			{
-				TestLibrary.TestFramework.LogInformation("East Asian Languages are not installed. Skipping Japanese culture test(s).");
-				retVal = retVal && true;
-			}
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeFormatInfoRFC1123Pattern test = new DateTimeFormatInfoRFC1123Pattern();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeFormatInfoRFC1123Pattern");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    #region Private Methods
-    private bool VerificationHelper(DateTimeFormatInfo info, string expected, string errorno)
-    {
-        bool retval = true;
-
-        string actual = info.RFC1123Pattern;
-        if (actual != expected)
-        {
-            TestLibrary.TestFramework.LogError(errorno, "Call RFC1123Pattern returns wrong value");
-            TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual = " + actual + ", expected = " + expected);
-            retval = false;
-        }
-
-        return retval;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfosortabledatetimepattern.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfosortabledatetimepattern.cs
deleted file mode 100644
index 5595ec0bb9..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfosortabledatetimepattern.cs
+++ /dev/null
@@ -1,93 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// SortableDateTimePattern
-/// </summary>
-public class DateTimeFormatInfoSortableDateTimePattern
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Call SortableDateTimePattern getter method should return correct value for InvariantInfo");
-
-        try
-        {
-            retVal = VerificationHelper(DateTimeFormatInfo.InvariantInfo, "yyyy'-'MM'-'dd'T'HH':'mm':'ss", "001.1") && retVal;
-            retVal = VerificationHelper(new CultureInfo("en-us").DateTimeFormat, "yyyy'-'MM'-'dd'T'HH':'mm':'ss", "001.2") && retVal;
-			try
-			{
-				retVal = VerificationHelper(new CultureInfo("ja-JP").DateTimeFormat, "yyyy'-'MM'-'dd'T'HH':'mm':'ss", "001.3") && retVal;
-			}
-			catch (ArgumentException)
-			{
-				TestLibrary.TestFramework.LogInformation("East Asian Languages are not installed. Skipping Japanese culture test(s).");
-				retVal = retVal && true;
-			}
-			retVal = VerificationHelper(new CultureInfo("fr-fr").DateTimeFormat, "yyyy'-'MM'-'dd'T'HH':'mm':'ss", "001.4") && retVal;
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeFormatInfoSortableDateTimePattern test = new DateTimeFormatInfoSortableDateTimePattern();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeFormatInfoSortableDateTimePattern");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    #region Private Methods
-    private bool VerificationHelper(DateTimeFormatInfo info, string expected, string errorno)
-    {
-        bool retval = true;
-
-        string actual = info.SortableDateTimePattern;
-        if (actual != expected)
-        {
-            TestLibrary.TestFramework.LogError(errorno, "Call SortableDateTimePattern returns wrong value");
-            TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual = " + actual + ", expected = " + expected);
-            retval = false;
-        }
-
-        return retval;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfouniversalsortabledatetimepattern.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfouniversalsortabledatetimepattern.cs
deleted file mode 100644
index 34c348cd6a..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimeformatinfo/datetimeformatinfouniversalsortabledatetimepattern.cs
+++ /dev/null
@@ -1,93 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// UniversalSortableDateTimePattern
-/// </summary>
-public class DateTimeFormatInfoUniversalSortableDateTimePattern
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Call UniversalSortableDateTimePattern getter method should return correct value for InvariantInfo");
-
-        try
-        {
-            retVal = VerificationHelper(DateTimeFormatInfo.InvariantInfo, "yyyy'-'MM'-'dd HH':'mm':'ss'Z'", "001.1") && retVal;
-            retVal = VerificationHelper(new CultureInfo("en-us").DateTimeFormat, "yyyy'-'MM'-'dd HH':'mm':'ss'Z'", "001.2") && retVal;
-			try
-			{
-				retVal = VerificationHelper(new CultureInfo("ja-jp").DateTimeFormat, "yyyy'-'MM'-'dd HH':'mm':'ss'Z'", "001.3") && retVal;
-			} catch (ArgumentException)
-			{
-				TestLibrary.TestFramework.LogInformation("East Asian Languages are not installed. Skipping Japanese culture test(s).");
-				retVal = retVal && true;
-			}
-
-            retVal = VerificationHelper(new CultureInfo("fr-fr").DateTimeFormat, "yyyy'-'MM'-'dd HH':'mm':'ss'Z'", "001.4") && retVal;
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        DateTimeFormatInfoUniversalSortableDateTimePattern test = new DateTimeFormatInfoUniversalSortableDateTimePattern();
-
-        TestLibrary.TestFramework.BeginTestCase("DateTimeFormatInfoUniversalSortableDateTimePattern");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    #region Private Methods
-    private bool VerificationHelper(DateTimeFormatInfo info, string expected, string errorno)
-    {
-        bool retval = true;
-
-        string actual = info.UniversalSortableDateTimePattern;
-        if (actual != expected)
-        {
-            TestLibrary.TestFramework.LogError(errorno, "Call UniversalSortableDateTimePattern returns wrong value");
-            TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual = " + actual + ", expected = " + expected);
-            retval = false;
-        }
-
-        return retval;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStyleAllowInnerWhite.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStyleAllowInnerWhite.csproj
deleted file mode 100644
index 1225c341db..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStyleAllowInnerWhite.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimestyleallowinnerwhite.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesAdjustToUniversal.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesAdjustToUniversal.csproj
deleted file mode 100644
index 21dc7910ff..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesAdjustToUniversal.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimestylesadjusttouniversal.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesAllowLeadingWhite.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesAllowLeadingWhite.csproj
deleted file mode 100644
index d089b55476..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesAllowLeadingWhite.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimestylesallowleadingwhite.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesAllowTrailingWhite.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesAllowTrailingWhite.csproj
deleted file mode 100644
index 527f8d53a0..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesAllowTrailingWhite.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimestylesallowtrailingwhite.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesAllowWhiteSpaces.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesAllowWhiteSpaces.csproj
deleted file mode 100644
index fd2745ef04..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesAllowWhiteSpaces.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimestylesallowwhitespaces.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesAssumeLocal.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesAssumeLocal.csproj
deleted file mode 100644
index 7765ed7bac..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesAssumeLocal.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimestylesassumelocal.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesAssumeUniversal.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesAssumeUniversal.csproj
deleted file mode 100644
index d9fc1407f2..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesAssumeUniversal.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimestylesassumeuniversal.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesNoCurrentDateDefault.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesNoCurrentDateDefault.csproj
deleted file mode 100644
index e8bb7e44b7..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesNoCurrentDateDefault.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimestylesnocurrentdatedefault.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesNone.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesNone.csproj
deleted file mode 100644
index de31176a6a..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesNone.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimestylesnone.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesRoundTripKind.csproj b/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesRoundTripKind.csproj
deleted file mode 100644
index c0ccab739e..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/DateTimeStylesRoundTripKind.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimestylesroundtripkind.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestyleallowinnerwhite.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestyleallowinnerwhite.cs
deleted file mode 100644
index bf57876930..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestyleallowinnerwhite.cs
+++ /dev/null
@@ -1,73 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.DateTimeStyles.AllowInnerWhite
-///</summary>
-
-public class DateTimeStylesAllowInnerWhite
-{
-
-    public static int Main()
-    {
-        DateTimeStylesAllowInnerWhite testObj = new DateTimeStylesAllowInnerWhite();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.Globalization.DateTimeStyles.AllowInnerWhite");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        UInt64 expectedValue = 0x00000004;
-        UInt64 actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get DateTimeStyles.AllowInnerWhite");
-        try
-        {
-            actualValue = (UInt64)DateTimeStyles.AllowInnerWhite;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesadjusttouniversal.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesadjusttouniversal.cs
deleted file mode 100644
index e4201821da..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesadjusttouniversal.cs
+++ /dev/null
@@ -1,73 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.DateTimeStyles.AdjustToUniversal
-///</summary>
-
-public class DateTimeStylesAdjustToUniversal
-{
-
-    public static int Main()
-    {
-        DateTimeStylesAdjustToUniversal testObj = new DateTimeStylesAdjustToUniversal();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.Globalization.DateTimeStyles.AdjustToUniversal");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        UInt64 expectedValue = 0x00000010;
-        UInt64 actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get DateTimeStyles.AdjustToUniversal");
-        try
-        {
-            actualValue = (UInt64)DateTimeStyles.AdjustToUniversal;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesallowleadingwhite.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesallowleadingwhite.cs
deleted file mode 100644
index c0623b12fe..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesallowleadingwhite.cs
+++ /dev/null
@@ -1,73 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.DateTimeStyles.AllowLeadingWhite
-///</summary>
-
-public class DateTimeStylesAllowLeadingWhite
-{
-
-    public static int Main()
-    {
-        DateTimeStylesAllowLeadingWhite testObj = new DateTimeStylesAllowLeadingWhite();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.Globalization.DateTimeStyles.AllowLeadingWhite");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        UInt64 expectedValue = 0x00000001;
-        UInt64 actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get DateTimeStyles.AllowLeadingWhite");
-        try
-        {
-            actualValue = (UInt64)DateTimeStyles.AllowLeadingWhite;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesallowtrailingwhite.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesallowtrailingwhite.cs
deleted file mode 100644
index f2600b0098..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesallowtrailingwhite.cs
+++ /dev/null
@@ -1,73 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.DateTimeStyles.AllowTrailingWhite
-///</summary>
-
-public class DateTimeStylesAllowTrailingWhite
-{
-
-    public static int Main()
-    {
-        DateTimeStylesAllowTrailingWhite testObj = new DateTimeStylesAllowTrailingWhite();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.Globalization.DateTimeStyles.AllowTrailingWhite");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        UInt64 expectedValue = 0x00000002;
-        UInt64 actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get DateTimeStyles.AllowTrailingWhite");
-        try
-        {
-            actualValue = (UInt64)DateTimeStyles.AllowTrailingWhite;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesallowwhitespaces.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesallowwhitespaces.cs
deleted file mode 100644
index 6abb682e4e..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesallowwhitespaces.cs
+++ /dev/null
@@ -1,73 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.DateTimeStyles.AllowWhiteSpaces
-///</summary>
-
-public class DateTimeStylesAllowWhiteSpaces
-{
-
-    public static int Main()
-    {
-        DateTimeStylesAllowWhiteSpaces testObj = new DateTimeStylesAllowWhiteSpaces();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.Globalization.DateTimeStyles.AllowWhiteSpaces");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        UInt64 expectedValue = 0x00000001 | 0x00000002 | 0x00000004;
-        UInt64 actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get DateTimeStyles.AllowWhiteSpaces");
-        try
-        {
-            actualValue = (UInt64)DateTimeStyles.AllowWhiteSpaces;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesassumelocal.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesassumelocal.cs
deleted file mode 100644
index 85d5ec4d4c..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesassumelocal.cs
+++ /dev/null
@@ -1,73 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.DateTimeStyles.AssumeLocal
-///</summary>
-
-public class DateTimeStylesAssumeLocal
-{
-
-    public static int Main()
-    {
-        DateTimeStylesAssumeLocal testObj = new DateTimeStylesAssumeLocal();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.Globalization.DateTimeStyles.AssumeLocal");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        UInt64 expectedValue = 0x00000020;
-        UInt64 actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get DateTimeStyles.AssumeLocal");
-        try
-        {
-            actualValue = (UInt64)DateTimeStyles.AssumeLocal;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesassumeuniversal.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesassumeuniversal.cs
deleted file mode 100644
index bf4460bd20..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesassumeuniversal.cs
+++ /dev/null
@@ -1,73 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.DateTimeStyles.AssumeUniversal
-///</summary>
-
-public class DateTimeStylesAssumeUniversal
-{
-
-    public static int Main()
-    {
-        DateTimeStylesAssumeUniversal testObj = new DateTimeStylesAssumeUniversal();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.Globalization.DateTimeStyles.AssumeUniversal");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        UInt64 expectedValue = 0x00000040;
-        UInt64 actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get DateTimeStyles.AssumeUniversal");
-        try
-        {
-            actualValue = (UInt64)DateTimeStyles.AssumeUniversal;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesnocurrentdatedefault.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesnocurrentdatedefault.cs
deleted file mode 100644
index b80b871e45..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesnocurrentdatedefault.cs
+++ /dev/null
@@ -1,73 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.DateTimeStyles.NoCurrentDateDefault
-///</summary>
-
-public class DateTimeStylesNoCurrentDateDefault
-{
-
-    public static int Main()
-    {
-        DateTimeStylesNoCurrentDateDefault testObj = new DateTimeStylesNoCurrentDateDefault();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.Globalization.DateTimeStyles.NoCurrentDateDefault");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        UInt64 expectedValue = 0x00000008;
-        UInt64 actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get DateTimeStyles.NoCurrentDateDefault");
-        try
-        {
-            actualValue = (UInt64)DateTimeStyles.NoCurrentDateDefault;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesnone.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesnone.cs
deleted file mode 100644
index 300f379e0a..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesnone.cs
+++ /dev/null
@@ -1,73 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.DateTimeStyles.None
-///</summary>
-
-public class DateTimeStylesNone
-{
-
-    public static int Main()
-    {
-        DateTimeStylesNone testObj = new DateTimeStylesNone();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.Globalization.DateTimeStyles.None");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        UInt64 expectedValue = 0x00000000;
-        UInt64 actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get DateTimeStyles.None");
-        try
-        {
-            actualValue = (UInt64)DateTimeStyles.None;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesroundtripkind.cs b/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesroundtripkind.cs
deleted file mode 100644
index 652fa65906..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/datetimestyles/datetimestylesroundtripkind.cs
+++ /dev/null
@@ -1,73 +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.
-using System;
-using System.Globalization;
-
-///<summary>
-///System.Globalization.DateTimeStyles.RoundtripKind
-///</summary>
-
-public class DateTimeStylesRoundtripKind
-{
-
-    public static int Main()
-    {
-        DateTimeStylesRoundtripKind testObj = new DateTimeStylesRoundtripKind();
-        TestLibrary.TestFramework.BeginTestCase("for property of System.Globalization.DateTimeStyles.RoundtripKind");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-
-
-    #region Test Logic
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        UInt64 expectedValue = 0x00000080;
-        UInt64 actualValue;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1:get DateTimeStyles.RoundtripKind");
-        try
-        {
-            actualValue = (UInt64)DateTimeStyles.RoundtripKind;
-
-            if (expectedValue != actualValue)
-            {
-                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/NumberFormatInfoClone.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/NumberFormatInfoClone.csproj
deleted file mode 100644
index 27641af31b..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/NumberFormatInfoClone.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberformatinfoclone.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/NumberFormatInfoCtor.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/NumberFormatInfoCtor.csproj
deleted file mode 100644
index 1c25e99ceb..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/NumberFormatInfoCtor.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberformatinfoctor.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/NumberFormatInfoCurrencyDecimalSeparator.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/NumberFormatInfoCurrencyDecimalSeparator.csproj
deleted file mode 100644
index 775795eac5..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/NumberFormatInfoCurrencyDecimalSeparator.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberformatinfocurrencydecimalseparator.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/NumberFormatInfoCurrencyGroupSeparator.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/NumberFormatInfoCurrencyGroupSeparator.csproj
deleted file mode 100644
index 9e52b952fb..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/NumberFormatInfoCurrencyGroupSeparator.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberformatinfocurrencygroupseparator.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/NumberFormatInfoGetFormat.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/NumberFormatInfoGetFormat.csproj
deleted file mode 100644
index d5ea727124..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/NumberFormatInfoGetFormat.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberformatinfogetformat.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/NumberFormatInfoGetInstance.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/NumberFormatInfoGetInstance.csproj
deleted file mode 100644
index c686c889b3..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/NumberFormatInfoGetInstance.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberformatinfogetinstance.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/NumberFormatInfoReadOnly.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/NumberFormatInfoReadOnly.csproj
deleted file mode 100644
index 2e54d88df2..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/NumberFormatInfoReadOnly.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberformatinforeadonly.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/numberformatinfoclone.cs b/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/numberformatinfoclone.cs
deleted file mode 100644
index d866b7c6b1..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/numberformatinfoclone.cs
+++ /dev/null
@@ -1,104 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// Clone
-/// </summary>
-
-public class NumberFormatInfoClone
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        // retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify method Clone .");
-
-        try
-        {
-            NumberFormatInfo nfi1 = new NumberFormatInfo();
-            NumberFormatInfo nfi2 = (NumberFormatInfo)nfi1.Clone();
-
-            if (!nfi1.Equals(nfi2) && nfi1.GetHashCode() == nfi2.GetHashCode())
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Method Clone Err .");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: ");
-
-    //    try
-    //    {
-    //          //
-    //          // Add your test logic here
-    //          //
-    //    }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e);
-    //        TestLibrary.TestFramework.LogInformation(e.StackTrace);
-    //        retVal = false;
-    //    }
-
-    //    return retVal;
-    //}
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberFormatInfoClone test = new NumberFormatInfoClone();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberFormatInfoClone");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/numberformatinfoctor.cs b/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/numberformatinfoctor.cs
deleted file mode 100644
index 807163628a..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/numberformatinfoctor.cs
+++ /dev/null
@@ -1,103 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// System.Globalization.NumberFormatInfo
-/// </summary>
-
-public class NumberFormatInfoCtor
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        // retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify Ctor .");
-
-        try
-        {
-            NumberFormatInfo nfi = new NumberFormatInfo();
-
-            if (nfi == null)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Failed to instance a NumberFormatInfo type .");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: ");
-
-    //    try
-    //    {
-    //          //
-    //          // Add your test logic here
-    //          //
-    //    }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e);
-    //        TestLibrary.TestFramework.LogInformation(e.StackTrace);
-    //        retVal = false;
-    //    }
-
-    //    return retVal;
-    //}
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberFormatInfoCtor test = new NumberFormatInfoCtor();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberFormatInfoCtor");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/numberformatinfocurrencydecimalseparator.cs b/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/numberformatinfocurrencydecimalseparator.cs
deleted file mode 100644
index 716b097c78..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/numberformatinfocurrencydecimalseparator.cs
+++ /dev/null
@@ -1,193 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// CurrencyDecimalSeparator
-/// </summary>
-
-public class NumberFormatInfoCurrencyDecimalSeparator
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-        retVal = NegTest2() && retVal;
-        retVal = NegTest3() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify default value of property CurrencyDecimalSeparator .");
-
-        try
-        {
-            NumberFormatInfo nfi = new NumberFormatInfo();
-
-            if (nfi.CurrencyDecimalSeparator!=".")
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Property CurrencyDecimalSeparator Err .");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest2: Verify set value of property CurrencyDecimalSeparator .");
-
-        try
-        {
-            string testStr = "testStr";
-            NumberFormatInfo nfi = new NumberFormatInfo();
-            nfi.CurrencyDecimalSeparator = testStr;
-
-            if (nfi.CurrencyDecimalSeparator != testStr)
-            {
-                TestLibrary.TestFramework.LogError("002.1", "Property CurrencyDecimalSeparator Err .");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    public bool NegTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: ArgumentNullException is not thrown.");
-
-        try
-        {
-            string testStr = null;
-            NumberFormatInfo nfi = new NumberFormatInfo();
-            nfi.CurrencyDecimalSeparator = testStr;
-
-            TestLibrary.TestFramework.LogError("101.1", "ArgumentNullException is not thrown.");
-            retVal = false;
-        }
-        catch (ArgumentNullException) { }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("101.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest2: InvalidOperationException is not thrown.");
-
-        try
-        {
-            string testStr = "testStr";
-            NumberFormatInfo nfi = new NumberFormatInfo();
-            NumberFormatInfo nfiReadOnly = NumberFormatInfo.ReadOnly(nfi);
-            nfiReadOnly.CurrencyDecimalSeparator = testStr;
-
-            TestLibrary.TestFramework.LogError("102.1", "InvalidOperationException is not thrown.");
-            retVal = false;
-        }
-        catch (InvalidOperationException) { }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("102.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest3: ArgumentException is not thrown.");
-
-        try
-        {
-            string testStr = "";
-            NumberFormatInfo nfi = new NumberFormatInfo();
-            NumberFormatInfo nfiReadOnly = NumberFormatInfo.ReadOnly(nfi);
-            nfi.CurrencyDecimalSeparator = testStr;
-
-            TestLibrary.TestFramework.LogError("103.1", "ArgumentException is not thrown.");
-            retVal = false;
-        }
-        catch (ArgumentException) { }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("103.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberFormatInfoCurrencyDecimalSeparator test = new NumberFormatInfoCurrencyDecimalSeparator();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberFormatInfoCurrencyDecimalSeparator");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/numberformatinfocurrencygroupseparator.cs b/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/numberformatinfocurrencygroupseparator.cs
deleted file mode 100644
index fe75bc04de..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/numberformatinfocurrencygroupseparator.cs
+++ /dev/null
@@ -1,165 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// CurrencyGroupSeparator
-/// </summary>
-
-public class NumberFormatInfoCurrencyGroupSeparator
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-        retVal = NegTest2() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify default value of property CurrencyGroupSeparator .");
-
-        try
-        {
-            NumberFormatInfo nfi = new NumberFormatInfo();
-
-            if (nfi.CurrencyGroupSeparator != ",")
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Property CurrencyGroupSeparator Err .");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest2: Verify set value of property CurrencyGroupSeparator .");
-
-        try
-        {
-            string testStr = "testStr";
-            NumberFormatInfo nfi = new NumberFormatInfo();
-            nfi.CurrencyGroupSeparator = testStr;
-
-            if (nfi.CurrencyGroupSeparator != testStr)
-            {
-                TestLibrary.TestFramework.LogError("002.1", "Property CurrencyGroupSeparator Err .");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    public bool NegTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: ArgumentNullException is not thrown.");
-
-        try
-        {
-            string testStr = null;
-            NumberFormatInfo nfi = new NumberFormatInfo();
-            nfi.CurrencyGroupSeparator = testStr;
-
-            TestLibrary.TestFramework.LogError("101.1", "ArgumentNullException is not thrown.");
-            retVal = false;
-        }
-        catch (ArgumentNullException) { }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("101.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest2: InvalidOperationException is not thrown.");
-
-        try
-        {
-            string testStr = "testStr";
-            NumberFormatInfo nfi = new NumberFormatInfo();
-            NumberFormatInfo nfiReadOnly = NumberFormatInfo.ReadOnly(nfi);
-            nfiReadOnly.CurrencyGroupSeparator = testStr;
-
-            TestLibrary.TestFramework.LogError("102.1", "InvalidOperationException is not thrown.");
-            retVal = false;
-        }
-        catch (InvalidOperationException) { }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("102.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberFormatInfoCurrencyGroupSeparator test = new NumberFormatInfoCurrencyGroupSeparator();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberFormatInfoCurrencyGroupSeparator");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/numberformatinfogetformat.cs b/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/numberformatinfogetformat.cs
deleted file mode 100644
index ee321af124..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/numberformatinfogetformat.cs
+++ /dev/null
@@ -1,137 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// GetFormat(System.Type)
-/// </summary>
-
-public class NumberFormatInfoGetFormat
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify method GetFormat when arg is a type of NumberFormatInfo .");
-
-        try
-        {
-            NumberFormatInfo nfi = new NumberFormatInfo();
-            Type formatType = typeof(NumberFormatInfo);
-            object obj = nfi.GetFormat(formatType);
-
-            bool testVerify = obj is NumberFormatInfo;
-
-            if (testVerify != true)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Method GetFormat .");
-                retVal = false;
-            }
-    
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest2: Verify method GetFormat when arg is not a type of NumberFormatInfo .");
-
-        try
-        {
-            NumberFormatInfo nfi = new NumberFormatInfo();
-            Type formatType = typeof(object);
-
-            if (nfi.GetFormat(formatType) != null)
-            {
-                TestLibrary.TestFramework.LogError("002.1", "Failed to instance a NumberFormatInfo type .");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: ");
-
-    //    try
-    //    {
-    //          //
-    //          // Add your test logic here
-    //          //
-    //    }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e);
-    //        TestLibrary.TestFramework.LogInformation(e.StackTrace);
-    //        retVal = false;
-    //    }
-
-    //    return retVal;
-    //}
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberFormatInfoGetFormat test = new NumberFormatInfoGetFormat();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberFormatInfoGetFormat");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/numberformatinfogetinstance.cs b/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/numberformatinfogetinstance.cs
deleted file mode 100644
index 2de248c6d4..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/numberformatinfogetinstance.cs
+++ /dev/null
@@ -1,105 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// GetInstance(System.IFormatProvider)
-/// </summary>
-
-public class NumberFormatInfoGetInstance
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        // retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify method GetInstance .");
-
-        try
-        {
-            CultureInfo ci = new CultureInfo("fr-FR");
-            NumberFormatInfo nfi = NumberFormatInfo.GetInstance(ci);
-
-            if (nfi == null)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Method GetInstance Err .");
-                retVal = false;
-            }
-    
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: ");
-
-    //    try
-    //    {
-    //          //
-    //          // Add your test logic here
-    //          //
-    //    }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e);
-    //        TestLibrary.TestFramework.LogInformation(e.StackTrace);
-    //        retVal = false;
-    //    }
-
-    //    return retVal;
-    //}
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberFormatInfoGetInstance test = new NumberFormatInfoGetInstance();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberFormatInfoGetInstance");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/numberformatinforeadonly.cs b/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/numberformatinforeadonly.cs
deleted file mode 100644
index 51f63c013e..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberformatinfo/numberformatinforeadonly.cs
+++ /dev/null
@@ -1,107 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// ReadOnly(System.Globalization.NumberFormatInfo)
-/// </summary>
-
-public class NumberFormatInfoReadOnly
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify method ReadOnly .");
-
-        try
-        {
-            NumberFormatInfo nfi = new NumberFormatInfo();
-            NumberFormatInfo nfiReadOnly = NumberFormatInfo.ReadOnly(nfi);
-
-            if (nfiReadOnly.IsReadOnly != true)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Method ReadOnly Err .");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    public bool NegTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: ArgumentNullException is not thrown.");
-
-        try
-        {
-            NumberFormatInfo nfi = null;
-            NumberFormatInfo nfiReadOnly = NumberFormatInfo.ReadOnly(nfi);
-
-            TestLibrary.TestFramework.LogError("101.1", "ArgumentNullException is not thrown.");
-            retVal = false;
-        }
-        catch (ArgumentNullException) { }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("101.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberFormatInfoReadOnly test = new NumberFormatInfoReadOnly();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberFormatInfoReadOnly");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowCurrencySymbol.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowCurrencySymbol.csproj
deleted file mode 100644
index 1079ef3563..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowCurrencySymbol.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberstylesallowcurrencysymbol.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowDecimalPoint.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowDecimalPoint.csproj
deleted file mode 100644
index 52a9defb6e..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowDecimalPoint.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberstylesallowdecimalpoint.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowExponent.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowExponent.csproj
deleted file mode 100644
index ebcb0a555d..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowExponent.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberstylesallowexponent.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowHexSpecifier.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowHexSpecifier.csproj
deleted file mode 100644
index 012ec8e8af..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowHexSpecifier.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberstylesallowhexspecifier.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowLeadingSign.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowLeadingSign.csproj
deleted file mode 100644
index 59202092f6..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowLeadingSign.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberstylesallowleadingsign.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowLeadingWhite.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowLeadingWhite.csproj
deleted file mode 100644
index 11e9d6956a..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowLeadingWhite.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberstylesallowleadingwhite.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowParentheses.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowParentheses.csproj
deleted file mode 100644
index 23f25cef0d..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowParentheses.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberstylesallowparentheses.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowThousands.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowThousands.csproj
deleted file mode 100644
index e3b9323edd..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowThousands.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberstylesallowthousands.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowTrailingSign.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowTrailingSign.csproj
deleted file mode 100644
index c2707d3dc7..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowTrailingSign.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberstylesallowtrailingsign.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowTrailingWhite.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowTrailingWhite.csproj
deleted file mode 100644
index 1b4bac079e..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAllowTrailingWhite.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberstylesallowtrailingwhite.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAny.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAny.csproj
deleted file mode 100644
index cc74514d8b..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesAny.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberstylesany.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesCurrency.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesCurrency.csproj
deleted file mode 100644
index acca22ad3b..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesCurrency.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberstylescurrency.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesFloat.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesFloat.csproj
deleted file mode 100644
index 331c18860d..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesFloat.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberstylesfloat.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesHexNumber.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesHexNumber.csproj
deleted file mode 100644
index d5ee79e71d..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesHexNumber.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberstyleshexnumber.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesInteger.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesInteger.csproj
deleted file mode 100644
index c78a6d0071..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesInteger.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberstylesinteger.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesNone.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesNone.csproj
deleted file mode 100644
index e8ce455b93..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesNone.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberstylesnone.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesNumber.csproj b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesNumber.csproj
deleted file mode 100644
index 0bce942aef..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/NumberStylesNumber.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="numberstylesnumber.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowcurrencysymbol.cs b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowcurrencysymbol.cs
deleted file mode 100644
index b9c3873af7..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowcurrencysymbol.cs
+++ /dev/null
@@ -1,105 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// AllowCurrencySymbol [v-jianq]
-/// </summary>
-
-public class NumberStylesAllowCurrencySymbol
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        // retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify value of NumberStyles.AllowCurrencySymbol .");
-
-        try
-        {
-            int expected = 0x00000100;
-            int actual = (int)NumberStyles.AllowCurrencySymbol;
-
-            if (actual != expected)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Value of NumberStyles.AllowCurrencySymbol Err .");
-                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual = " + actual + ", expected = " + expected);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: ");
-
-    //    try
-    //    {
-    //          //
-    //          // Add your test logic here
-    //          //
-    //    }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e);
-    //        TestLibrary.TestFramework.LogInformation(e.StackTrace);
-    //        retVal = false;
-    //    }
-
-    //    return retVal;
-    //}
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberStylesAllowCurrencySymbol test = new NumberStylesAllowCurrencySymbol();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberStylesAllowCurrencySymbol");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowdecimalpoint.cs b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowdecimalpoint.cs
deleted file mode 100644
index 10ee6edb6c..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowdecimalpoint.cs
+++ /dev/null
@@ -1,105 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// AllowDecimalPoint [v-jianq]
-/// </summary>
-
-public class NumberStylesAllowDecimalPoint
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        // retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify value of NumberStyles.AllowDecimalPoint .");
-
-        try
-        {
-            int expected = 0x00000020;
-            int actual = (int)NumberStyles.AllowDecimalPoint;
-
-            if (actual != expected)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Value of NumberStyles.AllowDecimalPoint Err .");
-                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual = " + actual + ", expected = " + expected);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: ");
-
-    //    try
-    //    {
-    //          //
-    //          // Add your test logic here
-    //          //
-    //    }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e);
-    //        TestLibrary.TestFramework.LogInformation(e.StackTrace);
-    //        retVal = false;
-    //    }
-
-    //    return retVal;
-    //}
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberStylesAllowDecimalPoint test = new NumberStylesAllowDecimalPoint();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberStylesAllowDecimalPoint");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowexponent.cs b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowexponent.cs
deleted file mode 100644
index 26d6b387cc..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowexponent.cs
+++ /dev/null
@@ -1,105 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// AllowExponent [v-jianq]
-/// </summary>
-
-public class NumberStylesAllowExponent
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        // retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify value of NumberStyles.AllowExponent .");
-
-        try
-        {
-            int expected = 0x00000080;
-            int actual = (int)NumberStyles.AllowExponent;
-
-            if (actual != expected)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Value of NumberStyles.AllowExponent Err .");
-                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual = " + actual + ", expected = " + expected);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: ");
-
-    //    try
-    //    {
-    //          //
-    //          // Add your test logic here
-    //          //
-    //    }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e);
-    //        TestLibrary.TestFramework.LogInformation(e.StackTrace);
-    //        retVal = false;
-    //    }
-
-    //    return retVal;
-    //}
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberStylesAllowExponent test = new NumberStylesAllowExponent();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberStylesAllowExponent");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowhexspecifier.cs b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowhexspecifier.cs
deleted file mode 100644
index e366e878f7..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowhexspecifier.cs
+++ /dev/null
@@ -1,105 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// AllowHexSpecifier [v-jianq]
-/// </summary>
-
-public class NumberStylesAllowHexSpecifier
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        // retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify value of NumberStyles.AllowHexSpecifier .");
-
-        try
-        {
-            int expected = 0x00000200;
-            int actual = (int)NumberStyles.AllowHexSpecifier;
-
-            if (actual != expected)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Value of NumberStyles.AllowHexSpecifier Err .");
-                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual = " + actual + ", expected = " + expected);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: ");
-
-    //    try
-    //    {
-    //          //
-    //          // Add your test logic here
-    //          //
-    //    }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e);
-    //        TestLibrary.TestFramework.LogInformation(e.StackTrace);
-    //        retVal = false;
-    //    }
-
-    //    return retVal;
-    //}
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberStylesAllowHexSpecifier test = new NumberStylesAllowHexSpecifier();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberStylesAllowHexSpecifier");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowleadingsign.cs b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowleadingsign.cs
deleted file mode 100644
index 197173aac5..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowleadingsign.cs
+++ /dev/null
@@ -1,105 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// AllowLeadingSign [v-jianq]
-/// </summary>
-
-public class NumberStylesAllowLeadingSign
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        // retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify value of NumberStyles.AllowLeadingSign .");
-
-        try
-        {
-            int expected = 0x00000004;
-            int actual = (int)NumberStyles.AllowLeadingSign;
-
-            if (actual != expected)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Value of NumberStyles.AllowLeadingSign Err .");
-                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual = " + actual + ", expected = " + expected);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: ");
-
-    //    try
-    //    {
-    //          //
-    //          // Add your test logic here
-    //          //
-    //    }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e);
-    //        TestLibrary.TestFramework.LogInformation(e.StackTrace);
-    //        retVal = false;
-    //    }
-
-    //    return retVal;
-    //}
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberStylesAllowLeadingSign test = new NumberStylesAllowLeadingSign();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberStylesAllowLeadingSign");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowleadingwhite.cs b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowleadingwhite.cs
deleted file mode 100644
index 3b9af11a3d..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowleadingwhite.cs
+++ /dev/null
@@ -1,105 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// AllowLeadingWhite [v-jianq]
-/// </summary>
-
-public class NumberStylesAllowLeadingWhite
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        // retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify value of NumberStyles.AllowLeadingWhite .");
-
-        try
-        {
-            int expected = 0x00000001;
-            int actual = (int)NumberStyles.AllowLeadingWhite;
-
-            if (actual != expected)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Value of NumberStyles.AllowLeadingWhite Err .");
-                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual = " + actual + ", expected = " + expected);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: ");
-
-    //    try
-    //    {
-    //          //
-    //          // Add your test logic here
-    //          //
-    //    }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e);
-    //        TestLibrary.TestFramework.LogInformation(e.StackTrace);
-    //        retVal = false;
-    //    }
-
-    //    return retVal;
-    //}
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberStylesAllowLeadingWhite test = new NumberStylesAllowLeadingWhite();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberStylesAllowLeadingWhite");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowparentheses.cs b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowparentheses.cs
deleted file mode 100644
index 7bbf7ee6bb..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowparentheses.cs
+++ /dev/null
@@ -1,105 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// AllowParentheses [v-jianq]
-/// </summary>
-
-public class NumberStylesAllowParentheses
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        // retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify value of NumberStyles.AllowParentheses .");
-
-        try
-        {
-            int expected = 0x00000010;
-            int actual = (int)NumberStyles.AllowParentheses;
-
-            if (actual != expected)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Value of NumberStyles.AllowParentheses Err .");
-                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual = " + actual + ", expected = " + expected);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: ");
-
-    //    try
-    //    {
-    //          //
-    //          // Add your test logic here
-    //          //
-    //    }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e);
-    //        TestLibrary.TestFramework.LogInformation(e.StackTrace);
-    //        retVal = false;
-    //    }
-
-    //    return retVal;
-    //}
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberStylesAllowParentheses test = new NumberStylesAllowParentheses();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberStylesAllowParentheses");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowthousands.cs b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowthousands.cs
deleted file mode 100644
index 8f83b564a4..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowthousands.cs
+++ /dev/null
@@ -1,105 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// AllowThousands [v-jianq]
-/// </summary>
-
-public class NumberStylesAllowThousands
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        // retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify value of NumberStyles.AllowThousands .");
-
-        try
-        {
-            int expected = 0x00000040;
-            int actual = (int)NumberStyles.AllowThousands;
-
-            if (actual != expected)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Value of NumberStyles.AllowThousands Err .");
-                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual = " + actual + ", expected = " + expected);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: ");
-
-    //    try
-    //    {
-    //          //
-    //          // Add your test logic here
-    //          //
-    //    }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e);
-    //        TestLibrary.TestFramework.LogInformation(e.StackTrace);
-    //        retVal = false;
-    //    }
-
-    //    return retVal;
-    //}
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberStylesAllowThousands test = new NumberStylesAllowThousands();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberStylesAllowThousands");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowtrailingsign.cs b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowtrailingsign.cs
deleted file mode 100644
index 5153b20fbe..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowtrailingsign.cs
+++ /dev/null
@@ -1,105 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// AllowTrailingSign [v-jianq]
-/// </summary>
-
-public class NumberStylesAllowTrailingSign
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        // retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify value of NumberStyles.AllowTrailingSign .");
-
-        try
-        {
-            int expected = 0x00000008;
-            int actual = (int)NumberStyles.AllowTrailingSign;
-
-            if (actual != expected)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Value of NumberStyles.AllowTrailingSign Err .");
-                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual = " + actual + ", expected = " + expected);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: ");
-
-    //    try
-    //    {
-    //          //
-    //          // Add your test logic here
-    //          //
-    //    }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e);
-    //        TestLibrary.TestFramework.LogInformation(e.StackTrace);
-    //        retVal = false;
-    //    }
-
-    //    return retVal;
-    //}
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberStylesAllowTrailingSign test = new NumberStylesAllowTrailingSign();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberStylesAllowTrailingSign");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowtrailingwhite.cs b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowtrailingwhite.cs
deleted file mode 100644
index fda107c24b..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesallowtrailingwhite.cs
+++ /dev/null
@@ -1,105 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// AllowTrailingWhite [v-jianq]
-/// </summary>
-
-public class NumberStylesAllowTrailingWhite
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        // retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify value of NumberStyles.AllowTrailingWhite .");
-
-        try
-        {
-            int expected = 0x00000002;
-            int actual = (int)NumberStyles.AllowTrailingWhite;
-
-            if (actual != expected)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Value of NumberStyles.AllowTrailingWhite Err .");
-                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual = " + actual + ", expected = " + expected);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: ");
-
-    //    try
-    //    {
-    //          //
-    //          // Add your test logic here
-    //          //
-    //    }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e);
-    //        TestLibrary.TestFramework.LogInformation(e.StackTrace);
-    //        retVal = false;
-    //    }
-
-    //    return retVal;
-    //}
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberStylesAllowTrailingWhite test = new NumberStylesAllowTrailingWhite();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberStylesAllowTrailingWhite");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesany.cs b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesany.cs
deleted file mode 100644
index 88da563283..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesany.cs
+++ /dev/null
@@ -1,125 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// Any [v-jianq]
-/// </summary>
-
-public class NumberStylesAny
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        // retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify value of NumberStyles.Any .");
-
-        try
-        {
-            int  AllowLeadingWhite = 0x00000001,
-
-                 AllowTrailingWhite = 0x00000002,
-
-                 AllowLeadingSign = 0x00000004,
-
-                 AllowTrailingSign = 0x00000008,
-
-                 AllowParentheses = 0x00000010,
-
-                 AllowDecimalPoint = 0x00000020,
-
-                 AllowThousands = 0x00000040,
-
-                 AllowExponent = 0x00000080,
-
-                 AllowCurrencySymbol = 0x00000100;
-
-            int expected = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign | AllowTrailingSign |
-                           AllowParentheses | AllowDecimalPoint | AllowThousands | AllowCurrencySymbol | AllowExponent;
-
-            int actual = (int)NumberStyles.Any;
-
-            if (actual != expected)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Value of NumberStyles.Any Err .");
-                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual = " + actual + ", expected = " + expected);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: ");
-
-    //    try
-    //    {
-    //          //
-    //          // Add your test logic here
-    //          //
-    //    }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e);
-    //        TestLibrary.TestFramework.LogInformation(e.StackTrace);
-    //        retVal = false;
-    //    }
-
-    //    return retVal;
-    //}
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberStylesAny test = new NumberStylesAny();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberStylesAny");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylescurrency.cs b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylescurrency.cs
deleted file mode 100644
index a7c053c36b..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylescurrency.cs
+++ /dev/null
@@ -1,124 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// Currency 
-/// </summary>
-
-public class NumberStylesCurrency
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        // retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify value of NumberStyles.Currency .");
-
-        try
-        {
-            int AllowLeadingWhite = 0x00000001,
-
-                AllowTrailingWhite = 0x00000002,
-
-                AllowLeadingSign = 0x00000004,
-
-                AllowTrailingSign = 0x00000008,
-
-                AllowParentheses = 0x00000010,
-
-                AllowDecimalPoint = 0x00000020,
-
-                AllowThousands = 0x00000040,
-
-                AllowCurrencySymbol = 0x00000100;
-
-
-            int expected = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign | AllowTrailingSign |
-                           AllowParentheses | AllowDecimalPoint | AllowThousands | AllowCurrencySymbol;
-
-            int actual = (int)NumberStyles.Currency;
-
-            if (actual != expected)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Value of NumberStyles.Currency Err .");
-                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual = " + actual + ", expected = " + expected);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: ");
-
-    //    try
-    //    {
-    //          //
-    //          // Add your test logic here
-    //          //
-    //    }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e);
-    //        TestLibrary.TestFramework.LogInformation(e.StackTrace);
-    //        retVal = false;
-    //    }
-
-    //    return retVal;
-    //}
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberStylesCurrency test = new NumberStylesCurrency();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberStylesCurrency");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesfloat.cs b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesfloat.cs
deleted file mode 100644
index f7520115c1..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesfloat.cs
+++ /dev/null
@@ -1,119 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// Float
-/// </summary>
-
-public class NumberStylesFloat
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        // retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify value of NumberStyles.Float .");
-
-        try
-        {
-            int AllowLeadingWhite = 0x00000001,
-
-                 AllowTrailingWhite = 0x00000002,
-
-                 AllowLeadingSign = 0x00000004,
-
-                 AllowDecimalPoint = 0x00000020,
-
-                 AllowExponent = 0x00000080;
-
-
-            int expected = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign | 
-                           AllowDecimalPoint | AllowExponent;
-
-            int actual = (int)NumberStyles.Float;
-
-            if (actual != expected)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Value of NumberStyles.Float Err .");
-                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual = " + actual + ", expected = " + expected);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    
-    #endregion
-
-    #region Nagetive Test Cases
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: ");
-
-    //    try
-    //    {
-    //          //
-    //          // Add your test logic here
-    //          //
-    //    }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e);
-    //        TestLibrary.TestFramework.LogInformation(e.StackTrace);
-    //        retVal = false;
-    //    }
-
-    //    return retVal;
-    //}
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberStylesFloat test = new NumberStylesFloat();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberStylesFloat");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstyleshexnumber.cs b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstyleshexnumber.cs
deleted file mode 100644
index ca400c53cb..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstyleshexnumber.cs
+++ /dev/null
@@ -1,112 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// HexNumber [v-jianq]
-/// </summary>
-
-public class NumberStylesHexNumber
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        // retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify value of NumberStyles.HexNumber .");
-
-        try
-        {
-            int  AllowLeadingWhite = 0x00000001,
-
-                 AllowTrailingWhite = 0x00000002,
-
-                 AllowHexSpecifier = 0x00000200;
-
-            int expected = AllowLeadingWhite | AllowTrailingWhite | AllowHexSpecifier;
-
-            int actual = (int)NumberStyles.HexNumber;
-
-            if (actual != expected)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Value of NumberStyles.HexNumber Err .");
-                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual = " + actual + ", expected = " + expected);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: ");
-
-    //    try
-    //    {
-    //          //
-    //          // Add your test logic here
-    //          //
-    //    }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e);
-    //        TestLibrary.TestFramework.LogInformation(e.StackTrace);
-    //        retVal = false;
-    //    }
-
-    //    return retVal;
-    //}
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberStylesHexNumber test = new NumberStylesHexNumber();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberStylesHexNumber");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesinteger.cs b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesinteger.cs
deleted file mode 100644
index 7535463963..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesinteger.cs
+++ /dev/null
@@ -1,111 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// Integer [v-jianq]
-/// </summary>
-
-public class NumberStylesInteger
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        // retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify value of NumberStyles.Integer .");
-
-        try
-        {
-            int  AllowLeadingWhite = 0x00000001,
-
-                 AllowTrailingWhite = 0x00000002,
-
-                 AllowLeadingSign = 0x00000004;
-
-            int expected = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign;
-            int actual = (int)NumberStyles.Integer;
-
-            if (actual != expected)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Value of NumberStyles.Integer Err .");
-                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual = " + actual + ", expected = " + expected);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: ");
-
-    //    try
-    //    {
-    //          //
-    //          // Add your test logic here
-    //          //
-    //    }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e);
-    //        TestLibrary.TestFramework.LogInformation(e.StackTrace);
-    //        retVal = false;
-    //    }
-
-    //    return retVal;
-    //}
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberStylesInteger test = new NumberStylesInteger();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberStylesInteger");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesnone.cs b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesnone.cs
deleted file mode 100644
index 87cb5c7481..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesnone.cs
+++ /dev/null
@@ -1,105 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// None [v-jianq]
-/// </summary>
-
-public class NumberStylesNone
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        // retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify value of NumberStyles.None .");
-
-        try
-        {
-            int expected = 0x00000000;
-            int actual = (int)NumberStyles.None;
-
-            if (actual != expected)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Value of NumberStyles.None Err .");
-                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual = " + actual + ", expected = " + expected);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: ");
-
-    //    try
-    //    {
-    //          //
-    //          // Add your test logic here
-    //          //
-    //    }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e);
-    //        TestLibrary.TestFramework.LogInformation(e.StackTrace);
-    //        retVal = false;
-    //    }
-
-    //    return retVal;
-    //}
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberStylesNone test = new NumberStylesNone();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberStylesNone");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesnumber.cs b/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesnumber.cs
deleted file mode 100644
index 225d458ec3..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/numberstyles/numberstylesnumber.cs
+++ /dev/null
@@ -1,120 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// Number [v-jianq]
-/// </summary>
-
-public class NumberStylesNumber
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        
-        //
-        // TODO: Add your negative test cases here
-        //
-        // TestLibrary.TestFramework.LogInformation("[Negative]");
-        // retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        // Add your scenario description here
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Verify value of NumberStyles.Number .");
-
-        try
-        {
-            int AllowLeadingWhite = 0x00000001,
-
-                 AllowTrailingWhite = 0x00000002,
-
-                 AllowLeadingSign = 0x00000004,
-
-                 AllowTrailingSign = 0x00000008,
-
-                 AllowDecimalPoint = 0x00000020,
-
-                 AllowThousands = 0x00000040;
-
-            int expected = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign | AllowTrailingSign |
-                           AllowDecimalPoint | AllowThousands;
-
-
-            int actual = (int)NumberStyles.Number;
-
-            if (actual != expected)
-            {
-                TestLibrary.TestFramework.LogError("001.1", "Value of NumberStyles.Number Err .");
-                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual = " + actual + ", expected = " + expected);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    //public bool NegTest1()
-    //{
-    //    bool retVal = true;
-
-    //    TestLibrary.TestFramework.BeginScenario("NegTest1: ");
-
-    //    try
-    //    {
-    //          //
-    //          // Add your test logic here
-    //          //
-    //    }
-    //    catch (Exception e)
-    //    {
-    //        TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e);
-    //        TestLibrary.TestFramework.LogInformation(e.StackTrace);
-    //        retVal = false;
-    //    }
-
-    //    return retVal;
-    //}
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        NumberStylesNumber test = new NumberStylesNumber();
-
-        TestLibrary.TestFramework.BeginTestCase("NumberStylesNumber");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/RegionInfoEquals.csproj b/tests/src/CoreMangLib/cti/system/globalization/regioninfo/RegionInfoEquals.csproj
deleted file mode 100644
index 857841b57c..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/RegionInfoEquals.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="regioninfoequals.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/RegionInfoGetHashCode.csproj b/tests/src/CoreMangLib/cti/system/globalization/regioninfo/RegionInfoGetHashCode.csproj
deleted file mode 100644
index 500f7dbb4d..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/RegionInfoGetHashCode.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="regioninfogethashcode.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/RegionInfoISOCurrencySymbol.csproj b/tests/src/CoreMangLib/cti/system/globalization/regioninfo/RegionInfoISOCurrencySymbol.csproj
deleted file mode 100644
index 9c1f5e5957..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/RegionInfoISOCurrencySymbol.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="regioninfoisocurrencysymbol.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/RegionInfoIsMetric.csproj b/tests/src/CoreMangLib/cti/system/globalization/regioninfo/RegionInfoIsMetric.csproj
deleted file mode 100644
index eeef871514..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/RegionInfoIsMetric.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="regioninfoismetric.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/RegionInfoName.csproj b/tests/src/CoreMangLib/cti/system/globalization/regioninfo/RegionInfoName.csproj
deleted file mode 100644
index 19bada9ae4..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/RegionInfoName.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="regioninfoname.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/RegionInfoToString.csproj b/tests/src/CoreMangLib/cti/system/globalization/regioninfo/RegionInfoToString.csproj
deleted file mode 100644
index a0d8a95ab1..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/RegionInfoToString.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="regioninfotostring.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/RegionInfoTwoLetterISORegionName.csproj b/tests/src/CoreMangLib/cti/system/globalization/regioninfo/RegionInfoTwoLetterISORegionName.csproj
deleted file mode 100644
index 4140d72bf3..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/RegionInfoTwoLetterISORegionName.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="regioninfotwoletterisoregionname.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/regioninfoequals.cs b/tests/src/CoreMangLib/cti/system/globalization/regioninfo/regioninfoequals.cs
deleted file mode 100644
index df14b135b2..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/regioninfoequals.cs
+++ /dev/null
@@ -1,133 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// RegionInfo.Equals(Object)
-/// </summary>
-public class RegionInfoEquals
-{
-    public static int Main()
-    {
-        RegionInfoEquals regInfoEquals = new RegionInfoEquals();
-        TestLibrary.TestFramework.BeginTestCase("RegionInfoEquals");
-        if (regInfoEquals.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-		// The RegionInfo constructor will disallow partial names
-        retVal = PosTest4() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Compare two RegionInfo object 1");
-        try
-        {
-            RegionInfo regionInfo1 = new RegionInfo("en-US");
-            RegionInfo regionInfo2 = new RegionInfo("en-US");
-            bool boolVal = regionInfo1.Equals(regionInfo2);
-            if (!boolVal)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is true but the ActualResult is " + boolVal.ToString());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest2:Compare two RegionInfo object 2");
-        try
-        {
-            RegionInfo regionInfo1 = new RegionInfo("en-US");
-            RegionInfo regionInfo2 = new RegionInfo("zh-CN");
-            bool boolVal = regionInfo1.Equals(regionInfo2);
-            if (boolVal)
-            {
-                TestLibrary.TestFramework.LogError("003", "the ExpectResult is false but the ActualResult is " + boolVal.ToString());
-                retVal = false;
-            }
-        }
-		catch (ArgumentException)
-		{
-			TestLibrary.TestFramework.LogInformation("The East Asian Languages are not installed. Skipping test(s)");
-			retVal = true;
-		}
-		catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-	public bool PosTest3() // The RegionInfo constructor will disallow partial names
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest3:Compare two RegionInfo object 3");
-        try
-        {
-            RegionInfo regionInfo1 = new RegionInfo("US");
-            RegionInfo regionInfo2 = new RegionInfo("en-US");
-            bool boolVal = regionInfo1.Equals(regionInfo2);
-            if (boolVal)
-            {
-                TestLibrary.TestFramework.LogError("005", "the ExpectResult is false but the ActualResult is " + boolVal.ToString());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest4()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest4:RegionInfo object compared with not RegionInfo object");
-        try
-        {
-            RegionInfo regionInfo1 = new RegionInfo("en-US");
-            object objVal = new object();
-            bool boolVal = regionInfo1.Equals(objVal);
-            if (boolVal)
-            {
-                TestLibrary.TestFramework.LogError("007", "the ExpectResult is false but the ActualResult is " + boolVal.ToString());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("008", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/regioninfogethashcode.cs b/tests/src/CoreMangLib/cti/system/globalization/regioninfo/regioninfogethashcode.cs
deleted file mode 100644
index 119f94b9f1..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/regioninfogethashcode.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.
-using System;
-using System.Globalization;
-/// <summary>
-/// RegionInfo.GetHashCode()
-/// </summary>
-public class RegionInfoGetHashCode
-{
-    public static int Main()
-    {
-        RegionInfoGetHashCode regInfoGetHashCode = new RegionInfoGetHashCode();
-        TestLibrary.TestFramework.BeginTestCase("RegionInfoGetHashCode");
-        if (regInfoGetHashCode.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Get the hash code of the RegionInfo object 1");
-        try
-        {
-            RegionInfo regionInfo = new RegionInfo("zh-CN");
-            int hashCode = regionInfo.GetHashCode();
-            if (hashCode != regionInfo.Name.GetHashCode())
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is" + regionInfo.Name.GetHashCode() +"but the ActualResult is " + hashCode);
-                retVal = false;
-            }
-        }
-		catch (ArgumentException)
-		{
-			TestLibrary.TestFramework.LogInformation("The East Asian Languages are not installed. Skipping test(s)");
-			retVal = true;
-		}
-		catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest2:Get the hash code of the RegionInfo object 2");
-        try
-        {
-            RegionInfo regionInfo = new RegionInfo("en-US");
-            int hashCode = regionInfo.GetHashCode();
-            if (hashCode != regionInfo.Name.GetHashCode())
-            {
-                TestLibrary.TestFramework.LogError("003", "the ExpectResult is" + regionInfo.Name.GetHashCode() +"but the ActualResult is " + hashCode);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/regioninfoismetric.cs b/tests/src/CoreMangLib/cti/system/globalization/regioninfo/regioninfoismetric.cs
deleted file mode 100644
index b89c74b29e..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/regioninfoismetric.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.
-using System;
-using System.Globalization;
-/// <summary>
-/// RegionInfo.IsMetric
-/// </summary>
-public class RegionInfoIsMetric
-{
-    public static int Main()
-    {
-        RegionInfoIsMetric regInfoIsMetric = new RegionInfoIsMetric();
-        TestLibrary.TestFramework.BeginTestCase("RegionInfoIsMetric");
-        if (regInfoIsMetric.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the property IsMetric in RegionInfo object 1");
-        try
-        {
-            RegionInfo regionInfo = new RegionInfo("en-US");
-            bool boolVal = regionInfo.IsMetric;
-            if (boolVal)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is false but the ActualResult is " + boolVal.ToString());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest2:Return the property IsMetric in RegionInfo object 2");
-        try
-        {
-            RegionInfo regionInfo = new RegionInfo("zh-CN");
-            bool boolVal = regionInfo.IsMetric;
-            if (!boolVal)
-            {
-                TestLibrary.TestFramework.LogError("003", "the ExpectResult is false but the ActualResult is " + boolVal.ToString());
-                retVal = false;
-            }
-        }
-		catch (ArgumentException)
-		{
-			TestLibrary.TestFramework.LogInformation("The East Asian Languages are not installed. Skipping test(s)");
-			retVal = true;
-		}
-		catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/regioninfoisocurrencysymbol.cs b/tests/src/CoreMangLib/cti/system/globalization/regioninfo/regioninfoisocurrencysymbol.cs
deleted file mode 100644
index 47a7e0d0b2..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/regioninfoisocurrencysymbol.cs
+++ /dev/null
@@ -1,153 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// RegionInfo.ISOCurrencySymbol [v-minch]
-/// </summary>
-public class RegionInfoISOCurrencySymbol
-{
-    public static int Main()
-    {
-        RegionInfoISOCurrencySymbol regInfoISOCurrencySymbol = new RegionInfoISOCurrencySymbol();
-        TestLibrary.TestFramework.BeginTestCase("RegionInfoISOCurrencySymbol");
-        if (regInfoISOCurrencySymbol.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the property ISOCurrencySymbol in RegionInfo object 1");
-        try
-        {
-            RegionInfo regionInfo = new RegionInfo("en-US");
-            string strISOCurrency = regionInfo.ISOCurrencySymbol;
-            if (strISOCurrency != "USD")
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is USD but the ActualResult is (" + strISOCurrency +")");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest2:Return the property ISOCurrencySymbol in RegionInfo object 2");
-        try
-        {
-            RegionInfo regionInfo = new RegionInfo("zh-CN");
-            string strISOCurrency = regionInfo.ISOCurrencySymbol;
-            if (strISOCurrency != "CNY")
-            {
-                TestLibrary.TestFramework.LogError("003", "the ExpectResult is CNY but the ActualResult is (" + strISOCurrency +")");
-                retVal = false;
-            }
-        }
-		catch (ArgumentException)
-		{
-			TestLibrary.TestFramework.LogInformation("The East Asian Languages are not installed. Skipping test(s)");
-			retVal = true;
-		}
-		catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest3()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest3:Return the property ISOCurrencySymbol in RegionInfo object 3");
-        try
-        {
-            RegionInfo regionInfo = new RegionInfo("de-DE");
-            string strISOCurrency = regionInfo.ISOCurrencySymbol;
-            // On an older OS which does not have the right uptodate information, we can report DEM as the currency for German
-            if (TestLibrary.Utilities.IsVistaOrLater)
-            {
-                if (strISOCurrency != "EUR")
-                {
-                    TestLibrary.TestFramework.LogError("005", "the ExpectResult is EUR but the ActualResult is (" + strISOCurrency + ")");
-                    retVal = false;
-                }
-            }
-            else
-            {
-                if (strISOCurrency != "EUR" && strISOCurrency != "DEM")
-                {
-                    TestLibrary.TestFramework.LogError("005", "the ExpectResult is EUR or DEM but the ActualResult is (" + strISOCurrency + ")");
-                    retVal = false;
-                }
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest4()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest4:Return the property ISOCurrencySymbol in RegionInfo object 4");
-        try
-        {
-            RegionInfo regionInfo = new RegionInfo("it-IT");
-            string strISOCurrency = regionInfo.ISOCurrencySymbol;
-            // On an older OS which does not have the right uptodate information, we can report ITL as the currency for Italian
-            if (TestLibrary.Utilities.IsVistaOrLater)
-            {
-                if (strISOCurrency != "EUR")
-                {
-                    TestLibrary.TestFramework.LogError("007", "the ExpectResult is EUR but the ActualResult is (" + strISOCurrency + ")");
-                    retVal = false;
-                }
-            }
-            else
-            {
-                if (strISOCurrency != "EUR" && strISOCurrency != "ITL")
-                {
-                    TestLibrary.TestFramework.LogError("007", "the ExpectResult is EUR or ITL but the ActualResult is (" + strISOCurrency + ")");
-                    retVal = false;
-                }
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("008", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/regioninfoname.cs b/tests/src/CoreMangLib/cti/system/globalization/regioninfo/regioninfoname.cs
deleted file mode 100644
index 3b6dfa0c17..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/regioninfoname.cs
+++ /dev/null
@@ -1,130 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// RegionInfo.Name [v-minch]
-/// </summary>
-public class RegionInfoName
-{
-    public static int Main()
-    {
-        RegionInfoName regInfoName = new RegionInfoName();
-        TestLibrary.TestFramework.BeginTestCase("RegionInfoName");
-        if (regInfoName.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest1() && retVal;
-		// The constructor will disallow partial names
-		//retVal = PosTest3() && retVal;
-		//retVal = PosTest4() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the property Name in RegionInfo object 1");
-        try
-        {
-            RegionInfo regionInfo = new RegionInfo("en-US");
-            string strName = regionInfo.Name;
-            if (strName != "US")
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is en-US but the ActualResult is " + strName);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest2:Return the property Name in RegionInfo object 2");
-        try
-        {
-            RegionInfo regionInfo = new RegionInfo("zh-CN");
-            string strName = regionInfo.Name;
-            if (strName != "CN")
-            {
-                TestLibrary.TestFramework.LogError("003", "the ExpectResult is ZH-CN but the ActualResult is " + strName);
-                retVal = false;
-            }
-        }
-		catch (ArgumentException)
-		{
-			TestLibrary.TestFramework.LogInformation("The East Asian Languages are not installed. Skipping test(s)");
-			retVal = true;
-		}
-		catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-	public bool PosTest3() // The constructor will disallow partial names
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest3:Return the property Name in RegionInfo object 3");
-        try
-        {
-            RegionInfo regionInfo = new RegionInfo("US");
-            string strName = regionInfo.Name;
-            if (strName != "US")
-            {
-                TestLibrary.TestFramework.LogError("005", "the ExpectResult is US but the ActualResult is " + strName);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-	public bool PosTest4() // The constructor will disallow partial names
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest4:Return the property Name in RegionInfo object 4");
-        try
-        {
-            RegionInfo regionInfo = new RegionInfo("CN");
-            string strName = regionInfo.Name;
-            if (strName != "CN")
-            {
-                TestLibrary.TestFramework.LogError("007", "the ExpectResult is CN but the ActualResult is " + strName);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("008", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/regioninfotostring.cs b/tests/src/CoreMangLib/cti/system/globalization/regioninfo/regioninfotostring.cs
deleted file mode 100644
index bf3b90d31e..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/regioninfotostring.cs
+++ /dev/null
@@ -1,107 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// RegionInfo.ToString()
-/// </summary>
-public class RegionInfoToString
-{
-    public static int Main()
-    {
-        RegionInfoToString regInfoToString = new RegionInfoToString();
-        TestLibrary.TestFramework.BeginTestCase("RegionInfoToString");
-        if (regInfoToString.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest1() && retVal;
-        retVal = PosTest3() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Invoke the method ToString in RegionInfo object 1");
-		try
-		{
-			RegionInfo regionInfo = new RegionInfo("zh-CN");
-			string strVal = regionInfo.ToString();
-			if (strVal != regionInfo.Name)
-			{
-				TestLibrary.TestFramework.LogError("001", "the ExpectResult is" + regionInfo.Name + "but the ActualResult is" + strVal);
-				retVal = false;
-			}
-		}
-		catch (ArgumentException)
-		{
-			TestLibrary.TestFramework.LogInformation("The East Asian Languages are not installed. Skipping test(s)");
-			retVal = true;
-		}
-		catch (Exception e)
-		{
-			TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-			retVal = false;
-		}
-        return retVal;
-    }
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest2:Invoke the method ToString in RegionInfo object 2");
-        try
-        {
-            RegionInfo regionInfo = new RegionInfo("en-US");
-            string strVal = regionInfo.ToString();
-            if (strVal != regionInfo.Name)
-            {
-                TestLibrary.TestFramework.LogError("003", "the ExpectResult is" + regionInfo.Name + "but the ActualResult is" + strVal);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest3()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest3:Invoke the method ToString in RegionInfo object 3");
-        try
-        {
-            RegionInfo regionInfo = new RegionInfo("en-IE");
-            string strVal = regionInfo.ToString();
-            if (strVal != regionInfo.Name)
-            {
-                TestLibrary.TestFramework.LogError("005", "the ExpectResult is" + regionInfo.Name + "but the ActualResult is" + strVal);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/regioninfotwoletterisoregionname.cs b/tests/src/CoreMangLib/cti/system/globalization/regioninfo/regioninfotwoletterisoregionname.cs
deleted file mode 100644
index bec7ad3814..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/regioninfo/regioninfotwoletterisoregionname.cs
+++ /dev/null
@@ -1,129 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// RegionInfo.TwoLetterISORegionName [v-minch]
-/// </summary>
-public class RegionInfoTwoLetterISORegionName
-{
-    public static int Main()
-    {
-        RegionInfoTwoLetterISORegionName regInfoTwoLetterISOName = new RegionInfoTwoLetterISORegionName();
-        TestLibrary.TestFramework.BeginTestCase("RegionInfoTwoLetterISORegionName");
-        if (regInfoTwoLetterISOName.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the property TwoLetterISORegionName in RegionInfo object 1");
-        try
-        {
-            RegionInfo regionInfo = new RegionInfo("en-US");
-            string strTwoLetterName = regionInfo.TwoLetterISORegionName;
-            if (strTwoLetterName != "US")
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is US but the ActualResult is " + strTwoLetterName);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest2:Return the property TwoLetterISORegionName in RegionInfo object 2");
-        try
-        {
-            RegionInfo regionInfo = new RegionInfo("zh-CN");
-            string strTwoLetterName = regionInfo.TwoLetterISORegionName;
-            if (strTwoLetterName != "CN")
-            {
-                TestLibrary.TestFramework.LogError("003", "the ExpectResult is CN but the ActualResult is " + strTwoLetterName);
-                retVal = false;
-            }
-        }
-		catch (ArgumentException)
-		{
-			TestLibrary.TestFramework.LogInformation("The East Asian Languages are not installed. Skipping test(s)");
-			retVal = true;
-		}
-		catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest3()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest3:Return the property TwoLetterISORegionName in RegionInfo object 3");
-        try
-        {
-            RegionInfo regionInfo = new RegionInfo("de-DE");
-            string strTwoLetterName = regionInfo.TwoLetterISORegionName;
-            if (strTwoLetterName != "DE")
-            {
-                TestLibrary.TestFramework.LogError("005", "the ExpectResult is DE but the ActualResult is " + strTwoLetterName);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest4()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest4:Return the property TwoLetterISORegionName in RegionInfo object 4");
-        try
-        {
-            RegionInfo regionInfo = new RegionInfo("it-IT");
-            string strTwoLetterName = regionInfo.TwoLetterISORegionName;
-            if (strTwoLetterName != "IT")
-            {
-                TestLibrary.TestFramework.LogError("007", "the ExpectResult is IT but the ActualResult is " + strTwoLetterName);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("008", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoCtor1.csproj b/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoCtor1.csproj
deleted file mode 100644
index 153e433336..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoCtor1.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="stringinfoctor1.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoCtor2.csproj b/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoCtor2.csproj
deleted file mode 100644
index b32d70506b..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoCtor2.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="stringinfoctor2.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoEquals.csproj b/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoEquals.csproj
deleted file mode 100644
index 43d549dc8a..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoEquals.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="stringinfoequals.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoGetHashCode.csproj b/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoGetHashCode.csproj
deleted file mode 100644
index 2b1ea4a0ff..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoGetHashCode.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="stringinfogethashcode.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoGetNextTextElement2.csproj b/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoGetNextTextElement2.csproj
deleted file mode 100644
index 7e190a857e..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoGetNextTextElement2.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="stringinfogetnexttextelement2.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoGetTextElementEnumerator1.csproj b/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoGetTextElementEnumerator1.csproj
deleted file mode 100644
index f3dbb3dc33..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoGetTextElementEnumerator1.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="stringinfogettextelementenumerator1.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoGetTextElementEnumerator2.csproj b/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoGetTextElementEnumerator2.csproj
deleted file mode 100644
index 62fbca43ea..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoGetTextElementEnumerator2.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="stringinfogettextelementenumerator2.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoLengthInTextElements.csproj b/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoLengthInTextElements.csproj
deleted file mode 100644
index 5fb5e06563..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoLengthInTextElements.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="stringinfolengthintextelements.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoParseCombiningCharacters.csproj b/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoParseCombiningCharacters.csproj
deleted file mode 100644
index 7d30397972..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoParseCombiningCharacters.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="stringinfoparsecombiningcharacters.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoString.csproj b/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoString.csproj
deleted file mode 100644
index 494784f20e..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/StringInfoString.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="stringinfostring.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfoctor1.cs b/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfoctor1.cs
deleted file mode 100644
index edd16c04d9..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfoctor1.cs
+++ /dev/null
@@ -1,77 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// System.Globalization.StringInfo.Ctor
-/// </summary>
-public class StringInfoCtor1
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Call constructor to create an instance");
-
-        try
-        {
-            StringInfo stringInfo = new StringInfo();
-            if (stringInfo == null)
-            {
-                TestLibrary.TestFramework.LogError("001", "The constructor does not create a new instance");
-                retVal = false;
-            }
-            if (stringInfo.String != string.Empty)
-            {
-                TestLibrary.TestFramework.LogError("002", "The constructor does not work correctly");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("003", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        StringInfoCtor1 test = new StringInfoCtor1();
-
-        TestLibrary.TestFramework.BeginTestCase("StringInfoCtor1");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfoctor2.cs b/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfoctor2.cs
deleted file mode 100644
index 09a1344117..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfoctor2.cs
+++ /dev/null
@@ -1,171 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// System.Globalization.StringInfo.Ctor(System.String)
-/// </summary>
-public class StringInfoCtor2
-{
-    private const int c_MINI_STRING_LENGTH = 8;
-    private const int c_MAX_STRING_LENGTH = 256;
-
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-
-        TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Call constructor to create an instance with a random string argument");
-
-        try
-        {
-            string str = TestLibrary.Generator.GetString(-55, false, c_MINI_STRING_LENGTH, c_MAX_STRING_LENGTH);
-            StringInfo stringInfo = new StringInfo(str);
-            if (stringInfo == null)
-            {
-                TestLibrary.TestFramework.LogError("001", "The constructor does not create a new instance");
-                retVal = false;
-            }
-            if (stringInfo.String != str)
-            {
-                TestLibrary.TestFramework.LogError("002", "The constructor does not work correctly,the str is: " + str);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("003", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: Call constructor to create an instance with an empty string argument");
-
-        try
-        {
-            string str = string.Empty;
-            StringInfo stringInfo = new StringInfo(str);
-            if (stringInfo == null)
-            {
-                TestLibrary.TestFramework.LogError("004", "The constructor does not create a new instance");
-                retVal = false;
-            }
-            if (stringInfo.String != string.Empty)
-            {
-                TestLibrary.TestFramework.LogError("005", "The constructor does not work correctly,the str is: " + str);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: Call constructor to create an instance with a string of white space");
-
-        try
-        {
-            string str = " ";
-            StringInfo stringInfo = new StringInfo(str);
-            if (stringInfo == null)
-            {
-                TestLibrary.TestFramework.LogError("007", "The constructor does not create a new instance");
-                retVal = false;
-            }
-            if (stringInfo.String != " ")
-            {
-                TestLibrary.TestFramework.LogError("008", "The constructor does not work correctly,the str is: " + str);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("009", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    public bool NegTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: The string is a null reference");
-
-        try
-        {
-            string str = null;
-            StringInfo stringInfo = new StringInfo(str);
-            TestLibrary.TestFramework.LogError("101", "The ArgumentNullException was not thrown as expected");
-            retVal = false;
-        }
-        catch (ArgumentNullException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("102", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        StringInfoCtor2 test = new StringInfoCtor2();
-
-        TestLibrary.TestFramework.BeginTestCase("StringInfoCtor2");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfoequals.cs b/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfoequals.cs
deleted file mode 100644
index 4866c64f17..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfoequals.cs
+++ /dev/null
@@ -1,235 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// System.Globalization.StringInfo.Equals(Object)
-/// </summary>
-public class StringInfoEquals
-{
-    private const int c_MINI_STRING_LENGTH = 8;
-    private const int c_MAX_STRING_LENGTH = 256;
-
-
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-        retVal = PosTest5() && retVal;
-        retVal = PosTest6() && retVal;
-        retVal = PosTest7() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Compare two equal StringInfo");
-
-        try
-        {
-            string str = TestLibrary.Generator.GetString(-55, false, c_MINI_STRING_LENGTH, c_MAX_STRING_LENGTH);
-            StringInfo stringInfo1 = new StringInfo(str);
-            StringInfo stringInfo2 = new StringInfo(str);
-            if (!stringInfo1.Equals(stringInfo2))
-            {
-                TestLibrary.TestFramework.LogError("001", "The result is not the value as expected");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: The two stringinfos reference to one object ");
-
-        try
-        {
-            string str = TestLibrary.Generator.GetString(-55, false, c_MINI_STRING_LENGTH, c_MAX_STRING_LENGTH);
-            StringInfo stringInfo1 = new StringInfo(str);
-            StringInfo stringInfo2 = stringInfo1;
-            if (!stringInfo1.Equals(stringInfo2))
-            {
-                TestLibrary.TestFramework.LogError("003", "The result is not the value as expected");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: Using default constructor to create two equal instance");
-
-        try
-        {
-            StringInfo stringInfo1 = new StringInfo();
-            StringInfo stringInfo2 = new StringInfo();
-            if (!stringInfo1.Equals(stringInfo2))
-            {
-                TestLibrary.TestFramework.LogError("005", "The result is not the value as expected");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest4()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest4: Compare two instance with different string value");
-
-        try
-        {
-            StringInfo stringInfo1 = new StringInfo("stringinfo1");
-            StringInfo stringInfo2 = new StringInfo("stringinfo2");
-            if (stringInfo1.Equals(stringInfo2))
-            {
-                TestLibrary.TestFramework.LogError("007", "The result is not the value as expected");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("008", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest5()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest5: Compare with a different kind of type");
-
-        try
-        {
-            StringInfo stringInfo1 = new StringInfo("stringinfo1");
-            string str = "stringinfo1";
-            if (stringInfo1.Equals(str))
-            {
-                TestLibrary.TestFramework.LogError("009", "The result is not the value as expected");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("010", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest6()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest6: The argument is a null reference");
-
-        try
-        {
-            StringInfo stringInfo1 = new StringInfo("stringinfo1");
-            object ob = null;
-            if (stringInfo1.Equals(ob))
-            {
-                TestLibrary.TestFramework.LogError("011", "The result is not the value as expected");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("012", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest7()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest7: The argument is value type");
-
-        try
-        {
-            StringInfo stringInfo1 = new StringInfo("123");
-            int i = 123;
-            if (stringInfo1.Equals(i))
-            {
-                TestLibrary.TestFramework.LogError("013", "The result is not the value as expected");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("014", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        StringInfoEquals test = new StringInfoEquals();
-
-        TestLibrary.TestFramework.BeginTestCase("StringInfoEquals");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfogethashcode.cs b/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfogethashcode.cs
deleted file mode 100644
index 89b7bb45cc..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfogethashcode.cs
+++ /dev/null
@@ -1,104 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// System.Globalization.StringInfo.GetHashCode()
-/// </summary>
-public class StringInfoGetHashCode
-{
-    private const int c_MINI_STRING_LENGTH = 8;
-    private const int c_MAX_STRING_LENGTH = 256;
-
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: The two instances created by the same argument return the same hashcode");
-
-        try
-        {
-            string str = TestLibrary.Generator.GetString(-55, false, c_MINI_STRING_LENGTH, c_MAX_STRING_LENGTH);
-            StringInfo stringInfo1 = new StringInfo(str);
-            StringInfo stringInfo2 = new StringInfo(str);
-            if (stringInfo1.GetHashCode() != stringInfo2.GetHashCode())
-            {
-                TestLibrary.TestFramework.LogError("001", "The result is not the value as expected");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: Check two different instance");
-
-        try
-        {
-            string str = TestLibrary.Generator.GetString(-55, false, c_MINI_STRING_LENGTH, c_MAX_STRING_LENGTH);
-            StringInfo stringInfo1 = new StringInfo(str);
-            StringInfo stringInfo2 = new StringInfo("");
-            if (stringInfo1.GetHashCode() == stringInfo2.GetHashCode())
-            {
-                TestLibrary.TestFramework.LogError("003", "The result is not the value as expected");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        StringInfoGetHashCode test = new StringInfoGetHashCode();
-
-        TestLibrary.TestFramework.BeginTestCase("StringInfoGetHashCode");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfogetnexttextelement2.cs b/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfogetnexttextelement2.cs
deleted file mode 100644
index 7f323d0707..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfogetnexttextelement2.cs
+++ /dev/null
@@ -1,267 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// System.Globalization.StringInfo.GetNextTestElement(string,int32)
-/// </summary>
-public class StringInfoGetNextTextElement2
-{
-    private const int c_MINI_STRING_LENGTH = 8;
-    private const int c_MAX_STRING_LENGTH = 256;
-
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-
-        TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-        retVal = NegTest2() && retVal;
-        retVal = NegTest3() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: Get the text element from a random index in a string");
-
-        try
-        {
-            string str = TestLibrary.Generator.GetString(-55, true, c_MINI_STRING_LENGTH, c_MAX_STRING_LENGTH);
-            int index = this.GetInt32(8, str.Length);
-            string result = StringInfo.GetNextTextElement(str, index);
-            if (result != str[index].ToString())
-            {
-                TestLibrary.TestFramework.LogError("001", "The result is not the value as expected,the result is: " + result);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: The first element is a surrogate pair");
-
-        try
-        {
-            string str = "\uDBFF\uDFFF";
-            string result = StringInfo.GetNextTextElement("ef45-;\uDBFF\uDFFFabcde", 6);
-            if (result.Length != 2)
-            {
-                TestLibrary.TestFramework.LogError("003", "The result is not the value as expected");
-                retVal = false;
-            }
-            if (result != str)
-            {
-                TestLibrary.TestFramework.LogError("004", "The result is not the value as expected,the result is: " + result);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("005", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: The element is  a combining character");
-
-        try
-        {
-            string str = "a\u20D1";
-            string result = StringInfo.GetNextTextElement("13229^a\u20D1abcde", 6);
-            if (result != str)
-            {
-                TestLibrary.TestFramework.LogError("006", "The result is not the value as expected,the result is: " + result);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("007", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest4()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest4: The element is a combination of base character and several combining characters");
-
-        try
-        {
-            string str = "z\uFE22\u20D1\u20EB";
-            string result = StringInfo.GetNextTextElement("az\uFE22\u20D1\u20EBabcde", 1);
-            if (result.Length != 4)
-            {
-                TestLibrary.TestFramework.LogError("008", "The result is not the value as expected,length is: " + result.Length);
-                retVal = false;
-            }
-            if (result != str)
-            {
-                TestLibrary.TestFramework.LogError("009", "The result is not the value as expected,the result is: " + result);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("010", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    public bool NegTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: The string is a null reference");
-
-        try
-        {
-            string str = null;
-            string result = StringInfo.GetNextTextElement(str, 0);
-            TestLibrary.TestFramework.LogError("101", "The ArgumentNullException was not thrown as expected");
-            retVal = false;
-        }
-        catch (ArgumentNullException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("102", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest2: The index is out of the range of the string");
-
-        try
-        {
-            string str = "abc";
-            string result = StringInfo.GetNextTextElement(str, -4);
-            TestLibrary.TestFramework.LogError("103", "The ArgumentOutOfRangeException was not thrown as expected");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("104", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest3: The index is a negative number");
-
-        try
-        {
-            string str = "df8%^dk";
-            string result = StringInfo.GetNextTextElement(str, -1);
-            TestLibrary.TestFramework.LogError("105", "The ArgumentOutOfRangeException was not thrown as expected");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("106", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        StringInfoGetNextTextElement2 test = new StringInfoGetNextTextElement2();
-
-        TestLibrary.TestFramework.BeginTestCase("StringInfoGetNextTextElement2");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    private Int32 GetInt32(Int32 minValue, Int32 maxValue)
-    {
-        try
-        {
-            if (minValue == maxValue)
-            {
-                return minValue;
-            }
-            if (minValue < maxValue)
-            {
-                return minValue + TestLibrary.Generator.GetInt32(-55) % (maxValue - minValue);
-            }
-        }
-        catch
-        {
-            throw;
-        }
-
-        return minValue;
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfogettextelementenumerator1.cs b/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfogettextelementenumerator1.cs
deleted file mode 100644
index 5b7fe1c42c..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfogettextelementenumerator1.cs
+++ /dev/null
@@ -1,185 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// System.Globalization.StringInfo.GetTestElementEnumerator(string)
-/// </summary>
-public class StringInfoGetTextElementEnumerator1
-{
-    private const int c_MINI_STRING_LENGTH = 8;
-    private const int c_MAX_STRING_LENGTH = 256;
-
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-
-        TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: The argument is a random string");
-
-        try
-        {
-            string str = TestLibrary.Generator.GetString(-55, true, c_MINI_STRING_LENGTH, c_MAX_STRING_LENGTH);
-            TextElementEnumerator TextElementEnumerator = StringInfo.GetTextElementEnumerator(str);
-            int len = str.Length;
-            TextElementEnumerator.MoveNext();
-            for (int i = 0; i < len; i++)
-            {
-                if (TextElementEnumerator.Current.ToString() != str[i].ToString())
-                {
-                    TestLibrary.TestFramework.LogError("001", "The result is not the value as expected,the str[i] is: " + str[i]);
-                    retVal = false;
-                }
-                TextElementEnumerator.MoveNext();
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: The string has a surrogate pair");
-
-        try
-        {
-            string str = "\uDBFF\uDFFF";
-            TextElementEnumerator TextElementEnumerator = StringInfo.GetTextElementEnumerator("s\uDBFF\uDFFF$");
-            TextElementEnumerator.MoveNext();
-            if (TextElementEnumerator.Current.ToString() != "s")
-            {
-                TestLibrary.TestFramework.LogError("003", "The result is not the value as expected");
-                retVal = false;
-            }
-            TextElementEnumerator.MoveNext();
-            if (TextElementEnumerator.Current.ToString() != str)
-            {
-                TestLibrary.TestFramework.LogError("004", "The result is not the value as expected,the current is: " + TextElementEnumerator.Current.ToString());
-                retVal = false;
-            }
-            TextElementEnumerator.MoveNext();
-            if (TextElementEnumerator.Current.ToString() != "$")
-            {
-                TestLibrary.TestFramework.LogError("005", "The result is not the value as expected");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: The string has a combining character");
-
-        try
-        {
-            string str = "a\u20D1";
-            TextElementEnumerator TextElementEnumerator = StringInfo.GetTextElementEnumerator("13229^a\u20D1a");
-            for (int i = 0; i < 7; i++)
-            {
-                TextElementEnumerator.MoveNext();
-            }
-            if (TextElementEnumerator.Current.ToString() != str)
-            {
-                TestLibrary.TestFramework.LogError("007", "The result is not the value as expected,the current is: " + TextElementEnumerator.Current.ToString());
-                retVal = false;
-            }
-            TextElementEnumerator.MoveNext();
-            if (TextElementEnumerator.MoveNext())
-            {
-                TestLibrary.TestFramework.LogError("008", "The result is not the value as expected,the current is: " + TextElementEnumerator.Current.ToString());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("009", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    public bool NegTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: The string is a null reference");
-
-        try
-        {
-            string str = null;
-            TextElementEnumerator TextElementEnumerator = StringInfo.GetTextElementEnumerator(str);
-            TestLibrary.TestFramework.LogError("101", "The ArgumentNullException was not thrown as expected");
-            retVal = false;
-        }
-        catch (ArgumentNullException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("102", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        StringInfoGetTextElementEnumerator1 test = new StringInfoGetTextElementEnumerator1();
-
-        TestLibrary.TestFramework.BeginTestCase("StringInfoGetTextElementEnumerator1");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfogettextelementenumerator2.cs b/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfogettextelementenumerator2.cs
deleted file mode 100644
index aeb9a27c44..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfogettextelementenumerator2.cs
+++ /dev/null
@@ -1,257 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// System.Globalization.StringInfo.GetTestElementEnumerator(string,Int32)
-/// </summary>
-public class StringInfoGetTextElementEnumerator2
-{
-    private const int c_MINI_STRING_LENGTH = 8;
-    private const int c_MAX_STRING_LENGTH = 256;
-
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-
-        TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-        retVal = NegTest2() && retVal;
-        retVal = NegTest3() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: The argument is a random string,and start at a random index");
-
-        try
-        {
-            string str = TestLibrary.Generator.GetString(-55, true, c_MINI_STRING_LENGTH, c_MAX_STRING_LENGTH);
-            int len = str.Length;
-            int index = this.GetInt32(8, len);
-            TextElementEnumerator TextElementEnumerator = StringInfo.GetTextElementEnumerator(str, index);
-            TextElementEnumerator.MoveNext();
-            for (int i = 0; i < len - index; i++)
-            {
-                if (TextElementEnumerator.Current.ToString() != str[i + index].ToString())
-                {
-                    TestLibrary.TestFramework.LogError("001", "The result is not the value as expected,the str is: " + str[i + index]);
-                    retVal = false;
-                }
-                TextElementEnumerator.MoveNext();
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: The string has a surrogate pair");
-
-        try
-        {
-            string str = "\uDBFF\uDFFF";
-            TextElementEnumerator TextElementEnumerator = StringInfo.GetTextElementEnumerator("s\uDBFF\uDFFF$", 1);
-            TextElementEnumerator.MoveNext();
-            if (TextElementEnumerator.Current.ToString() != str)
-            {
-                TestLibrary.TestFramework.LogError("003", "The result is not the value as expected,the current is: " + TextElementEnumerator.Current.ToString());
-                retVal = false;
-            }
-            TextElementEnumerator.MoveNext();
-            if (TextElementEnumerator.Current.ToString() != "$")
-            {
-                TestLibrary.TestFramework.LogError("004", "The result is not the value as expected");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("005", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: The string has a combining character");
-
-        try
-        {
-            string str = "a\u20D1";
-            TextElementEnumerator TextElementEnumerator = StringInfo.GetTextElementEnumerator("13229^a\u20D1a", 6);
-            TextElementEnumerator.MoveNext();
-            if (TextElementEnumerator.Current.ToString() != str)
-            {
-                TestLibrary.TestFramework.LogError("006", "The result is not the value as expected,the current is: " + TextElementEnumerator.Current.ToString());
-                retVal = false;
-            }
-            TextElementEnumerator.MoveNext();
-            if (TextElementEnumerator.Current.ToString() != "a")
-            {
-                TestLibrary.TestFramework.LogError("007", "The result is not the value as expected,the current is: " + TextElementEnumerator.Current.ToString());
-                retVal = false;
-            }
-            if (TextElementEnumerator.MoveNext())
-            {
-                TestLibrary.TestFramework.LogError("008", "The result is not the value as expected,the current is: " + TextElementEnumerator.Current.ToString());
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("009", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    public bool NegTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: The string is a null reference");
-
-        try
-        {
-            string str = null;
-            TextElementEnumerator TextElementEnumerator = StringInfo.GetTextElementEnumerator(str, 0);
-            TestLibrary.TestFramework.LogError("101", "The ArgumentNullException was not thrown as expected");
-            retVal = false;
-        }
-        catch (ArgumentNullException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("102", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest2: The index is out of the range of the string");
-
-        try
-        {
-            string str = "dur8&p!";
-            TextElementEnumerator TextElementEnumerator = StringInfo.GetTextElementEnumerator(str, 10);
-            TestLibrary.TestFramework.LogError("103", "The ArgumentOutOfRangeException was not thrown as expected");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("104", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest3: The index is a negative number");
-
-        try
-        {
-            string str = "dur8&p!";
-            TextElementEnumerator TextElementEnumerator = StringInfo.GetTextElementEnumerator(str, -10);
-            TestLibrary.TestFramework.LogError("105", "The ArgumentOutOfRangeException was not thrown as expected");
-            retVal = false;
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("106", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        StringInfoGetTextElementEnumerator2 test = new StringInfoGetTextElementEnumerator2();
-
-        TestLibrary.TestFramework.BeginTestCase("StringInfoGetTextElementEnumerator2");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    private Int32 GetInt32(Int32 minValue, Int32 maxValue)
-    {
-        try
-        {
-            if (minValue == maxValue)
-            {
-                return minValue;
-            }
-            if (minValue < maxValue)
-            {
-                return minValue + TestLibrary.Generator.GetInt32(-55) % (maxValue - minValue);
-            }
-        }
-        catch
-        {
-            throw;
-        }
-
-        return minValue;
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfolengthintextelements.cs b/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfolengthintextelements.cs
deleted file mode 100644
index 95e298787f..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfolengthintextelements.cs
+++ /dev/null
@@ -1,109 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// System.Globalization.StringInfo.LengthInTextElements
-/// </summary>
-public class StringInfoLengthInTextElements
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: The mothod should return the number of base character in the current stringInfo object");
-
-        try
-        {
-            retVal = VerificationHelper("\u4f00\u302a\ud800\udc00\u4f01", 3, "001.1");
-            retVal = VerificationHelper("abcdefgh", 8, "001.2");
-            retVal = VerificationHelper("zj\uDBFF\uDFFFlk", 5, "001.3");
-            retVal = VerificationHelper("!@#$%^&", 7, "001.4");
-            retVal = VerificationHelper("!\u20D1bo\uFE22\u20D1\u20EB|", 4, "001.5");
-            retVal = VerificationHelper("1\uDBFF\uDFFF@\uFE22\u20D1\u20EB9", 4, "001.6");
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: The string in stringinfo is white space or empty string");
-
-        try
-        {
-            retVal = VerificationHelper("   ", 3, "001.1");
-            retVal = VerificationHelper(string.Empty, 0, "001.2");
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        StringInfoLengthInTextElements test = new StringInfoLengthInTextElements();
-
-        TestLibrary.TestFramework.BeginTestCase("StringInfoLengthInTextElements");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    #region Private Methods
-    private bool VerificationHelper(string str, int expected, string errorno)
-    {
-        bool retVal = true;
-
-        StringInfo stringInfo = new StringInfo(str);
-        int result = stringInfo.LengthInTextElements;
-        if (result != expected)
-        {
-            TestLibrary.TestFramework.LogError(errorno, "The result is not the value as expected,The actual is: " + result + ", the desire is: " + expected);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfoparsecombiningcharacters.cs b/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfoparsecombiningcharacters.cs
deleted file mode 100644
index 9fbbe76037..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfoparsecombiningcharacters.cs
+++ /dev/null
@@ -1,166 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// System.Globalization.StringInfo.ParseCombiningCharacters(System.String)
-/// </summary>
-public class StringInfoParseCombiningCharacters
-{
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-
-        TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: The mothod should return the indexes of each base character");
-
-        try
-        {
-            retVal = VerificationHelper("\u4f00\u302a\ud800\udc00\u4f01", new int[] { 0, 2, 4 }, "001.1");
-            retVal = VerificationHelper("abcdefgh", new int[] { 0, 1, 2, 3, 4, 5, 6, 7 }, "001.2");
-            retVal = VerificationHelper("zj\uDBFF\uDFFFlk", new int[] { 0, 1, 2, 4, 5 }, "001.3");
-            retVal = VerificationHelper("!@#$%^&", new int[] { 0, 1, 2, 3, 4, 5, 6 }, "001.4");
-            retVal = VerificationHelper("!\u20D1bo\uFE22\u20D1\u20EB|", new int[] { 0, 2, 3, 7 }, "001.5");
-            retVal = VerificationHelper("1\uDBFF\uDFFF@\uFE22\u20D1\u20EB9", new int[] { 0, 1, 3, 7 }, "001.6");
-            retVal = VerificationHelper("   ", new int[] { 0, 1, 2 }, "001.7");
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: The argument string is an empty string");
-
-        try
-        {
-            int[] result = StringInfo.ParseCombiningCharacters(string.Empty);
-            if (result == null)
-            {
-                TestLibrary.TestFramework.LogError("003", "The result is not the value as expected");
-                retVal = false;
-            }
-            if (result.Length != 0)
-            {
-                TestLibrary.TestFramework.LogError("004", "The result is not the value as expected");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("005", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    public bool NegTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: The argument string is a null reference");
-
-        try
-        {
-            string str = null;
-            int[] result = StringInfo.ParseCombiningCharacters(str);
-            TestLibrary.TestFramework.LogError("101", "The ArgumentNullException was not thrown as expected");
-            retVal = false;
-        }
-        catch (ArgumentNullException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("102", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        StringInfoParseCombiningCharacters test = new StringInfoParseCombiningCharacters();
-
-        TestLibrary.TestFramework.BeginTestCase("StringInfoParseCombiningCharacters");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    #region Private Methods
-    private bool VerificationHelper(string str, int[] expected, string errorno)
-    {
-        bool retVal = true;
-
-        int[] result = StringInfo.ParseCombiningCharacters(str);
-
-        if (!compare<int>(result, expected))
-        {
-            TestLibrary.TestFramework.LogError(errorno, "The result is not the value as expected");
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    private bool compare<T>(T[] a, T[] b)
-    {
-        if (a.Length != b.Length)
-        {
-            return false;
-        }
-        else
-        {
-            for (int i = 0; i < a.Length; i++)
-            {
-                if (!a[i].Equals(b[i]))
-                {
-                    return false;
-                }
-            }
-            return true;
-        }
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfostring.cs b/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfostring.cs
deleted file mode 100644
index 0656a630ad..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/stringinfo/stringinfostring.cs
+++ /dev/null
@@ -1,184 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// System.Globalization.StringInfo.string
-/// </summary>
-public class StringInfoString
-{
-    private const int c_MINI_STRING_LENGTH = 8;
-    private const int c_MAX_STRING_LENGTH = 256;
-
-    #region Public Methods
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-
-        TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    #region Positive Test Cases
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: The string property in stringinfo object is a random string argument");
-
-        try
-        {
-            string str = TestLibrary.Generator.GetString(-55, false, c_MINI_STRING_LENGTH, c_MAX_STRING_LENGTH);
-            StringInfo stringInfo = new StringInfo(str);
-            if (stringInfo.String != str)
-            {
-                TestLibrary.TestFramework.LogError("001", "The constructor does not work correctly,the str is: " + str);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: The string property in stringinfo object is an empty string argument");
-
-        try
-        {
-            string str = string.Empty;
-            StringInfo stringInfo = new StringInfo(str);
-            if (stringInfo.String != string.Empty)
-            {
-                TestLibrary.TestFramework.LogError("003", "The constructor does not work correctly,the str is: " + str);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3:  Check an instance with a string of white space");
-
-        try
-        {
-            string str = " ";
-            StringInfo stringInfo = new StringInfo(str);
-            if (stringInfo.String != " ")
-            {
-                TestLibrary.TestFramework.LogError("005", "The constructor does not work correctly,the str is: " + str);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest4()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest4:  Set the property with a random string value");
-
-        try
-        {
-            string str = TestLibrary.Generator.GetString(-55, false, c_MINI_STRING_LENGTH, c_MAX_STRING_LENGTH);
-            StringInfo stringInfo = new StringInfo();
-            stringInfo.String = str;
-            if (stringInfo.String != str)
-            {
-                TestLibrary.TestFramework.LogError("007", "The constructor does not work correctly,the str is: " + str);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("008", "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Nagetive Test Cases
-    public bool NegTest1()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.BeginScenario("NegTest1: The property was set with a value of null");
-
-        try
-        {
-            string str = null;
-            StringInfo stringInfo = new StringInfo();
-            stringInfo.String = str;
-            TestLibrary.TestFramework.LogError("101", "The ArgumentNullException was not thrown as expected");
-            retVal = false;
-        }
-        catch (ArgumentNullException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("102", "Unexpected exception: " + e);
-            TestLibrary.TestFramework.LogInformation(e.StackTrace);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-    #endregion
-
-    public static int Main()
-    {
-        StringInfoString test = new StringInfoString();
-
-        TestLibrary.TestFramework.BeginTestCase("StringInfoString");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/TextElementEnumeratorCurrent.csproj b/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/TextElementEnumeratorCurrent.csproj
deleted file mode 100644
index 293566ca05..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/TextElementEnumeratorCurrent.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="textelementenumeratorcurrent.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/TextElementEnumeratorElementIndex.csproj b/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/TextElementEnumeratorElementIndex.csproj
deleted file mode 100644
index 289f05c338..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/TextElementEnumeratorElementIndex.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="textelementenumeratorelementindex.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/TextElementEnumeratorGetTextElement.csproj b/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/TextElementEnumeratorGetTextElement.csproj
deleted file mode 100644
index c43bec8922..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/TextElementEnumeratorGetTextElement.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="textelementenumeratorgettextelement.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/TextElementEnumeratorMoveNext.csproj b/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/TextElementEnumeratorMoveNext.csproj
deleted file mode 100644
index fbc809baef..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/TextElementEnumeratorMoveNext.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="textelementenumeratormovenext.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/TextElementEnumeratorReset.csproj b/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/TextElementEnumeratorReset.csproj
deleted file mode 100644
index e2089806ec..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/TextElementEnumeratorReset.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="textelementenumeratorreset.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/textelementenumeratorcurrent.cs b/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/textelementenumeratorcurrent.cs
deleted file mode 100644
index 7369ef772f..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/textelementenumeratorcurrent.cs
+++ /dev/null
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/textelementenumeratorelementindex.cs b/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/textelementenumeratorelementindex.cs
deleted file mode 100644
index 6a9c144556..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/textelementenumeratorelementindex.cs
+++ /dev/null
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/textelementenumeratorgettextelement.cs b/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/textelementenumeratorgettextelement.cs
deleted file mode 100644
index a0c6caa59e..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/textelementenumeratorgettextelement.cs
+++ /dev/null
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/textelementenumeratormovenext.cs b/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/textelementenumeratormovenext.cs
deleted file mode 100644
index adcefaefd9..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/textelementenumeratormovenext.cs
+++ /dev/null
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/textelementenumeratorreset.cs b/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/textelementenumeratorreset.cs
deleted file mode 100644
index 0f847678fa..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textelementenumerator/textelementenumeratorreset.cs
+++ /dev/null
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textinfo/TextInfoCultureName.csproj b/tests/src/CoreMangLib/cti/system/globalization/textinfo/TextInfoCultureName.csproj
deleted file mode 100644
index 490e931df9..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textinfo/TextInfoCultureName.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="textinfoculturename.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textinfo/TextInfoEquals.csproj b/tests/src/CoreMangLib/cti/system/globalization/textinfo/TextInfoEquals.csproj
deleted file mode 100644
index b3785d2b9c..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textinfo/TextInfoEquals.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="textinfoequals.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textinfo/TextInfoGetHashCode.csproj b/tests/src/CoreMangLib/cti/system/globalization/textinfo/TextInfoGetHashCode.csproj
deleted file mode 100644
index f3df729358..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textinfo/TextInfoGetHashCode.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="textinfogethashcode.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textinfo/TextInfoIsReadOnly.csproj b/tests/src/CoreMangLib/cti/system/globalization/textinfo/TextInfoIsReadOnly.csproj
deleted file mode 100644
index 23de89ae51..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textinfo/TextInfoIsReadOnly.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="textinfoisreadonly.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textinfo/TextInfoToString.csproj b/tests/src/CoreMangLib/cti/system/globalization/textinfo/TextInfoToString.csproj
deleted file mode 100644
index 90dc881304..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textinfo/TextInfoToString.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="textinfotostring.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textinfo/TextInfoToUpper1.csproj b/tests/src/CoreMangLib/cti/system/globalization/textinfo/TextInfoToUpper1.csproj
deleted file mode 100644
index a1ab434288..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textinfo/TextInfoToUpper1.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="textinfotoupper1.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textinfo/TextInfoToUpper2.csproj b/tests/src/CoreMangLib/cti/system/globalization/textinfo/TextInfoToUpper2.csproj
deleted file mode 100644
index 2ba47808f6..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textinfo/TextInfoToUpper2.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="textinfotoupper2.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textinfo/textinfoculturename.cs b/tests/src/CoreMangLib/cti/system/globalization/textinfo/textinfoculturename.cs
deleted file mode 100644
index 7d094f80a4..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textinfo/textinfoculturename.cs
+++ /dev/null
@@ -1,104 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// System.Globalization.TextInfo.CultureName
-/// </summary>
-public class TextInfoCultureName
-{
-    public static int Main()
-    {
-        TextInfoCultureName testObj = new TextInfoCultureName();
-        TestLibrary.TestFramework.BeginTestCase("for Property:System.Globalization.TextInfo.CultureInfo");
-
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-
-        return retVal;
-    }
-
-    #region PositiveTesting
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        const string c_TEST_DESC = "PosTest1: Verify the en-US TextInfo";
-        const string c_TEST_ID = "P001";
-
-        TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
-
-        CultureInfo ci = new CultureInfo("en-US");
-        TextInfo textInfoUS = ci.TextInfo;
-        String cultureName = ci.Name;
-        try
-        {
-
-            if (cultureName != textInfoUS.CultureName)
-            {
-                string errorDesc = "Value is not " + cultureName + " as expected: Actual(" + textInfoUS.CultureName + ")";
-                TestLibrary.TestFramework.LogError("001" + " TestId-" + c_TEST_ID, errorDesc);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002" + " TestId-" + c_TEST_ID, "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        const string c_TEST_DESC = "PosTest2: Verify the fr-FR CultureInfo's TextInfo";
-        const string c_TEST_ID = "P002";
-
-
-        CultureInfo ci = new CultureInfo("fr-FR");
-        TextInfo textInfoFrance = ci.TextInfo;
-        String cultureName = ci.Name;
-
-        TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
-
-        try
-        {
-            if (cultureName != textInfoFrance.CultureName)
-            {
-                string errorDesc = "Value is not " + cultureName + " as expected: Actual(" + textInfoFrance.CultureName + ")";
-                TestLibrary.TestFramework.LogError("003" + " TestId-" + c_TEST_ID, errorDesc);
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004" + " TestId-" + c_TEST_ID, "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-}
-
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textinfo/textinfoequals.cs b/tests/src/CoreMangLib/cti/system/globalization/textinfo/textinfoequals.cs
deleted file mode 100644
index ca7dae7f7f..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textinfo/textinfoequals.cs
+++ /dev/null
@@ -1,243 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// System.Globalization.TextInfo.Equals(Object)
-/// </summary>
-public class TextInfoEquals
-{
-
-    private int c_MINI_STRING_LENGTH = 8;
-    private int c_MAX_STRING_LENGTH = 256;
-
-    public static int Main()
-    {
-        TextInfoEquals testObj = new TextInfoEquals();
-        TestLibrary.TestFramework.BeginTestCase("for Method:System.Globalization.TextInfo.Equals(Object)");
-
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-        retVal = PosTest5() && retVal;
-        retVal = PosTest6() && retVal;
-
-        return retVal;
-    }
-
-    #region PositiveTesting
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        const string c_TEST_DESC = "PosTest1: Verify same culture TextInfo equals original TextInfo. ";
-        const string c_TEST_ID = "P001";
-
-        TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
-
-        CultureInfo ci = new CultureInfo("en-US");
-        CultureInfo ci2 = new CultureInfo("en-US");
-        object textInfo = ci2.TextInfo;
-
-        try
-        {
-            
-            if (!ci.TextInfo.Equals(textInfo))
-            {
-                string errorDesc = "the second TextInfo should equal original TextInfo.";
-                TestLibrary.TestFramework.LogError("001" + " TestId-" + c_TEST_ID, errorDesc);
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002" + " TestId-" + c_TEST_ID, "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        const string c_TEST_DESC = "PosTest2: Verify the TextInfo is not same CultureInfo's . ";
-        const string c_TEST_ID = "P002";
-
-
-       TextInfo textInfoFrance = new CultureInfo("fr-FR").TextInfo;
-       TextInfo textInfoUS = new CultureInfo("en-US").TextInfo;
-
-       TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
-
-        try
-        {
-            if (textInfoFrance.Equals((object)textInfoUS))
-            {
-                string errorDesc = "the TextInfos of differente CultureInfo should not equal. ";
-                TestLibrary.TestFramework.LogError("003" + " TestId-" + c_TEST_ID, errorDesc);
-                retVal = false;
-            }
-           
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004" + " TestId-" + c_TEST_ID, "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-        const string c_TEST_DESC = "PosTest3: Verify the TextInfo not equal a null reference . ";
-        const string c_TEST_ID = "P003";
-
-
-        TextInfo textInfoUS = new CultureInfo("en-US").TextInfo;
-
-        TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
-
-        try
-        {
-            if (textInfoUS.Equals(null))
-            {
-                string errorDesc = "the US CultureInfo's TextInfo should not equal a null reference. ";
-                TestLibrary.TestFramework.LogError("003" + " TestId-" + c_TEST_ID, errorDesc);
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004" + " TestId-" + c_TEST_ID, "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest4()
-    {
-        bool retVal = true;
-        const string c_TEST_DESC = "PosTest4: Verify the TextInfo not equal another type object . ";
-        const string c_TEST_ID = "P004";
-
-
-        TextInfo textInfoUS = new CultureInfo("en-US").TextInfo;
-        object obj = (object)(new MyClass());
-        TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
-
-        try
-        {
-            if (textInfoUS.Equals(obj))
-            {
-                string errorDesc = "the US CultureInfo's TextInfo should not equal user-defined type object. ";
-                TestLibrary.TestFramework.LogError("007" + " TestId-" + c_TEST_ID, errorDesc);
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("008" + " TestId-" + c_TEST_ID, "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest5()
-    {
-        bool retVal = true;
-        const string c_TEST_DESC = "PosTest5: Verify the TextInfo not equal a int object . ";
-        const string c_TEST_ID = "P005";
-
-
-        TextInfo textInfoUS = new CultureInfo("en-US").TextInfo;
-        int i = TestLibrary.Generator.GetInt32(-55);
-        object intObject = i as object;
-        TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
-
-        try
-        {
-            if (textInfoUS.Equals(intObject))
-            {
-                string errorDesc = "the US CultureInfo's TextInfo should not equal int object. ";
-                TestLibrary.TestFramework.LogError("007" + " TestId-" + c_TEST_ID, errorDesc);
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("008" + " TestId-" + c_TEST_ID, "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest6()
-    {
-        bool retVal = true;
-        const string c_TEST_DESC = "PosTest6: Verify the TextInfo not equal a string object . ";
-        const string c_TEST_ID = "P006";
-
-
-        TextInfo textInfoUS = new CultureInfo("en-US").TextInfo;
-        String str = TestLibrary.Generator.GetString(-55, false,c_MINI_STRING_LENGTH,c_MAX_STRING_LENGTH);
-        object strObject = str as object;
-
-        TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
-
-        try
-        {
-            if (textInfoUS.Equals(strObject))
-            {
-                string errorDesc = "the US CultureInfo's TextInfo should not equal string object. ";
-                TestLibrary.TestFramework.LogError("009" + " TestId-" + c_TEST_ID, errorDesc);
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("010" + " TestId-" + c_TEST_ID, "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-
-    #region Customer Class
-    public class MyClass
-    {
- 
-    }
-    #endregion
-}
-
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textinfo/textinfogethashcode.cs b/tests/src/CoreMangLib/cti/system/globalization/textinfo/textinfogethashcode.cs
deleted file mode 100644
index f6cf23af91..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textinfo/textinfogethashcode.cs
+++ /dev/null
@@ -1,108 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// System.Globalization.TextInfo.GetHashCode()
-/// </summary>
-public class TextInfoGetHashCode
-{
-    public static int Main()
-    {
-        TextInfoGetHashCode testObj = new TextInfoGetHashCode();
-        TestLibrary.TestFramework.BeginTestCase("for Method:System.Globalization.TextInfo.GetHashCode()");
-
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-
-        return retVal;
-    }
-
-    #region PositiveTesting
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        const string c_TEST_DESC = "PosTest1: Verify the TextInfo equals original TextInfo. ";
-        const string c_TEST_ID = "P001";
-
-        TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
-
-        CultureInfo ci = new CultureInfo("en-US");
-        CultureInfo ci2 = new CultureInfo("en-US");
-        object textInfo = ci2.TextInfo;
-       
-        try
-        {
-            int originalHC = ci.TextInfo.GetHashCode();
-            int clonedHC = (textInfo as TextInfo).GetHashCode();
-            if (originalHC != clonedHC)
-            {
-                string errorDesc = "the cloned TextInfo'HashCode should equal original TextInfo's HashCode.";
-                TestLibrary.TestFramework.LogError("001" + " TestId-" + c_TEST_ID, errorDesc);
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002" + " TestId-" + c_TEST_ID, "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        const string c_TEST_DESC = "PosTest2: Verify the TextInfo is not same  CultureInfo's . ";
-        const string c_TEST_ID = "P002";
-
-
-        TextInfo textInfoFrance = new CultureInfo("fr-FR").TextInfo;
-        TextInfo textInfoUS = new CultureInfo("en-US").TextInfo;
-
-        TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
-
-        try
-        {
-            int franceHashCode = textInfoFrance.GetHashCode();
-            int usHashCode = textInfoUS.GetHashCode();
-            if (franceHashCode == usHashCode)
-            {
-                string errorDesc = "the differente TextInfo's HashCode should not equal. ";
-                TestLibrary.TestFramework.LogError("003" + " TestId-" + c_TEST_ID, errorDesc);
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004" + " TestId-" + c_TEST_ID, "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-}
-
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textinfo/textinfoisreadonly.cs b/tests/src/CoreMangLib/cti/system/globalization/textinfo/textinfoisreadonly.cs
deleted file mode 100644
index f0d9eb1c84..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textinfo/textinfoisreadonly.cs
+++ /dev/null
@@ -1,103 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// System.Globalization.TextInfo.IsReadOnly
-/// </summary>
-public class TextInfoIsReadOnly
-{
-    public static int Main()
-    {
-        TextInfoIsReadOnly testObj = new TextInfoIsReadOnly();
-        TestLibrary.TestFramework.BeginTestCase("for Property:System.Globalization.TextInfo.IsReadOnly");
-
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-
-        return retVal;
-    }
-
-    #region PositiveTesting
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        const string c_TEST_DESC = "PosTest1: Verify the new TextInfo is not readOnly";
-        const string c_TEST_ID = "P001";
-
-        TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
-
-        CultureInfo ci = new CultureInfo("en-US");
-        TextInfo textInfoUS = ci.TextInfo;
-
-        try
-        {
-
-            if (textInfoUS.IsReadOnly)
-            {
-                string errorDesc = "Value is not true as expected: Actual is false";
-                TestLibrary.TestFramework.LogError("001" + " TestId-" + c_TEST_ID, errorDesc);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002" + " TestId-" + c_TEST_ID, "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        const string c_TEST_DESC = "PosTest2: Verify the fr-FR CultureInfo's TextInfo";
-        const string c_TEST_ID = "P002";
-
-
-        CultureInfo ci = new CultureInfo("fr-FR");
-        TextInfo textInfoFrance = ci.TextInfo;
-
-        TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
-
-        try
-        {
-            if (textInfoFrance.IsReadOnly)
-            {
-                string errorDesc = "Value is not true as expected: Actual is false";
-                TestLibrary.TestFramework.LogError("003" + " TestId-" + c_TEST_ID, errorDesc);
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004" + " TestId-" + c_TEST_ID, "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-}
-
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textinfo/textinfotostring.cs b/tests/src/CoreMangLib/cti/system/globalization/textinfo/textinfotostring.cs
deleted file mode 100644
index 27064abb32..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textinfo/textinfotostring.cs
+++ /dev/null
@@ -1,102 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// System.Globalization.TextInfo.ToString()
-/// </summary>
-public class TextInfoToString
-{
-    public static int Main()
-    {
-        TextInfoToString testObj = new TextInfoToString();
-        TestLibrary.TestFramework.BeginTestCase("for Method:System.Globalization.TextInfo.ToString()");
-
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-
-        return retVal;
-    }
-
-    #region PositiveTesting
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        const string c_TEST_DESC = "PosTest1: Verify the en-US TextInfo";
-        const string c_TEST_ID = "P001";
-
-        TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
-
-        TextInfo textInfoUS = new CultureInfo("en-US").TextInfo;
-        String textinfoStr = "TextInfo - en-US";
-        try
-        {
-
-            if (textinfoStr != textInfoUS.ToString())
-            {
-                string errorDesc = "Value is not " + textinfoStr + " as expected: Actual(" + textInfoUS.ToString() + ")";
-                TestLibrary.TestFramework.LogError("001" + " TestId-" + c_TEST_ID, errorDesc);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002" + " TestId-" + c_TEST_ID, "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        const string c_TEST_DESC = "PosTest2: Verify the fr-FR CultureInfo's TextInfo";
-        const string c_TEST_ID = "P002";
-
-
-        TextInfo    textInfoFrance = new CultureInfo("fr-FR").TextInfo;
-        String textinfoStr = "TextInfo - fr-FR";
-
-        TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
-
-        try
-        {
-            if (textinfoStr != textInfoFrance.ToString())
-            {
-                string errorDesc = "Value is not " + textinfoStr + " as expected: Actual(" + textInfoFrance.ToString() + ")";
-                TestLibrary.TestFramework.LogError("003" + " TestId-" + c_TEST_ID, errorDesc);
-                retVal = false;
-            }
-
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004" + " TestId-" + c_TEST_ID, "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-}
-
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textinfo/textinfotoupper1.cs b/tests/src/CoreMangLib/cti/system/globalization/textinfo/textinfotoupper1.cs
deleted file mode 100644
index d87eac576f..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textinfo/textinfotoupper1.cs
+++ /dev/null
@@ -1,223 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// System.Globalization.TextInfo.ToUpper(Char)
-/// </summary>
-public class TextInfoToUpper1
-{
-    public static int Main()
-    {
-        TextInfoToUpper1 testObj = new TextInfoToUpper1();
-
-        TestLibrary.TestFramework.BeginTestCase("for method: System.Globalization.TextInfo.ToUpper(Char)");
-        if (testObj.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest4() && retVal;
-        retVal = PosTest5() && retVal;
-
-        return retVal;
-    }
-
-    public bool PosTest1()
-    {
-        bool retVal = true;
-
-        const string c_TEST_ID = "P001";
-        const string c_TEST_DESC = "PosTest1: uppercase character";
-        string errorDesc;
-
-        char ch = 'A';
-        char expectedChar = ch;
-        TextInfo textInfo = new CultureInfo("en-US").TextInfo;
-
-
-        TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
-        try
-        {
-           
-            char actualChar = textInfo.ToUpper(ch);
-            if (actualChar != expectedChar)
-            {
-                errorDesc = string.Format("Uppercase of character \\u{0:x} is not the value ", (int)ch);
-                errorDesc += string.Format("\\u{0:x} as expected: actual(\\u{1:x}", (int)expectedChar, (int)actualChar);
-                TestLibrary.TestFramework.LogError("001" + " TestId-" + c_TEST_ID, errorDesc);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            errorDesc = "Unexpected exception: " + e;
-            TestLibrary.TestFramework.LogError("002" + " TestId-" + c_TEST_ID, errorDesc);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest2()
-    {
-        bool retVal = true;
-
-        const string c_TEST_ID = "P002";
-        const string c_TEST_DESC = "PosTest2: lowercase character";
-        string errorDesc;
-
-        char ch = 'a';
-        char expectedChar = 'A';
-        TextInfo textInfo = new CultureInfo("en-US").TextInfo;
-
-        TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
-        try
-        {
-            
-            char actualChar = textInfo.ToUpper(ch);
-            if (actualChar != expectedChar)
-            {
-                errorDesc = string.Format("Uppercase of character \\u{0:x} is not the value ", (int)ch);
-                errorDesc += string.Format("\\u{0:x} as expected: actual(\\u{1:x}", (int)expectedChar, (int)actualChar);
-                TestLibrary.TestFramework.LogError("003" + " TestId-" + c_TEST_ID, errorDesc);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            errorDesc = "Unexpected exception: " + e;
-            TestLibrary.TestFramework.LogError("004" + " TestId-" + c_TEST_ID, errorDesc);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest3()
-    {
-        bool retVal = true;
-
-        const string c_TEST_ID = "P003";
-        const string c_TEST_DESC = "PosTest3: non-alphabetic character";
-        string errorDesc;
-
-        char ch = Convert.ToChar(TestLibrary.Generator.GetInt16(-55) % 10 + '0');
-        char expectedChar = ch;
-        TextInfo textInfo = new CultureInfo("en-US").TextInfo;
-
-        TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
-        try
-        {
-            
-            char actualChar = textInfo.ToUpper(ch);
-            if (actualChar != expectedChar)
-            {
-                errorDesc = string.Format("Uppercase of character \\u{0:x} is not the value ", (int)ch);
-                errorDesc += string.Format("\\u{0:x} as expected: actual(\\u{1:x}", (int)expectedChar, (int)actualChar);
-                TestLibrary.TestFramework.LogError("005" + " TestId-" + c_TEST_ID, errorDesc);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            errorDesc = "Unexpected exception: " + e;
-            TestLibrary.TestFramework.LogError("006" + " TestId-" + c_TEST_ID, errorDesc);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest4()
-    {
-        bool retVal = true;
-
-        const string c_TEST_ID = "P004";
-        const string c_TEST_DESC = "PosTest4: uppercase character and TextInfo is french CultureInfo's";
-        string errorDesc;
-
-        char ch = 'G';
-        char expectedChar = ch;
-        TextInfo textInfo = new CultureInfo("fr-FR").TextInfo;
-
-
-        TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
-        try
-        {
-
-            char actualChar = textInfo.ToUpper(ch);
-            if (actualChar != expectedChar)
-            {
-                errorDesc = string.Format("Uppercase of character \\u{0:x} is not the value ", (int)ch);
-                errorDesc += string.Format("\\u{0:x} as expected: actual(\\u{1:x}", (int)expectedChar, (int)actualChar);
-                TestLibrary.TestFramework.LogError("007" + " TestId-" + c_TEST_ID, errorDesc);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            errorDesc = "Unexpected exception: " + e;
-            TestLibrary.TestFramework.LogError("008" + " TestId-" + c_TEST_ID, errorDesc);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool PosTest5()
-    {
-        bool retVal = true;
-
-        const string c_TEST_ID = "P005";
-        const string c_TEST_DESC = "PosTest5: lowercase character and TextInfo is french(France) CultureInfo's";
-        string errorDesc;
-
-        char ch = 'g';
-        char expectedChar = 'G';
-        TextInfo textInfo = new CultureInfo("fr-FR").TextInfo;
-
-        TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
-        try
-        {
-
-            char actualChar = textInfo.ToUpper(ch);
-            if (actualChar != expectedChar)
-            {
-                errorDesc = string.Format("Uppercase of character \\u{0:x} is not the value ", (int)ch);
-                errorDesc += string.Format("\\u{0:x} as expected: actual(\\u{1:x}", (int)expectedChar, (int)actualChar);
-                TestLibrary.TestFramework.LogError("009" + " TestId-" + c_TEST_ID, errorDesc);
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            errorDesc = "Unexpected exception: " + e;
-            TestLibrary.TestFramework.LogError("010" + " TestId-" + c_TEST_ID, errorDesc);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-}
-
diff --git a/tests/src/CoreMangLib/cti/system/globalization/textinfo/textinfotoupper2.cs b/tests/src/CoreMangLib/cti/system/globalization/textinfo/textinfotoupper2.cs
deleted file mode 100644
index ff385637d3..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/textinfo/textinfotoupper2.cs
+++ /dev/null
@@ -1,244 +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.
-using System;
-using System.Globalization;
-
-/// <summary>
-/// System.Globalization.TextInfo.ToUpper(String)
-/// </summary>
-public class TextInfoToUpper2
-{
-    public static int Main()
-    {
-        TextInfoToUpper2 stu1 = new TextInfoToUpper2();
-        TestLibrary.TestFramework.BeginTestCase("for Method:System.Globalization.TextInfo.ToUpper(String)");
-
-        if (stu1.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        retVal = PosTest2() && retVal;
-        retVal = PosTest3() && retVal;
-        retVal = PosTest5() && retVal;
-        retVal = PosTest6() && retVal;
-
-        TestLibrary.TestFramework.LogInformation("[Negative]");
-        retVal = NegTest1() && retVal;
-        retVal = NegTest2() && retVal;
-
-        return retVal;
-    }
-
-    #region PositiveTesting
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        string strA = "HelloWorld!";
-        string ActualResult;
-
-        TextInfo textInfo = new CultureInfo("en-US").TextInfo;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: normal string ToUpper");
-        try
-        {   
-            ActualResult = textInfo.ToUpper(strA);
-            if (ActualResult != "HELLOWORLD!")
-            {
-                TestLibrary.TestFramework.LogError("001", "normal string ToUpper ActualResult is not the ExpectResult");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    public bool PosTest2()
-    {
-        bool retVal = true;
-        string strA = string.Empty;
-        string ActualResult;
-
-        TextInfo textInfo = new CultureInfo("en-US").TextInfo;
-
-
-        TestLibrary.TestFramework.BeginScenario("PosTest2: empty string ToUpper");
-        try
-        {
-            ActualResult = textInfo.ToUpper(strA);
-            if (ActualResult != string.Empty)
-            {
-                TestLibrary.TestFramework.LogError("003", "empty string ToUpper ActualResult is not the ExpectResult");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("004", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    
-    public bool PosTest3()
-    {
-        bool retVal = true;
-        string strA = "Hello\n\0World\u0009!";
-        string ActualResult;
-
-        TextInfo textInfo = new CultureInfo("en-US").TextInfo;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest3: normal string with special symbols '\u0009' and '\0'");
-        try
-        {
-            
-            ActualResult = textInfo.ToUpper(strA);
-            if (ActualResult != "HELLO\n\0WORLD\t!")
-            {
-                TestLibrary.TestFramework.LogError("005", "normal string with special symbols ToUpper ActualResult is not the ExpectResult");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("006", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest5()
-    {
-        bool retVal = true;
-        string strA = "HelloWorld!";
-        string ActualResult;
-
-        TextInfo textInfo = new CultureInfo("fr-FR").TextInfo;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest1: normal string ToUpper and TextInfo is French (France) CultureInfo's");
-        try
-        {
-            ActualResult = textInfo.ToUpper(strA);
-            if (ActualResult != "HELLOWORLD!")
-            {
-                TestLibrary.TestFramework.LogError("009", "normal string ToUpper ActualResult is not the ExpectResult");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("010", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-
-    public bool PosTest6()
-    {
-        bool retVal = true;
-        string strA = "Hello\n\0World\u0009!";
-        string ActualResult;
-
-        TextInfo textInfo = new CultureInfo("fr-FR").TextInfo;
-
-        TestLibrary.TestFramework.BeginScenario("PosTest6: normal string with special symbols and TextInfo is French (France) CultureInfo's");
-        try
-        {
-
-            ActualResult = textInfo.ToUpper(strA);
-            if (ActualResult != "HELLO\n\0WORLD\t!")
-            {
-                TestLibrary.TestFramework.LogError("011", "normal string with special symbols ToUpper ActualResult is not the ExpectResult");
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("012", "Unexpected exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-
-    #region NegativeTests
-    public bool NegTest1()
-    {
-        bool retVal = true;
-
-        const string c_TEST_DESC = "NegTest1: The string is a null reference";
-        const string c_TEST_ID = "N001";
-
-        TextInfo textInfoUS = new CultureInfo("en-US").TextInfo;
-        string str = null;
-
-        TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
-
-        try
-        {
-            textInfoUS.ToUpper(str);
-            TestLibrary.TestFramework.LogError("009" + " TestId-" + c_TEST_ID, "ArgumentNullException is not thrown as expected.");
-            retVal = false;
-        }
-        catch (ArgumentNullException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("010" + " TestId-" + c_TEST_ID, "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-
-    public bool NegTest2()
-    {
-        bool retVal = true;
-
-        const string c_TEST_DESC = "NegTest2: The string is a null reference and TextInfo is French (France) CultureInfo's";
-        const string c_TEST_ID = "N001";
-
-        TextInfo textInfoUS = new CultureInfo("fr-FR").TextInfo;
-        string str = null;
-
-        TestLibrary.TestFramework.BeginScenario(c_TEST_DESC);
-
-        try
-        {
-            textInfoUS.ToUpper(str);
-            TestLibrary.TestFramework.LogError("011" + " TestId-" + c_TEST_ID, "ArgumentNullException is not thrown as expected.");
-            retVal = false;
-        }
-        catch (ArgumentNullException)
-        {
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("012" + " TestId-" + c_TEST_ID, "Unexpected exception: " + e);
-            retVal = false;
-        }
-
-        return retVal;
-    }
-    #endregion
-}
-
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryClosePunctuation.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryClosePunctuation.csproj
deleted file mode 100644
index 8132678627..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryClosePunctuation.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategoryclosepunctuation.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryConnectorPunctuation.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryConnectorPunctuation.csproj
deleted file mode 100644
index 11f3d94e85..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryConnectorPunctuation.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategoryconnectorpunctuation.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryControl.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryControl.csproj
deleted file mode 100644
index ae4ca6c387..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryControl.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategorycontrol.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryDashPunctuation.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryDashPunctuation.csproj
deleted file mode 100644
index 739caab798..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryDashPunctuation.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategorydashpunctuation.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryDecimalDigitNumber.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryDecimalDigitNumber.csproj
deleted file mode 100644
index 8b3ef430e3..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryDecimalDigitNumber.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategorydecimaldigitnumber.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryEnclosingMark.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryEnclosingMark.csproj
deleted file mode 100644
index 126d970b72..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryEnclosingMark.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategoryenclosingmark.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryFinalQuotePunctuation.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryFinalQuotePunctuation.csproj
deleted file mode 100644
index c6f43d1278..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryFinalQuotePunctuation.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategoryfinalquotepunctuation.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryFormat.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryFormat.csproj
deleted file mode 100644
index 96f5fc5863..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryFormat.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategoryformat.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryInitialQuotePunctuation.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryInitialQuotePunctuation.csproj
deleted file mode 100644
index 59366df06c..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryInitialQuotePunctuation.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategoryinitialquotepunctuation.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryLetterNumber.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryLetterNumber.csproj
deleted file mode 100644
index ab5c9ceecd..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryLetterNumber.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategoryletternumber.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryLineSeparator.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryLineSeparator.csproj
deleted file mode 100644
index ef9346c0e7..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryLineSeparator.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategorylineseparator.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryLowercaseLetter.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryLowercaseLetter.csproj
deleted file mode 100644
index 178bae3ca0..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryLowercaseLetter.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategorylowercaseletter.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryMathSymbol.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryMathSymbol.csproj
deleted file mode 100644
index 5a32d07ad3..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryMathSymbol.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategorymathsymbol.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryModifierLetter.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryModifierLetter.csproj
deleted file mode 100644
index a94578a65d..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryModifierLetter.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategorymodifierletter.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryModifierSymbol.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryModifierSymbol.csproj
deleted file mode 100644
index 7a9793265e..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryModifierSymbol.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategorymodifiersymbol.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryNonSpacingMark.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryNonSpacingMark.csproj
deleted file mode 100644
index e0278b659c..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryNonSpacingMark.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategorynonspacingmark.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryOpenPunctuation.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryOpenPunctuation.csproj
deleted file mode 100644
index e6bb5a427c..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryOpenPunctuation.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategoryopenpunctuation.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryOtherLetter.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryOtherLetter.csproj
deleted file mode 100644
index ea407c0f68..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryOtherLetter.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategoryotherletter.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryOtherNotAssigned.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryOtherNotAssigned.csproj
deleted file mode 100644
index 308e4720e5..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryOtherNotAssigned.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategoryothernotassigned.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryOtherNumber.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryOtherNumber.csproj
deleted file mode 100644
index 704ad15cf7..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryOtherNumber.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategoryothernumber.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryOtherPunctuation.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryOtherPunctuation.csproj
deleted file mode 100644
index 346fce411e..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryOtherPunctuation.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategoryotherpunctuation.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryOtherSymbol.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryOtherSymbol.csproj
deleted file mode 100644
index 73ef39db0f..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryOtherSymbol.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategoryothersymbol.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryParagraphSeparator.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryParagraphSeparator.csproj
deleted file mode 100644
index e21f98425e..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryParagraphSeparator.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategoryparagraphseparator.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryPrivateUse.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryPrivateUse.csproj
deleted file mode 100644
index 8889136510..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryPrivateUse.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategoryprivateuse.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategorySpaceSeparator.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategorySpaceSeparator.csproj
deleted file mode 100644
index 3e16f7f37e..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategorySpaceSeparator.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategoryspaceseparator.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategorySpacingCombiningMark.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategorySpacingCombiningMark.csproj
deleted file mode 100644
index 5c617ba633..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategorySpacingCombiningMark.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategoryspacingcombiningmark.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategorySurrogate.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategorySurrogate.csproj
deleted file mode 100644
index cb263d0dd9..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategorySurrogate.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategorysurrogate.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryTitlecaseLetter.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryTitlecaseLetter.csproj
deleted file mode 100644
index 47655c1195..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryTitlecaseLetter.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategorytitlecaseletter.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryUppercaseLetter.csproj b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryUppercaseLetter.csproj
deleted file mode 100644
index 266bb41667..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/UnicodeCategoryUppercaseLetter.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<?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>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
-    <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
-  </PropertyGroup>
-  <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
-      <Visible>False</Visible>
-    </CodeAnalysisDependentAssemblyPaths>
-  </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="unicodecategoryuppercaseletter.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-  <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryclosepunctuation.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryclosepunctuation.cs
deleted file mode 100644
index 98af37cdc0..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryclosepunctuation.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.ClosePunctuation [v-minch]
-/// </summary>
-public class UnicodeCategoryClosePunctuation
-{
-    public static int Main()
-    {
-        UnicodeCategoryClosePunctuation unicodeClosePunc = new UnicodeCategoryClosePunctuation();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryClosePunctuation");
-        if (unicodeClosePunc.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the ClosePunctuation Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.ClosePunctuation;
-            if (myUnicodeCategory != (UnicodeCategory)21)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 21 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryconnectorpunctuation.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryconnectorpunctuation.cs
deleted file mode 100644
index dfd6b85756..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryconnectorpunctuation.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.ConnectorPunctuation [v-minch]
-/// </summary>
-public class UnicodeCategoryConnectorPunctuation
-{
-    public static int Main()
-    {
-        UnicodeCategoryConnectorPunctuation unicodeConnectPunc = new UnicodeCategoryConnectorPunctuation();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryConnectorPunctuation");
-        if (unicodeConnectPunc.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the ConnectorPunctuation Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.ConnectorPunctuation;
-            if (myUnicodeCategory != (UnicodeCategory)18)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 18 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorycontrol.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorycontrol.cs
deleted file mode 100644
index 9aa99a8e5d..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorycontrol.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.Control [v-minch]
-/// </summary>
-public class UnicodeCategoryControl
-{
-    public static int Main()
-    {
-        UnicodeCategoryControl unicodeControl = new UnicodeCategoryControl();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryControl");
-        if (unicodeControl.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the Control Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.Control;
-            if (myUnicodeCategory != (UnicodeCategory)14)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 14 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorydashpunctuation.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorydashpunctuation.cs
deleted file mode 100644
index 8fb4ef20b9..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorydashpunctuation.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.DashPunctuation [v-minch]
-/// </summary>
-public class UnicodeCategoryDashPunctuation
-{
-    public static int Main()
-    {
-        UnicodeCategoryDashPunctuation unicodeDashPunctuation = new UnicodeCategoryDashPunctuation();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryDashPunctuation");
-        if (unicodeDashPunctuation.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the DashPunctuation Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.DashPunctuation;
-            if (myUnicodeCategory != (UnicodeCategory)19)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 19 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorydecimaldigitnumber.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorydecimaldigitnumber.cs
deleted file mode 100644
index 06b08e4beb..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorydecimaldigitnumber.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.DecimalDigitNumber [v-minch]
-/// </summary>
-public class UnicodeCategoryDecimalDigitNumber
-{
-    public static int Main()
-    {
-        UnicodeCategoryDecimalDigitNumber unicodeDecimalDigitNumber = new UnicodeCategoryDecimalDigitNumber();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryDecimalDigitNumber");
-        if (unicodeDecimalDigitNumber.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the DecimalDigitNumber Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.DecimalDigitNumber;
-            if (myUnicodeCategory != (UnicodeCategory)8)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 8 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryenclosingmark.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryenclosingmark.cs
deleted file mode 100644
index 18d837bae5..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryenclosingmark.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.EnclosingMark [v-minch]
-/// </summary>
-public class UnicodeCategoryEnclosingMark
-{
-    public static int Main()
-    {
-        UnicodeCategoryEnclosingMark unicodeEnclosingMark = new UnicodeCategoryEnclosingMark();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryEnclosingMark");
-        if (unicodeEnclosingMark.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the EnclosingMark Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.EnclosingMark;
-            if (myUnicodeCategory != (UnicodeCategory)7)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 7 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryfinalquotepunctuation.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryfinalquotepunctuation.cs
deleted file mode 100644
index c1693a43a0..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryfinalquotepunctuation.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.FinalQuotePunctuation [v-minch]
-/// </summary>
-public class UnicodeCategoryFinalQuotePunctuation
-{
-    public static int Main()
-    {
-        UnicodeCategoryFinalQuotePunctuation unicodeFinalQuotePunctuation = new UnicodeCategoryFinalQuotePunctuation();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryFinalQuotePunctuation");
-        if (unicodeFinalQuotePunctuation.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the FinalQuotePunctuation Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.FinalQuotePunctuation;
-            if (myUnicodeCategory != (UnicodeCategory)23)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 23 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryformat.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryformat.cs
deleted file mode 100644
index f8ce3d50a0..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryformat.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.Format [v-minch]
-/// </summary>
-public class UnicodeCategoryFormat
-{
-    public static int Main()
-    {
-        UnicodeCategoryFormat unicodeFormat = new UnicodeCategoryFormat();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryFormat");
-        if (unicodeFormat.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the Format Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.Format;
-            if (myUnicodeCategory != (UnicodeCategory)15)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 15 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryinitialquotepunctuation.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryinitialquotepunctuation.cs
deleted file mode 100644
index 84070ec329..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryinitialquotepunctuation.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.InitialQuotePunctuation [v-minch]
-/// </summary>
-public class UnicodeCategoryInitialQuotePunctuation
-{
-    public static int Main()
-    {
-        UnicodeCategoryInitialQuotePunctuation unicodeInitialQuotePunctuation = new UnicodeCategoryInitialQuotePunctuation();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryInitialQuotePunctuation");
-        if (unicodeInitialQuotePunctuation.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the InitialQuotePunctuation Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.InitialQuotePunctuation;
-            if (myUnicodeCategory != (UnicodeCategory)22)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 22 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryletternumber.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryletternumber.cs
deleted file mode 100644
index f95c248cef..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryletternumber.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.LetterNumber [v-minch]
-/// </summary>
-public class UnicodeCategoryLetterNumber
-{
-    public static int Main()
-    {
-        UnicodeCategoryLetterNumber unicodeLetterNumber = new UnicodeCategoryLetterNumber();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryLetterNumber");
-        if (unicodeLetterNumber.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the LetterNumber Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.LetterNumber;
-            if (myUnicodeCategory != (UnicodeCategory)9)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 9 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorylineseparator.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorylineseparator.cs
deleted file mode 100644
index 8ea8f2edcd..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorylineseparator.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.LineSeparator [v-minch]
-/// </summary>
-public class UnicodeCategoryLineSeparator
-{
-    public static int Main()
-    {
-        UnicodeCategoryLineSeparator unicodeLineSeparator = new UnicodeCategoryLineSeparator();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryLineSeparator");
-        if (unicodeLineSeparator.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the LineSeparator Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.LineSeparator;
-            if (myUnicodeCategory != (UnicodeCategory)12)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 12 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorylowercaseletter.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorylowercaseletter.cs
deleted file mode 100644
index 35d628066d..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorylowercaseletter.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.LowercaseLette [v-minch]
-/// </summary>
-public class UnicodeCategoryLowercaseLetter
-{
-    public static int Main()
-    {
-        UnicodeCategoryLowercaseLetter unicodeLowercaseLetter = new UnicodeCategoryLowercaseLetter();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryLowercaseLetter");
-        if (unicodeLowercaseLetter.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the LowercaseLetter Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.LowercaseLetter;
-            if (myUnicodeCategory != (UnicodeCategory)1)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 1 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorymathsymbol.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorymathsymbol.cs
deleted file mode 100644
index 66a8427b04..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorymathsymbol.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.MathSymbol [v-minch]
-/// </summary>
-public class UnicodeCategoryMathSymbol
-{
-    public static int Main()
-    {
-        UnicodeCategoryMathSymbol unicodeMathSymbol = new UnicodeCategoryMathSymbol();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryMathSymbol");
-        if (unicodeMathSymbol.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the MathSymbol Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.MathSymbol;
-            if (myUnicodeCategory != (UnicodeCategory)25)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 25 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorymodifierletter.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorymodifierletter.cs
deleted file mode 100644
index 63e6cc510b..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorymodifierletter.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.ModifierLetter [v-minch]
-/// </summary>
-public class UnicodeCategoryModifierLetter
-{
-    public static int Main()
-    {
-        UnicodeCategoryModifierLetter unicodeModifierLetter = new UnicodeCategoryModifierLetter();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryModifierLetter");
-        if (unicodeModifierLetter.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the ModifierLetter Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.ModifierLetter;
-            if (myUnicodeCategory != (UnicodeCategory)3)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 3 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorymodifiersymbol.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorymodifiersymbol.cs
deleted file mode 100644
index c63f4a7fa1..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorymodifiersymbol.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.ModifierSymbol [v-minch]
-/// </summary>
-public class UnicodeCategoryModifierSymbol
-{
-    public static int Main()
-    {
-        UnicodeCategoryModifierSymbol unicodeModifierSymbol = new UnicodeCategoryModifierSymbol();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryModifierSymbol");
-        if (unicodeModifierSymbol.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the ModifierSymbol Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.ModifierSymbol;
-            if (myUnicodeCategory != (UnicodeCategory)27)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 27 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorynonspacingmark.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorynonspacingmark.cs
deleted file mode 100644
index b815da9dfb..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorynonspacingmark.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.NonSpacingMark [v-minch]
-/// </summary>
-class UnicodeCategoryNonSpacingMark
-{
-    public static int Main()
-    {
-        UnicodeCategoryNonSpacingMark unicodeNonSpacingMark = new UnicodeCategoryNonSpacingMark();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryNonSpacingMark");
-        if (unicodeNonSpacingMark.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the NonSpacingMark Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.NonSpacingMark;
-            if (myUnicodeCategory != (UnicodeCategory)5)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 5 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryopenpunctuation.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryopenpunctuation.cs
deleted file mode 100644
index 914c69e55d..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryopenpunctuation.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.OpenPunctuation [v-minch]
-/// </summary>
-public class UnicodeCategoryOpenPunctuation
-{
-    public static int Main()
-    {
-        UnicodeCategoryOpenPunctuation unicodeOpenPunctuation = new UnicodeCategoryOpenPunctuation();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryOpenPunctuation");
-        if (unicodeOpenPunctuation.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the OpenPunctuation Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.OpenPunctuation;
-            if (myUnicodeCategory != (UnicodeCategory)20)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 20 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryotherletter.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryotherletter.cs
deleted file mode 100644
index 90424ddbc6..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryotherletter.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.OtherLetter [v-minch]
-/// </summary>
-public class UnicodeCategoryOtherLetter
-{
-    public static int Main()
-    {
-        UnicodeCategoryOtherLetter unicodeOtherLetter = new UnicodeCategoryOtherLetter();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryOtherLetter");
-        if (unicodeOtherLetter.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the OtherLetter Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.OtherLetter;
-            if (myUnicodeCategory != (UnicodeCategory)4)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 4 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryothernotassigned.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryothernotassigned.cs
deleted file mode 100644
index a6a7920751..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryothernotassigned.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.OtherNotAssigned [v-minch]
-/// </summary>
-public class UnicodeCategoryOtherNotAssigned
-{
-    public static int Main()
-    {
-        UnicodeCategoryOtherNotAssigned unicodeOtherNotAssigned = new UnicodeCategoryOtherNotAssigned();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryOtherNotAssigned");
-        if (unicodeOtherNotAssigned.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the OtherNotAssigned Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.OtherNotAssigned;
-            if (myUnicodeCategory != (UnicodeCategory)29)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 29 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryothernumber.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryothernumber.cs
deleted file mode 100644
index f6128de1e0..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryothernumber.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.OtherNumber [v-minch]
-/// </summary>
-public class UnicodeCategoryOtherNumber
-{
-    public static int Main()
-    {
-        UnicodeCategoryOtherNumber unicodeOtherNumber = new UnicodeCategoryOtherNumber();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryOtherNumber");
-        if (unicodeOtherNumber.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the OtherNumber Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.OtherNumber;
-            if (myUnicodeCategory != (UnicodeCategory)10)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 10 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryotherpunctuation.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryotherpunctuation.cs
deleted file mode 100644
index 884c0ab6ae..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryotherpunctuation.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.OtherPunctuation [v-minch]
-/// </summary>
-public class UnicodeCategoryOtherPunctuation
-{
-    public static int Main()
-    {
-        UnicodeCategoryOtherPunctuation unicodeOtherPunctuation = new UnicodeCategoryOtherPunctuation();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryOtherPunctuation");
-        if (unicodeOtherPunctuation.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the OtherPunctuation Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.OtherPunctuation;
-            if (myUnicodeCategory != (UnicodeCategory)24)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 24 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryothersymbol.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryothersymbol.cs
deleted file mode 100644
index 4e8d4ac138..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryothersymbol.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.OtherSymbol [v-minch]
-/// </summary>
-public class UnicodeCategoryOtherSymbol
-{
-    public static int Main()
-    {
-        UnicodeCategoryOtherSymbol unicodeOtherSymbol = new UnicodeCategoryOtherSymbol();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryOtherSymbol");
-        if (unicodeOtherSymbol.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the OtherSymbol Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.OtherSymbol;
-            if (myUnicodeCategory != (UnicodeCategory)28)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 28 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryparagraphseparator.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryparagraphseparator.cs
deleted file mode 100644
index 4e1bfa3280..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryparagraphseparator.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.ParagraphSeparator [v-minch]
-/// </summary>
-public class UnicodeCategoryParagraphSeparator
-{
-    public static int Main()
-    {
-        UnicodeCategoryParagraphSeparator unicodeParagraphSeparator = new UnicodeCategoryParagraphSeparator();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryParagraphSeparator");
-        if (unicodeParagraphSeparator.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the ParagraphSeparator Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.ParagraphSeparator;
-            if (myUnicodeCategory != (UnicodeCategory)13)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 13 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryprivateuse.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryprivateuse.cs
deleted file mode 100644
index 53aa98f4ca..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryprivateuse.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.PrivateUse [v-minch]
-/// </summary>
-public class UnicodeCategoryPrivateUse
-{
-    public static int Main()
-    {
-        UnicodeCategoryPrivateUse unicodePrivateUse = new UnicodeCategoryPrivateUse();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryPrivateUse");
-        if (unicodePrivateUse.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the PrivateUse Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.PrivateUse;
-            if (myUnicodeCategory != (UnicodeCategory)17)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 17 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryspaceseparator.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryspaceseparator.cs
deleted file mode 100644
index 5d4b5bb063..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryspaceseparator.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.SpaceSeparator [v-minch]
-/// </summary>
-public class UnicodeCategorySpaceSeparator
-{
-    public static int Main()
-    {
-        UnicodeCategorySpaceSeparator unicodeSpaceSeparator = new UnicodeCategorySpaceSeparator();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategorySpaceSeparator");
-        if (unicodeSpaceSeparator.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the SpaceSeparator Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.SpaceSeparator;
-            if (myUnicodeCategory != (UnicodeCategory)11)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 11 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryspacingcombiningmark.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryspacingcombiningmark.cs
deleted file mode 100644
index 685129f854..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryspacingcombiningmark.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.SpacingCombiningMark [v-minch]
-/// </summary>
-public class UnicodeCategorySpacingCombiningMark
-{
-    public static int Main()
-    {
-        UnicodeCategorySpacingCombiningMark unicodeSpacingCombiningMark = new UnicodeCategorySpacingCombiningMark();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategorySpacingCombiningMark");
-        if (unicodeSpacingCombiningMark.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the SpacingCombiningMark Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.SpacingCombiningMark;
-            if (myUnicodeCategory != (UnicodeCategory)6)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 6 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorysurrogate.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorysurrogate.cs
deleted file mode 100644
index 1acd3e5e1f..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorysurrogate.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.Surrogate [v-minch]
-/// </summary>
-public class UnicodeCategorySurrogate
-{
-    public static int Main()
-    {
-        UnicodeCategorySurrogate unicodeSurrogate = new UnicodeCategorySurrogate();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategorySurrogate");
-        if (unicodeSurrogate.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the Surrogate Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.Surrogate;
-            if (myUnicodeCategory != (UnicodeCategory)16)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 16 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorytitlecaseletter.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorytitlecaseletter.cs
deleted file mode 100644
index 1e61044588..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategorytitlecaseletter.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.TitlecaseLetter [v-minch]
-/// </summary>
-public class UnicodeCategoryTitlecaseLetter
-{
-    public static int Main()
-    {
-        UnicodeCategoryTitlecaseLetter unicodeTitlecaseLetter = new UnicodeCategoryTitlecaseLetter();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryTitlecaseLetter");
-        if (unicodeTitlecaseLetter.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the TitlecaseLetter Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.TitlecaseLetter;
-            if (myUnicodeCategory != (UnicodeCategory)2)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 2 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryuppercaseletter.cs b/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryuppercaseletter.cs
deleted file mode 100644
index 4a634b6242..0000000000
--- a/tests/src/CoreMangLib/cti/system/globalization/unicodecategory/unicodecategoryuppercaseletter.cs
+++ /dev/null
@@ -1,57 +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.
-using System;
-using System.Globalization;
-/// <summary>
-/// UnicodeCategory.UppercaseLetter
-/// </summary>
-public class UnicodeCategoryUppercaseLetter
-{
-    public static int Main()
-    {
-        UnicodeCategoryUppercaseLetter unicodeUppercaseLetter = new UnicodeCategoryUppercaseLetter();
-        TestLibrary.TestFramework.BeginTestCase("UnicodeCategoryUppercaseLetter");
-        if (unicodeUppercaseLetter.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.TestFramework.LogInformation("FAIL");
-            return 0;
-        }
-    }
-    public bool RunTests()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.LogInformation("[Positive]");
-        retVal = PosTest1() && retVal;
-        return retVal;
-    }
-    #region PositiveTest
-    public bool PosTest1()
-    {
-        bool retVal = true;
-        TestLibrary.TestFramework.BeginScenario("PosTest1:Return the UppercaseLetter Value in UnicodeCategory Enumerator");
-        try
-        {
-            UnicodeCategory myUnicodeCategory = UnicodeCategory.UppercaseLetter;
-            if (myUnicodeCategory != (UnicodeCategory)0)
-            {
-                TestLibrary.TestFramework.LogError("001", "the ExpectResult is 0 but the ActualResult is " + myUnicodeCategory.GetHashCode());
-                retVal = false;
-            }
-        }
-        catch (Exception e)
-        {
-            TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
-            retVal = false;
-        }
-        return retVal;
-    }
-    #endregion
-}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/system/datetime/co7510parseexact_formatarray.cs b/tests/src/CoreMangLib/system/datetime/co7510parseexact_formatarray.cs
deleted file mode 100644
index 8d31690027..0000000000
--- a/tests/src/CoreMangLib/system/datetime/co7510parseexact_formatarray.cs
+++ /dev/null
@@ -1,69 +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.
-using System;
-using System.Globalization;
-
-//Introduced as a BuildBVT as a regression test for NDPWhidbey bug #24414.
-//Make sure that a basic case of DateTime.ParseExact with a format array works.
-class Co7510ParseExact_formatarray
-{
-    public static int Main() 
-    {
-	try
-	{
-	    string[] formats = new string[24];	
-	    formats[0] = "HH:mm:ss";
-	    formats[1] = "HH:mm:ss.f";
-	    formats[2] = "HH:mm:ss.ff";
-	    formats[3] = "HH:mm:ss.fff";
-	    formats[4] = "HH:mm:ss.ffff";
-	    formats[5] = "HH:mm:ss.fffff";
-	    formats[6] = "HH:mm:ss.ffffff";
-	    formats[7] = "HH:mm:ss.fffffff";
-	    formats[8] = "HH:mm:ssZ";
-	    formats[9] = "HH:mm:ss.fZ";
-	    formats[10] = "HH:mm:ss.ffZ";
-	    formats[11] = "HH:mm:ss.fffZ";
-	    formats[12] = "HH:mm:ss.ffffZ";
-	    formats[13] = "HH:mm:ss.fffffZ";
-	    formats[14] = "HH:mm:ss.ffffffZ";
-	    formats[15] = "HH:mm:ss.fffffffZ";
-	    formats[16] = "HH:mm:sszzzzzz";
-	    formats[17] = "HH:mm:ss.fzzzzzz";
-	    formats[18] = "HH:mm:ss.ffzzzzzz";
-	    formats[19] = "HH:mm:ss.fffzzzzzz";
-	    formats[20] = "HH:mm:ss.ffffzzzzzz";
-	    formats[21] = "HH:mm:ss.fffffzzzzzz";
-	    formats[22] = "HH:mm:ss.ffffffzzzzzz";
-	    formats[23] = "HH:mm:ss.fffffffzzzzzz";
-	    string time = "10:27:27.123";
-
-	    DateTime dtReturned = 
-		DateTime.ParseExact(time, formats, DateTimeFormatInfo.InvariantInfo, 
-				    DateTimeStyles.AllowLeadingWhite|DateTimeStyles.AllowTrailingWhite);
-
-	    DateTime dtNow = DateTime.Now;
-	    DateTime dtExpected = new DateTime(dtNow.Year, dtNow.Month, dtNow.Day, 10, 27, 27, 123);
-
-	    if (dtExpected == dtReturned)
-	    {
-		TestLibrary.Logging.WriteLine("PASS");
-		return 100;
-	    }
-	    else
-	    {
-		TestLibrary.Logging.WriteLine("Expected: {0}", dtExpected.ToString("M/d/yyyy HH:mm:ss.ffff tt"));
-		TestLibrary.Logging.WriteLine("Actual:   {0}", dtReturned.ToString("M/d/yyyy HH:mm:ss.ffff tt"));
-		TestLibrary.Logging.WriteLine("FAIL");
-		return 1;
-	    }
-	}
-	catch (Exception e)
-	{
-	    TestLibrary.Logging.WriteLine("Unexpected exception: {0}", e.ToString());
-	    TestLibrary.Logging.WriteLine("FAIL");
-	    return 1;
-	}
-    }
-}
diff --git a/tests/src/CoreMangLib/system/text/encoding/shift_jis.cs b/tests/src/CoreMangLib/system/text/encoding/shift_jis.cs
deleted file mode 100644
index 68ce5e21ba..0000000000
--- a/tests/src/CoreMangLib/system/text/encoding/shift_jis.cs
+++ /dev/null
@@ -1,224 +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.
-using System;
-using System.Text;
-using TestLibrary;
-
-public class Shift_JisTest
-{
-    public static int Main(string[] args)
-    {
-        Shift_JisTest test = new Shift_JisTest();
-        TestLibrary.TestFramework.BeginTestCase("Testing Shift_Jis encoding support in CoreCLR");
-
-        if (test.RunTests())
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.Logging.WriteLine("PASS");
-            return 100;
-        }
-        else
-        {
-            TestLibrary.TestFramework.EndTestCase();
-            TestLibrary.Logging.WriteLine("FAIL");
-            return 0;
-        }
-    }
-
-    public bool RunTests()
-    {
-        bool retVal = true;
-
-        TestLibrary.Logging.WriteLine("[Positive]");
-        // We now support only Unicode and UTF8 encodings
-        //retVal = PosTest1() && retVal;
-        //retVal = PosTest2() && retVal;
-        //retVal = PosTest3() && retVal;
-        //retVal = PosTest4() && retVal;
-        retVal = NegTest1() && retVal;
-
-        return retVal;
-    }
-
-    public bool NegTest1()
-    {
-        bool ret = true;
-        TestLibrary.TestFramework.BeginScenario("Creating the shift_jis encoding");
-
-        try
-        {
-            Encoding enc = Encoding.GetEncoding("shift_jis");
-
-            ret = false;
-            TestFramework.LogError("00F", "Encoding created unexpectedly. Expected argument exception. Actual: Create encoding with name: " + enc.WebName);
-        }
-        catch (NotSupportedException)
-        {
-            // Expected
-        }
-		catch (ArgumentException)
-		{
-			// Expected
-		}
-		catch (Exception exc)
-        {
-            ret = false;
-            TestFramework.LogError("010", "Unexpected error: " + exc.ToString());
-        }
-        return ret;
-    }
-
-    public bool PosTest1()
-    {
-        bool ret = true;
-        TestLibrary.TestFramework.BeginScenario("Creating the shift_jis encoding");
-
-        try
-        {
-            Encoding enc2 = Encoding.GetEncoding("shift_jis");
-            if (enc2.WebName != "shift_jis")
-            {
-                ret = false;
-                TestFramework.LogError("002", "Error creating encoding. Web name not as expected. Expected: shift_jis Actual: " + enc2.WebName);
-            }
-
-            Encoding enc3 = Encoding.GetEncoding("sHiFT_JIs");
-            if (enc3.WebName != "shift_jis")
-            {
-                ret = false;
-                TestFramework.LogError("003", "Error creating encoding. Web name not as expected. Expected: shift_jis Actual: " + enc3.WebName);
-            }
-        }
-        catch (Exception exc)
-        {
-            ret = false;
-            TestFramework.LogError("004", "Unexpected error: " + exc.ToString());
-        }
-        return ret;
-    }
-
-    public bool PosTest2()
-    {
-        bool ret = true;
-        TestLibrary.TestFramework.BeginScenario("Encoding strings with the shift_jis encoding");
-
-        try
-        {
-            Encoding enc = Encoding.GetEncoding("shift_jis");
-
-            string str = "ABc";
-            byte[] bytes = enc.GetBytes(str);
-            byte[] expected = new byte[] { 0x41, 0x42, 0x63 };
-
-            if (!Utilities.CompareBytes(bytes, expected))
-            {
-                ret = false;
-                TestFramework.LogError("005", "Encoding str -> bytes not as expected. Str: " + str + " Expected bytes: " + Utilities.ByteArrayToString(expected) + " Actual bytes: " + Utilities.ByteArrayToString(bytes));
-            }
-
-            str = "";
-            bytes = enc.GetBytes(str);
-            expected = new byte[0];
-
-            if (!Utilities.CompareBytes(bytes, expected))
-            {
-                ret = false;
-                TestFramework.LogError("006", "Encoding str -> bytes not as expected. Str: " + str + " Expected bytes: " + Utilities.ByteArrayToString(expected) + " Actual bytes: " + Utilities.ByteArrayToString(bytes));
-            }
-
-            str = "A\xff70\x3000\x00b6\x25ef\x044f\x9adc\x9ed1";
-            bytes = enc.GetBytes(str);
-            expected = new byte[] { 0x41, 0xb0, 0x81, 0x40, 0x81, 0xf7, 0x81, 0xfc, 0x84, 0x91, 0xfc, 0x40, 0xfc, 0x4b };
-
-            if (!Utilities.CompareBytes(bytes, expected))
-            {
-                ret = false;
-                TestFramework.LogError("007", "Encoding str -> bytes not as expected. Str: " + str + " Expected bytes: " + Utilities.ByteArrayToString(expected) + " Actual bytes: " + Utilities.ByteArrayToString(bytes));
-            }
-        }
-        catch (Exception exc)
-        {
-            ret = false;
-            TestFramework.LogError("008", "Unexpected error: " + exc.ToString());
-        }
-        return ret;
-    }
-
-    public bool PosTest3()
-    {
-        bool ret = true;
-        TestLibrary.TestFramework.BeginScenario("Encoding char[]s with the shift_jis encoding");
-
-        try
-        {
-            Encoding enc = Encoding.GetEncoding("shift_jis");
-
-            char[] str = new char[] { 'A', 'B', 'c' };
-            byte[] bytes = enc.GetBytes(str);
-            byte[] expected = new byte[] { 0x41, 0x42, 0x63 };
-
-            if (!Utilities.CompareBytes(bytes, expected))
-            {
-                ret = false;
-                TestFramework.LogError("009", "Encoding char[] -> bytes not as expected. Str: " + new string(str) + " Expected bytes: " + Utilities.ByteArrayToString(expected) + " Actual bytes: " + Utilities.ByteArrayToString(bytes));
-            }
-
-            str = new char[0];
-            bytes = enc.GetBytes(str);
-            expected = new byte[0];
-
-            if (!Utilities.CompareBytes(bytes, expected))
-            {
-                ret = false;
-                TestFramework.LogError("00A", "Encoding char[] -> bytes not as expected. Str: " + new string(str) + " Expected bytes: " + Utilities.ByteArrayToString(expected) + " Actual bytes: " + Utilities.ByteArrayToString(bytes));
-            }
-
-            str = new char[] { 'A', '\xff70', '\x3000', '\x00b6', '\x25ef', '\x044f', '\x9adc', '\x9ed1' };
-            bytes = enc.GetBytes(str);
-            expected = new byte[] { 0x41, 0xb0, 0x81, 0x40, 0x81, 0xf7, 0x81, 0xfc, 0x84, 0x91, 0xfc, 0x40, 0xfc, 0x4b };
-
-            if (!Utilities.CompareBytes(bytes, expected))
-            {
-                ret = false;
-                TestFramework.LogError("00B", "Encoding char[] -> bytes not as expected. Str: " + new string(str) + " Expected bytes: " + Utilities.ByteArrayToString(expected) + " Actual bytes: " + Utilities.ByteArrayToString(bytes));
-            }
-        }
-        catch (Exception exc)
-        {
-            ret = false;
-            TestFramework.LogError("00C", "Unexpected error: " + exc.ToString());
-        }
-        return ret;
-    }
-
-    public bool PosTest4()
-    {
-        bool ret = true;
-        TestLibrary.TestFramework.BeginScenario("Decoding byte[]s with the shift_jis encoding");
-
-        try
-        {
-            Encoding enc = Encoding.GetEncoding("shift_jis");
-
-            byte[] bytes = { 0x87, 0x90 };
-            char[] expected = new char[] {'\x2252'};
-
-            char[] actual = enc.GetChars(bytes);
-
-            if (!Utilities.CompareChars(actual, expected))
-            {
-                ret = false;
-                TestFramework.LogError("00D", "Decoding byte[] -> char[] not as expected! Expected: 0x8786 Actual ");
-                foreach (char c in actual) Logging.Write("0x" + ((int)c).ToString("x") + " ");
-            }
-        }
-        catch (Exception exc)
-        {
-            ret = false;
-            TestFramework.LogError("00E", "Unexpected error: " + exc.ToString());
-        }
-        return ret;
-    }
-
-}
diff --git a/tests/src/GC/Coverage/delete_next_card_table.csproj b/tests/src/GC/Coverage/delete_next_card_table.csproj
index 98bd7f38e0..0c80943169 100644
--- a/tests/src/GC/Coverage/delete_next_card_table.csproj
+++ b/tests/src/GC/Coverage/delete_next_card_table.csproj
@@ -14,6 +14,7 @@
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
     <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
     <GCStressIncompatible>true</GCStressIncompatible>
+    <IsLongRunningGCTest>true</IsLongRunningGCTest>
   </PropertyGroup>
   <!-- Default configurations to help VS understand the configurations -->
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
@@ -35,4 +36,4 @@
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
   <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
   </PropertyGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/tests/src/Interop/common/types.h b/tests/src/Interop/common/types.h
index cb59c42e9d..f183a07e4e 100755
--- a/tests/src/Interop/common/types.h
+++ b/tests/src/Interop/common/types.h
@@ -5,6 +5,7 @@
 #ifndef _INTEROP_TYPES__H
 #define _INTEROP_TYPES__H
 
+#undef INT_MIN
 #define INT_MIN	   (-2147483647 - 1)
 
 typedef char16_t WCHAR;
diff --git a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/LICENSE.TXT b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/LICENSE.TXT
index 5e0fbafb8d..a4f22b13f9 100644
--- a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/LICENSE.TXT
+++ b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/LICENSE.TXT
@@ -4,7 +4,7 @@ This is a specific instance of the Open Source Initiative (OSI) BSD license temp
 http://www.opensource.org/licenses/bsd-license.php
 
 
-Copyright © 2004-2008 Brent Fulgham, 2005-2015 Isaac Gouy
+Copyright © 2004-2008 Brent Fulgham, 2005-2016 Isaac Gouy
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
diff --git a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/k-nucleotide/k-nucleotide.cs b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/k-nucleotide/k-nucleotide.cs
new file mode 100644
index 0000000000..54bd10702c
--- /dev/null
+++ b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/k-nucleotide/k-nucleotide.cs
@@ -0,0 +1,312 @@
+/* The Computer Language Benchmarks Game
+   http://benchmarksgame.alioth.debian.org/
+ *
+ * submitted by Josh Goldfoot
+ * 
+ */
+
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Xunit.Performance;
+using Xunit;
+
+[assembly: OptimizeForBenchmarks]
+[assembly: MeasureInstructionsRetired]
+[assembly: MeasureGCCounts]
+
+namespace BenchmarksGame
+{
+
+public class knucleotide
+{
+#if DEBUG
+    const int Iterations = 1;
+    const string InputFile = "knucleotide-input.txt"; 
+    static int[] expectedCountLetter = new int[] { 1480, 974, 970, 1576 };
+    static int[] expectedCountPairs = new int[] { 420, 272, 292, 496, 273, 202, 201, 298, 316, 185, 167, 302, 470, 315, 310, 480 };
+    static int[] expectedCountFragments = new int[] { 54, 24, 4, 0, 0 };
+#else
+    const int Iterations = 10;
+    const string InputFile = "knucleotide-input-big.txt"; 
+    static int[] expectedCountLetter = new int[] { 302923, 198136, 197566, 301375 };
+    static int[] expectedCountPairs = new int[] { 91779, 60030, 59889, 91225, 60096, 39203, 39081, 59756, 59795, 39190, 39023, 59557, 91253, 59713, 59572, 90837 };
+    static int[] expectedCountFragments = new int[] { 11765, 3572, 380, 7, 7 };
+#endif
+
+
+    static string FindInput(string s)
+   {
+       string CoreRoot = System.Environment.GetEnvironmentVariable("CORE_ROOT");
+
+       if (CoreRoot == null)
+       {
+           Console.WriteLine("This benchmark requries CORE_ROOT to be set");
+           return null;
+       }
+
+       string inputFile = s ?? InputFile;
+
+       // Normal testing -- input file will end up next to the assembly
+       // and CoreRoot points at the test overlay dir
+       string[] pathPartsNormal = new string[] {
+           CoreRoot, "..", "..", "JIT", "Performance",
+           "CodeQuality", "BenchmarksGame", "k-nucleotide", "k-nucleotide", inputFile
+       };
+
+       string inputPathNormal = Path.Combine(pathPartsNormal);
+
+       // Perf testing -- input file will end up next to the assembly
+       // and CoreRoot points at this directory
+       string[] pathPartsPerf = new string[] { CoreRoot, inputFile };
+
+       string inputPathPerf = Path.Combine(pathPartsPerf);
+
+       string inputPath = null;
+
+       if (File.Exists(inputPathNormal))
+       {
+           inputPath = inputPathNormal;
+       }
+       else if (File.Exists(inputPathPerf))
+       {
+           inputPath = inputPathPerf;
+       }
+
+       if (inputPath != null)
+       {
+           Console.WriteLine("Using input file {0}", inputPath);
+       }
+       else
+       {
+           Console.WriteLine("Unable to find input file {0}", inputFile);
+       }
+
+       return inputPath;
+   }
+
+    public static int Main(string[] args)
+    {
+        int iterations = Iterations;
+        
+        string inputFile = FindInput(InputFile);
+        if (inputFile == null)
+        {
+            throw new Exception("unable to find input");
+        }
+
+        PrepareLookups();
+        var source = new FileStream(inputFile, FileMode.Open);
+        var buffer = GetBytesForThirdSequence(source);
+        var fragmentLengths = new[] { 1, 2, 3, 4, 6, 12, 18 };
+        var dicts =
+            (from fragmentLength in fragmentLengths.AsParallel()
+             select CountFrequency(buffer, fragmentLength)).ToArray();
+        source.Dispose();
+        int res = 100;
+        for (ulong i = 0; i < 4; ++i){
+            if (dicts[0][i].V != expectedCountLetter[i]){
+                res = -1;
+            }
+        }
+         for (ulong i = 0; i < 16; ++i){
+            if (dicts[1][i].V != expectedCountPairs[i]){
+                res = -1;
+            }
+        }
+        int buflen = dicts[0].Values.Sum(x => x.V);
+        WriteFrequencies(dicts[0], buflen, 1);
+        WriteFrequencies(dicts[1], buflen, 2);
+        if (WriteCount(dicts[2], "GGT") != expectedCountFragments[0]) { res = -1; }
+        if (WriteCount(dicts[3], "GGTA") != expectedCountFragments[1]) { res = -1; }
+        if (WriteCount(dicts[4], "GGTATT") != expectedCountFragments[2]) { res = -1; }
+        if (WriteCount(dicts[5], "GGTATTTTAATT") != expectedCountFragments[3]) { res = -1; }
+        if (WriteCount(dicts[6], "GGTATTTTAATTTATAGT") != expectedCountFragments[4]) { res = -1; }
+        //Console.ReadKey();
+        return res;
+    }
+
+    private static void WriteFrequencies(Dictionary<ulong, Wrapper> freq, int buflen, int fragmentLength)
+    {
+
+        double percent = 100.0 / (buflen - fragmentLength + 1);
+        foreach (var line in (from k in freq.Keys
+                              orderby freq[k].V descending
+                              select string.Format("{0} {1:f3}", PrintKey(k, fragmentLength),
+                                (freq.ContainsKey(k) ? freq[k].V : 0) * percent)))
+            Console.WriteLine(line);
+        Console.WriteLine();
+    }
+
+    private static int WriteCount(Dictionary<ulong, Wrapper> dictionary, string fragment)
+    {
+        ulong key = 0;
+        var keybytes = Encoding.ASCII.GetBytes(fragment.ToLower());
+        for (int i = 0; i < keybytes.Length; i++)
+        {
+            key <<= 2;
+            key |= tonum[keybytes[i]];
+        }
+        Wrapper w;
+        int count = dictionary.TryGetValue(key, out w) ? w.V : 0;
+        Console.WriteLine("{0}\t{1}",
+            count,
+            fragment);
+        return count;
+    }
+
+    private static string PrintKey(ulong key, int fragmentLength)
+    {
+        char[] items = new char[fragmentLength];
+        for (int i = 0; i < fragmentLength; ++i)
+        {
+            items[fragmentLength - i - 1] = tochar[key & 0x3];
+            key >>= 2;
+        }
+        return new string(items);
+    }
+
+    private static Dictionary<ulong, Wrapper> CountFrequency(byte[] buffer, int fragmentLength)
+    {
+        var dictionary = new Dictionary<ulong, Wrapper>();
+        ulong rollingKey = 0;
+        ulong mask = 0;
+        int cursor;
+        for (cursor = 0; cursor < fragmentLength - 1; cursor++)
+        {
+            rollingKey <<= 2;
+            rollingKey |= tonum[buffer[cursor]];
+            mask = (mask << 2) + 3;
+        }
+        mask = (mask << 2) + 3;
+        int stop = buffer.Length;
+        Wrapper w;
+        byte cursorByte;
+        while (cursor < stop)
+        {
+            if ((cursorByte = buffer[cursor++]) < (byte)'a')
+                cursorByte = buffer[cursor++];
+            rollingKey = ((rollingKey << 2) & mask) | tonum[cursorByte];
+            if (dictionary.TryGetValue(rollingKey, out w))
+                w.V++;
+            else
+                dictionary.Add(rollingKey, new Wrapper(1));
+        }
+        return dictionary;
+    }
+
+    private static byte[] GetBytesForThirdSequence(FileStream source)
+    {
+        const int buffersize = 2500120;
+        byte[] threebuffer = null;
+        var buffer = new byte[buffersize];
+        int amountRead, threebuflen, indexOfFirstByteInThreeSequence, indexOfGreaterThan, threepos, tocopy;
+        amountRead = threebuflen = indexOfFirstByteInThreeSequence = indexOfGreaterThan = threepos = tocopy = 0;
+        bool threeFound = false;
+        //var source = new FileStream(inputFile, FileMode.Open);
+        source.Seek(0, SeekOrigin.Begin);
+        while (!threeFound && (amountRead = source.Read(buffer, 0, buffersize)) > 0)
+        {
+            indexOfGreaterThan = Array.LastIndexOf(buffer, (byte)'>');
+            threeFound = (indexOfGreaterThan > -1 &&
+                buffer[indexOfGreaterThan + 1] == (byte)'T' &&
+                buffer[indexOfGreaterThan + 2] == (byte)'H');
+            if (threeFound)
+            {
+                threepos += indexOfGreaterThan;
+                threebuflen = threepos - 48;
+                threebuffer = new byte[threebuflen];
+                indexOfFirstByteInThreeSequence = Array.IndexOf<byte>(buffer, 10, indexOfGreaterThan) + 1;
+                tocopy = amountRead - indexOfFirstByteInThreeSequence;
+                if (amountRead < buffersize)
+                    tocopy -= 1;
+                Buffer.BlockCopy(buffer, indexOfFirstByteInThreeSequence, threebuffer, 0, tocopy);
+                buffer = null;
+            }
+            else
+                threepos += amountRead;
+        }
+        int toread = threebuflen - tocopy;
+        source.Read(threebuffer, tocopy, toread);
+        return threebuffer;
+    }
+
+    private static byte[] tonum = new byte[256];
+    private static char[] tochar = new char[4];
+    private static void PrepareLookups()
+    {
+        tonum['a'] = 0;
+        tonum['c'] = 1;
+        tonum['g'] = 2;
+        tonum['t'] = 3;
+        tochar[0] = 'A';
+        tochar[1] = 'C';
+        tochar[2] = 'G';
+        tochar[3] = 'T';
+    }
+
+    [Benchmark(InnerIterationCount=Iterations)]
+    public static void Bench_Parallel()
+    {
+        PrepareLookups();
+        string inputFile = FindInput(InputFile);
+        var source = new FileStream(inputFile, FileMode.Open);
+
+        if (inputFile == null)
+        {
+            throw new Exception("unable to find input");
+        }
+        foreach (var iteration in Benchmark.Iterations) 
+        {
+            using (iteration.StartMeasurement())
+            {
+                for (int i = 0; i < Benchmark.InnerIterationCount; ++i)
+                {
+                    var buffer = GetBytesForThirdSequence(source);
+                    var fragmentLengths = new[] { 1, 2, 3, 4, 6, 12, 18 };
+                    var dicts =
+                        (from fragmentLength in fragmentLengths.AsParallel()
+                         select CountFrequency(buffer, fragmentLength)).ToArray();
+                }
+            }
+        }
+        source.Dispose();
+    }
+    [Benchmark(InnerIterationCount=Iterations)]
+    public static void Bench_No_Parallel()
+    {
+        string inputFile = FindInput(InputFile);
+        var source = new FileStream(inputFile, FileMode.Open);
+
+        if (inputFile == null)
+        {
+            throw new Exception("unable to find input");
+        }
+        foreach (var iteration in Benchmark.Iterations) 
+        {
+            using (iteration.StartMeasurement())
+            {
+                for (int i = 0; i < Benchmark.InnerIterationCount; ++i)
+                {
+                    PrepareLookups();
+                    var buffer = GetBytesForThirdSequence(source);
+                    var fragmentLengths = new[] { 1, 2, 3, 4, 6, 12, 18 };
+                    var dicts =
+                        (from fragmentLength in fragmentLengths
+                         select CountFrequency(buffer, fragmentLength)).ToArray();
+                }
+            }
+        }
+        source.Dispose();
+    }
+}
+
+public class Wrapper
+{
+    public int V;
+    public Wrapper(int v) { V = v; }
+}
+
+}
\ No newline at end of file
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeCtor1.csproj b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/k-nucleotide/k-nucleotide.csproj
index ec41ab4408..94e1dfbda8 100644
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeCtor1.csproj
+++ b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/k-nucleotide/k-nucleotide.csproj
@@ -13,32 +13,40 @@
     <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
     <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
+    <NuGetTargetMoniker>.NETStandard,Version=v1.4</NuGetTargetMoniker>
   </PropertyGroup>
   <!-- Default configurations to help VS understand the configurations -->
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
   </PropertyGroup>
+  <PropertyGroup>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+  </PropertyGroup>
   <ItemGroup>
     <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
       <Visible>False</Visible>
     </CodeAnalysisDependentAssemblyPaths>
   </ItemGroup>
   <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimector1.cs" />
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
   <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+    <Compile Include="k-nucleotide.cs" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
+    <Content Include="knucleotide-input.txt">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
+    <Content Include="knucleotide-input-big.txt">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
   </ItemGroup>
+  <PropertyGroup>
+    <ProjectJson>$(JitPackagesConfigFileDirectory)benchmark\project.json</ProjectJson>
+    <ProjectLockJson>$(JitPackagesConfigFileDirectory)benchmark\project.lock.json</ProjectLockJson>
+  </PropertyGroup>
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
   <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
   </PropertyGroup>
diff --git a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/k-nucleotide/knucleotide-input-big.txt b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/k-nucleotide/knucleotide-input-big.txt
new file mode 100644
index 0000000000..7af7cbecf9
--- /dev/null
+++ b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/k-nucleotide/knucleotide-input-big.txt
@@ -0,0 +1,33337 @@
+>ONE Homo sapiens alu
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+>TWO IUB ambiguity codes
+cttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcg
+tactDtDagcctatttSVHtHttKtgtHMaSattgWaHKHttttagacatWatgtRgaaa
+NtactMcSMtYtcMgRtacttctWBacgaaatatagScDtttgaagacacatagtVgYgt
+cattHWtMMWcStgttaggKtSgaYaaccWStcgBttgcgaMttBYatcWtgacaYcaga
+gtaBDtRacttttcWatMttDBcatWtatcttactaBgaYtcttgttttttttYaaScYa
+HgtgttNtSatcMtcVaaaStccRcctDaataataStcYtRDSaMtDttgttSagtRRca
+tttHatSttMtWgtcgtatSSagactYaaattcaMtWatttaSgYttaRgKaRtccactt
+tattRggaMcDaWaWagttttgacatgttctacaaaRaatataataaMttcgDacgaSSt
+acaStYRctVaNMtMgtaggcKatcttttattaaaaagVWaHKYagtttttatttaacct
+tacgtVtcVaattVMBcttaMtttaStgacttagattWWacVtgWYagWVRctDattBYt
+gtttaagaagattattgacVatMaacattVctgtBSgaVtgWWggaKHaatKWcBScSWa
+accRVacacaaactaccScattRatatKVtactatatttHttaagtttSKtRtacaaagt
+RDttcaaaaWgcacatWaDgtDKacgaacaattacaRNWaatHtttStgttattaaMtgt
+tgDcgtMgcatBtgcttcgcgaDWgagctgcgaggggVtaaScNatttacttaatgacag
+cccccacatYScaMgtaggtYaNgttctgaMaacNaMRaacaaacaKctacatagYWctg
+ttWaaataaaataRattagHacacaagcgKatacBttRttaagtatttccgatctHSaat
+actcNttMaagtattMtgRtgaMgcataatHcMtaBSaRattagttgatHtMttaaKagg
+YtaaBataSaVatactWtataVWgKgttaaaacagtgcgRatatacatVtHRtVYataSa
+KtWaStVcNKHKttactatccctcatgWHatWaRcttactaggatctataDtDHBttata
+aaaHgtacVtagaYttYaKcctattcttcttaataNDaaggaaaDYgcggctaaWSctBa
+aNtgctggMBaKctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacg
+gtttNattgVtttctgtBaWgtaattcaagtcaVWtactNggattctttaYtaaagccgc
+tcttagHVggaYtgtNcDaVagctctctKgacgtatagYcctRYHDtgBattDaaDgccK
+tcHaaStttMcctagtattgcRgWBaVatHaaaataYtgtttagMDMRtaataaggatMt
+ttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtcattttcWattRSHcVagaagtacg
+ggtaKVattKYagactNaatgtttgKMMgYNtcccgSKttctaStatatNVataYHgtNa
+BKRgNacaactgatttcctttaNcgatttctctataScaHtataRagtcRVttacDSDtt
+aRtSatacHgtSKacYagttMHtWataggatgactNtatSaNctataVtttRNKtgRacc
+tttYtatgttactttttcctttaaacatacaHactMacacggtWataMtBVacRaSaatc
+cgtaBVttccagccBcttaRKtgtgcctttttRtgtcagcRttKtaaacKtaaatctcac
+aattgcaNtSBaaccgggttattaaBcKatDagttactcttcattVtttHaaggctKKga
+tacatcBggScagtVcacattttgaHaDSgHatRMaHWggtatatRgccDttcgtatcga
+aacaHtaagttaRatgaVacttagattVKtaaYttaaatcaNatccRttRRaMScNaaaD
+gttVHWgtcHaaHgacVaWtgttScactaagSgttatcttagggDtaccagWattWtRtg
+ttHWHacgattBtgVcaYatcggttgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcV
+taBtWaaYatcDRaaRtSctgaHaYRttagatMatgcatttNattaDttaattgttctaa
+ccctcccctagaWBtttHtBccttagaVaatMcBHagaVcWcagBVttcBtaYMccagat
+gaaaaHctctaacgttagNWRtcggattNatcRaNHttcagtKttttgWatWttcSaNgg
+gaWtactKKMaacatKatacNattgctWtatctaVgagctatgtRaHtYcWcttagccaa
+tYttWttaWSSttaHcaaaaagVacVgtaVaRMgattaVcDactttcHHggHRtgNcctt
+tYatcatKgctcctctatVcaaaaKaaaagtatatctgMtWtaaaacaStttMtcgactt
+taSatcgDataaactaaacaagtaaVctaggaSccaatMVtaaSKNVattttgHccatca
+cBVctgcaVatVttRtactgtVcaattHgtaaattaaattttYtatattaaRSgYtgBag
+aHSBDgtagcacRHtYcBgtcacttacactaYcgctWtattgSHtSatcataaatataHt
+cgtYaaMNgBaatttaRgaMaatatttBtttaaaHHKaatctgatWatYaacttMctctt
+ttVctagctDaaagtaVaKaKRtaacBgtatccaaccactHHaagaagaaggaNaaatBW
+attccgStaMSaMatBttgcatgRSacgttVVtaaDMtcSgVatWcaSatcttttVatag
+ttactttacgatcaccNtaDVgSRcgVcgtgaacgaNtaNatatagtHtMgtHcMtagaa
+attBgtataRaaaacaYKgtRccYtatgaagtaataKgtaaMttgaaRVatgcagaKStc
+tHNaaatctBBtcttaYaBWHgtVtgacagcaRcataWctcaBcYacYgatDgtDHccta
+aagacYRcaggattHaYgtKtaatgcVcaataMYacccatatcacgWDBtgaatcBaata
+cKcttRaRtgatgaBDacggtaattaaYtataStgVHDtDctgactcaaatKtacaatgc
+gYatBtRaDatHaactgtttatatDttttaaaKVccYcaaccNcBcgHaaVcattHctcg
+attaaatBtatgcaaaaatYMctSactHatacgaWacattacMBgHttcgaatVaaaaca
+BatatVtctgaaaaWtctRacgBMaatSgRgtgtcgactatcRtattaScctaStagKga
+DcWgtYtDDWKRgRtHatRtggtcgaHgggcgtattaMgtcagccaBggWVcWctVaaat
+tcgNaatcKWagcNaHtgaaaSaaagctcYctttRVtaaaatNtataaccKtaRgtttaM
+tgtKaBtRtNaggaSattHatatWactcagtgtactaKctatttgRYYatKatgtccgtR
+tttttatttaatatVgKtttgtatgtNtataRatWYNgtRtHggtaaKaYtKSDcatcKg
+taaYatcSRctaVtSMWtVtRWHatttagataDtVggacagVcgKWagBgatBtaaagNc
+aRtagcataBggactaacacRctKgttaatcctHgDgttKHHagttgttaatgHBtatHc
+DaagtVaBaRccctVgtgDtacRHSctaagagcggWYaBtSaKtHBtaaactYacgNKBa
+VYgtaacttagtVttcttaatgtBtatMtMtttaattaatBWccatRtttcatagVgMMt
+agctStKctaMactacDNYgKYHgaWcgaHgagattacVgtttgtRaSttaWaVgataat
+gtgtYtaStattattMtNgWtgttKaccaatagNYttattcgtatHcWtctaaaNVYKKt
+tWtggcDtcgaagtNcagatacgcattaagaccWctgcagcttggNSgaNcHggatgtVt
+catNtRaaBNcHVagagaaBtaaSggDaatWaatRccaVgggStctDaacataKttKatt
+tggacYtattcSatcttagcaatgaVBMcttDattctYaaRgatgcattttNgVHtKcYR
+aatRKctgtaaacRatVSagctgtWacBtKVatctgttttKcgtctaaDcaagtatcSat
+aWVgcKKataWaYttcccSaatgaaaacccWgcRctWatNcWtBRttYaattataaNgac
+acaatagtttVNtataNaYtaatRaVWKtBatKagtaatataDaNaaaaataMtaagaaS
+tccBcaatNgaataWtHaNactgtcDtRcYaaVaaaaaDgtttRatctatgHtgttKtga
+aNSgatactttcgagWaaatctKaaDaRttgtggKKagcDgataaattgSaacWaVtaNM
+acKtcaDaaatttctRaaVcagNacaScRBatatctRatcctaNatWgRtcDcSaWSgtt
+RtKaRtMtKaatgttBHcYaaBtgatSgaSWaScMgatNtctcctatttctYtatMatMt
+RRtSaattaMtagaaaaStcgVgRttSVaScagtgDtttatcatcatacRcatatDctta
+tcatVRtttataaHtattcYtcaaaatactttgVctagtaaYttagatagtSYacKaaac
+gaaKtaaatagataatSatatgaaatSgKtaatVtttatcctgKHaatHattagaaccgt
+YaaHactRcggSBNgtgctaaBagBttgtRttaaattYtVRaaaattgtaatVatttctc
+ttcatgBcVgtgKgaHaaatattYatagWacNctgaaMcgaattStagWaSgtaaKagtt
+ttaagaDgatKcctgtaHtcatggKttVDatcaaggtYcgccagNgtgcVttttagagat
+gctaccacggggtNttttaSHaNtatNcctcatSaaVgtactgBHtagcaYggYVKNgta
+KBcRttgaWatgaatVtagtcgattYgatgtaatttacDacSctgctaaaStttaWMagD
+aaatcaVYctccgggcgaVtaaWtStaKMgDtttcaaMtVgBaatccagNaaatcYRMBg
+gttWtaaScKttMWtYataRaDBMaDataatHBcacDaaKDactaMgagttDattaHatH
+taYatDtattDcRNStgaatattSDttggtattaaNSYacttcDMgYgBatWtaMagact
+VWttctttgYMaYaacRgHWaattgRtaagcattctMKVStatactacHVtatgatcBtV
+NataaBttYtSttacKgggWgYDtgaVtYgatDaacattYgatggtRDaVDttNactaSa
+MtgNttaacaaSaBStcDctaccacagacgcaHatMataWKYtaYattMcaMtgSttDag
+cHacgatcaHttYaKHggagttccgatYcaatgatRaVRcaagatcagtatggScctata
+ttaNtagcgacgtgKaaWaactSgagtMYtcttccaKtStaacggMtaagNttattatcg
+tctaRcactctctDtaacWYtgaYaSaagaWtNtatttRacatgNaatgttattgWDDcN
+aHcctgaaHacSgaataaRaataMHttatMtgaSDSKatatHHaNtacagtccaYatWtc
+actaactatKDacSaStcggataHgYatagKtaatKagStaNgtatactatggRHacttg
+tattatgtDVagDVaRctacMYattDgtttYgtctatggtKaRSttRccRtaaccttaga
+gRatagSaaMaacgcaNtatgaaatcaRaagataatagatactcHaaYKBctccaagaRa
+BaStNagataggcgaatgaMtagaatgtcaKttaaatgtaWcaBttaatRcggtgNcaca
+aKtttScRtWtgcatagtttWYaagBttDKgcctttatMggNttattBtctagVtacata
+aaYttacacaaRttcYtWttgHcaYYtaMgBaBatctNgcDtNttacgacDcgataaSat
+YaSttWtcctatKaatgcagHaVaacgctgcatDtgttaSataaaaYSNttatagtaNYt
+aDaaaNtggggacttaBggcHgcgtNtaaMcctggtVtaKcgNacNtatVaSWctWtgaW
+cggNaBagctctgaYataMgaagatBSttctatacttgtgtKtaattttRagtDtacata
+tatatgatNHVgBMtKtaKaNttDHaagatactHaccHtcatttaaagttVaMcNgHata
+tKtaNtgYMccttatcaaNagctggacStttcNtggcaVtattactHaSttatgNMVatt
+MMDtMactattattgWMSgtHBttStStgatatRaDaagattttctatMtaaaaaggtac
+taaVttaSacNaatactgMttgacHaHRttgMacaaaatagttaatatWKRgacDgaRta
+tatttattatcYttaWtgtBRtWatgHaaattHataagtVaDtWaVaWtgStcgtMSgaS
+RgMKtaaataVacataatgtaSaatttagtcgaaHtaKaatgcacatcggRaggSKctDc
+agtcSttcccStYtccRtctctYtcaaKcgagtaMttttcRaYDttgttatctaatcata
+NctctgctatcaMatactataggDaHaaSttMtaDtcNatataattctMcStaaBYtaNa
+gatgtaatHagagSttgWHVcttatKaYgDctcttggtgttMcRaVgSgggtagacaata
+aDtaattSaDaNaHaBctattgNtaccaaRgaVtKNtaaYggHtaKKgHcatctWtctDt
+ttctttggSDtNtaStagttataaacaattgcaBaBWggHgcaaaBtYgctaatgaaatW
+cDcttHtcMtWWattBHatcatcaaatctKMagtDNatttWaBtHaaaNgMttaaStagt
+tctctaatDtcRVaYttgttMtRtgtcaSaaYVgSWDRtaatagctcagDgcWWaaaBaa
+RaBctgVgggNgDWStNaNBKcBctaaKtttDcttBaaggBttgaccatgaaaNgttttt
+tttatctatgttataccaaDRaaSagtaVtDtcaWatBtacattaWacttaSgtattggD
+gKaaatScaattacgWcagKHaaccaYcRcaRttaDttRtttHgaHVggcttBaRgtccc
+tDatKaVtKtcRgYtaKttacgtatBtStaagcaattaagaRgBagSaattccSWYttta
+ttVaataNctgHgttaaNBgcVYgtRtcccagWNaaaacaDNaBcaaaaRVtcWMgBagM
+tttattacgDacttBtactatcattggaaatVccggttRttcatagttVYcatYaSHaHc
+ttaaagcNWaHataaaRWtctVtRYtagHtaaaYMataHYtNBctNtKaatattStgaMc
+BtRgctaKtgcScSttDgYatcVtggaaKtaagatWccHccgKYctaNNctacaWctttt
+gcRtgtVcgaKttcMRHgctaHtVaataaDtatgKDcttatBtDttggNtacttttMtga
+acRattaaNagaactcaaaBBVtcDtcgaStaDctgaaaSgttMaDtcgttcaccaaaag
+gWtcKcgSMtcDtatgtttStaaBtatagDcatYatWtaaaBacaKgcaDatgRggaaYc
+taRtccagattDaWtttggacBaVcHtHtaacDacYgtaatataMagaatgHMatcttat
+acgtatttttatattacHactgttataMgStYaattYaccaattgagtcaaattaYtgta
+tcatgMcaDcgggtcttDtKgcatgWRtataatatRacacNRBttcHtBgcRttgtgcgt
+catacMtttBctatctBaatcattMttMYgattaaVYatgDaatVagtattDacaacDMa
+tcMtHcccataagatgBggaccattVWtRtSacatgctcaaggggYtttDtaaNgNtaaB
+atggaatgtctRtaBgBtcNYatatNRtagaacMgagSaSDDSaDcctRagtVWSHtVSR
+ggaacaBVaccgtttaStagaacaMtactccagtttVctaaRaaHttNcttagcaattta
+ttaatRtaaaatctaacDaBttggSagagctacHtaaRWgattcaaBtctRtSHaNtgta
+cattVcaHaNaagtataccacaWtaRtaaVKgMYaWgttaKggKMtKcgWatcaDatYtK
+SttgtacgaccNctSaattcDcatcttcaaaDKttacHtggttHggRRaRcaWacaMtBW
+VHSHgaaMcKattgtaRWttScNattBBatYtaNRgcggaagacHSaattRtttcYgacc
+BRccMacccKgatgaacttcgDgHcaaaaaRtatatDtatYVtttttHgSHaSaatagct
+NYtaHYaVYttattNtttgaaaYtaKttWtctaNtgagaaaNctNDctaaHgttagDcRt
+tatagccBaacgcaRBtRctRtggtaMYYttWtgataatcgaataattattataVaaaaa
+ttacNRVYcaaMacNatRttcKatMctgaagactaattataaYgcKcaSYaatMNctcaa
+cgtgatttttBacNtgatDccaattattKWWcattttatatatgatBcDtaaaagttgaa
+VtaHtaHHtBtataRBgtgDtaataMttRtDgDcttattNtggtctatctaaBcatctaR
+atgNacWtaatgaagtcMNaacNgHttatactaWgcNtaStaRgttaaHacccgaYStac
+aaaatWggaYaWgaattattcMaactcBKaaaRVNcaNRDcYcgaBctKaacaaaaaSgc
+tccYBBHYaVagaatagaaaacagYtctVccaMtcgtttVatcaatttDRtgWctagtac
+RttMctgtDctttcKtWttttataaatgVttgBKtgtKWDaWagMtaaagaaattDVtag
+gttacatcatttatgtcgMHaVcttaBtVRtcgtaYgBRHatttHgaBcKaYWaatcNSc
+tagtaaaaatttacaatcactSWacgtaatgKttWattagttttNaggtctcaagtcact
+attcttctaagKggaataMgtttcataagataaaaatagattatDgcBVHWgaBKttDgc
+atRHaagcaYcRaattattatgtMatatattgHDtcaDtcaaaHctStattaatHaccga
+cNattgatatattttgtgtDtRatagSacaMtcRtcattcccgacacSattgttKaWatt
+NHcaacttccgtttSRtgtctgDcgctcaaMagVtBctBMcMcWtgtaacgactctcttR
+ggRKSttgYtYatDccagttDgaKccacgVatWcataVaaagaataMgtgataaKYaaat
+cHDaacgataYctRtcYatcgcaMgtNttaBttttgatttaRtStgcaacaaaataccVg
+aaDgtVgDcStctatatttattaaaaRKDatagaaagaKaaYYcaYSgKStctccSttac
+agtcNactttDVttagaaagMHttRaNcSaRaMgBttattggtttaRMggatggcKDgWR
+tNaataataWKKacttcKWaaagNaBttaBatMHtccattaacttccccYtcBcYRtaga
+ttaagctaaYBDttaNtgaaaccHcaRMtKtaaHMcNBttaNaNcVcgVttWNtDaBatg
+ataaVtcWKcttRggWatcattgaRagHgaattNtatttctctattaattaatgaDaaMa
+tacgttgggcHaYVaaNaDDttHtcaaHtcVVDgBVagcMacgtgttaaBRNtatRtcag
+taagaggtttaagacaVaaggttaWatctccgtVtaDtcDatttccVatgtacNtttccg
+tHttatKgScBatgtVgHtYcWagcaKtaMYaaHgtaattaSaHcgcagtWNaatNccNN
+YcacgVaagaRacttctcattcccRtgtgtaattagcSttaaStWaMtctNNcSMacatt
+ataaactaDgtatWgtagtttaagaaaattgtagtNagtcaataaatttgatMMYactaa
+tatcggBWDtVcYttcDHtVttatacYaRgaMaacaStaatcRttttVtagaDtcacWat
+ttWtgaaaagaaagNRacDtttStVatBaDNtaactatatcBSMcccaSttccggaMatg
+attaaWatKMaBaBatttgataNctgttKtVaagtcagScgaaaDggaWgtgttttKtWt
+atttHaatgtagttcactaaKMagttSYBtKtaYgaactcagagRtatagtVtatcaaaW
+YagcgNtaDagtacNSaaYDgatBgtcgataacYDtaaactacagWDcYKaagtttatta
+gcatcgagttKcatDaattgattatDtcagRtWSKtcgNtMaaaaacaMttKcaWcaaSV
+MaaaccagMVtaMaDtMaHaBgaacataBBVtaatVYaNSWcSgNtDNaaKacacBttta
+tKtgtttcaaHaMctcagtaacgtcgYtactDcgcctaNgagagcYgatattttaaattt
+ccattttacatttDaaRctattttWctttacgtDatYtttcagacgcaaVttagtaaKaa
+aRtgVtccataBggacttatttgtttaWNtgttVWtaWNVDaattgtatttBaagcBtaa
+BttaaVatcHcaVgacattccNggtcgacKttaaaRtagRtctWagaYggtgMtataatM
+tgaaRttattttgWcttNtDRRgMDKacagaaaaggaaaRStcccagtYccVattaNaaK
+StNWtgacaVtagaagcttSaaDtcacaacgDYacWDYtgtttKatcVtgcMaDaSKStV
+cgtagaaWaKaagtttcHaHgMgMtctataagBtKaaaKKcactggagRRttaagaBaaN
+atVVcgRcKSttDaactagtSttSattgttgaaRYatggttVttaataaHttccaagDtg
+atNWtaagHtgcYtaactRgcaatgMgtgtRaatRaNaacHKtagactactggaatttcg
+ccataacgMctRgatgttaccctaHgtgWaYcactcacYaattcttaBtgacttaaacct
+gYgaWatgBttcttVttcgttWttMcNYgtaaaatctYgMgaaattacNgaHgaacDVVM
+tttggtHtctaaRgtacagacgHtVtaBMNBgattagcttaRcttacaHcRctgttcaaD
+BggttKaacatgKtttYataVaNattccgMcgcgtagtRaVVaattaKaatggttRgaMc
+agtatcWBttNtHagctaatctagaaNaaacaYBctatcgcVctBtgcaaagDgttVtga
+HtactSNYtaaNccatgtgDacgaVtDcgKaRtacDcttgctaagggcagMDagggtBWR
+tttSgccttttttaacgtcHctaVtVDtagatcaNMaVtcVacatHctDWNaataRgcgt
+aVHaggtaaaaSgtttMtattDgBtctgatSgtRagagYtctSaKWaataMgattRKtaa
+catttYcgtaacacattRWtBtcggtaaatMtaaacBatttctKagtcDtttgcBtKYYB
+aKttctVttgttaDtgattttcttccacttgSaaacggaaaNDaattcYNNaWcgaaYat
+tttMgcBtcatRtgtaaagatgaWtgaccaYBHgaatagataVVtHtttVgYBtMctaMt
+cctgaDcYttgtccaaaRNtacagcMctKaaaggatttacatgtttaaWSaYaKttBtag
+DacactagctMtttNaKtctttcNcSattNacttggaacaatDagtattRtgSHaataat
+gccVgacccgatactatccctgtRctttgagaSgatcatatcgDcagWaaHSgctYYWta
+tHttggttctttatVattatcgactaagtgtagcatVgtgHMtttgtttcgttaKattcM
+atttgtttWcaaStNatgtHcaaaDtaagBaKBtRgaBgDtSagtatMtaacYaatYtVc
+KatgtgcaacVaaaatactKcRgtaYtgtNgBBNcKtcttaccttKgaRaYcaNKtactt
+tgagSBtgtRagaNgcaaaNcacagtVtttHWatgttaNatBgtttaatNgVtctgaata
+tcaRtattcttttttttRaaKcRStctcggDgKagattaMaaaKtcaHacttaataataK
+taRgDtKVBttttcgtKaggHHcatgttagHggttNctcgtatKKagVagRaaaggaaBt
+NatttVKcRttaHctaHtcaaatgtaggHccaBataNaNaggttgcWaatctgatYcaaa
+HaatWtaVgaaBttagtaagaKKtaaaKtRHatMaDBtBctagcatWtatttgWttVaaa
+ScMNattRactttgtYtttaaaagtaagtMtaMaSttMBtatgaBtttaKtgaatgagYg
+tNNacMtcNRacMMHcttWtgtRtctttaacaacattattcYaMagBaacYttMatcttK
+cRMtgMNccattaRttNatHaHNaSaaHMacacaVaatacaKaSttHatattMtVatWga
+ttttttaYctttKttHgScWaacgHtttcaVaaMgaacagNatcgttaacaaaaagtaca
+HBNaattgttKtcttVttaaBtctgctacgBgcWtttcaggacacatMgacatcccagcg
+gMgaVKaBattgacttaatgacacacaaaaaatRKaaBctacgtRaDcgtagcVBaacDS
+BHaaaaSacatatacagacRNatcttNaaVtaaaataHattagtaaaaSWccgtatWatg
+gDttaactattgcccatcttHaSgYataBttBaactattBtcHtgatcaataSttaBtat
+KSHYttWggtcYtttBttaataccRgVatStaHaKagaatNtagRMNgtcttYaaSaact
+cagDSgagaaYtMttDtMRVgWKWtgMaKtKaDttttgactatacataatcNtatNaHat
+tVagacgYgatatatttttgtStWaaatctWaMgagaRttRatacgStgattcttaagaD
+taWccaaatRcagcagaaNKagtaaDggcgccBtYtagSBMtactaaataMataBSacRM
+gDgattMMgtcHtcaYDtRaDaacggttDaggcMtttatgttaNctaattaVacgaaMMt
+aatDccSgtattgaRtWWaccaccgagtactMcgVNgctDctaMScatagcgtcaactat
+acRacgHRttgctatttaatgaattataYKttgtaagWgtYttgcHgMtaMattWaWVta
+RgcttgYgttBHtYataSccStBtgtagMgtDtggcVaaSBaatagDttgBgtctttctc
+attttaNagtHKtaMWcYactVcgcgtatMVtttRacVagDaatcttgctBBcRDgcaac
+KttgatSKtYtagBMagaRtcgBattHcBWcaactgatttaatttWDccatttatcgagS
+KaWttataHactaHMttaatHtggaHtHagaatgtKtaaRactgtttMatacgatcaagD
+gatKaDctataMggtHDtggHacctttRtatcttYattttgacttgaaSaataaatYcgB
+aaaaccgNatVBttMacHaKaataagtatKgtcaagactcttaHttcggaattgttDtct
+aaccHttttWaaatgaaatataaaWattccYDtKtaaaacggtgaggWVtctattagtga
+ctattaagtMgtttaagcatttgSgaaatatccHaaggMaaaattttcWtatKctagDtY
+tMcctagagHcactttactatacaaacattaacttaHatcVMYattYgVgtMttaaRtga
+aataaDatcaHgtHHatKcDYaatcttMtNcgatYatgSaMaNtcttKcWataScKggta
+tcttacgcttWaaagNatgMgHtctttNtaacVtgttcMaaRatccggggactcMtttaY
+MtcWRgNctgNccKatcttgYDcMgattNYaRagatHaaHgKctcataRDttacatBatc
+cattgDWttatttaWgtcggagaaaaatacaatacSNtgggtttccttacSMaagBatta
+caMaNcactMttatgaRBacYcYtcaaaWtagctSaacttWgDMHgaggatgBVgcHaDt
+ggaactttggtcNatNgtaKaBcccaNtaagttBaacagtatacDYttcctNgWgcgSMc
+acatStctHatgRcNcgtacacaatRttMggaNKKggataaaSaYcMVcMgtaMaHtgat
+tYMatYcggtcttcctHtcDccgtgRatcattgcgccgatatMaaYaataaYSggatagc
+gcBtNtaaaScaKgttBgagVagttaKagagtatVaactaSacWactSaKatWccaKaaa
+atBKgaaKtDMattttgtaaatcRctMatcaaMagMttDgVatggMaaWgttcgaWatga
+aatttgRtYtattaWHKcRgctacatKttctaccaaHttRatctaYattaaWatVNccat
+NgagtcKttKataStRaatatattcctRWatDctVagttYDgSBaatYgttttgtVaatt
+taatagcagMatRaacttBctattgtMagagattaaactaMatVtHtaaatctRgaaaaa
+aaatttWacaacaYccYDSaattMatgaccKtaBKWBattgtcaagcHKaagttMMtaat
+ttcKcMagNaaKagattggMagaggtaatttYacatcWaaDgatMgKHacMacgcVaaca
+DtaDatatYggttBcgtatgWgaSatttgtagaHYRVacaRtctHaaRtatgaactaata
+tctSSBgggaaHMWtcaagatKgagtDaSatagttgattVRatNtctMtcSaagaSHaat
+aNataataRaaRgattctttaataaagWaRHcYgcatgtWRcttgaaggaMcaataBRaa
+ccagStaaacNtttcaatataYtaatatgHaDgcStcWttaacctaRgtYaRtataKtgM
+ttttatgactaaaatttacYatcccRWtttHRtattaaatgtttatatttgttYaatMca
+RcSVaaDatcgtaYMcatgtagacatgaaattgRtcaaYaaYtRBatKacttataccaNa
+aattVaBtctggacaagKaaYaaatatWtMtatcYaaVNtcgHaactBaagKcHgtctac
+aatWtaDtSgtaHcataHtactgataNctRgttMtDcDttatHtcgtacatcccaggStt
+aBgtcacacWtccNMcNatMVaVgtccDYStatMaccDatggYaRKaaagataRatttHK
+tSaaatDgataaacttaHgttgVBtcttVttHgDacgaKatgtatatNYataactctSat
+atatattgcHRRYttStggaactHgttttYtttaWtatMcttttctatctDtagVHYgMR
+BgtHttcctaatYRttKtaagatggaVRataKDctaMtKBNtMtHNtWtttYcVtattMc
+gRaacMcctNSctcatttaaagDcaHtYccSgatgcaatYaaaaDcttcgtaWtaattct
+cgttttScttggtaatctttYgtctaactKataHacctMctcttacHtKataacacagcN
+RatgKatttttSaaatRYcgDttaMRcgaaattactMtgcgtaagcgttatBtttttaat
+taagtNacatHgttcRgacKcBBtVgatKttcgaBaatactDRgtRtgaNacWtcacYtt
+aaKcgttctHaKttaNaMgWgWaggtctRgaKgWttSttBtDcNtgtttacaaatYcDRt
+gVtgcctattcNtctaaaDMNttttNtggctgagaVctDaacVtWccaagtaacacaNct
+gaScattccDHcVBatcgatgtMtaatBgHaatDctMYgagaatgYWKcctaatNaStHa
+aaKccgHgcgtYaaYtattgtStgtgcaaRtattaKatattagaWVtcaMtBagttatta
+gNaWHcVgcaattttDcMtgtaRHVYtHtctgtaaaaHVtMKacatcgNaatttMatatg
+ttgttactagWYtaRacgataKagYNKcattataNaRtgaacKaYgcaaYYacaNccHat
+MatDcNgtHttRaWttagaaDcaaaaaatagggtKDtStaDaRtaVtHWKNtgtattVct
+SVgRgataDaRaWataBgaagaaKtaataaYgDcaStaNgtaDaaggtattHaRaWMYaY
+aWtggttHYgagVtgtgcttttcaaDKcagVcgttagacNaaWtagtaataDttctggtt
+VcatcataaagtgKaaaNaMtaBBaattaatWaattgctHaVKaSgDaaVKaHtatatat
+HatcatSBagNgHtatcHYMHgttDgtaHtBttWatcgtttaRaattgStKgSKNWKatc
+agDtctcagatttctRtYtBatBgHHtKaWtgYBgacVVWaKtacKcDttKMaKaVcggt
+gttataagaataaHaatattagtataatMHgttYgaRttagtaRtcaaVatacggtcMcg
+agtaaRttacWgactKRYataaaagSattYaWgagatYagKagatgSaagKgttaatMgg
+tataatgttWYttatgagaaacctNVataatHcccKtDctcctaatactggctHggaSag
+gRtKHaWaattcgSatMatttagaggcYtctaMcgctcataSatatgRagacNaaDagga
+VBagaYttKtacNaKgtSYtagttggaWcatcWttaatctatgaVtcgtgtMtatcaYcg
+tRccaaYgDctgcMgtgtWgacWtgataacacgcgctBtgttaKtYDtatDcatcagKaV
+MctaatcttgVcaaRgcRMtDcgattaHttcaNatgaatMtactacVgtRgatggaWttt
+actaaKatgagSaaKggtaNtactVaYtaaKRagaacccacaMtaaMtKtatBcttgtaa
+WBtMctaataaVcDaaYtcRHBtcgttNtaaHatttBNgRStVDattBatVtaagttaYa
+tVattaagaBcacggtSgtVtatttaRattgatgtaHDKgcaatattKtggcctatgaWD
+KRYcggattgRctatNgatacaatMNttctgtcRBYRaaaHctNYattcHtaWcaattct
+BtMKtVgYataatMgYtcagcttMDataVtggRtKtgaatgccNcRttcaMtRgattaac
+attRcagcctHtWMtgtDRagaKaBtgDttYaaaaKatKgatctVaaYaacWcgcatagB
+VtaNtRtYRaggBaaBtgKgttacataagagcatgtRattccacttaccatRaaatgWgD
+aMHaYVgVtaSctatcgKaatatattaDgacccYagtgtaYNaaatKcagtBRgagtcca
+tgKgaaaccBgaagBtgSttWtacgatWHaYatcgatttRaaNRgcaNaKVacaNtDgat
+tgHVaatcDaagcgtatgcNttaDataatcSataaKcaataaHWataBtttatBtcaKtK
+tatagttaDgSaYctacaRatNtaWctSaatatttYaKaKtaccWtatcRagacttaYtt
+VcKgSDcgagaagatccHtaattctSttatggtKYgtMaHagVaBRatttctgtRgtcta
+tgggtaHKgtHacHtSYacgtacacHatacKaaBaVaccaDtatcSaataaHaagagaat
+ScagactataaRttagcaaVcaHataKgDacatWccccaagcaBgagWatctaYttgaaa
+tctVNcYtttWagHcgcgcDcVaaatgttKcHtNtcaatagtgtNRaactttttcaatgg
+WgBcgDtgVgtttctacMtaaataaaRggaaacWaHttaRtNtgctaaRRtVBctYtVta
+tDcattDtgaccYatagatYRKatNYKttNgcctagtaWtgaactaMVaacctgaStttc
+tgaKVtaaVaRKDttVtVctaDNtataaaDtccccaagtWtcgatcactDgYaBcatcct
+MtVtacDaaBtYtMaKNatNtcaNacgDatYcatcgcaRatWBgaacWttKttagYtaat
+tcggttgSWttttDWctttacYtatatWtcatDtMgtBttgRtVDggttaacYtacgtac
+atgaattgaaWcttMStaDgtatattgaDtcRBcattSgaaVBRgagccaaKtttcDgcg
+aSMtatgWattaKttWtgDBMaggBBttBaatWttRtgcNtHcgttttHtKtcWtagHSt
+aacagttgatatBtaWSaWggtaataaMttaKacDaatactcBttcaatatHttcBaaSa
+aatYggtaRtatNtHcaatcaHtagVtgtattataNggaMtcttHtNagctaaaggtaga
+YctMattNaMVNtcKtactBKcaHHcBttaSagaKacataYgctaKaYgttYcgacWVtt
+WtSagcaacatcccHaccKtcttaacgaKttcacKtNtacHtatatRtaaatacactaBt
+ttgaHaRttggttWtatYagcatYDatcggagagcWBataagRtacctataRKgtBgatg
+aDatataSttagBaHtaatNtaDWcWtgtaattacagKttcNtMagtattaNgtctcgtc
+ctcttBaHaKcKccgtRcaaYagSattaagtKataDatatatagtcDtaacaWHcaKttD
+gaaRcgtgYttgtcatatNtatttttatggccHtgDtYHtWgttatYaacaattcaWtat
+NgctcaaaSttRgctaatcaaatNatcgtttaBtNNVtgttataagcaaagattBacgtD
+atttNatttaaaDcBgtaSKgacgtagataatttcHMVNttgttBtDtgtaWKaaRMcKM
+tHtaVtagataWctccNNaSWtVaHatctcMgggDgtNHtDaDttatatVWttgttattt
+aacctttcacaaggaSaDcggttttttatatVtctgVtaacaStDVaKactaMtttaSNa
+gtgaaattaNacttSKctattcctctaSagKcaVttaagNaVcttaVaaRNaHaaHttat
+gtHttgtgatMccaggtaDcgaccgtWgtWMtttaHcRtattgScctatttKtaaccaag
+tYagaHgtWcHaatgccKNRtttagtMYSgaDatctgtgaWDtccMNcgHgcaaacNDaa
+aRaStDWtcaaaaHKtaNBctagBtgtattaactaattttVctagaatggcWSatMaccc
+ttHttaSgSgtgMRcatRVKtatctgaaaccDNatYgaaVHNgatMgHRtacttaaaRta
+tStRtDtatDttYatattHggaBcttHgcgattgaKcKtttcRataMtcgaVttWacatN
+catacctRataDDatVaWNcggttgaHtgtMacVtttaBHtgagVttMaataattatgtt
+cttagtttgtgcDtSatttgBtcaacHattaaBagVWcgcaSYttMgcttacYKtVtatc
+aYaKctgBatgcgggcYcaaaaacgNtctagKBtattatctttKtaVttatagtaYtRag
+NtaYataaVtgaatatcHgcaaRataHtacacatgtaNtgtcgYatWMatttgaactacR
+ctaWtWtatacaatctBatatgYtaagtatgtgtatSttactVatcttYtaBcKgRaSgg
+RaaaaatgcagtaaaWgtaRgcgataatcBaataccgtatttttccatcNHtatWYgatH
+SaaaDHttgctgtccHtggggcctaataatttttctatattYWtcattBtgBRcVttaVM
+RSgctaatMagtYtttaaaaatBRtcBttcaaVtaacagctccSaaSttKNtHtKYcagc
+agaaaccccRtttttaaDcDtaStatccaagcgctHtatcttaDRYgatDHtWcaaaBcW
+gKWHttHataagHacgMNKttMKHccaYcatMVaacgttaKgYcaVaaBtacgcaacttt
+MctaaHaatgtBatgagaSatgtatgSRgHgWaVWgataaatatttccKagVgataattW
+aHNcYggaaatgctHtKtaDtctaaagtMaatVDVactWtSaaWaaMtaHtaSKtcBRaN
+cttStggtBttacNagcatagRgtKtgcgaacaacBcgKaatgataagatgaaaattgta
+ctgcgggtccHHWHaaNacaBttNKtKtcaaBatatgctaHNgtKcDWgtttatNgVDHg
+accaacWctKaaggHttgaRgYaatHcaBacaatgagcaaattactgtaVaaYaDtagat
+tgagNKggtggtgKtWKaatacagDRtatRaMRtgattDggtcaaYRtatttNtagaDtc
+acaaSDctDtataatcgtactaHttatacaatYaacaaHttHatHtgcgatRRttNgcat
+SVtacWWgaaggagtatVMaVaaattScDDKNcaYBYaDatHgtctatBagcaacaagaa
+tgagaaRcataaKNaRtBDatcaaacgcattttttaaBtcSgtacaRggatgtMNaattg
+gatatWtgagtattaaaVctgcaYMtatgatttttYgaHtgtcttaagWBttHttgtctt
+attDtcgtatWtataataSgctaHagcDVcNtaatcaagtaBDaWaDgtttagYctaNcc
+DtaKtaHcttaataacccaRKtacaVaatNgcWRaMgaattatgaBaaagattVYaHMDc
+aDHtcRcgYtcttaaaWaaaVKgatacRtttRRKYgaatacaWVacVcRtatMacaBtac
+tggMataaattttHggNagSctacHgtBagcgtcgtgattNtttgatSaaggMttctttc
+ttNtYNagBtaaacaaatttMgaccttacataattgYtcgacBtVMctgStgMDtagtaR
+ctHtatgttcatatVRNWataDKatWcgaaaaagttaaaagcacgHNacgtaatctttMR
+tgacttttDacctataaacgaaatatgattagaactccSYtaBctttaataacWgaaaYa
+tagatgWttcatKtNgatttttcaagHtaYgaaRaDaagtaggagcttatVtagtctttc
+attaaaatcgKtattaRttacagVaDatgcatVgattgggtctttHVtagKaaRBtaHta
+aggccccaaaaKatggtttaMWgtBtaaacttcactttKHtcgatctccctaYaBacMgt
+cttBaBaNgcgaaacaatctagtHccHtKttcRtRVttccVctttcatacYagMVtMcag
+aMaaacaataBctgYtaatRaaagattaaccatVRatHtaRagcgcaBcgDttStttttc
+VtttaDtKgcaaWaaaaatSccMcVatgtKgtaKgcgatatgtagtSaaaDttatacaaa
+catYaRRcVRHctKtcgacKttaaVctaDaatgttMggRcWaacttttHaDaKaDaBctg
+taggcgtttaHBccatccattcNHtDaYtaataMttacggctNVaacDattgatatttta
+cVttSaattacaaRtataNDgacVtgaacataVRttttaDtcaaacataYDBtttaatBa
+DtttYDaDaMccMttNBttatatgagaaMgaNtattHccNataattcaHagtgaaggDga
+tgtatatatgYatgaStcataaBStWacgtcccataRMaaDattggttaaattcMKtctM
+acaBSactcggaatDDgatDgcWctaacaccgggaVcacWKVacggtaNatatacctMta
+tgatagtgcaKagggVaDtgtaacttggagtcKatatcgMcttRaMagcattaBRaStct
+YSggaHYtacaactMBaagDcaBDRaaacMYacaHaattagcattaaaHgcgctaaggSc
+cKtgaaKtNaBtatDDcKBSaVtgatVYaagVtctSgMctacgttaacWaaattctSgtD
+actaaStaaattgcagBBRVctaatatacctNttMcRggctttMttagacRaHcaBaacV
+KgaataHttttMgYgattcYaNRgttMgcVaaacaVVcDHaatttgKtMYgtatBtVVct
+WgVtatHtacaaHttcacgatagcagtaaNattBatatatttcVgaDagcggttMaagtc
+ScHagaaatgcYNggcgtttttMtStggtRatctacttaaatVVtBacttHNttttaRca
+aatcacagHgagagtMgatcSWaNRacagDtatactaaDKaSRtgattctccatSaaRtt
+aaYctacacNtaRtaactggatgaccYtacactttaattaattgattYgttcagDtNKtt
+agDttaaaaaaaBtttaaNaYWKMBaaaacVcBMtatWtgBatatgaacVtattMtYatM
+NYDKNcKgDttDaVtaaaatgggatttctgtaaatWtctcWgtVVagtcgRgacttcccc
+taDcacagcRcagagtgtWSatgtacatgttaaSttgtaaHcgatgggMagtgaacttat
+RtttaVcaccaWaMgtactaatSSaHtcMgaaYtatcgaaggYgggcgtgaNDtgttMNg
+aNDMtaattcgVttttaacatgVatgtWVMatatcaKgaaattcaBcctccWcttgaaWH
+tWgHtcgNWgaRgctcBgSgaattgcaaHtgattgtgNagtDttHHgBttaaWcaaWagc
+aSaHHtaaaVctRaaMagtaDaatHtDMtcVaWMtagSagcttHSattaacaaagtRacM
+tRtctgttagcMtcaBatVKtKtKacgagaSNatSactgtatatcBctgagVtYactgta
+aattaaaggcYgDHgtaacatSRDatMMccHatKgttaacgactKtgKagtcttcaaHRV
+tccttKgtSataatttacaactggatDNgaacttcaRtVaagDcaWatcBctctHYatHa
+DaaatttagYatSatccaWtttagaaatVaacBatHcatcgtacaatatcgcNYRcaata
+YaRaYtgattVttgaatgaVaactcRcaNStgtgtattMtgaggtNttBaDRcgaaaagc
+tNgBcWaWgtSaDcVtgVaatMKBtttcgtttctaaHctaaagYactgMtatBDtcStga
+ccgtSDattYaataHctgggaYYttcggttaWaatctggtRagWMaDagtaacBccacta
+cgHWMKaatgatWatcctgHcaBaSctVtcMtgtDttacctaVgatYcWaDRaaaaRtag
+atcgaMagtggaRaWctctgMgcWttaagKBRtaaDaaWtctgtaagYMttactaHtaat
+cttcataacggcacBtSgcgttNHtgtHccatgttttaaagtatcgaKtMttVcataYBB
+aKtaMVaVgtattNDSataHcagtWMtaggtaSaaKgttgBtVtttgttatcatKcgHac
+acRtctHatNVagSBgatgHtgaRaSgttRcctaacaaattDNttgacctaaYtBgaaaa
+tagttattactcttttgatgtNNtVtgtatMgtcttRttcatttgatgacacttcHSaaa
+ccaWWDtWagtaRDDVNacVaRatgttBccttaatHtgtaaacStcVNtcacaSRttcYa
+gacagaMMttttgMcNttBcgWBtactgVtaRttctccaaYHBtaaagaBattaYacgat
+ttacatctgtaaMKaRYtttttactaaVatWgctBtttDVttctggcDaHaggDaagtcg
+aWcaagtagtWttHtgKtVataStccaMcWcaagataagatcactctHatgtcYgaKcat
+cagatactaagNSStHcctRRNtattgtccttagttagMVgtatagactaactctVcaat
+MctgtttgtgttgccttatWgtaBVtttctggMcaaKgDWtcgtaaYStgSactatttHg
+atctgKagtagBtVacRaagRtMctatgggcaaaKaaaatacttcHctaRtgtDcttDat
+taggaaatttcYHaRaaBttaatggcacKtgctHVcaDcaaaVDaaaVcgMttgtNagcg
+taDWgtcgttaatDgKgagcSatatcSHtagtagttggtgtHaWtaHKtatagctgtVga
+ttaBVaatgaataagtaatVatSttaHctttKtttgtagttaccttaatcgtagtcctgB
+cgactatttVcMacHaaaggaatgDatggKtaHtgStatattaaSagctWcctccRtata
+BaDYcgttgcNaagaggatRaaaYtaWgNtSMcaatttactaacatttaaWttHtatBat
+tgtcgacaatNgattgcNgtMaaaKaBDattHacttggtRtttaYaacgVactBtaBaKt
+gBttatgVttgtVttcaatcWcNctDBaaBgaDHacBttattNtgtDtatttVSaaacag
+gatgcRatSgtaSaNtgBatagttcHBgcBBaaattaHgtDattatDaKaatBaaYaaMa
+ataaataKtttYtagtBgMatNcatgtttgaNagtgttgtgKaNaSagtttgaSMaYBca
+aaacDStagttVacaaaaactaaWttBaagtctgtgcgtMgtaattctcctacctcaNtt
+taaccaaaaVtBcacataacaccccBcWMtatVtggaatgaWtcaaWaaaaaaaaWtDta
+atatRcctDWtcctaccMtVVatKttaWaaKaaatataaagScHBagaggBaSMtaWaVt
+atattactSaaaKNaactatNatccttgaYctattcaaaVgatttYHcRagattttaSat
+aggttattcVtaaagaKgtattattKtRttNcggcRgtgtgtWYtaacHgKatKgatYta
+cYagDtWcHBDctctgRaYKaYagcactKcacSaRtBttttBHKcMtNtcBatttatttt
+tgSatVgaaagaWtcDtagDatatgMacaacRgatatatgtttgtKtNRaatatNatgYc
+aHtgHataacKtgagtagtaacYttaNccaaatHcacaacaVDtagtaYtccagcattNt
+acKtBtactaaagaBatVtKaaHBctgStgtBgtatgaSNtgDataaccctgtagcaBgt
+gatcttaDataStgaMaccaSBBgWagtacKcgattgaDgNNaaaacacagtSatBacKD
+gcgtataBKcatacactaSaatYtYcDaactHttcatRtttaatcaattataRtttgtaa
+gMcgNttcatcBtYBagtNWNMtSHcattcRctttttRWgaKacKttgggagBcgttcgc
+MaWHtaatactgtctctatttataVgtttaBScttttaBMaNaatMacactYtBMggtHa
+cMagtaRtctgcatttaHtcaaaatttgagKtgNtactBacaHtcgtatttctMaSRagc
+agttaatgtNtaaattgagagWcKtaNttagVtacgatttgaatttcgRtgtWcVatcgt
+taaDVctgtttBWgaccagaaagtcSgtVtatagaBccttttcctaaattgHtatcggRa
+ttttcaaggcYSKaagWaWtRactaaaacccBatMtttBaatYtaagaactSttcgaaSc
+aatagtattgaccaagtgttttctaacatgtttNVaatcaaagagaaaNattaaRtttta
+VaaaccgcaggNMtatattVctcaagaggaacgBgtttaacaagttcKcYaatatactaa
+ccBaaaSggttcNtattctagttRtBacgScVctcaatttaatYtaaaaaaatgSaatga
+tagaMBRatgRcMcgttgaWHtcaVYgaatYtaatctttYttatRaWtctgBtDcgatNa
+tcKaBaDgatgtaNatWKctccgatattaacattNaaacDatgBgttctgtDtaaaMggt
+gaBaSHataacgccSctaBtttaRBtcNHcDatcDcctagagtcRtaBgWttDRVHagat
+tYatgtatcWtaHtttYcattWtaaagtctNgtStggRNcgcggagSSaaagaaaatYcH
+DtcgctttaatgYcKBVSgtattRaYBaDaaatBgtatgaHtaaRaRgcaSWNtagatHa
+acttNctBtcaccatctMcatattccaSatttgcgaDagDgtatYtaaaVDtaagtttWV
+aagtagYatRttaagDcNgacKBcScagHtattatcDaDactaaaaaYgHttBcgaDttg
+gataaaKSRcBMaBcgaBSttcWtgNBatRaccgattcatttataacggHVtaattcaca
+agagVttaaRaatVVRKcgWtVgacctgDgYaaHaWtctttcacMagggatVgactagMa
+aataKaaNWagKatagNaaWtaaaatttgaattttatttgctaaVgaHatBatcaaBWcB
+gttcMatcgBaaNgttcgSNaggSaRtttgHtRtattaNttcDcatSaVttttcgaaaaa
+ttgHatctaRaggSaNatMDaaatDcacgattttagaHgHaWtYgattaatHNSttatMS
+gggNtcKtYatRggtttgtMWVtttaYtagcagBagHaYagttatatggtBacYcattaR
+SataBatMtttaaatctHcaaaSaaaagttNSaaWcWRccRtKaagtBWtcaaattSttM
+tattggaaaccttaacgttBtWatttatatWcDaatagattcctScacctaagggRaaYt
+aNaatgVtBcttaaBaacaMVaaattatStYgRcctgtactatcMcVKatttcgSgatRH
+MaaaHtagtaaHtVgcaaataatatcgKKtgccaatBNgaaWcVttgagttaKatagttc
+aggKDatDtattgaKaVcaKtaataDataataHSaHcattagttaatRVYcNaHtaRcaa
+ggtNHcgtcaaccaBaaagYtHWaaaRcKgaYaaDttgcWYtataRgaatatgtYtgcKt
+aNttWacatYHctRaDtYtattcBttttatcSataYaYgttWaRagcacHMgtttHtYtt
+YaatcggtatStttcgtRSattaaDaKMaatatactaNBaWgctacacYtgaYVgtgHta
+aaRaaRgHtagtWattataaaSDaaWtgMattatcgaaaagtaYRSaWtSgNtBgagcRY
+aMDtactaacttaWgtatctagacaagNtattHggataatYttYatcataDcgHgttBtt
+ctttVttgccgaaWtaaaacgKgtatctaaaaaNtccDtaDatBMaMggaatNKtatBaa
+atVtccRaHtaSacataHattgtttKVYattcataVaattWtcgtgMttcttKtgtctaa
+cVtatctatatBRataactcgKatStatattcatHHRttKtccaacgtgggtgRgtgaMt
+attattggctatcgtgacMtRcBDtcttgtactaatRHttttaagatcgVMDStattatY
+BtttDttgtBtNttgRcMtYtgBacHaWaBaatDKctaagtgaaactaatgRaaKgatcc
+aagNaaaatattaggWNtaagtatacttttKcgtcggSYtcttgRctataYcttatataa
+agtatattaatttataVaacacaDHatctatttttKYVatHRactttaBHccaWagtact
+BtcacgaVgcgttRtttttttSVgtSagtBaaattctgaHgactcttgMcattttagVta
+agaattHctHtcaDaaNtaacRggWatagttcgtSttgaDatcNgNagctagDgatcNtt
+KgttgtaDtctttRaaYStRatDtgMggactSttaDtagSaVtBDttgtDgccatcacaM
+attaaaMtNacaVcgSWcVaaDatcaHaatgaattaMtatccVtctBtaattgtWattat
+BRcWcaatgNNtactWYtDaKttaaatcactcagtRaaRgatggtKgcgccaaHgaggat
+StattYcaNMtcaBttacttatgagDaNtaMgaaWtgtttcttctaHtMNgttatctaWW
+atMtBtaaatagDVatgtBYtatcggcttaagacMRtaHScgatatYgRDtcattatSDa
+HggaaataNgaWSRRaaaBaatagBattaDctttgHWNttacaataaaaaaatacggttt
+gHgVtaHtWMttNtBtctagtMcgKMgHgYtataHaNagWtcaacYattaataYRgtaWK
+gaBctataaccgatttaHaNBRaRaMtccggtNgacMtctcatttgcaattcWgMactta
+caaDaaNtactWatVtttagccttMaatcagVaagtctVaaDaBtattaattaYtNaYtg
+gattaKtaKctYaMtattYgatattataatKtVgDcttatatNBtcgttgtStttttMag
+aggttaHYSttcKgtcKtDNtataagttataagSgttatDtRttattgttttSNggRtca
+aKMNatgaatattgtBWtaMacctgggYgaSgaagYataagattacgagaatBtggtRcV
+HtgYggaDgaYaKagWagctatagacgaaHgtWaNgacttHRatVaWacKYtgRVNgVcS
+gRWctacatcKSactctgWYtBggtataagcttNRttVtgRcaWaaatDMatYattaact
+ttcgaagRatSctgccttgcRKaccHtttSNVagtagHagBagttagaccaRtataBcca
+taatSHatRtcHagacBWatagcaMtacaRtgtgaaBatctKRtScttccaNaatcNgta
+atatWtcaMgactctBtWtaaNactHaaaaRctcgcatggctMcaaNtcagaaaaacaca
+gtggggWttRttagtaagaVctVMtcgaatcttcMaaaHcaHBttcgattatgtcaDagc
+YRtBtYcgacMgtDcagcgaNgttaataatagcagKYYtcgtaBtYctMaRtaRtDagaa
+aacacatgYaBttgattattcgaaNttBctSataaMataWRgaHtttccgtDgaYtatgg
+tDgHKgMtatttVtMtVagttaRatMattRagataaccctKctMtSttgaHagtcStcta
+tttccSagatgttccacgaggYNttHRacgattcDatatDcataaaatBBttatcgaHtN
+HaaatatDNaggctgaNcaaggagttBttMgRagVatBcRtaWgatgBtSgaKtcgHttt
+gaatcaaDaHttcSBgHcagtVaaSttDcagccgttNBtgttHagYtattctttRWaaVt
+SttcatatKaaRaaaNacaVtVctMtSDtDtRHRcgtaatgctcttaaatSacacaatcg
+HattcaWcttaaaatHaaatcNctWttaNMcMtaKctVtcctaagYgatgatcYaaaRac
+tctaRDaYagtaacgtDgaggaaatctcaaacatcaScttcKttNtaccatNtaNataca
+tttHaaDHgcaDatMWaaBttcRggctMaagctVYcacgatcaDttatYtaatcKatWat
+caatVYtNagatttgattgaYttttYgacttVtcKaRagaaaHVgDtaMatKYagagttN
+atWttaccNtYtcDWgSatgaRgtMatgKtcgacaagWtacttaagtcgKtgatccttNc
+ttatagMatHVggtagcgHctatagccctYttggtaattKNaacgaaYatatVctaataM
+aaaYtgVtcKaYtaataacagaatHcacVagatYWHttagaaSMaatWtYtgtaaagNaa
+acaVgaWtcacNWgataNttcaSagctMDaRttgNactaccgataMaaatgtttattDtc
+aagacgctDHYYatggttcaagccNctccttcMctttagacBtaaWtaWVHggaaaaNat
+ttaDtDtgctaaHHtMtatNtMtagtcatttgcaaaRatacagRHtatDNtgtDgaatVg
+tVNtcaaatYBMaaaagcaKgtgatgatMgWWMaHttttMgMagatDtataaattaacca
+actMtacataaattgRataatacgBtKtaataattRgtatDagDtcRDacctatRcagag
+cSHatNtcaScNtttggacNtaaggaccgtgKNttgttNcttgaaRgYgRtNtcagttBc
+ttttcHtKtgcttYaaNgYagtaaatgaatggWaMattBHtatctatSgtcYtgcHtaat
+tHgaaMtHcagaaSatggtatgccaHBtYtcNattWtgtNgctttaggtttgtWatNtgH
+tgcDttactttttttgcNtactKtWRaVcttcatagtgSNKaNccgaataaBttataata
+YtSagctttaaatSttggctaaKSaatRccgWHgagDttaaatcatgagMtcgagtVtaD
+ggaBtatttgDacataaacgtagYRagBWtgDStKDgatgaagttcattatttaKWcata
+aatWRgatataRgttRacaaNKttNtKagaaYaStaactScattattaacgatttaaatg
+DtaattagatHgaYataaactatggggatVHtgccgtNgatNYcaStRtagaccacWcaM
+tatRagHgVactYtWHtcttcatgatWgagaKggagtatgaWtDtVtNaNtcgYYgtaaa
+ctttaDtBactagtaDctatagtaatatttatatataacgHaaaRagKattSagttYtSt
+atatatagtcttaaaaMtcatgttcaaDactgRttctaagagDtatttttagcgacttgt
+gRtgNctgSgRaaaaatgcaMtYtDcatcaaYKttHcatSWgaaaatDataggttatgBD
+MtgttataacaaYSgagttacgttatgtDStttaaatctcgWKtcSacgagagaSgttat
+BMDgtcggtgtgcgaNtaSHBatBtttVMgVcagaNatcaDDaKMtMYtatagaBccctc
+tDtgtatttatatKNtgggtatgtRaacttgaWaaYgcaHatccctggtttStatMtcgc
+MtaaaWKttMVtWctVtgttaKDWctgWaVttaDVatgKtagagtcatctaKWgtaaMtt
+SacBaMattaKaaHDataattgWtgttttgtcatBacacgtStacaaagtNctNtgtgat
+cHtWttcKaagagttttaaaaWacgRacatctNatVStgaatDHgttWcgtRKcatatat
+ctcaNttaaBDcctgaaaaaDtaYaHaKttNtaYVaVtttaDtctacttctWttaactaa
+ttttMagWcaatcccNKYtBaacatgttgaKgKcgcBHaatDMttatatcSWacatDatR
+cWaMtDgatBctHgScttaaaHtSgKtDtttattgtRStWgttccatatttcacWttcat
+attgtaHVgaBtacaMtgMaaagDaataactDatattagMaNBagcttcattcgtaaKtg
+tatttcacMtgBaVtaattStcttagtYgtgtcgccttKatgggtgaWaataggaatacM
+MagaSKRttBgatgacRtgMtagaSRataggtatcaccgaNaaaWSWacDgatacttgat
+tagcttgtgVMttatYctaRgHVcDtVRRtSaMtcaVtVtatcaYaHatattaaVaatct
+aBtgtacRatNtatttgaYatSaHctaNgNtYtYaYagattVgatcRtaacgYggtgtat
+KttaatMagatgRtatatgHaKccHaaaaYtgaacgaWaNgtYHgacagaYtctaVtacc
+cgatttttaaagcDttatNRgattKaaattttcatctaatgccgcaataataattgttat
+YtagtRNtaagttggtHaKttWMtDKgatSagBYcgRggtWaVaattHtatgtaaaMgSa
+aagataaKaaKgttDttttRaagaacaWRcaacDgtgttaatattaKtatcaWacacatt
+tVtctgatHRcagtttNcaaatcNctNttttataactWacBBttgBttaaaRaWtBKaaa
+cgtatcRcaMaatgYacaaaagtgBataStWYtggtatgacaKWtctSgcKHgtcNaMNc
+ataSatattgactacMcataattNVtDaRccaaatcagttttYttagYaacgtaatMtMV
+atNgKaaMaaBgattaKttatDaBcttKtccttttacDagaYtacHgttggacaaaVaat
+agtYatcataSgatcaaWVttcgaatgaccctccttNtaSBWaatttDttttcaatatYg
+gctatDcttatNctttagDcMttcaacWaaNattSYgctttcaHcRaattaataaaatcV
+ccRaattactctaMaVRattacagtgRcDtcgtgctcttNtWVtacagtHtatHaBDtcW
+ggtgctcaaRHtatgtDgacStgcaaaVKtagttataatactaatatgtagScaatRSac
+aattgtattgcagatHHtgBcaatKKtaaMMcaRcgactatKBaMaYatgKatttDaaNt
+RatattgtatWttagcaaaaacaWgcacaaHcataYtDaHgttataaSacgcagggggtY
+atgcKctaaaHgcVgctBDaVttccStagNgcSgtatgVYaMatcaWRBtVtgYttgtgR
+cYttcgctgaacNttgtgtctattWttttcctagMtagaWtaKgatStScatMaBtaSta
+SactattYNatctgtacRatYDaatgatgatatgaatYaaaaSHttaaYMaWtDcaNHaB
+caYtgVgcatVaacattMRatBtaatttaDacRtagtaaaNYVSMtcagaaDtttDHtRc
+YatacSNKaaMcHgatBaaVttactggBYgaYatttttgcDacHctWatcgtagagtact
+cattDggtcatKaSgctttatttagtDtRBacttaWYaaaattttgaccttaaWtaatgc
+RgccacttMtaggKtcBtgacgaHctttatcgtcStatMHDNagattatNagVaaaWcgg
+aaaYcaVactDYactaStattgBHtcYctgggtacatataaYcgaYagaggaggacaVat
+acHRtYtctgtaVgaYcNgaaaNatacVgcNgtaatttDcatttttcaacttSNcaaDat
+VYctSgcaccttagMgacgcttgaSttaaaatagttaggRHttaaacMatagcaWgMgag
+tcgctagtgtKgactaaHttattaWgcaaaaaaSatatgcgttaBNggttaYVatgaact
+ttttgccatataaataRatSaBctagttataBccgaaacaagatacttaattttgaHgHM
+gtaaKctttaYtaaRacBMtBaYgaBaaacaYtVtagcRgWatHaWagattWSacStMHa
+tttaDagacaatcgtgtKtttggaMtgtWtgtgcaaNaaaaWtKaaBcMWtcttctatga
+cVgagcgaggHaYYtttWgSaaYYaWtRYHHaMDtctttacaatggaaMctataagcttB
+cgHcNWaatttgtatatYtStatctagcactgtVttccagaaattaDtttaRtVataBtt
+WagcatDMVactYtgcatWtttgaaMggKaatgaaaaHtataDtgYcMggVaaatSMHtt
+tgVttaYaWaataRttgttaYttattttRtWtataaBgtDtttatatcVgaaBcaDtatg
+tcaDagaWtgaYtWctcVagctcagctatatagcRVtcaKtaataatHgNaccgaaaatV
+HBaatattcgttaVYttatttctBYaatKaagaccVStttcattgaMagSaaaaccccWK
+caaNtMYacctaDStagaaatttatcatVgtcaatacccKattgtaaagtggWgtatatV
+tagBcttDaBacaattWtDYKtatRKggStRtaaaWatBtaagtaattDaaaaBRacWta
+agtacaSttaaatccgctaaccKaattgVWttDattatttattKaMtcYtMRWagMtcgK
+gBagacgggVaaNaaatgctKcgtaataaKtaaagtccWcttHMatSYgataaatDttBa
+HccattgBttSgaaHYtaataaaMtgaagatgtttBgRcattaRaDHcttBgaMaWaaVM
+MattaatttgtgBRctattgKMagNcMtatttaaaWttgaaacatWgcScgYYDYgttYt
+VtattgcKcWtagcggtgBaSctaKatacaaVtcaRDccccgtgttBgKgggtHagcgaa
+ttaaagMMttScggtDttttaHcSaagaacactcacactBcVgaKNaDHacacttatSag
+aattSKHtcagtataaatKaaHtgaaRagaaVcBtaHtaaatcgatcWcaRtaaaattta
+WttaagtcaggRctgaWcttDttgactttaVSaaaatggtaWDaRMtBtaaaaaKatBga
+tMtctatatcaVaMgatttgNagtDRttDatcttttaMtYaaatcggagttctctaYatN
+tagaNcgMMactacHcaagtaaaatStaSaacaHcacSgggtNKatggaaagcggaaKgg
+gtaYtacSgccgBaggcRacgtVgDtggaMcYaaaMatggacgYStKKatgaBcaaRtSt
+ccSagcRccgccgcSDtgcggBDgaDtBtSSggacMttttaWcatcMatgtNMBWgataa
+tcaaVtgaataataaNatgcaaNttNctgacDMcaHccgatgKgWVttccaStggattct
+cDacttttttctttaaNcWaMWccWKWttgaaaMctDaaBactRtVattttBtcMaNttW
+cKacagttKSttaYaWSactHSaBtHgatgttacatgcatatMtttgtaacScWHBatHa
+ctggatatatctgagMgRSatctaaSttaVagcaRcttggaYaatKHtagBBactattcg
+taaagaagttgtVcgatgaVatHMtcaggtcgKSgWattgaaaVctccVgtDcaaatgaa
+HgMYactcaMatatatattNVttWtWaatttacRagKataaaNtttacaaWgMVactatt
+aSgaggVaaagVtaccDRHaaataRaHaRgcattMttcaatcaKaaataDcaDKtctcga
+ggBggacctDtttatHacWVaWgatDctaNaNcgKatcMtcMaatBtttggacgtgataa
+tagaaacRactcBtattttaKtgSaaggKtaggRaVtatagcccaNRttaccttSMaaga
+tcggDacNBatWcgaactacactaactNBtaStgVtNagcatctaVtaKatKgaBtcgtt
+tWaagWMgagRaNatHaaaaDtacagacaBagtgcaHaNatctcBccNttaagttDgaat
+aaNtcgctaacRBgtaatSttaatatgcataacccaSattKcccttDttggtcaatgggt
+tWaacgatacattBtgMaYgaRttatgatKaKgtattDtKWgataacgNBtaccgaKWat
+cttcttKtgtcttagcattcctWcaaHgagtatDMSgKtcagcttgVHaKcttDaataaa
+VaatttDgtgaaataaRgtcaVaatacttagtVatatgggcatgtDDtMtgtatBggatt
+HtgcVtgtgatcaaSattatKYVaacSNNttNWcgaHttKDaaMYHatcgttaattaStt
+gctWaacHtaKBtaaaaKHttcRWgaaWcRtBtttggBcDtgtacNttaagcKtaHgtag
+aaaaRttgaaacatagtWRaacYggtaaatcgctYaBtWDRtgttgSctaaKatNcattg
+tgtMttatccatatagctSacgccSNaaactacgNtgtgcttMatSKtcaaBaNaaacat
+aacagaaatagtagctcNcatcVgaagStaataVcDKKttcagDHDtattctaatgaggg
+RgBMctatacaagYactctMaaagtcgctttctcgtgaattatNcgatMtttaggcBaaa
+tctNtactaaRKtgKactattgtcatatgtacgagttMaaHSSgHgBatatcgcaSaata
+aaWgaagtatagaHgcttctttatgaccWaatttaRtaDaatttaatcgaaattgattMc
+atcaWaMtaWaKactttctBacactatNgtccttaWgtctgaccKatStaKtgagtacgg
+gcgcgtYNtatttagacctctKcatgatKWStcaataactaWgMSgHtgatctttttgtc
+gacgtSacttaYgcctWctcctctacaagVtttMaBactWVaccaYtgtSgcgttattcK
+tatStgaaKaccgNaataaHtatWtYtRacggcaDaScagcagHaYWRtRNcDtHtcVWt
+ggaataaaYttgVaNtgttagtYttgtagSaaatDgaggccDcgBRYStattatttaagg
+ccgHgggYRaaccMaagttatSttctttagcMtgcgMtgaSagaNaDagttSatgattWa
+tttagtDgcttgagtgMKaYWaYccagcaHatKctaKaDgctagacttattgattaaYtt
+atcttattattStaattWaRaYBWagYaatatgttRgScttgBagDaWgcgtgcVDaggc
+ttgtctaDRKacttgcaKBWRtaaVaSctKtacttMaaSVaWWcgSaNtttSWgtcggtc
+acttggVVtgagaataaataaDttgaaccaaaaMttaaaagaaaaaaaatcNBtatMgcc
+WagcaNgaVaNaaaaaaYaMgttaWtatHaagtNtacgacaBtMMattttWNaRtaaata
+gYaScKattacagctVKBtWNSKgYtYgtWatHaVatDaaatWgDatcctggSRagagta
+aaaMgatttRtaHacatggtaKagVcctgatgaMtaaYgatgtattattttHggBaccaD
+ctctggNNtYaatctVttgVtRtVcRacttNctttataggHSRtaRacaaattaacHaHg
+tgttgtttcBtBtatWtgtattttgcKagMcaaagaMtattagtStagcBacYaaHcagV
+gWtgtttcgtgDHaVtagDatcRaRtggtWtaactgcacgaggaaaRttSDaaVaSttaa
+aaacSMttactaNtcaacaattDtacttttYatVSacYtWtMttaattatcKtcttctat
+caKDtctStSaaacggtYccatgtgagagtWtagWKgcaBaaaaKttgNactaatcgagg
+cWtcDDaaaaaacactHattaattcactatYttaagacactaKaagRtRataaattttca
+tHggtaataaatgataHtggctaacBacDgtaatattRtYgtDNDBgKtcaggcHatttt
+gHNgWtaatttccgactactgacatVNttYYgactcgctctatttagaMcgggatHcgtt
+tatBaDSagBaaaagRttBggttaaBactVHgatgaatttattcaaaattgcacttcDga
+cttYcVttactVtttatBaKHagaWgtgaatggBtaaSggcagacNcttaDttVgMtWag
+attggVatttacHtctNcMatacttSatMagcttgtNcYaaScaYactcKctKtagScSt
+cagtttcatWaatggtgagaggHaggggcaacgcRKtaRcMaNtHaatRaRaaactVtBt
+gttaatRtWWcaaagKttccaaKaaatacgVttcacaaacgcggtgagaRaatggtgDMW
+atcWVScacaaaDaggaaHtgttSMaaaaaccYccDBtatYgtMagcSagaccaVcctcg
+gtVWaaagttatcNaagataataSaataaaKccgtaDtYttatYcttHttaagKcMctaa
+atggaatRgaaaVaaVtcKYaggatWcaBtDaggDatccttcYNtgcSMRgaRtNgaatc
+gttRttatDVMtagctttacatDVtatatatcagctaDagMtataccYgaggYaaatgDa
+aaatSgctctgatgtttVaaBcctgataKtagaaaccaKatatgttaDtgaDtatagata
+atacagtaDtatcNtgtDMtYcattRVtctataNtWttggNaSgtMgaaYctctDggHtg
+gHDccaccacKKaaacaaaatRatttccctttaagcRattMHctattHaRtataVattgg
+atcSttaaHaHgaaHNDtacattSaaggDatttcaaaYgctBcatattaaaKagtgccca
+tSctcgatRtaaaMtgWactttNMaWctYgRatDggaactcDcaattaKaactgagtatc
+tataagYaaaSRctggtacWtttccWtaYRtKHattatagWtKttaNgcDtatHacccat
+taatttataacgctMgaagtaacaacagMgtaYHYVtKMHtacMgKcaaatctgRYataN
+tcgttcaatacggWtMcaatYcBWaagYtVaDNagtatagDaaNtaaaYtttcYWttttS
+tgggataaMgatattagaaYtNctcttcBagactaYDcgtacHDWccKaHgttcttHgVg
+gVDttatcatKaMttttacWaaSattctatagaHaggKaDagBtaaagtcYccattgtYc
+atctaNgRgVtgaagtDKttatBKcggDtattRYgHccgtgcgBNMtttVRgacaYctSc
+taRacgtagagccgtacRaagtaHKagStSttttgYSatattaaaWHaaWagttDKaaNa
+NHaaHttaYcttMtcaaatgKttBtSgtccaaVaattSaacgttgNattgatatNctaWt
+VcagtactKcWacgVagggHaaRgaDaatcMttattaataacaBMaaVtgYtKgRgHact
+gtactatcBaMtVggtagKcYtHtBSaattagtaatgMcaVVagYYgWtactttccaaSt
+tDgaaMaMttcacttYtRgacttcagcttWtttagtgataMaattaagVtagaatatKat
+aagtagttaagHMRaDattaHaaVcctDtagtcVYcaataaYcNttNaaaHctcaRaatt
+tcaNRgatSHgVatagctRtcatgaBttMaaagRtcgHVtgRgStgatttgtagaKagaR
+WRctgNaHYgaaatBctgtttRttNWagaccgagKgtgcggHKVttaatattaatataat
+aDtaNcctacaaRgcaNMctctgaaSHWWHcttagtNagtWgWaaKtYaNgcBattatcc
+aaaSctRRHKaNtKcBgtgagaDRWBttactaaattSMctatatagaaYacDgatttccV
+taagRtgRataatatagtctttttatgtMgtcaacaaNtaaaaactctWtagaVaaaDta
+attatagtBStcgaatDtgattVaatMtcaDattVKWaagatagggttgtMRSgtcYgWM
+aatgNtagtcBttagtttctctWaaMtVgctWgSgtHagaSagactagKtagWggcattt
+HgttgacaaactcggggHggcWBgVgtatgggagVgagtcVcBtDctttagtctaagVWt
+HtgtttaScatacMBtKgattatRtgtttgtctttDggcHaBtRtgtaataNataattta
+taWctgaYWataStcHaatcRtaaVagDWaSatagtaccNDgaagtatacgttttacgac
+gKRtattgDctatRRattVtStaaactagatgVatttagaMaSaaaattVtatYtgttgt
+RMagtHaatttSttaaYNaggWagtgcacgaMcactgHgtgtgggHMgtKacttaaYgtc
+gcatcSatattgBaagtttacMtYagSatttatttaVtaaDtaWaHcgNatactgactHt
+ggWtataDcDScatactcStcDtgtcgtgtatgaggtHaaNKgDattgcBccaagKgtat
+gacKSMtttttgttcaaatcaaYtagtaSatgDaaaMccKNaMaatagaataagcaatta
+ttataaMgagtgaSgtctNYttattHaNaYYtcDDtaatNRgtatttaaYtaaatcactH
+VaHcStccttcccaaVatcVggatKtatgRaaDBgaYtttacttYggactSDtaBcaaNg
+gggtattatattBDcttagagYNMatBgttYaagactMatgttRgatacccgtaacacBH
+tatKacWgatRcHttaattYtKtStccaaatVDcaNKHHaaataatagtagtatcttgct
+NDggVaVVtaVaRaaagSaccgttctcMtVtgNBgtDtttctYgttactBctcRtStWtW
+DScMtcWSaRatgaataRHctaNtcStctYtWacagatgtatYBtHaHWBtacggtDcaa
+BtatcaggtcaVattaNctactgaaaatWaDgactNWtMtggagaattBaataYcMWYcg
+atMYatWtgattSatgaRtDaRgccagtSttatatRaBtattRcWtagtVgaagttMcta
+ttatatDttaggtctKtgtgtBagacgttatRKtgatctatttBtataactgataacKcg
+gagtgHgtVttcttgtKDgcDtaYatBDatcaatattgttNtaBacatcgcNcaKcaWcR
+ataWcVgtacgScaWgttcggHcMttcRccatgaRStYgNacagatacYacWWtggNaDc
+WagttHatMaNaatNtcDMDcMaKgHNatScVgatKWatatgNRgtccgYgaagattDHg
+tMtcHaSNaaattBatRagtaaatttacaagHWtKatcaagtccHtYcctgttKDMSgta
+ctactVctgacaaaaHgatatacataatKtStHgctScSatNatacaYttaaWHtctgaa
+tYtagtHtKaggccWBaStaDctaagagNtaatcaatcgttNgaYDaagtaaaaHataga
+atcgcgBaYaBgaacSaaWaaaaactccgcMttHttYgtaagaMctKBtacSagattcBa
+aWtaattttacRttatcgaRtacaRHgtgRagaaBcttaVgacVDgggaatVatagaact
+RRtacgYttNattVHgaHttacaaaaaaaYtcRWtgtgattatgccaSDtttatKWgaat
+atSNDgattttaacgtcSRtatggttcttcBtWtttMtBtMScttaHatBattHacYtaY
+acattcgttKgtcStSctcKtatatttcaKSgagcttccaacaccRDtttDaccattata
+tSgtcWtVaaagttgtagccattDtYaatattDaccatcVDaaRccagttttgtcHacMa
+ttcHgaNcatgttKcVttcctgtgcSataaatattgaKtctaWctMRaKggtaYcaagtt
+DttcgttacRtatgatggHNaWMtKttcatattaaDaSaBaaaMtMatBgKtttgHtHac
+taatcatcgtWaatKaaWcaWtcctVttaaNaggaaaagtaaagaDctNttaDBaBgata
+gMgaataacRcYggatcRaaaHaagatRDtVRactaYagttcaccaaWtctcSSaaatcS
+KattctggDgaacagDtaDagacagtgtaattcaStYttNaStgtaHgccttaScatMRc
+accWtcatttatRtaagatWtNataaWtMNtDVgWttgcWgtgaRttttRgWcttMtcta
+HacaaYtKctgaBagtRagacttDatNttaaaDgRtatNcHatcSDgtBatcttacVcYa
+cNgaattaacgagttgYgacttDattatacBattMgctagcctagatVcaactNttccta
+atgtDaacgYaNatagMatSWtYBaaaRtgMtatSRgaataYaScaVgtaScMagatNNt
+ttacaaHBaWtNtRtctaaacDaaaaWMcaNtcVaDNcagaDtgcWKYgagttaHtgcDY
+ataaacataBaWWtcggtatgtgaaScaacctttRNatcgttaaagcaDctaatgcBatt
+tacaattVaMgSMMtccYaaaBYtggattttcataWttgBtatDtBgactaatgtccWaa
+HataaScHttWttDtcgtcaagMctMDtaaaatRtBaaaacaatgtcagcatBgNNBVtt
+ttttcBacWtttWtSWWtgaaaaSacgBtaaataaagtcDStaagaactgttaatYatgD
+ctattactgaHtaaatStHaagacaKtagDtaaHaDgttccaaDtaaggacactctDggc
+gtDagtcWaHgRcHgDgaSctttattgtcttttccttRYaDgNactaaatcaWggcNSBa
+gttttatatStKgtcRtgattaaggtcaSBttaacaaKatgggatcaaattgRgcBagtN
+tcgDcatttWcctttgtNagDgctgcatttactttgtgtcaBgSatttNHaMcggcagSc
+tcKDtWBaagSagWatggYtVatSRgKagattgaVatKttcgatYatKYSgDaacNtcVg
+tttaWataWtgVctgcgSggMgatccatgagttgtWcatYWWcctVcNHagtNtgtKttt
+gatcaacttaSttattgatNcatWaVgNHcagStVHcggHacaaDttgDttWcaaRaKga
+aatKaattagtaWacattgaaatgtgaatgacagtgaRVtaaYagYtcggcatMttgaag
+gDgagDRcaKgHtacacaaaMcaBtagHactgKaatRtNttcttcatcatNgYgStggac
+tatgSMttgKtDaDgacRRgtWaVattgatttaagYctatatagactaagaggtatWtat
+aaactaYaHRctStgKWcgtRtKtYtYtagacgattRaaYBtaStcttaWataatcHtta
+taRcactgagtgggagccaattctcDtgDaggHcDRVaVVggaaBtRttaataaRRttgt
+aagKNcaVWWgtatacctgatcttBtcttRgaWcaVRKcagttSacttagcgtKtgtYWa
+tatcgNttcKaccacacVKctgattBtggacgtctgacaDtWKttattttgMBgKaacaD
+ataattWtBtBRtVtacataaatatttgtWtttatagtDtgcctagctHYaatgcaNaaR
+caatVtacctgggggKtagBgagaBgRaaNttttMtMagMtgtgattNctcNaKggWtMa
+tcttagWgtaatatatNctaYBggKaataBattYtaattataVtggNtcgtgtctaatta
+aacctHtacaaactDctDtctgatatgMtgataacWctgtgYSaaNScgDYaWtatDatM
+KgcaatttctgNcgtHtaWtagatatcYBttaattactcaaaVattYRWtatttDtaNMY
+MttgattataatgcgNggWaatYagttgBagNcaagaaaDtRgtaaaagctgcatctagc
+ttaVgtBttatagcKMSaattYtHcMaBttcagtcttgKatgVSVttKgttttttagtgt
+DHgNggtcaVtatttaacNtgaatatgctatMcatgaaaBtgBSaWctaataaattatYt
+tagtaDtaccggaatgagtaattggatttaacBtctSMgWYtgKgattacgRctctccaa
+tgtaggcctgaNaatScgYataaBBacaKtHtttcatgaaHtgBtagaKHVtacctVtca
+accaDaaWNHNaatgataattgatgWcagggtcMBtgSgRataHctMctgMHHtKaBtaa
+MtMgataaRWtagYtgaaMaSgctYtgcgaaHatDtatgtcWRatKatatYDcBgNtRaR
+acattMcagaHgaaagRccgcgWttggSatBagagcHgYtatctVtcatYaaVRtcaSac
+aMYDcgRtcaaWgaRgataMtaaaacaggtgtaaYcattgWgDHcWgttaVatttgcatc
+taatccacaaagaagSatgcgtagRgagtHDgaVcgtgcttatggMttttcatKSctNac
+HcctMaKRatttgatctaaatgHaaScataataatgtttgtgtHaVcaaaaNHaaaatcg
+ctgSVtattVttagaaNWcacagtgKtatgattHcYcttgDaWVataBatBttttWtaac
+tNaattttctttaaYHaMtttaaaccgStcHaVBaatcRacaaWactgtagVKtNRtcct
+agcWaatNgctKccttctcDaBDcatYHatatgcaataaBaagaatgDMttaHcaaYYtc
+actgttRtgacRaacctaWtBtBMagBctaaBaWtgatgVtttattataggttaattgta
+atYcaRtVctcttgcacSaaMaatactRSgcataKcagcaVNKttcgSatcaaactaatt
+DtaHtNaVtgttttttaWVtatNccagWttcgtatBcgttVctcBttaaaaMSaDattKR
+cctttcataHaattaatWaaataKcaHVaggaatataBYKHVtgVcVgtcHcttccgcct
+attDtMMgWaacttgWttYtttcMcgtcctaaVHtgWtggtgacKtcaWaYMttacttag
+VWtacgSatatcgWcKaaatHKaaaYttgtagtcaacWtttggtcaagttgaaBBaSHac
+VcgYgttWBSRWggtattttaYDtHatattcgatNttacaaaaVacaMccaaYStaataR
+ttVtcttagaVKaacaWcgccgtRatcatctaaatccMcctttaMggccHgYcDgaKcta
+tgMRYBagcaNDtgMtcRttgtgHaRttacatgaWcDtgctgtataggNggtgaatagBg
+agYNtatcagKtHcatBatgVKgaHWagattRDatatcgYcHagRtaatgWtcStagcVa
+tNaaaaKttgRaRBYNgtaaDtStaVRgcMccatMWaaattBDatttaatttataaHtag
+tVVaDRMKBtaacaatttttttDaRSgaaKDtVaBatcagtaaMttaagcctRgaNVggg
+ttcataatagNatcctacactacgcatgtcggaYgtaKcatggattgactttHtaattWN
+RaaWYggttcaaaggaaNtaatgcHcaaaattBtagcttattcaagVtatttWgcctaKt
+atBttDYcattagDacKVaYNccgYaYRaaMaattRaagaHtatgcttgcRagcgctSaa
+tagaaRacaRacSccagcacVMataatHgRtagcgaKgYRaDcVWSDVgRaMgcDgtaat
+tttaYttggtaaWcttKDaaYtatMRcgKccYcagtYcBgRccattcaKtgaSSRtactg
+acgHtgtaaaaBatWgcaMcBcYcgccagactcttcSatYattgatgaNccaaaaWaKat
+VgcaggtWtBcgttaRMagcaaagtgttcacatataaagaHWtKatctacttatatcacY
+RaaVagataagtaattttgatgtBctaataggtaRtaaHaattgtaRcStYSYaWRgMta
+caHcNSttVNScattNKaaKgBtagtgatYcaaaStactggttggggaBggtNtgtcaaW
+BaYVSNgtaataBNtagtatatcacMcScccVcgtVRRtttNcKaSRNaNtHRttattta
+ttgacaatggSaBagataaccgttcctaDNaattgctVtatNtHtatagSccaagctKtt
+aaacaaattattgtSHgMWgStttNaccattBMYatRtccStNgttgaaBcctVagcaaa
+atgatattcRaBccMWaagKtttttcMtgaRYNaataDttgttWRttattggHtNtataa
+tggttgtStYgaMcYVtcattaggtaatVcaNggaRtNataMWcctcYgcgagagRgcHM
+gcWtgaYtVSttgDaacgaaaatMttYWtWttcctgaKNttatttattRaattaagaccM
+KtttcWgtcaBagKSaWaaacaNtaYaDtBNaaagWtHgacaaagtgVtcatKcgcaatV
+aactatgcgaaactccNctatatMgactatttatSaaVttNttRttagHtccKtHtaaaN
+atttYVctaatttaaaatHWaNtSacgaaaHggaaatcacagVYcctaattcMNtgtYtg
+agttatttaBtcRgBHNacBtactctagaacgcKaaDWYYgcattactVagaYtgaVVcg
+caNctttBagKRcSgaaatttgtatccattgtggHcaatRtaVtaSaBtcYYcatcgtgt
+cHaVttaHattctgtcaBSNYaKBBattaatggctgtHatattgtBacDcBgatttaaaN
+tggaaaaYtNcaKagRRtRgttRtMtWgggatcNtacacctgtWKagatataaYVMtaaD
+taaacctctgtgtgccttScacWaggaYacttttKacgtttgtgataKYagaYaVatcWc
+SattaMcatBYttYaaatgStKagWattKtttaWgtagaaSgtRattcSaDagVaMatta
+ttYaagccSgcNaaDgaaSaggtaNgtWactaWcgHctgaNatttttcaatgtaMHSWaR
+tggtaNtaHBtttWWaaatattcVtBtctStWtaWMaBcatttcDagttDtttatatgtt
+WBtNaYatcccSgtgagcgaRYtBtagaDacBtaagaataWactaaaagKtaKaWaataa
+cKcccgDtagccaaagcggaatcgctSRtacKgcactacccHaactMgtgccaBaRaaaB
+VtcgSacRKtttStgatcaaHgKtaaKaccHaccacccKttgagcttcSttttKKcgacB
+gggtYMaatcBStcgDBtMcataWtaWaMtgaataagaaDatccSYDtgBatgactBaVt
+aagatctcNMgtcaWKtgcWggcgatacgtgtttatttWaDaNWBNaaNtNttcaaatag
+taatScgHtMWttgttgaBaDtgNatSaagtttHttaNaNKaattKatttgatcgtVcat
+gaatatBtttctaacKaNttVttSagccatRtatatcactcHHatctWSKttaMacaaDa
+ttccaRaYttttagttaatattcctYaacVactgctMcgagcaMYtttgaagctagtKgN
+WttgaaaMatcaMcttcSVatcaatgtNactaaBagatagagtDMgtNtNWatttSaHac
+tagaaaDggtaaaaNctMaatagtaHgacgMaaacMtacatHtaSagaHatYDccagtBt
+gaWatcYtVaagataattgatcgacctgcaacgttttattacNMWNcattataDVDacta
+tattatYattttgcgaagtgagYVtagYaWaHaatctgWttttatgcHaacgttaccDaK
+tatagaccaDDttaacgtHBaacatccgtYaBtVtNccaaataaaatVactDttSKtcMt
+DSgaagctaMtatattgattactgtNaagNBcagHaDattaaaWttacacaaatactcaa
+tSDatagctcaDttWactttgaStaaDtagatSaaDtgtaatKtgVataggaagWSaaaa
+KatttaaagtttgcgtaaagcccggNWaacatacatgttctaRcaHttVtcattatctag
+ttttNcataaacDttWaagVtNYtaggctttggtatgagaWgtactNaVatcactVttBK
+cttaaccttcMtatcggtaataYaMaYggttgtcaaagSWHctaRMSatVcggactMata
+tccgaatcttttttcgagtccagtttgaMtcgcatcaaKagtattRMaaaKDBttDNcca
+tttttaaBNtVtccgtaatgaKgtcagMVSattatttaWaattttaHNcaaMaHttgtgg
+ctattctacDtgaagattatcgacaaVRHttcSaSaatactNHWaaNcgtWaWgaccgRS
+ttNtHtcttcKatYatatBaagtcgctBtgagccatatScctKaagaaKDaWactWagBg
+ctgattBagKtgaaataBaaaaagSacScaaagagtagcgaDaYtaMcaYcKtaataMat
+ttttaactttgYgtcgaaggacgcHctBcgYgaaVacRYagagBaaYgtagattgcgagt
+caagtStDagatBgtgaccctaSWtctDgactaSHttctWatWttctaWtatctYacact
+gBWatKKctgtatYgacaaHSatYSaNgSagtatagatgagtatttatgaccMaatgtaH
+tStaWttgYagccaWattcagtBaYtaaNaBtaNatactggcttWcaagatDctacggaN
+ctatcacatSgKgattgacgacccccgagtNDtattgagaaatattaatcVttNKtaaWt
+YacgSNcBHgttgWtatgtttcgccaactKaattaRgacgNataatctacaacKgttBat
+YatNMSaaaNtctKgacttatgcttatKtcaVtVcagDaataattYgNtRtHaagcaata
+HcacaVgtaNNHtHDatgttaMNtggWagSVaRttcMVDtcttWgtRttctacKaaVttc
+VcgcatcctHRKtattSgttSacgaagtcccRDVaacBWagtgYtKtgattgSgaBtgcc
+BtcaKacaDatacttHatcattNatttacgtcagtgaggcBtaRNaRcaSgcatattatS
+tatgctYcacgtattcattaaRtgStcttWgtattKtSYttNaHaRtNYcRaYtVtggtD
+cKcttctactaMcacggcMtacgcttctatatHtaatggcattMDtaaMaKattgaagtB
+aaKMVMNacKaDtttKNcgagctaaagtccMMtgagaagVaataatggcaWaaaaVaBgt
+aSaVgaaaSaaaataDttVtBccaNagcSBgaMaDaVaVYYRVBgttYMtagtaactDta
+agWaattBtattttMDYHtSaStScRaKatattacacctMttgNBKtcRtRggNagtYMa
+ttaaatMctYgaatgcKHagSggaaaaBcaggtHtatWcatcgtStagMcctcatgatta
+WRcStcgWtgRgttttcctaacatcgctcgDDtRaatatMgtcMtHtMaDYatgDattta
+tagctKDtYHaaaaattaSatatctggtctttattttatMtgtYttgtcatactcaaVcY
+BgatgSctKtYcctWaRaataWcMgNgcgggagtcttRMgactataHaHtgctNtVaatc
+aaccacgSRaDtgKtaaMSKgtaaaaWaKtttVagSDtaaaaaatgttYattttNagMHa
+aRtNgBttWattatatgcttatatcatttatKtKaaaagctRaaatcgcYgacgNtacNt
+ccVtSaaatttcDVctaatacWgcaMtcttSaaWaaaWagtagtaattaactagRttaVc
+SaaatataacHgHatWaattggaagtgcgSSgaaVtgYgSttccatWVataatcgaatat
+gHtRcgtBttcttaaggatatgttgtBcNtaatgtcacVatactgaaatMBttRRcRatc
+catagagggacatcgccWttagttgWttatKagtaaaagHtttccttSatVatKtgagca
+atttattaaYVattcaaattctgSattRaMtgaatMgttattattacaNcggVagcctta
+aKgccYcaaDattWtggMcttMacWttccMVgtgaattctDaBYgacttKYtBacatgct
+DcRaaKaaRaatatctttagKcKtaactttaatNaaggctgScacctYgcgcaaaccaHt
+tVHcBaDgtaatHaHVaaatMgttggtSatHtNNaaVagtgtacaataaagacgKttcaa
+aWVacagctcacWHaatcctgtBNWtaNMKcVcVSWtSgcaattctgKtVVaaacaRaat
+tgatRcgBacaKacVccVMactagcgMNaaactgataDaSgagaatVHaatVSVtccgga
+tgRgtagRatttgtaactaBataVaggcaagHgaaSMSaKgctRagcStNcatttVgcta
+tacttcNDtcaKBDcaHtDcaatagttHttattMBgagctgtaaagtMgatStStcagat
+atYcBtataacRcaggRaaaggtaWSatKgatatgagcgtgMYatcagcatVttSgaaaa
+aatatatgttYttcattatacataatVcacgattataDggttBtRaagtHMtatagaDgN
+ttggDaKctBcaaRcgattcgtgccttacaaaWattYWVcaaWagDattgaaagggaaga
+HattBtatVggtaHtWtaMagtccagaKttSatatcaStDtgWaagtKWaggtatttaWa
+aRcattaatStgaaVtacggaacatKctacatHtaaaBtcNWatttBBaNatRcDattcg
+aactataaattataactcagtSgatataagRaYaKHctggtaaNtttaaNgaRHtttatt
+atacNttttaDccttYgtaaacaggaagtgataaacatBgaSgtaaaaaaVcBgtWNtRM
+ttBttaaBgtaaaatatcHNStaBtaggtaVatYaccNtBaWagRctNSacRtMatDact
+StVctaaDtaYSRgttaRNttttKggccagaaBcatagtYcaYNtDatcgtatVcaatWR
+taggaattMcatRtgggatgtcMggMtttataagtaBgtggacNaaKYtgctWgagYtWc
+ctWtVcttaaactaRacatggtRcatctSDcHcMgcaactttttagttaccttattHRgt
+acggcactDBggtMHcVaaRatKctSHacctacaccactaaHaacgSttagKtKttttgN
+HVgagtaYaMtVYNVcggttaSBaBtaatttSRcgtBgaWaatctttttKggacaWKaat
+tKSaccttgDRgtcatatDatVMtMaVcgaattaNaagMWccctaaHgataatatgtatt
+WataaaatBaaMtgRttcHctaagctaagatatattMcggactaRttttKaSttactWYt
+gBcaMMacRRgNtactttaaaSKtttcaYBaBttaVagtRtHcWaggaVccttNgtgagt
+catataWttYScMtWgVRgattWtaSggacggWWctBHatattataaKaagttactaMRa
+aataSRaDttDaaatataVHaatggaaBDgWgHtcKStVcatHtaatcatggBWaagHta
+gtMtgHcHtcatggggWcatacaHNHagcDatRcaaattcgcttgDggDNVcaacgSgtg
+gcaccttMttaatattVYtVgaagRttaBcagVaYaHcaRDBagatgaVHtNMtcttact
+DaggMgMaattRWDcctVtgagaaaaSKatHHttVDgtctgtcacatHNttgaatSaagt
+KBatatagacaaRVctcWtgtacKtaacHtgHataSgVtactaggtttatggBgtcaaaY
+aDgaaaaaatcgMtagaKaYatgaattatYcttKtacaatttgWttMaatBgaatSttMt
+NaVgVtScgcttctBHKgtaRcNBaatcDtacgattgacgtgctatNaaBtMgagNgKct
+tWcWKacactYgttVgNcgaattttcttgaaaaactacccctcgcNtgMctatcccacMc
+actcMatttatttagtagaacMNtttcttgYKaWtaaBtttcWttagHtgtttctcttgt
+ggctatgDgctaatWDataatttagaNcgcRRNataKtctaataHgaaMYctNaKWtact
+aacDtgaVcgagaactggtaccaactHgaggctagagHHagtMgKtaaactacaggMatg
+tYgSBaKaaaattMgatRtggggtHBVgttaattgKttaaRDacgMactcaaacStaaag
+ctctgtgccttcgtSagtSaRctacaataKatattctaVgtgtaattRacKagttattga
+MtaatgaNatacDataaggactttccNtStatatKaagaataKtatggtcctctatgagg
+ttaaDtgtattgataaaactggatcactKBtttggcgtcaaagaaaNtagtWKatctaaW
+BactDaBaYtacaWtaSgcaattattWgaaBgactgaKctatBRgtagttaBaRRgattt
+aagBHctStgtVYRtaaataaagtMWtcHgcattcacaaMWtcMccWttgVgcHaWttca
+NtgtVaggNgcVatKttataaWDcccctatgatVttttattacagRBBWttcttRaWgaa
+tBVgcgtHgWgaccagtYacaattgSttaaMcVtDatttaVttRgttKtcaYWatKtaaD
+tttWaYtaatYctSctatagtcctBtccMaMMtaMYHaSSgKaaacttctcBtMtgDtgt
+ttttagRcgtacttataHgKtNtMtKcBtaNKaHStgSagYHtataDtcKtagRtNWaac
+VgctVtRtttStNtgaaccttaVatgagaaggtcaKSttaDataagcYaSatNStcaatD
+NgttcgacaatttaSgaRaBNNacattRatNtgSttHVtgWHgtSHccaactKttYtatH
+YttVtgHcNgactMcaacttBatatgSgattttacgtatttgtggtScaacggYtHtgca
+tctatttttWtaSatcagaYatcgcagtgtgtMgtattctttcattaRatttStcaatat
+gcttDtStaaagaccDcVtaWNcHYtWMaMcgaacKcaNcttacctaBtgcDacatcaHK
+tRcDaaacataaRacNNtccDataNactttatBSDYatDtctBtaBatctDatKaMcatt
+MatatcDHctaagRgYVcatgttcgtgataHDYaagttSgHYctaaatgtaaaactNgta
+gaaactaattRaatcttttBKcgaatSctMaggVaVaaatgagataaataSgttKgtcat
+KaKatDYtaaaRttYaMtgctcSatRtagttttagcaaNtaKgatcgWYcacDgaatcaa
+tactgBgaNtaactaaWatatacaatacactaNatcaVaKaaMaaaaaatcaccBtgttg
+NctaacaBattttaaKWcaggataWMtaattgtaaHtgVtcgaHtScaHtctcHacVata
+gtaMcaaKtcccSagMYtWcaaatHHtaagRttDagtMtcYtttaaWWaaaVaRtcHNtc
+tcSttagcacaKttgtagtNgWYtatKDtcatttgaacctcKHtatccttattcttNggt
+BgtgtKaggWtYgtStgtVaRtaRaaagtagtgtcgcKtKagatgagYtttaatKcScct
+gaaaaaRaaHtttttaaaVgtatagKctaNtKaSVgttcgagacattttRSatagttSac
+ataMtaYHccacttttctatactagtatgaBaagctttaMtgaatgtcaKYtaaatatgg
+attataNcgBHatcctaRaaactgttgacttYaHtStcatcctDaMBttgtaWgagtaat
+WKataaaBgBattcttttctttaatWStaatacgNaagtWaMaaNgactMtgaaDaggaa
+aSctaSSgatatDttattatcatagBcaataVcHcRgcStaHaaatWagatHttMHacta
+RacttaYaaaaNtataHKVaataKtatgatcgtcVaaWgttYtVcaaYggctRWttaaKt
+RttDaKtgtatcaattWKaatBHaaaaNgaatggStHgVVgatMgBYtaRNgBDttMcNt
+ggaNgtcaHtgttDcNaggBtatYtacVaNttctcWtactHYcSctgtYtDtgWaatcHg
+atDatatcHtcttatattaaKaRYaDgaatgSYcgactgcRgaagttagtStYatYtttc
+cgacactacagKcaaagDttaatVatcttaaacRaDatRcBatKNtNtaaaHtcBgatKH
+cWStSRaKaSMgtaKaBacWgDDttgYaaYttaNtDgHtatSaSataaaaMBaaDtaMat
+DaagWtggaMtRcacttatggctNataaaaatatWNMtacctatgtcaYKaRacagttHD
+agccgtaaYcaatataatcatagggaaSatgMYBcKBBtaaRVRatRtccVtgtgaagVN
+ttcttagtgtcWataVggtaaNaatVgVaKctttNgtttagtaaagBatBtgaYSagHtt
+SYaacaStcgcagaSttcDBtKtttggtctacNttgNgKNNtcaaaaKWactgaaYgaYa
+ctatHtaWcaactgttSatNVtgtctSttYctgattVaatKgtaYcaaattSgttaStat
+ggtccaatgSWccaaactattgccgttacgcNatcHctctcaKatgtagtctattttaag
+gHRatcDaagSaVgaVNccaBKtacgtttStagKgtctaHtcattaYcctaVKtttaYaa
+atYtccgataaaVttcDgatWcgBtcctaatttNaattgctDYgtgatcaatttaagggc
+tctcatcKattgBtaBagcaYcKctctttNtaacHacNStggRtMatHHgtacatgcaMa
+gtgtccatRWttRKctaaaDtcMctttaNVgaNtcMatcacHcctgWtaaStcacgtctN
+aagRNNaagMaDtactDgctttttcatcYacttaKttatgcStDaStNaMgDtaacKtMt
+acctaaWattggtttNaaVHatgaaattaattacgVNaaWtggaWatctgVatcacYctc
+VHMtVaNacNtcccaWtttgcaacctcWctHaatcttWcaaaYaBaattSctYatctaag
+DgBttagtaSgaWtBcRcKtccYatatcKBgtctttatgaaHDcgNaMatggatgtWagR
+ctStagagaagaacagctWtNtataaaataRatHatKgctNactHgttRgRgVcRacatg
+HYaNttaHtattaNStaagatgtagaHcVctcYgggccYcaaaatgatcttctagctctH
+MaMMgcaVtgHgtaagaWHHtggtaactBcaMNNctagaacggWtctttgaggHcYNaaM
+HtaYcttKaagtSccgttgggNMStatacDttataaaVaYcKtcgcattttcgacctctc
+acVttNtttattgtcttctaVcatagaattMttgtHtMgacataaatagttctMtgtWgW
+ctttcaagYgcgtNaagcaaDaVHaaStMtaaagccccgtgVgtcacatcHVaDtgttBt
+BacBtcggYttDagaDYtccMttagcttacNcgaagatRtDataRtgctaatatatgRtW
+VttatWKtgcBgactcgagaSgtaaaaagttaaWaaagtatttctcWtatcBtcataacN
+cgctcRKaaDKactRaNtagtatBtgaaatttcgcDactttaNtYgagagaNttgaatta
+ataaaSMattRHNtYtgttgaDBRBttgWttagSatgacDggNVagRWcggctacDaYSg
+aaattHgtYaaagctccVtatacattaMctttgSgacatBKaattRgtaBRtttaactat
+tctagcMKMtttctgtgtgVgtctttcDcgtaaMtaggtaaaDtcaYtatccgattcYtg
+aaRttctKaNctaYgYaattYgRttWctWttaaaccaatcactVatgcgYttgaaatgat
+KBcNRgctcatgaccHagcgaaaatgtVgccatcaBSatKccRStSattaaatttggtaa
+gcVattctgVcattMtacatMgaaaaaataYNDtDaatcatWattcaggNcaccctcBtg
+cKcHagYtatBatgBttgtVttaYBgBgataaHNtacRtcaaBaKcagNtcagaatYgtt
+WgggaNDagtatagRtctcDtDaHScagttcYcatcSYacHcagagNgtgcHagtacagc
+tgRtatatMtaatRaWMHgaaKacaBRtagHtaaaNcVHcatWBgWaaacWccggtaaRc
+attgMgttaNgttVMVttgcaagagaatcaaaaaagYScKVtgccgacHgacgttcaMcc
+tcattatgcBttttaagtKatDactccgBatHYgttcatcgaaatctSaKaagaatWVtc
+gttgtcttaMaaYaSDtaaaataccgcKMtatgKtgScaaDMaaaactgtgagcVtttaR
+cttgtaNMatatatttggtMgYVatDaatttgctttaaRtaBgttaYaaagKtataMtWS
+tcHaaaaNacgctacMttDDgactacaNaatBcagtcattatatSttaVgRtWgSggcaa
+tSataVgSYgctBttataaYRRgaactgtgHtgacHWSactYNgtttBactatWStaNtc
+StcMttgattStacctgaattctWatNaaHgMatattcaaaKWaBaataatHKgaWgata
+YcaWMBtgtacKagaaaaagaattttWttDaMtggttgtgaNMtVtDcaacNttactatt
+acggKctatttaaaaBKatagttHaatggaatatYWgtaVtNaaYgataatMaccWagag
+atRttMtgKaMcgatattaacaagatgttBBcNaYattcNgtRttgaBcctaagaSMttc
+MtcctcYattcaNaRBttaatgVcMNgaacKagatcgNctaWVgttaaYRtgctSctaaa
+aNtttgctaaScttcVattaHtaaMacNgttNtKHMcctattttaRtttVtSgtacatBg
+tVaaSSaMVaRBcaSaRHtaWtWHttMtattVcaMtWaaaNaccccgHYtcatagaaRta
+aBaatttaBccaatcRctcatagWgcBHRtacaaDttcBgaHggcgctaHtgacagcSNa
+ttcctcgagaccBggtcaagWctgVcRDgVtaagtttaattatcMtgatNagYttHtYta
+gccRatagDtaatcNtaKtacaMSgDaaaatttgHaHtRDgtaattKtaMHgaBcaWtBN
+YaWgtttStttaSttgataatgactMKatHBtttaVcYatgggttttaDKcSatttMata
+tcagtYaBtgVacaatHcaDMcccgtaataatagDataatVaaagaagaVtctccgaRgt
+RtaatcgagtcacttgttSatgNDHaSNRcggtaSaagcSaBgWSgcatcaaWatgttac
+atgattcWacMtagtgNcacgatgatttttRcWttSgtaatMRRBaacNWRHaaBaattD
+aagStgatccttcaDacccctKaagScSSHaaYHWcHcaWcaaaMBataattgDtagccW
+tcRHataMNKtMgHaBcatcgaagtgtaRgtgggaVMatgttaWRtStBHactaaRaact
+NctcHaaaggcatgcVHKHgaatcSccttggSaWatWtNcaaBctaRagaaacacgcttc
+KatRattcWtgYDaaaaaaNatWtKgaacgtNttactgWHBaccaWacggttcaaVgaga
+aacVtMttatagaagtatWtaaaNHYaMacagWagtaatttgcatcttcgaatacggaHt
+aatVattctaDaHtRKRaNHcttacatcDKttMDKaWggDtaatcttYctcWtRaaaaKt
+aatcctgccccatgcgDtctaaVMtWRKKDctaatatDgactagWtaaaBcKcacMactM
+HHttgDataKHDaDttHttatttagtcaaVatccKWtacWtSVcaggtaatatDSatgcc
+tKtatDtttagacKaaaagcgtttaaSaaaYtgattgtKtgBMcKttgDaaaagttBRat
+HgcaKgDgtgcWataatMWgcVaVatcYgWttaDatcatNaVgtttgggcttgaHRDaWg
+atttctgMHgtVtgccttBtWtaatcgttcgKgRcaBaRMtaattWgctaatMaVBccaH
+tDagaBNaataRcacYcYcHcatBgaNtgaNgKHttctYaacaaaYgBttRNtNggaagc
+WtDggattgagtHaWttVacaaaBtgttaNctaatactKaMaaaaaDtaRatttDaaagN
+ttcYcaaactcMgaYgtacaaatMaaatYtcacVaacgaaDagatWgBgaataggtWtKa
+aMtgDttHtgagttaatttgVaaDagttNMataatttaSVattNaDtKVccaaatcgaYV
+taaaacKRaataatgaBDtctRtgVcttatttYtgaHgttBWatgaatatacSaacctSa
+tNNRccagtactKagaRtgSKMcgaaDattttagtHcKcaaagtggtataaaggctccta
+SatHtaMtRKattaNRcWtccgctataKggatWttaggtaatHDRatttattRWgcgatc
+ttagSgtcttactatgYgttYaVBtgcaYaaRtDaatacHHtDcttHgBgNcccataDta
+aaaatctNtacatatWaRMBgaattaaaacgctctctcaagtKcacNacgVRVcttttta
+acttgctcStatRScaRaMataNaKagtatcattRttNaVatcKgtacNatttttgaNcg
+acaaKctHWtgaKStacMaBatgWttNSacaaKcaDaatcWaKaccgYBggMScgaMcct
+agcaDatgtttcVatgtRBtKNWHtcctWDtatttttNNSaatattcMttgatKgNgaNB
+atcSggtctRcttttttatatggtNttDYNYgaaaKctcacacYHRgttacatacttYac
+aataNaagaaaagttataNaataSatacagttScacVaScaccSWtccagKHtaatcaaa
+tVacatWacgBctccaataHaaYtMtacKacHttttKtcataWWtgtgaatWaataaaaa
+catttcaccttaHtttgttccaatcccgRBaWgatKgagtttBaVgaNtaNVBgcaataa
+gaatagcaKRttgtatcaattaMtaacatataDBgtaaNttcaNcgagatYactggttat
+gtNVtaBNtDaaDtDttaSaWtactaVtHactttNttcttcatWttcDatKaacgtttgg
+VDaDtVagttatgtcagactKaatcaYtSgttttataaataDttKttKagacWgHgatat
+aaatcttagatNKtttWtWaaatattacSHaRgtttScttaatWttacgRRaaMactcat
+BacaccatRtttgaacctacttcDMggcVaSBagaatcttaKMagcaVtctDVataWtSg
+atagacttBctDtBNWgtgKatWctYgaaStccgVaaaDattYatagtatcaacBaWYct
+gaaatttaKVgYtStNtcaVggtggaNYgaRtMaacataSttcagacVactcaVaagtgg
+tattaaDBNDaagtatatMtactatatgatRSgtttgccaacgcacRMtacRYNataaga
+tcMgttgatcataaacttVcatatgWtacaaaWttggaaactttaScataactRattMtD
+acVYataaaagMaattttKtgaBttKcaacatattVtagtcatgactcgDaacDtaWcta
+tRttSSYNtgWaScaaataagaaatKtagacataatggNaatttcSKtVWtgacagKWat
+tcgVatttcKWgagcaWgNKaaaatatgtaaacgttcactaaWgacaccBNaacagaaSt
+ctgctaHcVtttMtcYttStagYcgtttBcRtaYacttgNaacMtDRtagcatgtgcgag
+cScaMgtaatBaKataactMttttattaRcattattatacgtaagSNatVRgcttcgaVa
+acHNtctaHBKYgKaccYcttagagcccaVgatttgttagactaaacgtgcaBgccaWga
+VataggattDBWaattttgtBacWtttttaatDtMgaactaagcVtctcagBMKatgatt
+gaNaVttggatDaSaBatttcgccatatgctaattgYacatgatccacaaMHtttcKYKa
+WtYcgDtNaaDccgNaNcacacHKttDtttaggctagRVtYgtaactagctttcacaaat
+YtHaattYacaattaMSagMactcctcatgtScttcaaYtataaaaScHYaKcaYacact
+VcacataNtaBcaRatgYagVBatttgtaactttgRggacaagcVacctattacRcaaMa
+cHRagagtaVNctacagtgagacgaaaggKttacattgggacaataKNtattcaagWKtt
+gatNagNtgctaNgagatNacSatctNatttatctatRgaaaatKatNKSBcKactatac
+StcagtaggtVtcaaaBYYgctattKtWNttcRacaaaNatgaacttaRtaaDSttVBYt
+aatccagtNaaacRttagaaccRBatataWaatKctcattcSacWaacaacactDttVtt
+gacYaagagtaSgcMttBttaVNgRVagKDcttcttcNtaggttgcgacYacttaaggVH
+caagDagaagataaVaatctgtatRatDtKaaSDgattcaattYtcatgYgtgaVMtMaa
+ctaagaatgRgDtHttaaccaatStaaaaMctVDDtgttatcttaBBgccNacKMaHggc
+BMttctgNctHggagaataYMgtaMccaataattHttYttKggtKaccaactcccHtMSa
+atNactcRtttcatgcKcatgcacttcatSaatatactttVtaYttDattgWcctcactc
+YccattaDDaHaaKcaatSttagKtWtcatRcaactattaattYaDggKtagtNcgSgtt
+tKRgtDWtVHtDNcHWNtKtccgtctagtatSctaBcacgcaBtaacatgagatVtttaa
+ggcaVttBttaStWtattgYaggtSatBMBDactVtggttDagacataaactactBgcac
+aacMaagaStccaWNaaSYMYtgtaKaMcYSaHaaaatatttMgtcaaDScaKtcaBVta
+MVMRRDMtcttRBgWctaacttgaacNaatgttWgtggBtRttHVKgKcHVtatattSaa
+aatBttcBtttcDgHccBagtRBRttaVagBctRcaagcattacKccaWVWtaVcggtta
+tNaSgccgKtYcBaagcWgcatgaNHaKtagNgcHcgtgtcataaaatagagacttgHYa
+tattctaBgtttatRatctatttagacattttNtWaaSagtaHatRtctcggatttatgt
+gatBtctRggggcatWctaSVMaRtcatgKattgRcatMaHaataNcBcDcaggcactat
+tHBgaatStatattcatBgMVataaSacVacKHatggttaaBKtgtaSaWMattttMacK
+tgaaWaaWgctgRatgtgDacBtSaHtDgtgtMVttagatgattagagaSttgattgtSa
+aacagHaaatacaRcaccBtaaDtcaMtKaaStttatKagaataaNcaaBtattKaVNaW
+aNactagtYattaaagWgHttaMcKaSagatSactctatMSagtggaYctcacKKgaSMg
+cRgKtgccagNMataatccaVgatcttHagttttcttaaccataggggcttaDtYatcga
+aaMataagcaaatBttgHHcHagacagagaggcacWtacccMttacgtgNttattYctVa
+aactgttaagtKatMagttcacaaagggatgaVNMatgcaSattatcKagtHaBtgaagB
+cggagtWttVaaDaccMScactgVatccaRaSatattNtgcBatgBaaNgtcaBMgggaa
+tgagtatRgaatgtNttacaggcttaHaataaHSagatagtgVctattaaagggaagDWV
+ccatcKaaaatRccccaSVaaatttMtatStgtWagtStMaaatBctgcctKWgttDDaS
+KactctaaVRtaSWcVactggaaaaNMaaaccgcacNtaVgaagcttDNgaDBtaMaMKN
+tKccaVtgctcttMMYaaaaHaattcWgHcgtacatWaMaaKtaataccgBDaYRaggat
+atSKcScYagMtaatKHMtaaccatgHgtagDaggtgtaaatatagaKVgccRYctcRaK
+BKWtgatHYcaHgBaYtttMcatataatgaDttcatttaStgtcVSgacggtggVgtBtg
+acatgtaaSgtBgatKtKtaYcatVtNattataaaHaSccHaaagctSMKattcatagca
+cagtgBRataacaatMttKcWaaaaatagStcggRttaattatWaataatMaYagatgVt
+atccttttHaScgtBgagWcatgBtgcctatcgtaaWHacagtactgaattaaaaaNatt
+RNMaSSNSctattcaaagccVVcatattttagMcgtattNtVBactacScattgKVtata
+aKtttgNaWcttNacctagtgaNaaDcagtaWgKggaaKtacgcaaaYttatacSttgYa
+YttcDNagggttVDagHatSgtacYVatataVattataSataacgKgatVtVacHYRWtt
+atcctaaDtgtaaDgRDttttattWtaaDttggatcattNgtVaaaVggaaggcYgSWaa
+attcWHcgaSaVWaMatctMDtHBgttttaatctaWaagatatDKtVttaccgaMatRaa
+aBttaNagHatDHWcDtBVttaatKtMataYttSRHHcgtaHDtggttccaaagRRtaWt
+VctRcaNDttatacgatMcaatNHtacgaattBaatHtcccatctctccBtgtataYcta
+tgtcgaaDYWtNggatNcacRtMaatNtKcttSYSctaDaaaggctDaStatKtataBgc
+VaatttggYcttaaatgatgtHctaaccaactttgggttcMaaDattatKtVacgVcSca
+actSataSccHttYctttgtggcDtMcactaNSBtMRBMaggttWKtattaatgtKHact
+tcaMVatctgttgtccaaYNtaagttKaacttctHcgcWtYttatMBgBaMacaattaDa
+actNaaatSatcVtSSgatctatgNatSYaattRatgcDgtctataagagaagRgatatt
+tcccaataHgttttWKtgaagNRtctaaBtWcHHcDgaattgaaaKtgttaaRtatgtaM
+aggDttcMaccaMaattDctgYctaWtStaNtgRKaBtNcMHcSttMtaKccYacgNNct
+ttatStgVtaYtaagttaagaBHaaStVKHatgttRVWtataMtSatgcaattcMcttat
+KgMcagtgaatcYtcctNaYcttactttctcttcatggcgNcatScStBtagctWtHaaW
+attaccgtctcgtBMcaaacKctcccaacttBgtWStVttMRgKcVagHttVtaagMaNa
+tcaHttacatcYKttDBtatgSattVcgBcBVYttHNtcatKgcYgaaSaKtatttttMt
+ctatctaSaattDttcWagHSacgttagYgacWaSaDKatcNgctaatgVSctgctYgaK
+gKtaataggtggagcgtcgaaaaRYtgYWYSaatacBgacWtaNStcaattWtRctttta
+aSYgttcNgtBWWgtgaatHttttBaMcMtKccagtattttcgaHaDtSVgatgaacatg
+cacgtcagagDYattBcagDctcttNcNtaaaatRctgMcDacaagtttagtcaaSSaag
+aaacatacaDtctctYgcaaacBcaagaBatgtattgacgagYacBDgttcgtgRtaMga
+attttcNtgVcttctgtctagtgtccatatctgatYatNtatVWgttacaDacaHDDagW
+tgataWtatcaaBRatDRtMgVcgaaattcSMagYgWacgggtaacaaattcagcatagS
+gttactBctgSVWatYcYgcBWgggRcHtataSaattBcagHgcgcctttKcttWaggct
+ttaaDtRacBactaaVaaKtaaacctcgcgccattactKactKSDcgacaVtatatagga
+taKctcgSatgHSatVcgtagtgaBtSYtgaBataatStaaccaagttcaDtHtatatta
+acYatattatcctacgagatcaccgtVSttctYgtcataaVactcgWtaVatttgttgga
+ctaaaVcaSaDtYcgNtYtctVaMtaattatWRtWcaNtaKcaaYggatgNgaatcaatc
+RtcgagtHcgVgttataHDcatttaagttctHtcgMRHtaaagaVactBMtatgaagtaa
+aaaBNtataaNttcKcctaNttaaDtcgMacgDcaMatttgYtaaNtcaccgatgagMtg
+ttaggWcacHttNgtcttHYMcaattKcagttcNcaaaacgNaaSattgKttaaBaKtta
+tttaMggHcttttaaRNVgttaYttttMVRtYVgRatKcgVtacgaatttccBatBgYBR
+tSKKctaaaatgatatgBtcttcgtttgacHagtaattatatctgDtBttatgaDtatKt
+cKRcRttagattattagHgDNaaaKgcgMtHtttKtDtgaaaagtaMatcagaaccgaat
+KgtatatVaccRaKYtDHtcSagtBgtgccWaaaggtYKcaHatDDaaattDStDtcKgg
+tMgcMtgtHtcaaVcgtttNtagtNtgKgctaDcScgBcWSatgtatagcKgWgttgaac
+gagtgcgcgtKaaaacgRtttccatatatttttMgaKagcVcVRataccWctctcgBcga
+ggcgttaatgaHYtttHtaSWtagcagtttKtYaacaaataMtaNDatRgMBaBacSaat
+aSDctgaactattgataaRtaVtttHatWaacWtVaHaaBDtactYtaDactttSgtKtR
+attgatttatatattattataattBatagattctaacDcRMaaggttcgtcatattRVYc
+ttKgtRcgWaatcgaaWWatDctacaaaagaattHaatctgttttacYatKatBaccMaM
+aaVtcacStaaYgYKgtttctcattatattNgSaaHtgRaBtcataKYtHtacttgtaca
+aaDtYtgatagNRcYatgaStaaagactgtcWDtYaatVaNStagaaaWtaaaataDYtc
+aMatSVBVaaaYagaaaattgtgcDagWSaStattttaatNcacgataNBtaattggaat
+gcMgacattHaattctctaaMatactaBaaattacaHWgBNtNaaSattttaacHtgtag
+tBtcRtttSaNNaYaMaDtatDtagaKggYgcaaSttgctactDcNRtWgtttaVtggca
+aactattgSgaagtattatgDgcgtgtcttagcNtRctKggtMaHgaDaaagtactgtcg
+atttagatcagNggtaattaKaatgaaYaaHaattggttVaaMggatactctaBgtYHMc
+ttccVcaaWtgttHHRgagttKaaagaBtaRtaaWaggttctatRatSgtatcYtaWcat
+gtaBtcaatctaatRgaYYtWtccattataBacttWtcctaHaaaaggttgacgtRattK
+gaagcattSBtttctaNcSctSStNtYtWaWtgtagtcttgtctttaagNKgaagacgDa
+RgtNaBaVDgaattggaYtaccSVYKctSKKcatagttgSttatcStactcaatSMataH
+caKgatWVYtNacagtttBtRagYHaagtaNaaVVDgatattMaagattagcatcctaMa
+aMctgNtMcSaRcgctHMttaattDtttYttcgataaagtMtaagttaWaaDcaatccKg
+tgMMcatBgtRtaHBcttgtBaBggcaDcgaWttgggtaDaggtgatRtYaMWDttatcN
+tVcttRaKagctRgtgcNaatctgattatagattagtatatgaataDNatcYaggKRaca
+atcaHcaagttagtKgRatRgttaagaaaatacVctaaaagtgtaagKVgcttSWaaHat
+agHctagtDgDtSaVtgatcatttaNKgKHataKBctatatWaNgtttgcRaVNttaDgt
+cttagHYKatYaVaBtaatgaBattaYcNtgcaBtHaacttVtccatDagVaaaYgWtND
+BgacagVgctcaRtaHaaacttttacaaggaSRaaatagaagaatacccVaHatcBRtct
+tttaaDMHWtHgacMtctcaagKDttctgYctctcNagaMgcgaaDWatMcMatatttDc
+tttactaVSctagttcaRKWgtttKRaVaaKtacaacaKttatttttggcctataaDgtc
+BctBDgcYYaatNactcaaRgaRWcgattgVNcWaatctgKagDMgctatKttRatcatt
+MaagtctaRaVaattKctgaKtatccgaaRatcHMaaaaaagattccacgtacgaDStat
+atctcataggtacgcgatgtgaaggtHYtatWagKVKgaMDcaatttWccttgKgagtct
+agatgaatgVRcctaMttgtaRaaYtRtaacWgaaaMttatcatNcgttactaaggtDaa
+ggcagtRctcatcaatggYagccagcgaatatagtgttWtaccaRctagatttDtaaatR
+cDKtccHtBWgttctWaagccYBSgtggaaagHNttHtctaaattaBatggaDMgaBgat
+atcaatactcMtaaKtcYccgatDaYgHDBaagBattWattgatttttaagaRaaggatg
+gYggaKttaKtBVBcttaWcttBtacctYaNYttgctgtBaaMtWtcWaagtaaggWcgM
+DaaNtccWMWtatcMVgaSaRctaKtBgKWDacDgaaaaNgttcaaaaataMcttaWtat
+gNaVaaRataWtgKctRatataagtgttgacgaKgaNgtaHattaaRagSgattctatgt
+YtcaattagBYBatccYtgtNacHagHtacVcVacaacaccgNgBtataYaatWHSttat
+tgctDacttgtgHgHcMcHacagctRSDtgattaggaDHtYagatggagWtaMatcRccc
+acRaaaYagcagatgatacatatttVBBcaaMtctctaWgaNtttcctaVcttaYBDBct
+RgSaagcNgatttcacgtcRDaVBttaRaggtaaggHcacttccgDBKgagaatttataa
+aMaRattagcVgtttacaaagagaaaMtgDtttYttggcttataKaStacaVttBttctt
+gBcVaataaagagtgagBgcgNcNattgaaacRcactDaaccaatWMtaaHtBgaaacaa
+ccctcMctcaaatctMWttggttttacttagcRtttacatRtccBttVcatgaaBacaYg
+agHttatWDtcctSatRtYggHtNMttRgNtgcatcacgacagaHgtYaSaactgaaNWV
+agtagttagaNgatctgcatWYaDacataHtaWttaatHaDgactYgttcaSVtttacct
+aatttaDgRcagacaDtgcYVttaagaSSKBYtgHtDtNtcgtcWttDtgtcNtgacKag
+cactccDMacDNcccctWataRKcaaatttctRVaacagcaMtataaattWBctttgKgV
+catttaVgtDgtatHtgtaSctagtatagcBtBtgtatgtcgcMcgagttctacgaaBgW
+ccgaWatgcaRtWtaagYttaNtcWaHtgattYDatWRgRWagtRcHggNatNttWaaac
+aSgcaatMatgacNgggaSatgatttcBHcctaaggWactacagaaaagctMcaaagaYt
+HVgtaaHKgKattVaWtttcctaWgaKattatgMaattBgaaagtgaSaaaWtSNBtttY
+ataVgNatgaSgcBaaccatattcctctagRtattatctttctMtgaRtctcYgaatDtR
+cHgcRVtWtaacDtcacYatRcttNgcgaDtVctWtacHtatatgtatKaaggtaNcata
+KRaataacacDctcctWgtSaWcatcDgatatBtaatHSNBtcaataaStHtacttaYaD
+aMtaagMtgNaaaaNccccgYWHaatgcBcttaBcgtMBKggccaVgacaWgaaaaaVYc
+RKctMgcaccWctcSacttcVtacgaagtYtcctttttaYgttattaataactSttRggt
+cVgagWRStatKataYcaatNMtacttcgcttVBaYRaKttaaYatacagctBgagcttc
+HcaatBaaaVcgctcacaMgttaHaggctaDtSgatattggggBgRMagtaattggattg
+YYHtVtcttSRYaacttataBtNKgatVaWSDWacatVcttgttgaagScaDaSttcact
+aattagatKttaMcHtMgKccaYatKataMcKNgattgtYtaaRHHcaWagctgtgcYat
+MHaatRDgtgttYctatNKtSDtaKgcBttgagtKtacatgaaggcgMatDaWtcBatag
+taaaatNYtSVgVatttcaNgRtaRaaNBttggaatVgaaaaagaaggtgNtttVBgcct
+tgtgaBtgMgtaaacBgtactWgtaacctatatggaSYattYtVgtttaagccaRtatRM
+cgWMgDVSNgataatBRccNagagStHttBgctaBagatattaacaagaggttttcDaRa
+gtcDgtHttcataagaacaKBttaBgactaRatgaaDYHttgVagcMcBDgYactWgSga
+cBataMMcttSaRHgcagKcgaaYaDgttcataYKcttcMWttattaaBacDcttDtttB
+catVggttVHtgtMgKcgaaVgtcgMaaHHYBMaHtaaKaDttaNgNtttttaggMcWtt
+NaaaDaaaaactRgaatagSVHtaataagttStccaatcHataatacMcattHtacaatt
+tctgatggacatatgcaaacaKBatgcagacagVcctccgcaacNatcMaHtcMtaSctg
+taYgtStcBtcatDacRggttRgagaaHatVcttYWgaDtatgYcaBKgtSWVYtttctW
+ttHtctaYttttaBtcataaNgtBRaNcgttKgtgVKgggVtWatcWagttSttttttaM
+aRWtccgttttattaHatttBVtataSctRWtgcMacaattaStBcacggaatRatactV
+gaagMaaagWacaMgctaacaHctHtaatacacgaYagtcttKagcDttaKBHccgtaHa
+acaKVtcMKcaataaaNaggttSaatcatgaNaaBtacggBcaagatcRgttttHaNgtK
+ctYatBHHtaaaDNHtaVtVagttVacKtcYgcattcatacaaagtaacKaKKtaaNtNa
+taaNaaSaBtagaattctgacacNtaHtataBDttBctataatagYSctgtaHcgccgaM
+BaggttaMHtKgttactaaHaacgDatataaagcaWtgaMtttgVatcKaattcgHVNat
+NgDaaYtataHacaaacaagagtatatDStgcNgcRtaaWVVaDStNgtcaaacgDttaa
+ggNttWcaVNaccctgaaaMcagVYVaMtBgtatacSacgSgNtaaaDtRaBSaWcNacg
+YaggtcaYtattagVStaccgatgSStMattctWtattHtHaDtatgYaatattgtttta
+NggttVatcttRcgaNtHaVaStgaagactcacaaatcactgataaKBtNHtttctWWta
+ttgactacNtaWatataaaBaatBttgggtatYtttYtgttttVttgagtcVaMVgaatN
+taaNgKMaacgtaatattKWggcagtgRttgtgacactaaYacactggaaKaWYRgcatg
+cgttctBcttggtVaaWgtttHagtcaatctcggaNWtaatBNcaMVKStaNcMtgatat
+aatDYMctttcgcatgcYtHtVNgStggagcBtggMgccctgtgNtVatactgcctcHca
+taDBtaStgNcagaYttaMtcaYtgtagatDaagaHaaaRcRataattcaDtcaDgttgt
+atRaaaaYaRgtttDBgDcgaagcNttgcVttcacttaMgtMWaYaattcggaDcgaVtY
+attaBYaaaattaHVttttWaacDttaRaSWactcBgaRctacaVStBaaatRgaacMSa
+agaatagYtNctcaatagctNttaVtgctgtttgYcttaatgtgMaStactgDBagVSgg
+tSKMYttDatgtMaaSaVtccSRMgaaaactHaatWWtcatttctDgcMcggVtgtRtca
+tctttNatcaatatYaKaaaatKWtDDDaaactaagtacRHtcKttacaataggttWctt
+ataSaYctgctVtaaVggatcctaHVttgWtgHtWttaDHaNgaccctatatgcWtNtta
+cctaYtttDWtttaggHNgccatattacKggattVatatcRcggRWMtgcaVRaaHgtaa
+taattttaggtctcDccaatatgSaaaagatDtaaVtYgNaHBtcaYttaaaaacagata
+taaagttaaaDWccMHMattggtaaagtccgaKtatDKaVHaBagaBatactataVttDt
+tDaMagctctaaDSggtttgaDacacVatcttNtgatKtVaBStatgNtgDKYcaatcat
+aWtcNatYccgRtcgBHacaBaatagaVtagcttgaKagcgHtttDNtgaagMttStttt
+gDDKRWtagtaBgtgagtgBcaDtWtaHcctatHatttgttWgagcggDtgtRDRcaaat
+agcacacRtDgtgVaWtaattRacVataBWacSYWVctgYtWDaVtaKataaacttKaaa
+MVHaaaaKNtaaacttgVataaaatMaaatMaagtatcaaRtatSYRtBtaataattgtt
+tgaWtaNNtctcaatNaataaaaaaattgaaaattattgtgttaaYatccccHtaNcatt
+cacttttaMgVDtaDMtcaWSgYWcSYtSgaatHtgctagaVattaBtaaaYgatattcg
+aaBtgaaDacacatRaagcgggagggDMtatDttaatttggaKSNtactRMttactgtBg
+gcgtcatNttctattaVacgttccKtVttMacttWtctaYcacgtaVtaaRgKcttggat
+SYatattttgttacaaMgtgagagaSatattWcagDttggNtNaaYtaggaaKtYHcttg
+KattWagNgtaagHHVatYatcattaaaaaYtHgttcaaaataattatBgcaKWKtagaa
+tagtatBagaaMtattMagaMtHcWgYcacgttagtgtDNggctatNatRcYYHtaacMa
+SStattRagRcgataaaatWNNatgaaatttVtKcRtKtDtaaMcctccaDRcaHtBSWc
+YtaKttcacaaMaataaMaactccgSgtYattDtaWctagatBtaatSgatgatHKgttg
+caaaaagaScHtgaaHRDatSagatcBcggcatcatYVaatgMaatStgNgWaaaaMttg
+cYaaagttSHaYgaaatHattBgtaaMRagSaSacBaagtttttcatgttaaYcagYtgK
+tYctaStcaagcgtaVattaNatWtHgtHKNDtcNaKaVaStSacaaStttagaaataat
+gcDSatgtaKtgMMtcaaagtNattacMYgtgctNgVcaaNcDtaaaVtYggtaaaactg
+caagaWNcaaacctDSaaSgVaKtctcatataMtggBtaRttKtagRcctgttaHgWRaa
+ttgDaaatttHtaccagctcagaccKaaBctaagtatWtaVagBgtttatgaHaaggatt
+StaactWacKDVtMHccgtacaMWYctDtagatttRctaccRagtWcWgaaaaMcagttc
+tgacSctaaaactgaatcacaNcaMWtWccYgtttNaatttggttaaNtggttSattttc
+aacgYVccMtcgaactBtatcYttcYDVMttcgattaKWtatttagcaatatcagWatgc
+RVaatgRtacWaVVBttggatRtaNgRagttDYataacDVBcaaactttgtttgaccata
+gHMtRctaWcgacagtgcVcaaVgRgtaagtRaaaattSBKacBaatcagaatgtHattc
+aVRtatVSSaKatNataWRVaaagMaacataDgataWHatcNYcMtatttggaSatttcH
+cgacaYcaKaaatattacHcSaBVatHacactaMDataaaggcacaacaSacctgtaaRg
+tcccaaaatWtDtagtcaagNtttgatDacDgcagaDcWgatDaaKagctDWtttatatW
+gDcaaaWttStDtKtatSagVgaaKtaacgaccgMgaSaatRRcagYtgttNDggcHSca
+aYDWtcaacgtaHgaStKtgMtRtaatccagtDaaacHgtacaaccHtagataNaattat
+cVtgaKaaNaaaaaaaagttgMgtcRaNaacagtaKcaBgtttgaMDgDMacttattatg
+aDgagcgtcacaaRaagtYaggMtaaactagaacagVaMWataggtatHagtttaaHtca
+gtaaatgRgcatgRctgaMttBaaataagWVtcHctgtgtYaaaaVtKtaSaaBatMttt
+gttatattattcaaBYctBWtggatBtgaggDagtgcacVataRBctaBaaaataatttt
+tNggtccgtVaaaaataaattBHaatBaagaHgttaagcctaatcaaatgaYtKaatYta
+aggtMgaRggtWgggNactaacgaRaaattSttWtaataaVtHgtacttNtaagHaSacg
+WggaYggNStcctgacgDcgHggtttHggtNtMtttDatNDgtgacgtatacgatKatat
+aaacaattSaaagcagatKtttSagcaaMttttgaKtMtagtcRacctKSttBttaatMt
+gcgttacaaagaVaataattcaSaaWcBVacYKtacaNBaaKRtRtcgWtWBaRKVtYWW
+WgattgBctaaatKaattaYtMtSBMBHDtBtaggDtcNctWYagtgSaaBaVtcttNgt
+cgttHtgtMtctatKtatVggKaSaagtttattttatgtactactHtHttSMactatHca
+agaattVataaaMKNtaMccgtgatDaHcaacttRataacaNgaatcSBtatgacBcctc
+gggtaatWaaWtacacaattctRVgattctatgtgtatHagatagggacVaattttDtNa
+WKagtatatHtagacgaggtatgtcagtgagHccccaatNataKMBaHtcWgctagtgHa
+atBatSataDatatcacccaagattttcSatKgatWtgaagtcBMataaHaaMaattatg
+cttWWtttcgVKYNBattggtacttcaaMaVNcctcHatcgctVcttKatgtctctBMgg
+acatcaggacSgaKttgagtctKVYaaagtaaSgaaaHaWactgRattaaBttVaHtgga
+ttagRWtaaDaaatgatttSMBWMaDactScgRYtgaVagNctgtSBataKacStHRatc
+tVgBKaggccaRctaacttcYKtcaDcttgaaacBBataatacYMgWgctgtacttttat
+gaSaaatYcccgattattRStccaaaBagaacaaaVtttgcttatagaaacacScccSaN
+taaaaBgtaaggcDgtSttRatMYSWatcgtaacgtStBagttaVaaaScccSggaMDBS
+gcaaKaggatatacgtatgcWactccgVctNttMaYtaaatKaaatgKStaaaHaKatat
+gBtcctatgtVaBggaatBcgcaatgagtatHcYagctDgtWaaccagtatWWtaRtKag
+atagtgKatatgaaaggcaWgtNKaaagataWaatHaaaaaKMaaatttBtatHtctNac
+tKtBVVagtatcacgtMgtgttaKtaatcgaaMHtYKNcMaatgcaSaaDBaaaaagaWa
+DtWMgaacatttDcatttaBaBtDttaaSMtcagcttttRWWaataattcNctactWaat
+NaBaattaagaaacttYRHaccatatKtaKcNVgttYagttBtaaaaVtctcgVctagct
+cgSVatatagVtMcaaHRctaHStttNtcattRaatgtaRtgttaatYtaagcattgaat
+ttaKtctaKKgaaggtcgMctttcWaagcgWaKcttcYttgtgaRaagMtDatgWgYaat
+aKaatSWScatKBtYgtaagagaVcacgctHStaacaSgBtgtaNRYaaWtWcKgaccDt
+gaWtgagMaYgVVgBaRacYtcKgatcagttgtaKcgttgagNaStctggaatVtactaS
+NtaaagtaatcaattaaVaaDattHDBaHKDHctVggcaaacccKMaatVtgttacBcct
+StgBgMtScgaaHcatgctMtStaVttttcDaNagtDVaatYcggaDaYtaactaNgtcc
+aattSacaaaaRgtagaaKgtcRSNtgatBacccttMtactatKgtaaRMagataMatgV
+tVKagaRagtcagMgMaatRHNttagaagaatgggaatcHtttttSgtNgYatgtgcYta
+atgDctMaaaMccVScgcRgKNaaagtaMtacaKaMNaBatagBttttcttttYatataN
+aWcagatttgMtgaaacaBYtHaaatgtaDactatttNatttKttSattgBatSRtgKHt
+tacgattgcggtaaaaacHHtaNgMcgHaVDtgtagaagatBaaagDttaacSatttaat
+ttaccagatataattggVgaRctRtcgccVatRNtDgcagBcVaHtBaatDttatgKRKa
+gataaRgcagtaKgagttatatcaMSagttccRcttaaatgatcttataaacaaatttcc
+cttaBaWtagtagttMaacMaKaaaagHatYKactttRatgtctcgattBcSagaDKttt
+HtBaccttNttVttVVtggttacgtaaBMRgatcgtctacaaNBtaVggttYaaggattc
+caNgRgtagBtgtaBacaagtataaatBaaatKRtaMtKHgatcgYggDSgKRaSttHSt
+catgtatatWacacRacHcatYtttaacYatatgtgttNtgcSagDHgataYttNattat
+cVattcaaYttggtaRHtWtcgaBacgtttaBaccaBaatgtcgcNagaNtKtaDtgDta
+tgDaBtcKgtBgatacNaccDDatttYtKggMtYNtaactgVacattaaHgMttatcgtH
+MNtataBtKSgccaVttaBcttattcBaagtgaWtaRtcctDVRatgaattgatatgaWg
+ccacDaatKaHtttacatNttaWNWgtacaggctacttBaYaaatatacaaaatttcgNH
+gMgttHctcKYcttgMtaacBaDVtaatttacagaRttttttagcKagtKactatMRtgt
+DtaattccRcaaKSttagttttBtctatagaKaVttttgcNagtKVccttagRgWaNaKW
+ttataDgcgaatgMKatgatRcYtctgVagaccgcgVgactagaWaaHNtcRNRKaatac
+tcYaNtSDKtcVVggNgDagtttaaKRgttaDcgtNNgtcaYttggtttYtatgtaaagg
+attttagatattKMcatgYaaatcaVactcagagtRYtgtaactatagtBaDtVaWatDa
+tctataaaSgggtactaYaKKWagaaaaataaattatagRcaaaVataVagatatgtagg
+cWagacRWattctgacgcDtaBcYattgtaDggMatgagcgagaggctaaatVtctcagR
+agDtSgKNcgtVcStacatttagNtgatSNgatcYVtHattHtBgMacRaattaHBacRc
+NaaccctVaaYaattcVccatacKcttSagtctgKMNagRaNcatNgcgHattStSKYRg
+gtcagtcaccattttagtMaccctggVattHaatVagaaMaattaVacatacacaaatta
+attacgtKtagaaaMgatWgWccatYtagacKatctKatMcggYcgcatgHRtcStVtaa
+tHgSaaaVagtgaatgtgYtattaYcRagatgatcataacacSgaYaactMKttatRcga
+ataaMSatacNgaMatttcggccacgaYYMcaKattRagDtRtatMVBtaattWtMHgNa
+WDgStaaSNggStcBcVYtaYagaHtacagttccMcgtYtYttcattgSWcttagttcgt
+HtgVRYgaMacttBtatcaactaaaaVtDgataaDgtatcatYDttaStgccBacctaaB
+agttgRtaSBtaaaagWgcacBggttagcMaYatttBgtaggtRBaSagttcacgtaDaY
+aaaacDSaKattctgtSatatgtatggVBcctctgtgaaHDKgttaRttttBMHgRMgHa
+gtagMgacgaagttaatattgRtHtHttatYaaagcagatgtgattagtggcactactVa
+ttagatctctgtttatcattYttgatHcHttagStgatgactctDaaatcagtgttgttt
+ttcYaaagtatatcYcaSaacaVttcgWtatKaaaHWtRgtttaKacttctgaaNaYacc
+tNtcStatttaaagttKgtgatcctBcaBtctttaaaKagttgDtWctDtgtgctataKa
+gtaNHatctagYgatcMgtggYaagactgacacttaRaaccHgttcaYtagWtggtgBcS
+tacaMcMHataaaNagatactccaggagttaatcatRttttgaKNgSgcaggtgttRaYc
+aaataBtaDtatHgBtatacKaataKtaggaaatatgcataaHgaKttttatMaaaNgMa
+tYattgaatNtatVaggtKctttHattcatttatYtattagtataYtttagYcattagaa
+ataHtaaccttactcatYttHMRagttctDagNSVgcgVaNNattctVcaaVagaattta
+agaggttttacRagtagtaaaBaBaaMtaScKgVaRcNtctgtataagtatVgtDgHaYt
+tcHYttaagatRgtgaattctYaaaattRtcWtacDDaRatcaKtaSacaagctaNttRY
+agMSDKtWgWaYNgaaaatatNtaatatHMtMWRaRacaaaatgctgctacNKaKtagtt
+gVatDaVccatSDtgaSggcgWatccBgaaVtgtaWttagatVaBWtacgWtaYattaaa
+tMctDgDaaKatttgaaatgctWctttaHtggHaBBSRVBWtgattgagatccNcaaaHt
+tccgVcttaDHtNgtttaMggccVWaagattgKcaacgagtatgtccctctcttaccDtH
+cttcctBatcStVaactaatctacatgtacataacDgcgaVttataagcaaRWataattc
+ggtMaaBccYgRctagatctNtBaggacMaaaNgctgttHgScgttaaVgattVDtaaNa
+ccggatatHatKcgataRtaMcagctattcaagagaatHcYRNgNgcaWtgagYtacttN
+taagStaVVagctgcaaggHatgtcaWgaattKttgtcgaBcKatKKtDtRtNYNtctac
+tatgcgatgtaacDtcaYgaactSHctDataKtcaagtccVRtWaaKMRtagKttaatag
+tggKttYtaKtVataWYgHBatataatcatNMRtDYaYcttgttHagRtYacgaDaaMMt
+cagattBVScattYcaataataBWaBatgDtBaKaHacagtBggaVtgtgttRtgacata
+aagtBtaVgttaNaatcaSgcctgtcBBaVttctHgVttcttgttatccaatacaNtgcg
+ctatacctcatHtNaBMtgtagaDtKagtHatacctHgtgaDVWtatcWgtatScattac
+tSgatcWatatDataRSgctHaaWataataYacgtacgtgDatHcgtaacSaaagYaMat
+aYaactggaagtKgattKMaatStRgtatVgttcttKSMtcataVtttaDtgttatatta
+gWtatNaDcttgccHaMDttStgtctgagtRtatRSMWttaStcatattaNaDtcaattt
+aVatgMtcaattagMYWaRcNtDttcaaagMgagaVHtatYaacggttScaaccVKHaaa
+tacWagaataaccMatWgctDtatttgaatBtNttgaaBgagaaWcttggatcRctctaD
+agWBcacaatMStBcBWtatggtagtgaagaMKatacttaYHtNctgttHSMaWttacaS
+aatgtattttggccatatSatcgctctttgaRRVVtDaatcSYHcSDNacattcMDaNVa
+gatctSctBcatagtggHagaVtgtSactctSHaMaWtgtatcattWtacgaaHatatBa
+aSaYacagtaaaagtVacatKtatatataVtagcgWccacagctcaaccttRtatNactM
+tcattaaatttNaaggctgYctctacatcaVgcMHaagaBttcgYDaSRtHgaaaNcaWY
+BggataatBactgaataYgcgtaacccactHataagaaWgcgRacccagagaVtataggc
+ttNtaaaaHatacatttttYYatHattgaatgtNcttatNaVcaaRtKctcgaaWctDtt
+ttataaatgatagcgSttcVtgatataaataataBgaatgaRacgagtaRctttaactat
+tNagtcagtgtgaSgaHRacgVtggRccatttatgtMtattaNatgttaaatRaBRttca
+tcttaRBtNtaNSWgtVSgcNacBtWaDgaaNBMgagaBMgaHaHagatttctNtWatca
+aaaDgtgcaaWaataBattaNtatgDaMaWDataNtctatDagatSWctctggaccatca
+BgtatattaaHacHgattcgatgtRtaYattactNtWgaaRgcgDaatactgWcKaMacR
+SaSaacDgtgSgSRaagNtKttattcattaagtctgtctctataaVgctHKttgVtgacg
+attgRYcatccWcMtaBagaHacaaaDaaaRVgcacatgatYaatatttMttaaWBtctc
+gaNcWDtttcagYKattaRtttagHcKaacaBcaggtaacctaHtaMtttaHacctVacc
+taaagtcactttcWcaatggatSaataHattacaMggtgaaWaacagaaattgttggRgg
+cgattatWtaKtScWKggtttcttgtcMaRgYYacacggagtgccDcDattcaaacHaac
+ttSScaaStMttaYtgtcWaaaaaaaataBataWaatatBNttcgttgtVatgacaHtgt
+acatHtaatgtKcatgSatacVRcVctttagNttaatKYgHtRccttDBggHgDtgaatc
+aagacacWtcgRWKaactgRaDNMactactgacaDgVgatcaagNRatacagattSMtta
+attYtgWctRgttaaKMgggaaataagttatgHaScYaattccRMggSagaKKttRggtt
+tgDtcgtcMttttggaDgcVctYcaaataattSctDaccatNataDtaaaWtttagHMSS
+aagaaBgatYaaggNtagtgctcMaatttWMggtctatttggaKagaggatWcatttgct
+atcgcccBacacttataagaYtcNcagaNatcaYHgNgaacRgtaDgaNYttcattRtag
+NDcHNVcgDctggDatDtgNaaaaaHgaYagtRtcaaDcgcaKatcagttattcataacc
+NaatacacaaYWcatBaaaacaRttMgtaattctWttMaMtttccgaNcatVtgatcBaR
+tttgSaactcaKYaaNtKDttttRagaMcDYgcaKcataVaaagattcatatWcHtagta
+gatttctBtcWHtctaRgaSttgHatgaHMtNtaactgaaaNWtDctgDcacattMctNg
+WattatatctSttaScctaDaatatDYataaaaatataatNctKaNaatatcSgagttaa
+gtKDttaaStaaHtttaatgaRataBtaVcBtcDWWaaDaacacRNtaVggatattatag
+tBttggcaaKcacRNgaaYaaMRaHtatBcaaacNataKacttaMtaacaacgRtaattg
+ggaRcttagtWataactKttDccgaMcacNHKtattStaRcSStDttacggagagtMtaN
+HatttWRNVgaaacattcScatgctaVSttaRaMagatcScaBggtatacgatVttKcVt
+agtgccgtcDtagtRagggcagggRRttKtcgtKDRaaatgatVttDtcatMaNKtNaca
+gMattgttcaacKaatYKttaactaatgagattttaBattBctcaaRWgtYtYBatDcat
+tggRtaaHttcaNagagctcaRatBtaagHtctcttRatagBttHtgatgattgcRcgtg
+SaagcYaccacBWgtaNtctagacgaaSatBNtHMcKagttaaDcHtaDaaDtttccaat
+McaSaaacWWggtgDtgtMtcacggcgcWttcBctaaVatggaagNgtaacctagatggY
+KRVttRtMcgttaagccaHgatHBcgNtctMKDcYtaVttHaaDWcYcKtttttgatata
+cataggaaaaacWgctgttatWHaggatcgtggcataagaaaWtttgatcaagaDatgaW
+tRtttgMagcBattcNaatNcKgaatatWBBcttKVHtgcagtagaYRatcggaagaRta
+ttaBNttattaataatatgtttttaagMggggMttctBgtcgaaMctcctaVttRtBatt
+aatattgVDcDtggtgaccBaNttDWaVtaaaaactHcaVtacKMtgaataacggHtaaa
+atatataYtacBcattttSaaSttgatcatccacatatgcYaVcattatcaagacYcMaa
+taagaWWcBataBattcBtaKatgtaRgtKgattaSttYaHcgttHcacaatatKatgRM
+gatgatgRaattctKNMRtggatNttttagYRtgtgYttaataaDcttHaDcctttgggM
+tcgcMgNYtcNacttKtttttgYBaHMgcccgggtWttatVttttMtVgaHagDNtccBV
+aaagtaKttaaacgaYgHagVatMgaacBaSacNaaaBcagaaaatatttaYgaaSccaR
+acgctgtYcctttStttaacgatVWaatKtaBtaaataVaBVcctgKaatcaggaDYatg
+VcgctaaacVtcHctggttaDggtatRatttttaaatDttaMtMaggtMaattaRcaagg
+aatVaaaactSRctatttWaDtBataaBaaKattScSVgtatcWaaaBtattVtattttt
+atYtaatacRKcgcgYtccaacVBtagcttYBtgtgttaataataWactatataaVccaN
+tcaBtttcMagataatgactMBatBctaaRtatataaaaaaRacagtatYgtHgcaDgaH
+taaNMMStKtDgtaaaaactgtaaccBttMaaMDVaaaggaVatcScMRMaBttctSgac
+KaccKcDgaWattHVtKaNcDaagRSgcgcaRgagtacMKtWaacRtcKKtBYgtagNta
+tgtttVttatcRaWtattcgtttaDccttMVtatgHagaBgtaMWKtcVagaagcaaaaS
+taaatgagaWtttDttttagNMgVttcWagacDgaMatataaataagtttgcctatRttt
+NtcttggMtggVcgaMaBMgaatDtVaDgttaaacgaagVtttNccaagtgHgtgtcSca
+ataaRYaactgcVWtaNRDccSggagttattatgcctMaaNcgtttVgtcaatctaccaD
+MtaattBaatMtKgaDcBggatVtaattRBattgcccatgaNtttMDcKtgcaccttccB
+ccaatctgDgMSgaagcactctaWtattgaHgcDaagVRgtaBtaaRtgtYcYttaagat
+aaaHaHataattaattaStcttcgatHWaaRRSHctggttgtccaacaDttcaKggcVcg
+tSBctBNaRaattcgcatagaMtNattStRSaaattVtMtgttNYaatgtaHaKNSagat
+caHctaaaKKgtaYatDgaaaBKSacaatacRgDctaSagVcagDgtYMtcatcgttcRa
+tgaatgtcBSKtSagcttagKKccgHtBRgttStgtBaaKaMtaaKHBgaVaVattaatN
+NgcattgagtcaBaggMgctHtaatatttDatcWatagRatVaaattNttttaaVctYag
+tRaHttatttaaaVtaccgtNattataKSRcgcagMgaaMccagaatatMgtgNtcttNt
+gattaBgaaaagatWtccNtDggaaagaNttttNtttSggtDcaaagagtactccattMa
+tataHcgcHMBtgaaKHSYtctaVtaattgtacctctctaaaVtatgKaWaacagttYaM
+tNgDYtttcYRtgYaWaaaacagataaacgtaVatNaaBtBattcctWaaggcacatgWt
+ttaMtVtagatatacgataMtttggtVBagatctRatKggttgcYtacSaMStattBgca
+tttKatKtVgcDgcttNaaataatWNtaDStRaacHtacttacataatacaMtYgcggca
+tYcactttttDtcaacBtgHttggctttHNtRcgatctcactctcattMtatccgattag
+gtgggNgagacgttctDtHcaaatacaVaaaHttctcMaNtaattHWaMYgatNacKNNM
+atcRtNtYMgVtataaaatttaaaBMtaaaatBtaaacttgMataaaagBaaatBVacta
+gaaaHtWtKRHttgaatVattctttgaNgaDDtatcVWtDaataaaVaaatgcaYaagga
+tgggcttaaRataaacttVDcattcaattgtaBcMtgYtBtcaMKcRNaKRtKcaatttg
+atWgaMagtWtgYVaRcagattacaWttgaataaaaWgHaagacggYccctBtWttttYV
+tttggatKBtVagHBgtaatgttcgaggaWtDtgatattaMaagttcattMtttWcgtNg
+cgaRcaactaMgaVHctctgcgagKRatWtggtcgtWaaaBctcScVcaHatattNcact
+ttccBtDaaNtYggaattRtcggctaggNVgDcgaacttMatNagaagtaaRaaRttggt
+aVSaagaattattcaatNttWcaWtaggattScaStgattBagVBttaNcNaSagttagt
+cttDccctatBatHaRRttaacBYKKtattHVcHagStaSaatNDDatcSaVgtgMttaH
+ttgttaataatcaYtDcatttHNaRgWtgtaYcaaBaagaatYaagaccKggRattttaN
+cgacStttaatKcVtcYtttcggcaaaSYacaKattgSatHtWtKVcagatccccStaat
+RMaatgtaatKtcDgNaYaaBttccRaaacttHtaRcaaagtatgtctaaBDVcKSKVat
+SagtggttaatcttaVNaagRtctgRataKgcaagactSKattaBatNttggttDtgcDa
+taKaKgKacaWHgttScVaagaWtcatHagcgattcBBtcWaactBatgacBRctgatDc
+MaaVDattWaaKtRcctYVYacggaaagVNBaaaaaattKYaKcMatgagcatStaBtcc
+tgaHgtttacHacgcttatgNHWatgctWWattttgYaaacctaacYcataVtagVagtV
+tNgaMagtcgttatcYtaagcatgKgaaagNSattKtttaaggacaBNRatttacatttH
+ctaaaHactNcNcaaaYBcacggctcaaHagaaSaagcaWtcaaaDaaBNtNacRgtttB
+SVtttccttaaDgcctgKSttgtcaaacNMcaBtagaWatttVgcRtgaRtMttgccVtt
+atNtatggacaaagWgcacNatcaDMaWtcHgaaNaMMtttgcatHtYDcDactttRYta
+aatMtaVaaattggtgtcaacatVctBtHctYNacaaactcaMaaaMcHgtaactHaaWa
+ttKttactYataagaYgcttattaWMDgStMKKatatDataNHMaSagBaaaVtYtgVta
+NtataDRcBtagttcgVKagggatacaaSRaataaatagtaataKatMattVaSatSBta
+gVaYccaaaYacaKSactctaaHctaaaSaaagNttgactaSacDtttcattVctccagY
+tcNcagtWatacattNgttagagNctaYaYNttKgttttatKacMgRatgaaacVccgtc
+aKaatHHcacRtgtgDtccatHaaaRtNgcaSagtStgWKtttgBtHtSagaaacgtaSa
+atctacWaaattagagaDaWgtataMtgataaDaaaaaaaagttcBggaHaDWWcYctYt
+catctttcaBtctBaattattagcatgWcacgcaaaaDaactRVccBtaWaatYcVVcac
+MatNatacctSgtWgtttaattcactaaagcHgaatcHatcaBtgtaWatSScMMgctat
+ctctRaaaWMgttaKaatagBtttcttagaggVttcaatRattNtccatttcagctactc
+cacMatSHtagataaaWgaagtttgDcctaagtMaaaYagaaattttVattRacatctga
+accataYtcaaatcaRttaStRgSacctBcaHcgtMcccBaagaaagaDaaattKttNta
+ataaMgtctYcttDgaactaKaacNgcaRccDKtcatgaagtactcgtgttcctBtBtgt
+tatDtctgaactataacagtagStaaaaaatgHaaacaacYgtgtgHacaaattgttcSt
+tBtVctaHaacttKtttttWatBtcccttaaVaacaMaagaattcaKaSNatMScRtgaa
+aDtSStDtHtacNtNtaHtMtNMNNcWtgctctaaWttaattaNtttKtBttttttagct
+tcDagMNagtcKWatVMgcttBcgccttttgtBtatatttYtMgctaKaacttgatttta
+tctaatRagtttggKBSatagtaVVcaattMataaSBtDtaBaactgSgtatcaactgHa
+taacaDcaRtcKttatgaatcatacgcgaagNYaNgaaacaattatHMgYgtagatctct
+WttacatVgcgRcMaagttgttDaNtScgStWgtgacaacacggVgcgaSctcactcaaa
+aYtDatatBtattaNgatactctaagtWtKSgYtatataaaaaYagaggttaKagtcYtN
+tgaagtctBWgaWtaaBaattStcatgNNtttagMtRDtWttgctYattcVSBaMDcaga
+tVgccatMatttatctatcgtBgcScYtaaccaaHcattgcagtcttMNVaactWWKcaa
+ataNaatgHatgaatgtMStgccattacHNgVataaYtgaggtKttNBVtYagKacHRgg
+YMacDatcgKtatVtWaKgtHatatMgttScgaaVHagaaattaNttaatatgcaaactt
+WgRagaaRBcNcatctaagtggatgVKaaVgNcaccagtatgHKgacaWatYcSacaRaM
+gttgcttatVcaaWcVaKaaaKaDtaaaatcgVaccatcgKgtDagBNKNatccgaacgt
+KgtYctgaKaaSKcccKgcVtttKcaaYtagcagatVcctVtgaMYctaccMcgDtgBaR
+taaattaaagctKtaaatatatVgctgaatatctMatccaattacaSYgcactWttaRac
+attgtNaYcaactatNNtaHttYcStactctatatcWSaccaVNctBtaaagataNaagt
+aaaaStBaaVtggttatttagDScttttMMWctagcaactBctcttattSatacSatttR
+tBataatcaaKVSttaaaaacaNattMBcaacagtttcVtttatatttgtaaKBgcacat
+tttHNNaVtWaggaDataatNaWtBataattVacWaaattRHtacaSgWtttataDMctt
+RScttttaaaaMgatacMatYccgacKMagVtWcMtBaaatDatatHtttDtaattHaat
+ctaHgcgtaagRgWaccattgaStttattctattcVacctccBcgttaNaacagNWtagt
+aNgtctgaHaacBgtatgMcRVatataatKNKaagtttRgtaYcYcaMaaagattKgaaa
+aKcttgtaBHNaWNgMatcacctgcaMggScBaRgMMctaDaaRgctcYtaacgtgtata
+cttcacDaKtatgcaatMtactaHDtaaVcgaagaaaggVaMaatYtttttattttatMg
+gaVYVaaatBaatMgctgWctaagKtctgBtKacaataYtgctBgKgaMtgtgataBagt
+tMaagRcccVtSNtaWcgVDctcaSSttKaaaaVaDctacYatctcHHDtgattaacctt
+ttYatattcgaaHBagWgYtSgcMtMtagaHactaSgBgBSatHtDttagaacSatccca
+YtatttgtgKcgDcRatctccNtaagctagBVWaBaaMHacaHctDVaWgtaBtaaStVt
+DYtatacttgttcttggNYtatWBSNcagatttgBtcVaacVtRgtYaatctatSatagt
+tDatgttgtKagtctagKHtcttttaccattcccctaaaaSatttaDgBactaMttctVc
+aacVgtaSYcttgYaaKaggtaWttgaaaYgagataatgccMgSHatHtacaaMatHDtt
+caagtaMatgtaagtgtaggtDtacStVaHcaactatgagttatataaBHagggccHagt
+aaagcRgcttagYaaaaaagttaaattatYNtYctagtttaacBataaWactVtRtaatg
+tHatctagacatttaKagStttgttttaaagtDttMtgMKgcgttaactaVttHcatccg
+ctaaaaDttSMccttNaaccattacaBcHctVcttctYtaaSSctVtRVattaaagtHta
+BgttcatacRcctKctHVHgttKtcatctatagNSaacHVatcVgRtgtaaaRatYtcgg
+gtBtgcKacttgataRttDattatcMaggcWWRttccgaHttNtacYtYactgtatWaaW
+taaggtacaDacaDgttStgcttatctattatgttgStaaDaaattagttRgtgcBgRDt
+aWaggMaaVttVRtcBttatcgttBDgVgatttKgaaaMttatatgattataWctcWMga
+HgaattMDatgVagtgatatcaNcaaaataSttattttaaatDgtaNDNggaaacgataa
+tttaRaaatataaaVaagttacDtgtggttctatRatgcBtaVatVtMtaYtttaaYgaH
+ttgttgagctacttaatatBHtctttaagtcaHaWYtKttacttgtttatagacataMgt
+tgcaBVcttMacttYcHcNaDatNttagatcagaatcttatcatHaNtatcMagYaacac
+McaatacaNRatDtaHDHtSYgaatcRaBtKttgaMKgcDgtacgtgYatHcggatactD
+DctaVRgtgctttRtatgtaaaccagtttacVtatttBcatcRaaYgcaMaagaacSctH
+RtctaWatatacgtattKaNagtagatataaWKcgggacgaRWttNacaaaaagaaatga
+tacDaaaaMataKacatVgcgVcgcNacaaHNattaggaacattYtcRYtggtatccBat
+caccgacaccagaaagMgataacHRgttKctDaggMaKtaaatttScBtcagKBgYtaRK
+ttagttttcBaaHYatgattaaDaDVacaagKaaRYattaMaaagVatattKactatctt
+DacHaDaatBcactattKtKtRHggtaSctaaaaagtttaggBScaatcgMStttaatKa
+caVBSattaKaaagacacaaagtaattWactttacWaaBgYtMcMccagRtacaatatct
+tatBacgNagaRtctHgaKtMgaattcKYaaMacgcaatctcNgYgtYRaHagYtcVgaa
+gaacacKgaRaacgBtttagDcgaWgaYtKataaDcaBatttccgaaaacaRRBaVtRtg
+HacttHgagtMttWattMtBtgDaNtgKtaaKDccKgctaMRtaNacattacWcttacBa
+cgRtRttaYggcKNattagtgactttcKHNcWBYagttgataaYagaWaSMttgataatc
+tataatRtggaKtcactWaataatYgtgcHgYKttaaaacNcaSatgcggacaBaRattt
+tcgacctHtaKYgttaaactataRaaSactKatSggatgtKYtatctYggcMtactatgt
+gaWtttctgYDttggtBtcHBctactacBcVacaagtgaatSttcHttttttatRYYacc
+agatctgatgacgcccVataagMaggWgYtatctgtgtatcWttRttcattattgYcHtg
+atcVatcttVSataactgtgcgtgtgaRWaacgatSgaNaVKaaaaMttccNtWgtVaat
+NtHgttgatVcttatcaaDaRScagDtaKtatttYaSctttctcatccttaattagttaa
+atactgctgNcttgctcatatatactaDtagctagRcataBcgccRaacaagcacaagta
+HYaaatgttaaRgacNgccgctcKtacataBtWtaaaDagagactacaccacggaagcSt
+HgggtcatDcKcaacctctgDVRaYaatattWttattcttataatWatattaccYaagWt
+gaataatgatttgtatBYSaDctatRattgaatDgWtMacggtattttRgtaagtgWtRt
+agtSctVtaRgttScRcattacYYatattaRaaggaataagRtttBHaggtattacBHMc
+acKaDDagtatMaaSMacaSggtVVgacctgttaaHagtactaaatYtSSBgaKatcMVH
+cDtatgtagaVgtWtMcttctYRtgctRtgaacatDctcRaggatRaaVWtgHtaMgaat
+taHataStgaKRaVacataDtgDRagBHttgNcNaRDcaaSagStDgaStattBtBNHRH
+acaYaatcagcatacDtattWctgcMattaMaaWgKttgRKgcacNYtcatcaaKtctaN
+tgacatMatMgYagNtaRWtgaaatBattctaStYgttcSYatcctMagtgatgcgtatt
+KHKtNtcattcacatccDaaWattgcacMattattgDcttgaBgccaMNaacattctcaa
+cgaggagctaactagattWaatgtagtcagtYtcKtMVSagWagataaatgtaaVtaSat
+cccVMttataacaVWHNataWtgccggBVYtacRgHatagVtctDttaccaataSaDgcg
+gtttcKaggtaaMcatgMttaaDacaccagYgtattacWgaDtaBaacctatgaWagaca
+YttcRHDgDgaaMtcagRtaattDtaagKtYMMacagcaYacgtWtctcaNcaagttttc
+tacVtatagttgttDgDRDtatScgatgcgagggSacttcaNcVaatKtattRtWttaVa
+gtaaMDtMaattHtagtttaSgWctcctggNgatgMataNRcttatataatcVtDBHgtN
+aRatgctttacHtRacgYtYaBBtaScWtttMKcStgRcaSgaagatNVtagctgtatVt
+aaagttcgWMtgtcgtHtcacSgaaWcgttaMcttWDWataVKcaatctattaKgtattc
+MttattcgtatcaaatacaDtcacatatVaatcSgtgDatBtgtagatgtagttataaag
+tctcatMNgataNgtagKcatgaagKcYgcNYtVttYtaHKcattaaMagaataRWacgS
+actctWgtcgtaaaKaWagRaBataRSVatccYacttcaggtBVatKtHctatMcttctg
+tHttcataMgttattcttRtYttagNtVtDatattgcatYBtggKtctatcYctDtagHK
+BNttYKtcWtRgtaDatgaaStgtaMagcBgaaagtSctRNaHcDgtttcYaacBcagaM
+ttatRaVacgttKaaaacMttaWSgWcNRcaVgSaaaBatNcatttatttgYatttDgtc
+aatgagaYNattggagcDagagatacNtaacaWtBHgtatNtaggctaggcaacYBtatW
+ctgaRttDatcgttKtaNtgaaaHaYtcgattgtgccaagagKatcgatatttcaDHMMt
+tVagaKRtaKtDacYgtcBtaDMacagatHcttcagactcgtagaMggtKSctagKtaBY
+MggtagcStgNgaacaatSgattaaKWNaaYggaaaacgMaaattgatagagaMtacacN
+acacSgagcYVaattHgatDWatBtaattaaYttgDaacgctcRatatacVtcaMgcBta
+agattgcgNtaHDgtcaaaDcYMRtgcataVgtaatcaagaRccctYWccaacttagaag
+aaNgccHWaaaacacaMgatScgatgDtWaaVtatacatggtgRNattattcaatctBct
+tatDaMcaaHttatacaaNcttgtttagSSatgatacccKttaMtcatWgaVataatatg
+YYtcaHaacactWHatttVYatatgDactaaggcgcaKcatHaccMtccHcaatgtWtct
+ttatgWDatctgWaagHVtDggaagagtYHttBgaDKMctMHccDaattMatcaaBtBca
+gatBcatatagatttatDtNatcaaaatctgaaSNaagatagtVBtagctaBVNtStWBg
+ctagtYgatHNatatgcWacWtaYtctatatgaatactcattagatcgHgaRattaatDt
+NcaaDgactSatactgNataBYaHKaKaactctcHcKHRagDttgtYgtaattaactagc
+tatatataaKcattttgcKtcaacSttgHRaagacNaBtatacataaaaataVWHMcaYc
+agcagRaagagttBttaaMtgatacSDaNtttgaagRtattaHtttagtatYaaatcacc
+gaYaatattWBtttataactMYactaaactaaatttcNcVatgcVgKVatatattaaatc
+cggaaNaacacaSatgcttgcHccacatgatNtatgKaNtgctggagtctataHcRRScS
+agcactcaatataggaaYaataaagtKKaaaKtBttYRtgtcNVVaaaaaatatagaNaS
+gattDtgacgtctMatcaaatggtSaYtttaatcttaagcKataaMDaMctgtYcDtgaa
+ttRctgHaatgttggtcttcaataWacaaYaNtacHNtVWagcHWtBBYagSagcaaatc
+KgataaSgDHataaacattKBttWagtRtcNagHcttaatBccgaaatVacggStctaKa
+RaVtgcaHBcgKVcattttHgctttgtgacgaBttttccatccMatRcaVataattKatt
+aaaagDatVttaSRMggtacttKHaacaatgagRaWcgDtaggcataBaVgttNBcgtag
+SttgccYtacWcgagNaatttgctagagacatacaaggataacWRtcDaacSDStcaRtc
+DcaaaHgtatcaDRtgcagtDtacBtatDMagtatcctagtgcDaSaaRtcaRactHgaa
+atccaRtWgaacttattaataScaDaatYaaaWaRNcagtaaaYcaHttBctaattctNg
+gBYBtggaacaDaatKgcagataHtgtcKaWctaVtNWYBgttttgtHScaBctRccata
+ataMaaacatgaatatNatgagtWgatggattgaNttataHcSKttgtatcatBtDtaWa
+tcaWaDNgtagctaaaWttBatDgMatgagatctKttaHactataSgattRataYaYata
+gaatDagtaDaagatcKcYgtgWSgtttttaYKtSatttgYatgYHStattaKcttatNN
+SataaaacHBtaKgcataggYtacgtttccaaVtaVaHDcaWRYSBHattattcaaaaBa
+tataaggaBtaacaYcgHgaatgcggYHagtactNagaaatttttacgaBcaaBttgagt
+KtYHaKKgttgaacgacacgBtWDtSttgNHDMgaaaaattcKcatgataMKttVHVBac
+ataKaatcggWtaccagMtttcKgScgcaactattVctHScccaacccHDtgttacgttH
+VaatcVgMtgttcatBWBttDaaactattcttaaactaYtRtgtaWataWggacVgtggW
+tatgtataaaHNctRgRtattaagtcgHgWStttaWDacacatcaHatttVacttagcgt
+HagagttgttcatcatgcaHcgtcKaagaRRacaatNgtYDtatVgYccaYKVttDttBc
+tYcttaWtatgYtaVttttacVatBaYKSSVaNNccgctgctBtcaagcacaNttctata
+YMatccWacBcgVaaatagWgccRtHMttHgBacttYScaaVtgSgttacBtctBttaRt
+SMgttaatNaRatgttgtcatVtaaYgVgcVaaYSaNcagcttatNtacgatagtcgaVt
+aacYVaMttggataaagatStcaNtDttgcBacatattaDWatDatcaatatNttagttM
+ttcaactacaRHYtcggaacVHtaggatDggStgSWtVatagctgtttaagBcccgBtgc
+gtctacYaBatactYMttHttVttaWtSttgKtcttcgtgacctaDtttMYMtaaaaaat
+tcaMgWatBtgWWtaScccttaaVVgatagaRtYataatttgKaVHtgcataYtaaaaag
+StcaRaMaattWgcaacaaRaBaataacaMNatagatattatgWtagcgVHcgtcatgaH
+gtRatcctgtcSaaatWgtatcHBcatcatcHaattattDBHggcatBtgttagNDggtc
+RttaataVtctttStaaggtcccBtccaBgBRgaDaatttgtttgcNtatBgaaaggcgN
+ttatMtggtBgMgatactDtcatMaaWctatttaaaacYNgtSgMatBcSactaKYaDVa
+VtcagaaaStagttYRcaaKacaHaacagctNcatttKtttaaacWtMNaatttattaaV
+gaMStMcagctaWgaSccatNatgMacataWaaMtataggcgtatcctagHatttttVaa
+ttttSBttScgtBSatgaHcaacgaVtMaaaactKHatatttNWtttataWtaatVttKa
+KMggatcMaaattattMgatttgtatRtaVgaaDtacacRtaaaaaMttScaggRttgtc
+ttSatYWtVMactagatVaMaaaDtaattttaBWcataaggaatBtRgtctaWDtagWta
+aWYSaHaaacgatRcttgcatcattaSDBBKttttctaYSaactcgYacatttBaattKa
+aaccaMStaHatHtatgtctKcWataactctcVNYtttMttaDatSacDKcacaaHgagg
+aaBtgNaaaHtattgtRcgacDtYtctttMttatcDaNgattagtttYtaattBMtaggt
+acatgtYBNttcMacaagaaaaaKgaaatcacaNttgtttttagDBcMgtaNacSatcWB
+WtataVatYagtttccatatHtttDtcgtggBggcKacaBWtBcaattgMatcttaVaac
+VYgMgttDcaaactctctcgcHaSatYVHRaaatccMMtaDHtaaKccactgattatcca
+tBYVDacgttMctaaVtatacaatBgaagttaattttgatatgcatKgaYttHtatggaa
+aatcaDtttBtatgccacattactcaaagctctcBKcaagcaatataNtattcVtcataa
+cMHgtattaaDtctNaNttYWcWtaVatatataWgtaWtgaHtattcgagtMVaHDHtat
+gcttctaaWYaatttaatccaMactKtcgtDaDVWttaccVtacYBgDattKtHKSVStg
+MtBgcgtDRSatggatatDKacataWtatWaVttctSRWgtcaWattKaaYWtYaHctat
+aKacMaagtctRttaatcgtgaHaggYWtcgatKttKaccttacttccgtttHcgtKtct
+taatSBgaatttcVKaMattVSgDDcaattcagtcataccBccgtgaVtaggttYgaNag
+YcHatMYaattDgtttaaMagRactHattgatttaaSKtSccggBattatatKDacaacB
+gVWBaaacaagattgtcDtcttBgcattatcaaaacagNtaaDgtggVaacYDgtttDtg
+gKccttaaaWcacgSatacaggtagVgatacctBttcaattKRtctaMgSattgtaccta
+tataaaMgVtctYMYYcacttRaBgDctRtttaRHgcRSMVaaaaacagaYaagtaMatD
+aatttaggcctNaacgaaaatgNtttaBtMtScVtVtSacStaBggtggtKtRcatagHa
+ttcctggaRtaaKaBKtagttgaattgtatttMcatgcttDaWYtaVtNDgatKtHaaat
+taattaaStaagWaaBtNcaccaatRcacttgttttcaaattctggcccttttBgHccat
+cgaWctataSttBgataacagtacggcccDcScaactgattttaSWYtaaaMaVatttag
+ctaBgSaggtNaBRgStDaatDBtatcHgDtRtgMtStWaYaggtaYatBtaWaattgaa
+YattcBVtaVSactWaWgtKaatagaaatgNttHtgtcaatMattcggtcaDcVttgata
+MNttYVgSSYMWaVtgcaRaaccYtgccattaaHVgaaaattMtaSgtaYaggctataBt
+cRtttaaBtcHDatDgtaaVttgcagNcatWggNtgRMaDcYgYttacWNtgcaWtaaVa
+NctVacaaccRcacttgMttgtRMtgtccatttgKagttctVagcttccaccaNgtgcat
+RgtSBaacggaattttttNagtDcagaHaaaatStcaMtctagcacactHWtNtgctcgt
+NaWatataKcMcWtagaggDaVatttaatttYSDgRccWattHtaggctaccDMctacVa
+attBYtDacaYctWaHaaHttcggaMKaacSagtattaaatDttNaVNtacgVttKaaHt
+gagttWcKtgtaDcDaKacgtactctttacatSgtagtaHHtgaaatRtttagttMctac
+KgaKaatBttataKWMcggtttatgtgtgaStaagaaRttaVtgttBaHgNtggaRaWat
+aacaWtRWacaactcgHWttttaDagScKgtgSagtcMgaRgttacccaaaKRaaatatt
+cKatttNgtMaVcataccaKgaWgHBWagctaagttatcDaRVVtggaaHSVacggttaH
+aWWagtSgctctVattKctKtMatHWcgccttaYtagtaKDaVcHtctgHagatcaSaca
+atKtatgatagDgtcgttttgatVtatStctYaYNtgtgKaKaVcVNgaattWccgattc
+ttgaMaRattRgcaatHctcattaBaaMtattNSSttHcagRKRaaccaYacMDtaYaaa
+atttRataBVtcacaagKtatgcctcatcgtgWataagcgtatcDtNagcatNNatgttc
+RaaScagaaaRaataMtacMSctKtDgaBactaggtWgcRtaWcaYtgtgWaagDKattt
+tttaaccaaatDHattgacSttttatWaataatDaDaaaaRtaYaggagcYatacYaKaa
+gaaNtaaaYtaVtDtBaaDcgtttKMtggcagtVatgccggtHgtgtaVaacDBaattac
+aNatttMgaDgcaDtttggaaMgtYtDtSgccaaaaYcNgaacDVgcattaNgatgaaDa
+BBttgccatttRtctaatgtHNtaaatBtaMaVattcctggaaaaatMattgtagRDaca
+aacgaataWSBctctYVcgtSaMStgtttSatNagaacaRcagtatgaNBtcKgBttRta
+ttVtaBtBaKactaWaMgRtcMtaDtYtatHattScggacMtaggcataaWaKHaataaa
+gYcgWatatStBattKaKagKttacMaRacaSaRaaWtKaatagSatcgaaaKaaVcDtt
+cVcgaKVattggaYgtMataaacRtaDaactNatYcagtDgttagacBataRYRDgttct
+tttattacBcHatgaRacMaactcatVVtttaaaHgctgttcaattaVaHtDcaYKacgK
+tcNtttgctttgHWcaaSactWKSatcgYaNVaattacRcatVNgtagatgcatYatVaa
+YWaSactgatccatatNMaNagNtaatcgttaSttattWattaggagaatcNaaccaaaW
+atRaatHMaattaNWatRaMKaWctWtDataaagHctMctttRSttaacgaSWcatcaVg
+atataattgtWMagKKaBBgatatctcgHSaaNBctgVtaStagtttgaggSgagcKtta
+aatHattDtaaattgaacatactaaWaBYtKttacWtaaVNcWacgttctcctaactBaa
+SRagaaatgttKVgtHacatctcaScaataNgaaVagaaHttaKgHgKaccgtcYtcctB
+ccataagaSacataaaggtttDtVStaVBgtcgNatgtgaVctatWaaDccWHcctttaa
+tcWactaatactcttacttgttcttatttatcaaagatWacYctacKtaSaaaStgtWaV
+caYaRctgggtSaaaWtgctgcHtttgMcgatSaagttgttttNattgaacttaaKaYcS
+BSacWattaataKDattKaHtgaaattKKttttgacDtDtattttDBDDcMgcatagaVN
+ttaWtgaDttgttttttttgacattatagBDacgatNatMBcaggtacaatgtgctttat
+atttRgBcctVtYVctgcatgtgatataatHagtttccttHatagtaMMaaWggBataaK
+tttgataaagcKgtVtaaaatgtatWWaataaHgatttYtcWataataacagaacDRWDg
+WaWaaaggattBcRctacYtagctNgtScagMcccHaBaYgtgctgtSDtHacKtNgtga
+caaaacccMcacaKctcactaaaaaNgtagWtttYtgaDcatWctataVctNttKgRtat
+ataYaaaRacaggttatagtcRgDgcaYctattNcaNtVatYattKgaaggBDtttactt
+HttNtgcatRatgaMHtRBtaagatMcacatBatgtStctagacttccKaRgaWccRata
+VtggaScgatttDMaaatNNtcYaYtaDaatctatgaVtctBKtgccYgtWatDcMYtaa
+RtcVgcttttDtMtRagtactHccRBWatatccttatMtNatgttagagBcttKacaaMt
+agaaattaDttaatatgaaaRattNcHSgaaHtaDcagctYacgccagcMtaaMgDaaaa
+aggatcttcaaVNatRcKVaaHRBctgcattatMaWaNaKataaatatgWaaatcgMaaa
+atcctgttactDtDagaccYWacttctRatgataaKtaaatcaMttttcaaRtScaWgat
+MactMtcaBNataaaBactggtWHtYaattaWacattgaaVtYtSgMcatgaatYgatta
+tacaYttaaaKRgaVagNgtaHWaattcgDaRaaacgVtBDtStttRaKgVagatatWtc
+MKaaaaMDatttaaYcataDYagtaaaaKttVWMggctgVgtgagtKagtgtBBNctaca
+aacttagattSttHagacKVttgHttatSataaWtMHttSaSaaaaDatgBtaYaaaggt
+taMttgVtVtttctaattgaacaggtttDDVMtNSgcatataagDaNttatSVttMScNa
+aattDttYaaHcNgttatatBatgDKctttgVVaaBgataaBatRaagactBYgMgNaBt
+taaattagatttttttaVgttaYtatVtccgtaagDcNVcaWtgcaKgggYtgagattaM
+aaagaatagtgaBaVcacBNtagtaDctctcVtaSctgtagcBcHMWtataattDtaact
+ttHctaRcRaaBaYacatttcVRaatctgctattDSNDgBatcaaatgcaBccKctaHcB
+tctVtaaHgatcRgaacggctRtaagtaSatatgatcaaagBtaagatttVaMagaagaW
+WgcMWBRStRggtttWttttagtccaMRMaaattaSgBccggNataagtgctctttacYa
+taRtcattgtgYBtggcatRtacttBaacDacaKtHDtaNacMtataaKKtgtaaaRMVt
+ctVcRatcgatttgcattSaaaggttRatagtagaattVcNgRtKccBgBtWcataataK
+ctctKatttttgVcaacKStcacSRtattgcggtcctcHatcgaaDgaVgctagtMNVta
+attaaatattMYNcgattaaKtMttRtYgacttgttagggcDNgagNtKBaScagttctg
+cMaaaMtHctRaYtcgRtHatVctttatcttggtYctctYgttgattttaacSttaaact
+aaaWHattgWtctactatttcgMcVaaMctaKRcttcRaatSgctVNgtgaaaNcagata
+atcaatcKtagtgacaaBVtttgtaaVctaBatgtaagtgtacctttacKtMWtaaaatW
+tcVctgagataattacggaatacgSaWgaHcagtagNWaaaSacggaaatgatRBtRctV
+ctgtVaatataVNactMgDtaatggtatctacaaatgtatacKtttgttttaaacgttgB
+ggBtgacttWacgaMtttcagaacagaaRVtttKBacttDWaccagtaaatatcgMctta
+tRtaaKKcgMtHKattWYYgttgatgttaRgacHcattcttKtcgtttaatagagWgDKa
+YatKataKcDgctaaaHWgRtagccgttcatYattcagSHtttattataBVccaNMHtta
+cgWttgDgaaRtRaatcgatNaaNtWVcctacatacYtctgKtcattatctattatcgtc
+KtaataaattagggHctcatgHttSNacctYaKttMHtctttSgacgtttgMcStgttca
+aSBggataggWttataNagaNBcatcaagtBtagcMagtcagagaaDcaaaataKgtatg
+tgSaagtgtYDtDccVaaacagaagttaHSWatagaaaMYaggtacttctccttatatHa
+tgctgVMatKttgaNtggSaRcattggttgWcatYagtaatatttgcttgaVctaataMR
+ttttScggggtgagVcacatYBggtccatMattBaatgNataDatWtDttVcataacSVt
+attagaagtaDtatcBacNaacaaBaaagaaWBHSttgattttKRcVataHatttttgaB
+tcctctacctcRYttagcatactttagaMHgtcatgtHtatctaaYacacggtaaMtatg
+ttaagaHWaRcaaBaacaVaKattHgataNatatacgtatttaDWctagatataaNtacc
+gaacaDMttDSaSYaaYgYaVtcatactaaWWtatataaVtMcagMccaDaaSatBatta
+gcaaaatgRtaHRgccgataatagcaaacacWacagaaVgBcagaYctHctgtcttaccB
+attVaYtttHatgaVgttcRgaHtttagttttataatRWggattYatatMaaaactWaDR
+aggataaWgMataggtactatatttVctataattaaatatgtgttDtcctaKataaaaac
+ggtacgtKaaatccBKtgtaattacaKtKYtgStRaagaaaaaaaggYagtNactttaaN
+aStcNtBcBaaacHtacaatSgattYttaacDacaHtcttcatttgSYgtctRaatVagc
+aWtctcDcRctNHatScRtaMgaacWaaYatcaHaaagttggagtacaNcSRttagaatc
+atVgtgaccaaYacWHHtaMtHtctaatttcactBtgNVggBgttctaDtcttaWttaat
+catatHgaDacatgaaNagtaatacgDgHttaNggatDaggactcaatttcttDaNtRag
+ttgVgaVRacWNVHBttcVtYYtagataagHtccattcaatNaataYtNctgatcRttga
+YaaaBcaKatcacgSaataHatggtacacctttatRcgtaYacgataHWVKaattVtKcg
+atcgtRtatagRgccBtaatagctcVNtttatgRtggggtttcttatactaatcMaaaWc
+gcaatKttatttgtttatHRRacaVcSgatcagcaacccaMatYacBVccNcRgagatct
+gtSgaMttHgtaattatggRatgcWtcKatattMKWtaaatctccgtgtcaHNYaagStK
+caDaMtaaaWBttacBgNctMaatDttcttgatMagtagaaatYHKaacttattSgttNa
+KagttctcataagtaatgactgaVStaatcctcDagtcataagWtataatattacagScH
+aatatagcaHYaaSagaaaaactYtRYaatcggaaHcVcDcaccctattRaatattNgVa
+atacagaataaSaaaagcWRgaKttccgtaWttctaaWacgatctMHaNWSgVtgNttVg
+tattStaatNatVttacaRWagNgcaSgRVtcYtgtctYgtRKatctStHWttcYagtgN
+tBaacgtagtgtHcgaSggcNgHgWggKatMtaHcgtKaHaWggacRRatattaHaagga
+agaSgHggtttacctagtaattBaaatSttYgtagBaSKBaaSKgctMMcacagcgtYat
+SctWctSaatRtKKtgatatctMtattagcgagaMctNtBcgtatRDtcatHtgaVcYtt
+ctaHacgagDaaMNtcttaBgWattatagaKtcWtHaMacagattgtHacttttgDaBWD
+tcSWKacKttcaHtSgttttDtHtSaVRYVgcagaatWattYtgNcgccBSttataaNct
+ttcHtccaaDRgaataSatgctVDggacagBYtBcRacDtYDNtgWaattattatYKtNc
+ggaKRatcagBactgatgcctSttttttDtcSgtcaaataataaMVttgaacBagtattc
+tatggYtcaaatDWacVtgataYYacSccVcataaagacagtNaatgtactaagtRtatt
+BMKacNacagaaWtctSaMgaKataaaMBgtYtaWaaKNtDStSNggaacgtMRtaaHct
+atacMtattttaccaataKVtcagctttatacgtSWBaStgttgWVtYaacaacRgtSgt
+acNgatgRtaYcagStcaNScaaaRttaDttctcaaBgcScDtWaggtgaacttNBBYaa
+ccaNaactNgctaaDaaaggttgagaaMtatacttgtgtctHtgagKacagcacagcgKS
+attaSDaKaatttagtHtMttaMVctaaBtgBaattttactttaKcMagcatgcDcatcB
+agaBHattVgWtaataMgtttgtDaHaggctgtVattDYacNtNStttaKaNggtBtaKt
+gHaaKcaacatDMtagatgtatMtaaacttccNBgctacgtgcaaKgWSNacttSBaggM
+tNStaKtcaatagattatctagtaBttaggactYtaaaStaaYtgaaaagYtMaagaKct
+gtVtttcgWcatctacgtatVaagtagaattBcagaDcgSgtaSggaactaRcaBRtMtt
+RgattaattWaBYcaataHMacgHactatNctacgaVataNVcHatatVHKKagaaRSat
+taacgttMattgtatagBagtatctttgaagaBctgattattHgRttacDgMgtWtaggc
+aatNttgcttagagaRatttSgtttBtgRtgaNtHcgStatgaaKtgtaBacctgaaWgt
+KatHDStatctttaRaaataacaBttStHVMaccggtaVYaaBttYNKgNaBHaaKcKaa
+atStBcattgagggcRSttttctaaatcacaRBattccacatagacatSaDtaaaSNttt
+gtatDgWgcatacgaSacRttagNaggaHtttagccttttWDtcYaVtaRtacWggctca
+aaacVctWtacatagttaattBBttMacatDtatttaaRggattatBVcacattattaag
+WctactVcaBgcttKagagttatRBgctagaHtgDgaaaSVtKgattaWtMDWaRccaaW
+aagtaaVttgWgVgacaBtSaacDaaaaKcacaRKaagttgagtNatttaSttaWRgtct
+aaccataDatagYaMgaWBcattaacSttcacDtSttgtaWYataRBHtccagaMctaag
+aWagSDaactRNaaaWagtacaScaSDcaatMaaaaaaaVBcatKacaggtgMaaMtatV
+aVgcctcDDYgtattcaatattaggagtYBaaatttagaaVWDattcgttagHKSgcWtW
+caatttaBtaatNcaMYgYagatcRRtcataaaYctNtatttKRatRggtYcgaWcgccc
+ataWttVaaBtaataaatcgNtctttaggNtatatgNaagtMttccaagactRttgtgat
+tBagBtaataattBStcaatttaWcattaatVtacatgtatttBataVYWStagcaYKDa
+agYtaggKtgagatVtMDtKgNtcatagtNcagtBagagcaNaaNtaRtagatatcYWtS
+ataWggacagagtcaDSggYatttDaaatcactKatWatcDatatRattataaatatcta
+ttHSctttggNctaagtSacgagatatatatRataagtttcatgcSaaKttctHaRgaaD
+atgStWcataaaaatWMNttaaRaVgaYcHaagWggttttaaBtcagacKtaBtggcaac
+HtaggVttttactatRWaataVcccaRaagattNttggStYaatBRaataVacgaaattt
+aBaMYgcaMgtKStStVtgVaatacccYaDVYaVaYKVtgatgcctacaaagcWgDtVtc
+taBtcctccacgatatWtcDHHaHacaaataaatataccaYRSataVagtttaaStgttg
+RHtctaDMMaYYaaagatacaBWKcagttgcaacgagBagcaaatccgKaRgtgaatcgt
+aWcatYtWaBtaBatcgRattcaagtHctctaatcttcctattaaYgaNaaaaRaDtact
+DtMNagatMtttRacKaccWaYtatcagaaKcttVtVaaaatgttgtNYgtHtaDactag
+gaRttaccVaagMacgcKtatataHaMtcaattcctMaRtttttcatgtctcaacatggt
+gacatcaBatHaaMagaatttattaaaactYgMttaKHBccgacttttaVaaVtcScHaN
+ccttacccatataMgggDtactagKgtcacRtacMacYgBaatttcagYcacaaataaaa
+ggagYaaMHtataaaHtKgaaHtctcaVatcgStcatHtcaYctttWcttattBactata
+atWctcctRKaaHtaaHYcttcaYataaaHtNcaSctgattaagaKaatWagRaVaNSHD
+aactaYVRaatgttatVYttatDcctRtgcgaacStaWttgaYcatYtggtatWNataMt
+DNRtgtttgggtHcWtatHaaataatVtaaWaVgcaatagDatgScgNcagggagtcaDt
+gagataKtgtctataattgtgaNatcaNatDgtagctaaaNtgtagtcBatgWcagagtg
+tWtaagWtaKgattHagWRaNatacaagtactYtaWgatataRctcNKcttttgaRtgKW
+tgtgRagcNtKtYtgatatgatBDKVtaaaaatttWtcaatacgRtaactttaaaaMtaM
+attaVNHRKttattattaaVaatagatYaggattVaaaRactcaagccccRtagtScgDW
+gVSagtggtaacataVatttcagtttRtattcttcYaccaaaagttNttKtggBttBcSa
+WaattataatcataBtgtMtMtaaagataYtacgMtWaaacBtttatcKacaaaatattM
+agtKccaaWccatttgtgacctttMSataMgBtcttaVgtNttttSaactatgaggaSWa
+taRtHtcgaMagSMccSaMctcgNtatgtataaVtBatHcHtattaacgactgNKtttaM
+tVaaaagaatVgttMWcttacacgtacScttcttcWtaatccatactctaacaHHaaaat
+DctNtgatMcRaaWRtMgttgttatRagtaNtatgRtaMttggaaKWttaRtHKMaDDaa
+catgcgttaaaccaaaDttatagVRBatacMaatacMaaatWcNcaaHttBgttgtacgg
+RKaaaMtcHgttaattattttaHgKtgttaatDaHatctggtaatMtYaRgMccKRaRKa
+DaagaggatBtSacatactccaKgVaaRMaBttgcataaacYtKgaVDtttgcatSaata
+ttatNattataWatWgBttaggtBttaaYataaSHtRtaccaacMttaccattccKggKN
+tMatacctctgtaYctaaccttgagtataaRatagaatRBtttttMtgWNtKtgcttatg
+actcSaatattgtBRBtSWVWYagtaWBcNatttcNNgSKacctgaaMKgatWcYHgRat
+aYggtctaMtggcagaRgaaYaYgKgaaHVtaattMgaaWaWaDataagaaaaBDataca
+tatgatcNtagagMtactcatgatgtHataaggtaHaWatMgtagcttaWtcStataStt
+agttttgcaagtgctgacDtgctcDtgaSgVMtagttKtaacgtacattaaatctHgatY
+atttcgggcaDtVttcaaacccgDgtatBggcttcBcWtacttgaatBaRNcgYtgtaaa
+aaRDctKctagtaKSatRtRatMaMtaacVYaKtactgRDcaataaatSacagctDaatg
+gttttaaacNttBaattgattaaMgVBKtBaacctYNcaKcaVtDYtcBaaataNSaBga
+tacccgtVtaatactSgtttgMSYtttgKtgtKacgtKatgataaVccaMgtaVaWattt
+atattgBNtgtVgVNtYStMtgtatBcgagaBaVatgatgBcStttgtagDgYMgaatta
+cacHtaaaaaBttKaaggHttctaggKagRNtMBaatWcagMSBaaVtgaatgtgatNaa
+tSagcaatttHctatWMtgVcNtSaNRHatVaVacVtHattcaataatgSKttttttgta
+taRKYaatccRYaatggtaVtttaaaaaWBKtatatttatgtagtcNatSaatatcMDRt
+gtBttYtatKaattaaaaYtcWccVattcDaaatgattgtHccactgNgctttBtgagat
+WDgVgtactgtRtaaggtBgacctaaatctRtDttaBRaYacaaaYYtcaaagaWaSDtt
+ctttggacttcBcgaDacHataNtNgWtVMVtRactggaaagSgtgggtgaggcctccat
+aaatNttaYYgtcBatattWMaacMRctcgttaaaVatatagagataKatRMtHaVagaa
+BBtStttaatcaaatgagtatcaagtRMtaccgtBagaWKtagaaaYttcSScttaVttt
+tcatatcaSgtcWNgtttagccaaaVgaatgtgttatgaaYaatgaataaaagagatctt
+cYacaaatataDgRttcMtcataYaBtctStgaatgagDaDgtRNaMtYMatatagWNgg
+aNtcattatgacYgtBKYttttagccttataaNRaatggaatccaBacgttacttatMNg
+gaaaMtaaRtctagtttttKKKgcBttgccgtHKatcgatVtttacataMtagNaMttct
+KHNctaaNatttWaRNgRatctagatSctaactctDttaagacgcatagcRNgagatttg
+tacattSattaacttttcgttgattWatKtgaatttaMtSBattKKcttaaSggcactaa
+taaatcactcaMgacggtRcaDScNctYtBRYVgttgtttaVtacHWattattcatttVa
+KtgKaacctaggStatttacaactcKNtaaacaagSttcgattatttcaRttVtaVaaac
+RgDtaatgtccMaacNtcggttgcctaattaaaNaWcgKataaYcctSgMcataaatttg
+aaatttHtagSBgKYggcgYaagagataaWBcMgatRBNRaYctgHatctatHttgaHtg
+cHKBKVaWaacacWNRactWBVttaatttVccaagBSWacaaaatcDgttattBtHaMtM
+tHacKgWtcctcctttHaatagtYttaagccaHtYatatttacgtcaSgtgtYttgBcat
+catttaNRgaKgBtgattttaaatgaattVaKtVYgNaatgDaacaaVtHaaatggtttg
+aYYatgctgcacatttttctacVtacaNatataHtgtcVtaacVgtYccgaactaKaaaa
+tcagtttaKNRtaaataMatgtacatatcKScctDatDcKttSattttagatgttHtcBt
+KgNVRagctaRVtttaNYWttcWYRatgatMgaMKRctNVMgttVagWcaVStcDgtttc
+tcRatBVggaccgaatcMttgagaBDgtNMgKKRBNSMgcaWHYWccNgcacaggVYtMc
+aaaatgBtaKcgaRacccgStattcHttgaYttattattctaVMttgaacDaWtNccDtc
+HBataNcRggaaNBtgaYNtaaMaDctMaaaaaaHaaattcBgtcgHtgcgaaStttcta
+cttcgMagagtaaaacaDctgcagHctHtWaacgaatgtggtDacgtcacataSaatKtc
+WBtataccaaScttNgDgcctacgBaNWtagataBaNtRcSggtaMattgaatgtRHtgH
+aaNWtgttaccatacctBataaMWatttNttVaaRagMataVtgtaccattYVcKYcgag
+taaYtttgDaKDgVacMtttaVttcYcgtMattctatatataaggaagagttaaatHgtW
+ctatttgaaatHttgScgtBataatgatRWgtttVgatMBcgctttatgtctgWKtaaca
+aHttaMtctttatcDtccaHaNYtSWcWNtHNacaaatactNggtgStacKatgtgKVct
+aBcaHcttaccaaWatHaaYtattatYtttDgtBaKcataaaatcaNgttNYcatVSgtg
+atatYDMMtggaatKMaagcttVtaNNYctKcctagMWtttatttBattNagccggaRga
+gtattaKatgatctacatcaKVaaagttYgcStagtctacttttcatKtWtKtctRaRDt
+cggtataMcMDcaattNcacattattgaBaHattHgcYattagaattataaBtattBKHt
+gtaacHtHaacaaRYaBttaRVSaagttHVtatMtcacaWctgVtgaatcVtcctcNata
+acacgWtattDWccatDDYtcgtaHaaKaacaYaHaataBtaaBKagtttcStWataccg
+NcaDtWNaaRgctcNaacttatttgttaaacaaStttagtgVaKgggtatNaatVagtat
+aVVaHtaRaccacaRatacNStaacaYDgaWaRtaKttgtaatacggtttgccaaggMWt
+caaccttcgctaMSaattaatgaaVDagttBcatccattttccaaBggRttgKgccaaaY
+NcDcaSatMcaattYDcatcWatStttggaaWtttHtatVaggttDgVWatttaBWMagt
+cagcgaSaaSgtattctacHtaaSaVacaataNKtatagRMagtKYBKggtttKatDaca
+WaYDaactagcaDttctctttHtagtMtWtttatYatWNaBgHtaBgSttRgattatgKc
+ccaaBtWcccataaNattaYtRYWgRccNatatHttWgttatactttacBYHaaaKaHYa
+NttaatagKatacaaatWSMctttcKacatMattgcaRctBataaVaHtataSctDVtRa
+acttcggScYctataHRHtgttctgtgattYatatYtcYHaataaataYtMMgttaaatg
+atcttaaattaKRtttaaRtaacttaBtgtcatgtctNcaaKactMtKatagRaDKaatg
+SaHcRtMDctagatcaYtRatMSVRMYKYaggataaatYtDBaDacDtaVtacggaKtta
+ttNaggScgWcaYtaBaaacaWaNVtHVagtBaatgaBNagHaBtaNatNttSgaaactc
+tBaggtHHtgaSagYKNcataaMcatagaSttctNBYcttattcatagagagtHWWDtct
+gMtRHtactgggagcKcacctggaYattatttgaaWgtcaVaataagaaNatRgtttacN
+tWYMBcNScgggataataaagtWYKDYcVWVggtttMcttYaatagaaKaaataDcaYMV
+caVtgtStctctWaagtaRtaagtaaatWacSKaaatYaScctggtgMKtYMtctacDat
+ctcaMatVtNaataaNtaattgaagaNaataataagcttaagtgtgcgtVgttataYaag
+VgNaaRctSctgWKVaYKgctNWMaaRaHatcgctHaaYMtccggattgtgBacatHaac
+ttggtggDVgtcaaaggSatWRaKtKacNVggaatYttatttattcaaSttttttttcaa
+tgttatttgttttaBgcatacWKDgtYNtcYtgtcttttttgtcaaatgatacttWagat
+DatttcacctaaaaggtgagttatWgtgHctaatMtRKagccagcgcVgagYagtactgt
+actttagVctaBBaYNggtYtaattttcRtaaagatctMtaVYatctYgNMaVtaWtcat
+tgRtaNataagaaaacVSctHNtcNaMaRYcgagttaHcgacNgagagBgtKaactaaat
+atYRcggatgtKtttactgDctcVaYaaSaacBcacatagaaataaaaWDctVcNtttRt
+cataatNagatVMctBgttcHtVgagaNaaaHaaSccggatSctaHgtgaYRagattDcS
+DtMStNYtgtgaagcttgggaatttttDgcaatHatgaBttHttaacatBcaaagtaggt
+KgagacaattaataHcaNaaHataMtccaKagagtttBYSagDDtaNaRtWtWagatSgc
+SKtcttttcaaRgtMattatRtYSHgaMccttttttBtHactaattcaHtMatagaattV
+tBtDatcttVgagtatttaaaattacYSattatttaYtagcaVSHattDctKcVattata
+agagRaccccWcaBtYYtctaaaaYccSgattaaaMDRtHatMaYtHtcgcaaggWgBaN
+VDatataaatWtcMYSVtacBYaaatactcgtacttttWgaacRNaattctHagcYtaSt
+taaataatttttaaSDtKaaMcWgBaagBgaatDagaaatactcctNtgRaattaNWcat
+tgYVMtRtHgBaatcaagRcagtStaaWRgtaaatHcaMacDctatNaagtactVHaaVa
+gMgttgKtgtHatcMacatagMgaBtSaaaBtagttaaNaYgStRRctYWYVtttMNBgc
+ctgMctcacttagtgtttDagacaYaattagaggKtttacaatMttctttatKagaaNtB
+tttKSHWSaVtVtgttaRSaYccgtaBgggMtKtttctYWttcaVaagctttttMBgDKc
+catagVactWDgtRtKMtgBKaDaVaggtttRaataBgttYtattatgttatgtcMMaat
+cagaatagHaacaattRcBcDatttaYWttagattggttgaMcgtYRgagMtcactaRct
+cBMaaNgcaStgcgNtgagVttaBaaagaatacgcatYMaaatDtacgatatataMtYKa
+tctScatattNgStYWgtttaYcttgtagaHaHaYtaRaaagttcMHaStatcatYtttK
+BtctataaaatcaStcatatStattatMtSatcataHcaWaccagHtaaggaHatatgag
+aaYYgtgVacSttgKaBacSYcaNNccBNtHKtHcctttMttttagtaaaBHBaaattWK
+gtaaccDataactgatatgtaaRVtaHgaattctcRttcgcatHtaagttYYctaaattt
+tgWDacBtataatttctVaYHtMtagMaHWtagatttcaVgtKaaacctgHagSgtacSW
+ttMaBcHttaatcttMaStYatatatattagtttggMaYaatHgaaaHHgatggccctac
+tatSgacaatcVMcatactBBMtaattaaatattBNDacYtgYattBttHtNcaatgcgg
+acccctDcYcDtttaKaSggtatcaBYaaBttctDSRgacHttagMcggtWgagtcctRa
+tatRcttgattggaaaKggaaaagaaSNtattcNtataatVttgagBaMaaBctWtHatg
+cDaatHccgMDcgcWaaDaacWgaagcaatattactcaaaatMgttgtaaMatatYtctR
+SctctWcatttVatgBNtaaYagNtaMatcSgSgaVttSaccaataccKRNcataaggYc
+DMWaSKVcccaaaggVtHtgHagMaggtKVatVtVMDVatBgttWagcctagagacaaag
+gtataatttgcttgtSaaccttctccttcaatgNaacaBtttaVcaacagWaHMttgtta
+agttNWaaYcgaaVtatacBatgagHtSattacBgttYgtNRRcttgatcttaHcaataa
+ttattttccttgaYgacVgNcttaRattatatctcagWWatNcDgacacgttaatRatta
+YcKtggtSggWgatMcaaDBttgaacNttctcaaHtHaagcgVtDaaDtNMcagaaatWa
+NtatcttcattSgatatgatactattWatSaattWccgtctaatcttgKDacatRatggB
+ttatggKgaagtttcBaKtgttaaaKtcgatagcNgtatVDagaDtaVtcaactttYgaB
+YcgaYgWgaWtaaaWatVtctVtgggKaVctcgRtttacMaVaaagaaggtVtKNYtWcY
+aVtRVccgaattatacttatattagcatcKBattttgVDggcKaHaYttgcggcNaatRa
+ctWagWgttcagtgWMctaataBHtttgHaggcctgacMcYaRtRtcggcaatBagttaa
+gcDatatatNttgtMcVtaaaHMgattVgaYgtattatatSaDaaaaataWacaaNttKt
+tcatttttHaMagatYtgtttcattaatatVacgcHRttacaYtaagttacaBtcgaagc
+gttWtatVWRaaSacggWaBgSgcttaScatNaHcaatWacaMatagttcagYBagYgVa
+ctWtgtStNatacatYgSYDtaaacSaaatBtttKaKRSWRcRYMgcYgVataSNNtWgV
+tSaMgBcactaaatYaKattVggacaWaaatgHtatHccacStaatagaYaaaVaMaaac
+YYMctcagaNattatctattaaatatgMaRgggtatgaMcttaHgattgtScgtgtatVa
+tHNgcYttNatatBWaaactNVtHScgataaNcBataggtaagagatttMatVtaagtaa
+atYgctgttttaagatagaWaaYcgctaacttaaagaattggtSYgtVaStttRtcKtHa
+VcWaYaWVSccRactDaattgWaBSKtaDgtataaRcttaaaatKcagtNgtaaataaat
+gattcatgtcKRctatHaYtMacaWNgagatcDcgDtatKaHgaBcaaaNWaRataYtYY
+acttgcactaaYDcKDttWcYataStKcgcaaaaaRaaNtttatttgctYatgtcVcttt
+cBKcgtcttatSttattYMttaatcatattcatSaYtgWaDacgaataactctggaDcca
+ttacgSagaaattgatttaDtHacgtcMgaMHaaNDKttgtaMgRNtacataWgttccSt
+gaaatDaagYRtDagcatcHttcVNWWataatataaccKaatWtYgcctacVaagttWtH
+actaRaagatatMMtYattMttccatactHgStagHcaattaagacagaMDtttagcHtg
+ccctttattatSatWataBaaSMaccVVgtggatgtgttgYgtDHSaaMaKcagaagcWa
+caaaBagRactKacDaDgagagagcgKcaBggtgtaYttatgcDatgaNgatagagtBtN
+taWatagcacgcgcatDRSacHttcataBtaWaNtgtaatcDctBaSttttaggcWtBac
+gacaVYtRttaacttatgKcggDStacgtagaYtaagtaatgacggVMKtWagcatatag
+tcataagMgatVagVttSaacHataatatacaatRYaHacaWaaactRtHRaatagcaVt
+cMataaacatattHaStattDcMWVtYaacYagaaHaaWaccNHcatgtcccgaNttata
+aNaacatctBtaDNKgMtcDtgMgtatgKgSatDSgMtgVaaHNWcDcaaKgHMtaRtgg
+cgRgtHtVtatHgtMggaRVgtcDgtWaactactgttagaKcccDctcNcgtagtgStac
+gtataNcgVaHHagYttStaaccWacaKctgctttaactagtVatttaaatKttRcgact
+aHttSaKtcagBBaWaacccgRatKagNagKaWtHttttcWtatatttattacagacSBa
+gDgtagtatHtgcattgcaMaRgtagatYacactYSBDgctgatcMattStSgattcNtt
+aBWaacatgcttSattttctatNttaHNtSctgtcWttKgttgtttttKaMHNMcaacaa
+gNattRtcBaccatKgtVtaaDcttgattaaaatHgaataKYtgagMtgcWaWgtRttcD
+aatgRtDgcNWSgtagtatRttDcggatHWgaagtacgcVtcaatHtttttttgaKggaS
+aStaataWBMtgcaaatacgWttctagccRtaaaattNWaMggataRRaaHaaMcagaaa
+cacacgDaatctactaactDgatgtttaaDacacVaNgagKaBcatataaattcgRtSNa
+atDttKgKDgcaaactBDtaatatagWaBgagtgtYaaVatatMtaacaggtataacgKM
+taKgcttgNMtRaaaaVcHctKctaaBcWtcHtaRaacKgcaDKaYaSHgtatttataaY
+tcaKatgNacgtcWWatgDttRaacaaDWaatDgagaStaVScctgcacaaBtatacttc
+tgtctttcactacWcaaaWcactKattaKtatWagttacttgBtgaBMagaattgtYYtt
+ttVatttWtcBagaatcctcWtatYcVttattMgNgYStaBgtttcttWtagcaggtMat
+gtRaaDtDKttgataDggtttatgctaataVYcSttBtYcatctVtBtYaVagtaaDtga
+gacctgaaatcNKDactgKtacgBtDKgattaaatagattatagactatggacgacgRga
+aYKgYaRtgaaaagRgBaacatctctMttgacNaWtctVagtStMaactacaatttcVga
+tacKctaKgcSactaDaatHgBgtHgYttaagtNYtRcaRgYtBaactaatatDctaacS
+KatSDMatWtagKtttagaaHKattaVactttSgtgtagWctaggagctttgaScatcgg
+SttaggtgHtgYatgtctNtaggaaatDttcctgagagaHagttKcttttgcHtcaDgtc
+gKtatcaatgcgStVcatcaWNcgtatttHtatctggaHWSataWaVttgKgtKBaaagg
+taMNaatttRDtcDattaStctaaatKgtaagtcVgccaHKgtgtcgaSVtaaaaHtatg
+aaVcatacacVtKattaWaKDgttctattgNcaagaacaKYaHttWcDaccattttagac
+ttttMttaRaMtaHtacNgccgaaaaacKctNgaaagagggaVttttgtBVcatttattt
+VaHcgattWttMaWcattagtaYcMagaatKaYtcatttagacttStDtcagacattctc
+YaaKMttcagtSNtBtMaHacYWNaactVaMgtcNgMcVcVtgKaaataaVataacaDta
+aggtcSgtDatttaKtgSNHcgctVaaaatatagacRaBgaNtaattVWaKtgcaattHt
+tctaNRWtaHtttaaSgWBctVacaNVcKtaaagHDaaaNagtYcYKaVKtaaatBaaaS
+aVaMtcSgtaaacctcBYWttSgMaMccagcttRgtVggaaWgagtaggYctRtaaWtgt
+acaaMNtagtacggVcttKcaMgNaaatgtatgaSgDcSBRgRVcYtaDHgaVtWaaNag
+DtagggtHagHgctRagaNacacaStaNttMaatgaataaSgagBgagtgWccDtVgagc
+DWVctBttccaWcacgHttgtcYtttacttaatVatgtKtaaatttaNaYttaStMtVaS
+tggattgtVgaMRNHtacaaNttRScRtVcgttcScatMtBtttcDtcatVctDaSctta
+gacaaDaaBtaHtacRgRgaRNtKataNgcaaScactcWtKggRagtgtaaYtaaattWg
+NagatatYtHattWtYWatagatatttKatgtcgDagaVcgKVagacagagatVgHWtaa
+gttgcatgaKaatggattaHcaatatgKtMaWtWaYSVtNBDttaaHaMcaRctWScNcg
+gtggYSttcagaattattggaaaattVccMtgggWatatHMaYtaMaacaHaagVtgDtg
+gcHtRaagtHaagVMWacaaagggataBRcaaBcttKtHtMgcKaVtaacaRatKRaMaR
+tMtcagcaataaaaVccNcttMtctattaagacacgagatNtatttataaaSagaaatat
+SccaRHKatYMacgttaWKtgttgHtgagatBBaRRWSacatacWtNtcWgttcaaacca
+ctVcaSaYtaactaHgtcVWgactaNaatRgNattatagacHatgcYWcttatctaagct
+taatatgaaRcaDVaSaHatgaatttBDacatBtttHactacaNaNtataVcaVtattKg
+MaSaSggttggDNcgtgatactaccYHttaaaMaVcBSacctgatatataBgcaattaat
+BaHtttgtaagggataaacatgcgcaaataatattaaBVcaWgttagtVaaWctRgBtgY
+tttccgYattttYMaVMtaHatRDaatgVacaatatVBccgttaagactcgcaaHtVaBa
+aRctaVgggaacRaaaaaatYaSaccVgRaaBtgataaatttcaVttataSMatacKtaW
+ttgcaRcgtgNattatttaatagaatNctcatHtSWttaVtRattcaRYtaaattDcaKa
+gcWggaWcStaatNVgHaMaBKttaaatYRMHaRtcgtagMRgtattcctHtcacaaaKt
+aNttcaRcatRtccgatNDagaBttDHtcttggccttaNtattaaStaWgKtVWNaMcca
+VgVgtatcKacDaYcccactcattcacYtattggatVgaWttctgSDagaWDattctaca
+taaaDggtactatagcNcSgagtgtMtaacNtVtcStttSgNDaDYgaaWVgtactRtaN
+cYgataHagaDtagttggaHtgtNtcgcHYgaDttgRtgStatcattttKtWVaYattgN
+taaYgYccHgWactgtaaaVBtaBattaMBtHtttYttVgtaYMWatWgWtNaccVtgMW
+aSDaatcYWccaaaHtacgKagtNcMKactcgtaaaVtaMatttcRcttgHtattattcR
+aaaWaWactgDttttccttttaKVNaVggataagaagWttcgBtBtVaYcataRtaacBg
+NaaYctggtatctacaaaagatttagttaaaaNaaattgctcaactttBKagatctgctg
+aMgtBttgtKaSatVgcacgaHNatVDgttacVBacKBaaKaBctccDtagctataWKtt
+agtcttYgtaSccaatcBttggaBtMaaaagaYtMgtgtNatgacacctWcKattctgaN
+taSgaaataatatVSaattaaWattagDtgagBaHaaNHtBgttcttatHaggaBtatcH
+tSttgccaatNgtaHtttBattaacatcactgaWaaaaaatggatagMHtSgaaBSatac
+BSaagMaDcaattttcgtctaacgHtaaaBtatcttaattagtttatcttcgtWVttata
+tcgccgaagBgRaDcBaatHVDtataacaccVgttHaaSgaagaaatcMSaHBattgcaS
+gaSVaRttcaMtgtgcaatKaatWggatBVgtataNWgNctttacctttgaaRatSaKtt
+HgaaaYSaBttVacWttcctgctDgBSgYcagcgggWRataaaatgcactagaaHStaca
+atHtggtgtBgcNDttggattatgaagaKaatStgcttHtgKNMNRagtaNtaDattgaD
+DcKtaaatcVVBtcSgNcRtcHataRcggctVBtccaWcaDgaaRaRctgaatMtaRtgB
+caWNaNatatWScYYaWttatScYtSgcataDtWcacBtactaWgcYtcgtataagctat
+aNSgBctagattaNgaKgatVKgtagttttcaaagtgcgcYattcagatggaKcMBtacg
+tttaacctaaattaaatattcatRaggtcgcccattMttaaaaaaactggSgtcccgtct
+aNtWattcaattVHDagRtggVSSaaHtattatWctatKatHtHattYBtaVaMRatgYa
+gcHtaSataaStKaaacattaagggttggVYaaDgttWSttcattaRBcMttttaacatR
+DaataaMttRgataaagVDKatcatacaacgMtaatYctKcgggcBKNgtggttcttaag
+ttYgcataVMaaVBgtVMSNagttatSttgtDtgtMgMDtNKtBgctattacagataMWt
+cSggtcHgggcgagtcRtcRattaaaatgaaYYattgtaaccttgatacgtWcHDgBtVa
+gNcSgBKtaaMtcaStgggatDaVtKScaYagtttctagNBtcMcDgKaDHtVtMaMacM
+gtagtaaWtaYtgHtttttgtctagYHtRaagacDRaatgctVMtttWaYaaNtttatat
+ttStcgactaDatKaatatattHggttgtRtattaattaaaaRtaNacKattctVaatga
+ttcttacWatgDgagggtggScatNtcMggaagggHtaaccttcWcatWaStagHtttga
+tHaRVaaSVNNtcaRacaNaKttgctgggcVattatccatVatataDtDcNgMBMgHSag
+ggaaagKctgggtcacgaatcaataaVtDttaRRgtctStattNBaaaBHatcgttaaWM
+agatagacatatVgDBttYMacaatttKtttaataaaagcacgVgaaactDBtaaccgta
+gaNtgagaaaRttcKKagtYKttttaStataaHgtcNDcgttYccaaaaMcaWtgggtta
+tcaaRaaggaataaVWcacatattaRYaaVagagVtcHggaBtaataNattagKtcVRtg
+actatcgHDaBgRBStVtSgNBccWDgaatgaggaaNctttNttttacaaggagaaDDaV
+tcgaataaataagttaattStBDccaaaBgVaDtctScgtgtttttgctgtcacgtttWg
+acStMtttVaVgaBtacDWtttagttDctaSDVtttNaDDcHatatacYtKataaatagt
+tgaacaagaatacaDDcacatttgtaaaggHattaaatgttacgtcagtNStttcVattt
+aBtHtVggttattaaHcgaWagaYtVaataaatcaBgaccctHcatKaDatRttHRMcgt
+cgggSMtaatNagtYtgaYtggMYttgtaaactacgKgStttaaaYatatDtaaSaVVcH
+gtagatgaggtcaHggMtaMWaWaHctgaatctaaBaWaDtcgggtccctaagtaVYDaN
+actataaNcctKcBcataaatttcaWSttttgacHtctRggagRaagacagWVNtctcat
+HtDHaRagctStatattggcattcattttMaNaSaRaNDHaagNtMgtVWtgtMccaact
+KNaaaVaStatcgtStgtgtaBgBgtaatcNtccgaagtttaWgactNgtaaccaatgNa
+tWttgWagtaaKgtctRgtctaataagttVDHgStgttcVttgtSWatcYaggMatgMRc
+BaStgtaaaaaMttaYagccggtgaRRatgatccaaaggtttctaaKgacaDagagatgc
+tcMgaaaMcgRaacaaatataaaagcagtgtatDHgRaVtWBVtggacatStctKccttV
+ttatgtKattttYcatctgttatgtcDKHYcctSHMttgSDRNgtaMNHaggatBcSBtH
+atDMBcttMacNaVMKtctgtttcgaHSgtMgcacagaStaBttcWcattctDtcttHtD
+KBcaaNtRNaaDgaaaaccMRtBcWVVagcttatcgaDYccacKtatgatgtcaRttatt
+YttctaMBggcaYctaNtBactgattStaDaHccYaDtgcaRDgSYtYtatBSaYaaata
+aagtctcgcgttcagaaKtttctVattagtWcacgaaVaaVtctcaVgtagttNaaacaa
+tgtccttaactaaaStaKWagttaNttatacaaaKattBctgaagaagtYDNtagatata
+DtHcKcctaBaggcaatctHttctaaDNtgtgaaaagRaattataaBMaggtDgtMaWHa
+cBStSMtcgaacYttRMatNacScgaaRtttctattcMaaBggtaKttaRcgtBattcga
+tatYtVaccSacacgtaaagtctNatYttgcSSattttcKccttataatcRtHNctttMc
+atBtacatgtYtctagcNttYacaatgtaBgcgttVtattaaWtaDRtKNaNDttDWaaa
+ataatDgcgcKtaatatcgctMctatcatcgtaaaaYNRttSaNtWggatRgtgtcttat
+aVgaaaatcWDcttDRaatMKctcatatRttBtccaattBSacctgMtaDDRagtcagac
+BNtttattttagtDacaagcaHcacgRttVtatcatatacStaatMaWagttRccKtRct
+cgaagttgaatttNtttatHaHttagctatSBaBtcaagtDaaaRtgattcatStagttc
+aRattacaVgtatWRttWggttttctaactttSaaaVHRatttYHMKVVcgttMtatBta
+SaaMctgMtcaagaMtactcDatSaaaacNgatttNcaagttRgacgataVtaacYNata
+StRtgaattactgtaKtNagaaccDaatgNDaaHcataDSYattatgtctgYWaaRaHtt
+tWggcKatgcgtagDSVtMactataKMSttaHaaaacaHatVaDKtSaaaRtcaNWHtat
+ttctWataagctttcccaacctNtaaacattcgagaBKVattaWtcVaKtWcggtaatca
+atgttcaaatccDttctcaaSaWNDataaKatBcaYttRtcataMVtKttggcaaNgtgt
+tatMaccgttgMNagtgVtNBWggaacacaKaaKctagtctacttSaKYMacaWtWDtta
+tagHBacttRttcctgttagtScVNaRtaacgScaStttatctttttSgtBgNtttStRa
+tNDWtctgatcKtgHcattatctaaaaattNaaaWgWaDWttWRtHRNcHacBVgWttgt
+NggtWtWcttgSatRtaaYtYtNaDttYagactStacYaYtNHBatggatacVtBatgcc
+aHcgtagaaMatgataHagtKgHaWcgtaccKaNatagWtDttcgtagggcSgtRatatN
+gaRtYataaataRtBtcttaSatcagatgaaSgtVtHtgtaaDtVactgattcgcatctc
+tBaWWtaagBttVgacHattWWgcKataHtBtagScWtcaNtHStBKMHBRtRagcataa
+YtNtttatacttaMgacccattgagtDYggKccNaaRgataWaaaNWDMttMacttaatg
+StDYgtattaBatBttKcSaactagtaccgttggaKacRtDaataSBaatacaKtgagDt
+NcttattaagYcagacttNNttatcBtHtgRatgccacctaSaatccaRSgtWggtgaaM
+cgcaMaagSagaaDatHcttgaaDgNRttaDKacgcataagYaagtMRttNaMMMgcggt
+tcgtRaSgacaStaaVgStcaRBKcaMtctKtctatNaactaHtaactaaatNWaKtWaS
+tRSKcatggtgBtgRBtagaatagataSBagMtDVataaDtaattgaYgaBaagWagaac
+aggaagtctgacgMgtgagaRVacMcBaaDatKatcNtKaRtcatDNBaaHatatacatt
+aWRBtcaccattctctaaWttWacgtccgcgtMctcaaaccHYtNDatttSaDMccaStR
+ttWgttattaSVKtgttttgtcWatgtgStttgttttatcaagacMttgtRDgcRtctct
+gtgggggcSaagcatVattMacattSgttaacctaaaaccgcagtgagNgtctataatBt
+HtacaaSccccMgagRVctYagcgaatttacMagVttaRDcctRgSSttttcHtVaacat
+agBgaMRagatRcDBaMtaNtcatggHgaDYgaVgWaaaaMKattBtaDYBaHRccagtt
+atacVaDcacactcgtaSctaaatatRDaccagctttttaatgtagaMaRaaKaaataaa
+atacaRagaaYaNtatKcDttgHgcVtaYgDacagMBagtgttatgMcSgWDWYWtSaKa
+agcatKatatctcaRHacagttaKtgBKtDRggtcaYcattcgcYattttgtccaagtVg
+cattttttaVaagtaaaagtWccttgacYcaagtaatataYBaatataBtaaatacactt
+ttRHagtttaDSHgNtNVcatKgaKtgagttgaaaHcgBattatHgRKtcaBaagttgtt
+tgtVatYattaattBatYgaatgMgtttatagtKcVctagttaaYWttWaRKWggYttga
+RgagaaMKtaggtattaMVttataVcagHYacaaMaattRRtataWaaRacHcattaVaB
+tHgtatBaRtttaccaaggNgtaDMtatYtaYVtNtcBRKMgaatRaaagaatactRatt
+ttNcaaaDDaagtagtacaNtSHttaaataattggtaaKtttaaBaNgtaagtcaYttac
+VaataataatDtgHSSgtSDNaattcRMBgHttctaagaYVcHcactKgaaNHcgWaWtt
+aaBactcgYtDaacgactMtaYKacBgttcttgttataBacatScBcattKaaattactt
+SSDaRgKtHHagRNRMtttBDtcaagcBcgcYattactcgtttacSaaNVagtacacgtg
+gtSaWatBtgatttWttScaaDtttggtKtNKaMtMgcttaHKaRaccgatccctgtggg
+agRMttaaMaWccggtttBtgttaaVtagMWctNtctHgtBgcttatSMYccttgHaata
+tctgNgVttagcttagggaBBSStaYgYatYgtaaaaattHatctatgtWRNgtVcSgtg
+cgtcYBagtRHgacttaaagSHatatBaaDgcaKtcccDgcacMttatRaacaataaccW
+tNBaYatttYacYtagagattRtatagKcatattDgKtNNgtttWNagggtacStataRt
+VDYaacgtaBtVKtagaagRttttttatataSaagaaKtaatatKtattagBtHataata
+tcWNaacagtgWaccatatStcYcaaNRctcKacKttgtStaaKRaWDDaatBtttgtca
+gggBgtggSctaaWtttYVWttNtctaacatagVYatcagatctVaHMgWtcaagtataH
+tgacaagttSacgtNRataaatgttgNtaattagaattgctMaRttBtacBatNgacatt
+tcaMcgtaaacctctagHctaaKNttBatatttaatattBaKtRagYtatattSgtgtcc
+BaNSattgaaattgYggcaaataatatHcaaaatcMBaagYatttttaYttYaStatttD
+tacRtgRattttttgDcRaggagcaccaattcRcttttataHcggatcatNSatgtagtH
+HcactgtWgtaggtNgactactHagagHattcaggggSaatgcaaaacSSKDtaggcDta
+tVagMtggactaBSatagMttaggatSYttaacBtagaNSVtaSaNcSScaaatattVct
+cYaWYtBcttcgaYBagWtRgagHKagagMaatttMatgtDtaYNagDtaBagcKcKcaM
+ttKaaaaatVaatHDaataacgRatBNVKtMaccYaaccMgttgtactagcttMatKgKB
+tMagtcttMWgaatRcacaaaaSgcgVtSatggcaggcgKaYaatgctcattaaaggDVa
+cStgttaMaaaaacNVtBtgcttaacgtDNaaRcgWaKtatactagcactgKVttaatct
+tRcgDHHattcStatgatcWataagtattttacgtcaRgaaMcDattYHattYgatatca
+cNNWtDatgaaaactgaatHaggaNcttcctKggNgatBaaatttgcaaaDtgctcaatg
+tYagacMgtVVtgDBaacVaatNaDtatctgaaggKcagSggVtacgatgNWtKWaggMa
+cctagaatattcttYaatDatcgttgatggtcaacgttatatgcttaWVttccRgVcaDc
+gagMtacattaMtaVWcgttRcatRacaRcMcaNtaYWNYgMtatMgccctaKctagHtt
+taaBVMaaWcSaccgMttBRgNcRWMtHMaccaatgataaggagVttYgaatcttagtgt
+cMtgcctVtaRtgcaccaDaagHactNYcNcttaaggcMBagaWtattgtgctaccacgc
+WataRaHtDtacgaaVttagttVacctatatStDgtggtaMgaSattcatgMcaRctatg
+WgatKatYYaaataNYcSaDtttgtcYttttttaBScatRtctgtaWttaatagMaacat
+DttaaaNgaacttacYttagaaccctgNgagMNHaaKacccNatgKccttaKcatDStaa
+StNaaVBatagttcacRtYcRcKaagMgctKtBagSaagNcKRttaaaaKaaRtttttta
+tHHNHaHRtcaRcMataKDDtNcKtKatctaaataaatRatYttMccaaaNaaWgctgat
+tcaaaKgaatScaNaaaKaBaaaaRNtataVcYDattagctattaaatWtgBWHgggtat
+catattatcVttcgHacgcgatMattDcaRggDYtYttNaaaatBKttKccStYVDatat
+YcctSacVcattttatMtWRctaYagRgctcttttaacVtagaNaVRaccgRaattaaVc
+aattgcgKRctMaKtttHgctttVMaNaRaNMKacHSagtWagtgNatKttatctataaH
+atgSaSattcagtDctWaataaYtcagtaYtctatHcgattSRttaaaNDgagatatact
+tVttatcataSSaBNaDataRtRRaattcaRataaRtattttNaRYtaKttaccaaaaaH
+VaBtttWtttgatRagctaMattgcttactctgatKtgatgRBttaataagYttcStKaN
+gcNatacgWatYaatctggVtaaattYccKagaVagggatttatttWacgaBcaBtaaDt
+tttcgaBcHDgaaSgVNctgaaKtgaVagtVWgRHgtacaatattgcMDNNataatagaa
+aataatNtNgccgaaMaagtgNttacgVHaacSgStBBtRagtBgtaaWgacttcKgact
+aaatgaagVaacaBtggtacattcaaagtgattagKagNatatVaKBacaMMctccatcg
+cgggRctttKaaBatcacaScaNaaaaatVgHaattaatatcWcacacactcatgctcga
+RggVgcatatcaDcatYgaggttDgWNagagaaagagaYttHKaatgtaVtYttSNaDtc
+gaatctattSKgtgtaggaMgtaccWcaMRtHttaaatgWtgtccgtKtacggacaNgaa
+cgaSgcYagcKBttNacaagatacgaagaVcBgStMacMtgKaactataSgWtaaaatDR
+ataaaNaSaagHttHWYgaccWMtatataaaaagatgtaKtVtgtcBNMtRaSaRacVat
+aaNaaaDtaatgtaaagaDgtataVDaacagatttWtDtcBgatggBcgagctcKWgtHc
+BgcMaatDNatcaYtctBgaHtccagHctttMtattgtBccaHMctatctNaaatacgcg
+tacatacatctaDactactcKtacctataDccMattRgRggHtaaaaNYcVtatccgttS
+aagYcgMatttaVattttHagVatVtttKattaagttaNaacaccHSttagDactSNgtg
+tttaNtVtatttatgaaacSaKtactctacgagttgaagtcaSBaDgtagatNaaactRK
+ttcatcWtaBaggKtKcYttaDttatMaWcStgattKattgtatatDttatDtKatgtaN
+tgtcgtcttttttaBtDBcaaaaSgDatgHtctacaattcgMtVYtatgcattaaaattc
+aVgatRtcagBtcaMaNctHgtatVatcHttcaDNKgtWcgagHtttaccattNgaactY
+acaKgaaagtggtttgtgatcgaKaHgaatYNtBgcaaVatWacNggataccaDtaaaWt
+tBMaBccagaHDaataaBaagYVacYaScctYVgagWagaYagtgatgtttWatSaaaMY
+DcactYtaStWgaaattacHgKDaYtttttgttcaaaaatttgYatatVcMatcactggR
+aaMVtStBtaaaagggatYaagtBtatcatgcDttDaaaaMatagtctaataNtcttWHa
+aatcaVttaRaKtcgatttataWRtaatatcDWcctaNMatgtttDaYaaWtMaagtcag
+aKtaMKacgccaaVatgWtSagtagctatttcactaaNcaaaNaaattaggattatMWgt
+gacgtcttcattacaYttctRRtttgMatggNtatacaataataNgatNcMttaggBcDg
+RHgatctttagtNtacaaccgBatgtHaatgttttgatatccgttatcataStaKRaKgt
+tgNaagagKttgNYMaggaattcagaactcaRataDttaagcttaccttttgVttaWWga
+cYggStacYcgatgcSccaacHcaYNtgRaHtcaYaacHctYacatagatBgtgacDaNg
+atMacgKgBaWagacaSgttaKcatactatatcaHaatataattctggtcNttaYggDRt
+DaSHgNttYaatWagagtagaacKtWtHtBatNtScttttacaattagtaMaatttHgtc
+tagMctaccagagttcaKcStaccKggaggtctgcNatctctDgYccaaVgttgaatgac
+VcatagtgtattttccttcatctacttSgaaStcagHtMaataWNDagtatttttatagg
+catNKataNaMtgctgtttVaacctVBDWattgHttatattaKtatSVSttgtaScgcMc
+ccattgggtagaKMgaSaSttYgcaaMaatVaVaKgtatgYNattcttagWgtcBaaagS
+aaatRatttNctacaStggtYcaaggttBtgaDWBtRtgaaDccacaaaVSatatBcaaS
+cWccgaKttttcgtMaVttgatgtMatacatgNttBaNaagtaggaRaBagaagtaRtaa
+gttacWatgHtttaagSaatgataNWattgtaSggHDtttBataaNNBRaatKWBgtaDc
+BaMaKtctaYatVaKataaaattWYcgtaHcttagtgYtgcKDtccatMSaaagatYcSa
+HatcaDtaatgMMatgcaaatgtttagaDDNtatttgaaKcNtagKYcaBMattaaagtt
+aaWDacgRaRtaKttaaattaVVKaMaBtaKctaaWcatctRMtgKcBaBaaagattHcg
+McgaSNgactaccRatHtaSNtctYcaaBDtaggaagcMatttcaBcDaaatggWtcaHc
+taKtHcHMcRgattgaMtNVaDagttaggcttYctcatDacWDaaaaaKtaBgtBaatca
+ataaKgactgactcNcattMcacatNMattgtaaaNaaacttgctaRtttacttaatKYg
+cttgaSStgtaDaNgtaKgBgMaKgccagtgtMgatHDtgacaWDttHKaDgMacttaKa
+agBtttgtcttaagMagtaHcttWcacaatSatgYtgacHgHcaHDgtagaDccVaKcaa
+taNttccHYctctaSRtaYagtNgDagatWtRttSttNtRNagacatattttatggacta
+cYMagtMacYaagYgVgKgtNtaVcgtgaatcataatcgattYtaaatYtctgBaMgNWN
+KMgDttttaWtaBaaHatNHaDacctccNKtgaVcWattYtgccaVRattMacBtcccNa
+gYttBYNgaBaaaStWacMgcttccatgHaacttYagMtNaaVSYgcgatatHcaatatt
+tgtgBcatWMtaaaaDRttHaBaHttgaacaaataaWaMcaDctgBtatWttaacaaWac
+acWtDtatttatWaaHacaVagVgKaaaDttWgRBVagttVNttctgcttgacatttSHH
+MKScSgSaMtDtaMcgtcaWaacactMcaHWRgaactWtcgcMNcactVDaatHcDSttW
+tagactatgaRNcttagataYgaggaagagcaSHcWtMaKStatgYatttttVaattgtt
+tWataaaDaDgataMcaMtatttctVKaKgcttcctDagtgatWatacaRtttaaaBSMc
+tHaaatcagStatStgaaVttaattatttgctaagcgagaWaaWtccgcaaSgaatVgta
+StMcSNcgtWggMVWNatHctggRtttaacNagtttRtaMBgatatHtaatcMaaaYgat
+MtaccttaagYatcgaaattMataaHatYMcccaaaDaYaVaWgRaHaaaMcHSattcat
+WSatttcaMtgataKBYtactgaNttgaaDactgBatgYgttaagVgaagDagaatttKN
+tgaMtHagtaaHRgaaatttaYtaccNcgWNcKtaYtBMctVBWttttaSagRHBtaHtc
+gtactHggagtaatttaaaVVattWDgtaaHaYgDtaacatDtacWttttttatgccact
+taDtagtaaKgYNcttMNDaBcaVMcMctWgatactaRcaaWagaatgcWcRtattccag
+KgaNgtctcKtWgaNtSttagVaagaSYtcctWatatSgaDaKcactcgBtYacDgMtaK
+ggtKcDtRtRgSaNKctaatHtRDaRgatatacattagtgccSttctDgcgatNcatttc
+HgcKtagcYgttttgNKWRattgBtaaNcRaatcNaagcgaaVKttYtWttaBttttttN
+ggKcgaRBMVtNcNtDVaaMtcBNaKtaataRMcaaaattYactactBattWcgccgWaa
+MtaBYtgtaHagtcttVttaggaHVaaNaNaatcttgtgcattttatMDYKccataScaW
+gNttccttttMaRcVtWHgaaatgBaaRatgcgatataaaWYacYggtacttaaaaDaaa
+ttgatcWaatgtttRcatatcaggaBcttttcttVKatKccaccYtDatMtcttacMtSa
+ttaatatagaatgSgagYgWNtttagtatgRggYKacaatattgggVtttaSaYcaRtBc
+ggtDaggYaaactNataggaggaDgaKcaaataagatMKaattaaNagtagttcWctata
+aDtttcgtcgtattaccStgYgatgKtgcccYatDctYtttttYttaaaagaactcaNVa
+aYaYtccagacBttKcaatKataatKVWcBataaatgttcctatYaacttaSVtgatagg
+VatgagttgatcttacgMMgtWtYtagcacaSctcHYtataattMttataYaaccKgtgt
+aaKcYagaaVtcBKattStgcaaKcaKKaHgtaaBtctgcaattaWgMcgYttMctWtaD
+NcDatggWaattggaVDagKattttgaaaRHattgMaaMgtaatcattctKgNaacaccc
+NHataaaatgaaagagSatKtacVagttggtcgtgcBtgtgcatgagcaacataagKtca
+gtttgtDBBHWcgaDtatYttgattcttaaagcMMttaKgDaHtatVgWHccgatKttca
+aNcYtcaaDWDatcaWtBtWHgctaaMDaDWtWtNKcRRaNttVgHaRgKgcWgattNaa
+attaataNcaRtagtRgaacagataDKgtatScattaDgatcatMtcgYcgtttaaaRct
+cagcRattaacatccStcBtgaccgtgWaaagaaatgaaWtattaVtHacctaccaaatg
+BgtaVVYaaaatccKgtcaactataDgNagtcaSgtKttacHtccMKKWattagtatNct
+attagtttWttRtgaKaBHStgRagattaKRtWaKttaaWaagtaVccctgcgMRWatgt
+tNKgtcSggSHtaBttgtaYaatDtaVtaatgtHcatWaYcMttataVgaaaaagBgaag
+RattccggcttDgggcttcttaacttRgaStaMBaaMtctMBHBacttVgKggcttgcgB
+cBtgDtttcctattaaRcatStNgcKgctatcccacSctcHtaHWtgWaYatgVaRRYtg
+ctaaaatggagacctMcttgttMagBaKctttYWBtaYKgcccYttaMgtHaaNYgtgta
+gagDttcBatgtStttMtBWtaaBctaggaaNgaRgcttttttgtagacRttHSagaatD
+aYgcctMBtgtNSNaaBttgVtWtttKgacaatatVttVatagatttgcgtcgDtVgtSa
+ttaaaVHtaDaatYttatKSWtcattagtaaNatctcagcgtgcKcatDtaBccaaccct
+gaYcattaNaagNaKgagttttcattaHMaVKMDDtaSHScaDattgcaggcccMattat
+acYtMatWgatttcBcBtBctKacccaaWctatccctcaacaataaataaMttgtaHHcg
+atKgaggBtRYattatacgtaYNBacagacaaatVtMcttttRtVcaattgtttgaWtaa
+SacaRccMcaaacttttaaacgtacVBtcWcSaYHgtattacgRtgtgtaKgWgaatcta
+BtcgtgRaaaWWVBcaNtcgctgYtaaaHaSccaagaVMNaacagattaHRaaMWcVgMt
+ctgcatgaagRDattactgcKHtcactYtccttatgHtKgMgKcDtacNtcaStgYccaa
+DagttDtttgYcaagcacWWttaMgccaStaaWtVactgaagtKtttcaWaatgMattat
+KcctctttttcatgtaaactttNcaaKgttttMaMcYtgWctMtttactttagaKtMgtt
+DYttctatagWcRttatYSagacttcaScaacaYtSaattcaaagtgctSaagctattaa
+agggtaactcacgDKgttaMRgggattttMcgttattaVtccaNagaRgMaataaagaSt
+cSaacgtaWttatatHgttHBcgtacggKBtSatDactRggaRgccBRttctaaaatSac
+tcKtttVaWRatatttWaHaKMatgtacatcagctaatggBgaBNSNatatcYStagaat
+SNattaccgtcaataaggYMRtaDaatVgYaDaattataRgVaagtgcaNKtgttgactt
+atHccacHaacVcWcNMDtatcatttttaHacatKtatagtgccWttaattttBSDaKaH
+aDttYacDtBgtMNgggBaaaaattDaaVMaKgatcggKtgtctatctctVatcDtaaga
+agtgtaMcWatDggaaaaaYtcDVtNttcNacgaYtcgatHctctaWgaaggtMttcKtc
+ttaMgtctKNagcRWcgBVtcBDatYKtctaVaaaBgtaRagcacggcaHHagcagaaaa
+acgggtataatcaaWtacYcWtcctaBgVVaBagHaaaaaatataRYagaacgggVtttc
+HaMtNtMgcgaaatKtattaagtMttatcttWttttRaatatgttatgtatttRaagKtB
+gtgHtHDggaBDtWccattcKtttagtttagtBYcDaMBtgatcttgacatKctBcaaaa
+caHtatggaNaVttcgttatttttttcaaDtDDaatcaaaYaaBHttaMKMVgctgWtac
+VtRaaactgYtcatggcVHtgattRttataBtcgaaRataDttaatcattHtatatccNa
+ttcaaHtgKRtRtagtKaRWaataYaggatccacttcacaatgtgatMaggactNaacca
+aMaaKtagaaMctacttDSaaaWSgctcagtWaataWaHtStMacttaDtgagWaaaata
+tttatcaacaactRtDgYcYtatatgtataatWtagccaagcgtttataatDgctgVaaa
+gHaattagaatBWggttctBaNtactHtKBtcgaaaRttHBatDaaKccaSHgtgctWtt
+cBaatcctYttgaHacgtatgagStatRtMaacKacacggaaSctagDagNttgaKKSgt
+ttctacgtagSataHttDctggBcYtttaaatcgRgagagaDtgRSaVStggVtgacgtM
+tatgaaNtWtHgtDaDtgttNaSVagaattccgcttVatatacattatataYtaggYaaa
+RDHttHYDtNgcatHggctattYtaMcWaaVtaNtatttHaagBtatcagatHtttgaaW
+WtttKaaaggBtattHagtaacactDggtattttScttaaaacaStcaacHttMtatcag
+atSaHtaVtBaNYcttHcatgHatagaaggggaWgtgBtttagtVttgacatYtKtatta
+YSggtaaaHgcaggaStHtYcgtaaDWgtaaaMcgYtNHtgNgcttttataWatttKWaa
+KtHattgRtBtMMccgtBtYttgaKaWBatcBgaaacaBgaagatYgKWaaacBgatgtD
+aaacttDcacgatSKtaVaRDWtVKgHtcRattactctattBacaaactaatgDtaatca
+tatKRattSggtcggRMaaHVtgttMcgatatcccgVctKMgBactVtWtBKtgWtaaaV
+aatRgKatttKSaYHtcVBNtgStgtatNStaaccgttaaaaYactBgaaaaattacacV
+ttKattVNgaMattNccctaVtaaStctgaaVatactgtctaaaKYNDtataWtattaaN
+gtHtaWgaBMttttccaaaDcgctgagBacacttctDSctcMtBtNccaacaaatSVtat
+WggagSattKatRBaaaNtNtttagacttaagtHttaatcgtWctHaMBaHtaaagKaaK
+ttgatattttgKcgtcDtgtKtHagDtMtatgatcttgtcSgtWgctaaaaattDaaaNg
+NYtMttNHgtHBataatMgMttctDcgtNtNatggKatHtaaRtRtDStttRVcaatKga
+aRSRtBttatccataaMttagcaaWtagtVgaVBatcVtYtagttgtaMactaaataDat
+agNttttactagcgcKctDatatDgaHtRatVWagaDtttcggSKataacaggaaKggMt
+ttctaVttMaatgattcgaagcgattaNNtYactttKgaatWttNNgctatatgttacKa
+MtaaDgtKgttBttHtDacaagaaRgDgttWtaatgVBcaaccatgcYggtRcctaaDaa
+HcatYNaaVDNtBgtBaattYYgcHttRctattVtattgttcKaaatagtacccttgcVt
+aaHttaagaKtaagSaYtgcacttDattYttaVgRcacaattDDttagattttcHagcca
+YaataKaatccVDKctNcctcaaBccaaBaYgKacWVtWttatgcSatcDHttattaaca
+agaacRSactBHttDaBBBcacgttactHaKgacaKtaWMcHtaVHttaattcgttatat
+BaaagatgaactaaYgDNattNaHgHKtaatcctcttcHttagaatVcagaHtagBgtMa
+taattaagtcSRcatSagMagaaaacgYacgagcacgBcggacaHKaaBatSatagtatc
+DttRHtcagtDtaStYtagaaagtYNHtgaacaatgcgataaNgtNVagtacccctBcga
+YWaactRtDtatttKatBccVKtHttNcttVtgaKMtgcttggcgaNatctcKggtcttt
+tataaacWaBttcgHtcaHtcgatcgcggccaHaagcVgKattBaaWttKcttaVaagYa
+VacagaacgcScDcgatataagttttacaaKcaaaBcYcHKctRagcgaatgtScBagMt
+tYHtaatHcKKtgggatgKSaaatactgWBHVcagHcttVBgYDtaVtcctcatRcVKcN
+aaYaBtattttatRtVtDaaScgtatacMatcaaactagtaKataaatStHtacaagagt
+tgtYatctagaBaHSYtaaataaaStacaHagWSRSDtagtatggctgaKtaRctaaagB
+tactcttatgBcHcNtNRNtHataaccRttagatataaHtacScgtattgttgtDcctaY
+RaattccaNatgtgctaaaactMcaWttgttgVMaSgtaVaSctMcagtcacNaWacgaa
+tWtaRtaatSgatgaaWtaaWcgtttHtWcttgatKtgDtDMcagtcattcacttgaaat
+actWgtattcHttcataactgctgtgtKatRagtaatttYgNcaatcBctgtStaggtaM
+atacgtYaRNtgNaHtNccRtgcSHgRcaatttVcctattaBKtgYtaMaactRaaaaBa
+attHHtatVNWYHaatcagtaMVtttctattWHtttacaaVccDctYtttVtNtRRKtBg
+atHtBcaatHYaSgaagaagHagtttDaVaattVactactYcaDtKttgVVVtaWtggct
+aSttgtaataDctWactcaRttWcMSYtWagaagttctKHcgKtDaYggaDttgtgtata
+acaRKctaacttcYaDtccNaNttaYtaatagRttaSagaatBtVRtaatcttatgcgtW
+tataaWgHataatttYYSttYcggKKtaHcttttagHDDBtggtttaaacatagaRagtV
+agactttacKaWDMacgYaacctgctKaNattggatggNgtKcYSttttcctttDtYttB
+catgattSHaaccVtccatctcccacDBtgaWBaMaaccgttttcttaaMgScBNatBta
+gtcttccttatKBRcctggtVStatagcDgMgtacattacccattKKtaRcRatRctYVa
+SagttatatYtcgNDDggKaHggcccgcRtacgDtcYctgaaacHtatattaVtcaatta
+aatgaWaBggYtHYYaVagWacaNtDtaRattgRacRtacacatgHtagagtaatatttc
+tgDDcttgNDagcctaaHtatYHtKtRaScgtattMttacaacHggttttatSgaHVVga
+attaatagttattactgtRtaWgataMDaaaactgNYacYtagKtaRcaYDHatatVatg
+gctKtWatHaNttaatttttgtaagcctggcgKataaNtttRMNggDtataaaatVcMRa
+taacagctMatBgMtaaVcgagattcaaaSgtgKacgtDHatWaatgttcDtWatgYcWR
+ttcatBSHtttgaatatBgaaWgggaaBcctSSVaagctSctagYatDggtatatgtaat
+atgtatgHYcRtagagtHcgggcataDHattcaaattcRgcaaaataagattcaaYVtaB
+taagRagtttgSRtgRYKgWggtttaaHgcHStgtggtctaHaccaccSaaaattaHatg
+ttVtataccagaatDKVtctagtttcaatgtNctaccgDcacgaattacactatgaaggc
+cKVatccaSWaaKHtttSggatgagMagttgcaatatKYtacBttaccatHRttaactta
+caDKKtaKaDcHHcaYatatgMagaRaNNttcggagYRtacMtHgacttagacBaagggB
+atcttgaRDactgatacatatcSBggtaaaVWgMaatttaYtaWacHattDMtttaaaRR
+ScatcttctaatacagtBVgtgtttBagtatgBNcaagHaaaSaSYKcacMtKatggcac
+gcctSRaagcataattaYacctMaaKtcggaBaVaaWaDMttgccttaaacttDaaHacN
+VtgagaataccactctMttaatcttHcctttaggaKgaggWtaNataYgtaggtgaagtc
+WDcWaBatattRtVgtRgVtataacDDNttatcYaaaagcaVgtYggaDattccgtccDc
+SttaaWtttcaaaatggataSatctRYcaaBctMMtcttaacMaSgDatgagatcaYgct
+cacHccMgaacatcDNgtNRcgBaaatagaYgatgcttRaattStccttgagcctaVaag
+ggatatcagtaNMttaaHcMaatccScBtYaYttatgaMNagtgHaatHacaHaBaaDta
+RNDNcBtagBgacatStagacttgtaatMtYaNaKSaccBtttHcDaHNBttBaacSagg
+agaacgWcMgtRcaagattSctgtaBtcaatMtaHgcaaccataVgtaagDRcDcggaac
+caBtacVMgSttgtcataaaaacaMataHatgttaacaaMgtacgtMVcatagYtKgtgt
+cctaBcYKattcaggBaaHagStcNcattatRRaSYtYDRaHYttttggaRggggttatK
+cVtHgctggaNttaagagBaacattggYaaDcSacggYaRttacaacactcDcacBDtYa
+taaaaDWtctcaggVtaYttKtaVKtDSaMtYtYcgtaacHtRcHctaacBgattttagH
+aScDctHttaaaatVaHttggttatttDtatHtcaHcBagSttttDctttWtctaaataa
+WtHYtRgtBccSaaDSaNgatcSttaaaatgaYgKaaDaVatatYaRaHDtataKaNtag
+tacataggSaatMtctMtccctWgaYtaggataMttcgtacgccYgBSgttaaHgctRgR
+gtDVSRattttttaaKtRMtatSgRaatKacMaYgggtagBgNHcgYRagHcatatgtga
+acMtacSDRMHaaacHaagtWSMcaattcagtDctBattgttcatttMBaDVHVDBtaat
+KactNacgcBYtttgatctatVVtatcKaKSgtaWcgtcgNYatSaRtcaggaRtctatt
+agattKHttYaaBtcacatataattMgtatcataKKatDVtWtaHtHHVaggaaHagWaH
+tattgtDaHRgatgtaaaWaaSStMatttgNtgtcagDWgagaBagtcattaataggagt
+tcagcHttgWagaWcRttaKttaDgaDWtYacMWgRaatatccMtaaattRaatacaKYc
+gcatgtatgtNaccataSttSatttttcgatcttcaaKcMDatgaattcaMWctKNcHtc
+tacaYgatgcaBtDDWtaRtScaYaatYSgBtDcaacYataacgcDgtaacMtSaaKcKt
+tttDVgttgtaaNcaattctcaataaatcSVcKaacattgggacatgaaaacggaggagt
+acDYgatMYttaaaBBctccYgcgagccHattttaWtataYcaKaaDYaaaStMctSatt
+aatataNaWcacaataVtcatacaHcgMgaatYgaataatRcWcgtttcNDYcacaaaca
+caNttttaatctaKtRttHDSttccWatatagtKtgtcgaccaBgtVacNaYBHgtttSS
+agcNtctacctttaacgacaDcWVacSHcaNacatttgBYaaagatWagaacYMatcKgB
+YcBggtaWatataKcNgaaaattHYtSaYDVHSactgttNRgaaaMBtatataaaaacVt
+ctWtgKggtatDBgHaKaHVcMWtYYBaaattaVtcgaaacatggagYKtaaaacagttN
+tttatcatgctagYcctctNgttctgctaYttBataaRtattgatgaaactagttBgagt
+cttccatBagatctBaaagSacagtaaStaaatatataataatcttaactatVtaaBatt
+HcHgcttSSaaDRaKtataagggKaacRagBaggtaMYttggtacMatMttttYttaact
+taBaYaaaatKgtactactKDctcttgaDtMgattgVgcRaaaKattaatataagWgttc
+aWgtcaKtatcgacatDaaSatHtttcagcNtatSggtgtaRtgatttStBaNaHgcagt
+taggggatWtttgattttatcgaBtctaggcgtgtgtWttttaaSaWKctWggtgataaa
+attacBtMRtatccattaaSWttaSMcYtHtaacttaaBaDattctatKatctttcatDt
+cgNcgacttgtaaaattDcaVatRacatgaaagtcctgtctcatacatatcSWgNDttga
+aVKatNacDggagWaaatgaaVNtttBataaagVttVataataYcNMVaNaKaatRMcag
+NacVRactcWgctttNatHaRaBRtaaatRtaKtNgYWattaatcttaRttgttcttaaW
+aaagttcNVtagMaBatcVcgccDaaBMgKttgaVaaccgYtRaactttYtcatgattgt
+WSaaBatagtagSataDgatgNtaWatcaMttaHattagVtggagaNHtaatatctNaag
+aDBatcttttaRaaNtBYagtaacVttYBtaagcaaaMatcNgKaggacagagtgaRatW
+aDaaSaDaaattVgcWttatBNctgSagtctgcSttacSRtgatHDgggcBagccDtatY
+aaagaataDgatDaBttagctatcHtcWtagggagtDtSaaacagtagcttVatgttggc
+StataacttVtaatWKtatDatcttcDaagactgtgDNBaccaattaacaaagaaHWtat
+ttaacattWaatgttcMttaNNcYaRccHtacRagatccKaaYactcVRDtcHVtgaaNa
+SatctRSaWtagagtcgcaataDcagBaagtctSNagaaaKgttataStaatagStaatS
+atataWttctcgtaDgtYRcgtHttaKtcDttRaatNacYgtagVaattNttttatDgKc
+ttttSaaattYcgYBaaggttctagYcBataacVcagggaWtaKtacatgcYcctatccD
+atatagtcRaaaSMgtggaatcaaMaatWcgctagggtcattaVtctaatgHcaSHtcac
+ttBaagaMDtactYgtttgWgacccStDtagaDaBtgctctttKaaaatMttNStggttt
+atWttYttatKMKgtctaKcgaBaaaattcccgacYtBcaKaKttRccaaBaWgMaMatg
+tWtcRDWttcggacNctataaacKaaatHatggDatSaaKtgcgRaaacgtgttcatNtg
+HtcaataaacaaWMKatattcWaKcNaccWtggttcctBaMttgRtggtWtaaVggDgtt
+aDaScgWccWHatacaagtaHtaacttWaNatgtgttaacKaVtcataDMattgtaKcct
+tttttStaaDDtHYattNtcgatataBattctWRatMVtStaSaWttNRacgatagtRcg
+cRtcctttacagBKaaVcYtRaKatVtaWttaVggBBatcaaWatgtggagattDgWttt
+caataDtactRaatBattWVacttWVNtVagHaHtatttaVagtRMMtaBattatataaN
+aagatHBtgtatVtaaacatttagtccaKDcacgWaaHagttVKBgcgRaSYtttVcgaa
+caBatttaatctaSYtccNtcatctatttatBaHcattcaBgDMYtactgScccttRcta
+agtaaNtaaaaattatggtVataaagVStcaatcacgcDaatgtaacatDBagtcgaaRD
+aSactgcagaHgttYatgaVgtNccttcaKHgcgataDcgYtgtgBatcacScgctBcVt
+tttcYaaNtttttatcBaatgataYgtgttgtatgaVcBagtatagtNaRaaatKVtcRt
+cWatctaattgtVgataaMataWagaDttaatRcgctaKHgaRagtDctScatNgHgtKg
+tDtHBVgYcagatgttagcgaataaNBactBaaRaWcRcMctctBtWKaggcaataatSY
+tccagtRtaSVtRgatctaBgDNDtBgtttgtaNtWtaatatDtataacgccDttcaMaM
+atgRtgaaaMHatgBaatgcccDagNgttRDcWtaaaKtMSaBgctgcaatgtSVattRW
+cBtDaaMKRcccWtVttaaatatttctgtcatNBgaaaatHtttWtYtttcaacaaagaa
+NYBaatatctgatNtgaacaaMaaYcNgtgatttWtNaatWcYMScMctaaStttNgHtM
+acgtMDtgagcattcacWtttKttBtKaKcHaBtttaBacgaaNYaaaatBaatNHgaaa
+tMtagatDcaagMtaattctKtgNtScaatagcaHDagtagagSRcagcaagaccYHtaN
+tBatKtStcRagtgttMaYgtgggtNatSaatStcYtaBaSBtaggtctMtatcatgaat
+tactcYtNagaaaDtggaaatKBattaaatcWgKtStKtcaWMggaattYtggccgaWca
+cagaNWaNgaacaYaHgaVtMctVHttaKDcctNccBKMDagtatgcHtttaaaDaggtg
+HtattcatatttaagcBaaaRcSgttaaatgWacRatacaaatgBatYatatRBcacaVa
+taRaKWMcDWtSaatatHattcVgMKYtgtaVBtgagattRgaatgaDgtcaStacgcta
+ggRggtSagKcWYctacaagtttBtgaBttacgaStHgVaStgtaRtacaDccNDattSR
+gttatMtNttttWHacDtttVtgacgYattccWctaagtgaaaMMatgNtctaataRctg
+aacatttVcNtgtttgaggcaaagtatgVgtaVtgRDcttBDtataaMBatatNgataat
+aHaaaNacaStgaNaHgYtgacagtcYDggagattNcaDtKgtagMaacSHRtcagNaga
+tKcatataVatactgRVatgBtatcgttattHtHcKaDtagRagtgHtaDcVtatacatt
+acggcaKttattgacatDaatgtctcattVcaRcttttgDtNHSggcttaYDcHaatcDY
+acccWaMttgRtNggYtttttggDgctacVDtBMgBaDgtMaaBgctBVttVagaHBaaa
+aatgNactaattattNagaagNVaBgVtRgggatacgctgMtgaccatMaaDYDaagctg
+gtcaatggtatBtNtccWtWKcaNcBttactgtgBYDaMtMtcWaatctWYHatccgWta
+taaaNNacNgctYagtaaaRtaaYggcagaMaagggttHaatatcaccVtagtggcgtMt
+agtcaYaaRttWgBtctgaaBtKattaatYtacaatcKcacNcMDtgtactatcDcgRta
+aYagattgccMtgtYKaRaWHgtaccttagcRaWaagDataccagcatcYtcaaSgVaca
+tttaSttSVDSctactgaNctatVattttacgaggWgtaaaKtcNgatgttgcaaNVtta
+gRtttttRttYYaYcaaagcVDMaaRaRtccVcSattttcaattagWattMMctataWat
+ggtaagagRaaattYKKtgatagcMYgcVcgggStattacgBBctNtRgacaacYHctct
+NtataattBttStaRaaaatctgtWatcRacaaMtattYttKtccaatcSttatgtaWtt
+cgcaaWgtWNcBccRgtBagNgYtDctatccMaagtgcYMtYctYttgtcVaaHtatgcB
+aaBcgaataattcttcDaacaaacBtagWYaagcaVacYcKYttgSaKVcttccgcctca
+ttctcaatgVgaaacatWWctgcagtttctttttMagWttatRggcattattVaagaBBt
+tatctattatMcNtaacagttgaaaBaRtaRRtNtataYNtttNtcctaVBtatNtNgBt
+aHHYDttKctaDctcaNcatgDaYatgYagaDcaHgactHgWWaagWtSttctagKaagg
+YtcataYgBtccRaggggaaaHagaacaDatgaaaatcaKtattgWacgtcMSaacYaYg
+cWYNgagtaMgtSccgaaaaaatctggaMMRaaaataatctaaacgatatgDaggaVKct
+tttaatgacBttNYttagtatDagYttWctttNgtHtcVtattHtcHacattatHgNStg
+tSaNaactVMcaatcccBHNatcttDtcgaKccKttatttctVRaagttaMtaYtcttca
+tMYRctttRtaMgSaaaactgWacHagtacccatttcgcatgagtaaagtHcaKgVBtaa
+ttatBtttWatgMctccattgactattcttgtcatSttaaHaVtKtDcatcatatccaac
+KatattatNggNaRatcMSDHRtcctYRaatccacYaatBattcttBVctatatttRNtg
+aNtcaaaRgtaBcttaaDRcgctacWcttgatatctHttttgtNtYatatacgaVBgYHg
+attgggtcgacacDtttKVcaattWRcaagBtgctDKDaYtttcKgNgggtcacVagatM
+gtMVgVgatttcagtcgtgKgtKYgtYSaMtgataatNggattKNgaSggactaaBagat
+aacactcataVgttataaSacaatcRRaagtaDaagDYtcactgtgaVttWtBaMttttg
+aHtKaYtattccagccaaBaggataaRtBatNcatgtatatttcttacaaYVNatagaaa
+gaSaaaagaaatSaBgtcgattacattgWccttHNattataacgVRDtYcWgaaYaVgMt
+tcttgtDtKaYVttctgggSNtaYHWaaHactaaSSagttgSaaactYaMttaMaHVRtc
+gattaccHtcgcgatgNcaYtatattacgcHaaaMNMtaYDgacaggRgaYVtVKcaSVc
+WMBBaWaWcagtatHaWBNaMcBtatccatgaScHtYtgactcattgaYatRtacttYtc
+tttgBgtattaaDtcaHgcNcaVatagtttggggRaaaccWcNNttRBgaaRKgaaNtMa
+agcVacgtgttaaMYWtcBYtgagtaatcgttttaatcgaaaagttDcaatgtggtBaBc
+NtgNatBtggactttagYttBcgttRttatSgacNaDttatRKacactgcSKaVaaaRgH
+aattaaaRctgatKaWcctWggWWagccgaactaYccttgtgaBHggcYttttBccttag
+gaKtaaaBacVDcBYYgaWagaKtaHaaactaNttatagtcttttacgaccctttKattW
+cgHgcaDccctHttatVVaagKaatatgggMaNHagattgNStatBatcgaaYgcVcaga
+atcctcYtBKDatatcNKgacaatKDatgaaacgaaatYYcgNBDtataatMcRWtaagt
+ataHgMaVggcaaDtggttcVattattaaaatSVaMaNcDBttataYgttttStacattg
+agagtccaNtgaatttttKtStatatttRaatttcgBDccctaaSWatttaaMBStcata
+cctgctctatctatKatatgaacaactctWBaNagtcgYaaaaRtctMtDgtaBaacaNt
+acagtcgataNgaVccgtttattatgatctagtDSgaHNcctKtcttatNtgatYKaaSt
+ctWDVcaaccgaVttScaagaaaaVcccggagWatcVaNtVaRcNtcagatcMMatacta
+aaWaagatYHRWcaSagcgMtttatSBtBtBgacRaVgtgattaagtBgtatcgtNgggg
+DaWgagctgatctatttHaactttcgcttttccatttNaaYgtattttactttacttRat
+aBttgatagggacattattaaSaaaYtgatggaDaMttacttatttttttaaWttttaat
+aaWaNaattgtaBtBMcatcNtaaMtDaaaatcRgcatccaMtggWggHggagSttacaY
+HatYtgtaatcatttgVtataaDVttcaYttctHtHtagttWHNYYtVRVccatacaatt
+aaaYatcgcatBagcaatDaWacVaBWattagaaBataatgtKaaaNKcagaactNaaga
+NatgKtBSctgattgWcNaaSataggtataaacVaatDttcRaRtVtVtgtataagMtSc
+caSScagttgatYattcagcMaaWctaagtYcSattNccgtcgtaBtaattgttgacaaa
+DttttattaatacSKtcgcatNttatWatacgRtgcataactYtcacHgVgHttYaataa
+WacgSVKatactagDggcattKctggataagtVgKYtatgttagcgtaRtttaaagacHg
+acacattcHKaMKtcgKtcacggtgatcaaBtMttcttattcttDaKKVgWagtaacatg
+KatVgacattagWtaRtaccRaaVHtttttRtgBccagtcgctagtRtaBcMVWMtaBta
+ggttaYcttagaSgYgttttcaaNNgtttVaagctgStttactaacWattcgtVgtgtKc
+gtYaaaaaKtaSaattgBtYgaVcagKatgaMttWDRatgtaatctagacWaccgcaNgt
+ctgtgagtMttgaaatNtttattaRKcgtaWatcaWccaKtttNactaatNcgVaaBcgR
+gDttcDcatttgagWNattttNaYtttatgcHtttBBacgttgRgtcataNtatatcaWV
+catgaacatRgtNaWaatcaggttaaSctttcaacatHttVKaHtNtMtcttcHattYat
+cgatgtacSaaataVtcttYStaagattDagtKccgaccHBYatMtcggBacatVtaaag
+McttBgtSagKgNttttcNtSaaMaStHgtattttKaRttaMtDtcKtcgagDKgaaaac
+ttaaaWNaattgaWWaaggaaacKtttVggMBcatattDacctaMgaaKgcgcaaMRtaa
+tcgataaatRDttataNtVgtaVDggttaNgatBgtggcaaYWtagctcWgtSaacgtat
+tKcgcBtttDacaaaaaStKMtatNccagKatgtVtHtWaSBgDttgWgaattWagtttt
+aagcctNcttaBtYttaRactaattggagagggtctagtatgggtttacttBtatcatat
+gctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcgtactDtDagcct
+atttSVHtHttKtgtHMaSattgWaHKHttttagacatWatgtRgaaaNtactMcSMtYt
+cMgRtacttctWBacgaaatatagScDtttgaagacacatagtVgYgtcattHWtMMWcS
+tgttaggKtSgaYaaccWStcgBttgcgaMttBYatcWtgacaYcagagtaBDtRacttt
+tcWatMttDBcatWtatcttactaBgaYtcttgttttttttYaaScYaHgtgttNtSatc
+MtcVaaaStccRcctDaataataStcYtRDSaMtDttgttSagtRRcatttHatSttMtW
+gtcgtatSSagactYaaattcaMtWatttaSgYttaRgKaRtccactttattRggaMcDa
+WaWagttttgacatgttctacaaaRaatataataaMttcgDacgaSStacaStYRctVaN
+MtMgtaggcKatcttttattaaaaagVWaHKYagtttttatttaaccttacgtVtcVaat
+tVMBcttaMtttaStgacttagattWWacVtgWYagWVRctDattBYtgtttaagaagat
+tattgacVatMaacattVctgtBSgaVtgWWggaKHaatKWcBScSWaaccRVacacaaa
+ctaccScattRatatKVtactatatttHttaagtttSKtRtacaaagtRDttcaaaaWgc
+acatWaDgtDKacgaacaattacaRNWaatHtttStgttattaaMtgttgDcgtMgcatB
+tgcttcgcgaDWgagctgcgaggggVtaaScNatttacttaatgacagcccccacatYSc
+aMgtaggtYaNgttctgaMaacNaMRaacaaacaKctacatagYWctgttWaaataaaat
+aRattagHacacaagcgKatacBttRttaagtatttccgatctHSaatactcNttMaagt
+attMtgRtgaMgcataatHcMtaBSaRattagttgatHtMttaaKaggYtaaBataSaVa
+tactWtataVWgKgttaaaacagtgcgRatatacatVtHRtVYataSaKtWaStVcNKHK
+ttactatccctcatgWHatWaRcttactaggatctataDtDHBttataaaaHgtacVtag
+aYttYaKcctattcttcttaataNDaaggaaaDYgcggctaaWSctBaaNtgctggMBaK
+ctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacggtttNattgVtt
+tctgtBaWgtaattcaagtcaVWtactNggattctttaYtaaagccgctcttagHVggaY
+tgtNcDaVagctctctKgacgtatagYcctRYHDtgBattDaaDgccKtcHaaStttMcc
+tagtattgcRgWBaVatHaaaataYtgtttagMDMRtaataaggatMtttctWgtNtgtg
+aaaaMaatatRtttMtDgHHtgtcattttcWattRSHcVagaagtacgggtaKVattKYa
+gactNaatgtttgKMMgYNtcccgSKttctaStatatNVataYHgtNaBKRgNacaactg
+atttcctttaNcgatttctctataScaHtataRagtcRVttacDSDttaRtSatacHgtS
+KacYagttMHtWataggatgactNtatSaNctataVtttRNKtgRacctttYtatgttac
+tttttcctttaaacatacaHactMacacggtWataMtBVacRaSaatccgtaBVttccag
+ccBcttaRKtgtgcctttttRtgtcagcRttKtaaacKtaaatctcacaattgcaNtSBa
+accgggttattaaBcKatDagttactcttcattVtttHaaggctKKgatacatcBggSca
+gtVcacattttgaHaDSgHatRMaHWggtatatRgccDttcgtatcgaaacaHtaagtta
+RatgaVacttagattVKtaaYttaaatcaNatccRttRRaMScNaaaDgttVHWgtcHaa
+HgacVaWtgttScactaagSgttatcttagggDtaccagWattWtRtgttHWHacgattB
+tgVcaYatcggttgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcVtaBtWaaYatcD
+RaaRtSctgaHaYRttagatMatgcatttNattaDttaattgttctaaccctcccctaga
+WBtttHtBccttagaVaatMcBHagaVcWcagBVttcBtaYMccagatgaaaaHctctaa
+cgttagNWRtcggattNatcRaNHttcagtKttttgWatWttcSaNgggaWtactKKMaa
+catKatacNattgctWtatctaVgagctatgtRaHtYcWcttagccaatYttWttaWSSt
+taHcaaaaagVacVgtaVaRMgattaVcDactttcHHggHRtgNcctttYatcatKgctc
+ctctatVcaaaaKaaaagtatatctgMtWtaaaacaStttMtcgactttaSatcgDataa
+actaaacaagtaaVctaggaSccaatMVtaaSKNVattttgHccatcacBVctgcaVatV
+ttRtactgtVcaattHgtaaattaaattttYtatattaaRSgYtgBagaHSBDgtagcac
+RHtYcBgtcacttacactaYcgctWtattgSHtSatcataaatataHtcgtYaaMNgBaa
+tttaRgaMaatatttBtttaaaHHKaatctgatWatYaacttMctcttttVctagctDaa
+agtaVaKaKRtaacBgtatccaaccactHHaagaagaaggaNaaatBWattccgStaMSa
+MatBttgcatgRSacgttVVtaaDMtcSgVatWcaSatcttttVatagttactttacgat
+caccNtaDVgSRcgVcgtgaacgaNtaNatatagtHtMgtHcMtagaaattBgtataRaa
+aacaYKgtRccYtatgaagtaataKgtaaMttgaaRVatgcagaKStctHNaaatctBBt
+cttaYaBWHgtVtgacagcaRcataWctcaBcYacYgatDgtDHcctaaagacYRcagga
+ttHaYgtKtaatgcVcaataMYacccatatcacgWDBtgaatcBaatacKcttRaRtgat
+gaBDacggtaattaaYtataStgVHDtDctgactcaaatKtacaatgcgYatBtRaDatH
+aactgtttatatDttttaaaKVccYcaaccNcBcgHaaVcattHctcgattaaatBtatg
+caaaaatYMctSactHatacgaWacattacMBgHttcgaatVaaaacaBatatVtctgaa
+aaWtctRacgBMaatSgRgtgtcgactatcRtattaScctaStagKgaDcWgtYtDDWKR
+gRtHatRtggtcgaHgggcgtattaMgtcagccaBggWVcWctVaaattcgNaatcKWag
+cNaHtgaaaSaaagctcYctttRVtaaaatNtataaccKtaRgtttaMtgtKaBtRtNag
+gaSattHatatWactcagtgtactaKctatttgRYYatKatgtccgtRtttttatttaat
+atVgKtttgtatgtNtataRatWYNgtRtHggtaaKaYtKSDcatcKgtaaYatcSRcta
+VtSMWtVtRWHatttagataDtVggacagVcgKWagBgatBtaaagNcaRtagcataBgg
+actaacacRctKgttaatcctHgDgttKHHagttgttaatgHBtatHcDaagtVaBaRcc
+ctVgtgDtacRHSctaagagcggWYaBtSaKtHBtaaactYacgNKBaVYgtaacttagt
+VttcttaatgtBtatMtMtttaattaatBWccatRtttcatagVgMMtagctStKctaMa
+ctacDNYgKYHgaWcgaHgagattacVgtttgtRaSttaWaVgataatgtgtYtaStatt
+attMtNgWtgttKaccaatagNYttattcgtatHcWtctaaaNVYKKttWtggcDtcgaa
+gtNcagatacgcattaagaccWctgcagcttggNSgaNcHggatgtVtcatNtRaaBNcH
+VagagaaBtaaSggDaatWaatRccaVgggStctDaacataKttKatttggacYtattcS
+atcttagcaatgaVBMcttDattctYaaRgatgcattttNgVHtKcYRaatRKctgtaaa
+cRatVSagctgtWacBtKVatctgttttKcgtctaaDcaagtatcSataWVgcKKataWa
+YttcccSaatgaaaacccWgcRctWatNcWtBRttYaattataaNgacacaatagtttVN
+tataNaYtaatRaVWKtBatKagtaatataDaNaaaaataMtaagaaStccBcaatNgaa
+taWtHaNactgtcDtRcYaaVaaaaaDgtttRatctatgHtgttKtgaaNSgatactttc
+gagWaaatctKaaDaRttgtggKKagcDgataaattgSaacWaVtaNMacKtcaDaaatt
+tctRaaVcagNacaScRBatatctRatcctaNatWgRtcDcSaWSgttRtKaRtMtKaat
+gttBHcYaaBtgatSgaSWaScMgatNtctcctatttctYtatMatMtRRtSaattaMta
+gaaaaStcgVgRttSVaScagtgDtttatcatcatacRcatatDcttatcatVRtttata
+aHtattcYtcaaaatactttgVctagtaaYttagatagtSYacKaaacgaaKtaaataga
+taatSatatgaaatSgKtaatVtttatcctgKHaatHattagaaccgtYaaHactRcggS
+BNgtgctaaBagBttgtRttaaattYtVRaaaattgtaatVatttctcttcatgBcVgtg
+KgaHaaatattYatagWacNctgaaMcgaattStagWaSgtaaKagttttaagaDgatKc
+ctgtaHtcatggKttVDatcaaggtYcgccagNgtgcVttttagagatgctaccacgggg
+tNttttaSHaNtatNcctcatSaaVgtactgBHtagcaYggYVKNgtaKBcRttgaWatg
+aatVtagtcgattYgatgtaatttacDacSctgctaaaStttaWMagDaaatcaVYctcc
+gggcgaVtaaWtStaKMgDtttcaaMtVgBaatccagNaaatcYRMBggttWtaaScKtt
+MWtYataRaDBMaDataatHBcacDaaKDactaMgagttDattaHatHtaYatDtattDc
+RNStgaatattSDttggtattaaNSYacttcDMgYgBatWtaMagactVWttctttgYMa
+YaacRgHWaattgRtaagcattctMKVStatactacHVtatgatcBtVNataaBttYtSt
+tacKgggWgYDtgaVtYgatDaacattYgatggtRDaVDttNactaSaMtgNttaacaaS
+aBStcDctaccacagacgcaHatMataWKYtaYattMcaMtgSttDagcHacgatcaHtt
+YaKHggagttccgatYcaatgatRaVRcaagatcagtatggScctatattaNtagcgacg
+tgKaaWaactSgagtMYtcttccaKtStaacggMtaagNttattatcgtctaRcactctc
+tDtaacWYtgaYaSaagaWtNtatttRacatgNaatgttattgWDDcNaHcctgaaHacS
+gaataaRaataMHttatMtgaSDSKatatHHaNtacagtccaYatWtcactaactatKDa
+cSaStcggataHgYatagKtaatKagStaNgtatactatggRHacttgtattatgtDVag
+DVaRctacMYattDgtttYgtctatggtKaRSttRccRtaaccttagagRatagSaaMaa
+cgcaNtatgaaatcaRaagataatagatactcHaaYKBctccaagaRaBaStNagatagg
+cgaatgaMtagaatgtcaKttaaatgtaWcaBttaatRcggtgNcacaaKtttScRtWtg
+catagtttWYaagBttDKgcctttatMggNttattBtctagVtacataaaYttacacaaR
+ttcYtWttgHcaYYtaMgBaBatctNgcDtNttacgacDcgataaSatYaSttWtcctat
+KaatgcagHaVaacgctgcatDtgttaSataaaaYSNttatagtaNYtaDaaaNtgggga
+cttaBggcHgcgtNtaaMcctggtVtaKcgNacNtatVaSWctWtgaWcggNaBagctct
+gaYataMgaagatBSttctatacttgtgtKtaattttRagtDtacatatatatgatNHVg
+BMtKtaKaNttDHaagatactHaccHtcatttaaagttVaMcNgHatatKtaNtgYMcct
+tatcaaNagctggacStttcNtggcaVtattactHaSttatgNMVattMMDtMactatta
+ttgWMSgtHBttStStgatatRaDaagattttctatMtaaaaaggtactaaVttaSacNa
+atactgMttgacHaHRttgMacaaaatagttaatatWKRgacDgaRtatatttattatcY
+ttaWtgtBRtWatgHaaattHataagtVaDtWaVaWtgStcgtMSgaSRgMKtaaataVa
+cataatgtaSaatttagtcgaaHtaKaatgcacatcggRaggSKctDcagtcSttcccSt
+YtccRtctctYtcaaKcgagtaMttttcRaYDttgttatctaatcataNctctgctatca
+MatactataggDaHaaSttMtaDtcNatataattctMcStaaBYtaNagatgtaatHaga
+gSttgWHVcttatKaYgDctcttggtgttMcRaVgSgggtagacaataaDtaattSaDaN
+aHaBctattgNtaccaaRgaVtKNtaaYggHtaKKgHcatctWtctDtttctttggSDtN
+taStagttataaacaattgcaBaBWggHgcaaaBtYgctaatgaaatWcDcttHtcMtWW
+attBHatcatcaaatctKMagtDNatttWaBtHaaaNgMttaaStagttctctaatDtcR
+VaYttgttMtRtgtcaSaaYVgSWDRtaatagctcagDgcWWaaaBaaRaBctgVgggNg
+DWStNaNBKcBctaaKtttDcttBaaggBttgaccatgaaaNgttttttttatctatgtt
+ataccaaDRaaSagtaVtDtcaWatBtacattaWacttaSgtattggDgKaaatScaatt
+acgWcagKHaaccaYcRcaRttaDttRtttHgaHVggcttBaRgtccctDatKaVtKtcR
+gYtaKttacgtatBtStaagcaattaagaRgBagSaattccSWYtttattVaataNctgH
+gttaaNBgcVYgtRtcccagWNaaaacaDNaBcaaaaRVtcWMgBagMtttattacgDac
+ttBtactatcattggaaatVccggttRttcatagttVYcatYaSHaHcttaaagcNWaHa
+taaaRWtctVtRYtagHtaaaYMataHYtNBctNtKaatattStgaMcBtRgctaKtgcS
+cSttDgYatcVtggaaKtaagatWccHccgKYctaNNctacaWcttttgcRtgtVcgaKt
+tcMRHgctaHtVaataaDtatgKDcttatBtDttggNtacttttMtgaacRattaaNaga
+actcaaaBBVtcDtcgaStaDctgaaaSgttMaDtcgttcaccaaaaggWtcKcgSMtcD
+tatgtttStaaBtatagDcatYatWtaaaBacaKgcaDatgRggaaYctaRtccagattD
+aWtttggacBaVcHtHtaacDacYgtaatataMagaatgHMatcttatacgtatttttat
+attacHactgttataMgStYaattYaccaattgagtcaaattaYtgtatcatgMcaDcgg
+gtcttDtKgcatgWRtataatatRacacNRBttcHtBgcRttgtgcgtcatacMtttBct
+atctBaatcattMttMYgattaaVYatgDaatVagtattDacaacDMatcMtHcccataa
+gatgBggaccattVWtRtSacatgctcaaggggYtttDtaaNgNtaaBatggaatgtctR
+taBgBtcNYatatNRtagaacMgagSaSDDSaDcctRagtVWSHtVSRggaacaBVaccg
+tttaStagaacaMtactccagtttVctaaRaaHttNcttagcaatttattaatRtaaaat
+ctaacDaBttggSagagctacHtaaRWgattcaaBtctRtSHaNtgtacattVcaHaNaa
+gtataccacaWtaRtaaVKgMYaWgttaKggKMtKcgWatcaDatYtKSttgtacgaccN
+ctSaattcDcatcttcaaaDKttacHtggttHggRRaRcaWacaMtBWVHSHgaaMcKat
+tgtaRWttScNattBBatYtaNRgcggaagacHSaattRtttcYgaccBRccMacccKga
+tgaacttcgDgHcaaaaaRtatatDtatYVtttttHgSHaSaatagctNYtaHYaVYtta
+ttNtttgaaaYtaKttWtctaNtgagaaaNctNDctaaHgttagDcRttatagccBaacg
+caRBtRctRtggtaMYYttWtgataatcgaataattattataVaaaaattacNRVYcaaM
+acNatRttcKatMctgaagactaattataaYgcKcaSYaatMNctcaacgtgatttttBa
+cNtgatDccaattattKWWcattttatatatgatBcDtaaaagttgaaVtaHtaHHtBta
+taRBgtgDtaataMttRtDgDcttattNtggtctatctaaBcatctaRatgNacWtaatg
+aagtcMNaacNgHttatactaWgcNtaStaRgttaaHacccgaYStacaaaatWggaYaW
+gaattattcMaactcBKaaaRVNcaNRDcYcgaBctKaacaaaaaSgctccYBBHYaVag
+aatagaaaacagYtctVccaMtcgtttVatcaatttDRtgWctagtacRttMctgtDctt
+tcKtWttttataaatgVttgBKtgtKWDaWagMtaaagaaattDVtaggttacatcattt
+atgtcgMHaVcttaBtVRtcgtaYgBRHatttHgaBcKaYWaatcNSctagtaaaaattt
+acaatcactSWacgtaatgKttWattagttttNaggtctcaagtcactattcttctaagK
+ggaataMgtttcataagataaaaatagattatDgcBVHWgaBKttDgcatRHaagcaYcR
+aattattatgtMatatattgHDtcaDtcaaaHctStattaatHaccgacNattgatatat
+tttgtgtDtRatagSacaMtcRtcattcccgacacSattgttKaWattNHcaacttccgt
+ttSRtgtctgDcgctcaaMagVtBctBMcMcWtgtaacgactctcttRggRKSttgYtYa
+tDccagttDgaKccacgVatWcataVaaagaataMgtgataaKYaaatcHDaacgataYc
+tRtcYatcgcaMgtNttaBttttgatttaRtStgcaacaaaataccVgaaDgtVgDcStc
+tatatttattaaaaRKDatagaaagaKaaYYcaYSgKStctccSttacagtcNactttDV
+ttagaaagMHttRaNcSaRaMgBttattggtttaRMggatggcKDgWRtNaataataWKK
+acttcKWaaagNaBttaBatMHtccattaacttccccYtcBcYRtagattaagctaaYBD
+ttaNtgaaaccHcaRMtKtaaHMcNBttaNaNcVcgVttWNtDaBatgataaVtcWKctt
+RggWatcattgaRagHgaattNtatttctctattaattaatgaDaaMatacgttgggcHa
+YVaaNaDDttHtcaaHtcVVDgBVagcMacgtgttaaBRNtatRtcagtaagaggtttaa
+gacaVaaggttaWatctccgtVtaDtcDatttccVatgtacNtttccgtHttatKgScBa
+tgtVgHtYcWagcaKtaMYaaHgtaattaSaHcgcagtWNaatNccNNYcacgVaagaRa
+cttctcattcccRtgtgtaattagcSttaaStWaMtctNNcSMacattataaactaDgta
+tWgtagtttaagaaaattgtagtNagtcaataaatttgatMMYactaatatcggBWDtVc
+YttcDHtVttatacYaRgaMaacaStaatcRttttVtagaDtcacWatttWtgaaaagaa
+agNRacDtttStVatBaDNtaactatatcBSMcccaSttccggaMatgattaaWatKMaB
+aBatttgataNctgttKtVaagtcagScgaaaDggaWgtgttttKtWtatttHaatgtag
+ttcactaaKMagttSYBtKtaYgaactcagagRtatagtVtatcaaaWYagcgNtaDagt
+acNSaaYDgatBgtcgataacYDtaaactacagWDcYKaagtttattagcatcgagttKc
+atDaattgattatDtcagRtWSKtcgNtMaaaaacaMttKcaWcaaSVMaaaccagMVta
+MaDtMaHaBgaacataBBVtaatVYaNSWcSgNtDNaaKacacBtttatKtgtttcaaHa
+MctcagtaacgtcgYtactDcgcctaNgagagcYgatattttaaatttccattttacatt
+tDaaRctattttWctttacgtDatYtttcagacgcaaVttagtaaKaaaRtgVtccataB
+ggacttatttgtttaWNtgttVWtaWNVDaattgtatttBaagcBtaaBttaaVatcHca
+VgacattccNggtcgacKttaaaRtagRtctWagaYggtgMtataatMtgaaRttatttt
+gWcttNtDRRgMDKacagaaaaggaaaRStcccagtYccVattaNaaKStNWtgacaVta
+gaagcttSaaDtcacaacgDYacWDYtgtttKatcVtgcMaDaSKStVcgtagaaWaKaa
+gtttcHaHgMgMtctataagBtKaaaKKcactggagRRttaagaBaaNatVVcgRcKStt
+DaactagtSttSattgttgaaRYatggttVttaataaHttccaagDtgatNWtaagHtgc
+YtaactRgcaatgMgtgtRaatRaNaacHKtagactactggaatttcgccataacgMctR
+gatgttaccctaHgtgWaYcactcacYaattcttaBtgacttaaacctgYgaWatgBttc
+ttVttcgttWttMcNYgtaaaatctYgMgaaattacNgaHgaacDVVMtttggtHtctaa
+RgtacagacgHtVtaBMNBgattagcttaRcttacaHcRctgttcaaDBggttKaacatg
+KtttYataVaNattccgMcgcgtagtRaVVaattaKaatggttRgaMcagtatcWBttNt
+HagctaatctagaaNaaacaYBctatcgcVctBtgcaaagDgttVtgaHtactSNYtaaN
+ccatgtgDacgaVtDcgKaRtacDcttgctaagggcagMDagggtBWRtttSgccttttt
+taacgtcHctaVtVDtagatcaNMaVtcVacatHctDWNaataRgcgtaVHaggtaaaaS
+gtttMtattDgBtctgatSgtRagagYtctSaKWaataMgattRKtaacatttYcgtaac
+acattRWtBtcggtaaatMtaaacBatttctKagtcDtttgcBtKYYBaKttctVttgtt
+aDtgattttcttccacttgSaaacggaaaNDaattcYNNaWcgaaYattttMgcBtcatR
+tgtaaagatgaWtgaccaYBHgaatagataVVtHtttVgYBtMctaMtcctgaDcYttgt
+ccaaaRNtacagcMctKaaaggatttacatgtttaaWSaYaKttBtagDacactagctMt
+ttNaKtctttcNcSattNacttggaacaatDagtattRtgSHaataatgccVgacccgat
+actatccctgtRctttgagaSgatcatatcgDcagWaaHSgctYYWtatHttggttcttt
+atVattatcgactaagtgtagcatVgtgHMtttgtttcgttaKattcMatttgtttWcaa
+StNatgtHcaaaDtaagBaKBtRgaBgDtSagtatMtaacYaatYtVcKatgtgcaacVa
+aaatactKcRgtaYtgtNgBBNcKtcttaccttKgaRaYcaNKtactttgagSBtgtRag
+aNgcaaaNcacagtVtttHWatgttaNatBgtttaatNgVtctgaatatcaRtattcttt
+tttttRaaKcRStctcggDgKagattaMaaaKtcaHacttaataataKtaRgDtKVBttt
+tcgtKaggHHcatgttagHggttNctcgtatKKagVagRaaaggaaBtNatttVKcRtta
+HctaHtcaaatgtaggHccaBataNaNaggttgcWaatctgatYcaaaHaatWtaVgaaB
+ttagtaagaKKtaaaKtRHatMaDBtBctagcatWtatttgWttVaaaScMNattRactt
+tgtYtttaaaagtaagtMtaMaSttMBtatgaBtttaKtgaatgagYgtNNacMtcNRac
+MMHcttWtgtRtctttaacaacattattcYaMagBaacYttMatcttKcRMtgMNccatt
+aRttNatHaHNaSaaHMacacaVaatacaKaSttHatattMtVatWgattttttaYcttt
+KttHgScWaacgHtttcaVaaMgaacagNatcgttaacaaaaagtacaHBNaattgttKt
+cttVttaaBtctgctacgBgcWtttcaggacacatMgacatcccagcggMgaVKaBattg
+acttaatgacacacaaaaaatRKaaBctacgtRaDcgtagcVBaacDSBHaaaaSacata
+tacagacRNatcttNaaVtaaaataHattagtaaaaSWccgtatWatggDttaactattg
+cccatcttHaSgYataBttBaactattBtcHtgatcaataSttaBtatKSHYttWggtcY
+tttBttaataccRgVatStaHaKagaatNtagRMNgtcttYaaSaactcagDSgagaaYt
+MttDtMRVgWKWtgMaKtKaDttttgactatacataatcNtatNaHattVagacgYgata
+tatttttgtStWaaatctWaMgagaRttRatacgStgattcttaagaDtaWccaaatRca
+gcagaaNKagtaaDggcgccBtYtagSBMtactaaataMataBSacRMgDgattMMgtcH
+tcaYDtRaDaacggttDaggcMtttatgttaNctaattaVacgaaMMtaatDccSgtatt
+gaRtWWaccaccgagtactMcgVNgctDctaMScatagcgtcaactatacRacgHRttgc
+tatttaatgaattataYKttgtaagWgtYttgcHgMtaMattWaWVtaRgcttgYgttBH
+tYataSccStBtgtagMgtDtggcVaaSBaatagDttgBgtctttctcattttaNagtHK
+taMWcYactVcgcgtatMVtttRacVagDaatcttgctBBcRDgcaacKttgatSKtYta
+gBMagaRtcgBattHcBWcaactgatttaatttWDccatttatcgagSKaWttataHact
+aHMttaatHtggaHtHagaatgtKtaaRactgtttMatacgatcaagDgatKaDctataM
+ggtHDtggHacctttRtatcttYattttgacttgaaSaataaatYcgBaaaaccgNatVB
+ttMacHaKaataagtatKgtcaagactcttaHttcggaattgttDtctaaccHttttWaa
+atgaaatataaaWattccYDtKtaaaacggtgaggWVtctattagtgactattaagtMgt
+ttaagcatttgSgaaatatccHaaggMaaaattttcWtatKctagDtYtMcctagagHca
+ctttactatacaaacattaacttaHatcVMYattYgVgtMttaaRtgaaataaDatcaHg
+tHHatKcDYaatcttMtNcgatYatgSaMaNtcttKcWataScKggtatcttacgcttWa
+aagNatgMgHtctttNtaacVtgttcMaaRatccggggactcMtttaYMtcWRgNctgNc
+cKatcttgYDcMgattNYaRagatHaaHgKctcataRDttacatBatccattgDWttatt
+taWgtcggagaaaaatacaatacSNtgggtttccttacSMaagBattacaMaNcactMtt
+atgaRBacYcYtcaaaWtagctSaacttWgDMHgaggatgBVgcHaDtggaactttggtc
+NatNgtaKaBcccaNtaagttBaacagtatacDYttcctNgWgcgSMcacatStctHatg
+RcNcgtacacaatRttMggaNKKggataaaSaYcMVcMgtaMaHtgattYMatYcggtct
+tcctHtcDccgtgRatcattgcgccgatatMaaYaataaYSggatagcgcBtNtaaaSca
+KgttBgagVagttaKagagtatVaactaSacWactSaKatWccaKaaaatBKgaaKtDMa
+ttttgtaaatcRctMatcaaMagMttDgVatggMaaWgttcgaWatgaaatttgRtYtat
+taWHKcRgctacatKttctaccaaHttRatctaYattaaWatVNccatNgagtcKttKat
+aStRaatatattcctRWatDctVagttYDgSBaatYgttttgtVaatttaatagcagMat
+RaacttBctattgtMagagattaaactaMatVtHtaaatctRgaaaaaaaatttWacaac
+aYccYDSaattMatgaccKtaBKWBattgtcaagcHKaagttMMtaatttcKcMagNaaK
+agattggMagaggtaatttYacatcWaaDgatMgKHacMacgcVaacaDtaDatatYggt
+tBcgtatgWgaSatttgtagaHYRVacaRtctHaaRtatgaactaatatctSSBgggaaH
+MWtcaagatKgagtDaSatagttgattVRatNtctMtcSaagaSHaataNataataRaaR
+gattctttaataaagWaRHcYgcatgtWRcttgaaggaMcaataBRaaccagStaaacNt
+ttcaatataYtaatatgHaDgcStcWttaacctaRgtYaRtataKtgMttttatgactaa
+aatttacYatcccRWtttHRtattaaatgtttatatttgttYaatMcaRcSVaaDatcgt
+aYMcatgtagacatgaaattgRtcaaYaaYtRBatKacttataccaNaaattVaBtctgg
+acaagKaaYaaatatWtMtatcYaaVNtcgHaactBaagKcHgtctacaatWtaDtSgta
+HcataHtactgataNctRgttMtDcDttatHtcgtacatcccaggSttaBgtcacacWtc
+cNMcNatMVaVgtccDYStatMaccDatggYaRKaaagataRatttHKtSaaatDgataa
+acttaHgttgVBtcttVttHgDacgaKatgtatatNYataactctSatatatattgcHRR
+YttStggaactHgttttYtttaWtatMcttttctatctDtagVHYgMRBgtHttcctaat
+YRttKtaagatggaVRataKDctaMtKBNtMtHNtWtttYcVtattMcgRaacMcctNSc
+tcatttaaagDcaHtYccSgatgcaatYaaaaDcttcgtaWtaattctcgttttScttgg
+taatctttYgtctaactKataHacctMctcttacHtKataacacagcNRatgKatttttS
+aaatRYcgDttaMRcgaaattactMtgcgtaagcgttatBtttttaattaagtNacatHg
+ttcRgacKcBBtVgatKttcgaBaatactDRgtRtgaNacWtcacYttaaKcgttctHaK
+ttaNaMgWgWaggtctRgaKgWttSttBtDcNtgtttacaaatYcDRtgVtgcctattcN
+tctaaaDMNttttNtggctgagaVctDaacVtWccaagtaacacaNctgaScattccDHc
+VBatcgatgtMtaatBgHaatDctMYgagaatgYWKcctaatNaStHaaaKccgHgcgtY
+aaYtattgtStgtgcaaRtattaKatattagaWVtcaMtBagttattagNaWHcVgcaat
+tttDcMtgtaRHVYtHtctgtaaaaHVtMKacatcgNaatttMatatgttgttactagWY
+taRacgataKagYNKcattataNaRtgaacKaYgcaaYYacaNccHatMatDcNgtHttR
+aWttagaaDcaaaaaatagggtKDtStaDaRtaVtHWKNtgtattVctSVgRgataDaRa
+WataBgaagaaKtaataaYgDcaStaNgtaDaaggtattHaRaWMYaYaWtggttHYgag
+VtgtgcttttcaaDKcagVcgttagacNaaWtagtaataDttctggttVcatcataaagt
+gKaaaNaMtaBBaattaatWaattgctHaVKaSgDaaVKaHtatatatHatcatSBagNg
+HtatcHYMHgttDgtaHtBttWatcgtttaRaattgStKgSKNWKatcagDtctcagatt
+tctRtYtBatBgHHtKaWtgYBgacVVWaKtacKcDttKMaKaVcggtgttataagaata
+aHaatattagtataatMHgttYgaRttagtaRtcaaVatacggtcMcgagtaaRttacWg
+actKRYataaaagSattYaWgagatYagKagatgSaagKgttaatMggtataatgttWYt
+tatgagaaacctNVataatHcccKtDctcctaatactggctHggaSaggRtKHaWaattc
+gSatMatttagaggcYtctaMcgctcataSatatgRagacNaaDaggaVBagaYttKtac
+NaKgtSYtagttggaWcatcWttaatctatgaVtcgtgtMtatcaYcgtRccaaYgDctg
+cMgtgtWgacWtgataacacgcgctBtgttaKtYDtatDcatcagKaVMctaatcttgVc
+aaRgcRMtDcgattaHttcaNatgaatMtactacVgtRgatggaWtttactaaKatgagS
+aaKggtaNtactVaYtaaKRagaacccacaMtaaMtKtatBcttgtaaWBtMctaataaV
+cDaaYtcRHBtcgttNtaaHatttBNgRStVDattBatVtaagttaYatVattaagaBca
+cggtSgtVtatttaRattgatgtaHDKgcaatattKtggcctatgaWDKRYcggattgRc
+tatNgatacaatMNttctgtcRBYRaaaHctNYattcHtaWcaattctBtMKtVgYataa
+tMgYtcagcttMDataVtggRtKtgaatgccNcRttcaMtRgattaacattRcagcctHt
+WMtgtDRagaKaBtgDttYaaaaKatKgatctVaaYaacWcgcatagBVtaNtRtYRagg
+BaaBtgKgttacataagagcatgtRattccacttaccatRaaatgWgDaMHaYVgVtaSc
+tatcgKaatatattaDgacccYagtgtaYNaaatKcagtBRgagtccatgKgaaaccBga
+agBtgSttWtacgatWHaYatcgatttRaaNRgcaNaKVacaNtDgattgHVaatcDaag
+cgtatgcNttaDataatcSataaKcaataaHWataBtttatBtcaKtKtatagttaDgSa
+YctacaRatNtaWctSaatatttYaKaKtaccWtatcRagacttaYttVcKgSDcgagaa
+gatccHtaattctSttatggtKYgtMaHagVaBRatttctgtRgtctatgggtaHKgtHa
+cHtSYacgtacacHatacKaaBaVaccaDtatcSaataaHaagagaatScagactataaR
+ttagcaaVcaHataKgDacatWccccaagcaBgagWatctaYttgaaatctVNcYtttWa
+gHcgcgcDcVaaatgttKcHtNtcaatagtgtNRaactttttcaatggWgBcgDtgVgtt
+tctacMtaaataaaRggaaacWaHttaRtNtgctaaRRtVBctYtVtatDcattDtgacc
+YatagatYRKatNYKttNgcctagtaWtgaactaMVaacctgaStttctgaKVtaaVaRK
+DttVtVctaDNtataaaDtccccaagtWtcgatcactDgYaBcatcctMtVtacDaaBtY
+tMaKNatNtcaNacgDatYcatcgcaRatWBgaacWttKttagYtaattcggttgSWttt
+tDWctttacYtatatWtcatDtMgtBttgRtVDggttaacYtacgtacatgaattgaaWc
+ttMStaDgtatattgaDtcRBcattSgaaVBRgagccaaKtttcDgcgaSMtatgWatta
+KttWtgDBMaggBBttBaatWttRtgcNtHcgttttHtKtcWtagHStaacagttgatat
+BtaWSaWggtaataaMttaKacDaatactcBttcaatatHttcBaaSaaatYggtaRtat
+NtHcaatcaHtagVtgtattataNggaMtcttHtNagctaaaggtagaYctMattNaMVN
+tcKtactBKcaHHcBttaSagaKacataYgctaKaYgttYcgacWVttWtSagcaacatc
+ccHaccKtcttaacgaKttcacKtNtacHtatatRtaaatacactaBtttgaHaRttggt
+tWtatYagcatYDatcggagagcWBataagRtacctataRKgtBgatgaDatataSttag
+BaHtaatNtaDWcWtgtaattacagKttcNtMagtattaNgtctcgtcctcttBaHaKcK
+ccgtRcaaYagSattaagtKataDatatatagtcDtaacaWHcaKttDgaaRcgtgYttg
+tcatatNtatttttatggccHtgDtYHtWgttatYaacaattcaWtatNgctcaaaSttR
+gctaatcaaatNatcgtttaBtNNVtgttataagcaaagattBacgtDatttNatttaaa
+DcBgtaSKgacgtagataatttcHMVNttgttBtDtgtaWKaaRMcKMtHtaVtagataW
+ctccNNaSWtVaHatctcMgggDgtNHtDaDttatatVWttgttatttaacctttcacaa
+ggaSaDcggttttttatatVtctgVtaacaStDVaKactaMtttaSNagtgaaattaNac
+ttSKctattcctctaSagKcaVttaagNaVcttaVaaRNaHaaHttatgtHttgtgatMc
+caggtaDcgaccgtWgtWMtttaHcRtattgScctatttKtaaccaagtYagaHgtWcHa
+atgccKNRtttagtMYSgaDatctgtgaWDtccMNcgHgcaaacNDaaaRaStDWtcaaa
+aHKtaNBctagBtgtattaactaattttVctagaatggcWSatMacccttHttaSgSgtg
+MRcatRVKtatctgaaaccDNatYgaaVHNgatMgHRtacttaaaRtatStRtDtatDtt
+YatattHggaBcttHgcgattgaKcKtttcRataMtcgaVttWacatNcatacctRataD
+DatVaWNcggttgaHtgtMacVtttaBHtgagVttMaataattatgttcttagtttgtgc
+DtSatttgBtcaacHattaaBagVWcgcaSYttMgcttacYKtVtatcaYaKctgBatgc
+gggcYcaaaaacgNtctagKBtattatctttKtaVttatagtaYtRagNtaYataaVtga
+atatcHgcaaRataHtacacatgtaNtgtcgYatWMatttgaactacRctaWtWtataca
+atctBatatgYtaagtatgtgtatSttactVatcttYtaBcKgRaSggRaaaaatgcagt
+aaaWgtaRgcgataatcBaataccgtatttttccatcNHtatWYgatHSaaaDHttgctg
+tccHtggggcctaataatttttctatattYWtcattBtgBRcVttaVMRSgctaatMagt
+YtttaaaaatBRtcBttcaaVtaacagctccSaaSttKNtHtKYcagcagaaaccccRtt
+tttaaDcDtaStatccaagcgctHtatcttaDRYgatDHtWcaaaBcWgKWHttHataag
+HacgMNKttMKHccaYcatMVaacgttaKgYcaVaaBtacgcaactttMctaaHaatgtB
+atgagaSatgtatgSRgHgWaVWgataaatatttccKagVgataattWaHNcYggaaatg
+ctHtKtaDtctaaagtMaatVDVactWtSaaWaaMtaHtaSKtcBRaNcttStggtBtta
+cNagcatagRgtKtgcgaacaacBcgKaatgataagatgaaaattgtactgcgggtccHH
+WHaaNacaBttNKtKtcaaBatatgctaHNgtKcDWgtttatNgVDHgaccaacWctKaa
+ggHttgaRgYaatHcaBacaatgagcaaattactgtaVaaYaDtagattgagNKggtggt
+gKtWKaatacagDRtatRaMRtgattDggtcaaYRtatttNtagaDtcacaaSDctDtat
+aatcgtactaHttatacaatYaacaaHttHatHtgcgatRRttNgcatSVtacWWgaagg
+agtatVMaVaaattScDDKNcaYBYaDatHgtctatBagcaacaagaatgagaaRcataa
+KNaRtBDatcaaacgcattttttaaBtcSgtacaRggatgtMNaattggatatWtgagta
+ttaaaVctgcaYMtatgatttttYgaHtgtcttaagWBttHttgtcttattDtcgtatWt
+ataataSgctaHagcDVcNtaatcaagtaBDaWaDgtttagYctaNccDtaKtaHcttaa
+taacccaRKtacaVaatNgcWRaMgaattatgaBaaagattVYaHMDcaDHtcRcgYtct
+taaaWaaaVKgatacRtttRRKYgaatacaWVacVcRtatMacaBtactggMataaattt
+tHggNagSctacHgtBagcgtcgtgattNtttgatSaaggMttctttcttNtYNagBtaa
+acaaatttMgaccttacataattgYtcgacBtVMctgStgMDtagtaRctHtatgttcat
+atVRNWataDKatWcgaaaaagttaaaagcacgHNacgtaatctttMRtgacttttDacc
+tataaacgaaatatgattagaactccSYtaBctttaataacWgaaaYatagatgWttcat
+KtNgatttttcaagHtaYgaaRaDaagtaggagcttatVtagtctttcattaaaatcgKt
+attaRttacagVaDatgcatVgattgggtctttHVtagKaaRBtaHtaaggccccaaaaK
+atggtttaMWgtBtaaacttcactttKHtcgatctccctaYaBacMgtcttBaBaNgcga
+aacaatctagtHccHtKttcRtRVttccVctttcatacYagMVtMcagaMaaacaataBc
+tgYtaatRaaagattaaccatVRatHtaRagcgcaBcgDttStttttcVtttaDtKgcaa
+WaaaaatSccMcVatgtKgtaKgcgatatgtagtSaaaDttatacaaacatYaRRcVRHc
+tKtcgacKttaaVctaDaatgttMggRcWaacttttHaDaKaDaBctgtaggcgtttaHB
+ccatccattcNHtDaYtaataMttacggctNVaacDattgatattttacVttSaattaca
+aRtataNDgacVtgaacataVRttttaDtcaaacataYDBtttaatBaDtttYDaDaMcc
+MttNBttatatgagaaMgaNtattHccNataattcaHagtgaaggDgatgtatatatgYa
+tgaStcataaBStWacgtcccataRMaaDattggttaaattcMKtctMacaBSactcgga
+atDDgatDgcWctaacaccgggaVcacWKVacggtaNatatacctMtatgatagtgcaKa
+gggVaDtgtaacttggagtcKatatcgMcttRaMagcattaBRaStctYSggaHYtacaa
+ctMBaagDcaBDRaaacMYacaHaattagcattaaaHgcgctaaggSccKtgaaKtNaBt
+atDDcKBSaVtgatVYaagVtctSgMctacgttaacWaaattctSgtDactaaStaaatt
+gcagBBRVctaatatacctNttMcRggctttMttagacRaHcaBaacVKgaataHttttM
+gYgattcYaNRgttMgcVaaacaVVcDHaatttgKtMYgtatBtVVctWgVtatHtacaa
+HttcacgatagcagtaaNattBatatatttcVgaDagcggttMaagtcScHagaaatgcY
+NggcgtttttMtStggtRatctacttaaatVVtBacttHNttttaRcaaatcacagHgag
+agtMgatcSWaNRacagDtatactaaDKaSRtgattctccatSaaRttaaYctacacNta
+RtaactggatgaccYtacactttaattaattgattYgttcagDtNKttagDttaaaaaaa
+BtttaaNaYWKMBaaaacVcBMtatWtgBatatgaacVtattMtYatMNYDKNcKgDttD
+aVtaaaatgggatttctgtaaatWtctcWgtVVagtcgRgacttcccctaDcacagcRca
+gagtgtWSatgtacatgttaaSttgtaaHcgatgggMagtgaacttatRtttaVcaccaW
+aMgtactaatSSaHtcMgaaYtatcgaaggYgggcgtgaNDtgttMNgaNDMtaattcgV
+ttttaacatgVatgtWVMatatcaKgaaattcaBcctccWcttgaaWHtWgHtcgNWgaR
+gctcBgSgaattgcaaHtgattgtgNagtDttHHgBttaaWcaaWagcaSaHHtaaaVct
+RaaMagtaDaatHtDMtcVaWMtagSagcttHSattaacaaagtRacMtRtctgttagcM
+tcaBatVKtKtKacgagaSNatSactgtatatcBctgagVtYactgtaaattaaaggcYg
+DHgtaacatSRDatMMccHatKgttaacgactKtgKagtcttcaaHRVtccttKgtSata
+atttacaactggatDNgaacttcaRtVaagDcaWatcBctctHYatHaDaaatttagYat
+SatccaWtttagaaatVaacBatHcatcgtacaatatcgcNYRcaataYaRaYtgattVt
+tgaatgaVaactcRcaNStgtgtattMtgaggtNttBaDRcgaaaagctNgBcWaWgtSa
+DcVtgVaatMKBtttcgtttctaaHctaaagYactgMtatBDtcStgaccgtSDattYaa
+taHctgggaYYttcggttaWaatctggtRagWMaDagtaacBccactacgHWMKaatgat
+WatcctgHcaBaSctVtcMtgtDttacctaVgatYcWaDRaaaaRtagatcgaMagtgga
+RaWctctgMgcWttaagKBRtaaDaaWtctgtaagYMttactaHtaatcttcataacggc
+acBtSgcgttNHtgtHccatgttttaaagtatcgaKtMttVcataYBBaKtaMVaVgtat
+tNDSataHcagtWMtaggtaSaaKgttgBtVtttgttatcatKcgHacacRtctHatNVa
+gSBgatgHtgaRaSgttRcctaacaaattDNttgacctaaYtBgaaaatagttattactc
+ttttgatgtNNtVtgtatMgtcttRttcatttgatgacacttcHSaaaccaWWDtWagta
+RDDVNacVaRatgttBccttaatHtgtaaacStcVNtcacaSRttcYagacagaMMtttt
+gMcNttBcgWBtactgVtaRttctccaaYHBtaaagaBattaYacgatttacatctgtaa
+MKaRYtttttactaaVatWgctBtttDVttctggcDaHaggDaagtcgaWcaagtagtWt
+tHtgKtVataStccaMcWcaagataagatcactctHatgtcYgaKcatcagatactaagN
+SStHcctRRNtattgtccttagttagMVgtatagactaactctVcaatMctgtttgtgtt
+gccttatWgtaBVtttctggMcaaKgDWtcgtaaYStgSactatttHgatctgKagtagB
+tVacRaagRtMctatgggcaaaKaaaatacttcHctaRtgtDcttDattaggaaatttcY
+HaRaaBttaatggcacKtgctHVcaDcaaaVDaaaVcgMttgtNagcgtaDWgtcgttaa
+tDgKgagcSatatcSHtagtagttggtgtHaWtaHKtatagctgtVgattaBVaatgaat
+aagtaatVatSttaHctttKtttgtagttaccttaatcgtagtcctgBcgactatttVcM
+acHaaaggaatgDatggKtaHtgStatattaaSagctWcctccRtataBaDYcgttgcNa
+agaggatRaaaYtaWgNtSMcaatttactaacatttaaWttHtatBattgtcgacaatNg
+attgcNgtMaaaKaBDattHacttggtRtttaYaacgVactBtaBaKtgBttatgVttgt
+VttcaatcWcNctDBaaBgaDHacBttattNtgtDtatttVSaaacaggatgcRatSgta
+SaNtgBatagttcHBgcBBaaattaHgtDattatDaKaatBaaYaaMaataaataKtttY
+tagtBgMatNcatgtttgaNagtgttgtgKaNaSagtttgaSMaYBcaaaacDStagttV
+acaaaaactaaWttBaagtctgtgcgtMgtaattctcctacctcaNtttaaccaaaaVtB
+cacataacaccccBcWMtatVtggaatgaWtcaaWaaaaaaaaWtDtaatatRcctDWtc
+ctaccMtVVatKttaWaaKaaatataaagScHBagaggBaSMtaWaVtatattactSaaa
+KNaactatNatccttgaYctattcaaaVgatttYHcRagattttaSataggttattcVta
+aagaKgtattattKtRttNcggcRgtgtgtWYtaacHgKatKgatYtacYagDtWcHBDc
+tctgRaYKaYagcactKcacSaRtBttttBHKcMtNtcBatttatttttgSatVgaaaga
+WtcDtagDatatgMacaacRgatatatgtttgtKtNRaatatNatgYcaHtgHataacKt
+gagtagtaacYttaNccaaatHcacaacaVDtagtaYtccagcattNtacKtBtactaaa
+gaBatVtKaaHBctgStgtBgtatgaSNtgDataaccctgtagcaBgtgatcttaDataS
+tgaMaccaSBBgWagtacKcgattgaDgNNaaaacacagtSatBacKDgcgtataBKcat
+acactaSaatYtYcDaactHttcatRtttaatcaattataRtttgtaagMcgNttcatcB
+tYBagtNWNMtSHcattcRctttttRWgaKacKttgggagBcgttcgcMaWHtaatactg
+tctctatttataVgtttaBScttttaBMaNaatMacactYtBMggtHacMagtaRtctgc
+atttaHtcaaaatttgagKtgNtactBacaHtcgtatttctMaSRagcagttaatgtNta
+aattgagagWcKtaNttagVtacgatttgaatttcgRtgtWcVatcgttaaDVctgtttB
+WgaccagaaagtcSgtVtatagaBccttttcctaaattgHtatcggRattttcaaggcYS
+KaagWaWtRactaaaacccBatMtttBaatYtaagaactSttcgaaScaatagtattgac
+caagtgttttctaacatgtttNVaatcaaagagaaaNattaaRttttaVaaaccgcaggN
+MtatattVctcaagaggaacgBgtttaacaagttcKcYaatatactaaccBaaaSggttc
+NtattctagttRtBacgScVctcaatttaatYtaaaaaaatgSaatgatagaMBRatgRc
+McgttgaWHtcaVYgaatYtaatctttYttatRaWtctgBtDcgatNatcKaBaDgatgt
+aNatWKctccgatattaacattNaaacDatgBgttctgtDtaaaMggtgaBaSHataacg
+ccSctaBtttaRBtcNHcDatcDcctagagtcRtaBgWttDRVHagattYatgtatcWta
+HtttYcattWtaaagtctNgtStggRNcgcggagSSaaagaaaatYcHDtcgctttaatg
+YcKBVSgtattRaYBaDaaatBgtatgaHtaaRaRgcaSWNtagatHaacttNctBtcac
+catctMcatattccaSatttgcgaDagDgtatYtaaaVDtaagtttWVaagtagYatRtt
+aagDcNgacKBcScagHtattatcDaDactaaaaaYgHttBcgaDttggataaaKSRcBM
+aBcgaBSttcWtgNBatRaccgattcatttataacggHVtaattcacaagagVttaaRaa
+tVVRKcgWtVgacctgDgYaaHaWtctttcacMagggatVgactagMaaataKaaNWagK
+atagNaaWtaaaatttgaattttatttgctaaVgaHatBatcaaBWcBgttcMatcgBaa
+NgttcgSNaggSaRtttgHtRtattaNttcDcatSaVttttcgaaaaattgHatctaRag
+gSaNatMDaaatDcacgattttagaHgHaWtYgattaatHNSttatMSgggNtcKtYatR
+ggtttgtMWVtttaYtagcagBagHaYagttatatggtBacYcattaRSataBatMttta
+aatctHcaaaSaaaagttNSaaWcWRccRtKaagtBWtcaaattSttMtattggaaacct
+taacgttBtWatttatatWcDaatagattcctScacctaagggRaaYtaNaatgVtBctt
+aaBaacaMVaaattatStYgRcctgtactatcMcVKatttcgSgatRHMaaaHtagtaaH
+tVgcaaataatatcgKKtgccaatBNgaaWcVttgagttaKatagttcaggKDatDtatt
+gaKaVcaKtaataDataataHSaHcattagttaatRVYcNaHtaRcaaggtNHcgtcaac
+caBaaagYtHWaaaRcKgaYaaDttgcWYtataRgaatatgtYtgcKtaNttWacatYHc
+tRaDtYtattcBttttatcSataYaYgttWaRagcacHMgtttHtYttYaatcggtatSt
+ttcgtRSattaaDaKMaatatactaNBaWgctacacYtgaYVgtgHtaaaRaaRgHtagt
+WattataaaSDaaWtgMattatcgaaaagtaYRSaWtSgNtBgagcRYaMDtactaactt
+aWgtatctagacaagNtattHggataatYttYatcataDcgHgttBttctttVttgccga
+aWtaaaacgKgtatctaaaaaNtccDtaDatBMaMggaatNKtatBaaatVtccRaHtaS
+acataHattgtttKVYattcataVaattWtcgtgMttcttKtgtctaacVtatctatatB
+RataactcgKatStatattcatHHRttKtccaacgtgggtgRgtgaMtattattggctat
+cgtgacMtRcBDtcttgtactaatRHttttaagatcgVMDStattatYBtttDttgtBtN
+ttgRcMtYtgBacHaWaBaatDKctaagtgaaactaatgRaaKgatccaagNaaaatatt
+aggWNtaagtatacttttKcgtcggSYtcttgRctataYcttatataaagtatattaatt
+tataVaacacaDHatctatttttKYVatHRactttaBHccaWagtactBtcacgaVgcgt
+tRtttttttSVgtSagtBaaattctgaHgactcttgMcattttagVtaagaattHctHtc
+aDaaNtaacRggWatagttcgtSttgaDatcNgNagctagDgatcNttKgttgtaDtctt
+tRaaYStRatDtgMggactSttaDtagSaVtBDttgtDgccatcacaMattaaaMtNaca
+VcgSWcVaaDatcaHaatgaattaMtatccVtctBtaattgtWattatBRcWcaatgNNt
+actWYtDaKttaaatcactcagtRaaRgatggtKgcgccaaHgaggatStattYcaNMtc
+aBttacttatgagDaNtaMgaaWtgtttcttctaHtMNgttatctaWWatMtBtaaatag
+DVatgtBYtatcggcttaagacMRtaHScgatatYgRDtcattatSDaHggaaataNgaW
+SRRaaaBaatagBattaDctttgHWNttacaataaaaaaatacggtttgHgVtaHtWMtt
+NtBtctagtMcgKMgHgYtataHaNagWtcaacYattaataYRgtaWKgaBctataaccg
+atttaHaNBRaRaMtccggtNgacMtctcatttgcaattcWgMacttacaaDaaNtactW
+atVtttagccttMaatcagVaagtctVaaDaBtattaattaYtNaYtggattaKtaKctY
+aMtattYgatattataatKtVgDcttatatNBtcgttgtStttttMagaggttaHYSttc
+KgtcKtDNtataagttataagSgttatDtRttattgttttSNggRtcaaKMNatgaatat
+tgtBWtaMacctgggYgaSgaagYataagattacgagaatBtggtRcVHtgYggaDgaYa
+KagWagctatagacgaaHgtWaNgacttHRatVaWacKYtgRVNgVcSgRWctacatcKS
+actctgWYtBggtataagcttNRttVtgRcaWaaatDMatYattaactttcgaagRatSc
+tgccttgcRKaccHtttSNVagtagHagBagttagaccaRtataBccataatSHatRtcH
+agacBWatagcaMtacaRtgtgaaBatctKRtScttccaNaatcNgtaatatWtcaMgac
+tctBtWtaaNactHaaaaRctcgcatggctMcaaNtcagaaaaacacagtggggWttRtt
+agtaagaVctVMtcgaatcttcMaaaHcaHBttcgattatgtcaDagcYRtBtYcgacMg
+tDcagcgaNgttaataatagcagKYYtcgtaBtYctMaRtaRtDagaaaacacatgYaBt
+tgattattcgaaNttBctSataaMataWRgaHtttccgtDgaYtatggtDgHKgMtattt
+VtMtVagttaRatMattRagataaccctKctMtSttgaHagtcStctatttccSagatgt
+tccacgaggYNttHRacgattcDatatDcataaaatBBttatcgaHtNHaaatatDNagg
+ctgaNcaaggagttBttMgRagVatBcRtaWgatgBtSgaKtcgHtttgaatcaaDaHtt
+cSBgHcagtVaaSttDcagccgttNBtgttHagYtattctttRWaaVtSttcatatKaaR
+aaaNacaVtVctMtSDtDtRHRcgtaatgctcttaaatSacacaatcgHattcaWcttaa
+aatHaaatcNctWttaNMcMtaKctVtcctaagYgatgatcYaaaRactctaRDaYagta
+acgtDgaggaaatctcaaacatcaScttcKttNtaccatNtaNatacatttHaaDHgcaD
+atMWaaBttcRggctMaagctVYcacgatcaDttatYtaatcKatWatcaatVYtNagat
+ttgattgaYttttYgacttVtcKaRagaaaHVgDtaMatKYagagttNatWttaccNtYt
+cDWgSatgaRgtMatgKtcgacaagWtacttaagtcgKtgatccttNcttatagMatHVg
+gtagcgHctatagccctYttggtaattKNaacgaaYatatVctaataMaaaYtgVtcKaY
+taataacagaatHcacVagatYWHttagaaSMaatWtYtgtaaagNaaacaVgaWtcacN
+WgataNttcaSagctMDaRttgNactaccgataMaaatgtttattDtcaagacgctDHYY
+atggttcaagccNctccttcMctttagacBtaaWtaWVHggaaaaNatttaDtDtgctaa
+HHtMtatNtMtagtcatttgcaaaRatacagRHtatDNtgtDgaatVgtVNtcaaatYBM
+aaaagcaKgtgatgatMgWWMaHttttMgMagatDtataaattaaccaactMtacataaa
+ttgRataatacgBtKtaataattRgtatDagDtcRDacctatRcagagcSHatNtcaScN
+tttggacNtaaggaccgtgKNttgttNcttgaaRgYgRtNtcagttBcttttcHtKtgct
+tYaaNgYagtaaatgaatggWaMattBHtatctatSgtcYtgcHtaattHgaaMtHcaga
+aSatggtatgccaHBtYtcNattWtgtNgctttaggtttgtWatNtgHtgcDttactttt
+tttgcNtactKtWRaVcttcatagtgSNKaNccgaataaBttataataYtSagctttaaa
+tSttggctaaKSaatRccgWHgagDttaaatcatgagMtcgagtVtaDggaBtatttgDa
+cataaacgtagYRagBWtgDStKDgatgaagttcattatttaKWcataaatWRgatataR
+gttRacaaNKttNtKagaaYaStaactScattattaacgatttaaatgDtaattagatHg
+aYataaactatggggatVHtgccgtNgatNYcaStRtagaccacWcaMtatRagHgVact
+YtWHtcttcatgatWgagaKggagtatgaWtDtVtNaNtcgYYgtaaactttaDtBacta
+gtaDctatagtaatatttatatataacgHaaaRagKattSagttYtStatatatagtctt
+aaaaMtcatgttcaaDactgRttctaagagDtatttttagcgacttgtgRtgNctgSgRa
+aaaatgcaMtYtDcatcaaYKttHcatSWgaaaatDataggttatgBDMtgttataacaa
+YSgagttacgttatgtDStttaaatctcgWKtcSacgagagaSgttatBMDgtcggtgtg
+cgaNtaSHBatBtttVMgVcagaNatcaDDaKMtMYtatagaBccctctDtgtatttata
+tKNtgggtatgtRaacttgaWaaYgcaHatccctggtttStatMtcgcMtaaaWKttMVt
+WctVtgttaKDWctgWaVttaDVatgKtagagtcatctaKWgtaaMttSacBaMattaKa
+aHDataattgWtgttttgtcatBacacgtStacaaagtNctNtgtgatcHtWttcKaaga
+gttttaaaaWacgRacatctNatVStgaatDHgttWcgtRKcatatatctcaNttaaBDc
+ctgaaaaaDtaYaHaKttNtaYVaVtttaDtctacttctWttaactaattttMagWcaat
+cccNKYtBaacatgttgaKgKcgcBHaatDMttatatcSWacatDatRcWaMtDgatBct
+HgScttaaaHtSgKtDtttattgtRStWgttccatatttcacWttcatattgtaHVgaBt
+acaMtgMaaagDaataactDatattagMaNBagcttcattcgtaaKtgtatttcacMtgB
+aVtaattStcttagtYgtgtcgccttKatgggtgaWaataggaatacMMagaSKRttBga
+tgacRtgMtagaSRataggtatcaccgaNaaaWSWacDgatacttgattagcttgtgVMt
+tatYctaRgHVcDtVRRtSaMtcaVtVtatcaYaHatattaaVaatctaBtgtacRatNt
+atttgaYatSaHctaNgNtYtYaYagattVgatcRtaacgYggtgtatKttaatMagatg
+RtatatgHaKccHaaaaYtgaacgaWaNgtYHgacagaYtctaVtacccgatttttaaag
+cDttatNRgattKaaattttcatctaatgccgcaataataattgttatYtagtRNtaagt
+tggtHaKttWMtDKgatSagBYcgRggtWaVaattHtatgtaaaMgSaaagataaKaaKg
+ttDttttRaagaacaWRcaacDgtgttaatattaKtatcaWacacatttVtctgatHRca
+gtttNcaaatcNctNttttataactWacBBttgBttaaaRaWtBKaaacgtatcRcaMaa
+tgYacaaaagtgBataStWYtggtatgacaKWtctSgcKHgtcNaMNcataSatattgac
+tacMcataattNVtDaRccaaatcagttttYttagYaacgtaatMtMVatNgKaaMaaBg
+attaKttatDaBcttKtccttttacDagaYtacHgttggacaaaVaatagtYatcataSg
+atcaaWVttcgaatgaccctccttNtaSBWaatttDttttcaatatYggctatDcttatN
+ctttagDcMttcaacWaaNattSYgctttcaHcRaattaataaaatcVccRaattactct
+aMaVRattacagtgRcDtcgtgctcttNtWVtacagtHtatHaBDtcWggtgctcaaRHt
+atgtDgacStgcaaaVKtagttataatactaatatgtagScaatRSacaattgtattgca
+gatHHtgBcaatKKtaaMMcaRcgactatKBaMaYatgKatttDaaNtRatattgtatWt
+tagcaaaaacaWgcacaaHcataYtDaHgttataaSacgcagggggtYatgcKctaaaHg
+cVgctBDaVttccStagNgcSgtatgVYaMatcaWRBtVtgYttgtgRcYttcgctgaac
+NttgtgtctattWttttcctagMtagaWtaKgatStScatMaBtaStaSactattYNatc
+tgtacRatYDaatgatgatatgaatYaaaaSHttaaYMaWtDcaNHaBcaYtgVgcatVa
+acattMRatBtaatttaDacRtagtaaaNYVSMtcagaaDtttDHtRcYatacSNKaaMc
+HgatBaaVttactggBYgaYatttttgcDacHctWatcgtagagtactcattDggtcatK
+aSgctttatttagtDtRBacttaWYaaaattttgaccttaaWtaatgcRgccacttMtag
+gKtcBtgacgaHctttatcgtcStatMHDNagattatNagVaaaWcggaaaYcaVactDY
+actaStattgBHtcYctgggtacatataaYcgaYagaggaggacaVatacHRtYtctgta
+VgaYcNgaaaNatacVgcNgtaatttDcatttttcaacttSNcaaDatVYctSgcacctt
+agMgacgcttgaSttaaaatagttaggRHttaaacMatagcaWgMgagtcgctagtgtKg
+actaaHttattaWgcaaaaaaSatatgcgttaBNggttaYVatgaactttttgccatata
+aataRatSaBctagttataBccgaaacaagatacttaattttgaHgHMgtaaKctttaYt
+aaRacBMtBaYgaBaaacaYtVtagcRgWatHaWagattWSacStMHatttaDagacaat
+cgtgtKtttggaMtgtWtgtgcaaNaaaaWtKaaBcMWtcttctatgacVgagcgaggHa
+YYtttWgSaaYYaWtRYHHaMDtctttacaatggaaMctataagcttBcgHcNWaatttg
+tatatYtStatctagcactgtVttccagaaattaDtttaRtVataBttWagcatDMVact
+YtgcatWtttgaaMggKaatgaaaaHtataDtgYcMggVaaatSMHtttgVttaYaWaat
+aRttgttaYttattttRtWtataaBgtDtttatatcVgaaBcaDtatgtcaDagaWtgaY
+tWctcVagctcagctatatagcRVtcaKtaataatHgNaccgaaaatVHBaatattcgtt
+aVYttatttctBYaatKaagaccVStttcattgaMagSaaaaccccWKcaaNtMYaccta
+DStagaaatttatcatVgtcaatacccKattgtaaagtggWgtatatVtagBcttDaBac
+aattWtDYKtatRKggStRtaaaWatBtaagtaattDaaaaBRacWtaagtacaSttaaa
+tccgctaaccKaattgVWttDattatttattKaMtcYtMRWagMtcgKgBagacgggVaa
+NaaatgctKcgtaataaKtaaagtccWcttHMatSYgataaatDttBaHccattgBttSg
+aaHYtaataaaMtgaagatgtttBgRcattaRaDHcttBgaMaWaaVMMattaatttgtg
+BRctattgKMagNcMtatttaaaWttgaaacatWgcScgYYDYgttYtVtattgcKcWta
+gcggtgBaSctaKatacaaVtcaRDccccgtgttBgKgggtHagcgaattaaagMMttSc
+ggtDttttaHcSaagaacactcacactBcVgaKNaDHacacttatSagaattSKHtcagt
+ataaatKaaHtgaaRagaaVcBtaHtaaatcgatcWcaRtaaaatttaWttaagtcaggR
+ctgaWcttDttgactttaVSaaaatggtaWDaRMtBtaaaaaKatBgatMtctatatcaV
+aMgatttgNagtDRttDatcttttaMtYaaatcggagttctctaYatNtagaNcgMMact
+acHcaagtaaaatStaSaacaHcacSgggtNKatggaaagcggaaKgggtaYtacSgccg
+BaggcRacgtVgDtggaMcYaaaMatggacgYStKKatgaBcaaRtStccSagcRccgcc
+gcSDtgcggBDgaDtBtSSggacMttttaWcatcMatgtNMBWgataatcaaVtgaataa
+taaNatgcaaNttNctgacDMcaHccgatgKgWVttccaStggattctcDacttttttct
+ttaaNcWaMWccWKWttgaaaMctDaaBactRtVattttBtcMaNttWcKacagttKStt
+aYaWSactHSaBtHgatgttacatgcatatMtttgtaacScWHBatHactggatatatct
+gagMgRSatctaaSttaVagcaRcttggaYaatKHtagBBactattcgtaaagaagttgt
+VcgatgaVatHMtcaggtcgKSgWattgaaaVctccVgtDcaaatgaaHgMYactcaMat
+atatattNVttWtWaatttacRagKataaaNtttacaaWgMVactattaSgaggVaaagV
+taccDRHaaataRaHaRgcattMttcaatcaKaaataDcaDKtctcgaggBggacctDtt
+tatHacWVaWgatDctaNaNcgKatcMtcMaatBtttggacgtgataatagaaacRactc
+BtattttaKtgSaaggKtaggRaVtatagcccaNRttaccttSMaagatcggDacNBatW
+cgaactacactaactNBtaStgVtNagcatctaVtaKatKgaBtcgtttWaagWMgagRa
+NatHaaaaDtacagacaBagtgcaHaNatctcBccNttaagttDgaataaNtcgctaacR
+BgtaatSttaatatgcataacccaSattKcccttDttggtcaatgggttWaacgatacat
+tBtgMaYgaRttatgatKaKgtattDtKWgataacgNBtaccgaKWatcttcttKtgtct
+tagcattcctWcaaHgagtatDMSgKtcagcttgVHaKcttDaataaaVaatttDgtgaa
+ataaRgtcaVaatacttagtVatatgggcatgtDDtMtgtatBggattHtgcVtgtgatc
+aaSattatKYVaacSNNttNWcgaHttKDaaMYHatcgttaattaSttgctWaacHtaKB
+taaaaKHttcRWgaaWcRtBtttggBcDtgtacNttaagcKtaHgtagaaaaRttgaaac
+atagtWRaacYggtaaatcgctYaBtWDRtgttgSctaaKatNcattgtgtMttatccat
+atagctSacgccSNaaactacgNtgtgcttMatSKtcaaBaNaaacataacagaaatagt
+agctcNcatcVgaagStaataVcDKKttcagDHDtattctaatgagggRgBMctatacaa
+gYactctMaaagtcgctttctcgtgaattatNcgatMtttaggcBaaatctNtactaaRK
+tgKactattgtcatatgtacgagttMaaHSSgHgBatatcgcaSaataaaWgaagtatag
+aHgcttctttatgaccWaatttaRtaDaatttaatcgaaattgattMcatcaWaMtaWaK
+actttctBacactatNgtccttaWgtctgaccKatStaKtgagtacgggcgcgtYNtatt
+tagacctctKcatgatKWStcaataactaWgMSgHtgatctttttgtcgacgtSacttaY
+gcctWctcctctacaagVtttMaBactWVaccaYtgtSgcgttattcKtatStgaaKacc
+gNaataaHtatWtYtRacggcaDaScagcagHaYWRtRNcDtHtcVWtggaataaaYttg
+VaNtgttagtYttgtagSaaatDgaggccDcgBRYStattatttaaggccgHgggYRaac
+cMaagttatSttctttagcMtgcgMtgaSagaNaDagttSatgattWatttagtDgcttg
+agtgMKaYWaYccagcaHatKctaKaDgctagacttattgattaaYttatcttattattS
+taattWaRaYBWagYaatatgttRgScttgBagDaWgcgtgcVDaggcttgtctaDRKac
+ttgcaKBWRtaaVaSctKtacttMaaSVaWWcgSaNtttSWgtcggtcacttggVVtgag
+aataaataaDttgaaccaaaaMttaaaagaaaaaaaatcNBtatMgccWagcaNgaVaNa
+aaaaaYaMgttaWtatHaagtNtacgacaBtMMattttWNaRtaaatagYaScKattaca
+gctVKBtWNSKgYtYgtWatHaVatDaaatWgDatcctggSRagagtaaaaMgatttRta
+HacatggtaKagVcctgatgaMtaaYgatgtattattttHggBaccaDctctggNNtYaa
+tctVttgVtRtVcRacttNctttataggHSRtaRacaaattaacHaHgtgttgtttcBtB
+tatWtgtattttgcKagMcaaagaMtattagtStagcBacYaaHcagVgWtgtttcgtgD
+HaVtagDatcRaRtggtWtaactgcacgaggaaaRttSDaaVaSttaaaaacSMttacta
+NtcaacaattDtacttttYatVSacYtWtMttaattatcKtcttctatcaKDtctStSaa
+acggtYccatgtgagagtWtagWKgcaBaaaaKttgNactaatcgaggcWtcDDaaaaaa
+cactHattaattcactatYttaagacactaKaagRtRataaattttcatHggtaataaat
+gataHtggctaacBacDgtaatattRtYgtDNDBgKtcaggcHattttgHNgWtaatttc
+cgactactgacatVNttYYgactcgctctatttagaMcgggatHcgtttatBaDSagBaa
+aagRttBggttaaBactVHgatgaatttattcaaaattgcacttcDgacttYcVttactV
+tttatBaKHagaWgtgaatggBtaaSggcagacNcttaDttVgMtWagattggVatttac
+HtctNcMatacttSatMagcttgtNcYaaScaYactcKctKtagScStcagtttcatWaa
+tggtgagaggHaggggcaacgcRKtaRcMaNtHaatRaRaaactVtBtgttaatRtWWca
+aagKttccaaKaaatacgVttcacaaacgcggtgagaRaatggtgDMWatcWVScacaaa
+DaggaaHtgttSMaaaaaccYccDBtatYgtMagcSagaccaVcctcggtVWaaagttat
+cNaagataataSaataaaKccgtaDtYttatYcttHttaagKcMctaaatggaatRgaaa
+VaaVtcKYaggatWcaBtDaggDatccttcYNtgcSMRgaRtNgaatcgttRttatDVMt
+agctttacatDVtatatatcagctaDagMtataccYgaggYaaatgDaaaatSgctctga
+tgtttVaaBcctgataKtagaaaccaKatatgttaDtgaDtatagataatacagtaDtat
+cNtgtDMtYcattRVtctataNtWttggNaSgtMgaaYctctDggHtggHDccaccacKK
+aaacaaaatRatttccctttaagcRattMHctattHaRtataVattggatcSttaaHaHg
+aaHNDtacattSaaggDatttcaaaYgctBcatattaaaKagtgcccatSctcgatRtaa
+aMtgWactttNMaWctYgRatDggaactcDcaattaKaactgagtatctataagYaaaSR
+ctggtacWtttccWtaYRtKHattatagWtKttaNgcDtatHacccattaatttataacg
+ctMgaagtaacaacagMgtaYHYVtKMHtacMgKcaaatctgRYataNtcgttcaatacg
+gWtMcaatYcBWaagYtVaDNagtatagDaaNtaaaYtttcYWttttStgggataaMgat
+attagaaYtNctcttcBagactaYDcgtacHDWccKaHgttcttHgVggVDttatcatKa
+MttttacWaaSattctatagaHaggKaDagBtaaagtcYccattgtYcatctaNgRgVtg
+aagtDKttatBKcggDtattRYgHccgtgcgBNMtttVRgacaYctSctaRacgtagagc
+cgtacRaagtaHKagStSttttgYSatattaaaWHaaWagttDKaaNaNHaaHttaYctt
+MtcaaatgKttBtSgtccaaVaattSaacgttgNattgatatNctaWtVcagtactKcWa
+cgVagggHaaRgaDaatcMttattaataacaBMaaVtgYtKgRgHactgtactatcBaMt
+VggtagKcYtHtBSaattagtaatgMcaVVagYYgWtactttccaaSttDgaaMaMttca
+cttYtRgacttcagcttWtttagtgataMaattaagVtagaatatKataagtagttaagH
+MRaDattaHaaVcctDtagtcVYcaataaYcNttNaaaHctcaRaatttcaNRgatSHgV
+atagctRtcatgaBttMaaagRtcgHVtgRgStgatttgtagaKagaRWRctgNaHYgaa
+atBctgtttRttNWagaccgagKgtgcggHKVttaatattaatataataDtaNcctacaa
+RgcaNMctctgaaSHWWHcttagtNagtWgWaaKtYaNgcBattatccaaaSctRRHKaN
+tKcBgtgagaDRWBttactaaattSMctatatagaaYacDgatttccVtaagRtgRataa
+tatagtctttttatgtMgtcaacaaNtaaaaactctWtagaVaaaDtaattatagtBStc
+gaatDtgattVaatMtcaDattVKWaagatagggttgtMRSgtcYgWMaatgNtagtcBt
+tagtttctctWaaMtVgctWgSgtHagaSagactagKtagWggcatttHgttgacaaact
+cggggHggcWBgVgtatgggagVgagtcVcBtDctttagtctaagVWtHtgtttaScata
+cMBtKgattatRtgtttgtctttDggcHaBtRtgtaataNataatttataWctgaYWata
+StcHaatcRtaaVagDWaSatagtaccNDgaagtatacgttttacgacgKRtattgDcta
+tRRattVtStaaactagatgVatttagaMaSaaaattVtatYtgttgtRMagtHaatttS
+ttaaYNaggWagtgcacgaMcactgHgtgtgggHMgtKacttaaYgtcgcatcSatattg
+BaagtttacMtYagSatttatttaVtaaDtaWaHcgNatactgactHtggWtataDcDSc
+atactcStcDtgtcgtgtatgaggtHaaNKgDattgcBccaagKgtatgacKSMtttttg
+ttcaaatcaaYtagtaSatgDaaaMccKNaMaatagaataagcaattattataaMgagtg
+aSgtctNYttattHaNaYYtcDDtaatNRgtatttaaYtaaatcactHVaHcStccttcc
+caaVatcVggatKtatgRaaDBgaYtttacttYggactSDtaBcaaNggggtattatatt
+BDcttagagYNMatBgttYaagactMatgttRgatacccgtaacacBHtatKacWgatRc
+HttaattYtKtStccaaatVDcaNKHHaaataatagtagtatcttgctNDggVaVVtaVa
+RaaagSaccgttctcMtVtgNBgtDtttctYgttactBctcRtStWtWDScMtcWSaRat
+gaataRHctaNtcStctYtWacagatgtatYBtHaHWBtacggtDcaaBtatcaggtcaV
+attaNctactgaaaatWaDgactNWtMtggagaattBaataYcMWYcgatMYatWtgatt
+SatgaRtDaRgccagtSttatatRaBtattRcWtagtVgaagttMctattatatDttagg
+tctKtgtgtBagacgttatRKtgatctatttBtataactgataacKcggagtgHgtVttc
+ttgtKDgcDtaYatBDatcaatattgttNtaBacatcgcNcaKcaWcRataWcVgtacgS
+caWgttcggHcMttcRccatgaRStYgNacagatacYacWWtggNaDcWagttHatMaNa
+atNtcDMDcMaKgHNatScVgatKWatatgNRgtccgYgaagattDHgtMtcHaSNaaat
+tBatRagtaaatttacaagHWtKatcaagtccHtYcctgttKDMSgtactactVctgaca
+aaaHgatatacataatKtStHgctScSatNatacaYttaaWHtctgaatYtagtHtKagg
+ccWBaStaDctaagagNtaatcaatcgttNgaYDaagtaaaaHatagaatcgcgBaYaBg
+aacSaaWaaaaactccgcMttHttYgtaagaMctKBtacSagattcBaaWtaattttacR
+ttatcgaRtacaRHgtgRagaaBcttaVgacVDgggaatVatagaactRRtacgYttNat
+tVHgaHttacaaaaaaaYtcRWtgtgattatgccaSDtttatKWgaatatSNDgatttta
+acgtcSRtatggttcttcBtWtttMtBtMScttaHatBattHacYtaYacattcgttKgt
+cStSctcKtatatttcaKSgagcttccaacaccRDtttDaccattatatSgtcWtVaaag
+ttgtagccattDtYaatattDaccatcVDaaRccagttttgtcHacMattcHgaNcatgt
+tKcVttcctgtgcSataaatattgaKtctaWctMRaKggtaYcaagttDttcgttacRta
+tgatggHNaWMtKttcatattaaDaSaBaaaMtMatBgKtttgHtHactaatcatcgtWa
+atKaaWcaWtcctVttaaNaggaaaagtaaagaDctNttaDBaBgatagMgaataacRcY
+ggatcRaaaHaagatRDtVRactaYagttcaccaaWtctcSSaaatcSKattctggDgaa
+cagDtaDagacagtgtaattcaStYttNaStgtaHgccttaScatMRcaccWtcatttat
+RtaagatWtNataaWtMNtDVgWttgcWgtgaRttttRgWcttMtctaHacaaYtKctga
+BagtRagacttDatNttaaaDgRtatNcHatcSDgtBatcttacVcYacNgaattaacga
+gttgYgacttDattatacBattMgctagcctagatVcaactNttcctaatgtDaacgYaN
+atagMatSWtYBaaaRtgMtatSRgaataYaScaVgtaScMagatNNtttacaaHBaWtN
+tRtctaaacDaaaaWMcaNtcVaDNcagaDtgcWKYgagttaHtgcDYataaacataBaW
+WtcggtatgtgaaScaacctttRNatcgttaaagcaDctaatgcBatttacaattVaMgS
+MMtccYaaaBYtggattttcataWttgBtatDtBgactaatgtccWaaHataaScHttWt
+tDtcgtcaagMctMDtaaaatRtBaaaacaatgtcagcatBgNNBVttttttcBacWttt
+WtSWWtgaaaaSacgBtaaataaagtcDStaagaactgttaatYatgDctattactgaHt
+aaatStHaagacaKtagDtaaHaDgttccaaDtaaggacactctDggcgtDagtcWaHgR
+cHgDgaSctttattgtcttttccttRYaDgNactaaatcaWggcNSBagttttatatStK
+gtcRtgattaaggtcaSBttaacaaKatgggatcaaattgRgcBagtNtcgDcatttWcc
+tttgtNagDgctgcatttactttgtgtcaBgSatttNHaMcggcagSctcKDtWBaagSa
+gWatggYtVatSRgKagattgaVatKttcgatYatKYSgDaacNtcVgtttaWataWtgV
+ctgcgSggMgatccatgagttgtWcatYWWcctVcNHagtNtgtKtttgatcaacttaSt
+tattgatNcatWaVgNHcagStVHcggHacaaDttgDttWcaaRaKgaaatKaattagta
+WacattgaaatgtgaatgacagtgaRVtaaYagYtcggcatMttgaaggDgagDRcaKgH
+tacacaaaMcaBtagHactgKaatRtNttcttcatcatNgYgStggactatgSMttgKtD
+aDgacRRgtWaVattgatttaagYctatatagactaagaggtatWtataaactaYaHRct
+StgKWcgtRtKtYtYtagacgattRaaYBtaStcttaWataatcHttataRcactgagtg
+ggagccaattctcDtgDaggHcDRVaVVggaaBtRttaataaRRttgtaagKNcaVWWgt
+atacctgatcttBtcttRgaWcaVRKcagttSacttagcgtKtgtYWatatcgNttcKac
+cacacVKctgattBtggacgtctgacaDtWKttattttgMBgKaacaDataattWtBtBR
+tVtacataaatatttgtWtttatagtDtgcctagctHYaatgcaNaaRcaatVtacctgg
+gggKtagBgagaBgRaaNttttMtMagMtgtgattNctcNaKggWtMatcttagWgtaat
+atatNctaYBggKaataBattYtaattataVtggNtcgtgtctaattaaacctHtacaaa
+ctDctDtctgatatgMtgataacWctgtgYSaaNScgDYaWtatDatMKgcaatttctgN
+cgtHtaWtagatatcYBttaattactcaaaVattYRWtatttDtaNMYMttgattataat
+gcgNggWaatYagttgBagNcaagaaaDtRgtaaaagctgcatctagcttaVgtBttata
+gcKMSaattYtHcMaBttcagtcttgKatgVSVttKgttttttagtgtDHgNggtcaVta
+tttaacNtgaatatgctatMcatgaaaBtgBSaWctaataaattatYttagtaDtaccgg
+aatgagtaattggatttaacBtctSMgWYtgKgattacgRctctccaatgtaggcctgaN
+aatScgYataaBBacaKtHtttcatgaaHtgBtagaKHVtacctVtcaaccaDaaWNHNa
+atgataattgatgWcagggtcMBtgSgRataHctMctgMHHtKaBtaaMtMgataaRWta
+gYtgaaMaSgctYtgcgaaHatDtatgtcWRatKatatYDcBgNtRaRacattMcagaHg
+aaagRccgcgWttggSatBagagcHgYtatctVtcatYaaVRtcaSacaMYDcgRtcaaW
+gaRgataMtaaaacaggtgtaaYcattgWgDHcWgttaVatttgcatctaatccacaaag
+aagSatgcgtagRgagtHDgaVcgtgcttatggMttttcatKSctNacHcctMaKRattt
+gatctaaatgHaaScataataatgtttgtgtHaVcaaaaNHaaaatcgctgSVtattVtt
+agaaNWcacagtgKtatgattHcYcttgDaWVataBatBttttWtaactNaattttcttt
+aaYHaMtttaaaccgStcHaVBaatcRacaaWactgtagVKtNRtcctagcWaatNgctK
+ccttctcDaBDcatYHatatgcaataaBaagaatgDMttaHcaaYYtcactgttRtgacR
+aacctaWtBtBMagBctaaBaWtgatgVtttattataggttaattgtaatYcaRtVctct
+tgcacSaaMaatactRSgcataKcagcaVNKttcgSatcaaactaattDtaHtNaVtgtt
+ttttaWVtatNccagWttcgtatBcgttVctcBttaaaaMSaDattKRcctttcataHaa
+ttaatWaaataKcaHVaggaatataBYKHVtgVcVgtcHcttccgcctattDtMMgWaac
+ttgWttYtttcMcgtcctaaVHtgWtggtgacKtcaWaYMttacttagVWtacgSatatc
+gWcKaaatHKaaaYttgtagtcaacWtttggtcaagttgaaBBaSHacVcgYgttWBSRW
+ggtattttaYDtHatattcgatNttacaaaaVacaMccaaYStaataRttVtcttagaVK
+aacaWcgccgtRatcatctaaatccMcctttaMggccHgYcDgaKctatgMRYBagcaND
+tgMtcRttgtgHaRttacatgaWcDtgctgtataggNggtgaatagBgagYNtatcagKt
+HcatBatgVKgaHWagattRDatatcgYcHagRtaatgWtcStagcVatNaaaaKttgRa
+RBYNgtaaDtStaVRgcMccatMWaaattBDatttaatttataaHtagtVVaDRMKBtaa
+caatttttttDaRSgaaKDtVaBatcagtaaMttaagcctRgaNVgggttcataatagNa
+tcctacactacgcatgtcggaYgtaKcatggattgactttHtaattWNRaaWYggttcaa
+aggaaNtaatgcHcaaaattBtagcttattcaagVtatttWgcctaKtatBttDYcatta
+gDacKVaYNccgYaYRaaMaattRaagaHtatgcttgcRagcgctSaatagaaRacaRac
+SccagcacVMataatHgRtagcgaKgYRaDcVWSDVgRaMgcDgtaattttaYttggtaa
+WcttKDaaYtatMRcgKccYcagtYcBgRccattcaKtgaSSRtactgacgHtgtaaaaB
+atWgcaMcBcYcgccagactcttcSatYattgatgaNccaaaaWaKatVgcaggtWtBcg
+ttaRMagcaaagtgttcacatataaagaHWtKatctacttatatcacYRaaVagataagt
+aattttgatgtBctaataggtaRtaaHaattgtaRcStYSYaWRgMtacaHcNSttVNSc
+attNKaaKgBtagtgatYcaaaStactggttggggaBggtNtgtcaaWBaYVSNgtaata
+BNtagtatatcacMcScccVcgtVRRtttNcKaSRNaNtHRttatttattgacaatggSa
+BagataaccgttcctaDNaattgctVtatNtHtatagSccaagctKttaaacaaattatt
+gtSHgMWgStttNaccattBMYatRtccStNgttgaaBcctVagcaaaatgatattcRaB
+ccMWaagKtttttcMtgaRYNaataDttgttWRttattggHtNtataatggttgtStYga
+McYVtcattaggtaatVcaNggaRtNataMWcctcYgcgagagRgcHMgcWtgaYtVStt
+gDaacgaaaatMttYWtWttcctgaKNttatttattRaattaagaccMKtttcWgtcaBa
+gKSaWaaacaNtaYaDtBNaaagWtHgacaaagtgVtcatKcgcaatVaactatgcgaaa
+ctccNctatatMgactatttatSaaVttNttRttagHtccKtHtaaaNatttYVctaatt
+taaaatHWaNtSacgaaaHggaaatcacagVYcctaattcMNtgtYtgagttatttaBtc
+RgBHNacBtactctagaacgcKaaDWYYgcattactVagaYtgaVVcgcaNctttBagKR
+cSgaaatttgtatccattgtggHcaatRtaVtaSaBtcYYcatcgtgtcHaVttaHattc
+tgtcaBSNYaKBBattaatggctgtHatattgtBacDcBgatttaaaNtggaaaaYtNca
+KagRRtRgttRtMtWgggatcNtacacctgtWKagatataaYVMtaaDtaaacctctgtg
+tgccttScacWaggaYacttttKacgtttgtgataKYagaYaVatcWcSattaMcatBYt
+tYaaatgStKagWattKtttaWgtagaaSgtRattcSaDagVaMattattYaagccSgcN
+aaDgaaSaggtaNgtWactaWcgHctgaNatttttcaatgtaMHSWaRtggtaNtaHBtt
+tWWaaatattcVtBtctStWtaWMaBcatttcDagttDtttatatgttWBtNaYatcccS
+gtgagcgaRYtBtagaDacBtaagaataWactaaaagKtaKaWaataacKcccgDtagcc
+aaagcggaatcgctSRtacKgcactacccHaactMgtgccaBaRaaaBVtcgSacRKttt
+StgatcaaHgKtaaKaccHaccacccKttgagcttcSttttKKcgacBgggtYMaatcBS
+tcgDBtMcataWtaWaMtgaataagaaDatccSYDtgBatgactBaVtaagatctcNMgt
+caWKtgcWggcgatacgtgtttatttWaDaNWBNaaNtNttcaaatagtaatScgHtMWt
+tgttgaBaDtgNatSaagtttHttaNaNKaattKatttgatcgtVcatgaatatBtttct
+aacKaNttVttSagccatRtatatcactcHHatctWSKttaMacaaDattccaRaYtttt
+agttaatattcctYaacVactgctMcgagcaMYtttgaagctagtKgNWttgaaaMatca
+McttcSVatcaatgtNactaaBagatagagtDMgtNtNWatttSaHactagaaaDggtaa
+aaNctMaatagtaHgacgMaaacMtacatHtaSagaHatYDccagtBtgaWatcYtVaag
+ataattgatcgacctgcaacgttttattacNMWNcattataDVDactatattatYatttt
+gcgaagtgagYVtagYaWaHaatctgWttttatgcHaacgttaccDaKtatagaccaDDt
+taacgtHBaacatccgtYaBtVtNccaaataaaatVactDttSKtcMtDSgaagctaMta
+tattgattactgtNaagNBcagHaDattaaaWttacacaaatactcaatSDatagctcaD
+ttWactttgaStaaDtagatSaaDtgtaatKtgVataggaagWSaaaaKatttaaagttt
+gcgtaaagcccggNWaacatacatgttctaRcaHttVtcattatctagttttNcataaac
+DttWaagVtNYtaggctttggtatgagaWgtactNaVatcactVttBKcttaaccttcMt
+atcggtaataYaMaYggttgtcaaagSWHctaRMSatVcggactMatatccgaatctttt
+ttcgagtccagtttgaMtcgcatcaaKagtattRMaaaKDBttDNccatttttaaBNtVt
+ccgtaatgaKgtcagMVSattatttaWaattttaHNcaaMaHttgtggctattctacDtg
+aagattatcgacaaVRHttcSaSaatactNHWaaNcgtWaWgaccgRSttNtHtcttcKa
+tYatatBaagtcgctBtgagccatatScctKaagaaKDaWactWagBgctgattBagKtg
+aaataBaaaaagSacScaaagagtagcgaDaYtaMcaYcKtaataMatttttaactttgY
+gtcgaaggacgcHctBcgYgaaVacRYagagBaaYgtagattgcgagtcaagtStDagat
+BgtgaccctaSWtctDgactaSHttctWatWttctaWtatctYacactgBWatKKctgta
+tYgacaaHSatYSaNgSagtatagatgagtatttatgaccMaatgtaHtStaWttgYagc
+caWattcagtBaYtaaNaBtaNatactggcttWcaagatDctacggaNctatcacatSgK
+gattgacgacccccgagtNDtattgagaaatattaatcVttNKtaaWtYacgSNcBHgtt
+gWtatgtttcgccaactKaattaRgacgNataatctacaacKgttBatYatNMSaaaNtc
+tKgacttatgcttatKtcaVtVcagDaataattYgNtRtHaagcaataHcacaVgtaNNH
+tHDatgttaMNtggWagSVaRttcMVDtcttWgtRttctacKaaVttcVcgcatcctHRK
+tattSgttSacgaagtcccRDVaacBWagtgYtKtgattgSgaBtgccBtcaKacaData
+cttHatcattNatttacgtcagtgaggcBtaRNaRcaSgcatattatStatgctYcacgt
+attcattaaRtgStcttWgtattKtSYttNaHaRtNYcRaYtVtggtDcKcttctactaM
+cacggcMtacgcttctatatHtaatggcattMDtaaMaKattgaagtBaaKMVMNacKaD
+tttKNcgagctaaagtccMMtgagaagVaataatggcaWaaaaVaBgtaSaVgaaaSaaa
+ataDttVtBccaNagcSBgaMaDaVaVYYRVBgttYMtagtaactDtaagWaattBtatt
+ttMDYHtSaStScRaKatattacacctMttgNBKtcRtRggNagtYMattaaatMctYga
+atgcKHagSggaaaaBcaggtHtatWcatcgtStagMcctcatgattaWRcStcgWtgRg
+ttttcctaacatcgctcgDDtRaatatMgtcMtHtMaDYatgDatttatagctKDtYHaa
+aaattaSatatctggtctttattttatMtgtYttgtcatactcaaVcYBgatgSctKtYc
+ctWaRaataWcMgNgcgggagtcttRMgactataHaHtgctNtVaatcaaccacgSRaDt
+gKtaaMSKgtaaaaWaKtttVagSDtaaaaaatgttYattttNagMHaaRtNgBttWatt
+atatgcttatatcatttatKtKaaaagctRaaatcgcYgacgNtacNtccVtSaaatttc
+DVctaatacWgcaMtcttSaaWaaaWagtagtaattaactagRttaVcSaaatataacHg
+HatWaattggaagtgcgSSgaaVtgYgSttccatWVataatcgaatatgHtRcgtBttct
+taaggatatgttgtBcNtaatgtcacVatactgaaatMBttRRcRatccatagagggaca
+tcgccWttagttgWttatKagtaaaagHtttccttSatVatKtgagcaatttattaaYVa
+ttcaaattctgSattRaMtgaatMgttattattacaNcggVagccttaaKgccYcaaDat
+tWtggMcttMacWttccMVgtgaattctDaBYgacttKYtBacatgctDcRaaKaaRaat
+atctttagKcKtaactttaatNaaggctgScacctYgcgcaaaccaHttVHcBaDgtaat
+HaHVaaatMgttggtSatHtNNaaVagtgtacaataaagacgKttcaaaWVacagctcac
+WHaatcctgtBNWtaNMKcVcVSWtSgcaattctgKtVVaaacaRaattgatRcgBacaK
+acVccVMactagcgMNaaactgataDaSgagaatVHaatVSVtccggatgRgtagRattt
+gtaactaBataVaggcaagHgaaSMSaKgctRagcStNcatttVgctatacttcNDtcaK
+BDcaHtDcaatagttHttattMBgagctgtaaagtMgatStStcagatatYcBtataacR
+caggRaaaggtaWSatKgatatgagcgtgMYatcagcatVttSgaaaaaatatatgttYt
+tcattatacataatVcacgattataDggttBtRaagtHMtatagaDgNttggDaKctBca
+aRcgattcgtgccttacaaaWattYWVcaaWagDattgaaagggaagaHattBtatVggt
+aHtWtaMagtccagaKttSatatcaStDtgWaagtKWaggtatttaWaaRcattaatStg
+aaVtacggaacatKctacatHtaaaBtcNWatttBBaNatRcDattcgaactataaatta
+taactcagtSgatataagRaYaKHctggtaaNtttaaNgaRHtttattatacNttttaDc
+cttYgtaaacaggaagtgataaacatBgaSgtaaaaaaVcBgtWNtRMttBttaaBgtaa
+aatatcHNStaBtaggtaVatYaccNtBaWagRctNSacRtMatDactStVctaaDtaYS
+RgttaRNttttKggccagaaBcatagtYcaYNtDatcgtatVcaatWRtaggaattMcat
+RtgggatgtcMggMtttataagtaBgtggacNaaKYtgctWgagYtWcctWtVcttaaac
+taRacatggtRcatctSDcHcMgcaactttttagttaccttattHRgtacggcactDBgg
+tMHcVaaRatKctSHacctacaccactaaHaacgSttagKtKttttgNHVgagtaYaMtV
+YNVcggttaSBaBtaatttSRcgtBgaWaatctttttKggacaWKaattKSaccttgDRg
+tcatatDatVMtMaVcgaattaNaagMWccctaaHgataatatgtattWataaaatBaaM
+tgRttcHctaagctaagatatattMcggactaRttttKaSttactWYtgBcaMMacRRgN
+tactttaaaSKtttcaYBaBttaVagtRtHcWaggaVccttNgtgagtcatataWttYSc
+MtWgVRgattWtaSggacggWWctBHatattataaKaagttactaMRaaataSRaDttDa
+aatataVHaatggaaBDgWgHtcKStVcatHtaatcatggBWaagHtagtMtgHcHtcat
+ggggWcatacaHNHagcDatRcaaattcgcttgDggDNVcaacgSgtggcaccttMttaa
+tattVYtVgaagRttaBcagVaYaHcaRDBagatgaVHtNMtcttactDaggMgMaattR
+WDcctVtgagaaaaSKatHHttVDgtctgtcacatHNttgaatSaagtKBatatagacaa
+RVctcWtgtacKtaacHtgHataSgVtactaggtttatggBgtcaaaYaDgaaaaaatcg
+MtagaKaYatgaattatYcttKtacaatttgWttMaatBgaatSttMtNaVgVtScgctt
+ctBHKgtaRcNBaatcDtacgattgacgtgctatNaaBtMgagNgKcttWcWKacactYg
+ttVgNcgaattttcttgaaaaactacccctcgcNtgMctatcccacMcactcMatttatt
+tagtagaacMNtttcttgYKaWtaaBtttcWttagHtgtttctcttgtggctatgDgcta
+atWDataatttagaNcgcRRNataKtctaataHgaaMYctNaKWtactaacDtgaVcgag
+aactggtaccaactHgaggctagagHHagtMgKtaaactacaggMatgtYgSBaKaaaat
+tMgatRtggggtHBVgttaattgKttaaRDacgMactcaaacStaaagctctgtgccttc
+gtSagtSaRctacaataKatattctaVgtgtaattRacKagttattgaMtaatgaNatac
+DataaggactttccNtStatatKaagaataKtatggtcctctatgaggttaaDtgtattg
+ataaaactggatcactKBtttggcgtcaaagaaaNtagtWKatctaaWBactDaBaYtac
+aWtaSgcaattattWgaaBgactgaKctatBRgtagttaBaRRgatttaagBHctStgtV
+YRtaaataaagtMWtcHgcattcacaaMWtcMccWttgVgcHaWttcaNtgtVaggNgcV
+atKttataaWDcccctatgatVttttattacagRBBWttcttRaWgaatBVgcgtHgWga
+ccagtYacaattgSttaaMcVtDatttaVttRgttKtcaYWatKtaaDtttWaYtaatYc
+tSctatagtcctBtccMaMMtaMYHaSSgKaaacttctcBtMtgDtgtttttagRcgtac
+ttataHgKtNtMtKcBtaNKaHStgSagYHtataDtcKtagRtNWaacVgctVtRtttSt
+NtgaaccttaVatgagaaggtcaKSttaDataagcYaSatNStcaatDNgttcgacaatt
+taSgaRaBNNacattRatNtgSttHVtgWHgtSHccaactKttYtatHYttVtgHcNgac
+tMcaacttBatatgSgattttacgtatttgtggtScaacggYtHtgcatctatttttWta
+SatcagaYatcgcagtgtgtMgtattctttcattaRatttStcaatatgcttDtStaaag
+accDcVtaWNcHYtWMaMcgaacKcaNcttacctaBtgcDacatcaHKtRcDaaacataa
+RacNNtccDataNactttatBSDYatDtctBtaBatctDatKaMcattMatatcDHctaa
+gRgYVcatgttcgtgataHDYaagttSgHYctaaatgtaaaactNgtagaaactaattRa
+atcttttBKcgaatSctMaggVaVaaatgagataaataSgttKgtcatKaKatDYtaaaR
+ttYaMtgctcSatRtagttttagcaaNtaKgatcgWYcacDgaatcaatactgBgaNtaa
+ctaaWatatacaatacactaNatcaVaKaaMaaaaaatcaccBtgttgNctaacaBattt
+taaKWcaggataWMtaattgtaaHtgVtcgaHtScaHtctcHacVatagtaMcaaKtccc
+SagMYtWcaaatHHtaagRttDagtMtcYtttaaWWaaaVaRtcHNtctcSttagcacaK
+ttgtagtNgWYtatKDtcatttgaacctcKHtatccttattcttNggtBgtgtKaggWtY
+gtStgtVaRtaRaaagtagtgtcgcKtKagatgagYtttaatKcScctgaaaaaRaaHtt
+tttaaaVgtatagKctaNtKaSVgttcgagacattttRSatagttSacataMtaYHccac
+ttttctatactagtatgaBaagctttaMtgaatgtcaKYtaaatatggattataNcgBHa
+tcctaRaaactgttgacttYaHtStcatcctDaMBttgtaWgagtaatWKataaaBgBat
+tcttttctttaatWStaatacgNaagtWaMaaNgactMtgaaDaggaaaSctaSSgatat
+DttattatcatagBcaataVcHcRgcStaHaaatWagatHttMHactaRacttaYaaaaN
+tataHKVaataKtatgatcgtcVaaWgttYtVcaaYggctRWttaaKtRttDaKtgtatc
+aattWKaatBHaaaaNgaatggStHgVVgatMgBYtaRNgBDttMcNtggaNgtcaHtgt
+tDcNaggBtatYtacVaNttctcWtactHYcSctgtYtDtgWaatcHgatDatatcHtct
+tatattaaKaRYaDgaatgSYcgactgcRgaagttagtStYatYtttccgacactacagK
+caaagDttaatVatcttaaacRaDatRcBatKNtNtaaaHtcBgatKHcWStSRaKaSMg
+taKaBacWgDDttgYaaYttaNtDgHtatSaSataaaaMBaaDtaMatDaagWtggaMtR
+cacttatggctNataaaaatatWNMtacctatgtcaYKaRacagttHDagccgtaaYcaa
+tataatcatagggaaSatgMYBcKBBtaaRVRatRtccVtgtgaagVNttcttagtgtcW
+ataVggtaaNaatVgVaKctttNgtttagtaaagBatBtgaYSagHttSYaacaStcgca
+gaSttcDBtKtttggtctacNttgNgKNNtcaaaaKWactgaaYgaYactatHtaWcaac
+tgttSatNVtgtctSttYctgattVaatKgtaYcaaattSgttaStatggtccaatgSWc
+caaactattgccgttacgcNatcHctctcaKatgtagtctattttaaggHRatcDaagSa
+VgaVNccaBKtacgtttStagKgtctaHtcattaYcctaVKtttaYaaatYtccgataaa
+VttcDgatWcgBtcctaatttNaattgctDYgtgatcaatttaagggctctcatcKattg
+BtaBagcaYcKctctttNtaacHacNStggRtMatHHgtacatgcaMagtgtccatRWtt
+RKctaaaDtcMctttaNVgaNtcMatcacHcctgWtaaStcacgtctNaagRNNaagMaD
+tactDgctttttcatcYacttaKttatgcStDaStNaMgDtaacKtMtacctaaWattgg
+tttNaaVHatgaaattaattacgVNaaWtggaWatctgVatcacYctcVHMtVaNacNtc
+ccaWtttgcaacctcWctHaatcttWcaaaYaBaattSctYatctaagDgBttagtaSga
+WtBcRcKtccYatatcKBgtctttatgaaHDcgNaMatggatgtWagRctStagagaaga
+acagctWtNtataaaataRatHatKgctNactHgttRgRgVcRacatgHYaNttaHtatt
+aNStaagatgtagaHcVctcYgggccYcaaaatgatcttctagctctHMaMMgcaVtgHg
+taagaWHHtggtaactBcaMNNctagaacggWtctttgaggHcYNaaMHtaYcttKaagt
+SccgttgggNMStatacDttataaaVaYcKtcgcattttcgacctctcacVttNtttatt
+gtcttctaVcatagaattMttgtHtMgacataaatagttctMtgtWgWctttcaagYgcg
+tNaagcaaDaVHaaStMtaaagccccgtgVgtcacatcHVaDtgttBtBacBtcggYttD
+agaDYtccMttagcttacNcgaagatRtDataRtgctaatatatgRtWVttatWKtgcBg
+actcgagaSgtaaaaagttaaWaaagtatttctcWtatcBtcataacNcgctcRKaaDKa
+ctRaNtagtatBtgaaatttcgcDactttaNtYgagagaNttgaattaataaaSMattRH
+NtYtgttgaDBRBttgWttagSatgacDggNVagRWcggctacDaYSgaaattHgtYaaa
+gctccVtatacattaMctttgSgacatBKaattRgtaBRtttaactattctagcMKMttt
+ctgtgtgVgtctttcDcgtaaMtaggtaaaDtcaYtatccgattcYtgaaRttctKaNct
+aYgYaattYgRttWctWttaaaccaatcactVatgcgYttgaaatgatKBcNRgctcatg
+accHagcgaaaatgtVgccatcaBSatKccRStSattaaatttggtaagcVattctgVca
+ttMtacatMgaaaaaataYNDtDaatcatWattcaggNcaccctcBtgcKcHagYtatBa
+tgBttgtVttaYBgBgataaHNtacRtcaaBaKcagNtcagaatYgttWgggaNDagtat
+agRtctcDtDaHScagttcYcatcSYacHcagagNgtgcHagtacagctgRtatatMtaa
+tRaWMHgaaKacaBRtagHtaaaNcVHcatWBgWaaacWccggtaaRcattgMgttaNgt
+tVMVttgcaagagaatcaaaaaagYScKVtgccgacHgacgttcaMcctcattatgcBtt
+ttaagtKatDactccgBatHYgttcatcgaaatctSaKaagaatWVtcgttgtcttaMaa
+YaSDtaaaataccgcKMtatgKtgScaaDMaaaactgtgagcVtttaRcttgtaNMatat
+atttggtMgYVatDaatttgctttaaRtaBgttaYaaagKtataMtWStcHaaaaNacgc
+tacMttDDgactacaNaatBcagtcattatatSttaVgRtWgSggcaatSataVgSYgct
+BttataaYRRgaactgtgHtgacHWSactYNgtttBactatWStaNtcStcMttgattSt
+acctgaattctWatNaaHgMatattcaaaKWaBaataatHKgaWgataYcaWMBtgtacK
+agaaaaagaattttWttDaMtggttgtgaNMtVtDcaacNttactattacggKctattta
+aaaBKatagttHaatggaatatYWgtaVtNaaYgataatMaccWagagatRttMtgKaMc
+gatattaacaagatgttBBcNaYattcNgtRttgaBcctaagaSMttcMtcctcYattca
+NaRBttaatgVcMNgaacKagatcgNctaWVgttaaYRtgctSctaaaaNtttgctaaSc
+ttcVattaHtaaMacNgttNtKHMcctattttaRtttVtSgtacatBgtVaaSSaMVaRB
+caSaRHtaWtWHttMtattVcaMtWaaaNaccccgHYtcatagaaRtaaBaatttaBcca
+atcRctcatagWgcBHRtacaaDttcBgaHggcgctaHtgacagcSNattcctcgagacc
+BggtcaagWctgVcRDgVtaagtttaattatcMtgatNagYttHtYtagccRatagDtaa
+tcNtaKtacaMSgDaaaatttgHaHtRDgtaattKtaMHgaBcaWtBNYaWgtttSttta
+SttgataatgactMKatHBtttaVcYatgggttttaDKcSatttMatatcagtYaBtgVa
+caatHcaDMcccgtaataatagDataatVaaagaagaVtctccgaRgtRtaatcgagtca
+cttgttSatgNDHaSNRcggtaSaagcSaBgWSgcatcaaWatgttacatgattcWacMt
+agtgNcacgatgatttttRcWttSgtaatMRRBaacNWRHaaBaattDaagStgatcctt
+caDacccctKaagScSSHaaYHWcHcaWcaaaMBataattgDtagccWtcRHataMNKtM
+gHaBcatcgaagtgtaRgtgggaVMatgttaWRtStBHactaaRaactNctcHaaaggca
+tgcVHKHgaatcSccttggSaWatWtNcaaBctaRagaaacacgcttcKatRattcWtgY
+DaaaaaaNatWtKgaacgtNttactgWHBaccaWacggttcaaVgagaaacVtMttatag
+aagtatWtaaaNHYaMacagWagtaatttgcatcttcgaatacggaHtaatVattctaDa
+HtRKRaNHcttacatcDKttMDKaWggDtaatcttYctcWtRaaaaKtaatcctgcccca
+tgcgDtctaaVMtWRKKDctaatatDgactagWtaaaBcKcacMactMHHttgDataKHD
+aDttHttatttagtcaaVatccKWtacWtSVcaggtaatatDSatgcctKtatDtttaga
+cKaaaagcgtttaaSaaaYtgattgtKtgBMcKttgDaaaagttBRatHgcaKgDgtgcW
+ataatMWgcVaVatcYgWttaDatcatNaVgtttgggcttgaHRDaWgatttctgMHgtV
+tgccttBtWtaatcgttcgKgRcaBaRMtaattWgctaatMaVBccaHtDagaBNaataR
+cacYcYcHcatBgaNtgaNgKHttctYaacaaaYgBttRNtNggaagcWtDggattgagt
+HaWttVacaaaBtgttaNctaatactKaMaaaaaDtaRatttDaaagNttcYcaaactcM
+gaYgtacaaatMaaatYtcacVaacgaaDagatWgBgaataggtWtKaaMtgDttHtgag
+ttaatttgVaaDagttNMataatttaSVattNaDtKVccaaatcgaYVtaaaacKRaata
+atgaBDtctRtgVcttatttYtgaHgttBWatgaatatacSaacctSatNNRccagtact
+KagaRtgSKMcgaaDattttagtHcKcaaagtggtataaaggctcctaSatHtaMtRKat
+taNRcWtccgctataKggatWttaggtaatHDRatttattRWgcgatcttagSgtcttac
+tatgYgttYaVBtgcaYaaRtDaatacHHtDcttHgBgNcccataDtaaaaatctNtaca
+tatWaRMBgaattaaaacgctctctcaagtKcacNacgVRVctttttaacttgctcStat
+RScaRaMataNaKagtatcattRttNaVatcKgtacNatttttgaNcgacaaKctHWtga
+KStacMaBatgWttNSacaaKcaDaatcWaKaccgYBggMScgaMcctagcaDatgtttc
+VatgtRBtKNWHtcctWDtatttttNNSaatattcMttgatKgNgaNBatcSggtctRct
+tttttatatggtNttDYNYgaaaKctcacacYHRgttacatacttYacaataNaagaaaa
+gttataNaataSatacagttScacVaScaccSWtccagKHtaatcaaatVacatWacgBc
+tccaataHaaYtMtacKacHttttKtcataWWtgtgaatWaataaaaacatttcacctta
+HtttgttccaatcccgRBaWgatKgagtttBaVgaNtaNVBgcaataagaatagcaKRtt
+gtatcaattaMtaacatataDBgtaaNttcaNcgagatYactggttatgtNVtaBNtDaa
+DtDttaSaWtactaVtHactttNttcttcatWttcDatKaacgtttggVDaDtVagttat
+gtcagactKaatcaYtSgttttataaataDttKttKagacWgHgatataaatcttagatN
+KtttWtWaaatattacSHaRgtttScttaatWttacgRRaaMactcatBacaccatRttt
+gaacctacttcDMggcVaSBagaatcttaKMagcaVtctDVataWtSgatagacttBctD
+tBNWgtgKatWctYgaaStccgVaaaDattYatagtatcaacBaWYctgaaatttaKVgY
+tStNtcaVggtggaNYgaRtMaacataSttcagacVactcaVaagtggtattaaDBNDaa
+gtatatMtactatatgatRSgtttgccaacgcacRMtacRYNataagatcMgttgatcat
+aaacttVcatatgWtacaaaWttggaaactttaScataactRattMtDacVYataaaagM
+aattttKtgaBttKcaacatattVtagtcatgactcgDaacDtaWctatRttSSYNtgWa
+ScaaataagaaatKtagacataatggNaatttcSKtVWtgacagKWattcgVatttcKWg
+agcaWgNKaaaatatgtaaacgttcactaaWgacaccBNaacagaaStctgctaHcVttt
+MtcYttStagYcgtttBcRtaYacttgNaacMtDRtagcatgtgcgagcScaMgtaatBa
+KataactMttttattaRcattattatacgtaagSNatVRgcttcgaVaacHNtctaHBKY
+gKaccYcttagagcccaVgatttgttagactaaacgtgcaBgccaWgaVataggattDBW
+aattttgtBacWtttttaatDtMgaactaagcVtctcagBMKatgattgaNaVttggatD
+aSaBatttcgccatatgctaattgYacatgatccacaaMHtttcKYKaWtYcgDtNaaDc
+cgNaNcacacHKttDtttaggctagRVtYgtaactagctttcacaaatYtHaattYacaa
+ttaMSagMactcctcatgtScttcaaYtataaaaScHYaKcaYacactVcacataNtaBc
+aRatgYagVBatttgtaactttgRggacaagcVacctattacRcaaMacHRagagtaVNc
+tacagtgagacgaaaggKttacattgggacaataKNtattcaagWKttgatNagNtgcta
+NgagatNacSatctNatttatctatRgaaaatKatNKSBcKactatacStcagtaggtVt
+caaaBYYgctattKtWNttcRacaaaNatgaacttaRtaaDSttVBYtaatccagtNaaa
+cRttagaaccRBatataWaatKctcattcSacWaacaacactDttVttgacYaagagtaS
+gcMttBttaVNgRVagKDcttcttcNtaggttgcgacYacttaaggVHcaagDagaagat
+aaVaatctgtatRatDtKaaSDgattcaattYtcatgYgtgaVMtMaactaagaatgRgD
+tHttaaccaatStaaaaMctVDDtgttatcttaBBgccNacKMaHggcBMttctgNctHg
+gagaataYMgtaMccaataattHttYttKggtKaccaactcccHtMSaatNactcRtttc
+atgcKcatgcacttcatSaatatactttVtaYttDattgWcctcactcYccattaDDaHa
+aKcaatSttagKtWtcatRcaactattaattYaDggKtagtNcgSgtttKRgtDWtVHtD
+NcHWNtKtccgtctagtatSctaBcacgcaBtaacatgagatVtttaaggcaVttBttaS
+tWtattgYaggtSatBMBDactVtggttDagacataaactactBgcacaacMaagaStcc
+aWNaaSYMYtgtaKaMcYSaHaaaatatttMgtcaaDScaKtcaBVtaMVMRRDMtcttR
+BgWctaacttgaacNaatgttWgtggBtRttHVKgKcHVtatattSaaaatBttcBtttc
+DgHccBagtRBRttaVagBctRcaagcattacKccaWVWtaVcggttatNaSgccgKtYc
+BaagcWgcatgaNHaKtagNgcHcgtgtcataaaatagagacttgHYatattctaBgttt
+atRatctatttagacattttNtWaaSagtaHatRtctcggatttatgtgatBtctRgggg
+catWctaSVMaRtcatgKattgRcatMaHaataNcBcDcaggcactattHBgaatStata
+ttcatBgMVataaSacVacKHatggttaaBKtgtaSaWMattttMacKtgaaWaaWgctg
+RatgtgDacBtSaHtDgtgtMVttagatgattagagaSttgattgtSaaacagHaaatac
+aRcaccBtaaDtcaMtKaaStttatKagaataaNcaaBtattKaVNaWaNactagtYatt
+aaagWgHttaMcKaSagatSactctatMSagtggaYctcacKKgaSMgcRgKtgccagNM
+ataatccaVgatcttHagttttcttaaccataggggcttaDtYatcgaaaMataagcaaa
+tBttgHHcHagacagagaggcacWtacccMttacgtgNttattYctVaaactgttaagtK
+atMagttcacaaagggatgaVNMatgcaSattatcKagtHaBtgaagBcggagtWttVaa
+DaccMScactgVatccaRaSatattNtgcBatgBaaNgtcaBMgggaatgagtatRgaat
+gtNttacaggcttaHaataaHSagatagtgVctattaaagggaagDWVccatcKaaaatR
+ccccaSVaaatttMtatStgtWagtStMaaatBctgcctKWgttDDaSKactctaaVRta
+SWcVactggaaaaNMaaaccgcacNtaVgaagcttDNgaDBtaMaMKNtKccaVtgctct
+tMMYaaaaHaattcWgHcgtacatWaMaaKtaataccgBDaYRaggatatSKcScYagMt
+aatKHMtaaccatgHgtagDaggtgtaaatatagaKVgccRYctcRaKBKWtgatHYcaH
+gBaYtttMcatataatgaDttcatttaStgtcVSgacggtggVgtBtgacatgtaaSgtB
+gatKtKtaYcatVtNattataaaHaSccHaaagctSMKattcatagcacagtgBRataac
+aatMttKcWaaaaatagStcggRttaattatWaataatMaYagatgVtatccttttHaSc
+gtBgagWcatgBtgcctatcgtaaWHacagtactgaattaaaaaNattRNMaSSNSctat
+tcaaagccVVcatattttagMcgtattNtVBactacScattgKVtataaKtttgNaWctt
+NacctagtgaNaaDcagtaWgKggaaKtacgcaaaYttatacSttgYaYttcDNagggtt
+VDagHatSgtacYVatataVattataSataacgKgatVtVacHYRWttatcctaaDtgta
+aDgRDttttattWtaaDttggatcattNgtVaaaVggaaggcYgSWaaattcWHcgaSaV
+WaMatctMDtHBgttttaatctaWaagatatDKtVttaccgaMatRaaaBttaNagHatD
+HWcDtBVttaatKtMataYttSRHHcgtaHDtggttccaaagRRtaWtVctRcaNDttat
+acgatMcaatNHtacgaattBaatHtcccatctctccBtgtataYctatgtcgaaDYWtN
+ggatNcacRtMaatNtKcttSYSctaDaaaggctDaStatKtataBgcVaatttggYctt
+aaatgatgtHctaaccaactttgggttcMaaDattatKtVacgVcScaactSataSccHt
+tYctttgtggcDtMcactaNSBtMRBMaggttWKtattaatgtKHacttcaMVatctgtt
+gtccaaYNtaagttKaacttctHcgcWtYttatMBgBaMacaattaDaactNaaatSatc
+VtSSgatctatgNatSYaattRatgcDgtctataagagaagRgatatttcccaataHgtt
+ttWKtgaagNRtctaaBtWcHHcDgaattgaaaKtgttaaRtatgtaMaggDttcMacca
+MaattDctgYctaWtStaNtgRKaBtNcMHcSttMtaKccYacgNNctttatStgVtaYt
+aagttaagaBHaaStVKHatgttRVWtataMtSatgcaattcMcttatKgMcagtgaatc
+YtcctNaYcttactttctcttcatggcgNcatScStBtagctWtHaaWattaccgtctcg
+tBMcaaacKctcccaacttBgtWStVttMRgKcVagHttVtaagMaNatcaHttacatcY
+KttDBtatgSattVcgBcBVYttHNtcatKgcYgaaSaKtatttttMtctatctaSaatt
+DttcWagHSacgttagYgacWaSaDKatcNgctaatgVSctgctYgaKgKtaataggtgg
+agcgtcgaaaaRYtgYWYSaatacBgacWtaNStcaattWtRcttttaaSYgttcNgtBW
+WgtgaatHttttBaMcMtKccagtattttcgaHaDtSVgatgaacatgcacgtcagagDY
+attBcagDctcttNcNtaaaatRctgMcDacaagtttagtcaaSSaagaaacatacaDtc
+tctYgcaaacBcaagaBatgtattgacgagYacBDgttcgtgRtaMgaattttcNtgVct
+tctgtctagtgtccatatctgatYatNtatVWgttacaDacaHDDagWtgataWtatcaa
+BRatDRtMgVcgaaattcSMagYgWacgggtaacaaattcagcatagSgttactBctgSV
+WatYcYgcBWgggRcHtataSaattBcagHgcgcctttKcttWaggctttaaDtRacBac
+taaVaaKtaaacctcgcgccattactKactKSDcgacaVtatataggataKctcgSatgH
+SatVcgtagtgaBtSYtgaBataatStaaccaagttcaDtHtatattaacYatattatcc
+tacgagatcaccgtVSttctYgtcataaVactcgWtaVatttgttggactaaaVcaSaDt
+YcgNtYtctVaMtaattatWRtWcaNtaKcaaYggatgNgaatcaatcRtcgagtHcgVg
+ttataHDcatttaagttctHtcgMRHtaaagaVactBMtatgaagtaaaaaBNtataaNt
+tcKcctaNttaaDtcgMacgDcaMatttgYtaaNtcaccgatgagMtgttaggWcacHtt
+NgtcttHYMcaattKcagttcNcaaaacgNaaSattgKttaaBaKttatttaMggHcttt
+taaRNVgttaYttttMVRtYVgRatKcgVtacgaatttccBatBgYBRtSKKctaaaatg
+atatgBtcttcgtttgacHagtaattatatctgDtBttatgaDtatKtcKRcRttagatt
+attagHgDNaaaKgcgMtHtttKtDtgaaaagtaMatcagaaccgaatKgtatatVaccR
+aKYtDHtcSagtBgtgccWaaaggtYKcaHatDDaaattDStDtcKggtMgcMtgtHtca
+aVcgtttNtagtNtgKgctaDcScgBcWSatgtatagcKgWgttgaacgagtgcgcgtKa
+aaacgRtttccatatatttttMgaKagcVcVRataccWctctcgBcgaggcgttaatgaH
+YtttHtaSWtagcagtttKtYaacaaataMtaNDatRgMBaBacSaataSDctgaactat
+tgataaRtaVtttHatWaacWtVaHaaBDtactYtaDactttSgtKtRattgatttatat
+attattataattBatagattctaacDcRMaaggttcgtcatattRVYcttKgtRcgWaat
+cgaaWWatDctacaaaagaattHaatctgttttacYatKatBaccMaMaaVtcacStaaY
+gYKgtttctcattatattNgSaaHtgRaBtcataKYtHtacttgtacaaaDtYtgatagN
+RcYatgaStaaagactgtcWDtYaatVaNStagaaaWtaaaataDYtcaMatSVBVaaaY
+agaaaattgtgcDagWSaStattttaatNcacgataNBtaattggaatgcMgacattHaa
+ttctctaaMatactaBaaattacaHWgBNtNaaSattttaacHtgtagtBtcRtttSaNN
+aYaMaDtatDtagaKggYgcaaSttgctactDcNRtWgtttaVtggcaaactattgSgaa
+gtattatgDgcgtgtcttagcNtRctKggtMaHgaDaaagtactgtcgatttagatcagN
+ggtaattaKaatgaaYaaHaattggttVaaMggatactctaBgtYHMcttccVcaaWtgt
+tHHRgagttKaaagaBtaRtaaWaggttctatRatSgtatcYtaWcatgtaBtcaatcta
+atRgaYYtWtccattataBacttWtcctaHaaaaggttgacgtRattKgaagcattSBtt
+tctaNcSctSStNtYtWaWtgtagtcttgtctttaagNKgaagacgDaRgtNaBaVDgaa
+ttggaYtaccSVYKctSKKcatagttgSttatcStactcaatSMataHcaKgatWVYtNa
+cagtttBtRagYHaagtaNaaVVDgatattMaagattagcatcctaMaaMctgNtMcSaR
+cgctHMttaattDtttYttcgataaagtMtaagttaWaaDcaatccKgtgMMcatBgtRt
+aHBcttgtBaBggcaDcgaWttgggtaDaggtgatRtYaMWDttatcNtVcttRaKagct
+RgtgcNaatctgattatagattagtatatgaataDNatcYaggKRacaatcaHcaagtta
+gtKgRatRgttaagaaaatacVctaaaagtgtaagKVgcttSWaaHatagHctagtDgDt
+SaVtgatcatttaNKgKHataKBctatatWaNgtttgcRaVNttaDgtcttagHYKatYa
+VaBtaatgaBattaYcNtgcaBtHaacttVtccatDagVaaaYgWtNDBgacagVgctca
+RtaHaaacttttacaaggaSRaaatagaagaatacccVaHatcBRtcttttaaDMHWtHg
+acMtctcaagKDttctgYctctcNagaMgcgaaDWatMcMatatttDctttactaVScta
+gttcaRKWgtttKRaVaaKtacaacaKttatttttggcctataaDgtcBctBDgcYYaat
+NactcaaRgaRWcgattgVNcWaatctgKagDMgctatKttRatcattMaagtctaRaVa
+attKctgaKtatccgaaRatcHMaaaaaagattccacgtacgaDStatatctcataggta
+cgcgatgtgaaggtHYtatWagKVKgaMDcaatttWccttgKgagtctagatgaatgVRc
+ctaMttgtaRaaYtRtaacWgaaaMttatcatNcgttactaaggtDaaggcagtRctcat
+caatggYagccagcgaatatagtgttWtaccaRctagatttDtaaatRcDKtccHtBWgt
+tctWaagccYBSgtggaaagHNttHtctaaattaBatggaDMgaBgatatcaatactcMt
+aaKtcYccgatDaYgHDBaagBattWattgatttttaagaRaaggatggYggaKttaKtB
+VBcttaWcttBtacctYaNYttgctgtBaaMtWtcWaagtaaggWcgMDaaNtccWMWta
+tcMVgaSaRctaKtBgKWDacDgaaaaNgttcaaaaataMcttaWtatgNaVaaRataWt
+gKctRatataagtgttgacgaKgaNgtaHattaaRagSgattctatgtYtcaattagBYB
+atccYtgtNacHagHtacVcVacaacaccgNgBtataYaatWHSttattgctDacttgtg
+HgHcMcHacagctRSDtgattaggaDHtYagatggagWtaMatcRcccacRaaaYagcag
+atgatacatatttVBBcaaMtctctaWgaNtttcctaVcttaYBDBctRgSaagcNgatt
+tcacgtcRDaVBttaRaggtaaggHcacttccgDBKgagaatttataaaMaRattagcVg
+tttacaaagagaaaMtgDtttYttggcttataKaStacaVttBttcttgBcVaataaaga
+gtgagBgcgNcNattgaaacRcactDaaccaatWMtaaHtBgaaacaaccctcMctcaaa
+tctMWttggttttacttagcRtttacatRtccBttVcatgaaBacaYgagHttatWDtcc
+tSatRtYggHtNMttRgNtgcatcacgacagaHgtYaSaactgaaNWVagtagttagaNg
+atctgcatWYaDacataHtaWttaatHaDgactYgttcaSVtttacctaatttaDgRcag
+acaDtgcYVttaagaSSKBYtgHtDtNtcgtcWttDtgtcNtgacKagcactccDMacDN
+cccctWataRKcaaatttctRVaacagcaMtataaattWBctttgKgVcatttaVgtDgt
+atHtgtaSctagtatagcBtBtgtatgtcgcMcgagttctacgaaBgWccgaWatgcaRt
+WtaagYttaNtcWaHtgattYDatWRgRWagtRcHggNatNttWaaacaSgcaatMatga
+cNgggaSatgatttcBHcctaaggWactacagaaaagctMcaaagaYtHVgtaaHKgKat
+tVaWtttcctaWgaKattatgMaattBgaaagtgaSaaaWtSNBtttYataVgNatgaSg
+cBaaccatattcctctagRtattatctttctMtgaRtctcYgaatDtRcHgcRVtWtaac
+DtcacYatRcttNgcgaDtVctWtacHtatatgtatKaaggtaNcataKRaataacacDc
+tcctWgtSaWcatcDgatatBtaatHSNBtcaataaStHtacttaYaDaMtaagMtgNaa
+aaNccccgYWHaatgcBcttaBcgtMBKggccaVgacaWgaaaaaVYcRKctMgcaccWc
+tcSacttcVtacgaagtYtcctttttaYgttattaataactSttRggtcVgagWRStatK
+ataYcaatNMtacttcgcttVBaYRaKttaaYatacagctBgagcttcHcaatBaaaVcg
+ctcacaMgttaHaggctaDtSgatattggggBgRMagtaattggattgYYHtVtcttSRY
+aacttataBtNKgatVaWSDWacatVcttgttgaagScaDaSttcactaattagatKtta
+McHtMgKccaYatKataMcKNgattgtYtaaRHHcaWagctgtgcYatMHaatRDgtgtt
+YctatNKtSDtaKgcBttgagtKtacatgaaggcgMatDaWtcBatagtaaaatNYtSVg
+VatttcaNgRtaRaaNBttggaatVgaaaaagaaggtgNtttVBgccttgtgaBtgMgta
+aacBgtactWgtaacctatatggaSYattYtVgtttaagccaRtatRMcgWMgDVSNgat
+aatBRccNagagStHttBgctaBagatattaacaagaggttttcDaRagtcDgtHttcat
+aagaacaKBttaBgactaRatgaaDYHttgVagcMcBDgYactWgSgacBataMMcttSa
+RHgcagKcgaaYaDgttcataYKcttcMWttattaaBacDcttDtttBcatVggttVHtg
+tMgKcgaaVgtcgMaaHHYBMaHtaaKaDttaNgNtttttaggMcWttNaaaDaaaaact
+RgaatagSVHtaataagttStccaatcHataatacMcattHtacaatttctgatggacat
+atgcaaacaKBatgcagacagVcctccgcaacNatcMaHtcMtaSctgtaYgtStcBtca
+tDacRggttRgagaaHatVcttYWgaDtatgYcaBKgtSWVYtttctWttHtctaYtttt
+aBtcataaNgtBRaNcgttKgtgVKgggVtWatcWagttSttttttaMaRWtccgtttta
+ttaHatttBVtataSctRWtgcMacaattaStBcacggaatRatactVgaagMaaagWac
+aMgctaacaHctHtaatacacgaYagtcttKagcDttaKBHccgtaHaacaKVtcMKcaa
+taaaNaggttSaatcatgaNaaBtacggBcaagatcRgttttHaNgtKctYatBHHtaaa
+DNHtaVtVagttVacKtcYgcattcatacaaagtaacKaKKtaaNtNataaNaaSaBtag
+aattctgacacNtaHtataBDttBctataatagYSctgtaHcgccgaMBaggttaMHtKg
+ttactaaHaacgDatataaagcaWtgaMtttgVatcKaattcgHVNatNgDaaYtataHa
+caaacaagagtatatDStgcNgcRtaaWVVaDStNgtcaaacgDttaaggNttWcaVNac
+cctgaaaMcagVYVaMtBgtatacSacgSgNtaaaDtRaBSaWcNacgYaggtcaYtatt
+agVStaccgatgSStMattctWtattHtHaDtatgYaatattgttttaNggttVatcttR
+cgaNtHaVaStgaagactcacaaatcactgataaKBtNHtttctWWtattgactacNtaW
+atataaaBaatBttgggtatYtttYtgttttVttgagtcVaMVgaatNtaaNgKMaacgt
+aatattKWggcagtgRttgtgacactaaYacactggaaKaWYRgcatgcgttctBcttgg
+tVaaWgtttHagtcaatctcggaNWtaatBNcaMVKStaNcMtgatataatDYMctttcg
+catgcYtHtVNgStggagcBtggMgccctgtgNtVatactgcctcHcataDBtaStgNca
+gaYttaMtcaYtgtagatDaagaHaaaRcRataattcaDtcaDgttgtatRaaaaYaRgt
+ttDBgDcgaagcNttgcVttcacttaMgtMWaYaattcggaDcgaVtYattaBYaaaatt
+aHVttttWaacDttaRaSWactcBgaRctacaVStBaaatRgaacMSaagaatagYtNct
+caatagctNttaVtgctgtttgYcttaatgtgMaStactgDBagVSggtSKMYttDatgt
+MaaSaVtccSRMgaaaactHaatWWtcatttctDgcMcggVtgtRtcatctttNatcaat
+atYaKaaaatKWtDDDaaactaagtacRHtcKttacaataggttWcttataSaYctgctV
+taaVggatcctaHVttgWtgHtWttaDHaNgaccctatatgcWtNttacctaYtttDWtt
+taggHNgccatattacKggattVatatcRcggRWMtgcaVRaaHgtaataattttaggtc
+tcDccaatatgSaaaagatDtaaVtYgNaHBtcaYttaaaaacagatataaagttaaaDW
+ccMHMattggtaaagtccgaKtatDKaVHaBagaBatactataVttDttDaMagctctaa
+DSggtttgaDacacVatcttNtgatKtVaBStatgNtgDKYcaatcataWtcNatYccgR
+tcgBHacaBaatagaVtagcttgaKagcgHtttDNtgaagMttSttttgDDKRWtagtaB
+gtgagtgBcaDtWtaHcctatHatttgttWgagcggDtgtRDRcaaatagcacacRtDgt
+gVaWtaattRacVataBWacSYWVctgYtWDaVtaKataaacttKaaaMVHaaaaKNtaa
+acttgVataaaatMaaatMaagtatcaaRtatSYRtBtaataattgtttgaWtaNNtctc
+aatNaataaaaaaattgaaaattattgtgttaaYatccccHtaNcattcacttttaMgVD
+taDMtcaWSgYWcSYtSgaatHtgctagaVattaBtaaaYgatattcgaaBtgaaDacac
+atRaagcgggagggDMtatDttaatttggaKSNtactRMttactgtBggcgtcatNttct
+attaVacgttccKtVttMacttWtctaYcacgtaVtaaRgKcttggatSYatattttgtt
+acaaMgtgagagaSatattWcagDttggNtNaaYtaggaaKtYHcttgKattWagNgtaa
+gHHVatYatcattaaaaaYtHgttcaaaataattatBgcaKWKtagaatagtatBagaaM
+tattMagaMtHcWgYcacgttagtgtDNggctatNatRcYYHtaacMaSStattRagRcg
+ataaaatWNNatgaaatttVtKcRtKtDtaaMcctccaDRcaHtBSWcYtaKttcacaaM
+aataaMaactccgSgtYattDtaWctagatBtaatSgatgatHKgttgcaaaaagaScHt
+gaaHRDatSagatcBcggcatcatYVaatgMaatStgNgWaaaaMttgcYaaagttSHaY
+gaaatHattBgtaaMRagSaSacBaagtttttcatgttaaYcagYtgKtYctaStcaagc
+gtaVattaNatWtHgtHKNDtcNaKaVaStSacaaStttagaaataatgcDSatgtaKtg
+MMtcaaagtNattacMYgtgctNgVcaaNcDtaaaVtYggtaaaactgcaagaWNcaaac
+ctDSaaSgVaKtctcatataMtggBtaRttKtagRcctgttaHgWRaattgDaaatttHt
+accagctcagaccKaaBctaagtatWtaVagBgtttatgaHaaggattStaactWacKDV
+tMHccgtacaMWYctDtagatttRctaccRagtWcWgaaaaMcagttctgacSctaaaac
+tgaatcacaNcaMWtWccYgtttNaatttggttaaNtggttSattttcaacgYVccMtcg
+aactBtatcYttcYDVMttcgattaKWtatttagcaatatcagWatgcRVaatgRtacWa
+VVBttggatRtaNgRagttDYataacDVBcaaactttgtttgaccatagHMtRctaWcga
+cagtgcVcaaVgRgtaagtRaaaattSBKacBaatcagaatgtHattcaVRtatVSSaKa
+tNataWRVaaagMaacataDgataWHatcNYcMtatttggaSatttcHcgacaYcaKaaa
+tattacHcSaBVatHacactaMDataaaggcacaacaSacctgtaaRgtcccaaaatWtD
+tagtcaagNtttgatDacDgcagaDcWgatDaaKagctDWtttatatWgDcaaaWttStD
+tKtatSagVgaaKtaacgaccgMgaSaatRRcagYtgttNDggcHScaaYDWtcaacgta
+HgaStKtgMtRtaatccagtDaaacHgtacaaccHtagataNaattatcVtgaKaaNaaa
+aaaaagttgMgtcRaNaacagtaKcaBgtttgaMDgDMacttattatgaDgagcgtcaca
+aRaagtYaggMtaaactagaacagVaMWataggtatHagtttaaHtcagtaaatgRgcat
+gRctgaMttBaaataagWVtcHctgtgtYaaaaVtKtaSaaBatMtttgttatattattc
+aaBYctBWtggatBtgaggDagtgcacVataRBctaBaaaataatttttNggtccgtVaa
+aaataaattBHaatBaagaHgttaagcctaatcaaatgaYtKaatYtaaggtMgaRggtW
+gggNactaacgaRaaattSttWtaataaVtHgtacttNtaagHaSacgWggaYggNStcc
+tgacgDcgHggtttHggtNtMtttDatNDgtgacgtatacgatKatataaacaattSaaa
+gcagatKtttSagcaaMttttgaKtMtagtcRacctKSttBttaatMtgcgttacaaaga
+VaataattcaSaaWcBVacYKtacaNBaaKRtRtcgWtWBaRKVtYWWWgattgBctaaa
+tKaattaYtMtSBMBHDtBtaggDtcNctWYagtgSaaBaVtcttNgtcgttHtgtMtct
+atKtatVggKaSaagtttattttatgtactactHtHttSMactatHcaagaattVataaa
+MKNtaMccgtgatDaHcaacttRataacaNgaatcSBtatgacBcctcgggtaatWaaWt
+acacaattctRVgattctatgtgtatHagatagggacVaattttDtNaWKagtatatHta
+gacgaggtatgtcagtgagHccccaatNataKMBaHtcWgctagtgHaatBatSataDat
+atcacccaagattttcSatKgatWtgaagtcBMataaHaaMaattatgcttWWtttcgVK
+YNBattggtacttcaaMaVNcctcHatcgctVcttKatgtctctBMggacatcaggacSg
+aKttgagtctKVYaaagtaaSgaaaHaWactgRattaaBttVaHtggattagRWtaaDaa
+atgatttSMBWMaDactScgRYtgaVagNctgtSBataKacStHRatctVgBKaggccaR
+ctaacttcYKtcaDcttgaaacBBataatacYMgWgctgtacttttatgaSaaatYcccg
+attattRStccaaaBagaacaaaVtttgcttatagaaacacScccSaNtaaaaBgtaagg
+cDgtSttRatMYSWatcgtaacgtStBagttaVaaaScccSggaMDBSgcaaKaggatat
+acgtatgcWactccgVctNttMaYtaaatKaaatgKStaaaHaKatatgBtcctatgtVa
+BggaatBcgcaatgagtatHcYagctDgtWaaccagtatWWtaRtKagatagtgKatatg
+aaaggcaWgtNKaaagataWaatHaaaaaKMaaatttBtatHtctNactKtBVVagtatc
+acgtMgtgttaKtaatcgaaMHtYKNcMaatgcaSaaDBaaaaagaWaDtWMgaacattt
+DcatttaBaBtDttaaSMtcagcttttRWWaataattcNctactWaatNaBaattaagaa
+acttYRHaccatatKtaKcNVgttYagttBtaaaaVtctcgVctagctcgSVatatagVt
+McaaHRctaHStttNtcattRaatgtaRtgttaatYtaagcattgaatttaKtctaKKga
+aggtcgMctttcWaagcgWaKcttcYttgtgaRaagMtDatgWgYaataKaatSWScatK
+BtYgtaagagaVcacgctHStaacaSgBtgtaNRYaaWtWcKgaccDtgaWtgagMaYgV
+VgBaRacYtcKgatcagttgtaKcgttgagNaStctggaatVtactaSNtaaagtaatca
+attaaVaaDattHDBaHKDHctVggcaaacccKMaatVtgttacBcctStgBgMtScgaa
+HcatgctMtStaVttttcDaNagtDVaatYcggaDaYtaactaNgtccaattSacaaaaR
+gtagaaKgtcRSNtgatBacccttMtactatKgtaaRMagataMatgVtVKagaRagtca
+gMgMaatRHNttagaagaatgggaatcHtttttSgtNgYatgtgcYtaatgDctMaaaMc
+cVScgcRgKNaaagtaMtacaKaMNaBatagBttttcttttYatataNaWcagatttgMt
+gaaacaBYtHaaatgtaDactatttNatttKttSattgBatSRtgKHttacgattgcggt
+aaaaacHHtaNgMcgHaVDtgtagaagatBaaagDttaacSatttaatttaccagatata
+attggVgaRctRtcgccVatRNtDgcagBcVaHtBaatDttatgKRKagataaRgcagta
+KgagttatatcaMSagttccRcttaaatgatcttataaacaaatttcccttaBaWtagta
+gttMaacMaKaaaagHatYKactttRatgtctcgattBcSagaDKtttHtBaccttNttV
+ttVVtggttacgtaaBMRgatcgtctacaaNBtaVggttYaaggattccaNgRgtagBtg
+taBacaagtataaatBaaatKRtaMtKHgatcgYggDSgKRaSttHStcatgtatatWac
+acRacHcatYtttaacYatatgtgttNtgcSagDHgataYttNattatcVattcaaYttg
+gtaRHtWtcgaBacgtttaBaccaBaatgtcgcNagaNtKtaDtgDtatgDaBtcKgtBg
+atacNaccDDatttYtKggMtYNtaactgVacattaaHgMttatcgtHMNtataBtKSgc
+caVttaBcttattcBaagtgaWtaRtcctDVRatgaattgatatgaWgccacDaatKaHt
+ttacatNttaWNWgtacaggctacttBaYaaatatacaaaatttcgNHgMgttHctcKYc
+ttgMtaacBaDVtaatttacagaRttttttagcKagtKactatMRtgtDtaattccRcaa
+KSttagttttBtctatagaKaVttttgcNagtKVccttagRgWaNaKWttataDgcgaat
+gMKatgatRcYtctgVagaccgcgVgactagaWaaHNtcRNRKaatactcYaNtSDKtcV
+VggNgDagtttaaKRgttaDcgtNNgtcaYttggtttYtatgtaaaggattttagatatt
+KMcatgYaaatcaVactcagagtRYtgtaactatagtBaDtVaWatDatctataaaSggg
+tactaYaKKWagaaaaataaattatagRcaaaVataVagatatgtaggcWagacRWattc
+tgacgcDtaBcYattgtaDggMatgagcgagaggctaaatVtctcagRagDtSgKNcgtV
+cStacatttagNtgatSNgatcYVtHattHtBgMacRaattaHBacRcNaaccctVaaYa
+attcVccatacKcttSagtctgKMNagRaNcatNgcgHattStSKYRggtcagtcaccat
+tttagtMaccctggVattHaatVagaaMaattaVacatacacaaattaattacgtKtaga
+aaMgatWgWccatYtagacKatctKatMcggYcgcatgHRtcStVtaatHgSaaaVagtg
+aatgtgYtattaYcRagatgatcataacacSgaYaactMKttatRcgaataaMSatacNg
+aMatttcggccacgaYYMcaKattRagDtRtatMVBtaattWtMHgNaWDgStaaSNggS
+tcBcVYtaYagaHtacagttccMcgtYtYttcattgSWcttagttcgtHtgVRYgaMact
+tBtatcaactaaaaVtDgataaDgtatcatYDttaStgccBacctaaBagttgRtaSBta
+aaagWgcacBggttagcMaYatttBgtaggtRBaSagttcacgtaDaYaaaacDSaKatt
+ctgtSatatgtatggVBcctctgtgaaHDKgttaRttttBMHgRMgHagtagMgacgaag
+ttaatattgRtHtHttatYaaagcagatgtgattagtggcactactVattagatctctgt
+ttatcattYttgatHcHttagStgatgactctDaaatcagtgttgtttttcYaaagtata
+tcYcaSaacaVttcgWtatKaaaHWtRgtttaKacttctgaaNaYacctNtcStatttaa
+agttKgtgatcctBcaBtctttaaaKagttgDtWctDtgtgctataKagtaNHatctagY
+gatcMgtggYaagactgacacttaRaaccHgttcaYtagWtggtgBcStacaMcMHataa
+aNagatactccaggagttaatcatRttttgaKNgSgcaggtgttRaYcaaataBtaDtat
+HgBtatacKaataKtaggaaatatgcataaHgaKttttatMaaaNgMatYattgaatNta
+tVaggtKctttHattcatttatYtattagtataYtttagYcattagaaataHtaacctta
+ctcatYttHMRagttctDagNSVgcgVaNNattctVcaaVagaatttaagaggttttacR
+agtagtaaaBaBaaMtaScKgVaRcNtctgtataagtatVgtDgHaYttcHYttaagatR
+gtgaattctYaaaattRtcWtacDDaRatcaKtaSacaagctaNttRYagMSDKtWgWaY
+NgaaaatatNtaatatHMtMWRaRacaaaatgctgctacNKaKtagttgVatDaVccatS
+DtgaSggcgWatccBgaaVtgtaWttagatVaBWtacgWtaYattaaatMctDgDaaKat
+ttgaaatgctWctttaHtggHaBBSRVBWtgattgagatccNcaaaHttccgVcttaDHt
+NgtttaMggccVWaagattgKcaacgagtatgtccctctcttaccDtHcttcctBatcSt
+VaactaatctacatgtacataacDgcgaVttataagcaaRWataattcggtMaaBccYgR
+ctagatctNtBaggacMaaaNgctgttHgScgttaaVgattVDtaaNaccggatatHatK
+cgataRtaMcagctattcaagagaatHcYRNgNgcaWtgagYtacttNtaagStaVVagc
+tgcaaggHatgtcaWgaattKttgtcgaBcKatKKtDtRtNYNtctactatgcgatgtaa
+cDtcaYgaactSHctDataKtcaagtccVRtWaaKMRtagKttaatagtggKttYtaKtV
+ataWYgHBatataatcatNMRtDYaYcttgttHagRtYacgaDaaMMtcagattBVScat
+tYcaataataBWaBatgDtBaKaHacagtBggaVtgtgttRtgacataaagtBtaVgtta
+NaatcaSgcctgtcBBaVttctHgVttcttgttatccaatacaNtgcgctatacctcatH
+tNaBMtgtagaDtKagtHatacctHgtgaDVWtatcWgtatScattactSgatcWatatD
+ataRSgctHaaWataataYacgtacgtgDatHcgtaacSaaagYaMataYaactggaagt
+KgattKMaatStRgtatVgttcttKSMtcataVtttaDtgttatattagWtatNaDcttg
+ccHaMDttStgtctgagtRtatRSMWttaStcatattaNaDtcaatttaVatgMtcaatt
+agMYWaRcNtDttcaaagMgagaVHtatYaacggttScaaccVKHaaatacWagaataac
+cMatWgctDtatttgaatBtNttgaaBgagaaWcttggatcRctctaDagWBcacaatMS
+tBcBWtatggtagtgaagaMKatacttaYHtNctgttHSMaWttacaSaatgtattttgg
+ccatatSatcgctctttgaRRVVtDaatcSYHcSDNacattcMDaNVagatctSctBcat
+agtggHagaVtgtSactctSHaMaWtgtatcattWtacgaaHatatBaaSaYacagtaaa
+agtVacatKtatatataVtagcgWccacagctcaaccttRtatNactMtcattaaatttN
+aaggctgYctctacatcaVgcMHaagaBttcgYDaSRtHgaaaNcaWYBggataatBact
+gaataYgcgtaacccactHataagaaWgcgRacccagagaVtataggcttNtaaaaHata
+catttttYYatHattgaatgtNcttatNaVcaaRtKctcgaaWctDttttataaatgata
+gcgSttcVtgatataaataataBgaatgaRacgagtaRctttaactattNagtcagtgtg
+aSgaHRacgVtggRccatttatgtMtattaNatgttaaatRaBRttcatcttaRBtNtaN
+SWgtVSgcNacBtWaDgaaNBMgagaBMgaHaHagatttctNtWatcaaaaDgtgcaaWa
+ataBattaNtatgDaMaWDataNtctatDagatSWctctggaccatcaBgtatattaaHa
+cHgattcgatgtRtaYattactNtWgaaRgcgDaatactgWcKaMacRSaSaacDgtgSg
+SRaagNtKttattcattaagtctgtctctataaVgctHKttgVtgacgattgRYcatccW
+cMtaBagaHacaaaDaaaRVgcacatgatYaatatttMttaaWBtctcgaNcWDtttcag
+YKattaRtttagHcKaacaBcaggtaacctaHtaMtttaHacctVacctaaagtcacttt
+cWcaatggatSaataHattacaMggtgaaWaacagaaattgttggRggcgattatWtaKt
+ScWKggtttcttgtcMaRgYYacacggagtgccDcDattcaaacHaacttSScaaStMtt
+aYtgtcWaaaaaaaataBataWaatatBNttcgttgtVatgacaHtgtacatHtaatgtK
+catgSatacVRcVctttagNttaatKYgHtRccttDBggHgDtgaatcaagacacWtcgR
+WKaactgRaDNMactactgacaDgVgatcaagNRatacagattSMttaattYtgWctRgt
+taaKMgggaaataagttatgHaScYaattccRMggSagaKKttRggtttgDtcgtcMttt
+tggaDgcVctYcaaataattSctDaccatNataDtaaaWtttagHMSSaagaaBgatYaa
+ggNtagtgctcMaatttWMggtctatttggaKagaggatWcatttgctatcgcccBacac
+ttataagaYtcNcagaNatcaYHgNgaacRgtaDgaNYttcattRtagNDcHNVcgDctg
+gDatDtgNaaaaaHgaYagtRtcaaDcgcaKatcagttattcataaccNaatacacaaYW
+catBaaaacaRttMgtaattctWttMaMtttccgaNcatVtgatcBaRtttgSaactcaK
+YaaNtKDttttRagaMcDYgcaKcataVaaagattcatatWcHtagtagatttctBtcWH
+tctaRgaSttgHatgaHMtNtaactgaaaNWtDctgDcacattMctNgWattatatctSt
+taScctaDaatatDYataaaaatataatNctKaNaatatcSgagttaagtKDttaaStaa
+HtttaatgaRataBtaVcBtcDWWaaDaacacRNtaVggatattatagtBttggcaaKca
+cRNgaaYaaMRaHtatBcaaacNataKacttaMtaacaacgRtaattgggaRcttagtWa
+taactKttDccgaMcacNHKtattStaRcSStDttacggagagtMtaNHatttWRNVgaa
+acattcScatgctaVSttaRaMagatcScaBggtatacgatVttKcVtagtgccgtcDta
+gtRagggcagggRRttKtcgtKDRaaatgatVttDtcatMaNKtNacagMattgttcaac
+KaatYKttaactaatgagattttaBattBctcaaRWgtYtYBatDcattggRtaaHttca
+NagagctcaRatBtaagHtctcttRatagBttHtgatgattgcRcgtgSaagcYaccacB
+WgtaNtctagacgaaSatBNtHMcKagttaaDcHtaDaaDtttccaatMcaSaaacWWgg
+tgDtgtMtcacggcgcWttcBctaaVatggaagNgtaacctagatggYKRVttRtMcgtt
+aagccaHgatHBcgNtctMKDcYtaVttHaaDWcYcKtttttgatatacataggaaaaac
+WgctgttatWHaggatcgtggcataagaaaWtttgatcaagaDatgaWtRtttgMagcBa
+ttcNaatNcKgaatatWBBcttKVHtgcagtagaYRatcggaagaRtattaBNttattaa
+taatatgtttttaagMggggMttctBgtcgaaMctcctaVttRtBattaatattgVDcDt
+ggtgaccBaNttDWaVtaaaaactHcaVtacKMtgaataacggHtaaaatatataYtacB
+cattttSaaSttgatcatccacatatgcYaVcattatcaagacYcMaataagaWWcBata
+BattcBtaKatgtaRgtKgattaSttYaHcgttHcacaatatKatgRMgatgatgRaatt
+ctKNMRtggatNttttagYRtgtgYttaataaDcttHaDcctttgggMtcgcMgNYtcNa
+cttKtttttgYBaHMgcccgggtWttatVttttMtVgaHagDNtccBVaaagtaKttaaa
+cgaYgHagVatMgaacBaSacNaaaBcagaaaatatttaYgaaSccaRacgctgtYcctt
+tStttaacgatVWaatKtaBtaaataVaBVcctgKaatcaggaDYatgVcgctaaacVtc
+HctggttaDggtatRatttttaaatDttaMtMaggtMaattaRcaaggaatVaaaactSR
+ctatttWaDtBataaBaaKattScSVgtatcWaaaBtattVtatttttatYtaatacRKc
+gcgYtccaacVBtagcttYBtgtgttaataataWactatataaVccaNtcaBtttcMaga
+taatgactMBatBctaaRtatataaaaaaRacagtatYgtHgcaDgaHtaaNMMStKtDg
+taaaaactgtaaccBttMaaMDVaaaggaVatcScMRMaBttctSgacKaccKcDgaWat
+tHVtKaNcDaagRSgcgcaRgagtacMKtWaacRtcKKtBYgtagNtatgtttVttatcR
+aWtattcgtttaDccttMVtatgHagaBgtaMWKtcVagaagcaaaaStaaatgagaWtt
+tDttttagNMgVttcWagacDgaMatataaataagtttgcctatRtttNtcttggMtggV
+cgaMaBMgaatDtVaDgttaaacgaagVtttNccaagtgHgtgtcScaataaRYaactgc
+VWtaNRDccSggagttattatgcctMaaNcgtttVgtcaatctaccaDMtaattBaatMt
+KgaDcBggatVtaattRBattgcccatgaNtttMDcKtgcaccttccBccaatctgDgMS
+gaagcactctaWtattgaHgcDaagVRgtaBtaaRtgtYcYttaagataaaHaHataatt
+aattaStcttcgatHWaaRRSHctggttgtccaacaDttcaKggcVcgtSBctBNaRaat
+tcgcatagaMtNattStRSaaattVtMtgttNYaatgtaHaKNSagatcaHctaaaKKgt
+aYatDgaaaBKSacaatacRgDctaSagVcagDgtYMtcatcgttcRatgaatgtcBSKt
+SagcttagKKccgHtBRgttStgtBaaKaMtaaKHBgaVaVattaatNNgcattgagtca
+BaggMgctHtaatatttDatcWatagRatVaaattNttttaaVctYagtRaHttatttaa
+aVtaccgtNattataKSRcgcagMgaaMccagaatatMgtgNtcttNtgattaBgaaaag
+atWtccNtDggaaagaNttttNtttSggtDcaaagagtactccattMatataHcgcHMBt
+gaaKHSYtctaVtaattgtacctctctaaaVtatgKaWaacagttYaMtNgDYtttcYRt
+gYaWaaaacagataaacgtaVatNaaBtBattcctWaaggcacatgWtttaMtVtagata
+tacgataMtttggtVBagatctRatKggttgcYtacSaMStattBgcatttKatKtVgcD
+gcttNaaataatWNtaDStRaacHtacttacataatacaMtYgcggcatYcactttttDt
+caacBtgHttggctttHNtRcgatctcactctcattMtatccgattaggtgggNgagacg
+ttctDtHcaaatacaVaaaHttctcMaNtaattHWaMYgatNacKNNMatcRtNtYMgVt
+ataaaatttaaaBMtaaaatBtaaacttgMataaaagBaaatBVactagaaaHtWtKRHt
+tgaatVattctttgaNgaDDtatcVWtDaataaaVaaatgcaYaaggatgggcttaaRat
+aaacttVDcattcaattgtaBcMtgYtBtcaMKcRNaKRtKcaatttgatWgaMagtWtg
+YVaRcagattacaWttgaataaaaWgHaagacggYccctBtWttttYVtttggatKBtVa
+gHBgtaatgttcgaggaWtDtgatattaMaagttcattMtttWcgtNgcgaRcaactaMg
+aVHctctgcgagKRatWtggtcgtWaaaBctcScVcaHatattNcactttccBtDaaNtY
+ggaattRtcggctaggNVgDcgaacttMatNagaagtaaRaaRttggtaVSaagaattat
+tcaatNttWcaWtaggattScaStgattBagVBttaNcNaSagttagtcttDccctatBa
+tHaRRttaacBYKKtattHVcHagStaSaatNDDatcSaVgtgMttaHttgttaataatc
+aYtDcatttHNaRgWtgtaYcaaBaagaatYaagaccKggRattttaNcgacStttaatK
+cVtcYtttcggcaaaSYacaKattgSatHtWtKVcagatccccStaatRMaatgtaatKt
+cDgNaYaaBttccRaaacttHtaRcaaagtatgtctaaBDVcKSKVatSagtggttaatc
+ttaVNaagRtctgRataKgcaagactSKattaBatNttggttDtgcDataKaKgKacaWH
+gttScVaagaWtcatHagcgattcBBtcWaactBatgacBRctgatDcMaaVDattWaaK
+tRcctYVYacggaaagVNBaaaaaattKYaKcMatgagcatStaBtcctgaHgtttacHa
+cgcttatgNHWatgctWWattttgYaaacctaacYcataVtagVagtVtNgaMagtcgtt
+atcYtaagcatgKgaaagNSattKtttaaggacaBNRatttacatttHctaaaHactNcN
+caaaYBcacggctcaaHagaaSaagcaWtcaaaDaaBNtNacRgtttBSVtttccttaaD
+gcctgKSttgtcaaacNMcaBtagaWatttVgcRtgaRtMttgccVttatNtatggacaa
+agWgcacNatcaDMaWtcHgaaNaMMtttgcatHtYDcDactttRYtaaatMtaVaaatt
+ggtgtcaacatVctBtHctYNacaaactcaMaaaMcHgtaactHaaWattKttactYata
+agaYgcttattaWMDgStMKKatatDataNHMaSagBaaaVtYtgVtaNtataDRcBtag
+ttcgVKagggatacaaSRaataaatagtaataKatMattVaSatSBtagVaYccaaaYac
+aKSactctaaHctaaaSaaagNttgactaSacDtttcattVctccagYtcNcagtWatac
+attNgttagagNctaYaYNttKgttttatKacMgRatgaaacVccgtcaKaatHHcacRt
+gtgDtccatHaaaRtNgcaSagtStgWKtttgBtHtSagaaacgtaSaatctacWaaatt
+agagaDaWgtataMtgataaDaaaaaaaagttcBggaHaDWWcYctYtcatctttcaBtc
+tBaattattagcatgWcacgcaaaaDaactRVccBtaWaatYcVVcacMatNatacctSg
+tWgtttaattcactaaagcHgaatcHatcaBtgtaWatSScMMgctatctctRaaaWMgt
+taKaatagBtttcttagaggVttcaatRattNtccatttcagctactccacMatSHtaga
+taaaWgaagtttgDcctaagtMaaaYagaaattttVattRacatctgaaccataYtcaaa
+tcaRttaStRgSacctBcaHcgtMcccBaagaaagaDaaattKttNtaataaMgtctYct
+tDgaactaKaacNgcaRccDKtcatgaagtactcgtgttcctBtBtgttatDtctgaact
+ataacagtagStaaaaaatgHaaacaacYgtgtgHacaaattgttcSttBtVctaHaact
+tKtttttWatBtcccttaaVaacaMaagaattcaKaSNatMScRtgaaaDtSStDtHtac
+NtNtaHtMtNMNNcWtgctctaaWttaattaNtttKtBttttttagcttcDagMNagtcK
+WatVMgcttBcgccttttgtBtatatttYtMgctaKaacttgattttatctaatRagttt
+ggKBSatagtaVVcaattMataaSBtDtaBaactgSgtatcaactgHataacaDcaRtcK
+ttatgaatcatacgcgaagNYaNgaaacaattatHMgYgtagatctctWttacatVgcgR
+cMaagttgttDaNtScgStWgtgacaacacggVgcgaSctcactcaaaaYtDatatBtat
+taNgatactctaagtWtKSgYtatataaaaaYagaggttaKagtcYtNtgaagtctBWga
+WtaaBaattStcatgNNtttagMtRDtWttgctYattcVSBaMDcagatVgccatMattt
+atctatcgtBgcScYtaaccaaHcattgcagtcttMNVaactWWKcaaataNaatgHatg
+aatgtMStgccattacHNgVataaYtgaggtKttNBVtYagKacHRggYMacDatcgKta
+tVtWaKgtHatatMgttScgaaVHagaaattaNttaatatgcaaacttWgRagaaRBcNc
+atctaagtggatgVKaaVgNcaccagtatgHKgacaWatYcSacaRaMgttgcttatVca
+aWcVaKaaaKaDtaaaatcgVaccatcgKgtDagBNKNatccgaacgtKgtYctgaKaaS
+KcccKgcVtttKcaaYtagcagatVcctVtgaMYctaccMcgDtgBaRtaaattaaagct
+KtaaatatatVgctgaatatctMatccaattacaSYgcactWttaRacattgtNaYcaac
+tatNNtaHttYcStactctatatcWSaccaVNctBtaaagataNaagtaaaaStBaaVtg
+gttatttagDScttttMMWctagcaactBctcttattSatacSatttRtBataatcaaKV
+SttaaaaacaNattMBcaacagtttcVtttatatttgtaaKBgcacattttHNNaVtWag
+gaDataatNaWtBataattVacWaaattRHtacaSgWtttataDMcttRScttttaaaaM
+gatacMatYccgacKMagVtWcMtBaaatDatatHtttDtaattHaatctaHgcgtaagR
+gWaccattgaStttattctattcVacctccBcgttaNaacagNWtagtaNgtctgaHaac
+BgtatgMcRVatataatKNKaagtttRgtaYcYcaMaaagattKgaaaaKcttgtaBHNa
+WNgMatcacctgcaMggScBaRgMMctaDaaRgctcYtaacgtgtatacttcacDaKtat
+gcaatMtactaHDtaaVcgaagaaaggVaMaatYtttttattttatMggaVYVaaatBaa
+tMgctgWctaagKtctgBtKacaataYtgctBgKgaMtgtgataBagttMaagRcccVtS
+NtaWcgVDctcaSSttKaaaaVaDctacYatctcHHDtgattaaccttttYatattcgaa
+HBagWgYtSgcMtMtagaHactaSgBgBSatHtDttagaacSatcccaYtatttgtgKcg
+DcRatctccNtaagctagBVWaBaaMHacaHctDVaWgtaBtaaStVtDYtatacttgtt
+cttggNYtatWBSNcagatttgBtcVaacVtRgtYaatctatSatagttDatgttgtKag
+tctagKHtcttttaccattcccctaaaaSatttaDgBactaMttctVcaacVgtaSYctt
+gYaaKaggtaWttgaaaYgagataatgccMgSHatHtacaaMatHDttcaagtaMatgta
+agtgtaggtDtacStVaHcaactatgagttatataaBHagggccHagtaaagcRgcttag
+YaaaaaagttaaattatYNtYctagtttaacBataaWactVtRtaatgtHatctagacat
+ttaKagStttgttttaaagtDttMtgMKgcgttaactaVttHcatccgctaaaaDttSMc
+cttNaaccattacaBcHctVcttctYtaaSSctVtRVattaaagtHtaBgttcatacRcc
+tKctHVHgttKtcatctatagNSaacHVatcVgRtgtaaaRatYtcgggtBtgcKacttg
+ataRttDattatcMaggcWWRttccgaHttNtacYtYactgtatWaaWtaaggtacaDac
+aDgttStgcttatctattatgttgStaaDaaattagttRgtgcBgRDtaWaggMaaVttV
+RtcBttatcgttBDgVgatttKgaaaMttatatgattataWctcWMgaHgaattMDatgV
+agtgatatcaNcaaaataSttattttaaatDgtaNDNggaaacgataatttaRaaatata
+aaVaagttacDtgtggttctatRatgcBtaVatVtMtaYtttaaYgaHttgttgagctac
+ttaatatBHtctttaagtcaHaWYtKttacttgtttatagacataMgttgcaBVcttMac
+ttYcHcNaDatNttagatcagaatcttatcatHaNtatcMagYaacacMcaatacaNRat
+DtaHDHtSYgaatcRaBtKttgaMKgcDgtacgtgYatHcggatactDDctaVRgtgctt
+tRtatgtaaaccagtttacVtatttBcatcRaaYgcaMaagaacSctHRtctaWatatac
+gtattKaNagtagatataaWKcgggacgaRWttNacaaaaagaaatgatacDaaaaMata
+KacatVgcgVcgcNacaaHNattaggaacattYtcRYtggtatccBatcaccgacaccag
+aaagMgataacHRgttKctDaggMaKtaaatttScBtcagKBgYtaRKttagttttcBaa
+HYatgattaaDaDVacaagKaaRYattaMaaagVatattKactatcttDacHaDaatBca
+ctattKtKtRHggtaSctaaaaagtttaggBScaatcgMStttaatKacaVBSattaKaa
+agacacaaagtaattWactttacWaaBgYtMcMccagRtacaatatcttatBacgNagaR
+tctHgaKtMgaattcKYaaMacgcaatctcNgYgtYRaHagYtcVgaagaacacKgaRaa
+cgBtttagDcgaWgaYtKataaDcaBatttccgaaaacaRRBaVtRtgHacttHgagtMt
+tWattMtBtgDaNtgKtaaKDccKgctaMRtaNacattacWcttacBacgRtRttaYggc
+KNattagtgactttcKHNcWBYagttgataaYagaWaSMttgataatctataatRtggaK
+tcactWaataatYgtgcHgYKttaaaacNcaSatgcggacaBaRattttcgacctHtaKY
+gttaaactataRaaSactKatSggatgtKYtatctYggcMtactatgtgaWtttctgYDt
+tggtBtcHBctactacBcVacaagtgaatSttcHttttttatRYYaccagatctgatgac
+gcccVataagMaggWgYtatctgtgtatcWttRttcattattgYcHtgatcVatcttVSa
+taactgtgcgtgtgaRWaacgatSgaNaVKaaaaMttccNtWgtVaatNtHgttgatVct
+tatcaaDaRScagDtaKtatttYaSctttctcatccttaattagttaaatactgctgNct
+tgctcatatatactaDtagctagRcataBcgccRaacaagcacaagtaHYaaatgttaaR
+gacNgccgctcKtacataBtWtaaaDagagactacaccacggaagcStHgggtcatDcKc
+aacctctgDVRaYaatattWttattcttataatWatattaccYaagWtgaataatgattt
+gtatBYSaDctatRattgaatDgWtMacggtattttRgtaagtgWtRtagtSctVtaRgt
+tScRcattacYYatattaRaaggaataagRtttBHaggtattacBHMcacKaDDagtatM
+aaSMacaSggtVVgacctgttaaHagtactaaatYtSSBgaKatcMVHcDtatgtagaVg
+tWtMcttctYRtgctRtgaacatDctcRaggatRaaVWtgHtaMgaattaHataStgaKR
+aVacataDtgDRagBHttgNcNaRDcaaSagStDgaStattBtBNHRHacaYaatcagca
+tacDtattWctgcMattaMaaWgKttgRKgcacNYtcatcaaKtctaNtgacatMatMgY
+agNtaRWtgaaatBattctaStYgttcSYatcctMagtgatgcgtattKHKtNtcattca
+catccDaaWattgcacMattattgDcttgaBgccaMNaacattctcaacgaggagctaac
+tagattWaatgtagtcagtYtcKtMVSagWagataaatgtaaVtaSatcccVMttataac
+aVWHNataWtgccggBVYtacRgHatagVtctDttaccaataSaDgcggtttcKaggtaa
+McatgMttaaDacaccagYgtattacWgaDtaBaacctatgaWagacaYttcRHDgDgaa
+MtcagRtaattDtaagKtYMMacagcaYacgtWtctcaNcaagttttctacVtatagttg
+ttDgDRDtatScgatgcgagggSacttcaNcVaatKtattRtWttaVagtaaMDtMaatt
+HtagtttaSgWctcctggNgatgMataNRcttatataatcVtDBHgtNaRatgctttacH
+tRacgYtYaBBtaScWtttMKcStgRcaSgaagatNVtagctgtatVtaaagttcgWMtg
+tcgtHtcacSgaaWcgttaMcttWDWataVKcaatctattaKgtattcMttattcgtatc
+aaatacaDtcacatatVaatcSgtgDatBtgtagatgtagttataaagtctcatMNgata
+NgtagKcatgaagKcYgcNYtVttYtaHKcattaaMagaataRWacgSactctWgtcgta
+aaKaWagRaBataRSVatccYacttcaggtBVatKtHctatMcttctgtHttcataMgtt
+attcttRtYttagNtVtDatattgcatYBtggKtctatcYctDtagHKBNttYKtcWtRg
+taDatgaaStgtaMagcBgaaagtSctRNaHcDgtttcYaacBcagaMttatRaVacgtt
+KaaaacMttaWSgWcNRcaVgSaaaBatNcatttatttgYatttDgtcaatgagaYNatt
+ggagcDagagatacNtaacaWtBHgtatNtaggctaggcaacYBtatWctgaRttDatcg
+ttKtaNtgaaaHaYtcgattgtgccaagagKatcgatatttcaDHMMttVagaKRtaKtD
+acYgtcBtaDMacagatHcttcagactcgtagaMggtKSctagKtaBYMggtagcStgNg
+aacaatSgattaaKWNaaYggaaaacgMaaattgatagagaMtacacNacacSgagcYVa
+attHgatDWatBtaattaaYttgDaacgctcRatatacVtcaMgcBtaagattgcgNtaH
+DgtcaaaDcYMRtgcataVgtaatcaagaRccctYWccaacttagaagaaNgccHWaaaa
+cacaMgatScgatgDtWaaVtatacatggtgRNattattcaatctBcttatDaMcaaHtt
+atacaaNcttgtttagSSatgatacccKttaMtcatWgaVataatatgYYtcaHaacact
+WHatttVYatatgDactaaggcgcaKcatHaccMtccHcaatgtWtctttatgWDatctg
+WaagHVtDggaagagtYHttBgaDKMctMHccDaattMatcaaBtBcagatBcatataga
+tttatDtNatcaaaatctgaaSNaagatagtVBtagctaBVNtStWBgctagtYgatHNa
+tatgcWacWtaYtctatatgaatactcattagatcgHgaRattaatDtNcaaDgactSat
+actgNataBYaHKaKaactctcHcKHRagDttgtYgtaattaactagctatatataaKca
+ttttgcKtcaacSttgHRaagacNaBtatacataaaaataVWHMcaYcagcagRaagagt
+tBttaaMtgatacSDaNtttgaagRtattaHtttagtatYaaatcaccgaYaatattWBt
+ttataactMYactaaactaaatttcNcVatgcVgKVatatattaaatccggaaNaacaca
+SatgcttgcHccacatgatNtatgKaNtgctggagtctataHcRRScSagcactcaatat
+aggaaYaataaagtKKaaaKtBttYRtgtcNVVaaaaaatatagaNaSgattDtgacgtc
+tMatcaaatggtSaYtttaatcttaagcKataaMDaMctgtYcDtgaattRctgHaatgt
+tggtcttcaataWacaaYaNtacHNtVWagcHWtBBYagSagcaaatcKgataaSgDHat
+aaacattKBttWagtRtcNagHcttaatBccgaaatVacggStctaKaRaVtgcaHBcgK
+VcattttHgctttgtgacgaBttttccatccMatRcaVataattKattaaaagDatVtta
+SRMggtacttKHaacaatgagRaWcgDtaggcataBaVgttNBcgtagSttgccYtacWc
+gagNaatttgctagagacatacaaggataacWRtcDaacSDStcaRtcDcaaaHgtatca
+DRtgcagtDtacBtatDMagtatcctagtgcDaSaaRtcaRactHgaaatccaRtWgaac
+ttattaataScaDaatYaaaWaRNcagtaaaYcaHttBctaattctNggBYBtggaacaD
+aatKgcagataHtgtcKaWctaVtNWYBgttttgtHScaBctRccataataMaaacatga
+atatNatgagtWgatggattgaNttataHcSKttgtatcatBtDtaWatcaWaDNgtagc
+taaaWttBatDgMatgagatctKttaHactataSgattRataYaYatagaatDagtaDaa
+gatcKcYgtgWSgtttttaYKtSatttgYatgYHStattaKcttatNNSataaaacHBta
+KgcataggYtacgtttccaaVtaVaHDcaWRYSBHattattcaaaaBatataaggaBtaa
+caYcgHgaatgcggYHagtactNagaaatttttacgaBcaaBttgagtKtYHaKKgttga
+acgacacgBtWDtSttgNHDMgaaaaattcKcatgataMKttVHVBacataKaatcggWt
+accagMtttcKgScgcaactattVctHScccaacccHDtgttacgttHVaatcVgMtgtt
+catBWBttDaaactattcttaaactaYtRtgtaWataWggacVgtggWtatgtataaaHN
+ctRgRtattaagtcgHgWStttaWDacacatcaHatttVacttagcgtHagagttgttca
+tcatgcaHcgtcKaagaRRacaatNgtYDtatVgYccaYKVttDttBctYcttaWtatgY
+taVttttacVatBaYKSSVaNNccgctgctBtcaagcacaNttctataYMatccWacBcg
+VaaatagWgccRtHMttHgBacttYScaaVtgSgttacBtctBttaRtSMgttaatNaRa
+tgttgtcatVtaaYgVgcVaaYSaNcagcttatNtacgatagtcgaVtaacYVaMttgga
+taaagatStcaNtDttgcBacatattaDWatDatcaatatNttagttMttcaactacaRH
+YtcggaacVHtaggatDggStgSWtVatagctgtttaagBcccgBtgcgtctacYaBata
+ctYMttHttVttaWtSttgKtcttcgtgacctaDtttMYMtaaaaaattcaMgWatBtgW
+WtaScccttaaVVgatagaRtYataatttgKaVHtgcataYtaaaaagStcaRaMaattW
+gcaacaaRaBaataacaMNatagatattatgWtagcgVHcgtcatgaHgtRatcctgtcS
+aaatWgtatcHBcatcatcHaattattDBHggcatBtgttagNDggtcRttaataVtctt
+tStaaggtcccBtccaBgBRgaDaatttgtttgcNtatBgaaaggcgNttatMtggtBgM
+gatactDtcatMaaWctatttaaaacYNgtSgMatBcSactaKYaDVaVtcagaaaStag
+ttYRcaaKacaHaacagctNcatttKtttaaacWtMNaatttattaaVgaMStMcagcta
+WgaSccatNatgMacataWaaMtataggcgtatcctagHatttttVaattttSBttScgt
+BSatgaHcaacgaVtMaaaactKHatatttNWtttataWtaatVttKaKMggatcMaaat
+tattMgatttgtatRtaVgaaDtacacRtaaaaaMttScaggRttgtcttSatYWtVMac
+tagatVaMaaaDtaattttaBWcataaggaatBtRgtctaWDtagWtaaWYSaHaaacga
+tRcttgcatcattaSDBBKttttctaYSaactcgYacatttBaattKaaaccaMStaHat
+HtatgtctKcWataactctcVNYtttMttaDatSacDKcacaaHgaggaaBtgNaaaHta
+ttgtRcgacDtYtctttMttatcDaNgattagtttYtaattBMtaggtacatgtYBNttc
+MacaagaaaaaKgaaatcacaNttgtttttagDBcMgtaNacSatcWBWtataVatYagt
+ttccatatHtttDtcgtggBggcKacaBWtBcaattgMatcttaVaacVYgMgttDcaaa
+ctctctcgcHaSatYVHRaaatccMMtaDHtaaKccactgattatccatBYVDacgttMc
+taaVtatacaatBgaagttaattttgatatgcatKgaYttHtatggaaaatcaDtttBta
+tgccacattactcaaagctctcBKcaagcaatataNtattcVtcataacMHgtattaaDt
+ctNaNttYWcWtaVatatataWgtaWtgaHtattcgagtMVaHDHtatgcttctaaWYaa
+tttaatccaMactKtcgtDaDVWttaccVtacYBgDattKtHKSVStgMtBgcgtDRSat
+ggatatDKacataWtatWaVttctSRWgtcaWattKaaYWtYaHctataKacMaagtctR
+ttaatcgtgaHaggYWtcgatKttKaccttacttccgtttHcgtKtcttaatSBgaattt
+cVKaMattVSgDDcaattcagtcataccBccgtgaVtaggttYgaNagYcHatMYaattD
+gtttaaMagRactHattgatttaaSKtSccggBattatatKDacaacBgVWBaaacaaga
+ttgtcDtcttBgcattatcaaaacagNtaaDgtggVaacYDgtttDtggKccttaaaWca
+cgSatacaggtagVgatacctBttcaattKRtctaMgSattgtacctatataaaMgVtct
+YMYYcacttRaBgDctRtttaRHgcRSMVaaaaacagaYaagtaMatDaatttaggcctN
+aacgaaaatgNtttaBtMtScVtVtSacStaBggtggtKtRcatagHattcctggaRtaa
+KaBKtagttgaattgtatttMcatgcttDaWYtaVtNDgatKtHaaattaattaaStaag
+WaaBtNcaccaatRcacttgttttcaaattctggcccttttBgHccatcgaWctataStt
+BgataacagtacggcccDcScaactgattttaSWYtaaaMaVatttagctaBgSaggtNa
+BRgStDaatDBtatcHgDtRtgMtStWaYaggtaYatBtaWaattgaaYattcBVtaVSa
+ctWaWgtKaatagaaatgNttHtgtcaatMattcggtcaDcVttgataMNttYVgSSYMW
+aVtgcaRaaccYtgccattaaHVgaaaattMtaSgtaYaggctataBtcRtttaaBtcHD
+atDgtaaVttgcagNcatWggNtgRMaDcYgYttacWNtgcaWtaaVaNctVacaaccRc
+acttgMttgtRMtgtccatttgKagttctVagcttccaccaNgtgcatRgtSBaacggaa
+ttttttNagtDcagaHaaaatStcaMtctagcacactHWtNtgctcgtNaWatataKcMc
+WtagaggDaVatttaatttYSDgRccWattHtaggctaccDMctacVaattBYtDacaYc
+tWaHaaHttcggaMKaacSagtattaaatDttNaVNtacgVttKaaHtgagttWcKtgta
+DcDaKacgtactctttacatSgtagtaHHtgaaatRtttagttMctacKgaKaatBttat
+aKWMcggtttatgtgtgaStaagaaRttaVtgttBaHgNtggaRaWataacaWtRWacaa
+ctcgHWttttaDagScKgtgSagtcMgaRgttacccaaaKRaaatattcKatttNgtMaV
+cataccaKgaWgHBWagctaagttatcDaRVVtggaaHSVacggttaHaWWagtSgctct
+VattKctKtMatHWcgccttaYtagtaKDaVcHtctgHagatcaSacaatKtatgatagD
+gtcgttttgatVtatStctYaYNtgtgKaKaVcVNgaattWccgattcttgaMaRattRg
+caatHctcattaBaaMtattNSSttHcagRKRaaccaYacMDtaYaaaatttRataBVtc
+acaagKtatgcctcatcgtgWataagcgtatcDtNagcatNNatgttcRaaScagaaaRa
+ataMtacMSctKtDgaBactaggtWgcRtaWcaYtgtgWaagDKattttttaaccaaatD
+HattgacSttttatWaataatDaDaaaaRtaYaggagcYatacYaKaagaaNtaaaYtaV
+tDtBaaDcgtttKMtggcagtVatgccggtHgtgtaVaacDBaattacaNatttMgaDgc
+aDtttggaaMgtYtDtSgccaaaaYcNgaacDVgcattaNgatgaaDaBBttgccatttR
+tctaatgtHNtaaatBtaMaVattcctggaaaaatMattgtagRDacaaacgaataWSBc
+tctYVcgtSaMStgtttSatNagaacaRcagtatgaNBtcKgBttRtattVtaBtBaKac
+taWaMgRtcMtaDtYtatHattScggacMtaggcataaWaKHaataaagYcgWatatStB
+attKaKagKttacMaRacaSaRaaWtKaatagSatcgaaaKaaVcDttcVcgaKVattgg
+aYgtMataaacRtaDaactNatYcagtDgttagacBataRYRDgttcttttattacBcHa
+tgaRacMaactcatVVtttaaaHgctgttcaattaVaHtDcaYKacgKtcNtttgctttg
+HWcaaSactWKSatcgYaNVaattacRcatVNgtagatgcatYatVaaYWaSactgatcc
+atatNMaNagNtaatcgttaSttattWattaggagaatcNaaccaaaWatRaatHMaatt
+aNWatRaMKaWctWtDataaagHctMctttRSttaacgaSWcatcaVgatataattgtWM
+agKKaBBgatatctcgHSaaNBctgVtaStagtttgaggSgagcKttaaatHattDtaaa
+ttgaacatactaaWaBYtKttacWtaaVNcWacgttctcctaactBaaSRagaaatgttK
+VgtHacatctcaScaataNgaaVagaaHttaKgHgKaccgtcYtcctBccataagaSaca
+taaaggtttDtVStaVBgtcgNatgtgaVctatWaaDccWHcctttaatcWactaatact
+cttacttgttcttatttatcaaagatWacYctacKtaSaaaStgtWaVcaYaRctgggtS
+aaaWtgctgcHtttgMcgatSaagttgttttNattgaacttaaKaYcSBSacWattaata
+KDattKaHtgaaattKKttttgacDtDtattttDBDDcMgcatagaVNttaWtgaDttgt
+tttttttgacattatagBDacgatNatMBcaggtacaatgtgctttatatttRgBcctVt
+YVctgcatgtgatataatHagtttccttHatagtaMMaaWggBataaKtttgataaagcK
+gtVtaaaatgtatWWaataaHgatttYtcWataataacagaacDRWDgWaWaaaggattB
+cRctacYtagctNgtScagMcccHaBaYgtgctgtSDtHacKtNgtgacaaaacccMcac
+aKctcactaaaaaNgtagWtttYtgaDcatWctataVctNttKgRtatataYaaaRacag
+gttatagtcRgDgcaYctattNcaNtVatYattKgaaggBDtttacttHttNtgcatRat
+gaMHtRBtaagatMcacatBatgtStctagacttccKaRgaWccRataVtggaScgattt
+DMaaatNNtcYaYtaDaatctatgaVtctBKtgccYgtWatDcMYtaaRtcVgcttttDt
+MtRagtactHccRBWatatccttatMtNatgttagagBcttKacaaMtagaaattaDtta
+atatgaaaRattNcHSgaaHtaDcagctYacgccagcMtaaMgDaaaaaggatcttcaaV
+NatRcKVaaHRBctgcattatMaWaNaKataaatatgWaaatcgMaaaatcctgttactD
+tDagaccYWacttctRatgataaKtaaatcaMttttcaaRtScaWgatMactMtcaBNat
+aaaBactggtWHtYaattaWacattgaaVtYtSgMcatgaatYgattatacaYttaaaKR
+gaVagNgtaHWaattcgDaRaaacgVtBDtStttRaKgVagatatWtcMKaaaaMDattt
+aaYcataDYagtaaaaKttVWMggctgVgtgagtKagtgtBBNctacaaacttagattSt
+tHagacKVttgHttatSataaWtMHttSaSaaaaDatgBtaYaaaggttaMttgVtVttt
+ctaattgaacaggtttDDVMtNSgcatataagDaNttatSVttMScNaaattDttYaaHc
+NgttatatBatgDKctttgVVaaBgataaBatRaagactBYgMgNaBttaaattagattt
+ttttaVgttaYtatVtccgtaagDcNVcaWtgcaKgggYtgagattaMaaagaatagtga
+BaVcacBNtagtaDctctcVtaSctgtagcBcHMWtataattDtaactttHctaRcRaaB
+aYacatttcVRaatctgctattDSNDgBatcaaatgcaBccKctaHcBtctVtaaHgatc
+RgaacggctRtaagtaSatatgatcaaagBtaagatttVaMagaagaWWgcMWBRStRgg
+tttWttttagtccaMRMaaattaSgBccggNataagtgctctttacYataRtcattgtgY
+BtggcatRtacttBaacDacaKtHDtaNacMtataaKKtgtaaaRMVtctVcRatcgatt
+tgcattSaaaggttRatagtagaattVcNgRtKccBgBtWcataataKctctKatttttg
+VcaacKStcacSRtattgcggtcctcHatcgaaDgaVgctagtMNVtaattaaatattMY
+NcgattaaKtMttRtYgacttgttagggcDNgagNtKBaScagttctgcMaaaMtHctRa
+YtcgRtHatVctttatcttggtYctctYgttgattttaacSttaaactaaaWHattgWtc
+tactatttcgMcVaaMctaKRcttcRaatSgctVNgtgaaaNcagataatcaatcKtagt
+gacaaBVtttgtaaVctaBatgtaagtgtacctttacKtMWtaaaatWtcVctgagataa
+ttacggaatacgSaWgaHcagtagNWaaaSacggaaatgatRBtRctVctgtVaatataV
+NactMgDtaatggtatctacaaatgtatacKtttgttttaaacgttgBggBtgacttWac
+gaMtttcagaacagaaRVtttKBacttDWaccagtaaatatcgMcttatRtaaKKcgMtH
+KattWYYgttgatgttaRgacHcattcttKtcgtttaatagagWgDKaYatKataKcDgc
+taaaHWgRtagccgttcatYattcagSHtttattataBVccaNMHttacgWttgDgaaRt
+RaatcgatNaaNtWVcctacatacYtctgKtcattatctattatcgtcKtaataaattag
+ggHctcatgHttSNacctYaKttMHtctttSgacgtttgMcStgttcaaSBggataggWt
+tataNagaNBcatcaagtBtagcMagtcagagaaDcaaaataKgtatgtgSaagtgtYDt
+DccVaaacagaagttaHSWatagaaaMYaggtacttctccttatatHatgctgVMatKtt
+gaNtggSaRcattggttgWcatYagtaatatttgcttgaVctaataMRttttScggggtg
+agVcacatYBggtccatMattBaatgNataDatWtDttVcataacSVtattagaagtaDt
+atcBacNaacaaBaaagaaWBHSttgattttKRcVataHatttttgaBtcctctacctcR
+YttagcatactttagaMHgtcatgtHtatctaaYacacggtaaMtatgttaagaHWaRca
+aBaacaVaKattHgataNatatacgtatttaDWctagatataaNtaccgaacaDMttDSa
+SYaaYgYaVtcatactaaWWtatataaVtMcagMccaDaaSatBattagcaaaatgRtaH
+RgccgataatagcaaacacWacagaaVgBcagaYctHctgtcttaccBattVaYtttHat
+gaVgttcRgaHtttagttttataatRWggattYatatMaaaactWaDRaggataaWgMat
+aggtactatatttVctataattaaatatgtgttDtcctaKataaaaacggtacgtKaaat
+ccBKtgtaattacaKtKYtgStRaagaaaaaaaggYagtNactttaaNaStcNtBcBaaa
+cHtacaatSgattYttaacDacaHtcttcatttgSYgtctRaatVagcaWtctcDcRctN
+HatScRtaMgaacWaaYatcaHaaagttggagtacaNcSRttagaatcatVgtgaccaaY
+acWHHtaMtHtctaatttcactBtgNVggBgttctaDtcttaWttaatcatatHgaDaca
+tgaaNagtaatacgDgHttaNggatDaggactcaatttcttDaNtRagttgVgaVRacWN
+VHBttcVtYYtagataagHtccattcaatNaataYtNctgatcRttgaYaaaBcaKatca
+cgSaataHatggtacacctttatRcgtaYacgataHWVKaattVtKcgatcgtRtatagR
+gccBtaatagctcVNtttatgRtggggtttcttatactaatcMaaaWcgcaatKttattt
+gtttatHRRacaVcSgatcagcaacccaMatYacBVccNcRgagatctgtSgaMttHgta
+attatggRatgcWtcKatattMKWtaaatctccgtgtcaHNYaagStKcaDaMtaaaWBt
+tacBgNctMaatDttcttgatMagtagaaatYHKaacttattSgttNaKagttctcataa
+gtaatgactgaVStaatcctcDagtcataagWtataatattacagScHaatatagcaHYa
+aSagaaaaactYtRYaatcggaaHcVcDcaccctattRaatattNgVaatacagaataaS
+aaaagcWRgaKttccgtaWttctaaWacgatctMHaNWSgVtgNttVgtattStaatNat
+VttacaRWagNgcaSgRVtcYtgtctYgtRKatctStHWttcYagtgNtBaacgtagtgt
+HcgaSggcNgHgWggKatMtaHcgtKaHaWggacRRatattaHaaggaagaSgHggttta
+cctagtaattBaaatSttYgtagBaSKBaaSKgctMMcacagcgtYatSctWctSaatRt
+KKtgatatctMtattagcgagaMctNtBcgtatRDtcatHtgaVcYttctaHacgagDaa
+MNtcttaBgWattatagaKtcWtHaMacagattgtHacttttgDaBWDtcSWKacKttca
+HtSgttttDtHtSaVRYVgcagaatWattYtgNcgccBSttataaNctttcHtccaaDRg
+aataSatgctVDggacagBYtBcRacDtYDNtgWaattattatYKtNcggaKRatcagBa
+ctgatgcctSttttttDtcSgtcaaataataaMVttgaacBagtattctatggYtcaaat
+DWacVtgataYYacSccVcataaagacagtNaatgtactaagtRtattBMKacNacagaa
+WtctSaMgaKataaaMBgtYtaWaaKNtDStSNggaacgtMRtaaHctatacMtatttta
+ccaataKVtcagctttatacgtSWBaStgttgWVtYaacaacRgtSgtacNgatgRtaYc
+agStcaNScaaaRttaDttctcaaBgcScDtWaggtgaacttNBBYaaccaNaactNgct
+aaDaaaggttgagaaMtatacttgtgtctHtgagKacagcacagcgKSattaSDaKaatt
+tagtHtMttaMVctaaBtgBaattttactttaKcMagcatgcDcatcBagaBHattVgWt
+aataMgtttgtDaHaggctgtVattDYacNtNStttaKaNggtBtaKtgHaaKcaacatD
+MtagatgtatMtaaacttccNBgctacgtgcaaKgWSNacttSBaggMtNStaKtcaata
+gattatctagtaBttaggactYtaaaStaaYtgaaaagYtMaagaKctgtVtttcgWcat
+ctacgtatVaagtagaattBcagaDcgSgtaSggaactaRcaBRtMttRgattaattWaB
+YcaataHMacgHactatNctacgaVataNVcHatatVHKKagaaRSattaacgttMattg
+tatagBagtatctttgaagaBctgattattHgRttacDgMgtWtaggcaatNttgcttag
+agaRatttSgtttBtgRtgaNtHcgStatgaaKtgtaBacctgaaWgtKatHDStatctt
+taRaaataacaBttStHVMaccggtaVYaaBttYNKgNaBHaaKcKaaatStBcattgag
+ggcRSttttctaaatcacaRBattccacatagacatSaDtaaaSNtttgtatDgWgcata
+cgaSacRttagNaggaHtttagccttttWDtcYaVtaRtacWggctcaaaacVctWtaca
+tagttaattBBttMacatDtatttaaRggattatBVcacattattaagWctactVcaBgc
+ttKagagttatRBgctagaHtgDgaaaSVtKgattaWtMDWaRccaaWaagtaaVttgWg
+VgacaBtSaacDaaaaKcacaRKaagttgagtNatttaSttaWRgtctaaccataDatag
+YaMgaWBcattaacSttcacDtSttgtaWYataRBHtccagaMctaagaWagSDaactRN
+aaaWagtacaScaSDcaatMaaaaaaaVBcatKacaggtgMaaMtatVaVgcctcDDYgt
+attcaatattaggagtYBaaatttagaaVWDattcgttagHKSgcWtWcaatttaBtaat
+NcaMYgYagatcRRtcataaaYctNtatttKRatRggtYcgaWcgcccataWttVaaBta
+ataaatcgNtctttaggNtatatgNaagtMttccaagactRttgtgattBagBtaataat
+tBStcaatttaWcattaatVtacatgtatttBataVYWStagcaYKDaagYtaggKtgag
+atVtMDtKgNtcatagtNcagtBagagcaNaaNtaRtagatatcYWtSataWggacagag
+tcaDSggYatttDaaatcactKatWatcDatatRattataaatatctattHSctttggNc
+taagtSacgagatatatatRataagtttcatgcSaaKttctHaRgaaDatgStWcataaa
+aatWMNttaaRaVgaYcHaagWggttttaaBtcagacKtaBtggcaacHtaggVttttac
+tatRWaataVcccaRaagattNttggStYaatBRaataVacgaaatttaBaMYgcaMgtK
+StStVtgVaatacccYaDVYaVaYKVtgatgcctacaaagcWgDtVtctaBtcctccacg
+atatWtcDHHaHacaaataaatataccaYRSataVagtttaaStgttgRHtctaDMMaYY
+aaagatacaBWKcagttgcaacgagBagcaaatccgKaRgtgaatcgtaWcatYtWaBta
+BatcgRattcaagtHctctaatcttcctattaaYgaNaaaaRaDtactDtMNagatMttt
+RacKaccWaYtatcagaaKcttVtVaaaatgttgtNYgtHtaDactaggaRttaccVaag
+MacgcKtatataHaMtcaattcctMaRtttttcatgtctcaacatggtgacatcaBatHa
+aMagaatttattaaaactYgMttaKHBccgacttttaVaaVtcScHaNccttacccatat
+aMgggDtactagKgtcacRtacMacYgBaatttcagYcacaaataaaaggagYaaMHtat
+aaaHtKgaaHtctcaVatcgStcatHtcaYctttWcttattBactataatWctcctRKaa
+HtaaHYcttcaYataaaHtNcaSctgattaagaKaatWagRaVaNSHDaactaYVRaatg
+ttatVYttatDcctRtgcgaacStaWttgaYcatYtggtatWNataMtDNRtgtttgggt
+HcWtatHaaataatVtaaWaVgcaatagDatgScgNcagggagtcaDtgagataKtgtct
+ataattgtgaNatcaNatDgtagctaaaNtgtagtcBatgWcagagtgtWtaagWtaKga
+ttHagWRaNatacaagtactYtaWgatataRctcNKcttttgaRtgKWtgtgRagcNtKt
+YtgatatgatBDKVtaaaaatttWtcaatacgRtaactttaaaaMtaMattaVNHRKtta
+ttattaaVaatagatYaggattVaaaRactcaagccccRtagtScgDWgVSagtggtaac
+ataVatttcagtttRtattcttcYaccaaaagttNttKtggBttBcSaWaattataatca
+taBtgtMtMtaaagataYtacgMtWaaacBtttatcKacaaaatattMagtKccaaWcca
+tttgtgacctttMSataMgBtcttaVgtNttttSaactatgaggaSWataRtHtcgaMag
+SMccSaMctcgNtatgtataaVtBatHcHtattaacgactgNKtttaMtVaaaagaatVg
+ttMWcttacacgtacScttcttcWtaatccatactctaacaHHaaaatDctNtgatMcRa
+aWRtMgttgttatRagtaNtatgRtaMttggaaKWttaRtHKMaDDaacatgcgttaaac
+caaaDttatagVRBatacMaatacMaaatWcNcaaHttBgttgtacggRKaaaMtcHgtt
+aattattttaHgKtgttaatDaHatctggtaatMtYaRgMccKRaRKaDaagaggatBtS
+acatactccaKgVaaRMaBttgcataaacYtKgaVDtttgcatSaatattatNattataW
+atWgBttaggtBttaaYataaSHtRtaccaacMttaccattccKggKNtMatacctctgt
+aYctaaccttgagtataaRatagaatRBtttttMtgWNtKtgcttatgactcSaatattg
+tBRBtSWVWYagtaWBcNatttcNNgSKacctgaaMKgatWcYHgRataYggtctaMtgg
+cagaRgaaYaYgKgaaHVtaattMgaaWaWaDataagaaaaBDatacatatgatcNtaga
+gMtactcatgatgtHataaggtaHaWatMgtagcttaWtcStataSttagttttgcaagt
+gctgacDtgctcDtgaSgVMtagttKtaacgtacattaaatctHgatYatttcgggcaDt
+VttcaaacccgDgtatBggcttcBcWtacttgaatBaRNcgYtgtaaaaaRDctKctagt
+aKSatRtRatMaMtaacVYaKtactgRDcaataaatSacagctDaatggttttaaacNtt
+BaattgattaaMgVBKtBaacctYNcaKcaVtDYtcBaaataNSaBgatacccgtVtaat
+actSgtttgMSYtttgKtgtKacgtKatgataaVccaMgtaVaWatttatattgBNtgtV
+gVNtYStMtgtatBcgagaBaVatgatgBcStttgtagDgYMgaattacacHtaaaaaBt
+tKaaggHttctaggKagRNtMBaatWcagMSBaaVtgaatgtgatNaatSagcaatttHc
+tatWMtgVcNtSaNRHatVaVacVtHattcaataatgSKttttttgtataRKYaatccRY
+aatggtaVtttaaaaaWBKtatatttatgtagtcNatSaatatcMDRtgtBttYtatKaa
+ttaaaaYtcWccVattcDaaatgattgtHccactgNgctttBtgagatWDgVgtactgtR
+taaggtBgacctaaatctRtDttaBRaYacaaaYYtcaaagaWaSDttctttggacttcB
+cgaDacHataNtNgWtVMVtRactggaaagSgtgggtgaggcctccataaatNttaYYgt
+cBatattWMaacMRctcgttaaaVatatagagataKatRMtHaVagaaBBtStttaatca
+aatgagtatcaagtRMtaccgtBagaWKtagaaaYttcSScttaVttttcatatcaSgtc
+WNgtttagccaaaVgaatgtgttatgaaYaatgaataaaagagatcttcYacaaatataD
+gRttcMtcataYaBtctStgaatgagDaDgtRNaMtYMatatagWNggaNtcattatgac
+YgtBKYttttagccttataaNRaatggaatccaBacgttacttatMNggaaaMtaaRtct
+agtttttKKKgcBttgccgtHKatcgatVtttacataMtagNaMttctKHNctaaNattt
+WaRNgRatctagatSctaactctDttaagacgcatagcRNgagatttgtacattSattaa
+cttttcgttgattWatKtgaatttaMtSBattKKcttaaSggcactaataaatcactcaM
+gacggtRcaDScNctYtBRYVgttgtttaVtacHWattattcatttVaKtgKaacctagg
+StatttacaactcKNtaaacaagSttcgattatttcaRttVtaVaaacRgDtaatgtccM
+aacNtcggttgcctaattaaaNaWcgKataaYcctSgMcataaatttgaaatttHtagSB
+gKYggcgYaagagataaWBcMgatRBNRaYctgHatctatHttgaHtgcHKBKVaWaaca
+cWNRactWBVttaatttVccaagBSWacaaaatcDgttattBtHaMtMtHacKgWtcctc
+ctttHaatagtYttaagccaHtYatatttacgtcaSgtgtYttgBcatcatttaNRgaKg
+BtgattttaaatgaattVaKtVYgNaatgDaacaaVtHaaatggtttgaYYatgctgcac
+atttttctacVtacaNatataHtgtcVtaacVgtYccgaactaKaaaatcagtttaKNRt
+aaataMatgtacatatcKScctDatDcKttSattttagatgttHtcBtKgNVRagctaRV
+tttaNYWttcWYRatgatMgaMKRctNVMgttVagWcaVStcDgtttctcRatBVggacc
+gaatcMttgagaBDgtNMgKKRBNSMgcaWHYWccNgcacaggVYtMcaaaatgBtaKcg
+aRacccgStattcHttgaYttattattctaVMttgaacDaWtNccDtcHBataNcRggaa
+NBtgaYNtaaMaDctMaaaaaaHaaattcBgtcgHtgcgaaStttctacttcgMagagta
+aaacaDctgcagHctHtWaacgaatgtggtDacgtcacataSaatKtcWBtataccaaSc
+ttNgDgcctacgBaNWtagataBaNtRcSggtaMattgaatgtRHtgHaaNWtgttacca
+tacctBataaMWatttNttVaaRagMataVtgtaccattYVcKYcgagtaaYtttgDaKD
+gVacMtttaVttcYcgtMattctatatataaggaagagttaaatHgtWctatttgaaatH
+ttgScgtBataatgatRWgtttVgatMBcgctttatgtctgWKtaacaaHttaMtcttta
+tcDtccaHaNYtSWcWNtHNacaaatactNggtgStacKatgtgKVctaBcaHcttacca
+aWatHaaYtattatYtttDgtBaKcataaaatcaNgttNYcatVSgtgatatYDMMtgga
+atKMaagcttVtaNNYctKcctagMWtttatttBattNagccggaRgagtattaKatgat
+ctacatcaKVaaagttYgcStagtctacttttcatKtWtKtctRaRDtcggtataMcMDc
+aattNcacattattgaBaHattHgcYattagaattataaBtattBKHtgtaacHtHaaca
+aRYaBttaRVSaagttHVtatMtcacaWctgVtgaatcVtcctcNataacacgWtattDW
+ccatDDYtcgtaHaaKaacaYaHaataBtaaBKagtttcStWataccgNcaDtWNaaRgc
+tcNaacttatttgttaaacaaStttagtgVaKgggtatNaatVagtataVVaHtaRacca
+caRatacNStaacaYDgaWaRtaKttgtaatacggtttgccaaggMWtcaaccttcgcta
+MSaattaatgaaVDagttBcatccattttccaaBggRttgKgccaaaYNcDcaSatMcaa
+ttYDcatcWatStttggaaWtttHtatVaggttDgVWatttaBWMagtcagcgaSaaSgt
+attctacHtaaSaVacaataNKtatagRMagtKYBKggtttKatDacaWaYDaactagca
+DttctctttHtagtMtWtttatYatWNaBgHtaBgSttRgattatgKcccaaBtWcccat
+aaNattaYtRYWgRccNatatHttWgttatactttacBYHaaaKaHYaNttaatagKata
+caaatWSMctttcKacatMattgcaRctBataaVaHtataSctDVtRaacttcggScYct
+ataHRHtgttctgtgattYatatYtcYHaataaataYtMMgttaaatgatcttaaattaK
+RtttaaRtaacttaBtgtcatgtctNcaaKactMtKatagRaDKaatgSaHcRtMDctag
+atcaYtRatMSVRMYKYaggataaatYtDBaDacDtaVtacggaKttattNaggScgWca
+YtaBaaacaWaNVtHVagtBaatgaBNagHaBtaNatNttSgaaactctBaggtHHtgaS
+agYKNcataaMcatagaSttctNBYcttattcatagagagtHWWDtctgMtRHtactggg
+agcKcacctggaYattatttgaaWgtcaVaataagaaNatRgtttacNtWYMBcNScggg
+ataataaagtWYKDYcVWVggtttMcttYaatagaaKaaataDcaYMVcaVtgtStctct
+WaagtaRtaagtaaatWacSKaaatYaScctggtgMKtYMtctacDatctcaMatVtNaa
+taaNtaattgaagaNaataataagcttaagtgtgcgtVgttataYaagVgNaaRctSctg
+WKVaYKgctNWMaaRaHatcgctHaaYMtccggattgtgBacatHaacttggtggDVgtc
+aaaggSatWRaKtKacNVggaatYttatttattcaaSttttttttcaatgttatttgttt
+taBgcatacWKDgtYNtcYtgtcttttttgtcaaatgatacttWagatDatttcacctaa
+aaggtgagttatWgtgHctaatMtRKagccagcgcVgagYagtactgtactttagVctaB
+BaYNggtYtaattttcRtaaagatctMtaVYatctYgNMaVtaWtcattgRtaNataaga
+aaacVSctHNtcNaMaRYcgagttaHcgacNgagagBgtKaactaaatatYRcggatgtK
+tttactgDctcVaYaaSaacBcacatagaaataaaaWDctVcNtttRtcataatNagatV
+MctBgttcHtVgagaNaaaHaaSccggatSctaHgtgaYRagattDcSDtMStNYtgtga
+agcttgggaatttttDgcaatHatgaBttHttaacatBcaaagtaggtKgagacaattaa
+taHcaNaaHataMtccaKagagtttBYSagDDtaNaRtWtWagatSgcSKtcttttcaaR
+gtMattatRtYSHgaMccttttttBtHactaattcaHtMatagaattVtBtDatcttVga
+gtatttaaaattacYSattatttaYtagcaVSHattDctKcVattataagagRaccccWc
+aBtYYtctaaaaYccSgattaaaMDRtHatMaYtHtcgcaaggWgBaNVDatataaatWt
+cMYSVtacBYaaatactcgtacttttWgaacRNaattctHagcYtaSttaaataattttt
+aaSDtKaaMcWgBaagBgaatDagaaatactcctNtgRaattaNWcattgYVMtRtHgBa
+atcaagRcagtStaaWRgtaaatHcaMacDctatNaagtactVHaaVagMgttgKtgtHa
+tcMacatagMgaBtSaaaBtagttaaNaYgStRRctYWYVtttMNBgcctgMctcactta
+gtgtttDagacaYaattagaggKtttacaatMttctttatKagaaNtBtttKSHWSaVtV
+tgttaRSaYccgtaBgggMtKtttctYWttcaVaagctttttMBgDKccatagVactWDg
+tRtKMtgBKaDaVaggtttRaataBgttYtattatgttatgtcMMaatcagaatagHaac
+aattRcBcDatttaYWttagattggttgaMcgtYRgagMtcactaRctcBMaaNgcaStg
+cgNtgagVttaBaaagaatacgcatYMaaatDtacgatatataMtYKatctScatattNg
+StYWgtttaYcttgtagaHaHaYtaRaaagttcMHaStatcatYtttKBtctataaaatc
+aStcatatStattatMtSatcataHcaWaccagHtaaggaHatatgagaaYYgtgVacSt
+tgKaBacSYcaNNccBNtHKtHcctttMttttagtaaaBHBaaattWKgtaaccDataac
+tgatatgtaaRVtaHgaattctcRttcgcatHtaagttYYctaaattttgWDacBtataa
+tttctVaYHtMtagMaHWtagatttcaVgtKaaacctgHagSgtacSWttMaBcHttaat
+cttMaStYatatatattagtttggMaYaatHgaaaHHgatggccctactatSgacaatcV
+McatactBBMtaattaaatattBNDacYtgYattBttHtNcaatgcggacccctDcYcDt
+ttaKaSggtatcaBYaaBttctDSRgacHttagMcggtWgagtcctRatatRcttgattg
+gaaaKggaaaagaaSNtattcNtataatVttgagBaMaaBctWtHatgcDaatHccgMDc
+gcWaaDaacWgaagcaatattactcaaaatMgttgtaaMatatYtctRSctctWcatttV
+atgBNtaaYagNtaMatcSgSgaVttSaccaataccKRNcataaggYcDMWaSKVcccaa
+aggVtHtgHagMaggtKVatVtVMDVatBgttWagcctagagacaaaggtataatttgct
+tgtSaaccttctccttcaatgNaacaBtttaVcaacagWaHMttgttaagttNWaaYcga
+aVtatacBatgagHtSattacBgttYgtNRRcttgatcttaHcaataattattttccttg
+aYgacVgNcttaRattatatctcagWWatNcDgacacgttaatRattaYcKtggtSggWg
+atMcaaDBttgaacNttctcaaHtHaagcgVtDaaDtNMcagaaatWaNtatcttcattS
+gatatgatactattWatSaattWccgtctaatcttgKDacatRatggBttatggKgaagt
+ttcBaKtgttaaaKtcgatagcNgtatVDagaDtaVtcaactttYgaBYcgaYgWgaWta
+aaWatVtctVtgggKaVctcgRtttacMaVaaagaaggtVtKNYtWcYaVtRVccgaatt
+atacttatattagcatcKBattttgVDggcKaHaYttgcggcNaatRactWagWgttcag
+tgWMctaataBHtttgHaggcctgacMcYaRtRtcggcaatBagttaagcDatatatNtt
+gtMcVtaaaHMgattVgaYgtattatatSaDaaaaataWacaaNttKttcatttttHaMa
+gatYtgtttcattaatatVacgcHRttacaYtaagttacaBtcgaagcgttWtatVWRaa
+SacggWaBgSgcttaScatNaHcaatWacaMatagttcagYBagYgVactWtgtStNata
+catYgSYDtaaacSaaatBtttKaKRSWRcRYMgcYgVataSNNtWgVtSaMgBcactaa
+atYaKattVggacaWaaatgHtatHccacStaatagaYaaaVaMaaacYYMctcagaNat
+tatctattaaatatgMaRgggtatgaMcttaHgattgtScgtgtatVatHNgcYttNata
+tBWaaactNVtHScgataaNcBataggtaagagatttMatVtaagtaaatYgctgtttta
+agatagaWaaYcgctaacttaaagaattggtSYgtVaStttRtcKtHaVcWaYaWVSccR
+actDaattgWaBSKtaDgtataaRcttaaaatKcagtNgtaaataaatgattcatgtcKR
+ctatHaYtMacaWNgagatcDcgDtatKaHgaBcaaaNWaRataYtYYacttgcactaaY
+DcKDttWcYataStKcgcaaaaaRaaNtttatttgctYatgtcVctttcBKcgtcttatS
+ttattYMttaatcatattcatSaYtgWaDacgaataactctggaDccattacgSagaaat
+tgatttaDtHacgtcMgaMHaaNDKttgtaMgRNtacataWgttccStgaaatDaagYRt
+DagcatcHttcVNWWataatataaccKaatWtYgcctacVaagttWtHactaRaagatat
+MMtYattMttccatactHgStagHcaattaagacagaMDtttagcHtgccctttattatS
+atWataBaaSMaccVVgtggatgtgttgYgtDHSaaMaKcagaagcWacaaaBagRactK
+acDaDgagagagcgKcaBggtgtaYttatgcDatgaNgatagagtBtNtaWatagcacgc
+gcatDRSacHttcataBtaWaNtgtaatcDctBaSttttaggcWtBacgacaVYtRttaa
+cttatgKcggDStacgtagaYtaagtaatgacggVMKtWagcatatagtcataagMgatV
+agVttSaacHataatatacaatRYaHacaWaaactRtHRaatagcaVtcMataaacatat
+tHaStattDcMWVtYaacYagaaHaaWaccNHcatgtcccgaNttataaNaacatctBta
+DNKgMtcDtgMgtatgKgSatDSgMtgVaaHNWcDcaaKgHMtaRtggcgRgtHtVtatH
+gtMggaRVgtcDgtWaactactgttagaKcccDctcNcgtagtgStacgtataNcgVaHH
+agYttStaaccWacaKctgctttaactagtVatttaaatKttRcgactaHttSaKtcagB
+BaWaacccgRatKagNagKaWtHttttcWtatatttattacagacSBagDgtagtatHtg
+cattgcaMaRgtagatYacactYSBDgctgatcMattStSgattcNttaBWaacatgctt
+SattttctatNttaHNtSctgtcWttKgttgtttttKaMHNMcaacaagNattRtcBacc
+atKgtVtaaDcttgattaaaatHgaataKYtgagMtgcWaWgtRttcDaatgRtDgcNWS
+gtagtatRttDcggatHWgaagtacgcVtcaatHtttttttgaKggaSaStaataWBMtg
+caaatacgWttctagccRtaaaattNWaMggataRRaaHaaMcagaaacacacgDaatct
+actaactDgatgtttaaDacacVaNgagKaBcatataaattcgRtSNaatDttKgKDgca
+aactBDtaatatagWaBgagtgtYaaVatatMtaacaggtataacgKMtaKgcttgNMtR
+aaaaVcHctKctaaBcWtcHtaRaacKgcaDKaYaSHgtatttataaYtcaKatgNacgt
+cWWatgDttRaacaaDWaatDgagaStaVScctgcacaaBtatacttctgtctttcacta
+cWcaaaWcactKattaKtatWagttacttgBtgaBMagaattgtYYttttVatttWtcBa
+gaatcctcWtatYcVttattMgNgYStaBgtttcttWtagcaggtMatgtRaaDtDKttg
+ataDggtttatgctaataVYcSttBtYcatctVtBtYaVagtaaDtgagacctgaaatcN
+KDactgKtacgBtDKgattaaatagattatagactatggacgacgRgaaYKgYaRtgaaa
+agRgBaacatctctMttgacNaWtctVagtStMaactacaatttcVgatacKctaKgcSa
+ctaDaatHgBgtHgYttaagtNYtRcaRgYtBaactaatatDctaacSKatSDMatWtag
+KtttagaaHKattaVactttSgtgtagWctaggagctttgaScatcggSttaggtgHtgY
+atgtctNtaggaaatDttcctgagagaHagttKcttttgcHtcaDgtcgKtatcaatgcg
+StVcatcaWNcgtatttHtatctggaHWSataWaVttgKgtKBaaaggtaMNaatttRDt
+cDattaStctaaatKgtaagtcVgccaHKgtgtcgaSVtaaaaHtatgaaVcatacacVt
+KattaWaKDgttctattgNcaagaacaKYaHttWcDaccattttagacttttMttaRaMt
+aHtacNgccgaaaaacKctNgaaagagggaVttttgtBVcatttatttVaHcgattWttM
+aWcattagtaYcMagaatKaYtcatttagacttStDtcagacattctcYaaKMttcagtS
+NtBtMaHacYWNaactVaMgtcNgMcVcVtgKaaataaVataacaDtaaggtcSgtDatt
+taKtgSNHcgctVaaaatatagacRaBgaNtaattVWaKtgcaattHttctaNRWtaHtt
+taaSgWBctVacaNVcKtaaagHDaaaNagtYcYKaVKtaaatBaaaSaVaMtcSgtaaa
+cctcBYWttSgMaMccagcttRgtVggaaWgagtaggYctRtaaWtgtacaaMNtagtac
+ggVcttKcaMgNaaatgtatgaSgDcSBRgRVcYtaDHgaVtWaaNagDtagggtHagHg
+ctRagaNacacaStaNttMaatgaataaSgagBgagtgWccDtVgagcDWVctBttccaW
+cacgHttgtcYtttacttaatVatgtKtaaatttaNaYttaStMtVaStggattgtVgaM
+RNHtacaaNttRScRtVcgttcScatMtBtttcDtcatVctDaScttagacaaDaaBtaH
+tacRgRgaRNtKataNgcaaScactcWtKggRagtgtaaYtaaattWgNagatatYtHat
+tWtYWatagatatttKatgtcgDagaVcgKVagacagagatVgHWtaagttgcatgaKaa
+tggattaHcaatatgKtMaWtWaYSVtNBDttaaHaMcaRctWScNcggtggYSttcaga
+attattggaaaattVccMtgggWatatHMaYtaMaacaHaagVtgDtggcHtRaagtHaa
+gVMWacaaagggataBRcaaBcttKtHtMgcKaVtaacaRatKRaMaRtMtcagcaataa
+aaVccNcttMtctattaagacacgagatNtatttataaaSagaaatatSccaRHKatYMa
+cgttaWKtgttgHtgagatBBaRRWSacatacWtNtcWgttcaaaccactVcaSaYtaac
+taHgtcVWgactaNaatRgNattatagacHatgcYWcttatctaagcttaatatgaaRca
+DVaSaHatgaatttBDacatBtttHactacaNaNtataVcaVtattKgMaSaSggttggD
+NcgtgatactaccYHttaaaMaVcBSacctgatatataBgcaattaatBaHtttgtaagg
+gataaacatgcgcaaataatattaaBVcaWgttagtVaaWctRgBtgYtttccgYatttt
+YMaVMtaHatRDaatgVacaatatVBccgttaagactcgcaaHtVaBaaRctaVgggaac
+RaaaaaatYaSaccVgRaaBtgataaatttcaVttataSMatacKtaWttgcaRcgtgNa
+ttatttaatagaatNctcatHtSWttaVtRattcaRYtaaattDcaKagcWggaWcStaa
+tNVgHaMaBKttaaatYRMHaRtcgtagMRgtattcctHtcacaaaKtaNttcaRcatRt
+ccgatNDagaBttDHtcttggccttaNtattaaStaWgKtVWNaMccaVgVgtatcKacD
+aYcccactcattcacYtattggatVgaWttctgSDagaWDattctacataaaDggtacta
+tagcNcSgagtgtMtaacNtVtcStttSgNDaDYgaaWVgtactRtaNcYgataHagaDt
+agttggaHtgtNtcgcHYgaDttgRtgStatcattttKtWVaYattgNtaaYgYccHgWa
+ctgtaaaVBtaBattaMBtHtttYttVgtaYMWatWgWtNaccVtgMWaSDaatcYWcca
+aaHtacgKagtNcMKactcgtaaaVtaMatttcRcttgHtattattcRaaaWaWactgDt
+tttccttttaKVNaVggataagaagWttcgBtBtVaYcataRtaacBgNaaYctggtatc
+tacaaaagatttagttaaaaNaaattgctcaactttBKagatctgctgaMgtBttgtKaS
+atVgcacgaHNatVDgttacVBacKBaaKaBctccDtagctataWKttagtcttYgtaSc
+caatcBttggaBtMaaaagaYtMgtgtNatgacacctWcKattctgaNtaSgaaataata
+tVSaattaaWattagDtgagBaHaaNHtBgttcttatHaggaBtatcHtSttgccaatNg
+taHtttBattaacatcactgaWaaaaaatggatagMHtSgaaBSatacBSaagMaDcaat
+tttcgtctaacgHtaaaBtatcttaattagtttatcttcgtWVttatatcgccgaagBgR
+aDcBaatHVDtataacaccVgttHaaSgaagaaatcMSaHBattgcaSgaSVaRttcaMt
+gtgcaatKaatWggatBVgtataNWgNctttacctttgaaRatSaKttHgaaaYSaBttV
+acWttcctgctDgBSgYcagcgggWRataaaatgcactagaaHStacaatHtggtgtBgc
+NDttggattatgaagaKaatStgcttHtgKNMNRagtaNtaDattgaDDcKtaaatcVVB
+tcSgNcRtcHataRcggctVBtccaWcaDgaaRaRctgaatMtaRtgBcaWNaNatatWS
+cYYaWttatScYtSgcataDtWcacBtactaWgcYtcgtataagctataNSgBctagatt
+aNgaKgatVKgtagttttcaaagtgcgcYattcagatggaKcMBtacgtttaacctaaat
+taaatattcatRaggtcgcccattMttaaaaaaactggSgtcccgtctaNtWattcaatt
+VHDagRtggVSSaaHtattatWctatKatHtHattYBtaVaMRatgYagcHtaSataaSt
+KaaacattaagggttggVYaaDgttWSttcattaRBcMttttaacatRDaataaMttRga
+taaagVDKatcatacaacgMtaatYctKcgggcBKNgtggttcttaagttYgcataVMaa
+VBgtVMSNagttatSttgtDtgtMgMDtNKtBgctattacagataMWtcSggtcHgggcg
+agtcRtcRattaaaatgaaYYattgtaaccttgatacgtWcHDgBtVagNcSgBKtaaMt
+caStgggatDaVtKScaYagtttctagNBtcMcDgKaDHtVtMaMacMgtagtaaWtaYt
+gHtttttgtctagYHtRaagacDRaatgctVMtttWaYaaNtttatatttStcgactaDa
+tKaatatattHggttgtRtattaattaaaaRtaNacKattctVaatgattcttacWatgD
+gagggtggScatNtcMggaagggHtaaccttcWcatWaStagHtttgatHaRVaaSVNNt
+caRacaNaKttgctgggcVattatccatVatataDtDcNgMBMgHSagggaaagKctggg
+tcacgaatcaataaVtDttaRRgtctStattNBaaaBHatcgttaaWMagatagacatat
+VgDBttYMacaatttKtttaataaaagcacgVgaaactDBtaaccgtagaNtgagaaaRt
+tcKKagtYKttttaStataaHgtcNDcgttYccaaaaMcaWtgggttatcaaRaaggaat
+aaVWcacatattaRYaaVagagVtcHggaBtaataNattagKtcVRtgactatcgHDaBg
+RBStVtSgNBccWDgaatgaggaaNctttNttttacaaggagaaDDaVtcgaataaataa
+gttaattStBDccaaaBgVaDtctScgtgtttttgctgtcacgtttWgacStMtttVaVg
+aBtacDWtttagttDctaSDVtttNaDDcHatatacYtKataaatagttgaacaagaata
+caDDcacatttgtaaaggHattaaatgttacgtcagtNStttcVatttaBtHtVggttat
+taaHcgaWagaYtVaataaatcaBgaccctHcatKaDatRttHRMcgtcgggSMtaatNa
+gtYtgaYtggMYttgtaaactacgKgStttaaaYatatDtaaSaVVcHgtagatgaggtc
+aHggMtaMWaWaHctgaatctaaBaWaDtcgggtccctaagtaVYDaNactataaNcctK
+cBcataaatttcaWSttttgacHtctRggagRaagacagWVNtctcatHtDHaRagctSt
+atattggcattcattttMaNaSaRaNDHaagNtMgtVWtgtMccaactKNaaaVaStatc
+gtStgtgtaBgBgtaatcNtccgaagtttaWgactNgtaaccaatgNatWttgWagtaaK
+gtctRgtctaataagttVDHgStgttcVttgtSWatcYaggMatgMRcBaStgtaaaaaM
+ttaYagccggtgaRRatgatccaaaggtttctaaKgacaDagagatgctcMgaaaMcgRa
+acaaatataaaagcagtgtatDHgRaVtWBVtggacatStctKccttVttatgtKatttt
+YcatctgttatgtcDKHYcctSHMttgSDRNgtaMNHaggatBcSBtHatDMBcttMacN
+aVMKtctgtttcgaHSgtMgcacagaStaBttcWcattctDtcttHtDKBcaaNtRNaaD
+gaaaaccMRtBcWVVagcttatcgaDYccacKtatgatgtcaRttattYttctaMBggca
+YctaNtBactgattStaDaHccYaDtgcaRDgSYtYtatBSaYaaataaagtctcgcgtt
+cagaaKtttctVattagtWcacgaaVaaVtctcaVgtagttNaaacaatgtccttaacta
+aaStaKWagttaNttatacaaaKattBctgaagaagtYDNtagatataDtHcKcctaBag
+gcaatctHttctaaDNtgtgaaaagRaattataaBMaggtDgtMaWHacBStSMtcgaac
+YttRMatNacScgaaRtttctattcMaaBggtaKttaRcgtBattcgatatYtVaccSac
+acgtaaagtctNatYttgcSSattttcKccttataatcRtHNctttMcatBtacatgtYt
+ctagcNttYacaatgtaBgcgttVtattaaWtaDRtKNaNDttDWaaaataatDgcgcKt
+aatatcgctMctatcatcgtaaaaYNRttSaNtWggatRgtgtcttataVgaaaatcWDc
+ttDRaatMKctcatatRttBtccaattBSacctgMtaDDRagtcagacBNtttattttag
+tDacaagcaHcacgRttVtatcatatacStaatMaWagttRccKtRctcgaagttgaatt
+tNtttatHaHttagctatSBaBtcaagtDaaaRtgattcatStagttcaRattacaVgta
+tWRttWggttttctaactttSaaaVHRatttYHMKVVcgttMtatBtaSaaMctgMtcaa
+gaMtactcDatSaaaacNgatttNcaagttRgacgataVtaacYNataStRtgaattact
+gtaKtNagaaccDaatgNDaaHcataDSYattatgtctgYWaaRaHtttWggcKatgcgt
+agDSVtMactataKMSttaHaaaacaHatVaDKtSaaaRtcaNWHtatttctWataagct
+ttcccaacctNtaaacattcgagaBKVattaWtcVaKtWcggtaatcaatgttcaaatcc
+DttctcaaSaWNDataaKatBcaYttRtcataMVtKttggcaaNgtgttatMaccgttgM
+NagtgVtNBWggaacacaKaaKctagtctacttSaKYMacaWtWDttatagHBacttRtt
+cctgttagtScVNaRtaacgScaStttatctttttSgtBgNtttStRatNDWtctgatcK
+tgHcattatctaaaaattNaaaWgWaDWttWRtHRNcHacBVgWttgtNggtWtWcttgS
+atRtaaYtYtNaDttYagactStacYaYtNHBatggatacVtBatgccaHcgtagaaMat
+gataHagtKgHaWcgtaccKaNatagWtDttcgtagggcSgtRatatNgaRtYataaata
+RtBtcttaSatcagatgaaSgtVtHtgtaaDtVactgattcgcatctctBaWWtaagBtt
+VgacHattWWgcKataHtBtagScWtcaNtHStBKMHBRtRagcataaYtNtttatactt
+aMgacccattgagtDYggKccNaaRgataWaaaNWDMttMacttaatgStDYgtattaBa
+tBttKcSaactagtaccgttggaKacRtDaataSBaatacaKtgagDtNcttattaagYc
+agacttNNttatcBtHtgRatgccacctaSaatccaRSgtWggtgaaMcgcaMaagSaga
+aDatHcttgaaDgNRttaDKacgcataagYaagtMRttNaMMMgcggttcgtRaSgacaS
+taaVgStcaRBKcaMtctKtctatNaactaHtaactaaatNWaKtWaStRSKcatggtgB
+tgRBtagaatagataSBagMtDVataaDtaattgaYgaBaagWagaacaggaagtctgac
+gMgtgagaRVacMcBaaDatKatcNtKaRtcatDNBaaHatatacattaWRBtcaccatt
+ctctaaWttWacgtccgcgtMctcaaaccHYtNDatttSaDMccaStRttWgttattaSV
+KtgttttgtcWatgtgStttgttttatcaagacMttgtRDgcRtctctgtgggggcSaag
+catVattMacattSgttaacctaaaaccgcagtgagNgtctataatBtHtacaaSccccM
+gagRVctYagcgaatttacMagVttaRDcctRgSSttttcHtVaacatagBgaMRagatR
+cDBaMtaNtcatggHgaDYgaVgWaaaaMKattBtaDYBaHRccagttatacVaDcacac
+tcgtaSctaaatatRDaccagctttttaatgtagaMaRaaKaaataaaatacaRagaaYa
+NtatKcDttgHgcVtaYgDacagMBagtgttatgMcSgWDWYWtSaKaagcatKatatct
+caRHacagttaKtgBKtDRggtcaYcattcgcYattttgtccaagtVgcattttttaVaa
+gtaaaagtWccttgacYcaagtaatataYBaatataBtaaatacacttttRHagtttaDS
+HgNtNVcatKgaKtgagttgaaaHcgBattatHgRKtcaBaagttgtttgtVatYattaa
+ttBatYgaatgMgtttatagtKcVctagttaaYWttWaRKWggYttgaRgagaaMKtagg
+tattaMVttataVcagHYacaaMaattRRtataWaaRacHcattaVaBtHgtatBaRttt
+accaaggNgtaDMtatYtaYVtNtcBRKMgaatRaaagaatactRattttNcaaaDDaag
+tagtacaNtSHttaaataattggtaaKtttaaBaNgtaagtcaYttacVaataataatDt
+gHSSgtSDNaattcRMBgHttctaagaYVcHcactKgaaNHcgWaWttaaBactcgYtDa
+acgactMtaYKacBgttcttgttataBacatScBcattKaaattacttSSDaRgKtHHag
+RNRMtttBDtcaagcBcgcYattactcgtttacSaaNVagtacacgtggtSaWatBtgat
+ttWttScaaDtttggtKtNKaMtMgcttaHKaRaccgatccctgtgggagRMttaaMaWc
+cggtttBtgttaaVtagMWctNtctHgtBgcttatSMYccttgHaatatctgNgVttagc
+ttagggaBBSStaYgYatYgtaaaaattHatctatgtWRNgtVcSgtgcgtcYBagtRHg
+acttaaagSHatatBaaDgcaKtcccDgcacMttatRaacaataaccWtNBaYatttYac
+YtagagattRtatagKcatattDgKtNNgtttWNagggtacStataRtVDYaacgtaBtV
+KtagaagRttttttatataSaagaaKtaatatKtattagBtHataatatcWNaacagtgW
+accatatStcYcaaNRctcKacKttgtStaaKRaWDDaatBtttgtcagggBgtggScta
+aWtttYVWttNtctaacatagVYatcagatctVaHMgWtcaagtataHtgacaagttSac
+gtNRataaatgttgNtaattagaattgctMaRttBtacBatNgacatttcaMcgtaaacc
+tctagHctaaKNttBatatttaatattBaKtRagYtatattSgtgtccBaNSattgaaat
+tgYggcaaataatatHcaaaatcMBaagYatttttaYttYaStatttDtacRtgRatttt
+ttgDcRaggagcaccaattcRcttttataHcggatcatNSatgtagtHHcactgtWgtag
+gtNgactactHagagHattcaggggSaatgcaaaacSSKDtaggcDtatVagMtggacta
+BSatagMttaggatSYttaacBtagaNSVtaSaNcSScaaatattVctcYaWYtBcttcg
+aYBagWtRgagHKagagMaatttMatgtDtaYNagDtaBagcKcKcaMttKaaaaatVaa
+tHDaataacgRatBNVKtMaccYaaccMgttgtactagcttMatKgKBtMagtcttMWga
+atRcacaaaaSgcgVtSatggcaggcgKaYaatgctcattaaaggDVacStgttaMaaaa
+acNVtBtgcttaacgtDNaaRcgWaKtatactagcactgKVttaatcttRcgDHHattcS
+tatgatcWataagtattttacgtcaRgaaMcDattYHattYgatatcacNNWtDatgaaa
+actgaatHaggaNcttcctKggNgatBaaatttgcaaaDtgctcaatgtYagacMgtVVt
+gDBaacVaatNaDtatctgaaggKcagSggVtacgatgNWtKWaggMacctagaatattc
+ttYaatDatcgttgatggtcaacgttatatgcttaWVttccRgVcaDcgagMtacattaM
+taVWcgttRcatRacaRcMcaNtaYWNYgMtatMgccctaKctagHtttaaBVMaaWcSa
+ccgMttBRgNcRWMtHMaccaatgataaggagVttYgaatcttagtgtcMtgcctVtaRt
+gcaccaDaagHactNYcNcttaaggcMBagaWtattgtgctaccacgcWataRaHtDtac
+gaaVttagttVacctatatStDgtggtaMgaSattcatgMcaRctatgWgatKatYYaaa
+taNYcSaDtttgtcYttttttaBScatRtctgtaWttaatagMaacatDttaaaNgaact
+tacYttagaaccctgNgagMNHaaKacccNatgKccttaKcatDStaaStNaaVBatagt
+tcacRtYcRcKaagMgctKtBagSaagNcKRttaaaaKaaRttttttatHHNHaHRtcaR
+cMataKDDtNcKtKatctaaataaatRatYttMccaaaNaaWgctgattcaaaKgaatSc
+aNaaaKaBaaaaRNtataVcYDattagctattaaatWtgBWHgggtatcatattatcVtt
+cgHacgcgatMattDcaRggDYtYttNaaaatBKttKccStYVDatatYcctSacVcatt
+ttatMtWRctaYagRgctcttttaacVtagaNaVRaccgRaattaaVcaattgcgKRctM
+aKtttHgctttVMaNaRaNMKacHSagtWagtgNatKttatctataaHatgSaSattcag
+tDctWaataaYtcagtaYtctatHcgattSRttaaaNDgagatatacttVttatcataSS
+aBNaDataRtRRaattcaRataaRtattttNaRYtaKttaccaaaaaHVaBtttWtttga
+tRagctaMattgcttactctgatKtgatgRBttaataagYttcStKaNgcNatacgWatY
+aatctggVtaaattYccKagaVagggatttatttWacgaBcaBtaaDttttcgaBcHDga
+aSgVNctgaaKtgaVagtVWgRHgtacaatattgcMDNNataatagaaaataatNtNgcc
+gaaMaagtgNttacgVHaacSgStBBtRagtBgtaaWgacttcKgactaaatgaagVaac
+aBtggtacattcaaagtgattagKagNatatVaKBacaMMctccatcgcgggRctttKaa
+BatcacaScaNaaaaatVgHaattaatatcWcacacactcatgctcgaRggVgcatatca
+DcatYgaggttDgWNagagaaagagaYttHKaatgtaVtYttSNaDtcgaatctattSKg
+tgtaggaMgtaccWcaMRtHttaaatgWtgtccgtKtacggacaNgaacgaSgcYagcKB
+ttNacaagatacgaagaVcBgStMacMtgKaactataSgWtaaaatDRataaaNaSaagH
+ttHWYgaccWMtatataaaaagatgtaKtVtgtcBNMtRaSaRacVataaNaaaDtaatg
+taaagaDgtataVDaacagatttWtDtcBgatggBcgagctcKWgtHcBgcMaatDNatc
+aYtctBgaHtccagHctttMtattgtBccaHMctatctNaaatacgcgtacatacatcta
+DactactcKtacctataDccMattRgRggHtaaaaNYcVtatccgttSaagYcgMattta
+VattttHagVatVtttKattaagttaNaacaccHSttagDactSNgtgtttaNtVtattt
+atgaaacSaKtactctacgagttgaagtcaSBaDgtagatNaaactRKttcatcWtaBag
+gKtKcYttaDttatMaWcStgattKattgtatatDttatDtKatgtaNtgtcgtcttttt
+taBtDBcaaaaSgDatgHtctacaattcgMtVYtatgcattaaaattcaVgatRtcagBt
+caMaNctHgtatVatcHttcaDNKgtWcgagHtttaccattNgaactYacaKgaaagtgg
+tttgtgatcgaKaHgaatYNtBgcaaVatWacNggataccaDtaaaWttBMaBccagaHD
+aataaBaagYVacYaScctYVgagWagaYagtgatgtttWatSaaaMYDcactYtaStWg
+aaattacHgKDaYtttttgttcaaaaatttgYatatVcMatcactggRaaMVtStBtaaa
+agggatYaagtBtatcatgcDttDaaaaMatagtctaataNtcttWHaaatcaVttaRaK
+tcgatttataWRtaatatcDWcctaNMatgtttDaYaaWtMaagtcagaKtaMKacgcca
+aVatgWtSagtagctatttcactaaNcaaaNaaattaggattatMWgtgacgtcttcatt
+acaYttctRRtttgMatggNtatacaataataNgatNcMttaggBcDgRHgatctttagt
+NtacaaccgBatgtHaatgttttgatatccgttatcataStaKRaKgttgNaagagKttg
+NYMaggaattcagaactcaRataDttaagcttaccttttgVttaWWgacYggStacYcga
+tgcSccaacHcaYNtgRaHtcaYaacHctYacatagatBgtgacDaNgatMacgKgBaWa
+gacaSgttaKcatactatatcaHaatataattctggtcNttaYggDRtDaSHgNttYaat
+WagagtagaacKtWtHtBatNtScttttacaattagtaMaatttHgtctagMctaccaga
+gttcaKcStaccKggaggtctgcNatctctDgYccaaVgttgaatgacVcatagtgtatt
+ttccttcatctacttSgaaStcagHtMaataWNDagtatttttataggcatNKataNaMt
+gctgtttVaacctVBDWattgHttatattaKtatSVSttgtaScgcMcccattgggtaga
+KMgaSaSttYgcaaMaatVaVaKgtatgYNattcttagWgtcBaaagSaaatRatttNct
+acaStggtYcaaggttBtgaDWBtRtgaaDccacaaaVSatatBcaaScWccgaKttttc
+gtMaVttgatgtMatacatgNttBaNaagtaggaRaBagaagtaRtaagttacWatgHtt
+taagSaatgataNWattgtaSggHDtttBataaNNBRaatKWBgtaDcBaMaKtctaYat
+VaKataaaattWYcgtaHcttagtgYtgcKDtccatMSaaagatYcSaHatcaDtaatgM
+MatgcaaatgtttagaDDNtatttgaaKcNtagKYcaBMattaaagttaaWDacgRaRta
+KttaaattaVVKaMaBtaKctaaWcatctRMtgKcBaBaaagattHcgMcgaSNgactac
+cRatHtaSNtctYcaaBDtaggaagcMatttcaBcDaaatggWtcaHctaKtHcHMcRga
+ttgaMtNVaDagttaggcttYctcatDacWDaaaaaKtaBgtBaatcaataaKgactgac
+tcNcattMcacatNMattgtaaaNaaacttgctaRtttacttaatKYgcttgaSStgtaD
+aNgtaKgBgMaKgccagtgtMgatHDtgacaWDttHKaDgMacttaKaagBtttgtctta
+agMagtaHcttWcacaatSatgYtgacHgHcaHDgtagaDccVaKcaataNttccHYctc
+taSRtaYagtNgDagatWtRttSttNtRNagacatattttatggactacYMagtMacYaa
+gYgVgKgtNtaVcgtgaatcataatcgattYtaaatYtctgBaMgNWNKMgDttttaWta
+BaaHatNHaDacctccNKtgaVcWattYtgccaVRattMacBtcccNagYttBYNgaBaa
+aStWacMgcttccatgHaacttYagMtNaaVSYgcgatatHcaatatttgtgBcatWMta
+aaaDRttHaBaHttgaacaaataaWaMcaDctgBtatWttaacaaWacacWtDtatttat
+WaaHacaVagVgKaaaDttWgRBVagttVNttctgcttgacatttSHHMKScSgSaMtDt
+aMcgtcaWaacactMcaHWRgaactWtcgcMNcactVDaatHcDSttWtagactatgaRN
+cttagataYgaggaagagcaSHcWtMaKStatgYatttttVaattgtttWataaaDaDga
+taMcaMtatttctVKaKgcttcctDagtgatWatacaRtttaaaBSMctHaaatcagSta
+tStgaaVttaattatttgctaagcgagaWaaWtccgcaaSgaatVgtaStMcSNcgtWgg
+MVWNatHctggRtttaacNagtttRtaMBgatatHtaatcMaaaYgatMtaccttaagYa
+tcgaaattMataaHatYMcccaaaDaYaVaWgRaHaaaMcHSattcatWSatttcaMtga
+taKBYtactgaNttgaaDactgBatgYgttaagVgaagDagaatttKNtgaMtHagtaaH
+RgaaatttaYtaccNcgWNcKtaYtBMctVBWttttaSagRHBtaHtcgtactHggagta
+atttaaaVVattWDgtaaHaYgDtaacatDtacWttttttatgccacttaDtagtaaKgY
+NcttMNDaBcaVMcMctWgatactaRcaaWagaatgcWcRtattccagKgaNgtctcKtW
+gaNtSttagVaagaSYtcctWatatSgaDaKcactcgBtYacDgMtaKggtKcDtRtRgS
+aNKctaatHtRDaRgatatacattagtgccSttctDgcgatNcatttcHgcKtagcYgtt
+ttgNKWRattgBtaaNcRaatcNaagcgaaVKttYtWttaBttttttNggKcgaRBMVtN
+cNtDVaaMtcBNaKtaataRMcaaaattYactactBattWcgccgWaaMtaBYtgtaHag
+tcttVttaggaHVaaNaNaatcttgtgcattttatMDYKccataScaWgNttccttttMa
+RcVtWHgaaatgBaaRatgcgatataaaWYacYggtacttaaaaDaaattgatcWaatgt
+ttRcatatcaggaBcttttcttVKatKccaccYtDatMtcttacMtSattaatatagaat
+gSgagYgWNtttagtatgRggYKacaatattgggVtttaSaYcaRtBcggtDaggYaaac
+tNataggaggaDgaKcaaataagatMKaattaaNagtagttcWctataaDtttcgtcgta
+ttaccStgYgatgKtgcccYatDctYtttttYttaaaagaactcaNVaaYaYtccagacB
+ttKcaatKataatKVWcBataaatgttcctatYaacttaSVtgataggVatgagttgatc
+ttacgMMgtWtYtagcacaSctcHYtataattMttataYaaccKgtgtaaKcYagaaVtc
+BKattStgcaaKcaKKaHgtaaBtctgcaattaWgMcgYttMctWtaDNcDatggWaatt
+ggaVDagKattttgaaaRHattgMaaMgtaatcattctKgNaacacccNHataaaatgaa
+agagSatKtacVagttggtcgtgcBtgtgcatgagcaacataagKtcagtttgtDBBHWc
+gaDtatYttgattcttaaagcMMttaKgDaHtatVgWHccgatKttcaaNcYtcaaDWDa
+tcaWtBtWHgctaaMDaDWtWtNKcRRaNttVgHaRgKgcWgattNaaattaataNcaRt
+agtRgaacagataDKgtatScattaDgatcatMtcgYcgtttaaaRctcagcRattaaca
+tccStcBtgaccgtgWaaagaaatgaaWtattaVtHacctaccaaatgBgtaVVYaaaat
+ccKgtcaactataDgNagtcaSgtKttacHtccMKKWattagtatNctattagtttWttR
+tgaKaBHStgRagattaKRtWaKttaaWaagtaVccctgcgMRWatgttNKgtcSggSHt
+aBttgtaYaatDtaVtaatgtHcatWaYcMttataVgaaaaagBgaagRattccggcttD
+gggcttcttaacttRgaStaMBaaMtctMBHBacttVgKggcttgcgBcBtgDtttccta
+ttaaRcatStNgcKgctatcccacSctcHtaHWtgWaYatgVaRRYtgctaaaatggaga
+cctMcttgttMagBaKctttYWBtaYKgcccYttaMgtHaaNYgtgtagagDttcBatgt
+StttMtBWtaaBctaggaaNgaRgcttttttgtagacRttHSagaatDaYgcctMBtgtN
+SNaaBttgVtWtttKgacaatatVttVatagatttgcgtcgDtVgtSattaaaVHtaDaa
+tYttatKSWtcattagtaaNatctcagcgtgcKcatDtaBccaaccctgaYcattaNaag
+NaKgagttttcattaHMaVKMDDtaSHScaDattgcaggcccMattatacYtMatWgatt
+tcBcBtBctKacccaaWctatccctcaacaataaataaMttgtaHHcgatKgaggBtRYa
+ttatacgtaYNBacagacaaatVtMcttttRtVcaattgtttgaWtaaSacaRccMcaaa
+cttttaaacgtacVBtcWcSaYHgtattacgRtgtgtaKgWgaatctaBtcgtgRaaaWW
+VBcaNtcgctgYtaaaHaSccaagaVMNaacagattaHRaaMWcVgMtctgcatgaagRD
+attactgcKHtcactYtccttatgHtKgMgKcDtacNtcaStgYccaaDagttDtttgYc
+aagcacWWttaMgccaStaaWtVactgaagtKtttcaWaatgMattatKcctctttttca
+tgtaaactttNcaaKgttttMaMcYtgWctMtttactttagaKtMgttDYttctatagWc
+RttatYSagacttcaScaacaYtSaattcaaagtgctSaagctattaaagggtaactcac
+gDKgttaMRgggattttMcgttattaVtccaNagaRgMaataaagaStcSaacgtaWtta
+tatHgttHBcgtacggKBtSatDactRggaRgccBRttctaaaatSactcKtttVaWRat
+atttWaHaKMatgtacatcagctaatggBgaBNSNatatcYStagaatSNattaccgtca
+ataaggYMRtaDaatVgYaDaattataRgVaagtgcaNKtgttgacttatHccacHaacV
+cWcNMDtatcatttttaHacatKtatagtgccWttaattttBSDaKaHaDttYacDtBgt
+MNgggBaaaaattDaaVMaKgatcggKtgtctatctctVatcDtaagaagtgtaMcWatD
+ggaaaaaYtcDVtNttcNacgaYtcgatHctctaWgaaggtMttcKtcttaMgtctKNag
+cRWcgBVtcBDatYKtctaVaaaBgtaRagcacggcaHHagcagaaaaacgggtataatc
+aaWtacYcWtcctaBgVVaBagHaaaaaatataRYagaacgggVtttcHaMtNtMgcgaa
+atKtattaagtMttatcttWttttRaatatgttatgtatttRaagKtBgtgHtHDggaBD
+tWccattcKtttagtttagtBYcDaMBtgatcttgacatKctBcaaaacaHtatggaNaV
+ttcgttatttttttcaaDtDDaatcaaaYaaBHttaMKMVgctgWtacVtRaaactgYtc
+atggcVHtgattRttataBtcgaaRataDttaatcattHtatatccNattcaaHtgKRtR
+tagtKaRWaataYaggatccacttcacaatgtgatMaggactNaaccaaMaaKtagaaMc
+tacttDSaaaWSgctcagtWaataWaHtStMacttaDtgagWaaaatatttatcaacaac
+tRtDgYcYtatatgtataatWtagccaagcgtttataatDgctgVaaagHaattagaatB
+WggttctBaNtactHtKBtcgaaaRttHBatDaaKccaSHgtgctWttcBaatcctYttg
+aHacgtatgagStatRtMaacKacacggaaSctagDagNttgaKKSgtttctacgtagSa
+taHttDctggBcYtttaaatcgRgagagaDtgRSaVStggVtgacgtMtatgaaNtWtHg
+tDaDtgttNaSVagaattccgcttVatatacattatataYtaggYaaaRDHttHYDtNgc
+atHggctattYtaMcWaaVtaNtatttHaagBtatcagatHtttgaaWWtttKaaaggBt
+attHagtaacactDggtattttScttaaaacaStcaacHttMtatcagatSaHtaVtBaN
+YcttHcatgHatagaaggggaWgtgBtttagtVttgacatYtKtattaYSggtaaaHgca
+ggaStHtYcgtaaDWgtaaaMcgYtNHtgNgcttttataWatttKWaaKtHattgRtBtM
+MccgtBtYttgaKaWBatcBgaaacaBgaagatYgKWaaacBgatgtDaaacttDcacga
+tSKtaVaRDWtVKgHtcRattactctattBacaaactaatgDtaatcatatKRattSggt
+cggRMaaHVtgttMcgatatcccgVctKMgBactVtWtBKtgWtaaaVaatRgKatttKS
+aYHtcVBNtgStgtatNStaaccgttaaaaYactBgaaaaattacacVttKattVNgaMa
+ttNccctaVtaaStctgaaVatactgtctaaaKYNDtataWtattaaNgtHtaWgaBMtt
+ttccaaaDcgctgagBacacttctDSctcMtBtNccaacaaatSVtatWggagSattKat
+RBaaaNtNtttagacttaagtHttaatcgtWctHaMBaHtaaagKaaKttgatattttgK
+cgtcDtgtKtHagDtMtatgatcttgtcSgtWgctaaaaattDaaaNgNYtMttNHgtHB
+ataatMgMttctDcgtNtNatggKatHtaaRtRtDStttRVcaatKgaaRSRtBttatcc
+ataaMttagcaaWtagtVgaVBatcVtYtagttgtaMactaaataDatagNttttactag
+cgcKctDatatDgaHtRatVWagaDtttcggSKataacaggaaKggMtttctaVttMaat
+gattcgaagcgattaNNtYactttKgaatWttNNgctatatgttacKaMtaaDgtKgttB
+ttHtDacaagaaRgDgttWtaatgVBcaaccatgcYggtRcctaaDaaHcatYNaaVDNt
+BgtBaattYYgcHttRctattVtattgttcKaaatagtacccttgcVtaaHttaagaKta
+agSaYtgcacttDattYttaVgRcacaattDDttagattttcHagccaYaataKaatccV
+DKctNcctcaaBccaaBaYgKacWVtWttatgcSatcDHttattaacaagaacRSactBH
+ttDaBBBcacgttactHaKgacaKtaWMcHtaVHttaattcgttatatBaaagatgaact
+aaYgDNattNaHgHKtaatcctcttcHttagaatVcagaHtagBgtMataattaagtcSR
+catSagMagaaaacgYacgagcacgBcggacaHKaaBatSatagtatcDttRHtcagtDt
+aStYtagaaagtYNHtgaacaatgcgataaNgtNVagtacccctBcgaYWaactRtDtat
+ttKatBccVKtHttNcttVtgaKMtgcttggcgaNatctcKggtcttttataaacWaBtt
+cgHtcaHtcgatcgcggccaHaagcVgKattBaaWttKcttaVaagYaVacagaacgcSc
+DcgatataagttttacaaKcaaaBcYcHKctRagcgaatgtScBagMttYHtaatHcKKt
+gggatgKSaaatactgWBHVcagHcttVBgYDtaVtcctcatRcVKcNaaYaBtatttta
+tRtVtDaaScgtatacMatcaaactagtaKataaatStHtacaagagttgtYatctagaB
+aHSYtaaataaaStacaHagWSRSDtagtatggctgaKtaRctaaagBtactcttatgBc
+HcNtNRNtHataaccRttagatataaHtacScgtattgttgtDcctaYRaattccaNatg
+tgctaaaactMcaWttgttgVMaSgtaVaSctMcagtcacNaWacgaatWtaRtaatSga
+tgaaWtaaWcgtttHtWcttgatKtgDtDMcagtcattcacttgaaatactWgtattcHt
+tcataactgctgtgtKatRagtaatttYgNcaatcBctgtStaggtaMatacgtYaRNtg
+NaHtNccRtgcSHgRcaatttVcctattaBKtgYtaMaactRaaaaBaattHHtatVNWY
+HaatcagtaMVtttctattWHtttacaaVccDctYtttVtNtRRKtBgatHtBcaatHYa
+SgaagaagHagtttDaVaattVactactYcaDtKttgVVVtaWtggctaSttgtaataDc
+tWactcaRttWcMSYtWagaagttctKHcgKtDaYggaDttgtgtataacaRKctaactt
+cYaDtccNaNttaYtaatagRttaSagaatBtVRtaatcttatgcgtWtataaWgHataa
+tttYYSttYcggKKtaHcttttagHDDBtggtttaaacatagaRagtVagactttacKaW
+DMacgYaacctgctKaNattggatggNgtKcYSttttcctttDtYttBcatgattSHaac
+cVtccatctcccacDBtgaWBaMaaccgttttcttaaMgScBNatBtagtcttccttatK
+BRcctggtVStatagcDgMgtacattacccattKKtaRcRatRctYVaSagttatatYtc
+gNDDggKaHggcccgcRtacgDtcYctgaaacHtatattaVtcaattaaatgaWaBggYt
+HYYaVagWacaNtDtaRattgRacRtacacatgHtagagtaatatttctgDDcttgNDag
+cctaaHtatYHtKtRaScgtattMttacaacHggttttatSgaHVVgaattaatagttat
+tactgtRtaWgataMDaaaactgNYacYtagKtaRcaYDHatatVatggctKtWatHaNt
+taatttttgtaagcctggcgKataaNtttRMNggDtataaaatVcMRataacagctMatB
+gMtaaVcgagattcaaaSgtgKacgtDHatWaatgttcDtWatgYcWRttcatBSHtttg
+aatatBgaaWgggaaBcctSSVaagctSctagYatDggtatatgtaatatgtatgHYcRt
+agagtHcgggcataDHattcaaattcRgcaaaataagattcaaYVtaBtaagRagtttgS
+RtgRYKgWggtttaaHgcHStgtggtctaHaccaccSaaaattaHatgttVtataccaga
+atDKVtctagtttcaatgtNctaccgDcacgaattacactatgaaggccKVatccaSWaa
+KHtttSggatgagMagttgcaatatKYtacBttaccatHRttaacttacaDKKtaKaDcH
+HcaYatatgMagaRaNNttcggagYRtacMtHgacttagacBaagggBatcttgaRDact
+gatacatatcSBggtaaaVWgMaatttaYtaWacHattDMtttaaaRRScatcttctaat
+acagtBVgtgtttBagtatgBNcaagHaaaSaSYKcacMtKatggcacgcctSRaagcat
+aattaYacctMaaKtcggaBaVaaWaDMttgccttaaacttDaaHacNVtgagaatacca
+ctctMttaatcttHcctttaggaKgaggWtaNataYgtaggtgaagtcWDcWaBatattR
+tVgtRgVtataacDDNttatcYaaaagcaVgtYggaDattccgtccDcSttaaWtttcaa
+aatggataSatctRYcaaBctMMtcttaacMaSgDatgagatcaYgctcacHccMgaaca
+tcDNgtNRcgBaaatagaYgatgcttRaattStccttgagcctaVaagggatatcagtaN
+MttaaHcMaatccScBtYaYttatgaMNagtgHaatHacaHaBaaDtaRNDNcBtagBga
+catStagacttgtaatMtYaNaKSaccBtttHcDaHNBttBaacSaggagaacgWcMgtR
+caagattSctgtaBtcaatMtaHgcaaccataVgtaagDRcDcggaaccaBtacVMgStt
+gtcataaaaacaMataHatgttaacaaMgtacgtMVcatagYtKgtgtcctaBcYKattc
+aggBaaHagStcNcattatRRaSYtYDRaHYttttggaRggggttatKcVtHgctggaNt
+taagagBaacattggYaaDcSacggYaRttacaacactcDcacBDtYataaaaDWtctca
+ggVtaYttKtaVKtDSaMtYtYcgtaacHtRcHctaacBgattttagHaScDctHttaaa
+atVaHttggttatttDtatHtcaHcBagSttttDctttWtctaaataaWtHYtRgtBccS
+aaDSaNgatcSttaaaatgaYgKaaDaVatatYaRaHDtataKaNtagtacataggSaat
+MtctMtccctWgaYtaggataMttcgtacgccYgBSgttaaHgctRgRgtDVSRattttt
+taaKtRMtatSgRaatKacMaYgggtagBgNHcgYRagHcatatgtgaacMtacSDRMHa
+aacHaagtWSMcaattcagtDctBattgttcatttMBaDVHVDBtaatKactNacgcBYt
+ttgatctatVVtatcKaKSgtaWcgtcgNYatSaRtcaggaRtctattagattKHttYaa
+BtcacatataattMgtatcataKKatDVtWtaHtHHVaggaaHagWaHtattgtDaHRga
+tgtaaaWaaSStMatttgNtgtcagDWgagaBagtcattaataggagttcagcHttgWag
+aWcRttaKttaDgaDWtYacMWgRaatatccMtaaattRaatacaKYcgcatgtatgtNa
+ccataSttSatttttcgatcttcaaKcMDatgaattcaMWctKNcHtctacaYgatgcaB
+tDDWtaRtScaYaatYSgBtDcaacYataacgcDgtaacMtSaaKcKttttDVgttgtaa
+NcaattctcaataaatcSVcKaacattgggacatgaaaacggaggagtacDYgatMYtta
+aaBBctccYgcgagccHattttaWtataYcaKaaDYaaaStMctSattaatataNaWcac
+aataVtcatacaHcgMgaatYgaataatRcWcgtttcNDYcacaaacacaNttttaatct
+aKtRttHDSttccWatatagtKtgtcgaccaBgtVacNaYBHgtttSSagcNtctacctt
+taacgacaDcWVacSHcaNacatttgBYaaagatWagaacYMatcKgBYcBggtaWatat
+aKcNgaaaattHYtSaYDVHSactgttNRgaaaMBtatataaaaacVtctWtgKggtatD
+BgHaKaHVcMWtYYBaaattaVtcgaaacatggagYKtaaaacagttNtttatcatgcta
+gYcctctNgttctgctaYttBataaRtattgatgaaactagttBgagtcttccatBagat
+ctBaaagSacagtaaStaaatatataataatcttaactatVtaaBattHcHgcttSSaaD
+RaKtataagggKaacRagBaggtaMYttggtacMatMttttYttaacttaBaYaaaatKg
+tactactKDctcttgaDtMgattgVgcRaaaKattaatataagWgttcaWgtcaKtatcg
+acatDaaSatHtttcagcNtatSggtgtaRtgatttStBaNaHgcagttaggggatWttt
+gattttatcgaBtctaggcgtgtgtWttttaaSaWKctWggtgataaaattacBtMRtat
+ccattaaSWttaSMcYtHtaacttaaBaDattctatKatctttcatDtcgNcgacttgta
+aaattDcaVatRacatgaaagtcctgtctcatacatatcSWgNDttgaaVKatNacDgga
+gWaaatgaaVNtttBataaagVttVataataYcNMVaNaKaatRMcagNacVRactcWgc
+tttNatHaRaBRtaaatRtaKtNgYWattaatcttaRttgttcttaaWaaagttcNVtag
+MaBatcVcgccDaaBMgKttgaVaaccgYtRaactttYtcatgattgtWSaaBatagtag
+SataDgatgNtaWatcaMttaHattagVtggagaNHtaatatctNaagaDBatcttttaR
+aaNtBYagtaacVttYBtaagcaaaMatcNgKaggacagagtgaRatWaDaaSaDaaatt
+VgcWttatBNctgSagtctgcSttacSRtgatHDgggcBagccDtatYaaagaataDgat
+DaBttagctatcHtcWtagggagtDtSaaacagtagcttVatgttggcStataacttVta
+atWKtatDatcttcDaagactgtgDNBaccaattaacaaagaaHWtatttaacattWaat
+gttcMttaNNcYaRccHtacRagatccKaaYactcVRDtcHVtgaaNaSatctRSaWtag
+agtcgcaataDcagBaagtctSNagaaaKgttataStaatagStaatSatataWttctcg
+taDgtYRcgtHttaKtcDttRaatNacYgtagVaattNttttatDgKcttttSaaattYc
+gYBaaggttctagYcBataacVcagggaWtaKtacatgcYcctatccDatatagtcRaaa
+SMgtggaatcaaMaatWcgctagggtcattaVtctaatgHcaSHtcacttBaagaMDtac
+tYgtttgWgacccStDtagaDaBtgctctttKaaaatMttNStggtttatWttYttatKM
+KgtctaKcgaBaaaattcccgacYtBcaKaKttRccaaBaWgMaMatgtWtcRDWttcgg
+acNctataaacKaaatHatggDatSaaKtgcgRaaacgtgttcatNtgHtcaataaacaa
+WMKatattcWaKcNaccWtggttcctBaMttgRtggtWtaaVggDgttaDaScgWccWHa
+tacaagtaHtaacttWaNatgtgttaacKaVtcataDMattgtaKccttttttStaaDDt
+HYattNtcgatataBattctWRatMVtStaSaWttNRacgatagtRcgcRtcctttacag
+BKaaVcYtRaKatVtaWttaVggBBatcaaWatgtggagattDgWtttcaataDtactRa
+atBattWVacttWVNtVagHaHtatttaVagtRMMtaBattatataaNaagatHBtgtat
+VtaaacatttagtccaKDcacgWaaHagttVKBgcgRaSYtttVcgaacaBatttaatct
+aSYtccNtcatctatttatBaHcattcaBgDMYtactgScccttRctaagtaaNtaaaaa
+ttatggtVataaagVStcaatcacgcDaatgtaacatDBagtcgaaRDaSactgcagaHg
+ttYatgaVgtNccttcaKHgcgataDcgYtgtgBatcacScgctBcVttttcYaaNtttt
+tatcBaatgataYgtgttgtatgaVcBagtatagtNaRaaatKVtcRtcWatctaattgt
+VgataaMataWagaDttaatRcgctaKHgaRagtDctScatNgHgtKgtDtHBVgYcaga
+tgttagcgaataaNBactBaaRaWcRcMctctBtWKaggcaataatSYtccagtRtaSVt
+RgatctaBgDNDtBgtttgtaNtWtaatatDtataacgccDttcaMaMatgRtgaaaMHa
+tgBaatgcccDagNgttRDcWtaaaKtMSaBgctgcaatgtSVattRWcBtDaaMKRccc
+WtVttaaatatttctgtcatNBgaaaatHtttWtYtttcaacaaagaaNYBaatatctga
+tNtgaacaaMaaYcNgtgatttWtNaatWcYMScMctaaStttNgHtMacgtMDtgagca
+ttcacWtttKttBtKaKcHaBtttaBacgaaNYaaaatBaatNHgaaatMtagatDcaag
+MtaattctKtgNtScaatagcaHDagtagagSRcagcaagaccYHtaNtBatKtStcRag
+tgttMaYgtgggtNatSaatStcYtaBaSBtaggtctMtatcatgaattactcYtNagaa
+aDtggaaatKBattaaatcWgKtStKtcaWMggaattYtggccgaWcacagaNWaNgaac
+aYaHgaVtMctVHttaKDcctNccBKMDagtatgcHtttaaaDaggtgHtattcatattt
+aagcBaaaRcSgttaaatgWacRatacaaatgBatYatatRBcacaVataRaKWMcDWtS
+aatatHattcVgMKYtgtaVBtgagattRgaatgaDgtcaStacgctaggRggtSagKcW
+YctacaagtttBtgaBttacgaStHgVaStgtaRtacaDccNDattSRgttatMtNtttt
+WHacDtttVtgacgYattccWctaagtgaaaMMatgNtctaataRctgaacatttVcNtg
+tttgaggcaaagtatgVgtaVtgRDcttBDtataaMBatatNgataataHaaaNacaStg
+aNaHgYtgacagtcYDggagattNcaDtKgtagMaacSHRtcagNagatKcatataVata
+ctgRVatgBtatcgttattHtHcKaDtagRagtgHtaDcVtatacattacggcaKttatt
+gacatDaatgtctcattVcaRcttttgDtNHSggcttaYDcHaatcDYacccWaMttgRt
+NggYtttttggDgctacVDtBMgBaDgtMaaBgctBVttVagaHBaaaaatgNactaatt
+attNagaagNVaBgVtRgggatacgctgMtgaccatMaaDYDaagctggtcaatggtatB
+tNtccWtWKcaNcBttactgtgBYDaMtMtcWaatctWYHatccgWtataaaNNacNgct
+YagtaaaRtaaYggcagaMaagggttHaatatcaccVtagtggcgtMtagtcaYaaRttW
+gBtctgaaBtKattaatYtacaatcKcacNcMDtgtactatcDcgRtaaYagattgccMt
+gtYKaRaWHgtaccttagcRaWaagDataccagcatcYtcaaSgVacatttaSttSVDSc
+tactgaNctatVattttacgaggWgtaaaKtcNgatgttgcaaNVttagRtttttRttYY
+aYcaaagcVDMaaRaRtccVcSattttcaattagWattMMctataWatggtaagagRaaa
+ttYKKtgatagcMYgcVcgggStattacgBBctNtRgacaacYHctctNtataattBttS
+taRaaaatctgtWatcRacaaMtattYttKtccaatcSttatgtaWttcgcaaWgtWNcB
+ccRgtBagNgYtDctatccMaagtgcYMtYctYttgtcVaaHtatgcBaaBcgaataatt
+cttcDaacaaacBtagWYaagcaVacYcKYttgSaKVcttccgcctcattctcaatgVga
+aacatWWctgcagtttctttttMagWttatRggcattattVaagaBBttatctattatMc
+NtaacagttgaaaBaRtaRRtNtataYNtttNtcctaVBtatNtNgBtaHHYDttKctaD
+ctcaNcatgDaYatgYagaDcaHgactHgWWaagWtSttctagKaaggYtcataYgBtcc
+RaggggaaaHagaacaDatgaaaatcaKtattgWacgtcMSaacYaYgcWYNgagtaMgt
+SccgaaaaaatctggaMMRaaaataatctaaacgatatgDaggaVKcttttaatgacBtt
+NYttagtatDagYttWctttNgtHtcVtattHtcHacattatHgNStgtSaNaactVMca
+atcccBHNatcttDtcgaKccKttatttctVRaagttaMtaYtcttcatMYRctttRtaM
+gSaaaactgWacHagtacccatttcgcatgagtaaagtHcaKgVBtaattatBtttWatg
+MctccattgactattcttgtcatSttaaHaVtKtDcatcatatccaacKatattatNggN
+aRatcMSDHRtcctYRaatccacYaatBattcttBVctatatttRNtgaNtcaaaRgtaB
+cttaaDRcgctacWcttgatatctHttttgtNtYatatacgaVBgYHgattgggtcgaca
+cDtttKVcaattWRcaagBtgctDKDaYtttcKgNgggtcacVagatMgtMVgVgatttc
+agtcgtgKgtKYgtYSaMtgataatNggattKNgaSggactaaBagataacactcataVg
+ttataaSacaatcRRaagtaDaagDYtcactgtgaVttWtBaMttttgaHtKaYtattcc
+agccaaBaggataaRtBatNcatgtatatttcttacaaYVNatagaaagaSaaaagaaat
+SaBgtcgattacattgWccttHNattataacgVRDtYcWgaaYaVgMttcttgtDtKaYV
+ttctgggSNtaYHWaaHactaaSSagttgSaaactYaMttaMaHVRtcgattaccHtcgc
+gatgNcaYtatattacgcHaaaMNMtaYDgacaggRgaYVtVKcaSVcWMBBaWaWcagt
+atHaWBNaMcBtatccatgaScHtYtgactcattgaYatRtacttYtctttgBgtattaa
+DtcaHgcNcaVatagtttggggRaaaccWcNNttRBgaaRKgaaNtMaagcVacgtgtta
+aMYWtcBYtgagtaatcgttttaatcgaaaagttDcaatgtggtBaBcNtgNatBtggac
+tttagYttBcgttRttatSgacNaDttatRKacactgcSKaVaaaRgHaattaaaRctga
+tKaWcctWggWWagccgaactaYccttgtgaBHggcYttttBccttaggaKtaaaBacVD
+cBYYgaWagaKtaHaaactaNttatagtcttttacgaccctttKattWcgHgcaDccctH
+ttatVVaagKaatatgggMaNHagattgNStatBatcgaaYgcVcagaatcctcYtBKDa
+tatcNKgacaatKDatgaaacgaaatYYcgNBDtataatMcRWtaagtataHgMaVggca
+aDtggttcVattattaaaatSVaMaNcDBttataYgttttStacattgagagtccaNtga
+atttttKtStatatttRaatttcgBDccctaaSWatttaaMBStcatacctgctctatct
+atKatatgaacaactctWBaNagtcgYaaaaRtctMtDgtaBaacaNtacagtcgataNg
+aVccgtttattatgatctagtDSgaHNcctKtcttatNtgatYKaaStctWDVcaaccga
+VttScaagaaaaVcccggagWatcVaNtVaRcNtcagatcMMatactaaaWaagatYHRW
+caSagcgMtttatSBtBtBgacRaVgtgattaagtBgtatcgtNggggDaWgagctgatc
+tatttHaactttcgcttttccatttNaaYgtattttactttacttRataBttgataggga
+cattattaaSaaaYtgatggaDaMttacttatttttttaaWttttaataaWaNaattgta
+BtBMcatcNtaaMtDaaaatcRgcatccaMtggWggHggagSttacaYHatYtgtaatca
+tttgVtataaDVttcaYttctHtHtagttWHNYYtVRVccatacaattaaaYatcgcatB
+agcaatDaWacVaBWattagaaBataatgtKaaaNKcagaactNaagaNatgKtBSctga
+ttgWcNaaSataggtataaacVaatDttcRaRtVtVtgtataagMtSccaSScagttgat
+YattcagcMaaWctaagtYcSattNccgtcgtaBtaattgttgacaaaDttttattaata
+cSKtcgcatNttatWatacgRtgcataactYtcacHgVgHttYaataaWacgSVKatact
+agDggcattKctggataagtVgKYtatgttagcgtaRtttaaagacHgacacattcHKaM
+KtcgKtcacggtgatcaaBtMttcttattcttDaKKVgWagtaacatgKatVgacattag
+WtaRtaccRaaVHtttttRtgBccagtcgctagtRtaBcMVWMtaBtaggttaYcttaga
+SgYgttttcaaNNgtttVaagctgStttactaacWattcgtVgtgtKcgtYaaaaaKtaS
+aattgBtYgaVcagKatgaMttWDRatgtaatctagacWaccgcaNgtctgtgagtMttg
+aaatNtttattaRKcgtaWatcaWccaKtttNactaatNcgVaaBcgRgDttcDcatttg
+agWNattttNaYtttatgcHtttBBacgttgRgtcataNtatatcaWVcatgaacatRgt
+NaWaatcaggttaaSctttcaacatHttVKaHtNtMtcttcHattYatcgatgtacSaaa
+taVtcttYStaagattDagtKccgaccHBYatMtcggBacatVtaaagMcttBgtSagKg
+NttttcNtSaaMaStHgtattttKaRttaMtDtcKtcgagDKgaaaacttaaaWNaattg
+aWWaaggaaacKtttVggMBcatattDacctaMgaaKgcgcaaMRtaatcgataaatRDt
+tataNtVgtaVDggttaNgatBgtggcaaYWtagctcWgtSaacgtattKcgcBtttDac
+aaaaaStKMtatNccagKatgtVtHtWaSBgDttgWgaattWagttttaagcctNcttaB
+tYttaRactaattggagagggtctagtatgggtttacttBtatcatatgctaKggNcata
+aaSatgtaaaDcDRtBggDtctttataattcBgtcgtactDtDagcctatttSVHtHttK
+tgtHMaSattgWaHKHttttagacatWatgtRgaaaNtactMcSMtYtcMgRtacttctW
+BacgaaatatagScDtttgaagacacatagtVgYgtcattHWtMMWcStgttaggKtSga
+YaaccWStcgBttgcgaMttBYatcWtgacaYcagagtaBDtRacttttcWatMttDBca
+tWtatcttactaBgaYtcttgttttttttYaaScYaHgtgttNtSatcMtcVaaaStccR
+cctDaataataStcYtRDSaMtDttgttSagtRRcatttHatSttMtWgtcgtatSSaga
+ctYaaattcaMtWatttaSgYttaRgKaRtccactttattRggaMcDaWaWagttttgac
+atgttctacaaaRaatataataaMttcgDacgaSStacaStYRctVaNMtMgtaggcKat
+cttttattaaaaagVWaHKYagtttttatttaaccttacgtVtcVaattVMBcttaMttt
+aStgacttagattWWacVtgWYagWVRctDattBYtgtttaagaagattattgacVatMa
+acattVctgtBSgaVtgWWggaKHaatKWcBScSWaaccRVacacaaactaccScattRa
+tatKVtactatatttHttaagtttSKtRtacaaagtRDttcaaaaWgcacatWaDgtDKa
+cgaacaattacaRNWaatHtttStgttattaaMtgttgDcgtMgcatBtgcttcgcgaDW
+gagctgcgaggggVtaaScNatttacttaatgacagcccccacatYScaMgtaggtYaNg
+ttctgaMaacNaMRaacaaacaKctacatagYWctgttWaaataaaataRattagHacac
+aagcgKatacBttRttaagtatttccgatctHSaatactcNttMaagtattMtgRtgaMg
+cataatHcMtaBSaRattagttgatHtMttaaKaggYtaaBataSaVatactWtataVWg
+KgttaaaacagtgcgRatatacatVtHRtVYataSaKtWaStVcNKHKttactatccctc
+atgWHatWaRcttactaggatctataDtDHBttataaaaHgtacVtagaYttYaKcctat
+tcttcttaataNDaaggaaaDYgcggctaaWSctBaaNtgctggMBaKctaMVKagBaac
+taWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacggtttNattgVtttctgtBaWgtaa
+ttcaagtcaVWtactNggattctttaYtaaagccgctcttagHVggaYtgtNcDaVagct
+ctctKgacgtatagYcctRYHDtgBattDaaDgccKtcHaaStttMcctagtattgcRgW
+BaVatHaaaataYtgtttagMDMRtaataaggatMtttctWgtNtgtgaaaaMaatatRt
+ttMtDgHHtgtcattttcWattRSHcVagaagtacgggtaKVattKYagactNaatgttt
+gKMMgYNtcccgSKttctaStatatNVataYHgtNaBKRgNacaactgatttcctttaNc
+gatttctctataScaHtataRagtcRVttacDSDttaRtSatacHgtSKacYagttMHtW
+ataggatgactNtatSaNctataVtttRNKtgRacctttYtatgttactttttcctttaa
+acatacaHactMacacggtWataMtBVacRaSaatccgtaBVttccagccBcttaRKtgt
+gcctttttRtgtcagcRttKtaaacKtaaatctcacaattgcaNtSBaaccgggttatta
+aBcKatDagttactcttcattVtttHaaggctKKgatacatcBggScagtVcacattttg
+aHaDSgHatRMaHWggtatatRgccDttcgtatcgaaacaHtaagttaRatgaVacttag
+attVKtaaYttaaatcaNatccRttRRaMScNaaaDgttVHWgtcHaaHgacVaWtgttS
+cactaagSgttatcttagggDtaccagWattWtRtgttHWHacgattBtgVcaYatcggt
+tgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcVtaBtWaaYatcDRaaRtSctgaHa
+YRttagatMatgcatttNattaDttaattgttctaaccctcccctagaWBtttHtBcctt
+agaVaatMcBHagaVcWcagBVttcBtaYMccagatgaaaaHctctaacgttagNWRtcg
+gattNatcRaNHttcagtKttttgWatWttcSaNgggaWtactKKMaacatKatacNatt
+gctWtatctaVgagctatgtRaHtYcWcttagccaatYttWttaWSSttaHcaaaaagVa
+cVgtaVaRMgattaVcDactttcHHggHRtgNcctttYatcatKgctcctctatVcaaaa
+KaaaagtatatctgMtWtaaaacaStttMtcgactttaSatcgDataaactaaacaagta
+aVctaggaSccaatMVtaaSKNVattttgHccatcacBVctgcaVatVttRtactgtVca
+attHgtaaattaaattttYtatattaaRSgYtgBagaHSBDgtagcacRHtYcBgtcact
+tacactaYcgctWtattgSHtSatcataaatataHtcgtYaaMNgBaatttaRgaMaata
+tttBtttaaaHHKaatctgatWatYaacttMctcttttVctagctDaaagtaVaKaKRta
+acBgtatccaaccactHHaagaagaaggaNaaatBWattccgStaMSaMatBttgcatgR
+SacgttVVtaaDMtcSgVatWcaSatcttttVatagttactttacgatcaccNtaDVgSR
+cgVcgtgaacgaNtaNatatagtHtMgtHcMtagaaattBgtataRaaaacaYKgtRccY
+tatgaagtaataKgtaaMttgaaRVatgcagaKStctHNaaatctBBtcttaYaBWHgtV
+tgacagcaRcataWctcaBcYacYgatDgtDHcctaaagacYRcaggattHaYgtKtaat
+gcVcaataMYacccatatcacgWDBtgaatcBaatacKcttRaRtgatgaBDacggtaat
+taaYtataStgVHDtDctgactcaaatKtacaatgcgYatBtRaDatHaactgtttatat
+DttttaaaKVccYcaaccNcBcgHaaVcattHctcgattaaatBtatgcaaaaatYMctS
+actHatacgaWacattacMBgHttcgaatVaaaacaBatatVtctgaaaaWtctRacgBM
+aatSgRgtgtcgactatcRtattaScctaStagKgaDcWgtYtDDWKRgRtHatRtggtc
+gaHgggcgtattaMgtcagccaBggWVcWctVaaattcgNaatcKWagcNaHtgaaaSaa
+agctcYctttRVtaaaatNtataaccKtaRgtttaMtgtKaBtRtNaggaSattHatatW
+actcagtgtactaKctatttgRYYatKatgtccgtRtttttatttaatatVgKtttgtat
+gtNtataRatWYNgtRtHggtaaKaYtKSDcatcKgtaaYatcSRctaVtSMWtVtRWHa
+tttagataDtVggacagVcgKWagBgatBtaaagNcaRtagcataBggactaacacRctK
+gttaatcctHgDgttKHHagttgttaatgHBtatHcDaagtVaBaRccctVgtgDtacRH
+SctaagagcggWYaBtSaKtHBtaaactYacgNKBaVYgtaacttagtVttcttaatgtB
+tatMtMtttaattaatBWccatRtttcatagVgMMtagctStKctaMactacDNYgKYHg
+aWcgaHgagattacVgtttgtRaSttaWaVgataatgtgtYtaStattattMtNgWtgtt
+KaccaatagNYttattcgtatHcWtctaaaNVYKKttWtggcDtcgaagtNcagatacgc
+attaagaccWctgcagcttggNSgaNcHggatgtVtcatNtRaaBNcHVagagaaBtaaS
+ggDaatWaatRccaVgggStctDaacataKttKatttggacYtattcSatcttagcaatg
+aVBMcttDattctYaaRgatgcattttNgVHtKcYRaatRKctgtaaacRatVSagctgt
+WacBtKVatctgttttKcgtctaaDcaagtatcSataWVgcKKataWaYttcccSaatga
+aaacccWgcRctWatNcWtBRttYaattataaNgacacaatagtttVNtataNaYtaatR
+aVWKtBatKagtaatataDaNaaaaataMtaagaaStccBcaatNgaataWtHaNactgt
+cDtRcYaaVaaaaaDgtttRatctatgHtgttKtgaaNSgatactttcgagWaaatctKa
+aDaRttgtggKKagcDgataaattgSaacWaVtaNMacKtcaDaaatttctRaaVcagNa
+caScRBatatctRatcctaNatWgRtcDcSaWSgttRtKaRtMtKaatgttBHcYaaBtg
+atSgaSWaScMgatNtctcctatttctYtatMatMtRRtSaattaMtagaaaaStcgVgR
+ttSVaScagtgDtttatcatcatacRcatatDcttatcatVRtttataaHtattcYtcaa
+aatactttgVctagtaaYttagatagtSYacKaaacgaaKtaaatagataatSatatgaa
+atSgKtaatVtttatcctgKHaatHattagaaccgtYaaHactRcggSBNgtgctaaBag
+BttgtRttaaattYtVRaaaattgtaatVatttctcttcatgBcVgtgKgaHaaatattY
+atagWacNctgaaMcgaattStagWaSgtaaKagttttaagaDgatKcctgtaHtcatgg
+KttVDatcaaggtYcgccagNgtgcVttttagagatgctaccacggggtNttttaSHaNt
+atNcctcatSaaVgtactgBHtagcaYggYVKNgtaKBcRttgaWatgaatVtagtcgat
+tYgatgtaatttacDacSctgctaaaStttaWMagDaaatcaVYctccgggcgaVtaaWt
+StaKMgDtttcaaMtVgBaatccagNaaatcYRMBggttWtaaScKttMWtYataRaDBM
+aDataatHBcacDaaKDactaMgagttDattaHatHtaYatDtattDcRNStgaatattS
+DttggtattaaNSYacttcDMgYgBatWtaMagactVWttctttgYMaYaacRgHWaatt
+gRtaagcattctMKVStatactacHVtatgatcBtVNataaBttYtSttacKgggWgYDt
+gaVtYgatDaacattYgatggtRDaVDttNactaSaMtgNttaacaaSaBStcDctacca
+cagacgcaHatMataWKYtaYattMcaMtgSttDagcHacgatcaHttYaKHggagttcc
+gatYcaatgatRaVRcaagatcagtatggScctatattaNtagcgacgtgKaaWaactSg
+agtMYtcttccaKtStaacggMtaagNttattatcgtctaRcactctctDtaacWYtgaY
+aSaagaWtNtatttRacatgNaatgttattgWDDcNaHcctgaaHacSgaataaRaataM
+HttatMtgaSDSKatatHHaNtacagtccaYatWtcactaactatKDacSaStcggataH
+gYatagKtaatKagStaNgtatactatggRHacttgtattatgtDVagDVaRctacMYat
+tDgtttYgtctatggtKaRSttRccRtaaccttagagRatagSaaMaacgcaNtatgaaa
+tcaRaagataatagatactcHaaYKBctccaagaRaBaStNagataggcgaatgaMtaga
+atgtcaKttaaatgtaWcaBttaatRcggtgNcacaaKtttScRtWtgcatagtttWYaa
+gBttDKgcctttatMggNttattBtctagVtacataaaYttacacaaRttcYtWttgHca
+YYtaMgBaBatctNgcDtNttacgacDcgataaSatYaSttWtcctatKaatgcagHaVa
+acgctgcatDtgttaSataaaaYSNttatagtaNYtaDaaaNtggggacttaBggcHgcg
+tNtaaMcctggtVtaKcgNacNtatVaSWctWtgaWcggNaBagctctgaYataMgaaga
+tBSttctatacttgtgtKtaattttRagtDtacatatatatgatNHVgBMtKtaKaNttD
+HaagatactHaccHtcatttaaagttVaMcNgHatatKtaNtgYMccttatcaaNagctg
+gacStttcNtggcaVtattactHaSttatgNMVattMMDtMactattattgWMSgtHBtt
+StStgatatRaDaagattttctatMtaaaaaggtactaaVttaSacNaatactgMttgac
+HaHRttgMacaaaatagttaatatWKRgacDgaRtatatttattatcYttaWtgtBRtWa
+tgHaaattHataagtVaDtWaVaWtgStcgtMSgaSRgMKtaaataVacataatgtaSaa
+tttagtcgaaHtaKaatgcacatcggRaggSKctDcagtcSttcccStYtccRtctctYt
+caaKcgagtaMttttcRaYDttgttatctaatcataNctctgctatcaMatactataggD
+aHaaSttMtaDtcNatataattctMcStaaBYtaNagatgtaatHagagSttgWHVctta
+tKaYgDctcttggtgttMcRaVgSgggtagacaataaDtaattSaDaNaHaBctattgNt
+accaaRgaVtKNtaaYggHtaKKgHcatctWtctDtttctttggSDtNtaStagttataa
+acaattgcaBaBWggHgcaaaBtYgctaatgaaatWcDcttHtcMtWWattBHatcatca
+aatctKMagtDNatttWaBtHaaaNgMttaaStagttctctaatDtcRVaYttgttMtRt
+gtcaSaaYVgSWDRtaatagctcagDgcWWaaaBaaRaBctgVgggNgDWStNaNBKcBc
+taaKtttDcttBaaggBttgaccatgaaaNgttttttttatctatgttataccaaDRaaS
+agtaVtDtcaWatBtacattaWacttaSgtattggDgKaaatScaattacgWcagKHaac
+caYcRcaRttaDttRtttHgaHVggcttBaRgtccctDatKaVtKtcRgYtaKttacgta
+tBtStaagcaattaagaRgBagSaattccSWYtttattVaataNctgHgttaaNBgcVYg
+tRtcccagWNaaaacaDNaBcaaaaRVtcWMgBagMtttattacgDacttBtactatcat
+tggaaatVccggttRttcatagttVYcatYaSHaHcttaaagcNWaHataaaRWtctVtR
+YtagHtaaaYMataHYtNBctNtKaatattStgaMcBtRgctaKtgcScSttDgYatcVt
+ggaaKtaagatWccHccgKYctaNNctacaWcttttgcRtgtVcgaKttcMRHgctaHtV
+aataaDtatgKDcttatBtDttggNtacttttMtgaacRattaaNagaactcaaaBBVtc
+DtcgaStaDctgaaaSgttMaDtcgttcaccaaaaggWtcKcgSMtcDtatgtttStaaB
+tatagDcatYatWtaaaBacaKgcaDatgRggaaYctaRtccagattDaWtttggacBaV
+cHtHtaacDacYgtaatataMagaatgHMatcttatacgtatttttatattacHactgtt
+ataMgStYaattYaccaattgagtcaaattaYtgtatcatgMcaDcgggtcttDtKgcat
+gWRtataatatRacacNRBttcHtBgcRttgtgcgtcatacMtttBctatctBaatcatt
+MttMYgattaaVYatgDaatVagtattDacaacDMatcMtHcccataagatgBggaccat
+tVWtRtSacatgctcaaggggYtttDtaaNgNtaaBatggaatgtctRtaBgBtcNYata
+tNRtagaacMgagSaSDDSaDcctRagtVWSHtVSRggaacaBVaccgtttaStagaaca
+MtactccagtttVctaaRaaHttNcttagcaatttattaatRtaaaatctaacDaBttgg
+SagagctacHtaaRWgattcaaBtctRtSHaNtgtacattVcaHaNaagtataccacaWt
+aRtaaVKgMYaWgttaKggKMtKcgWatcaDatYtKSttgtacgaccNctSaattcDcat
+cttcaaaDKttacHtggttHggRRaRcaWacaMtBWVHSHgaaMcKattgtaRWttScNa
+ttBBatYtaNRgcggaagacHSaattRtttcYgaccBRccMacccKgatgaacttcgDgH
+caaaaaRtatatDtatYVtttttHgSHaSaatagctNYtaHYaVYttattNtttgaaaYt
+aKttWtctaNtgagaaaNctNDctaaHgttagDcRttatagccBaacgcaRBtRctRtgg
+taMYYttWtgataatcgaataattattataVaaaaattacNRVYcaaMacNatRttcKat
+MctgaagactaattataaYgcKcaSYaatMNctcaacgtgatttttBacNtgatDccaat
+tattKWWcattttatatatgatBcDtaaaagttgaaVtaHtaHHtBtataRBgtgDtaat
+aMttRtDgDcttattNtggtctatctaaBcatctaRatgNacWtaatgaagtcMNaacNg
+HttatactaWgcNtaStaRgttaaHacccgaYStacaaaatWggaYaWgaattattcMaa
+ctcBKaaaRVNcaNRDcYcgaBctKaacaaaaaSgctccYBBHYaVagaatagaaaacag
+YtctVccaMtcgtttVatcaatttDRtgWctagtacRttMctgtDctttcKtWttttata
+aatgVttgBKtgtKWDaWagMtaaagaaattDVtaggttacatcatttatgtcgMHaVct
+taBtVRtcgtaYgBRHatttHgaBcKaYWaatcNSctagtaaaaatttacaatcactSWa
+cgtaatgKttWattagttttNaggtctcaagtcactattcttctaagKggaataMgtttc
+ataagataaaaatagattatDgcBVHWgaBKttDgcatRHaagcaYcRaattattatgtM
+atatattgHDtcaDtcaaaHctStattaatHaccgacNattgatatattttgtgtDtRat
+agSacaMtcRtcattcccgacacSattgttKaWattNHcaacttccgtttSRtgtctgDc
+gctcaaMagVtBctBMcMcWtgtaacgactctcttRggRKSttgYtYatDccagttDgaK
+ccacgVatWcataVaaagaataMgtgataaKYaaatcHDaacgataYctRtcYatcgcaM
+gtNttaBttttgatttaRtStgcaacaaaataccVgaaDgtVgDcStctatatttattaa
+aaRKDatagaaagaKaaYYcaYSgKStctccSttacagtcNactttDVttagaaagMHtt
+RaNcSaRaMgBttattggtttaRMggatggcKDgWRtNaataataWKKacttcKWaaagN
+aBttaBatMHtccattaacttccccYtcBcYRtagattaagctaaYBDttaNtgaaaccH
+caRMtKtaaHMcNBttaNaNcVcgVttWNtDaBatgataaVtcWKcttRggWatcattga
+RagHgaattNtatttctctattaattaatgaDaaMatacgttgggcHaYVaaNaDDttHt
+caaHtcVVDgBVagcMacgtgttaaBRNtatRtcagtaagaggtttaagacaVaaggtta
+WatctccgtVtaDtcDatttccVatgtacNtttccgtHttatKgScBatgtVgHtYcWag
+caKtaMYaaHgtaattaSaHcgcagtWNaatNccNNYcacgVaagaRacttctcattccc
+RtgtgtaattagcSttaaStWaMtctNNcSMacattataaactaDgtatWgtagtttaag
+aaaattgtagtNagtcaataaatttgatMMYactaatatcggBWDtVcYttcDHtVttat
+acYaRgaMaacaStaatcRttttVtagaDtcacWatttWtgaaaagaaagNRacDtttSt
+VatBaDNtaactatatcBSMcccaSttccggaMatgattaaWatKMaBaBatttgataNc
+tgttKtVaagtcagScgaaaDggaWgtgttttKtWtatttHaatgtagttcactaaKMag
+ttSYBtKtaYgaactcagagRtatagtVtatcaaaWYagcgNtaDagtacNSaaYDgatB
+gtcgataacYDtaaactacagWDcYKaagtttattagcatcgagttKcatDaattgatta
+tDtcagRtWSKtcgNtMaaaaacaMttKcaWcaaSVMaaaccagMVtaMaDtMaHaBgaa
+cataBBVtaatVYaNSWcSgNtDNaaKacacBtttatKtgtttcaaHaMctcagtaacgt
+cgYtactDcgcctaNgagagcYgatattttaaatttccattttacatttDaaRctatttt
+WctttacgtDatYtttcagacgcaaVttagtaaKaaaRtgVtccataBggacttatttgt
+ttaWNtgttVWtaWNVDaattgtatttBaagcBtaaBttaaVatcHcaVgacattccNgg
+tcgacKttaaaRtagRtctWagaYggtgMtataatMtgaaRttattttgWcttNtDRRgM
+DKacagaaaaggaaaRStcccagtYccVattaNaaKStNWtgacaVtagaagcttSaaDt
+cacaacgDYacWDYtgtttKatcVtgcMaDaSKStVcgtagaaWaKaagtttcHaHgMgM
+tctataagBtKaaaKKcactggagRRttaagaBaaNatVVcgRcKSttDaactagtSttS
+attgttgaaRYatggttVttaataaHttccaagDtgatNWtaagHtgcYtaactRgcaat
+gMgtgtRaatRaNaacHKtagactactggaatttcgccataacgMctRgatgttacccta
+HgtgWaYcactcacYaattcttaBtgacttaaacctgYgaWatgBttcttVttcgttWtt
+McNYgtaaaatctYgMgaaattacNgaHgaacDVVMtttggtHtctaaRgtacagacgHt
+VtaBMNBgattagcttaRcttacaHcRctgttcaaDBggttKaacatgKtttYataVaNa
+ttccgMcgcgtagtRaVVaattaKaatggttRgaMcagtatcWBttNtHagctaatctag
+aaNaaacaYBctatcgcVctBtgcaaagDgttVtgaHtactSNYtaaNccatgtgDacga
+VtDcgKaRtacDcttgctaagggcagMDagggtBWRtttSgccttttttaacgtcHctaV
+tVDtagatcaNMaVtcVacatHctDWNaataRgcgtaVHaggtaaaaSgtttMtattDgB
+tctgatSgtRagagYtctSaKWaataMgattRKtaacatttYcgtaacacattRWtBtcg
+gtaaatMtaaacBatttctKagtcDtttgcBtKYYBaKttctVttgttaDtgattttctt
+ccacttgSaaacggaaaNDaattcYNNaWcgaaYattttMgcBtcatRtgtaaagatgaW
+tgaccaYBHgaatagataVVtHtttVgYBtMctaMtcctgaDcYttgtccaaaRNtacag
+cMctKaaaggatttacatgtttaaWSaYaKttBtagDacactagctMtttNaKtctttcN
+cSattNacttggaacaatDagtattRtgSHaataatgccVgacccgatactatccctgtR
+ctttgagaSgatcatatcgDcagWaaHSgctYYWtatHttggttctttatVattatcgac
+taagtgtagcatVgtgHMtttgtttcgttaKattcMatttgtttWcaaStNatgtHcaaa
+DtaagBaKBtRgaBgDtSagtatMtaacYaatYtVcKatgtgcaacVaaaatactKcRgt
+aYtgtNgBBNcKtcttaccttKgaRaYcaNKtactttgagSBtgtRagaNgcaaaNcaca
+gtVtttHWatgttaNatBgtttaatNgVtctgaatatcaRtattcttttttttRaaKcRS
+tctcggDgKagattaMaaaKtcaHacttaataataKtaRgDtKVBttttcgtKaggHHca
+tgttagHggttNctcgtatKKagVagRaaaggaaBtNatttVKcRttaHctaHtcaaatg
+taggHccaBataNaNaggttgcWaatctgatYcaaaHaatWtaVgaaBttagtaagaKKt
+aaaKtRHatMaDBtBctagcatWtatttgWttVaaaScMNattRactttgtYtttaaaag
+taagtMtaMaSttMBtatgaBtttaKtgaatgagYgtNNacMtcNRacMMHcttWtgtRt
+ctttaacaacattattcYaMagBaacYttMatcttKcRMtgMNccattaRttNatHaHNa
+SaaHMacacaVaatacaKaSttHatattMtVatWgattttttaYctttKttHgScWaacg
+HtttcaVaaMgaacagNatcgttaacaaaaagtacaHBNaattgttKtcttVttaaBtct
+gctacgBgcWtttcaggacacatMgacatcccagcggMgaVKaBattgacttaatgacac
+acaaaaaatRKaaBctacgtRaDcgtagcVBaacDSBHaaaaSacatatacagacRNatc
+ttNaaVtaaaataHattagtaaaaSWccgtatWatggDttaactattgcccatcttHaSg
+YataBttBaactattBtcHtgatcaataSttaBtatKSHYttWggtcYtttBttaatacc
+RgVatStaHaKagaatNtagRMNgtcttYaaSaactcagDSgagaaYtMttDtMRVgWKW
+tgMaKtKaDttttgactatacataatcNtatNaHattVagacgYgatatatttttgtStW
+aaatctWaMgagaRttRatacgStgattcttaagaDtaWccaaatRcagcagaaNKagta
+aDggcgccBtYtagSBMtactaaataMataBSacRMgDgattMMgtcHtcaYDtRaDaac
+ggttDaggcMtttatgttaNctaattaVacgaaMMtaatDccSgtattgaRtWWaccacc
+gagtactMcgVNgctDctaMScatagcgtcaactatacRacgHRttgctatttaatgaat
+tataYKttgtaagWgtYttgcHgMtaMattWaWVtaRgcttgYgttBHtYataSccStBt
+gtagMgtDtggcVaaSBaatagDttgBgtctttctcattttaNagtHKtaMWcYactVcg
+cgtatMVtttRacVagDaatcttgctBBcRDgcaacKttgatSKtYtagBMagaRtcgBa
+ttHcBWcaactgatttaatttWDccatttatcgagSKaWttataHactaHMttaatHtgg
+aHtHagaatgtKtaaRactgtttMatacgatcaagDgatKaDctataMggtHDtggHacc
+tttRtatcttYattttgacttgaaSaataaatYcgBaaaaccgNatVBttMacHaKaata
+agtatKgtcaagactcttaHttcggaattgttDtctaaccHttttWaaatgaaatataaa
+WattccYDtKtaaaacggtgaggWVtctattagtgactattaagtMgtttaagcatttgS
+gaaatatccHaaggMaaaattttcWtatKctagDtYtMcctagagHcactttactataca
+aacattaacttaHatcVMYattYgVgtMttaaRtgaaataaDatcaHgtHHatKcDYaat
+cttMtNcgatYatgSaMaNtcttKcWataScKggtatcttacgcttWaaagNatgMgHtc
+tttNtaacVtgttcMaaRatccggggactcMtttaYMtcWRgNctgNccKatcttgYDcM
+gattNYaRagatHaaHgKctcataRDttacatBatccattgDWttatttaWgtcggagaa
+aaatacaatacSNtgggtttccttacSMaagBattacaMaNcactMttatgaRBacYcYt
+caaaWtagctSaacttWgDMHgaggatgBVgcHaDtggaactttggtcNatNgtaKaBcc
+caNtaagttBaacagtatacDYttcctNgWgcgSMcacatStctHatgRcNcgtacacaa
+tRttMggaNKKggataaaSaYcMVcMgtaMaHtgattYMatYcggtcttcctHtcDccgt
+gRatcattgcgccgatatMaaYaataaYSggatagcgcBtNtaaaScaKgttBgagVagt
+taKagagtatVaactaSacWactSaKatWccaKaaaatBKgaaKtDMattttgtaaatcR
+ctMatcaaMagMttDgVatggMaaWgttcgaWatgaaatttgRtYtattaWHKcRgctac
+atKttctaccaaHttRatctaYattaaWatVNccatNgagtcKttKataStRaatatatt
+cctRWatDctVagttYDgSBaatYgttttgtVaatttaatagcagMatRaacttBctatt
+gtMagagattaaactaMatVtHtaaatctRgaaaaaaaatttWacaacaYccYDSaattM
+atgaccKtaBKWBattgtcaagcHKaagttMMtaatttcKcMagNaaKagattggMagag
+gtaatttYacatcWaaDgatMgKHacMacgcVaacaDtaDatatYggttBcgtatgWgaS
+atttgtagaHYRVacaRtctHaaRtatgaactaatatctSSBgggaaHMWtcaagatKga
+gtDaSatagttgattVRatNtctMtcSaagaSHaataNataataRaaRgattctttaata
+aagWaRHcYgcatgtWRcttgaaggaMcaataBRaaccagStaaacNtttcaatataYta
+atatgHaDgcStcWttaacctaRgtYaRtataKtgMttttatgactaaaatttacYatcc
+cRWtttHRtattaaatgtttatatttgttYaatMcaRcSVaaDatcgtaYMcatgtagac
+atgaaattgRtcaaYaaYtRBatKacttataccaNaaattVaBtctggacaagKaaYaaa
+tatWtMtatcYaaVNtcgHaactBaagKcHgtctacaatWtaDtSgtaHcataHtactga
+taNctRgttMtDcDttatHtcgtacatcccaggSttaBgtcacacWtccNMcNatMVaVg
+tccDYStatMaccDatggYaRKaaagataRatttHKtSaaatDgataaacttaHgttgVB
+tcttVttHgDacgaKatgtatatNYataactctSatatatattgcHRRYttStggaactH
+gttttYtttaWtatMcttttctatctDtagVHYgMRBgtHttcctaatYRttKtaagatg
+gaVRataKDctaMtKBNtMtHNtWtttYcVtattMcgRaacMcctNSctcatttaaagDc
+aHtYccSgatgcaatYaaaaDcttcgtaWtaattctcgttttScttggtaatctttYgtc
+taactKataHacctMctcttacHtKataacacagcNRatgKatttttSaaatRYcgDtta
+MRcgaaattactMtgcgtaagcgttatBtttttaattaagtNacatHgttcRgacKcBBt
+VgatKttcgaBaatactDRgtRtgaNacWtcacYttaaKcgttctHaKttaNaMgWgWag
+gtctRgaKgWttSttBtDcNtgtttacaaatYcDRtgVtgcctattcNtctaaaDMNttt
+tNtggctgagaVctDaacVtWccaagtaacacaNctgaScattccDHcVBatcgatgtMt
+aatBgHaatDctMYgagaatgYWKcctaatNaStHaaaKccgHgcgtYaaYtattgtStg
+tgcaaRtattaKatattagaWVtcaMtBagttattagNaWHcVgcaattttDcMtgtaRH
+VYtHtctgtaaaaHVtMKacatcgNaatttMatatgttgttactagWYtaRacgataKag
+YNKcattataNaRtgaacKaYgcaaYYacaNccHatMatDcNgtHttRaWttagaaDcaa
+aaaatagggtKDtStaDaRtaVtHWKNtgtattVctSVgRgataDaRaWataBgaagaaK
+taataaYgDcaStaNgtaDaaggtattHaRaWMYaYaWtggttHYgagVtgtgcttttca
+aDKcagVcgttagacNaaWtagtaataDttctggttVcatcataaagtgKaaaNaMtaBB
+aattaatWaattgctHaVKaSgDaaVKaHtatatatHatcatSBagNgHtatcHYMHgtt
+DgtaHtBttWatcgtttaRaattgStKgSKNWKatcagDtctcagatttctRtYtBatBg
+HHtKaWtgYBgacVVWaKtacKcDttKMaKaVcggtgttataagaataaHaatattagta
+taatMHgttYgaRttagtaRtcaaVatacggtcMcgagtaaRttacWgactKRYataaaa
+gSattYaWgagatYagKagatgSaagKgttaatMggtataatgttWYttatgagaaacct
+NVataatHcccKtDctcctaatactggctHggaSaggRtKHaWaattcgSatMatttaga
+ggcYtctaMcgctcataSatatgRagacNaaDaggaVBagaYttKtacNaKgtSYtagtt
+ggaWcatcWttaatctatgaVtcgtgtMtatcaYcgtRccaaYgDctgcMgtgtWgacWt
+gataacacgcgctBtgttaKtYDtatDcatcagKaVMctaatcttgVcaaRgcRMtDcga
+ttaHttcaNatgaatMtactacVgtRgatggaWtttactaaKatgagSaaKggtaNtact
+VaYtaaKRagaacccacaMtaaMtKtatBcttgtaaWBtMctaataaVcDaaYtcRHBtc
+gttNtaaHatttBNgRStVDattBatVtaagttaYatVattaagaBcacggtSgtVtatt
+taRattgatgtaHDKgcaatattKtggcctatgaWDKRYcggattgRctatNgatacaat
+MNttctgtcRBYRaaaHctNYattcHtaWcaattctBtMKtVgYataatMgYtcagcttM
+DataVtggRtKtgaatgccNcRttcaMtRgattaacattRcagcctHtWMtgtDRagaKa
+BtgDttYaaaaKatKgatctVaaYaacWcgcatagBVtaNtRtYRaggBaaBtgKgttac
+ataagagcatgtRattccacttaccatRaaatgWgDaMHaYVgVtaSctatcgKaatata
+ttaDgacccYagtgtaYNaaatKcagtBRgagtccatgKgaaaccBgaagBtgSttWtac
+gatWHaYatcgatttRaaNRgcaNaKVacaNtDgattgHVaatcDaagcgtatgcNttaD
+ataatcSataaKcaataaHWataBtttatBtcaKtKtatagttaDgSaYctacaRatNta
+WctSaatatttYaKaKtaccWtatcRagacttaYttVcKgSDcgagaagatccHtaattc
+tSttatggtKYgtMaHagVaBRatttctgtRgtctatgggtaHKgtHacHtSYacgtaca
+cHatacKaaBaVaccaDtatcSaataaHaagagaatScagactataaRttagcaaVcaHa
+taKgDacatWccccaagcaBgagWatctaYttgaaatctVNcYtttWagHcgcgcDcVaa
+atgttKcHtNtcaatagtgtNRaactttttcaatggWgBcgDtgVgtttctacMtaaata
+aaRggaaacWaHttaRtNtgctaaRRtVBctYtVtatDcattDtgaccYatagatYRKat
+NYKttNgcctagtaWtgaactaMVaacctgaStttctgaKVtaaVaRKDttVtVctaDNt
+ataaaDtccccaagtWtcgatcactDgYaBcatcctMtVtacDaaBtYtMaKNatNtcaN
+acgDatYcatcgcaRatWBgaacWttKttagYtaattcggttgSWttttDWctttacYta
+tatWtcatDtMgtBttgRtVDggttaacYtacgtacatgaattgaaWcttMStaDgtata
+ttgaDtcRBcattSgaaVBRgagccaaKtttcDgcgaSMtatgWattaKttWtgDBMagg
+BBttBaatWttRtgcNtHcgttttHtKtcWtagHStaacagttgatatBtaWSaWggtaa
+taaMttaKacDaatactcBttcaatatHttcBaaSaaatYggtaRtatNtHcaatcaHta
+gVtgtattataNggaMtcttHtNagctaaaggtagaYctMattNaMVNtcKtactBKcaH
+HcBttaSagaKacataYgctaKaYgttYcgacWVttWtSagcaacatcccHaccKtctta
+acgaKttcacKtNtacHtatatRtaaatacactaBtttgaHaRttggttWtatYagcatY
+DatcggagagcWBataagRtacctataRKgtBgatgaDatataSttagBaHtaatNtaDW
+cWtgtaattacagKttcNtMagtattaNgtctcgtcctcttBaHaKcKccgtRcaaYagS
+attaagtKataDatatatagtcDtaacaWHcaKttDgaaRcgtgYttgtcatatNtattt
+ttatggccHtgDtYHtWgttatYaacaattcaWtatNgctcaaaSttRgctaatcaaatN
+atcgtttaBtNNVtgttataagcaaagattBacgtDatttNatttaaaDcBgtaSKgacg
+tagataatttcHMVNttgttBtDtgtaWKaaRMcKMtHtaVtagataWctccNNaSWtVa
+HatctcMgggDgtNHtDaDttatatVWttgttatttaacctttcacaaggaSaDcggttt
+tttatatVtctgVtaacaStDVaKactaMtttaSNagtgaaattaNacttSKctattcct
+ctaSagKcaVttaagNaVcttaVaaRNaHaaHttatgtHttgtgatMccaggtaDcgacc
+gtWgtWMtttaHcRtattgScctatttKtaaccaagtYagaHgtWcHaatgccKNRttta
+gtMYSgaDatctgtgaWDtccMNcgHgcaaacNDaaaRaStDWtcaaaaHKtaNBctagB
+tgtattaactaattttVctagaatggcWSatMacccttHttaSgSgtgMRcatRVKtatc
+tgaaaccDNatYgaaVHNgatMgHRtacttaaaRtatStRtDtatDttYatattHggaBc
+ttHgcgattgaKcKtttcRataMtcgaVttWacatNcatacctRataDDatVaWNcggtt
+gaHtgtMacVtttaBHtgagVttMaataattatgttcttagtttgtgcDtSatttgBtca
+acHattaaBagVWcgcaSYttMgcttacYKtVtatcaYaKctgBatgcgggcYcaaaaac
+gNtctagKBtattatctttKtaVttatagtaYtRagNtaYataaVtgaatatcHgcaaRa
+taHtacacatgtaNtgtcgYatWMatttgaactacRctaWtWtatacaatctBatatgYt
+aagtatgtgtatSttactVatcttYtaBcKgRaSggRaaaaatgcagtaaaWgtaRgcga
+taatcBaataccgtatttttccatcNHtatWYgatHSaaaDHttgctgtccHtggggcct
+aataatttttctatattYWtcattBtgBRcVttaVMRSgctaatMagtYtttaaaaatBR
+tcBttcaaVtaacagctccSaaSttKNtHtKYcagcagaaaccccRtttttaaDcDtaSt
+atccaagcgctHtatcttaDRYgatDHtWcaaaBcWgKWHttHataagHacgMNKttMKH
+ccaYcatMVaacgttaKgYcaVaaBtacgcaactttMctaaHaatgtBatgagaSatgta
+tgSRgHgWaVWgataaatatttccKagVgataattWaHNcYggaaatgctHtKtaDtcta
+aagtMaatVDVactWtSaaWaaMtaHtaSKtcBRaNcttStggtBttacNagcatagRgt
+KtgcgaacaacBcgKaatgataagatgaaaattgtactgcgggtccHHWHaaNacaBttN
+KtKtcaaBatatgctaHNgtKcDWgtttatNgVDHgaccaacWctKaaggHttgaRgYaa
+tHcaBacaatgagcaaattactgtaVaaYaDtagattgagNKggtggtgKtWKaatacag
+DRtatRaMRtgattDggtcaaYRtatttNtagaDtcacaaSDctDtataatcgtactaHt
+tatacaatYaacaaHttHatHtgcgatRRttNgcatSVtacWWgaaggagtatVMaVaaa
+ttScDDKNcaYBYaDatHgtctatBagcaacaagaatgagaaRcataaKNaRtBDatcaa
+acgcattttttaaBtcSgtacaRggatgtMNaattggatatWtgagtattaaaVctgcaY
+MtatgatttttYgaHtgtcttaagWBttHttgtcttattDtcgtatWtataataSgctaH
+agcDVcNtaatcaagtaBDaWaDgtttagYctaNccDtaKtaHcttaataacccaRKtac
+aVaatNgcWRaMgaattatgaBaaagattVYaHMDcaDHtcRcgYtcttaaaWaaaVKga
+tacRtttRRKYgaatacaWVacVcRtatMacaBtactggMataaattttHggNagSctac
+HgtBagcgtcgtgattNtttgatSaaggMttctttcttNtYNagBtaaacaaatttMgac
+cttacataattgYtcgacBtVMctgStgMDtagtaRctHtatgttcatatVRNWataDKa
+tWcgaaaaagttaaaagcacgHNacgtaatctttMRtgacttttDacctataaacgaaat
+atgattagaactccSYtaBctttaataacWgaaaYatagatgWttcatKtNgatttttca
+agHtaYgaaRaDaagtaggagcttatVtagtctttcattaaaatcgKtattaRttacagV
+aDatgcatVgattgggtctttHVtagKaaRBtaHtaaggccccaaaaKatggtttaMWgt
+BtaaacttcactttKHtcgatctccctaYaBacMgtcttBaBaNgcgaaacaatctagtH
+ccHtKttcRtRVttccVctttcatacYagMVtMcagaMaaacaataBctgYtaatRaaag
+attaaccatVRatHtaRagcgcaBcgDttStttttcVtttaDtKgcaaWaaaaatSccMc
+VatgtKgtaKgcgatatgtagtSaaaDttatacaaacatYaRRcVRHctKtcgacKttaa
+VctaDaatgttMggRcWaacttttHaDaKaDaBctgtaggcgtttaHBccatccattcNH
+tDaYtaataMttacggctNVaacDattgatattttacVttSaattacaaRtataNDgacV
+tgaacataVRttttaDtcaaacataYDBtttaatBaDtttYDaDaMccMttNBttatatg
+agaaMgaNtattHccNataattcaHagtgaaggDgatgtatatatgYatgaStcataaBS
+tWacgtcccataRMaaDattggttaaattcMKtctMacaBSactcggaatDDgatDgcWc
+taacaccgggaVcacWKVacggtaNatatacctMtatgatagtgcaKagggVaDtgtaac
+ttggagtcKatatcgMcttRaMagcattaBRaStctYSggaHYtacaactMBaagDcaBD
+RaaacMYacaHaattagcattaaaHgcgctaaggSccKtgaaKtNaBtatDDcKBSaVtg
+atVYaagVtctSgMctacgttaacWaaattctSgtDactaaStaaattgcagBBRVctaa
+tatacctNttMcRggctttMttagacRaHcaBaacVKgaataHttttMgYgattcYaNRg
+ttMgcVaaacaVVcDHaatttgKtMYgtatBtVVctWgVtatHtacaaHttcacgatagc
+agtaaNattBatatatttcVgaDagcggttMaagtcScHagaaatgcYNggcgtttttMt
+StggtRatctacttaaatVVtBacttHNttttaRcaaatcacagHgagagtMgatcSWaN
+RacagDtatactaaDKaSRtgattctccatSaaRttaaYctacacNtaRtaactggatga
+ccYtacactttaattaattgattYgttcagDtNKttagDttaaaaaaaBtttaaNaYWKM
+BaaaacVcBMtatWtgBatatgaacVtattMtYatMNYDKNcKgDttDaVtaaaatggga
+tttctgtaaatWtctcWgtVVagtcgRgacttcccctaDcacagcRcagagtgtWSatgt
+acatgttaaSttgtaaHcgatgggMagtgaacttatRtttaVcaccaWaMgtactaatSS
+aHtcMgaaYtatcgaaggYgggcgtgaNDtgttMNgaNDMtaattcgVttttaacatgVa
+tgtWVMatatcaKgaaattcaBcctccWcttgaaWHtWgHtcgNWgaRgctcBgSgaatt
+gcaaHtgattgtgNagtDttHHgBttaaWcaaWagcaSaHHtaaaVctRaaMagtaDaat
+HtDMtcVaWMtagSagcttHSattaacaaagtRacMtRtctgttagcMtcaBatVKtKtK
+acgagaSNatSactgtatatcBctgagVtYactgtaaattaaaggcYgDHgtaacatSRD
+atMMccHatKgttaacgactKtgKagtcttcaaHRVtccttKgtSataatttacaactgg
+atDNgaacttcaRtVaagDcaWatcBctctHYatHaDaaatttagYatSatccaWtttag
+aaatVaacBatHcatcgtacaatatcgcNYRcaataYaRaYtgattVttgaatgaVaact
+cRcaNStgtgtattMtgaggtNttBaDRcgaaaagctNgBcWaWgtSaDcVtgVaatMKB
+tttcgtttctaaHctaaagYactgMtatBDtcStgaccgtSDattYaataHctgggaYYt
+tcggttaWaatctggtRagWMaDagtaacBccactacgHWMKaatgatWatcctgHcaBa
+SctVtcMtgtDttacctaVgatYcWaDRaaaaRtagatcgaMagtggaRaWctctgMgcW
+ttaagKBRtaaDaaWtctgtaagYMttactaHtaatcttcataacggcacBtSgcgttNH
+tgtHccatgttttaaagtatcgaKtMttVcataYBBaKtaMVaVgtattNDSataHcagt
+WMtaggtaSaaKgttgBtVtttgttatcatKcgHacacRtctHatNVagSBgatgHtgaR
+aSgttRcctaacaaattDNttgacctaaYtBgaaaatagttattactcttttgatgtNNt
+VtgtatMgtcttRttcatttgatgacacttcHSaaaccaWWDtWagtaRDDVNacVaRat
+gttBccttaatHtgtaaacStcVNtcacaSRttcYagacagaMMttttgMcNttBcgWBt
+actgVtaRttctccaaYHBtaaagaBattaYacgatttacatctgtaaMKaRYtttttac
+taaVatWgctBtttDVttctggcDaHaggDaagtcgaWcaagtagtWttHtgKtVataSt
+ccaMcWcaagataagatcactctHatgtcYgaKcatcagatactaagNSStHcctRRNta
+ttgtccttagttagMVgtatagactaactctVcaatMctgtttgtgttgccttatWgtaB
+VtttctggMcaaKgDWtcgtaaYStgSactatttHgatctgKagtagBtVacRaagRtMc
+tatgggcaaaKaaaatacttcHctaRtgtDcttDattaggaaatttcYHaRaaBttaatg
+gcacKtgctHVcaDcaaaVDaaaVcgMttgtNagcgtaDWgtcgttaatDgKgagcSata
+tcSHtagtagttggtgtHaWtaHKtatagctgtVgattaBVaatgaataagtaatVatSt
+taHctttKtttgtagttaccttaatcgtagtcctgBcgactatttVcMacHaaaggaatg
+DatggKtaHtgStatattaaSagctWcctccRtataBaDYcgttgcNaagaggatRaaaY
+taWgNtSMcaatttactaacatttaaWttHtatBattgtcgacaatNgattgcNgtMaaa
+KaBDattHacttggtRtttaYaacgVactBtaBaKtgBttatgVttgtVttcaatcWcNc
+tDBaaBgaDHacBttattNtgtDtatttVSaaacaggatgcRatSgtaSaNtgBatagtt
+cHBgcBBaaattaHgtDattatDaKaatBaaYaaMaataaataKtttYtagtBgMatNca
+tgtttgaNagtgttgtgKaNaSagtttgaSMaYBcaaaacDStagttVacaaaaactaaW
+ttBaagtctgtgcgtMgtaattctcctacctcaNtttaaccaaaaVtBcacataacaccc
+cBcWMtatVtggaatgaWtcaaWaaaaaaaaWtDtaatatRcctDWtcctaccMtVVatK
+ttaWaaKaaatataaagScHBagaggBaSMtaWaVtatattactSaaaKNaactatNatc
+cttgaYctattcaaaVgatttYHcRagattttaSataggttattcVtaaagaKgtattat
+tKtRttNcggcRgtgtgtWYtaacHgKatKgatYtacYagDtWcHBDctctgRaYKaYag
+cactKcacSaRtBttttBHKcMtNtcBatttatttttgSatVgaaagaWtcDtagDatat
+gMacaacRgatatatgtttgtKtNRaatatNatgYcaHtgHataacKtgagtagtaacYt
+taNccaaatHcacaacaVDtagtaYtccagcattNtacKtBtactaaagaBatVtKaaHB
+ctgStgtBgtatgaSNtgDataaccctgtagcaBgtgatcttaDataStgaMaccaSBBg
+WagtacKcgattgaDgNNaaaacacagtSatBacKDgcgtataBKcatacactaSaatYt
+YcDaactHttcatRtttaatcaattataRtttgtaagMcgNttcatcBtYBagtNWNMtS
+HcattcRctttttRWgaKacKttgggagBcgttcgcMaWHtaatactgtctctatttata
+VgtttaBScttttaBMaNaatMacactYtBMggtHacMagtaRtctgcatttaHtcaaaa
+tttgagKtgNtactBacaHtcgtatttctMaSRagcagttaatgtNtaaattgagagWcK
+taNttagVtacgatttgaatttcgRtgtWcVatcgttaaDVctgtttBWgaccagaaagt
+cSgtVtatagaBccttttcctaaattgHtatcggRattttcaaggcYSKaagWaWtRact
+aaaacccBatMtttBaatYtaagaactSttcgaaScaatagtattgaccaagtgttttct
+aacatgtttNVaatcaaagagaaaNattaaRttttaVaaaccgcaggNMtatattVctca
+agaggaacgBgtttaacaagttcKcYaatatactaaccBaaaSggttcNtattctagttR
+tBacgScVctcaatttaatYtaaaaaaatgSaatgatagaMBRatgRcMcgttgaWHtca
+VYgaatYtaatctttYttatRaWtctgBtDcgatNatcKaBaDgatgtaNatWKctccga
+tattaacattNaaacDatgBgttctgtDtaaaMggtgaBaSHataacgccSctaBtttaR
+BtcNHcDatcDcctagagtcRtaBgWttDRVHagattYatgtatcWtaHtttYcattWta
+aagtctNgtStggRNcgcggagSSaaagaaaatYcHDtcgctttaatgYcKBVSgtattR
+aYBaDaaatBgtatgaHtaaRaRgcaSWNtagatHaacttNctBtcaccatctMcatatt
+ccaSatttgcgaDagDgtatYtaaaVDtaagtttWVaagtagYatRttaagDcNgacKBc
+ScagHtattatcDaDactaaaaaYgHttBcgaDttggataaaKSRcBMaBcgaBSttcWt
+gNBatRaccgattcatttataacggHVtaattcacaagagVttaaRaatVVRKcgWtVga
+cctgDgYaaHaWtctttcacMagggatVgactagMaaataKaaNWagKatagNaaWtaaa
+atttgaattttatttgctaaVgaHatBatcaaBWcBgttcMatcgBaaNgttcgSNaggS
+aRtttgHtRtattaNttcDcatSaVttttcgaaaaattgHatctaRaggSaNatMDaaat
+DcacgattttagaHgHaWtYgattaatHNSttatMSgggNtcKtYatRggtttgtMWVtt
+taYtagcagBagHaYagttatatggtBacYcattaRSataBatMtttaaatctHcaaaSa
+aaagttNSaaWcWRccRtKaagtBWtcaaattSttMtattggaaaccttaacgttBtWat
+ttatatWcDaatagattcctScacctaagggRaaYtaNaatgVtBcttaaBaacaMVaaa
+ttatStYgRcctgtactatcMcVKatttcgSgatRHMaaaHtagtaaHtVgcaaataata
+tcgKKtgccaatBNgaaWcVttgagttaKatagttcaggKDatDtattgaKaVcaKtaat
+aDataataHSaHcattagttaatRVYcNaHtaRcaaggtNHcgtcaaccaBaaagYtHWa
+aaRcKgaYaaDttgcWYtataRgaatatgtYtgcKtaNttWacatYHctRaDtYtattcB
+ttttatcSataYaYgttWaRagcacHMgtttHtYttYaatcggtatStttcgtRSattaa
+DaKMaatatactaNBaWgctacacYtgaYVgtgHtaaaRaaRgHtagtWattataaaSDa
+aWtgMattatcgaaaagtaYRSaWtSgNtBgagcRYaMDtactaacttaWgtatctagac
+aagNtattHggataatYttYatcataDcgHgttBttctttVttgccgaaWtaaaacgKgt
+atctaaaaaNtccDtaDatBMaMggaatNKtatBaaatVtccRaHtaSacataHattgtt
+tKVYattcataVaattWtcgtgMttcttKtgtctaacVtatctatatBRataactcgKat
+StatattcatHHRttKtccaacgtgggtgRgtgaMtattattggctatcgtgacMtRcBD
+tcttgtactaatRHttttaagatcgVMDStattatYBtttDttgtBtNttgRcMtYtgBa
+cHaWaBaatDKctaagtgaaactaatgRaaKgatccaagNaaaatattaggWNtaagtat
+acttttKcgtcggSYtcttgRctataYcttatataaagtatattaatttataVaacacaD
+HatctatttttKYVatHRactttaBHccaWagtactBtcacgaVgcgttRtttttttSVg
+tSagtBaaattctgaHgactcttgMcattttagVtaagaattHctHtcaDaaNtaacRgg
+WatagttcgtSttgaDatcNgNagctagDgatcNttKgttgtaDtctttRaaYStRatDt
+gMggactSttaDtagSaVtBDttgtDgccatcacaMattaaaMtNacaVcgSWcVaaDat
+caHaatgaattaMtatccVtctBtaattgtWattatBRcWcaatgNNtactWYtDaKtta
+aatcactcagtRaaRgatggtKgcgccaaHgaggatStattYcaNMtcaBttacttatga
+gDaNtaMgaaWtgtttcttctaHtMNgttatctaWWatMtBtaaatagDVatgtBYtatc
+ggcttaagacMRtaHScgatatYgRDtcattatSDaHggaaataNgaWSRRaaaBaatag
+BattaDctttgHWNttacaataaaaaaatacggtttgHgVtaHtWMttNtBtctagtMcg
+KMgHgYtataHaNagWtcaacYattaataYRgtaWKgaBctataaccgatttaHaNBRaR
+aMtccggtNgacMtctcatttgcaattcWgMacttacaaDaaNtactWatVtttagcctt
+MaatcagVaagtctVaaDaBtattaattaYtNaYtggattaKtaKctYaMtattYgatat
+tataatKtVgDcttatatNBtcgttgtStttttMagaggttaHYSttcKgtcKtDNtata
+agttataagSgttatDtRttattgttttSNggRtcaaKMNatgaatattgtBWtaMacct
+gggYgaSgaagYataagattacgagaatBtggtRcVHtgYggaDgaYaKagWagctatag
+acgaaHgtWaNgacttHRatVaWacKYtgRVNgVcSgRWctacatcKSactctgWYtBgg
+tataagcttNRttVtgRcaWaaatDMatYattaactttcgaagRatSctgccttgcRKac
+cHtttSNVagtagHagBagttagaccaRtataBccataatSHatRtcHagacBWatagca
+MtacaRtgtgaaBatctKRtScttccaNaatcNgtaatatWtcaMgactctBtWtaaNac
+tHaaaaRctcgcatggctMcaaNtcagaaaaacacagtggggWttRttagtaagaVctVM
+tcgaatcttcMaaaHcaHBttcgattatgtcaDagcYRtBtYcgacMgtDcagcgaNgtt
+aataatagcagKYYtcgtaBtYctMaRtaRtDagaaaacacatgYaBttgattattcgaa
+NttBctSataaMataWRgaHtttccgtDgaYtatggtDgHKgMtatttVtMtVagttaRa
+tMattRagataaccctKctMtSttgaHagtcStctatttccSagatgttccacgaggYNt
+tHRacgattcDatatDcataaaatBBttatcgaHtNHaaatatDNaggctgaNcaaggag
+ttBttMgRagVatBcRtaWgatgBtSgaKtcgHtttgaatcaaDaHttcSBgHcagtVaa
+SttDcagccgttNBtgttHagYtattctttRWaaVtSttcatatKaaRaaaNacaVtVct
+MtSDtDtRHRcgtaatgctcttaaatSacacaatcgHattcaWcttaaaatHaaatcNct
+WttaNMcMtaKctVtcctaagYgatgatcYaaaRactctaRDaYagtaacgtDgaggaaa
+tctcaaacatcaScttcKttNtaccatNtaNatacatttHaaDHgcaDatMWaaBttcRg
+gctMaagctVYcacgatcaDttatYtaatcKatWatcaatVYtNagatttgattgaYttt
+tYgacttVtcKaRagaaaHVgDtaMatKYagagttNatWttaccNtYtcDWgSatgaRgt
+MatgKtcgacaagWtacttaagtcgKtgatccttNcttatagMatHVggtagcgHctata
+gccctYttggtaattKNaacgaaYatatVctaataMaaaYtgVtcKaYtaataacagaat
+HcacVagatYWHttagaaSMaatWtYtgtaaagNaaacaVgaWtcacNWgataNttcaSa
+gctMDaRttgNactaccgataMaaatgtttattDtcaagacgctDHYYatggttcaagcc
+NctccttcMctttagacBtaaWtaWVHggaaaaNatttaDtDtgctaaHHtMtatNtMta
+gtcatttgcaaaRatacagRHtatDNtgtDgaatVgtVNtcaaatYBMaaaagcaKgtga
+tgatMgWWMaHttttMgMagatDtataaattaaccaactMtacataaattgRataatacg
+BtKtaataattRgtatDagDtcRDacctatRcagagcSHatNtcaScNtttggacNtaag
+gaccgtgKNttgttNcttgaaRgYgRtNtcagttBcttttcHtKtgcttYaaNgYagtaa
+atgaatggWaMattBHtatctatSgtcYtgcHtaattHgaaMtHcagaaSatggtatgcc
+aHBtYtcNattWtgtNgctttaggtttgtWatNtgHtgcDttactttttttgcNtactKt
+WRaVcttcatagtgSNKaNccgaataaBttataataYtSagctttaaatSttggctaaKS
+aatRccgWHgagDttaaatcatgagMtcgagtVtaDggaBtatttgDacataaacgtagY
+RagBWtgDStKDgatgaagttcattatttaKWcataaatWRgatataRgttRacaaNKtt
+NtKagaaYaStaactScattattaacgatttaaatgDtaattagatHgaYataaactatg
+gggatVHtgccgtNgatNYcaStRtagaccacWcaMtatRagHgVactYtWHtcttcatg
+atWgagaKggagtatgaWtDtVtNaNtcgYYgtaaactttaDtBactagtaDctatagta
+atatttatatataacgHaaaRagKattSagttYtStatatatagtcttaaaaMtcatgtt
+caaDactgRttctaagagDtatttttagcgacttgtgRtgNctgSgRaaaaatgcaMtYt
+DcatcaaYKttHcatSWgaaaatDataggttatgBDMtgttataacaaYSgagttacgtt
+atgtDStttaaatctcgWKtcSacgagagaSgttatBMDgtcggtgtgcgaNtaSHBatB
+tttVMgVcagaNatcaDDaKMtMYtatagaBccctctDtgtatttatatKNtgggtatgt
+RaacttgaWaaYgcaHatccctggtttStatMtcgcMtaaaWKttMVtWctVtgttaKDW
+ctgWaVttaDVatgKtagagtcatctaKWgtaaMttSacBaMattaKaaHDataattgWt
+gttttgtcatBacacgtStacaaagtNctNtgtgatcHtWttcKaagagttttaaaaWac
+gRacatctNatVStgaatDHgttWcgtRKcatatatctcaNttaaBDcctgaaaaaDtaY
+aHaKttNtaYVaVtttaDtctacttctWttaactaattttMagWcaatcccNKYtBaaca
+tgttgaKgKcgcBHaatDMttatatcSWacatDatRcWaMtDgatBctHgScttaaaHtS
+gKtDtttattgtRStWgttccatatttcacWttcatattgtaHVgaBtacaMtgMaaagD
+aataactDatattagMaNBagcttcattcgtaaKtgtatttcacMtgBaVtaattStctt
+agtYgtgtcgccttKatgggtgaWaataggaatacMMagaSKRttBgatgacRtgMtaga
+SRataggtatcaccgaNaaaWSWacDgatacttgattagcttgtgVMttatYctaRgHVc
+DtVRRtSaMtcaVtVtatcaYaHatattaaVaatctaBtgtacRatNtatttgaYatSaH
+ctaNgNtYtYaYagattVgatcRtaacgYggtgtatKttaatMagatgRtatatgHaKcc
+HaaaaYtgaacgaWaNgtYHgacagaYtctaVtacccgatttttaaagcDttatNRgatt
+KaaattttcatctaatgccgcaataataattgttatYtagtRNtaagttggtHaKttWMt
+DKgatSagBYcgRggtWaVaattHtatgtaaaMgSaaagataaKaaKgttDttttRaaga
+acaWRcaacDgtgttaatattaKtatcaWacacatttVtctgatHRcagtttNcaaatcN
+ctNttttataactWacBBttgBttaaaRaWtBKaaacgtatcRcaMaatgYacaaaagtg
+BataStWYtggtatgacaKWtctSgcKHgtcNaMNcataSatattgactacMcataattN
+VtDaRccaaatcagttttYttagYaacgtaatMtMVatNgKaaMaaBgattaKttatDaB
+cttKtccttttacDagaYtacHgttggacaaaVaatagtYatcataSgatcaaWVttcga
+atgaccctccttNtaSBWaatttDttttcaatatYggctatDcttatNctttagDcMttc
+aacWaaNattSYgctttcaHcRaattaataaaatcVccRaattactctaMaVRattacag
+tgRcDtcgtgctcttNtWVtacagtHtatHaBDtcWggtgctcaaRHtatgtDgacStgc
+aaaVKtagttataatactaatatgtagScaatRSacaattgtattgcagatHHtgBcaat
+KKtaaMMcaRcgactatKBaMaYatgKatttDaaNtRatattgtatWttagcaaaaacaW
+gcacaaHcataYtDaHgttataaSacgcagggggtYatgcKctaaaHgcVgctBDaVttc
+cStagNgcSgtatgVYaMatcaWRBtVtgYttgtgRcYttcgctgaacNttgtgtctatt
+WttttcctagMtagaWtaKgatStScatMaBtaStaSactattYNatctgtacRatYDaa
+tgatgatatgaatYaaaaSHttaaYMaWtDcaNHaBcaYtgVgcatVaacattMRatBta
+atttaDacRtagtaaaNYVSMtcagaaDtttDHtRcYatacSNKaaMcHgatBaaVttac
+tggBYgaYatttttgcDacHctWatcgtagagtactcattDggtcatKaSgctttattta
+gtDtRBacttaWYaaaattttgaccttaaWtaatgcRgccacttMtaggKtcBtgacgaH
+ctttatcgtcStatMHDNagattatNagVaaaWcggaaaYcaVactDYactaStattgBH
+tcYctgggtacatataaYcgaYagaggaggacaVatacHRtYtctgtaVgaYcNgaaaNa
+tacVgcNgtaatttDcatttttcaacttSNcaaDatVYctSgcaccttagMgacgcttga
+SttaaaatagttaggRHttaaacMatagcaWgMgagtcgctagtgtKgactaaHttatta
+WgcaaaaaaSatatgcgttaBNggttaYVatgaactttttgccatataaataRatSaBct
+agttataBccgaaacaagatacttaattttgaHgHMgtaaKctttaYtaaRacBMtBaYg
+aBaaacaYtVtagcRgWatHaWagattWSacStMHatttaDagacaatcgtgtKtttgga
+MtgtWtgtgcaaNaaaaWtKaaBcMWtcttctatgacVgagcgaggHaYYtttWgSaaYY
+aWtRYHHaMDtctttacaatggaaMctataagcttBcgHcNWaatttgtatatYtStatc
+tagcactgtVttccagaaattaDtttaRtVataBttWagcatDMVactYtgcatWtttga
+aMggKaatgaaaaHtataDtgYcMggVaaatSMHtttgVttaYaWaataRttgttaYtta
+ttttRtWtataaBgtDtttatatcVgaaBcaDtatgtcaDagaWtgaYtWctcVagctca
+gctatatagcRVtcaKtaataatHgNaccgaaaatVHBaatattcgttaVYttatttctB
+YaatKaagaccVStttcattgaMagSaaaaccccWKcaaNtMYacctaDStagaaattta
+tcatVgtcaatacccKattgtaaagtggWgtatatVtagBcttDaBacaattWtDYKtat
+RKggStRtaaaWatBtaagtaattDaaaaBRacWtaagtacaSttaaatccgctaaccKa
+attgVWttDattatttattKaMtcYtMRWagMtcgKgBagacgggVaaNaaatgctKcgt
+aataaKtaaagtccWcttHMatSYgataaatDttBaHccattgBttSgaaHYtaataaaM
+tgaagatgtttBgRcattaRaDHcttBgaMaWaaVMMattaatttgtgBRctattgKMag
+NcMtatttaaaWttgaaacatWgcScgYYDYgttYtVtattgcKcWtagcggtgBaScta
+KatacaaVtcaRDccccgtgttBgKgggtHagcgaattaaagMMttScggtDttttaHcS
+aagaacactcacactBcVgaKNaDHacacttatSagaattSKHtcagtataaatKaaHtg
+aaRagaaVcBtaHtaaatcgatcWcaRtaaaatttaWttaagtcaggRctgaWcttDttg
+actttaVSaaaatggtaWDaRMtBtaaaaaKatBgatMtctatatcaVaMgatttgNagt
+DRttDatcttttaMtYaaatcggagttctctaYatNtagaNcgMMactacHcaagtaaaa
+tStaSaacaHcacSgggtNKatggaaagcggaaKgggtaYtacSgccgBaggcRacgtVg
+DtggaMcYaaaMatggacgYStKKatgaBcaaRtStccSagcRccgccgcSDtgcggBDg
+aDtBtSSggacMttttaWcatcMatgtNMBWgataatcaaVtgaataataaNatgcaaNt
+tNctgacDMcaHccgatgKgWVttccaStggattctcDacttttttctttaaNcWaMWcc
+WKWttgaaaMctDaaBactRtVattttBtcMaNttWcKacagttKSttaYaWSactHSaB
+tHgatgttacatgcatatMtttgtaacScWHBatHactggatatatctgagMgRSatcta
+aSttaVagcaRcttggaYaatKHtagBBactattcgtaaagaagttgtVcgatgaVatHM
+tcaggtcgKSgWattgaaaVctccVgtDcaaatgaaHgMYactcaMatatatattNVttW
+tWaatttacRagKataaaNtttacaaWgMVactattaSgaggVaaagVtaccDRHaaata
+RaHaRgcattMttcaatcaKaaataDcaDKtctcgaggBggacctDtttatHacWVaWga
+tDctaNaNcgKatcMtcMaatBtttggacgtgataatagaaacRactcBtattttaKtgS
+aaggKtaggRaVtatagcccaNRttaccttSMaagatcggDacNBatWcgaactacacta
+actNBtaStgVtNagcatctaVtaKatKgaBtcgtttWaagWMgagRaNatHaaaaDtac
+agacaBagtgcaHaNatctcBccNttaagttDgaataaNtcgctaacRBgtaatSttaat
+atgcataacccaSattKcccttDttggtcaatgggttWaacgatacattBtgMaYgaRtt
+atgatKaKgtattDtKWgataacgNBtaccgaKWatcttcttKtgtcttagcattcctWc
+aaHgagtatDMSgKtcagcttgVHaKcttDaataaaVaatttDgtgaaataaRgtcaVaa
+tacttagtVatatgggcatgtDDtMtgtatBggattHtgcVtgtgatcaaSattatKYVa
+acSNNttNWcgaHttKDaaMYHatcgttaattaSttgctWaacHtaKBtaaaaKHttcRW
+gaaWcRtBtttggBcDtgtacNttaagcKtaHgtagaaaaRttgaaacatagtWRaacYg
+gtaaatcgctYaBtWDRtgttgSctaaKatNcattgtgtMttatccatatagctSacgcc
+SNaaactacgNtgtgcttMatSKtcaaBaNaaacataacagaaatagtagctcNcatcVg
+aagStaataVcDKKttcagDHDtattctaatgagggRgBMctatacaagYactctMaaag
+tcgctttctcgtgaattatNcgatMtttaggcBaaatctNtactaaRKtgKactattgtc
+atatgtacgagttMaaHSSgHgBatatcgcaSaataaaWgaagtatagaHgcttctttat
+gaccWaatttaRtaDaatttaatcgaaattgattMcatcaWaMtaWaKactttctBacac
+tatNgtccttaWgtctgaccKatStaKtgagtacgggcgcgtYNtatttagacctctKca
+tgatKWStcaataactaWgMSgHtgatctttttgtcgacgtSacttaYgcctWctcctct
+acaagVtttMaBactWVaccaYtgtSgcgttattcKtatStgaaKaccgNaataaHtatW
+tYtRacggcaDaScagcagHaYWRtRNcDtHtcVWtggaataaaYttgVaNtgttagtYt
+tgtagSaaatDgaggccDcgBRYStattatttaaggccgHgggYRaaccMaagttatStt
+ctttagcMtgcgMtgaSagaNaDagttSatgattWatttagtDgcttgagtgMKaYWaYc
+cagcaHatKctaKaDgctagacttattgattaaYttatcttattattStaattWaRaYBW
+agYaatatgttRgScttgBagDaWgcgtgcVDaggcttgtctaDRKacttgcaKBWRtaa
+VaSctKtacttMaaSVaWWcgSaNtttSWgtcggtcacttggVVtgagaataaataaDtt
+gaaccaaaaMttaaaagaaaaaaaatcNBtatMgccWagcaNgaVaNaaaaaaYaMgtta
+WtatHaagtNtacgacaBtMMattttWNaRtaaatagYaScKattacagctVKBtWNSKg
+YtYgtWatHaVatDaaatWgDatcctggSRagagtaaaaMgatttRtaHacatggtaKag
+VcctgatgaMtaaYgatgtattattttHggBaccaDctctggNNtYaatctVttgVtRtV
+cRacttNctttataggHSRtaRacaaattaacHaHgtgttgtttcBtBtatWtgtatttt
+gcKagMcaaagaMtattagtStagcBacYaaHcagVgWtgtttcgtgDHaVtagDatcRa
+RtggtWtaactgcacgaggaaaRttSDaaVaSttaaaaacSMttactaNtcaacaattDt
+acttttYatVSacYtWtMttaattatcKtcttctatcaKDtctStSaaacggtYccatgt
+gagagtWtagWKgcaBaaaaKttgNactaatcgaggcWtcDDaaaaaacactHattaatt
+cactatYttaagacactaKaagRtRataaattttcatHggtaataaatgataHtggctaa
+cBacDgtaatattRtYgtDNDBgKtcaggcHattttgHNgWtaatttccgactactgaca
+tVNttYYgactcgctctatttagaMcgggatHcgtttatBaDSagBaaaagRttBggtta
+aBactVHgatgaatttattcaaaattgcacttcDgacttYcVttactVtttatBaKHaga
+WgtgaatggBtaaSggcagacNcttaDttVgMtWagattggVatttacHtctNcMatact
+tSatMagcttgtNcYaaScaYactcKctKtagScStcagtttcatWaatggtgagaggHa
+ggggcaacgcRKtaRcMaNtHaatRaRaaactVtBtgttaatRtWWcaaagKttccaaKa
+aatacgVttcacaaacgcggtgagaRaatggtgDMWatcWVScacaaaDaggaaHtgttS
+MaaaaaccYccDBtatYgtMagcSagaccaVcctcggtVWaaagttatcNaagataataS
+aataaaKccgtaDtYttatYcttHttaagKcMctaaatggaatRgaaaVaaVtcKYagga
+tWcaBtDaggDatccttcYNtgcSMRgaRtNgaatcgttRttatDVMtagctttacatDV
+tatatatcagctaDagMtataccYgaggYaaatgDaaaatSgctctgatgtttVaaBcct
+gataKtagaaaccaKatatgttaDtgaDtatagataatacagtaDtatcNtgtDMtYcat
+tRVtctataNtWttggNaSgtMgaaYctctDggHtggHDccaccacKKaaacaaaatRat
+ttccctttaagcRattMHctattHaRtataVattggatcSttaaHaHgaaHNDtacattS
+aaggDatttcaaaYgctBcatattaaaKagtgcccatSctcgatRtaaaMtgWactttNM
+aWctYgRatDggaactcDcaattaKaactgagtatctataagYaaaSRctggtacWtttc
+cWtaYRtKHattatagWtKttaNgcDtatHacccattaatttataacgctMgaagtaaca
+acagMgtaYHYVtKMHtacMgKcaaatctgRYataNtcgttcaatacggWtMcaatYcBW
+aagYtVaDNagtatagDaaNtaaaYtttcYWttttStgggataaMgatattagaaYtNct
+cttcBagactaYDcgtacHDWccKaHgttcttHgVggVDttatcatKaMttttacWaaSa
+ttctatagaHaggKaDagBtaaagtcYccattgtYcatctaNgRgVtgaagtDKttatBK
+cggDtattRYgHccgtgcgBNMtttVRgacaYctSctaRacgtagagccgtacRaagtaH
+KagStSttttgYSatattaaaWHaaWagttDKaaNaNHaaHttaYcttMtcaaatgKttB
+tSgtccaaVaattSaacgttgNattgatatNctaWtVcagtactKcWacgVagggHaaRg
+aDaatcMttattaataacaBMaaVtgYtKgRgHactgtactatcBaMtVggtagKcYtHt
+BSaattagtaatgMcaVVagYYgWtactttccaaSttDgaaMaMttcacttYtRgacttc
+agcttWtttagtgataMaattaagVtagaatatKataagtagttaagHMRaDattaHaaV
+cctDtagtcVYcaataaYcNttNaaaHctcaRaatttcaNRgatSHgVatagctRtcatg
+aBttMaaagRtcgHVtgRgStgatttgtagaKagaRWRctgNaHYgaaatBctgtttRtt
+NWagaccgagKgtgcggHKVttaatattaatataataDtaNcctacaaRgcaNMctctga
+aSHWWHcttagtNagtWgWaaKtYaNgcBattatccaaaSctRRHKaNtKcBgtgagaDR
+WBttactaaattSMctatatagaaYacDgatttccVtaagRtgRataatatagtcttttt
+atgtMgtcaacaaNtaaaaactctWtagaVaaaDtaattatagtBStcgaatDtgattVa
+atMtcaDattVKWaagatagggttgtMRSgtcYgWMaatgNtagtcBttagtttctctWa
+aMtVgctWgSgtHagaSagactagKtagWggcatttHgttgacaaactcggggHggcWBg
+VgtatgggagVgagtcVcBtDctttagtctaagVWtHtgtttaScatacMBtKgattatR
+tgtttgtctttDggcHaBtRtgtaataNataatttataWctgaYWataStcHaatcRtaa
+VagDWaSatagtaccNDgaagtatacgttttacgacgKRtattgDctatRRattVtStaa
+actagatgVatttagaMaSaaaattVtatYtgttgtRMagtHaatttSttaaYNaggWag
+tgcacgaMcactgHgtgtgggHMgtKacttaaYgtcgcatcSatattgBaagtttacMtY
+agSatttatttaVtaaDtaWaHcgNatactgactHtggWtataDcDScatactcStcDtg
+tcgtgtatgaggtHaaNKgDattgcBccaagKgtatgacKSMtttttgttcaaatcaaYt
+agtaSatgDaaaMccKNaMaatagaataagcaattattataaMgagtgaSgtctNYttat
+tHaNaYYtcDDtaatNRgtatttaaYtaaatcactHVaHcStccttcccaaVatcVggat
+KtatgRaaDBgaYtttacttYggactSDtaBcaaNggggtattatattBDcttagagYNM
+atBgttYaagactMatgttRgatacccgtaacacBHtatKacWgatRcHttaattYtKtS
+tccaaatVDcaNKHHaaataatagtagtatcttgctNDggVaVVtaVaRaaagSaccgtt
+ctcMtVtgNBgtDtttctYgttactBctcRtStWtWDScMtcWSaRatgaataRHctaNt
+cStctYtWacagatgtatYBtHaHWBtacggtDcaaBtatcaggtcaVattaNctactga
+aaatWaDgactNWtMtggagaattBaataYcMWYcgatMYatWtgattSatgaRtDaRgc
+cagtSttatatRaBtattRcWtagtVgaagttMctattatatDttaggtctKtgtgtBag
+acgttatRKtgatctatttBtataactgataacKcggagtgHgtVttcttgtKDgcDtaY
+atBDatcaatattgttNtaBacatcgcNcaKcaWcRataWcVgtacgScaWgttcggHcM
+ttcRccatgaRStYgNacagatacYacWWtggNaDcWagttHatMaNaatNtcDMDcMaK
+gHNatScVgatKWatatgNRgtccgYgaagattDHgtMtcHaSNaaattBatRagtaaat
+ttacaagHWtKatcaagtccHtYcctgttKDMSgtactactVctgacaaaaHgatataca
+taatKtStHgctScSatNatacaYttaaWHtctgaatYtagtHtKaggccWBaStaDcta
+agagNtaatcaatcgttNgaYDaagtaaaaHatagaatcgcgBaYaBgaacSaaWaaaaa
+ctccgcMttHttYgtaagaMctKBtacSagattcBaaWtaattttacRttatcgaRtaca
+RHgtgRagaaBcttaVgacVDgggaatVatagaactRRtacgYttNattVHgaHttacaa
+aaaaaYtcRWtgtgattatgccaSDtttatKWgaatatSNDgattttaacgtcSRtatgg
+ttcttcBtWtttMtBtMScttaHatBattHacYtaYacattcgttKgtcStSctcKtata
+tttcaKSgagcttccaacaccRDtttDaccattatatSgtcWtVaaagttgtagccattD
+tYaatattDaccatcVDaaRccagttttgtcHacMattcHgaNcatgttKcVttcctgtg
+cSataaatattgaKtctaWctMRaKggtaYcaagttDttcgttacRtatgatggHNaWMt
+KttcatattaaDaSaBaaaMtMatBgKtttgHtHactaatcatcgtWaatKaaWcaWtcc
+tVttaaNaggaaaagtaaagaDctNttaDBaBgatagMgaataacRcYggatcRaaaHaa
+gatRDtVRactaYagttcaccaaWtctcSSaaatcSKattctggDgaacagDtaDagaca
+gtgtaattcaStYttNaStgtaHgccttaScatMRcaccWtcatttatRtaagatWtNat
+aaWtMNtDVgWttgcWgtgaRttttRgWcttMtctaHacaaYtKctgaBagtRagacttD
+atNttaaaDgRtatNcHatcSDgtBatcttacVcYacNgaattaacgagttgYgacttDa
+ttatacBattMgctagcctagatVcaactNttcctaatgtDaacgYaNatagMatSWtYB
+aaaRtgMtatSRgaataYaScaVgtaScMagatNNtttacaaHBaWtNtRtctaaacDaa
+aaWMcaNtcVaDNcagaDtgcWKYgagttaHtgcDYataaacataBaWWtcggtatgtga
+aScaacctttRNatcgttaaagcaDctaatgcBatttacaattVaMgSMMtccYaaaBYt
+ggattttcataWttgBtatDtBgactaatgtccWaaHataaScHttWttDtcgtcaagMc
+tMDtaaaatRtBaaaacaatgtcagcatBgNNBVttttttcBacWtttWtSWWtgaaaaS
+acgBtaaataaagtcDStaagaactgttaatYatgDctattactgaHtaaatStHaagac
+aKtagDtaaHaDgttccaaDtaaggacactctDggcgtDagtcWaHgRcHgDgaScttta
+ttgtcttttccttRYaDgNactaaatcaWggcNSBagttttatatStKgtcRtgattaag
+gtcaSBttaacaaKatgggatcaaattgRgcBagtNtcgDcatttWcctttgtNagDgct
+gcatttactttgtgtcaBgSatttNHaMcggcagSctcKDtWBaagSagWatggYtVatS
+RgKagattgaVatKttcgatYatKYSgDaacNtcVgtttaWataWtgVctgcgSggMgat
+ccatgagttgtWcatYWWcctVcNHagtNtgtKtttgatcaacttaSttattgatNcatW
+aVgNHcagStVHcggHacaaDttgDttWcaaRaKgaaatKaattagtaWacattgaaatg
+tgaatgacagtgaRVtaaYagYtcggcatMttgaaggDgagDRcaKgHtacacaaaMcaB
+tagHactgKaatRtNttcttcatcatNgYgStggactatgSMttgKtDaDgacRRgtWaV
+attgatttaagYctatatagactaagaggtatWtataaactaYaHRctStgKWcgtRtKt
+YtYtagacgattRaaYBtaStcttaWataatcHttataRcactgagtgggagccaattct
+cDtgDaggHcDRVaVVggaaBtRttaataaRRttgtaagKNcaVWWgtatacctgatctt
+BtcttRgaWcaVRKcagttSacttagcgtKtgtYWatatcgNttcKaccacacVKctgat
+tBtggacgtctgacaDtWKttattttgMBgKaacaDataattWtBtBRtVtacataaata
+tttgtWtttatagtDtgcctagctHYaatgcaNaaRcaatVtacctgggggKtagBgaga
+BgRaaNttttMtMagMtgtgattNctcNaKggWtMatcttagWgtaatatatNctaYBgg
+KaataBattYtaattataVtggNtcgtgtctaattaaacctHtacaaactDctDtctgat
+atgMtgataacWctgtgYSaaNScgDYaWtatDatMKgcaatttctgNcgtHtaWtagat
+atcYBttaattactcaaaVattYRWtatttDtaNMYMttgattataatgcgNggWaatYa
+gttgBagNcaagaaaDtRgtaaaagctgcatctagcttaVgtBttatagcKMSaattYtH
+cMaBttcagtcttgKatgVSVttKgttttttagtgtDHgNggtcaVtatttaacNtgaat
+atgctatMcatgaaaBtgBSaWctaataaattatYttagtaDtaccggaatgagtaattg
+gatttaacBtctSMgWYtgKgattacgRctctccaatgtaggcctgaNaatScgYataaB
+BacaKtHtttcatgaaHtgBtagaKHVtacctVtcaaccaDaaWNHNaatgataattgat
+gWcagggtcMBtgSgRataHctMctgMHHtKaBtaaMtMgataaRWtagYtgaaMaSgct
+YtgcgaaHatDtatgtcWRatKatatYDcBgNtRaRacattMcagaHgaaagRccgcgWt
+tggSatBagagcHgYtatctVtcatYaaVRtcaSacaMYDcgRtcaaWgaRgataMtaaa
+acaggtgtaaYcattgWgDHcWgttaVatttgcatctaatccacaaagaagSatgcgtag
+RgagtHDgaVcgtgcttatggMttttcatKSctNacHcctMaKRatttgatctaaatgHa
+aScataataatgtttgtgtHaVcaaaaNHaaaatcgctgSVtattVttagaaNWcacagt
+gKtatgattHcYcttgDaWVataBatBttttWtaactNaattttctttaaYHaMtttaaa
+ccgStcHaVBaatcRacaaWactgtagVKtNRtcctagcWaatNgctKccttctcDaBDc
+atYHatatgcaataaBaagaatgDMttaHcaaYYtcactgttRtgacRaacctaWtBtBM
+agBctaaBaWtgatgVtttattataggttaattgtaatYcaRtVctcttgcacSaaMaat
+actRSgcataKcagcaVNKttcgSatcaaactaattDtaHtNaVtgttttttaWVtatNc
+cagWttcgtatBcgttVctcBttaaaaMSaDattKRcctttcataHaattaatWaaataK
+caHVaggaatataBYKHVtgVcVgtcHcttccgcctattDtMMgWaacttgWttYtttcM
+cgtcctaaVHtgWtggtgacKtcaWaYMttacttagVWtacgSatatcgWcKaaatHKaa
+aYttgtagtcaacWtttggtcaagttgaaBBaSHacVcgYgttWBSRWggtattttaYDt
+HatattcgatNttacaaaaVacaMccaaYStaataRttVtcttagaVKaacaWcgccgtR
+atcatctaaatccMcctttaMggccHgYcDgaKctatgMRYBagcaNDtgMtcRttgtgH
+aRttacatgaWcDtgctgtataggNggtgaatagBgagYNtatcagKtHcatBatgVKga
+HWagattRDatatcgYcHagRtaatgWtcStagcVatNaaaaKttgRaRBYNgtaaDtSt
+aVRgcMccatMWaaattBDatttaatttataaHtagtVVaDRMKBtaacaatttttttDa
+RSgaaKDtVaBatcagtaaMttaagcctRgaNVgggttcataatagNatcctacactacg
+catgtcggaYgtaKcatggattgactttHtaattWNRaaWYggttcaaaggaaNtaatgc
+HcaaaattBtagcttattcaagVtatttWgcctaKtatBttDYcattagDacKVaYNccg
+YaYRaaMaattRaagaHtatgcttgcRagcgctSaatagaaRacaRacSccagcacVMat
+aatHgRtagcgaKgYRaDcVWSDVgRaMgcDgtaattttaYttggtaaWcttKDaaYtat
+MRcgKccYcagtYcBgRccattcaKtgaSSRtactgacgHtgtaaaaBatWgcaMcBcYc
+gccagactcttcSatYattgatgaNccaaaaWaKatVgcaggtWtBcgttaRMagcaaag
+tgttcacatataaagaHWtKatctacttatatcacYRaaVagataagtaattttgatgtB
+ctaataggtaRtaaHaattgtaRcStYSYaWRgMtacaHcNSttVNScattNKaaKgBta
+gtgatYcaaaStactggttggggaBggtNtgtcaaWBaYVSNgtaataBNtagtatatca
+cMcScccVcgtVRRtttNcKaSRNaNtHRttatttattgacaatggSaBagataaccgtt
+cctaDNaattgctVtatNtHtatagSccaagctKttaaacaaattattgtSHgMWgSttt
+NaccattBMYatRtccStNgttgaaBcctVagcaaaatgatattcRaBccMWaagKtttt
+tcMtgaRYNaataDttgttWRttattggHtNtataatggttgtStYgaMcYVtcattagg
+taatVcaNggaRtNataMWcctcYgcgagagRgcHMgcWtgaYtVSttgDaacgaaaatM
+ttYWtWttcctgaKNttatttattRaattaagaccMKtttcWgtcaBagKSaWaaacaNt
+aYaDtBNaaagWtHgacaaagtgVtcatKcgcaatVaactatgcgaaactccNctatatM
+gactatttatSaaVttNttRttagHtccKtHtaaaNatttYVctaatttaaaatHWaNtS
+acgaaaHggaaatcacagVYcctaattcMNtgtYtgagttatttaBtcRgBHNacBtact
+ctagaacgcKaaDWYYgcattactVagaYtgaVVcgcaNctttBagKRcSgaaatttgta
+tccattgtggHcaatRtaVtaSaBtcYYcatcgtgtcHaVttaHattctgtcaBSNYaKB
+BattaatggctgtHatattgtBacDcBgatttaaaNtggaaaaYtNcaKagRRtRgttRt
+MtWgggatcNtacacctgtWKagatataaYVMtaaDtaaacctctgtgtgccttScacWa
+ggaYacttttKacgtttgtgataKYagaYaVatcWcSattaMcatBYttYaaatgStKag
+WattKtttaWgtagaaSgtRattcSaDagVaMattattYaagccSgcNaaDgaaSaggta
+NgtWactaWcgHctgaNatttttcaatgtaMHSWaRtggtaNtaHBtttWWaaatattcV
+tBtctStWtaWMaBcatttcDagttDtttatatgttWBtNaYatcccSgtgagcgaRYtB
+tagaDacBtaagaataWactaaaagKtaKaWaataacKcccgDtagccaaagcggaatcg
+ctSRtacKgcactacccHaactMgtgccaBaRaaaBVtcgSacRKtttStgatcaaHgKt
+aaKaccHaccacccKttgagcttcSttttKKcgacBgggtYMaatcBStcgDBtMcataW
+taWaMtgaataagaaDatccSYDtgBatgactBaVtaagatctcNMgtcaWKtgcWggcg
+atacgtgtttatttWaDaNWBNaaNtNttcaaatagtaatScgHtMWttgttgaBaDtgN
+atSaagtttHttaNaNKaattKatttgatcgtVcatgaatatBtttctaacKaNttVttS
+agccatRtatatcactcHHatctWSKttaMacaaDattccaRaYttttagttaatattcc
+tYaacVactgctMcgagcaMYtttgaagctagtKgNWttgaaaMatcaMcttcSVatcaa
+tgtNactaaBagatagagtDMgtNtNWatttSaHactagaaaDggtaaaaNctMaatagt
+aHgacgMaaacMtacatHtaSagaHatYDccagtBtgaWatcYtVaagataattgatcga
+cctgcaacgttttattacNMWNcattataDVDactatattatYattttgcgaagtgagYV
+tagYaWaHaatctgWttttatgcHaacgttaccDaKtatagaccaDDttaacgtHBaaca
+tccgtYaBtVtNccaaataaaatVactDttSKtcMtDSgaagctaMtatattgattactg
+tNaagNBcagHaDattaaaWttacacaaatactcaatSDatagctcaDttWactttgaSt
+aaDtagatSaaDtgtaatKtgVataggaagWSaaaaKatttaaagtttgcgtaaagcccg
+gNWaacatacatgttctaRcaHttVtcattatctagttttNcataaacDttWaagVtNYt
+aggctttggtatgagaWgtactNaVatcactVttBKcttaaccttcMtatcggtaataYa
+MaYggttgtcaaagSWHctaRMSatVcggactMatatccgaatcttttttcgagtccagt
+ttgaMtcgcatcaaKagtattRMaaaKDBttDNccatttttaaBNtVtccgtaatgaKgt
+cagMVSattatttaWaattttaHNcaaMaHttgtggctattctacDtgaagattatcgac
+aaVRHttcSaSaatactNHWaaNcgtWaWgaccgRSttNtHtcttcKatYatatBaagtc
+gctBtgagccatatScctKaagaaKDaWactWagBgctgattBagKtgaaataBaaaaag
+SacScaaagagtagcgaDaYtaMcaYcKtaataMatttttaactttgYgtcgaaggacgc
+HctBcgYgaaVacRYagagBaaYgtagattgcgagtcaagtStDagatBgtgaccctaSW
+tctDgactaSHttctWatWttctaWtatctYacactgBWatKKctgtatYgacaaHSatY
+SaNgSagtatagatgagtatttatgaccMaatgtaHtStaWttgYagccaWattcagtBa
+YtaaNaBtaNatactggcttWcaagatDctacggaNctatcacatSgKgattgacgaccc
+ccgagtNDtattgagaaatattaatcVttNKtaaWtYacgSNcBHgttgWtatgtttcgc
+caactKaattaRgacgNataatctacaacKgttBatYatNMSaaaNtctKgacttatgct
+tatKtcaVtVcagDaataattYgNtRtHaagcaataHcacaVgtaNNHtHDatgttaMNt
+ggWagSVaRttcMVDtcttWgtRttctacKaaVttcVcgcatcctHRKtattSgttSacg
+aagtcccRDVaacBWagtgYtKtgattgSgaBtgccBtcaKacaDatacttHatcattNa
+tttacgtcagtgaggcBtaRNaRcaSgcatattatStatgctYcacgtattcattaaRtg
+StcttWgtattKtSYttNaHaRtNYcRaYtVtggtDcKcttctactaMcacggcMtacgc
+ttctatatHtaatggcattMDtaaMaKattgaagtBaaKMVMNacKaDtttKNcgagcta
+aagtccMMtgagaagVaataatggcaWaaaaVaBgtaSaVgaaaSaaaataDttVtBcca
+NagcSBgaMaDaVaVYYRVBgttYMtagtaactDtaagWaattBtattttMDYHtSaStS
+cRaKatattacacctMttgNBKtcRtRggNagtYMattaaatMctYgaatgcKHagSgga
+aaaBcaggtHtatWcatcgtStagMcctcatgattaWRcStcgWtgRgttttcctaacat
+cgctcgDDtRaatatMgtcMtHtMaDYatgDatttatagctKDtYHaaaaattaSatatc
+tggtctttattttatMtgtYttgtcatactcaaVcYBgatgSctKtYcctWaRaataWcM
+gNgcgggagtcttRMgactataHaHtgctNtVaatcaaccacgSRaDtgKtaaMSKgtaa
+aaWaKtttVagSDtaaaaaatgttYattttNagMHaaRtNgBttWattatatgcttatat
+catttatKtKaaaagctRaaatcgcYgacgNtacNtccVtSaaatttcDVctaatacWgc
+aMtcttSaaWaaaWagtagtaattaactagRttaVcSaaatataacHgHatWaattggaa
+gtgcgSSgaaVtgYgSttccatWVataatcgaatatgHtRcgtBttcttaaggatatgtt
+gtBcNtaatgtcacVatactgaaatMBttRRcRatccatagagggacatcgccWttagtt
+gWttatKagtaaaagHtttccttSatVatKtgagcaatttattaaYVattcaaattctgS
+attRaMtgaatMgttattattacaNcggVagccttaaKgccYcaaDattWtggMcttMac
+WttccMVgtgaattctDaBYgacttKYtBacatgctDcRaaKaaRaatatctttagKcKt
+aactttaatNaaggctgScacctYgcgcaaaccaHttVHcBaDgtaatHaHVaaatMgtt
+ggtSatHtNNaaVagtgtacaataaagacgKttcaaaWVacagctcacWHaatcctgtBN
+WtaNMKcVcVSWtSgcaattctgKtVVaaacaRaattgatRcgBacaKacVccVMactag
+cgMNaaactgataDaSgagaatVHaatVSVtccggatgRgtagRatttgtaactaBataV
+aggcaagHgaaSMSaKgctRagcStNcatttVgctatacttcNDtcaKBDcaHtDcaata
+gttHttattMBgagctgtaaagtMgatStStcagatatYcBtataacRcaggRaaaggta
+WSatKgatatgagcgtgMYatcagcatVttSgaaaaaatatatgttYttcattatacata
+atVcacgattataDggttBtRaagtHMtatagaDgNttggDaKctBcaaRcgattcgtgc
+cttacaaaWattYWVcaaWagDattgaaagggaagaHattBtatVggtaHtWtaMagtcc
+agaKttSatatcaStDtgWaagtKWaggtatttaWaaRcattaatStgaaVtacggaaca
+tKctacatHtaaaBtcNWatttBBaNatRcDattcgaactataaattataactcagtSga
+tataagRaYaKHctggtaaNtttaaNgaRHtttattatacNttttaDccttYgtaaacag
+gaagtgataaacatBgaSgtaaaaaaVcBgtWNtRMttBttaaBgtaaaatatcHNStaB
+taggtaVatYaccNtBaWagRctNSacRtMatDactStVctaaDtaYSRgttaRNttttK
+ggccagaaBcatagtYcaYNtDatcgtatVcaatWRtaggaattMcatRtgggatgtcMg
+gMtttataagtaBgtggacNaaKYtgctWgagYtWcctWtVcttaaactaRacatggtRc
+atctSDcHcMgcaactttttagttaccttattHRgtacggcactDBggtMHcVaaRatKc
+tSHacctacaccactaaHaacgSttagKtKttttgNHVgagtaYaMtVYNVcggttaSBa
+BtaatttSRcgtBgaWaatctttttKggacaWKaattKSaccttgDRgtcatatDatVMt
+MaVcgaattaNaagMWccctaaHgataatatgtattWataaaatBaaMtgRttcHctaag
+ctaagatatattMcggactaRttttKaSttactWYtgBcaMMacRRgNtactttaaaSKt
+ttcaYBaBttaVagtRtHcWaggaVccttNgtgagtcatataWttYScMtWgVRgattWt
+aSggacggWWctBHatattataaKaagttactaMRaaataSRaDttDaaatataVHaatg
+gaaBDgWgHtcKStVcatHtaatcatggBWaagHtagtMtgHcHtcatggggWcatacaH
+NHagcDatRcaaattcgcttgDggDNVcaacgSgtggcaccttMttaatattVYtVgaag
+RttaBcagVaYaHcaRDBagatgaVHtNMtcttactDaggMgMaattRWDcctVtgagaa
+aaSKatHHttVDgtctgtcacatHNttgaatSaagtKBatatagacaaRVctcWtgtacK
+taacHtgHataSgVtactaggtttatggBgtcaaaYaDgaaaaaatcgMtagaKaYatga
+attatYcttKtacaatttgWttMaatBgaatSttMtNaVgVtScgcttctBHKgtaRcNB
+aatcDtacgattgacgtgctatNaaBtMgagNgKcttWcWKacactYgttVgNcgaattt
+tcttgaaaaactacccctcgcNtgMctatcccacMcactcMatttatttagtagaacMNt
+ttcttgYKaWtaaBtttcWttagHtgtttctcttgtggctatgDgctaatWDataattta
+gaNcgcRRNataKtctaataHgaaMYctNaKWtactaacDtgaVcgagaactggtaccaa
+ctHgaggctagagHHagtMgKtaaactacaggMatgtYgSBaKaaaattMgatRtggggt
+HBVgttaattgKttaaRDacgMactcaaacStaaagctctgtgccttcgtSagtSaRcta
+caataKatattctaVgtgtaattRacKagttattgaMtaatgaNatacDataaggacttt
+ccNtStatatKaagaataKtatggtcctctatgaggttaaDtgtattgataaaactggat
+cactKBtttggcgtcaaagaaaNtagtWKatctaaWBactDaBaYtacaWtaSgcaatta
+ttWgaaBgactgaKctatBRgtagttaBaRRgatttaagBHctStgtVYRtaaataaagt
+MWtcHgcattcacaaMWtcMccWttgVgcHaWttcaNtgtVaggNgcVatKttataaWDc
+ccctatgatVttttattacagRBBWttcttRaWgaatBVgcgtHgWgaccagtYacaatt
+gSttaaMcVtDatttaVttRgttKtcaYWatKtaaDtttWaYtaatYctSctatagtcct
+BtccMaMMtaMYHaSSgKaaacttctcBtMtgDtgtttttagRcgtacttataHgKtNtM
+tKcBtaNKaHStgSagYHtataDtcKtagRtNWaacVgctVtRtttStNtgaaccttaVa
+tgagaaggtcaKSttaDataagcYaSatNStcaatDNgttcgacaatttaSgaRaBNNac
+attRatNtgSttHVtgWHgtSHccaactKttYtatHYttVtgHcNgactMcaacttBata
+tgSgattttacgtatttgtggtScaacggYtHtgcatctatttttWtaSatcagaYatcg
+cagtgtgtMgtattctttcattaRatttStcaatatgcttDtStaaagaccDcVtaWNcH
+YtWMaMcgaacKcaNcttacctaBtgcDacatcaHKtRcDaaacataaRacNNtccData
+NactttatBSDYatDtctBtaBatctDatKaMcattMatatcDHctaagRgYVcatgttc
+gtgataHDYaagttSgHYctaaatgtaaaactNgtagaaactaattRaatcttttBKcga
+atSctMaggVaVaaatgagataaataSgttKgtcatKaKatDYtaaaRttYaMtgctcSa
+tRtagttttagcaaNtaKgatcgWYcacDgaatcaatactgBgaNtaactaaWatataca
+atacactaNatcaVaKaaMaaaaaatcaccBtgttgNctaacaBattttaaKWcaggata
+WMtaattgtaaHtgVtcgaHtScaHtctcHacVatagtaMcaaKtcccSagMYtWcaaat
+HHtaagRttDagtMtcYtttaaWWaaaVaRtcHNtctcSttagcacaKttgtagtNgWYt
+atKDtcatttgaacctcKHtatccttattcttNggtBgtgtKaggWtYgtStgtVaRtaR
+aaagtagtgtcgcKtKagatgagYtttaatKcScctgaaaaaRaaHtttttaaaVgtata
+gKctaNtKaSVgttcgagacattttRSatagttSacataMtaYHccacttttctatacta
+gtatgaBaagctttaMtgaatgtcaKYtaaatatggattataNcgBHatcctaRaaactg
+ttgacttYaHtStcatcctDaMBttgtaWgagtaatWKataaaBgBattcttttctttaa
+tWStaatacgNaagtWaMaaNgactMtgaaDaggaaaSctaSSgatatDttattatcata
+gBcaataVcHcRgcStaHaaatWagatHttMHactaRacttaYaaaaNtataHKVaataK
+tatgatcgtcVaaWgttYtVcaaYggctRWttaaKtRttDaKtgtatcaattWKaatBHa
+aaaNgaatggStHgVVgatMgBYtaRNgBDttMcNtggaNgtcaHtgttDcNaggBtatY
+tacVaNttctcWtactHYcSctgtYtDtgWaatcHgatDatatcHtcttatattaaKaRY
+aDgaatgSYcgactgcRgaagttagtStYatYtttccgacactacagKcaaagDttaatV
+atcttaaacRaDatRcBatKNtNtaaaHtcBgatKHcWStSRaKaSMgtaKaBacWgDDt
+tgYaaYttaNtDgHtatSaSataaaaMBaaDtaMatDaagWtggaMtRcacttatggctN
+ataaaaatatWNMtacctatgtcaYKaRacagttHDagccgtaaYcaatataatcatagg
+gaaSatgMYBcKBBtaaRVRatRtccVtgtgaagVNttcttagtgtcWataVggtaaNaa
+tVgVaKctttNgtttagtaaagBatBtgaYSagHttSYaacaStcgcagaSttcDBtKtt
+tggtctacNttgNgKNNtcaaaaKWactgaaYgaYactatHtaWcaactgttSatNVtgt
+ctSttYctgattVaatKgtaYcaaattSgttaStatggtccaatgSWccaaactattgcc
+gttacgcNatcHctctcaKatgtagtctattttaaggHRatcDaagSaVgaVNccaBKta
+cgtttStagKgtctaHtcattaYcctaVKtttaYaaatYtccgataaaVttcDgatWcgB
+tcctaatttNaattgctDYgtgatcaatttaagggctctcatcKattgBtaBagcaYcKc
+tctttNtaacHacNStggRtMatHHgtacatgcaMagtgtccatRWttRKctaaaDtcMc
+tttaNVgaNtcMatcacHcctgWtaaStcacgtctNaagRNNaagMaDtactDgcttttt
+catcYacttaKttatgcStDaStNaMgDtaacKtMtacctaaWattggtttNaaVHatga
+aattaattacgVNaaWtggaWatctgVatcacYctcVHMtVaNacNtcccaWtttgcaac
+ctcWctHaatcttWcaaaYaBaattSctYatctaagDgBttagtaSgaWtBcRcKtccYa
+tatcKBgtctttatgaaHDcgNaMatggatgtWagRctStagagaagaacagctWtNtat
+aaaataRatHatKgctNactHgttRgRgVcRacatgHYaNttaHtattaNStaagatgta
+gaHcVctcYgggccYcaaaatgatcttctagctctHMaMMgcaVtgHgtaagaWHHtggt
+aactBcaMNNctagaacggWtctttgaggHcYNaaMHtaYcttKaagtSccgttgggNMS
+tatacDttataaaVaYcKtcgcattttcgacctctcacVttNtttattgtcttctaVcat
+agaattMttgtHtMgacataaatagttctMtgtWgWctttcaagYgcgtNaagcaaDaVH
+aaStMtaaagccccgtgVgtcacatcHVaDtgttBtBacBtcggYttDagaDYtccMtta
+gcttacNcgaagatRtDataRtgctaatatatgRtWVttatWKtgcBgactcgagaSgta
+aaaagttaaWaaagtatttctcWtatcBtcataacNcgctcRKaaDKactRaNtagtatB
+tgaaatttcgcDactttaNtYgagagaNttgaattaataaaSMattRHNtYtgttgaDBR
+BttgWttagSatgacDggNVagRWcggctacDaYSgaaattHgtYaaagctccVtataca
+ttaMctttgSgacatBKaattRgtaBRtttaactattctagcMKMtttctgtgtgVgtct
+ttcDcgtaaMtaggtaaaDtcaYtatccgattcYtgaaRttctKaNctaYgYaattYgRt
+tWctWttaaaccaatcactVatgcgYttgaaatgatKBcNRgctcatgaccHagcgaaaa
+tgtVgccatcaBSatKccRStSattaaatttggtaagcVattctgVcattMtacatMgaa
+aaaataYNDtDaatcatWattcaggNcaccctcBtgcKcHagYtatBatgBttgtVttaY
+BgBgataaHNtacRtcaaBaKcagNtcagaatYgttWgggaNDagtatagRtctcDtDaH
+ScagttcYcatcSYacHcagagNgtgcHagtacagctgRtatatMtaatRaWMHgaaKac
+aBRtagHtaaaNcVHcatWBgWaaacWccggtaaRcattgMgttaNgttVMVttgcaaga
+gaatcaaaaaagYScKVtgccgacHgacgttcaMcctcattatgcBttttaagtKatDac
+tccgBatHYgttcatcgaaatctSaKaagaatWVtcgttgtcttaMaaYaSDtaaaatac
+cgcKMtatgKtgScaaDMaaaactgtgagcVtttaRcttgtaNMatatatttggtMgYVa
+tDaatttgctttaaRtaBgttaYaaagKtataMtWStcHaaaaNacgctacMttDDgact
+acaNaatBcagtcattatatSttaVgRtWgSggcaatSataVgSYgctBttataaYRRga
+actgtgHtgacHWSactYNgtttBactatWStaNtcStcMttgattStacctgaattctW
+atNaaHgMatattcaaaKWaBaataatHKgaWgataYcaWMBtgtacKagaaaaagaatt
+ttWttDaMtggttgtgaNMtVtDcaacNttactattacggKctatttaaaaBKatagttH
+aatggaatatYWgtaVtNaaYgataatMaccWagagatRttMtgKaMcgatattaacaag
+atgttBBcNaYattcNgtRttgaBcctaagaSMttcMtcctcYattcaNaRBttaatgVc
+MNgaacKagatcgNctaWVgttaaYRtgctSctaaaaNtttgctaaScttcVattaHtaa
+MacNgttNtKHMcctattttaRtttVtSgtacatBgtVaaSSaMVaRBcaSaRHtaWtWH
+ttMtattVcaMtWaaaNaccccgHYtcatagaaRtaaBaatttaBccaatcRctcatagW
+gcBHRtacaaDttcBgaHggcgctaHtgacagcSNattcctcgagaccBggtcaagWctg
+VcRDgVtaagtttaattatcMtgatNagYttHtYtagccRatagDtaatcNtaKtacaMS
+gDaaaatttgHaHtRDgtaattKtaMHgaBcaWtBNYaWgtttStttaSttgataatgac
+tMKatHBtttaVcYatgggttttaDKcSatttMatatcagtYaBtgVacaatHcaDMccc
+gtaataatagDataatVaaagaagaVtctccgaRgtRtaatcgagtcacttgttSatgND
+HaSNRcggtaSaagcSaBgWSgcatcaaWatgttacatgattcWacMtagtgNcacgatg
+atttttRcWttSgtaatMRRBaacNWRHaaBaattDaagStgatccttcaDacccctKaa
+gScSSHaaYHWcHcaWcaaaMBataattgDtagccWtcRHataMNKtMgHaBcatcgaag
+tgtaRgtgggaVMatgttaWRtStBHactaaRaactNctcHaaaggcatgcVHKHgaatc
+SccttggSaWatWtNcaaBctaRagaaacacgcttcKatRattcWtgYDaaaaaaNatWt
+KgaacgtNttactgWHBaccaWacggttcaaVgagaaacVtMttatagaagtatWtaaaN
+HYaMacagWagtaatttgcatcttcgaatacggaHtaatVattctaDaHtRKRaNHctta
+catcDKttMDKaWggDtaatcttYctcWtRaaaaKtaatcctgccccatgcgDtctaaVM
+tWRKKDctaatatDgactagWtaaaBcKcacMactMHHttgDataKHDaDttHttattta
+gtcaaVatccKWtacWtSVcaggtaatatDSatgcctKtatDtttagacKaaaagcgttt
+aaSaaaYtgattgtKtgBMcKttgDaaaagttBRatHgcaKgDgtgcWataatMWgcVaV
+atcYgWttaDatcatNaVgtttgggcttgaHRDaWgatttctgMHgtVtgccttBtWtaa
+tcgttcgKgRcaBaRMtaattWgctaatMaVBccaHtDagaBNaataRcacYcYcHcatB
+gaNtgaNgKHttctYaacaaaYgBttRNtNggaagcWtDggattgagtHaWttVacaaaB
+tgttaNctaatactKaMaaaaaDtaRatttDaaagNttcYcaaactcMgaYgtacaaatM
+aaatYtcacVaacgaaDagatWgBgaataggtWtKaaMtgDttHtgagttaatttgVaaD
+agttNMataatttaSVattNaDtKVccaaatcgaYVtaaaacKRaataatgaBDtctRtg
+VcttatttYtgaHgttBWatgaatatacSaacctSatNNRccagtactKagaRtgSKMcg
+aaDattttagtHcKcaaagtggtataaaggctcctaSatHtaMtRKattaNRcWtccgct
+ataKggatWttaggtaatHDRatttattRWgcgatcttagSgtcttactatgYgttYaVB
+tgcaYaaRtDaatacHHtDcttHgBgNcccataDtaaaaatctNtacatatWaRMBgaat
+taaaacgctctctcaagtKcacNacgVRVctttttaacttgctcStatRScaRaMataNa
+KagtatcattRttNaVatcKgtacNatttttgaNcgacaaKctHWtgaKStacMaBatgW
+ttNSacaaKcaDaatcWaKaccgYBggMScgaMcctagcaDatgtttcVatgtRBtKNWH
+tcctWDtatttttNNSaatattcMttgatKgNgaNBatcSggtctRcttttttatatggt
+NttDYNYgaaaKctcacacYHRgttacatacttYacaataNaagaaaagttataNaataS
+atacagttScacVaScaccSWtccagKHtaatcaaatVacatWacgBctccaataHaaYt
+MtacKacHttttKtcataWWtgtgaatWaataaaaacatttcaccttaHtttgttccaat
+cccgRBaWgatKgagtttBaVgaNtaNVBgcaataagaatagcaKRttgtatcaattaMt
+aacatataDBgtaaNttcaNcgagatYactggttatgtNVtaBNtDaaDtDttaSaWtac
+taVtHactttNttcttcatWttcDatKaacgtttggVDaDtVagttatgtcagactKaat
+caYtSgttttataaataDttKttKagacWgHgatataaatcttagatNKtttWtWaaata
+ttacSHaRgtttScttaatWttacgRRaaMactcatBacaccatRtttgaacctacttcD
+MggcVaSBagaatcttaKMagcaVtctDVataWtSgatagacttBctDtBNWgtgKatWc
+tYgaaStccgVaaaDattYatagtatcaacBaWYctgaaatttaKVgYtStNtcaVggtg
+gaNYgaRtMaacataSttcagacVactcaVaagtggtattaaDBNDaagtatatMtacta
+tatgatRSgtttgccaacgcacRMtacRYNataagatcMgttgatcataaacttVcatat
+gWtacaaaWttggaaactttaScataactRattMtDacVYataaaagMaattttKtgaBt
+tKcaacatattVtagtcatgactcgDaacDtaWctatRttSSYNtgWaScaaataagaaa
+tKtagacataatggNaatttcSKtVWtgacagKWattcgVatttcKWgagcaWgNKaaaa
+tatgtaaacgttcactaaWgacaccBNaacagaaStctgctaHcVtttMtcYttStagYc
+gtttBcRtaYacttgNaacMtDRtagcatgtgcgagcScaMgtaatBaKataactMtttt
+attaRcattattatacgtaagSNatVRgcttcgaVaacHNtctaHBKYgKaccYcttaga
+gcccaVgatttgttagactaaacgtgcaBgccaWgaVataggattDBWaattttgtBacW
+tttttaatDtMgaactaagcVtctcagBMKatgattgaNaVttggatDaSaBatttcgcc
+atatgctaattgYacatgatccacaaMHtttcKYKaWtYcgDtNaaDccgNaNcacacHK
+ttDtttaggctagRVtYgtaactagctttcacaaatYtHaattYacaattaMSagMactc
+ctcatgtScttcaaYtataaaaScHYaKcaYacactVcacataNtaBcaRatgYagVBat
+ttgtaactttgRggacaagcVacctattacRcaaMacHRagagtaVNctacagtgagacg
+aaaggKttacattgggacaataKNtattcaagWKttgatNagNtgctaNgagatNacSat
+ctNatttatctatRgaaaatKatNKSBcKactatacStcagtaggtVtcaaaBYYgctat
+tKtWNttcRacaaaNatgaacttaRtaaDSttVBYtaatccagtNaaacRttagaaccRB
+atataWaatKctcattcSacWaacaacactDttVttgacYaagagtaSgcMttBttaVNg
+RVagKDcttcttcNtaggttgcgacYacttaaggVHcaagDagaagataaVaatctgtat
+RatDtKaaSDgattcaattYtcatgYgtgaVMtMaactaagaatgRgDtHttaaccaatS
+taaaaMctVDDtgttatcttaBBgccNacKMaHggcBMttctgNctHggagaataYMgta
+MccaataattHttYttKggtKaccaactcccHtMSaatNactcRtttcatgcKcatgcac
+ttcatSaatatactttVtaYttDattgWcctcactcYccattaDDaHaaKcaatSttagK
+tWtcatRcaactattaattYaDggKtagtNcgSgtttKRgtDWtVHtDNcHWNtKtccgt
+ctagtatSctaBcacgcaBtaacatgagatVtttaaggcaVttBttaStWtattgYaggt
+SatBMBDactVtggttDagacataaactactBgcacaacMaagaStccaWNaaSYMYtgt
+aKaMcYSaHaaaatatttMgtcaaDScaKtcaBVtaMVMRRDMtcttRBgWctaacttga
+acNaatgttWgtggBtRttHVKgKcHVtatattSaaaatBttcBtttcDgHccBagtRBR
+ttaVagBctRcaagcattacKccaWVWtaVcggttatNaSgccgKtYcBaagcWgcatga
+NHaKtagNgcHcgtgtcataaaatagagacttgHYatattctaBgtttatRatctattta
+gacattttNtWaaSagtaHatRtctcggatttatgtgatBtctRggggcatWctaSVMaR
+tcatgKattgRcatMaHaataNcBcDcaggcactattHBgaatStatattcatBgMVata
+aSacVacKHatggttaaBKtgtaSaWMattttMacKtgaaWaaWgctgRatgtgDacBtS
+aHtDgtgtMVttagatgattagagaSttgattgtSaaacagHaaatacaRcaccBtaaDt
+caMtKaaStttatKagaataaNcaaBtattKaVNaWaNactagtYattaaagWgHttaMc
+KaSagatSactctatMSagtggaYctcacKKgaSMgcRgKtgccagNMataatccaVgat
+cttHagttttcttaaccataggggcttaDtYatcgaaaMataagcaaatBttgHHcHaga
+cagagaggcacWtacccMttacgtgNttattYctVaaactgttaagtKatMagttcacaa
+agggatgaVNMatgcaSattatcKagtHaBtgaagBcggagtWttVaaDaccMScactgV
+atccaRaSatattNtgcBatgBaaNgtcaBMgggaatgagtatRgaatgtNttacaggct
+taHaataaHSagatagtgVctattaaagggaagDWVccatcKaaaatRccccaSVaaatt
+tMtatStgtWagtStMaaatBctgcctKWgttDDaSKactctaaVRtaSWcVactggaaa
+aNMaaaccgcacNtaVgaagcttDNgaDBtaMaMKNtKccaVtgctcttMMYaaaaHaat
+tcWgHcgtacatWaMaaKtaataccgBDaYRaggatatSKcScYagMtaatKHMtaacca
+tgHgtagDaggtgtaaatatagaKVgccRYctcRaKBKWtgatHYcaHgBaYtttMcata
+taatgaDttcatttaStgtcVSgacggtggVgtBtgacatgtaaSgtBgatKtKtaYcat
+VtNattataaaHaSccHaaagctSMKattcatagcacagtgBRataacaatMttKcWaaa
+aatagStcggRttaattatWaataatMaYagatgVtatccttttHaScgtBgagWcatgB
+tgcctatcgtaaWHacagtactgaattaaaaaNattRNMaSSNSctattcaaagccVVca
+tattttagMcgtattNtVBactacScattgKVtataaKtttgNaWcttNacctagtgaNa
+aDcagtaWgKggaaKtacgcaaaYttatacSttgYaYttcDNagggttVDagHatSgtac
+YVatataVattataSataacgKgatVtVacHYRWttatcctaaDtgtaaDgRDttttatt
+WtaaDttggatcattNgtVaaaVggaaggcYgSWaaattcWHcgaSaVWaMatctMDtHB
+gttttaatctaWaagatatDKtVttaccgaMatRaaaBttaNagHatDHWcDtBVttaat
+KtMataYttSRHHcgtaHDtggttccaaagRRtaWtVctRcaNDttatacgatMcaatNH
+tacgaattBaatHtcccatctctccBtgtataYctatgtcgaaDYWtNggatNcacRtMa
+atNtKcttSYSctaDaaaggctDaStatKtataBgcVaatttggYcttaaatgatgtHct
+aaccaactttgggttcMaaDattatKtVacgVcScaactSataSccHttYctttgtggcD
+tMcactaNSBtMRBMaggttWKtattaatgtKHacttcaMVatctgttgtccaaYNtaag
+ttKaacttctHcgcWtYttatMBgBaMacaattaDaactNaaatSatcVtSSgatctatg
+NatSYaattRatgcDgtctataagagaagRgatatttcccaataHgttttWKtgaagNRt
+ctaaBtWcHHcDgaattgaaaKtgttaaRtatgtaMaggDttcMaccaMaattDctgYct
+aWtStaNtgRKaBtNcMHcSttMtaKccYacgNNctttatStgVtaYtaagttaagaBHa
+aStVKHatgttRVWtataMtSatgcaattcMcttatKgMcagtgaatcYtcctNaYctta
+ctttctcttcatggcgNcatScStBtagctWtHaaWattaccgtctcgtBMcaaacKctc
+ccaacttBgtWStVttMRgKcVagHttVtaagMaNatcaHttacatcYKttDBtatgSat
+tVcgBcBVYttHNtcatKgcYgaaSaKtatttttMtctatctaSaattDttcWagHSacg
+ttagYgacWaSaDKatcNgctaatgVSctgctYgaKgKtaataggtggagcgtcgaaaaR
+YtgYWYSaatacBgacWtaNStcaattWtRcttttaaSYgttcNgtBWWgtgaatHtttt
+BaMcMtKccagtattttcgaHaDtSVgatgaacatgcacgtcagagDYattBcagDctct
+tNcNtaaaatRctgMcDacaagtttagtcaaSSaagaaacatacaDtctctYgcaaacBc
+aagaBatgtattgacgagYacBDgttcgtgRtaMgaattttcNtgVcttctgtctagtgt
+ccatatctgatYatNtatVWgttacaDacaHDDagWtgataWtatcaaBRatDRtMgVcg
+aaattcSMagYgWacgggtaacaaattcagcatagSgttactBctgSVWatYcYgcBWgg
+gRcHtataSaattBcagHgcgcctttKcttWaggctttaaDtRacBactaaVaaKtaaac
+ctcgcgccattactKactKSDcgacaVtatataggataKctcgSatgHSatVcgtagtga
+BtSYtgaBataatStaaccaagttcaDtHtatattaacYatattatcctacgagatcacc
+gtVSttctYgtcataaVactcgWtaVatttgttggactaaaVcaSaDtYcgNtYtctVaM
+taattatWRtWcaNtaKcaaYggatgNgaatcaatcRtcgagtHcgVgttataHDcattt
+aagttctHtcgMRHtaaagaVactBMtatgaagtaaaaaBNtataaNttcKcctaNttaa
+DtcgMacgDcaMatttgYtaaNtcaccgatgagMtgttaggWcacHttNgtcttHYMcaa
+ttKcagttcNcaaaacgNaaSattgKttaaBaKttatttaMggHcttttaaRNVgttaYt
+tttMVRtYVgRatKcgVtacgaatttccBatBgYBRtSKKctaaaatgatatgBtcttcg
+tttgacHagtaattatatctgDtBttatgaDtatKtcKRcRttagattattagHgDNaaa
+KgcgMtHtttKtDtgaaaagtaMatcagaaccgaatKgtatatVaccRaKYtDHtcSagt
+BgtgccWaaaggtYKcaHatDDaaattDStDtcKggtMgcMtgtHtcaaVcgtttNtagt
+NtgKgctaDcScgBcWSatgtatagcKgWgttgaacgagtgcgcgtKaaaacgRtttcca
+tatatttttMgaKagcVcVRataccWctctcgBcgaggcgttaatgaHYtttHtaSWtag
+cagtttKtYaacaaataMtaNDatRgMBaBacSaataSDctgaactattgataaRtaVtt
+tHatWaacWtVaHaaBDtactYtaDactttSgtKtRattgatttatatattattataatt
+BatagattctaacDcRMaaggttcgtcatattRVYcttKgtRcgWaatcgaaWWatDcta
+caaaagaattHaatctgttttacYatKatBaccMaMaaVtcacStaaYgYKgtttctcat
+tatattNgSaaHtgRaBtcataKYtHtacttgtacaaaDtYtgatagNRcYatgaStaaa
+gactgtcWDtYaatVaNStagaaaWtaaaataDYtcaMatSVBVaaaYagaaaattgtgc
+DagWSaStattttaatNcacgataNBtaattggaatgcMgacattHaattctctaaMata
+ctaBaaattacaHWgBNtNaaSattttaacHtgtagtBtcRtttSaNNaYaMaDtatDta
+gaKggYgcaaSttgctactDcNRtWgtttaVtggcaaactattgSgaagtattatgDgcg
+tgtcttagcNtRctKggtMaHgaDaaagtactgtcgatttagatcagNggtaattaKaat
+gaaYaaHaattggttVaaMggatactctaBgtYHMcttccVcaaWtgttHHRgagttKaa
+agaBtaRtaaWaggttctatRatSgtatcYtaWcatgtaBtcaatctaatRgaYYtWtcc
+attataBacttWtcctaHaaaaggttgacgtRattKgaagcattSBtttctaNcSctSSt
+NtYtWaWtgtagtcttgtctttaagNKgaagacgDaRgtNaBaVDgaattggaYtaccSV
+YKctSKKcatagttgSttatcStactcaatSMataHcaKgatWVYtNacagtttBtRagY
+HaagtaNaaVVDgatattMaagattagcatcctaMaaMctgNtMcSaRcgctHMttaatt
+DtttYttcgataaagtMtaagttaWaaDcaatccKgtgMMcatBgtRtaHBcttgtBaBg
+gcaDcgaWttgggtaDaggtgatRtYaMWDttatcNtVcttRaKagctRgtgcNaatctg
+attatagattagtatatgaataDNatcYaggKRacaatcaHcaagttagtKgRatRgtta
+agaaaatacVctaaaagtgtaagKVgcttSWaaHatagHctagtDgDtSaVtgatcattt
+aNKgKHataKBctatatWaNgtttgcRaVNttaDgtcttagHYKatYaVaBtaatgaBat
+taYcNtgcaBtHaacttVtccatDagVaaaYgWtNDBgacagVgctcaRtaHaaactttt
+acaaggaSRaaatagaagaatacccVaHatcBRtcttttaaDMHWtHgacMtctcaagKD
+ttctgYctctcNagaMgcgaaDWatMcMatatttDctttactaVSctagttcaRKWgttt
+KRaVaaKtacaacaKttatttttggcctataaDgtcBctBDgcYYaatNactcaaRgaRW
+cgattgVNcWaatctgKagDMgctatKttRatcattMaagtctaRaVaattKctgaKtat
+ccgaaRatcHMaaaaaagattccacgtacgaDStatatctcataggtacgcgatgtgaag
+gtHYtatWagKVKgaMDcaatttWccttgKgagtctagatgaatgVRcctaMttgtaRaa
+YtRtaacWgaaaMttatcatNcgttactaaggtDaaggcagtRctcatcaatggYagcca
+gcgaatatagtgttWtaccaRctagatttDtaaatRcDKtccHtBWgttctWaagccYBS
+gtggaaagHNttHtctaaattaBatggaDMgaBgatatcaatactcMtaaKtcYccgatD
+aYgHDBaagBattWattgatttttaagaRaaggatggYggaKttaKtBVBcttaWcttBt
+acctYaNYttgctgtBaaMtWtcWaagtaaggWcgMDaaNtccWMWtatcMVgaSaRcta
+KtBgKWDacDgaaaaNgttcaaaaataMcttaWtatgNaVaaRataWtgKctRatataag
+tgttgacgaKgaNgtaHattaaRagSgattctatgtYtcaattagBYBatccYtgtNacH
+agHtacVcVacaacaccgNgBtataYaatWHSttattgctDacttgtgHgHcMcHacagc
+tRSDtgattaggaDHtYagatggagWtaMatcRcccacRaaaYagcagatgatacatatt
+tVBBcaaMtctctaWgaNtttcctaVcttaYBDBctRgSaagcNgatttcacgtcRDaVB
+ttaRaggtaaggHcacttccgDBKgagaatttataaaMaRattagcVgtttacaaagaga
+aaMtgDtttYttggcttataKaStacaVttBttcttgBcVaataaagagtgagBgcgNcN
+attgaaacRcactDaaccaatWMtaaHtBgaaacaaccctcMctcaaatctMWttggttt
+tacttagcRtttacatRtccBttVcatgaaBacaYgagHttatWDtcctSatRtYggHtN
+MttRgNtgcatcacgacagaHgtYaSaactgaaNWVagtagttagaNgatctgcatWYaD
+acataHtaWttaatHaDgactYgttcaSVtttacctaatttaDgRcagacaDtgcYVtta
+agaSSKBYtgHtDtNtcgtcWttDtgtcNtgacKagcactccDMacDNcccctWataRKc
+aaatttctRVaacagcaMtataaattWBctttgKgVcatttaVgtDgtatHtgtaSctag
+tatagcBtBtgtatgtcgcMcgagttctacgaaBgWccgaWatgcaRtWtaagYttaNtc
+WaHtgattYDatWRgRWagtRcHggNatNttWaaacaSgcaatMatgacNgggaSatgat
+ttcBHcctaaggWactacagaaaagctMcaaagaYtHVgtaaHKgKattVaWtttcctaW
+gaKattatgMaattBgaaagtgaSaaaWtSNBtttYataVgNatgaSgcBaaccatattc
+ctctagRtattatctttctMtgaRtctcYgaatDtRcHgcRVtWtaacDtcacYatRctt
+NgcgaDtVctWtacHtatatgtatKaaggtaNcataKRaataacacDctcctWgtSaWca
+tcDgatatBtaatHSNBtcaataaStHtacttaYaDaMtaagMtgNaaaaNccccgYWHa
+atgcBcttaBcgtMBKggccaVgacaWgaaaaaVYcRKctMgcaccWctcSacttcVtac
+gaagtYtcctttttaYgttattaataactSttRggtcVgagWRStatKataYcaatNMta
+cttcgcttVBaYRaKttaaYatacagctBgagcttcHcaatBaaaVcgctcacaMgttaH
+aggctaDtSgatattggggBgRMagtaattggattgYYHtVtcttSRYaacttataBtNK
+gatVaWSDWacatVcttgttgaagScaDaSttcactaattagatKttaMcHtMgKccaYa
+tKataMcKNgattgtYtaaRHHcaWagctgtgcYatMHaatRDgtgttYctatNKtSDta
+KgcBttgagtKtacatgaaggcgMatDaWtcBatagtaaaatNYtSVgVatttcaNgRta
+RaaNBttggaatVgaaaaagaaggtgNtttVBgccttgtgaBtgMgtaaacBgtactWgt
+aacctatatggaSYattYtVgtttaagccaRtatRMcgWMgDVSNgataatBRccNagag
+StHttBgctaBagatattaacaagaggttttcDaRagtcDgtHttcataagaacaKBtta
+BgactaRatgaaDYHttgVagcMcBDgYactWgSgacBataMMcttSaRHgcagKcgaaY
+aDgttcataYKcttcMWttattaaBacDcttDtttBcatVggttVHtgtMgKcgaaVgtc
+gMaaHHYBMaHtaaKaDttaNgNtttttaggMcWttNaaaDaaaaactRgaatagSVHta
+ataagttStccaatcHataatacMcattHtacaatttctgatggacatatgcaaacaKBa
+tgcagacagVcctccgcaacNatcMaHtcMtaSctgtaYgtStcBtcatDacRggttRga
+gaaHatVcttYWgaDtatgYcaBKgtSWVYtttctWttHtctaYttttaBtcataaNgtB
+RaNcgttKgtgVKgggVtWatcWagttSttttttaMaRWtccgttttattaHatttBVta
+taSctRWtgcMacaattaStBcacggaatRatactVgaagMaaagWacaMgctaacaHct
+HtaatacacgaYagtcttKagcDttaKBHccgtaHaacaKVtcMKcaataaaNaggttSa
+atcatgaNaaBtacggBcaagatcRgttttHaNgtKctYatBHHtaaaDNHtaVtVagtt
+VacKtcYgcattcatacaaagtaacKaKKtaaNtNataaNaaSaBtagaattctgacacN
+taHtataBDttBctataatagYSctgtaHcgccgaMBaggttaMHtKgttactaaHaacg
+DatataaagcaWtgaMtttgVatcKaattcgHVNatNgDaaYtataHacaaacaagagta
+tatDStgcNgcRtaaWVVaDStNgtcaaacgDttaaggNttWcaVNaccctgaaaMcagV
+YVaMtBgtatacSacgSgNtaaaDtRaBSaWcNacgYaggtcaYtattagVStaccgatg
+SStMattctWtattHtHaDtatgYaatattgttttaNggttVatcttRcgaNtHaVaStg
+aagactcacaaatcactgataaKBtNHtttctWWtattgactacNtaWatataaaBaatB
+ttgggtatYtttYtgttttVttgagtcVaMVgaatNtaaNgKMaacgtaatattKWggca
+gtgRttgtgacactaaYacactggaaKaWYRgcatgcgttctBcttggtVaaWgtttHag
+tcaatctcggaNWtaatBNcaMVKStaNcMtgatataatDYMctttcgcatgcYtHtVNg
+StggagcBtggMgccctgtgNtVatactgcctcHcataDBtaStgNcagaYttaMtcaYt
+gtagatDaagaHaaaRcRataattcaDtcaDgttgtatRaaaaYaRgtttDBgDcgaagc
+NttgcVttcacttaMgtMWaYaattcggaDcgaVtYattaBYaaaattaHVttttWaacD
+ttaRaSWactcBgaRctacaVStBaaatRgaacMSaagaatagYtNctcaatagctNtta
+VtgctgtttgYcttaatgtgMaStactgDBagVSggtSKMYttDatgtMaaSaVtccSRM
+gaaaactHaatWWtcatttctDgcMcggVtgtRtcatctttNatcaatatYaKaaaatKW
+tDDDaaactaagtacRHtcKttacaataggttWcttataSaYctgctVtaaVggatccta
+HVttgWtgHtWttaDHaNgaccctatatgcWtNttacctaYtttDWtttaggHNgccata
+ttacKggattVatatcRcggRWMtgcaVRaaHgtaataattttaggtctcDccaatatgS
+aaaagatDtaaVtYgNaHBtcaYttaaaaacagatataaagttaaaDWccMHMattggta
+aagtccgaKtatDKaVHaBagaBatactataVttDttDaMagctctaaDSggtttgaDac
+acVatcttNtgatKtVaBStatgNtgDKYcaatcataWtcNatYccgRtcgBHacaBaat
+agaVtagcttgaKagcgHtttDNtgaagMttSttttgDDKRWtagtaBgtgagtgBcaDt
+WtaHcctatHatttgttWgagcggDtgtRDRcaaatagcacacRtDgtgVaWtaattRac
+VataBWacSYWVctgYtWDaVtaKataaacttKaaaMVHaaaaKNtaaacttgVataaaa
+tMaaatMaagtatcaaRtatSYRtBtaataattgtttgaWtaNNtctcaatNaataaaaa
+aattgaaaattattgtgttaaYatccccHtaNcattcacttttaMgVDtaDMtcaWSgYW
+cSYtSgaatHtgctagaVattaBtaaaYgatattcgaaBtgaaDacacatRaagcgggag
+ggDMtatDttaatttggaKSNtactRMttactgtBggcgtcatNttctattaVacgttcc
+KtVttMacttWtctaYcacgtaVtaaRgKcttggatSYatattttgttacaaMgtgagag
+aSatattWcagDttggNtNaaYtaggaaKtYHcttgKattWagNgtaagHHVatYatcat
+taaaaaYtHgttcaaaataattatBgcaKWKtagaatagtatBagaaMtattMagaMtHc
+WgYcacgttagtgtDNggctatNatRcYYHtaacMaSStattRagRcgataaaatWNNat
+gaaatttVtKcRtKtDtaaMcctccaDRcaHtBSWcYtaKttcacaaMaataaMaactcc
+gSgtYattDtaWctagatBtaatSgatgatHKgttgcaaaaagaScHtgaaHRDatSaga
+tcBcggcatcatYVaatgMaatStgNgWaaaaMttgcYaaagttSHaYgaaatHattBgt
+aaMRagSaSacBaagtttttcatgttaaYcagYtgKtYctaStcaagcgtaVattaNatW
+tHgtHKNDtcNaKaVaStSacaaStttagaaataatgcDSatgtaKtgMMtcaaagtNat
+tacMYgtgctNgVcaaNcDtaaaVtYggtaaaactgcaagaWNcaaacctDSaaSgVaKt
+ctcatataMtggBtaRttKtagRcctgttaHgWRaattgDaaatttHtaccagctcagac
+cKaaBctaagtatWtaVagBgtttatgaHaaggattStaactWacKDVtMHccgtacaMW
+YctDtagatttRctaccRagtWcWgaaaaMcagttctgacSctaaaactgaatcacaNca
+MWtWccYgtttNaatttggttaaNtggttSattttcaacgYVccMtcgaactBtatcYtt
+cYDVMttcgattaKWtatttagcaatatcagWatgcRVaatgRtacWaVVBttggatRta
+NgRagttDYataacDVBcaaactttgtttgaccatagHMtRctaWcgacagtgcVcaaVg
+RgtaagtRaaaattSBKacBaatcagaatgtHattcaVRtatVSSaKatNataWRVaaag
+MaacataDgataWHatcNYcMtatttggaSatttcHcgacaYcaKaaatattacHcSaBV
+atHacactaMDataaaggcacaacaSacctgtaaRgtcccaaaatWtDtagtcaagNttt
+gatDacDgcagaDcWgatDaaKagctDWtttatatWgDcaaaWttStDtKtatSagVgaa
+KtaacgaccgMgaSaatRRcagYtgttNDggcHScaaYDWtcaacgtaHgaStKtgMtRt
+aatccagtDaaacHgtacaaccHtagataNaattatcVtgaKaaNaaaaaaaagttgMgt
+cRaNaacagtaKcaBgtttgaMDgDMacttattatgaDgagcgtcacaaRaagtYaggMt
+aaactagaacagVaMWataggtatHagtttaaHtcagtaaatgRgcatgRctgaMttBaa
+ataagWVtcHctgtgtYaaaaVtKtaSaaBatMtttgttatattattcaaBYctBWtgga
+tBtgaggDagtgcacVataRBctaBaaaataatttttNggtccgtVaaaaataaattBHa
+atBaagaHgttaagcctaatcaaatgaYtKaatYtaaggtMgaRggtWgggNactaacga
+RaaattSttWtaataaVtHgtacttNtaagHaSacgWggaYggNStcctgacgDcgHggt
+ttHggtNtMtttDatNDgtgacgtatacgatKatataaacaattSaaagcagatKtttSa
+gcaaMttttgaKtMtagtcRacctKSttBttaatMtgcgttacaaagaVaataattcaSa
+aWcBVacYKtacaNBaaKRtRtcgWtWBaRKVtYWWWgattgBctaaatKaattaYtMtS
+BMBHDtBtaggDtcNctWYagtgSaaBaVtcttNgtcgttHtgtMtctatKtatVggKaS
+aagtttattttatgtactactHtHttSMactatHcaagaattVataaaMKNtaMccgtga
+tDaHcaacttRataacaNgaatcSBtatgacBcctcgggtaatWaaWtacacaattctRV
+gattctatgtgtatHagatagggacVaattttDtNaWKagtatatHtagacgaggtatgt
+cagtgagHccccaatNataKMBaHtcWgctagtgHaatBatSataDatatcacccaagat
+tttcSatKgatWtgaagtcBMataaHaaMaattatgcttWWtttcgVKYNBattggtact
+tcaaMaVNcctcHatcgctVcttKatgtctctBMggacatcaggacSgaKttgagtctKV
+YaaagtaaSgaaaHaWactgRattaaBttVaHtggattagRWtaaDaaatgatttSMBWM
+aDactScgRYtgaVagNctgtSBataKacStHRatctVgBKaggccaRctaacttcYKtc
+aDcttgaaacBBataatacYMgWgctgtacttttatgaSaaatYcccgattattRStcca
+aaBagaacaaaVtttgcttatagaaacacScccSaNtaaaaBgtaaggcDgtSttRatMY
+SWatcgtaacgtStBagttaVaaaScccSggaMDBSgcaaKaggatatacgtatgcWact
+ccgVctNttMaYtaaatKaaatgKStaaaHaKatatgBtcctatgtVaBggaatBcgcaa
+tgagtatHcYagctDgtWaaccagtatWWtaRtKagatagtgKatatgaaaggcaWgtNK
+aaagataWaatHaaaaaKMaaatttBtatHtctNactKtBVVagtatcacgtMgtgttaK
+taatcgaaMHtYKNcMaatgcaSaaDBaaaaagaWaDtWMgaacatttDcatttaBaBtD
+ttaaSMtcagcttttRWWaataattcNctactWaatNaBaattaagaaacttYRHaccat
+atKtaKcNVgttYagttBtaaaaVtctcgVctagctcgSVatatagVtMcaaHRctaHSt
+ttNtcattRaatgtaRtgttaatYtaagcattgaatttaKtctaKKgaaggtcgMctttc
+WaagcgWaKcttcYttgtgaRaagMtDatgWgYaataKaatSWScatKBtYgtaagagaV
+cacgctHStaacaSgBtgtaNRYaaWtWcKgaccDtgaWtgagMaYgVVgBaRacYtcKg
+atcagttgtaKcgttgagNaStctggaatVtactaSNtaaagtaatcaattaaVaaDatt
+HDBaHKDHctVggcaaacccKMaatVtgttacBcctStgBgMtScgaaHcatgctMtSta
+VttttcDaNagtDVaatYcggaDaYtaactaNgtccaattSacaaaaRgtagaaKgtcRS
+NtgatBacccttMtactatKgtaaRMagataMatgVtVKagaRagtcagMgMaatRHNtt
+agaagaatgggaatcHtttttSgtNgYatgtgcYtaatgDctMaaaMccVScgcRgKNaa
+agtaMtacaKaMNaBatagBttttcttttYatataNaWcagatttgMtgaaacaBYtHaa
+atgtaDactatttNatttKttSattgBatSRtgKHttacgattgcggtaaaaacHHtaNg
+McgHaVDtgtagaagatBaaagDttaacSatttaatttaccagatataattggVgaRctR
+tcgccVatRNtDgcagBcVaHtBaatDttatgKRKagataaRgcagtaKgagttatatca
+MSagttccRcttaaatgatcttataaacaaatttcccttaBaWtagtagttMaacMaKaa
+aagHatYKactttRatgtctcgattBcSagaDKtttHtBaccttNttVttVVtggttacg
+taaBMRgatcgtctacaaNBtaVggttYaaggattccaNgRgtagBtgtaBacaagtata
+aatBaaatKRtaMtKHgatcgYggDSgKRaSttHStcatgtatatWacacRacHcatYtt
+taacYatatgtgttNtgcSagDHgataYttNattatcVattcaaYttggtaRHtWtcgaB
+acgtttaBaccaBaatgtcgcNagaNtKtaDtgDtatgDaBtcKgtBgatacNaccDDat
+ttYtKggMtYNtaactgVacattaaHgMttatcgtHMNtataBtKSgccaVttaBcttat
+tcBaagtgaWtaRtcctDVRatgaattgatatgaWgccacDaatKaHtttacatNttaWN
+WgtacaggctacttBaYaaatatacaaaatttcgNHgMgttHctcKYcttgMtaacBaDV
+taatttacagaRttttttagcKagtKactatMRtgtDtaattccRcaaKSttagttttBt
+ctatagaKaVttttgcNagtKVccttagRgWaNaKWttataDgcgaatgMKatgatRcYt
+ctgVagaccgcgVgactagaWaaHNtcRNRKaatactcYaNtSDKtcVVggNgDagttta
+aKRgttaDcgtNNgtcaYttggtttYtatgtaaaggattttagatattKMcatgYaaatc
+aVactcagagtRYtgtaactatagtBaDtVaWatDatctataaaSgggtactaYaKKWag
+aaaaataaattatagRcaaaVataVagatatgtaggcWagacRWattctgacgcDtaBcY
+attgtaDggMatgagcgagaggctaaatVtctcagRagDtSgKNcgtVcStacatttagN
+tgatSNgatcYVtHattHtBgMacRaattaHBacRcNaaccctVaaYaattcVccatacK
+cttSagtctgKMNagRaNcatNgcgHattStSKYRggtcagtcaccattttagtMaccct
+ggVattHaatVagaaMaattaVacatacacaaattaattacgtKtagaaaMgatWgWcca
+tYtagacKatctKatMcggYcgcatgHRtcStVtaatHgSaaaVagtgaatgtgYtatta
+YcRagatgatcataacacSgaYaactMKttatRcgaataaMSatacNgaMatttcggcca
+cgaYYMcaKattRagDtRtatMVBtaattWtMHgNaWDgStaaSNggStcBcVYtaYaga
+HtacagttccMcgtYtYttcattgSWcttagttcgtHtgVRYgaMacttBtatcaactaa
+aaVtDgataaDgtatcatYDttaStgccBacctaaBagttgRtaSBtaaaagWgcacBgg
+ttagcMaYatttBgtaggtRBaSagttcacgtaDaYaaaacDSaKattctgtSatatgta
+tggVBcctctgtgaaHDKgttaRttttBMHgRMgHagtagMgacgaagttaatattgRtH
+tHttatYaaagcagatgtgattagtggcactactVattagatctctgtttatcattYttg
+atHcHttagStgatgactctDaaatcagtgttgtttttcYaaagtatatcYcaSaacaVt
+tcgWtatKaaaHWtRgtttaKacttctgaaNaYacctNtcStatttaaagttKgtgatcc
+tBcaBtctttaaaKagttgDtWctDtgtgctataKagtaNHatctagYgatcMgtggYaa
+gactgacacttaRaaccHgttcaYtagWtggtgBcStacaMcMHataaaNagatactcca
+ggagttaatcatRttttgaKNgSgcaggtgttRaYcaaataBtaDtatHgBtatacKaat
+aKtaggaaatatgcataaHgaKttttatMaaaNgMatYattgaatNtatVaggtKctttH
+attcatttatYtattagtataYtttagYcattagaaataHtaaccttactcatYttHMRa
+gttctDagNSVgcgVaNNattctVcaaVagaatttaagaggttttacRagtagtaaaBaB
+aaMtaScKgVaRcNtctgtataagtatVgtDgHaYttcHYttaagatRgtgaattctYaa
+aattRtcWtacDDaRatcaKtaSacaagctaNttRYagMSDKtWgWaYNgaaaatatNta
+atatHMtMWRaRacaaaatgctgctacNKaKtagttgVatDaVccatSDtgaSggcgWat
+ccBgaaVtgtaWttagatVaBWtacgWtaYattaaatMctDgDaaKatttgaaatgctWc
+tttaHtggHaBBSRVBWtgattgagatccNcaaaHttccgVcttaDHtNgtttaMggccV
+WaagattgKcaacgagtatgtccctctcttaccDtHcttcctBatcStVaactaatctac
+atgtacataacDgcgaVttataagcaaRWataattcggtMaaBccYgRctagatctNtBa
+ggacMaaaNgctgttHgScgttaaVgattVDtaaNaccggatatHatKcgataRtaMcag
+ctattcaagagaatHcYRNgNgcaWtgagYtacttNtaagStaVVagctgcaaggHatgt
+caWgaattKttgtcgaBcKatKKtDtRtNYNtctactatgcgatgtaacDtcaYgaactS
+HctDataKtcaagtccVRtWaaKMRtagKttaatagtggKttYtaKtVataWYgHBatat
+aatcatNMRtDYaYcttgttHagRtYacgaDaaMMtcagattBVScattYcaataataBW
+aBatgDtBaKaHacagtBggaVtgtgttRtgacataaagtBtaVgttaNaatcaSgcctg
+tcBBaVttctHgVttcttgttatccaatacaNtgcgctatacctcatHtNaBMtgtagaD
+tKagtHatacctHgtgaDVWtatcWgtatScattactSgatcWatatDataRSgctHaaW
+ataataYacgtacgtgDatHcgtaacSaaagYaMataYaactggaagtKgattKMaatSt
+RgtatVgttcttKSMtcataVtttaDtgttatattagWtatNaDcttgccHaMDttStgt
+ctgagtRtatRSMWttaStcatattaNaDtcaatttaVatgMtcaattagMYWaRcNtDt
+tcaaagMgagaVHtatYaacggttScaaccVKHaaatacWagaataaccMatWgctDtat
+ttgaatBtNttgaaBgagaaWcttggatcRctctaDagWBcacaatMStBcBWtatggta
+gtgaagaMKatacttaYHtNctgttHSMaWttacaSaatgtattttggccatatSatcgc
+tctttgaRRVVtDaatcSYHcSDNacattcMDaNVagatctSctBcatagtggHagaVtg
+tSactctSHaMaWtgtatcattWtacgaaHatatBaaSaYacagtaaaagtVacatKtat
+atataVtagcgWccacagctcaaccttRtatNactMtcattaaatttNaaggctgYctct
+acatcaVgcMHaagaBttcgYDaSRtHgaaaNcaWYBggataatBactgaataYgcgtaa
+cccactHataagaaWgcgRacccagagaVtataggcttNtaaaaHatacatttttYYatH
+attgaatgtNcttatNaVcaaRtKctcgaaWctDttttataaatgatagcgSttcVtgat
+ataaataataBgaatgaRacgagtaRctttaactattNagtcagtgtgaSgaHRacgVtg
+gRccatttatgtMtattaNatgttaaatRaBRttcatcttaRBtNtaNSWgtVSgcNacB
+tWaDgaaNBMgagaBMgaHaHagatttctNtWatcaaaaDgtgcaaWaataBattaNtat
+gDaMaWDataNtctatDagatSWctctggaccatcaBgtatattaaHacHgattcgatgt
+RtaYattactNtWgaaRgcgDaatactgWcKaMacRSaSaacDgtgSgSRaagNtKttat
+tcattaagtctgtctctataaVgctHKttgVtgacgattgRYcatccWcMtaBagaHaca
+aaDaaaRVgcacatgatYaatatttMttaaWBtctcgaNcWDtttcagYKattaRtttag
+HcKaacaBcaggtaacctaHtaMtttaHacctVacctaaagtcactttcWcaatggatSa
+ataHattacaMggtgaaWaacagaaattgttggRggcgattatWtaKtScWKggtttctt
+gtcMaRgYYacacggagtgccDcDattcaaacHaacttSScaaStMttaYtgtcWaaaaa
+aaataBataWaatatBNttcgttgtVatgacaHtgtacatHtaatgtKcatgSatacVRc
+VctttagNttaatKYgHtRccttDBggHgDtgaatcaagacacWtcgRWKaactgRaDNM
+actactgacaDgVgatcaagNRatacagattSMttaattYtgWctRgttaaKMgggaaat
+aagttatgHaScYaattccRMggSagaKKttRggtttgDtcgtcMttttggaDgcVctYc
+aaataattSctDaccatNataDtaaaWtttagHMSSaagaaBgatYaaggNtagtgctcM
+aatttWMggtctatttggaKagaggatWcatttgctatcgcccBacacttataagaYtcN
+cagaNatcaYHgNgaacRgtaDgaNYttcattRtagNDcHNVcgDctggDatDtgNaaaa
+aHgaYagtRtcaaDcgcaKatcagttattcataaccNaatacacaaYWcatBaaaacaRt
+tMgtaattctWttMaMtttccgaNcatVtgatcBaRtttgSaactcaKYaaNtKDttttR
+agaMcDYgcaKcataVaaagattcatatWcHtagtagatttctBtcWHtctaRgaSttgH
+atgaHMtNtaactgaaaNWtDctgDcacattMctNgWattatatctSttaScctaDaata
+tDYataaaaatataatNctKaNaatatcSgagttaagtKDttaaStaaHtttaatgaRat
+aBtaVcBtcDWWaaDaacacRNtaVggatattatagtBttggcaaKcacRNgaaYaaMRa
+HtatBcaaacNataKacttaMtaacaacgRtaattgggaRcttagtWataactKttDccg
+aMcacNHKtattStaRcSStDttacggagagtMtaNHatttWRNVgaaacattcScatgc
+taVSttaRaMagatcScaBggtatacgatVttKcVtagtgccgtcDtagtRagggcaggg
+RRttKtcgtKDRaaatgatVttDtcatMaNKtNacagMattgttcaacKaatYKttaact
+aatgagattttaBattBctcaaRWgtYtYBatDcattggRtaaHttcaNagagctcaRat
+BtaagHtctcttRatagBttHtgatgattgcRcgtgSaagcYaccacBWgtaNtctagac
+gaaSatBNtHMcKagttaaDcHtaDaaDtttccaatMcaSaaacWWggtgDtgtMtcacg
+gcgcWttcBctaaVatggaagNgtaacctagatggYKRVttRtMcgttaagccaHgatHB
+cgNtctMKDcYtaVttHaaDWcYcKtttttgatatacataggaaaaacWgctgttatWHa
+ggatcgtggcataagaaaWtttgatcaagaDatgaWtRtttgMagcBattcNaatNcKga
+atatWBBcttKVHtgcagtagaYRatcggaagaRtattaBNttattaataatatgttttt
+aagMggggMttctBgtcgaaMctcctaVttRtBattaatattgVDcDtggtgaccBaNtt
+DWaVtaaaaactHcaVtacKMtgaataacggHtaaaatatataYtacBcattttSaaStt
+gatcatccacatatgcYaVcattatcaagacYcMaataagaWWcBataBattcBtaKatg
+taRgtKgattaSttYaHcgttHcacaatatKatgRMgatgatgRaattctKNMRtggatN
+ttttagYRtgtgYttaataaDcttHaDcctttgggMtcgcMgNYtcNacttKtttttgYB
+aHMgcccgggtWttatVttttMtVgaHagDNtccBVaaagtaKttaaacgaYgHagVatM
+gaacBaSacNaaaBcagaaaatatttaYgaaSccaRacgctgtYcctttStttaacgatV
+WaatKtaBtaaataVaBVcctgKaatcaggaDYatgVcgctaaacVtcHctggttaDggt
+atRatttttaaatDttaMtMaggtMaattaRcaaggaatVaaaactSRctatttWaDtBa
+taaBaaKattScSVgtatcWaaaBtattVtatttttatYtaatacRKcgcgYtccaacVB
+tagcttYBtgtgttaataataWactatataaVccaNtcaBtttcMagataatgactMBat
+BctaaRtatataaaaaaRacagtatYgtHgcaDgaHtaaNMMStKtDgtaaaaactgtaa
+ccBttMaaMDVaaaggaVatcScMRMaBttctSgacKaccKcDgaWattHVtKaNcDaag
+RSgcgcaRgagtacMKtWaacRtcKKtBYgtagNtatgtttVttatcRaWtattcgttta
+DccttMVtatgHagaBgtaMWKtcVagaagcaaaaStaaatgagaWtttDttttagNMgV
+ttcWagacDgaMatataaataagtttgcctatRtttNtcttggMtggVcgaMaBMgaatD
+tVaDgttaaacgaagVtttNccaagtgHgtgtcScaataaRYaactgcVWtaNRDccSgg
+agttattatgcctMaaNcgtttVgtcaatctaccaDMtaattBaatMtKgaDcBggatVt
+aattRBattgcccatgaNtttMDcKtgcaccttccBccaatctgDgMSgaagcactctaW
+tattgaHgcDaagVRgtaBtaaRtgtYcYttaagataaaHaHataattaattaStcttcg
+atHWaaRRSHctggttgtccaacaDttcaKggcVcgtSBctBNaRaattcgcatagaMtN
+attStRSaaattVtMtgttNYaatgtaHaKNSagatcaHctaaaKKgtaYatDgaaaBKS
+acaatacRgDctaSagVcagDgtYMtcatcgttcRatgaatgtcBSKtSagcttagKKcc
+gHtBRgttStgtBaaKaMtaaKHBgaVaVattaatNNgcattgagtcaBaggMgctHtaa
+tatttDatcWatagRatVaaattNttttaaVctYagtRaHttatttaaaVtaccgtNatt
+ataKSRcgcagMgaaMccagaatatMgtgNtcttNtgattaBgaaaagatWtccNtDgga
+aagaNttttNtttSggtDcaaagagtactccattMatataHcgcHMBtgaaKHSYtctaV
+taattgtacctctctaaaVtatgKaWaacagttYaMtNgDYtttcYRtgYaWaaaacaga
+taaacgtaVatNaaBtBattcctWaaggcacatgWtttaMtVtagatatacgataMtttg
+gtVBagatctRatKggttgcYtacSaMStattBgcatttKatKtVgcDgcttNaaataat
+WNtaDStRaacHtacttacataatacaMtYgcggcatYcactttttDtcaacBtgHttgg
+ctttHNtRcgatctcactctcattMtatccgattaggtgggNgagacgttctDtHcaaat
+acaVaaaHttctcMaNtaattHWaMYgatNacKNNMatcRtNtYMgVtataaaatttaaa
+BMtaaaatBtaaacttgMataaaagBaaatBVactagaaaHtWtKRHttgaatVattctt
+tgaNgaDDtatcVWtDaataaaVaaatgcaYaaggatgggcttaaRataaacttVDcatt
+caattgtaBcMtgYtBtcaMKcRNaKRtKcaatttgatWgaMagtWtgYVaRcagattac
+aWttgaataaaaWgHaagacggYccctBtWttttYVtttggatKBtVagHBgtaatgttc
+gaggaWtDtgatattaMaagttcattMtttWcgtNgcgaRcaactaMgaVHctctgcgag
+KRatWtggtcgtWaaaBctcScVcaHatattNcactttccBtDaaNtYggaattRtcggc
+taggNVgDcgaacttMatNagaagtaaRaaRttggtaVSaagaattattcaatNttWcaW
+taggattScaStgattBagVBttaNcNaSagttagtcttDccctatBatHaRRttaacBY
+KKtattHVcHagStaSaatNDDatcSaVgtgMttaHttgttaataatcaYtDcatttHNa
+RgWtgtaYcaaBaagaatYaagaccKggRattttaNcgacStttaatKcVtcYtttcggc
+aaaSYacaKattgSatHtWtKVcagatccccStaatRMaatgtaatKtcDgNaYaaBttc
+cRaaacttHtaRcaaagtatgtctaaBDVcKSKVatSagtggttaatcttaVNaagRtct
+gRataKgcaagactSKattaBatNttggttDtgcDataKaKgKacaWHgttScVaagaWt
+catHagcgattcBBtcWaactBatgacBRctgatDcMaaVDattWaaKtRcctYVYacgg
+aaagVNBaaaaaattKYaKcMatgagcatStaBtcctgaHgtttacHacgcttatgNHWa
+tgctWWattttgYaaacctaacYcataVtagVagtVtNgaMagtcgttatcYtaagcatg
+KgaaagNSattKtttaaggacaBNRatttacatttHctaaaHactNcNcaaaYBcacggc
+tcaaHagaaSaagcaWtcaaaDaaBNtNacRgtttBSVtttccttaaDgcctgKSttgtc
+aaacNMcaBtagaWatttVgcRtgaRtMttgccVttatNtatggacaaagWgcacNatca
+DMaWtcHgaaNaMMtttgcatHtYDcDactttRYtaaatMtaVaaattggtgtcaacatV
+ctBtHctYNacaaactcaMaaaMcHgtaactHaaWattKttactYataagaYgcttatta
+WMDgStMKKatatDataNHMaSagBaaaVtYtgVtaNtataDRcBtagttcgVKagggat
+acaaSRaataaatagtaataKatMattVaSatSBtagVaYccaaaYacaKSactctaaHc
+taaaSaaagNttgactaSacDtttcattVctccagYtcNcagtWatacattNgttagagN
+ctaYaYNttKgttttatKacMgRatgaaacVccgtcaKaatHHcacRtgtgDtccatHaa
+aRtNgcaSagtStgWKtttgBtHtSagaaacgtaSaatctacWaaattagagaDaWgtat
+aMtgataaDaaaaaaaagttcBggaHaDWWcYctYtcatctttcaBtctBaattattagc
+atgWcacgcaaaaDaactRVccBtaWaatYcVVcacMatNatacctSgtWgtttaattca
+ctaaagcHgaatcHatcaBtgtaWatSScMMgctatctctRaaaWMgttaKaatagBttt
+cttagaggVttcaatRattNtccatttcagctactccacMatSHtagataaaWgaagttt
+gDcctaagtMaaaYagaaattttVattRacatctgaaccataYtcaaatcaRttaStRgS
+acctBcaHcgtMcccBaagaaagaDaaattKttNtaataaMgtctYcttDgaactaKaac
+NgcaRccDKtcatgaagtactcgtgttcctBtBtgttatDtctgaactataacagtagSt
+aaaaaatgHaaacaacYgtgtgHacaaattgttcSttBtVctaHaacttKtttttWatBt
+cccttaaVaacaMaagaattcaKaSNatMScRtgaaaDtSStDtHtacNtNtaHtMtNMN
+NcWtgctctaaWttaattaNtttKtBttttttagcttcDagMNagtcKWatVMgcttBcg
+ccttttgtBtatatttYtMgctaKaacttgattttatctaatRagtttggKBSatagtaV
+VcaattMataaSBtDtaBaactgSgtatcaactgHataacaDcaRtcKttatgaatcata
+cgcgaagNYaNgaaacaattatHMgYgtagatctctWttacatVgcgRcMaagttgttDa
+NtScgStWgtgacaacacggVgcgaSctcactcaaaaYtDatatBtattaNgatactcta
+agtWtKSgYtatataaaaaYagaggttaKagtcYtNtgaagtctBWgaWtaaBaattStc
+atgNNtttagMtRDtWttgctYattcVSBaMDcagatVgccatMatttatctatcgtBgc
+ScYtaaccaaHcattgcagtcttMNVaactWWKcaaataNaatgHatgaatgtMStgcca
+ttacHNgVataaYtgaggtKttNBVtYagKacHRggYMacDatcgKtatVtWaKgtHata
+tMgttScgaaVHagaaattaNttaatatgcaaacttWgRagaaRBcNcatctaagtggat
+gVKaaVgNcaccagtatgHKgacaWatYcSacaRaMgttgcttatVcaaWcVaKaaaKaD
+taaaatcgVaccatcgKgtDagBNKNatccgaacgtKgtYctgaKaaSKcccKgcVtttK
+caaYtagcagatVcctVtgaMYctaccMcgDtgBaRtaaattaaagctKtaaatatatVg
+ctgaatatctMatccaattacaSYgcactWttaRacattgtNaYcaactatNNtaHttYc
+StactctatatcWSaccaVNctBtaaagataNaagtaaaaStBaaVtggttatttagDSc
+ttttMMWctagcaactBctcttattSatacSatttRtBataatcaaKVSttaaaaacaNa
+ttMBcaacagtttcVtttatatttgtaaKBgcacattttHNNaVtWaggaDataatNaWt
+BataattVacWaaattRHtacaSgWtttataDMcttRScttttaaaaMgatacMatYccg
+acKMagVtWcMtBaaatDatatHtttDtaattHaatctaHgcgtaagRgWaccattgaSt
+ttattctattcVacctccBcgttaNaacagNWtagtaNgtctgaHaacBgtatgMcRVat
+ataatKNKaagtttRgtaYcYcaMaaagattKgaaaaKcttgtaBHNaWNgMatcacctg
+caMggScBaRgMMctaDaaRgctcYtaacgtgtatacttcacDaKtatgcaatMtactaH
+DtaaVcgaagaaaggVaMaatYtttttattttatMggaVYVaaatBaatMgctgWctaag
+KtctgBtKacaataYtgctBgKgaMtgtgataBagttMaagRcccVtSNtaWcgVDctca
+SSttKaaaaVaDctacYatctcHHDtgattaaccttttYatattcgaaHBagWgYtSgcM
+tMtagaHactaSgBgBSatHtDttagaacSatcccaYtatttgtgKcgDcRatctccNta
+agctagBVWaBaaMHacaHctDVaWgtaBtaaStVtDYtatacttgttcttggNYtatWB
+SNcagatttgBtcVaacVtRgtYaatctatSatagttDatgttgtKagtctagKHtcttt
+taccattcccctaaaaSatttaDgBactaMttctVcaacVgtaSYcttgYaaKaggtaWt
+tgaaaYgagataatgccMgSHatHtacaaMatHDttcaagtaMatgtaagtgtaggtDta
+cStVaHcaactatgagttatataaBHagggccHagtaaagcRgcttagYaaaaaagttaa
+attatYNtYctagtttaacBataaWactVtRtaatgtHatctagacatttaKagStttgt
+tttaaagtDttMtgMKgcgttaactaVttHcatccgctaaaaDttSMccttNaaccatta
+caBcHctVcttctYtaaSSctVtRVattaaagtHtaBgttcatacRcctKctHVHgttKt
+catctatagNSaacHVatcVgRtgtaaaRatYtcgggtBtgcKacttgataRttDattat
+cMaggcWWRttccgaHttNtacYtYactgtatWaaWtaaggtacaDacaDgttStgctta
+tctattatgttgStaaDaaattagttRgtgcBgRDtaWaggMaaVttVRtcBttatcgtt
+BDgVgatttKgaaaMttatatgattataWctcWMgaHgaattMDatgVagtgatatcaNc
+aaaataSttattttaaatDgtaNDNggaaacgataatttaRaaatataaaVaagttacDt
+gtggttctatRatgcBtaVatVtMtaYtttaaYgaHttgttgagctacttaatatBHtct
+ttaagtcaHaWYtKttacttgtttatagacataMgttgcaBVcttMacttYcHcNaDatN
+ttagatcagaatcttatcatHaNtatcMagYaacacMcaatacaNRatDtaHDHtSYgaa
+tcRaBtKttgaMKgcDgtacgtgYatHcggatactDDctaVRgtgctttRtatgtaaacc
+agtttacVtatttBcatcRaaYgcaMaagaacSctHRtctaWatatacgtattKaNagta
+gatataaWKcgggacgaRWttNacaaaaagaaatgatacDaaaaMataKacatVgcgVcg
+cNacaaHNattaggaacattYtcRYtggtatccBatcaccgacaccagaaagMgataacH
+RgttKctDaggMaKtaaatttScBtcagKBgYtaRKttagttttcBaaHYatgattaaDa
+DVacaagKaaRYattaMaaagVatattKactatcttDacHaDaatBcactattKtKtRHg
+gtaSctaaaaagtttaggBScaatcgMStttaatKacaVBSattaKaaagacacaaagta
+attWactttacWaaBgYtMcMccagRtacaatatcttatBacgNagaRtctHgaKtMgaa
+ttcKYaaMacgcaatctcNgYgtYRaHagYtcVgaagaacacKgaRaacgBtttagDcga
+WgaYtKataaDcaBatttccgaaaacaRRBaVtRtgHacttHgagtMttWattMtBtgDa
+NtgKtaaKDccKgctaMRtaNacattacWcttacBacgRtRttaYggcKNattagtgact
+ttcKHNcWBYagttgataaYagaWaSMttgataatctataatRtggaKtcactWaataat
+YgtgcHgYKttaaaacNcaSatgcggacaBaRattttcgacctHtaKYgttaaactataR
+aaSactKatSggatgtKYtatctYggcMtactatgtgaWtttctgYDttggtBtcHBcta
+ctacBcVacaagtgaatSttcHttttttatRYYaccagatctgatgacgcccVataagMa
+ggWgYtatctgtgtatcWttRttcattattgYcHtgatcVatcttVSataactgtgcgtg
+tgaRWaacgatSgaNaVKaaaaMttccNtWgtVaatNtHgttgatVcttatcaaDaRSca
+gDtaKtatttYaSctttctcatccttaattagttaaatactgctgNcttgctcatatata
+ctaDtagctagRcataBcgccRaacaagcacaagtaHYaaatgttaaRgacNgccgctcK
+tacataBtWtaaaDagagactacaccacggaagcStHgggtcatDcKcaacctctgDVRa
+YaatattWttattcttataatWatattaccYaagWtgaataatgatttgtatBYSaDcta
+tRattgaatDgWtMacggtattttRgtaagtgWtRtagtSctVtaRgttScRcattacYY
+atattaRaaggaataagRtttBHaggtattacBHMcacKaDDagtatMaaSMacaSggtV
+VgacctgttaaHagtactaaatYtSSBgaKatcMVHcDtatgtagaVgtWtMcttctYRt
+gctRtgaacatDctcRaggatRaaVWtgHtaMgaattaHataStgaKRaVacataDtgDR
+agBHttgNcNaRDcaaSagStDgaStattBtBNHRHacaYaatcagcatacDtattWctg
+cMattaMaaWgKttgRKgcacNYtcatcaaKtctaNtgacatMatMgYagNtaRWtgaaa
+tBattctaStYgttcSYatcctMagtgatgcgtattKHKtNtcattcacatccDaaWatt
+gcacMattattgDcttgaBgccaMNaacattctcaacgaggagctaactagattWaatgt
+agtcagtYtcKtMVSagWagataaatgtaaVtaSatcccVMttataacaVWHNataWtgc
+cggBVYtacRgHatagVtctDttaccaataSaDgcggtttcKaggtaaMcatgMttaaDa
+caccagYgtattacWgaDtaBaacctatgaWagacaYttcRHDgDgaaMtcagRtaattD
+taagKtYMMacagcaYacgtWtctcaNcaagttttctacVtatagttgttDgDRDtatSc
+gatgcgagggSacttcaNcVaatKtattRtWttaVagtaaMDtMaattHtagtttaSgWc
+tcctggNgatgMataNRcttatataatcVtDBHgtNaRatgctttacHtRacgYtYaBBt
+aScWtttMKcStgRcaSgaagatNVtagctgtatVtaaagttcgWMtgtcgtHtcacSga
+aWcgttaMcttWDWataVKcaatctattaKgtattcMttattcgtatcaaatacaDtcac
+atatVaatcSgtgDatBtgtagatgtagttataaagtctcatMNgataNgtagKcatgaa
+gKcYgcNYtVttYtaHKcattaaMagaataRWacgSactctWgtcgtaaaKaWagRaBat
+aRSVatccYacttcaggtBVatKtHctatMcttctgtHttcataMgttattcttRtYtta
+gNtVtDatattgcatYBtggKtctatcYctDtagHKBNttYKtcWtRgtaDatgaaStgt
+aMagcBgaaagtSctRNaHcDgtttcYaacBcagaMttatRaVacgttKaaaacMttaWS
+gWcNRcaVgSaaaBatNcatttatttgYatttDgtcaatgagaYNattggagcDagagat
+acNtaacaWtBHgtatNtaggctaggcaacYBtatWctgaRttDatcgttKtaNtgaaaH
+aYtcgattgtgccaagagKatcgatatttcaDHMMttVagaKRtaKtDacYgtcBtaDMa
+cagatHcttcagactcgtagaMggtKSctagKtaBYMggtagcStgNgaacaatSgatta
+aKWNaaYggaaaacgMaaattgatagagaMtacacNacacSgagcYVaattHgatDWatB
+taattaaYttgDaacgctcRatatacVtcaMgcBtaagattgcgNtaHDgtcaaaDcYMR
+tgcataVgtaatcaagaRccctYWccaacttagaagaaNgccHWaaaacacaMgatScga
+tgDtWaaVtatacatggtgRNattattcaatctBcttatDaMcaaHttatacaaNcttgt
+ttagSSatgatacccKttaMtcatWgaVataatatgYYtcaHaacactWHatttVYatat
+gDactaaggcgcaKcatHaccMtccHcaatgtWtctttatgWDatctgWaagHVtDggaa
+gagtYHttBgaDKMctMHccDaattMatcaaBtBcagatBcatatagatttatDtNatca
+aaatctgaaSNaagatagtVBtagctaBVNtStWBgctagtYgatHNatatgcWacWtaY
+tctatatgaatactcattagatcgHgaRattaatDtNcaaDgactSatactgNataBYaH
+KaKaactctcHcKHRagDttgtYgtaattaactagctatatataaKcattttgcKtcaac
+SttgHRaagacNaBtatacataaaaataVWHMcaYcagcagRaagagttBttaaMtgata
+cSDaNtttgaagRtattaHtttagtatYaaatcaccgaYaatattWBtttataactMYac
+taaactaaatttcNcVatgcVgKVatatattaaatccggaaNaacacaSatgcttgcHcc
+acatgatNtatgKaNtgctggagtctataHcRRScSagcactcaatataggaaYaataaa
+gtKKaaaKtBttYRtgtcNVVaaaaaatatagaNaSgattDtgacgtctMatcaaatggt
+SaYtttaatcttaagcKataaMDaMctgtYcDtgaattRctgHaatgttggtcttcaata
+WacaaYaNtacHNtVWagcHWtBBYagSagcaaatcKgataaSgDHataaacattKBttW
+agtRtcNagHcttaatBccgaaatVacggStctaKaRaVtgcaHBcgKVcattttHgctt
+tgtgacgaBttttccatccMatRcaVataattKattaaaagDatVttaSRMggtacttKH
+aacaatgagRaWcgDtaggcataBaVgttNBcgtagSttgccYtacWcgagNaatttgct
+agagacatacaaggataacWRtcDaacSDStcaRtcDcaaaHgtatcaDRtgcagtDtac
+BtatDMagtatcctagtgcDaSaaRtcaRactHgaaatccaRtWgaacttattaataSca
+DaatYaaaWaRNcagtaaaYcaHttBctaattctNggBYBtggaacaDaatKgcagataH
+tgtcKaWctaVtNWYBgttttgtHScaBctRccataataMaaacatgaatatNatgagtW
+gatggattgaNttataHcSKttgtatcatBtDtaWatcaWaDNgtagctaaaWttBatDg
+MatgagatctKttaHactataSgattRataYaYatagaatDagtaDaagatcKcYgtgWS
+gtttttaYKtSatttgYatgYHStattaKcttatNNSataaaacHBtaKgcataggYtac
+gtttccaaVtaVaHDcaWRYSBHattattcaaaaBatataaggaBtaacaYcgHgaatgc
+ggYHagtactNagaaatttttacgaBcaaBttgagtKtYHaKKgttgaacgacacgBtWD
+tSttgNHDMgaaaaattcKcatgataMKttVHVBacataKaatcggWtaccagMtttcKg
+ScgcaactattVctHScccaacccHDtgttacgttHVaatcVgMtgttcatBWBttDaaa
+ctattcttaaactaYtRtgtaWataWggacVgtggWtatgtataaaHNctRgRtattaag
+tcgHgWStttaWDacacatcaHatttVacttagcgtHagagttgttcatcatgcaHcgtc
+KaagaRRacaatNgtYDtatVgYccaYKVttDttBctYcttaWtatgYtaVttttacVat
+BaYKSSVaNNccgctgctBtcaagcacaNttctataYMatccWacBcgVaaatagWgccR
+tHMttHgBacttYScaaVtgSgttacBtctBttaRtSMgttaatNaRatgttgtcatVta
+aYgVgcVaaYSaNcagcttatNtacgatagtcgaVtaacYVaMttggataaagatStcaN
+tDttgcBacatattaDWatDatcaatatNttagttMttcaactacaRHYtcggaacVHta
+ggatDggStgSWtVatagctgtttaagBcccgBtgcgtctacYaBatactYMttHttVtt
+aWtSttgKtcttcgtgacctaDtttMYMtaaaaaattcaMgWatBtgWWtaScccttaaV
+VgatagaRtYataatttgKaVHtgcataYtaaaaagStcaRaMaattWgcaacaaRaBaa
+taacaMNatagatattatgWtagcgVHcgtcatgaHgtRatcctgtcSaaatWgtatcHB
+catcatcHaattattDBHggcatBtgttagNDggtcRttaataVtctttStaaggtcccB
+tccaBgBRgaDaatttgtttgcNtatBgaaaggcgNttatMtggtBgMgatactDtcatM
+aaWctatttaaaacYNgtSgMatBcSactaKYaDVaVtcagaaaStagttYRcaaKacaH
+aacagctNcatttKtttaaacWtMNaatttattaaVgaMStMcagctaWgaSccatNatg
+MacataWaaMtataggcgtatcctagHatttttVaattttSBttScgtBSatgaHcaacg
+aVtMaaaactKHatatttNWtttataWtaatVttKaKMggatcMaaattattMgatttgt
+atRtaVgaaDtacacRtaaaaaMttScaggRttgtcttSatYWtVMactagatVaMaaaD
+taattttaBWcataaggaatBtRgtctaWDtagWtaaWYSaHaaacgatRcttgcatcat
+taSDBBKttttctaYSaactcgYacatttBaattKaaaccaMStaHatHtatgtctKcWa
+taactctcVNYtttMttaDatSacDKcacaaHgaggaaBtgNaaaHtattgtRcgacDtY
+tctttMttatcDaNgattagtttYtaattBMtaggtacatgtYBNttcMacaagaaaaaK
+gaaatcacaNttgtttttagDBcMgtaNacSatcWBWtataVatYagtttccatatHttt
+DtcgtggBggcKacaBWtBcaattgMatcttaVaacVYgMgttDcaaactctctcgcHaS
+atYVHRaaatccMMtaDHtaaKccactgattatccatBYVDacgttMctaaVtatacaat
+BgaagttaattttgatatgcatKgaYttHtatggaaaatcaDtttBtatgccacattact
+caaagctctcBKcaagcaatataNtattcVtcataacMHgtattaaDtctNaNttYWcWt
+aVatatataWgtaWtgaHtattcgagtMVaHDHtatgcttctaaWYaatttaatccaMac
+tKtcgtDaDVWttaccVtacYBgDattKtHKSVStgMtBgcgtDRSatggatatDKacat
+aWtatWaVttctSRWgtcaWattKaaYWtYaHctataKacMaagtctRttaatcgtgaHa
+ggYWtcgatKttKaccttacttccgtttHcgtKtcttaatSBgaatttcVKaMattVSgD
+DcaattcagtcataccBccgtgaVtaggttYgaNagYcHatMYaattDgtttaaMagRac
+tHattgatttaaSKtSccggBattatatKDacaacBgVWBaaacaagattgtcDtcttBg
+cattatcaaaacagNtaaDgtggVaacYDgtttDtggKccttaaaWcacgSatacaggta
+gVgatacctBttcaattKRtctaMgSattgtacctatataaaMgVtctYMYYcacttRaB
+gDctRtttaRHgcRSMVaaaaacagaYaagtaMatDaatttaggcctNaacgaaaatgNt
+ttaBtMtScVtVtSacStaBggtggtKtRcatagHattcctggaRtaaKaBKtagttgaa
+ttgtatttMcatgcttDaWYtaVtNDgatKtHaaattaattaaStaagWaaBtNcaccaa
+tRcacttgttttcaaattctggcccttttBgHccatcgaWctataSttBgataacagtac
+ggcccDcScaactgattttaSWYtaaaMaVatttagctaBgSaggtNaBRgStDaatDBt
+atcHgDtRtgMtStWaYaggtaYatBtaWaattgaaYattcBVtaVSactWaWgtKaata
+gaaatgNttHtgtcaatMattcggtcaDcVttgataMNttYVgSSYMWaVtgcaRaaccY
+tgccattaaHVgaaaattMtaSgtaYaggctataBtcRtttaaBtcHDatDgtaaVttgc
+agNcatWggNtgRMaDcYgYttacWNtgcaWtaaVaNctVacaaccRcacttgMttgtRM
+tgtccatttgKagttctVagcttccaccaNgtgcatRgtSBaacggaattttttNagtDc
+agaHaaaatStcaMtctagcacactHWtNtgctcgtNaWatataKcMcWtagaggDaVat
+ttaatttYSDgRccWattHtaggctaccDMctacVaattBYtDacaYctWaHaaHttcgg
+aMKaacSagtattaaatDttNaVNtacgVttKaaHtgagttWcKtgtaDcDaKacgtact
+ctttacatSgtagtaHHtgaaatRtttagttMctacKgaKaatBttataKWMcggtttat
+gtgtgaStaagaaRttaVtgttBaHgNtggaRaWataacaWtRWacaactcgHWttttaD
+agScKgtgSagtcMgaRgttacccaaaKRaaatattcKatttNgtMaVcataccaKgaWg
+HBWagctaagttatcDaRVVtggaaHSVacggttaHaWWagtSgctctVattKctKtMat
+HWcgccttaYtagtaKDaVcHtctgHagatcaSacaatKtatgatagDgtcgttttgatV
+tatStctYaYNtgtgKaKaVcVNgaattWccgattcttgaMaRattRgcaatHctcatta
+BaaMtattNSSttHcagRKRaaccaYacMDtaYaaaatttRataBVtcacaagKtatgcc
+tcatcgtgWataagcgtatcDtNagcatNNatgttcRaaScagaaaRaataMtacMSctK
+tDgaBactaggtWgcRtaWcaYtgtgWaagDKattttttaaccaaatDHattgacStttt
+atWaataatDaDaaaaRtaYaggagcYatacYaKaagaaNtaaaYtaVtDtBaaDcgttt
+KMtggcagtVatgccggtHgtgtaVaacDBaattacaNatttMgaDgcaDtttggaaMgt
+YtDtSgccaaaaYcNgaacDVgcattaNgatgaaDaBBttgccatttRtctaatgtHNta
+aatBtaMaVattcctggaaaaatMattgtagRDacaaacgaataWSBctctYVcgtSaMS
+tgtttSatNagaacaRcagtatgaNBtcKgBttRtattVtaBtBaKactaWaMgRtcMta
+DtYtatHattScggacMtaggcataaWaKHaataaagYcgWatatStBattKaKagKtta
+cMaRacaSaRaaWtKaatagSatcgaaaKaaVcDttcVcgaKVattggaYgtMataaacR
+taDaactNatYcagtDgttagacBataRYRDgttcttttattacBcHatgaRacMaactc
+atVVtttaaaHgctgttcaattaVaHtDcaYKacgKtcNtttgctttgHWcaaSactWKS
+atcgYaNVaattacRcatVNgtagatgcatYatVaaYWaSactgatccatatNMaNagNt
+aatcgttaSttattWattaggagaatcNaaccaaaWatRaatHMaattaNWatRaMKaWc
+tWtDataaagHctMctttRSttaacgaSWcatcaVgatataattgtWMagKKaBBgatat
+ctcgHSaaNBctgVtaStagtttgaggSgagcKttaaatHattDtaaattgaacatacta
+aWaBYtKttacWtaaVNcWacgttctcctaactBaaSRagaaatgttKVgtHacatctca
+ScaataNgaaVagaaHttaKgHgKaccgtcYtcctBccataagaSacataaaggtttDtV
+StaVBgtcgNatgtgaVctatWaaDccWHcctttaatcWactaatactcttacttgttct
+tatttatcaaagatWacYctacKtaSaaaStgtWaVcaYaRctgggtSaaaWtgctgcHt
+ttgMcgatSaagttgttttNattgaacttaaKaYcSBSacWattaataKDattKaHtgaa
+attKKttttgacDtDtattttDBDDcMgcatagaVNttaWtgaDttgttttttttgacat
+tatagBDacgatNatMBcaggtacaatgtgctttatatttRgBcctVtYVctgcatgtga
+tataatHagtttccttHatagtaMMaaWggBataaKtttgataaagcKgtVtaaaatgta
+tWWaataaHgatttYtcWataataacagaacDRWDgWaWaaaggattBcRctacYtagct
+NgtScagMcccHaBaYgtgctgtSDtHacKtNgtgacaaaacccMcacaKctcactaaaa
+aNgtagWtttYtgaDcatWctataVctNttKgRtatataYaaaRacaggttatagtcRgD
+gcaYctattNcaNtVatYattKgaaggBDtttacttHttNtgcatRatgaMHtRBtaaga
+tMcacatBatgtStctagacttccKaRgaWccRataVtggaScgatttDMaaatNNtcYa
+YtaDaatctatgaVtctBKtgccYgtWatDcMYtaaRtcVgcttttDtMtRagtactHcc
+RBWatatccttatMtNatgttagagBcttKacaaMtagaaattaDttaatatgaaaRatt
+NcHSgaaHtaDcagctYacgccagcMtaaMgDaaaaaggatcttcaaVNatRcKVaaHRB
+ctgcattatMaWaNaKataaatatgWaaatcgMaaaatcctgttactDtDagaccYWact
+tctRatgataaKtaaatcaMttttcaaRtScaWgatMactMtcaBNataaaBactggtWH
+tYaattaWacattgaaVtYtSgMcatgaatYgattatacaYttaaaKRgaVagNgtaHWa
+attcgDaRaaacgVtBDtStttRaKgVagatatWtcMKaaaaMDatttaaYcataDYagt
+aaaaKttVWMggctgVgtgagtKagtgtBBNctacaaacttagattSttHagacKVttgH
+ttatSataaWtMHttSaSaaaaDatgBtaYaaaggttaMttgVtVtttctaattgaacag
+gtttDDVMtNSgcatataagDaNttatSVttMScNaaattDttYaaHcNgttatatBatg
+DKctttgVVaaBgataaBatRaagactBYgMgNaBttaaattagatttttttaVgttaYt
+atVtccgtaagDcNVcaWtgcaKgggYtgagattaMaaagaatagtgaBaVcacBNtagt
+aDctctcVtaSctgtagcBcHMWtataattDtaactttHctaRcRaaBaYacatttcVRa
+atctgctattDSNDgBatcaaatgcaBccKctaHcBtctVtaaHgatcRgaacggctRta
+agtaSatatgatcaaagBtaagatttVaMagaagaWWgcMWBRStRggtttWttttagtc
+caMRMaaattaSgBccggNataagtgctctttacYataRtcattgtgYBtggcatRtact
+tBaacDacaKtHDtaNacMtataaKKtgtaaaRMVtctVcRatcgatttgcattSaaagg
+ttRatagtagaattVcNgRtKccBgBtWcataataKctctKatttttgVcaacKStcacS
+RtattgcggtcctcHatcgaaDgaVgctagtMNVtaattaaatattMYNcgattaaKtMt
+tRtYgacttgttagggcDNgagNtKBaScagttctgcMaaaMtHctRaYtcgRtHatVct
+ttatcttggtYctctYgttgattttaacSttaaactaaaWHattgWtctactatttcgMc
+VaaMctaKRcttcRaatSgctVNgtgaaaNcagataatcaatcKtagtgacaaBVtttgt
+aaVctaBatgtaagtgtacctttacKtMWtaaaatWtcVctgagataattacggaatacg
+SaWgaHcagtagNWaaaSacggaaatgatRBtRctVctgtVaatataVNactMgDtaatg
+gtatctacaaatgtatacKtttgttttaaacgttgBggBtgacttWacgaMtttcagaac
+agaaRVtttKBacttDWaccagtaaatatcgMcttatRtaaKKcgMtHKattWYYgttga
+tgttaRgacHcattcttKtcgtttaatagagWgDKaYatKataKcDgctaaaHWgRtagc
+cgttcatYattcagSHtttattataBVccaNMHttacgWttgDgaaRtRaatcgatNaaN
+tWVcctacatacYtctgKtcattatctattatcgtcKtaataaattagggHctcatgHtt
+SNacctYaKttMHtctttSgacgtttgMcStgttcaaSBggataggWttataNagaNBca
+tcaagtBtagcMagtcagagaaDcaaaataKgtatgtgSaagtgtYDtDccVaaacagaa
+gttaHSWatagaaaMYaggtacttctccttatatHatgctgVMatKttgaNtggSaRcat
+tggttgWcatYagtaatatttgcttgaVctaataMRttttScggggtgagVcacatYBgg
+tccatMattBaatgNataDatWtDttVcataacSVtattagaagtaDtatcBacNaacaa
+BaaagaaWBHSttgattttKRcVataHatttttgaBtcctctacctcRYttagcatactt
+tagaMHgtcatgtHtatctaaYacacggtaaMtatgttaagaHWaRcaaBaacaVaKatt
+HgataNatatacgtatttaDWctagatataaNtaccgaacaDMttDSaSYaaYgYaVtca
+tactaaWWtatataaVtMcagMccaDaaSatBattagcaaaatgRtaHRgccgataatag
+caaacacWacagaaVgBcagaYctHctgtcttaccBattVaYtttHatgaVgttcRgaHt
+ttagttttataatRWggattYatatMaaaactWaDRaggataaWgMataggtactatatt
+tVctataattaaatatgtgttDtcctaKataaaaacggtacgtKaaatccBKtgtaatta
+caKtKYtgStRaagaaaaaaaggYagtNactttaaNaStcNtBcBaaacHtacaatSgat
+tYttaacDacaHtcttcatttgSYgtctRaatVagcaWtctcDcRctNHatScRtaMgaa
+cWaaYatcaHaaagttggagtacaNcSRttagaatcatVgtgaccaaYacWHHtaMtHtc
+taatttcactBtgNVggBgttctaDtcttaWttaatcatatHgaDacatgaaNagtaata
+cgDgHttaNggatDaggactcaatttcttDaNtRagttgVgaVRacWNVHBttcVtYYta
+gataagHtccattcaatNaataYtNctgatcRttgaYaaaBcaKatcacgSaataHatgg
+tacacctttatRcgtaYacgataHWVKaattVtKcgatcgtRtatagRgccBtaatagct
+cVNtttatgRtggggtttcttatactaatcMaaaWcgcaatKttatttgtttatHRRaca
+VcSgatcagcaacccaMatYacBVccNcRgagatctgtSgaMttHgtaattatggRatgc
+WtcKatattMKWtaaatctccgtgtcaHNYaagStKcaDaMtaaaWBttacBgNctMaat
+DttcttgatMagtagaaatYHKaacttattSgttNaKagttctcataagtaatgactgaV
+StaatcctcDagtcataagWtataatattacagScHaatatagcaHYaaSagaaaaactY
+tRYaatcggaaHcVcDcaccctattRaatattNgVaatacagaataaSaaaagcWRgaKt
+tccgtaWttctaaWacgatctMHaNWSgVtgNttVgtattStaatNatVttacaRWagNg
+caSgRVtcYtgtctYgtRKatctStHWttcYagtgNtBaacgtagtgtHcgaSggcNgHg
+WggKatMtaHcgtKaHaWggacRRatattaHaaggaagaSgHggtttacctagtaattBa
+aatSttYgtagBaSKBaaSKgctMMcacagcgtYatSctWctSaatRtKKtgatatctMt
+attagcgagaMctNtBcgtatRDtcatHtgaVcYttctaHacgagDaaMNtcttaBgWat
+tatagaKtcWtHaMacagattgtHacttttgDaBWDtcSWKacKttcaHtSgttttDtHt
+SaVRYVgcagaatWattYtgNcgccBSttataaNctttcHtccaaDRgaataSatgctVD
+ggacagBYtBcRacDtYDNtgWaattattatYKtNcggaKRatcagBactgatgcctStt
+ttttDtcSgtcaaataataaMVttgaacBagtattctatggYtcaaatDWacVtgataYY
+acSccVcataaagacagtNaatgtactaagtRtattBMKacNacagaaWtctSaMgaKat
+aaaMBgtYtaWaaKNtDStSNggaacgtMRtaaHctatacMtattttaccaataKVtcag
+ctttatacgtSWBaStgttgWVtYaacaacRgtSgtacNgatgRtaYcagStcaNScaaa
+RttaDttctcaaBgcScDtWaggtgaacttNBBYaaccaNaactNgctaaDaaaggttga
+gaaMtatacttgtgtctHtgagKacagcacagcgKSattaSDaKaatttagtHtMttaMV
+ctaaBtgBaattttactttaKcMagcatgcDcatcBagaBHattVgWtaataMgtttgtD
+aHaggctgtVattDYacNtNStttaKaNggtBtaKtgHaaKcaacatDMtagatgtatMt
+aaacttccNBgctacgtgcaaKgWSNacttSBaggMtNStaKtcaatagattatctagta
+BttaggactYtaaaStaaYtgaaaagYtMaagaKctgtVtttcgWcatctacgtatVaag
+tagaattBcagaDcgSgtaSggaactaRcaBRtMttRgattaattWaBYcaataHMacgH
+actatNctacgaVataNVcHatatVHKKagaaRSattaacgttMattgtatagBagtatc
+tttgaagaBctgattattHgRttacDgMgtWtaggcaatNttgcttagagaRatttSgtt
+tBtgRtgaNtHcgStatgaaKtgtaBacctgaaWgtKatHDStatctttaRaaataacaB
+ttStHVMaccggtaVYaaBttYNKgNaBHaaKcKaaatStBcattgagggcRSttttcta
+aatcacaRBattccacatagacatSaDtaaaSNtttgtatDgWgcatacgaSacRttagN
+aggaHtttagccttttWDtcYaVtaRtacWggctcaaaacVctWtacatagttaattBBt
+tMacatDtatttaaRggattatBVcacattattaagWctactVcaBgcttKagagttatR
+BgctagaHtgDgaaaSVtKgattaWtMDWaRccaaWaagtaaVttgWgVgacaBtSaacD
+aaaaKcacaRKaagttgagtNatttaSttaWRgtctaaccataDatagYaMgaWBcatta
+acSttcacDtSttgtaWYataRBHtccagaMctaagaWagSDaactRNaaaWagtacaSc
+aSDcaatMaaaaaaaVBcatKacaggtgMaaMtatVaVgcctcDDYgtattcaatattag
+gagtYBaaatttagaaVWDattcgttagHKSgcWtWcaatttaBtaatNcaMYgYagatc
+RRtcataaaYctNtatttKRatRggtYcgaWcgcccataWttVaaBtaataaatcgNtct
+ttaggNtatatgNaagtMttccaagactRttgtgattBagBtaataattBStcaatttaW
+cattaatVtacatgtatttBataVYWStagcaYKDaagYtaggKtgagatVtMDtKgNtc
+atagtNcagtBagagcaNaaNtaRtagatatcYWtSataWggacagagtcaDSggYattt
+DaaatcactKatWatcDatatRattataaatatctattHSctttggNctaagtSacgaga
+tatatatRataagtttcatgcSaaKttctHaRgaaDatgStWcataaaaatWMNttaaRa
+VgaYcHaagWggttttaaBtcagacKtaBtggcaacHtaggVttttactatRWaataVcc
+caRaagattNttggStYaatBRaataVacgaaatttaBaMYgcaMgtKStStVtgVaata
+cccYaDVYaVaYKVtgatgcctacaaagcWgDtVtctaBtcctccacgatatWtcDHHaH
+acaaataaatataccaYRSataVagtttaaStgttgRHtctaDMMaYYaaagatacaBWK
+cagttgcaacgagBagcaaatccgKaRgtgaatcgtaWcatYtWaBtaBatcgRattcaa
+gtHctctaatcttcctattaaYgaNaaaaRaDtactDtMNagatMtttRacKaccWaYta
+tcagaaKcttVtVaaaatgttgtNYgtHtaDactaggaRttaccVaagMacgcKtatata
+HaMtcaattcctMaRtttttcatgtctcaacatggtgacatcaBatHaaMagaatttatt
+aaaactYgMttaKHBccgacttttaVaaVtcScHaNccttacccatataMgggDtactag
+KgtcacRtacMacYgBaatttcagYcacaaataaaaggagYaaMHtataaaHtKgaaHtc
+tcaVatcgStcatHtcaYctttWcttattBactataatWctcctRKaaHtaaHYcttcaY
+ataaaHtNcaSctgattaagaKaatWagRaVaNSHDaactaYVRaatgttatVYttatDc
+ctRtgcgaacStaWttgaYcatYtggtatWNataMtDNRtgtttgggtHcWtatHaaata
+atVtaaWaVgcaatagDatgScgNcagggagtcaDtgagataKtgtctataattgtgaNa
+tcaNatDgtagctaaaNtgtagtcBatgWcagagtgtWtaagWtaKgattHagWRaNata
+caagtactYtaWgatataRctcNKcttttgaRtgKWtgtgRagcNtKtYtgatatgatBD
+KVtaaaaatttWtcaatacgRtaactttaaaaMtaMattaVNHRKttattattaaVaata
+gatYaggattVaaaRactcaagccccRtagtScgDWgVSagtggtaacataVatttcagt
+ttRtattcttcYaccaaaagttNttKtggBttBcSaWaattataatcataBtgtMtMtaa
+agataYtacgMtWaaacBtttatcKacaaaatattMagtKccaaWccatttgtgaccttt
+MSataMgBtcttaVgtNttttSaactatgaggaSWataRtHtcgaMagSMccSaMctcgN
+tatgtataaVtBatHcHtattaacgactgNKtttaMtVaaaagaatVgttMWcttacacg
+tacScttcttcWtaatccatactctaacaHHaaaatDctNtgatMcRaaWRtMgttgtta
+tRagtaNtatgRtaMttggaaKWttaRtHKMaDDaacatgcgttaaaccaaaDttatagV
+RBatacMaatacMaaatWcNcaaHttBgttgtacggRKaaaMtcHgttaattattttaHg
+KtgttaatDaHatctggtaatMtYaRgMccKRaRKaDaagaggatBtSacatactccaKg
+VaaRMaBttgcataaacYtKgaVDtttgcatSaatattatNattataWatWgBttaggtB
+ttaaYataaSHtRtaccaacMttaccattccKggKNtMatacctctgtaYctaaccttga
+gtataaRatagaatRBtttttMtgWNtKtgcttatgactcSaatattgtBRBtSWVWYag
+taWBcNatttcNNgSKacctgaaMKgatWcYHgRataYggtctaMtggcagaRgaaYaYg
+KgaaHVtaattMgaaWaWaDataagaaaaBDatacatatgatcNtagagMtactcatgat
+gtHataaggtaHaWatMgtagcttaWtcStataSttagttttgcaagtgctgacDtgctc
+DtgaSgVMtagttKtaacgtacattaaatctHgatYatttcgggcaDtVttcaaacccgD
+gtatBggcttcBcWtacttgaatBaRNcgYtgtaaaaaRDctKctagtaKSatRtRatMa
+MtaacVYaKtactgRDcaataaatSacagctDaatggttttaaacNttBaattgattaaM
+gVBKtBaacctYNcaKcaVtDYtcBaaataNSaBgatacccgtVtaatactSgtttgMSY
+tttgKtgtKacgtKatgataaVccaMgtaVaWatttatattgBNtgtVgVNtYStMtgta
+tBcgagaBaVatgatgBcStttgtagDgYMgaattacacHtaaaaaBttKaaggHttcta
+ggKagRNtMBaatWcagMSBaaVtgaatgtgatNaatSagcaatttHctatWMtgVcNtS
+aNRHatVaVacVtHattcaataatgSKttttttgtataRKYaatccRYaatggtaVttta
+aaaaWBKtatatttatgtagtcNatSaatatcMDRtgtBttYtatKaattaaaaYtcWcc
+VattcDaaatgattgtHccactgNgctttBtgagatWDgVgtactgtRtaaggtBgacct
+aaatctRtDttaBRaYacaaaYYtcaaagaWaSDttctttggacttcBcgaDacHataNt
+NgWtVMVtRactggaaagSgtgggtgaggcctccataaatNttaYYgtcBatattWMaac
+MRctcgttaaaVatatagagataKatRMtHaVagaaBBtStttaatcaaatgagtatcaa
+gtRMtaccgtBagaWKtagaaaYttcSScttaVttttcatatcaSgtcWNgtttagccaa
+aVgaatgtgttatgaaYaatgaataaaagagatcttcYacaaatataDgRttcMtcataY
+aBtctStgaatgagDaDgtRNaMtYMatatagWNggaNtcattatgacYgtBKYttttag
+ccttataaNRaatggaatccaBacgttacttatMNggaaaMtaaRtctagtttttKKKgc
+BttgccgtHKatcgatVtttacataMtagNaMttctKHNctaaNatttWaRNgRatctag
+atSctaactctDttaagacgcatagcRNgagatttgtacattSattaacttttcgttgat
+tWatKtgaatttaMtSBattKKcttaaSggcactaataaatcactcaMgacggtRcaDSc
+NctYtBRYVgttgtttaVtacHWattattcatttVaKtgKaacctaggStatttacaact
+cKNtaaacaagSttcgattatttcaRttVtaVaaacRgDtaatgtccMaacNtcggttgc
+ctaattaaaNaWcgKataaYcctSgMcataaatttgaaatttHtagSBgKYggcgYaaga
+gataaWBcMgatRBNRaYctgHatctatHttgaHtgcHKBKVaWaacacWNRactWBVtt
+aatttVccaagBSWacaaaatcDgttattBtHaMtMtHacKgWtcctcctttHaatagtY
+ttaagccaHtYatatttacgtcaSgtgtYttgBcatcatttaNRgaKgBtgattttaaat
+gaattVaKtVYgNaatgDaacaaVtHaaatggtttgaYYatgctgcacatttttctacVt
+acaNatataHtgtcVtaacVgtYccgaactaKaaaatcagtttaKNRtaaataMatgtac
+atatcKScctDatDcKttSattttagatgttHtcBtKgNVRagctaRVtttaNYWttcWY
+RatgatMgaMKRctNVMgttVagWcaVStcDgtttctcRatBVggaccgaatcMttgaga
+BDgtNMgKKRBNSMgcaWHYWccNgcacaggVYtMcaaaatgBtaKcgaRacccgStatt
+cHttgaYttattattctaVMttgaacDaWtNccDtcHBataNcRggaaNBtgaYNtaaMa
+DctMaaaaaaHaaattcBgtcgHtgcgaaStttctacttcgMagagtaaaacaDctgcag
+HctHtWaacgaatgtggtDacgtcacataSaatKtcWBtataccaaScttNgDgcctacg
+BaNWtagataBaNtRcSggtaMattgaatgtRHtgHaaNWtgttaccatacctBataaMW
+atttNttVaaRagMataVtgtaccattYVcKYcgagtaaYtttgDaKDgVacMtttaVtt
+cYcgtMattctatatataaggaagagttaaatHgtWctatttgaaatHttgScgtBataa
+tgatRWgtttVgatMBcgctttatgtctgWKtaacaaHttaMtctttatcDtccaHaNYt
+SWcWNtHNacaaatactNggtgStacKatgtgKVctaBcaHcttaccaaWatHaaYtatt
+atYtttDgtBaKcataaaatcaNgttNYcatVSgtgatatYDMMtggaatKMaagcttVt
+aNNYctKcctagMWtttatttBattNagccggaRgagtattaKatgatctacatcaKVaa
+agttYgcStagtctacttttcatKtWtKtctRaRDtcggtataMcMDcaattNcacatta
+ttgaBaHattHgcYattagaattataaBtattBKHtgtaacHtHaacaaRYaBttaRVSa
+agttHVtatMtcacaWctgVtgaatcVtcctcNataacacgWtattDWccatDDYtcgta
+HaaKaacaYaHaataBtaaBKagtttcStWataccgNcaDtWNaaRgctcNaacttattt
+gttaaacaaStttagtgVaKgggtatNaatVagtataVVaHtaRaccacaRatacNStaa
+caYDgaWaRtaKttgtaatacggtttgccaaggMWtcaaccttcgctaMSaattaatgaa
+VDagttBcatccattttccaaBggRttgKgccaaaYNcDcaSatMcaattYDcatcWatS
+tttggaaWtttHtatVaggttDgVWatttaBWMagtcagcgaSaaSgtattctacHtaaS
+aVacaataNKtatagRMagtKYBKggtttKatDacaWaYDaactagcaDttctctttHta
+gtMtWtttatYatWNaBgHtaBgSttRgattatgKcccaaBtWcccataaNattaYtRYW
+gRccNatatHttWgttatactttacBYHaaaKaHYaNttaatagKatacaaatWSMcttt
+cKacatMattgcaRctBataaVaHtataSctDVtRaacttcggScYctataHRHtgttct
+gtgattYatatYtcYHaataaataYtMMgttaaatgatcttaaattaKRtttaaRtaact
+taBtgtcatgtctNcaaKactMtKatagRaDKaatgSaHcRtMDctagatcaYtRatMSV
+RMYKYaggataaatYtDBaDacDtaVtacggaKttattNaggScgWcaYtaBaaacaWaN
+VtHVagtBaatgaBNagHaBtaNatNttSgaaactctBaggtHHtgaSagYKNcataaMc
+atagaSttctNBYcttattcatagagagtHWWDtctgMtRHtactgggagcKcacctgga
+YattatttgaaWgtcaVaataagaaNatRgtttacNtWYMBcNScgggataataaagtWY
+KDYcVWVggtttMcttYaatagaaKaaataDcaYMVcaVtgtStctctWaagtaRtaagt
+aaatWacSKaaatYaScctggtgMKtYMtctacDatctcaMatVtNaataaNtaattgaa
+gaNaataataagcttaagtgtgcgtVgttataYaagVgNaaRctSctgWKVaYKgctNWM
+aaRaHatcgctHaaYMtccggattgtgBacatHaacttggtggDVgtcaaaggSatWRaK
+tKacNVggaatYttatttattcaaSttttttttcaatgttatttgttttaBgcatacWKD
+gtYNtcYtgtcttttttgtcaaatgatacttWagatDatttcacctaaaaggtgagttat
+WgtgHctaatMtRKagccagcgcVgagYagtactgtactttagVctaBBaYNggtYtaat
+tttcRtaaagatctMtaVYatctYgNMaVtaWtcattgRtaNataagaaaacVSctHNtc
+NaMaRYcgagttaHcgacNgagagBgtKaactaaatatYRcggatgtKtttactgDctcV
+aYaaSaacBcacatagaaataaaaWDctVcNtttRtcataatNagatVMctBgttcHtVg
+agaNaaaHaaSccggatSctaHgtgaYRagattDcSDtMStNYtgtgaagcttgggaatt
+tttDgcaatHatgaBttHttaacatBcaaagtaggtKgagacaattaataHcaNaaHata
+MtccaKagagtttBYSagDDtaNaRtWtWagatSgcSKtcttttcaaRgtMattatRtYS
+HgaMccttttttBtHactaattcaHtMatagaattVtBtDatcttVgagtatttaaaatt
+acYSattatttaYtagcaVSHattDctKcVattataagagRaccccWcaBtYYtctaaaa
+YccSgattaaaMDRtHatMaYtHtcgcaaggWgBaNVDatataaatWtcMYSVtacBYaa
+atactcgtacttttWgaacRNaattctHagcYtaSttaaataatttttaaSDtKaaMcWg
+BaagBgaatDagaaatactcctNtgRaattaNWcattgYVMtRtHgBaatcaagRcagtS
+taaWRgtaaatHcaMacDctatNaagtactVHaaVagMgttgKtgtHatcMacatagMga
+BtSaaaBtagttaaNaYgStRRctYWYVtttMNBgcctgMctcacttagtgtttDagaca
+YaattagaggKtttacaatMttctttatKagaaNtBtttKSHWSaVtVtgttaRSaYccg
+taBgggMtKtttctYWttcaVaagctttttMBgDKccatagVactWDgtRtKMtgBKaDa
+VaggtttRaataBgttYtattatgttatgtcMMaatcagaatagHaacaattRcBcDatt
+taYWttagattggttgaMcgtYRgagMtcactaRctcBMaaNgcaStgcgNtgagVttaB
+aaagaatacgcatYMaaatDtacgatatataMtYKatctScatattNgStYWgtttaYct
+tgtagaHaHaYtaRaaagttcMHaStatcatYtttKBtctataaaatcaStcatatStat
+tatMtSatcataHcaWaccagHtaaggaHatatgagaaYYgtgVacSttgKaBacSYcaN
+NccBNtHKtHcctttMttttagtaaaBHBaaattWKgtaaccDataactgatatgtaaRV
+taHgaattctcRttcgcatHtaagttYYctaaattttgWDacBtataatttctVaYHtMt
+agMaHWtagatttcaVgtKaaacctgHagSgtacSWttMaBcHttaatcttMaStYatat
+atattagtttggMaYaatHgaaaHHgatggccctactatSgacaatcVMcatactBBMta
+attaaatattBNDacYtgYattBttHtNcaatgcggacccctDcYcDtttaKaSggtatc
+aBYaaBttctDSRgacHttagMcggtWgagtcctRatatRcttgattggaaaKggaaaag
+aaSNtattcNtataatVttgagBaMaaBctWtHatgcDaatHccgMDcgcWaaDaacWga
+agcaatattactcaaaatMgttgtaaMatatYtctRSctctWcatttVatgBNtaaYagN
+taMatcSgSgaVttSaccaataccKRNcataaggYcDMWaSKVcccaaaggVtHtgHagM
+aggtKVatVtVMDVatBgttWagcctagagacaaaggtataatttgcttgtSaaccttct
+ccttcaatgNaacaBtttaVcaacagWaHMttgttaagttNWaaYcgaaVtatacBatga
+gHtSattacBgttYgtNRRcttgatcttaHcaataattattttccttgaYgacVgNctta
+RattatatctcagWWatNcDgacacgttaatRattaYcKtggtSggWgatMcaaDBttga
+acNttctcaaHtHaagcgVtDaaDtNMcagaaatWaNtatcttcattSgatatgatacta
+ttWatSaattWccgtctaatcttgKDacatRatggBttatggKgaagtttcBaKtgttaa
+aKtcgatagcNgtatVDagaDtaVtcaactttYgaBYcgaYgWgaWtaaaWatVtctVtg
+ggKaVctcgRtttacMaVaaagaaggtVtKNYtWcYaVtRVccgaattatacttatatta
+gcatcKBattttgVDggcKaHaYttgcggcNaatRactWagWgttcagtgWMctaataBH
+tttgHaggcctgacMcYaRtRtcggcaatBagttaagcDatatatNttgtMcVtaaaHMg
+attVgaYgtattatatSaDaaaaataWacaaNttKttcatttttHaMagatYtgtttcat
+taatatVacgcHRttacaYtaagttacaBtcgaagcgttWtatVWRaaSacggWaBgSgc
+ttaScatNaHcaatWacaMatagttcagYBagYgVactWtgtStNatacatYgSYDtaaa
+cSaaatBtttKaKRSWRcRYMgcYgVataSNNtWgVtSaMgBcactaaatYaKattVgga
+caWaaatgHtatHccacStaatagaYaaaVaMaaacYYMctcagaNattatctattaaat
+atgMaRgggtatgaMcttaHgattgtScgtgtatVatHNgcYttNatatBWaaactNVtH
+ScgataaNcBataggtaagagatttMatVtaagtaaatYgctgttttaagatagaWaaYc
+gctaacttaaagaattggtSYgtVaStttRtcKtHaVcWaYaWVSccRactDaattgWaB
+SKtaDgtataaRcttaaaatKcagtNgtaaataaatgattcatgtcKRctatHaYtMaca
+WNgagatcDcgDtatKaHgaBcaaaNWaRataYtYYacttgcactaaYDcKDttWcYata
+StKcgcaaaaaRaaNtttatttgctYatgtcVctttcBKcgtcttatSttattYMttaat
+catattcatSaYtgWaDacgaataactctggaDccattacgSagaaattgatttaDtHac
+gtcMgaMHaaNDKttgtaMgRNtacataWgttccStgaaatDaagYRtDagcatcHttcV
+NWWataatataaccKaatWtYgcctacVaagttWtHactaRaagatatMMtYattMttcc
+atactHgStagHcaattaagacagaMDtttagcHtgccctttattatSatWataBaaSMa
+ccVVgtggatgtgttgYgtDHSaaMaKcagaagcWacaaaBagRactKacDaDgagagag
+cgKcaBggtgtaYttatgcDatgaNgatagagtBtNtaWatagcacgcgcatDRSacHtt
+cataBtaWaNtgtaatcDctBaSttttaggcWtBacgacaVYtRttaacttatgKcggDS
+tacgtagaYtaagtaatgacggVMKtWagcatatagtcataagMgatVagVttSaacHat
+aatatacaatRYaHacaWaaactRtHRaatagcaVtcMataaacatattHaStattDcMW
+VtYaacYagaaHaaWaccNHcatgtcccgaNttataaNaacatctBtaDNKgMtcDtgMg
+tatgKgSatDSgMtgVaaHNWcDcaaKgHMtaRtggcgRgtHtVtatHgtMggaRVgtcD
+gtWaactactgttagaKcccDctcNcgtagtgStacgtataNcgVaHHagYttStaaccW
+acaKctgctttaactagtVatttaaatKttRcgactaHttSaKtcagBBaWaacccgRat
+KagNagKaWtHttttcWtatatttattacagacSBagDgtagtatHtgcattgcaMaRgt
+agatYacactYSBDgctgatcMattStSgattcNttaBWaacatgcttSattttctatNt
+taHNtSctgtcWttKgttgtttttKaMHNMcaacaagNattRtcBaccatKgtVtaaDct
+tgattaaaatHgaataKYtgagMtgcWaWgtRttcDaatgRtDgcNWSgtagtatRttDc
+ggatHWgaagtacgcVtcaatHtttttttgaKggaSaStaataWBMtgcaaatacgWttc
+tagccRtaaaattNWaMggataRRaaHaaMcagaaacacacgDaatctactaactDgatg
+tttaaDacacVaNgagKaBcatataaattcgRtSNaatDttKgKDgcaaactBDtaatat
+agWaBgagtgtYaaVatatMtaacaggtataacgKMtaKgcttgNMtRaaaaVcHctKct
+aaBcWtcHtaRaacKgcaDKaYaSHgtatttataaYtcaKatgNacgtcWWatgDttRaa
+caaDWaatDgagaStaVScctgcacaaBtatacttctgtctttcactacWcaaaWcactK
+attaKtatWagttacttgBtgaBMagaattgtYYttttVatttWtcBagaatcctcWtat
+YcVttattMgNgYStaBgtttcttWtagcaggtMatgtRaaDtDKttgataDggtttatg
+ctaataVYcSttBtYcatctVtBtYaVagtaaDtgagacctgaaatcNKDactgKtacgB
+tDKgattaaatagattatagactatggacgacgRgaaYKgYaRtgaaaagRgBaacatct
+ctMttgacNaWtctVagtStMaactacaatttcVgatacKctaKgcSactaDaatHgBgt
+HgYttaagtNYtRcaRgYtBaactaatatDctaacSKatSDMatWtagKtttagaaHKat
+taVactttSgtgtagWctaggagctttgaScatcggSttaggtgHtgYatgtctNtagga
+aatDttcctgagagaHagttKcttttgcHtcaDgtcgKtatcaatgcgStVcatcaWNcg
+tatttHtatctggaHWSataWaVttgKgtKBaaaggtaMNaatttRDtcDattaStctaa
+atKgtaagtcVgccaHKgtgtcgaSVtaaaaHtatgaaVcatacacVtKattaWaKDgtt
+ctattgNcaagaacaKYaHttWcDaccattttagacttttMttaRaMtaHtacNgccgaa
+aaacKctNgaaagagggaVttttgtBVcatttatttVaHcgattWttMaWcattagtaYc
+MagaatKaYtcatttagacttStDtcagacattctcYaaKMttcagtSNtBtMaHacYWN
+aactVaMgtcNgMcVcVtgKaaataaVataacaDtaaggtcSgtDatttaKtgSNHcgct
+VaaaatatagacRaBgaNtaattVWaKtgcaattHttctaNRWtaHtttaaSgWBctVac
+aNVcKtaaagHDaaaNagtYcYKaVKtaaatBaaaSaVaMtcSgtaaacctcBYWttSgM
+aMccagcttRgtVggaaWgagtaggYctRtaaWtgtacaaMNtagtacggVcttKcaMgN
+aaatgtatgaSgDcSBRgRVcYtaDHgaVtWaaNagDtagggtHagHgctRagaNacaca
+StaNttMaatgaataaSgagBgagtgWccDtVgagcDWVctBttccaWcacgHttgtcYt
+ttacttaatVatgtKtaaatttaNaYttaStMtVaStggattgtVgaMRNHtacaaNttR
+ScRtVcgttcScatMtBtttcDtcatVctDaScttagacaaDaaBtaHtacRgRgaRNtK
+ataNgcaaScactcWtKggRagtgtaaYtaaattWgNagatatYtHattWtYWatagata
+tttKatgtcgDagaVcgKVagacagagatVgHWtaagttgcatgaKaatggattaHcaat
+atgKtMaWtWaYSVtNBDttaaHaMcaRctWScNcggtggYSttcagaattattggaaaa
+ttVccMtgggWatatHMaYtaMaacaHaagVtgDtggcHtRaagtHaagVMWacaaaggg
+ataBRcaaBcttKtHtMgcKaVtaacaRatKRaMaRtMtcagcaataaaaVccNcttMtc
+tattaagacacgagatNtatttataaaSagaaatatSccaRHKatYMacgttaWKtgttg
+HtgagatBBaRRWSacatacWtNtcWgttcaaaccactVcaSaYtaactaHgtcVWgact
+aNaatRgNattatagacHatgcYWcttatctaagcttaatatgaaRcaDVaSaHatgaat
+ttBDacatBtttHactacaNaNtataVcaVtattKgMaSaSggttggDNcgtgatactac
+cYHttaaaMaVcBSacctgatatataBgcaattaatBaHtttgtaagggataaacatgcg
+caaataatattaaBVcaWgttagtVaaWctRgBtgYtttccgYattttYMaVMtaHatRD
+aatgVacaatatVBccgttaagactcgcaaHtVaBaaRctaVgggaacRaaaaaatYaSa
+ccVgRaaBtgataaatttcaVttataSMatacKtaWttgcaRcgtgNattatttaataga
+atNctcatHtSWttaVtRattcaRYtaaattDcaKagcWggaWcStaatNVgHaMaBKtt
+aaatYRMHaRtcgtagMRgtattcctHtcacaaaKtaNttcaRcatRtccgatNDagaBt
+tDHtcttggccttaNtattaaStaWgKtVWNaMccaVgVgtatcKacDaYcccactcatt
+cacYtattggatVgaWttctgSDagaWDattctacataaaDggtactatagcNcSgagtg
+tMtaacNtVtcStttSgNDaDYgaaWVgtactRtaNcYgataHagaDtagttggaHtgtN
+tcgcHYgaDttgRtgStatcattttKtWVaYattgNtaaYgYccHgWactgtaaaVBtaB
+attaMBtHtttYttVgtaYMWatWgWtNaccVtgMWaSDaatcYWccaaaHtacgKagtN
+cMKactcgtaaaVtaMatttcRcttgHtattattcRaaaWaWactgDttttccttttaKV
+NaVggataagaagWttcgBtBtVaYcataRtaacBgNaaYctggtatctacaaaagattt
+agttaaaaNaaattgctcaactttBKagatctgctgaMgtBttgtKaSatVgcacgaHNa
+tVDgttacVBacKBaaKaBctccDtagctataWKttagtcttYgtaSccaatcBttggaB
+tMaaaagaYtMgtgtNatgacacctWcKattctgaNtaSgaaataatatVSaattaaWat
+tagDtgagBaHaaNHtBgttcttatHaggaBtatcHtSttgccaatNgtaHtttBattaa
+catcactgaWaaaaaatggatagMHtSgaaBSatacBSaagMaDcaattttcgtctaacg
+HtaaaBtatcttaattagtttatcttcgtWVttatatcgccgaagBgRaDcBaatHVDta
+taacaccVgttHaaSgaagaaatcMSaHBattgcaSgaSVaRttcaMtgtgcaatKaatW
+ggatBVgtataNWgNctttacctttgaaRatSaKttHgaaaYSaBttVacWttcctgctD
+gBSgYcagcgggWRataaaatgcactagaaHStacaatHtggtgtBgcNDttggattatg
+aagaKaatStgcttHtgKNMNRagtaNtaDattgaDDcKtaaatcVVBtcSgNcRtcHat
+aRcggctVBtccaWcaDgaaRaRctgaatMtaRtgBcaWNaNatatWScYYaWttatScY
+tSgcataDtWcacBtactaWgcYtcgtataagctataNSgBctagattaNgaKgatVKgt
+agttttcaaagtgcgcYattcagatggaKcMBtacgtttaacctaaattaaatattcatR
+aggtcgcccattMttaaaaaaactggSgtcccgtctaNtWattcaattVHDagRtggVSS
+aaHtattatWctatKatHtHattYBtaVaMRatgYagcHtaSataaStKaaacattaagg
+gttggVYaaDgttWSttcattaRBcMttttaacatRDaataaMttRgataaagVDKatca
+tacaacgMtaatYctKcgggcBKNgtggttcttaagttYgcataVMaaVBgtVMSNagtt
+atSttgtDtgtMgMDtNKtBgctattacagataMWtcSggtcHgggcgagtcRtcRatta
+aaatgaaYYattgtaaccttgatacgtWcHDgBtVagNcSgBKtaaMtcaStgggatDaV
+tKScaYagtttctagNBtcMcDgKaDHtVtMaMacMgtagtaaWtaYtgHtttttgtcta
+gYHtRaagacDRaatgctVMtttWaYaaNtttatatttStcgactaDatKaatatattHg
+gttgtRtattaattaaaaRtaNacKattctVaatgattcttacWatgDgagggtggScat
+NtcMggaagggHtaaccttcWcatWaStagHtttgatHaRVaaSVNNtcaRacaNaKttg
+ctgggcVattatccatVatataDtDcNgMBMgHSagggaaagKctgggtcacgaatcaat
+aaVtDttaRRgtctStattNBaaaBHatcgttaaWMagatagacatatVgDBttYMacaa
+tttKtttaataaaagcacgVgaaactDBtaaccgtagaNtgagaaaRttcKKagtYKttt
+taStataaHgtcNDcgttYccaaaaMcaWtgggttatcaaRaaggaataaVWcacatatt
+aRYaaVagagVtcHggaBtaataNattagKtcVRtgactatcgHDaBgRBStVtSgNBcc
+WDgaatgaggaaNctttNttttacaaggagaaDDaVtcgaataaataagttaattStBDc
+caaaBgVaDtctScgtgtttttgctgtcacgtttWgacStMtttVaVgaBtacDWtttag
+ttDctaSDVtttNaDDcHatatacYtKataaatagttgaacaagaatacaDDcacatttg
+taaaggHattaaatgttacgtcagtNStttcVatttaBtHtVggttattaaHcgaWagaY
+tVaataaatcaBgaccctHcatKaDatRttHRMcgtcgggSMtaatNagtYtgaYtggMY
+ttgtaaactacgKgStttaaaYatatDtaaSaVVcHgtagatgaggtcaHggMtaMWaWa
+HctgaatctaaBaWaDtcgggtccctaagtaVYDaNactataaNcctKcBcataaatttc
+aWSttttgacHtctRggagRaagacagWVNtctcatHtDHaRagctStatattggcattc
+attttMaNaSaRaNDHaagNtMgtVWtgtMccaactKNaaaVaStatcgtStgtgtaBgB
+gtaatcNtccgaagtttaWgactNgtaaccaatgNatWttgWagtaaKgtctRgtctaat
+aagttVDHgStgttcVttgtSWatcYaggMatgMRcBaStgtaaaaaMttaYagccggtg
+aRRatgatccaaaggtttctaaKgacaDagagatgctcMgaaaMcgRaacaaatataaaa
+gcagtgtatDHgRaVtWBVtggacatStctKccttVttatgtKattttYcatctgttatg
+tcDKHYcctSHMttgSDRNgtaMNHaggatBcSBtHatDMBcttMacNaVMKtctgtttc
+gaHSgtMgcacagaStaBttcWcattctDtcttHtDKBcaaNtRNaaDgaaaaccMRtBc
+WVVagcttatcgaDYccacKtatgatgtcaRttattYttctaMBggcaYctaNtBactga
+ttStaDaHccYaDtgcaRDgSYtYtatBSaYaaataaagtctcgcgttcagaaKtttctV
+attagtWcacgaaVaaVtctcaVgtagttNaaacaatgtccttaactaaaStaKWagtta
+NttatacaaaKattBctgaagaagtYDNtagatataDtHcKcctaBaggcaatctHttct
+aaDNtgtgaaaagRaattataaBMaggtDgtMaWHacBStSMtcgaacYttRMatNacSc
+gaaRtttctattcMaaBggtaKttaRcgtBattcgatatYtVaccSacacgtaaagtctN
+atYttgcSSattttcKccttataatcRtHNctttMcatBtacatgtYtctagcNttYaca
+atgtaBgcgttVtattaaWtaDRtKNaNDttDWaaaataatDgcgcKtaatatcgctMct
+atcatcgtaaaaYNRttSaNtWggatRgtgtcttataVgaaaatcWDcttDRaatMKctc
+atatRttBtccaattBSacctgMtaDDRagtcagacBNtttattttagtDacaagcaHca
+cgRttVtatcatatacStaatMaWagttRccKtRctcgaagttgaatttNtttatHaHtt
+agctatSBaBtcaagtDaaaRtgattcatStagttcaRattacaVgtatWRttWggtttt
+ctaactttSaaaVHRatttYHMKVVcgttMtatBtaSaaMctgMtcaagaMtactcDatS
+aaaacNgatttNcaagttRgacgataVtaacYNataStRtgaattactgtaKtNagaacc
+DaatgNDaaHcataDSYattatgtctgYWaaRaHtttWggcKatgcgtagDSVtMactat
+aKMSttaHaaaacaHatVaDKtSaaaRtcaNWHtatttctWataagctttcccaacctNt
+aaacattcgagaBKVattaWtcVaKtWcggtaatcaatgttcaaatccDttctcaaSaWN
+DataaKatBcaYttRtcataMVtKttggcaaNgtgttatMaccgttgMNagtgVtNBWgg
+aacacaKaaKctagtctacttSaKYMacaWtWDttatagHBacttRttcctgttagtScV
+NaRtaacgScaStttatctttttSgtBgNtttStRatNDWtctgatcKtgHcattatcta
+aaaattNaaaWgWaDWttWRtHRNcHacBVgWttgtNggtWtWcttgSatRtaaYtYtNa
+DttYagactStacYaYtNHBatggatacVtBatgccaHcgtagaaMatgataHagtKgHa
+WcgtaccKaNatagWtDttcgtagggcSgtRatatNgaRtYataaataRtBtcttaSatc
+agatgaaSgtVtHtgtaaDtVactgattcgcatctctBaWWtaagBttVgacHattWWgc
+KataHtBtagScWtcaNtHStBKMHBRtRagcataaYtNtttatacttaMgacccattga
+gtDYggKccNaaRgataWaaaNWDMttMacttaatgStDYgtattaBatBttKcSaacta
+gtaccgttggaKacRtDaataSBaatacaKtgagDtNcttattaagYcagacttNNttat
+cBtHtgRatgccacctaSaatccaRSgtWggtgaaMcgcaMaagSagaaDatHcttgaaD
+gNRttaDKacgcataagYaagtMRttNaMMMgcggttcgtRaSgacaStaaVgStcaRBK
+caMtctKtctatNaactaHtaactaaatNWaKtWaStRSKcatggtgBtgRBtagaatag
+ataSBagMtDVataaDtaattgaYgaBaagWagaacaggaagtctgacgMgtgagaRVac
+McBaaDatKatcNtKaRtcatDNBaaHatatacattaWRBtcaccattctctaaWttWac
+gtccgcgtMctcaaaccHYtNDatttSaDMccaStRttWgttattaSVKtgttttgtcWa
+tgtgStttgttttatcaagacMttgtRDgcRtctctgtgggggcSaagcatVattMacat
+tSgttaacctaaaaccgcagtgagNgtctataatBtHtacaaSccccMgagRVctYagcg
+aatttacMagVttaRDcctRgSSttttcHtVaacatagBgaMRagatRcDBaMtaNtcat
+ggHgaDYgaVgWaaaaMKattBtaDYBaHRccagttatacVaDcacactcgtaSctaaat
+atRDaccagctttttaatgtagaMaRaaKaaataaaatacaRagaaYaNtatKcDttgHg
+cVtaYgDacagMBagtgttatgMcSgWDWYWtSaKaagcatKatatctcaRHacagttaK
+tgBKtDRggtcaYcattcgcYattttgtccaagtVgcattttttaVaagtaaaagtWcct
+tgacYcaagtaatataYBaatataBtaaatacacttttRHagtttaDSHgNtNVcatKga
+KtgagttgaaaHcgBattatHgRKtcaBaagttgtttgtVatYattaattBatYgaatgM
+gtttatagtKcVctagttaaYWttWaRKWggYttgaRgagaaMKtaggtattaMVttata
+VcagHYacaaMaattRRtataWaaRacHcattaVaBtHgtatBaRtttaccaaggNgtaD
+MtatYtaYVtNtcBRKMgaatRaaagaatactRattttNcaaaDDaagtagtacaNtSHt
+taaataattggtaaKtttaaBaNgtaagtcaYttacVaataataatDtgHSSgtSDNaat
+tcRMBgHttctaagaYVcHcactKgaaNHcgWaWttaaBactcgYtDaacgactMtaYKa
+cBgttcttgttataBacatScBcattKaaattacttSSDaRgKtHHagRNRMtttBDtca
+agcBcgcYattactcgtttacSaaNVagtacacgtggtSaWatBtgatttWttScaaDtt
+tggtKtNKaMtMgcttaHKaRaccgatccctgtgggagRMttaaMaWccggtttBtgtta
+aVtagMWctNtctHgtBgcttatSMYccttgHaatatctgNgVttagcttagggaBBSSt
+aYgYatYgtaaaaattHatctatgtWRNgtVcSgtgcgtcYBagtRHgacttaaagSHat
+atBaaDgcaKtcccDgcacMttatRaacaataaccWtNBaYatttYacYtagagattRta
+tagKcatattDgKtNNgtttWNagggtacStataRtVDYaacgtaBtVKtagaagRtttt
+ttatataSaagaaKtaatatKtattagBtHataatatcWNaacagtgWaccatatStcYc
+aaNRctcKacKttgtStaaKRaWDDaatBtttgtcagggBgtggSctaaWtttYVWttNt
+ctaacatagVYatcagatctVaHMgWtcaagtataHtgacaagttSacgtNRataaatgt
+tgNtaattagaattgctMaRttBtacBatNgacatttcaMcgtaaacctctagHctaaKN
+ttBatatttaatattBaKtRagYtatattSgtgtccBaNSattgaaattgYggcaaataa
+tatHcaaaatcMBaagYatttttaYttYaStatttDtacRtgRattttttgDcRaggagc
+accaattcRcttttataHcggatcatNSatgtagtHHcactgtWgtaggtNgactactHa
+gagHattcaggggSaatgcaaaacSSKDtaggcDtatVagMtggactaBSatagMttagg
+atSYttaacBtagaNSVtaSaNcSScaaatattVctcYaWYtBcttcgaYBagWtRgagH
+KagagMaatttMatgtDtaYNagDtaBagcKcKcaMttKaaaaatVaatHDaataacgRa
+tBNVKtMaccYaaccMgttgtactagcttMatKgKBtMagtcttMWgaatRcacaaaaSg
+cgVtSatggcaggcgKaYaatgctcattaaaggDVacStgttaMaaaaacNVtBtgctta
+acgtDNaaRcgWaKtatactagcactgKVttaatcttRcgDHHattcStatgatcWataa
+gtattttacgtcaRgaaMcDattYHattYgatatcacNNWtDatgaaaactgaatHagga
+NcttcctKggNgatBaaatttgcaaaDtgctcaatgtYagacMgtVVtgDBaacVaatNa
+DtatctgaaggKcagSggVtacgatgNWtKWaggMacctagaatattcttYaatDatcgt
+tgatggtcaacgttatatgcttaWVttccRgVcaDcgagMtacattaMtaVWcgttRcat
+RacaRcMcaNtaYWNYgMtatMgccctaKctagHtttaaBVMaaWcSaccgMttBRgNcR
+WMtHMaccaatgataaggagVttYgaatcttagtgtcMtgcctVtaRtgcaccaDaagHa
+ctNYcNcttaaggcMBagaWtattgtgctaccacgcWataRaHtDtacgaaVttagttVa
+cctatatStDgtggtaMgaSattcatgMcaRctatgWgatKatYYaaataNYcSaDtttg
+tcYttttttaBScatRtctgtaWttaatagMaacatDttaaaNgaacttacYttagaacc
+ctgNgagMNHaaKacccNatgKccttaKcatDStaaStNaaVBatagttcacRtYcRcKa
+agMgctKtBagSaagNcKRttaaaaKaaRttttttatHHNHaHRtcaRcMataKDDtNcK
+tKatctaaataaatRatYttMccaaaNaaWgctgattcaaaKgaatScaNaaaKaBaaaa
+RNtataVcYDattagctattaaatWtgBWHgggtatcatattatcVttcgHacgcgatMa
+ttDcaRggDYtYttNaaaatBKttKccStYVDatatYcctSacVcattttatMtWRctaY
+agRgctcttttaacVtagaNaVRaccgRaattaaVcaattgcgKRctMaKtttHgctttV
+MaNaRaNMKacHSagtWagtgNatKttatctataaHatgSaSattcagtDctWaataaYt
+cagtaYtctatHcgattSRttaaaNDgagatatacttVttatcataSSaBNaDataRtRR
+aattcaRataaRtattttNaRYtaKttaccaaaaaHVaBtttWtttgatRagctaMattg
+cttactctgatKtgatgRBttaataagYttcStKaNgcNatacgWatYaatctggVtaaa
+ttYccKagaVagggatttatttWacgaBcaBtaaDttttcgaBcHDgaaSgVNctgaaKt
+gaVagtVWgRHgtacaatattgcMDNNataatagaaaataatNtNgccgaaMaagtgNtt
+acgVHaacSgStBBtRagtBgtaaWgacttcKgactaaatgaagVaacaBtggtacattc
+aaagtgattagKagNatatVaKBacaMMctccatcgcgggRctttKaaBatcacaScaNa
+aaaatVgHaattaatatcWcacacactcatgctcgaRggVgcatatcaDcatYgaggttD
+gWNagagaaagagaYttHKaatgtaVtYttSNaDtcgaatctattSKgtgtaggaMgtac
+cWcaMRtHttaaatgWtgtccgtKtacggacaNgaacgaSgcYagcKBttNacaagatac
+gaagaVcBgStMacMtgKaactataSgWtaaaatDRataaaNaSaagHttHWYgaccWMt
+atataaaaagatgtaKtVtgtcBNMtRaSaRacVataaNaaaDtaatgtaaagaDgtata
+VDaacagatttWtDtcBgatggBcgagctcKWgtHcBgcMaatDNatcaYtctBgaHtcc
+agHctttMtattgtBccaHMctatctNaaatacgcgtacatacatctaDactactcKtac
+ctataDccMattRgRggHtaaaaNYcVtatccgttSaagYcgMatttaVattttHagVat
+VtttKattaagttaNaacaccHSttagDactSNgtgtttaNtVtatttatgaaacSaKta
+ctctacgagttgaagtcaSBaDgtagatNaaactRKttcatcWtaBaggKtKcYttaDtt
+atMaWcStgattKattgtatatDttatDtKatgtaNtgtcgtcttttttaBtDBcaaaaS
+gDatgHtctacaattcgMtVYtatgcattaaaattcaVgatRtcagBtcaMaNctHgtat
+VatcHttcaDNKgtWcgagHtttaccattNgaactYacaKgaaagtggtttgtgatcgaK
+aHgaatYNtBgcaaVatWacNggataccaDtaaaWttBMaBccagaHDaataaBaagYVa
+cYaScctYVgagWagaYagtgatgtttWatSaaaMYDcactYtaStWgaaattacHgKDa
+YtttttgttcaaaaatttgYatatVcMatcactggRaaMVtStBtaaaagggatYaagtB
+tatcatgcDttDaaaaMatagtctaataNtcttWHaaatcaVttaRaKtcgatttataWR
+taatatcDWcctaNMatgtttDaYaaWtMaagtcagaKtaMKacgccaaVatgWtSagta
+gctatttcactaaNcaaaNaaattaggattatMWgtgacgtcttcattacaYttctRRtt
+tgMatggNtatacaataataNgatNcMttaggBcDgRHgatctttagtNtacaaccgBat
+gtHaatgttttgatatccgttatcataStaKRaKgttgNaagagKttgNYMaggaattca
+gaactcaRataDttaagcttaccttttgVttaWWgacYggStacYcgatgcSccaacHca
+YNtgRaHtcaYaacHctYacatagatBgtgacDaNgatMacgKgBaWagacaSgttaKca
+tactatatcaHaatataattctggtcNttaYggDRtDaSHgNttYaatWagagtagaacK
+tWtHtBatNtScttttacaattagtaMaatttHgtctagMctaccagagttcaKcStacc
+KggaggtctgcNatctctDgYccaaVgttgaatgacVcatagtgtattttccttcatcta
+cttSgaaStcagHtMaataWNDagtatttttataggcatNKataNaMtgctgtttVaacc
+tVBDWattgHttatattaKtatSVSttgtaScgcMcccattgggtagaKMgaSaSttYgc
+aaMaatVaVaKgtatgYNattcttagWgtcBaaagSaaatRatttNctacaStggtYcaa
+ggttBtgaDWBtRtgaaDccacaaaVSatatBcaaScWccgaKttttcgtMaVttgatgt
+MatacatgNttBaNaagtaggaRaBagaagtaRtaagttacWatgHtttaagSaatgata
+NWattgtaSggHDtttBataaNNBRaatKWBgtaDcBaMaKtctaYatVaKataaaattW
+YcgtaHcttagtgYtgcKDtccatMSaaagatYcSaHatcaDtaatgMMatgcaaatgtt
+tagaDDNtatttgaaKcNtagKYcaBMattaaagttaaWDacgRaRtaKttaaattaVVK
+aMaBtaKctaaWcatctRMtgKcBaBaaagattHcgMcgaSNgactaccRatHtaSNtct
+YcaaBDtaggaagcMatttcaBcDaaatggWtcaHctaKtHcHMcRgattgaMtNVaDag
+ttaggcttYctcatDacWDaaaaaKtaBgtBaatcaataaKgactgactcNcattMcaca
+tNMattgtaaaNaaacttgctaRtttacttaatKYgcttgaSStgtaDaNgtaKgBgMaK
+gccagtgtMgatHDtgacaWDttHKaDgMacttaKaagBtttgtcttaagMagtaHcttW
+cacaatSatgYtgacHgHcaHDgtagaDccVaKcaataNttccHYctctaSRtaYagtNg
+DagatWtRttSttNtRNagacatattttatggactacYMagtMacYaagYgVgKgtNtaV
+cgtgaatcataatcgattYtaaatYtctgBaMgNWNKMgDttttaWtaBaaHatNHaDac
+ctccNKtgaVcWattYtgccaVRattMacBtcccNagYttBYNgaBaaaStWacMgcttc
+catgHaacttYagMtNaaVSYgcgatatHcaatatttgtgBcatWMtaaaaDRttHaBaH
+ttgaacaaataaWaMcaDctgBtatWttaacaaWacacWtDtatttatWaaHacaVagVg
+KaaaDttWgRBVagttVNttctgcttgacatttSHHMKScSgSaMtDtaMcgtcaWaaca
+ctMcaHWRgaactWtcgcMNcactVDaatHcDSttWtagactatgaRNcttagataYgag
+gaagagcaSHcWtMaKStatgYatttttVaattgtttWataaaDaDgataMcaMtatttc
+tVKaKgcttcctDagtgatWatacaRtttaaaBSMctHaaatcagStatStgaaVttaat
+tatttgctaagcgagaWaaWtccgcaaSgaatVgtaStMcSNcgtWggMVWNatHctggR
+tttaacNagtttRtaMBgatatHtaatcMaaaYgatMtaccttaagYatcgaaattMata
+aHatYMcccaaaDaYaVaWgRaHaaaMcHSattcatWSatttcaMtgataKBYtactgaN
+ttgaaDactgBatgYgttaagVgaagDagaatttKNtgaMtHagtaaHRgaaatttaYta
+ccNcgWNcKtaYtBMctVBWttttaSagRHBtaHtcgtactHggagtaatttaaaVVatt
+WDgtaaHaYgDtaacatDtacWttttttatgccacttaDtagtaaKgYNcttMNDaBcaV
+McMctWgatactaRcaaWagaatgcWcRtattccagKgaNgtctcKtWgaNtSttagVaa
+gaSYtcctWatatSgaDaKcactcgBtYacDgMtaKggtKcDtRtRgSaNKctaatHtRD
+aRgatatacattagtgccSttctDgcgatNcatttcHgcKtagcYgttttgNKWRattgB
+taaNcRaatcNaagcgaaVKttYtWttaBttttttNggKcgaRBMVtNcNtDVaaMtcBN
+aKtaataRMcaaaattYactactBattWcgccgWaaMtaBYtgtaHagtcttVttaggaH
+VaaNaNaatcttgtgcattttatMDYKccataScaWgNttccttttMaRcVtWHgaaatg
+BaaRatgcgatataaaWYacYggtacttaaaaDaaattgatcWaatgtttRcatatcagg
+aBcttttcttVKatKccaccYtDatMtcttacMtSattaatatagaatgSgagYgWNttt
+agtatgRggYKacaatattgggVtttaSaYcaRtBcggtDaggYaaactNataggaggaD
+gaKcaaataagatMKaattaaNagtagttcWctataaDtttcgtcgtattaccStgYgat
+gKtgcccYatDctYtttttYttaaaagaactcaNVaaYaYtccagacBttKcaatKataa
+tKVWcBataaatgttcctatYaacttaSVtgataggVatgagttgatcttacgMMgtWtY
+tagcacaSctcHYtataattMttataYaaccKgtgtaaKcYagaaVtcBKattStgcaaK
+caKKaHgtaaBtctgcaattaWgMcgYttMctWtaDNcDatggWaattggaVDagKattt
+tgaaaRHattgMaaMgtaatcattctKgNaacacccNHataaaatgaaagagSatKtacV
+agttggtcgtgcBtgtgcatgagcaacataagKtcagtttgtDBBHWcgaDtatYttgat
+tcttaaagcMMttaKgDaHtatVgWHccgatKttcaaNcYtcaaDWDatcaWtBtWHgct
+aaMDaDWtWtNKcRRaNttVgHaRgKgcWgattNaaattaataNcaRtagtRgaacagat
+aDKgtatScattaDgatcatMtcgYcgtttaaaRctcagcRattaacatccStcBtgacc
+gtgWaaagaaatgaaWtattaVtHacctaccaaatgBgtaVVYaaaatccKgtcaactat
+aDgNagtcaSgtKttacHtccMKKWattagtatNctattagtttWttRtgaKaBHStgRa
+gattaKRtWaKttaaWaagtaVccctgcgMRWatgttNKgtcSggSHtaBttgtaYaatD
+taVtaatgtHcatWaYcMttataVgaaaaagBgaagRattccggcttDgggcttcttaac
+ttRgaStaMBaaMtctMBHBacttVgKggcttgcgBcBtgDtttcctattaaRcatStNg
+cKgctatcccacSctcHtaHWtgWaYatgVaRRYtgctaaaatggagacctMcttgttMa
+gBaKctttYWBtaYKgcccYttaMgtHaaNYgtgtagagDttcBatgtStttMtBWtaaB
+ctaggaaNgaRgcttttttgtagacRttHSagaatDaYgcctMBtgtNSNaaBttgVtWt
+ttKgacaatatVttVatagatttgcgtcgDtVgtSattaaaVHtaDaatYttatKSWtca
+ttagtaaNatctcagcgtgcKcatDtaBccaaccctgaYcattaNaagNaKgagttttca
+ttaHMaVKMDDtaSHScaDattgcaggcccMattatacYtMatWgatttcBcBtBctKac
+ccaaWctatccctcaacaataaataaMttgtaHHcgatKgaggBtRYattatacgtaYNB
+acagacaaatVtMcttttRtVcaattgtttgaWtaaSacaRccMcaaacttttaaacgta
+cVBtcWcSaYHgtattacgRtgtgtaKgWgaatctaBtcgtgRaaaWWVBcaNtcgctgY
+taaaHaSccaagaVMNaacagattaHRaaMWcVgMtctgcatgaagRDattactgcKHtc
+actYtccttatgHtKgMgKcDtacNtcaStgYccaaDagttDtttgYcaagcacWWttaM
+gccaStaaWtVactgaagtKtttcaWaatgMattatKcctctttttcatgtaaactttNc
+aaKgttttMaMcYtgWctMtttactttagaKtMgttDYttctatagWcRttatYSagact
+tcaScaacaYtSaattcaaagtgctSaagctattaaagggtaactcacgDKgttaMRggg
+attttMcgttattaVtccaNagaRgMaataaagaStcSaacgtaWttatatHgttHBcgt
+acggKBtSatDactRggaRgccBRttctaaaatSactcKtttVaWRatatttWaHaKMat
+gtacatcagctaatggBgaBNSNatatcYStagaatSNattaccgtcaataaggYMRtaD
+aatVgYaDaattataRgVaagtgcaNKtgttgacttatHccacHaacVcWcNMDtatcat
+ttttaHacatKtatagtgccWttaattttBSDaKaHaDttYacDtBgtMNgggBaaaaat
+tDaaVMaKgatcggKtgtctatctctVatcDtaagaagtgtaMcWatDggaaaaaYtcDV
+tNttcNacgaYtcgatHctctaWgaaggtMttcKtcttaMgtctKNagcRWcgBVtcBDa
+tYKtctaVaaaBgtaRagcacggcaHHagcagaaaaacgggtataatcaaWtacYcWtcc
+taBgVVaBagHaaaaaatataRYagaacgggVtttcHaMtNtMgcgaaatKtattaagtM
+ttatcttWttttRaatatgttatgtatttRaagKtBgtgHtHDggaBDtWccattcKttt
+agtttagtBYcDaMBtgatcttgacatKctBcaaaacaHtatggaNaVttcgttattttt
+ttcaaDtDDaatcaaaYaaBHttaMKMVgctgWtacVtRaaactgYtcatggcVHtgatt
+RttataBtcgaaRataDttaatcattHtatatccNattcaaHtgKRtRtagtKaRWaata
+YaggatccacttcacaatgtgatMaggactNaaccaaMaaKtagaaMctacttDSaaaWS
+gctcagtWaataWaHtStMacttaDtgagWaaaatatttatcaacaactRtDgYcYtata
+tgtataatWtagccaagcgtttataatDgctgVaaagHaattagaatBWggttctBaNta
+ctHtKBtcgaaaRttHBatDaaKccaSHgtgctWttcBaatcctYttgaHacgtatgagS
+tatRtMaacKacacggaaSctagDagNttgaKKSgtttctacgtagSataHttDctggBc
+YtttaaatcgRgagagaDtgRSaVStggVtgacgtMtatgaaNtWtHgtDaDtgttNaSV
+agaattccgcttVatatacattatataYtaggYaaaRDHttHYDtNgcatHggctattYt
+aMcWaaVtaNtatttHaagBtatcagatHtttgaaWWtttKaaaggBtattHagtaacac
+tDggtattttScttaaaacaStcaacHttMtatcagatSaHtaVtBaNYcttHcatgHat
+agaaggggaWgtgBtttagtVttgacatYtKtattaYSggtaaaHgcaggaStHtYcgta
+aDWgtaaaMcgYtNHtgNgcttttataWatttKWaaKtHattgRtBtMMccgtBtYttga
+KaWBatcBgaaacaBgaagatYgKWaaacBgatgtDaaacttDcacgatSKtaVaRDWtV
+KgHtcRattactctattBacaaactaatgDtaatcatatKRattSggtcggRMaaHVtgt
+tMcgatatcccgVctKMgBactVtWtBKtgWtaaaVaatRgKatttKSaYHtcVBNtgSt
+gtatNStaaccgttaaaaYactBgaaaaattacacVttKattVNgaMattNccctaVtaa
+StctgaaVatactgtctaaaKYNDtataWtattaaNgtHtaWgaBMttttccaaaDcgct
+gagBacacttctDSctcMtBtNccaacaaatSVtatWggagSattKatRBaaaNtNttta
+gacttaagtHttaatcgtWctHaMBaHtaaagKaaKttgatattttgKcgtcDtgtKtHa
+gDtMtatgatcttgtcSgtWgctaaaaattDaaaNgNYtMttNHgtHBataatMgMttct
+DcgtNtNatggKatHtaaRtRtDStttRVcaatKgaaRSRtBttatccataaMttagcaa
+WtagtVgaVBatcVtYtagttgtaMactaaataDatagNttttactagcgcKctDatatD
+gaHtRatVWagaDtttcggSKataacaggaaKggMtttctaVttMaatgattcgaagcga
+ttaNNtYactttKgaatWttNNgctatatgttacKaMtaaDgtKgttBttHtDacaagaa
+RgDgttWtaatgVBcaaccatgcYggtRcctaaDaaHcatYNaaVDNtBgtBaattYYgc
+HttRctattVtattgttcKaaatagtacccttgcVtaaHttaagaKtaagSaYtgcactt
+DattYttaVgRcacaattDDttagattttcHagccaYaataKaatccVDKctNcctcaaB
+ccaaBaYgKacWVtWttatgcSatcDHttattaacaagaacRSactBHttDaBBBcacgt
+tactHaKgacaKtaWMcHtaVHttaattcgttatatBaaagatgaactaaYgDNattNaH
+gHKtaatcctcttcHttagaatVcagaHtagBgtMataattaagtcSRcatSagMagaaa
+acgYacgagcacgBcggacaHKaaBatSatagtatcDttRHtcagtDtaStYtagaaagt
+YNHtgaacaatgcgataaNgtNVagtacccctBcgaYWaactRtDtatttKatBccVKtH
+ttNcttVtgaKMtgcttggcgaNatctcKggtcttttataaacWaBttcgHtcaHtcgat
+cgcggccaHaagcVgKattBaaWttKcttaVaagYaVacagaacgcScDcgatataagtt
+ttacaaKcaaaBcYcHKctRagcgaatgtScBagMttYHtaatHcKKtgggatgKSaaat
+actgWBHVcagHcttVBgYDtaVtcctcatRcVKcNaaYaBtattttatRtVtDaaScgt
+atacMatcaaactagtaKataaatStHtacaagagttgtYatctagaBaHSYtaaataaa
+StacaHagWSRSDtagtatggctgaKtaRctaaagBtactcttatgBcHcNtNRNtHata
+accRttagatataaHtacScgtattgttgtDcctaYRaattccaNatgtgctaaaactMc
+aWttgttgVMaSgtaVaSctMcagtcacNaWacgaatWtaRtaatSgatgaaWtaaWcgt
+ttHtWcttgatKtgDtDMcagtcattcacttgaaatactWgtattcHttcataactgctg
+tgtKatRagtaatttYgNcaatcBctgtStaggtaMatacgtYaRNtgNaHtNccRtgcS
+HgRcaatttVcctattaBKtgYtaMaactRaaaaBaattHHtatVNWYHaatcagtaMVt
+ttctattWHtttacaaVccDctYtttVtNtRRKtBgatHtBcaatHYaSgaagaagHagt
+ttDaVaattVactactYcaDtKttgVVVtaWtggctaSttgtaataDctWactcaRttWc
+MSYtWagaagttctKHcgKtDaYggaDttgtgtataacaRKctaacttcYaDtccNaNtt
+aYtaatagRttaSagaatBtVRtaatcttatgcgtWtataaWgHataatttYYSttYcgg
+KKtaHcttttagHDDBtggtttaaacatagaRagtVagactttacKaWDMacgYaacctg
+ctKaNattggatggNgtKcYSttttcctttDtYttBcatgattSHaaccVtccatctccc
+acDBtgaWBaMaaccgttttcttaaMgScBNatBtagtcttccttatKBRcctggtVSta
+tagcDgMgtacattacccattKKtaRcRatRctYVaSagttatatYtcgNDDggKaHggc
+ccgcRtacgDtcYctgaaacHtatattaVtcaattaaatgaWaBggYtHYYaVagWacaN
+tDtaRattgRacRtacacatgHtagagtaatatttctgDDcttgNDagcctaaHtatYHt
+KtRaScgtattMttacaacHggttttatSgaHVVgaattaatagttattactgtRtaWga
+taMDaaaactgNYacYtagKtaRcaYDHatatVatggctKtWatHaNttaatttttgtaa
+gcctggcgKataaNtttRMNggDtataaaatVcMRataacagctMatBgMtaaVcgagat
+tcaaaSgtgKacgtDHatWaatgttcDtWatgYcWRttcatBSHtttgaatatBgaaWgg
+gaaBcctSSVaagctSctagYatDggtatatgtaatatgtatgHYcRtagagtHcgggca
+taDHattcaaattcRgcaaaataagattcaaYVtaBtaagRagtttgSRtgRYKgWggtt
+taaHgcHStgtggtctaHaccaccSaaaattaHatgttVtataccagaatDKVtctagtt
+tcaatgtNctaccgDcacgaattacactatgaaggccKVatccaSWaaKHtttSggatga
+gMagttgcaatatKYtacBttaccatHRttaacttacaDKKtaKaDcHHcaYatatgMag
+aRaNNttcggagYRtacMtHgacttagacBaagggBatcttgaRDactgatacatatcSB
+ggtaaaVWgMaatttaYtaWacHattDMtttaaaRRScatcttctaatacagtBVgtgtt
+tBagtatgBNcaagHaaaSaSYKcacMtKatggcacgcctSRaagcataattaYacctMa
+aKtcggaBaVaaWaDMttgccttaaacttDaaHacNVtgagaataccactctMttaatct
+tHcctttaggaKgaggWtaNataYgtaggtgaagtcWDcWaBatattRtVgtRgVtataa
+cDDNttatcYaaaagcaVgtYggaDattccgtccDcSttaaWtttcaaaatggataSatc
+tRYcaaBctMMtcttaacMaSgDatgagatcaYgctcacHccMgaacatcDNgtNRcgBa
+aatagaYgatgcttRaattStccttgagcctaVaagggatatcagtaNMttaaHcMaatc
+cScBtYaYttatgaMNagtgHaatHacaHaBaaDtaRNDNcBtagBgacatStagacttg
+taatMtYaNaKSaccBtttHcDaHNBttBaacSaggagaacgWcMgtRcaagattSctgt
+aBtcaatMtaHgcaaccataVgtaagDRcDcggaaccaBtacVMgSttgtcataaaaaca
+MataHatgttaacaaMgtacgtMVcatagYtKgtgtcctaBcYKattcaggBaaHagStc
+NcattatRRaSYtYDRaHYttttggaRggggttatKcVtHgctggaNttaagagBaacat
+tggYaaDcSacggYaRttacaacactcDcacBDtYataaaaDWtctcaggVtaYttKtaV
+KtDSaMtYtYcgtaacHtRcHctaacBgattttagHaScDctHttaaaatVaHttggtta
+tttDtatHtcaHcBagSttttDctttWtctaaataaWtHYtRgtBccSaaDSaNgatcSt
+taaaatgaYgKaaDaVatatYaRaHDtataKaNtagtacataggSaatMtctMtccctWg
+aYtaggataMttcgtacgccYgBSgttaaHgctRgRgtDVSRattttttaaKtRMtatSg
+RaatKacMaYgggtagBgNHcgYRagHcatatgtgaacMtacSDRMHaaacHaagtWSMc
+aattcagtDctBattgttcatttMBaDVHVDBtaatKactNacgcBYtttgatctatVVt
+atcKaKSgtaWcgtcgNYatSaRtcaggaRtctattagattKHttYaaBtcacatataat
+tMgtatcataKKatDVtWtaHtHHVaggaaHagWaHtattgtDaHRgatgtaaaWaaSSt
+MatttgNtgtcagDWgagaBagtcattaataggagttcagcHttgWagaWcRttaKttaD
+gaDWtYacMWgRaatatccMtaaattRaatacaKYcgcatgtatgtNaccataSttSatt
+tttcgatcttcaaKcMDatgaattcaMWctKNcHtctacaYgatgcaBtDDWtaRtScaY
+aatYSgBtDcaacYataacgcDgtaacMtSaaKcKttttDVgttgtaaNcaattctcaat
+aaatcSVcKaacattgggacatgaaaacggaggagtacDYgatMYttaaaBBctccYgcg
+agccHattttaWtataYcaKaaDYaaaStMctSattaatataNaWcacaataVtcataca
+HcgMgaatYgaataatRcWcgtttcNDYcacaaacacaNttttaatctaKtRttHDSttc
+cWatatagtKtgtcgaccaBgtVacNaYBHgtttSSagcNtctacctttaacgacaDcWV
+acSHcaNacatttgBYaaagatWagaacYMatcKgBYcBggtaWatataKcNgaaaattH
+YtSaYDVHSactgttNRgaaaMBtatataaaaacVtctWtgKggtatDBgHaKaHVcMWt
+YYBaaattaVtcgaaacatggagYKtaaaacagttNtttatcatgctagYcctctNgttc
+tgctaYttBataaRtattgatgaaactagttBgagtcttccatBagatctBaaagSacag
+taaStaaatatataataatcttaactatVtaaBattHcHgcttSSaaDRaKtataagggK
+aacRagBaggtaMYttggtacMatMttttYttaacttaBaYaaaatKgtactactKDctc
+ttgaDtMgattgVgcRaaaKattaatataagWgttcaWgtcaKtatcgacatDaaSatHt
+ttcagcNtatSggtgtaRtgatttStBaNaHgcagttaggggatWtttgattttatcgaB
+tctaggcgtgtgtWttttaaSaWKctWggtgataaaattacBtMRtatccattaaSWtta
+SMcYtHtaacttaaBaDattctatKatctttcatDtcgNcgacttgtaaaattDcaVatR
+acatgaaagtcctgtctcatacatatcSWgNDttgaaVKatNacDggagWaaatgaaVNt
+ttBataaagVttVataataYcNMVaNaKaatRMcagNacVRactcWgctttNatHaRaBR
+taaatRtaKtNgYWattaatcttaRttgttcttaaWaaagttcNVtagMaBatcVcgccD
+aaBMgKttgaVaaccgYtRaactttYtcatgattgtWSaaBatagtagSataDgatgNta
+WatcaMttaHattagVtggagaNHtaatatctNaagaDBatcttttaRaaNtBYagtaac
+VttYBtaagcaaaMatcNgKaggacagagtgaRatWaDaaSaDaaattVgcWttatBNct
+gSagtctgcSttacSRtgatHDgggcBagccDtatYaaagaataDgatDaBttagctatc
+HtcWtagggagtDtSaaacagtagcttVatgttggcStataacttVtaatWKtatDatct
+tcDaagactgtgDNBaccaattaacaaagaaHWtatttaacattWaatgttcMttaNNcY
+aRccHtacRagatccKaaYactcVRDtcHVtgaaNaSatctRSaWtagagtcgcaataDc
+agBaagtctSNagaaaKgttataStaatagStaatSatataWttctcgtaDgtYRcgtHt
+taKtcDttRaatNacYgtagVaattNttttatDgKcttttSaaattYcgYBaaggttcta
+gYcBataacVcagggaWtaKtacatgcYcctatccDatatagtcRaaaSMgtggaatcaa
+MaatWcgctagggtcattaVtctaatgHcaSHtcacttBaagaMDtactYgtttgWgacc
+cStDtagaDaBtgctctttKaaaatMttNStggtttatWttYttatKMKgtctaKcgaBa
+aaattcccgacYtBcaKaKttRccaaBaWgMaMatgtWtcRDWttcggacNctataaacK
+aaatHatggDatSaaKtgcgRaaacgtgttcatNtgHtcaataaacaaWMKatattcWaK
+cNaccWtggttcctBaMttgRtggtWtaaVggDgttaDaScgWccWHatacaagtaHtaa
+cttWaNatgtgttaacKaVtcataDMattgtaKccttttttStaaDDtHYattNtcgata
+taBattctWRatMVtStaSaWttNRacgatagtRcgcRtcctttacagBKaaVcYtRaKa
+tVtaWttaVggBBatcaaWatgtggagattDgWtttcaataDtactRaatBattWVactt
+WVNtVagHaHtatttaVagtRMMtaBattatataaNaagatHBtgtatVtaaacatttag
+tccaKDcacgWaaHagttVKBgcgRaSYtttVcgaacaBatttaatctaSYtccNtcatc
+tatttatBaHcattcaBgDMYtactgScccttRctaagtaaNtaaaaattatggtVataa
+agVStcaatcacgcDaatgtaacatDBagtcgaaRDaSactgcagaHgttYatgaVgtNc
+cttcaKHgcgataDcgYtgtgBatcacScgctBcVttttcYaaNtttttatcBaatgata
+YgtgttgtatgaVcBagtatagtNaRaaatKVtcRtcWatctaattgtVgataaMataWa
+gaDttaatRcgctaKHgaRagtDctScatNgHgtKgtDtHBVgYcagatgttagcgaata
+aNBactBaaRaWcRcMctctBtWKaggcaataatSYtccagtRtaSVtRgatctaBgDND
+tBgtttgtaNtWtaatatDtataacgccDttcaMaMatgRtgaaaMHatgBaatgcccDa
+gNgttRDcWtaaaKtMSaBgctgcaatgtSVattRWcBtDaaMKRcccWtVttaaatatt
+tctgtcatNBgaaaatHtttWtYtttcaacaaagaaNYBaatatctgatNtgaacaaMaa
+YcNgtgatttWtNaatWcYMScMctaaStttNgHtMacgtMDtgagcattcacWtttKtt
+BtKaKcHaBtttaBacgaaNYaaaatBaatNHgaaatMtagatDcaagMtaattctKtgN
+tScaatagcaHDagtagagSRcagcaagaccYHtaNtBatKtStcRagtgttMaYgtggg
+tNatSaatStcYtaBaSBtaggtctMtatcatgaattactcYtNagaaaDtggaaatKBa
+ttaaatcWgKtStKtcaWMggaattYtggccgaWcacagaNWaNgaacaYaHgaVtMctV
+HttaKDcctNccBKMDagtatgcHtttaaaDaggtgHtattcatatttaagcBaaaRcSg
+ttaaatgWacRatacaaatgBatYatatRBcacaVataRaKWMcDWtSaatatHattcVg
+MKYtgtaVBtgagattRgaatgaDgtcaStacgctaggRggtSagKcWYctacaagtttB
+tgaBttacgaStHgVaStgtaRtacaDccNDattSRgttatMtNttttWHacDtttVtga
+cgYattccWctaagtgaaaMMatgNtctaataRctgaacatttVcNtgtttgaggcaaag
+tatgVgtaVtgRDcttBDtataaMBatatNgataataHaaaNacaStgaNaHgYtgacag
+tcYDggagattNcaDtKgtagMaacSHRtcagNagatKcatataVatactgRVatgBtat
+cgttattHtHcKaDtagRagtgHtaDcVtatacattacggcaKttattgacatDaatgtc
+tcattVcaRcttttgDtNHSggcttaYDcHaatcDYacccWaMttgRtNggYtttttggD
+gctacVDtBMgBaDgtMaaBgctBVttVagaHBaaaaatgNactaattattNagaagNVa
+BgVtRgggatacgctgMtgaccatMaaDYDaagctggtcaatggtatBtNtccWtWKcaN
+cBttactgtgBYDaMtMtcWaatctWYHatccgWtataaaNNacNgctYagtaaaRtaaY
+ggcagaMaagggttHaatatcaccVtagtggcgtMtagtcaYaaRttWgBtctgaaBtKa
+ttaatYtacaatcKcacNcMDtgtactatcDcgRtaaYagattgccMtgtYKaRaWHgta
+ccttagcRaWaagDataccagcatcYtcaaSgVacatttaSttSVDSctactgaNctatV
+attttacgaggWgtaaaKtcNgatgttgcaaNVttagRtttttRttYYaYcaaagcVDMa
+aRaRtccVcSattttcaattagWattMMctataWatggtaagagRaaattYKKtgatagc
+MYgcVcgggStattacgBBctNtRgacaacYHctctNtataattBttStaRaaaatctgt
+WatcRacaaMtattYttKtccaatcSttatgtaWttcgcaaWgtWNcBccRgtBagNgYt
+DctatccMaagtgcYMtYctYttgtcVaaHtatgcBaaBcgaataattcttcDaacaaac
+BtagWYaagcaVacYcKYttgSaKVcttccgcctcattctcaatgVgaaacatWWctgca
+gtttctttttMagWttatRggcattattVaagaBBttatctattatMcNtaacagttgaa
+aBaRtaRRtNtataYNtttNtcctaVBtatNtNgBtaHHYDttKctaDctcaNcatgDaY
+atgYagaDcaHgactHgWWaagWtSttctagKaaggYtcataYgBtccRaggggaaaHag
+aacaDatgaaaatcaKtattgWacgtcMSaacYaYgcWYNgagtaMgtSccgaaaaaatc
+tggaMMRaaaataatctaaacgatatgDaggaVKcttttaatgacBttNYttagtatDag
+YttWctttNgtHtcVtattHtcHacattatHgNStgtSaNaactVMcaatcccBHNatct
+tDtcgaKccKttatttctVRaagttaMtaYtcttcatMYRctttRtaMgSaaaactgWac
+HagtacccatttcgcatgagtaaagtHcaKgVBtaattatBtttWatgMctccattgact
+attcttgtcatSttaaHaVtKtDcatcatatccaacKatattatNggNaRatcMSDHRtc
+ctYRaatccacYaatBattcttBVctatatttRNtgaNtcaaaRgtaBcttaaDRcgcta
+cWcttgatatctHttttgtNtYatatacgaVBgYHgattgggtcgacacDtttKVcaatt
+WRcaagBtgctDKDaYtttcKgNgggtcacVagatMgtMVgVgatttcagtcgtgKgtKY
+gtYSaMtgataatNggattKNgaSggactaaBagataacactcataVgttataaSacaat
+cRRaagtaDaagDYtcactgtgaVttWtBaMttttgaHtKaYtattccagccaaBaggat
+aaRtBatNcatgtatatttcttacaaYVNatagaaagaSaaaagaaatSaBgtcgattac
+attgWccttHNattataacgVRDtYcWgaaYaVgMttcttgtDtKaYVttctgggSNtaY
+HWaaHactaaSSagttgSaaactYaMttaMaHVRtcgattaccHtcgcgatgNcaYtata
+ttacgcHaaaMNMtaYDgacaggRgaYVtVKcaSVcWMBBaWaWcagtatHaWBNaMcBt
+atccatgaScHtYtgactcattgaYatRtacttYtctttgBgtattaaDtcaHgcNcaVa
+tagtttggggRaaaccWcNNttRBgaaRKgaaNtMaagcVacgtgttaaMYWtcBYtgag
+taatcgttttaatcgaaaagttDcaatgtggtBaBcNtgNatBtggactttagYttBcgt
+tRttatSgacNaDttatRKacactgcSKaVaaaRgHaattaaaRctgatKaWcctWggWW
+agccgaactaYccttgtgaBHggcYttttBccttaggaKtaaaBacVDcBYYgaWagaKt
+aHaaactaNttatagtcttttacgaccctttKattWcgHgcaDccctHttatVVaagKaa
+tatgggMaNHagattgNStatBatcgaaYgcVcagaatcctcYtBKDatatcNKgacaat
+KDatgaaacgaaatYYcgNBDtataatMcRWtaagtataHgMaVggcaaDtggttcVatt
+attaaaatSVaMaNcDBttataYgttttStacattgagagtccaNtgaatttttKtStat
+atttRaatttcgBDccctaaSWatttaaMBStcatacctgctctatctatKatatgaaca
+actctWBaNagtcgYaaaaRtctMtDgtaBaacaNtacagtcgataNgaVccgtttatta
+tgatctagtDSgaHNcctKtcttatNtgatYKaaStctWDVcaaccgaVttScaagaaaa
+VcccggagWatcVaNtVaRcNtcagatcMMatactaaaWaagatYHRWcaSagcgMttta
+tSBtBtBgacRaVgtgattaagtBgtatcgtNggggDaWgagctgatctatttHaacttt
+cgcttttccatttNaaYgtattttactttacttRataBttgatagggacattattaaSaa
+aYtgatggaDaMttacttatttttttaaWttttaataaWaNaattgtaBtBMcatcNtaa
+MtDaaaatcRgcatccaMtggWggHggagSttacaYHatYtgtaatcatttgVtataaDV
+ttcaYttctHtHtagttWHNYYtVRVccatacaattaaaYatcgcatBagcaatDaWacV
+aBWattagaaBataatgtKaaaNKcagaactNaagaNatgKtBSctgattgWcNaaSata
+ggtataaacVaatDttcRaRtVtVtgtataagMtSccaSScagttgatYattcagcMaaW
+ctaagtYcSattNccgtcgtaBtaattgttgacaaaDttttattaatacSKtcgcatNtt
+atWatacgRtgcataactYtcacHgVgHttYaataaWacgSVKatactagDggcattKct
+ggataagtVgKYtatgttagcgtaRtttaaagacHgacacattcHKaMKtcgKtcacggt
+gatcaaBtMttcttattcttDaKKVgWagtaacatgKatVgacattagWtaRtaccRaaV
+HtttttRtgBccagtcgctagtRtaBcMVWMtaBtaggttaYcttagaSgYgttttcaaN
+NgtttVaagctgStttactaacWattcgtVgtgtKcgtYaaaaaKtaSaattgBtYgaVc
+agKatgaMttWDRatgtaatctagacWaccgcaNgtctgtgagtMttgaaatNtttatta
+RKcgtaWatcaWccaKtttNactaatNcgVaaBcgRgDttcDcatttgagWNattttNaY
+tttatgcHtttBBacgttgRgtcataNtatatcaWVcatgaacatRgtNaWaatcaggtt
+aaSctttcaacatHttVKaHtNtMtcttcHattYatcgatgtacSaaataVtcttYStaa
+gattDagtKccgaccHBYatMtcggBacatVtaaagMcttBgtSagKgNttttcNtSaaM
+aStHgtattttKaRttaMtDtcKtcgagDKgaaaacttaaaWNaattgaWWaaggaaacK
+tttVggMBcatattDacctaMgaaKgcgcaaMRtaatcgataaatRDttataNtVgtaVD
+ggttaNgatBgtggcaaYWtagctcWgtSaacgtattKcgcBtttDacaaaaaStKMtat
+NccagKatgtVtHtWaSBgDttgWgaattWagttttaagcctNcttaBtYttaRactaat
+tggagagggtctagtatgggtttacttBtatcatatgctaKggNcataaaSatgtaaaDc
+DRtBggDtctttataattcBgtcgtactDtDagcctatttSVHtHttKtgtHMaSattgW
+aHKHttttagacatWatgtRgaaaNtactMcSMtYtcMgRtacttctWBacgaaatatag
+ScDtttgaagacacatagtVgYgtcattHWtMMWcStgttaggKtSgaYaaccWStcgBt
+tgcgaMttBYatcWtgacaYcagagtaBDtRacttttcWatMttDBcatWtatcttacta
+BgaYtcttgttttttttYaaScYaHgtgttNtSatcMtcVaaaStccRcctDaataataS
+tcYtRDSaMtDttgttSagtRRcatttHatSttMtWgtcgtatSSagactYaaattcaMt
+WatttaSgYttaRgKaRtccactttattRggaMcDaWaWagttttgacatgttctacaaa
+RaatataataaMttcgDacgaSStacaStYRctVaNMtMgtaggcKatcttttattaaaa
+agVWaHKYagtttttatttaaccttacgtVtcVaattVMBcttaMtttaStgacttagat
+tWWacVtgWYagWVRctDattBYtgtttaagaagattattgacVatMaacattVctgtBS
+gaVtgWWggaKHaatKWcBScSWaaccRVacacaaactaccScattRatatKVtactata
+tttHttaagtttSKtRtacaaagtRDttcaaaaWgcacatWaDgtDKacgaacaattaca
+RNWaatHtttStgttattaaMtgttgDcgtMgcatBtgcttcgcgaDWgagctgcgaggg
+gVtaaScNatttacttaatgacagcccccacatYScaMgtaggtYaNgttctgaMaacNa
+MRaacaaacaKctacatagYWctgttWaaataaaataRattagHacacaagcgKatacBt
+tRttaagtatttccgatctHSaatactcNttMaagtattMtgRtgaMgcataatHcMtaB
+SaRattagttgatHtMttaaKaggYtaaBataSaVatactWtataVWgKgttaaaacagt
+gcgRatatacatVtHRtVYataSaKtWaStVcNKHKttactatccctcatgWHatWaRct
+tactaggatctataDtDHBttataaaaHgtacVtagaYttYaKcctattcttcttaataN
+DaaggaaaDYgcggctaaWSctBaaNtgctggMBaKctaMVKagBaactaWaDaMaccYV
+tNtaHtVWtKgRtcaaNtYaNacggtttNattgVtttctgtBaWgtaattcaagtcaVWt
+actNggattctttaYtaaagccgctcttagHVggaYtgtNcDaVagctctctKgacgtat
+agYcctRYHDtgBattDaaDgccKtcHaaStttMcctagtattgcRgWBaVatHaaaata
+YtgtttagMDMRtaataaggatMtttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtc
+attttcWattRSHcVagaagtacgggtaKVattKYagactNaatgtttgKMMgYNtcccg
+SKttctaStatatNVataYHgtNaBKRgNacaactgatttcctttaNcgatttctctata
+ScaHtataRagtcRVttacDSDttaRtSatacHgtSKacYagttMHtWataggatgactN
+tatSaNctataVtttRNKtgRacctttYtatgttactttttcctttaaacatacaHactM
+acacggtWataMtBVacRaSaatccgtaBVttccagccBcttaRKtgtgcctttttRtgt
+cagcRttKtaaacKtaaatctcacaattgcaNtSBaaccgggttattaaBcKatDagtta
+ctcttcattVtttHaaggctKKgatacatcBggScagtVcacattttgaHaDSgHatRMa
+HWggtatatRgccDttcgtatcgaaacaHtaagttaRatgaVacttagattVKtaaYtta
+aatcaNatccRttRRaMScNaaaDgttVHWgtcHaaHgacVaWtgttScactaagSgtta
+tcttagggDtaccagWattWtRtgttHWHacgattBtgVcaYatcggttgagKcWtKKca
+VtgaYgWctgYggVctgtHgaNcVtaBtWaaYatcDRaaRtSctgaHaYRttagatMatg
+catttNattaDttaattgttctaaccctcccctagaWBtttHtBccttagaVaatMcBHa
+gaVcWcagBVttcBtaYMccagatgaaaaHctctaacgttagNWRtcggattNatcRaNH
+ttcagtKttttgWatWttcSaNgggaWtactKKMaacatKatacNattgctWtatctaVg
+agctatgtRaHtYcWcttagccaatYttWttaWSSttaHcaaaaagVacVgtaVaRMgat
+taVcDactttcHHggHRtgNcctttYatcatKgctcctctatVcaaaaKaaaagtatatc
+tgMtWtaaaacaStttMtcgactttaSatcgDataaactaaacaagtaaVctaggaScca
+atMVtaaSKNVattttgHccatcacBVctgcaVatVttRtactgtVcaattHgtaaatta
+aattttYtatattaaRSgYtgBagaHSBDgtagcacRHtYcBgtcacttacactaYcgct
+WtattgSHtSatcataaatataHtcgtYaaMNgBaatttaRgaMaatatttBtttaaaHH
+KaatctgatWatYaacttMctcttttVctagctDaaagtaVaKaKRtaacBgtatccaac
+cactHHaagaagaaggaNaaatBWattccgStaMSaMatBttgcatgRSacgttVVtaaD
+MtcSgVatWcaSatcttttVatagttactttacgatcaccNtaDVgSRcgVcgtgaacga
+NtaNatatagtHtMgtHcMtagaaattBgtataRaaaacaYKgtRccYtatgaagtaata
+KgtaaMttgaaRVatgcagaKStctHNaaatctBBtcttaYaBWHgtVtgacagcaRcat
+aWctcaBcYacYgatDgtDHcctaaagacYRcaggattHaYgtKtaatgcVcaataMYac
+ccatatcacgWDBtgaatcBaatacKcttRaRtgatgaBDacggtaattaaYtataStgV
+HDtDctgactcaaatKtacaatgcgYatBtRaDatHaactgtttatatDttttaaaKVcc
+YcaaccNcBcgHaaVcattHctcgattaaatBtatgcaaaaatYMctSactHatacgaWa
+cattacMBgHttcgaatVaaaacaBatatVtctgaaaaWtctRacgBMaatSgRgtgtcg
+actatcRtattaScctaStagKgaDcWgtYtDDWKRgRtHatRtggtcgaHgggcgtatt
+aMgtcagccaBggWVcWctVaaattcgNaatcKWagcNaHtgaaaSaaagctcYctttRV
+taaaatNtataaccKtaRgtttaMtgtKaBtRtNaggaSattHatatWactcagtgtact
+aKctatttgRYYatKatgtccgtRtttttatttaatatVgKtttgtatgtNtataRatWY
+NgtRtHggtaaKaYtKSDcatcKgtaaYatcSRctaVtSMWtVtRWHatttagataDtVg
+gacagVcgKWagBgatBtaaagNcaRtagcataBggactaacacRctKgttaatcctHgD
+gttKHHagttgttaatgHBtatHcDaagtVaBaRccctVgtgDtacRHSctaagagcggW
+YaBtSaKtHBtaaactYacgNKBaVYgtaacttagtVttcttaatgtBtatMtMtttaat
+taatBWccatRtttcatagVgMMtagctStKctaMactacDNYgKYHgaWcgaHgagatt
+acVgtttgtRaSttaWaVgataatgtgtYtaStattattMtNgWtgttKaccaatagNYt
+tattcgtatHcWtctaaaNVYKKttWtggcDtcgaagtNcagatacgcattaagaccWct
+gcagcttggNSgaNcHggatgtVtcatNtRaaBNcHVagagaaBtaaSggDaatWaatRc
+caVgggStctDaacataKttKatttggacYtattcSatcttagcaatgaVBMcttDattc
+tYaaRgatgcattttNgVHtKcYRaatRKctgtaaacRatVSagctgtWacBtKVatctg
+ttttKcgtctaaDcaagtatcSataWVgcKKataWaYttcccSaatgaaaacccWgcRct
+WatNcWtBRttYaattataaNgacacaatagtttVNtataNaYtaatRaVWKtBatKagt
+aatataDaNaaaaataMtaagaaStccBcaatNgaataWtHaNactgtcDtRcYaaVaaa
+aaDgtttRatctatgHtgttKtgaaNSgatactttcgagWaaatctKaaDaRttgtggKK
+agcDgataaattgSaacWaVtaNMacKtcaDaaatttctRaaVcagNacaScRBatatct
+RatcctaNatWgRtcDcSaWSgttRtKaRtMtKaatgttBHcYaaBtgatSgaSWaScMg
+atNtctcctatttctYtatMatMtRRtSaattaMtagaaaaStcgVgRttSVaScagtgD
+tttatcatcatacRcatatDcttatcatVRtttataaHtattcYtcaaaatactttgVct
+agtaaYttagatagtSYacKaaacgaaKtaaatagataatSatatgaaatSgKtaatVtt
+tatcctgKHaatHattagaaccgtYaaHactRcggSBNgtgctaaBagBttgtRttaaat
+tYtVRaaaattgtaatVatttctcttcatgBcVgtgKgaHaaatattYatagWacNctga
+aMcgaattStagWaSgtaaKagttttaagaDgatKcctgtaHtcatggKttVDatcaagg
+tYcgccagNgtgcVttttagagatgctaccacggggtNttttaSHaNtatNcctcatSaa
+VgtactgBHtagcaYggYVKNgtaKBcRttgaWatgaatVtagtcgattYgatgtaattt
+acDacSctgctaaaStttaWMagDaaatcaVYctccgggcgaVtaaWtStaKMgDtttca
+aMtVgBaatccagNaaatcYRMBggttWtaaScKttMWtYataRaDBMaDataatHBcac
+DaaKDactaMgagttDattaHatHtaYatDtattDcRNStgaatattSDttggtattaaN
+SYacttcDMgYgBatWtaMagactVWttctttgYMaYaacRgHWaattgRtaagcattct
+MKVStatactacHVtatgatcBtVNataaBttYtSttacKgggWgYDtgaVtYgatDaac
+attYgatggtRDaVDttNactaSaMtgNttaacaaSaBStcDctaccacagacgcaHatM
+ataWKYtaYattMcaMtgSttDagcHacgatcaHttYaKHggagttccgatYcaatgatR
+aVRcaagatcagtatggScctatattaNtagcgacgtgKaaWaactSgagtMYtcttcca
+KtStaacggMtaagNttattatcgtctaRcactctctDtaacWYtgaYaSaagaWtNtat
+ttRacatgNaatgttattgWDDcNaHcctgaaHacSgaataaRaataMHttatMtgaSDS
+KatatHHaNtacagtccaYatWtcactaactatKDacSaStcggataHgYatagKtaatK
+agStaNgtatactatggRHacttgtattatgtDVagDVaRctacMYattDgtttYgtcta
+tggtKaRSttRccRtaaccttagagRatagSaaMaacgcaNtatgaaatcaRaagataat
+agatactcHaaYKBctccaagaRaBaStNagataggcgaatgaMtagaatgtcaKttaaa
+tgtaWcaBttaatRcggtgNcacaaKtttScRtWtgcatagtttWYaagBttDKgccttt
+atMggNttattBtctagVtacataaaYttacacaaRttcYtWttgHcaYYtaMgBaBatc
+tNgcDtNttacgacDcgataaSatYaSttWtcctatKaatgcagHaVaacgctgcatDtg
+ttaSataaaaYSNttatagtaNYtaDaaaNtggggacttaBggcHgcgtNtaaMcctggt
+VtaKcgNacNtatVaSWctWtgaWcggNaBagctctgaYataMgaagatBSttctatact
+tgtgtKtaattttRagtDtacatatatatgatNHVgBMtKtaKaNttDHaagatactHac
+cHtcatttaaagttVaMcNgHatatKtaNtgYMccttatcaaNagctggacStttcNtgg
+caVtattactHaSttatgNMVattMMDtMactattattgWMSgtHBttStStgatatRaD
+aagattttctatMtaaaaaggtactaaVttaSacNaatactgMttgacHaHRttgMacaa
+aatagttaatatWKRgacDgaRtatatttattatcYttaWtgtBRtWatgHaaattHata
+agtVaDtWaVaWtgStcgtMSgaSRgMKtaaataVacataatgtaSaatttagtcgaaHt
+aKaatgcacatcggRaggSKctDcagtcSttcccStYtccRtctctYtcaaKcgagtaMt
+tttcRaYDttgttatctaatcataNctctgctatcaMatactataggDaHaaSttMtaDt
+cNatataattctMcStaaBYtaNagatgtaatHagagSttgWHVcttatKaYgDctcttg
+gtgttMcRaVgSgggtagacaataaDtaattSaDaNaHaBctattgNtaccaaRgaVtKN
+taaYggHtaKKgHcatctWtctDtttctttggSDtNtaStagttataaacaattgcaBaB
+WggHgcaaaBtYgctaatgaaatWcDcttHtcMtWWattBHatcatcaaatctKMagtDN
+atttWaBtHaaaNgMttaaStagttctctaatDtcRVaYttgttMtRtgtcaSaaYVgSW
+DRtaatagctcagDgcWWaaaBaaRaBctgVgggNgDWStNaNBKcBctaaKtttDcttB
+aaggBttgaccatgaaaNgttttttttatctatgttataccaaDRaaSagtaVtDtcaWa
+tBtacattaWacttaSgtattggDgKaaatScaattacgWcagKHaaccaYcRcaRttaD
+ttRtttHgaHVggcttBaRgtccctDatKaVtKtcRgYtaKttacgtatBtStaagcaat
+taagaRgBagSaattccSWYtttattVaataNctgHgttaaNBgcVYgtRtcccagWNaa
+aacaDNaBcaaaaRVtcWMgBagMtttattacgDacttBtactatcattggaaatVccgg
+ttRttcatagttVYcatYaSHaHcttaaagcNWaHataaaRWtctVtRYtagHtaaaYMa
+taHYtNBctNtKaatattStgaMcBtRgctaKtgcScSttDgYatcVtggaaKtaagatW
+ccHccgKYctaNNctacaWcttttgcRtgtVcgaKttcMRHgctaHtVaataaDtatgKD
+cttatBtDttggNtacttttMtgaacRattaaNagaactcaaaBBVtcDtcgaStaDctg
+aaaSgttMaDtcgttcaccaaaaggWtcKcgSMtcDtatgtttStaaBtatagDcatYat
+WtaaaBacaKgcaDatgRggaaYctaRtccagattDaWtttggacBaVcHtHtaacDacY
+gtaatataMagaatgHMatcttatacgtatttttatattacHactgttataMgStYaatt
+YaccaattgagtcaaattaYtgtatcatgMcaDcgggtcttDtKgcatgWRtataatatR
+acacNRBttcHtBgcRttgtgcgtcatacMtttBctatctBaatcattMttMYgattaaV
+YatgDaatVagtattDacaacDMatcMtHcccataagatgBggaccattVWtRtSacatg
+ctcaaggggYtttDtaaNgNtaaBatggaatgtctRtaBgBtcNYatatNRtagaacMga
+gSaSDDSaDcctRagtVWSHtVSRggaacaBVaccgtttaStagaacaMtactccagttt
+VctaaRaaHttNcttagcaatttattaatRtaaaatctaacDaBttggSagagctacHta
+aRWgattcaaBtctRtSHaNtgtacattVcaHaNaagtataccacaWtaRtaaVKgMYaW
+gttaKggKMtKcgWatcaDatYtKSttgtacgaccNctSaattcDcatcttcaaaDKtta
+cHtggttHggRRaRcaWacaMtBWVHSHgaaMcKattgtaRWttScNattBBatYtaNRg
+cggaagacHSaattRtttcYgaccBRccMacccKgatgaacttcgDgHcaaaaaRtatat
+DtatYVtttttHgSHaSaatagctNYtaHYaVYttattNtttgaaaYtaKttWtctaNtg
+agaaaNctNDctaaHgttagDcRttatagccBaacgcaRBtRctRtggtaMYYttWtgat
+aatcgaataattattataVaaaaattacNRVYcaaMacNatRttcKatMctgaagactaa
+ttataaYgcKcaSYaatMNctcaacgtgatttttBacNtgatDccaattattKWWcattt
+tatatatgatBcDtaaaagttgaaVtaHtaHHtBtataRBgtgDtaataMttRtDgDctt
+attNtggtctatctaaBcatctaRatgNacWtaatgaagtcMNaacNgHttatactaWgc
+NtaStaRgttaaHacccgaYStacaaaatWggaYaWgaattattcMaactcBKaaaRVNc
+aNRDcYcgaBctKaacaaaaaSgctccYBBHYaVagaatagaaaacagYtctVccaMtcg
+tttVatcaatttDRtgWctagtacRttMctgtDctttcKtWttttataaatgVttgBKtg
+tKWDaWagMtaaagaaattDVtaggttacatcatttatgtcgMHaVcttaBtVRtcgtaY
+gBRHatttHgaBcKaYWaatcNSctagtaaaaatttacaatcactSWacgtaatgKttWa
+ttagttttNaggtctcaagtcactattcttctaagKggaataMgtttcataagataaaaa
+tagattatDgcBVHWgaBKttDgcatRHaagcaYcRaattattatgtMatatattgHDtc
+aDtcaaaHctStattaatHaccgacNattgatatattttgtgtDtRatagSacaMtcRtc
+attcccgacacSattgttKaWattNHcaacttccgtttSRtgtctgDcgctcaaMagVtB
+ctBMcMcWtgtaacgactctcttRggRKSttgYtYatDccagttDgaKccacgVatWcat
+aVaaagaataMgtgataaKYaaatcHDaacgataYctRtcYatcgcaMgtNttaBttttg
+atttaRtStgcaacaaaataccVgaaDgtVgDcStctatatttattaaaaRKDatagaaa
+gaKaaYYcaYSgKStctccSttacagtcNactttDVttagaaagMHttRaNcSaRaMgBt
+tattggtttaRMggatggcKDgWRtNaataataWKKacttcKWaaagNaBttaBatMHtc
+cattaacttccccYtcBcYRtagattaagctaaYBDttaNtgaaaccHcaRMtKtaaHMc
+NBttaNaNcVcgVttWNtDaBatgataaVtcWKcttRggWatcattgaRagHgaattNta
+tttctctattaattaatgaDaaMatacgttgggcHaYVaaNaDDttHtcaaHtcVVDgBV
+agcMacgtgttaaBRNtatRtcagtaagaggtttaagacaVaaggttaWatctccgtVta
+DtcDatttccVatgtacNtttccgtHttatKgScBatgtVgHtYcWagcaKtaMYaaHgt
+aattaSaHcgcagtWNaatNccNNYcacgVaagaRacttctcattcccRtgtgtaattag
+cSttaaStWaMtctNNcSMacattataaactaDgtatWgtagtttaagaaaattgtagtN
+agtcaataaatttgatMMYactaatatcggBWDtVcYttcDHtVttatacYaRgaMaaca
+StaatcRttttVtagaDtcacWatttWtgaaaagaaagNRacDtttStVatBaDNtaact
+atatcBSMcccaSttccggaMatgattaaWatKMaBaBatttgataNctgttKtVaagtc
+agScgaaaDggaWgtgttttKtWtatttHaatgtagttcactaaKMagttSYBtKtaYga
+actcagagRtatagtVtatcaaaWYagcgNtaDagtacNSaaYDgatBgtcgataacYDt
+aaactacagWDcYKaagtttattagcatcgagttKcatDaattgattatDtcagRtWSKt
+cgNtMaaaaacaMttKcaWcaaSVMaaaccagMVtaMaDtMaHaBgaacataBBVtaatV
+YaNSWcSgNtDNaaKacacBtttatKtgtttcaaHaMctcagtaacgtcgYtactDcgcc
+taNgagagcYgatattttaaatttccattttacatttDaaRctattttWctttacgtDat
+YtttcagacgcaaVttagtaaKaaaRtgVtccataBggacttatttgtttaWNtgttVWt
+aWNVDaattgtatttBaagcBtaaBttaaVatcHcaVgacattccNggtcgacKttaaaR
+tagRtctWagaYggtgMtataatMtgaaRttattttgWcttNtDRRgMDKacagaaaagg
+aaaRStcccagtYccVattaNaaKStNWtgacaVtagaagcttSaaDtcacaacgDYacW
+DYtgtttKatcVtgcMaDaSKStVcgtagaaWaKaagtttcHaHgMgMtctataagBtKa
+aaKKcactggagRRttaagaBaaNatVVcgRcKSttDaactagtSttSattgttgaaRYa
+tggttVttaataaHttccaagDtgatNWtaagHtgcYtaactRgcaatgMgtgtRaatRa
+NaacHKtagactactggaatttcgccataacgMctRgatgttaccctaHgtgWaYcactc
+acYaattcttaBtgacttaaacctgYgaWatgBttcttVttcgttWttMcNYgtaaaatc
+tYgMgaaattacNgaHgaacDVVMtttggtHtctaaRgtacagacgHtVtaBMNBgatta
+gcttaRcttacaHcRctgttcaaDBggttKaacatgKtttYataVaNattccgMcgcgta
+gtRaVVaattaKaatggttRgaMcagtatcWBttNtHagctaatctagaaNaaacaYBct
+atcgcVctBtgcaaagDgttVtgaHtactSNYtaaNccatgtgDacgaVtDcgKaRtacD
+cttgctaagggcagMDagggtBWRtttSgccttttttaacgtcHctaVtVDtagatcaNM
+aVtcVacatHctDWNaataRgcgtaVHaggtaaaaSgtttMtattDgBtctgatSgtRag
+agYtctSaKWaataMgattRKtaacatttYcgtaacacattRWtBtcggtaaatMtaaac
+BatttctKagtcDtttgcBtKYYBaKttctVttgttaDtgattttcttccacttgSaaac
+ggaaaNDaattcYNNaWcgaaYattttMgcBtcatRtgtaaagatgaWtgaccaYBHgaa
+tagataVVtHtttVgYBtMctaMtcctgaDcYttgtccaaaRNtacagcMctKaaaggat
+ttacatgtttaaWSaYaKttBtagDacactagctMtttNaKtctttcNcSattNacttgg
+aacaatDagtattRtgSHaataatgccVgacccgatactatccctgtRctttgagaSgat
+catatcgDcagWaaHSgctYYWtatHttggttctttatVattatcgactaagtgtagcat
+VgtgHMtttgtttcgttaKattcMatttgtttWcaaStNatgtHcaaaDtaagBaKBtRg
+aBgDtSagtatMtaacYaatYtVcKatgtgcaacVaaaatactKcRgtaYtgtNgBBNcK
+tcttaccttKgaRaYcaNKtactttgagSBtgtRagaNgcaaaNcacagtVtttHWatgt
+taNatBgtttaatNgVtctgaatatcaRtattcttttttttRaaKcRStctcggDgKaga
+ttaMaaaKtcaHacttaataataKtaRgDtKVBttttcgtKaggHHcatgttagHggttN
+ctcgtatKKagVagRaaaggaaBtNatttVKcRttaHctaHtcaaatgtaggHccaBata
+NaNaggttgcWaatctgatYcaaaHaatWtaVgaaBttagtaagaKKtaaaKtRHatMaD
+BtBctagcatWtatttgWttVaaaScMNattRactttgtYtttaaaagtaagtMtaMaSt
+tMBtatgaBtttaKtgaatgagYgtNNacMtcNRacMMHcttWtgtRtctttaacaacat
+tattcYaMagBaacYttMatcttKcRMtgMNccattaRttNatHaHNaSaaHMacacaVa
+atacaKaSttHatattMtVatWgattttttaYctttKttHgScWaacgHtttcaVaaMga
+acagNatcgttaacaaaaagtacaHBNaattgttKtcttVttaaBtctgctacgBgcWtt
+tcaggacacatMgacatcccagcggMgaVKaBattgacttaatgacacacaaaaaatRKa
+aBctacgtRaDcgtagcVBaacDSBHaaaaSacatatacagacRNatcttNaaVtaaaat
+aHattagtaaaaSWccgtatWatggDttaactattgcccatcttHaSgYataBttBaact
+attBtcHtgatcaataSttaBtatKSHYttWggtcYtttBttaataccRgVatStaHaKa
+gaatNtagRMNgtcttYaaSaactcagDSgagaaYtMttDtMRVgWKWtgMaKtKaDttt
+tgactatacataatcNtatNaHattVagacgYgatatatttttgtStWaaatctWaMgag
+aRttRatacgStgattcttaagaDtaWccaaatRcagcagaaNKagtaaDggcgccBtYt
+agSBMtactaaataMataBSacRMgDgattMMgtcHtcaYDtRaDaacggttDaggcMtt
+tatgttaNctaattaVacgaaMMtaatDccSgtattgaRtWWaccaccgagtactMcgVN
+gctDctaMScatagcgtcaactatacRacgHRttgctatttaatgaattataYKttgtaa
+gWgtYttgcHgMtaMattWaWVtaRgcttgYgttBHtYataSccStBtgtagMgtDtggc
+VaaSBaatagDttgBgtctttctcattttaNagtHKtaMWcYactVcgcgtatMVtttRa
+cVagDaatcttgctBBcRDgcaacKttgatSKtYtagBMagaRtcgBattHcBWcaactg
+atttaatttWDccatttatcgagSKaWttataHactaHMttaatHtggaHtHagaatgtK
+taaRactgtttMatacgatcaagDgatKaDctataMggtHDtggHacctttRtatcttYa
+ttttgacttgaaSaataaatYcgBaaaaccgNatVBttMacHaKaataagtatKgtcaag
+actcttaHttcggaattgttDtctaaccHttttWaaatgaaatataaaWattccYDtKta
+aaacggtgaggWVtctattagtgactattaagtMgtttaagcatttgSgaaatatccHaa
+ggMaaaattttcWtatKctagDtYtMcctagagHcactttactatacaaacattaactta
+HatcVMYattYgVgtMttaaRtgaaataaDatcaHgtHHatKcDYaatcttMtNcgatYa
+tgSaMaNtcttKcWataScKggtatcttacgcttWaaagNatgMgHtctttNtaacVtgt
+tcMaaRatccggggactcMtttaYMtcWRgNctgNccKatcttgYDcMgattNYaRagat
+HaaHgKctcataRDttacatBatccattgDWttatttaWgtcggagaaaaatacaatacS
+NtgggtttccttacSMaagBattacaMaNcactMttatgaRBacYcYtcaaaWtagctSa
+acttWgDMHgaggatgBVgcHaDtggaactttggtcNatNgtaKaBcccaNtaagttBaa
+cagtatacDYttcctNgWgcgSMcacatStctHatgRcNcgtacacaatRttMggaNKKg
+gataaaSaYcMVcMgtaMaHtgattYMatYcggtcttcctHtcDccgtgRatcattgcgc
+cgatatMaaYaataaYSggatagcgcBtNtaaaScaKgttBgagVagttaKagagtatVa
+actaSacWactSaKatWccaKaaaatBKgaaKtDMattttgtaaatcRctMatcaaMagM
+ttDgVatggMaaWgttcgaWatgaaatttgRtYtattaWHKcRgctacatKttctaccaa
+HttRatctaYattaaWatVNccatNgagtcKttKataStRaatatattcctRWatDctVa
+gttYDgSBaatYgttttgtVaatttaatagcagMatRaacttBctattgtMagagattaa
+actaMatVtHtaaatctRgaaaaaaaatttWacaacaYccYDSaattMatgaccKtaBKW
+BattgtcaagcHKaagttMMtaatttcKcMagNaaKagattggMagaggtaatttYacat
+cWaaDgatMgKHacMacgcVaacaDtaDatatYggttBcgtatgWgaSatttgtagaHYR
+VacaRtctHaaRtatgaactaatatctSSBgggaaHMWtcaagatKgagtDaSatagttg
+attVRatNtctMtcSaagaSHaataNataataRaaRgattctttaataaagWaRHcYgca
+tgtWRcttgaaggaMcaataBRaaccagStaaacNtttcaatataYtaatatgHaDgcSt
+cWttaacctaRgtYaRtataKtgMttttatgactaaaatttacYatcccRWtttHRtatt
+aaatgtttatatttgttYaatMcaRcSVaaDatcgtaYMcatgtagacatgaaattgRtc
+aaYaaYtRBatKacttataccaNaaattVaBtctggacaagKaaYaaatatWtMtatcYa
+aVNtcgHaactBaagKcHgtctacaatWtaDtSgtaHcataHtactgataNctRgttMtD
+cDttatHtcgtacatcccaggSttaBgtcacacWtccNMcNatMVaVgtccDYStatMac
+cDatggYaRKaaagataRatttHKtSaaatDgataaacttaHgttgVBtcttVttHgDac
+gaKatgtatatNYataactctSatatatattgcHRRYttStggaactHgttttYtttaWt
+atMcttttctatctDtagVHYgMRBgtHttcctaatYRttKtaagatggaVRataKDcta
+MtKBNtMtHNtWtttYcVtattMcgRaacMcctNSctcatttaaagDcaHtYccSgatgc
+aatYaaaaDcttcgtaWtaattctcgttttScttggtaatctttYgtctaactKataHac
+ctMctcttacHtKataacacagcNRatgKatttttSaaatRYcgDttaMRcgaaattact
+MtgcgtaagcgttatBtttttaattaagtNacatHgttcRgacKcBBtVgatKttcgaBa
+atactDRgtRtgaNacWtcacYttaaKcgttctHaKttaNaMgWgWaggtctRgaKgWtt
+SttBtDcNtgtttacaaatYcDRtgVtgcctattcNtctaaaDMNttttNtggctgagaV
+ctDaacVtWccaagtaacacaNctgaScattccDHcVBatcgatgtMtaatBgHaatDct
+MYgagaatgYWKcctaatNaStHaaaKccgHgcgtYaaYtattgtStgtgcaaRtattaK
+atattagaWVtcaMtBagttattagNaWHcVgcaattttDcMtgtaRHVYtHtctgtaaa
+aHVtMKacatcgNaatttMatatgttgttactagWYtaRacgataKagYNKcattataNa
+RtgaacKaYgcaaYYacaNccHatMatDcNgtHttRaWttagaaDcaaaaaatagggtKD
+tStaDaRtaVtHWKNtgtattVctSVgRgataDaRaWataBgaagaaKtaataaYgDcaS
+taNgtaDaaggtattHaRaWMYaYaWtggttHYgagVtgtgcttttcaaDKcagVcgtta
+gacNaaWtagtaataDttctggttVcatcataaagtgKaaaNaMtaBBaattaatWaatt
+gctHaVKaSgDaaVKaHtatatatHatcatSBagNgHtatcHYMHgttDgtaHtBttWat
+cgtttaRaattgStKgSKNWKatcagDtctcagatttctRtYtBatBgHHtKaWtgYBga
+cVVWaKtacKcDttKMaKaVcggtgttataagaataaHaatattagtataatMHgttYga
+RttagtaRtcaaVatacggtcMcgagtaaRttacWgactKRYataaaagSattYaWgaga
+tYagKagatgSaagKgttaatMggtataatgttWYttatgagaaacctNVataatHcccK
+tDctcctaatactggctHggaSaggRtKHaWaattcgSatMatttagaggcYtctaMcgc
+tcataSatatgRagacNaaDaggaVBagaYttKtacNaKgtSYtagttggaWcatcWtta
+atctatgaVtcgtgtMtatcaYcgtRccaaYgDctgcMgtgtWgacWtgataacacgcgc
+tBtgttaKtYDtatDcatcagKaVMctaatcttgVcaaRgcRMtDcgattaHttcaNatg
+aatMtactacVgtRgatggaWtttactaaKatgagSaaKggtaNtactVaYtaaKRagaa
+cccacaMtaaMtKtatBcttgtaaWBtMctaataaVcDaaYtcRHBtcgttNtaaHattt
+BNgRStVDattBatVtaagttaYatVattaagaBcacggtSgtVtatttaRattgatgta
+HDKgcaatattKtggcctatgaWDKRYcggattgRctatNgatacaatMNttctgtcRBY
+RaaaHctNYattcHtaWcaattctBtMKtVgYataatMgYtcagcttMDataVtggRtKt
+gaatgccNcRttcaMtRgattaacattRcagcctHtWMtgtDRagaKaBtgDttYaaaaK
+atKgatctVaaYaacWcgcatagBVtaNtRtYRaggBaaBtgKgttacataagagcatgt
+RattccacttaccatRaaatgWgDaMHaYVgVtaSctatcgKaatatattaDgacccYag
+tgtaYNaaatKcagtBRgagtccatgKgaaaccBgaagBtgSttWtacgatWHaYatcga
+tttRaaNRgcaNaKVacaNtDgattgHVaatcDaagcgtatgcNttaDataatcSataaK
+caataaHWataBtttatBtcaKtKtatagttaDgSaYctacaRatNtaWctSaatatttY
+aKaKtaccWtatcRagacttaYttVcKgSDcgagaagatccHtaattctSttatggtKYg
+tMaHagVaBRatttctgtRgtctatgggtaHKgtHacHtSYacgtacacHatacKaaBaV
+accaDtatcSaataaHaagagaatScagactataaRttagcaaVcaHataKgDacatWcc
+ccaagcaBgagWatctaYttgaaatctVNcYtttWagHcgcgcDcVaaatgttKcHtNtc
+aatagtgtNRaactttttcaatggWgBcgDtgVgtttctacMtaaataaaRggaaacWaH
+ttaRtNtgctaaRRtVBctYtVtatDcattDtgaccYatagatYRKatNYKttNgcctag
+taWtgaactaMVaacctgaStttctgaKVtaaVaRKDttVtVctaDNtataaaDtcccca
+agtWtcgatcactDgYaBcatcctMtVtacDaaBtYtMaKNatNtcaNacgDatYcatcg
+caRatWBgaacWttKttagYtaattcggttgSWttttDWctttacYtatatWtcatDtMg
+tBttgRtVDggttaacYtacgtacatgaattgaaWcttMStaDgtatattgaDtcRBcat
+tSgaaVBRgagccaaKtttcDgcgaSMtatgWattaKttWtgDBMaggBBttBaatWttR
+tgcNtHcgttttHtKtcWtagHStaacagttgatatBtaWSaWggtaataaMttaKacDa
+atactcBttcaatatHttcBaaSaaatYggtaRtatNtHcaatcaHtagVtgtattataN
+ggaMtcttHtNagctaaaggtagaYctMattNaMVNtcKtactBKcaHHcBttaSagaKa
+cataYgctaKaYgttYcgacWVttWtSagcaacatcccHaccKtcttaacgaKttcacKt
+NtacHtatatRtaaatacactaBtttgaHaRttggttWtatYagcatYDatcggagagcW
+BataagRtacctataRKgtBgatgaDatataSttagBaHtaatNtaDWcWtgtaattaca
+gKttcNtMagtattaNgtctcgtcctcttBaHaKcKccgtRcaaYagSattaagtKataD
+atatatagtcDtaacaWHcaKttDgaaRcgtgYttgtcatatNtatttttatggccHtgD
+tYHtWgttatYaacaattcaWtatNgctcaaaSttRgctaatcaaatNatcgtttaBtNN
+VtgttataagcaaagattBacgtDatttNatttaaaDcBgtaSKgacgtagataatttcH
+MVNttgttBtDtgtaWKaaRMcKMtHtaVtagataWctccNNaSWtVaHatctcMgggDg
+tNHtDaDttatatVWttgttatttaacctttcacaaggaSaDcggttttttatatVtctg
+VtaacaStDVaKactaMtttaSNagtgaaattaNacttSKctattcctctaSagKcaVtt
+aagNaVcttaVaaRNaHaaHttatgtHttgtgatMccaggtaDcgaccgtWgtWMtttaH
+cRtattgScctatttKtaaccaagtYagaHgtWcHaatgccKNRtttagtMYSgaDatct
+gtgaWDtccMNcgHgcaaacNDaaaRaStDWtcaaaaHKtaNBctagBtgtattaactaa
+ttttVctagaatggcWSatMacccttHttaSgSgtgMRcatRVKtatctgaaaccDNatY
+gaaVHNgatMgHRtacttaaaRtatStRtDtatDttYatattHggaBcttHgcgattgaK
+cKtttcRataMtcgaVttWacatNcatacctRataDDatVaWNcggttgaHtgtMacVtt
+taBHtgagVttMaataattatgttcttagtttgtgcDtSatttgBtcaacHattaaBagV
+WcgcaSYttMgcttacYKtVtatcaYaKctgBatgcgggcYcaaaaacgNtctagKBtat
+tatctttKtaVttatagtaYtRagNtaYataaVtgaatatcHgcaaRataHtacacatgt
+aNtgtcgYatWMatttgaactacRctaWtWtatacaatctBatatgYtaagtatgtgtat
+SttactVatcttYtaBcKgRaSggRaaaaatgcagtaaaWgtaRgcgataatcBaatacc
+gtatttttccatcNHtatWYgatHSaaaDHttgctgtccHtggggcctaataatttttct
+atattYWtcattBtgBRcVttaVMRSgctaatMagtYtttaaaaatBRtcBttcaaVtaa
+cagctccSaaSttKNtHtKYcagcagaaaccccRtttttaaDcDtaStatccaagcgctH
+tatcttaDRYgatDHtWcaaaBcWgKWHttHataagHacgMNKttMKHccaYcatMVaac
+gttaKgYcaVaaBtacgcaactttMctaaHaatgtBatgagaSatgtatgSRgHgWaVWg
+ataaatatttccKagVgataattWaHNcYggaaatgctHtKtaDtctaaagtMaatVDVa
+ctWtSaaWaaMtaHtaSKtcBRaNcttStggtBttacNagcatagRgtKtgcgaacaacB
+cgKaatgataagatgaaaattgtactgcgggtccHHWHaaNacaBttNKtKtcaaBatat
+gctaHNgtKcDWgtttatNgVDHgaccaacWctKaaggHttgaRgYaatHcaBacaatga
+gcaaattactgtaVaaYaDtagattgagNKggtggtgKtWKaatacagDRtatRaMRtga
+ttDggtcaaYRtatttNtagaDtcacaaSDctDtataatcgtactaHttatacaatYaac
+aaHttHatHtgcgatRRttNgcatSVtacWWgaaggagtatVMaVaaattScDDKNcaYB
+YaDatHgtctatBagcaacaagaatgagaaRcataaKNaRtBDatcaaacgcatttttta
+aBtcSgtacaRggatgtMNaattggatatWtgagtattaaaVctgcaYMtatgatttttY
+gaHtgtcttaagWBttHttgtcttattDtcgtatWtataataSgctaHagcDVcNtaatc
+aagtaBDaWaDgtttagYctaNccDtaKtaHcttaataacccaRKtacaVaatNgcWRaM
+gaattatgaBaaagattVYaHMDcaDHtcRcgYtcttaaaWaaaVKgatacRtttRRKYg
+aatacaWVacVcRtatMacaBtactggMataaattttHggNagSctacHgtBagcgtcgt
+gattNtttgatSaaggMttctttcttNtYNagBtaaacaaatttMgaccttacataattg
+YtcgacBtVMctgStgMDtagtaRctHtatgttcatatVRNWataDKatWcgaaaaagtt
+aaaagcacgHNacgtaatctttMRtgacttttDacctataaacgaaatatgattagaact
+ccSYtaBctttaataacWgaaaYatagatgWttcatKtNgatttttcaagHtaYgaaRaD
+aagtaggagcttatVtagtctttcattaaaatcgKtattaRttacagVaDatgcatVgat
+tgggtctttHVtagKaaRBtaHtaaggccccaaaaKatggtttaMWgtBtaaacttcact
+ttKHtcgatctccctaYaBacMgtcttBaBaNgcgaaacaatctagtHccHtKttcRtRV
+ttccVctttcatacYagMVtMcagaMaaacaataBctgYtaatRaaagattaaccatVRa
+tHtaRagcgcaBcgDttStttttcVtttaDtKgcaaWaaaaatSccMcVatgtKgtaKgc
+gatatgtagtSaaaDttatacaaacatYaRRcVRHctKtcgacKttaaVctaDaatgttM
+ggRcWaacttttHaDaKaDaBctgtaggcgtttaHBccatccattcNHtDaYtaataMtt
+acggctNVaacDattgatattttacVttSaattacaaRtataNDgacVtgaacataVRtt
+ttaDtcaaacataYDBtttaatBaDtttYDaDaMccMttNBttatatgagaaMgaNtatt
+HccNataattcaHagtgaaggDgatgtatatatgYatgaStcataaBStWacgtcccata
+RMaaDattggttaaattcMKtctMacaBSactcggaatDDgatDgcWctaacaccgggaV
+cacWKVacggtaNatatacctMtatgatagtgcaKagggVaDtgtaacttggagtcKata
+tcgMcttRaMagcattaBRaStctYSggaHYtacaactMBaagDcaBDRaaacMYacaHa
+attagcattaaaHgcgctaaggSccKtgaaKtNaBtatDDcKBSaVtgatVYaagVtctS
+gMctacgttaacWaaattctSgtDactaaStaaattgcagBBRVctaatatacctNttMc
+RggctttMttagacRaHcaBaacVKgaataHttttMgYgattcYaNRgttMgcVaaacaV
+VcDHaatttgKtMYgtatBtVVctWgVtatHtacaaHttcacgatagcagtaaNattBat
+atatttcVgaDagcggttMaagtcScHagaaatgcYNggcgtttttMtStggtRatctac
+ttaaatVVtBacttHNttttaRcaaatcacagHgagagtMgatcSWaNRacagDtatact
+aaDKaSRtgattctccatSaaRttaaYctacacNtaRtaactggatgaccYtacacttta
+attaattgattYgttcagDtNKttagDttaaaaaaaBtttaaNaYWKMBaaaacVcBMta
+tWtgBatatgaacVtattMtYatMNYDKNcKgDttDaVtaaaatgggatttctgtaaatW
+tctcWgtVVagtcgRgacttcccctaDcacagcRcagagtgtWSatgtacatgttaaStt
+gtaaHcgatgggMagtgaacttatRtttaVcaccaWaMgtactaatSSaHtcMgaaYtat
+cgaaggYgggcgtgaNDtgttMNgaNDMtaattcgVttttaacatgVatgtWVMatatca
+KgaaattcaBcctccWcttgaaWHtWgHtcgNWgaRgctcBgSgaattgcaaHtgattgt
+gNagtDttHHgBttaaWcaaWagcaSaHHtaaaVctRaaMagtaDaatHtDMtcVaWMta
+gSagcttHSattaacaaagtRacMtRtctgttagcMtcaBatVKtKtKacgagaSNatSa
+ctgtatatcBctgagVtYactgtaaattaaaggcYgDHgtaacatSRDatMMccHatKgt
+taacgactKtgKagtcttcaaHRVtccttKgtSataatttacaactggatDNgaacttca
+RtVaagDcaWatcBctctHYatHaDaaatttagYatSatccaWtttagaaatVaacBatH
+catcgtacaatatcgcNYRcaataYaRaYtgattVttgaatgaVaactcRcaNStgtgta
+ttMtgaggtNttBaDRcgaaaagctNgBcWaWgtSaDcVtgVaatMKBtttcgtttctaa
+HctaaagYactgMtatBDtcStgaccgtSDattYaataHctgggaYYttcggttaWaatc
+tggtRagWMaDagtaacBccactacgHWMKaatgatWatcctgHcaBaSctVtcMtgtDt
+tacctaVgatYcWaDRaaaaRtagatcgaMagtggaRaWctctgMgcWttaagKBRtaaD
+aaWtctgtaagYMttactaHtaatcttcataacggcacBtSgcgttNHtgtHccatgttt
+taaagtatcgaKtMttVcataYBBaKtaMVaVgtattNDSataHcagtWMtaggtaSaaK
+gttgBtVtttgttatcatKcgHacacRtctHatNVagSBgatgHtgaRaSgttRcctaac
+aaattDNttgacctaaYtBgaaaatagttattactcttttgatgtNNtVtgtatMgtctt
+RttcatttgatgacacttcHSaaaccaWWDtWagtaRDDVNacVaRatgttBccttaatH
+tgtaaacStcVNtcacaSRttcYagacagaMMttttgMcNttBcgWBtactgVtaRttct
+ccaaYHBtaaagaBattaYacgatttacatctgtaaMKaRYtttttactaaVatWgctBt
+ttDVttctggcDaHaggDaagtcgaWcaagtagtWttHtgKtVataStccaMcWcaagat
+aagatcactctHatgtcYgaKcatcagatactaagNSStHcctRRNtattgtccttagtt
+agMVgtatagactaactctVcaatMctgtttgtgttgccttatWgtaBVtttctggMcaa
+KgDWtcgtaaYStgSactatttHgatctgKagtagBtVacRaagRtMctatgggcaaaKa
+aaatacttcHctaRtgtDcttDattaggaaatttcYHaRaaBttaatggcacKtgctHVc
+aDcaaaVDaaaVcgMttgtNagcgtaDWgtcgttaatDgKgagcSatatcSHtagtagtt
+ggtgtHaWtaHKtatagctgtVgattaBVaatgaataagtaatVatSttaHctttKtttg
+tagttaccttaatcgtagtcctgBcgactatttVcMacHaaaggaatgDatggKtaHtgS
+tatattaaSagctWcctccRtataBaDYcgttgcNaagaggatRaaaYtaWgNtSMcaat
+ttactaacatttaaWttHtatBattgtcgacaatNgattgcNgtMaaaKaBDattHactt
+ggtRtttaYaacgVactBtaBaKtgBttatgVttgtVttcaatcWcNctDBaaBgaDHac
+BttattNtgtDtatttVSaaacaggatgcRatSgtaSaNtgBatagttcHBgcBBaaatt
+aHgtDattatDaKaatBaaYaaMaataaataKtttYtagtBgMatNcatgtttgaNagtg
+ttgtgKaNaSagtttgaSMaYBcaaaacDStagttVacaaaaactaaWttBaagtctgtg
+cgtMgtaattctcctacctcaNtttaaccaaaaVtBcacataacaccccBcWMtatVtgg
+aatgaWtcaaWaaaaaaaaWtDtaatatRcctDWtcctaccMtVVatKttaWaaKaaata
+taaagScHBagaggBaSMtaWaVtatattactSaaaKNaactatNatccttgaYctattc
+aaaVgatttYHcRagattttaSataggttattcVtaaagaKgtattattKtRttNcggcR
+gtgtgtWYtaacHgKatKgatYtacYagDtWcHBDctctgRaYKaYagcactKcacSaRt
+BttttBHKcMtNtcBatttatttttgSatVgaaagaWtcDtagDatatgMacaacRgata
+tatgtttgtKtNRaatatNatgYcaHtgHataacKtgagtagtaacYttaNccaaatHca
+caacaVDtagtaYtccagcattNtacKtBtactaaagaBatVtKaaHBctgStgtBgtat
+gaSNtgDataaccctgtagcaBgtgatcttaDataStgaMaccaSBBgWagtacKcgatt
+gaDgNNaaaacacagtSatBacKDgcgtataBKcatacactaSaatYtYcDaactHttca
+tRtttaatcaattataRtttgtaagMcgNttcatcBtYBagtNWNMtSHcattcRctttt
+tRWgaKacKttgggagBcgttcgcMaWHtaatactgtctctatttataVgtttaBScttt
+taBMaNaatMacactYtBMggtHacMagtaRtctgcatttaHtcaaaatttgagKtgNta
+ctBacaHtcgtatttctMaSRagcagttaatgtNtaaattgagagWcKtaNttagVtacg
+atttgaatttcgRtgtWcVatcgttaaDVctgtttBWgaccagaaagtcSgtVtatagaB
+ccttttcctaaattgHtatcggRattttcaaggcYSKaagWaWtRactaaaacccBatMt
+ttBaatYtaagaactSttcgaaScaatagtattgaccaagtgttttctaacatgtttNVa
+atcaaagagaaaNattaaRttttaVaaaccgcaggNMtatattVctcaagaggaacgBgt
+ttaacaagttcKcYaatatactaaccBaaaSggttcNtattctagttRtBacgScVctca
+atttaatYtaaaaaaatgSaatgatagaMBRatgRcMcgttgaWHtcaVYgaatYtaatc
+tttYttatRaWtctgBtDcgatNatcKaBaDgatgtaNatWKctccgatattaacattNa
+aacDatgBgttctgtDtaaaMggtgaBaSHataacgccSctaBtttaRBtcNHcDatcDc
+ctagagtcRtaBgWttDRVHagattYatgtatcWtaHtttYcattWtaaagtctNgtStg
+gRNcgcggagSSaaagaaaatYcHDtcgctttaatgYcKBVSgtattRaYBaDaaatBgt
+atgaHtaaRaRgcaSWNtagatHaacttNctBtcaccatctMcatattccaSatttgcga
+DagDgtatYtaaaVDtaagtttWVaagtagYatRttaagDcNgacKBcScagHtattatc
+DaDactaaaaaYgHttBcgaDttggataaaKSRcBMaBcgaBSttcWtgNBatRaccgat
+tcatttataacggHVtaattcacaagagVttaaRaatVVRKcgWtVgacctgDgYaaHaW
+tctttcacMagggatVgactagMaaataKaaNWagKatagNaaWtaaaatttgaatttta
+tttgctaaVgaHatBatcaaBWcBgttcMatcgBaaNgttcgSNaggSaRtttgHtRtat
+taNttcDcatSaVttttcgaaaaattgHatctaRaggSaNatMDaaatDcacgattttag
+aHgHaWtYgattaatHNSttatMSgggNtcKtYatRggtttgtMWVtttaYtagcagBag
+HaYagttatatggtBacYcattaRSataBatMtttaaatctHcaaaSaaaagttNSaaWc
+WRccRtKaagtBWtcaaattSttMtattggaaaccttaacgttBtWatttatatWcDaat
+agattcctScacctaagggRaaYtaNaatgVtBcttaaBaacaMVaaattatStYgRcct
+gtactatcMcVKatttcgSgatRHMaaaHtagtaaHtVgcaaataatatcgKKtgccaat
+BNgaaWcVttgagttaKatagttcaggKDatDtattgaKaVcaKtaataDataataHSaH
+cattagttaatRVYcNaHtaRcaaggtNHcgtcaaccaBaaagYtHWaaaRcKgaYaaDt
+tgcWYtataRgaatatgtYtgcKtaNttWacatYHctRaDtYtattcBttttatcSataY
+aYgttWaRagcacHMgtttHtYttYaatcggtatStttcgtRSattaaDaKMaatatact
+aNBaWgctacacYtgaYVgtgHtaaaRaaRgHtagtWattataaaSDaaWtgMattatcg
+aaaagtaYRSaWtSgNtBgagcRYaMDtactaacttaWgtatctagacaagNtattHgga
+taatYttYatcataDcgHgttBttctttVttgccgaaWtaaaacgKgtatctaaaaaNtc
+cDtaDatBMaMggaatNKtatBaaatVtccRaHtaSacataHattgtttKVYattcataV
+aattWtcgtgMttcttKtgtctaacVtatctatatBRataactcgKatStatattcatHH
+RttKtccaacgtgggtgRgtgaMtattattggctatcgtgacMtRcBDtcttgtactaat
+RHttttaagatcgVMDStattatYBtttDttgtBtNttgRcMtYtgBacHaWaBaatDKc
+taagtgaaactaatgRaaKgatccaagNaaaatattaggWNtaagtatacttttKcgtcg
+gSYtcttgRctataYcttatataaagtatattaatttataVaacacaDHatctatttttK
+YVatHRactttaBHccaWagtactBtcacgaVgcgttRtttttttSVgtSagtBaaattc
+tgaHgactcttgMcattttagVtaagaattHctHtcaDaaNtaacRggWatagttcgtSt
+tgaDatcNgNagctagDgatcNttKgttgtaDtctttRaaYStRatDtgMggactSttaD
+tagSaVtBDttgtDgccatcacaMattaaaMtNacaVcgSWcVaaDatcaHaatgaatta
+MtatccVtctBtaattgtWattatBRcWcaatgNNtactWYtDaKttaaatcactcagtR
+aaRgatggtKgcgccaaHgaggatStattYcaNMtcaBttacttatgagDaNtaMgaaWt
+gtttcttctaHtMNgttatctaWWatMtBtaaatagDVatgtBYtatcggcttaagacMR
+taHScgatatYgRDtcattatSDaHggaaataNgaWSRRaaaBaatagBattaDctttgH
+WNttacaataaaaaaatacggtttgHgVtaHtWMttNtBtctagtMcgKMgHgYtataHa
+NagWtcaacYattaataYRgtaWKgaBctataaccgatttaHaNBRaRaMtccggtNgac
+MtctcatttgcaattcWgMacttacaaDaaNtactWatVtttagccttMaatcagVaagt
+ctVaaDaBtattaattaYtNaYtggattaKtaKctYaMtattYgatattataatKtVgDc
+ttatatNBtcgttgtStttttMagaggttaHYSttcKgtcKtDNtataagttataagSgt
+tatDtRttattgttttSNggRtcaaKMNatgaatattgtBWtaMacctgggYgaSgaagY
+ataagattacgagaatBtggtRcVHtgYggaDgaYaKagWagctatagacgaaHgtWaNg
+acttHRatVaWacKYtgRVNgVcSgRWctacatcKSactctgWYtBggtataagcttNRt
+tVtgRcaWaaatDMatYattaactttcgaagRatSctgccttgcRKaccHtttSNVagta
+gHagBagttagaccaRtataBccataatSHatRtcHagacBWatagcaMtacaRtgtgaa
+BatctKRtScttccaNaatcNgtaatatWtcaMgactctBtWtaaNactHaaaaRctcgc
+atggctMcaaNtcagaaaaacacagtggggWttRttagtaagaVctVMtcgaatcttcMa
+aaHcaHBttcgattatgtcaDagcYRtBtYcgacMgtDcagcgaNgttaataatagcagK
+YYtcgtaBtYctMaRtaRtDagaaaacacatgYaBttgattattcgaaNttBctSataaM
+ataWRgaHtttccgtDgaYtatggtDgHKgMtatttVtMtVagttaRatMattRagataa
+ccctKctMtSttgaHagtcStctatttccSagatgttccacgaggYNttHRacgattcDa
+tatDcataaaatBBttatcgaHtNHaaatatDNaggctgaNcaaggagttBttMgRagVa
+tBcRtaWgatgBtSgaKtcgHtttgaatcaaDaHttcSBgHcagtVaaSttDcagccgtt
+NBtgttHagYtattctttRWaaVtSttcatatKaaRaaaNacaVtVctMtSDtDtRHRcg
+taatgctcttaaatSacacaatcgHattcaWcttaaaatHaaatcNctWttaNMcMtaKc
+tVtcctaagYgatgatcYaaaRactctaRDaYagtaacgtDgaggaaatctcaaacatca
+ScttcKttNtaccatNtaNatacatttHaaDHgcaDatMWaaBttcRggctMaagctVYc
+acgatcaDttatYtaatcKatWatcaatVYtNagatttgattgaYttttYgacttVtcKa
+RagaaaHVgDtaMatKYagagttNatWttaccNtYtcDWgSatgaRgtMatgKtcgacaa
+gWtacttaagtcgKtgatccttNcttatagMatHVggtagcgHctatagccctYttggta
+attKNaacgaaYatatVctaataMaaaYtgVtcKaYtaataacagaatHcacVagatYWH
+ttagaaSMaatWtYtgtaaagNaaacaVgaWtcacNWgataNttcaSagctMDaRttgNa
+ctaccgataMaaatgtttattDtcaagacgctDHYYatggttcaagccNctccttcMctt
+tagacBtaaWtaWVHggaaaaNatttaDtDtgctaaHHtMtatNtMtagtcatttgcaaa
+RatacagRHtatDNtgtDgaatVgtVNtcaaatYBMaaaagcaKgtgatgatMgWWMaHt
+tttMgMagatDtataaattaaccaactMtacataaattgRataatacgBtKtaataattR
+gtatDagDtcRDacctatRcagagcSHatNtcaScNtttggacNtaaggaccgtgKNttg
+ttNcttgaaRgYgRtNtcagttBcttttcHtKtgcttYaaNgYagtaaatgaatggWaMa
+ttBHtatctatSgtcYtgcHtaattHgaaMtHcagaaSatggtatgccaHBtYtcNattW
+tgtNgctttaggtttgtWatNtgHtgcDttactttttttgcNtactKtWRaVcttcatag
+tgSNKaNccgaataaBttataataYtSagctttaaatSttggctaaKSaatRccgWHgag
+DttaaatcatgagMtcgagtVtaDggaBtatttgDacataaacgtagYRagBWtgDStKD
+gatgaagttcattatttaKWcataaatWRgatataRgttRacaaNKttNtKagaaYaSta
+actScattattaacgatttaaatgDtaattagatHgaYataaactatggggatVHtgccg
+tNgatNYcaStRtagaccacWcaMtatRagHgVactYtWHtcttcatgatWgagaKggag
+tatgaWtDtVtNaNtcgYYgtaaactttaDtBactagtaDctatagtaatatttatatat
+aacgHaaaRagKattSagttYtStatatatagtcttaaaaMtcatgttcaaDactgRttc
+taagagDtatttttagcgacttgtgRtgNctgSgRaaaaatgcaMtYtDcatcaaYKttH
+catSWgaaaatDataggttatgBDMtgttataacaaYSgagttacgttatgtDStttaaa
+tctcgWKtcSacgagagaSgttatBMDgtcggtgtgcgaNtaSHBatBtttVMgVcagaN
+atcaDDaKMtMYtatagaBccctctDtgtatttatatKNtgggtatgtRaacttgaWaaY
+gcaHatccctggtttStatMtcgcMtaaaWKttMVtWctVtgttaKDWctgWaVttaDVa
+tgKtagagtcatctaKWgtaaMttSacBaMattaKaaHDataattgWtgttttgtcatBa
+cacgtStacaaagtNctNtgtgatcHtWttcKaagagttttaaaaWacgRacatctNatV
+StgaatDHgttWcgtRKcatatatctcaNttaaBDcctgaaaaaDtaYaHaKttNtaYVa
+VtttaDtctacttctWttaactaattttMagWcaatcccNKYtBaacatgttgaKgKcgc
+BHaatDMttatatcSWacatDatRcWaMtDgatBctHgScttaaaHtSgKtDtttattgt
+RStWgttccatatttcacWttcatattgtaHVgaBtacaMtgMaaagDaataactDatat
+tagMaNBagcttcattcgtaaKtgtatttcacMtgBaVtaattStcttagtYgtgtcgcc
+ttKatgggtgaWaataggaatacMMagaSKRttBgatgacRtgMtagaSRataggtatca
+ccgaNaaaWSWacDgatacttgattagcttgtgVMttatYctaRgHVcDtVRRtSaMtca
+VtVtatcaYaHatattaaVaatctaBtgtacRatNtatttgaYatSaHctaNgNtYtYaY
+agattVgatcRtaacgYggtgtatKttaatMagatgRtatatgHaKccHaaaaYtgaacg
+aWaNgtYHgacagaYtctaVtacccgatttttaaagcDttatNRgattKaaattttcatc
+taatgccgcaataataattgttatYtagtRNtaagttggtHaKttWMtDKgatSagBYcg
+RggtWaVaattHtatgtaaaMgSaaagataaKaaKgttDttttRaagaacaWRcaacDgt
+gttaatattaKtatcaWacacatttVtctgatHRcagtttNcaaatcNctNttttataac
+tWacBBttgBttaaaRaWtBKaaacgtatcRcaMaatgYacaaaagtgBataStWYtggt
+atgacaKWtctSgcKHgtcNaMNcataSatattgactacMcataattNVtDaRccaaatc
+agttttYttagYaacgtaatMtMVatNgKaaMaaBgattaKttatDaBcttKtcctttta
+cDagaYtacHgttggacaaaVaatagtYatcataSgatcaaWVttcgaatgaccctcctt
+NtaSBWaatttDttttcaatatYggctatDcttatNctttagDcMttcaacWaaNattSY
+gctttcaHcRaattaataaaatcVccRaattactctaMaVRattacagtgRcDtcgtgct
+cttNtWVtacagtHtatHaBDtcWggtgctcaaRHtatgtDgacStgcaaaVKtagttat
+aatactaatatgtagScaatRSacaattgtattgcagatHHtgBcaatKKtaaMMcaRcg
+actatKBaMaYatgKatttDaaNtRatattgtatWttagcaaaaacaWgcacaaHcataY
+tDaHgttataaSacgcagggggtYatgcKctaaaHgcVgctBDaVttccStagNgcSgta
+tgVYaMatcaWRBtVtgYttgtgRcYttcgctgaacNttgtgtctattWttttcctagMt
+agaWtaKgatStScatMaBtaStaSactattYNatctgtacRatYDaatgatgatatgaa
+tYaaaaSHttaaYMaWtDcaNHaBcaYtgVgcatVaacattMRatBtaatttaDacRtag
+taaaNYVSMtcagaaDtttDHtRcYatacSNKaaMcHgatBaaVttactggBYgaYattt
+ttgcDacHctWatcgtagagtactcattDggtcatKaSgctttatttagtDtRBacttaW
+YaaaattttgaccttaaWtaatgcRgccacttMtaggKtcBtgacgaHctttatcgtcSt
+atMHDNagattatNagVaaaWcggaaaYcaVactDYactaStattgBHtcYctgggtaca
+tataaYcgaYagaggaggacaVatacHRtYtctgtaVgaYcNgaaaNatacVgcNgtaat
+ttDcatttttcaacttSNcaaDatVYctSgcaccttagMgacgcttgaSttaaaatagtt
+aggRHttaaacMatagcaWgMgagtcgctagtgtKgactaaHttattaWgcaaaaaaSat
+atgcgttaBNggttaYVatgaactttttgccatataaataRatSaBctagttataBccga
+aacaagatacttaattttgaHgHMgtaaKctttaYtaaRacBMtBaYgaBaaacaYtVta
+gcRgWatHaWagattWSacStMHatttaDagacaatcgtgtKtttggaMtgtWtgtgcaa
+NaaaaWtKaaBcMWtcttctatgacVgagcgaggHaYYtttWgSaaYYaWtRYHHaMDtc
+tttacaatggaaMctataagcttBcgHcNWaatttgtatatYtStatctagcactgtVtt
+ccagaaattaDtttaRtVataBttWagcatDMVactYtgcatWtttgaaMggKaatgaaa
+aHtataDtgYcMggVaaatSMHtttgVttaYaWaataRttgttaYttattttRtWtataa
+BgtDtttatatcVgaaBcaDtatgtcaDagaWtgaYtWctcVagctcagctatatagcRV
+tcaKtaataatHgNaccgaaaatVHBaatattcgttaVYttatttctBYaatKaagaccV
+StttcattgaMagSaaaaccccWKcaaNtMYacctaDStagaaatttatcatVgtcaata
+cccKattgtaaagtggWgtatatVtagBcttDaBacaattWtDYKtatRKggStRtaaaW
+atBtaagtaattDaaaaBRacWtaagtacaSttaaatccgctaaccKaattgVWttDatt
+atttattKaMtcYtMRWagMtcgKgBagacgggVaaNaaatgctKcgtaataaKtaaagt
+ccWcttHMatSYgataaatDttBaHccattgBttSgaaHYtaataaaMtgaagatgtttB
+gRcattaRaDHcttBgaMaWaaVMMattaatttgtgBRctattgKMagNcMtatttaaaW
+ttgaaacatWgcScgYYDYgttYtVtattgcKcWtagcggtgBaSctaKatacaaVtcaR
+DccccgtgttBgKgggtHagcgaattaaagMMttScggtDttttaHcSaagaacactcac
+actBcVgaKNaDHacacttatSagaattSKHtcagtataaatKaaHtgaaRagaaVcBta
+HtaaatcgatcWcaRtaaaatttaWttaagtcaggRctgaWcttDttgactttaVSaaaa
+tggtaWDaRMtBtaaaaaKatBgatMtctatatcaVaMgatttgNagtDRttDatctttt
+aMtYaaatcggagttctctaYatNtagaNcgMMactacHcaagtaaaatStaSaacaHca
+cSgggtNKatggaaagcggaaKgggtaYtacSgccgBaggcRacgtVgDtggaMcYaaaM
+atggacgYStKKatgaBcaaRtStccSagcRccgccgcSDtgcggBDgaDtBtSSggacM
+ttttaWcatcMatgtNMBWgataatcaaVtgaataataaNatgcaaNttNctgacDMcaH
+ccgatgKgWVttccaStggattctcDacttttttctttaaNcWaMWccWKWttgaaaMct
+DaaBactRtVattttBtcMaNttWcKacagttKSttaYaWSactHSaBtHgatgttacat
+gcatatMtttgtaacScWHBatHactggatatatctgagMgRSatctaaSttaVagcaRc
+ttggaYaatKHtagBBactattcgtaaagaagttgtVcgatgaVatHMtcaggtcgKSgW
+attgaaaVctccVgtDcaaatgaaHgMYactcaMatatatattNVttWtWaatttacRag
+KataaaNtttacaaWgMVactattaSgaggVaaagVtaccDRHaaataRaHaRgcattMt
+tcaatcaKaaataDcaDKtctcgaggBggacctDtttatHacWVaWgatDctaNaNcgKa
+tcMtcMaatBtttggacgtgataatagaaacRactcBtattttaKtgSaaggKtaggRaV
+tatagcccaNRttaccttSMaagatcggDacNBatWcgaactacactaactNBtaStgVt
+NagcatctaVtaKatKgaBtcgtttWaagWMgagRaNatHaaaaDtacagacaBagtgca
+HaNatctcBccNttaagttDgaataaNtcgctaacRBgtaatSttaatatgcataaccca
+SattKcccttDttggtcaatgggttWaacgatacattBtgMaYgaRttatgatKaKgtat
+tDtKWgataacgNBtaccgaKWatcttcttKtgtcttagcattcctWcaaHgagtatDMS
+gKtcagcttgVHaKcttDaataaaVaatttDgtgaaataaRgtcaVaatacttagtVata
+tgggcatgtDDtMtgtatBggattHtgcVtgtgatcaaSattatKYVaacSNNttNWcga
+HttKDaaMYHatcgttaattaSttgctWaacHtaKBtaaaaKHttcRWgaaWcRtBtttg
+gBcDtgtacNttaagcKtaHgtagaaaaRttgaaacatagtWRaacYggtaaatcgctYa
+BtWDRtgttgSctaaKatNcattgtgtMttatccatatagctSacgccSNaaactacgNt
+gtgcttMatSKtcaaBaNaaacataacagaaatagtagctcNcatcVgaagStaataVcD
+KKttcagDHDtattctaatgagggRgBMctatacaagYactctMaaagtcgctttctcgt
+gaattatNcgatMtttaggcBaaatctNtactaaRKtgKactattgtcatatgtacgagt
+tMaaHSSgHgBatatcgcaSaataaaWgaagtatagaHgcttctttatgaccWaatttaR
+taDaatttaatcgaaattgattMcatcaWaMtaWaKactttctBacactatNgtccttaW
+gtctgaccKatStaKtgagtacgggcgcgtYNtatttagacctctKcatgatKWStcaat
+aactaWgMSgHtgatctttttgtcgacgtSacttaYgcctWctcctctacaagVtttMaB
+actWVaccaYtgtSgcgttattcKtatStgaaKaccgNaataaHtatWtYtRacggcaDa
+ScagcagHaYWRtRNcDtHtcVWtggaataaaYttgVaNtgttagtYttgtagSaaatDg
+aggccDcgBRYStattatttaaggccgHgggYRaaccMaagttatSttctttagcMtgcg
+MtgaSagaNaDagttSatgattWatttagtDgcttgagtgMKaYWaYccagcaHatKcta
+KaDgctagacttattgattaaYttatcttattattStaattWaRaYBWagYaatatgttR
+gScttgBagDaWgcgtgcVDaggcttgtctaDRKacttgcaKBWRtaaVaSctKtacttM
+aaSVaWWcgSaNtttSWgtcggtcacttggVVtgagaataaataaDttgaaccaaaaMtt
+aaaagaaaaaaaatcNBtatMgccWagcaNgaVaNaaaaaaYaMgttaWtatHaagtNta
+cgacaBtMMattttWNaRtaaatagYaScKattacagctVKBtWNSKgYtYgtWatHaVa
+tDaaatWgDatcctggSRagagtaaaaMgatttRtaHacatggtaKagVcctgatgaMta
+aYgatgtattattttHggBaccaDctctggNNtYaatctVttgVtRtVcRacttNcttta
+taggHSRtaRacaaattaacHaHgtgttgtttcBtBtatWtgtattttgcKagMcaaaga
+MtattagtStagcBacYaaHcagVgWtgtttcgtgDHaVtagDatcRaRtggtWtaactg
+cacgaggaaaRttSDaaVaSttaaaaacSMttactaNtcaacaattDtacttttYatVSa
+cYtWtMttaattatcKtcttctatcaKDtctStSaaacggtYccatgtgagagtWtagWK
+gcaBaaaaKttgNactaatcgaggcWtcDDaaaaaacactHattaattcactatYttaag
+acactaKaagRtRataaattttcatHggtaataaatgataHtggctaacBacDgtaatat
+tRtYgtDNDBgKtcaggcHattttgHNgWtaatttccgactactgacatVNttYYgactc
+gctctatttagaMcgggatHcgtttatBaDSagBaaaagRttBggttaaBactVHgatga
+atttattcaaaattgcacttcDgacttYcVttactVtttatBaKHagaWgtgaatggBta
+aSggcagacNcttaDttVgMtWagattggVatttacHtctNcMatacttSatMagcttgt
+NcYaaScaYactcKctKtagScStcagtttcatWaatggtgagaggHaggggcaacgcRK
+taRcMaNtHaatRaRaaactVtBtgttaatRtWWcaaagKttccaaKaaatacgVttcac
+aaacgcggtgagaRaatggtgDMWatcWVScacaaaDaggaaHtgttSMaaaaaccYccD
+BtatYgtMagcSagaccaVcctcggtVWaaagttatcNaagataataSaataaaKccgta
+DtYttatYcttHttaagKcMctaaatggaatRgaaaVaaVtcKYaggatWcaBtDaggDa
+tccttcYNtgcSMRgaRtNgaatcgttRttatDVMtagctttacatDVtatatatcagct
+aDagMtataccYgaggYaaatgDaaaatSgctctgatgtttVaaBcctgataKtagaaac
+caKatatgttaDtgaDtatagataatacagtaDtatcNtgtDMtYcattRVtctataNtW
+ttggNaSgtMgaaYctctDggHtggHDccaccacKKaaacaaaatRatttccctttaagc
+RattMHctattHaRtataVattggatcSttaaHaHgaaHNDtacattSaaggDatttcaa
+aYgctBcatattaaaKagtgcccatSctcgatRtaaaMtgWactttNMaWctYgRatDgg
+aactcDcaattaKaactgagtatctataagYaaaSRctggtacWtttccWtaYRtKHatt
+atagWtKttaNgcDtatHacccattaatttataacgctMgaagtaacaacagMgtaYHYV
+tKMHtacMgKcaaatctgRYataNtcgttcaatacggWtMcaatYcBWaagYtVaDNagt
+atagDaaNtaaaYtttcYWttttStgggataaMgatattagaaYtNctcttcBagactaY
+DcgtacHDWccKaHgttcttHgVggVDttatcatKaMttttacWaaSattctatagaHag
+gKaDagBtaaagtcYccattgtYcatctaNgRgVtgaagtDKttatBKcggDtattRYgH
+ccgtgcgBNMtttVRgacaYctSctaRacgtagagccgtacRaagtaHKagStSttttgY
+SatattaaaWHaaWagttDKaaNaNHaaHttaYcttMtcaaatgKttBtSgtccaaVaat
+tSaacgttgNattgatatNctaWtVcagtactKcWacgVagggHaaRgaDaatcMttatt
+aataacaBMaaVtgYtKgRgHactgtactatcBaMtVggtagKcYtHtBSaattagtaat
+gMcaVVagYYgWtactttccaaSttDgaaMaMttcacttYtRgacttcagcttWtttagt
+gataMaattaagVtagaatatKataagtagttaagHMRaDattaHaaVcctDtagtcVYc
+aataaYcNttNaaaHctcaRaatttcaNRgatSHgVatagctRtcatgaBttMaaagRtc
+gHVtgRgStgatttgtagaKagaRWRctgNaHYgaaatBctgtttRttNWagaccgagKg
+tgcggHKVttaatattaatataataDtaNcctacaaRgcaNMctctgaaSHWWHcttagt
+NagtWgWaaKtYaNgcBattatccaaaSctRRHKaNtKcBgtgagaDRWBttactaaatt
+SMctatatagaaYacDgatttccVtaagRtgRataatatagtctttttatgtMgtcaaca
+aNtaaaaactctWtagaVaaaDtaattatagtBStcgaatDtgattVaatMtcaDattVK
+WaagatagggttgtMRSgtcYgWMaatgNtagtcBttagtttctctWaaMtVgctWgSgt
+HagaSagactagKtagWggcatttHgttgacaaactcggggHggcWBgVgtatgggagVg
+agtcVcBtDctttagtctaagVWtHtgtttaScatacMBtKgattatRtgtttgtctttD
+ggcHaBtRtgtaataNataatttataWctgaYWataStcHaatcRtaaVagDWaSatagt
+accNDgaagtatacgttttacgacgKRtattgDctatRRattVtStaaactagatgVatt
+tagaMaSaaaattVtatYtgttgtRMagtHaatttSttaaYNaggWagtgcacgaMcact
+gHgtgtgggHMgtKacttaaYgtcgcatcSatattgBaagtttacMtYagSatttattta
+VtaaDtaWaHcgNatactgactHtggWtataDcDScatactcStcDtgtcgtgtatgagg
+tHaaNKgDattgcBccaagKgtatgacKSMtttttgttcaaatcaaYtagtaSatgDaaa
+MccKNaMaatagaataagcaattattataaMgagtgaSgtctNYttattHaNaYYtcDDt
+aatNRgtatttaaYtaaatcactHVaHcStccttcccaaVatcVggatKtatgRaaDBga
+YtttacttYggactSDtaBcaaNggggtattatattBDcttagagYNMatBgttYaagac
+tMatgttRgatacccgtaacacBHtatKacWgatRcHttaattYtKtStccaaatVDcaN
+KHHaaataatagtagtatcttgctNDggVaVVtaVaRaaagSaccgttctcMtVtgNBgt
+DtttctYgttactBctcRtStWtWDScMtcWSaRatgaataRHctaNtcStctYtWacag
+atgtatYBtHaHWBtacggtDcaaBtatcaggtcaVattaNctactgaaaatWaDgactN
+WtMtggagaattBaataYcMWYcgatMYatWtgattSatgaRtDaRgccagtSttatatR
+aBtattRcWtagtVgaagttMctattatatDttaggtctKtgtgtBagacgttatRKtga
+tctatttBtataactgataacKcggagtgHgtVttcttgtKDgcDtaYatBDatcaatat
+tgttNtaBacatcgcNcaKcaWcRataWcVgtacgScaWgttcggHcMttcRccatgaRS
+tYgNacagatacYacWWtggNaDcWagttHatMaNaatNtcDMDcMaKgHNatScVgatK
+WatatgNRgtccgYgaagattDHgtMtcHaSNaaattBatRagtaaatttacaagHWtKa
+tcaagtccHtYcctgttKDMSgtactactVctgacaaaaHgatatacataatKtStHgct
+ScSatNatacaYttaaWHtctgaatYtagtHtKaggccWBaStaDctaagagNtaatcaa
+tcgttNgaYDaagtaaaaHatagaatcgcgBaYaBgaacSaaWaaaaactccgcMttHtt
+YgtaagaMctKBtacSagattcBaaWtaattttacRttatcgaRtacaRHgtgRagaaBc
+ttaVgacVDgggaatVatagaactRRtacgYttNattVHgaHttacaaaaaaaYtcRWtg
+tgattatgccaSDtttatKWgaatatSNDgattttaacgtcSRtatggttcttcBtWttt
+MtBtMScttaHatBattHacYtaYacattcgttKgtcStSctcKtatatttcaKSgagct
+tccaacaccRDtttDaccattatatSgtcWtVaaagttgtagccattDtYaatattDacc
+atcVDaaRccagttttgtcHacMattcHgaNcatgttKcVttcctgtgcSataaatattg
+aKtctaWctMRaKggtaYcaagttDttcgttacRtatgatggHNaWMtKttcatattaaD
+aSaBaaaMtMatBgKtttgHtHactaatcatcgtWaatKaaWcaWtcctVttaaNaggaa
+aagtaaagaDctNttaDBaBgatagMgaataacRcYggatcRaaaHaagatRDtVRacta
+YagttcaccaaWtctcSSaaatcSKattctggDgaacagDtaDagacagtgtaattcaSt
+YttNaStgtaHgccttaScatMRcaccWtcatttatRtaagatWtNataaWtMNtDVgWt
+tgcWgtgaRttttRgWcttMtctaHacaaYtKctgaBagtRagacttDatNttaaaDgRt
+atNcHatcSDgtBatcttacVcYacNgaattaacgagttgYgacttDattatacBattMg
+ctagcctagatVcaactNttcctaatgtDaacgYaNatagMatSWtYBaaaRtgMtatSR
+gaataYaScaVgtaScMagatNNtttacaaHBaWtNtRtctaaacDaaaaWMcaNtcVaD
+NcagaDtgcWKYgagttaHtgcDYataaacataBaWWtcggtatgtgaaScaacctttRN
+atcgttaaagcaDctaatgcBatttacaattVaMgSMMtccYaaaBYtggattttcataW
+ttgBtatDtBgactaatgtccWaaHataaScHttWttDtcgtcaagMctMDtaaaatRtB
+aaaacaatgtcagcatBgNNBVttttttcBacWtttWtSWWtgaaaaSacgBtaaataaa
+gtcDStaagaactgttaatYatgDctattactgaHtaaatStHaagacaKtagDtaaHaD
+gttccaaDtaaggacactctDggcgtDagtcWaHgRcHgDgaSctttattgtcttttcct
+tRYaDgNactaaatcaWggcNSBagttttatatStKgtcRtgattaaggtcaSBttaaca
+aKatgggatcaaattgRgcBagtNtcgDcatttWcctttgtNagDgctgcatttactttg
+tgtcaBgSatttNHaMcggcagSctcKDtWBaagSagWatggYtVatSRgKagattgaVa
+tKttcgatYatKYSgDaacNtcVgtttaWataWtgVctgcgSggMgatccatgagttgtW
+catYWWcctVcNHagtNtgtKtttgatcaacttaSttattgatNcatWaVgNHcagStVH
+cggHacaaDttgDttWcaaRaKgaaatKaattagtaWacattgaaatgtgaatgacagtg
+aRVtaaYagYtcggcatMttgaaggDgagDRcaKgHtacacaaaMcaBtagHactgKaat
+RtNttcttcatcatNgYgStggactatgSMttgKtDaDgacRRgtWaVattgatttaagY
+ctatatagactaagaggtatWtataaactaYaHRctStgKWcgtRtKtYtYtagacgatt
+RaaYBtaStcttaWataatcHttataRcactgagtgggagccaattctcDtgDaggHcDR
+VaVVggaaBtRttaataaRRttgtaagKNcaVWWgtatacctgatcttBtcttRgaWcaV
+RKcagttSacttagcgtKtgtYWatatcgNttcKaccacacVKctgattBtggacgtctg
+acaDtWKttattttgMBgKaacaDataattWtBtBRtVtacataaatatttgtWtttata
+gtDtgcctagctHYaatgcaNaaRcaatVtacctgggggKtagBgagaBgRaaNttttMt
+MagMtgtgattNctcNaKggWtMatcttagWgtaatatatNctaYBggKaataBattYta
+attataVtggNtcgtgtctaattaaacctHtacaaactDctDtctgatatgMtgataacW
+ctgtgYSaaNScgDYaWtatDatMKgcaatttctgNcgtHtaWtagatatcYBttaatta
+ctcaaaVattYRWtatttDtaNMYMttgattataatgcgNggWaatYagttgBagNcaag
+aaaDtRgtaaaagctgcatctagcttaVgtBttatagcKMSaattYtHcMaBttcagtct
+tgKatgVSVttKgttttttagtgtDHgNggtcaVtatttaacNtgaatatgctatMcatg
+aaaBtgBSaWctaataaattatYttagtaDtaccggaatgagtaattggatttaacBtct
+SMgWYtgKgattacgRctctccaatgtaggcctgaNaatScgYataaBBacaKtHtttca
+tgaaHtgBtagaKHVtacctVtcaaccaDaaWNHNaatgataattgatgWcagggtcMBt
+gSgRataHctMctgMHHtKaBtaaMtMgataaRWtagYtgaaMaSgctYtgcgaaHatDt
+atgtcWRatKatatYDcBgNtRaRacattMcagaHgaaagRccgcgWttggSatBagagc
+HgYtatctVtcatYaaVRtcaSacaMYDcgRtcaaWgaRgataMtaaaacaggtgtaaYc
+attgWgDHcWgttaVatttgcatctaatccacaaagaagSatgcgtagRgagtHDgaVcg
+tgcttatggMttttcatKSctNacHcctMaKRatttgatctaaatgHaaScataataatg
+tttgtgtHaVcaaaaNHaaaatcgctgSVtattVttagaaNWcacagtgKtatgattHcY
+cttgDaWVataBatBttttWtaactNaattttctttaaYHaMtttaaaccgStcHaVBaa
+tcRacaaWactgtagVKtNRtcctagcWaatNgctKccttctcDaBDcatYHatatgcaa
+taaBaagaatgDMttaHcaaYYtcactgttRtgacRaacctaWtBtBMagBctaaBaWtg
+atgVtttattataggttaattgtaatYcaRtVctcttgcacSaaMaatactRSgcataKc
+agcaVNKttcgSatcaaactaattDtaHtNaVtgttttttaWVtatNccagWttcgtatB
+cgttVctcBttaaaaMSaDattKRcctttcataHaattaatWaaataKcaHVaggaatat
+aBYKHVtgVcVgtcHcttccgcctattDtMMgWaacttgWttYtttcMcgtcctaaVHtg
+WtggtgacKtcaWaYMttacttagVWtacgSatatcgWcKaaatHKaaaYttgtagtcaa
+cWtttggtcaagttgaaBBaSHacVcgYgttWBSRWggtattttaYDtHatattcgatNt
+tacaaaaVacaMccaaYStaataRttVtcttagaVKaacaWcgccgtRatcatctaaatc
+cMcctttaMggccHgYcDgaKctatgMRYBagcaNDtgMtcRttgtgHaRttacatgaWc
+DtgctgtataggNggtgaatagBgagYNtatcagKtHcatBatgVKgaHWagattRData
+tcgYcHagRtaatgWtcStagcVatNaaaaKttgRaRBYNgtaaDtStaVRgcMccatMW
+aaattBDatttaatttataaHtagtVVaDRMKBtaacaatttttttDaRSgaaKDtVaBa
+tcagtaaMttaagcctRgaNVgggttcataatagNatcctacactacgcatgtcggaYgt
+aKcatggattgactttHtaattWNRaaWYggttcaaaggaaNtaatgcHcaaaattBtag
+cttattcaagVtatttWgcctaKtatBttDYcattagDacKVaYNccgYaYRaaMaattR
+aagaHtatgcttgcRagcgctSaatagaaRacaRacSccagcacVMataatHgRtagcga
+KgYRaDcVWSDVgRaMgcDgtaattttaYttggtaaWcttKDaaYtatMRcgKccYcagt
+YcBgRccattcaKtgaSSRtactgacgHtgtaaaaBatWgcaMcBcYcgccagactcttc
+SatYattgatgaNccaaaaWaKatVgcaggtWtBcgttaRMagcaaagtgttcacatata
+aagaHWtKatctacttatatcacYRaaVagataagtaattttgatgtBctaataggtaRt
+aaHaattgtaRcStYSYaWRgMtacaHcNSttVNScattNKaaKgBtagtgatYcaaaSt
+actggttggggaBggtNtgtcaaWBaYVSNgtaataBNtagtatatcacMcScccVcgtV
+RRtttNcKaSRNaNtHRttatttattgacaatggSaBagataaccgttcctaDNaattgc
+tVtatNtHtatagSccaagctKttaaacaaattattgtSHgMWgStttNaccattBMYat
+RtccStNgttgaaBcctVagcaaaatgatattcRaBccMWaagKtttttcMtgaRYNaat
+aDttgttWRttattggHtNtataatggttgtStYgaMcYVtcattaggtaatVcaNggaR
+tNataMWcctcYgcgagagRgcHMgcWtgaYtVSttgDaacgaaaatMttYWtWttcctg
+aKNttatttattRaattaagaccMKtttcWgtcaBagKSaWaaacaNtaYaDtBNaaagW
+tHgacaaagtgVtcatKcgcaatVaactatgcgaaactccNctatatMgactatttatSa
+aVttNttRttagHtccKtHtaaaNatttYVctaatttaaaatHWaNtSacgaaaHggaaa
+tcacagVYcctaattcMNtgtYtgagttatttaBtcRgBHNacBtactctagaacgcKaa
+DWYYgcattactVagaYtgaVVcgcaNctttBagKRcSgaaatttgtatccattgtggHc
+aatRtaVtaSaBtcYYcatcgtgtcHaVttaHattctgtcaBSNYaKBBattaatggctg
+tHatattgtBacDcBgatttaaaNtggaaaaYtNcaKagRRtRgttRtMtWgggatcNta
+cacctgtWKagatataaYVMtaaDtaaacctctgtgtgccttScacWaggaYacttttKa
+cgtttgtgataKYagaYaVatcWcSattaMcatBYttYaaatgStKagWattKtttaWgt
+agaaSgtRattcSaDagVaMattattYaagccSgcNaaDgaaSaggtaNgtWactaWcgH
+ctgaNatttttcaatgtaMHSWaRtggtaNtaHBtttWWaaatattcVtBtctStWtaWM
+aBcatttcDagttDtttatatgttWBtNaYatcccSgtgagcgaRYtBtagaDacBtaag
+aataWactaaaagKtaKaWaataacKcccgDtagccaaagcggaatcgctSRtacKgcac
+tacccHaactMgtgccaBaRaaaBVtcgSacRKtttStgatcaaHgKtaaKaccHaccac
+ccKttgagcttcSttttKKcgacBgggtYMaatcBStcgDBtMcataWtaWaMtgaataa
+gaaDatccSYDtgBatgactBaVtaagatctcNMgtcaWKtgcWggcgatacgtgtttat
+ttWaDaNWBNaaNtNttcaaatagtaatScgHtMWttgttgaBaDtgNatSaagtttHtt
+aNaNKaattKatttgatcgtVcatgaatatBtttctaacKaNttVttSagccatRtatat
+cactcHHatctWSKttaMacaaDattccaRaYttttagttaatattcctYaacVactgct
+McgagcaMYtttgaagctagtKgNWttgaaaMatcaMcttcSVatcaatgtNactaaBag
+atagagtDMgtNtNWatttSaHactagaaaDggtaaaaNctMaatagtaHgacgMaaacM
+tacatHtaSagaHatYDccagtBtgaWatcYtVaagataattgatcgacctgcaacgttt
+tattacNMWNcattataDVDactatattatYattttgcgaagtgagYVtagYaWaHaatc
+tgWttttatgcHaacgttaccDaKtatagaccaDDttaacgtHBaacatccgtYaBtVtN
+ccaaataaaatVactDttSKtcMtDSgaagctaMtatattgattactgtNaagNBcagHa
+DattaaaWttacacaaatactcaatSDatagctcaDttWactttgaStaaDtagatSaaD
+tgtaatKtgVataggaagWSaaaaKatttaaagtttgcgtaaagcccggNWaacatacat
+gttctaRcaHttVtcattatctagttttNcataaacDttWaagVtNYtaggctttggtat
+gagaWgtactNaVatcactVttBKcttaaccttcMtatcggtaataYaMaYggttgtcaa
+agSWHctaRMSatVcggactMatatccgaatcttttttcgagtccagtttgaMtcgcatc
+aaKagtattRMaaaKDBttDNccatttttaaBNtVtccgtaatgaKgtcagMVSattatt
+taWaattttaHNcaaMaHttgtggctattctacDtgaagattatcgacaaVRHttcSaSa
+atactNHWaaNcgtWaWgaccgRSttNtHtcttcKatYatatBaagtcgctBtgagccat
+atScctKaagaaKDaWactWagBgctgattBagKtgaaataBaaaaagSacScaaagagt
+agcgaDaYtaMcaYcKtaataMatttttaactttgYgtcgaaggacgcHctBcgYgaaVa
+cRYagagBaaYgtagattgcgagtcaagtStDagatBgtgaccctaSWtctDgactaSHt
+tctWatWttctaWtatctYacactgBWatKKctgtatYgacaaHSatYSaNgSagtatag
+atgagtatttatgaccMaatgtaHtStaWttgYagccaWattcagtBaYtaaNaBtaNat
+actggcttWcaagatDctacggaNctatcacatSgKgattgacgacccccgagtNDtatt
+gagaaatattaatcVttNKtaaWtYacgSNcBHgttgWtatgtttcgccaactKaattaR
+gacgNataatctacaacKgttBatYatNMSaaaNtctKgacttatgcttatKtcaVtVca
+gDaataattYgNtRtHaagcaataHcacaVgtaNNHtHDatgttaMNtggWagSVaRttc
+MVDtcttWgtRttctacKaaVttcVcgcatcctHRKtattSgttSacgaagtcccRDVaa
+cBWagtgYtKtgattgSgaBtgccBtcaKacaDatacttHatcattNatttacgtcagtg
+aggcBtaRNaRcaSgcatattatStatgctYcacgtattcattaaRtgStcttWgtattK
+tSYttNaHaRtNYcRaYtVtggtDcKcttctactaMcacggcMtacgcttctatatHtaa
+tggcattMDtaaMaKattgaagtBaaKMVMNacKaDtttKNcgagctaaagtccMMtgag
+aagVaataatggcaWaaaaVaBgtaSaVgaaaSaaaataDttVtBccaNagcSBgaMaDa
+VaVYYRVBgttYMtagtaactDtaagWaattBtattttMDYHtSaStScRaKatattaca
+cctMttgNBKtcRtRggNagtYMattaaatMctYgaatgcKHagSggaaaaBcaggtHta
+tWcatcgtStagMcctcatgattaWRcStcgWtgRgttttcctaacatcgctcgDDtRaa
+tatMgtcMtHtMaDYatgDatttatagctKDtYHaaaaattaSatatctggtctttattt
+tatMtgtYttgtcatactcaaVcYBgatgSctKtYcctWaRaataWcMgNgcgggagtct
+tRMgactataHaHtgctNtVaatcaaccacgSRaDtgKtaaMSKgtaaaaWaKtttVagS
+DtaaaaaatgttYattttNagMHaaRtNgBttWattatatgcttatatcatttatKtKaa
+aagctRaaatcgcYgacgNtacNtccVtSaaatttcDVctaatacWgcaMtcttSaaWaa
+aWagtagtaattaactagRttaVcSaaatataacHgHatWaattggaagtgcgSSgaaVt
+gYgSttccatWVataatcgaatatgHtRcgtBttcttaaggatatgttgtBcNtaatgtc
+acVatactgaaatMBttRRcRatccatagagggacatcgccWttagttgWttatKagtaa
+aagHtttccttSatVatKtgagcaatttattaaYVattcaaattctgSattRaMtgaatM
+gttattattacaNcggVagccttaaKgccYcaaDattWtggMcttMacWttccMVgtgaa
+ttctDaBYgacttKYtBacatgctDcRaaKaaRaatatctttagKcKtaactttaatNaa
+ggctgScacctYgcgcaaaccaHttVHcBaDgtaatHaHVaaatMgttggtSatHtNNaa
+VagtgtacaataaagacgKttcaaaWVacagctcacWHaatcctgtBNWtaNMKcVcVSW
+tSgcaattctgKtVVaaacaRaattgatRcgBacaKacVccVMactagcgMNaaactgat
+aDaSgagaatVHaatVSVtccggatgRgtagRatttgtaactaBataVaggcaagHgaaS
+MSaKgctRagcStNcatttVgctatacttcNDtcaKBDcaHtDcaatagttHttattMBg
+agctgtaaagtMgatStStcagatatYcBtataacRcaggRaaaggtaWSatKgatatga
+gcgtgMYatcagcatVttSgaaaaaatatatgttYttcattatacataatVcacgattat
+aDggttBtRaagtHMtatagaDgNttggDaKctBcaaRcgattcgtgccttacaaaWatt
+YWVcaaWagDattgaaagggaagaHattBtatVggtaHtWtaMagtccagaKttSatatc
+aStDtgWaagtKWaggtatttaWaaRcattaatStgaaVtacggaacatKctacatHtaa
+aBtcNWatttBBaNatRcDattcgaactataaattataactcagtSgatataagRaYaKH
+ctggtaaNtttaaNgaRHtttattatacNttttaDccttYgtaaacaggaagtgataaac
+atBgaSgtaaaaaaVcBgtWNtRMttBttaaBgtaaaatatcHNStaBtaggtaVatYac
+cNtBaWagRctNSacRtMatDactStVctaaDtaYSRgttaRNttttKggccagaaBcat
+agtYcaYNtDatcgtatVcaatWRtaggaattMcatRtgggatgtcMggMtttataagta
+BgtggacNaaKYtgctWgagYtWcctWtVcttaaactaRacatggtRcatctSDcHcMgc
+aactttttagttaccttattHRgtacggcactDBggtMHcVaaRatKctSHacctacacc
+actaaHaacgSttagKtKttttgNHVgagtaYaMtVYNVcggttaSBaBtaatttSRcgt
+BgaWaatctttttKggacaWKaattKSaccttgDRgtcatatDatVMtMaVcgaattaNa
+agMWccctaaHgataatatgtattWataaaatBaaMtgRttcHctaagctaagatatatt
+McggactaRttttKaSttactWYtgBcaMMacRRgNtactttaaaSKtttcaYBaBttaV
+agtRtHcWaggaVccttNgtgagtcatataWttYScMtWgVRgattWtaSggacggWWct
+BHatattataaKaagttactaMRaaataSRaDttDaaatataVHaatggaaBDgWgHtcK
+StVcatHtaatcatggBWaagHtagtMtgHcHtcatggggWcatacaHNHagcDatRcaa
+attcgcttgDggDNVcaacgSgtggcaccttMttaatattVYtVgaagRttaBcagVaYa
+HcaRDBagatgaVHtNMtcttactDaggMgMaattRWDcctVtgagaaaaSKatHHttVD
+gtctgtcacatHNttgaatSaagtKBatatagacaaRVctcWtgtacKtaacHtgHataS
+gVtactaggtttatggBgtcaaaYaDgaaaaaatcgMtagaKaYatgaattatYcttKta
+caatttgWttMaatBgaatSttMtNaVgVtScgcttctBHKgtaRcNBaatcDtacgatt
+gacgtgctatNaaBtMgagNgKcttWcWKacactYgttVgNcgaattttcttgaaaaact
+acccctcgcNtgMctatcccacMcactcMatttatttagtagaacMNtttcttgYKaWta
+aBtttcWttagHtgtttctcttgtggctatgDgctaatWDataatttagaNcgcRRNata
+KtctaataHgaaMYctNaKWtactaacDtgaVcgagaactggtaccaactHgaggctaga
+gHHagtMgKtaaactacaggMatgtYgSBaKaaaattMgatRtggggtHBVgttaattgK
+ttaaRDacgMactcaaacStaaagctctgtgccttcgtSagtSaRctacaataKatattc
+taVgtgtaattRacKagttattgaMtaatgaNatacDataaggactttccNtStatatKa
+agaataKtatggtcctctatgaggttaaDtgtattgataaaactggatcactKBtttggc
+gtcaaagaaaNtagtWKatctaaWBactDaBaYtacaWtaSgcaattattWgaaBgactg
+aKctatBRgtagttaBaRRgatttaagBHctStgtVYRtaaataaagtMWtcHgcattca
+caaMWtcMccWttgVgcHaWttcaNtgtVaggNgcVatKttataaWDcccctatgatVtt
+ttattacagRBBWttcttRaWgaatBVgcgtHgWgaccagtYacaattgSttaaMcVtDa
+tttaVttRgttKtcaYWatKtaaDtttWaYtaatYctSctatagtcctBtccMaMMtaMY
+HaSSgKaaacttctcBtMtgDtgtttttagRcgtacttataHgKtNtMtKcBtaNKaHSt
+gSagYHtataDtcKtagRtNWaacVgctVtRtttStNtgaaccttaVatgagaaggtcaK
+SttaDataagcYaSatNStcaatDNgttcgacaatttaSgaRaBNNacattRatNtgStt
+HVtgWHgtSHccaactKttYtatHYttVtgHcNgactMcaacttBatatgSgattttacg
+tatttgtggtScaacggYtHtgcatctatttttWtaSatcagaYatcgcagtgtgtMgta
+ttctttcattaRatttStcaatatgcttDtStaaagaccDcVtaWNcHYtWMaMcgaacK
+caNcttacctaBtgcDacatcaHKtRcDaaacataaRacNNtccDataNactttatBSDY
+atDtctBtaBatctDatKaMcattMatatcDHctaagRgYVcatgttcgtgataHDYaag
+ttSgHYctaaatgtaaaactNgtagaaactaattRaatcttttBKcgaatSctMaggVaV
+aaatgagataaataSgttKgtcatKaKatDYtaaaRttYaMtgctcSatRtagttttagc
+aaNtaKgatcgWYcacDgaatcaatactgBgaNtaactaaWatatacaatacactaNatc
+aVaKaaMaaaaaatcaccBtgttgNctaacaBattttaaKWcaggataWMtaattgtaaH
+tgVtcgaHtScaHtctcHacVatagtaMcaaKtcccSagMYtWcaaatHHtaagRttDag
+tMtcYtttaaWWaaaVaRtcHNtctcSttagcacaKttgtagtNgWYtatKDtcatttga
+acctcKHtatccttattcttNggtBgtgtKaggWtYgtStgtVaRtaRaaagtagtgtcg
+cKtKagatgagYtttaatKcScctgaaaaaRaaHtttttaaaVgtatagKctaNtKaSVg
+ttcgagacattttRSatagttSacataMtaYHccacttttctatactagtatgaBaagct
+ttaMtgaatgtcaKYtaaatatggattataNcgBHatcctaRaaactgttgacttYaHtS
+tcatcctDaMBttgtaWgagtaatWKataaaBgBattcttttctttaatWStaatacgNa
+agtWaMaaNgactMtgaaDaggaaaSctaSSgatatDttattatcatagBcaataVcHcR
+gcStaHaaatWagatHttMHactaRacttaYaaaaNtataHKVaataKtatgatcgtcVa
+aWgttYtVcaaYggctRWttaaKtRttDaKtgtatcaattWKaatBHaaaaNgaatggSt
+HgVVgatMgBYtaRNgBDttMcNtggaNgtcaHtgttDcNaggBtatYtacVaNttctcW
+tactHYcSctgtYtDtgWaatcHgatDatatcHtcttatattaaKaRYaDgaatgSYcga
+ctgcRgaagttagtStYatYtttccgacactacagKcaaagDttaatVatcttaaacRaD
+atRcBatKNtNtaaaHtcBgatKHcWStSRaKaSMgtaKaBacWgDDttgYaaYttaNtD
+gHtatSaSataaaaMBaaDtaMatDaagWtggaMtRcacttatggctNataaaaatatWN
+MtacctatgtcaYKaRacagttHDagccgtaaYcaatataatcatagggaaSatgMYBcK
+BBtaaRVRatRtccVtgtgaagVNttcttagtgtcWataVggtaaNaatVgVaKctttNg
+tttagtaaagBatBtgaYSagHttSYaacaStcgcagaSttcDBtKtttggtctacNttg
+NgKNNtcaaaaKWactgaaYgaYactatHtaWcaactgttSatNVtgtctSttYctgatt
+VaatKgtaYcaaattSgttaStatggtccaatgSWccaaactattgccgttacgcNatcH
+ctctcaKatgtagtctattttaaggHRatcDaagSaVgaVNccaBKtacgtttStagKgt
+ctaHtcattaYcctaVKtttaYaaatYtccgataaaVttcDgatWcgBtcctaatttNaa
+ttgctDYgtgatcaatttaagggctctcatcKattgBtaBagcaYcKctctttNtaacHa
+cNStggRtMatHHgtacatgcaMagtgtccatRWttRKctaaaDtcMctttaNVgaNtcM
+atcacHcctgWtaaStcacgtctNaagRNNaagMaDtactDgctttttcatcYacttaKt
+tatgcStDaStNaMgDtaacKtMtacctaaWattggtttNaaVHatgaaattaattacgV
+NaaWtggaWatctgVatcacYctcVHMtVaNacNtcccaWtttgcaacctcWctHaatct
+tWcaaaYaBaattSctYatctaagDgBttagtaSgaWtBcRcKtccYatatcKBgtcttt
+atgaaHDcgNaMatggatgtWagRctStagagaagaacagctWtNtataaaataRatHat
+KgctNactHgttRgRgVcRacatgHYaNttaHtattaNStaagatgtagaHcVctcYggg
+ccYcaaaatgatcttctagctctHMaMMgcaVtgHgtaagaWHHtggtaactBcaMNNct
+agaacggWtctttgaggHcYNaaMHtaYcttKaagtSccgttgggNMStatacDttataa
+aVaYcKtcgcattttcgacctctcacVttNtttattgtcttctaVcatagaattMttgtH
+tMgacataaatagttctMtgtWgWctttcaagYgcgtNaagcaaDaVHaaStMtaaagcc
+ccgtgVgtcacatcHVaDtgttBtBacBtcggYttDagaDYtccMttagcttacNcgaag
+atRtDataRtgctaatatatgRtWVttatWKtgcBgactcgagaSgtaaaaagttaaWaa
+agtatttctcWtatcBtcataacNcgctcRKaaDKactRaNtagtatBtgaaatttcgcD
+actttaNtYgagagaNttgaattaataaaSMattRHNtYtgttgaDBRBttgWttagSat
+gacDggNVagRWcggctacDaYSgaaattHgtYaaagctccVtatacattaMctttgSga
+catBKaattRgtaBRtttaactattctagcMKMtttctgtgtgVgtctttcDcgtaaMta
+ggtaaaDtcaYtatccgattcYtgaaRttctKaNctaYgYaattYgRttWctWttaaacc
+aatcactVatgcgYttgaaatgatKBcNRgctcatgaccHagcgaaaatgtVgccatcaB
+SatKccRStSattaaatttggtaagcVattctgVcattMtacatMgaaaaaataYNDtDa
+atcatWattcaggNcaccctcBtgcKcHagYtatBatgBttgtVttaYBgBgataaHNta
+cRtcaaBaKcagNtcagaatYgttWgggaNDagtatagRtctcDtDaHScagttcYcatc
+SYacHcagagNgtgcHagtacagctgRtatatMtaatRaWMHgaaKacaBRtagHtaaaN
+cVHcatWBgWaaacWccggtaaRcattgMgttaNgttVMVttgcaagagaatcaaaaaag
+YScKVtgccgacHgacgttcaMcctcattatgcBttttaagtKatDactccgBatHYgtt
+catcgaaatctSaKaagaatWVtcgttgtcttaMaaYaSDtaaaataccgcKMtatgKtg
+ScaaDMaaaactgtgagcVtttaRcttgtaNMatatatttggtMgYVatDaatttgcttt
+aaRtaBgttaYaaagKtataMtWStcHaaaaNacgctacMttDDgactacaNaatBcagt
+cattatatSttaVgRtWgSggcaatSataVgSYgctBttataaYRRgaactgtgHtgacH
+WSactYNgtttBactatWStaNtcStcMttgattStacctgaattctWatNaaHgMatat
+tcaaaKWaBaataatHKgaWgataYcaWMBtgtacKagaaaaagaattttWttDaMtggt
+tgtgaNMtVtDcaacNttactattacggKctatttaaaaBKatagttHaatggaatatYW
+gtaVtNaaYgataatMaccWagagatRttMtgKaMcgatattaacaagatgttBBcNaYa
+ttcNgtRttgaBcctaagaSMttcMtcctcYattcaNaRBttaatgVcMNgaacKagatc
+gNctaWVgttaaYRtgctSctaaaaNtttgctaaScttcVattaHtaaMacNgttNtKHM
+cctattttaRtttVtSgtacatBgtVaaSSaMVaRBcaSaRHtaWtWHttMtattVcaMt
+WaaaNaccccgHYtcatagaaRtaaBaatttaBccaatcRctcatagWgcBHRtacaaDt
+tcBgaHggcgctaHtgacagcSNattcctcgagaccBggtcaagWctgVcRDgVtaagtt
+taattatcMtgatNagYttHtYtagccRatagDtaatcNtaKtacaMSgDaaaatttgHa
+HtRDgtaattKtaMHgaBcaWtBNYaWgtttStttaSttgataatgactMKatHBtttaV
+cYatgggttttaDKcSatttMatatcagtYaBtgVacaatHcaDMcccgtaataatagDa
+taatVaaagaagaVtctccgaRgtRtaatcgagtcacttgttSatgNDHaSNRcggtaSa
+agcSaBgWSgcatcaaWatgttacatgattcWacMtagtgNcacgatgatttttRcWttS
+gtaatMRRBaacNWRHaaBaattDaagStgatccttcaDacccctKaagScSSHaaYHWc
+HcaWcaaaMBataattgDtagccWtcRHataMNKtMgHaBcatcgaagtgtaRgtgggaV
+MatgttaWRtStBHactaaRaactNctcHaaaggcatgcVHKHgaatcSccttggSaWat
+WtNcaaBctaRagaaacacgcttcKatRattcWtgYDaaaaaaNatWtKgaacgtNttac
+tgWHBaccaWacggttcaaVgagaaacVtMttatagaagtatWtaaaNHYaMacagWagt
+aatttgcatcttcgaatacggaHtaatVattctaDaHtRKRaNHcttacatcDKttMDKa
+WggDtaatcttYctcWtRaaaaKtaatcctgccccatgcgDtctaaVMtWRKKDctaata
+tDgactagWtaaaBcKcacMactMHHttgDataKHDaDttHttatttagtcaaVatccKW
+tacWtSVcaggtaatatDSatgcctKtatDtttagacKaaaagcgtttaaSaaaYtgatt
+gtKtgBMcKttgDaaaagttBRatHgcaKgDgtgcWataatMWgcVaVatcYgWttaDat
+catNaVgtttgggcttgaHRDaWgatttctgMHgtVtgccttBtWtaatcgttcgKgRca
+BaRMtaattWgctaatMaVBccaHtDagaBNaataRcacYcYcHcatBgaNtgaNgKHtt
+ctYaacaaaYgBttRNtNggaagcWtDggattgagtHaWttVacaaaBtgttaNctaata
+ctKaMaaaaaDtaRatttDaaagNttcYcaaactcMgaYgtacaaatMaaatYtcacVaa
+cgaaDagatWgBgaataggtWtKaaMtgDttHtgagttaatttgVaaDagttNMataatt
+taSVattNaDtKVccaaatcgaYVtaaaacKRaataatgaBDtctRtgVcttatttYtga
+HgttBWatgaatatacSaacctSatNNRccagtactKagaRtgSKMcgaaDattttagtH
+cKcaaagtggtataaaggctcctaSatHtaMtRKattaNRcWtccgctataKggatWtta
+ggtaatHDRatttattRWgcgatcttagSgtcttactatgYgttYaVBtgcaYaaRtDaa
+tacHHtDcttHgBgNcccataDtaaaaatctNtacatatWaRMBgaattaaaacgctctc
+tcaagtKcacNacgVRVctttttaacttgctcStatRScaRaMataNaKagtatcattRt
+tNaVatcKgtacNatttttgaNcgacaaKctHWtgaKStacMaBatgWttNSacaaKcaD
+aatcWaKaccgYBggMScgaMcctagcaDatgtttcVatgtRBtKNWHtcctWDtatttt
+tNNSaatattcMttgatKgNgaNBatcSggtctRcttttttatatggtNttDYNYgaaaK
+ctcacacYHRgttacatacttYacaataNaagaaaagttataNaataSatacagttScac
+VaScaccSWtccagKHtaatcaaatVacatWacgBctccaataHaaYtMtacKacHtttt
+KtcataWWtgtgaatWaataaaaacatttcaccttaHtttgttccaatcccgRBaWgatK
+gagtttBaVgaNtaNVBgcaataagaatagcaKRttgtatcaattaMtaacatataDBgt
+aaNttcaNcgagatYactggttatgtNVtaBNtDaaDtDttaSaWtactaVtHactttNt
+tcttcatWttcDatKaacgtttggVDaDtVagttatgtcagactKaatcaYtSgttttat
+aaataDttKttKagacWgHgatataaatcttagatNKtttWtWaaatattacSHaRgttt
+ScttaatWttacgRRaaMactcatBacaccatRtttgaacctacttcDMggcVaSBagaa
+tcttaKMagcaVtctDVataWtSgatagacttBctDtBNWgtgKatWctYgaaStccgVa
+aaDattYatagtatcaacBaWYctgaaatttaKVgYtStNtcaVggtggaNYgaRtMaac
+ataSttcagacVactcaVaagtggtattaaDBNDaagtatatMtactatatgatRSgttt
+gccaacgcacRMtacRYNataagatcMgttgatcataaacttVcatatgWtacaaaWttg
+gaaactttaScataactRattMtDacVYataaaagMaattttKtgaBttKcaacatattV
+tagtcatgactcgDaacDtaWctatRttSSYNtgWaScaaataagaaatKtagacataat
+ggNaatttcSKtVWtgacagKWattcgVatttcKWgagcaWgNKaaaatatgtaaacgtt
+cactaaWgacaccBNaacagaaStctgctaHcVtttMtcYttStagYcgtttBcRtaYac
+ttgNaacMtDRtagcatgtgcgagcScaMgtaatBaKataactMttttattaRcattatt
+atacgtaagSNatVRgcttcgaVaacHNtctaHBKYgKaccYcttagagcccaVgatttg
+ttagactaaacgtgcaBgccaWgaVataggattDBWaattttgtBacWtttttaatDtMg
+aactaagcVtctcagBMKatgattgaNaVttggatDaSaBatttcgccatatgctaattg
+YacatgatccacaaMHtttcKYKaWtYcgDtNaaDccgNaNcacacHKttDtttaggcta
+gRVtYgtaactagctttcacaaatYtHaattYacaattaMSagMactcctcatgtScttc
+aaYtataaaaScHYaKcaYacactVcacataNtaBcaRatgYagVBatttgtaactttgR
+ggacaagcVacctattacRcaaMacHRagagtaVNctacagtgagacgaaaggKttacat
+tgggacaataKNtattcaagWKttgatNagNtgctaNgagatNacSatctNatttatcta
+tRgaaaatKatNKSBcKactatacStcagtaggtVtcaaaBYYgctattKtWNttcRaca
+aaNatgaacttaRtaaDSttVBYtaatccagtNaaacRttagaaccRBatataWaatKct
+cattcSacWaacaacactDttVttgacYaagagtaSgcMttBttaVNgRVagKDcttctt
+cNtaggttgcgacYacttaaggVHcaagDagaagataaVaatctgtatRatDtKaaSDga
+ttcaattYtcatgYgtgaVMtMaactaagaatgRgDtHttaaccaatStaaaaMctVDDt
+gttatcttaBBgccNacKMaHggcBMttctgNctHggagaataYMgtaMccaataattHt
+tYttKggtKaccaactcccHtMSaatNactcRtttcatgcKcatgcacttcatSaatata
+ctttVtaYttDattgWcctcactcYccattaDDaHaaKcaatSttagKtWtcatRcaact
+attaattYaDggKtagtNcgSgtttKRgtDWtVHtDNcHWNtKtccgtctagtatSctaB
+cacgcaBtaacatgagatVtttaaggcaVttBttaStWtattgYaggtSatBMBDactVt
+ggttDagacataaactactBgcacaacMaagaStccaWNaaSYMYtgtaKaMcYSaHaaa
+atatttMgtcaaDScaKtcaBVtaMVMRRDMtcttRBgWctaacttgaacNaatgttWgt
+ggBtRttHVKgKcHVtatattSaaaatBttcBtttcDgHccBagtRBRttaVagBctRca
+agcattacKccaWVWtaVcggttatNaSgccgKtYcBaagcWgcatgaNHaKtagNgcHc
+gtgtcataaaatagagacttgHYatattctaBgtttatRatctatttagacattttNtWa
+aSagtaHatRtctcggatttatgtgatBtctRggggcatWctaSVMaRtcatgKattgRc
+atMaHaataNcBcDcaggcactattHBgaatStatattcatBgMVataaSacVacKHatg
+gttaaBKtgtaSaWMattttMacKtgaaWaaWgctgRatgtgDacBtSaHtDgtgtMVtt
+agatgattagagaSttgattgtSaaacagHaaatacaRcaccBtaaDtcaMtKaaSttta
+tKagaataaNcaaBtattKaVNaWaNactagtYattaaagWgHttaMcKaSagatSactc
+tatMSagtggaYctcacKKgaSMgcRgKtgccagNMataatccaVgatcttHagttttct
+taaccataggggcttaDtYatcgaaaMataagcaaatBttgHHcHagacagagaggcacW
+tacccMttacgtgNttattYctVaaactgttaagtKatMagttcacaaagggatgaVNMa
+tgcaSattatcKagtHaBtgaagBcggagtWttVaaDaccMScactgVatccaRaSatat
+tNtgcBatgBaaNgtcaBMgggaatgagtatRgaatgtNttacaggcttaHaataaHSag
+atagtgVctattaaagggaagDWVccatcKaaaatRccccaSVaaatttMtatStgtWag
+tStMaaatBctgcctKWgttDDaSKactctaaVRtaSWcVactggaaaaNMaaaccgcac
+NtaVgaagcttDNgaDBtaMaMKNtKccaVtgctcttMMYaaaaHaattcWgHcgtacat
+WaMaaKtaataccgBDaYRaggatatSKcScYagMtaatKHMtaaccatgHgtagDaggt
+gtaaatatagaKVgccRYctcRaKBKWtgatHYcaHgBaYtttMcatataatgaDttcat
+ttaStgtcVSgacggtggVgtBtgacatgtaaSgtBgatKtKtaYcatVtNattataaaH
+aSccHaaagctSMKattcatagcacagtgBRataacaatMttKcWaaaaatagStcggRt
+taattatWaataatMaYagatgVtatccttttHaScgtBgagWcatgBtgcctatcgtaa
+WHacagtactgaattaaaaaNattRNMaSSNSctattcaaagccVVcatattttagMcgt
+attNtVBactacScattgKVtataaKtttgNaWcttNacctagtgaNaaDcagtaWgKgg
+aaKtacgcaaaYttatacSttgYaYttcDNagggttVDagHatSgtacYVatataVatta
+taSataacgKgatVtVacHYRWttatcctaaDtgtaaDgRDttttattWtaaDttggatc
+attNgtVaaaVggaaggcYgSWaaattcWHcgaSaVWaMatctMDtHBgttttaatctaW
+aagatatDKtVttaccgaMatRaaaBttaNagHatDHWcDtBVttaatKtMataYttSRH
+HcgtaHDtggttccaaagRRtaWtVctRcaNDttatacgatMcaatNHtacgaattBaat
+HtcccatctctccBtgtataYctatgtcgaaDYWtNggatNcacRtMaatNtKcttSYSc
+taDaaaggctDaStatKtataBgcVaatttggYcttaaatgatgtHctaaccaactttgg
+gttcMaaDattatKtVacgVcScaactSataSccHttYctttgtggcDtMcactaNSBtM
+RBMaggttWKtattaatgtKHacttcaMVatctgttgtccaaYNtaagttKaacttctHc
+gcWtYttatMBgBaMacaattaDaactNaaatSatcVtSSgatctatgNatSYaattRat
+gcDgtctataagagaagRgatatttcccaataHgttttWKtgaagNRtctaaBtWcHHcD
+gaattgaaaKtgttaaRtatgtaMaggDttcMaccaMaattDctgYctaWtStaNtgRKa
+BtNcMHcSttMtaKccYacgNNctttatStgVtaYtaagttaagaBHaaStVKHatgttR
+VWtataMtSatgcaattcMcttatKgMcagtgaatcYtcctNaYcttactttctcttcat
+ggcgNcatScStBtagctWtHaaWattaccgtctcgtBMcaaacKctcccaacttBgtWS
+tVttMRgKcVagHttVtaagMaNatcaHttacatcYKttDBtatgSattVcgBcBVYttH
+NtcatKgcYgaaSaKtatttttMtctatctaSaattDttcWagHSacgttagYgacWaSa
+DKatcNgctaatgVSctgctYgaKgKtaataggtggagcgtcgaaaaRYtgYWYSaatac
+BgacWtaNStcaattWtRcttttaaSYgttcNgtBWWgtgaatHttttBaMcMtKccagt
+attttcgaHaDtSVgatgaacatgcacgtcagagDYattBcagDctcttNcNtaaaatRc
+tgMcDacaagtttagtcaaSSaagaaacatacaDtctctYgcaaacBcaagaBatgtatt
+gacgagYacBDgttcgtgRtaMgaattttcNtgVcttctgtctagtgtccatatctgatY
+atNtatVWgttacaDacaHDDagWtgataWtatcaaBRatDRtMgVcgaaattcSMagYg
+WacgggtaacaaattcagcatagSgttactBctgSVWatYcYgcBWgggRcHtataSaat
+tBcagHgcgcctttKcttWaggctttaaDtRacBactaaVaaKtaaacctcgcgccatta
+ctKactKSDcgacaVtatataggataKctcgSatgHSatVcgtagtgaBtSYtgaBataa
+tStaaccaagttcaDtHtatattaacYatattatcctacgagatcaccgtVSttctYgtc
+ataaVactcgWtaVatttgttggactaaaVcaSaDtYcgNtYtctVaMtaattatWRtWc
+aNtaKcaaYggatgNgaatcaatcRtcgagtHcgVgttataHDcatttaagttctHtcgM
+RHtaaagaVactBMtatgaagtaaaaaBNtataaNttcKcctaNttaaDtcgMacgDcaM
+atttgYtaaNtcaccgatgagMtgttaggWcacHttNgtcttHYMcaattKcagttcNca
+aaacgNaaSattgKttaaBaKttatttaMggHcttttaaRNVgttaYttttMVRtYVgRa
+tKcgVtacgaatttccBatBgYBRtSKKctaaaatgatatgBtcttcgtttgacHagtaa
+ttatatctgDtBttatgaDtatKtcKRcRttagattattagHgDNaaaKgcgMtHtttKt
+DtgaaaagtaMatcagaaccgaatKgtatatVaccRaKYtDHtcSagtBgtgccWaaagg
+tYKcaHatDDaaattDStDtcKggtMgcMtgtHtcaaVcgtttNtagtNtgKgctaDcSc
+gBcWSatgtatagcKgWgttgaacgagtgcgcgtKaaaacgRtttccatatatttttMga
+KagcVcVRataccWctctcgBcgaggcgttaatgaHYtttHtaSWtagcagtttKtYaac
+aaataMtaNDatRgMBaBacSaataSDctgaactattgataaRtaVtttHatWaacWtVa
+HaaBDtactYtaDactttSgtKtRattgatttatatattattataattBatagattctaa
+cDcRMaaggttcgtcatattRVYcttKgtRcgWaatcgaaWWatDctacaaaagaattHa
+atctgttttacYatKatBaccMaMaaVtcacStaaYgYKgtttctcattatattNgSaaH
+tgRaBtcataKYtHtacttgtacaaaDtYtgatagNRcYatgaStaaagactgtcWDtYa
+atVaNStagaaaWtaaaataDYtcaMatSVBVaaaYagaaaattgtgcDagWSaStattt
+taatNcacgataNBtaattggaatgcMgacattHaattctctaaMatactaBaaattaca
+HWgBNtNaaSattttaacHtgtagtBtcRtttSaNNaYaMaDtatDtagaKggYgcaaSt
+tgctactDcNRtWgtttaVtggcaaactattgSgaagtattatgDgcgtgtcttagcNtR
+ctKggtMaHgaDaaagtactgtcgatttagatcagNggtaattaKaatgaaYaaHaattg
+gttVaaMggatactctaBgtYHMcttccVcaaWtgttHHRgagttKaaagaBtaRtaaWa
+ggttctatRatSgtatcYtaWcatgtaBtcaatctaatRgaYYtWtccattataBacttW
+tcctaHaaaaggttgacgtRattKgaagcattSBtttctaNcSctSStNtYtWaWtgtag
+tcttgtctttaagNKgaagacgDaRgtNaBaVDgaattggaYtaccSVYKctSKKcatag
+ttgSttatcStactcaatSMataHcaKgatWVYtNacagtttBtRagYHaagtaNaaVVD
+gatattMaagattagcatcctaMaaMctgNtMcSaRcgctHMttaattDtttYttcgata
+aagtMtaagttaWaaDcaatccKgtgMMcatBgtRtaHBcttgtBaBggcaDcgaWttgg
+gtaDaggtgatRtYaMWDttatcNtVcttRaKagctRgtgcNaatctgattatagattag
+tatatgaataDNatcYaggKRacaatcaHcaagttagtKgRatRgttaagaaaatacVct
+aaaagtgtaagKVgcttSWaaHatagHctagtDgDtSaVtgatcatttaNKgKHataKBc
+tatatWaNgtttgcRaVNttaDgtcttagHYKatYaVaBtaatgaBattaYcNtgcaBtH
+aacttVtccatDagVaaaYgWtNDBgacagVgctcaRtaHaaacttttacaaggaSRaaa
+tagaagaatacccVaHatcBRtcttttaaDMHWtHgacMtctcaagKDttctgYctctcN
+agaMgcgaaDWatMcMatatttDctttactaVSctagttcaRKWgtttKRaVaaKtacaa
+caKttatttttggcctataaDgtcBctBDgcYYaatNactcaaRgaRWcgattgVNcWaa
+tctgKagDMgctatKttRatcattMaagtctaRaVaattKctgaKtatccgaaRatcHMa
+aaaaagattccacgtacgaDStatatctcataggtacgcgatgtgaaggtHYtatWagKV
+KgaMDcaatttWccttgKgagtctagatgaatgVRcctaMttgtaRaaYtRtaacWgaaa
+MttatcatNcgttactaaggtDaaggcagtRctcatcaatggYagccagcgaatatagtg
+ttWtaccaRctagatttDtaaatRcDKtccHtBWgttctWaagccYBSgtggaaagHNtt
+HtctaaattaBatggaDMgaBgatatcaatactcMtaaKtcYccgatDaYgHDBaagBat
+tWattgatttttaagaRaaggatggYggaKttaKtBVBcttaWcttBtacctYaNYttgc
+tgtBaaMtWtcWaagtaaggWcgMDaaNtccWMWtatcMVgaSaRctaKtBgKWDacDga
+aaaNgttcaaaaataMcttaWtatgNaVaaRataWtgKctRatataagtgttgacgaKga
+NgtaHattaaRagSgattctatgtYtcaattagBYBatccYtgtNacHagHtacVcVaca
+acaccgNgBtataYaatWHSttattgctDacttgtgHgHcMcHacagctRSDtgattagg
+aDHtYagatggagWtaMatcRcccacRaaaYagcagatgatacatatttVBBcaaMtctc
+taWgaNtttcctaVcttaYBDBctRgSaagcNgatttcacgtcRDaVBttaRaggtaagg
+HcacttccgDBKgagaatttataaaMaRattagcVgtttacaaagagaaaMtgDtttYtt
+ggcttataKaStacaVttBttcttgBcVaataaagagtgagBgcgNcNattgaaacRcac
+tDaaccaatWMtaaHtBgaaacaaccctcMctcaaatctMWttggttttacttagcRttt
+acatRtccBttVcatgaaBacaYgagHttatWDtcctSatRtYggHtNMttRgNtgcatc
+acgacagaHgtYaSaactgaaNWVagtagttagaNgatctgcatWYaDacataHtaWtta
+atHaDgactYgttcaSVtttacctaatttaDgRcagacaDtgcYVttaagaSSKBYtgHt
+DtNtcgtcWttDtgtcNtgacKagcactccDMacDNcccctWataRKcaaatttctRVaa
+cagcaMtataaattWBctttgKgVcatttaVgtDgtatHtgtaSctagtatagcBtBtgt
+atgtcgcMcgagttctacgaaBgWccgaWatgcaRtWtaagYttaNtcWaHtgattYDat
+WRgRWagtRcHggNatNttWaaacaSgcaatMatgacNgggaSatgatttcBHcctaagg
+WactacagaaaagctMcaaagaYtHVgtaaHKgKattVaWtttcctaWgaKattatgMaa
+ttBgaaagtgaSaaaWtSNBtttYataVgNatgaSgcBaaccatattcctctagRtatta
+tctttctMtgaRtctcYgaatDtRcHgcRVtWtaacDtcacYatRcttNgcgaDtVctWt
+acHtatatgtatKaaggtaNcataKRaataacacDctcctWgtSaWcatcDgatatBtaa
+tHSNBtcaataaStHtacttaYaDaMtaagMtgNaaaaNccccgYWHaatgcBcttaBcg
+tMBKggccaVgacaWgaaaaaVYcRKctMgcaccWctcSacttcVtacgaagtYtccttt
+ttaYgttattaataactSttRggtcVgagWRStatKataYcaatNMtacttcgcttVBaY
+RaKttaaYatacagctBgagcttcHcaatBaaaVcgctcacaMgttaHaggctaDtSgat
+attggggBgRMagtaattggattgYYHtVtcttSRYaacttataBtNKgatVaWSDWaca
+tVcttgttgaagScaDaSttcactaattagatKttaMcHtMgKccaYatKataMcKNgat
+tgtYtaaRHHcaWagctgtgcYatMHaatRDgtgttYctatNKtSDtaKgcBttgagtKt
+acatgaaggcgMatDaWtcBatagtaaaatNYtSVgVatttcaNgRtaRaaNBttggaat
+VgaaaaagaaggtgNtttVBgccttgtgaBtgMgtaaacBgtactWgtaacctatatgga
+SYattYtVgtttaagccaRtatRMcgWMgDVSNgataatBRccNagagStHttBgctaBa
+gatattaacaagaggttttcDaRagtcDgtHttcataagaacaKBttaBgactaRatgaa
+DYHttgVagcMcBDgYactWgSgacBataMMcttSaRHgcagKcgaaYaDgttcataYKc
+ttcMWttattaaBacDcttDtttBcatVggttVHtgtMgKcgaaVgtcgMaaHHYBMaHt
+aaKaDttaNgNtttttaggMcWttNaaaDaaaaactRgaatagSVHtaataagttStcca
+atcHataatacMcattHtacaatttctgatggacatatgcaaacaKBatgcagacagVcc
+tccgcaacNatcMaHtcMtaSctgtaYgtStcBtcatDacRggttRgagaaHatVcttYW
+gaDtatgYcaBKgtSWVYtttctWttHtctaYttttaBtcataaNgtBRaNcgttKgtgV
+KgggVtWatcWagttSttttttaMaRWtccgttttattaHatttBVtataSctRWtgcMa
+caattaStBcacggaatRatactVgaagMaaagWacaMgctaacaHctHtaatacacgaY
+agtcttKagcDttaKBHccgtaHaacaKVtcMKcaataaaNaggttSaatcatgaNaaBt
+acggBcaagatcRgttttHaNgtKctYatBHHtaaaDNHtaVtVagttVacKtcYgcatt
+catacaaagtaacKaKKtaaNtNataaNaaSaBtagaattctgacacNtaHtataBDttB
+ctataatagYSctgtaHcgccgaMBaggttaMHtKgttactaaHaacgDatataaagcaW
+tgaMtttgVatcKaattcgHVNatNgDaaYtataHacaaacaagagtatatDStgcNgcR
+taaWVVaDStNgtcaaacgDttaaggNttWcaVNaccctgaaaMcagVYVaMtBgtatac
+SacgSgNtaaaDtRaBSaWcNacgYaggtcaYtattagVStaccgatgSStMattctWta
+ttHtHaDtatgYaatattgttttaNggttVatcttRcgaNtHaVaStgaagactcacaaa
+tcactgataaKBtNHtttctWWtattgactacNtaWatataaaBaatBttgggtatYttt
+YtgttttVttgagtcVaMVgaatNtaaNgKMaacgtaatattKWggcagtgRttgtgaca
+ctaaYacactggaaKaWYRgcatgcgttctBcttggtVaaWgtttHagtcaatctcggaN
+WtaatBNcaMVKStaNcMtgatataatDYMctttcgcatgcYtHtVNgStggagcBtggM
+gccctgtgNtVatactgcctcHcataDBtaStgNcagaYttaMtcaYtgtagatDaagaH
+aaaRcRataattcaDtcaDgttgtatRaaaaYaRgtttDBgDcgaagcNttgcVttcact
+taMgtMWaYaattcggaDcgaVtYattaBYaaaattaHVttttWaacDttaRaSWactcB
+gaRctacaVStBaaatRgaacMSaagaatagYtNctcaatagctNttaVtgctgtttgYc
+ttaatgtgMaStactgDBagVSggtSKMYttDatgtMaaSaVtccSRMgaaaactHaatW
+WtcatttctDgcMcggVtgtRtcatctttNatcaatatYaKaaaatKWtDDDaaactaag
+tacRHtcKttacaataggttWcttataSaYctgctVtaaVggatcctaHVttgWtgHtWt
+taDHaNgaccctatatgcWtNttacctaYtttDWtttaggHNgccatattacKggattVa
+tatcRcggRWMtgcaVRaaHgtaataattttaggtctcDccaatatgSaaaagatDtaaV
+tYgNaHBtcaYttaaaaacagatataaagttaaaDWccMHMattggtaaagtccgaKtat
+DKaVHaBagaBatactataVttDttDaMagctctaaDSggtttgaDacacVatcttNtga
+tKtVaBStatgNtgDKYcaatcataWtcNatYccgRtcgBHacaBaatagaVtagcttga
+KagcgHtttDNtgaagMttSttttgDDKRWtagtaBgtgagtgBcaDtWtaHcctatHat
+ttgttWgagcggDtgtRDRcaaatagcacacRtDgtgVaWtaattRacVataBWacSYWV
+ctgYtWDaVtaKataaacttKaaaMVHaaaaKNtaaacttgVataaaatMaaatMaagta
+tcaaRtatSYRtBtaataattgtttgaWtaNNtctcaatNaataaaaaaattgaaaatta
+ttgtgttaaYatccccHtaNcattcacttttaMgVDtaDMtcaWSgYWcSYtSgaatHtg
+ctagaVattaBtaaaYgatattcgaaBtgaaDacacatRaagcgggagggDMtatDttaa
+tttggaKSNtactRMttactgtBggcgtcatNttctattaVacgttccKtVttMacttWt
+ctaYcacgtaVtaaRgKcttggatSYatattttgttacaaMgtgagagaSatattWcagD
+ttggNtNaaYtaggaaKtYHcttgKattWagNgtaagHHVatYatcattaaaaaYtHgtt
+caaaataattatBgcaKWKtagaatagtatBagaaMtattMagaMtHcWgYcacgttagt
+gtDNggctatNatRcYYHtaacMaSStattRagRcgataaaatWNNatgaaatttVtKcR
+tKtDtaaMcctccaDRcaHtBSWcYtaKttcacaaMaataaMaactccgSgtYattDtaW
+ctagatBtaatSgatgatHKgttgcaaaaagaScHtgaaHRDatSagatcBcggcatcat
+YVaatgMaatStgNgWaaaaMttgcYaaagttSHaYgaaatHattBgtaaMRagSaSacB
+aagtttttcatgttaaYcagYtgKtYctaStcaagcgtaVattaNatWtHgtHKNDtcNa
+KaVaStSacaaStttagaaataatgcDSatgtaKtgMMtcaaagtNattacMYgtgctNg
+VcaaNcDtaaaVtYggtaaaactgcaagaWNcaaacctDSaaSgVaKtctcatataMtgg
+BtaRttKtagRcctgttaHgWRaattgDaaatttHtaccagctcagaccKaaBctaagta
+tWtaVagBgtttatgaHaaggattStaactWacKDVtMHccgtacaMWYctDtagatttR
+ctaccRagtWcWgaaaaMcagttctgacSctaaaactgaatcacaNcaMWtWccYgtttN
+aatttggttaaNtggttSattttcaacgYVccMtcgaactBtatcYttcYDVMttcgatt
+aKWtatttagcaatatcagWatgcRVaatgRtacWaVVBttggatRtaNgRagttDYata
+acDVBcaaactttgtttgaccatagHMtRctaWcgacagtgcVcaaVgRgtaagtRaaaa
+ttSBKacBaatcagaatgtHattcaVRtatVSSaKatNataWRVaaagMaacataDgata
+WHatcNYcMtatttggaSatttcHcgacaYcaKaaatattacHcSaBVatHacactaMDa
+taaaggcacaacaSacctgtaaRgtcccaaaatWtDtagtcaagNtttgatDacDgcaga
+DcWgatDaaKagctDWtttatatWgDcaaaWttStDtKtatSagVgaaKtaacgaccgMg
+aSaatRRcagYtgttNDggcHScaaYDWtcaacgtaHgaStKtgMtRtaatccagtDaaa
+cHgtacaaccHtagataNaattatcVtgaKaaNaaaaaaaagttgMgtcRaNaacagtaK
+caBgtttgaMDgDMacttattatgaDgagcgtcacaaRaagtYaggMtaaactagaacag
+VaMWataggtatHagtttaaHtcagtaaatgRgcatgRctgaMttBaaataagWVtcHct
+gtgtYaaaaVtKtaSaaBatMtttgttatattattcaaBYctBWtggatBtgaggDagtg
+cacVataRBctaBaaaataatttttNggtccgtVaaaaataaattBHaatBaagaHgtta
+agcctaatcaaatgaYtKaatYtaaggtMgaRggtWgggNactaacgaRaaattSttWta
+ataaVtHgtacttNtaagHaSacgWggaYggNStcctgacgDcgHggtttHggtNtMttt
+DatNDgtgacgtatacgatKatataaacaattSaaagcagatKtttSagcaaMttttgaK
+tMtagtcRacctKSttBttaatMtgcgttacaaagaVaataattcaSaaWcBVacYKtac
+aNBaaKRtRtcgWtWBaRKVtYWWWgattgBctaaatKaattaYtMtSBMBHDtBtaggD
+tcNctWYagtgSaaBaVtcttNgtcgttHtgtMtctatKtatVggKaSaagtttatttta
+tgtactactHtHttSMactatHcaagaattVataaaMKNtaMccgtgatDaHcaacttRa
+taacaNgaatcSBtatgacBcctcgggtaatWaaWtacacaattctRVgattctatgtgt
+atHagatagggacVaattttDtNaWKagtatatHtagacgaggtatgtcagtgagHcccc
+aatNataKMBaHtcWgctagtgHaatBatSataDatatcacccaagattttcSatKgatW
+tgaagtcBMataaHaaMaattatgcttWWtttcgVKYNBattggtacttcaaMaVNcctc
+HatcgctVcttKatgtctctBMggacatcaggacSgaKttgagtctKVYaaagtaaSgaa
+aHaWactgRattaaBttVaHtggattagRWtaaDaaatgatttSMBWMaDactScgRYtg
+aVagNctgtSBataKacStHRatctVgBKaggccaRctaacttcYKtcaDcttgaaacBB
+ataatacYMgWgctgtacttttatgaSaaatYcccgattattRStccaaaBagaacaaaV
+tttgcttatagaaacacScccSaNtaaaaBgtaaggcDgtSttRatMYSWatcgtaacgt
+StBagttaVaaaScccSggaMDBSgcaaKaggatatacgtatgcWactccgVctNttMaY
+taaatKaaatgKStaaaHaKatatgBtcctatgtVaBggaatBcgcaatgagtatHcYag
+ctDgtWaaccagtatWWtaRtKagatagtgKatatgaaaggcaWgtNKaaagataWaatH
+aaaaaKMaaatttBtatHtctNactKtBVVagtatcacgtMgtgttaKtaatcgaaMHtY
+KNcMaatgcaSaaDBaaaaagaWaDtWMgaacatttDcatttaBaBtDttaaSMtcagct
+tttRWWaataattcNctactWaatNaBaattaagaaacttYRHaccatatKtaKcNVgtt
+YagttBtaaaaVtctcgVctagctcgSVatatagVtMcaaHRctaHStttNtcattRaat
+gtaRtgttaatYtaagcattgaatttaKtctaKKgaaggtcgMctttcWaagcgWaKctt
+cYttgtgaRaagMtDatgWgYaataKaatSWScatKBtYgtaagagaVcacgctHStaac
+aSgBtgtaNRYaaWtWcKgaccDtgaWtgagMaYgVVgBaRacYtcKgatcagttgtaKc
+gttgagNaStctggaatVtactaSNtaaagtaatcaattaaVaaDattHDBaHKDHctVg
+gcaaacccKMaatVtgttacBcctStgBgMtScgaaHcatgctMtStaVttttcDaNagt
+DVaatYcggaDaYtaactaNgtccaattSacaaaaRgtagaaKgtcRSNtgatBaccctt
+MtactatKgtaaRMagataMatgVtVKagaRagtcagMgMaatRHNttagaagaatggga
+atcHtttttSgtNgYatgtgcYtaatgDctMaaaMccVScgcRgKNaaagtaMtacaKaM
+NaBatagBttttcttttYatataNaWcagatttgMtgaaacaBYtHaaatgtaDactatt
+tNatttKttSattgBatSRtgKHttacgattgcggtaaaaacHHtaNgMcgHaVDtgtag
+aagatBaaagDttaacSatttaatttaccagatataattggVgaRctRtcgccVatRNtD
+gcagBcVaHtBaatDttatgKRKagataaRgcagtaKgagttatatcaMSagttccRctt
+aaatgatcttataaacaaatttcccttaBaWtagtagttMaacMaKaaaagHatYKactt
+tRatgtctcgattBcSagaDKtttHtBaccttNttVttVVtggttacgtaaBMRgatcgt
+ctacaaNBtaVggttYaaggattccaNgRgtagBtgtaBacaagtataaatBaaatKRta
+MtKHgatcgYggDSgKRaSttHStcatgtatatWacacRacHcatYtttaacYatatgtg
+ttNtgcSagDHgataYttNattatcVattcaaYttggtaRHtWtcgaBacgtttaBacca
+BaatgtcgcNagaNtKtaDtgDtatgDaBtcKgtBgatacNaccDDatttYtKggMtYNt
+aactgVacattaaHgMttatcgtHMNtataBtKSgccaVttaBcttattcBaagtgaWta
+RtcctDVRatgaattgatatgaWgccacDaatKaHtttacatNttaWNWgtacaggctac
+ttBaYaaatatacaaaatttcgNHgMgttHctcKYcttgMtaacBaDVtaatttacagaR
+ttttttagcKagtKactatMRtgtDtaattccRcaaKSttagttttBtctatagaKaVtt
+ttgcNagtKVccttagRgWaNaKWttataDgcgaatgMKatgatRcYtctgVagaccgcg
+VgactagaWaaHNtcRNRKaatactcYaNtSDKtcVVggNgDagtttaaKRgttaDcgtN
+NgtcaYttggtttYtatgtaaaggattttagatattKMcatgYaaatcaVactcagagtR
+YtgtaactatagtBaDtVaWatDatctataaaSgggtactaYaKKWagaaaaataaatta
+tagRcaaaVataVagatatgtaggcWagacRWattctgacgcDtaBcYattgtaDggMat
+gagcgagaggctaaatVtctcagRagDtSgKNcgtVcStacatttagNtgatSNgatcYV
+tHattHtBgMacRaattaHBacRcNaaccctVaaYaattcVccatacKcttSagtctgKM
+NagRaNcatNgcgHattStSKYRggtcagtcaccattttagtMaccctggVattHaatVa
+gaaMaattaVacatacacaaattaattacgtKtagaaaMgatWgWccatYtagacKatct
+KatMcggYcgcatgHRtcStVtaatHgSaaaVagtgaatgtgYtattaYcRagatgatca
+taacacSgaYaactMKttatRcgaataaMSatacNgaMatttcggccacgaYYMcaKatt
+RagDtRtatMVBtaattWtMHgNaWDgStaaSNggStcBcVYtaYagaHtacagttccMc
+gtYtYttcattgSWcttagttcgtHtgVRYgaMacttBtatcaactaaaaVtDgataaDg
+tatcatYDttaStgccBacctaaBagttgRtaSBtaaaagWgcacBggttagcMaYattt
+BgtaggtRBaSagttcacgtaDaYaaaacDSaKattctgtSatatgtatggVBcctctgt
+gaaHDKgttaRttttBMHgRMgHagtagMgacgaagttaatattgRtHtHttatYaaagc
+agatgtgattagtggcactactVattagatctctgtttatcattYttgatHcHttagStg
+atgactctDaaatcagtgttgtttttcYaaagtatatcYcaSaacaVttcgWtatKaaaH
+WtRgtttaKacttctgaaNaYacctNtcStatttaaagttKgtgatcctBcaBtctttaa
+aKagttgDtWctDtgtgctataKagtaNHatctagYgatcMgtggYaagactgacactta
+RaaccHgttcaYtagWtggtgBcStacaMcMHataaaNagatactccaggagttaatcat
+RttttgaKNgSgcaggtgttRaYcaaataBtaDtatHgBtatacKaataKtaggaaatat
+gcataaHgaKttttatMaaaNgMatYattgaatNtatVaggtKctttHattcatttatYt
+attagtataYtttagYcattagaaataHtaaccttactcatYttHMRagttctDagNSVg
+cgVaNNattctVcaaVagaatttaagaggttttacRagtagtaaaBaBaaMtaScKgVaR
+cNtctgtataagtatVgtDgHaYttcHYttaagatRgtgaattctYaaaattRtcWtacD
+DaRatcaKtaSacaagctaNttRYagMSDKtWgWaYNgaaaatatNtaatatHMtMWRaR
+acaaaatgctgctacNKaKtagttgVatDaVccatSDtgaSggcgWatccBgaaVtgtaW
+ttagatVaBWtacgWtaYattaaatMctDgDaaKatttgaaatgctWctttaHtggHaBB
+SRVBWtgattgagatccNcaaaHttccgVcttaDHtNgtttaMggccVWaagattgKcaa
+cgagtatgtccctctcttaccDtHcttcctBatcStVaactaatctacatgtacataacD
+gcgaVttataagcaaRWataattcggtMaaBccYgRctagatctNtBaggacMaaaNgct
+gttHgScgttaaVgattVDtaaNaccggatatHatKcgataRtaMcagctattcaagaga
+atHcYRNgNgcaWtgagYtacttNtaagStaVVagctgcaaggHatgtcaWgaattKttg
+tcgaBcKatKKtDtRtNYNtctactatgcgatgtaacDtcaYgaactSHctDataKtcaa
+gtccVRtWaaKMRtagKttaatagtggKttYtaKtVataWYgHBatataatcatNMRtDY
+aYcttgttHagRtYacgaDaaMMtcagattBVScattYcaataataBWaBatgDtBaKaH
+acagtBggaVtgtgttRtgacataaagtBtaVgttaNaatcaSgcctgtcBBaVttctHg
+VttcttgttatccaatacaNtgcgctatacctcatHtNaBMtgtagaDtKagtHatacct
+HgtgaDVWtatcWgtatScattactSgatcWatatDataRSgctHaaWataataYacgta
+cgtgDatHcgtaacSaaagYaMataYaactggaagtKgattKMaatStRgtatVgttctt
+KSMtcataVtttaDtgttatattagWtatNaDcttgccHaMDttStgtctgagtRtatRS
+MWttaStcatattaNaDtcaatttaVatgMtcaattagMYWaRcNtDttcaaagMgagaV
+HtatYaacggttScaaccVKHaaatacWagaataaccMatWgctDtatttgaatBtNttg
+aaBgagaaWcttggatcRctctaDagWBcacaatMStBcBWtatggtagtgaagaMKata
+cttaYHtNctgttHSMaWttacaSaatgtattttggccatatSatcgctctttgaRRVVt
+DaatcSYHcSDNacattcMDaNVagatctSctBcatagtggHagaVtgtSactctSHaMa
+WtgtatcattWtacgaaHatatBaaSaYacagtaaaagtVacatKtatatataVtagcgW
+ccacagctcaaccttRtatNactMtcattaaatttNaaggctgYctctacatcaVgcMHa
+agaBttcgYDaSRtHgaaaNcaWYBggataatBactgaataYgcgtaacccactHataag
+aaWgcgRacccagagaVtataggcttNtaaaaHatacatttttYYatHattgaatgtNct
+tatNaVcaaRtKctcgaaWctDttttataaatgatagcgSttcVtgatataaataataBg
+aatgaRacgagtaRctttaactattNagtcagtgtgaSgaHRacgVtggRccatttatgt
+MtattaNatgttaaatRaBRttcatcttaRBtNtaNSWgtVSgcNacBtWaDgaaNBMga
+gaBMgaHaHagatttctNtWatcaaaaDgtgcaaWaataBattaNtatgDaMaWDataNt
+ctatDagatSWctctggaccatcaBgtatattaaHacHgattcgatgtRtaYattactNt
+WgaaRgcgDaatactgWcKaMacRSaSaacDgtgSgSRaagNtKttattcattaagtctg
+tctctataaVgctHKttgVtgacgattgRYcatccWcMtaBagaHacaaaDaaaRVgcac
+atgatYaatatttMttaaWBtctcgaNcWDtttcagYKattaRtttagHcKaacaBcagg
+taacctaHtaMtttaHacctVacctaaagtcactttcWcaatggatSaataHattacaMg
+gtgaaWaacagaaattgttggRggcgattatWtaKtScWKggtttcttgtcMaRgYYaca
+cggagtgccDcDattcaaacHaacttSScaaStMttaYtgtcWaaaaaaaataBataWaa
+tatBNttcgttgtVatgacaHtgtacatHtaatgtKcatgSatacVRcVctttagNttaa
+tKYgHtRccttDBggHgDtgaatcaagacacWtcgRWKaactgRaDNMactactgacaDg
+VgatcaagNRatacagattSMttaattYtgWctRgttaaKMgggaaataagttatgHaSc
+YaattccRMggSagaKKttRggtttgDtcgtcMttttggaDgcVctYcaaataattSctD
+accatNataDtaaaWtttagHMSSaagaaBgatYaaggNtagtgctcMaatttWMggtct
+atttggaKagaggatWcatttgctatcgcccBacacttataagaYtcNcagaNatcaYHg
+NgaacRgtaDgaNYttcattRtagNDcHNVcgDctggDatDtgNaaaaaHgaYagtRtca
+aDcgcaKatcagttattcataaccNaatacacaaYWcatBaaaacaRttMgtaattctWt
+tMaMtttccgaNcatVtgatcBaRtttgSaactcaKYaaNtKDttttRagaMcDYgcaKc
+ataVaaagattcatatWcHtagtagatttctBtcWHtctaRgaSttgHatgaHMtNtaac
+tgaaaNWtDctgDcacattMctNgWattatatctSttaScctaDaatatDYataaaaata
+taatNctKaNaatatcSgagttaagtKDttaaStaaHtttaatgaRataBtaVcBtcDWW
+aaDaacacRNtaVggatattatagtBttggcaaKcacRNgaaYaaMRaHtatBcaaacNa
+taKacttaMtaacaacgRtaattgggaRcttagtWataactKttDccgaMcacNHKtatt
+StaRcSStDttacggagagtMtaNHatttWRNVgaaacattcScatgctaVSttaRaMag
+atcScaBggtatacgatVttKcVtagtgccgtcDtagtRagggcagggRRttKtcgtKDR
+aaatgatVttDtcatMaNKtNacagMattgttcaacKaatYKttaactaatgagatttta
+BattBctcaaRWgtYtYBatDcattggRtaaHttcaNagagctcaRatBtaagHtctctt
+RatagBttHtgatgattgcRcgtgSaagcYaccacBWgtaNtctagacgaaSatBNtHMc
+KagttaaDcHtaDaaDtttccaatMcaSaaacWWggtgDtgtMtcacggcgcWttcBcta
+aVatggaagNgtaacctagatggYKRVttRtMcgttaagccaHgatHBcgNtctMKDcYt
+aVttHaaDWcYcKtttttgatatacataggaaaaacWgctgttatWHaggatcgtggcat
+aagaaaWtttgatcaagaDatgaWtRtttgMagcBattcNaatNcKgaatatWBBcttKV
+HtgcagtagaYRatcggaagaRtattaBNttattaataatatgtttttaagMggggMttc
+tBgtcgaaMctcctaVttRtBattaatattgVDcDtggtgaccBaNttDWaVtaaaaact
+HcaVtacKMtgaataacggHtaaaatatataYtacBcattttSaaSttgatcatccacat
+atgcYaVcattatcaagacYcMaataagaWWcBataBattcBtaKatgtaRgtKgattaS
+ttYaHcgttHcacaatatKatgRMgatgatgRaattctKNMRtggatNttttagYRtgtg
+YttaataaDcttHaDcctttgggMtcgcMgNYtcNacttKtttttgYBaHMgcccgggtW
+ttatVttttMtVgaHagDNtccBVaaagtaKttaaacgaYgHagVatMgaacBaSacNaa
+aBcagaaaatatttaYgaaSccaRacgctgtYcctttStttaacgatVWaatKtaBtaaa
+taVaBVcctgKaatcaggaDYatgVcgctaaacVtcHctggttaDggtatRatttttaaa
+tDttaMtMaggtMaattaRcaaggaatVaaaactSRctatttWaDtBataaBaaKattSc
+SVgtatcWaaaBtattVtatttttatYtaatacRKcgcgYtccaacVBtagcttYBtgtg
+ttaataataWactatataaVccaNtcaBtttcMagataatgactMBatBctaaRtatata
+aaaaaRacagtatYgtHgcaDgaHtaaNMMStKtDgtaaaaactgtaaccBttMaaMDVa
+aaggaVatcScMRMaBttctSgacKaccKcDgaWattHVtKaNcDaagRSgcgcaRgagt
+acMKtWaacRtcKKtBYgtagNtatgtttVttatcRaWtattcgtttaDccttMVtatgH
+agaBgtaMWKtcVagaagcaaaaStaaatgagaWtttDttttagNMgVttcWagacDgaM
+atataaataagtttgcctatRtttNtcttggMtggVcgaMaBMgaatDtVaDgttaaacg
+aagVtttNccaagtgHgtgtcScaataaRYaactgcVWtaNRDccSggagttattatgcc
+tMaaNcgtttVgtcaatctaccaDMtaattBaatMtKgaDcBggatVtaattRBattgcc
+catgaNtttMDcKtgcaccttccBccaatctgDgMSgaagcactctaWtattgaHgcDaa
+gVRgtaBtaaRtgtYcYttaagataaaHaHataattaattaStcttcgatHWaaRRSHct
+ggttgtccaacaDttcaKggcVcgtSBctBNaRaattcgcatagaMtNattStRSaaatt
+VtMtgttNYaatgtaHaKNSagatcaHctaaaKKgtaYatDgaaaBKSacaatacRgDct
+aSagVcagDgtYMtcatcgttcRatgaatgtcBSKtSagcttagKKccgHtBRgttStgt
+BaaKaMtaaKHBgaVaVattaatNNgcattgagtcaBaggMgctHtaatatttDatcWat
+agRatVaaattNttttaaVctYagtRaHttatttaaaVtaccgtNattataKSRcgcagM
+gaaMccagaatatMgtgNtcttNtgattaBgaaaagatWtccNtDggaaagaNttttNtt
+tSggtDcaaagagtactccattMatataHcgcHMBtgaaKHSYtctaVtaattgtacctc
+tctaaaVtatgKaWaacagttYaMtNgDYtttcYRtgYaWaaaacagataaacgtaVatN
+aaBtBattcctWaaggcacatgWtttaMtVtagatatacgataMtttggtVBagatctRa
+tKggttgcYtacSaMStattBgcatttKatKtVgcDgcttNaaataatWNtaDStRaacH
+tacttacataatacaMtYgcggcatYcactttttDtcaacBtgHttggctttHNtRcgat
+ctcactctcattMtatccgattaggtgggNgagacgttctDtHcaaatacaVaaaHttct
+cMaNtaattHWaMYgatNacKNNMatcRtNtYMgVtataaaatttaaaBMtaaaatBtaa
+acttgMataaaagBaaatBVactagaaaHtWtKRHttgaatVattctttgaNgaDDtatc
+VWtDaataaaVaaatgcaYaaggatgggcttaaRataaacttVDcattcaattgtaBcMt
+gYtBtcaMKcRNaKRtKcaatttgatWgaMagtWtgYVaRcagattacaWttgaataaaa
+WgHaagacggYccctBtWttttYVtttggatKBtVagHBgtaatgttcgaggaWtDtgat
+attaMaagttcattMtttWcgtNgcgaRcaactaMgaVHctctgcgagKRatWtggtcgt
+WaaaBctcScVcaHatattNcactttccBtDaaNtYggaattRtcggctaggNVgDcgaa
+cttMatNagaagtaaRaaRttggtaVSaagaattattcaatNttWcaWtaggattScaSt
+gattBagVBttaNcNaSagttagtcttDccctatBatHaRRttaacBYKKtattHVcHag
+StaSaatNDDatcSaVgtgMttaHttgttaataatcaYtDcatttHNaRgWtgtaYcaaB
+aagaatYaagaccKggRattttaNcgacStttaatKcVtcYtttcggcaaaSYacaKatt
+gSatHtWtKVcagatccccStaatRMaatgtaatKtcDgNaYaaBttccRaaacttHtaR
+caaagtatgtctaaBDVcKSKVatSagtggttaatcttaVNaagRtctgRataKgcaaga
+ctSKattaBatNttggttDtgcDataKaKgKacaWHgttScVaagaWtcatHagcgattc
+BBtcWaactBatgacBRctgatDcMaaVDattWaaKtRcctYVYacggaaagVNBaaaaa
+attKYaKcMatgagcatStaBtcctgaHgtttacHacgcttatgNHWatgctWWattttg
+YaaacctaacYcataVtagVagtVtNgaMagtcgttatcYtaagcatgKgaaagNSattK
+tttaaggacaBNRatttacatttHctaaaHactNcNcaaaYBcacggctcaaHagaaSaa
+gcaWtcaaaDaaBNtNacRgtttBSVtttccttaaDgcctgKSttgtcaaacNMcaBtag
+aWatttVgcRtgaRtMttgccVttatNtatggacaaagWgcacNatcaDMaWtcHgaaNa
+MMtttgcatHtYDcDactttRYtaaatMtaVaaattggtgtcaacatVctBtHctYNaca
+aactcaMaaaMcHgtaactHaaWattKttactYataagaYgcttattaWMDgStMKKata
+tDataNHMaSagBaaaVtYtgVtaNtataDRcBtagttcgVKagggatacaaSRaataaa
+tagtaataKatMattVaSatSBtagVaYccaaaYacaKSactctaaHctaaaSaaagNtt
+gactaSacDtttcattVctccagYtcNcagtWatacattNgttagagNctaYaYNttKgt
+tttatKacMgRatgaaacVccgtcaKaatHHcacRtgtgDtccatHaaaRtNgcaSagtS
+tgWKtttgBtHtSagaaacgtaSaatctacWaaattagagaDaWgtataMtgataaDaaa
+aaaaagttcBggaHaDWWcYctYtcatctttcaBtctBaattattagcatgWcacgcaaa
+aDaactRVccBtaWaatYcVVcacMatNatacctSgtWgtttaattcactaaagcHgaat
+cHatcaBtgtaWatSScMMgctatctctRaaaWMgttaKaatagBtttcttagaggVttc
+aatRattNtccatttcagctactccacMatSHtagataaaWgaagtttgDcctaagtMaa
+aYagaaattttVattRacatctgaaccataYtcaaatcaRttaStRgSacctBcaHcgtM
+cccBaagaaagaDaaattKttNtaataaMgtctYcttDgaactaKaacNgcaRccDKtca
+tgaagtactcgtgttcctBtBtgttatDtctgaactataacagtagStaaaaaatgHaaa
+caacYgtgtgHacaaattgttcSttBtVctaHaacttKtttttWatBtcccttaaVaaca
+MaagaattcaKaSNatMScRtgaaaDtSStDtHtacNtNtaHtMtNMNNcWtgctctaaW
+ttaattaNtttKtBttttttagcttcDagMNagtcKWatVMgcttBcgccttttgtBtat
+atttYtMgctaKaacttgattttatctaatRagtttggKBSatagtaVVcaattMataaS
+BtDtaBaactgSgtatcaactgHataacaDcaRtcKttatgaatcatacgcgaagNYaNg
+aaacaattatHMgYgtagatctctWttacatVgcgRcMaagttgttDaNtScgStWgtga
+caacacggVgcgaSctcactcaaaaYtDatatBtattaNgatactctaagtWtKSgYtat
+ataaaaaYagaggttaKagtcYtNtgaagtctBWgaWtaaBaattStcatgNNtttagMt
+RDtWttgctYattcVSBaMDcagatVgccatMatttatctatcgtBgcScYtaaccaaHc
+attgcagtcttMNVaactWWKcaaataNaatgHatgaatgtMStgccattacHNgVataa
+YtgaggtKttNBVtYagKacHRggYMacDatcgKtatVtWaKgtHatatMgttScgaaVH
+agaaattaNttaatatgcaaacttWgRagaaRBcNcatctaagtggatgVKaaVgNcacc
+agtatgHKgacaWatYcSacaRaMgttgcttatVcaaWcVaKaaaKaDtaaaatcgVacc
+atcgKgtDagBNKNatccgaacgtKgtYctgaKaaSKcccKgcVtttKcaaYtagcagat
+VcctVtgaMYctaccMcgDtgBaRtaaattaaagctKtaaatatatVgctgaatatctMa
+tccaattacaSYgcactWttaRacattgtNaYcaactatNNtaHttYcStactctatatc
+WSaccaVNctBtaaagataNaagtaaaaStBaaVtggttatttagDScttttMMWctagc
+aactBctcttattSatacSatttRtBataatcaaKVSttaaaaacaNattMBcaacagtt
+tcVtttatatttgtaaKBgcacattttHNNaVtWaggaDataatNaWtBataattVacWa
+aattRHtacaSgWtttataDMcttRScttttaaaaMgatacMatYccgacKMagVtWcMt
+BaaatDatatHtttDtaattHaatctaHgcgtaagRgWaccattgaStttattctattcV
+acctccBcgttaNaacagNWtagtaNgtctgaHaacBgtatgMcRVatataatKNKaagt
+ttRgtaYcYcaMaaagattKgaaaaKcttgtaBHNaWNgMatcacctgcaMggScBaRgM
+MctaDaaRgctcYtaacgtgtatacttcacDaKtatgcaatMtactaHDtaaVcgaagaa
+aggVaMaatYtttttattttatMggaVYVaaatBaatMgctgWctaagKtctgBtKacaa
+taYtgctBgKgaMtgtgataBagttMaagRcccVtSNtaWcgVDctcaSSttKaaaaVaD
+ctacYatctcHHDtgattaaccttttYatattcgaaHBagWgYtSgcMtMtagaHactaS
+gBgBSatHtDttagaacSatcccaYtatttgtgKcgDcRatctccNtaagctagBVWaBa
+aMHacaHctDVaWgtaBtaaStVtDYtatacttgttcttggNYtatWBSNcagatttgBt
+cVaacVtRgtYaatctatSatagttDatgttgtKagtctagKHtcttttaccattcccct
+aaaaSatttaDgBactaMttctVcaacVgtaSYcttgYaaKaggtaWttgaaaYgagata
+atgccMgSHatHtacaaMatHDttcaagtaMatgtaagtgtaggtDtacStVaHcaacta
+tgagttatataaBHagggccHagtaaagcRgcttagYaaaaaagttaaattatYNtYcta
+gtttaacBataaWactVtRtaatgtHatctagacatttaKagStttgttttaaagtDttM
+tgMKgcgttaactaVttHcatccgctaaaaDttSMccttNaaccattacaBcHctVcttc
+tYtaaSSctVtRVattaaagtHtaBgttcatacRcctKctHVHgttKtcatctatagNSa
+acHVatcVgRtgtaaaRatYtcgggtBtgcKacttgataRttDattatcMaggcWWRttc
+cgaHttNtacYtYactgtatWaaWtaaggtacaDacaDgttStgcttatctattatgttg
+StaaDaaattagttRgtgcBgRDtaWaggMaaVttVRtcBttatcgttBDgVgatttKga
+aaMttatatgattataWctcWMgaHgaattMDatgVagtgatatcaNcaaaataSttatt
+ttaaatDgtaNDNggaaacgataatttaRaaatataaaVaagttacDtgtggttctatRa
+tgcBtaVatVtMtaYtttaaYgaHttgttgagctacttaatatBHtctttaagtcaHaWY
+tKttacttgtttatagacataMgttgcaBVcttMacttYcHcNaDatNttagatcagaat
+cttatcatHaNtatcMagYaacacMcaatacaNRatDtaHDHtSYgaatcRaBtKttgaM
+KgcDgtacgtgYatHcggatactDDctaVRgtgctttRtatgtaaaccagtttacVtatt
+tBcatcRaaYgcaMaagaacSctHRtctaWatatacgtattKaNagtagatataaWKcgg
+gacgaRWttNacaaaaagaaatgatacDaaaaMataKacatVgcgVcgcNacaaHNatta
+ggaacattYtcRYtggtatccBatcaccgacaccagaaagMgataacHRgttKctDaggM
+aKtaaatttScBtcagKBgYtaRKttagttttcBaaHYatgattaaDaDVacaagKaaRY
+attaMaaagVatattKactatcttDacHaDaatBcactattKtKtRHggtaSctaaaaag
+tttaggBScaatcgMStttaatKacaVBSattaKaaagacacaaagtaattWactttacW
+aaBgYtMcMccagRtacaatatcttatBacgNagaRtctHgaKtMgaattcKYaaMacgc
+aatctcNgYgtYRaHagYtcVgaagaacacKgaRaacgBtttagDcgaWgaYtKataaDc
+aBatttccgaaaacaRRBaVtRtgHacttHgagtMttWattMtBtgDaNtgKtaaKDccK
+gctaMRtaNacattacWcttacBacgRtRttaYggcKNattagtgactttcKHNcWBYag
+ttgataaYagaWaSMttgataatctataatRtggaKtcactWaataatYgtgcHgYKtta
+aaacNcaSatgcggacaBaRattttcgacctHtaKYgttaaactataRaaSactKatSgg
+atgtKYtatctYggcMtactatgtgaWtttctgYDttggtBtcHBctactacBcVacaag
+tgaatSttcHttttttatRYYaccagatctgatgacgcccVataagMaggWgYtatctgt
+gtatcWttRttcattattgYcHtgatcVatcttVSataactgtgcgtgtgaRWaacgatS
+gaNaVKaaaaMttccNtWgtVaatNtHgttgatVcttatcaaDaRScagDtaKtatttYa
+SctttctcatccttaattagttaaatactgctgNcttgctcatatatactaDtagctagR
+cataBcgccRaacaagcacaagtaHYaaatgttaaRgacNgccgctcKtacataBtWtaa
+aDagagactacaccacggaagcStHgggtcatDcKcaacctctgDVRaYaatattWttat
+tcttataatWatattaccYaagWtgaataatgatttgtatBYSaDctatRattgaatDgW
+tMacggtattttRgtaagtgWtRtagtSctVtaRgttScRcattacYYatattaRaagga
+ataagRtttBHaggtattacBHMcacKaDDagtatMaaSMacaSggtVVgacctgttaaH
+agtactaaatYtSSBgaKatcMVHcDtatgtagaVgtWtMcttctYRtgctRtgaacatD
+ctcRaggatRaaVWtgHtaMgaattaHataStgaKRaVacataDtgDRagBHttgNcNaR
+DcaaSagStDgaStattBtBNHRHacaYaatcagcatacDtattWctgcMattaMaaWgK
+ttgRKgcacNYtcatcaaKtctaNtgacatMatMgYagNtaRWtgaaatBattctaStYg
+ttcSYatcctMagtgatgcgtattKHKtNtcattcacatccDaaWattgcacMattattg
+DcttgaBgccaMNaacattctcaacgaggagctaactagattWaatgtagtcagtYtcKt
+MVSagWagataaatgtaaVtaSatcccVMttataacaVWHNataWtgccggBVYtacRgH
+atagVtctDttaccaataSaDgcggtttcKaggtaaMcatgMttaaDacaccagYgtatt
+acWgaDtaBaacctatgaWagacaYttcRHDgDgaaMtcagRtaattDtaagKtYMMaca
+gcaYacgtWtctcaNcaagttttctacVtatagttgttDgDRDtatScgatgcgagggSa
+cttcaNcVaatKtattRtWttaVagtaaMDtMaattHtagtttaSgWctcctggNgatgM
+ataNRcttatataatcVtDBHgtNaRatgctttacHtRacgYtYaBBtaScWtttMKcSt
+gRcaSgaagatNVtagctgtatVtaaagttcgWMtgtcgtHtcacSgaaWcgttaMcttW
+DWataVKcaatctattaKgtattcMttattcgtatcaaatacaDtcacatatVaatcSgt
+gDatBtgtagatgtagttataaagtctcatMNgataNgtagKcatgaagKcYgcNYtVtt
+YtaHKcattaaMagaataRWacgSactctWgtcgtaaaKaWagRaBataRSVatccYact
+tcaggtBVatKtHctatMcttctgtHttcataMgttattcttRtYttagNtVtDatattg
+catYBtggKtctatcYctDtagHKBNttYKtcWtRgtaDatgaaStgtaMagcBgaaagt
+SctRNaHcDgtttcYaacBcagaMttatRaVacgttKaaaacMttaWSgWcNRcaVgSaa
+aBatNcatttatttgYatttDgtcaatgagaYNattggagcDagagatacNtaacaWtBH
+gtatNtaggctaggcaacYBtatWctgaRttDatcgttKtaNtgaaaHaYtcgattgtgc
+caagagKatcgatatttcaDHMMttVagaKRtaKtDacYgtcBtaDMacagatHcttcag
+actcgtagaMggtKSctagKtaBYMggtagcStgNgaacaatSgattaaKWNaaYggaaa
+acgMaaattgatagagaMtacacNacacSgagcYVaattHgatDWatBtaattaaYttgD
+aacgctcRatatacVtcaMgcBtaagattgcgNtaHDgtcaaaDcYMRtgcataVgtaat
+caagaRccctYWccaacttagaagaaNgccHWaaaacacaMgatScgatgDtWaaVtata
+catggtgRNattattcaatctBcttatDaMcaaHttatacaaNcttgtttagSSatgata
+cccKttaMtcatWgaVataatatgYYtcaHaacactWHatttVYatatgDactaaggcgc
+aKcatHaccMtccHcaatgtWtctttatgWDatctgWaagHVtDggaagagtYHttBgaD
+KMctMHccDaattMatcaaBtBcagatBcatatagatttatDtNatcaaaatctgaaSNa
+agatagtVBtagctaBVNtStWBgctagtYgatHNatatgcWacWtaYtctatatgaata
+ctcattagatcgHgaRattaatDtNcaaDgactSatactgNataBYaHKaKaactctcHc
+KHRagDttgtYgtaattaactagctatatataaKcattttgcKtcaacSttgHRaagacN
+aBtatacataaaaataVWHMcaYcagcagRaagagttBttaaMtgatacSDaNtttgaag
+RtattaHtttagtatYaaatcaccgaYaatattWBtttataactMYactaaactaaattt
+cNcVatgcVgKVatatattaaatccggaaNaacacaSatgcttgcHccacatgatNtatg
+KaNtgctggagtctataHcRRScSagcactcaatataggaaYaataaagtKKaaaKtBtt
+YRtgtcNVVaaaaaatatagaNaSgattDtgacgtctMatcaaatggtSaYtttaatctt
+aagcKataaMDaMctgtYcDtgaattRctgHaatgttggtcttcaataWacaaYaNtacH
+NtVWagcHWtBBYagSagcaaatcKgataaSgDHataaacattKBttWagtRtcNagHct
+taatBccgaaatVacggStctaKaRaVtgcaHBcgKVcattttHgctttgtgacgaBttt
+tccatccMatRcaVataattKattaaaagDatVttaSRMggtacttKHaacaatgagRaW
+cgDtaggcataBaVgttNBcgtagSttgccYtacWcgagNaatttgctagagacatacaa
+ggataacWRtcDaacSDStcaRtcDcaaaHgtatcaDRtgcagtDtacBtatDMagtatc
+ctagtgcDaSaaRtcaRactHgaaatccaRtWgaacttattaataScaDaatYaaaWaRN
+cagtaaaYcaHttBctaattctNggBYBtggaacaDaatKgcagataHtgtcKaWctaVt
+NWYBgttttgtHScaBctRccataataMaaacatgaatatNatgagtWgatggattgaNt
+tataHcSKttgtatcatBtDtaWatcaWaDNgtagctaaaWttBatDgMatgagatctKt
+taHactataSgattRataYaYatagaatDagtaDaagatcKcYgtgWSgtttttaYKtSa
+tttgYatgYHStattaKcttatNNSataaaacHBtaKgcataggYtacgtttccaaVtaV
+aHDcaWRYSBHattattcaaaaBatataaggaBtaacaYcgHgaatgcggYHagtactNa
+gaaatttttacgaBcaaBttgagtKtYHaKKgttgaacgacacgBtWDtSttgNHDMgaa
+aaattcKcatgataMKttVHVBacataKaatcggWtaccagMtttcKgScgcaactattV
+ctHScccaacccHDtgttacgttHVaatcVgMtgttcatBWBttDaaactattcttaaac
+taYtRtgtaWataWggacVgtggWtatgtataaaHNctRgRtattaagtcgHgWStttaW
+DacacatcaHatttVacttagcgtHagagttgttcatcatgcaHcgtcKaagaRRacaat
+NgtYDtatVgYccaYKVttDttBctYcttaWtatgYtaVttttacVatBaYKSSVaNNcc
+gctgctBtcaagcacaNttctataYMatccWacBcgVaaatagWgccRtHMttHgBactt
+YScaaVtgSgttacBtctBttaRtSMgttaatNaRatgttgtcatVtaaYgVgcVaaYSa
+NcagcttatNtacgatagtcgaVtaacYVaMttggataaagatStcaNtDttgcBacata
+ttaDWatDatcaatatNttagttMttcaactacaRHYtcggaacVHtaggatDggStgSW
+tVatagctgtttaagBcccgBtgcgtctacYaBatactYMttHttVttaWtSttgKtctt
+cgtgacctaDtttMYMtaaaaaattcaMgWatBtgWWtaScccttaaVVgatagaRtYat
+aatttgKaVHtgcataYtaaaaagStcaRaMaattWgcaacaaRaBaataacaMNataga
+tattatgWtagcgVHcgtcatgaHgtRatcctgtcSaaatWgtatcHBcatcatcHaatt
+attDBHggcatBtgttagNDggtcRttaataVtctttStaaggtcccBtccaBgBRgaDa
+atttgtttgcNtatBgaaaggcgNttatMtggtBgMgatactDtcatMaaWctatttaaa
+acYNgtSgMatBcSactaKYaDVaVtcagaaaStagttYRcaaKacaHaacagctNcatt
+tKtttaaacWtMNaatttattaaVgaMStMcagctaWgaSccatNatgMacataWaaMta
+taggcgtatcctagHatttttVaattttSBttScgtBSatgaHcaacgaVtMaaaactKH
+atatttNWtttataWtaatVttKaKMggatcMaaattattMgatttgtatRtaVgaaDta
+cacRtaaaaaMttScaggRttgtcttSatYWtVMactagatVaMaaaDtaattttaBWca
+taaggaatBtRgtctaWDtagWtaaWYSaHaaacgatRcttgcatcattaSDBBKttttc
+taYSaactcgYacatttBaattKaaaccaMStaHatHtatgtctKcWataactctcVNYt
+ttMttaDatSacDKcacaaHgaggaaBtgNaaaHtattgtRcgacDtYtctttMttatcD
+aNgattagtttYtaattBMtaggtacatgtYBNttcMacaagaaaaaKgaaatcacaNtt
+gtttttagDBcMgtaNacSatcWBWtataVatYagtttccatatHtttDtcgtggBggcK
+acaBWtBcaattgMatcttaVaacVYgMgttDcaaactctctcgcHaSatYVHRaaatcc
+MMtaDHtaaKccactgattatccatBYVDacgttMctaaVtatacaatBgaagttaattt
+tgatatgcatKgaYttHtatggaaaatcaDtttBtatgccacattactcaaagctctcBK
+caagcaatataNtattcVtcataacMHgtattaaDtctNaNttYWcWtaVatatataWgt
+aWtgaHtattcgagtMVaHDHtatgcttctaaWYaatttaatccaMactKtcgtDaDVWt
+taccVtacYBgDattKtHKSVStgMtBgcgtDRSatggatatDKacataWtatWaVttct
+SRWgtcaWattKaaYWtYaHctataKacMaagtctRttaatcgtgaHaggYWtcgatKtt
+KaccttacttccgtttHcgtKtcttaatSBgaatttcVKaMattVSgDDcaattcagtca
+taccBccgtgaVtaggttYgaNagYcHatMYaattDgtttaaMagRactHattgatttaa
+SKtSccggBattatatKDacaacBgVWBaaacaagattgtcDtcttBgcattatcaaaac
+agNtaaDgtggVaacYDgtttDtggKccttaaaWcacgSatacaggtagVgatacctBtt
+caattKRtctaMgSattgtacctatataaaMgVtctYMYYcacttRaBgDctRtttaRHg
+cRSMVaaaaacagaYaagtaMatDaatttaggcctNaacgaaaatgNtttaBtMtScVtV
+tSacStaBggtggtKtRcatagHattcctggaRtaaKaBKtagttgaattgtatttMcat
+gcttDaWYtaVtNDgatKtHaaattaattaaStaagWaaBtNcaccaatRcacttgtttt
+caaattctggcccttttBgHccatcgaWctataSttBgataacagtacggcccDcScaac
+tgattttaSWYtaaaMaVatttagctaBgSaggtNaBRgStDaatDBtatcHgDtRtgMt
+StWaYaggtaYatBtaWaattgaaYattcBVtaVSactWaWgtKaatagaaatgNttHtg
+tcaatMattcggtcaDcVttgataMNttYVgSSYMWaVtgcaRaaccYtgccattaaHVg
+aaaattMtaSgtaYaggctataBtcRtttaaBtcHDatDgtaaVttgcagNcatWggNtg
+RMaDcYgYttacWNtgcaWtaaVaNctVacaaccRcacttgMttgtRMtgtccatttgKa
+gttctVagcttccaccaNgtgcatRgtSBaacggaattttttNagtDcagaHaaaatStc
+aMtctagcacactHWtNtgctcgtNaWatataKcMcWtagaggDaVatttaatttYSDgR
+ccWattHtaggctaccDMctacVaattBYtDacaYctWaHaaHttcggaMKaacSagtat
+taaatDttNaVNtacgVttKaaHtgagttWcKtgtaDcDaKacgtactctttacatSgta
+gtaHHtgaaatRtttagttMctacKgaKaatBttataKWMcggtttatgtgtgaStaaga
+aRttaVtgttBaHgNtggaRaWataacaWtRWacaactcgHWttttaDagScKgtgSagt
+cMgaRgttacccaaaKRaaatattcKatttNgtMaVcataccaKgaWgHBWagctaagtt
+atcDaRVVtggaaHSVacggttaHaWWagtSgctctVattKctKtMatHWcgccttaYta
+gtaKDaVcHtctgHagatcaSacaatKtatgatagDgtcgttttgatVtatStctYaYNt
+gtgKaKaVcVNgaattWccgattcttgaMaRattRgcaatHctcattaBaaMtattNSSt
+tHcagRKRaaccaYacMDtaYaaaatttRataBVtcacaagKtatgcctcatcgtgWata
+agcgtatcDtNagcatNNatgttcRaaScagaaaRaataMtacMSctKtDgaBactaggt
+WgcRtaWcaYtgtgWaagDKattttttaaccaaatDHattgacSttttatWaataatDaD
+aaaaRtaYaggagcYatacYaKaagaaNtaaaYtaVtDtBaaDcgtttKMtggcagtVat
+gccggtHgtgtaVaacDBaattacaNatttMgaDgcaDtttggaaMgtYtDtSgccaaaa
+YcNgaacDVgcattaNgatgaaDaBBttgccatttRtctaatgtHNtaaatBtaMaVatt
+cctggaaaaatMattgtagRDacaaacgaataWSBctctYVcgtSaMStgtttSatNaga
+acaRcagtatgaNBtcKgBttRtattVtaBtBaKactaWaMgRtcMtaDtYtatHattSc
+ggacMtaggcataaWaKHaataaagYcgWatatStBattKaKagKttacMaRacaSaRaa
+WtKaatagSatcgaaaKaaVcDttcVcgaKVattggaYgtMataaacRtaDaactNatYc
+agtDgttagacBataRYRDgttcttttattacBcHatgaRacMaactcatVVtttaaaHg
+ctgttcaattaVaHtDcaYKacgKtcNtttgctttgHWcaaSactWKSatcgYaNVaatt
+acRcatVNgtagatgcatYatVaaYWaSactgatccatatNMaNagNtaatcgttaStta
+ttWattaggagaatcNaaccaaaWatRaatHMaattaNWatRaMKaWctWtDataaagHc
+tMctttRSttaacgaSWcatcaVgatataattgtWMagKKaBBgatatctcgHSaaNBct
+gVtaStagtttgaggSgagcKttaaatHattDtaaattgaacatactaaWaBYtKttacW
+taaVNcWacgttctcctaactBaaSRagaaatgttKVgtHacatctcaScaataNgaaVa
+gaaHttaKgHgKaccgtcYtcctBccataagaSacataaaggtttDtVStaVBgtcgNat
+gtgaVctatWaaDccWHcctttaatcWactaatactcttacttgttcttatttatcaaag
+atWacYctacKtaSaaaStgtWaVcaYaRctgggtSaaaWtgctgcHtttgMcgatSaag
+ttgttttNattgaacttaaKaYcSBSacWattaataKDattKaHtgaaattKKttttgac
+DtDtattttDBDDcMgcatagaVNttaWtgaDttgttttttttgacattatagBDacgat
+NatMBcaggtacaatgtgctttatatttRgBcctVtYVctgcatgtgatataatHagttt
+ccttHatagtaMMaaWggBataaKtttgataaagcKgtVtaaaatgtatWWaataaHgat
+ttYtcWataataacagaacDRWDgWaWaaaggattBcRctacYtagctNgtScagMcccH
+aBaYgtgctgtSDtHacKtNgtgacaaaacccMcacaKctcactaaaaaNgtagWtttYt
+gaDcatWctataVctNttKgRtatataYaaaRacaggttatagtcRgDgcaYctattNca
+NtVatYattKgaaggBDtttacttHttNtgcatRatgaMHtRBtaagatMcacatBatgt
+StctagacttccKaRgaWccRataVtggaScgatttDMaaatNNtcYaYtaDaatctatg
+aVtctBKtgccYgtWatDcMYtaaRtcVgcttttDtMtRagtactHccRBWatatcctta
+tMtNatgttagagBcttKacaaMtagaaattaDttaatatgaaaRattNcHSgaaHtaDc
+agctYacgccagcMtaaMgDaaaaaggatcttcaaVNatRcKVaaHRBctgcattatMaW
+aNaKataaatatgWaaatcgMaaaatcctgttactDtDagaccYWacttctRatgataaK
+taaatcaMttttcaaRtScaWgatMactMtcaBNataaaBactggtWHtYaattaWacat
+tgaaVtYtSgMcatgaatYgattatacaYttaaaKRgaVagNgtaHWaattcgDaRaaac
+gVtBDtStttRaKgVagatatWtcMKaaaaMDatttaaYcataDYagtaaaaKttVWMgg
+ctgVgtgagtKagtgtBBNctacaaacttagattSttHagacKVttgHttatSataaWtM
+HttSaSaaaaDatgBtaYaaaggttaMttgVtVtttctaattgaacaggtttDDVMtNSg
+catataagDaNttatSVttMScNaaattDttYaaHcNgttatatBatgDKctttgVVaaB
+gataaBatRaagactBYgMgNaBttaaattagatttttttaVgttaYtatVtccgtaagD
+cNVcaWtgcaKgggYtgagattaMaaagaatagtgaBaVcacBNtagtaDctctcVtaSc
+tgtagcBcHMWtataattDtaactttHctaRcRaaBaYacatttcVRaatctgctattDS
+NDgBatcaaatgcaBccKctaHcBtctVtaaHgatcRgaacggctRtaagtaSatatgat
+caaagBtaagatttVaMagaagaWWgcMWBRStRggtttWttttagtccaMRMaaattaS
+gBccggNataagtgctctttacYataRtcattgtgYBtggcatRtacttBaacDacaKtH
+DtaNacMtataaKKtgtaaaRMVtctVcRatcgatttgcattSaaaggttRatagtagaa
+ttVcNgRtKccBgBtWcataataKctctKatttttgVcaacKStcacSRtattgcggtcc
+tcHatcgaaDgaVgctagtMNVtaattaaatattMYNcgattaaKtMttRtYgacttgtt
+agggcDNgagNtKBaScagttctgcMaaaMtHctRaYtcgRtHatVctttatcttggtYc
+tctYgttgattttaacSttaaactaaaWHattgWtctactatttcgMcVaaMctaKRctt
+cRaatSgctVNgtgaaaNcagataatcaatcKtagtgacaaBVtttgtaaVctaBatgta
+agtgtacctttacKtMWtaaaatWtcVctgagataattacggaatacgSaWgaHcagtag
+NWaaaSacggaaatgatRBtRctVctgtVaatataVNactMgDtaatggtatctacaaat
+gtatacKtttgttttaaacgttgBggBtgacttWacgaMtttcagaacagaaRVtttKBa
+cttDWaccagtaaatatcgMcttatRtaaKKcgMtHKattWYYgttgatgttaRgacHca
+ttcttKtcgtttaatagagWgDKaYatKataKcDgctaaaHWgRtagccgttcatYattc
+agSHtttattataBVccaNMHttacgWttgDgaaRtRaatcgatNaaNtWVcctacatac
+YtctgKtcattatctattatcgtcKtaataaattagggHctcatgHttSNacctYaKttM
+HtctttSgacgtttgMcStgttcaaSBggataggWttataNagaNBcatcaagtBtagcM
+agtcagagaaDcaaaataKgtatgtgSaagtgtYDtDccVaaacagaagttaHSWataga
+aaMYaggtacttctccttatatHatgctgVMatKttgaNtggSaRcattggttgWcatYa
+gtaatatttgcttgaVctaataMRttttScggggtgagVcacatYBggtccatMattBaa
+tgNataDatWtDttVcataacSVtattagaagtaDtatcBacNaacaaBaaagaaWBHSt
+tgattttKRcVataHatttttgaBtcctctacctcRYttagcatactttagaMHgtcatg
+tHtatctaaYacacggtaaMtatgttaagaHWaRcaaBaacaVaKattHgataNatatac
+gtatttaDWctagatataaNtaccgaacaDMttDSaSYaaYgYaVtcatactaaWWtata
+taaVtMcagMccaDaaSatBattagcaaaatgRtaHRgccgataatagcaaacacWacag
+aaVgBcagaYctHctgtcttaccBattVaYtttHatgaVgttcRgaHtttagttttataa
+tRWggattYatatMaaaactWaDRaggataaWgMataggtactatatttVctataattaa
+atatgtgttDtcctaKataaaaacggtacgtKaaatccBKtgtaattacaKtKYtgStRa
+agaaaaaaaggYagtNactttaaNaStcNtBcBaaacHtacaatSgattYttaacDacaH
+tcttcatttgSYgtctRaatVagcaWtctcDcRctNHatScRtaMgaacWaaYatcaHaa
+agttggagtacaNcSRttagaatcatVgtgaccaaYacWHHtaMtHtctaatttcactBt
+gNVggBgttctaDtcttaWttaatcatatHgaDacatgaaNagtaatacgDgHttaNgga
+tDaggactcaatttcttDaNtRagttgVgaVRacWNVHBttcVtYYtagataagHtccat
+tcaatNaataYtNctgatcRttgaYaaaBcaKatcacgSaataHatggtacacctttatR
+cgtaYacgataHWVKaattVtKcgatcgtRtatagRgccBtaatagctcVNtttatgRtg
+gggtttcttatactaatcMaaaWcgcaatKttatttgtttatHRRacaVcSgatcagcaa
+cccaMatYacBVccNcRgagatctgtSgaMttHgtaattatggRatgcWtcKatattMKW
+taaatctccgtgtcaHNYaagStKcaDaMtaaaWBttacBgNctMaatDttcttgatMag
+tagaaatYHKaacttattSgttNaKagttctcataagtaatgactgaVStaatcctcDag
+tcataagWtataatattacagScHaatatagcaHYaaSagaaaaactYtRYaatcggaaH
+cVcDcaccctattRaatattNgVaatacagaataaSaaaagcWRgaKttccgtaWttcta
+aWacgatctMHaNWSgVtgNttVgtattStaatNatVttacaRWagNgcaSgRVtcYtgt
+ctYgtRKatctStHWttcYagtgNtBaacgtagtgtHcgaSggcNgHgWggKatMtaHcg
+tKaHaWggacRRatattaHaaggaagaSgHggtttacctagtaattBaaatSttYgtagB
+aSKBaaSKgctMMcacagcgtYatSctWctSaatRtKKtgatatctMtattagcgagaMc
+tNtBcgtatRDtcatHtgaVcYttctaHacgagDaaMNtcttaBgWattatagaKtcWtH
+aMacagattgtHacttttgDaBWDtcSWKacKttcaHtSgttttDtHtSaVRYVgcagaa
+tWattYtgNcgccBSttataaNctttcHtccaaDRgaataSatgctVDggacagBYtBcR
+acDtYDNtgWaattattatYKtNcggaKRatcagBactgatgcctSttttttDtcSgtca
+aataataaMVttgaacBagtattctatggYtcaaatDWacVtgataYYacSccVcataaa
+gacagtNaatgtactaagtRtattBMKacNacagaaWtctSaMgaKataaaMBgtYtaWa
+aKNtDStSNggaacgtMRtaaHctatacMtattttaccaataKVtcagctttatacgtSW
+BaStgttgWVtYaacaacRgtSgtacNgatgRtaYcagStcaNScaaaRttaDttctcaa
+BgcScDtWaggtgaacttNBBYaaccaNaactNgctaaDaaaggttgagaaMtatacttg
+tgtctHtgagKacagcacagcgKSattaSDaKaatttagtHtMttaMVctaaBtgBaatt
+ttactttaKcMagcatgcDcatcBagaBHattVgWtaataMgtttgtDaHaggctgtVat
+tDYacNtNStttaKaNggtBtaKtgHaaKcaacatDMtagatgtatMtaaacttccNBgc
+tacgtgcaaKgWSNacttSBaggMtNStaKtcaatagattatctagtaBttaggactYta
+aaStaaYtgaaaagYtMaagaKctgtVtttcgWcatctacgtatVaagtagaattBcaga
+DcgSgtaSggaactaRcaBRtMttRgattaattWaBYcaataHMacgHactatNctacga
+VataNVcHatatVHKKagaaRSattaacgttMattgtatagBagtatctttgaagaBctg
+attattHgRttacDgMgtWtaggcaatNttgcttagagaRatttSgtttBtgRtgaNtHc
+gStatgaaKtgtaBacctgaaWgtKatHDStatctttaRaaataacaBttStHVMaccgg
+taVYaaBttYNKgNaBHaaKcKaaatStBcattgagggcRSttttctaaatcacaRBatt
+ccacatagacatSaDtaaaSNtttgtatDgWgcatacgaSacRttagNaggaHtttagcc
+ttttWDtcYaVtaRtacWggctcaaaacVctWtacatagttaattBBttMacatDtattt
+aaRggattatBVcacattattaagWctactVcaBgcttKagagttatRBgctagaHtgDg
+aaaSVtKgattaWtMDWaRccaaWaagtaaVttgWgVgacaBtSaacDaaaaKcacaRKa
+agttgagtNatttaSttaWRgtctaaccataDatagYaMgaWBcattaacSttcacDtSt
+tgtaWYataRBHtccagaMctaagaWagSDaactRNaaaWagtacaScaSDcaatMaaaa
+aaaVBcatKacaggtgMaaMtatVaVgcctcDDYgtattcaatattaggagtYBaaattt
+agaaVWDattcgttagHKSgcWtWcaatttaBtaatNcaMYgYagatcRRtcataaaYct
+NtatttKRatRggtYcgaWcgcccataWttVaaBtaataaatcgNtctttaggNtatatg
+NaagtMttccaagactRttgtgattBagBtaataattBStcaatttaWcattaatVtaca
+tgtatttBataVYWStagcaYKDaagYtaggKtgagatVtMDtKgNtcatagtNcagtBa
+gagcaNaaNtaRtagatatcYWtSataWggacagagtcaDSggYatttDaaatcactKat
+WatcDatatRattataaatatctattHSctttggNctaagtSacgagatatatatRataa
+gtttcatgcSaaKttctHaRgaaDatgStWcataaaaatWMNttaaRaVgaYcHaagWgg
+ttttaaBtcagacKtaBtggcaacHtaggVttttactatRWaataVcccaRaagattNtt
+ggStYaatBRaataVacgaaatttaBaMYgcaMgtKStStVtgVaatacccYaDVYaVaY
+KVtgatgcctacaaagcWgDtVtctaBtcctccacgatatWtcDHHaHacaaataaatat
+accaYRSataVagtttaaStgttgRHtctaDMMaYYaaagatacaBWKcagttgcaacga
+gBagcaaatccgKaRgtgaatcgtaWcatYtWaBtaBatcgRattcaagtHctctaatct
+tcctattaaYgaNaaaaRaDtactDtMNagatMtttRacKaccWaYtatcagaaKcttVt
+VaaaatgttgtNYgtHtaDactaggaRttaccVaagMacgcKtatataHaMtcaattcct
+MaRtttttcatgtctcaacatggtgacatcaBatHaaMagaatttattaaaactYgMtta
+KHBccgacttttaVaaVtcScHaNccttacccatataMgggDtactagKgtcacRtacMa
+cYgBaatttcagYcacaaataaaaggagYaaMHtataaaHtKgaaHtctcaVatcgStca
+tHtcaYctttWcttattBactataatWctcctRKaaHtaaHYcttcaYataaaHtNcaSc
+tgattaagaKaatWagRaVaNSHDaactaYVRaatgttatVYttatDcctRtgcgaacSt
+aWttgaYcatYtggtatWNataMtDNRtgtttgggtHcWtatHaaataatVtaaWaVgca
+atagDatgScgNcagggagtcaDtgagataKtgtctataattgtgaNatcaNatDgtagc
+taaaNtgtagtcBatgWcagagtgtWtaagWtaKgattHagWRaNatacaagtactYtaW
+gatataRctcNKcttttgaRtgKWtgtgRagcNtKtYtgatatgatBDKVtaaaaatttW
+tcaatacgRtaactttaaaaMtaMattaVNHRKttattattaaVaatagatYaggattVa
+aaRactcaagccccRtagtScgDWgVSagtggtaacataVatttcagtttRtattcttcY
+accaaaagttNttKtggBttBcSaWaattataatcataBtgtMtMtaaagataYtacgMt
+WaaacBtttatcKacaaaatattMagtKccaaWccatttgtgacctttMSataMgBtctt
+aVgtNttttSaactatgaggaSWataRtHtcgaMagSMccSaMctcgNtatgtataaVtB
+atHcHtattaacgactgNKtttaMtVaaaagaatVgttMWcttacacgtacScttcttcW
+taatccatactctaacaHHaaaatDctNtgatMcRaaWRtMgttgttatRagtaNtatgR
+taMttggaaKWttaRtHKMaDDaacatgcgttaaaccaaaDttatagVRBatacMaatac
+MaaatWcNcaaHttBgttgtacggRKaaaMtcHgttaattattttaHgKtgttaatDaHa
+tctggtaatMtYaRgMccKRaRKaDaagaggatBtSacatactccaKgVaaRMaBttgca
+taaacYtKgaVDtttgcatSaatattatNattataWatWgBttaggtBttaaYataaSHt
+RtaccaacMttaccattccKggKNtMatacctctgtaYctaaccttgagtataaRataga
+atRBtttttMtgWNtKtgcttatgactcSaatattgtBRBtSWVWYagtaWBcNatttcN
+NgSKacctgaaMKgatWcYHgRataYggtctaMtggcagaRgaaYaYgKgaaHVtaattM
+gaaWaWaDataagaaaaBDatacatatgatcNtagagMtactcatgatgtHataaggtaH
+aWatMgtagcttaWtcStataSttagttttgcaagtgctgacDtgctcDtgaSgVMtagt
+tKtaacgtacattaaatctHgatYatttcgggcaDtVttcaaacccgDgtatBggcttcB
+cWtacttgaatBaRNcgYtgtaaaaaRDctKctagtaKSatRtRatMaMtaacVYaKtac
+tgRDcaataaatSacagctDaatggttttaaacNttBaattgattaaMgVBKtBaacctY
+NcaKcaVtDYtcBaaataNSaBgatacccgtVtaatactSgtttgMSYtttgKtgtKacg
+tKatgataaVccaMgtaVaWatttatattgBNtgtVgVNtYStMtgtatBcgagaBaVat
+gatgBcStttgtagDgYMgaattacacHtaaaaaBttKaaggHttctaggKagRNtMBaa
+tWcagMSBaaVtgaatgtgatNaatSagcaatttHctatWMtgVcNtSaNRHatVaVacV
+tHattcaataatgSKttttttgtataRKYaatccRYaatggtaVtttaaaaaWBKtatat
+ttatgtagtcNatSaatatcMDRtgtBttYtatKaattaaaaYtcWccVattcDaaatga
+ttgtHccactgNgctttBtgagatWDgVgtactgtRtaaggtBgacctaaatctRtDtta
+BRaYacaaaYYtcaaagaWaSDttctttggacttcBcgaDacHataNtNgWtVMVtRact
+ggaaagSgtgggtgaggcctccataaatNttaYYgtcBatattWMaacMRctcgttaaaV
+atatagagataKatRMtHaVagaaBBtStttaatcaaatgagtatcaagtRMtaccgtBa
+gaWKtagaaaYttcSScttaVttttcatatcaSgtcWNgtttagccaaaVgaatgtgtta
+tgaaYaatgaataaaagagatcttcYacaaatataDgRttcMtcataYaBtctStgaatg
+agDaDgtRNaMtYMatatagWNggaNtcattatgacYgtBKYttttagccttataaNRaa
+tggaatccaBacgttacttatMNggaaaMtaaRtctagtttttKKKgcBttgccgtHKat
+cgatVtttacataMtagNaMttctKHNctaaNatttWaRNgRatctagatSctaactctD
+ttaagacgcatagcRNgagatttgtacattSattaacttttcgttgattWatKtgaattt
+aMtSBattKKcttaaSggcactaataaatcactcaMgacggtRcaDScNctYtBRYVgtt
+gtttaVtacHWattattcatttVaKtgKaacctaggStatttacaactcKNtaaacaagS
+ttcgattatttcaRttVtaVaaacRgDtaatgtccMaacNtcggttgcctaattaaaNaW
+cgKataaYcctSgMcataaatttgaaatttHtagSBgKYggcgYaagagataaWBcMgat
+RBNRaYctgHatctatHttgaHtgcHKBKVaWaacacWNRactWBVttaatttVccaagB
+SWacaaaatcDgttattBtHaMtMtHacKgWtcctcctttHaatagtYttaagccaHtYa
+tatttacgtcaSgtgtYttgBcatcatttaNRgaKgBtgattttaaatgaattVaKtVYg
+NaatgDaacaaVtHaaatggtttgaYYatgctgcacatttttctacVtacaNatataHtg
+tcVtaacVgtYccgaactaKaaaatcagtttaKNRtaaataMatgtacatatcKScctDa
+tDcKttSattttagatgttHtcBtKgNVRagctaRVtttaNYWttcWYRatgatMgaMKR
+ctNVMgttVagWcaVStcDgtttctcRatBVggaccgaatcMttgagaBDgtNMgKKRBN
+SMgcaWHYWccNgcacaggVYtMcaaaatgBtaKcgaRacccgStattcHttgaYttatt
+attctaVMttgaacDaWtNccDtcHBataNcRggaaNBtgaYNtaaMaDctMaaaaaaHa
+aattcBgtcgHtgcgaaStttctacttcgMagagtaaaacaDctgcagHctHtWaacgaa
+tgtggtDacgtcacataSaatKtcWBtataccaaScttNgDgcctacgBaNWtagataBa
+NtRcSggtaMattgaatgtRHtgHaaNWtgttaccatacctBataaMWatttNttVaaRa
+gMataVtgtaccattYVcKYcgagtaaYtttgDaKDgVacMtttaVttcYcgtMattcta
+tatataaggaagagttaaatHgtWctatttgaaatHttgScgtBataatgatRWgtttVg
+atMBcgctttatgtctgWKtaacaaHttaMtctttatcDtccaHaNYtSWcWNtHNacaa
+atactNggtgStacKatgtgKVctaBcaHcttaccaaWatHaaYtattatYtttDgtBaK
+cataaaatcaNgttNYcatVSgtgatatYDMMtggaatKMaagcttVtaNNYctKcctag
+MWtttatttBattNagccggaRgagtattaKatgatctacatcaKVaaagttYgcStagt
+ctacttttcatKtWtKtctRaRDtcggtataMcMDcaattNcacattattgaBaHattHg
+cYattagaattataaBtattBKHtgtaacHtHaacaaRYaBttaRVSaagttHVtatMtc
+acaWctgVtgaatcVtcctcNataacacgWtattDWccatDDYtcgtaHaaKaacaYaHa
+ataBtaaBKagtttcStWataccgNcaDtWNaaRgctcNaacttatttgttaaacaaStt
+tagtgVaKgggtatNaatVagtataVVaHtaRaccacaRatacNStaacaYDgaWaRtaK
+ttgtaatacggtttgccaaggMWtcaaccttcgctaMSaattaatgaaVDagttBcatcc
+attttccaaBggRttgKgccaaaYNcDcaSatMcaattYDcatcWatStttggaaWtttH
+tatVaggttDgVWatttaBWMagtcagcgaSaaSgtattctacHtaaSaVacaataNKta
+tagRMagtKYBKggtttKatDacaWaYDaactagcaDttctctttHtagtMtWtttatYa
+tWNaBgHtaBgSttRgattatgKcccaaBtWcccataaNattaYtRYWgRccNatatHtt
+WgttatactttacBYHaaaKaHYaNttaatagKatacaaatWSMctttcKacatMattgc
+aRctBataaVaHtataSctDVtRaacttcggScYctataHRHtgttctgtgattYatatY
+tcYHaataaataYtMMgttaaatgatcttaaattaKRtttaaRtaacttaBtgtcatgtc
+tNcaaKactMtKatagRaDKaatgSaHcRtMDctagatcaYtRatMSVRMYKYaggataa
+atYtDBaDacDtaVtacggaKttattNaggScgWcaYtaBaaacaWaNVtHVagtBaatg
+aBNagHaBtaNatNttSgaaactctBaggtHHtgaSagYKNcataaMcatagaSttctNB
+YcttattcatagagagtHWWDtctgMtRHtactgggagcKcacctggaYattatttgaaW
+gtcaVaataagaaNatRgtttacNtWYMBcNScgggataataaagtWYKDYcVWVggttt
+McttYaatagaaKaaataDcaYMVcaVtgtStctctWaagtaRtaagtaaatWacSKaaa
+tYaScctggtgMKtYMtctacDatctcaMatVtNaataaNtaattgaagaNaataataag
+cttaagtgtgcgtVgttataYaagVgNaaRctSctgWKVaYKgctNWMaaRaHatcgctH
+aaYMtccggattgtgBacatHaacttggtggDVgtcaaaggSatWRaKtKacNVggaatY
+ttatttattcaaSttttttttcaatgttatttgttttaBgcatacWKDgtYNtcYtgtct
+tttttgtcaaatgatacttWagatDatttcacctaaaaggtgagttatWgtgHctaatMt
+RKagccagcgcVgagYagtactgtactttagVctaBBaYNggtYtaattttcRtaaagat
+ctMtaVYatctYgNMaVtaWtcattgRtaNataagaaaacVSctHNtcNaMaRYcgagtt
+aHcgacNgagagBgtKaactaaatatYRcggatgtKtttactgDctcVaYaaSaacBcac
+atagaaataaaaWDctVcNtttRtcataatNagatVMctBgttcHtVgagaNaaaHaaSc
+cggatSctaHgtgaYRagattDcSDtMStNYtgtgaagcttgggaatttttDgcaatHat
+gaBttHttaacatBcaaagtaggtKgagacaattaataHcaNaaHataMtccaKagagtt
+tBYSagDDtaNaRtWtWagatSgcSKtcttttcaaRgtMattatRtYSHgaMcctttttt
+BtHactaattcaHtMatagaattVtBtDatcttVgagtatttaaaattacYSattattta
+YtagcaVSHattDctKcVattataagagRaccccWcaBtYYtctaaaaYccSgattaaaM
+DRtHatMaYtHtcgcaaggWgBaNVDatataaatWtcMYSVtacBYaaatactcgtactt
+ttWgaacRNaattctHagcYtaSttaaataatttttaaSDtKaaMcWgBaagBgaatDag
+aaatactcctNtgRaattaNWcattgYVMtRtHgBaatcaagRcagtStaaWRgtaaatH
+caMacDctatNaagtactVHaaVagMgttgKtgtHatcMacatagMgaBtSaaaBtagtt
+aaNaYgStRRctYWYVtttMNBgcctgMctcacttagtgtttDagacaYaattagaggKt
+ttacaatMttctttatKagaaNtBtttKSHWSaVtVtgttaRSaYccgtaBgggMtKttt
+ctYWttcaVaagctttttMBgDKccatagVactWDgtRtKMtgBKaDaVaggtttRaata
+BgttYtattatgttatgtcMMaatcagaatagHaacaattRcBcDatttaYWttagattg
+gttgaMcgtYRgagMtcactaRctcBMaaNgcaStgcgNtgagVttaBaaagaatacgca
+tYMaaatDtacgatatataMtYKatctScatattNgStYWgtttaYcttgtagaHaHaYt
+aRaaagttcMHaStatcatYtttKBtctataaaatcaStcatatStattatMtSatcata
+HcaWaccagHtaaggaHatatgagaaYYgtgVacSttgKaBacSYcaNNccBNtHKtHcc
+tttMttttagtaaaBHBaaattWKgtaaccDataactgatatgtaaRVtaHgaattctcR
+ttcgcatHtaagttYYctaaattttgWDacBtataatttctVaYHtMtagMaHWtagatt
+tcaVgtKaaacctgHagSgtacSWttMaBcHttaatcttMaStYatatatattagtttgg
+MaYaatHgaaaHHgatggccctactatSgacaatcVMcatactBBMtaattaaatattBN
+DacYtgYattBttHtNcaatgcggacccctDcYcDtttaKaSggtatcaBYaaBttctDS
+RgacHttagMcggtWgagtcctRatatRcttgattggaaaKggaaaagaaSNtattcNta
+taatVttgagBaMaaBctWtHatgcDaatHccgMDcgcWaaDaacWgaagcaatattact
+caaaatMgttgtaaMatatYtctRSctctWcatttVatgBNtaaYagNtaMatcSgSgaV
+ttSaccaataccKRNcataaggYcDMWaSKVcccaaaggVtHtgHagMaggtKVatVtVM
+DVatBgttWagcctagagacaaaggtataatttgcttgtSaaccttctccttcaatgNaa
+caBtttaVcaacagWaHMttgttaagttNWaaYcgaaVtatacBatgagHtSattacBgt
+tYgtNRRcttgatcttaHcaataattattttccttgaYgacVgNcttaRattatatctca
+gWWatNcDgacacgttaatRattaYcKtggtSggWgatMcaaDBttgaacNttctcaaHt
+HaagcgVtDaaDtNMcagaaatWaNtatcttcattSgatatgatactattWatSaattWc
+cgtctaatcttgKDacatRatggBttatggKgaagtttcBaKtgttaaaKtcgatagcNg
+tatVDagaDtaVtcaactttYgaBYcgaYgWgaWtaaaWatVtctVtgggKaVctcgRtt
+tacMaVaaagaaggtVtKNYtWcYaVtRVccgaattatacttatattagcatcKBatttt
+gVDggcKaHaYttgcggcNaatRactWagWgttcagtgWMctaataBHtttgHaggcctg
+acMcYaRtRtcggcaatBagttaagcDatatatNttgtMcVtaaaHMgattVgaYgtatt
+atatSaDaaaaataWacaaNttKttcatttttHaMagatYtgtttcattaatatVacgcH
+RttacaYtaagttacaBtcgaagcgttWtatVWRaaSacggWaBgSgcttaScatNaHca
+atWacaMatagttcagYBagYgVactWtgtStNatacatYgSYDtaaacSaaatBtttKa
+KRSWRcRYMgcYgVataSNNtWgVtSaMgBcactaaatYaKattVggacaWaaatgHtat
+HccacStaatagaYaaaVaMaaacYYMctcagaNattatctattaaatatgMaRgggtat
+gaMcttaHgattgtScgtgtatVatHNgcYttNatatBWaaactNVtHScgataaNcBat
+aggtaagagatttMatVtaagtaaatYgctgttttaagatagaWaaYcgctaacttaaag
+aattggtSYgtVaStttRtcKtHaVcWaYaWVSccRactDaattgWaBSKtaDgtataaR
+cttaaaatKcagtNgtaaataaatgattcatgtcKRctatHaYtMacaWNgagatcDcgD
+tatKaHgaBcaaaNWaRataYtYYacttgcactaaYDcKDttWcYataStKcgcaaaaaR
+aaNtttatttgctYatgtcVctttcBKcgtcttatSttattYMttaatcatattcatSaY
+tgWaDacgaataactctggaDccattacgSagaaattgatttaDtHacgtcMgaMHaaND
+KttgtaMgRNtacataWgttccStgaaatDaagYRtDagcatcHttcVNWWataatataa
+ccKaatWtYgcctacVaagttWtHactaRaagatatMMtYattMttccatactHgStagH
+caattaagacagaMDtttagcHtgccctttattatSatWataBaaSMaccVVgtggatgt
+gttgYgtDHSaaMaKcagaagcWacaaaBagRactKacDaDgagagagcgKcaBggtgta
+YttatgcDatgaNgatagagtBtNtaWatagcacgcgcatDRSacHttcataBtaWaNtg
+taatcDctBaSttttaggcWtBacgacaVYtRttaacttatgKcggDStacgtagaYtaa
+gtaatgacggVMKtWagcatatagtcataagMgatVagVttSaacHataatatacaatRY
+aHacaWaaactRtHRaatagcaVtcMataaacatattHaStattDcMWVtYaacYagaaH
+aaWaccNHcatgtcccgaNttataaNaacatctBtaDNKgMtcDtgMgtatgKgSatDSg
+MtgVaaHNWcDcaaKgHMtaRtggcgRgtHtVtatHgtMggaRVgtcDgtWaactactgt
+tagaKcccDctcNcgtagtgStacgtataNcgVaHHagYttStaaccWacaKctgcttta
+actagtVatttaaatKttRcgactaHttSaKtcagBBaWaacccgRatKagNagKaWtHt
+tttcWtatatttattacagacSBagDgtagtatHtgcattgcaMaRgtagatYacactYS
+BDgctgatcMattStSgattcNttaBWaacatgcttSattttctatNttaHNtSctgtcW
+ttKgttgtttttKaMHNMcaacaagNattRtcBaccatKgtVtaaDcttgattaaaatHg
+aataKYtgagMtgcWaWgtRttcDaatgRtDgcNWSgtagtatRttDcggatHWgaagta
+cgcVtcaatHtttttttgaKggaSaStaataWBMtgcaaatacgWttctagccRtaaaat
+tNWaMggataRRaaHaaMcagaaacacacgDaatctactaactDgatgtttaaDacacVa
+NgagKaBcatataaattcgRtSNaatDttKgKDgcaaactBDtaatatagWaBgagtgtY
+aaVatatMtaacaggtataacgKMtaKgcttgNMtRaaaaVcHctKctaaBcWtcHtaRa
+acKgcaDKaYaSHgtatttataaYtcaKatgNacgtcWWatgDttRaacaaDWaatDgag
+aStaVScctgcacaaBtatacttctgtctttcactacWcaaaWcactKattaKtatWagt
+tacttgBtgaBMagaattgtYYttttVatttWtcBagaatcctcWtatYcVttattMgNg
+YStaBgtttcttWtagcaggtMatgtRaaDtDKttgataDggtttatgctaataVYcStt
+BtYcatctVtBtYaVagtaaDtgagacctgaaatcNKDactgKtacgBtDKgattaaata
+gattatagactatggacgacgRgaaYKgYaRtgaaaagRgBaacatctctMttgacNaWt
+ctVagtStMaactacaatttcVgatacKctaKgcSactaDaatHgBgtHgYttaagtNYt
+RcaRgYtBaactaatatDctaacSKatSDMatWtagKtttagaaHKattaVactttSgtg
+tagWctaggagctttgaScatcggSttaggtgHtgYatgtctNtaggaaatDttcctgag
+agaHagttKcttttgcHtcaDgtcgKtatcaatgcgStVcatcaWNcgtatttHtatctg
+gaHWSataWaVttgKgtKBaaaggtaMNaatttRDtcDattaStctaaatKgtaagtcVg
+ccaHKgtgtcgaSVtaaaaHtatgaaVcatacacVtKattaWaKDgttctattgNcaaga
+acaKYaHttWcDaccattttagacttttMttaRaMtaHtacNgccgaaaaacKctNgaaa
+gagggaVttttgtBVcatttatttVaHcgattWttMaWcattagtaYcMagaatKaYtca
+tttagacttStDtcagacattctcYaaKMttcagtSNtBtMaHacYWNaactVaMgtcNg
+McVcVtgKaaataaVataacaDtaaggtcSgtDatttaKtgSNHcgctVaaaatatagac
+RaBgaNtaattVWaKtgcaattHttctaNRWtaHtttaaSgWBctVacaNVcKtaaagHD
+aaaNagtYcYKaVKtaaatBaaaSaVaMtcSgtaaacctcBYWttSgMaMccagcttRgt
+VggaaWgagtaggYctRtaaWtgtacaaMNtagtacggVcttKcaMgNaaatgtatgaSg
+DcSBRgRVcYtaDHgaVtWaaNagDtagggtHagHgctRagaNacacaStaNttMaatga
+ataaSgagBgagtgWccDtVgagcDWVctBttccaWcacgHttgtcYtttacttaatVat
+gtKtaaatttaNaYttaStMtVaStggattgtVgaMRNHtacaaNttRScRtVcgttcSc
+atMtBtttcDtcatVctDaScttagacaaDaaBtaHtacRgRgaRNtKataNgcaaScac
+tcWtKggRagtgtaaYtaaattWgNagatatYtHattWtYWatagatatttKatgtcgDa
+gaVcgKVagacagagatVgHWtaagttgcatgaKaatggattaHcaatatgKtMaWtWaY
+SVtNBDttaaHaMcaRctWScNcggtggYSttcagaattattggaaaattVccMtgggWa
+tatHMaYtaMaacaHaagVtgDtggcHtRaagtHaagVMWacaaagggataBRcaaBctt
+KtHtMgcKaVtaacaRatKRaMaRtMtcagcaataaaaVccNcttMtctattaagacacg
+agatNtatttataaaSagaaatatSccaRHKatYMacgttaWKtgttgHtgagatBBaRR
+WSacatacWtNtcWgttcaaaccactVcaSaYtaactaHgtcVWgactaNaatRgNatta
+tagacHatgcYWcttatctaagcttaatatgaaRcaDVaSaHatgaatttBDacatBttt
+HactacaNaNtataVcaVtattKgMaSaSggttggDNcgtgatactaccYHttaaaMaVc
+BSacctgatatataBgcaattaatBaHtttgtaagggataaacatgcgcaaataatatta
+aBVcaWgttagtVaaWctRgBtgYtttccgYattttYMaVMtaHatRDaatgVacaatat
+VBccgttaagactcgcaaHtVaBaaRctaVgggaacRaaaaaatYaSaccVgRaaBtgat
+aaatttcaVttataSMatacKtaWttgcaRcgtgNattatttaatagaatNctcatHtSW
+ttaVtRattcaRYtaaattDcaKagcWggaWcStaatNVgHaMaBKttaaatYRMHaRtc
+gtagMRgtattcctHtcacaaaKtaNttcaRcatRtccgatNDagaBttDHtcttggcct
+taNtattaaStaWgKtVWNaMccaVgVgtatcKacDaYcccactcattcacYtattggat
+VgaWttctgSDagaWDattctacataaaDggtactatagcNcSgagtgtMtaacNtVtcS
+tttSgNDaDYgaaWVgtactRtaNcYgataHagaDtagttggaHtgtNtcgcHYgaDttg
+RtgStatcattttKtWVaYattgNtaaYgYccHgWactgtaaaVBtaBattaMBtHtttY
+ttVgtaYMWatWgWtNaccVtgMWaSDaatcYWccaaaHtacgKagtNcMKactcgtaaa
+VtaMatttcRcttgHtattattcRaaaWaWactgDttttccttttaKVNaVggataagaa
+gWttcgBtBtVaYcataRtaacBgNaaYctggtatctacaaaagatttagttaaaaNaaa
+ttgctcaactttBKagatctgctgaMgtBttgtKaSatVgcacgaHNatVDgttacVBac
+KBaaKaBctccDtagctataWKttagtcttYgtaSccaatcBttggaBtMaaaagaYtMg
+tgtNatgacacctWcKattctgaNtaSgaaataatatVSaattaaWattagDtgagBaHa
+aNHtBgttcttatHaggaBtatcHtSttgccaatNgtaHtttBattaacatcactgaWaa
+aaaatggatagMHtSgaaBSatacBSaagMaDcaattttcgtctaacgHtaaaBtatctt
+aattagtttatcttcgtWVttatatcgccgaagBgRaDcBaatHVDtataacaccVgttH
+aaSgaagaaatcMSaHBattgcaSgaSVaRttcaMtgtgcaatKaatWggatBVgtataN
+WgNctttacctttgaaRatSaKttHgaaaYSaBttVacWttcctgctDgBSgYcagcggg
+WRataaaatgcactagaaHStacaatHtggtgtBgcNDttggattatgaagaKaatStgc
+ttHtgKNMNRagtaNtaDattgaDDcKtaaatcVVBtcSgNcRtcHataRcggctVBtcc
+aWcaDgaaRaRctgaatMtaRtgBcaWNaNatatWScYYaWttatScYtSgcataDtWca
+cBtactaWgcYtcgtataagctataNSgBctagattaNgaKgatVKgtagttttcaaagt
+gcgcYattcagatggaKcMBtacgtttaacctaaattaaatattcatRaggtcgcccatt
+MttaaaaaaactggSgtcccgtctaNtWattcaattVHDagRtggVSSaaHtattatWct
+atKatHtHattYBtaVaMRatgYagcHtaSataaStKaaacattaagggttggVYaaDgt
+tWSttcattaRBcMttttaacatRDaataaMttRgataaagVDKatcatacaacgMtaat
+YctKcgggcBKNgtggttcttaagttYgcataVMaaVBgtVMSNagttatSttgtDtgtM
+gMDtNKtBgctattacagataMWtcSggtcHgggcgagtcRtcRattaaaatgaaYYatt
+gtaaccttgatacgtWcHDgBtVagNcSgBKtaaMtcaStgggatDaVtKScaYagtttc
+tagNBtcMcDgKaDHtVtMaMacMgtagtaaWtaYtgHtttttgtctagYHtRaagacDR
+aatgctVMtttWaYaaNtttatatttStcgactaDatKaatatattHggttgtRtattaa
+ttaaaaRtaNacKattctVaatgattcttacWatgDgagggtggScatNtcMggaagggH
+taaccttcWcatWaStagHtttgatHaRVaaSVNNtcaRacaNaKttgctgggcVattat
+ccatVatataDtDcNgMBMgHSagggaaagKctgggtcacgaatcaataaVtDttaRRgt
+ctStattNBaaaBHatcgttaaWMagatagacatatVgDBttYMacaatttKtttaataa
+aagcacgVgaaactDBtaaccgtagaNtgagaaaRttcKKagtYKttttaStataaHgtc
+NDcgttYccaaaaMcaWtgggttatcaaRaaggaataaVWcacatattaRYaaVagagVt
+cHggaBtaataNattagKtcVRtgactatcgHDaBgRBStVtSgNBccWDgaatgaggaa
+NctttNttttacaaggagaaDDaVtcgaataaataagttaattStBDccaaaBgVaDtct
+ScgtgtttttgctgtcacgtttWgacStMtttVaVgaBtacDWtttagttDctaSDVttt
+NaDDcHatatacYtKataaatagttgaacaagaatacaDDcacatttgtaaaggHattaa
+atgttacgtcagtNStttcVatttaBtHtVggttattaaHcgaWagaYtVaataaatcaB
+gaccctHcatKaDatRttHRMcgtcgggSMtaatNagtYtgaYtggMYttgtaaactacg
+KgStttaaaYatatDtaaSaVVcHgtagatgaggtcaHggMtaMWaWaHctgaatctaaB
+aWaDtcgggtccctaagtaVYDaNactataaNcctKcBcataaatttcaWSttttgacHt
+ctRggagRaagacagWVNtctcatHtDHaRagctStatattggcattcattttMaNaSaR
+aNDHaagNtMgtVWtgtMccaactKNaaaVaStatcgtStgtgtaBgBgtaatcNtccga
+agtttaWgactNgtaaccaatgNatWttgWagtaaKgtctRgtctaataagttVDHgStg
+ttcVttgtSWatcYaggMatgMRcBaStgtaaaaaMttaYagccggtgaRRatgatccaa
+aggtttctaaKgacaDagagatgctcMgaaaMcgRaacaaatataaaagcagtgtatDHg
+RaVtWBVtggacatStctKccttVttatgtKattttYcatctgttatgtcDKHYcctSHM
+ttgSDRNgtaMNHaggatBcSBtHatDMBcttMacNaVMKtctgtttcgaHSgtMgcaca
+gaStaBttcWcattctDtcttHtDKBcaaNtRNaaDgaaaaccMRtBcWVVagcttatcg
+aDYccacKtatgatgtcaRttattYttctaMBggcaYctaNtBactgattStaDaHccYa
+DtgcaRDgSYtYtatBSaYaaataaagtctcgcgttcagaaKtttctVattagtWcacga
+aVaaVtctcaVgtagttNaaacaatgtccttaactaaaStaKWagttaNttatacaaaKa
+ttBctgaagaagtYDNtagatataDtHcKcctaBaggcaatctHttctaaDNtgtgaaaa
+gRaattataaBMaggtDgtMaWHacBStSMtcgaacYttRMatNacScgaaRtttctatt
+cMaaBggtaKttaRcgtBattcgatatYtVaccSacacgtaaagtctNatYttgcSSatt
+ttcKccttataatcRtHNctttMcatBtacatgtYtctagcNttYacaatgtaBgcgttV
+tattaaWtaDRtKNaNDttDWaaaataatDgcgcKtaatatcgctMctatcatcgtaaaa
+YNRttSaNtWggatRgtgtcttataVgaaaatcWDcttDRaatMKctcatatRttBtcca
+attBSacctgMtaDDRagtcagacBNtttattttagtDacaagcaHcacgRttVtatcat
+atacStaatMaWagttRccKtRctcgaagttgaatttNtttatHaHttagctatSBaBtc
+aagtDaaaRtgattcatStagttcaRattacaVgtatWRttWggttttctaactttSaaa
+VHRatttYHMKVVcgttMtatBtaSaaMctgMtcaagaMtactcDatSaaaacNgatttN
+caagttRgacgataVtaacYNataStRtgaattactgtaKtNagaaccDaatgNDaaHca
+taDSYattatgtctgYWaaRaHtttWggcKatgcgtagDSVtMactataKMSttaHaaaa
+caHatVaDKtSaaaRtcaNWHtatttctWataagctttcccaacctNtaaacattcgaga
+BKVattaWtcVaKtWcggtaatcaatgttcaaatccDttctcaaSaWNDataaKatBcaY
+ttRtcataMVtKttggcaaNgtgttatMaccgttgMNagtgVtNBWggaacacaKaaKct
+agtctacttSaKYMacaWtWDttatagHBacttRttcctgttagtScVNaRtaacgScaS
+tttatctttttSgtBgNtttStRatNDWtctgatcKtgHcattatctaaaaattNaaaWg
+WaDWttWRtHRNcHacBVgWttgtNggtWtWcttgSatRtaaYtYtNaDttYagactSta
+cYaYtNHBatggatacVtBatgccaHcgtagaaMatgataHagtKgHaWcgtaccKaNat
+agWtDttcgtagggcSgtRatatNgaRtYataaataRtBtcttaSatcagatgaaSgtVt
+HtgtaaDtVactgattcgcatctctBaWWtaagBttVgacHattWWgcKataHtBtagSc
+WtcaNtHStBKMHBRtRagcataaYtNtttatacttaMgacccattgagtDYggKccNaa
+RgataWaaaNWDMttMacttaatgStDYgtattaBatBttKcSaactagtaccgttggaK
+acRtDaataSBaatacaKtgagDtNcttattaagYcagacttNNttatcBtHtgRatgcc
+acctaSaatccaRSgtWggtgaaMcgcaMaagSagaaDatHcttgaaDgNRttaDKacgc
+ataagYaagtMRttNaMMMgcggttcgtRaSgacaStaaVgStcaRBKcaMtctKtctat
+NaactaHtaactaaatNWaKtWaStRSKcatggtgBtgRBtagaatagataSBagMtDVa
+taaDtaattgaYgaBaagWagaacaggaagtctgacgMgtgagaRVacMcBaaDatKatc
+NtKaRtcatDNBaaHatatacattaWRBtcaccattctctaaWttWacgtccgcgtMctc
+aaaccHYtNDatttSaDMccaStRttWgttattaSVKtgttttgtcWatgtgStttgttt
+tatcaagacMttgtRDgcRtctctgtgggggcSaagcatVattMacattSgttaacctaa
+aaccgcagtgagNgtctataatBtHtacaaSccccMgagRVctYagcgaatttacMagVt
+taRDcctRgSSttttcHtVaacatagBgaMRagatRcDBaMtaNtcatggHgaDYgaVgW
+aaaaMKattBtaDYBaHRccagttatacVaDcacactcgtaSctaaatatRDaccagctt
+tttaatgtagaMaRaaKaaataaaatacaRagaaYaNtatKcDttgHgcVtaYgDacagM
+BagtgttatgMcSgWDWYWtSaKaagcatKatatctcaRHacagttaKtgBKtDRggtca
+YcattcgcYattttgtccaagtVgcattttttaVaagtaaaagtWccttgacYcaagtaa
+tataYBaatataBtaaatacacttttRHagtttaDSHgNtNVcatKgaKtgagttgaaaH
+cgBattatHgRKtcaBaagttgtttgtVatYattaattBatYgaatgMgtttatagtKcV
+ctagttaaYWttWaRKWggYttgaRgagaaMKtaggtattaMVttataVcagHYacaaMa
+attRRtataWaaRacHcattaVaBtHgtatBaRtttaccaaggNgtaDMtatYtaYVtNt
+cBRKMgaatRaaagaatactRattttNcaaaDDaagtagtacaNtSHttaaataattggt
+aaKtttaaBaNgtaagtcaYttacVaataataatDtgHSSgtSDNaattcRMBgHttcta
+agaYVcHcactKgaaNHcgWaWttaaBactcgYtDaacgactMtaYKacBgttcttgtta
+taBacatScBcattKaaattacttSSDaRgKtHHagRNRMtttBDtcaagcBcgcYatta
+ctcgtttacSaaNVagtacacgtggtSaWatBtgatttWttScaaDtttggtKtNKaMtM
+gcttaHKaRaccgatccctgtgggagRMttaaMaWccggtttBtgttaaVtagMWctNtc
+tHgtBgcttatSMYccttgHaatatctgNgVttagcttagggaBBSStaYgYatYgtaaa
+aattHatctatgtWRNgtVcSgtgcgtcYBagtRHgacttaaagSHatatBaaDgcaKtc
+ccDgcacMttatRaacaataaccWtNBaYatttYacYtagagattRtatagKcatattDg
+KtNNgtttWNagggtacStataRtVDYaacgtaBtVKtagaagRttttttatataSaaga
+aKtaatatKtattagBtHataatatcWNaacagtgWaccatatStcYcaaNRctcKacKt
+tgtStaaKRaWDDaatBtttgtcagggBgtggSctaaWtttYVWttNtctaacatagVYa
+tcagatctVaHMgWtcaagtataHtgacaagttSacgtNRataaatgttgNtaattagaa
+ttgctMaRttBtacBatNgacatttcaMcgtaaacctctagHctaaKNttBatatttaat
+attBaKtRagYtatattSgtgtccBaNSattgaaattgYggcaaataatatHcaaaatcM
+BaagYatttttaYttYaStatttDtacRtgRattttttgDcRaggagcaccaattcRctt
+ttataHcggatcatNSatgtagtHHcactgtWgtaggtNgactactHagagHattcaggg
+gSaatgcaaaacSSKDtaggcDtatVagMtggactaBSatagMttaggatSYttaacBta
+gaNSVtaSaNcSScaaatattVctcYaWYtBcttcgaYBagWtRgagHKagagMaatttM
+atgtDtaYNagDtaBagcKcKcaMttKaaaaatVaatHDaataacgRatBNVKtMaccYa
+accMgttgtactagcttMatKgKBtMagtcttMWgaatRcacaaaaSgcgVtSatggcag
+gcgKaYaatgctcattaaaggDVacStgttaMaaaaacNVtBtgcttaacgtDNaaRcgW
+aKtatactagcactgKVttaatcttRcgDHHattcStatgatcWataagtattttacgtc
+aRgaaMcDattYHattYgatatcacNNWtDatgaaaactgaatHaggaNcttcctKggNg
+atBaaatttgcaaaDtgctcaatgtYagacMgtVVtgDBaacVaatNaDtatctgaaggK
+cagSggVtacgatgNWtKWaggMacctagaatattcttYaatDatcgttgatggtcaacg
+ttatatgcttaWVttccRgVcaDcgagMtacattaMtaVWcgttRcatRacaRcMcaNta
+YWNYgMtatMgccctaKctagHtttaaBVMaaWcSaccgMttBRgNcRWMtHMaccaatg
+ataaggagVttYgaatcttagtgtcMtgcctVtaRtgcaccaDaagHactNYcNcttaag
+gcMBagaWtattgtgctaccacgcWataRaHtDtacgaaVttagttVacctatatStDgt
+ggtaMgaSattcatgMcaRctatgWgatKatYYaaataNYcSaDtttgtcYttttttaBS
+catRtctgtaWttaatagMaacatDttaaaNgaacttacYttagaaccctgNgagMNHaa
+KacccNatgKccttaKcatDStaaStNaaVBatagttcacRtYcRcKaagMgctKtBagS
+aagNcKRttaaaaKaaRttttttatHHNHaHRtcaRcMataKDDtNcKtKatctaaataa
+atRatYttMccaaaNaaWgctgattcaaaKgaatScaNaaaKaBaaaaRNtataVcYDat
+tagctattaaatWtgBWHgggtatcatattatcVttcgHacgcgatMattDcaRggDYtY
+ttNaaaatBKttKccStYVDatatYcctSacVcattttatMtWRctaYagRgctctttta
+acVtagaNaVRaccgRaattaaVcaattgcgKRctMaKtttHgctttVMaNaRaNMKacH
+SagtWagtgNatKttatctataaHatgSaSattcagtDctWaataaYtcagtaYtctatH
+cgattSRttaaaNDgagatatacttVttatcataSSaBNaDataRtRRaattcaRataaR
+tattttNaRYtaKttaccaaaaaHVaBtttWtttgatRagctaMattgcttactctgatK
+tgatgRBttaataagYttcStKaNgcNatacgWatYaatctggVtaaattYccKagaVag
+ggatttatttWacgaBcaBtaaDttttcgaBcHDgaaSgVNctgaaKtgaVagtVWgRHg
+tacaatattgcMDNNataatagaaaataatNtNgccgaaMaagtgNttacgVHaacSgSt
+BBtRagtBgtaaWgacttcKgactaaatgaagVaacaBtggtacattcaaagtgattagK
+agNatatVaKBacaMMctccatcgcgggRctttKaaBatcacaScaNaaaaatVgHaatt
+aatatcWcacacactcatgctcgaRggVgcatatcaDcatYgaggttDgWNagagaaaga
+gaYttHKaatgtaVtYttSNaDtcgaatctattSKgtgtaggaMgtaccWcaMRtHttaa
+atgWtgtccgtKtacggacaNgaacgaSgcYagcKBttNacaagatacgaagaVcBgStM
+acMtgKaactataSgWtaaaatDRataaaNaSaagHttHWYgaccWMtatataaaaagat
+gtaKtVtgtcBNMtRaSaRacVataaNaaaDtaatgtaaagaDgtataVDaacagatttW
+tDtcBgatggBcgagctcKWgtHcBgcMaatDNatcaYtctBgaHtccagHctttMtatt
+gtBccaHMctatctNaaatacgcgtacatacatctaDactactcKtacctataDccMatt
+RgRggHtaaaaNYcVtatccgttSaagYcgMatttaVattttHagVatVtttKattaagt
+taNaacaccHSttagDactSNgtgtttaNtVtatttatgaaacSaKtactctacgagttg
+aagtcaSBaDgtagatNaaactRKttcatcWtaBaggKtKcYttaDttatMaWcStgatt
+KattgtatatDttatDtKatgtaNtgtcgtcttttttaBtDBcaaaaSgDatgHtctaca
+attcgMtVYtatgcattaaaattcaVgatRtcagBtcaMaNctHgtatVatcHttcaDNK
+gtWcgagHtttaccattNgaactYacaKgaaagtggtttgtgatcgaKaHgaatYNtBgc
+aaVatWacNggataccaDtaaaWttBMaBccagaHDaataaBaagYVacYaScctYVgag
+WagaYagtgatgtttWatSaaaMYDcactYtaStWgaaattacHgKDaYtttttgttcaa
+aaatttgYatatVcMatcactggRaaMVtStBtaaaagggatYaagtBtatcatgcDttD
+aaaaMatagtctaataNtcttWHaaatcaVttaRaKtcgatttataWRtaatatcDWcct
+aNMatgtttDaYaaWtMaagtcagaKtaMKacgccaaVatgWtSagtagctatttcacta
+aNcaaaNaaattaggattatMWgtgacgtcttcattacaYttctRRtttgMatggNtata
+caataataNgatNcMttaggBcDgRHgatctttagtNtacaaccgBatgtHaatgttttg
+atatccgttatcataStaKRaKgttgNaagagKttgNYMaggaattcagaactcaRataD
+ttaagcttaccttttgVttaWWgacYggStacYcgatgcSccaacHcaYNtgRaHtcaYa
+acHctYacatagatBgtgacDaNgatMacgKgBaWagacaSgttaKcatactatatcaHa
+atataattctggtcNttaYggDRtDaSHgNttYaatWagagtagaacKtWtHtBatNtSc
+ttttacaattagtaMaatttHgtctagMctaccagagttcaKcStaccKggaggtctgcN
+atctctDgYccaaVgttgaatgacVcatagtgtattttccttcatctacttSgaaStcag
+HtMaataWNDagtatttttataggcatNKataNaMtgctgtttVaacctVBDWattgHtt
+atattaKtatSVSttgtaScgcMcccattgggtagaKMgaSaSttYgcaaMaatVaVaKg
+tatgYNattcttagWgtcBaaagSaaatRatttNctacaStggtYcaaggttBtgaDWBt
+RtgaaDccacaaaVSatatBcaaScWccgaKttttcgtMaVttgatgtMatacatgNttB
+aNaagtaggaRaBagaagtaRtaagttacWatgHtttaagSaatgataNWattgtaSggH
+DtttBataaNNBRaatKWBgtaDcBaMaKtctaYatVaKataaaattWYcgtaHcttagt
+gYtgcKDtccatMSaaagatYcSaHatcaDtaatgMMatgcaaatgtttagaDDNtattt
+gaaKcNtagKYcaBMattaaagttaaWDacgRaRtaKttaaattaVVKaMaBtaKctaaW
+catctRMtgKcBaBaaagattHcgMcgaSNgactaccRatHtaSNtctYcaaBDtaggaa
+gcMatttcaBcDaaatggWtcaHctaKtHcHMcRgattgaMtNVaDagttaggcttYctc
+atDacWDaaaaaKtaBgtBaatcaataaKgactgactcNcattMcacatNMattgtaaaN
+aaacttgctaRtttacttaatKYgcttgaSStgtaDaNgtaKgBgMaKgccagtgtMgat
+HDtgacaWDttHKaDgMacttaKaagBtttgtcttaagMagtaHcttWcacaatSatgYt
+gacHgHcaHDgtagaDccVaKcaataNttccHYctctaSRtaYagtNgDagatWtRttSt
+tNtRNagacatattttatggactacYMagtMacYaagYgVgKgtNtaVcgtgaatcataa
+tcgattYtaaatYtctgBaMgNWNKMgDttttaWtaBaaHatNHaDacctccNKtgaVcW
+attYtgccaVRattMacBtcccNagYttBYNgaBaaaStWacMgcttccatgHaacttYa
+gMtNaaVSYgcgatatHcaatatttgtgBcatWMtaaaaDRttHaBaHttgaacaaataa
+WaMcaDctgBtatWttaacaaWacacWtDtatttatWaaHacaVagVgKaaaDttWgRBV
+agttVNttctgcttgacatttSHHMKScSgSaMtDtaMcgtcaWaacactMcaHWRgaac
+tWtcgcMNcactVDaatHcDSttWtagactatgaRNcttagataYgaggaagagcaSHcW
+tMaKStatgYatttttVaattgtttWataaaDaDgataMcaMtatttctVKaKgcttcct
+DagtgatWatacaRtttaaaBSMctHaaatcagStatStgaaVttaattatttgctaagc
+gagaWaaWtccgcaaSgaatVgtaStMcSNcgtWggMVWNatHctggRtttaacNagttt
+RtaMBgatatHtaatcMaaaYgatMtaccttaagYatcgaaattMataaHatYMcccaaa
+DaYaVaWgRaHaaaMcHSattcatWSatttcaMtgataKBYtactgaNttgaaDactgBa
+tgYgttaagVgaagDagaatttKNtgaMtHagtaaHRgaaatttaYtaccNcgWNcKtaY
+tBMctVBWttttaSagRHBtaHtcgtactHggagtaatttaaaVVattWDgtaaHaYgDt
+aacatDtacWttttttatgccacttaDtagtaaKgYNcttMNDaBcaVMcMctWgatact
+aRcaaWagaatgcWcRtattccagKgaNgtctcKtWgaNtSttagVaagaSYtcctWata
+tSgaDaKcactcgBtYacDgMtaKggtKcDtRtRgSaNKctaatHtRDaRgatatacatt
+agtgccSttctDgcgatNcatttcHgcKtagcYgttttgNKWRattgBtaaNcRaatcNa
+agcgaaVKttYtWttaBttttttNggKcgaRBMVtNcNtDVaaMtcBNaKtaataRMcaa
+aattYactactBattWcgccgWaaMtaBYtgtaHagtcttVttaggaHVaaNaNaatctt
+gtgcattttatMDYKccataScaWgNttccttttMaRcVtWHgaaatgBaaRatgcgata
+taaaWYacYggtacttaaaaDaaattgatcWaatgtttRcatatcaggaBcttttcttVK
+atKccaccYtDatMtcttacMtSattaatatagaatgSgagYgWNtttagtatgRggYKa
+caatattgggVtttaSaYcaRtBcggtDaggYaaactNataggaggaDgaKcaaataaga
+tMKaattaaNagtagttcWctataaDtttcgtcgtattaccStgYgatgKtgcccYatDc
+tYtttttYttaaaagaactcaNVaaYaYtccagacBttKcaatKataatKVWcBataaat
+gttcctatYaacttaSVtgataggVatgagttgatcttacgMMgtWtYtagcacaSctcH
+YtataattMttataYaaccKgtgtaaKcYagaaVtcBKattStgcaaKcaKKaHgtaaBt
+ctgcaattaWgMcgYttMctWtaDNcDatggWaattggaVDagKattttgaaaRHattgM
+aaMgtaatcattctKgNaacacccNHataaaatgaaagagSatKtacVagttggtcgtgc
+BtgtgcatgagcaacataagKtcagtttgtDBBHWcgaDtatYttgattcttaaagcMMt
+taKgDaHtatVgWHccgatKttcaaNcYtcaaDWDatcaWtBtWHgctaaMDaDWtWtNK
+cRRaNttVgHaRgKgcWgattNaaattaataNcaRtagtRgaacagataDKgtatScatt
+aDgatcatMtcgYcgtttaaaRctcagcRattaacatccStcBtgaccgtgWaaagaaat
+gaaWtattaVtHacctaccaaatgBgtaVVYaaaatccKgtcaactataDgNagtcaSgt
+KttacHtccMKKWattagtatNctattagtttWttRtgaKaBHStgRagattaKRtWaKt
+taaWaagtaVccctgcgMRWatgttNKgtcSggSHtaBttgtaYaatDtaVtaatgtHca
+tWaYcMttataVgaaaaagBgaagRattccggcttDgggcttcttaacttRgaStaMBaa
+MtctMBHBacttVgKggcttgcgBcBtgDtttcctattaaRcatStNgcKgctatcccac
+SctcHtaHWtgWaYatgVaRRYtgctaaaatggagacctMcttgttMagBaKctttYWBt
+aYKgcccYttaMgtHaaNYgtgtagagDttcBatgtStttMtBWtaaBctaggaaNgaRg
+cttttttgtagacRttHSagaatDaYgcctMBtgtNSNaaBttgVtWtttKgacaatatV
+ttVatagatttgcgtcgDtVgtSattaaaVHtaDaatYttatKSWtcattagtaaNatct
+cagcgtgcKcatDtaBccaaccctgaYcattaNaagNaKgagttttcattaHMaVKMDDt
+aSHScaDattgcaggcccMattatacYtMatWgatttcBcBtBctKacccaaWctatccc
+tcaacaataaataaMttgtaHHcgatKgaggBtRYattatacgtaYNBacagacaaatVt
+McttttRtVcaattgtttgaWtaaSacaRccMcaaacttttaaacgtacVBtcWcSaYHg
+tattacgRtgtgtaKgWgaatctaBtcgtgRaaaWWVBcaNtcgctgYtaaaHaSccaag
+aVMNaacagattaHRaaMWcVgMtctgcatgaagRDattactgcKHtcactYtccttatg
+HtKgMgKcDtacNtcaStgYccaaDagttDtttgYcaagcacWWttaMgccaStaaWtVa
+ctgaagtKtttcaWaatgMattatKcctctttttcatgtaaactttNcaaKgttttMaMc
+YtgWctMtttactttagaKtMgttDYttctatagWcRttatYSagacttcaScaacaYtS
+aattcaaagtgctSaagctattaaagggtaactcacgDKgttaMRgggattttMcgttat
+taVtccaNagaRgMaataaagaStcSaacgtaWttatatHgttHBcgtacggKBtSatDa
+ctRggaRgccBRttctaaaatSactcKtttVaWRatatttWaHaKMatgtacatcagcta
+atggBgaBNSNatatcYStagaatSNattaccgtcaataaggYMRtaDaatVgYaDaatt
+ataRgVaagtgcaNKtgttgacttatHccacHaacVcWcNMDtatcatttttaHacatKt
+atagtgccWttaattttBSDaKaHaDttYacDtBgtMNgggBaaaaattDaaVMaKgatc
+ggKtgtctatctctVatcDtaagaagtgtaMcWatDggaaaaaYtcDVtNttcNacgaYt
+cgatHctctaWgaaggtMttcKtcttaMgtctKNagcRWcgBVtcBDatYKtctaVaaaB
+gtaRagcacggcaHHagcagaaaaacgggtataatcaaWtacYcWtcctaBgVVaBagHa
+aaaaatataRYagaacgggVtttcHaMtNtMgcgaaatKtattaagtMttatcttWtttt
+RaatatgttatgtatttRaagKtBgtgHtHDggaBDtWccattcKtttagtttagtBYcD
+aMBtgatcttgacatKctBcaaaacaHtatggaNaVttcgttatttttttcaaDtDDaat
+caaaYaaBHttaMKMVgctgWtacVtRaaactgYtcatggcVHtgattRttataBtcgaa
+RataDttaatcattHtatatccNattcaaHtgKRtRtagtKaRWaataYaggatccactt
+cacaatgtgatMaggactNaaccaaMaaKtagaaMctacttDSaaaWSgctcagtWaata
+WaHtStMacttaDtgagWaaaatatttatcaacaactRtDgYcYtatatgtataatWtag
+ccaagcgtttataatDgctgVaaagHaattagaatBWggttctBaNtactHtKBtcgaaa
+RttHBatDaaKccaSHgtgctWttcBaatcctYttgaHacgtatgagStatRtMaacKac
+acggaaSctagDagNttgaKKSgtttctacgtagSataHttDctggBcYtttaaatcgRg
+agagaDtgRSaVStggVtgacgtMtatgaaNtWtHgtDaDtgttNaSVagaattccgctt
+VatatacattatataYtaggYaaaRDHttHYDtNgcatHggctattYtaMcWaaVtaNta
+tttHaagBtatcagatHtttgaaWWtttKaaaggBtattHagtaacactDggtattttSc
+ttaaaacaStcaacHttMtatcagatSaHtaVtBaNYcttHcatgHatagaaggggaWgt
+gBtttagtVttgacatYtKtattaYSggtaaaHgcaggaStHtYcgtaaDWgtaaaMcgY
+tNHtgNgcttttataWatttKWaaKtHattgRtBtMMccgtBtYttgaKaWBatcBgaaa
+caBgaagatYgKWaaacBgatgtDaaacttDcacgatSKtaVaRDWtVKgHtcRattact
+ctattBacaaactaatgDtaatcatatKRattSggtcggRMaaHVtgttMcgatatcccg
+VctKMgBactVtWtBKtgWtaaaVaatRgKatttKSaYHtcVBNtgStgtatNStaaccg
+ttaaaaYactBgaaaaattacacVttKattVNgaMattNccctaVtaaStctgaaVatac
+tgtctaaaKYNDtataWtattaaNgtHtaWgaBMttttccaaaDcgctgagBacacttct
+DSctcMtBtNccaacaaatSVtatWggagSattKatRBaaaNtNtttagacttaagtHtt
+aatcgtWctHaMBaHtaaagKaaKttgatattttgKcgtcDtgtKtHagDtMtatgatct
+tgtcSgtWgctaaaaattDaaaNgNYtMttNHgtHBataatMgMttctDcgtNtNatggK
+atHtaaRtRtDStttRVcaatKgaaRSRtBttatccataaMttagcaaWtagtVgaVBat
+cVtYtagttgtaMactaaataDatagNttttactagcgcKctDatatDgaHtRatVWaga
+DtttcggSKataacaggaaKggMtttctaVttMaatgattcgaagcgattaNNtYacttt
+KgaatWttNNgctatatgttacKaMtaaDgtKgttBttHtDacaagaaRgDgttWtaatg
+VBcaaccatgcYggtRcctaaDaaHcatYNaaVDNtBgtBaattYYgcHttRctattVta
+ttgttcKaaatagtacccttgcVtaaHttaagaKtaagSaYtgcacttDattYttaVgRc
+acaattDDttagattttcHagccaYaataKaatccVDKctNcctcaaBccaaBaYgKacW
+VtWttatgcSatcDHttattaacaagaacRSactBHttDaBBBcacgttactHaKgacaK
+taWMcHtaVHttaattcgttatatBaaagatgaactaaYgDNattNaHgHKtaatcctct
+tcHttagaatVcagaHtagBgtMataattaagtcSRcatSagMagaaaacgYacgagcac
+gBcggacaHKaaBatSatagtatcDttRHtcagtDtaStYtagaaagtYNHtgaacaatg
+cgataaNgtNVagtacccctBcgaYWaactRtDtatttKatBccVKtHttNcttVtgaKM
+tgcttggcgaNatctcKggtcttttataaacWaBttcgHtcaHtcgatcgcggccaHaag
+cVgKattBaaWttKcttaVaagYaVacagaacgcScDcgatataagttttacaaKcaaaB
+cYcHKctRagcgaatgtScBagMttYHtaatHcKKtgggatgKSaaatactgWBHVcagH
+cttVBgYDtaVtcctcatRcVKcNaaYaBtattttatRtVtDaaScgtatacMatcaaac
+tagtaKataaatStHtacaagagttgtYatctagaBaHSYtaaataaaStacaHagWSRS
+DtagtatggctgaKtaRctaaagBtactcttatgBcHcNtNRNtHataaccRttagatat
+aaHtacScgtattgttgtDcctaYRaattccaNatgtgctaaaactMcaWttgttgVMaS
+gtaVaSctMcagtcacNaWacgaatWtaRtaatSgatgaaWtaaWcgtttHtWcttgatK
+tgDtDMcagtcattcacttgaaatactWgtattcHttcataactgctgtgtKatRagtaa
+tttYgNcaatcBctgtStaggtaMatacgtYaRNtgNaHtNccRtgcSHgRcaatttVcc
+tattaBKtgYtaMaactRaaaaBaattHHtatVNWYHaatcagtaMVtttctattWHttt
+acaaVccDctYtttVtNtRRKtBgatHtBcaatHYaSgaagaagHagtttDaVaattVac
+tactYcaDtKttgVVVtaWtggctaSttgtaataDctWactcaRttWcMSYtWagaagtt
+ctKHcgKtDaYggaDttgtgtataacaRKctaacttcYaDtccNaNttaYtaatagRtta
+SagaatBtVRtaatcttatgcgtWtataaWgHataatttYYSttYcggKKtaHcttttag
+HDDBtggtttaaacatagaRagtVagactttacKaWDMacgYaacctgctKaNattggat
+ggNgtKcYSttttcctttDtYttBcatgattSHaaccVtccatctcccacDBtgaWBaMa
+accgttttcttaaMgScBNatBtagtcttccttatKBRcctggtVStatagcDgMgtaca
+ttacccattKKtaRcRatRctYVaSagttatatYtcgNDDggKaHggcccgcRtacgDtc
+YctgaaacHtatattaVtcaattaaatgaWaBggYtHYYaVagWacaNtDtaRattgRac
+RtacacatgHtagagtaatatttctgDDcttgNDagcctaaHtatYHtKtRaScgtattM
+ttacaacHggttttatSgaHVVgaattaatagttattactgtRtaWgataMDaaaactgN
+YacYtagKtaRcaYDHatatVatggctKtWatHaNttaatttttgtaagcctggcgKata
+aNtttRMNggDtataaaatVcMRataacagctMatBgMtaaVcgagattcaaaSgtgKac
+gtDHatWaatgttcDtWatgYcWRttcatBSHtttgaatatBgaaWgggaaBcctSSVaa
+gctSctagYatDggtatatgtaatatgtatgHYcRtagagtHcgggcataDHattcaaat
+tcRgcaaaataagattcaaYVtaBtaagRagtttgSRtgRYKgWggtttaaHgcHStgtg
+gtctaHaccaccSaaaattaHatgttVtataccagaatDKVtctagtttcaatgtNctac
+cgDcacgaattacactatgaaggccKVatccaSWaaKHtttSggatgagMagttgcaata
+tKYtacBttaccatHRttaacttacaDKKtaKaDcHHcaYatatgMagaRaNNttcggag
+YRtacMtHgacttagacBaagggBatcttgaRDactgatacatatcSBggtaaaVWgMaa
+tttaYtaWacHattDMtttaaaRRScatcttctaatacagtBVgtgtttBagtatgBNca
+agHaaaSaSYKcacMtKatggcacgcctSRaagcataattaYacctMaaKtcggaBaVaa
+WaDMttgccttaaacttDaaHacNVtgagaataccactctMttaatcttHcctttaggaK
+gaggWtaNataYgtaggtgaagtcWDcWaBatattRtVgtRgVtataacDDNttatcYaa
+aagcaVgtYggaDattccgtccDcSttaaWtttcaaaatggataSatctRYcaaBctMMt
+cttaacMaSgDatgagatcaYgctcacHccMgaacatcDNgtNRcgBaaatagaYgatgc
+ttRaattStccttgagcctaVaagggatatcagtaNMttaaHcMaatccScBtYaYttat
+gaMNagtgHaatHacaHaBaaDtaRNDNcBtagBgacatStagacttgtaatMtYaNaKS
+accBtttHcDaHNBttBaacSaggagaacgWcMgtRcaagattSctgtaBtcaatMtaHg
+caaccataVgtaagDRcDcggaaccaBtacVMgSttgtcataaaaacaMataHatgttaa
+caaMgtacgtMVcatagYtKgtgtcctaBcYKattcaggBaaHagStcNcattatRRaSY
+tYDRaHYttttggaRggggttatKcVtHgctggaNttaagagBaacattggYaaDcSacg
+gYaRttacaacactcDcacBDtYataaaaDWtctcaggVtaYttKtaVKtDSaMtYtYcg
+taacHtRcHctaacBgattttagHaScDctHttaaaatVaHttggttatttDtatHtcaH
+cBagSttttDctttWtctaaataaWtHYtRgtBccSaaDSaNgatcSttaaaatgaYgKa
+aDaVatatYaRaHDtataKaNtagtacataggSaatMtctMtccctWgaYtaggataMtt
+cgtacgccYgBSgttaaHgctRgRgtDVSRattttttaaKtRMtatSgRaatKacMaYgg
+gtagBgNHcgYRagHcatatgtgaacMtacSDRMHaaacHaagtWSMcaattcagtDctB
+attgttcatttMBaDVHVDBtaatKactNacgcBYtttgatctatVVtatcKaKSgtaWc
+gtcgNYatSaRtcaggaRtctattagattKHttYaaBtcacatataattMgtatcataKK
+atDVtWtaHtHHVaggaaHagWaHtattgtDaHRgatgtaaaWaaSStMatttgNtgtca
+gDWgagaBagtcattaataggagttcagcHttgWagaWcRttaKttaDgaDWtYacMWgR
+aatatccMtaaattRaatacaKYcgcatgtatgtNaccataSttSatttttcgatcttca
+aKcMDatgaattcaMWctKNcHtctacaYgatgcaBtDDWtaRtScaYaatYSgBtDcaa
+cYataacgcDgtaacMtSaaKcKttttDVgttgtaaNcaattctcaataaatcSVcKaac
+attgggacatgaaaacggaggagtacDYgatMYttaaaBBctccYgcgagccHattttaW
+tataYcaKaaDYaaaStMctSattaatataNaWcacaataVtcatacaHcgMgaatYgaa
+taatRcWcgtttcNDYcacaaacacaNttttaatctaKtRttHDSttccWatatagtKtg
+tcgaccaBgtVacNaYBHgtttSSagcNtctacctttaacgacaDcWVacSHcaNacatt
+tgBYaaagatWagaacYMatcKgBYcBggtaWatataKcNgaaaattHYtSaYDVHSact
+gttNRgaaaMBtatataaaaacVtctWtgKggtatDBgHaKaHVcMWtYYBaaattaVtc
+gaaacatggagYKtaaaacagttNtttatcatgctagYcctctNgttctgctaYttBata
+aRtattgatgaaactagttBgagtcttccatBagatctBaaagSacagtaaStaaatata
+taataatcttaactatVtaaBattHcHgcttSSaaDRaKtataagggKaacRagBaggta
+MYttggtacMatMttttYttaacttaBaYaaaatKgtactactKDctcttgaDtMgattg
+VgcRaaaKattaatataagWgttcaWgtcaKtatcgacatDaaSatHtttcagcNtatSg
+gtgtaRtgatttStBaNaHgcagttaggggatWtttgattttatcgaBtctaggcgtgtg
+tWttttaaSaWKctWggtgataaaattacBtMRtatccattaaSWttaSMcYtHtaactt
+aaBaDattctatKatctttcatDtcgNcgacttgtaaaattDcaVatRacatgaaagtcc
+tgtctcatacatatcSWgNDttgaaVKatNacDggagWaaatgaaVNtttBataaagVtt
+VataataYcNMVaNaKaatRMcagNacVRactcWgctttNatHaRaBRtaaatRtaKtNg
+YWattaatcttaRttgttcttaaWaaagttcNVtagMaBatcVcgccDaaBMgKttgaVa
+accgYtRaactttYtcatgattgtWSaaBatagtagSataDgatgNtaWatcaMttaHat
+tagVtggagaNHtaatatctNaagaDBatcttttaRaaNtBYagtaacVttYBtaagcaa
+aMatcNgKaggacagagtgaRatWaDaaSaDaaattVgcWttatBNctgSagtctgcStt
+acSRtgatHDgggcBagccDtatYaaagaataDgatDaBttagctatcHtcWtagggagt
+DtSaaacagtagcttVatgttggcStataacttVtaatWKtatDatcttcDaagactgtg
+DNBaccaattaacaaagaaHWtatttaacattWaatgttcMttaNNcYaRccHtacRaga
+tccKaaYactcVRDtcHVtgaaNaSatctRSaWtagagtcgcaataDcagBaagtctSNa
+gaaaKgttataStaatagStaatSatataWttctcgtaDgtYRcgtHttaKtcDttRaat
+NacYgtagVaattNttttatDgKcttttSaaattYcgYBaaggttctagYcBataacVca
+gggaWtaKtacatgcYcctatccDatatagtcRaaaSMgtggaatcaaMaatWcgctagg
+gtcattaVtctaatgHcaSHtcacttBaagaMDtactYgtttgWgacccStDtagaDaBt
+gctctttKaaaatMttNStggtttatWttYttatKMKgtctaKcgaBaaaattcccgacY
+tBcaKaKttRccaaBaWgMaMatgtWtcRDWttcggacNctataaacKaaatHatggDat
+SaaKtgcgRaaacgtgttcatNtgHtcaataaacaaWMKatattcWaKcNaccWtggttc
+ctBaMttgRtggtWtaaVggDgttaDaScgWccWHatacaagtaHtaacttWaNatgtgt
+taacKaVtcataDMattgtaKccttttttStaaDDtHYattNtcgatataBattctWRat
+MVtStaSaWttNRacgatagtRcgcRtcctttacagBKaaVcYtRaKatVtaWttaVggB
+BatcaaWatgtggagattDgWtttcaataDtactRaatBattWVacttWVNtVagHaHta
+tttaVagtRMMtaBattatataaNaagatHBtgtatVtaaacatttagtccaKDcacgWa
+aHagttVKBgcgRaSYtttVcgaacaBatttaatctaSYtccNtcatctatttatBaHca
+ttcaBgDMYtactgScccttRctaagtaaNtaaaaattatggtVataaagVStcaatcac
+gcDaatgtaacatDBagtcgaaRDaSactgcagaHgttYatgaVgtNccttcaKHgcgat
+aDcgYtgtgBatcacScgctBcVttttcYaaNtttttatcBaatgataYgtgttgtatga
+VcBagtatagtNaRaaatKVtcRtcWatctaattgtVgataaMataWagaDttaatRcgc
+taKHgaRagtDctScatNgHgtKgtDtHBVgYcagatgttagcgaataaNBactBaaRaW
+cRcMctctBtWKaggcaataatSYtccagtRtaSVtRgatctaBgDNDtBgtttgtaNtW
+taatatDtataacgccDttcaMaMatgRtgaaaMHatgBaatgcccDagNgttRDcWtaa
+aKtMSaBgctgcaatgtSVattRWcBtDaaMKRcccWtVttaaatatttctgtcatNBga
+aaatHtttWtYtttcaacaaagaaNYBaatatctgatNtgaacaaMaaYcNgtgatttWt
+NaatWcYMScMctaaStttNgHtMacgtMDtgagcattcacWtttKttBtKaKcHaBttt
+aBacgaaNYaaaatBaatNHgaaatMtagatDcaagMtaattctKtgNtScaatagcaHD
+agtagagSRcagcaagaccYHtaNtBatKtStcRagtgttMaYgtgggtNatSaatStcY
+taBaSBtaggtctMtatcatgaattactcYtNagaaaDtggaaatKBattaaatcWgKtS
+tKtcaWMggaattYtggccgaWcacagaNWaNgaacaYaHgaVtMctVHttaKDcctNcc
+BKMDagtatgcHtttaaaDaggtgHtattcatatttaagcBaaaRcSgttaaatgWacRa
+tacaaatgBatYatatRBcacaVataRaKWMcDWtSaatatHattcVgMKYtgtaVBtga
+gattRgaatgaDgtcaStacgctaggRggtSagKcWYctacaagtttBtgaBttacgaSt
+HgVaStgtaRtacaDccNDattSRgttatMtNttttWHacDtttVtgacgYattccWcta
+agtgaaaMMatgNtctaataRctgaacatttVcNtgtttgaggcaaagtatgVgtaVtgR
+DcttBDtataaMBatatNgataataHaaaNacaStgaNaHgYtgacagtcYDggagattN
+caDtKgtagMaacSHRtcagNagatKcatataVatactgRVatgBtatcgttattHtHcK
+aDtagRagtgHtaDcVtatacattacggcaKttattgacatDaatgtctcattVcaRctt
+ttgDtNHSggcttaYDcHaatcDYacccWaMttgRtNggYtttttggDgctacVDtBMgB
+aDgtMaaBgctBVttVagaHBaaaaatgNactaattattNagaagNVaBgVtRgggatac
+gctgMtgaccatMaaDYDaagctggtcaatggtatBtNtccWtWKcaNcBttactgtgBY
+DaMtMtcWaatctWYHatccgWtataaaNNacNgctYagtaaaRtaaYggcagaMaaggg
+ttHaatatcaccVtagtggcgtMtagtcaYaaRttWgBtctgaaBtKattaatYtacaat
+cKcacNcMDtgtactatcDcgRtaaYagattgccMtgtYKaRaWHgtaccttagcRaWaa
+gDataccagcatcYtcaaSgVacatttaSttSVDSctactgaNctatVattttacgaggW
+gtaaaKtcNgatgttgcaaNVttagRtttttRttYYaYcaaagcVDMaaRaRtccVcSat
+tttcaattagWattMMctataWatggtaagagRaaattYKKtgatagcMYgcVcgggSta
+ttacgBBctNtRgacaacYHctctNtataattBttStaRaaaatctgtWatcRacaaMta
+ttYttKtccaatcSttatgtaWttcgcaaWgtWNcBccRgtBagNgYtDctatccMaagt
+gcYMtYctYttgtcVaaHtatgcBaaBcgaataattcttcDaacaaacBtagWYaagcaV
+acYcKYttgSaKVcttccgcctcattctcaatgVgaaacatWWctgcagtttctttttMa
+gWttatRggcattattVaagaBBttatctattatMcNtaacagttgaaaBaRtaRRtNta
+taYNtttNtcctaVBtatNtNgBtaHHYDttKctaDctcaNcatgDaYatgYagaDcaHg
+actHgWWaagWtSttctagKaaggYtcataYgBtccRaggggaaaHagaacaDatgaaaa
+tcaKtattgWacgtcMSaacYaYgcWYNgagtaMgtSccgaaaaaatctggaMMRaaaat
+aatctaaacgatatgDaggaVKcttttaatgacBttNYttagtatDagYttWctttNgtH
+tcVtattHtcHacattatHgNStgtSaNaactVMcaatcccBHNatcttDtcgaKccKtt
+atttctVRaagttaMtaYtcttcatMYRctttRtaMgSaaaactgWacHagtacccattt
+cgcatgagtaaagtHcaKgVBtaattatBtttWatgMctccattgactattcttgtcatS
+ttaaHaVtKtDcatcatatccaacKatattatNggNaRatcMSDHRtcctYRaatccacY
+aatBattcttBVctatatttRNtgaNtcaaaRgtaBcttaaDRcgctacWcttgatatct
+HttttgtNtYatatacgaVBgYHgattgggtcgacacDtttKVcaattWRcaagBtgctD
+KDaYtttcKgNgggtcacVagatMgtMVgVgatttcagtcgtgKgtKYgtYSaMtgataa
+tNggattKNgaSggactaaBagataacactcataVgttataaSacaatcRRaagtaDaag
+DYtcactgtgaVttWtBaMttttgaHtKaYtattccagccaaBaggataaRtBatNcatg
+tatatttcttacaaYVNatagaaagaSaaaagaaatSaBgtcgattacattgWccttHNa
+ttataacgVRDtYcWgaaYaVgMttcttgtDtKaYVttctgggSNtaYHWaaHactaaSS
+agttgSaaactYaMttaMaHVRtcgattaccHtcgcgatgNcaYtatattacgcHaaaMN
+MtaYDgacaggRgaYVtVKcaSVcWMBBaWaWcagtatHaWBNaMcBtatccatgaScHt
+YtgactcattgaYatRtacttYtctttgBgtattaaDtcaHgcNcaVatagtttggggRa
+aaccWcNNttRBgaaRKgaaNtMaagcVacgtgttaaMYWtcBYtgagtaatcgttttaa
+tcgaaaagttDcaatgtggtBaBcNtgNatBtggactttagYttBcgttRttatSgacNa
+DttatRKacactgcSKaVaaaRgHaattaaaRctgatKaWcctWggWWagccgaactaYc
+cttgtgaBHggcYttttBccttaggaKtaaaBacVDcBYYgaWagaKtaHaaactaNtta
+tagtcttttacgaccctttKattWcgHgcaDccctHttatVVaagKaatatgggMaNHag
+attgNStatBatcgaaYgcVcagaatcctcYtBKDatatcNKgacaatKDatgaaacgaa
+atYYcgNBDtataatMcRWtaagtataHgMaVggcaaDtggttcVattattaaaatSVaM
+aNcDBttataYgttttStacattgagagtccaNtgaatttttKtStatatttRaatttcg
+BDccctaaSWatttaaMBStcatacctgctctatctatKatatgaacaactctWBaNagt
+cgYaaaaRtctMtDgtaBaacaNtacagtcgataNgaVccgtttattatgatctagtDSg
+aHNcctKtcttatNtgatYKaaStctWDVcaaccgaVttScaagaaaaVcccggagWatc
+VaNtVaRcNtcagatcMMatactaaaWaagatYHRWcaSagcgMtttatSBtBtBgacRa
+VgtgattaagtBgtatcgtNggggDaWgagctgatctatttHaactttcgcttttccatt
+tNaaYgtattttactttacttRataBttgatagggacattattaaSaaaYtgatggaDaM
+ttacttatttttttaaWttttaataaWaNaattgtaBtBMcatcNtaaMtDaaaatcRgc
+atccaMtggWggHggagSttacaYHatYtgtaatcatttgVtataaDVttcaYttctHtH
+tagttWHNYYtVRVccatacaattaaaYatcgcatBagcaatDaWacVaBWattagaaBa
+taatgtKaaaNKcagaactNaagaNatgKtBSctgattgWcNaaSataggtataaacVaa
+tDttcRaRtVtVtgtataagMtSccaSScagttgatYattcagcMaaWctaagtYcSatt
+NccgtcgtaBtaattgttgacaaaDttttattaatacSKtcgcatNttatWatacgRtgc
+ataactYtcacHgVgHttYaataaWacgSVKatactagDggcattKctggataagtVgKY
+tatgttagcgtaRtttaaagacHgacacattcHKaMKtcgKtcacggtgatcaaBtMttc
+ttattcttDaKKVgWagtaacatgKatVgacattagWtaRtaccRaaVHtttttRtgBcc
+agtcgctagtRtaBcMVWMtaBtaggttaYcttagaSgYgttttcaaNNgtttVaagctg
+StttactaacWattcgtVgtgtKcgtYaaaaaKtaSaattgBtYgaVcagKatgaMttWD
+RatgtaatctagacWaccgcaNgtctgtgagtMttgaaatNtttattaRKcgtaWatcaW
+ccaKtttNactaatNcgVaaBcgRgDttcDcatttgagWNattttNaYtttatgcHtttB
+BacgttgRgtcataNtatatcaWVcatgaacatRgtNaWaatcaggttaaSctttcaaca
+tHttVKaHtNtMtcttcHattYatcgatgtacSaaataVtcttYStaagattDagtKccg
+accHBYatMtcggBacatVtaaagMcttBgtSagKgNttttcNtSaaMaStHgtattttK
+aRttaMtDtcKtcgagDKgaaaacttaaaWNaattgaWWaaggaaacKtttVggMBcata
+ttDacctaMgaaKgcgcaaMRtaatcgataaatRDttataNtVgtaVDggttaNgatBgt
+ggcaaYWtagctcWgtSaacgtattKcgcBtttDacaaaaaStKMtatNccagKatgtVt
+HtWaSBgDttgWgaattWagttttaagcctNcttaBtYttaRactaattggagagggtct
+agtatgggtttacttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtcttt
+ataattcBgtcgtactDtDagcctatttSVHtHttKtgtHMaSattgWaHKHttttagac
+atWatgtRgaaaNtactMcSMtYtcMgRtacttctWBacgaaatatagScDtttgaagac
+acatagtVgYgtcattHWtMMWcStgttaggKtSgaYaaccWStcgBttgcgaMttBYat
+cWtgacaYcagagtaBDtRacttttcWatMttDBcatWtatcttactaBgaYtcttgttt
+tttttYaaScYaHgtgttNtSatcMtcVaaaStccRcctDaataataStcYtRDSaMtDt
+tgttSagtRRcatttHatSttMtWgtcgtatSSagactYaaattcaMtWatttaSgYtta
+RgKaRtccactttattRggaMcDaWaWagttttgacatgttctacaaaRaatataataaM
+ttcgDacgaSStacaStYRctVaNMtMgtaggcKatcttttattaaaaagVWaHKYagtt
+tttatttaaccttacgtVtcVaattVMBcttaMtttaStgacttagattWWacVtgWYag
+WVRctDattBYtgtttaagaagattattgacVatMaacattVctgtBSgaVtgWWggaKH
+aatKWcBScSWaaccRVacacaaactaccScattRatatKVtactatatttHttaagttt
+SKtRtacaaagtRDttcaaaaWgcacatWaDgtDKacgaacaattacaRNWaatHtttSt
+gttattaaMtgttgDcgtMgcatBtgcttcgcgaDWgagctgcgaggggVtaaScNattt
+acttaatgacagcccccacatYScaMgtaggtYaNgttctgaMaacNaMRaacaaacaKc
+tacatagYWctgttWaaataaaataRattagHacacaagcgKatacBttRttaagtattt
+ccgatctHSaatactcNttMaagtattMtgRtgaMgcataatHcMtaBSaRattagttga
+tHtMttaaKaggYtaaBataSaVatactWtataVWgKgttaaaacagtgcgRatatacat
+VtHRtVYataSaKtWaStVcNKHKttactatccctcatgWHatWaRcttactaggatcta
+taDtDHBttataaaaHgtacVtagaYttYaKcctattcttcttaataNDaaggaaaDYgc
+ggctaaWSctBaaNtgctggMBaKctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgR
+tcaaNtYaNacggtttNattgVtttctgtBaWgtaattcaagtcaVWtactNggattctt
+taYtaaagccgctcttagHVggaYtgtNcDaVagctctctKgacgtatagYcctRYHDtg
+BattDaaDgccKtcHaaStttMcctagtattgcRgWBaVatHaaaataYtgtttagMDMR
+taataaggatMtttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtcattttcWattRS
+HcVagaagtacgggtaKVattKYagactNaatgtttgKMMgYNtcccgSKttctaStata
+tNVataYHgtNaBKRgNacaactgatttcctttaNcgatttctctataScaHtataRagt
+cRVttacDSDttaRtSatacHgtSKacYagttMHtWataggatgactNtatSaNctataV
+tttRNKtgRacctttYtatgttactttttcctttaaacatacaHactMacacggtWataM
+tBVacRaSaatccgtaBVttccagccBcttaRKtgtgcctttttRtgtcagcRttKtaaa
+cKtaaatctcacaattgcaNtSBaaccgggttattaaBcKatDagttactcttcattVtt
+tHaaggctKKgatacatcBggScagtVcacattttgaHaDSgHatRMaHWggtatatRgc
+cDttcgtatcgaaacaHtaagttaRatgaVacttagattVKtaaYttaaatcaNatccRt
+tRRaMScNaaaDgttVHWgtcHaaHgacVaWtgttScactaagSgttatcttagggDtac
+cagWattWtRtgttHWHacgattBtgVcaYatcggttgagKcWtKKcaVtgaYgWctgYg
+gVctgtHgaNcVtaBtWaaYatcDRaaRtSctgaHaYRttagatMatgcatttNattaDt
+taattgttctaaccctcccctagaWBtttHtBccttagaVaatMcBHagaVcWcagBVtt
+cBtaYMccagatgaaaaHctctaacgttagNWRtcggattNatcRaNHttcagtKttttg
+WatWttcSaNgggaWtactKKMaacatKatacNattgctWtatctaVgagctatgtRaHt
+YcWcttagccaatYttWttaWSSttaHcaaaaagVacVgtaVaRMgattaVcDactttcH
+HggHRtgNcctttYatcatKgctcctctatVcaaaaKaaaagtatatctgMtWtaaaaca
+StttMtcgactttaSatcgDataaactaaacaagtaaVctaggaSccaatMVtaaSKNVa
+ttttgHccatcacBVctgcaVatVttRtactgtVcaattHgtaaattaaattttYtatat
+taaRSgYtgBagaHSBDgtagcacRHtYcBgtcacttacactaYcgctWtattgSHtSat
+cataaatataHtcgtYaaMNgBaatttaRgaMaatatttBtttaaaHHKaatctgatWat
+YaacttMctcttttVctagctDaaagtaVaKaKRtaacBgtatccaaccactHHaagaag
+aaggaNaaatBWattccgStaMSaMatBttgcatgRSacgttVVtaaDMtcSgVatWcaS
+atcttttVatagttactttacgatcaccNtaDVgSRcgVcgtgaacgaNtaNatatagtH
+tMgtHcMtagaaattBgtataRaaaacaYKgtRccYtatgaagtaataKgtaaMttgaaR
+VatgcagaKStctHNaaatctBBtcttaYaBWHgtVtgacagcaRcataWctcaBcYacY
+gatDgtDHcctaaagacYRcaggattHaYgtKtaatgcVcaataMYacccatatcacgWD
+BtgaatcBaatacKcttRaRtgatgaBDacggtaattaaYtataStgVHDtDctgactca
+aatKtacaatgcgYatBtRaDatHaactgtttatatDttttaaaKVccYcaaccNcBcgH
+aaVcattHctcgattaaatBtatgcaaaaatYMctSactHatacgaWacattacMBgHtt
+cgaatVaaaacaBatatVtctgaaaaWtctRacgBMaatSgRgtgtcgactatcRtatta
+ScctaStagKgaDcWgtYtDDWKRgRtHatRtggtcgaHgggcgtattaMgtcagccaBg
+gWVcWctVaaattcgNaatcKWagcNaHtgaaaSaaagctcYctttRVtaaaatNtataa
+ccKtaRgtttaMtgtKaBtRtNaggaSattHatatWactcagtgtactaKctatttgRYY
+atKatgtccgtRtttttatttaatatVgKtttgtatgtNtataRatWYNgtRtHggtaaK
+aYtKSDcatcKgtaaYatcSRctaVtSMWtVtRWHatttagataDtVggacagVcgKWag
+BgatBtaaagNcaRtagcataBggactaacacRctKgttaatcctHgDgttKHHagttgt
+taatgHBtatHcDaagtVaBaRccctVgtgDtacRHSctaagagcggWYaBtSaKtHBta
+aactYacgNKBaVYgtaacttagtVttcttaatgtBtatMtMtttaattaatBWccatRt
+ttcatagVgMMtagctStKctaMactacDNYgKYHgaWcgaHgagattacVgtttgtRaS
+ttaWaVgataatgtgtYtaStattattMtNgWtgttKaccaatagNYttattcgtatHcW
+tctaaaNVYKKttWtggcDtcgaagtNcagatacgcattaagaccWctgcagcttggNSg
+aNcHggatgtVtcatNtRaaBNcHVagagaaBtaaSggDaatWaatRccaVgggStctDa
+acataKttKatttggacYtattcSatcttagcaatgaVBMcttDattctYaaRgatgcat
+tttNgVHtKcYRaatRKctgtaaacRatVSagctgtWacBtKVatctgttttKcgtctaa
+DcaagtatcSataWVgcKKataWaYttcccSaatgaaaacccWgcRctWatNcWtBRttY
+aattataaNgacacaatagtttVNtataNaYtaatRaVWKtBatKagtaatataDaNaaa
+aataMtaagaaStccBcaatNgaataWtHaNactgtcDtRcYaaVaaaaaDgtttRatct
+atgHtgttKtgaaNSgatactttcgagWaaatctKaaDaRttgtggKKagcDgataaatt
+gSaacWaVtaNMacKtcaDaaatttctRaaVcagNacaScRBatatctRatcctaNatWg
+RtcDcSaWSgttRtKaRtMtKaatgttBHcYaaBtgatSgaSWaScMgatNtctcctatt
+tctYtatMatMtRRtSaattaMtagaaaaStcgVgRttSVaScagtgDtttatcatcata
+cRcatatDcttatcatVRtttataaHtattcYtcaaaatactttgVctagtaaYttagat
+agtSYacKaaacgaaKtaaatagataatSatatgaaatSgKtaatVtttatcctgKHaat
+HattagaaccgtYaaHactRcggSBNgtgctaaBagBttgtRttaaattYtVRaaaattg
+taatVatttctcttcatgBcVgtgKgaHaaatattYatagWacNctgaaMcgaattStag
+WaSgtaaKagttttaagaDgatKcctgtaHtcatggKttVDatcaaggtYcgccagNgtg
+cVttttagagatgctaccacggggtNttttaSHaNtatNcctcatSaaVgtactgBHtag
+caYggYVKNgtaKBcRttgaWatgaatVtagtcgattYgatgtaatttacDacSctgcta
+aaStttaWMagDaaatcaVYctccgggcgaVtaaWtStaKMgDtttcaaMtVgBaatcca
+gNaaatcYRMBggttWtaaScKttMWtYataRaDBMaDataatHBcacDaaKDactaMga
+gttDattaHatHtaYatDtattDcRNStgaatattSDttggtattaaNSYacttcDMgYg
+BatWtaMagactVWttctttgYMaYaacRgHWaattgRtaagcattctMKVStatactac
+HVtatgatcBtVNataaBttYtSttacKgggWgYDtgaVtYgatDaacattYgatggtRD
+aVDttNactaSaMtgNttaacaaSaBStcDctaccacagacgcaHatMataWKYtaYatt
+McaMtgSttDagcHacgatcaHttYaKHggagttccgatYcaatgatRaVRcaagatcag
+tatggScctatattaNtagcgacgtgKaaWaactSgagtMYtcttccaKtStaacggMta
+agNttattatcgtctaRcactctctDtaacWYtgaYaSaagaWtNtatttRacatgNaat
+gttattgWDDcNaHcctgaaHacSgaataaRaataMHttatMtgaSDSKatatHHaNtac
+agtccaYatWtcactaactatKDacSaStcggataHgYatagKtaatKagStaNgtatac
+tatggRHacttgtattatgtDVagDVaRctacMYattDgtttYgtctatggtKaRSttRc
+cRtaaccttagagRatagSaaMaacgcaNtatgaaatcaRaagataatagatactcHaaY
+KBctccaagaRaBaStNagataggcgaatgaMtagaatgtcaKttaaatgtaWcaBttaa
+tRcggtgNcacaaKtttScRtWtgcatagtttWYaagBttDKgcctttatMggNttattB
+tctagVtacataaaYttacacaaRttcYtWttgHcaYYtaMgBaBatctNgcDtNttacg
+acDcgataaSatYaSttWtcctatKaatgcagHaVaacgctgcatDtgttaSataaaaYS
+NttatagtaNYtaDaaaNtggggacttaBggcHgcgtNtaaMcctggtVtaKcgNacNta
+tVaSWctWtgaWcggNaBagctctgaYataMgaagatBSttctatacttgtgtKtaattt
+tRagtDtacatatatatgatNHVgBMtKtaKaNttDHaagatactHaccHtcatttaaag
+ttVaMcNgHatatKtaNtgYMccttatcaaNagctggacStttcNtggcaVtattactHa
+SttatgNMVattMMDtMactattattgWMSgtHBttStStgatatRaDaagattttctat
+MtaaaaaggtactaaVttaSacNaatactgMttgacHaHRttgMacaaaatagttaatat
+WKRgacDgaRtatatttattatcYttaWtgtBRtWatgHaaattHataagtVaDtWaVaW
+tgStcgtMSgaSRgMKtaaataVacataatgtaSaatttagtcgaaHtaKaatgcacatc
+ggRaggSKctDcagtcSttcccStYtccRtctctYtcaaKcgagtaMttttcRaYDttgt
+tatctaatcataNctctgctatcaMatactataggDaHaaSttMtaDtcNatataattct
+McStaaBYtaNagatgtaatHagagSttgWHVcttatKaYgDctcttggtgttMcRaVgS
+gggtagacaataaDtaattSaDaNaHaBctattgNtaccaaRgaVtKNtaaYggHtaKKg
+HcatctWtctDtttctttggSDtNtaStagttataaacaattgcaBaBWggHgcaaaBtY
+gctaatgaaatWcDcttHtcMtWWattBHatcatcaaatctKMagtDNatttWaBtHaaa
+NgMttaaStagttctctaatDtcRVaYttgttMtRtgtcaSaaYVgSWDRtaatagctca
+gDgcWWaaaBaaRaBctgVgggNgDWStNaNBKcBctaaKtttDcttBaaggBttgacca
+tgaaaNgttttttttatctatgttataccaaDRaaSagtaVtDtcaWatBtacattaWac
+ttaSgtattggDgKaaatScaattacgWcagKHaaccaYcRcaRttaDttRtttHgaHVg
+gcttBaRgtccctDatKaVtKtcRgYtaKttacgtatBtStaagcaattaagaRgBagSa
+attccSWYtttattVaataNctgHgttaaNBgcVYgtRtcccagWNaaaacaDNaBcaaa
+aRVtcWMgBagMtttattacgDacttBtactatcattggaaatVccggttRttcatagtt
+VYcatYaSHaHcttaaagcNWaHataaaRWtctVtRYtagHtaaaYMataHYtNBctNtK
+aatattStgaMcBtRgctaKtgcScSttDgYatcVtggaaKtaagatWccHccgKYctaN
+NctacaWcttttgcRtgtVcgaKttcMRHgctaHtVaataaDtatgKDcttatBtDttgg
+NtacttttMtgaacRattaaNagaactcaaaBBVtcDtcgaStaDctgaaaSgttMaDtc
+gttcaccaaaaggWtcKcgSMtcDtatgtttStaaBtatagDcatYatWtaaaBacaKgc
+aDatgRggaaYctaRtccagattDaWtttggacBaVcHtHtaacDacYgtaatataMaga
+atgHMatcttatacgtatttttatattacHactgttataMgStYaattYaccaattgagt
+caaattaYtgtatcatgMcaDcgggtcttDtKgcatgWRtataatatRacacNRBttcHt
+BgcRttgtgcgtcatacMtttBctatctBaatcattMttMYgattaaVYatgDaatVagt
+attDacaacDMatcMtHcccataagatgBggaccattVWtRtSacatgctcaaggggYtt
+tDtaaNgNtaaBatggaatgtctRtaBgBtcNYatatNRtagaacMgagSaSDDSaDcct
+RagtVWSHtVSRggaacaBVaccgtttaStagaacaMtactccagtttVctaaRaaHttN
+cttagcaatttattaatRtaaaatctaacDaBttggSagagctacHtaaRWgattcaaBt
+ctRtSHaNtgtacattVcaHaNaagtataccacaWtaRtaaVKgMYaWgttaKggKMtKc
+gWatcaDatYtKSttgtacgaccNctSaattcDcatcttcaaaDKttacHtggttHggRR
+aRcaWacaMtBWVHSHgaaMcKattgtaRWttScNattBBatYtaNRgcggaagacHSaa
+ttRtttcYgaccBRccMacccKgatgaacttcgDgHcaaaaaRtatatDtatYVtttttH
+gSHaSaatagctNYtaHYaVYttattNtttgaaaYtaKttWtctaNtgagaaaNctNDct
+aaHgttagDcRttatagccBaacgcaRBtRctRtggtaMYYttWtgataatcgaataatt
+attataVaaaaattacNRVYcaaMacNatRttcKatMctgaagactaattataaYgcKca
+SYaatMNctcaacgtgatttttBacNtgatDccaattattKWWcattttatatatgatBc
+DtaaaagttgaaVtaHtaHHtBtataRBgtgDtaataMttRtDgDcttattNtggtctat
+ctaaBcatctaRatgNacWtaatgaagtcMNaacNgHttatactaWgcNtaStaRgttaa
+HacccgaYStacaaaatWggaYaWgaattattcMaactcBKaaaRVNcaNRDcYcgaBct
+KaacaaaaaSgctccYBBHYaVagaatagaaaacagYtctVccaMtcgtttVatcaattt
+DRtgWctagtacRttMctgtDctttcKtWttttataaatgVttgBKtgtKWDaWagMtaa
+agaaattDVtaggttacatcatttatgtcgMHaVcttaBtVRtcgtaYgBRHatttHgaB
+cKaYWaatcNSctagtaaaaatttacaatcactSWacgtaatgKttWattagttttNagg
+tctcaagtcactattcttctaagKggaataMgtttcataagataaaaatagattatDgcB
+VHWgaBKttDgcatRHaagcaYcRaattattatgtMatatattgHDtcaDtcaaaHctSt
+attaatHaccgacNattgatatattttgtgtDtRatagSacaMtcRtcattcccgacacS
+attgttKaWattNHcaacttccgtttSRtgtctgDcgctcaaMagVtBctBMcMcWtgta
+acgactctcttRggRKSttgYtYatDccagttDgaKccacgVatWcataVaaagaataMg
+tgataaKYaaatcHDaacgataYctRtcYatcgcaMgtNttaBttttgatttaRtStgca
+acaaaataccVgaaDgtVgDcStctatatttattaaaaRKDatagaaagaKaaYYcaYSg
+KStctccSttacagtcNactttDVttagaaagMHttRaNcSaRaMgBttattggtttaRM
+ggatggcKDgWRtNaataataWKKacttcKWaaagNaBttaBatMHtccattaacttccc
+cYtcBcYRtagattaagctaaYBDttaNtgaaaccHcaRMtKtaaHMcNBttaNaNcVcg
+VttWNtDaBatgataaVtcWKcttRggWatcattgaRagHgaattNtatttctctattaa
+ttaatgaDaaMatacgttgggcHaYVaaNaDDttHtcaaHtcVVDgBVagcMacgtgtta
+aBRNtatRtcagtaagaggtttaagacaVaaggttaWatctccgtVtaDtcDatttccVa
+tgtacNtttccgtHttatKgScBatgtVgHtYcWagcaKtaMYaaHgtaattaSaHcgca
+gtWNaatNccNNYcacgVaagaRacttctcattcccRtgtgtaattagcSttaaStWaMt
+ctNNcSMacattataaactaDgtatWgtagtttaagaaaattgtagtNagtcaataaatt
+tgatMMYactaatatcggBWDtVcYttcDHtVttatacYaRgaMaacaStaatcRttttV
+tagaDtcacWatttWtgaaaagaaagNRacDtttStVatBaDNtaactatatcBSMccca
+SttccggaMatgattaaWatKMaBaBatttgataNctgttKtVaagtcagScgaaaDgga
+WgtgttttKtWtatttHaatgtagttcactaaKMagttSYBtKtaYgaactcagagRtat
+agtVtatcaaaWYagcgNtaDagtacNSaaYDgatBgtcgataacYDtaaactacagWDc
+YKaagtttattagcatcgagttKcatDaattgattatDtcagRtWSKtcgNtMaaaaaca
+MttKcaWcaaSVMaaaccagMVtaMaDtMaHaBgaacataBBVtaatVYaNSWcSgNtDN
+aaKacacBtttatKtgtttcaaHaMctcagtaacgtcgYtactDcgcctaNgagagcYga
+tattttaaatttccattttacatttDaaRctattttWctttacgtDatYtttcagacgca
+aVttagtaaKaaaRtgVtccataBggacttatttgtttaWNtgttVWtaWNVDaattgta
+tttBaagcBtaaBttaaVatcHcaVgacattccNggtcgacKttaaaRtagRtctWagaY
+ggtgMtataatMtgaaRttattttgWcttNtDRRgMDKacagaaaaggaaaRStcccagt
+YccVattaNaaKStNWtgacaVtagaagcttSaaDtcacaacgDYacWDYtgtttKatcV
+tgcMaDaSKStVcgtagaaWaKaagtttcHaHgMgMtctataagBtKaaaKKcactggag
+RRttaagaBaaNatVVcgRcKSttDaactagtSttSattgttgaaRYatggttVttaata
+aHttccaagDtgatNWtaagHtgcYtaactRgcaatgMgtgtRaatRaNaacHKtagact
+actggaatttcgccataacgMctRgatgttaccctaHgtgWaYcactcacYaattcttaB
+tgacttaaacctgYgaWatgBttcttVttcgttWttMcNYgtaaaatctYgMgaaattac
+NgaHgaacDVVMtttggtHtctaaRgtacagacgHtVtaBMNBgattagcttaRcttaca
+HcRctgttcaaDBggttKaacatgKtttYataVaNattccgMcgcgtagtRaVVaattaK
+aatggttRgaMcagtatcWBttNtHagctaatctagaaNaaacaYBctatcgcVctBtgc
+aaagDgttVtgaHtactSNYtaaNccatgtgDacgaVtDcgKaRtacDcttgctaagggc
+agMDagggtBWRtttSgccttttttaacgtcHctaVtVDtagatcaNMaVtcVacatHct
+DWNaataRgcgtaVHaggtaaaaSgtttMtattDgBtctgatSgtRagagYtctSaKWaa
+taMgattRKtaacatttYcgtaacacattRWtBtcggtaaatMtaaacBatttctKagtc
+DtttgcBtKYYBaKttctVttgttaDtgattttcttccacttgSaaacggaaaNDaattc
+YNNaWcgaaYattttMgcBtcatRtgtaaagatgaWtgaccaYBHgaatagataVVtHtt
+tVgYBtMctaMtcctgaDcYttgtccaaaRNtacagcMctKaaaggatttacatgtttaa
+WSaYaKttBtagDacactagctMtttNaKtctttcNcSattNacttggaacaatDagtat
+tRtgSHaataatgccVgacccgatactatccctgtRctttgagaSgatcatatcgDcagW
+aaHSgctYYWtatHttggttctttatVattatcgactaagtgtagcatVgtgHMtttgtt
+tcgttaKattcMatttgtttWcaaStNatgtHcaaaDtaagBaKBtRgaBgDtSagtatM
+taacYaatYtVcKatgtgcaacVaaaatactKcRgtaYtgtNgBBNcKtcttaccttKga
+RaYcaNKtactttgagSBtgtRagaNgcaaaNcacagtVtttHWatgttaNatBgtttaa
+tNgVtctgaatatcaRtattcttttttttRaaKcRStctcggDgKagattaMaaaKtcaH
+acttaataataKtaRgDtKVBttttcgtKaggHHcatgttagHggttNctcgtatKKagV
+agRaaaggaaBtNatttVKcRttaHctaHtcaaatgtaggHccaBataNaNaggttgcWa
+atctgatYcaaaHaatWtaVgaaBttagtaagaKKtaaaKtRHatMaDBtBctagcatWt
+atttgWttVaaaScMNattRactttgtYtttaaaagtaagtMtaMaSttMBtatgaBttt
+aKtgaatgagYgtNNacMtcNRacMMHcttWtgtRtctttaacaacattattcYaMagBa
+acYttMatcttKcRMtgMNccattaRttNatHaHNaSaaHMacacaVaatacaKaSttHa
+tattMtVatWgattttttaYctttKttHgScWaacgHtttcaVaaMgaacagNatcgtta
+acaaaaagtacaHBNaattgttKtcttVttaaBtctgctacgBgcWtttcaggacacatM
+gacatcccagcggMgaVKaBattgacttaatgacacacaaaaaatRKaaBctacgtRaDc
+gtagcVBaacDSBHaaaaSacatatacagacRNatcttNaaVtaaaataHattagtaaaa
+SWccgtatWatggDttaactattgcccatcttHaSgYataBttBaactattBtcHtgatc
+aataSttaBtatKSHYttWggtcYtttBttaataccRgVatStaHaKagaatNtagRMNg
+tcttYaaSaactcagDSgagaaYtMttDtMRVgWKWtgMaKtKaDttttgactatacata
+atcNtatNaHattVagacgYgatatatttttgtStWaaatctWaMgagaRttRatacgSt
+gattcttaagaDtaWccaaatRcagcagaaNKagtaaDggcgccBtYtagSBMtactaaa
+taMataBSacRMgDgattMMgtcHtcaYDtRaDaacggttDaggcMtttatgttaNctaa
+ttaVacgaaMMtaatDccSgtattgaRtWWaccaccgagtactMcgVNgctDctaMScat
+agcgtcaactatacRacgHRttgctatttaatgaattataYKttgtaagWgtYttgcHgM
+taMattWaWVtaRgcttgYgttBHtYataSccStBtgtagMgtDtggcVaaSBaatagDt
+tgBgtctttctcattttaNagtHKtaMWcYactVcgcgtatMVtttRacVagDaatcttg
+ctBBcRDgcaacKttgatSKtYtagBMagaRtcgBattHcBWcaactgatttaatttWDc
+catttatcgagSKaWttataHactaHMttaatHtggaHtHagaatgtKtaaRactgtttM
+atacgatcaagDgatKaDctataMggtHDtggHacctttRtatcttYattttgacttgaa
+SaataaatYcgBaaaaccgNatVBttMacHaKaataagtatKgtcaagactcttaHttcg
+gaattgttDtctaaccHttttWaaatgaaatataaaWattccYDtKtaaaacggtgaggW
+VtctattagtgactattaagtMgtttaagcatttgSgaaatatccHaaggMaaaattttc
+WtatKctagDtYtMcctagagHcactttactatacaaacattaacttaHatcVMYattYg
+VgtMttaaRtgaaataaDatcaHgtHHatKcDYaatcttMtNcgatYatgSaMaNtcttK
+cWataScKggtatcttacgcttWaaagNatgMgHtctttNtaacVtgttcMaaRatccgg
+ggactcMtttaYMtcWRgNctgNccKatcttgYDcMgattNYaRagatHaaHgKctcata
+RDttacatBatccattgDWttatttaWgtcggagaaaaatacaatacSNtgggtttcctt
+acSMaagBattacaMaNcactMttatgaRBacYcYtcaaaWtagctSaacttWgDMHgag
+gatgBVgcHaDtggaactttggtcNatNgtaKaBcccaNtaagttBaacagtatacDYtt
+cctNgWgcgSMcacatStctHatgRcNcgtacacaatRttMggaNKKggataaaSaYcMV
+cMgtaMaHtgattYMatYcggtcttcctHtcDccgtgRatcattgcgccgatatMaaYaa
+taaYSggatagcgcBtNtaaaScaKgttBgagVagttaKagagtatVaactaSacWactS
+aKatWccaKaaaatBKgaaKtDMattttgtaaatcRctMatcaaMagMttDgVatggMaa
+WgttcgaWatgaaatttgRtYtattaWHKcRgctacatKttctaccaaHttRatctaYat
+taaWatVNccatNgagtcKttKataStRaatatattcctRWatDctVagttYDgSBaatY
+gttttgtVaatttaatagcagMatRaacttBctattgtMagagattaaactaMatVtHta
+aatctRgaaaaaaaatttWacaacaYccYDSaattMatgaccKtaBKWBattgtcaagcH
+KaagttMMtaatttcKcMagNaaKagattggMagaggtaatttYacatcWaaDgatMgKH
+acMacgcVaacaDtaDatatYggttBcgtatgWgaSatttgtagaHYRVacaRtctHaaR
+tatgaactaatatctSSBgggaaHMWtcaagatKgagtDaSatagttgattVRatNtctM
+tcSaagaSHaataNataataRaaRgattctttaataaagWaRHcYgcatgtWRcttgaag
+gaMcaataBRaaccagStaaacNtttcaatataYtaatatgHaDgcStcWttaacctaRg
+tYaRtataKtgMttttatgactaaaatttacYatcccRWtttHRtattaaatgtttatat
+ttgttYaatMcaRcSVaaDatcgtaYMcatgtagacatgaaattgRtcaaYaaYtRBatK
+acttataccaNaaattVaBtctggacaagKaaYaaatatWtMtatcYaaVNtcgHaactB
+aagKcHgtctacaatWtaDtSgtaHcataHtactgataNctRgttMtDcDttatHtcgta
+catcccaggSttaBgtcacacWtccNMcNatMVaVgtccDYStatMaccDatggYaRKaa
+agataRatttHKtSaaatDgataaacttaHgttgVBtcttVttHgDacgaKatgtatatN
+YataactctSatatatattgcHRRYttStggaactHgttttYtttaWtatMcttttctat
+ctDtagVHYgMRBgtHttcctaatYRttKtaagatggaVRataKDctaMtKBNtMtHNtW
+tttYcVtattMcgRaacMcctNSctcatttaaagDcaHtYccSgatgcaatYaaaaDctt
+cgtaWtaattctcgttttScttggtaatctttYgtctaactKataHacctMctcttacHt
+KataacacagcNRatgKatttttSaaatRYcgDttaMRcgaaattactMtgcgtaagcgt
+tatBtttttaattaagtNacatHgttcRgacKcBBtVgatKttcgaBaatactDRgtRtg
+aNacWtcacYttaaKcgttctHaKttaNaMgWgWaggtctRgaKgWttSttBtDcNtgtt
+tacaaatYcDRtgVtgcctattcNtctaaaDMNttttNtggctgagaVctDaacVtWcca
+agtaacacaNctgaScattccDHcVBatcgatgtMtaatBgHaatDctMYgagaatgYWK
+cctaatNaStHaaaKccgHgcgtYaaYtattgtStgtgcaaRtattaKatattagaWVtc
+aMtBagttattagNaWHcVgcaattttDcMtgtaRHVYtHtctgtaaaaHVtMKacatcg
+NaatttMatatgttgttactagWYtaRacgataKagYNKcattataNaRtgaacKaYgca
+aYYacaNccHatMatDcNgtHttRaWttagaaDcaaaaaatagggtKDtStaDaRtaVtH
+WKNtgtattVctSVgRgataDaRaWataBgaagaaKtaataaYgDcaStaNgtaDaaggt
+attHaRaWMYaYaWtggttHYgagVtgtgcttttcaaDKcagVcgttagacNaaWtagta
+ataDttctggttVcatcataaagtgKaaaNaMtaBBaattaatWaattgctHaVKaSgDa
+aVKaHtatatatHatcatSBagNgHtatcHYMHgttDgtaHtBttWatcgtttaRaattg
+StKgSKNWKatcagDtctcagatttctRtYtBatBgHHtKaWtgYBgacVVWaKtacKcD
+ttKMaKaVcggtgttataagaataaHaatattagtataatMHgttYgaRttagtaRtcaa
+VatacggtcMcgagtaaRttacWgactKRYataaaagSattYaWgagatYagKagatgSa
+agKgttaatMggtataatgttWYttatgagaaacctNVataatHcccKtDctcctaatac
+tggctHggaSaggRtKHaWaattcgSatMatttagaggcYtctaMcgctcataSatatgR
+agacNaaDaggaVBagaYttKtacNaKgtSYtagttggaWcatcWttaatctatgaVtcg
+tgtMtatcaYcgtRccaaYgDctgcMgtgtWgacWtgataacacgcgctBtgttaKtYDt
+atDcatcagKaVMctaatcttgVcaaRgcRMtDcgattaHttcaNatgaatMtactacVg
+tRgatggaWtttactaaKatgagSaaKggtaNtactVaYtaaKRagaacccacaMtaaMt
+KtatBcttgtaaWBtMctaataaVcDaaYtcRHBtcgttNtaaHatttBNgRStVDattB
+atVtaagttaYatVattaagaBcacggtSgtVtatttaRattgatgtaHDKgcaatattK
+tggcctatgaWDKRYcggattgRctatNgatacaatMNttctgtcRBYRaaaHctNYatt
+cHtaWcaattctBtMKtVgYataatMgYtcagcttMDataVtggRtKtgaatgccNcRtt
+caMtRgattaacattRcagcctHtWMtgtDRagaKaBtgDttYaaaaKatKgatctVaaY
+aacWcgcatagBVtaNtRtYRaggBaaBtgKgttacataagagcatgtRattccacttac
+catRaaatgWgDaMHaYVgVtaSctatcgKaatatattaDgacccYagtgtaYNaaatKc
+agtBRgagtccatgKgaaaccBgaagBtgSttWtacgatWHaYatcgatttRaaNRgcaN
+aKVacaNtDgattgHVaatcDaagcgtatgcNttaDataatcSataaKcaataaHWataB
+tttatBtcaKtKtatagttaDgSaYctacaRatNtaWctSaatatttYaKaKtaccWtat
+cRagacttaYttVcKgSDcgagaagatccHtaattctSttatggtKYgtMaHagVaBRat
+ttctgtRgtctatgggtaHKgtHacHtSYacgtacacHatacKaaBaVaccaDtatcSaa
+taaHaagagaatScagactataaRttagcaaVcaHataKgDacatWccccaagcaBgagW
+atctaYttgaaatctVNcYtttWagHcgcgcDcVaaatgttKcHtNtcaatagtgtNRaa
+ctttttcaatggWgBcgDtgVgtttctacMtaaataaaRggaaacWaHttaRtNtgctaa
+RRtVBctYtVtatDcattDtgaccYatagatYRKatNYKttNgcctagtaWtgaactaMV
+aacctgaStttctgaKVtaaVaRKDttVtVctaDNtataaaDtccccaagtWtcgatcac
+tDgYaBcatcctMtVtacDaaBtYtMaKNatNtcaNacgDatYcatcgcaRatWBgaacW
+ttKttagYtaattcggttgSWttttDWctttacYtatatWtcatDtMgtBttgRtVDggt
+taacYtacgtacatgaattgaaWcttMStaDgtatattgaDtcRBcattSgaaVBRgagc
+caaKtttcDgcgaSMtatgWattaKttWtgDBMaggBBttBaatWttRtgcNtHcgtttt
+HtKtcWtagHStaacagttgatatBtaWSaWggtaataaMttaKacDaatactcBttcaa
+tatHttcBaaSaaatYggtaRtatNtHcaatcaHtagVtgtattataNggaMtcttHtNa
+gctaaaggtagaYctMattNaMVNtcKtactBKcaHHcBttaSagaKacataYgctaKaY
+gttYcgacWVttWtSagcaacatcccHaccKtcttaacgaKttcacKtNtacHtatatRt
+aaatacactaBtttgaHaRttggttWtatYagcatYDatcggagagcWBataagRtacct
+ataRKgtBgatgaDatataSttagBaHtaatNtaDWcWtgtaattacagKttcNtMagta
+ttaNgtctcgtcctcttBaHaKcKccgtRcaaYagSattaagtKataDatatatagtcDt
+aacaWHcaKttDgaaRcgtgYttgtcatatNtatttttatggccHtgDtYHtWgttatYa
+acaattcaWtatNgctcaaaSttRgctaatcaaatNatcgtttaBtNNVtgttataagca
+aagattBacgtDatttNatttaaaDcBgtaSKgacgtagataatttcHMVNttgttBtDt
+gtaWKaaRMcKMtHtaVtagataWctccNNaSWtVaHatctcMgggDgtNHtDaDttata
+tVWttgttatttaacctttcacaaggaSaDcggttttttatatVtctgVtaacaStDVaK
+actaMtttaSNagtgaaattaNacttSKctattcctctaSagKcaVttaagNaVcttaVa
+aRNaHaaHttatgtHttgtgatMccaggtaDcgaccgtWgtWMtttaHcRtattgSccta
+tttKtaaccaagtYagaHgtWcHaatgccKNRtttagtMYSgaDatctgtgaWDtccMNc
+gHgcaaacNDaaaRaStDWtcaaaaHKtaNBctagBtgtattaactaattttVctagaat
+ggcWSatMacccttHttaSgSgtgMRcatRVKtatctgaaaccDNatYgaaVHNgatMgH
+RtacttaaaRtatStRtDtatDttYatattHggaBcttHgcgattgaKcKtttcRataMt
+cgaVttWacatNcatacctRataDDatVaWNcggttgaHtgtMacVtttaBHtgagVttM
+aataattatgttcttagtttgtgcDtSatttgBtcaacHattaaBagVWcgcaSYttMgc
+ttacYKtVtatcaYaKctgBatgcgggcYcaaaaacgNtctagKBtattatctttKtaVt
+tatagtaYtRagNtaYataaVtgaatatcHgcaaRataHtacacatgtaNtgtcgYatWM
+atttgaactacRctaWtWtatacaatctBatatgYtaagtatgtgtatSttactVatctt
+YtaBcKgRaSggRaaaaatgcagtaaaWgtaRgcgataatcBaataccgtatttttccat
+cNHtatWYgatHSaaaDHttgctgtccHtggggcctaataatttttctatattYWtcatt
+BtgBRcVttaVMRSgctaatMagtYtttaaaaatBRtcBttcaaVtaacagctccSaaSt
+tKNtHtKYcagcagaaaccccRtttttaaDcDtaStatccaagcgctHtatcttaDRYga
+tDHtWcaaaBcWgKWHttHataagHacgMNKttMKHccaYcatMVaacgttaKgYcaVaa
+BtacgcaactttMctaaHaatgtBatgagaSatgtatgSRgHgWaVWgataaatatttcc
+KagVgataattWaHNcYggaaatgctHtKtaDtctaaagtMaatVDVactWtSaaWaaMt
+aHtaSKtcBRaNcttStggtBttacNagcatagRgtKtgcgaacaacBcgKaatgataag
+atgaaaattgtactgcgggtccHHWHaaNacaBttNKtKtcaaBatatgctaHNgtKcDW
+gtttatNgVDHgaccaacWctKaaggHttgaRgYaatHcaBacaatgagcaaattactgt
+aVaaYaDtagattgagNKggtggtgKtWKaatacagDRtatRaMRtgattDggtcaaYRt
+atttNtagaDtcacaaSDctDtataatcgtactaHttatacaatYaacaaHttHatHtgc
+gatRRttNgcatSVtacWWgaaggagtatVMaVaaattScDDKNcaYBYaDatHgtctat
+BagcaacaagaatgagaaRcataaKNaRtBDatcaaacgcattttttaaBtcSgtacaRg
+gatgtMNaattggatatWtgagtattaaaVctgcaYMtatgatttttYgaHtgtcttaag
+WBttHttgtcttattDtcgtatWtataataSgctaHagcDVcNtaatcaagtaBDaWaDg
+tttagYctaNccDtaKtaHcttaataacccaRKtacaVaatNgcWRaMgaattatgaBaa
+agattVYaHMDcaDHtcRcgYtcttaaaWaaaVKgatacRtttRRKYgaatacaWVacVc
+RtatMacaBtactggMataaattttHggNagSctacHgtBagcgtcgtgattNtttgatS
+aaggMttctttcttNtYNagBtaaacaaatttMgaccttacataattgYtcgacBtVMct
+gStgMDtagtaRctHtatgttcatatVRNWataDKatWcgaaaaagttaaaagcacgHNa
+cgtaatctttMRtgacttttDacctataaacgaaatatgattagaactccSYtaBcttta
+ataacWgaaaYatagatgWttcatKtNgatttttcaagHtaYgaaRaDaagtaggagctt
+atVtagtctttcattaaaatcgKtattaRttacagVaDatgcatVgattgggtctttHVt
+agKaaRBtaHtaaggccccaaaaKatggtttaMWgtBtaaacttcactttKHtcgatctc
+cctaYaBacMgtcttBaBaNgcgaaacaatctagtHccHtKttcRtRVttccVctttcat
+acYagMVtMcagaMaaacaataBctgYtaatRaaagattaaccatVRatHtaRagcgcaB
+cgDttStttttcVtttaDtKgcaaWaaaaatSccMcVatgtKgtaKgcgatatgtagtSa
+aaDttatacaaacatYaRRcVRHctKtcgacKttaaVctaDaatgttMggRcWaactttt
+HaDaKaDaBctgtaggcgtttaHBccatccattcNHtDaYtaataMttacggctNVaacD
+attgatattttacVttSaattacaaRtataNDgacVtgaacataVRttttaDtcaaacat
+aYDBtttaatBaDtttYDaDaMccMttNBttatatgagaaMgaNtattHccNataattca
+HagtgaaggDgatgtatatatgYatgaStcataaBStWacgtcccataRMaaDattggtt
+aaattcMKtctMacaBSactcggaatDDgatDgcWctaacaccgggaVcacWKVacggta
+NatatacctMtatgatagtgcaKagggVaDtgtaacttggagtcKatatcgMcttRaMag
+cattaBRaStctYSggaHYtacaactMBaagDcaBDRaaacMYacaHaattagcattaaa
+HgcgctaaggSccKtgaaKtNaBtatDDcKBSaVtgatVYaagVtctSgMctacgttaac
+WaaattctSgtDactaaStaaattgcagBBRVctaatatacctNttMcRggctttMttag
+acRaHcaBaacVKgaataHttttMgYgattcYaNRgttMgcVaaacaVVcDHaatttgKt
+MYgtatBtVVctWgVtatHtacaaHttcacgatagcagtaaNattBatatatttcVgaDa
+gcggttMaagtcScHagaaatgcYNggcgtttttMtStggtRatctacttaaatVVtBac
+ttHNttttaRcaaatcacagHgagagtMgatcSWaNRacagDtatactaaDKaSRtgatt
+ctccatSaaRttaaYctacacNtaRtaactggatgaccYtacactttaattaattgattY
+gttcagDtNKttagDttaaaaaaaBtttaaNaYWKMBaaaacVcBMtatWtgBatatgaa
+cVtattMtYatMNYDKNcKgDttDaVtaaaatgggatttctgtaaatWtctcWgtVVagt
+cgRgacttcccctaDcacagcRcagagtgtWSatgtacatgttaaSttgtaaHcgatggg
+MagtgaacttatRtttaVcaccaWaMgtactaatSSaHtcMgaaYtatcgaaggYgggcg
+tgaNDtgttMNgaNDMtaattcgVttttaacatgVatgtWVMatatcaKgaaattcaBcc
+tccWcttgaaWHtWgHtcgNWgaRgctcBgSgaattgcaaHtgattgtgNagtDttHHgB
+ttaaWcaaWagcaSaHHtaaaVctRaaMagtaDaatHtDMtcVaWMtagSagcttHSatt
+aacaaagtRacMtRtctgttagcMtcaBatVKtKtKacgagaSNatSactgtatatcBct
+gagVtYactgtaaattaaaggcYgDHgtaacatSRDatMMccHatKgttaacgactKtgK
+agtcttcaaHRVtccttKgtSataatttacaactggatDNgaacttcaRtVaagDcaWat
+cBctctHYatHaDaaatttagYatSatccaWtttagaaatVaacBatHcatcgtacaata
+tcgcNYRcaataYaRaYtgattVttgaatgaVaactcRcaNStgtgtattMtgaggtNtt
+BaDRcgaaaagctNgBcWaWgtSaDcVtgVaatMKBtttcgtttctaaHctaaagYactg
+MtatBDtcStgaccgtSDattYaataHctgggaYYttcggttaWaatctggtRagWMaDa
+gtaacBccactacgHWMKaatgatWatcctgHcaBaSctVtcMtgtDttacctaVgatYc
+WaDRaaaaRtagatcgaMagtggaRaWctctgMgcWttaagKBRtaaDaaWtctgtaagY
+MttactaHtaatcttcataacggcacBtSgcgttNHtgtHccatgttttaaagtatcgaK
+tMttVcataYBBaKtaMVaVgtattNDSataHcagtWMtaggtaSaaKgttgBtVtttgt
+tatcatKcgHacacRtctHatNVagSBgatgHtgaRaSgttRcctaacaaattDNttgac
+ctaaYtBgaaaatagttattactcttttgatgtNNtVtgtatMgtcttRttcatttgatg
+acacttcHSaaaccaWWDtWagtaRDDVNacVaRatgttBccttaatHtgtaaacStcVN
+tcacaSRttcYagacagaMMttttgMcNttBcgWBtactgVtaRttctccaaYHBtaaag
+aBattaYacgatttacatctgtaaMKaRYtttttactaaVatWgctBtttDVttctggcD
+aHaggDaagtcgaWcaagtagtWttHtgKtVataStccaMcWcaagataagatcactctH
+atgtcYgaKcatcagatactaagNSStHcctRRNtattgtccttagttagMVgtatagac
+taactctVcaatMctgtttgtgttgccttatWgtaBVtttctggMcaaKgDWtcgtaaYS
+tgSactatttHgatctgKagtagBtVacRaagRtMctatgggcaaaKaaaatacttcHct
+aRtgtDcttDattaggaaatttcYHaRaaBttaatggcacKtgctHVcaDcaaaVDaaaV
+cgMttgtNagcgtaDWgtcgttaatDgKgagcSatatcSHtagtagttggtgtHaWtaHK
+tatagctgtVgattaBVaatgaataagtaatVatSttaHctttKtttgtagttaccttaa
+tcgtagtcctgBcgactatttVcMacHaaaggaatgDatggKtaHtgStatattaaSagc
+tWcctccRtataBaDYcgttgcNaagaggatRaaaYtaWgNtSMcaatttactaacattt
+aaWttHtatBattgtcgacaatNgattgcNgtMaaaKaBDattHacttggtRtttaYaac
+gVactBtaBaKtgBttatgVttgtVttcaatcWcNctDBaaBgaDHacBttattNtgtDt
+atttVSaaacaggatgcRatSgtaSaNtgBatagttcHBgcBBaaattaHgtDattatDa
+KaatBaaYaaMaataaataKtttYtagtBgMatNcatgtttgaNagtgttgtgKaNaSag
+tttgaSMaYBcaaaacDStagttVacaaaaactaaWttBaagtctgtgcgtMgtaattct
+cctacctcaNtttaaccaaaaVtBcacataacaccccBcWMtatVtggaatgaWtcaaWa
+aaaaaaaWtDtaatatRcctDWtcctaccMtVVatKttaWaaKaaatataaagScHBaga
+ggBaSMtaWaVtatattactSaaaKNaactatNatccttgaYctattcaaaVgatttYHc
+RagattttaSataggttattcVtaaagaKgtattattKtRttNcggcRgtgtgtWYtaac
+HgKatKgatYtacYagDtWcHBDctctgRaYKaYagcactKcacSaRtBttttBHKcMtN
+tcBatttatttttgSatVgaaagaWtcDtagDatatgMacaacRgatatatgtttgtKtN
+RaatatNatgYcaHtgHataacKtgagtagtaacYttaNccaaatHcacaacaVDtagta
+YtccagcattNtacKtBtactaaagaBatVtKaaHBctgStgtBgtatgaSNtgDataac
+cctgtagcaBgtgatcttaDataStgaMaccaSBBgWagtacKcgattgaDgNNaaaaca
+cagtSatBacKDgcgtataBKcatacactaSaatYtYcDaactHttcatRtttaatcaat
+tataRtttgtaagMcgNttcatcBtYBagtNWNMtSHcattcRctttttRWgaKacKttg
+ggagBcgttcgcMaWHtaatactgtctctatttataVgtttaBScttttaBMaNaatMac
+actYtBMggtHacMagtaRtctgcatttaHtcaaaatttgagKtgNtactBacaHtcgta
+tttctMaSRagcagttaatgtNtaaattgagagWcKtaNttagVtacgatttgaatttcg
+RtgtWcVatcgttaaDVctgtttBWgaccagaaagtcSgtVtatagaBccttttcctaaa
+ttgHtatcggRattttcaaggcYSKaagWaWtRactaaaacccBatMtttBaatYtaaga
+actSttcgaaScaatagtattgaccaagtgttttctaacatgtttNVaatcaaagagaaa
+NattaaRttttaVaaaccgcaggNMtatattVctcaagaggaacgBgtttaacaagttcK
+cYaatatactaaccBaaaSggttcNtattctagttRtBacgScVctcaatttaatYtaaa
+aaaatgSaatgatagaMBRatgRcMcgttgaWHtcaVYgaatYtaatctttYttatRaWt
+ctgBtDcgatNatcKaBaDgatgtaNatWKctccgatattaacattNaaacDatgBgttc
+tgtDtaaaMggtgaBaSHataacgccSctaBtttaRBtcNHcDatcDcctagagtcRtaB
+gWttDRVHagattYatgtatcWtaHtttYcattWtaaagtctNgtStggRNcgcggagSS
+aaagaaaatYcHDtcgctttaatgYcKBVSgtattRaYBaDaaatBgtatgaHtaaRaRg
+caSWNtagatHaacttNctBtcaccatctMcatattccaSatttgcgaDagDgtatYtaa
+aVDtaagtttWVaagtagYatRttaagDcNgacKBcScagHtattatcDaDactaaaaaY
+gHttBcgaDttggataaaKSRcBMaBcgaBSttcWtgNBatRaccgattcatttataacg
+gHVtaattcacaagagVttaaRaatVVRKcgWtVgacctgDgYaaHaWtctttcacMagg
+gatVgactagMaaataKaaNWagKatagNaaWtaaaatttgaattttatttgctaaVgaH
+atBatcaaBWcBgttcMatcgBaaNgttcgSNaggSaRtttgHtRtattaNttcDcatSa
+VttttcgaaaaattgHatctaRaggSaNatMDaaatDcacgattttagaHgHaWtYgatt
+aatHNSttatMSgggNtcKtYatRggtttgtMWVtttaYtagcagBagHaYagttatatg
+gtBacYcattaRSataBatMtttaaatctHcaaaSaaaagttNSaaWcWRccRtKaagtB
+WtcaaattSttMtattggaaaccttaacgttBtWatttatatWcDaatagattcctScac
+ctaagggRaaYtaNaatgVtBcttaaBaacaMVaaattatStYgRcctgtactatcMcVK
+atttcgSgatRHMaaaHtagtaaHtVgcaaataatatcgKKtgccaatBNgaaWcVttga
+gttaKatagttcaggKDatDtattgaKaVcaKtaataDataataHSaHcattagttaatR
+VYcNaHtaRcaaggtNHcgtcaaccaBaaagYtHWaaaRcKgaYaaDttgcWYtataRga
+atatgtYtgcKtaNttWacatYHctRaDtYtattcBttttatcSataYaYgttWaRagca
+cHMgtttHtYttYaatcggtatStttcgtRSattaaDaKMaatatactaNBaWgctacac
+YtgaYVgtgHtaaaRaaRgHtagtWattataaaSDaaWtgMattatcgaaaagtaYRSaW
+tSgNtBgagcRYaMDtactaacttaWgtatctagacaagNtattHggataatYttYatca
+taDcgHgttBttctttVttgccgaaWtaaaacgKgtatctaaaaaNtccDtaDatBMaMg
+gaatNKtatBaaatVtccRaHtaSacataHattgtttKVYattcataVaattWtcgtgMt
+tcttKtgtctaacVtatctatatBRataactcgKatStatattcatHHRttKtccaacgt
+gggtgRgtgaMtattattggctatcgtgacMtRcBDtcttgtactaatRHttttaagatc
+gVMDStattatYBtttDttgtBtNttgRcMtYtgBacHaWaBaatDKctaagtgaaacta
+atgRaaKgatccaagNaaaatattaggWNtaagtatacttttKcgtcggSYtcttgRcta
+taYcttatataaagtatattaatttataVaacacaDHatctatttttKYVatHRacttta
+BHccaWagtactBtcacgaVgcgttRtttttttSVgtSagtBaaattctgaHgactcttg
+McattttagVtaagaattHctHtcaDaaNtaacRggWatagttcgtSttgaDatcNgNag
+ctagDgatcNttKgttgtaDtctttRaaYStRatDtgMggactSttaDtagSaVtBDttg
+tDgccatcacaMattaaaMtNacaVcgSWcVaaDatcaHaatgaattaMtatccVtctBt
+aattgtWattatBRcWcaatgNNtactWYtDaKttaaatcactcagtRaaRgatggtKgc
+gccaaHgaggatStattYcaNMtcaBttacttatgagDaNtaMgaaWtgtttcttctaHt
+MNgttatctaWWatMtBtaaatagDVatgtBYtatcggcttaagacMRtaHScgatatYg
+RDtcattatSDaHggaaataNgaWSRRaaaBaatagBattaDctttgHWNttacaataaa
+aaaatacggtttgHgVtaHtWMttNtBtctagtMcgKMgHgYtataHaNagWtcaacYat
+taataYRgtaWKgaBctataaccgatttaHaNBRaRaMtccggtNgacMtctcatttgca
+attcWgMacttacaaDaaNtactWatVtttagccttMaatcagVaagtctVaaDaBtatt
+aattaYtNaYtggattaKtaKctYaMtattYgatattataatKtVgDcttatatNBtcgt
+tgtStttttMagaggttaHYSttcKgtcKtDNtataagttataagSgttatDtRttattg
+ttttSNggRtcaaKMNatgaatattgtBWtaMacctgggYgaSgaagYataagattacga
+gaatBtggtRcVHtgYggaDgaYaKagWagctatagacgaaHgtWaNgacttHRatVaWa
+cKYtgRVNgVcSgRWctacatcKSactctgWYtBggtataagcttNRttVtgRcaWaaat
+DMatYattaactttcgaagRatSctgccttgcRKaccHtttSNVagtagHagBagttaga
+ccaRtataBccataatSHatRtcHagacBWatagcaMtacaRtgtgaaBatctKRtSctt
+ccaNaatcNgtaatatWtcaMgactctBtWtaaNactHaaaaRctcgcatggctMcaaNt
+cagaaaaacacagtggggWttRttagtaagaVctVMtcgaatcttcMaaaHcaHBttcga
+ttatgtcaDagcYRtBtYcgacMgtDcagcgaNgttaataatagcagKYYtcgtaBtYct
+MaRtaRtDagaaaacacatgYaBttgattattcgaaNttBctSataaMataWRgaHtttc
+cgtDgaYtatggtDgHKgMtatttVtMtVagttaRatMattRagataaccctKctMtStt
+gaHagtcStctatttccSagatgttccacgaggYNttHRacgattcDatatDcataaaat
+BBttatcgaHtNHaaatatDNaggctgaNcaaggagttBttMgRagVatBcRtaWgatgB
+tSgaKtcgHtttgaatcaaDaHttcSBgHcagtVaaSttDcagccgttNBtgttHagYta
+ttctttRWaaVtSttcatatKaaRaaaNacaVtVctMtSDtDtRHRcgtaatgctcttaa
+atSacacaatcgHattcaWcttaaaatHaaatcNctWttaNMcMtaKctVtcctaagYga
+tgatcYaaaRactctaRDaYagtaacgtDgaggaaatctcaaacatcaScttcKttNtac
+catNtaNatacatttHaaDHgcaDatMWaaBttcRggctMaagctVYcacgatcaDttat
+YtaatcKatWatcaatVYtNagatttgattgaYttttYgacttVtcKaRagaaaHVgDta
+MatKYagagttNatWttaccNtYtcDWgSatgaRgtMatgKtcgacaagWtacttaagtc
+gKtgatccttNcttatagMatHVggtagcgHctatagccctYttggtaattKNaacgaaY
+atatVctaataMaaaYtgVtcKaYtaataacagaatHcacVagatYWHttagaaSMaatW
+tYtgtaaagNaaacaVgaWtcacNWgataNttcaSagctMDaRttgNactaccgataMaa
+atgtttattDtcaagacgctDHYYatggttcaagccNctccttcMctttagacBtaaWta
+WVHggaaaaNatttaDtDtgctaaHHtMtatNtMtagtcatttgcaaaRatacagRHtat
+DNtgtDgaatVgtVNtcaaatYBMaaaagcaKgtgatgatMgWWMaHttttMgMagatDt
+ataaattaaccaactMtacataaattgRataatacgBtKtaataattRgtatDagDtcRD
+acctatRcagagcSHatNtcaScNtttggacNtaaggaccgtgKNttgttNcttgaaRgY
+gRtNtcagttBcttttcHtKtgcttYaaNgYagtaaatgaatggWaMattBHtatctatS
+gtcYtgcHtaattHgaaMtHcagaaSatggtatgccaHBtYtcNattWtgtNgctttagg
+tttgtWatNtgHtgcDttactttttttgcNtactKtWRaVcttcatagtgSNKaNccgaa
+taaBttataataYtSagctttaaatSttggctaaKSaatRccgWHgagDttaaatcatga
+gMtcgagtVtaDggaBtatttgDacataaacgtagYRagBWtgDStKDgatgaagttcat
+tatttaKWcataaatWRgatataRgttRacaaNKttNtKagaaYaStaactScattatta
+acgatttaaatgDtaattagatHgaYataaactatggggatVHtgccgtNgatNYcaStR
+tagaccacWcaMtatRagHgVactYtWHtcttcatgatWgagaKggagtatgaWtDtVtN
+aNtcgYYgtaaactttaDtBactagtaDctatagtaatatttatatataacgHaaaRagK
+attSagttYtStatatatagtcttaaaaMtcatgttcaaDactgRttctaagagDtattt
+ttagcgacttgtgRtgNctgSgRaaaaatgcaMtYtDcatcaaYKttHcatSWgaaaatD
+ataggttatgBDMtgttataacaaYSgagttacgttatgtDStttaaatctcgWKtcSac
+gagagaSgttatBMDgtcggtgtgcgaNtaSHBatBtttVMgVcagaNatcaDDaKMtMY
+tatagaBccctctDtgtatttatatKNtgggtatgtRaacttgaWaaYgcaHatccctgg
+tttStatMtcgcMtaaaWKttMVtWctVtgttaKDWctgWaVttaDVatgKtagagtcat
+ctaKWgtaaMttSacBaMattaKaaHDataattgWtgttttgtcatBacacgtStacaaa
+gtNctNtgtgatcHtWttcKaagagttttaaaaWacgRacatctNatVStgaatDHgttW
+cgtRKcatatatctcaNttaaBDcctgaaaaaDtaYaHaKttNtaYVaVtttaDtctact
+tctWttaactaattttMagWcaatcccNKYtBaacatgttgaKgKcgcBHaatDMttata
+tcSWacatDatRcWaMtDgatBctHgScttaaaHtSgKtDtttattgtRStWgttccata
+tttcacWttcatattgtaHVgaBtacaMtgMaaagDaataactDatattagMaNBagctt
+cattcgtaaKtgtatttcacMtgBaVtaattStcttagtYgtgtcgccttKatgggtgaW
+aataggaatacMMagaSKRttBgatgacRtgMtagaSRataggtatcaccgaNaaaWSWa
+cDgatacttgattagcttgtgVMttatYctaRgHVcDtVRRtSaMtcaVtVtatcaYaHa
+tattaaVaatctaBtgtacRatNtatttgaYatSaHctaNgNtYtYaYagattVgatcRt
+aacgYggtgtatKttaatMagatgRtatatgHaKccHaaaaYtgaacgaWaNgtYHgaca
+gaYtctaVtacccgatttttaaagcDttatNRgattKaaattttcatctaatgccgcaat
+aataattgttatYtagtRNtaagttggtHaKttWMtDKgatSagBYcgRggtWaVaattH
+tatgtaaaMgSaaagataaKaaKgttDttttRaagaacaWRcaacDgtgttaatattaKt
+atcaWacacatttVtctgatHRcagtttNcaaatcNctNttttataactWacBBttgBtt
+aaaRaWtBKaaacgtatcRcaMaatgYacaaaagtgBataStWYtggtatgacaKWtctS
+gcKHgtcNaMNcataSatattgactacMcataattNVtDaRccaaatcagttttYttagY
+aacgtaatMtMVatNgKaaMaaBgattaKttatDaBcttKtccttttacDagaYtacHgt
+tggacaaaVaatagtYatcataSgatcaaWVttcgaatgaccctccttNtaSBWaatttD
+ttttcaatatYggctatDcttatNctttagDcMttcaacWaaNattSYgctttcaHcRaa
+ttaataaaatcVccRaattactctaMaVRattacagtgRcDtcgtgctcttNtWVtacag
+tHtatHaBDtcWggtgctcaaRHtatgtDgacStgcaaaVKtagttataatactaatatg
+tagScaatRSacaattgtattgcagatHHtgBcaatKKtaaMMcaRcgactatKBaMaYa
+tgKatttDaaNtRatattgtatWttagcaaaaacaWgcacaaHcataYtDaHgttataaS
+acgcagggggtYatgcKctaaaHgcVgctBDaVttccStagNgcSgtatgVYaMatcaWR
+BtVtgYttgtgRcYttcgctgaacNttgtgtctattWttttcctagMtagaWtaKgatSt
+ScatMaBtaStaSactattYNatctgtacRatYDaatgatgatatgaatYaaaaSHttaa
+YMaWtDcaNHaBcaYtgVgcatVaacattMRatBtaatttaDacRtagtaaaNYVSMtca
+gaaDtttDHtRcYatacSNKaaMcHgatBaaVttactggBYgaYatttttgcDacHctWa
+tcgtagagtactcattDggtcatKaSgctttatttagtDtRBacttaWYaaaattttgac
+cttaaWtaatgcRgccacttMtaggKtcBtgacgaHctttatcgtcStatMHDNagatta
+tNagVaaaWcggaaaYcaVactDYactaStattgBHtcYctgggtacatataaYcgaYag
+aggaggacaVatacHRtYtctgtaVgaYcNgaaaNatacVgcNgtaatttDcatttttca
+acttSNcaaDatVYctSgcaccttagMgacgcttgaSttaaaatagttaggRHttaaacM
+atagcaWgMgagtcgctagtgtKgactaaHttattaWgcaaaaaaSatatgcgttaBNgg
+ttaYVatgaactttttgccatataaataRatSaBctagttataBccgaaacaagatactt
+aattttgaHgHMgtaaKctttaYtaaRacBMtBaYgaBaaacaYtVtagcRgWatHaWag
+attWSacStMHatttaDagacaatcgtgtKtttggaMtgtWtgtgcaaNaaaaWtKaaBc
+MWtcttctatgacVgagcgaggHaYYtttWgSaaYYaWtRYHHaMDtctttacaatggaa
+MctataagcttBcgHcNWaatttgtatatYtStatctagcactgtVttccagaaattaDt
+ttaRtVataBttWagcatDMVactYtgcatWtttgaaMggKaatgaaaaHtataDtgYcM
+ggVaaatSMHtttgVttaYaWaataRttgttaYttattttRtWtataaBgtDtttatatc
+VgaaBcaDtatgtcaDagaWtgaYtWctcVagctcagctatatagcRVtcaKtaataatH
+gNaccgaaaatVHBaatattcgttaVYttatttctBYaatKaagaccVStttcattgaMa
+gSaaaaccccWKcaaNtMYacctaDStagaaatttatcatVgtcaatacccKattgtaaa
+gtggWgtatatVtagBcttDaBacaattWtDYKtatRKggStRtaaaWatBtaagtaatt
+DaaaaBRacWtaagtacaSttaaatccgctaaccKaattgVWttDattatttattKaMtc
+YtMRWagMtcgKgBagacgggVaaNaaatgctKcgtaataaKtaaagtccWcttHMatSY
+gataaatDttBaHccattgBttSgaaHYtaataaaMtgaagatgtttBgRcattaRaDHc
+ttBgaMaWaaVMMattaatttgtgBRctattgKMagNcMtatttaaaWttgaaacatWgc
+ScgYYDYgttYtVtattgcKcWtagcggtgBaSctaKatacaaVtcaRDccccgtgttBg
+KgggtHagcgaattaaagMMttScggtDttttaHcSaagaacactcacactBcVgaKNaD
+HacacttatSagaattSKHtcagtataaatKaaHtgaaRagaaVcBtaHtaaatcgatcW
+caRtaaaatttaWttaagtcaggRctgaWcttDttgactttaVSaaaatggtaWDaRMtB
+taaaaaKatBgatMtctatatcaVaMgatttgNagtDRttDatcttttaMtYaaatcgga
+gttctctaYatNtagaNcgMMactacHcaagtaaaatStaSaacaHcacSgggtNKatgg
+aaagcggaaKgggtaYtacSgccgBaggcRacgtVgDtggaMcYaaaMatggacgYStKK
+atgaBcaaRtStccSagcRccgccgcSDtgcggBDgaDtBtSSggacMttttaWcatcMa
+tgtNMBWgataatcaaVtgaataataaNatgcaaNttNctgacDMcaHccgatgKgWVtt
+ccaStggattctcDacttttttctttaaNcWaMWccWKWttgaaaMctDaaBactRtVat
+tttBtcMaNttWcKacagttKSttaYaWSactHSaBtHgatgttacatgcatatMtttgt
+aacScWHBatHactggatatatctgagMgRSatctaaSttaVagcaRcttggaYaatKHt
+agBBactattcgtaaagaagttgtVcgatgaVatHMtcaggtcgKSgWattgaaaVctcc
+VgtDcaaatgaaHgMYactcaMatatatattNVttWtWaatttacRagKataaaNtttac
+aaWgMVactattaSgaggVaaagVtaccDRHaaataRaHaRgcattMttcaatcaKaaat
+aDcaDKtctcgaggBggacctDtttatHacWVaWgatDctaNaNcgKatcMtcMaatBtt
+tggacgtgataatagaaacRactcBtattttaKtgSaaggKtaggRaVtatagcccaNRt
+taccttSMaagatcggDacNBatWcgaactacactaactNBtaStgVtNagcatctaVta
+KatKgaBtcgtttWaagWMgagRaNatHaaaaDtacagacaBagtgcaHaNatctcBccN
+ttaagttDgaataaNtcgctaacRBgtaatSttaatatgcataacccaSattKcccttDt
+tggtcaatgggttWaacgatacattBtgMaYgaRttatgatKaKgtattDtKWgataacg
+NBtaccgaKWatcttcttKtgtcttagcattcctWcaaHgagtatDMSgKtcagcttgVH
+aKcttDaataaaVaatttDgtgaaataaRgtcaVaatacttagtVatatgggcatgtDDt
+MtgtatBggattHtgcVtgtgatcaaSattatKYVaacSNNttNWcgaHttKDaaMYHat
+cgttaattaSttgctWaacHtaKBtaaaaKHttcRWgaaWcRtBtttggBcDtgtacNtt
+aagcKtaHgtagaaaaRttgaaacatagtWRaacYggtaaatcgctYaBtWDRtgttgSc
+taaKatNcattgtgtMttatccatatagctSacgccSNaaactacgNtgtgcttMatSKt
+caaBaNaaacataacagaaatagtagctcNcatcVgaagStaataVcDKKttcagDHDta
+ttctaatgagggRgBMctatacaagYactctMaaagtcgctttctcgtgaattatNcgat
+MtttaggcBaaatctNtactaaRKtgKactattgtcatatgtacgagttMaaHSSgHgBa
+tatcgcaSaataaaWgaagtatagaHgcttctttatgaccWaatttaRtaDaatttaatc
+gaaattgattMcatcaWaMtaWaKactttctBacactatNgtccttaWgtctgaccKatS
+taKtgagtacgggcgcgtYNtatttagacctctKcatgatKWStcaataactaWgMSgHt
+gatctttttgtcgacgtSacttaYgcctWctcctctacaagVtttMaBactWVaccaYtg
+tSgcgttattcKtatStgaaKaccgNaataaHtatWtYtRacggcaDaScagcagHaYWR
+tRNcDtHtcVWtggaataaaYttgVaNtgttagtYttgtagSaaatDgaggccDcgBRYS
+tattatttaaggccgHgggYRaaccMaagttatSttctttagcMtgcgMtgaSagaNaDa
+gttSatgattWatttagtDgcttgagtgMKaYWaYccagcaHatKctaKaDgctagactt
+attgattaaYttatcttattattStaattWaRaYBWagYaatatgttRgScttgBagDaW
+gcgtgcVDaggcttgtctaDRKacttgcaKBWRtaaVaSctKtacttMaaSVaWWcgSaN
+tttSWgtcggtcacttggVVtgagaataaataaDttgaaccaaaaMttaaaagaaaaaaa
+atcNBtatMgccWagcaNgaVaNaaaaaaYaMgttaWtatHaagtNtacgacaBtMMatt
+ttWNaRtaaatagYaScKattacagctVKBtWNSKgYtYgtWatHaVatDaaatWgDatc
+ctggSRagagtaaaaMgatttRtaHacatggtaKagVcctgatgaMtaaYgatgtattat
+tttHggBaccaDctctggNNtYaatctVttgVtRtVcRacttNctttataggHSRtaRac
+aaattaacHaHgtgttgtttcBtBtatWtgtattttgcKagMcaaagaMtattagtStag
+cBacYaaHcagVgWtgtttcgtgDHaVtagDatcRaRtggtWtaactgcacgaggaaaRt
+tSDaaVaSttaaaaacSMttactaNtcaacaattDtacttttYatVSacYtWtMttaatt
+atcKtcttctatcaKDtctStSaaacggtYccatgtgagagtWtagWKgcaBaaaaKttg
+NactaatcgaggcWtcDDaaaaaacactHattaattcactatYttaagacactaKaagRt
+RataaattttcatHggtaataaatgataHtggctaacBacDgtaatattRtYgtDNDBgK
+tcaggcHattttgHNgWtaatttccgactactgacatVNttYYgactcgctctatttaga
+McgggatHcgtttatBaDSagBaaaagRttBggttaaBactVHgatgaatttattcaaaa
+ttgcacttcDgacttYcVttactVtttatBaKHagaWgtgaatggBtaaSggcagacNct
+taDttVgMtWagattggVatttacHtctNcMatacttSatMagcttgtNcYaaScaYact
+cKctKtagScStcagtttcatWaatggtgagaggHaggggcaacgcRKtaRcMaNtHaat
+RaRaaactVtBtgttaatRtWWcaaagKttccaaKaaatacgVttcacaaacgcggtgag
+aRaatggtgDMWatcWVScacaaaDaggaaHtgttSMaaaaaccYccDBtatYgtMagcS
+agaccaVcctcggtVWaaagttatcNaagataataSaataaaKccgtaDtYttatYcttH
+ttaagKcMctaaatggaatRgaaaVaaVtcKYaggatWcaBtDaggDatccttcYNtgcS
+MRgaRtNgaatcgttRttatDVMtagctttacatDVtatatatcagctaDagMtataccY
+gaggYaaatgDaaaatSgctctgatgtttVaaBcctgataKtagaaaccaKatatgttaD
+tgaDtatagataatacagtaDtatcNtgtDMtYcattRVtctataNtWttggNaSgtMga
+aYctctDggHtggHDccaccacKKaaacaaaatRatttccctttaagcRattMHctattH
+aRtataVattggatcSttaaHaHgaaHNDtacattSaaggDatttcaaaYgctBcatatt
+aaaKagtgcccatSctcgatRtaaaMtgWactttNMaWctYgRatDggaactcDcaatta
+KaactgagtatctataagYaaaSRctggtacWtttccWtaYRtKHattatagWtKttaNg
+cDtatHacccattaatttataacgctMgaagtaacaacagMgtaYHYVtKMHtacMgKca
+aatctgRYataNtcgttcaatacggWtMcaatYcBWaagYtVaDNagtatagDaaNtaaa
+YtttcYWttttStgggataaMgatattagaaYtNctcttcBagactaYDcgtacHDWccK
+aHgttcttHgVggVDttatcatKaMttttacWaaSattctatagaHaggKaDagBtaaag
+tcYccattgtYcatctaNgRgVtgaagtDKttatBKcggDtattRYgHccgtgcgBNMtt
+tVRgacaYctSctaRacgtagagccgtacRaagtaHKagStSttttgYSatattaaaWHa
+aWagttDKaaNaNHaaHttaYcttMtcaaatgKttBtSgtccaaVaattSaacgttgNat
+tgatatNctaWtVcagtactKcWacgVagggHaaRgaDaatcMttattaataacaBMaaV
+tgYtKgRgHactgtactatcBaMtVggtagKcYtHtBSaattagtaatgMcaVVagYYgW
+tactttccaaSttDgaaMaMttcacttYtRgacttcagcttWtttagtgataMaattaag
+VtagaatatKataagtagttaagHMRaDattaHaaVcctDtagtcVYcaataaYcNttNa
+aaHctcaRaatttcaNRgatSHgVatagctRtcatgaBttMaaagRtcgHVtgRgStgat
+ttgtagaKagaRWRctgNaHYgaaatBctgtttRttNWagaccgagKgtgcggHKVttaa
+tattaatataataDtaNcctacaaRgcaNMctctgaaSHWWHcttagtNagtWgWaaKtY
+aNgcBattatccaaaSctRRHKaNtKcBgtgagaDRWBttactaaattSMctatatagaa
+YacDgatttccVtaagRtgRataatatagtctttttatgtMgtcaacaaNtaaaaactct
+WtagaVaaaDtaattatagtBStcgaatDtgattVaatMtcaDattVKWaagatagggtt
+gtMRSgtcYgWMaatgNtagtcBttagtttctctWaaMtVgctWgSgtHagaSagactag
+KtagWggcatttHgttgacaaactcggggHggcWBgVgtatgggagVgagtcVcBtDctt
+tagtctaagVWtHtgtttaScatacMBtKgattatRtgtttgtctttDggcHaBtRtgta
+ataNataatttataWctgaYWataStcHaatcRtaaVagDWaSatagtaccNDgaagtat
+acgttttacgacgKRtattgDctatRRattVtStaaactagatgVatttagaMaSaaaat
+tVtatYtgttgtRMagtHaatttSttaaYNaggWagtgcacgaMcactgHgtgtgggHMg
+tKacttaaYgtcgcatcSatattgBaagtttacMtYagSatttatttaVtaaDtaWaHcg
+NatactgactHtggWtataDcDScatactcStcDtgtcgtgtatgaggtHaaNKgDattg
+cBccaagKgtatgacKSMtttttgttcaaatcaaYtagtaSatgDaaaMccKNaMaatag
+aataagcaattattataaMgagtgaSgtctNYttattHaNaYYtcDDtaatNRgtattta
+aYtaaatcactHVaHcStccttcccaaVatcVggatKtatgRaaDBgaYtttacttYgga
+ctSDtaBcaaNggggtattatattBDcttagagYNMatBgttYaagactMatgttRgata
+cccgtaacacBHtatKacWgatRcHttaattYtKtStccaaatVDcaNKHHaaataatag
+tagtatcttgctNDggVaVVtaVaRaaagSaccgttctcMtVtgNBgtDtttctYgttac
+tBctcRtStWtWDScMtcWSaRatgaataRHctaNtcStctYtWacagatgtatYBtHaH
+WBtacggtDcaaBtatcaggtcaVattaNctactgaaaatWaDgactNWtMtggagaatt
+BaataYcMWYcgatMYatWtgattSatgaRtDaRgccagtSttatatRaBtattRcWtag
+tVgaagttMctattatatDttaggtctKtgtgtBagacgttatRKtgatctatttBtata
+actgataacKcggagtgHgtVttcttgtKDgcDtaYatBDatcaatattgttNtaBacat
+cgcNcaKcaWcRataWcVgtacgScaWgttcggHcMttcRccatgaRStYgNacagatac
+YacWWtggNaDcWagttHatMaNaatNtcDMDcMaKgHNatScVgatKWatatgNRgtcc
+gYgaagattDHgtMtcHaSNaaattBatRagtaaatttacaagHWtKatcaagtccHtYc
+ctgttKDMSgtactactVctgacaaaaHgatatacataatKtStHgctScSatNatacaY
+ttaaWHtctgaatYtagtHtKaggccWBaStaDctaagagNtaatcaatcgttNgaYDaa
+gtaaaaHatagaatcgcgBaYaBgaacSaaWaaaaactccgcMttHttYgtaagaMctKB
+tacSagattcBaaWtaattttacRttatcgaRtacaRHgtgRagaaBcttaVgacVDggg
+aatVatagaactRRtacgYttNattVHgaHttacaaaaaaaYtcRWtgtgattatgccaS
+DtttatKWgaatatSNDgattttaacgtcSRtatggttcttcBtWtttMtBtMScttaHa
+tBattHacYtaYacattcgttKgtcStSctcKtatatttcaKSgagcttccaacaccRDt
+>THREE Homo sapiens frequency
+gttaacaggatagtctatgtaaacttcgagacatgtttaagagttaccagcttaatccac
+ggtgctctactagtatcatcagctgtcttgcctcgcctagaaatatgcattctatcgtta
+tcctatcaacggttgccgtactgagcagccttattgtggaagagtaatatataaatgtag
+tcttgtctttacgaagcagacgtaagtaataatgacttggaataccaaaactaaacatag
+tggattatcatactcaagaactctccagataaataacagtttttacgatacgtcaccaat
+gagcttaaagattaggatcctcaaaactgatacaaacgctaattcatttgttattggatc
+cagtatcagttaaactgaatggagtgaagattgtagaatgttgttctggcctcgcatggg
+gtctaggtgatatacaatttctcatacttacacggtagtggaaatctgattctagcttcg
+tagctgactatactcaaggaaccactgctcaaggtaggagactagttccgaccctacagt
+caaagtggccgaagcttaaactatagactagttgttaaatgctgatttcaagatatcatc
+tatatacagtttggacaattatgtgtgcgaaactaaaattcatgctattcagatggattt
+cacttatgccttagaaacagatattgcccgagctcaatcaacagttttagccggaaacaa
+tcgaagcatagggacaatgtatcttttcctaaattgccatgtgcagatttctgagtgtca
+cgaagcgcataatagaatcttgtgttgcctcaactcgttgaaaagtttaaaacaatcgca
+gcagtctttttggggtctactgtgtgtttgcaaaataactgaaagaaacgcttgaacaac
+tctgaagtagctcgagtactcattaaagtgtaacacattagtgaatatcggccaatgaac
+caaacgcttcccggtacgctatctctctcatcgggaggcgatgtgcaggttatctacgaa
+agcatccctttacgttgagagtgtcgatgcatgaacctcattgtaacaatagcccagcaa
+attctcatacgtgcctcagggtccgggcgtactcctccatggaagggcgcgcatctagtg
+ttataccaactcgctttttaactactatgctgtagttctacaggcatagtggccagtatt
+ttctaacttctctggatagatgctctcactcctcatccatcacggcttcagtttacgtct
+tacttgcttgttcagcaacggatggaggcattaagtatcttcactgttccctaaaattgc
+tgttcaatatcaaagtaaggacgatacagggaaagctcaagcacactcattgaatactgc
+cccagttgcaacctcacttaatctgacaaaaataatgactactctaagtgttgcggaagc
+agtctcttccacgagcttgtctgtatcacttcgtataggcatgtaactcgatagacacga
+acaccgagtgagaaactatattcttgcttccgtgtgtgtgacaccaggtaattgatgcgg
+atataagctggagatcactcacgcccacacaaggcgctgctacctctttattccaatgtg
+taagaatttgctaacttcatttctagaccgcagctttgcggtcataatttcacggtacgg
+acccttgggttagagacttgataacacacttcgcagtttccaccgcgcacatgttttagt
+ggcttctaacatagaatttttgttgtgacataaagagtgcgtgggagacttgcccgaccg
+ttaagccataatcaattgaaagccccgtgagtcacatctaattggttgtactgcgcattt
+agctatcctttagctgactcgaagagattcgattcctaatataggttaattagatggctg
+ccgcgcgaagtaaaacgtgaaaaacgtagtgcgcagatctgcataactcgcgcttaatta
+cttatgagtagttccaagttcgctacgttatgagagagattggaattaagcaaatatgtt
+ttatggtgattttgggatgagaaggactgctaagtacggctactaaacaaatttctaaaa
+ccgccatctaccttatcttggagacatttaagttgtatatgtcactagtctagcttttgt
+ctgtgggacgcgttctcggaatgagggaaatgcaagagccgattcatcaaatgcttatct
+aagaaagtagtggactattacaccaagcacgaatgccagggaactgctttcttgctcagg
+acctcgcgacaaggtaccccgcataagtcctagaattacatttggtcagcaatgctgaca
+tttgaccgtgaaaacataattttaatcagaaggcagctcacccgcttgctctagatctta
+tctttgtatgaatgtcagaatttactgcaatatccgttccgaatagtgagggcttagtat
+agttctctgtatacaggtcacatcaaactccccctgtcctagtacagctctgagctttaa
+ttaattgcatacatttccttcaatcatcagatgaaaacaccgcgaatcatgctcttctcg
+tatagggcaagagaagcaacaaacaactagcccgactcacgttcatccgccgtatccttg
+ttcagttcttactccgtattaggtcagcgaaatctaatcagaataatcggtcgcgtatca
+aaattaaaatcccgcttgaggttgacaattaaaacgctgagcagttatcggctattagat
+agtggggtgaaagtaattggctggaattatgttaaaacgtgatattaagctaaaatacgc
+tacttgttgccgacctaattcagtcattcgatattcagttagagccaagaataacaagct
+tgtataaattgaacggggtgcactaaacgatgtgttactctaatattcagcttggagtat
+acctgaaggcgaattcatgtatcggccaataataagacgttgaagatcacaatttggact
+agcaaaagaaggtgatttatgcgtggggattgagtccactgtacgagtacggtctctgga
+aaattataggttcagggaatataaggaagtaaagataattaccaagagatttttggtatc
+gctatgacccagaggtgttctaacgtctgttttgatccgcagaatttctgcctcaatgca
+tatttgacggacttgaactagagcctctaaagttaaatggcgacgcaactgttcctaaac
+ttcaattattactactctttttttcctagggtattgtagaggccagtggacaaaataaat
+caaatttaagatgtttcggacattaacatcccccgtagcatagaaatcatcagttatcca
+atctctcatcgagcttttacaatttctgctggcgctatggacagcatatgccgcgagacc
+tccgcaagactcacttgatcactgtaagtatcttcattagaggttagagcctatagttaa
+gctgctgacctagtaaaattggtattttctaattttattgctcaagttaaaggttagtga
+agggataatgacgttatttttgaacaatgggttgtattcaattttatatcacgaatggaa
+cccttcattcccggcataatactagacgacacgaacaagctccgatctatcagccaggca
+cgtgttaaggtttaattccggcaaaccaatgaagcatcaaaaggtgacctgatgcaactt
+agggtcacgatgagtttttcaggactacttattacctattaataagttaacatgagcctt
+cataccccgtaagacaatacatactccaccaattagaattctgagccatcttatcttttt
+gtatcatcgaagggtatggccgaataggttaattagttactcctaacgtctctacaggca
+tgcatttgacgcaccttcgaaaatagtcaatctctcgccacacgcgtctagtatgcagca
+tcaaaaatatagtccacggtttccggattaccaaacgcggcaaagagaaacattgtatcg
+acggagataacttaatacagaaggaaggggcatcttcgaatacggatgaataattctatc
+tgtttattctgacatcttgttttcaggttaatcttacgcattcaaatgacgcctgcccca
+tgcgtgcgcaattattttctaatattgacgagagcaatctcactccttttgggtctattt
+atgttttattgaggcacaagcctatacagaacaggtactattaaggccgtgagtgtgaga
+ctcaaaccgtggaaacaaaggatgggttgttcttggtacaagttttagtgcatgtgggca
+atccttaccaaaatcagatgctatccttaactttgggctgcatttaagatggcggttgga
+ggcctgtgagaatcctgcgtgtcatctttaatgaccgaattcatccatgtagattcagat
+cacacactcattccttgatgttgtctaaacaaaagttgttgtggacgcattggagggagt
+taagtaacaacttgggatcgcatacttataaaaattatatgttaaactttcacaaacgct
+gaagtccaaagtaactagcccaaacgcctcgagagtcactaggtattaatggtgtttgag
+ttcctgtgaaatagtgttcgaaggtaaaatttatgtaccaaatcgaaagaacacttaata
+aggcttgcttgcacggaggtatgatgtttactgactctacaaccctaattttccagtacg
+tacattcattccaataggttagttctcaaagtgctatacaggctcctcaattgatgatat
+gcttcagccgctctatggatattagctcattttatttaggaagcccgcttagaggcttac
+tatgagggaaatgccaaaatgtcatacttttcggtgtgtcccatatgacaccgctttaca
+tagaatttgaattaaaacgcgctctcccgttcactaccatacttggtaccgtgcgcatat
+tacatatagatataggatcattttttaaagctgtactaggtttgatcgacaatcttatgc
+tatactatatgatgtaaccctcataatcaataccgatcgtacgatcctagcataggtggc
+aagcgattttatgccgattattgtgttaaatagtctgtgagtgtgattatcagggctacg
+ttggtagaggggttgtatagacctcgcacacattgtgacatacttaacaatatacgaaaa
+ctgatataataaatccccttacccaaacaccaatcccgttgaatcaactaccataacgtc
+tcccatataaattgcctacttgtttgcataaatctgaatacataacaccattgcaccttc
+ttgtgttccaatcccgttaagattgccttgtcagatgatatgcaagaacaatagcatttg
+ctagcaattattaacagctcttcgaattgcctccacataacgcgggagggtatattttaa
+tttggcaaatactaagtactgttggcgtcatatgctattaacggttggatattaagttat
+gtcagccgtaagcaagagtgggcgaaatattttgttacccagtgagagcactcttagagt
+ttggatacaataggccatatgttgacttaagaggacgtaactacgccgtacaccattgtt
+caaccgacttcttggcaaatagaatcgtattagcaatcttaagaatagagacacgttcgt
+gttagggtatactacaaatccgaaaatcttaagaggatcacctaaactgaaatttataca
+tatttcaacgtggatagatttaacataattcagccacctccaacctgggagtaattttca
+gtagatttactagatgattagtggcccaacgcacttgactatataagatctggggatcct
+aacctgacctatgagacaaaattggaaacgttaacagcccttatgtgtacaaagaaaagt
+aagttgttgctgttcaacagatgatagtcatgacgcgtaacttcactatagtaaattgaa
+acaaatacgcaatttagacagaatggtacggtcatgaatgacagtaattcgaagtgctag
+accaacttaaaataggtaaacgtgcccgaaaccccccttaacagaaagctgctatcatgg
+tgcagtatcgacgtgttcagaaacttgtaacttttgagcaggtccgagcacatggaagta
+tatcacgtgtttctgaaccggcttatccctaagatatatccgtcgcaaactttcgattta
+gtcccacgtagagcccaagcgttgtgcgactccacgtgcatgcccagaaatacgagttta
+aatttggttacatggttaattttgaccgaagcatcgcactttatgattgataattggatt
+caatatgtcgccctatgcgaatgcaacatgatccacaatttggctataagacgtttaatc
+cgtatcacactttgtttgcggctagtatagtaacgcccgtgcaccaagagtcagtaacaa
+ttataagtactccgcaggtacttcaaatataaaaactaatcaaacacgacccatatgatc
+atctgaagatatttggaactttctcgacaaccaccctcgtactcaatacttacactaatc
+gacaggcacacgcaacgtgtacagtcgcaccatattgagtcaagatttgcttagtggcga
+tgagcgtacacgcttatttctctagtcacaattagttatctacgagacatcacgagggag
+caaataagcgatgttatggctacacataggcacgtatgaatatgatataagccagttaaa
+cagtcgaaccatcgagcaaattctcatgcaccaacccacacgttgaggcacaaagagtaa
+gctgtttgaatgtaacttcttctgctgagcgggccccaacgtaaggatcaactagaagag
+aaaactcggtattagtttaaatgcgtcacggagcatgagtgcatttcactaagaatgtct
+gtgtaaccaatataacatctatttgttatctgattgcctacttatggctttgcggtcgtg
+gcgactaatgtctccaatccttttgaggtcggtaccaactccctttaaattacgctgtgc
+aggctcatgcactgcatacatatacggtagcaggtagggacctcacgcacccttattata
+atcaatagtagttatcagtcaacgaggcaggaatgctgaggtcgaggtgttggtatattt
+tctatgtgccgtctaggcgactatcacgcattaccaggcgagatttaagccaattttgaa
+tatagtcaacgtaatttttactatgggttccaccgaaacgccttgcacaactaagaatcc
+cataaaatatcgatatcaaataaaagattgtgtcaataccttcatatatattttttcggt
+tgactaacgtgaactaaggttaggggttttgtatgtctatataggaaacagtttcttttc
+tgtcctactttagtaaagtcttcaagccttactccaaaatcacggtgattaagccgttac
+tcagcagcatgattctgcctgctcgggtcctaaaatccagccttgtaagagtcgctgtgt
+attagctagggagacctttgttaaaaaggatatatcgcggcgggatgtgagtgcgtggcg
+catactcaatcttcagctcgtgtcattataatatctctcccccacgcttttcactagata
+tgccgtgtaagcaaacaccttatgcttaatttcgaaaatattggtacttgaaaaaagctg
+taggggtacttaatgtctggtaggagatcaggagagaattgagtgtaaaaccgtaaagcc
+ctcacctgacttcatgtaaatggcttagaagactccatgatttaataaatactacgaagg
+aaagactggatctaaagataactctagtaaggccaactcccttcaatgctgttgccagtt
+ataatccaagagctgtccttttctgaaccatagcggcttctgaagcgaactagaagcaaa
+gttggttctagccagacagccacataccctgtacgggtgtattactaaaactggtccggt
+attagttcaccaagggaggaattaggcaaaggatctaggtatgcaagtcggagtattaca
+tccctaccctgaatccatcaataggttcctctgtactggccttcgcaatgagtattcaag
+gttgtacagccgtataataataagatagtgactatgaacgggaagtaacccgctcacctt
+ccccaaaacattgttatatctaagtattaaagtctgccgtagtgttaatactcgaaaata
+aacaactggcaaattacaccgcacttaagccgcttttgatttatatttttccaatgcgct
+tttaaaaataattcagtcctacatactaattaagacccttaaacggagatatcacaagtt
+aagttttaaccatctcgactaggtggaactatagatacccaactcaatttatcattacct
+gtaatgttcctagaaggattgcatttcatgtcaagacggtggagtttcacagcgaaactt
+cagtgtgaacagattctgagaaatcacctaaacctattagtcagagcacccggttagaac
+cagttgtcaaaaaatagagcggttgcatgagacagaagtaacgatgagatccgttgtaac
+gttgagacatctggcctatcgtcaatacagtcctcccttaaaaatatttttaaatactag
+gcaaacccaacataggttagtcctatgtgatacgccacatggtatatcattttgtaacgt
+tacctagggataatcaggaagtggaattacgcaaaagtagacagtgaaatgcttagggtt
+atagtctagtccaaagataaaggataaagcacgtcagagaactatattagccgaatggga
+atcattgttaggagactgtggatcatgtctaaaaagcaacgcagaaacagtcatcgaaaa
+aatctcgtttttgtttgaatctaaaagagctttgatgaccgatagtacctgtatactagt
+tactgtattacgtgtctaatgatttcggattggggtccccagaatcagacgtcattgtag
+acgattcaagtttaccaatttaatttcccagctctccttggagaactatcgccaataatt
+gcagtcactttccttttctgaaacgataaagccgtcagagttctctgcaacgttggactt
+acctgaggttctaacccactttcggttctaatagtagttaacgacacaacgaataacctt
+tactgtggggctttcacgatattttttcgcttattattaatggttacgtcataagctggt
+gtccaaattaaggttaccggcttcgcagagtagttgtatccaagtataacttccctaatc
+ataagatcgaggtagaaaattaatgctgtctctaaccgaacagatatgtcccactatgtg
+gtatggacgttgctaattacttctgaagggaaattggtcattatggatacgtgtctacca
+tcaggtcggacgcagatatggttctgtcttcagttgatccaccgttctttataggataat
+aactgacgattaaagattatggtaaatagattaagccaattctcttcttgtcagtgaagc
+atccttaactgacttgctctgcagcccctcatacatttagctattcaaagtaccggctcg
+tttcaaactctcccacctttggaagaggttgtcaacttgataagtatatcatttacagca
+ttttttcggacgtacctctaatgtttcattgcagaaaattagttttttctatcgcacatt
+ttgcaagtaacgttagagacacaattatctgcgaatgaactgctagatctgacgaccggg
+agcctcgcaaatatcaaaaaagactgacatatatcaaggagtcgttgacaagtgctggta
+agtcaattggtttatctgtcccggcgtttcgatcttaagctgaccatgcacggcagagta
+atgtcactctcgttcttacaagtctgtctccaagggtcggcaaaaaagacccctccattc
+tcgagcccactcacgatatgtagggacgacaacttgtgcggcttatgaattgtctggact
+gcgggcgagggtccatatctccgaagttagaagggacatacctttagatgataagatcaa
+ttcttattgacgaaattcatccacaacggggaacaacttcaccctagacttacgtctgaa
+aagacacctagcgtcttataaaaggtcagtgccccgtttcgtaaggctggaattacctac
+gcaaacttaaacctcgcgcccttccttacgtatcgacaagatagaggctatcgcgaatgt
+actacggaggcatgaatcatatactagaaccaagtgcctgtgatattaacaagatgatcc
+gacgcgagcaccgtaattctaggcataaaactccagcaatttgggggccgaaaacaaatg
+acgttagctaattaattatatgacatgatcaaaggaggtcaatcacgcatcgagttcgac
+gtatattcattgaacttcgtgcgtttgaaagaaacttttatgaaggcaaaattgatcctg
+tctcctatttcatgcgtacctcctagttgataattccccgagcagtggttaggacacttt
+tgtcggtatcaagttccggtctcaaaacgtaaaattctgtaatctgtatggatggtctgt
+gaattagttaatttttatgaagtcgtcgagacgcagttcctattgatttattctaaacgg
+agatgtgcttcgtgggactcggaagtagatctgtgtttatgattattgctactttagatg
+ctgactgttaactccgtgttgtttttcaaccgtatatcacaaccgaattggatagaacct
+atagtttcaagttctgccacaaggtatcatatttacagttagtgctggttgcttctttca
+aacgtggtgagtttgtgctatcacgtcaacggtagagctcagtggaccgagtgcgcgttc
+aaccctgttccagagagggtgtgatagcacatataccacgctcgtcgaggcgttcatgat
+agtttgcaagagccggtgttaaacacatattattattgttatccaactaatcggacctat
+gcataaagcattgtctaaacagaataattgcctatatacggtagttttagtgatttatat
+cttagtatcagttagagcttcgaactcttcaggttcctcatatttaacgttcttcgaaag
+cgaaaacttctacaaacgaatgtaagcggttttccaagtagtacctataaatcacagaaa
+gatctgtctcagtatagttgaaatggtattcagctagtgacgtgtaccaattatcatagt
+tcactcaagcaagacgctcattaacgaatatagacaagacactatatcatataataaaaa
+agaacatggtgctcgaacatagttgaattcaccatattgaaggggaatgctgacatgtaa
+ttcgctactagacgatcaattccctacttgtcaaagttgaactggtacgttcttggaatt
+aaatatgattgcgctggaccaaattgcgacttcttgagtttcagggcaaacgattgagcc
+ggaggatgtccgtctcttacctttcttgcttatgataaacgacggtccctgtacatcact
+gggaattctcagcaaaaataattgggtaaatcgagactcgatgtattcggccacaaaggt
+gttagacgttaaagattattcaacggggcgataataggatcataaccggtatgcaagcgc
+attgaaagagccatgagatccttatccgataaacgctgcacggtatgtgcagccttattg
+tcgatcacgaatttataaatgtagtctgggctgtaagttgaagacctaagttataatgaa
+gtgcaataccaaatcgattcatagtggattatcagactcaagatatctcctgataaatta
+cagttgttaagatacggataaaatgagatttaagattagcagcctctaatctgtttcaat
+cccgttggaatgtggtatgcgatcaaggttaagttaaaatcaagcctgtcttcagtcttg
+attcttgttctgccatcgcatgcggtctacgtgagttaatatgtagcttacgttctagct
+tgtgctaatctgagtatagattcgtagaggaatattatcaagcttccacgcctcaacgta
+cgtgtattggtcacacaagacactaaaagtggaagtagcgtaaactatagtctagttgtt
+aaatgctcagttcttgttatattcgatatactcttggctaatttatgtctgagtatataa
+aattaatgatattaacttgcatttcacggatcccttagaaaaagattttgaccgagcgca
+ttataaacggttacaccgaatcaatagaagcatacccaatagctttctttgaatttattg
+cctgcgcaacttggctgactctctagatccgaataattctatatggtcgtgacgaaacta
+gttcattactgtttaaaatgccaacatgtcttttgggccgataatggctctttgcaaaat
+tactcaatgatacgattgatcaaagcggtagttgctagtggtagcatgtaagtctatcaa
+atgtctgattatccgaaaatcttccaaaagagtccacgtaccatatctatctcatagcga
+cgcgaggggaaccttatctaactatcattccatttaccgggtgactctcgatgcaggatc
+cgattgggataaattgcccagaaatggctcattcctgactaagggtaaggccgttctcag
+caagggaaccccgcgaatctaggcttataccatctagattgttaactacttgcctgtagt
+tctacagccatactggacagttgtttctaaatgatcgggattcatgctagcactcctctg
+aatgcaccgcgtaagtttaactattacgtccgtgggcagataaggatggaggctgtatgt
+atcttaactgttacctaatatggctggtaattatcaaagtaaggaccttaatgccatagc
+gctagcaatcgctttgtatactgaccatgtgccaacctctcttaatctgtaaaatataat
+gtcttagctaactgtggacgatcatgtctctgcctagagcttcgctgtatcaattcctat
+agccagcgtactagtgacacaacaacaccgtgtgagaaaagatattagtccttacgtctg
+tctctctacagcttattgatgaggattgaacatggacatatagctccccctcaaaagcag
+atgctacctctttattccattctcgaacatttgccgaacttaatttcgacaaacctgagg
+tcacgtcttaatttatcggtaacgtcacgtccctttgagactggataaatatattaccag
+gggccaacgagcaattgttggaggcgcttctataatacaaggtgtcttgtcaaagaaaga
+cggcgtgcgtctcgtgcaactcacttaaccaatattaatgtgaaacccccctctctcaca
+tcttatgcggtgtactgccctggtacatttcctgtacaggactccaacagtgtagattcc
+taagatagctgttggagttgcctcacgccagatcgaaaaactgaataaactagtgagctg
+agctgcagaaataccgcttaattacttatgactagttcaaagggacctacgtgatgtcag
+acattgcaaggaagaaattaggtttgtgcgtcattttggctggactagcactccttactt
+cccctactattcaaatgtcgtaaacagcatgagacaggatcgtgctgacatttaaggtct
+attgggaacgaggctacctttggtcgcgcgctcgcgttctccgaatgaccgaaatgcatg
+agcacagtatgcaattgcttatagatctaaggtctggtcgttgaaaccaagcacgtaggc
+ctgggaaatcagttcttcctcagcaactacacaaaagcgtccaagcattagtacttgtag
+taaatgtccgaacctatgcgctcatttgaaagtcaaaaaatatttttaagcagtaggcac
+ctaacccgattcctctacttagtagctttctttgattctcagaattgactgcaatatcac
+tgcacaattctgtgccattactagacttctctgtattaacgtctcatcttactaacactc
+gcctaggacacatctgagagtgaagtatttcaatacatttactgaaatcttcagttctaa
+aatccccgaataaggctcttatcggtttggccaacacaagaaaaaaacttcttgcaccac
+tcaccttcatacgcaggagcctggggaacttagtaataactatttcggcagacaaagctt
+ataacaagttgccggcgcgtataatatttaaaagaccccttgagctgctcaattaaaacg
+ctcacctggtataggctattagatagtgccgtcttagtaaggggcgggaattatcggata
+aactgatattttgataaaataaccgacttgttcacgacataagtcactaaggagatttta
+tctttctccaaagtatatcttccttggataatttcaaagcgctgcaatttaagttctgtt
+actagtttatgctgctgggaggtgaccggaaggcgtagtaatctagaggcaaattataag
+aagttcatcatatcattttcgactacaaaaacaaggtgttgtatgccggcgcattgtgta
+aactggacgagtaccctagatggaaaattatacgttaagccaagatttcgatgtaatgat
+aattacctacacatttttgctatccataggaacaagagctgttctataggctcgtggcat
+acgaacatttgctgccgctatgaatattggaagctcttcaactacagactctattcttaa
+ttgccgtcgaaaatgggccgaatcggctattattaatactcggtttttccgaggggattg
+ttgtcgacagtcgtaattattattaatattgatgttggtgaggtcatttaaatacaacct
+tgcagacaatgaataagggatccaatctctcatactccttttacaattgctcatgcccct
+atgcaaaccttatgccgccacacctccgcaactctctcttctgaactgtaagtagcttca
+ttactggtttgagactatactgaagctgatgacattctaaaatggctattttcgaatgtg
+attcataatgtttatcgtttgggatggcagaatcacgttatttttgatatagcccgggta
+ttctattgtatagaacgtatgctacaagtcattccccgaagaagactagaagtaaacaac
+atgcgaccatcgttaagccacgcaaggctgtagctttatttcccgataacctatcttcca
+taaatagcggacagcaggatactgacgctcaacatcagtggttatggtctaatttttaac
+ttttaataaggtaacttcagcaggcatacacagtaactctttaatttataatcaaattag
+aagtctgacacttcttatatttttctatcatccaacgcgatcgcccattagcttattgtg
+ttactaataacgtatctaaaccaatccttttcaagctactgcctatattgtcaatatata
+caaacaacaggatagtaggctgcttaaaaaatattgtcaaccgtgtacgctttacaatac
+ccggaaatcacaaactttgtagacaacgagtgaaatttatacactacgaagggccagcgt
+acaagacccatgaattaggcgatatgtttattctgacatattggtttatccttaatctgt
+cgctgtaaaatgaagccgcccccatccctgcgaattttttttcgaagattcacgactgaa
+atataaatacgtttggctatatttatgttggagggaggcaatagcctttactgttaaccg
+aagatttagccagtgagtgtgacactaaaacactggaataaatgcaggcgttcttctggg
+taaaaggtttagtcaatctcgcctataagttcatatagctctggatataattatctggcc
+catgcatttatcatggcgcttggtgccctgtgtgaagccggcctctcatattgaaggtcc
+gaagtattccatgtacattaagatcactctctcattcatgcatcttggcttaacaaatct
+ggttgtccaagctttccaggcacgtatggtacaaattcggatcgaatacttataaaaatg
+atatgttaaactgtctaaaacgctcatctacaaagtaaagtgcactaaccaatagagtct
+caagaccgtgtaatgctggtgcactgaatgtgtaatacggttagaagggattagttatgt
+tacaaatccattgaaaacttaagaagcattgcgtgctcggagggtgcatcttttatcaag
+agactaacattattttcaacgacgtacatgctttacaatagggtacttatcaaacgccga
+gaaacgcgcctatagtgatgttatgattatgacccgatatccattggaccgaattttatg
+taggttcccagcgtactcgcgtaatatctcggtattgccataatgtaatacttgtcggtc
+tctcccagatgaaaaagcgttacagagtatttcaatgaaaaacagcgcgcaacgtcaata
+cctttaggggtaacggccgctgatttcatatagatatacgataagttggtatagctctac
+taggtggcatccacaatcgttgcatttactatagctggttacaatcataatctataccgt
+tccttacatactaccatagcgggatagcgtttttttgccgttgattgggtttaagaggat
+gtcagtctcattatatccgattcggtgggagagccgttgttttcaaatcgcacactttgt
+gacataatgtacaagataacaaaactgatataagatataaactgtcaatatcaccttgac
+acttgaatcaaagtaaattaactcgcaaatataatttgactaattgggtgcagatttctc
+aattaataaaaaaatggcaccggatgggcttacaagccccttatcattcacttgtatcat
+gatttccaagaacaatagaatttgctagcaagtatgaacagagattcgaattgcatccac
+agtacgccggagcgtttattttaatgtggatatgacgatgtactgttggcggcatttgct
+agtaaccggtccttatttacgtagcgcacacgtaagcatgtctgggagaaatatggtggt
+acaatctcagagaaagattacagtttggtttaaataggacttatcgggtcggaagtggaa
+cttaataagcagtacacaattgggcaacagacgtcttgcctattacaataggattacaat
+gcgttagatttcagacacgttcgtgtttggctattcgtcaattccctaaatagttagacg
+atcaactattatcaaagtgattctttgttcatcctccattcatgtaacagatggcacact
+acgcataacgccgaggaattttaacgagatttaagagagcagttcgggcacaacccactt
+gactttataacagctcggcagcataaacggtaatatgtgacaaatttccaaacgttataa
+gaacgtatgtgtacttagaaaactaagtggttcatgttcaacagatgtgacgcagcaagc
+ctaacttatctattggttttgctataaaagaacaaagttacacagaatcctaagggcttg
+tttcacacttatgcctagtgcttcaccatcttaaaatagcgaaaccggcacgaatcaaac
+cttaaaacaatgcgcagatattggtgatggtgactccgggtatgataatggtaactgttg
+accagcgcccacctcatcgaagtatagaaagtggttaggataaggatgagaccgaactta
+tttccggccataactttagattttctacctagtacacaacatcagggcggacacgaaacc
+gccatcacatcatataccaggtttaatttgcttaatgggggaagtgtcaacgaaccttcg
+aactttagcaggcatatggccattatatatggccccagagcagaatgctacagcagacaa
+aatttggatttatgtagtttaatacctatcaaacttggtgtgaccatacttgtctaacga
+cagtgcacaaagtgtaagttacaattattactactcagcagcttctgcaatgataaaatc
+ttatcatacacgtcacatatgataatatctacttagggggaacgggctccacaacctaca
+tagtactcaatacttacactattcgacaggcacaccaaacctgtacagtcccaaaagatt
+gagtcaactttgcagtactgcagatcacagtaatagcttagttagcgagtcaaaattagt
+tttctacgagactgcacgaccgtgcaaatttccgatgtgttggctacaaatagcaacgta
+tgaatttgtttgaagccacgtaaactgtacaaccttagagataagtctcaggctactaaa
+aacacgttgtggcactaacaggatcatggttgattcttacttattcggctgaccggccca
+ataagtaaccttcaactagaacagaataatcgggagtagtttaattcagtcaaggtgcag
+gtctcattgtaactaacaagctctgtgtaaccaagttaaaatcgttttcttagcggattc
+cctacttatggatttgagctcgtccacaatattcgatacaagaagtttgtggtccgtaac
+aacgaaattttaattacgctgtgcagcctcatccaaggaattaatagaaggttgatggta
+ggctccgaacgctccatgattataatcaagtggactgtgcagtaaacgaggaaggtatcc
+tgacgtcgtggtgttcgtttttgttatttgtgccctatacgagtagataaaccatgaaca
+gcacagtgtgaacccatggttgattttaggctaccttatttttaatttccgttacacaga
+aacgaattccacaactaacatgccattaatttttcgatatcttataaaagatggtcgaaa
+ttcattcatttattttttttcggttctcgaaagtcaactaagctgtcgcgttttgtttct
+ctttagaggtaaaagtggctttgatctcctacgtttggatactagtcaaccattactcca
+tttgatccgtgagtatcacctgtctaacatccagcattatgactcctcggcgaagaaaag
+acacacttcttagagtcgatgtgtattagctagggacacagttgtttaatacgatagtga
+gcccagggagggcagtgcgtcccccagtagatttattcagctagtgtaagtataagatat
+ctcacccacgaggttcaagtgatatgcagtcttagaataatacttatcctgaatttcgat
+attatgggtacttcaataatccgctagcgctactttatgtctcgttggacagcaggacac
+atggcagtcttaaacactaaagacatcacctgaatgaatgtaatgggattacaagaatca
+atgaggtattatatacgacgtaggaaactctggatatatacagtaatctagttacgccat
+cgcacttcattcctctggaaacttagaagacatcagctgtacgtggaggaaccagacccc
+cgtatgtagccaaatagaaccaaagttgcttatacaaacacacccaatgacaatggaccg
+ctggagttcgtaaactcggaacgtagtactgcacaaacccagcatttagcaataggagct
+acgtatgcaactcccacgtggtaataccttcaagctatcaatatataggtgcctagctaa
+tcgcattcgcaagcagtattcaagcttgtaaaccagtataataattacagaggctctatg
+aaacccaactttccagctaaaagtcccaattaaatggttatttcgtacttttaaagtcgc
+ccgttctgttattacgcgaattgattctactccaaaattaaacacaaattatcaaccgtt
+tcatttatatttgtcaatgcagctgtttaaaataaggctctactaaattataattaagac
+acttattaccagatttctctagttaagtttgaaccagctcgactaccgcgaaagatacat
+tcccttctctatttttcagttcatctatgggtcagagaagcattgaatttattctattca
+ccctcgtcgttcacagcgaatcgtcagtgtgatcagtgtatgagaaatatcctaaaccgt
+ttagtcagaccacacgcttagaacaagtggtctaaaaagactgccctggaaggagtaaga
+agtatacagctgatccggtgtatccttcagtcatctgccctatactaattacacgacgca
+aggaaaaataggtttattttctaggcaaacccttcataggtgactccgatgtgttacgaa
+tcatgcttgagaatgtgctatcgttaccgacggataataacgatctccaatgaaccaaat
+gtagaatgtctattgattacccttttactattcgacttagagataggagatagaacctca
+gtgtacttttttagccgaatgggaatctttgggaggtgaatggccataaggtcgtaaatc
+caaccctcttaaagtcttccatattatatcgttgttcgtggaatcgataacagatttgtt
+gacccatagtaaatgtatactagtttatgttgtaagtgtagattgttttccgattgccgt
+ccaaactttatgtcgtaattgtagaccagtaaagttgaccaaggtaagtgcccagcgatc
+ctgcgagatcgatcgccaatttttccagtcactgtaagtgtaggtttagataaagccgta
+tgagttatatcataagggcctcggaaagcagcttcgaaccaaagttcccttataatagta
+gtttaactataaaagtatatactggtctgtcgccctttcacgatttgttttaccggttta
+tgaagcgttacgtcattagagcggctccaatttaaggttaacggcttccatgtgtagttg
+tatacaaggataacttaaagtatctgttcagcgagctagttaagttatcctcgatagaac
+acaactcagaggtcccaagatcgggtttgcaacttgctaatttattctcaaggcaaattg
+ggaattatcgatacctgtataccataaggtcgctcgatgtgatgcttatgtcttctggtg
+atcctaccttagttagtgctgattaacggaacattaatgtttatcgttttgagatttagc
+caattctctgattctaactcaagatgccttatctgacgtgctatgcagcccctaagtatt
+ttacattgtaataggacacgctcctttaaaactcgccaaaaggtcgttgtggttctctac
+tggttaactatataatttacagctttgttgagctagttcctctttggtttaagtcctcaa
+tattagttggttcgagcgataagttggctagttaccttagtcactatattagatccgaat
+gttatgcttcatctgaagaccgccaccctccaaaatttcttttaagactcacttattgca
+aggtgtaggtgaattcggctcgtttctcaagtggtgtatctgtacacgagtttccatatt
+ttcatcaacagccaccgcacacttatgtcactctaggtattaaaagtcgctctacaaggg
+gacgcaattaagaaacagacatgctagtcaaaaataaacatagcgaggcaccactaattc
+ggccgcttatcaatgggatgctctgcgcgagacgcgccagagctcagtagttagttcgga
+catacatttacttcagatgatcaattagttttctacaaatgcttactctaccccgaaaaa
+agtcaccagactcttacgtctctttagtatccttccgtcttatataaggtcagtcccccg
+tttcggtaccctggaatttactaagaataatgaaacagcccccaaggacgtacgtttaca
+aatgatagaccagatcgcctagcttattccgacgcatgttgcatagaattgaaccaacgg
+aatgtgagagtaactagatgagccgaccacagcacccgtttgcgtcgcagaatacgcctg
+atagttcggccacgaaatcatatgtcctttgagtattaagtatttgtaatgatcaatcga
+gctcaagcaagcttacacttcctcggatattcagggaacttagtgcctttgaaagatacg
+ttgatcaacgaaaaattgataatggctcatatggaatgcctacctcatagtgctgaatta
+acacagcactgcggacctaacttttcgaggtttcaagttcacgtctcaaaacctaatagg
+ctggaatatgtagggatcctcggtgaatttgtgattgggtttgttgtagtactgaccaag
+tgaatattctttttttctaaaagcagatctgctgccgggcactacgaaggagatctctgt
+gtatcattattgcttcttgacatgatgactcttaaatcactgtgggtgtgcaaaacgata
+gcacaacccaattcgatagtacatattgttgatacttcgcactaaaccgttcatatttaa
+aggttgtgctccttccttcgttaaatactggtgacttggtcctatctactattagctaga
+cctctggggaaccacgcccccgtaaaacctgtgcaagagagggggtcatacatcttagac
+atcgcgcctccaccagggaagcattgggtgattgaccaggtgtgtaacaaatatgattat
+tcttatactaatattagcaaagatgcataatgatttgtattaaatgtataattgaattga
+taagggtcttttagtcagtgatagagtagtataaggtagacattagaactcttaaccgga
+cgcagatttttcggtcttagtaagccaattagtcgacaaaacaaggtaagagcggttact
+agtagtacctataatgcactgaatcttcggtcgaagtatagttctaatgctatgcagatt
+gtgacggcgacaaatgttcagacttatatcatgaaacaagctcttgtaagtattgacaaa
+tgaaaagattgaatatttttaaatacaaaatgcgcctacttattaggggaattaaccaga
+ttgaaggccaatcctcacatgtaatgagataatagacgataaatgaaattcttgtaatag
+ttgaactgctacgtgatgggtattatatatgattgagatcctccaattgccgacgtcttg
+tcttgatgcccaaaagattgtcaacgaggagctccctcgcgtacctgtcgtccgtatcat
+aaacgacgcgacatgtacagcactccgaagtataagcaataataatgcgggtaatccaga
+ctagatcttttcggactcaatgcggtttcacggtaaacatgattaataccggagagtagt
+cgagcttatcagcgatgcaagcgaattcattgtgccaggagatacgttgcagataaaacc
+ggcaacgtatgtcaacaagttttggcgatctcgttgtttgtattcgacgaggcgcgggaa
+cttcaagaactatcgtatattcaagtccattaccttttagtttcagactggtggagctga
+ctaaagttatatcatcattttgtacactggtttagttaacgataatttcagatttaacat
+gaccagacgataatcgctgtatatccagttggaatgtggtttgccagaaaggttaactta
+taatcaagcctctcttcagtcttgattcgtcgtatcccatccattgcgctatacctcagt
+gtatttggagctgtagttataccgtgtgctaagatcagtagacatgacgagagcaatatt
+atctaccttacaagcatcaacggacgtctagtcggaacaaaagactctaaaactcgaact
+tcaggttaatatactatagttctgtattcagcagttattcttatattcgatattatcttg
+cctattggatgtctgactttagtatattaatcatagtatctgccatgtaaaggtgccagt
+actaaatctgtttcacagtgcgaattataaacggttacaaccattaaagacaacaagacc
+ctatagctttatttgaattttgtcaatgcgcaacttggagctcgcgatacatcccaatta
+gtctatagggtcgggacgattctacggcatttctggttataatgacaacatggattgtgg
+cccgagaatcgctctttcattaattaagcaatcattacagtcttataagcgctacttccg
+agtggtagcaggtaactcgatataaggtcgcatgagccgaatagcttaaaaaacaggcca
+ccgaacattgatagagaataccgaccacagcgcaacctttgattactttcattaaattgt
+acggctcactcgacatcaagcttaagattgcgataatgtgaactcaaatggatcagtact
+gaagaaccgtaacccacttcgcagaaagcgtacccagagaagatacgctgttacaatata
+cagggtgaaattattgcctgttcttcgtaaccatttcgccaaacttggttagaaatgata
+gccattcatgatagaaataagctgaatgataccagtatctttaactatgtagtcaggggg
+aagataacgatggtccatgtatgtttctgatatgtgacagtattggccgcgtaatttgct
+aacgaagctacttaatgcctttgagcttcatatagatttctttaatcaaaatcggcaaaa
+agatagtatgagctataatatatgctagtagagaactctggaccatcatctatatgaata
+ctgattcgagcgtgcaattactttagcctgcgtactactgactctacaaaacactctgag
+ataagtttgtagtcagtaagtcgctctctataaaccttttggatgaccattgtacagcca
+cttatagatcccaataaatagcacaggagacagagtttttcaatgctcgatcatttgccg
+atagtattttcgtctaacctcagggcacctattatttgatacctaacctaacggcccttt
+cacaatggagaaatatatgacatcgggacaaacacaaatggtgggtggccaggagatatg
+acatggtggcgtctctaagaaacacggactccctctaggcaaactcacgtaaccaatttt
+aatgtcaaacaaaacgctcgaaaagattttgccgtgtaatgacctggtacattgactggt
+caggaatacatcactgtagttgccgtagtgtcctgttggtgttccatcaagacacatcgt
+ataacgcaatttacgacggacatcagatcaagttatacagattatttaagtatcacgtgt
+gcattgggacataagggatctcacacatgccttggaacatttttgctttgtgccgctttt
+tcgctgcactaccaatccttacttaccagtatattcaaaggtcgttaacagaatgagaaa
+ggttagggctctaagttatcgtcgattgggatagacgagacatttgcgagcgccctccac
+ggatacgaatctcccatatcaatgtgaactggatgctatgcagtttagttcttacgtctc
+ctagtggtaaaaatcaaagtagcactcgcatagcagttattcagaacctaatacacaaaa
+ccgtcaaacattttctaattctaggtatgggccgatcataggagctaaggtgaaactcat
+aaatgttttgttagatctagcatcctaaaaagatgcatatactgagtagctggcgtgcat
+tctctcaattgtatcctttttaactgaactagtcggtcccatttcgtgactgagatctat
+taaccgataagattaataacactcgcattcgtatcagctcagagtgaagtttttcaataa
+tttgactgatatattaacttctaaaataaccctttaagcctcggatccgtttcccaatca
+catcaaaaattcttattccaactatctacggattaacaacgtgcatggggatcgtagtaa
+gaacttgttccgatcactttgagtatatcaagttgacggcccggttattattgaatagaa
+acattcacctgctaaattaaataccgcacatcggatacccgatttcagagggccgtctta
+ctaagggcaggctttgttcggtttaactgagatgttcattattttacagtatgcttcaac
+taatatgtaacgaaggacagtggatctgtctccatagtagatcttcagtcgtgaatttca
+taccgctcctatttaagttcgcgttcgagttgttgatcatggcacgtgaaagcaacccct
+agtattctagacgaaaattttttctagttcatctgataatttgccaattcaaaaacaacc
+gctggtttcccggcgcattctctaaaatggaagtcgaacctagagccattatttgtcggt
+aacccatgagttccttcttttcagaagttaatacactgtggtcctatacagaggaaaaac
+agcggttatatacgatcgtggcataacaacattggatcaagatagcaatttggctaccta
+ttctaattctcactagattcggtattccactacaatatcggcagattaggattggatgaa
+taatcggtgtttaagtccggttgcgtctccaatctcctaatttttattaatattgatctt
+ggtgacctattgtaaataaaaacttcaagactttgaataacggtgaaaagatagaagact
+catttgaaaatggatcatccacagatccaaacattagcaagacactaatccccaactagc
+tattctgatcgcgatcgtgctgcagtactcctgtcacaatagtctgttcatgatctaatt
+ctttttgggctttgttcgatggtgattcagaatctttatccggtcgcttccctgtagcta
+ctttgtggggatattgcccggggattatagggttgagatcgtttcctaaaagtatttaaa
+ccaagtagacttcaactaaactacatcagaacatcgtgaagacaccatacgcggtacctt
+tatttaccgataacatttcttcaagaaataccggtaagcagcataatgaccctaaacagc
+tcggggtatcgtcgtagttttaaattttatttaggttactgctcaaggaataaaaactaa
+ctatttaatttataataatattacaaggctcacactgattagatttgtctataagacttc
+gcgatcccccattaccggattgtcttaagaataaactagataaaccatgcattttctaga
+taaggcctttagtctaattagatacaaaaaacacgatagttgcatccttaatttattgtg
+tcaaacctggaaccttttaattacccgcaaatcactttatgtcgagactacctctgaaat
+ttattatctacctaccgcatgaggacttgaaccatcttgtaggagttatgtttattagct
+aagattcgtttatcctgtagcggtccatgtatattcaacaagcaaaaagcactcagaatt
+gtttttagttgagtcaagactgatatataaataagtttccctagttttttcgtggtggga
+cgatattgaattgaatcttaaccgaagagtttcccactctgtcgcacaataatacacgcc
+aatatttccagccctgcttatgccttaatcggttactcaatctcccattgaagttcattt
+tgatctgcatagaagtttcgggcccagccttttttctgccaccttcctccaagctctgta
+gacgcactctaagattgatgctcacatgtattaattctacattaacataaatatataagt
+catgcatcttcgagtaaaatatctggttctccaacatgtcctggcacgtatcgttataat
+gcccatacatgtagtattaaaatgattgggttaactggatattaagatcatcgaaattgt
+aaagtcaaattaacaatactgtctcaagaccgtgtattcctcgtgctcggaagggctatt
+acgcttacttccgttttggtatcttaatatgactttcaaaaattaagttgcagtgagtcc
+tacctgcgtgcatcggttagcaagagtataaaagttgtttaaacgaactacttgctttac
+aataccggtcgtatatatcgccgtgaatccagaagattgtcttctttggattatcaaccg
+agatcctgtggaccgatgttttgggaccttcacagaggactccaggtagagctcgctttt
+gcattaatctaagaattgtacctctctaaaagatctaaaacagtgaatgtgtatttcatg
+gaaaaacacagagaaacgtaaattactttaggccgaaaggcacatgagttattatacata
+tacgagatggtggtatacatcgaattcggggcatacactatagttgcattgtatttagct
+gctttaaataatatgatattaccttccttacataagacattaccggcataccctggtttt
+caacttgtggggctttttgacgatcgcactctcatttgatccgagtagggcggtgacccc
+tgcttttcaaatacaaaaatttcgctatgaaggtaatagattacttttcgctgttatgat
+agaaacggtaaatttaaaattgaaacttctagaaaagtaaagtaacgagaaatgattttg
+tgaataatgcggtcatgattgcgcaagtaagaaaaaaaggcaaaaggatgcgcggaatag
+aaacttatcagtcacgggtatcttgatttcattcttcttgtcaattgccgacataggatg
+aaatcagattccaatgcaatacacagtaacccccacccttgattgtaatgtcgatttgaa
+gttgtacgcgtcgacgaagtggatagtatacgggccttttgtacggtgcgatcaactatg
+aatctcggcgagttagatggtcgtacaatctcacacatagaggtcacttgcctgtaatga
+cgaattttcggctaggtactcgaactttattagaagtaaaaatgtgggcaaaagaaggat
+tccattttacaagacgattacaatgagttacatgtctctcaacgtagtctttccctagta
+gtctttgaactatttaggtactccagaaaattttagcaaagggtttctgtgtgaatccgc
+cattcatgtttatgatggaacaataagaataacgccctcgtatgttatcgacagtgaagt
+cagcagttcggccaaaaacatattcaatttagtacagatccccagaagttaagctaagtg
+ctctaaaatggcctaaacggttatcaaagtaggtctaattactatactaacgggtgcatc
+gtaataactgctgtcgatgcaacactatatgatagtgtcgttttgctatatatgtacaat
+gtgacaaagaagccttagcgattcttgcaaacttaggacttcggattctcaatcttaaat
+gtccgaaaacgcaaagattcaaaaatttaatctatgagcagatatgcctgatggtgacta
+cgcgtatgttaaggctaaatgttgacaaccgcacacataatcgaactattgatagtcggg
+agcataaccaggtgaacgtactttgttcacgacatttattgacatgttctaaatacgtct
+caaaatcacggcgcactagaaaacgcaatcaaatcattgtcctggtttaagggccgtaat
+gccggtagtgtcaaacttcatgagaactttagctggcttttggccagtatttagggacca
+agagcactagccttaagctgaatattttgccatttatctactgttataactttaaaactt
+ggtggcaccagacttgtcgatacacacgcatcaatctgtaacgtaaaaggtttactaaga
+acaagcgtaggaattgagtttatattatatttaaactaaaagatgatattagcttctgag
+ggcgatagggctccaaatcataaagaggaatatattattacacgattagaaacccacaac
+atacctcgaatcgcccaaaagtttgacgaaacttggcagtactccacatctcagtaatac
+agttgggagagtctcaaatgttgttttattactcaatgaaccaccctcataatttcactg
+ctgttccattaaatttgcaaacgatcatttgctttgaagaaacgtaaaatcgacaaaatt
+acagataagtagatgcataataaaaaaaactgctcgctataacacgatcatcgtgcattc
+ttacttaggagcatcacccgcacaataacgtaccttaaactacaacactattagaccgag
+tactgtaattcacgaaagctcaagctcgcattgtaaagaacttgctctctcgtaaaatgt
+gataatagtttgcggagaggattcaattattttccattgcacctactccactagattcga
+taaaagaaggtggtcctcccttaaaaagaaatgttaagtaacatcggaaccataagcaaa
+gcatgtaagtgaaccgtcatccttccctaagaaacataaaggtttttaataatgtcgact
+gtgaactataactgcatcctttcctgacctactccggttccttgttgttatttctgaacg
+agaccagtagataaacaatgtaaaccacagtgggtaccaatggtgcatgtgacgctaccg
+ttgttttaagtgcccgtacaaacataagaagtcataatcttacttgaaattaattttgcc
+ttttattttttttcaggctcgaaattaatgatttgttttttttgaccttctagttacgct
+aatatgcggtcgcctgtggtttctattgagtcctataacgggatgggatctaatacgttt
+ggttactagtaaacaaggtataaatttgataccggagtatcaactgtataacatcaagct
+ttatgactcatacgcgaagtaatgacacaaggctttcaggagatcgcgagtacagagcca
+ctaaggggtgtattacgatagtgacaccaccgagcgcactcactccccaagtagatttat
+gatcctacgctaagtattagatatataaccaaagaggttctagtcagtgcaactcttaga
+ataataattagccggttttgcctttttaggcctaatgcaatattcagctagcccttatgt
+atctcgcgttccacagcaccactcatggcacgcgtttaaactaatcaaatataatctatg
+aatgttatgccagtacttgaataaatcaggttttttataagtccttgcatactctcgtta
+tatactgttagagtcttaccccatagaaattctttcatctgcaaacttagaagaattctc
+agctacggggagcataaagtccccaggatgttgacaaatacaacaaatgtggcttataca
+aacactccatatgaaaatcgaaccctcgtggtagttttagccgaaccttgtacggataaa
+tccctccattttccaatagcagatacctatcctactacctcgtggtattaaattaaagct
+tgaaatatagagctgcatagcttatccaattcccaagcacgagtctaccgtcgtaaccac
+gatttgatttacagacgctagagcaaacccatctttaaacatataagtaaaaattaaagg
+gtgagtgcgtacgtgtttactagcaacttcgcttattaagacaattgtttataagccata
+attaaaaacatatgttcaacaggttcattgatatttgtaattgcacaggtttttaataag
+gatctacgtaagtataatgaacaaactttttaccagagttatattctgtactttgaaaat
+gctcctctaccgccttagagactttcaattagattttttgcagttaatctatgcgtaagt
+gaaccatgcaagggatgcgattcaaccgcctcgtgctaaccctatcgtctgtctcataac
+tgtaggtctaatataattttcagttttcgaacacataaccctttgaaaatctgctattta
+atgtctcacctgcatgcactatcttctatactgctcagaacggctatacgtcactatgct
+ccaagtgacgatttaaacgaagcaaggaataataggtttattttagtgcaaaacaattaa
+gtgcggactacgtgctctttacaataagccttgtgattgggctataggttaagtcccata
+ttaacgatctccaatgtacaaaatcgacaatcgctttgcattacccggttactagtcgaa
+ttacagatagctgttagatactcactctaattttggacaacaatcccaatcttggggtcg
+tctatcgcctgaagctcgtaaatccttccatcttaaacgattacatattatagacttgtt
+cggggtagagatatcacagttgtgcaaacattgtaaatcgatactagtttatgttggtag
+tctagttgcttttaccattccccgaaaaacttgatctactatttcgacaacagtaaactt
+gaactaggtaagtgaaaacagagaatgcctcatagtgccactatttgtccactatatgta
+agtgtagctttacataatccactatgactgagatcattacggcctaggaaagcagcgtag
+aaaaaaagggcccggatattacgactgtaactataaaactagttactggtagcgcgccat
+gtatagatttgttttaccggttgtggttgcgttaacgaatttcagccgcgaaaattgatc
+cgttaaccagtccatctcgacttctataaaacgataaagtaaagttgatgttcagcctcc
+ttcttatggttgcatcgagagtacactactcagtgggaaatagatcggggttcctacttc
+agattgtattatctaggcaattgccgattgtgccatacctggataaaataagctacctac
+atgtgatgcttatctattatcgtcatactaccttagggtgtcctgttgaacgctacatta
+atctttagccgtttgagatgttccaatggataggagtctaacgcatgatgaagtttagga
+aggcagagcatcccactaagtatgtgacagtgtatttcgaaacgagacgttataaataga
+aaaaaggtccttctggttctattctgctgaactattgaatggaaagattggttgacctac
+gtactatttgcttgaagtcatcaatttgacggggtgagagacatatggtgcatactttac
+ggactctatattttagatcagaagcttagcagtcttctctacaccccctcacgacataat
+tgcttttaagaatctatgtttgattcctctacgggaattcggatccgttcgcatgtgcgg
+tttatctaaaccaggggacatatgttcagctaaagcatacgaacactttgctaactagac
+gtatgtatagtagctataaatcccgacgatatttacaaaaagaaatgagactcaaatata
+tacatagcgaccctacacttattcgcaccctgatctaggcgatcctagcacccacacccg
+aaagtgagcactagtgtcttccgtattaaatttactgcagttgagattttagttgtctac
+taaggattactctaacccgtaataaggatcaagactcggtactagctttactatcattcc
+ctatgtgttttcctaactcacaagggtacgtaccagcctatgtaattacaataatgataa
+agacacaaaggaagtaactttacaaatgagtctccagttacactagcttagtccctccca
+tcttgctttgaagtctaaatacgcaatctctgaggatatacagcagaagaacactcataa
+cgttggagtccaagaattagactcatagggcccccaacatttaatatgtactgtgagttt
+gaaggtgttctattgttaattcctgctcttgatacatgacacgtactccgtgtttaaggc
+ttcggactgactttctttcataagttgagcaacgaaaatttcagaatcgataagttggat
+tcactaactaatacggctgattgaaaactccactccggacctatatggtcgacctttata
+cgtaaccgatataaaacttataggctggtatatcgagccttcctagcgcaatttcggatg
+gggtttcttctactactcaacaacggaatagtctttgtttagtaaaccagagctcaggac
+gcccaatacgtaggagagcgctgtggagcatgtgtcattatggactggagcactcttaaa
+tcactctgcgtgtgctaaacgatagatcataacatgtcctgagtaaattttcttgatacg
+tcgcaatataccgttattagttaaacgttctcatccgtcatgcgtgaaatacggctgtcg
+tgctcagatatactattagcgactcatctcgcctaacacgcacacgtataaactcggaat
+gactgccgctcttacatattagaaatacagactacaccacggaagcattgggtcattctc
+aaccgctgtataaaagatgattagtcttataataagattaccaaagaggcagaatcatgg
+gtagtaaatctattattcaagtgattaccgtcgtgtaggcagggagtgaggacgagatgg
+tactcaggacaaatattaaccggacgaagtggtttacgtcgtactttcactattagtagt
+aaatacaaggtaacaccggggaatagtactaaatataatgatatctatcttcgggagaac
+gagtcgtctattgctttgaacattctcaaggcgtaaaatgtgctgacttatagcatgata
+caaccgattgttacttttgtctattcaaaagattgaatagttttttatacaaaagccgca
+tacttatgacggctagtatacagtttcatcccctagcatcaatgctatggacagtattga
+acttataggaaattcttctaatagggcaaatccgtcgtgatgcctattttttttcagtca
+catcctcaaatggcactagtattgtcgggatcccattaacaggctcaaccacgagctcac
+gcgaggacatgtagtccgtatctttaacgaagcgacagcgacagaactcccatggataac
+caattataaggcccgtaatcctctagacatcgtttaccaataaatccgctttctccgtaa
+tcatgttgaataccccagagtagtccagatgataaccgatgaaacacaagtctttctcaa
+tgcacttacggtgaacttattaccgccaacgtagctcatcaaggttgcgacatctagttg
+tgtgtttgcgacgagcccagcgaacttcatcaactttcgtatattcaacgccttgtaatt
+ttactttaagacgcctggtgatgtagattcttagataatcagtttgttatcggctgtact
+ttaccataatttcacaggtttcaggtcaagaagattatagctgtatatacagttccatgc
+tcggtgcacagaaacgtgatcggataataatcaatcgcttatgtcgtctttaggcgtatc
+caatacatgccccgataccgcagtgtatttcgacatgtaggtataccgtcgcatttgagc
+tcgagtcaggacgtcagctagattagattccttaatagaatataccgacctctagtccga
+actaaactatagataacgccaacttcaggttaattgtctagtcgtctgtttgcagatggg
+attcttagatgagtgagtatcggccatattggttcgagcactttagtttttgatgcatag
+gatatgcaatgtatagctgaaagtactttatctgtttcaaactcacattgattaaaccgg
+taaacctttaaagactacaagaaaatattcagtgagggcaattttgtcaatcacaatctt
+ccagctagagatacttcacaatttgtcttgaggctacgcaacattagacggattttcgcg
+ttttattgaaataatcgaggggcccaagagtatccatagttcattttgtaagatttcttt
+acaggcttattacagcttcttcagactcctacatgcttacgagttatatgctagcatgtg
+aacaatagattaatatacaggaaaacgtacattgagagagatgaccctacacagcgcaac
+cgttgagtactttcattaaagggtaacgctctcgagacagcatccttaagatggccttat
+tgtcaaatcatttgcagaagtacgcaagatccctaaccaacgtagaagaatccctacaaa
+cacatgagacgcggtgaaaatagacagggtgttagtattcaatcttcggagtatcaattt
+cgccaatcttggtgagaaagcataccctttcttcagagaaagaagatcaatcataacact
+atctttaacgaggtacgcacgcgcatcattacctgcctccatggatctttaggatagcgg
+aaagtattggcagcgtattgtgatttcgttcctactttatcaatttcacattcatataca
+tgtcttttatcaaaatcgccaataagataggatgagctatattagatgctagtagagttc
+gcgccaacatcatcgataggaatactcaggacagcgtgataggacttttcaatccctaat
+actctctataattataactctctcttaagtttggaggcagtaacgcgctctatataatca
+gtttgctgcaccattcttcagcctctgatacatacaaataaattccacagcagtaagagg
+gtttaattgagacatcttgggaacttaggattttactctaacatcaccgaaacgattatt
+ggataccgtacctaaacgaactttctcaaggcagtaatataggacatccgcaataacaca
+aatgctgcctccccaggagttatgtcttcctggaggctatatcttacacccactcactat
+aggcaaactaaagtttaaatgttgattgtctaaaaaaaagatagataagagttggccggc
+gtagcacatgcgaaagtgaatcgtaagctataattctctggacttgaagttctgtcctgt
+tcctctgcaagaaacaaacttcctttaaagctatttacgacgcacatctcagcaagttat
+aaacatgttggaagtttctagtcggaattcccaaagaacggatctatctaatgcattcct
+acatttttcctgtctgccgatggtgccatcctattcaaagaatttcttaaaagtagatta
+aatgggacttttaacaatgagtaaccttacgcctctaagggttcctcgagtgccatacac
+cagtcaggtccgagccacatacacggagaacattctaacatagcattctcaactcgatca
+tttgcaggttacttctttcctatcctagtgctaaaaatcatacttgcaatcccatagcac
+ggattaagaacctaagaaacaattcagtaaaacatgttcgaattcttggtatgggaacat
+cattgcagctatggtctaacgcattaatgtttgggtacatcttccatcatataaacagga
+agagtctgacgacagggagtgcttgcgatcatgtctatcattgtgaaatcaaattgtagc
+tcacatgtcgtctatgagagcgtgtatccgataagatttagaaaaatagaagtcgtataa
+gatctcactgaacttttgaatgaatgtgaagcatatatgatctgctttaataaaacttta
+tccataggatacgtttccaaatcaattcaataattattagtcaaaatagataaggatgaa
+caacctgaaggccgatcggacgtagaaagtggtcccatcactttgagttgatattgttga
+accacacgttattatggttttcaaacagtctcaggatattgtatatacagataatccgat
+accagttgtctgacgcccctcttacgtaccccaccctttgtgacgtttaaagcagttgtt
+cagtattttaaactaggcggcaactaatttggaaagaagcacagtggatatgtctaaatt
+cttgttattcaggcctgaatttaatacaccgcatagttaacttcgcggtagagttgttca
+tcatgcctcctctaagctaccacttctatgatacaccaatagttgttctacggaatctga
+taattggccaagtcataaacttccgctgcgttcaacccccttgctcgaatatccaactcg
+aaaagacagccttttggtgtccggaacaaatcagttacttcttttctgatgttaattctc
+tgtggtcagatacagaccaaaaactccgcggatttaccatcctccaagaacaaatttgca
+tcaacatagcattttggctacatattctaagtctcaatagtttaggttttcaactacatt
+atcccaacattaggattggaggaataatagctgggtaagtccccttgcgtctacaatcga
+ctattttttatgaatatgcttctgccgcacctatggttattaaaaaagtcatgactttga
+agaaccctgaaaagatagatgaatcaggtgtaatggcagcagccaaagagcatataatta
+gcaacactctaagaacattatagatatgatgatagcgatcgtcatgatgttatccggtca
+caatagtagcttcatcagctaattcgttttgccagtggtgacttgcgctggaagaatcgt
+tatacggtcccttccctcttgatacggtgggggcttattcaaccgcgtggattgggttgt
+catacttgcattaaacgatgtaaaccatctagtagtcaactatactaaatcacaaaatag
+tgatcaatacatacccgcttcatggttttaaccatttaattgattaaagatattccgcta
+agaaccattatctacctaaactgatcgccgtatcctagtagtttgaaatttgatgtaccg
+taatgatcaacgaagtaaaacgttatattgtatgtagaataataggtcttggagctaaat
+gatgtgattggtagtgaagacttacccttacaactttaccggtttctcggaagaatatac
+tagagaatcaatgcatgggctacataagcactttagtctaatgagataaaaaatacacga
+gtcttccatcatgaattttttgtcgaaaaactcgaacctggtaatttaaaccatatatct
+ttatgtcgtcaataactctcatatgttttatataacttcccaatcacgacttgtaactgc
+ttgttcgactgagctgtttgagctatgaggccgggatccggttgagctacatctatttgc
+tacaagaaaaatgaaagcacatttgttgggagttctggctacactcatagagaaataagt
+ggcccgagtgggtgcggcctgcctccatattcaagtgtatcttaaaccaagtggttccaa
+cgctcgcgctaaagaattaaagcctttatttcctccacggagtagcccgtaatccggttc
+gaaagagaccattgaagttaattttcatatccagtgaagtttaggcacaagcatgtgttc
+tgccacatgcctcaaagcgctcttcaaccaagatatgattcatcctaacttcgatgaatg
+cgtctgtaacataaatatagaaggaatgattcggcgagttaattttcgccttctccaaca
+tggcatccctacgttcgttataaggaccatacatgtaggttttaaaggtttgcggttaat
+cgatatttacatcatagaaattctatagtcaaatttacaagactctagatactcactcgt
+tgcagccggctaggaagcgctttgtaccttacttcccttttcgttgcgtaatatgaattt
+catatagtaagttcaaggcactcatacctccgtgaagagggtagatagactattaaagtt
+gtttaatagtacgtattgatggaaatgacccgtaggagatttaccactcaatccacaaga
+ttcgctgctgtgcattatcaaaacagtgcatgtcgaaacatgggttgggtccttcaaaca
+cgaatccaggtagagatacctttgcaatttttcgatgaaggcgaccgagataaatgagct
+ataacactgtatgtcttttgattgctataaaacacagaaacggatattaatttaggccgt
+aaccaacatctgttatttgacatagaacagatggtcctttacagcgtattccggccttaa
+tattgaggtccagtgtattgtcctcctttaaagaagttgattgtaactgacttaaataag
+acatgtcacccattcactgggttgcaactgctggccctttttgtccatcgcacgctaatg
+tgataacagtaccgccctcacacctgcgtttaaaagacataaatgtcgctatgaaggtta
+ttcattaattttagctgttttcttagaaaaggtaaatttaaaattgaaaaggctagaaaa
+ctaaagttacgacaaatgtgtttgtcaagtaggcgggcatcattgagattgtaagaaata
+aagccataaccagccccggaatagaaaatgttaaggaaaggcgatcttctttgaattctt
+attgtcaagtgcagtcatacgttcttatcagaggacattgcaataaaatctaacaccctc
+ccttgtgtggttgggccatttgtacttcgaagcgtccaccatgtgcagaggataacggaa
+tgtggttccgtcccataaacgatcattctcgcccacttagtggcgcggtaaatcgctctc
+atagaggtaactggcctgtaatgtccaatgttaggctaccttctccaactttagtacaac
+gaataatgtccgattaacaaggagtcaatttgtcatgaccagttcattcaggtacttgta
+tctatacggacgcgttccagagtagtatttgaaattttgaggttctactgataagtttag
+ctatcgctgtatgtctgaataagaatttaatgtttatcttcgataaataacaattaacaa
+ctcctaggtgatacactgtgaagtctgctgttccccaaattacatatgctattttgttca
+cataccatgaagttaagctaagtgctctataatggcataaacggttatcaaactagctcg
+aatttcttttattacgccggaagcggattaactgctgtagatcaaacacgttaggatagt
+gtcgttttcatatatatctaaattcggtctaacatgcattacccatgcttgataacgtag
+cacttcgcagtctaattatgtaatgtccgtttaaccaaactttaaaaaagtttatctatc
+accagtgatgcctcatcgtgactacccggatctttagcctttagggtctaaacagaacta
+atattactacgtgtcatactccggagcttaaccaggtgaaacttatttgttaaccaaatt
+tagtgacagggtagaaatacgtatcaaattaacccagcaatacaataagcatgaaaataa
+ttgtaatcgggtttgggccggaatcccgcttggcgaaaacttaatgacatagtgtgatgc
+attttgcactggattgagccacaaactcaactagcattatgctcaatatttggccagtgt
+tctacggtttgaaatttataaaggccgcgcaaaagtcttgtagttacaaacgcataaatc
+tcgaacgtaataggtttaattagaacatccgtaggatttctgtttatagtagatttatac
+taaatgttctgattagattctgacggccttacccatacaattaataaagacgaatatatt
+agttatagtttactatccaaataaattaagcgaatcgaaataaactgtcacgatactggg
+cagttatcaacttatcacttatacagttcggacactctatattggtctgtgagtactcta
+tcaaactaactcataagttaactgcgcttccattaaatttcaatacgttcttgtgctgtg
+tacaaacctataatcgaataaatgacacatatggagatgcataataaaaaaaacggctcc
+atatttctcgttaatcgggcattcttaaggaggagcatctcaccaaaaataacgttcctg
+ataagtcttaactattagaccgtcttcgggaatgaacgaaacctcaagctagcatggtat
+agttcttgatagcgcgtaaattctgataatactgggcggacagctggaaattagttgcca
+gtgcacctacgcaaatagtttacataaatcaacgggctccgaacgtaaatacaaagggtt
+agttacatcgcaacaagatgaaaagcatgtatgtctaccgtcatccgtccctaacaaaca
+taaaggtggtgaagaatctcgtaggtcaactataactccatccttgaagcaactactccg
+cgtccgtgtgcgtagttcgcaacgagaacactactgaaaaaagctaaacaactctcggta
+caaatgcggcttgtgtcgataaagttggtggtagtgcacggaataacataacaaggaata
+ttatttattcaaattttttgtgactgttatttgttttctgcctagaatgtaaggatgtgt
+tttttgtgacctgatagttacgcttatttcaggtccacggtgcgtgagagtgtgtcctat
+aacggcaggggagcgaagtagtgtcctttagactattcaaggtagaattttgataacgct
+ctataaaaggtagaaaatcatgattgagcaataagaccccaacttatcaaaaaaggagtt
+ctcgacagcgcgtgtacagtccctataacggctgtatttcctgtgtcacaacaccctccc
+atcgcactcaaaatgtagatttatgatcagacgctaacttgttcttagagaaaaatacac
+gggatactctgtgcaacgatttcattaataaggtgcagcttgggacttttttggccgtag
+gctttattaacattcacagtaggtagcgagacttcctatgaaccaatcatgccacgcgtt
+ttaacgtttcaaatataagctaggaagcgtttgccaggacttctataatgcaccgttttt
+tttagtacttccttactagccttagtttatgttagagtctttccaattacaaaggattga
+atagccaaaatttctacaattctcagcgaacgccagcttaatctaaacacgagcttcaaa
+tattctacatatcggcaggagtcaatatataaatatgaaaatcgtaccatcctcgtactt
+ttagaccaaacgtcttcggataattaaatcctttttcaattaccacagtacgtgcattag
+aactactgctatgaaagtaaaccttgaaatatagtcctcaagagcgtatccaagtacatt
+gcacgtgtatacagtcgtataaacgagttgatgttctgacgctagagcttaccattcgtt
+aaacagataactaaaatttaatggctgagtgacttagtgttttcgacaaacgtcgcggat
+gtagactattgtttataagcaatttttaaaaacatatgttcaaaacggtatgggatatgt
+cgaattccacaggggtttatgtaccatagaagtatgtataaggtactaaaggtttaaatc
+tgtgatattcggttcggtgaaaatcagactagtcacacttagtgtctgtaaattagattg
+ggtgaaggtaagcgatcccgaactctacaaggcatgggatgagattctaccgactccgga
+taacactttacgatcgcgcataactctagctcttagataagtttaacttgtcgatctcat
+aaacagttcaaaatctgcgatttattgtatcaaatccatcctctatcttctataatcatc
+tgaaccgcgatacggcactatgagccaagtgaagattgaatccaagaaagctataattgg
+tttattttagtccatttaaattaagtccggtataagtgctctgtacaatatgcagtctca
+tgggcatatacgttaactaccttttgatacttcgaattggtaaaatatcgactatcgatt
+tgcagtaaaaggtgtagagtccaattactctttcctgttacatacgatctcttagtttgg
+acaactagcccatgatggcgctcctctagcgcatgaacctactttataattacatcttta
+tcgatgaatttttttagactgcggaggccttgagttttaacagggctgctaaatttctta
+agcgattagacggtagcgtcgtacgctacttgcttggaacaggcaccgaaaatattgatc
+tactattgcgtcaactctattctgctaatagcgatggcaaatcacagaagccctcttagt
+gacaatagttgtcaactatatctaagtcgacctttactgtatcaacgatcacggagagaa
+ttaccgaatacgaaacctcaggactaaaaaacggaaaggatttgtcgacggtaaatataa
+tacttgttaagggtagcgacacaggtatactttgggtgtaaacgtggtgcttcccggaac
+gattttcagaccagaaaattgttccggtaaccaggaaatctcgtctgcgttaattcgtgt
+tagtaaacttgatcttcagactccttcttttcgttgcagcgagacttaaattatatctgc
+gaaatagtgccccgtgcatacttcagatggtaggagataccatttggcccattgtgactt
+tacgcgattaattaaccgacatacatctgttcctgagctatgatcgtctgaataaattac
+ggtctcctcttgatacctaatggtttctggagacgtttctcatgttcaaatggatagcag
+gagatcgcttcatcaagtttagctacgcagagcatcaaaatatgtatgggaaagtcgatt
+tccaaaccagaagggataaagagaaataacggacttctccgtagattagcctgatatttt
+gatgggaatcatggcggcacatacgtaagagttgcgtgaacgaatattttggacggcggg
+agacacatatcggccattcgttaaggtctctatattggacatcacaagcttagcagtatg
+agctactaacactcaagacattattgattttttcaagatatgtttcattcctctaccgct
+attcccatacgttcgattcgccgggtgagcgaaaccacgggactgaggttaagctaatca
+ataacaactcgttgcgatagagacctatgtatactagagagaattccccaacatttttac
+aaaaacaaagcagactaaaatagatacagtccctccatacaattaggaccaacatgttat
+tgccgatcctagcacacacaccacaaactcagaacttctgtcttacctatgaaagggtct
+gcacttctgattgtacgtgtctaattagcattaatattaaaactaattaggataaactat
+aggtacgagctttactataagtcactaggtgttttccgatcgaaaaacgggaccttcaag
+ccttggtaagtacatttaggataaagaaaaaaaggaaggtacgtgactaatctgtctaaa
+ctgacaatagagtagtacctacatgcttcatgtcaagtcttaatacgcaagcgctctcgt
+tatactgctcaacaaaactcataaagttggactccatcatttagaatcatagggaccaaa
+acatttatttgctactgtcactttgtaggtgttctattctgaattcctcatattgataca
+tgaatcggaatacctgtggatcccttaggacgcacgtgctttctttacgtcagaatacat
+attgtcagaatcgagaagttccatgcaattaagaattcgcctctttgaaaactcatatcc
+ccacatatagggtccaccgttattcggaaacgatataataattattccagcgttgagcgt
+cccttaagagcgcattttcgcttggcctttcttctacgactctacaacgcaagtggctgt
+gtggagtttaccacagcgcagcaccccatagaactacctctgagagcgcgagatggtggc
+agtatgctctgcagctagcgtttagaacgcgcccgcgcattaaccagtcatattaaaatg
+gactgtcttaattgtcggcattaggagcaatattaactgatgagggtatcggtcgcagaa
+gtaatgacggaaatacgcctctagtccgcagagatacgattacagactcagatcccctaa
+caagcaaaacgattaaatcggaatcactccccctatgacatatttgaaatacacaagaaa
+ccacgcaacatgtcccgcattctcaaccgcgctttataagatgttgagtctgagaattag
+atgacctaactgcaagaatcatggcgagtttatctagtaggcaagtctgtaccctagggt
+tcgaacgctgtgacgtcgtgatcggtctaaggacttagatgataaccaagaactggttta
+ccgagtactttcactattaggagtaattacatgcgttcaccgcggaatacgacgaaattt
+tttcatatctttatgagcgagatcgtgtcgtctttgcattgcaacagtcgctaccagtaa
+ttgctgatcaattatagattcattatacagatgcttacttttctctattcaatactgtca
+tgagttgtttttaaataagcaccagaattatgtcgcctagtataatcttgcttccacttg
+aatcaatgcgatggacagtattctactgattgcaaagtagtctatttcggcttagcagta
+cgcatgcctatttttttgcaggcacagaataatatgcaactaggattctcggcatccaat
+taacaggctaaaacaccaccgaaagacaggtaatctacgaagttgatgtttactacagaa
+agcgaatgatatcacttggagaacattttagatgcccccttttaatctagactgagtgta
+ccaatatatcaccggtctaccgaatcagcttgaataaaccactctagtactcatgataac
+cgagcatacacatgtatttctcaatgcactgaaggtgaactgtttacaccataccttgcg
+aatcaacgtggcgacttatacttctgtctttgagtacagcacaccctaatgaatctaagt
+tagttgttgatacgaattgtaatttgactggatctcgcctcctcatctagattcttagag
+aagatgtttcttatagccggtactgtaactttattgatctggtttatggtaatcaacatt
+ttacctctatttaaacgtccttgcgccgtgcactcaatcctgatcggtttagattcaagc
+gattatcgagtctggaggccgagaaaagaaatgcacagagtaagctctctattgcgacat
+ctacgtagaaactcgcatttcagatcgagtaagcaactctcattgtgttgattcagtaat
+acaagattacctacgcttctacgaaatatactatagatttagcctacgtcacctttagtg
+tcgagtcggagctttgaagatcggatgcggtgtggactgtgtataggcaattttgctgcg
+agctcgtgacttttggttgatgtcgatatcaatgggatacctcaaacgtctttatctctg
+gataactcacattgagtataccggtaaaaatttattctattcatctaaatagtcagtgag
+ggctagggtcgcaatcacattaggccacatacacatacttaacatgttctattgacccga
+cccaactttagtagcattgtagccgtttatgcaaatatgccaggcgccaaacactagcca
+gagggcattttgttacatttatttaatcgattattacacagtcggaacacgcctacatgc
+gttcgacttatttgcgacatggtcaacaattcagtaatttaatccaaaacctaaagtcag
+agacatgacactaaaatcacattaaggtcagttagtgaaggaatggctaaccagctagag
+aatgcatcattaacaggcacttattgtcaaatattttccagatctaagcaacatcacgtt
+aaaaagtacaacaatcacttaaaacacatcagtccaggtgtaattagaaagccgcttagt
+aggcaagcgtaggagtataaatgtagacaatagtcgggacttagcagacactggatgcag
+tcatagaagatcttgcataacacgttagggttagagctacgaacgcccatcattaactgc
+ctaaagcgtgcgtgagcttagcgctaacttttccaacacgtttgtgatttcgttcataat
+gtatcaatttcacagtcatatacagggagtgtagaaaaatcgcaattaacatacgttgac
+ctatttttgttcagagttcagttagagcctaatgattcgagagcaataatcaggacagcc
+tcataggaagtgtcaatcacttagaagctatattattataaatcgctctttactgtcgtc
+gaaggaacgagcgagagagaatcagttgcctgcaactggcttaacaatatgatacataaa
+aatattttcatcaccactaagacggtggaattcagacttattggcaacttaggatgggac
+tattaaataacccataagatgttgggataaagttacgaaacgaaagggatatagcctgtt
+agataggaaatccccaataaaacatagccggcctccacagcagtgatctattccgccacg
+cgatatctttataccacgcaatataccaataataaaggttaaatgtggttgcgatttaaa
+aaagatacatatcagttgcaccgcgtagcaaatccgtatgtgaagcgtaacctagaatta
+tagcgtctgcaagttctctaagcttcctctgcaagatacaatatgactttttagcttttt
+tactaccaaatctcagaatcttagaaacaggttggtacgtgctactcggaattcccaaag
+taccctgctatatatgccattccttcattggtccgggctcaccatggggccatcatagta
+atagaaggtagtaaaactagttgatttccgacttttaacaatcactatcctgacccagat
+atgggttccgactggcccttactccagtaagggcagacacacagacaacgagaacttgat
+aactttgaattctcaaatcgatcattgcaacgtgacttatttactagcctactcctataa
+ttcatacgtcaaatacatttcaacggaggaagataataagtaaatattcactaaataatg
+gtcgaaggagtcctttgccaacataagtccacatatgcgctatagattttttcttggggt
+tcatattcaataagataaacagcaagagtatcacgtcagcgagtcattgagatcttggct
+agcattgtgatagcatattctacctaaatggtagtctagcacagagtggataagatatca
+gttagatatagacaagtactataacagatctcgcttcgttggattgtatggctagctttg
+atgatatgattttataaaaattgatccagacctgacctggccaattatattcatttttta
+tgagtaaaaatagataaccatgaaaatactcaagccccttaggacgtacaaagtggtaac
+ataaatttcaggtgttattctgcaaccacacctgttttgggttttcaaaaaggctaagca
+gattggttttacagataatccctgaacactggtatctcccaacgatgtcgttcccaaccc
+ttgctgaccttttaagctctgctgaagttttgtaaactaggcggaaaatatgttcgatag
+atccactcgcctgaggtagaaattcgtcttagtaacgcctctttggattacacagaatag
+tgtactgacacgtacactgctgcagcagccatacgctaacattaaaattcgttgagtcta
+catttgttgttattcggattatgttattgggaatagtatttttattcccctgcgtgaaac
+cacatggatagattagcctactcctaaagactcccttttggtctacggttcaattctctt
+actgagtttatgttcgtaattatatcggcgcagtgaatctcctaattatcaccggagtta
+ccagacgccatgaacttatggccagaaacattgcatgtggcctacataggattagtatca
+agagtttacgtttgcaacgacatttgaccaacttgaccattcctgcttgtagaccgcggg
+aactcccctgcacgcgactatagaagttggtggtggatgtggcttatgccgcaaatatgg
+ttttgaaaaaagtaatctattgcttgatacctgaattgagacatgtataagggctattgc
+cagatgaaaaactgcatataaggtcaaacaatataagaacattatacataggatcttagc
+gttcctcaggatggtatacgctataaagtctagcttcagcagctaaggagttttgccagt
+gcggacttccgctggaagattaggtttaaccgccctgacatcttcataaggtcgggcctg
+attcaaacccctggagtgccgtctcatacttgaattaatcgatggaaaacttcttctagt
+ctaatattattattaacaaatgacggttcaataaataacaccgtaagggtgggaaactgt
+taagtgatgaatcattttaacctatcatccattagctacagataatgataccccgatccg
+actagggggtaagtggttgttccgttaggataaaccatgtaaaacgttagagggtttgta
+gattaattggtattccagataaatgaggtcagggcgagtgatcaattacactgaaaaatt
+gtcagcttgcgcggtagttgttaagacagtataaatgaaggggattcagaagcaagtttc
+tcgattgactgaatttataaaccagtcgtcaatcatgatttttgtgtcgattaaagccta
+aatggtaatttaaaccattgatatttatcgagtctataaatatctttggttgtatattac
+ttcacaatcaccaattctaaatgattcttccactgtgcgggtggagatatcaggacgggt
+taaggttgacctacatcgttttgatacaacaaaaatcaaagcacatggctggggacttct
+cgatactatctttgagatagtacgggcaagagtgggtgacgcctccctacattttcaagt
+ctatcggataacttctcggtaaaacgctcgcgatatagttttaaagcattgatttaatcc
+acgcaggagcaagttttaccggtcgaatgagaaaattcaacgtaagtgtcatatccagtc
+atggttagccaaaagcatgggttatccaaaaggaataaaacagctcttcaacaaagagat
+gaggcttcataacttcgatgaatgcgtatggttctgatatatagatcgatgcatgaggac
+actttattttagccggcgaattaatggaatccatacgttacttatttggacatgacttct
+aggtgtttttgctgtcccgtttagcgatatttacagattagtatttcgtttctcatagtt
+aattgtatctagatactaactcgttgaagacgcataccttgccatttgtacaggacttaa
+ctgttccgtgcgtaatttgaatttcttataggttcttcaaggcacgaatacctcactcat
+gaccgttcatactctagttaaggtcgggaatactacgtatgcagggaattgtaacctagg
+agatttacaactctttaaacaagagtcgctgaggtccaggatcaaaacactgaatctcct
+aacttcgggtgcctccgtaaatcacctagaaacctactcatacatttgcaattttgagat
+gtaggcgaaagagagaaatctgctttttaacggtatctcttgggattccttttaaaaaca
+cataacgatagtaatgtaccaagtaaccaaaagctgggatgtgtctgtgtactgatccgc
+cgtgtcagagtagtccgccatgaatattgacgtcaaggctagtgtcatcaggtattgatg
+ttcattgtaaatgaaggaatgaactaatgtcaccaagtaaagggggtgaaaatgctcccc
+agggttctacagacatagagatggtcagaacacgacccccctctcaacgcagtgtatttg
+aaatatatggacatatctaccttattctgtaattttagatgtgttctgtgtataccgata
+ttgataagtcaataggcttgattacgtatcttaagacaaatctgtttcgcaagtaggacc
+gcatctttcagattgtttctttttatgccataacctgcccaggaattcaaaaggttatcg
+atacccgatatgctgtgaattattattctaatggccactcattcctgcttatatctggaa
+ttggcatgaatatcttacaacctaaagtctggcgttgcgccagttctacttcgtaccgga
+caccatctccagtcgttaaccgaaggtgggtacgtcacataaaagttcattagaccacac
+tttgtgccgacgtatatagatatattacacgtatagggaatgttttctcctaggtgaccc
+gaccttctactaaggttgtacatcgtataatggcccattaactacgaggaaagtggtatt
+gacctggtaatgcacgttcttcgatatataccgacgaggtaaagtctactattgcaaagt
+ttgacgttatactgataagtttagatttccctggatcgcgcatgaacaatgtatgcgtta
+tctgccatatataacatgttacaaatccttggggatactatcgctactatcatcggacca
+aaattaaataggctagtgtcttatcagaacatcatgtttaccgaactgatctattttcca
+atttaagctgatattacgtccgcgtatttattttagttccccggatgacgattatctgag
+ctacatcatacaagttagcatactcgccggtgcattgatttcttatttcgctatatcttc
+aagttcacaggcttcatatagttccaattagcagtataattaggttttgtaactttaacc
+atactttataaaaggttatattgcacaactgatcaagcatccgctataacccgagcttta
+ccagttagcggctaataacaaataagatgacttcgtgtcatacgaccgtcatgatcatgc
+tctaacttaggtgggaaccaaatttaggcaatgggtagtaataagtataaaatgatacca
+catatactataacaatgaaattatttgtaatccggtttgccaacgtatcccccttcgcga
+taaattaatgacatagggtcatccatgtgccaatcgtgtgtgccaaaatctcaaattcaa
+ttatcatcaatattggccaagtgttataagcgttgaaagtgatataggccgccaaaaagt
+agtctacttaaaaaccaatatttatcgttcgttattgctggtagtacaacatcacgagca
+tttctcttttgagttgatttatactatatctgctgatgtgattatgtcccacttacccag
+aatattaagaaagtcctagattgtaggtatacttgactataaatataatttaagactata
+caaataatctggctacattatgccatcgtagaaactgataacgtagtaacgtcggacact
+agattttggtcggggagtaatctagcatactaacgaatttgttaaatccgctgaaagtat
+atgtcattacctgcttggcctgtcttcaatacgtttagactattaaggactcatttcgag
+atccagtattaattatacgcatccatatttatactgaagacggattgagttaggacgaca
+agctaaacaaatattaagttaaggattagtattatattgtagaaactcgtcgggttggaa
+cgattcatcatcatagaatgcgttacttattcagagagacttaattcggttatgactggc
+agctcacctggaaagtaggtgaaaggcaacagaagaatattgttgactgaattctacggg
+ctacgaacgtaattacaaagcggttcgtaaagagcataaagatcaatacaatggatctct
+acagtattacgtaaataacatacataaacctggtgttgattcgactagctcatagattaa
+tcattaattgaagctacgaagacgcggaagtctgcggagtgagcaaacagtaatcgactg
+ataaatgcttataatatcgcgcttaaatgccgcatggtgtacattaacgtgggggtagtc
+aaaggaatatatttactaggaatattagttatgcaaatgttgtgtcaatgtgatgtgttt
+tatccagacattggatgcatggctgtgggggcacaggatacttaccattagttcacctac
+aagcggcgtgagagggtctcagttttagccagcgcagagaagtacgggcctttagacgat
+taatgctagaattgtcataaacctcgtgaaaagctagttaataatcatggtgctagaaga
+acacaacttttctataaaccagttctcgactgacagtcgtaactcactatatcgccgctt
+tgtactgtcgcaaaaaaacctcacatagaaagaaaaatctactgggtgcatcagtagaga
+tcgtgttctgagagataaatacaccggatacgatctgcatcgagttcatgtattaggtca
+agcttgggactgttgtgccagtagcattttttaacagtcaaagtagggtgagacacgtca
+tatcataatatatgccatcgaggtttaaagtttatatgataagctagcatgcgttgcaat
+cgtattcttgaatgctccgtggtttgtactaattcctttatagactgagtgtatcgtaca
+ctcggtacaattacaaaggatggaagagcaaataggtcttcaattataacagtaccccac
+cttaatctaaaaaccagcttcaattagtattaatttcgccaggagtatatatataaatat
+ctaaagactaaaagactcgtacttttacaacttacgtcgtagcataattaaatcatgggt
+aaatgtcatcagtaagtgcattagaaatactcctttgtaaggatacagtgaatgtgtctc
+agcaagtcagtagaaatggaaattcatactcgattaaggcctataaaactgttgttggta
+tctacagagtgattaaaattagtgaatcagattacgaaaatgttttcccgctcgcactta
+cgcgtttagacaaaagtacaggtggtacaattggctgtagtagaattttggtataaaata
+ggtgataaaccggatgggtgtgggcgaattcaaaagcggtttttgttccatagaactatg
+tagttggttataaaggttgtaatctcggagattaggttagggcttaatcagaatagtaac
+aatttctctatgtaaagtacagtgggtgatcgtatgagttcacgaactcttaatgccatg
+cctggacaggataaacaatacgcatataacttgacgatcgagcttatatcgacctatttg
+agaagtttaacgggtcgatataatatacaggtcttaatagccgattttttctagaaaagc
+aatcctatatcttagttaatcagatcaaccccgtgaacgatatatcagcaaactgaacat
+tgtatacaacattcctttttgtccgggtggggactccatttaaagtatctcacctagaac
+tcagcggtaatagatgcagtctcttgcccagttacggtaactaaatgttgatacttagaa
+ttgctaaattttagtctagacatttccaggtaaaccggtagacgacaatttctctgtcat
+ctgtcataagatcgcttagtgtgctcaaattgcaattgagggccctactatagacaatca
+tcagactttttaattaaatagttttccatgaatgtgttgtcaaggcggaccccttcactt
+ttatcacggctcataaatgtcgtatgactgtagtcggtagcggccttcgagtcttcaggg
+gaaatggaaaagaaattaggcttctaagatggactataatcgattaggctaattccgttc
+gcaaatcacagaagcaatcttactcaaaattgttggaatcgatagcgaacgcgaccgtga
+atgtttaaaagtgctcgcacagaattacccaatacctatcatcacgacttaaatacccaa
+agcagttgtagtcgcgtaatagattaagtctgaagcctagagacaaagggatactgggcg
+gggaaacctgctccttcacggtaacatggtaacaacagaatttggttaaggttaaaacga
+aatatactcggagtgaattactgttaggtttcgtcatcggatcaataagtagtttccgtg
+aagacactcttatattagatctccgaaattctgacccgtgcattaggcacttggtaggag
+attccatttggaacttgctcaatgtaagccagtaatgttccgaaataattcgctgcagga
+gcgaggagccgctgaataaaggaccctcgcatcttgttaccttatggttgagggtcaccg
+ttctctgcgtcaattccagagctggagatacattcatcaacgttacctacgcacagaata
+aaaagatcgagcgctaactcgttttcctaaacacaacggatttagacaaattaccgaatg
+cgccggagagtagcatcttagtgtcatgcctatcatggcggctcagtacgaagagttcag
+gcatcgaatattgtggtagcccgcactcaaagttccgccattaggtaagctatatattgt
+ggtcagaacttgaggacaactatgagctactaaaaataaacaattttgtcatttgttcta
+gatatgtggcattcatcgaacgcttgtaccagaagttacattcgcagcgtgagcgaataa
+acccgaatgagcgtaacattatcaataacatatagttcagatagagaacgaggtattcga
+cagagaattacccaacattggttattaatctatgcagaataatttagataatgtcactac
+ataatattaggaccaaaaggtgattccccagaagacaaaacaataaacaatctcacatat
+tcgctagtacctatgtatgggtatgatcttctgattggacggggataatttccaggtata
+ttaaaacttattaccataatctagacctaagagaggttatataagtaaagagctgtgttc
+cgatagaaaaacccgaccttaaagacttgcgaagtaaattttgctttaacaaaaaaacct
+acgtaagggaatattctgtataaactgaaaagtcaggtgtaactacatgagtcatgtctt
+cgattaattacaatgcgatctcgttattctgatcaactaatatcataaactgccactaca
+tcttgtacaatcattcgcaacaatacttttatgtgctaaggtcacgtgcttcctctgcta
+tgctgatttaatcagattcataaaggaatacgaataactctggatccattaccacgcaag
+ggatttatttacggctgattactttttggctgttgacagaactgccatgaaagtaagatg
+tcgcatcttgcataaataatagcacctaatatagccgacaaagtgattccgataacagat
+tttaagttgtccagccttgagactccatgaagaccgcttgggagcttccccgtgattaga
+agaatctaaatcccaagtggatggggggagtttaaatctcagcaccaacaaatagtactt
+cctctcagagcgcgtcatggtcgaaggagcctatcctgatagaggtttgaaagcgcacgc
+gcatttaactgtcatattaaattggaatctcgtaagtgtcggcagtacgacaaattttaa
+ctgatgtcggtatacggagaagaaggaagcacgcattgaagcagctacgcagaactgaga
+agatgacactctaagatacaattaatacaaaaacgttttaagcccaatctatcaacagat
+gtaagatgtctaatacacaagaataaaaccttcatgtcccgatgtataataacagcttta
+tttctgctggtcgaggtgaagtagtggaaattactccatcttgctgcgcgtctttatagt
+gttggctactctgtaaccgacgcgtccatccctctctcctagtgatccgtatatccaatt
+agaggataaccaacatctgcgttaccgacgaatttaaatttttcgactatttaattccgt
+tcaaacccgtattcgtagtaagtgtttcatagatttatgaccgacatcgtgtacgagttg
+cagtgcatatgtagataccactaattgctgatctaggatacatgctttataaacatgctt
+acttggctattttatttactgtcatgtgggggtttttattttcaacaagtatgtgctacc
+attggataatctggcttcaaattgaagatatgcgttccaaacttgtctactgtttgctaa
+gtaggagttgtcccattagaactacgcagcacgtggtttgtgatcgaaaagaataattgg
+caaatacgaggctagccttcaaatttaatgcagattactcctcagaaacacacgtaagcg
+acgaacgtgatgtttactacacaatgcgtatcatagaaattcgtgataatttttgttcca
+acctttgaatctagactgagtggaaaaagatttcaccgggataccgtttatgctggtttt
+aaaaactcgtcgaatcatcttataactgcattcaaatggatttctcaatcatctgtacgt
+caactgttttaacaataacgtcagaataaaccggcacaatgagacggcggtctttcacta
+caccacacccttaggattataagtgacgtgtggattcgaattctaaggtgacgggatcta
+caagcctcagctacattaggtctgaagatctttcgtatagccgcgtatgttactgtttgg
+atatgggttatgctaatcaacagttgacagcgagtgaaacggccttgcgacctgaaatct
+ttacggttaccttttgattcaagacaggatcgacgatggaccacgtgaaatgaattcaaa
+actgtaacatcgcttgtgcctcagcgaccgagtaacgacaagttcacatcctctatgcaa
+ctatcattgtggtcattaaggtattcaagattaactaagagtcgaccatatattctagag
+ttttacaattaggaaccgttagtctagactaggagcgtgcaacatcgcaggaggtgtgga
+ctgtcttgacccaagttgcctgacacatagtgtcttttgcttcatgtccttagcaatgcg
+atacctcaatcgtagttttatcgggataaataacatggtgtttaaccctattaatggttt
+ctattaatctaaattgtaaggcagcccttgggtcgaaagcacattaggccacatacacag
+tatgaaattgttcgagtgtccagaccataattgactaccatggtacacggtgttgctatt
+atgactcccgcaaaactcttgacagagggaattttggtacattgatgtaatcgatgattt
+aacagtaggaactagacgtcatccgttagactgagttccgacatgctcaaattgtcagga
+tttttatccaataactaatggctctcacatgtaaataaaatcacattaacgtcacttagt
+gatggattcgctaaacagatagactatcattcatgaactggcactgtttcgattatattt
+gcaacatcgaacatacttaaagttaaatacgacatcattcaattaaaaaaattcagtaca
+cctctaatgagtatcccgctttggaggaaagagtagcactttaaatggacaatttaggcc
+ggactttcctgtaaatggatgaagtcattgtacagcttgaataaatcgttagggttagtc
+cttacatccaccatatgttaatgaataaagcctgagggaccttagagctaacttgtccaa
+cacgttgctcatttacttaataaggttgaaatgtatcagtaagtgacagcgagtgtagat
+tttgaccatttaactgaccttcacagttttgtcttcagacgtcacttacaccataatgat
+gacagagcttgtagatgcacacactcattcctagtgtaaatcaagtagtagctagattat
+tataaagagatattttctggcgtcgaacgtaacacagagagagtataaggggcatgataa
+tggcttatcaatatgtgtaagaaaaagtttttaatatcatctaactcggtggaatgcaca
+cttatggccaactgaccttgggacgagttaagataccataagaggttgcctgtaagttaa
+gataacaaagggatattccatctttgtgtgctaagaacctatttatatttgcagccataa
+aaacctctgtgctatgcagccaccagagttatttatacaaagaaagagaccatttagata
+cgttaattctgcttgcgatttattaaacagacatttcacgtccaaccactacaaaagccc
+tatcgcaagacgatcattgtattatagcctatgcaacgtagctaagcggccgaggaatca
+taaaatatgaattgttacattgtttactacatatgatcacaatctttgtaaaaggttcgt
+tcgtgatactaccatgtacctaactaacctgagatatatgcaatgacttatggggtcagc
+gcgcaacatccgcaaagcatagtaatacaaggtaggaaaacttctggatttcccaaggtt
+ataatgctctatactgaccaagagatccgttacgactcgcaatgaatactctaagggcac
+tcacaaagaaaaccactaattgataaatttcaatgataatatcctgaattgcatcgtgta
+tgagttacgagaagtcgcatttaatgaattagtcatagaaatgtcatagcaggaacataa
+ttactatattttaacgatttaatcgtagttggagtcctttcccaaattatgtcatcagtt
+ccgatttagatgttttcgggcccttcttagtaaagaagttaatatccaagactagctcct
+cacccacgcatgcacatattcgcgagaagtctgatagaatattcgacagaaatgcgactc
+tagctcacactcgttaactgatcaggtacttatagacaagtacgttatcagatatcgctt
+cggggcattgttgcgctacctttgtgcatagcagttttgaaaaattgttcaagacctgaa
+cgggaaaatgatattatttttttaggaggaataatacagtaccatgtaaatactcaacca
+ccttacgtacttcttacgccgaacatatatggcacgtgttattcggctaacaaaactgtt
+gtgccttttctataaggataagcagattcgttttaaacatatgacctgtaaactgggatc
+tacaaaagaggtacttaaaataaattgcgcaacggtttagatctgcggatctttggttaa
+agagcaccattagatgtgccatacttcctatcgcctgagcgagaatttagtctgaggaac
+cactcttgggatttaaaacaattcggttaggacacctactcggcggatgaagcaatacga
+taacattaaaagtcgttcagtctaattttggtcgtagtacgatgagctgatggccaattg
+tatttttattaacagcactgaaacaaaatggagactttagactaatactaaagtctcaat
+gttcgtcgaaccttaaatgctcggaatgaggggatcttcggaagtatagcgccgaagtgt
+atctcattattataacaccagtgtacagacgacatctaattatggccagaaactgtcatt
+gtgccattaagaggattagtagatagtctggaccgtggaatagaattttgaccaaattga
+ccagtcctgcttgtagacagcgcgatctaaactgcacgagaatatacaagttggtggtgc
+ttgtggctgagcacgctaagatgcgtttgtttttacgattctagtgcttcttaacgcaat
+tcagtcttctagatccgctattccaacatcaatatctcaatttaaggtcaatatatataa
+caaaattagacagagcagctgacacttacgaagcatcgtagaaccgatatagtcgacctt
+atgatgatatggacgtgtccaagtccgcacttccgatgcatcttgacggtgaaccgaaat
+gaaatcttcattagggcccccatgtgtcaaaccactcgagtcccgtctctgaagtcaagt
+attactgcgaaaaattcgtctactattagtttattatgaacttatgacgcttaaataaat
+taaacagtaagcctgggaaaatgttaaggcaggaatctttgtaacagttcataatgttgc
+taaagattatcagaccccgtgaagacttcgggctttgggcttcgtaccgtagcataatac
+atctatatagttagaggcttgcgtgttgttgtgctattccacatatagcagctctgggcg
+actcttcaatgaaaatgaaaaatggtaacctggcgacctacttgttaagtcagtttaatt
+caaggggattaagtaccaagggtcgagtttctctgtatttattatactgtaggcaagaag
+cttttttggcgagatttaagacttaagcctatggtaaaaatttgatagtgagcgactata
+gtaagagatttgggtggttagtaattaaaattctcctatgctaaatcaggcgtacaatct
+gagggtgcacatttctcgacgcgtgaaccttcaccgaaagcgtgtggattatacaaattt
+caaacatattggcggggcacttatccataatagatttctgtttgtacgccaaactctgcc
+tcacccctccataaattgtattggctagaggttaaattctccgtaaatagagacacatat
+agttttatacaattgtttgaatcaaagcacgagaaacttttaaccgtacattgacaaatg
+tcttcggatggggcagagcatctcttcgtgacccaaatcaatcgctgagcaataagcaag
+aaaacacagattatacaaagagatctggatgaagatattcgtgcaatcactatcgttatg
+ttagagagttccatgcatgaggactcgttttttgaccaggagaattaagccaagaaataa
+ctgacgtatttccaaatgaattctacgtgtttttcctgtcacctttagccagtgttaaag
+atgactatggagtttcgaataggttattctatagacattataacgagtggaacacccata
+ccttcacagtgctaaaggtaggaacgggtacgtcaggtagttcaagggattttaggttct
+taatccaacgaagaaataacgcatcacccgtcattctattgttttcgtcgggattactta
+gtaggcagggtattctaacctacctgagttacaaatctttaaaaaactggccatgaggtc
+atggtgataaaatctgaatcgcctaaattcgcgtccctaaggaaatatactagaatccgt
+ctcagaaagtgcaaaggttgacttcttcccctaacacagaattctcagttttatagctat
+ctagtggcattcctttttataaaactttacgtttgtaagggtccaactttacaaaagctc
+ggatgtgtatgtgtaatcttccgccgtgtaagacttggaacccatgtatattgacggcat
+ggcgtggctaagcaggtattgatcttcagtgtaaagcaaggtatgttctaatctaacaat
+gtaaagccggggattagccgccaaaggggtctaatgacatagagatgctctgaaatcgta
+ccaactataaaagcacgggatttgaaatatagcgacagatcttccgtattctgttagttg
+acatctgtgctgtctttaccgattgtgatttggctttagcagtcatttagtttcgttact
+cattgctcgtgcgatagttccaccgaatatggcacattcgttctttttttccattttact
+gcaaaccttttcaaaagctgatcgataccactgatgatggcattgattagtcgattggca
+actatgtcctgcttatatctccaattgcattgaatatagtaaaaaataaaggctcgcctt
+cccaatgggctacggagtacacgaaaaaatcgcaactcgtttaaccaagcgccgtaccta
+acatataagtgattgagacaaatagttctccagacgtattgagatatatgtctcctatag
+gcaagcgtttctaattgctgaccagaaattagaattaggttgttaatactatattcgacc
+attttattccacgaatgtgctattctactggtattgctccgtatgcgatatataaccaac
+acggaaagtcgtcgattgcaaagtggctccgtagaatcatttctggtcatttaccgggag
+cgcgcttgaacaatggatgcggtatctgccatattgttattgttaaaaagacttccgctt
+actatcgcttcgatcatcggaaaaatattaatgaggattgggtcgtataagaaaatcatc
+ttttcagttcgcagatttttgccaatttaaccggttatttcgtcagacttggtagtgtag
+ttacaagcatcacgattatatcagctacagaattaaactgtcctgactcgacggggcagt
+gtgtgagtattgcgctatatattcaaggtaacaggaggcatataggtcatagtacaagga
+taatgaggtttgctaactttaaaaattattgatttaacggttgattgaaaatctctgcaa
+gatgacgctagaacacctgatgttcaagtttgccgataataacatataagatgaattact
+gtctttagaccctcatgttaatccgctaacttagggcggaaacaatgttaggctatgcgg
+agtaagtactatattatgataccacatagaatttaacattcatatgatgtctaatacccg
+ttcccaaccttgcaaccgtcccgattaattaagcaattacggtcatcaatgggccaatcc
+tgtctcaaaaattatcatattcaaggttcagctattttggcaatgggtgagtaccgttct
+tagtgatttacgaacccataatctaggcgacttaatatacaagatttagagttacgtttt
+ccgggtagtacatattaacgaccatggatcgggtgaggtgttgtattagttatctgatct
+tgtcagtagctcccaatgtcccagaatattatgtttctactagagtgttcgtatactgga
+atttaaatattatgtaagactagacaaattttatggatacattaggccatcgtagaatat
+gatatagttgtaacgtccctctatagattttcggagggcaggtatattgcttaataaaga
+tgttcggaaatcagcggaaaggatttgtaattaactgatgcgcagcgcttaaataagttt
+agactattaagctatatgttcgacagcatgtagttttttttaccagaaagtgttatactg
+atgacccatggaggtagctcctcatgataaaaatattgttacttaagcattactattata
+gtgttcaaactagtaccgttgcatactttaagaatcagacatggcgtttcttatgcagac
+acacttttttagctgttgacgcccacctcacatccatagtaggtcaatcgcataagaaca
+atattctggactgttttattacccagaagaaagttttttctttccggttcgttaagacaa
+taaagatcatttcattcgttctcttaacgatgaactaaagtacttaaagtatccgcctct
+tgtttcgactagcgcatagtgtaataattaaggcaagataagaagaacaggaacgcgcac
+gtcggagataactctaatagtctctttattccgtttaatatagcccgtaattgcaccatg
+cgctacagtaacggccgccttcgcaaacctatttatgtaattccaagtttaggtatgcaa
+tggttggggcaatgtgaggggttttatcaagactttcgttgcttcgcggggggcgcaaag
+cagactttacagtagttaaccgaaaaccgcagggagtcgctctaagtgttaccaacccct
+cactactacgcgaaggtactcgattattccttgaatgggctgaaacatcgtgattagcgt
+cttatgattcaggctgatagaagaaaacttattttctatattccacgtatacaatcacac
+tcgtaactaaatagttcccagcgttgtaatgtcgctataataaataaaatacaaagaaaa
+ttcgtctgggtgcataagtacagttagtcgtctgtcacataaataatccgcagtcgatct
+cattacaggtattgttgttggtcaaccttcgcaaggtggtccaagtagcattgttgaaca
+gtaaaactaccgtcacacaaggaatatcataatagatgccatacacggttttacttgata
+tgtttacagtccttgagttgcaatcgtagtattgtttcatccggggtgtgtacgaagtaa
+tttagacaaggtgtgtagcggtcactaggtaaaatgacttaggatggatgagcatttagg
+tattctatgataacactaaccatcatgtttctaaaatcctcaggaaatttgtattatttt
+accaacctgtatttatagaaagtgcttttgacttaaagaagccgaagtgttcaaattaag
+gagtacctgattgaaagaatggggaattgtaatctgtaactcaattacaaataagccgtt
+ctaaggattaaggctttgtgtctaagcaactcacgtgaattcgaaattcatactcgatta
+acgactttaatactcttctgcgtatctacagactcatttaaattacggaatatgttttcg
+tttttggtttccagctcgcacgtacgcgtttacaaataaggacacctggtacaattggct
+ggagtacaatgttggtttttatttgctgattatcccgatccctgtgggcgttggcataac
+cgggttttcttcaagactactttcgtgttgcttatatacctggtaatatcggtgagtagc
+ttagggcttaatcacaatactaacaagttctctatggattggacagggcggcatccgttg
+actgaacgatctattaatccattccctgcactggataaacaagacccatttaaattgacc
+atagagatgttagcgtcatatttctgttcgtgatagggtacatatattataaacggatta
+tgagcagtggttttctagaaaagcattcatagttaggagtgtatcagatcataccactga
+accatagagcacaattctctactggctatacttcattcctttttgtccgggtggggacga
+aatttaaaggttctaacctagaacgcagagcgaattgatcaaggcgctggccaagtgaac
+ggttctaaatgttcttaatgagaattgcgtattttgactattgacagggcatcgtaaacc
+gctactcgacttggtatctgtaatctgtatgtagatagagtacgggcctataattcaaat
+tcagccaccgaagattcacaatcttcagacgtttgaaggaaagaggtttactggtatgtg
+gtgtcaagccccacccattctctgttatatccgagcattaatgtagtttcactgtactac
+ggtcacgccgtagagtcggcagggcaaatccaaaacaatttaggctgagaagtggcacta
+taatagtttagcctaagtcccttcgctaataactcaacaaagatgacgcaaaagtcggcg
+aatagattgcgttcgcgtaagggtatcttgaatactgatagctctcatggtaccaagaac
+tttcataacctctttatttaccaaacctgttctactagcgttagtgttttagtctgtagc
+cgacacaaaaaccgagaatggccggcgtaaccggcgcctgcaagctaacatgggatcaaa
+actattggcttaacgtttaatcgaatgagactagcactgtattactctttcgtttcggca
+gcggatcaataaggaggtgacggcatcactctcttatagtagatatcacttattctcaca
+acggaagtaggatcttccgtcctcattaaatttgcaactggctcaatgtaacactgtaat
+gttaacaaagtatgagctgaaggtcagagcagacgatgtagtaaggtccctcgaagctgc
+ttacagtatccttgaggctcaacgggctatgcggaaattccagacctcgagttacattat
+gaaacgtgtcattccatctcattaaatagttcgtgccctatcgccttgtaatataaacaa
+ccgtttttgtctattttcccaaggagaaggagagtagcagcttagtggcttgcctatatg
+gccccctaagtacgtactcggcacgcttagaagattgggctaccccgcactatatgttcc
+caaagtaggtaacctagatagtgtcgtatgaaattcaggtcatcgatgagagtataaaaa
+tatacaattttggcaggggttatacattgcgggcatgaagagtaacattggacatgaacg
+gacattcgaaccctgtgagtttaataccctatctccggatcattataaagtaaatatacg
+tcacttactctacgtgcgtttagacagtctttgaaactaaattggttatttttctttcat
+ctagatttgtctgtatctaactaaattatagttccacataaagctgattcaactgaagac
+ataaatataaactttctaacatagtagcgaggaaagagctatgcctagcatcggatcatg
+cgtccgcgagtagttcctggtagagttaaaagtttttccagaatctagaccgaacacagg
+gtagtgaacgaaagtgcgcggtgaacatacataataccgaacgtaaacaattccgttcgt
+attgttgctgtatctatatttcctacgtaaggctatttgatctataatatgaaaagtcac
+gtcgaaataaatcaggaagcgcttcgagtatgtacattcagatctccttagtatcatcaa
+attatagattttacggccacgaattattggtctagatgtcccaaaaataatttgatgtca
+gtagcgatcgtgcttcctcggagttgaggttggaagaagagtcattatgctataccaaga
+actctccatccagtacctagaaaggcaggtatgtaccgctcattaattttgcgatcttga
+cagatctgcatgcaaagtaacttgtaccagatggcttttataatagaaactaagtttccc
+gaataacggtgtacgataacagatttttaggtgtacagacgtctgactcaatgaacacac
+attgggacctgccccgggaggagtagtagataattaccttctccagcgcgggtcttttaa
+tatcacaacataaaaatactaattaatatcacacaccctcatcctcgatggagcctagca
+tcatacacgtttgatagacaacgccaattttactgtaatatgatattcgaatctagtatg
+tggacgctgtaccacattgtttaaaggagctccctttaccgacatgaacgaagcaagctt
+tgtacaagatacgaagaactcagtactggtaactataagagacaatttatacataaaagt
+gttaagaccattatataaaaagaggtatgaggtctttgtaactacaataatacattcatc
+gaacgatggagaataacagagttatttctgctgctcgagctctagttctgctaatttctc
+aatcttgatgccactcgtttgagtcttccattcgctcttaacgacgcgtacatccctctc
+tcctactcttacctatatcctattactggttaacctacatctccgggaaagacgtaggta
+aagtggtccacgattgtattcacttataacacctagtagtactatgtgttgctgagagtg
+aggacacacttactctacgagttcaagtccatatggacattacactttttcagcatctag
+gtgtcatgatgtattaacagccgttaggggctatttgattttatcgattgtcggcgtgtg
+tattttcaacaactaggtgctacaattcgtgaataggcatgaaaattcaagattgcagtt
+cctatcttgtataatctttcctttggacgagttgtaccatttcaactaacctgcaagtgg
+ggggtcatccatatgaagatttgccaaatacctggagaccctgaaaagtttatccagatt
+aataataacaaacaaacctaagcgaagaacgtcagctttaataaactatcactatcatag
+aaattcctgttaattgttcttccaaacgttgaatagactatcacgggtaatagattgaac
+acggagaacgtttatccggcttgtaaaatatcgtcgaatctgctgataactcaattatat
+tcgatggagaattcatatctaccgcttagcttttaaaaattaagtcagattattccgcca
+caatgagaaggcgcgagtgcactaatcaaatcacttaggattattacggacgtctgcatt
+acaatgctttggggtagggttatacaagcatatgattctttaggtctcttgatcgggcgt
+ttaccaccgtagcttaatgttggcatatccgtgatcctaatattctgttgtcagcgtgtg
+tataggaatgcacaacgcaaatctttaagctgacctgttcatgaaagacaggagacacga
+ggcaccacctcaattctatgcaaaactctaacatagcgtggcactatgagtacgtgtaac
+gacaaggtctcatactcgatcctaagataattctcgtctggaaggttttaatctttaact
+aagagtagaacttagtttattgacttttacaattaggatacggttcgcgactctaccaca
+gggcatcatacctggagctctgctatctcgtgaccaaagtggcagcacacatagggtcgg
+gtcctgcatctactgagcaatccctttaagcattcctagtttgagagccatttagatatt
+gctgtttaaaccgattaatggtttctattattataaagtgtaacgctcccattcgggaca
+ttgaaaattagcaataagacaatgtatgatattcggcgagtctcaacaacattatggtct
+accatgggacaaggggttgatatgatgaatccacaaaaaatagtcaaacacccatggttc
+gttaagtgagggtatccaggtgttataaggacgatctagaagtattcaggtacacggtgt
+tcagacatgctctaattgtcaggttgtttataatttaacgtatcgctctctattctaaat
+aatataaaattaaccgctcgtagggatgctttccagtaaaagatacactatcattaaggt
+tatgcaaatgtggcgatttgatttgaatcttagtacattcttaaacttaaatacgtatta
+tttaaagtaaatatattatctaaaccgcttttgtctatccacatttcgtcgaatcacgac
+ctcgttaatgcgacaatttacgaccctctttcatctaaagcgatcatctatttcttctga
+ttgatgtaatactgacccttactccgtacatacaaatgatggtaagcaagaatgactgac
+gctcctgtcacctttcgtggcaatcaactggcgctggtactgaagtagcttgaaagggat
+atggatgtgtatgccaggcttcattttgacaatttttctgtcctgctcagtgttgtctga
+agtcgtatcgtacacaataatgatgactctcattgtagatccaatcacgctttcctacgc
+taatgaaagttctagatagtgtaggtgttagacagaggttagcgcctacatccttacaca
+cacagtgttgaacggcaagcataatcgagtatcaatagctgtatgtatttgtttggaata
+tcatatttctcccgcctttgaacaatgatgccaaaatgtcctgccctagagttatgataa
+aataactgctgccctgtaacttaagtttacaaaccgatattcaatcgttgtgtcctatga
+aaatatttatatttgcaccaagaaaatcatctgtgcgatgaacaaaacacagtgatttat
+aaatacaaagagtacatttagttaccggattgcggcttgacatttattttacagaatttt
+atcggcaaaacacttcatatgaactatcgcttcacgataagtctatgatagactagcatt
+cgtagagaacaggaagagcaatcattatatatgaagtgttacagtgggtactacatatga
+gatcattaggtctatatccggccttcctcataagaccttggaaatatcttacatcagaga
+tatcaaaggaagtatgggcgaacccagaaaaagccccaaagaatagtaattcatcggacg
+taatagtctggttttaactaggggttattgatatttaagctaaaagagttccctgaacac
+tcgaaatgtataatctatcccaactaaaaaagtatacctctaattcagaaatgtcattga
+gattagactgatgtcaatacgctaggaggtaagacaagtagaagtttttgatttaggaat
+tgaaatgtaatacctccatcttaagttctatattttaaagttttatgcggacttcgagta
+agtgcacaaatgatggcataagtgcccagttacatgtttgcggccccgtatgagtaatga
+tctgtttatcaatctctagctactatcccacgaatgcactgatgccagtcatggcgctta
+cattagtcgacagaaatccgacgatacctatcacgcgtgaactgttctggttcttattca
+attcgaagtgatctcagatacattacggccatgcttgcccttcatgtctgctgagcagtt
+ttgttataggctgaatctcctctaagcgaaattgataggatttttggtggtcgatttagt
+ctgtacctgcttattaagattcaaaatgacctacttcttacgccgaaatgatagggatcg
+gctgaggaggataaatatacgctggtgcctggtatttatccagaacaagttgcctgtgta
+tcagatgaactctaatctccgagataaaaaacaggtacgtaaaataaaggccgcaaaggg
+ttacatctcaggatcgtggcgtatagtccaccattagttctgacttacttaatatagact
+gaccgagattgtagtatgtggatccaagcttgccatgtaaaacatgtcggttagcaaaac
+gtataggagcatgatcaaagaagagttaattaatagtactgcactataattgtcggcgga
+gtaccatgagctgttgcccaattcgatgtttattaacagcacgcataaaaaatccagact
+tttcaattagaattaactataaatggtccgcgaaccttaaatgatcggaaggacgggatc
+tgccgttgtatagaccccaactctatctaatttttataacacctctgtaatcaacaaatc
+ttattatgccatcattatgtcattcgccaagtaagtccagttcgagattctctggaccgt
+gcaatagtattgtcaaattatggtaatggaatccttcttctaacacccttagaaaagcca
+cgagaattgacaagttgggcgtgcttgtccaggagcaacataagtgccgtttctttttac
+gatgatagggattcttaaagcttttctctattctagatcccagttgccatcatcaatatc
+tcaattgatgctcattatatagttcttatttagtatgtccagatgtcactgaagatcctg
+cctagaaccgatattctcgacaggatcatcagttcgacggggcaaacgcacctatgcaca
+tccatcttgaccgtgaaacgaaaggaaagagtcagtaccgacccaatgtggaaaaaaact
+cctgtccacgatatgtaggcaagttttactgcctttaattagtagtcgattagtgtagtt
+tgatattatctaccttatagaatgtaaacagtaacccggccttaatggtttggcaggatt
+ctttgtaaaagttaataatgttcataaactttatcagaaaacctgaagtagtccgccttt
+cgcctgcgtaacgttgcagattaattcgttttacggagtggcttgcgtcttgttgtccga
+gtacacatattgctcctctcccccactcttctaggaaaatcaattatgctaacctgcaga
+ccttcttctttactatctttaatgcatgcccagtatgttcatagggtagacttgctatct
+attttgtataatctacgaatgatgcttggggcgcgacttttaacaattaagccgttgggt
+ataatttgagagggtgccacgatagtaagagatttccggcgtgagtaaggaaaatgataa
+taggattaagcaggcgtaatagctcaccctcctcagttctccaaccctgaaccggctaag
+tatgactgtgcagtattaattttgaatacatattgcagcccctaggatacattatagatg
+tctctttcttacccaaactcgcccgcaccaagaaagaatgtggattcgattgaggttaaa
+ttagccggaattacagacacagattcttgtttacaattgtgggaagaaaaccacctcaaa
+cgttgaaacctacattcacaaatggattacgttggggatgagaatcgattccggtcaaaa
+atcatgcccggagcaataaccaagaattcacagaggattaatacacttctccatgaagat
+aggactgcttgcactatccttatctttgtgtcttccttcaagcaccaatcgtttggggac
+aaccacaattatgccaagaaataacggaaggtgttccaaatctatgagtccgcggtttca
+tcgcaacgtttcactgtgggtatcatgactttggactttagatttgggtattctagagac
+tgtagaaagactgcaacaacaagacattcacagggcgaaacctaggaaaggggaccgcac
+gttgtgctagggatgtttccttaggaatccatacatgtaagaaagaatcaaccgtaatta
+tagtgttttcggccccttgaattacgtgcatgcctttgctaaaagacctctgggaaatag
+attgaatattctggacagcagcgaatcctgattatatctcaagcgaatatatgacccgca
+agaaggatttatactagaataagtctaagaaagggcattgggtcacttcttccactaaca
+cacttttatcagttttataccttgagagtcccatgcatttttatatatatttaactttcg
+ttgcgtaaaactttaaatatgatccgtgctctatctctaatctgaacaacggtatcacgt
+cgaacaaatctagtggctacgaatcgcgtcgctaagaacggtttcttctgctggcgttag
+ctacgtatcttctatgctaaaaatgtatagccccgcattagcagcaaaaccgggagaatc
+aaatacacatccgatgaaatcgtaacaaagataaaacaacgcgatttctatgtttgccaa
+agtgattaagttgtatcgtaggggtcagcgctgatgtcttttcagtttgggttttggatt
+taccagtcttttagtttcggtactatttgatcgggacattcgtccaaacatgatggctca
+ttcgttctttttttcaattttaatcaaaaccttgtatttacctgatacattaaactgagc
+atcgcatggaggtggagattcccatatatgtaatcatttgatatcctattccattctttt
+tagttataaataaacgctccactgcacaatgggagtaggacttcaccaataattagcatc
+tactgtaaacaagcgccgtaacgaaatgattactgattgagaaaaataggtctcaacaac
+ttttgacagatatgtatccgatacccaagcgttgctaattgcgcaaaagtaagtagaatt
+acggtcgtattacttgttgccaaatggttattactccaatgggctattctaatccgatgg
+atacgtaggagagagtgtacctacaccgaaactcgtagtgggcttagtggctacgtagaa
+gctgttcgggtcagttacagcgtgcgaccttgtaaaatcgatcacggtgatgaattattg
+ttattgtttaaaagaagtcccctgaatagcccttagataatacgaaaatttgttatgtcc
+agtcgctcgtatatcaaaagattcggttaagttcgcagagttttgccaagtttacaggtg
+atttactaacacttgggagggtacgtacaaccatcacctggttagcagagaatgaattat
+acggtcatgtcgcgaagggcaagtgtgtgagtattgaccgagttattaaacgtaaatgca
+ggcatttacgtcataggacatcgagtttgtcctttgcgaaatgttaaatttatggttttt
+tccgttgagtgataatagctgcaacatgaagatagtaaaactgaggttaaactttcacca
+tattaaattatatgttcaattacgcgatgtacaaactaatgttaatcagatttaggagcg
+cgcttaatatgggtccctatcccgactttgtacgagattttgataaaaaatagtattgta
+aattcatttgatggcgtagaaccgggcaaaaccttgaaaaaggacacatttaggatgcta
+tttccctaagaaagcggaaaatcctggctcaatatttataatagtaatggttaagattgt
+ggcccaatcgctgagtacccgtcttacgctttttccaacacataatcgacgagaatgtat
+ttaaatgtttgagacttacgttttccgcgtacttattattaaagtcattggagagggtgt
+cgtctgggtgtagttttctcatctgctcaggagctaaaaatgtaaatctattggttgttt
+ctaattctgtcgtccgtgtaggctatttaatttttatggtacacttgaatatgtttagcc
+ataatgtagccaatactacaatatcagatacttgtatacgacctatagacttttgccgac
+cgctcgtagagtgatttagaaagatgttcggatagcacagcaatcgtttgcgaatgtaag
+catgcgaagcgagtatttaactgttgactattttgctatatgttactctgaatgttgttt
+tttttaccagaatgtgttataatgatcaaccatgcacgttcctactaatcatataaattt
+tgttacgtaagcttttctatgatagtggtctaaagactacccttgcatactttaagatta
+agacatgcactttaggaggaactcacacgttttgagctgttctagcccacctataagcca
+ttcgtccgcaatcccataactacaatagtcggcaatcttttattacccagaactaacgtt
+tttatttcccggtacgtatcacattaatcttaatttaatgcgtgagagtaacgatgaacg
+aaagttatttatgtttaagccgcttcttgagaatacagattactgttagaatgaaggcat
+cataactagaacaccaacgcgcacctcgcacattactctaatagtagctttattcagttt
+aatatagacagtatttgaaccaggcgctaatgttaaggcccccttcgaaaaccttgttat
+gttattccatgtggtcggaggatttgcggggcgatagcgctgggcggggatcaacaattt
+cgttcatgcgagcgcccccataaccagtaggtacagttcggaaaagaaaaccccacgcac
+tcgctagaagtgttacaatcacatcacttcgtaccgaagggactactgtattccgtcttg
+gggatgtaacagactgattacagtcttatgatgaagcctcattcatctaaaattagttga
+tttattccacggatactatcacactcctatagaaagagttaccaccgtgggaagctagat
+ataataaataaaagacatacaatattagtatggctcatgatctacacttactcggatctc
+tctttttttataaccagtagatcgcattacacgtattgttgttccgcatcaggccctagg
+ggctcaaacttccatggtggataactaaaacgtccgtcactaaacgaagatattaataga
+tgaaatacacgggtttacttgatttctgttcagtcattcacgggaaatcctaggagtctt
+tcataacggcggtcttagtaggaatgtagtcaagctctgtagaggtctcgacggaattgg
+tatttcctggcatcacaatttacctagtattggagatcacttaaaataatgttgagataa
+taatcaggatatttctagtatgtgacaaacctctatttagtgattgtgattttcaattaa
+acaagacgtaggggtcaaattaacgactacatgttggaaagaaggccgaattgtaatatc
+taactcatgtactaagaagaagtgctttcgtttaaggctttctgtctaacattctaacgt
+caattcctatgtaatactactgtaaccaagttattactcggctgcgtagataaagtctca
+tgtaaatgacggtttatctgttacttttgggtttcaacctagctaggacgccggtactaa
+ttacgacacctgcgtatagtgcagggtgttcaatgtgcctttttatgtccggattataac
+catccctctcccacttggaatatcaccgggttcttaatgacttagttcgtcttccttatt
+ttccgggtaagatcgctgtggaccggacccattttgatctagtctaaaaaggtatatagc
+gtttcgtctggcccgcttacgttcactgaaacttagattaatcaatgcactgcactggat
+taacaagaacatgttatagtgtactgacacatgttagactaagaggtctgttcgggttag
+ccgacttatatgtttaaccgattttgacaactgggttgagagataacaatgaagagtgag
+gactgtagaagatcttaaaactgtaccatagtgctcaattcgctaatggcttgaattatt
+taattgttctaaccctggcgtcgaatttttttggttcgaaaatacttagcacagcgtatt
+gttcaacgagatgcacaactgtaccgttagaaagcggcttaatgacaaggcagtattgtg
+actattgacagggaatcctaaaaagctactcgaattggtatatggaagaggtatgtactg
+agaggtcgcgcctattagtcaaattctgccaaagaagagtcaaaagcttaactagtttga
+tggtatgaggtttaatgctaggtggtctataccaccaaaaagtatatgggatatcccaga
+atttatcgactttcaatcgtctaccgtcacgacgtacactaggcagccctaatccaaaac
+ttttgaggatgagtactgccactattatactgtaccatttgtaacttacattttatatct
+tcaaagaggtagatattgtcggccattactgtcacttacactaagggtagcttgattact
+gatacctctcatggtaaaaagtaatttaagaacctatttttttacataacctctgctact
+accgttagtgttttagtcggttcaagtcacaaaatccctgtagcgcacccctataagcag
+aaggaaaccttaatgcggataaaaacttttgccggaaccgttaatcctatgagaatacca
+ctcttggaatcggtcctttaggctgaggatatagaacgaggggaacgcatcaatctaggt
+taggtgagagaactttgtatcaaaacgcaagtaccatatgccgtcctcagtaaattgcca
+aatgcagaaatcttacactcttttcttaactaagtatgagagcaacctcactcctgaaca
+gcttgttacctaacgagaagaggctttaagtagcctggagcctcaaccggatatccggat
+ttgactctcatccacttacatgatgattacggtcattacatctcatgattttctgagtgc
+cctatagactgggaatttaatctaccctgtttctatttgttaacaaggagaaccactggt
+caagatgacgcgcttccatttatgccaccataagtaagttctcggaacccttacatgatt
+ggcctaccaacctatatatgtgaccaatgtacggtacatagagtgtggcctatcatattc
+aggtcatcgagctcagtatttaaagattatatggtcgctgggggtattcagtgcgcgatg
+gaagactaacattggaaatcaacggaattgacaacacgctcactttaataacctatctca
+ggataagtttaatgtaattagacggaactttctctaactccgtgtactaactctttgaaa
+ataatgtgggtatttttatttcatctagatttgtctgtatcgaaagaaagtattggtcca
+aataatcctcagtaaaatcaagtcataaatataaaatttagatcttaggacagaggaaag
+tgctttcccgagcataggatctggcctacgccagtagttcatgcttgtgttaaaagttgt
+tactgtttatagtccgtactcagggtagtgttcgatactcagcggggaactgacatatta
+cactaaggaatcaaggcccttcgtatgggtcatgtttatatatttaattacttacgctat
+ttgatcgagaatagctatagtaacgtcgtaagaatgcaggatgcgattcgagtttgtaaa
+ttcacagatactgtgtatcatattattatagatgttaaggcatagaattattggtattga
+tgtacaaaaaattatgggtgggcagtaccgataggcattacgagcagtgcagcttggaag
+aactggatgtatcctataactagtaagagccttaaaggtactacatacccagggatgtta
+ccatcattaatttggccatcttcaatcttcgcaatgcatactttcttctacaagatgcct
+tttagaagacaaaataagtgtcaacaataacgctgtaacttaactctgttgtacgtggaa
+tcaagtctcactaaagcaactaacattccgacatgcaaacgcaggactactagattatta
+aattcgccagcccgcctcgtttaatataacatcataaaaattctaagtaatatctcacac
+actaatccgccatcgtccatagcatcagtcacctgtcttacacaaacacatgtttaatcg
+atgttgttatgccaagctagtttcgcgaccatgtaactaattgtggaaagctgctacctt
+gaacgacatcaaccatcctacctttgtacaacagaccaacatctctgtactggtaaatag
+atctgaaaagttataaatataactgttttcacattgatagaaaaacagctatgtgctatt
+tgtatatactataataaattaagcgaaacatggagattaaaacagtgttttctcatcctc
+cacctcttgttctgctaatttataattcttgatgccactcgtgtgagtcgtccattcgat
+cgtaaagaacccgacataaatagatacgacgctgaacgagatcctatttctcctgaaaat
+tattagcacggtaactcctagggatagtggtactagttggtatgaacgtataaaaacttg
+tactactttctcgggatgtgagggagcaaactattactcgaccagtgcaacgcattatcg
+acagtaaaagttttcagctgatacctgtctggatggattatatgcaggtaggcgagagtg
+gattgtagcgatgctcggcgggggtattttaaaaatctaggtgataaaagtcctgtttag
+ccaggaaaagtcatcattgcactgcatatcgtcgattagctgtcatttcgtccactggta
+ccagttcaacgtacatcaaagtccgggcgcatccatatcaagttttgcaatagtactcca
+gaccatgaaatggttatccagattaataataacttaatatactttcactacatactcagc
+gggtattaaatttcactttatgtcaaaggactcttatgtggtcttcaaaaaggtctagag
+tctatcacgcctaattgtgtgaaaaccgagtaacttgatcagccttgtaaaatatagtag
+aatatgatgttaaatcatttatattccagggagattgaatagcttacgattagctggtat
+aatttaactcacatgattaagcaaatatctgtaggaccgagggaaagaataaaataaagt
+accatgagttcggaacgctgcattacatggcgttgggctagcctgatacaagaagatgag
+tatggagctctcttcatcgggacgtgacaaccctagcgtaatcttggcagatcccggagc
+agatgattatcgtctaacactgtctttaccaatgcacaacgcatagatttaacctgaact
+gttctggattcactcctgactacagcctacaactcatttctatgcataactcttaaagac
+agtcgcaatatcagtacctctatacacatcggatcagactagatcataagataagtctcc
+tctggatccttgtattctgttaagtacactacaaatttgtttagtgtctgggacaattac
+gataagggtcgcgactagaccacagggcatatgacctccaccgctcctagcgagtctcca
+atctgcaagcactcatacgctaggggcatgaatcgactgtcaatgcactgtaagatttac
+gagggtgagacccatttagatatgcctcgtttaaccgttttaggcttgataggatgagtt
+tgtcgatccatcaaattcccgacattcatattgtccaataagtatatctagcttattcgg
+actcgctaaactaaattatggtataaatgccgtcaaccggtgcatttgttcaatcaacaa
+attatagtcaatctcccatggggccttatggcagcgtatacagctggtataacgaccata
+tacaactatgaacggactagctgtgaactaagcagattattggatccttgtgtataattt
+taagtttcgatctatatgctatagtatagaaaatgttccgatcgtacgcttcctttacag
+ttaaacagtctatatcatgaagcttatccaaagctggacatttgatggcaatcttactta
+attatgaaacttaattacctattattgaaagtatttatatgatcgaataagatttgctct
+ataaacaggtcgtccattcacgacctagtgattgcgtaaattgaccaacctaggtaatct
+aaagcctgcatctatttcttatcattcatgttatactgacccgttctcagtacttaaaaa
+tgatcgtaagcaagaatcactcacgctcatgtcacatttagtcgaaataaactgccgatg
+ggaaggaagttccgtcattgcgatatcgatgtctatcccacgcgtcattttcaaattggt
+tatctacggataactgtgcgatgaactactataggtcaaaattatcttcaatctcattct
+agatcatataaagatgtccttcgcgattgatacgtctacagtgtgttggtgttacacaga
+gggtagcgactacttacttactaactctctcttgatccgcaagcataagccaggttaaag
+tgctctatctttttctgtggattataatagttataccgccttgcatctaggtgcccatta
+ggtaatgccctagtgttttcataaatttactcctgccatctaacgttactttaatttccc
+agattcaataggtctctcatttgaaaattgttatatgtcaacaaagaatataatagctga
+gtggaacaatacactgtgagggagtaatacatactctaaattttctttacggtttgcgcc
+tgcacagttttttttatctatgtgatccgcataaaaagtaatttcaacgttccattcaag
+ttaagtcttggtgacactagcattaggagagatcaccaagaccattatttatttagctag
+ggtttaagtcggttagaaatatcagataatgaggtctttatccggccttacgcagtagaa
+attggaaatttcgtaaagcactgagttcaatggaagtatggccgaacccacataatgcac
+aaatcaagtcgatttcttccgtccttttagtctcctgggaactacgggttattcatagtt
+aagctaaatcagttaacggaactagacaaatgtataatagttcccaaatatatatctata
+aatcttatgcagttagggaatgcagatttgaatcatggcaatacgctagctcggaactca
+actacaagtgttggatgtacgaattcaaaggtattacatccttatgatgttcttttttgg
+atacttttatgacgacttccacgaagtgaaattatgttcgaatatctgaacagttacttg
+gttgagcccaaggatgacgaatgttctgtttataattctcgtcataatataaatacaagc
+atatgaggccagtcatggagctttcatttggactaacatttccgtagagtcatatcacgc
+ctgtaatctgatccgtctttttctattcgaagtgttatcagatacatgacgcccttgcgt
+gacattcatggctcctgacatcgggtcttttaggctgaatctaatctaacccaatttgtt
+tggattgtgggtcctccattttgtctgttaatgcttattaagattaaaaatgtactacgt
+atttagacctaatgattgcgatacgctgtggaccattaatataagctgcgccaggggatt
+tttccagatcatctggcctgtgtatatgttcaaatctaatagccgagagaaattactccg
+acggaaaataaaggcagataagcgtttcagagcaccatcgtggcgtttagtcaaccttta
+gttcggaatttattaatatacaatctcactctttggacgagctccttaaaagatgccctt
+gtatatcatgtcccgtacctaaaagtataccagcatcatcaaagaacagttaaggaatac
+gactgctctataattgtccgaggagtaccttctcatctgccaatagtcgttgggttggaa
+aacaacgcattaatatgccacacttgtcaattagaagtttctataaaggggacgagtaac
+tgatttgagacctagcacggcagaggacgttcgtgtgacaacatctctttataagtttga
+gataaaatcgctaatctacaatgattatttgccaatcattatcgaatgcgcaaagtatct
+cctgttcgtgattctagcctaaggccattactatggtcaaattatgctaatcgaagcagt
+cttctaacacccttagaaaagcaaacactattgaatactgccgccgcattcgccagcacc
+aacataactgcacgtgcttttttccatgattggcattatgaaagatttgatctatgattc
+ttaccagttgcaatattcaatttagcatgtgttcctaattattgtgttattatggtctat
+ctcatcatgtaaatgaagatcatgacgtcaacacagattctagtcaggatcatcagttcc
+tcggggaaatcgcacctaggaacagccttatgcaaccgctaaacaaagcaatgaggatgt
+accgacaaaagctcgatttaaaagcctcgaaacgagatgtacgaatcgtttactgccttt
+tatgaggagtcgagtactgttggttcatatttgctacatgattgtatgtaataacgatcc
+cgccctttatcggttcgatcctttatggcgataagttatgaatcgtcagtatctttagat
+caaaaactcaactagtacccagttccccggaggaacggtcatgattaatgcgttttacgg
+tctcccgtccctcttcttgtcagaggaatcagtttcatccgatcccactcgatgattggt
+atagctatttgccgaaaagccacaacgtattcggtactatcttgtttgattcccctgtat
+cttaattcgcgacacttgatatcttttgtgtttaatcgacgaatcatcctgggggcgaca
+cttgttacaattatccagttgcgtttaatggctgtgggtcacaagattgttagacaggtc
+ccgcgtgtcgtaggaaattgataattggagtttgcaggacgaatagctcacccgcctaag
+tgatccaaccctcatcaggataactatcactgggcagtattatttttgatttcatatgcc
+accccctaggagactgtagtcatgtatctttcttacccaatctagcccgaaacaagaaag
+aatgtcgattccagtcaccttttattagaccgatttacacacaaagtgtcttggtttaaa
+ggctggcatgaatacatactcaaaagttgaaaacgacttgctctattcgattaccttcgc
+gatctcaatcgattacgctaaattttaatgcccgctgaaatatccaacatttaaaacagg
+attaattctctgatccatgaacttaggactcattgcacgtgacttatctttctctcttaa
+ttcatgctccaatacggtgggctaaaccacttttatcacatgaatgtacgcaacgtgtta
+ataagctatgagtacgcgggggcagcgaaacgggtcaatctgggtatcttctattgggac
+ggtacatttcggttttatagactatgtagttacacggcatcaacatgtaattaaaacggc
+gtaacctaggaaagccgaacgcaccttgggattgccatgtgtccggaggattacatacat
+ctaagaaacattctaaactatgtatagtcgtttacgacccttgtagtacgtgcatccctt
+ggcgaaaagtactctgggtattagagtgtatattatcgacagcaccgaatcctcatttta
+tagcttgacaatttatgacccgaaagaaccttttataagtctataagtatatctaacgca
+attgcggcactgagtccactaactatctttgagcagtgttatacagtgagacgccatgga
+aggggtttatatattttactgtcgttccctaaaaagttaattatcagacctgcgcgatct
+cgtagatgaacaacgcgatctagtcgaaaaatgcttgtggctaccattccagtcgagatc
+aaccgtttctgcggatcgcgttacattccttgcttatttgcgataaatcgatacaacccc
+attaccagaaaaacccggagaatcaattactctgcagatcttatactaaaaaagagatta
+caacccctgttctatgtgtcccaaagtgagtaacgtggagcgttggggtaagagcggagc
+gattttaactttcgcttttccattttccagtattgtactttacgttatatttgagcggca
+cattcgtcaaaacatgatccatatggactgaggtgtttaaatgttaatcaaataattgta
+ttttcagctgactttaaaatctgcagccattggaggtggagattccaatagatgtaagca
+ggtgatatcatatgcaattcttgtgacttattaagataccagacacggcacaatcgcagt
+agcacgtaaacaataatgacaatcgacggttaaattccgaacgtaagatatgtttacgga
+tgcactaaaataggtagcaacaacgtttctctgagatgtataagttaccaaacactggag
+aattccgctaaactaaggacaatttccgtcgtattaattgttgacaaatggttagtaata
+cattcgcagtggataatccgttgcatacctagcactgagtgtaaataaaaccaatcgact
+actggcatttcgggctaacgactagatgttagcctatgtgaaagcctcacacatgcttat
+tgccttcacggtgagcaatgtttcttattcgttattagaagtcacctgtagagacagtag
+agatgacctaaatttggtttgtccagtcccgaggtgatctaatgattaggttaacttaga
+acagtggtcaattggttaaagctgatttacgaacacttccgaggggtcgtaaaacattaa
+actggtgagaacagtatgatgtattcggtcatctagacaaccccatcgctgggagtttgg
+acagtgttatgattcgtaaatccaccatgtgtccgaattcgaaatcctgttgctccgggg
+agatagggttaatttaggcttttttacggtgtggcatattagctcaaacatcaacattct
+taaaatcagcgtaaacggtcaccagttgatatttgttctgctaggaagcgatgtacaaaa
+taagcttaataagatttaggtccgaccttaatttcggtccatagcacctctttctaagtg
+ttttgcttaaataattgtattgttattgattttctgcgagttgaacacggaaaataagtc
+aaaaaggacacttttaggttcatatgtaccgatgaatgcgcaatagaatcgagaaatttt
+tagattagtaatcgtgatgattgtggccaaatcccgcactaaacggctttcgctgtttcc
+aaaaaattttagtccactaggtatttaaatgttggacactgaacgtggaagccgtcgtat
+tatgaaactaatggcagaggggctcctctgcgtgtactttgagcagatgctatcgtcaga
+aaaaggtaaatcttttggttctttataattctggcgtccgtgtagcctagtgaatgtgtt
+tggttcaagtgaatttgtttagccagaatggaccaattacgtcattagctgttacgtcta
+tacgaaatatagactgtggacgacccatcgtagagtcatgtagttacatgtgaccttaga
+acaccaatcgtgtgcgattgtaagcaggacaacacagtattgtactggtcaattggttca
+tagatctgactatgaatcttcgtttttgtacaacaatctcggtgaagcttcaaaaagcct
+ccttcctaataatcagttaatttttcgtaaggttcctgttcgaggttagtcgtataaaga
+cgaaacggccttaatgtaacattaactattccactgtaggtggatctaacaaggttggac
+atgtgctaccaataagataagaatttcgtccgcaatacaatatctacttttgtagcctat
+cttggattaacaacaacttacgttggtatttcaccggacgtatcaaatgattctgatttt
+aatgactgagagtaaacatcaacgaatcttatgtatctttaagccgctgcttgacaagtc
+acattactgttagaatgaacgcttcattactacaaaacctaccaccaactcccacattaa
+tattatactagatgtttgaagtttatttgacaaaggttttcaaaaagcacagaatcgtta
+cgaacacgtacattaaattgttagggtattaattgtggtcggtgcatttccggccccata
+gcgctccgcggggagaaactatggccttcatgacagcccccccataacatctaggtaatg
+gtcggataactataaacaaccctctccagagaactgtgaaaataaaatctcttagtacac
+aagcgtatactggtttaagtcttgcccatcttaaagactcttttcactattttcttgatg
+cctcattcttctaatattaggtgattttttaatccgagaatataaaaagacgatagaaag
+tgttaaaacacggcgtagcgacatattttaaagaaatgaaatactttttgactatccctc
+atgatctaaacttacgcggagctatctttttgtataacatgtacagagaattaatccgat
+gcttcttccgattaaggacatagcgccgaaaacgtcatggcggcttatcgatatcgtaac
+gcactataccaagtgattaagtgatcaatgaatacgggtttcgggatttctgttaagtca
+tgcacggcaaatacttggagtcttgaataacgccgcgcgtagtacgaaggttctcaagct
+cgcgtgacgtatagaccgtattgctatttcctgccttctcaattgtccgaggattgctga
+taacttaaaataaggttgagtttttaataacgatttgtcgagtttgggaaaatcctcgtt
+tgtgtgtttgtcattttcaagttatcaagaactacgggtataatttacgacgtaatgttg
+gtttgatgcccgattgcgaatatcgtacgaatggtatttgtacaactgctttcctttatc
+gattgctcgagaacattataaagtctattactatggattaagactgtatacaagtgttta
+agcggagcccgtgataatctataaggttttggtacctttatctgttacttttgccttgaa
+acatacatacgtacacgggaatatttacctaaacgccgtatagtccagcctcgtatttgg
+gccgtgttttgtcagcattttaaactgaaagcgcccacttgcattataacccggtgcgga
+atctcttagtgactcgtcaggagtttacgcctttgagacctctcgacaggacccattttg
+atctagtcgttataggtagagtgcctttcctatcgcaccattaccttctagcaaacttag
+agtattcaatgaaatcatatcctgtttatactaaatgttataggctaatgacacagctga
+cactaagaggtctcttcgggttacccgaatgagttgtttatacgatgttgacaactcggg
+ggagtcatttcaatgaagactgaggactcttgatcagattaaaacgcttaatgactgata
+atttagattatgccgtgtattatttaagtgggcgaaccctcccctagaatgggtttcctg
+agaaaagtcttagaacacagtattctgaatccagatgcaaatcgctaacgttagtaagcg
+gctgtagctcttggcagtttggtcaatagtcaatcgcaatccgtttaaccgtctactatt
+cctagagcgaagagctatgttctgacacgtccccaatattaggcaaaggctccaaaagaa
+cagtcaattgattaactacgggcttggtttctccgtgaatccttgcgccgctataccaca
+taaaaggatagcggtgataccacaagtttgcgacgttaaagcgtcgaccctcaacaagta
+cactagcaaccccttagcaattaattttgtccatcactactgccaagagttgactggacc
+agttggaaatgacatttgatatattaatagagctacatattgtaccactttactgtcact
+tacactaaccctagcgtgattactcatacatatattcgtaaattctaagttatgatacta
+gttttgtaaatttaatcggcgaagacacgttctcttgtacgagcttcaactaaatatttc
+actgtagccaaccactttaaccagaaggataccttaatgccgatataatattgtccagga
+aacgttaatactttcacaagacaaagcttggaagaggtactttacgatcacctgatagat
+cgaccggaacgattctatataggtttggtctgagaaatttgtagctaaaaccatgttcca
+taggaactcctctgtaatgggcaaaatgcagatagcgttcaatcgttgcttaactatcta
+tcacagcatcctaactcctcaacagcttctttcctaaagacatcagcaggtaagttgacg
+gcacccgataacccagagcacgattggaatctaatactctgtatggatcattacgctaag
+taaatataatgattttctgactcaaagttacactgcgaattttatattaactggttctat
+ttgttaaataccacaacctctcgtcaacaggtcgcgatgcaagtgatccaaaaatatcta
+acttataccaaccattacttctggcgcagaaaaacatagatatctgaacaatcgaccgtt
+aagactgtctcgccgatcttaggaacctaatactgctcagtagttattgtttatttgggc
+catccccggattatgtcagccatggaacactaaaagtcctaatctaacctatggacaaaa
+agctcacttttataaaattgctcaccttatgttgattgttatttgtccgaaatgtctata
+actcagtgtactatctattggaaaattatggccggagttttattgaatatacttttgtat
+gttgagaaagaatgttgtcgtaataattatcagctggaaaatcatctaatatatattata
+ttgagatattacgacagacctaagtgctttcccgtcatgagcagatggactaacactctt
+ggtaatccttctcgttttagttggtaatgtttagtctaagtaatatcccgactcttactt
+actcagagcggaaatgactttttaaactaacgtttaaaggcacttagtatgcgtcagggt
+tatttttttaattacgtacccttgtgcagagagtttagctattcgatcctacttagtatg
+aaccatgagagtacaggttggtaattcacagagaaggtcgagaagattatttttgatgtt
+taccaatactatgaggcgtattcatcgaaataattttatggctgcgcacttcacatacgc
+aggaagaccactgcagcttgctagatctggatgtatcattgtacttctaagagcctgaaa
+ggtaatacattcccagcgagcgtaacagattgtatggggacatattcaatcttagcaatg
+cattcgttcttcgaaatcaggcatttttgatgtcataagttctgtcaactataaccctgg
+aactttaatctgttgttcgtcgaatcaaggatcaagaaagcttctaaaaggcccaaagca
+aaacccaccactacttcagttttaaattagaatcacaccctagggtattagataataatt
+aaatgtcttaggaagagatatcaaaagatgcagacatcctcaagtgaataagtctccggt
+ctttcacaaacacatggttaagcgatgtggttttgactagagacgttcgccaccatcgta
+atatttctggttacctgcgaacgtgaaccaaatcttacttcatacattgcttaaacagta
+caacttatctcttatcctatagagatctcaaaagtttgtatttttactggtttcaaattg
+agagaaaaactgcgttctccgatttctatattattgtttaaatgatgccaaacatccagt
+ttaaaacacggtgtgatcagccgactcagattcgtatcctatgttagaatgagtcatcaa
+actacggtcacgcgtacattacagagtaaactacacgaatgaaagagataagaagatgaa
+agagttaataggtctcctgttaattatgagaaccctaactactacggattggcctactag
+tgggttggaacggatataaaattcgactaagttcgcggcatgtcaggctcctaaatatga
+agagaactcggcatcgaattatccacagtaatagttggaacatgattcctctatgcatgg
+tgtatatccacgtacgccagtgtgcagtgtagccatgcgaccacgggcgttgtgaatatt
+cttcctcagaaaaggactgttgagcaaggaattggattctgtgaacggaatatagtcgag
+tagatggaatttcctacactgcgaaaaggtcatagtaaatcaaacgccgcgcgcagacat
+atcttcttggcaattagtactccactaaatcaattggttataaacttttagaatatcttt
+atataagttcactacttacgctgcgggtagtatatttaaagtgatgtcttaggaatctta
+tggcggcggaataaacggcttgactatagataccctaattctggcataaccctgtaacgt
+gtgaagcatgctttaatagacgactagatcagcttatagaatggatatgactgccacatt
+gaagagattaacattagcgggtataatgttacgaacttgtttaacaaaatagctctacca
+cacacgcatagtataatataaaggtcctggagttcgctacgagcctggaattgcagttcc
+cctaccctgagtaaacaagatcagtatggacctatcttctgacccacgtgtaaaaactac
+cgttagcggccctgagaacggtgaagttgattatcggctaacactcgctttaccaaggaa
+caaacaattgatggaacaggtaagcggctggattctatcctgaatacagcataataatat
+ttgctttcaatatatagttatgacactcccaatatcactaactctttacaaatcggatat
+gaagagtgaattagagatggagccgatcgttccttgtattctggtaagtactcgactaat
+gtgtgtagtctaggggtaaaggtccttaaccgtcgagtctagaactcacgcattatgaaa
+tcctccgagcatagagactctaaattcgccaagcaataagtcccgacgcgaaggatgaga
+agctcattgaactgtaacatttacgtcgggctcaccatgttacatatgcagcgggtaaaa
+gtttttgcctggagtggttgagtttcgcgatacataaaaggccccactttcatatggtca
+aatatctatatcgtgctttggacgactcgataaactaaagtagcctagtaatgccctaaa
+ccgctgcatttgtgcaataaaaaatttagagtatatataacttccggacgtatggctgcc
+ttgaatcctcggatatcgtccttatacaacgatgaacggtatagctcggaactatgcaga
+ttaggcgatccttgggttgaatttttagtttccatagatatgagttagttttgatatggt
+taccatacgtccctgcattgaaacttaatctgtatattgattgatccttagcaatagcgg
+cacatttctgggcaatatgacttaattaggttacggtttttactatgatggatacgtttt
+atatgatagaataacagttgctatttaaacaggtactacattcaactaatactgtttcac
+tattgtgtccaacatagggaatatattgcctgaatagatgtattatcaggcatcttttac
+gctccaggtagaactaattaaaaatgatccttagaaactttcaagcaacataagctaaaa
+gttacgccaattataagccacatcggtaggatcttcaggcattcccatatccttctctat
+caatcccgtctgttgctaattggttatctaagcatatcgcggcgagcatctacgataggt
+ataaagttgctgctatctaattcgtcataatatatacatggaattacagattcatacgtc
+ttcagtctcgtggtgtttctaagagcggacccaagaattacgtaatatctctctcgtgtt
+acccaagaagttgacacgtgattgtcagctatctttttctggcgatgttaatagttataa
+acaattgcatatagctgcaaattagctaatcaaatactcgtttcttaaatgttatcagca
+aagctttaggttctgtaatttcactgtgtaaagagggcgctaagttcaaaattggttttt
+ggcaacaaacaatttaatagcgcagtgcaaaaataatatctcagggtgtaattatttctc
+taattggtctttacggttggaccaggcaatgggttttttatctatgtgataccaattaaa
+agtaatttcaaagtgacattaaacttaagtattgctgtcaagaccattacgacacttcac
+caacacatttatgtattgtgctacgcggtatggcccgtagtaatttctgatattgaccgc
+gttatcagcaagtacgctgtacaaatgccaaatttagtaaagctctgtgtgcattccaag
+gtgcccacatcacacattatcaacatatcatgtcgttgtattacgtccttttactagcct
+gggaaataccggtgattcagagtgaacataaatctctgaaagctactagacaaagctagt
+atagttaaaatatatatttcttttaatattaggatctttgcgattgcacatttcaagcat
+cgcattaacctacctccgtactcttctacaacggttgcatgtacgatttctatgcgatga
+aatacttatgttcttagtttggggttactttgttcacctagtcctcgaacgcaaattagc
+ttcgaatatctgaaaagtgtatgcgggcaccaaaacgatctcgattcttaggtttataat
+tatagtcagaagataaatacatgcatatctggacactcttccacatgtcatgtcgactaa
+ctttgaactacagtcatatatagactgttatctgatccgtatgtgtctattactactctt
+atctgagaaaggacccaatggagtcacagtaagcgatcatgtcatcggggctttttccct
+gattataagattacactattgctgtgcttggggcctcctactttttctatcttaatcatt
+ttgtacattaaaaagctaagaagtaggtacaacttatctttcccatacgagctggaccat
+taatttaacagccgcaaggcgagttttaatgttaatctggaagggctttatgttctaagc
+ttttagcactgagaaattaatccgtaggaaattaatcccacataacccggtaagagaacc
+ttacgccccgttactaataatgttctgcgcaatgtaggaagtgacaagctcactcttgcg
+acgagctccttaatacaggccctgcgttatattcgaccgtacctataactagaccaccat
+cttaaatgtacagttatggttttcgacgcatagagtatgggaccacctcgaaatgctcag
+ctgcaaattgtactgggggtggttatcaaacatttaatatgaatctatggtaaagtacta
+gtttatagatagccgaacactaaaggtttgcagaccttcctcccctgaggaacttcgtgt
+cacaaattagattgagaaggtggtgataaaatcgcgtatctacaatgatttggtgcaaat
+atttatcgattgcccaatcgttctactcgtactctttatagcctaacgccttttcttggc
+gctaattagcctaatccaagaaggagtctaacaaaattacttaaccatactcttgtctat
+tcggcccacgcatgcgcaagctcaaaaagttctcaacgggcgtttttacttgagtcccag
+gaggtaacattggatctatgagtcttaacagtggaaatatgatttttagattgtgttcag
+atttattgtcttattttggtctatctcatcagctatagctacataatgacgtcttaactg
+tttcgactaaccttcagatctgactaccccaaatacaacatagcaaaagaatgatgctaa
+cgcttaactatcctttcacgatcttaacaaaaaagctccatttaaaagaatcgaaaacag
+atctaccattcgtggaatcaatttttggacgagtactggtcgggtcgtgcttatttgcta
+caggattgtttcgtataacgttcaagcactttagcggttccatccttgatggcgttaact
+gatgatgcgtaagtttatggtgatctaaaactctactacgaaccaggtcccagcacgaaa
+cgtcatctttaatgagtttttaggtctccaggcactaggctgcgaagtggaatatgtgtc
+atcagagacaaatagatgattcctatagctttttgcagttaagccactaagtaggcggtt
+ctatagggtttcattcaaatcgatcgtaattcccgactctgcatagcgtgggtcttgtat
+agaccattcttcaggcccgccacaatggtttcaagtttcaacttccgtttattggctgtc
+cctcaatagagtcgttctcagggcacgactctcgttcgttattcataagtccagtttgat
+ccacgaatacagaacacgcatatctgataataaaagcttaacgataactttcacgcgcat
+ggtttatttttgatttattaggcaaccaaataccagaatgtagtcagcgatatgtagtaa
+aatttagacaaacataaaacaaagtatcgccattacagtctcctgttaggagaacctttt
+tatcaatatgtgtaggcgtgtattggcgcccttgatttaataataattacggctaaacgt
+attgatattttccaggaactgccccatctcatgagatgaccctaaattttattcacacct
+catttttaattcttttatatcacgattatttatctgagcaagcatctttgcaagcattca
+tagtgacggtgctgtctctatgaatgcatgctaatatacggtgcgctaaacatattggtt
+caattcaatgtaagctacctcggaatttgcttgcactaagacggggaagccaaaacggta
+aatcgccgtatatgctagtgccaagggacttgtccgttggagtcactatggagttacaag
+cattataaatctaaggaaatcgcagtatcagtccttaccccaaagatacttcgcattccc
+tggggtacggaccatgaaatacttctttcatacatgataaacgatggagactcggttacc
+accctggtagttactccatcaattggagttaactaagatcgctattacaggctttattag
+ccaatcatcacaagcctctttttagagattcacaagttagcaaaccaaagttcctttgat
+aagtctttaacgagatctatcccaattccggctaggagtaaaatttatatatttgagatc
+ggggttaaagtcacacgcaatgcaaggggtttttatatggtaatgtccttccctaattag
+gtaattttcagacctccgagagagagtagatcaacaacgcgttatactcctaaaatgctt
+gtcgataacatgacactacagatcatccctggatgagcatcgactttcattacttgatta
+gttcagttaattcgtttcaaaccattttcaacaaaatcccccagtagatatgtatatgca
+catcttagactaaataacagttttcataccctgggatttgtgtcactatctcaggaacgt
+cgagacgtcccctatcaccgcagcgagggtaactggccctgttccattgtaatcgatggg
+acgggacgttatattgcagacccaaagtagtaataaattcagccatatggacggaggggg
+ggaattgttaagaatataattcgattttcagctgaatgtaaaagctccagccattcctcc
+tccacttgacattagttcgaagaaggtctgagaattggaattgcttgtgacgttttttgt
+ttccagacaaggaaatagcccagtaccaagtataatattatgacaatagaagcttaaatt
+cacaacgtaacatatctgttagcatgctctaatagaccgagaaaataagtgtctatgtgt
+gcgagaactgtcaattcacggcagtagtcacctaatctaacgtctagttcccgactatga
+agtcttcacaaatggttagtaataatttcccagtggagtagaagtggcataacgtgcact
+ctctgttaataatacctttagactactcccatttcgccagaacgtcttgatggtacccta
+tgggaaacactcacacatgcttattgcctgcaacctcagcaatgtgtcgtatgcggtatt
+tctacgaacagctagtgaaaggactgatgacctaattttggtttctcaagtccagacgtg
+atattttgatgaccgtatctgacatctctgggcaattcggttaacctctggtacgaaata
+gtccgtcgcgtaggtaaaaatgataatgctgtcatcactatcatgttttagctaagctac
+actaccccatcgctcgcacgtggcaaagtgtgaggattccgatatcatccatgtgtacga
+attcctaatactcttgctcagggcacttagggttattgtagcctgtgttaccgtctcgca
+tattagatcattaatcaacagtcttataatcaccgtaatcggtaaacagttgttatttgt
+tctgataggtagacagctaataaagatgctgttgaacagttacgtcccacctttattgcc
+ctacagtgaaactagttcttactctgttgctgtaatatgtctagggttattgatttgctg
+ccacttcaaaacggaaattaagtcattaacgaaaatggttccttcataggtaaagatcaa
+tccccaattgaagccagaaattttgagatgtcgattcctgatcattcgccaaatttacag
+ctcgtaaacgagttccatgtgtaaaaaaatgttgagtccactagcttgtttattctggct
+caaggtacgtggaacacgtagtattttgatactaatgccagacccgctacgatccctgta
+ctgtgagcagagccgatcctcagaaatagctaaatcttgtgcttcgttagaagtctcgac
+tacgtgtagcctagtgtttgtgttgcgttatagtctatttgtggacacagtatggtcaaa
+tgacgtcttttgatctgacggcgttaacaaagatactctgggcaacacacatacttctct
+catgttgtttcttcggacctttcataacctttcctggcacatggttagctgcacatcaca
+ggattgtaagggtctagtggttcagtgagcggaatatcattcgtcggtggtgttaatcta
+tctcggtgtagcttataaatgcatccgtaagaatattatgtttatttgtcggtacgttca
+tggtagtggtgtcgccgatttagacgtaaaggcatgtatggatcttgatctatgcaaagg
+taggtccatctatatacgttgcacagcggatacaaataagataagaatttactaacattt
+aaattttcttattgtcgagcatagattggaggaaaaacttatttacttggtatttaaacg
+gaagtttctaatgtttatgattggatgcacggacagtttactgcttactttcttaggttt
+cttgaacaacaggatgcactagtaacatgtctcgttcatgcttccattaagttcttctta
+aacttacacaaactacctaatttagagttgacgagatggttgaacgtgttgtgacaaacg
+tttgcaaaatgcacagtatcgttaccaaaaagtacatttaagtgtgtgcgtaggaattct
+gctacgtccattgcaggccacattcacatcccacccctgaatatatggactgaatcacac
+acaccaaatttcatctaccttatcgtagcataactattaacaaacatatacagacttcgc
+ggtaaataaaatatattagtacacaaccgtatactggttgaactattgcccagctttaag
+acgcttttaactaggtgcttgatcaagaagtattattatatgacggcagtgtgtaatacc
+tgaatagatatagacgttagattgtctgaaaacacgccgtagagacatttttgttagata
+tgtatttctttttgacgagccagcatcttagtatctgaagacgagctatatgtttgtaga
+aaatcgactgacattgtatacgaggcggcgtaagattaaccaaattccccagaattagta
+atggcgccttatcgatttactaacgatatataacttgtgatgttgtctgcaatgtatacc
+cgtgtaggctgtgctcttatcgaaggaaacgcattgaagtccaggctggatgaaaccacc
+gcgtacttccatgcgtctatacatagcgtcaccgatactacgttttgctatgtaatccat
+tctaatgggtaagaggattcctcttatagtaaaatatgcttgactttttaagaaccattg
+ggagtggttggcaaaataatagtgggtgtctttctcagtgtatagttttctacaactacc
+cctattaggttacaagtaatctggctttcttgccacttggcgatgatagttagattcgta
+tttctacaacgcagttactgtatccatggcgcgagataattagatacgatttgaatttgg
+atgtagactcgttactactgttgtagaccagcacgtgagtatctagatgggtttgctacc
+ttgttagcggacttttgccgggaaaaagacatacgtacaaccgtatattttactataagc
+agtattggccaccctcgtattgcggcagggtgtgctcacctggttaaaatgaaagagaaa
+aattccattttaaaacccggaggaatctattactgacgaggaaggtgtttaacccgttga
+gacatctcctaacgtaaaaggttcatattctagttattccgagagtcactttcctatcca
+aacatgaactgatagcataatgacaggttgaatggaaagcatatcctgtttattctaaat
+ctgtttcgctaatcaatatgctgtcacgaactcggagcttacccttacaactatgtgttc
+tgtttaccaggtgctaatatcccggcactcttttcatgcatgtcgctcctagcgtcatct
+gatttaatagcttaatgtctcatattttacagtagccagtgtagtatggaaggcggcgaa
+ccagcccctacattgggtttcctgacataagtattacatatcacttgtctgattacacag
+caaaatcgctaaccttactttgcgcatgtagctattggaactttgggctagtgtctatcc
+cattaagtttaacagtagactagtccgtgagcgatcaccgagcttatgtctcgtacccaa
+gttttggatttggatcaaaaactactcgatattcatgatctacgggcttcctttctccgg
+gtatcattgcgccgagattaaaaataaaacgatagcgctgtgaaaacatgtttgacacgg
+gatagcgtagaaactaaacaacgaatagaccatccaatttgaattttattgggtccagca
+cttcgccatagtgttgaatggtaaagttcgaaaggaaatttgttatattaattctgctac
+attttcgaccacttgtatctcaaggacaatatcccttgaggcttttagcagaaagagatg
+ccgtaattctaagggatgataataggttgggaaatttaagagcagtagtaacggtcgcgg
+gttcgaccttaaactatatatttaaatctagccaaacaagttaacaacaaccataaagtt
+atgaccttattatattggcaagcttaacgttttaattgctctagtaatagagtggtagag
+gtaagggaccatcacctgattcttcctccgcaaccattatatagacgtgtcgtctgacaa
+atttcgagataaaacattcgtccttagcaacgaatatcgaatggcaattagccacattga
+gttaaatagttgaggatatttcttgcacagaatcagatctaatctaatgattcgttacta
+aacacttcaccaggtatcgtgaaggctcaagattacccagagaacctttgcaatataaga
+atatgtatgcagcattaccctaagtaattatattctttttctgactcaaagtgacaagcc
+ctagtgtatattaaatcggtatatttgggaaattcctcaaactatcctaatcaggtagcc
+atgaaagtgatcaaaaaagttcgtacttataccatacatgaattctggccaagtaaaaaa
+tagattgcgcaaaattcgtaccttaagtctctcgccaagatattaggatcctattactca
+tatcgtgtttttctttattgccgccatccccggagtatctcacccatccttctcttaaag
+gcctaatattacctatgcaaataaacatatattgttgaaaattgagaacctgatcgtgat
+tcttatgtgtaccatatgtatagtaatcacgcgactatatagtgctttagtatcgcccgt
+gggtgagtgaatattctgggctagcgtgagatagtttcttgtcctaatatttttcagatc
+gaatagcttctatttttgtgtttattgacatatgtcgaaactccttactcagtgaaagtc
+atgaccagatccacgaacaatcttcggaatcagtctcgttttacggcggaatcttgagtc
+taacttatatcccgtcgcttactttctaacaccccttatgtatttttaaaattacgttta
+ttcgaacgtacttggcggaagcgttattttttgaagtaagttacattgggcagactcttg
+acattttcgatacgactttctttcatccatcacaggactcgttcgtattgatatcagaag
+ctcgtgatgattagttgtcttctttaccaatactttgaggcctattctgcgaaatttttg
+ttgccctgcgaacttcacataccaaggaacacctcgcaacatgccttcatatccatcgtt
+cattgtaattcttacacaatgaatcctaagtaattacatccctgcgtaaaagatggtagg
+ggcactgaggatatattaccaagcatttagttatgagtaatcagcaatgtttcttgtatt
+aagttctctaaaatagttacatcgtaatgttatctcgggttccgcgaataaacgagatag
+attcattatatatggccctaagcaaaaacctcctcgtattctgttggtaattagaatcac
+acaatacgggttgagatattaattatttgtagtacgaagagatataaaaagatgaacaat
+tactcaagtcaagatgtatacgggatttataataaaaatcgggtagagatctgctttgca
+attcagacgtgccactaaatcgtaatatgtcgcgttacatcagaaagggtaactattatt
+aattaataaagggcttaatcactacatattagatcttatccgatagtcttatctattcgt
+tgtatttttaagcggttctaattcagtcattatatcagtgctccgagttctttattattg
+ttttaaggatgacaaaatgcctcttgttataacgctgggagaagcagactaagagtcgga
+gcagttggtagaatgaggctgcaaaagacggtctcgacgaatggacagactttactaaac
+caatgaaagacagaagtagagcaaagtctgaagtggtatcagcttaattatgacaaccct
+taatacttccctttcgccgaatactggcgtggaaaggttttaaaagtcgaagtagttaga
+ggcatctctcgctcataaataggtagactactcgcaatccaatgtgactatgtaatactg
+ggaacatcagtccgcgatgcagcgtgtttatcaaccgtccccactcgcctggggagacat
+gagaccacccccgtggggattattagtccgcagtaatcgactcttgacaatccttttcga
+ttatgtcatagcaatttacgacagttcagcgaagtgactactcggcgaaatggtattact
+aaagcattcgaacccacatgaatgtgattcttggcaatttctaatccactaaagcttttc
+cgttgaatctggttgtagatatttatataagttcactaattaagatcacggtagtatatt
+gatagtgatgtctttgcaagaggttggccgaggaatttacggattctctattgatacaat
+ttgtctggcttataactcttaaggctgaaccaggcgtttttagacgacttgatcagctgt
+tagaatggtttggactccctctttcatgtcagtaacatttcagccgttattgttacgata
+tgcttgaacaatattgatctaccacacacccatagtatattttataggtcatgctgttac
+ctacgagcatggtattccacttcccattcaatgagtattcaacatcactagcctcagaga
+tgatgacccacctctaataacgtcacgttgcggccatgtgaaacctgaacttgagtagac
+gatatcaagcgctttaaattgcatataacatttgagggtaaagctaagcggatgctttat
+ataatcaatactcaataataagatttgattgcattttagagttatgacacgacatagttc
+actaacgagttactattcccagatctagactgaagtactgatcgagacgatccttacgtc
+gatgatcgttagttatcgacttaggtcgggtctctagcggtattggtacttaaccggaca
+ctatactaataacccatgatcaaagcataacagaatacagacgataatttcgccaacata
+tatgtacagaccccaagcatgagaagctcattgaaagctatcattgaagtcccgctcaca
+atgtgtcttttccagacggtttaactggttcccgggagtcctggagtttcgacttacata
+aatggaaacaatgtattttgctaatttatctatagcgtcatttggaccaatacagaatat
+tatgttgcctagtaatccactataacccgcaagtgctgatagaaaatttttagacgattt
+ataaatgccccaagtatccctcccgtgaatcctccgttatactaattagtattcgttcat
+acgtataccgcgcatatatgaacatttggcgataaggcgcgtgaattgttacgtgacaga
+gatagcagtttcttgtgatatggttaacagacgtacatgaagggaaactttatatctata
+gtgatgcttccgtagaaataccgccactggtctgccaatgatgaagtatgtagctttagg
+tttgtactatgaggctttcgtttgtttgcagagtataacagttgcgagtgaaaaaccgac
+gaatttatactaatacgctttcactattggctacaaaatagggaagagtttcaatcatga
+gagggagtatatggatgctttgtagctaaaggtagaacgtatgtatatgctgccgttcat
+tcttgaaagatacataagcgataagttacgacaattataagcaacatccctaccttcgta
+acgatttcactgttactgcgcttgaaatacactatggggctattggcggagagaagcaga
+tcgcgccgagcatatacgagacctataatgttgatgatagagaaggcgtctgaattgata
+catcgaagtacactttctttcgtagtatctctcgtcctctttctatctccggacacaaga
+attaagttatatatatagagtcttaccaatcatgttgaatcctgattctcagagttcttt
+ggcgggccttgtgatgactgagaaacaatgcaatattgctccaaatttcctaagcaaatt
+ctcggttatgttatgttatcagcaaagcgttacgttatgttatttaaatctggaatgacg
+gagcgaagttcttatgtcggtgtgggaataattcttttgaagacagcactccttaaataa
+tatcgctccgtgtttgtatttatcgaatgggtctgtaaccttgcacaagcaaatcggtgg
+tgtatatatcggataacaattaatacgatgttcatagtgacagtatactgatcgagtcct
+ctaaagtcaattacctcacttaacaatctcattgatgttgtgtcattcccggtatcgccc
+gtagtatgtgctctgattgaccgagtgtgaaccaaggaacatctactaatgcctttgtta
+ggtaagatctctctgaattccttcgtgccaacttaaaacattatcaaaatttcttctact
+tggattaactacttttacgagcatggcaaattcccctgtggaagacggttcattattatc
+ggaaaccttatagaaattgcgtgttgactgaaattagatttttattgtaagagttgcatc
+tttgcgattcctctggtctagcttccaatgaacagtcctcccttctattcgacatcgggt
+ccttcgtacatgtctttgcgatgtaataattaggttcggagtgtggccttaatgggtgca
+actaggaatacaacgcaaatttgctgacatgatagcaaatcggtatgccggcaccaaaac
+gtgctccttgcttagcttgtgaatgagactcagtagttaaataaatccatatctgcaatc
+gattccacaggtattgtccactatctttgaactactctaagagatacaagcttagctgag
+accgaggtgtatatgactacgctgatatctgtaaggtaccaatgcaggcaaagtatgcga
+gaagctaataccggctgtttccagctttataagattaaaatttggctgtcctggcggcct
+cagaattgttctatcgtaatcagttggttcattaattagctaagtacgaggtacaactta
+tctgtcccagaacagctccacaagtttttttacagccgaaacccctgtgtgaatcttaat
+atccaagcgcgttatctgattagagtttacaactcagtattttatcagtacgttttgttt
+ccaacattacccggtatgacaaaatgacgccacgtgtcgaataatggtctgaccaatgta
+ggaagtgaaaagataaatattgcctacacatactgaattcaggcaatgcgttttattcga
+aaggtcatataactagaaaacatgatgaattcttatcggatccttttactagcatagtgt
+tggcgaacacctcgtaatgctcagcggcaaattggactgcgggtccttatcatacatttt
+ttttcaatataggcgattggtctaggttagtgattccccaacacttaaggtttgctgaca
+ttcataccctcagcaacttcctctcaaaaattagagtgagttggtggtcttataagaccg
+ttgattatttgaggtggtcaaatgatggtgcgatgcacaaatcgttataatcgtactctg
+tagacaataacccattgtagtgccgattttgtgcataatacaagaaggaggatataaaaa
+tgacttttcaataatattggctattagcaacaagaaggagaatcctcattaagttagcaa
+ccgcagggggtactgcagtccaaggaggtttcattggagagagcagtatgaaaacggcaa
+ttatgattgtgagattcgctgaagattgtgtctctgattttcctagatagaataagctat
+agctacttaatcaactcttaactgtggagactatcctgatgatctgaataccccatttac
+aaaattccatatcaatgaggctaacgcttaaatttcatttctccatcgtaacaaaaatca
+gcctttttatacaagacaaaacactgcttccattacgggtagcaatggttgctcgactac
+tggtagcgtcgtgatgtggtgataaagctgtcttgcgtttatacttaaacaaattttgac
+ctgacataatggagcgacttatcggatgttgccgatctttagggtcatctattaagctta
+tacgaaaaagggacaagcacgttacgtaatctggtaggactgggtacctagaaacgcaag
+aggaggcgaactccaatatctgtaagaacagaaaaatacaggagtccttttcatttttca
+agttaacaatataagtaggagcttagagaggcttgcatgaaaatcgttaggaattacaga
+ataggcagagagtggggcgtgtagactacattcttcaggccccacaatatgggttatagg
+ttaaactgcactttttgcgatctcccgaaatactgtcgttctctgcgaaccacgctcgtt
+ccttttgctgtagtccacgttcatccaactattcagataaacaagatcgcagaattaaag
+cttaaccatatcttgatagcccatcgtgtatggggcatgtatgtgcaaacaaaagacctc
+aatcttgtctgcgagagggaggaaaatttagacaaacataattcattctttcgactggac
+acgctaaggtttggacaaactttgtatctatatctggaggcctgtattccagcccttctt
+ttaataagatttacggcttaaactatggatatttgccaggaaatgacactgctattgaca
+ggaacataattttgattcaaacctcattgttaattattttatatctcctgtttttatatc
+agaatgcttctgtcctagaaggcatactcaaggtgagggctcgaggaatgaatcataata
+gaccggcccctattaatattggttcaattctttcttacataacgcggaatttgattgcac
+gaacaccgggaacacataaccgtatagcgcccgttatgctagtgcctagcgactgggacc
+gtggagtctatatcgtctttctaccattattaatctaaggatataccactttaagtcctt
+tcaactaacataaggcgcattccatgcgctaaggaccttgaatttattatttcttacatg
+ataaaagatcgagtcgacgggaacaaaaggctacgtactcaataaagtgcagtttactaa
+gagccctttttctggcttgtggagactatcataacatgaagatgttttgacattcaatag
+tttgcaaaacaaacttactttgtgtagtattgaacgagatctttccaattgccccatagc
+aggaatagttatatattgcagatcgcggtgtaacgcactccaaatccatcgcggtgtgtg
+agggtaagcgacttaaagaattacggtttttgatcaaagcacagtgagagttgagcaaat
+tacagttatacgacttaattcagtctccataaattgaaacgacacttcttaacgggagga
+ccagacacgttcattaagtgaggagtgcactttttgactttaaaaacatggtaatcaatt
+taaaccacttgatatgtatatgaacagatttgaagttatttctgttttaatacactggga
+gttctgtcaatatcgcaggaaccgcctgacgtcccctatcacacctcagagggtaaaggg
+acaggggaaagggtaatcgaggggtagggaacgtagttggcacacccaatggacgaataa
+atgctgccatatccacggagggcgggattgcggttgattttaaggcgatggtaacctgaa
+tgtaatagatcatcaaatgcctcctccactggaaattactgcgtacatccgctgagaatt
+gcaatggagtgtctcggtttttctttaaacaaaaccaaattgacaacttcatagtataat
+ttttgcacattacaagcgttaattaacaaacttactttgctgttagctgcctatatttgt
+ccgacaatataactggatatctctgcgagaactgtaaattaacggcacttggaacataat
+agttcctattggtaacgacgttgtaggcggcaattatccggtggaagaattgacaactgc
+agttgaactgcatgaaagtcaaatctctcgtaagtataactttagaagactccaaggtac
+ccagaacctcttcagcggacacgatcgctatcaatcaataaggattattcactgaaaccg
+ctcatatctggaggtggacgtttttcttcgaaaagcttgtcaaaggactcatcaaatttt
+tggccgtgctaatcgacacacctgttattttcatgaccggataggacatctcgcggaaat
+tcgggtaacagctgggtagatataggacctcccctacgtattaatgataagcctgtcata
+actagcttggtttaccgaagagacaataaacattcgagcgctcgtgccaaactcggtgca
+ttacgtttgaataaatcggtaacatgtactattactctgcctaacggcacttacccgttt
+gggtccatggggtaaccgctcgatgttgacagaattatgctaaagtcgtttaagatcccg
+attaccgaaaatctggttatgtctgagcattcgtacactgcgtattaagatcaggttgaa
+caggttcctaacaaattttgtgacctaaagtgaaactaggtcgtactctgggcatgtttt
+atgtcgtggcgtatgcatgtgctgacacttctaaaaccaaattaaggctttatccaatat
+gggtccttaagtgctaaacatcattcacaatttcaagacagattgttggtcttgtcgatt
+ccgcatctgtcgccaaattgacacatcgtaaaccaggtacatcggtaattatatgttgac
+taaactaccgtgtgtattctggctctaggtacggcgaacaagtacgatgtgcttaagaag
+ccctcaccccagacgagcccgcgtaggtcacatcagcagatcctaagtaattccgtttta
+ttgtcctgagggagtaggatcgacgaactctacaagtcgctttgtcgtgccttataggct
+atttcgggtcaatgtagcgtcaaatgaactattgtcatctgtacgagttaactaagtgtc
+tatcgccaactaaaagacgtctcgatggttctttatgcggacctgtcatatcattgactg
+gcacttgcttacatccaaataacacgtttgttagcggatagtcgttaagtgtgcgcaaga
+tcatgaggcggggggggtaatatttcgccctctacatgataaatgaataagtaagaagat
+gatctttttgtggcggtaccttaagcgtactcctgtcgacgagttactactaaaggaatg
+tagggttctggatctatgaaaagcgacctccatatatatacgggcctaagcggagtaaaa
+taagtgatcaatggactaacattgaaatgttagtattgtcgaccattgagggctggtaaa
+tcttatttacgggcgtgggaaaacgaacgtgatatggtttagcatgggatgcaagcactc
+gttaatgcttactttagttggttgcgggaacaacaggaggctatactaactggtagcgtt
+cttgcttccattatgttattattataattaaaaataagacatatggtagagttgtagtca
+gggtggatcgggttgtctataacgttggaataatcaaaactatcgttaacaaaaacgaaa
+tttaagtcggtgcggtggaatgcgcctacctcatgtgcaccacacattcacagcacaccc
+ctcattataggcaaggaagcaaacaaaaaaaagttaatcgaccgtatccgaccttaaatt
+ttaaaataaatagaaacacttagcggtaatgaaaagataggactaaaattcactagtatc
+ctggaacgaggcaacagagttatctagatggtaacgaggtgctgcatcaagatgtatgat
+ttttggtccgctgtgtggaatacctctattgatatacaagtgactttctcggtaataacg
+cacttcacaatgtgttgtttcttttctatgtattttgcaagagaaagaagcttagtatag
+gtacacctcagagatgtttcgtgtaaatcgtatcacatggtataactgcaggaggaacat
+tatccaaattcaccacaattactaatccacccttttacttttactaaagatatattaatt
+ctcatgttgtctgaattgtataacccggtaccctgggagcgtatcgaaggataccaattg
+aagtcctcgaggcatgttacaacacacgacttccttccgtctattcagacactcaacgag
+actaacttttcctaggtaatcaatgatattgggtaactcgtggcatcttatagttattga
+tccggctcttttgtagatcctgtgcgactcgtgcgctaattaagactggctctcttgcgc
+aggggatacgtttattctacgtacccgatttggttactactaagcggcctttcttcaaac
+ttgcagttgtgacttacattcctatttcttcaaagcagggaagggttacagggagagact
+tattgagatacgattggaatttccatgtacaatcgttaatacgcttgtagaccagcaact
+cagtatagagatccgtttcctaaagggtgagcggtaggggcaaggcaataagaaattact
+aaaaccctagttgttaatataagaacgattcgaaacaataggattgcccaagggggtgcg
+aacatggtgtaaatcaaagagaaataggcattgttaaaacccgcacgtttctagtacgca
+agaggaacgtcggtaaccagttctcaaagatcctaacctaaaaggggcttattctacttt
+ttccgacactcaatggacgagacaaacatgaacggatagctttaggtctcgttgaatgca
+aagaatagaatcgttattattaatcggtttccattatctatatgcggtatagatctccga
+gaggaccctgtaaactagctctgcggtttaactggtgctaatagaccgccactatgttat
+tgcttctagctcctagcgtcttatcatgttatacattaatgtcgcatattggacagtagc
+caggcttggatggatcgccgacaaaaagaaaagactttccctgtaaggacttaactatta
+catataacttggatcattaatctgcaaattagagtaacggtctttcaccagcttcatatt
+ccaacgtggcgctagtcgatatcccatgaagtttaaaactagaattggcagtctcacttc
+acagtgcgtatctatacgacaaaagtggtcgatttgcataaatatcttatcgatattcag
+gttattaccgattccttgctaacgctagaagtcacaccagagtaataataattccagaca
+cctgtgaaataatcggtcactacggatagactagtaacgataatacgtatagtccataaa
+agttgaattttaggggctaaagatattagcaatactggtctagcctaatcgtcgatagca
+aagggctgtgaggatttctcctacattttcgaccaattgtatcgataggaatagttacag
+tcacgcttgtagatgtaagagatgacgttattcttagggttcttaagtcggggggtaatt
+taagaccactagtaaaggtagaggcgtacacagtaaacgatattttgaaatcgtcaaaaa
+aaagtttacaacatcctttaagttagcaactgattttagtggcaaccttaacggttgaat
+tgatctactaatacaggcctacaccgaagggtacagataatgattcttactaccctaaca
+tgatagagtcctgtcctatctcataggtcgacattttaaattcgtaatgagcaacgaaga
+tcgtttcccaatttgcaacattcacttatagacttcaggttatttcgtgctaacattaag
+atagaatataatcagtcgttaagaaactattatccagctttcgtcaaccataaagattaa
+aaactgaaacttggcaagatatgaatagctatcctgctttaaccgatcgtatgagatgct
+ttgtagcaagaaaagtgactagcacttgtgtttagtaaagcgggagagtgcggtaattaa
+tattaatatactattaagctacacagcaaaggctgcaataatgttagtaagtagaacata
+aaggtattctccacaagtaataaatagtgtgagctaattgactaacttaactctcgcgac
+aagtgatgtggataagatgactcatatcgtctttttctgtagtgccgacatcccacctgg
+atcgaacaattccttctagttatcgactttgattacctatcctattaaacagatagggtt
+gtaaagtcagaaaatgatcggcttgcgttggtctaccatagctagagttagaacgcgtag
+atagaggccttttgttgccaacgtgggggtgggatgagtctgggcgagcgtgactttctt
+tcgtgtccgaatttgtttaacatccattagattagatgtttgtgttttgggtctgatgtc
+ctaactactttctcagtgaaactaatgtcatcatccaagtaaaatagtccgatgaagtct
+ccgttttcggccgaagcttgtctataacgtatataaagtcgctgaatttagaacacacct
+tatctatgttgtaaagttactttattccaaaggacgtgcacgaagcgtgagtgtgggaag
+gaacttaaagtcggatcactcttgtcagtgtagataagaatttctttcatacttcactgg
+aatccggcgtatggatatctctaccgcgtcatctggtggtgtctgcggtaaaaagtcttg
+ctgcacgagtctgagaaatttttggtgccatcacatcgtaactgtacaacgaacaaatag
+catcaggccttcttatccagcgtgaagtctaattatttcacaagctttcctaagtatgta
+aatccctcacttaatgatgcttgcgccaatgaggatagaggacattgcatgtacgtagga
+ctattctccaaggggtcttctattttgttagcgaaaattgttacagcctaatgttagagc
+ggcgtacgactttataccagatactttcattagatatgcaaatatccaattaaatcatag
+tagtatcgtggtatggacaatcaaaaaagacccgttgtgatatgatgtttttctagttcg
+ttctcatatatatagatcaacaatgaataatctcatgatctataaccgatgtatatttat
+attccggttgactgctccggtgcaattcactacggacactaatgactaatatggcgcctt
+tcatcagaaacgctaaatatgattaatgaattaagggagtattatctaattattagagag
+tagcagttagtctgatattttcggtgtatgtgttagccgttataatgctgtctttttatc
+agtgagaacagggagtgtgtagtgttgtatgcttcactttatgactctggttatatccct
+cggagaacaagaataagagtacgagaagttcggtcattgaggatgaaatagaaccgctag
+acgaatggactcacgtttataaaactatgtatcacagtactacagctaactctgaagtcc
+gagaagcttttgtaggacaaaacgttataagtacctttcgcagaatacggccgtgcatac
+ctgttataaggcgtagtagggacaccatgctatccctcatatagagctacactaatacca
+ttacatggtgactatcgtttacggccatcatctgtaagcgatcatgcctcgttagcatcc
+gtacaatctcgcatggcgtcactgcagaaaaaccccgtgcggattttgagtcagaactat
+tcgaagcttctcaatccttttccattatggcatagcaagtgacgactcgtcagccatggg
+aataatagcactaatccgattacttatgaattagaacccacatgaatgtgattctgcgaa
+ttgtctaagaatctaatgattttccggtgaatatggttgttgttatttattgaacttata
+ttattaacatcacccttcgttagtgatagtcagctatttccaagaggttccccgagcatt
+tttaccattctctagtcatacaagttggagcgcttttaaatctttaggctgatcaaggcg
+ttttgtctagaattctgcagatgttagattcgtgtgcaatccctcttgcatgtcagtaac
+aggtcacccgtttttcgttacatatgctggtaaaatattcatagtaataactacaatact
+tgatttgttacgtaatgctcgtacataacacaatcgtattccacggaacagtaaagctct
+attattctgatcgagcctaagagaggatcacactacgctattaaagtcacgttcacgaaa
+tctcaaacctcaactgctggtgaccagttatagacagtgtaattccatattacatgtcag
+gcttaagctaacccgagcctttatataagctataatcaagaattagattggagtgcattt
+tagacttatctatcgaaatagtgatagtaagagtttatatgacctgatctagactgatgt
+tctcttccacaacagccttaaggcgtggagcctttcttatactattaggtcgcgtcgaga
+gccctattcgtaatgttaacgacactagactaatatacaatgagctaagaataacacaag
+tcacaagataatttacaaatcatatatctacagtccacaaccatcactagcgattgcaaa
+gcgttattggtactaccgctctaaatcggtatgtgcaagacgcgttaactggttcaagcc
+tctcctgctcgtgagactgaaagaaatcgaaaatatggatgtgcctaattgttcttgtga
+gtcatgtgcaactatacagtttagtttggtcaagactatgcaactattaacagcatgtgc
+gcattgaatatttggtgtcgattgataaatgccccaacgttccatcacgtctataagccg
+tgttactaatgtgtattagtgcatacctattcagaccatagttcaactgttggactgaag
+gcccgtcttggggttcgtgaatgagagtgcagtttcttgtcttttccttaactgacctaa
+atgaaggcaatcggtttatctagagtcatgcttaaggtgaatttcagccaatgggctccc
+attgagctagtatggtgctttacctttgtaagtggtggctttccttggtgtgctgacttt
+aacacggcagagtgattatccgaagaatggataataagacgctggcaatattggctaata
+aagtccgatgagtttcaatcatgactgcgaggagatccatgcggtgtacctaaacctaca
+tcgtatgtatttgctgacgttcattcttgatacataaagatccgatatcggtccactttg
+tttaccaaaagccctaccttcgtaacgatggaaatgtgaatgagagtgaaatacacgatg
+gggatattgccggtgagtacaagttagaccacacattagaactgacctatattcgtcatc
+atagagatggagtatgaattgattctgcgaagtacactggctttacgagtatctagacgc
+cgcggtatatctcccgtcaatactatgaaggtatatatatagaggctgaaaattcatgtt
+caatcctctttctaagagtgagtgggagccccttctgttgtcggagtaaaaaggcattat
+tcctcaaattgtcagaagcaaagtatacgtgatgtttgcttagaacaaaagagttacctt
+agggtaggtaaatctcgattcaccgagagaagtgattttggcggtgtgcgattaattctt
+ttgatgacagatctcattattttatatagctccctctttgtatttagagtttgcgtaggt
+aacctggcaaaaccatatcccggggggagagtgcgctgaacattttatacgatgtgatta
+ctcaaaggataaggttcgaggcctctatactcatggaactatcttataattataatggat
+cgtggctcattccacctatccaaacttctttgtgatctgatgctacgagtgtgaacaaac
+gtacatcttctaaggaatttgggacgtttcatagctcgcatttcattcctgaaaacttaa
+atatttttaaaaattgattctactgcgaggaactaaggtgtagacaagcccttagtaacc
+ggtggatgtcgcttcagttttatagcaaacattattcaatttcagtcttgactgaaatta
+gtttgttagtgttagaggtccatatgtcacatgcatatggtctagatgccattgtacagt
+aataccttagattagtattagcggcatgcgtacttggatttcacttgtaagaatgagctt
+aggacggtcgcctgtagggctgcaaataggaatacttacaatttttgatgacttgttagc
+atatcgctatcacccataaaaaacctgatacttgatgagcgggtgattgagactatgtac
+tgatataattcaatagctccaatagatgaaacagctatgcgcctatttatgtcaaataat
+cgatgtgatacaagcttagagctgaacgagcgcgagtggaattagcggtgatctctatcc
+taaaaagccacgaaatcgatcccagaagctaatacccgaggtgtcaagcttgagttcagt
+taaatttgcatctcatgccccacgaagaatgggtagagagtttgaaggtgcttctggatt
+ttcctaagtacgtggtaaaaatttgatgtaaatgaacacctcctaatggttgtgttaacc
+acaaacccctgggtgaatctgattagccaacccagtgatctgatttcagttgtcaaatct
+cttttttataactaccttttgtttccataatttaaccggatctcataatgaacaaacggg
+tagaataatggtagcacatagcgagcttgtctattcagaaatatggcctactcagaatgt
+attctccaaatcagtgttatgcgaaacgtaattttacgtgtaataatgatgatttcttat
+cggttccttgtactacaatactcttgcccaacaaatactaagcataacagcaaaattcga
+atccccctccttttaataaatggtttttcaatatagccgattcgtattcgttagtctttc
+accaactattaacctggcatctaattaataaaatcaccaaaggactctataatatgacag
+tcacttcggcctcttttaagacagttgattattgcaggtccgcaattgatggtgacatgc
+acaattagttagaatccgactatggagacaattaacaattgtagtgcccatttggtccag
+ttgacttcaaccacgagttataaaggtattttaatttatagtcgatagtaccaacaacaa
+gcacaatcataattatgttagaaaacccagggggtaatgctctaaatccagctttaaggc
+cagagtgcactatgaaatcgccattgatcattgtgtcattcgctgaacttggtgtctagg
+aggtgccgagtgagaatatcagataccttatgaagcaacgattatatctggactagatca
+tgatgatcggaataaaacattgaaataagtccttatcaaggagcataaacattttattta
+atttatacttcgtaaataaattcagaattttttttcaagacattaatctgagtaaatgac
+ggctagaaagggttcctactcgaatcgtagcctacgcatgtgggcagtaacctggcttgc
+gtttttactgaaacaaaggttcaccggaaagaaggctgccacttttagcttcttgacgat
+ctttagcgtcatatttttagattagtcgaaaaacggaaaacaaacttaacgaagctggtt
+gcacggggtaccgagaaaccaaagagcaggacaactccttgatcgggaagaactgaaata
+gacagctgtcattttcattggtcaacttatcaatataacgaccaccgtagtgacgcttgc
+atgaaaatactgaggatgtaaactatagccagtcaggcccgcgtgttgactaattgatga
+agcaaacaaaatagccggtattcgttaaaaggaacgggttgccagctacagatatactct
+aggtatatcccaaacaagagacgtcctttggctgttgtaatcggtcataatacttgtcac
+ataaacaagatcgctgaattaaacattaaacagttagtgatacacaatcgtggttggggc
+tgggatgtgcaataaaaagtcatctatcgtctatcacagagcgacgtaaatttagacaaa
+cattattatttcttgacaatggaatcgataagcgttcctctaacttggtatatatatctc
+gaccccgggattccagccattcttgtatgaagatttaaccatttaactatgcatagttga
+atggtaaggaaaatgatattgactgcaacagattttggatgcaaaaatatttgtgaatta
+ttggttatatactggttgtatagcacaatcattaggtcctagaaggcatactcaacctca
+gcgagagagctagcatgcataattgtaccgcccatattaatattcctgaaatgatttctt
+acattacgcccaatttcagtcatcgaacacccccatcaatttacccgatagagaacgtga
+tcatacgcaataccctatgcgaacgtccactctatagcgtctgtatacaatgattattcg
+ttccatttacaacgttaagtaatttaaacttacataaggacaaggaaatccgcgaacctc
+ctggaatgtatgagttatttatgcagttaacttcgtctcgaccggaactaaaggcgtcgt
+acgaatgaaaggccacttttagaagagacctttgtatccattgtggagaatatcataaat
+tcaagatggggtgtcatgctattcggtcctaaacattcttaatggctgttctattgttag
+tctgatttaaaatggaaccatagcacgaatagttagatagggctcatacccctgtaacga
+tctacaaatccttccccgggtgtgtgcgttagcgacggaaagttttacggtttgtgatca
+aagaacactcacacgtcagattattacactgatacgaattatttcagtcgacagtaattg
+aatagaaacttattaacgccagcacctgacacggtaagtaaggcaggtctgaactgtttg
+actgtaaaaaaatggtaatatttttaaaaatcttgatttctatatcaaatgatgtgtagt
+tttttctctgttattaaaatcccagtgcgcgaaatttagatcgttacgactcacgtacaa
+gatcacacatcacacgcgttagcgaaagcggaatggctaatacagccctacgcaacgtag
+tgggatcaacatatggacgaatttatgctcaatgagccaacctcccccgcattgcggttc
+attttaaggcctgggtaacatctatcgtttagataatcaaaggaatccgactatgcaatt
+gtctgacttcatccgctctcaagtccaatgcaggcgctacgtgtttctttaatcaatacc
+atattgaaatcgtaatacgataattgttgctattgactacaggttatgaaaaaacttact
+ttgcgggtacatgcatatttttgtaccacattattacgcgatatctctcagtgtactcta
+aattaaaccctcttcgaacattttagttcctattcgtaaacacgtgctacgcggcaattt
+gccggtcgtagaatggacaactccagttcaactgcatgtaactcatagctcgcgttagta
+taaattgactagtagccatgggacaaagtaactagtcagcggaaaagatccctttaaaga
+tatatgcaggttgcaagcataaagctcattgctcgaggtgcaccgtggtattccaaaagc
+gtctctatcgtatcttctaattttgggccgtgagaatcgaaactactctgatttgctgca
+cacgttaggtaatatcgcccattttcccgtataagctccgtacttatacgaactacacga
+ccttttaagcattagccgctcatatcgtgattcgtgtacagatgagtctattaaaattac
+agacatactccatatctcgctccttgaactttgaataatgcgctaacttgtactatgaat
+aggcagaacccaactttcccgtttgcgtcaagcggggaaacgatacatgttgtcagattt
+atgattatctagttttagatcacgtttaccgataatcggctgtggtctgagcagtcctac
+actgagtatttacttcagcttcatatcggtccgaaaaaaggttgtgaccgaatgtcaaaa
+tacggagtacgatgggcatcttttttcgagtcgcggttgcagggcagcaaaaggcttaaa
+ccatttttacgatttttactatagcggtcatgaagtgcgaaactgcttgcaaattttcta
+cacacattgtggctcttgtccttgaagcttatggcgaaaatttgaaacatagtataccag
+ggaaagcgcgaattatttggtgactaatagtccgtgggtttgagccatatacctaacgcc
+ataaactacgtggtgctttagatgcaatctaaacagaacagaaagcgtagcgctcatcag
+cacagactaactttttcagtttgagtcgccggagggacttcgagacaagaacgcgtcaag
+tcgcttgcgcggcacggattcgattgggcggctcaatcttgcctaatttctactattgtc
+agctgtacgactgtactaagtgtatagccccaaataaaagaagtatcgatgcgtctttat
+gaccaaaggtcttataattgaagcgcacttccgttcatcaaattaaatcctggcttaccc
+gattctccggaagtctgacctagagattgacgacggccgcgtattattgagacctcttca
+ggattaatcaataacgaagtagttgatctgtttggcgacgtaccttaagccgactccgct
+acacgagtttctactaaaccaatgtagccttatgcttagatgaataccgtcctaattaga
+tattccggcataacagcagtaaattatctgttcaatggacgaacattgaattgttagtat
+tctacacaagtcaggcctcgtaaatattaggtaaggccgtgggataacctacgtgatatg
+cttgagcttgcgttgcaagctctcgttaatcattaatttaggtgcgtgagggttaaacac
+cagcatattctatatgctagacgtcttccttaaaggatcgtagtattataattaataata
+agaaatatggttgacgtctagtcagcgggcatacgctgctctatatactggcattattca
+aaacttgacggtaaaaaaacgaattttaaggcgctcacgtcgaatgagccgaactcatgg
+gaaccaaaatgtcacagaaaacacctctttattgccaagcatgcaataaaaaaaatgtta
+atagtacgtttacgacattttattttataataaagagaaactattacacctattgatatg
+ataggacgtaaattaacgagtagcctgcatagaggcaaatgaggtttctacatggtatag
+acctgatgctgaaacatcgatgagttttggtcccctcgctcgttgaaatctagtcattta
+ctactgtctttcgagctattataccacttcactatgtggtgtttctttgctatgtatggg
+gctagtcaaacatgatgactatagctacaactcagagagcgggcgtgttaagagtatctc
+atgctagaactgcacgacgaacttgatacaaagtaacaacatttacgattccacaaggtg
+actttgaagaaacatagtttaattctctgcttcgatcatttctataaaccggtaccatcg
+cagcggatagatgcataacatttctactactccaggcatcttaaaacacacgtagtactt
+cactagattaagacacgataagtgtataacttggcagtgggaagcaaggagattggcgaa
+ctcctggcatctgttacgttttgttcaggctcggttgttgataatgtccgactcctgcca
+tattgaagactcgctcgagggagatcgggattcgttgattataagtacacgtgttccgta
+atactatgaggcagtgattcaaaatggcacttctgacttacatgactaggtattattacc
+acggaagcgttaaaggcacactcttatggacttaagattgcaagtgccttcttctagcct
+gaattcgcgggttcaacacaaactctctttagacatccgttgcctaaaggctgagacgta
+ggggcaaccctttaactatgtactaaaaaactagttggtaatttaacaacgtgtccaatc
+aagacgatgcaccaacgcggtgcgaaaatcgggttaagcaaacacaaataggaattgtga
+taaaccccaccttgagaggtcgcaagaccaacctcgggaacaacggctctaagagaataa
+cctaaatccggatgagtagactgtgtaactctctaaagggaagtgaaaaaaagctaagca
+tacatttaggtctcctgcattgcattcaattgaatcgtttgtattatgagctgtacagta
+gctatatcagctatagttatcccagaggaacaggtaaactagctctgagcgtgaaatccg
+gatattagaacccctagatgggattgattctagctaatacaggcttatctggttttacag
+ttatctagatgattggtaaggtgaaacgcttggtgccttccaccacttaaacaaaagtat
+tgcccgggaagctattttctaggtattataaagtcgagcattaatatcaatttgacagta
+aaggtctttcaccagcttcatatgccatagggcccatactcgatttaaattgaacggttt
+aacgagtattggaactctcacttataactgagtagctatacgaaaaatctggtccatttc
+cagaaatttattatcgatttgctgcttagtacccaggaagtgataacccttgaaggcaca
+acactgtaataagttttcctgtcacatctgtaatattcggtcactacgcattcacgacta
+aagataattactatactaattaaaagttcaatgttagggccgaatcatagtagaaattct
+cgtctagcctaatcggacttacctatgggctgtgaggatttatcagtatgtggacaaaaa
+tgctagagataggtatagttaaagtcaccatggtacatctatgtgaggaagtttgtagtt
+cgcttctttagtccgggcgtttgggatgacaactactatacgtagagccgtactcaggat
+tagatagtgtgaaagagtcaaataaaagggttaatattaatttaacgttgcaaatgtgtt
+taggccaaacattaaccgttgtagggatattctaatacaggccttcaccgaaccctaatg
+ataatctgtcttaataacattaaatgattgtctccgctacgagctcttagggcctcattt
+taaatgactaatgtccaaagaagagactttcccaatttcaatctgtcacgtatagacggc
+accttagtgagtcatatcattaagatagaagattatcaggagggaagtttctattatcaa
+ccgttacgcaaccataaacttttaaatctcataatggcattgagatcaagagctttcatg
+atggtaaagttcgtatgtgatgctggggagctagatatcggtataccacttcggttgtgg
+taagcccgagtgggccgttagtaatattaatagacgattatccgacaatgcattcgctga
+aataatcttacttaggagaaattaatgctatgagccaaaactatttatgtctgtcacatt
+attgactaaagtatctatcgacaaaactgatgtccataagttgtagcagatagtcggtgt
+atggtgtcaccaatgaaaacctcgagcgaaaaatgaattatagttatccaatttgagtaa
+attgcctattatacagataggcttgtttagtcagataaggttccgcttgaggtgctctaa
+cttagcgagagttagaaagcctagtgagaggcattttggtgccaaactccggctcgcatg
+agtaggccagagagtcactttctttcgtcgaagaagttggtgaacagccttttgattagt
+tgtttgtcttgtggctatgtgctactatataagttagaacgcaaactaatctaatcagca
+aagtaaaataggaccttgaacgagacggggtacgccgttgaggctcgagatagtagataa
+actagaggaatgtagataaaacattagctagggggtttagttactggattacataggaag
+tgcaccatcacggtgtgggggttcgtacgtaaagtcgcatcaatattgtcagtggactta
+acaagttcgtgcataatgaaatcctatacggactttgcatatctctaccgactcatctgg
+tcgtctatgcgggtaattgtattgctccaagtggatgactattttggcgtcccagcacat
+agtaaatgtaaatccttataatagcataagcaattattagactgcgtgaagtcttagtag
+ttctcaagctttacgttgtatgtaaataactcacgtaatcagccgtccccaaatcaccat
+tgaggtcattgaatgtacggagcactattatcaatgcggtatgcgattttctgagcgatt
+attgttaaagacttagcgttgagccccggaacacttgattacagattctttaaggagtta
+tccaaatatcattttaaataatagtagtatcgtgctttggacaataaaaaaagacccgtt
+ctcttatgttgttttgcgacgtacttctctgatatatacttcaactatgaagattctatt
+catcgataacccaggtatatttatatgcccgttcactgcgcagggcaaattatctacgga
+caataatgacgtagttggacccggtaagaactaacgcttaatatgattaaggatgtatgc
+cagtattatcttattatgtcagagtagaagtttctctgagattttccgtcgttgtggtac
+accggatttggctctctttttagaactgagaactcggagtgtgtagtcttgtttccttca
+atttatcaatatgcttttataccgccctcatcaactataacaggacgacaagttccgtct
+tgctccatcatatactaccgatacaccaatcgtatcaagtttagtatacttgctttctct
+cttctacagcttactcgcttgtccgagaagcggttggtgctcataaagttagtagtaaat
+gtacaactagtagccagtccttacctgtttttacgactactacggacaccatgagataca
+gaagttagtgctacaattataccattacatgctcaatatcgttgtcggccataagatcga
+agagtgcatcacgcgtgtgaatacgtaaaatctaccatcccgtcaatgcacaaaaacaca
+ctccccttgttgactaacatcttttacaagaggctaaatcattgtccaggatcgaatacc
+ttgtgtacaatcgtcacccatcggaagaataccacttttccgatgtagtatgatttacaa
+aaaacatctatgtgagtaggccaattgtagtagaatatattcatttgaccgtcattagcc
+ttcttcttaggttgtgtacggatagtaggtacataaaccgtcgtgtggcatacgctgcga
+tttcatacagctgccaacaccttttttaccaggctagagtcagaaaagttggagccatgt
+taaatagttaccatcataaaccactgttgtctactagtctgatcagctttcatgcctgtg
+caagcaatatggattctcacgtaatggtaacaactgttgcgttacttaggctggttaatt
+tgtcagagtaataaatacatgtcttgttgtgtttcctaatcctcggaaagtacacaagcc
+taggaataggaaaagtaaagctcttttattctgatagtgactaactcaggatctaaatac
+gcgattatactaaccttcaccaaagctcaaaaatcatctgctggtgaccagttatagaca
+gggtaattcaatatttaatgtctcccttaacatttcaccagcatggattgaagatagtat
+aaagttttacatggcagtcattgtgtcacggttctatacaaattctgatagttagacggt
+atttgaaatgtgcttctagcatggtatcttacacaactgaatgaacgactggagccgttc
+gtatactatttgcgagcctcgagaccccgtttcctaatgttaacgaatatagtataatat
+aaattgtgatatgaataacacaagtaactacagtttggacaattaattgttctaaactaa
+aaatcattcacttcagatggcatagagttatggctactacacatataaagcggtatgtga
+aacacccgttttagccggaaaccctctactgctcgggacaatgaatgatttccaaaatat
+ggatgtgcagaattgttagtgtgactcaggtccaaatagacactttagtttcgtcaagtc
+gttgcaaagtttaaaaccatcgcagcattctttatttggtctacattgagaaatgaaaaa
+acgtgacagaaagtctagaagaactgtgaataatgtctattactgattaactagtaagac
+attagtgcatctggtccactgaagcacccgcttggcgttaggcaatctctgtgaactgtc
+gtggctgttccggtaatgtacgaaagcaagcctataggttgatcgagtcgcttcattaag
+gtcaatttcacaatatccgatcacattgtgctaggttcgtcctttaccttgcttagtgct
+gcatgtacggggtgtcatgacttgttatcggcagactctttatcccaagaatggataata
+tgtacatggaaagtgtccataattaagtcccttcactgtaaagaatgactgccacgtgat
+ccatgaggtctacagaaaccgacttacttgctttttgatcaacttaattatggattcata
+aagttcagatatcggtacaattggtgtacaatatgaaattaatgaggaaacatggaaatc
+tgaatgacagtgatagaaaagatccccatttgcccggtcagttcatgttacaccactcat
+tagtactgtaagtgtttcgtcagcattgagatccacgatcatgtgtttatgccttcgaaa
+ctggatgtacgacgatcgagacgaagaggtatatataacctaaatactaggtacgttgtt
+agagagacgatgaaaattaatcgtcaatacgctggcgaacactgagggggacccaatgct
+cttctcggtctaaaaaggaatgtgtcagaaattggtcagttcaaaagtagaccggatctt
+tgcggagaacaattcacggaacgtagcgttgggaaatatcctttctaccacacatcggat
+tttcgccctctcccattatttattgtgttctcacatagaattattgtttagacatccctc
+gttgtatggagagttgcccgagcgtaaaggcataatccatataccgccgggtgagtgacc
+tgaaattgtttttagttgggatttcgctatggattagcttacacgaagagattctaatgg
+tactataggataattataatgctgcgtggcgcagtacaccgttacaaacgtcgttcgcat
+atgtggctaacacggtgaaaatacctacatcgtatttgcaatttcggtcgtttcatagag
+cgcattgaattactcaaaaattatatatgttgattatttgattagactgcgtggaaagaa
+ggggtactcaagccatttgtaaaagctgcatctcgcttaagtttgagagcttacattagt
+ctatttcagtcttctaggaaatgtctgtgtgagtggttgtcgtccataggtcactggcat
+atgcgattcatgacatgctaaactaagaaagtagattactattaccggcatgcctaatgc
+gattgcactgctatgaaggtgcggacgtcgcgcccatgtagccctgataataccaatact
+tacatttggtcagcaattctgacattatacctagcacccataaatttactcagacttgag
+gacaggctcttggagtcgatcttctgtttgtatgcatgtgatcatatagatgaataagcg
+atgcgactagttagggcatagtatagatctgtgtatacagttcagctgaacgtccgcgag
+tggaagtacagctgagatctatcctaaaatgcaaccatatcgttcacacatgatatgaac
+ccagggggaaacattgagttcagttaaattggcagcgaatcccccaagaagaaggcggag
+tgacgttgaacgggcttatggtttttcagtacttcctccgtataagttgagcgaaatgta
+aacagaataatcgttgtgttaacaacattaaaatcgcggaatatgatgagaatacacagt
+gtgagcatttcacttgtaaaatatctttggtagaacttactttgctttaaatatgttaaa
+ccgatctaataatctacaaaacggtagattttgcctagcacattgcgtccttctctattc
+agatagaggcaatactcagaaggttttatccaaagcactgtgttgactaacctaagtttt
+agtctaataatcatgattgattataggtgccgtggactacatgactcgtccacaaataat
+acttagcagatcagcaattggccaagcacccgacttttatttaatggttgtgcaatagtc
+cagattcgtattcgggactctttcaaataatagtttcctggcatctaagtaagaaaagct
+cataaggaagcgatattatgacacgctcttccgccgctgttttgaaacttgagtattgct
+cgtccgaaattgagggtcacttcaaaatttactgagaagacgaagatcgactaaagttaa
+aatgctagtccacagttggtcaagttgaattcatccacgagttatatagctattttaatt
+tatagtcgagtgtacaaaaaacatccacaataagatttatcttagaataacaacccccgt
+atcatcgaaatcctccgttatggcctgactcctcgagcttatagcatttgtgctggcgct
+cttgccaggaacttgctcgcgaggtggtgacgagtgagatgatcagtttcattatgatga
+tacgattttatcgcgactagttaatcatcatagcaagtaaaatttgaattatgtcattat
+catgctccattaacaggttatttaattgatactgacgaaattttttcacaatgggttttc
+tagaatttaatatcagtaattgaagccttcataggggtcctactagtatcctacacgacg
+caggtccgcagtatcctggagggacgtgttactgattaaaagggtcaaaggaatgaaggc
+tcacaatgttacctgcttcaccatagtgagccgatgagttttacattagtactaaatccc
+aaatcatactttacgatgaggcttgctagcgctaaagagaatacatacaccaccacatag
+aattgttagcgatgatatcaaatagactcctggaagtgtcagggggaaactgttcaatat
+ttcgtccacaggactgaccaggcatggaaaagactgacgttggaaactataccatctcac
+gcccgacgcttcactaattgatgatccaaaaaatatagcccggattcctgattagcaaag
+ggttcacagagaaagatattatcgacgtatatcccaaaaaacagacgtaatgtgcatctt
+cgaatcgggatgaatacttgtatcataaaaatgtgacctctagtatacaggttaatgtta
+gtgatacacaatactcgtgggccatgggttctcaaataaaatgtaatattgcgtcgatca
+ctcacccacgtatttggtctaattatgttttatttagtgacaatccaatagataaccggt
+cctattaagggctatatttttagcgaccacgcgtttaaacaaaggattgtatgtagatgg
+taccagtttaattgccagtgggcaatcctaagcaaaatgagattctatcctaaagtttgg
+gcttgatataagatttcggatgtatgggttttataatcgttggagagctcaatcatgagc
+taatacatggatttcgctacctcaccgagagaccttgcatgaagaattctaaccaaaagt
+ttaataggccggattggattgagttaattaagaccttgttcagtcatagtaaaaaccctt
+aaattttaccgattgacaaagtgagcagtcgcaataccctatgcgaaacgcctcgatagt
+gactaggtatacaaggtttttgagttcctttgaaatagttaactaatttaaaattaatta
+acgacatggaaatcacagaacctaatgctttgtaggagttatttatgctgtttactgcct
+ctacaaccctaataaagcagtcctaagaatgaaacgcatcttttagttcagaaagtggta
+tccagggtggtcaatttaataaattcaacatcgggtctcaggatattcggtcatataatt
+tattaagggctcttcgagtcttactctgagtgaaattggaaacagtcatccttttcgttg
+tgaggcatcttacaccgctatcgatatacaatgcattccaccgcggtgtcccgtacacaa
+ggaaacttgttaccttggggatataagaaaactcacacgtctcattattaaactgagtac
+aatttttgcacgagaaagtaatgcaatacaatatgatgaaagccagctaatgaaaaggga
+tggaacgcacctcggatctgttgcactggattaaaatccgattatttttaaaaatattca
+gtgctagagcatatcaggtctacttttttatctggtatgtaaagcccacggagcgatagt
+gagatccttacgactcaacgaaaagttataacataactcccgttagccaaagcccaatcc
+cgattactgccctaccctaacgtctgccatctaaatatcgaacttgttatgatcaatgtg
+actacctcccaccctttccccttcatttgttccactggggataagctagcgttttcagaa
+tcaatgcaataagaatagccaattgtctcacttcatcagagctcttggcaattccaggcg
+ctacgtggttctggaatatattcatttttcaaatagtaatacgtttagtgttgctattgt
+ctacacgtttggatattacgttatgtgagcggacatcaatagttgtctaactctttagta
+agccagagatagcactcttagcgaatggataccatcttccataagtttagttaatagtcc
+gaaacaactgcttcgagcatatttgaacctccttgtaggcaaatagcctcttcaaagcaa
+tcttactaatagatagagtttgttttaagggactactagaaatgggacaatcttaatagt
+atgacctaaactgacatttaaagatatatccaggtggcaagcataaagatcattgcgcca
+cctccaccgtgggattacttatcagtcgatatcctatatgctaagtttgcgacggcagaa
+tacaaactaagctgagttgatgctaaccttacctatgataccccattggaccggttaaca
+gccctacttattccaaataaaagaacttttatgctgtagaagctattatagtgatgcctg
+gtaacttcagtatattaaaatgacacacatacgccatatagagctcctggaactttgaat
+aatgagcgaacttcgaagttgaagagcaagaaaccatatgtcacggttgcctaaagcccg
+gtaaccagacatgtgctatcattgatcattatcgaggttttcataaccttgacccattat
+cggctgtgcgcggacaagtacttaaatcactagtttcttcacctgcttatcggtaagaaa
+taaggttggcaaagaatcgcataagacggacgtagagccgcagcgttgtgcgagtccagg
+tgcatgcgcagcaataggattttaaattttgttccatttttaatttagccgtaaggatgt
+ccgtaaatgattgaaaattggattcaatctttgggcctatgctactggaacctgatcgac
+aaaatttcaaacatacgttaactccgaaagaccgtatttttgcggctagaatagtcagtc
+gcttggagccatataccttaccacttaaacgacgtgctcctgtagttgaaatataaacag
+aacacaaagactaccgatcatatcaactgaagatctttgtaactttgaggcgaagcaccc
+tcttcgagacaactaagagtaaagtaccgggcgccgcaaggagtcgattgggaccctaaa
+tcttgacgaattgctaagaggctcagagctaccactgtaatttctctagagcccataata
+aatgaacgatacatccgtaggtagcacctaagggattataatggaagccaaatgcagtta
+ataatattatatactggcgtacacgattcgacggatctctcacatagtgattcacgaccc
+ccccctttgattgacacagcgtcagcattttgcaagaacgatcttctgcatagggtgcgc
+caccgtaaggatgacgtcgaagctacaactgggtataatttaccatgcttccctgatgct
+gagtgcaatacactaagaatgagtttttaccccatatcaccagtatttgttctgttattg
+cgaagaaatggctatgctgagttggcgactaaagtcacccatcctttttattaggtaacc
+ccctcccttaaactaactgatttgctggagctgccctgcatacatatactttatcattta
+tggacgtccgtgacgcttattatccaccatagtcgatatgctacacggattcattaatgg
+atcgtaggagtttaagttatatttactaagatcggtctcggctactatcccgccttaccc
+ggcgctatttacggccatttttaatatattgacggtaattattcctatggtttcgaccgc
+acgtccttggacaagaaagaatggcaaaaaaaatgtaaaagaaaaaaaatattgagtccc
+taccatcatataaaaaatatgtgatgagtaacttgacgaaatgttagtggttattaaaga
+ctatctattacaccttttgttttctgtcgtagtatattaaagtctagaagccttacagga
+aaatcagggttatacagccgatactccgcagcatgaatcatcgaggaggtgtcctaccat
+cgcgccttgtaatcttgtctgtgtatactgtatttagaccttttatacaaagtaaatatc
+tcggctttatgtgattgggaggggcctactcaaacatgatgacttgacctaataatcact
+gtgcgggcgtcttatgactagctattccttgaaatccaccaccaaatggttaatatgtaa
+aaactttgacgatgaaacaaggtgaatgtgtagttactttgtgtaattagctgcgtcgag
+cattgcttgtaaaaccgtcaatcgcacacgttacttccataaaatttctacgaatacacc
+cttcttaaaaaaaacgtaggaattcacgagtttaacaaacgataactgtataaagtggaa
+gtccgaagaaagcagatgcccgaactactcgaagatgtttcgttttcttaaccatagggg
+cttcttaatggcccactacgcacattttgttcaagcccgagagggacatccccattacgg
+gagtattactaaaactgttccgtaatacgttcagcaagggatgaaaaaggccactgctca
+agttattgacgtgggagtattacatcggaagcctgaatcccacactatgatggtctgtac
+aggcctagggactgcgtctagacggtattaccggcttctaatcatacgatcgtgagtctt
+aacgggaagtaaggctcacacctaccccaaaccatttatctatgtaagtataaaattgtg
+cgtaagtgttcaaagtggacaataaagacgtggcaaaaacccccgcacataagccgcttt
+agatttcacaaataccaatgcggttaaaaacatccttgagtcgtacatacaccatactcg
+cgttaaacggatataacagaagataataaatccggatgtggagtcggtgtaactatagaa
+agccaagtgaaataatgcttaccagtcatttagctatacggctttcatttcatgtcaaga
+gggtggagtttgacctgtacagttgatatatcaccgatacttagaactcacctaaagcta
+aaattgctcgcagcgtgtaatccgcatattacaaacaatagatgggattcattatacata
+agacacgatgatctgctttttcaggttgcgagatgttgcctatcgtcaatcgagtcctgc
+cttacaccacttaaacaaaagtattgacagggaacctattttcgaggtattatatagtcc
+agcttgaatatcaatttgacagttaacctagtgaaaatcagtaagaggaaatacgccaca
+ttctccagtgaaattctacgggttatcgtctagtccaactatcaattataactcacgaga
+tataagtaaattctcgtacttggcctgatttttattatactttggatccttagtaaacag
+gaagggagaaaccttcaacgaaaaacactggattttgttttactctcaaagctcttatat
+gacggaaataccctgtcaagtcttaactttattactagactaatgaaatgggcttggggt
+ggccagaatcatagtacaatttagcggatacactattcggactttcctatcggctgtctg
+gttggataagtatggggactaataggctagacatacctatacttaaactatacaggcgtc
+atctatctctgcaactttggagttccctgatgttctcccgccctttgggttcacatcttc
+tataccgacacccctaataacgattagtttgtgggttagagtaaattaatacggttaata
+ttaatgtatcgttgaaaagctggtgtcgccaataaggtaaccggctaggcagagtatatg
+tcacgaagtataactaccctaatgataagctgtaggaataaaattaatgctgtctctaag
+cgaagagatatttccgactctgttttaatgacgaatctcattacttctgacttgcaaatg
+ttcaatatggcacggtttcacggcacctttgtgacgcatataatgaacttagaagattat
+aacgacggaactttatatgataatccgttacgattaaagaatctgttaaatatcataatg
+gcattcagttctagaccgtgcatcatggtaaacttactttctctgcatggcgacatacat
+ttcgctattcaaattcgcgtgtggttacacccactcgcacctttggaatattaagagaag
+atgatcagaaaatccattcgctcaatttttctgacgtacgtctaatttatcctaggagac
+aaatcgttttatgtctctcacatttttgaagaaaggttcgagagacaatactcaggtcct
+gaactgctagaagatactcggtggagcgtggcaacaatgaaaaactcgtgacataaatga
+atgatacttttccaagttcagttaagtgaatatgtttaacatacccggcttttcgatctt
+aagctgacgctggacgtgcgagtaatgtcagtctcttacatacactagtgactccaagtt
+tcgtcaaaaacgccccctcccttctcgagcccactcacgctatgtattgacgcgaacttg
+ttcgggatcagacttttcaggagttcggtcgcgtgtccctatgtgctaatatataagtta
+gatcgcattagatgctaatctgaatacttatagacgaccttcaacgagaacgggtaccac
+cttgaggctagagttaggtgtgaaacgacaggtagggacatataaaatttgagtgcggct
+ttagttaagggtttaattacctactcaaacatcacgctcgcgcccttcgtacgtaatcga
+ccatctagaggctaaggggactgtactaggtagtgattaatgatatcctagacgcacgtg
+ccttagatcttcagactctgatggtccgcgatcaccgtaattgtagtcctccaactcgat
+cactttgttggcgtcaaagaaattacgatatctaaatacttataatacaataaccaagga
+tgagaatgactcatcgcgttggagttatattgcttgaagttctatggaatgaaagcacgt
+tatctgccgtcccaatatctccagtgagctaattcattggacggtccactttgatcaatc
+cccgaggagatgttcggacactttagtctgtaacacttagcgttgagaccacgaacaatt
+gattactcagtcttgaaggtgttttccaaagttcattttaaataagactacgataggcct
+ttcctattgatataaactacccggctctgttgttcgtgtgagtcgtacttctctgtgttt
+ttctgattatagcaagattcgattcttagtgtaaacagcgatttttatttgacccgtcaa
+tgagaagcgcataggatctaagcaaaattatcaagttgtgccacaaggtaagatctttcc
+agttattgcaggtaggatgtatcccacgttgatagtatgaggtctgacgtcaactgtcta
+ggagagttgaccgcgtgcgggtacaccggatttgcatcgatgttgagaacgcagaactcc
+cactgtcgtggcggcgttcctgatatttagcaagaggcgttgataaagccctcatcatct
+agatctcgacctcatctgccctcttgctccatcattttctacacagactactttcctatc
+tacgttagtataattgctttctatcttagtatcatttagagcttctccgtcaacaggttc
+gtgctattaaagttagtacgaaagggacaacttgtagcaacgcatttaatcggttttcga
+ctacttcgcacaaaatcagataaagaagtttgtcattctattagacattgaattgcgcaa
+ttgacttgtaccacttatgatcgaacactgaatcaagactgtgattaactaaaatagaca
+agccactatatcaactaataaaaacgcccctggtggtcgaacatagttgactacaggata
+attaattggactggagccattacattctctacaatcgtatcacttcccaagtagacaact
+ttgaccttgtagtttcatgtacaaaaaaatgctttcgcaggagcacattggtagttcaat
+agtttcatgggaacctcttgagccgtcttctgtgggtgtgttcggatagtaggtactgat
+aaagtcgtgtcgctttcgatgagagggaattcaccggaaaacaccttggttaacaggata
+gtctatgtaaacttcgagacatgtttaagagttaccagcttaatccacggtgctctacta
+gtatcatcagctgtcttgcctcgcctagaaatatgcattctatcgttatcctatcaacgg
+ttgccgtactgagcagccttattgtggaagagtaatatataaatgtagtcttgtctttac
+gaagcagacgtaagtaataatgacttggaataccaaaactaaacatagtggattatcata
+ctcaagaactctccagataaataacagtttttacgatacgtcaccaatgagcttaaagat
+taggatcctcaaaactgatacaaacgctaattcatttgttattggatccagtatcagtta
+aactgaatggagtgaagattgtagaatgttgttctggcctcgcatggggtctaggtgata
+tacaatttctcatacttacacggtagtggaaatctgattctagcttcgtagctgactata
+ctcaaggaaccactgctcaaggtaggagactagttccgaccctacagtcaaagtggccga
+agcttaaactatagactagttgttaaatgctgatttcaagatatcatctatatacagttt
+ggacaattatgtgtgcgaaactaaaattcatgctattcagatggatttcacttatgcctt
+agaaacagatattgcccgagctcaatcaacagttttagccggaaacaatcgaagcatagg
+gacaatgtatcttttcctaaattgccatgtgcagatttctgagtgtcacgaagcgcataa
+tagaatcttgtgttgcctcaactcgttgaaaagtttaaaacaatcgcagcagtctttttg
+gggtctactgtgtgtttgcaaaataactgaaagaaacgcttgaacaactctgaagtagct
+cgagtactcattaaagtgtaacacattagtgaatatcggccaatgaaccaaacgcttccc
+ggtacgctatctctctcatcgggaggcgatgtgcaggttatctacgaaagcatcccttta
+cgttgagagtgtcgatgcatgaacctcattgtaacaatagcccagcaaattctcatacgt
+gcctcagggtccgggcgtactcctccatggaagggcgcgcatctagtgttataccaactc
+gctttttaactactatgctgtagttctacaggcatagtggccagtattttctaacttctc
+tggatagatgctctcactcctcatccatcacggcttcagtttacgtcttacttgcttgtt
+cagcaacggatggaggcattaagtatcttcactgttccctaaaattgctgttcaatatca
+aagtaaggacgatacagggaaagctcaagcacactcattgaatactgccccagttgcaac
+ctcacttaatctgacaaaaataatgactactctaagtgttgcggaagcagtctcttccac
+gagcttgtctgtatcacttcgtataggcatgtaactcgatagacacgaacaccgagtgag
+aaactatattcttgcttccgtgtgtgtgacaccaggtaattgatgcggatataagctgga
+gatcactcacgcccacacaaggcgctgctacctctttattccaatgtgtaagaatttgct
+aacttcatttctagaccgcagctttgcggtcataatttcacggtacggacccttgggtta
+gagacttgataacacacttcgcagtttccaccgcgcacatgttttagtggcttctaacat
+agaatttttgttgtgacataaagagtgcgtgggagacttgcccgaccgttaagccataat
+caattgaaagccccgtgagtcacatctaattggttgtactgcgcatttagctatccttta
+gctgactcgaagagattcgattcctaatataggttaattagatggctgccgcgcgaagta
+aaacgtgaaaaacgtagtgcgcagatctgcataactcgcgcttaattacttatgagtagt
+tccaagttcgctacgttatgagagagattggaattaagcaaatatgttttatggtgattt
+tgggatgagaaggactgctaagtacggctactaaacaaatttctaaaaccgccatctacc
+ttatcttggagacatttaagttgtatatgtcactagtctagcttttgtctgtgggacgcg
+ttctcggaatgagggaaatgcaagagccgattcatcaaatgcttatctaagaaagtagtg
+gactattacaccaagcacgaatgccagggaactgctttcttgctcaggacctcgcgacaa
+ggtaccccgcataagtcctagaattacatttggtcagcaatgctgacatttgaccgtgaa
+aacataattttaatcagaaggcagctcacccgcttgctctagatcttatctttgtatgaa
+tgtcagaatttactgcaatatccgttccgaatagtgagggcttagtatagttctctgtat
+acaggtcacatcaaactccccctgtcctagtacagctctgagctttaattaattgcatac
+atttccttcaatcatcagatgaaaacaccgcgaatcatgctcttctcgtatagggcaaga
+gaagcaacaaacaactagcccgactcacgttcatccgccgtatccttgttcagttcttac
+tccgtattaggtcagcgaaatctaatcagaataatcggtcgcgtatcaaaattaaaatcc
+cgcttgaggttgacaattaaaacgctgagcagttatcggctattagatagtggggtgaaa
+gtaattggctggaattatgttaaaacgtgatattaagctaaaatacgctacttgttgccg
+acctaattcagtcattcgatattcagttagagccaagaataacaagcttgtataaattga
+acggggtgcactaaacgatgtgttactctaatattcagcttggagtatacctgaaggcga
+attcatgtatcggccaataataagacgttgaagatcacaatttggactagcaaaagaagg
+tgatttatgcgtggggattgagtccactgtacgagtacggtctctggaaaattataggtt
+cagggaatataaggaagtaaagataattaccaagagatttttggtatcgctatgacccag
+aggtgttctaacgtctgttttgatccgcagaatttctgcctcaatgcatatttgacggac
+ttgaactagagcctctaaagttaaatggcgacgcaactgttcctaaacttcaattattac
+tactctttttttcctagggtattgtagaggccagtggacaaaataaatcaaatttaagat
+gtttcggacattaacatcccccgtagcatagaaatcatcagttatccaatctctcatcga
+gcttttacaatttctgctggcgctatggacagcatatgccgcgagacctccgcaagactc
+acttgatcactgtaagtatcttcattagaggttagagcctatagttaagctgctgaccta
+gtaaaattggtattttctaattttattgctcaagttaaaggttagtgaagggataatgac
+gttatttttgaacaatgggttgtattcaattttatatcacgaatggaacccttcattccc
+ggcataatactagacgacacgaacaagctccgatctatcagccaggcacgtgttaaggtt
+taattccggcaaaccaatgaagcatcaaaaggtgacctgatgcaacttagggtcacgatg
+agtttttcaggactacttattacctattaataagttaacatgagccttcataccccgtaa
+gacaatacatactccaccaattagaattctgagccatcttatctttttgtatcatcgaag
+ggtatggccgaataggttaattagttactcctaacgtctctacaggcatgcatttgacgc
+accttcgaaaatagtcaatctctcgccacacgcgtctagtatgcagcatcaaaaatatag
+tccacggtttccggattaccaaacgcggcaaagagaaacattgtatcgacggagataact
+taatacagaaggaaggggcatcttcgaatacggatgaataattctatctgtttattctga
+catcttgttttcaggttaatcttacgcattcaaatgacgcctgccccatgcgtgcgcaat
+tattttctaatattgacgagagcaatctcactccttttgggtctatttatgttttattga
+ggcacaagcctatacagaacaggtactattaaggccgtgagtgtgagactcaaaccgtgg
+aaacaaaggatgggttgttcttggtacaagttttagtgcatgtgggcaatccttaccaaa
+atcagatgctatccttaactttgggctgcatttaagatggcggttggaggcctgtgagaa
+tcctgcgtgtcatctttaatgaccgaattcatccatgtagattcagatcacacactcatt
+ccttgatgttgtctaaacaaaagttgttgtggacgcattggagggagttaagtaacaact
+tgggatcgcatacttataaaaattatatgttaaactttcacaaacgctgaagtccaaagt
+aactagcccaaacgcctcgagagtcactaggtattaatggtgtttgagttcctgtgaaat
+agtgttcgaaggtaaaatttatgtaccaaatcgaaagaacacttaataaggcttgcttgc
+acggaggtatgatgtttactgactctacaaccctaattttccagtacgtacattcattcc
+aataggttagttctcaaagtgctatacaggctcctcaattgatgatatgcttcagccgct
+ctatggatattagctcattttatttaggaagcccgcttagaggcttactatgagggaaat
+gccaaaatgtcatacttttcggtgtgtcccatatgacaccgctttacatagaatttgaat
+taaaacgcgctctcccgttcactaccatacttggtaccgtgcgcatattacatatagata
+taggatcattttttaaagctgtactaggtttgatcgacaatcttatgctatactatatga
+tgtaaccctcataatcaataccgatcgtacgatcctagcataggtggcaagcgattttat
+gccgattattgtgttaaatagtctgtgagtgtgattatcagggctacgttggtagagggg
+ttgtatagacctcgcacacattgtgacatacttaacaatatacgaaaactgatataataa
+atccccttacccaaacaccaatcccgttgaatcaactaccataacgtctcccatataaat
+tgcctacttgtttgcataaatctgaatacataacaccattgcaccttcttgtgttccaat
+cccgttaagattgccttgtcagatgatatgcaagaacaatagcatttgctagcaattatt
+aacagctcttcgaattgcctccacataacgcgggagggtatattttaatttggcaaatac
+taagtactgttggcgtcatatgctattaacggttggatattaagttatgtcagccgtaag
+caagagtgggcgaaatattttgttacccagtgagagcactcttagagtttggatacaata
+ggccatatgttgacttaagaggacgtaactacgccgtacaccattgttcaaccgacttct
+tggcaaatagaatcgtattagcaatcttaagaatagagacacgttcgtgttagggtatac
+tacaaatccgaaaatcttaagaggatcacctaaactgaaatttatacatatttcaacgtg
+gatagatttaacataattcagccacctccaacctgggagtaattttcagtagatttacta
+gatgattagtggcccaacgcacttgactatataagatctggggatcctaacctgacctat
+gagacaaaattggaaacgttaacagcccttatgtgtacaaagaaaagtaagttgttgctg
+ttcaacagatgatagtcatgacgcgtaacttcactatagtaaattgaaacaaatacgcaa
+tttagacagaatggtacggtcatgaatgacagtaattcgaagtgctagaccaacttaaaa
+taggtaaacgtgcccgaaaccccccttaacagaaagctgctatcatggtgcagtatcgac
+gtgttcagaaacttgtaacttttgagcaggtccgagcacatggaagtatatcacgtgttt
+ctgaaccggcttatccctaagatatatccgtcgcaaactttcgatttagtcccacgtaga
+gcccaagcgttgtgcgactccacgtgcatgcccagaaatacgagtttaaatttggttaca
+tggttaattttgaccgaagcatcgcactttatgattgataattggattcaatatgtcgcc
+ctatgcgaatgcaacatgatccacaatttggctataagacgtttaatccgtatcacactt
+tgtttgcggctagtatagtaacgcccgtgcaccaagagtcagtaacaattataagtactc
+cgcaggtacttcaaatataaaaactaatcaaacacgacccatatgatcatctgaagatat
+ttggaactttctcgacaaccaccctcgtactcaatacttacactaatcgacaggcacacg
+caacgtgtacagtcgcaccatattgagtcaagatttgcttagtggcgatgagcgtacacg
+cttatttctctagtcacaattagttatctacgagacatcacgagggagcaaataagcgat
+gttatggctacacataggcacgtatgaatatgatataagccagttaaacagtcgaaccat
+cgagcaaattctcatgcaccaacccacacgttgaggcacaaagagtaagctgtttgaatg
+taacttcttctgctgagcgggccccaacgtaaggatcaactagaagagaaaactcggtat
+tagtttaaatgcgtcacggagcatgagtgcatttcactaagaatgtctgtgtaaccaata
+taacatctatttgttatctgattgcctacttatggctttgcggtcgtggcgactaatgtc
+tccaatccttttgaggtcggtaccaactccctttaaattacgctgtgcaggctcatgcac
+tgcatacatatacggtagcaggtagggacctcacgcacccttattataatcaatagtagt
+tatcagtcaacgaggcaggaatgctgaggtcgaggtgttggtatattttctatgtgccgt
+ctaggcgactatcacgcattaccaggcgagatttaagccaattttgaatatagtcaacgt
+aatttttactatgggttccaccgaaacgccttgcacaactaagaatcccataaaatatcg
+atatcaaataaaagattgtgtcaataccttcatatatattttttcggttgactaacgtga
+actaaggttaggggttttgtatgtctatataggaaacagtttcttttctgtcctacttta
+gtaaagtcttcaagccttactccaaaatcacggtgattaagccgttactcagcagcatga
+ttctgcctgctcgggtcctaaaatccagccttgtaagagtcgctgtgtattagctaggga
+gacctttgttaaaaaggatatatcgcggcgggatgtgagtgcgtggcgcatactcaatct
+tcagctcgtgtcattataatatctctcccccacgcttttcactagatatgccgtgtaagc
+aaacaccttatgcttaatttcgaaaatattggtacttgaaaaaagctgtaggggtactta
+atgtctggtaggagatcaggagagaattgagtgtaaaaccgtaaagccctcacctgactt
+catgtaaatggcttagaagactccatgatttaataaatactacgaaggaaagactggatc
+taaagataactctagtaaggccaactcccttcaatgctgttgccagttataatccaagag
+ctgtccttttctgaaccatagcggcttctgaagcgaactagaagcaaagttggttctagc
+cagacagccacataccctgtacgggtgtattactaaaactggtccggtattagttcacca
+agggaggaattaggcaaaggatctaggtatgcaagtcggagtattacatccctaccctga
+atccatcaataggttcctctgtactggccttcgcaatgagtattcaaggttgtacagccg
+tataataataagatagtgactatgaacgggaagtaacccgctcaccttccccaaaacatt
+gttatatctaagtattaaagtctgccgtagtgttaatactcgaaaataaacaactggcaa
+attacaccgcacttaagccgcttttgatttatatttttccaatgcgcttttaaaaataat
+tcagtcctacatactaattaagacccttaaacggagatatcacaagttaagttttaacca
+tctcgactaggtggaactatagatacccaactcaatttatcattacctgtaatgttccta
+gaaggattgcatttcatgtcaagacggtggagtttcacagcgaaacttcagtgtgaacag
+attctgagaaatcacctaaacctattagtcagagcacccggttagaaccagttgtcaaaa
+aatagagcggttgcatgagacagaagtaacgatgagatccgttgtaacgttgagacatct
+ggcctatcgtcaatacagtcctcccttaaaaatatttttaaatactaggcaaacccaaca
+taggttagtcctatgtgatacgccacatggtatatcattttgtaacgttacctagggata
+atcaggaagtggaattacgcaaaagtagacagtgaaatgcttagggttatagtctagtcc
+aaagataaaggataaagcacgtcagagaactatattagccgaatgggaatcattgttagg
+agactgtggatcatgtctaaaaagcaacgcagaaacagtcatcgaaaaaatctcgttttt
+gtttgaatctaaaagagctttgatgaccgatagtacctgtatactagttactgtattacg
+tgtctaatgatttcggattggggtccccagaatcagacgtcattgtagacgattcaagtt
+taccaatttaatttcccagctctccttggagaactatcgccaataattgcagtcactttc
+cttttctgaaacgataaagccgtcagagttctctgcaacgttggacttacctgaggttct
+aacccactttcggttctaatagtagttaacgacacaacgaataacctttactgtggggct
+ttcacgatattttttcgcttattattaatggttacgtcataagctggtgtccaaattaag
+gttaccggcttcgcagagtagttgtatccaagtataacttccctaatcataagatcgagg
+tagaaaattaatgctgtctctaaccgaacagatatgtcccactatgtggtatggacgttg
+ctaattacttctgaagggaaattggtcattatggatacgtgtctaccatcaggtcggacg
+cagatatggttctgtcttcagttgatccaccgttctttataggataataactgacgatta
+aagattatggtaaatagattaagccaattctcttcttgtcagtgaagcatccttaactga
+cttgctctgcagcccctcatacatttagctattcaaagtaccggctcgtttcaaactctc
+ccacctttggaagaggttgtcaacttgataagtatatcatttacagcattttttcggacg
+tacctctaatgtttcattgcagaaaattagttttttctatcgcacattttgcaagtaacg
+ttagagacacaattatctgcgaatgaactgctagatctgacgaccgggagcctcgcaaat
+atcaaaaaagactgacatatatcaaggagtcgttgacaagtgctggtaagtcaattggtt
+tatctgtcccggcgtttcgatcttaagctgaccatgcacggcagagtaatgtcactctcg
+ttcttacaagtctgtctccaagggtcggcaaaaaagacccctccattctcgagcccactc
+acgatatgtagggacgacaacttgtgcggcttatgaattgtctggactgcgggcgagggt
+ccatatctccgaagttagaagggacatacctttagatgataagatcaattcttattgacg
+aaattcatccacaacggggaacaacttcaccctagacttacgtctgaaaagacacctagc
+gtcttataaaaggtcagtgccccgtttcgtaaggctggaattacctacgcaaacttaaac
+ctcgcgcccttccttacgtatcgacaagatagaggctatcgcgaatgtactacggaggca
+tgaatcatatactagaaccaagtgcctgtgatattaacaagatgatccgacgcgagcacc
+gtaattctaggcataaaactccagcaatttgggggccgaaaacaaatgacgttagctaat
+taattatatgacatgatcaaaggaggtcaatcacgcatcgagttcgacgtatattcattg
+aacttcgtgcgtttgaaagaaacttttatgaaggcaaaattgatcctgtctcctatttca
+tgcgtacctcctagttgataattccccgagcagtggttaggacacttttgtcggtatcaa
+gttccggtctcaaaacgtaaaattctgtaatctgtatggatggtctgtgaattagttaat
+ttttatgaagtcgtcgagacgcagttcctattgatttattctaaacggagatgtgcttcg
+tgggactcggaagtagatctgtgtttatgattattgctactttagatgctgactgttaac
+tccgtgttgtttttcaaccgtatatcacaaccgaattggatagaacctatagtttcaagt
+tctgccacaaggtatcatatttacagttagtgctggttgcttctttcaaacgtggtgagt
+ttgtgctatcacgtcaacggtagagctcagtggaccgagtgcgcgttcaaccctgttcca
+gagagggtgtgatagcacatataccacgctcgtcgaggcgttcatgatagtttgcaagag
+ccggtgttaaacacatattattattgttatccaactaatcggacctatgcataaagcatt
+gtctaaacagaataattgcctatatacggtagttttagtgatttatatcttagtatcagt
+tagagcttcgaactcttcaggttcctcatatttaacgttcttcgaaagcgaaaacttcta
+caaacgaatgtaagcggttttccaagtagtacctataaatcacagaaagatctgtctcag
+tatagttgaaatggtattcagctagtgacgtgtaccaattatcatagttcactcaagcaa
+gacgctcattaacgaatatagacaagacactatatcatataataaaaaagaacatggtgc
+tcgaacatagttgaattcaccatattgaaggggaatgctgacatgtaattcgctactaga
+cgatcaattccctacttgtcaaagttgaactggtacgttcttggaattaaatatgattgc
+gctggaccaaattgcgacttcttgagtttcagggcaaacgattgagccggaggatgtccg
+tctcttacctttcttgcttatgataaacgacggtccctgtacatcactgggaattctcag
+caaaaataattgggtaaatcgagactcgatgtattcggccacaaaggtgttagacgttaa
+agattattcaacggggcgataataggatcataaccggtatgcaagcgcattgaaagagcc
+atgagatccttatccgataaacgctgcacggtatgtgcagccttattgtcgatcacgaat
+ttataaatgtagtctgggctgtaagttgaagacctaagttataatgaagtgcaataccaa
+atcgattcatagtggattatcagactcaagatatctcctgataaattacagttgttaaga
+tacggataaaatgagatttaagattagcagcctctaatctgtttcaatcccgttggaatg
+tggtatgcgatcaaggttaagttaaaatcaagcctgtcttcagtcttgattcttgttctg
+ccatcgcatgcggtctacgtgagttaatatgtagcttacgttctagcttgtgctaatctg
+agtatagattcgtagaggaatattatcaagcttccacgcctcaacgtacgtgtattggtc
+acacaagacactaaaagtggaagtagcgtaaactatagtctagttgttaaatgctcagtt
+cttgttatattcgatatactcttggctaatttatgtctgagtatataaaattaatgatat
+taacttgcatttcacggatcccttagaaaaagattttgaccgagcgcattataaacggtt
+acaccgaatcaatagaagcatacccaatagctttctttgaatttattgcctgcgcaactt
+ggctgactctctagatccgaataattctatatggtcgtgacgaaactagttcattactgt
+ttaaaatgccaacatgtcttttgggccgataatggctctttgcaaaattactcaatgata
+cgattgatcaaagcggtagttgctagtggtagcatgtaagtctatcaaatgtctgattat
+ccgaaaatcttccaaaagagtccacgtaccatatctatctcatagcgacgcgaggggaac
+cttatctaactatcattccatttaccgggtgactctcgatgcaggatccgattgggataa
+attgcccagaaatggctcattcctgactaagggtaaggccgttctcagcaagggaacccc
+gcgaatctaggcttataccatctagattgttaactacttgcctgtagttctacagccata
+ctggacagttgtttctaaatgatcgggattcatgctagcactcctctgaatgcaccgcgt
+aagtttaactattacgtccgtgggcagataaggatggaggctgtatgtatcttaactgtt
+acctaatatggctggtaattatcaaagtaaggaccttaatgccatagcgctagcaatcgc
+tttgtatactgaccatgtgccaacctctcttaatctgtaaaatataatgtcttagctaac
+tgtggacgatcatgtctctgcctagagcttcgctgtatcaattcctatagccagcgtact
+agtgacacaacaacaccgtgtgagaaaagatattagtccttacgtctgtctctctacagc
+ttattgatgaggattgaacatggacatatagctccccctcaaaagcagatgctacctctt
+tattccattctcgaacatttgccgaacttaatttcgacaaacctgaggtcacgtcttaat
+ttatcggtaacgtcacgtccctttgagactggataaatatattaccaggggccaacgagc
+aattgttggaggcgcttctataatacaaggtgtcttgtcaaagaaagacggcgtgcgtct
+cgtgcaactcacttaaccaatattaatgtgaaacccccctctctcacatcttatgcggtg
+tactgccctggtacatttcctgtacaggactccaacagtgtagattcctaagatagctgt
+tggagttgcctcacgccagatcgaaaaactgaataaactagtgagctgagctgcagaaat
+accgcttaattacttatgactagttcaaagggacctacgtgatgtcagacattgcaagga
+agaaattaggtttgtgcgtcattttggctggactagcactccttacttcccctactattc
+aaatgtcgtaaacagcatgagacaggatcgtgctgacatttaaggtctattgggaacgag
+gctacctttggtcgcgcgctcgcgttctccgaatgaccgaaatgcatgagcacagtatgc
+aattgcttatagatctaaggtctggtcgttgaaaccaagcacgtaggcctgggaaatcag
+ttcttcctcagcaactacacaaaagcgtccaagcattagtacttgtagtaaatgtccgaa
+cctatgcgctcatttgaaagtcaaaaaatatttttaagcagtaggcacctaacccgattc
+ctctacttagtagctttctttgattctcagaattgactgcaatatcactgcacaattctg
+tgccattactagacttctctgtattaacgtctcatcttactaacactcgcctaggacaca
+tctgagagtgaagtatttcaatacatttactgaaatcttcagttctaaaatccccgaata
+aggctcttatcggtttggccaacacaagaaaaaaacttcttgcaccactcaccttcatac
+gcaggagcctggggaacttagtaataactatttcggcagacaaagcttataacaagttgc
+cggcgcgtataatatttaaaagaccccttgagctgctcaattaaaacgctcacctggtat
+aggctattagatagtgccgtcttagtaaggggcgggaattatcggataaactgatatttt
+gataaaataaccgacttgttcacgacataagtcactaaggagattttatctttctccaaa
+gtatatcttccttggataatttcaaagcgctgcaatttaagttctgttactagtttatgc
+tgctgggaggtgaccggaaggcgtagtaatctagaggcaaattataagaagttcatcata
+tcattttcgactacaaaaacaaggtgttgtatgccggcgcattgtgtaaactggacgagt
+accctagatggaaaattatacgttaagccaagatttcgatgtaatgataattacctacac
+atttttgctatccataggaacaagagctgttctataggctcgtggcatacgaacatttgc
+tgccgctatgaatattggaagctcttcaactacagactctattcttaattgccgtcgaaa
+atgggccgaatcggctattattaatactcggtttttccgaggggattgttgtcgacagtc
+gtaattattattaatattgatgttggtgaggtcatttaaatacaaccttgcagacaatga
+ataagggatccaatctctcatactccttttacaattgctcatgcccctatgcaaacctta
+tgccgccacacctccgcaactctctcttctgaactgtaagtagcttcattactggtttga
+gactatactgaagctgatgacattctaaaatggctattttcgaatgtgattcataatgtt
+tatcgtttgggatggcagaatcacgttatttttgatatagcccgggtattctattgtata
+gaacgtatgctacaagtcattccccgaagaagactagaagtaaacaacatgcgaccatcg
+ttaagccacgcaaggctgtagctttatttcccgataacctatcttccataaatagcggac
+agcaggatactgacgctcaacatcagtggttatggtctaatttttaacttttaataaggt
+aacttcagcaggcatacacagtaactctttaatttataatcaaattagaagtctgacact
+tcttatatttttctatcatccaacgcgatcgcccattagcttattgtgttactaataacg
+tatctaaaccaatccttttcaagctactgcctatattgtcaatatatacaaacaacagga
+tagtaggctgcttaaaaaatattgtcaaccgtgtacgctttacaatacccggaaatcaca
+aactttgtagacaacgagtgaaatttatacactacgaagggccagcgtacaagacccatg
+aattaggcgatatgtttattctgacatattggtttatccttaatctgtcgctgtaaaatg
+aagccgcccccatccctgcgaattttttttcgaagattcacgactgaaatataaatacgt
+ttggctatatttatgttggagggaggcaatagcctttactgttaaccgaagatttagcca
+gtgagtgtgacactaaaacactggaataaatgcaggcgttcttctgggtaaaaggtttag
+tcaatctcgcctataagttcatatagctctggatataattatctggcccatgcatttatc
+atggcgcttggtgccctgtgtgaagccggcctctcatattgaaggtccgaagtattccat
+gtacattaagatcactctctcattcatgcatcttggcttaacaaatctggttgtccaagc
+tttccaggcacgtatggtacaaattcggatcgaatacttataaaaatgatatgttaaact
+gtctaaaacgctcatctacaaagtaaagtgcactaaccaatagagtctcaagaccgtgta
+atgctggtgcactgaatgtgtaatacggttagaagggattagttatgttacaaatccatt
+gaaaacttaagaagcattgcgtgctcggagggtgcatcttttatcaagagactaacatta
+ttttcaacgacgtacatgctttacaatagggtacttatcaaacgccgagaaacgcgccta
+tagtgatgttatgattatgacccgatatccattggaccgaattttatgtaggttcccagc
+gtactcgcgtaatatctcggtattgccataatgtaatacttgtcggtctctcccagatga
+aaaagcgttacagagtatttcaatgaaaaacagcgcgcaacgtcaatacctttaggggta
+acggccgctgatttcatatagatatacgataagttggtatagctctactaggtggcatcc
+acaatcgttgcatttactatagctggttacaatcataatctataccgttccttacatact
+accatagcgggatagcgtttttttgccgttgattgggtttaagaggatgtcagtctcatt
+atatccgattcggtgggagagccgttgttttcaaatcgcacactttgtgacataatgtac
+aagataacaaaactgatataagatataaactgtcaatatcaccttgacacttgaatcaaa
+gtaaattaactcgcaaatataatttgactaattgggtgcagatttctcaattaataaaaa
+aatggcaccggatgggcttacaagccccttatcattcacttgtatcatgatttccaagaa
+caatagaatttgctagcaagtatgaacagagattcgaattgcatccacagtacgccggag
+cgtttattttaatgtggatatgacgatgtactgttggcggcatttgctagtaaccggtcc
+ttatttacgtagcgcacacgtaagcatgtctgggagaaatatggtggtacaatctcagag
+aaagattacagtttggtttaaataggacttatcgggtcggaagtggaacttaataagcag
+tacacaattgggcaacagacgtcttgcctattacaataggattacaatgcgttagatttc
+agacacgttcgtgtttggctattcgtcaattccctaaatagttagacgatcaactattat
+caaagtgattctttgttcatcctccattcatgtaacagatggcacactacgcataacgcc
+gaggaattttaacgagatttaagagagcagttcgggcacaacccacttgactttataaca
+gctcggcagcataaacggtaatatgtgacaaatttccaaacgttataagaacgtatgtgt
+acttagaaaactaagtggttcatgttcaacagatgtgacgcagcaagcctaacttatcta
+ttggttttgctataaaagaacaaagttacacagaatcctaagggcttgtttcacacttat
+gcctagtgcttcaccatcttaaaatagcgaaaccggcacgaatcaaaccttaaaacaatg
+cgcagatattggtgatggtgactccgggtatgataatggtaactgttgaccagcgcccac
+ctcatcgaagtatagaaagtggttaggataaggatgagaccgaacttatttccggccata
+actttagattttctacctagtacacaacatcagggcggacacgaaaccgccatcacatca
+tataccaggtttaatttgcttaatgggggaagtgtcaacgaaccttcgaactttagcagg
+catatggccattatatatggccccagagcagaatgctacagcagacaaaatttggattta
+tgtagtttaatacctatcaaacttggtgtgaccatacttgtctaacgacagtgcacaaag
+tgtaagttacaattattactactcagcagcttctgcaatgataaaatcttatcatacacg
+tcacatatgataatatctacttagggggaacgggctccacaacctacatagtactcaata
+cttacactattcgacaggcacaccaaacctgtacagtcccaaaagattgagtcaactttg
+cagtactgcagatcacagtaatagcttagttagcgagtcaaaattagttttctacgagac
+tgcacgaccgtgcaaatttccgatgtgttggctacaaatagcaacgtatgaatttgtttg
+aagccacgtaaactgtacaaccttagagataagtctcaggctactaaaaacacgttgtgg
+cactaacaggatcatggttgattcttacttattcggctgaccggcccaataagtaacctt
+caactagaacagaataatcgggagtagtttaattcagtcaaggtgcaggtctcattgtaa
+ctaacaagctctgtgtaaccaagttaaaatcgttttcttagcggattccctacttatgga
+tttgagctcgtccacaatattcgatacaagaagtttgtggtccgtaacaacgaaatttta
+attacgctgtgcagcctcatccaaggaattaatagaaggttgatggtaggctccgaacgc
+tccatgattataatcaagtggactgtgcagtaaacgaggaaggtatcctgacgtcgtggt
+gttcgtttttgttatttgtgccctatacgagtagataaaccatgaacagcacagtgtgaa
+cccatggttgattttaggctaccttatttttaatttccgttacacagaaacgaattccac
+aactaacatgccattaatttttcgatatcttataaaagatggtcgaaattcattcattta
+ttttttttcggttctcgaaagtcaactaagctgtcgcgttttgtttctctttagaggtaa
+aagtggctttgatctcctacgtttggatactagtcaaccattactccatttgatccgtga
+gtatcacctgtctaacatccagcattatgactcctcggcgaagaaaagacacacttctta
+gagtcgatgtgtattagctagggacacagttgtttaatacgatagtgagcccagggaggg
+cagtgcgtcccccagtagatttattcagctagtgtaagtataagatatctcacccacgag
+gttcaagtgatatgcagtcttagaataatacttatcctgaatttcgatattatgggtact
+tcaataatccgctagcgctactttatgtctcgttggacagcaggacacatggcagtctta
+aacactaaagacatcacctgaatgaatgtaatgggattacaagaatcaatgaggtattat
+atacgacgtaggaaactctggatatatacagtaatctagttacgccatcgcacttcattc
+ctctggaaacttagaagacatcagctgtacgtggaggaaccagacccccgtatgtagcca
+aatagaaccaaagttgcttatacaaacacacccaatgacaatggaccgctggagttcgta
+aactcggaacgtagtactgcacaaacccagcatttagcaataggagctacgtatgcaact
+cccacgtggtaataccttcaagctatcaatatataggtgcctagctaatcgcattcgcaa
+gcagtattcaagcttgtaaaccagtataataattacagaggctctatgaaacccaacttt
+ccagctaaaagtcccaattaaatggttatttcgtacttttaaagtcgcccgttctgttat
+tacgcgaattgattctactccaaaattaaacacaaattatcaaccgtttcatttatattt
+gtcaatgcagctgtttaaaataaggctctactaaattataattaagacacttattaccag
+atttctctagttaagtttgaaccagctcgactaccgcgaaagatacattcccttctctat
+ttttcagttcatctatgggtcagagaagcattgaatttattctattcaccctcgtcgttc
+acagcgaatcgtcagtgtgatcagtgtatgagaaatatcctaaaccgtttagtcagacca
+cacgcttagaacaagtggtctaaaaagactgccctggaaggagtaagaagtatacagctg
+atccggtgtatccttcagtcatctgccctatactaattacacgacgcaaggaaaaatagg
+tttattttctaggcaaacccttcataggtgactccgatgtgttacgaatcatgcttgaga
+atgtgctatcgttaccgacggataataacgatctccaatgaaccaaatgtagaatgtcta
+ttgattacccttttactattcgacttagagataggagatagaacctcagtgtactttttt
+agccgaatgggaatctttgggaggtgaatggccataaggtcgtaaatccaaccctcttaa
+agtcttccatattatatcgttgttcgtggaatcgataacagatttgttgacccatagtaa
+atgtatactagtttatgttgtaagtgtagattgttttccgattgccgtccaaactttatg
+tcgtaattgtagaccagtaaagttgaccaaggtaagtgcccagcgatcctgcgagatcga
+tcgccaatttttccagtcactgtaagtgtaggtttagataaagccgtatgagttatatca
+taagggcctcggaaagcagcttcgaaccaaagttcccttataatagtagtttaactataa
+aagtatatactggtctgtcgccctttcacgatttgttttaccggtttatgaagcgttacg
+tcattagagcggctccaatttaaggttaacggcttccatgtgtagttgtatacaaggata
+acttaaagtatctgttcagcgagctagttaagttatcctcgatagaacacaactcagagg
+tcccaagatcgggtttgcaacttgctaatttattctcaaggcaaattgggaattatcgat
+acctgtataccataaggtcgctcgatgtgatgcttatgtcttctggtgatcctaccttag
+ttagtgctgattaacggaacattaatgtttatcgttttgagatttagccaattctctgat
+tctaactcaagatgccttatctgacgtgctatgcagcccctaagtattttacattgtaat
+aggacacgctcctttaaaactcgccaaaaggtcgttgtggttctctactggttaactata
+taatttacagctttgttgagctagttcctctttggtttaagtcctcaatattagttggtt
+cgagcgataagttggctagttaccttagtcactatattagatccgaatgttatgcttcat
+ctgaagaccgccaccctccaaaatttcttttaagactcacttattgcaaggtgtaggtga
+attcggctcgtttctcaagtggtgtatctgtacacgagtttccatattttcatcaacagc
+caccgcacacttatgtcactctaggtattaaaagtcgctctacaaggggacgcaattaag
+aaacagacatgctagtcaaaaataaacatagcgaggcaccactaattcggccgcttatca
+atgggatgctctgcgcgagacgcgccagagctcagtagttagttcggacatacatttact
+tcagatgatcaattagttttctacaaatgcttactctaccccgaaaaaagtcaccagact
+cttacgtctctttagtatccttccgtcttatataaggtcagtcccccgtttcggtaccct
+ggaatttactaagaataatgaaacagcccccaaggacgtacgtttacaaatgatagacca
+gatcgcctagcttattccgacgcatgttgcatagaattgaaccaacggaatgtgagagta
+actagatgagccgaccacagcacccgtttgcgtcgcagaatacgcctgatagttcggcca
+cgaaatcatatgtcctttgagtattaagtatttgtaatgatcaatcgagctcaagcaagc
+ttacacttcctcggatattcagggaacttagtgcctttgaaagatacgttgatcaacgaa
+aaattgataatggctcatatggaatgcctacctcatagtgctgaattaacacagcactgc
+ggacctaacttttcgaggtttcaagttcacgtctcaaaacctaataggctggaatatgta
+gggatcctcggtgaatttgtgattgggtttgttgtagtactgaccaagtgaatattcttt
+ttttctaaaagcagatctgctgccgggcactacgaaggagatctctgtgtatcattattg
+cttcttgacatgatgactcttaaatcactgtgggtgtgcaaaacgatagcacaacccaat
+tcgatagtacatattgttgatacttcgcactaaaccgttcatatttaaaggttgtgctcc
+ttccttcgttaaatactggtgacttggtcctatctactattagctagacctctggggaac
+cacgcccccgtaaaacctgtgcaagagagggggtcatacatcttagacatcgcgcctcca
+ccagggaagcattgggtgattgaccaggtgtgtaacaaatatgattattcttatactaat
+attagcaaagatgcataatgatttgtattaaatgtataattgaattgataagggtctttt
+agtcagtgatagagtagtataaggtagacattagaactcttaaccggacgcagatttttc
+ggtcttagtaagccaattagtcgacaaaacaaggtaagagcggttactagtagtacctat
+aatgcactgaatcttcggtcgaagtatagttctaatgctatgcagattgtgacggcgaca
+aatgttcagacttatatcatgaaacaagctcttgtaagtattgacaaatgaaaagattga
+atatttttaaatacaaaatgcgcctacttattaggggaattaaccagattgaaggccaat
+cctcacatgtaatgagataatagacgataaatgaaattcttgtaatagttgaactgctac
+gtgatgggtattatatatgattgagatcctccaattgccgacgtcttgtcttgatgccca
+aaagattgtcaacgaggagctccctcgcgtacctgtcgtccgtatcataaacgacgcgac
+atgtacagcactccgaagtataagcaataataatgcgggtaatccagactagatcttttc
+ggactcaatgcggtttcacggtaaacatgattaataccggagagtagtcgagcttatcag
+cgatgcaagcgaattcattgtgccaggagatacgttgcagataaaaccggcaacgtatgt
+caacaagttttggcgatctcgttgtttgtattcgacgaggcgcgggaacttcaagaacta
+tcgtatattcaagtccattaccttttagtttcagactggtggagctgactaaagttatat
+catcattttgtacactggtttagttaacgataatttcagatttaacatgaccagacgata
+atcgctgtatatccagttggaatgtggtttgccagaaaggttaacttataatcaagcctc
+tcttcagtcttgattcgtcgtatcccatccattgcgctatacctcagtgtatttggagct
+gtagttataccgtgtgctaagatcagtagacatgacgagagcaatattatctaccttaca
+agcatcaacggacgtctagtcggaacaaaagactctaaaactcgaacttcaggttaatat
+actatagttctgtattcagcagttattcttatattcgatattatcttgcctattggatgt
+ctgactttagtatattaatcatagtatctgccatgtaaaggtgccagtactaaatctgtt
+tcacagtgcgaattataaacggttacaaccattaaagacaacaagaccctatagctttat
+ttgaattttgtcaatgcgcaacttggagctcgcgatacatcccaattagtctatagggtc
+gggacgattctacggcatttctggttataatgacaacatggattgtggcccgagaatcgc
+tctttcattaattaagcaatcattacagtcttataagcgctacttccgagtggtagcagg
+taactcgatataaggtcgcatgagccgaatagcttaaaaaacaggccaccgaacattgat
+agagaataccgaccacagcgcaacctttgattactttcattaaattgtacggctcactcg
+acatcaagcttaagattgcgataatgtgaactcaaatggatcagtactgaagaaccgtaa
+cccacttcgcagaaagcgtacccagagaagatacgctgttacaatatacagggtgaaatt
+attgcctgttcttcgtaaccatttcgccaaacttggttagaaatgatagccattcatgat
+agaaataagctgaatgataccagtatctttaactatgtagtcagggggaagataacgatg
+gtccatgtatgtttctgatatgtgacagtattggccgcgtaatttgctaacgaagctact
+taatgcctttgagcttcatatagatttctttaatcaaaatcggcaaaaagatagtatgag
+ctataatatatgctagtagagaactctggaccatcatctatatgaatactgattcgagcg
+tgcaattactttagcctgcgtactactgactctacaaaacactctgagataagtttgtag
+tcagtaagtcgctctctataaaccttttggatgaccattgtacagccacttatagatccc
+aataaatagcacaggagacagagtttttcaatgctcgatcatttgccgatagtattttcg
+tctaacctcagggcacctattatttgatacctaacctaacggccctttcacaatggagaa
+atatatgacatcgggacaaacacaaatggtgggtggccaggagatatgacatggtggcgt
+ctctaagaaacacggactccctctaggcaaactcacgtaaccaattttaatgtcaaacaa
+aacgctcgaaaagattttgccgtgtaatgacctggtacattgactggtcaggaatacatc
+actgtagttgccgtagtgtcctgttggtgttccatcaagacacatcgtataacgcaattt
+acgacggacatcagatcaagttatacagattatttaagtatcacgtgtgcattgggacat
+aagggatctcacacatgccttggaacatttttgctttgtgccgctttttcgctgcactac
+caatccttacttaccagtatattcaaaggtcgttaacagaatgagaaaggttagggctct
+aagttatcgtcgattgggatagacgagacatttgcgagcgccctccacggatacgaatct
+cccatatcaatgtgaactggatgctatgcagtttagttcttacgtctcctagtggtaaaa
+atcaaagtagcactcgcatagcagttattcagaacctaatacacaaaaccgtcaaacatt
+ttctaattctaggtatgggccgatcataggagctaaggtgaaactcataaatgttttgtt
+agatctagcatcctaaaaagatgcatatactgagtagctggcgtgcattctctcaattgt
+atcctttttaactgaactagtcggtcccatttcgtgactgagatctattaaccgataaga
+ttaataacactcgcattcgtatcagctcagagtgaagtttttcaataatttgactgatat
+attaacttctaaaataaccctttaagcctcggatccgtttcccaatcacatcaaaaattc
+ttattccaactatctacggattaacaacgtgcatggggatcgtagtaagaacttgttccg
+atcactttgagtatatcaagttgacggcccggttattattgaatagaaacattcacctgc
+taaattaaataccgcacatcggatacccgatttcagagggccgtcttactaagggcaggc
+tttgttcggtttaactgagatgttcattattttacagtatgcttcaactaatatgtaacg
+aaggacagtggatctgtctccatagtagatcttcagtcgtgaatttcataccgctcctat
+ttaagttcgcgttcgagttgttgatcatggcacgtgaaagcaacccctagtattctagac
+gaaaattttttctagttcatctgataatttgccaattcaaaaacaaccgctggtttcccg
+gcgcattctctaaaatggaagtcgaacctagagccattatttgtcggtaacccatgagtt
+ccttcttttcagaagttaatacactgtggtcctatacagaggaaaaacagcggttatata
+cgatcgtggcataacaacattggatcaagatagcaatttggctacctattctaattctca
+ctagattcggtattccactacaatatcggcagattaggattggatgaataatcggtgttt
+aagtccggttgcgtctccaatctcctaatttttattaatattgatcttggtgacctattg
+taaataaaaacttcaagactttgaataacggtgaaaagatagaagactcatttgaaaatg
+gatcatccacagatccaaacattagcaagacactaatccccaactagctattctgatcgc
+gatcgtgctgcagtactcctgtcacaatagtctgttcatgatctaattctttttgggctt
+tgttcgatggtgattcagaatctttatccggtcgcttccctgtagctactttgtggggat
+attgcccggggattatagggttgagatcgtttcctaaaagtatttaaaccaagtagactt
+caactaaactacatcagaacatcgtgaagacaccatacgcggtacctttatttaccgata
+acatttcttcaagaaataccggtaagcagcataatgaccctaaacagctcggggtatcgt
+cgtagttttaaattttatttaggttactgctcaaggaataaaaactaactatttaattta
+taataatattacaaggctcacactgattagatttgtctataagacttcgcgatcccccat
+taccggattgtcttaagaataaactagataaaccatgcattttctagataaggcctttag
+tctaattagatacaaaaaacacgatagttgcatccttaatttattgtgtcaaacctggaa
+ccttttaattacccgcaaatcactttatgtcgagactacctctgaaatttattatctacc
+taccgcatgaggacttgaaccatcttgtaggagttatgtttattagctaagattcgttta
+tcctgtagcggtccatgtatattcaacaagcaaaaagcactcagaattgtttttagttga
+gtcaagactgatatataaataagtttccctagttttttcgtggtgggacgatattgaatt
+gaatcttaaccgaagagtttcccactctgtcgcacaataatacacgccaatatttccagc
+cctgcttatgccttaatcggttactcaatctcccattgaagttcattttgatctgcatag
+aagtttcgggcccagccttttttctgccaccttcctccaagctctgtagacgcactctaa
+gattgatgctcacatgtattaattctacattaacataaatatataagtcatgcatcttcg
+agtaaaatatctggttctccaacatgtcctggcacgtatcgttataatgcccatacatgt
+agtattaaaatgattgggttaactggatattaagatcatcgaaattgtaaagtcaaatta
+acaatactgtctcaagaccgtgtattcctcgtgctcggaagggctattacgcttacttcc
+gttttggtatcttaatatgactttcaaaaattaagttgcagtgagtcctacctgcgtgca
+tcggttagcaagagtataaaagttgtttaaacgaactacttgctttacaataccggtcgt
+atatatcgccgtgaatccagaagattgtcttctttggattatcaaccgagatcctgtgga
+ccgatgttttgggaccttcacagaggactccaggtagagctcgcttttgcattaatctaa
+gaattgtacctctctaaaagatctaaaacagtgaatgtgtatttcatggaaaaacacaga
+gaaacgtaaattactttaggccgaaaggcacatgagttattatacatatacgagatggtg
+gtatacatcgaattcggggcatacactatagttgcattgtatttagctgctttaaataat
+atgatattaccttccttacataagacattaccggcataccctggttttcaacttgtgggg
+ctttttgacgatcgcactctcatttgatccgagtagggcggtgacccctgcttttcaaat
+acaaaaatttcgctatgaaggtaatagattacttttcgctgttatgatagaaacggtaaa
+tttaaaattgaaacttctagaaaagtaaagtaacgagaaatgattttgtgaataatgcgg
+tcatgattgcgcaagtaagaaaaaaaggcaaaaggatgcgcggaatagaaacttatcagt
+cacgggtatcttgatttcattcttcttgtcaattgccgacataggatgaaatcagattcc
+aatgcaatacacagtaacccccacccttgattgtaatgtcgatttgaagttgtacgcgtc
+gacgaagtggatagtatacgggccttttgtacggtgcgatcaactatgaatctcggcgag
+ttagatggtcgtacaatctcacacatagaggtcacttgcctgtaatgacgaattttcggc
+taggtactcgaactttattagaagtaaaaatgtgggcaaaagaaggattccattttacaa
+gacgattacaatgagttacatgtctctcaacgtagtctttccctagtagtctttgaacta
+tttaggtactccagaaaattttagcaaagggtttctgtgtgaatccgccattcatgttta
+tgatggaacaataagaataacgccctcgtatgttatcgacagtgaagtcagcagttcggc
+caaaaacatattcaatttagtacagatccccagaagttaagctaagtgctctaaaatggc
+ctaaacggttatcaaagtaggtctaattactatactaacgggtgcatcgtaataactgct
+gtcgatgcaacactatatgatagtgtcgttttgctatatatgtacaatgtgacaaagaag
+ccttagcgattcttgcaaacttaggacttcggattctcaatcttaaatgtccgaaaacgc
+aaagattcaaaaatttaatctatgagcagatatgcctgatggtgactacgcgtatgttaa
+ggctaaatgttgacaaccgcacacataatcgaactattgatagtcgggagcataaccagg
+tgaacgtactttgttcacgacatttattgacatgttctaaatacgtctcaaaatcacggc
+gcactagaaaacgcaatcaaatcattgtcctggtttaagggccgtaatgccggtagtgtc
+aaacttcatgagaactttagctggcttttggccagtatttagggaccaagagcactagcc
+ttaagctgaatattttgccatttatctactgttataactttaaaacttggtggcaccaga
+cttgtcgatacacacgcatcaatctgtaacgtaaaaggtttactaagaacaagcgtagga
+attgagtttatattatatttaaactaaaagatgatattagcttctgagggcgatagggct
+ccaaatcataaagaggaatatattattacacgattagaaacccacaacatacctcgaatc
+gcccaaaagtttgacgaaacttggcagtactccacatctcagtaatacagttgggagagt
+ctcaaatgttgttttattactcaatgaaccaccctcataatttcactgctgttccattaa
+atttgcaaacgatcatttgctttgaagaaacgtaaaatcgacaaaattacagataagtag
+atgcataataaaaaaaactgctcgctataacacgatcatcgtgcattcttacttaggagc
+atcacccgcacaataacgtaccttaaactacaacactattagaccgagtactgtaattca
+cgaaagctcaagctcgcattgtaaagaacttgctctctcgtaaaatgtgataatagtttg
+cggagaggattcaattattttccattgcacctactccactagattcgataaaagaaggtg
+gtcctcccttaaaaagaaatgttaagtaacatcggaaccataagcaaagcatgtaagtga
+accgtcatccttccctaagaaacataaaggtttttaataatgtcgactgtgaactataac
+tgcatcctttcctgacctactccggttccttgttgttatttctgaacgagaccagtagat
+aaacaatgtaaaccacagtgggtaccaatggtgcatgtgacgctaccgttgttttaagtg
+cccgtacaaacataagaagtcataatcttacttgaaattaattttgccttttattttttt
+tcaggctcgaaattaatgatttgttttttttgaccttctagttacgctaatatgcggtcg
+cctgtggtttctattgagtcctataacgggatgggatctaatacgtttggttactagtaa
+acaaggtataaatttgataccggagtatcaactgtataacatcaagctttatgactcata
+cgcgaagtaatgacacaaggctttcaggagatcgcgagtacagagccactaaggggtgta
+ttacgatagtgacaccaccgagcgcactcactccccaagtagatttatgatcctacgcta
+agtattagatatataaccaaagaggttctagtcagtgcaactcttagaataataattagc
+cggttttgcctttttaggcctaatgcaatattcagctagcccttatgtatctcgcgttcc
+acagcaccactcatggcacgcgtttaaactaatcaaatataatctatgaatgttatgcca
+gtacttgaataaatcaggttttttataagtccttgcatactctcgttatatactgttaga
+gtcttaccccatagaaattctttcatctgcaaacttagaagaattctcagctacggggag
+cataaagtccccaggatgttgacaaatacaacaaatgtggcttatacaaacactccatat
+gaaaatcgaaccctcgtggtagttttagccgaaccttgtacggataaatccctccatttt
+ccaatagcagatacctatcctactacctcgtggtattaaattaaagcttgaaatatagag
+ctgcatagcttatccaattcccaagcacgagtctaccgtcgtaaccacgatttgatttac
+agacgctagagcaaacccatctttaaacatataagtaaaaattaaagggtgagtgcgtac
+gtgtttactagcaacttcgcttattaagacaattgtttataagccataattaaaaacata
+tgttcaacaggttcattgatatttgtaattgcacaggtttttaataaggatctacgtaag
+tataatgaacaaactttttaccagagttatattctgtactttgaaaatgctcctctaccg
+ccttagagactttcaattagattttttgcagttaatctatgcgtaagtgaaccatgcaag
+ggatgcgattcaaccgcctcgtgctaaccctatcgtctgtctcataactgtaggtctaat
+ataattttcagttttcgaacacataaccctttgaaaatctgctatttaatgtctcacctg
+catgcactatcttctatactgctcagaacggctatacgtcactatgctccaagtgacgat
+ttaaacgaagcaaggaataataggtttattttagtgcaaaacaattaagtgcggactacg
+tgctctttacaataagccttgtgattgggctataggttaagtcccatattaacgatctcc
+aatgtacaaaatcgacaatcgctttgcattacccggttactagtcgaattacagatagct
+gttagatactcactctaattttggacaacaatcccaatcttggggtcgtctatcgcctga
+agctcgtaaatccttccatcttaaacgattacatattatagacttgttcggggtagagat
+atcacagttgtgcaaacattgtaaatcgatactagtttatgttggtagtctagttgcttt
+taccattccccgaaaaacttgatctactatttcgacaacagtaaacttgaactaggtaag
+tgaaaacagagaatgcctcatagtgccactatttgtccactatatgtaagtgtagcttta
+cataatccactatgactgagatcattacggcctaggaaagcagcgtagaaaaaaagggcc
+cggatattacgactgtaactataaaactagttactggtagcgcgccatgtatagatttgt
+tttaccggttgtggttgcgttaacgaatttcagccgcgaaaattgatccgttaaccagtc
+catctcgacttctataaaacgataaagtaaagttgatgttcagcctccttcttatggttg
+catcgagagtacactactcagtgggaaatagatcggggttcctacttcagattgtattat
+ctaggcaattgccgattgtgccatacctggataaaataagctacctacatgtgatgctta
+tctattatcgtcatactaccttagggtgtcctgttgaacgctacattaatctttagccgt
+ttgagatgttccaatggataggagtctaacgcatgatgaagtttaggaaggcagagcatc
+ccactaagtatgtgacagtgtatttcgaaacgagacgttataaatagaaaaaaggtcctt
+ctggttctattctgctgaactattgaatggaaagattggttgacctacgtactatttgct
+tgaagtcatcaatttgacggggtgagagacatatggtgcatactttacggactctatatt
+ttagatcagaagcttagcagtcttctctacaccccctcacgacataattgcttttaagaa
+tctatgtttgattcctctacgggaattcggatccgttcgcatgtgcggtttatctaaacc
+aggggacatatgttcagctaaagcatacgaacactttgctaactagacgtatgtatagta
+gctataaatcccgacgatatttacaaaaagaaatgagactcaaatatatacatagcgacc
+ctacacttattcgcaccctgatctaggcgatcctagcacccacacccgaaagtgagcact
+agtgtcttccgtattaaatttactgcagttgagattttagttgtctactaaggattactc
+taacccgtaataaggatcaagactcggtactagctttactatcattccctatgtgttttc
+ctaactcacaagggtacgtaccagcctatgtaattacaataatgataaagacacaaagga
+agtaactttacaaatgagtctccagttacactagcttagtccctcccatcttgctttgaa
+gtctaaatacgcaatctctgaggatatacagcagaagaacactcataacgttggagtcca
+agaattagactcatagggcccccaacatttaatatgtactgtgagtttgaaggtgttcta
+ttgttaattcctgctcttgatacatgacacgtactccgtgtttaaggcttcggactgact
+ttctttcataagttgagcaacgaaaatttcagaatcgataagttggattcactaactaat
+acggctgattgaaaactccactccggacctatatggtcgacctttatacgtaaccgatat
+aaaacttataggctggtatatcgagccttcctagcgcaatttcggatggggtttcttcta
+ctactcaacaacggaatagtctttgtttagtaaaccagagctcaggacgcccaatacgta
+ggagagcgctgtggagcatgtgtcattatggactggagcactcttaaatcactctgcgtg
+tgctaaacgatagatcataacatgtcctgagtaaattttcttgatacgtcgcaatatacc
+gttattagttaaacgttctcatccgtcatgcgtgaaatacggctgtcgtgctcagatata
+ctattagcgactcatctcgcctaacacgcacacgtataaactcggaatgactgccgctct
+tacatattagaaatacagactacaccacggaagcattgggtcattctcaaccgctgtata
+aaagatgattagtcttataataagattaccaaagaggcagaatcatgggtagtaaatcta
+ttattcaagtgattaccgtcgtgtaggcagggagtgaggacgagatggtactcaggacaa
+atattaaccggacgaagtggtttacgtcgtactttcactattagtagtaaatacaaggta
+acaccggggaatagtactaaatataatgatatctatcttcgggagaacgagtcgtctatt
+gctttgaacattctcaaggcgtaaaatgtgctgacttatagcatgatacaaccgattgtt
+acttttgtctattcaaaagattgaatagttttttatacaaaagccgcatacttatgacgg
+ctagtatacagtttcatcccctagcatcaatgctatggacagtattgaacttataggaaa
+ttcttctaatagggcaaatccgtcgtgatgcctattttttttcagtcacatcctcaaatg
+gcactagtattgtcgggatcccattaacaggctcaaccacgagctcacgcgaggacatgt
+agtccgtatctttaacgaagcgacagcgacagaactcccatggataaccaattataaggc
+ccgtaatcctctagacatcgtttaccaataaatccgctttctccgtaatcatgttgaata
+ccccagagtagtccagatgataaccgatgaaacacaagtctttctcaatgcacttacggt
+gaacttattaccgccaacgtagctcatcaaggttgcgacatctagttgtgtgtttgcgac
+gagcccagcgaacttcatcaactttcgtatattcaacgccttgtaattttactttaagac
+gcctggtgatgtagattcttagataatcagtttgttatcggctgtactttaccataattt
+cacaggtttcaggtcaagaagattatagctgtatatacagttccatgctcggtgcacaga
+aacgtgatcggataataatcaatcgcttatgtcgtctttaggcgtatccaatacatgccc
+cgataccgcagtgtatttcgacatgtaggtataccgtcgcatttgagctcgagtcaggac
+gtcagctagattagattccttaatagaatataccgacctctagtccgaactaaactatag
+ataacgccaacttcaggttaattgtctagtcgtctgtttgcagatgggattcttagatga
+gtgagtatcggccatattggttcgagcactttagtttttgatgcataggatatgcaatgt
+atagctgaaagtactttatctgtttcaaactcacattgattaaaccggtaaacctttaaa
+gactacaagaaaatattcagtgagggcaattttgtcaatcacaatcttccagctagagat
+acttcacaatttgtcttgaggctacgcaacattagacggattttcgcgttttattgaaat
+aatcgaggggcccaagagtatccatagttcattttgtaagatttctttacaggcttatta
+cagcttcttcagactcctacatgcttacgagttatatgctagcatgtgaacaatagatta
+atatacaggaaaacgtacattgagagagatgaccctacacagcgcaaccgttgagtactt
+tcattaaagggtaacgctctcgagacagcatccttaagatggccttattgtcaaatcatt
+tgcagaagtacgcaagatccctaaccaacgtagaagaatccctacaaacacatgagacgc
+ggtgaaaatagacagggtgttagtattcaatcttcggagtatcaatttcgccaatcttgg
+tgagaaagcataccctttcttcagagaaagaagatcaatcataacactatctttaacgag
+gtacgcacgcgcatcattacctgcctccatggatctttaggatagcggaaagtattggca
+gcgtattgtgatttcgttcctactttatcaatttcacattcatatacatgtcttttatca
+aaatcgccaataagataggatgagctatattagatgctagtagagttcgcgccaacatca
+tcgataggaatactcaggacagcgtgataggacttttcaatccctaatactctctataat
+tataactctctcttaagtttggaggcagtaacgcgctctatataatcagtttgctgcacc
+attcttcagcctctgatacatacaaataaattccacagcagtaagagggtttaattgaga
+catcttgggaacttaggattttactctaacatcaccgaaacgattattggataccgtacc
+taaacgaactttctcaaggcagtaatataggacatccgcaataacacaaatgctgcctcc
+ccaggagttatgtcttcctggaggctatatcttacacccactcactataggcaaactaaa
+gtttaaatgttgattgtctaaaaaaaagatagataagagttggccggcgtagcacatgcg
+aaagtgaatcgtaagctataattctctggacttgaagttctgtcctgttcctctgcaaga
+aacaaacttcctttaaagctatttacgacgcacatctcagcaagttataaacatgttgga
+agtttctagtcggaattcccaaagaacggatctatctaatgcattcctacatttttcctg
+tctgccgatggtgccatcctattcaaagaatttcttaaaagtagattaaatgggactttt
+aacaatgagtaaccttacgcctctaagggttcctcgagtgccatacaccagtcaggtccg
+agccacatacacggagaacattctaacatagcattctcaactcgatcatttgcaggttac
+ttctttcctatcctagtgctaaaaatcatacttgcaatcccatagcacggattaagaacc
+taagaaacaattcagtaaaacatgttcgaattcttggtatgggaacatcattgcagctat
+ggtctaacgcattaatgtttgggtacatcttccatcatataaacaggaagagtctgacga
+cagggagtgcttgcgatcatgtctatcattgtgaaatcaaattgtagctcacatgtcgtc
+tatgagagcgtgtatccgataagatttagaaaaatagaagtcgtataagatctcactgaa
+cttttgaatgaatgtgaagcatatatgatctgctttaataaaactttatccataggatac
+gtttccaaatcaattcaataattattagtcaaaatagataaggatgaacaacctgaaggc
+cgatcggacgtagaaagtggtcccatcactttgagttgatattgttgaaccacacgttat
+tatggttttcaaacagtctcaggatattgtatatacagataatccgataccagttgtctg
+acgcccctcttacgtaccccaccctttgtgacgtttaaagcagttgttcagtattttaaa
+ctaggcggcaactaatttggaaagaagcacagtggatatgtctaaattcttgttattcag
+gcctgaatttaatacaccgcatagttaacttcgcggtagagttgttcatcatgcctcctc
+taagctaccacttctatgatacaccaatagttgttctacggaatctgataattggccaag
+tcataaacttccgctgcgttcaacccccttgctcgaatatccaactcgaaaagacagcct
+tttggtgtccggaacaaatcagttacttcttttctgatgttaattctctgtggtcagata
+cagaccaaaaactccgcggatttaccatcctccaagaacaaatttgcatcaacatagcat
+tttggctacatattctaagtctcaatagtttaggttttcaactacattatcccaacatta
+ggattggaggaataatagctgggtaagtccccttgcgtctacaatcgactattttttatg
+aatatgcttctgccgcacctatggttattaaaaaagtcatgactttgaagaaccctgaaa
+agatagatgaatcaggtgtaatggcagcagccaaagagcatataattagcaacactctaa
+gaacattatagatatgatgatagcgatcgtcatgatgttatccggtcacaatagtagctt
+catcagctaattcgttttgccagtggtgacttgcgctggaagaatcgttatacggtccct
+tccctcttgatacggtgggggcttattcaaccgcgtggattgggttgtcatacttgcatt
+aaacgatgtaaaccatctagtagtcaactatactaaatcacaaaatagtgatcaatacat
+acccgcttcatggttttaaccatttaattgattaaagatattccgctaagaaccattatc
+tacctaaactgatcgccgtatcctagtagtttgaaatttgatgtaccgtaatgatcaacg
+aagtaaaacgttatattgtatgtagaataataggtcttggagctaaatgatgtgattggt
+agtgaagacttacccttacaactttaccggtttctcggaagaatatactagagaatcaat
+gcatgggctacataagcactttagtctaatgagataaaaaatacacgagtcttccatcat
+gaattttttgtcgaaaaactcgaacctggtaatttaaaccatatatctttatgtcgtcaa
+taactctcatatgttttatataacttcccaatcacgacttgtaactgcttgttcgactga
+gctgtttgagctatgaggccgggatccggttgagctacatctatttgctacaagaaaaat
+gaaagcacatttgttgggagttctggctacactcatagagaaataagtggcccgagtggg
+tgcggcctgcctccatattcaagtgtatcttaaaccaagtggttccaacgctcgcgctaa
+agaattaaagcctttatttcctccacggagtagcccgtaatccggttcgaaagagaccat
+tgaagttaattttcatatccagtgaagtttaggcacaagcatgtgttctgccacatgcct
+caaagcgctcttcaaccaagatatgattcatcctaacttcgatgaatgcgtctgtaacat
+aaatatagaaggaatgattcggcgagttaattttcgccttctccaacatggcatccctac
+gttcgttataaggaccatacatgtaggttttaaaggtttgcggttaatcgatatttacat
+catagaaattctatagtcaaatttacaagactctagatactcactcgttgcagccggcta
+ggaagcgctttgtaccttacttcccttttcgttgcgtaatatgaatttcatatagtaagt
+tcaaggcactcatacctccgtgaagagggtagatagactattaaagttgtttaatagtac
+gtattgatggaaatgacccgtaggagatttaccactcaatccacaagattcgctgctgtg
+cattatcaaaacagtgcatgtcgaaacatgggttgggtccttcaaacacgaatccaggta
+gagatacctttgcaatttttcgatgaaggcgaccgagataaatgagctataacactgtat
+gtcttttgattgctataaaacacagaaacggatattaatttaggccgtaaccaacatctg
+ttatttgacatagaacagatggtcctttacagcgtattccggccttaatattgaggtcca
+gtgtattgtcctcctttaaagaagttgattgtaactgacttaaataagacatgtcaccca
+ttcactgggttgcaactgctggccctttttgtccatcgcacgctaatgtgataacagtac
+cgccctcacacctgcgtttaaaagacataaatgtcgctatgaaggttattcattaatttt
+agctgttttcttagaaaaggtaaatttaaaattgaaaaggctagaaaactaaagttacga
+caaatgtgtttgtcaagtaggcgggcatcattgagattgtaagaaataaagccataacca
+gccccggaatagaaaatgttaaggaaaggcgatcttctttgaattcttattgtcaagtgc
+agtcatacgttcttatcagaggacattgcaataaaatctaacaccctcccttgtgtggtt
+gggccatttgtacttcgaagcgtccaccatgtgcagaggataacggaatgtggttccgtc
+ccataaacgatcattctcgcccacttagtggcgcggtaaatcgctctcatagaggtaact
+ggcctgtaatgtccaatgttaggctaccttctccaactttagtacaacgaataatgtccg
+attaacaaggagtcaatttgtcatgaccagttcattcaggtacttgtatctatacggacg
+cgttccagagtagtatttgaaattttgaggttctactgataagtttagctatcgctgtat
+gtctgaataagaatttaatgtttatcttcgataaataacaattaacaactcctaggtgat
+acactgtgaagtctgctgttccccaaattacatatgctattttgttcacataccatgaag
+ttaagctaagtgctctataatggcataaacggttatcaaactagctcgaatttcttttat
+tacgccggaagcggattaactgctgtagatcaaacacgttaggatagtgtcgttttcata
+tatatctaaattcggtctaacatgcattacccatgcttgataacgtagcacttcgcagtc
+taattatgtaatgtccgtttaaccaaactttaaaaaagtttatctatcaccagtgatgcc
+tcatcgtgactacccggatctttagcctttagggtctaaacagaactaatattactacgt
+gtcatactccggagcttaaccaggtgaaacttatttgttaaccaaatttagtgacagggt
+agaaatacgtatcaaattaacccagcaatacaataagcatgaaaataattgtaatcgggt
+ttgggccggaatcccgcttggcgaaaacttaatgacatagtgtgatgcattttgcactgg
+attgagccacaaactcaactagcattatgctcaatatttggccagtgttctacggtttga
+aatttataaaggccgcgcaaaagtcttgtagttacaaacgcataaatctcgaacgtaata
+ggtttaattagaacatccgtaggatttctgtttatagtagatttatactaaatgttctga
+ttagattctgacggccttacccatacaattaataaagacgaatatattagttatagttta
+ctatccaaataaattaagcgaatcgaaataaactgtcacgatactgggcagttatcaact
+tatcacttatacagttcggacactctatattggtctgtgagtactctatcaaactaactc
+ataagttaactgcgcttccattaaatttcaatacgttcttgtgctgtgtacaaacctata
+atcgaataaatgacacatatggagatgcataataaaaaaaacggctccatatttctcgtt
+aatcgggcattcttaaggaggagcatctcaccaaaaataacgttcctgataagtcttaac
+tattagaccgtcttcgggaatgaacgaaacctcaagctagcatggtatagttcttgatag
+cgcgtaaattctgataatactgggcggacagctggaaattagttgccagtgcacctacgc
+aaatagtttacataaatcaacgggctccgaacgtaaatacaaagggttagttacatcgca
+acaagatgaaaagcatgtatgtctaccgtcatccgtccctaacaaacataaaggtggtga
+agaatctcgtaggtcaactataactccatccttgaagcaactactccgcgtccgtgtgcg
+tagttcgcaacgagaacactactgaaaaaagctaaacaactctcggtacaaatgcggctt
+gtgtcgataaagttggtggtagtgcacggaataacataacaaggaatattatttattcaa
+attttttgtgactgttatttgttttctgcctagaatgtaaggatgtgttttttgtgacct
+gatagttacgcttatttcaggtccacggtgcgtgagagtgtgtcctataacggcagggga
+gcgaagtagtgtcctttagactattcaaggtagaattttgataacgctctataaaaggta
+gaaaatcatgattgagcaataagaccccaacttatcaaaaaaggagttctcgacagcgcg
+tgtacagtccctataacggctgtatttcctgtgtcacaacaccctcccatcgcactcaaa
+atgtagatttatgatcagacgctaacttgttcttagagaaaaatacacgggatactctgt
+gcaacgatttcattaataaggtgcagcttgggacttttttggccgtaggctttattaaca
+ttcacagtaggtagcgagacttcctatgaaccaatcatgccacgcgttttaacgtttcaa
+atataagctaggaagcgtttgccaggacttctataatgcaccgttttttttagtacttcc
+ttactagccttagtttatgttagagtctttccaattacaaaggattgaatagccaaaatt
+tctacaattctcagcgaacgccagcttaatctaaacacgagcttcaaatattctacatat
+cggcaggagtcaatatataaatatgaaaatcgtaccatcctcgtacttttagaccaaacg
+tcttcggataattaaatcctttttcaattaccacagtacgtgcattagaactactgctat
+gaaagtaaaccttgaaatatagtcctcaagagcgtatccaagtacattgcacgtgtatac
+agtcgtataaacgagttgatgttctgacgctagagcttaccattcgttaaacagataact
+aaaatttaatggctgagtgacttagtgttttcgacaaacgtcgcggatgtagactattgt
+ttataagcaatttttaaaaacatatgttcaaaacggtatgggatatgtcgaattccacag
+gggtttatgtaccatagaagtatgtataaggtactaaaggtttaaatctgtgatattcgg
+ttcggtgaaaatcagactagtcacacttagtgtctgtaaattagattgggtgaaggtaag
+cgatcccgaactctacaaggcatgggatgagattctaccgactccggataacactttacg
+atcgcgcataactctagctcttagataagtttaacttgtcgatctcataaacagttcaaa
+atctgcgatttattgtatcaaatccatcctctatcttctataatcatctgaaccgcgata
+cggcactatgagccaagtgaagattgaatccaagaaagctataattggtttattttagtc
+catttaaattaagtccggtataagtgctctgtacaatatgcagtctcatgggcatatacg
+ttaactaccttttgatacttcgaattggtaaaatatcgactatcgatttgcagtaaaagg
+tgtagagtccaattactctttcctgttacatacgatctcttagtttggacaactagccca
+tgatggcgctcctctagcgcatgaacctactttataattacatctttatcgatgaatttt
+tttagactgcggaggccttgagttttaacagggctgctaaatttcttaagcgattagacg
+gtagcgtcgtacgctacttgcttggaacaggcaccgaaaatattgatctactattgcgtc
+aactctattctgctaatagcgatggcaaatcacagaagccctcttagtgacaatagttgt
+caactatatctaagtcgacctttactgtatcaacgatcacggagagaattaccgaatacg
+aaacctcaggactaaaaaacggaaaggatttgtcgacggtaaatataatacttgttaagg
+gtagcgacacaggtatactttgggtgtaaacgtggtgcttcccggaacgattttcagacc
+agaaaattgttccggtaaccaggaaatctcgtctgcgttaattcgtgttagtaaacttga
+tcttcagactccttcttttcgttgcagcgagacttaaattatatctgcgaaatagtgccc
+cgtgcatacttcagatggtaggagataccatttggcccattgtgactttacgcgattaat
+taaccgacatacatctgttcctgagctatgatcgtctgaataaattacggtctcctcttg
+atacctaatggtttctggagacgtttctcatgttcaaatggatagcaggagatcgcttca
+tcaagtttagctacgcagagcatcaaaatatgtatgggaaagtcgatttccaaaccagaa
+gggataaagagaaataacggacttctccgtagattagcctgatattttgatgggaatcat
+ggcggcacatacgtaagagttgcgtgaacgaatattttggacggcgggagacacatatcg
+gccattcgttaaggtctctatattggacatcacaagcttagcagtatgagctactaacac
+tcaagacattattgattttttcaagatatgtttcattcctctaccgctattcccatacgt
+tcgattcgccgggtgagcgaaaccacgggactgaggttaagctaatcaataacaactcgt
+tgcgatagagacctatgtatactagagagaattccccaacatttttacaaaaacaaagca
+gactaaaatagatacagtccctccatacaattaggaccaacatgttattgccgatcctag
+cacacacaccacaaactcagaacttctgtcttacctatgaaagggtctgcacttctgatt
+gtacgtgtctaattagcattaatattaaaactaattaggataaactataggtacgagctt
+tactataagtcactaggtgttttccgatcgaaaaacgggaccttcaagccttggtaagta
+catttaggataaagaaaaaaaggaaggtacgtgactaatctgtctaaactgacaatagag
+tagtacctacatgcttcatgtcaagtcttaatacgcaagcgctctcgttatactgctcaa
+caaaactcataaagttggactccatcatttagaatcatagggaccaaaacatttatttgc
+tactgtcactttgtaggtgttctattctgaattcctcatattgatacatgaatcggaata
+cctgtggatcccttaggacgcacgtgctttctttacgtcagaatacatattgtcagaatc
+gagaagttccatgcaattaagaattcgcctctttgaaaactcatatccccacatataggg
+tccaccgttattcggaaacgatataataattattccagcgttgagcgtcccttaagagcg
+cattttcgcttggcctttcttctacgactctacaacgcaagtggctgtgtggagtttacc
+acagcgcagcaccccatagaactacctctgagagcgcgagatggtggcagtatgctctgc
+agctagcgtttagaacgcgcccgcgcattaaccagtcatattaaaatggactgtcttaat
+tgtcggcattaggagcaatattaactgatgagggtatcggtcgcagaagtaatgacggaa
+atacgcctctagtccgcagagatacgattacagactcagatcccctaacaagcaaaacga
+ttaaatcggaatcactccccctatgacatatttgaaatacacaagaaaccacgcaacatg
+tcccgcattctcaaccgcgctttataagatgttgagtctgagaattagatgacctaactg
+caagaatcatggcgagtttatctagtaggcaagtctgtaccctagggttcgaacgctgtg
+acgtcgtgatcggtctaaggacttagatgataaccaagaactggtttaccgagtactttc
+actattaggagtaattacatgcgttcaccgcggaatacgacgaaattttttcatatcttt
+atgagcgagatcgtgtcgtctttgcattgcaacagtcgctaccagtaattgctgatcaat
+tatagattcattatacagatgcttacttttctctattcaatactgtcatgagttgttttt
+aaataagcaccagaattatgtcgcctagtataatcttgcttccacttgaatcaatgcgat
+ggacagtattctactgattgcaaagtagtctatttcggcttagcagtacgcatgcctatt
+tttttgcaggcacagaataatatgcaactaggattctcggcatccaattaacaggctaaa
+acaccaccgaaagacaggtaatctacgaagttgatgtttactacagaaagcgaatgatat
+cacttggagaacattttagatgcccccttttaatctagactgagtgtaccaatatatcac
+cggtctaccgaatcagcttgaataaaccactctagtactcatgataaccgagcatacaca
+tgtatttctcaatgcactgaaggtgaactgtttacaccataccttgcgaatcaacgtggc
+gacttatacttctgtctttgagtacagcacaccctaatgaatctaagttagttgttgata
+cgaattgtaatttgactggatctcgcctcctcatctagattcttagagaagatgtttctt
+atagccggtactgtaactttattgatctggtttatggtaatcaacattttacctctattt
+aaacgtccttgcgccgtgcactcaatcctgatcggtttagattcaagcgattatcgagtc
+tggaggccgagaaaagaaatgcacagagtaagctctctattgcgacatctacgtagaaac
+tcgcatttcagatcgagtaagcaactctcattgtgttgattcagtaatacaagattacct
+acgcttctacgaaatatactatagatttagcctacgtcacctttagtgtcgagtcggagc
+tttgaagatcggatgcggtgtggactgtgtataggcaattttgctgcgagctcgtgactt
+ttggttgatgtcgatatcaatgggatacctcaaacgtctttatctctggataactcacat
+tgagtataccggtaaaaatttattctattcatctaaatagtcagtgagggctagggtcgc
+aatcacattaggccacatacacatacttaacatgttctattgacccgacccaactttagt
+agcattgtagccgtttatgcaaatatgccaggcgccaaacactagccagagggcattttg
+ttacatttatttaatcgattattacacagtcggaacacgcctacatgcgttcgacttatt
+tgcgacatggtcaacaattcagtaatttaatccaaaacctaaagtcagagacatgacact
+aaaatcacattaaggtcagttagtgaaggaatggctaaccagctagagaatgcatcatta
+acaggcacttattgtcaaatattttccagatctaagcaacatcacgttaaaaagtacaac
+aatcacttaaaacacatcagtccaggtgtaattagaaagccgcttagtaggcaagcgtag
+gagtataaatgtagacaatagtcgggacttagcagacactggatgcagtcatagaagatc
+ttgcataacacgttagggttagagctacgaacgcccatcattaactgcctaaagcgtgcg
+tgagcttagcgctaacttttccaacacgtttgtgatttcgttcataatgtatcaatttca
+cagtcatatacagggagtgtagaaaaatcgcaattaacatacgttgacctatttttgttc
+agagttcagttagagcctaatgattcgagagcaataatcaggacagcctcataggaagtg
+tcaatcacttagaagctatattattataaatcgctctttactgtcgtcgaaggaacgagc
+gagagagaatcagttgcctgcaactggcttaacaatatgatacataaaaatattttcatc
+accactaagacggtggaattcagacttattggcaacttaggatgggactattaaataacc
+cataagatgttgggataaagttacgaaacgaaagggatatagcctgttagataggaaatc
+cccaataaaacatagccggcctccacagcagtgatctattccgccacgcgatatctttat
+accacgcaatataccaataataaaggttaaatgtggttgcgatttaaaaaagatacatat
+cagttgcaccgcgtagcaaatccgtatgtgaagcgtaacctagaattatagcgtctgcaa
+gttctctaagcttcctctgcaagatacaatatgactttttagcttttttactaccaaatc
+tcagaatcttagaaacaggttggtacgtgctactcggaattcccaaagtaccctgctata
+tatgccattccttcattggtccgggctcaccatggggccatcatagtaatagaaggtagt
+aaaactagttgatttccgacttttaacaatcactatcctgacccagatatgggttccgac
+tggcccttactccagtaagggcagacacacagacaacgagaacttgataactttgaattc
+tcaaatcgatcattgcaacgtgacttatttactagcctactcctataattcatacgtcaa
+atacatttcaacggaggaagataataagtaaatattcactaaataatggtcgaaggagtc
+ctttgccaacataagtccacatatgcgctatagattttttcttggggttcatattcaata
+agataaacagcaagagtatcacgtcagcgagtcattgagatcttggctagcattgtgata
+gcatattctacctaaatggtagtctagcacagagtggataagatatcagttagatataga
+caagtactataacagatctcgcttcgttggattgtatggctagctttgatgatatgattt
+tataaaaattgatccagacctgacctggccaattatattcattttttatgagtaaaaata
+gataaccatgaaaatactcaagccccttaggacgtacaaagtggtaacataaatttcagg
+tgttattctgcaaccacacctgttttgggttttcaaaaaggctaagcagattggttttac
+agataatccctgaacactggtatctcccaacgatgtcgttcccaacccttgctgaccttt
+taagctctgctgaagttttgtaaactaggcggaaaatatgttcgatagatccactcgcct
+gaggtagaaattcgtcttagtaacgcctctttggattacacagaatagtgtactgacacg
+tacactgctgcagcagccatacgctaacattaaaattcgttgagtctacatttgttgtta
+ttcggattatgttattgggaatagtatttttattcccctgcgtgaaaccacatggataga
+ttagcctactcctaaagactcccttttggtctacggttcaattctcttactgagtttatg
+ttcgtaattatatcggcgcagtgaatctcctaattatcaccggagttaccagacgccatg
+aacttatggccagaaacattgcatgtggcctacataggattagtatcaagagtttacgtt
+tgcaacgacatttgaccaacttgaccattcctgcttgtagaccgcgggaactcccctgca
+cgcgactatagaagttggtggtggatgtggcttatgccgcaaatatggttttgaaaaaag
+taatctattgcttgatacctgaattgagacatgtataagggctattgccagatgaaaaac
+tgcatataaggtcaaacaatataagaacattatacataggatcttagcgttcctcaggat
+ggtatacgctataaagtctagcttcagcagctaaggagttttgccagtgcggacttccgc
+tggaagattaggtttaaccgccctgacatcttcataaggtcgggcctgattcaaacccct
+ggagtgccgtctcatacttgaattaatcgatggaaaacttcttctagtctaatattatta
+ttaacaaatgacggttcaataaataacaccgtaagggtgggaaactgttaagtgatgaat
+cattttaacctatcatccattagctacagataatgataccccgatccgactagggggtaa
+gtggttgttccgttaggataaaccatgtaaaacgttagagggtttgtagattaattggta
+ttccagataaatgaggtcagggcgagtgatcaattacactgaaaaattgtcagcttgcgc
+ggtagttgttaagacagtataaatgaaggggattcagaagcaagtttctcgattgactga
+atttataaaccagtcgtcaatcatgatttttgtgtcgattaaagcctaaatggtaattta
+aaccattgatatttatcgagtctataaatatctttggttgtatattacttcacaatcacc
+aattctaaatgattcttccactgtgcgggtggagatatcaggacgggttaaggttgacct
+acatcgttttgatacaacaaaaatcaaagcacatggctggggacttctcgatactatctt
+tgagatagtacgggcaagagtgggtgacgcctccctacattttcaagtctatcggataac
+ttctcggtaaaacgctcgcgatatagttttaaagcattgatttaatccacgcaggagcaa
+gttttaccggtcgaatgagaaaattcaacgtaagtgtcatatccagtcatggttagccaa
+aagcatgggttatccaaaaggaataaaacagctcttcaacaaagagatgaggcttcataa
+cttcgatgaatgcgtatggttctgatatatagatcgatgcatgaggacactttattttag
+ccggcgaattaatggaatccatacgttacttatttggacatgacttctaggtgtttttgc
+tgtcccgtttagcgatatttacagattagtatttcgtttctcatagttaattgtatctag
+atactaactcgttgaagacgcataccttgccatttgtacaggacttaactgttccgtgcg
+taatttgaatttcttataggttcttcaaggcacgaatacctcactcatgaccgttcatac
+tctagttaaggtcgggaatactacgtatgcagggaattgtaacctaggagatttacaact
+ctttaaacaagagtcgctgaggtccaggatcaaaacactgaatctcctaacttcgggtgc
+ctccgtaaatcacctagaaacctactcatacatttgcaattttgagatgtaggcgaaaga
+gagaaatctgctttttaacggtatctcttgggattccttttaaaaacacataacgatagt
+aatgtaccaagtaaccaaaagctgggatgtgtctgtgtactgatccgccgtgtcagagta
+gtccgccatgaatattgacgtcaaggctagtgtcatcaggtattgatgttcattgtaaat
+gaaggaatgaactaatgtcaccaagtaaagggggtgaaaatgctccccagggttctacag
+acatagagatggtcagaacacgacccccctctcaacgcagtgtatttgaaatatatggac
+atatctaccttattctgtaattttagatgtgttctgtgtataccgatattgataagtcaa
+taggcttgattacgtatcttaagacaaatctgtttcgcaagtaggaccgcatctttcaga
+ttgtttctttttatgccataacctgcccaggaattcaaaaggttatcgatacccgatatg
+ctgtgaattattattctaatggccactcattcctgcttatatctggaattggcatgaata
+tcttacaacctaaagtctggcgttgcgccagttctacttcgtaccggacaccatctccag
+tcgttaaccgaaggtgggtacgtcacataaaagttcattagaccacactttgtgccgacg
+tatatagatatattacacgtatagggaatgttttctcctaggtgacccgaccttctacta
+aggttgtacatcgtataatggcccattaactacgaggaaagtggtattgacctggtaatg
+cacgttcttcgatatataccgacgaggtaaagtctactattgcaaagtttgacgttatac
+tgataagtttagatttccctggatcgcgcatgaacaatgtatgcgttatctgccatatat
+aacatgttacaaatccttggggatactatcgctactatcatcggaccaaaattaaatagg
+ctagtgtcttatcagaacatcatgtttaccgaactgatctattttccaatttaagctgat
+attacgtccgcgtatttattttagttccccggatgacgattatctgagctacatcataca
+agttagcatactcgccggtgcattgatttcttatttcgctatatcttcaagttcacaggc
+ttcatatagttccaattagcagtataattaggttttgtaactttaaccatactttataaa
+aggttatattgcacaactgatcaagcatccgctataacccgagctttaccagttagcggc
+taataacaaataagatgacttcgtgtcatacgaccgtcatgatcatgctctaacttaggt
+gggaaccaaatttaggcaatgggtagtaataagtataaaatgataccacatatactataa
+caatgaaattatttgtaatccggtttgccaacgtatcccccttcgcgataaattaatgac
+atagggtcatccatgtgccaatcgtgtgtgccaaaatctcaaattcaattatcatcaata
+ttggccaagtgttataagcgttgaaagtgatataggccgccaaaaagtagtctacttaaa
+aaccaatatttatcgttcgttattgctggtagtacaacatcacgagcatttctcttttga
+gttgatttatactatatctgctgatgtgattatgtcccacttacccagaatattaagaaa
+gtcctagattgtaggtatacttgactataaatataatttaagactatacaaataatctgg
+ctacattatgccatcgtagaaactgataacgtagtaacgtcggacactagattttggtcg
+gggagtaatctagcatactaacgaatttgttaaatccgctgaaagtatatgtcattacct
+gcttggcctgtcttcaatacgtttagactattaaggactcatttcgagatccagtattaa
+ttatacgcatccatatttatactgaagacggattgagttaggacgacaagctaaacaaat
+attaagttaaggattagtattatattgtagaaactcgtcgggttggaacgattcatcatc
+atagaatgcgttacttattcagagagacttaattcggttatgactggcagctcacctgga
+aagtaggtgaaaggcaacagaagaatattgttgactgaattctacgggctacgaacgtaa
+ttacaaagcggttcgtaaagagcataaagatcaatacaatggatctctacagtattacgt
+aaataacatacataaacctggtgttgattcgactagctcatagattaatcattaattgaa
+gctacgaagacgcggaagtctgcggagtgagcaaacagtaatcgactgataaatgcttat
+aatatcgcgcttaaatgccgcatggtgtacattaacgtgggggtagtcaaaggaatatat
+ttactaggaatattagttatgcaaatgttgtgtcaatgtgatgtgttttatccagacatt
+ggatgcatggctgtgggggcacaggatacttaccattagttcacctacaagcggcgtgag
+agggtctcagttttagccagcgcagagaagtacgggcctttagacgattaatgctagaat
+tgtcataaacctcgtgaaaagctagttaataatcatggtgctagaagaacacaacttttc
+tataaaccagttctcgactgacagtcgtaactcactatatcgccgctttgtactgtcgca
+aaaaaacctcacatagaaagaaaaatctactgggtgcatcagtagagatcgtgttctgag
+agataaatacaccggatacgatctgcatcgagttcatgtattaggtcaagcttgggactg
+ttgtgccagtagcattttttaacagtcaaagtagggtgagacacgtcatatcataatata
+tgccatcgaggtttaaagtttatatgataagctagcatgcgttgcaatcgtattcttgaa
+tgctccgtggtttgtactaattcctttatagactgagtgtatcgtacactcggtacaatt
+acaaaggatggaagagcaaataggtcttcaattataacagtaccccaccttaatctaaaa
+accagcttcaattagtattaatttcgccaggagtatatatataaatatctaaagactaaa
+agactcgtacttttacaacttacgtcgtagcataattaaatcatgggtaaatgtcatcag
+taagtgcattagaaatactcctttgtaaggatacagtgaatgtgtctcagcaagtcagta
+gaaatggaaattcatactcgattaaggcctataaaactgttgttggtatctacagagtga
+ttaaaattagtgaatcagattacgaaaatgttttcccgctcgcacttacgcgtttagaca
+aaagtacaggtggtacaattggctgtagtagaattttggtataaaataggtgataaaccg
+gatgggtgtgggcgaattcaaaagcggtttttgttccatagaactatgtagttggttata
+aaggttgtaatctcggagattaggttagggcttaatcagaatagtaacaatttctctatg
+taaagtacagtgggtgatcgtatgagttcacgaactcttaatgccatgcctggacaggat
+aaacaatacgcatataacttgacgatcgagcttatatcgacctatttgagaagtttaacg
+ggtcgatataatatacaggtcttaatagccgattttttctagaaaagcaatcctatatct
+tagttaatcagatcaaccccgtgaacgatatatcagcaaactgaacattgtatacaacat
+tcctttttgtccgggtggggactccatttaaagtatctcacctagaactcagcggtaata
+gatgcagtctcttgcccagttacggtaactaaatgttgatacttagaattgctaaatttt
+agtctagacatttccaggtaaaccggtagacgacaatttctctgtcatctgtcataagat
+cgcttagtgtgctcaaattgcaattgagggccctactatagacaatcatcagacttttta
+attaaatagttttccatgaatgtgttgtcaaggcggaccccttcacttttatcacggctc
+ataaatgtcgtatgactgtagtcggtagcggccttcgagtcttcaggggaaatggaaaag
+aaattaggcttctaagatggactataatcgattaggctaattccgttcgcaaatcacaga
+agcaatcttactcaaaattgttggaatcgatagcgaacgcgaccgtgaatgtttaaaagt
+gctcgcacagaattacccaatacctatcatcacgacttaaatacccaaagcagttgtagt
+cgcgtaatagattaagtctgaagcctagagacaaagggatactgggcggggaaacctgct
+ccttcacggtaacatggtaacaacagaatttggttaaggttaaaacgaaatatactcgga
+gtgaattactgttaggtttcgtcatcggatcaataagtagtttccgtgaagacactctta
+tattagatctccgaaattctgacccgtgcattaggcacttggtaggagattccatttgga
+acttgctcaatgtaagccagtaatgttccgaaataattcgctgcaggagcgaggagccgc
+tgaataaaggaccctcgcatcttgttaccttatggttgagggtcaccgttctctgcgtca
+attccagagctggagatacattcatcaacgttacctacgcacagaataaaaagatcgagc
+gctaactcgttttcctaaacacaacggatttagacaaattaccgaatgcgccggagagta
+gcatcttagtgtcatgcctatcatggcggctcagtacgaagagttcaggcatcgaatatt
+gtggtagcccgcactcaaagttccgccattaggtaagctatatattgtggtcagaacttg
+aggacaactatgagctactaaaaataaacaattttgtcatttgttctagatatgtggcat
+tcatcgaacgcttgtaccagaagttacattcgcagcgtgagcgaataaacccgaatgagc
+gtaacattatcaataacatatagttcagatagagaacgaggtattcgacagagaattacc
+caacattggttattaatctatgcagaataatttagataatgtcactacataatattagga
+ccaaaaggtgattccccagaagacaaaacaataaacaatctcacatattcgctagtacct
+atgtatgggtatgatcttctgattggacggggataatttccaggtatattaaaacttatt
+accataatctagacctaagagaggttatataagtaaagagctgtgttccgatagaaaaac
+ccgaccttaaagacttgcgaagtaaattttgctttaacaaaaaaacctacgtaagggaat
+attctgtataaactgaaaagtcaggtgtaactacatgagtcatgtcttcgattaattaca
+atgcgatctcgttattctgatcaactaatatcataaactgccactacatcttgtacaatc
+attcgcaacaatacttttatgtgctaaggtcacgtgcttcctctgctatgctgatttaat
+cagattcataaaggaatacgaataactctggatccattaccacgcaagggatttatttac
+ggctgattactttttggctgttgacagaactgccatgaaagtaagatgtcgcatcttgca
+taaataatagcacctaatatagccgacaaagtgattccgataacagattttaagttgtcc
+agccttgagactccatgaagaccgcttgggagcttccccgtgattagaagaatctaaatc
+ccaagtggatggggggagtttaaatctcagcaccaacaaatagtacttcctctcagagcg
+cgtcatggtcgaaggagcctatcctgatagaggtttgaaagcgcacgcgcatttaactgt
+catattaaattggaatctcgtaagtgtcggcagtacgacaaattttaactgatgtcggta
+tacggagaagaaggaagcacgcattgaagcagctacgcagaactgagaagatgacactct
+aagatacaattaatacaaaaacgttttaagcccaatctatcaacagatgtaagatgtcta
+atacacaagaataaaaccttcatgtcccgatgtataataacagctttatttctgctggtc
+gaggtgaagtagtggaaattactccatcttgctgcgcgtctttatagtgttggctactct
+gtaaccgacgcgtccatccctctctcctagtgatccgtatatccaattagaggataacca
+acatctgcgttaccgacgaatttaaatttttcgactatttaattccgttcaaacccgtat
+tcgtagtaagtgtttcatagatttatgaccgacatcgtgtacgagttgcagtgcatatgt
+agataccactaattgctgatctaggatacatgctttataaacatgcttacttggctattt
+tatttactgtcatgtgggggtttttattttcaacaagtatgtgctaccattggataatct
+ggcttcaaattgaagatatgcgttccaaacttgtctactgtttgctaagtaggagttgtc
+ccattagaactacgcagcacgtggtttgtgatcgaaaagaataattggcaaatacgaggc
+tagccttcaaatttaatgcagattactcctcagaaacacacgtaagcgacgaacgtgatg
+tttactacacaatgcgtatcatagaaattcgtgataatttttgttccaacctttgaatct
+agactgagtggaaaaagatttcaccgggataccgtttatgctggttttaaaaactcgtcg
+aatcatcttataactgcattcaaatggatttctcaatcatctgtacgtcaactgttttaa
+caataacgtcagaataaaccggcacaatgagacggcggtctttcactacaccacaccctt
+aggattataagtgacgtgtggattcgaattctaaggtgacgggatctacaagcctcagct
+acattaggtctgaagatctttcgtatagccgcgtatgttactgtttggatatgggttatg
+ctaatcaacagttgacagcgagtgaaacggccttgcgacctgaaatctttacggttacct
+tttgattcaagacaggatcgacgatggaccacgtgaaatgaattcaaaactgtaacatcg
+cttgtgcctcagcgaccgagtaacgacaagttcacatcctctatgcaactatcattgtgg
+tcattaaggtattcaagattaactaagagtcgaccatatattctagagttttacaattag
+gaaccgttagtctagactaggagcgtgcaacatcgcaggaggtgtggactgtcttgaccc
+aagttgcctgacacatagtgtcttttgcttcatgtccttagcaatgcgatacctcaatcg
+tagttttatcgggataaataacatggtgtttaaccctattaatggtttctattaatctaa
+attgtaaggcagcccttgggtcgaaagcacattaggccacatacacagtatgaaattgtt
+cgagtgtccagaccataattgactaccatggtacacggtgttgctattatgactcccgca
+aaactcttgacagagggaattttggtacattgatgtaatcgatgatttaacagtaggaac
+tagacgtcatccgttagactgagttccgacatgctcaaattgtcaggatttttatccaat
+aactaatggctctcacatgtaaataaaatcacattaacgtcacttagtgatggattcgct
+aaacagatagactatcattcatgaactggcactgtttcgattatatttgcaacatcgaac
+atacttaaagttaaatacgacatcattcaattaaaaaaattcagtacacctctaatgagt
+atcccgctttggaggaaagagtagcactttaaatggacaatttaggccggactttcctgt
+aaatggatgaagtcattgtacagcttgaataaatcgttagggttagtccttacatccacc
+atatgttaatgaataaagcctgagggaccttagagctaacttgtccaacacgttgctcat
+ttacttaataaggttgaaatgtatcagtaagtgacagcgagtgtagattttgaccattta
+actgaccttcacagttttgtcttcagacgtcacttacaccataatgatgacagagcttgt
+agatgcacacactcattcctagtgtaaatcaagtagtagctagattattataaagagata
+ttttctggcgtcgaacgtaacacagagagagtataaggggcatgataatggcttatcaat
+atgtgtaagaaaaagtttttaatatcatctaactcggtggaatgcacacttatggccaac
+tgaccttgggacgagttaagataccataagaggttgcctgtaagttaagataacaaaggg
+atattccatctttgtgtgctaagaacctatttatatttgcagccataaaaacctctgtgc
+tatgcagccaccagagttatttatacaaagaaagagaccatttagatacgttaattctgc
+ttgcgatttattaaacagacatttcacgtccaaccactacaaaagccctatcgcaagacg
+atcattgtattatagcctatgcaacgtagctaagcggccgaggaatcataaaatatgaat
+tgttacattgtttactacatatgatcacaatctttgtaaaaggttcgttcgtgatactac
+catgtacctaactaacctgagatatatgcaatgacttatggggtcagcgcgcaacatccg
+caaagcatagtaatacaaggtaggaaaacttctggatttcccaaggttataatgctctat
+actgaccaagagatccgttacgactcgcaatgaatactctaagggcactcacaaagaaaa
+ccactaattgataaatttcaatgataatatcctgaattgcatcgtgtatgagttacgaga
+agtcgcatttaatgaattagtcatagaaatgtcatagcaggaacataattactatatttt
+aacgatttaatcgtagttggagtcctttcccaaattatgtcatcagttccgatttagatg
+ttttcgggcccttcttagtaaagaagttaatatccaagactagctcctcacccacgcatg
+cacatattcgcgagaagtctgatagaatattcgacagaaatgcgactctagctcacactc
+gttaactgatcaggtacttatagacaagtacgttatcagatatcgcttcggggcattgtt
+gcgctacctttgtgcatagcagttttgaaaaattgttcaagacctgaacgggaaaatgat
+attatttttttaggaggaataatacagtaccatgtaaatactcaaccaccttacgtactt
+cttacgccgaacatatatggcacgtgttattcggctaacaaaactgttgtgccttttcta
+taaggataagcagattcgttttaaacatatgacctgtaaactgggatctacaaaagaggt
+acttaaaataaattgcgcaacggtttagatctgcggatctttggttaaagagcaccatta
+gatgtgccatacttcctatcgcctgagcgagaatttagtctgaggaaccactcttgggat
+ttaaaacaattcggttaggacacctactcggcggatgaagcaatacgataacattaaaag
+tcgttcagtctaattttggtcgtagtacgatgagctgatggccaattgtatttttattaa
+cagcactgaaacaaaatggagactttagactaatactaaagtctcaatgttcgtcgaacc
+ttaaatgctcggaatgaggggatcttcggaagtatagcgccgaagtgtatctcattatta
+taacaccagtgtacagacgacatctaattatggccagaaactgtcattgtgccattaaga
+ggattagtagatagtctggaccgtggaatagaattttgaccaaattgaccagtcctgctt
+gtagacagcgcgatctaaactgcacgagaatatacaagttggtggtgcttgtggctgagc
+acgctaagatgcgtttgtttttacgattctagtgcttcttaacgcaattcagtcttctag
+atccgctattccaacatcaatatctcaatttaaggtcaatatatataacaaaattagaca
+gagcagctgacacttacgaagcatcgtagaaccgatatagtcgaccttatgatgatatgg
+acgtgtccaagtccgcacttccgatgcatcttgacggtgaaccgaaatgaaatcttcatt
+agggcccccatgtgtcaaaccactcgagtcccgtctctgaagtcaagtattactgcgaaa
+aattcgtctactattagtttattatgaacttatgacgcttaaataaattaaacagtaagc
+ctgggaaaatgttaaggcaggaatctttgtaacagttcataatgttgctaaagattatca
+gaccccgtgaagacttcgggctttgggcttcgtaccgtagcataatacatctatatagtt
+agaggcttgcgtgttgttgtgctattccacatatagcagctctgggcgactcttcaatga
+aaatgaaaaatggtaacctggcgacctacttgttaagtcagtttaattcaaggggattaa
+gtaccaagggtcgagtttctctgtatttattatactgtaggcaagaagcttttttggcga
+gatttaagacttaagcctatggtaaaaatttgatagtgagcgactatagtaagagatttg
+ggtggttagtaattaaaattctcctatgctaaatcaggcgtacaatctgagggtgcacat
+ttctcgacgcgtgaaccttcaccgaaagcgtgtggattatacaaatttcaaacatattgg
+cggggcacttatccataatagatttctgtttgtacgccaaactctgcctcacccctccat
+aaattgtattggctagaggttaaattctccgtaaatagagacacatatagttttatacaa
+ttgtttgaatcaaagcacgagaaacttttaaccgtacattgacaaatgtcttcggatggg
+gcagagcatctcttcgtgacccaaatcaatcgctgagcaataagcaagaaaacacagatt
+atacaaagagatctggatgaagatattcgtgcaatcactatcgttatgttagagagttcc
+atgcatgaggactcgttttttgaccaggagaattaagccaagaaataactgacgtatttc
+caaatgaattctacgtgtttttcctgtcacctttagccagtgttaaagatgactatggag
+tttcgaataggttattctatagacattataacgagtggaacacccataccttcacagtgc
+taaaggtaggaacgggtacgtcaggtagttcaagggattttaggttcttaatccaacgaa
+gaaataacgcatcacccgtcattctattgttttcgtcgggattacttagtaggcagggta
+ttctaacctacctgagttacaaatctttaaaaaactggccatgaggtcatggtgataaaa
+tctgaatcgcctaaattcgcgtccctaaggaaatatactagaatccgtctcagaaagtgc
+aaaggttgacttcttcccctaacacagaattctcagttttatagctatctagtggcattc
+ctttttataaaactttacgtttgtaagggtccaactttacaaaagctcggatgtgtatgt
+gtaatcttccgccgtgtaagacttggaacccatgtatattgacggcatggcgtggctaag
+caggtattgatcttcagtgtaaagcaaggtatgttctaatctaacaatgtaaagccgggg
+attagccgccaaaggggtctaatgacatagagatgctctgaaatcgtaccaactataaaa
+gcacgggatttgaaatatagcgacagatcttccgtattctgttagttgacatctgtgctg
+tctttaccgattgtgatttggctttagcagtcatttagtttcgttactcattgctcgtgc
+gatagttccaccgaatatggcacattcgttctttttttccattttactgcaaaccttttc
+aaaagctgatcgataccactgatgatggcattgattagtcgattggcaactatgtcctgc
+ttatatctccaattgcattgaatatagtaaaaaataaaggctcgccttcccaatgggcta
+cggagtacacgaaaaaatcgcaactcgtttaaccaagcgccgtacctaacatataagtga
+ttgagacaaatagttctccagacgtattgagatatatgtctcctataggcaagcgtttct
+aattgctgaccagaaattagaattaggttgttaatactatattcgaccattttattccac
+gaatgtgctattctactggtattgctccgtatgcgatatataaccaacacggaaagtcgt
+cgattgcaaagtggctccgtagaatcatttctggtcatttaccgggagcgcgcttgaaca
+atggatgcggtatctgccatattgttattgttaaaaagacttccgcttactatcgcttcg
+atcatcggaaaaatattaatgaggattgggtcgtataagaaaatcatcttttcagttcgc
+agatttttgccaatttaaccggttatttcgtcagacttggtagtgtagttacaagcatca
+cgattatatcagctacagaattaaactgtcctgactcgacggggcagtgtgtgagtattg
+cgctatatattcaaggtaacaggaggcatataggtcatagtacaaggataatgaggtttg
+ctaactttaaaaattattgatttaacggttgattgaaaatctctgcaagatgacgctaga
+acacctgatgttcaagtttgccgataataacatataagatgaattactgtctttagaccc
+tcatgttaatccgctaacttagggcggaaacaatgttaggctatgcggagtaagtactat
+attatgataccacatagaatttaacattcatatgatgtctaatacccgttcccaaccttg
+caaccgtcccgattaattaagcaattacggtcatcaatgggccaatcctgtctcaaaaat
+tatcatattcaaggttcagctattttggcaatgggtgagtaccgttcttagtgatttacg
+aacccataatctaggcgacttaatatacaagatttagagttacgttttccgggtagtaca
+tattaacgaccatggatcgggtgaggtgttgtattagttatctgatcttgtcagtagctc
+ccaatgtcccagaatattatgtttctactagagtgttcgtatactggaatttaaatatta
+tgtaagactagacaaattttatggatacattaggccatcgtagaatatgatatagttgta
+acgtccctctatagattttcggagggcaggtatattgcttaataaagatgttcggaaatc
+agcggaaaggatttgtaattaactgatgcgcagcgcttaaataagtttagactattaagc
+tatatgttcgacagcatgtagttttttttaccagaaagtgttatactgatgacccatgga
+ggtagctcctcatgataaaaatattgttacttaagcattactattatagtgttcaaacta
+gtaccgttgcatactttaagaatcagacatggcgtttcttatgcagacacacttttttag
+ctgttgacgcccacctcacatccatagtaggtcaatcgcataagaacaatattctggact
+gttttattacccagaagaaagttttttctttccggttcgttaagacaataaagatcattt
+cattcgttctcttaacgatgaactaaagtacttaaagtatccgcctcttgtttcgactag
+cgcatagtgtaataattaaggcaagataagaagaacaggaacgcgcacgtcggagataac
+tctaatagtctctttattccgtttaatatagcccgtaattgcaccatgcgctacagtaac
+ggccgccttcgcaaacctatttatgtaattccaagtttaggtatgcaatggttggggcaa
+tgtgaggggttttatcaagactttcgttgcttcgcggggggcgcaaagcagactttacag
+tagttaaccgaaaaccgcagggagtcgctctaagtgttaccaacccctcactactacgcg
+aaggtactcgattattccttgaatgggctgaaacatcgtgattagcgtcttatgattcag
+gctgatagaagaaaacttattttctatattccacgtatacaatcacactcgtaactaaat
+agttcccagcgttgtaatgtcgctataataaataaaatacaaagaaaattcgtctgggtg
+cataagtacagttagtcgtctgtcacataaataatccgcagtcgatctcattacaggtat
+tgttgttggtcaaccttcgcaaggtggtccaagtagcattgttgaacagtaaaactaccg
+tcacacaaggaatatcataatagatgccatacacggttttacttgatatgtttacagtcc
+ttgagttgcaatcgtagtattgtttcatccggggtgtgtacgaagtaatttagacaaggt
+gtgtagcggtcactaggtaaaatgacttaggatggatgagcatttaggtattctatgata
+acactaaccatcatgtttctaaaatcctcaggaaatttgtattattttaccaacctgtat
+ttatagaaagtgcttttgacttaaagaagccgaagtgttcaaattaaggagtacctgatt
+gaaagaatggggaattgtaatctgtaactcaattacaaataagccgttctaaggattaag
+gctttgtgtctaagcaactcacgtgaattcgaaattcatactcgattaacgactttaata
+ctcttctgcgtatctacagactcatttaaattacggaatatgttttcgtttttggtttcc
+agctcgcacgtacgcgtttacaaataaggacacctggtacaattggctggagtacaatgt
+tggtttttatttgctgattatcccgatccctgtgggcgttggcataaccgggttttcttc
+aagactactttcgtgttgcttatatacctggtaatatcggtgagtagcttagggcttaat
+cacaatactaacaagttctctatggattggacagggcggcatccgttgactgaacgatct
+attaatccattccctgcactggataaacaagacccatttaaattgaccatagagatgtta
+gcgtcatatttctgttcgtgatagggtacatatattataaacggattatgagcagtggtt
+ttctagaaaagcattcatagttaggagtgtatcagatcataccactgaaccatagagcac
+aattctctactggctatacttcattcctttttgtccgggtggggacgaaatttaaaggtt
+ctaacctagaacgcagagcgaattgatcaaggcgctggccaagtgaacggttctaaatgt
+tcttaatgagaattgcgtattttgactattgacagggcatcgtaaaccgctactcgactt
+ggtatctgtaatctgtatgtagatagagtacgggcctataattcaaattcagccaccgaa
+gattcacaatcttcagacgtttgaaggaaagaggtttactggtatgtggtgtcaagcccc
+acccattctctgttatatccgagcattaatgtagtttcactgtactacggtcacgccgta
+gagtcggcagggcaaatccaaaacaatttaggctgagaagtggcactataatagtttagc
+ctaagtcccttcgctaataactcaacaaagatgacgcaaaagtcggcgaatagattgcgt
+tcgcgtaagggtatcttgaatactgatagctctcatggtaccaagaactttcataacctc
+tttatttaccaaacctgttctactagcgttagtgttttagtctgtagccgacacaaaaac
+cgagaatggccggcgtaaccggcgcctgcaagctaacatgggatcaaaactattggctta
+acgtttaatcgaatgagactagcactgtattactctttcgtttcggcagcggatcaataa
+ggaggtgacggcatcactctcttatagtagatatcacttattctcacaacggaagtagga
+tcttccgtcctcattaaatttgcaactggctcaatgtaacactgtaatgttaacaaagta
+tgagctgaaggtcagagcagacgatgtagtaaggtccctcgaagctgcttacagtatcct
+tgaggctcaacgggctatgcggaaattccagacctcgagttacattatgaaacgtgtcat
+tccatctcattaaatagttcgtgccctatcgccttgtaatataaacaaccgtttttgtct
+attttcccaaggagaaggagagtagcagcttagtggcttgcctatatggccccctaagta
+cgtactcggcacgcttagaagattgggctaccccgcactatatgttcccaaagtaggtaa
+cctagatagtgtcgtatgaaattcaggtcatcgatgagagtataaaaatatacaattttg
+gcaggggttatacattgcgggcatgaagagtaacattggacatgaacggacattcgaacc
+ctgtgagtttaataccctatctccggatcattataaagtaaatatacgtcacttactcta
+cgtgcgtttagacagtctttgaaactaaattggttatttttctttcatctagatttgtct
+gtatctaactaaattatagttccacataaagctgattcaactgaagacataaatataaac
+tttctaacatagtagcgaggaaagagctatgcctagcatcggatcatgcgtccgcgagta
+gttcctggtagagttaaaagtttttccagaatctagaccgaacacagggtagtgaacgaa
+agtgcgcggtgaacatacataataccgaacgtaaacaattccgttcgtattgttgctgta
+tctatatttcctacgtaaggctatttgatctataatatgaaaagtcacgtcgaaataaat
+caggaagcgcttcgagtatgtacattcagatctccttagtatcatcaaattatagatttt
+acggccacgaattattggtctagatgtcccaaaaataatttgatgtcagtagcgatcgtg
+cttcctcggagttgaggttggaagaagagtcattatgctataccaagaactctccatcca
+gtacctagaaaggcaggtatgtaccgctcattaattttgcgatcttgacagatctgcatg
+caaagtaacttgtaccagatggcttttataatagaaactaagtttcccgaataacggtgt
+acgataacagatttttaggtgtacagacgtctgactcaatgaacacacattgggacctgc
+cccgggaggagtagtagataattaccttctccagcgcgggtcttttaatatcacaacata
+aaaatactaattaatatcacacaccctcatcctcgatggagcctagcatcatacacgttt
+gatagacaacgccaattttactgtaatatgatattcgaatctagtatgtggacgctgtac
+cacattgtttaaaggagctccctttaccgacatgaacgaagcaagctttgtacaagatac
+gaagaactcagtactggtaactataagagacaatttatacataaaagtgttaagaccatt
+atataaaaagaggtatgaggtctttgtaactacaataatacattcatcgaacgatggaga
+ataacagagttatttctgctgctcgagctctagttctgctaatttctcaatcttgatgcc
+actcgtttgagtcttccattcgctcttaacgacgcgtacatccctctctcctactcttac
+ctatatcctattactggttaacctacatctccgggaaagacgtaggtaaagtggtccacg
+attgtattcacttataacacctagtagtactatgtgttgctgagagtgaggacacactta
+ctctacgagttcaagtccatatggacattacactttttcagcatctaggtgtcatgatgt
+attaacagccgttaggggctatttgattttatcgattgtcggcgtgtgtattttcaacaa
+ctaggtgctacaattcgtgaataggcatgaaaattcaagattgcagttcctatcttgtat
+aatctttcctttggacgagttgtaccatttcaactaacctgcaagtggggggtcatccat
+atgaagatttgccaaatacctggagaccctgaaaagtttatccagattaataataacaaa
+caaacctaagcgaagaacgtcagctttaataaactatcactatcatagaaattcctgtta
+attgttcttccaaacgttgaatagactatcacgggtaatagattgaacacggagaacgtt
+tatccggcttgtaaaatatcgtcgaatctgctgataactcaattatattcgatggagaat
+tcatatctaccgcttagcttttaaaaattaagtcagattattccgccacaatgagaaggc
+gcgagtgcactaatcaaatcacttaggattattacggacgtctgcattacaatgctttgg
+ggtagggttatacaagcatatgattctttaggtctcttgatcgggcgtttaccaccgtag
+cttaatgttggcatatccgtgatcctaatattctgttgtcagcgtgtgtataggaatgca
+caacgcaaatctttaagctgacctgttcatgaaagacaggagacacgaggcaccacctca
+attctatgcaaaactctaacatagcgtggcactatgagtacgtgtaacgacaaggtctca
+tactcgatcctaagataattctcgtctggaaggttttaatctttaactaagagtagaact
+tagtttattgacttttacaattaggatacggttcgcgactctaccacagggcatcatacc
+tggagctctgctatctcgtgaccaaagtggcagcacacatagggtcgggtcctgcatcta
+ctgagcaatccctttaagcattcctagtttgagagccatttagatattgctgtttaaacc
+gattaatggtttctattattataaagtgtaacgctcccattcgggacattgaaaattagc
+aataagacaatgtatgatattcggcgagtctcaacaacattatggtctaccatgggacaa
+ggggttgatatgatgaatccacaaaaaatagtcaaacacccatggttcgttaagtgaggg
+tatccaggtgttataaggacgatctagaagtattcaggtacacggtgttcagacatgctc
+taattgtcaggttgtttataatttaacgtatcgctctctattctaaataatataaaatta
+accgctcgtagggatgctttccagtaaaagatacactatcattaaggttatgcaaatgtg
+gcgatttgatttgaatcttagtacattcttaaacttaaatacgtattatttaaagtaaat
+atattatctaaaccgcttttgtctatccacatttcgtcgaatcacgacctcgttaatgcg
+acaatttacgaccctctttcatctaaagcgatcatctatttcttctgattgatgtaatac
+tgacccttactccgtacatacaaatgatggtaagcaagaatgactgacgctcctgtcacc
+tttcgtggcaatcaactggcgctggtactgaagtagcttgaaagggatatggatgtgtat
+gccaggcttcattttgacaatttttctgtcctgctcagtgttgtctgaagtcgtatcgta
+cacaataatgatgactctcattgtagatccaatcacgctttcctacgctaatgaaagttc
+tagatagtgtaggtgttagacagaggttagcgcctacatccttacacacacagtgttgaa
+cggcaagcataatcgagtatcaatagctgtatgtatttgtttggaatatcatatttctcc
+cgcctttgaacaatgatgccaaaatgtcctgccctagagttatgataaaataactgctgc
+cctgtaacttaagtttacaaaccgatattcaatcgttgtgtcctatgaaaatatttatat
+ttgcaccaagaaaatcatctgtgcgatgaacaaaacacagtgatttataaatacaaagag
+tacatttagttaccggattgcggcttgacatttattttacagaattttatcggcaaaaca
+cttcatatgaactatcgcttcacgataagtctatgatagactagcattcgtagagaacag
+gaagagcaatcattatatatgaagtgttacagtgggtactacatatgagatcattaggtc
+tatatccggccttcctcataagaccttggaaatatcttacatcagagatatcaaaggaag
+tatgggcgaacccagaaaaagccccaaagaatagtaattcatcggacgtaatagtctggt
+tttaactaggggttattgatatttaagctaaaagagttccctgaacactcgaaatgtata
+atctatcccaactaaaaaagtatacctctaattcagaaatgtcattgagattagactgat
+gtcaatacgctaggaggtaagacaagtagaagtttttgatttaggaattgaaatgtaata
+cctccatcttaagttctatattttaaagttttatgcggacttcgagtaagtgcacaaatg
+atggcataagtgcccagttacatgtttgcggccccgtatgagtaatgatctgtttatcaa
+tctctagctactatcccacgaatgcactgatgccagtcatggcgcttacattagtcgaca
+gaaatccgacgatacctatcacgcgtgaactgttctggttcttattcaattcgaagtgat
+ctcagatacattacggccatgcttgcccttcatgtctgctgagcagttttgttataggct
+gaatctcctctaagcgaaattgataggatttttggtggtcgatttagtctgtacctgctt
+attaagattcaaaatgacctacttcttacgccgaaatgatagggatcggctgaggaggat
+aaatatacgctggtgcctggtatttatccagaacaagttgcctgtgtatcagatgaactc
+taatctccgagataaaaaacaggtacgtaaaataaaggccgcaaagggttacatctcagg
+atcgtggcgtatagtccaccattagttctgacttacttaatatagactgaccgagattgt
+agtatgtggatccaagcttgccatgtaaaacatgtcggttagcaaaacgtataggagcat
+gatcaaagaagagttaattaatagtactgcactataattgtcggcggagtaccatgagct
+gttgcccaattcgatgtttattaacagcacgcataaaaaatccagacttttcaattagaa
+ttaactataaatggtccgcgaaccttaaatgatcggaaggacgggatctgccgttgtata
+gaccccaactctatctaatttttataacacctctgtaatcaacaaatcttattatgccat
+cattatgtcattcgccaagtaagtccagttcgagattctctggaccgtgcaatagtattg
+tcaaattatggtaatggaatccttcttctaacacccttagaaaagccacgagaattgaca
+agttgggcgtgcttgtccaggagcaacataagtgccgtttctttttacgatgatagggat
+tcttaaagcttttctctattctagatcccagttgccatcatcaatatctcaattgatgct
+cattatatagttcttatttagtatgtccagatgtcactgaagatcctgcctagaaccgat
+attctcgacaggatcatcagttcgacggggcaaacgcacctatgcacatccatcttgacc
+gtgaaacgaaaggaaagagtcagtaccgacccaatgtggaaaaaaactcctgtccacgat
+atgtaggcaagttttactgcctttaattagtagtcgattagtgtagtttgatattatcta
+ccttatagaatgtaaacagtaacccggccttaatggtttggcaggattctttgtaaaagt
+taataatgttcataaactttatcagaaaacctgaagtagtccgcctttcgcctgcgtaac
+gttgcagattaattcgttttacggagtggcttgcgtcttgttgtccgagtacacatattg
+ctcctctcccccactcttctaggaaaatcaattatgctaacctgcagaccttcttcttta
+ctatctttaatgcatgcccagtatgttcatagggtagacttgctatctattttgtataat
+ctacgaatgatgcttggggcgcgacttttaacaattaagccgttgggtataatttgagag
+ggtgccacgatagtaagagatttccggcgtgagtaaggaaaatgataataggattaagca
+ggcgtaatagctcaccctcctcagttctccaaccctgaaccggctaagtatgactgtgca
+gtattaattttgaatacatattgcagcccctaggatacattatagatgtctctttcttac
+ccaaactcgcccgcaccaagaaagaatgtggattcgattgaggttaaattagccggaatt
+acagacacagattcttgtttacaattgtgggaagaaaaccacctcaaacgttgaaaccta
+cattcacaaatggattacgttggggatgagaatcgattccggtcaaaaatcatgcccgga
+gcaataaccaagaattcacagaggattaatacacttctccatgaagataggactgcttgc
+actatccttatctttgtgtcttccttcaagcaccaatcgtttggggacaaccacaattat
+gccaagaaataacggaaggtgttccaaatctatgagtccgcggtttcatcgcaacgtttc
+actgtgggtatcatgactttggactttagatttgggtattctagagactgtagaaagact
+gcaacaacaagacattcacagggcgaaacctaggaaaggggaccgcacgttgtgctaggg
+atgtttccttaggaatccatacatgtaagaaagaatcaaccgtaattatagtgttttcgg
+ccccttgaattacgtgcatgcctttgctaaaagacctctgggaaatagattgaatattct
+ggacagcagcgaatcctgattatatctcaagcgaatatatgacccgcaagaaggatttat
+actagaataagtctaagaaagggcattgggtcacttcttccactaacacacttttatcag
+ttttataccttgagagtcccatgcatttttatatatatttaactttcgttgcgtaaaact
+ttaaatatgatccgtgctctatctctaatctgaacaacggtatcacgtcgaacaaatcta
+gtggctacgaatcgcgtcgctaagaacggtttcttctgctggcgttagctacgtatcttc
+tatgctaaaaatgtatagccccgcattagcagcaaaaccgggagaatcaaatacacatcc
+gatgaaatcgtaacaaagataaaacaacgcgatttctatgtttgccaaagtgattaagtt
+gtatcgtaggggtcagcgctgatgtcttttcagtttgggttttggatttaccagtctttt
+agtttcggtactatttgatcgggacattcgtccaaacatgatggctcattcgttcttttt
+ttcaattttaatcaaaaccttgtatttacctgatacattaaactgagcatcgcatggagg
+tggagattcccatatatgtaatcatttgatatcctattccattctttttagttataaata
+aacgctccactgcacaatgggagtaggacttcaccaataattagcatctactgtaaacaa
+gcgccgtaacgaaatgattactgattgagaaaaataggtctcaacaacttttgacagata
+tgtatccgatacccaagcgttgctaattgcgcaaaagtaagtagaattacggtcgtatta
+cttgttgccaaatggttattactccaatgggctattctaatccgatggatacgtaggaga
+gagtgtacctacaccgaaactcgtagtgggcttagtggctacgtagaagctgttcgggtc
+agttacagcgtgcgaccttgtaaaatcgatcacggtgatgaattattgttattgtttaaa
+agaagtcccctgaatagcccttagataatacgaaaatttgttatgtccagtcgctcgtat
+atcaaaagattcggttaagttcgcagagttttgccaagtttacaggtgatttactaacac
+ttgggagggtacgtacaaccatcacctggttagcagagaatgaattatacggtcatgtcg
+cgaagggcaagtgtgtgagtattgaccgagttattaaacgtaaatgcaggcatttacgtc
+ataggacatcgagtttgtcctttgcgaaatgttaaatttatggttttttccgttgagtga
+taatagctgcaacatgaagatagtaaaactgaggttaaactttcaccatattaaattata
+tgttcaattacgcgatgtacaaactaatgttaatcagatttaggagcgcgcttaatatgg
+gtccctatcccgactttgtacgagattttgataaaaaatagtattgtaaattcatttgat
+ggcgtagaaccgggcaaaaccttgaaaaaggacacatttaggatgctatttccctaagaa
+agcggaaaatcctggctcaatatttataatagtaatggttaagattgtggcccaatcgct
+gagtacccgtcttacgctttttccaacacataatcgacgagaatgtatttaaatgtttga
+gacttacgttttccgcgtacttattattaaagtcattggagagggtgtcgtctgggtgta
+gttttctcatctgctcaggagctaaaaatgtaaatctattggttgtttctaattctgtcg
+tccgtgtaggctatttaatttttatggtacacttgaatatgtttagccataatgtagcca
+atactacaatatcagatacttgtatacgacctatagacttttgccgaccgctcgtagagt
+gatttagaaagatgttcggatagcacagcaatcgtttgcgaatgtaagcatgcgaagcga
+gtatttaactgttgactattttgctatatgttactctgaatgttgttttttttaccagaa
+tgtgttataatgatcaaccatgcacgttcctactaatcatataaattttgttacgtaagc
+ttttctatgatagtggtctaaagactacccttgcatactttaagattaagacatgcactt
+taggaggaactcacacgttttgagctgttctagcccacctataagccattcgtccgcaat
+cccataactacaatagtcggcaatcttttattacccagaactaacgtttttatttcccgg
+tacgtatcacattaatcttaatttaatgcgtgagagtaacgatgaacgaaagttatttat
+gtttaagccgcttcttgagaatacagattactgttagaatgaaggcatcataactagaac
+accaacgcgcacctcgcacattactctaatagtagctttattcagtttaatatagacagt
+atttgaaccaggcgctaatgttaaggcccccttcgaaaaccttgttatgttattccatgt
+ggtcggaggatttgcggggcgatagcgctgggcggggatcaacaatttcgttcatgcgag
+cgcccccataaccagtaggtacagttcggaaaagaaaaccccacgcactcgctagaagtg
+ttacaatcacatcacttcgtaccgaagggactactgtattccgtcttggggatgtaacag
+actgattacagtcttatgatgaagcctcattcatctaaaattagttgatttattccacgg
+atactatcacactcctatagaaagagttaccaccgtgggaagctagatataataaataaa
+agacatacaatattagtatggctcatgatctacacttactcggatctctctttttttata
+accagtagatcgcattacacgtattgttgttccgcatcaggccctaggggctcaaacttc
+catggtggataactaaaacgtccgtcactaaacgaagatattaatagatgaaatacacgg
+gtttacttgatttctgttcagtcattcacgggaaatcctaggagtctttcataacggcgg
+tcttagtaggaatgtagtcaagctctgtagaggtctcgacggaattggtatttcctggca
+tcacaatttacctagtattggagatcacttaaaataatgttgagataataatcaggatat
+ttctagtatgtgacaaacctctatttagtgattgtgattttcaattaaacaagacgtagg
+ggtcaaattaacgactacatgttggaaagaaggccgaattgtaatatctaactcatgtac
+taagaagaagtgctttcgtttaaggctttctgtctaacattctaacgtcaattcctatgt
+aatactactgtaaccaagttattactcggctgcgtagataaagtctcatgtaaatgacgg
+tttatctgttacttttgggtttcaacctagctaggacgccggtactaattacgacacctg
+cgtatagtgcagggtgttcaatgtgcctttttatgtccggattataaccatccctctccc
+acttggaatatcaccgggttcttaatgacttagttcgtcttccttattttccgggtaaga
+tcgctgtggaccggacccattttgatctagtctaaaaaggtatatagcgtttcgtctggc
+ccgcttacgttcactgaaacttagattaatcaatgcactgcactggattaacaagaacat
+gttatagtgtactgacacatgttagactaagaggtctgttcgggttagccgacttatatg
+tttaaccgattttgacaactgggttgagagataacaatgaagagtgaggactgtagaaga
+tcttaaaactgtaccatagtgctcaattcgctaatggcttgaattatttaattgttctaa
+ccctggcgtcgaatttttttggttcgaaaatacttagcacagcgtattgttcaacgagat
+gcacaactgtaccgttagaaagcggcttaatgacaaggcagtattgtgactattgacagg
+gaatcctaaaaagctactcgaattggtatatggaagaggtatgtactgagaggtcgcgcc
+tattagtcaaattctgccaaagaagagtcaaaagcttaactagtttgatggtatgaggtt
+taatgctaggtggtctataccaccaaaaagtatatgggatatcccagaatttatcgactt
+tcaatcgtctaccgtcacgacgtacactaggcagccctaatccaaaacttttgaggatga
+gtactgccactattatactgtaccatttgtaacttacattttatatcttcaaagaggtag
+atattgtcggccattactgtcacttacactaagggtagcttgattactgatacctctcat
+ggtaaaaagtaatttaagaacctatttttttacataacctctgctactaccgttagtgtt
+ttagtcggttcaagtcacaaaatccctgtagcgcacccctataagcagaaggaaacctta
+atgcggataaaaacttttgccggaaccgttaatcctatgagaataccactcttggaatcg
+gtcctttaggctgaggatatagaacgaggggaacgcatcaatctaggttaggtgagagaa
+ctttgtatcaaaacgcaagtaccatatgccgtcctcagtaaattgccaaatgcagaaatc
+ttacactcttttcttaactaagtatgagagcaacctcactcctgaacagcttgttaccta
+acgagaagaggctttaagtagcctggagcctcaaccggatatccggatttgactctcatc
+cacttacatgatgattacggtcattacatctcatgattttctgagtgccctatagactgg
+gaatttaatctaccctgtttctatttgttaacaaggagaaccactggtcaagatgacgcg
+cttccatttatgccaccataagtaagttctcggaacccttacatgattggcctaccaacc
+tatatatgtgaccaatgtacggtacatagagtgtggcctatcatattcaggtcatcgagc
+tcagtatttaaagattatatggtcgctgggggtattcagtgcgcgatggaagactaacat
+tggaaatcaacggaattgacaacacgctcactttaataacctatctcaggataagtttaa
+tgtaattagacggaactttctctaactccgtgtactaactctttgaaaataatgtgggta
+tttttatttcatctagatttgtctgtatcgaaagaaagtattggtccaaataatcctcag
+taaaatcaagtcataaatataaaatttagatcttaggacagaggaaagtgctttcccgag
+cataggatctggcctacgccagtagttcatgcttgtgttaaaagttgttactgtttatag
+tccgtactcagggtagtgttcgatactcagcggggaactgacatattacactaaggaatc
+aaggcccttcgtatgggtcatgtttatatatttaattacttacgctatttgatcgagaat
+agctatagtaacgtcgtaagaatgcaggatgcgattcgagtttgtaaattcacagatact
+gtgtatcatattattatagatgttaaggcatagaattattggtattgatgtacaaaaaat
+tatgggtgggcagtaccgataggcattacgagcagtgcagcttggaagaactggatgtat
+cctataactagtaagagccttaaaggtactacatacccagggatgttaccatcattaatt
+tggccatcttcaatcttcgcaatgcatactttcttctacaagatgccttttagaagacaa
+aataagtgtcaacaataacgctgtaacttaactctgttgtacgtggaatcaagtctcact
+aaagcaactaacattccgacatgcaaacgcaggactactagattattaaattcgccagcc
+cgcctcgtttaatataacatcataaaaattctaagtaatatctcacacactaatccgcca
+tcgtccatagcatcagtcacctgtcttacacaaacacatgtttaatcgatgttgttatgc
+caagctagtttcgcgaccatgtaactaattgtggaaagctgctaccttgaacgacatcaa
+ccatcctacctttgtacaacagaccaacatctctgtactggtaaatagatctgaaaagtt
+ataaatataactgttttcacattgatagaaaaacagctatgtgctatttgtatatactat
+aataaattaagcgaaacatggagattaaaacagtgttttctcatcctccacctcttgttc
+tgctaatttataattcttgatgccactcgtgtgagtcgtccattcgatcgtaaagaaccc
+gacataaatagatacgacgctgaacgagatcctatttctcctgaaaattattagcacggt
+aactcctagggatagtggtactagttggtatgaacgtataaaaacttgtactactttctc
+gggatgtgagggagcaaactattactcgaccagtgcaacgcattatcgacagtaaaagtt
+ttcagctgatacctgtctggatggattatatgcaggtaggcgagagtggattgtagcgat
+gctcggcgggggtattttaaaaatctaggtgataaaagtcctgtttagccaggaaaagtc
+atcattgcactgcatatcgtcgattagctgtcatttcgtccactggtaccagttcaacgt
+acatcaaagtccgggcgcatccatatcaagttttgcaatagtactccagaccatgaaatg
+gttatccagattaataataacttaatatactttcactacatactcagcgggtattaaatt
+tcactttatgtcaaaggactcttatgtggtcttcaaaaaggtctagagtctatcacgcct
+aattgtgtgaaaaccgagtaacttgatcagccttgtaaaatatagtagaatatgatgtta
+aatcatttatattccagggagattgaatagcttacgattagctggtataatttaactcac
+atgattaagcaaatatctgtaggaccgagggaaagaataaaataaagtaccatgagttcg
+gaacgctgcattacatggcgttgggctagcctgatacaagaagatgagtatggagctctc
+ttcatcgggacgtgacaaccctagcgtaatcttggcagatcccggagcagatgattatcg
+tctaacactgtctttaccaatgcacaacgcatagatttaacctgaactgttctggattca
+ctcctgactacagcctacaactcatttctatgcataactcttaaagacagtcgcaatatc
+agtacctctatacacatcggatcagactagatcataagataagtctcctctggatccttg
+tattctgttaagtacactacaaatttgtttagtgtctgggacaattacgataagggtcgc
+gactagaccacagggcatatgacctccaccgctcctagcgagtctccaatctgcaagcac
+tcatacgctaggggcatgaatcgactgtcaatgcactgtaagatttacgagggtgagacc
+catttagatatgcctcgtttaaccgttttaggcttgataggatgagtttgtcgatccatc
+aaattcccgacattcatattgtccaataagtatatctagcttattcggactcgctaaact
+aaattatggtataaatgccgtcaaccggtgcatttgttcaatcaacaaattatagtcaat
+ctcccatggggccttatggcagcgtatacagctggtataacgaccatatacaactatgaa
+cggactagctgtgaactaagcagattattggatccttgtgtataattttaagtttcgatc
+tatatgctatagtatagaaaatgttccgatcgtacgcttcctttacagttaaacagtcta
+tatcatgaagcttatccaaagctggacatttgatggcaatcttacttaattatgaaactt
+aattacctattattgaaagtatttatatgatcgaataagatttgctctataaacaggtcg
+tccattcacgacctagtgattgcgtaaattgaccaacctaggtaatctaaagcctgcatc
+tatttcttatcattcatgttatactgacccgttctcagtacttaaaaatgatcgtaagca
+agaatcactcacgctcatgtcacatttagtcgaaataaactgccgatgggaaggaagttc
+cgtcattgcgatatcgatgtctatcccacgcgtcattttcaaattggttatctacggata
+actgtgcgatgaactactataggtcaaaattatcttcaatctcattctagatcatataaa
+gatgtccttcgcgattgatacgtctacagtgtgttggtgttacacagagggtagcgacta
+cttacttactaactctctcttgatccgcaagcataagccaggttaaagtgctctatcttt
+ttctgtggattataatagttataccgccttgcatctaggtgcccattaggtaatgcccta
+gtgttttcataaatttactcctgccatctaacgttactttaatttcccagattcaatagg
+tctctcatttgaaaattgttatatgtcaacaaagaatataatagctgagtggaacaatac
+actgtgagggagtaatacatactctaaattttctttacggtttgcgcctgcacagttttt
+tttatctatgtgatccgcataaaaagtaatttcaacgttccattcaagttaagtcttggt
+gacactagcattaggagagatcaccaagaccattatttatttagctagggtttaagtcgg
+ttagaaatatcagataatgaggtctttatccggccttacgcagtagaaattggaaatttc
+gtaaagcactgagttcaatggaagtatggccgaacccacataatgcacaaatcaagtcga
+tttcttccgtccttttagtctcctgggaactacgggttattcatagttaagctaaatcag
+ttaacggaactagacaaatgtataatagttcccaaatatatatctataaatcttatgcag
+ttagggaatgcagatttgaatcatggcaatacgctagctcggaactcaactacaagtgtt
+ggatgtacgaattcaaaggtattacatccttatgatgttcttttttggatacttttatga
+cgacttccacgaagtgaaattatgttcgaatatctgaacagttacttggttgagcccaag
+gatgacgaatgttctgtttataattctcgtcataatataaatacaagcatatgaggccag
+tcatggagctttcatttggactaacatttccgtagagtcatatcacgcctgtaatctgat
+ccgtctttttctattcgaagtgttatcagatacatgacgcccttgcgtgacattcatggc
+tcctgacatcgggtcttttaggctgaatctaatctaacccaatttgtttggattgtgggt
+cctccattttgtctgttaatgcttattaagattaaaaatgtactacgtatttagacctaa
+tgattgcgatacgctgtggaccattaatataagctgcgccaggggatttttccagatcat
+ctggcctgtgtatatgttcaaatctaatagccgagagaaattactccgacggaaaataaa
+ggcagataagcgtttcagagcaccatcgtggcgtttagtcaacctttagttcggaattta
+ttaatatacaatctcactctttggacgagctccttaaaagatgcccttgtatatcatgtc
+ccgtacctaaaagtataccagcatcatcaaagaacagttaaggaatacgactgctctata
+attgtccgaggagtaccttctcatctgccaatagtcgttgggttggaaaacaacgcatta
+atatgccacacttgtcaattagaagtttctataaaggggacgagtaactgatttgagacc
+tagcacggcagaggacgttcgtgtgacaacatctctttataagtttgagataaaatcgct
+aatctacaatgattatttgccaatcattatcgaatgcgcaaagtatctcctgttcgtgat
+tctagcctaaggccattactatggtcaaattatgctaatcgaagcagtcttctaacaccc
+ttagaaaagcaaacactattgaatactgccgccgcattcgccagcaccaacataactgca
+cgtgcttttttccatgattggcattatgaaagatttgatctatgattcttaccagttgca
+atattcaatttagcatgtgttcctaattattgtgttattatggtctatctcatcatgtaa
+atgaagatcatgacgtcaacacagattctagtcaggatcatcagttcctcggggaaatcg
+cacctaggaacagccttatgcaaccgctaaacaaagcaatgaggatgtaccgacaaaagc
+tcgatttaaaagcctcgaaacgagatgtacgaatcgtttactgccttttatgaggagtcg
+agtactgttggttcatatttgctacatgattgtatgtaataacgatcccgccctttatcg
+gttcgatcctttatggcgataagttatgaatcgtcagtatctttagatcaaaaactcaac
+tagtacccagttccccggaggaacggtcatgattaatgcgttttacggtctcccgtccct
+cttcttgtcagaggaatcagtttcatccgatcccactcgatgattggtatagctatttgc
+cgaaaagccacaacgtattcggtactatcttgtttgattcccctgtatcttaattcgcga
+cacttgatatcttttgtgtttaatcgacgaatcatcctgggggcgacacttgttacaatt
+atccagttgcgtttaatggctgtgggtcacaagattgttagacaggtcccgcgtgtcgta
+ggaaattgataattggagtttgcaggacgaatagctcacccgcctaagtgatccaaccct
+catcaggataactatcactgggcagtattatttttgatttcatatgccaccccctaggag
+actgtagtcatgtatctttcttacccaatctagcccgaaacaagaaagaatgtcgattcc
+agtcaccttttattagaccgatttacacacaaagtgtcttggtttaaaggctggcatgaa
+tacatactcaaaagttgaaaacgacttgctctattcgattaccttcgcgatctcaatcga
+ttacgctaaattttaatgcccgctgaaatatccaacatttaaaacaggattaattctctg
+atccatgaacttaggactcattgcacgtgacttatctttctctcttaattcatgctccaa
+tacggtgggctaaaccacttttatcacatgaatgtacgcaacgtgttaataagctatgag
+tacgcgggggcagcgaaacgggtcaatctgggtatcttctattgggacggtacatttcgg
+ttttatagactatgtagttacacggcatcaacatgtaattaaaacggcgtaacctaggaa
+agccgaacgcaccttgggattgccatgtgtccggaggattacatacatctaagaaacatt
+ctaaactatgtatagtcgtttacgacccttgtagtacgtgcatcccttggcgaaaagtac
+tctgggtattagagtgtatattatcgacagcaccgaatcctcattttatagcttgacaat
+ttatgacccgaaagaaccttttataagtctataagtatatctaacgcaattgcggcactg
+agtccactaactatctttgagcagtgttatacagtgagacgccatggaaggggtttatat
+attttactgtcgttccctaaaaagttaattatcagacctgcgcgatctcgtagatgaaca
+acgcgatctagtcgaaaaatgcttgtggctaccattccagtcgagatcaaccgtttctgc
+ggatcgcgttacattccttgcttatttgcgataaatcgatacaaccccattaccagaaaa
+acccggagaatcaattactctgcagatcttatactaaaaaagagattacaacccctgttc
+tatgtgtcccaaagtgagtaacgtggagcgttggggtaagagcggagcgattttaacttt
+cgcttttccattttccagtattgtactttacgttatatttgagcggcacattcgtcaaaa
+catgatccatatggactgaggtgtttaaatgttaatcaaataattgtattttcagctgac
+tttaaaatctgcagccattggaggtggagattccaatagatgtaagcaggtgatatcata
+tgcaattcttgtgacttattaagataccagacacggcacaatcgcagtagcacgtaaaca
+ataatgacaatcgacggttaaattccgaacgtaagatatgtttacggatgcactaaaata
+ggtagcaacaacgtttctctgagatgtataagttaccaaacactggagaattccgctaaa
+ctaaggacaatttccgtcgtattaattgttgacaaatggttagtaatacattcgcagtgg
+ataatccgttgcatacctagcactgagtgtaaataaaaccaatcgactactggcatttcg
+ggctaacgactagatgttagcctatgtgaaagcctcacacatgcttattgccttcacggt
+gagcaatgtttcttattcgttattagaagtcacctgtagagacagtagagatgacctaaa
+tttggtttgtccagtcccgaggtgatctaatgattaggttaacttagaacagtggtcaat
+tggttaaagctgatttacgaacacttccgaggggtcgtaaaacattaaactggtgagaac
+agtatgatgtattcggtcatctagacaaccccatcgctgggagtttggacagtgttatga
+ttcgtaaatccaccatgtgtccgaattcgaaatcctgttgctccggggagatagggttaa
+tttaggcttttttacggtgtggcatattagctcaaacatcaacattcttaaaatcagcgt
+aaacggtcaccagttgatatttgttctgctaggaagcgatgtacaaaataagcttaataa
+gatttaggtccgaccttaatttcggtccatagcacctctttctaagtgttttgcttaaat
+aattgtattgttattgattttctgcgagttgaacacggaaaataagtcaaaaaggacact
+tttaggttcatatgtaccgatgaatgcgcaatagaatcgagaaatttttagattagtaat
+cgtgatgattgtggccaaatcccgcactaaacggctttcgctgtttccaaaaaattttag
+tccactaggtatttaaatgttggacactgaacgtggaagccgtcgtattatgaaactaat
+ggcagaggggctcctctgcgtgtactttgagcagatgctatcgtcagaaaaaggtaaatc
+ttttggttctttataattctggcgtccgtgtagcctagtgaatgtgtttggttcaagtga
+atttgtttagccagaatggaccaattacgtcattagctgttacgtctatacgaaatatag
+actgtggacgacccatcgtagagtcatgtagttacatgtgaccttagaacaccaatcgtg
+tgcgattgtaagcaggacaacacagtattgtactggtcaattggttcatagatctgacta
+tgaatcttcgtttttgtacaacaatctcggtgaagcttcaaaaagcctccttcctaataa
+tcagttaatttttcgtaaggttcctgttcgaggttagtcgtataaagacgaaacggcctt
+aatgtaacattaactattccactgtaggtggatctaacaaggttggacatgtgctaccaa
+taagataagaatttcgtccgcaatacaatatctacttttgtagcctatcttggattaaca
+acaacttacgttggtatttcaccggacgtatcaaatgattctgattttaatgactgagag
+taaacatcaacgaatcttatgtatctttaagccgctgcttgacaagtcacattactgtta
+gaatgaacgcttcattactacaaaacctaccaccaactcccacattaatattatactaga
+tgtttgaagtttatttgacaaaggttttcaaaaagcacagaatcgttacgaacacgtaca
+ttaaattgttagggtattaattgtggtcggtgcatttccggccccatagcgctccgcggg
+gagaaactatggccttcatgacagcccccccataacatctaggtaatggtcggataacta
+taaacaaccctctccagagaactgtgaaaataaaatctcttagtacacaagcgtatactg
+gtttaagtcttgcccatcttaaagactcttttcactattttcttgatgcctcattcttct
+aatattaggtgattttttaatccgagaatataaaaagacgatagaaagtgttaaaacacg
+gcgtagcgacatattttaaagaaatgaaatactttttgactatccctcatgatctaaact
+tacgcggagctatctttttgtataacatgtacagagaattaatccgatgcttcttccgat
+taaggacatagcgccgaaaacgtcatggcggcttatcgatatcgtaacgcactataccaa
+gtgattaagtgatcaatgaatacgggtttcgggatttctgttaagtcatgcacggcaaat
+acttggagtcttgaataacgccgcgcgtagtacgaaggttctcaagctcgcgtgacgtat
+agaccgtattgctatttcctgccttctcaattgtccgaggattgctgataacttaaaata
+aggttgagtttttaataacgatttgtcgagtttgggaaaatcctcgtttgtgtgtttgtc
+attttcaagttatcaagaactacgggtataatttacgacgtaatgttggtttgatgcccg
+attgcgaatatcgtacgaatggtatttgtacaactgctttcctttatcgattgctcgaga
+acattataaagtctattactatggattaagactgtatacaagtgtttaagcggagcccgt
+gataatctataaggttttggtacctttatctgttacttttgccttgaaacatacatacgt
+acacgggaatatttacctaaacgccgtatagtccagcctcgtatttgggccgtgttttgt
+cagcattttaaactgaaagcgcccacttgcattataacccggtgcggaatctcttagtga
+ctcgtcaggagtttacgcctttgagacctctcgacaggacccattttgatctagtcgtta
+taggtagagtgcctttcctatcgcaccattaccttctagcaaacttagagtattcaatga
+aatcatatcctgtttatactaaatgttataggctaatgacacagctgacactaagaggtc
+tcttcgggttacccgaatgagttgtttatacgatgttgacaactcgggggagtcatttca
+atgaagactgaggactcttgatcagattaaaacgcttaatgactgataatttagattatg
+ccgtgtattatttaagtgggcgaaccctcccctagaatgggtttcctgagaaaagtctta
+gaacacagtattctgaatccagatgcaaatcgctaacgttagtaagcggctgtagctctt
+ggcagtttggtcaatagtcaatcgcaatccgtttaaccgtctactattcctagagcgaag
+agctatgttctgacacgtccccaatattaggcaaaggctccaaaagaacagtcaattgat
+taactacgggcttggtttctccgtgaatccttgcgccgctataccacataaaaggatagc
+ggtgataccacaagtttgcgacgttaaagcgtcgaccctcaacaagtacactagcaaccc
+cttagcaattaattttgtccatcactactgccaagagttgactggaccagttggaaatga
+catttgatatattaatagagctacatattgtaccactttactgtcacttacactaaccct
+agcgtgattactcatacatatattcgtaaattctaagttatgatactagttttgtaaatt
+taatcggcgaagacacgttctcttgtacgagcttcaactaaatatttcactgtagccaac
+cactttaaccagaaggataccttaatgccgatataatattgtccaggaaacgttaatact
+ttcacaagacaaagcttggaagaggtactttacgatcacctgatagatcgaccggaacga
+ttctatataggtttggtctgagaaatttgtagctaaaaccatgttccataggaactcctc
+tgtaatgggcaaaatgcagatagcgttcaatcgttgcttaactatctatcacagcatcct
+aactcctcaacagcttctttcctaaagacatcagcaggtaagttgacggcacccgataac
+ccagagcacgattggaatctaatactctgtatggatcattacgctaagtaaatataatga
+ttttctgactcaaagttacactgcgaattttatattaactggttctatttgttaaatacc
+acaacctctcgtcaacaggtcgcgatgcaagtgatccaaaaatatctaacttataccaac
+cattacttctggcgcagaaaaacatagatatctgaacaatcgaccgttaagactgtctcg
+ccgatcttaggaacctaatactgctcagtagttattgtttatttgggccatccccggatt
+atgtcagccatggaacactaaaagtcctaatctaacctatggacaaaaagctcactttta
+taaaattgctcaccttatgttgattgttatttgtccgaaatgtctataactcagtgtact
+atctattggaaaattatggccggagttttattgaatatacttttgtatgttgagaaagaa
+tgttgtcgtaataattatcagctggaaaatcatctaatatatattatattgagatattac
+gacagacctaagtgctttcccgtcatgagcagatggactaacactcttggtaatccttct
+cgttttagttggtaatgtttagtctaagtaatatcccgactcttacttactcagagcgga
+aatgactttttaaactaacgtttaaaggcacttagtatgcgtcagggttatttttttaat
+tacgtacccttgtgcagagagtttagctattcgatcctacttagtatgaaccatgagagt
+acaggttggtaattcacagagaaggtcgagaagattatttttgatgtttaccaatactat
+gaggcgtattcatcgaaataattttatggctgcgcacttcacatacgcaggaagaccact
+gcagcttgctagatctggatgtatcattgtacttctaagagcctgaaaggtaatacattc
+ccagcgagcgtaacagattgtatggggacatattcaatcttagcaatgcattcgttcttc
+gaaatcaggcatttttgatgtcataagttctgtcaactataaccctggaactttaatctg
+ttgttcgtcgaatcaaggatcaagaaagcttctaaaaggcccaaagcaaaacccaccact
+acttcagttttaaattagaatcacaccctagggtattagataataattaaatgtcttagg
+aagagatatcaaaagatgcagacatcctcaagtgaataagtctccggtctttcacaaaca
+catggttaagcgatgtggttttgactagagacgttcgccaccatcgtaatatttctggtt
+acctgcgaacgtgaaccaaatcttacttcatacattgcttaaacagtacaacttatctct
+tatcctatagagatctcaaaagtttgtatttttactggtttcaaattgagagaaaaactg
+cgttctccgatttctatattattgtttaaatgatgccaaacatccagtttaaaacacggt
+gtgatcagccgactcagattcgtatcctatgttagaatgagtcatcaaactacggtcacg
+cgtacattacagagtaaactacacgaatgaaagagataagaagatgaaagagttaatagg
+tctcctgttaattatgagaaccctaactactacggattggcctactagtgggttggaacg
+gatataaaattcgactaagttcgcggcatgtcaggctcctaaatatgaagagaactcggc
+atcgaattatccacagtaatagttggaacatgattcctctatgcatggtgtatatccacg
+tacgccagtgtgcagtgtagccatgcgaccacgggcgttgtgaatattcttcctcagaaa
+aggactgttgagcaaggaattggattctgtgaacggaatatagtcgagtagatggaattt
+cctacactgcgaaaaggtcatagtaaatcaaacgccgcgcgcagacatatcttcttggca
+attagtactccactaaatcaattggttataaacttttagaatatctttatataagttcac
+tacttacgctgcgggtagtatatttaaagtgatgtcttaggaatcttatggcggcggaat
+aaacggcttgactatagataccctaattctggcataaccctgtaacgtgtgaagcatgct
+ttaatagacgactagatcagcttatagaatggatatgactgccacattgaagagattaac
+attagcgggtataatgttacgaacttgtttaacaaaatagctctaccacacacgcatagt
+ataatataaaggtcctggagttcgctacgagcctggaattgcagttcccctaccctgagt
+aaacaagatcagtatggacctatcttctgacccacgtgtaaaaactaccgttagcggccc
+tgagaacggtgaagttgattatcggctaacactcgctttaccaaggaacaaacaattgat
+ggaacaggtaagcggctggattctatcctgaatacagcataataatatttgctttcaata
+tatagttatgacactcccaatatcactaactctttacaaatcggatatgaagagtgaatt
+agagatggagccgatcgttccttgtattctggtaagtactcgactaatgtgtgtagtcta
+ggggtaaaggtccttaaccgtcgagtctagaactcacgcattatgaaatcctccgagcat
+agagactctaaattcgccaagcaataagtcccgacgcgaaggatgagaagctcattgaac
+tgtaacatttacgtcgggctcaccatgttacatatgcagcgggtaaaagtttttgcctgg
+agtggttgagtttcgcgatacataaaaggccccactttcatatggtcaaatatctatatc
+gtgctttggacgactcgataaactaaagtagcctagtaatgccctaaaccgctgcatttg
+tgcaataaaaaatttagagtatatataacttccggacgtatggctgccttgaatcctcgg
+atatcgtccttatacaacgatgaacggtatagctcggaactatgcagattaggcgatcct
+tgggttgaatttttagtttccatagatatgagttagttttgatatggttaccatacgtcc
+ctgcattgaaacttaatctgtatattgattgatccttagcaatagcggcacatttctggg
+caatatgacttaattaggttacggtttttactatgatggatacgttttatatgatagaat
+aacagttgctatttaaacaggtactacattcaactaatactgtttcactattgtgtccaa
+catagggaatatattgcctgaatagatgtattatcaggcatcttttacgctccaggtaga
+actaattaaaaatgatccttagaaactttcaagcaacataagctaaaagttacgccaatt
+ataagccacatcggtaggatcttcaggcattcccatatccttctctatcaatcccgtctg
+ttgctaattggttatctaagcatatcgcggcgagcatctacgataggtataaagttgctg
+ctatctaattcgtcataatatatacatggaattacagattcatacgtcttcagtctcgtg
+gtgtttctaagagcggacccaagaattacgtaatatctctctcgtgttacccaagaagtt
+gacacgtgattgtcagctatctttttctggcgatgttaatagttataaacaattgcatat
+agctgcaaattagctaatcaaatactcgtttcttaaatgttatcagcaaagctttaggtt
+ctgtaatttcactgtgtaaagagggcgctaagttcaaaattggtttttggcaacaaacaa
+tttaatagcgcagtgcaaaaataatatctcagggtgtaattatttctctaattggtcttt
+acggttggaccaggcaatgggttttttatctatgtgataccaattaaaagtaatttcaaa
+gtgacattaaacttaagtattgctgtcaagaccattacgacacttcaccaacacatttat
+gtattgtgctacgcggtatggcccgtagtaatttctgatattgaccgcgttatcagcaag
+tacgctgtacaaatgccaaatttagtaaagctctgtgtgcattccaaggtgcccacatca
+cacattatcaacatatcatgtcgttgtattacgtccttttactagcctgggaaataccgg
+tgattcagagtgaacataaatctctgaaagctactagacaaagctagtatagttaaaata
+tatatttcttttaatattaggatctttgcgattgcacatttcaagcatcgcattaaccta
+cctccgtactcttctacaacggttgcatgtacgatttctatgcgatgaaatacttatgtt
+cttagtttggggttactttgttcacctagtcctcgaacgcaaattagcttcgaatatctg
+aaaagtgtatgcgggcaccaaaacgatctcgattcttaggtttataattatagtcagaag
+ataaatacatgcatatctggacactcttccacatgtcatgtcgactaactttgaactaca
+gtcatatatagactgttatctgatccgtatgtgtctattactactcttatctgagaaagg
+acccaatggagtcacagtaagcgatcatgtcatcggggctttttccctgattataagatt
+acactattgctgtgcttggggcctcctactttttctatcttaatcattttgtacattaaa
+aagctaagaagtaggtacaacttatctttcccatacgagctggaccattaatttaacagc
+cgcaaggcgagttttaatgttaatctggaagggctttatgttctaagcttttagcactga
+gaaattaatccgtaggaaattaatcccacataacccggtaagagaaccttacgccccgtt
+actaataatgttctgcgcaatgtaggaagtgacaagctcactcttgcgacgagctcctta
+atacaggccctgcgttatattcgaccgtacctataactagaccaccatcttaaatgtaca
+gttatggttttcgacgcatagagtatgggaccacctcgaaatgctcagctgcaaattgta
+ctgggggtggttatcaaacatttaatatgaatctatggtaaagtactagtttatagatag
+ccgaacactaaaggtttgcagaccttcctcccctgaggaacttcgtgtcacaaattagat
+tgagaaggtggtgataaaatcgcgtatctacaatgatttggtgcaaatatttatcgattg
+cccaatcgttctactcgtactctttatagcctaacgccttttcttggcgctaattagcct
+aatccaagaaggagtctaacaaaattacttaaccatactcttgtctattcggcccacgca
+tgcgcaagctcaaaaagttctcaacgggcgtttttacttgagtcccaggaggtaacattg
+gatctatgagtcttaacagtggaaatatgatttttagattgtgttcagatttattgtctt
+attttggtctatctcatcagctatagctacataatgacgtcttaactgtttcgactaacc
+ttcagatctgactaccccaaatacaacatagcaaaagaatgatgctaacgcttaactatc
+ctttcacgatcttaacaaaaaagctccatttaaaagaatcgaaaacagatctaccattcg
+tggaatcaatttttggacgagtactggtcgggtcgtgcttatttgctacaggattgtttc
+gtataacgttcaagcactttagcggttccatccttgatggcgttaactgatgatgcgtaa
+gtttatggtgatctaaaactctactacgaaccaggtcccagcacgaaacgtcatctttaa
+tgagtttttaggtctccaggcactaggctgcgaagtggaatatgtgtcatcagagacaaa
+tagatgattcctatagctttttgcagttaagccactaagtaggcggttctatagggtttc
+attcaaatcgatcgtaattcccgactctgcatagcgtgggtcttgtatagaccattcttc
+aggcccgccacaatggtttcaagtttcaacttccgtttattggctgtccctcaatagagt
+cgttctcagggcacgactctcgttcgttattcataagtccagtttgatccacgaatacag
+aacacgcatatctgataataaaagcttaacgataactttcacgcgcatggtttatttttg
+atttattaggcaaccaaataccagaatgtagtcagcgatatgtagtaaaatttagacaaa
+cataaaacaaagtatcgccattacagtctcctgttaggagaacctttttatcaatatgtg
+taggcgtgtattggcgcccttgatttaataataattacggctaaacgtattgatattttc
+caggaactgccccatctcatgagatgaccctaaattttattcacacctcatttttaattc
+ttttatatcacgattatttatctgagcaagcatctttgcaagcattcatagtgacggtgc
+tgtctctatgaatgcatgctaatatacggtgcgctaaacatattggttcaattcaatgta
+agctacctcggaatttgcttgcactaagacggggaagccaaaacggtaaatcgccgtata
+tgctagtgccaagggacttgtccgttggagtcactatggagttacaagcattataaatct
+aaggaaatcgcagtatcagtccttaccccaaagatacttcgcattccctggggtacggac
+catgaaatacttctttcatacatgataaacgatggagactcggttaccaccctggtagtt
+actccatcaattggagttaactaagatcgctattacaggctttattagccaatcatcaca
+agcctctttttagagattcacaagttagcaaaccaaagttcctttgataagtctttaacg
+agatctatcccaattccggctaggagtaaaatttatatatttgagatcggggttaaagtc
+acacgcaatgcaaggggtttttatatggtaatgtccttccctaattaggtaattttcaga
+cctccgagagagagtagatcaacaacgcgttatactcctaaaatgcttgtcgataacatg
+acactacagatcatccctggatgagcatcgactttcattacttgattagttcagttaatt
+cgtttcaaaccattttcaacaaaatcccccagtagatatgtatatgcacatcttagacta
+aataacagttttcataccctgggatttgtgtcactatctcaggaacgtcgagacgtcccc
+tatcaccgcagcgagggtaactggccctgttccattgtaatcgatgggacgggacgttat
+attgcagacccaaagtagtaataaattcagccatatggacggagggggggaattgttaag
+aatataattcgattttcagctgaatgtaaaagctccagccattcctcctccacttgacat
+tagttcgaagaaggtctgagaattggaattgcttgtgacgttttttgtttccagacaagg
+aaatagcccagtaccaagtataatattatgacaatagaagcttaaattcacaacgtaaca
+tatctgttagcatgctctaatagaccgagaaaataagtgtctatgtgtgcgagaactgtc
+aattcacggcagtagtcacctaatctaacgtctagttcccgactatgaagtcttcacaaa
+tggttagtaataatttcccagtggagtagaagtggcataacgtgcactctctgttaataa
+tacctttagactactcccatttcgccagaacgtcttgatggtaccctatgggaaacactc
+acacatgcttattgcctgcaacctcagcaatgtgtcgtatgcggtatttctacgaacagc
+tagtgaaaggactgatgacctaattttggtttctcaagtccagacgtgatattttgatga
+ccgtatctgacatctctgggcaattcggttaacctctggtacgaaatagtccgtcgcgta
+ggtaaaaatgataatgctgtcatcactatcatgttttagctaagctacactaccccatcg
+ctcgcacgtggcaaagtgtgaggattccgatatcatccatgtgtacgaattcctaatact
+cttgctcagggcacttagggttattgtagcctgtgttaccgtctcgcatattagatcatt
+aatcaacagtcttataatcaccgtaatcggtaaacagttgttatttgttctgataggtag
+acagctaataaagatgctgttgaacagttacgtcccacctttattgccctacagtgaaac
+tagttcttactctgttgctgtaatatgtctagggttattgatttgctgccacttcaaaac
+ggaaattaagtcattaacgaaaatggttccttcataggtaaagatcaatccccaattgaa
+gccagaaattttgagatgtcgattcctgatcattcgccaaatttacagctcgtaaacgag
+ttccatgtgtaaaaaaatgttgagtccactagcttgtttattctggctcaaggtacgtgg
+aacacgtagtattttgatactaatgccagacccgctacgatccctgtactgtgagcagag
+ccgatcctcagaaatagctaaatcttgtgcttcgttagaagtctcgactacgtgtagcct
+agtgtttgtgttgcgttatagtctatttgtggacacagtatggtcaaatgacgtcttttg
+atctgacggcgttaacaaagatactctgggcaacacacatacttctctcatgttgtttct
+tcggacctttcataacctttcctggcacatggttagctgcacatcacaggattgtaaggg
+tctagtggttcagtgagcggaatatcattcgtcggtggtgttaatctatctcggtgtagc
+ttataaatgcatccgtaagaatattatgtttatttgtcggtacgttcatggtagtggtgt
+cgccgatttagacgtaaaggcatgtatggatcttgatctatgcaaaggtaggtccatcta
+tatacgttgcacagcggatacaaataagataagaatttactaacatttaaattttcttat
+tgtcgagcatagattggaggaaaaacttatttacttggtatttaaacggaagtttctaat
+gtttatgattggatgcacggacagtttactgcttactttcttaggtttcttgaacaacag
+gatgcactagtaacatgtctcgttcatgcttccattaagttcttcttaaacttacacaaa
+ctacctaatttagagttgacgagatggttgaacgtgttgtgacaaacgtttgcaaaatgc
+acagtatcgttaccaaaaagtacatttaagtgtgtgcgtaggaattctgctacgtccatt
+gcaggccacattcacatcccacccctgaatatatggactgaatcacacacaccaaatttc
+atctaccttatcgtagcataactattaacaaacatatacagacttcgcggtaaataaaat
+atattagtacacaaccgtatactggttgaactattgcccagctttaagacgcttttaact
+aggtgcttgatcaagaagtattattatatgacggcagtgtgtaatacctgaatagatata
+gacgttagattgtctgaaaacacgccgtagagacatttttgttagatatgtatttctttt
+tgacgagccagcatcttagtatctgaagacgagctatatgtttgtagaaaatcgactgac
+attgtatacgaggcggcgtaagattaaccaaattccccagaattagtaatggcgccttat
+cgatttactaacgatatataacttgtgatgttgtctgcaatgtatacccgtgtaggctgt
+gctcttatcgaaggaaacgcattgaagtccaggctggatgaaaccaccgcgtacttccat
+gcgtctatacatagcgtcaccgatactacgttttgctatgtaatccattctaatgggtaa
+gaggattcctcttatagtaaaatatgcttgactttttaagaaccattgggagtggttggc
+aaaataatagtgggtgtctttctcagtgtatagttttctacaactacccctattaggtta
+caagtaatctggctttcttgccacttggcgatgatagttagattcgtatttctacaacgc
+agttactgtatccatggcgcgagataattagatacgatttgaatttggatgtagactcgt
+tactactgttgtagaccagcacgtgagtatctagatgggtttgctaccttgttagcggac
+ttttgccgggaaaaagacatacgtacaaccgtatattttactataagcagtattggccac
+cctcgtattgcggcagggtgtgctcacctggttaaaatgaaagagaaaaattccatttta
+aaacccggaggaatctattactgacgaggaaggtgtttaacccgttgagacatctcctaa
+cgtaaaaggttcatattctagttattccgagagtcactttcctatccaaacatgaactga
+tagcataatgacaggttgaatggaaagcatatcctgtttattctaaatctgtttcgctaa
+tcaatatgctgtcacgaactcggagcttacccttacaactatgtgttctgtttaccaggt
+gctaatatcccggcactcttttcatgcatgtcgctcctagcgtcatctgatttaatagct
+taatgtctcatattttacagtagccagtgtagtatggaaggcggcgaaccagcccctaca
+ttgggtttcctgacataagtattacatatcacttgtctgattacacagcaaaatcgctaa
+ccttactttgcgcatgtagctattggaactttgggctagtgtctatcccattaagtttaa
+cagtagactagtccgtgagcgatcaccgagcttatgtctcgtacccaagttttggatttg
+gatcaaaaactactcgatattcatgatctacgggcttcctttctccgggtatcattgcgc
+cgagattaaaaataaaacgatagcgctgtgaaaacatgtttgacacgggatagcgtagaa
+actaaacaacgaatagaccatccaatttgaattttattgggtccagcacttcgccatagt
+gttgaatggtaaagttcgaaaggaaatttgttatattaattctgctacattttcgaccac
+ttgtatctcaaggacaatatcccttgaggcttttagcagaaagagatgccgtaattctaa
+gggatgataataggttgggaaatttaagagcagtagtaacggtcgcgggttcgaccttaa
+actatatatttaaatctagccaaacaagttaacaacaaccataaagttatgaccttatta
+tattggcaagcttaacgttttaattgctctagtaatagagtggtagaggtaagggaccat
+cacctgattcttcctccgcaaccattatatagacgtgtcgtctgacaaatttcgagataa
+aacattcgtccttagcaacgaatatcgaatggcaattagccacattgagttaaatagttg
+aggatatttcttgcacagaatcagatctaatctaatgattcgttactaaacacttcacca
+ggtatcgtgaaggctcaagattacccagagaacctttgcaatataagaatatgtatgcag
+cattaccctaagtaattatattctttttctgactcaaagtgacaagccctagtgtatatt
+aaatcggtatatttgggaaattcctcaaactatcctaatcaggtagccatgaaagtgatc
+aaaaaagttcgtacttataccatacatgaattctggccaagtaaaaaatagattgcgcaa
+aattcgtaccttaagtctctcgccaagatattaggatcctattactcatatcgtgttttt
+ctttattgccgccatccccggagtatctcacccatccttctcttaaaggcctaatattac
+ctatgcaaataaacatatattgttgaaaattgagaacctgatcgtgattcttatgtgtac
+catatgtatagtaatcacgcgactatatagtgctttagtatcgcccgtgggtgagtgaat
+attctgggctagcgtgagatagtttcttgtcctaatatttttcagatcgaatagcttcta
+tttttgtgtttattgacatatgtcgaaactccttactcagtgaaagtcatgaccagatcc
+acgaacaatcttcggaatcagtctcgttttacggcggaatcttgagtctaacttatatcc
+cgtcgcttactttctaacaccccttatgtatttttaaaattacgtttattcgaacgtact
+tggcggaagcgttattttttgaagtaagttacattgggcagactcttgacattttcgata
+cgactttctttcatccatcacaggactcgttcgtattgatatcagaagctcgtgatgatt
+agttgtcttctttaccaatactttgaggcctattctgcgaaatttttgttgccctgcgaa
+cttcacataccaaggaacacctcgcaacatgccttcatatccatcgttcattgtaattct
+tacacaatgaatcctaagtaattacatccctgcgtaaaagatggtaggggcactgaggat
+atattaccaagcatttagttatgagtaatcagcaatgtttcttgtattaagttctctaaa
+atagttacatcgtaatgttatctcgggttccgcgaataaacgagatagattcattatata
+tggccctaagcaaaaacctcctcgtattctgttggtaattagaatcacacaatacgggtt
+gagatattaattatttgtagtacgaagagatataaaaagatgaacaattactcaagtcaa
+gatgtatacgggatttataataaaaatcgggtagagatctgctttgcaattcagacgtgc
+cactaaatcgtaatatgtcgcgttacatcagaaagggtaactattattaattaataaagg
+gcttaatcactacatattagatcttatccgatagtcttatctattcgttgtatttttaag
+cggttctaattcagtcattatatcagtgctccgagttctttattattgttttaaggatga
+caaaatgcctcttgttataacgctgggagaagcagactaagagtcggagcagttggtaga
+atgaggctgcaaaagacggtctcgacgaatggacagactttactaaaccaatgaaagaca
+gaagtagagcaaagtctgaagtggtatcagcttaattatgacaacccttaatacttccct
+ttcgccgaatactggcgtggaaaggttttaaaagtcgaagtagttagaggcatctctcgc
+tcataaataggtagactactcgcaatccaatgtgactatgtaatactgggaacatcagtc
+cgcgatgcagcgtgtttatcaaccgtccccactcgcctggggagacatgagaccaccccc
+gtggggattattagtccgcagtaatcgactcttgacaatccttttcgattatgtcatagc
+aatttacgacagttcagcgaagtgactactcggcgaaatggtattactaaagcattcgaa
+cccacatgaatgtgattcttggcaatttctaatccactaaagcttttccgttgaatctgg
+ttgtagatatttatataagttcactaattaagatcacggtagtatattgatagtgatgtc
+tttgcaagaggttggccgaggaatttacggattctctattgatacaatttgtctggctta
+taactcttaaggctgaaccaggcgtttttagacgacttgatcagctgttagaatggtttg
+gactccctctttcatgtcagtaacatttcagccgttattgttacgatatgcttgaacaat
+attgatctaccacacacccatagtatattttataggtcatgctgttacctacgagcatgg
+tattccacttcccattcaatgagtattcaacatcactagcctcagagatgatgacccacc
+tctaataacgtcacgttgcggccatgtgaaacctgaacttgagtagacgatatcaagcgc
+tttaaattgcatataacatttgagggtaaagctaagcggatgctttatataatcaatact
+caataataagatttgattgcattttagagttatgacacgacatagttcactaacgagtta
+ctattcccagatctagactgaagtactgatcgagacgatccttacgtcgatgatcgttag
+ttatcgacttaggtcgggtctctagcggtattggtacttaaccggacactatactaataa
+cccatgatcaaagcataacagaatacagacgataatttcgccaacatatatgtacagacc
+ccaagcatgagaagctcattgaaagctatcattgaagtcccgctcacaatgtgtcttttc
+cagacggtttaactggttcccgggagtcctggagtttcgacttacataaatggaaacaat
+gtattttgctaatttatctatagcgtcatttggaccaatacagaatattatgttgcctag
+taatccactataacccgcaagtgctgatagaaaatttttagacgatttataaatgcccca
+agtatccctcccgtgaatcctccgttatactaattagtattcgttcatacgtataccgcg
+catatatgaacatttggcgataaggcgcgtgaattgttacgtgacagagatagcagtttc
+ttgtgatatggttaacagacgtacatgaagggaaactttatatctatagtgatgcttccg
+tagaaataccgccactggtctgccaatgatgaagtatgtagctttaggtttgtactatga
+ggctttcgtttgtttgcagagtataacagttgcgagtgaaaaaccgacgaatttatacta
+atacgctttcactattggctacaaaatagggaagagtttcaatcatgagagggagtatat
+ggatgctttgtagctaaaggtagaacgtatgtatatgctgccgttcattcttgaaagata
+cataagcgataagttacgacaattataagcaacatccctaccttcgtaacgatttcactg
+ttactgcgcttgaaatacactatggggctattggcggagagaagcagatcgcgccgagca
+tatacgagacctataatgttgatgatagagaaggcgtctgaattgatacatcgaagtaca
+ctttctttcgtagtatctctcgtcctctttctatctccggacacaagaattaagttatat
+atatagagtcttaccaatcatgttgaatcctgattctcagagttctttggcgggccttgt
+gatgactgagaaacaatgcaatattgctccaaatttcctaagcaaattctcggttatgtt
+atgttatcagcaaagcgttacgttatgttatttaaatctggaatgacggagcgaagttct
+tatgtcggtgtgggaataattcttttgaagacagcactccttaaataatatcgctccgtg
+tttgtatttatcgaatgggtctgtaaccttgcacaagcaaatcggtggtgtatatatcgg
+ataacaattaatacgatgttcatagtgacagtatactgatcgagtcctctaaagtcaatt
+acctcacttaacaatctcattgatgttgtgtcattcccggtatcgcccgtagtatgtgct
+ctgattgaccgagtgtgaaccaaggaacatctactaatgcctttgttaggtaagatctct
+ctgaattccttcgtgccaacttaaaacattatcaaaatttcttctacttggattaactac
+ttttacgagcatggcaaattcccctgtggaagacggttcattattatcggaaaccttata
+gaaattgcgtgttgactgaaattagatttttattgtaagagttgcatctttgcgattcct
+ctggtctagcttccaatgaacagtcctcccttctattcgacatcgggtccttcgtacatg
+tctttgcgatgtaataattaggttcggagtgtggccttaatgggtgcaactaggaataca
+acgcaaatttgctgacatgatagcaaatcggtatgccggcaccaaaacgtgctccttgct
+tagcttgtgaatgagactcagtagttaaataaatccatatctgcaatcgattccacaggt
+attgtccactatctttgaactactctaagagatacaagcttagctgagaccgaggtgtat
+atgactacgctgatatctgtaaggtaccaatgcaggcaaagtatgcgagaagctaatacc
+ggctgtttccagctttataagattaaaatttggctgtcctggcggcctcagaattgttct
+atcgtaatcagttggttcattaattagctaagtacgaggtacaacttatctgtcccagaa
+cagctccacaagtttttttacagccgaaacccctgtgtgaatcttaatatccaagcgcgt
+tatctgattagagtttacaactcagtattttatcagtacgttttgtttccaacattaccc
+ggtatgacaaaatgacgccacgtgtcgaataatggtctgaccaatgtaggaagtgaaaag
+ataaatattgcctacacatactgaattcaggcaatgcgttttattcgaaaggtcatataa
+ctagaaaacatgatgaattcttatcggatccttttactagcatagtgttggcgaacacct
+cgtaatgctcagcggcaaattggactgcgggtccttatcatacattttttttcaatatag
+gcgattggtctaggttagtgattccccaacacttaaggtttgctgacattcataccctca
+gcaacttcctctcaaaaattagagtgagttggtggtcttataagaccgttgattatttga
+ggtggtcaaatgatggtgcgatgcacaaatcgttataatcgtactctgtagacaataacc
+cattgtagtgccgattttgtgcataatacaagaaggaggatataaaaatgacttttcaat
+aatattggctattagcaacaagaaggagaatcctcattaagttagcaaccgcagggggta
+ctgcagtccaaggaggtttcattggagagagcagtatgaaaacggcaattatgattgtga
+gattcgctgaagattgtgtctctgattttcctagatagaataagctatagctacttaatc
+aactcttaactgtggagactatcctgatgatctgaataccccatttacaaaattccatat
+caatgaggctaacgcttaaatttcatttctccatcgtaacaaaaatcagcctttttatac
+aagacaaaacactgcttccattacgggtagcaatggttgctcgactactggtagcgtcgt
+gatgtggtgataaagctgtcttgcgtttatacttaaacaaattttgacctgacataatgg
+agcgacttatcggatgttgccgatctttagggtcatctattaagcttatacgaaaaaggg
+acaagcacgttacgtaatctggtaggactgggtacctagaaacgcaagaggaggcgaact
+ccaatatctgtaagaacagaaaaatacaggagtccttttcatttttcaagttaacaatat
+aagtaggagcttagagaggcttgcatgaaaatcgttaggaattacagaataggcagagag
+tggggcgtgtagactacattcttcaggccccacaatatgggttataggttaaactgcact
+ttttgcgatctcccgaaatactgtcgttctctgcgaaccacgctcgttccttttgctgta
+gtccacgttcatccaactattcagataaacaagatcgcagaattaaagcttaaccatatc
+ttgatagcccatcgtgtatggggcatgtatgtgcaaacaaaagacctcaatcttgtctgc
+gagagggaggaaaatttagacaaacataattcattctttcgactggacacgctaaggttt
+ggacaaactttgtatctatatctggaggcctgtattccagcccttcttttaataagattt
+acggcttaaactatggatatttgccaggaaatgacactgctattgacaggaacataattt
+tgattcaaacctcattgttaattattttatatctcctgtttttatatcagaatgcttctg
+tcctagaaggcatactcaaggtgagggctcgaggaatgaatcataatagaccggccccta
+ttaatattggttcaattctttcttacataacgcggaatttgattgcacgaacaccgggaa
+cacataaccgtatagcgcccgttatgctagtgcctagcgactgggaccgtggagtctata
+tcgtctttctaccattattaatctaaggatataccactttaagtcctttcaactaacata
+aggcgcattccatgcgctaaggaccttgaatttattatttcttacatgataaaagatcga
+gtcgacgggaacaaaaggctacgtactcaataaagtgcagtttactaagagccctttttc
+tggcttgtggagactatcataacatgaagatgttttgacattcaatagtttgcaaaacaa
+acttactttgtgtagtattgaacgagatctttccaattgccccatagcaggaatagttat
+atattgcagatcgcggtgtaacgcactccaaatccatcgcggtgtgtgagggtaagcgac
+ttaaagaattacggtttttgatcaaagcacagtgagagttgagcaaattacagttatacg
+acttaattcagtctccataaattgaaacgacacttcttaacgggaggaccagacacgttc
+attaagtgaggagtgcactttttgactttaaaaacatggtaatcaatttaaaccacttga
+tatgtatatgaacagatttgaagttatttctgttttaatacactgggagttctgtcaata
+tcgcaggaaccgcctgacgtcccctatcacacctcagagggtaaagggacaggggaaagg
+gtaatcgaggggtagggaacgtagttggcacacccaatggacgaataaatgctgccatat
+ccacggagggcgggattgcggttgattttaaggcgatggtaacctgaatgtaatagatca
+tcaaatgcctcctccactggaaattactgcgtacatccgctgagaattgcaatggagtgt
+ctcggtttttctttaaacaaaaccaaattgacaacttcatagtataatttttgcacatta
+caagcgttaattaacaaacttactttgctgttagctgcctatatttgtccgacaatataa
+ctggatatctctgcgagaactgtaaattaacggcacttggaacataatagttcctattgg
+taacgacgttgtaggcggcaattatccggtggaagaattgacaactgcagttgaactgca
+tgaaagtcaaatctctcgtaagtataactttagaagactccaaggtacccagaacctctt
+cagcggacacgatcgctatcaatcaataaggattattcactgaaaccgctcatatctgga
+ggtggacgtttttcttcgaaaagcttgtcaaaggactcatcaaatttttggccgtgctaa
+tcgacacacctgttattttcatgaccggataggacatctcgcggaaattcgggtaacagc
+tgggtagatataggacctcccctacgtattaatgataagcctgtcataactagcttggtt
+taccgaagagacaataaacattcgagcgctcgtgccaaactcggtgcattacgtttgaat
+aaatcggtaacatgtactattactctgcctaacggcacttacccgtttgggtccatgggg
+taaccgctcgatgttgacagaattatgctaaagtcgtttaagatcccgattaccgaaaat
+ctggttatgtctgagcattcgtacactgcgtattaagatcaggttgaacaggttcctaac
+aaattttgtgacctaaagtgaaactaggtcgtactctgggcatgttttatgtcgtggcgt
+atgcatgtgctgacacttctaaaaccaaattaaggctttatccaatatgggtccttaagt
+gctaaacatcattcacaatttcaagacagattgttggtcttgtcgattccgcatctgtcg
+ccaaattgacacatcgtaaaccaggtacatcggtaattatatgttgactaaactaccgtg
+tgtattctggctctaggtacggcgaacaagtacgatgtgcttaagaagccctcaccccag
+acgagcccgcgtaggtcacatcagcagatcctaagtaattccgttttattgtcctgaggg
+agtaggatcgacgaactctacaagtcgctttgtcgtgccttataggctatttcgggtcaa
+tgtagcgtcaaatgaactattgtcatctgtacgagttaactaagtgtctatcgccaacta
+aaagacgtctcgatggttctttatgcggacctgtcatatcattgactggcacttgcttac
+atccaaataacacgtttgttagcggatagtcgttaagtgtgcgcaagatcatgaggcggg
+gggggtaatatttcgccctctacatgataaatgaataagtaagaagatgatctttttgtg
+gcggtaccttaagcgtactcctgtcgacgagttactactaaaggaatgtagggttctgga
+tctatgaaaagcgacctccatatatatacgggcctaagcggagtaaaataagtgatcaat
+ggactaacattgaaatgttagtattgtcgaccattgagggctggtaaatcttatttacgg
+gcgtgggaaaacgaacgtgatatggtttagcatgggatgcaagcactcgttaatgcttac
+tttagttggttgcgggaacaacaggaggctatactaactggtagcgttcttgcttccatt
+atgttattattataattaaaaataagacatatggtagagttgtagtcagggtggatcggg
+ttgtctataacgttggaataatcaaaactatcgttaacaaaaacgaaatttaagtcggtg
+cggtggaatgcgcctacctcatgtgcaccacacattcacagcacacccctcattataggc
+aaggaagcaaacaaaaaaaagttaatcgaccgtatccgaccttaaattttaaaataaata
+gaaacacttagcggtaatgaaaagataggactaaaattcactagtatcctggaacgaggc
+aacagagttatctagatggtaacgaggtgctgcatcaagatgtatgatttttggtccgct
+gtgtggaatacctctattgatatacaagtgactttctcggtaataacgcacttcacaatg
+tgttgtttcttttctatgtattttgcaagagaaagaagcttagtataggtacacctcaga
+gatgtttcgtgtaaatcgtatcacatggtataactgcaggaggaacattatccaaattca
+ccacaattactaatccacccttttacttttactaaagatatattaattctcatgttgtct
+gaattgtataacccggtaccctgggagcgtatcgaaggataccaattgaagtcctcgagg
+catgttacaacacacgacttccttccgtctattcagacactcaacgagactaacttttcc
+taggtaatcaatgatattgggtaactcgtggcatcttatagttattgatccggctctttt
+gtagatcctgtgcgactcgtgcgctaattaagactggctctcttgcgcaggggatacgtt
+tattctacgtacccgatttggttactactaagcggcctttcttcaaacttgcagttgtga
+cttacattcctatttcttcaaagcagggaagggttacagggagagacttattgagatacg
+attggaatttccatgtacaatcgttaatacgcttgtagaccagcaactcagtatagagat
+ccgtttcctaaagggtgagcggtaggggcaaggcaataagaaattactaaaaccctagtt
+gttaatataagaacgattcgaaacaataggattgcccaagggggtgcgaacatggtgtaa
+atcaaagagaaataggcattgttaaaacccgcacgtttctagtacgcaagaggaacgtcg
+gtaaccagttctcaaagatcctaacctaaaaggggcttattctactttttccgacactca
+atggacgagacaaacatgaacggatagctttaggtctcgttgaatgcaaagaatagaatc
+gttattattaatcggtttccattatctatatgcggtatagatctccgagaggaccctgta
+aactagctctgcggtttaactggtgctaatagaccgccactatgttattgcttctagctc
+ctagcgtcttatcatgttatacattaatgtcgcatattggacagtagccaggcttggatg
+gatcgccgacaaaaagaaaagactttccctgtaaggacttaactattacatataacttgg
+atcattaatctgcaaattagagtaacggtctttcaccagcttcatattccaacgtggcgc
+tagtcgatatcccatgaagtttaaaactagaattggcagtctcacttcacagtgcgtatc
+tatacgacaaaagtggtcgatttgcataaatatcttatcgatattcaggttattaccgat
+tccttgctaacgctagaagtcacaccagagtaataataattccagacacctgtgaaataa
+tcggtcactacggatagactagtaacgataatacgtatagtccataaaagttgaatttta
+ggggctaaagatattagcaatactggtctagcctaatcgtcgatagcaaagggctgtgag
+gatttctcctacattttcgaccaattgtatcgataggaatagttacagtcacgcttgtag
+atgtaagagatgacgttattcttagggttcttaagtcggggggtaatttaagaccactag
+taaaggtagaggcgtacacagtaaacgatattttgaaatcgtcaaaaaaaagtttacaac
+atcctttaagttagcaactgattttagtggcaaccttaacggttgaattgatctactaat
+acaggcctacaccgaagggtacagataatgattcttactaccctaacatgatagagtcct
+gtcctatctcataggtcgacattttaaattcgtaatgagcaacgaagatcgtttcccaat
+ttgcaacattcacttatagacttcaggttatttcgtgctaacattaagatagaatataat
+cagtcgttaagaaactattatccagctttcgtcaaccataaagattaaaaactgaaactt
+ggcaagatatgaatagctatcctgctttaaccgatcgtatgagatgctttgtagcaagaa
+aagtgactagcacttgtgtttagtaaagcgggagagtgcggtaattaatattaatatact
+attaagctacacagcaaaggctgcaataatgttagtaagtagaacataaaggtattctcc
+acaagtaataaatagtgtgagctaattgactaacttaactctcgcgacaagtgatgtgga
+taagatgactcatatcgtctttttctgtagtgccgacatcccacctggatcgaacaattc
+cttctagttatcgactttgattacctatcctattaaacagatagggttgtaaagtcagaa
+aatgatcggcttgcgttggtctaccatagctagagttagaacgcgtagatagaggccttt
+tgttgccaacgtgggggtgggatgagtctgggcgagcgtgactttctttcgtgtccgaat
+ttgtttaacatccattagattagatgtttgtgttttgggtctgatgtcctaactactttc
+tcagtgaaactaatgtcatcatccaagtaaaatagtccgatgaagtctccgttttcggcc
+gaagcttgtctataacgtatataaagtcgctgaatttagaacacaccttatctatgttgt
+aaagttactttattccaaaggacgtgcacgaagcgtgagtgtgggaaggaacttaaagtc
+ggatcactcttgtcagtgtagataagaatttctttcatacttcactggaatccggcgtat
+ggatatctctaccgcgtcatctggtggtgtctgcggtaaaaagtcttgctgcacgagtct
+gagaaatttttggtgccatcacatcgtaactgtacaacgaacaaatagcatcaggccttc
+ttatccagcgtgaagtctaattatttcacaagctttcctaagtatgtaaatccctcactt
+aatgatgcttgcgccaatgaggatagaggacattgcatgtacgtaggactattctccaag
+gggtcttctattttgttagcgaaaattgttacagcctaatgttagagcggcgtacgactt
+tataccagatactttcattagatatgcaaatatccaattaaatcatagtagtatcgtggt
+atggacaatcaaaaaagacccgttgtgatatgatgtttttctagttcgttctcatatata
+tagatcaacaatgaataatctcatgatctataaccgatgtatatttatattccggttgac
+tgctccggtgcaattcactacggacactaatgactaatatggcgcctttcatcagaaacg
+ctaaatatgattaatgaattaagggagtattatctaattattagagagtagcagttagtc
+tgatattttcggtgtatgtgttagccgttataatgctgtctttttatcagtgagaacagg
+gagtgtgtagtgttgtatgcttcactttatgactctggttatatccctcggagaacaaga
+ataagagtacgagaagttcggtcattgaggatgaaatagaaccgctagacgaatggactc
+acgtttataaaactatgtatcacagtactacagctaactctgaagtccgagaagcttttg
+taggacaaaacgttataagtacctttcgcagaatacggccgtgcatacctgttataaggc
+gtagtagggacaccatgctatccctcatatagagctacactaataccattacatggtgac
+tatcgtttacggccatcatctgtaagcgatcatgcctcgttagcatccgtacaatctcgc
+atggcgtcactgcagaaaaaccccgtgcggattttgagtcagaactattcgaagcttctc
+aatccttttccattatggcatagcaagtgacgactcgtcagccatgggaataatagcact
+aatccgattacttatgaattagaacccacatgaatgtgattctgcgaattgtctaagaat
+ctaatgattttccggtgaatatggttgttgttatttattgaacttatattattaacatca
+cccttcgttagtgatagtcagctatttccaagaggttccccgagcatttttaccattctc
+tagtcatacaagttggagcgcttttaaatctttaggctgatcaaggcgttttgtctagaa
+ttctgcagatgttagattcgtgtgcaatccctcttgcatgtcagtaacaggtcacccgtt
+tttcgttacatatgctggtaaaatattcatagtaataactacaatacttgatttgttacg
+taatgctcgtacataacacaatcgtattccacggaacagtaaagctctattattctgatc
+gagcctaagagaggatcacactacgctattaaagtcacgttcacgaaatctcaaacctca
+actgctggtgaccagttatagacagtgtaattccatattacatgtcaggcttaagctaac
+ccgagcctttatataagctataatcaagaattagattggagtgcattttagacttatcta
+tcgaaatagtgatagtaagagtttatatgacctgatctagactgatgttctcttccacaa
+cagccttaaggcgtggagcctttcttatactattaggtcgcgtcgagagccctattcgta
+atgttaacgacactagactaatatacaatgagctaagaataacacaagtcacaagataat
+ttacaaatcatatatctacagtccacaaccatcactagcgattgcaaagcgttattggta
+ctaccgctctaaatcggtatgtgcaagacgcgttaactggttcaagcctctcctgctcgt
+gagactgaaagaaatcgaaaatatggatgtgcctaattgttcttgtgagtcatgtgcaac
+tatacagtttagtttggtcaagactatgcaactattaacagcatgtgcgcattgaatatt
+tggtgtcgattgataaatgccccaacgttccatcacgtctataagccgtgttactaatgt
+gtattagtgcatacctattcagaccatagttcaactgttggactgaaggcccgtcttggg
+gttcgtgaatgagagtgcagtttcttgtcttttccttaactgacctaaatgaaggcaatc
+ggtttatctagagtcatgcttaaggtgaatttcagccaatgggctcccattgagctagta
+tggtgctttacctttgtaagtggtggctttccttggtgtgctgactttaacacggcagag
+tgattatccgaagaatggataataagacgctggcaatattggctaataaagtccgatgag
+tttcaatcatgactgcgaggagatccatgcggtgtacctaaacctacatcgtatgtattt
+gctgacgttcattcttgatacataaagatccgatatcggtccactttgtttaccaaaagc
+cctaccttcgtaacgatggaaatgtgaatgagagtgaaatacacgatggggatattgccg
+gtgagtacaagttagaccacacattagaactgacctatattcgtcatcatagagatggag
+tatgaattgattctgcgaagtacactggctttacgagtatctagacgccgcggtatatct
+cccgtcaatactatgaaggtatatatatagaggctgaaaattcatgttcaatcctctttc
+taagagtgagtgggagccccttctgttgtcggagtaaaaaggcattattcctcaaattgt
+cagaagcaaagtatacgtgatgtttgcttagaacaaaagagttaccttagggtaggtaaa
+tctcgattcaccgagagaagtgattttggcggtgtgcgattaattcttttgatgacagat
+ctcattattttatatagctccctctttgtatttagagtttgcgtaggtaacctggcaaaa
+ccatatcccggggggagagtgcgctgaacattttatacgatgtgattactcaaaggataa
+ggttcgaggcctctatactcatggaactatcttataattataatggatcgtggctcattc
+cacctatccaaacttctttgtgatctgatgctacgagtgtgaacaaacgtacatcttcta
+aggaatttgggacgtttcatagctcgcatttcattcctgaaaacttaaatatttttaaaa
+attgattctactgcgaggaactaaggtgtagacaagcccttagtaaccggtggatgtcgc
+ttcagttttatagcaaacattattcaatttcagtcttgactgaaattagtttgttagtgt
+tagaggtccatatgtcacatgcatatggtctagatgccattgtacagtaataccttagat
+tagtattagcggcatgcgtacttggatttcacttgtaagaatgagcttaggacggtcgcc
+tgtagggctgcaaataggaatacttacaatttttgatgacttgttagcatatcgctatca
+cccataaaaaacctgatacttgatgagcgggtgattgagactatgtactgatataattca
+atagctccaatagatgaaacagctatgcgcctatttatgtcaaataatcgatgtgataca
+agcttagagctgaacgagcgcgagtggaattagcggtgatctctatcctaaaaagccacg
+aaatcgatcccagaagctaatacccgaggtgtcaagcttgagttcagttaaatttgcatc
+tcatgccccacgaagaatgggtagagagtttgaaggtgcttctggattttcctaagtacg
+tggtaaaaatttgatgtaaatgaacacctcctaatggttgtgttaaccacaaacccctgg
+gtgaatctgattagccaacccagtgatctgatttcagttgtcaaatctcttttttataac
+taccttttgtttccataatttaaccggatctcataatgaacaaacgggtagaataatggt
+agcacatagcgagcttgtctattcagaaatatggcctactcagaatgtattctccaaatc
+agtgttatgcgaaacgtaattttacgtgtaataatgatgatttcttatcggttccttgta
+ctacaatactcttgcccaacaaatactaagcataacagcaaaattcgaatccccctcctt
+ttaataaatggtttttcaatatagccgattcgtattcgttagtctttcaccaactattaa
+cctggcatctaattaataaaatcaccaaaggactctataatatgacagtcacttcggcct
+cttttaagacagttgattattgcaggtccgcaattgatggtgacatgcacaattagttag
+aatccgactatggagacaattaacaattgtagtgcccatttggtccagttgacttcaacc
+acgagttataaaggtattttaatttatagtcgatagtaccaacaacaagcacaatcataa
+ttatgttagaaaacccagggggtaatgctctaaatccagctttaaggccagagtgcacta
+tgaaatcgccattgatcattgtgtcattcgctgaacttggtgtctaggaggtgccgagtg
+agaatatcagataccttatgaagcaacgattatatctggactagatcatgatgatcggaa
+taaaacattgaaataagtccttatcaaggagcataaacattttatttaatttatacttcg
+taaataaattcagaattttttttcaagacattaatctgagtaaatgacggctagaaaggg
+ttcctactcgaatcgtagcctacgcatgtgggcagtaacctggcttgcgtttttactgaa
+acaaaggttcaccggaaagaaggctgccacttttagcttcttgacgatctttagcgtcat
+atttttagattagtcgaaaaacggaaaacaaacttaacgaagctggttgcacggggtacc
+gagaaaccaaagagcaggacaactccttgatcgggaagaactgaaatagacagctgtcat
+tttcattggtcaacttatcaatataacgaccaccgtagtgacgcttgcatgaaaatactg
+aggatgtaaactatagccagtcaggcccgcgtgttgactaattgatgaagcaaacaaaat
+agccggtattcgttaaaaggaacgggttgccagctacagatatactctaggtatatccca
+aacaagagacgtcctttggctgttgtaatcggtcataatacttgtcacataaacaagatc
+gctgaattaaacattaaacagttagtgatacacaatcgtggttggggctgggatgtgcaa
+taaaaagtcatctatcgtctatcacagagcgacgtaaatttagacaaacattattatttc
+ttgacaatggaatcgataagcgttcctctaacttggtatatatatctcgaccccgggatt
+ccagccattcttgtatgaagatttaaccatttaactatgcatagttgaatggtaaggaaa
+atgatattgactgcaacagattttggatgcaaaaatatttgtgaattattggttatatac
+tggttgtatagcacaatcattaggtcctagaaggcatactcaacctcagcgagagagcta
+gcatgcataattgtaccgcccatattaatattcctgaaatgatttcttacattacgccca
+atttcagtcatcgaacacccccatcaatttacccgatagagaacgtgatcatacgcaata
+ccctatgcgaacgtccactctatagcgtctgtatacaatgattattcgttccatttacaa
+cgttaagtaatttaaacttacataaggacaaggaaatccgcgaacctcctggaatgtatg
+agttatttatgcagttaacttcgtctcgaccggaactaaaggcgtcgtacgaatgaaagg
+ccacttttagaagagacctttgtatccattgtggagaatatcataaattcaagatggggt
+gtcatgctattcggtcctaaacattcttaatggctgttctattgttagtctgatttaaaa
+tggaaccatagcacgaatagttagatagggctcatacccctgtaacgatctacaaatcct
+tccccgggtgtgtgcgttagcgacggaaagttttacggtttgtgatcaaagaacactcac
+acgtcagattattacactgatacgaattatttcagtcgacagtaattgaatagaaactta
+ttaacgccagcacctgacacggtaagtaaggcaggtctgaactgtttgactgtaaaaaaa
+tggtaatatttttaaaaatcttgatttctatatcaaatgatgtgtagttttttctctgtt
+attaaaatcccagtgcgcgaaatttagatcgttacgactcacgtacaagatcacacatca
+cacgcgttagcgaaagcggaatggctaatacagccctacgcaacgtagtgggatcaacat
+atggacgaatttatgctcaatgagccaacctcccccgcattgcggttcattttaaggcct
+gggtaacatctatcgtttagataatcaaaggaatccgactatgcaattgtctgacttcat
+ccgctctcaagtccaatgcaggcgctacgtgtttctttaatcaataccatattgaaatcg
+taatacgataattgttgctattgactacaggttatgaaaaaacttactttgcgggtacat
+gcatatttttgtaccacattattacgcgatatctctcagtgtactctaaattaaaccctc
+ttcgaacattttagttcctattcgtaaacacgtgctacgcggcaatttgccggtcgtaga
+atggacaactccagttcaactgcatgtaactcatagctcgcgttagtataaattgactag
+tagccatgggacaaagtaactagtcagcggaaaagatccctttaaagatatatgcaggtt
+gcaagcataaagctcattgctcgaggtgcaccgtggtattccaaaagcgtctctatcgta
+tcttctaattttgggccgtgagaatcgaaactactctgatttgctgcacacgttaggtaa
+tatcgcccattttcccgtataagctccgtacttatacgaactacacgaccttttaagcat
+tagccgctcatatcgtgattcgtgtacagatgagtctattaaaattacagacatactcca
+tatctcgctccttgaactttgaataatgcgctaacttgtactatgaataggcagaaccca
+actttcccgtttgcgtcaagcggggaaacgatacatgttgtcagatttatgattatctag
+ttttagatcacgtttaccgataatcggctgtggtctgagcagtcctacactgagtattta
+cttcagcttcatatcggtccgaaaaaaggttgtgaccgaatgtcaaaatacggagtacga
+tgggcatcttttttcgagtcgcggttgcagggcagcaaaaggcttaaaccatttttacga
+tttttactatagcggtcatgaagtgcgaaactgcttgcaaattttctacacacattgtgg
+ctcttgtccttgaagcttatggcgaaaatttgaaacatagtataccagggaaagcgcgaa
+ttatttggtgactaatagtccgtgggtttgagccatatacctaacgccataaactacgtg
+gtgctttagatgcaatctaaacagaacagaaagcgtagcgctcatcagcacagactaact
+ttttcagtttgagtcgccggagggacttcgagacaagaacgcgtcaagtcgcttgcgcgg
+cacggattcgattgggcggctcaatcttgcctaatttctactattgtcagctgtacgact
+gtactaagtgtatagccccaaataaaagaagtatcgatgcgtctttatgaccaaaggtct
+tataattgaagcgcacttccgttcatcaaattaaatcctggcttacccgattctccggaa
+gtctgacctagagattgacgacggccgcgtattattgagacctcttcaggattaatcaat
+aacgaagtagttgatctgtttggcgacgtaccttaagccgactccgctacacgagtttct
+actaaaccaatgtagccttatgcttagatgaataccgtcctaattagatattccggcata
+acagcagtaaattatctgttcaatggacgaacattgaattgttagtattctacacaagtc
+aggcctcgtaaatattaggtaaggccgtgggataacctacgtgatatgcttgagcttgcg
+ttgcaagctctcgttaatcattaatttaggtgcgtgagggttaaacaccagcatattcta
+tatgctagacgtcttccttaaaggatcgtagtattataattaataataagaaatatggtt
+gacgtctagtcagcgggcatacgctgctctatatactggcattattcaaaacttgacggt
+aaaaaaacgaattttaaggcgctcacgtcgaatgagccgaactcatgggaaccaaaatgt
+cacagaaaacacctctttattgccaagcatgcaataaaaaaaatgttaatagtacgttta
+cgacattttattttataataaagagaaactattacacctattgatatgataggacgtaaa
+ttaacgagtagcctgcatagaggcaaatgaggtttctacatggtatagacctgatgctga
+aacatcgatgagttttggtcccctcgctcgttgaaatctagtcatttactactgtctttc
+gagctattataccacttcactatgtggtgtttctttgctatgtatggggctagtcaaaca
+tgatgactatagctacaactcagagagcgggcgtgttaagagtatctcatgctagaactg
+cacgacgaacttgatacaaagtaacaacatttacgattccacaaggtgactttgaagaaa
+catagtttaattctctgcttcgatcatttctataaaccggtaccatcgcagcggatagat
+gcataacatttctactactccaggcatcttaaaacacacgtagtacttcactagattaag
+acacgataagtgtataacttggcagtgggaagcaaggagattggcgaactcctggcatct
+gttacgttttgttcaggctcggttgttgataatgtccgactcctgccatattgaagactc
+gctcgagggagatcgggattcgttgattataagtacacgtgttccgtaatactatgaggc
+agtgattcaaaatggcacttctgacttacatgactaggtattattaccacggaagcgtta
+aaggcacactcttatggacttaagattgcaagtgccttcttctagcctgaattcgcgggt
+tcaacacaaactctctttagacatccgttgcctaaaggctgagacgtaggggcaaccctt
+taactatgtactaaaaaactagttggtaatttaacaacgtgtccaatcaagacgatgcac
+caacgcggtgcgaaaatcgggttaagcaaacacaaataggaattgtgataaaccccacct
+tgagaggtcgcaagaccaacctcgggaacaacggctctaagagaataacctaaatccgga
+tgagtagactgtgtaactctctaaagggaagtgaaaaaaagctaagcatacatttaggtc
+tcctgcattgcattcaattgaatcgtttgtattatgagctgtacagtagctatatcagct
+atagttatcccagaggaacaggtaaactagctctgagcgtgaaatccggatattagaacc
+cctagatgggattgattctagctaatacaggcttatctggttttacagttatctagatga
+ttggtaaggtgaaacgcttggtgccttccaccacttaaacaaaagtattgcccgggaagc
+tattttctaggtattataaagtcgagcattaatatcaatttgacagtaaaggtctttcac
+cagcttcatatgccatagggcccatactcgatttaaattgaacggtttaacgagtattgg
+aactctcacttataactgagtagctatacgaaaaatctggtccatttccagaaatttatt
+atcgatttgctgcttagtacccaggaagtgataacccttgaaggcacaacactgtaataa
+gttttcctgtcacatctgtaatattcggtcactacgcattcacgactaaagataattact
+atactaattaaaagttcaatgttagggccgaatcatagtagaaattctcgtctagcctaa
+tcggacttacctatgggctgtgaggatttatcagtatgtggacaaaaatgctagagatag
+gtatagttaaagtcaccatggtacatctatgtgaggaagtttgtagttcgcttctttagt
+ccgggcgtttgggatgacaactactatacgtagagccgtactcaggattagatagtgtga
+aagagtcaaataaaagggttaatattaatttaacgttgcaaatgtgtttaggccaaacat
+taaccgttgtagggatattctaatacaggccttcaccgaaccctaatgataatctgtctt
+aataacattaaatgattgtctccgctacgagctcttagggcctcattttaaatgactaat
+gtccaaagaagagactttcccaatttcaatctgtcacgtatagacggcaccttagtgagt
+catatcattaagatagaagattatcaggagggaagtttctattatcaaccgttacgcaac
+cataaacttttaaatctcataatggcattgagatcaagagctttcatgatggtaaagttc
+gtatgtgatgctggggagctagatatcggtataccacttcggttgtggtaagcccgagtg
+ggccgttagtaatattaatagacgattatccgacaatgcattcgctgaaataatcttact
+taggagaaattaatgctatgagccaaaactatttatgtctgtcacattattgactaaagt
+atctatcgacaaaactgatgtccataagttgtagcagatagtcggtgtatggtgtcacca
+atgaaaacctcgagcgaaaaatgaattatagttatccaatttgagtaaattgcctattat
+acagataggcttgtttagtcagataaggttccgcttgaggtgctctaacttagcgagagt
+tagaaagcctagtgagaggcattttggtgccaaactccggctcgcatgagtaggccagag
+agtcactttctttcgtcgaagaagttggtgaacagccttttgattagttgtttgtcttgt
+ggctatgtgctactatataagttagaacgcaaactaatctaatcagcaaagtaaaatagg
+accttgaacgagacggggtacgccgttgaggctcgagatagtagataaactagaggaatg
+tagataaaacattagctagggggtttagttactggattacataggaagtgcaccatcacg
+gtgtgggggttcgtacgtaaagtcgcatcaatattgtcagtggacttaacaagttcgtgc
+ataatgaaatcctatacggactttgcatatctctaccgactcatctggtcgtctatgcgg
+gtaattgtattgctccaagtggatgactattttggcgtcccagcacatagtaaatgtaaa
+tccttataatagcataagcaattattagactgcgtgaagtcttagtagttctcaagcttt
+acgttgtatgtaaataactcacgtaatcagccgtccccaaatcaccattgaggtcattga
+atgtacggagcactattatcaatgcggtatgcgattttctgagcgattattgttaaagac
+ttagcgttgagccccggaacacttgattacagattctttaaggagttatccaaatatcat
+tttaaataatagtagtatcgtgctttggacaataaaaaaagacccgttctcttatgttgt
+tttgcgacgtacttctctgatatatacttcaactatgaagattctattcatcgataaccc
+aggtatatttatatgcccgttcactgcgcagggcaaattatctacggacaataatgacgt
+agttggacccggtaagaactaacgcttaatatgattaaggatgtatgccagtattatctt
+attatgtcagagtagaagtttctctgagattttccgtcgttgtggtacaccggatttggc
+tctctttttagaactgagaactcggagtgtgtagtcttgtttccttcaatttatcaatat
+gcttttataccgccctcatcaactataacaggacgacaagttccgtcttgctccatcata
+tactaccgatacaccaatcgtatcaagtttagtatacttgctttctctcttctacagctt
+actcgcttgtccgagaagcggttggtgctcataaagttagtagtaaatgtacaactagta
+gccagtccttacctgtttttacgactactacggacaccatgagatacagaagttagtgct
+acaattataccattacatgctcaatatcgttgtcggccataagatcgaagagtgcatcac
+gcgtgtgaatacgtaaaatctaccatcccgtcaatgcacaaaaacacactccccttgttg
+actaacatcttttacaagaggctaaatcattgtccaggatcgaataccttgtgtacaatc
+gtcacccatcggaagaataccacttttccgatgtagtatgatttacaaaaaacatctatg
+tgagtaggccaattgtagtagaatatattcatttgaccgtcattagccttcttcttaggt
+tgtgtacggatagtaggtacataaaccgtcgtgtggcatacgctgcgatttcatacagct
+gccaacaccttttttaccaggctagagtcagaaaagttggagccatgttaaatagttacc
+atcataaaccactgttgtctactagtctgatcagctttcatgcctgtgcaagcaatatgg
+attctcacgtaatggtaacaactgttgcgttacttaggctggttaatttgtcagagtaat
+aaatacatgtcttgttgtgtttcctaatcctcggaaagtacacaagcctaggaataggaa
+aagtaaagctcttttattctgatagtgactaactcaggatctaaatacgcgattatacta
+accttcaccaaagctcaaaaatcatctgctggtgaccagttatagacagggtaattcaat
+atttaatgtctcccttaacatttcaccagcatggattgaagatagtataaagttttacat
+ggcagtcattgtgtcacggttctatacaaattctgatagttagacggtatttgaaatgtg
+cttctagcatggtatcttacacaactgaatgaacgactggagccgttcgtatactatttg
+cgagcctcgagaccccgtttcctaatgttaacgaatatagtataatataaattgtgatat
+gaataacacaagtaactacagtttggacaattaattgttctaaactaaaaatcattcact
+tcagatggcatagagttatggctactacacatataaagcggtatgtgaaacacccgtttt
+agccggaaaccctctactgctcgggacaatgaatgatttccaaaatatggatgtgcagaa
+ttgttagtgtgactcaggtccaaatagacactttagtttcgtcaagtcgttgcaaagttt
+aaaaccatcgcagcattctttatttggtctacattgagaaatgaaaaaacgtgacagaaa
+gtctagaagaactgtgaataatgtctattactgattaactagtaagacattagtgcatct
+ggtccactgaagcacccgcttggcgttaggcaatctctgtgaactgtcgtggctgttccg
+gtaatgtacgaaagcaagcctataggttgatcgagtcgcttcattaaggtcaatttcaca
+atatccgatcacattgtgctaggttcgtcctttaccttgcttagtgctgcatgtacgggg
+tgtcatgacttgttatcggcagactctttatcccaagaatggataatatgtacatggaaa
+gtgtccataattaagtcccttcactgtaaagaatgactgccacgtgatccatgaggtcta
+cagaaaccgacttacttgctttttgatcaacttaattatggattcataaagttcagatat
+cggtacaattggtgtacaatatgaaattaatgaggaaacatggaaatctgaatgacagtg
+atagaaaagatccccatttgcccggtcagttcatgttacaccactcattagtactgtaag
+tgtttcgtcagcattgagatccacgatcatgtgtttatgccttcgaaactggatgtacga
+cgatcgagacgaagaggtatatataacctaaatactaggtacgttgttagagagacgatg
+aaaattaatcgtcaatacgctggcgaacactgagggggacccaatgctcttctcggtcta
+aaaaggaatgtgtcagaaattggtcagttcaaaagtagaccggatctttgcggagaacaa
+ttcacggaacgtagcgttgggaaatatcctttctaccacacatcggattttcgccctctc
+ccattatttattgtgttctcacatagaattattgtttagacatccctcgttgtatggaga
+gttgcccgagcgtaaaggcataatccatataccgccgggtgagtgacctgaaattgtttt
+tagttgggatttcgctatggattagcttacacgaagagattctaatggtactataggata
+attataatgctgcgtggcgcagtacaccgttacaaacgtcgttcgcatatgtggctaaca
+cggtgaaaatacctacatcgtatttgcaatttcggtcgtttcatagagcgcattgaatta
+ctcaaaaattatatatgttgattatttgattagactgcgtggaaagaaggggtactcaag
+ccatttgtaaaagctgcatctcgcttaagtttgagagcttacattagtctatttcagtct
+tctaggaaatgtctgtgtgagtggttgtcgtccataggtcactggcatatgcgattcatg
+acatgctaaactaagaaagtagattactattaccggcatgcctaatgcgattgcactgct
+atgaaggtgcggacgtcgcgcccatgtagccctgataataccaatacttacatttggtca
+gcaattctgacattatacctagcacccataaatttactcagacttgaggacaggctcttg
+gagtcgatcttctgtttgtatgcatgtgatcatatagatgaataagcgatgcgactagtt
+agggcatagtatagatctgtgtatacagttcagctgaacgtccgcgagtggaagtacagc
+tgagatctatcctaaaatgcaaccatatcgttcacacatgatatgaacccagggggaaac
+attgagttcagttaaattggcagcgaatcccccaagaagaaggcggagtgacgttgaacg
+ggcttatggtttttcagtacttcctccgtataagttgagcgaaatgtaaacagaataatc
+gttgtgttaacaacattaaaatcgcggaatatgatgagaatacacagtgtgagcatttca
+cttgtaaaatatctttggtagaacttactttgctttaaatatgttaaaccgatctaataa
+tctacaaaacggtagattttgcctagcacattgcgtccttctctattcagatagaggcaa
+tactcagaaggttttatccaaagcactgtgttgactaacctaagttttagtctaataatc
+atgattgattataggtgccgtggactacatgactcgtccacaaataatacttagcagatc
+agcaattggccaagcacccgacttttatttaatggttgtgcaatagtccagattcgtatt
+cgggactctttcaaataatagtttcctggcatctaagtaagaaaagctcataaggaagcg
+atattatgacacgctcttccgccgctgttttgaaacttgagtattgctcgtccgaaattg
+agggtcacttcaaaatttactgagaagacgaagatcgactaaagttaaaatgctagtcca
+cagttggtcaagttgaattcatccacgagttatatagctattttaatttatagtcgagtg
+tacaaaaaacatccacaataagatttatcttagaataacaacccccgtatcatcgaaatc
+ctccgttatggcctgactcctcgagcttatagcatttgtgctggcgctcttgccaggaac
+ttgctcgcgaggtggtgacgagtgagatgatcagtttcattatgatgatacgattttatc
+gcgactagttaatcatcatagcaagtaaaatttgaattatgtcattatcatgctccatta
+acaggttatttaattgatactgacgaaattttttcacaatgggttttctagaatttaata
+tcagtaattgaagccttcataggggtcctactagtatcctacacgacgcaggtccgcagt
+atcctggagggacgtgttactgattaaaagggtcaaaggaatgaaggctcacaatgttac
+ctgcttcaccatagtgagccgatgagttttacattagtactaaatcccaaatcatacttt
+acgatgaggcttgctagcgctaaagagaatacatacaccaccacatagaattgttagcga
+tgatatcaaatagactcctggaagtgtcagggggaaactgttcaatatttcgtccacagg
+actgaccaggcatggaaaagactgacgttggaaactataccatctcacgcccgacgcttc
+actaattgatgatccaaaaaatatagcccggattcctgattagcaaagggttcacagaga
+aagatattatcgacgtatatcccaaaaaacagacgtaatgtgcatcttcgaatcgggatg
+aatacttgtatcataaaaatgtgacctctagtatacaggttaatgttagtgatacacaat
+actcgtgggccatgggttctcaaataaaatgtaatattgcgtcgatcactcacccacgta
+tttggtctaattatgttttatttagtgacaatccaatagataaccggtcctattaagggc
+tatatttttagcgaccacgcgtttaaacaaaggattgtatgtagatggtaccagtttaat
+tgccagtgggcaatcctaagcaaaatgagattctatcctaaagtttgggcttgatataag
+atttcggatgtatgggttttataatcgttggagagctcaatcatgagctaatacatggat
+ttcgctacctcaccgagagaccttgcatgaagaattctaaccaaaagtttaataggccgg
+attggattgagttaattaagaccttgttcagtcatagtaaaaacccttaaattttaccga
+ttgacaaagtgagcagtcgcaataccctatgcgaaacgcctcgatagtgactaggtatac
+aaggtttttgagttcctttgaaatagttaactaatttaaaattaattaacgacatggaaa
+tcacagaacctaatgctttgtaggagttatttatgctgtttactgcctctacaaccctaa
+taaagcagtcctaagaatgaaacgcatcttttagttcagaaagtggtatccagggtggtc
+aatttaataaattcaacatcgggtctcaggatattcggtcatataatttattaagggctc
+ttcgagtcttactctgagtgaaattggaaacagtcatccttttcgttgtgaggcatctta
+caccgctatcgatatacaatgcattccaccgcggtgtcccgtacacaaggaaacttgtta
+ccttggggatataagaaaactcacacgtctcattattaaactgagtacaatttttgcacg
+agaaagtaatgcaatacaatatgatgaaagccagctaatgaaaagggatggaacgcacct
+cggatctgttgcactggattaaaatccgattatttttaaaaatattcagtgctagagcat
+atcaggtctacttttttatctggtatgtaaagcccacggagcgatagtgagatccttacg
+actcaacgaaaagttataacataactcccgttagccaaagcccaatcccgattactgccc
+taccctaacgtctgccatctaaatatcgaacttgttatgatcaatgtgactacctcccac
+cctttccccttcatttgttccactggggataagctagcgttttcagaatcaatgcaataa
+gaatagccaattgtctcacttcatcagagctcttggcaattccaggcgctacgtggttct
+ggaatatattcatttttcaaatagtaatacgtttagtgttgctattgtctacacgtttgg
+atattacgttatgtgagcggacatcaatagttgtctaactctttagtaagccagagatag
+cactcttagcgaatggataccatcttccataagtttagttaatagtccgaaacaactgct
+tcgagcatatttgaacctccttgtaggcaaatagcctcttcaaagcaatcttactaatag
+atagagtttgttttaagggactactagaaatgggacaatcttaatagtatgacctaaact
+gacatttaaagatatatccaggtggcaagcataaagatcattgcgccacctccaccgtgg
+gattacttatcagtcgatatcctatatgctaagtttgcgacggcagaatacaaactaagc
+tgagttgatgctaaccttacctatgataccccattggaccggttaacagccctacttatt
+ccaaataaaagaacttttatgctgtagaagctattatagtgatgcctggtaacttcagta
+tattaaaatgacacacatacgccatatagagctcctggaactttgaataatgagcgaact
+tcgaagttgaagagcaagaaaccatatgtcacggttgcctaaagcccggtaaccagacat
+gtgctatcattgatcattatcgaggttttcataaccttgacccattatcggctgtgcgcg
+gacaagtacttaaatcactagtttcttcacctgcttatcggtaagaaataaggttggcaa
+agaatcgcataagacggacgtagagccgcagcgttgtgcgagtccaggtgcatgcgcagc
+aataggattttaaattttgttccatttttaatttagccgtaaggatgtccgtaaatgatt
+gaaaattggattcaatctttgggcctatgctactggaacctgatcgacaaaatttcaaac
+atacgttaactccgaaagaccgtatttttgcggctagaatagtcagtcgcttggagccat
+ataccttaccacttaaacgacgtgctcctgtagttgaaatataaacagaacacaaagact
+accgatcatatcaactgaagatctttgtaactttgaggcgaagcaccctcttcgagacaa
+ctaagagtaaagtaccgggcgccgcaaggagtcgattgggaccctaaatcttgacgaatt
+gctaagaggctcagagctaccactgtaatttctctagagcccataataaatgaacgatac
+atccgtaggtagcacctaagggattataatggaagccaaatgcagttaataatattatat
+actggcgtacacgattcgacggatctctcacatagtgattcacgacccccccctttgatt
+gacacagcgtcagcattttgcaagaacgatcttctgcatagggtgcgccaccgtaaggat
+gacgtcgaagctacaactgggtataatttaccatgcttccctgatgctgagtgcaataca
+ctaagaatgagtttttaccccatatcaccagtatttgttctgttattgcgaagaaatggc
+tatgctgagttggcgactaaagtcacccatcctttttattaggtaaccccctcccttaaa
+ctaactgatttgctggagctgccctgcatacatatactttatcatttatggacgtccgtg
+acgcttattatccaccatagtcgatatgctacacggattcattaatggatcgtaggagtt
+taagttatatttactaagatcggtctcggctactatcccgccttacccggcgctatttac
+ggccatttttaatatattgacggtaattattcctatggtttcgaccgcacgtccttggac
+aagaaagaatggcaaaaaaaatgtaaaagaaaaaaaatattgagtccctaccatcatata
+aaaaatatgtgatgagtaacttgacgaaatgttagtggttattaaagactatctattaca
+ccttttgttttctgtcgtagtatattaaagtctagaagccttacaggaaaatcagggtta
+tacagccgatactccgcagcatgaatcatcgaggaggtgtcctaccatcgcgccttgtaa
+tcttgtctgtgtatactgtatttagaccttttatacaaagtaaatatctcggctttatgt
+gattgggaggggcctactcaaacatgatgacttgacctaataatcactgtgcgggcgtct
+tatgactagctattccttgaaatccaccaccaaatggttaatatgtaaaaactttgacga
+tgaaacaaggtgaatgtgtagttactttgtgtaattagctgcgtcgagcattgcttgtaa
+aaccgtcaatcgcacacgttacttccataaaatttctacgaatacacccttcttaaaaaa
+aacgtaggaattcacgagtttaacaaacgataactgtataaagtggaagtccgaagaaag
+cagatgcccgaactactcgaagatgtttcgttttcttaaccataggggcttcttaatggc
+ccactacgcacattttgttcaagcccgagagggacatccccattacgggagtattactaa
+aactgttccgtaatacgttcagcaagggatgaaaaaggccactgctcaagttattgacgt
+gggagtattacatcggaagcctgaatcccacactatgatggtctgtacaggcctagggac
+tgcgtctagacggtattaccggcttctaatcatacgatcgtgagtcttaacgggaagtaa
+ggctcacacctaccccaaaccatttatctatgtaagtataaaattgtgcgtaagtgttca
+aagtggacaataaagacgtggcaaaaacccccgcacataagccgctttagatttcacaaa
+taccaatgcggttaaaaacatccttgagtcgtacatacaccatactcgcgttaaacggat
+ataacagaagataataaatccggatgtggagtcggtgtaactatagaaagccaagtgaaa
+taatgcttaccagtcatttagctatacggctttcatttcatgtcaagagggtggagtttg
+acctgtacagttgatatatcaccgatacttagaactcacctaaagctaaaattgctcgca
+gcgtgtaatccgcatattacaaacaatagatgggattcattatacataagacacgatgat
+ctgctttttcaggttgcgagatgttgcctatcgtcaatcgagtcctgccttacaccactt
+aaacaaaagtattgacagggaacctattttcgaggtattatatagtccagcttgaatatc
+aatttgacagttaacctagtgaaaatcagtaagaggaaatacgccacattctccagtgaa
+attctacgggttatcgtctagtccaactatcaattataactcacgagatataagtaaatt
+ctcgtacttggcctgatttttattatactttggatccttagtaaacaggaagggagaaac
+cttcaacgaaaaacactggattttgttttactctcaaagctcttatatgacggaaatacc
+ctgtcaagtcttaactttattactagactaatgaaatgggcttggggtggccagaatcat
+agtacaatttagcggatacactattcggactttcctatcggctgtctggttggataagta
+tggggactaataggctagacatacctatacttaaactatacaggcgtcatctatctctgc
+aactttggagttccctgatgttctcccgccctttgggttcacatcttctataccgacacc
+cctaataacgattagtttgtgggttagagtaaattaatacggttaatattaatgtatcgt
+tgaaaagctggtgtcgccaataaggtaaccggctaggcagagtatatgtcacgaagtata
+actaccctaatgataagctgtaggaataaaattaatgctgtctctaagcgaagagatatt
+tccgactctgttttaatgacgaatctcattacttctgacttgcaaatgttcaatatggca
+cggtttcacggcacctttgtgacgcatataatgaacttagaagattataacgacggaact
+ttatatgataatccgttacgattaaagaatctgttaaatatcataatggcattcagttct
+agaccgtgcatcatggtaaacttactttctctgcatggcgacatacatttcgctattcaa
+attcgcgtgtggttacacccactcgcacctttggaatattaagagaagatgatcagaaaa
+tccattcgctcaatttttctgacgtacgtctaatttatcctaggagacaaatcgttttat
+gtctctcacatttttgaagaaaggttcgagagacaatactcaggtcctgaactgctagaa
+gatactcggtggagcgtggcaacaatgaaaaactcgtgacataaatgaatgatacttttc
+caagttcagttaagtgaatatgtttaacatacccggcttttcgatcttaagctgacgctg
+gacgtgcgagtaatgtcagtctcttacatacactagtgactccaagtttcgtcaaaaacg
+ccccctcccttctcgagcccactcacgctatgtattgacgcgaacttgttcgggatcaga
+cttttcaggagttcggtcgcgtgtccctatgtgctaatatataagttagatcgcattaga
+tgctaatctgaatacttatagacgaccttcaacgagaacgggtaccaccttgaggctaga
+gttaggtgtgaaacgacaggtagggacatataaaatttgagtgcggctttagttaagggt
+ttaattacctactcaaacatcacgctcgcgcccttcgtacgtaatcgaccatctagaggc
+taaggggactgtactaggtagtgattaatgatatcctagacgcacgtgccttagatcttc
+agactctgatggtccgcgatcaccgtaattgtagtcctccaactcgatcactttgttggc
+gtcaaagaaattacgatatctaaatacttataatacaataaccaaggatgagaatgactc
+atcgcgttggagttatattgcttgaagttctatggaatgaaagcacgttatctgccgtcc
+caatatctccagtgagctaattcattggacggtccactttgatcaatccccgaggagatg
+ttcggacactttagtctgtaacacttagcgttgagaccacgaacaattgattactcagtc
+ttgaaggtgttttccaaagttcattttaaataagactacgataggcctttcctattgata
+taaactacccggctctgttgttcgtgtgagtcgtacttctctgtgtttttctgattatag
+caagattcgattcttagtgtaaacagcgatttttatttgacccgtcaatgagaagcgcat
+aggatctaagcaaaattatcaagttgtgccacaaggtaagatctttccagttattgcagg
+taggatgtatcccacgttgatagtatgaggtctgacgtcaactgtctaggagagttgacc
+gcgtgcgggtacaccggatttgcatcgatgttgagaacgcagaactcccactgtcgtggc
+ggcgttcctgatatttagcaagaggcgttgataaagccctcatcatctagatctcgacct
+catctgccctcttgctccatcattttctacacagactactttcctatctacgttagtata
+attgctttctatcttagtatcatttagagcttctccgtcaacaggttcgtgctattaaag
+ttagtacgaaagggacaacttgtagcaacgcatttaatcggttttcgactacttcgcaca
+aaatcagataaagaagtttgtcattctattagacattgaattgcgcaattgacttgtacc
+acttatgatcgaacactgaatcaagactgtgattaactaaaatagacaagccactatatc
+aactaataaaaacgcccctggtggtcgaacatagttgactacaggataattaattggact
+ggagccattacattctctacaatcgtatcacttcccaagtagacaactttgaccttgtag
+tttcatgtacaaaaaaatgctttcgcaggagcacattggtagttcaatagtttcatggga
+acctcttgagccgtcttctgtgggtgtgttcggatagtaggtactgataaagtcgtgtcg
+ctttcgatgagagggaattcaccggaaaacaccttggttaacaggatagtctatgtaaac
+ttcgagacatgtttaagagttaccagcttaatccacggtgctctactagtatcatcagct
+gtcttgcctcgcctagaaatatgcattctatcgttatcctatcaacggttgccgtactga
+gcagccttattgtggaagagtaatatataaatgtagtcttgtctttacgaagcagacgta
+agtaataatgacttggaataccaaaactaaacatagtggattatcatactcaagaactct
+ccagataaataacagtttttacgatacgtcaccaatgagcttaaagattaggatcctcaa
+aactgatacaaacgctaattcatttgttattggatccagtatcagttaaactgaatggag
+tgaagattgtagaatgttgttctggcctcgcatggggtctaggtgatatacaatttctca
+tacttacacggtagtggaaatctgattctagcttcgtagctgactatactcaaggaacca
+ctgctcaaggtaggagactagttccgaccctacagtcaaagtggccgaagcttaaactat
+agactagttgttaaatgctgatttcaagatatcatctatatacagtttggacaattatgt
+gtgcgaaactaaaattcatgctattcagatggatttcacttatgccttagaaacagatat
+tgcccgagctcaatcaacagttttagccggaaacaatcgaagcatagggacaatgtatct
+tttcctaaattgccatgtgcagatttctgagtgtcacgaagcgcataatagaatcttgtg
+ttgcctcaactcgttgaaaagtttaaaacaatcgcagcagtctttttggggtctactgtg
+tgtttgcaaaataactgaaagaaacgcttgaacaactctgaagtagctcgagtactcatt
+aaagtgtaacacattagtgaatatcggccaatgaaccaaacgcttcccggtacgctatct
+ctctcatcgggaggcgatgtgcaggttatctacgaaagcatccctttacgttgagagtgt
+cgatgcatgaacctcattgtaacaatagcccagcaaattctcatacgtgcctcagggtcc
+gggcgtactcctccatggaagggcgcgcatctagtgttataccaactcgctttttaacta
+ctatgctgtagttctacaggcatagtggccagtattttctaacttctctggatagatgct
+ctcactcctcatccatcacggcttcagtttacgtcttacttgcttgttcagcaacggatg
+gaggcattaagtatcttcactgttccctaaaattgctgttcaatatcaaagtaaggacga
+tacagggaaagctcaagcacactcattgaatactgccccagttgcaacctcacttaatct
+gacaaaaataatgactactctaagtgttgcggaagcagtctcttccacgagcttgtctgt
+atcacttcgtataggcatgtaactcgatagacacgaacaccgagtgagaaactatattct
+tgcttccgtgtgtgtgacaccaggtaattgatgcggatataagctggagatcactcacgc
+ccacacaaggcgctgctacctctttattccaatgtgtaagaatttgctaacttcatttct
+agaccgcagctttgcggtcataatttcacggtacggacccttgggttagagacttgataa
+cacacttcgcagtttccaccgcgcacatgttttagtggcttctaacatagaatttttgtt
+gtgacataaagagtgcgtgggagacttgcccgaccgttaagccataatcaattgaaagcc
+ccgtgagtcacatctaattggttgtactgcgcatttagctatcctttagctgactcgaag
+agattcgattcctaatataggttaattagatggctgccgcgcgaagtaaaacgtgaaaaa
+cgtagtgcgcagatctgcataactcgcgcttaattacttatgagtagttccaagttcgct
+acgttatgagagagattggaattaagcaaatatgttttatggtgattttgggatgagaag
+gactgctaagtacggctactaaacaaatttctaaaaccgccatctaccttatcttggaga
+catttaagttgtatatgtcactagtctagcttttgtctgtgggacgcgttctcggaatga
+gggaaatgcaagagccgattcatcaaatgcttatctaagaaagtagtggactattacacc
+aagcacgaatgccagggaactgctttcttgctcaggacctcgcgacaaggtaccccgcat
+aagtcctagaattacatttggtcagcaatgctgacatttgaccgtgaaaacataatttta
+atcagaaggcagctcacccgcttgctctagatcttatctttgtatgaatgtcagaattta
+ctgcaatatccgttccgaatagtgagggcttagtatagttctctgtatacaggtcacatc
+aaactccccctgtcctagtacagctctgagctttaattaattgcatacatttccttcaat
+catcagatgaaaacaccgcgaatcatgctcttctcgtatagggcaagagaagcaacaaac
+aactagcccgactcacgttcatccgccgtatccttgttcagttcttactccgtattaggt
+cagcgaaatctaatcagaataatcggtcgcgtatcaaaattaaaatcccgcttgaggttg
+acaattaaaacgctgagcagttatcggctattagatagtggggtgaaagtaattggctgg
+aattatgttaaaacgtgatattaagctaaaatacgctacttgttgccgacctaattcagt
+cattcgatattcagttagagccaagaataacaagcttgtataaattgaacggggtgcact
+aaacgatgtgttactctaatattcagcttggagtatacctgaaggcgaattcatgtatcg
+gccaataataagacgttgaagatcacaatttggactagcaaaagaaggtgatttatgcgt
+ggggattgagtccactgtacgagtacggtctctggaaaattataggttcagggaatataa
+ggaagtaaagataattaccaagagatttttggtatcgctatgacccagaggtgttctaac
+gtctgttttgatccgcagaatttctgcctcaatgcatatttgacggacttgaactagagc
+ctctaaagttaaatggcgacgcaactgttcctaaacttcaattattactactcttttttt
+cctagggtattgtagaggccagtggacaaaataaatcaaatttaagatgtttcggacatt
+aacatcccccgtagcatagaaatcatcagttatccaatctctcatcgagcttttacaatt
+tctgctggcgctatggacagcatatgccgcgagacctccgcaagactcacttgatcactg
+taagtatcttcattagaggttagagcctatagttaagctgctgacctagtaaaattggta
+ttttctaattttattgctcaagttaaaggttagtgaagggataatgacgttatttttgaa
+caatgggttgtattcaattttatatcacgaatggaacccttcattcccggcataatacta
+gacgacacgaacaagctccgatctatcagccaggcacgtgttaaggtttaattccggcaa
+accaatgaagcatcaaaaggtgacctgatgcaacttagggtcacgatgagtttttcagga
+ctacttattacctattaataagttaacatgagccttcataccccgtaagacaatacatac
+tccaccaattagaattctgagccatcttatctttttgtatcatcgaagggtatggccgaa
+taggttaattagttactcctaacgtctctacaggcatgcatttgacgcaccttcgaaaat
+agtcaatctctcgccacacgcgtctagtatgcagcatcaaaaatatagtccacggtttcc
+ggattaccaaacgcggcaaagagaaacattgtatcgacggagataacttaatacagaagg
+aaggggcatcttcgaatacggatgaataattctatctgtttattctgacatcttgttttc
+aggttaatcttacgcattcaaatgacgcctgccccatgcgtgcgcaattattttctaata
+ttgacgagagcaatctcactccttttgggtctatttatgttttattgaggcacaagccta
+tacagaacaggtactattaaggccgtgagtgtgagactcaaaccgtggaaacaaaggatg
+ggttgttcttggtacaagttttagtgcatgtgggcaatccttaccaaaatcagatgctat
+ccttaactttgggctgcatttaagatggcggttggaggcctgtgagaatcctgcgtgtca
+tctttaatgaccgaattcatccatgtagattcagatcacacactcattccttgatgttgt
+ctaaacaaaagttgttgtggacgcattggagggagttaagtaacaacttgggatcgcata
+cttataaaaattatatgttaaactttcacaaacgctgaagtccaaagtaactagcccaaa
+cgcctcgagagtcactaggtattaatggtgtttgagttcctgtgaaatagtgttcgaagg
+taaaatttatgtaccaaatcgaaagaacacttaataaggcttgcttgcacggaggtatga
+tgtttactgactctacaaccctaattttccagtacgtacattcattccaataggttagtt
+ctcaaagtgctatacaggctcctcaattgatgatatgcttcagccgctctatggatatta
+gctcattttatttaggaagcccgcttagaggcttactatgagggaaatgccaaaatgtca
+tacttttcggtgtgtcccatatgacaccgctttacatagaatttgaattaaaacgcgctc
+tcccgttcactaccatacttggtaccgtgcgcatattacatatagatataggatcatttt
+ttaaagctgtactaggtttgatcgacaatcttatgctatactatatgatgtaaccctcat
+aatcaataccgatcgtacgatcctagcataggtggcaagcgattttatgccgattattgt
+gttaaatagtctgtgagtgtgattatcagggctacgttggtagaggggttgtatagacct
+cgcacacattgtgacatacttaacaatatacgaaaactgatataataaatccccttaccc
+aaacaccaatcccgttgaatcaactaccataacgtctcccatataaattgcctacttgtt
+tgcataaatctgaatacataacaccattgcaccttcttgtgttccaatcccgttaagatt
+gccttgtcagatgatatgcaagaacaatagcatttgctagcaattattaacagctcttcg
+aattgcctccacataacgcgggagggtatattttaatttggcaaatactaagtactgttg
+gcgtcatatgctattaacggttggatattaagttatgtcagccgtaagcaagagtgggcg
+aaatattttgttacccagtgagagcactcttagagtttggatacaataggccatatgttg
+acttaagaggacgtaactacgccgtacaccattgttcaaccgacttcttggcaaatagaa
+tcgtattagcaatcttaagaatagagacacgttcgtgttagggtatactacaaatccgaa
+aatcttaagaggatcacctaaactgaaatttatacatatttcaacgtggatagatttaac
+ataattcagccacctccaacctgggagtaattttcagtagatttactagatgattagtgg
+cccaacgcacttgactatataagatctggggatcctaacctgacctatgagacaaaattg
+gaaacgttaacagcccttatgtgtacaaagaaaagtaagttgttgctgttcaacagatga
+tagtcatgacgcgtaacttcactatagtaaattgaaacaaatacgcaatttagacagaat
+ggtacggtcatgaatgacagtaattcgaagtgctagaccaacttaaaataggtaaacgtg
+cccgaaaccccccttaacagaaagctgctatcatggtgcagtatcgacgtgttcagaaac
+ttgtaacttttgagcaggtccgagcacatggaagtatatcacgtgtttctgaaccggctt
+atccctaagatatatccgtcgcaaactttcgatttagtcccacgtagagcccaagcgttg
+tgcgactccacgtgcatgcccagaaatacgagtttaaatttggttacatggttaattttg
+accgaagcatcgcactttatgattgataattggattcaatatgtcgccctatgcgaatgc
+aacatgatccacaatttggctataagacgtttaatccgtatcacactttgtttgcggcta
+gtatagtaacgcccgtgcaccaagagtcagtaacaattataagtactccgcaggtacttc
+aaatataaaaactaatcaaacacgacccatatgatcatctgaagatatttggaactttct
+cgacaaccaccctcgtactcaatacttacactaatcgacaggcacacgcaacgtgtacag
+tcgcaccatattgagtcaagatttgcttagtggcgatgagcgtacacgcttatttctcta
+gtcacaattagttatctacgagacatcacgagggagcaaataagcgatgttatggctaca
+cataggcacgtatgaatatgatataagccagttaaacagtcgaaccatcgagcaaattct
+catgcaccaacccacacgttgaggcacaaagagtaagctgtttgaatgtaacttcttctg
+ctgagcgggccccaacgtaaggatcaactagaagagaaaactcggtattagtttaaatgc
+gtcacggagcatgagtgcatttcactaagaatgtctgtgtaaccaatataacatctattt
+gttatctgattgcctacttatggctttgcggtcgtggcgactaatgtctccaatcctttt
+gaggtcggtaccaactccctttaaattacgctgtgcaggctcatgcactgcatacatata
+cggtagcaggtagggacctcacgcacccttattataatcaatagtagttatcagtcaacg
+aggcaggaatgctgaggtcgaggtgttggtatattttctatgtgccgtctaggcgactat
+cacgcattaccaggcgagatttaagccaattttgaatatagtcaacgtaatttttactat
+gggttccaccgaaacgccttgcacaactaagaatcccataaaatatcgatatcaaataaa
+agattgtgtcaataccttcatatatattttttcggttgactaacgtgaactaaggttagg
+ggttttgtatgtctatataggaaacagtttcttttctgtcctactttagtaaagtcttca
+agccttactccaaaatcacggtgattaagccgttactcagcagcatgattctgcctgctc
+gggtcctaaaatccagccttgtaagagtcgctgtgtattagctagggagacctttgttaa
+aaaggatatatcgcggcgggatgtgagtgcgtggcgcatactcaatcttcagctcgtgtc
+attataatatctctcccccacgcttttcactagatatgccgtgtaagcaaacaccttatg
+cttaatttcgaaaatattggtacttgaaaaaagctgtaggggtacttaatgtctggtagg
+agatcaggagagaattgagtgtaaaaccgtaaagccctcacctgacttcatgtaaatggc
+ttagaagactccatgatttaataaatactacgaaggaaagactggatctaaagataactc
+tagtaaggccaactcccttcaatgctgttgccagttataatccaagagctgtccttttct
+gaaccatagcggcttctgaagcgaactagaagcaaagttggttctagccagacagccaca
+taccctgtacgggtgtattactaaaactggtccggtattagttcaccaagggaggaatta
+ggcaaaggatctaggtatgcaagtcggagtattacatccctaccctgaatccatcaatag
+gttcctctgtactggccttcgcaatgagtattcaaggttgtacagccgtataataataag
+atagtgactatgaacgggaagtaacccgctcaccttccccaaaacattgttatatctaag
+tattaaagtctgccgtagtgttaatactcgaaaataaacaactggcaaattacaccgcac
+ttaagccgcttttgatttatatttttccaatgcgcttttaaaaataattcagtcctacat
+actaattaagacccttaaacggagatatcacaagttaagttttaaccatctcgactaggt
+ggaactatagatacccaactcaatttatcattacctgtaatgttcctagaaggattgcat
+ttcatgtcaagacggtggagtttcacagcgaaacttcagtgtgaacagattctgagaaat
+cacctaaacctattagtcagagcacccggttagaaccagttgtcaaaaaatagagcggtt
+gcatgagacagaagtaacgatgagatccgttgtaacgttgagacatctggcctatcgtca
+atacagtcctcccttaaaaatatttttaaatactaggcaaacccaacataggttagtcct
+atgtgatacgccacatggtatatcattttgtaacgttacctagggataatcaggaagtgg
+aattacgcaaaagtagacagtgaaatgcttagggttatagtctagtccaaagataaagga
+taaagcacgtcagagaactatattagccgaatgggaatcattgttaggagactgtggatc
+atgtctaaaaagcaacgcagaaacagtcatcgaaaaaatctcgtttttgtttgaatctaa
+aagagctttgatgaccgatagtacctgtatactagttactgtattacgtgtctaatgatt
+tcggattggggtccccagaatcagacgtcattgtagacgattcaagtttaccaatttaat
+ttcccagctctccttggagaactatcgccaataattgcagtcactttccttttctgaaac
+gataaagccgtcagagttctctgcaacgttggacttacctgaggttctaacccactttcg
+gttctaatagtagttaacgacacaacgaataacctttactgtggggctttcacgatattt
+tttcgcttattattaatggttacgtcataagctggtgtccaaattaaggttaccggcttc
+gcagagtagttgtatccaagtataacttccctaatcataagatcgaggtagaaaattaat
+gctgtctctaaccgaacagatatgtcccactatgtggtatggacgttgctaattacttct
+gaagggaaattggtcattatggatacgtgtctaccatcaggtcggacgcagatatggttc
+tgtcttcagttgatccaccgttctttataggataataactgacgattaaagattatggta
+aatagattaagccaattctcttcttgtcagtgaagcatccttaactgacttgctctgcag
+cccctcatacatttagctattcaaagtaccggctcgtttcaaactctcccacctttggaa
+gaggttgtcaacttgataagtatatcatttacagcattttttcggacgtacctctaatgt
+ttcattgcagaaaattagttttttctatcgcacattttgcaagtaacgttagagacacaa
+ttatctgcgaatgaactgctagatctgacgaccgggagcctcgcaaatatcaaaaaagac
+tgacatatatcaaggagtcgttgacaagtgctggtaagtcaattggtttatctgtcccgg
+cgtttcgatcttaagctgaccatgcacggcagagtaatgtcactctcgttcttacaagtc
+tgtctccaagggtcggcaaaaaagacccctccattctcgagcccactcacgatatgtagg
+gacgacaacttgtgcggcttatgaattgtctggactgcgggcgagggtccatatctccga
+agttagaagggacatacctttagatgataagatcaattcttattgacgaaattcatccac
+aacggggaacaacttcaccctagacttacgtctgaaaagacacctagcgtcttataaaag
+gtcagtgccccgtttcgtaaggctggaattacctacgcaaacttaaacctcgcgcccttc
+cttacgtatcgacaagatagaggctatcgcgaatgtactacggaggcatgaatcatatac
+tagaaccaagtgcctgtgatattaacaagatgatccgacgcgagcaccgtaattctaggc
+ataaaactccagcaatttgggggccgaaaacaaatgacgttagctaattaattatatgac
+atgatcaaaggaggtcaatcacgcatcgagttcgacgtatattcattgaacttcgtgcgt
+ttgaaagaaacttttatgaaggcaaaattgatcctgtctcctatttcatgcgtacctcct
+agttgataattccccgagcagtggttaggacacttttgtcggtatcaagttccggtctca
+aaacgtaaaattctgtaatctgtatggatggtctgtgaattagttaatttttatgaagtc
+gtcgagacgcagttcctattgatttattctaaacggagatgtgcttcgtgggactcggaa
+gtagatctgtgtttatgattattgctactttagatgctgactgttaactccgtgttgttt
+ttcaaccgtatatcacaaccgaattggatagaacctatagtttcaagttctgccacaagg
+tatcatatttacagttagtgctggttgcttctttcaaacgtggtgagtttgtgctatcac
+gtcaacggtagagctcagtggaccgagtgcgcgttcaaccctgttccagagagggtgtga
+tagcacatataccacgctcgtcgaggcgttcatgatagtttgcaagagccggtgttaaac
+acatattattattgttatccaactaatcggacctatgcataaagcattgtctaaacagaa
+taattgcctatatacggtagttttagtgatttatatcttagtatcagttagagcttcgaa
+ctcttcaggttcctcatatttaacgttcttcgaaagcgaaaacttctacaaacgaatgta
+agcggttttccaagtagtacctataaatcacagaaagatctgtctcagtatagttgaaat
+ggtattcagctagtgacgtgtaccaattatcatagttcactcaagcaagacgctcattaa
+cgaatatagacaagacactatatcatataataaaaaagaacatggtgctcgaacatagtt
+gaattcaccatattgaaggggaatgctgacatgtaattcgctactagacgatcaattccc
+tacttgtcaaagttgaactggtacgttcttggaattaaatatgattgcgctggaccaaat
+tgcgacttcttgagtttcagggcaaacgattgagccggaggatgtccgtctcttaccttt
+cttgcttatgataaacgacggtccctgtacatcactgggaattctcagcaaaaataattg
+ggtaaatcgagactcgatgtattcggccacaaaggtgttagacgttaaagattattcaac
+ggggcgataataggatcataaccggtatgcaagcgcattgaaagagccatgagatcctta
+tccgataaacgctgcacggtatgtgcagccttattgtcgatcacgaatttataaatgtag
+tctgggctgtaagttgaagacctaagttataatgaagtgcaataccaaatcgattcatag
+tggattatcagactcaagatatctcctgataaattacagttgttaagatacggataaaat
+gagatttaagattagcagcctctaatctgtttcaatcccgttggaatgtggtatgcgatc
+aaggttaagttaaaatcaagcctgtcttcagtcttgattcttgttctgccatcgcatgcg
+gtctacgtgagttaatatgtagcttacgttctagcttgtgctaatctgagtatagattcg
+tagaggaatattatcaagcttccacgcctcaacgtacgtgtattggtcacacaagacact
+aaaagtggaagtagcgtaaactatagtctagttgttaaatgctcagttcttgttatattc
+gatatactcttggctaatttatgtctgagtatataaaattaatgatattaacttgcattt
+cacggatcccttagaaaaagattttgaccgagcgcattataaacggttacaccgaatcaa
+tagaagcatacccaatagctttctttgaatttattgcctgcgcaacttggctgactctct
+agatccgaataattctatatggtcgtgacgaaactagttcattactgtttaaaatgccaa
+catgtcttttgggccgataatggctctttgcaaaattactcaatgatacgattgatcaaa
+gcggtagttgctagtggtagcatgtaagtctatcaaatgtctgattatccgaaaatcttc
+caaaagagtccacgtaccatatctatctcatagcgacgcgaggggaaccttatctaacta
+tcattccatttaccgggtgactctcgatgcaggatccgattgggataaattgcccagaaa
+tggctcattcctgactaagggtaaggccgttctcagcaagggaaccccgcgaatctaggc
+ttataccatctagattgttaactacttgcctgtagttctacagccatactggacagttgt
+ttctaaatgatcgggattcatgctagcactcctctgaatgcaccgcgtaagtttaactat
+tacgtccgtgggcagataaggatggaggctgtatgtatcttaactgttacctaatatggc
+tggtaattatcaaagtaaggaccttaatgccatagcgctagcaatcgctttgtatactga
+ccatgtgccaacctctcttaatctgtaaaatataatgtcttagctaactgtggacgatca
+tgtctctgcctagagcttcgctgtatcaattcctatagccagcgtactagtgacacaaca
+acaccgtgtgagaaaagatattagtccttacgtctgtctctctacagcttattgatgagg
+attgaacatggacatatagctccccctcaaaagcagatgctacctctttattccattctc
+gaacatttgccgaacttaatttcgacaaacctgaggtcacgtcttaatttatcggtaacg
+tcacgtccctttgagactggataaatatattaccaggggccaacgagcaattgttggagg
+cgcttctataatacaaggtgtcttgtcaaagaaagacggcgtgcgtctcgtgcaactcac
+ttaaccaatattaatgtgaaacccccctctctcacatcttatgcggtgtactgccctggt
+acatttcctgtacaggactccaacagtgtagattcctaagatagctgttggagttgcctc
+acgccagatcgaaaaactgaataaactagtgagctgagctgcagaaataccgcttaatta
+cttatgactagttcaaagggacctacgtgatgtcagacattgcaaggaagaaattaggtt
+tgtgcgtcattttggctggactagcactccttacttcccctactattcaaatgtcgtaaa
+cagcatgagacaggatcgtgctgacatttaaggtctattgggaacgaggctacctttggt
+cgcgcgctcgcgttctccgaatgaccgaaatgcatgagcacagtatgcaattgcttatag
+atctaaggtctggtcgttgaaaccaagcacgtaggcctgggaaatcagttcttcctcagc
+aactacacaaaagcgtccaagcattagtacttgtagtaaatgtccgaacctatgcgctca
+tttgaaagtcaaaaaatatttttaagcagtaggcacctaacccgattcctctacttagta
+gctttctttgattctcagaattgactgcaatatcactgcacaattctgtgccattactag
+acttctctgtattaacgtctcatcttactaacactcgcctaggacacatctgagagtgaa
+gtatttcaatacatttactgaaatcttcagttctaaaatccccgaataaggctcttatcg
+gtttggccaacacaagaaaaaaacttcttgcaccactcaccttcatacgcaggagcctgg
+ggaacttagtaataactatttcggcagacaaagcttataacaagttgccggcgcgtataa
+tatttaaaagaccccttgagctgctcaattaaaacgctcacctggtataggctattagat
+agtgccgtcttagtaaggggcgggaattatcggataaactgatattttgataaaataacc
+gacttgttcacgacataagtcactaaggagattttatctttctccaaagtatatcttcct
+tggataatttcaaagcgctgcaatttaagttctgttactagtttatgctgctgggaggtg
+accggaaggcgtagtaatctagaggcaaattataagaagttcatcatatcattttcgact
+acaaaaacaaggtgttgtatgccggcgcattgtgtaaactggacgagtaccctagatgga
+aaattatacgttaagccaagatttcgatgtaatgataattacctacacatttttgctatc
+cataggaacaagagctgttctataggctcgtggcatacgaacatttgctgccgctatgaa
+tattggaagctcttcaactacagactctattcttaattgccgtcgaaaatgggccgaatc
+ggctattattaatactcggtttttccgaggggattgttgtcgacagtcgtaattattatt
+aatattgatgttggtgaggtcatttaaatacaaccttgcagacaatgaataagggatcca
+atctctcatactccttttacaattgctcatgcccctatgcaaaccttatgccgccacacc
+tccgcaactctctcttctgaactgtaagtagcttcattactggtttgagactatactgaa
+gctgatgacattctaaaatggctattttcgaatgtgattcataatgtttatcgtttggga
+tggcagaatcacgttatttttgatatagcccgggtattctattgtatagaacgtatgcta
+caagtcattccccgaagaagactagaagtaaacaacatgcgaccatcgttaagccacgca
+aggctgtagctttatttcccgataacctatcttccataaatagcggacagcaggatactg
+acgctcaacatcagtggttatggtctaatttttaacttttaataaggtaacttcagcagg
+catacacagtaactctttaatttataatcaaattagaagtctgacacttcttatattttt
+ctatcatccaacgcgatcgcccattagcttattgtgttactaataacgtatctaaaccaa
+tccttttcaagctactgcctatattgtcaatatatacaaacaacaggatagtaggctgct
+taaaaaatattgtcaaccgtgtacgctttacaatacccggaaatcacaaactttgtagac
+aacgagtgaaatttatacactacgaagggccagcgtacaagacccatgaattaggcgata
+tgtttattctgacatattggtttatccttaatctgtcgctgtaaaatgaagccgccccca
+tccctgcgaattttttttcgaagattcacgactgaaatataaatacgtttggctatattt
+atgttggagggaggcaatagcctttactgttaaccgaagatttagccagtgagtgtgaca
+ctaaaacactggaataaatgcaggcgttcttctgggtaaaaggtttagtcaatctcgcct
+ataagttcatatagctctggatataattatctggcccatgcatttatcatggcgcttggt
+gccctgtgtgaagccggcctctcatattgaaggtccgaagtattccatgtacattaagat
+cactctctcattcatgcatcttggcttaacaaatctggttgtccaagctttccaggcacg
+tatggtacaaattcggatcgaatacttataaaaatgatatgttaaactgtctaaaacgct
+catctacaaagtaaagtgcactaaccaatagagtctcaagaccgtgtaatgctggtgcac
+tgaatgtgtaatacggttagaagggattagttatgttacaaatccattgaaaacttaaga
+agcattgcgtgctcggagggtgcatcttttatcaagagactaacattattttcaacgacg
+tacatgctttacaatagggtacttatcaaacgccgagaaacgcgcctatagtgatgttat
+gattatgacccgatatccattggaccgaattttatgtaggttcccagcgtactcgcgtaa
+tatctcggtattgccataatgtaatacttgtcggtctctcccagatgaaaaagcgttaca
+gagtatttcaatgaaaaacagcgcgcaacgtcaatacctttaggggtaacggccgctgat
+ttcatatagatatacgataagttggtatagctctactaggtggcatccacaatcgttgca
+tttactatagctggttacaatcataatctataccgttccttacatactaccatagcggga
+tagcgtttttttgccgttgattgggtttaagaggatgtcagtctcattatatccgattcg
+gtgggagagccgttgttttcaaatcgcacactttgtgacataatgtacaagataacaaaa
+ctgatataagatataaactgtcaatatcaccttgacacttgaatcaaagtaaattaactc
+gcaaatataatttgactaattgggtgcagatttctcaattaataaaaaaatggcaccgga
+tgggcttacaagccccttatcattcacttgtatcatgatttccaagaacaatagaatttg
+ctagcaagtatgaacagagattcgaattgcatccacagtacgccggagcgtttattttaa
+tgtggatatgacgatgtactgttggcggcatttgctagtaaccggtccttatttacgtag
+cgcacacgtaagcatgtctgggagaaatatggtggtacaatctcagagaaagattacagt
+ttggtttaaataggacttatcgggtcggaagtggaacttaataagcagtacacaattggg
+caacagacgtcttgcctattacaataggattacaatgcgttagatttcagacacgttcgt
+gtttggctattcgtcaattccctaaatagttagacgatcaactattatcaaagtgattct
+ttgttcatcctccattcatgtaacagatggcacactacgcataacgccgaggaattttaa
+cgagatttaagagagcagttcgggcacaacccacttgactttataacagctcggcagcat
+aaacggtaatatgtgacaaatttccaaacgttataagaacgtatgtgtacttagaaaact
+aagtggttcatgttcaacagatgtgacgcagcaagcctaacttatctattggttttgcta
+taaaagaacaaagttacacagaatcctaagggcttgtttcacacttatgcctagtgcttc
+accatcttaaaatagcgaaaccggcacgaatcaaaccttaaaacaatgcgcagatattgg
+tgatggtgactccgggtatgataatggtaactgttgaccagcgcccacctcatcgaagta
+tagaaagtggttaggataaggatgagaccgaacttatttccggccataactttagatttt
+ctacctagtacacaacatcagggcggacacgaaaccgccatcacatcatataccaggttt
+aatttgcttaatgggggaagtgtcaacgaaccttcgaactttagcaggcatatggccatt
+atatatggccccagagcagaatgctacagcagacaaaatttggatttatgtagtttaata
+cctatcaaacttggtgtgaccatacttgtctaacgacagtgcacaaagtgtaagttacaa
+ttattactactcagcagcttctgcaatgataaaatcttatcatacacgtcacatatgata
+atatctacttagggggaacgggctccacaacctacatagtactcaatacttacactattc
+gacaggcacaccaaacctgtacagtcccaaaagattgagtcaactttgcagtactgcaga
+tcacagtaatagcttagttagcgagtcaaaattagttttctacgagactgcacgaccgtg
+caaatttccgatgtgttggctacaaatagcaacgtatgaatttgtttgaagccacgtaaa
+ctgtacaaccttagagataagtctcaggctactaaaaacacgttgtggcactaacaggat
+catggttgattcttacttattcggctgaccggcccaataagtaaccttcaactagaacag
+aataatcgggagtagtttaattcagtcaaggtgcaggtctcattgtaactaacaagctct
+gtgtaaccaagttaaaatcgttttcttagcggattccctacttatggatttgagctcgtc
+cacaatattcgatacaagaagtttgtggtccgtaacaacgaaattttaattacgctgtgc
+agcctcatccaaggaattaatagaaggttgatggtaggctccgaacgctccatgattata
+atcaagtggactgtgcagtaaacgaggaaggtatcctgacgtcgtggtgttcgtttttgt
+tatttgtgccctatacgagtagataaaccatgaacagcacagtgtgaacccatggttgat
+tttaggctaccttatttttaatttccgttacacagaaacgaattccacaactaacatgcc
+attaatttttcgatatcttataaaagatggtcgaaattcattcatttattttttttcggt
+tctcgaaagtcaactaagctgtcgcgttttgtttctctttagaggtaaaagtggctttga
+tctcctacgtttggatactagtcaaccattactccatttgatccgtgagtatcacctgtc
+taacatccagcattatgactcctcggcgaagaaaagacacacttcttagagtcgatgtgt
+attagctagggacacagttgtttaatacgatagtgagcccagggagggcagtgcgtcccc
+cagtagatttattcagctagtgtaagtataagatatctcacccacgaggttcaagtgata
+tgcagtcttagaataatacttatcctgaatttcgatattatgggtacttcaataatccgc
+tagcgctactttatgtctcgttggacagcaggacacatggcagtcttaaacactaaagac
+atcacctgaatgaatgtaatgggattacaagaatcaatgaggtattatatacgacgtagg
+aaactctggatatatacagtaatctagttacgccatcgcacttcattcctctggaaactt
+agaagacatcagctgtacgtggaggaaccagacccccgtatgtagccaaatagaaccaaa
+gttgcttatacaaacacacccaatgacaatggaccgctggagttcgtaaactcggaacgt
+agtactgcacaaacccagcatttagcaataggagctacgtatgcaactcccacgtggtaa
+taccttcaagctatcaatatataggtgcctagctaatcgcattcgcaagcagtattcaag
+cttgtaaaccagtataataattacagaggctctatgaaacccaactttccagctaaaagt
+cccaattaaatggttatttcgtacttttaaagtcgcccgttctgttattacgcgaattga
+ttctactccaaaattaaacacaaattatcaaccgtttcatttatatttgtcaatgcagct
+gtttaaaataaggctctactaaattataattaagacacttattaccagatttctctagtt
+aagtttgaaccagctcgactaccgcgaaagatacattcccttctctatttttcagttcat
+ctatgggtcagagaagcattgaatttattctattcaccctcgtcgttcacagcgaatcgt
+cagtgtgatcagtgtatgagaaatatcctaaaccgtttagtcagaccacacgcttagaac
+aagtggtctaaaaagactgccctggaaggagtaagaagtatacagctgatccggtgtatc
+cttcagtcatctgccctatactaattacacgacgcaaggaaaaataggtttattttctag
+gcaaacccttcataggtgactccgatgtgttacgaatcatgcttgagaatgtgctatcgt
+taccgacggataataacgatctccaatgaaccaaatgtagaatgtctattgattaccctt
+ttactattcgacttagagataggagatagaacctcagtgtacttttttagccgaatggga
+atctttgggaggtgaatggccataaggtcgtaaatccaaccctcttaaagtcttccatat
+tatatcgttgttcgtggaatcgataacagatttgttgacccatagtaaatgtatactagt
+ttatgttgtaagtgtagattgttttccgattgccgtccaaactttatgtcgtaattgtag
+accagtaaagttgaccaaggtaagtgcccagcgatcctgcgagatcgatcgccaattttt
+ccagtcactgtaagtgtaggtttagataaagccgtatgagttatatcataagggcctcgg
+aaagcagcttcgaaccaaagttcccttataatagtagtttaactataaaagtatatactg
+gtctgtcgccctttcacgatttgttttaccggtttatgaagcgttacgtcattagagcgg
+ctccaatttaaggttaacggcttccatgtgtagttgtatacaaggataacttaaagtatc
+tgttcagcgagctagttaagttatcctcgatagaacacaactcagaggtcccaagatcgg
+gtttgcaacttgctaatttattctcaaggcaaattgggaattatcgatacctgtatacca
+taaggtcgctcgatgtgatgcttatgtcttctggtgatcctaccttagttagtgctgatt
+aacggaacattaatgtttatcgttttgagatttagccaattctctgattctaactcaaga
+tgccttatctgacgtgctatgcagcccctaagtattttacattgtaataggacacgctcc
+tttaaaactcgccaaaaggtcgttgtggttctctactggttaactatataatttacagct
+ttgttgagctagttcctctttggtttaagtcctcaatattagttggttcgagcgataagt
+tggctagttaccttagtcactatattagatccgaatgttatgcttcatctgaagaccgcc
+accctccaaaatttcttttaagactcacttattgcaaggtgtaggtgaattcggctcgtt
+tctcaagtggtgtatctgtacacgagtttccatattttcatcaacagccaccgcacactt
+atgtcactctaggtattaaaagtcgctctacaaggggacgcaattaagaaacagacatgc
+tagtcaaaaataaacatagcgaggcaccactaattcggccgcttatcaatgggatgctct
+gcgcgagacgcgccagagctcagtagttagttcggacatacatttacttcagatgatcaa
+ttagttttctacaaatgcttactctaccccgaaaaaagtcaccagactcttacgtctctt
+tagtatccttccgtcttatataaggtcagtcccccgtttcggtaccctggaatttactaa
+gaataatgaaacagcccccaaggacgtacgtttacaaatgatagaccagatcgcctagct
+tattccgacgcatgttgcatagaattgaaccaacggaatgtgagagtaactagatgagcc
+gaccacagcacccgtttgcgtcgcagaatacgcctgatagttcggccacgaaatcatatg
+tcctttgagtattaagtatttgtaatgatcaatcgagctcaagcaagcttacacttcctc
+ggatattcagggaacttagtgcctttgaaagatacgttgatcaacgaaaaattgataatg
+gctcatatggaatgcctacctcatagtgctgaattaacacagcactgcggacctaacttt
+tcgaggtttcaagttcacgtctcaaaacctaataggctggaatatgtagggatcctcggt
+gaatttgtgattgggtttgttgtagtactgaccaagtgaatattctttttttctaaaagc
+agatctgctgccgggcactacgaaggagatctctgtgtatcattattgcttcttgacatg
+atgactcttaaatcactgtgggtgtgcaaaacgatagcacaacccaattcgatagtacat
+attgttgatacttcgcactaaaccgttcatatttaaaggttgtgctccttccttcgttaa
+atactggtgacttggtcctatctactattagctagacctctggggaaccacgcccccgta
+aaacctgtgcaagagagggggtcatacatcttagacatcgcgcctccaccagggaagcat
+tgggtgattgaccaggtgtgtaacaaatatgattattcttatactaatattagcaaagat
+gcataatgatttgtattaaatgtataattgaattgataagggtcttttagtcagtgatag
+agtagtataaggtagacattagaactcttaaccggacgcagatttttcggtcttagtaag
+ccaattagtcgacaaaacaaggtaagagcggttactagtagtacctataatgcactgaat
+cttcggtcgaagtatagttctaatgctatgcagattgtgacggcgacaaatgttcagact
+tatatcatgaaacaagctcttgtaagtattgacaaatgaaaagattgaatatttttaaat
+acaaaatgcgcctacttattaggggaattaaccagattgaaggccaatcctcacatgtaa
+tgagataatagacgataaatgaaattcttgtaatagttgaactgctacgtgatgggtatt
+atatatgattgagatcctccaattgccgacgtcttgtcttgatgcccaaaagattgtcaa
+cgaggagctccctcgcgtacctgtcgtccgtatcataaacgacgcgacatgtacagcact
+ccgaagtataagcaataataatgcgggtaatccagactagatcttttcggactcaatgcg
+gtttcacggtaaacatgattaataccggagagtagtcgagcttatcagcgatgcaagcga
+attcattgtgccaggagatacgttgcagataaaaccggcaacgtatgtcaacaagttttg
+gcgatctcgttgtttgtattcgacgaggcgcgggaacttcaagaactatcgtatattcaa
+gtccattaccttttagtttcagactggtggagctgactaaagttatatcatcattttgta
+cactggtttagttaacgataatttcagatttaacatgaccagacgataatcgctgtatat
+ccagttggaatgtggtttgccagaaaggttaacttataatcaagcctctcttcagtcttg
+attcgtcgtatcccatccattgcgctatacctcagtgtatttggagctgtagttataccg
+tgtgctaagatcagtagacatgacgagagcaatattatctaccttacaagcatcaacgga
+cgtctagtcggaacaaaagactctaaaactcgaacttcaggttaatatactatagttctg
+tattcagcagttattcttatattcgatattatcttgcctattggatgtctgactttagta
+tattaatcatagtatctgccatgtaaaggtgccagtactaaatctgtttcacagtgcgaa
+ttataaacggttacaaccattaaagacaacaagaccctatagctttatttgaattttgtc
+aatgcgcaacttggagctcgcgatacatcccaattagtctatagggtcgggacgattcta
+cggcatttctggttataatgacaacatggattgtggcccgagaatcgctctttcattaat
+taagcaatcattacagtcttataagcgctacttccgagtggtagcaggtaactcgatata
+aggtcgcatgagccgaatagcttaaaaaacaggccaccgaacattgatagagaataccga
+ccacagcgcaacctttgattactttcattaaattgtacggctcactcgacatcaagctta
+agattgcgataatgtgaactcaaatggatcagtactgaagaaccgtaacccacttcgcag
+aaagcgtacccagagaagatacgctgttacaatatacagggtgaaattattgcctgttct
+tcgtaaccatttcgccaaacttggttagaaatgatagccattcatgatagaaataagctg
+aatgataccagtatctttaactatgtagtcagggggaagataacgatggtccatgtatgt
+ttctgatatgtgacagtattggccgcgtaatttgctaacgaagctacttaatgcctttga
+gcttcatatagatttctttaatcaaaatcggcaaaaagatagtatgagctataatatatg
+ctagtagagaactctggaccatcatctatatgaatactgattcgagcgtgcaattacttt
+agcctgcgtactactgactctacaaaacactctgagataagtttgtagtcagtaagtcgc
+tctctataaaccttttggatgaccattgtacagccacttatagatcccaataaatagcac
+aggagacagagtttttcaatgctcgatcatttgccgatagtattttcgtctaacctcagg
+gcacctattatttgatacctaacctaacggccctttcacaatggagaaatatatgacatc
+gggacaaacacaaatggtgggtggccaggagatatgacatggtggcgtctctaagaaaca
+cggactccctctaggcaaactcacgtaaccaattttaatgtcaaacaaaacgctcgaaaa
+gattttgccgtgtaatgacctggtacattgactggtcaggaatacatcactgtagttgcc
+gtagtgtcctgttggtgttccatcaagacacatcgtataacgcaatttacgacggacatc
+agatcaagttatacagattatttaagtatcacgtgtgcattgggacataagggatctcac
+acatgccttggaacatttttgctttgtgccgctttttcgctgcactaccaatccttactt
+accagtatattcaaaggtcgttaacagaatgagaaaggttagggctctaagttatcgtcg
+attgggatagacgagacatttgcgagcgccctccacggatacgaatctcccatatcaatg
+tgaactggatgctatgcagtttagttcttacgtctcctagtggtaaaaatcaaagtagca
+ctcgcatagcagttattcagaacctaatacacaaaaccgtcaaacattttctaattctag
+gtatgggccgatcataggagctaaggtgaaactcataaatgttttgttagatctagcatc
+ctaaaaagatgcatatactgagtagctggcgtgcattctctcaattgtatcctttttaac
+tgaactagtcggtcccatttcgtgactgagatctattaaccgataagattaataacactc
+gcattcgtatcagctcagagtgaagtttttcaataatttgactgatatattaacttctaa
+aataaccctttaagcctcggatccgtttcccaatcacatcaaaaattcttattccaacta
+tctacggattaacaacgtgcatggggatcgtagtaagaacttgttccgatcactttgagt
+atatcaagttgacggcccggttattattgaatagaaacattcacctgctaaattaaatac
+cgcacatcggatacccgatttcagagggccgtcttactaagggcaggctttgttcggttt
+aactgagatgttcattattttacagtatgcttcaactaatatgtaacgaaggacagtgga
+tctgtctccatagtagatcttcagtcgtgaatttcataccgctcctatttaagttcgcgt
+tcgagttgttgatcatggcacgtgaaagcaacccctagtattctagacgaaaattttttc
+tagttcatctgataatttgccaattcaaaaacaaccgctggtttcccggcgcattctcta
+aaatggaagtcgaacctagagccattatttgtcggtaacccatgagttccttcttttcag
+aagttaatacactgtggtcctatacagaggaaaaacagcggttatatacgatcgtggcat
+aacaacattggatcaagatagcaatttggctacctattctaattctcactagattcggta
+ttccactacaatatcggcagattaggattggatgaataatcggtgtttaagtccggttgc
+gtctccaatctcctaatttttattaatattgatcttggtgacctattgtaaataaaaact
+tcaagactttgaataacggtgaaaagatagaagactcatttgaaaatggatcatccacag
+atccaaacattagcaagacactaatccccaactagctattctgatcgcgatcgtgctgca
+gtactcctgtcacaatagtctgttcatgatctaattctttttgggctttgttcgatggtg
+attcagaatctttatccggtcgcttccctgtagctactttgtggggatattgcccgggga
+ttatagggttgagatcgtttcctaaaagtatttaaaccaagtagacttcaactaaactac
+atcagaacatcgtgaagacaccatacgcggtacctttatttaccgataacatttcttcaa
+gaaataccggtaagcagcataatgaccctaaacagctcggggtatcgtcgtagttttaaa
+ttttatttaggttactgctcaaggaataaaaactaactatttaatttataataatattac
+aaggctcacactgattagatttgtctataagacttcgcgatcccccattaccggattgtc
+ttaagaataaactagataaaccatgcattttctagataaggcctttagtctaattagata
+caaaaaacacgatagttgcatccttaatttattgtgtcaaacctggaaccttttaattac
+ccgcaaatcactttatgtcgagactacctctgaaatttattatctacctaccgcatgagg
+acttgaaccatcttgtaggagttatgtttattagctaagattcgtttatcctgtagcggt
+ccatgtatattcaacaagcaaaaagcactcagaattgtttttagttgagtcaagactgat
+atataaataagtttccctagttttttcgtggtgggacgatattgaattgaatcttaaccg
+aagagtttcccactctgtcgcacaataatacacgccaatatttccagccctgcttatgcc
+ttaatcggttactcaatctcccattgaagttcattttgatctgcatagaagtttcgggcc
+cagccttttttctgccaccttcctccaagctctgtagacgcactctaagattgatgctca
+catgtattaattctacattaacataaatatataagtcatgcatcttcgagtaaaatatct
+ggttctccaacatgtcctggcacgtatcgttataatgcccatacatgtagtattaaaatg
+attgggttaactggatattaagatcatcgaaattgtaaagtcaaattaacaatactgtct
+caagaccgtgtattcctcgtgctcggaagggctattacgcttacttccgttttggtatct
+taatatgactttcaaaaattaagttgcagtgagtcctacctgcgtgcatcggttagcaag
+agtataaaagttgtttaaacgaactacttgctttacaataccggtcgtatatatcgccgt
+gaatccagaagattgtcttctttggattatcaaccgagatcctgtggaccgatgttttgg
+gaccttcacagaggactccaggtagagctcgcttttgcattaatctaagaattgtacctc
+tctaaaagatctaaaacagtgaatgtgtatttcatggaaaaacacagagaaacgtaaatt
+actttaggccgaaaggcacatgagttattatacatatacgagatggtggtatacatcgaa
+ttcggggcatacactatagttgcattgtatttagctgctttaaataatatgatattacct
+tccttacataagacattaccggcataccctggttttcaacttgtggggctttttgacgat
+cgcactctcatttgatccgagtagggcggtgacccctgcttttcaaatacaaaaatttcg
+ctatgaaggtaatagattacttttcgctgttatgatagaaacggtaaatttaaaattgaa
+acttctagaaaagtaaagtaacgagaaatgattttgtgaataatgcggtcatgattgcgc
+aagtaagaaaaaaaggcaaaaggatgcgcggaatagaaacttatcagtcacgggtatctt
+gatttcattcttcttgtcaattgccgacataggatgaaatcagattccaatgcaatacac
+agtaacccccacccttgattgtaatgtcgatttgaagttgtacgcgtcgacgaagtggat
+agtatacgggccttttgtacggtgcgatcaactatgaatctcggcgagttagatggtcgt
+acaatctcacacatagaggtcacttgcctgtaatgacgaattttcggctaggtactcgaa
+ctttattagaagtaaaaatgtgggcaaaagaaggattccattttacaagacgattacaat
+gagttacatgtctctcaacgtagtctttccctagtagtctttgaactatttaggtactcc
+agaaaattttagcaaagggtttctgtgtgaatccgccattcatgtttatgatggaacaat
+aagaataacgccctcgtatgttatcgacagtgaagtcagcagttcggccaaaaacatatt
+caatttagtacagatccccagaagttaagctaagtgctctaaaatggcctaaacggttat
+caaagtaggtctaattactatactaacgggtgcatcgtaataactgctgtcgatgcaaca
+ctatatgatagtgtcgttttgctatatatgtacaatgtgacaaagaagccttagcgattc
+ttgcaaacttaggacttcggattctcaatcttaaatgtccgaaaacgcaaagattcaaaa
+atttaatctatgagcagatatgcctgatggtgactacgcgtatgttaaggctaaatgttg
+acaaccgcacacataatcgaactattgatagtcgggagcataaccaggtgaacgtacttt
+gttcacgacatttattgacatgttctaaatacgtctcaaaatcacggcgcactagaaaac
+gcaatcaaatcattgtcctggtttaagggccgtaatgccggtagtgtcaaacttcatgag
+aactttagctggcttttggccagtatttagggaccaagagcactagccttaagctgaata
+ttttgccatttatctactgttataactttaaaacttggtggcaccagacttgtcgataca
+cacgcatcaatctgtaacgtaaaaggtttactaagaacaagcgtaggaattgagtttata
+ttatatttaaactaaaagatgatattagcttctgagggcgatagggctccaaatcataaa
+gaggaatatattattacacgattagaaacccacaacatacctcgaatcgcccaaaagttt
+gacgaaacttggcagtactccacatctcagtaatacagttgggagagtctcaaatgttgt
+tttattactcaatgaaccaccctcataatttcactgctgttccattaaatttgcaaacga
+tcatttgctttgaagaaacgtaaaatcgacaaaattacagataagtagatgcataataaa
+aaaaactgctcgctataacacgatcatcgtgcattcttacttaggagcatcacccgcaca
+ataacgtaccttaaactacaacactattagaccgagtactgtaattcacgaaagctcaag
+ctcgcattgtaaagaacttgctctctcgtaaaatgtgataatagtttgcggagaggattc
+aattattttccattgcacctactccactagattcgataaaagaaggtggtcctcccttaa
+aaagaaatgttaagtaacatcggaaccataagcaaagcatgtaagtgaaccgtcatcctt
+ccctaagaaacataaaggtttttaataatgtcgactgtgaactataactgcatcctttcc
+tgacctactccggttccttgttgttatttctgaacgagaccagtagataaacaatgtaaa
+ccacagtgggtaccaatggtgcatgtgacgctaccgttgttttaagtgcccgtacaaaca
+taagaagtcataatcttacttgaaattaattttgccttttattttttttcaggctcgaaa
+ttaatgatttgttttttttgaccttctagttacgctaatatgcggtcgcctgtggtttct
+attgagtcctataacgggatgggatctaatacgtttggttactagtaaacaaggtataaa
+tttgataccggagtatcaactgtataacatcaagctttatgactcatacgcgaagtaatg
+acacaaggctttcaggagatcgcgagtacagagccactaaggggtgtattacgatagtga
+caccaccgagcgcactcactccccaagtagatttatgatcctacgctaagtattagatat
+ataaccaaagaggttctagtcagtgcaactcttagaataataattagccggttttgcctt
+tttaggcctaatgcaatattcagctagcccttatgtatctcgcgttccacagcaccactc
+atggcacgcgtttaaactaatcaaatataatctatgaatgttatgccagtacttgaataa
+atcaggttttttataagtccttgcatactctcgttatatactgttagagtcttaccccat
+agaaattctttcatctgcaaacttagaagaattctcagctacggggagcataaagtcccc
+aggatgttgacaaatacaacaaatgtggcttatacaaacactccatatgaaaatcgaacc
+ctcgtggtagttttagccgaaccttgtacggataaatccctccattttccaatagcagat
+acctatcctactacctcgtggtattaaattaaagcttgaaatatagagctgcatagctta
+tccaattcccaagcacgagtctaccgtcgtaaccacgatttgatttacagacgctagagc
+aaacccatctttaaacatataagtaaaaattaaagggtgagtgcgtacgtgtttactagc
+aacttcgcttattaagacaattgtttataagccataattaaaaacatatgttcaacaggt
+tcattgatatttgtaattgcacaggtttttaataaggatctacgtaagtataatgaacaa
+actttttaccagagttatattctgtactttgaaaatgctcctctaccgccttagagactt
+tcaattagattttttgcagttaatctatgcgtaagtgaaccatgcaagggatgcgattca
+accgcctcgtgctaaccctatcgtctgtctcataactgtaggtctaatataattttcagt
+tttcgaacacataaccctttgaaaatctgctatttaatgtctcacctgcatgcactatct
+tctatactgctcagaacggctatacgtcactatgctccaagtgacgatttaaacgaagca
+aggaataataggtttattttagtgcaaaacaattaagtgcggactacgtgctctttacaa
+taagccttgtgattgggctataggttaagtcccatattaacgatctccaatgtacaaaat
+cgacaatcgctttgcattacccggttactagtcgaattacagatagctgttagatactca
+ctctaattttggacaacaatcccaatcttggggtcgtctatcgcctgaagctcgtaaatc
+cttccatcttaaacgattacatattatagacttgttcggggtagagatatcacagttgtg
+caaacattgtaaatcgatactagtttatgttggtagtctagttgcttttaccattccccg
+aaaaacttgatctactatttcgacaacagtaaacttgaactaggtaagtgaaaacagaga
+atgcctcatagtgccactatttgtccactatatgtaagtgtagctttacataatccacta
+tgactgagatcattacggcctaggaaagcagcgtagaaaaaaagggcccggatattacga
+ctgtaactataaaactagttactggtagcgcgccatgtatagatttgttttaccggttgt
+ggttgcgttaacgaatttcagccgcgaaaattgatccgttaaccagtccatctcgacttc
+tataaaacgataaagtaaagttgatgttcagcctccttcttatggttgcatcgagagtac
+actactcagtgggaaatagatcggggttcctacttcagattgtattatctaggcaattgc
+cgattgtgccatacctggataaaataagctacctacatgtgatgcttatctattatcgtc
+atactaccttagggtgtcctgttgaacgctacattaatctttagccgtttgagatgttcc
+aatggataggagtctaacgcatgatgaagtttaggaaggcagagcatcccactaagtatg
+tgacagtgtatttcgaaacgagacgttataaatagaaaaaaggtccttctggttctattc
+tgctgaactattgaatggaaagattggttgacctacgtactatttgcttgaagtcatcaa
+tttgacggggtgagagacatatggtgcatactttacggactctatattttagatcagaag
+cttagcagtcttctctacaccccctcacgacataattgcttttaagaatctatgtttgat
+tcctctacgggaattcggatccgttcgcatgtgcggtttatctaaaccaggggacatatg
+ttcagctaaagcatacgaacactttgctaactagacgtatgtatagtagctataaatccc
+gacgatatttacaaaaagaaatgagactcaaatatatacatagcgaccctacacttattc
+gcaccctgatctaggcgatcctagcacccacacccgaaagtgagcactagtgtcttccgt
+attaaatttactgcagttgagattttagttgtctactaaggattactctaacccgtaata
+aggatcaagactcggtactagctttactatcattccctatgtgttttcctaactcacaag
+ggtacgtaccagcctatgtaattacaataatgataaagacacaaaggaagtaactttaca
+aatgagtctccagttacactagcttagtccctcccatcttgctttgaagtctaaatacgc
+aatctctgaggatatacagcagaagaacactcataacgttggagtccaagaattagactc
+atagggcccccaacatttaatatgtactgtgagtttgaaggtgttctattgttaattcct
+gctcttgatacatgacacgtactccgtgtttaaggcttcggactgactttctttcataag
+ttgagcaacgaaaatttcagaatcgataagttggattcactaactaatacggctgattga
+aaactccactccggacctatatggtcgacctttatacgtaaccgatataaaacttatagg
+ctggtatatcgagccttcctagcgcaatttcggatggggtttcttctactactcaacaac
+ggaatagtctttgtttagtaaaccagagctcaggacgcccaatacgtaggagagcgctgt
+ggagcatgtgtcattatggactggagcactcttaaatcactctgcgtgtgctaaacgata
+gatcataacatgtcctgagtaaattttcttgatacgtcgcaatataccgttattagttaa
+acgttctcatccgtcatgcgtgaaatacggctgtcgtgctcagatatactattagcgact
+catctcgcctaacacgcacacgtataaactcggaatgactgccgctcttacatattagaa
+atacagactacaccacggaagcattgggtcattctcaaccgctgtataaaagatgattag
+tcttataataagattaccaaagaggcagaatcatgggtagtaaatctattattcaagtga
+ttaccgtcgtgtaggcagggagtgaggacgagatggtactcaggacaaatattaaccgga
+cgaagtggtttacgtcgtactttcactattagtagtaaatacaaggtaacaccggggaat
+agtactaaatataatgatatctatcttcgggagaacgagtcgtctattgctttgaacatt
+ctcaaggcgtaaaatgtgctgacttatagcatgatacaaccgattgttacttttgtctat
+tcaaaagattgaatagttttttatacaaaagccgcatacttatgacggctagtatacagt
+ttcatcccctagcatcaatgctatggacagtattgaacttataggaaattcttctaatag
+ggcaaatccgtcgtgatgcctattttttttcagtcacatcctcaaatggcactagtattg
+tcgggatcccattaacaggctcaaccacgagctcacgcgaggacatgtagtccgtatctt
+taacgaagcgacagcgacagaactcccatggataaccaattataaggcccgtaatcctct
+agacatcgtttaccaataaatccgctttctccgtaatcatgttgaataccccagagtagt
+ccagatgataaccgatgaaacacaagtctttctcaatgcacttacggtgaacttattacc
+gccaacgtagctcatcaaggttgcgacatctagttgtgtgtttgcgacgagcccagcgaa
+cttcatcaactttcgtatattcaacgccttgtaattttactttaagacgcctggtgatgt
+agattcttagataatcagtttgttatcggctgtactttaccataatttcacaggtttcag
+gtcaagaagattatagctgtatatacagttccatgctcggtgcacagaaacgtgatcgga
+taataatcaatcgcttatgtcgtctttaggcgtatccaatacatgccccgataccgcagt
+gtatttcgacatgtaggtataccgtcgcatttgagctcgagtcaggacgtcagctagatt
+agattccttaatagaatataccgacctctagtccgaactaaactatagataacgccaact
+tcaggttaattgtctagtcgtctgtttgcagatgggattcttagatgagtgagtatcggc
+catattggttcgagcactttagtttttgatgcataggatatgcaatgtatagctgaaagt
+actttatctgtttcaaactcacattgattaaaccggtaaacctttaaagactacaagaaa
+atattcagtgagggcaattttgtcaatcacaatcttccagctagagatacttcacaattt
+gtcttgaggctacgcaacattagacggattttcgcgttttattgaaataatcgaggggcc
+caagagtatccatagttcattttgtaagatttctttacaggcttattacagcttcttcag
+actcctacatgcttacgagttatatgctagcatgtgaacaatagattaatatacaggaaa
+acgtacattgagagagatgaccctacacagcgcaaccgttgagtactttcattaaagggt
+aacgctctcgagacagcatccttaagatggccttattgtcaaatcatttgcagaagtacg
+caagatccctaaccaacgtagaagaatccctacaaacacatgagacgcggtgaaaataga
+cagggtgttagtattcaatcttcggagtatcaatttcgccaatcttggtgagaaagcata
+ccctttcttcagagaaagaagatcaatcataacactatctttaacgaggtacgcacgcgc
+atcattacctgcctccatggatctttaggatagcggaaagtattggcagcgtattgtgat
+ttcgttcctactttatcaatttcacattcatatacatgtcttttatcaaaatcgccaata
+agataggatgagctatattagatgctagtagagttcgcgccaacatcatcgataggaata
+ctcaggacagcgtgataggacttttcaatccctaatactctctataattataactctctc
+ttaagtttggaggcagtaacgcgctctatataatcagtttgctgcaccattcttcagcct
+ctgatacatacaaataaattccacagcagtaagagggtttaattgagacatcttgggaac
+ttaggattttactctaacatcaccgaaacgattattggataccgtacctaaacgaacttt
+ctcaaggcagtaatataggacatccgcaataacacaaatgctgcctccccaggagttatg
+tcttcctggaggctatatcttacacccactcactataggcaaactaaagtttaaatgttg
+attgtctaaaaaaaagatagataagagttggccggcgtagcacatgcgaaagtgaatcgt
+aagctataattctctggacttgaagttctgtcctgttcctctgcaagaaacaaacttcct
+ttaaagctatttacgacgcacatctcagcaagttataaacatgttggaagtttctagtcg
+gaattcccaaagaacggatctatctaatgcattcctacatttttcctgtctgccgatggt
+gccatcctattcaaagaatttcttaaaagtagattaaatgggacttttaacaatgagtaa
+ccttacgcctctaagggttcctcgagtgccatacaccagtcaggtccgagccacatacac
+ggagaacattctaacatagcattctcaactcgatcatttgcaggttacttctttcctatc
+ctagtgctaaaaatcatacttgcaatcccatagcacggattaagaacctaagaaacaatt
+cagtaaaacatgttcgaattcttggtatgggaacatcattgcagctatggtctaacgcat
+taatgtttgggtacatcttccatcatataaacaggaagagtctgacgacagggagtgctt
+gcgatcatgtctatcattgtgaaatcaaattgtagctcacatgtcgtctatgagagcgtg
+tatccgataagatttagaaaaatagaagtcgtataagatctcactgaacttttgaatgaa
+tgtgaagcatatatgatctgctttaataaaactttatccataggatacgtttccaaatca
+attcaataattattagtcaaaatagataaggatgaacaacctgaaggccgatcggacgta
+gaaagtggtcccatcactttgagttgatattgttgaaccacacgttattatggttttcaa
+acagtctcaggatattgtatatacagataatccgataccagttgtctgacgcccctctta
+cgtaccccaccctttgtgacgtttaaagcagttgttcagtattttaaactaggcggcaac
+taatttggaaagaagcacagtggatatgtctaaattcttgttattcaggcctgaatttaa
+tacaccgcatagttaacttcgcggtagagttgttcatcatgcctcctctaagctaccact
+tctatgatacaccaatagttgttctacggaatctgataattggccaagtcataaacttcc
+gctgcgttcaacccccttgctcgaatatccaactcgaaaagacagccttttggtgtccgg
+aacaaatcagttacttcttttctgatgttaattctctgtggtcagatacagaccaaaaac
+tccgcggatttaccatcctccaagaacaaatttgcatcaacatagcattttggctacata
+ttctaagtctcaatagtttaggttttcaactacattatcccaacattaggattggaggaa
+taatagctgggtaagtccccttgcgtctacaatcgactattttttatgaatatgcttctg
+ccgcacctatggttattaaaaaagtcatgactttgaagaaccctgaaaagatagatgaat
+caggtgtaatggcagcagccaaagagcatataattagcaacactctaagaacattataga
+tatgatgatagcgatcgtcatgatgttatccggtcacaatagtagcttcatcagctaatt
+cgttttgccagtggtgacttgcgctggaagaatcgttatacggtcccttccctcttgata
+cggtgggggcttattcaaccgcgtggattgggttgtcatacttgcattaaacgatgtaaa
+ccatctagtagtcaactatactaaatcacaaaatagtgatcaatacatacccgcttcatg
+gttttaaccatttaattgattaaagatattccgctaagaaccattatctacctaaactga
+tcgccgtatcctagtagtttgaaatttgatgtaccgtaatgatcaacgaagtaaaacgtt
+atattgtatgtagaataataggtcttggagctaaatgatgtgattggtagtgaagactta
+cccttacaactttaccggtttctcggaagaatatactagagaatcaatgcatgggctaca
+taagcactttagtctaatgagataaaaaatacacgagtcttccatcatgaattttttgtc
+gaaaaactcgaacctggtaatttaaaccatatatctttatgtcgtcaataactctcatat
+gttttatataacttcccaatcacgacttgtaactgcttgttcgactgagctgtttgagct
+atgaggccgggatccggttgagctacatctatttgctacaagaaaaatgaaagcacattt
+gttgggagttctggctacactcatagagaaataagtggcccgagtgggtgcggcctgcct
+ccatattcaagtgtatcttaaaccaagtggttccaacgctcgcgctaaagaattaaagcc
+tttatttcctccacggagtagcccgtaatccggttcgaaagagaccattgaagttaattt
+tcatatccagtgaagtttaggcacaagcatgtgttctgccacatgcctcaaagcgctctt
+caaccaagatatgattcatcctaacttcgatgaatgcgtctgtaacataaatatagaagg
+aatgattcggcgagttaattttcgccttctccaacatggcatccctacgttcgttataag
+gaccatacatgtaggttttaaaggtttgcggttaatcgatatttacatcatagaaattct
+atagtcaaatttacaagactctagatactcactcgttgcagccggctaggaagcgctttg
+taccttacttcccttttcgttgcgtaatatgaatttcatatagtaagttcaaggcactca
+tacctccgtgaagagggtagatagactattaaagttgtttaatagtacgtattgatggaa
+atgacccgtaggagatttaccactcaatccacaagattcgctgctgtgcattatcaaaac
+agtgcatgtcgaaacatgggttgggtccttcaaacacgaatccaggtagagatacctttg
+caatttttcgatgaaggcgaccgagataaatgagctataacactgtatgtcttttgattg
+ctataaaacacagaaacggatattaatttaggccgtaaccaacatctgttatttgacata
+gaacagatggtcctttacagcgtattccggccttaatattgaggtccagtgtattgtcct
+cctttaaagaagttgattgtaactgacttaaataagacatgtcacccattcactgggttg
+caactgctggccctttttgtccatcgcacgctaatgtgataacagtaccgccctcacacc
+tgcgtttaaaagacataaatgtcgctatgaaggttattcattaattttagctgttttctt
+agaaaaggtaaatttaaaattgaaaaggctagaaaactaaagttacgacaaatgtgtttg
+tcaagtaggcgggcatcattgagattgtaagaaataaagccataaccagccccggaatag
+aaaatgttaaggaaaggcgatcttctttgaattcttattgtcaagtgcagtcatacgttc
+ttatcagaggacattgcaataaaatctaacaccctcccttgtgtggttgggccatttgta
+cttcgaagcgtccaccatgtgcagaggataacggaatgtggttccgtcccataaacgatc
+attctcgcccacttagtggcgcggtaaatcgctctcatagaggtaactggcctgtaatgt
+ccaatgttaggctaccttctccaactttagtacaacgaataatgtccgattaacaaggag
+tcaatttgtcatgaccagttcattcaggtacttgtatctatacggacgcgttccagagta
+gtatttgaaattttgaggttctactgataagtttagctatcgctgtatgtctgaataaga
+atttaatgtttatcttcgataaataacaattaacaactcctaggtgatacactgtgaagt
+ctgctgttccccaaattacatatgctattttgttcacataccatgaagttaagctaagtg
+ctctataatggcataaacggttatcaaactagctcgaatttcttttattacgccggaagc
+ggattaactgctgtagatcaaacacgttaggatagtgtcgttttcatatatatctaaatt
+cggtctaacatgcattacccatgcttgataacgtagcacttcgcagtctaattatgtaat
+gtccgtttaaccaaactttaaaaaagtttatctatcaccagtgatgcctcatcgtgacta
+cccggatctttagcctttagggtctaaacagaactaatattactacgtgtcatactccgg
+agcttaaccaggtgaaacttatttgttaaccaaatttagtgacagggtagaaatacgtat
+caaattaacccagcaatacaataagcatgaaaataattgtaatcgggtttgggccggaat
+cccgcttggcgaaaacttaatgacatagtgtgatgcattttgcactggattgagccacaa
+actcaactagcattatgctcaatatttggccagtgttctacggtttgaaatttataaagg
+ccgcgcaaaagtcttgtagttacaaacgcataaatctcgaacgtaataggtttaattaga
+acatccgtaggatttctgtttatagtagatttatactaaatgttctgattagattctgac
+ggccttacccatacaattaataaagacgaatatattagttatagtttactatccaaataa
+attaagcgaatcgaaataaactgtcacgatactgggcagttatcaacttatcacttatac
+agttcggacactctatattggtctgtgagtactctatcaaactaactcataagttaactg
+cgcttccattaaatttcaatacgttcttgtgctgtgtacaaacctataatcgaataaatg
+acacatatggagatgcataataaaaaaaacggctccatatttctcgttaatcgggcattc
+ttaaggaggagcatctcaccaaaaataacgttcctgataagtcttaactattagaccgtc
+ttcgggaatgaacgaaacctcaagctagcatggtatagttcttgatagcgcgtaaattct
+gataatactgggcggacagctggaaattagttgccagtgcacctacgcaaatagtttaca
+taaatcaacgggctccgaacgtaaatacaaagggttagttacatcgcaacaagatgaaaa
+gcatgtatgtctaccgtcatccgtccctaacaaacataaaggtggtgaagaatctcgtag
+gtcaactataactccatccttgaagcaactactccgcgtccgtgtgcgtagttcgcaacg
+agaacactactgaaaaaagctaaacaactctcggtacaaatgcggcttgtgtcgataaag
+ttggtggtagtgcacggaataacataacaaggaatattatttattcaaattttttgtgac
+tgttatttgttttctgcctagaatgtaaggatgtgttttttgtgacctgatagttacgct
+tatttcaggtccacggtgcgtgagagtgtgtcctataacggcaggggagcgaagtagtgt
+cctttagactattcaaggtagaattttgataacgctctataaaaggtagaaaatcatgat
+tgagcaataagaccccaacttatcaaaaaaggagttctcgacagcgcgtgtacagtccct
+ataacggctgtatttcctgtgtcacaacaccctcccatcgcactcaaaatgtagatttat
+gatcagacgctaacttgttcttagagaaaaatacacgggatactctgtgcaacgatttca
+ttaataaggtgcagcttgggacttttttggccgtaggctttattaacattcacagtaggt
+agcgagacttcctatgaaccaatcatgccacgcgttttaacgtttcaaatataagctagg
+aagcgtttgccaggacttctataatgcaccgttttttttagtacttccttactagcctta
+gtttatgttagagtctttccaattacaaaggattgaatagccaaaatttctacaattctc
+agcgaacgccagcttaatctaaacacgagcttcaaatattctacatatcggcaggagtca
+atatataaatatgaaaatcgtaccatcctcgtacttttagaccaaacgtcttcggataat
+taaatcctttttcaattaccacagtacgtgcattagaactactgctatgaaagtaaacct
+tgaaatatagtcctcaagagcgtatccaagtacattgcacgtgtatacagtcgtataaac
+gagttgatgttctgacgctagagcttaccattcgttaaacagataactaaaatttaatgg
+ctgagtgacttagtgttttcgacaaacgtcgcggatgtagactattgtttataagcaatt
+tttaaaaacatatgttcaaaacggtatgggatatgtcgaattccacaggggtttatgtac
+catagaagtatgtataaggtactaaaggtttaaatctgtgatattcggttcggtgaaaat
+cagactagtcacacttagtgtctgtaaattagattgggtgaaggtaagcgatcccgaact
+ctacaaggcatgggatgagattctaccgactccggataacactttacgatcgcgcataac
+tctagctcttagataagtttaacttgtcgatctcataaacagttcaaaatctgcgattta
+ttgtatcaaatccatcctctatcttctataatcatctgaaccgcgatacggcactatgag
+ccaagtgaagattgaatccaagaaagctataattggtttattttagtccatttaaattaa
+gtccggtataagtgctctgtacaatatgcagtctcatgggcatatacgttaactaccttt
+tgatacttcgaattggtaaaatatcgactatcgatttgcagtaaaaggtgtagagtccaa
+ttactctttcctgttacatacgatctcttagtttggacaactagcccatgatggcgctcc
+tctagcgcatgaacctactttataattacatctttatcgatgaatttttttagactgcgg
+aggccttgagttttaacagggctgctaaatttcttaagcgattagacggtagcgtcgtac
+gctacttgcttggaacaggcaccgaaaatattgatctactattgcgtcaactctattctg
+ctaatagcgatggcaaatcacagaagccctcttagtgacaatagttgtcaactatatcta
+agtcgacctttactgtatcaacgatcacggagagaattaccgaatacgaaacctcaggac
+taaaaaacggaaaggatttgtcgacggtaaatataatacttgttaagggtagcgacacag
+gtatactttgggtgtaaacgtggtgcttcccggaacgattttcagaccagaaaattgttc
+cggtaaccaggaaatctcgtctgcgttaattcgtgttagtaaacttgatcttcagactcc
+ttcttttcgttgcagcgagacttaaattatatctgcgaaatagtgccccgtgcatacttc
+agatggtaggagataccatttggcccattgtgactttacgcgattaattaaccgacatac
+atctgttcctgagctatgatcgtctgaataaattacggtctcctcttgatacctaatggt
+ttctggagacgtttctcatgttcaaatggatagcaggagatcgcttcatcaagtttagct
+acgcagagcatcaaaatatgtatgggaaagtcgatttccaaaccagaagggataaagaga
+aataacggacttctccgtagattagcctgatattttgatgggaatcatggcggcacatac
+gtaagagttgcgtgaacgaatattttggacggcgggagacacatatcggccattcgttaa
+ggtctctatattggacatcacaagcttagcagtatgagctactaacactcaagacattat
+tgattttttcaagatatgtttcattcctctaccgctattcccatacgttcgattcgccgg
+gtgagcgaaaccacgggactgaggttaagctaatcaataacaactcgttgcgatagagac
+ctatgtatactagagagaattccccaacatttttacaaaaacaaagcagactaaaataga
+tacagtccctccatacaattaggaccaacatgttattgccgatcctagcacacacaccac
+aaactcagaacttctgtcttacctatgaaagggtctgcacttctgattgtacgtgtctaa
+ttagcattaatattaaaactaattaggataaactataggtacgagctttactataagtca
+ctaggtgttttccgatcgaaaaacgggaccttcaagccttggtaagtacatttaggataa
+agaaaaaaaggaaggtacgtgactaatctgtctaaactgacaatagagtagtacctacat
+gcttcatgtcaagtcttaatacgcaagcgctctcgttatactgctcaacaaaactcataa
+agttggactccatcatttagaatcatagggaccaaaacatttatttgctactgtcacttt
+gtaggtgttctattctgaattcctcatattgatacatgaatcggaatacctgtggatccc
+ttaggacgcacgtgctttctttacgtcagaatacatattgtcagaatcgagaagttccat
+gcaattaagaattcgcctctttgaaaactcatatccccacatatagggtccaccgttatt
+cggaaacgatataataattattccagcgttgagcgtcccttaagagcgcattttcgcttg
+gcctttcttctacgactctacaacgcaagtggctgtgtggagtttaccacagcgcagcac
+cccatagaactacctctgagagcgcgagatggtggcagtatgctctgcagctagcgttta
+gaacgcgcccgcgcattaaccagtcatattaaaatggactgtcttaattgtcggcattag
+gagcaatattaactgatgagggtatcggtcgcagaagtaatgacggaaatacgcctctag
+tccgcagagatacgattacagactcagatcccctaacaagcaaaacgattaaatcggaat
+cactccccctatgacatatttgaaatacacaagaaaccacgcaacatgtcccgcattctc
+aaccgcgctttataagatgttgagtctgagaattagatgacctaactgcaagaatcatgg
+cgagtttatctagtaggcaagtctgtaccctagggttcgaacgctgtgacgtcgtgatcg
+gtctaaggacttagatgataaccaagaactggtttaccgagtactttcactattaggagt
+aattacatgcgttcaccgcggaatacgacgaaattttttcatatctttatgagcgagatc
+gtgtcgtctttgcattgcaacagtcgctaccagtaattgctgatcaattatagattcatt
+atacagatgcttacttttctctattcaatactgtcatgagttgtttttaaataagcacca
+gaattatgtcgcctagtataatcttgcttccacttgaatcaatgcgatggacagtattct
+actgattgcaaagtagtctatttcggcttagcagtacgcatgcctatttttttgcaggca
+cagaataatatgcaactaggattctcggcatccaattaacaggctaaaacaccaccgaaa
+gacaggtaatctacgaagttgatgtttactacagaaagcgaatgatatcacttggagaac
+attttagatgcccccttttaatctagactgagtgtaccaatatatcaccggtctaccgaa
+tcagcttgaataaaccactctagtactcatgataaccgagcatacacatgtatttctcaa
+tgcactgaaggtgaactgtttacaccataccttgcgaatcaacgtggcgacttatacttc
+tgtctttgagtacagcacaccctaatgaatctaagttagttgttgatacgaattgtaatt
+tgactggatctcgcctcctcatctagattcttagagaagatgtttcttatagccggtact
+gtaactttattgatctggtttatggtaatcaacattttacctctatttaaacgtccttgc
+gccgtgcactcaatcctgatcggtttagattcaagcgattatcgagtctggaggccgaga
+aaagaaatgcacagagtaagctctctattgcgacatctacgtagaaactcgcatttcaga
+tcgagtaagcaactctcattgtgttgattcagtaatacaagattacctacgcttctacga
+aatatactatagatttagcctacgtcacctttagtgtcgagtcggagctttgaagatcgg
+atgcggtgtggactgtgtataggcaattttgctgcgagctcgtgacttttggttgatgtc
+gatatcaatgggatacctcaaacgtctttatctctggataactcacattgagtataccgg
+taaaaatttattctattcatctaaatagtcagtgagggctagggtcgcaatcacattagg
+ccacatacacatacttaacatgttctattgacccgacccaactttagtagcattgtagcc
+gtttatgcaaatatgccaggcgccaaacactagccagagggcattttgttacatttattt
+aatcgattattacacagtcggaacacgcctacatgcgttcgacttatttgcgacatggtc
+aacaattcagtaatttaatccaaaacctaaagtcagagacatgacactaaaatcacatta
+aggtcagttagtgaaggaatggctaaccagctagagaatgcatcattaacaggcacttat
+tgtcaaatattttccagatctaagcaacatcacgttaaaaagtacaacaatcacttaaaa
+cacatcagtccaggtgtaattagaaagccgcttagtaggcaagcgtaggagtataaatgt
+agacaatagtcgggacttagcagacactggatgcagtcatagaagatcttgcataacacg
+ttagggttagagctacgaacgcccatcattaactgcctaaagcgtgcgtgagcttagcgc
+taacttttccaacacgtttgtgatttcgttcataatgtatcaatttcacagtcatataca
+gggagtgtagaaaaatcgcaattaacatacgttgacctatttttgttcagagttcagtta
+gagcctaatgattcgagagcaataatcaggacagcctcataggaagtgtcaatcacttag
+aagctatattattataaatcgctctttactgtcgtcgaaggaacgagcgagagagaatca
+gttgcctgcaactggcttaacaatatgatacataaaaatattttcatcaccactaagacg
+gtggaattcagacttattggcaacttaggatgggactattaaataacccataagatgttg
+ggataaagttacgaaacgaaagggatatagcctgttagataggaaatccccaataaaaca
+tagccggcctccacagcagtgatctattccgccacgcgatatctttataccacgcaatat
+accaataataaaggttaaatgtggttgcgatttaaaaaagatacatatcagttgcaccgc
+gtagcaaatccgtatgtgaagcgtaacctagaattatagcgtctgcaagttctctaagct
+tcctctgcaagatacaatatgactttttagcttttttactaccaaatctcagaatcttag
+aaacaggttggtacgtgctactcggaattcccaaagtaccctgctatatatgccattcct
+tcattggtccgggctcaccatggggccatcatagtaatagaaggtagtaaaactagttga
+tttccgacttttaacaatcactatcctgacccagatatgggttccgactggcccttactc
+cagtaagggcagacacacagacaacgagaacttgataactttgaattctcaaatcgatca
+ttgcaacgtgacttatttactagcctactcctataattcatacgtcaaatacatttcaac
+ggaggaagataataagtaaatattcactaaataatggtcgaaggagtcctttgccaacat
+aagtccacatatgcgctatagattttttcttggggttcatattcaataagataaacagca
+agagtatcacgtcagcgagtcattgagatcttggctagcattgtgatagcatattctacc
+taaatggtagtctagcacagagtggataagatatcagttagatatagacaagtactataa
+cagatctcgcttcgttggattgtatggctagctttgatgatatgattttataaaaattga
+tccagacctgacctggccaattatattcattttttatgagtaaaaatagataaccatgaa
+aatactcaagccccttaggacgtacaaagtggtaacataaatttcaggtgttattctgca
+accacacctgttttgggttttcaaaaaggctaagcagattggttttacagataatccctg
+aacactggtatctcccaacgatgtcgttcccaacccttgctgaccttttaagctctgctg
+aagttttgtaaactaggcggaaaatatgttcgatagatccactcgcctgaggtagaaatt
+cgtcttagtaacgcctctttggattacacagaatagtgtactgacacgtacactgctgca
+gcagccatacgctaacattaaaattcgttgagtctacatttgttgttattcggattatgt
+tattgggaatagtatttttattcccctgcgtgaaaccacatggatagattagcctactcc
+taaagactcccttttggtctacggttcaattctcttactgagtttatgttcgtaattata
+tcggcgcagtgaatctcctaattatcaccggagttaccagacgccatgaacttatggcca
+gaaacattgcatgtggcctacataggattagtatcaagagtttacgtttgcaacgacatt
+tgaccaacttgaccattcctgcttgtagaccgcgggaactcccctgcacgcgactataga
+agttggtggtggatgtggcttatgccgcaaatatggttttgaaaaaagtaatctattgct
+tgatacctgaattgagacatgtataagggctattgccagatgaaaaactgcatataaggt
+caaacaatataagaacattatacataggatcttagcgttcctcaggatggtatacgctat
+aaagtctagcttcagcagctaaggagttttgccagtgcggacttccgctggaagattagg
+tttaaccgccctgacatcttcataaggtcgggcctgattcaaacccctggagtgccgtct
+catacttgaattaatcgatggaaaacttcttctagtctaatattattattaacaaatgac
+ggttcaataaataacaccgtaagggtgggaaactgttaagtgatgaatcattttaaccta
+tcatccattagctacagataatgataccccgatccgactagggggtaagtggttgttccg
+ttaggataaaccatgtaaaacgttagagggtttgtagattaattggtattccagataaat
+gaggtcagggcgagtgatcaattacactgaaaaattgtcagcttgcgcggtagttgttaa
+gacagtataaatgaaggggattcagaagcaagtttctcgattgactgaatttataaacca
+gtcgtcaatcatgatttttgtgtcgattaaagcctaaatggtaatttaaaccattgatat
+ttatcgagtctataaatatctttggttgtatattacttcacaatcaccaattctaaatga
+ttcttccactgtgcgggtggagatatcaggacgggttaaggttgacctacatcgttttga
+tacaacaaaaatcaaagcacatggctggggacttctcgatactatctttgagatagtacg
+ggcaagagtgggtgacgcctccctacattttcaagtctatcggataacttctcggtaaaa
+cgctcgcgatatagttttaaagcattgatttaatccacgcaggagcaagttttaccggtc
+gaatgagaaaattcaacgtaagtgtcatatccagtcatggttagccaaaagcatgggtta
+tccaaaaggaataaaacagctcttcaacaaagagatgaggcttcataacttcgatgaatg
+cgtatggttctgatatatagatcgatgcatgaggacactttattttagccggcgaattaa
+tggaatccatacgttacttatttggacatgacttctaggtgtttttgctgtcccgtttag
+cgatatttacagattagtatttcgtttctcatagttaattgtatctagatactaactcgt
+tgaagacgcataccttgccatttgtacaggacttaactgttccgtgcgtaatttgaattt
+cttataggttcttcaaggcacgaatacctcactcatgaccgttcatactctagttaaggt
+cgggaatactacgtatgcagggaattgtaacctaggagatttacaactctttaaacaaga
+gtcgctgaggtccaggatcaaaacactgaatctcctaacttcgggtgcctccgtaaatca
+cctagaaacctactcatacatttgcaattttgagatgtaggcgaaagagagaaatctgct
+ttttaacggtatctcttgggattccttttaaaaacacataacgatagtaatgtaccaagt
+aaccaaaagctgggatgtgtctgtgtactgatccgccgtgtcagagtagtccgccatgaa
+tattgacgtcaaggctagtgtcatcaggtattgatgttcattgtaaatgaaggaatgaac
+taatgtcaccaagtaaagggggtgaaaatgctccccagggttctacagacatagagatgg
+tcagaacacgacccccctctcaacgcagtgtatttgaaatatatggacatatctacctta
+ttctgtaattttagatgtgttctgtgtataccgatattgataagtcaataggcttgatta
+cgtatcttaagacaaatctgtttcgcaagtaggaccgcatctttcagattgtttcttttt
+atgccataacctgcccaggaattcaaaaggttatcgatacccgatatgctgtgaattatt
+attctaatggccactcattcctgcttatatctggaattggcatgaatatcttacaaccta
+aagtctggcgttgcgccagttctacttcgtaccggacaccatctccagtcgttaaccgaa
+ggtgggtacgtcacataaaagttcattagaccacactttgtgccgacgtatatagatata
+ttacacgtatagggaatgttttctcctaggtgacccgaccttctactaaggttgtacatc
+gtataatggcccattaactacgaggaaagtggtattgacctggtaatgcacgttcttcga
+tatataccgacgaggtaaagtctactattgcaaagtttgacgttatactgataagtttag
+atttccctggatcgcgcatgaacaatgtatgcgttatctgccatatataacatgttacaa
+atccttggggatactatcgctactatcatcggaccaaaattaaataggctagtgtcttat
+cagaacatcatgtttaccgaactgatctattttccaatttaagctgatattacgtccgcg
+tatttattttagttccccggatgacgattatctgagctacatcatacaagttagcatact
+cgccggtgcattgatttcttatttcgctatatcttcaagttcacaggcttcatatagttc
+caattagcagtataattaggttttgtaactttaaccatactttataaaaggttatattgc
+acaactgatcaagcatccgctataacccgagctttaccagttagcggctaataacaaata
+agatgacttcgtgtcatacgaccgtcatgatcatgctctaacttaggtgggaaccaaatt
+taggcaatgggtagtaataagtataaaatgataccacatatactataacaatgaaattat
+ttgtaatccggtttgccaacgtatcccccttcgcgataaattaatgacatagggtcatcc
+atgtgccaatcgtgtgtgccaaaatctcaaattcaattatcatcaatattggccaagtgt
+tataagcgttgaaagtgatataggccgccaaaaagtagtctacttaaaaaccaatattta
+tcgttcgttattgctggtagtacaacatcacgagcatttctcttttgagttgatttatac
+tatatctgctgatgtgattatgtcccacttacccagaatattaagaaagtcctagattgt
+aggtatacttgactataaatataatttaagactatacaaataatctggctacattatgcc
+atcgtagaaactgataacgtagtaacgtcggacactagattttggtcggggagtaatcta
+gcatactaacgaatttgttaaatccgctgaaagtatatgtcattacctgcttggcctgtc
+ttcaatacgtttagactattaaggactcatttcgagatccagtattaattatacgcatcc
+atatttatactgaagacggattgagttaggacgacaagctaaacaaatattaagttaagg
+attagtattatattgtagaaactcgtcgggttggaacgattcatcatcatagaatgcgtt
+acttattcagagagacttaattcggttatgactggcagctcacctggaaagtaggtgaaa
+ggcaacagaagaatattgttgactgaattctacgggctacgaacgtaattacaaagcggt
+tcgtaaagagcataaagatcaatacaatggatctctacagtattacgtaaataacataca
+taaacctggtgttgattcgactagctcatagattaatcattaattgaagctacgaagacg
+cggaagtctgcggagtgagcaaacagtaatcgactgataaatgcttataatatcgcgctt
+aaatgccgcatggtgtacattaacgtgggggtagtcaaaggaatatatttactaggaata
+ttagttatgcaaatgttgtgtcaatgtgatgtgttttatccagacattggatgcatggct
+gtgggggcacaggatacttaccattagttcacctacaagcggcgtgagagggtctcagtt
+ttagccagcgcagagaagtacgggcctttagacgattaatgctagaattgtcataaacct
+cgtgaaaagctagttaataatcatggtgctagaagaacacaacttttctataaaccagtt
+ctcgactgacagtcgtaactcactatatcgccgctttgtactgtcgcaaaaaaacctcac
+atagaaagaaaaatctactgggtgcatcagtagagatcgtgttctgagagataaatacac
+cggatacgatctgcatcgagttcatgtattaggtcaagcttgggactgttgtgccagtag
+cattttttaacagtcaaagtagggtgagacacgtcatatcataatatatgccatcgaggt
+ttaaagtttatatgataagctagcatgcgttgcaatcgtattcttgaatgctccgtggtt
+tgtactaattcctttatagactgagtgtatcgtacactcggtacaattacaaaggatgga
+agagcaaataggtcttcaattataacagtaccccaccttaatctaaaaaccagcttcaat
+tagtattaatttcgccaggagtatatatataaatatctaaagactaaaagactcgtactt
+ttacaacttacgtcgtagcataattaaatcatgggtaaatgtcatcagtaagtgcattag
+aaatactcctttgtaaggatacagtgaatgtgtctcagcaagtcagtagaaatggaaatt
+catactcgattaaggcctataaaactgttgttggtatctacagagtgattaaaattagtg
+aatcagattacgaaaatgttttcccgctcgcacttacgcgtttagacaaaagtacaggtg
+gtacaattggctgtagtagaattttggtataaaataggtgataaaccggatgggtgtggg
+cgaattcaaaagcggtttttgttccatagaactatgtagttggttataaaggttgtaatc
+tcggagattaggttagggcttaatcagaatagtaacaatttctctatgtaaagtacagtg
+ggtgatcgtatgagttcacgaactcttaatgccatgcctggacaggataaacaatacgca
+tataacttgacgatcgagcttatatcgacctatttgagaagtttaacgggtcgatataat
+atacaggtcttaatagccgattttttctagaaaagcaatcctatatcttagttaatcaga
+tcaaccccgtgaacgatatatcagcaaactgaacattgtatacaacattcctttttgtcc
+gggtggggactccatttaaagtatctcacctagaactcagcggtaatagatgcagtctct
+tgcccagttacggtaactaaatgttgatacttagaattgctaaattttagtctagacatt
+tccaggtaaaccggtagacgacaatttctctgtcatctgtcataagatcgcttagtgtgc
+tcaaattgcaattgagggccctactatagacaatcatcagactttttaattaaatagttt
+tccatgaatgtgttgtcaaggcggaccccttcacttttatcacggctcataaatgtcgta
+tgactgtagtcggtagcggccttcgagtcttcaggggaaatggaaaagaaattaggcttc
+taagatggactataatcgattaggctaattccgttcgcaaatcacagaagcaatcttact
+caaaattgttggaatcgatagcgaacgcgaccgtgaatgtttaaaagtgctcgcacagaa
+ttacccaatacctatcatcacgacttaaatacccaaagcagttgtagtcgcgtaatagat
+taagtctgaagcctagagacaaagggatactgggcggggaaacctgctccttcacggtaa
+catggtaacaacagaatttggttaaggttaaaacgaaatatactcggagtgaattactgt
+taggtttcgtcatcggatcaataagtagtttccgtgaagacactcttatattagatctcc
+gaaattctgacccgtgcattaggcacttggtaggagattccatttggaacttgctcaatg
+taagccagtaatgttccgaaataattcgctgcaggagcgaggagccgctgaataaaggac
+cctcgcatcttgttaccttatggttgagggtcaccgttctctgcgtcaattccagagctg
+gagatacattcatcaacgttacctacgcacagaataaaaagatcgagcgctaactcgttt
+tcctaaacacaacggatttagacaaattaccgaatgcgccggagagtagcatcttagtgt
+catgcctatcatggcggctcagtacgaagagttcaggcatcgaatattgtggtagcccgc
+actcaaagttccgccattaggtaagctatatattgtggtcagaacttgaggacaactatg
+agctactaaaaataaacaattttgtcatttgttctagatatgtggcattcatcgaacgct
+tgtaccagaagttacattcgcagcgtgagcgaataaacccgaatgagcgtaacattatca
+ataacatatagttcagatagagaacgaggtattcgacagagaattacccaacattggtta
+ttaatctatgcagaataatttagataatgtcactacataatattaggaccaaaaggtgat
+tccccagaagacaaaacaataaacaatctcacatattcgctagtacctatgtatgggtat
+gatcttctgattggacggggataatttccaggtatattaaaacttattaccataatctag
+acctaagagaggttatataagtaaagagctgtgttccgatagaaaaacccgaccttaaag
+acttgcgaagtaaattttgctttaacaaaaaaacctacgtaagggaatattctgtataaa
+ctgaaaagtcaggtgtaactacatgagtcatgtcttcgattaattacaatgcgatctcgt
+tattctgatcaactaatatcataaactgccactacatcttgtacaatcattcgcaacaat
+acttttatgtgctaaggtcacgtgcttcctctgctatgctgatttaatcagattcataaa
+ggaatacgaataactctggatccattaccacgcaagggatttatttacggctgattactt
+tttggctgttgacagaactgccatgaaagtaagatgtcgcatcttgcataaataatagca
+cctaatatagccgacaaagtgattccgataacagattttaagttgtccagccttgagact
+ccatgaagaccgcttgggagcttccccgtgattagaagaatctaaatcccaagtggatgg
+ggggagtttaaatctcagcaccaacaaatagtacttcctctcagagcgcgtcatggtcga
+aggagcctatcctgatagaggtttgaaagcgcacgcgcatttaactgtcatattaaattg
+gaatctcgtaagtgtcggcagtacgacaaattttaactgatgtcggtatacggagaagaa
+ggaagcacgcattgaagcagctacgcagaactgagaagatgacactctaagatacaatta
+atacaaaaacgttttaagcccaatctatcaacagatgtaagatgtctaatacacaagaat
+aaaaccttcatgtcccgatgtataataacagctttatttctgctggtcgaggtgaagtag
+tggaaattactccatcttgctgcgcgtctttatagtgttggctactctgtaaccgacgcg
+tccatccctctctcctagtgatccgtatatccaattagaggataaccaacatctgcgtta
+ccgacgaatttaaatttttcgactatttaattccgttcaaacccgtattcgtagtaagtg
+tttcatagatttatgaccgacatcgtgtacgagttgcagtgcatatgtagataccactaa
+ttgctgatctaggatacatgctttataaacatgcttacttggctattttatttactgtca
+tgtgggggtttttattttcaacaagtatgtgctaccattggataatctggcttcaaattg
+aagatatgcgttccaaacttgtctactgtttgctaagtaggagttgtcccattagaacta
+cgcagcacgtggtttgtgatcgaaaagaataattggcaaatacgaggctagccttcaaat
+ttaatgcagattactcctcagaaacacacgtaagcgacgaacgtgatgtttactacacaa
+tgcgtatcatagaaattcgtgataatttttgttccaacctttgaatctagactgagtgga
+aaaagatttcaccgggataccgtttatgctggttttaaaaactcgtcgaatcatcttata
+actgcattcaaatggatttctcaatcatctgtacgtcaactgttttaacaataacgtcag
+aataaaccggcacaatgagacggcggtctttcactacaccacacccttaggattataagt
+gacgtgtggattcgaattctaaggtgacgggatctacaagcctcagctacattaggtctg
+aagatctttcgtatagccgcgtatgttactgtttggatatgggttatgctaatcaacagt
+tgacagcgagtgaaacggccttgcgacctgaaatctttacggttaccttttgattcaaga
+caggatcgacgatggaccacgtgaaatgaattcaaaactgtaacatcgcttgtgcctcag
+cgaccgagtaacgacaagttcacatcctctatgcaactatcattgtggtcattaaggtat
+tcaagattaactaagagtcgaccatatattctagagttttacaattaggaaccgttagtc
+tagactaggagcgtgcaacatcgcaggaggtgtggactgtcttgacccaagttgcctgac
+acatagtgtcttttgcttcatgtccttagcaatgcgatacctcaatcgtagttttatcgg
+gataaataacatggtgtttaaccctattaatggtttctattaatctaaattgtaaggcag
+cccttgggtcgaaagcacattaggccacatacacagtatgaaattgttcgagtgtccaga
+ccataattgactaccatggtacacggtgttgctattatgactcccgcaaaactcttgaca
+gagggaattttggtacattgatgtaatcgatgatttaacagtaggaactagacgtcatcc
+gttagactgagttccgacatgctcaaattgtcaggatttttatccaataactaatggctc
+tcacatgtaaataaaatcacattaacgtcacttagtgatggattcgctaaacagatagac
+tatcattcatgaactggcactgtttcgattatatttgcaacatcgaacatacttaaagtt
+aaatacgacatcattcaattaaaaaaattcagtacacctctaatgagtatcccgctttgg
+aggaaagagtagcactttaaatggacaatttaggccggactttcctgtaaatggatgaag
+tcattgtacagcttgaataaatcgttagggttagtccttacatccaccatatgttaatga
+ataaagcctgagggaccttagagctaacttgtccaacacgttgctcatttacttaataag
+gttgaaatgtatcagtaagtgacagcgagtgtagattttgaccatttaactgaccttcac
+agttttgtcttcagacgtcacttacaccataatgatgacagagcttgtagatgcacacac
+tcattcctagtgtaaatcaagtagtagctagattattataaagagatattttctggcgtc
+gaacgtaacacagagagagtataaggggcatgataatggcttatcaatatgtgtaagaaa
+aagtttttaatatcatctaactcggtggaatgcacacttatggccaactgaccttgggac
+gagttaagataccataagaggttgcctgtaagttaagataacaaagggatattccatctt
+tgtgtgctaagaacctatttatatttgcagccataaaaacctctgtgctatgcagccacc
+agagttatttatacaaagaaagagaccatttagatacgttaattctgcttgcgatttatt
+aaacagacatttcacgtccaaccactacaaaagccctatcgcaagacgatcattgtatta
+tagcctatgcaacgtagctaagcggccgaggaatcataaaatatgaattgttacattgtt
+tactacatatgatcacaatctttgtaaaaggttcgttcgtgatactaccatgtacctaac
+taacctgagatatatgcaatgacttatggggtcagcgcgcaacatccgcaaagcatagta
+atacaaggtaggaaaacttctggatttcccaaggttataatgctctatactgaccaagag
+atccgttacgactcgcaatgaatactctaagggcactcacaaagaaaaccactaattgat
+aaatttcaatgataatatcctgaattgcatcgtgtatgagttacgagaagtcgcatttaa
+tgaattagtcatagaaatgtcatagcaggaacataattactatattttaacgatttaatc
+gtagttggagtcctttcccaaattatgtcatcagttccgatttagatgttttcgggccct
+tcttagtaaagaagttaatatccaagactagctcctcacccacgcatgcacatattcgcg
+agaagtctgatagaatattcgacagaaatgcgactctagctcacactcgttaactgatca
+ggtacttatagacaagtacgttatcagatatcgcttcggggcattgttgcgctacctttg
+tgcatagcagttttgaaaaattgttcaagacctgaacgggaaaatgatattattttttta
+ggaggaataatacagtaccatgtaaatactcaaccaccttacgtacttcttacgccgaac
+atatatggcacgtgttattcggctaacaaaactgttgtgccttttctataaggataagca
+gattcgttttaaacatatgacctgtaaactgggatctacaaaagaggtacttaaaataaa
+ttgcgcaacggtttagatctgcggatctttggttaaagagcaccattagatgtgccatac
+ttcctatcgcctgagcgagaatttagtctgaggaaccactcttgggatttaaaacaattc
+ggttaggacacctactcggcggatgaagcaatacgataacattaaaagtcgttcagtcta
+attttggtcgtagtacgatgagctgatggccaattgtatttttattaacagcactgaaac
+aaaatggagactttagactaatactaaagtctcaatgttcgtcgaaccttaaatgctcgg
+aatgaggggatcttcggaagtatagcgccgaagtgtatctcattattataacaccagtgt
+acagacgacatctaattatggccagaaactgtcattgtgccattaagaggattagtagat
+agtctggaccgtggaatagaattttgaccaaattgaccagtcctgcttgtagacagcgcg
+atctaaactgcacgagaatatacaagttggtggtgcttgtggctgagcacgctaagatgc
+gtttgtttttacgattctagtgcttcttaacgcaattcagtcttctagatccgctattcc
+aacatcaatatctcaatttaaggtcaatatatataacaaaattagacagagcagctgaca
+cttacgaagcatcgtagaaccgatatagtcgaccttatgatgatatggacgtgtccaagt
+ccgcacttccgatgcatcttgacggtgaaccgaaatgaaatcttcattagggcccccatg
+tgtcaaaccactcgagtcccgtctctgaagtcaagtattactgcgaaaaattcgtctact
+attagtttattatgaacttatgacgcttaaataaattaaacagtaagcctgggaaaatgt
+taaggcaggaatctttgtaacagttcataatgttgctaaagattatcagaccccgtgaag
+acttcgggctttgggcttcgtaccgtagcataatacatctatatagttagaggcttgcgt
+gttgttgtgctattccacatatagcagctctgggcgactcttcaatgaaaatgaaaaatg
+gtaacctggcgacctacttgttaagtcagtttaattcaaggggattaagtaccaagggtc
+gagtttctctgtatttattatactgtaggcaagaagcttttttggcgagatttaagactt
+aagcctatggtaaaaatttgatagtgagcgactatagtaagagatttgggtggttagtaa
+ttaaaattctcctatgctaaatcaggcgtacaatctgagggtgcacatttctcgacgcgt
+gaaccttcaccgaaagcgtgtggattatacaaatttcaaacatattggcggggcacttat
+ccataatagatttctgtttgtacgccaaactctgcctcacccctccataaattgtattgg
+ctagaggttaaattctccgtaaatagagacacatatagttttatacaattgtttgaatca
+aagcacgagaaacttttaaccgtacattgacaaatgtcttcggatggggcagagcatctc
+ttcgtgacccaaatcaatcgctgagcaataagcaagaaaacacagattatacaaagagat
+ctggatgaagatattcgtgcaatcactatcgttatgttagagagttccatgcatgaggac
+tcgttttttgaccaggagaattaagccaagaaataactgacgtatttccaaatgaattct
+acgtgtttttcctgtcacctttagccagtgttaaagatgactatggagtttcgaataggt
+tattctatagacattataacgagtggaacacccataccttcacagtgctaaaggtaggaa
+cgggtacgtcaggtagttcaagggattttaggttcttaatccaacgaagaaataacgcat
+cacccgtcattctattgttttcgtcgggattacttagtaggcagggtattctaacctacc
+tgagttacaaatctttaaaaaactggccatgaggtcatggtgataaaatctgaatcgcct
+aaattcgcgtccctaaggaaatatactagaatccgtctcagaaagtgcaaaggttgactt
+cttcccctaacacagaattctcagttttatagctatctagtggcattcctttttataaaa
+ctttacgtttgtaagggtccaactttacaaaagctcggatgtgtatgtgtaatcttccgc
+cgtgtaagacttggaacccatgtatattgacggcatggcgtggctaagcaggtattgatc
+ttcagtgtaaagcaaggtatgttctaatctaacaatgtaaagccggggattagccgccaa
+aggggtctaatgacatagagatgctctgaaatcgtaccaactataaaagcacgggatttg
+aaatatagcgacagatcttccgtattctgttagttgacatctgtgctgtctttaccgatt
+gtgatttggctttagcagtcatttagtttcgttactcattgctcgtgcgatagttccacc
+gaatatggcacattcgttctttttttccattttactgcaaaccttttcaaaagctgatcg
+ataccactgatgatggcattgattagtcgattggcaactatgtcctgcttatatctccaa
+ttgcattgaatatagtaaaaaataaaggctcgccttcccaatgggctacggagtacacga
+aaaaatcgcaactcgtttaaccaagcgccgtacctaacatataagtgattgagacaaata
+gttctccagacgtattgagatatatgtctcctataggcaagcgtttctaattgctgacca
+gaaattagaattaggttgttaatactatattcgaccattttattccacgaatgtgctatt
+ctactggtattgctccgtatgcgatatataaccaacacggaaagtcgtcgattgcaaagt
+ggctccgtagaatcatttctggtcatttaccgggagcgcgcttgaacaatggatgcggta
+tctgccatattgttattgttaaaaagacttccgcttactatcgcttcgatcatcggaaaa
+atattaatgaggattgggtcgtataagaaaatcatcttttcagttcgcagatttttgcca
+atttaaccggttatttcgtcagacttggtagtgtagttacaagcatcacgattatatcag
+ctacagaattaaactgtcctgactcgacggggcagtgtgtgagtattgcgctatatattc
+aaggtaacaggaggcatataggtcatagtacaaggataatgaggtttgctaactttaaaa
+attattgatttaacggttgattgaaaatctctgcaagatgacgctagaacacctgatgtt
+caagtttgccgataataacatataagatgaattactgtctttagaccctcatgttaatcc
+gctaacttagggcggaaacaatgttaggctatgcggagtaagtactatattatgatacca
+catagaatttaacattcatatgatgtctaatacccgttcccaaccttgcaaccgtcccga
+ttaattaagcaattacggtcatcaatgggccaatcctgtctcaaaaattatcatattcaa
+ggttcagctattttggcaatgggtgagtaccgttcttagtgatttacgaacccataatct
+aggcgacttaatatacaagatttagagttacgttttccgggtagtacatattaacgacca
+tggatcgggtgaggtgttgtattagttatctgatcttgtcagtagctcccaatgtcccag
+aatattatgtttctactagagtgttcgtatactggaatttaaatattatgtaagactaga
+caaattttatggatacattaggccatcgtagaatatgatatagttgtaacgtccctctat
+agattttcggagggcaggtatattgcttaataaagatgttcggaaatcagcggaaaggat
+ttgtaattaactgatgcgcagcgcttaaataagtttagactattaagctatatgttcgac
+agcatgtagttttttttaccagaaagtgttatactgatgacccatggaggtagctcctca
+tgataaaaatattgttacttaagcattactattatagtgttcaaactagtaccgttgcat
+actttaagaatcagacatggcgtttcttatgcagacacacttttttagctgttgacgccc
+acctcacatccatagtaggtcaatcgcataagaacaatattctggactgttttattaccc
+agaagaaagttttttctttccggttcgttaagacaataaagatcatttcattcgttctct
+taacgatgaactaaagtacttaaagtatccgcctcttgtttcgactagcgcatagtgtaa
+taattaaggcaagataagaagaacaggaacgcgcacgtcggagataactctaatagtctc
+tttattccgtttaatatagcccgtaattgcaccatgcgctacagtaacggccgccttcgc
+aaacctatttatgtaattccaagtttaggtatgcaatggttggggcaatgtgaggggttt
+tatcaagactttcgttgcttcgcggggggcgcaaagcagactttacagtagttaaccgaa
+aaccgcagggagtcgctctaagtgttaccaacccctcactactacgcgaaggtactcgat
+tattccttgaatgggctgaaacatcgtgattagcgtcttatgattcaggctgatagaaga
+aaacttattttctatattccacgtatacaatcacactcgtaactaaatagttcccagcgt
+tgtaatgtcgctataataaataaaatacaaagaaaattcgtctgggtgcataagtacagt
+tagtcgtctgtcacataaataatccgcagtcgatctcattacaggtattgttgttggtca
+accttcgcaaggtggtccaagtagcattgttgaacagtaaaactaccgtcacacaaggaa
+tatcataatagatgccatacacggttttacttgatatgtttacagtccttgagttgcaat
+cgtagtattgtttcatccggggtgtgtacgaagtaatttagacaaggtgtgtagcggtca
+ctaggtaaaatgacttaggatggatgagcatttaggtattctatgataacactaaccatc
+atgtttctaaaatcctcaggaaatttgtattattttaccaacctgtatttatagaaagtg
+cttttgacttaaagaagccgaagtgttcaaattaaggagtacctgattgaaagaatgggg
+aattgtaatctgtaactcaattacaaataagccgttctaaggattaaggctttgtgtcta
+agcaactcacgtgaattcgaaattcatactcgattaacgactttaatactcttctgcgta
+tctacagactcatttaaattacggaatatgttttcgtttttggtttccagctcgcacgta
+cgcgtttacaaataaggacacctggtacaattggctggagtacaatgttggtttttattt
+gctgattatcccgatccctgtgggcgttggcataaccgggttttcttcaagactactttc
+gtgttgcttatatacctggtaatatcggtgagtagcttagggcttaatcacaatactaac
+aagttctctatggattggacagggcggcatccgttgactgaacgatctattaatccattc
+cctgcactggataaacaagacccatttaaattgaccatagagatgttagcgtcatatttc
+tgttcgtgatagggtacatatattataaacggattatgagcagtggttttctagaaaagc
+attcatagttaggagtgtatcagatcataccactgaaccatagagcacaattctctactg
+gctatacttcattcctttttgtccgggtggggacgaaatttaaaggttctaacctagaac
+gcagagcgaattgatcaaggcgctggccaagtgaacggttctaaatgttcttaatgagaa
+ttgcgtattttgactattgacagggcatcgtaaaccgctactcgacttggtatctgtaat
+ctgtatgtagatagagtacgggcctataattcaaattcagccaccgaagattcacaatct
+tcagacgtttgaaggaaagaggtttactggtatgtggtgtcaagccccacccattctctg
+ttatatccgagcattaatgtagtttcactgtactacggtcacgccgtagagtcggcaggg
+caaatccaaaacaatttaggctgagaagtggcactataatagtttagcctaagtcccttc
+gctaataactcaacaaagatgacgcaaaagtcggcgaatagattgcgttcgcgtaagggt
+atcttgaatactgatagctctcatggtaccaagaactttcataacctctttatttaccaa
+acctgttctactagcgttagtgttttagtctgtagccgacacaaaaaccgagaatggccg
+gcgtaaccggcgcctgcaagctaacatgggatcaaaactattggcttaacgtttaatcga
+atgagactagcactgtattactctttcgtttcggcagcggatcaataaggaggtgacggc
+atcactctcttatagtagatatcacttattctcacaacggaagtaggatcttccgtcctc
+attaaatttgcaactggctcaatgtaacactgtaatgttaacaaagtatgagctgaaggt
+cagagcagacgatgtagtaaggtccctcgaagctgcttacagtatccttgaggctcaacg
+ggctatgcggaaattccagacctcgagttacattatgaaacgtgtcattccatctcatta
+aatagttcgtgccctatcgccttgtaatataaacaaccgtttttgtctattttcccaagg
+agaaggagagtagcagcttagtggcttgcctatatggccccctaagtacgtactcggcac
+gcttagaagattgggctaccccgcactatatgttcccaaagtaggtaacctagatagtgt
+cgtatgaaattcaggtcatcgatgagagtataaaaatatacaattttggcaggggttata
+cattgcgggcatgaagagtaacattggacatgaacggacattcgaaccctgtgagtttaa
+taccctatctccggatcattataaagtaaatatacgtcacttactctacgtgcgtttaga
+cagtctttgaaactaaattggttatttttctttcatctagatttgtctgtatctaactaa
+attatagttccacataaagctgattcaactgaagacataaatataaactttctaacatag
+tagcgaggaaagagctatgcctagcatcggatcatgcgtccgcgagtagttcctggtaga
+gttaaaagtttttccagaatctagaccgaacacagggtagtgaacgaaagtgcgcggtga
+acatacataataccgaacgtaaacaattccgttcgtattgttgctgtatctatatttcct
+acgtaaggctatttgatctataatatgaaaagtcacgtcgaaataaatcaggaagcgctt
+cgagtatgtacattcagatctccttagtatcatcaaattatagattttacggccacgaat
+tattggtctagatgtcccaaaaataatttgatgtcagtagcgatcgtgcttcctcggagt
+tgaggttggaagaagagtcattatgctataccaagaactctccatccagtacctagaaag
+gcaggtatgtaccgctcattaattttgcgatcttgacagatctgcatgcaaagtaacttg
+taccagatggcttttataatagaaactaagtttcccgaataacggtgtacgataacagat
+ttttaggtgtacagacgtctgactcaatgaacacacattgggacctgccccgggaggagt
+agtagataattaccttctccagcgcgggtcttttaatatcacaacataaaaatactaatt
+aatatcacacaccctcatcctcgatggagcctagcatcatacacgtttgatagacaacgc
+caattttactgtaatatgatattcgaatctagtatgtggacgctgtaccacattgtttaa
+aggagctccctttaccgacatgaacgaagcaagctttgtacaagatacgaagaactcagt
+actggtaactataagagacaatttatacataaaagtgttaagaccattatataaaaagag
+gtatgaggtctttgtaactacaataatacattcatcgaacgatggagaataacagagtta
+tttctgctgctcgagctctagttctgctaatttctcaatcttgatgccactcgtttgagt
+cttccattcgctcttaacgacgcgtacatccctctctcctactcttacctatatcctatt
+actggttaacctacatctccgggaaagacgtaggtaaagtggtccacgattgtattcact
+tataacacctagtagtactatgtgttgctgagagtgaggacacacttactctacgagttc
+aagtccatatggacattacactttttcagcatctaggtgtcatgatgtattaacagccgt
+taggggctatttgattttatcgattgtcggcgtgtgtattttcaacaactaggtgctaca
+attcgtgaataggcatgaaaattcaagattgcagttcctatcttgtataatctttccttt
+ggacgagttgtaccatttcaactaacctgcaagtggggggtcatccatatgaagatttgc
+caaatacctggagaccctgaaaagtttatccagattaataataacaaacaaacctaagcg
+aagaacgtcagctttaataaactatcactatcatagaaattcctgttaattgttcttcca
+aacgttgaatagactatcacgggtaatagattgaacacggagaacgtttatccggcttgt
+aaaatatcgtcgaatctgctgataactcaattatattcgatggagaattcatatctaccg
+cttagcttttaaaaattaagtcagattattccgccacaatgagaaggcgcgagtgcacta
+atcaaatcacttaggattattacggacgtctgcattacaatgctttggggtagggttata
+caagcatatgattctttaggtctcttgatcgggcgtttaccaccgtagcttaatgttggc
+atatccgtgatcctaatattctgttgtcagcgtgtgtataggaatgcacaacgcaaatct
+ttaagctgacctgttcatgaaagacaggagacacgaggcaccacctcaattctatgcaaa
+actctaacatagcgtggcactatgagtacgtgtaacgacaaggtctcatactcgatccta
+agataattctcgtctggaaggttttaatctttaactaagagtagaacttagtttattgac
+ttttacaattaggatacggttcgcgactctaccacagggcatcatacctggagctctgct
+atctcgtgaccaaagtggcagcacacatagggtcgggtcctgcatctactgagcaatccc
+tttaagcattcctagtttgagagccatttagatattgctgtttaaaccgattaatggttt
+ctattattataaagtgtaacgctcccattcgggacattgaaaattagcaataagacaatg
+tatgatattcggcgagtctcaacaacattatggtctaccatgggacaaggggttgatatg
+atgaatccacaaaaaatagtcaaacacccatggttcgttaagtgagggtatccaggtgtt
+ataaggacgatctagaagtattcaggtacacggtgttcagacatgctctaattgtcaggt
+tgtttataatttaacgtatcgctctctattctaaataatataaaattaaccgctcgtagg
+gatgctttccagtaaaagatacactatcattaaggttatgcaaatgtggcgatttgattt
+gaatcttagtacattcttaaacttaaatacgtattatttaaagtaaatatattatctaaa
+ccgcttttgtctatccacatttcgtcgaatcacgacctcgttaatgcgacaatttacgac
+cctctttcatctaaagcgatcatctatttcttctgattgatgtaatactgacccttactc
+cgtacatacaaatgatggtaagcaagaatgactgacgctcctgtcacctttcgtggcaat
+caactggcgctggtactgaagtagcttgaaagggatatggatgtgtatgccaggcttcat
+tttgacaatttttctgtcctgctcagtgttgtctgaagtcgtatcgtacacaataatgat
+gactctcattgtagatccaatcacgctttcctacgctaatgaaagttctagatagtgtag
+gtgttagacagaggttagcgcctacatccttacacacacagtgttgaacggcaagcataa
+tcgagtatcaatagctgtatgtatttgtttggaatatcatatttctcccgcctttgaaca
+atgatgccaaaatgtcctgccctagagttatgataaaataactgctgccctgtaacttaa
+gtttacaaaccgatattcaatcgttgtgtcctatgaaaatatttatatttgcaccaagaa
+aatcatctgtgcgatgaacaaaacacagtgatttataaatacaaagagtacatttagtta
+ccggattgcggcttgacatttattttacagaattttatcggcaaaacacttcatatgaac
+tatcgcttcacgataagtctatgatagactagcattcgtagagaacaggaagagcaatca
+ttatatatgaagtgttacagtgggtactacatatgagatcattaggtctatatccggcct
+tcctcataagaccttggaaatatcttacatcagagatatcaaaggaagtatgggcgaacc
+cagaaaaagccccaaagaatagtaattcatcggacgtaatagtctggttttaactagggg
+ttattgatatttaagctaaaagagttccctgaacactcgaaatgtataatctatcccaac
+taaaaaagtatacctctaattcagaaatgtcattgagattagactgatgtcaatacgcta
+ggaggtaagacaagtagaagtttttgatttaggaattgaaatgtaatacctccatcttaa
+gttctatattttaaagttttatgcggacttcgagtaagtgcacaaatgatggcataagtg
+cccagttacatgtttgcggccccgtatgagtaatgatctgtttatcaatctctagctact
+atcccacgaatgcactgatgccagtcatggcgcttacattagtcgacagaaatccgacga
+tacctatcacgcgtgaactgttctggttcttattcaattcgaagtgatctcagatacatt
+acggccatgcttgcccttcatgtctgctgagcagttttgttataggctgaatctcctcta
+agcgaaattgataggatttttggtggtcgatttagtctgtacctgcttattaagattcaa
+aatgacctacttcttacgccgaaatgatagggatcggctgaggaggataaatatacgctg
+gtgcctggtatttatccagaacaagttgcctgtgtatcagatgaactctaatctccgaga
+taaaaaacaggtacgtaaaataaaggccgcaaagggttacatctcaggatcgtggcgtat
+agtccaccattagttctgacttacttaatatagactgaccgagattgtagtatgtggatc
+caagcttgccatgtaaaacatgtcggttagcaaaacgtataggagcatgatcaaagaaga
+gttaattaatagtactgcactataattgtcggcggagtaccatgagctgttgcccaattc
+gatgtttattaacagcacgcataaaaaatccagacttttcaattagaattaactataaat
+ggtccgcgaaccttaaatgatcggaaggacgggatctgccgttgtatagaccccaactct
+atctaatttttataacacctctgtaatcaacaaatcttattatgccatcattatgtcatt
+cgccaagtaagtccagttcgagattctctggaccgtgcaatagtattgtcaaattatggt
+aatggaatccttcttctaacacccttagaaaagccacgagaattgacaagttgggcgtgc
+ttgtccaggagcaacataagtgccgtttctttttacgatgatagggattcttaaagcttt
+tctctattctagatcccagttgccatcatcaatatctcaattgatgctcattatatagtt
+cttatttagtatgtccagatgtcactgaagatcctgcctagaaccgatattctcgacagg
+atcatcagttcgacggggcaaacgcacctatgcacatccatcttgaccgtgaaacgaaag
+gaaagagtcagtaccgacccaatgtggaaaaaaactcctgtccacgatatgtaggcaagt
+tttactgcctttaattagtagtcgattagtgtagtttgatattatctaccttatagaatg
+taaacagtaacccggccttaatggtttggcaggattctttgtaaaagttaataatgttca
+taaactttatcagaaaacctgaagtagtccgcctttcgcctgcgtaacgttgcagattaa
+ttcgttttacggagtggcttgcgtcttgttgtccgagtacacatattgctcctctccccc
+actcttctaggaaaatcaattatgctaacctgcagaccttcttctttactatctttaatg
+catgcccagtatgttcatagggtagacttgctatctattttgtataatctacgaatgatg
+cttggggcgcgacttttaacaattaagccgttgggtataatttgagagggtgccacgata
+gtaagagatttccggcgtgagtaaggaaaatgataataggattaagcaggcgtaatagct
+caccctcctcagttctccaaccctgaaccggctaagtatgactgtgcagtattaattttg
+aatacatattgcagcccctaggatacattatagatgtctctttcttacccaaactcgccc
+gcaccaagaaagaatgtggattcgattgaggttaaattagccggaattacagacacagat
+tcttgtttacaattgtgggaagaaaaccacctcaaacgttgaaacctacattcacaaatg
+gattacgttggggatgagaatcgattccggtcaaaaatcatgcccggagcaataaccaag
+aattcacagaggattaatacacttctccatgaagataggactgcttgcactatccttatc
+tttgtgtcttccttcaagcaccaatcgtttggggacaaccacaattatgccaagaaataa
+cggaaggtgttccaaatctatgagtccgcggtttcatcgcaacgtttcactgtgggtatc
+atgactttggactttagatttgggtattctagagactgtagaaagactgcaacaacaaga
+cattcacagggcgaaacctaggaaaggggaccgcacgttgtgctagggatgtttccttag
+gaatccatacatgtaagaaagaatcaaccgtaattatagtgttttcggccccttgaatta
+cgtgcatgcctttgctaaaagacctctgggaaatagattgaatattctggacagcagcga
+atcctgattatatctcaagcgaatatatgacccgcaagaaggatttatactagaataagt
+ctaagaaagggcattgggtcacttcttccactaacacacttttatcagttttataccttg
+agagtcccatgcatttttatatatatttaactttcgttgcgtaaaactttaaatatgatc
+cgtgctctatctctaatctgaacaacggtatcacgtcgaacaaatctagtggctacgaat
+cgcgtcgctaagaacggtttcttctgctggcgttagctacgtatcttctatgctaaaaat
+gtatagccccgcattagcagcaaaaccgggagaatcaaatacacatccgatgaaatcgta
+acaaagataaaacaacgcgatttctatgtttgccaaagtgattaagttgtatcgtagggg
+tcagcgctgatgtcttttcagtttgggttttggatttaccagtcttttagtttcggtact
+atttgatcgggacattcgtccaaacatgatggctcattcgttctttttttcaattttaat
+caaaaccttgtatttacctgatacattaaactgagcatcgcatggaggtggagattccca
+tatatgtaatcatttgatatcctattccattctttttagttataaataaacgctccactg
+cacaatgggagtaggacttcaccaataattagcatctactgtaaacaagcgccgtaacga
+aatgattactgattgagaaaaataggtctcaacaacttttgacagatatgtatccgatac
+ccaagcgttgctaattgcgcaaaagtaagtagaattacggtcgtattacttgttgccaaa
+tggttattactccaatgggctattctaatccgatggatacgtaggagagagtgtacctac
+accgaaactcgtagtgggcttagtggctacgtagaagctgttcgggtcagttacagcgtg
+cgaccttgtaaaatcgatcacggtgatgaattattgttattgtttaaaagaagtcccctg
+aatagcccttagataatacgaaaatttgttatgtccagtcgctcgtatatcaaaagattc
+ggttaagttcgcagagttttgccaagtttacaggtgatttactaacacttgggagggtac
+gtacaaccatcacctggttagcagagaatgaattatacggtcatgtcgcgaagggcaagt
+gtgtgagtattgaccgagttattaaacgtaaatgcaggcatttacgtcataggacatcga
+gtttgtcctttgcgaaatgttaaatttatggttttttccgttgagtgataatagctgcaa
+catgaagatagtaaaactgaggttaaactttcaccatattaaattatatgttcaattacg
+cgatgtacaaactaatgttaatcagatttaggagcgcgcttaatatgggtccctatcccg
+actttgtacgagattttgataaaaaatagtattgtaaattcatttgatggcgtagaaccg
+ggcaaaaccttgaaaaaggacacatttaggatgctatttccctaagaaagcggaaaatcc
+tggctcaatatttataatagtaatggttaagattgtggcccaatcgctgagtacccgtct
+tacgctttttccaacacataatcgacgagaatgtatttaaatgtttgagacttacgtttt
+ccgcgtacttattattaaagtcattggagagggtgtcgtctgggtgtagttttctcatct
+gctcaggagctaaaaatgtaaatctattggttgtttctaattctgtcgtccgtgtaggct
+atttaatttttatggtacacttgaatatgtttagccataatgtagccaatactacaatat
+cagatacttgtatacgacctatagacttttgccgaccgctcgtagagtgatttagaaaga
+tgttcggatagcacagcaatcgtttgcgaatgtaagcatgcgaagcgagtatttaactgt
+tgactattttgctatatgttactctgaatgttgttttttttaccagaatgtgttataatg
+atcaaccatgcacgttcctactaatcatataaattttgttacgtaagcttttctatgata
+gtggtctaaagactacccttgcatactttaagattaagacatgcactttaggaggaactc
+acacgttttgagctgttctagcccacctataagccattcgtccgcaatcccataactaca
+atagtcggcaatcttttattacccagaactaacgtttttatttcccggtacgtatcacat
+taatcttaatttaatgcgtgagagtaacgatgaacgaaagttatttatgtttaagccgct
+tcttgagaatacagattactgttagaatgaaggcatcataactagaacaccaacgcgcac
+ctcgcacattactctaatagtagctttattcagtttaatatagacagtatttgaaccagg
+cgctaatgttaaggcccccttcgaaaaccttgttatgttattccatgtggtcggaggatt
+tgcggggcgatagcgctgggcggggatcaacaatttcgttcatgcgagcgcccccataac
+cagtaggtacagttcggaaaagaaaaccccacgcactcgctagaagtgttacaatcacat
+cacttcgtaccgaagggactactgtattccgtcttggggatgtaacagactgattacagt
+cttatgatgaagcctcattcatctaaaattagttgatttattccacggatactatcacac
+tcctatagaaagagttaccaccgtgggaagctagatataataaataaaagacatacaata
+ttagtatggctcatgatctacacttactcggatctctctttttttataaccagtagatcg
+cattacacgtattgttgttccgcatcaggccctaggggctcaaacttccatggtggataa
+ctaaaacgtccgtcactaaacgaagatattaatagatgaaatacacgggtttacttgatt
+tctgttcagtcattcacgggaaatcctaggagtctttcataacggcggtcttagtaggaa
+tgtagtcaagctctgtagaggtctcgacggaattggtatttcctggcatcacaatttacc
+tagtattggagatcacttaaaataatgttgagataataatcaggatatttctagtatgtg
+acaaacctctatttagtgattgtgattttcaattaaacaagacgtaggggtcaaattaac
+gactacatgttggaaagaaggccgaattgtaatatctaactcatgtactaagaagaagtg
+ctttcgtttaaggctttctgtctaacattctaacgtcaattcctatgtaatactactgta
+accaagttattactcggctgcgtagataaagtctcatgtaaatgacggtttatctgttac
+ttttgggtttcaacctagctaggacgccggtactaattacgacacctgcgtatagtgcag
+ggtgttcaatgtgcctttttatgtccggattataaccatccctctcccacttggaatatc
+accgggttcttaatgacttagttcgtcttccttattttccgggtaagatcgctgtggacc
+ggacccattttgatctagtctaaaaaggtatatagcgtttcgtctggcccgcttacgttc
+actgaaacttagattaatcaatgcactgcactggattaacaagaacatgttatagtgtac
+tgacacatgttagactaagaggtctgttcgggttagccgacttatatgtttaaccgattt
+tgacaactgggttgagagataacaatgaagagtgaggactgtagaagatcttaaaactgt
+accatagtgctcaattcgctaatggcttgaattatttaattgttctaaccctggcgtcga
+atttttttggttcgaaaatacttagcacagcgtattgttcaacgagatgcacaactgtac
+cgttagaaagcggcttaatgacaaggcagtattgtgactattgacagggaatcctaaaaa
+gctactcgaattggtatatggaagaggtatgtactgagaggtcgcgcctattagtcaaat
+tctgccaaagaagagtcaaaagcttaactagtttgatggtatgaggtttaatgctaggtg
+gtctataccaccaaaaagtatatgggatatcccagaatttatcgactttcaatcgtctac
+cgtcacgacgtacactaggcagccctaatccaaaacttttgaggatgagtactgccacta
+ttatactgtaccatttgtaacttacattttatatcttcaaagaggtagatattgtcggcc
+attactgtcacttacactaagggtagcttgattactgatacctctcatggtaaaaagtaa
+tttaagaacctatttttttacataacctctgctactaccgttagtgttttagtcggttca
+agtcacaaaatccctgtagcgcacccctataagcagaaggaaaccttaatgcggataaaa
+acttttgccggaaccgttaatcctatgagaataccactcttggaatcggtcctttaggct
+gaggatatagaacgaggggaacgcatcaatctaggttaggtgagagaactttgtatcaaa
+acgcaagtaccatatgccgtcctcagtaaattgccaaatgcagaaatcttacactctttt
+cttaactaagtatgagagcaacctcactcctgaacagcttgttacctaacgagaagaggc
+tttaagtagcctggagcctcaaccggatatccggatttgactctcatccacttacatgat
+gattacggtcattacatctcatgattttctgagtgccctatagactgggaatttaatcta
+ccctgtttctatttgttaacaaggagaaccactggtcaagatgacgcgcttccatttatg
+ccaccataagtaagttctcggaacccttacatgattggcctaccaacctatatatgtgac
+caatgtacggtacatagagtgtggcctatcatattcaggtcatcgagctcagtatttaaa
+gattatatggtcgctgggggtattcagtgcgcgatggaagactaacattggaaatcaacg
+gaattgacaacacgctcactttaataacctatctcaggataagtttaatgtaattagacg
+gaactttctctaactccgtgtactaactctttgaaaataatgtgggtatttttatttcat
+ctagatttgtctgtatcgaaagaaagtattggtccaaataatcctcagtaaaatcaagtc
+ataaatataaaatttagatcttaggacagaggaaagtgctttcccgagcataggatctgg
+cctacgccagtagttcatgcttgtgttaaaagttgttactgtttatagtccgtactcagg
+gtagtgttcgatactcagcggggaactgacatattacactaaggaatcaaggcccttcgt
+atgggtcatgtttatatatttaattacttacgctatttgatcgagaatagctatagtaac
+gtcgtaagaatgcaggatgcgattcgagtttgtaaattcacagatactgtgtatcatatt
+attatagatgttaaggcatagaattattggtattgatgtacaaaaaattatgggtgggca
+gtaccgataggcattacgagcagtgcagcttggaagaactggatgtatcctataactagt
+aagagccttaaaggtactacatacccagggatgttaccatcattaatttggccatcttca
+atcttcgcaatgcatactttcttctacaagatgccttttagaagacaaaataagtgtcaa
+caataacgctgtaacttaactctgttgtacgtggaatcaagtctcactaaagcaactaac
+attccgacatgcaaacgcaggactactagattattaaattcgccagcccgcctcgtttaa
+tataacatcataaaaattctaagtaatatctcacacactaatccgccatcgtccatagca
+tcagtcacctgtcttacacaaacacatgtttaatcgatgttgttatgccaagctagtttc
+gcgaccatgtaactaattgtggaaagctgctaccttgaacgacatcaaccatcctacctt
+tgtacaacagaccaacatctctgtactggtaaatagatctgaaaagttataaatataact
+gttttcacattgatagaaaaacagctatgtgctatttgtatatactataataaattaagc
+gaaacatggagattaaaacagtgttttctcatcctccacctcttgttctgctaatttata
+attcttgatgccactcgtgtgagtcgtccattcgatcgtaaagaacccgacataaataga
+tacgacgctgaacgagatcctatttctcctgaaaattattagcacggtaactcctaggga
+tagtggtactagttggtatgaacgtataaaaacttgtactactttctcgggatgtgaggg
+agcaaactattactcgaccagtgcaacgcattatcgacagtaaaagttttcagctgatac
+ctgtctggatggattatatgcaggtaggcgagagtggattgtagcgatgctcggcggggg
+tattttaaaaatctaggtgataaaagtcctgtttagccaggaaaagtcatcattgcactg
+catatcgtcgattagctgtcatttcgtccactggtaccagttcaacgtacatcaaagtcc
+gggcgcatccatatcaagttttgcaatagtactccagaccatgaaatggttatccagatt
+aataataacttaatatactttcactacatactcagcgggtattaaatttcactttatgtc
+aaaggactcttatgtggtcttcaaaaaggtctagagtctatcacgcctaattgtgtgaaa
+accgagtaacttgatcagccttgtaaaatatagtagaatatgatgttaaatcatttatat
+tccagggagattgaatagcttacgattagctggtataatttaactcacatgattaagcaa
+atatctgtaggaccgagggaaagaataaaataaagtaccatgagttcggaacgctgcatt
+acatggcgttgggctagcctgatacaagaagatgagtatggagctctcttcatcgggacg
+tgacaaccctagcgtaatcttggcagatcccggagcagatgattatcgtctaacactgtc
+tttaccaatgcacaacgcatagatttaacctgaactgttctggattcactcctgactaca
+gcctacaactcatttctatgcataactcttaaagacagtcgcaatatcagtacctctata
+cacatcggatcagactagatcataagataagtctcctctggatccttgtattctgttaag
+tacactacaaatttgtttagtgtctgggacaattacgataagggtcgcgactagaccaca
+gggcatatgacctccaccgctcctagcgagtctccaatctgcaagcactcatacgctagg
+ggcatgaatcgactgtcaatgcactgtaagatttacgagggtgagacccatttagatatg
+cctcgtttaaccgttttaggcttgataggatgagtttgtcgatccatcaaattcccgaca
+ttcatattgtccaataagtatatctagcttattcggactcgctaaactaaattatggtat
+aaatgccgtcaaccggtgcatttgttcaatcaacaaattatagtcaatctcccatggggc
+cttatggcagcgtatacagctggtataacgaccatatacaactatgaacggactagctgt
+gaactaagcagattattggatccttgtgtataattttaagtttcgatctatatgctatag
+tatagaaaatgttccgatcgtacgcttcctttacagttaaacagtctatatcatgaagct
+tatccaaagctggacatttgatggcaatcttacttaattatgaaacttaattacctatta
+ttgaaagtatttatatgatcgaataagatttgctctataaacaggtcgtccattcacgac
+ctagtgattgcgtaaattgaccaacctaggtaatctaaagcctgcatctatttcttatca
+ttcatgttatactgacccgttctcagtacttaaaaatgatcgtaagcaagaatcactcac
+gctcatgtcacatttagtcgaaataaactgccgatgggaaggaagttccgtcattgcgat
+atcgatgtctatcccacgcgtcattttcaaattggttatctacggataactgtgcgatga
+actactataggtcaaaattatcttcaatctcattctagatcatataaagatgtccttcgc
+gattgatacgtctacagtgtgttggtgttacacagagggtagcgactacttacttactaa
+ctctctcttgatccgcaagcataagccaggttaaagtgctctatctttttctgtggatta
+taatagttataccgccttgcatctaggtgcccattaggtaatgccctagtgttttcataa
+atttactcctgccatctaacgttactttaatttcccagattcaataggtctctcatttga
+aaattgttatatgtcaacaaagaatataatagctgagtggaacaatacactgtgagggag
+taatacatactctaaattttctttacggtttgcgcctgcacagttttttttatctatgtg
+atccgcataaaaagtaatttcaacgttccattcaagttaagtcttggtgacactagcatt
+aggagagatcaccaagaccattatttatttagctagggtttaagtcggttagaaatatca
+gataatgaggtctttatccggccttacgcagtagaaattggaaatttcgtaaagcactga
+gttcaatggaagtatggccgaacccacataatgcacaaatcaagtcgatttcttccgtcc
+ttttagtctcctgggaactacgggttattcatagttaagctaaatcagttaacggaacta
+gacaaatgtataatagttcccaaatatatatctataaatcttatgcagttagggaatgca
+gatttgaatcatggcaatacgctagctcggaactcaactacaagtgttggatgtacgaat
+tcaaaggtattacatccttatgatgttcttttttggatacttttatgacgacttccacga
+agtgaaattatgttcgaatatctgaacagttacttggttgagcccaaggatgacgaatgt
+tctgtttataattctcgtcataatataaatacaagcatatgaggccagtcatggagcttt
+catttggactaacatttccgtagagtcatatcacgcctgtaatctgatccgtctttttct
+attcgaagtgttatcagatacatgacgcccttgcgtgacattcatggctcctgacatcgg
+gtcttttaggctgaatctaatctaacccaatttgtttggattgtgggtcctccattttgt
+ctgttaatgcttattaagattaaaaatgtactacgtatttagacctaatgattgcgatac
+gctgtggaccattaatataagctgcgccaggggatttttccagatcatctggcctgtgta
+tatgttcaaatctaatagccgagagaaattactccgacggaaaataaaggcagataagcg
+tttcagagcaccatcgtggcgtttagtcaacctttagttcggaatttattaatatacaat
+ctcactctttggacgagctccttaaaagatgcccttgtatatcatgtcccgtacctaaaa
+gtataccagcatcatcaaagaacagttaaggaatacgactgctctataattgtccgagga
+gtaccttctcatctgccaatagtcgttgggttggaaaacaacgcattaatatgccacact
+tgtcaattagaagtttctataaaggggacgagtaactgatttgagacctagcacggcaga
+ggacgttcgtgtgacaacatctctttataagtttgagataaaatcgctaatctacaatga
+ttatttgccaatcattatcgaatgcgcaaagtatctcctgttcgtgattctagcctaagg
+ccattactatggtcaaattatgctaatcgaagcagtcttctaacacccttagaaaagcaa
+acactattgaatactgccgccgcattcgccagcaccaacataactgcacgtgcttttttc
+catgattggcattatgaaagatttgatctatgattcttaccagttgcaatattcaattta
+gcatgtgttcctaattattgtgttattatggtctatctcatcatgtaaatgaagatcatg
+acgtcaacacagattctagtcaggatcatcagttcctcggggaaatcgcacctaggaaca
+gccttatgcaaccgctaaacaaagcaatgaggatgtaccgacaaaagctcgatttaaaag
+cctcgaaacgagatgtacgaatcgtttactgccttttatgaggagtcgagtactgttggt
+tcatatttgctacatgattgtatgtaataacgatcccgccctttatcggttcgatccttt
+atggcgataagttatgaatcgtcagtatctttagatcaaaaactcaactagtacccagtt
+ccccggaggaacggtcatgattaatgcgttttacggtctcccgtccctcttcttgtcaga
+ggaatcagtttcatccgatcccactcgatgattggtatagctatttgccgaaaagccaca
+acgtattcggtactatcttgtttgattcccctgtatcttaattcgcgacacttgatatct
+tttgtgtttaatcgacgaatcatcctgggggcgacacttgttacaattatccagttgcgt
+ttaatggctgtgggtcacaagattgttagacaggtcccgcgtgtcgtaggaaattgataa
+ttggagtttgcaggacgaatagctcacccgcctaagtgatccaaccctcatcaggataac
+tatcactgggcagtattatttttgatttcatatgccaccccctaggagactgtagtcatg
+tatctttcttacccaatctagcccgaaacaagaaagaatgtcgattccagtcacctttta
+ttagaccgatttacacacaaagtgtcttggtttaaaggctggcatgaatacatactcaaa
+agttgaaaacgacttgctctattcgattaccttcgcgatctcaatcgattacgctaaatt
+ttaatgcccgctgaaatatccaacatttaaaacaggattaattctctgatccatgaactt
+aggactcattgcacgtgacttatctttctctcttaattcatgctccaatacggtgggcta
+aaccacttttatcacatgaatgtacgcaacgtgttaataagctatgagtacgcgggggca
+gcgaaacgggtcaatctgggtatcttctattgggacggtacatttcggttttatagacta
+tgtagttacacggcatcaacatgtaattaaaacggcgtaacctaggaaagccgaacgcac
+cttgggattgccatgtgtccggaggattacatacatctaagaaacattctaaactatgta
+tagtcgtttacgacccttgtagtacgtgcatcccttggcgaaaagtactctgggtattag
+agtgtatattatcgacagcaccgaatcctcattttatagcttgacaatttatgacccgaa
+agaaccttttataagtctataagtatatctaacgcaattgcggcactgagtccactaact
+atctttgagcagtgttatacagtgagacgccatggaaggggtttatatattttactgtcg
+ttccctaaaaagttaattatcagacctgcgcgatctcgtagatgaacaacgcgatctagt
+cgaaaaatgcttgtggctaccattccagtcgagatcaaccgtttctgcggatcgcgttac
+attccttgcttatttgcgataaatcgatacaaccccattaccagaaaaacccggagaatc
+aattactctgcagatcttatactaaaaaagagattacaacccctgttctatgtgtcccaa
+agtgagtaacgtggagcgttggggtaagagcggagcgattttaactttcgcttttccatt
+ttccagtattgtactttacgttatatttgagcggcacattcgtcaaaacatgatccatat
+ggactgaggtgtttaaatgttaatcaaataattgtattttcagctgactttaaaatctgc
+agccattggaggtggagattccaatagatgtaagcaggtgatatcatatgcaattcttgt
+gacttattaagataccagacacggcacaatcgcagtagcacgtaaacaataatgacaatc
+gacggttaaattccgaacgtaagatatgtttacggatgcactaaaataggtagcaacaac
+gtttctctgagatgtataagttaccaaacactggagaattccgctaaactaaggacaatt
+tccgtcgtattaattgttgacaaatggttagtaatacattcgcagtggataatccgttgc
+atacctagcactgagtgtaaataaaaccaatcgactactggcatttcgggctaacgacta
+gatgttagcctatgtgaaagcctcacacatgcttattgccttcacggtgagcaatgtttc
+ttattcgttattagaagtcacctgtagagacagtagagatgacctaaatttggtttgtcc
+agtcccgaggtgatctaatgattaggttaacttagaacagtggtcaattggttaaagctg
+atttacgaacacttccgaggggtcgtaaaacattaaactggtgagaacagtatgatgtat
+tcggtcatctagacaaccccatcgctgggagtttggacagtgttatgattcgtaaatcca
+ccatgtgtccgaattcgaaatcctgttgctccggggagatagggttaatttaggcttttt
+tacggtgtggcatattagctcaaacatcaacattcttaaaatcagcgtaaacggtcacca
+gttgatatttgttctgctaggaagcgatgtacaaaataagcttaataagatttaggtccg
+accttaatttcggtccatagcacctctttctaagtgttttgcttaaataattgtattgtt
+attgattttctgcgagttgaacacggaaaataagtcaaaaaggacacttttaggttcata
+tgtaccgatgaatgcgcaatagaatcgagaaatttttagattagtaatcgtgatgattgt
+ggccaaatcccgcactaaacggctttcgctgtttccaaaaaattttagtccactaggtat
+ttaaatgttggacactgaacgtggaagccgtcgtattatgaaactaatggcagaggggct
+cctctgcgtgtactttgagcagatgctatcgtcagaaaaaggtaaatcttttggttcttt
+ataattctggcgtccgtgtagcctagtgaatgtgtttggttcaagtgaatttgtttagcc
+agaatggaccaattacgtcattagctgttacgtctatacgaaatatagactgtggacgac
+ccatcgtagagtcatgtagttacatgtgaccttagaacaccaatcgtgtgcgattgtaag
+caggacaacacagtattgtactggtcaattggttcatagatctgactatgaatcttcgtt
+tttgtacaacaatctcggtgaagcttcaaaaagcctccttcctaataatcagttaatttt
+tcgtaaggttcctgttcgaggttagtcgtataaagacgaaacggccttaatgtaacatta
+actattccactgtaggtggatctaacaaggttggacatgtgctaccaataagataagaat
+ttcgtccgcaatacaatatctacttttgtagcctatcttggattaacaacaacttacgtt
+ggtatttcaccggacgtatcaaatgattctgattttaatgactgagagtaaacatcaacg
+aatcttatgtatctttaagccgctgcttgacaagtcacattactgttagaatgaacgctt
+cattactacaaaacctaccaccaactcccacattaatattatactagatgtttgaagttt
+atttgacaaaggttttcaaaaagcacagaatcgttacgaacacgtacattaaattgttag
+ggtattaattgtggtcggtgcatttccggccccatagcgctccgcggggagaaactatgg
+ccttcatgacagcccccccataacatctaggtaatggtcggataactataaacaaccctc
+tccagagaactgtgaaaataaaatctcttagtacacaagcgtatactggtttaagtcttg
+cccatcttaaagactcttttcactattttcttgatgcctcattcttctaatattaggtga
+ttttttaatccgagaatataaaaagacgatagaaagtgttaaaacacggcgtagcgacat
+attttaaagaaatgaaatactttttgactatccctcatgatctaaacttacgcggagcta
+tctttttgtataacatgtacagagaattaatccgatgcttcttccgattaaggacatagc
+gccgaaaacgtcatggcggcttatcgatatcgtaacgcactataccaagtgattaagtga
+tcaatgaatacgggtttcgggatttctgttaagtcatgcacggcaaatacttggagtctt
+gaataacgccgcgcgtagtacgaaggttctcaagctcgcgtgacgtatagaccgtattgc
+tatttcctgccttctcaattgtccgaggattgctgataacttaaaataaggttgagtttt
+taataacgatttgtcgagtttgggaaaatcctcgtttgtgtgtttgtcattttcaagtta
+tcaagaactacgggtataatttacgacgtaatgttggtttgatgcccgattgcgaatatc
+gtacgaatggtatttgtacaactgctttcctttatcgattgctcgagaacattataaagt
+ctattactatggattaagactgtatacaagtgtttaagcggagcccgtgataatctataa
+ggttttggtacctttatctgttacttttgccttgaaacatacatacgtacacgggaatat
+ttacctaaacgccgtatagtccagcctcgtatttgggccgtgttttgtcagcattttaaa
+ctgaaagcgcccacttgcattataacccggtgcggaatctcttagtgactcgtcaggagt
+ttacgcctttgagacctctcgacaggacccattttgatctagtcgttataggtagagtgc
+ctttcctatcgcaccattaccttctagcaaacttagagtattcaatgaaatcatatcctg
+tttatactaaatgttataggctaatgacacagctgacactaagaggtctcttcgggttac
+ccgaatgagttgtttatacgatgttgacaactcgggggagtcatttcaatgaagactgag
+gactcttgatcagattaaaacgcttaatgactgataatttagattatgccgtgtattatt
+taagtgggcgaaccctcccctagaatgggtttcctgagaaaagtcttagaacacagtatt
+ctgaatccagatgcaaatcgctaacgttagtaagcggctgtagctcttggcagtttggtc
+aatagtcaatcgcaatccgtttaaccgtctactattcctagagcgaagagctatgttctg
+acacgtccccaatattaggcaaaggctccaaaagaacagtcaattgattaactacgggct
+tggtttctccgtgaatccttgcgccgctataccacataaaaggatagcggtgataccaca
+agtttgcgacgttaaagcgtcgaccctcaacaagtacactagcaaccccttagcaattaa
+ttttgtccatcactactgccaagagttgactggaccagttggaaatgacatttgatatat
+taatagagctacatattgtaccactttactgtcacttacactaaccctagcgtgattact
+catacatatattcgtaaattctaagttatgatactagttttgtaaatttaatcggcgaag
+acacgttctcttgtacgagcttcaactaaatatttcactgtagccaaccactttaaccag
+aaggataccttaatgccgatataatattgtccaggaaacgttaatactttcacaagacaa
+agcttggaagaggtactttacgatcacctgatagatcgaccggaacgattctatataggt
+ttggtctgagaaatttgtagctaaaaccatgttccataggaactcctctgtaatgggcaa
+aatgcagatagcgttcaatcgttgcttaactatctatcacagcatcctaactcctcaaca
+gcttctttcctaaagacatcagcaggtaagttgacggcacccgataacccagagcacgat
+tggaatctaatactctgtatggatcattacgctaagtaaatataatgattttctgactca
+aagttacactgcgaattttatattaactggttctatttgttaaataccacaacctctcgt
+caacaggtcgcgatgcaagtgatccaaaaatatctaacttataccaaccattacttctgg
+cgcagaaaaacatagatatctgaacaatcgaccgttaagactgtctcgccgatcttagga
+acctaatactgctcagtagttattgtttatttgggccatccccggattatgtcagccatg
+gaacactaaaagtcctaatctaacctatggacaaaaagctcacttttataaaattgctca
+ccttatgttgattgttatttgtccgaaatgtctataactcagtgtactatctattggaaa
+attatggccggagttttattgaatatacttttgtatgttgagaaagaatgttgtcgtaat
+aattatcagctggaaaatcatctaatatatattatattgagatattacgacagacctaag
+tgctttcccgtcatgagcagatggactaacactcttggtaatccttctcgttttagttgg
+taatgtttagtctaagtaatatcccgactcttacttactcagagcggaaatgacttttta
+aactaacgtttaaaggcacttagtatgcgtcagggttatttttttaattacgtacccttg
+tgcagagagtttagctattcgatcctacttagtatgaaccatgagagtacaggttggtaa
+ttcacagagaaggtcgagaagattatttttgatgtttaccaatactatgaggcgtattca
+tcgaaataattttatggctgcgcacttcacatacgcaggaagaccactgcagcttgctag
+atctggatgtatcattgtacttctaagagcctgaaaggtaatacattcccagcgagcgta
+acagattgtatggggacatattcaatcttagcaatgcattcgttcttcgaaatcaggcat
+ttttgatgtcataagttctgtcaactataaccctggaactttaatctgttgttcgtcgaa
+tcaaggatcaagaaagcttctaaaaggcccaaagcaaaacccaccactacttcagtttta
+aattagaatcacaccctagggtattagataataattaaatgtcttaggaagagatatcaa
+aagatgcagacatcctcaagtgaataagtctccggtctttcacaaacacatggttaagcg
+atgtggttttgactagagacgttcgccaccatcgtaatatttctggttacctgcgaacgt
+gaaccaaatcttacttcatacattgcttaaacagtacaacttatctcttatcctatagag
+atctcaaaagtttgtatttttactggtttcaaattgagagaaaaactgcgttctccgatt
+tctatattattgtttaaatgatgccaaacatccagtttaaaacacggtgtgatcagccga
+ctcagattcgtatcctatgttagaatgagtcatcaaactacggtcacgcgtacattacag
+agtaaactacacgaatgaaagagataagaagatgaaagagttaataggtctcctgttaat
+tatgagaaccctaactactacggattggcctactagtgggttggaacggatataaaattc
+gactaagttcgcggcatgtcaggctcctaaatatgaagagaactcggcatcgaattatcc
+acagtaatagttggaacatgattcctctatgcatggtgtatatccacgtacgccagtgtg
+cagtgtagccatgcgaccacgggcgttgtgaatattcttcctcagaaaaggactgttgag
+caaggaattggattctgtgaacggaatatagtcgagtagatggaatttcctacactgcga
+aaaggtcatagtaaatcaaacgccgcgcgcagacatatcttcttggcaattagtactcca
+ctaaatcaattggttataaacttttagaatatctttatataagttcactacttacgctgc
+gggtagtatatttaaagtgatgtcttaggaatcttatggcggcggaataaacggcttgac
+tatagataccctaattctggcataaccctgtaacgtgtgaagcatgctttaatagacgac
+tagatcagcttatagaatggatatgactgccacattgaagagattaacattagcgggtat
+aatgttacgaacttgtttaacaaaatagctctaccacacacgcatagtataatataaagg
+tcctggagttcgctacgagcctggaattgcagttcccctaccctgagtaaacaagatcag
+tatggacctatcttctgacccacgtgtaaaaactaccgttagcggccctgagaacggtga
+agttgattatcggctaacactcgctttaccaaggaacaaacaattgatggaacaggtaag
+cggctggattctatcctgaatacagcataataatatttgctttcaatatatagttatgac
+actcccaatatcactaactctttacaaatcggatatgaagagtgaattagagatggagcc
+gatcgttccttgtattctggtaagtactcgactaatgtgtgtagtctaggggtaaaggtc
+cttaaccgtcgagtctagaactcacgcattatgaaatcctccgagcatagagactctaaa
+ttcgccaagcaataagtcccgacgcgaaggatgagaagctcattgaactgtaacatttac
+gtcgggctcaccatgttacatatgcagcgggtaaaagtttttgcctggagtggttgagtt
+tcgcgatacataaaaggccccactttcatatggtcaaatatctatatcgtgctttggacg
+actcgataaactaaagtagcctagtaatgccctaaaccgctgcatttgtgcaataaaaaa
+tttagagtatatataacttccggacgtatggctgccttgaatcctcggatatcgtcctta
+tacaacgatgaacggtatagctcggaactatgcagattaggcgatccttgggttgaattt
+ttagtttccatagatatgagttagttttgatatggttaccatacgtccctgcattgaaac
+ttaatctgtatattgattgatccttagcaatagcggcacatttctgggcaatatgactta
+attaggttacggtttttactatgatggatacgttttatatgatagaataacagttgctat
+ttaaacaggtactacattcaactaatactgtttcactattgtgtccaacatagggaatat
+attgcctgaatagatgtattatcaggcatcttttacgctccaggtagaactaattaaaaa
+tgatccttagaaactttcaagcaacataagctaaaagttacgccaattataagccacatc
+ggtaggatcttcaggcattcccatatccttctctatcaatcccgtctgttgctaattggt
+tatctaagcatatcgcggcgagcatctacgataggtataaagttgctgctatctaattcg
+tcataatatatacatggaattacagattcatacgtcttcagtctcgtggtgtttctaaga
+gcggacccaagaattacgtaatatctctctcgtgttacccaagaagttgacacgtgattg
+tcagctatctttttctggcgatgttaatagttataaacaattgcatatagctgcaaatta
+gctaatcaaatactcgtttcttaaatgttatcagcaaagctttaggttctgtaatttcac
+tgtgtaaagagggcgctaagttcaaaattggtttttggcaacaaacaatttaatagcgca
+gtgcaaaaataatatctcagggtgtaattatttctctaattggtctttacggttggacca
+ggcaatgggttttttatctatgtgataccaattaaaagtaatttcaaagtgacattaaac
+ttaagtattgctgtcaagaccattacgacacttcaccaacacatttatgtattgtgctac
+gcggtatggcccgtagtaatttctgatattgaccgcgttatcagcaagtacgctgtacaa
+atgccaaatttagtaaagctctgtgtgcattccaaggtgcccacatcacacattatcaac
+atatcatgtcgttgtattacgtccttttactagcctgggaaataccggtgattcagagtg
+aacataaatctctgaaagctactagacaaagctagtatagttaaaatatatatttctttt
+aatattaggatctttgcgattgcacatttcaagcatcgcattaacctacctccgtactct
+tctacaacggttgcatgtacgatttctatgcgatgaaatacttatgttcttagtttgggg
+ttactttgttcacctagtcctcgaacgcaaattagcttcgaatatctgaaaagtgtatgc
+gggcaccaaaacgatctcgattcttaggtttataattatagtcagaagataaatacatgc
+atatctggacactcttccacatgtcatgtcgactaactttgaactacagtcatatataga
+ctgttatctgatccgtatgtgtctattactactcttatctgagaaaggacccaatggagt
+cacagtaagcgatcatgtcatcggggctttttccctgattataagattacactattgctg
+tgcttggggcctcctactttttctatcttaatcattttgtacattaaaaagctaagaagt
+aggtacaacttatctttcccatacgagctggaccattaatttaacagccgcaaggcgagt
+tttaatgttaatctggaagggctttatgttctaagcttttagcactgagaaattaatccg
+taggaaattaatcccacataacccggtaagagaaccttacgccccgttactaataatgtt
+ctgcgcaatgtaggaagtgacaagctcactcttgcgacgagctccttaatacaggccctg
+cgttatattcgaccgtacctataactagaccaccatcttaaatgtacagttatggttttc
+gacgcatagagtatgggaccacctcgaaatgctcagctgcaaattgtactgggggtggtt
+atcaaacatttaatatgaatctatggtaaagtactagtttatagatagccgaacactaaa
+ggtttgcagaccttcctcccctgaggaacttcgtgtcacaaattagattgagaaggtggt
+gataaaatcgcgtatctacaatgatttggtgcaaatatttatcgattgcccaatcgttct
+actcgtactctttatagcctaacgccttttcttggcgctaattagcctaatccaagaagg
+agtctaacaaaattacttaaccatactcttgtctattcggcccacgcatgcgcaagctca
+aaaagttctcaacgggcgtttttacttgagtcccaggaggtaacattggatctatgagtc
+ttaacagtggaaatatgatttttagattgtgttcagatttattgtcttattttggtctat
+ctcatcagctatagctacataatgacgtcttaactgtttcgactaaccttcagatctgac
+taccccaaatacaacatagcaaaagaatgatgctaacgcttaactatcctttcacgatct
+taacaaaaaagctccatttaaaagaatcgaaaacagatctaccattcgtggaatcaattt
+ttggacgagtactggtcgggtcgtgcttatttgctacaggattgtttcgtataacgttca
+agcactttagcggttccatccttgatggcgttaactgatgatgcgtaagtttatggtgat
+ctaaaactctactacgaaccaggtcccagcacgaaacgtcatctttaatgagtttttagg
+tctccaggcactaggctgcgaagtggaatatgtgtcatcagagacaaatagatgattcct
+atagctttttgcagttaagccactaagtaggcggttctatagggtttcattcaaatcgat
+cgtaattcccgactctgcatagcgtgggtcttgtatagaccattcttcaggcccgccaca
+atggtttcaagtttcaacttccgtttattggctgtccctcaatagagtcgttctcagggc
+acgactctcgttcgttattcataagtccagtttgatccacgaatacagaacacgcatatc
+tgataataaaagcttaacgataactttcacgcgcatggtttatttttgatttattaggca
+accaaataccagaatgtagtcagcgatatgtagtaaaatttagacaaacataaaacaaag
+tatcgccattacagtctcctgttaggagaacctttttatcaatatgtgtaggcgtgtatt
+ggcgcccttgatttaataataattacggctaaacgtattgatattttccaggaactgccc
+catctcatgagatgaccctaaattttattcacacctcatttttaattcttttatatcacg
+attatttatctgagcaagcatctttgcaagcattcatagtgacggtgctgtctctatgaa
+tgcatgctaatatacggtgcgctaaacatattggttcaattcaatgtaagctacctcgga
+atttgcttgcactaagacggggaagccaaaacggtaaatcgccgtatatgctagtgccaa
+gggacttgtccgttggagtcactatggagttacaagcattataaatctaaggaaatcgca
+gtatcagtccttaccccaaagatacttcgcattccctggggtacggaccatgaaatactt
+ctttcatacatgataaacgatggagactcggttaccaccctggtagttactccatcaatt
+ggagttaactaagatcgctattacaggctttattagccaatcatcacaagcctcttttta
+gagattcacaagttagcaaaccaaagttcctttgataagtctttaacgagatctatccca
+attccggctaggagtaaaatttatatatttgagatcggggttaaagtcacacgcaatgca
+aggggtttttatatggtaatgtccttccctaattaggtaattttcagacctccgagagag
+agtagatcaacaacgcgttatactcctaaaatgcttgtcgataacatgacactacagatc
+atccctggatgagcatcgactttcattacttgattagttcagttaattcgtttcaaacca
+ttttcaacaaaatcccccagtagatatgtatatgcacatcttagactaaataacagtttt
+cataccctgggatttgtgtcactatctcaggaacgtcgagacgtcccctatcaccgcagc
+gagggtaactggccctgttccattgtaatcgatgggacgggacgttatattgcagaccca
+aagtagtaataaattcagccatatggacggagggggggaattgttaagaatataattcga
+ttttcagctgaatgtaaaagctccagccattcctcctccacttgacattagttcgaagaa
+ggtctgagaattggaattgcttgtgacgttttttgtttccagacaaggaaatagcccagt
+accaagtataatattatgacaatagaagcttaaattcacaacgtaacatatctgttagca
+tgctctaatagaccgagaaaataagtgtctatgtgtgcgagaactgtcaattcacggcag
+tagtcacctaatctaacgtctagttcccgactatgaagtcttcacaaatggttagtaata
+atttcccagtggagtagaagtggcataacgtgcactctctgttaataatacctttagact
+actcccatttcgccagaacgtcttgatggtaccctatgggaaacactcacacatgcttat
+tgcctgcaacctcagcaatgtgtcgtatgcggtatttctacgaacagctagtgaaaggac
+tgatgacctaattttggtttctcaagtccagacgtgatattttgatgaccgtatctgaca
+tctctgggcaattcggttaacctctggtacgaaatagtccgtcgcgtaggtaaaaatgat
+aatgctgtcatcactatcatgttttagctaagctacactaccccatcgctcgcacgtggc
+aaagtgtgaggattccgatatcatccatgtgtacgaattcctaatactcttgctcagggc
+acttagggttattgtagcctgtgttaccgtctcgcatattagatcattaatcaacagtct
+tataatcaccgtaatcggtaaacagttgttatttgttctgataggtagacagctaataaa
+gatgctgttgaacagttacgtcccacctttattgccctacagtgaaactagttcttactc
+tgttgctgtaatatgtctagggttattgatttgctgccacttcaaaacggaaattaagtc
+attaacgaaaatggttccttcataggtaaagatcaatccccaattgaagccagaaatttt
+gagatgtcgattcctgatcattcgccaaatttacagctcgtaaacgagttccatgtgtaa
+aaaaatgttgagtccactagcttgtttattctggctcaaggtacgtggaacacgtagtat
+tttgatactaatgccagacccgctacgatccctgtactgtgagcagagccgatcctcaga
+aatagctaaatcttgtgcttcgttagaagtctcgactacgtgtagcctagtgtttgtgtt
+gcgttatagtctatttgtggacacagtatggtcaaatgacgtcttttgatctgacggcgt
+taacaaagatactctgggcaacacacatacttctctcatgttgtttcttcggacctttca
+taacctttcctggcacatggttagctgcacatcacaggattgtaagggtctagtggttca
+gtgagcggaatatcattcgtcggtggtgttaatctatctcggtgtagcttataaatgcat
+ccgtaagaatattatgtttatttgtcggtacgttcatggtagtggtgtcgccgatttaga
+cgtaaaggcatgtatggatcttgatctatgcaaaggtaggtccatctatatacgttgcac
+agcggatacaaataagataagaatttactaacatttaaattttcttattgtcgagcatag
+attggaggaaaaacttatttacttggtatttaaacggaagtttctaatgtttatgattgg
+atgcacggacagtttactgcttactttcttaggtttcttgaacaacaggatgcactagta
+acatgtctcgttcatgcttccattaagttcttcttaaacttacacaaactacctaattta
+gagttgacgagatggttgaacgtgttgtgacaaacgtttgcaaaatgcacagtatcgtta
+ccaaaaagtacatttaagtgtgtgcgtaggaattctgctacgtccattgcaggccacatt
+cacatcccacccctgaatatatggactgaatcacacacaccaaatttcatctaccttatc
+gtagcataactattaacaaacatatacagacttcgcggtaaataaaatatattagtacac
+aaccgtatactggttgaactattgcccagctttaagacgcttttaactaggtgcttgatc
+aagaagtattattatatgacggcagtgtgtaatacctgaatagatatagacgttagattg
+tctgaaaacacgccgtagagacatttttgttagatatgtatttctttttgacgagccagc
+atcttagtatctgaagacgagctatatgtttgtagaaaatcgactgacattgtatacgag
+gcggcgtaagattaaccaaattccccagaattagtaatggcgccttatcgatttactaac
+gatatataacttgtgatgttgtctgcaatgtatacccgtgtaggctgtgctcttatcgaa
+ggaaacgcattgaagtccaggctggatgaaaccaccgcgtacttccatgcgtctatacat
+agcgtcaccgatactacgttttgctatgtaatccattctaatgggtaagaggattcctct
+tatagtaaaatatgcttgactttttaagaaccattgggagtggttggcaaaataatagtg
+ggtgtctttctcagtgtatagttttctacaactacccctattaggttacaagtaatctgg
+ctttcttgccacttggcgatgatagttagattcgtatttctacaacgcagttactgtatc
+catggcgcgagataattagatacgatttgaatttggatgtagactcgttactactgttgt
+agaccagcacgtgagtatctagatgggtttgctaccttgttagcggacttttgccgggaa
+aaagacatacgtacaaccgtatattttactataagcagtattggccaccctcgtattgcg
+gcagggtgtgctcacctggttaaaatgaaagagaaaaattccattttaaaacccggagga
+atctattactgacgaggaaggtgtttaacccgttgagacatctcctaacgtaaaaggttc
+atattctagttattccgagagtcactttcctatccaaacatgaactgatagcataatgac
+aggttgaatggaaagcatatcctgtttattctaaatctgtttcgctaatcaatatgctgt
+cacgaactcggagcttacccttacaactatgtgttctgtttaccaggtgctaatatcccg
+gcactcttttcatgcatgtcgctcctagcgtcatctgatttaatagcttaatgtctcata
+ttttacagtagccagtgtagtatggaaggcggcgaaccagcccctacattgggtttcctg
+acataagtattacatatcacttgtctgattacacagcaaaatcgctaaccttactttgcg
+catgtagctattggaactttgggctagtgtctatcccattaagtttaacagtagactagt
+ccgtgagcgatcaccgagcttatgtctcgtacccaagttttggatttggatcaaaaacta
+ctcgatattcatgatctacgggcttcctttctccgggtatcattgcgccgagattaaaaa
+taaaacgatagcgctgtgaaaacatgtttgacacgggatagcgtagaaactaaacaacga
+atagaccatccaatttgaattttattgggtccagcacttcgccatagtgttgaatggtaa
+agttcgaaaggaaatttgttatattaattctgctacattttcgaccacttgtatctcaag
+gacaatatcccttgaggcttttagcagaaagagatgccgtaattctaagggatgataata
+ggttgggaaatttaagagcagtagtaacggtcgcgggttcgaccttaaactatatattta
+aatctagccaaacaagttaacaacaaccataaagttatgaccttattatattggcaagct
+taacgttttaattgctctagtaatagagtggtagaggtaagggaccatcacctgattctt
+cctccgcaaccattatatagacgtgtcgtctgacaaatttcgagataaaacattcgtcct
+tagcaacgaatatcgaatggcaattagccacattgagttaaatagttgaggatatttctt
+gcacagaatcagatctaatctaatgattcgttactaaacacttcaccaggtatcgtgaag
+gctcaagattacccagagaacctttgcaatataagaatatgtatgcagcattaccctaag
+taattatattctttttctgactcaaagtgacaagccctagtgtatattaaatcggtatat
+ttgggaaattcctcaaactatcctaatcaggtagccatgaaagtgatcaaaaaagttcgt
+acttataccatacatgaattctggccaagtaaaaaatagattgcgcaaaattcgtacctt
+aagtctctcgccaagatattaggatcctattactcatatcgtgtttttctttattgccgc
+catccccggagtatctcacccatccttctcttaaaggcctaatattacctatgcaaataa
+acatatattgttgaaaattgagaacctgatcgtgattcttatgtgtaccatatgtatagt
+aatcacgcgactatatagtgctttagtatcgcccgtgggtgagtgaatattctgggctag
+cgtgagatagtttcttgtcctaatatttttcagatcgaatagcttctatttttgtgttta
+ttgacatatgtcgaaactccttactcagtgaaagtcatgaccagatccacgaacaatctt
+cggaatcagtctcgttttacggcggaatcttgagtctaacttatatcccgtcgcttactt
+tctaacaccccttatgtatttttaaaattacgtttattcgaacgtacttggcggaagcgt
+tattttttgaagtaagttacattgggcagactcttgacattttcgatacgactttctttc
+atccatcacaggactcgttcgtattgatatcagaagctcgtgatgattagttgtcttctt
+taccaatactttgaggcctattctgcgaaatttttgttgccctgcgaacttcacatacca
+aggaacacctcgcaacatgccttcatatccatcgttcattgtaattcttacacaatgaat
+cctaagtaattacatccctgcgtaaaagatggtaggggcactgaggatatattaccaagc
+atttagttatgagtaatcagcaatgtttcttgtattaagttctctaaaatagttacatcg
+taatgttatctcgggttccgcgaataaacgagatagattcattatatatggccctaagca
+aaaacctcctcgtattctgttggtaattagaatcacacaatacgggttgagatattaatt
+atttgtagtacgaagagatataaaaagatgaacaattactcaagtcaagatgtatacggg
+atttataataaaaatcgggtagagatctgctttgcaattcagacgtgccactaaatcgta
+atatgtcgcgttacatcagaaagggtaactattattaattaataaagggcttaatcacta
+catattagatcttatccgatagtcttatctattcgttgtatttttaagcggttctaattc
+agtcattatatcagtgctccgagttctttattattgttttaaggatgacaaaatgcctct
+tgttataacgctgggagaagcagactaagagtcggagcagttggtagaatgaggctgcaa
+aagacggtctcgacgaatggacagactttactaaaccaatgaaagacagaagtagagcaa
+agtctgaagtggtatcagcttaattatgacaacccttaatacttccctttcgccgaatac
+tggcgtggaaaggttttaaaagtcgaagtagttagaggcatctctcgctcataaataggt
+agactactcgcaatccaatgtgactatgtaatactgggaacatcagtccgcgatgcagcg
+tgtttatcaaccgtccccactcgcctggggagacatgagaccacccccgtggggattatt
+agtccgcagtaatcgactcttgacaatccttttcgattatgtcatagcaatttacgacag
+ttcagcgaagtgactactcggcgaaatggtattactaaagcattcgaacccacatgaatg
+tgattcttggcaatttctaatccactaaagcttttccgttgaatctggttgtagatattt
+atataagttcactaattaagatcacggtagtatattgatagtgatgtctttgcaagaggt
+tggccgaggaatttacggattctctattgatacaatttgtctggcttataactcttaagg
+ctgaaccaggcgtttttagacgacttgatcagctgttagaatggtttggactccctcttt
+catgtcagtaacatttcagccgttattgttacgatatgcttgaacaatattgatctacca
+cacacccatagtatattttataggtcatgctgttacctacgagcatggtattccacttcc
+cattcaatgagtattcaacatcactagcctcagagatgatgacccacctctaataacgtc
+acgttgcggccatgtgaaacctgaacttgagtagacgatatcaagcgctttaaattgcat
+ataacatttgagggtaaagctaagcggatgctttatataatcaatactcaataataagat
+ttgattgcattttagagttatgacacgacatagttcactaacgagttactattcccagat
+ctagactgaagtactgatcgagacgatccttacgtcgatgatcgttagttatcgacttag
+gtcgggtctctagcggtattggtacttaaccggacactatactaataacccatgatcaaa
+gcataacagaatacagacgataatttcgccaacatatatgtacagaccccaagcatgaga
+agctcattgaaagctatcattgaagtcccgctcacaatgtgtcttttccagacggtttaa
+ctggttcccgggagtcctggagtttcgacttacataaatggaaacaatgtattttgctaa
+tttatctatagcgtcatttggaccaatacagaatattatgttgcctagtaatccactata
+acccgcaagtgctgatagaaaatttttagacgatttataaatgccccaagtatccctccc
+gtgaatcctccgttatactaattagtattcgttcatacgtataccgcgcatatatgaaca
+tttggcgataaggcgcgtgaattgttacgtgacagagatagcagtttcttgtgatatggt
+taacagacgtacatgaagggaaactttatatctatagtgatgcttccgtagaaataccgc
+cactggtctgccaatgatgaagtatgtagctttaggtttgtactatgaggctttcgtttg
+tttgcagagtataacagttgcgagtgaaaaaccgacgaatttatactaatacgctttcac
+tattggctacaaaatagggaagagtttcaatcatgagagggagtatatggatgctttgta
+gctaaaggtagaacgtatgtatatgctgccgttcattcttgaaagatacataagcgataa
+gttacgacaattataagcaacatccctaccttcgtaacgatttcactgttactgcgcttg
+aaatacactatggggctattggcggagagaagcagatcgcgccgagcatatacgagacct
+ataatgttgatgatagagaaggcgtctgaattgatacatcgaagtacactttctttcgta
+gtatctctcgtcctctttctatctccggacacaagaattaagttatatatatagagtctt
+accaatcatgttgaatcctgattctcagagttctttggcgggccttgtgatgactgagaa
+acaatgcaatattgctccaaatttcctaagcaaattctcggttatgttatgttatcagca
+aagcgttacgttatgttatttaaatctggaatgacggagcgaagttcttatgtcggtgtg
+ggaataattcttttgaagacagcactccttaaataatatcgctccgtgtttgtatttatc
+gaatgggtctgtaaccttgcacaagcaaatcggtggtgtatatatcggataacaattaat
+acgatgttcatagtgacagtatactgatcgagtcctctaaagtcaattacctcacttaac
+aatctcattgatgttgtgtcattcccggtatcgcccgtagtatgtgctctgattgaccga
+gtgtgaaccaaggaacatctactaatgcctttgttaggtaagatctctctgaattccttc
+gtgccaacttaaaacattatcaaaatttcttctacttggattaactacttttacgagcat
+ggcaaattcccctgtggaagacggttcattattatcggaaaccttatagaaattgcgtgt
+tgactgaaattagatttttattgtaagagttgcatctttgcgattcctctggtctagctt
+ccaatgaacagtcctcccttctattcgacatcgggtccttcgtacatgtctttgcgatgt
+aataattaggttcggagtgtggccttaatgggtgcaactaggaatacaacgcaaatttgc
+tgacatgatagcaaatcggtatgccggcaccaaaacgtgctccttgcttagcttgtgaat
+gagactcagtagttaaataaatccatatctgcaatcgattccacaggtattgtccactat
+ctttgaactactctaagagatacaagcttagctgagaccgaggtgtatatgactacgctg
+atatctgtaaggtaccaatgcaggcaaagtatgcgagaagctaataccggctgtttccag
+ctttataagattaaaatttggctgtcctggcggcctcagaattgttctatcgtaatcagt
+tggttcattaattagctaagtacgaggtacaacttatctgtcccagaacagctccacaag
+tttttttacagccgaaacccctgtgtgaatcttaatatccaagcgcgttatctgattaga
+gtttacaactcagtattttatcagtacgttttgtttccaacattacccggtatgacaaaa
+tgacgccacgtgtcgaataatggtctgaccaatgtaggaagtgaaaagataaatattgcc
+tacacatactgaattcaggcaatgcgttttattcgaaaggtcatataactagaaaacatg
+atgaattcttatcggatccttttactagcatagtgttggcgaacacctcgtaatgctcag
+cggcaaattggactgcgggtccttatcatacattttttttcaatataggcgattggtcta
+ggttagtgattccccaacacttaaggtttgctgacattcataccctcagcaacttcctct
+caaaaattagagtgagttggtggtcttataagaccgttgattatttgaggtggtcaaatg
+atggtgcgatgcacaaatcgttataatcgtactctgtagacaataacccattgtagtgcc
+gattttgtgcataatacaagaaggaggatataaaaatgacttttcaataatattggctat
+tagcaacaagaaggagaatcctcattaagttagcaaccgcagggggtactgcagtccaag
+gaggtttcattggagagagcagtatgaaaacggcaattatgattgtgagattcgctgaag
+attgtgtctctgattttcctagatagaataagctatagctacttaatcaactcttaactg
+tggagactatcctgatgatctgaataccccatttacaaaattccatatcaatgaggctaa
+cgcttaaatttcatttctccatcgtaacaaaaatcagcctttttatacaagacaaaacac
+tgcttccattacgggtagcaatggttgctcgactactggtagcgtcgtgatgtggtgata
+aagctgtcttgcgtttatacttaaacaaattttgacctgacataatggagcgacttatcg
+gatgttgccgatctttagggtcatctattaagcttatacgaaaaagggacaagcacgtta
+cgtaatctggtaggactgggtacctagaaacgcaagaggaggcgaactccaatatctgta
+agaacagaaaaatacaggagtccttttcatttttcaagttaacaatataagtaggagctt
+agagaggcttgcatgaaaatcgttaggaattacagaataggcagagagtggggcgtgtag
+actacattcttcaggccccacaatatgggttataggttaaactgcactttttgcgatctc
+ccgaaatactgtcgttctctgcgaaccacgctcgttccttttgctgtagtccacgttcat
+ccaactattcagataaacaagatcgcagaattaaagcttaaccatatcttgatagcccat
+cgtgtatggggcatgtatgtgcaaacaaaagacctcaatcttgtctgcgagagggaggaa
+aatttagacaaacataattcattctttcgactggacacgctaaggtttggacaaactttg
+tatctatatctggaggcctgtattccagcccttcttttaataagatttacggcttaaact
+atggatatttgccaggaaatgacactgctattgacaggaacataattttgattcaaacct
+cattgttaattattttatatctcctgtttttatatcagaatgcttctgtcctagaaggca
+tactcaaggtgagggctcgaggaatgaatcataatagaccggcccctattaatattggtt
+caattctttcttacataacgcggaatttgattgcacgaacaccgggaacacataaccgta
+tagcgcccgttatgctagtgcctagcgactgggaccgtggagtctatatcgtctttctac
+cattattaatctaaggatataccactttaagtcctttcaactaacataaggcgcattcca
+tgcgctaaggaccttgaatttattatttcttacatgataaaagatcgagtcgacgggaac
+aaaaggctacgtactcaataaagtgcagtttactaagagccctttttctggcttgtggag
+actatcataacatgaagatgttttgacattcaatagtttgcaaaacaaacttactttgtg
+tagtattgaacgagatctttccaattgccccatagcaggaatagttatatattgcagatc
+gcggtgtaacgcactccaaatccatcgcggtgtgtgagggtaagcgacttaaagaattac
+ggtttttgatcaaagcacagtgagagttgagcaaattacagttatacgacttaattcagt
+ctccataaattgaaacgacacttcttaacgggaggaccagacacgttcattaagtgagga
+gtgcactttttgactttaaaaacatggtaatcaatttaaaccacttgatatgtatatgaa
+cagatttgaagttatttctgttttaatacactgggagttctgtcaatatcgcaggaaccg
+cctgacgtcccctatcacacctcagagggtaaagggacaggggaaagggtaatcgagggg
+tagggaacgtagttggcacacccaatggacgaataaatgctgccatatccacggagggcg
+ggattgcggttgattttaaggcgatggtaacctgaatgtaatagatcatcaaatgcctcc
+tccactggaaattactgcgtacatccgctgagaattgcaatggagtgtctcggtttttct
+ttaaacaaaaccaaattgacaacttcatagtataatttttgcacattacaagcgttaatt
+aacaaacttactttgctgttagctgcctatatttgtccgacaatataactggatatctct
+gcgagaactgtaaattaacggcacttggaacataatagttcctattggtaacgacgttgt
+aggcggcaattatccggtggaagaattgacaactgcagttgaactgcatgaaagtcaaat
+ctctcgtaagtataactttagaagactccaaggtacccagaacctcttcagcggacacga
+tcgctatcaatcaataaggattattcactgaaaccgctcatatctggaggtggacgtttt
+tcttcgaaaagcttgtcaaaggactcatcaaatttttggccgtgctaatcgacacacctg
+ttattttcatgaccggataggacatctcgcggaaattcgggtaacagctgggtagatata
+ggacctcccctacgtattaatgataagcctgtcataactagcttggtttaccgaagagac
+aataaacattcgagcgctcgtgccaaactcggtgcattacgtttgaataaatcggtaaca
+tgtactattactctgcctaacggcacttacccgtttgggtccatggggtaaccgctcgat
+gttgacagaattatgctaaagtcgtttaagatcccgattaccgaaaatctggttatgtct
+gagcattcgtacactgcgtattaagatcaggttgaacaggttcctaacaaattttgtgac
+ctaaagtgaaactaggtcgtactctgggcatgttttatgtcgtggcgtatgcatgtgctg
+acacttctaaaaccaaattaaggctttatccaatatgggtccttaagtgctaaacatcat
+tcacaatttcaagacagattgttggtcttgtcgattccgcatctgtcgccaaattgacac
+atcgtaaaccaggtacatcggtaattatatgttgactaaactaccgtgtgtattctggct
+ctaggtacggcgaacaagtacgatgtgcttaagaagccctcaccccagacgagcccgcgt
+aggtcacatcagcagatcctaagtaattccgttttattgtcctgagggagtaggatcgac
+gaactctacaagtcgctttgtcgtgccttataggctatttcgggtcaatgtagcgtcaaa
+tgaactattgtcatctgtacgagttaactaagtgtctatcgccaactaaaagacgtctcg
+atggttctttatgcggacctgtcatatcattgactggcacttgcttacatccaaataaca
+cgtttgttagcggatagtcgttaagtgtgcgcaagatcatgaggcggggggggtaatatt
+tcgccctctacatgataaatgaataagtaagaagatgatctttttgtggcggtaccttaa
+gcgtactcctgtcgacgagttactactaaaggaatgtagggttctggatctatgaaaagc
+gacctccatatatatacgggcctaagcggagtaaaataagtgatcaatggactaacattg
+aaatgttagtattgtcgaccattgagggctggtaaatcttatttacgggcgtgggaaaac
+gaacgtgatatggtttagcatgggatgcaagcactcgttaatgcttactttagttggttg
+cgggaacaacaggaggctatactaactggtagcgttcttgcttccattatgttattatta
+taattaaaaataagacatatggtagagttgtagtcagggtggatcgggttgtctataacg
+ttggaataatcaaaactatcgttaacaaaaacgaaatttaagtcggtgcggtggaatgcg
+cctacctcatgtgcaccacacattcacagcacacccctcattataggcaaggaagcaaac
+aaaaaaaagttaatcgaccgtatccgaccttaaattttaaaataaatagaaacacttagc
+ggtaatgaaaagataggactaaaattcactagtatcctggaacgaggcaacagagttatc
+tagatggtaacgaggtgctgcatcaagatgtatgatttttggtccgctgtgtggaatacc
+tctattgatatacaagtgactttctcggtaataacgcacttcacaatgtgttgtttcttt
+tctatgtattttgcaagagaaagaagcttagtataggtacacctcagagatgtttcgtgt
+aaatcgtatcacatggtataactgcaggaggaacattatccaaattcaccacaattacta
+atccacccttttacttttactaaagatatattaattctcatgttgtctgaattgtataac
+ccggtaccctgggagcgtatcgaaggataccaattgaagtcctcgaggcatgttacaaca
+cacgacttccttccgtctattcagacactcaacgagactaacttttcctaggtaatcaat
+gatattgggtaactcgtggcatcttatagttattgatccggctcttttgtagatcctgtg
+cgactcgtgcgctaattaagactggctctcttgcgcaggggatacgtttattctacgtac
+ccgatttggttactactaagcggcctttcttcaaacttgcagttgtgacttacattccta
+tttcttcaaagcagggaagggttacagggagagacttattgagatacgattggaatttcc
+atgtacaatcgttaatacgcttgtagaccagcaactcagtatagagatccgtttcctaaa
+gggtgagcggtaggggcaaggcaataagaaattactaaaaccctagttgttaatataaga
+acgattcgaaacaataggattgcccaagggggtgcgaacatggtgtaaatcaaagagaaa
+taggcattgttaaaacccgcacgtttctagtacgcaagaggaacgtcggtaaccagttct
+caaagatcctaacctaaaaggggcttattctactttttccgacactcaatggacgagaca
+aacatgaacggatagctttaggtctcgttgaatgcaaagaatagaatcgttattattaat
+cggtttccattatctatatgcggtatagatctccgagaggaccctgtaaactagctctgc
+ggtttaactggtgctaatagaccgccactatgttattgcttctagctcctagcgtcttat
+catgttatacattaatgtcgcatattggacagtagccaggcttggatggatcgccgacaa
+aaagaaaagactttccctgtaaggacttaactattacatataacttggatcattaatctg
+caaattagagtaacggtctttcaccagcttcatattccaacgtggcgctagtcgatatcc
+catgaagtttaaaactagaattggcagtctcacttcacagtgcgtatctatacgacaaaa
+gtggtcgatttgcataaatatcttatcgatattcaggttattaccgattccttgctaacg
+ctagaagtcacaccagagtaataataattccagacacctgtgaaataatcggtcactacg
+gatagactagtaacgataatacgtatagtccataaaagttgaattttaggggctaaagat
+attagcaatactggtctagcctaatcgtcgatagcaaagggctgtgaggatttctcctac
+attttcgaccaattgtatcgataggaatagttacagtcacgcttgtagatgtaagagatg
+acgttattcttagggttcttaagtcggggggtaatttaagaccactagtaaaggtagagg
+cgtacacagtaaacgatattttgaaatcgtcaaaaaaaagtttacaacatcctttaagtt
+agcaactgattttagtggcaaccttaacggttgaattgatctactaatacaggcctacac
+cgaagggtacagataatgattcttactaccctaacatgatagagtcctgtcctatctcat
+aggtcgacattttaaattcgtaatgagcaacgaagatcgtttcccaatttgcaacattca
+cttatagacttcaggttatttcgtgctaacattaagatagaatataatcagtcgttaaga
+aactattatccagctttcgtcaaccataaagattaaaaactgaaacttggcaagatatga
+atagctatcctgctttaaccgatcgtatgagatgctttgtagcaagaaaagtgactagca
+cttgtgtttagtaaagcgggagagtgcggtaattaatattaatatactattaagctacac
+agcaaaggctgcaataatgttagtaagtagaacataaaggtattctccacaagtaataaa
+tagtgtgagctaattgactaacttaactctcgcgacaagtgatgtggataagatgactca
+tatcgtctttttctgtagtgccgacatcccacctggatcgaacaattccttctagttatc
+gactttgattacctatcctattaaacagatagggttgtaaagtcagaaaatgatcggctt
+gcgttggtctaccatagctagagttagaacgcgtagatagaggccttttgttgccaacgt
+gggggtgggatgagtctgggcgagcgtgactttctttcgtgtccgaatttgtttaacatc
+cattagattagatgtttgtgttttgggtctgatgtcctaactactttctcagtgaaacta
+atgtcatcatccaagtaaaatagtccgatgaagtctccgttttcggccgaagcttgtcta
+taacgtatataaagtcgctgaatttagaacacaccttatctatgttgtaaagttacttta
+ttccaaaggacgtgcacgaagcgtgagtgtgggaaggaacttaaagtcggatcactcttg
+tcagtgtagataagaatttctttcatacttcactggaatccggcgtatggatatctctac
+cgcgtcatctggtggtgtctgcggtaaaaagtcttgctgcacgagtctgagaaatttttg
+gtgccatcacatcgtaactgtacaacgaacaaatagcatcaggccttcttatccagcgtg
+aagtctaattatttcacaagctttcctaagtatgtaaatccctcacttaatgatgcttgc
+gccaatgaggatagaggacattgcatgtacgtaggactattctccaaggggtcttctatt
+ttgttagcgaaaattgttacagcctaatgttagagcggcgtacgactttataccagatac
+tttcattagatatgcaaatatccaattaaatcatagtagtatcgtggtatggacaatcaa
+aaaagacccgttgtgatatgatgtttttctagttcgttctcatatatatagatcaacaat
+gaataatctcatgatctataaccgatgtatatttatattccggttgactgctccggtgca
+attcactacggacactaatgactaatatggcgcctttcatcagaaacgctaaatatgatt
+aatgaattaagggagtattatctaattattagagagtagcagttagtctgatattttcgg
+tgtatgtgttagccgttataatgctgtctttttatcagtgagaacagggagtgtgtagtg
+ttgtatgcttcactttatgactctggttatatccctcggagaacaagaataagagtacga
+gaagttcggtcattgaggatgaaatagaaccgctagacgaatggactcacgtttataaaa
+ctatgtatcacagtactacagctaactctgaagtccgagaagcttttgtaggacaaaacg
+ttataagtacctttcgcagaatacggccgtgcatacctgttataaggcgtagtagggaca
+ccatgctatccctcatatagagctacactaataccattacatggtgactatcgtttacgg
+ccatcatctgtaagcgatcatgcctcgttagcatccgtacaatctcgcatggcgtcactg
+cagaaaaaccccgtgcggattttgagtcagaactattcgaagcttctcaatccttttcca
+ttatggcatagcaagtgacgactcgtcagccatgggaataatagcactaatccgattact
+tatgaattagaacccacatgaatgtgattctgcgaattgtctaagaatctaatgattttc
+cggtgaatatggttgttgttatttattgaacttatattattaacatcacccttcgttagt
+gatagtcagctatttccaagaggttccccgagcatttttaccattctctagtcatacaag
+ttggagcgcttttaaatctttaggctgatcaaggcgttttgtctagaattctgcagatgt
+tagattcgtgtgcaatccctcttgcatgtcagtaacaggtcacccgtttttcgttacata
+tgctggtaaaatattcatagtaataactacaatacttgatttgttacgtaatgctcgtac
+ataacacaatcgtattccacggaacagtaaagctctattattctgatcgagcctaagaga
+ggatcacactacgctattaaagtcacgttcacgaaatctcaaacctcaactgctggtgac
+cagttatagacagtgtaattccatattacatgtcaggcttaagctaacccgagcctttat
+ataagctataatcaagaattagattggagtgcattttagacttatctatcgaaatagtga
+tagtaagagtttatatgacctgatctagactgatgttctcttccacaacagccttaaggc
+gtggagcctttcttatactattaggtcgcgtcgagagccctattcgtaatgttaacgaca
+ctagactaatatacaatgagctaagaataacacaagtcacaagataatttacaaatcata
+tatctacagtccacaaccatcactagcgattgcaaagcgttattggtactaccgctctaa
+atcggtatgtgcaagacgcgttaactggttcaagcctctcctgctcgtgagactgaaaga
+aatcgaaaatatggatgtgcctaattgttcttgtgagtcatgtgcaactatacagtttag
+tttggtcaagactatgcaactattaacagcatgtgcgcattgaatatttggtgtcgattg
+ataaatgccccaacgttccatcacgtctataagccgtgttactaatgtgtattagtgcat
+acctattcagaccatagttcaactgttggactgaaggcccgtcttggggttcgtgaatga
+gagtgcagtttcttgtcttttccttaactgacctaaatgaaggcaatcggtttatctaga
+gtcatgcttaaggtgaatttcagccaatgggctcccattgagctagtatggtgctttacc
+tttgtaagtggtggctttccttggtgtgctgactttaacacggcagagtgattatccgaa
+gaatggataataagacgctggcaatattggctaataaagtccgatgagtttcaatcatga
+ctgcgaggagatccatgcggtgtacctaaacctacatcgtatgtatttgctgacgttcat
+tcttgatacataaagatccgatatcggtccactttgtttaccaaaagccctaccttcgta
+acgatggaaatgtgaatgagagtgaaatacacgatggggatattgccggtgagtacaagt
+tagaccacacattagaactgacctatattcgtcatcatagagatggagtatgaattgatt
+ctgcgaagtacactggctttacgagtatctagacgccgcggtatatctcccgtcaatact
+atgaaggtatatatatagaggctgaaaattcatgttcaatcctctttctaagagtgagtg
+ggagccccttctgttgtcggagtaaaaaggcattattcctcaaattgtcagaagcaaagt
+atacgtgatgtttgcttagaacaaaagagttaccttagggtaggtaaatctcgattcacc
+gagagaagtgattttggcggtgtgcgattaattcttttgatgacagatctcattatttta
+tatagctccctctttgtatttagagtttgcgtaggtaacctggcaaaaccatatcccggg
+gggagagtgcgctgaacattttatacgatgtgattactcaaaggataaggttcgaggcct
+ctatactcatggaactatcttataattataatggatcgtggctcattccacctatccaaa
+cttctttgtgatctgatgctacgagtgtgaacaaacgtacatcttctaaggaatttggga
+cgtttcatagctcgcatttcattcctgaaaacttaaatatttttaaaaattgattctact
+gcgaggaactaaggtgtagacaagcccttagtaaccggtggatgtcgcttcagttttata
+gcaaacattattcaatttcagtcttgactgaaattagtttgttagtgttagaggtccata
+tgtcacatgcatatggtctagatgccattgtacagtaataccttagattagtattagcgg
+catgcgtacttggatttcacttgtaagaatgagcttaggacggtcgcctgtagggctgca
+aataggaatacttacaatttttgatgacttgttagcatatcgctatcacccataaaaaac
+ctgatacttgatgagcgggtgattgagactatgtactgatataattcaatagctccaata
+gatgaaacagctatgcgcctatttatgtcaaataatcgatgtgatacaagcttagagctg
+aacgagcgcgagtggaattagcggtgatctctatcctaaaaagccacgaaatcgatccca
+gaagctaatacccgaggtgtcaagcttgagttcagttaaatttgcatctcatgccccacg
+aagaatgggtagagagtttgaaggtgcttctggattttcctaagtacgtggtaaaaattt
+gatgtaaatgaacacctcctaatggttgtgttaaccacaaacccctgggtgaatctgatt
+agccaacccagtgatctgatttcagttgtcaaatctcttttttataactaccttttgttt
+ccataatttaaccggatctcataatgaacaaacgggtagaataatggtagcacatagcga
+gcttgtctattcagaaatatggcctactcagaatgtattctccaaatcagtgttatgcga
+aacgtaattttacgtgtaataatgatgatttcttatcggttccttgtactacaatactct
+tgcccaacaaatactaagcataacagcaaaattcgaatccccctccttttaataaatggt
+ttttcaatatagccgattcgtattcgttagtctttcaccaactattaacctggcatctaa
+ttaataaaatcaccaaaggactctataatatgacagtcacttcggcctcttttaagacag
+ttgattattgcaggtccgcaattgatggtgacatgcacaattagttagaatccgactatg
+gagacaattaacaattgtagtgcccatttggtccagttgacttcaaccacgagttataaa
+ggtattttaatttatagtcgatagtaccaacaacaagcacaatcataattatgttagaaa
+acccagggggtaatgctctaaatccagctttaaggccagagtgcactatgaaatcgccat
+tgatcattgtgtcattcgctgaacttggtgtctaggaggtgccgagtgagaatatcagat
+accttatgaagcaacgattatatctggactagatcatgatgatcggaataaaacattgaa
+ataagtccttatcaaggagcataaacattttatttaatttatacttcgtaaataaattca
+gaattttttttcaagacattaatctgagtaaatgacggctagaaagggttcctactcgaa
+tcgtagcctacgcatgtgggcagtaacctggcttgcgtttttactgaaacaaaggttcac
+cggaaagaaggctgccacttttagcttcttgacgatctttagcgtcatatttttagatta
+gtcgaaaaacggaaaacaaacttaacgaagctggttgcacggggtaccgagaaaccaaag
+agcaggacaactccttgatcgggaagaactgaaatagacagctgtcattttcattggtca
+acttatcaatataacgaccaccgtagtgacgcttgcatgaaaatactgaggatgtaaact
+atagccagtcaggcccgcgtgttgactaattgatgaagcaaacaaaatagccggtattcg
+ttaaaaggaacgggttgccagctacagatatactctaggtatatcccaaacaagagacgt
+cctttggctgttgtaatcggtcataatacttgtcacataaacaagatcgctgaattaaac
+attaaacagttagtgatacacaatcgtggttggggctgggatgtgcaataaaaagtcatc
+tatcgtctatcacagagcgacgtaaatttagacaaacattattatttcttgacaatggaa
+tcgataagcgttcctctaacttggtatatatatctcgaccccgggattccagccattctt
+gtatgaagatttaaccatttaactatgcatagttgaatggtaaggaaaatgatattgact
+gcaacagattttggatgcaaaaatatttgtgaattattggttatatactggttgtatagc
+acaatcattaggtcctagaaggcatactcaacctcagcgagagagctagcatgcataatt
+gtaccgcccatattaatattcctgaaatgatttcttacattacgcccaatttcagtcatc
+gaacacccccatcaatttacccgatagagaacgtgatcatacgcaataccctatgcgaac
+gtccactctatagcgtctgtatacaatgattattcgttccatttacaacgttaagtaatt
+taaacttacataaggacaaggaaatccgcgaacctcctggaatgtatgagttatttatgc
+agttaacttcgtctcgaccggaactaaaggcgtcgtacgaatgaaaggccacttttagaa
+gagacctttgtatccattgtggagaatatcataaattcaagatggggtgtcatgctattc
+ggtcctaaacattcttaatggctgttctattgttagtctgatttaaaatggaaccatagc
+acgaatagttagatagggctcatacccctgtaacgatctacaaatccttccccgggtgtg
+tgcgttagcgacggaaagttttacggtttgtgatcaaagaacactcacacgtcagattat
+tacactgatacgaattatttcagtcgacagtaattgaatagaaacttattaacgccagca
+cctgacacggtaagtaaggcaggtctgaactgtttgactgtaaaaaaatggtaatatttt
+taaaaatcttgatttctatatcaaatgatgtgtagttttttctctgttattaaaatccca
+gtgcgcgaaatttagatcgttacgactcacgtacaagatcacacatcacacgcgttagcg
+aaagcggaatggctaatacagccctacgcaacgtagtgggatcaacatatggacgaattt
+atgctcaatgagccaacctcccccgcattgcggttcattttaaggcctgggtaacatcta
+tcgtttagataatcaaaggaatccgactatgcaattgtctgacttcatccgctctcaagt
+ccaatgcaggcgctacgtgtttctttaatcaataccatattgaaatcgtaatacgataat
+tgttgctattgactacaggttatgaaaaaacttactttgcgggtacatgcatatttttgt
+accacattattacgcgatatctctcagtgtactctaaattaaaccctcttcgaacatttt
+agttcctattcgtaaacacgtgctacgcggcaatttgccggtcgtagaatggacaactcc
+agttcaactgcatgtaactcatagctcgcgttagtataaattgactagtagccatgggac
+aaagtaactagtcagcggaaaagatccctttaaagatatatgcaggttgcaagcataaag
+ctcattgctcgaggtgcaccgtggtattccaaaagcgtctctatcgtatcttctaatttt
+gggccgtgagaatcgaaactactctgatttgctgcacacgttaggtaatatcgcccattt
+tcccgtataagctccgtacttatacgaactacacgaccttttaagcattagccgctcata
+tcgtgattcgtgtacagatgagtctattaaaattacagacatactccatatctcgctcct
+tgaactttgaataatgcgctaacttgtactatgaataggcagaacccaactttcccgttt
+gcgtcaagcggggaaacgatacatgttgtcagatttatgattatctagttttagatcacg
+tttaccgataatcggctgtggtctgagcagtcctacactgagtatttacttcagcttcat
+atcggtccgaaaaaaggttgtgaccgaatgtcaaaatacggagtacgatgggcatctttt
+ttcgagtcgcggttgcagggcagcaaaaggcttaaaccatttttacgatttttactatag
+cggtcatgaagtgcgaaactgcttgcaaattttctacacacattgtggctcttgtccttg
+aagcttatggcgaaaatttgaaacatagtataccagggaaagcgcgaattatttggtgac
+taatagtccgtgggtttgagccatatacctaacgccataaactacgtggtgctttagatg
+caatctaaacagaacagaaagcgtagcgctcatcagcacagactaactttttcagtttga
+gtcgccggagggacttcgagacaagaacgcgtcaagtcgcttgcgcggcacggattcgat
+tgggcggctcaatcttgcctaatttctactattgtcagctgtacgactgtactaagtgta
+tagccccaaataaaagaagtatcgatgcgtctttatgaccaaaggtcttataattgaagc
+gcacttccgttcatcaaattaaatcctggcttacccgattctccggaagtctgacctaga
+gattgacgacggccgcgtattattgagacctcttcaggattaatcaataacgaagtagtt
+gatctgtttggcgacgtaccttaagccgactccgctacacgagtttctactaaaccaatg
+tagccttatgcttagatgaataccgtcctaattagatattccggcataacagcagtaaat
+tatctgttcaatggacgaacattgaattgttagtattctacacaagtcaggcctcgtaaa
+tattaggtaaggccgtgggataacctacgtgatatgcttgagcttgcgttgcaagctctc
+gttaatcattaatttaggtgcgtgagggttaaacaccagcatattctatatgctagacgt
+cttccttaaaggatcgtagtattataattaataataagaaatatggttgacgtctagtca
+gcgggcatacgctgctctatatactggcattattcaaaacttgacggtaaaaaaacgaat
+tttaaggcgctcacgtcgaatgagccgaactcatgggaaccaaaatgtcacagaaaacac
+ctctttattgccaagcatgcaataaaaaaaatgttaatagtacgtttacgacattttatt
+ttataataaagagaaactattacacctattgatatgataggacgtaaattaacgagtagc
+ctgcatagaggcaaatgaggtttctacatggtatagacctgatgctgaaacatcgatgag
+ttttggtcccctcgctcgttgaaatctagtcatttactactgtctttcgagctattatac
+cacttcactatgtggtgtttctttgctatgtatggggctagtcaaacatgatgactatag
+ctacaactcagagagcgggcgtgttaagagtatctcatgctagaactgcacgacgaactt
+gatacaaagtaacaacatttacgattccacaaggtgactttgaagaaacatagtttaatt
+ctctgcttcgatcatttctataaaccggtaccatcgcagcggatagatgcataacatttc
+tactactccaggcatcttaaaacacacgtagtacttcactagattaagacacgataagtg
+tataacttggcagtgggaagcaaggagattggcgaactcctggcatctgttacgttttgt
+tcaggctcggttgttgataatgtccgactcctgccatattgaagactcgctcgagggaga
+tcgggattcgttgattataagtacacgtgttccgtaatactatgaggcagtgattcaaaa
+tggcacttctgacttacatgactaggtattattaccacggaagcgttaaaggcacactct
+tatggacttaagattgcaagtgccttcttctagcctgaattcgcgggttcaacacaaact
+ctctttagacatccgttgcctaaaggctgagacgtaggggcaaccctttaactatgtact
+aaaaaactagttggtaatttaacaacgtgtccaatcaagacgatgcaccaacgcggtgcg
+aaaatcgggttaagcaaacacaaataggaattgtgataaaccccaccttgagaggtcgca
+agaccaacctcgggaacaacggctctaagagaataacctaaatccggatgagtagactgt
+gtaactctctaaagggaagtgaaaaaaagctaagcatacatttaggtctcctgcattgca
+ttcaattgaatcgtttgtattatgagctgtacagtagctatatcagctatagttatccca
+gaggaacaggtaaactagctctgagcgtgaaatccggatattagaacccctagatgggat
+tgattctagctaatacaggcttatctggttttacagttatctagatgattggtaaggtga
+aacgcttggtgccttccaccacttaaacaaaagtattgcccgggaagctattttctaggt
+attataaagtcgagcattaatatcaatttgacagtaaaggtctttcaccagcttcatatg
+ccatagggcccatactcgatttaaattgaacggtttaacgagtattggaactctcactta
+taactgagtagctatacgaaaaatctggtccatttccagaaatttattatcgatttgctg
+cttagtacccaggaagtgataacccttgaaggcacaacactgtaataagttttcctgtca
+catctgtaatattcggtcactacgcattcacgactaaagataattactatactaattaaa
+agttcaatgttagggccgaatcatagtagaaattctcgtctagcctaatcggacttacct
+atgggctgtgaggatttatcagtatgtggacaaaaatgctagagataggtatagttaaag
+tcaccatggtacatctatgtgaggaagtttgtagttcgcttctttagtccgggcgtttgg
+gatgacaactactatacgtagagccgtactcaggattagatagtgtgaaagagtcaaata
+aaagggttaatattaatttaacgttgcaaatgtgtttaggccaaacattaaccgttgtag
+ggatattctaatacaggccttcaccgaaccctaatgataatctgtcttaataacattaaa
+tgattgtctccgctacgagctcttagggcctcattttaaatgactaatgtccaaagaaga
+gactttcccaatttcaatctgtcacgtatagacggcaccttagtgagtcatatcattaag
+atagaagattatcaggagggaagtttctattatcaaccgttacgcaaccataaactttta
+aatctcataatggcattgagatcaagagctttcatgatggtaaagttcgtatgtgatgct
+ggggagctagatatcggtataccacttcggttgtggtaagcccgagtgggccgttagtaa
+tattaatagacgattatccgacaatgcattcgctgaaataatcttacttaggagaaatta
+atgctatgagccaaaactatttatgtctgtcacattattgactaaagtatctatcgacaa
+aactgatgtccataagttgtagcagatagtcggtgtatggtgtcaccaatgaaaacctcg
+agcgaaaaatgaattatagttatccaatttgagtaaattgcctattatacagataggctt
+gtttagtcagataaggttccgcttgaggtgctctaacttagcgagagttagaaagcctag
+tgagaggcattttggtgccaaactccggctcgcatgagtaggccagagagtcactttctt
+tcgtcgaagaagttggtgaacagccttttgattagttgtttgtcttgtggctatgtgcta
+ctatataagttagaacgcaaactaatctaatcagcaaagtaaaataggaccttgaacgag
+acggggtacgccgttgaggctcgagatagtagataaactagaggaatgtagataaaacat
+tagctagggggtttagttactggattacataggaagtgcaccatcacggtgtgggggttc
+gtacgtaaagtcgcatcaatattgtcagtggacttaacaagttcgtgcataatgaaatcc
+tatacggactttgcatatctctaccgactcatctggtcgtctatgcgggtaattgtattg
+ctccaagtggatgactattttggcgtcccagcacatagtaaatgtaaatccttataatag
+cataagcaattattagactgcgtgaagtcttagtagttctcaagctttacgttgtatgta
+aataactcacgtaatcagccgtccccaaatcaccattgaggtcattgaatgtacggagca
+ctattatcaatgcggtatgcgattttctgagcgattattgttaaagacttagcgttgagc
+cccggaacacttgattacagattctttaaggagttatccaaatatcattttaaataatag
+tagtatcgtgctttggacaataaaaaaagacccgttctcttatgttgttttgcgacgtac
+ttctctgatatatacttcaactatgaagattctattcatcgataacccaggtatatttat
+atgcccgttcactgcgcagggcaaattatctacggacaataatgacgtagttggacccgg
+taagaactaacgcttaatatgattaaggatgtatgccagtattatcttattatgtcagag
+tagaagtttctctgagattttccgtcgttgtggtacaccggatttggctctctttttaga
+actgagaactcggagtgtgtagtcttgtttccttcaatttatcaatatgcttttataccg
+ccctcatcaactataacaggacgacaagttccgtcttgctccatcatatactaccgatac
+accaatcgtatcaagtttagtatacttgctttctctcttctacagcttactcgcttgtcc
+gagaagcggttggtgctcataaagttagtagtaaatgtacaactagtagccagtccttac
+ctgtttttacgactactacggacaccatgagatacagaagttagtgctacaattatacca
+ttacatgctcaatatcgttgtcggccataagatcgaagagtgcatcacgcgtgtgaatac
+gtaaaatctaccatcccgtcaatgcacaaaaacacactccccttgttgactaacatcttt
+tacaagaggctaaatcattgtccaggatcgaataccttgtgtacaatcgtcacccatcgg
+aagaataccacttttccgatgtagtatgatttacaaaaaacatctatgtgagtaggccaa
+ttgtagtagaatatattcatttgaccgtcattagccttcttcttaggttgtgtacggata
+gtaggtacataaaccgtcgtgtggcatacgctgcgatttcatacagctgccaacaccttt
+tttaccaggctagagtcagaaaagttggagccatgttaaatagttaccatcataaaccac
+tgttgtctactagtctgatcagctttcatgcctgtgcaagcaatatggattctcacgtaa
+tggtaacaactgttgcgttacttaggctggttaatttgtcagagtaataaatacatgtct
+tgttgtgtttcctaatcctcggaaagtacacaagcctaggaataggaaaagtaaagctct
+tttattctgatagtgactaactcaggatctaaatacgcgattatactaaccttcaccaaa
+gctcaaaaatcatctgctggtgaccagttatagacagggtaattcaatatttaatgtctc
+ccttaacatttcaccagcatggattgaagatagtataaagttttacatggcagtcattgt
+gtcacggttctatacaaattctgatagttagacggtatttgaaatgtgcttctagcatgg
+tatcttacacaactgaatgaacgactggagccgttcgtatactatttgcgagcctcgaga
+ccccgtttcctaatgttaacgaatatagtataatataaattgtgatatgaataacacaag
+taactacagtttggacaattaattgttctaaactaaaaatcattcacttcagatggcata
+gagttatggctactacacatataaagcggtatgtgaaacacccgttttagccggaaaccc
+tctactgctcgggacaatgaatgatttccaaaatatggatgtgcagaattgttagtgtga
+ctcaggtccaaatagacactttagtttcgtcaagtcgttgcaaagtttaaaaccatcgca
+gcattctttatttggtctacattgagaaatgaaaaaacgtgacagaaagtctagaagaac
+tgtgaataatgtctattactgattaactagtaagacattagtgcatctggtccactgaag
+cacccgcttggcgttaggcaatctctgtgaactgtcgtggctgttccggtaatgtacgaa
+agcaagcctataggttgatcgagtcgcttcattaaggtcaatttcacaatatccgatcac
+attgtgctaggttcgtcctttaccttgcttagtgctgcatgtacggggtgtcatgacttg
+ttatcggcagactctttatcccaagaatggataatatgtacatggaaagtgtccataatt
+aagtcccttcactgtaaagaatgactgccacgtgatccatgaggtctacagaaaccgact
+tacttgctttttgatcaacttaattatggattcataaagttcagatatcggtacaattgg
+tgtacaatatgaaattaatgaggaaacatggaaatctgaatgacagtgatagaaaagatc
+cccatttgcccggtcagttcatgttacaccactcattagtactgtaagtgtttcgtcagc
+attgagatccacgatcatgtgtttatgccttcgaaactggatgtacgacgatcgagacga
+agaggtatatataacctaaatactaggtacgttgttagagagacgatgaaaattaatcgt
+caatacgctggcgaacactgagggggacccaatgctcttctcggtctaaaaaggaatgtg
+tcagaaattggtcagttcaaaagtagaccggatctttgcggagaacaattcacggaacgt
+agcgttgggaaatatcctttctaccacacatcggattttcgccctctcccattatttatt
+gtgttctcacatagaattattgtttagacatccctcgttgtatggagagttgcccgagcg
+taaaggcataatccatataccgccgggtgagtgacctgaaattgtttttagttgggattt
+cgctatggattagcttacacgaagagattctaatggtactataggataattataatgctg
+cgtggcgcagtacaccgttacaaacgtcgttcgcatatgtggctaacacggtgaaaatac
+ctacatcgtatttgcaatttcggtcgtttcatagagcgcattgaattactcaaaaattat
+atatgttgattatttgattagactgcgtggaaagaaggggtactcaagccatttgtaaaa
+gctgcatctcgcttaagtttgagagcttacattagtctatttcagtcttctaggaaatgt
+ctgtgtgagtggttgtcgtccataggtcactggcatatgcgattcatgacatgctaaact
+aagaaagtagattactattaccggcatgcctaatgcgattgcactgctatgaaggtgcgg
+acgtcgcgcccatgtagccctgataataccaatacttacatttggtcagcaattctgaca
+ttatacctagcacccataaatttactcagacttgaggacaggctcttggagtcgatcttc
+tgtttgtatgcatgtgatcatatagatgaataagcgatgcgactagttagggcatagtat
+agatctgtgtatacagttcagctgaacgtccgcgagtggaagtacagctgagatctatcc
+taaaatgcaaccatatcgttcacacatgatatgaacccagggggaaacattgagttcagt
+taaattggcagcgaatcccccaagaagaaggcggagtgacgttgaacgggcttatggttt
+ttcagtacttcctccgtataagttgagcgaaatgtaaacagaataatcgttgtgttaaca
+acattaaaatcgcggaatatgatgagaatacacagtgtgagcatttcacttgtaaaatat
+ctttggtagaacttactttgctttaaatatgttaaaccgatctaataatctacaaaacgg
+tagattttgcctagcacattgcgtccttctctattcagatagaggcaatactcagaaggt
+tttatccaaagcactgtgttgactaacctaagttttagtctaataatcatgattgattat
+aggtgccgtggactacatgactcgtccacaaataatacttagcagatcagcaattggcca
+agcacccgacttttatttaatggttgtgcaatagtccagattcgtattcgggactctttc
+aaataatagtttcctggcatctaagtaagaaaagctcataaggaagcgatattatgacac
+gctcttccgccgctgttttgaaacttgagtattgctcgtccgaaattgagggtcacttca
+aaatttactgagaagacgaagatcgactaaagttaaaatgctagtccacagttggtcaag
+ttgaattcatccacgagttatatagctattttaatttatagtcgagtgtacaaaaaacat
+ccacaataagatttatcttagaataacaacccccgtatcatcgaaatcctccgttatggc
+ctgactcctcgagcttatagcatttgtgctggcgctcttgccaggaacttgctcgcgagg
+tggtgacgagtgagatgatcagtttcattatgatgatacgattttatcgcgactagttaa
+tcatcatagcaagtaaaatttgaattatgtcattatcatgctccattaacaggttattta
+attgatactgacgaaattttttcacaatgggttttctagaatttaatatcagtaattgaa
+gccttcataggggtcctactagtatcctacacgacgcaggtccgcagtatcctggaggga
+cgtgttactgattaaaagggtcaaaggaatgaaggctcacaatgttacctgcttcaccat
+agtgagccgatgagttttacattagtactaaatcccaaatcatactttacgatgaggctt
+gctagcgctaaagagaatacatacaccaccacatagaattgttagcgatgatatcaaata
+gactcctggaagtgtcagggggaaactgttcaatatttcgtccacaggactgaccaggca
+tggaaaagactgacgttggaaactataccatctcacgcccgacgcttcactaattgatga
+tccaaaaaatatagcccggattcctgattagcaaagggttcacagagaaagatattatcg
+acgtatatcccaaaaaacagacgtaatgtgcatcttcgaatcgggatgaatacttgtatc
+ataaaaatgtgacctctagtatacaggttaatgttagtgatacacaatactcgtgggcca
+tgggttctcaaataaaatgtaatattgcgtcgatcactcacccacgtatttggtctaatt
+atgttttatttagtgacaatccaatagataaccggtcctattaagggctatatttttagc
+gaccacgcgtttaaacaaaggattgtatgtagatggtaccagtttaattgccagtgggca
+atcctaagcaaaatgagattctatcctaaagtttgggcttgatataagatttcggatgta
+tgggttttataatcgttggagagctcaatcatgagctaatacatggatttcgctacctca
+ccgagagaccttgcatgaagaattctaaccaaaagtttaataggccggattggattgagt
+taattaagaccttgttcagtcatagtaaaaacccttaaattttaccgattgacaaagtga
+gcagtcgcaataccctatgcgaaacgcctcgatagtgactaggtatacaaggtttttgag
+ttcctttgaaatagttaactaatttaaaattaattaacgacatggaaatcacagaaccta
+atgctttgtaggagttatttatgctgtttactgcctctacaaccctaataaagcagtcct
+aagaatgaaacgcatcttttagttcagaaagtggtatccagggtggtcaatttaataaat
+tcaacatcgggtctcaggatattcggtcatataatttattaagggctcttcgagtcttac
+tctgagtgaaattggaaacagtcatccttttcgttgtgaggcatcttacaccgctatcga
+tatacaatgcattccaccgcggtgtcccgtacacaaggaaacttgttaccttggggatat
+aagaaaactcacacgtctcattattaaactgagtacaatttttgcacgagaaagtaatgc
+aatacaatatgatgaaagccagctaatgaaaagggatggaacgcacctcggatctgttgc
+actggattaaaatccgattatttttaaaaatattcagtgctagagcatatcaggtctact
+tttttatctggtatgtaaagcccacggagcgatagtgagatccttacgactcaacgaaaa
+gttataacataactcccgttagccaaagcccaatcccgattactgccctaccctaacgtc
+tgccatctaaatatcgaacttgttatgatcaatgtgactacctcccaccctttccccttc
+atttgttccactggggataagctagcgttttcagaatcaatgcaataagaatagccaatt
+gtctcacttcatcagagctcttggcaattccaggcgctacgtggttctggaatatattca
+tttttcaaatagtaatacgtttagtgttgctattgtctacacgtttggatattacgttat
+gtgagcggacatcaatagttgtctaactctttagtaagccagagatagcactcttagcga
+atggataccatcttccataagtttagttaatagtccgaaacaactgcttcgagcatattt
+gaacctccttgtaggcaaatagcctcttcaaagcaatcttactaatagatagagtttgtt
+ttaagggactactagaaatgggacaatcttaatagtatgacctaaactgacatttaaaga
+tatatccaggtggcaagcataaagatcattgcgccacctccaccgtgggattacttatca
+gtcgatatcctatatgctaagtttgcgacggcagaatacaaactaagctgagttgatgct
+aaccttacctatgataccccattggaccggttaacagccctacttattccaaataaaaga
+acttttatgctgtagaagctattatagtgatgcctggtaacttcagtatattaaaatgac
+acacatacgccatatagagctcctggaactttgaataatgagcgaacttcgaagttgaag
+agcaagaaaccatatgtcacggttgcctaaagcccggtaaccagacatgtgctatcattg
+atcattatcgaggttttcataaccttgacccattatcggctgtgcgcggacaagtactta
+aatcactagtttcttcacctgcttatcggtaagaaataaggttggcaaagaatcgcataa
+gacggacgtagagccgcagcgttgtgcgagtccaggtgcatgcgcagcaataggatttta
+aattttgttccatttttaatttagccgtaaggatgtccgtaaatgattgaaaattggatt
+caatctttgggcctatgctactggaacctgatcgacaaaatttcaaacatacgttaactc
+cgaaagaccgtatttttgcggctagaatagtcagtcgcttggagccatataccttaccac
+ttaaacgacgtgctcctgtagttgaaatataaacagaacacaaagactaccgatcatatc
+aactgaagatctttgtaactttgaggcgaagcaccctcttcgagacaactaagagtaaag
+taccgggcgccgcaaggagtcgattgggaccctaaatcttgacgaattgctaagaggctc
+agagctaccactgtaatttctctagagcccataataaatgaacgatacatccgtaggtag
+cacctaagggattataatggaagccaaatgcagttaataatattatatactggcgtacac
+gattcgacggatctctcacatagtgattcacgacccccccctttgattgacacagcgtca
+gcattttgcaagaacgatcttctgcatagggtgcgccaccgtaaggatgacgtcgaagct
+acaactgggtataatttaccatgcttccctgatgctgagtgcaatacactaagaatgagt
+ttttaccccatatcaccagtatttgttctgttattgcgaagaaatggctatgctgagttg
+gcgactaaagtcacccatcctttttattaggtaaccccctcccttaaactaactgatttg
+ctggagctgccctgcatacatatactttatcatttatggacgtccgtgacgcttattatc
+caccatagtcgatatgctacacggattcattaatggatcgtaggagtttaagttatattt
+actaagatcggtctcggctactatcccgccttacccggcgctatttacggccatttttaa
+tatattgacggtaattattcctatggtttcgaccgcacgtccttggacaagaaagaatgg
+caaaaaaaatgtaaaagaaaaaaaatattgagtccctaccatcatataaaaaatatgtga
+tgagtaacttgacgaaatgttagtggttattaaagactatctattacaccttttgttttc
+tgtcgtagtatattaaagtctagaagccttacaggaaaatcagggttatacagccgatac
+tccgcagcatgaatcatcgaggaggtgtcctaccatcgcgccttgtaatcttgtctgtgt
+atactgtatttagaccttttatacaaagtaaatatctcggctttatgtgattgggagggg
+cctactcaaacatgatgacttgacctaataatcactgtgcgggcgtcttatgactagcta
+ttccttgaaatccaccaccaaatggttaatatgtaaaaactttgacgatgaaacaaggtg
+aatgtgtagttactttgtgtaattagctgcgtcgagcattgcttgtaaaaccgtcaatcg
+cacacgttacttccataaaatttctacgaatacacccttcttaaaaaaaacgtaggaatt
+cacgagtttaacaaacgataactgtataaagtggaagtccgaagaaagcagatgcccgaa
+ctactcgaagatgtttcgttttcttaaccataggggcttcttaatggcccactacgcaca
+ttttgttcaagcccgagagggacatccccattacgggagtattactaaaactgttccgta
+atacgttcagcaagggatgaaaaaggccactgctcaagttattgacgtgggagtattaca
+tcggaagcctgaatcccacactatgatggtctgtacaggcctagggactgcgtctagacg
+gtattaccggcttctaatcatacgatcgtgagtcttaacgggaagtaaggctcacaccta
+ccccaaaccatttatctatgtaagtataaaattgtgcgtaagtgttcaaagtggacaata
+aagacgtggcaaaaacccccgcacataagccgctttagatttcacaaataccaatgcggt
+taaaaacatccttgagtcgtacatacaccatactcgcgttaaacggatataacagaagat
+aataaatccggatgtggagtcggtgtaactatagaaagccaagtgaaataatgcttacca
+gtcatttagctatacggctttcatttcatgtcaagagggtggagtttgacctgtacagtt
+gatatatcaccgatacttagaactcacctaaagctaaaattgctcgcagcgtgtaatccg
+catattacaaacaatagatgggattcattatacataagacacgatgatctgctttttcag
+gttgcgagatgttgcctatcgtcaatcgagtcctgccttacaccacttaaacaaaagtat
+tgacagggaacctattttcgaggtattatatagtccagcttgaatatcaatttgacagtt
+aacctagtgaaaatcagtaagaggaaatacgccacattctccagtgaaattctacgggtt
+atcgtctagtccaactatcaattataactcacgagatataagtaaattctcgtacttggc
+ctgatttttattatactttggatccttagtaaacaggaagggagaaaccttcaacgaaaa
+acactggattttgttttactctcaaagctcttatatgacggaaataccctgtcaagtctt
+aactttattactagactaatgaaatgggcttggggtggccagaatcatagtacaatttag
+cggatacactattcggactttcctatcggctgtctggttggataagtatggggactaata
+ggctagacatacctatacttaaactatacaggcgtcatctatctctgcaactttggagtt
+ccctgatgttctcccgccctttgggttcacatcttctataccgacacccctaataacgat
+tagtttgtgggttagagtaaattaatacggttaatattaatgtatcgttgaaaagctggt
+gtcgccaataaggtaaccggctaggcagagtatatgtcacgaagtataactaccctaatg
+ataagctgtaggaataaaattaatgctgtctctaagcgaagagatatttccgactctgtt
+ttaatgacgaatctcattacttctgacttgcaaatgttcaatatggcacggtttcacggc
+acctttgtgacgcatataatgaacttagaagattataacgacggaactttatatgataat
+ccgttacgattaaagaatctgttaaatatcataatggcattcagttctagaccgtgcatc
+atggtaaacttactttctctgcatggcgacatacatttcgctattcaaattcgcgtgtgg
+ttacacccactcgcacctttggaatattaagagaagatgatcagaaaatccattcgctca
+atttttctgacgtacgtctaatttatcctaggagacaaatcgttttatgtctctcacatt
+tttgaagaaaggttcgagagacaatactcaggtcctgaactgctagaagatactcggtgg
+agcgtggcaacaatgaaaaactcgtgacataaatgaatgatacttttccaagttcagtta
+agtgaatatgtttaacatacccggcttttcgatcttaagctgacgctggacgtgcgagta
+atgtcagtctcttacatacactagtgactccaagtttcgtcaaaaacgccccctcccttc
+tcgagcccactcacgctatgtattgacgcgaacttgttcgggatcagacttttcaggagt
+tcggtcgcgtgtccctatgtgctaatatataagttagatcgcattagatgctaatctgaa
+tacttatagacgaccttcaacgagaacgggtaccaccttgaggctagagttaggtgtgaa
+acgacaggtagggacatataaaatttgagtgcggctttagttaagggtttaattacctac
+tcaaacatcacgctcgcgcccttcgtacgtaatcgaccatctagaggctaaggggactgt
+actaggtagtgattaatgatatcctagacgcacgtgccttagatcttcagactctgatgg
+tccgcgatcaccgtaattgtagtcctccaactcgatcactttgttggcgtcaaagaaatt
+acgatatctaaatacttataatacaataaccaaggatgagaatgactcatcgcgttggag
+ttatattgcttgaagttctatggaatgaaagcacgttatctgccgtcccaatatctccag
+tgagctaattcattggacggtccactttgatcaatccccgaggagatgttcggacacttt
+agtctgtaacacttagcgttgagaccacgaacaattgattactcagtcttgaaggtgttt
+tccaaagttcattttaaataagactacgataggcctttcctattgatataaactacccgg
+ctctgttgttcgtgtgagtcgtacttctctgtgtttttctgattatagcaagattcgatt
+cttagtgtaaacagcgatttttatttgacccgtcaatgagaagcgcataggatctaagca
+aaattatcaagttgtgccacaaggtaagatctttccagttattgcaggtaggatgtatcc
+cacgttgatagtatgaggtctgacgtcaactgtctaggagagttgaccgcgtgcgggtac
+accggatttgcatcgatgttgagaacgcagaactcccactgtcgtggcggcgttcctgat
+atttagcaagaggcgttgataaagccctcatcatctagatctcgacctcatctgccctct
+tgctccatcattttctacacagactactttcctatctacgttagtataattgctttctat
+cttagtatcatttagagcttctccgtcaacaggttcgtgctattaaagttagtacgaaag
+ggacaacttgtagcaacgcatttaatcggttttcgactacttcgcacaaaatcagataaa
+gaagtttgtcattctattagacattgaattgcgcaattgacttgtaccacttatgatcga
+acactgaatcaagactgtgattaactaaaatagacaagccactatatcaactaataaaaa
+cgcccctggtggtcgaacatagttgactacaggataattaattggactggagccattaca
+ttctctacaatcgtatcacttcccaagtagacaactttgaccttgtagtttcatgtacaa
+aaaaatgctttcgcaggagcacattggtagttcaatagtttcatgggaacctcttgagcc
+gtcttctgtgggtgtgttcggatagtaggtactgataaagtcgtgtcgctttcgatgaga
+gggaattcaccggaaaacaccttggttaacaggatagtctatgtaaacttcgagacatgt
+ttaagagttaccagcttaatccacggtgctctactagtatcatcagctgtcttgcctcgc
+ctagaaatatgcattctatcgttatcctatcaacggttgccgtactgagcagccttattg
+tggaagagtaatatataaatgtagtcttgtctttacgaagcagacgtaagtaataatgac
+ttggaataccaaaactaaacatagtggattatcatactcaagaactctccagataaataa
+cagtttttacgatacgtcaccaatgagcttaaagattaggatcctcaaaactgatacaaa
+cgctaattcatttgttattggatccagtatcagttaaactgaatggagtgaagattgtag
+aatgttgttctggcctcgcatggggtctaggtgatatacaatttctcatacttacacggt
+agtggaaatctgattctagcttcgtagctgactatactcaaggaaccactgctcaaggta
+ggagactagttccgaccctacagtcaaagtggccgaagcttaaactatagactagttgtt
+aaatgctgatttcaagatatcatctatatacagtttggacaattatgtgtgcgaaactaa
+aattcatgctattcagatggatttcacttatgccttagaaacagatattgcccgagctca
+atcaacagttttagccggaaacaatcgaagcatagggacaatgtatcttttcctaaattg
+ccatgtgcagatttctgagtgtcacgaagcgcataatagaatcttgtgttgcctcaactc
+gttgaaaagtttaaaacaatcgcagcagtctttttggggtctactgtgtgtttgcaaaat
+aactgaaagaaacgcttgaacaactctgaagtagctcgagtactcattaaagtgtaacac
+attagtgaatatcggccaatgaaccaaacgcttcccggtacgctatctctctcatcggga
+ggcgatgtgcaggttatctacgaaagcatccctttacgttgagagtgtcgatgcatgaac
+ctcattgtaacaatagcccagcaaattctcatacgtgcctcagggtccgggcgtactcct
+ccatggaagggcgcgcatctagtgttataccaactcgctttttaactactatgctgtagt
+tctacaggcatagtggccagtattttctaacttctctggatagatgctctcactcctcat
+ccatcacggcttcagtttacgtcttacttgcttgttcagcaacggatggaggcattaagt
+atcttcactgttccctaaaattgctgttcaatatcaaagtaaggacgatacagggaaagc
+tcaagcacactcattgaatactgccccagttgcaacctcacttaatctgacaaaaataat
+gactactctaagtgttgcggaagcagtctcttccacgagcttgtctgtatcacttcgtat
+aggcatgtaactcgatagacacgaacaccgagtgagaaactatattcttgcttccgtgtg
+tgtgacaccaggtaattgatgcggatataagctggagatcactcacgcccacacaaggcg
+ctgctacctctttattccaatgtgtaagaatttgctaacttcatttctagaccgcagctt
+tgcggtcataatttcacggtacggacccttgggttagagacttgataacacacttcgcag
+tttccaccgcgcacatgttttagtggcttctaacatagaatttttgttgtgacataaaga
+gtgcgtgggagacttgcccgaccgttaagccataatcaattgaaagccccgtgagtcaca
+tctaattggttgtactgcgcatttagctatcctttagctgactcgaagagattcgattcc
+taatataggttaattagatggctgccgcgcgaagtaaaacgtgaaaaacgtagtgcgcag
+atctgcataactcgcgcttaattacttatgagtagttccaagttcgctacgttatgagag
+agattggaattaagcaaatatgttttatggtgattttgggatgagaaggactgctaagta
+cggctactaaacaaatttctaaaaccgccatctaccttatcttggagacatttaagttgt
+atatgtcactagtctagcttttgtctgtgggacgcgttctcggaatgagggaaatgcaag
+agccgattcatcaaatgcttatctaagaaagtagtggactattacaccaagcacgaatgc
+cagggaactgctttcttgctcaggacctcgcgacaaggtaccccgcataagtcctagaat
+tacatttggtcagcaatgctgacatttgaccgtgaaaacataattttaatcagaaggcag
+ctcacccgcttgctctagatcttatctttgtatgaatgtcagaatttactgcaatatccg
+ttccgaatagtgagggcttagtatagttctctgtatacaggtcacatcaaactccccctg
+tcctagtacagctctgagctttaattaattgcatacatttccttcaatcatcagatgaaa
+acaccgcgaatcatgctcttctcgtatagggcaagagaagcaacaaacaactagcccgac
+tcacgttcatccgccgtatccttgttcagttcttactccgtattaggtcagcgaaatcta
+atcagaataatcggtcgcgtatcaaaattaaaatcccgcttgaggttgacaattaaaacg
+ctgagcagttatcggctattagatagtggggtgaaagtaattggctggaattatgttaaa
+acgtgatattaagctaaaatacgctacttgttgccgacctaattcagtcattcgatattc
+agttagagccaagaataacaagcttgtataaattgaacggggtgcactaaacgatgtgtt
+actctaatattcagcttggagtatacctgaaggcgaattcatgtatcggccaataataag
+acgttgaagatcacaatttggactagcaaaagaaggtgatttatgcgtggggattgagtc
+cactgtacgagtacggtctctggaaaattataggttcagggaatataaggaagtaaagat
+aattaccaagagatttttggtatcgctatgacccagaggtgttctaacgtctgttttgat
+ccgcagaatttctgcctcaatgcatatttgacggacttgaactagagcctctaaagttaa
+atggcgacgcaactgttcctaaacttcaattattactactctttttttcctagggtattg
+tagaggccagtggacaaaataaatcaaatttaagatgtttcggacattaacatcccccgt
+agcatagaaatcatcagttatccaatctctcatcgagcttttacaatttctgctggcgct
+atggacagcatatgccgcgagacctccgcaagactcacttgatcactgtaagtatcttca
+ttagaggttagagcctatagttaagctgctgacctagtaaaattggtattttctaatttt
+attgctcaagttaaaggttagtgaagggataatgacgttatttttgaacaatgggttgta
+ttcaattttatatcacgaatggaacccttcattcccggcataatactagacgacacgaac
+aagctccgatctatcagccaggcacgtgttaaggtttaattccggcaaaccaatgaagca
+tcaaaaggtgacctgatgcaacttagggtcacgatgagtttttcaggactacttattacc
+tattaataagttaacatgagccttcataccccgtaagacaatacatactccaccaattag
+aattctgagccatcttatctttttgtatcatcgaagggtatggccgaataggttaattag
+ttactcctaacgtctctacaggcatgcatttgacgcaccttcgaaaatagtcaatctctc
+gccacacgcgtctagtatgcagcatcaaaaatatagtccacggtttccggattaccaaac
+gcggcaaagagaaacattgtatcgacggagataacttaatacagaaggaaggggcatctt
+cgaatacggatgaataattctatctgtttattctgacatcttgttttcaggttaatctta
+cgcattcaaatgacgcctgccccatgcgtgcgcaattattttctaatattgacgagagca
+atctcactccttttgggtctatttatgttttattgaggcacaagcctatacagaacaggt
+actattaaggccgtgagtgtgagactcaaaccgtggaaacaaaggatgggttgttcttgg
+tacaagttttagtgcatgtgggcaatccttaccaaaatcagatgctatccttaactttgg
+gctgcatttaagatggcggttggaggcctgtgagaatcctgcgtgtcatctttaatgacc
+gaattcatccatgtagattcagatcacacactcattccttgatgttgtctaaacaaaagt
+tgttgtggacgcattggagggagttaagtaacaacttgggatcgcatacttataaaaatt
+atatgttaaactttcacaaacgctgaagtccaaagtaactagcccaaacgcctcgagagt
+cactaggtattaatggtgtttgagttcctgtgaaatagtgttcgaaggtaaaatttatgt
+accaaatcgaaagaacacttaataaggcttgcttgcacggaggtatgatgtttactgact
+ctacaaccctaattttccagtacgtacattcattccaataggttagttctcaaagtgcta
+tacaggctcctcaattgatgatatgcttcagccgctctatggatattagctcattttatt
+taggaagcccgcttagaggcttactatgagggaaatgccaaaatgtcatacttttcggtg
+tgtcccatatgacaccgctttacatagaatttgaattaaaacgcgctctcccgttcacta
+ccatacttggtaccgtgcgcatattacatatagatataggatcattttttaaagctgtac
+taggtttgatcgacaatcttatgctatactatatgatgtaaccctcataatcaataccga
+tcgtacgatcctagcataggtggcaagcgattttatgccgattattgtgttaaatagtct
+gtgagtgtgattatcagggctacgttggtagaggggttgtatagacctcgcacacattgt
+gacatacttaacaatatacgaaaactgatataataaatccccttacccaaacaccaatcc
+cgttgaatcaactaccataacgtctcccatataaattgcctacttgtttgcataaatctg
+aatacataacaccattgcaccttcttgtgttccaatcccgttaagattgccttgtcagat
+gatatgcaagaacaatagcatttgctagcaattattaacagctcttcgaattgcctccac
+ataacgcgggagggtatattttaatttggcaaatactaagtactgttggcgtcatatgct
+attaacggttggatattaagttatgtcagccgtaagcaagagtgggcgaaatattttgtt
+acccagtgagagcactcttagagtttggatacaataggccatatgttgacttaagaggac
+gtaactacgccgtacaccattgttcaaccgacttcttggcaaatagaatcgtattagcaa
+tcttaagaatagagacacgttcgtgttagggtatactacaaatccgaaaatcttaagagg
+atcacctaaactgaaatttatacatatttcaacgtggatagatttaacataattcagcca
+cctccaacctgggagtaattttcagtagatttactagatgattagtggcccaacgcactt
+gactatataagatctggggatcctaacctgacctatgagacaaaattggaaacgttaaca
+gcccttatgtgtacaaagaaaagtaagttgttgctgttcaacagatgatagtcatgacgc
+gtaacttcactatagtaaattgaaacaaatacgcaatttagacagaatggtacggtcatg
+aatgacagtaattcgaagtgctagaccaacttaaaataggtaaacgtgcccgaaaccccc
+cttaacagaaagctgctatcatggtgcagtatcgacgtgttcagaaacttgtaacttttg
+agcaggtccgagcacatggaagtatatcacgtgtttctgaaccggcttatccctaagata
+tatccgtcgcaaactttcgatttagtcccacgtagagcccaagcgttgtgcgactccacg
+tgcatgcccagaaatacgagtttaaatttggttacatggttaattttgaccgaagcatcg
+cactttatgattgataattggattcaatatgtcgccctatgcgaatgcaacatgatccac
+aatttggctataagacgtttaatccgtatcacactttgtttgcggctagtatagtaacgc
+ccgtgcaccaagagtcagtaacaattataagtactccgcaggtacttcaaatataaaaac
+taatcaaacacgacccatatgatcatctgaagatatttggaactttctcgacaaccaccc
+tcgtactcaatacttacactaatcgacaggcacacgcaacgtgtacagtcgcaccatatt
+gagtcaagatttgcttagtggcgatgagcgtacacgcttatttctctagtcacaattagt
+tatctacgagacatcacgagggagcaaataagcgatgttatggctacacataggcacgta
+tgaatatgatataagccagttaaacagtcgaaccatcgagcaaattctcatgcaccaacc
+cacacgttgaggcacaaagagtaagctgtttgaatgtaacttcttctgctgagcgggccc
+caacgtaaggatcaactagaagagaaaactcggtattagtttaaatgcgtcacggagcat
+gagtgcatttcactaagaatgtctgtgtaaccaatataacatctatttgttatctgattg
+cctacttatggctttgcggtcgtggcgactaatgtctccaatccttttgaggtcggtacc
+aactccctttaaattacgctgtgcaggctcatgcactgcatacatatacggtagcaggta
+gggacctcacgcacccttattataatcaatagtagttatcagtcaacgaggcaggaatgc
+tgaggtcgaggtgttggtatattttctatgtgccgtctaggcgactatcacgcattacca
+ggcgagatttaagccaattttgaatatagtcaacgtaatttttactatgggttccaccga
+aacgccttgcacaactaagaatcccataaaatatcgatatcaaataaaagattgtgtcaa
+taccttcatatatattttttcggttgactaacgtgaactaaggttaggggttttgtatgt
+ctatataggaaacagtttcttttctgtcctactttagtaaagtcttcaagccttactcca
+aaatcacggtgattaagccgttactcagcagcatgattctgcctgctcgggtcctaaaat
+ccagccttgtaagagtcgctgtgtattagctagggagacctttgttaaaaaggatatatc
+gcggcgggatgtgagtgcgtggcgcatactcaatcttcagctcgtgtcattataatatct
+ctcccccacgcttttcactagatatgccgtgtaagcaaacaccttatgcttaatttcgaa
+aatattggtacttgaaaaaagctgtaggggtacttaatgtctggtaggagatcaggagag
+aattgagtgtaaaaccgtaaagccctcacctgacttcatgtaaatggcttagaagactcc
+atgatttaataaatactacgaaggaaagactggatctaaagataactctagtaaggccaa
+ctcccttcaatgctgttgccagttataatccaagagctgtccttttctgaaccatagcgg
+cttctgaagcgaactagaagcaaagttggttctagccagacagccacataccctgtacgg
+gtgtattactaaaactggtccggtattagttcaccaagggaggaattaggcaaaggatct
+aggtatgcaagtcggagtattacatccctaccctgaatccatcaataggttcctctgtac
+tggccttcgcaatgagtattcaaggttgtacagccgtataataataagatagtgactatg
+aacgggaagtaacccgctcaccttccccaaaacattgttatatctaagtattaaagtctg
+ccgtagtgttaatactcgaaaataaacaactggcaaattacaccgcacttaagccgcttt
+tgatttatatttttccaatgcgcttttaaaaataattcagtcctacatactaattaagac
+ccttaaacggagatatcacaagttaagttttaaccatctcgactaggtggaactatagat
+acccaactcaatttatcattacctgtaatgttcctagaaggattgcatttcatgtcaaga
+cggtggagtttcacagcgaaacttcagtgtgaacagattctgagaaatcacctaaaccta
+ttagtcagagcacccggttagaaccagttgtcaaaaaatagagcggttgcatgagacaga
+agtaacgatgagatccgttgtaacgttgagacatctggcctatcgtcaatacagtcctcc
+cttaaaaatatttttaaatactaggcaaacccaacataggttagtcctatgtgatacgcc
+acatggtatatcattttgtaacgttacctagggataatcaggaagtggaattacgcaaaa
+gtagacagtgaaatgcttagggttatagtctagtccaaagataaaggataaagcacgtca
+gagaactatattagccgaatgggaatcattgttaggagactgtggatcatgtctaaaaag
+caacgcagaaacagtcatcgaaaaaatctcgtttttgtttgaatctaaaagagctttgat
+gaccgatagtacctgtatactagttactgtattacgtgtctaatgatttcggattggggt
+ccccagaatcagacgtcattgtagacgattcaagtttaccaatttaatttcccagctctc
+cttggagaactatcgccaataattgcagtcactttccttttctgaaacgataaagccgtc
+agagttctctgcaacgttggacttacctgaggttctaacccactttcggttctaatagta
+gttaacgacacaacgaataacctttactgtggggctttcacgatattttttcgcttatta
+ttaatggttacgtcataagctggtgtccaaattaaggttaccggcttcgcagagtagttg
+tatccaagtataacttccctaatcataagatcgaggtagaaaattaatgctgtctctaac
+cgaacagatatgtcccactatgtggtatggacgttgctaattacttctgaagggaaattg
+gtcattatggatacgtgtctaccatcaggtcggacgcagatatggttctgtcttcagttg
+atccaccgttctttataggataataactgacgattaaagattatggtaaatagattaagc
+caattctcttcttgtcagtgaagcatccttaactgacttgctctgcagcccctcatacat
+ttagctattcaaagtaccggctcgtttcaaactctcccacctttggaagaggttgtcaac
+ttgataagtatatcatttacagcattttttcggacgtacctctaatgtttcattgcagaa
+aattagttttttctatcgcacattttgcaagtaacgttagagacacaattatctgcgaat
+gaactgctagatctgacgaccgggagcctcgcaaatatcaaaaaagactgacatatatca
+aggagtcgttgacaagtgctggtaagtcaattggtttatctgtcccggcgtttcgatctt
+aagctgaccatgcacggcagagtaatgtcactctcgttcttacaagtctgtctccaaggg
+tcggcaaaaaagacccctccattctcgagcccactcacgatatgtagggacgacaacttg
+tgcggcttatgaattgtctggactgcgggcgagggtccatatctccgaagttagaaggga
+catacctttagatgataagatcaattcttattgacgaaattcatccacaacggggaacaa
+cttcaccctagacttacgtctgaaaagacacctagcgtcttataaaaggtcagtgccccg
+tttcgtaaggctggaattacctacgcaaacttaaacctcgcgcccttccttacgtatcga
+caagatagaggctatcgcgaatgtactacggaggcatgaatcatatactagaaccaagtg
+cctgtgatattaacaagatgatccgacgcgagcaccgtaattctaggcataaaactccag
+caatttgggggccgaaaacaaatgacgttagctaattaattatatgacatgatcaaagga
+ggtcaatcacgcatcgagttcgacgtatattcattgaacttcgtgcgtttgaaagaaact
+tttatgaaggcaaaattgatcctgtctcctatttcatgcgtacctcctagttgataattc
+cccgagcagtggttaggacacttttgtcggtatcaagttccggtctcaaaacgtaaaatt
+ctgtaatctgtatggatggtctgtgaattagttaatttttatgaagtcgtcgagacgcag
+ttcctattgatttattctaaacggagatgtgcttcgtgggactcggaagtagatctgtgt
+ttatgattattgctactttagatgctgactgttaactccgtgttgtttttcaaccgtata
+tcacaaccgaattggatagaacctatagtttcaagttctgccacaaggtatcatatttac
+agttagtgctggttgcttctttcaaacgtggtgagtttgtgctatcacgtcaacggtaga
+gctcagtggaccgagtgcgcgttcaaccctgttccagagagggtgtgatagcacatatac
+cacgctcgtcgaggcgttcatgatagtttgcaagagccggtgttaaacacatattattat
+tgttatccaactaatcggacctatgcataaagcattgtctaaacagaataattgcctata
+tacggtagttttagtgatttatatcttagtatcagttagagcttcgaactcttcaggttc
+ctcatatttaacgttcttcgaaagcgaaaacttctacaaacgaatgtaagcggttttcca
+agtagtacctataaatcacagaaagatctgtctcagtatagttgaaatggtattcagcta
+gtgacgtgtaccaattatcatagttcactcaagcaagacgctcattaacgaatatagaca
+agacactatatcatataataaaaaagaacatggtgctcgaacatagttgaattcaccata
+ttgaaggggaatgctgacatgtaattcgctactagacgatcaattccctacttgtcaaag
+ttgaactggtacgttcttggaattaaatatgattgcgctggaccaaattgcgacttcttg
+agtttcagggcaaacgattgagccggaggatgtccgtctcttacctttcttgcttatgat
+aaacgacggtccctgtacatcactgggaattctcagcaaaaataattgggtaaatcgaga
+ctcgatgtattcggccacaaaggtgttagacgttaaagattattcaacggggcgataata
+ggatcataaccggtatgcaagcgcattgaaagagccatgagatccttatccgataaacgc
+tgcacggtatgtgcagccttattgtcgatcacgaatttataaatgtagtctgggctgtaa
+gttgaagacctaagttataatgaagtgcaataccaaatcgattcatagtggattatcaga
+ctcaagatatctcctgataaattacagttgttaagatacggataaaatgagatttaagat
+tagcagcctctaatctgtttcaatcccgttggaatgtggtatgcgatcaaggttaagtta
+aaatcaagcctgtcttcagtcttgattcttgttctgccatcgcatgcggtctacgtgagt
+taatatgtagcttacgttctagcttgtgctaatctgagtatagattcgtagaggaatatt
+atcaagcttccacgcctcaacgtacgtgtattggtcacacaagacactaaaagtggaagt
+agcgtaaactatagtctagttgttaaatgctcagttcttgttatattcgatatactcttg
+gctaatttatgtctgagtatataaaattaatgatattaacttgcatttcacggatccctt
+agaaaaagattttgaccgagcgcattataaacggttacaccgaatcaatagaagcatacc
+caatagctttctttgaatttattgcctgcgcaacttggctgactctctagatccgaataa
+ttctatatggtcgtgacgaaactagttcattactgtttaaaatgccaacatgtcttttgg
+gccgataatggctctttgcaaaattactcaatgatacgattgatcaaagcggtagttgct
+agtggtagcatgtaagtctatcaaatgtctgattatccgaaaatcttccaaaagagtcca
+cgtaccatatctatctcatagcgacgcgaggggaaccttatctaactatcattccattta
+ccgggtgactctcgatgcaggatccgattgggataaattgcccagaaatggctcattcct
+gactaagggtaaggccgttctcagcaagggaaccccgcgaatctaggcttataccatcta
+gattgttaactacttgcctgtagttctacagccatactggacagttgtttctaaatgatc
+gggattcatgctagcactcctctgaatgcaccgcgtaagtttaactattacgtccgtggg
+cagataaggatggaggctgtatgtatcttaactgttacctaatatggctggtaattatca
+aagtaaggaccttaatgccatagcgctagcaatcgctttgtatactgaccatgtgccaac
+ctctcttaatctgtaaaatataatgtcttagctaactgtggacgatcatgtctctgccta
+gagcttcgctgtatcaattcctatagccagcgtactagtgacacaacaacaccgtgtgag
+aaaagatattagtccttacgtctgtctctctacagcttattgatgaggattgaacatgga
+catatagctccccctcaaaagcagatgctacctctttattccattctcgaacatttgccg
+aacttaatttcgacaaacctgaggtcacgtcttaatttatcggtaacgtcacgtcccttt
+gagactggataaatatattaccaggggccaacgagcaattgttggaggcgcttctataat
+acaaggtgtcttgtcaaagaaagacggcgtgcgtctcgtgcaactcacttaaccaatatt
+aatgtgaaacccccctctctcacatcttatgcggtgtactgccctggtacatttcctgta
+caggactccaacagtgtagattcctaagatagctgttggagttgcctcacgccagatcga
+aaaactgaataaactagtgagctgagctgcagaaataccgcttaattacttatgactagt
+tcaaagggacctacgtgatgtcagacattgcaaggaagaaattaggtttgtgcgtcattt
+tggctggactagcactccttacttcccctactattcaaatgtcgtaaacagcatgagaca
+ggatcgtgctgacatttaaggtctattgggaacgaggctacctttggtcgcgcgctcgcg
+ttctccgaatgaccgaaatgcatgagcacagtatgcaattgcttatagatctaaggtctg
+gtcgttgaaaccaagcacgtaggcctgggaaatcagttcttcctcagcaactacacaaaa
+gcgtccaagcattagtacttgtagtaaatgtccgaacctatgcgctcatttgaaagtcaa
+aaaatatttttaagcagtaggcacctaacccgattcctctacttagtagctttctttgat
+tctcagaattgactgcaatatcactgcacaattctgtgccattactagacttctctgtat
+taacgtctcatcttactaacactcgcctaggacacatctgagagtgaagtatttcaatac
+atttactgaaatcttcagttctaaaatccccgaataaggctcttatcggtttggccaaca
+caagaaaaaaacttcttgcaccactcaccttcatacgcaggagcctggggaacttagtaa
+taactatttcggcagacaaagcttataacaagttgccggcgcgtataatatttaaaagac
+cccttgagctgctcaattaaaacgctcacctggtataggctattagatagtgccgtctta
+gtaaggggcgggaattatcggataaactgatattttgataaaataaccgacttgttcacg
+acataagtcactaaggagattttatctttctccaaagtatatcttccttggataatttca
+aagcgctgcaatttaagttctgttactagtttatgctgctgggaggtgaccggaaggcgt
+agtaatctagaggcaaattataagaagttcatcatatcattttcgactacaaaaacaagg
+tgttgtatgccggcgcattgtgtaaactggacgagtaccctagatggaaaattatacgtt
+aagccaagatttcgatgtaatgataattacctacacatttttgctatccataggaacaag
+agctgttctataggctcgtggcatacgaacatttgctgccgctatgaatattggaagctc
+ttcaactacagactctattcttaattgccgtcgaaaatgggccgaatcggctattattaa
+tactcggtttttccgaggggattgttgtcgacagtcgtaattattattaatattgatgtt
+ggtgaggtcatttaaatacaaccttgcagacaatgaataagggatccaatctctcatact
+ccttttacaattgctcatgcccctatgcaaaccttatgccgccacacctccgcaactctc
+tcttctgaactgtaagtagcttcattactggtttgagactatactgaagctgatgacatt
+ctaaaatggctattttcgaatgtgattcataatgtttatcgtttgggatggcagaatcac
+gttatttttgatatagcccgggtattctattgtatagaacgtatgctacaagtcattccc
+cgaagaagactagaagtaaacaacatgcgaccatcgttaagccacgcaaggctgtagctt
+tatttcccgataacctatcttccataaatagcggacagcaggatactgacgctcaacatc
+agtggttatggtctaatttttaacttttaataaggtaacttcagcaggcatacacagtaa
+ctctttaatttataatcaaattagaagtctgacacttcttatatttttctatcatccaac
+gcgatcgcccattagcttattgtgttactaataacgtatctaaaccaatccttttcaagc
+tactgcctatattgtcaatatatacaaacaacaggatagtaggctgcttaaaaaatattg
+tcaaccgtgtacgctttacaatacccggaaatcacaaactttgtagacaacgagtgaaat
+ttatacactacgaagggccagcgtacaagacccatgaattaggcgatatgtttattctga
+catattggtttatccttaatctgtcgctgtaaaatgaagccgcccccatccctgcgaatt
+ttttttcgaagattcacgactgaaatataaatacgtttggctatatttatgttggaggga
+ggcaatagcctttactgttaaccgaagatttagccagtgagtgtgacactaaaacactgg
+aataaatgcaggcgttcttctgggtaaaaggtttagtcaatctcgcctataagttcatat
+agctctggatataattatctggcccatgcatttatcatggcgcttggtgccctgtgtgaa
+gccggcctctcatattgaaggtccgaagtattccatgtacattaagatcactctctcatt
+catgcatcttggcttaacaaatctggttgtccaagctttccaggcacgtatggtacaaat
+tcggatcgaatacttataaaaatgatatgttaaactgtctaaaacgctcatctacaaagt
+aaagtgcactaaccaatagagtctcaagaccgtgtaatgctggtgcactgaatgtgtaat
+acggttagaagggattagttatgttacaaatccattgaaaacttaagaagcattgcgtgc
+tcggagggtgcatcttttatcaagagactaacattattttcaacgacgtacatgctttac
+aatagggtacttatcaaacgccgagaaacgcgcctatagtgatgttatgattatgacccg
+atatccattggaccgaattttatgtaggttcccagcgtactcgcgtaatatctcggtatt
+gccataatgtaatacttgtcggtctctcccagatgaaaaagcgttacagagtatttcaat
+gaaaaacagcgcgcaacgtcaatacctttaggggtaacggccgctgatttcatatagata
+tacgataagttggtatagctctactaggtggcatccacaatcgttgcatttactatagct
+ggttacaatcataatctataccgttccttacatactaccatagcgggatagcgttttttt
+gccgttgattgggtttaagaggatgtcagtctcattatatccgattcggtgggagagccg
+ttgttttcaaatcgcacactttgtgacataatgtacaagataacaaaactgatataagat
+ataaactgtcaatatcaccttgacacttgaatcaaagtaaattaactcgcaaatataatt
+tgactaattgggtgcagatttctcaattaataaaaaaatggcaccggatgggcttacaag
+ccccttatcattcacttgtatcatgatttccaagaacaatagaatttgctagcaagtatg
+aacagagattcgaattgcatccacagtacgccggagcgtttattttaatgtggatatgac
+gatgtactgttggcggcatttgctagtaaccggtccttatttacgtagcgcacacgtaag
+catgtctgggagaaatatggtggtacaatctcagagaaagattacagtttggtttaaata
+ggacttatcgggtcggaagtggaacttaataagcagtacacaattgggcaacagacgtct
+tgcctattacaataggattacaatgcgttagatttcagacacgttcgtgtttggctattc
+gtcaattccctaaatagttagacgatcaactattatcaaagtgattctttgttcatcctc
+cattcatgtaacagatggcacactacgcataacgccgaggaattttaacgagatttaaga
+gagcagttcgggcacaacccacttgactttataacagctcggcagcataaacggtaatat
+gtgacaaatttccaaacgttataagaacgtatgtgtacttagaaaactaagtggttcatg
+ttcaacagatgtgacgcagcaagcctaacttatctattggttttgctataaaagaacaaa
+gttacacagaatcctaagggcttgtttcacacttatgcctagtgcttcaccatcttaaaa
+tagcgaaaccggcacgaatcaaaccttaaaacaatgcgcagatattggtgatggtgactc
+cgggtatgataatggtaactgttgaccagcgcccacctcatcgaagtatagaaagtggtt
+aggataaggatgagaccgaacttatttccggccataactttagattttctacctagtaca
+caacatcagggcggacacgaaaccgccatcacatcatataccaggtttaatttgcttaat
+gggggaagtgtcaacgaaccttcgaactttagcaggcatatggccattatatatggcccc
+agagcagaatgctacagcagacaaaatttggatttatgtagtttaatacctatcaaactt
+ggtgtgaccatacttgtctaacgacagtgcacaaagtgtaagttacaattattactactc
+agcagcttctgcaatgataaaatcttatcatacacgtcacatatgataatatctacttag
+ggggaacgggctccacaacctacatagtactcaatacttacactattcgacaggcacacc
+aaacctgtacagtcccaaaagattgagtcaactttgcagtactgcagatcacagtaatag
+cttagttagcgagtcaaaattagttttctacgagactgcacgaccgtgcaaatttccgat
+gtgttggctacaaatagcaacgtatgaatttgtttgaagccacgtaaactgtacaacctt
+agagataagtctcaggctactaaaaacacgttgtggcactaacaggatcatggttgattc
+ttacttattcggctgaccggcccaataagtaaccttcaactagaacagaataatcgggag
+tagtttaattcagtcaaggtgcaggtctcattgtaactaacaagctctgtgtaaccaagt
+taaaatcgttttcttagcggattccctacttatggatttgagctcgtccacaatattcga
+tacaagaagtttgtggtccgtaacaacgaaattttaattacgctgtgcagcctcatccaa
+ggaattaatagaaggttgatggtaggctccgaacgctccatgattataatcaagtggact
+gtgcagtaaacgaggaaggtatcctgacgtcgtggtgttcgtttttgttatttgtgccct
+atacgagtagataaaccatgaacagcacagtgtgaacccatggttgattttaggctacct
+tatttttaatttccgttacacagaaacgaattccacaactaacatgccattaatttttcg
+atatcttataaaagatggtcgaaattcattcatttattttttttcggttctcgaaagtca
+actaagctgtcgcgttttgtttctctttagaggtaaaagtggctttgatctcctacgttt
+ggatactagtcaaccattactccatttgatccgtgagtatcacctgtctaacatccagca
+ttatgactcctcggcgaagaaaagacacacttcttagagtcgatgtgtattagctaggga
+cacagttgtttaatacgatagtgagcccagggagggcagtgcgtcccccagtagatttat
+tcagctagtgtaagtataagatatctcacccacgaggttcaagtgatatgcagtcttaga
+ataatacttatcctgaatttcgatattatgggtacttcaataatccgctagcgctacttt
+atgtctcgttggacagcaggacacatggcagtcttaaacactaaagacatcacctgaatg
+aatgtaatgggattacaagaatcaatgaggtattatatacgacgtaggaaactctggata
+tatacagtaatctagttacgccatcgcacttcattcctctggaaacttagaagacatcag
+ctgtacgtggaggaaccagacccccgtatgtagccaaatagaaccaaagttgcttataca
+aacacacccaatgacaatggaccgctggagttcgtaaactcggaacgtagtactgcacaa
+acccagcatttagcaataggagctacgtatgcaactcccacgtggtaataccttcaagct
+atcaatatataggtgcctagctaatcgcattcgcaagcagtattcaagcttgtaaaccag
+tataataattacagaggctctatgaaacccaactttccagctaaaagtcccaattaaatg
+gttatttcgtacttttaaagtcgcccgttctgttattacgcgaattgattctactccaaa
+attaaacacaaattatcaaccgtttcatttatatttgtcaatgcagctgtttaaaataag
+gctctactaaattataattaagacacttattaccagatttctctagttaagtttgaacca
+gctcgactaccgcgaaagatacattcccttctctatttttcagttcatctatgggtcaga
+gaagcattgaatttattctattcaccctcgtcgttcacagcgaatcgtcagtgtgatcag
+tgtatgagaaatatcctaaaccgtttagtcagaccacacgcttagaacaagtggtctaaa
+aagactgccctggaaggagtaagaagtatacagctgatccggtgtatccttcagtcatct
+gccctatactaattacacgacgcaaggaaaaataggtttattttctaggcaaacccttca
+taggtgactccgatgtgttacgaatcatgcttgagaatgtgctatcgttaccgacggata
+ataacgatctccaatgaaccaaatgtagaatgtctattgattacccttttactattcgac
+ttagagataggagatagaacctcagtgtacttttttagccgaatgggaatctttgggagg
+tgaatggccataaggtcgtaaatccaaccctcttaaagtcttccatattatatcgttgtt
+cgtggaatcgataacagatttgttgacccatagtaaatgtatactagtttatgttgtaag
+tgtagattgttttccgattgccgtccaaactttatgtcgtaattgtagaccagtaaagtt
+gaccaaggtaagtgcccagcgatcctgcgagatcgatcgccaatttttccagtcactgta
+agtgtaggtttagataaagccgtatgagttatatcataagggcctcggaaagcagcttcg
+aaccaaagttcccttataatagtagtttaactataaaagtatatactggtctgtcgccct
+ttcacgatttgttttaccggtttatgaagcgttacgtcattagagcggctccaatttaag
+gttaacggcttccatgtgtagttgtatacaaggataacttaaagtatctgttcagcgagc
+tagttaagttatcctcgatagaacacaactcagaggtcccaagatcgggtttgcaacttg
+ctaatttattctcaaggcaaattgggaattatcgatacctgtataccataaggtcgctcg
+atgtgatgcttatgtcttctggtgatcctaccttagttagtgctgattaacggaacatta
+atgtttatcgttttgagatttagccaattctctgattctaactcaagatgccttatctga
+cgtgctatgcagcccctaagtattttacattgtaataggacacgctcctttaaaactcgc
+caaaaggtcgttgtggttctctactggttaactatataatttacagctttgttgagctag
+ttcctctttggtttaagtcctcaatattagttggttcgagcgataagttggctagttacc
+ttagtcactatattagatccgaatgttatgcttcatctgaagaccgccaccctccaaaat
+ttcttttaagactcacttattgcaaggtgtaggtgaattcggctcgtttctcaagtggtg
+tatctgtacacgagtttccatattttcatcaacagccaccgcacacttatgtcactctag
+gtattaaaagtcgctctacaaggggacgcaattaagaaacagacatgctagtcaaaaata
+aacatagcgaggcaccactaattcggccgcttatcaatgggatgctctgcgcgagacgcg
+ccagagctcagtagttagttcggacatacatttacttcagatgatcaattagttttctac
+aaatgcttactctaccccgaaaaaagtcaccagactcttacgtctctttagtatccttcc
+gtcttatataaggtcagtcccccgtttcggtaccctggaatttactaagaataatgaaac
+agcccccaaggacgtacgtttacaaatgatagaccagatcgcctagcttattccgacgca
+tgttgcatagaattgaaccaacggaatgtgagagtaactagatgagccgaccacagcacc
+cgtttgcgtcgcagaatacgcctgatagttcggccacgaaatcatatgtcctttgagtat
+taagtatttgtaatgatcaatcgagctcaagcaagcttacacttcctcggatattcaggg
+aacttagtgcctttgaaagatacgttgatcaacgaaaaattgataatggctcatatggaa
+tgcctacctcatagtgctgaattaacacagcactgcggacctaacttttcgaggtttcaa
+gttcacgtctcaaaacctaataggctggaatatgtagggatcctcggtgaatttgtgatt
+gggtttgttgtagtactgaccaagtgaatattctttttttctaaaagcagatctgctgcc
+gggcactacgaaggagatctctgtgtatcattattgcttcttgacatgatgactcttaaa
+tcactgtgggtgtgcaaaacgatagcacaacccaattcgatagtacatattgttgatact
+tcgcactaaaccgttcatatttaaaggttgtgctccttccttcgttaaatactggtgact
+tggtcctatctactattagctagacctctggggaaccacgcccccgtaaaacctgtgcaa
+gagagggggtcatacatcttagacatcgcgcctccaccagggaagcattgggtgattgac
+caggtgtgtaacaaatatgattattcttatactaatattagcaaagatgcataatgattt
+gtattaaatgtataattgaattgataagggtcttttagtcagtgatagagtagtataagg
+tagacattagaactcttaaccggacgcagatttttcggtcttagtaagccaattagtcga
+caaaacaaggtaagagcggttactagtagtacctataatgcactgaatcttcggtcgaag
+tatagttctaatgctatgcagattgtgacggcgacaaatgttcagacttatatcatgaaa
+caagctcttgtaagtattgacaaatgaaaagattgaatatttttaaatacaaaatgcgcc
+tacttattaggggaattaaccagattgaaggccaatcctcacatgtaatgagataataga
+cgataaatgaaattcttgtaatagttgaactgctacgtgatgggtattatatatgattga
+gatcctccaattgccgacgtcttgtcttgatgcccaaaagattgtcaacgaggagctccc
+tcgcgtacctgtcgtccgtatcataaacgacgcgacatgtacagcactccgaagtataag
+caataataatgcgggtaatccagactagatcttttcggactcaatgcggtttcacggtaa
+acatgattaataccggagagtagtcgagcttatcagcgatgcaagcgaattcattgtgcc
+aggagatacgttgcagataaaaccggcaacgtatgtcaacaagttttggcgatctcgttg
+tttgtattcgacgaggcgcgggaacttcaagaactatcgtatattcaagtccattacctt
+ttagtttcagactggtggagctgactaaagttatatcatcattttgtacactggtttagt
+taacgataatttcagatttaacatgaccagacgataatcgctgtatatccagttggaatg
+tggtttgccagaaaggttaacttataatcaagcctctcttcagtcttgattcgtcgtatc
+ccatccattgcgctatacctcagtgtatttggagctgtagttataccgtgtgctaagatc
+agtagacatgacgagagcaatattatctaccttacaagcatcaacggacgtctagtcgga
+acaaaagactctaaaactcgaacttcaggttaatatactatagttctgtattcagcagtt
+attcttatattcgatattatcttgcctattggatgtctgactttagtatattaatcatag
+tatctgccatgtaaaggtgccagtactaaatctgtttcacagtgcgaattataaacggtt
+acaaccattaaagacaacaagaccctatagctttatttgaattttgtcaatgcgcaactt
+ggagctcgcgatacatcccaattagtctatagggtcgggacgattctacggcatttctgg
+ttataatgacaacatggattgtggcccgagaatcgctctttcattaattaagcaatcatt
+acagtcttataagcgctacttccgagtggtagcaggtaactcgatataaggtcgcatgag
+ccgaatagcttaaaaaacaggccaccgaacattgatagagaataccgaccacagcgcaac
+ctttgattactttcattaaattgtacggctcactcgacatcaagcttaagattgcgataa
+tgtgaactcaaatggatcagtactgaagaaccgtaacccacttcgcagaaagcgtaccca
+gagaagatacgctgttacaatatacagggtgaaattattgcctgttcttcgtaaccattt
+cgccaaacttggttagaaatgatagccattcatgatagaaataagctgaatgataccagt
+atctttaactatgtagtcagggggaagataacgatggtccatgtatgtttctgatatgtg
+acagtattggccgcgtaatttgctaacgaagctacttaatgcctttgagcttcatataga
+tttctttaatcaaaatcggcaaaaagatagtatgagctataatatatgctagtagagaac
+tctggaccatcatctatatgaatactgattcgagcgtgcaattactttagcctgcgtact
+actgactctacaaaacactctgagataagtttgtagtcagtaagtcgctctctataaacc
+ttttggatgaccattgtacagccacttatagatcccaataaatagcacaggagacagagt
+ttttcaatgctcgatcatttgccgatagtattttcgtctaacctcagggcacctattatt
+tgatacctaacctaacggccctttcacaatggagaaatatatgacatcgggacaaacaca
+aatggtgggtggccaggagatatgacatggtggcgtctctaagaaacacggactccctct
+aggcaaactcacgtaaccaattttaatgtcaaacaaaacgctcgaaaagattttgccgtg
+taatgacctggtacattgactggtcaggaatacatcactgtagttgccgtagtgtcctgt
+tggtgttccatcaagacacatcgtataacgcaatttacgacggacatcagatcaagttat
+acagattatttaagtatcacgtgtgcattgggacataagggatctcacacatgccttgga
+acatttttgctttgtgccgctttttcgctgcactaccaatccttacttaccagtatattc
+aaaggtcgttaacagaatgagaaaggttagggctctaagttatcgtcgattgggatagac
+gagacatttgcgagcgccctccacggatacgaatctcccatatcaatgtgaactggatgc
+tatgcagtttagttcttacgtctcctagtggtaaaaatcaaagtagcactcgcatagcag
+ttattcagaacctaatacacaaaaccgtcaaacattttctaattctaggtatgggccgat
+cataggagctaaggtgaaactcataaatgttttgttagatctagcatcctaaaaagatgc
+atatactgagtagctggcgtgcattctctcaattgtatcctttttaactgaactagtcgg
+tcccatttcgtgactgagatctattaaccgataagattaataacactcgcattcgtatca
+gctcagagtgaagtttttcaataatttgactgatatattaacttctaaaataacccttta
+agcctcggatccgtttcccaatcacatcaaaaattcttattccaactatctacggattaa
+caacgtgcatggggatcgtagtaagaacttgttccgatcactttgagtatatcaagttga
+cggcccggttattattgaatagaaacattcacctgctaaattaaataccgcacatcggat
+acccgatttcagagggccgtcttactaagggcaggctttgttcggtttaactgagatgtt
+cattattttacagtatgcttcaactaatatgtaacgaaggacagtggatctgtctccata
+gtagatcttcagtcgtgaatttcataccgctcctatttaagttcgcgttcgagttgttga
+tcatggcacgtgaaagcaacccctagtattctagacgaaaattttttctagttcatctga
+taatttgccaattcaaaaacaaccgctggtttcccggcgcattctctaaaatggaagtcg
+aacctagagccattatttgtcggtaacccatgagttccttcttttcagaagttaatacac
+tgtggtcctatacagaggaaaaacagcggttatatacgatcgtggcataacaacattgga
+tcaagatagcaatttggctacctattctaattctcactagattcggtattccactacaat
+atcggcagattaggattggatgaataatcggtgtttaagtccggttgcgtctccaatctc
+ctaatttttattaatattgatcttggtgacctattgtaaataaaaacttcaagactttga
+ataacggtgaaaagatagaagactcatttgaaaatggatcatccacagatccaaacatta
+gcaagacactaatccccaactagctattctgatcgcgatcgtgctgcagtactcctgtca
+caatagtctgttcatgatctaattctttttgggctttgttcgatggtgattcagaatctt
+tatccggtcgcttccctgtagctactttgtggggatattgcccggggattatagggttga
+gatcgtttcctaaaagtatttaaaccaagtagacttcaactaaactacatcagaacatcg
+tgaagacaccatacgcggtacctttatttaccgataacatttcttcaagaaataccggta
+agcagcataatgaccctaaacagctcggggtatcgtcgtagttttaaattttatttaggt
+tactgctcaaggaataaaaactaactatttaatttataataatattacaaggctcacact
+gattagatttgtctataagacttcgcgatcccccattaccggattgtcttaagaataaac
+tagataaaccatgcattttctagataaggcctttagtctaattagatacaaaaaacacga
+tagttgcatccttaatttattgtgtcaaacctggaaccttttaattacccgcaaatcact
+ttatgtcgagactacctctgaaatttattatctacctaccgcatgaggacttgaaccatc
+ttgtaggagttatgtttattagctaagattcgtttatcctgtagcggtccatgtatattc
+aacaagcaaaaagcactcagaattgtttttagttgagtcaagactgatatataaataagt
+ttccctagttttttcgtggtgggacgatattgaattgaatcttaaccgaagagtttccca
+ctctgtcgcacaataatacacgccaatatttccagccctgcttatgccttaatcggttac
+tcaatctcccattgaagttcattttgatctgcatagaagtttcgggcccagccttttttc
+tgccaccttcctccaagctctgtagacgcactctaagattgatgctcacatgtattaatt
+ctacattaacataaatatataagtcatgcatcttcgagtaaaatatctggttctccaaca
+tgtcctggcacgtatcgttataatgcccatacatgtagtattaaaatgattgggttaact
+ggatattaagatcatcgaaattgtaaagtcaaattaacaatactgtctcaagaccgtgta
+ttcctcgtgctcggaagggctattacgcttacttccgttttggtatcttaatatgacttt
+caaaaattaagttgcagtgagtcctacctgcgtgcatcggttagcaagagtataaaagtt
+gtttaaacgaactacttgctttacaataccggtcgtatatatcgccgtgaatccagaaga
+ttgtcttctttggattatcaaccgagatcctgtggaccgatgttttgggaccttcacaga
+ggactccaggtagagctcgcttttgcattaatctaagaattgtacctctctaaaagatct
+aaaacagtgaatgtgtatttcatggaaaaacacagagaaacgtaaattactttaggccga
+aaggcacatgagttattatacatatacgagatggtggtatacatcgaattcggggcatac
+actatagttgcattgtatttagctgctttaaataatatgatattaccttccttacataag
+acattaccggcataccctggttttcaacttgtggggctttttgacgatcgcactctcatt
+tgatccgagtagggcggtgacccctgcttttcaaatacaaaaatttcgctatgaaggtaa
+tagattacttttcgctgttatgatagaaacggtaaatttaaaattgaaacttctagaaaa
+gtaaagtaacgagaaatgattttgtgaataatgcggtcatgattgcgcaagtaagaaaaa
+aaggcaaaaggatgcgcggaatagaaacttatcagtcacgggtatcttgatttcattctt
+cttgtcaattgccgacataggatgaaatcagattccaatgcaatacacagtaacccccac
+ccttgattgtaatgtcgatttgaagttgtacgcgtcgacgaagtggatagtatacgggcc
+ttttgtacggtgcgatcaactatgaatctcggcgagttagatggtcgtacaatctcacac
+atagaggtcacttgcctgtaatgacgaattttcggctaggtactcgaactttattagaag
+taaaaatgtgggcaaaagaaggattccattttacaagacgattacaatgagttacatgtc
+tctcaacgtagtctttccctagtagtctttgaactatttaggtactccagaaaattttag
+caaagggtttctgtgtgaatccgccattcatgtttatgatggaacaataagaataacgcc
+ctcgtatgttatcgacagtgaagtcagcagttcggccaaaaacatattcaatttagtaca
+gatccccagaagttaagctaagtgctctaaaatggcctaaacggttatcaaagtaggtct
+aattactatactaacgggtgcatcgtaataactgctgtcgatgcaacactatatgatagt
+gtcgttttgctatatatgtacaatgtgacaaagaagccttagcgattcttgcaaacttag
+gacttcggattctcaatcttaaatgtccgaaaacgcaaagattcaaaaatttaatctatg
+agcagatatgcctgatggtgactacgcgtatgttaaggctaaatgttgacaaccgcacac
+ataatcgaactattgatagtcgggagcataaccaggtgaacgtactttgttcacgacatt
+tattgacatgttctaaatacgtctcaaaatcacggcgcactagaaaacgcaatcaaatca
+ttgtcctggtttaagggccgtaatgccggtagtgtcaaacttcatgagaactttagctgg
+cttttggccagtatttagggaccaagagcactagccttaagctgaatattttgccattta
+tctactgttataactttaaaacttggtggcaccagacttgtcgatacacacgcatcaatc
+tgtaacgtaaaaggtttactaagaacaagcgtaggaattgagtttatattatatttaaac
+taaaagatgatattagcttctgagggcgatagggctccaaatcataaagaggaatatatt
+attacacgattagaaacccacaacatacctcgaatcgcccaaaagtttgacgaaacttgg
+cagtactccacatctcagtaatacagttgggagagtctcaaatgttgttttattactcaa
+tgaaccaccctcataatttcactgctgttccattaaatttgcaaacgatcatttgctttg
+aagaaacgtaaaatcgacaaaattacagataagtagatgcataataaaaaaaactgctcg
+ctataacacgatcatcgtgcattcttacttaggagcatcacccgcacaataacgtacctt
+aaactacaacactattagaccgagtactgtaattcacgaaagctcaagctcgcattgtaa
+agaacttgctctctcgtaaaatgtgataatagtttgcggagaggattcaattattttcca
+ttgcacctactccactagattcgataaaagaaggtggtcctcccttaaaaagaaatgtta
+agtaacatcggaaccataagcaaagcatgtaagtgaaccgtcatccttccctaagaaaca
+taaaggtttttaataatgtcgactgtgaactataactgcatcctttcctgacctactccg
+gttccttgttgttatttctgaacgagaccagtagataaacaatgtaaaccacagtgggta
+ccaatggtgcatgtgacgctaccgttgttttaagtgcccgtacaaacataagaagtcata
+atcttacttgaaattaattttgccttttattttttttcaggctcgaaattaatgatttgt
+tttttttgaccttctagttacgctaatatgcggtcgcctgtggtttctattgagtcctat
+aacgggatgggatctaatacgtttggttactagtaaacaaggtataaatttgataccgga
+gtatcaactgtataacatcaagctttatgactcatacgcgaagtaatgacacaaggcttt
+caggagatcgcgagtacagagccactaaggggtgtattacgatagtgacaccaccgagcg
+cactcactccccaagtagatttatgatcctacgctaagtattagatatataaccaaagag
+gttctagtcagtgcaactcttagaataataattagccggttttgcctttttaggcctaat
+gcaatattcagctagcccttatgtatctcgcgttccacagcaccactcatggcacgcgtt
+taaactaatcaaatataatctatgaatgttatgccagtacttgaataaatcaggtttttt
+ataagtccttgcatactctcgttatatactgttagagtcttaccccatagaaattctttc
+atctgcaaacttagaagaattctcagctacggggagcataaagtccccaggatgttgaca
+aatacaacaaatgtggcttatacaaacactccatatgaaaatcgaaccctcgtggtagtt
+ttagccgaaccttgtacggataaatccctccattttccaatagcagatacctatcctact
+acctcgtggtattaaattaaagcttgaaatatagagctgcatagcttatccaattcccaa
+gcacgagtctaccgtcgtaaccacgatttgatttacagacgctagagcaaacccatcttt
+aaacatataagtaaaaattaaagggtgagtgcgtacgtgtttactagcaacttcgcttat
+taagacaattgtttataagccataattaaaaacatatgttcaacaggttcattgatattt
+gtaattgcacaggtttttaataaggatctacgtaagtataatgaacaaactttttaccag
+agttatattctgtactttgaaaatgctcctctaccgccttagagactttcaattagattt
+tttgcagttaatctatgcgtaagtgaaccatgcaagggatgcgattcaaccgcctcgtgc
+taaccctatcgtctgtctcataactgtaggtctaatataattttcagttttcgaacacat
+aaccctttgaaaatctgctatttaatgtctcacctgcatgcactatcttctatactgctc
+agaacggctatacgtcactatgctccaagtgacgatttaaacgaagcaaggaataatagg
+tttattttagtgcaaaacaattaagtgcggactacgtgctctttacaataagccttgtga
+ttgggctataggttaagtcccatattaacgatctccaatgtacaaaatcgacaatcgctt
+tgcattacccggttactagtcgaattacagatagctgttagatactcactctaattttgg
+acaacaatcccaatcttggggtcgtctatcgcctgaagctcgtaaatccttccatcttaa
+acgattacatattatagacttgttcggggtagagatatcacagttgtgcaaacattgtaa
+atcgatactagtttatgttggtagtctagttgcttttaccattccccgaaaaacttgatc
+tactatttcgacaacagtaaacttgaactaggtaagtgaaaacagagaatgcctcatagt
+gccactatttgtccactatatgtaagtgtagctttacataatccactatgactgagatca
+ttacggcctaggaaagcagcgtagaaaaaaagggcccggatattacgactgtaactataa
+aactagttactggtagcgcgccatgtatagatttgttttaccggttgtggttgcgttaac
+gaatttcagccgcgaaaattgatccgttaaccagtccatctcgacttctataaaacgata
+aagtaaagttgatgttcagcctccttcttatggttgcatcgagagtacactactcagtgg
+gaaatagatcggggttcctacttcagattgtattatctaggcaattgccgattgtgccat
+acctggataaaataagctacctacatgtgatgcttatctattatcgtcatactaccttag
+ggtgtcctgttgaacgctacattaatctttagccgtttgagatgttccaatggataggag
+tctaacgcatgatgaagtttaggaaggcagagcatcccactaagtatgtgacagtgtatt
+tcgaaacgagacgttataaatagaaaaaaggtccttctggttctattctgctgaactatt
+gaatggaaagattggttgacctacgtactatttgcttgaagtcatcaatttgacggggtg
+agagacatatggtgcatactttacggactctatattttagatcagaagcttagcagtctt
+ctctacaccccctcacgacataattgcttttaagaatctatgtttgattcctctacggga
+attcggatccgttcgcatgtgcggtttatctaaaccaggggacatatgttcagctaaagc
+atacgaacactttgctaactagacgtatgtatagtagctataaatcccgacgatatttac
+aaaaagaaatgagactcaaatatatacatagcgaccctacacttattcgcaccctgatct
+aggcgatcctagcacccacacccgaaagtgagcactagtgtcttccgtattaaatttact
+gcagttgagattttagttgtctactaaggattactctaacccgtaataaggatcaagact
+cggtactagctttactatcattccctatgtgttttcctaactcacaagggtacgtaccag
+cctatgtaattacaataatgataaagacacaaaggaagtaactttacaaatgagtctcca
+gttacactagcttagtccctcccatcttgctttgaagtctaaatacgcaatctctgagga
+tatacagcagaagaacactcataacgttggagtccaagaattagactcatagggccccca
+acatttaatatgtactgtgagtttgaaggtgttctattgttaattcctgctcttgataca
+tgacacgtactccgtgtttaaggcttcggactgactttctttcataagttgagcaacgaa
+aatttcagaatcgataagttggattcactaactaatacggctgattgaaaactccactcc
+ggacctatatggtcgacctttatacgtaaccgatataaaacttataggctggtatatcga
+gccttcctagcgcaatttcggatggggtttcttctactactcaacaacggaatagtcttt
+gtttagtaaaccagagctcaggacgcccaatacgtaggagagcgctgtggagcatgtgtc
+attatggactggagcactcttaaatcactctgcgtgtgctaaacgatagatcataacatg
+tcctgagtaaattttcttgatacgtcgcaatataccgttattagttaaacgttctcatcc
+gtcatgcgtgaaatacggctgtcgtgctcagatatactattagcgactcatctcgcctaa
+cacgcacacgtataaactcggaatgactgccgctcttacatattagaaatacagactaca
+ccacggaagcattgggtcattctcaaccgctgtataaaagatgattagtcttataataag
+attaccaaagaggcagaatcatgggtagtaaatctattattcaagtgattaccgtcgtgt
+aggcagggagtgaggacgagatggtactcaggacaaatattaaccggacgaagtggttta
+cgtcgtactttcactattagtagtaaatacaaggtaacaccggggaatagtactaaatat
+aatgatatctatcttcgggagaacgagtcgtctattgctttgaacattctcaaggcgtaa
+aatgtgctgacttatagcatgatacaaccgattgttacttttgtctattcaaaagattga
+atagttttttatacaaaagccgcatacttatgacggctagtatacagtttcatcccctag
+catcaatgctatggacagtattgaacttataggaaattcttctaatagggcaaatccgtc
+gtgatgcctattttttttcagtcacatcctcaaatggcactagtattgtcgggatcccat
+taacaggctcaaccacgagctcacgcgaggacatgtagtccgtatctttaacgaagcgac
+agcgacagaactcccatggataaccaattataaggcccgtaatcctctagacatcgttta
+ccaataaatccgctttctccgtaatcatgttgaataccccagagtagtccagatgataac
+cgatgaaacacaagtctttctcaatgcacttacggtgaacttattaccgccaacgtagct
+catcaaggttgcgacatctagttgtgtgtttgcgacgagcccagcgaacttcatcaactt
+tcgtatattcaacgccttgtaattttactttaagacgcctggtgatgtagattcttagat
+aatcagtttgttatcggctgtactttaccataatttcacaggtttcaggtcaagaagatt
+atagctgtatatacagttccatgctcggtgcacagaaacgtgatcggataataatcaatc
+gcttatgtcgtctttaggcgtatccaatacatgccccgataccgcagtgtatttcgacat
+gtaggtataccgtcgcatttgagctcgagtcaggacgtcagctagattagattccttaat
+agaatataccgacctctagtccgaactaaactatagataacgccaacttcaggttaattg
+tctagtcgtctgtttgcagatgggattcttagatgagtgagtatcggccatattggttcg
+agcactttagtttttgatgcataggatatgcaatgtatagctgaaagtactttatctgtt
+tcaaactcacattgattaaaccggtaaacctttaaagactacaagaaaatattcagtgag
+ggcaattttgtcaatcacaatcttccagctagagatacttcacaatttgtcttgaggcta
+cgcaacattagacggattttcgcgttttattgaaataatcgaggggcccaagagtatcca
+tagttcattttgtaagatttctttacaggcttattacagcttcttcagactcctacatgc
+ttacgagttatatgctagcatgtgaacaatagattaatatacaggaaaacgtacattgag
+agagatgaccctacacagcgcaaccgttgagtactttcattaaagggtaacgctctcgag
+acagcatccttaagatggccttattgtcaaatcatttgcagaagtacgcaagatccctaa
+ccaacgtagaagaatccctacaaacacatgagacgcggtgaaaatagacagggtgttagt
+attcaatcttcggagtatcaatttcgccaatcttggtgagaaagcataccctttcttcag
+agaaagaagatcaatcataacactatctttaacgaggtacgcacgcgcatcattacctgc
+ctccatggatctttaggatagcggaaagtattggcagcgtattgtgatttcgttcctact
+ttatcaatttcacattcatatacatgtcttttatcaaaatcgccaataagataggatgag
+ctatattagatgctagtagagttcgcgccaacatcatcgataggaatactcaggacagcg
+tgataggacttttcaatccctaatactctctataattataactctctcttaagtttggag
+gcagtaacgcgctctatataatcagtttgctgcaccattcttcagcctctgatacataca
+aataaattccacagcagtaagagggtttaattgagacatcttgggaacttaggattttac
+tctaacatcaccgaaacgattattggataccgtacctaaacgaactttctcaaggcagta
+atataggacatccgcaataacacaaatgctgcctccccaggagttatgtcttcctggagg
+ctatatcttacacccactcactataggcaaactaaagtttaaatgttgattgtctaaaaa
+aaagatagataagagttggccggcgtagcacatgcgaaagtgaatcgtaagctataattc
+tctggacttgaagttctgtcctgttcctctgcaagaaacaaacttcctttaaagctattt
+acgacgcacatctcagcaagttataaacatgttggaagtttctagtcggaattcccaaag
+aacggatctatctaatgcattcctacatttttcctgtctgccgatggtgccatcctattc
+aaagaatttcttaaaagtagattaaatgggacttttaacaatgagtaaccttacgcctct
+aagggttcctcgagtgccatacaccagtcaggtccgagccacatacacggagaacattct
+aacatagcattctcaactcgatcatttgcaggttacttctttcctatcctagtgctaaaa
+atcatacttgcaatcccatagcacggattaagaacctaagaaacaattcagtaaaacatg
+ttcgaattcttggtatgggaacatcattgcagctatggtctaacgcattaatgtttgggt
+acatcttccatcatataaacaggaagagtctgacgacagggagtgcttgcgatcatgtct
+atcattgtgaaatcaaattgtagctcacatgtcgtctatgagagcgtgtatccgataaga
+tttagaaaaatagaagtcgtataagatctcactgaacttttgaatgaatgtgaagcatat
+atgatctgctttaataaaactttatccataggatacgtttccaaatcaattcaataatta
+ttagtcaaaatagataaggatgaacaacctgaaggccgatcggacgtagaaagtggtccc
+atcactttgagttgatattgttgaaccacacgttattatggttttcaaacagtctcagga
+tattgtatatacagataatccgataccagttgtctgacgcccctcttacgtaccccaccc
+tttgtgacgtttaaagcagttgttcagtattttaaactaggcggcaactaatttggaaag
+aagcacagtggatatgtctaaattcttgttattcaggcctgaatttaatacaccgcatag
+ttaacttcgcggtagagttgttcatcatgcctcctctaagctaccacttctatgatacac
+caatagttgttctacggaatctgataattggccaagtcataaacttccgctgcgttcaac
+ccccttgctcgaatatccaactcgaaaagacagccttttggtgtccggaacaaatcagtt
+acttcttttctgatgttaattctctgtggtcagatacagaccaaaaactccgcggattta
+ccatcctccaagaacaaatttgcatcaacatagcattttggctacatattctaagtctca
+atagtttaggttttcaactacattatcccaacattaggattggaggaataatagctgggt
+aagtccccttgcgtctacaatcgactattttttatgaatatgcttctgccgcacctatgg
+ttattaaaaaagtcatgactttgaagaaccctgaaaagatagatgaatcaggtgtaatgg
+cagcagccaaagagcatataattagcaacactctaagaacattatagatatgatgatagc
+gatcgtcatgatgttatccggtcacaatagtagcttcatcagctaattcgttttgccagt
+ggtgacttgcgctggaagaatcgttatacggtcccttccctcttgatacggtgggggctt
+attcaaccgcgtggattgggttgtcatacttgcattaaacgatgtaaaccatctagtagt
+caactatactaaatcacaaaatagtgatcaatacatacccgcttcatggttttaaccatt
+taattgattaaagatattccgctaagaaccattatctacctaaactgatcgccgtatcct
+agtagtttgaaatttgatgtaccgtaatgatcaacgaagtaaaacgttatattgtatgta
+gaataataggtcttggagctaaatgatgtgattggtagtgaagacttacccttacaactt
+taccggtttctcggaagaatatactagagaatcaatgcatgggctacataagcactttag
+tctaatgagataaaaaatacacgagtcttccatcatgaattttttgtcgaaaaactcgaa
+cctggtaatttaaaccatatatctttatgtcgtcaataactctcatatgttttatataac
+ttcccaatcacgacttgtaactgcttgttcgactgagctgtttgagctatgaggccggga
+tccggttgagctacatctatttgctacaagaaaaatgaaagcacatttgttgggagttct
+ggctacactcatagagaaataagtggcccgagtgggtgcggcctgcctccatattcaagt
+gtatcttaaaccaagtggttccaacgctcgcgctaaagaattaaagcctttatttcctcc
+acggagtagcccgtaatccggttcgaaagagaccattgaagttaattttcatatccagtg
+aagtttaggcacaagcatgtgttctgccacatgcctcaaagcgctcttcaaccaagatat
+gattcatcctaacttcgatgaatgcgtctgtaacataaatatagaaggaatgattcggcg
+agttaattttcgccttctccaacatggcatccctacgttcgttataaggaccatacatgt
+aggttttaaaggtttgcggttaatcgatatttacatcatagaaattctatagtcaaattt
+acaagactctagatactcactcgttgcagccggctaggaagcgctttgtaccttacttcc
+cttttcgttgcgtaatatgaatttcatatagtaagttcaaggcactcatacctccgtgaa
+gagggtagatagactattaaagttgtttaatagtacgtattgatggaaatgacccgtagg
+agatttaccactcaatccacaagattcgctgctgtgcattatcaaaacagtgcatgtcga
+aacatgggttgggtccttcaaacacgaatccaggtagagatacctttgcaatttttcgat
+gaaggcgaccgagataaatgagctataacactgtatgtcttttgattgctataaaacaca
+gaaacggatattaatttaggccgtaaccaacatctgttatttgacatagaacagatggtc
+ctttacagcgtattccggccttaatattgaggtccagtgtattgtcctcctttaaagaag
+ttgattgtaactgacttaaataagacatgtcacccattcactgggttgcaactgctggcc
+ctttttgtccatcgcacgctaatgtgataacagtaccgccctcacacctgcgtttaaaag
+acataaatgtcgctatgaaggttattcattaattttagctgttttcttagaaaaggtaaa
+tttaaaattgaaaaggctagaaaactaaagttacgacaaatgtgtttgtcaagtaggcgg
+gcatcattgagattgtaagaaataaagccataaccagccccggaatagaaaatgttaagg
+aaaggcgatcttctttgaattcttattgtcaagtgcagtcatacgttcttatcagaggac
+attgcaataaaatctaacaccctcccttgtgtggttgggccatttgtacttcgaagcgtc
+caccatgtgcagaggataacggaatgtggttccgtcccataaacgatcattctcgcccac
+ttagtggcgcggtaaatcgctctcatagaggtaactggcctgtaatgtccaatgttaggc
+taccttctccaactttagtacaacgaataatgtccgattaacaaggagtcaatttgtcat
+gaccagttcattcaggtacttgtatctatacggacgcgttccagagtagtatttgaaatt
+ttgaggttctactgataagtttagctatcgctgtatgtctgaataagaatttaatgttta
+tcttcgataaataacaattaacaactcctaggtgatacactgtgaagtctgctgttcccc
+aaattacatatgctattttgttcacataccatgaagttaagctaagtgctctataatggc
+ataaacggttatcaaactagctcgaatttcttttattacgccggaagcggattaactgct
+gtagatcaaacacgttaggatagtgtcgttttcatatatatctaaattcggtctaacatg
+cattacccatgcttgataacgtagcacttcgcagtctaattatgtaatgtccgtttaacc
+aaactttaaaaaagtttatctatcaccagtgatgcctcatcgtgactacccggatcttta
+gcctttagggtctaaacagaactaatattactacgtgtcatactccggagcttaaccagg
+tgaaacttatttgttaaccaaatttagtgacagggtagaaatacgtatcaaattaaccca
+gcaatacaataagcatgaaaataattgtaatcgggtttgggccggaatcccgcttggcga
+aaacttaatgacatagtgtgatgcattttgcactggattgagccacaaactcaactagca
+ttatgctcaatatttggccagtgttctacggtttgaaatttataaaggccgcgcaaaagt
+cttgtagttacaaacgcataaatctcgaacgtaataggtttaattagaacatccgtagga
+tttctgtttatagtagatttatactaaatgttctgattagattctgacggccttacccat
+acaattaataaagacgaatatattagttatagtttactatccaaataaattaagcgaatc
+gaaataaactgtcacgatactgggcagttatcaacttatcacttatacagttcggacact
+ctatattggtctgtgagtactctatcaaactaactcataagttaactgcgcttccattaa
+atttcaatacgttcttgtgctgtgtacaaacctataatcgaataaatgacacatatggag
+atgcataataaaaaaaacggctccatatttctcgttaatcgggcattcttaaggaggagc
+atctcaccaaaaataacgttcctgataagtcttaactattagaccgtcttcgggaatgaa
+cgaaacctcaagctagcatggtatagttcttgatagcgcgtaaattctgataatactggg
+cggacagctggaaattagttgccagtgcacctacgcaaatagtttacataaatcaacggg
+ctccgaacgtaaatacaaagggttagttacatcgcaacaagatgaaaagcatgtatgtct
+accgtcatccgtccctaacaaacataaaggtggtgaagaatctcgtaggtcaactataac
+tccatccttgaagcaactactccgcgtccgtgtgcgtagttcgcaacgagaacactactg
+aaaaaagctaaacaactctcggtacaaatgcggcttgtgtcgataaagttggtggtagtg
+cacggaataacataacaaggaatattatttattcaaattttttgtgactgttatttgttt
+tctgcctagaatgtaaggatgtgttttttgtgacctgatagttacgcttatttcaggtcc
+acggtgcgtgagagtgtgtcctataacggcaggggagcgaagtagtgtcctttagactat
+tcaaggtagaattttgataacgctctataaaaggtagaaaatcatgattgagcaataaga
+ccccaacttatcaaaaaaggagttctcgacagcgcgtgtacagtccctataacggctgta
+tttcctgtgtcacaacaccctcccatcgcactcaaaatgtagatttatgatcagacgcta
+acttgttcttagagaaaaatacacgggatactctgtgcaacgatttcattaataaggtgc
+agcttgggacttttttggccgtaggctttattaacattcacagtaggtagcgagacttcc
+tatgaaccaatcatgccacgcgttttaacgtttcaaatataagctaggaagcgtttgcca
+ggacttctataatgcaccgttttttttagtacttccttactagccttagtttatgttaga
+gtctttccaattacaaaggattgaatagccaaaatttctacaattctcagcgaacgccag
+cttaatctaaacacgagcttcaaatattctacatatcggcaggagtcaatatataaatat
+gaaaatcgtaccatcctcgtacttttagaccaaacgtcttcggataattaaatccttttt
+caattaccacagtacgtgcattagaactactgctatgaaagtaaaccttgaaatatagtc
+ctcaagagcgtatccaagtacattgcacgtgtatacagtcgtataaacgagttgatgttc
+tgacgctagagcttaccattcgttaaacagataactaaaatttaatggctgagtgactta
+gtgttttcgacaaacgtcgcggatgtagactattgtttataagcaatttttaaaaacata
+tgttcaaaacggtatgggatatgtcgaattccacaggggtttatgtaccatagaagtatg
+tataaggtactaaaggtttaaatctgtgatattcggttcggtgaaaatcagactagtcac
+acttagtgtctgtaaattagattgggtgaaggtaagcgatcccgaactctacaaggcatg
+ggatgagattctaccgactccggataacactttacgatcgcgcataactctagctcttag
+ataagtttaacttgtcgatctcataaacagttcaaaatctgcgatttattgtatcaaatc
+catcctctatcttctataatcatctgaaccgcgatacggcactatgagccaagtgaagat
+tgaatccaagaaagctataattggtttattttagtccatttaaattaagtccggtataag
+tgctctgtacaatatgcagtctcatgggcatatacgttaactaccttttgatacttcgaa
+ttggtaaaatatcgactatcgatttgcagtaaaaggtgtagagtccaattactctttcct
+gttacatacgatctcttagtttggacaactagcccatgatggcgctcctctagcgcatga
+acctactttataattacatctttatcgatgaatttttttagactgcggaggccttgagtt
+ttaacagggctgctaaatttcttaagcgattagacggtagcgtcgtacgctacttgcttg
+gaacaggcaccgaaaatattgatctactattgcgtcaactctattctgctaatagcgatg
+gcaaatcacagaagccctcttagtgacaatagttgtcaactatatctaagtcgaccttta
+ctgtatcaacgatcacggagagaattaccgaatacgaaacctcaggactaaaaaacggaa
+aggatttgtcgacggtaaatataatacttgttaagggtagcgacacaggtatactttggg
+tgtaaacgtggtgcttcccggaacgattttcagaccagaaaattgttccggtaaccagga
+aatctcgtctgcgttaattcgtgttagtaaacttgatcttcagactccttcttttcgttg
+cagcgagacttaaattatatctgcgaaatagtgccccgtgcatacttcagatggtaggag
+ataccatttggcccattgtgactttacgcgattaattaaccgacatacatctgttcctga
+gctatgatcgtctgaataaattacggtctcctcttgatacctaatggtttctggagacgt
+ttctcatgttcaaatggatagcaggagatcgcttcatcaagtttagctacgcagagcatc
+aaaatatgtatgggaaagtcgatttccaaaccagaagggataaagagaaataacggactt
+ctccgtagattagcctgatattttgatgggaatcatggcggcacatacgtaagagttgcg
+tgaacgaatattttggacggcgggagacacatatcggccattcgttaaggtctctatatt
+ggacatcacaagcttagcagtatgagctactaacactcaagacattattgattttttcaa
+gatatgtttcattcctctaccgctattcccatacgttcgattcgccgggtgagcgaaacc
+acgggactgaggttaagctaatcaataacaactcgttgcgatagagacctatgtatacta
+gagagaattccccaacatttttacaaaaacaaagcagactaaaatagatacagtccctcc
+atacaattaggaccaacatgttattgccgatcctagcacacacaccacaaactcagaact
+tctgtcttacctatgaaagggtctgcacttctgattgtacgtgtctaattagcattaata
+ttaaaactaattaggataaactataggtacgagctttactataagtcactaggtgttttc
+cgatcgaaaaacgggaccttcaagccttggtaagtacatttaggataaagaaaaaaagga
+aggtacgtgactaatctgtctaaactgacaatagagtagtacctacatgcttcatgtcaa
+gtcttaatacgcaagcgctctcgttatactgctcaacaaaactcataaagttggactcca
+tcatttagaatcatagggaccaaaacatttatttgctactgtcactttgtaggtgttcta
+ttctgaattcctcatattgatacatgaatcggaatacctgtggatcccttaggacgcacg
+tgctttctttacgtcagaatacatattgtcagaatcgagaagttccatgcaattaagaat
+tcgcctctttgaaaactcatatccccacatatagggtccaccgttattcggaaacgatat
+aataattattccagcgttgagcgtcccttaagagcgcattttcgcttggcctttcttcta
+cgactctacaacgcaagtggctgtgtggagtttaccacagcgcagcaccccatagaacta
+cctctgagagcgcgagatggtggcagtatgctctgcagctagcgtttagaacgcgcccgc
+gcattaaccagtcatattaaaatggactgtcttaattgtcggcattaggagcaatattaa
+ctgatgagggtatcggtcgcagaagtaatgacggaaatacgcctctagtccgcagagata
+cgattacagactcagatcccctaacaagcaaaacgattaaatcggaatcactccccctat
+gacatatttgaaatacacaagaaaccacgcaacatgtcccgcattctcaaccgcgcttta
+taagatgttgagtctgagaattagatgacctaactgcaagaatcatggcgagtttatcta
+gtaggcaagtctgtaccctagggttcgaacgctgtgacgtcgtgatcggtctaaggactt
+agatgataaccaagaactggtttaccgagtactttcactattaggagtaattacatgcgt
+tcaccgcggaatacgacgaaattttttcatatctttatgagcgagatcgtgtcgtctttg
+cattgcaacagtcgctaccagtaattgctgatcaattatagattcattatacagatgctt
+acttttctctattcaatactgtcatgagttgtttttaaataagcaccagaattatgtcgc
+ctagtataatcttgcttccacttgaatcaatgcgatggacagtattctactgattgcaaa
+gtagtctatttcggcttagcagtacgcatgcctatttttttgcaggcacagaataatatg
+caactaggattctcggcatccaattaacaggctaaaacaccaccgaaagacaggtaatct
+acgaagttgatgtttactacagaaagcgaatgatatcacttggagaacattttagatgcc
+cccttttaatctagactgagtgtaccaatatatcaccggtctaccgaatcagcttgaata
+aaccactctagtactcatgataaccgagcatacacatgtatttctcaatgcactgaaggt
+gaactgtttacaccataccttgcgaatcaacgtggcgacttatacttctgtctttgagta
+cagcacaccctaatgaatctaagttagttgttgatacgaattgtaatttgactggatctc
+gcctcctcatctagattcttagagaagatgtttcttatagccggtactgtaactttattg
+atctggtttatggtaatcaacattttacctctatttaaacgtccttgcgccgtgcactca
+atcctgatcggtttagattcaagcgattatcgagtctggaggccgagaaaagaaatgcac
+agagtaagctctctattgcgacatctacgtagaaactcgcatttcagatcgagtaagcaa
+ctctcattgtgttgattcagtaatacaagattacctacgcttctacgaaatatactatag
+atttagcctacgtcacctttagtgtcgagtcggagctttgaagatcggatgcggtgtgga
+ctgtgtataggcaattttgctgcgagctcgtgacttttggttgatgtcgatatcaatggg
+atacctcaaacgtctttatctctggataactcacattgagtataccggtaaaaatttatt
+ctattcatctaaatagtcagtgagggctagggtcgcaatcacattaggccacatacacat
+acttaacatgttctattgacccgacccaactttagtagcattgtagccgtttatgcaaat
+atgccaggcgccaaacactagccagagggcattttgttacatttatttaatcgattatta
+cacagtcggaacacgcctacatgcgttcgacttatttgcgacatggtcaacaattcagta
+atttaatccaaaacctaaagtcagagacatgacactaaaatcacattaaggtcagttagt
+gaaggaatggctaaccagctagagaatgcatcattaacaggcacttattgtcaaatattt
+tccagatctaagcaacatcacgttaaaaagtacaacaatcacttaaaacacatcagtcca
+ggtgtaattagaaagccgcttagtaggcaagcgtaggagtataaatgtagacaatagtcg
+ggacttagcagacactggatgcagtcatagaagatcttgcataacacgttagggttagag
+ctacgaacgcccatcattaactgcctaaagcgtgcgtgagcttagcgctaacttttccaa
+cacgtttgtgatttcgttcataatgtatcaatttcacagtcatatacagggagtgtagaa
+aaatcgcaattaacatacgttgacctatttttgttcagagttcagttagagcctaatgat
+tcgagagcaataatcaggacagcctcataggaagtgtcaatcacttagaagctatattat
+tataaatcgctctttactgtcgtcgaaggaacgagcgagagagaatcagttgcctgcaac
+tggcttaacaatatgatacataaaaatattttcatcaccactaagacggtggaattcaga
+cttattggcaacttaggatgggactattaaataacccataagatgttgggataaagttac
+gaaacgaaagggatatagcctgttagataggaaatccccaataaaacatagccggcctcc
+acagcagtgatctattccgccacgcgatatctttataccacgcaatataccaataataaa
+ggttaaatgtggttgcgatttaaaaaagatacatatcagttgcaccgcgtagcaaatccg
+tatgtgaagcgtaacctagaattatagcgtctgcaagttctctaagcttcctctgcaaga
+tacaatatgactttttagcttttttactaccaaatctcagaatcttagaaacaggttggt
+acgtgctactcggaattcccaaagtaccctgctatatatgccattccttcattggtccgg
+gctcaccatggggccatcatagtaatagaaggtagtaaaactagttgatttccgactttt
+aacaatcactatcctgacccagatatgggttccgactggcccttactccagtaagggcag
+acacacagacaacgagaacttgataactttgaattctcaaatcgatcattgcaacgtgac
+ttatttactagcctactcctataattcatacgtcaaatacatttcaacggaggaagataa
+taagtaaatattcactaaataatggtcgaaggagtcctttgccaacataagtccacatat
+gcgctatagattttttcttggggttcatattcaataagataaacagcaagagtatcacgt
+cagcgagtcattgagatcttggctagcattgtgatagcatattctacctaaatggtagtc
+tagcacagagtggataagatatcagttagatatagacaagtactataacagatctcgctt
+cgttggattgtatggctagctttgatgatatgattttataaaaattgatccagacctgac
+ctggccaattatattcattttttatgagtaaaaatagataaccatgaaaatactcaagcc
+ccttaggacgtacaaagtggtaacataaatttcaggtgttattctgcaaccacacctgtt
+ttgggttttcaaaaaggctaagcagattggttttacagataatccctgaacactggtatc
+tcccaacgatgtcgttcccaacccttgctgaccttttaagctctgctgaagttttgtaaa
+ctaggcggaaaatatgttcgatagatccactcgcctgaggtagaaattcgtcttagtaac
+gcctctttggattacacagaatagtgtactgacacgtacactgctgcagcagccatacgc
+taacattaaaattcgttgagtctacatttgttgttattcggattatgttattgggaatag
+tatttttattcccctgcgtgaaaccacatggatagattagcctactcctaaagactccct
+tttggtctacggttcaattctcttactgagtttatgttcgtaattatatcggcgcagtga
+atctcctaattatcaccggagttaccagacgccatgaacttatggccagaaacattgcat
+gtggcctacataggattagtatcaagagtttacgtttgcaacgacatttgaccaacttga
+ccattcctgcttgtagaccgcgggaactcccctgcacgcgactatagaagttggtggtgg
+atgtggcttatgccgcaaatatggttttgaaaaaagtaatctattgcttgatacctgaat
+tgagacatgtataagggctattgccagatgaaaaactgcatataaggtcaaacaatataa
+gaacattatacataggatcttagcgttcctcaggatggtatacgctataaagtctagctt
+cagcagctaaggagttttgccagtgcggacttccgctggaagattaggtttaaccgccct
+gacatcttcataaggtcgggcctgattcaaacccctggagtgccgtctcatacttgaatt
+aatcgatggaaaacttcttctagtctaatattattattaacaaatgacggttcaataaat
+aacaccgtaagggtgggaaactgttaagtgatgaatcattttaacctatcatccattagc
+tacagataatgataccccgatccgactagggggtaagtggttgttccgttaggataaacc
+atgtaaaacgttagagggtttgtagattaattggtattccagataaatgaggtcagggcg
+agtgatcaattacactgaaaaattgtcagcttgcgcggtagttgttaagacagtataaat
+gaaggggattcagaagcaagtttctcgattgactgaatttataaaccagtcgtcaatcat
+gatttttgtgtcgattaaagcctaaatggtaatttaaaccattgatatttatcgagtcta
+taaatatctttggttgtatattacttcacaatcaccaattctaaatgattcttccactgt
+gcgggtggagatatcaggacgggttaaggttgacctacatcgttttgatacaacaaaaat
+caaagcacatggctggggacttctcgatactatctttgagatagtacgggcaagagtggg
+tgacgcctccctacattttcaagtctatcggataacttctcggtaaaacgctcgcgatat
+agttttaaagcattgatttaatccacgcaggagcaagttttaccggtcgaatgagaaaat
+tcaacgtaagtgtcatatccagtcatggttagccaaaagcatgggttatccaaaaggaat
+aaaacagctcttcaacaaagagatgaggcttcataacttcgatgaatgcgtatggttctg
+atatatagatcgatgcatgaggacactttattttagccggcgaattaatggaatccatac
+gttacttatttggacatgacttctaggtgtttttgctgtcccgtttagcgatatttacag
+attagtatttcgtttctcatagttaattgtatctagatactaactcgttgaagacgcata
+ccttgccatttgtacaggacttaactgttccgtgcgtaatttgaatttcttataggttct
+tcaaggcacgaatacctcactcatgaccgttcatactctagttaaggtcgggaatactac
+gtatgcagggaattgtaacctaggagatttacaactctttaaacaagagtcgctgaggtc
+caggatcaaaacactgaatctcctaacttcgggtgcctccgtaaatcacctagaaaccta
+ctcatacatttgcaattttgagatgtaggcgaaagagagaaatctgctttttaacggtat
+ctcttgggattccttttaaaaacacataacgatagtaatgtaccaagtaaccaaaagctg
+ggatgtgtctgtgtactgatccgccgtgtcagagtagtccgccatgaatattgacgtcaa
+ggctagtgtcatcaggtattgatgttcattgtaaatgaaggaatgaactaatgtcaccaa
+gtaaagggggtgaaaatgctccccagggttctacagacatagagatggtcagaacacgac
+ccccctctcaacgcagtgtatttgaaatatatggacatatctaccttattctgtaatttt
+agatgtgttctgtgtataccgatattgataagtcaataggcttgattacgtatcttaaga
+caaatctgtttcgcaagtaggaccgcatctttcagattgtttctttttatgccataacct
+gcccaggaattcaaaaggttatcgatacccgatatgctgtgaattattattctaatggcc
+actcattcctgcttatatctggaattggcatgaatatcttacaacctaaagtctggcgtt
+gcgccagttctacttcgtaccggacaccatctccagtcgttaaccgaaggtgggtacgtc
+acataaaagttcattagaccacactttgtgccgacgtatatagatatattacacgtatag
+ggaatgttttctcctaggtgacccgaccttctactaaggttgtacatcgtataatggccc
+attaactacgaggaaagtggtattgacctggtaatgcacgttcttcgatatataccgacg
+aggtaaagtctactattgcaaagtttgacgttatactgataagtttagatttccctggat
+cgcgcatgaacaatgtatgcgttatctgccatatataacatgttacaaatccttggggat
+actatcgctactatcatcggaccaaaattaaataggctagtgtcttatcagaacatcatg
+tttaccgaactgatctattttccaatttaagctgatattacgtccgcgtatttattttag
+ttccccggatgacgattatctgagctacatcatacaagttagcatactcgccggtgcatt
+gatttcttatttcgctatatcttcaagttcacaggcttcatatagttccaattagcagta
+taattaggttttgtaactttaaccatactttataaaaggttatattgcacaactgatcaa
+gcatccgctataacccgagctttaccagttagcggctaataacaaataagatgacttcgt
+gtcatacgaccgtcatgatcatgctctaacttaggtgggaaccaaatttaggcaatgggt
+agtaataagtataaaatgataccacatatactataacaatgaaattatttgtaatccggt
+ttgccaacgtatcccccttcgcgataaattaatgacatagggtcatccatgtgccaatcg
+tgtgtgccaaaatctcaaattcaattatcatcaatattggccaagtgttataagcgttga
+aagtgatataggccgccaaaaagtagtctacttaaaaaccaatatttatcgttcgttatt
+gctggtagtacaacatcacgagcatttctcttttgagttgatttatactatatctgctga
+tgtgattatgtcccacttacccagaatattaagaaagtcctagattgtaggtatacttga
+ctataaatataatttaagactatacaaataatctggctacattatgccatcgtagaaact
+gataacgtagtaacgtcggacactagattttggtcggggagtaatctagcatactaacga
+atttgttaaatccgctgaaagtatatgtcattacctgcttggcctgtcttcaatacgttt
+agactattaaggactcatttcgagatccagtattaattatacgcatccatatttatactg
+aagacggattgagttaggacgacaagctaaacaaatattaagttaaggattagtattata
+ttgtagaaactcgtcgggttggaacgattcatcatcatagaatgcgttacttattcagag
+agacttaattcggttatgactggcagctcacctggaaagtaggtgaaaggcaacagaaga
+atattgttgactgaattctacgggctacgaacgtaattacaaagcggttcgtaaagagca
+taaagatcaatacaatggatctctacagtattacgtaaataacatacataaacctggtgt
+tgattcgactagctcatagattaatcattaattgaagctacgaagacgcggaagtctgcg
+gagtgagcaaacagtaatcgactgataaatgcttataatatcgcgcttaaatgccgcatg
+gtgtacattaacgtgggggtagtcaaaggaatatatttactaggaatattagttatgcaa
+atgttgtgtcaatgtgatgtgttttatccagacattggatgcatggctgtgggggcacag
+gatacttaccattagttcacctacaagcggcgtgagagggtctcagttttagccagcgca
+gagaagtacgggcctttagacgattaatgctagaattgtcataaacctcgtgaaaagcta
+gttaataatcatggtgctagaagaacacaacttttctataaaccagttctcgactgacag
+tcgtaactcactatatcgccgctttgtactgtcgcaaaaaaacctcacatagaaagaaaa
+atctactgggtgcatcagtagagatcgtgttctgagagataaatacaccggatacgatct
+gcatcgagttcatgtattaggtcaagcttgggactgttgtgccagtagcattttttaaca
+gtcaaagtagggtgagacacgtcatatcataatatatgccatcgaggtttaaagtttata
+tgataagctagcatgcgttgcaatcgtattcttgaatgctccgtggtttgtactaattcc
+tttatagactgagtgtatcgtacactcggtacaattacaaaggatggaagagcaaatagg
+tcttcaattataacagtaccccaccttaatctaaaaaccagcttcaattagtattaattt
+cgccaggagtatatatataaatatctaaagactaaaagactcgtacttttacaacttacg
+tcgtagcataattaaatcatgggtaaatgtcatcagtaagtgcattagaaatactccttt
+gtaaggatacagtgaatgtgtctcagcaagtcagtagaaatggaaattcatactcgatta
+aggcctataaaactgttgttggtatctacagagtgattaaaattagtgaatcagattacg
+aaaatgttttcccgctcgcacttacgcgtttagacaaaagtacaggtggtacaattggct
+gtagtagaattttggtataaaataggtgataaaccggatgggtgtgggcgaattcaaaag
+cggtttttgttccatagaactatgtagttggttataaaggttgtaatctcggagattagg
+ttagggcttaatcagaatagtaacaatttctctatgtaaagtacagtgggtgatcgtatg
+agttcacgaactcttaatgccatgcctggacaggataaacaatacgcatataacttgacg
+atcgagcttatatcgacctatttgagaagtttaacgggtcgatataatatacaggtctta
+atagccgattttttctagaaaagcaatcctatatcttagttaatcagatcaaccccgtga
+acgatatatcagcaaactgaacattgtatacaacattcctttttgtccgggtggggactc
+catttaaagtatctcacctagaactcagcggtaatagatgcagtctcttgcccagttacg
+gtaactaaatgttgatacttagaattgctaaattttagtctagacatttccaggtaaacc
+ggtagacgacaatttctctgtcatctgtcataagatcgcttagtgtgctcaaattgcaat
+tgagggccctactatagacaatcatcagactttttaattaaatagttttccatgaatgtg
+ttgtcaaggcggaccccttcacttttatcacggctcataaatgtcgtatgactgtagtcg
+gtagcggccttcgagtcttcaggggaaatggaaaagaaattaggcttctaagatggacta
+taatcgattaggctaattccgttcgcaaatcacagaagcaatcttactcaaaattgttgg
+aatcgatagcgaacgcgaccgtgaatgtttaaaagtgctcgcacagaattacccaatacc
+tatcatcacgacttaaatacccaaagcagttgtagtcgcgtaatagattaagtctgaagc
+ctagagacaaagggatactgggcggggaaacctgctccttcacggtaacatggtaacaac
+agaatttggttaaggttaaaacgaaatatactcggagtgaattactgttaggtttcgtca
+tcggatcaataagtagtttccgtgaagacactcttatattagatctccgaaattctgacc
+cgtgcattaggcacttggtaggagattccatttggaacttgctcaatgtaagccagtaat
+gttccgaaataattcgctgcaggagcgaggagccgctgaataaaggaccctcgcatcttg
+ttaccttatggttgagggtcaccgttctctgcgtcaattccagagctggagatacattca
+tcaacgttacctacgcacagaataaaaagatcgagcgctaactcgttttcctaaacacaa
+cggatttagacaaattaccgaatgcgccggagagtagcatcttagtgtcatgcctatcat
+ggcggctcagtacgaagagttcaggcatcgaatattgtggtagcccgcactcaaagttcc
+gccattaggtaagctatatattgtggtcagaacttgaggacaactatgagctactaaaaa
+taaacaattttgtcatttgttctagatatgtggcattcatcgaacgcttgtaccagaagt
+tacattcgcagcgtgagcgaataaacccgaatgagcgtaacattatcaataacatatagt
+tcagatagagaacgaggtattcgacagagaattacccaacattggttattaatctatgca
+gaataatttagataatgtcactacataatattaggaccaaaaggtgattccccagaagac
+aaaacaataaacaatctcacatattcgctagtacctatgtatgggtatgatcttctgatt
+ggacggggataatttccaggtatattaaaacttattaccataatctagacctaagagagg
+ttatataagtaaagagctgtgttccgatagaaaaacccgaccttaaagacttgcgaagta
+aattttgctttaacaaaaaaacctacgtaagggaatattctgtataaactgaaaagtcag
+gtgtaactacatgagtcatgtcttcgattaattacaatgcgatctcgttattctgatcaa
+ctaatatcataaactgccactacatcttgtacaatcattcgcaacaatacttttatgtgc
+taaggtcacgtgcttcctctgctatgctgatttaatcagattcataaaggaatacgaata
+actctggatccattaccacgcaagggatttatttacggctgattactttttggctgttga
+cagaactgccatgaaagtaagatgtcgcatcttgcataaataatagcacctaatatagcc
+gacaaagtgattccgataacagattttaagttgtccagccttgagactccatgaagaccg
+cttgggagcttccccgtgattagaagaatctaaatcccaagtggatggggggagtttaaa
+tctcagcaccaacaaatagtacttcctctcagagcgcgtcatggtcgaaggagcctatcc
+tgatagaggtttgaaagcgcacgcgcatttaactgtcatattaaattggaatctcgtaag
+tgtcggcagtacgacaaattttaactgatgtcggtatacggagaagaaggaagcacgcat
+tgaagcagctacgcagaactgagaagatgacactctaagatacaattaatacaaaaacgt
+tttaagcccaatctatcaacagatgtaagatgtctaatacacaagaataaaaccttcatg
+tcccgatgtataataacagctttatttctgctggtcgaggtgaagtagtggaaattactc
+catcttgctgcgcgtctttatagtgttggctactctgtaaccgacgcgtccatccctctc
+tcctagtgatccgtatatccaattagaggataaccaacatctgcgttaccgacgaattta
+aatttttcgactatttaattccgttcaaacccgtattcgtagtaagtgtttcatagattt
+atgaccgacatcgtgtacgagttgcagtgcatatgtagataccactaattgctgatctag
+gatacatgctttataaacatgcttacttggctattttatttactgtcatgtgggggtttt
+tattttcaacaagtatgtgctaccattggataatctggcttcaaattgaagatatgcgtt
+ccaaacttgtctactgtttgctaagtaggagttgtcccattagaactacgcagcacgtgg
+tttgtgatcgaaaagaataattggcaaatacgaggctagccttcaaatttaatgcagatt
+actcctcagaaacacacgtaagcgacgaacgtgatgtttactacacaatgcgtatcatag
+aaattcgtgataatttttgttccaacctttgaatctagactgagtggaaaaagatttcac
+cgggataccgtttatgctggttttaaaaactcgtcgaatcatcttataactgcattcaaa
+tggatttctcaatcatctgtacgtcaactgttttaacaataacgtcagaataaaccggca
+caatgagacggcggtctttcactacaccacacccttaggattataagtgacgtgtggatt
+cgaattctaaggtgacgggatctacaagcctcagctacattaggtctgaagatctttcgt
+atagccgcgtatgttactgtttggatatgggttatgctaatcaacagttgacagcgagtg
+aaacggccttgcgacctgaaatctttacggttaccttttgattcaagacaggatcgacga
+tggaccacgtgaaatgaattcaaaactgtaacatcgcttgtgcctcagcgaccgagtaac
+gacaagttcacatcctctatgcaactatcattgtggtcattaaggtattcaagattaact
+aagagtcgaccatatattctagagttttacaattaggaaccgttagtctagactaggagc
+gtgcaacatcgcaggaggtgtggactgtcttgacccaagttgcctgacacatagtgtctt
+ttgcttcatgtccttagcaatgcgatacctcaatcgtagttttatcgggataaataacat
+ggtgtttaaccctattaatggtttctattaatctaaattgtaaggcagcccttgggtcga
+aagcacattaggccacatacacagtatgaaattgttcgagtgtccagaccataattgact
+accatggtacacggtgttgctattatgactcccgcaaaactcttgacagagggaattttg
+gtacattgatgtaatcgatgatttaacagtaggaactagacgtcatccgttagactgagt
+tccgacatgctcaaattgtcaggatttttatccaataactaatggctctcacatgtaaat
+aaaatcacattaacgtcacttagtgatggattcgctaaacagatagactatcattcatga
+actggcactgtttcgattatatttgcaacatcgaacatacttaaagttaaatacgacatc
+attcaattaaaaaaattcagtacacctctaatgagtatcccgctttggaggaaagagtag
+cactttaaatggacaatttaggccggactttcctgtaaatggatgaagtcattgtacagc
+ttgaataaatcgttagggttagtccttacatccaccatatgttaatgaataaagcctgag
+ggaccttagagctaacttgtccaacacgttgctcatttacttaataaggttgaaatgtat
+cagtaagtgacagcgagtgtagattttgaccatttaactgaccttcacagttttgtcttc
+agacgtcacttacaccataatgatgacagagcttgtagatgcacacactcattcctagtg
+taaatcaagtagtagctagattattataaagagatattttctggcgtcgaacgtaacaca
+gagagagtataaggggcatgataatggcttatcaatatgtgtaagaaaaagtttttaata
+tcatctaactcggtggaatgcacacttatggccaactgaccttgggacgagttaagatac
+cataagaggttgcctgtaagttaagataacaaagggatattccatctttgtgtgctaaga
+acctatttatatttgcagccataaaaacctctgtgctatgcagccaccagagttatttat
+acaaagaaagagaccatttagatacgttaattctgcttgcgatttattaaacagacattt
+cacgtccaaccactacaaaagccctatcgcaagacgatcattgtattatagcctatgcaa
+cgtagctaagcggccgaggaatcataaaatatgaattgttacattgtttactacatatga
+tcacaatctttgtaaaaggttcgttcgtgatactaccatgtacctaactaacctgagata
+tatgcaatgacttatggggtcagcgcgcaacatccgcaaagcatagtaatacaaggtagg
+aaaacttctggatttcccaaggttataatgctctatactgaccaagagatccgttacgac
+tcgcaatgaatactctaagggcactcacaaagaaaaccactaattgataaatttcaatga
+taatatcctgaattgcatcgtgtatgagttacgagaagtcgcatttaatgaattagtcat
+agaaatgtcatagcaggaacataattactatattttaacgatttaatcgtagttggagtc
+ctttcccaaattatgtcatcagttccgatttagatgttttcgggcccttcttagtaaaga
+agttaatatccaagactagctcctcacccacgcatgcacatattcgcgagaagtctgata
+gaatattcgacagaaatgcgactctagctcacactcgttaactgatcaggtacttataga
+caagtacgttatcagatatcgcttcggggcattgttgcgctacctttgtgcatagcagtt
+ttgaaaaattgttcaagacctgaacgggaaaatgatattatttttttaggaggaataata
+cagtaccatgtaaatactcaaccaccttacgtacttcttacgccgaacatatatggcacg
+tgttattcggctaacaaaactgttgtgccttttctataaggataagcagattcgttttaa
+acatatgacctgtaaactgggatctacaaaagaggtacttaaaataaattgcgcaacggt
+ttagatctgcggatctttggttaaagagcaccattagatgtgccatacttcctatcgcct
+gagcgagaatttagtctgaggaaccactcttgggatttaaaacaattcggttaggacacc
+tactcggcggatgaagcaatacgataacattaaaagtcgttcagtctaattttggtcgta
+gtacgatgagctgatggccaattgtatttttattaacagcactgaaacaaaatggagact
+ttagactaatactaaagtctcaatgttcgtcgaaccttaaatgctcggaatgaggggatc
+ttcggaagtatagcgccgaagtgtatctcattattataacaccagtgtacagacgacatc
+taattatggccagaaactgtcattgtgccattaagaggattagtagatagtctggaccgt
+ggaatagaattttgaccaaattgaccagtcctgcttgtagacagcgcgatctaaactgca
+cgagaatatacaagttggtggtgcttgtggctgagcacgctaagatgcgtttgtttttac
+gattctagtgcttcttaacgcaattcagtcttctagatccgctattccaacatcaatatc
+tcaatttaaggtcaatatatataacaaaattagacagagcagctgacacttacgaagcat
+cgtagaaccgatatagtcgaccttatgatgatatggacgtgtccaagtccgcacttccga
+tgcatcttgacggtgaaccgaaatgaaatcttcattagggcccccatgtgtcaaaccact
+cgagtcccgtctctgaagtcaagtattactgcgaaaaattcgtctactattagtttatta
+tgaacttatgacgcttaaataaattaaacagtaagcctgggaaaatgttaaggcaggaat
+ctttgtaacagttcataatgttgctaaagattatcagaccccgtgaagacttcgggcttt
+gggcttcgtaccgtagcataatacatctatatagttagaggcttgcgtgttgttgtgcta
+ttccacatatagcagctctgggcgactcttcaatgaaaatgaaaaatggtaacctggcga
+cctacttgttaagtcagtttaattcaaggggattaagtaccaagggtcgagtttctctgt
+atttattatactgtaggcaagaagcttttttggcgagatttaagacttaagcctatggta
+aaaatttgatagtgagcgactatagtaagagatttgggtggttagtaattaaaattctcc
+tatgctaaatcaggcgtacaatctgagggtgcacatttctcgacgcgtgaaccttcaccg
+aaagcgtgtggattatacaaatttcaaacatattggcggggcacttatccataatagatt
+tctgtttgtacgccaaactctgcctcacccctccataaattgtattggctagaggttaaa
+ttctccgtaaatagagacacatatagttttatacaattgtttgaatcaaagcacgagaaa
+cttttaaccgtacattgacaaatgtcttcggatggggcagagcatctcttcgtgacccaa
+atcaatcgctgagcaataagcaagaaaacacagattatacaaagagatctggatgaagat
+attcgtgcaatcactatcgttatgttagagagttccatgcatgaggactcgttttttgac
+caggagaattaagccaagaaataactgacgtatttccaaatgaattctacgtgtttttcc
+tgtcacctttagccagtgttaaagatgactatggagtttcgaataggttattctatagac
+attataacgagtggaacacccataccttcacagtgctaaaggtaggaacgggtacgtcag
+gtagttcaagggattttaggttcttaatccaacgaagaaataacgcatcacccgtcattc
+tattgttttcgtcgggattacttagtaggcagggtattctaacctacctgagttacaaat
+ctttaaaaaactggccatgaggtcatggtgataaaatctgaatcgcctaaattcgcgtcc
+ctaaggaaatatactagaatccgtctcagaaagtgcaaaggttgacttcttcccctaaca
+cagaattctcagttttatagctatctagtggcattcctttttataaaactttacgtttgt
+aagggtccaactttacaaaagctcggatgtgtatgtgtaatcttccgccgtgtaagactt
+ggaacccatgtatattgacggcatggcgtggctaagcaggtattgatcttcagtgtaaag
+caaggtatgttctaatctaacaatgtaaagccggggattagccgccaaaggggtctaatg
+acatagagatgctctgaaatcgtaccaactataaaagcacgggatttgaaatatagcgac
+agatcttccgtattctgttagttgacatctgtgctgtctttaccgattgtgatttggctt
+tagcagtcatttagtttcgttactcattgctcgtgcgatagttccaccgaatatggcaca
+ttcgttctttttttccattttactgcaaaccttttcaaaagctgatcgataccactgatg
+atggcattgattagtcgattggcaactatgtcctgcttatatctccaattgcattgaata
+tagtaaaaaataaaggctcgccttcccaatgggctacggagtacacgaaaaaatcgcaac
+tcgtttaaccaagcgccgtacctaacatataagtgattgagacaaatagttctccagacg
+tattgagatatatgtctcctataggcaagcgtttctaattgctgaccagaaattagaatt
+aggttgttaatactatattcgaccattttattccacgaatgtgctattctactggtattg
+ctccgtatgcgatatataaccaacacggaaagtcgtcgattgcaaagtggctccgtagaa
+tcatttctggtcatttaccgggagcgcgcttgaacaatggatgcggtatctgccatattg
+ttattgttaaaaagacttccgcttactatcgcttcgatcatcggaaaaatattaatgagg
+attgggtcgtataagaaaatcatcttttcagttcgcagatttttgccaatttaaccggtt
+atttcgtcagacttggtagtgtagttacaagcatcacgattatatcagctacagaattaa
+actgtcctgactcgacggggcagtgtgtgagtattgcgctatatattcaaggtaacagga
+ggcatataggtcatagtacaaggataatgaggtttgctaactttaaaaattattgattta
+acggttgattgaaaatctctgcaagatgacgctagaacacctgatgttcaagtttgccga
+taataacatataagatgaattactgtctttagaccctcatgttaatccgctaacttaggg
+cggaaacaatgttaggctatgcggagtaagtactatattatgataccacatagaatttaa
+cattcatatgatgtctaatacccgttcccaaccttgcaaccgtcccgattaattaagcaa
+ttacggtcatcaatgggccaatcctgtctcaaaaattatcatattcaaggttcagctatt
+ttggcaatgggtgagtaccgttcttagtgatttacgaacccataatctaggcgacttaat
+atacaagatttagagttacgttttccgggtagtacatattaacgaccatggatcgggtga
+ggtgttgtattagttatctgatcttgtcagtagctcccaatgtcccagaatattatgttt
+ctactagagtgttcgtatactggaatttaaatattatgtaagactagacaaattttatgg
+atacattaggccatcgtagaatatgatatagttgtaacgtccctctatagattttcggag
+ggcaggtatattgcttaataaagatgttcggaaatcagcggaaaggatttgtaattaact
+gatgcgcagcgcttaaataagtttagactattaagctatatgttcgacagcatgtagttt
+tttttaccagaaagtgttatactgatgacccatggaggtagctcctcatgataaaaatat
+tgttacttaagcattactattatagtgttcaaactagtaccgttgcatactttaagaatc
+agacatggcgtttcttatgcagacacacttttttagctgttgacgcccacctcacatcca
+tagtaggtcaatcgcataagaacaatattctggactgttttattacccagaagaaagttt
+tttctttccggttcgttaagacaataaagatcatttcattcgttctcttaacgatgaact
+aaagtacttaaagtatccgcctcttgtttcgactagcgcatagtgtaataattaaggcaa
+gataagaagaacaggaacgcgcacgtcggagataactctaatagtctctttattccgttt
+aatatagcccgtaattgcaccatgcgctacagtaacggccgccttcgcaaacctatttat
+gtaattccaagtttaggtatgcaatggttggggcaatgtgaggggttttatcaagacttt
+cgttgcttcgcggggggcgcaaagcagactttacagtagttaaccgaaaaccgcagggag
+tcgctctaagtgttaccaacccctcactactacgcgaaggtactcgattattccttgaat
+gggctgaaacatcgtgattagcgtcttatgattcaggctgatagaagaaaacttattttc
+tatattccacgtatacaatcacactcgtaactaaatagttcccagcgttgtaatgtcgct
+ataataaataaaatacaaagaaaattcgtctgggtgcataagtacagttagtcgtctgtc
+acataaataatccgcagtcgatctcattacaggtattgttgttggtcaaccttcgcaagg
+tggtccaagtagcattgttgaacagtaaaactaccgtcacacaaggaatatcataataga
+tgccatacacggttttacttgatatgtttacagtccttgagttgcaatcgtagtattgtt
+tcatccggggtgtgtacgaagtaatttagacaaggtgtgtagcggtcactaggtaaaatg
+acttaggatggatgagcatttaggtattctatgataacactaaccatcatgtttctaaaa
+tcctcaggaaatttgtattattttaccaacctgtatttatagaaagtgcttttgacttaa
+agaagccgaagtgttcaaattaaggagtacctgattgaaagaatggggaattgtaatctg
+taactcaattacaaataagccgttctaaggattaaggctttgtgtctaagcaactcacgt
+gaattcgaaattcatactcgattaacgactttaatactcttctgcgtatctacagactca
+tttaaattacggaatatgttttcgtttttggtttccagctcgcacgtacgcgtttacaaa
+taaggacacctggtacaattggctggagtacaatgttggtttttatttgctgattatccc
+gatccctgtgggcgttggcataaccgggttttcttcaagactactttcgtgttgcttata
+tacctggtaatatcggtgagtagcttagggcttaatcacaatactaacaagttctctatg
+gattggacagggcggcatccgttgactgaacgatctattaatccattccctgcactggat
+aaacaagacccatttaaattgaccatagagatgttagcgtcatatttctgttcgtgatag
+ggtacatatattataaacggattatgagcagtggttttctagaaaagcattcatagttag
+gagtgtatcagatcataccactgaaccatagagcacaattctctactggctatacttcat
+tcctttttgtccgggtggggacgaaatttaaaggttctaacctagaacgcagagcgaatt
+gatcaaggcgctggccaagtgaacggttctaaatgttcttaatgagaattgcgtattttg
+actattgacagggcatcgtaaaccgctactcgacttggtatctgtaatctgtatgtagat
+agagtacgggcctataattcaaattcagccaccgaagattcacaatcttcagacgtttga
+aggaaagaggtttactggtatgtggtgtcaagccccacccattctctgttatatccgagc
+attaatgtagtttcactgtactacggtcacgccgtagagtcggcagggcaaatccaaaac
+aatttaggctgagaagtggcactataatagtttagcctaagtcccttcgctaataactca
+acaaagatgacgcaaaagtcggcgaatagattgcgttcgcgtaagggtatcttgaatact
+gatagctctcatggtaccaagaactttcataacctctttatttaccaaacctgttctact
+agcgttagtgttttagtctgtagccgacacaaaaaccgagaatggccggcgtaaccggcg
+cctgcaagctaacatgggatcaaaactattggcttaacgtttaatcgaatgagactagca
+ctgtattactctttcgtttcggcagcggatcaataaggaggtgacggcatcactctctta
+tagtagatatcacttattctcacaacggaagtaggatcttccgtcctcattaaatttgca
+actggctcaatgtaacactgtaatgttaacaaagtatgagctgaaggtcagagcagacga
+tgtagtaaggtccctcgaagctgcttacagtatccttgaggctcaacgggctatgcggaa
+attccagacctcgagttacattatgaaacgtgtcattccatctcattaaatagttcgtgc
+cctatcgccttgtaatataaacaaccgtttttgtctattttcccaaggagaaggagagta
+gcagcttagtggcttgcctatatggccccctaagtacgtactcggcacgcttagaagatt
+gggctaccccgcactatatgttcccaaagtaggtaacctagatagtgtcgtatgaaattc
+aggtcatcgatgagagtataaaaatatacaattttggcaggggttatacattgcgggcat
+gaagagtaacattggacatgaacggacattcgaaccctgtgagtttaataccctatctcc
+ggatcattataaagtaaatatacgtcacttactctacgtgcgtttagacagtctttgaaa
+ctaaattggttatttttctttcatctagatttgtctgtatctaactaaattatagttcca
+cataaagctgattcaactgaagacataaatataaactttctaacatagtagcgaggaaag
+agctatgcctagcatcggatcatgcgtccgcgagtagttcctggtagagttaaaagtttt
+tccagaatctagaccgaacacagggtagtgaacgaaagtgcgcggtgaacatacataata
+ccgaacgtaaacaattccgttcgtattgttgctgtatctatatttcctacgtaaggctat
+ttgatctataatatgaaaagtcacgtcgaaataaatcaggaagcgcttcgagtatgtaca
+ttcagatctccttagtatcatcaaattatagattttacggccacgaattattggtctaga
+tgtcccaaaaataatttgatgtcagtagcgatcgtgcttcctcggagttgaggttggaag
+aagagtcattatgctataccaagaactctccatccagtacctagaaaggcaggtatgtac
+cgctcattaattttgcgatcttgacagatctgcatgcaaagtaacttgtaccagatggct
+tttataatagaaactaagtttcccgaataacggtgtacgataacagatttttaggtgtac
+agacgtctgactcaatgaacacacattgggacctgccccgggaggagtagtagataatta
+ccttctccagcgcgggtcttttaatatcacaacataaaaatactaattaatatcacacac
+cctcatcctcgatggagcctagcatcatacacgtttgatagacaacgccaattttactgt
+aatatgatattcgaatctagtatgtggacgctgtaccacattgtttaaaggagctccctt
+taccgacatgaacgaagcaagctttgtacaagatacgaagaactcagtactggtaactat
+aagagacaatttatacataaaagtgttaagaccattatataaaaagaggtatgaggtctt
+tgtaactacaataatacattcatcgaacgatggagaataacagagttatttctgctgctc
+gagctctagttctgctaatttctcaatcttgatgccactcgtttgagtcttccattcgct
+cttaacgacgcgtacatccctctctcctactcttacctatatcctattactggttaacct
+acatctccgggaaagacgtaggtaaagtggtccacgattgtattcacttataacacctag
+tagtactatgtgttgctgagagtgaggacacacttactctacgagttcaagtccatatgg
+acattacactttttcagcatctaggtgtcatgatgtattaacagccgttaggggctattt
+gattttatcgattgtcggcgtgtgtattttcaacaactaggtgctacaattcgtgaatag
+gcatgaaaattcaagattgcagttcctatcttgtataatctttcctttggacgagttgta
+ccatttcaactaacctgcaagtggggggtcatccatatgaagatttgccaaatacctgga
+gaccctgaaaagtttatccagattaataataacaaacaaacctaagcgaagaacgtcagc
+tttaataaactatcactatcatagaaattcctgttaattgttcttccaaacgttgaatag
+actatcacgggtaatagattgaacacggagaacgtttatccggcttgtaaaatatcgtcg
+aatctgctgataactcaattatattcgatggagaattcatatctaccgcttagcttttaa
+aaattaagtcagattattccgccacaatgagaaggcgcgagtgcactaatcaaatcactt
+aggattattacggacgtctgcattacaatgctttggggtagggttatacaagcatatgat
+tctttaggtctcttgatcgggcgtttaccaccgtagcttaatgttggcatatccgtgatc
+ctaatattctgttgtcagcgtgtgtataggaatgcacaacgcaaatctttaagctgacct
+gttcatgaaagacaggagacacgaggcaccacctcaattctatgcaaaactctaacatag
+cgtggcactatgagtacgtgtaacgacaaggtctcatactcgatcctaagataattctcg
+tctggaaggttttaatctttaactaagagtagaacttagtttattgacttttacaattag
+gatacggttcgcgactctaccacagggcatcatacctggagctctgctatctcgtgacca
+aagtggcagcacacatagggtcgggtcctgcatctactgagcaatccctttaagcattcc
+tagtttgagagccatttagatattgctgtttaaaccgattaatggtttctattattataa
+agtgtaacgctcccattcgggacattgaaaattagcaataagacaatgtatgatattcgg
+cgagtctcaacaacattatggtctaccatgggacaaggggttgatatgatgaatccacaa
+aaaatagtcaaacacccatggttcgttaagtgagggtatccaggtgttataaggacgatc
+tagaagtattcaggtacacggtgttcagacatgctctaattgtcaggttgtttataattt
+aacgtatcgctctctattctaaataatataaaattaaccgctcgtagggatgctttccag
+taaaagatacactatcattaaggttatgcaaatgtggcgatttgatttgaatcttagtac
+attcttaaacttaaatacgtattatttaaagtaaatatattatctaaaccgcttttgtct
+atccacatttcgtcgaatcacgacctcgttaatgcgacaatttacgaccctctttcatct
+aaagcgatcatctatttcttctgattgatgtaatactgacccttactccgtacatacaaa
+tgatggtaagcaagaatgactgacgctcctgtcacctttcgtggcaatcaactggcgctg
+gtactgaagtagcttgaaagggatatggatgtgtatgccaggcttcattttgacaatttt
+tctgtcctgctcagtgttgtctgaagtcgtatcgtacacaataatgatgactctcattgt
+agatccaatcacgctttcctacgctaatgaaagttctagatagtgtaggtgttagacaga
+ggttagcgcctacatccttacacacacagtgttgaacggcaagcataatcgagtatcaat
+agctgtatgtatttgtttggaatatcatatttctcccgcctttgaacaatgatgccaaaa
+tgtcctgccctagagttatgataaaataactgctgccctgtaacttaagtttacaaaccg
+atattcaatcgttgtgtcctatgaaaatatttatatttgcaccaagaaaatcatctgtgc
+gatgaacaaaacacagtgatttataaatacaaagagtacatttagttaccggattgcggc
+ttgacatttattttacagaattttatcggcaaaacacttcatatgaactatcgcttcacg
+ataagtctatgatagactagcattcgtagagaacaggaagagcaatcattatatatgaag
+tgttacagtgggtactacatatgagatcattaggtctatatccggccttcctcataagac
+cttggaaatatcttacatcagagatatcaaaggaagtatgggcgaacccagaaaaagccc
+caaagaatagtaattcatcggacgtaatagtctggttttaactaggggttattgatattt
+aagctaaaagagttccctgaacactcgaaatgtataatctatcccaactaaaaaagtata
+cctctaattcagaaatgtcattgagattagactgatgtcaatacgctaggaggtaagaca
+agtagaagtttttgatttaggaattgaaatgtaatacctccatcttaagttctatatttt
+aaagttttatgcggacttcgagtaagtgcacaaatgatggcataagtgcccagttacatg
+tttgcggccccgtatgagtaatgatctgtttatcaatctctagctactatcccacgaatg
+cactgatgccagtcatggcgcttacattagtcgacagaaatccgacgatacctatcacgc
+gtgaactgttctggttcttattcaattcgaagtgatctcagatacattacggccatgctt
+gcccttcatgtctgctgagcagttttgttataggctgaatctcctctaagcgaaattgat
+aggatttttggtggtcgatttagtctgtacctgcttattaagattcaaaatgacctactt
+cttacgccgaaatgatagggatcggctgaggaggataaatatacgctggtgcctggtatt
+tatccagaacaagttgcctgtgtatcagatgaactctaatctccgagataaaaaacaggt
+acgtaaaataaaggccgcaaagggttacatctcaggatcgtggcgtatagtccaccatta
+gttctgacttacttaatatagactgaccgagattgtagtatgtggatccaagcttgccat
+gtaaaacatgtcggttagcaaaacgtataggagcatgatcaaagaagagttaattaatag
+tactgcactataattgtcggcggagtaccatgagctgttgcccaattcgatgtttattaa
+cagcacgcataaaaaatccagacttttcaattagaattaactataaatggtccgcgaacc
+ttaaatgatcggaaggacgggatctgccgttgtatagaccccaactctatctaattttta
+taacacctctgtaatcaacaaatcttattatgccatcattatgtcattcgccaagtaagt
+ccagttcgagattctctggaccgtgcaatagtattgtcaaattatggtaatggaatcctt
+cttctaacacccttagaaaagccacgagaattgacaagttgggcgtgcttgtccaggagc
+aacataagtgccgtttctttttacgatgatagggattcttaaagcttttctctattctag
+atcccagttgccatcatcaatatctcaattgatgctcattatatagttcttatttagtat
+gtccagatgtcactgaagatcctgcctagaaccgatattctcgacaggatcatcagttcg
+acggggcaaacgcacctatgcacatccatcttgaccgtgaaacgaaaggaaagagtcagt
+accgacccaatgtggaaaaaaactcctgtccacgatatgtaggcaagttttactgccttt
+aattagtagtcgattagtgtagtttgatattatctaccttatagaatgtaaacagtaacc
+cggccttaatggtttggcaggattctttgtaaaagttaataatgttcataaactttatca
+gaaaacctgaagtagtccgcctttcgcctgcgtaacgttgcagattaattcgttttacgg
+agtggcttgcgtcttgttgtccgagtacacatattgctcctctcccccactcttctagga
+aaatcaattatgctaacctgcagaccttcttctttactatctttaatgcatgcccagtat
+gttcatagggtagacttgctatctattttgtataatctacgaatgatgcttggggcgcga
+cttttaacaattaagccgttgggtataatttgagagggtgccacgatagtaagagatttc
+cggcgtgagtaaggaaaatgataataggattaagcaggcgtaatagctcaccctcctcag
+ttctccaaccctgaaccggctaagtatgactgtgcagtattaattttgaatacatattgc
+agcccctaggatacattatagatgtctctttcttacccaaactcgcccgcaccaagaaag
+aatgtggattcgattgaggttaaattagccggaattacagacacagattcttgtttacaa
+ttgtgggaagaaaaccacctcaaacgttgaaacctacattcacaaatggattacgttggg
+gatgagaatcgattccggtcaaaaatcatgcccggagcaataaccaagaattcacagagg
+attaatacacttctccatgaagataggactgcttgcactatccttatctttgtgtcttcc
+ttcaagcaccaatcgtttggggacaaccacaattatgccaagaaataacggaaggtgttc
+caaatctatgagtccgcggtttcatcgcaacgtttcactgtgggtatcatgactttggac
+tttagatttgggtattctagagactgtagaaagactgcaacaacaagacattcacagggc
+gaaacctaggaaaggggaccgcacgttgtgctagggatgtttccttaggaatccatacat
+gtaagaaagaatcaaccgtaattatagtgttttcggccccttgaattacgtgcatgcctt
+tgctaaaagacctctgggaaatagattgaatattctggacagcagcgaatcctgattata
+tctcaagcgaatatatgacccgcaagaaggatttatactagaataagtctaagaaagggc
+attgggtcacttcttccactaacacacttttatcagttttataccttgagagtcccatgc
+atttttatatatatttaactttcgttgcgtaaaactttaaatatgatccgtgctctatct
+ctaatctgaacaacggtatcacgtcgaacaaatctagtggctacgaatcgcgtcgctaag
+aacggtttcttctgctggcgttagctacgtatcttctatgctaaaaatgtatagccccgc
+attagcagcaaaaccgggagaatcaaatacacatccgatgaaatcgtaacaaagataaaa
+caacgcgatttctatgtttgccaaagtgattaagttgtatcgtaggggtcagcgctgatg
+tcttttcagtttgggttttggatttaccagtcttttagtttcggtactatttgatcggga
+cattcgtccaaacatgatggctcattcgttctttttttcaattttaatcaaaaccttgta
+tttacctgatacattaaactgagcatcgcatggaggtggagattcccatatatgtaatca
+tttgatatcctattccattctttttagttataaataaacgctccactgcacaatgggagt
+aggacttcaccaataattagcatctactgtaaacaagcgccgtaacgaaatgattactga
+ttgagaaaaataggtctcaacaacttttgacagatatgtatccgatacccaagcgttgct
+aattgcgcaaaagtaagtagaattacggtcgtattacttgttgccaaatggttattactc
+caatgggctattctaatccgatggatacgtaggagagagtgtacctacaccgaaactcgt
+agtgggcttagtggctacgtagaagctgttcgggtcagttacagcgtgcgaccttgtaaa
+atcgatcacggtgatgaattattgttattgtttaaaagaagtcccctgaatagcccttag
+ataatacgaaaatttgttatgtccagtcgctcgtatatcaaaagattcggttaagttcgc
+agagttttgccaagtttacaggtgatttactaacacttgggagggtacgtacaaccatca
+cctggttagcagagaatgaattatacggtcatgtcgcgaagggcaagtgtgtgagtattg
+accgagttattaaacgtaaatgcaggcatttacgtcataggacatcgagtttgtcctttg
+cgaaatgttaaatttatggttttttccgttgagtgataatagctgcaacatgaagatagt
+aaaactgaggttaaactttcaccatattaaattatatgttcaattacgcgatgtacaaac
+taatgttaatcagatttaggagcgcgcttaatatgggtccctatcccgactttgtacgag
+attttgataaaaaatagtattgtaaattcatttgatggcgtagaaccgggcaaaaccttg
+aaaaaggacacatttaggatgctatttccctaagaaagcggaaaatcctggctcaatatt
+tataatagtaatggttaagattgtggcccaatcgctgagtacccgtcttacgctttttcc
+aacacataatcgacgagaatgtatttaaatgtttgagacttacgttttccgcgtacttat
+tattaaagtcattggagagggtgtcgtctgggtgtagttttctcatctgctcaggagcta
+aaaatgtaaatctattggttgtttctaattctgtcgtccgtgtaggctatttaattttta
+tggtacacttgaatatgtttagccataatgtagccaatactacaatatcagatacttgta
+tacgacctatagacttttgccgaccgctcgtagagtgatttagaaagatgttcggatagc
+acagcaatcgtttgcgaatgtaagcatgcgaagcgagtatttaactgttgactattttgc
+tatatgttactctgaatgttgttttttttaccagaatgtgttataatgatcaaccatgca
+cgttcctactaatcatataaattttgttacgtaagcttttctatgatagtggtctaaaga
+ctacccttgcatactttaagattaagacatgcactttaggaggaactcacacgttttgag
+ctgttctagcccacctataagccattcgtccgcaatcccataactacaatagtcggcaat
+cttttattacccagaactaacgtttttatttcccggtacgtatcacattaatcttaattt
+aatgcgtgagagtaacgatgaacgaaagttatttatgtttaagccgcttcttgagaatac
+agattactgttagaatgaaggcatcataactagaacaccaacgcgcacctcgcacattac
+tctaatagtagctttattcagtttaatatagacagtatttgaaccaggcgctaatgttaa
+ggcccccttcgaaaaccttgttatgttattccatgtggtcggaggatttgcggggcgata
+gcgctgggcggggatcaacaatttcgttcatgcgagcgcccccataaccagtaggtacag
+ttcggaaaagaaaaccccacgcactcgctagaagtgttacaatcacatcacttcgtaccg
+aagggactactgtattccgtcttggggatgtaacagactgattacagtcttatgatgaag
+cctcattcatctaaaattagttgatttattccacggatactatcacactcctatagaaag
+agttaccaccgtgggaagctagatataataaataaaagacatacaatattagtatggctc
+atgatctacacttactcggatctctctttttttataaccagtagatcgcattacacgtat
+tgttgttccgcatcaggccctaggggctcaaacttccatggtggataactaaaacgtccg
+tcactaaacgaagatattaatagatgaaatacacgggtttacttgatttctgttcagtca
+ttcacgggaaatcctaggagtctttcataacggcggtcttagtaggaatgtagtcaagct
+ctgtagaggtctcgacggaattggtatttcctggcatcacaatttacctagtattggaga
+tcacttaaaataatgttgagataataatcaggatatttctagtatgtgacaaacctctat
+ttagtgattgtgattttcaattaaacaagacgtaggggtcaaattaacgactacatgttg
+gaaagaaggccgaattgtaatatctaactcatgtactaagaagaagtgctttcgtttaag
+gctttctgtctaacattctaacgtcaattcctatgtaatactactgtaaccaagttatta
+ctcggctgcgtagataaagtctcatgtaaatgacggtttatctgttacttttgggtttca
+acctagctaggacgccggtactaattacgacacctgcgtatagtgcagggtgttcaatgt
+gcctttttatgtccggattataaccatccctctcccacttggaatatcaccgggttctta
+atgacttagttcgtcttccttattttccgggtaagatcgctgtggaccggacccattttg
+atctagtctaaaaaggtatatagcgtttcgtctggcccgcttacgttcactgaaacttag
+attaatcaatgcactgcactggattaacaagaacatgttatagtgtactgacacatgtta
+gactaagaggtctgttcgggttagccgacttatatgtttaaccgattttgacaactgggt
+tgagagataacaatgaagagtgaggactgtagaagatcttaaaactgtaccatagtgctc
+aattcgctaatggcttgaattatttaattgttctaaccctggcgtcgaatttttttggtt
+cgaaaatacttagcacagcgtattgttcaacgagatgcacaactgtaccgttagaaagcg
+gcttaatgacaaggcagtattgtgactattgacagggaatcctaaaaagctactcgaatt
+ggtatatggaagaggtatgtactgagaggtcgcgcctattagtcaaattctgccaaagaa
+gagtcaaaagcttaactagtttgatggtatgaggtttaatgctaggtggtctataccacc
+aaaaagtatatgggatatcccagaatttatcgactttcaatcgtctaccgtcacgacgta
+cactaggcagccctaatccaaaacttttgaggatgagtactgccactattatactgtacc
+atttgtaacttacattttatatcttcaaagaggtagatattgtcggccattactgtcact
+tacactaagggtagcttgattactgatacctctcatggtaaaaagtaatttaagaaccta
+tttttttacataacctctgctactaccgttagtgttttagtcggttcaagtcacaaaatc
+cctgtagcgcacccctataagcagaaggaaaccttaatgcggataaaaacttttgccgga
+accgttaatcctatgagaataccactcttggaatcggtcctttaggctgaggatatagaa
+cgaggggaacgcatcaatctaggttaggtgagagaactttgtatcaaaacgcaagtacca
+tatgccgtcctcagtaaattgccaaatgcagaaatcttacactcttttcttaactaagta
+tgagagcaacctcactcctgaacagcttgttacctaacgagaagaggctttaagtagcct
+ggagcctcaaccggatatccggatttgactctcatccacttacatgatgattacggtcat
+tacatctcatgattttctgagtgccctatagactgggaatttaatctaccctgtttctat
+ttgttaacaaggagaaccactggtcaagatgacgcgcttccatttatgccaccataagta
+agttctcggaacccttacatgattggcctaccaacctatatatgtgaccaatgtacggta
+catagagtgtggcctatcatattcaggtcatcgagctcagtatttaaagattatatggtc
+gctgggggtattcagtgcgcgatggaagactaacattggaaatcaacggaattgacaaca
+cgctcactttaataacctatctcaggataagtttaatgtaattagacggaactttctcta
+actccgtgtactaactctttgaaaataatgtgggtatttttatttcatctagatttgtct
+gtatcgaaagaaagtattggtccaaataatcctcagtaaaatcaagtcataaatataaaa
+tttagatcttaggacagaggaaagtgctttcccgagcataggatctggcctacgccagta
+gttcatgcttgtgttaaaagttgttactgtttatagtccgtactcagggtagtgttcgat
+actcagcggggaactgacatattacactaaggaatcaaggcccttcgtatgggtcatgtt
+tatatatttaattacttacgctatttgatcgagaatagctatagtaacgtcgtaagaatg
+caggatgcgattcgagtttgtaaattcacagatactgtgtatcatattattatagatgtt
+aaggcatagaattattggtattgatgtacaaaaaattatgggtgggcagtaccgataggc
+attacgagcagtgcagcttggaagaactggatgtatcctataactagtaagagccttaaa
+ggtactacatacccagggatgttaccatcattaatttggccatcttcaatcttcgcaatg
+catactttcttctacaagatgccttttagaagacaaaataagtgtcaacaataacgctgt
+aacttaactctgttgtacgtggaatcaagtctcactaaagcaactaacattccgacatgc
+aaacgcaggactactagattattaaattcgccagcccgcctcgtttaatataacatcata
+aaaattctaagtaatatctcacacactaatccgccatcgtccatagcatcagtcacctgt
+cttacacaaacacatgtttaatcgatgttgttatgccaagctagtttcgcgaccatgtaa
+ctaattgtggaaagctgctaccttgaacgacatcaaccatcctacctttgtacaacagac
+caacatctctgtactggtaaatagatctgaaaagttataaatataactgttttcacattg
+atagaaaaacagctatgtgctatttgtatatactataataaattaagcgaaacatggaga
+ttaaaacagtgttttctcatcctccacctcttgttctgctaatttataattcttgatgcc
+actcgtgtgagtcgtccattcgatcgtaaagaacccgacataaatagatacgacgctgaa
+cgagatcctatttctcctgaaaattattagcacggtaactcctagggatagtggtactag
+ttggtatgaacgtataaaaacttgtactactttctcgggatgtgagggagcaaactatta
+ctcgaccagtgcaacgcattatcgacagtaaaagttttcagctgatacctgtctggatgg
+attatatgcaggtaggcgagagtggattgtagcgatgctcggcgggggtattttaaaaat
+ctaggtgataaaagtcctgtttagccaggaaaagtcatcattgcactgcatatcgtcgat
+tagctgtcatttcgtccactggtaccagttcaacgtacatcaaagtccgggcgcatccat
+atcaagttttgcaatagtactccagaccatgaaatggttatccagattaataataactta
+atatactttcactacatactcagcgggtattaaatttcactttatgtcaaaggactctta
+tgtggtcttcaaaaaggtctagagtctatcacgcctaattgtgtgaaaaccgagtaactt
+gatcagccttgtaaaatatagtagaatatgatgttaaatcatttatattccagggagatt
+gaatagcttacgattagctggtataatttaactcacatgattaagcaaatatctgtagga
+ccgagggaaagaataaaataaagtaccatgagttcggaacgctgcattacatggcgttgg
+gctagcctgatacaagaagatgagtatggagctctcttcatcgggacgtgacaaccctag
+cgtaatcttggcagatcccggagcagatgattatcgtctaacactgtctttaccaatgca
+caacgcatagatttaacctgaactgttctggattcactcctgactacagcctacaactca
+tttctatgcataactcttaaagacagtcgcaatatcagtacctctatacacatcggatca
+gactagatcataagataagtctcctctggatccttgtattctgttaagtacactacaaat
+ttgtttagtgtctgggacaattacgataagggtcgcgactagaccacagggcatatgacc
+tccaccgctcctagcgagtctccaatctgcaagcactcatacgctaggggcatgaatcga
+ctgtcaatgcactgtaagatttacgagggtgagacccatttagatatgcctcgtttaacc
+gttttaggcttgataggatgagtttgtcgatccatcaaattcccgacattcatattgtcc
+aataagtatatctagcttattcggactcgctaaactaaattatggtataaatgccgtcaa
+ccggtgcatttgttcaatcaacaaattatagtcaatctcccatggggccttatggcagcg
+tatacagctggtataacgaccatatacaactatgaacggactagctgtgaactaagcaga
+ttattggatccttgtgtataattttaagtttcgatctatatgctatagtatagaaaatgt
+tccgatcgtacgcttcctttacagttaaacagtctatatcatgaagcttatccaaagctg
+gacatttgatggcaatcttacttaattatgaaacttaattacctattattgaaagtattt
+atatgatcgaataagatttgctctataaacaggtcgtccattcacgacctagtgattgcg
+taaattgaccaacctaggtaatctaaagcctgcatctatttcttatcattcatgttatac
+tgacccgttctcagtacttaaaaatgatcgtaagcaagaatcactcacgctcatgtcaca
+tttagtcgaaataaactgccgatgggaaggaagttccgtcattgcgatatcgatgtctat
+cccacgcgtcattttcaaattggttatctacggataactgtgcgatgaactactataggt
+caaaattatcttcaatctcattctagatcatataaagatgtccttcgcgattgatacgtc
+tacagtgtgttggtgttacacagagggtagcgactacttacttactaactctctcttgat
+ccgcaagcataagccaggttaaagtgctctatctttttctgtggattataatagttatac
+cgccttgcatctaggtgcccattaggtaatgccctagtgttttcataaatttactcctgc
+catctaacgttactttaatttcccagattcaataggtctctcatttgaaaattgttatat
+gtcaacaaagaatataatagctgagtggaacaatacactgtgagggagtaatacatactc
+taaattttctttacggtttgcgcctgcacagttttttttatctatgtgatccgcataaaa
+agtaatttcaacgttccattcaagttaagtcttggtgacactagcattaggagagatcac
+caagaccattatttatttagctagggtttaagtcggttagaaatatcagataatgaggtc
+tttatccggccttacgcagtagaaattggaaatttcgtaaagcactgagttcaatggaag
+tatggccgaacccacataatgcacaaatcaagtcgatttcttccgtccttttagtctcct
+gggaactacgggttattcatagttaagctaaatcagttaacggaactagacaaatgtata
+atagttcccaaatatatatctataaatcttatgcagttagggaatgcagatttgaatcat
+ggcaatacgctagctcggaactcaactacaagtgttggatgtacgaattcaaaggtatta
+catccttatgatgttcttttttggatacttttatgacgacttccacgaagtgaaattatg
+ttcgaatatctgaacagttacttggttgagcccaaggatgacgaatgttctgtttataat
+tctcgtcataatataaatacaagcatatgaggccagtcatggagctttcatttggactaa
+catttccgtagagtcatatcacgcctgtaatctgatccgtctttttctattcgaagtgtt
+atcagatacatgacgcccttgcgtgacattcatggctcctgacatcgggtcttttaggct
+gaatctaatctaacccaatttgtttggattgtgggtcctccattttgtctgttaatgctt
+attaagattaaaaatgtactacgtatttagacctaatgattgcgatacgctgtggaccat
+taatataagctgcgccaggggatttttccagatcatctggcctgtgtatatgttcaaatc
+taatagccgagagaaattactccgacggaaaataaaggcagataagcgtttcagagcacc
+atcgtggcgtttagtcaacctttagttcggaatttattaatatacaatctcactctttgg
+acgagctccttaaaagatgcccttgtatatcatgtcccgtacctaaaagtataccagcat
+catcaaagaacagttaaggaatacgactgctctataattgtccgaggagtaccttctcat
+ctgccaatagtcgttgggttggaaaacaacgcattaatatgccacacttgtcaattagaa
+gtttctataaaggggacgagtaactgatttgagacctagcacggcagaggacgttcgtgt
+gacaacatctctttataagtttgagataaaatcgctaatctacaatgattatttgccaat
+cattatcgaatgcgcaaagtatctcctgttcgtgattctagcctaaggccattactatgg
+tcaaattatgctaatcgaagcagtcttctaacacccttagaaaagcaaacactattgaat
+actgccgccgcattcgccagcaccaacataactgcacgtgcttttttccatgattggcat
+tatgaaagatttgatctatgattcttaccagttgcaatattcaatttagcatgtgttcct
+aattattgtgttattatggtctatctcatcatgtaaatgaagatcatgacgtcaacacag
+attctagtcaggatcatcagttcctcggggaaatcgcacctaggaacagccttatgcaac
+cgctaaacaaagcaatgaggatgtaccgacaaaagctcgatttaaaagcctcgaaacgag
+atgtacgaatcgtttactgccttttatgaggagtcgagtactgttggttcatatttgcta
+catgattgtatgtaataacgatcccgccctttatcggttcgatcctttatggcgataagt
+tatgaatcgtcagtatctttagatcaaaaactcaactagtacccagttccccggaggaac
+ggtcatgattaatgcgttttacggtctcccgtccctcttcttgtcagaggaatcagtttc
+atccgatcccactcgatgattggtatagctatttgccgaaaagccacaacgtattcggta
+ctatcttgtttgattcccctgtatcttaattcgcgacacttgatatcttttgtgtttaat
+cgacgaatcatcctgggggcgacacttgttacaattatccagttgcgtttaatggctgtg
+ggtcacaagattgttagacaggtcccgcgtgtcgtaggaaattgataattggagtttgca
+ggacgaatagctcacccgcctaagtgatccaaccctcatcaggataactatcactgggca
+gtattatttttgatttcatatgccaccccctaggagactgtagtcatgtatctttcttac
+ccaatctagcccgaaacaagaaagaatgtcgattccagtcaccttttattagaccgattt
+acacacaaagtgtcttggtttaaaggctggcatgaatacatactcaaaagttgaaaacga
+cttgctctattcgattaccttcgcgatctcaatcgattacgctaaattttaatgcccgct
+gaaatatccaacatttaaaacaggattaattctctgatccatgaacttaggactcattgc
+acgtgacttatctttctctcttaattcatgctccaatacggtgggctaaaccacttttat
+cacatgaatgtacgcaacgtgttaataagctatgagtacgcgggggcagcgaaacgggtc
+aatctgggtatcttctattgggacggtacatttcggttttatagactatgtagttacacg
+gcatcaacatgtaattaaaacggcgtaacctaggaaagccgaacgcaccttgggattgcc
+atgtgtccggaggattacatacatctaagaaacattctaaactatgtatagtcgtttacg
+acccttgtagtacgtgcatcccttggcgaaaagtactctgggtattagagtgtatattat
+cgacagcaccgaatcctcattttatagcttgacaatttatgacccgaaagaaccttttat
+aagtctataagtatatctaacgcaattgcggcactgagtccactaactatctttgagcag
+tgttatacagtgagacgccatggaaggggtttatatattttactgtcgttccctaaaaag
+ttaattatcagacctgcgcgatctcgtagatgaacaacgcgatctagtcgaaaaatgctt
+gtggctaccattccagtcgagatcaaccgtttctgcggatcgcgttacattccttgctta
+tttgcgataaatcgatacaaccccattaccagaaaaacccggagaatcaattactctgca
+gatcttatactaaaaaagagattacaacccctgttctatgtgtcccaaagtgagtaacgt
+ggagcgttggggtaagagcggagcgattttaactttcgcttttccattttccagtattgt
+actttacgttatatttgagcggcacattcgtcaaaacatgatccatatggactgaggtgt
+ttaaatgttaatcaaataattgtattttcagctgactttaaaatctgcagccattggagg
+tggagattccaatagatgtaagcaggtgatatcatatgcaattcttgtgacttattaaga
+taccagacacggcacaatcgcagtagcacgtaaacaataatgacaatcgacggttaaatt
+ccgaacgtaagatatgtttacggatgcactaaaataggtagcaacaacgtttctctgaga
+tgtataagttaccaaacactggagaattccgctaaactaaggacaatttccgtcgtatta
+attgttgacaaatggttagtaatacattcgcagtggataatccgttgcatacctagcact
+gagtgtaaataaaaccaatcgactactggcatttcgggctaacgactagatgttagccta
+tgtgaaagcctcacacatgcttattgccttcacggtgagcaatgtttcttattcgttatt
+agaagtcacctgtagagacagtagagatgacctaaatttggtttgtccagtcccgaggtg
+atctaatgattaggttaacttagaacagtggtcaattggttaaagctgatttacgaacac
+ttccgaggggtcgtaaaacattaaactggtgagaacagtatgatgtattcggtcatctag
+acaaccccatcgctgggagtttggacagtgttatgattcgtaaatccaccatgtgtccga
+attcgaaatcctgttgctccggggagatagggttaatttaggcttttttacggtgtggca
+tattagctcaaacatcaacattcttaaaatcagcgtaaacggtcaccagttgatatttgt
+tctgctaggaagcgatgtacaaaataagcttaataagatttaggtccgaccttaatttcg
+gtccatagcacctctttctaagtgttttgcttaaataattgtattgttattgattttctg
+cgagttgaacacggaaaataagtcaaaaaggacacttttaggttcatatgtaccgatgaa
+tgcgcaatagaatcgagaaatttttagattagtaatcgtgatgattgtggccaaatcccg
+cactaaacggctttcgctgtttccaaaaaattttagtccactaggtatttaaatgttgga
+cactgaacgtggaagccgtcgtattatgaaactaatggcagaggggctcctctgcgtgta
+ctttgagcagatgctatcgtcagaaaaaggtaaatcttttggttctttataattctggcg
+tccgtgtagcctagtgaatgtgtttggttcaagtgaatttgtttagccagaatggaccaa
+ttacgtcattagctgttacgtctatacgaaatatagactgtggacgacccatcgtagagt
+catgtagttacatgtgaccttagaacaccaatcgtgtgcgattgtaagcaggacaacaca
+gtattgtactggtcaattggttcatagatctgactatgaatcttcgtttttgtacaacaa
+tctcggtgaagcttcaaaaagcctccttcctaataatcagttaatttttcgtaaggttcc
+tgttcgaggttagtcgtataaagacgaaacggccttaatgtaacattaactattccactg
+taggtggatctaacaaggttggacatgtgctaccaataagataagaatttcgtccgcaat
+acaatatctacttttgtagcctatcttggattaacaacaacttacgttggtatttcaccg
+gacgtatcaaatgattctgattttaatgactgagagtaaacatcaacgaatcttatgtat
+ctttaagccgctgcttgacaagtcacattactgttagaatgaacgcttcattactacaaa
+acctaccaccaactcccacattaatattatactagatgtttgaagtttatttgacaaagg
+ttttcaaaaagcacagaatcgttacgaacacgtacattaaattgttagggtattaattgt
+ggtcggtgcatttccggccccatagcgctccgcggggagaaactatggccttcatgacag
+cccccccataacatctaggtaatggtcggataactataaacaaccctctccagagaactg
+tgaaaataaaatctcttagtacacaagcgtatactggtttaagtcttgcccatcttaaag
+actcttttcactattttcttgatgcctcattcttctaatattaggtgattttttaatccg
+agaatataaaaagacgatagaaagtgttaaaacacggcgtagcgacatattttaaagaaa
+tgaaatactttttgactatccctcatgatctaaacttacgcggagctatctttttgtata
+acatgtacagagaattaatccgatgcttcttccgattaaggacatagcgccgaaaacgtc
+atggcggcttatcgatatcgtaacgcactataccaagtgattaagtgatcaatgaatacg
+ggtttcgggatttctgttaagtcatgcacggcaaatacttggagtcttgaataacgccgc
+gcgtagtacgaaggttctcaagctcgcgtgacgtatagaccgtattgctatttcctgcct
+tctcaattgtccgaggattgctgataacttaaaataaggttgagtttttaataacgattt
+gtcgagtttgggaaaatcctcgtttgtgtgtttgtcattttcaagttatcaagaactacg
+ggtataatttacgacgtaatgttggtttgatgcccgattgcgaatatcgtacgaatggta
+tttgtacaactgctttcctttatcgattgctcgagaacattataaagtctattactatgg
+attaagactgtatacaagtgtttaagcggagcccgtgataatctataaggttttggtacc
+tttatctgttacttttgccttgaaacatacatacgtacacgggaatatttacctaaacgc
+cgtatagtccagcctcgtatttgggccgtgttttgtcagcattttaaactgaaagcgccc
+acttgcattataacccggtgcggaatctcttagtgactcgtcaggagtttacgcctttga
+gacctctcgacaggacccattttgatctagtcgttataggtagagtgcctttcctatcgc
+accattaccttctagcaaacttagagtattcaatgaaatcatatcctgtttatactaaat
+gttataggctaatgacacagctgacactaagaggtctcttcgggttacccgaatgagttg
+tttatacgatgttgacaactcgggggagtcatttcaatgaagactgaggactcttgatca
+gattaaaacgcttaatgactgataatttagattatgccgtgtattatttaagtgggcgaa
+ccctcccctagaatgggtttcctgagaaaagtcttagaacacagtattctgaatccagat
+gcaaatcgctaacgttagtaagcggctgtagctcttggcagtttggtcaatagtcaatcg
+caatccgtttaaccgtctactattcctagagcgaagagctatgttctgacacgtccccaa
+tattaggcaaaggctccaaaagaacagtcaattgattaactacgggcttggtttctccgt
+gaatccttgcgccgctataccacataaaaggatagcggtgataccacaagtttgcgacgt
+taaagcgtcgaccctcaacaagtacactagcaaccccttagcaattaattttgtccatca
+ctactgccaagagttgactggaccagttggaaatgacatttgatatattaatagagctac
+atattgtaccactttactgtcacttacactaaccctagcgtgattactcatacatatatt
+cgtaaattctaagttatgatactagttttgtaaatttaatcggcgaagacacgttctctt
+gtacgagcttcaactaaatatttcactgtagccaaccactttaaccagaaggatacctta
+atgccgatataatattgtccaggaaacgttaatactttcacaagacaaagcttggaagag
+gtactttacgatcacctgatagatcgaccggaacgattctatataggtttggtctgagaa
+atttgtagctaaaaccatgttccataggaactcctctgtaatgggcaaaatgcagatagc
+gttcaatcgttgcttaactatctatcacagcatcctaactcctcaacagcttctttccta
+aagacatcagcaggtaagttgacggcacccgataacccagagcacgattggaatctaata
+ctctgtatggatcattacgctaagtaaatataatgattttctgactcaaagttacactgc
+gaattttatattaactggttctatttgttaaataccacaacctctcgtcaacaggtcgcg
+atgcaagtgatccaaaaatatctaacttataccaaccattacttctggcgcagaaaaaca
+tagatatctgaacaatcgaccgttaagactgtctcgccgatcttaggaacctaatactgc
+tcagtagttattgtttatttgggccatccccggattatgtcagccatggaacactaaaag
+tcctaatctaacctatggacaaaaagctcacttttataaaattgctcaccttatgttgat
+tgttatttgtccgaaatgtctataactcagtgtactatctattggaaaattatggccgga
+gttttattgaatatacttttgtatgttgagaaagaatgttgtcgtaataattatcagctg
+gaaaatcatctaatatatattatattgagatattacgacagacctaagtgctttcccgtc
+atgagcagatggactaacactcttggtaatccttctcgttttagttggtaatgtttagtc
+taagtaatatcccgactcttacttactcagagcggaaatgactttttaaactaacgttta
+aaggcacttagtatgcgtcagggttatttttttaattacgtacccttgtgcagagagttt
+agctattcgatcctacttagtatgaaccatgagagtacaggttggtaattcacagagaag
+gtcgagaagattatttttgatgtttaccaatactatgaggcgtattcatcgaaataattt
+tatggctgcgcacttcacatacgcaggaagaccactgcagcttgctagatctggatgtat
+cattgtacttctaagagcctgaaaggtaatacattcccagcgagcgtaacagattgtatg
+gggacatattcaatcttagcaatgcattcgttcttcgaaatcaggcatttttgatgtcat
+aagttctgtcaactataaccctggaactttaatctgttgttcgtcgaatcaaggatcaag
+aaagcttctaaaaggcccaaagcaaaacccaccactacttcagttttaaattagaatcac
+accctagggtattagataataattaaatgtcttaggaagagatatcaaaagatgcagaca
+tcctcaagtgaataagtctccggtctttcacaaacacatggttaagcgatgtggttttga
+ctagagacgttcgccaccatcgtaatatttctggttacctgcgaacgtgaaccaaatctt
+acttcatacattgcttaaacagtacaacttatctcttatcctatagagatctcaaaagtt
+tgtatttttactggtttcaaattgagagaaaaactgcgttctccgatttctatattattg
+tttaaatgatgccaaacatccagtttaaaacacggtgtgatcagccgactcagattcgta
+tcctatgttagaatgagtcatcaaactacggtcacgcgtacattacagagtaaactacac
+gaatgaaagagataagaagatgaaagagttaataggtctcctgttaattatgagaaccct
+aactactacggattggcctactagtgggttggaacggatataaaattcgactaagttcgc
+ggcatgtcaggctcctaaatatgaagagaactcggcatcgaattatccacagtaatagtt
+ggaacatgattcctctatgcatggtgtatatccacgtacgccagtgtgcagtgtagccat
+gcgaccacgggcgttgtgaatattcttcctcagaaaaggactgttgagcaaggaattgga
+ttctgtgaacggaatatagtcgagtagatggaatttcctacactgcgaaaaggtcatagt
+aaatcaaacgccgcgcgcagacatatcttcttggcaattagtactccactaaatcaattg
+gttataaacttttagaatatctttatataagttcactacttacgctgcgggtagtatatt
+taaagtgatgtcttaggaatcttatggcggcggaataaacggcttgactatagataccct
+aattctggcataaccctgtaacgtgtgaagcatgctttaatagacgactagatcagctta
+tagaatggatatgactgccacattgaagagattaacattagcgggtataatgttacgaac
+ttgtttaacaaaatagctctaccacacacgcatagtataatataaaggtcctggagttcg
+ctacgagcctggaattgcagttcccctaccctgagtaaacaagatcagtatggacctatc
+ttctgacccacgtgtaaaaactaccgttagcggccctgagaacggtgaagttgattatcg
+gctaacactcgctttaccaaggaacaaacaattgatggaacaggtaagcggctggattct
+atcctgaatacagcataataatatttgctttcaatatatagttatgacactcccaatatc
+actaactctttacaaatcggatatgaagagtgaattagagatggagccgatcgttccttg
+tattctggtaagtactcgactaatgtgtgtagtctaggggtaaaggtccttaaccgtcga
+gtctagaactcacgcattatgaaatcctccgagcatagagactctaaattcgccaagcaa
+taagtcccgacgcgaaggatgagaagctcattgaactgtaacatttacgtcgggctcacc
+atgttacatatgcagcgggtaaaagtttttgcctggagtggttgagtttcgcgatacata
+aaaggccccactttcatatggtcaaatatctatatcgtgctttggacgactcgataaact
+aaagtagcctagtaatgccctaaaccgctgcatttgtgcaataaaaaatttagagtatat
+ataacttccggacgtatggctgccttgaatcctcggatatcgtccttatacaacgatgaa
+cggtatagctcggaactatgcagattaggcgatccttgggttgaatttttagtttccata
+gatatgagttagttttgatatggttaccatacgtccctgcattgaaacttaatctgtata
+ttgattgatccttagcaatagcggcacatttctgggcaatatgacttaattaggttacgg
+tttttactatgatggatacgttttatatgatagaataacagttgctatttaaacaggtac
+tacattcaactaatactgtttcactattgtgtccaacatagggaatatattgcctgaata
+gatgtattatcaggcatcttttacgctccaggtagaactaattaaaaatgatccttagaa
+actttcaagcaacataagctaaaagttacgccaattataagccacatcggtaggatcttc
+aggcattcccatatccttctctatcaatcccgtctgttgctaattggttatctaagcata
+tcgcggcgagcatctacgataggtataaagttgctgctatctaattcgtcataatatata
+catggaattacagattcatacgtcttcagtctcgtggtgtttctaagagcggacccaaga
+attacgtaatatctctctcgtgttacccaagaagttgacacgtgattgtcagctatcttt
+ttctggcgatgttaatagttataaacaattgcatatagctgcaaattagctaatcaaata
+ctcgtttcttaaatgttatcagcaaagctttaggttctgtaatttcactgtgtaaagagg
+gcgctaagttcaaaattggtttttggcaacaaacaatttaatagcgcagtgcaaaaataa
+tatctcagggtgtaattatttctctaattggtctttacggttggaccaggcaatgggttt
+tttatctatgtgataccaattaaaagtaatttcaaagtgacattaaacttaagtattgct
+gtcaagaccattacgacacttcaccaacacatttatgtattgtgctacgcggtatggccc
+gtagtaatttctgatattgaccgcgttatcagcaagtacgctgtacaaatgccaaattta
+gtaaagctctgtgtgcattccaaggtgcccacatcacacattatcaacatatcatgtcgt
+tgtattacgtccttttactagcctgggaaataccggtgattcagagtgaacataaatctc
+tgaaagctactagacaaagctagtatagttaaaatatatatttcttttaatattaggatc
+tttgcgattgcacatttcaagcatcgcattaacctacctccgtactcttctacaacggtt
+gcatgtacgatttctatgcgatgaaatacttatgttcttagtttggggttactttgttca
+cctagtcctcgaacgcaaattagcttcgaatatctgaaaagtgtatgcgggcaccaaaac
+gatctcgattcttaggtttataattatagtcagaagataaatacatgcatatctggacac
+tcttccacatgtcatgtcgactaactttgaactacagtcatatatagactgttatctgat
+ccgtatgtgtctattactactcttatctgagaaaggacccaatggagtcacagtaagcga
+tcatgtcatcggggctttttccctgattataagattacactattgctgtgcttggggcct
+cctactttttctatcttaatcattttgtacattaaaaagctaagaagtaggtacaactta
+tctttcccatacgagctggaccattaatttaacagccgcaaggcgagttttaatgttaat
+ctggaagggctttatgttctaagcttttagcactgagaaattaatccgtaggaaattaat
+cccacataacccggtaagagaaccttacgccccgttactaataatgttctgcgcaatgta
+ggaagtgacaagctcactcttgcgacgagctccttaatacaggccctgcgttatattcga
+ccgtacctataactagaccaccatcttaaatgtacagttatggttttcgacgcatagagt
+atgggaccacctcgaaatgctcagctgcaaattgtactgggggtggttatcaaacattta
+atatgaatctatggtaaagtactagtttatagatagccgaacactaaaggtttgcagacc
+ttcctcccctgaggaacttcgtgtcacaaattagattgagaaggtggtgataaaatcgcg
+tatctacaatgatttggtgcaaatatttatcgattgcccaatcgttctactcgtactctt
+tatagcctaacgccttttcttggcgctaattagcctaatccaagaaggagtctaacaaaa
+ttacttaaccatactcttgtctattcggcccacgcatgcgcaagctcaaaaagttctcaa
+cgggcgtttttacttgagtcccaggaggtaacattggatctatgagtcttaacagtggaa
+atatgatttttagattgtgttcagatttattgtcttattttggtctatctcatcagctat
+agctacataatgacgtcttaactgtttcgactaaccttcagatctgactaccccaaatac
+aacatagcaaaagaatgatgctaacgcttaactatcctttcacgatcttaacaaaaaagc
+tccatttaaaagaatcgaaaacagatctaccattcgtggaatcaatttttggacgagtac
+tggtcgggtcgtgcttatttgctacaggattgtttcgtataacgttcaagcactttagcg
+gttccatccttgatggcgttaactgatgatgcgtaagtttatggtgatctaaaactctac
+tacgaaccaggtcccagcacgaaacgtcatctttaatgagtttttaggtctccaggcact
+aggctgcgaagtggaatatgtgtcatcagagacaaatagatgattcctatagctttttgc
+agttaagccactaagtaggcggttctatagggtttcattcaaatcgatcgtaattcccga
+ctctgcatagcgtgggtcttgtatagaccattcttcaggcccgccacaatggtttcaagt
+ttcaacttccgtttattggctgtccctcaatagagtcgttctcagggcacgactctcgtt
+cgttattcataagtccagtttgatccacgaatacagaacacgcatatctgataataaaag
+cttaacgataactttcacgcgcatggtttatttttgatttattaggcaaccaaataccag
+aatgtagtcagcgatatgtagtaaaatttagacaaacataaaacaaagtatcgccattac
+agtctcctgttaggagaacctttttatcaatatgtgtaggcgtgtattggcgcccttgat
+ttaataataattacggctaaacgtattgatattttccaggaactgccccatctcatgaga
+tgaccctaaattttattcacacctcatttttaattcttttatatcacgattatttatctg
+agcaagcatctttgcaagcattcatagtgacggtgctgtctctatgaatgcatgctaata
+tacggtgcgctaaacatattggttcaattcaatgtaagctacctcggaatttgcttgcac
+taagacggggaagccaaaacggtaaatcgccgtatatgctagtgccaagggacttgtccg
+ttggagtcactatggagttacaagcattataaatctaaggaaatcgcagtatcagtcctt
+accccaaagatacttcgcattccctggggtacggaccatgaaatacttctttcatacatg
+ataaacgatggagactcggttaccaccctggtagttactccatcaattggagttaactaa
+gatcgctattacaggctttattagccaatcatcacaagcctctttttagagattcacaag
+ttagcaaaccaaagttcctttgataagtctttaacgagatctatcccaattccggctagg
+agtaaaatttatatatttgagatcggggttaaagtcacacgcaatgcaaggggtttttat
+atggtaatgtccttccctaattaggtaattttcagacctccgagagagagtagatcaaca
+acgcgttatactcctaaaatgcttgtcgataacatgacactacagatcatccctggatga
+gcatcgactttcattacttgattagttcagttaattcgtttcaaaccattttcaacaaaa
+tcccccagtagatatgtatatgcacatcttagactaaataacagttttcataccctggga
+tttgtgtcactatctcaggaacgtcgagacgtcccctatcaccgcagcgagggtaactgg
+ccctgttccattgtaatcgatgggacgggacgttatattgcagacccaaagtagtaataa
+attcagccatatggacggagggggggaattgttaagaatataattcgattttcagctgaa
+tgtaaaagctccagccattcctcctccacttgacattagttcgaagaaggtctgagaatt
+ggaattgcttgtgacgttttttgtttccagacaaggaaatagcccagtaccaagtataat
+attatgacaatagaagcttaaattcacaacgtaacatatctgttagcatgctctaataga
+ccgagaaaataagtgtctatgtgtgcgagaactgtcaattcacggcagtagtcacctaat
+ctaacgtctagttcccgactatgaagtcttcacaaatggttagtaataatttcccagtgg
+agtagaagtggcataacgtgcactctctgttaataatacctttagactactcccatttcg
+ccagaacgtcttgatggtaccctatgggaaacactcacacatgcttattgcctgcaacct
+cagcaatgtgtcgtatgcggtatttctacgaacagctagtgaaaggactgatgacctaat
+tttggtttctcaagtccagacgtgatattttgatgaccgtatctgacatctctgggcaat
+tcggttaacctctggtacgaaatagtccgtcgcgtaggtaaaaatgataatgctgtcatc
+actatcatgttttagctaagctacactaccccatcgctcgcacgtggcaaagtgtgagga
+ttccgatatcatccatgtgtacgaattcctaatactcttgctcagggcacttagggttat
+tgtagcctgtgttaccgtctcgcatattagatcattaatcaacagtcttataatcaccgt
+aatcggtaaacagttgttatttgttctgataggtagacagctaataaagatgctgttgaa
+cagttacgtcccacctttattgccctacagtgaaactagttcttactctgttgctgtaat
+atgtctagggttattgatttgctgccacttcaaaacggaaattaagtcattaacgaaaat
+ggttccttcataggtaaagatcaatccccaattgaagccagaaattttgagatgtcgatt
+cctgatcattcgccaaatttacagctcgtaaacgagttccatgtgtaaaaaaatgttgag
+tccactagcttgtttattctggctcaaggtacgtggaacacgtagtattttgatactaat
+gccagacccgctacgatccctgtactgtgagcagagccgatcctcagaaatagctaaatc
+ttgtgcttcgttagaagtctcgactacgtgtagcctagtgtttgtgttgcgttatagtct
+atttgtggacacagtatggtcaaatgacgtcttttgatctgacggcgttaacaaagatac
+tctgggcaacacacatacttctctcatgttgtttcttcggacctttcataacctttcctg
+gcacatggttagctgcacatcacaggattgtaagggtctagtggttcagtgagcggaata
+tcattcgtcggtggtgttaatctatctcggtgtagcttataaatgcatccgtaagaatat
+tatgtttatttgtcggtacgttcatggtagtggtgtcgccgatttagacgtaaaggcatg
+tatggatcttgatctatgcaaaggtaggtccatctatatacgttgcacagcggatacaaa
+taagataagaatttactaacatttaaattttcttattgtcgagcatagattggaggaaaa
+acttatttacttggtatttaaacggaagtttctaatgtttatgattggatgcacggacag
+tttactgcttactttcttaggtttcttgaacaacaggatgcactagtaacatgtctcgtt
+catgcttccattaagttcttcttaaacttacacaaactacctaatttagagttgacgaga
+tggttgaacgtgttgtgacaaacgtttgcaaaatgcacagtatcgttaccaaaaagtaca
+tttaagtgtgtgcgtaggaattctgctacgtccattgcaggccacattcacatcccaccc
+ctgaatatatggactgaatcacacacaccaaatttcatctaccttatcgtagcataacta
+ttaacaaacatatacagacttcgcggtaaataaaatatattagtacacaaccgtatactg
+gttgaactattgcccagctttaagacgcttttaactaggtgcttgatcaagaagtattat
+tatatgacggcagtgtgtaatacctgaatagatatagacgttagattgtctgaaaacacg
+ccgtagagacatttttgttagatatgtatttctttttgacgagccagcatcttagtatct
+gaagacgagctatatgtttgtagaaaatcgactgacattgtatacgaggcggcgtaagat
+taaccaaattccccagaattagtaatggcgccttatcgatttactaacgatatataactt
+gtgatgttgtctgcaatgtatacccgtgtaggctgtgctcttatcgaaggaaacgcattg
+aagtccaggctggatgaaaccaccgcgtacttccatgcgtctatacatagcgtcaccgat
+actacgttttgctatgtaatccattctaatgggtaagaggattcctcttatagtaaaata
+tgcttgactttttaagaaccattgggagtggttggcaaaataatagtgggtgtctttctc
+agtgtatagttttctacaactacccctattaggttacaagtaatctggctttcttgccac
+ttggcgatgatagttagattcgtatttctacaacgcagttactgtatccatggcgcgaga
+taattagatacgatttgaatttggatgtagactcgttactactgttgtagaccagcacgt
+gagtatctagatgggtttgctaccttgttagcggacttttgccgggaaaaagacatacgt
+acaaccgtatattttactataagcagtattggccaccctcgtattgcggcagggtgtgct
+cacctggttaaaatgaaagagaaaaattccattttaaaacccggaggaatctattactga
+cgaggaaggtgtttaacccgttgagacatctcctaacgtaaaaggttcatattctagtta
+ttccgagagtcactttcctatccaaacatgaactgatagcataatgacaggttgaatgga
+aagcatatcctgtttattctaaatctgtttcgctaatcaatatgctgtcacgaactcgga
+gcttacccttacaactatgtgttctgtttaccaggtgctaatatcccggcactcttttca
+tgcatgtcgctcctagcgtcatctgatttaatagcttaatgtctcatattttacagtagc
+cagtgtagtatggaaggcggcgaaccagcccctacattgggtttcctgacataagtatta
+catatcacttgtctgattacacagcaaaatcgctaaccttactttgcgcatgtagctatt
+ggaactttgggctagtgtctatcccattaagtttaacagtagactagtccgtgagcgatc
+accgagcttatgtctcgtacccaagttttggatttggatcaaaaactactcgatattcat
+gatctacgggcttcctttctccgggtatcattgcgccgagattaaaaataaaacgatagc
+gctgtgaaaacatgtttgacacgggatagcgtagaaactaaacaacgaatagaccatcca
+atttgaattttattgggtccagcacttcgccatagtgttgaatggtaaagttcgaaagga
+aatttgttatattaattctgctacattttcgaccacttgtatctcaaggacaatatccct
+tgaggcttttagcagaaagagatgccgtaattctaagggatgataataggttgggaaatt
+taagagcagtagtaacggtcgcgggttcgaccttaaactatatatttaaatctagccaaa
+caagttaacaacaaccataaagttatgaccttattatattggcaagcttaacgttttaat
+tgctctagtaatagagtggtagaggtaagggaccatcacctgattcttcctccgcaacca
+ttatatagacgtgtcgtctgacaaatttcgagataaaacattcgtccttagcaacgaata
+tcgaatggcaattagccacattgagttaaatagttgaggatatttcttgcacagaatcag
+atctaatctaatgattcgttactaaacacttcaccaggtatcgtgaaggctcaagattac
+ccagagaacctttgcaatataagaatatgtatgcagcattaccctaagtaattatattct
+ttttctgactcaaagtgacaagccctagtgtatattaaatcggtatatttgggaaattcc
+tcaaactatcctaatcaggtagccatgaaagtgatcaaaaaagttcgtacttataccata
+catgaattctggccaagtaaaaaatagattgcgcaaaattcgtaccttaagtctctcgcc
+aagatattaggatcctattactcatatcgtgtttttctttattgccgccatccccggagt
+atctcacccatccttctcttaaaggcctaatattacctatgcaaataaacatatattgtt
+gaaaattgagaacctgatcgtgattcttatgtgtaccatatgtatagtaatcacgcgact
+atatagtgctttagtatcgcccgtgggtgagtgaatattctgggctagcgtgagatagtt
+tcttgtcctaatatttttcagatcgaatagcttctatttttgtgtttattgacatatgtc
+gaaactccttactcagtgaaagtcatgaccagatccacgaacaatcttcggaatcagtct
+cgttttacggcggaatcttgagtctaacttatatcccgtcgcttactttctaacacccct
+tatgtatttttaaaattacgtttattcgaacgtacttggcggaagcgttattttttgaag
+taagttacattgggcagactcttgacattttcgatacgactttctttcatccatcacagg
+actcgttcgtattgatatcagaagctcgtgatgattagttgtcttctttaccaatacttt
+gaggcctattctgcgaaatttttgttgccctgcgaacttcacataccaaggaacacctcg
+caacatgccttcatatccatcgttcattgtaattcttacacaatgaatcctaagtaatta
+catccctgcgtaaaagatggtaggggcactgaggatatattaccaagcatttagttatga
+gtaatcagcaatgtttcttgtattaagttctctaaaatagttacatcgtaatgttatctc
+gggttccgcgaataaacgagatagattcattatatatggccctaagcaaaaacctcctcg
+tattctgttggtaattagaatcacacaatacgggttgagatattaattatttgtagtacg
+aagagatataaaaagatgaacaattactcaagtcaagatgtatacgggatttataataaa
+aatcgggtagagatctgctttgcaattcagacgtgccactaaatcgtaatatgtcgcgtt
+acatcagaaagggtaactattattaattaataaagggcttaatcactacatattagatct
+tatccgatagtcttatctattcgttgtatttttaagcggttctaattcagtcattatatc
+agtgctccgagttctttattattgttttaaggatgacaaaatgcctcttgttataacgct
+gggagaagcagactaagagtcggagcagttggtagaatgaggctgcaaaagacggtctcg
+acgaatggacagactttactaaaccaatgaaagacagaagtagagcaaagtctgaagtgg
+tatcagcttaattatgacaacccttaatacttccctttcgccgaatactggcgtggaaag
+gttttaaaagtcgaagtagttagaggcatctctcgctcataaataggtagactactcgca
+atccaatgtgactatgtaatactgggaacatcagtccgcgatgcagcgtgtttatcaacc
+gtccccactcgcctggggagacatgagaccacccccgtggggattattagtccgcagtaa
+tcgactcttgacaatccttttcgattatgtcatagcaatttacgacagttcagcgaagtg
+actactcggcgaaatggtattactaaagcattcgaacccacatgaatgtgattcttggca
+atttctaatccactaaagcttttccgttgaatctggttgtagatatttatataagttcac
+taattaagatcacggtagtatattgatagtgatgtctttgcaagaggttggccgaggaat
+ttacggattctctattgatacaatttgtctggcttataactcttaaggctgaaccaggcg
+tttttagacgacttgatcagctgttagaatggtttggactccctctttcatgtcagtaac
+atttcagccgttattgttacgatatgcttgaacaatattgatctaccacacacccatagt
+atattttataggtcatgctgttacctacgagcatggtattccacttcccattcaatgagt
+attcaacatcactagcctcagagatgatgacccacctctaataacgtcacgttgcggcca
+tgtgaaacctgaacttgagtagacgatatcaagcgctttaaattgcatataacatttgag
+ggtaaagctaagcggatgctttatataatcaatactcaataataagatttgattgcattt
+tagagttatgacacgacatagttcactaacgagttactattcccagatctagactgaagt
+actgatcgagacgatccttacgtcgatgatcgttagttatcgacttaggtcgggtctcta
+gcggtattggtacttaaccggacactatactaataacccatgatcaaagcataacagaat
+acagacgataatttcgccaacatatatgtacagaccccaagcatgagaagctcattgaaa
+gctatcattgaagtcccgctcacaatgtgtcttttccagacggtttaactggttcccggg
+agtcctggagtttcgacttacataaatggaaacaatgtattttgctaatttatctatagc
+gtcatttggaccaatacagaatattatgttgcctagtaatccactataacccgcaagtgc
+tgatagaaaatttttagacgatttataaatgccccaagtatccctcccgtgaatcctccg
+ttatactaattagtattcgttcatacgtataccgcgcatatatgaacatttggcgataag
+gcgcgtgaattgttacgtgacagagatagcagtttcttgtgatatggttaacagacgtac
+atgaagggaaactttatatctatagtgatgcttccgtagaaataccgccactggtctgcc
+aatgatgaagtatgtagctttaggtttgtactatgaggctttcgtttgtttgcagagtat
+aacagttgcgagtgaaaaaccgacgaatttatactaatacgctttcactattggctacaa
+aatagggaagagtttcaatcatgagagggagtatatggatgctttgtagctaaaggtaga
+acgtatgtatatgctgccgttcattcttgaaagatacataagcgataagttacgacaatt
+ataagcaacatccctaccttcgtaacgatttcactgttactgcgcttgaaatacactatg
+gggctattggcggagagaagcagatcgcgccgagcatatacgagacctataatgttgatg
+atagagaaggcgtctgaattgatacatcgaagtacactttctttcgtagtatctctcgtc
+ctctttctatctccggacacaagaattaagttatatatatagagtcttaccaatcatgtt
+gaatcctgattctcagagttctttggcgggccttgtgatgactgagaaacaatgcaatat
+tgctccaaatttcctaagcaaattctcggttatgttatgttatcagcaaagcgttacgtt
+atgttatttaaatctggaatgacggagcgaagttcttatgtcggtgtgggaataattctt
+ttgaagacagcactccttaaataatatcgctccgtgtttgtatttatcgaatgggtctgt
+aaccttgcacaagcaaatcggtggtgtatatatcggataacaattaatacgatgttcata
+gtgacagtatactgatcgagtcctctaaagtcaattacctcacttaacaatctcattgat
+gttgtgtcattcccggtatcgcccgtagtatgtgctctgattgaccgagtgtgaaccaag
+gaacatctactaatgcctttgttaggtaagatctctctgaattccttcgtgccaacttaa
+aacattatcaaaatttcttctacttggattaactacttttacgagcatggcaaattcccc
+tgtggaagacggttcattattatcggaaaccttatagaaattgcgtgttgactgaaatta
+gatttttattgtaagagttgcatctttgcgattcctctggtctagcttccaatgaacagt
+cctcccttctattcgacatcgggtccttcgtacatgtctttgcgatgtaataattaggtt
+cggagtgtggccttaatgggtgcaactaggaatacaacgcaaatttgctgacatgatagc
+aaatcggtatgccggcaccaaaacgtgctccttgcttagcttgtgaatgagactcagtag
+ttaaataaatccatatctgcaatcgattccacaggtattgtccactatctttgaactact
+ctaagagatacaagcttagctgagaccgaggtgtatatgactacgctgatatctgtaagg
+taccaatgcaggcaaagtatgcgagaagctaataccggctgtttccagctttataagatt
+aaaatttggctgtcctggcggcctcagaattgttctatcgtaatcagttggttcattaat
+tagctaagtacgaggtacaacttatctgtcccagaacagctccacaagtttttttacagc
+cgaaacccctgtgtgaatcttaatatccaagcgcgttatctgattagagtttacaactca
+gtattttatcagtacgttttgtttccaacattacccggtatgacaaaatgacgccacgtg
+tcgaataatggtctgaccaatgtaggaagtgaaaagataaatattgcctacacatactga
+attcaggcaatgcgttttattcgaaaggtcatataactagaaaacatgatgaattcttat
+cggatccttttactagcatagtgttggcgaacacctcgtaatgctcagcggcaaattgga
+ctgcgggtccttatcatacattttttttcaatataggcgattggtctaggttagtgattc
+cccaacacttaaggtttgctgacattcataccctcagcaacttcctctcaaaaattagag
+tgagttggtggtcttataagaccgttgattatttgaggtggtcaaatgatggtgcgatgc
+acaaatcgttataatcgtactctgtagacaataacccattgtagtgccgattttgtgcat
+aatacaagaaggaggatataaaaatgacttttcaataatattggctattagcaacaagaa
+ggagaatcctcattaagttagcaaccgcagggggtactgcagtccaaggaggtttcattg
+gagagagcagtatgaaaacggcaattatgattgtgagattcgctgaagattgtgtctctg
+attttcctagatagaataagctatagctacttaatcaactcttaactgtggagactatcc
+tgatgatctgaataccccatttacaaaattccatatcaatgaggctaacgcttaaatttc
+atttctccatcgtaacaaaaatcagcctttttatacaagacaaaacactgcttccattac
+gggtagcaatggttgctcgactactggtagcgtcgtgatgtggtgataaagctgtcttgc
+gtttatacttaaacaaattttgacctgacataatggagcgacttatcggatgttgccgat
+ctttagggtcatctattaagcttatacgaaaaagggacaagcacgttacgtaatctggta
+ggactgggtacctagaaacgcaagaggaggcgaactccaatatctgtaagaacagaaaaa
+tacaggagtccttttcatttttcaagttaacaatataagtaggagcttagagaggcttgc
+atgaaaatcgttaggaattacagaataggcagagagtggggcgtgtagactacattcttc
+aggccccacaatatgggttataggttaaactgcactttttgcgatctcccgaaatactgt
+cgttctctgcgaaccacgctcgttccttttgctgtagtccacgttcatccaactattcag
+ataaacaagatcgcagaattaaagcttaaccatatcttgatagcccatcgtgtatggggc
+atgtatgtgcaaacaaaagacctcaatcttgtctgcgagagggaggaaaatttagacaaa
+cataattcattctttcgactggacacgctaaggtttggacaaactttgtatctatatctg
+gaggcctgtattccagcccttcttttaataagatttacggcttaaactatggatatttgc
+caggaaatgacactgctattgacaggaacataattttgattcaaacctcattgttaatta
+ttttatatctcctgtttttatatcagaatgcttctgtcctagaaggcatactcaaggtga
+gggctcgaggaatgaatcataatagaccggcccctattaatattggttcaattctttctt
+acataacgcggaatttgattgcacgaacaccgggaacacataaccgtatagcgcccgtta
+tgctagtgcctagcgactgggaccgtggagtctatatcgtctttctaccattattaatct
+aaggatataccactttaagtcctttcaactaacataaggcgcattccatgcgctaaggac
+cttgaatttattatttcttacatgataaaagatcgagtcgacgggaacaaaaggctacgt
+actcaataaagtgcagtttactaagagccctttttctggcttgtggagactatcataaca
+tgaagatgttttgacattcaatagtttgcaaaacaaacttactttgtgtagtattgaacg
+agatctttccaattgccccatagcaggaatagttatatattgcagatcgcggtgtaacgc
+actccaaatccatcgcggtgtgtgagggtaagcgacttaaagaattacggtttttgatca
+aagcacagtgagagttgagcaaattacagttatacgacttaattcagtctccataaattg
+aaacgacacttcttaacgggaggaccagacacgttcattaagtgaggagtgcactttttg
+actttaaaaacatggtaatcaatttaaaccacttgatatgtatatgaacagatttgaagt
+tatttctgttttaatacactgggagttctgtcaatatcgcaggaaccgcctgacgtcccc
+tatcacacctcagagggtaaagggacaggggaaagggtaatcgaggggtagggaacgtag
+ttggcacacccaatggacgaataaatgctgccatatccacggagggcgggattgcggttg
+attttaaggcgatggtaacctgaatgtaatagatcatcaaatgcctcctccactggaaat
+tactgcgtacatccgctgagaattgcaatggagtgtctcggtttttctttaaacaaaacc
+aaattgacaacttcatagtataatttttgcacattacaagcgttaattaacaaacttact
+ttgctgttagctgcctatatttgtccgacaatataactggatatctctgcgagaactgta
+aattaacggcacttggaacataatagttcctattggtaacgacgttgtaggcggcaatta
+tccggtggaagaattgacaactgcagttgaactgcatgaaagtcaaatctctcgtaagta
+taactttagaagactccaaggtacccagaacctcttcagcggacacgatcgctatcaatc
+aataaggattattcactgaaaccgctcatatctggaggtggacgtttttcttcgaaaagc
+ttgtcaaaggactcatcaaatttttggccgtgctaatcgacacacctgttattttcatga
+ccggataggacatctcgcggaaattcgggtaacagctgggtagatataggacctccccta
+cgtattaatgataagcctgtcataactagcttggtttaccgaagagacaataaacattcg
+agcgctcgtgccaaactcggtgcattacgtttgaataaatcggtaacatgtactattact
+ctgcctaacggcacttacccgtttgggtccatggggtaaccgctcgatgttgacagaatt
+atgctaaagtcgtttaagatcccgattaccgaaaatctggttatgtctgagcattcgtac
+actgcgtattaagatcaggttgaacaggttcctaacaaattttgtgacctaaagtgaaac
+taggtcgtactctgggcatgttttatgtcgtggcgtatgcatgtgctgacacttctaaaa
+ccaaattaaggctttatccaatatgggtccttaagtgctaaacatcattcacaatttcaa
+gacagattgttggtcttgtcgattccgcatctgtcgccaaattgacacatcgtaaaccag
+gtacatcggtaattatatgttgactaaactaccgtgtgtattctggctctaggtacggcg
+aacaagtacgatgtgcttaagaagccctcaccccagacgagcccgcgtaggtcacatcag
+cagatcctaagtaattccgttttattgtcctgagggagtaggatcgacgaactctacaag
+tcgctttgtcgtgccttataggctatttcgggtcaatgtagcgtcaaatgaactattgtc
+atctgtacgagttaactaagtgtctatcgccaactaaaagacgtctcgatggttctttat
+gcggacctgtcatatcattgactggcacttgcttacatccaaataacacgtttgttagcg
+gatagtcgttaagtgtgcgcaagatcatgaggcggggggggtaatatttcgccctctaca
+tgataaatgaataagtaagaagatgatctttttgtggcggtaccttaagcgtactcctgt
+cgacgagttactactaaaggaatgtagggttctggatctatgaaaagcgacctccatata
+tatacgggcctaagcggagtaaaataagtgatcaatggactaacattgaaatgttagtat
+tgtcgaccattgagggctggtaaatcttatttacgggcgtgggaaaacgaacgtgatatg
+gtttagcatgggatgcaagcactcgttaatgcttactttagttggttgcgggaacaacag
+gaggctatactaactggtagcgttcttgcttccattatgttattattataattaaaaata
+agacatatggtagagttgtagtcagggtggatcgggttgtctataacgttggaataatca
+aaactatcgttaacaaaaacgaaatttaagtcggtgcggtggaatgcgcctacctcatgt
+gcaccacacattcacagcacacccctcattataggcaaggaagcaaacaaaaaaaagtta
+atcgaccgtatccgaccttaaattttaaaataaatagaaacacttagcggtaatgaaaag
+ataggactaaaattcactagtatcctggaacgaggcaacagagttatctagatggtaacg
+aggtgctgcatcaagatgtatgatttttggtccgctgtgtggaatacctctattgatata
+caagtgactttctcggtaataacgcacttcacaatgtgttgtttcttttctatgtatttt
+gcaagagaaagaagcttagtataggtacacctcagagatgtttcgtgtaaatcgtatcac
+atggtataactgcaggaggaacattatccaaattcaccacaattactaatccaccctttt
+acttttactaaagatatattaattctcatgttgtctgaattgtataacccggtaccctgg
+gagcgtatcgaaggataccaattgaagtcctcgaggcatgttacaacacacgacttcctt
+ccgtctattcagacactcaacgagactaacttttcctaggtaatcaatgatattgggtaa
+ctcgtggcatcttatagttattgatccggctcttttgtagatcctgtgcgactcgtgcgc
+taattaagactggctctcttgcgcaggggatacgtttattctacgtacccgatttggtta
+ctactaagcggcctttcttcaaacttgcagttgtgacttacattcctatttcttcaaagc
+agggaagggttacagggagagacttattgagatacgattggaatttccatgtacaatcgt
+taatacgcttgtagaccagcaactcagtatagagatccgtttcctaaagggtgagcggta
+ggggcaaggcaataagaaattactaaaaccctagttgttaatataagaacgattcgaaac
+aataggattgcccaagggggtgcgaacatggtgtaaatcaaagagaaataggcattgtta
+aaacccgcacgtttctagtacgcaagaggaacgtcggtaaccagttctcaaagatcctaa
+cctaaaaggggcttattctactttttccgacactcaatggacgagacaaacatgaacgga
+tagctttaggtctcgttgaatgcaaagaatagaatcgttattattaatcggtttccatta
+tctatatgcggtatagatctccgagaggaccctgtaaactagctctgcggtttaactggt
+gctaatagaccgccactatgttattgcttctagctcctagcgtcttatcatgttatacat
+taatgtcgcatattggacagtagccaggcttggatggatcgccgacaaaaagaaaagact
+ttccctgtaaggacttaactattacatataacttggatcattaatctgcaaattagagta
+acggtctttcaccagcttcatattccaacgtggcgctagtcgatatcccatgaagtttaa
+aactagaattggcagtctcacttcacagtgcgtatctatacgacaaaagtggtcgatttg
+cataaatatcttatcgatattcaggttattaccgattccttgctaacgctagaagtcaca
+ccagagtaataataattccagacacctgtgaaataatcggtcactacggatagactagta
+acgataatacgtatagtccataaaagttgaattttaggggctaaagatattagcaatact
+ggtctagcctaatcgtcgatagcaaagggctgtgaggatttctcctacattttcgaccaa
+ttgtatcgataggaatagttacagtcacgcttgtagatgtaagagatgacgttattctta
+gggttcttaagtcggggggtaatttaagaccactagtaaaggtagaggcgtacacagtaa
+acgatattttgaaatcgtcaaaaaaaagtttacaacatcctttaagttagcaactgattt
+tagtggcaaccttaacggttgaattgatctactaatacaggcctacaccgaagggtacag
+ataatgattcttactaccctaacatgatagagtcctgtcctatctcataggtcgacattt
+taaattcgtaatgagcaacgaagatcgtttcccaatttgcaacattcacttatagacttc
+aggttatttcgtgctaacattaagatagaatataatcagtcgttaagaaactattatcca
+gctttcgtcaaccataaagattaaaaactgaaacttggcaagatatgaatagctatcctg
+ctttaaccgatcgtatgagatgctttgtagcaagaaaagtgactagcacttgtgtttagt
+aaagcgggagagtgcggtaattaatattaatatactattaagctacacagcaaaggctgc
+aataatgttagtaagtagaacataaaggtattctccacaagtaataaatagtgtgagcta
+attgactaacttaactctcgcgacaagtgatgtggataagatgactcatatcgtcttttt
+ctgtagtgccgacatcccacctggatcgaacaattccttctagttatcgactttgattac
+ctatcctattaaacagatagggttgtaaagtcagaaaatgatcggcttgcgttggtctac
+catagctagagttagaacgcgtagatagaggccttttgttgccaacgtgggggtgggatg
+agtctgggcgagcgtgactttctttcgtgtccgaatttgtttaacatccattagattaga
+tgtttgtgttttgggtctgatgtcctaactactttctcagtgaaactaatgtcatcatcc
+aagtaaaatagtccgatgaagtctccgttttcggccgaagcttgtctataacgtatataa
+agtcgctgaatttagaacacaccttatctatgttgtaaagttactttattccaaaggacg
+tgcacgaagcgtgagtgtgggaaggaacttaaagtcggatcactcttgtcagtgtagata
+agaatttctttcatacttcactggaatccggcgtatggatatctctaccgcgtcatctgg
+tggtgtctgcggtaaaaagtcttgctgcacgagtctgagaaatttttggtgccatcacat
+cgtaactgtacaacgaacaaatagcatcaggccttcttatccagcgtgaagtctaattat
+ttcacaagctttcctaagtatgtaaatccctcacttaatgatgcttgcgccaatgaggat
+agaggacattgcatgtacgtaggactattctccaaggggtcttctattttgttagcgaaa
+attgttacagcctaatgttagagcggcgtacgactttataccagatactttcattagata
+tgcaaatatccaattaaatcatagtagtatcgtggtatggacaatcaaaaaagacccgtt
+gtgatatgatgtttttctagttcgttctcatatatatagatcaacaatgaataatctcat
+gatctataaccgatgtatatttatattccggttgactgctccggtgcaattcactacgga
+cactaatgactaatatggcgcctttcatcagaaacgctaaatatgattaatgaattaagg
+gagtattatctaattattagagagtagcagttagtctgatattttcggtgtatgtgttag
+ccgttataatgctgtctttttatcagtgagaacagggagtgtgtagtgttgtatgcttca
+ctttatgactctggttatatccctcggagaacaagaataagagtacgagaagttcggtca
+ttgaggatgaaatagaaccgctagacgaatggactcacgtttataaaactatgtatcaca
+gtactacagctaactctgaagtccgagaagcttttgtaggacaaaacgttataagtacct
+ttcgcagaatacggccgtgcatacctgttataaggcgtagtagggacaccatgctatccc
+tcatatagagctacactaataccattacatggtgactatcgtttacggccatcatctgta
+agcgatcatgcctcgttagcatccgtacaatctcgcatggcgtcactgcagaaaaacccc
+gtgcggattttgagtcagaactattcgaagcttctcaatccttttccattatggcatagc
+aagtgacgactcgtcagccatgggaataatagcactaatccgattacttatgaattagaa
+cccacatgaatgtgattctgcgaattgtctaagaatctaatgattttccggtgaatatgg
+ttgttgttatttattgaacttatattattaacatcacccttcgttagtgatagtcagcta
+tttccaagaggttccccgagcatttttaccattctctagtcatacaagttggagcgcttt
+taaatctttaggctgatcaaggcgttttgtctagaattctgcagatgttagattcgtgtg
+caatccctcttgcatgtcagtaacaggtcacccgtttttcgttacatatgctggtaaaat
+attcatagtaataactacaatacttgatttgttacgtaatgctcgtacataacacaatcg
+tattccacggaacagtaaagctctattattctgatcgagcctaagagaggatcacactac
+gctattaaagtcacgttcacgaaatctcaaacctcaactgctggtgaccagttatagaca
+gtgtaattccatattacatgtcaggcttaagctaacccgagcctttatataagctataat
+caagaattagattggagtgcattttagacttatctatcgaaatagtgatagtaagagttt
+atatgacctgatctagactgatgttctcttccacaacagccttaaggcgtggagcctttc
+ttatactattaggtcgcgtcgagagccctattcgtaatgttaacgacactagactaatat
+acaatgagctaagaataacacaagtcacaagataatttacaaatcatatatctacagtcc
+acaaccatcactagcgattgcaaagcgttattggtactaccgctctaaatcggtatgtgc
+aagacgcgttaactggttcaagcctctcctgctcgtgagactgaaagaaatcgaaaatat
+ggatgtgcctaattgttcttgtgagtcatgtgcaactatacagtttagtttggtcaagac
+tatgcaactattaacagcatgtgcgcattgaatatttggtgtcgattgataaatgcccca
+acgttccatcacgtctataagccgtgttactaatgtgtattagtgcatacctattcagac
+catagttcaactgttggactgaaggcccgtcttggggttcgtgaatgagagtgcagtttc
+ttgtcttttccttaactgacctaaatgaaggcaatcggtttatctagagtcatgcttaag
+gtgaatttcagccaatgggctcccattgagctagtatggtgctttacctttgtaagtggt
+ggctttccttggtgtgctgactttaacacggcagagtgattatccgaagaatggataata
+agacgctggcaatattggctaataaagtccgatgagtttcaatcatgactgcgaggagat
+ccatgcggtgtacctaaacctacatcgtatgtatttgctgacgttcattcttgatacata
+aagatccgatatcggtccactttgtttaccaaaagccctaccttcgtaacgatggaaatg
+tgaatgagagtgaaatacacgatggggatattgccggtgagtacaagttagaccacacat
+tagaactgacctatattcgtcatcatagagatggagtatgaattgattctgcgaagtaca
+ctggctttacgagtatctagacgccgcggtatatctcccgtcaatactatgaaggtatat
+atatagaggctgaaaattcatgttcaatcctctttctaagagtgagtgggagccccttct
+gttgtcggagtaaaaaggcattattcctcaaattgtcagaagcaaagtatacgtgatgtt
+tgcttagaacaaaagagttaccttagggtaggtaaatctcgattcaccgagagaagtgat
+tttggcggtgtgcgattaattcttttgatgacagatctcattattttatatagctccctc
+tttgtatttagagtttgcgtaggtaacctggcaaaaccatatcccggggggagagtgcgc
+tgaacattttatacgatgtgattactcaaaggataaggttcgaggcctctatactcatgg
+aactatcttataattataatggatcgtggctcattccacctatccaaacttctttgtgat
+ctgatgctacgagtgtgaacaaacgtacatcttctaaggaatttgggacgtttcatagct
+cgcatttcattcctgaaaacttaaatatttttaaaaattgattctactgcgaggaactaa
+ggtgtagacaagcccttagtaaccggtggatgtcgcttcagttttatagcaaacattatt
+caatttcagtcttgactgaaattagtttgttagtgttagaggtccatatgtcacatgcat
+atggtctagatgccattgtacagtaataccttagattagtattagcggcatgcgtacttg
+gatttcacttgtaagaatgagcttaggacggtcgcctgtagggctgcaaataggaatact
+tacaatttttgatgacttgttagcatatcgctatcacccataaaaaacctgatacttgat
+gagcgggtgattgagactatgtactgatataattcaatagctccaatagatgaaacagct
+atgcgcctatttatgtcaaataatcgatgtgatacaagcttagagctgaacgagcgcgag
+tggaattagcggtgatctctatcctaaaaagccacgaaatcgatcccagaagctaatacc
+cgaggtgtcaagcttgagttcagttaaatttgcatctcatgccccacgaagaatgggtag
+agagtttgaaggtgcttctggattttcctaagtacgtggtaaaaatttgatgtaaatgaa
+cacctcctaatggttgtgttaaccacaaacccctgggtgaatctgattagccaacccagt
+gatctgatttcagttgtcaaatctcttttttataactaccttttgtttccataatttaac
+cggatctcataatgaacaaacgggtagaataatggtagcacatagcgagcttgtctattc
+agaaatatggcctactcagaatgtattctccaaatcagtgttatgcgaaacgtaatttta
+cgtgtaataatgatgatttcttatcggttccttgtactacaatactcttgcccaacaaat
+actaagcataacagcaaaattcgaatccccctccttttaataaatggtttttcaatatag
+ccgattcgtattcgttagtctttcaccaactattaacctggcatctaattaataaaatca
+ccaaaggactctataatatgacagtcacttcggcctcttttaagacagttgattattgca
+ggtccgcaattgatggtgacatgcacaattagttagaatccgactatggagacaattaac
+aattgtagtgcccatttggtccagttgacttcaaccacgagttataaaggtattttaatt
+tatagtcgatagtaccaacaacaagcacaatcataattatgttagaaaacccagggggta
+atgctctaaatccagctttaaggccagagtgcactatgaaatcgccattgatcattgtgt
+cattcgctgaacttggtgtctaggaggtgccgagtgagaatatcagataccttatgaagc
+aacgattatatctggactagatcatgatgatcggaataaaacattgaaataagtccttat
+caaggagcataaacattttatttaatttatacttcgtaaataaattcagaattttttttc
+aagacattaatctgagtaaatgacggctagaaagggttcctactcgaatcgtagcctacg
+catgtgggcagtaacctggcttgcgtttttactgaaacaaaggttcaccggaaagaaggc
+tgccacttttagcttcttgacgatctttagcgtcatatttttagattagtcgaaaaacgg
+aaaacaaacttaacgaagctggttgcacggggtaccgagaaaccaaagagcaggacaact
+ccttgatcgggaagaactgaaatagacagctgtcattttcattggtcaacttatcaatat
+aacgaccaccgtagtgacgcttgcatgaaaatactgaggatgtaaactatagccagtcag
+gcccgcgtgttgactaattgatgaagcaaacaaaatagccggtattcgttaaaaggaacg
+ggttgccagctacagatatactctaggtatatcccaaacaagagacgtcctttggctgtt
+gtaatcggtcataatacttgtcacataaacaagatcgctgaattaaacattaaacagtta
+gtgatacacaatcgtggttggggctgggatgtgcaataaaaagtcatctatcgtctatca
+cagagcgacgtaaatttagacaaacattattatttcttgacaatggaatcgataagcgtt
+cctctaacttggtatatatatctcgaccccgggattccagccattcttgtatgaagattt
+aaccatttaactatgcatagttgaatggtaaggaaaatgatattgactgcaacagatttt
+ggatgcaaaaatatttgtgaattattggttatatactggttgtatagcacaatcattagg
+tcctagaaggcatactcaacctcagcgagagagctagcatgcataattgtaccgcccata
+ttaatattcctgaaatgatttcttacattacgcccaatttcagtcatcgaacacccccat
+caatttacccgatagagaacgtgatcatacgcaataccctatgcgaacgtccactctata
+gcgtctgtatacaatgattattcgttccatttacaacgttaagtaatttaaacttacata
+aggacaaggaaatccgcgaacctcctggaatgtatgagttatttatgcagttaacttcgt
+ctcgaccggaactaaaggcgtcgtacgaatgaaaggccacttttagaagagacctttgta
+tccattgtggagaatatcataaattcaagatggggtgtcatgctattcggtcctaaacat
+tcttaatggctgttctattgttagtctgatttaaaatggaaccatagcacgaatagttag
+atagggctcatacccctgtaacgatctacaaatccttccccgggtgtgtgcgttagcgac
+ggaaagttttacggtttgtgatcaaagaacactcacacgtcagattattacactgatacg
+aattatttcagtcgacagtaattgaatagaaacttattaacgccagcacctgacacggta
+agtaaggcaggtctgaactgtttgactgtaaaaaaatggtaatatttttaaaaatcttga
+tttctatatcaaatgatgtgtagttttttctctgttattaaaatcccagtgcgcgaaatt
+tagatcgttacgactcacgtacaagatcacacatcacacgcgttagcgaaagcggaatgg
+ctaatacagccctacgcaacgtagtgggatcaacatatggacgaatttatgctcaatgag
+ccaacctcccccgcattgcggttcattttaaggcctgggtaacatctatcgtttagataa
+tcaaaggaatccgactatgcaattgtctgacttcatccgctctcaagtccaatgcaggcg
+ctacgtgtttctttaatcaataccatattgaaatcgtaatacgataattgttgctattga
+ctacaggttatgaaaaaacttactttgcgggtacatgcatatttttgtaccacattatta
+cgcgatatctctcagtgtactctaaattaaaccctcttcgaacattttagttcctattcg
+taaacacgtgctacgcggcaatttgccggtcgtagaatggacaactccagttcaactgca
+tgtaactcatagctcgcgttagtataaattgactagtagccatgggacaaagtaactagt
+cagcggaaaagatccctttaaagatatatgcaggttgcaagcataaagctcattgctcga
+ggtgcaccgtggtattccaaaagcgtctctatcgtatcttctaattttgggccgtgagaa
+tcgaaactactctgatttgctgcacacgttaggtaatatcgcccattttcccgtataagc
+tccgtacttatacgaactacacgaccttttaagcattagccgctcatatcgtgattcgtg
+tacagatgagtctattaaaattacagacatactccatatctcgctccttgaactttgaat
+aatgcgctaacttgtactatgaataggcagaacccaactttcccgtttgcgtcaagcggg
+gaaacgatacatgttgtcagatttatgattatctagttttagatcacgtttaccgataat
+cggctgtggtctgagcagtcctacactgagtatttacttcagcttcatatcggtccgaaa
+aaaggttgtgaccgaatgtcaaaatacggagtacgatgggcatcttttttcgagtcgcgg
+ttgcagggcagcaaaaggcttaaaccatttttacgatttttactatagcggtcatgaagt
+gcgaaactgcttgcaaattttctacacacattgtggctcttgtccttgaagcttatggcg
+aaaatttgaaacatagtataccagggaaagcgcgaattatttggtgactaatagtccgtg
+ggtttgagccatatacctaacgccataaactacgtggtgctttagatgcaatctaaacag
+aacagaaagcgtagcgctcatcagcacagactaactttttcagtttgagtcgccggaggg
+acttcgagacaagaacgcgtcaagtcgcttgcgcggcacggattcgattgggcggctcaa
+tcttgcctaatttctactattgtcagctgtacgactgtactaagtgtatagccccaaata
+aaagaagtatcgatgcgtctttatgaccaaaggtcttataattgaagcgcacttccgttc
+atcaaattaaatcctggcttacccgattctccggaagtctgacctagagattgacgacgg
+ccgcgtattattgagacctcttcaggattaatcaataacgaagtagttgatctgtttggc
+gacgtaccttaagccgactccgctacacgagtttctactaaaccaatgtagccttatgct
+tagatgaataccgtcctaattagatattccggcataacagcagtaaattatctgttcaat
+ggacgaacattgaattgttagtattctacacaagtcaggcctcgtaaatattaggtaagg
+ccgtgggataacctacgtgatatgcttgagcttgcgttgcaagctctcgttaatcattaa
+tttaggtgcgtgagggttaaacaccagcatattctatatgctagacgtcttccttaaagg
+atcgtagtattataattaataataagaaatatggttgacgtctagtcagcgggcatacgc
+tgctctatatactggcattattcaaaacttgacggtaaaaaaacgaattttaaggcgctc
+acgtcgaatgagccgaactcatgggaaccaaaatgtcacagaaaacacctctttattgcc
+aagcatgcaataaaaaaaatgttaatagtacgtttacgacattttattttataataaaga
+gaaactattacacctattgatatgataggacgtaaattaacgagtagcctgcatagaggc
+aaatgaggtttctacatggtatagacctgatgctgaaacatcgatgagttttggtcccct
+cgctcgttgaaatctagtcatttactactgtctttcgagctattataccacttcactatg
+tggtgtttctttgctatgtatggggctagtcaaacatgatgactatagctacaactcaga
+gagcgggcgtgttaagagtatctcatgctagaactgcacgacgaacttgatacaaagtaa
+caacatttacgattccacaaggtgactttgaagaaacatagtttaattctctgcttcgat
+catttctataaaccggtaccatcgcagcggatagatgcataacatttctactactccagg
+catcttaaaacacacgtagtacttcactagattaagacacgataagtgtataacttggca
+gtgggaagcaaggagattggcgaactcctggcatctgttacgttttgttcaggctcggtt
+gttgataatgtccgactcctgccatattgaagactcgctcgagggagatcgggattcgtt
+gattataagtacacgtgttccgtaatactatgaggcagtgattcaaaatggcacttctga
+cttacatgactaggtattattaccacggaagcgttaaaggcacactcttatggacttaag
+attgcaagtgccttcttctagcctgaattcgcgggttcaacacaaactctctttagacat
+ccgttgcctaaaggctgagacgtaggggcaaccctttaactatgtactaaaaaactagtt
+ggtaatttaacaacgtgtccaatcaagacgatgcaccaacgcggtgcgaaaatcgggtta
+agcaaacacaaataggaattgtgataaaccccaccttgagaggtcgcaagaccaacctcg
+ggaacaacggctctaagagaataacctaaatccggatgagtagactgtgtaactctctaa
+agggaagtgaaaaaaagctaagcatacatttaggtctcctgcattgcattcaattgaatc
+gtttgtattatgagctgtacagtagctatatcagctatagttatcccagaggaacaggta
+aactagctctgagcgtgaaatccggatattagaacccctagatgggattgattctagcta
+atacaggcttatctggttttacagttatctagatgattggtaaggtgaaacgcttggtgc
+cttccaccacttaaacaaaagtattgcccgggaagctattttctaggtattataaagtcg
+agcattaatatcaatttgacagtaaaggtctttcaccagcttcatatgccatagggccca
+tactcgatttaaattgaacggtttaacgagtattggaactctcacttataactgagtagc
+tatacgaaaaatctggtccatttccagaaatttattatcgatttgctgcttagtacccag
+gaagtgataacccttgaaggcacaacactgtaataagttttcctgtcacatctgtaatat
+tcggtcactacgcattcacgactaaagataattactatactaattaaaagttcaatgtta
+gggccgaatcatagtagaaattctcgtctagcctaatcggacttacctatgggctgtgag
+gatttatcagtatgtggacaaaaatgctagagataggtatagttaaagtcaccatggtac
+atctatgtgaggaagtttgtagttcgcttctttagtccgggcgtttgggatgacaactac
+tatacgtagagccgtactcaggattagatagtgtgaaagagtcaaataaaagggttaata
+ttaatttaacgttgcaaatgtgtttaggccaaacattaaccgttgtagggatattctaat
+acaggccttcaccgaaccctaatgataatctgtcttaataacattaaatgattgtctccg
+ctacgagctcttagggcctcattttaaatgactaatgtccaaagaagagactttcccaat
+ttcaatctgtcacgtatagacggcaccttagtgagtcatatcattaagatagaagattat
+caggagggaagtttctattatcaaccgttacgcaaccataaacttttaaatctcataatg
+gcattgagatcaagagctttcatgatggtaaagttcgtatgtgatgctggggagctagat
+atcggtataccacttcggttgtggtaagcccgagtgggccgttagtaatattaatagacg
+attatccgacaatgcattcgctgaaataatcttacttaggagaaattaatgctatgagcc
+aaaactatttatgtctgtcacattattgactaaagtatctatcgacaaaactgatgtcca
+taagttgtagcagatagtcggtgtatggtgtcaccaatgaaaacctcgagcgaaaaatga
+attatagttatccaatttgagtaaattgcctattatacagataggcttgtttagtcagat
+aaggttccgcttgaggtgctctaacttagcgagagttagaaagcctagtgagaggcattt
+tggtgccaaactccggctcgcatgagtaggccagagagtcactttctttcgtcgaagaag
+ttggtgaacagccttttgattagttgtttgtcttgtggctatgtgctactatataagtta
+gaacgcaaactaatctaatcagcaaagtaaaataggaccttgaacgagacggggtacgcc
+gttgaggctcgagatagtagataaactagaggaatgtagataaaacattagctagggggt
+ttagttactggattacataggaagtgcaccatcacggtgtgggggttcgtacgtaaagtc
+gcatcaatattgtcagtggacttaacaagttcgtgcataatgaaatcctatacggacttt
+gcatatctctaccgactcatctggtcgtctatgcgggtaattgtattgctccaagtggat
+gactattttggcgtcccagcacatagtaaatgtaaatccttataatagcataagcaatta
+ttagactgcgtgaagtcttagtagttctcaagctttacgttgtatgtaaataactcacgt
+aatcagccgtccccaaatcaccattgaggtcattgaatgtacggagcactattatcaatg
+cggtatgcgattttctgagcgattattgttaaagacttagcgttgagccccggaacactt
+gattacagattctttaaggagttatccaaatatcattttaaataatagtagtatcgtgct
+ttggacaataaaaaaagacccgttctcttatgttgttttgcgacgtacttctctgatata
+tacttcaactatgaagattctattcatcgataacccaggtatatttatatgcccgttcac
+tgcgcagggcaaattatctacggacaataatgacgtagttggacccggtaagaactaacg
+cttaatatgattaaggatgtatgccagtattatcttattatgtcagagtagaagtttctc
+tgagattttccgtcgttgtggtacaccggatttggctctctttttagaactgagaactcg
+gagtgtgtagtcttgtttccttcaatttatcaatatgcttttataccgccctcatcaact
+ataacaggacgacaagttccgtcttgctccatcatatactaccgatacaccaatcgtatc
+aagtttagtatacttgctttctctcttctacagcttactcgcttgtccgagaagcggttg
+gtgctcataaagttagtagtaaatgtacaactagtagccagtccttacctgtttttacga
+ctactacggacaccatgagatacagaagttagtgctacaattataccattacatgctcaa
+tatcgttgtcggccataagatcgaagagtgcatcacgcgtgtgaatacgtaaaatctacc
+atcccgtcaatgcacaaaaacacactccccttgttgactaacatcttttacaagaggcta
+aatcattgtccaggatcgaataccttgtgtacaatcgtcacccatcggaagaataccact
+tttccgatgtagtatgatttacaaaaaacatctatgtgagtaggccaattgtagtagaat
+atattcatttgaccgtcattagccttcttcttaggttgtgtacggatagtaggtacataa
+accgtcgtgtggcatacgctgcgatttcatacagctgccaacaccttttttaccaggcta
+gagtcagaaaagttggagccatgttaaatagttaccatcataaaccactgttgtctacta
+gtctgatcagctttcatgcctgtgcaagcaatatggattctcacgtaatggtaacaactg
+ttgcgttacttaggctggttaatttgtcagagtaataaatacatgtcttgttgtgtttcc
+taatcctcggaaagtacacaagcctaggaataggaaaagtaaagctcttttattctgata
+gtgactaactcaggatctaaatacgcgattatactaaccttcaccaaagctcaaaaatca
+tctgctggtgaccagttatagacagggtaattcaatatttaatgtctcccttaacatttc
+accagcatggattgaagatagtataaagttttacatggcagtcattgtgtcacggttcta
+tacaaattctgatagttagacggtatttgaaatgtgcttctagcatggtatcttacacaa
+ctgaatgaacgactggagccgttcgtatactatttgcgagcctcgagaccccgtttccta
+atgttaacgaatatagtataatataaattgtgatatgaataacacaagtaactacagttt
+ggacaattaattgttctaaactaaaaatcattcacttcagatggcatagagttatggcta
+ctacacatataaagcggtatgtgaaacacccgttttagccggaaaccctctactgctcgg
+gacaatgaatgatttccaaaatatggatgtgcagaattgttagtgtgactcaggtccaaa
+tagacactttagtttcgtcaagtcgttgcaaagtttaaaaccatcgcagcattctttatt
+tggtctacattgagaaatgaaaaaacgtgacagaaagtctagaagaactgtgaataatgt
+ctattactgattaactagtaagacattagtgcatctggtccactgaagcacccgcttggc
+gttaggcaatctctgtgaactgtcgtggctgttccggtaatgtacgaaagcaagcctata
+ggttgatcgagtcgcttcattaaggtcaatttcacaatatccgatcacattgtgctaggt
+tcgtcctttaccttgcttagtgctgcatgtacggggtgtcatgacttgttatcggcagac
+tctttatcccaagaatggataatatgtacatggaaagtgtccataattaagtcccttcac
+tgtaaagaatgactgccacgtgatccatgaggtctacagaaaccgacttacttgcttttt
+gatcaacttaattatggattcataaagttcagatatcggtacaattggtgtacaatatga
+aattaatgaggaaacatggaaatctgaatgacagtgatagaaaagatccccatttgcccg
+gtcagttcatgttacaccactcattagtactgtaagtgtttcgtcagcattgagatccac
+gatcatgtgtttatgccttcgaaactggatgtacgacgatcgagacgaagaggtatatat
+aacctaaatactaggtacgttgttagagagacgatgaaaattaatcgtcaatacgctggc
+gaacactgagggggacccaatgctcttctcggtctaaaaaggaatgtgtcagaaattggt
+cagttcaaaagtagaccggatctttgcggagaacaattcacggaacgtagcgttgggaaa
+tatcctttctaccacacatcggattttcgccctctcccattatttattgtgttctcacat
+agaattattgtttagacatccctcgttgtatggagagttgcccgagcgtaaaggcataat
+ccatataccgccgggtgagtgacctgaaattgtttttagttgggatttcgctatggatta
+gcttacacgaagagattctaatggtactataggataattataatgctgcgtggcgcagta
+caccgttacaaacgtcgttcgcatatgtggctaacacggtgaaaatacctacatcgtatt
+tgcaatttcggtcgtttcatagagcgcattgaattactcaaaaattatatatgttgatta
+tttgattagactgcgtggaaagaaggggtactcaagccatttgtaaaagctgcatctcgc
+ttaagtttgagagcttacattagtctatttcagtcttctaggaaatgtctgtgtgagtgg
+ttgtcgtccataggtcactggcatatgcgattcatgacatgctaaactaagaaagtagat
+tactattaccggcatgcctaatgcgattgcactgctatgaaggtgcggacgtcgcgccca
+tgtagccctgataataccaatacttacatttggtcagcaattctgacattatacctagca
+cccataaatttactcagacttgaggacaggctcttggagtcgatcttctgtttgtatgca
+tgtgatcatatagatgaataagcgatgcgactagttagggcatagtatagatctgtgtat
+acagttcagctgaacgtccgcgagtggaagtacagctgagatctatcctaaaatgcaacc
+atatcgttcacacatgatatgaacccagggggaaacattgagttcagttaaattggcagc
+gaatcccccaagaagaaggcggagtgacgttgaacgggcttatggtttttcagtacttcc
+tccgtataagttgagcgaaatgtaaacagaataatcgttgtgttaacaacattaaaatcg
+cggaatatgatgagaatacacagtgtgagcatttcacttgtaaaatatctttggtagaac
+ttactttgctttaaatatgttaaaccgatctaataatctacaaaacggtagattttgcct
+agcacattgcgtccttctctattcagatagaggcaatactcagaaggttttatccaaagc
+actgtgttgactaacctaagttttagtctaataatcatgattgattataggtgccgtgga
+ctacatgactcgtccacaaataatacttagcagatcagcaattggccaagcacccgactt
+ttatttaatggttgtgcaatagtccagattcgtattcgggactctttcaaataatagttt
+cctggcatctaagtaagaaaagctcataaggaagcgatattatgacacgctcttccgccg
+ctgttttgaaacttgagtattgctcgtccgaaattgagggtcacttcaaaatttactgag
+aagacgaagatcgactaaagttaaaatgctagtccacagttggtcaagttgaattcatcc
+acgagttatatagctattttaatttatagtcgagtgtacaaaaaacatccacaataagat
+ttatcttagaataacaacccccgtatcatcgaaatcctccgttatggcctgactcctcga
+gcttatagcatttgtgctggcgctcttgccaggaacttgctcgcgaggtggtgacgagtg
+agatgatcagtttcattatgatgatacgattttatcgcgactagttaatcatcatagcaa
+gtaaaatttgaattatgtcattatcatgctccattaacaggttatttaattgatactgac
+gaaattttttcacaatgggttttctagaatttaatatcagtaattgaagccttcataggg
+gtcctactagtatcctacacgacgcaggtccgcagtatcctggagggacgtgttactgat
+taaaagggtcaaaggaatgaaggctcacaatgttacctgcttcaccatagtgagccgatg
+agttttacattagtactaaatcccaaatcatactttacgatgaggcttgctagcgctaaa
+gagaatacatacaccaccacatagaattgttagcgatgatatcaaatagactcctggaag
+tgtcagggggaaactgttcaatatttcgtccacaggactgaccaggcatggaaaagactg
+acgttggaaactataccatctcacgcccgacgcttcactaattgatgatccaaaaaatat
+agcccggattcctgattagcaaagggttcacagagaaagatattatcgacgtatatccca
+aaaaacagacgtaatgtgcatcttcgaatcgggatgaatacttgtatcataaaaatgtga
+cctctagtatacaggttaatgttagtgatacacaatactcgtgggccatgggttctcaaa
+taaaatgtaatattgcgtcgatcactcacccacgtatttggtctaattatgttttattta
+gtgacaatccaatagataaccggtcctattaagggctatatttttagcgaccacgcgttt
+aaacaaaggattgtatgtagatggtaccagtttaattgccagtgggcaatcctaagcaaa
+atgagattctatcctaaagtttgggcttgatataagatttcggatgtatgggttttataa
+tcgttggagagctcaatcatgagctaatacatggatttcgctacctcaccgagagacctt
+gcatgaagaattctaaccaaaagtttaataggccggattggattgagttaattaagacct
+tgttcagtcatagtaaaaacccttaaattttaccgattgacaaagtgagcagtcgcaata
+ccctatgcgaaacgcctcgatagtgactaggtatacaaggtttttgagttcctttgaaat
+agttaactaatttaaaattaattaacgacatggaaatcacagaacctaatgctttgtagg
+agttatttatgctgtttactgcctctacaaccctaataaagcagtcctaagaatgaaacg
+catcttttagttcagaaagtggtatccagggtggtcaatttaataaattcaacatcgggt
+ctcaggatattcggtcatataatttattaagggctcttcgagtcttactctgagtgaaat
+tggaaacagtcatccttttcgttgtgaggcatcttacaccgctatcgatatacaatgcat
+tccaccgcggtgtcccgtacacaaggaaacttgttaccttggggatataagaaaactcac
+acgtctcattattaaactgagtacaatttttgcacgagaaagtaatgcaatacaatatga
+tgaaagccagctaatgaaaagggatggaacgcacctcggatctgttgcactggattaaaa
+tccgattatttttaaaaatattcagtgctagagcatatcaggtctacttttttatctggt
+atgtaaagcccacggagcgatagtgagatccttacgactcaacgaaaagttataacataa
+ctcccgttagccaaagcccaatcccgattactgccctaccctaacgtctgccatctaaat
+atcgaacttgttatgatcaatgtgactacctcccaccctttccccttcatttgttccact
+ggggataagctagcgttttcagaatcaatgcaataagaatagccaattgtctcacttcat
+cagagctcttggcaattccaggcgctacgtggttctggaatatattcatttttcaaatag
+taatacgtttagtgttgctattgtctacacgtttggatattacgttatgtgagcggacat
+caatagttgtctaactctttagtaagccagagatagcactcttagcgaatggataccatc
+ttccataagtttagttaatagtccgaaacaactgcttcgagcatatttgaacctccttgt
+aggcaaatagcctcttcaaagcaatcttactaatagatagagtttgttttaagggactac
+tagaaatgggacaatcttaatagtatgacctaaactgacatttaaagatatatccaggtg
+gcaagcataaagatcattgcgccacctccaccgtgggattacttatcagtcgatatccta
+tatgctaagtttgcgacggcagaatacaaactaagctgagttgatgctaaccttacctat
+gataccccattggaccggttaacagccctacttattccaaataaaagaacttttatgctg
+tagaagctattatagtgatgcctggtaacttcagtatattaaaatgacacacatacgcca
+tatagagctcctggaactttgaataatgagcgaacttcgaagttgaagagcaagaaacca
+tatgtcacggttgcctaaagcccggtaaccagacatgtgctatcattgatcattatcgag
+gttttcataaccttgacccattatcggctgtgcgcggacaagtacttaaatcactagttt
+cttcacctgcttatcggtaagaaataaggttggcaaagaatcgcataagacggacgtaga
+gccgcagcgttgtgcgagtccaggtgcatgcgcagcaataggattttaaattttgttcca
+tttttaatttagccgtaaggatgtccgtaaatgattgaaaattggattcaatctttgggc
+ctatgctactggaacctgatcgacaaaatttcaaacatacgttaactccgaaagaccgta
+tttttgcggctagaatagtcagtcgcttggagccatataccttaccacttaaacgacgtg
+ctcctgtagttgaaatataaacagaacacaaagactaccgatcatatcaactgaagatct
+ttgtaactttgaggcgaagcaccctcttcgagacaactaagagtaaagtaccgggcgccg
+caaggagtcgattgggaccctaaatcttgacgaattgctaagaggctcagagctaccact
+gtaatttctctagagcccataataaatgaacgatacatccgtaggtagcacctaagggat
+tataatggaagccaaatgcagttaataatattatatactggcgtacacgattcgacggat
+ctctcacatagtgattcacgacccccccctttgattgacacagcgtcagcattttgcaag
+aacgatcttctgcatagggtgcgccaccgtaaggatgacgtcgaagctacaactgggtat
+aatttaccatgcttccctgatgctgagtgcaatacactaagaatgagtttttaccccata
+tcaccagtatttgttctgttattgcgaagaaatggctatgctgagttggcgactaaagtc
+acccatcctttttattaggtaaccccctcccttaaactaactgatttgctggagctgccc
+tgcatacatatactttatcatttatggacgtccgtgacgcttattatccaccatagtcga
+tatgctacacggattcattaatggatcgtaggagtttaagttatatttactaagatcggt
+ctcggctactatcccgccttacccggcgctatttacggccatttttaatatattgacggt
+aattattcctatggtttcgaccgcacgtccttggacaagaaagaatggcaaaaaaaatgt
+aaaagaaaaaaaatattgagtccctaccatcatataaaaaatatgtgatgagtaacttga
+cgaaatgttagtggttattaaagactatctattacaccttttgttttctgtcgtagtata
+ttaaagtctagaagccttacaggaaaatcagggttatacagccgatactccgcagcatga
+atcatcgaggaggtgtcctaccatcgcgccttgtaatcttgtctgtgtatactgtattta
+gaccttttatacaaagtaaatatctcggctttatgtgattgggaggggcctactcaaaca
+tgatgacttgacctaataatcactgtgcgggcgtcttatgactagctattccttgaaatc
+caccaccaaatggttaatatgtaaaaactttgacgatgaaacaaggtgaatgtgtagtta
+ctttgtgtaattagctgcgtcgagcattgcttgtaaaaccgtcaatcgcacacgttactt
+ccataaaatttctacgaatacacccttcttaaaaaaaacgtaggaattcacgagtttaac
+aaacgataactgtataaagtggaagtccgaagaaagcagatgcccgaactactcgaagat
+gtttcgttttcttaaccataggggcttcttaatggcccactacgcacattttgttcaagc
+ccgagagggacatccccattacgggagtattactaaaactgttccgtaatacgttcagca
+agggatgaaaaaggccactgctcaagttattgacgtgggagtattacatcggaagcctga
+atcccacactatgatggtctgtacaggcctagggactgcgtctagacggtattaccggct
+tctaatcatacgatcgtgagtcttaacgggaagtaaggctcacacctaccccaaaccatt
+tatctatgtaagtataaaattgtgcgtaagtgttcaaagtggacaataaagacgtggcaa
+aaacccccgcacataagccgctttagatttcacaaataccaatgcggttaaaaacatcct
+tgagtcgtacatacaccatactcgcgttaaacggatataacagaagataataaatccgga
+tgtggagtcggtgtaactatagaaagccaagtgaaataatgcttaccagtcatttagcta
+tacggctttcatttcatgtcaagagggtggagtttgacctgtacagttgatatatcaccg
+atacttagaactcacctaaagctaaaattgctcgcagcgtgtaatccgcatattacaaac
+aatagatgggattcattatacataagacacgatgatctgctttttcaggttgcgagatgt
+tgcctatcgtcaatcgagtcctgccttacaccacttaaacaaaagtattgacagggaacc
+tattttcgaggtattatatagtccagcttgaatatcaatttgacagttaacctagtgaaa
+atcagtaagaggaaatacgccacattctccagtgaaattctacgggttatcgtctagtcc
+aactatcaattataactcacgagatataagtaaattctcgtacttggcctgatttttatt
+atactttggatccttagtaaacaggaagggagaaaccttcaacgaaaaacactggatttt
+gttttactctcaaagctcttatatgacggaaataccctgtcaagtcttaactttattact
+agactaatgaaatgggcttggggtggccagaatcatagtacaatttagcggatacactat
+tcggactttcctatcggctgtctggttggataagtatggggactaataggctagacatac
+ctatacttaaactatacaggcgtcatctatctctgcaactttggagttccctgatgttct
+cccgccctttgggttcacatcttctataccgacacccctaataacgattagtttgtgggt
+tagagtaaattaatacggttaatattaatgtatcgttgaaaagctggtgtcgccaataag
+gtaaccggctaggcagagtatatgtcacgaagtataactaccctaatgataagctgtagg
+aataaaattaatgctgtctctaagcgaagagatatttccgactctgttttaatgacgaat
+ctcattacttctgacttgcaaatgttcaatatggcacggtttcacggcacctttgtgacg
+catataatgaacttagaagattataacgacggaactttatatgataatccgttacgatta
+aagaatctgttaaatatcataatggcattcagttctagaccgtgcatcatggtaaactta
+ctttctctgcatggcgacatacatttcgctattcaaattcgcgtgtggttacacccactc
+gcacctttggaatattaagagaagatgatcagaaaatccattcgctcaatttttctgacg
+tacgtctaatttatcctaggagacaaatcgttttatgtctctcacatttttgaagaaagg
+ttcgagagacaatactcaggtcctgaactgctagaagatactcggtggagcgtggcaaca
+atgaaaaactcgtgacataaatgaatgatacttttccaagttcagttaagtgaatatgtt
+taacatacccggcttttcgatcttaagctgacgctggacgtgcgagtaatgtcagtctct
+tacatacactagtgactccaagtttcgtcaaaaacgccccctcccttctcgagcccactc
+acgctatgtattgacgcgaacttgttcgggatcagacttttcaggagttcggtcgcgtgt
+ccctatgtgctaatatataagttagatcgcattagatgctaatctgaatacttatagacg
+accttcaacgagaacgggtaccaccttgaggctagagttaggtgtgaaacgacaggtagg
+gacatataaaatttgagtgcggctttagttaagggtttaattacctactcaaacatcacg
+ctcgcgcccttcgtacgtaatcgaccatctagaggctaaggggactgtactaggtagtga
+ttaatgatatcctagacgcacgtgccttagatcttcagactctgatggtccgcgatcacc
+gtaattgtagtcctccaactcgatcactttgttggcgtcaaagaaattacgatatctaaa
+tacttataatacaataaccaaggatgagaatgactcatcgcgttggagttatattgcttg
+aagttctatggaatgaaagcacgttatctgccgtcccaatatctccagtgagctaattca
+ttggacggtccactttgatcaatccccgaggagatgttcggacactttagtctgtaacac
+ttagcgttgagaccacgaacaattgattactcagtcttgaaggtgttttccaaagttcat
+tttaaataagactacgataggcctttcctattgatataaactacccggctctgttgttcg
+tgtgagtcgtacttctctgtgtttttctgattatagcaagattcgattcttagtgtaaac
+agcgatttttatttgacccgtcaatgagaagcgcataggatctaagcaaaattatcaagt
+tgtgccacaaggtaagatctttccagttattgcaggtaggatgtatcccacgttgatagt
+atgaggtctgacgtcaactgtctaggagagttgaccgcgtgcgggtacaccggatttgca
+tcgatgttgagaacgcagaactcccactgtcgtggcggcgttcctgatatttagcaagag
+gcgttgataaagccctcatcatctagatctcgacctcatctgccctcttgctccatcatt
+ttctacacagactactttcctatctacgttagtataattgctttctatcttagtatcatt
+tagagcttctccgtcaacaggttcgtgctattaaagttagtacgaaagggacaacttgta
+gcaacgcatttaatcggttttcgactacttcgcacaaaatcagataaagaagtttgtcat
+tctattagacattgaattgcgcaattgacttgtaccacttatgatcgaacactgaatcaa
+gactgtgattaactaaaatagacaagccactatatcaactaataaaaacgcccctggtgg
+tcgaacatagttgactacaggataattaattggactggagccattacattctctacaatc
+gtatcacttcccaagtagacaactttgaccttgtagtttcatgtacaaaaaaatgctttc
+gcaggagcacattggtagttcaatagtttcatgggaacctcttgagccgtcttctgtggg
+tgtgttcggatagtaggtactgataaagtcgtgtcgctttcgatgagagggaattcaccg
+gaaaacaccttggttaacaggatagtctatgtaaacttcgagacatgtttaagagttacc
+agcttaatccacggtgctctactagtatcatcagctgtcttgcctcgcctagaaatatgc
+attctatcgttatcctatcaacggttgccgtactgagcagccttattgtggaagagtaat
+atataaatgtagtcttgtctttacgaagcagacgtaagtaataatgacttggaataccaa
+aactaaacatagtggattatcatactcaagaactctccagataaataacagtttttacga
+tacgtcaccaatgagcttaaagattaggatcctcaaaactgatacaaacgctaattcatt
+tgttattggatccagtatcagttaaactgaatggagtgaagattgtagaatgttgttctg
+gcctcgcatggggtctaggtgatatacaatttctcatacttacacggtagtggaaatctg
+attctagcttcgtagctgactatactcaaggaaccactgctcaaggtaggagactagttc
+cgaccctacagtcaaagtggccgaagcttaaactatagactagttgttaaatgctgattt
+caagatatcatctatatacagtttggacaattatgtgtgcgaaactaaaattcatgctat
+tcagatggatttcacttatgccttagaaacagatattgcccgagctcaatcaacagtttt
+agccggaaacaatcgaagcatagggacaatgtatcttttcctaaattgccatgtgcagat
+ttctgagtgtcacgaagcgcataatagaatcttgtgttgcctcaactcgttgaaaagttt
+aaaacaatcgcagcagtctttttggggtctactgtgtgtttgcaaaataactgaaagaaa
+cgcttgaacaactctgaagtagctcgagtactcattaaagtgtaacacattagtgaatat
+cggccaatgaaccaaacgcttcccggtacgctatctctctcatcgggaggcgatgtgcag
+gttatctacgaaagcatccctttacgttgagagtgtcgatgcatgaacctcattgtaaca
+atagcccagcaaattctcatacgtgcctcagggtccgggcgtactcctccatggaagggc
+gcgcatctagtgttataccaactcgctttttaactactatgctgtagttctacaggcata
+gtggccagtattttctaacttctctggatagatgctctcactcctcatccatcacggctt
+cagtttacgtcttacttgcttgttcagcaacggatggaggcattaagtatcttcactgtt
+ccctaaaattgctgttcaatatcaaagtaaggacgatacagggaaagctcaagcacactc
+attgaatactgccccagttgcaacctcacttaatctgacaaaaataatgactactctaag
+tgttgcggaagcagtctcttccacgagcttgtctgtatcacttcgtataggcatgtaact
+cgatagacacgaacaccgagtgagaaactatattcttgcttccgtgtgtgtgacaccagg
+taattgatgcggatataagctggagatcactcacgcccacacaaggcgctgctacctctt
+tattccaatgtgtaagaatttgctaacttcatttctagaccgcagctttgcggtcataat
+ttcacggtacggacccttgggttagagacttgataacacacttcgcagtttccaccgcgc
+acatgttttagtggcttctaacatagaatttttgttgtgacataaagagtgcgtgggaga
+cttgcccgaccgttaagccataatcaattgaaagccccgtgagtcacatctaattggttg
+tactgcgcatttagctatcctttagctgactcgaagagattcgattcctaatataggtta
+attagatggctgccgcgcgaagtaaaacgtgaaaaacgtagtgcgcagatctgcataact
+cgcgcttaattacttatgagtagttccaagttcgctacgttatgagagagattggaatta
+agcaaatatgttttatggtgattttgggatgagaaggactgctaagtacggctactaaac
+aaatttctaaaaccgccatctaccttatcttggagacatttaagttgtatatgtcactag
+tctagcttttgtctgtgggacgcgttctcggaatgagggaaatgcaagagccgattcatc
+aaatgcttatctaagaaagtagtggactattacaccaagcacgaatgccagggaactgct
+ttcttgctcaggacctcgcgacaaggtaccccgcataagtcctagaattacatttggtca
+gcaatgctgacatttgaccgtgaaaacataattttaatcagaaggcagctcacccgcttg
+ctctagatcttatctttgtatgaatgtcagaatttactgcaatatccgttccgaatagtg
+agggcttagtatagttctctgtatacaggtcacatcaaactccccctgtcctagtacagc
+tctgagctttaattaattgcatacatttccttcaatcatcagatgaaaacaccgcgaatc
+atgctcttctcgtatagggcaagagaagcaacaaacaactagcccgactcacgttcatcc
+gccgtatccttgttcagttcttactccgtattaggtcagcgaaatctaatcagaataatc
+ggtcgcgtatcaaaattaaaatcccgcttgaggttgacaattaaaacgctgagcagttat
+cggctattagatagtggggtgaaagtaattggctggaattatgttaaaacgtgatattaa
+gctaaaatacgctacttgttgccgacctaattcagtcattcgatattcagttagagccaa
+gaataacaagcttgtataaattgaacggggtgcactaaacgatgtgttactctaatattc
+agcttggagtatacctgaaggcgaattcatgtatcggccaataataagacgttgaagatc
+acaatttggactagcaaaagaaggtgatttatgcgtggggattgagtccactgtacgagt
+acggtctctggaaaattataggttcagggaatataaggaagtaaagataattaccaagag
+atttttggtatcgctatgacccagaggtgttctaacgtctgttttgatccgcagaatttc
+tgcctcaatgcatatttgacggacttgaactagagcctctaaagttaaatggcgacgcaa
+ctgttcctaaacttcaattattactactctttttttcctagggtattgtagaggccagtg
+gacaaaataaatcaaatttaagatgtttcggacattaacatcccccgtagcatagaaatc
+atcagttatccaatctctcatcgagcttttacaatttctgctggcgctatggacagcata
+tgccgcgagacctccgcaagactcacttgatcactgtaagtatcttcattagaggttaga
+gcctatagttaagctgctgacctagtaaaattggtattttctaattttattgctcaagtt
+aaaggttagtgaagggataatgacgttatttttgaacaatgggttgtattcaattttata
+tcacgaatggaacccttcattcccggcataatactagacgacacgaacaagctccgatct
+atcagccaggcacgtgttaaggtttaattccggcaaaccaatgaagcatcaaaaggtgac
+ctgatgcaacttagggtcacgatgagtttttcaggactacttattacctattaataagtt
+aacatgagccttcataccccgtaagacaatacatactccaccaattagaattctgagcca
+tcttatctttttgtatcatcgaagggtatggccgaataggttaattagttactcctaacg
+tctctacaggcatgcatttgacgcaccttcgaaaatagtcaatctctcgccacacgcgtc
+tagtatgcagcatcaaaaatatagtccacggtttccggattaccaaacgcggcaaagaga
+aacattgtatcgacggagataacttaatacagaaggaaggggcatcttcgaatacggatg
+aataattctatctgtttattctgacatcttgttttcaggttaatcttacgcattcaaatg
+acgcctgccccatgcgtgcgcaattattttctaatattgacgagagcaatctcactcctt
+ttgggtctatttatgttttattgaggcacaagcctatacagaacaggtactattaaggcc
+gtgagtgtgagactcaaaccgtggaaacaaaggatgggttgttcttggtacaagttttag
+tgcatgtgggcaatccttaccaaaatcagatgctatccttaactttgggctgcatttaag
+atggcggttggaggcctgtgagaatcctgcgtgtcatctttaatgaccgaattcatccat
+gtagattcagatcacacactcattccttgatgttgtctaaacaaaagttgttgtggacgc
+attggagggagttaagtaacaacttgggatcgcatacttataaaaattatatgttaaact
+ttcacaaacgctgaagtccaaagtaactagcccaaacgcctcgagagtcactaggtatta
+atggtgtttgagttcctgtgaaatagtgttcgaaggtaaaatttatgtaccaaatcgaaa
+gaacacttaataaggcttgcttgcacggaggtatgatgtttactgactctacaaccctaa
+ttttccagtacgtacattcattccaataggttagttctcaaagtgctatacaggctcctc
+aattgatgatatgcttcagccgctctatggatattagctcattttatttaggaagcccgc
+ttagaggcttactatgagggaaatgccaaaatgtcatacttttcggtgtgtcccatatga
+caccgctttacatagaatttgaattaaaacgcgctctcccgttcactaccatacttggta
+ccgtgcgcatattacatatagatataggatcattttttaaagctgtactaggtttgatcg
+acaatcttatgctatactatatgatgtaaccctcataatcaataccgatcgtacgatcct
+agcataggtggcaagcgattttatgccgattattgtgttaaatagtctgtgagtgtgatt
+atcagggctacgttggtagaggggttgtatagacctcgcacacattgtgacatacttaac
+aatatacgaaaactgatataataaatccccttacccaaacaccaatcccgttgaatcaac
+taccataacgtctcccatataaattgcctacttgtttgcataaatctgaatacataacac
+cattgcaccttcttgtgttccaatcccgttaagattgccttgtcagatgatatgcaagaa
+caatagcatttgctagcaattattaacagctcttcgaattgcctccacataacgcgggag
+ggtatattttaatttggcaaatactaagtactgttggcgtcatatgctattaacggttgg
+atattaagttatgtcagccgtaagcaagagtgggcgaaatattttgttacccagtgagag
+cactcttagagtttggatacaataggccatatgttgacttaagaggacgtaactacgccg
+tacaccattgttcaaccgacttcttggcaaatagaatcgtattagcaatcttaagaatag
+agacacgttcgtgttagggtatactacaaatccgaaaatcttaagaggatcacctaaact
+gaaatttatacatatttcaacgtggatagatttaacataattcagccacctccaacctgg
+gagtaattttcagtagatttactagatgattagtggcccaacgcacttgactatataaga
+tctggggatcctaacctgacctatgagacaaaattggaaacgttaacagcccttatgtgt
+acaaagaaaagtaagttgttgctgttcaacagatgatagtcatgacgcgtaacttcacta
+tagtaaattgaaacaaatacgcaatttagacagaatggtacggtcatgaatgacagtaat
+tcgaagtgctagaccaacttaaaataggtaaacgtgcccgaaaccccccttaacagaaag
+ctgctatcatggtgcagtatcgacgtgttcagaaacttgtaacttttgagcaggtccgag
+cacatggaagtatatcacgtgtttctgaaccggcttatccctaagatatatccgtcgcaa
+actttcgatttagtcccacgtagagcccaagcgttgtgcgactccacgtgcatgcccaga
+aatacgagtttaaatttggttacatggttaattttgaccgaagcatcgcactttatgatt
+gataattggattcaatatgtcgccctatgcgaatgcaacatgatccacaatttggctata
+agacgtttaatccgtatcacactttgtttgcggctagtatagtaacgcccgtgcaccaag
+agtcagtaacaattataagtactccgcaggtacttcaaatataaaaactaatcaaacacg
+acccatatgatcatctgaagatatttggaactttctcgacaaccaccctcgtactcaata
+cttacactaatcgacaggcacacgcaacgtgtacagtcgcaccatattgagtcaagattt
+gcttagtggcgatgagcgtacacgcttatttctctagtcacaattagttatctacgagac
+atcacgagggagcaaataagcgatgttatggctacacataggcacgtatgaatatgatat
+aagccagttaaacagtcgaaccatcgagcaaattctcatgcaccaacccacacgttgagg
+cacaaagagtaagctgtttgaatgtaacttcttctgctgagcgggccccaacgtaaggat
+caactagaagagaaaactcggtattagtttaaatgcgtcacggagcatgagtgcatttca
+ctaagaatgtctgtgtaaccaatataacatctatttgttatctgattgcctacttatggc
+tttgcggtcgtggcgactaatgtctccaatccttttgaggtcggtaccaactccctttaa
+attacgctgtgcaggctcatgcactgcatacatatacggtagcaggtagggacctcacgc
+acccttattataatcaatagtagttatcagtcaacgaggcaggaatgctgaggtcgaggt
+gttggtatattttctatgtgccgtctaggcgactatcacgcattaccaggcgagatttaa
+gccaattttgaatatagtcaacgtaatttttactatgggttccaccgaaacgccttgcac
+aactaagaatcccataaaatatcgatatcaaataaaagattgtgtcaataccttcatata
+tattttttcggttgactaacgtgaactaaggttaggggttttgtatgtctatataggaaa
+cagtttcttttctgtcctactttagtaaagtcttcaagccttactccaaaatcacggtga
+ttaagccgttactcagcagcatgattctgcctgctcgggtcctaaaatccagccttgtaa
+gagtcgctgtgtattagctagggagacctttgttaaaaaggatatatcgcggcgggatgt
+gagtgcgtggcgcatactcaatcttcagctcgtgtcattataatatctctcccccacgct
+tttcactagatatgccgtgtaagcaaacaccttatgcttaatttcgaaaatattggtact
+tgaaaaaagctgtaggggtacttaatgtctggtaggagatcaggagagaattgagtgtaa
+aaccgtaaagccctcacctgacttcatgtaaatggcttagaagactccatgatttaataa
+atactacgaaggaaagactggatctaaagataactctagtaaggccaactcccttcaatg
+ctgttgccagttataatccaagagctgtccttttctgaaccatagcggcttctgaagcga
+actagaagcaaagttggttctagccagacagccacataccctgtacgggtgtattactaa
+aactggtccggtattagttcaccaagggaggaattaggcaaaggatctaggtatgcaagt
+cggagtattacatccctaccctgaatccatcaataggttcctctgtactggccttcgcaa
+tgagtattcaaggttgtacagccgtataataataagatagtgactatgaacgggaagtaa
+cccgctcaccttccccaaaacattgttatatctaagtattaaagtctgccgtagtgttaa
+tactcgaaaataaacaactggcaaattacaccgcacttaagccgcttttgatttatattt
+ttccaatgcgcttttaaaaataattcagtcctacatactaattaagacccttaaacggag
+atatcacaagttaagttttaaccatctcgactaggtggaactatagatacccaactcaat
+ttatcattacctgtaatgttcctagaaggattgcatttcatgtcaagacggtggagtttc
+acagcgaaacttcagtgtgaacagattctgagaaatcacctaaacctattagtcagagca
+cccggttagaaccagttgtcaaaaaatagagcggttgcatgagacagaagtaacgatgag
+atccgttgtaacgttgagacatctggcctatcgtcaatacagtcctcccttaaaaatatt
+tttaaatactaggcaaacccaacataggttagtcctatgtgatacgccacatggtatatc
+attttgtaacgttacctagggataatcaggaagtggaattacgcaaaagtagacagtgaa
+atgcttagggttatagtctagtccaaagataaaggataaagcacgtcagagaactatatt
+agccgaatgggaatcattgttaggagactgtggatcatgtctaaaaagcaacgcagaaac
+agtcatcgaaaaaatctcgtttttgtttgaatctaaaagagctttgatgaccgatagtac
+ctgtatactagttactgtattacgtgtctaatgatttcggattggggtccccagaatcag
+acgtcattgtagacgattcaagtttaccaatttaatttcccagctctccttggagaacta
+tcgccaataattgcagtcactttccttttctgaaacgataaagccgtcagagttctctgc
+aacgttggacttacctgaggttctaacccactttcggttctaatagtagttaacgacaca
+acgaataacctttactgtggggctttcacgatattttttcgcttattattaatggttacg
+tcataagctggtgtccaaattaaggttaccggcttcgcagagtagttgtatccaagtata
+acttccctaatcataagatcgaggtagaaaattaatgctgtctctaaccgaacagatatg
+tcccactatgtggtatggacgttgctaattacttctgaagggaaattggtcattatggat
+acgtgtctaccatcaggtcggacgcagatatggttctgtcttcagttgatccaccgttct
+ttataggataataactgacgattaaagattatggtaaatagattaagccaattctcttct
+tgtcagtgaagcatccttaactgacttgctctgcagcccctcatacatttagctattcaa
+agtaccggctcgtttcaaactctcccacctttggaagaggttgtcaacttgataagtata
+tcatttacagcattttttcggacgtacctctaatgtttcattgcagaaaattagtttttt
+ctatcgcacattttgcaagtaacgttagagacacaattatctgcgaatgaactgctagat
+ctgacgaccgggagcctcgcaaatatcaaaaaagactgacatatatcaaggagtcgttga
+caagtgctggtaagtcaattggtttatctgtcccggcgtttcgatcttaagctgaccatg
+cacggcagagtaatgtcactctcgttcttacaagtctgtctccaagggtcggcaaaaaag
+acccctccattctcgagcccactcacgatatgtagggacgacaacttgtgcggcttatga
+attgtctggactgcgggcgagggtccatatctccgaagttagaagggacatacctttaga
+tgataagatcaattcttattgacgaaattcatccacaacggggaacaacttcaccctaga
+cttacgtctgaaaagacacctagcgtcttataaaaggtcagtgccccgtttcgtaaggct
+ggaattacctacgcaaacttaaacctcgcgcccttccttacgtatcgacaagatagaggc
+tatcgcgaatgtactacggaggcatgaatcatatactagaaccaagtgcctgtgatatta
+acaagatgatccgacgcgagcaccgtaattctaggcataaaactccagcaatttgggggc
+cgaaaacaaatgacgttagctaattaattatatgacatgatcaaaggaggtcaatcacgc
+atcgagttcgacgtatattcattgaacttcgtgcgtttgaaagaaacttttatgaaggca
+aaattgatcctgtctcctatttcatgcgtacctcctagttgataattccccgagcagtgg
+ttaggacacttttgtcggtatcaagttccggtctcaaaacgtaaaattctgtaatctgta
+tggatggtctgtgaattagttaatttttatgaagtcgtcgagacgcagttcctattgatt
+tattctaaacggagatgtgcttcgtgggactcggaagtagatctgtgtttatgattattg
+ctactttagatgctgactgttaactccgtgttgtttttcaaccgtatatcacaaccgaat
+tggatagaacctatagtttcaagttctgccacaaggtatcatatttacagttagtgctgg
+ttgcttctttcaaacgtggtgagtttgtgctatcacgtcaacggtagagctcagtggacc
+gagtgcgcgttcaaccctgttccagagagggtgtgatagcacatataccacgctcgtcga
+ggcgttcatgatagtttgcaagagccggtgttaaacacatattattattgttatccaact
+aatcggacctatgcataaagcattgtctaaacagaataattgcctatatacggtagtttt
+agtgatttatatcttagtatcagttagagcttcgaactcttcaggttcctcatatttaac
+gttcttcgaaagcgaaaacttctacaaacgaatgtaagcggttttccaagtagtacctat
+aaatcacagaaagatctgtctcagtatagttgaaatggtattcagctagtgacgtgtacc
+aattatcatagttcactcaagcaagacgctcattaacgaatatagacaagacactatatc
+atataataaaaaagaacatggtgctcgaacatagttgaattcaccatattgaaggggaat
+gctgacatgtaattcgctactagacgatcaattccctacttgtcaaagttgaactggtac
+gttcttggaattaaatatgattgcgctggaccaaattgcgacttcttgagtttcagggca
+aacgattgagccggaggatgtccgtctcttacctttcttgcttatgataaacgacggtcc
+ctgtacatcactgggaattctcagcaaaaataattgggtaaatcgagactcgatgtattc
+ggccacaaaggtgttagacgttaaagattattcaacggggcgataataggatcataaccg
+gtatgcaagcgcattgaaagagccatgagatccttatccgataaacgctgcacggtatgt
+gcagccttattgtcgatcacgaatttataaatgtagtctgggctgtaagttgaagaccta
+agttataatgaagtgcaataccaaatcgattcatagtggattatcagactcaagatatct
+cctgataaattacagttgttaagatacggataaaatgagatttaagattagcagcctcta
+atctgtttcaatcccgttggaatgtggtatgcgatcaaggttaagttaaaatcaagcctg
+tcttcagtcttgattcttgttctgccatcgcatgcggtctacgtgagttaatatgtagct
+tacgttctagcttgtgctaatctgagtatagattcgtagaggaatattatcaagcttcca
+cgcctcaacgtacgtgtattggtcacacaagacactaaaagtggaagtagcgtaaactat
+agtctagttgttaaatgctcagttcttgttatattcgatatactcttggctaatttatgt
+ctgagtatataaaattaatgatattaacttgcatttcacggatcccttagaaaaagattt
+tgaccgagcgcattataaacggttacaccgaatcaatagaagcatacccaatagctttct
+ttgaatttattgcctgcgcaacttggctgactctctagatccgaataattctatatggtc
+gtgacgaaactagttcattactgtttaaaatgccaacatgtcttttgggccgataatggc
+tctttgcaaaattactcaatgatacgattgatcaaagcggtagttgctagtggtagcatg
+taagtctatcaaatgtctgattatccgaaaatcttccaaaagagtccacgtaccatatct
+atctcatagcgacgcgaggggaaccttatctaactatcattccatttaccgggtgactct
+cgatgcaggatccgattgggataaattgcccagaaatggctcattcctgactaagggtaa
+ggccgttctcagcaagggaaccccgcgaatctaggcttataccatctagattgttaacta
+cttgcctgtagttctacagccatactggacagttgtttctaaatgatcgggattcatgct
+agcactcctctgaatgcaccgcgtaagtttaactattacgtccgtgggcagataaggatg
+gaggctgtatgtatcttaactgttacctaatatggctggtaattatcaaagtaaggacct
+taatgccatagcgctagcaatcgctttgtatactgaccatgtgccaacctctcttaatct
+gtaaaatataatgtcttagctaactgtggacgatcatgtctctgcctagagcttcgctgt
+atcaattcctatagccagcgtactagtgacacaacaacaccgtgtgagaaaagatattag
+tccttacgtctgtctctctacagcttattgatgaggattgaacatggacatatagctccc
+cctcaaaagcagatgctacctctttattccattctcgaacatttgccgaacttaatttcg
+acaaacctgaggtcacgtcttaatttatcggtaacgtcacgtccctttgagactggataa
+atatattaccaggggccaacgagcaattgttggaggcgcttctataatacaaggtgtctt
+gtcaaagaaagacggcgtgcgtctcgtgcaactcacttaaccaatattaatgtgaaaccc
+ccctctctcacatcttatgcggtgtactgccctggtacatttcctgtacaggactccaac
+agtgtagattcctaagatagctgttggagttgcctcacgccagatcgaaaaactgaataa
+actagtgagctgagctgcagaaataccgcttaattacttatgactagttcaaagggacct
+acgtgatgtcagacattgcaaggaagaaattaggtttgtgcgtcattttggctggactag
+cactccttacttcccctactattcaaatgtcgtaaacagcatgagacaggatcgtgctga
+catttaaggtctattgggaacgaggctacctttggtcgcgcgctcgcgttctccgaatga
+ccgaaatgcatgagcacagtatgcaattgcttatagatctaaggtctggtcgttgaaacc
+aagcacgtaggcctgggaaatcagttcttcctcagcaactacacaaaagcgtccaagcat
+tagtacttgtagtaaatgtccgaacctatgcgctcatttgaaagtcaaaaaatattttta
+agcagtaggcacctaacccgattcctctacttagtagctttctttgattctcagaattga
+ctgcaatatcactgcacaattctgtgccattactagacttctctgtattaacgtctcatc
+ttactaacactcgcctaggacacatctgagagtgaagtatttcaatacatttactgaaat
+cttcagttctaaaatccccgaataaggctcttatcggtttggccaacacaagaaaaaaac
+ttcttgcaccactcaccttcatacgcaggagcctggggaacttagtaataactatttcgg
+cagacaaagcttataacaagttgccggcgcgtataatatttaaaagaccccttgagctgc
+tcaattaaaacgctcacctggtataggctattagatagtgccgtcttagtaaggggcggg
+aattatcggataaactgatattttgataaaataaccgacttgttcacgacataagtcact
+aaggagattttatctttctccaaagtatatcttccttggataatttcaaagcgctgcaat
+ttaagttctgttactagtttatgctgctgggaggtgaccggaaggcgtagtaatctagag
+gcaaattataagaagttcatcatatcattttcgactacaaaaacaaggtgttgtatgccg
+gcgcattgtgtaaactggacgagtaccctagatggaaaattatacgttaagccaagattt
+cgatgtaatgataattacctacacatttttgctatccataggaacaagagctgttctata
+ggctcgtggcatacgaacatttgctgccgctatgaatattggaagctcttcaactacaga
+ctctattcttaattgccgtcgaaaatgggccgaatcggctattattaatactcggttttt
+ccgaggggattgttgtcgacagtcgtaattattattaatattgatgttggtgaggtcatt
+taaatacaaccttgcagacaatgaataagggatccaatctctcatactccttttacaatt
+gctcatgcccctatgcaaaccttatgccgccacacctccgcaactctctcttctgaactg
+taagtagcttcattactggtttgagactatactgaagctgatgacattctaaaatggcta
+ttttcgaatgtgattcataatgtttatcgtttgggatggcagaatcacgttatttttgat
+atagcccgggtattctattgtatagaacgtatgctacaagtcattccccgaagaagacta
+gaagtaaacaacatgcgaccatcgttaagccacgcaaggctgtagctttatttcccgata
+acctatcttccataaatagcggacagcaggatactgacgctcaacatcagtggttatggt
+ctaatttttaacttttaataaggtaacttcagcaggcatacacagtaactctttaattta
+taatcaaattagaagtctgacacttcttatatttttctatcatccaacgcgatcgcccat
+tagcttattgtgttactaataacgtatctaaaccaatccttttcaagctactgcctatat
+tgtcaatatatacaaacaacaggatagtaggctgcttaaaaaatattgtcaaccgtgtac
+gctttacaatacccggaaatcacaaactttgtagacaacgagtgaaatttatacactacg
+aagggccagcgtacaagacccatgaattaggcgatatgtttattctgacatattggttta
+tccttaatctgtcgctgtaaaatgaagccgcccccatccctgcgaattttttttcgaaga
+ttcacgactgaaatataaatacgtttggctatatttatgttggagggaggcaatagcctt
+tactgttaaccgaagatttagccagtgagtgtgacactaaaacactggaataaatgcagg
+cgttcttctgggtaaaaggtttagtcaatctcgcctataagttcatatagctctggatat
+aattatctggcccatgcatttatcatggcgcttggtgccctgtgtgaagccggcctctca
+tattgaaggtccgaagtattccatgtacattaagatcactctctcattcatgcatcttgg
+cttaacaaatctggttgtccaagctttccaggcacgtatggtacaaattcggatcgaata
+cttataaaaatgatatgttaaactgtctaaaacgctcatctacaaagtaaagtgcactaa
+ccaatagagtctcaagaccgtgtaatgctggtgcactgaatgtgtaatacggttagaagg
+gattagttatgttacaaatccattgaaaacttaagaagcattgcgtgctcggagggtgca
+tcttttatcaagagactaacattattttcaacgacgtacatgctttacaatagggtactt
+atcaaacgccgagaaacgcgcctatagtgatgttatgattatgacccgatatccattgga
+ccgaattttatgtaggttcccagcgtactcgcgtaatatctcggtattgccataatgtaa
+tacttgtcggtctctcccagatgaaaaagcgttacagagtatttcaatgaaaaacagcgc
+gcaacgtcaatacctttaggggtaacggccgctgatttcatatagatatacgataagttg
+gtatagctctactaggtggcatccacaatcgttgcatttactatagctggttacaatcat
+aatctataccgttccttacatactaccatagcgggatagcgtttttttgccgttgattgg
+gtttaagaggatgtcagtctcattatatccgattcggtgggagagccgttgttttcaaat
+cgcacactttgtgacataatgtacaagataacaaaactgatataagatataaactgtcaa
+tatcaccttgacacttgaatcaaagtaaattaactcgcaaatataatttgactaattggg
+tgcagatttctcaattaataaaaaaatggcaccggatgggcttacaagccccttatcatt
+cacttgtatcatgatttccaagaacaatagaatttgctagcaagtatgaacagagattcg
+aattgcatccacagtacgccggagcgtttattttaatgtggatatgacgatgtactgttg
+gcggcatttgctagtaaccggtccttatttacgtagcgcacacgtaagcatgtctgggag
+aaatatggtggtacaatctcagagaaagattacagtttggtttaaataggacttatcggg
+tcggaagtggaacttaataagcagtacacaattgggcaacagacgtcttgcctattacaa
+taggattacaatgcgttagatttcagacacgttcgtgtttggctattcgtcaattcccta
+aatagttagacgatcaactattatcaaagtgattctttgttcatcctccattcatgtaac
+agatggcacactacgcataacgccgaggaattttaacgagatttaagagagcagttcggg
+cacaacccacttgactttataacagctcggcagcataaacggtaatatgtgacaaatttc
+caaacgttataagaacgtatgtgtacttagaaaactaagtggttcatgttcaacagatgt
+gacgcagcaagcctaacttatctattggttttgctataaaagaacaaagttacacagaat
+cctaagggcttgtttcacacttatgcctagtgcttcaccatcttaaaatagcgaaaccgg
+cacgaatcaaaccttaaaacaatgcgcagatattggtgatggtgactccgggtatgataa
+tggtaactgttgaccagcgcccacctcatcgaagtatagaaagtggttaggataaggatg
+agaccgaacttatttccggccataactttagattttctacctagtacacaacatcagggc
+ggacacgaaaccgccatcacatcatataccaggtttaatttgcttaatgggggaagtgtc
+aacgaaccttcgaactttagcaggcatatggccattatatatggccccagagcagaatgc
+tacagcagacaaaatttggatttatgtagtttaatacctatcaaacttggtgtgaccata
+cttgtctaacgacagtgcacaaagtgtaagttacaattattactactcagcagcttctgc
+aatgataaaatcttatcatacacgtcacatatgataatatctacttagggggaacgggct
+ccacaacctacatagtactcaatacttacactattcgacaggcacaccaaacctgtacag
+tcccaaaagattgagtcaactttgcagtactgcagatcacagtaatagcttagttagcga
+gtcaaaattagttttctacgagactgcacgaccgtgcaaatttccgatgtgttggctaca
+aatagcaacgtatgaatttgtttgaagccacgtaaactgtacaaccttagagataagtct
+caggctactaaaaacacgttgtggcactaacaggatcatggttgattcttacttattcgg
+ctgaccggcccaataagtaaccttcaactagaacagaataatcgggagtagtttaattca
+gtcaaggtgcaggtctcattgtaactaacaagctctgtgtaaccaagttaaaatcgtttt
+cttagcggattccctacttatggatttgagctcgtccacaatattcgatacaagaagttt
+gtggtccgtaacaacgaaattttaattacgctgtgcagcctcatccaaggaattaataga
+aggttgatggtaggctccgaacgctccatgattataatcaagtggactgtgcagtaaacg
+aggaaggtatcctgacgtcgtggtgttcgtttttgttatttgtgccctatacgagtagat
+aaaccatgaacagcacagtgtgaacccatggttgattttaggctaccttatttttaattt
+ccgttacacagaaacgaattccacaactaacatgccattaatttttcgatatcttataaa
+agatggtcgaaattcattcatttattttttttcggttctcgaaagtcaactaagctgtcg
+cgttttgtttctctttagaggtaaaagtggctttgatctcctacgtttggatactagtca
+accattactccatttgatccgtgagtatcacctgtctaacatccagcattatgactcctc
+ggcgaagaaaagacacacttcttagagtcgatgtgtattagctagggacacagttgttta
+atacgatagtgagcccagggagggcagtgcgtcccccagtagatttattcagctagtgta
+agtataagatatctcacccacgaggttcaagtgatatgcagtcttagaataatacttatc
+ctgaatttcgatattatgggtacttcaataatccgctagcgctactttatgtctcgttgg
+acagcaggacacatggcagtcttaaacactaaagacatcacctgaatgaatgtaatggga
+ttacaagaatcaatgaggtattatatacgacgtaggaaactctggatatatacagtaatc
+tagttacgccatcgcacttcattcctctggaaacttagaagacatcagctgtacgtggag
+gaaccagacccccgtatgtagccaaatagaaccaaagttgcttatacaaacacacccaat
+gacaatggaccgctggagttcgtaaactcggaacgtagtactgcacaaacccagcattta
+gcaataggagctacgtatgcaactcccacgtggtaataccttcaagctatcaatatatag
+gtgcctagctaatcgcattcgcaagcagtattcaagcttgtaaaccagtataataattac
+agaggctctatgaaacccaactttccagctaaaagtcccaattaaatggttatttcgtac
+ttttaaagtcgcccgttctgttattacgcgaattgattctactccaaaattaaacacaaa
+ttatcaaccgtttcatttatatttgtcaatgcagctgtttaaaataaggctctactaaat
+tataattaagacacttattaccagatttctctagttaagtttgaaccagctcgactaccg
+cgaaagatacattcccttctctatttttcagttcatctatgggtcagagaagcattgaat
+ttattctattcaccctcgtcgttcacagcgaatcgtcagtgtgatcagtgtatgagaaat
+atcctaaaccgtttagtcagaccacacgcttagaacaagtggtctaaaaagactgccctg
+gaaggagtaagaagtatacagctgatccggtgtatccttcagtcatctgccctatactaa
+ttacacgacgcaaggaaaaataggtttattttctaggcaaacccttcataggtgactccg
+atgtgttacgaatcatgcttgagaatgtgctatcgttaccgacggataataacgatctcc
+aatgaaccaaatgtagaatgtctattgattacccttttactattcgacttagagatagga
+gatagaacctcagtgtacttttttagccgaatgggaatctttgggaggtgaatggccata
+aggtcgtaaatccaaccctcttaaagtcttccatattatatcgttgttcgtggaatcgat
+aacagatttgttgacccatagtaaatgtatactagtttatgttgtaagtgtagattgttt
+tccgattgccgtccaaactttatgtcgtaattgtagaccagtaaagttgaccaaggtaag
+tgcccagcgatcctgcgagatcgatcgccaatttttccagtcactgtaagtgtaggttta
+gataaagccgtatgagttatatcataagggcctcggaaagcagcttcgaaccaaagttcc
+cttataatagtagtttaactataaaagtatatactggtctgtcgccctttcacgatttgt
+tttaccggtttatgaagcgttacgtcattagagcggctccaatttaaggttaacggcttc
+catgtgtagttgtatacaaggataacttaaagtatctgttcagcgagctagttaagttat
+cctcgatagaacacaactcagaggtcccaagatcgggtttgcaacttgctaatttattct
+caaggcaaattgggaattatcgatacctgtataccataaggtcgctcgatgtgatgctta
+tgtcttctggtgatcctaccttagttagtgctgattaacggaacattaatgtttatcgtt
+ttgagatttagccaattctctgattctaactcaagatgccttatctgacgtgctatgcag
+cccctaagtattttacattgtaataggacacgctcctttaaaactcgccaaaaggtcgtt
+gtggttctctactggttaactatataatttacagctttgttgagctagttcctctttggt
+ttaagtcctcaatattagttggttcgagcgataagttggctagttaccttagtcactata
+ttagatccgaatgttatgcttcatctgaagaccgccaccctccaaaatttcttttaagac
+tcacttattgcaaggtgtaggtgaattcggctcgtttctcaagtggtgtatctgtacacg
+agtttccatattttcatcaacagccaccgcacacttatgtcactctaggtattaaaagtc
+gctctacaaggggacgcaattaagaaacagacatgctagtcaaaaataaacatagcgagg
+caccactaattcggccgcttatcaatgggatgctctgcgcgagacgcgccagagctcagt
+agttagttcggacatacatttacttcagatgatcaattagttttctacaaatgcttactc
+taccccgaaaaaagtcaccagactcttacgtctctttagtatccttccgtcttatataag
+gtcagtcccccgtttcggtaccctggaatttactaagaataatgaaacagcccccaagga
+cgtacgtttacaaatgatagaccagatcgcctagcttattccgacgcatgttgcatagaa
+ttgaaccaacggaatgtgagagtaactagatgagccgaccacagcacccgtttgcgtcgc
+agaatacgcctgatagttcggccacgaaatcatatgtcctttgagtattaagtatttgta
+atgatcaatcgagctcaagcaagcttacacttcctcggatattcagggaacttagtgcct
+ttgaaagatacgttgatcaacgaaaaattgataatggctcatatggaatgcctacctcat
+agtgctgaattaacacagcactgcggacctaacttttcgaggtttcaagttcacgtctca
+aaacctaataggctggaatatgtagggatcctcggtgaatttgtgattgggtttgttgta
+gtactgaccaagtgaatattctttttttctaaaagcagatctgctgccgggcactacgaa
+ggagatctctgtgtatcattattgcttcttgacatgatgactcttaaatcactgtgggtg
+tgcaaaacgatagcacaacccaattcgatagtacatattgttgatacttcgcactaaacc
+gttcatatttaaaggttgtgctccttccttcgttaaatactggtgacttggtcctatcta
+ctattagctagacctctggggaaccacgcccccgtaaaacctgtgcaagagagggggtca
+tacatcttagacatcgcgcctccaccagggaagcattgggtgattgaccaggtgtgtaac
+aaatatgattattcttatactaatattagcaaagatgcataatgatttgtattaaatgta
+taattgaattgataagggtcttttagtcagtgatagagtagtataaggtagacattagaa
+ctcttaaccggacgcagatttttcggtcttagtaagccaattagtcgacaaaacaaggta
+agagcggttactagtagtacctataatgcactgaatcttcggtcgaagtatagttctaat
+gctatgcagattgtgacggcgacaaatgttcagacttatatcatgaaacaagctcttgta
+agtattgacaaatgaaaagattgaatatttttaaatacaaaatgcgcctacttattaggg
+gaattaaccagattgaaggccaatcctcacatgtaatgagataatagacgataaatgaaa
+ttcttgtaatagttgaactgctacgtgatgggtattatatatgattgagatcctccaatt
+gccgacgtcttgtcttgatgcccaaaagattgtcaacgaggagctccctcgcgtacctgt
+cgtccgtatcataaacgacgcgacatgtacagcactccgaagtataagcaataataatgc
+gggtaatccagactagatcttttcggactcaatgcggtttcacggtaaacatgattaata
+ccggagagtagtcgagcttatcagcgatgcaagcgaattcattgtgccaggagatacgtt
+gcagataaaaccggcaacgtatgtcaacaagttttggcgatctcgttgtttgtattcgac
+gaggcgcgggaacttcaagaactatcgtatattcaagtccattaccttttagtttcagac
+tggtggagctgactaaagttatatcatcattttgtacactggtttagttaacgataattt
+cagatttaacatgaccagacgataatcgctgtatatccagttggaatgtggtttgccaga
+aaggttaacttataatcaagcctctcttcagtcttgattcgtcgtatcccatccattgcg
+ctatacctcagtgtatttggagctgtagttataccgtgtgctaagatcagtagacatgac
+gagagcaatattatctaccttacaagcatcaacggacgtctagtcggaacaaaagactct
+aaaactcgaacttcaggttaatatactatagttctgtattcagcagttattcttatattc
+gatattatcttgcctattggatgtctgactttagtatattaatcatagtatctgccatgt
+aaaggtgccagtactaaatctgtttcacagtgcgaattataaacggttacaaccattaaa
+gacaacaagaccctatagctttatttgaattttgtcaatgcgcaacttggagctcgcgat
+acatcccaattagtctatagggtcgggacgattctacggcatttctggttataatgacaa
+catggattgtggcccgagaatcgctctttcattaattaagcaatcattacagtcttataa
+gcgctacttccgagtggtagcaggtaactcgatataaggtcgcatgagccgaatagctta
+aaaaacaggccaccgaacattgatagagaataccgaccacagcgcaacctttgattactt
+tcattaaattgtacggctcactcgacatcaagcttaagattgcgataatgtgaactcaaa
+tggatcagtactgaagaaccgtaacccacttcgcagaaagcgtacccagagaagatacgc
+tgttacaatatacagggtgaaattattgcctgttcttcgtaaccatttcgccaaacttgg
+ttagaaatgatagccattcatgatagaaataagctgaatgataccagtatctttaactat
+gtagtcagggggaagataacgatggtccatgtatgtttctgatatgtgacagtattggcc
+gcgtaatttgctaacgaagctacttaatgcctttgagcttcatatagatttctttaatca
+aaatcggcaaaaagatagtatgagctataatatatgctagtagagaactctggaccatca
+tctatatgaatactgattcgagcgtgcaattactttagcctgcgtactactgactctaca
+aaacactctgagataagtttgtagtcagtaagtcgctctctataaaccttttggatgacc
+attgtacagccacttatagatcccaataaatagcacaggagacagagtttttcaatgctc
+gatcatttgccgatagtattttcgtctaacctcagggcacctattatttgatacctaacc
+taacggccctttcacaatggagaaatatatgacatcgggacaaacacaaatggtgggtgg
+ccaggagatatgacatggtggcgtctctaagaaacacggactccctctaggcaaactcac
+gtaaccaattttaatgtcaaacaaaacgctcgaaaagattttgccgtgtaatgacctggt
+acattgactggtcaggaatacatcactgtagttgccgtagtgtcctgttggtgttccatc
+aagacacatcgtataacgcaatttacgacggacatcagatcaagttatacagattattta
+agtatcacgtgtgcattgggacataagggatctcacacatgccttggaacatttttgctt
+tgtgccgctttttcgctgcactaccaatccttacttaccagtatattcaaaggtcgttaa
+cagaatgagaaaggttagggctctaagttatcgtcgattgggatagacgagacatttgcg
+agcgccctccacggatacgaatctcccatatcaatgtgaactggatgctatgcagtttag
+ttcttacgtctcctagtggtaaaaatcaaagtagcactcgcatagcagttattcagaacc
+taatacacaaaaccgtcaaacattttctaattctaggtatgggccgatcataggagctaa
+ggtgaaactcataaatgttttgttagatctagcatcctaaaaagatgcatatactgagta
+gctggcgtgcattctctcaattgtatcctttttaactgaactagtcggtcccatttcgtg
+actgagatctattaaccgataagattaataacactcgcattcgtatcagctcagagtgaa
+gtttttcaataatttgactgatatattaacttctaaaataaccctttaagcctcggatcc
+gtttcccaatcacatcaaaaattcttattccaactatctacggattaacaacgtgcatgg
+ggatcgtagtaagaacttgttccgatcactttgagtatatcaagttgacggcccggttat
+tattgaatagaaacattcacctgctaaattaaataccgcacatcggatacccgatttcag
+agggccgtcttactaagggcaggctttgttcggtttaactgagatgttcattattttaca
+gtatgcttcaactaatatgtaacgaaggacagtggatctgtctccatagtagatcttcag
+tcgtgaatttcataccgctcctatttaagttcgcgttcgagttgttgatcatggcacgtg
+aaagcaacccctagtattctagacgaaaattttttctagttcatctgataatttgccaat
+tcaaaaacaaccgctggtttcccggcgcattctctaaaatggaagtcgaacctagagcca
+ttatttgtcggtaacccatgagttccttcttttcagaagttaatacactgtggtcctata
+cagaggaaaaacagcggttatatacgatcgtggcataacaacattggatcaagatagcaa
+tttggctacctattctaattctcactagattcggtattccactacaatatcggcagatta
+ggattggatgaataatcggtgtttaagtccggttgcgtctccaatctcctaatttttatt
+aatattgatcttggtgacctattgtaaataaaaacttcaagactttgaataacggtgaaa
+agatagaagactcatttgaaaatggatcatccacagatccaaacattagcaagacactaa
+tccccaactagctattctgatcgcgatcgtgctgcagtactcctgtcacaatagtctgtt
+catgatctaattctttttgggctttgttcgatggtgattcagaatctttatccggtcgct
+tccctgtagctactttgtggggatattgcccggggattatagggttgagatcgtttccta
+aaagtatttaaaccaagtagacttcaactaaactacatcagaacatcgtgaagacaccat
+acgcggtacctttatttaccgataacatttcttcaagaaataccggtaagcagcataatg
+accctaaacagctcggggtatcgtcgtagttttaaattttatttaggttactgctcaagg
+aataaaaactaactatttaatttataataatattacaaggctcacactgattagatttgt
+ctataagacttcgcgatcccccattaccggattgtcttaagaataaactagataaaccat
+gcattttctagataaggcctttagtctaattagatacaaaaaacacgatagttgcatcct
+taatttattgtgtcaaacctggaaccttttaattacccgcaaatcactttatgtcgagac
+tacctctgaaatttattatctacctaccgcatgaggacttgaaccatcttgtaggagtta
+tgtttattagctaagattcgtttatcctgtagcggtccatgtatattcaacaagcaaaaa
+gcactcagaattgtttttagttgagtcaagactgatatataaataagtttccctagtttt
+ttcgtggtgggacgatattgaattgaatcttaaccgaagagtttcccactctgtcgcaca
+ataatacacgccaatatttccagccctgcttatgccttaatcggttactcaatctcccat
+tgaagttcattttgatctgcatagaagtttcgggcccagccttttttctgccaccttcct
+ccaagctctgtagacgcactctaagattgatgctcacatgtattaattctacattaacat
+aaatatataagtcatgcatcttcgagtaaaatatctggttctccaacatgtcctggcacg
+tatcgttataatgcccatacatgtagtattaaaatgattgggttaactggatattaagat
+catcgaaattgtaaagtcaaattaacaatactgtctcaagaccgtgtattcctcgtgctc
+ggaagggctattacgcttacttccgttttggtatcttaatatgactttcaaaaattaagt
+tgcagtgagtcctacctgcgtgcatcggttagcaagagtataaaagttgtttaaacgaac
+tacttgctttacaataccggtcgtatatatcgccgtgaatccagaagattgtcttctttg
+gattatcaaccgagatcctgtggaccgatgttttgggaccttcacagaggactccaggta
+gagctcgcttttgcattaatctaagaattgtacctctctaaaagatctaaaacagtgaat
+gtgtatttcatggaaaaacacagagaaacgtaaattactttaggccgaaaggcacatgag
+ttattatacatatacgagatggtggtatacatcgaattcggggcatacactatagttgca
+ttgtatttagctgctttaaataatatgatattaccttccttacataagacattaccggca
+taccctggttttcaacttgtggggctttttgacgatcgcactctcatttgatccgagtag
+ggcggtgacccctgcttttcaaatacaaaaatttcgctatgaaggtaatagattactttt
+cgctgttatgatagaaacggtaaatttaaaattgaaacttctagaaaagtaaagtaacga
+gaaatgattttgtgaataatgcggtcatgattgcgcaagtaagaaaaaaaggcaaaagga
+tgcgcggaatagaaacttatcagtcacgggtatcttgatttcattcttcttgtcaattgc
+cgacataggatgaaatcagattccaatgcaatacacagtaacccccacccttgattgtaa
+tgtcgatttgaagttgtacgcgtcgacgaagtggatagtatacgggccttttgtacggtg
+cgatcaactatgaatctcggcgagttagatggtcgtacaatctcacacatagaggtcact
+tgcctgtaatgacgaattttcggctaggtactcgaactttattagaagtaaaaatgtggg
+caaaagaaggattccattttacaagacgattacaatgagttacatgtctctcaacgtagt
+ctttccctagtagtctttgaactatttaggtactccagaaaattttagcaaagggtttct
+gtgtgaatccgccattcatgtttatgatggaacaataagaataacgccctcgtatgttat
+cgacagtgaagtcagcagttcggccaaaaacatattcaatttagtacagatccccagaag
+ttaagctaagtgctctaaaatggcctaaacggttatcaaagtaggtctaattactatact
+aacgggtgcatcgtaataactgctgtcgatgcaacactatatgatagtgtcgttttgcta
+tatatgtacaatgtgacaaagaagccttagcgattcttgcaaacttaggacttcggattc
+tcaatcttaaatgtccgaaaacgcaaagattcaaaaatttaatctatgagcagatatgcc
+tgatggtgactacgcgtatgttaaggctaaatgttgacaaccgcacacataatcgaacta
+ttgatagtcgggagcataaccaggtgaacgtactttgttcacgacatttattgacatgtt
+ctaaatacgtctcaaaatcacggcgcactagaaaacgcaatcaaatcattgtcctggttt
+aagggccgtaatgccggtagtgtcaaacttcatgagaactttagctggcttttggccagt
+atttagggaccaagagcactagccttaagctgaatattttgccatttatctactgttata
+actttaaaacttggtggcaccagacttgtcgatacacacgcatcaatctgtaacgtaaaa
+ggtttactaagaacaagcgtaggaattgagtttatattatatttaaactaaaagatgata
+ttagcttctgagggcgatagggctccaaatcataaagaggaatatattattacacgatta
+gaaacccacaacatacctcgaatcgcccaaaagtttgacgaaacttggcagtactccaca
+tctcagtaatacagttgggagagtctcaaatgttgttttattactcaatgaaccaccctc
+ataatttcactgctgttccattaaatttgcaaacgatcatttgctttgaagaaacgtaaa
+atcgacaaaattacagataagtagatgcataataaaaaaaactgctcgctataacacgat
+catcgtgcattcttacttaggagcatcacccgcacaataacgtaccttaaactacaacac
+tattagaccgagtactgtaattcacgaaagctcaagctcgcattgtaaagaacttgctct
+ctcgtaaaatgtgataatagtttgcggagaggattcaattattttccattgcacctactc
+cactagattcgataaaagaaggtggtcctcccttaaaaagaaatgttaagtaacatcgga
+accataagcaaagcatgtaagtgaaccgtcatccttccctaagaaacataaaggttttta
+ataatgtcgactgtgaactataactgcatcctttcctgacctactccggttccttgttgt
+tatttctgaacgagaccagtagataaacaatgtaaaccacagtgggtaccaatggtgcat
+gtgacgctaccgttgttttaagtgcccgtacaaacataagaagtcataatcttacttgaa
+attaattttgccttttattttttttcaggctcgaaattaatgatttgttttttttgacct
+tctagttacgctaatatgcggtcgcctgtggtttctattgagtcctataacgggatggga
+tctaatacgtttggttactagtaaacaaggtataaatttgataccggagtatcaactgta
+taacatcaagctttatgactcatacgcgaagtaatgacacaaggctttcaggagatcgcg
+agtacagagccactaaggggtgtattacgatagtgacaccaccgagcgcactcactcccc
+aagtagatttatgatcctacgctaagtattagatatataaccaaagaggttctagtcagt
+gcaactcttagaataataattagccggttttgcctttttaggcctaatgcaatattcagc
+tagcccttatgtatctcgcgttccacagcaccactcatggcacgcgtttaaactaatcaa
+atataatctatgaatgttatgccagtacttgaataaatcaggttttttataagtccttgc
+atactctcgttatatactgttagagtcttaccccatagaaattctttcatctgcaaactt
+agaagaattctcagctacggggagcataaagtccccaggatgttgacaaatacaacaaat
+gtggcttatacaaacactccatatgaaaatcgaaccctcgtggtagttttagccgaacct
+tgtacggataaatccctccattttccaatagcagatacctatcctactacctcgtggtat
+taaattaaagcttgaaatatagagctgcatagcttatccaattcccaagcacgagtctac
+cgtcgtaaccacgatttgatttacagacgctagagcaaacccatctttaaacatataagt
+aaaaattaaagggtgagtgcgtacgtgtttactagcaacttcgcttattaagacaattgt
+ttataagccataattaaaaacatatgttcaacaggttcattgatatttgtaattgcacag
+gtttttaataaggatctacgtaagtataatgaacaaactttttaccagagttatattctg
+tactttgaaaatgctcctctaccgccttagagactttcaattagattttttgcagttaat
+ctatgcgtaagtgaaccatgcaagggatgcgattcaaccgcctcgtgctaaccctatcgt
+ctgtctcataactgtaggtctaatataattttcagttttcgaacacataaccctttgaaa
+atctgctatttaatgtctcacctgcatgcactatcttctatactgctcagaacggctata
+cgtcactatgctccaagtgacgatttaaacgaagcaaggaataataggtttattttagtg
+caaaacaattaagtgcggactacgtgctctttacaataagccttgtgattgggctatagg
+ttaagtcccatattaacgatctccaatgtacaaaatcgacaatcgctttgcattacccgg
+ttactagtcgaattacagatagctgttagatactcactctaattttggacaacaatccca
+atcttggggtcgtctatcgcctgaagctcgtaaatccttccatcttaaacgattacatat
+tatagacttgttcggggtagagatatcacagttgtgcaaacattgtaaatcgatactagt
+ttatgttggtagtctagttgcttttaccattccccgaaaaacttgatctactatttcgac
+aacagtaaacttgaactaggtaagtgaaaacagagaatgcctcatagtgccactatttgt
+ccactatatgtaagtgtagctttacataatccactatgactgagatcattacggcctagg
+aaagcagcgtagaaaaaaagggcccggatattacgactgtaactataaaactagttactg
+gtagcgcgccatgtatagatttgttttaccggttgtggttgcgttaacgaatttcagccg
+cgaaaattgatccgttaaccagtccatctcgacttctataaaacgataaagtaaagttga
+tgttcagcctccttcttatggttgcatcgagagtacactactcagtgggaaatagatcgg
+ggttcctacttcagattgtattatctaggcaattgccgattgtgccatacctggataaaa
+taagctacctacatgtgatgcttatctattatcgtcatactaccttagggtgtcctgttg
+aacgctacattaatctttagccgtttgagatgttccaatggataggagtctaacgcatga
+tgaagtttaggaaggcagagcatcccactaagtatgtgacagtgtatttcgaaacgagac
+gttataaatagaaaaaaggtccttctggttctattctgctgaactattgaatggaaagat
+tggttgacctacgtactatttgcttgaagtcatcaatttgacggggtgagagacatatgg
+tgcatactttacggactctatattttagatcagaagcttagcagtcttctctacaccccc
+tcacgacataattgcttttaagaatctatgtttgattcctctacgggaattcggatccgt
+tcgcatgtgcggtttatctaaaccaggggacatatgttcagctaaagcatacgaacactt
+tgctaactagacgtatgtatagtagctataaatcccgacgatatttacaaaaagaaatga
+gactcaaatatatacatagcgaccctacacttattcgcaccctgatctaggcgatcctag
+cacccacacccgaaagtgagcactagtgtcttccgtattaaatttactgcagttgagatt
+ttagttgtctactaaggattactctaacccgtaataaggatcaagactcggtactagctt
+tactatcattccctatgtgttttcctaactcacaagggtacgtaccagcctatgtaatta
+caataatgataaagacacaaaggaagtaactttacaaatgagtctccagttacactagct
+tagtccctcccatcttgctttgaagtctaaatacgcaatctctgaggatatacagcagaa
+gaacactcataacgttggagtccaagaattagactcatagggcccccaacatttaatatg
+tactgtgagtttgaaggtgttctattgttaattcctgctcttgatacatgacacgtactc
+cgtgtttaaggcttcggactgactttctttcataagttgagcaacgaaaatttcagaatc
+gataagttggattcactaactaatacggctgattgaaaactccactccggacctatatgg
+tcgacctttatacgtaaccgatataaaacttataggctggtatatcgagccttcctagcg
+caatttcggatggggtttcttctactactcaacaacggaatagtctttgtttagtaaacc
+agagctcaggacgcccaatacgtaggagagcgctgtggagcatgtgtcattatggactgg
+agcactcttaaatcactctgcgtgtgctaaacgatagatcataacatgtcctgagtaaat
+tttcttgatacgtcgcaatataccgttattagttaaacgttctcatccgtcatgcgtgaa
+atacggctgtcgtgctcagatatactattagcgactcatctcgcctaacacgcacacgta
+taaactcggaatgactgccgctcttacatattagaaatacagactacaccacggaagcat
+tgggtcattctcaaccgctgtataaaagatgattagtcttataataagattaccaaagag
+gcagaatcatgggtagtaaatctattattcaagtgattaccgtcgtgtaggcagggagtg
+aggacgagatggtactcaggacaaatattaaccggacgaagtggtttacgtcgtactttc
+actattagtagtaaatacaaggtaacaccggggaatagtactaaatataatgatatctat
+cttcgggagaacgagtcgtctattgctttgaacattctcaaggcgtaaaatgtgctgact
+tatagcatgatacaaccgattgttacttttgtctattcaaaagattgaatagttttttat
+acaaaagccgcatacttatgacggctagtatacagtttcatcccctagcatcaatgctat
+ggacagtattgaacttataggaaattcttctaatagggcaaatccgtcgtgatgcctatt
+ttttttcagtcacatcctcaaatggcactagtattgtcgggatcccattaacaggctcaa
+ccacgagctcacgcgaggacatgtagtccgtatctttaacgaagcgacagcgacagaact
+cccatggataaccaattataaggcccgtaatcctctagacatcgtttaccaataaatccg
+ctttctccgtaatcatgttgaataccccagagtagtccagatgataaccgatgaaacaca
+agtctttctcaatgcacttacggtgaacttattaccgccaacgtagctcatcaaggttgc
+gacatctagttgtgtgtttgcgacgagcccagcgaacttcatcaactttcgtatattcaa
+cgccttgtaattttactttaagacgcctggtgatgtagattcttagataatcagtttgtt
+atcggctgtactttaccataatttcacaggtttcaggtcaagaagattatagctgtatat
+acagttccatgctcggtgcacagaaacgtgatcggataataatcaatcgcttatgtcgtc
+tttaggcgtatccaatacatgccccgataccgcagtgtatttcgacatgtaggtataccg
+tcgcatttgagctcgagtcaggacgtcagctagattagattccttaatagaatataccga
+cctctagtccgaactaaactatagataacgccaacttcaggttaattgtctagtcgtctg
+tttgcagatgggattcttagatgagtgagtatcggccatattggttcgagcactttagtt
+tttgatgcataggatatgcaatgtatagctgaaagtactttatctgtttcaaactcacat
+tgattaaaccggtaaacctttaaagactacaagaaaatattcagtgagggcaattttgtc
+aatcacaatcttccagctagagatacttcacaatttgtcttgaggctacgcaacattaga
+cggattttcgcgttttattgaaataatcgaggggcccaagagtatccatagttcattttg
+taagatttctttacaggcttattacagcttcttcagactcctacatgcttacgagttata
+tgctagcatgtgaacaatagattaatatacaggaaaacgtacattgagagagatgaccct
+acacagcgcaaccgttgagtactttcattaaagggtaacgctctcgagacagcatcctta
+agatggccttattgtcaaatcatttgcagaagtacgcaagatccctaaccaacgtagaag
+aatccctacaaacacatgagacgcggtgaaaatagacagggtgttagtattcaatcttcg
+gagtatcaatttcgccaatcttggtgagaaagcataccctttcttcagagaaagaagatc
+aatcataacactatctttaacgaggtacgcacgcgcatcattacctgcctccatggatct
+ttaggatagcggaaagtattggcagcgtattgtgatttcgttcctactttatcaatttca
+cattcatatacatgtcttttatcaaaatcgccaataagataggatgagctatattagatg
+ctagtagagttcgcgccaacatcatcgataggaatactcaggacagcgtgataggacttt
+tcaatccctaatactctctataattataactctctcttaagtttggaggcagtaacgcgc
+tctatataatcagtttgctgcaccattcttcagcctctgatacatacaaataaattccac
+agcagtaagagggtttaattgagacatcttgggaacttaggattttactctaacatcacc
+gaaacgattattggataccgtacctaaacgaactttctcaaggcagtaatataggacatc
+cgcaataacacaaatgctgcctccccaggagttatgtcttcctggaggctatatcttaca
+cccactcactataggcaaactaaagtttaaatgttgattgtctaaaaaaaagatagataa
+gagttggccggcgtagcacatgcgaaagtgaatcgtaagctataattctctggacttgaa
+gttctgtcctgttcctctgcaagaaacaaacttcctttaaagctatttacgacgcacatc
+tcagcaagttataaacatgttggaagtttctagtcggaattcccaaagaacggatctatc
+taatgcattcctacatttttcctgtctgccgatggtgccatcctattcaaagaatttctt
+aaaagtagattaaatgggacttttaacaatgagtaaccttacgcctctaagggttcctcg
+agtgccatacaccagtcaggtccgagccacatacacggagaacattctaacatagcattc
+tcaactcgatcatttgcaggttacttctttcctatcctagtgctaaaaatcatacttgca
+atcccatagcacggattaagaacctaagaaacaattcagtaaaacatgttcgaattcttg
+gtatgggaacatcattgcagctatggtctaacgcattaatgtttgggtacatcttccatc
+atataaacaggaagagtctgacgacagggagtgcttgcgatcatgtctatcattgtgaaa
+tcaaattgtagctcacatgtcgtctatgagagcgtgtatccgataagatttagaaaaata
+gaagtcgtataagatctcactgaacttttgaatgaatgtgaagcatatatgatctgcttt
+aataaaactttatccataggatacgtttccaaatcaattcaataattattagtcaaaata
+gataaggatgaacaacctgaaggccgatcggacgtagaaagtggtcccatcactttgagt
+tgatattgttgaaccacacgttattatggttttcaaacagtctcaggatattgtatatac
+agataatccgataccagttgtctgacgcccctcttacgtaccccaccctttgtgacgttt
+aaagcagttgttcagtattttaaactaggcggcaactaatttggaaagaagcacagtgga
+tatgtctaaattcttgttattcaggcctgaatttaatacaccgcatagttaacttcgcgg
+tagagttgttcatcatgcctcctctaagctaccacttctatgatacaccaatagttgttc
+tacggaatctgataattggccaagtcataaacttccgctgcgttcaacccccttgctcga
+atatccaactcgaaaagacagccttttggtgtccggaacaaatcagttacttcttttctg
+atgttaattctctgtggtcagatacagaccaaaaactccgcggatttaccatcctccaag
+aacaaatttgcatcaacatagcattttggctacatattctaagtctcaatagtttaggtt
+ttcaactacattatcccaacattaggattggaggaataatagctgggtaagtccccttgc
+gtctacaatcgactattttttatgaatatgcttctgccgcacctatggttattaaaaaag
+tcatgactttgaagaaccctgaaaagatagatgaatcaggtgtaatggcagcagccaaag
+agcatataattagcaacactctaagaacattatagatatgatgatagcgatcgtcatgat
+gttatccggtcacaatagtagcttcatcagctaattcgttttgccagtggtgacttgcgc
+tggaagaatcgttatacggtcccttccctcttgatacggtgggggcttattcaaccgcgt
+ggattgggttgtcatacttgcattaaacgatgtaaaccatctagtagtcaactatactaa
+atcacaaaatagtgatcaatacatacccgcttcatggttttaaccatttaattgattaaa
+gatattccgctaagaaccattatctacctaaactgatcgccgtatcctagtagtttgaaa
+tttgatgtaccgtaatgatcaacgaagtaaaacgttatattgtatgtagaataataggtc
+ttggagctaaatgatgtgattggtagtgaagacttacccttacaactttaccggtttctc
+ggaagaatatactagagaatcaatgcatgggctacataagcactttagtctaatgagata
+aaaaatacacgagtcttccatcatgaattttttgtcgaaaaactcgaacctggtaattta
+aaccatatatctttatgtcgtcaataactctcatatgttttatataacttcccaatcacg
+acttgtaactgcttgttcgactgagctgtttgagctatgaggccgggatccggttgagct
+acatctatttgctacaagaaaaatgaaagcacatttgttgggagttctggctacactcat
+agagaaataagtggcccgagtgggtgcggcctgcctccatattcaagtgtatcttaaacc
+aagtggttccaacgctcgcgctaaagaattaaagcctttatttcctccacggagtagccc
+gtaatccggttcgaaagagaccattgaagttaattttcatatccagtgaagtttaggcac
+aagcatgtgttctgccacatgcctcaaagcgctcttcaaccaagatatgattcatcctaa
+cttcgatgaatgcgtctgtaacataaatatagaaggaatgattcggcgagttaattttcg
+ccttctccaacatggcatccctacgttcgttataaggaccatacatgtaggttttaaagg
+tttgcggttaatcgatatttacatcatagaaattctatagtcaaatttacaagactctag
+atactcactcgttgcagccggctaggaagcgctttgtaccttacttcccttttcgttgcg
+taatatgaatttcatatagtaagttcaaggcactcatacctccgtgaagagggtagatag
+actattaaagttgtttaatagtacgtattgatggaaatgacccgtaggagatttaccact
+caatccacaagattcgctgctgtgcattatcaaaacagtgcatgtcgaaacatgggttgg
+gtccttcaaacacgaatccaggtagagatacctttgcaatttttcgatgaaggcgaccga
+gataaatgagctataacactgtatgtcttttgattgctataaaacacagaaacggatatt
+aatttaggccgtaaccaacatctgttatttgacatagaacagatggtcctttacagcgta
+ttccggccttaatattgaggtccagtgtattgtcctcctttaaagaagttgattgtaact
+gacttaaataagacatgtcacccattcactgggttgcaactgctggccctttttgtccat
+cgcacgctaatgtgataacagtaccgccctcacacctgcgtttaaaagacataaatgtcg
+ctatgaaggttattcattaattttagctgttttcttagaaaaggtaaatttaaaattgaa
+aaggctagaaaactaaagttacgacaaatgtgtttgtcaagtaggcgggcatcattgaga
+ttgtaagaaataaagccataaccagccccggaatagaaaatgttaaggaaaggcgatctt
+ctttgaattcttattgtcaagtgcagtcatacgttcttatcagaggacattgcaataaaa
+tctaacaccctcccttgtgtggttgggccatttgtacttcgaagcgtccaccatgtgcag
+aggataacggaatgtggttccgtcccataaacgatcattctcgcccacttagtggcgcgg
+taaatcgctctcatagaggtaactggcctgtaatgtccaatgttaggctaccttctccaa
+ctttagtacaacgaataatgtccgattaacaaggagtcaatttgtcatgaccagttcatt
+caggtacttgtatctatacggacgcgttccagagtagtatttgaaattttgaggttctac
+tgataagtttagctatcgctgtatgtctgaataagaatttaatgtttatcttcgataaat
+aacaattaacaactcctaggtgatacactgtgaagtctgctgttccccaaattacatatg
+ctattttgttcacataccatgaagttaagctaagtgctctataatggcataaacggttat
+caaactagctcgaatttcttttattacgccggaagcggattaactgctgtagatcaaaca
+cgttaggatagtgtcgttttcatatatatctaaattcggtctaacatgcattacccatgc
+ttgataacgtagcacttcgcagtctaattatgtaatgtccgtttaaccaaactttaaaaa
+agtttatctatcaccagtgatgcctcatcgtgactacccggatctttagcctttagggtc
+taaacagaactaatattactacgtgtcatactccggagcttaaccaggtgaaacttattt
+gttaaccaaatttagtgacagggtagaaatacgtatcaaattaacccagcaatacaataa
+gcatgaaaataattgtaatcgggtttgggccggaatcccgcttggcgaaaacttaatgac
+atagtgtgatgcattttgcactggattgagccacaaactcaactagcattatgctcaata
+tttggccagtgttctacggtttgaaatttataaaggccgcgcaaaagtcttgtagttaca
+aacgcataaatctcgaacgtaataggtttaattagaacatccgtaggatttctgtttata
+gtagatttatactaaatgttctgattagattctgacggccttacccatacaattaataaa
+gacgaatatattagttatagtttactatccaaataaattaagcgaatcgaaataaactgt
+cacgatactgggcagttatcaacttatcacttatacagttcggacactctatattggtct
+gtgagtactctatcaaactaactcataagttaactgcgcttccattaaatttcaatacgt
+tcttgtgctgtgtacaaacctataatcgaataaatgacacatatggagatgcataataaa
+aaaaacggctccatatttctcgttaatcgggcattcttaaggaggagcatctcaccaaaa
+ataacgttcctgataagtcttaactattagaccgtcttcgggaatgaacgaaacctcaag
+ctagcatggtatagttcttgatagcgcgtaaattctgataatactgggcggacagctgga
+aattagttgccagtgcacctacgcaaatagtttacataaatcaacgggctccgaacgtaa
+atacaaagggttagttacatcgcaacaagatgaaaagcatgtatgtctaccgtcatccgt
+ccctaacaaacataaaggtggtgaagaatctcgtaggtcaactataactccatccttgaa
+gcaactactccgcgtccgtgtgcgtagttcgcaacgagaacactactgaaaaaagctaaa
+caactctcggtacaaatgcggcttgtgtcgataaagttggtggtagtgcacggaataaca
+taacaaggaatattatttattcaaattttttgtgactgttatttgttttctgcctagaat
+gtaaggatgtgttttttgtgacctgatagttacgcttatttcaggtccacggtgcgtgag
+agtgtgtcctataacggcaggggagcgaagtagtgtcctttagactattcaaggtagaat
+tttgataacgctctataaaaggtagaaaatcatgattgagcaataagaccccaacttatc
+aaaaaaggagttctcgacagcgcgtgtacagtccctataacggctgtatttcctgtgtca
+caacaccctcccatcgcactcaaaatgtagatttatgatcagacgctaacttgttcttag
+agaaaaatacacgggatactctgtgcaacgatttcattaataaggtgcagcttgggactt
+ttttggccgtaggctttattaacattcacagtaggtagcgagacttcctatgaaccaatc
+atgccacgcgttttaacgtttcaaatataagctaggaagcgtttgccaggacttctataa
+tgcaccgttttttttagtacttccttactagccttagtttatgttagagtctttccaatt
+acaaaggattgaatagccaaaatttctacaattctcagcgaacgccagcttaatctaaac
+acgagcttcaaatattctacatatcggcaggagtcaatatataaatatgaaaatcgtacc
+atcctcgtacttttagaccaaacgtcttcggataattaaatcctttttcaattaccacag
+tacgtgcattagaactactgctatgaaagtaaaccttgaaatatagtcctcaagagcgta
+tccaagtacattgcacgtgtatacagtcgtataaacgagttgatgttctgacgctagagc
+ttaccattcgttaaacagataactaaaatttaatggctgagtgacttagtgttttcgaca
+aacgtcgcggatgtagactattgtttataagcaatttttaaaaacatatgttcaaaacgg
+tatgggatatgtcgaattccacaggggtttatgtaccatagaagtatgtataaggtacta
+aaggtttaaatctgtgatattcggttcggtgaaaatcagactagtcacacttagtgtctg
+taaattagattgggtgaaggtaagcgatcccgaactctacaaggcatgggatgagattct
+accgactccggataacactttacgatcgcgcataactctagctcttagataagtttaact
+tgtcgatctcataaacagttcaaaatctgcgatttattgtatcaaatccatcctctatct
+tctataatcatctgaaccgcgatacggcactatgagccaagtgaagattgaatccaagaa
+agctataattggtttattttagtccatttaaattaagtccggtataagtgctctgtacaa
+tatgcagtctcatgggcatatacgttaactaccttttgatacttcgaattggtaaaatat
+cgactatcgatttgcagtaaaaggtgtagagtccaattactctttcctgttacatacgat
+ctcttagtttggacaactagcccatgatggcgctcctctagcgcatgaacctactttata
+attacatctttatcgatgaatttttttagactgcggaggccttgagttttaacagggctg
+ctaaatttcttaagcgattagacggtagcgtcgtacgctacttgcttggaacaggcaccg
+aaaatattgatctactattgcgtcaactctattctgctaatagcgatggcaaatcacaga
+agccctcttagtgacaatagttgtcaactatatctaagtcgacctttactgtatcaacga
+tcacggagagaattaccgaatacgaaacctcaggactaaaaaacggaaaggatttgtcga
+cggtaaatataatacttgttaagggtagcgacacaggtatactttgggtgtaaacgtggt
+gcttcccggaacgattttcagaccagaaaattgttccggtaaccaggaaatctcgtctgc
+gttaattcgtgttagtaaacttgatcttcagactccttcttttcgttgcagcgagactta
+aattatatctgcgaaatagtgccccgtgcatacttcagatggtaggagataccatttggc
+ccattgtgactttacgcgattaattaaccgacatacatctgttcctgagctatgatcgtc
+tgaataaattacggtctcctcttgatacctaatggtttctggagacgtttctcatgttca
+aatggatagcaggagatcgcttcatcaagtttagctacgcagagcatcaaaatatgtatg
+ggaaagtcgatttccaaaccagaagggataaagagaaataacggacttctccgtagatta
+gcctgatattttgatgggaatcatggcggcacatacgtaagagttgcgtgaacgaatatt
+ttggacggcgggagacacatatcggccattcgttaaggtctctatattggacatcacaag
+cttagcagtatgagctactaacactcaagacattattgattttttcaagatatgtttcat
+tcctctaccgctattcccatacgttcgattcgccgggtgagcgaaaccacgggactgagg
+ttaagctaatcaataacaactcgttgcgatagagacctatgtatactagagagaattccc
+caacatttttacaaaaacaaagcagactaaaatagatacagtccctccatacaattagga
+ccaacatgttattgccgatcctagcacacacaccacaaactcagaacttctgtcttacct
+atgaaagggtctgcacttctgattgtacgtgtctaattagcattaatattaaaactaatt
+aggataaactataggtacgagctttactataagtcactaggtgttttccgatcgaaaaac
+gggaccttcaagccttggtaagtacatttaggataaagaaaaaaaggaaggtacgtgact
+aatctgtctaaactgacaatagagtagtacctacatgcttcatgtcaagtcttaatacgc
+aagcgctctcgttatactgctcaacaaaactcataaagttggactccatcatttagaatc
+atagggaccaaaacatttatttgctactgtcactttgtaggtgttctattctgaattcct
+catattgatacatgaatcggaatacctgtggatcccttaggacgcacgtgctttctttac
+gtcagaatacatattgtcagaatcgagaagttccatgcaattaagaattcgcctctttga
+aaactcatatccccacatatagggtccaccgttattcggaaacgatataataattattcc
+agcgttgagcgtcccttaagagcgcattttcgcttggcctttcttctacgactctacaac
+gcaagtggctgtgtggagtttaccacagcgcagcaccccatagaactacctctgagagcg
+cgagatggtggcagtatgctctgcagctagcgtttagaacgcgcccgcgcattaaccagt
+catattaaaatggactgtcttaattgtcggcattaggagcaatattaactgatgagggta
+tcggtcgcagaagtaatgacggaaatacgcctctagtccgcagagatacgattacagact
+cagatcccctaacaagcaaaacgattaaatcggaatcactccccctatgacatatttgaa
+atacacaagaaaccacgcaacatgtcccgcattctcaaccgcgctttataagatgttgag
+tctgagaattagatgacctaactgcaagaatcatggcgagtttatctagtaggcaagtct
+gtaccctagggttcgaacgctgtgacgtcgtgatcggtctaaggacttagatgataacca
+agaactggtttaccgagtactttcactattaggagtaattacatgcgttcaccgcggaat
+acgacgaaattttttcatatctttatgagcgagatcgtgtcgtctttgcattgcaacagt
+cgctaccagtaattgctgatcaattatagattcattatacagatgcttacttttctctat
+tcaatactgtcatgagttgtttttaaataagcaccagaattatgtcgcctagtataatct
+tgcttccacttgaatcaatgcgatggacagtattctactgattgcaaagtagtctatttc
+ggcttagcagtacgcatgcctatttttttgcaggcacagaataatatgcaactaggattc
+tcggcatccaattaacaggctaaaacaccaccgaaagacaggtaatctacgaagttgatg
+tttactacagaaagcgaatgatatcacttggagaacattttagatgcccccttttaatct
+agactgagtgtaccaatatatcaccggtctaccgaatcagcttgaataaaccactctagt
+actcatgataaccgagcatacacatgtatttctcaatgcactgaaggtgaactgtttaca
+ccataccttgcgaatcaacgtggcgacttatacttctgtctttgagtacagcacacccta
+atgaatctaagttagttgttgatacgaattgtaatttgactggatctcgcctcctcatct
+agattcttagagaagatgtttcttatagccggtactgtaactttattgatctggtttatg
+gtaatcaacattttacctctatttaaacgtccttgcgccgtgcactcaatcctgatcggt
+ttagattcaagcgattatcgagtctggaggccgagaaaagaaatgcacagagtaagctct
+ctattgcgacatctacgtagaaactcgcatttcagatcgagtaagcaactctcattgtgt
+tgattcagtaatacaagattacctacgcttctacgaaatatactatagatttagcctacg
+tcacctttagtgtcgagtcggagctttgaagatcggatgcggtgtggactgtgtataggc
+aattttgctgcgagctcgtgacttttggttgatgtcgatatcaatgggatacctcaaacg
+tctttatctctggataactcacattgagtataccggtaaaaatttattctattcatctaa
+atagtcagtgagggctagggtcgcaatcacattaggccacatacacatacttaacatgtt
+ctattgacccgacccaactttagtagcattgtagccgtttatgcaaatatgccaggcgcc
+aaacactagccagagggcattttgttacatttatttaatcgattattacacagtcggaac
+acgcctacatgcgttcgacttatttgcgacatggtcaacaattcagtaatttaatccaaa
+acctaaagtcagagacatgacactaaaatcacattaaggtcagttagtgaaggaatggct
+aaccagctagagaatgcatcattaacaggcacttattgtcaaatattttccagatctaag
+caacatcacgttaaaaagtacaacaatcacttaaaacacatcagtccaggtgtaattaga
+aagccgcttagtaggcaagcgtaggagtataaatgtagacaatagtcgggacttagcaga
+cactggatgcagtcatagaagatcttgcataacacgttagggttagagctacgaacgccc
+atcattaactgcctaaagcgtgcgtgagcttagcgctaacttttccaacacgtttgtgat
+ttcgttcataatgtatcaatttcacagtcatatacagggagtgtagaaaaatcgcaatta
+acatacgttgacctatttttgttcagagttcagttagagcctaatgattcgagagcaata
+atcaggacagcctcataggaagtgtcaatcacttagaagctatattattataaatcgctc
+tttactgtcgtcgaaggaacgagcgagagagaatcagttgcctgcaactggcttaacaat
+atgatacataaaaatattttcatcaccactaagacggtggaattcagacttattggcaac
+ttaggatgggactattaaataacccataagatgttgggataaagttacgaaacgaaaggg
+atatagcctgttagataggaaatccccaataaaacatagccggcctccacagcagtgatc
+tattccgccacgcgatatctttataccacgcaatataccaataataaaggttaaatgtgg
+ttgcgatttaaaaaagatacatatcagttgcaccgcgtagcaaatccgtatgtgaagcgt
+aacctagaattatagcgtctgcaagttctctaagcttcctctgcaagatacaatatgact
+ttttagcttttttactaccaaatctcagaatcttagaaacaggttggtacgtgctactcg
+gaattcccaaagtaccctgctatatatgccattccttcattggtccgggctcaccatggg
+gccatcatagtaatagaaggtagtaaaactagttgatttccgacttttaacaatcactat
+cctgacccagatatgggttccgactggcccttactccagtaagggcagacacacagacaa
+cgagaacttgataactttgaattctcaaatcgatcattgcaacgtgacttatttactagc
+ctactcctataattcatacgtcaaatacatttcaacggaggaagataataagtaaatatt
+cactaaataatggtcgaaggagtcctttgccaacataagtccacatatgcgctatagatt
+ttttcttggggttcatattcaataagataaacagcaagagtatcacgtcagcgagtcatt
+gagatcttggctagcattgtgatagcatattctacctaaatggtagtctagcacagagtg
+gataagatatcagttagatatagacaagtactataacagatctcgcttcgttggattgta
+tggctagctttgatgatatgattttataaaaattgatccagacctgacctggccaattat
+attcattttttatgagtaaaaatagataaccatgaaaatactcaagccccttaggacgta
+caaagtggtaacataaatttcaggtgttattctgcaaccacacctgttttgggttttcaa
+aaaggctaagcagattggttttacagataatccctgaacactggtatctcccaacgatgt
+cgttcccaacccttgctgaccttttaagctctgctgaagttttgtaaactaggcggaaaa
+tatgttcgatagatccactcgcctgaggtagaaattcgtcttagtaacgcctctttggat
+tacacagaatagtgtactgacacgtacactgctgcagcagccatacgctaacattaaaat
+tcgttgagtctacatttgttgttattcggattatgttattgggaatagtatttttattcc
+cctgcgtgaaaccacatggatagattagcctactcctaaagactcccttttggtctacgg
+ttcaattctcttactgagtttatgttcgtaattatatcggcgcagtgaatctcctaatta
+tcaccggagttaccagacgccatgaacttatggccagaaacattgcatgtggcctacata
+ggattagtatcaagagtttacgtttgcaacgacatttgaccaacttgaccattcctgctt
+gtagaccgcgggaactcccctgcacgcgactatagaagttggtggtggatgtggcttatg
+ccgcaaatatggttttgaaaaaagtaatctattgcttgatacctgaattgagacatgtat
+aagggctattgccagatgaaaaactgcatataaggtcaaacaatataagaacattataca
+taggatcttagcgttcctcaggatggtatacgctataaagtctagcttcagcagctaagg
+agttttgccagtgcggacttccgctggaagattaggtttaaccgccctgacatcttcata
+aggtcgggcctgattcaaacccctggagtgccgtctcatacttgaattaatcgatggaaa
+acttcttctagtctaatattattattaacaaatgacggttcaataaataacaccgtaagg
+gtgggaaactgttaagtgatgaatcattttaacctatcatccattagctacagataatga
+taccccgatccgactagggggtaagtggttgttccgttaggataaaccatgtaaaacgtt
+agagggtttgtagattaattggtattccagataaatgaggtcagggcgagtgatcaatta
+cactgaaaaattgtcagcttgcgcggtagttgttaagacagtataaatgaaggggattca
+gaagcaagtttctcgattgactgaatttataaaccagtcgtcaatcatgatttttgtgtc
+gattaaagcctaaatggtaatttaaaccattgatatttatcgagtctataaatatctttg
+gttgtatattacttcacaatcaccaattctaaatgattcttccactgtgcgggtggagat
+atcaggacgggttaaggttgacctacatcgttttgatacaacaaaaatcaaagcacatgg
+ctggggacttctcgatactatctttgagatagtacgggcaagagtgggtgacgcctccct
+acattttcaagtctatcggataacttctcggtaaaacgctcgcgatatagttttaaagca
+ttgatttaatccacgcaggagcaagttttaccggtcgaatgagaaaattcaacgtaagtg
+tcatatccagtcatggttagccaaaagcatgggttatccaaaaggaataaaacagctctt
+caacaaagagatgaggcttcataacttcgatgaatgcgtatggttctgatatatagatcg
+atgcatgaggacactttattttagccggcgaattaatggaatccatacgttacttatttg
+gacatgacttctaggtgtttttgctgtcccgtttagcgatatttacagattagtatttcg
+tttctcatagttaattgtatctagatactaactcgttgaagacgcataccttgccatttg
+tacaggacttaactgttccgtgcgtaatttgaatttcttataggttcttcaaggcacgaa
+tacctcactcatgaccgttcatactctagttaaggtcgggaatactacgtatgcagggaa
+ttgtaacctaggagatttacaactctttaaacaagagtcgctgaggtccaggatcaaaac
+actgaatctcctaacttcgggtgcctccgtaaatcacctagaaacctactcatacatttg
+caattttgagatgtaggcgaaagagagaaatctgctttttaacggtatctcttgggattc
+cttttaaaaacacataacgatagtaatgtaccaagtaaccaaaagctgggatgtgtctgt
+gtactgatccgccgtgtcagagtagtccgccatgaatattgacgtcaaggctagtgtcat
+caggtattgatgttcattgtaaatgaaggaatgaactaatgtcaccaagtaaagggggtg
+aaaatgctccccagggttctacagacatagagatggtcagaacacgacccccctctcaac
+gcagtgtatttgaaatatatggacatatctaccttattctgtaattttagatgtgttctg
+tgtataccgatattgataagtcaataggcttgattacgtatcttaagacaaatctgtttc
+gcaagtaggaccgcatctttcagattgtttctttttatgccataacctgcccaggaattc
+aaaaggttatcgatacccgatatgctgtgaattattattctaatggccactcattcctgc
+ttatatctggaattggcatgaatatcttacaacctaaagtctggcgttgcgccagttcta
+cttcgtaccggacaccatctccagtcgttaaccgaaggtgggtacgtcacataaaagttc
+attagaccacactttgtgccgacgtatatagatatattacacgtatagggaatgttttct
+cctaggtgacccgaccttctactaaggttgtacatcgtataatggcccattaactacgag
+gaaagtggtattgacctggtaatgcacgttcttcgatatataccgacgaggtaaagtcta
+ctattgcaaagtttgacgttatactgataagtttagatttccctggatcgcgcatgaaca
+atgtatgcgttatctgccatatataacatgttacaaatccttggggatactatcgctact
+atcatcggaccaaaattaaataggctagtgtcttatcagaacatcatgtttaccgaactg
+atctattttccaatttaagctgatattacgtccgcgtatttattttagttccccggatga
+cgattatctgagctacatcatacaagttagcatactcgccggtgcattgatttcttattt
+cgctatatcttcaagttcacaggcttcatatagttccaattagcagtataattaggtttt
+gtaactttaaccatactttataaaaggttatattgcacaactgatcaagcatccgctata
+acccgagctttaccagttagcggctaataacaaataagatgacttcgtgtcatacgaccg
+tcatgatcatgctctaacttaggtgggaaccaaatttaggcaatgggtagtaataagtat
+aaaatgataccacatatactataacaatgaaattatttgtaatccggtttgccaacgtat
+cccccttcgcgataaattaatgacatagggtcatccatgtgccaatcgtgtgtgccaaaa
+tctcaaattcaattatcatcaatattggccaagtgttataagcgttgaaagtgatatagg
+ccgccaaaaagtagtctacttaaaaaccaatatttatcgttcgttattgctggtagtaca
+acatcacgagcatttctcttttgagttgatttatactatatctgctgatgtgattatgtc
+ccacttacccagaatattaagaaagtcctagattgtaggtatacttgactataaatataa
+tttaagactatacaaataatctggctacattatgccatcgtagaaactgataacgtagta
+acgtcggacactagattttggtcggggagtaatctagcatactaacgaatttgttaaatc
+cgctgaaagtatatgtcattacctgcttggcctgtcttcaatacgtttagactattaagg
+actcatttcgagatccagtattaattatacgcatccatatttatactgaagacggattga
+gttaggacgacaagctaaacaaatattaagttaaggattagtattatattgtagaaactc
+gtcgggttggaacgattcatcatcatagaatgcgttacttattcagagagacttaattcg
+gttatgactggcagctcacctggaaagtaggtgaaaggcaacagaagaatattgttgact
+gaattctacgggctacgaacgtaattacaaagcggttcgtaaagagcataaagatcaata
+caatggatctctacagtattacgtaaataacatacataaacctggtgttgattcgactag
+ctcatagattaatcattaattgaagctacgaagacgcggaagtctgcggagtgagcaaac
+agtaatcgactgataaatgcttataatatcgcgcttaaatgccgcatggtgtacattaac
+gtgggggtagtcaaaggaatatatttactaggaatattagttatgcaaatgttgtgtcaa
+tgtgatgtgttttatccagacattggatgcatggctgtgggggcacaggatacttaccat
+tagttcacctacaagcggcgtgagagggtctcagttttagccagcgcagagaagtacggg
+cctttagacgattaatgctagaattgtcataaacctcgtgaaaagctagttaataatcat
+ggtgctagaagaacacaacttttctataaaccagttctcgactgacagtcgtaactcact
+atatcgccgctttgtactgtcgcaaaaaaacctcacatagaaagaaaaatctactgggtg
+catcagtagagatcgtgttctgagagataaatacaccggatacgatctgcatcgagttca
+tgtattaggtcaagcttgggactgttgtgccagtagcattttttaacagtcaaagtaggg
+tgagacacgtcatatcataatatatgccatcgaggtttaaagtttatatgataagctagc
+atgcgttgcaatcgtattcttgaatgctccgtggtttgtactaattcctttatagactga
+gtgtatcgtacactcggtacaattacaaaggatggaagagcaaataggtcttcaattata
+acagtaccccaccttaatctaaaaaccagcttcaattagtattaatttcgccaggagtat
+atatataaatatctaaagactaaaagactcgtacttttacaacttacgtcgtagcataat
+taaatcatgggtaaatgtcatcagtaagtgcattagaaatactcctttgtaaggatacag
+tgaatgtgtctcagcaagtcagtagaaatggaaattcatactcgattaaggcctataaaa
+ctgttgttggtatctacagagtgattaaaattagtgaatcagattacgaaaatgttttcc
+cgctcgcacttacgcgtttagacaaaagtacaggtggtacaattggctgtagtagaattt
+tggtataaaataggtgataaaccggatgggtgtgggcgaattcaaaagcggtttttgttc
+catagaactatgtagttggttataaaggttgtaatctcggagattaggttagggcttaat
+cagaatagtaacaatttctctatgtaaagtacagtgggtgatcgtatgagttcacgaact
+cttaatgccatgcctggacaggataaacaatacgcatataacttgacgatcgagcttata
+tcgacctatttgagaagtttaacgggtcgatataatatacaggtcttaatagccgatttt
+ttctagaaaagcaatcctatatcttagttaatcagatcaaccccgtgaacgatatatcag
+caaactgaacattgtatacaacattcctttttgtccgggtggggactccatttaaagtat
+ctcacctagaactcagcggtaatagatgcagtctcttgcccagttacggtaactaaatgt
+tgatacttagaattgctaaattttagtctagacatttccaggtaaaccggtagacgacaa
+tttctctgtcatctgtcataagatcgcttagtgtgctcaaattgcaattgagggccctac
+tatagacaatcatcagactttttaattaaatagttttccatgaatgtgttgtcaaggcgg
+accccttcacttttatcacggctcataaatgtcgtatgactgtagtcggtagcggccttc
+gagtcttcaggggaaatggaaaagaaattaggcttctaagatggactataatcgattagg
+ctaattccgttcgcaaatcacagaagcaatcttactcaaaattgttggaatcgatagcga
+acgcgaccgtgaatgtttaaaagtgctcgcacagaattacccaatacctatcatcacgac
+ttaaatacccaaagcagttgtagtcgcgtaatagattaagtctgaagcctagagacaaag
+ggatactgggcggggaaacctgctccttcacggtaacatggtaacaacagaatttggtta
+aggttaaaacgaaatatactcggagtgaattactgttaggtttcgtcatcggatcaataa
+gtagtttccgtgaagacactcttatattagatctccgaaattctgacccgtgcattaggc
+acttggtaggagattccatttggaacttgctcaatgtaagccagtaatgttccgaaataa
+ttcgctgcaggagcgaggagccgctgaataaaggaccctcgcatcttgttaccttatggt
+tgagggtcaccgttctctgcgtcaattccagagctggagatacattcatcaacgttacct
+acgcacagaataaaaagatcgagcgctaactcgttttcctaaacacaacggatttagaca
+aattaccgaatgcgccggagagtagcatcttagtgtcatgcctatcatggcggctcagta
+cgaagagttcaggcatcgaatattgtggtagcccgcactcaaagttccgccattaggtaa
+gctatatattgtggtcagaacttgaggacaactatgagctactaaaaataaacaattttg
+tcatttgttctagatatgtggcattcatcgaacgcttgtaccagaagttacattcgcagc
+gtgagcgaataaacccgaatgagcgtaacattatcaataacatatagttcagatagagaa
+cgaggtattcgacagagaattacccaacattggttattaatctatgcagaataatttaga
+taatgtcactacataatattaggaccaaaaggtgattccccagaagacaaaacaataaac
+aatctcacatattcgctagtacctatgtatgggtatgatcttctgattggacggggataa
+tttccaggtatattaaaacttattaccataatctagacctaagagaggttatataagtaa
+agagctgtgttccgatagaaaaacccgaccttaaagacttgcgaagtaaattttgcttta
+acaaaaaaacctacgtaagggaatattctgtataaactgaaaagtcaggtgtaactacat
+gagtcatgtcttcgattaattacaatgcgatctcgttattctgatcaactaatatcataa
+actgccactacatcttgtacaatcattcgcaacaatacttttatgtgctaaggtcacgtg
+cttcctctgctatgctgatttaatcagattcataaaggaatacgaataactctggatcca
+ttaccacgcaagggatttatttacggctgattactttttggctgttgacagaactgccat
+gaaagtaagatgtcgcatcttgcataaataatagcacctaatatagccgacaaagtgatt
+ccgataacagattttaagttgtccagccttgagactccatgaagaccgcttgggagcttc
+cccgtgattagaagaatctaaatcccaagtggatggggggagtttaaatctcagcaccaa
+caaatagtacttcctctcagagcgcgtcatggtcgaaggagcctatcctgatagaggttt
+gaaagcgcacgcgcatttaactgtcatattaaattggaatctcgtaagtgtcggcagtac
+gacaaattttaactgatgtcggtatacggagaagaaggaagcacgcattgaagcagctac
+gcagaactgagaagatgacactctaagatacaattaatacaaaaacgttttaagcccaat
+ctatcaacagatgtaagatgtctaatacacaagaataaaaccttcatgtcccgatgtata
+ataacagctttatttctgctggtcgaggtgaagtagtggaaattactccatcttgctgcg
+cgtctttatagtgttggctactctgtaaccgacgcgtccatccctctctcctagtgatcc
+gtatatccaattagaggataaccaacatctgcgttaccgacgaatttaaatttttcgact
+atttaattccgttcaaacccgtattcgtagtaagtgtttcatagatttatgaccgacatc
+gtgtacgagttgcagtgcatatgtagataccactaattgctgatctaggatacatgcttt
+ataaacatgcttacttggctattttatttactgtcatgtgggggtttttattttcaacaa
+gtatgtgctaccattggataatctggcttcaaattgaagatatgcgttccaaacttgtct
+actgtttgctaagtaggagttgtcccattagaactacgcagcacgtggtttgtgatcgaa
+aagaataattggcaaatacgaggctagccttcaaatttaatgcagattactcctcagaaa
+cacacgtaagcgacgaacgtgatgtttactacacaatgcgtatcatagaaattcgtgata
+atttttgttccaacctttgaatctagactgagtggaaaaagatttcaccgggataccgtt
+tatgctggttttaaaaactcgtcgaatcatcttataactgcattcaaatggatttctcaa
+tcatctgtacgtcaactgttttaacaataacgtcagaataaaccggcacaatgagacggc
+ggtctttcactacaccacacccttaggattataagtgacgtgtggattcgaattctaagg
+tgacgggatctacaagcctcagctacattaggtctgaagatctttcgtatagccgcgtat
+gttactgtttggatatgggttatgctaatcaacagttgacagcgagtgaaacggccttgc
+gacctgaaatctttacggttaccttttgattcaagacaggatcgacgatggaccacgtga
+aatgaattcaaaactgtaacatcgcttgtgcctcagcgaccgagtaacgacaagttcaca
+tcctctatgcaactatcattgtggtcattaaggtattcaagattaactaagagtcgacca
+tatattctagagttttacaattaggaaccgttagtctagactaggagcgtgcaacatcgc
+aggaggtgtggactgtcttgacccaagttgcctgacacatagtgtcttttgcttcatgtc
+cttagcaatgcgatacctcaatcgtagttttatcgggataaataacatggtgtttaaccc
+tattaatggtttctattaatctaaattgtaaggcagcccttgggtcgaaagcacattagg
+ccacatacacagtatgaaattgttcgagtgtccagaccataattgactaccatggtacac
+ggtgttgctattatgactcccgcaaaactcttgacagagggaattttggtacattgatgt
+aatcgatgatttaacagtaggaactagacgtcatccgttagactgagttccgacatgctc
+aaattgtcaggatttttatccaataactaatggctctcacatgtaaataaaatcacatta
+acgtcacttagtgatggattcgctaaacagatagactatcattcatgaactggcactgtt
+tcgattatatttgcaacatcgaacatacttaaagttaaatacgacatcattcaattaaaa
+aaattcagtacacctctaatgagtatcccgctttggaggaaagagtagcactttaaatgg
+acaatttaggccggactttcctgtaaatggatgaagtcattgtacagcttgaataaatcg
+ttagggttagtccttacatccaccatatgttaatgaataaagcctgagggaccttagagc
+taacttgtccaacacgttgctcatttacttaataaggttgaaatgtatcagtaagtgaca
+gcgagtgtagattttgaccatttaactgaccttcacagttttgtcttcagacgtcactta
+caccataatgatgacagagcttgtagatgcacacactcattcctagtgtaaatcaagtag
+tagctagattattataaagagatattttctggcgtcgaacgtaacacagagagagtataa
+ggggcatgataatggcttatcaatatgtgtaagaaaaagtttttaatatcatctaactcg
+gtggaatgcacacttatggccaactgaccttgggacgagttaagataccataagaggttg
+cctgtaagttaagataacaaagggatattccatctttgtgtgctaagaacctatttatat
+ttgcagccataaaaacctctgtgctatgcagccaccagagttatttatacaaagaaagag
+accatttagatacgttaattctgcttgcgatttattaaacagacatttcacgtccaacca
+ctacaaaagccctatcgcaagacgatcattgtattatagcctatgcaacgtagctaagcg
+gccgaggaatcataaaatatgaattgttacattgtttactacatatgatcacaatctttg
+taaaaggttcgttcgtgatactaccatgtacctaactaacctgagatatatgcaatgact
+tatggggtcagcgcgcaacatccgcaaagcatagtaatacaaggtaggaaaacttctgga
+tttcccaaggttataatgctctatactgaccaagagatccgttacgactcgcaatgaata
+ctctaagggcactcacaaagaaaaccactaattgataaatttcaatgataatatcctgaa
+ttgcatcgtgtatgagttacgagaagtcgcatttaatgaattagtcatagaaatgtcata
+gcaggaacataattactatattttaacgatttaatcgtagttggagtcctttcccaaatt
+atgtcatcagttccgatttagatgttttcgggcccttcttagtaaagaagttaatatcca
+agactagctcctcacccacgcatgcacatattcgcgagaagtctgatagaatattcgaca
+gaaatgcgactctagctcacactcgttaactgatcaggtacttatagacaagtacgttat
+cagatatcgcttcggggcattgttgcgctacctttgtgcatagcagttttgaaaaattgt
+tcaagacctgaacgggaaaatgatattatttttttaggaggaataatacagtaccatgta
+aatactcaaccaccttacgtacttcttacgccgaacatatatggcacgtgttattcggct
+aacaaaactgttgtgccttttctataaggataagcagattcgttttaaacatatgacctg
+taaactgggatctacaaaagaggtacttaaaataaattgcgcaacggtttagatctgcgg
+atctttggttaaagagcaccattagatgtgccatacttcctatcgcctgagcgagaattt
+agtctgaggaaccactcttgggatttaaaacaattcggttaggacacctactcggcggat
+gaagcaatacgataacattaaaagtcgttcagtctaattttggtcgtagtacgatgagct
+gatggccaattgtatttttattaacagcactgaaacaaaatggagactttagactaatac
+taaagtctcaatgttcgtcgaaccttaaatgctcggaatgaggggatcttcggaagtata
+gcgccgaagtgtatctcattattataacaccagtgtacagacgacatctaattatggcca
+gaaactgtcattgtgccattaagaggattagtagatagtctggaccgtggaatagaattt
+tgaccaaattgaccagtcctgcttgtagacagcgcgatctaaactgcacgagaatataca
+agttggtggtgcttgtggctgagcacgctaagatgcgtttgtttttacgattctagtgct
+tcttaacgcaattcagtcttctagatccgctattccaacatcaatatctcaatttaaggt
+caatatatataacaaaattagacagagcagctgacacttacgaagcatcgtagaaccgat
+atagtcgaccttatgatgatatggacgtgtccaagtccgcacttccgatgcatcttgacg
+gtgaaccgaaatgaaatcttcattagggcccccatgtgtcaaaccactcgagtcccgtct
+ctgaagtcaagtattactgcgaaaaattcgtctactattagtttattatgaacttatgac
+gcttaaataaattaaacagtaagcctgggaaaatgttaaggcaggaatctttgtaacagt
+tcataatgttgctaaagattatcagaccccgtgaagacttcgggctttgggcttcgtacc
+gtagcataatacatctatatagttagaggcttgcgtgttgttgtgctattccacatatag
+cagctctgggcgactcttcaatgaaaatgaaaaatggtaacctggcgacctacttgttaa
+gtcagtttaattcaaggggattaagtaccaagggtcgagtttctctgtatttattatact
+gtaggcaagaagcttttttggcgagatttaagacttaagcctatggtaaaaatttgatag
+tgagcgactatagtaagagatttgggtggttagtaattaaaattctcctatgctaaatca
+ggcgtacaatctgagggtgcacatttctcgacgcgtgaaccttcaccgaaagcgtgtgga
+ttatacaaatttcaaacatattggcggggcacttatccataatagatttctgtttgtacg
+ccaaactctgcctcacccctccataaattgtattggctagaggttaaattctccgtaaat
+agagacacatatagttttatacaattgtttgaatcaaagcacgagaaacttttaaccgta
+cattgacaaatgtcttcggatggggcagagcatctcttcgtgacccaaatcaatcgctga
+gcaataagcaagaaaacacagattatacaaagagatctggatgaagatattcgtgcaatc
+actatcgttatgttagagagttccatgcatgaggactcgttttttgaccaggagaattaa
+gccaagaaataactgacgtatttccaaatgaattctacgtgtttttcctgtcacctttag
+ccagtgttaaagatgactatggagtttcgaataggttattctatagacattataacgagt
+ggaacacccataccttcacagtgctaaaggtaggaacgggtacgtcaggtagttcaaggg
+attttaggttcttaatccaacgaagaaataacgcatcacccgtcattctattgttttcgt
+cgggattacttagtaggcagggtattctaacctacctgagttacaaatctttaaaaaact
+ggccatgaggtcatggtgataaaatctgaatcgcctaaattcgcgtccctaaggaaatat
+actagaatccgtctcagaaagtgcaaaggttgacttcttcccctaacacagaattctcag
+ttttatagctatctagtggcattcctttttataaaactttacgtttgtaagggtccaact
+ttacaaaagctcggatgtgtatgtgtaatcttccgccgtgtaagacttggaacccatgta
+tattgacggcatggcgtggctaagcaggtattgatcttcagtgtaaagcaaggtatgttc
+taatctaacaatgtaaagccggggattagccgccaaaggggtctaatgacatagagatgc
+tctgaaatcgtaccaactataaaagcacgggatttgaaatatagcgacagatcttccgta
+ttctgttagttgacatctgtgctgtctttaccgattgtgatttggctttagcagtcattt
+agtttcgttactcattgctcgtgcgatagttccaccgaatatggcacattcgttcttttt
+ttccattttactgcaaaccttttcaaaagctgatcgataccactgatgatggcattgatt
+agtcgattggcaactatgtcctgcttatatctccaattgcattgaatatagtaaaaaata
+aaggctcgccttcccaatgggctacggagtacacgaaaaaatcgcaactcgtttaaccaa
+gcgccgtacctaacatataagtgattgagacaaatagttctccagacgtattgagatata
+tgtctcctataggcaagcgtttctaattgctgaccagaaattagaattaggttgttaata
+ctatattcgaccattttattccacgaatgtgctattctactggtattgctccgtatgcga
+tatataaccaacacggaaagtcgtcgattgcaaagtggctccgtagaatcatttctggtc
+atttaccgggagcgcgcttgaacaatggatgcggtatctgccatattgttattgttaaaa
+agacttccgcttactatcgcttcgatcatcggaaaaatattaatgaggattgggtcgtat
+aagaaaatcatcttttcagttcgcagatttttgccaatttaaccggttatttcgtcagac
+ttggtagtgtagttacaagcatcacgattatatcagctacagaattaaactgtcctgact
+cgacggggcagtgtgtgagtattgcgctatatattcaaggtaacaggaggcatataggtc
+atagtacaaggataatgaggtttgctaactttaaaaattattgatttaacggttgattga
+aaatctctgcaagatgacgctagaacacctgatgttcaagtttgccgataataacatata
+agatgaattactgtctttagaccctcatgttaatccgctaacttagggcggaaacaatgt
+taggctatgcggagtaagtactatattatgataccacatagaatttaacattcatatgat
+gtctaatacccgttcccaaccttgcaaccgtcccgattaattaagcaattacggtcatca
+atgggccaatcctgtctcaaaaattatcatattcaaggttcagctattttggcaatgggt
+gagtaccgttcttagtgatttacgaacccataatctaggcgacttaatatacaagattta
+gagttacgttttccgggtagtacatattaacgaccatggatcgggtgaggtgttgtatta
+gttatctgatcttgtcagtagctcccaatgtcccagaatattatgtttctactagagtgt
+tcgtatactggaatttaaatattatgtaagactagacaaattttatggatacattaggcc
+atcgtagaatatgatatagttgtaacgtccctctatagattttcggagggcaggtatatt
+gcttaataaagatgttcggaaatcagcggaaaggatttgtaattaactgatgcgcagcgc
+ttaaataagtttagactattaagctatatgttcgacagcatgtagttttttttaccagaa
+agtgttatactgatgacccatggaggtagctcctcatgataaaaatattgttacttaagc
+attactattatagtgttcaaactagtaccgttgcatactttaagaatcagacatggcgtt
+tcttatgcagacacacttttttagctgttgacgcccacctcacatccatagtaggtcaat
+cgcataagaacaatattctggactgttttattacccagaagaaagttttttctttccggt
+tcgttaagacaataaagatcatttcattcgttctcttaacgatgaactaaagtacttaaa
+gtatccgcctcttgtttcgactagcgcatagtgtaataattaaggcaagataagaagaac
+aggaacgcgcacgtcggagataactctaatagtctctttattccgtttaatatagcccgt
+aattgcaccatgcgctacagtaacggccgccttcgcaaacctatttatgtaattccaagt
+ttaggtatgcaatggttggggcaatgtgaggggttttatcaagactttcgttgcttcgcg
+gggggcgcaaagcagactttacagtagttaaccgaaaaccgcagggagtcgctctaagtg
+ttaccaacccctcactactacgcgaaggtactcgattattccttgaatgggctgaaacat
+cgtgattagcgtcttatgattcaggctgatagaagaaaacttattttctatattccacgt
+atacaatcacactcgtaactaaatagttcccagcgttgtaatgtcgctataataaataaa
+atacaaagaaaattcgtctgggtgcataagtacagttagtcgtctgtcacataaataatc
+cgcagtcgatctcattacaggtattgttgttggtcaaccttcgcaaggtggtccaagtag
+cattgttgaacagtaaaactaccgtcacacaaggaatatcataatagatgccatacacgg
+ttttacttgatatgtttacagtccttgagttgcaatcgtagtattgtttcatccggggtg
+tgtacgaagtaatttagacaaggtgtgtagcggtcactaggtaaaatgacttaggatgga
+tgagcatttaggtattctatgataacactaaccatcatgtttctaaaatcctcaggaaat
+ttgtattattttaccaacctgtatttatagaaagtgcttttgacttaaagaagccgaagt
+gttcaaattaaggagtacctgattgaaagaatggggaattgtaatctgtaactcaattac
+aaataagccgttctaaggattaaggctttgtgtctaagcaactcacgtgaattcgaaatt
+catactcgattaacgactttaatactcttctgcgtatctacagactcatttaaattacgg
+aatatgttttcgtttttggtttccagctcgcacgtacgcgtttacaaataaggacacctg
+gtacaattggctggagtacaatgttggtttttatttgctgattatcccgatccctgtggg
+cgttggcataaccgggttttcttcaagactactttcgtgttgcttatatacctggtaata
+tcggtgagtagcttagggcttaatcacaatactaacaagttctctatggattggacaggg
+cggcatccgttgactgaacgatctattaatccattccctgcactggataaacaagaccca
+tttaaattgaccatagagatgttagcgtcatatttctgttcgtgatagggtacatatatt
+ataaacggattatgagcagtggttttctagaaaagcattcatagttaggagtgtatcaga
+tcataccactgaaccatagagcacaattctctactggctatacttcattcctttttgtcc
+gggtggggacgaaatttaaaggttctaacctagaacgcagagcgaattgatcaaggcgct
+ggccaagtgaacggttctaaatgttcttaatgagaattgcgtattttgactattgacagg
+gcatcgtaaaccgctactcgacttggtatctgtaatctgtatgtagatagagtacgggcc
+tataattcaaattcagccaccgaagattcacaatcttcagacgtttgaaggaaagaggtt
+tactggtatgtggtgtcaagccccacccattctctgttatatccgagcattaatgtagtt
+tcactgtactacggtcacgccgtagagtcggcagggcaaatccaaaacaatttaggctga
+gaagtggcactataatagtttagcctaagtcccttcgctaataactcaacaaagatgacg
+caaaagtcggcgaatagattgcgttcgcgtaagggtatcttgaatactgatagctctcat
+ggtaccaagaactttcataacctctttatttaccaaacctgttctactagcgttagtgtt
+ttagtctgtagccgacacaaaaaccgagaatggccggcgtaaccggcgcctgcaagctaa
+catgggatcaaaactattggcttaacgtttaatcgaatgagactagcactgtattactct
+ttcgtttcggcagcggatcaataaggaggtgacggcatcactctcttatagtagatatca
+cttattctcacaacggaagtaggatcttccgtcctcattaaatttgcaactggctcaatg
+taacactgtaatgttaacaaagtatgagctgaaggtcagagcagacgatgtagtaaggtc
+cctcgaagctgcttacagtatccttgaggctcaacgggctatgcggaaattccagacctc
+gagttacattatgaaacgtgtcattccatctcattaaatagttcgtgccctatcgccttg
+taatataaacaaccgtttttgtctattttcccaaggagaaggagagtagcagcttagtgg
+cttgcctatatggccccctaagtacgtactcggcacgcttagaagattgggctaccccgc
+actatatgttcccaaagtaggtaacctagatagtgtcgtatgaaattcaggtcatcgatg
+agagtataaaaatatacaattttggcaggggttatacattgcgggcatgaagagtaacat
+tggacatgaacggacattcgaaccctgtgagtttaataccctatctccggatcattataa
+agtaaatatacgtcacttactctacgtgcgtttagacagtctttgaaactaaattggtta
+tttttctttcatctagatttgtctgtatctaactaaattatagttccacataaagctgat
+tcaactgaagacataaatataaactttctaacatagtagcgaggaaagagctatgcctag
+catcggatcatgcgtccgcgagtagttcctggtagagttaaaagtttttccagaatctag
+accgaacacagggtagtgaacgaaagtgcgcggtgaacatacataataccgaacgtaaac
+aattccgttcgtattgttgctgtatctatatttcctacgtaaggctatttgatctataat
+atgaaaagtcacgtcgaaataaatcaggaagcgcttcgagtatgtacattcagatctcct
+tagtatcatcaaattatagattttacggccacgaattattggtctagatgtcccaaaaat
+aatttgatgtcagtagcgatcgtgcttcctcggagttgaggttggaagaagagtcattat
+gctataccaagaactctccatccagtacctagaaaggcaggtatgtaccgctcattaatt
+ttgcgatcttgacagatctgcatgcaaagtaacttgtaccagatggcttttataatagaa
+actaagtttcccgaataacggtgtacgataacagatttttaggtgtacagacgtctgact
+caatgaacacacattgggacctgccccgggaggagtagtagataattaccttctccagcg
+cgggtcttttaatatcacaacataaaaatactaattaatatcacacaccctcatcctcga
+tggagcctagcatcatacacgtttgatagacaacgccaattttactgtaatatgatattc
+gaatctagtatgtggacgctgtaccacattgtttaaaggagctccctttaccgacatgaa
+cgaagcaagctttgtacaagatacgaagaactcagtactggtaactataagagacaattt
+atacataaaagtgttaagaccattatataaaaagaggtatgaggtctttgtaactacaat
+aatacattcatcgaacgatggagaataacagagttatttctgctgctcgagctctagttc
+tgctaatttctcaatcttgatgccactcgtttgagtcttccattcgctcttaacgacgcg
+tacatccctctctcctactcttacctatatcctattactggttaacctacatctccggga
+aagacgtaggtaaagtggtccacgattgtattcacttataacacctagtagtactatgtg
+ttgctgagagtgaggacacacttactctacgagttcaagtccatatggacattacacttt
+ttcagcatctaggtgtcatgatgtattaacagccgttaggggctatttgattttatcgat
+tgtcggcgtgtgtattttcaacaactaggtgctacaattcgtgaataggcatgaaaattc
+aagattgcagttcctatcttgtataatctttcctttggacgagttgtaccatttcaacta
+acctgcaagtggggggtcatccatatgaagatttgccaaatacctggagaccctgaaaag
+tttatccagattaataataacaaacaaacctaagcgaagaacgtcagctttaataaacta
+tcactatcatagaaattcctgttaattgttcttccaaacgttgaatagactatcacgggt
+aatagattgaacacggagaacgtttatccggcttgtaaaatatcgtcgaatctgctgata
+actcaattatattcgatggagaattcatatctaccgcttagcttttaaaaattaagtcag
+attattccgccacaatgagaaggcgcgagtgcactaatcaaatcacttaggattattacg
+gacgtctgcattacaatgctttggggtagggttatacaagcatatgattctttaggtctc
+ttgatcgggcgtttaccaccgtagcttaatgttggcatatccgtgatcctaatattctgt
+tgtcagcgtgtgtataggaatgcacaacgcaaatctttaagctgacctgttcatgaaaga
+caggagacacgaggcaccacctcaattctatgcaaaactctaacatagcgtggcactatg
+agtacgtgtaacgacaaggtctcatactcgatcctaagataattctcgtctggaaggttt
+taatctttaactaagagtagaacttagtttattgacttttacaattaggatacggttcgc
+gactctaccacagggcatcatacctggagctctgctatctcgtgaccaaagtggcagcac
+acatagggtcgggtcctgcatctactgagcaatccctttaagcattcctagtttgagagc
+catttagatattgctgtttaaaccgattaatggtttctattattataaagtgtaacgctc
+ccattcgggacattgaaaattagcaataagacaatgtatgatattcggcgagtctcaaca
+acattatggtctaccatgggacaaggggttgatatgatgaatccacaaaaaatagtcaaa
+cacccatggttcgttaagtgagggtatccaggtgttataaggacgatctagaagtattca
+ggtacacggtgttcagacatgctctaattgtcaggttgtttataatttaacgtatcgctc
+tctattctaaataatataaaattaaccgctcgtagggatgctttccagtaaaagatacac
+tatcattaaggttatgcaaatgtggcgatttgatttgaatcttagtacattcttaaactt
+aaatacgtattatttaaagtaaatatattatctaaaccgcttttgtctatccacatttcg
+tcgaatcacgacctcgttaatgcgacaatttacgaccctctttcatctaaagcgatcatc
+tatttcttctgattgatgtaatactgacccttactccgtacatacaaatgatggtaagca
+agaatgactgacgctcctgtcacctttcgtggcaatcaactggcgctggtactgaagtag
+cttgaaagggatatggatgtgtatgccaggcttcattttgacaatttttctgtcctgctc
+agtgttgtctgaagtcgtatcgtacacaataatgatgactctcattgtagatccaatcac
+gctttcctacgctaatgaaagttctagatagtgtaggtgttagacagaggttagcgccta
+catccttacacacacagtgttgaacggcaagcataatcgagtatcaatagctgtatgtat
+ttgtttggaatatcatatttctcccgcctttgaacaatgatgccaaaatgtcctgcccta
+gagttatgataaaataactgctgccctgtaacttaagtttacaaaccgatattcaatcgt
+tgtgtcctatgaaaatatttatatttgcaccaagaaaatcatctgtgcgatgaacaaaac
+acagtgatttataaatacaaagagtacatttagttaccggattgcggcttgacatttatt
+ttacagaattttatcggcaaaacacttcatatgaactatcgcttcacgataagtctatga
+tagactagcattcgtagagaacaggaagagcaatcattatatatgaagtgttacagtggg
+tactacatatgagatcattaggtctatatccggccttcctcataagaccttggaaatatc
+ttacatcagagatatcaaaggaagtatgggcgaacccagaaaaagccccaaagaatagta
+attcatcggacgtaatagtctggttttaactaggggttattgatatttaagctaaaagag
+ttccctgaacactcgaaatgtataatctatcccaactaaaaaagtatacctctaattcag
+aaatgtcattgagattagactgatgtcaatacgctaggaggtaagacaagtagaagtttt
+tgatttaggaattgaaatgtaatacctccatcttaagttctatattttaaagttttatgc
+ggacttcgagtaagtgcacaaatgatggcataagtgcccagttacatgtttgcggccccg
+tatgagtaatgatctgtttatcaatctctagctactatcccacgaatgcactgatgccag
+tcatggcgcttacattagtcgacagaaatccgacgatacctatcacgcgtgaactgttct
+ggttcttattcaattcgaagtgatctcagatacattacggccatgcttgcccttcatgtc
+tgctgagcagttttgttataggctgaatctcctctaagcgaaattgataggatttttggt
+ggtcgatttagtctgtacctgcttattaagattcaaaatgacctacttcttacgccgaaa
+tgatagggatcggctgaggaggataaatatacgctggtgcctggtatttatccagaacaa
+gttgcctgtgtatcagatgaactctaatctccgagataaaaaacaggtacgtaaaataaa
+ggccgcaaagggttacatctcaggatcgtggcgtatagtccaccattagttctgacttac
+ttaatatagactgaccgagattgtagtatgtggatccaagcttgccatgtaaaacatgtc
+ggttagcaaaacgtataggagcatgatcaaagaagagttaattaatagtactgcactata
+attgtcggcggagtaccatgagctgttgcccaattcgatgtttattaacagcacgcataa
+aaaatccagacttttcaattagaattaactataaatggtccgcgaaccttaaatgatcgg
+aaggacgggatctgccgttgtatagaccccaactctatctaatttttataacacctctgt
+aatcaacaaatcttattatgccatcattatgtcattcgccaagtaagtccagttcgagat
+tctctggaccgtgcaatagtattgtcaaattatggtaatggaatccttcttctaacaccc
+ttagaaaagccacgagaattgacaagttgggcgtgcttgtccaggagcaacataagtgcc
+gtttctttttacgatgatagggattcttaaagcttttctctattctagatcccagttgcc
+atcatcaatatctcaattgatgctcattatatagttcttatttagtatgtccagatgtca
+ctgaagatcctgcctagaaccgatattctcgacaggatcatcagttcgacggggcaaacg
+cacctatgcacatccatcttgaccgtgaaacgaaaggaaagagtcagtaccgacccaatg
+tggaaaaaaactcctgtccacgatatgtaggcaagttttactgcctttaattagtagtcg
+attagtgtagtttgatattatctaccttatagaatgtaaacagtaacccggccttaatgg
+tttggcaggattctttgtaaaagttaataatgttcataaactttatcagaaaacctgaag
+tagtccgcctttcgcctgcgtaacgttgcagattaattcgttttacggagtggcttgcgt
+cttgttgtccgagtacacatattgctcctctcccccactcttctaggaaaatcaattatg
+ctaacctgcagaccttcttctttactatctttaatgcatgcccagtatgttcatagggta
+gacttgctatctattttgtataatctacgaatgatgcttggggcgcgacttttaacaatt
+aagccgttgggtataatttgagagggtgccacgatagtaagagatttccggcgtgagtaa
+ggaaaatgataataggattaagcaggcgtaatagctcaccctcctcagttctccaaccct
+gaaccggctaagtatgactgtgcagtattaattttgaatacatattgcagcccctaggat
+acattatagatgtctctttcttacccaaactcgcccgcaccaagaaagaatgtggattcg
+attgaggttaaattagccggaattacagacacagattcttgtttacaattgtgggaagaa
+aaccacctcaaacgttgaaacctacattcacaaatggattacgttggggatgagaatcga
+ttccggtcaaaaatcatgcccggagcaataaccaagaattcacagaggattaatacactt
+ctccatgaagataggactgcttgcactatccttatctttgtgtcttccttcaagcaccaa
+tcgtttggggacaaccacaattatgccaagaaataacggaaggtgttccaaatctatgag
+tccgcggtttcatcgcaacgtttcactgtgggtatcatgactttggactttagatttggg
+tattctagagactgtagaaagactgcaacaacaagacattcacagggcgaaacctaggaa
+aggggaccgcacgttgtgctagggatgtttccttaggaatccatacatgtaagaaagaat
+caaccgtaattatagtgttttcggccccttgaattacgtgcatgcctttgctaaaagacc
+tctgggaaatagattgaatattctggacagcagcgaatcctgattatatctcaagcgaat
+atatgacccgcaagaaggatttatactagaataagtctaagaaagggcattgggtcactt
+cttccactaacacacttttatcagttttataccttgagagtcccatgcatttttatatat
+atttaactttcgttgcgtaaaactttaaatatgatccgtgctctatctctaatctgaaca
+acggtatcacgtcgaacaaatctagtggctacgaatcgcgtcgctaagaacggtttcttc
+tgctggcgttagctacgtatcttctatgctaaaaatgtatagccccgcattagcagcaaa
+accgggagaatcaaatacacatccgatgaaatcgtaacaaagataaaacaacgcgatttc
+tatgtttgccaaagtgattaagttgtatcgtaggggtcagcgctgatgtcttttcagttt
+gggttttggatttaccagtcttttagtttcggtactatttgatcgggacattcgtccaaa
+catgatggctcattcgttctttttttcaattttaatcaaaaccttgtatttacctgatac
+attaaactgagcatcgcatggaggtggagattcccatatatgtaatcatttgatatccta
+ttccattctttttagttataaataaacgctccactgcacaatgggagtaggacttcacca
+ataattagcatctactgtaaacaagcgccgtaacgaaatgattactgattgagaaaaata
+ggtctcaacaacttttgacagatatgtatccgatacccaagcgttgctaattgcgcaaaa
+gtaagtagaattacggtcgtattacttgttgccaaatggttattactccaatgggctatt
+ctaatccgatggatacgtaggagagagtgtacctacaccgaaactcgtagtgggcttagt
+ggctacgtagaagctgttcgggtcagttacagcgtgcgaccttgtaaaatcgatcacggt
+gatgaattattgttattgtttaaaagaagtcccctgaatagcccttagataatacgaaaa
+tttgttatgtccagtcgctcgtatatcaaaagattcggttaagttcgcagagttttgcca
+agtttacaggtgatttactaacacttgggagggtacgtacaaccatcacctggttagcag
+agaatgaattatacggtcatgtcgcgaagggcaagtgtgtgagtattgaccgagttatta
+aacgtaaatgcaggcatttacgtcataggacatcgagtttgtcctttgcgaaatgttaaa
+tttatggttttttccgttgagtgataatagctgcaacatgaagatagtaaaactgaggtt
+aaactttcaccatattaaattatatgttcaattacgcgatgtacaaactaatgttaatca
+gatttaggagcgcgcttaatatgggtccctatcccgactttgtacgagattttgataaaa
+aatagtattgtaaattcatttgatggcgtagaaccgggcaaaaccttgaaaaaggacaca
+tttaggatgctatttccctaagaaagcggaaaatcctggctcaatatttataatagtaat
+ggttaagattgtggcccaatcgctgagtacccgtcttacgctttttccaacacataatcg
+acgagaatgtatttaaatgtttgagacttacgttttccgcgtacttattattaaagtcat
+tggagagggtgtcgtctgggtgtagttttctcatctgctcaggagctaaaaatgtaaatc
+tattggttgtttctaattctgtcgtccgtgtaggctatttaatttttatggtacacttga
+atatgtttagccataatgtagccaatactacaatatcagatacttgtatacgacctatag
+acttttgccgaccgctcgtagagtgatttagaaagatgttcggatagcacagcaatcgtt
+tgcgaatgtaagcatgcgaagcgagtatttaactgttgactattttgctatatgttactc
+tgaatgttgttttttttaccagaatgtgttataatgatcaaccatgcacgttcctactaa
+tcatataaattttgttacgtaagcttttctatgatagtggtctaaagactacccttgcat
+actttaagattaagacatgcactttaggaggaactcacacgttttgagctgttctagccc
+acctataagccattcgtccgcaatcccataactacaatagtcggcaatcttttattaccc
+agaactaacgtttttatttcccggtacgtatcacattaatcttaatttaatgcgtgagag
+taacgatgaacgaaagttatttatgtttaagccgcttcttgagaatacagattactgtta
+gaatgaaggcatcataactagaacaccaacgcgcacctcgcacattactctaatagtagc
+tttattcagtttaatatagacagtatttgaaccaggcgctaatgttaaggcccccttcga
+aaaccttgttatgttattccatgtggtcggaggatttgcggggcgatagcgctgggcggg
+gatcaacaatttcgttcatgcgagcgcccccataaccagtaggtacagttcggaaaagaa
+aaccccacgcactcgctagaagtgttacaatcacatcacttcgtaccgaagggactactg
+tattccgtcttggggatgtaacagactgattacagtcttatgatgaagcctcattcatct
+aaaattagttgatttattccacggatactatcacactcctatagaaagagttaccaccgt
+gggaagctagatataataaataaaagacatacaatattagtatggctcatgatctacact
+tactcggatctctctttttttataaccagtagatcgcattacacgtattgttgttccgca
+tcaggccctaggggctcaaacttccatggtggataactaaaacgtccgtcactaaacgaa
+gatattaatagatgaaatacacgggtttacttgatttctgttcagtcattcacgggaaat
+cctaggagtctttcataacggcggtcttagtaggaatgtagtcaagctctgtagaggtct
+cgacggaattggtatttcctggcatcacaatttacctagtattggagatcacttaaaata
+atgttgagataataatcaggatatttctagtatgtgacaaacctctatttagtgattgtg
+attttcaattaaacaagacgtaggggtcaaattaacgactacatgttggaaagaaggccg
+aattgtaatatctaactcatgtactaagaagaagtgctttcgtttaaggctttctgtcta
+acattctaacgtcaattcctatgtaatactactgtaaccaagttattactcggctgcgta
+gataaagtctcatgtaaatgacggtttatctgttacttttgggtttcaacctagctagga
+cgccggtactaattacgacacctgcgtatagtgcagggtgttcaatgtgcctttttatgt
+ccggattataaccatccctctcccacttggaatatcaccgggttcttaatgacttagttc
+gtcttccttattttccgggtaagatcgctgtggaccggacccattttgatctagtctaaa
+aaggtatatagcgtttcgtctggcccgcttacgttcactgaaacttagattaatcaatgc
+actgcactggattaacaagaacatgttatagtgtactgacacatgttagactaagaggtc
+tgttcgggttagccgacttatatgtttaaccgattttgacaactgggttgagagataaca
+atgaagagtgaggactgtagaagatcttaaaactgtaccatagtgctcaattcgctaatg
+gcttgaattatttaattgttctaaccctggcgtcgaatttttttggttcgaaaatactta
+gcacagcgtattgttcaacgagatgcacaactgtaccgttagaaagcggcttaatgacaa
+ggcagtattgtgactattgacagggaatcctaaaaagctactcgaattggtatatggaag
+aggtatgtactgagaggtcgcgcctattagtcaaattctgccaaagaagagtcaaaagct
+taactagtttgatggtatgaggtttaatgctaggtggtctataccaccaaaaagtatatg
+ggatatcccagaatttatcgactttcaatcgtctaccgtcacgacgtacactaggcagcc
+ctaatccaaaacttttgaggatgagtactgccactattatactgtaccatttgtaactta
+cattttatatcttcaaagaggtagatattgtcggccattactgtcacttacactaagggt
+agcttgattactgatacctctcatggtaaaaagtaatttaagaacctatttttttacata
+acctctgctactaccgttagtgttttagtcggttcaagtcacaaaatccctgtagcgcac
+ccctataagcagaaggaaaccttaatgcggataaaaacttttgccggaaccgttaatcct
+atgagaataccactcttggaatcggtcctttaggctgaggatatagaacgaggggaacgc
+atcaatctaggttaggtgagagaactttgtatcaaaacgcaagtaccatatgccgtcctc
+agtaaattgccaaatgcagaaatcttacactcttttcttaactaagtatgagagcaacct
+cactcctgaacagcttgttacctaacgagaagaggctttaagtagcctggagcctcaacc
+ggatatccggatttgactctcatccacttacatgatgattacggtcattacatctcatga
+ttttctgagtgccctatagactgggaatttaatctaccctgtttctatttgttaacaagg
+agaaccactggtcaagatgacgcgcttccatttatgccaccataagtaagttctcggaac
+ccttacatgattggcctaccaacctatatatgtgaccaatgtacggtacatagagtgtgg
+cctatcatattcaggtcatcgagctcagtatttaaagattatatggtcgctgggggtatt
+cagtgcgcgatggaagactaacattggaaatcaacggaattgacaacacgctcactttaa
+taacctatctcaggataagtttaatgtaattagacggaactttctctaactccgtgtact
+aactctttgaaaataatgtgggtatttttatttcatctagatttgtctgtatcgaaagaa
+agtattggtccaaataatcctcagtaaaatcaagtcataaatataaaatttagatcttag
+gacagaggaaagtgctttcccgagcataggatctggcctacgccagtagttcatgcttgt
+gttaaaagttgttactgtttatagtccgtactcagggtagtgttcgatactcagcgggga
+actgacatattacactaaggaatcaaggcccttcgtatgggtcatgtttatatatttaat
+tacttacgctatttgatcgagaatagctatagtaacgtcgtaagaatgcaggatgcgatt
+cgagtttgtaaattcacagatactgtgtatcatattattatagatgttaaggcatagaat
+tattggtattgatgtacaaaaaattatgggtgggcagtaccgataggcattacgagcagt
+gcagcttggaagaactggatgtatcctataactagtaagagccttaaaggtactacatac
+ccagggatgttaccatcattaatttggccatcttcaatcttcgcaatgcatactttcttc
+tacaagatgccttttagaagacaaaataagtgtcaacaataacgctgtaacttaactctg
+ttgtacgtggaatcaagtctcactaaagcaactaacattccgacatgcaaacgcaggact
+actagattattaaattcgccagcccgcctcgtttaatataacatcataaaaattctaagt
+aatatctcacacactaatccgccatcgtccatagcatcagtcacctgtcttacacaaaca
+catgtttaatcgatgttgttatgccaagctagtttcgcgaccatgtaactaattgtggaa
+agctgctaccttgaacgacatcaaccatcctacctttgtacaacagaccaacatctctgt
+actggtaaatagatctgaaaagttataaatataactgttttcacattgatagaaaaacag
+ctatgtgctatttgtatatactataataaattaagcgaaacatggagattaaaacagtgt
+tttctcatcctccacctcttgttctgctaatttataattcttgatgccactcgtgtgagt
+cgtccattcgatcgtaaagaacccgacataaatagatacgacgctgaacgagatcctatt
+tctcctgaaaattattagcacggtaactcctagggatagtggtactagttggtatgaacg
+tataaaaacttgtactactttctcgggatgtgagggagcaaactattactcgaccagtgc
+aacgcattatcgacagtaaaagttttcagctgatacctgtctggatggattatatgcagg
+taggcgagagtggattgtagcgatgctcggcgggggtattttaaaaatctaggtgataaa
+agtcctgtttagccaggaaaagtcatcattgcactgcatatcgtcgattagctgtcattt
+cgtccactggtaccagttcaacgtacatcaaagtccgggcgcatccatatcaagttttgc
+aatagtactccagaccatgaaatggttatccagattaataataacttaatatactttcac
+tacatactcagcgggtattaaatttcactttatgtcaaaggactcttatgtggtcttcaa
+aaaggtctagagtctatcacgcctaattgtgtgaaaaccgagtaacttgatcagccttgt
+aaaatatagtagaatatgatgttaaatcatttatattccagggagattgaatagcttacg
+attagctggtataatttaactcacatgattaagcaaatatctgtaggaccgagggaaaga
+ataaaataaagtaccatgagttcggaacgctgcattacatggcgttgggctagcctgata
+caagaagatgagtatggagctctcttcatcgggacgtgacaaccctagcgtaatcttggc
+agatcccggagcagatgattatcgtctaacactgtctttaccaatgcacaacgcatagat
+ttaacctgaactgttctggattcactcctgactacagcctacaactcatttctatgcata
+actcttaaagacagtcgcaatatcagtacctctatacacatcggatcagactagatcata
+agataagtctcctctggatccttgtattctgttaagtacactacaaatttgtttagtgtc
+tgggacaattacgataagggtcgcgactagaccacagggcatatgacctccaccgctcct
+agcgagtctccaatctgcaagcactcatacgctaggggcatgaatcgactgtcaatgcac
+tgtaagatttacgagggtgagacccatttagatatgcctcgtttaaccgttttaggcttg
+ataggatgagtttgtcgatccatcaaattcccgacattcatattgtccaataagtatatc
+tagcttattcggactcgctaaactaaattatggtataaatgccgtcaaccggtgcatttg
+ttcaatcaacaaattatagtcaatctcccatggggccttatggcagcgtatacagctggt
+ataacgaccatatacaactatgaacggactagctgtgaactaagcagattattggatcct
+tgtgtataattttaagtttcgatctatatgctatagtatagaaaatgttccgatcgtacg
+cttcctttacagttaaacagtctatatcatgaagcttatccaaagctggacatttgatgg
+caatcttacttaattatgaaacttaattacctattattgaaagtatttatatgatcgaat
+aagatttgctctataaacaggtcgtccattcacgacctagtgattgcgtaaattgaccaa
+cctaggtaatctaaagcctgcatctatttcttatcattcatgttatactgacccgttctc
+agtacttaaaaatgatcgtaagcaagaatcactcacgctcatgtcacatttagtcgaaat
+aaactgccgatgggaaggaagttccgtcattgcgatatcgatgtctatcccacgcgtcat
+tttcaaattggttatctacggataactgtgcgatgaactactataggtcaaaattatctt
+caatctcattctagatcatataaagatgtccttcgcgattgatacgtctacagtgtgttg
+gtgttacacagagggtagcgactacttacttactaactctctcttgatccgcaagcataa
+gccaggttaaagtgctctatctttttctgtggattataatagttataccgccttgcatct
+aggtgcccattaggtaatgccctagtgttttcataaatttactcctgccatctaacgtta
+ctttaatttcccagattcaataggtctctcatttgaaaattgttatatgtcaacaaagaa
+tataatagctgagtggaacaatacactgtgagggagtaatacatactctaaattttcttt
+acggtttgcgcctgcacagttttttttatctatgtgatccgcataaaaagtaatttcaac
+gttccattcaagttaagtcttggtgacactagcattaggagagatcaccaagaccattat
+ttatttagctagggtttaagtcggttagaaatatcagataatgaggtctttatccggcct
+tacgcagtagaaattggaaatttcgtaaagcactgagttcaatggaagtatggccgaacc
+cacataatgcacaaatcaagtcgatttcttccgtccttttagtctcctgggaactacggg
+ttattcatagttaagctaaatcagttaacggaactagacaaatgtataatagttcccaaa
+tatatatctataaatcttatgcagttagggaatgcagatttgaatcatggcaatacgcta
+gctcggaactcaactacaagtgttggatgtacgaattcaaaggtattacatccttatgat
+gttcttttttggatacttttatgacgacttccacgaagtgaaattatgttcgaatatctg
+aacagttacttggttgagcccaaggatgacgaatgttctgtttataattctcgtcataat
+ataaatacaagcatatgaggccagtcatggagctttcatttggactaacatttccgtaga
+gtcatatcacgcctgtaatctgatccgtctttttctattcgaagtgttatcagatacatg
+acgcccttgcgtgacattcatggctcctgacatcgggtcttttaggctgaatctaatcta
+acccaatttgtttggattgtgggtcctccattttgtctgttaatgcttattaagattaaa
+aatgtactacgtatttagacctaatgattgcgatacgctgtggaccattaatataagctg
+cgccaggggatttttccagatcatctggcctgtgtatatgttcaaatctaatagccgaga
+gaaattactccgacggaaaataaaggcagataagcgtttcagagcaccatcgtggcgttt
+agtcaacctttagttcggaatttattaatatacaatctcactctttggacgagctcctta
+aaagatgcccttgtatatcatgtcccgtacctaaaagtataccagcatcatcaaagaaca
+gttaaggaatacgactgctctataattgtccgaggagtaccttctcatctgccaatagtc
+gttgggttggaaaacaacgcattaatatgccacacttgtcaattagaagtttctataaag
+gggacgagtaactgatttgagacctagcacggcagaggacgttcgtgtgacaacatctct
+ttataagtttgagataaaatcgctaatctacaatgattatttgccaatcattatcgaatg
+cgcaaagtatctcctgttcgtgattctagcctaaggccattactatggtcaaattatgct
+aatcgaagcagtcttctaacacccttagaaaagcaaacactattgaatactgccgccgca
+ttcgccagcaccaacataactgcacgtgcttttttccatgattggcattatgaaagattt
+gatctatgattcttaccagttgcaatattcaatttagcatgtgttcctaattattgtgtt
+attatggtctatctcatcatgtaaatgaagatcatgacgtcaacacagattctagtcagg
+atcatcagttcctcggggaaatcgcacctaggaacagccttatgcaaccgctaaacaaag
+caatgaggatgtaccgacaaaagctcgatttaaaagcctcgaaacgagatgtacgaatcg
+tttactgccttttatgaggagtcgagtactgttggttcatatttgctacatgattgtatg
+taataacgatcccgccctttatcggttcgatcctttatggcgataagttatgaatcgtca
+gtatctttagatcaaaaactcaactagtacccagttccccggaggaacggtcatgattaa
+tgcgttttacggtctcccgtccctcttcttgtcagaggaatcagtttcatccgatcccac
+tcgatgattggtatagctatttgccgaaaagccacaacgtattcggtactatcttgtttg
+attcccctgtatcttaattcgcgacacttgatatcttttgtgtttaatcgacgaatcatc
+ctgggggcgacacttgttacaattatccagttgcgtttaatggctgtgggtcacaagatt
+gttagacaggtcccgcgtgtcgtaggaaattgataattggagtttgcaggacgaatagct
+cacccgcctaagtgatccaaccctcatcaggataactatcactgggcagtattatttttg
+atttcatatgccaccccctaggagactgtagtcatgtatctttcttacccaatctagccc
+gaaacaagaaagaatgtcgattccagtcaccttttattagaccgatttacacacaaagtg
+tcttggtttaaaggctggcatgaatacatactcaaaagttgaaaacgacttgctctattc
+gattaccttcgcgatctcaatcgattacgctaaattttaatgcccgctgaaatatccaac
+atttaaaacaggattaattctctgatccatgaacttaggactcattgcacgtgacttatc
+tttctctcttaattcatgctccaatacggtgggctaaaccacttttatcacatgaatgta
+cgcaacgtgttaataagctatgagtacgcgggggcagcgaaacgggtcaatctgggtatc
+ttctattgggacggtacatttcggttttatagactatgtagttacacggcatcaacatgt
+aattaaaacggcgtaacctaggaaagccgaacgcaccttgggattgccatgtgtccggag
+gattacatacatctaagaaacattctaaactatgtatagtcgtttacgacccttgtagta
+cgtgcatcccttggcgaaaagtactctgggtattagagtgtatattatcgacagcaccga
+atcctcattttatagcttgacaatttatgacccgaaagaaccttttataagtctataagt
+atatctaacgcaattgcggcactgagtccactaactatctttgagcagtgttatacagtg
+agacgccatggaaggggtttatatattttactgtcgttccctaaaaagttaattatcaga
+cctgcgcgatctcgtagatgaacaacgcgatctagtcgaaaaatgcttgtggctaccatt
+ccagtcgagatcaaccgtttctgcggatcgcgttacattccttgcttatttgcgataaat
+cgatacaaccccattaccagaaaaacccggagaatcaattactctgcagatcttatacta
+aaaaagagattacaacccctgttctatgtgtcccaaagtgagtaacgtggagcgttgggg
+taagagcggagcgattttaactttcgcttttccattttccagtattgtactttacgttat
+atttgagcggcacattcgtcaaaacatgatccatatggactgaggtgtttaaatgttaat
+caaataattgtattttcagctgactttaaaatctgcagccattggaggtggagattccaa
+tagatgtaagcaggtgatatcatatgcaattcttgtgacttattaagataccagacacgg
+cacaatcgcagtagcacgtaaacaataatgacaatcgacggttaaattccgaacgtaaga
+tatgtttacggatgcactaaaataggtagcaacaacgtttctctgagatgtataagttac
+caaacactggagaattccgctaaactaaggacaatttccgtcgtattaattgttgacaaa
+tggttagtaatacattcgcagtggataatccgttgcatacctagcactgagtgtaaataa
+aaccaatcgactactggcatttcgggctaacgactagatgttagcctatgtgaaagcctc
+acacatgcttattgccttcacggtgagcaatgtttcttattcgttattagaagtcacctg
+tagagacagtagagatgacctaaatttggtttgtccagtcccgaggtgatctaatgatta
+ggttaacttagaacagtggtcaattggttaaagctgatttacgaacacttccgaggggtc
+gtaaaacattaaactggtgagaacagtatgatgtattcggtcatctagacaaccccatcg
+ctgggagtttggacagtgttatgattcgtaaatccaccatgtgtccgaattcgaaatcct
+gttgctccggggagatagggttaatttaggcttttttacggtgtggcatattagctcaaa
+catcaacattcttaaaatcagcgtaaacggtcaccagttgatatttgttctgctaggaag
+cgatgtacaaaataagcttaataagatttaggtccgaccttaatttcggtccatagcacc
+tctttctaagtgttttgcttaaataattgtattgttattgattttctgcgagttgaacac
+ggaaaataagtcaaaaaggacacttttaggttcatatgtaccgatgaatgcgcaatagaa
+tcgagaaatttttagattagtaatcgtgatgattgtggccaaatcccgcactaaacggct
+ttcgctgtttccaaaaaattttagtccactaggtatttaaatgttggacactgaacgtgg
+aagccgtcgtattatgaaactaatggcagaggggctcctctgcgtgtactttgagcagat
+gctatcgtcagaaaaaggtaaatcttttggttctttataattctggcgtccgtgtagcct
+agtgaatgtgtttggttcaagtgaatttgtttagccagaatggaccaattacgtcattag
+ctgttacgtctatacgaaatatagactgtggacgacccatcgtagagtcatgtagttaca
+tgtgaccttagaacaccaatcgtgtgcgattgtaagcaggacaacacagtattgtactgg
+tcaattggttcatagatctgactatgaatcttcgtttttgtacaacaatctcggtgaagc
+ttcaaaaagcctccttcctaataatcagttaatttttcgtaaggttcctgttcgaggtta
+gtcgtataaagacgaaacggccttaatgtaacattaactattccactgtaggtggatcta
+acaaggttggacatgtgctaccaataagataagaatttcgtccgcaatacaatatctact
+tttgtagcctatcttggattaacaacaacttacgttggtatttcaccggacgtatcaaat
+gattctgattttaatgactgagagtaaacatcaacgaatcttatgtatctttaagccgct
+gcttgacaagtcacattactgttagaatgaacgcttcattactacaaaacctaccaccaa
+ctcccacattaatattatactagatgtttgaagtttatttgacaaaggttttcaaaaagc
+acagaatcgttacgaacacgtacattaaattgttagggtattaattgtggtcggtgcatt
+tccggccccatagcgctccgcggggagaaactatggccttcatgacagcccccccataac
+atctaggtaatggtcggataactataaacaaccctctccagagaactgtgaaaataaaat
+ctcttagtacacaagcgtatactggtttaagtcttgcccatcttaaagactcttttcact
+attttcttgatgcctcattcttctaatattaggtgattttttaatccgagaatataaaaa
+gacgatagaaagtgttaaaacacggcgtagcgacatattttaaagaaatgaaatactttt
+tgactatccctcatgatctaaacttacgcggagctatctttttgtataacatgtacagag
+aattaatccgatgcttcttccgattaaggacatagcgccgaaaacgtcatggcggcttat
+cgatatcgtaacgcactataccaagtgattaagtgatcaatgaatacgggtttcgggatt
+tctgttaagtcatgcacggcaaatacttggagtcttgaataacgccgcgcgtagtacgaa
+ggttctcaagctcgcgtgacgtatagaccgtattgctatttcctgccttctcaattgtcc
+gaggattgctgataacttaaaataaggttgagtttttaataacgatttgtcgagtttggg
+aaaatcctcgtttgtgtgtttgtcattttcaagttatcaagaactacgggtataatttac
+gacgtaatgttggtttgatgcccgattgcgaatatcgtacgaatggtatttgtacaactg
+ctttcctttatcgattgctcgagaacattataaagtctattactatggattaagactgta
+tacaagtgtttaagcggagcccgtgataatctataaggttttggtacctttatctgttac
+ttttgccttgaaacatacatacgtacacgggaatatttacctaaacgccgtatagtccag
+cctcgtatttgggccgtgttttgtcagcattttaaactgaaagcgcccacttgcattata
+acccggtgcggaatctcttagtgactcgtcaggagtttacgcctttgagacctctcgaca
+ggacccattttgatctagtcgttataggtagagtgcctttcctatcgcaccattaccttc
+tagcaaacttagagtattcaatgaaatcatatcctgtttatactaaatgttataggctaa
+tgacacagctgacactaagaggtctcttcgggttacccgaatgagttgtttatacgatgt
+tgacaactcgggggagtcatttcaatgaagactgaggactcttgatcagattaaaacgct
+taatgactgataatttagattatgccgtgtattatttaagtgggcgaaccctcccctaga
+atgggtttcctgagaaaagtcttagaacacagtattctgaatccagatgcaaatcgctaa
+cgttagtaagcggctgtagctcttggcagtttggtcaatagtcaatcgcaatccgtttaa
+ccgtctactattcctagagcgaagagctatgttctgacacgtccccaatattaggcaaag
+gctccaaaagaacagtcaattgattaactacgggcttggtttctccgtgaatccttgcgc
+cgctataccacataaaaggatagcggtgataccacaagtttgcgacgttaaagcgtcgac
+cctcaacaagtacactagcaaccccttagcaattaattttgtccatcactactgccaaga
+gttgactggaccagttggaaatgacatttgatatattaatagagctacatattgtaccac
+tttactgtcacttacactaaccctagcgtgattactcatacatatattcgtaaattctaa
+gttatgatactagttttgtaaatttaatcggcgaagacacgttctcttgtacgagcttca
+actaaatatttcactgtagccaaccactttaaccagaaggataccttaatgccgatataa
+tattgtccaggaaacgttaatactttcacaagacaaagcttggaagaggtactttacgat
+cacctgatagatcgaccggaacgattctatataggtttggtctgagaaatttgtagctaa
+aaccatgttccataggaactcctctgtaatgggcaaaatgcagatagcgttcaatcgttg
+cttaactatctatcacagcatcctaactcctcaacagcttctttcctaaagacatcagca
+ggtaagttgacggcacccgataacccagagcacgattggaatctaatactctgtatggat
+cattacgctaagtaaatataatgattttctgactcaaagttacactgcgaattttatatt
+aactggttctatttgttaaataccacaacctctcgtcaacaggtcgcgatgcaagtgatc
+caaaaatatctaacttataccaaccattacttctggcgcagaaaaacatagatatctgaa
+caatcgaccgttaagactgtctcgccgatcttaggaacctaatactgctcagtagttatt
+gtttatttgggccatccccggattatgtcagccatggaacactaaaagtcctaatctaac
+ctatggacaaaaagctcacttttataaaattgctcaccttatgttgattgttatttgtcc
+gaaatgtctataactcagtgtactatctattggaaaattatggccggagttttattgaat
+atacttttgtatgttgagaaagaatgttgtcgtaataattatcagctggaaaatcatcta
+atatatattatattgagatattacgacagacctaagtgctttcccgtcatgagcagatgg
+actaacactcttggtaatccttctcgttttagttggtaatgtttagtctaagtaatatcc
+cgactcttacttactcagagcggaaatgactttttaaactaacgtttaaaggcacttagt
+atgcgtcagggttatttttttaattacgtacccttgtgcagagagtttagctattcgatc
+ctacttagtatgaaccatgagagtacaggttggtaattcacagagaaggtcgagaagatt
+atttttgatgtttaccaatactatgaggcgtattcatcgaaataattttatggctgcgca
+cttcacatacgcaggaagaccactgcagcttgctagatctggatgtatcattgtacttct
+aagagcctgaaaggtaatacattcccagcgagcgtaacagattgtatggggacatattca
+atcttagcaatgcattcgttcttcgaaatcaggcatttttgatgtcataagttctgtcaa
+ctataaccctggaactttaatctgttgttcgtcgaatcaaggatcaagaaagcttctaaa
+aggcccaaagcaaaacccaccactacttcagttttaaattagaatcacaccctagggtat
+tagataataattaaatgtcttaggaagagatatcaaaagatgcagacatcctcaagtgaa
+taagtctccggtctttcacaaacacatggttaagcgatgtggttttgactagagacgttc
+gccaccatcgtaatatttctggttacctgcgaacgtgaaccaaatcttacttcatacatt
+gcttaaacagtacaacttatctcttatcctatagagatctcaaaagtttgtatttttact
+ggtttcaaattgagagaaaaactgcgttctccgatttctatattattgtttaaatgatgc
+caaacatccagtttaaaacacggtgtgatcagccgactcagattcgtatcctatgttaga
+atgagtcatcaaactacggtcacgcgtacattacagagtaaactacacgaatgaaagaga
+taagaagatgaaagagttaataggtctcctgttaattatgagaaccctaactactacgga
+ttggcctactagtgggttggaacggatataaaattcgactaagttcgcggcatgtcaggc
+tcctaaatatgaagagaactcggcatcgaattatccacagtaatagttggaacatgattc
+ctctatgcatggtgtatatccacgtacgccagtgtgcagtgtagccatgcgaccacgggc
+gttgtgaatattcttcctcagaaaaggactgttgagcaaggaattggattctgtgaacgg
+aatatagtcgagtagatggaatttcctacactgcgaaaaggtcatagtaaatcaaacgcc
+gcgcgcagacatatcttcttggcaattagtactccactaaatcaattggttataaacttt
+tagaatatctttatataagttcactacttacgctgcgggtagtatatttaaagtgatgtc
+ttaggaatcttatggcggcggaataaacggcttgactatagataccctaattctggcata
+accctgtaacgtgtgaagcatgctttaatagacgactagatcagcttatagaatggatat
+gactgccacattgaagagattaacattagcgggtataatgttacgaacttgtttaacaaa
+atagctctaccacacacgcatagtataatataaaggtcctggagttcgctacgagcctgg
+aattgcagttcccctaccctgagtaaacaagatcagtatggacctatcttctgacccacg
+tgtaaaaactaccgttagcggccctgagaacggtgaagttgattatcggctaacactcgc
+tttaccaaggaacaaacaattgatggaacaggtaagcggctggattctatcctgaataca
+gcataataatatttgctttcaatatatagttatgacactcccaatatcactaactcttta
+caaatcggatatgaagagtgaattagagatggagccgatcgttccttgtattctggtaag
+tactcgactaatgtgtgtagtctaggggtaaaggtccttaaccgtcgagtctagaactca
+cgcattatgaaatcctccgagcatagagactctaaattcgccaagcaataagtcccgacg
+cgaaggatgagaagctcattgaactgtaacatttacgtcgggctcaccatgttacatatg
+cagcgggtaaaagtttttgcctggagtggttgagtttcgcgatacataaaaggccccact
+ttcatatggtcaaatatctatatcgtgctttggacgactcgataaactaaagtagcctag
+taatgccctaaaccgctgcatttgtgcaataaaaaatttagagtatatataacttccgga
+cgtatggctgccttgaatcctcggatatcgtccttatacaacgatgaacggtatagctcg
+gaactatgcagattaggcgatccttgggttgaatttttagtttccatagatatgagttag
+ttttgatatggttaccatacgtccctgcattgaaacttaatctgtatattgattgatcct
+tagcaatagcggcacatttctgggcaatatgacttaattaggttacggtttttactatga
+tggatacgttttatatgatagaataacagttgctatttaaacaggtactacattcaacta
+atactgtttcactattgtgtccaacatagggaatatattgcctgaatagatgtattatca
+ggcatcttttacgctccaggtagaactaattaaaaatgatccttagaaactttcaagcaa
+cataagctaaaagttacgccaattataagccacatcggtaggatcttcaggcattcccat
+atccttctctatcaatcccgtctgttgctaattggttatctaagcatatcgcggcgagca
+tctacgataggtataaagttgctgctatctaattcgtcataatatatacatggaattaca
+gattcatacgtcttcagtctcgtggtgtttctaagagcggacccaagaattacgtaatat
+ctctctcgtgttacccaagaagttgacacgtgattgtcagctatctttttctggcgatgt
+taatagttataaacaattgcatatagctgcaaattagctaatcaaatactcgtttcttaa
+atgttatcagcaaagctttaggttctgtaatttcactgtgtaaagagggcgctaagttca
+aaattggtttttggcaacaaacaatttaatagcgcagtgcaaaaataatatctcagggtg
+taattatttctctaattggtctttacggttggaccaggcaatgggttttttatctatgtg
+ataccaattaaaagtaatttcaaagtgacattaaacttaagtattgctgtcaagaccatt
+acgacacttcaccaacacatttatgtattgtgctacgcggtatggcccgtagtaatttct
+gatattgaccgcgttatcagcaagtacgctgtacaaatgccaaatttagtaaagctctgt
+gtgcattccaaggtgcccacatcacacattatcaacatatcatgtcgttgtattacgtcc
+ttttactagcctgggaaataccggtgattcagagtgaacataaatctctgaaagctacta
+gacaaagctagtatagttaaaatatatatttcttttaatattaggatctttgcgattgca
+catttcaagcatcgcattaacctacctccgtactcttctacaacggttgcatgtacgatt
+tctatgcgatgaaatacttatgttcttagtttggggttactttgttcacctagtcctcga
+acgcaaattagcttcgaatatctgaaaagtgtatgcgggcaccaaaacgatctcgattct
+taggtttataattatagtcagaagataaatacatgcatatctggacactcttccacatgt
+catgtcgactaactttgaactacagtcatatatagactgttatctgatccgtatgtgtct
+attactactcttatctgagaaaggacccaatggagtcacagtaagcgatcatgtcatcgg
+ggctttttccctgattataagattacactattgctgtgcttggggcctcctactttttct
+atcttaatcattttgtacattaaaaagctaagaagtaggtacaacttatctttcccatac
+gagctggaccattaatttaacagccgcaaggcgagttttaatgttaatctggaagggctt
+tatgttctaagcttttagcactgagaaattaatccgtaggaaattaatcccacataaccc
+ggtaagagaaccttacgccccgttactaataatgttctgcgcaatgtaggaagtgacaag
+ctcactcttgcgacgagctccttaatacaggccctgcgttatattcgaccgtacctataa
+ctagaccaccatcttaaatgtacagttatggttttcgacgcatagagtatgggaccacct
+cgaaatgctcagctgcaaattgtactgggggtggttatcaaacatttaatatgaatctat
+ggtaaagtactagtttatagatagccgaacactaaaggtttgcagaccttcctcccctga
+ggaacttcgtgtcacaaattagattgagaaggtggtgataaaatcgcgtatctacaatga
+tttggtgcaaatatttatcgattgcccaatcgttctactcgtactctttatagcctaacg
+ccttttcttggcgctaattagcctaatccaagaaggagtctaacaaaattacttaaccat
+actcttgtctattcggcccacgcatgcgcaagctcaaaaagttctcaacgggcgttttta
+cttgagtcccaggaggtaacattggatctatgagtcttaacagtggaaatatgattttta
+gattgtgttcagatttattgtcttattttggtctatctcatcagctatagctacataatg
+acgtcttaactgtttcgactaaccttcagatctgactaccccaaatacaacatagcaaaa
+gaatgatgctaacgcttaactatcctttcacgatcttaacaaaaaagctccatttaaaag
+aatcgaaaacagatctaccattcgtggaatcaatttttggacgagtactggtcgggtcgt
+gcttatttgctacaggattgtttcgtataacgttcaagcactttagcggttccatccttg
+atggcgttaactgatgatgcgtaagtttatggtgatctaaaactctactacgaaccaggt
+cccagcacgaaacgtcatctttaatgagtttttaggtctccaggcactaggctgcgaagt
+ggaatatgtgtcatcagagacaaatagatgattcctatagctttttgcagttaagccact
+aagtaggcggttctatagggtttcattcaaatcgatcgtaattcccgactctgcatagcg
+tgggtcttgtatagaccattcttcaggcccgccacaatggtttcaagtttcaacttccgt
+ttattggctgtccctcaatagagtcgttctcagggcacgactctcgttcgttattcataa
+gtccagtttgatccacgaatacagaacacgcatatctgataataaaagcttaacgataac
+tttcacgcgcatggtttatttttgatttattaggcaaccaaataccagaatgtagtcagc
+gatatgtagtaaaatttagacaaacataaaacaaagtatcgccattacagtctcctgtta
+ggagaacctttttatcaatatgtgtaggcgtgtattggcgcccttgatttaataataatt
+acggctaaacgtattgatattttccaggaactgccccatctcatgagatgaccctaaatt
+ttattcacacctcatttttaattcttttatatcacgattatttatctgagcaagcatctt
+tgcaagcattcatagtgacggtgctgtctctatgaatgcatgctaatatacggtgcgcta
+aacatattggttcaattcaatgtaagctacctcggaatttgcttgcactaagacggggaa
+gccaaaacggtaaatcgccgtatatgctagtgccaagggacttgtccgttggagtcacta
+tggagttacaagcattataaatctaaggaaatcgcagtatcagtccttaccccaaagata
+cttcgcattccctggggtacggaccatgaaatacttctttcatacatgataaacgatgga
+gactcggttaccaccctggtagttactccatcaattggagttaactaagatcgctattac
+aggctttattagccaatcatcacaagcctctttttagagattcacaagttagcaaaccaa
+agttcctttgataagtctttaacgagatctatcccaattccggctaggagtaaaatttat
+atatttgagatcggggttaaagtcacacgcaatgcaaggggtttttatatggtaatgtcc
+ttccctaattaggtaattttcagacctccgagagagagtagatcaacaacgcgttatact
+cctaaaatgcttgtcgataacatgacactacagatcatccctggatgagcatcgactttc
+attacttgattagttcagttaattcgtttcaaaccattttcaacaaaatcccccagtaga
+tatgtatatgcacatcttagactaaataacagttttcataccctgggatttgtgtcacta
+tctcaggaacgtcgagacgtcccctatcaccgcagcgagggtaactggccctgttccatt
+gtaatcgatgggacgggacgttatattgcagacccaaagtagtaataaattcagccatat
+ggacggagggggggaattgttaagaatataattcgattttcagctgaatgtaaaagctcc
+agccattcctcctccacttgacattagttcgaagaaggtctgagaattggaattgcttgt
+gacgttttttgtttccagacaaggaaatagcccagtaccaagtataatattatgacaata
+gaagcttaaattcacaacgtaacatatctgttagcatgctctaatagaccgagaaaataa
+gtgtctatgtgtgcgagaactgtcaattcacggcagtagtcacctaatctaacgtctagt
+tcccgactatgaagtcttcacaaatggttagtaataatttcccagtggagtagaagtggc
+ataacgtgcactctctgttaataatacctttagactactcccatttcgccagaacgtctt
+gatggtaccctatgggaaacactcacacatgcttattgcctgcaacctcagcaatgtgtc
+gtatgcggtatttctacgaacagctagtgaaaggactgatgacctaattttggtttctca
+agtccagacgtgatattttgatgaccgtatctgacatctctgggcaattcggttaacctc
+tggtacgaaatagtccgtcgcgtaggtaaaaatgataatgctgtcatcactatcatgttt
+tagctaagctacactaccccatcgctcgcacgtggcaaagtgtgaggattccgatatcat
+ccatgtgtacgaattcctaatactcttgctcagggcacttagggttattgtagcctgtgt
+taccgtctcgcatattagatcattaatcaacagtcttataatcaccgtaatcggtaaaca
+gttgttatttgttctgataggtagacagctaataaagatgctgttgaacagttacgtccc
+acctttattgccctacagtgaaactagttcttactctgttgctgtaatatgtctagggtt
+attgatttgctgccacttcaaaacggaaattaagtcattaacgaaaatggttccttcata
+ggtaaagatcaatccccaattgaagccagaaattttgagatgtcgattcctgatcattcg
+ccaaatttacagctcgtaaacgagttccatgtgtaaaaaaatgttgagtccactagcttg
+tttattctggctcaaggtacgtggaacacgtagtattttgatactaatgccagacccgct
+acgatccctgtactgtgagcagagccgatcctcagaaatagctaaatcttgtgcttcgtt
+agaagtctcgactacgtgtagcctagtgtttgtgttgcgttatagtctatttgtggacac
+agtatggtcaaatgacgtcttttgatctgacggcgttaacaaagatactctgggcaacac
+acatacttctctcatgttgtttcttcggacctttcataacctttcctggcacatggttag
+ctgcacatcacaggattgtaagggtctagtggttcagtgagcggaatatcattcgtcggt
+ggtgttaatctatctcggtgtagcttataaatgcatccgtaagaatattatgtttatttg
+tcggtacgttcatggtagtggtgtcgccgatttagacgtaaaggcatgtatggatcttga
+tctatgcaaaggtaggtccatctatatacgttgcacagcggatacaaataagataagaat
+ttactaacatttaaattttcttattgtcgagcatagattggaggaaaaacttatttactt
+ggtatttaaacggaagtttctaatgtttatgattggatgcacggacagtttactgcttac
+tttcttaggtttcttgaacaacaggatgcactagtaacatgtctcgttcatgcttccatt
+aagttcttcttaaacttacacaaactacctaatttagagttgacgagatggttgaacgtg
+ttgtgacaaacgtttgcaaaatgcacagtatcgttaccaaaaagtacatttaagtgtgtg
+cgtaggaattctgctacgtccattgcaggccacattcacatcccacccctgaatatatgg
+actgaatcacacacaccaaatttcatctaccttatcgtagcataactattaacaaacata
+tacagacttcgcggtaaataaaatatattagtacacaaccgtatactggttgaactattg
+cccagctttaagacgcttttaactaggtgcttgatcaagaagtattattatatgacggca
+gtgtgtaatacctgaatagatatagacgttagattgtctgaaaacacgccgtagagacat
+ttttgttagatatgtatttctttttgacgagccagcatcttagtatctgaagacgagcta
+tatgtttgtagaaaatcgactgacattgtatacgaggcggcgtaagattaaccaaattcc
+ccagaattagtaatggcgccttatcgatttactaacgatatataacttgtgatgttgtct
+gcaatgtatacccgtgtaggctgtgctcttatcgaaggaaacgcattgaagtccaggctg
+gatgaaaccaccgcgtacttccatgcgtctatacatagcgtcaccgatactacgttttgc
+tatgtaatccattctaatgggtaagaggattcctcttatagtaaaatatgcttgactttt
+taagaaccattgggagtggttggcaaaataatagtgggtgtctttctcagtgtatagttt
+tctacaactacccctattaggttacaagtaatctggctttcttgccacttggcgatgata
+gttagattcgtatttctacaacgcagttactgtatccatggcgcgagataattagatacg
+atttgaatttggatgtagactcgttactactgttgtagaccagcacgtgagtatctagat
+gggtttgctaccttgttagcggacttttgccgggaaaaagacatacgtacaaccgtatat
+tttactataagcagtattggccaccctcgtattgcggcagggtgtgctcacctggttaaa
+atgaaagagaaaaattccattttaaaacccggaggaatctattactgacgaggaaggtgt
+ttaacccgttgagacatctcctaacgtaaaaggttcatattctagttattccgagagtca
+ctttcctatccaaacatgaactgatagcataatgacaggttgaatggaaagcatatcctg
+tttattctaaatctgtttcgctaatcaatatgctgtcacgaactcggagcttacccttac
+aactatgtgttctgtttaccaggtgctaatatcccggcactcttttcatgcatgtcgctc
+ctagcgtcatctgatttaatagcttaatgtctcatattttacagtagccagtgtagtatg
+gaaggcggcgaaccagcccctacattgggtttcctgacataagtattacatatcacttgt
+ctgattacacagcaaaatcgctaaccttactttgcgcatgtagctattggaactttgggc
+tagtgtctatcccattaagtttaacagtagactagtccgtgagcgatcaccgagcttatg
+tctcgtacccaagttttggatttggatcaaaaactactcgatattcatgatctacgggct
+tcctttctccgggtatcattgcgccgagattaaaaataaaacgatagcgctgtgaaaaca
+tgtttgacacgggatagcgtagaaactaaacaacgaatagaccatccaatttgaatttta
+ttgggtccagcacttcgccatagtgttgaatggtaaagttcgaaaggaaatttgttatat
+taattctgctacattttcgaccacttgtatctcaaggacaatatcccttgaggcttttag
+cagaaagagatgccgtaattctaagggatgataataggttgggaaatttaagagcagtag
+taacggtcgcgggttcgaccttaaactatatatttaaatctagccaaacaagttaacaac
+aaccataaagttatgaccttattatattggcaagcttaacgttttaattgctctagtaat
+agagtggtagaggtaagggaccatcacctgattcttcctccgcaaccattatatagacgt
+gtcgtctgacaaatttcgagataaaacattcgtccttagcaacgaatatcgaatggcaat
+tagccacattgagttaaatagttgaggatatttcttgcacagaatcagatctaatctaat
+gattcgttactaaacacttcaccaggtatcgtgaaggctcaagattacccagagaacctt
+tgcaatataagaatatgtatgcagcattaccctaagtaattatattctttttctgactca
+aagtgacaagccctagtgtatattaaatcggtatatttgggaaattcctcaaactatcct
+aatcaggtagccatgaaagtgatcaaaaaagttcgtacttataccatacatgaattctgg
+ccaagtaaaaaatagattgcgcaaaattcgtaccttaagtctctcgccaagatattagga
+tcctattactcatatcgtgtttttctttattgccgccatccccggagtatctcacccatc
+cttctcttaaaggcctaatattacctatgcaaataaacatatattgttgaaaattgagaa
+cctgatcgtgattcttatgtgtaccatatgtatagtaatcacgcgactatatagtgcttt
+agtatcgcccgtgggtgagtgaatattctgggctagcgtgagatagtttcttgtcctaat
+atttttcagatcgaatagcttctatttttgtgtttattgacatatgtcgaaactccttac
+tcagtgaaagtcatgaccagatccacgaacaatcttcggaatcagtctcgttttacggcg
+gaatcttgagtctaacttatatcccgtcgcttactttctaacaccccttatgtattttta
+aaattacgtttattcgaacgtacttggcggaagcgttattttttgaagtaagttacattg
+ggcagactcttgacattttcgatacgactttctttcatccatcacaggactcgttcgtat
+tgatatcagaagctcgtgatgattagttgtcttctttaccaatactttgaggcctattct
+gcgaaatttttgttgccctgcgaacttcacataccaaggaacacctcgcaacatgccttc
+atatccatcgttcattgtaattcttacacaatgaatcctaagtaattacatccctgcgta
+aaagatggtaggggcactgaggatatattaccaagcatttagttatgagtaatcagcaat
+gtttcttgtattaagttctctaaaatagttacatcgtaatgttatctcgggttccgcgaa
+taaacgagatagattcattatatatggccctaagcaaaaacctcctcgtattctgttggt
+aattagaatcacacaatacgggttgagatattaattatttgtagtacgaagagatataaa
+aagatgaacaattactcaagtcaagatgtatacgggatttataataaaaatcgggtagag
+atctgctttgcaattcagacgtgccactaaatcgtaatatgtcgcgttacatcagaaagg
+gtaactattattaattaataaagggcttaatcactacatattagatcttatccgatagtc
+ttatctattcgttgtatttttaagcggttctaattcagtcattatatcagtgctccgagt
+tctttattattgttttaaggatgacaaaatgcctcttgttataacgctgggagaagcaga
+ctaagagtcggagcagttggtagaatgaggctgcaaaagacggtctcgacgaatggacag
+actttactaaaccaatgaaagacagaagtagagcaaagtctgaagtggtatcagcttaat
+tatgacaacccttaatacttccctttcgccgaatactggcgtggaaaggttttaaaagtc
+gaagtagttagaggcatctctcgctcataaataggtagactactcgcaatccaatgtgac
+tatgtaatactgggaacatcagtccgcgatgcagcgtgtttatcaaccgtccccactcgc
+ctggggagacatgagaccacccccgtggggattattagtccgcagtaatcgactcttgac
+aatccttttcgattatgtcatagcaatttacgacagttcagcgaagtgactactcggcga
+aatggtattactaaagcattcgaacccacatgaatgtgattcttggcaatttctaatcca
+ctaaagcttttccgttgaatctggttgtagatatttatataagttcactaattaagatca
+cggtagtatattgatagtgatgtctttgcaagaggttggccgaggaatttacggattctc
+tattgatacaatttgtctggcttataactcttaaggctgaaccaggcgtttttagacgac
+ttgatcagctgttagaatggtttggactccctctttcatgtcagtaacatttcagccgtt
+attgttacgatatgcttgaacaatattgatctaccacacacccatagtatattttatagg
+tcatgctgttacctacgagcatggtattccacttcccattcaatgagtattcaacatcac
+tagcctcagagatgatgacccacctctaataacgtcacgttgcggccatgtgaaacctga
+acttgagtagacgatatcaagcgctttaaattgcatataacatttgagggtaaagctaag
+cggatgctttatataatcaatactcaataataagatttgattgcattttagagttatgac
+acgacatagttcactaacgagttactattcccagatctagactgaagtactgatcgagac
+gatccttacgtcgatgatcgttagttatcgacttaggtcgggtctctagcggtattggta
+cttaaccggacactatactaataacccatgatcaaagcataacagaatacagacgataat
+ttcgccaacatatatgtacagaccccaagcatgagaagctcattgaaagctatcattgaa
+gtcccgctcacaatgtgtcttttccagacggtttaactggttcccgggagtcctggagtt
+tcgacttacataaatggaaacaatgtattttgctaatttatctatagcgtcatttggacc
+aatacagaatattatgttgcctagtaatccactataacccgcaagtgctgatagaaaatt
+tttagacgatttataaatgccccaagtatccctcccgtgaatcctccgttatactaatta
+gtattcgttcatacgtataccgcgcatatatgaacatttggcgataaggcgcgtgaattg
+ttacgtgacagagatagcagtttcttgtgatatggttaacagacgtacatgaagggaaac
+tttatatctatagtgatgcttccgtagaaataccgccactggtctgccaatgatgaagta
+tgtagctttaggtttgtactatgaggctttcgtttgtttgcagagtataacagttgcgag
+tgaaaaaccgacgaatttatactaatacgctttcactattggctacaaaatagggaagag
+tttcaatcatgagagggagtatatggatgctttgtagctaaaggtagaacgtatgtatat
+gctgccgttcattcttgaaagatacataagcgataagttacgacaattataagcaacatc
+cctaccttcgtaacgatttcactgttactgcgcttgaaatacactatggggctattggcg
+gagagaagcagatcgcgccgagcatatacgagacctataatgttgatgatagagaaggcg
+tctgaattgatacatcgaagtacactttctttcgtagtatctctcgtcctctttctatct
+ccggacacaagaattaagttatatatatagagtcttaccaatcatgttgaatcctgattc
+tcagagttctttggcgggccttgtgatgactgagaaacaatgcaatattgctccaaattt
+cctaagcaaattctcggttatgttatgttatcagcaaagcgttacgttatgttatttaaa
+tctggaatgacggagcgaagttcttatgtcggtgtgggaataattcttttgaagacagca
+ctccttaaataatatcgctccgtgtttgtatttatcgaatgggtctgtaaccttgcacaa
+gcaaatcggtggtgtatatatcggataacaattaatacgatgttcatagtgacagtatac
+tgatcgagtcctctaaagtcaattacctcacttaacaatctcattgatgttgtgtcattc
+ccggtatcgcccgtagtatgtgctctgattgaccgagtgtgaaccaaggaacatctacta
+atgcctttgttaggtaagatctctctgaattccttcgtgccaacttaaaacattatcaaa
+atttcttctacttggattaactacttttacgagcatggcaaattcccctgtggaagacgg
+ttcattattatcggaaaccttatagaaattgcgtgttgactgaaattagatttttattgt
+aagagttgcatctttgcgattcctctggtctagcttccaatgaacagtcctcccttctat
+tcgacatcgggtccttcgtacatgtctttgcgatgtaataattaggttcggagtgtggcc
+ttaatgggtgcaactaggaatacaacgcaaatttgctgacatgatagcaaatcggtatgc
+cggcaccaaaacgtgctccttgcttagcttgtgaatgagactcagtagttaaataaatcc
+atatctgcaatcgattccacaggtattgtccactatctttgaactactctaagagataca
+agcttagctgagaccgaggtgtatatgactacgctgatatctgtaaggtaccaatgcagg
+caaagtatgcgagaagctaataccggctgtttccagctttataagattaaaatttggctg
+tcctggcggcctcagaattgttctatcgtaatcagttggttcattaattagctaagtacg
+aggtacaacttatctgtcccagaacagctccacaagtttttttacagccgaaacccctgt
+gtgaatcttaatatccaagcgcgttatctgattagagtttacaactcagtattttatcag
+tacgttttgtttccaacattacccggtatgacaaaatgacgccacgtgtcgaataatggt
+ctgaccaatgtaggaagtgaaaagataaatattgcctacacatactgaattcaggcaatg
+cgttttattcgaaaggtcatataactagaaaacatgatgaattcttatcggatcctttta
+ctagcatagtgttggcgaacacctcgtaatgctcagcggcaaattggactgcgggtcctt
+atcatacattttttttcaatataggcgattggtctaggttagtgattccccaacacttaa
+ggtttgctgacattcataccctcagcaacttcctctcaaaaattagagtgagttggtggt
+cttataagaccgttgattatttgaggtggtcaaatgatggtgcgatgcacaaatcgttat
+aatcgtactctgtagacaataacccattgtagtgccgattttgtgcataatacaagaagg
+aggatataaaaatgacttttcaataatattggctattagcaacaagaaggagaatcctca
+ttaagttagcaaccgcagggggtactgcagtccaaggaggtttcattggagagagcagta
+tgaaaacggcaattatgattgtgagattcgctgaagattgtgtctctgattttcctagat
+agaataagctatagctacttaatcaactcttaactgtggagactatcctgatgatctgaa
+taccccatttacaaaattccatatcaatgaggctaacgcttaaatttcatttctccatcg
+taacaaaaatcagcctttttatacaagacaaaacactgcttccattacgggtagcaatgg
+ttgctcgactactggtagcgtcgtgatgtggtgataaagctgtcttgcgtttatacttaa
+acaaattttgacctgacataatggagcgacttatcggatgttgccgatctttagggtcat
+ctattaagcttatacgaaaaagggacaagcacgttacgtaatctggtaggactgggtacc
+tagaaacgcaagaggaggcgaactccaatatctgtaagaacagaaaaatacaggagtcct
+tttcatttttcaagttaacaatataagtaggagcttagagaggcttgcatgaaaatcgtt
+aggaattacagaataggcagagagtggggcgtgtagactacattcttcaggccccacaat
+atgggttataggttaaactgcactttttgcgatctcccgaaatactgtcgttctctgcga
+accacgctcgttccttttgctgtagtccacgttcatccaactattcagataaacaagatc
+gcagaattaaagcttaaccatatcttgatagcccatcgtgtatggggcatgtatgtgcaa
+acaaaagacctcaatcttgtctgcgagagggaggaaaatttagacaaacataattcattc
+tttcgactggacacgctaaggtttggacaaactttgtatctatatctggaggcctgtatt
+ccagcccttcttttaataagatttacggcttaaactatggatatttgccaggaaatgaca
+ctgctattgacaggaacataattttgattcaaacctcattgttaattattttatatctcc
+tgtttttatatcagaatgcttctgtcctagaaggcatactcaaggtgagggctcgaggaa
+tgaatcataatagaccggcccctattaatattggttcaattctttcttacataacgcgga
+atttgattgcacgaacaccgggaacacataaccgtatagcgcccgttatgctagtgccta
+gcgactgggaccgtggagtctatatcgtctttctaccattattaatctaaggatatacca
+ctttaagtcctttcaactaacataaggcgcattccatgcgctaaggaccttgaatttatt
+atttcttacatgataaaagatcgagtcgacgggaacaaaaggctacgtactcaataaagt
+gcagtttactaagagccctttttctggcttgtggagactatcataacatgaagatgtttt
+gacattcaatagtttgcaaaacaaacttactttgtgtagtattgaacgagatctttccaa
+ttgccccatagcaggaatagttatatattgcagatcgcggtgtaacgcactccaaatcca
+tcgcggtgtgtgagggtaagcgacttaaagaattacggtttttgatcaaagcacagtgag
+agttgagcaaattacagttatacgacttaattcagtctccataaattgaaacgacacttc
+ttaacgggaggaccagacacgttcattaagtgaggagtgcactttttgactttaaaaaca
+tggtaatcaatttaaaccacttgatatgtatatgaacagatttgaagttatttctgtttt
+aatacactgggagttctgtcaatatcgcaggaaccgcctgacgtcccctatcacacctca
+gagggtaaagggacaggggaaagggtaatcgaggggtagggaacgtagttggcacaccca
+atggacgaataaatgctgccatatccacggagggcgggattgcggttgattttaaggcga
+tggtaacctgaatgtaatagatcatcaaatgcctcctccactggaaattactgcgtacat
+ccgctgagaattgcaatggagtgtctcggtttttctttaaacaaaaccaaattgacaact
+tcatagtataatttttgcacattacaagcgttaattaacaaacttactttgctgttagct
+gcctatatttgtccgacaatataactggatatctctgcgagaactgtaaattaacggcac
+ttggaacataatagttcctattggtaacgacgttgtaggcggcaattatccggtggaaga
+attgacaactgcagttgaactgcatgaaagtcaaatctctcgtaagtataactttagaag
+actccaaggtacccagaacctcttcagcggacacgatcgctatcaatcaataaggattat
+tcactgaaaccgctcatatctggaggtggacgtttttcttcgaaaagcttgtcaaaggac
+tcatcaaatttttggccgtgctaatcgacacacctgttattttcatgaccggataggaca
+tctcgcggaaattcgggtaacagctgggtagatataggacctcccctacgtattaatgat
+aagcctgtcataactagcttggtttaccgaagagacaataaacattcgagcgctcgtgcc
+aaactcggtgcattacgtttgaataaatcggtaacatgtactattactctgcctaacggc
+acttacccgtttgggtccatggggtaaccgctcgatgttgacagaattatgctaaagtcg
+tttaagatcccgattaccgaaaatctggttatgtctgagcattcgtacactgcgtattaa
+gatcaggttgaacaggttcctaacaaattttgtgacctaaagtgaaactaggtcgtactc
+tgggcatgttttatgtcgtggcgtatgcatgtgctgacacttctaaaaccaaattaaggc
+tttatccaatatgggtccttaagtgctaaacatcattcacaatttcaagacagattgttg
+gtcttgtcgattccgcatctgtcgccaaattgacacatcgtaaaccaggtacatcggtaa
+ttatatgttgactaaactaccgtgtgtattctggctctaggtacggcgaacaagtacgat
+gtgcttaagaagccctcaccccagacgagcccgcgtaggtcacatcagcagatcctaagt
+aattccgttttattgtcctgagggagtaggatcgacgaactctacaagtcgctttgtcgt
+gccttataggctatttcgggtcaatgtagcgtcaaatgaactattgtcatctgtacgagt
+taactaagtgtctatcgccaactaaaagacgtctcgatggttctttatgcggacctgtca
+tatcattgactggcacttgcttacatccaaataacacgtttgttagcggatagtcgttaa
+gtgtgcgcaagatcatgaggcggggggggtaatatttcgccctctacatgataaatgaat
+aagtaagaagatgatctttttgtggcggtaccttaagcgtactcctgtcgacgagttact
+actaaaggaatgtagggttctggatctatgaaaagcgacctccatatatatacgggccta
+agcggagtaaaataagtgatcaatggactaacattgaaatgttagtattgtcgaccattg
+agggctggtaaatcttatttacgggcgtgggaaaacgaacgtgatatggtttagcatggg
+atgcaagcactcgttaatgcttactttagttggttgcgggaacaacaggaggctatacta
+actggtagcgttcttgcttccattatgttattattataattaaaaataagacatatggta
+gagttgtagtcagggtggatcgggttgtctataacgttggaataatcaaaactatcgtta
+acaaaaacgaaatttaagtcggtgcggtggaatgcgcctacctcatgtgcaccacacatt
+cacagcacacccctcattataggcaaggaagcaaacaaaaaaaagttaatcgaccgtatc
+cgaccttaaattttaaaataaatagaaacacttagcggtaatgaaaagataggactaaaa
+ttcactagtatcctggaacgaggcaacagagttatctagatggtaacgaggtgctgcatc
+aagatgtatgatttttggtccgctgtgtggaatacctctattgatatacaagtgactttc
+tcggtaataacgcacttcacaatgtgttgtttcttttctatgtattttgcaagagaaaga
+agcttagtataggtacacctcagagatgtttcgtgtaaatcgtatcacatggtataactg
+caggaggaacattatccaaattcaccacaattactaatccacccttttacttttactaaa
+gatatattaattctcatgttgtctgaattgtataacccggtaccctgggagcgtatcgaa
+ggataccaattgaagtcctcgaggcatgttacaacacacgacttccttccgtctattcag
+acactcaacgagactaacttttcctaggtaatcaatgatattgggtaactcgtggcatct
+tatagttattgatccggctcttttgtagatcctgtgcgactcgtgcgctaattaagactg
+gctctcttgcgcaggggatacgtttattctacgtacccgatttggttactactaagcggc
+ctttcttcaaacttgcagttgtgacttacattcctatttcttcaaagcagggaagggtta
+cagggagagacttattgagatacgattggaatttccatgtacaatcgttaatacgcttgt
+agaccagcaactcagtatagagatccgtttcctaaagggtgagcggtaggggcaaggcaa
+taagaaattactaaaaccctagttgttaatataagaacgattcgaaacaataggattgcc
+caagggggtgcgaacatggtgtaaatcaaagagaaataggcattgttaaaacccgcacgt
+ttctagtacgcaagaggaacgtcggtaaccagttctcaaagatcctaacctaaaaggggc
+ttattctactttttccgacactcaatggacgagacaaacatgaacggatagctttaggtc
+tcgttgaatgcaaagaatagaatcgttattattaatcggtttccattatctatatgcggt
+atagatctccgagaggaccctgtaaactagctctgcggtttaactggtgctaatagaccg
+ccactatgttattgcttctagctcctagcgtcttatcatgttatacattaatgtcgcata
+ttggacagtagccaggcttggatggatcgccgacaaaaagaaaagactttccctgtaagg
+acttaactattacatataacttggatcattaatctgcaaattagagtaacggtctttcac
+cagcttcatattccaacgtggcgctagtcgatatcccatgaagtttaaaactagaattgg
+cagtctcacttcacagtgcgtatctatacgacaaaagtggtcgatttgcataaatatctt
+atcgatattcaggttattaccgattccttgctaacgctagaagtcacaccagagtaataa
+taattccagacacctgtgaaataatcggtcactacggatagactagtaacgataatacgt
+atagtccataaaagttgaattttaggggctaaagatattagcaatactggtctagcctaa
+tcgtcgatagcaaagggctgtgaggatttctcctacattttcgaccaattgtatcgatag
+gaatagttacagtcacgcttgtagatgtaagagatgacgttattcttagggttcttaagt
+cggggggtaatttaagaccactagtaaaggtagaggcgtacacagtaaacgatattttga
+aatcgtcaaaaaaaagtttacaacatcctttaagttagcaactgattttagtggcaacct
+taacggttgaattgatctactaatacaggcctacaccgaagggtacagataatgattctt
+actaccctaacatgatagagtcctgtcctatctcataggtcgacattttaaattcgtaat
+gagcaacgaagatcgtttcccaatttgcaacattcacttatagacttcaggttatttcgt
+gctaacattaagatagaatataatcagtcgttaagaaactattatccagctttcgtcaac
+cataaagattaaaaactgaaacttggcaagatatgaatagctatcctgctttaaccgatc
+gtatgagatgctttgtagcaagaaaagtgactagcacttgtgtttagtaaagcgggagag
+tgcggtaattaatattaatatactattaagctacacagcaaaggctgcaataatgttagt
+aagtagaacataaaggtattctccacaagtaataaatagtgtgagctaattgactaactt
+aactctcgcgacaagtgatgtggataagatgactcatatcgtctttttctgtagtgccga
+catcccacctggatcgaacaattccttctagttatcgactttgattacctatcctattaa
+acagatagggttgtaaagtcagaaaatgatcggcttgcgttggtctaccatagctagagt
+tagaacgcgtagatagaggccttttgttgccaacgtgggggtgggatgagtctgggcgag
+cgtgactttctttcgtgtccgaatttgtttaacatccattagattagatgtttgtgtttt
+gggtctgatgtcctaactactttctcagtgaaactaatgtcatcatccaagtaaaatagt
+ccgatgaagtctccgttttcggccgaagcttgtctataacgtatataaagtcgctgaatt
+tagaacacaccttatctatgttgtaaagttactttattccaaaggacgtgcacgaagcgt
+gagtgtgggaaggaacttaaagtcggatcactcttgtcagtgtagataagaatttctttc
+atacttcactggaatccggcgtatggatatctctaccgcgtcatctggtggtgtctgcgg
+taaaaagtcttgctgcacgagtctgagaaatttttggtgccatcacatcgtaactgtaca
+acgaacaaatagcatcaggccttcttatccagcgtgaagtctaattatttcacaagcttt
+cctaagtatgtaaatccctcacttaatgatgcttgcgccaatgaggatagaggacattgc
+atgtacgtaggactattctccaaggggtcttctattttgttagcgaaaattgttacagcc
+taatgttagagcggcgtacgactttataccagatactttcattagatatgcaaatatcca
+attaaatcatagtagtatcgtggtatggacaatcaaaaaagacccgttgtgatatgatgt
+ttttctagttcgttctcatatatatagatcaacaatgaataatctcatgatctataaccg
+atgtatatttatattccggttgactgctccggtgcaattcactacggacactaatgacta
+atatggcgcctttcatcagaaacgctaaatatgattaatgaattaagggagtattatcta
+attattagagagtagcagttagtctgatattttcggtgtatgtgttagccgttataatgc
+tgtctttttatcagtgagaacagggagtgtgtagtgttgtatgcttcactttatgactct
+ggttatatccctcggagaacaagaataagagtacgagaagttcggtcattgaggatgaaa
+tagaaccgctagacgaatggactcacgtttataaaactatgtatcacagtactacagcta
+actctgaagtccgagaagcttttgtaggacaaaacgttataagtacctttcgcagaatac
+ggccgtgcatacctgttataaggcgtagtagggacaccatgctatccctcatatagagct
+acactaataccattacatggtgactatcgtttacggccatcatctgtaagcgatcatgcc
+tcgttagcatccgtacaatctcgcatggcgtcactgcagaaaaaccccgtgcggattttg
+agtcagaactattcgaagcttctcaatccttttccattatggcatagcaagtgacgactc
+gtcagccatgggaataatagcactaatccgattacttatgaattagaacccacatgaatg
+tgattctgcgaattgtctaagaatctaatgattttccggtgaatatggttgttgttattt
+attgaacttatattattaacatcacccttcgttagtgatagtcagctatttccaagaggt
+tccccgagcatttttaccattctctagtcatacaagttggagcgcttttaaatctttagg
+ctgatcaaggcgttttgtctagaattctgcagatgttagattcgtgtgcaatccctcttg
+catgtcagtaacaggtcacccgtttttcgttacatatgctggtaaaatattcatagtaat
+aactacaatacttgatttgttacgtaatgctcgtacataacacaatcgtattccacggaa
+cagtaaagctctattattctgatcgagcctaagagaggatcacactacgctattaaagtc
+acgttcacgaaatctcaaacctcaactgctggtgaccagttatagacagtgtaattccat
+attacatgtcaggcttaagctaacccgagcctttatataagctataatcaagaattagat
+tggagtgcattttagacttatctatcgaaatagtgatagtaagagtttatatgacctgat
+ctagactgatgttctcttccacaacagccttaaggcgtggagcctttcttatactattag
+gtcgcgtcgagagccctattcgtaatgttaacgacactagactaatatacaatgagctaa
+gaataacacaagtcacaagataatttacaaatcatatatctacagtccacaaccatcact
+agcgattgcaaagcgttattggtactaccgctctaaatcggtatgtgcaagacgcgttaa
+ctggttcaagcctctcctgctcgtgagactgaaagaaatcgaaaatatggatgtgcctaa
+ttgttcttgtgagtcatgtgcaactatacagtttagtttggtcaagactatgcaactatt
+aacagcatgtgcgcattgaatatttggtgtcgattgataaatgccccaacgttccatcac
+gtctataagccgtgttactaatgtgtattagtgcatacctattcagaccatagttcaact
+gttggactgaaggcccgtcttggggttcgtgaatgagagtgcagtttcttgtcttttcct
+taactgacctaaatgaaggcaatcggtttatctagagtcatgcttaaggtgaatttcagc
+caatgggctcccattgagctagtatggtgctttacctttgtaagtggtggctttccttgg
+tgtgctgactttaacacggcagagtgattatccgaagaatggataataagacgctggcaa
+tattggctaataaagtccgatgagtttcaatcatgactgcgaggagatccatgcggtgta
+cctaaacctacatcgtatgtatttgctgacgttcattcttgatacataaagatccgatat
+cggtccactttgtttaccaaaagccctaccttcgtaacgatggaaatgtgaatgagagtg
+aaatacacgatggggatattgccggtgagtacaagttagaccacacattagaactgacct
+atattcgtcatcatagagatggagtatgaattgattctgcgaagtacactggctttacga
+gtatctagacgccgcggtatatctcccgtcaatactatgaaggtatatatatagaggctg
+aaaattcatgttcaatcctctttctaagagtgagtgggagccccttctgttgtcggagta
+aaaaggcattattcctcaaattgtcagaagcaaagtatacgtgatgtttgcttagaacaa
+aagagttaccttagggtaggtaaatctcgattcaccgagagaagtgattttggcggtgtg
+cgattaattcttttgatgacagatctcattattttatatagctccctctttgtatttaga
+gtttgcgtaggtaacctggcaaaaccatatcccggggggagagtgcgctgaacattttat
+acgatgtgattactcaaaggataaggttcgaggcctctatactcatggaactatcttata
+attataatggatcgtggctcattccacctatccaaacttctttgtgatctgatgctacga
+gtgtgaacaaacgtacatcttctaaggaatttgggacgtttcatagctcgcatttcattc
+ctgaaaacttaaatatttttaaaaattgattctactgcgaggaactaaggtgtagacaag
+cccttagtaaccggtggatgtcgcttcagttttatagcaaacattattcaatttcagtct
+tgactgaaattagtttgttagtgttagaggtccatatgtcacatgcatatggtctagatg
+ccattgtacagtaataccttagattagtattagcggcatgcgtacttggatttcacttgt
+aagaatgagcttaggacggtcgcctgtagggctgcaaataggaatacttacaatttttga
+tgacttgttagcatatcgctatcacccataaaaaacctgatacttgatgagcgggtgatt
+gagactatgtactgatataattcaatagctccaatagatgaaacagctatgcgcctattt
+atgtcaaataatcgatgtgatacaagcttagagctgaacgagcgcgagtggaattagcgg
+tgatctctatcctaaaaagccacgaaatcgatcccagaagctaatacccgaggtgtcaag
+cttgagttcagttaaatttgcatctcatgccccacgaagaatgggtagagagtttgaagg
+tgcttctggattttcctaagtacgtggtaaaaatttgatgtaaatgaacacctcctaatg
+gttgtgttaaccacaaacccctgggtgaatctgattagccaacccagtgatctgatttca
+gttgtcaaatctcttttttataactaccttttgtttccataatttaaccggatctcataa
+tgaacaaacgggtagaataatggtagcacatagcgagcttgtctattcagaaatatggcc
+tactcagaatgtattctccaaatcagtgttatgcgaaacgtaattttacgtgtaataatg
+atgatttcttatcggttccttgtactacaatactcttgcccaacaaatactaagcataac
+agcaaaattcgaatccccctccttttaataaatggtttttcaatatagccgattcgtatt
+cgttagtctttcaccaactattaacctggcatctaattaataaaatcaccaaaggactct
+ataatatgacagtcacttcggcctcttttaagacagttgattattgcaggtccgcaattg
+atggtgacatgcacaattagttagaatccgactatggagacaattaacaattgtagtgcc
+catttggtccagttgacttcaaccacgagttataaaggtattttaatttatagtcgatag
+taccaacaacaagcacaatcataattatgttagaaaacccagggggtaatgctctaaatc
+cagctttaaggccagagtgcactatgaaatcgccattgatcattgtgtcattcgctgaac
+ttggtgtctaggaggtgccgagtgagaatatcagataccttatgaagcaacgattatatc
+tggactagatcatgatgatcggaataaaacattgaaataagtccttatcaaggagcataa
+acattttatttaatttatacttcgtaaataaattcagaattttttttcaagacattaatc
+tgagtaaatgacggctagaaagggttcctactcgaatcgtagcctacgcatgtgggcagt
+aacctggcttgcgtttttactgaaacaaaggttcaccggaaagaaggctgccacttttag
+cttcttgacgatctttagcgtcatatttttagattagtcgaaaaacggaaaacaaactta
+acgaagctggttgcacggggtaccgagaaaccaaagagcaggacaactccttgatcggga
+agaactgaaatagacagctgtcattttcattggtcaacttatcaatataacgaccaccgt
+agtgacgcttgcatgaaaatactgaggatgtaaactatagccagtcaggcccgcgtgttg
+actaattgatgaagcaaacaaaatagccggtattcgttaaaaggaacgggttgccagcta
+cagatatactctaggtatatcccaaacaagagacgtcctttggctgttgtaatcggtcat
+aatacttgtcacataaacaagatcgctgaattaaacattaaacagttagtgatacacaat
+cgtggttggggctgggatgtgcaataaaaagtcatctatcgtctatcacagagcgacgta
+aatttagacaaacattattatttcttgacaatggaatcgataagcgttcctctaacttgg
+tatatatatctcgaccccgggattccagccattcttgtatgaagatttaaccatttaact
+atgcatagttgaatggtaaggaaaatgatattgactgcaacagattttggatgcaaaaat
+atttgtgaattattggttatatactggttgtatagcacaatcattaggtcctagaaggca
+tactcaacctcagcgagagagctagcatgcataattgtaccgcccatattaatattcctg
+aaatgatttcttacattacgcccaatttcagtcatcgaacacccccatcaatttacccga
+tagagaacgtgatcatacgcaataccctatgcgaacgtccactctatagcgtctgtatac
+aatgattattcgttccatttacaacgttaagtaatttaaacttacataaggacaaggaaa
+tccgcgaacctcctggaatgtatgagttatttatgcagttaacttcgtctcgaccggaac
+taaaggcgtcgtacgaatgaaaggccacttttagaagagacctttgtatccattgtggag
+aatatcataaattcaagatggggtgtcatgctattcggtcctaaacattcttaatggctg
+ttctattgttagtctgatttaaaatggaaccatagcacgaatagttagatagggctcata
+cccctgtaacgatctacaaatccttccccgggtgtgtgcgttagcgacggaaagttttac
+ggtttgtgatcaaagaacactcacacgtcagattattacactgatacgaattatttcagt
+cgacagtaattgaatagaaacttattaacgccagcacctgacacggtaagtaaggcaggt
+ctgaactgtttgactgtaaaaaaatggtaatatttttaaaaatcttgatttctatatcaa
+atgatgtgtagttttttctctgttattaaaatcccagtgcgcgaaatttagatcgttacg
+actcacgtacaagatcacacatcacacgcgttagcgaaagcggaatggctaatacagccc
+tacgcaacgtagtgggatcaacatatggacgaatttatgctcaatgagccaacctccccc
+gcattgcggttcattttaaggcctgggtaacatctatcgtttagataatcaaaggaatcc
+gactatgcaattgtctgacttcatccgctctcaagtccaatgcaggcgctacgtgtttct
+ttaatcaataccatattgaaatcgtaatacgataattgttgctattgactacaggttatg
+aaaaaacttactttgcgggtacatgcatatttttgtaccacattattacgcgatatctct
+cagtgtactctaaattaaaccctcttcgaacattttagttcctattcgtaaacacgtgct
+acgcggcaatttgccggtcgtagaatggacaactccagttcaactgcatgtaactcatag
+ctcgcgttagtataaattgactagtagccatgggacaaagtaactagtcagcggaaaaga
+tccctttaaagatatatgcaggttgcaagcataaagctcattgctcgaggtgcaccgtgg
+tattccaaaagcgtctctatcgtatcttctaattttgggccgtgagaatcgaaactactc
+tgatttgctgcacacgttaggtaatatcgcccattttcccgtataagctccgtacttata
+cgaactacacgaccttttaagcattagccgctcatatcgtgattcgtgtacagatgagtc
+tattaaaattacagacatactccatatctcgctccttgaactttgaataatgcgctaact
+tgtactatgaataggcagaacccaactttcccgtttgcgtcaagcggggaaacgatacat
+gttgtcagatttatgattatctagttttagatcacgtttaccgataatcggctgtggtct
+gagcagtcctacactgagtatttacttcagcttcatatcggtccgaaaaaaggttgtgac
+cgaatgtcaaaatacggagtacgatgggcatcttttttcgagtcgcggttgcagggcagc
+aaaaggcttaaaccatttttacgatttttactatagcggtcatgaagtgcgaaactgctt
+gcaaattttctacacacattgtggctcttgtccttgaagcttatggcgaaaatttgaaac
+atagtataccagggaaagcgcgaattatttggtgactaatagtccgtgggtttgagccat
+atacctaacgccataaactacgtggtgctttagatgcaatctaaacagaacagaaagcgt
+agcgctcatcagcacagactaactttttcagtttgagtcgccggagggacttcgagacaa
+gaacgcgtcaagtcgcttgcgcggcacggattcgattgggcggctcaatcttgcctaatt
+tctactattgtcagctgtacgactgtactaagtgtatagccccaaataaaagaagtatcg
+atgcgtctttatgaccaaaggtcttataattgaagcgcacttccgttcatcaaattaaat
+cctggcttacccgattctccggaagtctgacctagagattgacgacggccgcgtattatt
+gagacctcttcaggattaatcaataacgaagtagttgatctgtttggcgacgtaccttaa
+gccgactccgctacacgagtttctactaaaccaatgtagccttatgcttagatgaatacc
+gtcctaattagatattccggcataacagcagtaaattatctgttcaatggacgaacattg
+aattgttagtattctacacaagtcaggcctcgtaaatattaggtaaggccgtgggataac
+ctacgtgatatgcttgagcttgcgttgcaagctctcgttaatcattaatttaggtgcgtg
+agggttaaacaccagcatattctatatgctagacgtcttccttaaaggatcgtagtatta
+taattaataataagaaatatggttgacgtctagtcagcgggcatacgctgctctatatac
+tggcattattcaaaacttgacggtaaaaaaacgaattttaaggcgctcacgtcgaatgag
+ccgaactcatgggaaccaaaatgtcacagaaaacacctctttattgccaagcatgcaata
+aaaaaaatgttaatagtacgtttacgacattttattttataataaagagaaactattaca
+cctattgatatgataggacgtaaattaacgagtagcctgcatagaggcaaatgaggtttc
+tacatggtatagacctgatgctgaaacatcgatgagttttggtcccctcgctcgttgaaa
+tctagtcatttactactgtctttcgagctattataccacttcactatgtggtgtttcttt
+gctatgtatggggctagtcaaacatgatgactatagctacaactcagagagcgggcgtgt
+taagagtatctcatgctagaactgcacgacgaacttgatacaaagtaacaacatttacga
+ttccacaaggtgactttgaagaaacatagtttaattctctgcttcgatcatttctataaa
+ccggtaccatcgcagcggatagatgcataacatttctactactccaggcatcttaaaaca
+cacgtagtacttcactagattaagacacgataagtgtataacttggcagtgggaagcaag
+gagattggcgaactcctggcatctgttacgttttgttcaggctcggttgttgataatgtc
+cgactcctgccatattgaagactcgctcgagggagatcgggattcgttgattataagtac
+acgtgttccgtaatactatgaggcagtgattcaaaatggcacttctgacttacatgacta
+ggtattattaccacggaagcgttaaaggcacactcttatggacttaagattgcaagtgcc
+ttcttctagcctgaattcgcgggttcaacacaaactctctttagacatccgttgcctaaa
+ggctgagacgtaggggcaaccctttaactatgtactaaaaaactagttggtaatttaaca
+acgtgtccaatcaagacgatgcaccaacgcggtgcgaaaatcgggttaagcaaacacaaa
+taggaattgtgataaaccccaccttgagaggtcgcaagaccaacctcgggaacaacggct
+ctaagagaataacctaaatccggatgagtagactgtgtaactctctaaagggaagtgaaa
+aaaagctaagcatacatttaggtctcctgcattgcattcaattgaatcgtttgtattatg
+agctgtacagtagctatatcagctatagttatcccagaggaacaggtaaactagctctga
+gcgtgaaatccggatattagaacccctagatgggattgattctagctaatacaggcttat
+ctggttttacagttatctagatgattggtaaggtgaaacgcttggtgccttccaccactt
+aaacaaaagtattgcccgggaagctattttctaggtattataaagtcgagcattaatatc
+aatttgacagtaaaggtctttcaccagcttcatatgccatagggcccatactcgatttaa
+attgaacggtttaacgagtattggaactctcacttataactgagtagctatacgaaaaat
+ctggtccatttccagaaatttattatcgatttgctgcttagtacccaggaagtgataacc
+cttgaaggcacaacactgtaataagttttcctgtcacatctgtaatattcggtcactacg
+cattcacgactaaagataattactatactaattaaaagttcaatgttagggccgaatcat
+agtagaaattctcgtctagcctaatcggacttacctatgggctgtgaggatttatcagta
+tgtggacaaaaatgctagagataggtatagttaaagtcaccatggtacatctatgtgagg
+aagtttgtagttcgcttctttagtccgggcgtttgggatgacaactactatacgtagagc
+cgtactcaggattagatagtgtgaaagagtcaaataaaagggttaatattaatttaacgt
+tgcaaatgtgtttaggccaaacattaaccgttgtagggatattctaatacaggccttcac
+cgaaccctaatgataatctgtcttaataacattaaatgattgtctccgctacgagctctt
+agggcctcattttaaatgactaatgtccaaagaagagactttcccaatttcaatctgtca
+cgtatagacggcaccttagtgagtcatatcattaagatagaagattatcaggagggaagt
+ttctattatcaaccgttacgcaaccataaacttttaaatctcataatggcattgagatca
+agagctttcatgatggtaaagttcgtatgtgatgctggggagctagatatcggtatacca
+cttcggttgtggtaagcccgagtgggccgttagtaatattaatagacgattatccgacaa
+tgcattcgctgaaataatcttacttaggagaaattaatgctatgagccaaaactatttat
+gtctgtcacattattgactaaagtatctatcgacaaaactgatgtccataagttgtagca
+gatagtcggtgtatggtgtcaccaatgaaaacctcgagcgaaaaatgaattatagttatc
+caatttgagtaaattgcctattatacagataggcttgtttagtcagataaggttccgctt
+gaggtgctctaacttagcgagagttagaaagcctagtgagaggcattttggtgccaaact
+ccggctcgcatgagtaggccagagagtcactttctttcgtcgaagaagttggtgaacagc
+cttttgattagttgtttgtcttgtggctatgtgctactatataagttagaacgcaaacta
+atctaatcagcaaagtaaaataggaccttgaacgagacggggtacgccgttgaggctcga
+gatagtagataaactagaggaatgtagataaaacattagctagggggtttagttactgga
+ttacataggaagtgcaccatcacggtgtgggggttcgtacgtaaagtcgcatcaatattg
+tcagtggacttaacaagttcgtgcataatgaaatcctatacggactttgcatatctctac
+cgactcatctggtcgtctatgcgggtaattgtattgctccaagtggatgactattttggc
+gtcccagcacatagtaaatgtaaatccttataatagcataagcaattattagactgcgtg
+aagtcttagtagttctcaagctttacgttgtatgtaaataactcacgtaatcagccgtcc
+ccaaatcaccattgaggtcattgaatgtacggagcactattatcaatgcggtatgcgatt
+ttctgagcgattattgttaaagacttagcgttgagccccggaacacttgattacagattc
+tttaaggagttatccaaatatcattttaaataatagtagtatcgtgctttggacaataaa
+aaaagacccgttctcttatgttgttttgcgacgtacttctctgatatatacttcaactat
+gaagattctattcatcgataacccaggtatatttatatgcccgttcactgcgcagggcaa
+attatctacggacaataatgacgtagttggacccggtaagaactaacgcttaatatgatt
+aaggatgtatgccagtattatcttattatgtcagagtagaagtttctctgagattttccg
+tcgttgtggtacaccggatttggctctctttttagaactgagaactcggagtgtgtagtc
+ttgtttccttcaatttatcaatatgcttttataccgccctcatcaactataacaggacga
+caagttccgtcttgctccatcatatactaccgatacaccaatcgtatcaagtttagtata
+cttgctttctctcttctacagcttactcgcttgtccgagaagcggttggtgctcataaag
+ttagtagtaaatgtacaactagtagccagtccttacctgtttttacgactactacggaca
+ccatgagatacagaagttagtgctacaattataccattacatgctcaatatcgttgtcgg
+ccataagatcgaagagtgcatcacgcgtgtgaatacgtaaaatctaccatcccgtcaatg
+cacaaaaacacactccccttgttgactaacatcttttacaagaggctaaatcattgtcca
+ggatcgaataccttgtgtacaatcgtcacccatcggaagaataccacttttccgatgtag
+tatgatttacaaaaaacatctatgtgagtaggccaattgtagtagaatatattcatttga
+ccgtcattagccttcttcttaggttgtgtacggatagtaggtacataaaccgtcgtgtgg
+catacgctgcgatttcatacagctgccaacaccttttttaccaggctagagtcagaaaag
+ttggagccatgttaaatagttaccatcataaaccactgttgtctactagtctgatcagct
+ttcatgcctgtgcaagcaatatggattctcacgtaatggtaacaactgttgcgttactta
+ggctggttaatttgtcagagtaataaatacatgtcttgttgtgtttcctaatcctcggaa
+agtacacaagcctaggaataggaaaagtaaagctcttttattctgatagtgactaactca
+ggatctaaatacgcgattatactaaccttcaccaaagctcaaaaatcatctgctggtgac
+cagttatagacagggtaattcaatatttaatgtctcccttaacatttcaccagcatggat
+tgaagatagtataaagttttacatggcagtcattgtgtcacggttctatacaaattctga
+tagttagacggtatttgaaatgtgcttctagcatggtatcttacacaactgaatgaacga
+ctggagccgttcgtatactatttgcgagcctcgagaccccgtttcctaatgttaacgaat
+atagtataatataaattgtgatatgaataacacaagtaactacagtttggacaattaatt
+gttctaaactaaaaatcattcacttcagatggcatagagttatggctactacacatataa
+agcggtatgtgaaacacccgttttagccggaaaccctctactgctcgggacaatgaatga
+tttccaaaatatggatgtgcagaattgttagtgtgactcaggtccaaatagacactttag
+tttcgtcaagtcgttgcaaagtttaaaaccatcgcagcattctttatttggtctacattg
+agaaatgaaaaaacgtgacagaaagtctagaagaactgtgaataatgtctattactgatt
+aactagtaagacattagtgcatctggtccactgaagcacccgcttggcgttaggcaatct
+ctgtgaactgtcgtggctgttccggtaatgtacgaaagcaagcctataggttgatcgagt
+cgcttcattaaggtcaatttcacaatatccgatcacattgtgctaggttcgtcctttacc
+ttgcttagtgctgcatgtacggggtgtcatgacttgttatcggcagactctttatcccaa
+gaatggataatatgtacatggaaagtgtccataattaagtcccttcactgtaaagaatga
+ctgccacgtgatccatgaggtctacagaaaccgacttacttgctttttgatcaacttaat
+tatggattcataaagttcagatatcggtacaattggtgtacaatatgaaattaatgagga
+aacatggaaatctgaatgacagtgatagaaaagatccccatttgcccggtcagttcatgt
+tacaccactcattagtactgtaagtgtttcgtcagcattgagatccacgatcatgtgttt
+atgccttcgaaactggatgtacgacgatcgagacgaagaggtatatataacctaaatact
+aggtacgttgttagagagacgatgaaaattaatcgtcaatacgctggcgaacactgaggg
+ggacccaatgctcttctcggtctaaaaaggaatgtgtcagaaattggtcagttcaaaagt
+agaccggatctttgcggagaacaattcacggaacgtagcgttgggaaatatcctttctac
+cacacatcggattttcgccctctcccattatttattgtgttctcacatagaattattgtt
+tagacatccctcgttgtatggagagttgcccgagcgtaaaggcataatccatataccgcc
+gggtgagtgacctgaaattgtttttagttgggatttcgctatggattagcttacacgaag
+agattctaatggtactataggataattataatgctgcgtggcgcagtacaccgttacaaa
+cgtcgttcgcatatgtggctaacacggtgaaaatacctacatcgtatttgcaatttcggt
+cgtttcatagagcgcattgaattactcaaaaattatatatgttgattatttgattagact
+gcgtggaaagaaggggtactcaagccatttgtaaaagctgcatctcgcttaagtttgaga
+gcttacattagtctatttcagtcttctaggaaatgtctgtgtgagtggttgtcgtccata
+ggtcactggcatatgcgattcatgacatgctaaactaagaaagtagattactattaccgg
+catgcctaatgcgattgcactgctatgaaggtgcggacgtcgcgcccatgtagccctgat
+aataccaatacttacatttggtcagcaattctgacattatacctagcacccataaattta
+ctcagacttgaggacaggctcttggagtcgatcttctgtttgtatgcatgtgatcatata
+gatgaataagcgatgcgactagttagggcatagtatagatctgtgtatacagttcagctg
+aacgtccgcgagtggaagtacagctgagatctatcctaaaatgcaaccatatcgttcaca
+catgatatgaacccagggggaaacattgagttcagttaaattggcagcgaatcccccaag
+aagaaggcggagtgacgttgaacgggcttatggtttttcagtacttcctccgtataagtt
+gagcgaaatgtaaacagaataatcgttgtgttaacaacattaaaatcgcggaatatgatg
+agaatacacagtgtgagcatttcacttgtaaaatatctttggtagaacttactttgcttt
+aaatatgttaaaccgatctaataatctacaaaacggtagattttgcctagcacattgcgt
+ccttctctattcagatagaggcaatactcagaaggttttatccaaagcactgtgttgact
+aacctaagttttagtctaataatcatgattgattataggtgccgtggactacatgactcg
+tccacaaataatacttagcagatcagcaattggccaagcacccgacttttatttaatggt
+tgtgcaatagtccagattcgtattcgggactctttcaaataatagtttcctggcatctaa
+gtaagaaaagctcataaggaagcgatattatgacacgctcttccgccgctgttttgaaac
+ttgagtattgctcgtccgaaattgagggtcacttcaaaatttactgagaagacgaagatc
+gactaaagttaaaatgctagtccacagttggtcaagttgaattcatccacgagttatata
+gctattttaatttatagtcgagtgtacaaaaaacatccacaataagatttatcttagaat
+aacaacccccgtatcatcgaaatcctccgttatggcctgactcctcgagcttatagcatt
+tgtgctggcgctcttgccaggaacttgctcgcgaggtggtgacgagtgagatgatcagtt
+tcattatgatgatacgattttatcgcgactagttaatcatcatagcaagtaaaatttgaa
+ttatgtcattatcatgctccattaacaggttatttaattgatactgacgaaattttttca
+caatgggttttctagaatttaatatcagtaattgaagccttcataggggtcctactagta
+tcctacacgacgcaggtccgcagtatcctggagggacgtgttactgattaaaagggtcaa
+aggaatgaaggctcacaatgttacctgcttcaccatagtgagccgatgagttttacatta
+gtactaaatcccaaatcatactttacgatgaggcttgctagcgctaaagagaatacatac
+accaccacatagaattgttagcgatgatatcaaatagactcctggaagtgtcagggggaa
+actgttcaatatttcgtccacaggactgaccaggcatggaaaagactgacgttggaaact
+ataccatctcacgcccgacgcttcactaattgatgatccaaaaaatatagcccggattcc
+tgattagcaaagggttcacagagaaagatattatcgacgtatatcccaaaaaacagacgt
+aatgtgcatcttcgaatcgggatgaatacttgtatcataaaaatgtgacctctagtatac
+aggttaatgttagtgatacacaatactcgtgggccatgggttctcaaataaaatgtaata
+ttgcgtcgatcactcacccacgtatttggtctaattatgttttatttagtgacaatccaa
+tagataaccggtcctattaagggctatatttttagcgaccacgcgtttaaacaaaggatt
+gtatgtagatggtaccagtttaattgccagtgggcaatcctaagcaaaatgagattctat
+cctaaagtttgggcttgatataagatttcggatgtatgggttttataatcgttggagagc
+tcaatcatgagctaatacatggatttcgctacctcaccgagagaccttgcatgaagaatt
+ctaaccaaaagtttaataggccggattggattgagttaattaagaccttgttcagtcata
+gtaaaaacccttaaattttaccgattgacaaagtgagcagtcgcaataccctatgcgaaa
+cgcctcgatagtgactaggtatacaaggtttttgagttcctttgaaatagttaactaatt
+taaaattaattaacgacatggaaatcacagaacctaatgctttgtaggagttatttatgc
+tgtttactgcctctacaaccctaataaagcagtcctaagaatgaaacgcatcttttagtt
+cagaaagtggtatccagggtggtcaatttaataaattcaacatcgggtctcaggatattc
+ggtcatataatttattaagggctcttcgagtcttactctgagtgaaattggaaacagtca
+tccttttcgttgtgaggcatcttacaccgctatcgatatacaatgcattccaccgcggtg
+tcccgtacacaaggaaacttgttaccttggggatataagaaaactcacacgtctcattat
+taaactgagtacaatttttgcacgagaaagtaatgcaatacaatatgatgaaagccagct
+aatgaaaagggatggaacgcacctcggatctgttgcactggattaaaatccgattatttt
+taaaaatattcagtgctagagcatatcaggtctacttttttatctggtatgtaaagccca
+cggagcgatagtgagatccttacgactcaacgaaaagttataacataactcccgttagcc
+aaagcccaatcccgattactgccctaccctaacgtctgccatctaaatatcgaacttgtt
+atgatcaatgtgactacctcccaccctttccccttcatttgttccactggggataagcta
+gcgttttcagaatcaatgcaataagaatagccaattgtctcacttcatcagagctcttgg
+caattccaggcgctacgtggttctggaatatattcatttttcaaatagtaatacgtttag
+tgttgctattgtctacacgtttggatattacgttatgtgagcggacatcaatagttgtct
+aactctttagtaagccagagatagcactcttagcgaatggataccatcttccataagttt
+agttaatagtccgaaacaactgcttcgagcatatttgaacctccttgtaggcaaatagcc
+tcttcaaagcaatcttactaatagatagagtttgttttaagggactactagaaatgggac
+aatcttaatagtatgacctaaactgacatttaaagatatatccaggtggcaagcataaag
+atcattgcgccacctccaccgtgggattacttatcagtcgatatcctatatgctaagttt
+gcgacggcagaatacaaactaagctgagttgatgctaaccttacctatgataccccattg
+gaccggttaacagccctacttattccaaataaaagaacttttatgctgtagaagctatta
+tagtgatgcctggtaacttcagtatattaaaatgacacacatacgccatatagagctcct
+ggaactttgaataatgagcgaacttcgaagttgaagagcaagaaaccatatgtcacggtt
+gcctaaagcccggtaaccagacatgtgctatcattgatcattatcgaggttttcataacc
+ttgacccattatcggctgtgcgcggacaagtacttaaatcactagtttcttcacctgctt
+atcggtaagaaataaggttggcaaagaatcgcataagacggacgtagagccgcagcgttg
+tgcgagtccaggtgcatgcgcagcaataggattttaaattttgttccatttttaatttag
+ccgtaaggatgtccgtaaatgattgaaaattggattcaatctttgggcctatgctactgg
+aacctgatcgacaaaatttcaaacatacgttaactccgaaagaccgtatttttgcggcta
+gaatagtcagtcgcttggagccatataccttaccacttaaacgacgtgctcctgtagttg
+aaatataaacagaacacaaagactaccgatcatatcaactgaagatctttgtaactttga
+ggcgaagcaccctcttcgagacaactaagagtaaagtaccgggcgccgcaaggagtcgat
+tgggaccctaaatcttgacgaattgctaagaggctcagagctaccactgtaatttctcta
+gagcccataataaatgaacgatacatccgtaggtagcacctaagggattataatggaagc
+caaatgcagttaataatattatatactggcgtacacgattcgacggatctctcacatagt
+gattcacgacccccccctttgattgacacagcgtcagcattttgcaagaacgatcttctg
+catagggtgcgccaccgtaaggatgacgtcgaagctacaactgggtataatttaccatgc
+ttccctgatgctgagtgcaatacactaagaatgagtttttaccccatatcaccagtattt
+gttctgttattgcgaagaaatggctatgctgagttggcgactaaagtcacccatcctttt
+tattaggtaaccccctcccttaaactaactgatttgctggagctgccctgcatacatata
+ctttatcatttatggacgtccgtgacgcttattatccaccatagtcgatatgctacacgg
+attcattaatggatcgtaggagtttaagttatatttactaagatcggtctcggctactat
+cccgccttacccggcgctatttacggccatttttaatatattgacggtaattattcctat
+ggtttcgaccgcacgtccttggacaagaaagaatggcaaaaaaaatgtaaaagaaaaaaa
+atattgagtccctaccatcatataaaaaatatgtgatgagtaacttgacgaaatgttagt
+ggttattaaagactatctattacaccttttgttttctgtcgtagtatattaaagtctaga
+agccttacaggaaaatcagggttatacagccgatactccgcagcatgaatcatcgaggag
+gtgtcctaccatcgcgccttgtaatcttgtctgtgtatactgtatttagaccttttatac
+aaagtaaatatctcggctttatgtgattgggaggggcctactcaaacatgatgacttgac
+ctaataatcactgtgcgggcgtcttatgactagctattccttgaaatccaccaccaaatg
+gttaatatgtaaaaactttgacgatgaaacaaggtgaatgtgtagttactttgtgtaatt
+agctgcgtcgagcattgcttgtaaaaccgtcaatcgcacacgttacttccataaaatttc
+tacgaatacacccttcttaaaaaaaacgtaggaattcacgagtttaacaaacgataactg
+tataaagtggaagtccgaagaaagcagatgcccgaactactcgaagatgtttcgttttct
+taaccataggggcttcttaatggcccactacgcacattttgttcaagcccgagagggaca
+tccccattacgggagtattactaaaactgttccgtaatacgttcagcaagggatgaaaaa
+ggccactgctcaagttattgacgtgggagtattacatcggaagcctgaatcccacactat
+gatggtctgtacaggcctagggactgcgtctagacggtattaccggcttctaatcatacg
+atcgtgagtcttaacgggaagtaaggctcacacctaccccaaaccatttatctatgtaag
+tataaaattgtgcgtaagtgttcaaagtggacaataaagacgtggcaaaaacccccgcac
+ataagccgctttagatttcacaaataccaatgcggttaaaaacatccttgagtcgtacat
+acaccatactcgcgttaaacggatataacagaagataataaatccggatgtggagtcggt
+gtaactatagaaagccaagtgaaataatgcttaccagtcatttagctatacggctttcat
+ttcatgtcaagagggtggagtttgacctgtacagttgatatatcaccgatacttagaact
+cacctaaagctaaaattgctcgcagcgtgtaatccgcatattacaaacaatagatgggat
+tcattatacataagacacgatgatctgctttttcaggttgcgagatgttgcctatcgtca
+atcgagtcctgccttacaccacttaaacaaaagtattgacagggaacctattttcgaggt
+attatatagtccagcttgaatatcaatttgacagttaacctagtgaaaatcagtaagagg
+aaatacgccacattctccagtgaaattctacgggttatcgtctagtccaactatcaatta
+taactcacgagatataagtaaattctcgtacttggcctgatttttattatactttggatc
+cttagtaaacaggaagggagaaaccttcaacgaaaaacactggattttgttttactctca
+aagctcttatatgacggaaataccctgtcaagtcttaactttattactagactaatgaaa
+tgggcttggggtggccagaatcatagtacaatttagcggatacactattcggactttcct
+atcggctgtctggttggataagtatggggactaataggctagacatacctatacttaaac
+tatacaggcgtcatctatctctgcaactttggagttccctgatgttctcccgccctttgg
+gttcacatcttctataccgacacccctaataacgattagtttgtgggttagagtaaatta
+atacggttaatattaatgtatcgttgaaaagctggtgtcgccaataaggtaaccggctag
+gcagagtatatgtcacgaagtataactaccctaatgataagctgtaggaataaaattaat
+gctgtctctaagcgaagagatatttccgactctgttttaatgacgaatctcattacttct
+gacttgcaaatgttcaatatggcacggtttcacggcacctttgtgacgcatataatgaac
+ttagaagattataacgacggaactttatatgataatccgttacgattaaagaatctgtta
+aatatcataatggcattcagttctagaccgtgcatcatggtaaacttactttctctgcat
+ggcgacatacatttcgctattcaaattcgcgtgtggttacacccactcgcacctttggaa
+tattaagagaagatgatcagaaaatccattcgctcaatttttctgacgtacgtctaattt
+atcctaggagacaaatcgttttatgtctctcacatttttgaagaaaggttcgagagacaa
+tactcaggtcctgaactgctagaagatactcggtggagcgtggcaacaatgaaaaactcg
+tgacataaatgaatgatacttttccaagttcagttaagtgaatatgtttaacatacccgg
+cttttcgatcttaagctgacgctggacgtgcgagtaatgtcagtctcttacatacactag
+tgactccaagtttcgtcaaaaacgccccctcccttctcgagcccactcacgctatgtatt
+gacgcgaacttgttcgggatcagacttttcaggagttcggtcgcgtgtccctatgtgcta
+atatataagttagatcgcattagatgctaatctgaatacttatagacgaccttcaacgag
+aacgggtaccaccttgaggctagagttaggtgtgaaacgacaggtagggacatataaaat
+ttgagtgcggctttagttaagggtttaattacctactcaaacatcacgctcgcgcccttc
+gtacgtaatcgaccatctagaggctaaggggactgtactaggtagtgattaatgatatcc
+tagacgcacgtgccttagatcttcagactctgatggtccgcgatcaccgtaattgtagtc
+ctccaactcgatcactttgttggcgtcaaagaaattacgatatctaaatacttataatac
+aataaccaaggatgagaatgactcatcgcgttggagttatattgcttgaagttctatgga
+atgaaagcacgttatctgccgtcccaatatctccagtgagctaattcattggacggtcca
+ctttgatcaatccccgaggagatgttcggacactttagtctgtaacacttagcgttgaga
+ccacgaacaattgattactcagtcttgaaggtgttttccaaagttcattttaaataagac
+tacgataggcctttcctattgatataaactacccggctctgttgttcgtgtgagtcgtac
+ttctctgtgtttttctgattatagcaagattcgattcttagtgtaaacagcgatttttat
+ttgacccgtcaatgagaagcgcataggatctaagcaaaattatcaagttgtgccacaagg
+taagatctttccagttattgcaggtaggatgtatcccacgttgatagtatgaggtctgac
+gtcaactgtctaggagagttgaccgcgtgcgggtacaccggatttgcatcgatgttgaga
+acgcagaactcccactgtcgtggcggcgttcctgatatttagcaagaggcgttgataaag
+ccctcatcatctagatctcgacctcatctgccctcttgctccatcattttctacacagac
+tactttcctatctacgttagtataattgctttctatcttagtatcatttagagcttctcc
+gtcaacaggttcgtgctattaaagttagtacgaaagggacaacttgtagcaacgcattta
+atcggttttcgactacttcgcacaaaatcagataaagaagtttgtcattctattagacat
+tgaattgcgcaattgacttgtaccacttatgatcgaacactgaatcaagactgtgattaa
+ctaaaatagacaagccactatatcaactaataaaaacgcccctggtggtcgaacatagtt
+gactacaggataattaattggactggagccattacattctctacaatcgtatcacttccc
+aagtagacaactttgaccttgtagtttcatgtacaaaaaaatgctttcgcaggagcacat
+tggtagttcaatagtttcatgggaacctcttgagccgtcttctgtgggtgtgttcggata
+gtaggtactgataaagtcgtgtcgctttcgatgagagggaattcaccggaaaacaccttg
+gttaacaggatagtctatgtaaacttcgagacatgtttaagagttaccagcttaatccac
+ggtgctctactagtatcatcagctgtcttgcctcgcctagaaatatgcattctatcgtta
+tcctatcaacggttgccgtactgagcagccttattgtggaagagtaatatataaatgtag
+tcttgtctttacgaagcagacgtaagtaataatgacttggaataccaaaactaaacatag
+tggattatcatactcaagaactctccagataaataacagtttttacgatacgtcaccaat
+gagcttaaagattaggatcctcaaaactgatacaaacgctaattcatttgttattggatc
+cagtatcagttaaactgaatggagtgaagattgtagaatgttgttctggcctcgcatggg
+gtctaggtgatatacaatttctcatacttacacggtagtggaaatctgattctagcttcg
+tagctgactatactcaaggaaccactgctcaaggtaggagactagttccgaccctacagt
+caaagtggccgaagcttaaactatagactagttgttaaatgctgatttcaagatatcatc
+tatatacagtttggacaattatgtgtgcgaaactaaaattcatgctattcagatggattt
+cacttatgccttagaaacagatattgcccgagctcaatcaacagttttagccggaaacaa
+tcgaagcatagggacaatgtatcttttcctaaattgccatgtgcagatttctgagtgtca
+cgaagcgcataatagaatcttgtgttgcctcaactcgttgaaaagtttaaaacaatcgca
+gcagtctttttggggtctactgtgtgtttgcaaaataactgaaagaaacgcttgaacaac
+tctgaagtagctcgagtactcattaaagtgtaacacattagtgaatatcggccaatgaac
+caaacgcttcccggtacgctatctctctcatcgggaggcgatgtgcaggttatctacgaa
+agcatccctttacgttgagagtgtcgatgcatgaacctcattgtaacaatagcccagcaa
+attctcatacgtgcctcagggtccgggcgtactcctccatggaagggcgcgcatctagtg
+ttataccaactcgctttttaactactatgctgtagttctacaggcatagtggccagtatt
+ttctaacttctctggatagatgctctcactcctcatccatcacggcttcagtttacgtct
+tacttgcttgttcagcaacggatggaggcattaagtatcttcactgttccctaaaattgc
+tgttcaatatcaaagtaaggacgatacagggaaagctcaagcacactcattgaatactgc
+cccagttgcaacctcacttaatctgacaaaaataatgactactctaagtgttgcggaagc
+agtctcttccacgagcttgtctgtatcacttcgtataggcatgtaactcgatagacacga
+acaccgagtgagaaactatattcttgcttccgtgtgtgtgacaccaggtaattgatgcgg
+atataagctggagatcactcacgcccacacaaggcgctgctacctctttattccaatgtg
+taagaatttgctaacttcatttctagaccgcagctttgcggtcataatttcacggtacgg
+acccttgggttagagacttgataacacacttcgcagtttccaccgcgcacatgttttagt
+ggcttctaacatagaatttttgttgtgacataaagagtgcgtgggagacttgcccgaccg
+ttaagccataatcaattgaaagccccgtgagtcacatctaattggttgtactgcgcattt
+agctatcctttagctgactcgaagagattcgattcctaatataggttaattagatggctg
+ccgcgcgaagtaaaacgtgaaaaacgtagtgcgcagatctgcataactcgcgcttaatta
+cttatgagtagttccaagttcgctacgttatgagagagattggaattaagcaaatatgtt
+ttatggtgattttgggatgagaaggactgctaagtacggctactaaacaaatttctaaaa
+ccgccatctaccttatcttggagacatttaagttgtatatgtcactagtctagcttttgt
+ctgtgggacgcgttctcggaatgagggaaatgcaagagccgattcatcaaatgcttatct
+aagaaagtagtggactattacaccaagcacgaatgccagggaactgctttcttgctcagg
+acctcgcgacaaggtaccccgcataagtcctagaattacatttggtcagcaatgctgaca
+tttgaccgtgaaaacataattttaatcagaaggcagctcacccgcttgctctagatctta
+tctttgtatgaatgtcagaatttactgcaatatccgttccgaatagtgagggcttagtat
+agttctctgtatacaggtcacatcaaactccccctgtcctagtacagctctgagctttaa
+ttaattgcatacatttccttcaatcatcagatgaaaacaccgcgaatcatgctcttctcg
+tatagggcaagagaagcaacaaacaactagcccgactcacgttcatccgccgtatccttg
+ttcagttcttactccgtattaggtcagcgaaatctaatcagaataatcggtcgcgtatca
+aaattaaaatcccgcttgaggttgacaattaaaacgctgagcagttatcggctattagat
+agtggggtgaaagtaattggctggaattatgttaaaacgtgatattaagctaaaatacgc
+tacttgttgccgacctaattcagtcattcgatattcagttagagccaagaataacaagct
+tgtataaattgaacggggtgcactaaacgatgtgttactctaatattcagcttggagtat
+acctgaaggcgaattcatgtatcggccaataataagacgttgaagatcacaatttggact
+agcaaaagaaggtgatttatgcgtggggattgagtccactgtacgagtacggtctctgga
+aaattataggttcagggaatataaggaagtaaagataattaccaagagatttttggtatc
+gctatgacccagaggtgttctaacgtctgttttgatccgcagaatttctgcctcaatgca
+tatttgacggacttgaactagagcctctaaagttaaatggcgacgcaactgttcctaaac
+ttcaattattactactctttttttcctagggtattgtagaggccagtggacaaaataaat
+caaatttaagatgtttcggacattaacatcccccgtagcatagaaatcatcagttatcca
+atctctcatcgagcttttacaatttctgctggcgctatggacagcatatgccgcgagacc
+tccgcaagactcacttgatcactgtaagtatcttcattagaggttagagcctatagttaa
+gctgctgacctagtaaaattggtattttctaattttattgctcaagttaaaggttagtga
+agggataatgacgttatttttgaacaatgggttgtattcaattttatatcacgaatggaa
+cccttcattcccggcataatactagacgacacgaacaagctccgatctatcagccaggca
+cgtgttaaggtttaattccggcaaaccaatgaagcatcaaaaggtgacctgatgcaactt
+agggtcacgatgagtttttcaggactacttattacctattaataagttaacatgagcctt
+cataccccgtaagacaatacatactccaccaattagaattctgagccatcttatcttttt
+gtatcatcgaagggtatggccgaataggttaattagttactcctaacgtctctacaggca
+tgcatttgacgcaccttcgaaaatagtcaatctctcgccacacgcgtctagtatgcagca
+tcaaaaatatagtccacggtttccggattaccaaacgcggcaaagagaaacattgtatcg
+acggagataacttaatacagaaggaaggggcatcttcgaatacggatgaataattctatc
+tgtttattctgacatcttgttttcaggttaatcttacgcattcaaatgacgcctgcccca
+tgcgtgcgcaattattttctaatattgacgagagcaatctcactccttttgggtctattt
+atgttttattgaggcacaagcctatacagaacaggtactattaaggccgtgagtgtgaga
+ctcaaaccgtggaaacaaaggatgggttgttcttggtacaagttttagtgcatgtgggca
+atccttaccaaaatcagatgctatccttaactttgggctgcatttaagatggcggttgga
+ggcctgtgagaatcctgcgtgtcatctttaatgaccgaattcatccatgtagattcagat
+cacacactcattccttgatgttgtctaaacaaaagttgttgtggacgcattggagggagt
+taagtaacaacttgggatcgcatacttataaaaattatatgttaaactttcacaaacgct
+gaagtccaaagtaactagcccaaacgcctcgagagtcactaggtattaatggtgtttgag
+ttcctgtgaaatagtgttcgaaggtaaaatttatgtaccaaatcgaaagaacacttaata
+aggcttgcttgcacggaggtatgatgtttactgactctacaaccctaattttccagtacg
+tacattcattccaataggttagttctcaaagtgctatacaggctcctcaattgatgatat
+gcttcagccgctctatggatattagctcattttatttaggaagcccgcttagaggcttac
+tatgagggaaatgccaaaatgtcatacttttcggtgtgtcccatatgacaccgctttaca
+tagaatttgaattaaaacgcgctctcccgttcactaccatacttggtaccgtgcgcatat
+tacatatagatataggatcattttttaaagctgtactaggtttgatcgacaatcttatgc
+tatactatatgatgtaaccctcataatcaataccgatcgtacgatcctagcataggtggc
+aagcgattttatgccgattattgtgttaaatagtctgtgagtgtgattatcagggctacg
+ttggtagaggggttgtatagacctcgcacacattgtgacatacttaacaatatacgaaaa
+ctgatataataaatccccttacccaaacaccaatcccgttgaatcaactaccataacgtc
+tcccatataaattgcctacttgtttgcataaatctgaatacataacaccattgcaccttc
+ttgtgttccaatcccgttaagattgccttgtcagatgatatgcaagaacaatagcatttg
+ctagcaattattaacagctcttcgaattgcctccacataacgcgggagggtatattttaa
+tttggcaaatactaagtactgttggcgtcatatgctattaacggttggatattaagttat
+gtcagccgtaagcaagagtgggcgaaatattttgttacccagtgagagcactcttagagt
+ttggatacaataggccatatgttgacttaagaggacgtaactacgccgtacaccattgtt
+caaccgacttcttggcaaatagaatcgtattagcaatcttaagaatagagacacgttcgt
+gttagggtatactacaaatccgaaaatcttaagaggatcacctaaactgaaatttataca
+tatttcaacgtggatagatttaacataattcagccacctccaacctgggagtaattttca
+gtagatttactagatgattagtggcccaacgcacttgactatataagatctggggatcct
+aacctgacctatgagacaaaattggaaacgttaacagcccttatgtgtacaaagaaaagt
+aagttgttgctgttcaacagatgatagtcatgacgcgtaacttcactatagtaaattgaa
+acaaatacgcaatttagacagaatggtacggtcatgaatgacagtaattcgaagtgctag
+accaacttaaaataggtaaacgtgcccgaaaccccccttaacagaaagctgctatcatgg
+tgcagtatcgacgtgttcagaaacttgtaacttttgagcaggtccgagcacatggaagta
+tatcacgtgtttctgaaccggcttatccctaagatatatccgtcgcaaactttcgattta
+gtcccacgtagagcccaagcgttgtgcgactccacgtgcatgcccagaaatacgagttta
+aatttggttacatggttaattttgaccgaagcatcgcactttatgattgataattggatt
+caatatgtcgccctatgcgaatgcaacatgatccacaatttggctataagacgtttaatc
+cgtatcacactttgtttgcggctagtatagtaacgcccgtgcaccaagagtcagtaacaa
+ttataagtactccgcaggtacttcaaatataaaaactaatcaaacacgacccatatgatc
+atctgaagatatttggaactttctcgacaaccaccctcgtactcaatacttacactaatc
+gacaggcacacgcaacgtgtacagtcgcaccatattgagtcaagatttgcttagtggcga
+tgagcgtacacgcttatttctctagtcacaattagttatctacgagacatcacgagggag
+caaataagcgatgttatggctacacataggcacgtatgaatatgatataagccagttaaa
+cagtcgaaccatcgagcaaattctcatgcaccaacccacacgttgaggcacaaagagtaa
+gctgtttgaatgtaacttcttctgctgagcgggccccaacgtaaggatcaactagaagag
+aaaactcggtattagtttaaatgcgtcacggagcatgagtgcatttcactaagaatgtct
+gtgtaaccaatataacatctatttgttatctgattgcctacttatggctttgcggtcgtg
+gcgactaatgtctccaatccttttgaggtcggtaccaactccctttaaattacgctgtgc
+aggctcatgcactgcatacatatacggtagcaggtagggacctcacgcacccttattata
+atcaatagtagttatcagtcaacgaggcaggaatgctgaggtcgaggtgttggtatattt
+tctatgtgccgtctaggcgactatcacgcattaccaggcgagatttaagccaattttgaa
+tatagtcaacgtaatttttactatgggttccaccgaaacgccttgcacaactaagaatcc
+cataaaatatcgatatcaaataaaagattgtgtcaataccttcatatatattttttcggt
+tgactaacgtgaactaaggttaggggttttgtatgtctatataggaaacagtttcttttc
+tgtcctactttagtaaagtcttcaagccttactccaaaatcacggtgattaagccgttac
+tcagcagcatgattctgcctgctcgggtcctaaaatccagccttgtaagagtcgctgtgt
+attagctagggagacctttgttaaaaaggatatatcgcggcgggatgtgagtgcgtggcg
+catactcaatcttcagctcgtgtcattataatatctctcccccacgcttttcactagata
+tgccgtgtaagcaaacaccttatgcttaatttcgaaaatattggtacttgaaaaaagctg
+taggggtacttaatgtctggtaggagatcaggagagaattgagtgtaaaaccgtaaagcc
+ctcacctgacttcatgtaaatggcttagaagactccatgatttaataaatactacgaagg
+aaagactggatctaaagataactctagtaaggccaactcccttcaatgctgttgccagtt
+ataatccaagagctgtccttttctgaaccatagcggcttctgaagcgaactagaagcaaa
+gttggttctagccagacagccacataccctgtacgggtgtattactaaaactggtccggt
+attagttcaccaagggaggaattaggcaaaggatctaggtatgcaagtcggagtattaca
+tccctaccctgaatccatcaataggttcctctgtactggccttcgcaatgagtattcaag
+gttgtacagccgtataataataagatagtgactatgaacgggaagtaacccgctcacctt
+ccccaaaacattgttatatctaagtattaaagtctgccgtagtgttaatactcgaaaata
+aacaactggcaaattacaccgcacttaagccgcttttgatttatatttttccaatgcgct
+tttaaaaataattcagtcctacatactaattaagacccttaaacggagatatcacaagtt
+aagttttaaccatctcgactaggtggaactatagatacccaactcaatttatcattacct
+gtaatgttcctagaaggattgcatttcatgtcaagacggtggagtttcacagcgaaactt
+cagtgtgaacagattctgagaaatcacctaaacctattagtcagagcacccggttagaac
+cagttgtcaaaaaatagagcggttgcatgagacagaagtaacgatgagatccgttgtaac
+gttgagacatctggcctatcgtcaatacagtcctcccttaaaaatatttttaaatactag
+gcaaacccaacataggttagtcctatgtgatacgccacatggtatatcattttgtaacgt
+tacctagggataatcaggaagtggaattacgcaaaagtagacagtgaaatgcttagggtt
+atagtctagtccaaagataaaggataaagcacgtcagagaactatattagccgaatggga
+atcattgttaggagactgtggatcatgtctaaaaagcaacgcagaaacagtcatcgaaaa
+aatctcgtttttgtttgaatctaaaagagctttgatgaccgatagtacctgtatactagt
+tactgtattacgtgtctaatgatttcggattggggtccccagaatcagacgtcattgtag
+acgattcaagtttaccaatttaatttcccagctctccttggagaactatcgccaataatt
+gcagtcactttccttttctgaaacgataaagccgtcagagttctctgcaacgttggactt
+acctgaggttctaacccactttcggttctaatagtagttaacgacacaacgaataacctt
+tactgtggggctttcacgatattttttcgcttattattaatggttacgtcataagctggt
+gtccaaattaaggttaccggcttcgcagagtagttgtatccaagtataacttccctaatc
+ataagatcgaggtagaaaattaatgctgtctctaaccgaacagatatgtcccactatgtg
+gtatggacgttgctaattacttctgaagggaaattggtcattatggatacgtgtctacca
+tcaggtcggacgcagatatggttctgtcttcagttgatccaccgttctttataggataat
+aactgacgattaaagattatggtaaatagattaagccaattctcttcttgtcagtgaagc
+atccttaactgacttgctctgcagcccctcatacatttagctattcaaagtaccggctcg
+tttcaaactctcccacctttggaagaggttgtcaacttgataagtatatcatttacagca
+ttttttcggacgtacctctaatgtttcattgcagaaaattagttttttctatcgcacatt
+ttgcaagtaacgttagagacacaattatctgcgaatgaactgctagatctgacgaccggg
+agcctcgcaaatatcaaaaaagactgacatatatcaaggagtcgttgacaagtgctggta
+agtcaattggtttatctgtcccggcgtttcgatcttaagctgaccatgcacggcagagta
+atgtcactctcgttcttacaagtctgtctccaagggtcggcaaaaaagacccctccattc
+tcgagcccactcacgatatgtagggacgacaacttgtgcggcttatgaattgtctggact
+gcgggcgagggtccatatctccgaagttagaagggacatacctttagatgataagatcaa
+ttcttattgacgaaattcatccacaacggggaacaacttcaccctagacttacgtctgaa
+aagacacctagcgtcttataaaaggtcagtgccccgtttcgtaaggctggaattacctac
+gcaaacttaaacctcgcgcccttccttacgtatcgacaagatagaggctatcgcgaatgt
+actacggaggcatgaatcatatactagaaccaagtgcctgtgatattaacaagatgatcc
+gacgcgagcaccgtaattctaggcataaaactccagcaatttgggggccgaaaacaaatg
+acgttagctaattaattatatgacatgatcaaaggaggtcaatcacgcatcgagttcgac
+gtatattcattgaacttcgtgcgtttgaaagaaacttttatgaaggcaaaattgatcctg
+tctcctatttcatgcgtacctcctagttgataattccccgagcagtggttaggacacttt
+tgtcggtatcaagttccggtctcaaaacgtaaaattctgtaatctgtatggatggtctgt
+gaattagttaatttttatgaagtcgtcgagacgcagttcctattgatttattctaaacgg
+agatgtgcttcgtgggactcggaagtagatctgtgtttatgattattgctactttagatg
+ctgactgttaactccgtgttgtttttcaaccgtatatcacaaccgaattggatagaacct
+atagtttcaagttctgccacaaggtatcatatttacagttagtgctggttgcttctttca
+aacgtggtgagtttgtgctatcacgtcaacggtagagctcagtggaccgagtgcgcgttc
+aaccctgttccagagagggtgtgatagcacatataccacgctcgtcgaggcgttcatgat
+agtttgcaagagccggtgttaaacacatattattattgttatccaactaatcggacctat
+gcataaagcattgtctaaacagaataattgcctatatacggtagttttagtgatttatat
+cttagtatcagttagagcttcgaactcttcaggttcctcatatttaacgttcttcgaaag
+cgaaaacttctacaaacgaatgtaagcggttttccaagtagtacctataaatcacagaaa
+gatctgtctcagtatagttgaaatggtattcagctagtgacgtgtaccaattatcatagt
+tcactcaagcaagacgctcattaacgaatatagacaagacactatatcatataataaaaa
+agaacatggtgctcgaacatagttgaattcaccatattgaaggggaatgctgacatgtaa
+ttcgctactagacgatcaattccctacttgtcaaagttgaactggtacgttcttggaatt
+aaatatgattgcgctggaccaaattgcgacttcttgagtttcagggcaaacgattgagcc
+ggaggatgtccgtctcttacctttcttgcttatgataaacgacggtccctgtacatcact
+gggaattctcagcaaaaataattgggtaaatcgagactcgatgtattcggccacaaaggt
+gttagacgttaaagattattcaacggggcgataataggatcataaccggtatgcaagcgc
+attgaaagagccatgagatccttatccgataaacgctgcacggtatgtgcagccttattg
+tcgatcacgaatttataaatgtagtctgggctgtaagttgaagacctaagttataatgaa
+gtgcaataccaaatcgattcatagtggattatcagactcaagatatctcctgataaatta
+cagttgttaagatacggataaaatgagatttaagattagcagcctctaatctgtttcaat
+cccgttggaatgtggtatgcgatcaaggttaagttaaaatcaagcctgtcttcagtcttg
+attcttgttctgccatcgcatgcggtctacgtgagttaatatgtagcttacgttctagct
+tgtgctaatctgagtatagattcgtagaggaatattatcaagcttccacgcctcaacgta
+cgtgtattggtcacacaagacactaaaagtggaagtagcgtaaactatagtctagttgtt
+aaatgctcagttcttgttatattcgatatactcttggctaatttatgtctgagtatataa
+aattaatgatattaacttgcatttcacggatcccttagaaaaagattttgaccgagcgca
+ttataaacggttacaccgaatcaatagaagcatacccaatagctttctttgaatttattg
+cctgcgcaacttggctgactctctagatccgaataattctatatggtcgtgacgaaacta
+gttcattactgtttaaaatgccaacatgtcttttgggccgataatggctctttgcaaaat
+tactcaatgatacgattgatcaaagcggtagttgctagtggtagcatgtaagtctatcaa
+atgtctgattatccgaaaatcttccaaaagagtccacgtaccatatctatctcatagcga
+cgcgaggggaaccttatctaactatcattccatttaccgggtgactctcgatgcaggatc
+cgattgggataaattgcccagaaatggctcattcctgactaagggtaaggccgttctcag
+caagggaaccccgcgaatctaggcttataccatctagattgttaactacttgcctgtagt
+tctacagccatactggacagttgtttctaaatgatcgggattcatgctagcactcctctg
+aatgcaccgcgtaagtttaactattacgtccgtgggcagataaggatggaggctgtatgt
+atcttaactgttacctaatatggctggtaattatcaaagtaaggaccttaatgccatagc
+gctagcaatcgctttgtatactgaccatgtgccaacctctcttaatctgtaaaatataat
+gtcttagctaactgtggacgatcatgtctctgcctagagcttcgctgtatcaattcctat
+agccagcgtactagtgacacaacaacaccgtgtgagaaaagatattagtccttacgtctg
+tctctctacagcttattgatgaggattgaacatggacatatagctccccctcaaaagcag
+atgctacctctttattccattctcgaacatttgccgaacttaatttcgacaaacctgagg
+tcacgtcttaatttatcggtaacgtcacgtccctttgagactggataaatatattaccag
+gggccaacgagcaattgttggaggcgcttctataatacaaggtgtcttgtcaaagaaaga
+cggcgtgcgtctcgtgcaactcacttaaccaatattaatgtgaaacccccctctctcaca
+tcttatgcggtgtactgccctggtacatttcctgtacaggactccaacagtgtagattcc
+taagatagctgttggagttgcctcacgccagatcgaaaaactgaataaactagtgagctg
+agctgcagaaataccgcttaattacttatgactagttcaaagggacctacgtgatgtcag
+acattgcaaggaagaaattaggtttgtgcgtcattttggctggactagcactccttactt
+cccctactattcaaatgtcgtaaacagcatgagacaggatcgtgctgacatttaaggtct
+attgggaacgaggctacctttggtcgcgcgctcgcgttctccgaatgaccgaaatgcatg
+agcacagtatgcaattgcttatagatctaaggtctggtcgttgaaaccaagcacgtaggc
+ctgggaaatcagttcttcctcagcaactacacaaaagcgtccaagcattagtacttgtag
+taaatgtccgaacctatgcgctcatttgaaagtcaaaaaatatttttaagcagtaggcac
+ctaacccgattcctctacttagtagctttctttgattctcagaattgactgcaatatcac
+tgcacaattctgtgccattactagacttctctgtattaacgtctcatcttactaacactc
+gcctaggacacatctgagagtgaagtatttcaatacatttactgaaatcttcagttctaa
+aatccccgaataaggctcttatcggtttggccaacacaagaaaaaaacttcttgcaccac
+tcaccttcatacgcaggagcctggggaacttagtaataactatttcggcagacaaagctt
+ataacaagttgccggcgcgtataatatttaaaagaccccttgagctgctcaattaaaacg
+ctcacctggtataggctattagatagtgccgtcttagtaaggggcgggaattatcggata
+aactgatattttgataaaataaccgacttgttcacgacataagtcactaaggagatttta
+tctttctccaaagtatatcttccttggataatttcaaagcgctgcaatttaagttctgtt
+actagtttatgctgctgggaggtgaccggaaggcgtagtaatctagaggcaaattataag
+aagttcatcatatcattttcgactacaaaaacaaggtgttgtatgccggcgcattgtgta
+aactggacgagtaccctagatggaaaattatacgttaagccaagatttcgatgtaatgat
+aattacctacacatttttgctatccataggaacaagagctgttctataggctcgtggcat
+acgaacatttgctgccgctatgaatattggaagctcttcaactacagactctattcttaa
+ttgccgtcgaaaatgggccgaatcggctattattaatactcggtttttccgaggggattg
+ttgtcgacagtcgtaattattattaatattgatgttggtgaggtcatttaaatacaacct
+tgcagacaatgaataagggatccaatctctcatactccttttacaattgctcatgcccct
+atgcaaaccttatgccgccacacctccgcaactctctcttctgaactgtaagtagcttca
+ttactggtttgagactatactgaagctgatgacattctaaaatggctattttcgaatgtg
+attcataatgtttatcgtttgggatggcagaatcacgttatttttgatatagcccgggta
+ttctattgtatagaacgtatgctacaagtcattccccgaagaagactagaagtaaacaac
+atgcgaccatcgttaagccacgcaaggctgtagctttatttcccgataacctatcttcca
+taaatagcggacagcaggatactgacgctcaacatcagtggttatggtctaatttttaac
+ttttaataaggtaacttcagcaggcatacacagtaactctttaatttataatcaaattag
+aagtctgacacttcttatatttttctatcatccaacgcgatcgcccattagcttattgtg
+ttactaataacgtatctaaaccaatccttttcaagctactgcctatattgtcaatatata
+caaacaacaggatagtaggctgcttaaaaaatattgtcaaccgtgtacgctttacaatac
+ccggaaatcacaaactttgtagacaacgagtgaaatttatacactacgaagggccagcgt
+acaagacccatgaattaggcgatatgtttattctgacatattggtttatccttaatctgt
+cgctgtaaaatgaagccgcccccatccctgcgaattttttttcgaagattcacgactgaa
+atataaatacgtttggctatatttatgttggagggaggcaatagcctttactgttaaccg
+aagatttagccagtgagtgtgacactaaaacactggaataaatgcaggcgttcttctggg
+taaaaggtttagtcaatctcgcctataagttcatatagctctggatataattatctggcc
+catgcatttatcatggcgcttggtgccctgtgtgaagccggcctctcatattgaaggtcc
+gaagtattccatgtacattaagatcactctctcattcatgcatcttggcttaacaaatct
+ggttgtccaagctttccaggcacgtatggtacaaattcggatcgaatacttataaaaatg
+atatgttaaactgtctaaaacgctcatctacaaagtaaagtgcactaaccaatagagtct
+caagaccgtgtaatgctggtgcactgaatgtgtaatacggttagaagggattagttatgt
+tacaaatccattgaaaacttaagaagcattgcgtgctcggagggtgcatcttttatcaag
+agactaacattattttcaacgacgtacatgctttacaatagggtacttatcaaacgccga
+gaaacgcgcctatagtgatgttatgattatgacccgatatccattggaccgaattttatg
+taggttcccagcgtactcgcgtaatatctcggtattgccataatgtaatacttgtcggtc
+tctcccagatgaaaaagcgttacagagtatttcaatgaaaaacagcgcgcaacgtcaata
+cctttaggggtaacggccgctgatttcatatagatatacgataagttggtatagctctac
+taggtggcatccacaatcgttgcatttactatagctggttacaatcataatctataccgt
+tccttacatactaccatagcgggatagcgtttttttgccgttgattgggtttaagaggat
+gtcagtctcattatatccgattcggtgggagagccgttgttttcaaatcgcacactttgt
+gacataatgtacaagataacaaaactgatataagatataaactgtcaatatcaccttgac
+acttgaatcaaagtaaattaactcgcaaatataatttgactaattgggtgcagatttctc
+aattaataaaaaaatggcaccggatgggcttacaagccccttatcattcacttgtatcat
+gatttccaagaacaatagaatttgctagcaagtatgaacagagattcgaattgcatccac
+agtacgccggagcgtttattttaatgtggatatgacgatgtactgttggcggcatttgct
+agtaaccggtccttatttacgtagcgcacacgtaagcatgtctgggagaaatatggtggt
+acaatctcagagaaagattacagtttggtttaaataggacttatcgggtcggaagtggaa
+cttaataagcagtacacaattgggcaacagacgtcttgcctattacaataggattacaat
+gcgttagatttcagacacgttcgtgtttggctattcgtcaattccctaaatagttagacg
+atcaactattatcaaagtgattctttgttcatcctccattcatgtaacagatggcacact
+acgcataacgccgaggaattttaacgagatttaagagagcagttcgggcacaacccactt
+gactttataacagctcggcagcataaacggtaatatgtgacaaatttccaaacgttataa
+gaacgtatgtgtacttagaaaactaagtggttcatgttcaacagatgtgacgcagcaagc
+ctaacttatctattggttttgctataaaagaacaaagttacacagaatcctaagggcttg
+tttcacacttatgcctagtgcttcaccatcttaaaatagcgaaaccggcacgaatcaaac
+cttaaaacaatgcgcagatattggtgatggtgactccgggtatgataatggtaactgttg
+accagcgcccacctcatcgaagtatagaaagtggttaggataaggatgagaccgaactta
+tttccggccataactttagattttctacctagtacacaacatcagggcggacacgaaacc
+gccatcacatcatataccaggtttaatttgcttaatgggggaagtgtcaacgaaccttcg
+aactttagcaggcatatggccattatatatggccccagagcagaatgctacagcagacaa
+aatttggatttatgtagtttaatacctatcaaacttggtgtgaccatacttgtctaacga
+cagtgcacaaagtgtaagttacaattattactactcagcagcttctgcaatgataaaatc
+ttatcatacacgtcacatatgataatatctacttagggggaacgggctccacaacctaca
+tagtactcaatacttacactattcgacaggcacaccaaacctgtacagtcccaaaagatt
+gagtcaactttgcagtactgcagatcacagtaatagcttagttagcgagtcaaaattagt
+tttctacgagactgcacgaccgtgcaaatttccgatgtgttggctacaaatagcaacgta
+tgaatttgtttgaagccacgtaaactgtacaaccttagagataagtctcaggctactaaa
+aacacgttgtggcactaacaggatcatggttgattcttacttattcggctgaccggccca
+ataagtaaccttcaactagaacagaataatcgggagtagtttaattcagtcaaggtgcag
+gtctcattgtaactaacaagctctgtgtaaccaagttaaaatcgttttcttagcggattc
+cctacttatggatttgagctcgtccacaatattcgatacaagaagtttgtggtccgtaac
+aacgaaattttaattacgctgtgcagcctcatccaaggaattaatagaaggttgatggta
+ggctccgaacgctccatgattataatcaagtggactgtgcagtaaacgaggaaggtatcc
+tgacgtcgtggtgttcgtttttgttatttgtgccctatacgagtagataaaccatgaaca
+gcacagtgtgaacccatggttgattttaggctaccttatttttaatttccgttacacaga
+aacgaattccacaactaacatgccattaatttttcgatatcttataaaagatggtcgaaa
+ttcattcatttattttttttcggttctcgaaagtcaactaagctgtcgcgttttgtttct
+ctttagaggtaaaagtggctttgatctcctacgtttggatactagtcaaccattactcca
+tttgatccgtgagtatcacctgtctaacatccagcattatgactcctcggcgaagaaaag
+acacacttcttagagtcgatgtgtattagctagggacacagttgtttaatacgatagtga
+gcccagggagggcagtgcgtcccccagtagatttattcagctagtgtaagtataagatat
+ctcacccacgaggttcaagtgatatgcagtcttagaataatacttatcctgaatttcgat
+attatgggtacttcaataatccgctagcgctactttatgtctcgttggacagcaggacac
+atggcagtcttaaacactaaagacatcacctgaatgaatgtaatgggattacaagaatca
+atgaggtattatatacgacgtaggaaactctggatatatacagtaatctagttacgccat
+cgcacttcattcctctggaaacttagaagacatcagctgtacgtggaggaaccagacccc
+cgtatgtagccaaatagaaccaaagttgcttatacaaacacacccaatgacaatggaccg
+ctggagttcgtaaactcggaacgtagtactgcacaaacccagcatttagcaataggagct
+acgtatgcaactcccacgtggtaataccttcaagctatcaatatataggtgcctagctaa
+tcgcattcgcaagcagtattcaagcttgtaaaccagtataataattacagaggctctatg
+aaacccaactttccagctaaaagtcccaattaaatggttatttcgtacttttaaagtcgc
+ccgttctgttattacgcgaattgattctactccaaaattaaacacaaattatcaaccgtt
+tcatttatatttgtcaatgcagctgtttaaaataaggctctactaaattataattaagac
+acttattaccagatttctctagttaagtttgaaccagctcgactaccgcgaaagatacat
+tcccttctctatttttcagttcatctatgggtcagagaagcattgaatttattctattca
+ccctcgtcgttcacagcgaatcgtcagtgtgatcagtgtatgagaaatatcctaaaccgt
+ttagtcagaccacacgcttagaacaagtggtctaaaaagactgccctggaaggagtaaga
+agtatacagctgatccggtgtatccttcagtcatctgccctatactaattacacgacgca
+aggaaaaataggtttattttctaggcaaacccttcataggtgactccgatgtgttacgaa
+tcatgcttgagaatgtgctatcgttaccgacggataataacgatctccaatgaaccaaat
+gtagaatgtctattgattacccttttactattcgacttagagataggagatagaacctca
+gtgtacttttttagccgaatgggaatctttgggaggtgaatggccataaggtcgtaaatc
+caaccctcttaaagtcttccatattatatcgttgttcgtggaatcgataacagatttgtt
+gacccatagtaaatgtatactagtttatgttgtaagtgtagattgttttccgattgccgt
+ccaaactttatgtcgtaattgtagaccagtaaagttgaccaaggtaagtgcccagcgatc
+ctgcgagatcgatcgccaatttttccagtcactgtaagtgtaggtttagataaagccgta
+tgagttatatcataagggcctcggaaagcagcttcgaaccaaagttcccttataatagta
+gtttaactataaaagtatatactggtctgtcgccctttcacgatttgttttaccggttta
+tgaagcgttacgtcattagagcggctccaatttaaggttaacggcttccatgtgtagttg
+tatacaaggataacttaaagtatctgttcagcgagctagttaagttatcctcgatagaac
+acaactcagaggtcccaagatcgggtttgcaacttgctaatttattctcaaggcaaattg
+ggaattatcgatacctgtataccataaggtcgctcgatgtgatgcttatgtcttctggtg
+atcctaccttagttagtgctgattaacggaacattaatgtttatcgttttgagatttagc
+caattctctgattctaactcaagatgccttatctgacgtgctatgcagcccctaagtatt
+ttacattgtaataggacacgctcctttaaaactcgccaaaaggtcgttgtggttctctac
+tggttaactatataatttacagctttgttgagctagttcctctttggtttaagtcctcaa
+tattagttggttcgagcgataagttggctagttaccttagtcactatattagatccgaat
+gttatgcttcatctgaagaccgccaccctccaaaatttcttttaagactcacttattgca
+aggtgtaggtgaattcggctcgtttctcaagtggtgtatctgtacacgagtttccatatt
+ttcatcaacagccaccgcacacttatgtcactctaggtattaaaagtcgctctacaaggg
+gacgcaattaagaaacagacatgctagtcaaaaataaacatagcgaggcaccactaattc
+ggccgcttatcaatgggatgctctgcgcgagacgcgccagagctcagtagttagttcgga
+catacatttacttcagatgatcaattagttttctacaaatgcttactctaccccgaaaaa
+agtcaccagactcttacgtctctttagtatccttccgtcttatataaggtcagtcccccg
+tttcggtaccctggaatttactaagaataatgaaacagcccccaaggacgtacgtttaca
+aatgatagaccagatcgcctagcttattccgacgcatgttgcatagaattgaaccaacgg
+aatgtgagagtaactagatgagccgaccacagcacccgtttgcgtcgcagaatacgcctg
+atagttcggccacgaaatcatatgtcctttgagtattaagtatttgtaatgatcaatcga
+gctcaagcaagcttacacttcctcggatattcagggaacttagtgcctttgaaagatacg
+ttgatcaacgaaaaattgataatggctcatatggaatgcctacctcatagtgctgaatta
+acacagcactgcggacctaacttttcgaggtttcaagttcacgtctcaaaacctaatagg
+ctggaatatgtagggatcctcggtgaatttgtgattgggtttgttgtagtactgaccaag
+tgaatattctttttttctaaaagcagatctgctgccgggcactacgaaggagatctctgt
+gtatcattattgcttcttgacatgatgactcttaaatcactgtgggtgtgcaaaacgata
+gcacaacccaattcgatagtacatattgttgatacttcgcactaaaccgttcatatttaa
+aggttgtgctccttccttcgttaaatactggtgacttggtcctatctactattagctaga
+cctctggggaaccacgcccccgtaaaacctgtgcaagagagggggtcatacatcttagac
+atcgcgcctccaccagggaagcattgggtgattgaccaggtgtgtaacaaatatgattat
+tcttatactaatattagcaaagatgcataatgatttgtattaaatgtataattgaattga
+taagggtcttttagtcagtgatagagtagtataaggtagacattagaactcttaaccgga
+cgcagatttttcggtcttagtaagccaattagtcgacaaaacaaggtaagagcggttact
+agtagtacctataatgcactgaatcttcggtcgaagtatagttctaatgctatgcagatt
+gtgacggcgacaaatgttcagacttatatcatgaaacaagctcttgtaagtattgacaaa
+tgaaaagattgaatatttttaaatacaaaatgcgcctacttattaggggaattaaccaga
+ttgaaggccaatcctcacatgtaatgagataatagacgataaatgaaattcttgtaatag
+ttgaactgctacgtgatgggtattatatatgattgagatcctccaattgccgacgtcttg
+tcttgatgcccaaaagattgtcaacgaggagctccctcgcgtacctgtcgtccgtatcat
+aaacgacgcgacatgtacagcactccgaagtataagcaataataatgcgggtaatccaga
+ctagatcttttcggactcaatgcggtttcacggtaaacatgattaataccggagagtagt
+cgagcttatcagcgatgcaagcgaattcattgtgccaggagatacgttgcagataaaacc
+ggcaacgtatgtcaacaagttttggcgatctcgttgtttgtattcgacgaggcgcgggaa
+cttcaagaactatcgtatattcaagtccattaccttttagtttcagactggtggagctga
+ctaaagttatatcatcattttgtacactggtttagttaacgataatttcagatttaacat
+gaccagacgataatcgctgtatatccagttggaatgtggtttgccagaaaggttaactta
+taatcaagcctctcttcagtcttgattcgtcgtatcccatccattgcgctatacctcagt
+gtatttggagctgtagttataccgtgtgctaagatcagtagacatgacgagagcaatatt
+atctaccttacaagcatcaacggacgtctagtcggaacaaaagactctaaaactcgaact
+tcaggttaatatactatagttctgtattcagcagttattcttatattcgatattatcttg
+cctattggatgtctgactttagtatattaatcatagtatctgccatgtaaaggtgccagt
+actaaatctgtttcacagtgcgaattataaacggttacaaccattaaagacaacaagacc
+ctatagctttatttgaattttgtcaatgcgcaacttggagctcgcgatacatcccaatta
+gtctatagggtcgggacgattctacggcatttctggttataatgacaacatggattgtgg
+cccgagaatcgctctttcattaattaagcaatcattacagtcttataagcgctacttccg
+agtggtagcaggtaactcgatataaggtcgcatgagccgaatagcttaaaaaacaggcca
+ccgaacattgatagagaataccgaccacagcgcaacctttgattactttcattaaattgt
+acggctcactcgacatcaagcttaagattgcgataatgtgaactcaaatggatcagtact
+gaagaaccgtaacccacttcgcagaaagcgtacccagagaagatacgctgttacaatata
+cagggtgaaattattgcctgttcttcgtaaccatttcgccaaacttggttagaaatgata
+gccattcatgatagaaataagctgaatgataccagtatctttaactatgtagtcaggggg
+aagataacgatggtccatgtatgtttctgatatgtgacagtattggccgcgtaatttgct
+aacgaagctacttaatgcctttgagcttcatatagatttctttaatcaaaatcggcaaaa
+agatagtatgagctataatatatgctagtagagaactctggaccatcatctatatgaata
+ctgattcgagcgtgcaattactttagcctgcgtactactgactctacaaaacactctgag
+ataagtttgtagtcagtaagtcgctctctataaaccttttggatgaccattgtacagcca
+cttatagatcccaataaatagcacaggagacagagtttttcaatgctcgatcatttgccg
+atagtattttcgtctaacctcagggcacctattatttgatacctaacctaacggcccttt
+cacaatggagaaatatatgacatcgggacaaacacaaatggtgggtggccaggagatatg
+acatggtggcgtctctaagaaacacggactccctctaggcaaactcacgtaaccaatttt
+aatgtcaaacaaaacgctcgaaaagattttgccgtgtaatgacctggtacattgactggt
+caggaatacatcactgtagttgccgtagtgtcctgttggtgttccatcaagacacatcgt
+ataacgcaatttacgacggacatcagatcaagttatacagattatttaagtatcacgtgt
+gcattgggacataagggatctcacacatgccttggaacatttttgctttgtgccgctttt
+tcgctgcactaccaatccttacttaccagtatattcaaaggtcgttaacagaatgagaaa
+ggttagggctctaagttatcgtcgattgggatagacgagacatttgcgagcgccctccac
+ggatacgaatctcccatatcaatgtgaactggatgctatgcagtttagttcttacgtctc
+ctagtggtaaaaatcaaagtagcactcgcatagcagttattcagaacctaatacacaaaa
+ccgtcaaacattttctaattctaggtatgggccgatcataggagctaaggtgaaactcat
+aaatgttttgttagatctagcatcctaaaaagatgcatatactgagtagctggcgtgcat
+tctctcaattgtatcctttttaactgaactagtcggtcccatttcgtgactgagatctat
+taaccgataagattaataacactcgcattcgtatcagctcagagtgaagtttttcaataa
+tttgactgatatattaacttctaaaataaccctttaagcctcggatccgtttcccaatca
+catcaaaaattcttattccaactatctacggattaacaacgtgcatggggatcgtagtaa
+gaacttgttccgatcactttgagtatatcaagttgacggcccggttattattgaatagaa
+acattcacctgctaaattaaataccgcacatcggatacccgatttcagagggccgtctta
+ctaagggcaggctttgttcggtttaactgagatgttcattattttacagtatgcttcaac
+taatatgtaacgaaggacagtggatctgtctccatagtagatcttcagtcgtgaatttca
+taccgctcctatttaagttcgcgttcgagttgttgatcatggcacgtgaaagcaacccct
+agtattctagacgaaaattttttctagttcatctgataatttgccaattcaaaaacaacc
+gctggtttcccggcgcattctctaaaatggaagtcgaacctagagccattatttgtcggt
+aacccatgagttccttcttttcagaagttaatacactgtggtcctatacagaggaaaaac
+agcggttatatacgatcgtggcataacaacattggatcaagatagcaatttggctaccta
+ttctaattctcactagattcggtattccactacaatatcggcagattaggattggatgaa
+taatcggtgtttaagtccggttgcgtctccaatctcctaatttttattaatattgatctt
+ggtgacctattgtaaataaaaacttcaagactttgaataacggtgaaaagatagaagact
+catttgaaaatggatcatccacagatccaaacattagcaagacactaatccccaactagc
+tattctgatcgcgatcgtgctgcagtactcctgtcacaatagtctgttcatgatctaatt
+ctttttgggctttgttcgatggtgattcagaatctttatccggtcgcttccctgtagcta
+ctttgtggggatattgcccggggattatagggttgagatcgtttcctaaaagtatttaaa
+ccaagtagacttcaactaaactacatcagaacatcgtgaagacaccatacgcggtacctt
+tatttaccgataacatttcttcaagaaataccggtaagcagcataatgaccctaaacagc
+tcggggtatcgtcgtagttttaaattttatttaggttactgctcaaggaataaaaactaa
+ctatttaatttataataatattacaaggctcacactgattagatttgtctataagacttc
+gcgatcccccattaccggattgtcttaagaataaactagataaaccatgcattttctaga
+taaggcctttagtctaattagatacaaaaaacacgatagttgcatccttaatttattgtg
+tcaaacctggaaccttttaattacccgcaaatcactttatgtcgagactacctctgaaat
+ttattatctacctaccgcatgaggacttgaaccatcttgtaggagttatgtttattagct
+aagattcgtttatcctgtagcggtccatgtatattcaacaagcaaaaagcactcagaatt
+gtttttagttgagtcaagactgatatataaataagtttccctagttttttcgtggtggga
+cgatattgaattgaatcttaaccgaagagtttcccactctgtcgcacaataatacacgcc
+aatatttccagccctgcttatgccttaatcggttactcaatctcccattgaagttcattt
+tgatctgcatagaagtttcgggcccagccttttttctgccaccttcctccaagctctgta
+gacgcactctaagattgatgctcacatgtattaattctacattaacataaatatataagt
+catgcatcttcgagtaaaatatctggttctccaacatgtcctggcacgtatcgttataat
+gcccatacatgtagtattaaaatgattgggttaactggatattaagatcatcgaaattgt
+aaagtcaaattaacaatactgtctcaagaccgtgtattcctcgtgctcggaagggctatt
+acgcttacttccgttttggtatcttaatatgactttcaaaaattaagttgcagtgagtcc
+tacctgcgtgcatcggttagcaagagtataaaagttgtttaaacgaactacttgctttac
+aataccggtcgtatatatcgccgtgaatccagaagattgtcttctttggattatcaaccg
+agatcctgtggaccgatgttttgggaccttcacagaggactccaggtagagctcgctttt
+gcattaatctaagaattgtacctctctaaaagatctaaaacagtgaatgtgtatttcatg
+gaaaaacacagagaaacgtaaattactttaggccgaaaggcacatgagttattatacata
+tacgagatggtggtatacatcgaattcggggcatacactatagttgcattgtatttagct
+gctttaaataatatgatattaccttccttacataagacattaccggcataccctggtttt
+caacttgtggggctttttgacgatcgcactctcatttgatccgagtagggcggtgacccc
+tgcttttcaaatacaaaaatttcgctatgaaggtaatagattacttttcgctgttatgat
+agaaacggtaaatttaaaattgaaacttctagaaaagtaaagtaacgagaaatgattttg
+tgaataatgcggtcatgattgcgcaagtaagaaaaaaaggcaaaaggatgcgcggaatag
+aaacttatcagtcacgggtatcttgatttcattcttcttgtcaattgccgacataggatg
+aaatcagattccaatgcaatacacagtaacccccacccttgattgtaatgtcgatttgaa
+gttgtacgcgtcgacgaagtggatagtatacgggccttttgtacggtgcgatcaactatg
+aatctcggcgagttagatggtcgtacaatctcacacatagaggtcacttgcctgtaatga
+cgaattttcggctaggtactcgaactttattagaagtaaaaatgtgggcaaaagaaggat
+tccattttacaagacgattacaatgagttacatgtctctcaacgtagtctttccctagta
+gtctttgaactatttaggtactccagaaaattttagcaaagggtttctgtgtgaatccgc
+cattcatgtttatgatggaacaataagaataacgccctcgtatgttatcgacagtgaagt
+cagcagttcggccaaaaacatattcaatttagtacagatccccagaagttaagctaagtg
+ctctaaaatggcctaaacggttatcaaagtaggtctaattactatactaacgggtgcatc
+gtaataactgctgtcgatgcaacactatatgatagtgtcgttttgctatatatgtacaat
+gtgacaaagaagccttagcgattcttgcaaacttaggacttcggattctcaatcttaaat
+gtccgaaaacgcaaagattcaaaaatttaatctatgagcagatatgcctgatggtgacta
+cgcgtatgttaaggctaaatgttgacaaccgcacacataatcgaactattgatagtcggg
+agcataaccaggtgaacgtactttgttcacgacatttattgacatgttctaaatacgtct
+caaaatcacggcgcactagaaaacgcaatcaaatcattgtcctggtttaagggccgtaat
+gccggtagtgtcaaacttcatgagaactttagctggcttttggccagtatttagggacca
+agagcactagccttaagctgaatattttgccatttatctactgttataactttaaaactt
+ggtggcaccagacttgtcgatacacacgcatcaatctgtaacgtaaaaggtttactaaga
+acaagcgtaggaattgagtttatattatatttaaactaaaagatgatattagcttctgag
+ggcgatagggctccaaatcataaagaggaatatattattacacgattagaaacccacaac
+atacctcgaatcgcccaaaagtttgacgaaacttggcagtactccacatctcagtaatac
+agttgggagagtctcaaatgttgttttattactcaatgaaccaccctcataatttcactg
+ctgttccattaaatttgcaaacgatcatttgctttgaagaaacgtaaaatcgacaaaatt
+acagataagtagatgcataataaaaaaaactgctcgctataacacgatcatcgtgcattc
+ttacttaggagcatcacccgcacaataacgtaccttaaactacaacactattagaccgag
+tactgtaattcacgaaagctcaagctcgcattgtaaagaacttgctctctcgtaaaatgt
+gataatagtttgcggagaggattcaattattttccattgcacctactccactagattcga
+taaaagaaggtggtcctcccttaaaaagaaatgttaagtaacatcggaaccataagcaaa
+gcatgtaagtgaaccgtcatccttccctaagaaacataaaggtttttaataatgtcgact
+gtgaactataactgcatcctttcctgacctactccggttccttgttgttatttctgaacg
+agaccagtagataaacaatgtaaaccacagtgggtaccaatggtgcatgtgacgctaccg
+ttgttttaagtgcccgtacaaacataagaagtcataatcttacttgaaattaattttgcc
+ttttattttttttcaggctcgaaattaatgatttgttttttttgaccttctagttacgct
+aatatgcggtcgcctgtggtttctattgagtcctataacgggatgggatctaatacgttt
+ggttactagtaaacaaggtataaatttgataccggagtatcaactgtataacatcaagct
+ttatgactcatacgcgaagtaatgacacaaggctttcaggagatcgcgagtacagagcca
+ctaaggggtgtattacgatagtgacaccaccgagcgcactcactccccaagtagatttat
+gatcctacgctaagtattagatatataaccaaagaggttctagtcagtgcaactcttaga
+ataataattagccggttttgcctttttaggcctaatgcaatattcagctagcccttatgt
+atctcgcgttccacagcaccactcatggcacgcgtttaaactaatcaaatataatctatg
+aatgttatgccagtacttgaataaatcaggttttttataagtccttgcatactctcgtta
+tatactgttagagtcttaccccatagaaattctttcatctgcaaacttagaagaattctc
+agctacggggagcataaagtccccaggatgttgacaaatacaacaaatgtggcttataca
+aacactccatatgaaaatcgaaccctcgtggtagttttagccgaaccttgtacggataaa
+tccctccattttccaatagcagatacctatcctactacctcgtggtattaaattaaagct
+tgaaatatagagctgcatagcttatccaattcccaagcacgagtctaccgtcgtaaccac
+gatttgatttacagacgctagagcaaacccatctttaaacatataagtaaaaattaaagg
+gtgagtgcgtacgtgtttactagcaacttcgcttattaagacaattgtttataagccata
+attaaaaacatatgttcaacaggttcattgatatttgtaattgcacaggtttttaataag
+gatctacgtaagtataatgaacaaactttttaccagagttatattctgtactttgaaaat
+gctcctctaccgccttagagactttcaattagattttttgcagttaatctatgcgtaagt
+gaaccatgcaagggatgcgattcaaccgcctcgtgctaaccctatcgtctgtctcataac
+tgtaggtctaatataattttcagttttcgaacacataaccctttgaaaatctgctattta
+atgtctcacctgcatgcactatcttctatactgctcagaacggctatacgtcactatgct
+ccaagtgacgatttaaacgaagcaaggaataataggtttattttagtgcaaaacaattaa
+gtgcggactacgtgctctttacaataagccttgtgattgggctataggttaagtcccata
+ttaacgatctccaatgtacaaaatcgacaatcgctttgcattacccggttactagtcgaa
+ttacagatagctgttagatactcactctaattttggacaacaatcccaatcttggggtcg
+tctatcgcctgaagctcgtaaatccttccatcttaaacgattacatattatagacttgtt
+cggggtagagatatcacagttgtgcaaacattgtaaatcgatactagtttatgttggtag
+tctagttgcttttaccattccccgaaaaacttgatctactatttcgacaacagtaaactt
+gaactaggtaagtgaaaacagagaatgcctcatagtgccactatttgtccactatatgta
+agtgtagctttacataatccactatgactgagatcattacggcctaggaaagcagcgtag
+aaaaaaagggcccggatattacgactgtaactataaaactagttactggtagcgcgccat
+gtatagatttgttttaccggttgtggttgcgttaacgaatttcagccgcgaaaattgatc
+cgttaaccagtccatctcgacttctataaaacgataaagtaaagttgatgttcagcctcc
+ttcttatggttgcatcgagagtacactactcagtgggaaatagatcggggttcctacttc
+agattgtattatctaggcaattgccgattgtgccatacctggataaaataagctacctac
+atgtgatgcttatctattatcgtcatactaccttagggtgtcctgttgaacgctacatta
+atctttagccgtttgagatgttccaatggataggagtctaacgcatgatgaagtttagga
+aggcagagcatcccactaagtatgtgacagtgtatttcgaaacgagacgttataaataga
+aaaaaggtccttctggttctattctgctgaactattgaatggaaagattggttgacctac
+gtactatttgcttgaagtcatcaatttgacggggtgagagacatatggtgcatactttac
+ggactctatattttagatcagaagcttagcagtcttctctacaccccctcacgacataat
+tgcttttaagaatctatgtttgattcctctacgggaattcggatccgttcgcatgtgcgg
+tttatctaaaccaggggacatatgttcagctaaagcatacgaacactttgctaactagac
+gtatgtatagtagctataaatcccgacgatatttacaaaaagaaatgagactcaaatata
+tacatagcgaccctacacttattcgcaccctgatctaggcgatcctagcacccacacccg
+aaagtgagcactagtgtcttccgtattaaatttactgcagttgagattttagttgtctac
+taaggattactctaacccgtaataaggatcaagactcggtactagctttactatcattcc
+ctatgtgttttcctaactcacaagggtacgtaccagcctatgtaattacaataatgataa
+agacacaaaggaagtaactttacaaatgagtctccagttacactagcttagtccctccca
+tcttgctttgaagtctaaatacgcaatctctgaggatatacagcagaagaacactcataa
+cgttggagtccaagaattagactcatagggcccccaacatttaatatgtactgtgagttt
+gaaggtgttctattgttaattcctgctcttgatacatgacacgtactccgtgtttaaggc
+ttcggactgactttctttcataagttgagcaacgaaaatttcagaatcgataagttggat
+tcactaactaatacggctgattgaaaactccactccggacctatatggtcgacctttata
+cgtaaccgatataaaacttataggctggtatatcgagccttcctagcgcaatttcggatg
+gggtttcttctactactcaacaacggaatagtctttgtttagtaaaccagagctcaggac
+gcccaatacgtaggagagcgctgtggagcatgtgtcattatggactggagcactcttaaa
+tcactctgcgtgtgctaaacgatagatcataacatgtcctgagtaaattttcttgatacg
+tcgcaatataccgttattagttaaacgttctcatccgtcatgcgtgaaatacggctgtcg
+tgctcagatatactattagcgactcatctcgcctaacacgcacacgtataaactcggaat
+gactgccgctcttacatattagaaatacagactacaccacggaagcattgggtcattctc
+aaccgctgtataaaagatgattagtcttataataagattaccaaagaggcagaatcatgg
+gtagtaaatctattattcaagtgattaccgtcgtgtaggcagggagtgaggacgagatgg
+tactcaggacaaatattaaccggacgaagtggtttacgtcgtactttcactattagtagt
+aaatacaaggtaacaccggggaatagtactaaatataatgatatctatcttcgggagaac
+gagtcgtctattgctttgaacattctcaaggcgtaaaatgtgctgacttatagcatgata
+caaccgattgttacttttgtctattcaaaagattgaatagttttttatacaaaagccgca
+tacttatgacggctagtatacagtttcatcccctagcatcaatgctatggacagtattga
+acttataggaaattcttctaatagggcaaatccgtcgtgatgcctattttttttcagtca
+catcctcaaatggcactagtattgtcgggatcccattaacaggctcaaccacgagctcac
+gcgaggacatgtagtccgtatctttaacgaagcgacagcgacagaactcccatggataac
+caattataaggcccgtaatcctctagacatcgtttaccaataaatccgctttctccgtaa
+tcatgttgaataccccagagtagtccagatgataaccgatgaaacacaagtctttctcaa
+tgcacttacggtgaacttattaccgccaacgtagctcatcaaggttgcgacatctagttg
+tgtgtttgcgacgagcccagcgaacttcatcaactttcgtatattcaacgccttgtaatt
+ttactttaagacgcctggtgatgtagattcttagataatcagtttgttatcggctgtact
+ttaccataatttcacaggtttcaggtcaagaagattatagctgtatatacagttccatgc
+tcggtgcacagaaacgtgatcggataataatcaatcgcttatgtcgtctttaggcgtatc
+caatacatgccccgataccgcagtgtatttcgacatgtaggtataccgtcgcatttgagc
+tcgagtcaggacgtcagctagattagattccttaatagaatataccgacctctagtccga
+actaaactatagataacgccaacttcaggttaattgtctagtcgtctgtttgcagatggg
+attcttagatgagtgagtatcggccatattggttcgagcactttagtttttgatgcatag
+gatatgcaatgtatagctgaaagtactttatctgtttcaaactcacattgattaaaccgg
+taaacctttaaagactacaagaaaatattcagtgagggcaattttgtcaatcacaatctt
+ccagctagagatacttcacaatttgtcttgaggctacgcaacattagacggattttcgcg
+ttttattgaaataatcgaggggcccaagagtatccatagttcattttgtaagatttcttt
+acaggcttattacagcttcttcagactcctacatgcttacgagttatatgctagcatgtg
+aacaatagattaatatacaggaaaacgtacattgagagagatgaccctacacagcgcaac
+cgttgagtactttcattaaagggtaacgctctcgagacagcatccttaagatggccttat
+tgtcaaatcatttgcagaagtacgcaagatccctaaccaacgtagaagaatccctacaaa
+cacatgagacgcggtgaaaatagacagggtgttagtattcaatcttcggagtatcaattt
+cgccaatcttggtgagaaagcataccctttcttcagagaaagaagatcaatcataacact
+atctttaacgaggtacgcacgcgcatcattacctgcctccatggatctttaggatagcgg
+aaagtattggcagcgtattgtgatttcgttcctactttatcaatttcacattcatataca
+tgtcttttatcaaaatcgccaataagataggatgagctatattagatgctagtagagttc
+gcgccaacatcatcgataggaatactcaggacagcgtgataggacttttcaatccctaat
+actctctataattataactctctcttaagtttggaggcagtaacgcgctctatataatca
+gtttgctgcaccattcttcagcctctgatacatacaaataaattccacagcagtaagagg
+gtttaattgagacatcttgggaacttaggattttactctaacatcaccgaaacgattatt
+ggataccgtacctaaacgaactttctcaaggcagtaatataggacatccgcaataacaca
+aatgctgcctccccaggagttatgtcttcctggaggctatatcttacacccactcactat
+aggcaaactaaagtttaaatgttgattgtctaaaaaaaagatagataagagttggccggc
+gtagcacatgcgaaagtgaatcgtaagctataattctctggacttgaagttctgtcctgt
+tcctctgcaagaaacaaacttcctttaaagctatttacgacgcacatctcagcaagttat
+aaacatgttggaagtttctagtcggaattcccaaagaacggatctatctaatgcattcct
+acatttttcctgtctgccgatggtgccatcctattcaaagaatttcttaaaagtagatta
+aatgggacttttaacaatgagtaaccttacgcctctaagggttcctcgagtgccatacac
+cagtcaggtccgagccacatacacggagaacattctaacatagcattctcaactcgatca
+tttgcaggttacttctttcctatcctagtgctaaaaatcatacttgcaatcccatagcac
+ggattaagaacctaagaaacaattcagtaaaacatgttcgaattcttggtatgggaacat
+cattgcagctatggtctaacgcattaatgtttgggtacatcttccatcatataaacagga
+agagtctgacgacagggagtgcttgcgatcatgtctatcattgtgaaatcaaattgtagc
+tcacatgtcgtctatgagagcgtgtatccgataagatttagaaaaatagaagtcgtataa
+gatctcactgaacttttgaatgaatgtgaagcatatatgatctgctttaataaaacttta
+tccataggatacgtttccaaatcaattcaataattattagtcaaaatagataaggatgaa
+caacctgaaggccgatcggacgtagaaagtggtcccatcactttgagttgatattgttga
+accacacgttattatggttttcaaacagtctcaggatattgtatatacagataatccgat
+accagttgtctgacgcccctcttacgtaccccaccctttgtgacgtttaaagcagttgtt
+cagtattttaaactaggcggcaactaatttggaaagaagcacagtggatatgtctaaatt
+cttgttattcaggcctgaatttaatacaccgcatagttaacttcgcggtagagttgttca
+tcatgcctcctctaagctaccacttctatgatacaccaatagttgttctacggaatctga
+taattggccaagtcataaacttccgctgcgttcaacccccttgctcgaatatccaactcg
+aaaagacagccttttggtgtccggaacaaatcagttacttcttttctgatgttaattctc
+tgtggtcagatacagaccaaaaactccgcggatttaccatcctccaagaacaaatttgca
+tcaacatagcattttggctacatattctaagtctcaatagtttaggttttcaactacatt
+atcccaacattaggattggaggaataatagctgggtaagtccccttgcgtctacaatcga
+ctattttttatgaatatgcttctgccgcacctatggttattaaaaaagtcatgactttga
+agaaccctgaaaagatagatgaatcaggtgtaatggcagcagccaaagagcatataatta
+gcaacactctaagaacattatagatatgatgatagcgatcgtcatgatgttatccggtca
+caatagtagcttcatcagctaattcgttttgccagtggtgacttgcgctggaagaatcgt
+tatacggtcccttccctcttgatacggtgggggcttattcaaccgcgtggattgggttgt
+catacttgcattaaacgatgtaaaccatctagtagtcaactatactaaatcacaaaatag
+tgatcaatacatacccgcttcatggttttaaccatttaattgattaaagatattccgcta
+agaaccattatctacctaaactgatcgccgtatcctagtagtttgaaatttgatgtaccg
+taatgatcaacgaagtaaaacgttatattgtatgtagaataataggtcttggagctaaat
+gatgtgattggtagtgaagacttacccttacaactttaccggtttctcggaagaatatac
+tagagaatcaatgcatgggctacataagcactttagtctaatgagataaaaaatacacga
+gtcttccatcatgaattttttgtcgaaaaactcgaacctggtaatttaaaccatatatct
+ttatgtcgtcaataactctcatatgttttatataacttcccaatcacgacttgtaactgc
+ttgttcgactgagctgtttgagctatgaggccgggatccggttgagctacatctatttgc
+tacaagaaaaatgaaagcacatttgttgggagttctggctacactcatagagaaataagt
+ggcccgagtgggtgcggcctgcctccatattcaagtgtatcttaaaccaagtggttccaa
+cgctcgcgctaaagaattaaagcctttatttcctccacggagtagcccgtaatccggttc
+gaaagagaccattgaagttaattttcatatccagtgaagtttaggcacaagcatgtgttc
+tgccacatgcctcaaagcgctcttcaaccaagatatgattcatcctaacttcgatgaatg
+cgtctgtaacataaatatagaaggaatgattcggcgagttaattttcgccttctccaaca
+tggcatccctacgttcgttataaggaccatacatgtaggttttaaaggtttgcggttaat
+cgatatttacatcatagaaattctatagtcaaatttacaagactctagatactcactcgt
+tgcagccggctaggaagcgctttgtaccttacttcccttttcgttgcgtaatatgaattt
+catatagtaagttcaaggcactcatacctccgtgaagagggtagatagactattaaagtt
+gtttaatagtacgtattgatggaaatgacccgtaggagatttaccactcaatccacaaga
+ttcgctgctgtgcattatcaaaacagtgcatgtcgaaacatgggttgggtccttcaaaca
+cgaatccaggtagagatacctttgcaatttttcgatgaaggcgaccgagataaatgagct
+ataacactgtatgtcttttgattgctataaaacacagaaacggatattaatttaggccgt
+aaccaacatctgttatttgacatagaacagatggtcctttacagcgtattccggccttaa
+tattgaggtccagtgtattgtcctcctttaaagaagttgattgtaactgacttaaataag
+acatgtcacccattcactgggttgcaactgctggccctttttgtccatcgcacgctaatg
+tgataacagtaccgccctcacacctgcgtttaaaagacataaatgtcgctatgaaggtta
+ttcattaattttagctgttttcttagaaaaggtaaatttaaaattgaaaaggctagaaaa
+ctaaagttacgacaaatgtgtttgtcaagtaggcgggcatcattgagattgtaagaaata
+aagccataaccagccccggaatagaaaatgttaaggaaaggcgatcttctttgaattctt
+attgtcaagtgcagtcatacgttcttatcagaggacattgcaataaaatctaacaccctc
+ccttgtgtggttgggccatttgtacttcgaagcgtccaccatgtgcagaggataacggaa
+tgtggttccgtcccataaacgatcattctcgcccacttagtggcgcggtaaatcgctctc
+atagaggtaactggcctgtaatgtccaatgttaggctaccttctccaactttagtacaac
+gaataatgtccgattaacaaggagtcaatttgtcatgaccagttcattcaggtacttgta
+tctatacggacgcgttccagagtagtatttgaaattttgaggttctactgataagtttag
+ctatcgctgtatgtctgaataagaatttaatgtttatcttcgataaataacaattaacaa
+ctcctaggtgatacactgtgaagtctgctgttccccaaattacatatgctattttgttca
+cataccatgaagttaagctaagtgctctataatggcataaacggttatcaaactagctcg
+aatttcttttattacgccggaagcggattaactgctgtagatcaaacacgttaggatagt
+gtcgttttcatatatatctaaattcggtctaacatgcattacccatgcttgataacgtag
+cacttcgcagtctaattatgtaatgtccgtttaaccaaactttaaaaaagtttatctatc
+accagtgatgcctcatcgtgactacccggatctttagcctttagggtctaaacagaacta
+atattactacgtgtcatactccggagcttaaccaggtgaaacttatttgttaaccaaatt
+tagtgacagggtagaaatacgtatcaaattaacccagcaatacaataagcatgaaaataa
+ttgtaatcgggtttgggccggaatcccgcttggcgaaaacttaatgacatagtgtgatgc
+attttgcactggattgagccacaaactcaactagcattatgctcaatatttggccagtgt
+tctacggtttgaaatttataaaggccgcgcaaaagtcttgtagttacaaacgcataaatc
+tcgaacgtaataggtttaattagaacatccgtaggatttctgtttatagtagatttatac
+taaatgttctgattagattctgacggccttacccatacaattaataaagacgaatatatt
+agttatagtttactatccaaataaattaagcgaatcgaaataaactgtcacgatactggg
+cagttatcaacttatcacttatacagttcggacactctatattggtctgtgagtactcta
+tcaaactaactcataagttaactgcgcttccattaaatttcaatacgttcttgtgctgtg
+tacaaacctataatcgaataaatgacacatatggagatgcataataaaaaaaacggctcc
+atatttctcgttaatcgggcattcttaaggaggagcatctcaccaaaaataacgttcctg
+ataagtcttaactattagaccgtcttcgggaatgaacgaaacctcaagctagcatggtat
+agttcttgatagcgcgtaaattctgataatactgggcggacagctggaaattagttgcca
+gtgcacctacgcaaatagtttacataaatcaacgggctccgaacgtaaatacaaagggtt
+agttacatcgcaacaagatgaaaagcatgtatgtctaccgtcatccgtccctaacaaaca
+taaaggtggtgaagaatctcgtaggtcaactataactccatccttgaagcaactactccg
+cgtccgtgtgcgtagttcgcaacgagaacactactgaaaaaagctaaacaactctcggta
+caaatgcggcttgtgtcgataaagttggtggtagtgcacggaataacataacaaggaata
+ttatttattcaaattttttgtgactgttatttgttttctgcctagaatgtaaggatgtgt
+tttttgtgacctgatagttacgcttatttcaggtccacggtgcgtgagagtgtgtcctat
+aacggcaggggagcgaagtagtgtcctttagactattcaaggtagaattttgataacgct
+ctataaaaggtagaaaatcatgattgagcaataagaccccaacttatcaaaaaaggagtt
+ctcgacagcgcgtgtacagtccctataacggctgtatttcctgtgtcacaacaccctccc
+atcgcactcaaaatgtagatttatgatcagacgctaacttgttcttagagaaaaatacac
+gggatactctgtgcaacgatttcattaataaggtgcagcttgggacttttttggccgtag
+gctttattaacattcacagtaggtagcgagacttcctatgaaccaatcatgccacgcgtt
+ttaacgtttcaaatataagctaggaagcgtttgccaggacttctataatgcaccgttttt
+tttagtacttccttactagccttagtttatgttagagtctttccaattacaaaggattga
+atagccaaaatttctacaattctcagcgaacgccagcttaatctaaacacgagcttcaaa
+tattctacatatcggcaggagtcaatatataaatatgaaaatcgtaccatcctcgtactt
+ttagaccaaacgtcttcggataattaaatcctttttcaattaccacagtacgtgcattag
+aactactgctatgaaagtaaaccttgaaatatagtcctcaagagcgtatccaagtacatt
+gcacgtgtatacagtcgtataaacgagttgatgttctgacgctagagcttaccattcgtt
+aaacagataactaaaatttaatggctgagtgacttagtgttttcgacaaacgtcgcggat
+gtagactattgtttataagcaatttttaaaaacatatgttcaaaacggtatgggatatgt
+cgaattccacaggggtttatgtaccatagaagtatgtataaggtactaaaggtttaaatc
+tgtgatattcggttcggtgaaaatcagactagtcacacttagtgtctgtaaattagattg
+ggtgaaggtaagcgatcccgaactctacaaggcatgggatgagattctaccgactccgga
+taacactttacgatcgcgcataactctagctcttagataagtttaacttgtcgatctcat
+aaacagttcaaaatctgcgatttattgtatcaaatccatcctctatcttctataatcatc
+tgaaccgcgatacggcactatgagccaagtgaagattgaatccaagaaagctataattgg
+tttattttagtccatttaaattaagtccggtataagtgctctgtacaatatgcagtctca
+tgggcatatacgttaactaccttttgatacttcgaattggtaaaatatcgactatcgatt
+tgcagtaaaaggtgtagagtccaattactctttcctgttacatacgatctcttagtttgg
+acaactagcccatgatggcgctcctctagcgcatgaacctactttataattacatcttta
+tcgatgaatttttttagactgcggaggccttgagttttaacagggctgctaaatttctta
+agcgattagacggtagcgtcgtacgctacttgcttggaacaggcaccgaaaatattgatc
+tactattgcgtcaactctattctgctaatagcgatggcaaatcacagaagccctcttagt
+gacaatagttgtcaactatatctaagtcgacctttactgtatcaacgatcacggagagaa
+ttaccgaatacgaaacctcaggactaaaaaacggaaaggatttgtcgacggtaaatataa
+tacttgttaagggtagcgacacaggtatactttgggtgtaaacgtggtgcttcccggaac
+gattttcagaccagaaaattgttccggtaaccaggaaatctcgtctgcgttaattcgtgt
+tagtaaacttgatcttcagactccttcttttcgttgcagcgagacttaaattatatctgc
+gaaatagtgccccgtgcatacttcagatggtaggagataccatttggcccattgtgactt
+tacgcgattaattaaccgacatacatctgttcctgagctatgatcgtctgaataaattac
+ggtctcctcttgatacctaatggtttctggagacgtttctcatgttcaaatggatagcag
+gagatcgcttcatcaagtttagctacgcagagcatcaaaatatgtatgggaaagtcgatt
+tccaaaccagaagggataaagagaaataacggacttctccgtagattagcctgatatttt
+gatgggaatcatggcggcacatacgtaagagttgcgtgaacgaatattttggacggcggg
+agacacatatcggccattcgttaaggtctctatattggacatcacaagcttagcagtatg
+agctactaacactcaagacattattgattttttcaagatatgtttcattcctctaccgct
+attcccatacgttcgattcgccgggtgagcgaaaccacgggactgaggttaagctaatca
+ataacaactcgttgcgatagagacctatgtatactagagagaattccccaacatttttac
+aaaaacaaagcagactaaaatagatacagtccctccatacaattaggaccaacatgttat
+tgccgatcctagcacacacaccacaaactcagaacttctgtcttacctatgaaagggtct
+gcacttctgattgtacgtgtctaattagcattaatattaaaactaattaggataaactat
+aggtacgagctttactataagtcactaggtgttttccgatcgaaaaacgggaccttcaag
+ccttggtaagtacatttaggataaagaaaaaaaggaaggtacgtgactaatctgtctaaa
+ctgacaatagagtagtacctacatgcttcatgtcaagtcttaatacgcaagcgctctcgt
+tatactgctcaacaaaactcataaagttggactccatcatttagaatcatagggaccaaa
+acatttatttgctactgtcactttgtaggtgttctattctgaattcctcatattgataca
+tgaatcggaatacctgtggatcccttaggacgcacgtgctttctttacgtcagaatacat
+attgtcagaatcgagaagttccatgcaattaagaattcgcctctttgaaaactcatatcc
+ccacatatagggtccaccgttattcggaaacgatataataattattccagcgttgagcgt
+cccttaagagcgcattttcgcttggcctttcttctacgactctacaacgcaagtggctgt
+gtggagtttaccacagcgcagcaccccatagaactacctctgagagcgcgagatggtggc
+agtatgctctgcagctagcgtttagaacgcgcccgcgcattaaccagtcatattaaaatg
+gactgtcttaattgtcggcattaggagcaatattaactgatgagggtatcggtcgcagaa
+gtaatgacggaaatacgcctctagtccgcagagatacgattacagactcagatcccctaa
+caagcaaaacgattaaatcggaatcactccccctatgacatatttgaaatacacaagaaa
+ccacgcaacatgtcccgcattctcaaccgcgctttataagatgttgagtctgagaattag
+atgacctaactgcaagaatcatggcgagtttatctagtaggcaagtctgtaccctagggt
+tcgaacgctgtgacgtcgtgatcggtctaaggacttagatgataaccaagaactggttta
+ccgagtactttcactattaggagtaattacatgcgttcaccgcggaatacgacgaaattt
+tttcatatctttatgagcgagatcgtgtcgtctttgcattgcaacagtcgctaccagtaa
+ttgctgatcaattatagattcattatacagatgcttacttttctctattcaatactgtca
+tgagttgtttttaaataagcaccagaattatgtcgcctagtataatcttgcttccacttg
+aatcaatgcgatggacagtattctactgattgcaaagtagtctatttcggcttagcagta
+cgcatgcctatttttttgcaggcacagaataatatgcaactaggattctcggcatccaat
+taacaggctaaaacaccaccgaaagacaggtaatctacgaagttgatgtttactacagaa
+agcgaatgatatcacttggagaacattttagatgcccccttttaatctagactgagtgta
+ccaatatatcaccggtctaccgaatcagcttgaataaaccactctagtactcatgataac
+cgagcatacacatgtatttctcaatgcactgaaggtgaactgtttacaccataccttgcg
+aatcaacgtggcgacttatacttctgtctttgagtacagcacaccctaatgaatctaagt
+tagttgttgatacgaattgtaatttgactggatctcgcctcctcatctagattcttagag
+aagatgtttcttatagccggtactgtaactttattgatctggtttatggtaatcaacatt
+ttacctctatttaaacgtccttgcgccgtgcactcaatcctgatcggtttagattcaagc
+gattatcgagtctggaggccgagaaaagaaatgcacagagtaagctctctattgcgacat
+ctacgtagaaactcgcatttcagatcgagtaagcaactctcattgtgttgattcagtaat
+acaagattacctacgcttctacgaaatatactatagatttagcctacgtcacctttagtg
+tcgagtcggagctttgaagatcggatgcggtgtggactgtgtataggcaattttgctgcg
+agctcgtgacttttggttgatgtcgatatcaatgggatacctcaaacgtctttatctctg
+gataactcacattgagtataccggtaaaaatttattctattcatctaaatagtcagtgag
+ggctagggtcgcaatcacattaggccacatacacatacttaacatgttctattgacccga
+cccaactttagtagcattgtagccgtttatgcaaatatgccaggcgccaaacactagcca
+gagggcattttgttacatttatttaatcgattattacacagtcggaacacgcctacatgc
+gttcgacttatttgcgacatggtcaacaattcagtaatttaatccaaaacctaaagtcag
+agacatgacactaaaatcacattaaggtcagttagtgaaggaatggctaaccagctagag
+aatgcatcattaacaggcacttattgtcaaatattttccagatctaagcaacatcacgtt
+aaaaagtacaacaatcacttaaaacacatcagtccaggtgtaattagaaagccgcttagt
+aggcaagcgtaggagtataaatgtagacaatagtcgggacttagcagacactggatgcag
+tcatagaagatcttgcataacacgttagggttagagctacgaacgcccatcattaactgc
+ctaaagcgtgcgtgagcttagcgctaacttttccaacacgtttgtgatttcgttcataat
+gtatcaatttcacagtcatatacagggagtgtagaaaaatcgcaattaacatacgttgac
+ctatttttgttcagagttcagttagagcctaatgattcgagagcaataatcaggacagcc
+tcataggaagtgtcaatcacttagaagctatattattataaatcgctctttactgtcgtc
+gaaggaacgagcgagagagaatcagttgcctgcaactggcttaacaatatgatacataaa
+aatattttcatcaccactaagacggtggaattcagacttattggcaacttaggatgggac
+tattaaataacccataagatgttgggataaagttacgaaacgaaagggatatagcctgtt
+agataggaaatccccaataaaacatagccggcctccacagcagtgatctattccgccacg
+cgatatctttataccacgcaatataccaataataaaggttaaatgtggttgcgatttaaa
+aaagatacatatcagttgcaccgcgtagcaaatccgtatgtgaagcgtaacctagaatta
+tagcgtctgcaagttctctaagcttcctctgcaagatacaatatgactttttagcttttt
+tactaccaaatctcagaatcttagaaacaggttggtacgtgctactcggaattcccaaag
+taccctgctatatatgccattccttcattggtccgggctcaccatggggccatcatagta
+atagaaggtagtaaaactagttgatttccgacttttaacaatcactatcctgacccagat
+atgggttccgactggcccttactccagtaagggcagacacacagacaacgagaacttgat
+aactttgaattctcaaatcgatcattgcaacgtgacttatttactagcctactcctataa
+ttcatacgtcaaatacatttcaacggaggaagataataagtaaatattcactaaataatg
+gtcgaaggagtcctttgccaacataagtccacatatgcgctatagattttttcttggggt
+tcatattcaataagataaacagcaagagtatcacgtcagcgagtcattgagatcttggct
+agcattgtgatagcatattctacctaaatggtagtctagcacagagtggataagatatca
+gttagatatagacaagtactataacagatctcgcttcgttggattgtatggctagctttg
+atgatatgattttataaaaattgatccagacctgacctggccaattatattcatttttta
+tgagtaaaaatagataaccatgaaaatactcaagccccttaggacgtacaaagtggtaac
+ataaatttcaggtgttattctgcaaccacacctgttttgggttttcaaaaaggctaagca
+gattggttttacagataatccctgaacactggtatctcccaacgatgtcgttcccaaccc
+ttgctgaccttttaagctctgctgaagttttgtaaactaggcggaaaatatgttcgatag
+atccactcgcctgaggtagaaattcgtcttagtaacgcctctttggattacacagaatag
+tgtactgacacgtacactgctgcagcagccatacgctaacattaaaattcgttgagtcta
+catttgttgttattcggattatgttattgggaatagtatttttattcccctgcgtgaaac
+cacatggatagattagcctactcctaaagactcccttttggtctacggttcaattctctt
+actgagtttatgttcgtaattatatcggcgcagtgaatctcctaattatcaccggagtta
+ccagacgccatgaacttatggccagaaacattgcatgtggcctacataggattagtatca
+agagtttacgtttgcaacgacatttgaccaacttgaccattcctgcttgtagaccgcggg
+aactcccctgcacgcgactatagaagttggtggtggatgtggcttatgccgcaaatatgg
+ttttgaaaaaagtaatctattgcttgatacctgaattgagacatgtataagggctattgc
+cagatgaaaaactgcatataaggtcaaacaatataagaacattatacataggatcttagc
+gttcctcaggatggtatacgctataaagtctagcttcagcagctaaggagttttgccagt
+gcggacttccgctggaagattaggtttaaccgccctgacatcttcataaggtcgggcctg
+attcaaacccctggagtgccgtctcatacttgaattaatcgatggaaaacttcttctagt
+ctaatattattattaacaaatgacggttcaataaataacaccgtaagggtgggaaactgt
+taagtgatgaatcattttaacctatcatccattagctacagataatgataccccgatccg
+actagggggtaagtggttgttccgttaggataaaccatgtaaaacgttagagggtttgta
+gattaattggtattccagataaatgaggtcagggcgagtgatcaattacactgaaaaatt
+gtcagcttgcgcggtagttgttaagacagtataaatgaaggggattcagaagcaagtttc
+tcgattgactgaatttataaaccagtcgtcaatcatgatttttgtgtcgattaaagccta
+aatggtaatttaaaccattgatatttatcgagtctataaatatctttggttgtatattac
+ttcacaatcaccaattctaaatgattcttccactgtgcgggtggagatatcaggacgggt
+taaggttgacctacatcgttttgatacaacaaaaatcaaagcacatggctggggacttct
+cgatactatctttgagatagtacgggcaagagtgggtgacgcctccctacattttcaagt
+ctatcggataacttctcggtaaaacgctcgcgatatagttttaaagcattgatttaatcc
+acgcaggagcaagttttaccggtcgaatgagaaaattcaacgtaagtgtcatatccagtc
+atggttagccaaaagcatgggttatccaaaaggaataaaacagctcttcaacaaagagat
+gaggcttcataacttcgatgaatgcgtatggttctgatatatagatcgatgcatgaggac
+actttattttagccggcgaattaatggaatccatacgttacttatttggacatgacttct
+aggtgtttttgctgtcccgtttagcgatatttacagattagtatttcgtttctcatagtt
+aattgtatctagatactaactcgttgaagacgcataccttgccatttgtacaggacttaa
+ctgttccgtgcgtaatttgaatttcttataggttcttcaaggcacgaatacctcactcat
+gaccgttcatactctagttaaggtcgggaatactacgtatgcagggaattgtaacctagg
+agatttacaactctttaaacaagagtcgctgaggtccaggatcaaaacactgaatctcct
+aacttcgggtgcctccgtaaatcacctagaaacctactcatacatttgcaattttgagat
+gtaggcgaaagagagaaatctgctttttaacggtatctcttgggattccttttaaaaaca
+cataacgatagtaatgtaccaagtaaccaaaagctgggatgtgtctgtgtactgatccgc
+cgtgtcagagtagtccgccatgaatattgacgtcaaggctagtgtcatcaggtattgatg
+ttcattgtaaatgaaggaatgaactaatgtcaccaagtaaagggggtgaaaatgctcccc
+agggttctacagacatagagatggtcagaacacgacccccctctcaacgcagtgtatttg
+aaatatatggacatatctaccttattctgtaattttagatgtgttctgtgtataccgata
+ttgataagtcaataggcttgattacgtatcttaagacaaatctgtttcgcaagtaggacc
+gcatctttcagattgtttctttttatgccataacctgcccaggaattcaaaaggttatcg
+atacccgatatgctgtgaattattattctaatggccactcattcctgcttatatctggaa
+ttggcatgaatatcttacaacctaaagtctggcgttgcgccagttctacttcgtaccgga
+caccatctccagtcgttaaccgaaggtgggtacgtcacataaaagttcattagaccacac
+tttgtgccgacgtatatagatatattacacgtatagggaatgttttctcctaggtgaccc
+gaccttctactaaggttgtacatcgtataatggcccattaactacgaggaaagtggtatt
+gacctggtaatgcacgttcttcgatatataccgacgaggtaaagtctactattgcaaagt
+ttgacgttatactgataagtttagatttccctggatcgcgcatgaacaatgtatgcgtta
+tctgccatatataacatgttacaaatccttggggatactatcgctactatcatcggacca
+aaattaaataggctagtgtcttatcagaacatcatgtttaccgaactgatctattttcca
+atttaagctgatattacgtccgcgtatttattttagttccccggatgacgattatctgag
+ctacatcatacaagttagcatactcgccggtgcattgatttcttatttcgctatatcttc
+aagttcacaggcttcatatagttccaattagcagtataattaggttttgtaactttaacc
+atactttataaaaggttatattgcacaactgatcaagcatccgctataacccgagcttta
+ccagttagcggctaataacaaataagatgacttcgtgtcatacgaccgtcatgatcatgc
+tctaacttaggtgggaaccaaatttaggcaatgggtagtaataagtataaaatgatacca
+catatactataacaatgaaattatttgtaatccggtttgccaacgtatcccccttcgcga
+taaattaatgacatagggtcatccatgtgccaatcgtgtgtgccaaaatctcaaattcaa
+ttatcatcaatattggccaagtgttataagcgttgaaagtgatataggccgccaaaaagt
+agtctacttaaaaaccaatatttatcgttcgttattgctggtagtacaacatcacgagca
+tttctcttttgagttgatttatactatatctgctgatgtgattatgtcccacttacccag
+aatattaagaaagtcctagattgtaggtatacttgactataaatataatttaagactata
+caaataatctggctacattatgccatcgtagaaactgataacgtagtaacgtcggacact
+agattttggtcggggagtaatctagcatactaacgaatttgttaaatccgctgaaagtat
+atgtcattacctgcttggcctgtcttcaatacgtttagactattaaggactcatttcgag
+atccagtattaattatacgcatccatatttatactgaagacggattgagttaggacgaca
+agctaaacaaatattaagttaaggattagtattatattgtagaaactcgtcgggttggaa
+cgattcatcatcatagaatgcgttacttattcagagagacttaattcggttatgactggc
+agctcacctggaaagtaggtgaaaggcaacagaagaatattgttgactgaattctacggg
+ctacgaacgtaattacaaagcggttcgtaaagagcataaagatcaatacaatggatctct
+acagtattacgtaaataacatacataaacctggtgttgattcgactagctcatagattaa
+tcattaattgaagctacgaagacgcggaagtctgcggagtgagcaaacagtaatcgactg
+ataaatgcttataatatcgcgcttaaatgccgcatggtgtacattaacgtgggggtagtc
+aaaggaatatatttactaggaatattagttatgcaaatgttgtgtcaatgtgatgtgttt
+tatccagacattggatgcatggctgtgggggcacaggatacttaccattagttcacctac
+aagcggcgtgagagggtctcagttttagccagcgcagagaagtacgggcctttagacgat
+taatgctagaattgtcataaacctcgtgaaaagctagttaataatcatggtgctagaaga
+acacaacttttctataaaccagttctcgactgacagtcgtaactcactatatcgccgctt
+tgtactgtcgcaaaaaaacctcacatagaaagaaaaatctactgggtgcatcagtagaga
+tcgtgttctgagagataaatacaccggatacgatctgcatcgagttcatgtattaggtca
+agcttgggactgttgtgccagtagcattttttaacagtcaaagtagggtgagacacgtca
+tatcataatatatgccatcgaggtttaaagtttatatgataagctagcatgcgttgcaat
+cgtattcttgaatgctccgtggtttgtactaattcctttatagactgagtgtatcgtaca
+ctcggtacaattacaaaggatggaagagcaaataggtcttcaattataacagtaccccac
+cttaatctaaaaaccagcttcaattagtattaatttcgccaggagtatatatataaatat
+ctaaagactaaaagactcgtacttttacaacttacgtcgtagcataattaaatcatgggt
+aaatgtcatcagtaagtgcattagaaatactcctttgtaaggatacagtgaatgtgtctc
+agcaagtcagtagaaatggaaattcatactcgattaaggcctataaaactgttgttggta
+tctacagagtgattaaaattagtgaatcagattacgaaaatgttttcccgctcgcactta
+cgcgtttagacaaaagtacaggtggtacaattggctgtagtagaattttggtataaaata
+ggtgataaaccggatgggtgtgggcgaattcaaaagcggtttttgttccatagaactatg
+tagttggttataaaggttgtaatctcggagattaggttagggcttaatcagaatagtaac
+aatttctctatgtaaagtacagtgggtgatcgtatgagttcacgaactcttaatgccatg
+cctggacaggataaacaatacgcatataacttgacgatcgagcttatatcgacctatttg
+agaagtttaacgggtcgatataatatacaggtcttaatagccgattttttctagaaaagc
+aatcctatatcttagttaatcagatcaaccccgtgaacgatatatcagcaaactgaacat
+tgtatacaacattcctttttgtccgggtggggactccatttaaagtatctcacctagaac
+tcagcggtaatagatgcagtctcttgcccagttacggtaactaaatgttgatacttagaa
+ttgctaaattttagtctagacatttccaggtaaaccggtagacgacaatttctctgtcat
+ctgtcataagatcgcttagtgtgctcaaattgcaattgagggccctactatagacaatca
+tcagactttttaattaaatagttttccatgaatgtgttgtcaaggcggaccccttcactt
+ttatcacggctcataaatgtcgtatgactgtagtcggtagcggccttcgagtcttcaggg
+gaaatggaaaagaaattaggcttctaagatggactataatcgattaggctaattccgttc
+gcaaatcacagaagcaatcttactcaaaattgttggaatcgatagcgaacgcgaccgtga
+atgtttaaaagtgctcgcacagaattacccaatacctatcatcacgacttaaatacccaa
+agcagttgtagtcgcgtaatagattaagtctgaagcctagagacaaagggatactgggcg
+gggaaacctgctccttcacggtaacatggtaacaacagaatttggttaaggttaaaacga
+aatatactcggagtgaattactgttaggtttcgtcatcggatcaataagtagtttccgtg
+aagacactcttatattagatctccgaaattctgacccgtgcattaggcacttggtaggag
+attccatttggaacttgctcaatgtaagccagtaatgttccgaaataattcgctgcagga
+gcgaggagccgctgaataaaggaccctcgcatcttgttaccttatggttgagggtcaccg
+ttctctgcgtcaattccagagctggagatacattcatcaacgttacctacgcacagaata
+aaaagatcgagcgctaactcgttttcctaaacacaacggatttagacaaattaccgaatg
+cgccggagagtagcatcttagtgtcatgcctatcatggcggctcagtacgaagagttcag
+gcatcgaatattgtggtagcccgcactcaaagttccgccattaggtaagctatatattgt
+ggtcagaacttgaggacaactatgagctactaaaaataaacaattttgtcatttgttcta
+gatatgtggcattcatcgaacgcttgtaccagaagttacattcgcagcgtgagcgaataa
+acccgaatgagcgtaacattatcaataacatatagttcagatagagaacgaggtattcga
+cagagaattacccaacattggttattaatctatgcagaataatttagataatgtcactac
+ataatattaggaccaaaaggtgattccccagaagacaaaacaataaacaatctcacatat
+tcgctagtacctatgtatgggtatgatcttctgattggacggggataatttccaggtata
+ttaaaacttattaccataatctagacctaagagaggttatataagtaaagagctgtgttc
+cgatagaaaaacccgaccttaaagacttgcgaagtaaattttgctttaacaaaaaaacct
+acgtaagggaatattctgtataaactgaaaagtcaggtgtaactacatgagtcatgtctt
+cgattaattacaatgcgatctcgttattctgatcaactaatatcataaactgccactaca
+tcttgtacaatcattcgcaacaatacttttatgtgctaaggtcacgtgcttcctctgcta
+tgctgatttaatcagattcataaaggaatacgaataactctggatccattaccacgcaag
+ggatttatttacggctgattactttttggctgttgacagaactgccatgaaagtaagatg
+tcgcatcttgcataaataatagcacctaatatagccgacaaagtgattccgataacagat
+tttaagttgtccagccttgagactccatgaagaccgcttgggagcttccccgtgattaga
+agaatctaaatcccaagtggatggggggagtttaaatctcagcaccaacaaatagtactt
+cctctcagagcgcgtcatggtcgaaggagcctatcctgatagaggtttgaaagcgcacgc
+gcatttaactgtcatattaaattggaatctcgtaagtgtcggcagtacgacaaattttaa
+ctgatgtcggtatacggagaagaaggaagcacgcattgaagcagctacgcagaactgaga
+agatgacactctaagatacaattaatacaaaaacgttttaagcccaatctatcaacagat
+gtaagatgtctaatacacaagaataaaaccttcatgtcccgatgtataataacagcttta
+tttctgctggtcgaggtgaagtagtggaaattactccatcttgctgcgcgtctttatagt
+gttggctactctgtaaccgacgcgtccatccctctctcctagtgatccgtatatccaatt
+agaggataaccaacatctgcgttaccgacgaatttaaatttttcgactatttaattccgt
+tcaaacccgtattcgtagtaagtgtttcatagatttatgaccgacatcgtgtacgagttg
+cagtgcatatgtagataccactaattgctgatctaggatacatgctttataaacatgctt
+acttggctattttatttactgtcatgtgggggtttttattttcaacaagtatgtgctacc
+attggataatctggcttcaaattgaagatatgcgttccaaacttgtctactgtttgctaa
+gtaggagttgtcccattagaactacgcagcacgtggtttgtgatcgaaaagaataattgg
+caaatacgaggctagccttcaaatttaatgcagattactcctcagaaacacacgtaagcg
+acgaacgtgatgtttactacacaatgcgtatcatagaaattcgtgataatttttgttcca
+acctttgaatctagactgagtggaaaaagatttcaccgggataccgtttatgctggtttt
+aaaaactcgtcgaatcatcttataactgcattcaaatggatttctcaatcatctgtacgt
+caactgttttaacaataacgtcagaataaaccggcacaatgagacggcggtctttcacta
+caccacacccttaggattataagtgacgtgtggattcgaattctaaggtgacgggatcta
+caagcctcagctacattaggtctgaagatctttcgtatagccgcgtatgttactgtttgg
+atatgggttatgctaatcaacagttgacagcgagtgaaacggccttgcgacctgaaatct
+ttacggttaccttttgattcaagacaggatcgacgatggaccacgtgaaatgaattcaaa
+actgtaacatcgcttgtgcctcagcgaccgagtaacgacaagttcacatcctctatgcaa
+ctatcattgtggtcattaaggtattcaagattaactaagagtcgaccatatattctagag
+ttttacaattaggaaccgttagtctagactaggagcgtgcaacatcgcaggaggtgtgga
+ctgtcttgacccaagttgcctgacacatagtgtcttttgcttcatgtccttagcaatgcg
+atacctcaatcgtagttttatcgggataaataacatggtgtttaaccctattaatggttt
+ctattaatctaaattgtaaggcagcccttgggtcgaaagcacattaggccacatacacag
+tatgaaattgttcgagtgtccagaccataattgactaccatggtacacggtgttgctatt
+atgactcccgcaaaactcttgacagagggaattttggtacattgatgtaatcgatgattt
+aacagtaggaactagacgtcatccgttagactgagttccgacatgctcaaattgtcagga
+tttttatccaataactaatggctctcacatgtaaataaaatcacattaacgtcacttagt
+gatggattcgctaaacagatagactatcattcatgaactggcactgtttcgattatattt
+gcaacatcgaacatacttaaagttaaatacgacatcattcaattaaaaaaattcagtaca
+cctctaatgagtatcccgctttggaggaaagagtagcactttaaatggacaatttaggcc
+ggactttcctgtaaatggatgaagtcattgtacagcttgaataaatcgttagggttagtc
+cttacatccaccatatgttaatgaataaagcctgagggaccttagagctaacttgtccaa
+cacgttgctcatttacttaataaggttgaaatgtatcagtaagtgacagcgagtgtagat
+tttgaccatttaactgaccttcacagttttgtcttcagacgtcacttacaccataatgat
+gacagagcttgtagatgcacacactcattcctagtgtaaatcaagtagtagctagattat
+tataaagagatattttctggcgtcgaacgtaacacagagagagtataaggggcatgataa
+tggcttatcaatatgtgtaagaaaaagtttttaatatcatctaactcggtggaatgcaca
+cttatggccaactgaccttgggacgagttaagataccataagaggttgcctgtaagttaa
+gataacaaagggatattccatctttgtgtgctaagaacctatttatatttgcagccataa
+aaacctctgtgctatgcagccaccagagttatttatacaaagaaagagaccatttagata
+cgttaattctgcttgcgatttattaaacagacatttcacgtccaaccactacaaaagccc
+tatcgcaagacgatcattgtattatagcctatgcaacgtagctaagcggccgaggaatca
+taaaatatgaattgttacattgtttactacatatgatcacaatctttgtaaaaggttcgt
+tcgtgatactaccatgtacctaactaacctgagatatatgcaatgacttatggggtcagc
+gcgcaacatccgcaaagcatagtaatacaaggtaggaaaacttctggatttcccaaggtt
+ataatgctctatactgaccaagagatccgttacgactcgcaatgaatactctaagggcac
+tcacaaagaaaaccactaattgataaatttcaatgataatatcctgaattgcatcgtgta
+tgagttacgagaagtcgcatttaatgaattagtcatagaaatgtcatagcaggaacataa
+ttactatattttaacgatttaatcgtagttggagtcctttcccaaattatgtcatcagtt
+ccgatttagatgttttcgggcccttcttagtaaagaagttaatatccaagactagctcct
+cacccacgcatgcacatattcgcgagaagtctgatagaatattcgacagaaatgcgactc
+tagctcacactcgttaactgatcaggtacttatagacaagtacgttatcagatatcgctt
+cggggcattgttgcgctacctttgtgcatagcagttttgaaaaattgttcaagacctgaa
+cgggaaaatgatattatttttttaggaggaataatacagtaccatgtaaatactcaacca
+ccttacgtacttcttacgccgaacatatatggcacgtgttattcggctaacaaaactgtt
+gtgccttttctataaggataagcagattcgttttaaacatatgacctgtaaactgggatc
+tacaaaagaggtacttaaaataaattgcgcaacggtttagatctgcggatctttggttaa
+agagcaccattagatgtgccatacttcctatcgcctgagcgagaatttagtctgaggaac
+cactcttgggatttaaaacaattcggttaggacacctactcggcggatgaagcaatacga
+taacattaaaagtcgttcagtctaattttggtcgtagtacgatgagctgatggccaattg
+tatttttattaacagcactgaaacaaaatggagactttagactaatactaaagtctcaat
+gttcgtcgaaccttaaatgctcggaatgaggggatcttcggaagtatagcgccgaagtgt
+atctcattattataacaccagtgtacagacgacatctaattatggccagaaactgtcatt
+gtgccattaagaggattagtagatagtctggaccgtggaatagaattttgaccaaattga
+ccagtcctgcttgtagacagcgcgatctaaactgcacgagaatatacaagttggtggtgc
+ttgtggctgagcacgctaagatgcgtttgtttttacgattctagtgcttcttaacgcaat
+tcagtcttctagatccgctattccaacatcaatatctcaatttaaggtcaatatatataa
+caaaattagacagagcagctgacacttacgaagcatcgtagaaccgatatagtcgacctt
+atgatgatatggacgtgtccaagtccgcacttccgatgcatcttgacggtgaaccgaaat
+gaaatcttcattagggcccccatgtgtcaaaccactcgagtcccgtctctgaagtcaagt
+attactgcgaaaaattcgtctactattagtttattatgaacttatgacgcttaaataaat
+taaacagtaagcctgggaaaatgttaaggcaggaatctttgtaacagttcataatgttgc
+taaagattatcagaccccgtgaagacttcgggctttgggcttcgtaccgtagcataatac
+atctatatagttagaggcttgcgtgttgttgtgctattccacatatagcagctctgggcg
+actcttcaatgaaaatgaaaaatggtaacctggcgacctacttgttaagtcagtttaatt
+caaggggattaagtaccaagggtcgagtttctctgtatttattatactgtaggcaagaag
+cttttttggcgagatttaagacttaagcctatggtaaaaatttgatagtgagcgactata
+gtaagagatttgggtggttagtaattaaaattctcctatgctaaatcaggcgtacaatct
+gagggtgcacatttctcgacgcgtgaaccttcaccgaaagcgtgtggattatacaaattt
+caaacatattggcggggcacttatccataatagatttctgtttgtacgccaaactctgcc
+tcacccctccataaattgtattggctagaggttaaattctccgtaaatagagacacatat
+agttttatacaattgtttgaatcaaagcacgagaaacttttaaccgtacattgacaaatg
+tcttcggatggggcagagcatctcttcgtgacccaaatcaatcgctgagcaataagcaag
+aaaacacagattatacaaagagatctggatgaagatattcgtgcaatcactatcgttatg
+ttagagagttccatgcatgaggactcgttttttgaccaggagaattaagccaagaaataa
+ctgacgtatttccaaatgaattctacgtgtttttcctgtcacctttagccagtgttaaag
+atgactatggagtttcgaataggttattctatagacattataacgagtggaacacccata
+ccttcacagtgctaaaggtaggaacgggtacgtcaggtagttcaagggattttaggttct
+taatccaacgaagaaataacgcatcacccgtcattctattgttttcgtcgggattactta
+gtaggcagggtattctaacctacctgagttacaaatctttaaaaaactggccatgaggtc
+atggtgataaaatctgaatcgcctaaattcgcgtccctaaggaaatatactagaatccgt
+ctcagaaagtgcaaaggttgacttcttcccctaacacagaattctcagttttatagctat
+ctagtggcattcctttttataaaactttacgtttgtaagggtccaactttacaaaagctc
+ggatgtgtatgtgtaatcttccgccgtgtaagacttggaacccatgtatattgacggcat
+ggcgtggctaagcaggtattgatcttcagtgtaaagcaaggtatgttctaatctaacaat
+gtaaagccggggattagccgccaaaggggtctaatgacatagagatgctctgaaatcgta
+ccaactataaaagcacgggatttgaaatatagcgacagatcttccgtattctgttagttg
+acatctgtgctgtctttaccgattgtgatttggctttagcagtcatttagtttcgttact
+cattgctcgtgcgatagttccaccgaatatggcacattcgttctttttttccattttact
+gcaaaccttttcaaaagctgatcgataccactgatgatggcattgattagtcgattggca
+actatgtcctgcttatatctccaattgcattgaatatagtaaaaaataaaggctcgcctt
+cccaatgggctacggagtacacgaaaaaatcgcaactcgtttaaccaagcgccgtaccta
+acatataagtgattgagacaaatagttctccagacgtattgagatatatgtctcctatag
+gcaagcgtttctaattgctgaccagaaattagaattaggttgttaatactatattcgacc
+attttattccacgaatgtgctattctactggtattgctccgtatgcgatatataaccaac
+acggaaagtcgtcgattgcaaagtggctccgtagaatcatttctggtcatttaccgggag
+cgcgcttgaacaatggatgcggtatctgccatattgttattgttaaaaagacttccgctt
+actatcgcttcgatcatcggaaaaatattaatgaggattgggtcgtataagaaaatcatc
+ttttcagttcgcagatttttgccaatttaaccggttatttcgtcagacttggtagtgtag
+ttacaagcatcacgattatatcagctacagaattaaactgtcctgactcgacggggcagt
+gtgtgagtattgcgctatatattcaaggtaacaggaggcatataggtcatagtacaagga
+taatgaggtttgctaactttaaaaattattgatttaacggttgattgaaaatctctgcaa
+gatgacgctagaacacctgatgttcaagtttgccgataataacatataagatgaattact
+gtctttagaccctcatgttaatccgctaacttagggcggaaacaatgttaggctatgcgg
+agtaagtactatattatgataccacatagaatttaacattcatatgatgtctaatacccg
+ttcccaaccttgcaaccgtcccgattaattaagcaattacggtcatcaatgggccaatcc
+tgtctcaaaaattatcatattcaaggttcagctattttggcaatgggtgagtaccgttct
+tagtgatttacgaacccataatctaggcgacttaatatacaagatttagagttacgtttt
+ccgggtagtacatattaacgaccatggatcgggtgaggtgttgtattagttatctgatct
+tgtcagtagctcccaatgtcccagaatattatgtttctactagagtgttcgtatactgga
+atttaaatattatgtaagactagacaaattttatggatacattaggccatcgtagaatat
+gatatagttgtaacgtccctctatagattttcggagggcaggtatattgcttaataaaga
+tgttcggaaatcagcggaaaggatttgtaattaactgatgcgcagcgcttaaataagttt
+agactattaagctatatgttcgacagcatgtagttttttttaccagaaagtgttatactg
+atgacccatggaggtagctcctcatgataaaaatattgttacttaagcattactattata
+gtgttcaaactagtaccgttgcatactttaagaatcagacatggcgtttcttatgcagac
+acacttttttagctgttgacgcccacctcacatccatagtaggtcaatcgcataagaaca
+atattctggactgttttattacccagaagaaagttttttctttccggttcgttaagacaa
+taaagatcatttcattcgttctcttaacgatgaactaaagtacttaaagtatccgcctct
+tgtttcgactagcgcatagtgtaataattaaggcaagataagaagaacaggaacgcgcac
+gtcggagataactctaatagtctctttattccgtttaatatagcccgtaattgcaccatg
+cgctacagtaacggccgccttcgcaaacctatttatgtaattccaagtttaggtatgcaa
+tggttggggcaatgtgaggggttttatcaagactttcgttgcttcgcggggggcgcaaag
+cagactttacagtagttaaccgaaaaccgcagggagtcgctctaagtgttaccaacccct
+cactactacgcgaaggtactcgattattccttgaatgggctgaaacatcgtgattagcgt
+cttatgattcaggctgatagaagaaaacttattttctatattccacgtatacaatcacac
+tcgtaactaaatagttcccagcgttgtaatgtcgctataataaataaaatacaaagaaaa
+ttcgtctgggtgcataagtacagttagtcgtctgtcacataaataatccgcagtcgatct
+cattacaggtattgttgttggtcaaccttcgcaaggtggtccaagtagcattgttgaaca
+gtaaaactaccgtcacacaaggaatatcataatagatgccatacacggttttacttgata
+tgtttacagtccttgagttgcaatcgtagtattgtttcatccggggtgtgtacgaagtaa
+tttagacaaggtgtgtagcggtcactaggtaaaatgacttaggatggatgagcatttagg
+tattctatgataacactaaccatcatgtttctaaaatcctcaggaaatttgtattatttt
+accaacctgtatttatagaaagtgcttttgacttaaagaagccgaagtgttcaaattaag
+gagtacctgattgaaagaatggggaattgtaatctgtaactcaattacaaataagccgtt
+ctaaggattaaggctttgtgtctaagcaactcacgtgaattcgaaattcatactcgatta
+acgactttaatactcttctgcgtatctacagactcatttaaattacggaatatgttttcg
+tttttggtttccagctcgcacgtacgcgtttacaaataaggacacctggtacaattggct
+ggagtacaatgttggtttttatttgctgattatcccgatccctgtgggcgttggcataac
+cgggttttcttcaagactactttcgtgttgcttatatacctggtaatatcggtgagtagc
+ttagggcttaatcacaatactaacaagttctctatggattggacagggcggcatccgttg
+actgaacgatctattaatccattccctgcactggataaacaagacccatttaaattgacc
+atagagatgttagcgtcatatttctgttcgtgatagggtacatatattataaacggatta
+tgagcagtggttttctagaaaagcattcatagttaggagtgtatcagatcataccactga
+accatagagcacaattctctactggctatacttcattcctttttgtccgggtggggacga
+aatttaaaggttctaacctagaacgcagagcgaattgatcaaggcgctggccaagtgaac
+ggttctaaatgttcttaatgagaattgcgtattttgactattgacagggcatcgtaaacc
+gctactcgacttggtatctgtaatctgtatgtagatagagtacgggcctataattcaaat
+tcagccaccgaagattcacaatcttcagacgtttgaaggaaagaggtttactggtatgtg
+gtgtcaagccccacccattctctgttatatccgagcattaatgtagtttcactgtactac
+ggtcacgccgtagagtcggcagggcaaatccaaaacaatttaggctgagaagtggcacta
+taatagtttagcctaagtcccttcgctaataactcaacaaagatgacgcaaaagtcggcg
+aatagattgcgttcgcgtaagggtatcttgaatactgatagctctcatggtaccaagaac
+tttcataacctctttatttaccaaacctgttctactagcgttagtgttttagtctgtagc
+cgacacaaaaaccgagaatggccggcgtaaccggcgcctgcaagctaacatgggatcaaa
+actattggcttaacgtttaatcgaatgagactagcactgtattactctttcgtttcggca
+gcggatcaataaggaggtgacggcatcactctcttatagtagatatcacttattctcaca
+acggaagtaggatcttccgtcctcattaaatttgcaactggctcaatgtaacactgtaat
+gttaacaaagtatgagctgaaggtcagagcagacgatgtagtaaggtccctcgaagctgc
+ttacagtatccttgaggctcaacgggctatgcggaaattccagacctcgagttacattat
+gaaacgtgtcattccatctcattaaatagttcgtgccctatcgccttgtaatataaacaa
+ccgtttttgtctattttcccaaggagaaggagagtagcagcttagtggcttgcctatatg
+gccccctaagtacgtactcggcacgcttagaagattgggctaccccgcactatatgttcc
+caaagtaggtaacctagatagtgtcgtatgaaattcaggtcatcgatgagagtataaaaa
+tatacaattttggcaggggttatacattgcgggcatgaagagtaacattggacatgaacg
+gacattcgaaccctgtgagtttaataccctatctccggatcattataaagtaaatatacg
+tcacttactctacgtgcgtttagacagtctttgaaactaaattggttatttttctttcat
+ctagatttgtctgtatctaactaaattatagttccacataaagctgattcaactgaagac
+ataaatataaactttctaacatagtagcgaggaaagagctatgcctagcatcggatcatg
+cgtccgcgagtagttcctggtagagttaaaagtttttccagaatctagaccgaacacagg
+gtagtgaacgaaagtgcgcggtgaacatacataataccgaacgtaaacaattccgttcgt
+attgttgctgtatctatatttcctacgtaaggctatttgatctataatatgaaaagtcac
+gtcgaaataaatcaggaagcgcttcgagtatgtacattcagatctccttagtatcatcaa
+attatagattttacggccacgaattattggtctagatgtcccaaaaataatttgatgtca
+gtagcgatcgtgcttcctcggagttgaggttggaagaagagtcattatgctataccaaga
+actctccatccagtacctagaaaggcaggtatgtaccgctcattaattttgcgatcttga
+cagatctgcatgcaaagtaacttgtaccagatggcttttataatagaaactaagtttccc
+gaataacggtgtacgataacagatttttaggtgtacagacgtctgactcaatgaacacac
+attgggacctgccccgggaggagtagtagataattaccttctccagcgcgggtcttttaa
+tatcacaacataaaaatactaattaatatcacacaccctcatcctcgatggagcctagca
+tcatacacgtttgatagacaacgccaattttactgtaatatgatattcgaatctagtatg
+tggacgctgtaccacattgtttaaaggagctccctttaccgacatgaacgaagcaagctt
+tgtacaagatacgaagaactcagtactggtaactataagagacaatttatacataaaagt
+gttaagaccattatataaaaagaggtatgaggtctttgtaactacaataatacattcatc
+gaacgatggagaataacagagttatttctgctgctcgagctctagttctgctaatttctc
+aatcttgatgccactcgtttgagtcttccattcgctcttaacgacgcgtacatccctctc
+tcctactcttacctatatcctattactggttaacctacatctccgggaaagacgtaggta
+aagtggtccacgattgtattcacttataacacctagtagtactatgtgttgctgagagtg
+aggacacacttactctacgagttcaagtccatatggacattacactttttcagcatctag
+gtgtcatgatgtattaacagccgttaggggctatttgattttatcgattgtcggcgtgtg
+tattttcaacaactaggtgctacaattcgtgaataggcatgaaaattcaagattgcagtt
+cctatcttgtataatctttcctttggacgagttgtaccatttcaactaacctgcaagtgg
+ggggtcatccatatgaagatttgccaaatacctggagaccctgaaaagtttatccagatt
+aataataacaaacaaacctaagcgaagaacgtcagctttaataaactatcactatcatag
+aaattcctgttaattgttcttccaaacgttgaatagactatcacgggtaatagattgaac
+acggagaacgtttatccggcttgtaaaatatcgtcgaatctgctgataactcaattatat
+tcgatggagaattcatatctaccgcttagcttttaaaaattaagtcagattattccgcca
+caatgagaaggcgcgagtgcactaatcaaatcacttaggattattacggacgtctgcatt
+acaatgctttggggtagggttatacaagcatatgattctttaggtctcttgatcgggcgt
+ttaccaccgtagcttaatgttggcatatccgtgatcctaatattctgttgtcagcgtgtg
+tataggaatgcacaacgcaaatctttaagctgacctgttcatgaaagacaggagacacga
+ggcaccacctcaattctatgcaaaactctaacatagcgtggcactatgagtacgtgtaac
+gacaaggtctcatactcgatcctaagataattctcgtctggaaggttttaatctttaact
+aagagtagaacttagtttattgacttttacaattaggatacggttcgcgactctaccaca
+gggcatcatacctggagctctgctatctcgtgaccaaagtggcagcacacatagggtcgg
+gtcctgcatctactgagcaatccctttaagcattcctagtttgagagccatttagatatt
+gctgtttaaaccgattaatggtttctattattataaagtgtaacgctcccattcgggaca
+ttgaaaattagcaataagacaatgtatgatattcggcgagtctcaacaacattatggtct
+accatgggacaaggggttgatatgatgaatccacaaaaaatagtcaaacacccatggttc
+gttaagtgagggtatccaggtgttataaggacgatctagaagtattcaggtacacggtgt
+tcagacatgctctaattgtcaggttgtttataatttaacgtatcgctctctattctaaat
+aatataaaattaaccgctcgtagggatgctttccagtaaaagatacactatcattaaggt
+tatgcaaatgtggcgatttgatttgaatcttagtacattcttaaacttaaatacgtatta
+tttaaagtaaatatattatctaaaccgcttttgtctatccacatttcgtcgaatcacgac
+ctcgttaatgcgacaatttacgaccctctttcatctaaagcgatcatctatttcttctga
+ttgatgtaatactgacccttactccgtacatacaaatgatggtaagcaagaatgactgac
+gctcctgtcacctttcgtggcaatcaactggcgctggtactgaagtagcttgaaagggat
+atggatgtgtatgccaggcttcattttgacaatttttctgtcctgctcagtgttgtctga
+agtcgtatcgtacacaataatgatgactctcattgtagatccaatcacgctttcctacgc
+taatgaaagttctagatagtgtaggtgttagacagaggttagcgcctacatccttacaca
+cacagtgttgaacggcaagcataatcgagtatcaatagctgtatgtatttgtttggaata
+tcatatttctcccgcctttgaacaatgatgccaaaatgtcctgccctagagttatgataa
+aataactgctgccctgtaacttaagtttacaaaccgatattcaatcgttgtgtcctatga
+aaatatttatatttgcaccaagaaaatcatctgtgcgatgaacaaaacacagtgatttat
+aaatacaaagagtacatttagttaccggattgcggcttgacatttattttacagaatttt
+atcggcaaaacacttcatatgaactatcgcttcacgataagtctatgatagactagcatt
+cgtagagaacaggaagagcaatcattatatatgaagtgttacagtgggtactacatatga
+gatcattaggtctatatccggccttcctcataagaccttggaaatatcttacatcagaga
+tatcaaaggaagtatgggcgaacccagaaaaagccccaaagaatagtaattcatcggacg
+taatagtctggttttaactaggggttattgatatttaagctaaaagagttccctgaacac
+tcgaaatgtataatctatcccaactaaaaaagtatacctctaattcagaaatgtcattga
+gattagactgatgtcaatacgctaggaggtaagacaagtagaagtttttgatttaggaat
+tgaaatgtaatacctccatcttaagttctatattttaaagttttatgcggacttcgagta
+agtgcacaaatgatggcataagtgcccagttacatgtttgcggccccgtatgagtaatga
+tctgtttatcaatctctagctactatcccacgaatgcactgatgccagtcatggcgctta
+cattagtcgacagaaatccgacgatacctatcacgcgtgaactgttctggttcttattca
+attcgaagtgatctcagatacattacggccatgcttgcccttcatgtctgctgagcagtt
+ttgttataggctgaatctcctctaagcgaaattgataggatttttggtggtcgatttagt
+ctgtacctgcttattaagattcaaaatgacctacttcttacgccgaaatgatagggatcg
+gctgaggaggataaatatacgctggtgcctggtatttatccagaacaagttgcctgtgta
+tcagatgaactctaatctccgagataaaaaacaggtacgtaaaataaaggccgcaaaggg
+ttacatctcaggatcgtggcgtatagtccaccattagttctgacttacttaatatagact
+gaccgagattgtagtatgtggatccaagcttgccatgtaaaacatgtcggttagcaaaac
+gtataggagcatgatcaaagaagagttaattaatagtactgcactataattgtcggcgga
+gtaccatgagctgttgcccaattcgatgtttattaacagcacgcataaaaaatccagact
+tttcaattagaattaactataaatggtccgcgaaccttaaatgatcggaaggacgggatc
+tgccgttgtatagaccccaactctatctaatttttataacacctctgtaatcaacaaatc
+ttattatgccatcattatgtcattcgccaagtaagtccagttcgagattctctggaccgt
+gcaatagtattgtcaaattatggtaatggaatccttcttctaacacccttagaaaagcca
+cgagaattgacaagttgggcgtgcttgtccaggagcaacataagtgccgtttctttttac
+gatgatagggattcttaaagcttttctctattctagatcccagttgccatcatcaatatc
+tcaattgatgctcattatatagttcttatttagtatgtccagatgtcactgaagatcctg
+cctagaaccgatattctcgacaggatcatcagttcgacggggcaaacgcacctatgcaca
+tccatcttgaccgtgaaacgaaaggaaagagtcagtaccgacccaatgtggaaaaaaact
+cctgtccacgatatgtaggcaagttttactgcctttaattagtagtcgattagtgtagtt
+tgatattatctaccttatagaatgtaaacagtaacccggccttaatggtttggcaggatt
+ctttgtaaaagttaataatgttcataaactttatcagaaaacctgaagtagtccgccttt
+cgcctgcgtaacgttgcagattaattcgttttacggagtggcttgcgtcttgttgtccga
+gtacacatattgctcctctcccccactcttctaggaaaatcaattatgctaacctgcaga
+ccttcttctttactatctttaatgcatgcccagtatgttcatagggtagacttgctatct
+attttgtataatctacgaatgatgcttggggcgcgacttttaacaattaagccgttgggt
+ataatttgagagggtgccacgatagtaagagatttccggcgtgagtaaggaaaatgataa
+taggattaagcaggcgtaatagctcaccctcctcagttctccaaccctgaaccggctaag
+tatgactgtgcagtattaattttgaatacatattgcagcccctaggatacattatagatg
+tctctttcttacccaaactcgcccgcaccaagaaagaatgtggattcgattgaggttaaa
+ttagccggaattacagacacagattcttgtttacaattgtgggaagaaaaccacctcaaa
+cgttgaaacctacattcacaaatggattacgttggggatgagaatcgattccggtcaaaa
+atcatgcccggagcaataaccaagaattcacagaggattaatacacttctccatgaagat
+aggactgcttgcactatccttatctttgtgtcttccttcaagcaccaatcgtttggggac
+aaccacaattatgccaagaaataacggaaggtgttccaaatctatgagtccgcggtttca
+tcgcaacgtttcactgtgggtatcatgactttggactttagatttgggtattctagagac
+tgtagaaagactgcaacaacaagacattcacagggcgaaacctaggaaaggggaccgcac
+gttgtgctagggatgtttccttaggaatccatacatgtaagaaagaatcaaccgtaatta
+tagtgttttcggccccttgaattacgtgcatgcctttgctaaaagacctctgggaaatag
+attgaatattctggacagcagcgaatcctgattatatctcaagcgaatatatgacccgca
+agaaggatttatactagaataagtctaagaaagggcattgggtcacttcttccactaaca
+cacttttatcagttttataccttgagagtcccatgcatttttatatatatttaactttcg
+ttgcgtaaaactttaaatatgatccgtgctctatctctaatctgaacaacggtatcacgt
+cgaacaaatctagtggctacgaatcgcgtcgctaagaacggtttcttctgctggcgttag
+ctacgtatcttctatgctaaaaatgtatagccccgcattagcagcaaaaccgggagaatc
+aaatacacatccgatgaaatcgtaacaaagataaaacaacgcgatttctatgtttgccaa
+agtgattaagttgtatcgtaggggtcagcgctgatgtcttttcagtttgggttttggatt
+taccagtcttttagtttcggtactatttgatcgggacattcgtccaaacatgatggctca
+ttcgttctttttttcaattttaatcaaaaccttgtatttacctgatacattaaactgagc
+atcgcatggaggtggagattcccatatatgtaatcatttgatatcctattccattctttt
+tagttataaataaacgctccactgcacaatgggagtaggacttcaccaataattagcatc
+tactgtaaacaagcgccgtaacgaaatgattactgattgagaaaaataggtctcaacaac
+ttttgacagatatgtatccgatacccaagcgttgctaattgcgcaaaagtaagtagaatt
+acggtcgtattacttgttgccaaatggttattactccaatgggctattctaatccgatgg
+atacgtaggagagagtgtacctacaccgaaactcgtagtgggcttagtggctacgtagaa
+gctgttcgggtcagttacagcgtgcgaccttgtaaaatcgatcacggtgatgaattattg
+ttattgtttaaaagaagtcccctgaatagcccttagataatacgaaaatttgttatgtcc
+agtcgctcgtatatcaaaagattcggttaagttcgcagagttttgccaagtttacaggtg
+atttactaacacttgggagggtacgtacaaccatcacctggttagcagagaatgaattat
+acggtcatgtcgcgaagggcaagtgtgtgagtattgaccgagttattaaacgtaaatgca
+ggcatttacgtcataggacatcgagtttgtcctttgcgaaatgttaaatttatggttttt
+tccgttgagtgataatagctgcaacatgaagatagtaaaactgaggttaaactttcacca
+tattaaattatatgttcaattacgcgatgtacaaactaatgttaatcagatttaggagcg
+cgcttaatatgggtccctatcccgactttgtacgagattttgataaaaaatagtattgta
+aattcatttgatggcgtagaaccgggcaaaaccttgaaaaaggacacatttaggatgcta
+tttccctaagaaagcggaaaatcctggctcaatatttataatagtaatggttaagattgt
+ggcccaatcgctgagtacccgtcttacgctttttccaacacataatcgacgagaatgtat
+ttaaatgtttgagacttacgttttccgcgtacttattattaaagtcattggagagggtgt
+cgtctgggtgtagttttctcatctgctcaggagctaaaaatgtaaatctattggttgttt
+ctaattctgtcgtccgtgtaggctatttaatttttatggtacacttgaatatgtttagcc
+ataatgtagccaatactacaatatcagatacttgtatacgacctatagacttttgccgac
+cgctcgtagagtgatttagaaagatgttcggatagcacagcaatcgtttgcgaatgtaag
+catgcgaagcgagtatttaactgttgactattttgctatatgttactctgaatgttgttt
+tttttaccagaatgtgttataatgatcaaccatgcacgttcctactaatcatataaattt
+tgttacgtaagcttttctatgatagtggtctaaagactacccttgcatactttaagatta
+agacatgcactttaggaggaactcacacgttttgagctgttctagcccacctataagcca
+ttcgtccgcaatcccataactacaatagtcggcaatcttttattacccagaactaacgtt
+tttatttcccggtacgtatcacattaatcttaatttaatgcgtgagagtaacgatgaacg
+aaagttatttatgtttaagccgcttcttgagaatacagattactgttagaatgaaggcat
+cataactagaacaccaacgcgcacctcgcacattactctaatagtagctttattcagttt
+aatatagacagtatttgaaccaggcgctaatgttaaggcccccttcgaaaaccttgttat
+gttattccatgtggtcggaggatttgcggggcgatagcgctgggcggggatcaacaattt
+cgttcatgcgagcgcccccataaccagtaggtacagttcggaaaagaaaaccccacgcac
+tcgctagaagtgttacaatcacatcacttcgtaccgaagggactactgtattccgtcttg
+gggatgtaacagactgattacagtcttatgatgaagcctcattcatctaaaattagttga
+tttattccacggatactatcacactcctatagaaagagttaccaccgtgggaagctagat
+ataataaataaaagacatacaatattagtatggctcatgatctacacttactcggatctc
+tctttttttataaccagtagatcgcattacacgtattgttgttccgcatcaggccctagg
+ggctcaaacttccatggtggataactaaaacgtccgtcactaaacgaagatattaataga
+tgaaatacacgggtttacttgatttctgttcagtcattcacgggaaatcctaggagtctt
+tcataacggcggtcttagtaggaatgtagtcaagctctgtagaggtctcgacggaattgg
+tatttcctggcatcacaatttacctagtattggagatcacttaaaataatgttgagataa
+taatcaggatatttctagtatgtgacaaacctctatttagtgattgtgattttcaattaa
+acaagacgtaggggtcaaattaacgactacatgttggaaagaaggccgaattgtaatatc
+taactcatgtactaagaagaagtgctttcgtttaaggctttctgtctaacattctaacgt
+caattcctatgtaatactactgtaaccaagttattactcggctgcgtagataaagtctca
+tgtaaatgacggtttatctgttacttttgggtttcaacctagctaggacgccggtactaa
+ttacgacacctgcgtatagtgcagggtgttcaatgtgcctttttatgtccggattataac
+catccctctcccacttggaatatcaccgggttcttaatgacttagttcgtcttccttatt
+ttccgggtaagatcgctgtggaccggacccattttgatctagtctaaaaaggtatatagc
+gtttcgtctggcccgcttacgttcactgaaacttagattaatcaatgcactgcactggat
+taacaagaacatgttatagtgtactgacacatgttagactaagaggtctgttcgggttag
+ccgacttatatgtttaaccgattttgacaactgggttgagagataacaatgaagagtgag
+gactgtagaagatcttaaaactgtaccatagtgctcaattcgctaatggcttgaattatt
+taattgttctaaccctggcgtcgaatttttttggttcgaaaatacttagcacagcgtatt
+gttcaacgagatgcacaactgtaccgttagaaagcggcttaatgacaaggcagtattgtg
+actattgacagggaatcctaaaaagctactcgaattggtatatggaagaggtatgtactg
+agaggtcgcgcctattagtcaaattctgccaaagaagagtcaaaagcttaactagtttga
+tggtatgaggtttaatgctaggtggtctataccaccaaaaagtatatgggatatcccaga
+atttatcgactttcaatcgtctaccgtcacgacgtacactaggcagccctaatccaaaac
+ttttgaggatgagtactgccactattatactgtaccatttgtaacttacattttatatct
+tcaaagaggtagatattgtcggccattactgtcacttacactaagggtagcttgattact
+gatacctctcatggtaaaaagtaatttaagaacctatttttttacataacctctgctact
+accgttagtgttttagtcggttcaagtcacaaaatccctgtagcgcacccctataagcag
+aaggaaaccttaatgcggataaaaacttttgccggaaccgttaatcctatgagaatacca
+ctcttggaatcggtcctttaggctgaggatatagaacgaggggaacgcatcaatctaggt
+taggtgagagaactttgtatcaaaacgcaagtaccatatgccgtcctcagtaaattgcca
+aatgcagaaatcttacactcttttcttaactaagtatgagagcaacctcactcctgaaca
+gcttgttacctaacgagaagaggctttaagtagcctggagcctcaaccggatatccggat
+ttgactctcatccacttacatgatgattacggtcattacatctcatgattttctgagtgc
+cctatagactgggaatttaatctaccctgtttctatttgttaacaaggagaaccactggt
+caagatgacgcgcttccatttatgccaccataagtaagttctcggaacccttacatgatt
+ggcctaccaacctatatatgtgaccaatgtacggtacatagagtgtggcctatcatattc
+aggtcatcgagctcagtatttaaagattatatggtcgctgggggtattcagtgcgcgatg
+gaagactaacattggaaatcaacggaattgacaacacgctcactttaataacctatctca
+ggataagtttaatgtaattagacggaactttctctaactccgtgtactaactctttgaaa
+ataatgtgggtatttttatttcatctagatttgtctgtatcgaaagaaagtattggtcca
+aataatcctcagtaaaatcaagtcataaatataaaatttagatcttaggacagaggaaag
+tgctttcccgagcataggatctggcctacgccagtagttcatgcttgtgttaaaagttgt
+tactgtttatagtccgtactcagggtagtgttcgatactcagcggggaactgacatatta
+cactaaggaatcaaggcccttcgtatgggtcatgtttatatatttaattacttacgctat
+ttgatcgagaatagctatagtaacgtcgtaagaatgcaggatgcgattcgagtttgtaaa
+ttcacagatactgtgtatcatattattatagatgttaaggcatagaattattggtattga
+tgtacaaaaaattatgggtgggcagtaccgataggcattacgagcagtgcagcttggaag
+aactggatgtatcctataactagtaagagccttaaaggtactacatacccagggatgtta
+ccatcattaatttggccatcttcaatcttcgcaatgcatactttcttctacaagatgcct
+tttagaagacaaaataagtgtcaacaataacgctgtaacttaactctgttgtacgtggaa
+tcaagtctcactaaagcaactaacattccgacatgcaaacgcaggactactagattatta
+aattcgccagcccgcctcgtttaatataacatcataaaaattctaagtaatatctcacac
+actaatccgccatcgtccatagcatcagtcacctgtcttacacaaacacatgtttaatcg
+atgttgttatgccaagctagtttcgcgaccatgtaactaattgtggaaagctgctacctt
+gaacgacatcaaccatcctacctttgtacaacagaccaacatctctgtactggtaaatag
+atctgaaaagttataaatataactgttttcacattgatagaaaaacagctatgtgctatt
+tgtatatactataataaattaagcgaaacatggagattaaaacagtgttttctcatcctc
+cacctcttgttctgctaatttataattcttgatgccactcgtgtgagtcgtccattcgat
+cgtaaagaacccgacataaatagatacgacgctgaacgagatcctatttctcctgaaaat
+tattagcacggtaactcctagggatagtggtactagttggtatgaacgtataaaaacttg
+tactactttctcgggatgtgagggagcaaactattactcgaccagtgcaacgcattatcg
+acagtaaaagttttcagctgatacctgtctggatggattatatgcaggtaggcgagagtg
+gattgtagcgatgctcggcgggggtattttaaaaatctaggtgataaaagtcctgtttag
+ccaggaaaagtcatcattgcactgcatatcgtcgattagctgtcatttcgtccactggta
+ccagttcaacgtacatcaaagtccgggcgcatccatatcaagttttgcaatagtactcca
+gaccatgaaatggttatccagattaataataacttaatatactttcactacatactcagc
+gggtattaaatttcactttatgtcaaaggactcttatgtggtcttcaaaaaggtctagag
+tctatcacgcctaattgtgtgaaaaccgagtaacttgatcagccttgtaaaatatagtag
+aatatgatgttaaatcatttatattccagggagattgaatagcttacgattagctggtat
+aatttaactcacatgattaagcaaatatctgtaggaccgagggaaagaataaaataaagt
+accatgagttcggaacgctgcattacatggcgttgggctagcctgatacaagaagatgag
+tatggagctctcttcatcgggacgtgacaaccctagcgtaatcttggcagatcccggagc
+agatgattatcgtctaacactgtctttaccaatgcacaacgcatagatttaacctgaact
+gttctggattcactcctgactacagcctacaactcatttctatgcataactcttaaagac
+agtcgcaatatcagtacctctatacacatcggatcagactagatcataagataagtctcc
+tctggatccttgtattctgttaagtacactacaaatttgtttagtgtctgggacaattac
+gataagggtcgcgactagaccacagggcatatgacctccaccgctcctagcgagtctcca
+atctgcaagcactcatacgctaggggcatgaatcgactgtcaatgcactgtaagatttac
+gagggtgagacccatttagatatgcctcgtttaaccgttttaggcttgataggatgagtt
+tgtcgatccatcaaattcccgacattcatattgtccaataagtatatctagcttattcgg
+actcgctaaactaaattatggtataaatgccgtcaaccggtgcatttgttcaatcaacaa
+attatagtcaatctcccatggggccttatggcagcgtatacagctggtataacgaccata
+tacaactatgaacggactagctgtgaactaagcagattattggatccttgtgtataattt
+taagtttcgatctatatgctatagtatagaaaatgttccgatcgtacgcttcctttacag
+ttaaacagtctatatcatgaagcttatccaaagctggacatttgatggcaatcttactta
+attatgaaacttaattacctattattgaaagtatttatatgatcgaataagatttgctct
+ataaacaggtcgtccattcacgacctagtgattgcgtaaattgaccaacctaggtaatct
+aaagcctgcatctatttcttatcattcatgttatactgacccgttctcagtacttaaaaa
+tgatcgtaagcaagaatcactcacgctcatgtcacatttagtcgaaataaactgccgatg
+ggaaggaagttccgtcattgcgatatcgatgtctatcccacgcgtcattttcaaattggt
+tatctacggataactgtgcgatgaactactataggtcaaaattatcttcaatctcattct
+agatcatataaagatgtccttcgcgattgatacgtctacagtgtgttggtgttacacaga
+gggtagcgactacttacttactaactctctcttgatccgcaagcataagccaggttaaag
+tgctctatctttttctgtggattataatagttataccgccttgcatctaggtgcccatta
+ggtaatgccctagtgttttcataaatttactcctgccatctaacgttactttaatttccc
+agattcaataggtctctcatttgaaaattgttatatgtcaacaaagaatataatagctga
+gtggaacaatacactgtgagggagtaatacatactctaaattttctttacggtttgcgcc
+tgcacagttttttttatctatgtgatccgcataaaaagtaatttcaacgttccattcaag
+ttaagtcttggtgacactagcattaggagagatcaccaagaccattatttatttagctag
+ggtttaagtcggttagaaatatcagataatgaggtctttatccggccttacgcagtagaa
+attggaaatttcgtaaagcactgagttcaatggaagtatggccgaacccacataatgcac
+aaatcaagtcgatttcttccgtccttttagtctcctgggaactacgggttattcatagtt
+aagctaaatcagttaacggaactagacaaatgtataatagttcccaaatatatatctata
+aatcttatgcagttagggaatgcagatttgaatcatggcaatacgctagctcggaactca
+actacaagtgttggatgtacgaattcaaaggtattacatccttatgatgttcttttttgg
+atacttttatgacgacttccacgaagtgaaattatgttcgaatatctgaacagttacttg
+gttgagcccaaggatgacgaatgttctgtttataattctcgtcataatataaatacaagc
+atatgaggccagtcatggagctttcatttggactaacatttccgtagagtcatatcacgc
+ctgtaatctgatccgtctttttctattcgaagtgttatcagatacatgacgcccttgcgt
+gacattcatggctcctgacatcgggtcttttaggctgaatctaatctaacccaatttgtt
+tggattgtgggtcctccattttgtctgttaatgcttattaagattaaaaatgtactacgt
+atttagacctaatgattgcgatacgctgtggaccattaatataagctgcgccaggggatt
+tttccagatcatctggcctgtgtatatgttcaaatctaatagccgagagaaattactccg
+acggaaaataaaggcagataagcgtttcagagcaccatcgtggcgtttagtcaaccttta
+gttcggaatttattaatatacaatctcactctttggacgagctccttaaaagatgccctt
+gtatatcatgtcccgtacctaaaagtataccagcatcatcaaagaacagttaaggaatac
+gactgctctataattgtccgaggagtaccttctcatctgccaatagtcgttgggttggaa
+aacaacgcattaatatgccacacttgtcaattagaagtttctataaaggggacgagtaac
+tgatttgagacctagcacggcagaggacgttcgtgtgacaacatctctttataagtttga
+gataaaatcgctaatctacaatgattatttgccaatcattatcgaatgcgcaaagtatct
+cctgttcgtgattctagcctaaggccattactatggtcaaattatgctaatcgaagcagt
+cttctaacacccttagaaaagcaaacactattgaatactgccgccgcattcgccagcacc
+aacataactgcacgtgcttttttccatgattggcattatgaaagatttgatctatgattc
+ttaccagttgcaatattcaatttagcatgtgttcctaattattgtgttattatggtctat
+ctcatcatgtaaatgaagatcatgacgtcaacacagattctagtcaggatcatcagttcc
+tcggggaaatcgcacctaggaacagccttatgcaaccgctaaacaaagcaatgaggatgt
+accgacaaaagctcgatttaaaagcctcgaaacgagatgtacgaatcgtttactgccttt
+tatgaggagtcgagtactgttggttcatatttgctacatgattgtatgtaataacgatcc
+cgccctttatcggttcgatcctttatggcgataagttatgaatcgtcagtatctttagat
+caaaaactcaactagtacccagttccccggaggaacggtcatgattaatgcgttttacgg
+tctcccgtccctcttcttgtcagaggaatcagtttcatccgatcccactcgatgattggt
+atagctatttgccgaaaagccacaacgtattcggtactatcttgtttgattcccctgtat
+cttaattcgcgacacttgatatcttttgtgtttaatcgacgaatcatcctgggggcgaca
+cttgttacaattatccagttgcgtttaatggctgtgggtcacaagattgttagacaggtc
+ccgcgtgtcgtaggaaattgataattggagtttgcaggacgaatagctcacccgcctaag
+tgatccaaccctcatcaggataactatcactgggcagtattatttttgatttcatatgcc
+accccctaggagactgtagtcatgtatctttcttacccaatctagcccgaaacaagaaag
+aatgtcgattccagtcaccttttattagaccgatttacacacaaagtgtcttggtttaaa
+ggctggcatgaatacatactcaaaagttgaaaacgacttgctctattcgattaccttcgc
+gatctcaatcgattacgctaaattttaatgcccgctgaaatatccaacatttaaaacagg
+attaattctctgatccatgaacttaggactcattgcacgtgacttatctttctctcttaa
+ttcatgctccaatacggtgggctaaaccacttttatcacatgaatgtacgcaacgtgtta
+ataagctatgagtacgcgggggcagcgaaacgggtcaatctgggtatcttctattgggac
+ggtacatttcggttttatagactatgtagttacacggcatcaacatgtaattaaaacggc
+gtaacctaggaaagccgaacgcaccttgggattgccatgtgtccggaggattacatacat
+ctaagaaacattctaaactatgtatagtcgtttacgacccttgtagtacgtgcatccctt
+ggcgaaaagtactctgggtattagagtgtatattatcgacagcaccgaatcctcatttta
+tagcttgacaatttatgacccgaaagaaccttttataagtctataagtatatctaacgca
+attgcggcactgagtccactaactatctttgagcagtgttatacagtgagacgccatgga
+aggggtttatatattttactgtcgttccctaaaaagttaattatcagacctgcgcgatct
+cgtagatgaacaacgcgatctagtcgaaaaatgcttgtggctaccattccagtcgagatc
+aaccgtttctgcggatcgcgttacattccttgcttatttgcgataaatcgatacaacccc
+attaccagaaaaacccggagaatcaattactctgcagatcttatactaaaaaagagatta
+caacccctgttctatgtgtcccaaagtgagtaacgtggagcgttggggtaagagcggagc
+gattttaactttcgcttttccattttccagtattgtactttacgttatatttgagcggca
+cattcgtcaaaacatgatccatatggactgaggtgtttaaatgttaatcaaataattgta
+ttttcagctgactttaaaatctgcagccattggaggtggagattccaatagatgtaagca
+ggtgatatcatatgcaattcttgtgacttattaagataccagacacggcacaatcgcagt
+agcacgtaaacaataatgacaatcgacggttaaattccgaacgtaagatatgtttacgga
+tgcactaaaataggtagcaacaacgtttctctgagatgtataagttaccaaacactggag
+aattccgctaaactaaggacaatttccgtcgtattaattgttgacaaatggttagtaata
+cattcgcagtggataatccgttgcatacctagcactgagtgtaaataaaaccaatcgact
+actggcatttcgggctaacgactagatgttagcctatgtgaaagcctcacacatgcttat
+tgccttcacggtgagcaatgtttcttattcgttattagaagtcacctgtagagacagtag
+agatgacctaaatttggtttgtccagtcccgaggtgatctaatgattaggttaacttaga
+acagtggtcaattggttaaagctgatttacgaacacttccgaggggtcgtaaaacattaa
+actggtgagaacagtatgatgtattcggtcatctagacaaccccatcgctgggagtttgg
+acagtgttatgattcgtaaatccaccatgtgtccgaattcgaaatcctgttgctccgggg
+agatagggttaatttaggcttttttacggtgtggcatattagctcaaacatcaacattct
+taaaatcagcgtaaacggtcaccagttgatatttgttctgctaggaagcgatgtacaaaa
+taagcttaataagatttaggtccgaccttaatttcggtccatagcacctctttctaagtg
+ttttgcttaaataattgtattgttattgattttctgcgagttgaacacggaaaataagtc
+aaaaaggacacttttaggttcatatgtaccgatgaatgcgcaatagaatcgagaaatttt
+tagattagtaatcgtgatgattgtggccaaatcccgcactaaacggctttcgctgtttcc
+aaaaaattttagtccactaggtatttaaatgttggacactgaacgtggaagccgtcgtat
+tatgaaactaatggcagaggggctcctctgcgtgtactttgagcagatgctatcgtcaga
+aaaaggtaaatcttttggttctttataattctggcgtccgtgtagcctagtgaatgtgtt
+tggttcaagtgaatttgtttagccagaatggaccaattacgtcattagctgttacgtcta
+tacgaaatatagactgtggacgacccatcgtagagtcatgtagttacatgtgaccttaga
+acaccaatcgtgtgcgattgtaagcaggacaacacagtattgtactggtcaattggttca
+tagatctgactatgaatcttcgtttttgtacaacaatctcggtgaagcttcaaaaagcct
+ccttcctaataatcagttaatttttcgtaaggttcctgttcgaggttagtcgtataaaga
+cgaaacggccttaatgtaacattaactattccactgtaggtggatctaacaaggttggac
+atgtgctaccaataagataagaatttcgtccgcaatacaatatctacttttgtagcctat
+cttggattaacaacaacttacgttggtatttcaccggacgtatcaaatgattctgatttt
+aatgactgagagtaaacatcaacgaatcttatgtatctttaagccgctgcttgacaagtc
+acattactgttagaatgaacgcttcattactacaaaacctaccaccaactcccacattaa
+tattatactagatgtttgaagtttatttgacaaaggttttcaaaaagcacagaatcgtta
+cgaacacgtacattaaattgttagggtattaattgtggtcggtgcatttccggccccata
+gcgctccgcggggagaaactatggccttcatgacagcccccccataacatctaggtaatg
+gtcggataactataaacaaccctctccagagaactgtgaaaataaaatctcttagtacac
+aagcgtatactggtttaagtcttgcccatcttaaagactcttttcactattttcttgatg
+cctcattcttctaatattaggtgattttttaatccgagaatataaaaagacgatagaaag
+tgttaaaacacggcgtagcgacatattttaaagaaatgaaatactttttgactatccctc
+atgatctaaacttacgcggagctatctttttgtataacatgtacagagaattaatccgat
+gcttcttccgattaaggacatagcgccgaaaacgtcatggcggcttatcgatatcgtaac
+gcactataccaagtgattaagtgatcaatgaatacgggtttcgggatttctgttaagtca
+tgcacggcaaatacttggagtcttgaataacgccgcgcgtagtacgaaggttctcaagct
+cgcgtgacgtatagaccgtattgctatttcctgccttctcaattgtccgaggattgctga
+taacttaaaataaggttgagtttttaataacgatttgtcgagtttgggaaaatcctcgtt
+tgtgtgtttgtcattttcaagttatcaagaactacgggtataatttacgacgtaatgttg
+gtttgatgcccgattgcgaatatcgtacgaatggtatttgtacaactgctttcctttatc
+gattgctcgagaacattataaagtctattactatggattaagactgtatacaagtgttta
+agcggagcccgtgataatctataaggttttggtacctttatctgttacttttgccttgaa
+acatacatacgtacacgggaatatttacctaaacgccgtatagtccagcctcgtatttgg
+gccgtgttttgtcagcattttaaactgaaagcgcccacttgcattataacccggtgcgga
+atctcttagtgactcgtcaggagtttacgcctttgagacctctcgacaggacccattttg
+atctagtcgttataggtagagtgcctttcctatcgcaccattaccttctagcaaacttag
+agtattcaatgaaatcatatcctgtttatactaaatgttataggctaatgacacagctga
+cactaagaggtctcttcgggttacccgaatgagttgtttatacgatgttgacaactcggg
+ggagtcatttcaatgaagactgaggactcttgatcagattaaaacgcttaatgactgata
+atttagattatgccgtgtattatttaagtgggcgaaccctcccctagaatgggtttcctg
+agaaaagtcttagaacacagtattctgaatccagatgcaaatcgctaacgttagtaagcg
+gctgtagctcttggcagtttggtcaatagtcaatcgcaatccgtttaaccgtctactatt
+cctagagcgaagagctatgttctgacacgtccccaatattaggcaaaggctccaaaagaa
+cagtcaattgattaactacgggcttggtttctccgtgaatccttgcgccgctataccaca
+taaaaggatagcggtgataccacaagtttgcgacgttaaagcgtcgaccctcaacaagta
+cactagcaaccccttagcaattaattttgtccatcactactgccaagagttgactggacc
+agttggaaatgacatttgatatattaatagagctacatattgtaccactttactgtcact
+tacactaaccctagcgtgattactcatacatatattcgtaaattctaagttatgatacta
+gttttgtaaatttaatcggcgaagacacgttctcttgtacgagcttcaactaaatatttc
+actgtagccaaccactttaaccagaaggataccttaatgccgatataatattgtccagga
+aacgttaatactttcacaagacaaagcttggaagaggtactttacgatcacctgatagat
+cgaccggaacgattctatataggtttggtctgagaaatttgtagctaaaaccatgttcca
+taggaactcctctgtaatgggcaaaatgcagatagcgttcaatcgttgcttaactatcta
+tcacagcatcctaactcctcaacagcttctttcctaaagacatcagcaggtaagttgacg
+gcacccgataacccagagcacgattggaatctaatactctgtatggatcattacgctaag
+taaatataatgattttctgactcaaagttacactgcgaattttatattaactggttctat
+ttgttaaataccacaacctctcgtcaacaggtcgcgatgcaagtgatccaaaaatatcta
+acttataccaaccattacttctggcgcagaaaaacatagatatctgaacaatcgaccgtt
+aagactgtctcgccgatcttaggaacctaatactgctcagtagttattgtttatttgggc
+catccccggattatgtcagccatggaacactaaaagtcctaatctaacctatggacaaaa
+agctcacttttataaaattgctcaccttatgttgattgttatttgtccgaaatgtctata
+actcagtgtactatctattggaaaattatggccggagttttattgaatatacttttgtat
+gttgagaaagaatgttgtcgtaataattatcagctggaaaatcatctaatatatattata
+ttgagatattacgacagacctaagtgctttcccgtcatgagcagatggactaacactctt
+ggtaatccttctcgttttagttggtaatgtttagtctaagtaatatcccgactcttactt
+actcagagcggaaatgactttttaaactaacgtttaaaggcacttagtatgcgtcagggt
+tatttttttaattacgtacccttgtgcagagagtttagctattcgatcctacttagtatg
+aaccatgagagtacaggttggtaattcacagagaaggtcgagaagattatttttgatgtt
+taccaatactatgaggcgtattcatcgaaataattttatggctgcgcacttcacatacgc
+aggaagaccactgcagcttgctagatctggatgtatcattgtacttctaagagcctgaaa
+ggtaatacattcccagcgagcgtaacagattgtatggggacatattcaatcttagcaatg
+cattcgttcttcgaaatcaggcatttttgatgtcataagttctgtcaactataaccctgg
+aactttaatctgttgttcgtcgaatcaaggatcaagaaagcttctaaaaggcccaaagca
+aaacccaccactacttcagttttaaattagaatcacaccctagggtattagataataatt
+aaatgtcttaggaagagatatcaaaagatgcagacatcctcaagtgaataagtctccggt
+ctttcacaaacacatggttaagcgatgtggttttgactagagacgttcgccaccatcgta
+atatttctggttacctgcgaacgtgaaccaaatcttacttcatacattgcttaaacagta
+caacttatctcttatcctatagagatctcaaaagtttgtatttttactggtttcaaattg
+agagaaaaactgcgttctccgatttctatattattgtttaaatgatgccaaacatccagt
+ttaaaacacggtgtgatcagccgactcagattcgtatcctatgttagaatgagtcatcaa
+actacggtcacgcgtacattacagagtaaactacacgaatgaaagagataagaagatgaa
+agagttaataggtctcctgttaattatgagaaccctaactactacggattggcctactag
+tgggttggaacggatataaaattcgactaagttcgcggcatgtcaggctcctaaatatga
+agagaactcggcatcgaattatccacagtaatagttggaacatgattcctctatgcatgg
+tgtatatccacgtacgccagtgtgcagtgtagccatgcgaccacgggcgttgtgaatatt
+cttcctcagaaaaggactgttgagcaaggaattggattctgtgaacggaatatagtcgag
+tagatggaatttcctacactgcgaaaaggtcatagtaaatcaaacgccgcgcgcagacat
+atcttcttggcaattagtactccactaaatcaattggttataaacttttagaatatcttt
+atataagttcactacttacgctgcgggtagtatatttaaagtgatgtcttaggaatctta
+tggcggcggaataaacggcttgactatagataccctaattctggcataaccctgtaacgt
+gtgaagcatgctttaatagacgactagatcagcttatagaatggatatgactgccacatt
+gaagagattaacattagcgggtataatgttacgaacttgtttaacaaaatagctctacca
+cacacgcatagtataatataaaggtcctggagttcgctacgagcctggaattgcagttcc
+cctaccctgagtaaacaagatcagtatggacctatcttctgacccacgtgtaaaaactac
+cgttagcggccctgagaacggtgaagttgattatcggctaacactcgctttaccaaggaa
+caaacaattgatggaacaggtaagcggctggattctatcctgaatacagcataataatat
+ttgctttcaatatatagttatgacactcccaatatcactaactctttacaaatcggatat
+gaagagtgaattagagatggagccgatcgttccttgtattctggtaagtactcgactaat
+gtgtgtagtctaggggtaaaggtccttaaccgtcgagtctagaactcacgcattatgaaa
+tcctccgagcatagagactctaaattcgccaagcaataagtcccgacgcgaaggatgaga
+agctcattgaactgtaacatttacgtcgggctcaccatgttacatatgcagcgggtaaaa
+gtttttgcctggagtggttgagtttcgcgatacataaaaggccccactttcatatggtca
+aatatctatatcgtgctttggacgactcgataaactaaagtagcctagtaatgccctaaa
+ccgctgcatttgtgcaataaaaaatttagagtatatataacttccggacgtatggctgcc
+ttgaatcctcggatatcgtccttatacaacgatgaacggtatagctcggaactatgcaga
+ttaggcgatccttgggttgaatttttagtttccatagatatgagttagttttgatatggt
+taccatacgtccctgcattgaaacttaatctgtatattgattgatccttagcaatagcgg
+cacatttctgggcaatatgacttaattaggttacggtttttactatgatggatacgtttt
+atatgatagaataacagttgctatttaaacaggtactacattcaactaatactgtttcac
+tattgtgtccaacatagggaatatattgcctgaatagatgtattatcaggcatcttttac
+gctccaggtagaactaattaaaaatgatccttagaaactttcaagcaacataagctaaaa
+gttacgccaattataagccacatcggtaggatcttcaggcattcccatatccttctctat
+caatcccgtctgttgctaattggttatctaagcatatcgcggcgagcatctacgataggt
+ataaagttgctgctatctaattcgtcataatatatacatggaattacagattcatacgtc
+ttcagtctcgtggtgtttctaagagcggacccaagaattacgtaatatctctctcgtgtt
+acccaagaagttgacacgtgattgtcagctatctttttctggcgatgttaatagttataa
+acaattgcatatagctgcaaattagctaatcaaatactcgtttcttaaatgttatcagca
+aagctttaggttctgtaatttcactgtgtaaagagggcgctaagttcaaaattggttttt
+ggcaacaaacaatttaatagcgcagtgcaaaaataatatctcagggtgtaattatttctc
+taattggtctttacggttggaccaggcaatgggttttttatctatgtgataccaattaaa
+agtaatttcaaagtgacattaaacttaagtattgctgtcaagaccattacgacacttcac
+caacacatttatgtattgtgctacgcggtatggcccgtagtaatttctgatattgaccgc
+gttatcagcaagtacgctgtacaaatgccaaatttagtaaagctctgtgtgcattccaag
+gtgcccacatcacacattatcaacatatcatgtcgttgtattacgtccttttactagcct
+gggaaataccggtgattcagagtgaacataaatctctgaaagctactagacaaagctagt
+atagttaaaatatatatttcttttaatattaggatctttgcgattgcacatttcaagcat
+cgcattaacctacctccgtactcttctacaacggttgcatgtacgatttctatgcgatga
+aatacttatgttcttagtttggggttactttgttcacctagtcctcgaacgcaaattagc
+ttcgaatatctgaaaagtgtatgcgggcaccaaaacgatctcgattcttaggtttataat
+tatagtcagaagataaatacatgcatatctggacactcttccacatgtcatgtcgactaa
+ctttgaactacagtcatatatagactgttatctgatccgtatgtgtctattactactctt
+atctgagaaaggacccaatggagtcacagtaagcgatcatgtcatcggggctttttccct
+gattataagattacactattgctgtgcttggggcctcctactttttctatcttaatcatt
+ttgtacattaaaaagctaagaagtaggtacaacttatctttcccatacgagctggaccat
+taatttaacagccgcaaggcgagttttaatgttaatctggaagggctttatgttctaagc
+ttttagcactgagaaattaatccgtaggaaattaatcccacataacccggtaagagaacc
+ttacgccccgttactaataatgttctgcgcaatgtaggaagtgacaagctcactcttgcg
+acgagctccttaatacaggccctgcgttatattcgaccgtacctataactagaccaccat
+cttaaatgtacagttatggttttcgacgcatagagtatgggaccacctcgaaatgctcag
+ctgcaaattgtactgggggtggttatcaaacatttaatatgaatctatggtaaagtacta
+gtttatagatagccgaacactaaaggtttgcagaccttcctcccctgaggaacttcgtgt
+cacaaattagattgagaaggtggtgataaaatcgcgtatctacaatgatttggtgcaaat
+atttatcgattgcccaatcgttctactcgtactctttatagcctaacgccttttcttggc
+gctaattagcctaatccaagaaggagtctaacaaaattacttaaccatactcttgtctat
+tcggcccacgcatgcgcaagctcaaaaagttctcaacgggcgtttttacttgagtcccag
+gaggtaacattggatctatgagtcttaacagtggaaatatgatttttagattgtgttcag
+atttattgtcttattttggtctatctcatcagctatagctacataatgacgtcttaactg
+tttcgactaaccttcagatctgactaccccaaatacaacatagcaaaagaatgatgctaa
+cgcttaactatcctttcacgatcttaacaaaaaagctccatttaaaagaatcgaaaacag
+atctaccattcgtggaatcaatttttggacgagtactggtcgggtcgtgcttatttgcta
+caggattgtttcgtataacgttcaagcactttagcggttccatccttgatggcgttaact
+gatgatgcgtaagtttatggtgatctaaaactctactacgaaccaggtcccagcacgaaa
+cgtcatctttaatgagtttttaggtctccaggcactaggctgcgaagtggaatatgtgtc
+atcagagacaaatagatgattcctatagctttttgcagttaagccactaagtaggcggtt
+ctatagggtttcattcaaatcgatcgtaattcccgactctgcatagcgtgggtcttgtat
+agaccattcttcaggcccgccacaatggtttcaagtttcaacttccgtttattggctgtc
+cctcaatagagtcgttctcagggcacgactctcgttcgttattcataagtccagtttgat
+ccacgaatacagaacacgcatatctgataataaaagcttaacgataactttcacgcgcat
+ggtttatttttgatttattaggcaaccaaataccagaatgtagtcagcgatatgtagtaa
+aatttagacaaacataaaacaaagtatcgccattacagtctcctgttaggagaacctttt
+tatcaatatgtgtaggcgtgtattggcgcccttgatttaataataattacggctaaacgt
+attgatattttccaggaactgccccatctcatgagatgaccctaaattttattcacacct
+catttttaattcttttatatcacgattatttatctgagcaagcatctttgcaagcattca
+tagtgacggtgctgtctctatgaatgcatgctaatatacggtgcgctaaacatattggtt
+caattcaatgtaagctacctcggaatttgcttgcactaagacggggaagccaaaacggta
+aatcgccgtatatgctagtgccaagggacttgtccgttggagtcactatggagttacaag
+cattataaatctaaggaaatcgcagtatcagtccttaccccaaagatacttcgcattccc
+tggggtacggaccatgaaatacttctttcatacatgataaacgatggagactcggttacc
+accctggtagttactccatcaattggagttaactaagatcgctattacaggctttattag
+ccaatcatcacaagcctctttttagagattcacaagttagcaaaccaaagttcctttgat
+aagtctttaacgagatctatcccaattccggctaggagtaaaatttatatatttgagatc
+ggggttaaagtcacacgcaatgcaaggggtttttatatggtaatgtccttccctaattag
+gtaattttcagacctccgagagagagtagatcaacaacgcgttatactcctaaaatgctt
+gtcgataacatgacactacagatcatccctggatgagcatcgactttcattacttgatta
+gttcagttaattcgtttcaaaccattttcaacaaaatcccccagtagatatgtatatgca
+catcttagactaaataacagttttcataccctgggatttgtgtcactatctcaggaacgt
+cgagacgtcccctatcaccgcagcgagggtaactggccctgttccattgtaatcgatggg
+acgggacgttatattgcagacccaaagtagtaataaattcagccatatggacggaggggg
+ggaattgttaagaatataattcgattttcagctgaatgtaaaagctccagccattcctcc
+tccacttgacattagttcgaagaaggtctgagaattggaattgcttgtgacgttttttgt
+ttccagacaaggaaatagcccagtaccaagtataatattatgacaatagaagcttaaatt
+cacaacgtaacatatctgttagcatgctctaatagaccgagaaaataagtgtctatgtgt
+gcgagaactgtcaattcacggcagtagtcacctaatctaacgtctagttcccgactatga
+agtcttcacaaatggttagtaataatttcccagtggagtagaagtggcataacgtgcact
+ctctgttaataatacctttagactactcccatttcgccagaacgtcttgatggtacccta
+tgggaaacactcacacatgcttattgcctgcaacctcagcaatgtgtcgtatgcggtatt
+tctacgaacagctagtgaaaggactgatgacctaattttggtttctcaagtccagacgtg
+atattttgatgaccgtatctgacatctctgggcaattcggttaacctctggtacgaaata
+gtccgtcgcgtaggtaaaaatgataatgctgtcatcactatcatgttttagctaagctac
+actaccccatcgctcgcacgtggcaaagtgtgaggattccgatatcatccatgtgtacga
+attcctaatactcttgctcagggcacttagggttattgtagcctgtgttaccgtctcgca
+tattagatcattaatcaacagtcttataatcaccgtaatcggtaaacagttgttatttgt
+tctgataggtagacagctaataaagatgctgttgaacagttacgtcccacctttattgcc
+ctacagtgaaactagttcttactctgttgctgtaatatgtctagggttattgatttgctg
+ccacttcaaaacggaaattaagtcattaacgaaaatggttccttcataggtaaagatcaa
+tccccaattgaagccagaaattttgagatgtcgattcctgatcattcgccaaatttacag
+ctcgtaaacgagttccatgtgtaaaaaaatgttgagtccactagcttgtttattctggct
+caaggtacgtggaacacgtagtattttgatactaatgccagacccgctacgatccctgta
+ctgtgagcagagccgatcctcagaaatagctaaatcttgtgcttcgttagaagtctcgac
+tacgtgtagcctagtgtttgtgttgcgttatagtctatttgtggacacagtatggtcaaa
+tgacgtcttttgatctgacggcgttaacaaagatactctgggcaacacacatacttctct
+catgttgtttcttcggacctttcataacctttcctggcacatggttagctgcacatcaca
+ggattgtaagggtctagtggttcagtgagcggaatatcattcgtcggtggtgttaatcta
+tctcggtgtagcttataaatgcatccgtaagaatattatgtttatttgtcggtacgttca
+tggtagtggtgtcgccgatttagacgtaaaggcatgtatggatcttgatctatgcaaagg
+taggtccatctatatacgttgcacagcggatacaaataagataagaatttactaacattt
+aaattttcttattgtcgagcatagattggaggaaaaacttatttacttggtatttaaacg
+gaagtttctaatgtttatgattggatgcacggacagtttactgcttactttcttaggttt
+cttgaacaacaggatgcactagtaacatgtctcgttcatgcttccattaagttcttctta
+aacttacacaaactacctaatttagagttgacgagatggttgaacgtgttgtgacaaacg
+tttgcaaaatgcacagtatcgttaccaaaaagtacatttaagtgtgtgcgtaggaattct
+gctacgtccattgcaggccacattcacatcccacccctgaatatatggactgaatcacac
+acaccaaatttcatctaccttatcgtagcataactattaacaaacatatacagacttcgc
+ggtaaataaaatatattagtacacaaccgtatactggttgaactattgcccagctttaag
+acgcttttaactaggtgcttgatcaagaagtattattatatgacggcagtgtgtaatacc
+tgaatagatatagacgttagattgtctgaaaacacgccgtagagacatttttgttagata
+tgtatttctttttgacgagccagcatcttagtatctgaagacgagctatatgtttgtaga
+aaatcgactgacattgtatacgaggcggcgtaagattaaccaaattccccagaattagta
+atggcgccttatcgatttactaacgatatataacttgtgatgttgtctgcaatgtatacc
+cgtgtaggctgtgctcttatcgaaggaaacgcattgaagtccaggctggatgaaaccacc
+gcgtacttccatgcgtctatacatagcgtcaccgatactacgttttgctatgtaatccat
+tctaatgggtaagaggattcctcttatagtaaaatatgcttgactttttaagaaccattg
+ggagtggttggcaaaataatagtgggtgtctttctcagtgtatagttttctacaactacc
+cctattaggttacaagtaatctggctttcttgccacttggcgatgatagttagattcgta
+tttctacaacgcagttactgtatccatggcgcgagataattagatacgatttgaatttgg
+atgtagactcgttactactgttgtagaccagcacgtgagtatctagatgggtttgctacc
+ttgttagcggacttttgccgggaaaaagacatacgtacaaccgtatattttactataagc
+agtattggccaccctcgtattgcggcagggtgtgctcacctggttaaaatgaaagagaaa
+aattccattttaaaacccggaggaatctattactgacgaggaaggtgtttaacccgttga
+gacatctcctaacgtaaaaggttcatattctagttattccgagagtcactttcctatcca
+aacatgaactgatagcataatgacaggttgaatggaaagcatatcctgtttattctaaat
+ctgtttcgctaatcaatatgctgtcacgaactcggagcttacccttacaactatgtgttc
+tgtttaccaggtgctaatatcccggcactcttttcatgcatgtcgctcctagcgtcatct
+gatttaatagcttaatgtctcatattttacagtagccagtgtagtatggaaggcggcgaa
+ccagcccctacattgggtttcctgacataagtattacatatcacttgtctgattacacag
+caaaatcgctaaccttactttgcgcatgtagctattggaactttgggctagtgtctatcc
+cattaagtttaacagtagactagtccgtgagcgatcaccgagcttatgtctcgtacccaa
+gttttggatttggatcaaaaactactcgatattcatgatctacgggcttcctttctccgg
+gtatcattgcgccgagattaaaaataaaacgatagcgctgtgaaaacatgtttgacacgg
+gatagcgtagaaactaaacaacgaatagaccatccaatttgaattttattgggtccagca
+cttcgccatagtgttgaatggtaaagttcgaaaggaaatttgttatattaattctgctac
+attttcgaccacttgtatctcaaggacaatatcccttgaggcttttagcagaaagagatg
+ccgtaattctaagggatgataataggttgggaaatttaagagcagtagtaacggtcgcgg
+gttcgaccttaaactatatatttaaatctagccaaacaagttaacaacaaccataaagtt
+atgaccttattatattggcaagcttaacgttttaattgctctagtaatagagtggtagag
+gtaagggaccatcacctgattcttcctccgcaaccattatatagacgtgtcgtctgacaa
+atttcgagataaaacattcgtccttagcaacgaatatcgaatggcaattagccacattga
+gttaaatagttgaggatatttcttgcacagaatcagatctaatctaatgattcgttacta
+aacacttcaccaggtatcgtgaaggctcaagattacccagagaacctttgcaatataaga
+atatgtatgcagcattaccctaagtaattatattctttttctgactcaaagtgacaagcc
+ctagtgtatattaaatcggtatatttgggaaattcctcaaactatcctaatcaggtagcc
+atgaaagtgatcaaaaaagttcgtacttataccatacatgaattctggccaagtaaaaaa
+tagattgcgcaaaattcgtaccttaagtctctcgccaagatattaggatcctattactca
+tatcgtgtttttctttattgccgccatccccggagtatctcacccatccttctcttaaag
+gcctaatattacctatgcaaataaacatatattgttgaaaattgagaacctgatcgtgat
+tcttatgtgtaccatatgtatagtaatcacgcgactatatagtgctttagtatcgcccgt
+gggtgagtgaatattctgggctagcgtgagatagtttcttgtcctaatatttttcagatc
+gaatagcttctatttttgtgtttattgacatatgtcgaaactccttactcagtgaaagtc
+atgaccagatccacgaacaatcttcggaatcagtctcgttttacggcggaatcttgagtc
+taacttatatcccgtcgcttactttctaacaccccttatgtatttttaaaattacgttta
+ttcgaacgtacttggcggaagcgttattttttgaagtaagttacattgggcagactcttg
+acattttcgatacgactttctttcatccatcacaggactcgttcgtattgatatcagaag
+ctcgtgatgattagttgtcttctttaccaatactttgaggcctattctgcgaaatttttg
+ttgccctgcgaacttcacataccaaggaacacctcgcaacatgccttcatatccatcgtt
+cattgtaattcttacacaatgaatcctaagtaattacatccctgcgtaaaagatggtagg
+ggcactgaggatatattaccaagcatttagttatgagtaatcagcaatgtttcttgtatt
+aagttctctaaaatagttacatcgtaatgttatctcgggttccgcgaataaacgagatag
+attcattatatatggccctaagcaaaaacctcctcgtattctgttggtaattagaatcac
+acaatacgggttgagatattaattatttgtagtacgaagagatataaaaagatgaacaat
+tactcaagtcaagatgtatacgggatttataataaaaatcgggtagagatctgctttgca
+attcagacgtgccactaaatcgtaatatgtcgcgttacatcagaaagggtaactattatt
+aattaataaagggcttaatcactacatattagatcttatccgatagtcttatctattcgt
+tgtatttttaagcggttctaattcagtcattatatcagtgctccgagttctttattattg
+ttttaaggatgacaaaatgcctcttgttataacgctgggagaagcagactaagagtcgga
+gcagttggtagaatgaggctgcaaaagacggtctcgacgaatggacagactttactaaac
+caatgaaagacagaagtagagcaaagtctgaagtggtatcagcttaattatgacaaccct
+taatacttccctttcgccgaatactggcgtggaaaggttttaaaagtcgaagtagttaga
+ggcatctctcgctcataaataggtagactactcgcaatccaatgtgactatgtaatactg
+ggaacatcagtccgcgatgcagcgtgtttatcaaccgtccccactcgcctggggagacat
+gagaccacccccgtggggattattagtccgcagtaatcgactcttgacaatccttttcga
+ttatgtcatagcaatttacgacagttcagcgaagtgactactcggcgaaatggtattact
+aaagcattcgaacccacatgaatgtgattcttggcaatttctaatccactaaagcttttc
+cgttgaatctggttgtagatatttatataagttcactaattaagatcacggtagtatatt
+gatagtgatgtctttgcaagaggttggccgaggaatttacggattctctattgatacaat
+ttgtctggcttataactcttaaggctgaaccaggcgtttttagacgacttgatcagctgt
+tagaatggtttggactccctctttcatgtcagtaacatttcagccgttattgttacgata
+tgcttgaacaatattgatctaccacacacccatagtatattttataggtcatgctgttac
+ctacgagcatggtattccacttcccattcaatgagtattcaacatcactagcctcagaga
+tgatgacccacctctaataacgtcacgttgcggccatgtgaaacctgaacttgagtagac
+gatatcaagcgctttaaattgcatataacatttgagggtaaagctaagcggatgctttat
+ataatcaatactcaataataagatttgattgcattttagagttatgacacgacatagttc
+actaacgagttactattcccagatctagactgaagtactgatcgagacgatccttacgtc
+gatgatcgttagttatcgacttaggtcgggtctctagcggtattggtacttaaccggaca
+ctatactaataacccatgatcaaagcataacagaatacagacgataatttcgccaacata
+tatgtacagaccccaagcatgagaagctcattgaaagctatcattgaagtcccgctcaca
+atgtgtcttttccagacggtttaactggttcccgggagtcctggagtttcgacttacata
+aatggaaacaatgtattttgctaatttatctatagcgtcatttggaccaatacagaatat
+tatgttgcctagtaatccactataacccgcaagtgctgatagaaaatttttagacgattt
+ataaatgccccaagtatccctcccgtgaatcctccgttatactaattagtattcgttcat
+acgtataccgcgcatatatgaacatttggcgataaggcgcgtgaattgttacgtgacaga
+gatagcagtttcttgtgatatggttaacagacgtacatgaagggaaactttatatctata
+gtgatgcttccgtagaaataccgccactggtctgccaatgatgaagtatgtagctttagg
+tttgtactatgaggctttcgtttgtttgcagagtataacagttgcgagtgaaaaaccgac
+gaatttatactaatacgctttcactattggctacaaaatagggaagagtttcaatcatga
+gagggagtatatggatgctttgtagctaaaggtagaacgtatgtatatgctgccgttcat
+tcttgaaagatacataagcgataagttacgacaattataagcaacatccctaccttcgta
+acgatttcactgttactgcgcttgaaatacactatggggctattggcggagagaagcaga
+tcgcgccgagcatatacgagacctataatgttgatgatagagaaggcgtctgaattgata
+catcgaagtacactttctttcgtagtatctctcgtcctctttctatctccggacacaaga
+attaagttatatatatagagtcttaccaatcatgttgaatcctgattctcagagttcttt
+ggcgggccttgtgatgactgagaaacaatgcaatattgctccaaatttcctaagcaaatt
+ctcggttatgttatgttatcagcaaagcgttacgttatgttatttaaatctggaatgacg
+gagcgaagttcttatgtcggtgtgggaataattcttttgaagacagcactccttaaataa
+tatcgctccgtgtttgtatttatcgaatgggtctgtaaccttgcacaagcaaatcggtgg
+tgtatatatcggataacaattaatacgatgttcatagtgacagtatactgatcgagtcct
+ctaaagtcaattacctcacttaacaatctcattgatgttgtgtcattcccggtatcgccc
+gtagtatgtgctctgattgaccgagtgtgaaccaaggaacatctactaatgcctttgtta
+ggtaagatctctctgaattccttcgtgccaacttaaaacattatcaaaatttcttctact
+tggattaactacttttacgagcatggcaaattcccctgtggaagacggttcattattatc
+ggaaaccttatagaaattgcgtgttgactgaaattagatttttattgtaagagttgcatc
+tttgcgattcctctggtctagcttccaatgaacagtcctcccttctattcgacatcgggt
+ccttcgtacatgtctttgcgatgtaataattaggttcggagtgtggccttaatgggtgca
+actaggaatacaacgcaaatttgctgacatgatagcaaatcggtatgccggcaccaaaac
+gtgctccttgcttagcttgtgaatgagactcagtagttaaataaatccatatctgcaatc
+gattccacaggtattgtccactatctttgaactactctaagagatacaagcttagctgag
+accgaggtgtatatgactacgctgatatctgtaaggtaccaatgcaggcaaagtatgcga
+gaagctaataccggctgtttccagctttataagattaaaatttggctgtcctggcggcct
+cagaattgttctatcgtaatcagttggttcattaattagctaagtacgaggtacaactta
+tctgtcccagaacagctccacaagtttttttacagccgaaacccctgtgtgaatcttaat
+atccaagcgcgttatctgattagagtttacaactcagtattttatcagtacgttttgttt
+ccaacattacccggtatgacaaaatgacgccacgtgtcgaataatggtctgaccaatgta
+ggaagtgaaaagataaatattgcctacacatactgaattcaggcaatgcgttttattcga
+aaggtcatataactagaaaacatgatgaattcttatcggatccttttactagcatagtgt
+tggcgaacacctcgtaatgctcagcggcaaattggactgcgggtccttatcatacatttt
+ttttcaatataggcgattggtctaggttagtgattccccaacacttaaggtttgctgaca
+ttcataccctcagcaacttcctctcaaaaattagagtgagttggtggtcttataagaccg
+ttgattatttgaggtggtcaaatgatggtgcgatgcacaaatcgttataatcgtactctg
+tagacaataacccattgtagtgccgattttgtgcataatacaagaaggaggatataaaaa
+tgacttttcaataatattggctattagcaacaagaaggagaatcctcattaagttagcaa
+ccgcagggggtactgcagtccaaggaggtttcattggagagagcagtatgaaaacggcaa
+ttatgattgtgagattcgctgaagattgtgtctctgattttcctagatagaataagctat
+agctacttaatcaactcttaactgtggagactatcctgatgatctgaataccccatttac
+aaaattccatatcaatgaggctaacgcttaaatttcatttctccatcgtaacaaaaatca
+gcctttttatacaagacaaaacactgcttccattacgggtagcaatggttgctcgactac
+tggtagcgtcgtgatgtggtgataaagctgtcttgcgtttatacttaaacaaattttgac
+ctgacataatggagcgacttatcggatgttgccgatctttagggtcatctattaagctta
+tacgaaaaagggacaagcacgttacgtaatctggtaggactgggtacctagaaacgcaag
+aggaggcgaactccaatatctgtaagaacagaaaaatacaggagtccttttcatttttca
+agttaacaatataagtaggagcttagagaggcttgcatgaaaatcgttaggaattacaga
+ataggcagagagtggggcgtgtagactacattcttcaggccccacaatatgggttatagg
+ttaaactgcactttttgcgatctcccgaaatactgtcgttctctgcgaaccacgctcgtt
+ccttttgctgtagtccacgttcatccaactattcagataaacaagatcgcagaattaaag
+cttaaccatatcttgatagcccatcgtgtatggggcatgtatgtgcaaacaaaagacctc
+aatcttgtctgcgagagggaggaaaatttagacaaacataattcattctttcgactggac
+acgctaaggtttggacaaactttgtatctatatctggaggcctgtattccagcccttctt
+ttaataagatttacggcttaaactatggatatttgccaggaaatgacactgctattgaca
+ggaacataattttgattcaaacctcattgttaattattttatatctcctgtttttatatc
+agaatgcttctgtcctagaaggcatactcaaggtgagggctcgaggaatgaatcataata
+gaccggcccctattaatattggttcaattctttcttacataacgcggaatttgattgcac
+gaacaccgggaacacataaccgtatagcgcccgttatgctagtgcctagcgactgggacc
+gtggagtctatatcgtctttctaccattattaatctaaggatataccactttaagtcctt
+tcaactaacataaggcgcattccatgcgctaaggaccttgaatttattatttcttacatg
+ataaaagatcgagtcgacgggaacaaaaggctacgtactcaataaagtgcagtttactaa
+gagccctttttctggcttgtggagactatcataacatgaagatgttttgacattcaatag
+tttgcaaaacaaacttactttgtgtagtattgaacgagatctttccaattgccccatagc
+aggaatagttatatattgcagatcgcggtgtaacgcactccaaatccatcgcggtgtgtg
+agggtaagcgacttaaagaattacggtttttgatcaaagcacagtgagagttgagcaaat
+tacagttatacgacttaattcagtctccataaattgaaacgacacttcttaacgggagga
+ccagacacgttcattaagtgaggagtgcactttttgactttaaaaacatggtaatcaatt
+taaaccacttgatatgtatatgaacagatttgaagttatttctgttttaatacactggga
+gttctgtcaatatcgcaggaaccgcctgacgtcccctatcacacctcagagggtaaaggg
+acaggggaaagggtaatcgaggggtagggaacgtagttggcacacccaatggacgaataa
+atgctgccatatccacggagggcgggattgcggttgattttaaggcgatggtaacctgaa
+tgtaatagatcatcaaatgcctcctccactggaaattactgcgtacatccgctgagaatt
+gcaatggagtgtctcggtttttctttaaacaaaaccaaattgacaacttcatagtataat
+ttttgcacattacaagcgttaattaacaaacttactttgctgttagctgcctatatttgt
+ccgacaatataactggatatctctgcgagaactgtaaattaacggcacttggaacataat
+agttcctattggtaacgacgttgtaggcggcaattatccggtggaagaattgacaactgc
+agttgaactgcatgaaagtcaaatctctcgtaagtataactttagaagactccaaggtac
+ccagaacctcttcagcggacacgatcgctatcaatcaataaggattattcactgaaaccg
+ctcatatctggaggtggacgtttttcttcgaaaagcttgtcaaaggactcatcaaatttt
+tggccgtgctaatcgacacacctgttattttcatgaccggataggacatctcgcggaaat
+tcgggtaacagctgggtagatataggacctcccctacgtattaatgataagcctgtcata
+actagcttggtttaccgaagagacaataaacattcgagcgctcgtgccaaactcggtgca
+ttacgtttgaataaatcggtaacatgtactattactctgcctaacggcacttacccgttt
+gggtccatggggtaaccgctcgatgttgacagaattatgctaaagtcgtttaagatcccg
+attaccgaaaatctggttatgtctgagcattcgtacactgcgtattaagatcaggttgaa
+caggttcctaacaaattttgtgacctaaagtgaaactaggtcgtactctgggcatgtttt
+atgtcgtggcgtatgcatgtgctgacacttctaaaaccaaattaaggctttatccaatat
+gggtccttaagtgctaaacatcattcacaatttcaagacagattgttggtcttgtcgatt
+ccgcatctgtcgccaaattgacacatcgtaaaccaggtacatcggtaattatatgttgac
+taaactaccgtgtgtattctggctctaggtacggcgaacaagtacgatgtgcttaagaag
+ccctcaccccagacgagcccgcgtaggtcacatcagcagatcctaagtaattccgtttta
+ttgtcctgagggagtaggatcgacgaactctacaagtcgctttgtcgtgccttataggct
+atttcgggtcaatgtagcgtcaaatgaactattgtcatctgtacgagttaactaagtgtc
+tatcgccaactaaaagacgtctcgatggttctttatgcggacctgtcatatcattgactg
+gcacttgcttacatccaaataacacgtttgttagcggatagtcgttaagtgtgcgcaaga
+tcatgaggcggggggggtaatatttcgccctctacatgataaatgaataagtaagaagat
+gatctttttgtggcggtaccttaagcgtactcctgtcgacgagttactactaaaggaatg
+tagggttctggatctatgaaaagcgacctccatatatatacgggcctaagcggagtaaaa
+taagtgatcaatggactaacattgaaatgttagtattgtcgaccattgagggctggtaaa
+tcttatttacgggcgtgggaaaacgaacgtgatatggtttagcatgggatgcaagcactc
+gttaatgcttactttagttggttgcgggaacaacaggaggctatactaactggtagcgtt
+cttgcttccattatgttattattataattaaaaataagacatatggtagagttgtagtca
+gggtggatcgggttgtctataacgttggaataatcaaaactatcgttaacaaaaacgaaa
+tttaagtcggtgcggtggaatgcgcctacctcatgtgcaccacacattcacagcacaccc
+ctcattataggcaaggaagcaaacaaaaaaaagttaatcgaccgtatccgaccttaaatt
+ttaaaataaatagaaacacttagcggtaatgaaaagataggactaaaattcactagtatc
+ctggaacgaggcaacagagttatctagatggtaacgaggtgctgcatcaagatgtatgat
+ttttggtccgctgtgtggaatacctctattgatatacaagtgactttctcggtaataacg
+cacttcacaatgtgttgtttcttttctatgtattttgcaagagaaagaagcttagtatag
+gtacacctcagagatgtttcgtgtaaatcgtatcacatggtataactgcaggaggaacat
+tatccaaattcaccacaattactaatccacccttttacttttactaaagatatattaatt
+ctcatgttgtctgaattgtataacccggtaccctgggagcgtatcgaaggataccaattg
+aagtcctcgaggcatgttacaacacacgacttccttccgtctattcagacactcaacgag
+actaacttttcctaggtaatcaatgatattgggtaactcgtggcatcttatagttattga
+tccggctcttttgtagatcctgtgcgactcgtgcgctaattaagactggctctcttgcgc
+aggggatacgtttattctacgtacccgatttggttactactaagcggcctttcttcaaac
+ttgcagttgtgacttacattcctatttcttcaaagcagggaagggttacagggagagact
+tattgagatacgattggaatttccatgtacaatcgttaatacgcttgtagaccagcaact
+cagtatagagatccgtttcctaaagggtgagcggtaggggcaaggcaataagaaattact
+aaaaccctagttgttaatataagaacgattcgaaacaataggattgcccaagggggtgcg
+aacatggtgtaaatcaaagagaaataggcattgttaaaacccgcacgtttctagtacgca
+agaggaacgtcggtaaccagttctcaaagatcctaacctaaaaggggcttattctacttt
+ttccgacactcaatggacgagacaaacatgaacggatagctttaggtctcgttgaatgca
+aagaatagaatcgttattattaatcggtttccattatctatatgcggtatagatctccga
+gaggaccctgtaaactagctctgcggtttaactggtgctaatagaccgccactatgttat
+tgcttctagctcctagcgtcttatcatgttatacattaatgtcgcatattggacagtagc
+caggcttggatggatcgccgacaaaaagaaaagactttccctgtaaggacttaactatta
+catataacttggatcattaatctgcaaattagagtaacggtctttcaccagcttcatatt
+ccaacgtggcgctagtcgatatcccatgaagtttaaaactagaattggcagtctcacttc
+acagtgcgtatctatacgacaaaagtggtcgatttgcataaatatcttatcgatattcag
+gttattaccgattccttgctaacgctagaagtcacaccagagtaataataattccagaca
+cctgtgaaataatcggtcactacggatagactagtaacgataatacgtatagtccataaa
+agttgaattttaggggctaaagatattagcaatactggtctagcctaatcgtcgatagca
+aagggctgtgaggatttctcctacattttcgaccaattgtatcgataggaatagttacag
+tcacgcttgtagatgtaagagatgacgttattcttagggttcttaagtcggggggtaatt
+taagaccactagtaaaggtagaggcgtacacagtaaacgatattttgaaatcgtcaaaaa
+aaagtttacaacatcctttaagttagcaactgattttagtggcaaccttaacggttgaat
+tgatctactaatacaggcctacaccgaagggtacagataatgattcttactaccctaaca
+tgatagagtcctgtcctatctcataggtcgacattttaaattcgtaatgagcaacgaaga
+tcgtttcccaatttgcaacattcacttatagacttcaggttatttcgtgctaacattaag
+atagaatataatcagtcgttaagaaactattatccagctttcgtcaaccataaagattaa
+aaactgaaacttggcaagatatgaatagctatcctgctttaaccgatcgtatgagatgct
+ttgtagcaagaaaagtgactagcacttgtgtttagtaaagcgggagagtgcggtaattaa
+tattaatatactattaagctacacagcaaaggctgcaataatgttagtaagtagaacata
+aaggtattctccacaagtaataaatagtgtgagctaattgactaacttaactctcgcgac
+aagtgatgtggataagatgactcatatcgtctttttctgtagtgccgacatcccacctgg
+atcgaacaattccttctagttatcgactttgattacctatcctattaaacagatagggtt
+gtaaagtcagaaaatgatcggcttgcgttggtctaccatagctagagttagaacgcgtag
+atagaggccttttgttgccaacgtgggggtgggatgagtctgggcgagcgtgactttctt
+tcgtgtccgaatttgtttaacatccattagattagatgtttgtgttttgggtctgatgtc
+ctaactactttctcagtgaaactaatgtcatcatccaagtaaaatagtccgatgaagtct
+ccgttttcggccgaagcttgtctataacgtatataaagtcgctgaatttagaacacacct
+tatctatgttgtaaagttactttattccaaaggacgtgcacgaagcgtgagtgtgggaag
+gaacttaaagtcggatcactcttgtcagtgtagataagaatttctttcatacttcactgg
+aatccggcgtatggatatctctaccgcgtcatctggtggtgtctgcggtaaaaagtcttg
+ctgcacgagtctgagaaatttttggtgccatcacatcgtaactgtacaacgaacaaatag
+catcaggccttcttatccagcgtgaagtctaattatttcacaagctttcctaagtatgta
+aatccctcacttaatgatgcttgcgccaatgaggatagaggacattgcatgtacgtagga
+ctattctccaaggggtcttctattttgttagcgaaaattgttacagcctaatgttagagc
+ggcgtacgactttataccagatactttcattagatatgcaaatatccaattaaatcatag
+tagtatcgtggtatggacaatcaaaaaagacccgttgtgatatgatgtttttctagttcg
+ttctcatatatatagatcaacaatgaataatctcatgatctataaccgatgtatatttat
+attccggttgactgctccggtgcaattcactacggacactaatgactaatatggcgcctt
+tcatcagaaacgctaaatatgattaatgaattaagggagtattatctaattattagagag
+tagcagttagtctgatattttcggtgtatgtgttagccgttataatgctgtctttttatc
+agtgagaacagggagtgtgtagtgttgtatgcttcactttatgactctggttatatccct
+cggagaacaagaataagagtacgagaagttcggtcattgaggatgaaatagaaccgctag
+acgaatggactcacgtttataaaactatgtatcacagtactacagctaactctgaagtcc
+gagaagcttttgtaggacaaaacgttataagtacctttcgcagaatacggccgtgcatac
+ctgttataaggcgtagtagggacaccatgctatccctcatatagagctacactaatacca
+ttacatggtgactatcgtttacggccatcatctgtaagcgatcatgcctcgttagcatcc
+gtacaatctcgcatggcgtcactgcagaaaaaccccgtgcggattttgagtcagaactat
+tcgaagcttctcaatccttttccattatggcatagcaagtgacgactcgtcagccatggg
+aataatagcactaatccgattacttatgaattagaacccacatgaatgtgattctgcgaa
+ttgtctaagaatctaatgattttccggtgaatatggttgttgttatttattgaacttata
+ttattaacatcacccttcgttagtgatagtcagctatttccaagaggttccccgagcatt
+tttaccattctctagtcatacaagttggagcgcttttaaatctttaggctgatcaaggcg
+ttttgtctagaattctgcagatgttagattcgtgtgcaatccctcttgcatgtcagtaac
+aggtcacccgtttttcgttacatatgctggtaaaatattcatagtaataactacaatact
+tgatttgttacgtaatgctcgtacataacacaatcgtattccacggaacagtaaagctct
+attattctgatcgagcctaagagaggatcacactacgctattaaagtcacgttcacgaaa
+tctcaaacctcaactgctggtgaccagttatagacagtgtaattccatattacatgtcag
+gcttaagctaacccgagcctttatataagctataatcaagaattagattggagtgcattt
+tagacttatctatcgaaatagtgatagtaagagtttatatgacctgatctagactgatgt
+tctcttccacaacagccttaaggcgtggagcctttcttatactattaggtcgcgtcgaga
+gccctattcgtaatgttaacgacactagactaatatacaatgagctaagaataacacaag
+tcacaagataatttacaaatcatatatctacagtccacaaccatcactagcgattgcaaa
+gcgttattggtactaccgctctaaatcggtatgtgcaagacgcgttaactggttcaagcc
+tctcctgctcgtgagactgaaagaaatcgaaaatatggatgtgcctaattgttcttgtga
+gtcatgtgcaactatacagtttagtttggtcaagactatgcaactattaacagcatgtgc
+gcattgaatatttggtgtcgattgataaatgccccaacgttccatcacgtctataagccg
+tgttactaatgtgtattagtgcatacctattcagaccatagttcaactgttggactgaag
+gcccgtcttggggttcgtgaatgagagtgcagtttcttgtcttttccttaactgacctaa
+atgaaggcaatcggtttatctagagtcatgcttaaggtgaatttcagccaatgggctccc
+attgagctagtatggtgctttacctttgtaagtggtggctttccttggtgtgctgacttt
+aacacggcagagtgattatccgaagaatggataataagacgctggcaatattggctaata
+aagtccgatgagtttcaatcatgactgcgaggagatccatgcggtgtacctaaacctaca
+tcgtatgtatttgctgacgttcattcttgatacataaagatccgatatcggtccactttg
+tttaccaaaagccctaccttcgtaacgatggaaatgtgaatgagagtgaaatacacgatg
+gggatattgccggtgagtacaagttagaccacacattagaactgacctatattcgtcatc
+atagagatggagtatgaattgattctgcgaagtacactggctttacgagtatctagacgc
+cgcggtatatctcccgtcaatactatgaaggtatatatatagaggctgaaaattcatgtt
+caatcctctttctaagagtgagtgggagccccttctgttgtcggagtaaaaaggcattat
+tcctcaaattgtcagaagcaaagtatacgtgatgtttgcttagaacaaaagagttacctt
+agggtaggtaaatctcgattcaccgagagaagtgattttggcggtgtgcgattaattctt
+ttgatgacagatctcattattttatatagctccctctttgtatttagagtttgcgtaggt
+aacctggcaaaaccatatcccggggggagagtgcgctgaacattttatacgatgtgatta
+ctcaaaggataaggttcgaggcctctatactcatggaactatcttataattataatggat
+cgtggctcattccacctatccaaacttctttgtgatctgatgctacgagtgtgaacaaac
+gtacatcttctaaggaatttgggacgtttcatagctcgcatttcattcctgaaaacttaa
+atatttttaaaaattgattctactgcgaggaactaaggtgtagacaagcccttagtaacc
+ggtggatgtcgcttcagttttatagcaaacattattcaatttcagtcttgactgaaatta
+gtttgttagtgttagaggtccatatgtcacatgcatatggtctagatgccattgtacagt
+aataccttagattagtattagcggcatgcgtacttggatttcacttgtaagaatgagctt
+aggacggtcgcctgtagggctgcaaataggaatacttacaatttttgatgacttgttagc
+atatcgctatcacccataaaaaacctgatacttgatgagcgggtgattgagactatgtac
+tgatataattcaatagctccaatagatgaaacagctatgcgcctatttatgtcaaataat
+cgatgtgatacaagcttagagctgaacgagcgcgagtggaattagcggtgatctctatcc
+taaaaagccacgaaatcgatcccagaagctaatacccgaggtgtcaagcttgagttcagt
+taaatttgcatctcatgccccacgaagaatgggtagagagtttgaaggtgcttctggatt
+ttcctaagtacgtggtaaaaatttgatgtaaatgaacacctcctaatggttgtgttaacc
+acaaacccctgggtgaatctgattagccaacccagtgatctgatttcagttgtcaaatct
+cttttttataactaccttttgtttccataatttaaccggatctcataatgaacaaacggg
+tagaataatggtagcacatagcgagcttgtctattcagaaatatggcctactcagaatgt
+attctccaaatcagtgttatgcgaaacgtaattttacgtgtaataatgatgatttcttat
+cggttccttgtactacaatactcttgcccaacaaatactaagcataacagcaaaattcga
+atccccctccttttaataaatggtttttcaatatagccgattcgtattcgttagtctttc
+accaactattaacctggcatctaattaataaaatcaccaaaggactctataatatgacag
+tcacttcggcctcttttaagacagttgattattgcaggtccgcaattgatggtgacatgc
+acaattagttagaatccgactatggagacaattaacaattgtagtgcccatttggtccag
+ttgacttcaaccacgagttataaaggtattttaatttatagtcgatagtaccaacaacaa
+gcacaatcataattatgttagaaaacccagggggtaatgctctaaatccagctttaaggc
+cagagtgcactatgaaatcgccattgatcattgtgtcattcgctgaacttggtgtctagg
+aggtgccgagtgagaatatcagataccttatgaagcaacgattatatctggactagatca
+tgatgatcggaataaaacattgaaataagtccttatcaaggagcataaacattttattta
+atttatacttcgtaaataaattcagaattttttttcaagacattaatctgagtaaatgac
+ggctagaaagggttcctactcgaatcgtagcctacgcatgtgggcagtaacctggcttgc
+gtttttactgaaacaaaggttcaccggaaagaaggctgccacttttagcttcttgacgat
+ctttagcgtcatatttttagattagtcgaaaaacggaaaacaaacttaacgaagctggtt
+gcacggggtaccgagaaaccaaagagcaggacaactccttgatcgggaagaactgaaata
+gacagctgtcattttcattggtcaacttatcaatataacgaccaccgtagtgacgcttgc
+atgaaaatactgaggatgtaaactatagccagtcaggcccgcgtgttgactaattgatga
+agcaaacaaaatagccggtattcgttaaaaggaacgggttgccagctacagatatactct
+aggtatatcccaaacaagagacgtcctttggctgttgtaatcggtcataatacttgtcac
+ataaacaagatcgctgaattaaacattaaacagttagtgatacacaatcgtggttggggc
+tgggatgtgcaataaaaagtcatctatcgtctatcacagagcgacgtaaatttagacaaa
+cattattatttcttgacaatggaatcgataagcgttcctctaacttggtatatatatctc
+gaccccgggattccagccattcttgtatgaagatttaaccatttaactatgcatagttga
+atggtaaggaaaatgatattgactgcaacagattttggatgcaaaaatatttgtgaatta
+ttggttatatactggttgtatagcacaatcattaggtcctagaaggcatactcaacctca
+gcgagagagctagcatgcataattgtaccgcccatattaatattcctgaaatgatttctt
+acattacgcccaatttcagtcatcgaacacccccatcaatttacccgatagagaacgtga
+tcatacgcaataccctatgcgaacgtccactctatagcgtctgtatacaatgattattcg
+ttccatttacaacgttaagtaatttaaacttacataaggacaaggaaatccgcgaacctc
+ctggaatgtatgagttatttatgcagttaacttcgtctcgaccggaactaaaggcgtcgt
+acgaatgaaaggccacttttagaagagacctttgtatccattgtggagaatatcataaat
+tcaagatggggtgtcatgctattcggtcctaaacattcttaatggctgttctattgttag
+tctgatttaaaatggaaccatagcacgaatagttagatagggctcatacccctgtaacga
+tctacaaatccttccccgggtgtgtgcgttagcgacggaaagttttacggtttgtgatca
+aagaacactcacacgtcagattattacactgatacgaattatttcagtcgacagtaattg
+aatagaaacttattaacgccagcacctgacacggtaagtaaggcaggtctgaactgtttg
+actgtaaaaaaatggtaatatttttaaaaatcttgatttctatatcaaatgatgtgtagt
+tttttctctgttattaaaatcccagtgcgcgaaatttagatcgttacgactcacgtacaa
+gatcacacatcacacgcgttagcgaaagcggaatggctaatacagccctacgcaacgtag
+tgggatcaacatatggacgaatttatgctcaatgagccaacctcccccgcattgcggttc
+attttaaggcctgggtaacatctatcgtttagataatcaaaggaatccgactatgcaatt
+gtctgacttcatccgctctcaagtccaatgcaggcgctacgtgtttctttaatcaatacc
+atattgaaatcgtaatacgataattgttgctattgactacaggttatgaaaaaacttact
+ttgcgggtacatgcatatttttgtaccacattattacgcgatatctctcagtgtactcta
+aattaaaccctcttcgaacattttagttcctattcgtaaacacgtgctacgcggcaattt
+gccggtcgtagaatggacaactccagttcaactgcatgtaactcatagctcgcgttagta
+taaattgactagtagccatgggacaaagtaactagtcagcggaaaagatccctttaaaga
+tatatgcaggttgcaagcataaagctcattgctcgaggtgcaccgtggtattccaaaagc
+gtctctatcgtatcttctaattttgggccgtgagaatcgaaactactctgatttgctgca
+cacgttaggtaatatcgcccattttcccgtataagctccgtacttatacgaactacacga
+ccttttaagcattagccgctcatatcgtgattcgtgtacagatgagtctattaaaattac
+agacatactccatatctcgctccttgaactttgaataatgcgctaacttgtactatgaat
+aggcagaacccaactttcccgtttgcgtcaagcggggaaacgatacatgttgtcagattt
+atgattatctagttttagatcacgtttaccgataatcggctgtggtctgagcagtcctac
+actgagtatttacttcagcttcatatcggtccgaaaaaaggttgtgaccgaatgtcaaaa
+tacggagtacgatgggcatcttttttcgagtcgcggttgcagggcagcaaaaggcttaaa
+ccatttttacgatttttactatagcggtcatgaagtgcgaaactgcttgcaaattttcta
+cacacattgtggctcttgtccttgaagcttatggcgaaaatttgaaacatagtataccag
+ggaaagcgcgaattatttggtgactaatagtccgtgggtttgagccatatacctaacgcc
+ataaactacgtggtgctttagatgcaatctaaacagaacagaaagcgtagcgctcatcag
+cacagactaactttttcagtttgagtcgccggagggacttcgagacaagaacgcgtcaag
+tcgcttgcgcggcacggattcgattgggcggctcaatcttgcctaatttctactattgtc
+agctgtacgactgtactaagtgtatagccccaaataaaagaagtatcgatgcgtctttat
+gaccaaaggtcttataattgaagcgcacttccgttcatcaaattaaatcctggcttaccc
+gattctccggaagtctgacctagagattgacgacggccgcgtattattgagacctcttca
+ggattaatcaataacgaagtagttgatctgtttggcgacgtaccttaagccgactccgct
+acacgagtttctactaaaccaatgtagccttatgcttagatgaataccgtcctaattaga
+tattccggcataacagcagtaaattatctgttcaatggacgaacattgaattgttagtat
+tctacacaagtcaggcctcgtaaatattaggtaaggccgtgggataacctacgtgatatg
+cttgagcttgcgttgcaagctctcgttaatcattaatttaggtgcgtgagggttaaacac
+cagcatattctatatgctagacgtcttccttaaaggatcgtagtattataattaataata
+agaaatatggttgacgtctagtcagcgggcatacgctgctctatatactggcattattca
+aaacttgacggtaaaaaaacgaattttaaggcgctcacgtcgaatgagccgaactcatgg
+gaaccaaaatgtcacagaaaacacctctttattgccaagcatgcaataaaaaaaatgtta
+atagtacgtttacgacattttattttataataaagagaaactattacacctattgatatg
+ataggacgtaaattaacgagtagcctgcatagaggcaaatgaggtttctacatggtatag
+acctgatgctgaaacatcgatgagttttggtcccctcgctcgttgaaatctagtcattta
+ctactgtctttcgagctattataccacttcactatgtggtgtttctttgctatgtatggg
+gctagtcaaacatgatgactatagctacaactcagagagcgggcgtgttaagagtatctc
+atgctagaactgcacgacgaacttgatacaaagtaacaacatttacgattccacaaggtg
+actttgaagaaacatagtttaattctctgcttcgatcatttctataaaccggtaccatcg
+cagcggatagatgcataacatttctactactccaggcatcttaaaacacacgtagtactt
+cactagattaagacacgataagtgtataacttggcagtgggaagcaaggagattggcgaa
+ctcctggcatctgttacgttttgttcaggctcggttgttgataatgtccgactcctgcca
+tattgaagactcgctcgagggagatcgggattcgttgattataagtacacgtgttccgta
+atactatgaggcagtgattcaaaatggcacttctgacttacatgactaggtattattacc
+acggaagcgttaaaggcacactcttatggacttaagattgcaagtgccttcttctagcct
+gaattcgcgggttcaacacaaactctctttagacatccgttgcctaaaggctgagacgta
+ggggcaaccctttaactatgtactaaaaaactagttggtaatttaacaacgtgtccaatc
+aagacgatgcaccaacgcggtgcgaaaatcgggttaagcaaacacaaataggaattgtga
+taaaccccaccttgagaggtcgcaagaccaacctcgggaacaacggctctaagagaataa
+cctaaatccggatgagtagactgtgtaactctctaaagggaagtgaaaaaaagctaagca
+tacatttaggtctcctgcattgcattcaattgaatcgtttgtattatgagctgtacagta
+gctatatcagctatagttatcccagaggaacaggtaaactagctctgagcgtgaaatccg
+gatattagaacccctagatgggattgattctagctaatacaggcttatctggttttacag
+ttatctagatgattggtaaggtgaaacgcttggtgccttccaccacttaaacaaaagtat
+tgcccgggaagctattttctaggtattataaagtcgagcattaatatcaatttgacagta
+aaggtctttcaccagcttcatatgccatagggcccatactcgatttaaattgaacggttt
+aacgagtattggaactctcacttataactgagtagctatacgaaaaatctggtccatttc
+cagaaatttattatcgatttgctgcttagtacccaggaagtgataacccttgaaggcaca
+acactgtaataagttttcctgtcacatctgtaatattcggtcactacgcattcacgacta
+aagataattactatactaattaaaagttcaatgttagggccgaatcatagtagaaattct
+cgtctagcctaatcggacttacctatgggctgtgaggatttatcagtatgtggacaaaaa
+tgctagagataggtatagttaaagtcaccatggtacatctatgtgaggaagtttgtagtt
+cgcttctttagtccgggcgtttgggatgacaactactatacgtagagccgtactcaggat
+tagatagtgtgaaagagtcaaataaaagggttaatattaatttaacgttgcaaatgtgtt
+taggccaaacattaaccgttgtagggatattctaatacaggccttcaccgaaccctaatg
+ataatctgtcttaataacattaaatgattgtctccgctacgagctcttagggcctcattt
+taaatgactaatgtccaaagaagagactttcccaatttcaatctgtcacgtatagacggc
+accttagtgagtcatatcattaagatagaagattatcaggagggaagtttctattatcaa
+ccgttacgcaaccataaacttttaaatctcataatggcattgagatcaagagctttcatg
+atggtaaagttcgtatgtgatgctggggagctagatatcggtataccacttcggttgtgg
+taagcccgagtgggccgttagtaatattaatagacgattatccgacaatgcattcgctga
+aataatcttacttaggagaaattaatgctatgagccaaaactatttatgtctgtcacatt
+attgactaaagtatctatcgacaaaactgatgtccataagttgtagcagatagtcggtgt
+atggtgtcaccaatgaaaacctcgagcgaaaaatgaattatagttatccaatttgagtaa
+attgcctattatacagataggcttgtttagtcagataaggttccgcttgaggtgctctaa
+cttagcgagagttagaaagcctagtgagaggcattttggtgccaaactccggctcgcatg
+agtaggccagagagtcactttctttcgtcgaagaagttggtgaacagccttttgattagt
+tgtttgtcttgtggctatgtgctactatataagttagaacgcaaactaatctaatcagca
+aagtaaaataggaccttgaacgagacggggtacgccgttgaggctcgagatagtagataa
+actagaggaatgtagataaaacattagctagggggtttagttactggattacataggaag
+tgcaccatcacggtgtgggggttcgtacgtaaagtcgcatcaatattgtcagtggactta
+acaagttcgtgcataatgaaatcctatacggactttgcatatctctaccgactcatctgg
+tcgtctatgcgggtaattgtattgctccaagtggatgactattttggcgtcccagcacat
+agtaaatgtaaatccttataatagcataagcaattattagactgcgtgaagtcttagtag
+ttctcaagctttacgttgtatgtaaataactcacgtaatcagccgtccccaaatcaccat
+tgaggtcattgaatgtacggagcactattatcaatgcggtatgcgattttctgagcgatt
+attgttaaagacttagcgttgagccccggaacacttgattacagattctttaaggagtta
+tccaaatatcattttaaataatagtagtatcgtgctttggacaataaaaaaagacccgtt
+ctcttatgttgttttgcgacgtacttctctgatatatacttcaactatgaagattctatt
+catcgataacccaggtatatttatatgcccgttcactgcgcagggcaaattatctacgga
+caataatgacgtagttggacccggtaagaactaacgcttaatatgattaaggatgtatgc
+cagtattatcttattatgtcagagtagaagtttctctgagattttccgtcgttgtggtac
+accggatttggctctctttttagaactgagaactcggagtgtgtagtcttgtttccttca
+atttatcaatatgcttttataccgccctcatcaactataacaggacgacaagttccgtct
+tgctccatcatatactaccgatacaccaatcgtatcaagtttagtatacttgctttctct
+cttctacagcttactcgcttgtccgagaagcggttggtgctcataaagttagtagtaaat
+gtacaactagtagccagtccttacctgtttttacgactactacggacaccatgagataca
+gaagttagtgctacaattataccattacatgctcaatatcgttgtcggccataagatcga
+agagtgcatcacgcgtgtgaatacgtaaaatctaccatcccgtcaatgcacaaaaacaca
+ctccccttgttgactaacatcttttacaagaggctaaatcattgtccaggatcgaatacc
+ttgtgtacaatcgtcacccatcggaagaataccacttttccgatgtagtatgatttacaa
+aaaacatctatgtgagtaggccaattgtagtagaatatattcatttgaccgtcattagcc
+ttcttcttaggttgtgtacggatagtaggtacataaaccgtcgtgtggcatacgctgcga
+tttcatacagctgccaacaccttttttaccaggctagagtcagaaaagttggagccatgt
+taaatagttaccatcataaaccactgttgtctactagtctgatcagctttcatgcctgtg
+caagcaatatggattctcacgtaatggtaacaactgttgcgttacttaggctggttaatt
+tgtcagagtaataaatacatgtcttgttgtgtttcctaatcctcggaaagtacacaagcc
+taggaataggaaaagtaaagctcttttattctgatagtgactaactcaggatctaaatac
+gcgattatactaaccttcaccaaagctcaaaaatcatctgctggtgaccagttatagaca
+gggtaattcaatatttaatgtctcccttaacatttcaccagcatggattgaagatagtat
+aaagttttacatggcagtcattgtgtcacggttctatacaaattctgatagttagacggt
+atttgaaatgtgcttctagcatggtatcttacacaactgaatgaacgactggagccgttc
+gtatactatttgcgagcctcgagaccccgtttcctaatgttaacgaatatagtataatat
+aaattgtgatatgaataacacaagtaactacagtttggacaattaattgttctaaactaa
+aaatcattcacttcagatggcatagagttatggctactacacatataaagcggtatgtga
+aacacccgttttagccggaaaccctctactgctcgggacaatgaatgatttccaaaatat
+ggatgtgcagaattgttagtgtgactcaggtccaaatagacactttagtttcgtcaagtc
+gttgcaaagtttaaaaccatcgcagcattctttatttggtctacattgagaaatgaaaaa
+acgtgacagaaagtctagaagaactgtgaataatgtctattactgattaactagtaagac
+attagtgcatctggtccactgaagcacccgcttggcgttaggcaatctctgtgaactgtc
+gtggctgttccggtaatgtacgaaagcaagcctataggttgatcgagtcgcttcattaag
+gtcaatttcacaatatccgatcacattgtgctaggttcgtcctttaccttgcttagtgct
+gcatgtacggggtgtcatgacttgttatcggcagactctttatcccaagaatggataata
+tgtacatggaaagtgtccataattaagtcccttcactgtaaagaatgactgccacgtgat
+ccatgaggtctacagaaaccgacttacttgctttttgatcaacttaattatggattcata
+aagttcagatatcggtacaattggtgtacaatatgaaattaatgaggaaacatggaaatc
+tgaatgacagtgatagaaaagatccccatttgcccggtcagttcatgttacaccactcat
+tagtactgtaagtgtttcgtcagcattgagatccacgatcatgtgtttatgccttcgaaa
+ctggatgtacgacgatcgagacgaagaggtatatataacctaaatactaggtacgttgtt
+agagagacgatgaaaattaatcgtcaatacgctggcgaacactgagggggacccaatgct
+cttctcggtctaaaaaggaatgtgtcagaaattggtcagttcaaaagtagaccggatctt
+tgcggagaacaattcacggaacgtagcgttgggaaatatcctttctaccacacatcggat
+tttcgccctctcccattatttattgtgttctcacatagaattattgtttagacatccctc
+gttgtatggagagttgcccgagcgtaaaggcataatccatataccgccgggtgagtgacc
+tgaaattgtttttagttgggatttcgctatggattagcttacacgaagagattctaatgg
+tactataggataattataatgctgcgtggcgcagtacaccgttacaaacgtcgttcgcat
+atgtggctaacacggtgaaaatacctacatcgtatttgcaatttcggtcgtttcatagag
+cgcattgaattactcaaaaattatatatgttgattatttgattagactgcgtggaaagaa
+ggggtactcaagccatttgtaaaagctgcatctcgcttaagtttgagagcttacattagt
+ctatttcagtcttctaggaaatgtctgtgtgagtggttgtcgtccataggtcactggcat
+atgcgattcatgacatgctaaactaagaaagtagattactattaccggcatgcctaatgc
+gattgcactgctatgaaggtgcggacgtcgcgcccatgtagccctgataataccaatact
+tacatttggtcagcaattctgacattatacctagcacccataaatttactcagacttgag
+gacaggctcttggagtcgatcttctgtttgtatgcatgtgatcatatagatgaataagcg
+atgcgactagttagggcatagtatagatctgtgtatacagttcagctgaacgtccgcgag
+tggaagtacagctgagatctatcctaaaatgcaaccatatcgttcacacatgatatgaac
+ccagggggaaacattgagttcagttaaattggcagcgaatcccccaagaagaaggcggag
+tgacgttgaacgggcttatggtttttcagtacttcctccgtataagttgagcgaaatgta
+aacagaataatcgttgtgttaacaacattaaaatcgcggaatatgatgagaatacacagt
+gtgagcatttcacttgtaaaatatctttggtagaacttactttgctttaaatatgttaaa
+ccgatctaataatctacaaaacggtagattttgcctagcacattgcgtccttctctattc
+agatagaggcaatactcagaaggttttatccaaagcactgtgttgactaacctaagtttt
+agtctaataatcatgattgattataggtgccgtggactacatgactcgtccacaaataat
+acttagcagatcagcaattggccaagcacccgacttttatttaatggttgtgcaatagtc
+cagattcgtattcgggactctttcaaataatagtttcctggcatctaagtaagaaaagct
+cataaggaagcgatattatgacacgctcttccgccgctgttttgaaacttgagtattgct
+cgtccgaaattgagggtcacttcaaaatttactgagaagacgaagatcgactaaagttaa
+aatgctagtccacagttggtcaagttgaattcatccacgagttatatagctattttaatt
+tatagtcgagtgtacaaaaaacatccacaataagatttatcttagaataacaacccccgt
+atcatcgaaatcctccgttatggcctgactcctcgagcttatagcatttgtgctggcgct
+cttgccaggaacttgctcgcgaggtggtgacgagtgagatgatcagtttcattatgatga
+tacgattttatcgcgactagttaatcatcatagcaagtaaaatttgaattatgtcattat
+catgctccattaacaggttatttaattgatactgacgaaattttttcacaatgggttttc
+tagaatttaatatcagtaattgaagccttcataggggtcctactagtatcctacacgacg
+caggtccgcagtatcctggagggacgtgttactgattaaaagggtcaaaggaatgaaggc
+tcacaatgttacctgcttcaccatagtgagccgatgagttttacattagtactaaatccc
+aaatcatactttacgatgaggcttgctagcgctaaagagaatacatacaccaccacatag
+aattgttagcgatgatatcaaatagactcctggaagtgtcagggggaaactgttcaatat
+ttcgtccacaggactgaccaggcatggaaaagactgacgttggaaactataccatctcac
+gcccgacgcttcactaattgatgatccaaaaaatatagcccggattcctgattagcaaag
+ggttcacagagaaagatattatcgacgtatatcccaaaaaacagacgtaatgtgcatctt
+cgaatcgggatgaatacttgtatcataaaaatgtgacctctagtatacaggttaatgtta
+gtgatacacaatactcgtgggccatgggttctcaaataaaatgtaatattgcgtcgatca
+ctcacccacgtatttggtctaattatgttttatttagtgacaatccaatagataaccggt
+cctattaagggctatatttttagcgaccacgcgtttaaacaaaggattgtatgtagatgg
+taccagtttaattgccagtgggcaatcctaagcaaaatgagattctatcctaaagtttgg
+gcttgatataagatttcggatgtatgggttttataatcgttggagagctcaatcatgagc
+taatacatggatttcgctacctcaccgagagaccttgcatgaagaattctaaccaaaagt
+ttaataggccggattggattgagttaattaagaccttgttcagtcatagtaaaaaccctt
+aaattttaccgattgacaaagtgagcagtcgcaataccctatgcgaaacgcctcgatagt
+gactaggtatacaaggtttttgagttcctttgaaatagttaactaatttaaaattaatta
+acgacatggaaatcacagaacctaatgctttgtaggagttatttatgctgtttactgcct
+ctacaaccctaataaagcagtcctaagaatgaaacgcatcttttagttcagaaagtggta
+tccagggtggtcaatttaataaattcaacatcgggtctcaggatattcggtcatataatt
+tattaagggctcttcgagtcttactctgagtgaaattggaaacagtcatccttttcgttg
+tgaggcatcttacaccgctatcgatatacaatgcattccaccgcggtgtcccgtacacaa
+ggaaacttgttaccttggggatataagaaaactcacacgtctcattattaaactgagtac
+aatttttgcacgagaaagtaatgcaatacaatatgatgaaagccagctaatgaaaaggga
+tggaacgcacctcggatctgttgcactggattaaaatccgattatttttaaaaatattca
+gtgctagagcatatcaggtctacttttttatctggtatgtaaagcccacggagcgatagt
+gagatccttacgactcaacgaaaagttataacataactcccgttagccaaagcccaatcc
+cgattactgccctaccctaacgtctgccatctaaatatcgaacttgttatgatcaatgtg
+actacctcccaccctttccccttcatttgttccactggggataagctagcgttttcagaa
+tcaatgcaataagaatagccaattgtctcacttcatcagagctcttggcaattccaggcg
+ctacgtggttctggaatatattcatttttcaaatagtaatacgtttagtgttgctattgt
+ctacacgtttggatattacgttatgtgagcggacatcaatagttgtctaactctttagta
+agccagagatagcactcttagcgaatggataccatcttccataagtttagttaatagtcc
+gaaacaactgcttcgagcatatttgaacctccttgtaggcaaatagcctcttcaaagcaa
+tcttactaatagatagagtttgttttaagggactactagaaatgggacaatcttaatagt
+atgacctaaactgacatttaaagatatatccaggtggcaagcataaagatcattgcgcca
+cctccaccgtgggattacttatcagtcgatatcctatatgctaagtttgcgacggcagaa
+tacaaactaagctgagttgatgctaaccttacctatgataccccattggaccggttaaca
+gccctacttattccaaataaaagaacttttatgctgtagaagctattatagtgatgcctg
+gtaacttcagtatattaaaatgacacacatacgccatatagagctcctggaactttgaat
+aatgagcgaacttcgaagttgaagagcaagaaaccatatgtcacggttgcctaaagcccg
+gtaaccagacatgtgctatcattgatcattatcgaggttttcataaccttgacccattat
+cggctgtgcgcggacaagtacttaaatcactagtttcttcacctgcttatcggtaagaaa
+taaggttggcaaagaatcgcataagacggacgtagagccgcagcgttgtgcgagtccagg
+tgcatgcgcagcaataggattttaaattttgttccatttttaatttagccgtaaggatgt
+ccgtaaatgattgaaaattggattcaatctttgggcctatgctactggaacctgatcgac
+aaaatttcaaacatacgttaactccgaaagaccgtatttttgcggctagaatagtcagtc
+gcttggagccatataccttaccacttaaacgacgtgctcctgtagttgaaatataaacag
+aacacaaagactaccgatcatatcaactgaagatctttgtaactttgaggcgaagcaccc
+tcttcgagacaactaagagtaaagtaccgggcgccgcaaggagtcgattgggaccctaaa
+tcttgacgaattgctaagaggctcagagctaccactgtaatttctctagagcccataata
+aatgaacgatacatccgtaggtagcacctaagggattataatggaagccaaatgcagtta
+ataatattatatactggcgtacacgattcgacggatctctcacatagtgattcacgaccc
+ccccctttgattgacacagcgtcagcattttgcaagaacgatcttctgcatagggtgcgc
+caccgtaaggatgacgtcgaagctacaactgggtataatttaccatgcttccctgatgct
+gagtgcaatacactaagaatgagtttttaccccatatcaccagtatttgttctgttattg
+cgaagaaatggctatgctgagttggcgactaaagtcacccatcctttttattaggtaacc
+ccctcccttaaactaactgatttgctggagctgccctgcatacatatactttatcattta
+tggacgtccgtgacgcttattatccaccatagtcgatatgctacacggattcattaatgg
+atcgtaggagtttaagttatatttactaagatcggtctcggctactatcccgccttaccc
+ggcgctatttacggccatttttaatatattgacggtaattattcctatggtttcgaccgc
+acgtccttggacaagaaagaatggcaaaaaaaatgtaaaagaaaaaaaatattgagtccc
+taccatcatataaaaaatatgtgatgagtaacttgacgaaatgttagtggttattaaaga
+ctatctattacaccttttgttttctgtcgtagtatattaaagtctagaagccttacagga
+aaatcagggttatacagccgatactccgcagcatgaatcatcgaggaggtgtcctaccat
+cgcgccttgtaatcttgtctgtgtatactgtatttagaccttttatacaaagtaaatatc
+tcggctttatgtgattgggaggggcctactcaaacatgatgacttgacctaataatcact
+gtgcgggcgtcttatgactagctattccttgaaatccaccaccaaatggttaatatgtaa
+aaactttgacgatgaaacaaggtgaatgtgtagttactttgtgtaattagctgcgtcgag
+cattgcttgtaaaaccgtcaatcgcacacgttacttccataaaatttctacgaatacacc
+cttcttaaaaaaaacgtaggaattcacgagtttaacaaacgataactgtataaagtggaa
+gtccgaagaaagcagatgcccgaactactcgaagatgtttcgttttcttaaccatagggg
+cttcttaatggcccactacgcacattttgttcaagcccgagagggacatccccattacgg
+gagtattactaaaactgttccgtaatacgttcagcaagggatgaaaaaggccactgctca
+agttattgacgtgggagtattacatcggaagcctgaatcccacactatgatggtctgtac
+aggcctagggactgcgtctagacggtattaccggcttctaatcatacgatcgtgagtctt
+aacgggaagtaaggctcacacctaccccaaaccatttatctatgtaagtataaaattgtg
+cgtaagtgttcaaagtggacaataaagacgtggcaaaaacccccgcacataagccgcttt
+agatttcacaaataccaatgcggttaaaaacatccttgagtcgtacatacaccatactcg
+cgttaaacggatataacagaagataataaatccggatgtggagtcggtgtaactatagaa
+agccaagtgaaataatgcttaccagtcatttagctatacggctttcatttcatgtcaaga
+gggtggagtttgacctgtacagttgatatatcaccgatacttagaactcacctaaagcta
+aaattgctcgcagcgtgtaatccgcatattacaaacaatagatgggattcattatacata
+agacacgatgatctgctttttcaggttgcgagatgttgcctatcgtcaatcgagtcctgc
+cttacaccacttaaacaaaagtattgacagggaacctattttcgaggtattatatagtcc
+agcttgaatatcaatttgacagttaacctagtgaaaatcagtaagaggaaatacgccaca
+ttctccagtgaaattctacgggttatcgtctagtccaactatcaattataactcacgaga
+tataagtaaattctcgtacttggcctgatttttattatactttggatccttagtaaacag
+gaagggagaaaccttcaacgaaaaacactggattttgttttactctcaaagctcttatat
+gacggaaataccctgtcaagtcttaactttattactagactaatgaaatgggcttggggt
+ggccagaatcatagtacaatttagcggatacactattcggactttcctatcggctgtctg
+gttggataagtatggggactaataggctagacatacctatacttaaactatacaggcgtc
+atctatctctgcaactttggagttccctgatgttctcccgccctttgggttcacatcttc
+tataccgacacccctaataacgattagtttgtgggttagagtaaattaatacggttaata
+ttaatgtatcgttgaaaagctggtgtcgccaataaggtaaccggctaggcagagtatatg
+tcacgaagtataactaccctaatgataagctgtaggaataaaattaatgctgtctctaag
+cgaagagatatttccgactctgttttaatgacgaatctcattacttctgacttgcaaatg
+ttcaatatggcacggtttcacggcacctttgtgacgcatataatgaacttagaagattat
+aacgacggaactttatatgataatccgttacgattaaagaatctgttaaatatcataatg
+gcattcagttctagaccgtgcatcatggtaaacttactttctctgcatggcgacatacat
+ttcgctattcaaattcgcgtgtggttacacccactcgcacctttggaatattaagagaag
+atgatcagaaaatccattcgctcaatttttctgacgtacgtctaatttatcctaggagac
+aaatcgttttatgtctctcacatttttgaagaaaggttcgagagacaatactcaggtcct
+gaactgctagaagatactcggtggagcgtggcaacaatgaaaaactcgtgacataaatga
+atgatacttttccaagttcagttaagtgaatatgtttaacatacccggcttttcgatctt
+aagctgacgctggacgtgcgagtaatgtcagtctcttacatacactagtgactccaagtt
+tcgtcaaaaacgccccctcccttctcgagcccactcacgctatgtattgacgcgaacttg
+ttcgggatcagacttttcaggagttcggtcgcgtgtccctatgtgctaatatataagtta
+gatcgcattagatgctaatctgaatacttatagacgaccttcaacgagaacgggtaccac
+cttgaggctagagttaggtgtgaaacgacaggtagggacatataaaatttgagtgcggct
+ttagttaagggtttaattacctactcaaacatcacgctcgcgcccttcgtacgtaatcga
+ccatctagaggctaaggggactgtactaggtagtgattaatgatatcctagacgcacgtg
+ccttagatcttcagactctgatggtccgcgatcaccgtaattgtagtcctccaactcgat
+cactttgttggcgtcaaagaaattacgatatctaaatacttataatacaataaccaagga
+tgagaatgactcatcgcgttggagttatattgcttgaagttctatggaatgaaagcacgt
+tatctgccgtcccaatatctccagtgagctaattcattggacggtccactttgatcaatc
+cccgaggagatgttcggacactttagtctgtaacacttagcgttgagaccacgaacaatt
+gattactcagtcttgaaggtgttttccaaagttcattttaaataagactacgataggcct
+ttcctattgatataaactacccggctctgttgttcgtgtgagtcgtacttctctgtgttt
+ttctgattatagcaagattcgattcttagtgtaaacagcgatttttatttgacccgtcaa
+tgagaagcgcataggatctaagcaaaattatcaagttgtgccacaaggtaagatctttcc
+agttattgcaggtaggatgtatcccacgttgatagtatgaggtctgacgtcaactgtcta
+ggagagttgaccgcgtgcgggtacaccggatttgcatcgatgttgagaacgcagaactcc
+cactgtcgtggcggcgttcctgatatttagcaagaggcgttgataaagccctcatcatct
+agatctcgacctcatctgccctcttgctccatcattttctacacagactactttcctatc
+tacgttagtataattgctttctatcttagtatcatttagagcttctccgtcaacaggttc
+gtgctattaaagttagtacgaaagggacaacttgtagcaacgcatttaatcggttttcga
+ctacttcgcacaaaatcagataaagaagtttgtcattctattagacattgaattgcgcaa
+ttgacttgtaccacttatgatcgaacactgaatcaagactgtgattaactaaaatagaca
+agccactatatcaactaataaaaacgcccctggtggtcgaacatagttgactacaggata
+attaattggactggagccattacattctctacaatcgtatcacttcccaagtagacaact
+ttgaccttgtagtttcatgtacaaaaaaatgctttcgcaggagcacattggtagttcaat
+agtttcatgggaacctcttgagccgtcttctgtgggtgtgttcggatagtaggtactgat
+aaagtcgtgtcgctttcgatgagagggaattcaccggaaaacaccttggttaacaggata
+gtctatgtaaacttcgagacatgtttaagagttaccagcttaatccacggtgctctacta
+gtatcatcagctgtcttgcctcgcctagaaatatgcattctatcgttatcctatcaacgg
+ttgccgtactgagcagccttattgtggaagagtaatatataaatgtagtcttgtctttac
+gaagcagacgtaagtaataatgacttggaataccaaaactaaacatagtggattatcata
+ctcaagaactctccagataaataacagtttttacgatacgtcaccaatgagcttaaagat
+taggatcctcaaaactgatacaaacgctaattcatttgttattggatccagtatcagtta
+aactgaatggagtgaagattgtagaatgttgttctggcctcgcatggggtctaggtgata
+tacaatttctcatacttacacggtagtggaaatctgattctagcttcgtagctgactata
+ctcaaggaaccactgctcaaggtaggagactagttccgaccctacagtcaaagtggccga
+agcttaaactatagactagttgttaaatgctgatttcaagatatcatctatatacagttt
+ggacaattatgtgtgcgaaactaaaattcatgctattcagatggatttcacttatgcctt
+agaaacagatattgcccgagctcaatcaacagttttagccggaaacaatcgaagcatagg
+gacaatgtatcttttcctaaattgccatgtgcagatttctgagtgtcacgaagcgcataa
+tagaatcttgtgttgcctcaactcgttgaaaagtttaaaacaatcgcagcagtctttttg
+gggtctactgtgtgtttgcaaaataactgaaagaaacgcttgaacaactctgaagtagct
+cgagtactcattaaagtgtaacacattagtgaatatcggccaatgaaccaaacgcttccc
+ggtacgctatctctctcatcgggaggcgatgtgcaggttatctacgaaagcatcccttta
+cgttgagagtgtcgatgcatgaacctcattgtaacaatagcccagcaaattctcatacgt
+gcctcagggtccgggcgtactcctccatggaagggcgcgcatctagtgttataccaactc
+gctttttaactactatgctgtagttctacaggcatagtggccagtattttctaacttctc
+tggatagatgctctcactcctcatccatcacggcttcagtttacgtcttacttgcttgtt
+cagcaacggatggaggcattaagtatcttcactgttccctaaaattgctgttcaatatca
+aagtaaggacgatacagggaaagctcaagcacactcattgaatactgccccagttgcaac
+ctcacttaatctgacaaaaataatgactactctaagtgttgcggaagcagtctcttccac
+gagcttgtctgtatcacttcgtataggcatgtaactcgatagacacgaacaccgagtgag
+aaactatattcttgcttccgtgtgtgtgacaccaggtaattgatgcggatataagctgga
+gatcactcacgcccacacaaggcgctgctacctctttattccaatgtgtaagaatttgct
+aacttcatttctagaccgcagctttgcggtcataatttcacggtacggacccttgggtta
+gagacttgataacacacttcgcagtttccaccgcgcacatgttttagtggcttctaacat
+agaatttttgttgtgacataaagagtgcgtgggagacttgcccgaccgttaagccataat
+caattgaaagccccgtgagtcacatctaattggttgtactgcgcatttagctatccttta
+gctgactcgaagagattcgattcctaatataggttaattagatggctgccgcgcgaagta
+aaacgtgaaaaacgtagtgcgcagatctgcataactcgcgcttaattacttatgagtagt
+tccaagttcgctacgttatgagagagattggaattaagcaaatatgttttatggtgattt
+tgggatgagaaggactgctaagtacggctactaaacaaatttctaaaaccgccatctacc
+ttatcttggagacatttaagttgtatatgtcactagtctagcttttgtctgtgggacgcg
+ttctcggaatgagggaaatgcaagagccgattcatcaaatgcttatctaagaaagtagtg
+gactattacaccaagcacgaatgccagggaactgctttcttgctcaggacctcgcgacaa
+ggtaccccgcataagtcctagaattacatttggtcagcaatgctgacatttgaccgtgaa
+aacataattttaatcagaaggcagctcacccgcttgctctagatcttatctttgtatgaa
+tgtcagaatttactgcaatatccgttccgaatagtgagggcttagtatagttctctgtat
+acaggtcacatcaaactccccctgtcctagtacagctctgagctttaattaattgcatac
+atttccttcaatcatcagatgaaaacaccgcgaatcatgctcttctcgtatagggcaaga
+gaagcaacaaacaactagcccgactcacgttcatccgccgtatccttgttcagttcttac
+tccgtattaggtcagcgaaatctaatcagaataatcggtcgcgtatcaaaattaaaatcc
+cgcttgaggttgacaattaaaacgctgagcagttatcggctattagatagtggggtgaaa
+gtaattggctggaattatgttaaaacgtgatattaagctaaaatacgctacttgttgccg
+acctaattcagtcattcgatattcagttagagccaagaataacaagcttgtataaattga
+acggggtgcactaaacgatgtgttactctaatattcagcttggagtatacctgaaggcga
+attcatgtatcggccaataataagacgttgaagatcacaatttggactagcaaaagaagg
+tgatttatgcgtggggattgagtccactgtacgagtacggtctctggaaaattataggtt
+cagggaatataaggaagtaaagataattaccaagagatttttggtatcgctatgacccag
+aggtgttctaacgtctgttttgatccgcagaatttctgcctcaatgcatatttgacggac
+ttgaactagagcctctaaagttaaatggcgacgcaactgttcctaaacttcaattattac
+tactctttttttcctagggtattgtagaggccagtggacaaaataaatcaaatttaagat
+gtttcggacattaacatcccccgtagcatagaaatcatcagttatccaatctctcatcga
+gcttttacaatttctgctggcgctatggacagcatatgccgcgagacctccgcaagactc
+acttgatcactgtaagtatcttcattagaggttagagcctatagttaagctgctgaccta
+gtaaaattggtattttctaattttattgctcaagttaaaggttagtgaagggataatgac
+gttatttttgaacaatgggttgtattcaattttatatcacgaatggaacccttcattccc
+ggcataatactagacgacacgaacaagctccgatctatcagccaggcacgtgttaaggtt
+taattccggcaaaccaatgaagcatcaaaaggtgacctgatgcaacttagggtcacgatg
+agtttttcaggactacttattacctattaataagttaacatgagccttcataccccgtaa
+gacaatacatactccaccaattagaattctgagccatcttatctttttgtatcatcgaag
+ggtatggccgaataggttaattagttactcctaacgtctctacaggcatgcatttgacgc
+accttcgaaaatagtcaatctctcgccacacgcgtctagtatgcagcatcaaaaatatag
+tccacggtttccggattaccaaacgcggcaaagagaaacattgtatcgacggagataact
+taatacagaaggaaggggcatcttcgaatacggatgaataattctatctgtttattctga
+catcttgttttcaggttaatcttacgcattcaaatgacgcctgccccatgcgtgcgcaat
+tattttctaatattgacgagagcaatctcactccttttgggtctatttatgttttattga
+ggcacaagcctatacagaacaggtactattaaggccgtgagtgtgagactcaaaccgtgg
+aaacaaaggatgggttgttcttggtacaagttttagtgcatgtgggcaatccttaccaaa
+atcagatgctatccttaactttgggctgcatttaagatggcggttggaggcctgtgagaa
+tcctgcgtgtcatctttaatgaccgaattcatccatgtagattcagatcacacactcatt
+ccttgatgttgtctaaacaaaagttgttgtggacgcattggagggagttaagtaacaact
+tgggatcgcatacttataaaaattatatgttaaactttcacaaacgctgaagtccaaagt
+aactagcccaaacgcctcgagagtcactaggtattaatggtgtttgagttcctgtgaaat
+agtgttcgaaggtaaaatttatgtaccaaatcgaaagaacacttaataaggcttgcttgc
+acggaggtatgatgtttactgactctacaaccctaattttccagtacgtacattcattcc
+aataggttagttctcaaagtgctatacaggctcctcaattgatgatatgcttcagccgct
+ctatggatattagctcattttatttaggaagcccgcttagaggcttactatgagggaaat
+gccaaaatgtcatacttttcggtgtgtcccatatgacaccgctttacatagaatttgaat
+taaaacgcgctctcccgttcactaccatacttggtaccgtgcgcatattacatatagata
+taggatcattttttaaagctgtactaggtttgatcgacaatcttatgctatactatatga
+tgtaaccctcataatcaataccgatcgtacgatcctagcataggtggcaagcgattttat
+gccgattattgtgttaaatagtctgtgagtgtgattatcagggctacgttggtagagggg
+ttgtatagacctcgcacacattgtgacatacttaacaatatacgaaaactgatataataa
+atccccttacccaaacaccaatcccgttgaatcaactaccataacgtctcccatataaat
+tgcctacttgtttgcataaatctgaatacataacaccattgcaccttcttgtgttccaat
+cccgttaagattgccttgtcagatgatatgcaagaacaatagcatttgctagcaattatt
+aacagctcttcgaattgcctccacataacgcgggagggtatattttaatttggcaaatac
+taagtactgttggcgtcatatgctattaacggttggatattaagttatgtcagccgtaag
+caagagtgggcgaaatattttgttacccagtgagagcactcttagagtttggatacaata
+ggccatatgttgacttaagaggacgtaactacgccgtacaccattgttcaaccgacttct
+tggcaaatagaatcgtattagcaatcttaagaatagagacacgttcgtgttagggtatac
+tacaaatccgaaaatcttaagaggatcacctaaactgaaatttatacatatttcaacgtg
+gatagatttaacataattcagccacctccaacctgggagtaattttcagtagatttacta
+gatgattagtggcccaacgcacttgactatataagatctggggatcctaacctgacctat
+gagacaaaattggaaacgttaacagcccttatgtgtacaaagaaaagtaagttgttgctg
+ttcaacagatgatagtcatgacgcgtaacttcactatagtaaattgaaacaaatacgcaa
+tttagacagaatggtacggtcatgaatgacagtaattcgaagtgctagaccaacttaaaa
+taggtaaacgtgcccgaaaccccccttaacagaaagctgctatcatggtgcagtatcgac
+gtgttcagaaacttgtaacttttgagcaggtccgagcacatggaagtatatcacgtgttt
+ctgaaccggcttatccctaagatatatccgtcgcaaactttcgatttagtcccacgtaga
+gcccaagcgttgtgcgactccacgtgcatgcccagaaatacgagtttaaatttggttaca
+tggttaattttgaccgaagcatcgcactttatgattgataattggattcaatatgtcgcc
+ctatgcgaatgcaacatgatccacaatttggctataagacgtttaatccgtatcacactt
+tgtttgcggctagtatagtaacgcccgtgcaccaagagtcagtaacaattataagtactc
+cgcaggtacttcaaatataaaaactaatcaaacacgacccatatgatcatctgaagatat
+ttggaactttctcgacaaccaccctcgtactcaatacttacactaatcgacaggcacacg
+caacgtgtacagtcgcaccatattgagtcaagatttgcttagtggcgatgagcgtacacg
+cttatttctctagtcacaattagttatctacgagacatcacgagggagcaaataagcgat
+gttatggctacacataggcacgtatgaatatgatataagccagttaaacagtcgaaccat
+cgagcaaattctcatgcaccaacccacacgttgaggcacaaagagtaagctgtttgaatg
+taacttcttctgctgagcgggccccaacgtaaggatcaactagaagagaaaactcggtat
+tagtttaaatgcgtcacggagcatgagtgcatttcactaagaatgtctgtgtaaccaata
+taacatctatttgttatctgattgcctacttatggctttgcggtcgtggcgactaatgtc
+tccaatccttttgaggtcggtaccaactccctttaaattacgctgtgcaggctcatgcac
+tgcatacatatacggtagcaggtagggacctcacgcacccttattataatcaatagtagt
+tatcagtcaacgaggcaggaatgctgaggtcgaggtgttggtatattttctatgtgccgt
+ctaggcgactatcacgcattaccaggcgagatttaagccaattttgaatatagtcaacgt
+aatttttactatgggttccaccgaaacgccttgcacaactaagaatcccataaaatatcg
+atatcaaataaaagattgtgtcaataccttcatatatattttttcggttgactaacgtga
+actaaggttaggggttttgtatgtctatataggaaacagtttcttttctgtcctacttta
+gtaaagtcttcaagccttactccaaaatcacggtgattaagccgttactcagcagcatga
+ttctgcctgctcgggtcctaaaatccagccttgtaagagtcgctgtgtattagctaggga
+gacctttgttaaaaaggatatatcgcggcgggatgtgagtgcgtggcgcatactcaatct
+tcagctcgtgtcattataatatctctcccccacgcttttcactagatatgccgtgtaagc
+aaacaccttatgcttaatttcgaaaatattggtacttgaaaaaagctgtaggggtactta
+atgtctggtaggagatcaggagagaattgagtgtaaaaccgtaaagccctcacctgactt
+catgtaaatggcttagaagactccatgatttaataaatactacgaaggaaagactggatc
+taaagataactctagtaaggccaactcccttcaatgctgttgccagttataatccaagag
+ctgtccttttctgaaccatagcggcttctgaagcgaactagaagcaaagttggttctagc
+cagacagccacataccctgtacgggtgtattactaaaactggtccggtattagttcacca
+agggaggaattaggcaaaggatctaggtatgcaagtcggagtattacatccctaccctga
+atccatcaataggttcctctgtactggccttcgcaatgagtattcaaggttgtacagccg
+tataataataagatagtgactatgaacgggaagtaacccgctcaccttccccaaaacatt
+gttatatctaagtattaaagtctgccgtagtgttaatactcgaaaataaacaactggcaa
+attacaccgcacttaagccgcttttgatttatatttttccaatgcgcttttaaaaataat
+tcagtcctacatactaattaagacccttaaacggagatatcacaagttaagttttaacca
+tctcgactaggtggaactatagatacccaactcaatttatcattacctgtaatgttccta
+gaaggattgcatttcatgtcaagacggtggagtttcacagcgaaacttcagtgtgaacag
+attctgagaaatcacctaaacctattagtcagagcacccggttagaaccagttgtcaaaa
+aatagagcggttgcatgagacagaagtaacgatgagatccgttgtaacgttgagacatct
+ggcctatcgtcaatacagtcctcccttaaaaatatttttaaatactaggcaaacccaaca
+taggttagtcctatgtgatacgccacatggtatatcattttgtaacgttacctagggata
+atcaggaagtggaattacgcaaaagtagacagtgaaatgcttagggttatagtctagtcc
+aaagataaaggataaagcacgtcagagaactatattagccgaatgggaatcattgttagg
+agactgtggatcatgtctaaaaagcaacgcagaaacagtcatcgaaaaaatctcgttttt
+gtttgaatctaaaagagctttgatgaccgatagtacctgtatactagttactgtattacg
+tgtctaatgatttcggattggggtccccagaatcagacgtcattgtagacgattcaagtt
+taccaatttaatttcccagctctccttggagaactatcgccaataattgcagtcactttc
+cttttctgaaacgataaagccgtcagagttctctgcaacgttggacttacctgaggttct
+aacccactttcggttctaatagtagttaacgacacaacgaataacctttactgtggggct
+ttcacgatattttttcgcttattattaatggttacgtcataagctggtgtccaaattaag
+gttaccggcttcgcagagtagttgtatccaagtataacttccctaatcataagatcgagg
+tagaaaattaatgctgtctctaaccgaacagatatgtcccactatgtggtatggacgttg
+ctaattacttctgaagggaaattggtcattatggatacgtgtctaccatcaggtcggacg
+cagatatggttctgtcttcagttgatccaccgttctttataggataataactgacgatta
+aagattatggtaaatagattaagccaattctcttcttgtcagtgaagcatccttaactga
+cttgctctgcagcccctcatacatttagctattcaaagtaccggctcgtttcaaactctc
+ccacctttggaagaggttgtcaacttgataagtatatcatttacagcattttttcggacg
+tacctctaatgtttcattgcagaaaattagttttttctatcgcacattttgcaagtaacg
+ttagagacacaattatctgcgaatgaactgctagatctgacgaccgggagcctcgcaaat
+atcaaaaaagactgacatatatcaaggagtcgttgacaagtgctggtaagtcaattggtt
+tatctgtcccggcgtttcgatcttaagctgaccatgcacggcagagtaatgtcactctcg
+ttcttacaagtctgtctccaagggtcggcaaaaaagacccctccattctcgagcccactc
+acgatatgtagggacgacaacttgtgcggcttatgaattgtctggactgcgggcgagggt
+ccatatctccgaagttagaagggacatacctttagatgataagatcaattcttattgacg
+aaattcatccacaacggggaacaacttcaccctagacttacgtctgaaaagacacctagc
+gtcttataaaaggtcagtgccccgtttcgtaaggctggaattacctacgcaaacttaaac
+ctcgcgcccttccttacgtatcgacaagatagaggctatcgcgaatgtactacggaggca
+tgaatcatatactagaaccaagtgcctgtgatattaacaagatgatccgacgcgagcacc
+gtaattctaggcataaaactccagcaatttgggggccgaaaacaaatgacgttagctaat
+taattatatgacatgatcaaaggaggtcaatcacgcatcgagttcgacgtatattcattg
+aacttcgtgcgtttgaaagaaacttttatgaaggcaaaattgatcctgtctcctatttca
+tgcgtacctcctagttgataattccccgagcagtggttaggacacttttgtcggtatcaa
+gttccggtctcaaaacgtaaaattctgtaatctgtatggatggtctgtgaattagttaat
+ttttatgaagtcgtcgagacgcagttcctattgatttattctaaacggagatgtgcttcg
+tgggactcggaagtagatctgtgtttatgattattgctactttagatgctgactgttaac
+tccgtgttgtttttcaaccgtatatcacaaccgaattggatagaacctatagtttcaagt
+tctgccacaaggtatcatatttacagttagtgctggttgcttctttcaaacgtggtgagt
+ttgtgctatcacgtcaacggtagagctcagtggaccgagtgcgcgttcaaccctgttcca
+gagagggtgtgatagcacatataccacgctcgtcgaggcgttcatgatagtttgcaagag
+ccggtgttaaacacatattattattgttatccaactaatcggacctatgcataaagcatt
+gtctaaacagaataattgcctatatacggtagttttagtgatttatatcttagtatcagt
+tagagcttcgaactcttcaggttcctcatatttaacgttcttcgaaagcgaaaacttcta
+caaacgaatgtaagcggttttccaagtagtacctataaatcacagaaagatctgtctcag
+tatagttgaaatggtattcagctagtgacgtgtaccaattatcatagttcactcaagcaa
+gacgctcattaacgaatatagacaagacactatatcatataataaaaaagaacatggtgc
+tcgaacatagttgaattcaccatattgaaggggaatgctgacatgtaattcgctactaga
+cgatcaattccctacttgtcaaagttgaactggtacgttcttggaattaaatatgattgc
+gctggaccaaattgcgacttcttgagtttcagggcaaacgattgagccggaggatgtccg
+tctcttacctttcttgcttatgataaacgacggtccctgtacatcactgggaattctcag
+caaaaataattgggtaaatcgagactcgatgtattcggccacaaaggtgttagacgttaa
+agattattcaacggggcgataataggatcataaccggtatgcaagcgcattgaaagagcc
+atgagatccttatccgataaacgctgcacggtatgtgcagccttattgtcgatcacgaat
+ttataaatgtagtctgggctgtaagttgaagacctaagttataatgaagtgcaataccaa
+atcgattcatagtggattatcagactcaagatatctcctgataaattacagttgttaaga
+tacggataaaatgagatttaagattagcagcctctaatctgtttcaatcccgttggaatg
+tggtatgcgatcaaggttaagttaaaatcaagcctgtcttcagtcttgattcttgttctg
+ccatcgcatgcggtctacgtgagttaatatgtagcttacgttctagcttgtgctaatctg
+agtatagattcgtagaggaatattatcaagcttccacgcctcaacgtacgtgtattggtc
+acacaagacactaaaagtggaagtagcgtaaactatagtctagttgttaaatgctcagtt
+cttgttatattcgatatactcttggctaatttatgtctgagtatataaaattaatgatat
+taacttgcatttcacggatcccttagaaaaagattttgaccgagcgcattataaacggtt
+acaccgaatcaatagaagcatacccaatagctttctttgaatttattgcctgcgcaactt
+ggctgactctctagatccgaataattctatatggtcgtgacgaaactagttcattactgt
+ttaaaatgccaacatgtcttttgggccgataatggctctttgcaaaattactcaatgata
+cgattgatcaaagcggtagttgctagtggtagcatgtaagtctatcaaatgtctgattat
+ccgaaaatcttccaaaagagtccacgtaccatatctatctcatagcgacgcgaggggaac
+cttatctaactatcattccatttaccgggtgactctcgatgcaggatccgattgggataa
+attgcccagaaatggctcattcctgactaagggtaaggccgttctcagcaagggaacccc
+gcgaatctaggcttataccatctagattgttaactacttgcctgtagttctacagccata
+ctggacagttgtttctaaatgatcgggattcatgctagcactcctctgaatgcaccgcgt
+aagtttaactattacgtccgtgggcagataaggatggaggctgtatgtatcttaactgtt
+acctaatatggctggtaattatcaaagtaaggaccttaatgccatagcgctagcaatcgc
+tttgtatactgaccatgtgccaacctctcttaatctgtaaaatataatgtcttagctaac
+tgtggacgatcatgtctctgcctagagcttcgctgtatcaattcctatagccagcgtact
+agtgacacaacaacaccgtgtgagaaaagatattagtccttacgtctgtctctctacagc
+ttattgatgaggattgaacatggacatatagctccccctcaaaagcagatgctacctctt
+tattccattctcgaacatttgccgaacttaatttcgacaaacctgaggtcacgtcttaat
+ttatcggtaacgtcacgtccctttgagactggataaatatattaccaggggccaacgagc
+aattgttggaggcgcttctataatacaaggtgtcttgtcaaagaaagacggcgtgcgtct
+cgtgcaactcacttaaccaatattaatgtgaaacccccctctctcacatcttatgcggtg
+tactgccctggtacatttcctgtacaggactccaacagtgtagattcctaagatagctgt
+tggagttgcctcacgccagatcgaaaaactgaataaactagtgagctgagctgcagaaat
+accgcttaattacttatgactagttcaaagggacctacgtgatgtcagacattgcaagga
+agaaattaggtttgtgcgtcattttggctggactagcactccttacttcccctactattc
+aaatgtcgtaaacagcatgagacaggatcgtgctgacatttaaggtctattgggaacgag
+gctacctttggtcgcgcgctcgcgttctccgaatgaccgaaatgcatgagcacagtatgc
+aattgcttatagatctaaggtctggtcgttgaaaccaagcacgtaggcctgggaaatcag
+ttcttcctcagcaactacacaaaagcgtccaagcattagtacttgtagtaaatgtccgaa
+cctatgcgctcatttgaaagtcaaaaaatatttttaagcagtaggcacctaacccgattc
+ctctacttagtagctttctttgattctcagaattgactgcaatatcactgcacaattctg
+tgccattactagacttctctgtattaacgtctcatcttactaacactcgcctaggacaca
+tctgagagtgaagtatttcaatacatttactgaaatcttcagttctaaaatccccgaata
+aggctcttatcggtttggccaacacaagaaaaaaacttcttgcaccactcaccttcatac
+gcaggagcctggggaacttagtaataactatttcggcagacaaagcttataacaagttgc
+cggcgcgtataatatttaaaagaccccttgagctgctcaattaaaacgctcacctggtat
+aggctattagatagtgccgtcttagtaaggggcgggaattatcggataaactgatatttt
+gataaaataaccgacttgttcacgacataagtcactaaggagattttatctttctccaaa
+gtatatcttccttggataatttcaaagcgctgcaatttaagttctgttactagtttatgc
+tgctgggaggtgaccggaaggcgtagtaatctagaggcaaattataagaagttcatcata
+tcattttcgactacaaaaacaaggtgttgtatgccggcgcattgtgtaaactggacgagt
+accctagatggaaaattatacgttaagccaagatttcgatgtaatgataattacctacac
+atttttgctatccataggaacaagagctgttctataggctcgtggcatacgaacatttgc
+tgccgctatgaatattggaagctcttcaactacagactctattcttaattgccgtcgaaa
+atgggccgaatcggctattattaatactcggtttttccgaggggattgttgtcgacagtc
+gtaattattattaatattgatgttggtgaggtcatttaaatacaaccttgcagacaatga
+ataagggatccaatctctcatactccttttacaattgctcatgcccctatgcaaacctta
+tgccgccacacctccgcaactctctcttctgaactgtaagtagcttcattactggtttga
+gactatactgaagctgatgacattctaaaatggctattttcgaatgtgattcataatgtt
+tatcgtttgggatggcagaatcacgttatttttgatatagcccgggtattctattgtata
+gaacgtatgctacaagtcattccccgaagaagactagaagtaaacaacatgcgaccatcg
+ttaagccacgcaaggctgtagctttatttcccgataacctatcttccataaatagcggac
+agcaggatactgacgctcaacatcagtggttatggtctaatttttaacttttaataaggt
+aacttcagcaggcatacacagtaactctttaatttataatcaaattagaagtctgacact
+tcttatatttttctatcatccaacgcgatcgcccattagcttattgtgttactaataacg
+tatctaaaccaatccttttcaagctactgcctatattgtcaatatatacaaacaacagga
+tagtaggctgcttaaaaaatattgtcaaccgtgtacgctttacaatacccggaaatcaca
+aactttgtagacaacgagtgaaatttatacactacgaagggccagcgtacaagacccatg
+aattaggcgatatgtttattctgacatattggtttatccttaatctgtcgctgtaaaatg
+aagccgcccccatccctgcgaattttttttcgaagattcacgactgaaatataaatacgt
+ttggctatatttatgttggagggaggcaatagcctttactgttaaccgaagatttagcca
+gtgagtgtgacactaaaacactggaataaatgcaggcgttcttctgggtaaaaggtttag
+tcaatctcgcctataagttcatatagctctggatataattatctggcccatgcatttatc
+atggcgcttggtgccctgtgtgaagccggcctctcatattgaaggtccgaagtattccat
+gtacattaagatcactctctcattcatgcatcttggcttaacaaatctggttgtccaagc
+tttccaggcacgtatggtacaaattcggatcgaatacttataaaaatgatatgttaaact
+gtctaaaacgctcatctacaaagtaaagtgcactaaccaatagagtctcaagaccgtgta
+atgctggtgcactgaatgtgtaatacggttagaagggattagttatgttacaaatccatt
+gaaaacttaagaagcattgcgtgctcggagggtgcatcttttatcaagagactaacatta
+ttttcaacgacgtacatgctttacaatagggtacttatcaaacgccgagaaacgcgccta
+tagtgatgttatgattatgacccgatatccattggaccgaattttatgtaggttcccagc
+gtactcgcgtaatatctcggtattgccataatgtaatacttgtcggtctctcccagatga
+aaaagcgttacagagtatttcaatgaaaaacagcgcgcaacgtcaatacctttaggggta
+acggccgctgatttcatatagatatacgataagttggtatagctctactaggtggcatcc
+acaatcgttgcatttactatagctggttacaatcataatctataccgttccttacatact
+accatagcgggatagcgtttttttgccgttgattgggtttaagaggatgtcagtctcatt
+atatccgattcggtgggagagccgttgttttcaaatcgcacactttgtgacataatgtac
+aagataacaaaactgatataagatataaactgtcaatatcaccttgacacttgaatcaaa
+gtaaattaactcgcaaatataatttgactaattgggtgcagatttctcaattaataaaaa
+aatggcaccggatgggcttacaagccccttatcattcacttgtatcatgatttccaagaa
+caatagaatttgctagcaagtatgaacagagattcgaattgcatccacagtacgccggag
+cgtttattttaatgtggatatgacgatgtactgttggcggcatttgctagtaaccggtcc
+ttatttacgtagcgcacacgtaagcatgtctgggagaaatatggtggtacaatctcagag
+aaagattacagtttggtttaaataggacttatcgggtcggaagtggaacttaataagcag
+tacacaattgggcaacagacgtcttgcctattacaataggattacaatgcgttagatttc
+agacacgttcgtgtttggctattcgtcaattccctaaatagttagacgatcaactattat
+caaagtgattctttgttcatcctccattcatgtaacagatggcacactacgcataacgcc
+gaggaattttaacgagatttaagagagcagttcgggcacaacccacttgactttataaca
+gctcggcagcataaacggtaatatgtgacaaatttccaaacgttataagaacgtatgtgt
+acttagaaaactaagtggttcatgttcaacagatgtgacgcagcaagcctaacttatcta
+ttggttttgctataaaagaacaaagttacacagaatcctaagggcttgtttcacacttat
+gcctagtgcttcaccatcttaaaatagcgaaaccggcacgaatcaaaccttaaaacaatg
+cgcagatattggtgatggtgactccgggtatgataatggtaactgttgaccagcgcccac
+ctcatcgaagtatagaaagtggttaggataaggatgagaccgaacttatttccggccata
+actttagattttctacctagtacacaacatcagggcggacacgaaaccgccatcacatca
+tataccaggtttaatttgcttaatgggggaagtgtcaacgaaccttcgaactttagcagg
+catatggccattatatatggccccagagcagaatgctacagcagacaaaatttggattta
+tgtagtttaatacctatcaaacttggtgtgaccatacttgtctaacgacagtgcacaaag
+tgtaagttacaattattactactcagcagcttctgcaatgataaaatcttatcatacacg
+tcacatatgataatatctacttagggggaacgggctccacaacctacatagtactcaata
+cttacactattcgacaggcacaccaaacctgtacagtcccaaaagattgagtcaactttg
+cagtactgcagatcacagtaatagcttagttagcgagtcaaaattagttttctacgagac
+tgcacgaccgtgcaaatttccgatgtgttggctacaaatagcaacgtatgaatttgtttg
+aagccacgtaaactgtacaaccttagagataagtctcaggctactaaaaacacgttgtgg
+cactaacaggatcatggttgattcttacttattcggctgaccggcccaataagtaacctt
+caactagaacagaataatcgggagtagtttaattcagtcaaggtgcaggtctcattgtaa
+ctaacaagctctgtgtaaccaagttaaaatcgttttcttagcggattccctacttatgga
+tttgagctcgtccacaatattcgatacaagaagtttgtggtccgtaacaacgaaatttta
+attacgctgtgcagcctcatccaaggaattaatagaaggttgatggtaggctccgaacgc
+tccatgattataatcaagtggactgtgcagtaaacgaggaaggtatcctgacgtcgtggt
+gttcgtttttgttatttgtgccctatacgagtagataaaccatgaacagcacagtgtgaa
+cccatggttgattttaggctaccttatttttaatttccgttacacagaaacgaattccac
+aactaacatgccattaatttttcgatatcttataaaagatggtcgaaattcattcattta
+ttttttttcggttctcgaaagtcaactaagctgtcgcgttttgtttctctttagaggtaa
+aagtggctttgatctcctacgtttggatactagtcaaccattactccatttgatccgtga
+gtatcacctgtctaacatccagcattatgactcctcggcgaagaaaagacacacttctta
+gagtcgatgtgtattagctagggacacagttgtttaatacgatagtgagcccagggaggg
+cagtgcgtcccccagtagatttattcagctagtgtaagtataagatatctcacccacgag
+gttcaagtgatatgcagtcttagaataatacttatcctgaatttcgatattatgggtact
+tcaataatccgctagcgctactttatgtctcgttggacagcaggacacatggcagtctta
+aacactaaagacatcacctgaatgaatgtaatgggattacaagaatcaatgaggtattat
+atacgacgtaggaaactctggatatatacagtaatctagttacgccatcgcacttcattc
+ctctggaaacttagaagacatcagctgtacgtggaggaaccagacccccgtatgtagcca
+aatagaaccaaagttgcttatacaaacacacccaatgacaatggaccgctggagttcgta
+aactcggaacgtagtactgcacaaacccagcatttagcaataggagctacgtatgcaact
+cccacgtggtaataccttcaagctatcaatatataggtgcctagctaatcgcattcgcaa
+gcagtattcaagcttgtaaaccagtataataattacagaggctctatgaaacccaacttt
+ccagctaaaagtcccaattaaatggttatttcgtacttttaaagtcgcccgttctgttat
+tacgcgaattgattctactccaaaattaaacacaaattatcaaccgtttcatttatattt
+gtcaatgcagctgtttaaaataaggctctactaaattataattaagacacttattaccag
+atttctctagttaagtttgaaccagctcgactaccgcgaaagatacattcccttctctat
+ttttcagttcatctatgggtcagagaagcattgaatttattctattcaccctcgtcgttc
+acagcgaatcgtcagtgtgatcagtgtatgagaaatatcctaaaccgtttagtcagacca
+cacgcttagaacaagtggtctaaaaagactgccctggaaggagtaagaagtatacagctg
+atccggtgtatccttcagtcatctgccctatactaattacacgacgcaaggaaaaatagg
+tttattttctaggcaaacccttcataggtgactccgatgtgttacgaatcatgcttgaga
+atgtgctatcgttaccgacggataataacgatctccaatgaaccaaatgtagaatgtcta
+ttgattacccttttactattcgacttagagataggagatagaacctcagtgtactttttt
+agccgaatgggaatctttgggaggtgaatggccataaggtcgtaaatccaaccctcttaa
+agtcttccatattatatcgttgttcgtggaatcgataacagatttgttgacccatagtaa
+atgtatactagtttatgttgtaagtgtagattgttttccgattgccgtccaaactttatg
+tcgtaattgtagaccagtaaagttgaccaaggtaagtgcccagcgatcctgcgagatcga
+tcgccaatttttccagtcactgtaagtgtaggtttagataaagccgtatgagttatatca
+taagggcctcggaaagcagcttcgaaccaaagttcccttataatagtagtttaactataa
+aagtatatactggtctgtcgccctttcacgatttgttttaccggtttatgaagcgttacg
+tcattagagcggctccaatttaaggttaacggcttccatgtgtagttgtatacaaggata
+acttaaagtatctgttcagcgagctagttaagttatcctcgatagaacacaactcagagg
+tcccaagatcgggtttgcaacttgctaatttattctcaaggcaaattgggaattatcgat
+acctgtataccataaggtcgctcgatgtgatgcttatgtcttctggtgatcctaccttag
+ttagtgctgattaacggaacattaatgtttatcgttttgagatttagccaattctctgat
+tctaactcaagatgccttatctgacgtgctatgcagcccctaagtattttacattgtaat
+aggacacgctcctttaaaactcgccaaaaggtcgttgtggttctctactggttaactata
+taatttacagctttgttgagctagttcctctttggtttaagtcctcaatattagttggtt
+cgagcgataagttggctagttaccttagtcactatattagatccgaatgttatgcttcat
+ctgaagaccgccaccctccaaaatttcttttaagactcacttattgcaaggtgtaggtga
+attcggctcgtttctcaagtggtgtatctgtacacgagtttccatattttcatcaacagc
+caccgcacacttatgtcactctaggtattaaaagtcgctctacaaggggacgcaattaag
+aaacagacatgctagtcaaaaataaacatagcgaggcaccactaattcggccgcttatca
+atgggatgctctgcgcgagacgcgccagagctcagtagttagttcggacatacatttact
+tcagatgatcaattagttttctacaaatgcttactctaccccgaaaaaagtcaccagact
+cttacgtctctttagtatccttccgtcttatataaggtcagtcccccgtttcggtaccct
+ggaatttactaagaataatgaaacagcccccaaggacgtacgtttacaaatgatagacca
+gatcgcctagcttattccgacgcatgttgcatagaattgaaccaacggaatgtgagagta
+actagatgagccgaccacagcacccgtttgcgtcgcagaatacgcctgatagttcggcca
+cgaaatcatatgtcctttgagtattaagtatttgtaatgatcaatcgagctcaagcaagc
+ttacacttcctcggatattcagggaacttagtgcctttgaaagatacgttgatcaacgaa
+aaattgataatggctcatatggaatgcctacctcatagtgctgaattaacacagcactgc
+ggacctaacttttcgaggtttcaagttcacgtctcaaaacctaataggctggaatatgta
+gggatcctcggtgaatttgtgattgggtttgttgtagtactgaccaagtgaatattcttt
+ttttctaaaagcagatctgctgccgggcactacgaaggagatctctgtgtatcattattg
+cttcttgacatgatgactcttaaatcactgtgggtgtgcaaaacgatagcacaacccaat
+tcgatagtacatattgttgatacttcgcactaaaccgttcatatttaaaggttgtgctcc
+ttccttcgttaaatactggtgacttggtcctatctactattagctagacctctggggaac
+cacgcccccgtaaaacctgtgcaagagagggggtcatacatcttagacatcgcgcctcca
+ccagggaagcattgggtgattgaccaggtgtgtaacaaatatgattattcttatactaat
+attagcaaagatgcataatgatttgtattaaatgtataattgaattgataagggtctttt
+agtcagtgatagagtagtataaggtagacattagaactcttaaccggacgcagatttttc
+ggtcttagtaagccaattagtcgacaaaacaaggtaagagcggttactagtagtacctat
+aatgcactgaatcttcggtcgaagtatagttctaatgctatgcagattgtgacggcgaca
+aatgttcagacttatatcatgaaacaagctcttgtaagtattgacaaatgaaaagattga
+atatttttaaatacaaaatgcgcctacttattaggggaattaaccagattgaaggccaat
+cctcacatgtaatgagataatagacgataaatgaaattcttgtaatagttgaactgctac
+gtgatgggtattatatatgattgagatcctccaattgccgacgtcttgtcttgatgccca
+aaagattgtcaacgaggagctccctcgcgtacctgtcgtccgtatcataaacgacgcgac
+atgtacagcactccgaagtataagcaataataatgcgggtaatccagactagatcttttc
+ggactcaatgcggtttcacggtaaacatgattaataccggagagtagtcgagcttatcag
+cgatgcaagcgaattcattgtgccaggagatacgttgcagataaaaccggcaacgtatgt
+caacaagttttggcgatctcgttgtttgtattcgacgaggcgcgggaacttcaagaacta
+tcgtatattcaagtccattaccttttagtttcagactggtggagctgactaaagttatat
+catcattttgtacactggtttagttaacgataatttcagatttaacatgaccagacgata
+atcgctgtatatccagttggaatgtggtttgccagaaaggttaacttataatcaagcctc
+tcttcagtcttgattcgtcgtatcccatccattgcgctatacctcagtgtatttggagct
+gtagttataccgtgtgctaagatcagtagacatgacgagagcaatattatctaccttaca
+agcatcaacggacgtctagtcggaacaaaagactctaaaactcgaacttcaggttaatat
+actatagttctgtattcagcagttattcttatattcgatattatcttgcctattggatgt
+ctgactttagtatattaatcatagtatctgccatgtaaaggtgccagtactaaatctgtt
+tcacagtgcgaattataaacggttacaaccattaaagacaacaagaccctatagctttat
+ttgaattttgtcaatgcgcaacttggagctcgcgatacatcccaattagtctatagggtc
+gggacgattctacggcatttctggttataatgacaacatggattgtggcccgagaatcgc
+tctttcattaattaagcaatcattacagtcttataagcgctacttccgagtggtagcagg
+taactcgatataaggtcgcatgagccgaatagcttaaaaaacaggccaccgaacattgat
+agagaataccgaccacagcgcaacctttgattactttcattaaattgtacggctcactcg
+acatcaagcttaagattgcgataatgtgaactcaaatggatcagtactgaagaaccgtaa
+cccacttcgcagaaagcgtacccagagaagatacgctgttacaatatacagggtgaaatt
+attgcctgttcttcgtaaccatttcgccaaacttggttagaaatgatagccattcatgat
+agaaataagctgaatgataccagtatctttaactatgtagtcagggggaagataacgatg
+gtccatgtatgtttctgatatgtgacagtattggccgcgtaatttgctaacgaagctact
+taatgcctttgagcttcatatagatttctttaatcaaaatcggcaaaaagatagtatgag
+ctataatatatgctagtagagaactctggaccatcatctatatgaatactgattcgagcg
+tgcaattactttagcctgcgtactactgactctacaaaacactctgagataagtttgtag
+tcagtaagtcgctctctataaaccttttggatgaccattgtacagccacttatagatccc
+aataaatagcacaggagacagagtttttcaatgctcgatcatttgccgatagtattttcg
+tctaacctcagggcacctattatttgatacctaacctaacggccctttcacaatggagaa
+atatatgacatcgggacaaacacaaatggtgggtggccaggagatatgacatggtggcgt
+ctctaagaaacacggactccctctaggcaaactcacgtaaccaattttaatgtcaaacaa
+aacgctcgaaaagattttgccgtgtaatgacctggtacattgactggtcaggaatacatc
+actgtagttgccgtagtgtcctgttggtgttccatcaagacacatcgtataacgcaattt
+acgacggacatcagatcaagttatacagattatttaagtatcacgtgtgcattgggacat
+aagggatctcacacatgccttggaacatttttgctttgtgccgctttttcgctgcactac
+caatccttacttaccagtatattcaaaggtcgttaacagaatgagaaaggttagggctct
+aagttatcgtcgattgggatagacgagacatttgcgagcgccctccacggatacgaatct
+cccatatcaatgtgaactggatgctatgcagtttagttcttacgtctcctagtggtaaaa
+atcaaagtagcactcgcatagcagttattcagaacctaatacacaaaaccgtcaaacatt
+ttctaattctaggtatgggccgatcataggagctaaggtgaaactcataaatgttttgtt
+agatctagcatcctaaaaagatgcatatactgagtagctggcgtgcattctctcaattgt
+atcctttttaactgaactagtcggtcccatttcgtgactgagatctattaaccgataaga
+ttaataacactcgcattcgtatcagctcagagtgaagtttttcaataatttgactgatat
+attaacttctaaaataaccctttaagcctcggatccgtttcccaatcacatcaaaaattc
+ttattccaactatctacggattaacaacgtgcatggggatcgtagtaagaacttgttccg
+atcactttgagtatatcaagttgacggcccggttattattgaatagaaacattcacctgc
+taaattaaataccgcacatcggatacccgatttcagagggccgtcttactaagggcaggc
+tttgttcggtttaactgagatgttcattattttacagtatgcttcaactaatatgtaacg
+aaggacagtggatctgtctccatagtagatcttcagtcgtgaatttcataccgctcctat
+ttaagttcgcgttcgagttgttgatcatggcacgtgaaagcaacccctagtattctagac
+gaaaattttttctagttcatctgataatttgccaattcaaaaacaaccgctggtttcccg
+gcgcattctctaaaatggaagtcgaacctagagccattatttgtcggtaacccatgagtt
+ccttcttttcagaagttaatacactgtggtcctatacagaggaaaaacagcggttatata
+cgatcgtggcataacaacattggatcaagatagcaatttggctacctattctaattctca
+ctagattcggtattccactacaatatcggcagattaggattggatgaataatcggtgttt
+aagtccggttgcgtctccaatctcctaatttttattaatattgatcttggtgacctattg
+taaataaaaacttcaagactttgaataacggtgaaaagatagaagactcatttgaaaatg
+gatcatccacagatccaaacattagcaagacactaatccccaactagctattctgatcgc
+gatcgtgctgcagtactcctgtcacaatagtctgttcatgatctaattctttttgggctt
+tgttcgatggtgattcagaatctttatccggtcgcttccctgtagctactttgtggggat
+attgcccggggattatagggttgagatcgtttcctaaaagtatttaaaccaagtagactt
+caactaaactacatcagaacatcgtgaagacaccatacgcggtacctttatttaccgata
+acatttcttcaagaaataccggtaagcagcataatgaccctaaacagctcggggtatcgt
+cgtagttttaaattttatttaggttactgctcaaggaataaaaactaactatttaattta
+taataatattacaaggctcacactgattagatttgtctataagacttcgcgatcccccat
+taccggattgtcttaagaataaactagataaaccatgcattttctagataaggcctttag
+tctaattagatacaaaaaacacgatagttgcatccttaatttattgtgtcaaacctggaa
+ccttttaattacccgcaaatcactttatgtcgagactacctctgaaatttattatctacc
+taccgcatgaggacttgaaccatcttgtaggagttatgtttattagctaagattcgttta
+tcctgtagcggtccatgtatattcaacaagcaaaaagcactcagaattgtttttagttga
+gtcaagactgatatataaataagtttccctagttttttcgtggtgggacgatattgaatt
+gaatcttaaccgaagagtttcccactctgtcgcacaataatacacgccaatatttccagc
+cctgcttatgccttaatcggttactcaatctcccattgaagttcattttgatctgcatag
+aagtttcgggcccagccttttttctgccaccttcctccaagctctgtagacgcactctaa
+gattgatgctcacatgtattaattctacattaacataaatatataagtcatgcatcttcg
+agtaaaatatctggttctccaacatgtcctggcacgtatcgttataatgcccatacatgt
+agtattaaaatgattgggttaactggatattaagatcatcgaaattgtaaagtcaaatta
+acaatactgtctcaagaccgtgtattcctcgtgctcggaagggctattacgcttacttcc
+gttttggtatcttaatatgactttcaaaaattaagttgcagtgagtcctacctgcgtgca
+tcggttagcaagagtataaaagttgtttaaacgaactacttgctttacaataccggtcgt
+atatatcgccgtgaatccagaagattgtcttctttggattatcaaccgagatcctgtgga
+ccgatgttttgggaccttcacagaggactccaggtagagctcgcttttgcattaatctaa
+gaattgtacctctctaaaagatctaaaacagtgaatgtgtatttcatggaaaaacacaga
+gaaacgtaaattactttaggccgaaaggcacatgagttattatacatatacgagatggtg
+gtatacatcgaattcggggcatacactatagttgcattgtatttagctgctttaaataat
+atgatattaccttccttacataagacattaccggcataccctggttttcaacttgtgggg
+ctttttgacgatcgcactctcatttgatccgagtagggcggtgacccctgcttttcaaat
+acaaaaatttcgctatgaaggtaatagattacttttcgctgttatgatagaaacggtaaa
+tttaaaattgaaacttctagaaaagtaaagtaacgagaaatgattttgtgaataatgcgg
+tcatgattgcgcaagtaagaaaaaaaggcaaaaggatgcgcggaatagaaacttatcagt
+cacgggtatcttgatttcattcttcttgtcaattgccgacataggatgaaatcagattcc
+aatgcaatacacagtaacccccacccttgattgtaatgtcgatttgaagttgtacgcgtc
+gacgaagtggatagtatacgggccttttgtacggtgcgatcaactatgaatctcggcgag
+ttagatggtcgtacaatctcacacatagaggtcacttgcctgtaatgacgaattttcggc
+taggtactcgaactttattagaagtaaaaatgtgggcaaaagaaggattccattttacaa
+gacgattacaatgagttacatgtctctcaacgtagtctttccctagtagtctttgaacta
+tttaggtactccagaaaattttagcaaagggtttctgtgtgaatccgccattcatgttta
+tgatggaacaataagaataacgccctcgtatgttatcgacagtgaagtcagcagttcggc
+caaaaacatattcaatttagtacagatccccagaagttaagctaagtgctctaaaatggc
+ctaaacggttatcaaagtaggtctaattactatactaacgggtgcatcgtaataactgct
+gtcgatgcaacactatatgatagtgtcgttttgctatatatgtacaatgtgacaaagaag
+ccttagcgattcttgcaaacttaggacttcggattctcaatcttaaatgtccgaaaacgc
+aaagattcaaaaatttaatctatgagcagatatgcctgatggtgactacgcgtatgttaa
+ggctaaatgttgacaaccgcacacataatcgaactattgatagtcgggagcataaccagg
+tgaacgtactttgttcacgacatttattgacatgttctaaatacgtctcaaaatcacggc
+gcactagaaaacgcaatcaaatcattgtcctggtttaagggccgtaatgccggtagtgtc
+aaacttcatgagaactttagctggcttttggccagtatttagggaccaagagcactagcc
+ttaagctgaatattttgccatttatctactgttataactttaaaacttggtggcaccaga
+cttgtcgatacacacgcatcaatctgtaacgtaaaaggtttactaagaacaagcgtagga
+attgagtttatattatatttaaactaaaagatgatattagcttctgagggcgatagggct
+ccaaatcataaagaggaatatattattacacgattagaaacccacaacatacctcgaatc
+gcccaaaagtttgacgaaacttggcagtactccacatctcagtaatacagttgggagagt
+ctcaaatgttgttttattactcaatgaaccaccctcataatttcactgctgttccattaa
+atttgcaaacgatcatttgctttgaagaaacgtaaaatcgacaaaattacagataagtag
+atgcataataaaaaaaactgctcgctataacacgatcatcgtgcattcttacttaggagc
+atcacccgcacaataacgtaccttaaactacaacactattagaccgagtactgtaattca
+cgaaagctcaagctcgcattgtaaagaacttgctctctcgtaaaatgtgataatagtttg
+cggagaggattcaattattttccattgcacctactccactagattcgataaaagaaggtg
+gtcctcccttaaaaagaaatgttaagtaacatcggaaccataagcaaagcatgtaagtga
+accgtcatccttccctaagaaacataaaggtttttaataatgtcgactgtgaactataac
+tgcatcctttcctgacctactccggttccttgttgttatttctgaacgagaccagtagat
+aaacaatgtaaaccacagtgggtaccaatggtgcatgtgacgctaccgttgttttaagtg
+cccgtacaaacataagaagtcataatcttacttgaaattaattttgccttttattttttt
+tcaggctcgaaattaatgatttgttttttttgaccttctagttacgctaatatgcggtcg
+cctgtggtttctattgagtcctataacgggatgggatctaatacgtttggttactagtaa
+acaaggtataaatttgataccggagtatcaactgtataacatcaagctttatgactcata
+cgcgaagtaatgacacaaggctttcaggagatcgcgagtacagagccactaaggggtgta
+ttacgatagtgacaccaccgagcgcactcactccccaagtagatttatgatcctacgcta
+agtattagatatataaccaaagaggttctagtcagtgcaactcttagaataataattagc
+cggttttgcctttttaggcctaatgcaatattcagctagcccttatgtatctcgcgttcc
+acagcaccactcatggcacgcgtttaaactaatcaaatataatctatgaatgttatgcca
+gtacttgaataaatcaggttttttataagtccttgcatactctcgttatatactgttaga
+gtcttaccccatagaaattctttcatctgcaaacttagaagaattctcagctacggggag
+cataaagtccccaggatgttgacaaatacaacaaatgtggcttatacaaacactccatat
+gaaaatcgaaccctcgtggtagttttagccgaaccttgtacggataaatccctccatttt
+ccaatagcagatacctatcctactacctcgtggtattaaattaaagcttgaaatatagag
+ctgcatagcttatccaattcccaagcacgagtctaccgtcgtaaccacgatttgatttac
+agacgctagagcaaacccatctttaaacatataagtaaaaattaaagggtgagtgcgtac
+gtgtttactagcaacttcgcttattaagacaattgtttataagccataattaaaaacata
+tgttcaacaggttcattgatatttgtaattgcacaggtttttaataaggatctacgtaag
+tataatgaacaaactttttaccagagttatattctgtactttgaaaatgctcctctaccg
+ccttagagactttcaattagattttttgcagttaatctatgcgtaagtgaaccatgcaag
+ggatgcgattcaaccgcctcgtgctaaccctatcgtctgtctcataactgtaggtctaat
+ataattttcagttttcgaacacataaccctttgaaaatctgctatttaatgtctcacctg
+catgcactatcttctatactgctcagaacggctatacgtcactatgctccaagtgacgat
+ttaaacgaagcaaggaataataggtttattttagtgcaaaacaattaagtgcggactacg
+tgctctttacaataagccttgtgattgggctataggttaagtcccatattaacgatctcc
+aatgtacaaaatcgacaatcgctttgcattacccggttactagtcgaattacagatagct
+gttagatactcactctaattttggacaacaatcccaatcttggggtcgtctatcgcctga
+agctcgtaaatccttccatcttaaacgattacatattatagacttgttcggggtagagat
+atcacagttgtgcaaacattgtaaatcgatactagtttatgttggtagtctagttgcttt
+taccattccccgaaaaacttgatctactatttcgacaacagtaaacttgaactaggtaag
+tgaaaacagagaatgcctcatagtgccactatttgtccactatatgtaagtgtagcttta
+cataatccactatgactgagatcattacggcctaggaaagcagcgtagaaaaaaagggcc
+cggatattacgactgtaactataaaactagttactggtagcgcgccatgtatagatttgt
+tttaccggttgtggttgcgttaacgaatttcagccgcgaaaattgatccgttaaccagtc
+catctcgacttctataaaacgataaagtaaagttgatgttcagcctccttcttatggttg
+catcgagagtacactactcagtgggaaatagatcggggttcctacttcagattgtattat
+ctaggcaattgccgattgtgccatacctggataaaataagctacctacatgtgatgctta
+tctattatcgtcatactaccttagggtgtcctgttgaacgctacattaatctttagccgt
+ttgagatgttccaatggataggagtctaacgcatgatgaagtttaggaaggcagagcatc
+ccactaagtatgtgacagtgtatttcgaaacgagacgttataaatagaaaaaaggtcctt
+ctggttctattctgctgaactattgaatggaaagattggttgacctacgtactatttgct
+tgaagtcatcaatttgacggggtgagagacatatggtgcatactttacggactctatatt
+ttagatcagaagcttagcagtcttctctacaccccctcacgacataattgcttttaagaa
+tctatgtttgattcctctacgggaattcggatccgttcgcatgtgcggtttatctaaacc
+aggggacatatgttcagctaaagcatacgaacactttgctaactagacgtatgtatagta
+gctataaatcccgacgatatttacaaaaagaaatgagactcaaatatatacatagcgacc
+ctacacttattcgcaccctgatctaggcgatcctagcacccacacccgaaagtgagcact
+agtgtcttccgtattaaatttactgcagttgagattttagttgtctactaaggattactc
+taacccgtaataaggatcaagactcggtactagctttactatcattccctatgtgttttc
+ctaactcacaagggtacgtaccagcctatgtaattacaataatgataaagacacaaagga
+agtaactttacaaatgagtctccagttacactagcttagtccctcccatcttgctttgaa
+gtctaaatacgcaatctctgaggatatacagcagaagaacactcataacgttggagtcca
+agaattagactcatagggcccccaacatttaatatgtactgtgagtttgaaggtgttcta
+ttgttaattcctgctcttgatacatgacacgtactccgtgtttaaggcttcggactgact
+ttctttcataagttgagcaacgaaaatttcagaatcgataagttggattcactaactaat
+acggctgattgaaaactccactccggacctatatggtcgacctttatacgtaaccgatat
+aaaacttataggctggtatatcgagccttcctagcgcaatttcggatggggtttcttcta
+ctactcaacaacggaatagtctttgtttagtaaaccagagctcaggacgcccaatacgta
+ggagagcgctgtggagcatgtgtcattatggactggagcactcttaaatcactctgcgtg
+tgctaaacgatagatcataacatgtcctgagtaaattttcttgatacgtcgcaatatacc
+gttattagttaaacgttctcatccgtcatgcgtgaaatacggctgtcgtgctcagatata
+ctattagcgactcatctcgcctaacacgcacacgtataaactcggaatgactgccgctct
+tacatattagaaatacagactacaccacggaagcattgggtcattctcaaccgctgtata
+aaagatgattagtcttataataagattaccaaagaggcagaatcatgggtagtaaatcta
+ttattcaagtgattaccgtcgtgtaggcagggagtgaggacgagatggtactcaggacaa
+atattaaccggacgaagtggtttacgtcgtactttcactattagtagtaaatacaaggta
+acaccggggaatagtactaaatataatgatatctatcttcgggagaacgagtcgtctatt
+gctttgaacattctcaaggcgtaaaatgtgctgacttatagcatgatacaaccgattgtt
+acttttgtctattcaaaagattgaatagttttttatacaaaagccgcatacttatgacgg
+ctagtatacagtttcatcccctagcatcaatgctatggacagtattgaacttataggaaa
+ttcttctaatagggcaaatccgtcgtgatgcctattttttttcagtcacatcctcaaatg
+gcactagtattgtcgggatcccattaacaggctcaaccacgagctcacgcgaggacatgt
+agtccgtatctttaacgaagcgacagcgacagaactcccatggataaccaattataaggc
+ccgtaatcctctagacatcgtttaccaataaatccgctttctccgtaatcatgttgaata
+ccccagagtagtccagatgataaccgatgaaacacaagtctttctcaatgcacttacggt
+gaacttattaccgccaacgtagctcatcaaggttgcgacatctagttgtgtgtttgcgac
+gagcccagcgaacttcatcaactttcgtatattcaacgccttgtaattttactttaagac
+gcctggtgatgtagattcttagataatcagtttgttatcggctgtactttaccataattt
+cacaggtttcaggtcaagaagattatagctgtatatacagttccatgctcggtgcacaga
+aacgtgatcggataataatcaatcgcttatgtcgtctttaggcgtatccaatacatgccc
+cgataccgcagtgtatttcgacatgtaggtataccgtcgcatttgagctcgagtcaggac
+gtcagctagattagattccttaatagaatataccgacctctagtccgaactaaactatag
+ataacgccaacttcaggttaattgtctagtcgtctgtttgcagatgggattcttagatga
+gtgagtatcggccatattggttcgagcactttagtttttgatgcataggatatgcaatgt
+atagctgaaagtactttatctgtttcaaactcacattgattaaaccggtaaacctttaaa
+gactacaagaaaatattcagtgagggcaattttgtcaatcacaatcttccagctagagat
+acttcacaatttgtcttgaggctacgcaacattagacggattttcgcgttttattgaaat
+aatcgaggggcccaagagtatccatagttcattttgtaagatttctttacaggcttatta
+cagcttcttcagactcctacatgcttacgagttatatgctagcatgtgaacaatagatta
+atatacaggaaaacgtacattgagagagatgaccctacacagcgcaaccgttgagtactt
+tcattaaagggtaacgctctcgagacagcatccttaagatggccttattgtcaaatcatt
+tgcagaagtacgcaagatccctaaccaacgtagaagaatccctacaaacacatgagacgc
+ggtgaaaatagacagggtgttagtattcaatcttcggagtatcaatttcgccaatcttgg
+tgagaaagcataccctttcttcagagaaagaagatcaatcataacactatctttaacgag
+gtacgcacgcgcatcattacctgcctccatggatctttaggatagcggaaagtattggca
+gcgtattgtgatttcgttcctactttatcaatttcacattcatatacatgtcttttatca
+aaatcgccaataagataggatgagctatattagatgctagtagagttcgcgccaacatca
+tcgataggaatactcaggacagcgtgataggacttttcaatccctaatactctctataat
+tataactctctcttaagtttggaggcagtaacgcgctctatataatcagtttgctgcacc
+attcttcagcctctgatacatacaaataaattccacagcagtaagagggtttaattgaga
+catcttgggaacttaggattttactctaacatcaccgaaacgattattggataccgtacc
+taaacgaactttctcaaggcagtaatataggacatccgcaataacacaaatgctgcctcc
+ccaggagttatgtcttcctggaggctatatcttacacccactcactataggcaaactaaa
+gtttaaatgttgattgtctaaaaaaaagatagataagagttggccggcgtagcacatgcg
+aaagtgaatcgtaagctataattctctggacttgaagttctgtcctgttcctctgcaaga
+aacaaacttcctttaaagctatttacgacgcacatctcagcaagttataaacatgttgga
+agtttctagtcggaattcccaaagaacggatctatctaatgcattcctacatttttcctg
+tctgccgatggtgccatcctattcaaagaatttcttaaaagtagattaaatgggactttt
+aacaatgagtaaccttacgcctctaagggttcctcgagtgccatacaccagtcaggtccg
+agccacatacacggagaacattctaacatagcattctcaactcgatcatttgcaggttac
+ttctttcctatcctagtgctaaaaatcatacttgcaatcccatagcacggattaagaacc
+taagaaacaattcagtaaaacatgttcgaattcttggtatgggaacatcattgcagctat
+ggtctaacgcattaatgtttgggtacatcttccatcatataaacaggaagagtctgacga
+cagggagtgcttgcgatcatgtctatcattgtgaaatcaaattgtagctcacatgtcgtc
+tatgagagcgtgtatccgataagatttagaaaaatagaagtcgtataagatctcactgaa
+cttttgaatgaatgtgaagcatatatgatctgctttaataaaactttatccataggatac
+gtttccaaatcaattcaataattattagtcaaaatagataaggatgaacaacctgaaggc
+cgatcggacgtagaaagtggtcccatcactttgagttgatattgttgaaccacacgttat
+tatggttttcaaacagtctcaggatattgtatatacagataatccgataccagttgtctg
+acgcccctcttacgtaccccaccctttgtgacgtttaaagcagttgttcagtattttaaa
+ctaggcggcaactaatttggaaagaagcacagtggatatgtctaaattcttgttattcag
+gcctgaatttaatacaccgcatagttaacttcgcggtagagttgttcatcatgcctcctc
+taagctaccacttctatgatacaccaatagttgttctacggaatctgataattggccaag
+tcataaacttccgctgcgttcaacccccttgctcgaatatccaactcgaaaagacagcct
+tttggtgtccggaacaaatcagttacttcttttctgatgttaattctctgtggtcagata
+cagaccaaaaactccgcggatttaccatcctccaagaacaaatttgcatcaacatagcat
+tttggctacatattctaagtctcaatagtttaggttttcaactacattatcccaacatta
+ggattggaggaataatagctgggtaagtccccttgcgtctacaatcgactattttttatg
+aatatgcttctgccgcacctatggttattaaaaaagtcatgactttgaagaaccctgaaa
+agatagatgaatcaggtgtaatggcagcagccaaagagcatataattagcaacactctaa
+gaacattatagatatgatgatagcgatcgtcatgatgttatccggtcacaatagtagctt
+catcagctaattcgttttgccagtggtgacttgcgctggaagaatcgttatacggtccct
+tccctcttgatacggtgggggcttattcaaccgcgtggattgggttgtcatacttgcatt
+aaacgatgtaaaccatctagtagtcaactatactaaatcacaaaatagtgatcaatacat
+acccgcttcatggttttaaccatttaattgattaaagatattccgctaagaaccattatc
+tacctaaactgatcgccgtatcctagtagtttgaaatttgatgtaccgtaatgatcaacg
+aagtaaaacgttatattgtatgtagaataataggtcttggagctaaatgatgtgattggt
+agtgaagacttacccttacaactttaccggtttctcggaagaatatactagagaatcaat
+gcatgggctacataagcactttagtctaatgagataaaaaatacacgagtcttccatcat
+gaattttttgtcgaaaaactcgaacctggtaatttaaaccatatatctttatgtcgtcaa
+taactctcatatgttttatataacttcccaatcacgacttgtaactgcttgttcgactga
+gctgtttgagctatgaggccgggatccggttgagctacatctatttgctacaagaaaaat
+gaaagcacatttgttgggagttctggctacactcatagagaaataagtggcccgagtggg
+tgcggcctgcctccatattcaagtgtatcttaaaccaagtggttccaacgctcgcgctaa
+agaattaaagcctttatttcctccacggagtagcccgtaatccggttcgaaagagaccat
+tgaagttaattttcatatccagtgaagtttaggcacaagcatgtgttctgccacatgcct
+caaagcgctcttcaaccaagatatgattcatcctaacttcgatgaatgcgtctgtaacat
+aaatatagaaggaatgattcggcgagttaattttcgccttctccaacatggcatccctac
+gttcgttataaggaccatacatgtaggttttaaaggtttgcggttaatcgatatttacat
+catagaaattctatagtcaaatttacaagactctagatactcactcgttgcagccggcta
+ggaagcgctttgtaccttacttcccttttcgttgcgtaatatgaatttcatatagtaagt
+tcaaggcactcatacctccgtgaagagggtagatagactattaaagttgtttaatagtac
+gtattgatggaaatgacccgtaggagatttaccactcaatccacaagattcgctgctgtg
+cattatcaaaacagtgcatgtcgaaacatgggttgggtccttcaaacacgaatccaggta
+gagatacctttgcaatttttcgatgaaggcgaccgagataaatgagctataacactgtat
+gtcttttgattgctataaaacacagaaacggatattaatttaggccgtaaccaacatctg
+ttatttgacatagaacagatggtcctttacagcgtattccggccttaatattgaggtcca
+gtgtattgtcctcctttaaagaagttgattgtaactgacttaaataagacatgtcaccca
+ttcactgggttgcaactgctggccctttttgtccatcgcacgctaatgtgataacagtac
+cgccctcacacctgcgtttaaaagacataaatgtcgctatgaaggttattcattaatttt
+agctgttttcttagaaaaggtaaatttaaaattgaaaaggctagaaaactaaagttacga
+caaatgtgtttgtcaagtaggcgggcatcattgagattgtaagaaataaagccataacca
+gccccggaatagaaaatgttaaggaaaggcgatcttctttgaattcttattgtcaagtgc
+agtcatacgttcttatcagaggacattgcaataaaatctaacaccctcccttgtgtggtt
+gggccatttgtacttcgaagcgtccaccatgtgcagaggataacggaatgtggttccgtc
+ccataaacgatcattctcgcccacttagtggcgcggtaaatcgctctcatagaggtaact
+ggcctgtaatgtccaatgttaggctaccttctccaactttagtacaacgaataatgtccg
+attaacaaggagtcaatttgtcatgaccagttcattcaggtacttgtatctatacggacg
+cgttccagagtagtatttgaaattttgaggttctactgataagtttagctatcgctgtat
+gtctgaataagaatttaatgtttatcttcgataaataacaattaacaactcctaggtgat
+acactgtgaagtctgctgttccccaaattacatatgctattttgttcacataccatgaag
+ttaagctaagtgctctataatggcataaacggttatcaaactagctcgaatttcttttat
+tacgccggaagcggattaactgctgtagatcaaacacgttaggatagtgtcgttttcata
+tatatctaaattcggtctaacatgcattacccatgcttgataacgtagcacttcgcagtc
+taattatgtaatgtccgtttaaccaaactttaaaaaagtttatctatcaccagtgatgcc
+tcatcgtgactacccggatctttagcctttagggtctaaacagaactaatattactacgt
+gtcatactccggagcttaaccaggtgaaacttatttgttaaccaaatttagtgacagggt
+agaaatacgtatcaaattaacccagcaatacaataagcatgaaaataattgtaatcgggt
+ttgggccggaatcccgcttggcgaaaacttaatgacatagtgtgatgcattttgcactgg
+attgagccacaaactcaactagcattatgctcaatatttggccagtgttctacggtttga
+aatttataaaggccgcgcaaaagtcttgtagttacaaacgcataaatctcgaacgtaata
+ggtttaattagaacatccgtaggatttctgtttatagtagatttatactaaatgttctga
+ttagattctgacggccttacccatacaattaataaagacgaatatattagttatagttta
+ctatccaaataaattaagcgaatcgaaataaactgtcacgatactgggcagttatcaact
+tatcacttatacagttcggacactctatattggtctgtgagtactctatcaaactaactc
+ataagttaactgcgcttccattaaatttcaatacgttcttgtgctgtgtacaaacctata
+atcgaataaatgacacatatggagatgcataataaaaaaaacggctccatatttctcgtt
+aatcgggcattcttaaggaggagcatctcaccaaaaataacgttcctgataagtcttaac
+tattagaccgtcttcgggaatgaacgaaacctcaagctagcatggtatagttcttgatag
+cgcgtaaattctgataatactgggcggacagctggaaattagttgccagtgcacctacgc
+aaatagtttacataaatcaacgggctccgaacgtaaatacaaagggttagttacatcgca
+acaagatgaaaagcatgtatgtctaccgtcatccgtccctaacaaacataaaggtggtga
+agaatctcgtaggtcaactataactccatccttgaagcaactactccgcgtccgtgtgcg
+tagttcgcaacgagaacactactgaaaaaagctaaacaactctcggtacaaatgcggctt
+gtgtcgataaagttggtggtagtgcacggaataacataacaaggaatattatttattcaa
+attttttgtgactgttatttgttttctgcctagaatgtaaggatgtgttttttgtgacct
+gatagttacgcttatttcaggtccacggtgcgtgagagtgtgtcctataacggcagggga
+gcgaagtagtgtcctttagactattcaaggtagaattttgataacgctctataaaaggta
+gaaaatcatgattgagcaataagaccccaacttatcaaaaaaggagttctcgacagcgcg
+tgtacagtccctataacggctgtatttcctgtgtcacaacaccctcccatcgcactcaaa
+atgtagatttatgatcagacgctaacttgttcttagagaaaaatacacgggatactctgt
+gcaacgatttcattaataaggtgcagcttgggacttttttggccgtaggctttattaaca
+ttcacagtaggtagcgagacttcctatgaaccaatcatgccacgcgttttaacgtttcaa
+atataagctaggaagcgtttgccaggacttctataatgcaccgttttttttagtacttcc
+ttactagccttagtttatgttagagtctttccaattacaaaggattgaatagccaaaatt
+tctacaattctcagcgaacgccagcttaatctaaacacgagcttcaaatattctacatat
+cggcaggagtcaatatataaatatgaaaatcgtaccatcctcgtacttttagaccaaacg
+tcttcggataattaaatcctttttcaattaccacagtacgtgcattagaactactgctat
+gaaagtaaaccttgaaatatagtcctcaagagcgtatccaagtacattgcacgtgtatac
+agtcgtataaacgagttgatgttctgacgctagagcttaccattcgttaaacagataact
+aaaatttaatggctgagtgacttagtgttttcgacaaacgtcgcggatgtagactattgt
+ttataagcaatttttaaaaacatatgttcaaaacggtatgggatatgtcgaattccacag
+gggtttatgtaccatagaagtatgtataaggtactaaaggtttaaatctgtgatattcgg
+ttcggtgaaaatcagactagtcacacttagtgtctgtaaattagattgggtgaaggtaag
+cgatcccgaactctacaaggcatgggatgagattctaccgactccggataacactttacg
+atcgcgcataactctagctcttagataagtttaacttgtcgatctcataaacagttcaaa
+atctgcgatttattgtatcaaatccatcctctatcttctataatcatctgaaccgcgata
+cggcactatgagccaagtgaagattgaatccaagaaagctataattggtttattttagtc
+catttaaattaagtccggtataagtgctctgtacaatatgcagtctcatgggcatatacg
+ttaactaccttttgatacttcgaattggtaaaatatcgactatcgatttgcagtaaaagg
+tgtagagtccaattactctttcctgttacatacgatctcttagtttggacaactagccca
+tgatggcgctcctctagcgcatgaacctactttataattacatctttatcgatgaatttt
+tttagactgcggaggccttgagttttaacagggctgctaaatttcttaagcgattagacg
+gtagcgtcgtacgctacttgcttggaacaggcaccgaaaatattgatctactattgcgtc
+aactctattctgctaatagcgatggcaaatcacagaagccctcttagtgacaatagttgt
+caactatatctaagtcgacctttactgtatcaacgatcacggagagaattaccgaatacg
+aaacctcaggactaaaaaacggaaaggatttgtcgacggtaaatataatacttgttaagg
+gtagcgacacaggtatactttgggtgtaaacgtggtgcttcccggaacgattttcagacc
+agaaaattgttccggtaaccaggaaatctcgtctgcgttaattcgtgttagtaaacttga
+tcttcagactccttcttttcgttgcagcgagacttaaattatatctgcgaaatagtgccc
+cgtgcatacttcagatggtaggagataccatttggcccattgtgactttacgcgattaat
+taaccgacatacatctgttcctgagctatgatcgtctgaataaattacggtctcctcttg
+atacctaatggtttctggagacgtttctcatgttcaaatggatagcaggagatcgcttca
+tcaagtttagctacgcagagcatcaaaatatgtatgggaaagtcgatttccaaaccagaa
+gggataaagagaaataacggacttctccgtagattagcctgatattttgatgggaatcat
+ggcggcacatacgtaagagttgcgtgaacgaatattttggacggcgggagacacatatcg
+gccattcgttaaggtctctatattggacatcacaagcttagcagtatgagctactaacac
+tcaagacattattgattttttcaagatatgtttcattcctctaccgctattcccatacgt
+tcgattcgccgggtgagcgaaaccacgggactgaggttaagctaatcaataacaactcgt
+tgcgatagagacctatgtatactagagagaattccccaacatttttacaaaaacaaagca
+gactaaaatagatacagtccctccatacaattaggaccaacatgttattgccgatcctag
+cacacacaccacaaactcagaacttctgtcttacctatgaaagggtctgcacttctgatt
+gtacgtgtctaattagcattaatattaaaactaattaggataaactataggtacgagctt
+tactataagtcactaggtgttttccgatcgaaaaacgggaccttcaagccttggtaagta
+catttaggataaagaaaaaaaggaaggtacgtgactaatctgtctaaactgacaatagag
+tagtacctacatgcttcatgtcaagtcttaatacgcaagcgctctcgttatactgctcaa
+caaaactcataaagttggactccatcatttagaatcatagggaccaaaacatttatttgc
+tactgtcactttgtaggtgttctattctgaattcctcatattgatacatgaatcggaata
+cctgtggatcccttaggacgcacgtgctttctttacgtcagaatacatattgtcagaatc
+gagaagttccatgcaattaagaattcgcctctttgaaaactcatatccccacatataggg
+tccaccgttattcggaaacgatataataattattccagcgttgagcgtcccttaagagcg
+cattttcgcttggcctttcttctacgactctacaacgcaagtggctgtgtggagtttacc
+acagcgcagcaccccatagaactacctctgagagcgcgagatggtggcagtatgctctgc
+agctagcgtttagaacgcgcccgcgcattaaccagtcatattaaaatggactgtcttaat
+tgtcggcattaggagcaatattaactgatgagggtatcggtcgcagaagtaatgacggaa
+atacgcctctagtccgcagagatacgattacagactcagatcccctaacaagcaaaacga
+ttaaatcggaatcactccccctatgacatatttgaaatacacaagaaaccacgcaacatg
+tcccgcattctcaaccgcgctttataagatgttgagtctgagaattagatgacctaactg
+caagaatcatggcgagtttatctagtaggcaagtctgtaccctagggttcgaacgctgtg
+acgtcgtgatcggtctaaggacttagatgataaccaagaactggtttaccgagtactttc
+actattaggagtaattacatgcgttcaccgcggaatacgacgaaattttttcatatcttt
+atgagcgagatcgtgtcgtctttgcattgcaacagtcgctaccagtaattgctgatcaat
+tatagattcattatacagatgcttacttttctctattcaatactgtcatgagttgttttt
+aaataagcaccagaattatgtcgcctagtataatcttgcttccacttgaatcaatgcgat
+ggacagtattctactgattgcaaagtagtctatttcggcttagcagtacgcatgcctatt
+tttttgcaggcacagaataatatgcaactaggattctcggcatccaattaacaggctaaa
+acaccaccgaaagacaggtaatctacgaagttgatgtttactacagaaagcgaatgatat
+cacttggagaacattttagatgcccccttttaatctagactgagtgtaccaatatatcac
+cggtctaccgaatcagcttgaataaaccactctagtactcatgataaccgagcatacaca
+tgtatttctcaatgcactgaaggtgaactgtttacaccataccttgcgaatcaacgtggc
+gacttatacttctgtctttgagtacagcacaccctaatgaatctaagttagttgttgata
+cgaattgtaatttgactggatctcgcctcctcatctagattcttagagaagatgtttctt
+atagccggtactgtaactttattgatctggtttatggtaatcaacattttacctctattt
+aaacgtccttgcgccgtgcactcaatcctgatcggtttagattcaagcgattatcgagtc
+tggaggccgagaaaagaaatgcacagagtaagctctctattgcgacatctacgtagaaac
+tcgcatttcagatcgagtaagcaactctcattgtgttgattcagtaatacaagattacct
+acgcttctacgaaatatactatagatttagcctacgtcacctttagtgtcgagtcggagc
+tttgaagatcggatgcggtgtggactgtgtataggcaattttgctgcgagctcgtgactt
+ttggttgatgtcgatatcaatgggatacctcaaacgtctttatctctggataactcacat
+tgagtataccggtaaaaatttattctattcatctaaatagtcagtgagggctagggtcgc
+aatcacattaggccacatacacatacttaacatgttctattgacccgacccaactttagt
+agcattgtagccgtttatgcaaatatgccaggcgccaaacactagccagagggcattttg
+ttacatttatttaatcgattattacacagtcggaacacgcctacatgcgttcgacttatt
+tgcgacatggtcaacaattcagtaatttaatccaaaacctaaagtcagagacatgacact
+aaaatcacattaaggtcagttagtgaaggaatggctaaccagctagagaatgcatcatta
+acaggcacttattgtcaaatattttccagatctaagcaacatcacgttaaaaagtacaac
+aatcacttaaaacacatcagtccaggtgtaattagaaagccgcttagtaggcaagcgtag
+gagtataaatgtagacaatagtcgggacttagcagacactggatgcagtcatagaagatc
+ttgcataacacgttagggttagagctacgaacgcccatcattaactgcctaaagcgtgcg
+tgagcttagcgctaacttttccaacacgtttgtgatttcgttcataatgtatcaatttca
+cagtcatatacagggagtgtagaaaaatcgcaattaacatacgttgacctatttttgttc
+agagttcagttagagcctaatgattcgagagcaataatcaggacagcctcataggaagtg
+tcaatcacttagaagctatattattataaatcgctctttactgtcgtcgaaggaacgagc
+gagagagaatcagttgcctgcaactggcttaacaatatgatacataaaaatattttcatc
+accactaagacggtggaattcagacttattggcaacttaggatgggactattaaataacc
+cataagatgttgggataaagttacgaaacgaaagggatatagcctgttagataggaaatc
+cccaataaaacatagccggcctccacagcagtgatctattccgccacgcgatatctttat
+accacgcaatataccaataataaaggttaaatgtggttgcgatttaaaaaagatacatat
+cagttgcaccgcgtagcaaatccgtatgtgaagcgtaacctagaattatagcgtctgcaa
+gttctctaagcttcctctgcaagatacaatatgactttttagcttttttactaccaaatc
+tcagaatcttagaaacaggttggtacgtgctactcggaattcccaaagtaccctgctata
+tatgccattccttcattggtccgggctcaccatggggccatcatagtaatagaaggtagt
+aaaactagttgatttccgacttttaacaatcactatcctgacccagatatgggttccgac
+tggcccttactccagtaagggcagacacacagacaacgagaacttgataactttgaattc
+tcaaatcgatcattgcaacgtgacttatttactagcctactcctataattcatacgtcaa
+atacatttcaacggaggaagataataagtaaatattcactaaataatggtcgaaggagtc
+ctttgccaacataagtccacatatgcgctatagattttttcttggggttcatattcaata
+agataaacagcaagagtatcacgtcagcgagtcattgagatcttggctagcattgtgata
+gcatattctacctaaatggtagtctagcacagagtggataagatatcagttagatataga
+caagtactataacagatctcgcttcgttggattgtatggctagctttgatgatatgattt
+tataaaaattgatccagacctgacctggccaattatattcattttttatgagtaaaaata
+gataaccatgaaaatactcaagccccttaggacgtacaaagtggtaacataaatttcagg
+tgttattctgcaaccacacctgttttgggttttcaaaaaggctaagcagattggttttac
+agataatccctgaacactggtatctcccaacgatgtcgttcccaacccttgctgaccttt
+taagctctgctgaagttttgtaaactaggcggaaaatatgttcgatagatccactcgcct
+gaggtagaaattcgtcttagtaacgcctctttggattacacagaatagtgtactgacacg
+tacactgctgcagcagccatacgctaacattaaaattcgttgagtctacatttgttgtta
+ttcggattatgttattgggaatagtatttttattcccctgcgtgaaaccacatggataga
+ttagcctactcctaaagactcccttttggtctacggttcaattctcttactgagtttatg
+ttcgtaattatatcggcgcagtgaatctcctaattatcaccggagttaccagacgccatg
+aacttatggccagaaacattgcatgtggcctacataggattagtatcaagagtttacgtt
+tgcaacgacatttgaccaacttgaccattcctgcttgtagaccgcgggaactcccctgca
+cgcgactatagaagttggtggtggatgtggcttatgccgcaaatatggttttgaaaaaag
+taatctattgcttgatacctgaattgagacatgtataagggctattgccagatgaaaaac
+tgcatataaggtcaaacaatataagaacattatacataggatcttagcgttcctcaggat
+ggtatacgctataaagtctagcttcagcagctaaggagttttgccagtgcggacttccgc
+tggaagattaggtttaaccgccctgacatcttcataaggtcgggcctgattcaaacccct
+ggagtgccgtctcatacttgaattaatcgatggaaaacttcttctagtctaatattatta
+ttaacaaatgacggttcaataaataacaccgtaagggtgggaaactgttaagtgatgaat
+cattttaacctatcatccattagctacagataatgataccccgatccgactagggggtaa
+gtggttgttccgttaggataaaccatgtaaaacgttagagggtttgtagattaattggta
+ttccagataaatgaggtcagggcgagtgatcaattacactgaaaaattgtcagcttgcgc
+ggtagttgttaagacagtataaatgaaggggattcagaagcaagtttctcgattgactga
+atttataaaccagtcgtcaatcatgatttttgtgtcgattaaagcctaaatggtaattta
+aaccattgatatttatcgagtctataaatatctttggttgtatattacttcacaatcacc
+aattctaaatgattcttccactgtgcgggtggagatatcaggacgggttaaggttgacct
+acatcgttttgatacaacaaaaatcaaagcacatggctggggacttctcgatactatctt
+tgagatagtacgggcaagagtgggtgacgcctccctacattttcaagtctatcggataac
+ttctcggtaaaacgctcgcgatatagttttaaagcattgatttaatccacgcaggagcaa
+gttttaccggtcgaatgagaaaattcaacgtaagtgtcatatccagtcatggttagccaa
+aagcatgggttatccaaaaggaataaaacagctcttcaacaaagagatgaggcttcataa
+cttcgatgaatgcgtatggttctgatatatagatcgatgcatgaggacactttattttag
+ccggcgaattaatggaatccatacgttacttatttggacatgacttctaggtgtttttgc
+tgtcccgtttagcgatatttacagattagtatttcgtttctcatagttaattgtatctag
+atactaactcgttgaagacgcataccttgccatttgtacaggacttaactgttccgtgcg
+taatttgaatttcttataggttcttcaaggcacgaatacctcactcatgaccgttcatac
+tctagttaaggtcgggaatactacgtatgcagggaattgtaacctaggagatttacaact
+ctttaaacaagagtcgctgaggtccaggatcaaaacactgaatctcctaacttcgggtgc
+ctccgtaaatcacctagaaacctactcatacatttgcaattttgagatgtaggcgaaaga
+gagaaatctgctttttaacggtatctcttgggattccttttaaaaacacataacgatagt
+aatgtaccaagtaaccaaaagctgggatgtgtctgtgtactgatccgccgtgtcagagta
+gtccgccatgaatattgacgtcaaggctagtgtcatcaggtattgatgttcattgtaaat
+gaaggaatgaactaatgtcaccaagtaaagggggtgaaaatgctccccagggttctacag
+acatagagatggtcagaacacgacccccctctcaacgcagtgtatttgaaatatatggac
+atatctaccttattctgtaattttagatgtgttctgtgtataccgatattgataagtcaa
+taggcttgattacgtatcttaagacaaatctgtttcgcaagtaggaccgcatctttcaga
+ttgtttctttttatgccataacctgcccaggaattcaaaaggttatcgatacccgatatg
+ctgtgaattattattctaatggccactcattcctgcttatatctggaattggcatgaata
+tcttacaacctaaagtctggcgttgcgccagttctacttcgtaccggacaccatctccag
+tcgttaaccgaaggtgggtacgtcacataaaagttcattagaccacactttgtgccgacg
+tatatagatatattacacgtatagggaatgttttctcctaggtgacccgaccttctacta
+aggttgtacatcgtataatggcccattaactacgaggaaagtggtattgacctggtaatg
+cacgttcttcgatatataccgacgaggtaaagtctactattgcaaagtttgacgttatac
+tgataagtttagatttccctggatcgcgcatgaacaatgtatgcgttatctgccatatat
+aacatgttacaaatccttggggatactatcgctactatcatcggaccaaaattaaatagg
+ctagtgtcttatcagaacatcatgtttaccgaactgatctattttccaatttaagctgat
+attacgtccgcgtatttattttagttccccggatgacgattatctgagctacatcataca
+agttagcatactcgccggtgcattgatttcttatttcgctatatcttcaagttcacaggc
+ttcatatagttccaattagcagtataattaggttttgtaactttaaccatactttataaa
+aggttatattgcacaactgatcaagcatccgctataacccgagctttaccagttagcggc
+taataacaaataagatgacttcgtgtcatacgaccgtcatgatcatgctctaacttaggt
+gggaaccaaatttaggcaatgggtagtaataagtataaaatgataccacatatactataa
+caatgaaattatttgtaatccggtttgccaacgtatcccccttcgcgataaattaatgac
+atagggtcatccatgtgccaatcgtgtgtgccaaaatctcaaattcaattatcatcaata
+ttggccaagtgttataagcgttgaaagtgatataggccgccaaaaagtagtctacttaaa
+aaccaatatttatcgttcgttattgctggtagtacaacatcacgagcatttctcttttga
+gttgatttatactatatctgctgatgtgattatgtcccacttacccagaatattaagaaa
+gtcctagattgtaggtatacttgactataaatataatttaagactatacaaataatctgg
+ctacattatgccatcgtagaaactgataacgtagtaacgtcggacactagattttggtcg
+gggagtaatctagcatactaacgaatttgttaaatccgctgaaagtatatgtcattacct
+gcttggcctgtcttcaatacgtttagactattaaggactcatttcgagatccagtattaa
+ttatacgcatccatatttatactgaagacggattgagttaggacgacaagctaaacaaat
+attaagttaaggattagtattatattgtagaaactcgtcgggttggaacgattcatcatc
+atagaatgcgttacttattcagagagacttaattcggttatgactggcagctcacctgga
+aagtaggtgaaaggcaacagaagaatattgttgactgaattctacgggctacgaacgtaa
+ttacaaagcggttcgtaaagagcataaagatcaatacaatggatctctacagtattacgt
+aaataacatacataaacctggtgttgattcgactagctcatagattaatcattaattgaa
+gctacgaagacgcggaagtctgcggagtgagcaaacagtaatcgactgataaatgcttat
+aatatcgcgcttaaatgccgcatggtgtacattaacgtgggggtagtcaaaggaatatat
+ttactaggaatattagttatgcaaatgttgtgtcaatgtgatgtgttttatccagacatt
+ggatgcatggctgtgggggcacaggatacttaccattagttcacctacaagcggcgtgag
+agggtctcagttttagccagcgcagagaagtacgggcctttagacgattaatgctagaat
+tgtcataaacctcgtgaaaagctagttaataatcatggtgctagaagaacacaacttttc
+tataaaccagttctcgactgacagtcgtaactcactatatcgccgctttgtactgtcgca
+aaaaaacctcacatagaaagaaaaatctactgggtgcatcagtagagatcgtgttctgag
+agataaatacaccggatacgatctgcatcgagttcatgtattaggtcaagcttgggactg
+ttgtgccagtagcattttttaacagtcaaagtagggtgagacacgtcatatcataatata
+tgccatcgaggtttaaagtttatatgataagctagcatgcgttgcaatcgtattcttgaa
+tgctccgtggtttgtactaattcctttatagactgagtgtatcgtacactcggtacaatt
+acaaaggatggaagagcaaataggtcttcaattataacagtaccccaccttaatctaaaa
+accagcttcaattagtattaatttcgccaggagtatatatataaatatctaaagactaaa
+agactcgtacttttacaacttacgtcgtagcataattaaatcatgggtaaatgtcatcag
+taagtgcattagaaatactcctttgtaaggatacagtgaatgtgtctcagcaagtcagta
+gaaatggaaattcatactcgattaaggcctataaaactgttgttggtatctacagagtga
+ttaaaattagtgaatcagattacgaaaatgttttcccgctcgcacttacgcgtttagaca
+aaagtacaggtggtacaattggctgtagtagaattttggtataaaataggtgataaaccg
+gatgggtgtgggcgaattcaaaagcggtttttgttccatagaactatgtagttggttata
+aaggttgtaatctcggagattaggttagggcttaatcagaatagtaacaatttctctatg
+taaagtacagtgggtgatcgtatgagttcacgaactcttaatgccatgcctggacaggat
+aaacaatacgcatataacttgacgatcgagcttatatcgacctatttgagaagtttaacg
+ggtcgatataatatacaggtcttaatagccgattttttctagaaaagcaatcctatatct
+tagttaatcagatcaaccccgtgaacgatatatcagcaaactgaacattgtatacaacat
+tcctttttgtccgggtggggactccatttaaagtatctcacctagaactcagcggtaata
+gatgcagtctcttgcccagttacggtaactaaatgttgatacttagaattgctaaatttt
+agtctagacatttccaggtaaaccggtagacgacaatttctctgtcatctgtcataagat
+cgcttagtgtgctcaaattgcaattgagggccctactatagacaatcatcagacttttta
+attaaatagttttccatgaatgtgttgtcaaggcggaccccttcacttttatcacggctc
+ataaatgtcgtatgactgtagtcggtagcggccttcgagtcttcaggggaaatggaaaag
+aaattaggcttctaagatggactataatcgattaggctaattccgttcgcaaatcacaga
+agcaatcttactcaaaattgttggaatcgatagcgaacgcgaccgtgaatgtttaaaagt
+gctcgcacagaattacccaatacctatcatcacgacttaaatacccaaagcagttgtagt
+cgcgtaatagattaagtctgaagcctagagacaaagggatactgggcggggaaacctgct
+ccttcacggtaacatggtaacaacagaatttggttaaggttaaaacgaaatatactcgga
+gtgaattactgttaggtttcgtcatcggatcaataagtagtttccgtgaagacactctta
+tattagatctccgaaattctgacccgtgcattaggcacttggtaggagattccatttgga
+acttgctcaatgtaagccagtaatgttccgaaataattcgctgcaggagcgaggagccgc
+tgaataaaggaccctcgcatcttgttaccttatggttgagggtcaccgttctctgcgtca
+attccagagctggagatacattcatcaacgttacctacgcacagaataaaaagatcgagc
+gctaactcgttttcctaaacacaacggatttagacaaattaccgaatgcgccggagagta
+gcatcttagtgtcatgcctatcatggcggctcagtacgaagagttcaggcatcgaatatt
+gtggtagcccgcactcaaagttccgccattaggtaagctatatattgtggtcagaacttg
+aggacaactatgagctactaaaaataaacaattttgtcatttgttctagatatgtggcat
+tcatcgaacgcttgtaccagaagttacattcgcagcgtgagcgaataaacccgaatgagc
+gtaacattatcaataacatatagttcagatagagaacgaggtattcgacagagaattacc
+caacattggttattaatctatgcagaataatttagataatgtcactacataatattagga
+ccaaaaggtgattccccagaagacaaaacaataaacaatctcacatattcgctagtacct
+atgtatgggtatgatcttctgattggacggggataatttccaggtatattaaaacttatt
+accataatctagacctaagagaggttatataagtaaagagctgtgttccgatagaaaaac
+ccgaccttaaagacttgcgaagtaaattttgctttaacaaaaaaacctacgtaagggaat
+attctgtataaactgaaaagtcaggtgtaactacatgagtcatgtcttcgattaattaca
+atgcgatctcgttattctgatcaactaatatcataaactgccactacatcttgtacaatc
+attcgcaacaatacttttatgtgctaaggtcacgtgcttcctctgctatgctgatttaat
+cagattcataaaggaatacgaataactctggatccattaccacgcaagggatttatttac
+ggctgattactttttggctgttgacagaactgccatgaaagtaagatgtcgcatcttgca
+taaataatagcacctaatatagccgacaaagtgattccgataacagattttaagttgtcc
+agccttgagactccatgaagaccgcttgggagcttccccgtgattagaagaatctaaatc
+ccaagtggatggggggagtttaaatctcagcaccaacaaatagtacttcctctcagagcg
+cgtcatggtcgaaggagcctatcctgatagaggtttgaaagcgcacgcgcatttaactgt
+catattaaattggaatctcgtaagtgtcggcagtacgacaaattttaactgatgtcggta
+tacggagaagaaggaagcacgcattgaagcagctacgcagaactgagaagatgacactct
+aagatacaattaatacaaaaacgttttaagcccaatctatcaacagatgtaagatgtcta
+atacacaagaataaaaccttcatgtcccgatgtataataacagctttatttctgctggtc
+gaggtgaagtagtggaaattactccatcttgctgcgcgtctttatagtgttggctactct
+gtaaccgacgcgtccatccctctctcctagtgatccgtatatccaattagaggataacca
+acatctgcgttaccgacgaatttaaatttttcgactatttaattccgttcaaacccgtat
+tcgtagtaagtgtttcatagatttatgaccgacatcgtgtacgagttgcagtgcatatgt
+agataccactaattgctgatctaggatacatgctttataaacatgcttacttggctattt
+tatttactgtcatgtgggggtttttattttcaacaagtatgtgctaccattggataatct
+ggcttcaaattgaagatatgcgttccaaacttgtctactgtttgctaagtaggagttgtc
+ccattagaactacgcagcacgtggtttgtgatcgaaaagaataattggcaaatacgaggc
+tagccttcaaatttaatgcagattactcctcagaaacacacgtaagcgacgaacgtgatg
+tttactacacaatgcgtatcatagaaattcgtgataatttttgttccaacctttgaatct
+agactgagtggaaaaagatttcaccgggataccgtttatgctggttttaaaaactcgtcg
+aatcatcttataactgcattcaaatggatttctcaatcatctgtacgtcaactgttttaa
+caataacgtcagaataaaccggcacaatgagacggcggtctttcactacaccacaccctt
+aggattataagtgacgtgtggattcgaattctaaggtgacgggatctacaagcctcagct
+acattaggtctgaagatctttcgtatagccgcgtatgttactgtttggatatgggttatg
+ctaatcaacagttgacagcgagtgaaacggccttgcgacctgaaatctttacggttacct
+tttgattcaagacaggatcgacgatggaccacgtgaaatgaattcaaaactgtaacatcg
+cttgtgcctcagcgaccgagtaacgacaagttcacatcctctatgcaactatcattgtgg
+tcattaaggtattcaagattaactaagagtcgaccatatattctagagttttacaattag
+gaaccgttagtctagactaggagcgtgcaacatcgcaggaggtgtggactgtcttgaccc
+aagttgcctgacacatagtgtcttttgcttcatgtccttagcaatgcgatacctcaatcg
+tagttttatcgggataaataacatggtgtttaaccctattaatggtttctattaatctaa
+attgtaaggcagcccttgggtcgaaagcacattaggccacatacacagtatgaaattgtt
+cgagtgtccagaccataattgactaccatggtacacggtgttgctattatgactcccgca
+aaactcttgacagagggaattttggtacattgatgtaatcgatgatttaacagtaggaac
+tagacgtcatccgttagactgagttccgacatgctcaaattgtcaggatttttatccaat
+aactaatggctctcacatgtaaataaaatcacattaacgtcacttagtgatggattcgct
+aaacagatagactatcattcatgaactggcactgtttcgattatatttgcaacatcgaac
+atacttaaagttaaatacgacatcattcaattaaaaaaattcagtacacctctaatgagt
+atcccgctttggaggaaagagtagcactttaaatggacaatttaggccggactttcctgt
+aaatggatgaagtcattgtacagcttgaataaatcgttagggttagtccttacatccacc
+atatgttaatgaataaagcctgagggaccttagagctaacttgtccaacacgttgctcat
+ttacttaataaggttgaaatgtatcagtaagtgacagcgagtgtagattttgaccattta
+actgaccttcacagttttgtcttcagacgtcacttacaccataatgatgacagagcttgt
+agatgcacacactcattcctagtgtaaatcaagtagtagctagattattataaagagata
+ttttctggcgtcgaacgtaacacagagagagtataaggggcatgataatggcttatcaat
+atgtgtaagaaaaagtttttaatatcatctaactcggtggaatgcacacttatggccaac
+tgaccttgggacgagttaagataccataagaggttgcctgtaagttaagataacaaaggg
+atattccatctttgtgtgctaagaacctatttatatttgcagccataaaaacctctgtgc
+tatgcagccaccagagttatttatacaaagaaagagaccatttagatacgttaattctgc
+ttgcgatttattaaacagacatttcacgtccaaccactacaaaagccctatcgcaagacg
+atcattgtattatagcctatgcaacgtagctaagcggccgaggaatcataaaatatgaat
+tgttacattgtttactacatatgatcacaatctttgtaaaaggttcgttcgtgatactac
+catgtacctaactaacctgagatatatgcaatgacttatggggtcagcgcgcaacatccg
+caaagcatagtaatacaaggtaggaaaacttctggatttcccaaggttataatgctctat
+actgaccaagagatccgttacgactcgcaatgaatactctaagggcactcacaaagaaaa
+ccactaattgataaatttcaatgataatatcctgaattgcatcgtgtatgagttacgaga
+agtcgcatttaatgaattagtcatagaaatgtcatagcaggaacataattactatatttt
+aacgatttaatcgtagttggagtcctttcccaaattatgtcatcagttccgatttagatg
+ttttcgggcccttcttagtaaagaagttaatatccaagactagctcctcacccacgcatg
+cacatattcgcgagaagtctgatagaatattcgacagaaatgcgactctagctcacactc
+gttaactgatcaggtacttatagacaagtacgttatcagatatcgcttcggggcattgtt
+gcgctacctttgtgcatagcagttttgaaaaattgttcaagacctgaacgggaaaatgat
+attatttttttaggaggaataatacagtaccatgtaaatactcaaccaccttacgtactt
+cttacgccgaacatatatggcacgtgttattcggctaacaaaactgttgtgccttttcta
+taaggataagcagattcgttttaaacatatgacctgtaaactgggatctacaaaagaggt
+acttaaaataaattgcgcaacggtttagatctgcggatctttggttaaagagcaccatta
+gatgtgccatacttcctatcgcctgagcgagaatttagtctgaggaaccactcttgggat
+ttaaaacaattcggttaggacacctactcggcggatgaagcaatacgataacattaaaag
+tcgttcagtctaattttggtcgtagtacgatgagctgatggccaattgtatttttattaa
+cagcactgaaacaaaatggagactttagactaatactaaagtctcaatgttcgtcgaacc
+ttaaatgctcggaatgaggggatcttcggaagtatagcgccgaagtgtatctcattatta
+taacaccagtgtacagacgacatctaattatggccagaaactgtcattgtgccattaaga
+ggattagtagatagtctggaccgtggaatagaattttgaccaaattgaccagtcctgctt
+gtagacagcgcgatctaaactgcacgagaatatacaagttggtggtgcttgtggctgagc
+acgctaagatgcgtttgtttttacgattctagtgcttcttaacgcaattcagtcttctag
+atccgctattccaacatcaatatctcaatttaaggtcaatatatataacaaaattagaca
+gagcagctgacacttacgaagcatcgtagaaccgatatagtcgaccttatgatgatatgg
+acgtgtccaagtccgcacttccgatgcatcttgacggtgaaccgaaatgaaatcttcatt
+agggcccccatgtgtcaaaccactcgagtcccgtctctgaagtcaagtattactgcgaaa
+aattcgtctactattagtttattatgaacttatgacgcttaaataaattaaacagtaagc
+ctgggaaaatgttaaggcaggaatctttgtaacagttcataatgttgctaaagattatca
+gaccccgtgaagacttcgggctttgggcttcgtaccgtagcataatacatctatatagtt
+agaggcttgcgtgttgttgtgctattccacatatagcagctctgggcgactcttcaatga
+aaatgaaaaatggtaacctggcgacctacttgttaagtcagtttaattcaaggggattaa
+gtaccaagggtcgagtttctctgtatttattatactgtaggcaagaagcttttttggcga
+gatttaagacttaagcctatggtaaaaatttgatagtgagcgactatagtaagagatttg
+ggtggttagtaattaaaattctcctatgctaaatcaggcgtacaatctgagggtgcacat
+ttctcgacgcgtgaaccttcaccgaaagcgtgtggattatacaaatttcaaacatattgg
+cggggcacttatccataatagatttctgtttgtacgccaaactctgcctcacccctccat
+aaattgtattggctagaggttaaattctccgtaaatagagacacatatagttttatacaa
+ttgtttgaatcaaagcacgagaaacttttaaccgtacattgacaaatgtcttcggatggg
+gcagagcatctcttcgtgacccaaatcaatcgctgagcaataagcaagaaaacacagatt
+atacaaagagatctggatgaagatattcgtgcaatcactatcgttatgttagagagttcc
+atgcatgaggactcgttttttgaccaggagaattaagccaagaaataactgacgtatttc
+caaatgaattctacgtgtttttcctgtcacctttagccagtgttaaagatgactatggag
+tttcgaataggttattctatagacattataacgagtggaacacccataccttcacagtgc
+taaaggtaggaacgggtacgtcaggtagttcaagggattttaggttcttaatccaacgaa
+gaaataacgcatcacccgtcattctattgttttcgtcgggattacttagtaggcagggta
+ttctaacctacctgagttacaaatctttaaaaaactggccatgaggtcatggtgataaaa
+tctgaatcgcctaaattcgcgtccctaaggaaatatactagaatccgtctcagaaagtgc
+aaaggttgacttcttcccctaacacagaattctcagttttatagctatctagtggcattc
+ctttttataaaactttacgtttgtaagggtccaactttacaaaagctcggatgtgtatgt
+gtaatcttccgccgtgtaagacttggaacccatgtatattgacggcatggcgtggctaag
+caggtattgatcttcagtgtaaagcaaggtatgttctaatctaacaatgtaaagccgggg
+attagccgccaaaggggtctaatgacatagagatgctctgaaatcgtaccaactataaaa
+gcacgggatttgaaatatagcgacagatcttccgtattctgttagttgacatctgtgctg
+tctttaccgattgtgatttggctttagcagtcatttagtttcgttactcattgctcgtgc
+gatagttccaccgaatatggcacattcgttctttttttccattttactgcaaaccttttc
+aaaagctgatcgataccactgatgatggcattgattagtcgattggcaactatgtcctgc
+ttatatctccaattgcattgaatatagtaaaaaataaaggctcgccttcccaatgggcta
+cggagtacacgaaaaaatcgcaactcgtttaaccaagcgccgtacctaacatataagtga
+ttgagacaaatagttctccagacgtattgagatatatgtctcctataggcaagcgtttct
+aattgctgaccagaaattagaattaggttgttaatactatattcgaccattttattccac
+gaatgtgctattctactggtattgctccgtatgcgatatataaccaacacggaaagtcgt
+cgattgcaaagtggctccgtagaatcatttctggtcatttaccgggagcgcgcttgaaca
+atggatgcggtatctgccatattgttattgttaaaaagacttccgcttactatcgcttcg
+atcatcggaaaaatattaatgaggattgggtcgtataagaaaatcatcttttcagttcgc
+agatttttgccaatttaaccggttatttcgtcagacttggtagtgtagttacaagcatca
+cgattatatcagctacagaattaaactgtcctgactcgacggggcagtgtgtgagtattg
+cgctatatattcaaggtaacaggaggcatataggtcatagtacaaggataatgaggtttg
+ctaactttaaaaattattgatttaacggttgattgaaaatctctgcaagatgacgctaga
+acacctgatgttcaagtttgccgataataacatataagatgaattactgtctttagaccc
+tcatgttaatccgctaacttagggcggaaacaatgttaggctatgcggagtaagtactat
+attatgataccacatagaatttaacattcatatgatgtctaatacccgttcccaaccttg
+caaccgtcccgattaattaagcaattacggtcatcaatgggccaatcctgtctcaaaaat
+tatcatattcaaggttcagctattttggcaatgggtgagtaccgttcttagtgatttacg
+aacccataatctaggcgacttaatatacaagatttagagttacgttttccgggtagtaca
+tattaacgaccatggatcgggtgaggtgttgtattagttatctgatcttgtcagtagctc
+ccaatgtcccagaatattatgtttctactagagtgttcgtatactggaatttaaatatta
+tgtaagactagacaaattttatggatacattaggccatcgtagaatatgatatagttgta
+acgtccctctatagattttcggagggcaggtatattgcttaataaagatgttcggaaatc
+agcggaaaggatttgtaattaactgatgcgcagcgcttaaataagtttagactattaagc
+tatatgttcgacagcatgtagttttttttaccagaaagtgttatactgatgacccatgga
+ggtagctcctcatgataaaaatattgttacttaagcattactattatagtgttcaaacta
+gtaccgttgcatactttaagaatcagacatggcgtttcttatgcagacacacttttttag
+ctgttgacgcccacctcacatccatagtaggtcaatcgcataagaacaatattctggact
+gttttattacccagaagaaagttttttctttccggttcgttaagacaataaagatcattt
+cattcgttctcttaacgatgaactaaagtacttaaagtatccgcctcttgtttcgactag
+cgcatagtgtaataattaaggcaagataagaagaacaggaacgcgcacgtcggagataac
+tctaatagtctctttattccgtttaatatagcccgtaattgcaccatgcgctacagtaac
+ggccgccttcgcaaacctatttatgtaattccaagtttaggtatgcaatggttggggcaa
+tgtgaggggttttatcaagactttcgttgcttcgcggggggcgcaaagcagactttacag
+tagttaaccgaaaaccgcagggagtcgctctaagtgttaccaacccctcactactacgcg
+aaggtactcgattattccttgaatgggctgaaacatcgtgattagcgtcttatgattcag
+gctgatagaagaaaacttattttctatattccacgtatacaatcacactcgtaactaaat
+agttcccagcgttgtaatgtcgctataataaataaaatacaaagaaaattcgtctgggtg
+cataagtacagttagtcgtctgtcacataaataatccgcagtcgatctcattacaggtat
+tgttgttggtcaaccttcgcaaggtggtccaagtagcattgttgaacagtaaaactaccg
+tcacacaaggaatatcataatagatgccatacacggttttacttgatatgtttacagtcc
+ttgagttgcaatcgtagtattgtttcatccggggtgtgtacgaagtaatttagacaaggt
+gtgtagcggtcactaggtaaaatgacttaggatggatgagcatttaggtattctatgata
+acactaaccatcatgtttctaaaatcctcaggaaatttgtattattttaccaacctgtat
+ttatagaaagtgcttttgacttaaagaagccgaagtgttcaaattaaggagtacctgatt
+gaaagaatggggaattgtaatctgtaactcaattacaaataagccgttctaaggattaag
+gctttgtgtctaagcaactcacgtgaattcgaaattcatactcgattaacgactttaata
+ctcttctgcgtatctacagactcatttaaattacggaatatgttttcgtttttggtttcc
+agctcgcacgtacgcgtttacaaataaggacacctggtacaattggctggagtacaatgt
+tggtttttatttgctgattatcccgatccctgtgggcgttggcataaccgggttttcttc
+aagactactttcgtgttgcttatatacctggtaatatcggtgagtagcttagggcttaat
+cacaatactaacaagttctctatggattggacagggcggcatccgttgactgaacgatct
+attaatccattccctgcactggataaacaagacccatttaaattgaccatagagatgtta
+gcgtcatatttctgttcgtgatagggtacatatattataaacggattatgagcagtggtt
+ttctagaaaagcattcatagttaggagtgtatcagatcataccactgaaccatagagcac
+aattctctactggctatacttcattcctttttgtccgggtggggacgaaatttaaaggtt
+ctaacctagaacgcagagcgaattgatcaaggcgctggccaagtgaacggttctaaatgt
+tcttaatgagaattgcgtattttgactattgacagggcatcgtaaaccgctactcgactt
+ggtatctgtaatctgtatgtagatagagtacgggcctataattcaaattcagccaccgaa
+gattcacaatcttcagacgtttgaaggaaagaggtttactggtatgtggtgtcaagcccc
+acccattctctgttatatccgagcattaatgtagtttcactgtactacggtcacgccgta
+gagtcggcagggcaaatccaaaacaatttaggctgagaagtggcactataatagtttagc
+ctaagtcccttcgctaataactcaacaaagatgacgcaaaagtcggcgaatagattgcgt
+tcgcgtaagggtatcttgaatactgatagctctcatggtaccaagaactttcataacctc
+tttatttaccaaacctgttctactagcgttagtgttttagtctgtagccgacacaaaaac
+cgagaatggccggcgtaaccggcgcctgcaagctaacatgggatcaaaactattggctta
+acgtttaatcgaatgagactagcactgtattactctttcgtttcggcagcggatcaataa
+ggaggtgacggcatcactctcttatagtagatatcacttattctcacaacggaagtagga
+tcttccgtcctcattaaatttgcaactggctcaatgtaacactgtaatgttaacaaagta
+tgagctgaaggtcagagcagacgatgtagtaaggtccctcgaagctgcttacagtatcct
+tgaggctcaacgggctatgcggaaattccagacctcgagttacattatgaaacgtgtcat
+tccatctcattaaatagttcgtgccctatcgccttgtaatataaacaaccgtttttgtct
+attttcccaaggagaaggagagtagcagcttagtggcttgcctatatggccccctaagta
+cgtactcggcacgcttagaagattgggctaccccgcactatatgttcccaaagtaggtaa
+cctagatagtgtcgtatgaaattcaggtcatcgatgagagtataaaaatatacaattttg
+gcaggggttatacattgcgggcatgaagagtaacattggacatgaacggacattcgaacc
+ctgtgagtttaataccctatctccggatcattataaagtaaatatacgtcacttactcta
+cgtgcgtttagacagtctttgaaactaaattggttatttttctttcatctagatttgtct
+gtatctaactaaattatagttccacataaagctgattcaactgaagacataaatataaac
+tttctaacatagtagcgaggaaagagctatgcctagcatcggatcatgcgtccgcgagta
+gttcctggtagagttaaaagtttttccagaatctagaccgaacacagggtagtgaacgaa
+agtgcgcggtgaacatacataataccgaacgtaaacaattccgttcgtattgttgctgta
+tctatatttcctacgtaaggctatttgatctataatatgaaaagtcacgtcgaaataaat
+caggaagcgcttcgagtatgtacattcagatctccttagtatcatcaaattatagatttt
+acggccacgaattattggtctagatgtcccaaaaataatttgatgtcagtagcgatcgtg
+cttcctcggagttgaggttggaagaagagtcattatgctataccaagaactctccatcca
+gtacctagaaaggcaggtatgtaccgctcattaattttgcgatcttgacagatctgcatg
+caaagtaacttgtaccagatggcttttataatagaaactaagtttcccgaataacggtgt
+acgataacagatttttaggtgtacagacgtctgactcaatgaacacacattgggacctgc
+cccgggaggagtagtagataattaccttctccagcgcgggtcttttaatatcacaacata
+aaaatactaattaatatcacacaccctcatcctcgatggagcctagcatcatacacgttt
+gatagacaacgccaattttactgtaatatgatattcgaatctagtatgtggacgctgtac
+cacattgtttaaaggagctccctttaccgacatgaacgaagcaagctttgtacaagatac
+gaagaactcagtactggtaactataagagacaatttatacataaaagtgttaagaccatt
+atataaaaagaggtatgaggtctttgtaactacaataatacattcatcgaacgatggaga
+ataacagagttatttctgctgctcgagctctagttctgctaatttctcaatcttgatgcc
+actcgtttgagtcttccattcgctcttaacgacgcgtacatccctctctcctactcttac
+ctatatcctattactggttaacctacatctccgggaaagacgtaggtaaagtggtccacg
+attgtattcacttataacacctagtagtactatgtgttgctgagagtgaggacacactta
+ctctacgagttcaagtccatatggacattacactttttcagcatctaggtgtcatgatgt
+attaacagccgttaggggctatttgattttatcgattgtcggcgtgtgtattttcaacaa
+ctaggtgctacaattcgtgaataggcatgaaaattcaagattgcagttcctatcttgtat
+aatctttcctttggacgagttgtaccatttcaactaacctgcaagtggggggtcatccat
+atgaagatttgccaaatacctggagaccctgaaaagtttatccagattaataataacaaa
+caaacctaagcgaagaacgtcagctttaataaactatcactatcatagaaattcctgtta
+attgttcttccaaacgttgaatagactatcacgggtaatagattgaacacggagaacgtt
+tatccggcttgtaaaatatcgtcgaatctgctgataactcaattatattcgatggagaat
+tcatatctaccgcttagcttttaaaaattaagtcagattattccgccacaatgagaaggc
+gcgagtgcactaatcaaatcacttaggattattacggacgtctgcattacaatgctttgg
+ggtagggttatacaagcatatgattctttaggtctcttgatcgggcgtttaccaccgtag
+cttaatgttggcatatccgtgatcctaatattctgttgtcagcgtgtgtataggaatgca
+caacgcaaatctttaagctgacctgttcatgaaagacaggagacacgaggcaccacctca
+attctatgcaaaactctaacatagcgtggcactatgagtacgtgtaacgacaaggtctca
+tactcgatcctaagataattctcgtctggaaggttttaatctttaactaagagtagaact
+tagtttattgacttttacaattaggatacggttcgcgactctaccacagggcatcatacc
+tggagctctgctatctcgtgaccaaagtggcagcacacatagggtcgggtcctgcatcta
+ctgagcaatccctttaagcattcctagtttgagagccatttagatattgctgtttaaacc
+gattaatggtttctattattataaagtgtaacgctcccattcgggacattgaaaattagc
+aataagacaatgtatgatattcggcgagtctcaacaacattatggtctaccatgggacaa
+ggggttgatatgatgaatccacaaaaaatagtcaaacacccatggttcgttaagtgaggg
+tatccaggtgttataaggacgatctagaagtattcaggtacacggtgttcagacatgctc
+taattgtcaggttgtttataatttaacgtatcgctctctattctaaataatataaaatta
+accgctcgtagggatgctttccagtaaaagatacactatcattaaggttatgcaaatgtg
+gcgatttgatttgaatcttagtacattcttaaacttaaatacgtattatttaaagtaaat
+atattatctaaaccgcttttgtctatccacatttcgtcgaatcacgacctcgttaatgcg
+acaatttacgaccctctttcatctaaagcgatcatctatttcttctgattgatgtaatac
+tgacccttactccgtacatacaaatgatggtaagcaagaatgactgacgctcctgtcacc
+tttcgtggcaatcaactggcgctggtactgaagtagcttgaaagggatatggatgtgtat
+gccaggcttcattttgacaatttttctgtcctgctcagtgttgtctgaagtcgtatcgta
+cacaataatgatgactctcattgtagatccaatcacgctttcctacgctaatgaaagttc
+tagatagtgtaggtgttagacagaggttagcgcctacatccttacacacacagtgttgaa
+cggcaagcataatcgagtatcaatagctgtatgtatttgtttggaatatcatatttctcc
+cgcctttgaacaatgatgccaaaatgtcctgccctagagttatgataaaataactgctgc
+cctgtaacttaagtttacaaaccgatattcaatcgttgtgtcctatgaaaatatttatat
+ttgcaccaagaaaatcatctgtgcgatgaacaaaacacagtgatttataaatacaaagag
+tacatttagttaccggattgcggcttgacatttattttacagaattttatcggcaaaaca
+cttcatatgaactatcgcttcacgataagtctatgatagactagcattcgtagagaacag
+gaagagcaatcattatatatgaagtgttacagtgggtactacatatgagatcattaggtc
+tatatccggccttcctcataagaccttggaaatatcttacatcagagatatcaaaggaag
+tatgggcgaacccagaaaaagccccaaagaatagtaattcatcggacgtaatagtctggt
+tttaactaggggttattgatatttaagctaaaagagttccctgaacactcgaaatgtata
+atctatcccaactaaaaaagtatacctctaattcagaaatgtcattgagattagactgat
+gtcaatacgctaggaggtaagacaagtagaagtttttgatttaggaattgaaatgtaata
+cctccatcttaagttctatattttaaagttttatgcggacttcgagtaagtgcacaaatg
+atggcataagtgcccagttacatgtttgcggccccgtatgagtaatgatctgtttatcaa
+tctctagctactatcccacgaatgcactgatgccagtcatggcgcttacattagtcgaca
+gaaatccgacgatacctatcacgcgtgaactgttctggttcttattcaattcgaagtgat
+ctcagatacattacggccatgcttgcccttcatgtctgctgagcagttttgttataggct
+gaatctcctctaagcgaaattgataggatttttggtggtcgatttagtctgtacctgctt
+attaagattcaaaatgacctacttcttacgccgaaatgatagggatcggctgaggaggat
+aaatatacgctggtgcctggtatttatccagaacaagttgcctgtgtatcagatgaactc
+taatctccgagataaaaaacaggtacgtaaaataaaggccgcaaagggttacatctcagg
+atcgtggcgtatagtccaccattagttctgacttacttaatatagactgaccgagattgt
+agtatgtggatccaagcttgccatgtaaaacatgtcggttagcaaaacgtataggagcat
+gatcaaagaagagttaattaatagtactgcactataattgtcggcggagtaccatgagct
+gttgcccaattcgatgtttattaacagcacgcataaaaaatccagacttttcaattagaa
+ttaactataaatggtccgcgaaccttaaatgatcggaaggacgggatctgccgttgtata
+gaccccaactctatctaatttttataacacctctgtaatcaacaaatcttattatgccat
+cattatgtcattcgccaagtaagtccagttcgagattctctggaccgtgcaatagtattg
+tcaaattatggtaatggaatccttcttctaacacccttagaaaagccacgagaattgaca
+agttgggcgtgcttgtccaggagcaacataagtgccgtttctttttacgatgatagggat
+tcttaaagcttttctctattctagatcccagttgccatcatcaatatctcaattgatgct
+cattatatagttcttatttagtatgtccagatgtcactgaagatcctgcctagaaccgat
+attctcgacaggatcatcagttcgacggggcaaacgcacctatgcacatccatcttgacc
+gtgaaacgaaaggaaagagtcagtaccgacccaatgtggaaaaaaactcctgtccacgat
+atgtaggcaagttttactgcctttaattagtagtcgattagtgtagtttgatattatcta
+ccttatagaatgtaaacagtaacccggccttaatggtttggcaggattctttgtaaaagt
+taataatgttcataaactttatcagaaaacctgaagtagtccgcctttcgcctgcgtaac
+gttgcagattaattcgttttacggagtggcttgcgtcttgttgtccgagtacacatattg
+ctcctctcccccactcttctaggaaaatcaattatgctaacctgcagaccttcttcttta
+ctatctttaatgcatgcccagtatgttcatagggtagacttgctatctattttgtataat
+ctacgaatgatgcttggggcgcgacttttaacaattaagccgttgggtataatttgagag
+ggtgccacgatagtaagagatttccggcgtgagtaaggaaaatgataataggattaagca
+ggcgtaatagctcaccctcctcagttctccaaccctgaaccggctaagtatgactgtgca
+gtattaattttgaatacatattgcagcccctaggatacattatagatgtctctttcttac
+ccaaactcgcccgcaccaagaaagaatgtggattcgattgaggttaaattagccggaatt
+acagacacagattcttgtttacaattgtgggaagaaaaccacctcaaacgttgaaaccta
+cattcacaaatggattacgttggggatgagaatcgattccggtcaaaaatcatgcccgga
+gcaataaccaagaattcacagaggattaatacacttctccatgaagataggactgcttgc
+actatccttatctttgtgtcttccttcaagcaccaatcgtttggggacaaccacaattat
+gccaagaaataacggaaggtgttccaaatctatgagtccgcggtttcatcgcaacgtttc
+actgtgggtatcatgactttggactttagatttgggtattctagagactgtagaaagact
+gcaacaacaagacattcacagggcgaaacctaggaaaggggaccgcacgttgtgctaggg
+atgtttccttaggaatccatacatgtaagaaagaatcaaccgtaattatagtgttttcgg
+ccccttgaattacgtgcatgcctttgctaaaagacctctgggaaatagattgaatattct
+ggacagcagcgaatcctgattatatctcaagcgaatatatgacccgcaagaaggatttat
+actagaataagtctaagaaagggcattgggtcacttcttccactaacacacttttatcag
+ttttataccttgagagtcccatgcatttttatatatatttaactttcgttgcgtaaaact
+ttaaatatgatccgtgctctatctctaatctgaacaacggtatcacgtcgaacaaatcta
+gtggctacgaatcgcgtcgctaagaacggtttcttctgctggcgttagctacgtatcttc
+tatgctaaaaatgtatagccccgcattagcagcaaaaccgggagaatcaaatacacatcc
+gatgaaatcgtaacaaagataaaacaacgcgatttctatgtttgccaaagtgattaagtt
+gtatcgtaggggtcagcgctgatgtcttttcagtttgggttttggatttaccagtctttt
+agtttcggtactatttgatcgggacattcgtccaaacatgatggctcattcgttcttttt
+ttcaattttaatcaaaaccttgtatttacctgatacattaaactgagcatcgcatggagg
+tggagattcccatatatgtaatcatttgatatcctattccattctttttagttataaata
+aacgctccactgcacaatgggagtaggacttcaccaataattagcatctactgtaaacaa
+gcgccgtaacgaaatgattactgattgagaaaaataggtctcaacaacttttgacagata
+tgtatccgatacccaagcgttgctaattgcgcaaaagtaagtagaattacggtcgtatta
+cttgttgccaaatggttattactccaatgggctattctaatccgatggatacgtaggaga
+gagtgtacctacaccgaaactcgtagtgggcttagtggctacgtagaagctgttcgggtc
+agttacagcgtgcgaccttgtaaaatcgatcacggtgatgaattattgttattgtttaaa
+agaagtcccctgaatagcccttagataatacgaaaatttgttatgtccagtcgctcgtat
+atcaaaagattcggttaagttcgcagagttttgccaagtttacaggtgatttactaacac
+ttgggagggtacgtacaaccatcacctggttagcagagaatgaattatacggtcatgtcg
+cgaagggcaagtgtgtgagtattgaccgagttattaaacgtaaatgcaggcatttacgtc
+ataggacatcgagtttgtcctttgcgaaatgttaaatttatggttttttccgttgagtga
+taatagctgcaacatgaagatagtaaaactgaggttaaactttcaccatattaaattata
+tgttcaattacgcgatgtacaaactaatgttaatcagatttaggagcgcgcttaatatgg
+gtccctatcccgactttgtacgagattttgataaaaaatagtattgtaaattcatttgat
+ggcgtagaaccgggcaaaaccttgaaaaaggacacatttaggatgctatttccctaagaa
+agcggaaaatcctggctcaatatttataatagtaatggttaagattgtggcccaatcgct
+gagtacccgtcttacgctttttccaacacataatcgacgagaatgtatttaaatgtttga
+gacttacgttttccgcgtacttattattaaagtcattggagagggtgtcgtctgggtgta
+gttttctcatctgctcaggagctaaaaatgtaaatctattggttgtttctaattctgtcg
+tccgtgtaggctatttaatttttatggtacacttgaatatgtttagccataatgtagcca
+atactacaatatcagatacttgtatacgacctatagacttttgccgaccgctcgtagagt
+gatttagaaagatgttcggatagcacagcaatcgtttgcgaatgtaagcatgcgaagcga
+gtatttaactgttgactattttgctatatgttactctgaatgttgttttttttaccagaa
+tgtgttataatgatcaaccatgcacgttcctactaatcatataaattttgttacgtaagc
+ttttctatgatagtggtctaaagactacccttgcatactttaagattaagacatgcactt
+taggaggaactcacacgttttgagctgttctagcccacctataagccattcgtccgcaat
+cccataactacaatagtcggcaatcttttattacccagaactaacgtttttatttcccgg
+tacgtatcacattaatcttaatttaatgcgtgagagtaacgatgaacgaaagttatttat
+gtttaagccgcttcttgagaatacagattactgttagaatgaaggcatcataactagaac
+accaacgcgcacctcgcacattactctaatagtagctttattcagtttaatatagacagt
+atttgaaccaggcgctaatgttaaggcccccttcgaaaaccttgttatgttattccatgt
+ggtcggaggatttgcggggcgatagcgctgggcggggatcaacaatttcgttcatgcgag
+cgcccccataaccagtaggtacagttcggaaaagaaaaccccacgcactcgctagaagtg
+ttacaatcacatcacttcgtaccgaagggactactgtattccgtcttggggatgtaacag
+actgattacagtcttatgatgaagcctcattcatctaaaattagttgatttattccacgg
+atactatcacactcctatagaaagagttaccaccgtgggaagctagatataataaataaa
+agacatacaatattagtatggctcatgatctacacttactcggatctctctttttttata
+accagtagatcgcattacacgtattgttgttccgcatcaggccctaggggctcaaacttc
+catggtggataactaaaacgtccgtcactaaacgaagatattaatagatgaaatacacgg
+gtttacttgatttctgttcagtcattcacgggaaatcctaggagtctttcataacggcgg
+tcttagtaggaatgtagtcaagctctgtagaggtctcgacggaattggtatttcctggca
+tcacaatttacctagtattggagatcacttaaaataatgttgagataataatcaggatat
+ttctagtatgtgacaaacctctatttagtgattgtgattttcaattaaacaagacgtagg
+ggtcaaattaacgactacatgttggaaagaaggccgaattgtaatatctaactcatgtac
+taagaagaagtgctttcgtttaaggctttctgtctaacattctaacgtcaattcctatgt
+aatactactgtaaccaagttattactcggctgcgtagataaagtctcatgtaaatgacgg
+tttatctgttacttttgggtttcaacctagctaggacgccggtactaattacgacacctg
+cgtatagtgcagggtgttcaatgtgcctttttatgtccggattataaccatccctctccc
+acttggaatatcaccgggttcttaatgacttagttcgtcttccttattttccgggtaaga
+tcgctgtggaccggacccattttgatctagtctaaaaaggtatatagcgtttcgtctggc
+ccgcttacgttcactgaaacttagattaatcaatgcactgcactggattaacaagaacat
+gttatagtgtactgacacatgttagactaagaggtctgttcgggttagccgacttatatg
+tttaaccgattttgacaactgggttgagagataacaatgaagagtgaggactgtagaaga
+tcttaaaactgtaccatagtgctcaattcgctaatggcttgaattatttaattgttctaa
+ccctggcgtcgaatttttttggttcgaaaatacttagcacagcgtattgttcaacgagat
+gcacaactgtaccgttagaaagcggcttaatgacaaggcagtattgtgactattgacagg
+gaatcctaaaaagctactcgaattggtatatggaagaggtatgtactgagaggtcgcgcc
+tattagtcaaattctgccaaagaagagtcaaaagcttaactagtttgatggtatgaggtt
+taatgctaggtggtctataccaccaaaaagtatatgggatatcccagaatttatcgactt
+tcaatcgtctaccgtcacgacgtacactaggcagccctaatccaaaacttttgaggatga
+gtactgccactattatactgtaccatttgtaacttacattttatatcttcaaagaggtag
+atattgtcggccattactgtcacttacactaagggtagcttgattactgatacctctcat
+ggtaaaaagtaatttaagaacctatttttttacataacctctgctactaccgttagtgtt
+ttagtcggttcaagtcacaaaatccctgtagcgcacccctataagcagaaggaaacctta
+atgcggataaaaacttttgccggaaccgttaatcctatgagaataccactcttggaatcg
+gtcctttaggctgaggatatagaacgaggggaacgcatcaatctaggttaggtgagagaa
+ctttgtatcaaaacgcaagtaccatatgccgtcctcagtaaattgccaaatgcagaaatc
+ttacactcttttcttaactaagtatgagagcaacctcactcctgaacagcttgttaccta
+acgagaagaggctttaagtagcctggagcctcaaccggatatccggatttgactctcatc
+cacttacatgatgattacggtcattacatctcatgattttctgagtgccctatagactgg
+gaatttaatctaccctgtttctatttgttaacaaggagaaccactggtcaagatgacgcg
+cttccatttatgccaccataagtaagttctcggaacccttacatgattggcctaccaacc
+tatatatgtgaccaatgtacggtacatagagtgtggcctatcatattcaggtcatcgagc
+tcagtatttaaagattatatggtcgctgggggtattcagtgcgcgatggaagactaacat
+tggaaatcaacggaattgacaacacgctcactttaataacctatctcaggataagtttaa
+tgtaattagacggaactttctctaactccgtgtactaactctttgaaaataatgtgggta
+tttttatttcatctagatttgtctgtatcgaaagaaagtattggtccaaataatcctcag
+taaaatcaagtcataaatataaaatttagatcttaggacagaggaaagtgctttcccgag
+cataggatctggcctacgccagtagttcatgcttgtgttaaaagttgttactgtttatag
+tccgtactcagggtagtgttcgatactcagcggggaactgacatattacactaaggaatc
+aaggcccttcgtatgggtcatgtttatatatttaattacttacgctatttgatcgagaat
+agctatagtaacgtcgtaagaatgcaggatgcgattcgagtttgtaaattcacagatact
+gtgtatcatattattatagatgttaaggcatagaattattggtattgatgtacaaaaaat
+tatgggtgggcagtaccgataggcattacgagcagtgcagcttggaagaactggatgtat
+cctataactagtaagagccttaaaggtactacatacccagggatgttaccatcattaatt
+tggccatcttcaatcttcgcaatgcatactttcttctacaagatgccttttagaagacaa
+aataagtgtcaacaataacgctgtaacttaactctgttgtacgtggaatcaagtctcact
+aaagcaactaacattccgacatgcaaacgcaggactactagattattaaattcgccagcc
+cgcctcgtttaatataacatcataaaaattctaagtaatatctcacacactaatccgcca
+tcgtccatagcatcagtcacctgtcttacacaaacacatgtttaatcgatgttgttatgc
+caagctagtttcgcgaccatgtaactaattgtggaaagctgctaccttgaacgacatcaa
+ccatcctacctttgtacaacagaccaacatctctgtactggtaaatagatctgaaaagtt
+ataaatataactgttttcacattgatagaaaaacagctatgtgctatttgtatatactat
+aataaattaagcgaaacatggagattaaaacagtgttttctcatcctccacctcttgttc
+tgctaatttataattcttgatgccactcgtgtgagtcgtccattcgatcgtaaagaaccc
+gacataaatagatacgacgctgaacgagatcctatttctcctgaaaattattagcacggt
+aactcctagggatagtggtactagttggtatgaacgtataaaaacttgtactactttctc
+gggatgtgagggagcaaactattactcgaccagtgcaacgcattatcgacagtaaaagtt
+ttcagctgatacctgtctggatggattatatgcaggtaggcgagagtggattgtagcgat
+gctcggcgggggtattttaaaaatctaggtgataaaagtcctgtttagccaggaaaagtc
+atcattgcactgcatatcgtcgattagctgtcatttcgtccactggtaccagttcaacgt
+acatcaaagtccgggcgcatccatatcaagttttgcaatagtactccagaccatgaaatg
+gttatccagattaataataacttaatatactttcactacatactcagcgggtattaaatt
+tcactttatgtcaaaggactcttatgtggtcttcaaaaaggtctagagtctatcacgcct
+aattgtgtgaaaaccgagtaacttgatcagccttgtaaaatatagtagaatatgatgtta
+aatcatttatattccagggagattgaatagcttacgattagctggtataatttaactcac
+atgattaagcaaatatctgtaggaccgagggaaagaataaaataaagtaccatgagttcg
+gaacgctgcattacatggcgttgggctagcctgatacaagaagatgagtatggagctctc
+ttcatcgggacgtgacaaccctagcgtaatcttggcagatcccggagcagatgattatcg
+tctaacactgtctttaccaatgcacaacgcatagatttaacctgaactgttctggattca
+ctcctgactacagcctacaactcatttctatgcataactcttaaagacagtcgcaatatc
+agtacctctatacacatcggatcagactagatcataagataagtctcctctggatccttg
+tattctgttaagtacactacaaatttgtttagtgtctgggacaattacgataagggtcgc
+gactagaccacagggcatatgacctccaccgctcctagcgagtctccaatctgcaagcac
+tcatacgctaggggcatgaatcgactgtcaatgcactgtaagatttacgagggtgagacc
+catttagatatgcctcgtttaaccgttttaggcttgataggatgagtttgtcgatccatc
+aaattcccgacattcatattgtccaataagtatatctagcttattcggactcgctaaact
+aaattatggtataaatgccgtcaaccggtgcatttgttcaatcaacaaattatagtcaat
+ctcccatggggccttatggcagcgtatacagctggtataacgaccatatacaactatgaa
+cggactagctgtgaactaagcagattattggatccttgtgtataattttaagtttcgatc
+tatatgctatagtatagaaaatgttccgatcgtacgcttcctttacagttaaacagtcta
+tatcatgaagcttatccaaagctggacatttgatggcaatcttacttaattatgaaactt
+aattacctattattgaaagtatttatatgatcgaataagatttgctctataaacaggtcg
+tccattcacgacctagtgattgcgtaaattgaccaacctaggtaatctaaagcctgcatc
+tatttcttatcattcatgttatactgacccgttctcagtacttaaaaatgatcgtaagca
+agaatcactcacgctcatgtcacatttagtcgaaataaactgccgatgggaaggaagttc
+cgtcattgcgatatcgatgtctatcccacgcgtcattttcaaattggttatctacggata
+actgtgcgatgaactactataggtcaaaattatcttcaatctcattctagatcatataaa
+gatgtccttcgcgattgatacgtctacagtgtgttggtgttacacagagggtagcgacta
+cttacttactaactctctcttgatccgcaagcataagccaggttaaagtgctctatcttt
+ttctgtggattataatagttataccgccttgcatctaggtgcccattaggtaatgcccta
+gtgttttcataaatttactcctgccatctaacgttactttaatttcccagattcaatagg
+tctctcatttgaaaattgttatatgtcaacaaagaatataatagctgagtggaacaatac
+actgtgagggagtaatacatactctaaattttctttacggtttgcgcctgcacagttttt
+tttatctatgtgatccgcataaaaagtaatttcaacgttccattcaagttaagtcttggt
+gacactagcattaggagagatcaccaagaccattatttatttagctagggtttaagtcgg
+ttagaaatatcagataatgaggtctttatccggccttacgcagtagaaattggaaatttc
+gtaaagcactgagttcaatggaagtatggccgaacccacataatgcacaaatcaagtcga
+tttcttccgtccttttagtctcctgggaactacgggttattcatagttaagctaaatcag
+ttaacggaactagacaaatgtataatagttcccaaatatatatctataaatcttatgcag
+ttagggaatgcagatttgaatcatggcaatacgctagctcggaactcaactacaagtgtt
+ggatgtacgaattcaaaggtattacatccttatgatgttcttttttggatacttttatga
+cgacttccacgaagtgaaattatgttcgaatatctgaacagttacttggttgagcccaag
+gatgacgaatgttctgtttataattctcgtcataatataaatacaagcatatgaggccag
+tcatggagctttcatttggactaacatttccgtagagtcatatcacgcctgtaatctgat
+ccgtctttttctattcgaagtgttatcagatacatgacgcccttgcgtgacattcatggc
+tcctgacatcgggtcttttaggctgaatctaatctaacccaatttgtttggattgtgggt
+cctccattttgtctgttaatgcttattaagattaaaaatgtactacgtatttagacctaa
+tgattgcgatacgctgtggaccattaatataagctgcgccaggggatttttccagatcat
+ctggcctgtgtatatgttcaaatctaatagccgagagaaattactccgacggaaaataaa
+ggcagataagcgtttcagagcaccatcgtggcgtttagtcaacctttagttcggaattta
+ttaatatacaatctcactctttggacgagctccttaaaagatgcccttgtatatcatgtc
+ccgtacctaaaagtataccagcatcatcaaagaacagttaaggaatacgactgctctata
+attgtccgaggagtaccttctcatctgccaatagtcgttgggttggaaaacaacgcatta
+atatgccacacttgtcaattagaagtttctataaaggggacgagtaactgatttgagacc
+tagcacggcagaggacgttcgtgtgacaacatctctttataagtttgagataaaatcgct
+aatctacaatgattatttgccaatcattatcgaatgcgcaaagtatctcctgttcgtgat
+tctagcctaaggccattactatggtcaaattatgctaatcgaagcagtcttctaacaccc
+ttagaaaagcaaacactattgaatactgccgccgcattcgccagcaccaacataactgca
+cgtgcttttttccatgattggcattatgaaagatttgatctatgattcttaccagttgca
+atattcaatttagcatgtgttcctaattattgtgttattatggtctatctcatcatgtaa
+atgaagatcatgacgtcaacacagattctagtcaggatcatcagttcctcggggaaatcg
+cacctaggaacagccttatgcaaccgctaaacaaagcaatgaggatgtaccgacaaaagc
+tcgatttaaaagcctcgaaacgagatgtacgaatcgtttactgccttttatgaggagtcg
+agtactgttggttcatatttgctacatgattgtatgtaataacgatcccgccctttatcg
+gttcgatcctttatggcgataagttatgaatcgtcagtatctttagatcaaaaactcaac
+tagtacccagttccccggaggaacggtcatgattaatgcgttttacggtctcccgtccct
+cttcttgtcagaggaatcagtttcatccgatcccactcgatgattggtatagctatttgc
+cgaaaagccacaacgtattcggtactatcttgtttgattcccctgtatcttaattcgcga
+cacttgatatcttttgtgtttaatcgacgaatcatcctgggggcgacacttgttacaatt
+atccagttgcgtttaatggctgtgggtcacaagattgttagacaggtcccgcgtgtcgta
+ggaaattgataattggagtttgcaggacgaatagctcacccgcctaagtgatccaaccct
+catcaggataactatcactgggcagtattatttttgatttcatatgccaccccctaggag
+actgtagtcatgtatctttcttacccaatctagcccgaaacaagaaagaatgtcgattcc
+agtcaccttttattagaccgatttacacacaaagtgtcttggtttaaaggctggcatgaa
+tacatactcaaaagttgaaaacgacttgctctattcgattaccttcgcgatctcaatcga
+ttacgctaaattttaatgcccgctgaaatatccaacatttaaaacaggattaattctctg
+atccatgaacttaggactcattgcacgtgacttatctttctctcttaattcatgctccaa
+tacggtgggctaaaccacttttatcacatgaatgtacgcaacgtgttaataagctatgag
+tacgcgggggcagcgaaacgggtcaatctgggtatcttctattgggacggtacatttcgg
+ttttatagactatgtagttacacggcatcaacatgtaattaaaacggcgtaacctaggaa
+agccgaacgcaccttgggattgccatgtgtccggaggattacatacatctaagaaacatt
+ctaaactatgtatagtcgtttacgacccttgtagtacgtgcatcccttggcgaaaagtac
+tctgggtattagagtgtatattatcgacagcaccgaatcctcattttatagcttgacaat
+ttatgacccgaaagaaccttttataagtctataagtatatctaacgcaattgcggcactg
+agtccactaactatctttgagcagtgttatacagtgagacgccatggaaggggtttatat
+attttactgtcgttccctaaaaagttaattatcagacctgcgcgatctcgtagatgaaca
+acgcgatctagtcgaaaaatgcttgtggctaccattccagtcgagatcaaccgtttctgc
+ggatcgcgttacattccttgcttatttgcgataaatcgatacaaccccattaccagaaaa
+acccggagaatcaattactctgcagatcttatactaaaaaagagattacaacccctgttc
+tatgtgtcccaaagtgagtaacgtggagcgttggggtaagagcggagcgattttaacttt
+cgcttttccattttccagtattgtactttacgttatatttgagcggcacattcgtcaaaa
+catgatccatatggactgaggtgtttaaatgttaatcaaataattgtattttcagctgac
+tttaaaatctgcagccattggaggtggagattccaatagatgtaagcaggtgatatcata
+tgcaattcttgtgacttattaagataccagacacggcacaatcgcagtagcacgtaaaca
+ataatgacaatcgacggttaaattccgaacgtaagatatgtttacggatgcactaaaata
+ggtagcaacaacgtttctctgagatgtataagttaccaaacactggagaattccgctaaa
+ctaaggacaatttccgtcgtattaattgttgacaaatggttagtaatacattcgcagtgg
+ataatccgttgcatacctagcactgagtgtaaataaaaccaatcgactactggcatttcg
+ggctaacgactagatgttagcctatgtgaaagcctcacacatgcttattgccttcacggt
+gagcaatgtttcttattcgttattagaagtcacctgtagagacagtagagatgacctaaa
+tttggtttgtccagtcccgaggtgatctaatgattaggttaacttagaacagtggtcaat
+tggttaaagctgatttacgaacacttccgaggggtcgtaaaacattaaactggtgagaac
+agtatgatgtattcggtcatctagacaaccccatcgctgggagtttggacagtgttatga
+ttcgtaaatccaccatgtgtccgaattcgaaatcctgttgctccggggagatagggttaa
+tttaggcttttttacggtgtggcatattagctcaaacatcaacattcttaaaatcagcgt
+aaacggtcaccagttgatatttgttctgctaggaagcgatgtacaaaataagcttaataa
+gatttaggtccgaccttaatttcggtccatagcacctctttctaagtgttttgcttaaat
+aattgtattgttattgattttctgcgagttgaacacggaaaataagtcaaaaaggacact
+tttaggttcatatgtaccgatgaatgcgcaatagaatcgagaaatttttagattagtaat
+cgtgatgattgtggccaaatcccgcactaaacggctttcgctgtttccaaaaaattttag
+tccactaggtatttaaatgttggacactgaacgtggaagccgtcgtattatgaaactaat
+ggcagaggggctcctctgcgtgtactttgagcagatgctatcgtcagaaaaaggtaaatc
+ttttggttctttataattctggcgtccgtgtagcctagtgaatgtgtttggttcaagtga
+atttgtttagccagaatggaccaattacgtcattagctgttacgtctatacgaaatatag
+actgtggacgacccatcgtagagtcatgtagttacatgtgaccttagaacaccaatcgtg
+tgcgattgtaagcaggacaacacagtattgtactggtcaattggttcatagatctgacta
+tgaatcttcgtttttgtacaacaatctcggtgaagcttcaaaaagcctccttcctaataa
+tcagttaatttttcgtaaggttcctgttcgaggttagtcgtataaagacgaaacggcctt
+aatgtaacattaactattccactgtaggtggatctaacaaggttggacatgtgctaccaa
+taagataagaatttcgtccgcaatacaatatctacttttgtagcctatcttggattaaca
+acaacttacgttggtatttcaccggacgtatcaaatgattctgattttaatgactgagag
+taaacatcaacgaatcttatgtatctttaagccgctgcttgacaagtcacattactgtta
+gaatgaacgcttcattactacaaaacctaccaccaactcccacattaatattatactaga
+tgtttgaagtttatttgacaaaggttttcaaaaagcacagaatcgttacgaacacgtaca
+ttaaattgttagggtattaattgtggtcggtgcatttccggccccatagcgctccgcggg
+gagaaactatggccttcatgacagcccccccataacatctaggtaatggtcggataacta
+taaacaaccctctccagagaactgtgaaaataaaatctcttagtacacaagcgtatactg
+gtttaagtcttgcccatcttaaagactcttttcactattttcttgatgcctcattcttct
+aatattaggtgattttttaatccgagaatataaaaagacgatagaaagtgttaaaacacg
+gcgtagcgacatattttaaagaaatgaaatactttttgactatccctcatgatctaaact
+tacgcggagctatctttttgtataacatgtacagagaattaatccgatgcttcttccgat
+taaggacatagcgccgaaaacgtcatggcggcttatcgatatcgtaacgcactataccaa
+gtgattaagtgatcaatgaatacgggtttcgggatttctgttaagtcatgcacggcaaat
+acttggagtcttgaataacgccgcgcgtagtacgaaggttctcaagctcgcgtgacgtat
+agaccgtattgctatttcctgccttctcaattgtccgaggattgctgataacttaaaata
+aggttgagtttttaataacgatttgtcgagtttgggaaaatcctcgtttgtgtgtttgtc
+attttcaagttatcaagaactacgggtataatttacgacgtaatgttggtttgatgcccg
+attgcgaatatcgtacgaatggtatttgtacaactgctttcctttatcgattgctcgaga
+acattataaagtctattactatggattaagactgtatacaagtgtttaagcggagcccgt
+gataatctataaggttttggtacctttatctgttacttttgccttgaaacatacatacgt
+acacgggaatatttacctaaacgccgtatagtccagcctcgtatttgggccgtgttttgt
+cagcattttaaactgaaagcgcccacttgcattataacccggtgcggaatctcttagtga
+ctcgtcaggagtttacgcctttgagacctctcgacaggacccattttgatctagtcgtta
+taggtagagtgcctttcctatcgcaccattaccttctagcaaacttagagtattcaatga
+aatcatatcctgtttatactaaatgttataggctaatgacacagctgacactaagaggtc
+tcttcgggttacccgaatgagttgtttatacgatgttgacaactcgggggagtcatttca
+atgaagactgaggactcttgatcagattaaaacgcttaatgactgataatttagattatg
+ccgtgtattatttaagtgggcgaaccctcccctagaatgggtttcctgagaaaagtctta
+gaacacagtattctgaatccagatgcaaatcgctaacgttagtaagcggctgtagctctt
+ggcagtttggtcaatagtcaatcgcaatccgtttaaccgtctactattcctagagcgaag
+agctatgttctgacacgtccccaatattaggcaaaggctccaaaagaacagtcaattgat
+taactacgggcttggtttctccgtgaatccttgcgccgctataccacataaaaggatagc
+ggtgataccacaagtttgcgacgttaaagcgtcgaccctcaacaagtacactagcaaccc
+cttagcaattaattttgtccatcactactgccaagagttgactggaccagttggaaatga
+catttgatatattaatagagctacatattgtaccactttactgtcacttacactaaccct
+agcgtgattactcatacatatattcgtaaattctaagttatgatactagttttgtaaatt
+taatcggcgaagacacgttctcttgtacgagcttcaactaaatatttcactgtagccaac
+cactttaaccagaaggataccttaatgccgatataatattgtccaggaaacgttaatact
+ttcacaagacaaagcttggaagaggtactttacgatcacctgatagatcgaccggaacga
+ttctatataggtttggtctgagaaatttgtagctaaaaccatgttccataggaactcctc
+tgtaatgggcaaaatgcagatagcgttcaatcgttgcttaactatctatcacagcatcct
+aactcctcaacagcttctttcctaaagacatcagcaggtaagttgacggcacccgataac
+ccagagcacgattggaatctaatactctgtatggatcattacgctaagtaaatataatga
+ttttctgactcaaagttacactgcgaattttatattaactggttctatttgttaaatacc
+acaacctctcgtcaacaggtcgcgatgcaagtgatccaaaaatatctaacttataccaac
+cattacttctggcgcagaaaaacatagatatctgaacaatcgaccgttaagactgtctcg
+ccgatcttaggaacctaatactgctcagtagttattgtttatttgggccatccccggatt
+atgtcagccatggaacactaaaagtcctaatctaacctatggacaaaaagctcactttta
+taaaattgctcaccttatgttgattgttatttgtccgaaatgtctataactcagtgtact
+atctattggaaaattatggccggagttttattgaatatacttttgtatgttgagaaagaa
+tgttgtcgtaataattatcagctggaaaatcatctaatatatattatattgagatattac
+gacagacctaagtgctttcccgtcatgagcagatggactaacactcttggtaatccttct
+cgttttagttggtaatgtttagtctaagtaatatcccgactcttacttactcagagcgga
+aatgactttttaaactaacgtttaaaggcacttagtatgcgtcagggttatttttttaat
+tacgtacccttgtgcagagagtttagctattcgatcctacttagtatgaaccatgagagt
+acaggttggtaattcacagagaaggtcgagaagattatttttgatgtttaccaatactat
+gaggcgtattcatcgaaataattttatggctgcgcacttcacatacgcaggaagaccact
+gcagcttgctagatctggatgtatcattgtacttctaagagcctgaaaggtaatacattc
+ccagcgagcgtaacagattgtatggggacatattcaatcttagcaatgcattcgttcttc
+gaaatcaggcatttttgatgtcataagttctgtcaactataaccctggaactttaatctg
+ttgttcgtcgaatcaaggatcaagaaagcttctaaaaggcccaaagcaaaacccaccact
+acttcagttttaaattagaatcacaccctagggtattagataataattaaatgtcttagg
+aagagatatcaaaagatgcagacatcctcaagtgaataagtctccggtctttcacaaaca
+catggttaagcgatgtggttttgactagagacgttcgccaccatcgtaatatttctggtt
+acctgcgaacgtgaaccaaatcttacttcatacattgcttaaacagtacaacttatctct
+tatcctatagagatctcaaaagtttgtatttttactggtttcaaattgagagaaaaactg
+cgttctccgatttctatattattgtttaaatgatgccaaacatccagtttaaaacacggt
+gtgatcagccgactcagattcgtatcctatgttagaatgagtcatcaaactacggtcacg
+cgtacattacagagtaaactacacgaatgaaagagataagaagatgaaagagttaatagg
+tctcctgttaattatgagaaccctaactactacggattggcctactagtgggttggaacg
+gatataaaattcgactaagttcgcggcatgtcaggctcctaaatatgaagagaactcggc
+atcgaattatccacagtaatagttggaacatgattcctctatgcatggtgtatatccacg
+tacgccagtgtgcagtgtagccatgcgaccacgggcgttgtgaatattcttcctcagaaa
+aggactgttgagcaaggaattggattctgtgaacggaatatagtcgagtagatggaattt
+cctacactgcgaaaaggtcatagtaaatcaaacgccgcgcgcagacatatcttcttggca
+attagtactccactaaatcaattggttataaacttttagaatatctttatataagttcac
+tacttacgctgcgggtagtatatttaaagtgatgtcttaggaatcttatggcggcggaat
+aaacggcttgactatagataccctaattctggcataaccctgtaacgtgtgaagcatgct
+ttaatagacgactagatcagcttatagaatggatatgactgccacattgaagagattaac
+attagcgggtataatgttacgaacttgtttaacaaaatagctctaccacacacgcatagt
+ataatataaaggtcctggagttcgctacgagcctggaattgcagttcccctaccctgagt
+aaacaagatcagtatggacctatcttctgacccacgtgtaaaaactaccgttagcggccc
+tgagaacggtgaagttgattatcggctaacactcgctttaccaaggaacaaacaattgat
+ggaacaggtaagcggctggattctatcctgaatacagcataataatatttgctttcaata
+tatagttatgacactcccaatatcactaactctttacaaatcggatatgaagagtgaatt
+agagatggagccgatcgttccttgtattctggtaagtactcgactaatgtgtgtagtcta
+ggggtaaaggtccttaaccgtcgagtctagaactcacgcattatgaaatcctccgagcat
+agagactctaaattcgccaagcaataagtcccgacgcgaaggatgagaagctcattgaac
+tgtaacatttacgtcgggctcaccatgttacatatgcagcgggtaaaagtttttgcctgg
+agtggttgagtttcgcgatacataaaaggccccactttcatatggtcaaatatctatatc
+gtgctttggacgactcgataaactaaagtagcctagtaatgccctaaaccgctgcatttg
+tgcaataaaaaatttagagtatatataacttccggacgtatggctgccttgaatcctcgg
+atatcgtccttatacaacgatgaacggtatagctcggaactatgcagattaggcgatcct
+tgggttgaatttttagtttccatagatatgagttagttttgatatggttaccatacgtcc
+ctgcattgaaacttaatctgtatattgattgatccttagcaatagcggcacatttctggg
+caatatgacttaattaggttacggtttttactatgatggatacgttttatatgatagaat
+aacagttgctatttaaacaggtactacattcaactaatactgtttcactattgtgtccaa
+catagggaatatattgcctgaatagatgtattatcaggcatcttttacgctccaggtaga
+actaattaaaaatgatccttagaaactttcaagcaacataagctaaaagttacgccaatt
+ataagccacatcggtaggatcttcaggcattcccatatccttctctatcaatcccgtctg
+ttgctaattggttatctaagcatatcgcggcgagcatctacgataggtataaagttgctg
+ctatctaattcgtcataatatatacatggaattacagattcatacgtcttcagtctcgtg
+gtgtttctaagagcggacccaagaattacgtaatatctctctcgtgttacccaagaagtt
+gacacgtgattgtcagctatctttttctggcgatgttaatagttataaacaattgcatat
+agctgcaaattagctaatcaaatactcgtttcttaaatgttatcagcaaagctttaggtt
+ctgtaatttcactgtgtaaagagggcgctaagttcaaaattggtttttggcaacaaacaa
+tttaatagcgcagtgcaaaaataatatctcagggtgtaattatttctctaattggtcttt
+acggttggaccaggcaatgggttttttatctatgtgataccaattaaaagtaatttcaaa
+gtgacattaaacttaagtattgctgtcaagaccattacgacacttcaccaacacatttat
+gtattgtgctacgcggtatggcccgtagtaatttctgatattgaccgcgttatcagcaag
+tacgctgtacaaatgccaaatttagtaaagctctgtgtgcattccaaggtgcccacatca
+cacattatcaacatatcatgtcgttgtattacgtccttttactagcctgggaaataccgg
+tgattcagagtgaacataaatctctgaaagctactagacaaagctagtatagttaaaata
+tatatttcttttaatattaggatctttgcgattgcacatttcaagcatcgcattaaccta
+cctccgtactcttctacaacggttgcatgtacgatttctatgcgatgaaatacttatgtt
+cttagtttggggttactttgttcacctagtcctcgaacgcaaattagcttcgaatatctg
+aaaagtgtatgcgggcaccaaaacgatctcgattcttaggtttataattatagtcagaag
+ataaatacatgcatatctggacactcttccacatgtcatgtcgactaactttgaactaca
+gtcatatatagactgttatctgatccgtatgtgtctattactactcttatctgagaaagg
+acccaatggagtcacagtaagcgatcatgtcatcggggctttttccctgattataagatt
+acactattgctgtgcttggggcctcctactttttctatcttaatcattttgtacattaaa
+aagctaagaagtaggtacaacttatctttcccatacgagctggaccattaatttaacagc
+cgcaaggcgagttttaatgttaatctggaagggctttatgttctaagcttttagcactga
+gaaattaatccgtaggaaattaatcccacataacccggtaagagaaccttacgccccgtt
+actaataatgttctgcgcaatgtaggaagtgacaagctcactcttgcgacgagctcctta
+atacaggccctgcgttatattcgaccgtacctataactagaccaccatcttaaatgtaca
+gttatggttttcgacgcatagagtatgggaccacctcgaaatgctcagctgcaaattgta
+ctgggggtggttatcaaacatttaatatgaatctatggtaaagtactagtttatagatag
+ccgaacactaaaggtttgcagaccttcctcccctgaggaacttcgtgtcacaaattagat
+tgagaaggtggtgataaaatcgcgtatctacaatgatttggtgcaaatatttatcgattg
+cccaatcgttctactcgtactctttatagcctaacgccttttcttggcgctaattagcct
+aatccaagaaggagtctaacaaaattacttaaccatactcttgtctattcggcccacgca
+tgcgcaagctcaaaaagttctcaacgggcgtttttacttgagtcccaggaggtaacattg
+gatctatgagtcttaacagtggaaatatgatttttagattgtgttcagatttattgtctt
+attttggtctatctcatcagctatagctacataatgacgtcttaactgtttcgactaacc
+ttcagatctgactaccccaaatacaacatagcaaaagaatgatgctaacgcttaactatc
+ctttcacgatcttaacaaaaaagctccatttaaaagaatcgaaaacagatctaccattcg
+tggaatcaatttttggacgagtactggtcgggtcgtgcttatttgctacaggattgtttc
+gtataacgttcaagcactttagcggttccatccttgatggcgttaactgatgatgcgtaa
+gtttatggtgatctaaaactctactacgaaccaggtcccagcacgaaacgtcatctttaa
+tgagtttttaggtctccaggcactaggctgcgaagtggaatatgtgtcatcagagacaaa
+tagatgattcctatagctttttgcagttaagccactaagtaggcggttctatagggtttc
+attcaaatcgatcgtaattcccgactctgcatagcgtgggtcttgtatagaccattcttc
+aggcccgccacaatggtttcaagtttcaacttccgtttattggctgtccctcaatagagt
+cgttctcagggcacgactctcgttcgttattcataagtccagtttgatccacgaatacag
+aacacgcatatctgataataaaagcttaacgataactttcacgcgcatggtttatttttg
+atttattaggcaaccaaataccagaatgtagtcagcgatatgtagtaaaatttagacaaa
+cataaaacaaagtatcgccattacagtctcctgttaggagaacctttttatcaatatgtg
+taggcgtgtattggcgcccttgatttaataataattacggctaaacgtattgatattttc
+caggaactgccccatctcatgagatgaccctaaattttattcacacctcatttttaattc
+ttttatatcacgattatttatctgagcaagcatctttgcaagcattcatagtgacggtgc
+tgtctctatgaatgcatgctaatatacggtgcgctaaacatattggttcaattcaatgta
+agctacctcggaatttgcttgcactaagacggggaagccaaaacggtaaatcgccgtata
+tgctagtgccaagggacttgtccgttggagtcactatggagttacaagcattataaatct
+aaggaaatcgcagtatcagtccttaccccaaagatacttcgcattccctggggtacggac
+catgaaatacttctttcatacatgataaacgatggagactcggttaccaccctggtagtt
+actccatcaattggagttaactaagatcgctattacaggctttattagccaatcatcaca
+agcctctttttagagattcacaagttagcaaaccaaagttcctttgataagtctttaacg
+agatctatcccaattccggctaggagtaaaatttatatatttgagatcggggttaaagtc
+acacgcaatgcaaggggtttttatatggtaatgtccttccctaattaggtaattttcaga
+cctccgagagagagtagatcaacaacgcgttatactcctaaaatgcttgtcgataacatg
+acactacagatcatccctggatgagcatcgactttcattacttgattagttcagttaatt
+cgtttcaaaccattttcaacaaaatcccccagtagatatgtatatgcacatcttagacta
+aataacagttttcataccctgggatttgtgtcactatctcaggaacgtcgagacgtcccc
+tatcaccgcagcgagggtaactggccctgttccattgtaatcgatgggacgggacgttat
+attgcagacccaaagtagtaataaattcagccatatggacggagggggggaattgttaag
+aatataattcgattttcagctgaatgtaaaagctccagccattcctcctccacttgacat
+tagttcgaagaaggtctgagaattggaattgcttgtgacgttttttgtttccagacaagg
+aaatagcccagtaccaagtataatattatgacaatagaagcttaaattcacaacgtaaca
+tatctgttagcatgctctaatagaccgagaaaataagtgtctatgtgtgcgagaactgtc
+aattcacggcagtagtcacctaatctaacgtctagttcccgactatgaagtcttcacaaa
+tggttagtaataatttcccagtggagtagaagtggcataacgtgcactctctgttaataa
+tacctttagactactcccatttcgccagaacgtcttgatggtaccctatgggaaacactc
+acacatgcttattgcctgcaacctcagcaatgtgtcgtatgcggtatttctacgaacagc
+tagtgaaaggactgatgacctaattttggtttctcaagtccagacgtgatattttgatga
+ccgtatctgacatctctgggcaattcggttaacctctggtacgaaatagtccgtcgcgta
+ggtaaaaatgataatgctgtcatcactatcatgttttagctaagctacactaccccatcg
+ctcgcacgtggcaaagtgtgaggattccgatatcatccatgtgtacgaattcctaatact
+cttgctcagggcacttagggttattgtagcctgtgttaccgtctcgcatattagatcatt
+aatcaacagtcttataatcaccgtaatcggtaaacagttgttatttgttctgataggtag
+acagctaataaagatgctgttgaacagttacgtcccacctttattgccctacagtgaaac
+tagttcttactctgttgctgtaatatgtctagggttattgatttgctgccacttcaaaac
+ggaaattaagtcattaacgaaaatggttccttcataggtaaagatcaatccccaattgaa
+gccagaaattttgagatgtcgattcctgatcattcgccaaatttacagctcgtaaacgag
+ttccatgtgtaaaaaaatgttgagtccactagcttgtttattctggctcaaggtacgtgg
+aacacgtagtattttgatactaatgccagacccgctacgatccctgtactgtgagcagag
+ccgatcctcagaaatagctaaatcttgtgcttcgttagaagtctcgactacgtgtagcct
+agtgtttgtgttgcgttatagtctatttgtggacacagtatggtcaaatgacgtcttttg
+atctgacggcgttaacaaagatactctgggcaacacacatacttctctcatgttgtttct
+tcggacctttcataacctttcctggcacatggttagctgcacatcacaggattgtaaggg
+tctagtggttcagtgagcggaatatcattcgtcggtggtgttaatctatctcggtgtagc
+ttataaatgcatccgtaagaatattatgtttatttgtcggtacgttcatggtagtggtgt
+cgccgatttagacgtaaaggcatgtatggatcttgatctatgcaaaggtaggtccatcta
+tatacgttgcacagcggatacaaataagataagaatttactaacatttaaattttcttat
+tgtcgagcatagattggaggaaaaacttatttacttggtatttaaacggaagtttctaat
+gtttatgattggatgcacggacagtttactgcttactttcttaggtttcttgaacaacag
+gatgcactagtaacatgtctcgttcatgcttccattaagttcttcttaaacttacacaaa
+ctacctaatttagagttgacgagatggttgaacgtgttgtgacaaacgtttgcaaaatgc
+acagtatcgttaccaaaaagtacatttaagtgtgtgcgtaggaattctgctacgtccatt
+gcaggccacattcacatcccacccctgaatatatggactgaatcacacacaccaaatttc
+atctaccttatcgtagcataactattaacaaacatatacagacttcgcggtaaataaaat
+atattagtacacaaccgtatactggttgaactattgcccagctttaagacgcttttaact
+aggtgcttgatcaagaagtattattatatgacggcagtgtgtaatacctgaatagatata
+gacgttagattgtctgaaaacacgccgtagagacatttttgttagatatgtatttctttt
+tgacgagccagcatcttagtatctgaagacgagctatatgtttgtagaaaatcgactgac
+attgtatacgaggcggcgtaagattaaccaaattccccagaattagtaatggcgccttat
+cgatttactaacgatatataacttgtgatgttgtctgcaatgtatacccgtgtaggctgt
+gctcttatcgaaggaaacgcattgaagtccaggctggatgaaaccaccgcgtacttccat
+gcgtctatacatagcgtcaccgatactacgttttgctatgtaatccattctaatgggtaa
+gaggattcctcttatagtaaaatatgcttgactttttaagaaccattgggagtggttggc
+aaaataatagtgggtgtctttctcagtgtatagttttctacaactacccctattaggtta
+caagtaatctggctttcttgccacttggcgatgatagttagattcgtatttctacaacgc
+agttactgtatccatggcgcgagataattagatacgatttgaatttggatgtagactcgt
+tactactgttgtagaccagcacgtgagtatctagatgggtttgctaccttgttagcggac
+ttttgccgggaaaaagacatacgtacaaccgtatattttactataagcagtattggccac
+cctcgtattgcggcagggtgtgctcacctggttaaaatgaaagagaaaaattccatttta
+aaacccggaggaatctattactgacgaggaaggtgtttaacccgttgagacatctcctaa
+cgtaaaaggttcatattctagttattccgagagtcactttcctatccaaacatgaactga
+tagcataatgacaggttgaatggaaagcatatcctgtttattctaaatctgtttcgctaa
+tcaatatgctgtcacgaactcggagcttacccttacaactatgtgttctgtttaccaggt
+gctaatatcccggcactcttttcatgcatgtcgctcctagcgtcatctgatttaatagct
+taatgtctcatattttacagtagccagtgtagtatggaaggcggcgaaccagcccctaca
+ttgggtttcctgacataagtattacatatcacttgtctgattacacagcaaaatcgctaa
+ccttactttgcgcatgtagctattggaactttgggctagtgtctatcccattaagtttaa
+cagtagactagtccgtgagcgatcaccgagcttatgtctcgtacccaagttttggatttg
+gatcaaaaactactcgatattcatgatctacgggcttcctttctccgggtatcattgcgc
+cgagattaaaaataaaacgatagcgctgtgaaaacatgtttgacacgggatagcgtagaa
+actaaacaacgaatagaccatccaatttgaattttattgggtccagcacttcgccatagt
+gttgaatggtaaagttcgaaaggaaatttgttatattaattctgctacattttcgaccac
+ttgtatctcaaggacaatatcccttgaggcttttagcagaaagagatgccgtaattctaa
+gggatgataataggttgggaaatttaagagcagtagtaacggtcgcgggttcgaccttaa
+actatatatttaaatctagccaaacaagttaacaacaaccataaagttatgaccttatta
+tattggcaagcttaacgttttaattgctctagtaatagagtggtagaggtaagggaccat
+cacctgattcttcctccgcaaccattatatagacgtgtcgtctgacaaatttcgagataa
+aacattcgtccttagcaacgaatatcgaatggcaattagccacattgagttaaatagttg
+aggatatttcttgcacagaatcagatctaatctaatgattcgttactaaacacttcacca
+ggtatcgtgaaggctcaagattacccagagaacctttgcaatataagaatatgtatgcag
+cattaccctaagtaattatattctttttctgactcaaagtgacaagccctagtgtatatt
+aaatcggtatatttgggaaattcctcaaactatcctaatcaggtagccatgaaagtgatc
+aaaaaagttcgtacttataccatacatgaattctggccaagtaaaaaatagattgcgcaa
+aattcgtaccttaagtctctcgccaagatattaggatcctattactcatatcgtgttttt
+ctttattgccgccatccccggagtatctcacccatccttctcttaaaggcctaatattac
+ctatgcaaataaacatatattgttgaaaattgagaacctgatcgtgattcttatgtgtac
+catatgtatagtaatcacgcgactatatagtgctttagtatcgcccgtgggtgagtgaat
+attctgggctagcgtgagatagtttcttgtcctaatatttttcagatcgaatagcttcta
+tttttgtgtttattgacatatgtcgaaactccttactcagtgaaagtcatgaccagatcc
+acgaacaatcttcggaatcagtctcgttttacggcggaatcttgagtctaacttatatcc
+cgtcgcttactttctaacaccccttatgtatttttaaaattacgtttattcgaacgtact
+tggcggaagcgttattttttgaagtaagttacattgggcagactcttgacattttcgata
+cgactttctttcatccatcacaggactcgttcgtattgatatcagaagctcgtgatgatt
+agttgtcttctttaccaatactttgaggcctattctgcgaaatttttgttgccctgcgaa
+cttcacataccaaggaacacctcgcaacatgccttcatatccatcgttcattgtaattct
+tacacaatgaatcctaagtaattacatccctgcgtaaaagatggtaggggcactgaggat
+atattaccaagcatttagttatgagtaatcagcaatgtttcttgtattaagttctctaaa
+atagttacatcgtaatgttatctcgggttccgcgaataaacgagatagattcattatata
+tggccctaagcaaaaacctcctcgtattctgttggtaattagaatcacacaatacgggtt
+gagatattaattatttgtagtacgaagagatataaaaagatgaacaattactcaagtcaa
+gatgtatacgggatttataataaaaatcgggtagagatctgctttgcaattcagacgtgc
+cactaaatcgtaatatgtcgcgttacatcagaaagggtaactattattaattaataaagg
+gcttaatcactacatattagatcttatccgatagtcttatctattcgttgtatttttaag
+cggttctaattcagtcattatatcagtgctccgagttctttattattgttttaaggatga
+caaaatgcctcttgttataacgctgggagaagcagactaagagtcggagcagttggtaga
+atgaggctgcaaaagacggtctcgacgaatggacagactttactaaaccaatgaaagaca
+gaagtagagcaaagtctgaagtggtatcagcttaattatgacaacccttaatacttccct
+ttcgccgaatactggcgtggaaaggttttaaaagtcgaagtagttagaggcatctctcgc
+tcataaataggtagactactcgcaatccaatgtgactatgtaatactgggaacatcagtc
+cgcgatgcagcgtgtttatcaaccgtccccactcgcctggggagacatgagaccaccccc
+gtggggattattagtccgcagtaatcgactcttgacaatccttttcgattatgtcatagc
+aatttacgacagttcagcgaagtgactactcggcgaaatggtattactaaagcattcgaa
+cccacatgaatgtgattcttggcaatttctaatccactaaagcttttccgttgaatctgg
+ttgtagatatttatataagttcactaattaagatcacggtagtatattgatagtgatgtc
+tttgcaagaggttggccgaggaatttacggattctctattgatacaatttgtctggctta
+taactcttaaggctgaaccaggcgtttttagacgacttgatcagctgttagaatggtttg
+gactccctctttcatgtcagtaacatttcagccgttattgttacgatatgcttgaacaat
+attgatctaccacacacccatagtatattttataggtcatgctgttacctacgagcatgg
+tattccacttcccattcaatgagtattcaacatcactagcctcagagatgatgacccacc
+tctaataacgtcacgttgcggccatgtgaaacctgaacttgagtagacgatatcaagcgc
+tttaaattgcatataacatttgagggtaaagctaagcggatgctttatataatcaatact
+caataataagatttgattgcattttagagttatgacacgacatagttcactaacgagtta
+ctattcccagatctagactgaagtactgatcgagacgatccttacgtcgatgatcgttag
+ttatcgacttaggtcgggtctctagcggtattggtacttaaccggacactatactaataa
+cccatgatcaaagcataacagaatacagacgataatttcgccaacatatatgtacagacc
+ccaagcatgagaagctcattgaaagctatcattgaagtcccgctcacaatgtgtcttttc
+cagacggtttaactggttcccgggagtcctggagtttcgacttacataaatggaaacaat
+gtattttgctaatttatctatagcgtcatttggaccaatacagaatattatgttgcctag
+taatccactataacccgcaagtgctgatagaaaatttttagacgatttataaatgcccca
+agtatccctcccgtgaatcctccgttatactaattagtattcgttcatacgtataccgcg
+catatatgaacatttggcgataaggcgcgtgaattgttacgtgacagagatagcagtttc
+ttgtgatatggttaacagacgtacatgaagggaaactttatatctatagtgatgcttccg
+tagaaataccgccactggtctgccaatgatgaagtatgtagctttaggtttgtactatga
+ggctttcgtttgtttgcagagtataacagttgcgagtgaaaaaccgacgaatttatacta
+atacgctttcactattggctacaaaatagggaagagtttcaatcatgagagggagtatat
+ggatgctttgtagctaaaggtagaacgtatgtatatgctgccgttcattcttgaaagata
+cataagcgataagttacgacaattataagcaacatccctaccttcgtaacgatttcactg
+ttactgcgcttgaaatacactatggggctattggcggagagaagcagatcgcgccgagca
+tatacgagacctataatgttgatgatagagaaggcgtctgaattgatacatcgaagtaca
+ctttctttcgtagtatctctcgtcctctttctatctccggacacaagaattaagttatat
+atatagagtcttaccaatcatgttgaatcctgattctcagagttctttggcgggccttgt
+gatgactgagaaacaatgcaatattgctccaaatttcctaagcaaattctcggttatgtt
+atgttatcagcaaagcgttacgttatgttatttaaatctggaatgacggagcgaagttct
+tatgtcggtgtgggaataattcttttgaagacagcactccttaaataatatcgctccgtg
+tttgtatttatcgaatgggtctgtaaccttgcacaagcaaatcggtggtgtatatatcgg
+ataacaattaatacgatgttcatagtgacagtatactgatcgagtcctctaaagtcaatt
+acctcacttaacaatctcattgatgttgtgtcattcccggtatcgcccgtagtatgtgct
+ctgattgaccgagtgtgaaccaaggaacatctactaatgcctttgttaggtaagatctct
+ctgaattccttcgtgccaacttaaaacattatcaaaatttcttctacttggattaactac
+ttttacgagcatggcaaattcccctgtggaagacggttcattattatcggaaaccttata
+gaaattgcgtgttgactgaaattagatttttattgtaagagttgcatctttgcgattcct
+ctggtctagcttccaatgaacagtcctcccttctattcgacatcgggtccttcgtacatg
+tctttgcgatgtaataattaggttcggagtgtggccttaatgggtgcaactaggaataca
+acgcaaatttgctgacatgatagcaaatcggtatgccggcaccaaaacgtgctccttgct
+tagcttgtgaatgagactcagtagttaaataaatccatatctgcaatcgattccacaggt
+attgtccactatctttgaactactctaagagatacaagcttagctgagaccgaggtgtat
+atgactacgctgatatctgtaaggtaccaatgcaggcaaagtatgcgagaagctaatacc
+ggctgtttccagctttataagattaaaatttggctgtcctggcggcctcagaattgttct
+atcgtaatcagttggttcattaattagctaagtacgaggtacaacttatctgtcccagaa
+cagctccacaagtttttttacagccgaaacccctgtgtgaatcttaatatccaagcgcgt
+tatctgattagagtttacaactcagtattttatcagtacgttttgtttccaacattaccc
+ggtatgacaaaatgacgccacgtgtcgaataatggtctgaccaatgtaggaagtgaaaag
+ataaatattgcctacacatactgaattcaggcaatgcgttttattcgaaaggtcatataa
+ctagaaaacatgatgaattcttatcggatccttttactagcatagtgttggcgaacacct
+cgtaatgctcagcggcaaattggactgcgggtccttatcatacattttttttcaatatag
+gcgattggtctaggttagtgattccccaacacttaaggtttgctgacattcataccctca
+gcaacttcctctcaaaaattagagtgagttggtggtcttataagaccgttgattatttga
+ggtggtcaaatgatggtgcgatgcacaaatcgttataatcgtactctgtagacaataacc
+cattgtagtgccgattttgtgcataatacaagaaggaggatataaaaatgacttttcaat
+aatattggctattagcaacaagaaggagaatcctcattaagttagcaaccgcagggggta
+ctgcagtccaaggaggtttcattggagagagcagtatgaaaacggcaattatgattgtga
+gattcgctgaagattgtgtctctgattttcctagatagaataagctatagctacttaatc
+aactcttaactgtggagactatcctgatgatctgaataccccatttacaaaattccatat
+caatgaggctaacgcttaaatttcatttctccatcgtaacaaaaatcagcctttttatac
+aagacaaaacactgcttccattacgggtagcaatggttgctcgactactggtagcgtcgt
+gatgtggtgataaagctgtcttgcgtttatacttaaacaaattttgacctgacataatgg
+agcgacttatcggatgttgccgatctttagggtcatctattaagcttatacgaaaaaggg
+acaagcacgttacgtaatctggtaggactgggtacctagaaacgcaagaggaggcgaact
+ccaatatctgtaagaacagaaaaatacaggagtccttttcatttttcaagttaacaatat
+aagtaggagcttagagaggcttgcatgaaaatcgttaggaattacagaataggcagagag
+tggggcgtgtagactacattcttcaggccccacaatatgggttataggttaaactgcact
+ttttgcgatctcccgaaatactgtcgttctctgcgaaccacgctcgttccttttgctgta
+gtccacgttcatccaactattcagataaacaagatcgcagaattaaagcttaaccatatc
+ttgatagcccatcgtgtatggggcatgtatgtgcaaacaaaagacctcaatcttgtctgc
+gagagggaggaaaatttagacaaacataattcattctttcgactggacacgctaaggttt
+ggacaaactttgtatctatatctggaggcctgtattccagcccttcttttaataagattt
+acggcttaaactatggatatttgccaggaaatgacactgctattgacaggaacataattt
+tgattcaaacctcattgttaattattttatatctcctgtttttatatcagaatgcttctg
+tcctagaaggcatactcaaggtgagggctcgaggaatgaatcataatagaccggccccta
+ttaatattggttcaattctttcttacataacgcggaatttgattgcacgaacaccgggaa
+cacataaccgtatagcgcccgttatgctagtgcctagcgactgggaccgtggagtctata
+tcgtctttctaccattattaatctaaggatataccactttaagtcctttcaactaacata
+aggcgcattccatgcgctaaggaccttgaatttattatttcttacatgataaaagatcga
+gtcgacgggaacaaaaggctacgtactcaataaagtgcagtttactaagagccctttttc
+tggcttgtggagactatcataacatgaagatgttttgacattcaatagtttgcaaaacaa
+acttactttgtgtagtattgaacgagatctttccaattgccccatagcaggaatagttat
+atattgcagatcgcggtgtaacgcactccaaatccatcgcggtgtgtgagggtaagcgac
+ttaaagaattacggtttttgatcaaagcacagtgagagttgagcaaattacagttatacg
+acttaattcagtctccataaattgaaacgacacttcttaacgggaggaccagacacgttc
+attaagtgaggagtgcactttttgactttaaaaacatggtaatcaatttaaaccacttga
+tatgtatatgaacagatttgaagttatttctgttttaatacactgggagttctgtcaata
+tcgcaggaaccgcctgacgtcccctatcacacctcagagggtaaagggacaggggaaagg
+gtaatcgaggggtagggaacgtagttggcacacccaatggacgaataaatgctgccatat
+ccacggagggcgggattgcggttgattttaaggcgatggtaacctgaatgtaatagatca
+tcaaatgcctcctccactggaaattactgcgtacatccgctgagaattgcaatggagtgt
+ctcggtttttctttaaacaaaaccaaattgacaacttcatagtataatttttgcacatta
+caagcgttaattaacaaacttactttgctgttagctgcctatatttgtccgacaatataa
+ctggatatctctgcgagaactgtaaattaacggcacttggaacataatagttcctattgg
+taacgacgttgtaggcggcaattatccggtggaagaattgacaactgcagttgaactgca
+tgaaagtcaaatctctcgtaagtataactttagaagactccaaggtacccagaacctctt
+cagcggacacgatcgctatcaatcaataaggattattcactgaaaccgctcatatctgga
+ggtggacgtttttcttcgaaaagcttgtcaaaggactcatcaaatttttggccgtgctaa
+tcgacacacctgttattttcatgaccggataggacatctcgcggaaattcgggtaacagc
+tgggtagatataggacctcccctacgtattaatgataagcctgtcataactagcttggtt
+taccgaagagacaataaacattcgagcgctcgtgccaaactcggtgcattacgtttgaat
+aaatcggtaacatgtactattactctgcctaacggcacttacccgtttgggtccatgggg
+taaccgctcgatgttgacagaattatgctaaagtcgtttaagatcccgattaccgaaaat
+ctggttatgtctgagcattcgtacactgcgtattaagatcaggttgaacaggttcctaac
+aaattttgtgacctaaagtgaaactaggtcgtactctgggcatgttttatgtcgtggcgt
+atgcatgtgctgacacttctaaaaccaaattaaggctttatccaatatgggtccttaagt
+gctaaacatcattcacaatttcaagacagattgttggtcttgtcgattccgcatctgtcg
+ccaaattgacacatcgtaaaccaggtacatcggtaattatatgttgactaaactaccgtg
+tgtattctggctctaggtacggcgaacaagtacgatgtgcttaagaagccctcaccccag
+acgagcccgcgtaggtcacatcagcagatcctaagtaattccgttttattgtcctgaggg
+agtaggatcgacgaactctacaagtcgctttgtcgtgccttataggctatttcgggtcaa
+tgtagcgtcaaatgaactattgtcatctgtacgagttaactaagtgtctatcgccaacta
+aaagacgtctcgatggttctttatgcggacctgtcatatcattgactggcacttgcttac
+atccaaataacacgtttgttagcggatagtcgttaagtgtgcgcaagatcatgaggcggg
+gggggtaatatttcgccctctacatgataaatgaataagtaagaagatgatctttttgtg
+gcggtaccttaagcgtactcctgtcgacgagttactactaaaggaatgtagggttctgga
+tctatgaaaagcgacctccatatatatacgggcctaagcggagtaaaataagtgatcaat
+ggactaacattgaaatgttagtattgtcgaccattgagggctggtaaatcttatttacgg
+gcgtgggaaaacgaacgtgatatggtttagcatgggatgcaagcactcgttaatgcttac
+tttagttggttgcgggaacaacaggaggctatactaactggtagcgttcttgcttccatt
+atgttattattataattaaaaataagacatatggtagagttgtagtcagggtggatcggg
+ttgtctataacgttggaataatcaaaactatcgttaacaaaaacgaaatttaagtcggtg
+cggtggaatgcgcctacctcatgtgcaccacacattcacagcacacccctcattataggc
+aaggaagcaaacaaaaaaaagttaatcgaccgtatccgaccttaaattttaaaataaata
+gaaacacttagcggtaatgaaaagataggactaaaattcactagtatcctggaacgaggc
+aacagagttatctagatggtaacgaggtgctgcatcaagatgtatgatttttggtccgct
+gtgtggaatacctctattgatatacaagtgactttctcggtaataacgcacttcacaatg
+tgttgtttcttttctatgtattttgcaagagaaagaagcttagtataggtacacctcaga
+gatgtttcgtgtaaatcgtatcacatggtataactgcaggaggaacattatccaaattca
+ccacaattactaatccacccttttacttttactaaagatatattaattctcatgttgtct
+gaattgtataacccggtaccctgggagcgtatcgaaggataccaattgaagtcctcgagg
+catgttacaacacacgacttccttccgtctattcagacactcaacgagactaacttttcc
+taggtaatcaatgatattgggtaactcgtggcatcttatagttattgatccggctctttt
+gtagatcctgtgcgactcgtgcgctaattaagactggctctcttgcgcaggggatacgtt
+tattctacgtacccgatttggttactactaagcggcctttcttcaaacttgcagttgtga
+cttacattcctatttcttcaaagcagggaagggttacagggagagacttattgagatacg
+attggaatttccatgtacaatcgttaatacgcttgtagaccagcaactcagtatagagat
+ccgtttcctaaagggtgagcggtaggggcaaggcaataagaaattactaaaaccctagtt
+gttaatataagaacgattcgaaacaataggattgcccaagggggtgcgaacatggtgtaa
+atcaaagagaaataggcattgttaaaacccgcacgtttctagtacgcaagaggaacgtcg
+gtaaccagttctcaaagatcctaacctaaaaggggcttattctactttttccgacactca
+atggacgagacaaacatgaacggatagctttaggtctcgttgaatgcaaagaatagaatc
+gttattattaatcggtttccattatctatatgcggtatagatctccgagaggaccctgta
+aactagctctgcggtttaactggtgctaatagaccgccactatgttattgcttctagctc
+ctagcgtcttatcatgttatacattaatgtcgcatattggacagtagccaggcttggatg
+gatcgccgacaaaaagaaaagactttccctgtaaggacttaactattacatataacttgg
+atcattaatctgcaaattagagtaacggtctttcaccagcttcatattccaacgtggcgc
+tagtcgatatcccatgaagtttaaaactagaattggcagtctcacttcacagtgcgtatc
+tatacgacaaaagtggtcgatttgcataaatatcttatcgatattcaggttattaccgat
+tccttgctaacgctagaagtcacaccagagtaataataattccagacacctgtgaaataa
+tcggtcactacggatagactagtaacgataatacgtatagtccataaaagttgaatttta
+ggggctaaagatattagcaatactggtctagcctaatcgtcgatagcaaagggctgtgag
+gatttctcctacattttcgaccaattgtatcgataggaatagttacagtcacgcttgtag
+atgtaagagatgacgttattcttagggttcttaagtcggggggtaatttaagaccactag
+taaaggtagaggcgtacacagtaaacgatattttgaaatcgtcaaaaaaaagtttacaac
+atcctttaagttagcaactgattttagtggcaaccttaacggttgaattgatctactaat
+acaggcctacaccgaagggtacagataatgattcttactaccctaacatgatagagtcct
+gtcctatctcataggtcgacattttaaattcgtaatgagcaacgaagatcgtttcccaat
+ttgcaacattcacttatagacttcaggttatttcgtgctaacattaagatagaatataat
+cagtcgttaagaaactattatccagctttcgtcaaccataaagattaaaaactgaaactt
+ggcaagatatgaatagctatcctgctttaaccgatcgtatgagatgctttgtagcaagaa
+aagtgactagcacttgtgtttagtaaagcgggagagtgcggtaattaatattaatatact
+attaagctacacagcaaaggctgcaataatgttagtaagtagaacataaaggtattctcc
+acaagtaataaatagtgtgagctaattgactaacttaactctcgcgacaagtgatgtgga
+taagatgactcatatcgtctttttctgtagtgccgacatcccacctggatcgaacaattc
+cttctagttatcgactttgattacctatcctattaaacagatagggttgtaaagtcagaa
+aatgatcggcttgcgttggtctaccatagctagagttagaacgcgtagatagaggccttt
+tgttgccaacgtgggggtgggatgagtctgggcgagcgtgactttctttcgtgtccgaat
+ttgtttaacatccattagattagatgtttgtgttttgggtctgatgtcctaactactttc
+tcagtgaaactaatgtcatcatccaagtaaaatagtccgatgaagtctccgttttcggcc
+gaagcttgtctataacgtatataaagtcgctgaatttagaacacaccttatctatgttgt
+aaagttactttattccaaaggacgtgcacgaagcgtgagtgtgggaaggaacttaaagtc
+ggatcactcttgtcagtgtagataagaatttctttcatacttcactggaatccggcgtat
+ggatatctctaccgcgtcatctggtggtgtctgcggtaaaaagtcttgctgcacgagtct
+gagaaatttttggtgccatcacatcgtaactgtacaacgaacaaatagcatcaggccttc
+ttatccagcgtgaagtctaattatttcacaagctttcctaagtatgtaaatccctcactt
+aatgatgcttgcgccaatgaggatagaggacattgcatgtacgtaggactattctccaag
+gggtcttctattttgttagcgaaaattgttacagcctaatgttagagcggcgtacgactt
+tataccagatactttcattagatatgcaaatatccaattaaatcatagtagtatcgtggt
+atggacaatcaaaaaagacccgttgtgatatgatgtttttctagttcgttctcatatata
+tagatcaacaatgaataatctcatgatctataaccgatgtatatttatattccggttgac
+tgctccggtgcaattcactacggacactaatgactaatatggcgcctttcatcagaaacg
+ctaaatatgattaatgaattaagggagtattatctaattattagagagtagcagttagtc
+tgatattttcggtgtatgtgttagccgttataatgctgtctttttatcagtgagaacagg
+gagtgtgtagtgttgtatgcttcactttatgactctggttatatccctcggagaacaaga
+ataagagtacgagaagttcggtcattgaggatgaaatagaaccgctagacgaatggactc
+acgtttataaaactatgtatcacagtactacagctaactctgaagtccgagaagcttttg
+taggacaaaacgttataagtacctttcgcagaatacggccgtgcatacctgttataaggc
+gtagtagggacaccatgctatccctcatatagagctacactaataccattacatggtgac
+tatcgtttacggccatcatctgtaagcgatcatgcctcgttagcatccgtacaatctcgc
+atggcgtcactgcagaaaaaccccgtgcggattttgagtcagaactattcgaagcttctc
+aatccttttccattatggcatagcaagtgacgactcgtcagccatgggaataatagcact
+aatccgattacttatgaattagaacccacatgaatgtgattctgcgaattgtctaagaat
+ctaatgattttccggtgaatatggttgttgttatttattgaacttatattattaacatca
+cccttcgttagtgatagtcagctatttccaagaggttccccgagcatttttaccattctc
+tagtcatacaagttggagcgcttttaaatctttaggctgatcaaggcgttttgtctagaa
+ttctgcagatgttagattcgtgtgcaatccctcttgcatgtcagtaacaggtcacccgtt
+tttcgttacatatgctggtaaaatattcatagtaataactacaatacttgatttgttacg
+taatgctcgtacataacacaatcgtattccacggaacagtaaagctctattattctgatc
+gagcctaagagaggatcacactacgctattaaagtcacgttcacgaaatctcaaacctca
+actgctggtgaccagttatagacagtgtaattccatattacatgtcaggcttaagctaac
+ccgagcctttatataagctataatcaagaattagattggagtgcattttagacttatcta
+tcgaaatagtgatagtaagagtttatatgacctgatctagactgatgttctcttccacaa
+cagccttaaggcgtggagcctttcttatactattaggtcgcgtcgagagccctattcgta
+atgttaacgacactagactaatatacaatgagctaagaataacacaagtcacaagataat
+ttacaaatcatatatctacagtccacaaccatcactagcgattgcaaagcgttattggta
+ctaccgctctaaatcggtatgtgcaagacgcgttaactggttcaagcctctcctgctcgt
+gagactgaaagaaatcgaaaatatggatgtgcctaattgttcttgtgagtcatgtgcaac
+tatacagtttagtttggtcaagactatgcaactattaacagcatgtgcgcattgaatatt
+tggtgtcgattgataaatgccccaacgttccatcacgtctataagccgtgttactaatgt
+gtattagtgcatacctattcagaccatagttcaactgttggactgaaggcccgtcttggg
+gttcgtgaatgagagtgcagtttcttgtcttttccttaactgacctaaatgaaggcaatc
+ggtttatctagagtcatgcttaaggtgaatttcagccaatgggctcccattgagctagta
+tggtgctttacctttgtaagtggtggctttccttggtgtgctgactttaacacggcagag
+tgattatccgaagaatggataataagacgctggcaatattggctaataaagtccgatgag
+tttcaatcatgactgcgaggagatccatgcggtgtacctaaacctacatcgtatgtattt
+gctgacgttcattcttgatacataaagatccgatatcggtccactttgtttaccaaaagc
+cctaccttcgtaacgatggaaatgtgaatgagagtgaaatacacgatggggatattgccg
+gtgagtacaagttagaccacacattagaactgacctatattcgtcatcatagagatggag
+tatgaattgattctgcgaagtacactggctttacgagtatctagacgccgcggtatatct
+cccgtcaatactatgaaggtatatatatagaggctgaaaattcatgttcaatcctctttc
+taagagtgagtgggagccccttctgttgtcggagtaaaaaggcattattcctcaaattgt
+cagaagcaaagtatacgtgatgtttgcttagaacaaaagagttaccttagggtaggtaaa
+tctcgattcaccgagagaagtgattttggcggtgtgcgattaattcttttgatgacagat
+ctcattattttatatagctccctctttgtatttagagtttgcgtaggtaacctggcaaaa
+ccatatcccggggggagagtgcgctgaacattttatacgatgtgattactcaaaggataa
+ggttcgaggcctctatactcatggaactatcttataattataatggatcgtggctcattc
+cacctatccaaacttctttgtgatctgatgctacgagtgtgaacaaacgtacatcttcta
+aggaatttgggacgtttcatagctcgcatttcattcctgaaaacttaaatatttttaaaa
+attgattctactgcgaggaactaaggtgtagacaagcccttagtaaccggtggatgtcgc
+ttcagttttatagcaaacattattcaatttcagtcttgactgaaattagtttgttagtgt
+tagaggtccatatgtcacatgcatatggtctagatgccattgtacagtaataccttagat
+tagtattagcggcatgcgtacttggatttcacttgtaagaatgagcttaggacggtcgcc
+tgtagggctgcaaataggaatacttacaatttttgatgacttgttagcatatcgctatca
+cccataaaaaacctgatacttgatgagcgggtgattgagactatgtactgatataattca
+atagctccaatagatgaaacagctatgcgcctatttatgtcaaataatcgatgtgataca
+agcttagagctgaacgagcgcgagtggaattagcggtgatctctatcctaaaaagccacg
+aaatcgatcccagaagctaatacccgaggtgtcaagcttgagttcagttaaatttgcatc
+tcatgccccacgaagaatgggtagagagtttgaaggtgcttctggattttcctaagtacg
+tggtaaaaatttgatgtaaatgaacacctcctaatggttgtgttaaccacaaacccctgg
+gtgaatctgattagccaacccagtgatctgatttcagttgtcaaatctcttttttataac
+taccttttgtttccataatttaaccggatctcataatgaacaaacgggtagaataatggt
+agcacatagcgagcttgtctattcagaaatatggcctactcagaatgtattctccaaatc
+agtgttatgcgaaacgtaattttacgtgtaataatgatgatttcttatcggttccttgta
+ctacaatactcttgcccaacaaatactaagcataacagcaaaattcgaatccccctcctt
+ttaataaatggtttttcaatatagccgattcgtattcgttagtctttcaccaactattaa
+cctggcatctaattaataaaatcaccaaaggactctataatatgacagtcacttcggcct
+cttttaagacagttgattattgcaggtccgcaattgatggtgacatgcacaattagttag
+aatccgactatggagacaattaacaattgtagtgcccatttggtccagttgacttcaacc
+acgagttataaaggtattttaatttatagtcgatagtaccaacaacaagcacaatcataa
+ttatgttagaaaacccagggggtaatgctctaaatccagctttaaggccagagtgcacta
+tgaaatcgccattgatcattgtgtcattcgctgaacttggtgtctaggaggtgccgagtg
+agaatatcagataccttatgaagcaacgattatatctggactagatcatgatgatcggaa
+taaaacattgaaataagtccttatcaaggagcataaacattttatttaatttatacttcg
+taaataaattcagaattttttttcaagacattaatctgagtaaatgacggctagaaaggg
+ttcctactcgaatcgtagcctacgcatgtgggcagtaacctggcttgcgtttttactgaa
+acaaaggttcaccggaaagaaggctgccacttttagcttcttgacgatctttagcgtcat
+atttttagattagtcgaaaaacggaaaacaaacttaacgaagctggttgcacggggtacc
+gagaaaccaaagagcaggacaactccttgatcgggaagaactgaaatagacagctgtcat
+tttcattggtcaacttatcaatataacgaccaccgtagtgacgcttgcatgaaaatactg
+aggatgtaaactatagccagtcaggcccgcgtgttgactaattgatgaagcaaacaaaat
+agccggtattcgttaaaaggaacgggttgccagctacagatatactctaggtatatccca
+aacaagagacgtcctttggctgttgtaatcggtcataatacttgtcacataaacaagatc
+gctgaattaaacattaaacagttagtgatacacaatcgtggttggggctgggatgtgcaa
+taaaaagtcatctatcgtctatcacagagcgacgtaaatttagacaaacattattatttc
+ttgacaatggaatcgataagcgttcctctaacttggtatatatatctcgaccccgggatt
+ccagccattcttgtatgaagatttaaccatttaactatgcatagttgaatggtaaggaaa
+atgatattgactgcaacagattttggatgcaaaaatatttgtgaattattggttatatac
+tggttgtatagcacaatcattaggtcctagaaggcatactcaacctcagcgagagagcta
+gcatgcataattgtaccgcccatattaatattcctgaaatgatttcttacattacgccca
+atttcagtcatcgaacacccccatcaatttacccgatagagaacgtgatcatacgcaata
+ccctatgcgaacgtccactctatagcgtctgtatacaatgattattcgttccatttacaa
+cgttaagtaatttaaacttacataaggacaaggaaatccgcgaacctcctggaatgtatg
+agttatttatgcagttaacttcgtctcgaccggaactaaaggcgtcgtacgaatgaaagg
+ccacttttagaagagacctttgtatccattgtggagaatatcataaattcaagatggggt
+gtcatgctattcggtcctaaacattcttaatggctgttctattgttagtctgatttaaaa
+tggaaccatagcacgaatagttagatagggctcatacccctgtaacgatctacaaatcct
+tccccgggtgtgtgcgttagcgacggaaagttttacggtttgtgatcaaagaacactcac
+acgtcagattattacactgatacgaattatttcagtcgacagtaattgaatagaaactta
+ttaacgccagcacctgacacggtaagtaaggcaggtctgaactgtttgactgtaaaaaaa
+tggtaatatttttaaaaatcttgatttctatatcaaatgatgtgtagttttttctctgtt
+attaaaatcccagtgcgcgaaatttagatcgttacgactcacgtacaagatcacacatca
+cacgcgttagcgaaagcggaatggctaatacagccctacgcaacgtagtgggatcaacat
+atggacgaatttatgctcaatgagccaacctcccccgcattgcggttcattttaaggcct
+gggtaacatctatcgtttagataatcaaaggaatccgactatgcaattgtctgacttcat
+ccgctctcaagtccaatgcaggcgctacgtgtttctttaatcaataccatattgaaatcg
+taatacgataattgttgctattgactacaggttatgaaaaaacttactttgcgggtacat
+gcatatttttgtaccacattattacgcgatatctctcagtgtactctaaattaaaccctc
+ttcgaacattttagttcctattcgtaaacacgtgctacgcggcaatttgccggtcgtaga
+atggacaactccagttcaactgcatgtaactcatagctcgcgttagtataaattgactag
+tagccatgggacaaagtaactagtcagcggaaaagatccctttaaagatatatgcaggtt
+gcaagcataaagctcattgctcgaggtgcaccgtggtattccaaaagcgtctctatcgta
+tcttctaattttgggccgtgagaatcgaaactactctgatttgctgcacacgttaggtaa
+tatcgcccattttcccgtataagctccgtacttatacgaactacacgaccttttaagcat
+tagccgctcatatcgtgattcgtgtacagatgagtctattaaaattacagacatactcca
+tatctcgctccttgaactttgaataatgcgctaacttgtactatgaataggcagaaccca
+actttcccgtttgcgtcaagcggggaaacgatacatgttgtcagatttatgattatctag
+ttttagatcacgtttaccgataatcggctgtggtctgagcagtcctacactgagtattta
+cttcagcttcatatcggtccgaaaaaaggttgtgaccgaatgtcaaaatacggagtacga
+tgggcatcttttttcgagtcgcggttgcagggcagcaaaaggcttaaaccatttttacga
+tttttactatagcggtcatgaagtgcgaaactgcttgcaaattttctacacacattgtgg
+ctcttgtccttgaagcttatggcgaaaatttgaaacatagtataccagggaaagcgcgaa
+ttatttggtgactaatagtccgtgggtttgagccatatacctaacgccataaactacgtg
+gtgctttagatgcaatctaaacagaacagaaagcgtagcgctcatcagcacagactaact
+ttttcagtttgagtcgccggagggacttcgagacaagaacgcgtcaagtcgcttgcgcgg
+cacggattcgattgggcggctcaatcttgcctaatttctactattgtcagctgtacgact
+gtactaagtgtatagccccaaataaaagaagtatcgatgcgtctttatgaccaaaggtct
+tataattgaagcgcacttccgttcatcaaattaaatcctggcttacccgattctccggaa
+gtctgacctagagattgacgacggccgcgtattattgagacctcttcaggattaatcaat
+aacgaagtagttgatctgtttggcgacgtaccttaagccgactccgctacacgagtttct
+actaaaccaatgtagccttatgcttagatgaataccgtcctaattagatattccggcata
+acagcagtaaattatctgttcaatggacgaacattgaattgttagtattctacacaagtc
+aggcctcgtaaatattaggtaaggccgtgggataacctacgtgatatgcttgagcttgcg
+ttgcaagctctcgttaatcattaatttaggtgcgtgagggttaaacaccagcatattcta
+tatgctagacgtcttccttaaaggatcgtagtattataattaataataagaaatatggtt
+gacgtctagtcagcgggcatacgctgctctatatactggcattattcaaaacttgacggt
+aaaaaaacgaattttaaggcgctcacgtcgaatgagccgaactcatgggaaccaaaatgt
+cacagaaaacacctctttattgccaagcatgcaataaaaaaaatgttaatagtacgttta
+cgacattttattttataataaagagaaactattacacctattgatatgataggacgtaaa
+ttaacgagtagcctgcatagaggcaaatgaggtttctacatggtatagacctgatgctga
+aacatcgatgagttttggtcccctcgctcgttgaaatctagtcatttactactgtctttc
+gagctattataccacttcactatgtggtgtttctttgctatgtatggggctagtcaaaca
+tgatgactatagctacaactcagagagcgggcgtgttaagagtatctcatgctagaactg
+cacgacgaacttgatacaaagtaacaacatttacgattccacaaggtgactttgaagaaa
+catagtttaattctctgcttcgatcatttctataaaccggtaccatcgcagcggatagat
+gcataacatttctactactccaggcatcttaaaacacacgtagtacttcactagattaag
+acacgataagtgtataacttggcagtgggaagcaaggagattggcgaactcctggcatct
+gttacgttttgttcaggctcggttgttgataatgtccgactcctgccatattgaagactc
+gctcgagggagatcgggattcgttgattataagtacacgtgttccgtaatactatgaggc
+agtgattcaaaatggcacttctgacttacatgactaggtattattaccacggaagcgtta
+aaggcacactcttatggacttaagattgcaagtgccttcttctagcctgaattcgcgggt
+tcaacacaaactctctttagacatccgttgcctaaaggctgagacgtaggggcaaccctt
+taactatgtactaaaaaactagttggtaatttaacaacgtgtccaatcaagacgatgcac
+caacgcggtgcgaaaatcgggttaagcaaacacaaataggaattgtgataaaccccacct
+tgagaggtcgcaagaccaacctcgggaacaacggctctaagagaataacctaaatccgga
+tgagtagactgtgtaactctctaaagggaagtgaaaaaaagctaagcatacatttaggtc
+tcctgcattgcattcaattgaatcgtttgtattatgagctgtacagtagctatatcagct
+atagttatcccagaggaacaggtaaactagctctgagcgtgaaatccggatattagaacc
+cctagatgggattgattctagctaatacaggcttatctggttttacagttatctagatga
+ttggtaaggtgaaacgcttggtgccttccaccacttaaacaaaagtattgcccgggaagc
+tattttctaggtattataaagtcgagcattaatatcaatttgacagtaaaggtctttcac
+cagcttcatatgccatagggcccatactcgatttaaattgaacggtttaacgagtattgg
+aactctcacttataactgagtagctatacgaaaaatctggtccatttccagaaatttatt
+atcgatttgctgcttagtacccaggaagtgataacccttgaaggcacaacactgtaataa
+gttttcctgtcacatctgtaatattcggtcactacgcattcacgactaaagataattact
+atactaattaaaagttcaatgttagggccgaatcatagtagaaattctcgtctagcctaa
+tcggacttacctatgggctgtgaggatttatcagtatgtggacaaaaatgctagagatag
+gtatagttaaagtcaccatggtacatctatgtgaggaagtttgtagttcgcttctttagt
+ccgggcgtttgggatgacaactactatacgtagagccgtactcaggattagatagtgtga
+aagagtcaaataaaagggttaatattaatttaacgttgcaaatgtgtttaggccaaacat
+taaccgttgtagggatattctaatacaggccttcaccgaaccctaatgataatctgtctt
+aataacattaaatgattgtctccgctacgagctcttagggcctcattttaaatgactaat
+gtccaaagaagagactttcccaatttcaatctgtcacgtatagacggcaccttagtgagt
+catatcattaagatagaagattatcaggagggaagtttctattatcaaccgttacgcaac
+cataaacttttaaatctcataatggcattgagatcaagagctttcatgatggtaaagttc
+gtatgtgatgctggggagctagatatcggtataccacttcggttgtggtaagcccgagtg
+ggccgttagtaatattaatagacgattatccgacaatgcattcgctgaaataatcttact
+taggagaaattaatgctatgagccaaaactatttatgtctgtcacattattgactaaagt
+atctatcgacaaaactgatgtccataagttgtagcagatagtcggtgtatggtgtcacca
+atgaaaacctcgagcgaaaaatgaattatagttatccaatttgagtaaattgcctattat
+acagataggcttgtttagtcagataaggttccgcttgaggtgctctaacttagcgagagt
+tagaaagcctagtgagaggcattttggtgccaaactccggctcgcatgagtaggccagag
+agtcactttctttcgtcgaagaagttggtgaacagccttttgattagttgtttgtcttgt
+ggctatgtgctactatataagttagaacgcaaactaatctaatcagcaaagtaaaatagg
+accttgaacgagacggggtacgccgttgaggctcgagatagtagataaactagaggaatg
+tagataaaacattagctagggggtttagttactggattacataggaagtgcaccatcacg
+gtgtgggggttcgtacgtaaagtcgcatcaatattgtcagtggacttaacaagttcgtgc
+ataatgaaatcctatacggactttgcatatctctaccgactcatctggtcgtctatgcgg
+gtaattgtattgctccaagtggatgactattttggcgtcccagcacatagtaaatgtaaa
+tccttataatagcataagcaattattagactgcgtgaagtcttagtagttctcaagcttt
+acgttgtatgtaaataactcacgtaatcagccgtccccaaatcaccattgaggtcattga
+atgtacggagcactattatcaatgcggtatgcgattttctgagcgattattgttaaagac
+ttagcgttgagccccggaacacttgattacagattctttaaggagttatccaaatatcat
+tttaaataatagtagtatcgtgctttggacaataaaaaaagacccgttctcttatgttgt
+tttgcgacgtacttctctgatatatacttcaactatgaagattctattcatcgataaccc
+aggtatatttatatgcccgttcactgcgcagggcaaattatctacggacaataatgacgt
+agttggacccggtaagaactaacgcttaatatgattaaggatgtatgccagtattatctt
+attatgtcagagtagaagtttctctgagattttccgtcgttgtggtacaccggatttggc
+tctctttttagaactgagaactcggagtgtgtagtcttgtttccttcaatttatcaatat
+gcttttataccgccctcatcaactataacaggacgacaagttccgtcttgctccatcata
+tactaccgatacaccaatcgtatcaagtttagtatacttgctttctctcttctacagctt
+actcgcttgtccgagaagcggttggtgctcataaagttagtagtaaatgtacaactagta
+gccagtccttacctgtttttacgactactacggacaccatgagatacagaagttagtgct
+acaattataccattacatgctcaatatcgttgtcggccataagatcgaagagtgcatcac
+gcgtgtgaatacgtaaaatctaccatcccgtcaatgcacaaaaacacactccccttgttg
+actaacatcttttacaagaggctaaatcattgtccaggatcgaataccttgtgtacaatc
+gtcacccatcggaagaataccacttttccgatgtagtatgatttacaaaaaacatctatg
+tgagtaggccaattgtagtagaatatattcatttgaccgtcattagccttcttcttaggt
+tgtgtacggatagtaggtacataaaccgtcgtgtggcatacgctgcgatttcatacagct
+gccaacaccttttttaccaggctagagtcagaaaagttggagccatgttaaatagttacc
+atcataaaccactgttgtctactagtctgatcagctttcatgcctgtgcaagcaatatgg
+attctcacgtaatggtaacaactgttgcgttacttaggctggttaatttgtcagagtaat
+aaatacatgtcttgttgtgtttcctaatcctcggaaagtacacaagcctaggaataggaa
+aagtaaagctcttttattctgatagtgactaactcaggatctaaatacgcgattatacta
+accttcaccaaagctcaaaaatcatctgctggtgaccagttatagacagggtaattcaat
+atttaatgtctcccttaacatttcaccagcatggattgaagatagtataaagttttacat
+ggcagtcattgtgtcacggttctatacaaattctgatagttagacggtatttgaaatgtg
+cttctagcatggtatcttacacaactgaatgaacgactggagccgttcgtatactatttg
+cgagcctcgagaccccgtttcctaatgttaacgaatatagtataatataaattgtgatat
+gaataacacaagtaactacagtttggacaattaattgttctaaactaaaaatcattcact
+tcagatggcatagagttatggctactacacatataaagcggtatgtgaaacacccgtttt
+agccggaaaccctctactgctcgggacaatgaatgatttccaaaatatggatgtgcagaa
+ttgttagtgtgactcaggtccaaatagacactttagtttcgtcaagtcgttgcaaagttt
+aaaaccatcgcagcattctttatttggtctacattgagaaatgaaaaaacgtgacagaaa
+gtctagaagaactgtgaataatgtctattactgattaactagtaagacattagtgcatct
+ggtccactgaagcacccgcttggcgttaggcaatctctgtgaactgtcgtggctgttccg
+gtaatgtacgaaagcaagcctataggttgatcgagtcgcttcattaaggtcaatttcaca
+atatccgatcacattgtgctaggttcgtcctttaccttgcttagtgctgcatgtacgggg
+tgtcatgacttgttatcggcagactctttatcccaagaatggataatatgtacatggaaa
+gtgtccataattaagtcccttcactgtaaagaatgactgccacgtgatccatgaggtcta
+cagaaaccgacttacttgctttttgatcaacttaattatggattcataaagttcagatat
+cggtacaattggtgtacaatatgaaattaatgaggaaacatggaaatctgaatgacagtg
+atagaaaagatccccatttgcccggtcagttcatgttacaccactcattagtactgtaag
+tgtttcgtcagcattgagatccacgatcatgtgtttatgccttcgaaactggatgtacga
+cgatcgagacgaagaggtatatataacctaaatactaggtacgttgttagagagacgatg
+aaaattaatcgtcaatacgctggcgaacactgagggggacccaatgctcttctcggtcta
+aaaaggaatgtgtcagaaattggtcagttcaaaagtagaccggatctttgcggagaacaa
+ttcacggaacgtagcgttgggaaatatcctttctaccacacatcggattttcgccctctc
+ccattatttattgtgttctcacatagaattattgtttagacatccctcgttgtatggaga
+gttgcccgagcgtaaaggcataatccatataccgccgggtgagtgacctgaaattgtttt
+tagttgggatttcgctatggattagcttacacgaagagattctaatggtactataggata
+attataatgctgcgtggcgcagtacaccgttacaaacgtcgttcgcatatgtggctaaca
+cggtgaaaatacctacatcgtatttgcaatttcggtcgtttcatagagcgcattgaatta
+ctcaaaaattatatatgttgattatttgattagactgcgtggaaagaaggggtactcaag
+ccatttgtaaaagctgcatctcgcttaagtttgagagcttacattagtctatttcagtct
+tctaggaaatgtctgtgtgagtggttgtcgtccataggtcactggcatatgcgattcatg
+acatgctaaactaagaaagtagattactattaccggcatgcctaatgcgattgcactgct
+atgaaggtgcggacgtcgcgcccatgtagccctgataataccaatacttacatttggtca
+gcaattctgacattatacctagcacccataaatttactcagacttgaggacaggctcttg
+gagtcgatcttctgtttgtatgcatgtgatcatatagatgaataagcgatgcgactagtt
+agggcatagtatagatctgtgtatacagttcagctgaacgtccgcgagtggaagtacagc
+tgagatctatcctaaaatgcaaccatatcgttcacacatgatatgaacccagggggaaac
+attgagttcagttaaattggcagcgaatcccccaagaagaaggcggagtgacgttgaacg
+ggcttatggtttttcagtacttcctccgtataagttgagcgaaatgtaaacagaataatc
+gttgtgttaacaacattaaaatcgcggaatatgatgagaatacacagtgtgagcatttca
+cttgtaaaatatctttggtagaacttactttgctttaaatatgttaaaccgatctaataa
+tctacaaaacggtagattttgcctagcacattgcgtccttctctattcagatagaggcaa
+tactcagaaggttttatccaaagcactgtgttgactaacctaagttttagtctaataatc
+atgattgattataggtgccgtggactacatgactcgtccacaaataatacttagcagatc
+agcaattggccaagcacccgacttttatttaatggttgtgcaatagtccagattcgtatt
+cgggactctttcaaataatagtttcctggcatctaagtaagaaaagctcataaggaagcg
+atattatgacacgctcttccgccgctgttttgaaacttgagtattgctcgtccgaaattg
+agggtcacttcaaaatttactgagaagacgaagatcgactaaagttaaaatgctagtcca
+cagttggtcaagttgaattcatccacgagttatatagctattttaatttatagtcgagtg
+tacaaaaaacatccacaataagatttatcttagaataacaacccccgtatcatcgaaatc
+ctccgttatggcctgactcctcgagcttatagcatttgtgctggcgctcttgccaggaac
+ttgctcgcgaggtggtgacgagtgagatgatcagtttcattatgatgatacgattttatc
+gcgactagttaatcatcatagcaagtaaaatttgaattatgtcattatcatgctccatta
+acaggttatttaattgatactgacgaaattttttcacaatgggttttctagaatttaata
+tcagtaattgaagccttcataggggtcctactagtatcctacacgacgcaggtccgcagt
+atcctggagggacgtgttactgattaaaagggtcaaaggaatgaaggctcacaatgttac
+ctgcttcaccatagtgagccgatgagttttacattagtactaaatcccaaatcatacttt
+acgatgaggcttgctagcgctaaagagaatacatacaccaccacatagaattgttagcga
+tgatatcaaatagactcctggaagtgtcagggggaaactgttcaatatttcgtccacagg
+actgaccaggcatggaaaagactgacgttggaaactataccatctcacgcccgacgcttc
+actaattgatgatccaaaaaatatagcccggattcctgattagcaaagggttcacagaga
+aagatattatcgacgtatatcccaaaaaacagacgtaatgtgcatcttcgaatcgggatg
+aatacttgtatcataaaaatgtgacctctagtatacaggttaatgttagtgatacacaat
+actcgtgggccatgggttctcaaataaaatgtaatattgcgtcgatcactcacccacgta
+tttggtctaattatgttttatttagtgacaatccaatagataaccggtcctattaagggc
+tatatttttagcgaccacgcgtttaaacaaaggattgtatgtagatggtaccagtttaat
+tgccagtgggcaatcctaagcaaaatgagattctatcctaaagtttgggcttgatataag
+atttcggatgtatgggttttataatcgttggagagctcaatcatgagctaatacatggat
+ttcgctacctcaccgagagaccttgcatgaagaattctaaccaaaagtttaataggccgg
+attggattgagttaattaagaccttgttcagtcatagtaaaaacccttaaattttaccga
+ttgacaaagtgagcagtcgcaataccctatgcgaaacgcctcgatagtgactaggtatac
+aaggtttttgagttcctttgaaatagttaactaatttaaaattaattaacgacatggaaa
+tcacagaacctaatgctttgtaggagttatttatgctgtttactgcctctacaaccctaa
+taaagcagtcctaagaatgaaacgcatcttttagttcagaaagtggtatccagggtggtc
+aatttaataaattcaacatcgggtctcaggatattcggtcatataatttattaagggctc
+ttcgagtcttactctgagtgaaattggaaacagtcatccttttcgttgtgaggcatctta
+caccgctatcgatatacaatgcattccaccgcggtgtcccgtacacaaggaaacttgtta
+ccttggggatataagaaaactcacacgtctcattattaaactgagtacaatttttgcacg
+agaaagtaatgcaatacaatatgatgaaagccagctaatgaaaagggatggaacgcacct
+cggatctgttgcactggattaaaatccgattatttttaaaaatattcagtgctagagcat
+atcaggtctacttttttatctggtatgtaaagcccacggagcgatagtgagatccttacg
+actcaacgaaaagttataacataactcccgttagccaaagcccaatcccgattactgccc
+taccctaacgtctgccatctaaatatcgaacttgttatgatcaatgtgactacctcccac
+cctttccccttcatttgttccactggggataagctagcgttttcagaatcaatgcaataa
+gaatagccaattgtctcacttcatcagagctcttggcaattccaggcgctacgtggttct
+ggaatatattcatttttcaaatagtaatacgtttagtgttgctattgtctacacgtttgg
+atattacgttatgtgagcggacatcaatagttgtctaactctttagtaagccagagatag
+cactcttagcgaatggataccatcttccataagtttagttaatagtccgaaacaactgct
+tcgagcatatttgaacctccttgtaggcaaatagcctcttcaaagcaatcttactaatag
+atagagtttgttttaagggactactagaaatgggacaatcttaatagtatgacctaaact
+gacatttaaagatatatccaggtggcaagcataaagatcattgcgccacctccaccgtgg
+gattacttatcagtcgatatcctatatgctaagtttgcgacggcagaatacaaactaagc
+tgagttgatgctaaccttacctatgataccccattggaccggttaacagccctacttatt
+ccaaataaaagaacttttatgctgtagaagctattatagtgatgcctggtaacttcagta
+tattaaaatgacacacatacgccatatagagctcctggaactttgaataatgagcgaact
+tcgaagttgaagagcaagaaaccatatgtcacggttgcctaaagcccggtaaccagacat
+gtgctatcattgatcattatcgaggttttcataaccttgacccattatcggctgtgcgcg
+gacaagtacttaaatcactagtttcttcacctgcttatcggtaagaaataaggttggcaa
+agaatcgcataagacggacgtagagccgcagcgttgtgcgagtccaggtgcatgcgcagc
+aataggattttaaattttgttccatttttaatttagccgtaaggatgtccgtaaatgatt
+gaaaattggattcaatctttgggcctatgctactggaacctgatcgacaaaatttcaaac
+atacgttaactccgaaagaccgtatttttgcggctagaatagtcagtcgcttggagccat
+ataccttaccacttaaacgacgtgctcctgtagttgaaatataaacagaacacaaagact
+accgatcatatcaactgaagatctttgtaactttgaggcgaagcaccctcttcgagacaa
+ctaagagtaaagtaccgggcgccgcaaggagtcgattgggaccctaaatcttgacgaatt
+gctaagaggctcagagctaccactgtaatttctctagagcccataataaatgaacgatac
+atccgtaggtagcacctaagggattataatggaagccaaatgcagttaataatattatat
+actggcgtacacgattcgacggatctctcacatagtgattcacgacccccccctttgatt
+gacacagcgtcagcattttgcaagaacgatcttctgcatagggtgcgccaccgtaaggat
+gacgtcgaagctacaactgggtataatttaccatgcttccctgatgctgagtgcaataca
+ctaagaatgagtttttaccccatatcaccagtatttgttctgttattgcgaagaaatggc
+tatgctgagttggcgactaaagtcacccatcctttttattaggtaaccccctcccttaaa
+ctaactgatttgctggagctgccctgcatacatatactttatcatttatggacgtccgtg
+acgcttattatccaccatagtcgatatgctacacggattcattaatggatcgtaggagtt
+taagttatatttactaagatcggtctcggctactatcccgccttacccggcgctatttac
+ggccatttttaatatattgacggtaattattcctatggtttcgaccgcacgtccttggac
+aagaaagaatggcaaaaaaaatgtaaaagaaaaaaaatattgagtccctaccatcatata
+aaaaatatgtgatgagtaacttgacgaaatgttagtggttattaaagactatctattaca
+ccttttgttttctgtcgtagtatattaaagtctagaagccttacaggaaaatcagggtta
+tacagccgatactccgcagcatgaatcatcgaggaggtgtcctaccatcgcgccttgtaa
+tcttgtctgtgtatactgtatttagaccttttatacaaagtaaatatctcggctttatgt
+gattgggaggggcctactcaaacatgatgacttgacctaataatcactgtgcgggcgtct
+tatgactagctattccttgaaatccaccaccaaatggttaatatgtaaaaactttgacga
+tgaaacaaggtgaatgtgtagttactttgtgtaattagctgcgtcgagcattgcttgtaa
+aaccgtcaatcgcacacgttacttccataaaatttctacgaatacacccttcttaaaaaa
+aacgtaggaattcacgagtttaacaaacgataactgtataaagtggaagtccgaagaaag
+cagatgcccgaactactcgaagatgtttcgttttcttaaccataggggcttcttaatggc
+ccactacgcacattttgttcaagcccgagagggacatccccattacgggagtattactaa
+aactgttccgtaatacgttcagcaagggatgaaaaaggccactgctcaagttattgacgt
+gggagtattacatcggaagcctgaatcccacactatgatggtctgtacaggcctagggac
+tgcgtctagacggtattaccggcttctaatcatacgatcgtgagtcttaacgggaagtaa
+ggctcacacctaccccaaaccatttatctatgtaagtataaaattgtgcgtaagtgttca
+aagtggacaataaagacgtggcaaaaacccccgcacataagccgctttagatttcacaaa
+taccaatgcggttaaaaacatccttgagtcgtacatacaccatactcgcgttaaacggat
+ataacagaagataataaatccggatgtggagtcggtgtaactatagaaagccaagtgaaa
+taatgcttaccagtcatttagctatacggctttcatttcatgtcaagagggtggagtttg
+acctgtacagttgatatatcaccgatacttagaactcacctaaagctaaaattgctcgca
+gcgtgtaatccgcatattacaaacaatagatgggattcattatacataagacacgatgat
+ctgctttttcaggttgcgagatgttgcctatcgtcaatcgagtcctgccttacaccactt
+aaacaaaagtattgacagggaacctattttcgaggtattatatagtccagcttgaatatc
+aatttgacagttaacctagtgaaaatcagtaagaggaaatacgccacattctccagtgaa
+attctacgggttatcgtctagtccaactatcaattataactcacgagatataagtaaatt
+ctcgtacttggcctgatttttattatactttggatccttagtaaacaggaagggagaaac
+cttcaacgaaaaacactggattttgttttactctcaaagctcttatatgacggaaatacc
+ctgtcaagtcttaactttattactagactaatgaaatgggcttggggtggccagaatcat
+agtacaatttagcggatacactattcggactttcctatcggctgtctggttggataagta
+tggggactaataggctagacatacctatacttaaactatacaggcgtcatctatctctgc
+aactttggagttccctgatgttctcccgccctttgggttcacatcttctataccgacacc
+cctaataacgattagtttgtgggttagagtaaattaatacggttaatattaatgtatcgt
+tgaaaagctggtgtcgccaataaggtaaccggctaggcagagtatatgtcacgaagtata
+actaccctaatgataagctgtaggaataaaattaatgctgtctctaagcgaagagatatt
+tccgactctgttttaatgacgaatctcattacttctgacttgcaaatgttcaatatggca
+cggtttcacggcacctttgtgacgcatataatgaacttagaagattataacgacggaact
+ttatatgataatccgttacgattaaagaatctgttaaatatcataatggcattcagttct
+agaccgtgcatcatggtaaacttactttctctgcatggcgacatacatttcgctattcaa
+attcgcgtgtggttacacccactcgcacctttggaatattaagagaagatgatcagaaaa
+tccattcgctcaatttttctgacgtacgtctaatttatcctaggagacaaatcgttttat
+gtctctcacatttttgaagaaaggttcgagagacaatactcaggtcctgaactgctagaa
+gatactcggtggagcgtggcaacaatgaaaaactcgtgacataaatgaatgatacttttc
+caagttcagttaagtgaatatgtttaacatacccggcttttcgatcttaagctgacgctg
+gacgtgcgagtaatgtcagtctcttacatacactagtgactccaagtttcgtcaaaaacg
+ccccctcccttctcgagcccactcacgctatgtattgacgcgaacttgttcgggatcaga
+cttttcaggagttcggtcgcgtgtccctatgtgctaatatataagttagatcgcattaga
+tgctaatctgaatacttatagacgaccttcaacgagaacgggtaccaccttgaggctaga
+gttaggtgtgaaacgacaggtagggacatataaaatttgagtgcggctttagttaagggt
+ttaattacctactcaaacatcacgctcgcgcccttcgtacgtaatcgaccatctagaggc
+taaggggactgtactaggtagtgattaatgatatcctagacgcacgtgccttagatcttc
+agactctgatggtccgcgatcaccgtaattgtagtcctccaactcgatcactttgttggc
+gtcaaagaaattacgatatctaaatacttataatacaataaccaaggatgagaatgactc
+atcgcgttggagttatattgcttgaagttctatggaatgaaagcacgttatctgccgtcc
+caatatctccagtgagctaattcattggacggtccactttgatcaatccccgaggagatg
+ttcggacactttagtctgtaacacttagcgttgagaccacgaacaattgattactcagtc
+ttgaaggtgttttccaaagttcattttaaataagactacgataggcctttcctattgata
+taaactacccggctctgttgttcgtgtgagtcgtacttctctgtgtttttctgattatag
+caagattcgattcttagtgtaaacagcgatttttatttgacccgtcaatgagaagcgcat
+aggatctaagcaaaattatcaagttgtgccacaaggtaagatctttccagttattgcagg
+taggatgtatcccacgttgatagtatgaggtctgacgtcaactgtctaggagagttgacc
+gcgtgcgggtacaccggatttgcatcgatgttgagaacgcagaactcccactgtcgtggc
+ggcgttcctgatatttagcaagaggcgttgataaagccctcatcatctagatctcgacct
+catctgccctcttgctccatcattttctacacagactactttcctatctacgttagtata
+attgctttctatcttagtatcatttagagcttctccgtcaacaggttcgtgctattaaag
+ttagtacgaaagggacaacttgtagcaacgcatttaatcggttttcgactacttcgcaca
+aaatcagataaagaagtttgtcattctattagacattgaattgcgcaattgacttgtacc
+acttatgatcgaacactgaatcaagactgtgattaactaaaatagacaagccactatatc
+aactaataaaaacgcccctggtggtcgaacatagttgactacaggataattaattggact
+ggagccattacattctctacaatcgtatcacttcccaagtagacaactttgaccttgtag
+tttcatgtacaaaaaaatgctttcgcaggagcacattggtagttcaatagtttcatggga
+acctcttgagccgtcttctgtgggtgtgttcggatagtaggtactgataaagtcgtgtcg
+ctttcgatgagagggaattcaccggaaaacaccttggttaacaggatagtctatgtaaac
+ttcgagacatgtttaagagttaccagcttaatccacggtgctctactagtatcatcagct
+gtcttgcctcgcctagaaatatgcattctatcgttatcctatcaacggttgccgtactga
+gcagccttattgtggaagagtaatatataaatgtagtcttgtctttacgaagcagacgta
+agtaataatgacttggaataccaaaactaaacatagtggattatcatactcaagaactct
+ccagataaataacagtttttacgatacgtcaccaatgagcttaaagattaggatcctcaa
+aactgatacaaacgctaattcatttgttattggatccagtatcagttaaactgaatggag
+tgaagattgtagaatgttgttctggcctcgcatggggtctaggtgatatacaatttctca
+tacttacacggtagtggaaatctgattctagcttcgtagctgactatactcaaggaacca
+ctgctcaaggtaggagactagttccgaccctacagtcaaagtggccgaagcttaaactat
+agactagttgttaaatgctgatttcaagatatcatctatatacagtttggacaattatgt
+gtgcgaaactaaaattcatgctattcagatggatttcacttatgccttagaaacagatat
+tgcccgagctcaatcaacagttttagccggaaacaatcgaagcatagggacaatgtatct
+tttcctaaattgccatgtgcagatttctgagtgtcacgaagcgcataatagaatcttgtg
+ttgcctcaactcgttgaaaagtttaaaacaatcgcagcagtctttttggggtctactgtg
+tgtttgcaaaataactgaaagaaacgcttgaacaactctgaagtagctcgagtactcatt
+aaagtgtaacacattagtgaatatcggccaatgaaccaaacgcttcccggtacgctatct
+ctctcatcgggaggcgatgtgcaggttatctacgaaagcatccctttacgttgagagtgt
+cgatgcatgaacctcattgtaacaatagcccagcaaattctcatacgtgcctcagggtcc
+gggcgtactcctccatggaagggcgcgcatctagtgttataccaactcgctttttaacta
+ctatgctgtagttctacaggcatagtggccagtattttctaacttctctggatagatgct
+ctcactcctcatccatcacggcttcagtttacgtcttacttgcttgttcagcaacggatg
+gaggcattaagtatcttcactgttccctaaaattgctgttcaatatcaaagtaaggacga
+tacagggaaagctcaagcacactcattgaatactgccccagttgcaacctcacttaatct
+gacaaaaataatgactactctaagtgttgcggaagcagtctcttccacgagcttgtctgt
+atcacttcgtataggcatgtaactcgatagacacgaacaccgagtgagaaactatattct
+tgcttccgtgtgtgtgacaccaggtaattgatgcggatataagctggagatcactcacgc
+ccacacaaggcgctgctacctctttattccaatgtgtaagaatttgctaacttcatttct
+agaccgcagctttgcggtcataatttcacggtacggacccttgggttagagacttgataa
+cacacttcgcagtttccaccgcgcacatgttttagtggcttctaacatagaatttttgtt
+gtgacataaagagtgcgtgggagacttgcccgaccgttaagccataatcaattgaaagcc
+ccgtgagtcacatctaattggttgtactgcgcatttagctatcctttagctgactcgaag
+agattcgattcctaatataggttaattagatggctgccgcgcgaagtaaaacgtgaaaaa
+cgtagtgcgcagatctgcataactcgcgcttaattacttatgagtagttccaagttcgct
+acgttatgagagagattggaattaagcaaatatgttttatggtgattttgggatgagaag
+gactgctaagtacggctactaaacaaatttctaaaaccgccatctaccttatcttggaga
+catttaagttgtatatgtcactagtctagcttttgtctgtgggacgcgttctcggaatga
+gggaaatgcaagagccgattcatcaaatgcttatctaagaaagtagtggactattacacc
+aagcacgaatgccagggaactgctttcttgctcaggacctcgcgacaaggtaccccgcat
+aagtcctagaattacatttggtcagcaatgctgacatttgaccgtgaaaacataatttta
+atcagaaggcagctcacccgcttgctctagatcttatctttgtatgaatgtcagaattta
+ctgcaatatccgttccgaatagtgagggcttagtatagttctctgtatacaggtcacatc
+aaactccccctgtcctagtacagctctgagctttaattaattgcatacatttccttcaat
+catcagatgaaaacaccgcgaatcatgctcttctcgtatagggcaagagaagcaacaaac
+aactagcccgactcacgttcatccgccgtatccttgttcagttcttactccgtattaggt
+cagcgaaatctaatcagaataatcggtcgcgtatcaaaattaaaatcccgcttgaggttg
+acaattaaaacgctgagcagttatcggctattagatagtggggtgaaagtaattggctgg
+aattatgttaaaacgtgatattaagctaaaatacgctacttgttgccgacctaattcagt
+cattcgatattcagttagagccaagaataacaagcttgtataaattgaacggggtgcact
+aaacgatgtgttactctaatattcagcttggagtatacctgaaggcgaattcatgtatcg
+gccaataataagacgttgaagatcacaatttggactagcaaaagaaggtgatttatgcgt
+ggggattgagtccactgtacgagtacggtctctggaaaattataggttcagggaatataa
+ggaagtaaagataattaccaagagatttttggtatcgctatgacccagaggtgttctaac
+gtctgttttgatccgcagaatttctgcctcaatgcatatttgacggacttgaactagagc
+ctctaaagttaaatggcgacgcaactgttcctaaacttcaattattactactcttttttt
+cctagggtattgtagaggccagtggacaaaataaatcaaatttaagatgtttcggacatt
+aacatcccccgtagcatagaaatcatcagttatccaatctctcatcgagcttttacaatt
+tctgctggcgctatggacagcatatgccgcgagacctccgcaagactcacttgatcactg
+taagtatcttcattagaggttagagcctatagttaagctgctgacctagtaaaattggta
+ttttctaattttattgctcaagttaaaggttagtgaagggataatgacgttatttttgaa
+caatgggttgtattcaattttatatcacgaatggaacccttcattcccggcataatacta
+gacgacacgaacaagctccgatctatcagccaggcacgtgttaaggtttaattccggcaa
+accaatgaagcatcaaaaggtgacctgatgcaacttagggtcacgatgagtttttcagga
+ctacttattacctattaataagttaacatgagccttcataccccgtaagacaatacatac
+tccaccaattagaattctgagccatcttatctttttgtatcatcgaagggtatggccgaa
+taggttaattagttactcctaacgtctctacaggcatgcatttgacgcaccttcgaaaat
+agtcaatctctcgccacacgcgtctagtatgcagcatcaaaaatatagtccacggtttcc
+ggattaccaaacgcggcaaagagaaacattgtatcgacggagataacttaatacagaagg
+aaggggcatcttcgaatacggatgaataattctatctgtttattctgacatcttgttttc
+aggttaatcttacgcattcaaatgacgcctgccccatgcgtgcgcaattattttctaata
+ttgacgagagcaatctcactccttttgggtctatttatgttttattgaggcacaagccta
+tacagaacaggtactattaaggccgtgagtgtgagactcaaaccgtggaaacaaaggatg
+ggttgttcttggtacaagttttagtgcatgtgggcaatccttaccaaaatcagatgctat
+ccttaactttgggctgcatttaagatggcggttggaggcctgtgagaatcctgcgtgtca
+tctttaatgaccgaattcatccatgtagattcagatcacacactcattccttgatgttgt
+ctaaacaaaagttgttgtggacgcattggagggagttaagtaacaacttgggatcgcata
+cttataaaaattatatgttaaactttcacaaacgctgaagtccaaagtaactagcccaaa
+cgcctcgagagtcactaggtattaatggtgtttgagttcctgtgaaatagtgttcgaagg
+taaaatttatgtaccaaatcgaaagaacacttaataaggcttgcttgcacggaggtatga
+tgtttactgactctacaaccctaattttccagtacgtacattcattccaataggttagtt
+ctcaaagtgctatacaggctcctcaattgatgatatgcttcagccgctctatggatatta
+gctcattttatttaggaagcccgcttagaggcttactatgagggaaatgccaaaatgtca
+tacttttcggtgtgtcccatatgacaccgctttacatagaatttgaattaaaacgcgctc
+tcccgttcactaccatacttggtaccgtgcgcatattacatatagatataggatcatttt
+ttaaagctgtactaggtttgatcgacaatcttatgctatactatatgatgtaaccctcat
+aatcaataccgatcgtacgatcctagcataggtggcaagcgattttatgccgattattgt
+gttaaatagtctgtgagtgtgattatcagggctacgttggtagaggggttgtatagacct
+cgcacacattgtgacatacttaacaatatacgaaaactgatataataaatccccttaccc
+aaacaccaatcccgttgaatcaactaccataacgtctcccatataaattgcctacttgtt
+tgcataaatctgaatacataacaccattgcaccttcttgtgttccaatcccgttaagatt
+gccttgtcagatgatatgcaagaacaatagcatttgctagcaattattaacagctcttcg
+aattgcctccacataacgcgggagggtatattttaatttggcaaatactaagtactgttg
+gcgtcatatgctattaacggttggatattaagttatgtcagccgtaagcaagagtgggcg
+aaatattttgttacccagtgagagcactcttagagtttggatacaataggccatatgttg
+acttaagaggacgtaactacgccgtacaccattgttcaaccgacttcttggcaaatagaa
+tcgtattagcaatcttaagaatagagacacgttcgtgttagggtatactacaaatccgaa
+aatcttaagaggatcacctaaactgaaatttatacatatttcaacgtggatagatttaac
+ataattcagccacctccaacctgggagtaattttcagtagatttactagatgattagtgg
+cccaacgcacttgactatataagatctggggatcctaacctgacctatgagacaaaattg
+gaaacgttaacagcccttatgtgtacaaagaaaagtaagttgttgctgttcaacagatga
+tagtcatgacgcgtaacttcactatagtaaattgaaacaaatacgcaatttagacagaat
+ggtacggtcatgaatgacagtaattcgaagtgctagaccaacttaaaataggtaaacgtg
+cccgaaaccccccttaacagaaagctgctatcatggtgcagtatcgacgtgttcagaaac
+ttgtaacttttgagcaggtccgagcacatggaagtatatcacgtgtttctgaaccggctt
+atccctaagatatatccgtcgcaaactttcgatttagtcccacgtagagcccaagcgttg
+tgcgactccacgtgcatgcccagaaatacgagtttaaatttggttacatggttaattttg
+accgaagcatcgcactttatgattgataattggattcaatatgtcgccctatgcgaatgc
+aacatgatccacaatttggctataagacgtttaatccgtatcacactttgtttgcggcta
+gtatagtaacgcccgtgcaccaagagtcagtaacaattataagtactccgcaggtacttc
+aaatataaaaactaatcaaacacgacccatatgatcatctgaagatatttggaactttct
+cgacaaccaccctcgtactcaatacttacactaatcgacaggcacacgcaacgtgtacag
+tcgcaccatattgagtcaagatttgcttagtggcgatgagcgtacacgcttatttctcta
+gtcacaattagttatctacgagacatcacgagggagcaaataagcgatgttatggctaca
+cataggcacgtatgaatatgatataagccagttaaacagtcgaaccatcgagcaaattct
+catgcaccaacccacacgttgaggcacaaagagtaagctgtttgaatgtaacttcttctg
+ctgagcgggccccaacgtaaggatcaactagaagagaaaactcggtattagtttaaatgc
+gtcacggagcatgagtgcatttcactaagaatgtctgtgtaaccaatataacatctattt
+gttatctgattgcctacttatggctttgcggtcgtggcgactaatgtctccaatcctttt
+gaggtcggtaccaactccctttaaattacgctgtgcaggctcatgcactgcatacatata
+cggtagcaggtagggacctcacgcacccttattataatcaatagtagttatcagtcaacg
+aggcaggaatgctgaggtcgaggtgttggtatattttctatgtgccgtctaggcgactat
+cacgcattaccaggcgagatttaagccaattttgaatatagtcaacgtaatttttactat
+gggttccaccgaaacgccttgcacaactaagaatcccataaaatatcgatatcaaataaa
+agattgtgtcaataccttcatatatattttttcggttgactaacgtgaactaaggttagg
+ggttttgtatgtctatataggaaacagtttcttttctgtcctactttagtaaagtcttca
+agccttactccaaaatcacggtgattaagccgttactcagcagcatgattctgcctgctc
+gggtcctaaaatccagccttgtaagagtcgctgtgtattagctagggagacctttgttaa
+aaaggatatatcgcggcgggatgtgagtgcgtggcgcatactcaatcttcagctcgtgtc
+attataatatctctcccccacgcttttcactagatatgccgtgtaagcaaacaccttatg
+cttaatttcgaaaatattggtacttgaaaaaagctgtaggggtacttaatgtctggtagg
+agatcaggagagaattgagtgtaaaaccgtaaagccctcacctgacttcatgtaaatggc
+ttagaagactccatgatttaataaatactacgaaggaaagactggatctaaagataactc
+tagtaaggccaactcccttcaatgctgttgccagttataatccaagagctgtccttttct
+gaaccatagcggcttctgaagcgaactagaagcaaagttggttctagccagacagccaca
+taccctgtacgggtgtattactaaaactggtccggtattagttcaccaagggaggaatta
+ggcaaaggatctaggtatgcaagtcggagtattacatccctaccctgaatccatcaatag
+gttcctctgtactggccttcgcaatgagtattcaaggttgtacagccgtataataataag
+atagtgactatgaacgggaagtaacccgctcaccttccccaaaacattgttatatctaag
+tattaaagtctgccgtagtgttaatactcgaaaataaacaactggcaaattacaccgcac
+ttaagccgcttttgatttatatttttccaatgcgcttttaaaaataattcagtcctacat
+actaattaagacccttaaacggagatatcacaagttaagttttaaccatctcgactaggt
+ggaactatagatacccaactcaatttatcattacctgtaatgttcctagaaggattgcat
+ttcatgtcaagacggtggagtttcacagcgaaacttcagtgtgaacagattctgagaaat
+cacctaaacctattagtcagagcacccggttagaaccagttgtcaaaaaatagagcggtt
+gcatgagacagaagtaacgatgagatccgttgtaacgttgagacatctggcctatcgtca
+atacagtcctcccttaaaaatatttttaaatactaggcaaacccaacataggttagtcct
+atgtgatacgccacatggtatatcattttgtaacgttacctagggataatcaggaagtgg
+aattacgcaaaagtagacagtgaaatgcttagggttatagtctagtccaaagataaagga
+taaagcacgtcagagaactatattagccgaatgggaatcattgttaggagactgtggatc
+atgtctaaaaagcaacgcagaaacagtcatcgaaaaaatctcgtttttgtttgaatctaa
+aagagctttgatgaccgatagtacctgtatactagttactgtattacgtgtctaatgatt
+tcggattggggtccccagaatcagacgtcattgtagacgattcaagtttaccaatttaat
+ttcccagctctccttggagaactatcgccaataattgcagtcactttccttttctgaaac
+gataaagccgtcagagttctctgcaacgttggacttacctgaggttctaacccactttcg
+gttctaatagtagttaacgacacaacgaataacctttactgtggggctttcacgatattt
+tttcgcttattattaatggttacgtcataagctggtgtccaaattaaggttaccggcttc
+gcagagtagttgtatccaagtataacttccctaatcataagatcgaggtagaaaattaat
+gctgtctctaaccgaacagatatgtcccactatgtggtatggacgttgctaattacttct
+gaagggaaattggtcattatggatacgtgtctaccatcaggtcggacgcagatatggttc
+tgtcttcagttgatccaccgttctttataggataataactgacgattaaagattatggta
+aatagattaagccaattctcttcttgtcagtgaagcatccttaactgacttgctctgcag
+cccctcatacatttagctattcaaagtaccggctcgtttcaaactctcccacctttggaa
+gaggttgtcaacttgataagtatatcatttacagcattttttcggacgtacctctaatgt
+ttcattgcagaaaattagttttttctatcgcacattttgcaagtaacgttagagacacaa
+ttatctgcgaatgaactgctagatctgacgaccgggagcctcgcaaatatcaaaaaagac
+tgacatatatcaaggagtcgttgacaagtgctggtaagtcaattggtttatctgtcccgg
+cgtttcgatcttaagctgaccatgcacggcagagtaatgtcactctcgttcttacaagtc
+tgtctccaagggtcggcaaaaaagacccctccattctcgagcccactcacgatatgtagg
+gacgacaacttgtgcggcttatgaattgtctggactgcgggcgagggtccatatctccga
+agttagaagggacatacctttagatgataagatcaattcttattgacgaaattcatccac
+aacggggaacaacttcaccctagacttacgtctgaaaagacacctagcgtcttataaaag
+gtcagtgccccgtttcgtaaggctggaattacctacgcaaacttaaacctcgcgcccttc
+cttacgtatcgacaagatagaggctatcgcgaatgtactacggaggcatgaatcatatac
+tagaaccaagtgcctgtgatattaacaagatgatccgacgcgagcaccgtaattctaggc
+ataaaactccagcaatttgggggccgaaaacaaatgacgttagctaattaattatatgac
+atgatcaaaggaggtcaatcacgcatcgagttcgacgtatattcattgaacttcgtgcgt
+ttgaaagaaacttttatgaaggcaaaattgatcctgtctcctatttcatgcgtacctcct
+agttgataattccccgagcagtggttaggacacttttgtcggtatcaagttccggtctca
+aaacgtaaaattctgtaatctgtatggatggtctgtgaattagttaatttttatgaagtc
+gtcgagacgcagttcctattgatttattctaaacggagatgtgcttcgtgggactcggaa
+gtagatctgtgtttatgattattgctactttagatgctgactgttaactccgtgttgttt
+ttcaaccgtatatcacaaccgaattggatagaacctatagtttcaagttctgccacaagg
+tatcatatttacagttagtgctggttgcttctttcaaacgtggtgagtttgtgctatcac
+gtcaacggtagagctcagtggaccgagtgcgcgttcaaccctgttccagagagggtgtga
+tagcacatataccacgctcgtcgaggcgttcatgatagtttgcaagagccggtgttaaac
+acatattattattgttatccaactaatcggacctatgcataaagcattgtctaaacagaa
+taattgcctatatacggtagttttagtgatttatatcttagtatcagttagagcttcgaa
+ctcttcaggttcctcatatttaacgttcttcgaaagcgaaaacttctacaaacgaatgta
+agcggttttccaagtagtacctataaatcacagaaagatctgtctcagtatagttgaaat
+ggtattcagctagtgacgtgtaccaattatcatagttcactcaagcaagacgctcattaa
+cgaatatagacaagacactatatcatataataaaaaagaacatggtgctcgaacatagtt
+gaattcaccatattgaaggggaatgctgacatgtaattcgctactagacgatcaattccc
+tacttgtcaaagttgaactggtacgttcttggaattaaatatgattgcgctggaccaaat
+tgcgacttcttgagtttcagggcaaacgattgagccggaggatgtccgtctcttaccttt
+cttgcttatgataaacgacggtccctgtacatcactgggaattctcagcaaaaataattg
+ggtaaatcgagactcgatgtattcggccacaaaggtgttagacgttaaagattattcaac
+ggggcgataataggatcataaccggtatgcaagcgcattgaaagagccatgagatcctta
+tccgataaacgctgcacggtatgtgcagccttattgtcgatcacgaatttataaatgtag
+tctgggctgtaagttgaagacctaagttataatgaagtgcaataccaaatcgattcatag
+tggattatcagactcaagatatctcctgataaattacagttgttaagatacggataaaat
+gagatttaagattagcagcctctaatctgtttcaatcccgttggaatgtggtatgcgatc
+aaggttaagttaaaatcaagcctgtcttcagtcttgattcttgttctgccatcgcatgcg
+gtctacgtgagttaatatgtagcttacgttctagcttgtgctaatctgagtatagattcg
+tagaggaatattatcaagcttccacgcctcaacgtacgtgtattggtcacacaagacact
+aaaagtggaagtagcgtaaactatagtctagttgttaaatgctcagttcttgttatattc
+gatatactcttggctaatttatgtctgagtatataaaattaatgatattaacttgcattt
+cacggatcccttagaaaaagattttgaccgagcgcattataaacggttacaccgaatcaa
+tagaagcatacccaatagctttctttgaatttattgcctgcgcaacttggctgactctct
+agatccgaataattctatatggtcgtgacgaaactagttcattactgtttaaaatgccaa
+catgtcttttgggccgataatggctctttgcaaaattactcaatgatacgattgatcaaa
+gcggtagttgctagtggtagcatgtaagtctatcaaatgtctgattatccgaaaatcttc
+caaaagagtccacgtaccatatctatctcatagcgacgcgaggggaaccttatctaacta
+tcattccatttaccgggtgactctcgatgcaggatccgattgggataaattgcccagaaa
+tggctcattcctgactaagggtaaggccgttctcagcaagggaaccccgcgaatctaggc
+ttataccatctagattgttaactacttgcctgtagttctacagccatactggacagttgt
+ttctaaatgatcgggattcatgctagcactcctctgaatgcaccgcgtaagtttaactat
+tacgtccgtgggcagataaggatggaggctgtatgtatcttaactgttacctaatatggc
+tggtaattatcaaagtaaggaccttaatgccatagcgctagcaatcgctttgtatactga
+ccatgtgccaacctctcttaatctgtaaaatataatgtcttagctaactgtggacgatca
+tgtctctgcctagagcttcgctgtatcaattcctatagccagcgtactagtgacacaaca
+acaccgtgtgagaaaagatattagtccttacgtctgtctctctacagcttattgatgagg
+attgaacatggacatatagctccccctcaaaagcagatgctacctctttattccattctc
+gaacatttgccgaacttaatttcgacaaacctgaggtcacgtcttaatttatcggtaacg
+tcacgtccctttgagactggataaatatattaccaggggccaacgagcaattgttggagg
+cgcttctataatacaaggtgtcttgtcaaagaaagacggcgtgcgtctcgtgcaactcac
+ttaaccaatattaatgtgaaacccccctctctcacatcttatgcggtgtactgccctggt
+acatttcctgtacaggactccaacagtgtagattcctaagatagctgttggagttgcctc
+acgccagatcgaaaaactgaataaactagtgagctgagctgcagaaataccgcttaatta
+cttatgactagttcaaagggacctacgtgatgtcagacattgcaaggaagaaattaggtt
+tgtgcgtcattttggctggactagcactccttacttcccctactattcaaatgtcgtaaa
+cagcatgagacaggatcgtgctgacatttaaggtctattgggaacgaggctacctttggt
+cgcgcgctcgcgttctccgaatgaccgaaatgcatgagcacagtatgcaattgcttatag
+atctaaggtctggtcgttgaaaccaagcacgtaggcctgggaaatcagttcttcctcagc
+aactacacaaaagcgtccaagcattagtacttgtagtaaatgtccgaacctatgcgctca
+tttgaaagtcaaaaaatatttttaagcagtaggcacctaacccgattcctctacttagta
+gctttctttgattctcagaattgactgcaatatcactgcacaattctgtgccattactag
+acttctctgtattaacgtctcatcttactaacactcgcctaggacacatctgagagtgaa
+gtatttcaatacatttactgaaatcttcagttctaaaatccccgaataaggctcttatcg
+gtttggccaacacaagaaaaaaacttcttgcaccactcaccttcatacgcaggagcctgg
+ggaacttagtaataactatttcggcagacaaagcttataacaagttgccggcgcgtataa
+tatttaaaagaccccttgagctgctcaattaaaacgctcacctggtataggctattagat
+agtgccgtcttagtaaggggcgggaattatcggataaactgatattttgataaaataacc
+gacttgttcacgacataagtcactaaggagattttatctttctccaaagtatatcttcct
+tggataatttcaaagcgctgcaatttaagttctgttactagtttatgctgctgggaggtg
+accggaaggcgtagtaatctagaggcaaattataagaagttcatcatatcattttcgact
+acaaaaacaaggtgttgtatgccggcgcattgtgtaaactggacgagtaccctagatgga
+aaattatacgttaagccaagatttcgatgtaatgataattacctacacatttttgctatc
+cataggaacaagagctgttctataggctcgtggcatacgaacatttgctgccgctatgaa
+tattggaagctcttcaactacagactctattcttaattgccgtcgaaaatgggccgaatc
+ggctattattaatactcggtttttccgaggggattgttgtcgacagtcgtaattattatt
+aatattgatgttggtgaggtcatttaaatacaaccttgcagacaatgaataagggatcca
+atctctcatactccttttacaattgctcatgcccctatgcaaaccttatgccgccacacc
+tccgcaactctctcttctgaactgtaagtagcttcattactggtttgagactatactgaa
+gctgatgacattctaaaatggctattttcgaatgtgattcataatgtttatcgtttggga
+tggcagaatcacgttatttttgatatagcccgggtattctattgtatagaacgtatgcta
+caagtcattccccgaagaagactagaagtaaacaacatgcgaccatcgttaagccacgca
+aggctgtagctttatttcccgataacctatcttccataaatagcggacagcaggatactg
+acgctcaacatcagtggttatggtctaatttttaacttttaataaggtaacttcagcagg
+catacacagtaactctttaatttataatcaaattagaagtctgacacttcttatattttt
+ctatcatccaacgcgatcgcccattagcttattgtgttactaataacgtatctaaaccaa
+tccttttcaagctactgcctatattgtcaatatatacaaacaacaggatagtaggctgct
+taaaaaatattgtcaaccgtgtacgctttacaatacccggaaatcacaaactttgtagac
+aacgagtgaaatttatacactacgaagggccagcgtacaagacccatgaattaggcgata
+tgtttattctgacatattggtttatccttaatctgtcgctgtaaaatgaagccgccccca
+tccctgcgaattttttttcgaagattcacgactgaaatataaatacgtttggctatattt
+atgttggagggaggcaatagcctttactgttaaccgaagatttagccagtgagtgtgaca
+ctaaaacactggaataaatgcaggcgttcttctgggtaaaaggtttagtcaatctcgcct
+ataagttcatatagctctggatataattatctggcccatgcatttatcatggcgcttggt
+gccctgtgtgaagccggcctctcatattgaaggtccgaagtattccatgtacattaagat
+cactctctcattcatgcatcttggcttaacaaatctggttgtccaagctttccaggcacg
+tatggtacaaattcggatcgaatacttataaaaatgatatgttaaactgtctaaaacgct
+catctacaaagtaaagtgcactaaccaatagagtctcaagaccgtgtaatgctggtgcac
+tgaatgtgtaatacggttagaagggattagttatgttacaaatccattgaaaacttaaga
+agcattgcgtgctcggagggtgcatcttttatcaagagactaacattattttcaacgacg
+tacatgctttacaatagggtacttatcaaacgccgagaaacgcgcctatagtgatgttat
+gattatgacccgatatccattggaccgaattttatgtaggttcccagcgtactcgcgtaa
+tatctcggtattgccataatgtaatacttgtcggtctctcccagatgaaaaagcgttaca
+gagtatttcaatgaaaaacagcgcgcaacgtcaatacctttaggggtaacggccgctgat
+ttcatatagatatacgataagttggtatagctctactaggtggcatccacaatcgttgca
+tttactatagctggttacaatcataatctataccgttccttacatactaccatagcggga
+tagcgtttttttgccgttgattgggtttaagaggatgtcagtctcattatatccgattcg
+gtgggagagccgttgttttcaaatcgcacactttgtgacataatgtacaagataacaaaa
+ctgatataagatataaactgtcaatatcaccttgacacttgaatcaaagtaaattaactc
+gcaaatataatttgactaattgggtgcagatttctcaattaataaaaaaatggcaccgga
+tgggcttacaagccccttatcattcacttgtatcatgatttccaagaacaatagaatttg
+ctagcaagtatgaacagagattcgaattgcatccacagtacgccggagcgtttattttaa
+tgtggatatgacgatgtactgttggcggcatttgctagtaaccggtccttatttacgtag
+cgcacacgtaagcatgtctgggagaaatatggtggtacaatctcagagaaagattacagt
+ttggtttaaataggacttatcgggtcggaagtggaacttaataagcagtacacaattggg
+caacagacgtcttgcctattacaataggattacaatgcgttagatttcagacacgttcgt
+gtttggctattcgtcaattccctaaatagttagacgatcaactattatcaaagtgattct
+ttgttcatcctccattcatgtaacagatggcacactacgcataacgccgaggaattttaa
+cgagatttaagagagcagttcgggcacaacccacttgactttataacagctcggcagcat
+aaacggtaatatgtgacaaatttccaaacgttataagaacgtatgtgtacttagaaaact
+aagtggttcatgttcaacagatgtgacgcagcaagcctaacttatctattggttttgcta
+taaaagaacaaagttacacagaatcctaagggcttgtttcacacttatgcctagtgcttc
+accatcttaaaatagcgaaaccggcacgaatcaaaccttaaaacaatgcgcagatattgg
+tgatggtgactccgggtatgataatggtaactgttgaccagcgcccacctcatcgaagta
+tagaaagtggttaggataaggatgagaccgaacttatttccggccataactttagatttt
+ctacctagtacacaacatcagggcggacacgaaaccgccatcacatcatataccaggttt
+aatttgcttaatgggggaagtgtcaacgaaccttcgaactttagcaggcatatggccatt
+atatatggccccagagcagaatgctacagcagacaaaatttggatttatgtagtttaata
+cctatcaaacttggtgtgaccatacttgtctaacgacagtgcacaaagtgtaagttacaa
+ttattactactcagcagcttctgcaatgataaaatcttatcatacacgtcacatatgata
+atatctacttagggggaacgggctccacaacctacatagtactcaatacttacactattc
+gacaggcacaccaaacctgtacagtcccaaaagattgagtcaactttgcagtactgcaga
+tcacagtaatagcttagttagcgagtcaaaattagttttctacgagactgcacgaccgtg
+caaatttccgatgtgttggctacaaatagcaacgtatgaatttgtttgaagccacgtaaa
+ctgtacaaccttagagataagtctcaggctactaaaaacacgttgtggcactaacaggat
+catggttgattcttacttattcggctgaccggcccaataagtaaccttcaactagaacag
+aataatcgggagtagtttaattcagtcaaggtgcaggtctcattgtaactaacaagctct
+gtgtaaccaagttaaaatcgttttcttagcggattccctacttatggatttgagctcgtc
+cacaatattcgatacaagaagtttgtggtccgtaacaacgaaattttaattacgctgtgc
+agcctcatccaaggaattaatagaaggttgatggtaggctccgaacgctccatgattata
+atcaagtggactgtgcagtaaacgaggaaggtatcctgacgtcgtggtgttcgtttttgt
+tatttgtgccctatacgagtagataaaccatgaacagcacagtgtgaacccatggttgat
+tttaggctaccttatttttaatttccgttacacagaaacgaattccacaactaacatgcc
+attaatttttcgatatcttataaaagatggtcgaaattcattcatttattttttttcggt
+tctcgaaagtcaactaagctgtcgcgttttgtttctctttagaggtaaaagtggctttga
+tctcctacgtttggatactagtcaaccattactccatttgatccgtgagtatcacctgtc
+taacatccagcattatgactcctcggcgaagaaaagacacacttcttagagtcgatgtgt
+attagctagggacacagttgtttaatacgatagtgagcccagggagggcagtgcgtcccc
+cagtagatttattcagctagtgtaagtataagatatctcacccacgaggttcaagtgata
+tgcagtcttagaataatacttatcctgaatttcgatattatgggtacttcaataatccgc
+tagcgctactttatgtctcgttggacagcaggacacatggcagtcttaaacactaaagac
+atcacctgaatgaatgtaatgggattacaagaatcaatgaggtattatatacgacgtagg
+aaactctggatatatacagtaatctagttacgccatcgcacttcattcctctggaaactt
+agaagacatcagctgtacgtggaggaaccagacccccgtatgtagccaaatagaaccaaa
+gttgcttatacaaacacacccaatgacaatggaccgctggagttcgtaaactcggaacgt
+agtactgcacaaacccagcatttagcaataggagctacgtatgcaactcccacgtggtaa
+taccttcaagctatcaatatataggtgcctagctaatcgcattcgcaagcagtattcaag
+cttgtaaaccagtataataattacagaggctctatgaaacccaactttccagctaaaagt
+cccaattaaatggttatttcgtacttttaaagtcgcccgttctgttattacgcgaattga
+ttctactccaaaattaaacacaaattatcaaccgtttcatttatatttgtcaatgcagct
+gtttaaaataaggctctactaaattataattaagacacttattaccagatttctctagtt
+aagtttgaaccagctcgactaccgcgaaagatacattcccttctctatttttcagttcat
+ctatgggtcagagaagcattgaatttattctattcaccctcgtcgttcacagcgaatcgt
+cagtgtgatcagtgtatgagaaatatcctaaaccgtttag
diff --git a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/k-nucleotide/knucleotide-input.txt b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/k-nucleotide/knucleotide-input.txt
new file mode 100644
index 0000000000..f1caba0d62
--- /dev/null
+++ b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/k-nucleotide/knucleotide-input.txt
@@ -0,0 +1,171 @@
+>ONE Homo sapiens alu
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCG
+>TWO IUB ambiguity codes
+cttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcg
+tactDtDagcctatttSVHtHttKtgtHMaSattgWaHKHttttagacatWatgtRgaaa
+NtactMcSMtYtcMgRtacttctWBacgaaatatagScDtttgaagacacatagtVgYgt
+cattHWtMMWcStgttaggKtSgaYaaccWStcgBttgcgaMttBYatcWtgacaYcaga
+gtaBDtRacttttcWatMttDBcatWtatcttactaBgaYtcttgttttttttYaaScYa
+HgtgttNtSatcMtcVaaaStccRcctDaataataStcYtRDSaMtDttgttSagtRRca
+tttHatSttMtWgtcgtatSSagactYaaattcaMtWatttaSgYttaRgKaRtccactt
+tattRggaMcDaWaWagttttgacatgttctacaaaRaatataataaMttcgDacgaSSt
+acaStYRctVaNMtMgtaggcKatcttttattaaaaagVWaHKYagtttttatttaacct
+tacgtVtcVaattVMBcttaMtttaStgacttagattWWacVtgWYagWVRctDattBYt
+gtttaagaagattattgacVatMaacattVctgtBSgaVtgWWggaKHaatKWcBScSWa
+accRVacacaaactaccScattRatatKVtactatatttHttaagtttSKtRtacaaagt
+RDttcaaaaWgcacatWaDgtDKacgaacaattacaRNWaatHtttStgttattaaMtgt
+tgDcgtMgcatBtgcttcgcgaDWgagctgcgaggggVtaaScNatttacttaatgacag
+cccccacatYScaMgtaggtYaNgttctgaMaacNaMRaacaaacaKctacatagYWctg
+ttWaaataaaataRattagHacacaagcgKatacBttRttaagtatttccgatctHSaat
+actcNttMaagtattMtgRtgaMgcataatHcMtaBSaRattagttgatHtMttaaKagg
+YtaaBataSaVatactWtataVWgKgttaaaacagtgcgRatatacatVtHRtVYataSa
+KtWaStVcNKHKttactatccctcatgWHatWaRcttactaggatctataDtDHBttata
+aaaHgtacVtagaYttYaKcctattcttcttaataNDaaggaaaDYgcggctaaWSctBa
+aNtgctggMBaKctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacg
+gtttNattgVtttctgtBaWgtaattcaagtcaVWtactNggattctttaYtaaagccgc
+tcttagHVggaYtgtNcDaVagctctctKgacgtatagYcctRYHDtgBattDaaDgccK
+tcHaaStttMcctagtattgcRgWBaVatHaaaataYtgtttagMDMRtaataaggatMt
+ttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtcattttcWattRSHcVagaagtacg
+ggtaKVattKYagactNaatgtttgKMMgYNtcccgSKttctaStatatNVataYHgtNa
+BKRgNacaactgatttcctttaNcgatttctctataScaHtataRagtcRVttacDSDtt
+aRtSatacHgtSKacYagttMHtWataggatgactNtatSaNctataVtttRNKtgRacc
+tttYtatgttactttttcctttaaacatacaHactMacacggtWataMtBVacRaSaatc
+cgtaBVttccagccBcttaRKtgtgcctttttRtgtcagcRttKtaaacKtaaatctcac
+aattgcaNtSBaaccgggttattaaBcKatDagttactcttcattVtttHaaggctKKga
+tacatcBggScagtVcacattttgaHaDSgHatRMaHWggtatatRgccDttcgtatcga
+aacaHtaagttaRatgaVacttagattVKtaaYttaaatcaNatccRttRRaMScNaaaD
+gttVHWgtcHaaHgacVaWtgttScactaagSgttatcttagggDtaccagWattWtRtg
+ttHWHacgattBtgVcaYatcggttgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcV
+taBtWaaYatcDRaaRtSctgaHaYRttagatMatgcatttNattaDttaattgttctaa
+ccctcccctagaWBtttHtBccttagaVaatMcBHagaVcWcagBVttcBtaYMccagat
+gaaaaHctctaacgttagNWRtcggattNatcRaNHttcagtKttttgWatWttcSaNgg
+gaWtactKKMaacatKatacNattgctWtatctaVgagctatgtRaHtYcWcttagccaa
+tYttWttaWSSttaHcaaaaagVacVgtaVaRMgattaVcDactttcHHggHRtgNcctt
+tYatcatKgctcctctatVcaaaaKaaaagtatatctgMtWtaaaacaStttMtcgactt
+taSatcgDataaactaaacaagtaaVctaggaSccaatMVtaaSKNVattttgHccatca
+cBVctgcaVatVttRtactgtVcaattHgtaaattaaattttYtatattaaRSgYtgBag
+aHSBDgtagcacRHtYcBgtcacttacactaYcgctWtattgSHtSatcataaatataHt
+cgtYaaMNgBaatttaRgaMaatatttBtttaaaHHKaatctgatWatYaacttMctctt
+ttVctagctDaaagtaVaKaKRtaacBgtatccaaccactHHaagaagaaggaNaaatBW
+attccgStaMSaMatBttgcatgRSacgttVVtaaDMtcSgVatWcaSatcttttVatag
+ttactttacgatcaccNtaDVgSRcgVcgtgaacgaNtaNatatagtHtMgtHcMtagaa
+attBgtataRaaaacaYKgtRccYtatgaagtaataKgtaaMttgaaRVatgcagaKStc
+tHNaaatctBBtcttaYaBWHgtVtgacagcaRcataWctcaBcYacYgatDgtDHccta
+>THREE Homo sapiens frequency
+aacacttcaccaggtatcgtgaaggctcaagattacccagagaacctttgcaatataaga
+atatgtatgcagcattaccctaagtaattatattctttttctgactcaaagtgacaagcc
+ctagtgtatattaaatcggtatatttgggaaattcctcaaactatcctaatcaggtagcc
+atgaaagtgatcaaaaaagttcgtacttataccatacatgaattctggccaagtaaaaaa
+tagattgcgcaaaattcgtaccttaagtctctcgccaagatattaggatcctattactca
+tatcgtgtttttctttattgccgccatccccggagtatctcacccatccttctcttaaag
+gcctaatattacctatgcaaataaacatatattgttgaaaattgagaacctgatcgtgat
+tcttatgtgtaccatatgtatagtaatcacgcgactatatagtgctttagtatcgcccgt
+gggtgagtgaatattctgggctagcgtgagatagtttcttgtcctaatatttttcagatc
+gaatagcttctatttttgtgtttattgacatatgtcgaaactccttactcagtgaaagtc
+atgaccagatccacgaacaatcttcggaatcagtctcgttttacggcggaatcttgagtc
+taacttatatcccgtcgcttactttctaacaccccttatgtatttttaaaattacgttta
+ttcgaacgtacttggcggaagcgttattttttgaagtaagttacattgggcagactcttg
+acattttcgatacgactttctttcatccatcacaggactcgttcgtattgatatcagaag
+ctcgtgatgattagttgtcttctttaccaatactttgaggcctattctgcgaaatttttg
+ttgccctgcgaacttcacataccaaggaacacctcgcaacatgccttcatatccatcgtt
+cattgtaattcttacacaatgaatcctaagtaattacatccctgcgtaaaagatggtagg
+ggcactgaggatatattaccaagcatttagttatgagtaatcagcaatgtttcttgtatt
+aagttctctaaaatagttacatcgtaatgttatctcgggttccgcgaataaacgagatag
+attcattatatatggccctaagcaaaaacctcctcgtattctgttggtaattagaatcac
+acaatacgggttgagatattaattatttgtagtacgaagagatataaaaagatgaacaat
+tactcaagtcaagatgtatacgggatttataataaaaatcgggtagagatctgctttgca
+attcagacgtgccactaaatcgtaatatgtcgcgttacatcagaaagggtaactattatt
+aattaataaagggcttaatcactacatattagatcttatccgatagtcttatctattcgt
+tgtatttttaagcggttctaattcagtcattatatcagtgctccgagttctttattattg
+ttttaaggatgacaaaatgcctcttgttataacgctgggagaagcagactaagagtcgga
+gcagttggtagaatgaggctgcaaaagacggtctcgacgaatggacagactttactaaac
+caatgaaagacagaagtagagcaaagtctgaagtggtatcagcttaattatgacaaccct
+taatacttccctttcgccgaatactggcgtggaaaggttttaaaagtcgaagtagttaga
+ggcatctctcgctcataaataggtagactactcgcaatccaatgtgactatgtaatactg
+ggaacatcagtccgcgatgcagcgtgtttatcaaccgtccccactcgcctggggagacat
+gagaccacccccgtggggattattagtccgcagtaatcgactcttgacaatccttttcga
+ttatgtcatagcaatttacgacagttcagcgaagtgactactcggcgaaatggtattact
+aaagcattcgaacccacatgaatgtgattcttggcaatttctaatccactaaagcttttc
+cgttgaatctggttgtagatatttatataagttcactaattaagatcacggtagtatatt
+gatagtgatgtctttgcaagaggttggccgaggaatttacggattctctattgatacaat
+ttgtctggcttataactcttaaggctgaaccaggcgtttttagacgacttgatcagctgt
+tagaatggtttggactccctctttcatgtcagtaacatttcagccgttattgttacgata
+tgcttgaacaatattgatctaccacacacccatagtatattttataggtcatgctgttac
+ctacgagcatggtattccacttcccattcaatgagtattcaacatcactagcctcagaga
+tgatgacccacctctaataacgtcacgttgcggccatgtgaaacctgaacttgagtagac
+gatatcaagcgctttaaattgcatataacatttgagggtaaagctaagcggatgctttat
+ataatcaatactcaataataagatttgattgcattttagagttatgacacgacatagttc
+actaacgagttactattcccagatctagactgaagtactgatcgagacgatccttacgtc
+gatgatcgttagttatcgacttaggtcgggtctctagcggtattggtacttaaccggaca
+ctatactaataacccatgatcaaagcataacagaatacagacgataatttcgccaacata
+tatgtacagaccccaagcatgagaagctcattgaaagctatcattgaagtcccgctcaca
+atgtgtcttttccagacggtttaactggttcccgggagtcctggagtttcgacttacata
+aatggaaacaatgtattttgctaatttatctatagcgtcatttggaccaatacagaatat
+tatgttgcctagtaatccactataacccgcaagtgctgatagaaaatttttagacgattt
+ataaatgccccaagtatccctcccgtgaatcctccgttatactaattagtattcgttcat
+acgtataccgcgcatatatgaacatttggcgataaggcgcgtgaattgttacgtgacaga
+gatagcagtttcttgtgatatggttaacagacgtacatgaagggaaactttatatctata
+gtgatgcttccgtagaaataccgccactggtctgccaatgatgaagtatgtagctttagg
+tttgtactatgaggctttcgtttgtttgcagagtataacagttgcgagtgaaaaaccgac
+gaatttatactaatacgctttcactattggctacaaaatagggaagagtttcaatcatga
+gagggagtatatggatgctttgtagctaaaggtagaacgtatgtatatgctgccgttcat
+tcttgaaagatacataagcgataagttacgacaattataagcaacatccctaccttcgta
+acgatttcactgttactgcgcttgaaatacactatggggctattggcggagagaagcaga
+tcgcgccgagcatatacgagacctataatgttgatgatagagaaggcgtctgaattgata
+catcgaagtacactttctttcgtagtatctctcgtcctctttctatctccggacacaaga
+attaagttatatatatagagtcttaccaatcatgttgaatcctgattctcagagttcttt
+ggcgggccttgtgatgactgagaaacaatgcaatattgctccaaatttcctaagcaaatt
+ctcggttatgttatgttatcagcaaagcgttacgttatgttatttaaatctggaatgacg
+gagcgaagttcttatgtcggtgtgggaataattcttttgaagacagcactccttaaataa
+tatcgctccgtgtttgtatttatcgaatgggtctgtaaccttgcacaagcaaatcggtgg
+tgtatatatcggataacaattaatacgatgttcatagtgacagtatactgatcgagtcct
+ctaaagtcaattacctcacttaacaatctcattgatgttgtgtcattcccggtatcgccc
+gtagtatgtgctctgattgaccgagtgtgaaccaaggaacatctactaatgcctttgtta
+ggtaagatctctctgaattccttcgtgccaacttaaaacattatcaaaatttcttctact
+tggattaactacttttacgagcatggcaaattcccctgtggaagacggttcattattatc
+ggaaaccttatagaaattgcgtgttgactgaaattagatttttattgtaagagttgcatc
+tttgcgattcctctggtctagcttccaatgaacagtcctcccttctattcgacatcgggt
+ccttcgtacatgtctttgcgatgtaataattaggttcggagtgtggccttaatgggtgca
+actaggaatacaacgcaaatttgctgacatgatagcaaatcggtatgccggcaccaaaac
+gtgctccttgcttagcttgtgaatgagactcagtagttaaataaatccatatctgcaatc
+gattccacaggtattgtccactatctttgaactactctaagagatacaagcttagctgag
+accgaggtgtatatgactacgctgatatctgtaaggtaccaatgcaggcaaagtatgcga
+gaagctaataccggctgtttccagctttataagattaaaatttggctgtcctggcggcct
+cagaattgttctatcgtaatcagttggttcattaattagctaagtacgaggtacaactta
+tctgtcccagaacagctccacaagtttttttacagccgaaacccctgtgtgaatcttaat
+atccaagcgcgttatctgattagagtttacaactcagtattttatcagtacgttttgttt
+ccaacattacccggtatgacaaaatgacgccacgtgtcgaataatggtctgaccaatgta
+ggaagtgaaaagataaatat
diff --git a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/regexdna/regexdna-input25.txt b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/regexdna/regexdna-input25.txt
new file mode 100644
index 0000000000..c32ac3c876
--- /dev/null
+++ b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/regexdna/regexdna-input25.txt
@@ -0,0 +1,9 @@
+>ONE Homo sapiens alu
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+>TWO IUB ambiguity codes
+cttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcg
+tactDtDagcctatt
+>THREE Homo sapiens frequency
+agggtaaagtttgtgttgcgttatagtctatttgtggacacagtatggtcaaatgacgtc
+ttttccctttaacaaagatactctgggcaacacacatacttctctcatgttgtttcttcg
+gacct
diff --git a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/regexdna/regexdna-input25000.txt b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/regexdna/regexdna-input25000.txt
new file mode 100644
index 0000000000..fd4414b176
--- /dev/null
+++ b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/regexdna/regexdna-input25000.txt
@@ -0,0 +1,4171 @@
+>ONE Homo sapiens alu
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATC
+>TWO IUB ambiguity codes
+cttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcg
+tactDtDagcctatttSVHtHttKtgtHMaSattgWaHKHttttagacatWatgtRgaaa
+NtactMcSMtYtcMgRtacttctWBacgaaatatagScDtttgaagacacatagtVgYgt
+cattHWtMMWcStgttaggKtSgaYaaccWStcgBttgcgaMttBYatcWtgacaYcaga
+gtaBDtRacttttcWatMttDBcatWtatcttactaBgaYtcttgttttttttYaaScYa
+HgtgttNtSatcMtcVaaaStccRcctDaataataStcYtRDSaMtDttgttSagtRRca
+tttHatSttMtWgtcgtatSSagactYaaattcaMtWatttaSgYttaRgKaRtccactt
+tattRggaMcDaWaWagttttgacatgttctacaaaRaatataataaMttcgDacgaSSt
+acaStYRctVaNMtMgtaggcKatcttttattaaaaagVWaHKYagtttttatttaacct
+tacgtVtcVaattVMBcttaMtttaStgacttagattWWacVtgWYagWVRctDattBYt
+gtttaagaagattattgacVatMaacattVctgtBSgaVtgWWggaKHaatKWcBScSWa
+accRVacacaaactaccScattRatatKVtactatatttHttaagtttSKtRtacaaagt
+RDttcaaaaWgcacatWaDgtDKacgaacaattacaRNWaatHtttStgttattaaMtgt
+tgDcgtMgcatBtgcttcgcgaDWgagctgcgaggggVtaaScNatttacttaatgacag
+cccccacatYScaMgtaggtYaNgttctgaMaacNaMRaacaaacaKctacatagYWctg
+ttWaaataaaataRattagHacacaagcgKatacBttRttaagtatttccgatctHSaat
+actcNttMaagtattMtgRtgaMgcataatHcMtaBSaRattagttgatHtMttaaKagg
+YtaaBataSaVatactWtataVWgKgttaaaacagtgcgRatatacatVtHRtVYataSa
+KtWaStVcNKHKttactatccctcatgWHatWaRcttactaggatctataDtDHBttata
+aaaHgtacVtagaYttYaKcctattcttcttaataNDaaggaaaDYgcggctaaWSctBa
+aNtgctggMBaKctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacg
+gtttNattgVtttctgtBaWgtaattcaagtcaVWtactNggattctttaYtaaagccgc
+tcttagHVggaYtgtNcDaVagctctctKgacgtatagYcctRYHDtgBattDaaDgccK
+tcHaaStttMcctagtattgcRgWBaVatHaaaataYtgtttagMDMRtaataaggatMt
+ttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtcattttcWattRSHcVagaagtacg
+ggtaKVattKYagactNaatgtttgKMMgYNtcccgSKttctaStatatNVataYHgtNa
+BKRgNacaactgatttcctttaNcgatttctctataScaHtataRagtcRVttacDSDtt
+aRtSatacHgtSKacYagttMHtWataggatgactNtatSaNctataVtttRNKtgRacc
+tttYtatgttactttttcctttaaacatacaHactMacacggtWataMtBVacRaSaatc
+cgtaBVttccagccBcttaRKtgtgcctttttRtgtcagcRttKtaaacKtaaatctcac
+aattgcaNtSBaaccgggttattaaBcKatDagttactcttcattVtttHaaggctKKga
+tacatcBggScagtVcacattttgaHaDSgHatRMaHWggtatatRgccDttcgtatcga
+aacaHtaagttaRatgaVacttagattVKtaaYttaaatcaNatccRttRRaMScNaaaD
+gttVHWgtcHaaHgacVaWtgttScactaagSgttatcttagggDtaccagWattWtRtg
+ttHWHacgattBtgVcaYatcggttgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcV
+taBtWaaYatcDRaaRtSctgaHaYRttagatMatgcatttNattaDttaattgttctaa
+ccctcccctagaWBtttHtBccttagaVaatMcBHagaVcWcagBVttcBtaYMccagat
+gaaaaHctctaacgttagNWRtcggattNatcRaNHttcagtKttttgWatWttcSaNgg
+gaWtactKKMaacatKatacNattgctWtatctaVgagctatgtRaHtYcWcttagccaa
+tYttWttaWSSttaHcaaaaagVacVgtaVaRMgattaVcDactttcHHggHRtgNcctt
+tYatcatKgctcctctatVcaaaaKaaaagtatatctgMtWtaaaacaStttMtcgactt
+taSatcgDataaactaaacaagtaaVctaggaSccaatMVtaaSKNVattttgHccatca
+cBVctgcaVatVttRtactgtVcaattHgtaaattaaattttYtatattaaRSgYtgBag
+aHSBDgtagcacRHtYcBgtcacttacactaYcgctWtattgSHtSatcataaatataHt
+cgtYaaMNgBaatttaRgaMaatatttBtttaaaHHKaatctgatWatYaacttMctctt
+ttVctagctDaaagtaVaKaKRtaacBgtatccaaccactHHaagaagaaggaNaaatBW
+attccgStaMSaMatBttgcatgRSacgttVVtaaDMtcSgVatWcaSatcttttVatag
+ttactttacgatcaccNtaDVgSRcgVcgtgaacgaNtaNatatagtHtMgtHcMtagaa
+attBgtataRaaaacaYKgtRccYtatgaagtaataKgtaaMttgaaRVatgcagaKStc
+tHNaaatctBBtcttaYaBWHgtVtgacagcaRcataWctcaBcYacYgatDgtDHccta
+aagacYRcaggattHaYgtKtaatgcVcaataMYacccatatcacgWDBtgaatcBaata
+cKcttRaRtgatgaBDacggtaattaaYtataStgVHDtDctgactcaaatKtacaatgc
+gYatBtRaDatHaactgtttatatDttttaaaKVccYcaaccNcBcgHaaVcattHctcg
+attaaatBtatgcaaaaatYMctSactHatacgaWacattacMBgHttcgaatVaaaaca
+BatatVtctgaaaaWtctRacgBMaatSgRgtgtcgactatcRtattaScctaStagKga
+DcWgtYtDDWKRgRtHatRtggtcgaHgggcgtattaMgtcagccaBggWVcWctVaaat
+tcgNaatcKWagcNaHtgaaaSaaagctcYctttRVtaaaatNtataaccKtaRgtttaM
+tgtKaBtRtNaggaSattHatatWactcagtgtactaKctatttgRYYatKatgtccgtR
+tttttatttaatatVgKtttgtatgtNtataRatWYNgtRtHggtaaKaYtKSDcatcKg
+taaYatcSRctaVtSMWtVtRWHatttagataDtVggacagVcgKWagBgatBtaaagNc
+aRtagcataBggactaacacRctKgttaatcctHgDgttKHHagttgttaatgHBtatHc
+DaagtVaBaRccctVgtgDtacRHSctaagagcggWYaBtSaKtHBtaaactYacgNKBa
+VYgtaacttagtVttcttaatgtBtatMtMtttaattaatBWccatRtttcatagVgMMt
+agctStKctaMactacDNYgKYHgaWcgaHgagattacVgtttgtRaSttaWaVgataat
+gtgtYtaStattattMtNgWtgttKaccaatagNYttattcgtatHcWtctaaaNVYKKt
+tWtggcDtcgaagtNcagatacgcattaagaccWctgcagcttggNSgaNcHggatgtVt
+catNtRaaBNcHVagagaaBtaaSggDaatWaatRccaVgggStctDaacataKttKatt
+tggacYtattcSatcttagcaatgaVBMcttDattctYaaRgatgcattttNgVHtKcYR
+aatRKctgtaaacRatVSagctgtWacBtKVatctgttttKcgtctaaDcaagtatcSat
+aWVgcKKataWaYttcccSaatgaaaacccWgcRctWatNcWtBRttYaattataaNgac
+acaatagtttVNtataNaYtaatRaVWKtBatKagtaatataDaNaaaaataMtaagaaS
+tccBcaatNgaataWtHaNactgtcDtRcYaaVaaaaaDgtttRatctatgHtgttKtga
+aNSgatactttcgagWaaatctKaaDaRttgtggKKagcDgataaattgSaacWaVtaNM
+acKtcaDaaatttctRaaVcagNacaScRBatatctRatcctaNatWgRtcDcSaWSgtt
+RtKaRtMtKaatgttBHcYaaBtgatSgaSWaScMgatNtctcctatttctYtatMatMt
+RRtSaattaMtagaaaaStcgVgRttSVaScagtgDtttatcatcatacRcatatDctta
+tcatVRtttataaHtattcYtcaaaatactttgVctagtaaYttagatagtSYacKaaac
+gaaKtaaatagataatSatatgaaatSgKtaatVtttatcctgKHaatHattagaaccgt
+YaaHactRcggSBNgtgctaaBagBttgtRttaaattYtVRaaaattgtaatVatttctc
+ttcatgBcVgtgKgaHaaatattYatagWacNctgaaMcgaattStagWaSgtaaKagtt
+ttaagaDgatKcctgtaHtcatggKttVDatcaaggtYcgccagNgtgcVttttagagat
+gctaccacggggtNttttaSHaNtatNcctcatSaaVgtactgBHtagcaYggYVKNgta
+KBcRttgaWatgaatVtagtcgattYgatgtaatttacDacSctgctaaaStttaWMagD
+aaatcaVYctccgggcgaVtaaWtStaKMgDtttcaaMtVgBaatccagNaaatcYRMBg
+gttWtaaScKttMWtYataRaDBMaDataatHBcacDaaKDactaMgagttDattaHatH
+taYatDtattDcRNStgaatattSDttggtattaaNSYacttcDMgYgBatWtaMagact
+VWttctttgYMaYaacRgHWaattgRtaagcattctMKVStatactacHVtatgatcBtV
+NataaBttYtSttacKgggWgYDtgaVtYgatDaacattYgatggtRDaVDttNactaSa
+MtgNttaacaaSaBStcDctaccacagacgcaHatMataWKYtaYattMcaMtgSttDag
+cHacgatcaHttYaKHggagttccgatYcaatgatRaVRcaagatcagtatggScctata
+ttaNtagcgacgtgKaaWaactSgagtMYtcttccaKtStaacggMtaagNttattatcg
+tctaRcactctctDtaacWYtgaYaSaagaWtNtatttRacatgNaatgttattgWDDcN
+aHcctgaaHacSgaataaRaataMHttatMtgaSDSKatatHHaNtacagtccaYatWtc
+actaactatKDacSaStcggataHgYatagKtaatKagStaNgtatactatggRHacttg
+tattatgtDVagDVaRctacMYattDgtttYgtctatggtKaRSttRccRtaaccttaga
+gRatagSaaMaacgcaNtatgaaatcaRaagataatagatactcHaaYKBctccaagaRa
+BaStNagataggcgaatgaMtagaatgtcaKttaaatgtaWcaBttaatRcggtgNcaca
+aKtttScRtWtgcatagtttWYaagBttDKgcctttatMggNttattBtctagVtacata
+aaYttacacaaRttcYtWttgHcaYYtaMgBaBatctNgcDtNttacgacDcgataaSat
+YaSttWtcctatKaatgcagHaVaacgctgcatDtgttaSataaaaYSNttatagtaNYt
+aDaaaNtggggacttaBggcHgcgtNtaaMcctggtVtaKcgNacNtatVaSWctWtgaW
+cggNaBagctctgaYataMgaagatBSttctatacttgtgtKtaattttRagtDtacata
+tatatgatNHVgBMtKtaKaNttDHaagatactHaccHtcatttaaagttVaMcNgHata
+tKtaNtgYMccttatcaaNagctggacStttcNtggcaVtattactHaSttatgNMVatt
+MMDtMactattattgWMSgtHBttStStgatatRaDaagattttctatMtaaaaaggtac
+taaVttaSacNaatactgMttgacHaHRttgMacaaaatagttaatatWKRgacDgaRta
+tatttattatcYttaWtgtBRtWatgHaaattHataagtVaDtWaVaWtgStcgtMSgaS
+RgMKtaaataVacataatgtaSaatttagtcgaaHtaKaatgcacatcggRaggSKctDc
+agtcSttcccStYtccRtctctYtcaaKcgagtaMttttcRaYDttgttatctaatcata
+NctctgctatcaMatactataggDaHaaSttMtaDtcNatataattctMcStaaBYtaNa
+gatgtaatHagagSttgWHVcttatKaYgDctcttggtgttMcRaVgSgggtagacaata
+aDtaattSaDaNaHaBctattgNtaccaaRgaVtKNtaaYggHtaKKgHcatctWtctDt
+ttctttggSDtNtaStagttataaacaattgcaBaBWggHgcaaaBtYgctaatgaaatW
+cDcttHtcMtWWattBHatcatcaaatctKMagtDNatttWaBtHaaaNgMttaaStagt
+tctctaatDtcRVaYttgttMtRtgtcaSaaYVgSWDRtaatagctcagDgcWWaaaBaa
+RaBctgVgggNgDWStNaNBKcBctaaKtttDcttBaaggBttgaccatgaaaNgttttt
+tttatctatgttataccaaDRaaSagtaVtDtcaWatBtacattaWacttaSgtattggD
+gKaaatScaattacgWcagKHaaccaYcRcaRttaDttRtttHgaHVggcttBaRgtccc
+tDatKaVtKtcRgYtaKttacgtatBtStaagcaattaagaRgBagSaattccSWYttta
+ttVaataNctgHgttaaNBgcVYgtRtcccagWNaaaacaDNaBcaaaaRVtcWMgBagM
+tttattacgDacttBtactatcattggaaatVccggttRttcatagttVYcatYaSHaHc
+ttaaagcNWaHataaaRWtctVtRYtagHtaaaYMataHYtNBctNtKaatattStgaMc
+BtRgctaKtgcScSttDgYatcVtggaaKtaagatWccHccgKYctaNNctacaWctttt
+gcRtgtVcgaKttcMRHgctaHtVaataaDtatgKDcttatBtDttggNtacttttMtga
+acRattaaNagaactcaaaBBVtcDtcgaStaDctgaaaSgttMaDtcgttcaccaaaag
+gWtcKcgSMtcDtatgtttStaaBtatagDcatYatWtaaaBacaKgcaDatgRggaaYc
+taRtccagattDaWtttggacBaVcHtHtaacDacYgtaatataMagaatgHMatcttat
+acgtatttttatattacHactgttataMgStYaattYaccaattgagtcaaattaYtgta
+tcatgMcaDcgggtcttDtKgcatgWRtataatatRacacNRBttcHtBgcRttgtgcgt
+catacMtttBctatctBaatcattMttMYgattaaVYatgDaatVagtattDacaacDMa
+tcMtHcccataagatgBggaccattVWtRtSacatgctcaaggggYtttDtaaNgNtaaB
+atggaatgtctRtaBgBtcNYatatNRtagaacMgagSaSDDSaDcctRagtVWSHtVSR
+ggaacaBVaccgtttaStagaacaMtactccagtttVctaaRaaHttNcttagcaattta
+ttaatRtaaaatctaacDaBttggSagagctacHtaaRWgattcaaBtctRtSHaNtgta
+cattVcaHaNaagtataccacaWtaRtaaVKgMYaWgttaKggKMtKcgWatcaDatYtK
+SttgtacgaccNctSaattcDcatcttcaaaDKttacHtggttHggRRaRcaWacaMtBW
+VHSHgaaMcKattgtaRWttScNattBBatYtaNRgcggaagacHSaattRtttcYgacc
+BRccMacccKgatgaacttcgDgHcaaaaaRtatatDtatYVtttttHgSHaSaatagct
+NYtaHYaVYttattNtttgaaaYtaKttWtctaNtgagaaaNctNDctaaHgttagDcRt
+tatagccBaacgcaRBtRctRtggtaMYYttWtgataatcgaataattattataVaaaaa
+ttacNRVYcaaMacNatRttcKatMctgaagactaattataaYgcKcaSYaatMNctcaa
+cgtgatttttBacNtgatDccaattattKWWcattttatatatgatBcDtaaaagttgaa
+VtaHtaHHtBtataRBgtgDtaataMttRtDgDcttattNtggtctatctaaBcatctaR
+atgNacWtaatgaagtcMNaacNgHttatactaWgcNtaStaRgttaaHacccgaYStac
+aaaatWggaYaWgaattattcMaactcBKaaaRVNcaNRDcYcgaBctKaacaaaaaSgc
+tccYBBHYaVagaatagaaaacagYtctVccaMtcgtttVatcaatttDRtgWctagtac
+RttMctgtDctttcKtWttttataaatgVttgBKtgtKWDaWagMtaaagaaattDVtag
+gttacatcatttatgtcgMHaVcttaBtVRtcgtaYgBRHatttHgaBcKaYWaatcNSc
+tagtaaaaatttacaatcactSWacgtaatgKttWattagttttNaggtctcaagtcact
+attcttctaagKggaataMgtttcataagataaaaatagattatDgcBVHWgaBKttDgc
+atRHaagcaYcRaattattatgtMatatattgHDtcaDtcaaaHctStattaatHaccga
+cNattgatatattttgtgtDtRatagSacaMtcRtcattcccgacacSattgttKaWatt
+NHcaacttccgtttSRtgtctgDcgctcaaMagVtBctBMcMcWtgtaacgactctcttR
+ggRKSttgYtYatDccagttDgaKccacgVatWcataVaaagaataMgtgataaKYaaat
+cHDaacgataYctRtcYatcgcaMgtNttaBttttgatttaRtStgcaacaaaataccVg
+aaDgtVgDcStctatatttattaaaaRKDatagaaagaKaaYYcaYSgKStctccSttac
+agtcNactttDVttagaaagMHttRaNcSaRaMgBttattggtttaRMggatggcKDgWR
+tNaataataWKKacttcKWaaagNaBttaBatMHtccattaacttccccYtcBcYRtaga
+ttaagctaaYBDttaNtgaaaccHcaRMtKtaaHMcNBttaNaNcVcgVttWNtDaBatg
+ataaVtcWKcttRggWatcattgaRagHgaattNtatttctctattaattaatgaDaaMa
+tacgttgggcHaYVaaNaDDttHtcaaHtcVVDgBVagcMacgtgttaaBRNtatRtcag
+taagaggtttaagacaVaaggttaWatctccgtVtaDtcDatttccVatgtacNtttccg
+tHttatKgScBatgtVgHtYcWagcaKtaMYaaHgtaattaSaHcgcagtWNaatNccNN
+YcacgVaagaRacttctcattcccRtgtgtaattagcSttaaStWaMtctNNcSMacatt
+ataaactaDgtatWgtagtttaagaaaattgtagtNagtcaataaatttgatMMYactaa
+tatcggBWDtVcYttcDHtVttatacYaRgaMaacaStaatcRttttVtagaDtcacWat
+ttWtgaaaagaaagNRacDtttStVatBaDNtaactatatcBSMcccaSttccggaMatg
+attaaWatKMaBaBatttgataNctgttKtVaagtcagScgaaaDggaWgtgttttKtWt
+atttHaatgtagttcactaaKMagttSYBtKtaYgaactcagagRtatagtVtatcaaaW
+YagcgNtaDagtacNSaaYDgatBgtcgataacYDtaaactacagWDcYKaagtttatta
+gcatcgagttKcatDaattgattatDtcagRtWSKtcgNtMaaaaacaMttKcaWcaaSV
+MaaaccagMVtaMaDtMaHaBgaacataBBVtaatVYaNSWcSgNtDNaaKacacBttta
+tKtgtttcaaHaMctcagtaacgtcgYtactDcgcctaNgagagcYgatattttaaattt
+ccattttacatttDaaRctattttWctttacgtDatYtttcagacgcaaVttagtaaKaa
+aRtgVtccataBggacttatttgtttaWNtgttVWtaWNVDaattgtatttBaagcBtaa
+BttaaVatcHcaVgacattccNggtcgacKttaaaRtagRtctWagaYggtgMtataatM
+tgaaRttattttgWcttNtDRRgMDKacagaaaaggaaaRStcccagtYccVattaNaaK
+StNWtgacaVtagaagcttSaaDtcacaacgDYacWDYtgtttKatcVtgcMaDaSKStV
+cgtagaaWaKaagtttcHaHgMgMtctataagBtKaaaKKcactggagRRttaagaBaaN
+atVVcgRcKSttDaactagtSttSattgttgaaRYatggttVttaataaHttccaagDtg
+atNWtaagHtgcYtaactRgcaatgMgtgtRaatRaNaacHKtagactactggaatttcg
+ccataacgMctRgatgttaccctaHgtgWaYcactcacYaattcttaBtgacttaaacct
+gYgaWatgBttcttVttcgttWttMcNYgtaaaatctYgMgaaattacNgaHgaacDVVM
+tttggtHtctaaRgtacagacgHtVtaBMNBgattagcttaRcttacaHcRctgttcaaD
+BggttKaacatgKtttYataVaNattccgMcgcgtagtRaVVaattaKaatggttRgaMc
+agtatcWBttNtHagctaatctagaaNaaacaYBctatcgcVctBtgcaaagDgttVtga
+HtactSNYtaaNccatgtgDacgaVtDcgKaRtacDcttgctaagggcagMDagggtBWR
+tttSgccttttttaacgtcHctaVtVDtagatcaNMaVtcVacatHctDWNaataRgcgt
+aVHaggtaaaaSgtttMtattDgBtctgatSgtRagagYtctSaKWaataMgattRKtaa
+catttYcgtaacacattRWtBtcggtaaatMtaaacBatttctKagtcDtttgcBtKYYB
+aKttctVttgttaDtgattttcttccacttgSaaacggaaaNDaattcYNNaWcgaaYat
+tttMgcBtcatRtgtaaagatgaWtgaccaYBHgaatagataVVtHtttVgYBtMctaMt
+cctgaDcYttgtccaaaRNtacagcMctKaaaggatttacatgtttaaWSaYaKttBtag
+DacactagctMtttNaKtctttcNcSattNacttggaacaatDagtattRtgSHaataat
+gccVgacccgatactatccctgtRctttgagaSgatcatatcgDcagWaaHSgctYYWta
+tHttggttctttatVattatcgactaagtgtagcatVgtgHMtttgtttcgttaKattcM
+atttgtttWcaaStNatgtHcaaaDtaagBaKBtRgaBgDtSagtatMtaacYaatYtVc
+KatgtgcaacVaaaatactKcRgtaYtgtNgBBNcKtcttaccttKgaRaYcaNKtactt
+tgagSBtgtRagaNgcaaaNcacagtVtttHWatgttaNatBgtttaatNgVtctgaata
+tcaRtattcttttttttRaaKcRStctcggDgKagattaMaaaKtcaHacttaataataK
+taRgDtKVBttttcgtKaggHHcatgttagHggttNctcgtatKKagVagRaaaggaaBt
+NatttVKcRttaHctaHtcaaatgtaggHccaBataNaNaggttgcWaatctgatYcaaa
+HaatWtaVgaaBttagtaagaKKtaaaKtRHatMaDBtBctagcatWtatttgWttVaaa
+ScMNattRactttgtYtttaaaagtaagtMtaMaSttMBtatgaBtttaKtgaatgagYg
+tNNacMtcNRacMMHcttWtgtRtctttaacaacattattcYaMagBaacYttMatcttK
+cRMtgMNccattaRttNatHaHNaSaaHMacacaVaatacaKaSttHatattMtVatWga
+ttttttaYctttKttHgScWaacgHtttcaVaaMgaacagNatcgttaacaaaaagtaca
+HBNaattgttKtcttVttaaBtctgctacgBgcWtttcaggacacatMgacatcccagcg
+gMgaVKaBattgacttaatgacacacaaaaaatRKaaBctacgtRaDcgtagcVBaacDS
+BHaaaaSacatatacagacRNatcttNaaVtaaaataHattagtaaaaSWccgtatWatg
+gDttaactattgcccatcttHaSgYataBttBaactattBtcHtgatcaataSttaBtat
+KSHYttWggtcYtttBttaataccRgVatStaHaKagaatNtagRMNgtcttYaaSaact
+cagDSgagaaYtMttDtMRVgWKWtgMaKtKaDttttgactatacataatcNtatNaHat
+tVagacgYgatatatttttgtStWaaatctWaMgagaRttRatacgStgattcttaagaD
+taWccaaatRcagcagaaNKagtaaDggcgccBtYtagSBMtactaaataMataBSacRM
+gDgattMMgtcHtcaYDtRaDaacggttDaggcMtttatgttaNctaattaVacgaaMMt
+aatDccSgtattgaRtWWaccaccgagtactMcgVNgctDctaMScatagcgtcaactat
+acRacgHRttgctatttaatgaattataYKttgtaagWgtYttgcHgMtaMattWaWVta
+RgcttgYgttBHtYataSccStBtgtagMgtDtggcVaaSBaatagDttgBgtctttctc
+attttaNagtHKtaMWcYactVcgcgtatMVtttRacVagDaatcttgctBBcRDgcaac
+KttgatSKtYtagBMagaRtcgBattHcBWcaactgatttaatttWDccatttatcgagS
+KaWttataHactaHMttaatHtggaHtHagaatgtKtaaRactgtttMatacgatcaagD
+gatKaDctataMggtHDtggHacctttRtatcttYattttgacttgaaSaataaatYcgB
+aaaaccgNatVBttMacHaKaataagtatKgtcaagactcttaHttcggaattgttDtct
+aaccHttttWaaatgaaatataaaWattccYDtKtaaaacggtgaggWVtctattagtga
+ctattaagtMgtttaagcatttgSgaaatatccHaaggMaaaattttcWtatKctagDtY
+tMcctagagHcactttactatacaaacattaacttaHatcVMYattYgVgtMttaaRtga
+aataaDatcaHgtHHatKcDYaatcttMtNcgatYatgSaMaNtcttKcWataScKggta
+tcttacgcttWaaagNatgMgHtctttNtaacVtgttcMaaRatccggggactcMtttaY
+MtcWRgNctgNccKatcttgYDcMgattNYaRagatHaaHgKctcataRDttacatBatc
+cattgDWttatttaWgtcggagaaaaatacaatacSNtgggtttccttacSMaagBatta
+caMaNcactMttatgaRBacYcYtcaaaWtagctSaacttWgDMHgaggatgBVgcHaDt
+ggaactttggtcNatNgtaKaBcccaNtaagttBaacagtatacDYttcctNgWgcgSMc
+acatStctHatgRcNcgtacacaatRttMggaNKKggataaaSaYcMVcMgtaMaHtgat
+tYMatYcggtcttcctHtcDccgtgRatcattgcgccgatatMaaYaataaYSggatagc
+gcBtNtaaaScaKgttBgagVagttaKagagtatVaactaSacWactSaKatWccaKaaa
+atBKgaaKtDMattttgtaaatcRctMatcaaMagMttDgVatggMaaWgttcgaWatga
+aatttgRtYtattaWHKcRgctacatKttctaccaaHttRatctaYattaaWatVNccat
+NgagtcKttKataStRaatatattcctRWatDctVagttYDgSBaatYgttttgtVaatt
+taatagcagMatRaacttBctattgtMagagattaaactaMatVtHtaaatctRgaaaaa
+aaatttWacaacaYccYDSaattMatgaccKtaBKWBattgtcaagcHKaagttMMtaat
+ttcKcMagNaaKagattggMagaggtaatttYacatcWaaDgatMgKHacMacgcVaaca
+DtaDatatYggttBcgtatgWgaSatttgtagaHYRVacaRtctHaaRtatgaactaata
+tctSSBgggaaHMWtcaagatKgagtDaSatagttgattVRatNtctMtcSaagaSHaat
+aNataataRaaRgattctttaataaagWaRHcYgcatgtWRcttgaaggaMcaataBRaa
+ccagStaaacNtttcaatataYtaatatgHaDgcStcWttaacctaRgtYaRtataKtgM
+ttttatgactaaaatttacYatcccRWtttHRtattaaatgtttatatttgttYaatMca
+RcSVaaDatcgtaYMcatgtagacatgaaattgRtcaaYaaYtRBatKacttataccaNa
+aattVaBtctggacaagKaaYaaatatWtMtatcYaaVNtcgHaactBaagKcHgtctac
+aatWtaDtSgtaHcataHtactgataNctRgttMtDcDttatHtcgtacatcccaggStt
+aBgtcacacWtccNMcNatMVaVgtccDYStatMaccDatggYaRKaaagataRatttHK
+tSaaatDgataaacttaHgttgVBtcttVttHgDacgaKatgtatatNYataactctSat
+atatattgcHRRYttStggaactHgttttYtttaWtatMcttttctatctDtagVHYgMR
+BgtHttcctaatYRttKtaagatggaVRataKDctaMtKBNtMtHNtWtttYcVtattMc
+gRaacMcctNSctcatttaaagDcaHtYccSgatgcaatYaaaaDcttcgtaWtaattct
+cgttttScttggtaatctttYgtctaactKataHacctMctcttacHtKataacacagcN
+RatgKatttttSaaatRYcgDttaMRcgaaattactMtgcgtaagcgttatBtttttaat
+taagtNacatHgttcRgacKcBBtVgatKttcgaBaatactDRgtRtgaNacWtcacYtt
+aaKcgttctHaKttaNaMgWgWaggtctRgaKgWttSttBtDcNtgtttacaaatYcDRt
+gVtgcctattcNtctaaaDMNttttNtggctgagaVctDaacVtWccaagtaacacaNct
+gaScattccDHcVBatcgatgtMtaatBgHaatDctMYgagaatgYWKcctaatNaStHa
+aaKccgHgcgtYaaYtattgtStgtgcaaRtattaKatattagaWVtcaMtBagttatta
+gNaWHcVgcaattttDcMtgtaRHVYtHtctgtaaaaHVtMKacatcgNaatttMatatg
+ttgttactagWYtaRacgataKagYNKcattataNaRtgaacKaYgcaaYYacaNccHat
+MatDcNgtHttRaWttagaaDcaaaaaatagggtKDtStaDaRtaVtHWKNtgtattVct
+SVgRgataDaRaWataBgaagaaKtaataaYgDcaStaNgtaDaaggtattHaRaWMYaY
+aWtggttHYgagVtgtgcttttcaaDKcagVcgttagacNaaWtagtaataDttctggtt
+VcatcataaagtgKaaaNaMtaBBaattaatWaattgctHaVKaSgDaaVKaHtatatat
+HatcatSBagNgHtatcHYMHgttDgtaHtBttWatcgtttaRaattgStKgSKNWKatc
+agDtctcagatttctRtYtBatBgHHtKaWtgYBgacVVWaKtacKcDttKMaKaVcggt
+gttataagaataaHaatattagtataatMHgttYgaRttagtaRtcaaVatacggtcMcg
+agtaaRttacWgactKRYataaaagSattYaWgagatYagKagatgSaagKgttaatMgg
+tataatgttWYttatgagaaacctNVataatHcccKtDctcctaatactggctHggaSag
+gRtKHaWaattcgSatMatttagaggcYtctaMcgctcataSatatgRagacNaaDagga
+VBagaYttKtacNaKgtSYtagttggaWcatcWttaatctatgaVtcgtgtMtatcaYcg
+tRccaaYgDctgcMgtgtWgacWtgataacacgcgctBtgttaKtYDtatDcatcagKaV
+MctaatcttgVcaaRgcRMtDcgattaHttcaNatgaatMtactacVgtRgatggaWttt
+actaaKatgagSaaKggtaNtactVaYtaaKRagaacccacaMtaaMtKtatBcttgtaa
+WBtMctaataaVcDaaYtcRHBtcgttNtaaHatttBNgRStVDattBatVtaagttaYa
+tVattaagaBcacggtSgtVtatttaRattgatgtaHDKgcaatattKtggcctatgaWD
+KRYcggattgRctatNgatacaatMNttctgtcRBYRaaaHctNYattcHtaWcaattct
+BtMKtVgYataatMgYtcagcttMDataVtggRtKtgaatgccNcRttcaMtRgattaac
+attRcagcctHtWMtgtDRagaKaBtgDttYaaaaKatKgatctVaaYaacWcgcatagB
+VtaNtRtYRaggBaaBtgKgttacataagagcatgtRattccacttaccatRaaatgWgD
+aMHaYVgVtaSctatcgKaatatattaDgacccYagtgtaYNaaatKcagtBRgagtcca
+tgKgaaaccBgaagBtgSttWtacgatWHaYatcgatttRaaNRgcaNaKVacaNtDgat
+tgHVaatcDaagcgtatgcNttaDataatcSataaKcaataaHWataBtttatBtcaKtK
+tatagttaDgSaYctacaRatNtaWctSaatatttYaKaKtaccWtatcRagacttaYtt
+VcKgSDcgagaagatccHtaattctSttatggtKYgtMaHagVaBRatttctgtRgtcta
+tgggtaHKgtHacHtSYacgtacacHatacKaaBaVaccaDtatcSaataaHaagagaat
+ScagactataaRttagcaaVcaHataKgDacatWccccaagcaBgagWatctaYttgaaa
+tctVNcYtttWagHcgcgcDcVaaatgttKcHtNtcaatagtgtNRaactttttcaatgg
+WgBcgDtgVgtttctacMtaaataaaRggaaacWaHttaRtNtgctaaRRtVBctYtVta
+tDcattDtgaccYatagatYRKatNYKttNgcctagtaWtgaactaMVaacctgaStttc
+tgaKVtaaVaRKDttVtVctaDNtataaaDtccccaagtWtcgatcactDgYaBcatcct
+MtVtacDaaBtYtMaKNatNtcaNacgDatYcatcgcaRatWBgaacWttKttagYtaat
+tcggttgSWttttDWctttacYtatatWtcatDtMgtBttgRtVDggttaacYtacgtac
+atgaattgaaWcttMStaDgtatattgaDtcRBcattSgaaVBRgagccaaKtttcDgcg
+aSMtatgWattaKttWtgDBMaggBBttBaatWttRtgcNtHcgttttHtKtcWtagHSt
+aacagttgatatBtaWSaWggtaataaMttaKacDaatactcBttcaatatHttcBaaSa
+aatYggtaRtatNtHcaatcaHtagVtgtattataNggaMtcttHtNagctaaaggtaga
+YctMattNaMVNtcKtactBKcaHHcBttaSagaKacataYgctaKaYgttYcgacWVtt
+WtSagcaacatcccHaccKtcttaacgaKttcacKtNtacHtatatRtaaatacactaBt
+ttgaHaRttggttWtatYagcatYDatcggagagcWBataagRtacctataRKgtBgatg
+aDatataSttagBaHtaatNtaDWcWtgtaattacagKttcNtMagtattaNgtctcgtc
+ctcttBaHaKcKccgtRcaaYagSattaagtKataDatatatagtcDtaacaWHcaKttD
+gaaRcgtgYttgtcatatNtatttttatggccHtgDtYHtWgttatYaacaattcaWtat
+NgctcaaaSttRgctaatcaaatNatcgtttaBtNNVtgttataagcaaagattBacgtD
+atttNatttaaaDcBgtaSKgacgtagataatttcHMVNttgttBtDtgtaWKaaRMcKM
+tHtaVtagataWctccNNaSWtVaHatctcMgggDgtNHtDaDttatatVWttgttattt
+aacctttcacaaggaSaDcggttttttatatVtctgVtaacaStDVaKactaMtttaSNa
+gtgaaattaNacttSKctattcctctaSagKcaVttaagNaVcttaVaaRNaHaaHttat
+gtHttgtgatMccaggtaDcgaccgtWgtWMtttaHcRtattgScctatttKtaaccaag
+tYagaHgtWcHaatgccKNRtttagtMYSgaDatctgtgaWDtccMNcgHgcaaacNDaa
+aRaStDWtcaaaaHKtaNBctagBtgtattaactaattttVctagaatggcWSatMaccc
+ttHttaSgSgtgMRcatRVKtatctgaaaccDNatYgaaVHNgatMgHRtacttaaaRta
+tStRtDtatDttYatattHggaBcttHgcgattgaKcKtttcRataMtcgaVttWacatN
+catacctRataDDatVaWNcggttgaHtgtMacVtttaBHtgagVttMaataattatgtt
+cttagtttgtgcDtSatttgBtcaacHattaaBagVWcgcaSYttMgcttacYKtVtatc
+aYaKctgBatgcgggcYcaaaaacgNtctagKBtattatctttKtaVttatagtaYtRag
+NtaYataaVtgaatatcHgcaaRataHtacacatgtaNtgtcgYatWMatttgaactacR
+ctaWtWtatacaatctBatatgYtaagtatgtgtatSttactVatcttYtaBcKgRaSgg
+RaaaaatgcagtaaaWgtaRgcgataatcBaataccgtatttttccatcNHtatWYgatH
+SaaaDHttgctgtccHtggggcctaataatttttctatattYWtcattBtgBRcVttaVM
+RSgctaatMagtYtttaaaaatBRtcBttcaaVtaacagctccSaaSttKNtHtKYcagc
+agaaaccccRtttttaaDcDtaStatccaagcgctHtatcttaDRYgatDHtWcaaaBcW
+gKWHttHataagHacgMNKttMKHccaYcatMVaacgttaKgYcaVaaBtacgcaacttt
+MctaaHaatgtBatgagaSatgtatgSRgHgWaVWgataaatatttccKagVgataattW
+aHNcYggaaatgctHtKtaDtctaaagtMaatVDVactWtSaaWaaMtaHtaSKtcBRaN
+cttStggtBttacNagcatagRgtKtgcgaacaacBcgKaatgataagatgaaaattgta
+ctgcgggtccHHWHaaNacaBttNKtKtcaaBatatgctaHNgtKcDWgtttatNgVDHg
+accaacWctKaaggHttgaRgYaatHcaBacaatgagcaaattactgtaVaaYaDtagat
+tgagNKggtggtgKtWKaatacagDRtatRaMRtgattDggtcaaYRtatttNtagaDtc
+acaaSDctDtataatcgtactaHttatacaatYaacaaHttHatHtgcgatRRttNgcat
+SVtacWWgaaggagtatVMaVaaattScDDKNcaYBYaDatHgtctatBagcaacaagaa
+tgagaaRcataaKNaRtBDatcaaacgcattttttaaBtcSgtacaRggatgtMNaattg
+gatatWtgagtattaaaVctgcaYMtatgatttttYgaHtgtcttaagWBttHttgtctt
+attDtcgtatWtataataSgctaHagcDVcNtaatcaagtaBDaWaDgtttagYctaNcc
+DtaKtaHcttaataacccaRKtacaVaatNgcWRaMgaattatgaBaaagattVYaHMDc
+aDHtcRcgYtcttaaaWaaaVKgatacRtttRRKYgaatacaWVacVcRtatMacaBtac
+tggMataaattttHggNagSctacHgtBagcgtcgtgattNtttgatSaaggMttctttc
+ttNtYNagBtaaacaaatttMgaccttacataattgYtcgacBtVMctgStgMDtagtaR
+ctHtatgttcatatVRNWataDKatWcgaaaaagttaaaagcacgHNacgtaatctttMR
+tgacttttDacctataaacgaaatatgattagaactccSYtaBctttaataacWgaaaYa
+tagatgWttcatKtNgatttttcaagHtaYgaaRaDaagtaggagcttatVtagtctttc
+attaaaatcgKtattaRttacagVaDatgcatVgattgggtctttHVtagKaaRBtaHta
+aggccccaaaaKatggtttaMWgtBtaaacttcactttKHtcgatctccctaYaBacMgt
+cttBaBaNgcgaaacaatctagtHccHtKttcRtRVttccVctttcatacYagMVtMcag
+aMaaacaataBctgYtaatRaaagattaaccatVRatHtaRagcgcaBcgDttStttttc
+VtttaDtKgcaaWaaaaatSccMcVatgtKgtaKgcgatatgtagtSaaaDttatacaaa
+catYaRRcVRHctKtcgacKttaaVctaDaatgttMggRcWaacttttHaDaKaDaBctg
+taggcgtttaHBccatccattcNHtDaYtaataMttacggctNVaacDattgatatttta
+cVttSaattacaaRtataNDgacVtgaacataVRttttaDtcaaacataYDBtttaatBa
+DtttYDaDaMccMttNBttatatgagaaMgaNtattHccNataattcaHagtgaaggDga
+tgtatatatgYatgaStcataaBStWacgtcccataRMaaDattggttaaattcMKtctM
+acaBSactcggaatDDgatDgcWctaacaccgggaVcacWKVacggtaNatatacctMta
+tgatagtgcaKagggVaDtgtaacttggagtcKatatcgMcttRaMagcattaBRaStct
+YSggaHYtacaactMBaagDcaBDRaaacMYacaHaattagcattaaaHgcgctaaggSc
+cKtgaaKtNaBtatDDcKBSaVtgatVYaagVtctSgMctacgttaacWaaattctSgtD
+actaaStaaattgcagBBRVctaatatacctNttMcRggctttMttagacRaHcaBaacV
+KgaataHttttMgYgattcYaNRgttMgcVaaacaVVcDHaatttgKtMYgtatBtVVct
+WgVtatHtacaaHttcacgatagcagtaaNattBatatatttcVgaDagcggttMaagtc
+ScHagaaatgcYNggcgtttttMtStggtRatctacttaaatVVtBacttHNttttaRca
+aatcacagHgagagtMgatcSWaNRacagDtatactaaDKaSRtgattctccatSaaRtt
+aaYctacacNtaRtaactggatgaccYtacactttaattaattgattYgttcagDtNKtt
+agDttaaaaaaaBtttaaNaYWKMBaaaacVcBMtatWtgBatatgaacVtattMtYatM
+NYDKNcKgDttDaVtaaaatgggatttctgtaaatWtctcWgtVVagtcgRgacttcccc
+taDcacagcRcagagtgtWSatgtacatgttaaSttgtaaHcgatgggMagtgaacttat
+RtttaVcaccaWaMgtactaatSSaHtcMgaaYtatcgaaggYgggcgtgaNDtgttMNg
+aNDMtaattcgVttttaacatgVatgtWVMatatcaKgaaattcaBcctccWcttgaaWH
+tWgHtcgNWgaRgctcBgSgaattgcaaHtgattgtgNagtDttHHgBttaaWcaaWagc
+aSaHHtaaaVctRaaMagtaDaatHtDMtcVaWMtagSagcttHSattaacaaagtRacM
+tRtctgttagcMtcaBatVKtKtKacgagaSNatSactgtatatcBctgagVtYactgta
+aattaaaggcYgDHgtaacatSRDatMMccHatKgttaacgactKtgKagtcttcaaHRV
+tccttKgtSataatttacaactggatDNgaacttcaRtVaagDcaWatcBctctHYatHa
+DaaatttagYatSatccaWtttagaaatVaacBatHcatcgtacaatatcgcNYRcaata
+YaRaYtgattVttgaatgaVaactcRcaNStgtgtattMtgaggtNttBaDRcgaaaagc
+tNgBcWaWgtSaDcVtgVaatMKBtttcgtttctaaHctaaagYactgMtatBDtcStga
+ccgtSDattYaataHctgggaYYttcggttaWaatctggtRagWMaDagtaacBccacta
+cgHWMKaatgatWatcctgHcaBaSctVtcMtgtDttacctaVgatYcWaDRaaaaRtag
+atcgaMagtggaRaWctctgMgcWttaagKBRtaaDaaWtctgtaagYMttactaHtaat
+cttcataacggcacBtSgcgttNHtgtHccatgttttaaagtatcgaKtMttVcataYBB
+aKtaMVaVgtattNDSataHcagtWMtaggtaSaaKgttgBtVtttgttatcatKcgHac
+acRtctHatNVagSBgatgHtgaRaSgttRcctaacaaattDNttgacctaaYtBgaaaa
+tagttattactcttttgatgtNNtVtgtatMgtcttRttcatttgatgacacttcHSaaa
+ccaWWDtWagtaRDDVNacVaRatgttBccttaatHtgtaaacStcVNtcacaSRttcYa
+gacagaMMttttgMcNttBcgWBtactgVtaRttctccaaYHBtaaagaBattaYacgat
+ttacatctgtaaMKaRYtttttactaaVatWgctBtttDVttctggcDaHaggDaagtcg
+aWcaagtagtWttHtgKtVataStccaMcWcaagataagatcactctHatgtcYgaKcat
+cagatactaagNSStHcctRRNtattgtccttagttagMVgtatagactaactctVcaat
+MctgtttgtgttgccttatWgtaBVtttctggMcaaKgDWtcgtaaYStgSactatttHg
+atctgKagtagBtVacRaagRtMctatgggcaaaKaaaatacttcHctaRtgtDcttDat
+taggaaatttcYHaRaaBttaatggcacKtgctHVcaDcaaaVDaaaVcgMttgtNagcg
+taDWgtcgttaatDgKgagcSatatcSHtagtagttggtgtHaWtaHKtatagctgtVga
+ttaBVaatgaataagtaatVatSttaHctttKtttgtagttaccttaatcgtagtcctgB
+cgactatttVcMacHaaaggaatgDatggKtaHtgStatattaaSagctWcctccRtata
+BaDYcgttgcNaagaggatRaaaYtaWgNtSMcaatttactaacatttaaWttHtatBat
+tgtcgacaatNgattgcNgtMaaaKaBDattHacttggtRtttaYaacgVactBtaBaKt
+gBttatgVttgtVttcaatcWcNctDBaaBgaDHacBttattNtgtDtatttVSaaacag
+gatgcRatSgtaSaNtgBatagttcHBgcBBaaattaHgtDattatDaKaatBaaYaaMa
+ataaataKtttYtagtBgMatNcatgtttgaNagtgttgtgKaNaSagtttgaSMaYBca
+aaacDStagttVacaaaaactaaWttBaagtctgtgcgtMgtaattctcctacctcaNtt
+taaccaaaaVtBcacataacaccccBcWMtatVtggaatgaWtcaaWaaaaaaaaWtDta
+atatRcctDWtcctaccMtVVatKttaWaaKaaatataaagScHBagaggBaSMtaWaVt
+atattactSaaaKNaactatNatccttgaYctattcaaaVgatttYHcRagattttaSat
+aggttattcVtaaagaKgtattattKtRttNcggcRgtgtgtWYtaacHgKatKgatYta
+cYagDtWcHBDctctgRaYKaYagcactKcacSaRtBttttBHKcMtNtcBatttatttt
+tgSatVgaaagaWtcDtagDatatgMacaacRgatatatgtttgtKtNRaatatNatgYc
+aHtgHataacKtgagtagtaacYttaNccaaatHcacaacaVDtagtaYtccagcattNt
+acKtBtactaaagaBatVtKaaHBctgStgtBgtatgaSNtgDataaccctgtagcaBgt
+gatcttaDataStgaMaccaSBBgWagtacKcgattgaDgNNaaaacacagtSatBacKD
+gcgtataBKcatacactaSaatYtYcDaactHttcatRtttaatcaattataRtttgtaa
+gMcgNttcatcBtYBagtNWNMtSHcattcRctttttRWgaKacKttgggagBcgttcgc
+MaWHtaatactgtctctatttataVgtttaBScttttaBMaNaatMacactYtBMggtHa
+cMagtaRtctgcatttaHtcaaaatttgagKtgNtactBacaHtcgtatttctMaSRagc
+agttaatgtNtaaattgagagWcKtaNttagVtacgatttgaatttcgRtgtWcVatcgt
+taaDVctgtttBWgaccagaaagtcSgtVtatagaBccttttcctaaattgHtatcggRa
+ttttcaaggcYSKaagWaWtRactaaaacccBatMtttBaatYtaagaactSttcgaaSc
+aatagtattgaccaagtgttttctaacatgtttNVaatcaaagagaaaNattaaRtttta
+VaaaccgcaggNMtatattVctcaagaggaacgBgtttaacaagttcKcYaatatactaa
+ccBaaaSggttcNtattctagttRtBacgScVctcaatttaatYtaaaaaaatgSaatga
+tagaMBRatgRcMcgttgaWHtcaVYgaatYtaatctttYttatRaWtctgBtDcgatNa
+tcKaBaDgatgtaNatWKctccgatattaacattNaaacDatgBgttctgtDtaaaMggt
+gaBaSHataacgccSctaBtttaRBtcNHcDatcDcctagagtcRtaBgWttDRVHagat
+tYatgtatcWtaHtttYcattWtaaagtctNgtStggRNcgcggagSSaaagaaaatYcH
+DtcgctttaatgYcKBVSgtattRaYBaDaaatBgtatgaHtaaRaRgcaSWNtagatHa
+acttNctBtcaccatctMcatattccaSatttgcgaDagDgtatYtaaaVDtaagtttWV
+aagtagYatRttaagDcNgacKBcScagHtattatcDaDactaaaaaYgHttBcgaDttg
+gataaaKSRcBMaBcgaBSttcWtgNBatRaccgattcatttataacggHVtaattcaca
+agagVttaaRaatVVRKcgWtVgacctgDgYaaHaWtctttcacMagggatVgactagMa
+aataKaaNWagKatagNaaWtaaaatttgaattttatttgctaaVgaHatBatcaaBWcB
+gttcMatcgBaaNgttcgSNaggSaRtttgHtRtattaNttcDcatSaVttttcgaaaaa
+ttgHatctaRaggSaNatMDaaatDcacgattttagaHgHaWtYgattaatHNSttatMS
+gggNtcKtYatRggtttgtMWVtttaYtagcagBagHaYagttatatggtBacYcattaR
+SataBatMtttaaatctHcaaaSaaaagttNSaaWcWRccRtKaagtBWtcaaattSttM
+tattggaaaccttaacgttBtWatttatatWcDaatagattcctScacctaagggRaaYt
+aNaatgVtBcttaaBaacaMVaaattatStYgRcctgtactatcMcVKatttcgSgatRH
+MaaaHtagtaaHtVgcaaataatatcgKKtgccaatBNgaaWcVttgagttaKatagttc
+aggKDatDtattgaKaVcaKtaataDataataHSaHcattagttaatRVYcNaHtaRcaa
+ggtNHcgtcaaccaBaaagYtHWaaaRcKgaYaaDttgcWYtataRgaatatgtYtgcKt
+aNttWacatYHctRaDtYtattcBttttatcSataYaYgttWaRagcacHMgtttHtYtt
+YaatcggtatStttcgtRSattaaDaKMaatatactaNBaWgctacacYtgaYVgtgHta
+aaRaaRgHtagtWattataaaSDaaWtgMattatcgaaaagtaYRSaWtSgNtBgagcRY
+aMDtactaacttaWgtatctagacaagNtattHggataatYttYatcataDcgHgttBtt
+ctttVttgccgaaWtaaaacgKgtatctaaaaaNtccDtaDatBMaMggaatNKtatBaa
+atVtccRaHtaSacataHattgtttKVYattcataVaattWtcgtgMttcttKtgtctaa
+cVtatctatatBRataactcgKatStatattcatHHRttKtccaacgtgggtgRgtgaMt
+attattggctatcgtgacMtRcBDtcttgtactaatRHttttaagatcgVMDStattatY
+BtttDttgtBtNttgRcMtYtgBacHaWaBaatDKctaagtgaaactaatgRaaKgatcc
+aagNaaaatattaggWNtaagtatacttttKcgtcggSYtcttgRctataYcttatataa
+agtatattaatttataVaacacaDHatctatttttKYVatHRactttaBHccaWagtact
+BtcacgaVgcgttRtttttttSVgtSagtBaaattctgaHgactcttgMcattttagVta
+agaattHctHtcaDaaNtaacRggWatagttcgtSttgaDatcNgNagctagDgatcNtt
+KgttgtaDtctttRaaYStRatDtgMggactSttaDtagSaVtBDttgtDgccatcacaM
+attaaaMtNacaVcgSWcVaaDatcaHaatgaattaMtatccVtctBtaattgtWattat
+BRcWcaatgNNtactWYtDaKttaaatcactcagtRaaRgatggtKgcgccaaHgaggat
+StattYcaNMtcaBttacttatgagDaNtaMgaaWtgtttcttctaHtMNgttatctaWW
+atMtBtaaatagDVatgtBYtatcggcttaagacMRtaHScgatatYgRDtcattatSDa
+HggaaataNgaWSRRaaaBaatagBattaDctttgHWNttacaataaaaaaatacggttt
+gHgVtaHtWMttNtBtctagtMcgKMgHgYtataHaNagWtcaacYattaataYRgtaWK
+gaBctataaccgatttaHaNBRaRaMtccggtNgacMtctcatttgcaattcWgMactta
+caaDaaNtactWatVtttagccttMaatcagVaagtctVaaDaBtattaattaYtNaYtg
+gattaKtaKctYaMtattYgatattataatKtVgDcttatatNBtcgttgtStttttMag
+aggttaHYSttcKgtcKtDNtataagttataagSgttatDtRttattgttttSNggRtca
+aKMNatgaatattgtBWtaMacctgggYgaSgaagYataagattacgagaatBtggtRcV
+HtgYggaDgaYaKagWagctatagacgaaHgtWaNgacttHRatVaWacKYtgRVNgVcS
+gRWctacatcKSactctgWYtBggtataagcttNRttVtgRcaWaaatDMatYattaact
+ttcgaagRatSctgccttgcRKaccHtttSNVagtagHagBagttagaccaRtataBcca
+taatSHatRtcHagacBWatagcaMtacaRtgtgaaBatctKRtScttccaNaatcNgta
+atatWtcaMgactctBtWtaaNactHaaaaRctcgcatggctMcaaNtcagaaaaacaca
+gtggggWttRttagtaagaVctVMtcgaatcttcMaaaHcaHBttcgattatgtcaDagc
+YRtBtYcgacMgtDcagcgaNgttaataatagcagKYYtcgtaBtYctMaRtaRtDagaa
+aacacatgYaBttgattattcgaaNttBctSataaMataWRgaHtttccgtDgaYtatgg
+tDgHKgMtatttVtMtVagttaRatMattRagataaccctKctMtSttgaHagtcStcta
+tttccSagatgttccacgaggYNttHRacgattcDatatDcataaaatBBttatcgaHtN
+HaaatatDNaggctgaNcaaggagttBttMgRagVatBcRtaWgatgBtSgaKtcgHttt
+gaatcaaDaHttcSBgHcagtVaaSttDcagccgttNBtgttHagYtattctttRWaaVt
+SttcatatKaaRaaaNacaVtVctMtSDtDtRHRcgtaatgctcttaaatSacacaatcg
+HattcaWcttaaaatHaaatcNctWttaNMcMtaKctVtcctaagYgatgatcYaaaRac
+tctaRDaYagtaacgtDgaggaaatctcaaacatcaScttcKttNtaccatNtaNataca
+tttHaaDHgcaDatMWaaBttcRggctMaagctVYcacgatcaDttatYtaatcKatWat
+caatVYtNagatttgattgaYttttYgacttVtcKaRagaaaHVgDtaMatKYagagttN
+atWttaccNtYtcDWgSatgaRgtMatgKtcgacaagWtacttaagtcgKtgatccttNc
+ttatagMatHVggtagcgHctatagccctYttggtaattKNaacgaaYatatVctaataM
+aaaYtgVtcKaYtaataacagaatHcacVagatYWHttagaaSMaatWtYtgtaaagNaa
+acaVgaWtcacNWgataNttcaSagctMDaRttgNactaccgataMaaatgtttattDtc
+aagacgctDHYYatggttcaagccNctccttcMctttagacBtaaWtaWVHggaaaaNat
+ttaDtDtgctaaHHtMtatNtMtagtcatttgcaaaRatacagRHtatDNtgtDgaatVg
+tVNtcaaatYBMaaaagcaKgtgatgatMgWWMaHttttMgMagatDtataaattaacca
+actMtacataaattgRataatacgBtKtaataattRgtatDagDtcRDacctatRcagag
+cSHatNtcaScNtttggacNtaaggaccgtgKNttgttNcttgaaRgYgRtNtcagttBc
+ttttcHtKtgcttYaaNgYagtaaatgaatggWaMattBHtatctatSgtcYtgcHtaat
+tHgaaMtHcagaaSatggtatgccaHBtYtcNattWtgtNgctttaggtttgtWatNtgH
+tgcDttactttttttgcNtactKtWRaVcttcatagtgSNKaNccgaataaBttataata
+YtSagctttaaatSttggctaaKSaatRccgWHgagDttaaatcatgagMtcgagtVtaD
+ggaBtatttgDacataaacgtagYRagBWtgDStKDgatgaagttcattatttaKWcata
+aatWRgatataRgttRacaaNKttNtKagaaYaStaactScattattaacgatttaaatg
+DtaattagatHgaYataaactatggggatVHtgccgtNgatNYcaStRtagaccacWcaM
+tatRagHgVactYtWHtcttcatgatWgagaKggagtatgaWtDtVtNaNtcgYYgtaaa
+ctttaDtBactagtaDctatagtaatatttatatataacgHaaaRagKattSagttYtSt
+atatatagtcttaaaaMtcatgttcaaDactgRttctaagagDtatttttagcgacttgt
+gRtgNctgSgRaaaaatgcaMtYtDcatcaaYKttHcatSWgaaaatDataggttatgBD
+MtgttataacaaYSgagttacgttatgtDStttaaatctcgWKtcSacgagagaSgttat
+BMDgtcggtgtgcgaNtaSHBatBtttVMgVcagaNatcaDDaKMtMYtatagaBccctc
+tDtgtatttatatKNtgggtatgtRaacttgaWaaYgcaHatccctggtttStatMtcgc
+MtaaaWKttMVtWctVtgttaKDWctgWaVttaDVatgKtagagtcatctaKWgtaaMtt
+SacBaMattaKaaHDataattgWtgttttgtcatBacacgtStacaaagtNctNtgtgat
+cHtWttcKaagagttttaaaaWacgRacatctNatVStgaatDHgttWcgtRKcatatat
+ctcaNttaaBDcctgaaaaaDtaYaHaKttNtaYVaVtttaDtctacttctWttaactaa
+ttttMagWcaatcccNKYtBaacatgttgaKgKcgcBHaatDMttatatcSWacatDatR
+cWaMtDgatBctHgScttaaaHtSgKtDtttattgtRStWgttccatatttcacWttcat
+attgtaHVgaBtacaMtgMaaagDaataactDatattagMaNBagcttcattcgtaaKtg
+tatttcacMtgBaVtaattStcttagtYgtgtcgccttKatgggtgaWaataggaatacM
+MagaSKRttBgatgacRtgMtagaSRataggtatcaccgaNaaaWSWacDgatacttgat
+tagcttgtgVMttatYctaRgHVcDtVRRtSaMtcaVtVtatcaYaHatattaaVaatct
+aBtgtacRatNtatttgaYatSaHctaNgNtYtYaYagattVgatcRtaacgYggtgtat
+KttaatMagatgRtatatgHaKccHaaaaYtgaacgaWaNgtYHgacagaYtctaVtacc
+cgatttttaaagcDttatNRgattKaaattttcatctaatgccgcaataataattgttat
+YtagtRNtaagttggtHaKttWMtDKgatSagBYcgRggtWaVaattHtatgtaaaMgSa
+aagataaKaaKgttDttttRaagaacaWRcaacDgtgttaatattaKtatcaWacacatt
+tVtctgatHRcagtttNcaaatcNctNttttataactWacBBttgBttaaaRaWtBKaaa
+cgtatcRcaMaatgYacaaaagtgBataStWYtggtatgacaKWtctSgcKHgtcNaMNc
+ataSatattgactacMcataattNVtDaRccaaatcagttttYttagYaacgtaatMtMV
+atNgKaaMaaBgattaKttatDaBcttKtccttttacDagaYtacHgttggacaaaVaat
+agtYatcataSgatcaaWVttcgaatgaccctccttNtaSBWaatttDttttcaatatYg
+gctatDcttatNctttagDcMttcaacWaaNattSYgctttcaHcRaattaataaaatcV
+ccRaattactctaMaVRattacagtgRcDtcgtgctcttNtWVtacagtHtatHaBDtcW
+ggtgctcaaRHtatgtDgacStgcaaaVKtagttataatactaatatgtagScaatRSac
+aattgtattgcagatHHtgBcaatKKtaaMMcaRcgactatKBaMaYatgKatttDaaNt
+RatattgtatWttagcaaaaacaWgcacaaHcataYtDaHgttataaSacgcagggggtY
+atgcKctaaaHgcVgctBDaVttccStagNgcSgtatgVYaMatcaWRBtVtgYttgtgR
+cYttcgctgaacNttgtgtctattWttttcctagMtagaWtaKgatStScatMaBtaSta
+SactattYNatctgtacRatYDaatgatgatatgaatYaaaaSHttaaYMaWtDcaNHaB
+caYtgVgcatVaacattMRatBtaatttaDacRtagtaaaNYVSMtcagaaDtttDHtRc
+YatacSNKaaMcHgatBaaVttactggBYgaYatttttgcDacHctWatcgtagagtact
+cattDggtcatKaSgctttatttagtDtRBacttaWYaaaattttgaccttaaWtaatgc
+RgccacttMtaggKtcBtgacgaHctttatcgtcStatMHDNagattatNagVaaaWcgg
+aaaYcaVactDYactaStattgBHtcYctgggtacatataaYcgaYagaggaggacaVat
+acHRtYtctgtaVgaYcNgaaaNatacVgcNgtaatttDcatttttcaacttSNcaaDat
+VYctSgcaccttagMgacgcttgaSttaaaatagttaggRHttaaacMatagcaWgMgag
+tcgctagtgtKgactaaHttattaWgcaaaaaaSatatgcgttaBNggttaYVatgaact
+ttttgccatataaataRatSaBctagttataBccgaaacaagatacttaattttgaHgHM
+gtaaKctttaYtaaRacBMtBaYgaBaaacaYtVtagcRgWatHaWagattWSacStMHa
+tttaDagacaatcgtgtKtttggaMtgtWtgtgcaaNaaaaWtKaaBcMWtcttctatga
+cVgagcgaggHaYYtttWgSaaYYaWtRYHHaMDtctttacaatggaaMctataagcttB
+cgHcNWaatttgtatatYtStatctagcactgtVttccagaaattaDtttaRtVataBtt
+WagcatDMVactYtgcatWtttgaaMggKaatgaaaaHtataDtgYcMggVaaatSMHtt
+tgVttaYaWaataRttgttaYttattttRtWtataaBgtDtttatatcVgaaBcaDtatg
+tcaDagaWtgaYtWctcVagctcagctatatagcRVtcaKtaataatHgNaccgaaaatV
+HBaatattcgttaVYttatttctBYaatKaagaccVStttcattgaMagSaaaaccccWK
+caaNtMYacctaDStagaaatttatcatVgtcaatacccKattgtaaagtggWgtatatV
+tagBcttDaBacaattWtDYKtatRKggStRtaaaWatBtaagtaattDaaaaBRacWta
+agtacaSttaaatccgctaaccKaattgVWttDattatttattKaMtcYtMRWagMtcgK
+gBagacgggVaaNaaatgctKcgtaataaKtaaagtccWcttHMatSYgataaatDttBa
+HccattgBttSgaaHYtaataaaMtgaagatgtttBgRcattaRaDHcttBgaMaWaaVM
+MattaatttgtgBRctattgKMagNcMtatttaaaWttgaaacatWgcScgYYDYgttYt
+VtattgcKcWtagcggtgBaSctaKatacaaVtcaRDccccgtgttBgKgggtHagcgaa
+ttaaagMMttScggtDttttaHcSaagaacactcacactBcVgaKNaDHacacttatSag
+aattSKHtcagtataaatKaaHtgaaRagaaVcBtaHtaaatcgatcWcaRtaaaattta
+WttaagtcaggRctgaWcttDttgactttaVSaaaatggtaWDaRMtBtaaaaaKatBga
+tMtctatatcaVaMgatttgNagtDRttDatcttttaMtYaaatcggagttctctaYatN
+tagaNcgMMactacHcaagtaaaatStaSaacaHcacSgggtNKatggaaagcggaaKgg
+gtaYtacSgccgBaggcRacgtVgDtggaMcYaaaMatggacgYStKKatgaBcaaRtSt
+ccSagcRccgccgcSDtgcggBDgaDtBtSSggacMttttaWcatcMatgtNMBWgataa
+tcaaVtgaataataaNatgcaaNttNctgacDMcaHccgatgKgWVttccaStggattct
+cDacttttttctttaaNcWaMWccWKWttgaaaMctDaaBactRtVattttBtcMaNttW
+cKacagttKSttaYaWSactHSaBtHgatgttacatgcatatMtttgtaacScWHBatHa
+ctggatatatctgagMgRSatctaaSttaVagcaRcttggaYaatKHtagBBactattcg
+taaagaagttgtVcgatgaVatHMtcaggtcgKSgWattgaaaVctccVgtDcaaatgaa
+HgMYactcaMatatatattNVttWtWaatttacRagKataaaNtttacaaWgMVactatt
+aSgaggVaaagVtaccDRHaaataRaHaRgcattMttcaatcaKaaataDcaDKtctcga
+ggBggacctDtttatHacWVaWgatDctaNaNcgKatcMtcMaatBtttggacgtgataa
+tagaaacRactcBtattttaKtgSaaggKtaggRaVtatagcccaNRttaccttSMaaga
+tcggDacNBatWcgaactacactaactNBtaStgVtNagcatctaVtaKatKgaBtcgtt
+tWaagWMgagRaNatHaaaaDtacagacaBagtgcaHaNatctcBccNttaagttDgaat
+aaNtcgctaacRBgtaatSttaatatgcataacccaSattKcccttDttggtcaatgggt
+tWaacgatacattBtgMaYgaRttatgatKaKgtattDtKWgataacgNBtaccgaKWat
+cttcttKtgtcttagcattcctWcaaHgagtatDMSgKtcagcttgVHaKcttDaataaa
+VaatttDgtgaaataaRgtcaVaatacttagtVatatgggcatgtDDtMtgtatBggatt
+HtgcVtgtgatcaaSattatKYVaacSNNttNWcgaHttKDaaMYHatcgttaattaStt
+gctWaacHtaKBtaaaaKHttcRWgaaWcRtBtttggBcDtgtacNttaagcKtaHgtag
+aaaaRttgaaacatagtWRaacYggtaaatcgctYaBtWDRtgttgSctaaKatNcattg
+tgtMttatccatatagctSacgccSNaaactacgNtgtgcttMatSKtcaaBaNaaacat
+aacagaaatagtagctcNcatcVgaagStaataVcDKKttcagDHDtattctaatgaggg
+RgBMctatacaagYactctMaaagtcgctttctcgtgaattatNcgatMtttaggcBaaa
+tctNtactaaRKtgKactattgtcatatgtacgagttMaaHSSgHgBatatcgcaSaata
+aaWgaagtatagaHgcttctttatgaccWaatttaRtaDaatttaatcgaaattgattMc
+atcaWaMtaWaKactttctBacactatNgtccttaWgtctgaccKatStaKtgagtacgg
+gcgcgtYNtatttagacctctKcatgatKWStcaataactaWgMSgHtgatctttttgtc
+gacgtSacttaYgcctWctcctctacaagVtttMaBactWVaccaYtgtSgcgttattcK
+tatStgaaKaccgNaataaHtatWtYtRacggcaDaScagcagHaYWRtRNcDtHtcVWt
+ggaataaaYttgVaNtgttagtYttgtagSaaatDgaggccDcgBRYStattatttaagg
+ccgHgggYRaaccMaagttatSttctttagcMtgcgMtgaSagaNaDagttSatgattWa
+tttagtDgcttgagtgMKaYWaYccagcaHatKctaKaDgctagacttattgattaaYtt
+atcttattattStaattWaRaYBWagYaatatgttRgScttgBagDaWgcgtgcVDaggc
+ttgtctaDRKacttgcaKBWRtaaVaSctKtacttMaaSVaWWcgSaNtttSWgtcggtc
+acttggVVtgagaataaataaDttgaaccaaaaMttaaaagaaaaaaaatcNBtatMgcc
+WagcaNgaVaNaaaaaaYaMgttaWtatHaagtNtacgacaBtMMattttWNaRtaaata
+gYaScKattacagctVKBtWNSKgYtYgtWatHaVatDaaatWgDatcctggSRagagta
+aaaMgatttRtaHacatggtaKagVcctgatgaMtaaYgatgtattattttHggBaccaD
+ctctggNNtYaatctVttgVtRtVcRacttNctttataggHSRtaRacaaattaacHaHg
+tgttgtttcBtBtatWtgtattttgcKagMcaaagaMtattagtStagcBacYaaHcagV
+gWtgtttcgtgDHaVtagDatcRaRtggtWtaactgcacgaggaaaRttSDaaVaSttaa
+aaacSMttactaNtcaacaattDtacttttYatVSacYtWtMttaattatcKtcttctat
+caKDtctStSaaacggtYccatgtgagagtWtagWKgcaBaaaaKttgNactaatcgagg
+cWtcDDaaaaaacactHattaattcactatYttaagacactaKaagRtRataaattttca
+tHggtaataaatgataHtggctaacBacDgtaatattRtYgtDNDBgKtcaggcHatttt
+gHNgWtaatttccgactactgacatVNttYYgactcgctctatttagaMcgggatHcgtt
+tatBaDSagBaaaagRttBggttaaBactVHgatgaatttattcaaaattgcacttcDga
+cttYcVttactVtttatBaKHagaWgtgaatggBtaaSggcagacNcttaDttVgMtWag
+attggVatttacHtctNcMatacttSatMagcttgtNcYaaScaYactcKctKtagScSt
+cagtttcatWaatggtgagaggHaggggcaacgcRKtaRcMaNtHaatRaRaaactVtBt
+gttaatRtWWcaaagKttccaaKaaatacgVttcacaaacgcggtgagaRaatggtgDMW
+atcWVScacaaaDaggaaHtgttSMaaaaaccYccDBtatYgtMagcSagaccaVcctcg
+gtVWaaagttatcNaagataataSaataaaKccgtaDtYttatYcttHttaagKcMctaa
+atggaatRgaaaVaaVtcKYaggatWcaBtDaggDatccttcYNtgcSMRgaRtNgaatc
+gttRttatDVMtagctttacatDVtatatatcagctaDagMtataccYgaggYaaatgDa
+aaatSgctctgatgtttVaaBcctgataKtagaaaccaKatatgttaDtgaDtatagata
+atacagtaDtatcNtgtDMtYcattRVtctataNtWttggNaSgtMgaaYctctDggHtg
+gHDccaccacKKaaacaaaatRatttccctttaagcRattMHctattHaRtataVattgg
+atcSttaaHaHgaaHNDtacattSaaggDatttcaaaYgctBcatattaaaKagtgccca
+tSctcgatRtaaaMtgWactttNMaWctYgRatDggaactcDcaattaKaactgagtatc
+tataagYaaaSRctggtacWtttccWtaYRtKHattatagWtKttaNgcDtatHacccat
+taatttataacgctMgaagtaacaacagMgtaYHYVtKMHtacMgKcaaatctgRYataN
+tcgttcaatacggWtMcaatYcBWaagYtVaDNagtatagDaaNtaaaYtttcYWttttS
+tgggataaMgatattagaaYtNctcttcBagactaYDcgtacHDWccKaHgttcttHgVg
+gVDttatcatKaMttttacWaaSattctatagaHaggKaDagBtaaagtcYccattgtYc
+atctaNgRgVtgaagtDKttatBKcggDtattRYgHccgtgcgBNMtttVRgacaYctSc
+taRacgtagagccgtacRaagtaHKagStSttttgYSatattaaaWHaaWagttDKaaNa
+NHaaHttaYcttMtcaaatgKttBtSgtccaaVaattSaacgttgNattgatatNctaWt
+VcagtactKcWacgVagggHaaRgaDaatcMttattaataacaBMaaVtgYtKgRgHact
+gtactatcBaMtVggtagKcYtHtBSaattagtaatgMcaVVagYYgWtactttccaaSt
+tDgaaMaMttcacttYtRgacttcagcttWtttagtgataMaattaagVtagaatatKat
+aagtagttaagHMRaDattaHaaVcctDtagtcVYcaataaYcNttNaaaHctcaRaatt
+tcaNRgatSHgVatagctRtcatgaBttMaaagRtcgHVtgRgStgatttgtagaKagaR
+WRctgNaHYgaaatBctgtttRttNWagaccgagKgtgcggHKVttaatattaatataat
+aDtaNcctacaaRgcaNMctctgaaSHWWHcttagtNagtWgWaaKtYaNgcBattatcc
+aaaSctRRHKaNtKcBgtgagaDRWBttactaaattSMctatatagaaYacDgatttccV
+taagRtgRataatatagtctttttatgtMgtcaacaaNtaaaaactctWtagaVaaaDta
+attatagtBStcgaatDtgattVaatMtcaDattVKWaagatagggttgtMRSgtcYgWM
+aatgNtagtcBttagtttctctWaaMtVgctWgSgtHagaSagactagKtagWggcattt
+HgttgacaaactcggggHggcWBgVgtatgggagVgagtcVcBtDctttagtctaagVWt
+HtgtttaScatacMBtKgattatRtgtttgtctttDggcHaBtRtgtaataNataattta
+taWctgaYWataStcHaatcRtaaVagDWaSatagtaccNDgaagtatacgttttacgac
+gKRtattgDctatRRattVtStaaactagatgVatttagaMaSaaaattVtatYtgttgt
+RMagtHaatttSttaaYNaggWagtgcacgaMcactgHgtgtgggHMgtKacttaaYgtc
+gcatcSatattgBaagtttacMtYagSatttatttaVtaaDtaWaHcgNatactgactHt
+ggWtataDcDScatactcStcDtgtcgtgtatgaggtHaaNKgDattgcBccaagKgtat
+gacKSMtttttgttcaaatcaaYtagtaSatgDaaaMccKNaMaatagaataagcaatta
+ttataaMgagtgaSgtctNYttattHaNaYYtcDDtaatNRgtatttaaYtaaatcactH
+VaHcStccttcccaaVatcVggatKtatgRaaDBgaYtttacttYggactSDtaBcaaNg
+gggtattatattBDcttagagYNMatBgttYaagactMatgttRgatacccgtaacacBH
+tatKacWgatRcHttaattYtKtStccaaatVDcaNKHHaaataatagtagtatcttgct
+NDggVaVVtaVaRaaagSaccgttctcMtVtgNBgtDtttctYgttactBctcRtStWtW
+DScMtcWSaRatgaataRHctaNtcStctYtWacagatgtatYBtHaHWBtacggtDcaa
+BtatcaggtcaVattaNctactgaaaatWaDgactNWtMtggagaattBaataYcMWYcg
+atMYatWtgattSatgaRtDaRgccagtSttatatRaBtattRcWtagtVgaagttMcta
+ttatatDttaggtctKtgtgtBagacgttatRKtgatctatttBtataactgataacKcg
+gagtgHgtVttcttgtKDgcDtaYatBDatcaatattgttNtaBacatcgcNcaKcaWcR
+ataWcVgtacgScaWgttcggHcMttcRccatgaRStYgNacagatacYacWWtggNaDc
+WagttHatMaNaatNtcDMDcMaKgHNatScVgatKWatatgNRgtccgYgaagattDHg
+tMtcHaSNaaattBatRagtaaatttacaagHWtKatcaagtccHtYcctgttKDMSgta
+ctactVctgacaaaaHgatatacataatKtStHgctScSatNatacaYttaaWHtctgaa
+tYtagtHtKaggccWBaStaDctaagagNtaatcaatcgttNgaYDaagtaaaaHataga
+atcgcgBaYaBgaacSaaWaaaaactccgcMttHttYgtaagaMctKBtacSagattcBa
+aWtaattttacRttatcgaRtacaRHgtgRagaaBcttaVgacVDgggaatVatagaact
+RRtacgYttNattVHgaHttacaaaaaaaYtcRWtgtgattatgccaSDtttatKWgaat
+atSNDgattttaacgtcSRtatggttcttcBtWtttMtBtMScttaHatBattHacYtaY
+acattcgttKgtcStSctcKtatatttcaKSgagcttccaacaccRDtttDaccattata
+tSgtcWtVaaagttgtagccattDtYaatattDaccatcVDaaRccagttttgtcHacMa
+ttcHgaNcatgttKcVttcctgtgcSataaatattgaKtctaWctMRaKggtaYcaagtt
+DttcgttacRtatgatggHNaWMtKttcatattaaDaSaBaaaMtMatBgKtttgHtHac
+taatcatcgtWaatKaaWcaWtcctVttaaNaggaaaagtaaagaDctNttaDBaBgata
+gMgaataacRcYggatcRaaaHaagatRDtVRactaYagttcaccaaWtctcSSaaatcS
+KattctggDgaacagDtaDagacagtgtaattcaStYttNaStgtaHgccttaScatMRc
+accWtcatttatRtaagatWtNataaWtMNtDVgWttgcWgtgaRttttRgWcttMtcta
+HacaaYtKctgaBagtRagacttDatNttaaaDgRtatNcHatcSDgtBatcttacVcYa
+cNgaattaacgagttgYgacttDattatacBattMgctagcctagatVcaactNttccta
+atgtDaacgYaNatagMatSWtYBaaaRtgMtatSRgaataYaScaVgtaScMagatNNt
+ttacaaHBaWtNtRtctaaacDaaaaWMcaNtcVaDNcagaDtgcWKYgagttaHtgcDY
+ataaacataBaWWtcggtatgtgaaScaacctttRNatcgttaaagcaDctaatgcBatt
+tacaattVaMgSMMtccYaaaBYtggattttcataWttgBtatDtBgactaatgtccWaa
+HataaScHttWttDtcgtcaagMctMDtaaaatRtBaaaacaatgtcagcatBgNNBVtt
+ttttcBacWtttWtSWWtgaaaaSacgBtaaataaagtcDStaagaactgttaatYatgD
+ctattactgaHtaaatStHaagacaKtagDtaaHaDgttccaaDtaaggacactctDggc
+gtDagtcWaHgRcHgDgaSctttattgtcttttccttRYaDgNactaaatcaWggcNSBa
+gttttatatStKgtcRtgattaaggtcaSBttaacaaKatgggatcaaattgRgcBagtN
+tcgDcatttWcctttgtNagDgctgcatttactttgtgtcaBgSatttNHaMcggcagSc
+tcKDtWBaagSagWatggYtVatSRgKagattgaVatKttcgatYatKYSgDaacNtcVg
+tttaWataWtgVctgcgSggMgatccatgagttgtWcatYWWcctVcNHagtNtgtKttt
+gatcaacttaSttattgatNcatWaVgNHcagStVHcggHacaaDttgDttWcaaRaKga
+aatKaattagtaWacattgaaatgtgaatgacagtgaRVtaaYagYtcggcatMttgaag
+gDgagDRcaKgHtacacaaaMcaBtagHactgKaatRtNttcttcatcatNgYgStggac
+tatgSMttgKtDaDgacRRgtWaVattgatttaagYctatatagactaagaggtatWtat
+aaactaYaHRctStgKWcgtRtKtYtYtagacgattRaaYBtaStcttaWataatcHtta
+taRcactgagtgggagccaattctcDtgDaggHcDRVaVVggaaBtRttaataaRRttgt
+aagKNcaVWWgtatacctgatcttBtcttRgaWcaVRKcagttSacttagcgtKtgtYWa
+tatcgNttcKaccacacVKctgattBtggacgtctgacaDtWKttattttgMBgKaacaD
+ataattWtBtBRtVtacataaatatttgtWtttatagtDtgcctagctHYaatgcaNaaR
+caatVtacctgggggKtagBgagaBgRaaNttttMtMagMtgtgattNctcNaKggWtMa
+tcttagWgtaatatatNctaYBggKaataBattYtaattataVtggNtcgtgtctaatta
+aacctHtacaaactDctDtctgatatgMtgataacWctgtgYSaaNScgDYaWtatDatM
+KgcaatttctgNcgtHtaWtagatatcYBttaattactcaaaVattYRWtatttDtaNMY
+MttgattataatgcgNggWaatYagttgBagNcaagaaaDtRgtaaaagctgcatctagc
+ttaVgtBttatagcKMSaattYtHcMaBttcagtcttgKatgVSVttKgttttttagtgt
+DHgNggtcaVtatttaacNtgaatatgctatMcatgaaaBtgBSaWctaataaattatYt
+tagtaDtaccggaatgagtaattggatttaacBtctSMgWYtgKgattacgRctctccaa
+tgtaggcctgaNaatScgYataaBBacaKtHtttcatgaaHtgBtagaKHVtacctVtca
+accaDaaWNHNaatgataattgatgWcagggtcMBtgSgRataHctMctgMHHtKaBtaa
+MtMgataaRWtagYtgaaMaSgctYtgcgaaHatDtatgtcWRatKatatYDcBgNtRaR
+acattMcagaHgaaagRccgcgWttggSatBagagcHgYtatctVtcatYaaVRtcaSac
+aMYDcgRtcaaWgaRgataMtaaaacaggtgtaaYcattgWgDHcWgttaVatttgcatc
+taatccacaaagaagSatgcgtagRgagtHDgaVcgtgcttatggMttttcatKSctNac
+HcctMaKRatttgatctaaatgHaaScataataatgtttgtgtHaVcaaaaNHaaaatcg
+ctgSVtattVttagaaNWcacagtgKtatgattHcYcttgDaWVataBatBttttWtaac
+tNaattttctttaaYHaMtttaaaccgStcHaVBaatcRacaaWactgtagVKtNRtcct
+agcWaatNgctKccttctcDaBDcatYHatatgcaataaBaagaatgDMttaHcaaYYtc
+actgttRtgacRaacctaWtBtBMagBctaaBaWtgatgVtttattataggttaattgta
+atYcaRtVctcttgcacSaaMaatactRSgcataKcagcaVNKttcgSatcaaactaatt
+DtaHtNaVtgttttttaWVtatNccagWttcgtatBcgttVctcBttaaaaMSaDattKR
+cctttcataHaattaatWaaataKcaHVaggaatataBYKHVtgVcVgtcHcttccgcct
+attDtMMgWaacttgWttYtttcMcgtcctaaVHtgWtggtgacKtcaWaYMttacttag
+VWtacgSatatcgWcKaaatHKaaaYttgtagtcaacWtttggtcaagttgaaBBaSHac
+VcgYgttWBSRWggtattttaYDtHatattcgatNttacaaaaVacaMccaaYStaataR
+ttVtcttagaVKaacaWcgccgtRatcatctaaatccMcctttaMggccHgYcDgaKcta
+tgMRYBagcaNDtgMtcRttgtgHaRttacatgaWcDtgctgtataggNggtgaatagBg
+agYNtatcagKtHcatBatgVKgaHWagattRDatatcgYcHagRtaatgWtcStagcVa
+tNaaaaKttgRaRBYNgtaaDtStaVRgcMccatMWaaattBDatttaatttataaHtag
+tVVaDRMKBtaacaatttttttDaRSgaaKDtVaBatcagtaaMttaagcctRgaNVggg
+ttcataatagNatcctacactacgcatgtcggaYgtaKcatggattgactttHtaattWN
+RaaWYggttcaaaggaaNtaatgcHcaaaattBtagcttattcaagVtatttWgcctaKt
+atBttDYcattagDacKVaYNccgYaYRaaMaattRaagaHtatgcttgcRagcgctSaa
+tagaaRacaRacSccagcacVMataatHgRtagcgaKgYRaDcVWSDVgRaMgcDgtaat
+tttaYttggtaaWcttKDaaYtatMRcgKccYcagtYcBgRccattcaKtgaSSRtactg
+acgHtgtaaaaBatWgcaMcBcYcgccagactcttcSatYattgatgaNccaaaaWaKat
+VgcaggtWtBcgttaRMagcaaagtgttcacatataaagaHWtKatctacttatatcacY
+RaaVagataagtaattttgatgtBctaataggtaRtaaHaattgtaRcStYSYaWRgMta
+caHcNSttVNScattNKaaKgBtagtgatYcaaaStactggttggggaBggtNtgtcaaW
+BaYVSNgtaataBNtagtatatcacMcScccVcgtVRRtttNcKaSRNaNtHRttattta
+ttgacaatggSaBagataaccgttcctaDNaattgctVtatNtHtatagSccaagctKtt
+aaacaaattattgtSHgMWgStttNaccattBMYatRtccStNgttgaaBcctVagcaaa
+atgatattcRaBccMWaagKtttttcMtgaRYNaataDttgttWRttattggHtNtataa
+tggttgtStYgaMcYVtcattaggtaatVcaNggaRtNataMWcctcYgcgagagRgcHM
+gcWtgaYtVSttgDaacgaaaatMttYWtWttcctgaKNttatttattRaattaagaccM
+KtttcWgtcaBagKSaWaaacaNtaYaDtBNaaagWtHgacaaagtgVtcatKcgcaatV
+aactatgcgaaactccNctatatMgactatttatSaaVttNttRttagHtccKtHtaaaN
+atttYVctaatttaaaatHWaNtSacgaaaHggaaatcacagVYcctaattcMNtgtYtg
+agttatttaBtcRgBHNacBtactctagaacgcKaaDWYYgcattactVagaYtgaVVcg
+caNctttBagKRcSgaaatttgtatccattgtggHcaatRtaVtaSaBtcYYcatcgtgt
+cHaVttaHattctgtcaBSNYaKBBattaatggctgtHatattgtBacDcBgatttaaaN
+tggaaaaYtNcaKagRRtRgttRtMtWgggatcNtacacctgtWKagatataaYVMtaaD
+taaacctctgtgtgccttScacWaggaYacttttKacgtttgtgataKYagaYaVatcWc
+SattaMcatBYttYaaatgStKagWattKtttaWgtagaaSgtRattcSaDagVaMatta
+ttYaagccSgcNaaDgaaSaggtaNgtWactaWcgHctgaNatttttcaatgtaMHSWaR
+tggtaNtaHBtttWWaaatattcVtBtctStWtaWMaBcatttcDagttDtttatatgtt
+WBtNaYatcccSgtgagcgaRYtBtagaDacBtaagaataWactaaaagKtaKaWaataa
+cKcccgDtagccaaagcggaatcgctSRtacKgcactacccHaactMgtgccaBaRaaaB
+VtcgSacRKtttStgatcaaHgKtaaKaccHaccacccKttgagcttcSttttKKcgacB
+gggtYMaatcBStcgDBtMcataWtaWaMtgaataagaaDatccSYDtgBatgactBaVt
+aagatctcNMgtcaWKtgcWggcgatacgtgtttatttWaDaNWBNaaNtNttcaaatag
+taatScgHtMWttgttgaBaDtgNatSaagtttHttaNaNKaattKatttgatcgtVcat
+gaatatBtttctaacKaNttVttSagccatRtatatcactcHHatctWSKttaMacaaDa
+ttccaRaYttttagttaatattcctYaacVactgctMcgagcaMYtttgaagctagtKgN
+WttgaaaMatcaMcttcSVatcaatgtNactaaBagatagagtDMgtNtNWatttSaHac
+tagaaaDggtaaaaNctMaatagtaHgacgMaaacMtacatHtaSagaHatYDccagtBt
+gaWatcYtVaagataattgatcgacctgcaacgttttattacNMWNcattataDVDacta
+tattatYattttgcgaagtgagYVtagYaWaHaatctgWttttatgcHaacgttaccDaK
+tatagaccaDDttaacgtHBaacatccgtYaBtVtNccaaataaaatVactDttSKtcMt
+DSgaagctaMtatattgattactgtNaagNBcagHaDattaaaWttacacaaatactcaa
+tSDatagctcaDttWactttgaStaaDtagatSaaDtgtaatKtgVataggaagWSaaaa
+KatttaaagtttgcgtaaagcccggNWaacatacatgttctaRcaHttVtcattatctag
+ttttNcataaacDttWaagVtNYtaggctttggtatgagaWgtactNaVatcactVttBK
+cttaaccttcMtatcggtaataYaMaYggttgtcaaagSWHctaRMSatVcggactMata
+tccgaatcttttttcgagtccagtttgaMtcgcatcaaKagtattRMaaaKDBttDNcca
+tttttaaBNtVtccgtaatgaKgtcagMVSattatttaWaattttaHNcaaMaHttgtgg
+ctattctacDtgaagattatcgacaaVRHttcSaSaatactNHWaaNcgtWaWgaccgRS
+ttNtHtcttcKatYatatBaagtcgctBtgagccatatScctKaagaaKDaWactWagBg
+ctgattBagKtgaaataBaaaaagSacScaaagagtagcgaDaYtaMcaYcKtaataMat
+ttttaactttgYgtcgaaggacgcHctBcgYgaaVacRYagagBaaYgtagattgcgagt
+caagtStDagatBgtgaccctaSWtctDgactaSHttctWatWttctaWtatctYacact
+gBWatKKctgtatYgacaaHSatYSaNgSagtatagatgagtatttatgaccMaatgtaH
+tStaWttgYagccaWattcagtBaYtaaNaBtaNatactggcttWcaagatDctacggaN
+ctatcacatSgKgattgacgacccccgagtNDtattgagaaatattaatcVttNKtaaWt
+YacgSNcBHgttgWtatgtttcgccaactKaattaRgacgNataatctacaacKgttBat
+YatNMSaaaNtctKgacttatgcttatKtcaVtVcagDaataattYgNtRtHaagcaata
+HcacaVgtaNNHtHDatgttaMNtggWagSVaRttcMVDtcttWgtRttctacKaaVttc
+VcgcatcctHRKtattSgttSacgaagtcccRDVaacBWagtgYtKtgattgSgaBtgcc
+BtcaKacaDatacttHatcattNatttacgtcagtgaggcBtaRNaRcaSgcatattatS
+tatgctYcacgtattcattaaRtgStcttWgtattKtSYttNaHaRtNYcRaYtVtggtD
+cKcttctactaMcacggcMtacgcttctatatHtaatggcattMDtaaMaKattgaagtB
+aaKMVMNacKaDtttKNcgagctaaagtccMMtgagaagVaataatggcaWaaaaVaBgt
+aSaVgaaaSaaaataDttVtBccaNagcSBgaMaDaVaVYYRVBgttYMtagtaactDta
+agWaattBtattttMDYHtSaStScRaKatattacacctMttgNBKtcRtRggNagtYMa
+ttaaatMctYgaatgcKHagSggaaaaBcaggtHtatWcatcgtStagMcctcatgatta
+WRcStcgWtgRgttttcctaacatcgctcgDDtRaatatMgtcMtHtMaDYatgDattta
+tagctKDtYHaaaaattaSatatctggtctttattttatMtgtYttgtcatactcaaVcY
+BgatgSctKtYcctWaRaataWcMgNgcgggagtcttRMgactataHaHtgctNtVaatc
+aaccacgSRaDtgKtaaMSKgtaaaaWaKtttVagSDtaaaaaatgttYattttNagMHa
+aRtNgBttWattatatgcttatatcatttatKtKaaaagctRaaatcgcYgacgNtacNt
+ccVtSaaatttcDVctaatacWgcaMtcttSaaWaaaWagtagtaattaactagRttaVc
+SaaatataacHgHatWaattggaagtgcgSSgaaVtgYgSttccatWVataatcgaatat
+gHtRcgtBttcttaaggatatgttgtBcNtaatgtcacVatactgaaatMBttRRcRatc
+catagagggacatcgccWttagttgWttatKagtaaaagHtttccttSatVatKtgagca
+atttattaaYVattcaaattctgSattRaMtgaatMgttattattacaNcggVagcctta
+aKgccYcaaDattWtggMcttMacWttccMVgtgaattctDaBYgacttKYtBacatgct
+DcRaaKaaRaatatctttagKcKtaactttaatNaaggctgScacctYgcgcaaaccaHt
+tVHcBaDgtaatHaHVaaatMgttggtSatHtNNaaVagtgtacaataaagacgKttcaa
+aWVacagctcacWHaatcctgtBNWtaNMKcVcVSWtSgcaattctgKtVVaaacaRaat
+tgatRcgBacaKacVccVMactagcgMNaaactgataDaSgagaatVHaatVSVtccgga
+tgRgtagRatttgtaactaBataVaggcaagHgaaSMSaKgctRagcStNcatttVgcta
+tacttcNDtcaKBDcaHtDcaatagttHttattMBgagctgtaaagtMgatStStcagat
+atYcBtataacRcaggRaaaggtaWSatKgatatgagcgtgMYatcagcatVttSgaaaa
+aatatatgttYttcattatacataatVcacgattataDggttBtRaagtHMtatagaDgN
+ttggDaKctBcaaRcgattcgtgccttacaaaWattYWVcaaWagDattgaaagggaaga
+HattBtatVggtaHtWtaMagtccagaKttSatatcaStDtgWaagtKWaggtatttaWa
+aRcattaatStgaaVtacggaacatKctacatHtaaaBtcNWatttBBaNatRcDattcg
+aactataaattataactcagtSgatataagRaYaKHctggtaaNtttaaNgaRHtttatt
+atacNttttaDccttYgtaaacaggaagtgataaacatBgaSgtaaaaaaVcBgtWNtRM
+ttBttaaBgtaaaatatcHNStaBtaggtaVatYaccNtBaWagRctNSacRtMatDact
+StVctaaDtaYSRgttaRNttttKggccagaaBcatagtYcaYNtDatcgtatVcaatWR
+taggaattMcatRtgggatgtcMggMtttataagtaBgtggacNaaKYtgctWgagYtWc
+ctWtVcttaaactaRacatggtRcatctSDcHcMgcaactttttagttaccttattHRgt
+acggcactDBggtMHcVaaRatKctSHacctacaccactaaHaacgSttagKtKttttgN
+HVgagtaYaMtVYNVcggttaSBaBtaatttSRcgtBgaWaatctttttKggacaWKaat
+tKSaccttgDRgtcatatDatVMtMaVcgaattaNaagMWccctaaHgataatatgtatt
+WataaaatBaaMtgRttcHctaagctaagatatattMcggactaRttttKaSttactWYt
+gBcaMMacRRgNtactttaaaSKtttcaYBaBttaVagtRtHcWaggaVccttNgtgagt
+catataWttYScMtWgVRgattWtaSggacggWWctBHatattataaKaagttactaMRa
+aataSRaDttDaaatataVHaatggaaBDgWgHtcKStVcatHtaatcatggBWaagHta
+gtMtgHcHtcatggggWcatacaHNHagcDatRcaaattcgcttgDggDNVcaacgSgtg
+gcaccttMttaatattVYtVgaagRttaBcagVaYaHcaRDBagatgaVHtNMtcttact
+DaggMgMaattRWDcctVtgagaaaaSKatHHttVDgtctgtcacatHNttgaatSaagt
+KBatatagacaaRVctcWtgtacKtaacHtgHataSgVtactaggtttatggBgtcaaaY
+aDgaaaaaatcgMtagaKaYatgaattatYcttKtacaatttgWttMaatBgaatSttMt
+NaVgVtScgcttctBHKgtaRcNBaatcDtacgattgacgtgctatNaaBtMgagNgKct
+tWcWKacactYgttVgNcgaattttcttgaaaaactacccctcgcNtgMctatcccacMc
+actcMatttatttagtagaacMNtttcttgYKaWtaaBtttcWttagHtgtttctcttgt
+ggctatgDgctaatWDataatttagaNcgcRRNataKtctaataHgaaMYctNaKWtact
+aacDtgaVcgagaactggtaccaactHgaggctagagHHagtMgKtaaactacaggMatg
+tYgSBaKaaaattMgatRtggggtHBVgttaattgKttaaRDacgMactcaaacStaaag
+ctctgtgccttcgtSagtSaRctacaataKatattctaVgtgtaattRacKagttattga
+MtaatgaNatacDataaggactttccNtStatatKaagaataKtatggtcctctatgagg
+ttaaDtgtattgataaaactggatcactKBtttggcgtcaaagaaaNtagtWKatctaaW
+BactDaBaYtacaWtaSgcaattattWgaaBgactgaKctatBRgtagttaBaRRgattt
+aagBHctStgtVYRtaaataaagtMWtcHgcattcacaaMWtcMccWttgVgcHaWttca
+NtgtVaggNgcVatKttataaWDcccctatgatVttttattacagRBBWttcttRaWgaa
+tBVgcgtHgWgaccagtYacaattgSttaaMcVtDatttaVttRgttKtcaYWatKtaaD
+tttWaYtaatYctSctatagtcctBtccMaMMtaMYHaSSgKaaacttctcBtMtgDtgt
+ttttagRcgtacttataHgKtNtMtKcBtaNKaHStgSagYHtataDtcKtagRtNWaac
+VgctVtRtttStNtgaaccttaVatgagaaggtcaKSttaDataagcYaSatNStcaatD
+NgttcgacaatttaSgaRaBNNacattRatNtgSttHVtgWHgtSHccaactKttYtatH
+YttVtgHcNgactMcaacttBatatgSgattttacgtatttgtggtScaacggYtHtgca
+tctatttttWtaSatcagaYatcgcagtgtgtMgtattctttcattaRatttStcaatat
+gcttDtStaaagaccDcVtaWNcHYtWMaMcgaacKcaNcttacctaBtgcDacatcaHK
+tRcDaaacataaRacNNtccDataNactttatBSDYatDtctBtaBatctDatKaMcatt
+MatatcDHctaagRgYVcatgttcgtgataHDYaagttSgHYctaaatgtaaaactNgta
+gaaactaattRaatcttttBKcgaatSctMaggVaVaaatgagataaataSgttKgtcat
+KaKatDYtaaaRttYaMtgctcSatRtagttttagcaaNtaKgatcgWYcacDgaatcaa
+tactgBgaNtaactaaWatatacaatacactaNatcaVaKaaMaaaaaatcaccBtgttg
+NctaacaBattttaaKWcaggataWMtaattgtaaHtgVtcgaHtScaHtctcHacVata
+gtaMcaaKtcccSagMYtWcaaatHHtaagRttDagtMtcYtttaaWWaaaVaRtcHNtc
+tcSttagcacaKttgtagtNgWYtatKDtcatttgaacctcKHtatccttattcttNggt
+BgtgtKaggWtYgtStgtVaRtaRaaagtagtgtcgcKtKagatgagYtttaatKcScct
+gaaaaaRaaHtttttaaaVgtatagKctaNtKaSVgttcgagacattttRSatagttSac
+ataMtaYHccacttttctatactagtatgaBaagctttaMtgaatgtcaKYtaaatatgg
+attataNcgBHatcctaRaaactgttgacttYaHtStcatcctDaMBttgtaWgagtaat
+WKataaaBgBattcttttctttaatWStaatacgNaagtWaMaaNgactMtgaaDaggaa
+aSctaSSgatatDttattatcatagBcaataVcHcRgcStaHaaatWagatHttMHacta
+RacttaYaaaaNtataHKVaataKtatgatcgtcVaaWgttYtVcaaYggctRWttaaKt
+RttDaKtgtatcaattWKaatBHaaaaNgaatggStHgVVgatMgBYtaRNgBDttMcNt
+ggaNgtcaHtgttDcNaggBtatYtacVaNttctcWtactHYcSctgtYtDtgWaatcHg
+atDatatcHtcttatattaaKaRYaDgaatgSYcgactgcRgaagttagtStYatYtttc
+cgacactacagKcaaagDttaatVatcttaaacRaDatRcBatKNtNtaaaHtcBgatKH
+cWStSRaKaSMgtaKaBacWgDDttgYaaYttaNtDgHtatSaSataaaaMBaaDtaMat
+DaagWtggaMtRcacttatggctNataaaaatatWNMtacctatgtcaYKaRacagttHD
+agccgtaaYcaatataatcatagggaaSatgMYBcKBBtaaRVRatRtccVtgtgaagVN
+ttcttagtgtcWataVggtaaNaatVgVaKctttNgtttagtaaagBatBtgaYSagHtt
+SYaacaStcgcagaSttcDBtKtttggtctacNttgNgKNNtcaaaaKWactgaaYgaYa
+ctatHtaWcaactgttSatNVtgtctSttYctgattVaatKgtaYcaaattSgttaStat
+ggtccaatgSWccaaactattgccgttacgcNatcHctctcaKatgtagtctattttaag
+gHRatcDaagSaVgaVNccaBKtacgtttStagKgtctaHtcattaYcctaVKtttaYaa
+atYtccgataaaVttcDgatWcgBtcctaatttNaattgctDYgtgatcaatttaagggc
+tctcatcKattgBtaBagcaYcKctctttNtaacHacNStggRtMatHHgtacatgcaMa
+gtgtccatRWttRKctaaaDtcMctttaNVgaNtcMatcacHcctgWtaaStcacgtctN
+aagRNNaagMaDtactDgctttttcatcYacttaKttatgcStDaStNaMgDtaacKtMt
+acctaaWattggtttNaaVHatgaaattaattacgVNaaWtggaWatctgVatcacYctc
+VHMtVaNacNtcccaWtttgcaacctcWctHaatcttWcaaaYaBaattSctYatctaag
+DgBttagtaSgaWtBcRcKtccYatatcKBgtctttatgaaHDcgNaMatggatgtWagR
+ctStagagaagaacagctWtNtataaaataRatHatKgctNactHgttRgRgVcRacatg
+HYaNttaHtattaNStaagatgtagaHcVctcYgggccYcaaaatgatcttctagctctH
+MaMMgcaVtgHgtaagaWHHtggtaactBcaMNNctagaacggWtctttgaggHcYNaaM
+HtaYcttKaagtSccgttgggNMStatacDttataaaVaYcKtcgcattttcgacctctc
+acVttNtttattgtcttctaVcatagaattMttgtHtMgacataaatagttctMtgtWgW
+ctttcaagYgcgtNaagcaaDaVHaaStMtaaagccccgtgVgtcacatcHVaDtgttBt
+BacBtcggYttDagaDYtccMttagcttacNcgaagatRtDataRtgctaatatatgRtW
+VttatWKtgcBgactcgagaSgtaaaaagttaaWaaagtatttctcWtatcBtcataacN
+cgctcRKaaDKactRaNtagtatBtgaaatttcgcDactttaNtYgagagaNttgaatta
+ataaaSMattRHNtYtgttgaDBRBttgWttagSatgacDggNVagRWcggctacDaYSg
+aaattHgtYaaagctccVtatacattaMctttgSgacatBKaattRgtaBRtttaactat
+tctagcMKMtttctgtgtgVgtctttcDcgtaaMtaggtaaaDtcaYtatccgattcYtg
+aaRttctKaNctaYgYaattYgRttWctWttaaaccaatcactVatgcgYttgaaatgat
+KBcNRgctcatgaccHagcgaaaatgtVgccatcaBSatKccRStSattaaatttggtaa
+gcVattctgVcattMtacatMgaaaaaataYNDtDaatcatWattcaggNcaccctcBtg
+cKcHagYtatBatgBttgtVttaYBgBgataaHNtacRtcaaBaKcagNtcagaatYgtt
+WgggaNDagtatagRtctcDtDaHScagttcYcatcSYacHcagagNgtgcHagtacagc
+tgRtatatMtaatRaWMHgaaKacaBRtagHtaaaNcVHcatWBgWaaacWccggtaaRc
+attgMgttaNgttVMVttgcaagagaatcaaaaaagYScKVtgccgacHgacgttcaMcc
+tcattatgcBttttaagtKatDactccgBatHYgttcatcgaaatctSaKaagaatWVtc
+gttgtcttaMaaYaSDtaaaataccgcKMtatgKtgScaaDMaaaactgtgagcVtttaR
+cttgtaNMatatatttggtMgYVatDaatttgctttaaRtaBgttaYaaagKtataMtWS
+tcHaaaaNacgctacMttDDgactacaNaatBcagtcattatatSttaVgRtWgSggcaa
+tSataVgSYgctBttataaYRRgaactgtgHtgacHWSactYNgtttBactatWStaNtc
+StcMttgattStacctgaattctWatNaaHgMatattcaaaKWaBaataatHKgaWgata
+YcaWMBtgtacKagaaaaagaattttWttDaMtggttgtgaNMtVtDcaacNttactatt
+acggKctatttaaaaBKatagttHaatggaatatYWgtaVtNaaYgataatMaccWagag
+atRttMtgKaMcgatattaacaagatgttBBcNaYattcNgtRttgaBcctaagaSMttc
+MtcctcYattcaNaRBttaatgVcMNgaacKagatcgNctaWVgttaaYRtgctSctaaa
+aNtttgctaaScttcVattaHtaaMacNgttNtKHMcctattttaRtttVtSgtacatBg
+tVaaSSaMVaRBcaSaRHtaWtWHttMtattVcaMtWaaaNaccccgHYtcatagaaRta
+aBaatttaBccaatcRctcatagWgcBHRtacaaDttcBgaHggcgctaHtgacagcSNa
+ttcctcgagaccBggtcaagWctgVcRDgVtaagtttaattatcMtgatNagYttHtYta
+gccRatagDtaatcNtaKtacaMSgDaaaatttgHaHtRDgtaattKtaMHgaBcaWtBN
+YaWgtttStttaSttgataatgactMKatHBtttaVcYatgggttttaDKcSatttMata
+tcagtYaBtgVacaatHcaDMcccgtaataatagDataatVaaagaagaVtctccgaRgt
+RtaatcgagtcacttgttSatgNDHaSNRcggtaSaagcSaBgWSgcatcaaWatgttac
+atgattcWacMtagtgNcacgatgatttttRcWttSgtaatMRRBaacNWRHaaBaattD
+aagStgatccttcaDacccctKaagScSSHaaYHWcHcaWcaaaMBataattgDtagccW
+tcRHataMNKtMgHaBcatcgaagtgtaRgtgggaVMatgttaWRtStBHactaaRaact
+NctcHaaaggcatgcVHKHgaatcSccttggSaWatWtNcaaBctaRagaaacacgcttc
+KatRattcWtgYDaaaaaaNatWtKgaacgtNttactgWHBaccaWacggttcaaVgaga
+aacVtMttatagaagtatWtaaaNHYaMacagWagtaatttgcatcttcgaatacggaHt
+aatVattctaDaHtRKRaNHcttacatcDKttMDKaWggDtaatcttYctcWtRaaaaKt
+aatcctgccccatgcgDtctaaVMtWRKKDctaatatDgactagWtaaaBcKcacMactM
+HHttgDataKHDaDttHttatttagtcaaVatccKWtacWtSVcaggtaatatDSatgcc
+tKtatDtttagacKaaaagcgtttaaSaaaYtgattgtKtgBMcKttgDaaaagttBRat
+HgcaKgDgtgcWataatMWgcVaVatcYgWttaDatcatNaVgtttgggcttgaHRDaWg
+atttctgMHgtVtgccttBtWtaatcgttcgKgRcaBaRMtaattWgctaatMaVBccaH
+tDagaBNaataRcacYcYcHcatBgaNtgaNgKHttctYaacaaaYgBttRNtNggaagc
+WtDggattgagtHaWttVacaaaBtgttaNctaatactKaMaaaaaDtaRatttDaaagN
+ttcYcaaactcMgaYgtacaaatMaaatYtcacVaacgaaDagatWgBgaataggtWtKa
+aMtgDttHtgagttaatttgVaaDagttNMataatttaSVattNaDtKVccaaatcgaYV
+taaaacKRaataatgaBDtctRtgVcttatttYtgaHgttBWatgaatatacSaacctSa
+tNNRccagtactKagaRtgSKMcgaaDattttagtHcKcaaagtggtataaaggctccta
+SatHtaMtRKattaNRcWtccgctataKggatWttaggtaatHDRatttattRWgcgatc
+ttagSgtcttactatgYgttYaVBtgcaYaaRtDaatacHHtDcttHgBgNcccataDta
+aaaatctNtacatatWaRMBgaattaaaacgctctctcaagtKcacNacgVRVcttttta
+acttgctcStatRScaRaMataNaKagtatcattRttNaVatcKgtacNatttttgaNcg
+acaaKctHWtgaKStacMaBatgWttNSacaaKcaDaatcWaKaccgYBggMScgaMcct
+agcaDatgtttcVatgtRBtKNWHtcctWDtatttttNNSaatattcMttgatKgNgaNB
+atcSggtctRcttttttatatggtNttDYNYgaaaKctcacacYHRgttacatacttYac
+aataNaagaaaagttataNaataSatacagttScacVaScaccSWtccagKHtaatcaaa
+tVacatWacgBctccaataHaaYtMtacKacHttttKtcataWWtgtgaatWaataaaaa
+catttcaccttaHtttgttccaatcccgRBaWgatKgagtttBaVgaNtaNVBgcaataa
+gaatagcaKRttgtatcaattaMtaacatataDBgtaaNttcaNcgagatYactggttat
+gtNVtaBNtDaaDtDttaSaWtactaVtHactttNttcttcatWttcDatKaacgtttgg
+VDaDtVagttatgtcagactKaatcaYtSgttttataaataDttKttKagacWgHgatat
+aaatcttagatNKtttWtWaaatattacSHaRgtttScttaatWttacgRRaaMactcat
+BacaccatRtttgaacctacttcDMggcVaSBagaatcttaKMagcaVtctDVataWtSg
+atagacttBctDtBNWgtgKatWctYgaaStccgVaaaDattYatagtatcaacBaWYct
+gaaatttaKVgYtStNtcaVggtggaNYgaRtMaacataSttcagacVactcaVaagtgg
+tattaaDBNDaagtatatMtactatatgatRSgtttgccaacgcacRMtacRYNataaga
+tcMgttgatcataaacttVcatatgWtacaaaWttggaaactttaScataactRattMtD
+acVYataaaagMaattttKtgaBttKcaacatattVtagtcatgactcgDaacDtaWcta
+tRttSSYNtgWaScaaataagaaatKtagacataatggNaatttcSKtVWtgacagKWat
+tcgVatttcKWgagcaWgNKaaaatatgtaaacgttcactaaWgacaccBNaacagaaSt
+ctgctaHcVtttMtcYttStagYcgtttBcRtaYacttgNaacMtDRtagcatgtgcgag
+cScaMgtaatBaKataactMttttattaRcattattatacgtaagSNatVRgcttcgaVa
+acHNtctaHBKYgKaccYcttagagcccaVgatttgttagactaaacgtgcaBgccaWga
+VataggattDBWaattttgtBacWtttttaatDtMgaactaagcVtctcagBMKatgatt
+gaNaVttggatDaSaBatttcgccatatgctaattgYacatgatccacaaMHtttcKYKa
+WtYcgDtNaaDccgNaNcacacHKttDtttaggctagRVtYgtaactagctttcacaaat
+YtHaattYacaattaMSagMactcctcatgtScttcaaYtataaaaScHYaKcaYacact
+VcacataNtaBcaRatgYagVBatttgtaactttgRggacaagcVacctattacRcaaMa
+cHRagagtaVNctacagtgagacgaaaggKttacattgggacaataKNtattcaagWKtt
+gatNagNtgctaNgagatNacSatctNatttatctatRgaaaatKatNKSBcKactatac
+StcagtaggtVtcaaaBYYgctattKtWNttcRacaaaNatgaacttaRtaaDSttVBYt
+aatccagtNaaacRttagaaccRBatataWaatKctcattcSacWaacaacactDttVtt
+gacYaagagtaSgcMttBttaVNgRVagKDcttcttcNtaggttgcgacYacttaaggVH
+caagDagaagataaVaatctgtatRatDtKaaSDgattcaattYtcatgYgtgaVMtMaa
+ctaagaatgRgDtHttaaccaatStaaaaMctVDDtgttatcttaBBgccNacKMaHggc
+BMttctgNctHggagaataYMgtaMccaataattHttYttKggtKaccaactcccHtMSa
+atNactcRtttcatgcKcatgcacttcatSaatatactttVtaYttDattgWcctcactc
+YccattaDDaHaaKcaatSttagKtWtcatRcaactattaattYaDggKtagtNcgSgtt
+tKRgtDWtVHtDNcHWNtKtccgtctagtatSctaBcacgcaBtaacatgagatVtttaa
+ggcaVttBttaStWtattgYaggtSatBMBDactVtggttDagacataaactactBgcac
+aacMaagaStccaWNaaSYMYtgtaKaMcYSaHaaaatatttMgtcaaDScaKtcaBVta
+MVMRRDMtcttRBgWctaacttgaacNaatgttWgtggBtRttHVKgKcHVtatattSaa
+aatBttcBtttcDgHccBagtRBRttaVagBctRcaagcattacKccaWVWtaVcggtta
+tNaSgccgKtYcBaagcWgcatgaNHaKtagNgcHcgtgtcataaaatagagacttgHYa
+tattctaBgtttatRatctatttagacattttNtWaaSagtaHatRtctcggatttatgt
+gatBtctRggggcatWctaSVMaRtcatgKattgRcatMaHaataNcBcDcaggcactat
+tHBgaatStatattcatBgMVataaSacVacKHatggttaaBKtgtaSaWMattttMacK
+tgaaWaaWgctgRatgtgDacBtSaHtDgtgtMVttagatgattagagaSttgattgtSa
+aacagHaaatacaRcaccBtaaDtcaMtKaaStttatKagaataaNcaaBtattKaVNaW
+aNactagtYattaaagWgHttaMcKaSagatSactctatMSagtggaYctcacKKgaSMg
+cRgKtgccagNMataatccaVgatcttHagttttcttaaccataggggcttaDtYatcga
+aaMataagcaaatBttgHHcHagacagagaggcacWtacccMttacgtgNttattYctVa
+aactgttaagtKatMagttcacaaagggatgaVNMatgcaSattatcKagtHaBtgaagB
+cggagtWttVaaDaccMScactgVatccaRaSatattNtgcBatgBaaNgtcaBMgggaa
+tgagtatRgaatgtNttacaggcttaHaataaHSagatagtgVctattaaagggaagDWV
+ccatcKaaaatRccccaSVaaatttMtatStgtWagtStMaaatBctgcctKWgttDDaS
+KactctaaVRtaSWcVactggaaaaNMaaaccgcacNtaVgaagcttDNgaDBtaMaMKN
+tKccaVtgctcttMMYaaaaHaattcWgHcgtacatWaMaaKtaataccgBDaYRaggat
+atSKcScYagMtaatKHMtaaccatgHgtagDaggtgtaaatatagaKVgccRYctcRaK
+BKWtgatHYcaHgBaYtttMcatataatgaDttcatttaStgtcVSgacggtggVgtBtg
+acatgtaaSgtBgatKtKtaYcatVtNattataaaHaSccHaaagctSMKattcatagca
+cagtgBRataacaatMttKcWaaaaatagStcggRttaattatWaataatMaYagatgVt
+atccttttHaScgtBgagWcatgBtgcctatcgtaaWHacagtactgaattaaaaaNatt
+RNMaSSNSctattcaaagccVVcatattttagMcgtattNtVBactacScattgKVtata
+aKtttgNaWcttNacctagtgaNaaDcagtaWgKggaaKtacgcaaaYttatacSttgYa
+YttcDNagggttVDagHatSgtacYVatataVattataSataacgKgatVtVacHYRWtt
+atcctaaDtgtaaDgRDttttattWtaaDttggatcattNgtVaaaVggaaggcYgSWaa
+attcWHcgaSaVWaMatctMDtHBgttttaatctaWaagatatDKtVttaccgaMatRaa
+aBttaNagHatDHWcDtBVttaatKtMataYttSRHHcgtaHDtggttccaaagRRtaWt
+VctRcaNDttatacgatMcaatNHtacgaattBaatHtcccatctctccBtgtataYcta
+tgtcgaaDYWtNggatNcacRtMaatNtKcttSYSctaDaaaggctDaStatKtataBgc
+VaatttggYcttaaatgatgtHctaaccaactttgggttcMaaDattatKtVacgVcSca
+actSataSccHttYctttgtggcDtMcactaNSBtMRBMaggttWKtattaatgtKHact
+tcaMVatctgttgtccaaYNtaagttKaacttctHcgcWtYttatMBgBaMacaattaDa
+actNaaatSatcVtSSgatctatgNatSYaattRatgcDgtctataagagaagRgatatt
+tcccaataHgttttWKtgaagNRtctaaBtWcHHcDgaattgaaaKtgttaaRtatgtaM
+aggDttcMaccaMaattDctgYctaWtStaNtgRKaBtNcMHcSttMtaKccYacgNNct
+ttatStgVtaYtaagttaagaBHaaStVKHatgttRVWtataMtSatgcaattcMcttat
+KgMcagtgaatcYtcctNaYcttactttctcttcatggcgNcatScStBtagctWtHaaW
+attaccgtctcgtBMcaaacKctcccaacttBgtWStVttMRgKcVagHttVtaagMaNa
+tcaHttacatcYKttDBtatgSattVcgBcBVYttHNtcatKgcYgaaSaKtatttttMt
+ctatctaSaattDttcWagHSacgttagYgacWaSaDKatcNgctaatgVSctgctYgaK
+gKtaataggtggagcgtcgaaaaRYtgYWYSaatacBgacWtaNStcaattWtRctttta
+aSYgttcNgtBWWgtgaatHttttBaMcMtKccagtattttcgaHaDtSVgatgaacatg
+cacgtcagagDYattBcagDctcttNcNtaaaatRctgMcDacaagtttagtcaaSSaag
+aaacatacaDtctctYgcaaacBcaagaBatgtattgacgagYacBDgttcgtgRtaMga
+attttcNtgVcttctgtctagtgtccatatctgatYatNtatVWgttacaDacaHDDagW
+tgataWtatcaaBRatDRtMgVcgaaattcSMagYgWacgggtaacaaattcagcatagS
+gttactBctgSVWatYcYgcBWgggRcHtataSaattBcagHgcgcctttKcttWaggct
+ttaaDtRacBactaaVaaKtaaacctcgcgccattactKactKSDcgacaVtatatagga
+taKctcgSatgHSatVcgtagtgaBtSYtgaBataatStaaccaagttcaDtHtatatta
+acYatattatcctacgagatcaccgtVSttctYgtcataaVactcgWtaVatttgttgga
+ctaaaVcaSaDtYcgNtYtctVaMtaattatWRtWcaNtaKcaaYggatgNgaatcaatc
+RtcgagtHcgVgttataHDcatttaagttctHtcgMRHtaaagaVactBMtatgaagtaa
+aaaBNtataaNttcKcctaNttaaDtcgMacgDcaMatttgYtaaNtcaccgatgagMtg
+ttaggWcacHttNgtcttHYMcaattKcagttcNcaaaacgNaaSattgKttaaBaKtta
+tttaMggHcttttaaRNVgttaYttttMVRtYVgRatKcgVtacgaatttccBatBgYBR
+tSKKctaaaatgatatgBtcttcgtttgacHagtaattatatctgDtBttatgaDtatKt
+cKRcRttagattattagHgDNaaaKgcgMtHtttKtDtgaaaagtaMatcagaaccgaat
+KgtatatVaccRaKYtDHtcSagtBgtgccWaaaggtYKcaHatDDaaattDStDtcKgg
+tMgcMtgtHtcaaVcgtttNtagtNtgKgctaDcScgBcWSatgtatagcKgWgttgaac
+gagtgcgcgtKaaaacgRtttccatatatttttMgaKagcVcVRataccWctctcgBcga
+ggcgttaatgaHYtttHtaSWtagcagtttKtYaacaaataMtaNDatRgMBaBacSaat
+aSDctgaactattgataaRtaVtttHatWaacWtVaHaaBDtactYtaDactttSgtKtR
+attgatttatatattattataattBatagattctaacDcRMaaggttcgtcatattRVYc
+ttKgtRcgWaatcgaaWWatDctacaaaagaattHaatctgttttacYatKatBaccMaM
+aaVtcacStaaYgYKgtttctcattatattNgSaaHtgRaBtcataKYtHtacttgtaca
+aaDtYtgatagNRcYatgaStaaagactgtcWDtYaatVaNStagaaaWtaaaataDYtc
+aMatSVBVaaaYagaaaattgtgcDagWSaStattttaatNcacgataNBtaattggaat
+gcMgacattHaattctctaaMatactaBaaattacaHWgBNtNaaSattttaacHtgtag
+tBtcRtttSaNNaYaMaDtatDtagaKggYgcaaSttgctactDcNRtWgtttaVtggca
+aactattgSgaagtattatgDgcgtgtcttagcNtRctKggtMaHgaDaaagtactgtcg
+atttagatcagNggtaattaKaatgaaYaaHaattggttVaaMggatactctaBgtYHMc
+ttccVcaaWtgttHHRgagttKaaagaBtaRtaaWaggttctatRatSgtatcYtaWcat
+gtaBtcaatctaatRgaYYtWtccattataBacttWtcctaHaaaaggttgacgtRattK
+gaagcattSBtttctaNcSctSStNtYtWaWtgtagtcttgtctttaagNKgaagacgDa
+RgtNaBaVDgaattggaYtaccSVYKctSKKcatagttgSttatcStactcaatSMataH
+caKgatWVYtNacagtttBtRagYHaagtaNaaVVDgatattMaagattagcatcctaMa
+aMctgNtMcSaRcgctHMttaattDtttYttcgataaagtMtaagttaWaaDcaatccKg
+tgMMcatBgtRtaHBcttgtBaBggcaDcgaWttgggtaDaggtgatRtYaMWDttatcN
+tVcttRaKagctRgtgcNaatctgattatagattagtatatgaataDNatcYaggKRaca
+atcaHcaagttagtKgRatRgttaagaaaatacVctaaaagtgtaagKVgcttSWaaHat
+agHctagtDgDtSaVtgatcatttaNKgKHataKBctatatWaNgtttgcRaVNttaDgt
+cttagHYKatYaVaBtaatgaBattaYcNtgcaBtHaacttVtccatDagVaaaYgWtND
+BgacagVgctcaRtaHaaacttttacaaggaSRaaatagaagaatacccVaHatcBRtct
+tttaaDMHWtHgacMtctcaagKDttctgYctctcNagaMgcgaaDWatMcMatatttDc
+tttactaVSctagttcaRKWgtttKRaVaaKtacaacaKttatttttggcctataaDgtc
+BctBDgcYYaatNactcaaRgaRWcgattgVNcWaatctgKagDMgctatKttRatcatt
+MaagtctaRaVaattKctgaKtatccgaaRatcHMaaaaaagattccacgtacgaDStat
+atctcataggtacgcgatgtgaaggtHYtatWagKVKgaMDcaatttWccttgKgagtct
+agatgaatgVRcctaMttgtaRaaYtRtaacWgaaaMttatcatNcgttactaaggtDaa
+ggcagtRctcatcaatggYagccagcgaatatagtgttWtaccaRctagatttDtaaatR
+cDKtccHtBWgttctWaagccYBSgtggaaagHNttHtctaaattaBatggaDMgaBgat
+atcaatactcMtaaKtcYccgatDaYgHDBaagBattWattgatttttaagaRaaggatg
+gYggaKttaKtBVBcttaWcttBtacctYaNYttgctgtBaaMtWtcWaagtaaggWcgM
+DaaNtccWMWtatcMVgaSaRctaKtBgKWDacDgaaaaNgttcaaaaataMcttaWtat
+gNaVaaRataWtgKctRatataagtgttgacgaKgaNgtaHattaaRagSgattctatgt
+YtcaattagBYBatccYtgtNacHagHtacVcVacaacaccgNgBtataYaatWHSttat
+tgctDacttgtgHgHcMcHacagctRSDtgattaggaDHtYagatggagWtaMatcRccc
+acRaaaYagcagatgatacatatttVBBcaaMtctctaWgaNtttcctaVcttaYBDBct
+RgSaagcNgatttcacgtcRDaVBttaRaggtaaggHcacttccgDBKgagaatttataa
+aMaRattagcVgtttacaaagagaaaMtgDtttYttggcttataKaStacaVttBttctt
+gBcVaataaagagtgagBgcgNcNattgaaacRcactDaaccaatWMtaaHtBgaaacaa
+ccctcMctcaaatctMWttggttttacttagcRtttacatRtccBttVcatgaaBacaYg
+agHttatWDtcctSatRtYggHtNMttRgNtgcatcacgacagaHgtYaSaactgaaNWV
+agtagttagaNgatctgcatWYaDacataHtaWttaatHaDgactYgttcaSVtttacct
+aatttaDgRcagacaDtgcYVttaagaSSKBYtgHtDtNtcgtcWttDtgtcNtgacKag
+cactccDMacDNcccctWataRKcaaatttctRVaacagcaMtataaattWBctttgKgV
+catttaVgtDgtatHtgtaSctagtatagcBtBtgtatgtcgcMcgagttctacgaaBgW
+ccgaWatgcaRtWtaagYttaNtcWaHtgattYDatWRgRWagtRcHggNatNttWaaac
+aSgcaatMatgacNgggaSatgatttcBHcctaaggWactacagaaaagctMcaaagaYt
+HVgtaaHKgKattVaWtttcctaWgaKattatgMaattBgaaagtgaSaaaWtSNBtttY
+ataVgNatgaSgcBaaccatattcctctagRtattatctttctMtgaRtctcYgaatDtR
+cHgcRVtWtaacDtcacYatRcttNgcgaDtVctWtacHtatatgtatKaaggtaNcata
+KRaataacacDctcctWgtSaWcatcDgatatBtaatHSNBtcaataaStHtacttaYaD
+aMtaagMtgNaaaaNccccgYWHaatgcBcttaBcgtMBKggccaVgacaWgaaaaaVYc
+RKctMgcaccWctcSacttcVtacgaagtYtcctttttaYgttattaataactSttRggt
+cVgagWRStatKataYcaatNMtacttcgcttVBaYRaKttaaYatacagctBgagcttc
+HcaatBaaaVcgctcacaMgttaHaggctaDtSgatattggggBgRMagtaattggattg
+YYHtVtcttSRYaacttataBtNKgatVaWSDWacatVcttgttgaagScaDaSttcact
+aattagatKttaMcHtMgKccaYatKataMcKNgattgtYtaaRHHcaWagctgtgcYat
+MHaatRDgtgttYctatNKtSDtaKgcBttgagtKtacatgaaggcgMatDaWtcBatag
+taaaatNYtSVgVatttcaNgRtaRaaNBttggaatVgaaaaagaaggtgNtttVBgcct
+tgtgaBtgMgtaaacBgtactWgtaacctatatggaSYattYtVgtttaagccaRtatRM
+cgWMgDVSNgataatBRccNagagStHttBgctaBagatattaacaagaggttttcDaRa
+gtcDgtHttcataagaacaKBttaBgactaRatgaaDYHttgVagcMcBDgYactWgSga
+cBataMMcttSaRHgcagKcgaaYaDgttcataYKcttcMWttattaaBacDcttDtttB
+catVggttVHtgtMgKcgaaVgtcgMaaHHYBMaHtaaKaDttaNgNtttttaggMcWtt
+NaaaDaaaaactRgaatagSVHtaataagttStccaatcHataatacMcattHtacaatt
+tctgatggacatatgcaaacaKBatgcagacagVcctccgcaacNatcMaHtcMtaSctg
+taYgtStcBtcatDacRggttRgagaaHatVcttYWgaDtatgYcaBKgtSWVYtttctW
+ttHtctaYttttaBtcataaNgtBRaNcgttKgtgVKgggVtWatcWagttSttttttaM
+aRWtccgttttattaHatttBVtataSctRWtgcMacaattaStBcacggaatRatactV
+gaagMaaagWacaMgctaacaHctHtaatacacgaYagtcttKagcDttaKBHccgtaHa
+acaKVtcMKcaataaaNaggttSaatcatgaNaaBtacggBcaagatcRgttttHaNgtK
+ctYatBHHtaaaDNHtaVtVagttVacKtcYgcattcatacaaagtaacKaKKtaaNtNa
+taaNaaSaBtagaattctgacacNtaHtataBDttBctataatagYSctgtaHcgccgaM
+BaggttaMHtKgttactaaHaacgDatataaagcaWtgaMtttgVatcKaattcgHVNat
+NgDaaYtataHacaaacaagagtatatDStgcNgcRtaaWVVaDStNgtcaaacgDttaa
+ggNttWcaVNaccctgaaaMcagVYVaMtBgtatacSacgSgNtaaaDtRaBSaWcNacg
+YaggtcaYtattagVStaccgatgSStMattctWtattHtHaDtatgYaatattgtttta
+NggttVatcttRcgaNtHaVaStgaagactcacaaatcactgataaKBtNHtttctWWta
+ttgactacNtaWatataaaBaatBttgggtatYtttYtgttttVttgagtcVaMVgaatN
+taaNgKMaacgtaatattKWggcagtgRttgtgacactaaYacactggaaKaWYRgcatg
+cgttctBcttggtVaaWgtttHagtcaatctcggaNWtaatBNcaMVKStaNcMtgatat
+aatDYMctttcgcatgcYtHtVNgStggagcBtggMgccctgtgNtVatactgcctcHca
+taDBtaStgNcagaYttaMtcaYtgtagatDaagaHaaaRcRataattcaDtcaDgttgt
+atRaaaaYaRgtttDBgDcgaagcNttgcVttcacttaMgtMWaYaattcggaDcgaVtY
+attaBYaaaattaHVttttWaacDttaRaSWactcBgaRctacaVStBaaatRgaacMSa
+agaatagYtNctcaatagctNttaVtgctgtttgYcttaatgtgMaStactgDBagVSgg
+tSKMYttDatgtMaaSaVtccSRMgaaaactHaatWWtcatttctDgcMcggVtgtRtca
+tctttNatcaatatYaKaaaatKWtDDDaaactaagtacRHtcKttacaataggttWctt
+ataSaYctgctVtaaVggatcctaHVttgWtgHtWttaDHaNgaccctatatgcWtNtta
+cctaYtttDWtttaggHNgccatattacKggattVatatcRcggRWMtgcaVRaaHgtaa
+taattttaggtctcDccaatatgSaaaagatDtaaVtYgNaHBtcaYttaaaaacagata
+taaagttaaaDWccMHMattggtaaagtccgaKtatDKaVHaBagaBatactataVttDt
+tDaMagctctaaDSggtttgaDacacVatcttNtgatKtVaBStatgNtgDKYcaatcat
+aWtcNatYccgRtcgBHacaBaatagaVtagcttgaKagcgHtttDNtgaagMttStttt
+gDDKRWtagtaBgtgagtgBcaDtWtaHcctatHatttgttWgagcggDtgtRDRcaaat
+agcacacRtDgtgVaWtaattRacVataBWacSYWVctgYtWDaVtaKataaacttKaaa
+MVHaaaaKNtaaacttgVataaaatMaaatMaagtatcaaRtatSYRtBtaataattgtt
+tgaWtaNNtctcaatNaataaaaaaattgaaaattattgtgttaaYatccccHtaNcatt
+cacttttaMgVDtaDMtcaWSgYWcSYtSgaatHtgctagaVattaBtaaaYgatattcg
+aaBtgaaDacacatRaagcgggagggDMtatDttaatttggaKSNtactRMttactgtBg
+gcgtcatNttctattaVacgttccKtVttMacttWtctaYcacgtaVtaaRgKcttggat
+SYatattttgttacaaMgtgagagaSatattWcagDttggNtNaaYtaggaaKtYHcttg
+KattWagNgtaagHHVatYatcattaaaaaYtHgttcaaaataattatBgcaKWKtagaa
+tagtatBagaaMtattMagaMtHcWgYcacgttagtgtDNggctatNatRcYYHtaacMa
+SStattRagRcgataaaatWNNatgaaatttVtKcRtKtDtaaMcctccaDRcaHtBSWc
+YtaKttcacaaMaataaMaactccgSgtYattDtaWctagatBtaatSgatgatHKgttg
+caaaaagaScHtgaaHRDatSagatcBcggcatcatYVaatgMaatStgNgWaaaaMttg
+cYaaagttSHaYgaaatHattBgtaaMRagSaSacBaagtttttcatgttaaYcagYtgK
+tYctaStcaagcgtaVattaNatWtHgtHKNDtcNaKaVaStSacaaStttagaaataat
+gcDSatgtaKtgMMtcaaagtNattacMYgtgctNgVcaaNcDtaaaVtYggtaaaactg
+caagaWNcaaacctDSaaSgVaKtctcatataMtggBtaRttKtagRcctgttaHgWRaa
+ttgDaaatttHtaccagctcagaccKaaBctaagtatWtaVagBgtttatgaHaaggatt
+StaactWacKDVtMHccgtacaMWYctDtagatttRctaccRagtWcWgaaaaMcagttc
+tgacSctaaaactgaatcacaNcaMWtWccYgtttNaatttggttaaNtggttSattttc
+aacgYVccMtcgaactBtatcYttcYDVMttcgattaKWtatttagcaatatcagWatgc
+RVaatgRtacWaVVBttggatRtaNgRagttDYataacDVBcaaactttgtttgaccata
+gHMtRctaWcgacagtgcVcaaVgRgtaagtRaaaattSBKacBaatcagaatgtHattc
+aVRtatVSSaKatNataWRVaaagMaacataDgataWHatcNYcMtatttggaSatttcH
+cgacaYcaKaaatattacHcSaBVatHacactaMDataaaggcacaacaSacctgtaaRg
+tcccaaaatWtDtagtcaagNtttgatDacDgcagaDcWgatDaaKagctDWtttatatW
+gDcaaaWttStDtKtatSagVgaaKtaacgaccgMgaSaatRRcagYtgttNDggcHSca
+aYDWtcaacgtaHgaStKtgMtRtaatccagtDaaacHgtacaaccHtagataNaattat
+cVtgaKaaNaaaaaaaagttgMgtcRaNaacagtaKcaBgtttgaMDgDMacttattatg
+aDgagcgtcacaaRaagtYaggMtaaactagaacagVaMWataggtatHagtttaaHtca
+gtaaatgRgcatgRctgaMttBaaataagWVtcHctgtgtYaaaaVtKtaSaaBatMttt
+gttatattattcaaBYctBWtggatBtgaggDagtgcacVataRBctaBaaaataatttt
+tNggtccgtVaaaaataaattBHaatBaagaHgttaagcctaatcaaatgaYtKaatYta
+aggtMgaRggtWgggNactaacgaRaaattSttWtaataaVtHgtacttNtaagHaSacg
+WggaYggNStcctgacgDcgHggtttHggtNtMtttDatNDgtgacgtatacgatKatat
+aaacaattSaaagcagatKtttSagcaaMttttgaKtMtagtcRacctKSttBttaatMt
+gcgttacaaagaVaataattcaSaaWcBVacYKtacaNBaaKRtRtcgWtWBaRKVtYWW
+WgattgBctaaatKaattaYtMtSBMBHDtBtaggDtcNctWYagtgSaaBaVtcttNgt
+cgttHtgtMtctatKtatVggKaSaagtttattttatgtactactHtHttSMactatHca
+agaattVataaaMKNtaMccgtgatDaHcaacttRataacaNgaatcSBtatgacBcctc
+gggtaatWaaWtacacaattctRVgattctatgtgtatHagatagggacVaattttDtNa
+WKagtatatHtagacgaggtatgtcagtgagHccccaatNataKMBaHtcWgctagtgHa
+atBatSataDatatcacccaagattttcSatKgatWtgaagtcBMataaHaaMaattatg
+cttWWtttcgVKYNBattggtacttcaaMaVNcctcHatcgctVcttKatgtctctBMgg
+acatcaggacSgaKttgagtctKVYaaagtaaSgaaaHaWactgRattaaBttVaHtgga
+ttagRWtaaDaaatgatttSMBWMaDactScgRYtgaVagNctgtSBataKacStHRatc
+tVgBKaggccaRctaacttcYKtcaDcttgaaacBBataatacYMgWgctgtacttttat
+gaSaaatYcccgattattRStccaaaBagaacaaaVtttgcttatagaaacacScccSaN
+taaaaBgtaaggcDgtSttRatMYSWatcgtaacgtStBagttaVaaaScccSggaMDBS
+gcaaKaggatatacgtatgcWactccgVctNttMaYtaaatKaaatgKStaaaHaKatat
+gBtcctatgtVaBggaatBcgcaatgagtatHcYagctDgtWaaccagtatWWtaRtKag
+atagtgKatatgaaaggcaWgtNKaaagataWaatHaaaaaKMaaatttBtatHtctNac
+tKtBVVagtatcacgtMgtgttaKtaatcgaaMHtYKNcMaatgcaSaaDBaaaaagaWa
+DtWMgaacatttDcatttaBaBtDttaaSMtcagcttttRWWaataattcNctactWaat
+NaBaattaagaaacttYRHaccatatKtaKcNVgttYagttBtaaaaVtctcgVctagct
+cgSVatatagVtMcaaHRctaHStttNtcattRaatgtaRtgttaatYtaagcattgaat
+ttaKtctaKKgaaggtcgMctttcWaagcgWaKcttcYttgtgaRaagMtDatgWgYaat
+aKaatSWScatKBtYgtaagagaVcacgctHStaacaSgBtgtaNRYaaWtWcKgaccDt
+gaWtgagMaYgVVgBaRacYtcKgatcagttgtaKcgttgagNaStctggaatVtactaS
+NtaaagtaatcaattaaVaaDattHDBaHKDHctVggcaaacccKMaatVtgttacBcct
+StgBgMtScgaaHcatgctMtStaVttttcDaNagtDVaatYcggaDaYtaactaNgtcc
+aattSacaaaaRgtagaaKgtcRSNtgatBacccttMtactatKgtaaRMagataMatgV
+tVKagaRagtcagMgMaatRHNttagaagaatgggaatcHtttttSgtNgYatgtgcYta
+atgDctMaaaMccVScgcRgKNaaagtaMtacaKaMNaBatagBttttcttttYatataN
+aWcagatttgMtgaaacaBYtHaaatgtaDactatttNatttKttSattgBatSRtgKHt
+tacgattgcggtaaaaacHHtaNgMcgHaVDtgtagaagatBaaagDttaacSatttaat
+ttaccagatataattggVgaRctRtcgccVatRNtDgcagBcVaHtBaatDttatgKRKa
+gataaRgcagtaKgagttatatcaMSagttccRcttaaatgatcttataaacaaatttcc
+cttaBaWtagtagttMaacMaKaaaagHatYKactttRatgtctcgattBcSagaDKttt
+HtBaccttNttVttVVtggttacgtaaBMRgatcgtctacaaNBtaVggttYaaggattc
+caNgRgtagBtgtaBacaagtataaatBaaatKRtaMtKHgatcgYggDSgKRaSttHSt
+catgtatatWacacRacHcatYtttaacYatatgtgttNtgcSagDHgataYttNattat
+cVattcaaYttggtaRHtWtcgaBacgtttaBaccaBaatgtcgcNagaNtKtaDtgDta
+tgDaBtcKgtBgatacNaccDDatttYtKggMtYNtaactgVacattaaHgMttatcgtH
+MNtataBtKSgccaVttaBcttattcBaagtgaWtaRtcctDVRatgaattgatatgaWg
+ccacDaatKaHtttacatNttaWNWgtacaggctacttBaYaaatatacaaaatttcgNH
+gMgttHctcKYcttgMtaacBaDVtaatttacagaRttttttagcKagtKactatMRtgt
+DtaattccRcaaKSttagttttBtctatagaKaVttttgcNagtKVccttagRgWaNaKW
+ttataDgcgaatgMKatgatRcYtctgVagaccgcgVgactagaWaaHNtcRNRKaatac
+tcYaNtSDKtcVVggNgDagtttaaKRgttaDcgtNNgtcaYttggtttYtatgtaaagg
+attttagatattKMcatgYaaatcaVactcagagtRYtgtaactatagtBaDtVaWatDa
+tctataaaSgggtactaYaKKWagaaaaataaattatagRcaaaVataVagatatgtagg
+cWagacRWattctgacgcDtaBcYattgtaDggMatgagcgagaggctaaatVtctcagR
+agDtSgKNcgtVcStacatttagNtgatSNgatcYVtHattHtBgMacRaattaHBacRc
+NaaccctVaaYaattcVccatacKcttSagtctgKMNagRaNcatNgcgHattStSKYRg
+gtcagtcaccattttagtMaccctggVattHaatVagaaMaattaVacatacacaaatta
+attacgtKtagaaaMgatWgWccatYtagacKatctKatMcggYcgcatgHRtcStVtaa
+tHgSaaaVagtgaatgtgYtattaYcRagatgatcataacacSgaYaactMKttatRcga
+ataaMSatacNgaMatttcggccacgaYYMcaKattRagDtRtatMVBtaattWtMHgNa
+WDgStaaSNggStcBcVYtaYagaHtacagttccMcgtYtYttcattgSWcttagttcgt
+HtgVRYgaMacttBtatcaactaaaaVtDgataaDgtatcatYDttaStgccBacctaaB
+agttgRtaSBtaaaagWgcacBggttagcMaYatttBgtaggtRBaSagttcacgtaDaY
+aaaacDSaKattctgtSatatgtatggVBcctctgtgaaHDKgttaRttttBMHgRMgHa
+gtagMgacgaagttaatattgRtHtHttatYaaagcagatgtgattagtggcactactVa
+ttagatctctgtttatcattYttgatHcHttagStgatgactctDaaatcagtgttgttt
+ttcYaaagtatatcYcaSaacaVttcgWtatKaaaHWtRgtttaKacttctgaaNaYacc
+tNtcStatttaaagttKgtgatcctBcaBtctttaaaKagttgDtWctDtgtgctataKa
+gtaNHatctagYgatcMgtggYaagactgacacttaRaaccHgttcaYtagWtggtgBcS
+tacaMcMHataaaNagatactccaggagttaatcatRttttgaKNgSgcaggtgttRaYc
+aaataBtaDtatHgBtatacKaataKtaggaaatatgcataaHgaKttttatMaaaNgMa
+tYattgaatNtatVaggtKctttHattcatttatYtattagtataYtttagYcattagaa
+ataHtaaccttactcatYttHMRagttctDagNSVgcgVaNNattctVcaaVagaattta
+agaggttttacRagtagtaaaBaBaaMtaScKgVaRcNtctgtataagtatVgtDgHaYt
+tcHYttaagatRgtgaattctYaaaattRtcWtacDDaRatcaKtaSacaagctaNttRY
+agMSDKtWgWaYNgaaaatatNtaatatHMtMWRaRacaaaatgctgctacNKaKtagtt
+gVatDaVccatSDtgaSggcgWatccBgaaVtgtaWttagatVaBWtacgWtaYattaaa
+tMctDgDaaKatttgaaatgctWctttaHtggHaBBSRVBWtgattgagatccNcaaaHt
+>THREE Homo sapiens frequency
+gcactagtattgtcgggatcccattaacaggctcaaccacgagctcacgcgaggacatgt
+agtccgtatctttaacgaagcgacagcgacagaactcccatggataaccaattataaggc
+ccgtaatcctctagacatcgtttaccaataaatccgctttctccgtaatcatgttgaata
+ccccagagtagtccagatgataaccgatgaaacacaagtctttctcaatgcacttacggt
+gaacttattaccgccaacgtagctcatcaaggttgcgacatctagttgtgtgtttgcgac
+gagcccagcgaacttcatcaactttcgtatattcaacgccttgtaattttactttaagac
+gcctggtgatgtagattcttagataatcagtttgttatcggctgtactttaccataattt
+cacaggtttcaggtcaagaagattatagctgtatatacagttccatgctcggtgcacaga
+aacgtgatcggataataatcaatcgcttatgtcgtctttaggcgtatccaatacatgccc
+cgataccgcagtgtatttcgacatgtaggtataccgtcgcatttgagctcgagtcaggac
+gtcagctagattagattccttaatagaatataccgacctctagtccgaactaaactatag
+ataacgccaacttcaggttaattgtctagtcgtctgtttgcagatgggattcttagatga
+gtgagtatcggccatattggttcgagcactttagtttttgatgcataggatatgcaatgt
+atagctgaaagtactttatctgtttcaaactcacattgattaaaccggtaaacctttaaa
+gactacaagaaaatattcagtgagggcaattttgtcaatcacaatcttccagctagagat
+acttcacaatttgtcttgaggctacgcaacattagacggattttcgcgttttattgaaat
+aatcgaggggcccaagagtatccatagttcattttgtaagatttctttacaggcttatta
+cagcttcttcagactcctacatgcttacgagttatatgctagcatgtgaacaatagatta
+atatacaggaaaacgtacattgagagagatgaccctacacagcgcaaccgttgagtactt
+tcattaaagggtaacgctctcgagacagcatccttaagatggccttattgtcaaatcatt
+tgcagaagtacgcaagatccctaaccaacgtagaagaatccctacaaacacatgagacgc
+ggtgaaaatagacagggtgttagtattcaatcttcggagtatcaatttcgccaatcttgg
+tgagaaagcataccctttcttcagagaaagaagatcaatcataacactatctttaacgag
+gtacgcacgcgcatcattacctgcctccatggatctttaggatagcggaaagtattggca
+gcgtattgtgatttcgttcctactttatcaatttcacattcatatacatgtcttttatca
+aaatcgccaataagataggatgagctatattagatgctagtagagttcgcgccaacatca
+tcgataggaatactcaggacagcgtgataggacttttcaatccctaatactctctataat
+tataactctctcttaagtttggaggcagtaacgcgctctatataatcagtttgctgcacc
+attcttcagcctctgatacatacaaataaattccacagcagtaagagggtttaattgaga
+catcttgggaacttaggattttactctaacatcaccgaaacgattattggataccgtacc
+taaacgaactttctcaaggcagtaatataggacatccgcaataacacaaatgctgcctcc
+ccaggagttatgtcttcctggaggctatatcttacacccactcactataggcaaactaaa
+gtttaaatgttgattgtctaaaaaaaagatagataagagttggccggcgtagcacatgcg
+aaagtgaatcgtaagctataattctctggacttgaagttctgtcctgttcctctgcaaga
+aacaaacttcctttaaagctatttacgacgcacatctcagcaagttataaacatgttgga
+agtttctagtcggaattcccaaagaacggatctatctaatgcattcctacatttttcctg
+tctgccgatggtgccatcctattcaaagaatttcttaaaagtagattaaatgggactttt
+aacaatgagtaaccttacgcctctaagggttcctcgagtgccatacaccagtcaggtccg
+agccacatacacggagaacattctaacatagcattctcaactcgatcatttgcaggttac
+ttctttcctatcctagtgctaaaaatcatacttgcaatcccatagcacggattaagaacc
+taagaaacaattcagtaaaacatgttcgaattcttggtatgggaacatcattgcagctat
+ggtctaacgcattaatgtttgggtacatcttccatcatataaacaggaagagtctgacga
+cagggagtgcttgcgatcatgtctatcattgtgaaatcaaattgtagctcacatgtcgtc
+tatgagagcgtgtatccgataagatttagaaaaatagaagtcgtataagatctcactgaa
+cttttgaatgaatgtgaagcatatatgatctgctttaataaaactttatccataggatac
+gtttccaaatcaattcaataattattagtcaaaatagataaggatgaacaacctgaaggc
+cgatcggacgtagaaagtggtcccatcactttgagttgatattgttgaaccacacgttat
+tatggttttcaaacagtctcaggatattgtatatacagataatccgataccagttgtctg
+acgcccctcttacgtaccccaccctttgtgacgtttaaagcagttgttcagtattttaaa
+ctaggcggcaactaatttggaaagaagcacagtggatatgtctaaattcttgttattcag
+gcctgaatttaatacaccgcatagttaacttcgcggtagagttgttcatcatgcctcctc
+taagctaccacttctatgatacaccaatagttgttctacggaatctgataattggccaag
+tcataaacttccgctgcgttcaacccccttgctcgaatatccaactcgaaaagacagcct
+tttggtgtccggaacaaatcagttacttcttttctgatgttaattctctgtggtcagata
+cagaccaaaaactccgcggatttaccatcctccaagaacaaatttgcatcaacatagcat
+tttggctacatattctaagtctcaatagtttaggttttcaactacattatcccaacatta
+ggattggaggaataatagctgggtaagtccccttgcgtctacaatcgactattttttatg
+aatatgcttctgccgcacctatggttattaaaaaagtcatgactttgaagaaccctgaaa
+agatagatgaatcaggtgtaatggcagcagccaaagagcatataattagcaacactctaa
+gaacattatagatatgatgatagcgatcgtcatgatgttatccggtcacaatagtagctt
+catcagctaattcgttttgccagtggtgacttgcgctggaagaatcgttatacggtccct
+tccctcttgatacggtgggggcttattcaaccgcgtggattgggttgtcatacttgcatt
+aaacgatgtaaaccatctagtagtcaactatactaaatcacaaaatagtgatcaatacat
+acccgcttcatggttttaaccatttaattgattaaagatattccgctaagaaccattatc
+tacctaaactgatcgccgtatcctagtagtttgaaatttgatgtaccgtaatgatcaacg
+aagtaaaacgttatattgtatgtagaataataggtcttggagctaaatgatgtgattggt
+agtgaagacttacccttacaactttaccggtttctcggaagaatatactagagaatcaat
+gcatgggctacataagcactttagtctaatgagataaaaaatacacgagtcttccatcat
+gaattttttgtcgaaaaactcgaacctggtaatttaaaccatatatctttatgtcgtcaa
+taactctcatatgttttatataacttcccaatcacgacttgtaactgcttgttcgactga
+gctgtttgagctatgaggccgggatccggttgagctacatctatttgctacaagaaaaat
+gaaagcacatttgttgggagttctggctacactcatagagaaataagtggcccgagtggg
+tgcggcctgcctccatattcaagtgtatcttaaaccaagtggttccaacgctcgcgctaa
+agaattaaagcctttatttcctccacggagtagcccgtaatccggttcgaaagagaccat
+tgaagttaattttcatatccagtgaagtttaggcacaagcatgtgttctgccacatgcct
+caaagcgctcttcaaccaagatatgattcatcctaacttcgatgaatgcgtctgtaacat
+aaatatagaaggaatgattcggcgagttaattttcgccttctccaacatggcatccctac
+gttcgttataaggaccatacatgtaggttttaaaggtttgcggttaatcgatatttacat
+catagaaattctatagtcaaatttacaagactctagatactcactcgttgcagccggcta
+ggaagcgctttgtaccttacttcccttttcgttgcgtaatatgaatttcatatagtaagt
+tcaaggcactcatacctccgtgaagagggtagatagactattaaagttgtttaatagtac
+gtattgatggaaatgacccgtaggagatttaccactcaatccacaagattcgctgctgtg
+cattatcaaaacagtgcatgtcgaaacatgggttgggtccttcaaacacgaatccaggta
+gagatacctttgcaatttttcgatgaaggcgaccgagataaatgagctataacactgtat
+gtcttttgattgctataaaacacagaaacggatattaatttaggccgtaaccaacatctg
+ttatttgacatagaacagatggtcctttacagcgtattccggccttaatattgaggtcca
+gtgtattgtcctcctttaaagaagttgattgtaactgacttaaataagacatgtcaccca
+ttcactgggttgcaactgctggccctttttgtccatcgcacgctaatgtgataacagtac
+cgccctcacacctgcgtttaaaagacataaatgtcgctatgaaggttattcattaatttt
+agctgttttcttagaaaaggtaaatttaaaattgaaaaggctagaaaactaaagttacga
+caaatgtgtttgtcaagtaggcgggcatcattgagattgtaagaaataaagccataacca
+gccccggaatagaaaatgttaaggaaaggcgatcttctttgaattcttattgtcaagtgc
+agtcatacgttcttatcagaggacattgcaataaaatctaacaccctcccttgtgtggtt
+gggccatttgtacttcgaagcgtccaccatgtgcagaggataacggaatgtggttccgtc
+ccataaacgatcattctcgcccacttagtggcgcggtaaatcgctctcatagaggtaact
+ggcctgtaatgtccaatgttaggctaccttctccaactttagtacaacgaataatgtccg
+attaacaaggagtcaatttgtcatgaccagttcattcaggtacttgtatctatacggacg
+cgttccagagtagtatttgaaattttgaggttctactgataagtttagctatcgctgtat
+gtctgaataagaatttaatgtttatcttcgataaataacaattaacaactcctaggtgat
+acactgtgaagtctgctgttccccaaattacatatgctattttgttcacataccatgaag
+ttaagctaagtgctctataatggcataaacggttatcaaactagctcgaatttcttttat
+tacgccggaagcggattaactgctgtagatcaaacacgttaggatagtgtcgttttcata
+tatatctaaattcggtctaacatgcattacccatgcttgataacgtagcacttcgcagtc
+taattatgtaatgtccgtttaaccaaactttaaaaaagtttatctatcaccagtgatgcc
+tcatcgtgactacccggatctttagcctttagggtctaaacagaactaatattactacgt
+gtcatactccggagcttaaccaggtgaaacttatttgttaaccaaatttagtgacagggt
+agaaatacgtatcaaattaacccagcaatacaataagcatgaaaataattgtaatcgggt
+ttgggccggaatcccgcttggcgaaaacttaatgacatagtgtgatgcattttgcactgg
+attgagccacaaactcaactagcattatgctcaatatttggccagtgttctacggtttga
+aatttataaaggccgcgcaaaagtcttgtagttacaaacgcataaatctcgaacgtaata
+ggtttaattagaacatccgtaggatttctgtttatagtagatttatactaaatgttctga
+ttagattctgacggccttacccatacaattaataaagacgaatatattagttatagttta
+ctatccaaataaattaagcgaatcgaaataaactgtcacgatactgggcagttatcaact
+tatcacttatacagttcggacactctatattggtctgtgagtactctatcaaactaactc
+ataagttaactgcgcttccattaaatttcaatacgttcttgtgctgtgtacaaacctata
+atcgaataaatgacacatatggagatgcataataaaaaaaacggctccatatttctcgtt
+aatcgggcattcttaaggaggagcatctcaccaaaaataacgttcctgataagtcttaac
+tattagaccgtcttcgggaatgaacgaaacctcaagctagcatggtatagttcttgatag
+cgcgtaaattctgataatactgggcggacagctggaaattagttgccagtgcacctacgc
+aaatagtttacataaatcaacgggctccgaacgtaaatacaaagggttagttacatcgca
+acaagatgaaaagcatgtatgtctaccgtcatccgtccctaacaaacataaaggtggtga
+agaatctcgtaggtcaactataactccatccttgaagcaactactccgcgtccgtgtgcg
+tagttcgcaacgagaacactactgaaaaaagctaaacaactctcggtacaaatgcggctt
+gtgtcgataaagttggtggtagtgcacggaataacataacaaggaatattatttattcaa
+attttttgtgactgttatttgttttctgcctagaatgtaaggatgtgttttttgtgacct
+gatagttacgcttatttcaggtccacggtgcgtgagagtgtgtcctataacggcagggga
+gcgaagtagtgtcctttagactattcaaggtagaattttgataacgctctataaaaggta
+gaaaatcatgattgagcaataagaccccaacttatcaaaaaaggagttctcgacagcgcg
+tgtacagtccctataacggctgtatttcctgtgtcacaacaccctcccatcgcactcaaa
+atgtagatttatgatcagacgctaacttgttcttagagaaaaatacacgggatactctgt
+gcaacgatttcattaataaggtgcagcttgggacttttttggccgtaggctttattaaca
+ttcacagtaggtagcgagacttcctatgaaccaatcatgccacgcgttttaacgtttcaa
+atataagctaggaagcgtttgccaggacttctataatgcaccgttttttttagtacttcc
+ttactagccttagtttatgttagagtctttccaattacaaaggattgaatagccaaaatt
+tctacaattctcagcgaacgccagcttaatctaaacacgagcttcaaatattctacatat
+cggcaggagtcaatatataaatatgaaaatcgtaccatcctcgtacttttagaccaaacg
+tcttcggataattaaatcctttttcaattaccacagtacgtgcattagaactactgctat
+gaaagtaaaccttgaaatatagtcctcaagagcgtatccaagtacattgcacgtgtatac
+agtcgtataaacgagttgatgttctgacgctagagcttaccattcgttaaacagataact
+aaaatttaatggctgagtgacttagtgttttcgacaaacgtcgcggatgtagactattgt
+ttataagcaatttttaaaaacatatgttcaaaacggtatgggatatgtcgaattccacag
+gggtttatgtaccatagaagtatgtataaggtactaaaggtttaaatctgtgatattcgg
+ttcggtgaaaatcagactagtcacacttagtgtctgtaaattagattgggtgaaggtaag
+cgatcccgaactctacaaggcatgggatgagattctaccgactccggataacactttacg
+atcgcgcataactctagctcttagataagtttaacttgtcgatctcataaacagttcaaa
+atctgcgatttattgtatcaaatccatcctctatcttctataatcatctgaaccgcgata
+cggcactatgagccaagtgaagattgaatccaagaaagctataattggtttattttagtc
+catttaaattaagtccggtataagtgctctgtacaatatgcagtctcatgggcatatacg
+ttaactaccttttgatacttcgaattggtaaaatatcgactatcgatttgcagtaaaagg
+tgtagagtccaattactctttcctgttacatacgatctcttagtttggacaactagccca
+tgatggcgctcctctagcgcatgaacctactttataattacatctttatcgatgaatttt
+tttagactgcggaggccttgagttttaacagggctgctaaatttcttaagcgattagacg
+gtagcgtcgtacgctacttgcttggaacaggcaccgaaaatattgatctactattgcgtc
+aactctattctgctaatagcgatggcaaatcacagaagccctcttagtgacaatagttgt
+caactatatctaagtcgacctttactgtatcaacgatcacggagagaattaccgaatacg
+aaacctcaggactaaaaaacggaaaggatttgtcgacggtaaatataatacttgttaagg
+gtagcgacacaggtatactttgggtgtaaacgtggtgcttcccggaacgattttcagacc
+agaaaattgttccggtaaccaggaaatctcgtctgcgttaattcgtgttagtaaacttga
+tcttcagactccttcttttcgttgcagcgagacttaaattatatctgcgaaatagtgccc
+cgtgcatacttcagatggtaggagataccatttggcccattgtgactttacgcgattaat
+taaccgacatacatctgttcctgagctatgatcgtctgaataaattacggtctcctcttg
+atacctaatggtttctggagacgtttctcatgttcaaatggatagcaggagatcgcttca
+tcaagtttagctacgcagagcatcaaaatatgtatgggaaagtcgatttccaaaccagaa
+gggataaagagaaataacggacttctccgtagattagcctgatattttgatgggaatcat
+ggcggcacatacgtaagagttgcgtgaacgaatattttggacggcgggagacacatatcg
+gccattcgttaaggtctctatattggacatcacaagcttagcagtatgagctactaacac
+tcaagacattattgattttttcaagatatgtttcattcctctaccgctattcccatacgt
+tcgattcgccgggtgagcgaaaccacgggactgaggttaagctaatcaataacaactcgt
+tgcgatagagacctatgtatactagagagaattccccaacatttttacaaaaacaaagca
+gactaaaatagatacagtccctccatacaattaggaccaacatgttattgccgatcctag
+cacacacaccacaaactcagaacttctgtcttacctatgaaagggtctgcacttctgatt
+gtacgtgtctaattagcattaatattaaaactaattaggataaactataggtacgagctt
+tactataagtcactaggtgttttccgatcgaaaaacgggaccttcaagccttggtaagta
+catttaggataaagaaaaaaaggaaggtacgtgactaatctgtctaaactgacaatagag
+tagtacctacatgcttcatgtcaagtcttaatacgcaagcgctctcgttatactgctcaa
+caaaactcataaagttggactccatcatttagaatcatagggaccaaaacatttatttgc
+tactgtcactttgtaggtgttctattctgaattcctcatattgatacatgaatcggaata
+cctgtggatcccttaggacgcacgtgctttctttacgtcagaatacatattgtcagaatc
+gagaagttccatgcaattaagaattcgcctctttgaaaactcatatccccacatataggg
+tccaccgttattcggaaacgatataataattattccagcgttgagcgtcccttaagagcg
+cattttcgcttggcctttcttctacgactctacaacgcaagtggctgtgtggagtttacc
+acagcgcagcaccccatagaactacctctgagagcgcgagatggtggcagtatgctctgc
+agctagcgtttagaacgcgcccgcgcattaaccagtcatattaaaatggactgtcttaat
+tgtcggcattaggagcaatattaactgatgagggtatcggtcgcagaagtaatgacggaa
+atacgcctctagtccgcagagatacgattacagactcagatcccctaacaagcaaaacga
+ttaaatcggaatcactccccctatgacatatttgaaatacacaagaaaccacgcaacatg
+tcccgcattctcaaccgcgctttataagatgttgagtctgagaattagatgacctaactg
+caagaatcatggcgagtttatctagtaggcaagtctgtaccctagggttcgaacgctgtg
+acgtcgtgatcggtctaaggacttagatgataaccaagaactggtttaccgagtactttc
+actattaggagtaattacatgcgttcaccgcggaatacgacgaaattttttcatatcttt
+atgagcgagatcgtgtcgtctttgcattgcaacagtcgctaccagtaattgctgatcaat
+tatagattcattatacagatgcttacttttctctattcaatactgtcatgagttgttttt
+aaataagcaccagaattatgtcgcctagtataatcttgcttccacttgaatcaatgcgat
+ggacagtattctactgattgcaaagtagtctatttcggcttagcagtacgcatgcctatt
+tttttgcaggcacagaataatatgcaactaggattctcggcatccaattaacaggctaaa
+acaccaccgaaagacaggtaatctacgaagttgatgtttactacagaaagcgaatgatat
+cacttggagaacattttagatgcccccttttaatctagactgagtgtaccaatatatcac
+cggtctaccgaatcagcttgaataaaccactctagtactcatgataaccgagcatacaca
+tgtatttctcaatgcactgaaggtgaactgtttacaccataccttgcgaatcaacgtggc
+gacttatacttctgtctttgagtacagcacaccctaatgaatctaagttagttgttgata
+cgaattgtaatttgactggatctcgcctcctcatctagattcttagagaagatgtttctt
+atagccggtactgtaactttattgatctggtttatggtaatcaacattttacctctattt
+aaacgtccttgcgccgtgcactcaatcctgatcggtttagattcaagcgattatcgagtc
+tggaggccgagaaaagaaatgcacagagtaagctctctattgcgacatctacgtagaaac
+tcgcatttcagatcgagtaagcaactctcattgtgttgattcagtaatacaagattacct
+acgcttctacgaaatatactatagatttagcctacgtcacctttagtgtcgagtcggagc
+tttgaagatcggatgcggtgtggactgtgtataggcaattttgctgcgagctcgtgactt
+ttggttgatgtcgatatcaatgggatacctcaaacgtctttatctctggataactcacat
+tgagtataccggtaaaaatttattctattcatctaaatagtcagtgagggctagggtcgc
+aatcacattaggccacatacacatacttaacatgttctattgacccgacccaactttagt
+agcattgtagccgtttatgcaaatatgccaggcgccaaacactagccagagggcattttg
+ttacatttatttaatcgattattacacagtcggaacacgcctacatgcgttcgacttatt
+tgcgacatggtcaacaattcagtaatttaatccaaaacctaaagtcagagacatgacact
+aaaatcacattaaggtcagttagtgaaggaatggctaaccagctagagaatgcatcatta
+acaggcacttattgtcaaatattttccagatctaagcaacatcacgttaaaaagtacaac
+aatcacttaaaacacatcagtccaggtgtaattagaaagccgcttagtaggcaagcgtag
+gagtataaatgtagacaatagtcgggacttagcagacactggatgcagtcatagaagatc
+ttgcataacacgttagggttagagctacgaacgcccatcattaactgcctaaagcgtgcg
+tgagcttagcgctaacttttccaacacgtttgtgatttcgttcataatgtatcaatttca
+cagtcatatacagggagtgtagaaaaatcgcaattaacatacgttgacctatttttgttc
+agagttcagttagagcctaatgattcgagagcaataatcaggacagcctcataggaagtg
+tcaatcacttagaagctatattattataaatcgctctttactgtcgtcgaaggaacgagc
+gagagagaatcagttgcctgcaactggcttaacaatatgatacataaaaatattttcatc
+accactaagacggtggaattcagacttattggcaacttaggatgggactattaaataacc
+cataagatgttgggataaagttacgaaacgaaagggatatagcctgttagataggaaatc
+cccaataaaacatagccggcctccacagcagtgatctattccgccacgcgatatctttat
+accacgcaatataccaataataaaggttaaatgtggttgcgatttaaaaaagatacatat
+cagttgcaccgcgtagcaaatccgtatgtgaagcgtaacctagaattatagcgtctgcaa
+gttctctaagcttcctctgcaagatacaatatgactttttagcttttttactaccaaatc
+tcagaatcttagaaacaggttggtacgtgctactcggaattcccaaagtaccctgctata
+tatgccattccttcattggtccgggctcaccatggggccatcatagtaatagaaggtagt
+aaaactagttgatttccgacttttaacaatcactatcctgacccagatatgggttccgac
+tggcccttactccagtaagggcagacacacagacaacgagaacttgataactttgaattc
+tcaaatcgatcattgcaacgtgacttatttactagcctactcctataattcatacgtcaa
+atacatttcaacggaggaagataataagtaaatattcactaaataatggtcgaaggagtc
+ctttgccaacataagtccacatatgcgctatagattttttcttggggttcatattcaata
+agataaacagcaagagtatcacgtcagcgagtcattgagatcttggctagcattgtgata
+gcatattctacctaaatggtagtctagcacagagtggataagatatcagttagatataga
+caagtactataacagatctcgcttcgttggattgtatggctagctttgatgatatgattt
+tataaaaattgatccagacctgacctggccaattatattcattttttatgagtaaaaata
+gataaccatgaaaatactcaagccccttaggacgtacaaagtggtaacataaatttcagg
+tgttattctgcaaccacacctgttttgggttttcaaaaaggctaagcagattggttttac
+agataatccctgaacactggtatctcccaacgatgtcgttcccaacccttgctgaccttt
+taagctctgctgaagttttgtaaactaggcggaaaatatgttcgatagatccactcgcct
+gaggtagaaattcgtcttagtaacgcctctttggattacacagaatagtgtactgacacg
+tacactgctgcagcagccatacgctaacattaaaattcgttgagtctacatttgttgtta
+ttcggattatgttattgggaatagtatttttattcccctgcgtgaaaccacatggataga
+ttagcctactcctaaagactcccttttggtctacggttcaattctcttactgagtttatg
+ttcgtaattatatcggcgcagtgaatctcctaattatcaccggagttaccagacgccatg
+aacttatggccagaaacattgcatgtggcctacataggattagtatcaagagtttacgtt
+tgcaacgacatttgaccaacttgaccattcctgcttgtagaccgcgggaactcccctgca
+cgcgactatagaagttggtggtggatgtggcttatgccgcaaatatggttttgaaaaaag
+taatctattgcttgatacctgaattgagacatgtataagggctattgccagatgaaaaac
+tgcatataaggtcaaacaatataagaacattatacataggatcttagcgttcctcaggat
+ggtatacgctataaagtctagcttcagcagctaaggagttttgccagtgcggacttccgc
+tggaagattaggtttaaccgccctgacatcttcataaggtcgggcctgattcaaacccct
+ggagtgccgtctcatacttgaattaatcgatggaaaacttcttctagtctaatattatta
+ttaacaaatgacggttcaataaataacaccgtaagggtgggaaactgttaagtgatgaat
+cattttaacctatcatccattagctacagataatgataccccgatccgactagggggtaa
+gtggttgttccgttaggataaaccatgtaaaacgttagagggtttgtagattaattggta
+ttccagataaatgaggtcagggcgagtgatcaattacactgaaaaattgtcagcttgcgc
+ggtagttgttaagacagtataaatgaaggggattcagaagcaagtttctcgattgactga
+atttataaaccagtcgtcaatcatgatttttgtgtcgattaaagcctaaatggtaattta
+aaccattgatatttatcgagtctataaatatctttggttgtatattacttcacaatcacc
+aattctaaatgattcttccactgtgcgggtggagatatcaggacgggttaaggttgacct
+acatcgttttgatacaacaaaaatcaaagcacatggctggggacttctcgatactatctt
+tgagatagtacgggcaagagtgggtgacgcctccctacattttcaagtctatcggataac
+ttctcggtaaaacgctcgcgatatagttttaaagcattgatttaatccacgcaggagcaa
+gttttaccggtcgaatgagaaaattcaacgtaagtgtcatatccagtcatggttagccaa
+aagcatgggttatccaaaaggaataaaacagctcttcaacaaagagatgaggcttcataa
+cttcgatgaatgcgtatggttctgatatatagatcgatgcatgaggacactttattttag
+ccggcgaattaatggaatccatacgttacttatttggacatgacttctaggtgtttttgc
+tgtcccgtttagcgatatttacagattagtatttcgtttctcatagttaattgtatctag
+atactaactcgttgaagacgcataccttgccatttgtacaggacttaactgttccgtgcg
+taatttgaatttcttataggttcttcaaggcacgaatacctcactcatgaccgttcatac
+tctagttaaggtcgggaatactacgtatgcagggaattgtaacctaggagatttacaact
+ctttaaacaagagtcgctgaggtccaggatcaaaacactgaatctcctaacttcgggtgc
+ctccgtaaatcacctagaaacctactcatacatttgcaattttgagatgtaggcgaaaga
+gagaaatctgctttttaacggtatctcttgggattccttttaaaaacacataacgatagt
+aatgtaccaagtaaccaaaagctgggatgtgtctgtgtactgatccgccgtgtcagagta
+gtccgccatgaatattgacgtcaaggctagtgtcatcaggtattgatgttcattgtaaat
+gaaggaatgaactaatgtcaccaagtaaagggggtgaaaatgctccccagggttctacag
+acatagagatggtcagaacacgacccccctctcaacgcagtgtatttgaaatatatggac
+atatctaccttattctgtaattttagatgtgttctgtgtataccgatattgataagtcaa
+taggcttgattacgtatcttaagacaaatctgtttcgcaagtaggaccgcatctttcaga
+ttgtttctttttatgccataacctgcccaggaattcaaaaggttatcgatacccgatatg
+ctgtgaattattattctaatggccactcattcctgcttatatctggaattggcatgaata
+tcttacaacctaaagtctggcgttgcgccagttctacttcgtaccggacaccatctccag
+tcgttaaccgaaggtgggtacgtcacataaaagttcattagaccacactttgtgccgacg
+tatatagatatattacacgtatagggaatgttttctcctaggtgacccgaccttctacta
+aggttgtacatcgtataatggcccattaactacgaggaaagtggtattgacctggtaatg
+cacgttcttcgatatataccgacgaggtaaagtctactattgcaaagtttgacgttatac
+tgataagtttagatttccctggatcgcgcatgaacaatgtatgcgttatctgccatatat
+aacatgttacaaatccttggggatactatcgctactatcatcggaccaaaattaaatagg
+ctagtgtcttatcagaacatcatgtttaccgaactgatctattttccaatttaagctgat
+attacgtccgcgtatttattttagttccccggatgacgattatctgagctacatcataca
+agttagcatactcgccggtgcattgatttcttatttcgctatatcttcaagttcacaggc
+ttcatatagttccaattagcagtataattaggttttgtaactttaaccatactttataaa
+aggttatattgcacaactgatcaagcatccgctataacccgagctttaccagttagcggc
+taataacaaataagatgacttcgtgtcatacgaccgtcatgatcatgctctaacttaggt
+gggaaccaaatttaggcaatgggtagtaataagtataaaatgataccacatatactataa
+caatgaaattatttgtaatccggtttgccaacgtatcccccttcgcgataaattaatgac
+atagggtcatccatgtgccaatcgtgtgtgccaaaatctcaaattcaattatcatcaata
+ttggccaagtgttataagcgttgaaagtgatataggccgccaaaaagtagtctacttaaa
+aaccaatatttatcgttcgttattgctggtagtacaacatcacgagcatttctcttttga
+gttgatttatactatatctgctgatgtgattatgtcccacttacccagaatattaagaaa
+gtcctagattgtaggtatacttgactataaatataatttaagactatacaaataatctgg
+ctacattatgccatcgtagaaactgataacgtagtaacgtcggacactagattttggtcg
+gggagtaatctagcatactaacgaatttgttaaatccgctgaaagtatatgtcattacct
+gcttggcctgtcttcaatacgtttagactattaaggactcatttcgagatccagtattaa
+ttatacgcatccatatttatactgaagacggattgagttaggacgacaagctaaacaaat
+attaagttaaggattagtattatattgtagaaactcgtcgggttggaacgattcatcatc
+atagaatgcgttacttattcagagagacttaattcggttatgactggcagctcacctgga
+aagtaggtgaaaggcaacagaagaatattgttgactgaattctacgggctacgaacgtaa
+ttacaaagcggttcgtaaagagcataaagatcaatacaatggatctctacagtattacgt
+aaataacatacataaacctggtgttgattcgactagctcatagattaatcattaattgaa
+gctacgaagacgcggaagtctgcggagtgagcaaacagtaatcgactgataaatgcttat
+aatatcgcgcttaaatgccgcatggtgtacattaacgtgggggtagtcaaaggaatatat
+ttactaggaatattagttatgcaaatgttgtgtcaatgtgatgtgttttatccagacatt
+ggatgcatggctgtgggggcacaggatacttaccattagttcacctacaagcggcgtgag
+agggtctcagttttagccagcgcagagaagtacgggcctttagacgattaatgctagaat
+tgtcataaacctcgtgaaaagctagttaataatcatggtgctagaagaacacaacttttc
+tataaaccagttctcgactgacagtcgtaactcactatatcgccgctttgtactgtcgca
+aaaaaacctcacatagaaagaaaaatctactgggtgcatcagtagagatcgtgttctgag
+agataaatacaccggatacgatctgcatcgagttcatgtattaggtcaagcttgggactg
+ttgtgccagtagcattttttaacagtcaaagtagggtgagacacgtcatatcataatata
+tgccatcgaggtttaaagtttatatgataagctagcatgcgttgcaatcgtattcttgaa
+tgctccgtggtttgtactaattcctttatagactgagtgtatcgtacactcggtacaatt
+acaaaggatggaagagcaaataggtcttcaattataacagtaccccaccttaatctaaaa
+accagcttcaattagtattaatttcgccaggagtatatatataaatatctaaagactaaa
+agactcgtacttttacaacttacgtcgtagcataattaaatcatgggtaaatgtcatcag
+taagtgcattagaaatactcctttgtaaggatacagtgaatgtgtctcagcaagtcagta
+gaaatggaaattcatactcgattaaggcctataaaactgttgttggtatctacagagtga
+ttaaaattagtgaatcagattacgaaaatgttttcccgctcgcacttacgcgtttagaca
+aaagtacaggtggtacaattggctgtagtagaattttggtataaaataggtgataaaccg
+gatgggtgtgggcgaattcaaaagcggtttttgttccatagaactatgtagttggttata
+aaggttgtaatctcggagattaggttagggcttaatcagaatagtaacaatttctctatg
+taaagtacagtgggtgatcgtatgagttcacgaactcttaatgccatgcctggacaggat
+aaacaatacgcatataacttgacgatcgagcttatatcgacctatttgagaagtttaacg
+ggtcgatataatatacaggtcttaatagccgattttttctagaaaagcaatcctatatct
+tagttaatcagatcaaccccgtgaacgatatatcagcaaactgaacattgtatacaacat
+tcctttttgtccgggtggggactccatttaaagtatctcacctagaactcagcggtaata
+gatgcagtctcttgcccagttacggtaactaaatgttgatacttagaattgctaaatttt
+agtctagacatttccaggtaaaccggtagacgacaatttctctgtcatctgtcataagat
+cgcttagtgtgctcaaattgcaattgagggccctactatagacaatcatcagacttttta
+attaaatagttttccatgaatgtgttgtcaaggcggaccccttcacttttatcacggctc
+ataaatgtcgtatgactgtagtcggtagcggccttcgagtcttcaggggaaatggaaaag
+aaattaggcttctaagatggactataatcgattaggctaattccgttcgcaaatcacaga
+agcaatcttactcaaaattgttggaatcgatagcgaacgcgaccgtgaatgtttaaaagt
+gctcgcacagaattacccaatacctatcatcacgacttaaatacccaaagcagttgtagt
+cgcgtaatagattaagtctgaagcctagagacaaagggatactgggcggggaaacctgct
+ccttcacggtaacatggtaacaacagaatttggttaaggttaaaacgaaatatactcgga
+gtgaattactgttaggtttcgtcatcggatcaataagtagtttccgtgaagacactctta
+tattagatctccgaaattctgacccgtgcattaggcacttggtaggagattccatttgga
+acttgctcaatgtaagccagtaatgttccgaaataattcgctgcaggagcgaggagccgc
+tgaataaaggaccctcgcatcttgttaccttatggttgagggtcaccgttctctgcgtca
+attccagagctggagatacattcatcaacgttacctacgcacagaataaaaagatcgagc
+gctaactcgttttcctaaacacaacggatttagacaaattaccgaatgcgccggagagta
+gcatcttagtgtcatgcctatcatggcggctcagtacgaagagttcaggcatcgaatatt
+gtggtagcccgcactcaaagttccgccattaggtaagctatatattgtggtcagaacttg
+aggacaactatgagctactaaaaataaacaattttgtcatttgttctagatatgtggcat
+tcatcgaacgcttgtaccagaagttacattcgcagcgtgagcgaataaacccgaatgagc
+gtaacattatcaataacatatagttcagatagagaacgaggtattcgacagagaattacc
+caacattggttattaatctatgcagaataatttagataatgtcactacataatattagga
+ccaaaaggtgattccccagaagacaaaacaataaacaatctcacatattcgctagtacct
+atgtatgggtatgatcttctgattggacggggataatttccaggtatattaaaacttatt
+accataatctagacctaagagaggttatataagtaaagagctgtgttccgatagaaaaac
+ccgaccttaaagacttgcgaagtaaattttgctttaacaaaaaaacctacgtaagggaat
+attctgtataaactgaaaagtcaggtgtaactacatgagtcatgtcttcgattaattaca
+atgcgatctcgttattctgatcaactaatatcataaactgccactacatcttgtacaatc
+attcgcaacaatacttttatgtgctaaggtcacgtgcttcctctgctatgctgatttaat
+cagattcataaaggaatacgaataactctggatccattaccacgcaagggatttatttac
+ggctgattactttttggctgttgacagaactgccatgaaagtaagatgtcgcatcttgca
+taaataatagcacctaatatagccgacaaagtgattccgataacagattttaagttgtcc
+agccttgagactccatgaagaccgcttgggagcttccccgtgattagaagaatctaaatc
+ccaagtggatggggggagtttaaatctcagcaccaacaaatagtacttcctctcagagcg
+cgtcatggtcgaaggagcctatcctgatagaggtttgaaagcgcacgcgcatttaactgt
+catattaaattggaatctcgtaagtgtcggcagtacgacaaattttaactgatgtcggta
+tacggagaagaaggaagcacgcattgaagcagctacgcagaactgagaagatgacactct
+aagatacaattaatacaaaaacgttttaagcccaatctatcaacagatgtaagatgtcta
+atacacaagaataaaaccttcatgtcccgatgtataataacagctttatttctgctggtc
+gaggtgaagtagtggaaattactccatcttgctgcgcgtctttatagtgttggctactct
+gtaaccgacgcgtccatccctctctcctagtgatccgtatatccaattagaggataacca
+acatctgcgttaccgacgaatttaaatttttcgactatttaattccgttcaaacccgtat
+tcgtagtaagtgtttcatagatttatgaccgacatcgtgtacgagttgcagtgcatatgt
+agataccactaattgctgatctaggatacatgctttataaacatgcttacttggctattt
+tatttactgtcatgtgggggtttttattttcaacaagtatgtgctaccattggataatct
+ggcttcaaattgaagatatgcgttccaaacttgtctactgtttgctaagtaggagttgtc
+ccattagaactacgcagcacgtggtttgtgatcgaaaagaataattggcaaatacgaggc
+tagccttcaaatttaatgcagattactcctcagaaacacacgtaagcgacgaacgtgatg
+tttactacacaatgcgtatcatagaaattcgtgataatttttgttccaacctttgaatct
+agactgagtggaaaaagatttcaccgggataccgtttatgctggttttaaaaactcgtcg
+aatcatcttataactgcattcaaatggatttctcaatcatctgtacgtcaactgttttaa
+caataacgtcagaataaaccggcacaatgagacggcggtctttcactacaccacaccctt
+aggattataagtgacgtgtggattcgaattctaaggtgacgggatctacaagcctcagct
+acattaggtctgaagatctttcgtatagccgcgtatgttactgtttggatatgggttatg
+ctaatcaacagttgacagcgagtgaaacggccttgcgacctgaaatctttacggttacct
+tttgattcaagacaggatcgacgatggaccacgtgaaatgaattcaaaactgtaacatcg
+cttgtgcctcagcgaccgagtaacgacaagttcacatcctctatgcaactatcattgtgg
+tcattaaggtattcaagattaactaagagtcgaccatatattctagagttttacaattag
+gaaccgttagtctagactaggagcgtgcaacatcgcaggaggtgtggactgtcttgaccc
+aagttgcctgacacatagtgtcttttgcttcatgtccttagcaatgcgatacctcaatcg
+tagttttatcgggataaataacatggtgtttaaccctattaatggtttctattaatctaa
+attgtaaggcagcccttgggtcgaaagcacattaggccacatacacagtatgaaattgtt
+cgagtgtccagaccataattgactaccatggtacacggtgttgctattatgactcccgca
+aaactcttgacagagggaattttggtacattgatgtaatcgatgatttaacagtaggaac
+tagacgtcatccgttagactgagttccgacatgctcaaattgtcaggatttttatccaat
+aactaatggctctcacatgtaaataaaatcacattaacgtcacttagtgatggattcgct
+aaacagatagactatcattcatgaactggcactgtttcgattatatttgcaacatcgaac
+atacttaaagttaaatacgacatcattcaattaaaaaaattcagtacacctctaatgagt
+atcccgctttggaggaaagagtagcactttaaatggacaatttaggccggactttcctgt
+aaatggatgaagtcattgtacagcttgaataaatcgttagggttagtccttacatccacc
+atatgttaatgaataaagcctgagggaccttagagctaacttgtccaacacgttgctcat
+ttacttaataaggttgaaatgtatcagtaagtgacagcgagtgtagattttgaccattta
+actgaccttcacagttttgtcttcagacgtcacttacaccataatgatgacagagcttgt
+agatgcacacactcattcctagtgtaaatcaagtagtagctagattattataaagagata
+ttttctggcgtcgaacgtaacacagagagagtataaggggcatgataatggcttatcaat
+atgtgtaagaaaaagtttttaatatcatctaactcggtggaatgcacacttatggccaac
+tgaccttgggacgagttaagataccataagaggttgcctgtaagttaagataacaaaggg
+atattccatctttgtgtgctaagaacctatttatatttgcagccataaaaacctctgtgc
+tatgcagccaccagagttatttatacaaagaaagagaccatttagatacgttaattctgc
+ttgcgatttattaaacagacatttcacgtccaaccactacaaaagccctatcgcaagacg
+atcattgtattatagcctatgcaacgtagctaagcggccgaggaatcataaaatatgaat
+tgttacattgtttactacatatgatcacaatctttgtaaaaggttcgttcgtgatactac
+catgtacctaactaacctgagatatatgcaatgacttatggggtcagcgcgcaacatccg
+caaagcatagtaatacaaggtaggaaaacttctggatttcccaaggttataatgctctat
+actgaccaagagatccgttacgactcgcaatgaatactctaagggcactcacaaagaaaa
+ccactaattgataaatttcaatgataatatcctgaattgcatcgtgtatgagttacgaga
+agtcgcatttaatgaattagtcatagaaatgtcatagcaggaacataattactatatttt
+aacgatttaatcgtagttggagtcctttcccaaattatgtcatcagttccgatttagatg
+ttttcgggcccttcttagtaaagaagttaatatccaagactagctcctcacccacgcatg
+cacatattcgcgagaagtctgatagaatattcgacagaaatgcgactctagctcacactc
+gttaactgatcaggtacttatagacaagtacgttatcagatatcgcttcggggcattgtt
+gcgctacctttgtgcatagcagttttgaaaaattgttcaagacctgaacgggaaaatgat
+attatttttttaggaggaataatacagtaccatgtaaatactcaaccaccttacgtactt
+cttacgccgaacatatatggcacgtgttattcggctaacaaaactgttgtgccttttcta
+taaggataagcagattcgttttaaacatatgacctgtaaactgggatctacaaaagaggt
+acttaaaataaattgcgcaacggtttagatctgcggatctttggttaaagagcaccatta
+gatgtgccatacttcctatcgcctgagcgagaatttagtctgaggaaccactcttgggat
+ttaaaacaattcggttaggacacctactcggcggatgaagcaatacgataacattaaaag
+tcgttcagtctaattttggtcgtagtacgatgagctgatggccaattgtatttttattaa
+cagcactgaaacaaaatggagactttagactaatactaaagtctcaatgttcgtcgaacc
+ttaaatgctcggaatgaggggatcttcggaagtatagcgccgaagtgtatctcattatta
+taacaccagtgtacagacgacatctaattatggccagaaactgtcattgtgccattaaga
+ggattagtagatagtctggaccgtggaatagaattttgaccaaattgaccagtcctgctt
+gtagacagcgcgatctaaactgcacgagaatatacaagttggtggtgcttgtggctgagc
+acgctaagatgcgtttgtttttacgattctagtgcttcttaacgcaattcagtcttctag
+atccgctattccaacatcaatatctcaatttaaggtcaatatatataacaaaattagaca
+gagcagctgacacttacgaagcatcgtagaaccgatatagtcgaccttatgatgatatgg
+acgtgtccaagtccgcacttccgatgcatcttgacggtgaaccgaaatgaaatcttcatt
+agggcccccatgtgtcaaaccactcgagtcccgtctctgaagtcaagtattactgcgaaa
+aattcgtctactattagtttattatgaacttatgacgcttaaataaattaaacagtaagc
+ctgggaaaatgttaaggcaggaatctttgtaacagttcataatgttgctaaagattatca
+gaccccgtgaagacttcgggctttgggcttcgtaccgtagcataatacatctatatagtt
+agaggcttgcgtgttgttgtgctattccacatatagcagctctgggcgactcttcaatga
+aaatgaaaaatggtaacctggcgacctacttgttaagtcagtttaattcaaggggattaa
+gtaccaagggtcgagtttctctgtatttattatactgtaggcaagaagcttttttggcga
+gatttaagacttaagcctatggtaaaaatttgatagtgagcgactatagtaagagatttg
+ggtggttagtaattaaaattctcctatgctaaatcaggcgtacaatctgagggtgcacat
+ttctcgacgcgtgaaccttcaccgaaagcgtgtggattatacaaatttcaaacatattgg
+cggggcacttatccataatagatttctgtttgtacgccaaactctgcctcacccctccat
+aaattgtattggctagaggttaaattctccgtaaatagagacacatatagttttatacaa
+ttgtttgaatcaaagcacgagaaacttttaaccgtacattgacaaatgtcttcggatggg
+gcagagcatctcttcgtgacccaaatcaatcgctgagcaataagcaagaaaacacagatt
+atacaaagagatctggatgaagatattcgtgcaatcactatcgttatgttagagagttcc
+atgcatgaggactcgttttttgaccaggagaattaagccaagaaataactgacgtatttc
+caaatgaattctacgtgtttttcctgtcacctttagccagtgttaaagatgactatggag
+tttcgaataggttattctatagacattataacgagtggaacacccataccttcacagtgc
+taaaggtaggaacgggtacgtcaggtagttcaagggattttaggttcttaatccaacgaa
+gaaataacgcatcacccgtcattctattgttttcgtcgggattacttagtaggcagggta
+ttctaacctacctgagttacaaatctttaaaaaactggccatgaggtcatggtgataaaa
+tctgaatcgcctaaattcgcgtccctaaggaaatatactagaatccgtctcagaaagtgc
+aaaggttgacttcttcccctaacacagaattctcagttttatagctatctagtggcattc
+ctttttataaaactttacgtttgtaagggtccaactttacaaaagctcggatgtgtatgt
+gtaatcttccgccgtgtaagacttggaacccatgtatattgacggcatggcgtggctaag
+caggtattgatcttcagtgtaaagcaaggtatgttctaatctaacaatgtaaagccgggg
+attagccgccaaaggggtctaatgacatagagatgctctgaaatcgtaccaactataaaa
+gcacgggatttgaaatatagcgacagatcttccgtattctgttagttgacatctgtgctg
+tctttaccgattgtgatttggctttagcagtcatttagtttcgttactcattgctcgtgc
+gatagttccaccgaatatggcacattcgttctttttttccattttactgcaaaccttttc
+aaaagctgatcgataccactgatgatggcattgattagtcgattggcaactatgtcctgc
+ttatatctccaattgcattgaatatagtaaaaaataaaggctcgccttcccaatgggcta
+cggagtacacgaaaaaatcgcaactcgtttaaccaagcgccgtacctaacatataagtga
+ttgagacaaatagttctccagacgtattgagatatatgtctcctataggcaagcgtttct
+aattgctgaccagaaattagaattaggttgttaatactatattcgaccattttattccac
+gaatgtgctattctactggtattgctccgtatgcgatatataaccaacacggaaagtcgt
+cgattgcaaagtggctccgtagaatcatttctggtcatttaccgggagcgcgcttgaaca
+atggatgcggtatctgccatattgttattgttaaaaagacttccgcttactatcgcttcg
+atcatcggaaaaatattaatgaggattgggtcgtataagaaaatcatcttttcagttcgc
+agatttttgccaatttaaccggttatttcgtcagacttggtagtgtagttacaagcatca
+cgattatatcagctacagaattaaactgtcctgactcgacggggcagtgtgtgagtattg
+cgctatatattcaaggtaacaggaggcatataggtcatagtacaaggataatgaggtttg
+ctaactttaaaaattattgatttaacggttgattgaaaatctctgcaagatgacgctaga
+acacctgatgttcaagtttgccgataataacatataagatgaattactgtctttagaccc
+tcatgttaatccgctaacttagggcggaaacaatgttaggctatgcggagtaagtactat
+attatgataccacatagaatttaacattcatatgatgtctaatacccgttcccaaccttg
+caaccgtcccgattaattaagcaattacggtcatcaatgggccaatcctgtctcaaaaat
+tatcatattcaaggttcagctattttggcaatgggtgagtaccgttcttagtgatttacg
+aacccataatctaggcgacttaatatacaagatttagagttacgttttccgggtagtaca
+tattaacgaccatggatcgggtgaggtgttgtattagttatctgatcttgtcagtagctc
+ccaatgtcccagaatattatgtttctactagagtgttcgtatactggaatttaaatatta
+tgtaagactagacaaattttatggatacattaggccatcgtagaatatgatatagttgta
+acgtccctctatagattttcggagggcaggtatattgcttaataaagatgttcggaaatc
+agcggaaaggatttgtaattaactgatgcgcagcgcttaaataagtttagactattaagc
+tatatgttcgacagcatgtagttttttttaccagaaagtgttatactgatgacccatgga
+ggtagctcctcatgataaaaatattgttacttaagcattactattatagtgttcaaacta
+gtaccgttgcatactttaagaatcagacatggcgtttcttatgcagacacacttttttag
+ctgttgacgcccacctcacatccatagtaggtcaatcgcataagaacaatattctggact
+gttttattacccagaagaaagttttttctttccggttcgttaagacaataaagatcattt
+cattcgttctcttaacgatgaactaaagtacttaaagtatccgcctcttgtttcgactag
+cgcatagtgtaataattaaggcaagataagaagaacaggaacgcgcacgtcggagataac
+tctaatagtctctttattccgtttaatatagcccgtaattgcaccatgcgctacagtaac
+ggccgccttcgcaaacctatttatgtaattccaagtttaggtatgcaatggttggggcaa
+tgtgaggggttttatcaagactttcgttgcttcgcggggggcgcaaagcagactttacag
+tagttaaccgaaaaccgcagggagtcgctctaagtgttaccaacccctcactactacgcg
+aaggtactcgattattccttgaatgggctgaaacatcgtgattagcgtcttatgattcag
+gctgatagaagaaaacttattttctatattccacgtatacaatcacactcgtaactaaat
+agttcccagcgttgtaatgtcgctataataaataaaatacaaagaaaattcgtctgggtg
+cataagtacagttagtcgtctgtcacataaataatccgcagtcgatctcattacaggtat
+tgttgttggtcaaccttcgcaaggtggtccaagtagcattgttgaacagtaaaactaccg
+tcacacaaggaatatcataatagatgccatacacggttttacttgatatgtttacagtcc
+ttgagttgcaatcgtagtattgtttcatccggggtgtgtacgaagtaatttagacaaggt
+gtgtagcggtcactaggtaaaatgacttaggatggatgagcatttaggtattctatgata
+acactaaccatcatgtttctaaaatcctcaggaaatttgtattattttaccaacctgtat
+ttatagaaagtgcttttgacttaaagaagccgaagtgttcaaattaaggagtacctgatt
+gaaagaatggggaattgtaatctgtaactcaattacaaataagccgttctaaggattaag
+gctttgtgtctaagcaactcacgtgaattcgaaattcatactcgattaacgactttaata
+ctcttctgcgtatctacagactcatttaaattacggaatatgttttcgtttttggtttcc
+agctcgcacgtacgcgtttacaaataaggacacctggtacaattggctggagtacaatgt
+tggtttttatttgctgattatcccgatccctgtgggcgttggcataaccgggttttcttc
+aagactactttcgtgttgcttatatacctggtaatatcggtgagtagcttagggcttaat
+cacaatactaacaagttctctatggattggacagggcggcatccgttgactgaacgatct
+attaatccattccctgcactggataaacaagacccatttaaattgaccatagagatgtta
+gcgtcatatttctgttcgtgatagggtacatatattataaacggattatgagcagtggtt
+ttctagaaaagcattcatagttaggagtgtatcagatcataccactgaaccatagagcac
+aattctctactggctatacttcattcctttttgtccgggtggggacgaaatttaaaggtt
+ctaacctagaacgcagagcgaattgatcaaggcgctggccaagtgaacggttctaaatgt
+tcttaatgagaattgcgtattttgactattgacagggcatcgtaaaccgctactcgactt
+ggtatctgtaatctgtatgtagatagagtacgggcctataattcaaattcagccaccgaa
+gattcacaatcttcagacgtttgaaggaaagaggtttactggtatgtggtgtcaagcccc
+acccattctctgttatatccgagcattaatgtagtttcactgtactacggtcacgccgta
+gagtcggcagggcaaatccaaaacaatttaggctgagaagtggcactataatagtttagc
+ctaagtcccttcgctaataactcaacaaagatgacgcaaaagtcggcgaatagattgcgt
+tcgcgtaagggtatcttgaatactgatagctctcatggtaccaagaactttcataacctc
+tttatttaccaaacctgttctactagcgttagtgttttagtctgtagccgacacaaaaac
+cgagaatggccggcgtaaccggcgcctgcaagctaacatgggatcaaaactattggctta
+acgtttaatcgaatgagactagcactgtattactctttcgtttcggcagcggatcaataa
+ggaggtgacggcatcactctcttatagtagatatcacttattctcacaacggaagtagga
+tcttccgtcctcattaaatttgcaactggctcaatgtaacactgtaatgttaacaaagta
+tgagctgaaggtcagagcagacgatgtagtaaggtccctcgaagctgcttacagtatcct
+tgaggctcaacgggctatgcggaaattccagacctcgagttacattatgaaacgtgtcat
+tccatctcattaaatagttcgtgccctatcgccttgtaatataaacaaccgtttttgtct
+attttcccaaggagaaggagagtagcagcttagtggcttgcctatatggccccctaagta
+cgtactcggcacgcttagaagattgggctaccccgcactatatgttcccaaagtaggtaa
+cctagatagtgtcgtatgaaattcaggtcatcgatgagagtataaaaatatacaattttg
+gcaggggttatacattgcgggcatgaagagtaacattggacatgaacggacattcgaacc
+ctgtgagtttaataccctatctccggatcattataaagtaaatatacgtcacttactcta
+cgtgcgtttagacagtctttgaaactaaattggttatttttctttcatctagatttgtct
+gtatctaactaaattatagttccacataaagctgattcaactgaagacataaatataaac
+tttctaacatagtagcgaggaaagagctatgcctagcatcggatcatgcgtccgcgagta
+gttcctggtagagttaaaagtttttccagaatctagaccgaacacagggtagtgaacgaa
+agtgcgcggtgaacatacataataccgaacgtaaacaattccgttcgtattgttgctgta
+tctatatttcctacgtaaggctatttgatctataatatgaaaagtcacgtcgaaataaat
+caggaagcgcttcgagtatgtacattcagatctccttagtatcatcaaattatagatttt
+acggccacgaattattggtctagatgtcccaaaaataatttgatgtcagtagcgatcgtg
+cttcctcggagttgaggttggaagaagagtcattatgctataccaagaactctccatcca
+gtacctagaaaggcaggtatgtaccgctcattaattttgcgatcttgacagatctgcatg
+caaagtaacttgtaccagatggcttttataatagaaactaagtttcccgaataacggtgt
+acgataacagatttttaggtgtacagacgtctgactcaatgaacacacattgggacctgc
+cccgggaggagtagtagataattaccttctccagcgcgggtcttttaatatcacaacata
+aaaatactaattaatatcacacaccctcatcctcgatggagcctagcatcatacacgttt
+gatagacaacgccaattttactgtaatatgatattcgaatctagtatgtggacgctgtac
+cacattgtttaaaggagctccctttaccgacatgaacgaagcaagctttgtacaagatac
+gaagaactcagtactggtaactataagagacaatttatacataaaagtgttaagaccatt
+atataaaaagaggtatgaggtctttgtaactacaataatacattcatcgaacgatggaga
+ataacagagttatttctgctgctcgagctctagttctgctaatttctcaatcttgatgcc
+actcgtttgagtcttccattcgctcttaacgacgcgtacatccctctctcctactcttac
+ctatatcctattactggttaacctacatctccgggaaagacgtaggtaaagtggtccacg
+attgtattcacttataacacctagtagtactatgtgttgctgagagtgaggacacactta
+ctctacgagttcaagtccatatggacattacactttttcagcatctaggtgtcatgatgt
+attaacagccgttaggggctatttgattttatcgattgtcggcgtgtgtattttcaacaa
+ctaggtgctacaattcgtgaataggcatgaaaattcaagattgcagttcctatcttgtat
+aatctttcctttggacgagttgtaccatttcaactaacctgcaagtggggggtcatccat
+atgaagatttgccaaatacctggagaccctgaaaagtttatccagattaataataacaaa
+caaacctaagcgaagaacgtcagctttaataaactatcactatcatagaaattcctgtta
+attgttcttccaaacgttgaatagactatcacgggtaatagattgaacacggagaacgtt
+tatccggcttgtaaaatatcgtcgaatctgctgataactcaattatattcgatggagaat
+tcatatctaccgcttagcttttaaaaattaagtcagattattccgccacaatgagaaggc
+gcgagtgcactaatcaaatcacttaggattattacggacgtctgcattacaatgctttgg
+ggtagggttatacaagcatatgattctttaggtctcttgatcgggcgtttaccaccgtag
+cttaatgttggcatatccgtgatcctaatattctgttgtcagcgtgtgtataggaatgca
+caacgcaaatctttaagctgacctgttcatgaaagacaggagacacgaggcaccacctca
+attctatgcaaaactctaacatagcgtggcactatgagtacgtgtaacgacaaggtctca
+tactcgatcctaagataattctcgtctggaaggttttaatctttaactaagagtagaact
+tagtttattgacttttacaattaggatacggttcgcgactctaccacagggcatcatacc
+tggagctctgctatctcgtgaccaaagtggcagcacacatagggtcgggtcctgcatcta
+ctgagcaatccctttaagcattcctagtttgagagccatttagatattgctgtttaaacc
+gattaatggtttctattattataaagtgtaacgctcccattcgggacattgaaaattagc
+aataagacaatgtatgatattcggcgagtctcaacaacattatggtctaccatgggacaa
+ggggttgatatgatgaatccacaaaaaatagtcaaacacccatggttcgttaagtgaggg
+tatccaggtgttataaggacgatctagaagtattcaggtacacggtgttcagacatgctc
+taattgtcaggttgtttataatttaacgtatcgctctctattctaaataatataaaatta
+accgctcgtagggatgctttccagtaaaagatacactatcattaaggttatgcaaatgtg
+gcgatttgatttgaatcttagtacattcttaaacttaaatacgtattatttaaagtaaat
+atattatctaaaccgcttttgtctatccacatttcgtcgaatcacgacctcgttaatgcg
+acaatttacgaccctctttcatctaaagcgatcatctatttcttctgattgatgtaatac
+tgacccttactccgtacatacaaatgatggtaagcaagaatgactgacgctcctgtcacc
+tttcgtggcaatcaactggcgctggtactgaagtagcttgaaagggatatggatgtgtat
+gccaggcttcattttgacaatttttctgtcctgctcagtgttgtctgaagtcgtatcgta
+cacaataatgatgactctcattgtagatccaatcacgctttcctacgctaatgaaagttc
+tagatagtgtaggtgttagacagaggttagcgcctacatccttacacacacagtgttgaa
+cggcaagcataatcgagtatcaatagctgtatgtatttgtttggaatatcatatttctcc
+cgcctttgaacaatgatgccaaaatgtcctgccctagagttatgataaaataactgctgc
+cctgtaacttaagtttacaaaccgatattcaatcgttgtgtcctatgaaaatatttatat
+ttgcaccaagaaaatcatctgtgcgatgaacaaaacacagtgatttataaatacaaagag
+tacatttagttaccggattgcggcttgacatttattttacagaattttatcggcaaaaca
+cttcatatgaactatcgcttcacgataagtctatgatagactagcattcgtagagaacag
+gaagagcaatcattatatatgaagtgttacagtgggtactacatatgagatcattaggtc
+tatatccggccttcctcataagaccttggaaatatcttacatcagagatatcaaaggaag
+tatgggcgaacccagaaaaagccccaaagaatagtaattcatcggacgtaatagtctggt
+tttaactaggggttattgatatttaagctaaaagagttccctgaacactcgaaatgtata
+atctatcccaactaaaaaagtatacctctaattcagaaatgtcattgagattagactgat
+gtcaatacgctaggaggtaagacaagtagaagtttttgatttaggaattgaaatgtaata
+cctccatcttaagttctatattttaaagttttatgcggacttcgagtaagtgcacaaatg
+atggcataagtgcccagttacatgtttgcggccccgtatgagtaatgatctgtttatcaa
+tctctagctactatcccacgaatgcactgatgccagtcatggcgcttacattagtcgaca
+gaaatccgacgatacctatcacgcgtgaactgttctggttcttattcaattcgaagtgat
+ctcagatacattacggccatgcttgcccttcatgtctgctgagcagttttgttataggct
+gaatctcctctaagcgaaattgataggatttttggtggtcgatttagtctgtacctgctt
+attaagattcaaaatgacctacttcttacgccgaaatgatagggatcggctgaggaggat
+aaatatacgctggtgcctggtatttatccagaacaagttgcctgtgtatcagatgaactc
+taatctccgagataaaaaacaggtacgtaaaataaaggccgcaaagggttacatctcagg
+atcgtggcgtatagtccaccattagttctgacttacttaatatagactgaccgagattgt
+agtatgtggatccaagcttgccatgtaaaacatgtcggttagcaaaacgtataggagcat
+gatcaaagaagagttaattaatagtactgcactataattgtcggcggagtaccatgagct
+gttgcccaattcgatgtttattaacagcacgcataaaaaatccagacttttcaattagaa
+ttaactataaatggtccgcgaaccttaaatgatcggaaggacgggatctgccgttgtata
+gaccccaactctatctaatttttataacacctctgtaatcaacaaatcttattatgccat
+cattatgtcattcgccaagtaagtccagttcgagattctctggaccgtgcaatagtattg
+tcaaattatggtaatggaatccttcttctaacacccttagaaaagccacgagaattgaca
+agttgggcgtgcttgtccaggagcaacataagtgccgtttctttttacgatgatagggat
+tcttaaagcttttctctattctagatcccagttgccatcatcaatatctcaattgatgct
+cattatatagttcttatttagtatgtccagatgtcactgaagatcctgcctagaaccgat
+attctcgacaggatcatcagttcgacggggcaaacgcacctatgcacatccatcttgacc
+gtgaaacgaaaggaaagagtcagtaccgacccaatgtggaaaaaaactcctgtccacgat
+atgtaggcaagttttactgcctttaattagtagtcgattagtgtagtttgatattatcta
+ccttatagaatgtaaacagtaacccggccttaatggtttggcaggattctttgtaaaagt
+taataatgttcataaactttatcagaaaacctgaagtagtccgcctttcgcctgcgtaac
+gttgcagattaattcgttttacggagtggcttgcgtcttgttgtccgagtacacatattg
+ctcctctcccccactcttctaggaaaatcaattatgctaacctgcagaccttcttcttta
+ctatctttaatgcatgcccagtatgttcatagggtagacttgctatctattttgtataat
+ctacgaatgatgcttggggcgcgacttttaacaattaagccgttgggtataatttgagag
+ggtgccacgatagtaagagatttccggcgtgagtaaggaaaatgataataggattaagca
+ggcgtaatagctcaccctcctcagttctccaaccctgaaccggctaagtatgactgtgca
+gtattaattttgaatacatattgcagcccctaggatacattatagatgtctctttcttac
+ccaaactcgcccgcaccaagaaagaatgtggattcgattgaggttaaattagccggaatt
+acagacacagattcttgtttacaattgtgggaagaaaaccacctcaaacgttgaaaccta
+cattcacaaatggattacgttggggatgagaatcgattccggtcaaaaatcatgcccgga
+gcaataaccaagaattcacagaggattaatacacttctccatgaagataggactgcttgc
+actatccttatctttgtgtcttccttcaagcaccaatcgtttggggacaaccacaattat
+gccaagaaataacggaaggtgttccaaatctatgagtccgcggtttcatcgcaacgtttc
+actgtgggtatcatgactttggactttagatttgggtattctagagactgtagaaagact
+gcaacaacaagacattcacagggcgaaacctaggaaaggggaccgcacgttgtgctaggg
+atgtttccttaggaatccatacatgtaagaaagaatcaaccgtaattatagtgttttcgg
+ccccttgaattacgtgcatgcctttgctaaaagacctctgggaaatagattgaatattct
+ggacagcagcgaatcctgattatatctcaagcgaatatatgacccgcaagaaggatttat
+actagaataagtctaagaaagggcattgggtcacttcttccactaacacacttttatcag
+ttttataccttgagagtcccatgcatttttatatatatttaactttcgttgcgtaaaact
+ttaaatatgatccgtgctctatctctaatctgaacaacggtatcacgtcgaacaaatcta
+gtggctacgaatcgcgtcgctaagaacggtttcttctgctggcgttagctacgtatcttc
+tatgctaaaaatgtatagccccgcattagcagcaaaaccgggagaatcaaatacacatcc
+gatgaaatcgtaacaaagataaaacaacgcgatttctatgtttgccaaagtgattaagtt
+gtatcgtaggggtcagcgctgatgtcttttcagtttgggttttggatttaccagtctttt
+agtttcggtactatttgatcgggacattcgtccaaacatgatggctcattcgttcttttt
+ttcaattttaatcaaaaccttgtatttacctgatacattaaactgagcatcgcatggagg
+tggagattcccatatatgtaatcatttgatatcctattccattctttttagttataaata
+aacgctccactgcacaatgggagtaggacttcaccaataattagcatctactgtaaacaa
+gcgccgtaacgaaatgattactgattgagaaaaataggtctcaacaacttttgacagata
+tgtatccgatacccaagcgttgctaattgcgcaaaagtaagtagaattacggtcgtatta
+cttgttgccaaatggttattactccaatgggctattctaatccgatggatacgtaggaga
+gagtgtacctacaccgaaactcgtagtgggcttagtggctacgtagaagctgttcgggtc
+agttacagcgtgcgaccttgtaaaatcgatcacggtgatgaattattgttattgtttaaa
+agaagtcccctgaatagcccttagataatacgaaaatttgttatgtccagtcgctcgtat
+atcaaaagattcggttaagttcgcagagttttgccaagtttacaggtgatttactaacac
+ttgggagggtacgtacaaccatcacctggttagcagagaatgaattatacggtcatgtcg
+cgaagggcaagtgtgtgagtattgaccgagttattaaacgtaaatgcaggcatttacgtc
+ataggacatcgagtttgtcctttgcgaaatgttaaatttatggttttttccgttgagtga
+taatagctgcaacatgaagatagtaaaactgaggttaaactttcaccatattaaattata
+tgttcaattacgcgatgtacaaactaatgttaatcagatttaggagcgcgcttaatatgg
+gtccctatcccgactttgtacgagattttgataaaaaatagtattgtaaattcatttgat
+ggcgtagaaccgggcaaaaccttgaaaaaggacacatttaggatgctatttccctaagaa
+agcggaaaatcctggctcaatatttataatagtaatggttaagattgtggcccaatcgct
+gagtacccgtcttacgctttttccaacacataatcgacgagaatgtatttaaatgtttga
+gacttacgttttccgcgtacttattattaaagtcattggagagggtgtcgtctgggtgta
+gttttctcatctgctcaggagctaaaaatgtaaatctattggttgtttctaattctgtcg
+tccgtgtaggctatttaatttttatggtacacttgaatatgtttagccataatgtagcca
+atactacaatatcagatacttgtatacgacctatagacttttgccgaccgctcgtagagt
+gatttagaaagatgttcggatagcacagcaatcgtttgcgaatgtaagcatgcgaagcga
+gtatttaactgttgactattttgctatatgttactctgaatgttgttttttttaccagaa
+tgtgttataatgatcaaccatgcacgttcctactaatcatataaattttgttacgtaagc
+ttttctatgatagtggtctaaagactacccttgcatactttaagattaagacatgcactt
+taggaggaactcacacgttttgagctgttctagcccacctataagccattcgtccgcaat
+cccataactacaatagtcggcaatcttttattacccagaactaacgtttttatttcccgg
+tacgtatcacattaatcttaatttaatgcgtgagagtaacgatgaacgaaagttatttat
+gtttaagccgcttcttgagaatacagattactgttagaatgaaggcatcataactagaac
+accaacgcgcacctcgcacattactctaatagtagctttattcagtttaatatagacagt
+atttgaaccaggcgctaatgttaaggcccccttcgaaaaccttgttatgttattccatgt
+ggtcggaggatttgcggggcgatagcgctgggcggggatcaacaatttcgttcatgcgag
+cgcccccataaccagtaggtacagttcggaaaagaaaaccccacgcactcgctagaagtg
+ttacaatcacatcacttcgtaccgaagggactactgtattccgtcttggggatgtaacag
+actgattacagtcttatgatgaagcctcattcatctaaaattagttgatttattccacgg
+atactatcacactcctatagaaagagttaccaccgtgggaagctagatataataaataaa
+agacatacaatattagtatggctcatgatctacacttactcggatctctctttttttata
+accagtagatcgcattacacgtattgttgttccgcatcaggccctaggggctcaaacttc
+catggtggataactaaaacgtccgtcactaaacgaagatattaatagatgaaatacacgg
+gtttacttgatttctgttcagtcattcacgggaaatcctaggagtctttcataacggcgg
+tcttagtaggaatgtagtcaagctctgtagaggtctcgacggaattggtatttcctggca
+tcacaatttacctagtattggagatcacttaaaataatgttgagataataatcaggatat
+ttctagtatgtgacaaacctctatttagtgattgtgattttcaattaaacaagacgtagg
+ggtcaaattaacgactacatgttggaaagaaggccgaattgtaatatctaactcatgtac
+taagaagaagtgctttcgtttaaggctttctgtctaacattctaacgtcaattcctatgt
+aatactactgtaaccaagttattactcggctgcgtagataaagtctcatgtaaatgacgg
+tttatctgttacttttgggtttcaacctagctaggacgccggtactaattacgacacctg
+cgtatagtgcagggtgttcaatgtgcctttttatgtccggattataaccatccctctccc
+acttggaatatcaccgggttcttaatgacttagttcgtcttccttattttccgggtaaga
+tcgctgtggaccggacccattttgatctagtctaaaaaggtatatagcgtttcgtctggc
+ccgcttacgttcactgaaacttagattaatcaatgcactgcactggattaacaagaacat
+gttatagtgtactgacacatgttagactaagaggtctgttcgggttagccgacttatatg
+tttaaccgattttgacaactgggttgagagataacaatgaagagtgaggactgtagaaga
+tcttaaaactgtaccatagtgctcaattcgctaatggcttgaattatttaattgttctaa
+ccctggcgtcgaatttttttggttcgaaaatacttagcacagcgtattgttcaacgagat
+gcacaactgtaccgttagaaagcggcttaatgacaaggcagtattgtgactattgacagg
+gaatcctaaaaagctactcgaattggtatatggaagaggtatgtactgagaggtcgcgcc
+tattagtcaaattctgccaaagaagagtcaaaagcttaactagtttgatggtatgaggtt
+taatgctaggtggtctataccaccaaaaagtatatgggatatcccagaatttatcgactt
+tcaatcgtctaccgtcacgacgtacactaggcagccctaatccaaaacttttgaggatga
+gtactgccactattatactgtaccatttgtaacttacattttatatcttcaaagaggtag
+atattgtcggccattactgtcacttacactaagggtagcttgattactgatacctctcat
+ggtaaaaagtaatttaagaacctatttttttacataacctctgctactaccgttagtgtt
+ttagtcggttcaagtcacaaaatccctgtagcgcacccctataagcagaaggaaacctta
+atgcggataaaaacttttgccggaaccgttaatcctatgagaataccactcttggaatcg
+gtcctttaggctgaggatatagaacgaggggaacgcatcaatctaggttaggtgagagaa
+ctttgtatcaaaacgcaagtaccatatgccgtcctcagtaaattgccaaatgcagaaatc
+ttacactcttttcttaactaagtatgagagcaacctcactcctgaacagcttgttaccta
+acgagaagaggctttaagtagcctggagcctcaaccggatatccggatttgactctcatc
+cacttacatgatgattacggtcattacatctcatgattttctgagtgccctatagactgg
+gaatttaatctaccctgtttctatttgttaacaaggagaaccactggtcaagatgacgcg
+cttccatttatgccaccataagtaagttctcggaacccttacatgattggcctaccaacc
+tatatatgtgaccaatgtacggtacatagagtgtggcctatcatattcaggtcatcgagc
+tcagtatttaaagattatatggtcgctgggggtattcagtgcgcgatggaagactaacat
+tggaaatcaacggaattgacaacacgctcactttaataacctatctcaggataagtttaa
+tgtaattagacggaactttctctaactccgtgtactaactctttgaaaataatgtgggta
+tttttatttcatctagatttgtctgtatcgaaagaaagtattggtccaaataatcctcag
+taaaatcaagtcataaatataaaatttagatcttaggacagaggaaagtgctttcccgag
+cataggatctggcctacgccagtagttcatgcttgtgttaaaagttgttactgtttatag
+tccgtactcagggtagtgttcgatactcagcggggaactgacatattacactaaggaatc
+aaggcccttcgtatgggtcatgtttatatatttaattacttacgctatttgatcgagaat
+agctatagtaacgtcgtaagaatgcaggatgcgattcgagtttgtaaattcacagatact
+gtgtatcatattattatagatgttaaggcatagaattattggtattgatgtacaaaaaat
+tatgggtgggcagtaccgataggcattacgagcagtgcagcttggaagaactggatgtat
+cctataactagtaagagccttaaaggtactacatacccagggatgttaccatcattaatt
+tggccatcttcaatcttcgcaatgcatactttcttctacaagatgccttttagaagacaa
+aataagtgtcaacaataacgctgtaacttaactctgttgtacgtggaatcaagtctcact
+aaagcaactaacattccgacatgcaaacgcaggactactagattattaaattcgccagcc
+cgcctcgtttaatataacatcataaaaattctaagtaatatctcacacactaatccgcca
+tcgtccatagcatcagtcacctgtcttacacaaacacatgtttaatcgatgttgttatgc
+caagctagtttcgcgaccatgtaactaattgtggaaagctgctaccttgaacgacatcaa
+ccatcctacctttgtacaacagaccaacatctctgtactggtaaatagatctgaaaagtt
+ataaatataactgttttcacattgatagaaaaacagctatgtgctatttgtatatactat
+aataaattaagcgaaacatggagattaaaacagtgttttctcatcctccacctcttgttc
+tgctaatttataattcttgatgccactcgtgtgagtcgtccattcgatcgtaaagaaccc
+gacataaatagatacgacgctgaacgagatcctatttctcctgaaaattattagcacggt
+aactcctagggatagtggtactagttggtatgaacgtataaaaacttgtactactttctc
+gggatgtgagggagcaaactattactcgaccagtgcaacgcattatcgacagtaaaagtt
+ttcagctgatacctgtctggatggattatatgcaggtaggcgagagtggattgtagcgat
+gctcggcgggggtattttaaaaatctaggtgataaaagtcctgtttagccaggaaaagtc
+atcattgcactgcatatcgtcgattagctgtcatttcgtccactggtaccagttcaacgt
+acatcaaagtccgggcgcatccatatcaagttttgcaatagtactccagaccatgaaatg
+gttatccagattaataataacttaatatactttcactacatactcagcgggtattaaatt
+tcactttatgtcaaaggactcttatgtggtcttcaaaaaggtctagagtctatcacgcct
+aattgtgtgaaaaccgagtaacttgatcagccttgtaaaatatagtagaatatgatgtta
+aatcatttatattccagggagattgaatagcttacgattagctggtataatttaactcac
+atgattaagcaaatatctgtaggaccgagggaaagaataaaataaagtaccatgagttcg
+gaacgctgcattacatggcgttgggctagcctgatacaagaagatgagtatggagctctc
+ttcatcgggacgtgacaaccctagcgtaatcttggcagatcccggagcagatgattatcg
+tctaacactgtctttaccaatgcacaacgcatagatttaacctgaactgttctggattca
+ctcctgactacagcctacaactcatttctatgcataactcttaaagacagtcgcaatatc
+agtacctctatacacatcggatcagactagatcataagataagtctcctctggatccttg
+tattctgttaagtacactacaaatttgtttagtgtctgggacaattacgataagggtcgc
+gactagaccacagggcatatgacctccaccgctcctagcgagtctccaatctgcaagcac
+tcatacgctaggggcatgaatcgactgtcaatgcactgtaagatttacgagggtgagacc
+catttagatatgcctcgtttaaccgttttaggcttgataggatgagtttgtcgatccatc
+aaattcccgacattcatattgtccaataagtatatctagcttattcggactcgctaaact
+aaattatggtataaatgccgtcaaccggtgcatttgttcaatcaacaaattatagtcaat
+ctcccatggggccttatggcagcgtatacagctggtataacgaccatatacaactatgaa
+cggactagctgtgaactaagcagattattggatccttgtgtataattttaagtttcgatc
+tatatgctatagtatagaaaatgttccgatcgtacgcttcctttacagttaaacagtcta
+tatcatgaagcttatccaaagctggacatttgatggcaatcttacttaattatgaaactt
+aattacctattattgaaagtatttatatgatcgaataagatttgctctataaacaggtcg
+tccattcacgacctagtgattgcgtaaattgaccaacctaggtaatctaaagcctgcatc
+tatttcttatcattcatgttatactgacccgttctcagtacttaaaaatgatcgtaagca
+agaatcactcacgctcatgtcacatttagtcgaaataaactgccgatgggaaggaagttc
+cgtcattgcgatatcgatgtctatcccacgcgtcattttcaaattggttatctacggata
+actgtgcgatgaactactataggtcaaaattatcttcaatctcattctagatcatataaa
+gatgtccttcgcgattgatacgtctacagtgtgttggtgttacacagagggtagcgacta
+cttacttactaactctctcttgatccgcaagcataagccaggttaaagtgctctatcttt
+ttctgtggattataatagttataccgccttgcatctaggtgcccattaggtaatgcccta
+gtgttttcataaatttactcctgccatctaacgttactttaatttcccagattcaatagg
+tctctcatttgaaaattgttatatgtcaacaaagaatataatagctgagtggaacaatac
+actgtgagggagtaatacatactctaaattttctttacggtttgcgcctgcacagttttt
+tttatctatgtgatccgcataaaaagtaatttcaacgttccattcaagttaagtcttggt
+gacactagcattaggagagatcaccaagaccattatttatttagctagggtttaagtcgg
+ttagaaatatcagataatgaggtctttatccggccttacgcagtagaaattggaaatttc
+gtaaagcactgagttcaatggaagtatggccgaacccacataatgcacaaatcaagtcga
+tttcttccgtccttttagtctcctgggaactacgggttattcatagttaagctaaatcag
+ttaacggaactagacaaatgtataatagttcccaaatatatatctataaatcttatgcag
+ttagggaatgcagatttgaatcatggcaatacgctagctcggaactcaactacaagtgtt
+ggatgtacgaattcaaaggtattacatccttatgatgttcttttttggatacttttatga
+cgacttccacgaagtgaaattatgttcgaatatctgaacagttacttggttgagcccaag
+gatgacgaatgttctgtttataattctcgtcataatataaatacaagcatatgaggccag
+tcatggagctttcatttggactaacatttccgtagagtcatatcacgcctgtaatctgat
+ccgtctttttctattcgaagtgttatcagatacatgacgcccttgcgtgacattcatggc
+tcctgacatcgggtcttttaggctgaatctaatctaacccaatttgtttggattgtgggt
+cctccattttgtctgttaatgcttattaagattaaaaatgtactacgtatttagacctaa
+tgattgcgatacgctgtggaccattaatataagctgcgccaggggatttttccagatcat
+ctggcctgtgtatatgttcaaatctaatagccgagagaaattactccgacggaaaataaa
+ggcagataagcgtttcagagcaccatcgtggcgtttagtcaacctttagttcggaattta
+ttaatatacaatctcactctttggacgagctccttaaaagatgcccttgtatatcatgtc
+ccgtacctaaaagtataccagcatcatcaaagaacagttaaggaatacgactgctctata
+attgtccgaggagtaccttctcatctgccaatagtcgttgggttggaaaacaacgcatta
+atatgccacacttgtcaattagaagtttctataaaggggacgagtaactgatttgagacc
+tagcacggcagaggacgttcgtgtgacaacatctctttataagtttgagataaaatcgct
+aatctacaatgattatttgccaatcattatcgaatgcgcaaagtatctcctgttcgtgat
+tctagcctaaggccattactatggtcaaattatgctaatcgaagcagtcttctaacaccc
+ttagaaaagcaaacactattgaatactgccgccgcattcgccagcaccaacataactgca
+cgtgcttttttccatgattggcattatgaaagatttgatctatgattcttaccagttgca
+atattcaatttagcatgtgttcctaattattgtgttattatggtctatctcatcatgtaa
+atgaagatcatgacgtcaacacagattctagtcaggatcatcagttcctcggggaaatcg
+cacctaggaacagccttatgcaaccgctaaacaaagcaatgaggatgtaccgacaaaagc
+tcgatttaaaagcctcgaaacgagatgtacgaatcgtttactgccttttatgaggagtcg
+agtactgttggttcatatttgctacatgattgtatgtaataacgatcccgccctttatcg
+gttcgatcctttatggcgataagttatgaatcgtcagtatctttagatcaaaaactcaac
+tagtacccagttccccggaggaacggtcatgattaatgcgttttacggtctcccgtccct
+cttcttgtcagaggaatcagtttcatccgatcccactcgatgattggtatagctatttgc
+cgaaaagccacaacgtattcggtactatcttgtttgattcccctgtatcttaattcgcga
+cacttgatatcttttgtgtttaatcgacgaatcatcctgggggcgacacttgttacaatt
+atccagttgcgtttaatggctgtgggtcacaagattgttagacaggtcccgcgtgtcgta
+ggaaattgataattggagtttgcaggacgaatagctcacccgcctaagtgatccaaccct
+catcaggataactatcactgggcagtattatttttgatttcatatgccaccccctaggag
+actgtagtcatgtatctttcttacccaatctagcccgaaacaagaaagaatgtcgattcc
+agtcaccttttattagaccgatttacacacaaagtgtcttggtttaaaggctggcatgaa
+tacatactcaaaagttgaaaacgacttgctctattcgattaccttcgcgatctcaatcga
+ttacgctaaattttaatgcccgctgaaatatccaacatttaaaacaggattaattctctg
+atccatgaacttaggactcattgcacgtgacttatctttctctcttaattcatgctccaa
+tacggtgggctaaaccacttttatcacatgaatgtacgcaacgtgttaataagctatgag
+tacgcgggggcagcgaaacgggtcaatctgggtatcttctattgggacggtacatttcgg
+ttttatagactatgtagttacacggcatcaacatgtaattaaaacggcgtaacctaggaa
+agccgaacgcaccttgggattgccatgtgtccggaggattacatacatctaagaaacatt
+ctaaactatgtatagtcgtttacgacccttgtagtacgtgcatcccttggcgaaaagtac
+tctgggtattagagtgtatattatcgacagcaccgaatcctcattttatagcttgacaat
+ttatgacccgaaagaaccttttataagtctataagtatatctaacgcaattgcggcactg
+agtccactaactatctttgagcagtgttatacagtgagacgccatggaaggggtttatat
+attttactgtcgttccctaaaaagttaattatcagacctgcgcgatctcgtagatgaaca
+acgcgatctagtcgaaaaatgcttgtggctaccattccagtcgagatcaaccgtttctgc
+ggatcgcgttacattccttgcttatttgcgataaatcgatacaaccccattaccagaaaa
+acccggagaatcaattactctgcagatcttatactaaaaaagagattacaacccctgttc
+tatgtgtcccaaagtgagtaacgtggagcgttggggtaagagcggagcgattttaacttt
+cgcttttccattttccagtattgtactttacgttatatttgagcggcacattcgtcaaaa
+catgatccatatggactgaggtgtttaaatgttaatcaaataattgtattttcagctgac
+tttaaaatctgcagccattggaggtggagattccaatagatgtaagcaggtgatatcata
+tgcaattcttgtgacttattaagataccagacacggcacaatcgcagtagcacgtaaaca
+ataatgacaatcgacggttaaattccgaacgtaagatatgtttacggatgcactaaaata
+ggtagcaacaacgtttctctgagatgtataagttaccaaacactggagaattccgctaaa
+ctaaggacaatttccgtcgtattaattgttgacaaatggttagtaatacattcgcagtgg
+ataatccgttgcatacctagcactgagtgtaaataaaaccaatcgactactggcatttcg
+ggctaacgactagatgttagcctatgtgaaagcctcacacatgcttattgccttcacggt
+gagcaatgtttcttattcgttattagaagtcacctgtagagacagtagagatgacctaaa
+tttggtttgtccagtcccgaggtgatctaatgattaggttaacttagaacagtggtcaat
+tggttaaagctgatttacgaacacttccgaggggtcgtaaaacattaaactggtgagaac
+agtatgatgtattcggtcatctagacaaccccatcgctgggagtttggacagtgttatga
+ttcgtaaatccaccatgtgtccgaattcgaaatcctgttgctccggggagatagggttaa
+tttaggcttttttacggtgtggcatattagctcaaacatcaacattcttaaaatcagcgt
+aaacggtcaccagttgatatttgttctgctaggaagcgatgtacaaaataagcttaataa
+gatttaggtccgaccttaatttcggtccatagcacctctttctaagtgttttgcttaaat
+aattgtattgttattgattttctgcgagttgaacacggaaaataagtcaaaaaggacact
+tttaggttcatatgtaccgatgaatgcgcaatagaatcgagaaatttttagattagtaat
+cgtgatgattgtggccaaatcccgcactaaacggctttcgctgtttccaaaaaattttag
+tccactaggtatttaaatgttggacactgaacgtggaagccgtcgtattatgaaactaat
+ggcagaggggctcctctgcgtgtactttgagcagatgctatcgtcagaaaaaggtaaatc
+ttttggttctttataattctggcgtccgtgtagcctagtgaatgtgtttggttcaagtga
+atttgtttagccagaatggaccaattacgtcattagctgttacgtctatacgaaatatag
+actgtggacgacccatcgtagagtcatgtagttacatgtgaccttagaacaccaatcgtg
+tgcgattgtaagcaggacaacacagtattgtactggtcaattggttcatagatctgacta
+tgaatcttcgtttttgtacaacaatctcggtgaagcttcaaaaagcctccttcctaataa
+tcagttaatttttcgtaaggttcctgttcgaggttagtcgtataaagacgaaacggcctt
+aatgtaacattaactattccactgtaggtggatctaacaaggttggacatgtgctaccaa
+taagataagaatttcgtccgcaatacaatatctacttttgtagcctatcttggattaaca
+acaacttacgttggtatttcaccggacgtatcaaatgattctgattttaatgactgagag
+taaacatcaacgaatcttatgtatctttaagccgctgcttgacaagtcacattactgtta
+gaatgaacgcttcattactacaaaacctaccaccaactcccacattaatattatactaga
+tgtttgaagtttatttgacaaaggttttcaaaaagcacagaatcgttacgaacacgtaca
+ttaaattgttagggtattaattgtggtcggtgcatttccggccccatagcgctccgcggg
+gagaaactatggccttcatgacagcccccccataacatctaggtaatggtcggataacta
+taaacaaccctctccagagaactgtgaaaataaaatctcttagtacacaagcgtatactg
+gtttaagtcttgcccatcttaaagactcttttcactattttcttgatgcctcattcttct
+aatattaggtgattttttaatccgagaatataaaaagacgatagaaagtgttaaaacacg
+gcgtagcgacatattttaaagaaatgaaatactttttgactatccctcatgatctaaact
+tacgcggagctatctttttgtataacatgtacagagaattaatccgatgcttcttccgat
+taaggacatagcgccgaaaacgtcatggcggcttatcgatatcgtaacgcactataccaa
+gtgattaagtgatcaatgaatacgggtttcgggatttctgttaagtcatgcacggcaaat
+acttggagtcttgaataacgccgcgcgtagtacgaaggttctcaagctcgcgtgacgtat
+agaccgtattgctatttcctgccttctcaattgtccgaggattgctgataacttaaaata
+aggttgagtttttaataacgatttgtcgagtttgggaaaatcctcgtttgtgtgtttgtc
+attttcaagttatcaagaactacgggtataatttacgacgtaatgttggtttgatgcccg
+attgcgaatatcgtacgaatggtatttgtacaactgctttcctttatcgattgctcgaga
+acattataaagtctattactatggattaagactgtatacaagtgtttaagcggagcccgt
+gataatctataaggttttggtacctttatctgttacttttgccttgaaacatacatacgt
+acacgggaatatttacctaaacgccgtatagtccagcctcgtatttgggccgtgttttgt
+cagcattttaaactgaaagcgcccacttgcattataacccggtgcggaatctcttagtga
+ctcgtcaggagtttacgcctttgagacctctcgacaggacccattttgatctagtcgtta
+taggtagagtgcctttcctatcgcaccattaccttctagcaaacttagagtattcaatga
+aatcatatcctgtttatactaaatgttataggctaatgacacagctgacactaagaggtc
+tcttcgggttacccgaatgagttgtttatacgatgttgacaactcgggggagtcatttca
+atgaagactgaggactcttgatcagattaaaacgcttaatgactgataatttagattatg
+ccgtgtattatttaagtgggcgaaccctcccctagaatgggtttcctgagaaaagtctta
+gaacacagtattctgaatccagatgcaaatcgctaacgttagtaagcggctgtagctctt
+ggcagtttggtcaatagtcaatcgcaatccgtttaaccgtctactattcctagagcgaag
+agctatgttctgacacgtccccaatattaggcaaaggctccaaaagaacagtcaattgat
+taactacgggcttggtttctccgtgaatccttgcgccgctataccacataaaaggatagc
+ggtgataccacaagtttgcgacgttaaagcgtcgaccctcaacaagtacactagcaaccc
+cttagcaattaattttgtccatcactactgccaagagttgactggaccagttggaaatga
+catttgatatattaatagagctacatattgtaccactttactgtcacttacactaaccct
+agcgtgattactcatacatatattcgtaaattctaagttatgatactagttttgtaaatt
+taatcggcgaagacacgttctcttgtacgagcttcaactaaatatttcactgtagccaac
+cactttaaccagaaggataccttaatgccgatataatattgtccaggaaacgttaatact
+ttcacaagacaaagcttggaagaggtactttacgatcacctgatagatcgaccggaacga
+ttctatataggtttggtctgagaaatttgtagctaaaaccatgttccataggaactcctc
+tgtaatgggcaaaatgcagatagcgttcaatcgttgcttaactatctatcacagcatcct
+aactcctcaacagcttctttcctaaagacatcagcaggtaagttgacggcacccgataac
+ccagagcacgattggaatctaatactctgtatggatcattacgctaagtaaatataatga
+ttttctgactcaaagttacactgcgaattttatattaactggttctatttgttaaatacc
+acaacctctcgtcaacaggtcgcgatgcaagtgatccaaaaatatctaacttataccaac
+cattacttctggcgcagaaaaacatagatatctgaacaatcgaccgttaagactgtctcg
+ccgatcttaggaacctaatactgctcagtagttattgtttatttgggccatccccggatt
+atgtcagccatggaacactaaaagtcctaatctaacctatggacaaaaagctcactttta
+taaaattgctcaccttatgttgattgttatttgtccgaaatgtctataactcagtgtact
+atctattggaaaattatggccggagttttattgaatatacttttgtatgttgagaaagaa
+tgttgtcgtaataattatcagctggaaaatcatctaatatatattatattgagatattac
+gacagacctaagtgctttcccgtcatgagcagatggactaacactcttggtaatccttct
+cgttttagttggtaatgtttagtctaagtaatatcccgactcttacttactcagagcgga
+aatgactttttaaactaacgtttaaaggcacttagtatgcgtcagggttatttttttaat
+tacgtacccttgtgcagagagtttagctattcgatcctacttagtatgaaccatgagagt
+acaggttggtaattcacagagaaggtcgagaagattatttttgatgtttaccaatactat
+gaggcgtattcatcgaaataattttatggctgcgcacttcacatacgcaggaagaccact
+gcagcttgctagatctggatgtatcattgtacttctaagagcctgaaaggtaatacattc
+ccagcgagcgtaacagattgtatggggacatattcaatcttagcaatgcattcgttcttc
+gaaatcaggcatttttgatgtcataagttctgtcaactataaccctggaactttaatctg
+ttgttcgtcgaatcaaggatcaagaaagcttctaaaaggcccaaagcaaaacccaccact
+acttcagttttaaattagaatcacaccctagggtattagataataattaaatgtcttagg
+aagagatatcaaaagatgcagacatcctcaagtgaataagtctccggtctttcacaaaca
+catggttaagcgatgtggttttgactagagacgttcgccaccatcgtaatatttctggtt
+acctgcgaacgtgaaccaaatcttacttcatacattgcttaaacagtacaacttatctct
+tatcctatagagatctcaaaagtttgtatttttactggtttcaaattgagagaaaaactg
+cgttctccgatttctatattattgtttaaatgatgccaaacatccagtttaaaacacggt
+gtgatcagccgactcagattcgtatcctatgttagaatgagtcatcaaactacggtcacg
+cgtacattacagagtaaactacacgaatgaaagagataagaagatgaaagagttaatagg
+tctcctgttaattatgagaaccctaactactacggattggcctactagtgggttggaacg
+gatataaaattcgactaagttcgcggcatgtcaggctcctaaatatgaagagaactcggc
+atcgaattatccacagtaatagttggaacatgattcctctatgcatggtgtatatccacg
+tacgccagtgtgcagtgtagccatgcgaccacgggcgttgtgaatattcttcctcagaaa
+aggactgttgagcaaggaattggattctgtgaacggaatatagtcgagtagatggaattt
+cctacactgcgaaaaggtcatagtaaatcaaacgccgcgcgcagacatatcttcttggca
+attagtactccactaaatcaattggttataaacttttagaatatctttatataagttcac
+tacttacgctgcgggtagtatatttaaagtgatgtcttaggaatcttatggcggcggaat
+aaacggcttgactatagataccctaattctggcataaccctgtaacgtgtgaagcatgct
+ttaatagacgactagatcagcttatagaatggatatgactgccacattgaagagattaac
+attagcgggtataatgttacgaacttgtttaacaaaatagctctaccacacacgcatagt
+ataatataaaggtcctggagttcgctacgagcctggaattgcagttcccctaccctgagt
+aaacaagatcagtatggacctatcttctgacccacgtgtaaaaactaccgttagcggccc
+tgagaacggtgaagttgattatcggctaacactcgctttaccaaggaacaaacaattgat
+ggaacaggtaagcggctggattctatcctgaatacagcataataatatttgctttcaata
+tatagttatgacactcccaatatcactaactctttacaaatcggatatgaagagtgaatt
+agagatggagccgatcgttccttgtattctggtaagtactcgactaatgtgtgtagtcta
+ggggtaaaggtccttaaccgtcgagtctagaactcacgcattatgaaatcctccgagcat
+agagactctaaattcgccaagcaataagtcccgacgcgaaggatgagaagctcattgaac
+tgtaacatttacgtcgggctcaccatgttacatatgcagcgggtaaaagtttttgcctgg
+agtggttgagtttcgcgatacataaaaggccccactttcatatggtcaaatatctatatc
+gtgctttggacgactcgataaactaaagtagcctagtaatgccctaaaccgctgcatttg
+tgcaataaaaaatttagagtatatataacttccggacgtatggctgccttgaatcctcgg
+atatcgtccttatacaacgatgaacggtatagctcggaactatgcagattaggcgatcct
+tgggttgaatttttagtttccatagatatgagttagttttgatatggttaccatacgtcc
+ctgcattgaaacttaatctgtatattgattgatccttagcaatagcggcacatttctggg
+caatatgacttaattaggttacggtttttactatgatggatacgttttatatgatagaat
+aacagttgctatttaaacaggtactacattcaactaatactgtttcactattgtgtccaa
+catagggaatatattgcctgaatagatgtattatcaggcatcttttacgctccaggtaga
+actaattaaaaatgatccttagaaactttcaagcaacataagctaaaagttacgccaatt
+ataagccacatcggtaggatcttcaggcattcccatatccttctctatcaatcccgtctg
+ttgctaattggttatctaagcatatcgcggcgagcatctacgataggtataaagttgctg
+ctatctaattcgtcataatatatacatggaattacagattcatacgtcttcagtctcgtg
+gtgtttctaagagcggacccaagaattacgtaatatctctctcgtgttacccaagaagtt
+gacacgtgattgtcagctatctttttctggcgatgttaatagttataaacaattgcatat
+agctgcaaattagctaatcaaatactcgtttcttaaatgttatcagcaaagctttaggtt
+ctgtaatttcactgtgtaaagagggcgctaagttcaaaattggtttttggcaacaaacaa
+tttaatagcgcagtgcaaaaataatatctcagggtgtaattatttctctaattggtcttt
+acggttggaccaggcaatgggttttttatctatgtgataccaattaaaagtaatttcaaa
+gtgacattaaacttaagtattgctgtcaagaccattacgacacttcaccaacacatttat
+gtattgtgctacgcggtatggcccgtagtaatttctgatattgaccgcgttatcagcaag
+tacgctgtacaaatgccaaatttagtaaagctctgtgtgcattccaaggtgcccacatca
+cacattatcaacatatcatgtcgttgtattacgtccttttactagcctgggaaataccgg
+tgattcagagtgaacataaatctctgaaagctactagacaaagctagtatagttaaaata
+tatatttcttttaatattaggatctttgcgattgcacatttcaagcatcgcattaaccta
+cctccgtactcttctacaacggttgcatgtacgatttctatgcgatgaaatacttatgtt
+cttagtttggggttactttgttcacctagtcctcgaacgcaaattagcttcgaatatctg
+aaaagtgtatgcgggcaccaaaacgatctcgattcttaggtttataattatagtcagaag
+ataaatacatgcatatctggacactcttccacatgtcatgtcgactaactttgaactaca
+gtcatatatagactgttatctgatccgtatgtgtctattactactcttatctgagaaagg
+acccaatggagtcacagtaagcgatcatgtcatcggggctttttccctgattataagatt
+acactattgctgtgcttggggcctcctactttttctatcttaatcattttgtacattaaa
+aagctaagaagtaggtacaacttatctttcccatacgagctggaccattaatttaacagc
+cgcaaggcgagttttaatgttaatctggaagggctttatgttctaagcttttagcactga
+gaaattaatccgtaggaaattaatcccacataacccggtaagagaaccttacgccccgtt
+actaataatgttctgcgcaatgtaggaagtgacaagctcactcttgcgacgagctcctta
+atacaggccctgcgttatattcgaccgtacctataactagaccaccatcttaaatgtaca
+gttatggttttcgacgcatagagtatgggaccacctcgaaatgctcagctgcaaattgta
+ctgggggtggttatcaaacatttaatatgaatctatggtaaagtactagtttatagatag
+ccgaacactaaaggtttgcagaccttcctcccctgaggaacttcgtgtcacaaattagat
+tgagaaggtggtgataaaatcgcgtatctacaatgatttggtgcaaatatttatcgattg
+cccaatcgttctactcgtactctttatagcctaacgccttttcttggcgctaattagcct
+aatccaagaaggagtctaacaaaattacttaaccatactcttgtctattcggcccacgca
+tgcgcaagctcaaaaagttctcaacgggcgtttttacttgagtcccaggaggtaacattg
+gatctatgagtcttaacagtggaaatatgatttttagattgtgttcagatttattgtctt
+attttggtctatctcatcagctatagctacataatgacgtcttaactgtttcgactaacc
+ttcagatctgactaccccaaatacaacatagcaaaagaatgatgctaacgcttaactatc
+ctttcacgatcttaacaaaaaagctccatttaaaagaatcgaaaacagatctaccattcg
+tggaatcaatttttggacgagtactggtcgggtcgtgcttatttgctacaggattgtttc
+gtataacgttcaagcactttagcggttccatccttgatggcgttaactgatgatgcgtaa
+gtttatggtgatctaaaactctactacgaaccaggtcccagcacgaaacgtcatctttaa
+tgagtttttaggtctccaggcactaggctgcgaagtggaatatgtgtcatcagagacaaa
+tagatgattcctatagctttttgcagttaagccactaagtaggcggttctatagggtttc
+attcaaatcgatcgtaattcccgactctgcatagcgtgggtcttgtatagaccattcttc
+aggcccgccacaatggtttcaagtttcaacttccgtttattggctgtccctcaatagagt
+cgttctcagggcacgactctcgttcgttattcataagtccagtttgatccacgaatacag
+aacacgcatatctgataataaaagcttaacgataactttcacgcgcatggtttatttttg
+atttattaggcaaccaaataccagaatgtagtcagcgatatgtagtaaaatttagacaaa
+cataaaacaaagtatcgccattacagtctcctgttaggagaacctttttatcaatatgtg
+taggcgtgtattggcgcccttgatttaataataattacggctaaacgtattgatattttc
+caggaactgccccatctcatgagatgaccctaaattttattcacacctcatttttaattc
+ttttatatcacgattatttatctgagcaagcatctttgcaagcattcatagtgacggtgc
+tgtctctatgaatgcatgctaatatacggtgcgctaaacatattggttcaattcaatgta
+agctacctcggaatttgcttgcactaagacggggaagccaaaacggtaaatcgccgtata
+tgctagtgccaagggacttgtccgttggagtcactatggagttacaagcattataaatct
+aaggaaatcgcagtatcagtccttaccccaaagatacttcgcattccctggggtacggac
+catgaaatacttctttcatacatgataaacgatggagactcggttaccaccctggtagtt
+actccatcaattggagttaactaagatcgctattacaggctttattagccaatcatcaca
+agcctctttttagagattcacaagttagcaaaccaaagttcctttgataagtctttaacg
+agatctatcccaattccggctaggagtaaaatttatatatttgagatcggggttaaagtc
+acacgcaatgcaaggggtttttatatggtaatgtccttccctaattaggtaattttcaga
+cctccgagagagagtagatcaacaacgcgttatactcctaaaatgcttgtcgataacatg
+acactacagatcatccctggatgagcatcgactttcattacttgattagttcagttaatt
+cgtttcaaaccattttcaacaaaatcccccagtagatatgtatatgcacatcttagacta
+aataacagttttcataccctgggatttgtgtcactatctcaggaacgtcgagacgtcccc
+tatcaccgcagcgagggtaactggccctgttccattgtaatcgatgggacgggacgttat
+attgcagacccaaagtagtaataaattcagccatatggacggagggggggaattgttaag
+aatataattcgattttcagctgaatgtaaaagctccagccattcctcctccacttgacat
+tagttcgaagaaggtctgagaattggaattgcttgtgacgttttttgtttccagacaagg
+aaatagcccagtaccaagtataatattatgacaatagaagcttaaattcacaacgtaaca
+tatctgttagcatgctctaatagaccgagaaaataagtgtctatgtgtgcgagaactgtc
+aattcacggcagtagtcacctaatctaacgtctagttcccgactatgaagtcttcacaaa
+tggttagtaataatttcccagtggagtagaagtggcataacgtgcactctctgttaataa
+tacctttagactactcccatttcgccagaacgtcttgatggtaccctatgggaaacactc
+acacatgcttattgcctgcaacctcagcaatgtgtcgtatgcggtatttctacgaacagc
+tagtgaaaggactgatgacctaattttggtttctcaagtccagacgtgatattttgatga
+ccgtatctgacatctctgggcaattcggttaacctctggtacgaaatagtccgtcgcgta
+ggtaaaaatgataatgctgtcatcactatcatgttttagctaagctacactaccccatcg
+ctcgcacgtggcaaagtgtgaggattccgatatcatccatgtgtacgaattcctaatact
+cttgctcagggcacttagggttattgtagcctgtgttaccgtctcgcatattagatcatt
+aatcaacagtcttataatcaccgtaatcggtaaacagttgttatttgttctgataggtag
+acagctaataaagatgctgttgaacagttacgtcccacctttattgccctacagtgaaac
+tagttcttactctgttgctgtaatatgtctagggttattgatttgctgccacttcaaaac
+ggaaattaagtcattaacgaaaatggttccttcataggtaaagatcaatccccaattgaa
+gccagaaattttgagatgtcgattcctgatcattcgccaaatttacagctcgtaaacgag
+ttccatgtgtaaaaaaatgttgagtccactagcttgtttattctggctcaaggtacgtgg
+aacacgtagtattttgatactaatgccagacccgctacgatccctgtactgtgagcagag
+ccgatcctcagaaatagctaaatcttgtgcttcgttagaagtctcgactacgtgtagcct
+agtgtttgtgttgcgttatagtctatttgtggacacagtatggtcaaatgacgtcttttg
+atctgacggcgttaacaaagatactctgggcaacacacatacttctctcatgttgtttct
+tcggacctttcataacctttcctggcacatggttagctgcacatcacaggattgtaaggg
+tctagtggttcagtgagcggaatatcattcgtcggtggtgttaatctatctcggtgtagc
+ttataaatgcatccgtaagaatattatgtttatttgtcggtacgttcatggtagtggtgt
+cgccgatttagacgtaaaggcatgtatggatcttgatctatgcaaaggtaggtccatcta
+tatacgttgcacagcggatacaaataagataagaatttactaacatttaaattttcttat
+tgtcgagcatagattggaggaaaaacttatttacttggtatttaaacggaagtttctaat
+gtttatgattggatgcacggacagtttactgcttactttcttaggtttcttgaacaacag
+gatgcactagtaacatgtctcgttcatgcttccattaagttcttcttaaacttacacaaa
+ctacctaatttagagttgacgagatggttgaacgtgttgtgacaaacgtttgcaaaatgc
+acagtatcgttaccaaaaagtacatttaagtgtgtgcgtaggaattctgctacgtccatt
+gcaggccacattcacatcccacccctgaatatatggactgaatcacacacaccaaatttc
+atctaccttatcgtagcataactattaacaaacatatacagacttcgcggtaaataaaat
+atattagtacacaaccgtatactggttgaactattgcccagctttaagacgcttttaact
+aggtgcttgatcaagaagtattattatatgacggcagtgtgtaatacctgaatagatata
+gacgttagattgtctgaaaacacgccgtagagacatttttgttagatatgtatttctttt
+tgacgagccagcatcttagtatctgaagacgagctatatgtttgtagaaaatcgactgac
+attgtatacgaggcggcgtaagattaaccaaattccccagaattagtaatggcgccttat
+cgatttactaacgatatataacttgtgatgttgtctgcaatgtatacccgtgtaggctgt
+gctcttatcgaaggaaacgcattgaagtccaggctggatgaaaccaccgcgtacttccat
+gcgtctatacatagcgtcaccgatactacgttttgctatgtaatccattctaatgggtaa
+gaggattcctcttatagtaaaatatgcttgactttttaagaaccattgggagtggttggc
+aaaataatagtgggtgtctttctcagtgtatagttttctacaactacccctattaggtta
+caagtaatctggctttcttgccacttggcgatgatagttagattcgtatttctacaacgc
+agttactgtatccatggcgcgagataattagatacgatttgaatttggatgtagactcgt
+tactactgttgtagaccagcacgtgagtatctagatgggtttgctaccttgttagcggac
+ttttgccgggaaaaagacatacgtacaaccgtatattttactataagcagtattggccac
+cctcgtattgcggcagggtgtgctcacctggttaaaatgaaagagaaaaattccatttta
+aaacccggaggaatctattactgacgaggaaggtgtttaacccgttgagacatctcctaa
+cgtaaaaggttcatattctagttattccgagagtcactttcctatccaaacatgaactga
+tagcataatgacaggttgaatggaaagcatatcctgtttattctaaatctgtttcgctaa
+tcaatatgctgtcacgaactcggagcttacccttacaactatgtgttctgtttaccaggt
+gctaatatcccggcactcttttcatgcatgtcgctcctagcgtcatctgatttaatagct
+taatgtctcatattttacagtagccagtgtagtatggaaggcggcgaaccagcccctaca
+ttgggtttcctgacataagtattacatatcacttgtctgattacacagcaaaatcgctaa
+ccttactttgcgcatgtagctattggaactttgggctagtgtctatcccattaagtttaa
+cagtagactagtccgtgagcgatcaccgagcttatgtctcgtacccaagttttggatttg
+gatcaaaaactactcgatattcatgatctacgggcttcctttctccgggtatcattgcgc
+cgagattaaaaataaaacgatagcgctgtgaaaacatgtttgacacgggatagcgtagaa
+actaaacaacgaatagaccatccaatttgaattttattgggtccagcacttcgccatagt
+gttgaatggtaaagttcgaaaggaaatttgttatattaattctgctacattttcgaccac
+ttgtatctcaaggacaatatcccttgaggcttttagcagaaagagatgccgtaattctaa
+gggatgataataggttgggaaatttaagagcagtagtaacggtcgcgggttcgaccttaa
+actatatatttaaatctagccaaacaagttaacaacaaccataaagttatgaccttatta
+tattggcaagcttaacgttttaattgctctagtaatagagtggtagaggtaagggaccat
+cacctgattcttcctccgcaaccattatatagacgtgtcgtctgacaaatttcgagataa
+aacattcgtccttagcaacgaatatcgaatggcaattagccacattgagttaaatagttg
+aggatatttcttgcacagaatcagatctaatctaatgattcgttactaaacacttcacca
+ggtatcgtgaaggctcaagattacccagagaacctttgcaatataagaatatgtatgcag
+cattaccctaagtaattatattctttttctgactcaaagtgacaagccctagtgtatatt
+aaatcggtatatttgggaaattcctcaaactatcctaatcaggtagccatgaaagtgatc
+aaaaaagttcgtacttataccatacatgaattctggccaagtaaaaaatagattgcgcaa
+aattcgtaccttaagtctctcgccaagatattaggatcctattactcatatcgtgttttt
+ctttattgccgccatccccggagtatctcacccatccttctcttaaaggcctaatattac
+ctatgcaaataaacatatattgttgaaaattgagaacctgatcgtgattcttatgtgtac
+catatgtatagtaatcacgcgactatatagtgctttagtatcgcccgtgggtgagtgaat
+attctgggctagcgtgagatagtttcttgtcctaatatttttcagatcgaatagcttcta
+tttttgtgtttattgacatatgtcgaaactccttactcagtgaaagtcatgaccagatcc
+acgaacaatcttcggaatcagtctcgttttacggcggaatcttgagtctaacttatatcc
+cgtcgcttactttctaacaccccttatgtatttttaaaattacgtttattcgaacgtact
+tggcggaagcgttattttttgaagtaagttacattgggcagactcttgacattttcgata
+cgactttctttcatccatcacaggactcgttcgtattgatatcagaagctcgtgatgatt
+agttgtcttctttaccaatactttgaggcctattctgcgaaatttttgttgccctgcgaa
+cttcacataccaaggaacacctcgcaacatgccttcatatccatcgttcattgtaattct
+tacacaatgaatcctaagtaattacatccctgcgtaaaagatggtaggggcactgaggat
+atattaccaagcatttagttatgagtaatcagcaatgtttcttgtattaagttctctaaa
+atagttacatcgtaatgttatctcgggttccgcgaataaacgagatagattcattatata
+tggccctaagcaaaaacctcctcgtattctgttggtaattagaatcacacaatacgggtt
+gagatattaattatttgtagtacgaagagatataaaaagatgaacaattactcaagtcaa
+gatgtatacgggatttataataaaaatcgggtagagatctgctttgcaattcagacgtgc
+cactaaatcgtaatatgtcgcgttacatcagaaagggtaactattattaattaataaagg
+gcttaatcactacatattagatcttatccgatagtcttatctattcgttgtatttttaag
+cggttctaattcagtcattatatcagtgctccgagttctttattattgttttaaggatga
+caaaatgcctcttgttataacgctgggagaagcagactaagagtcggagcagttggtaga
+atgaggctgcaaaagacggtctcgacgaatggacagactttactaaaccaatgaaagaca
+gaagtagagcaaagtctgaagtggtatcagcttaattatgacaacccttaatacttccct
+ttcgccgaatactggcgtggaaaggttttaaaagtcgaagtagttagaggcatctctcgc
+tcataaataggtagactactcgcaatccaatgtgactatgtaatactgggaacatcagtc
+cgcgatgcagcgtgtttatcaaccgtccccactcgcctggggagacatgagaccaccccc
+gtggggattattagtccgcagtaatcgactcttgacaatccttttcgattatgtcatagc
+aatttacgacagttcagcgaagtgactactcggcgaaatggtattactaaagcattcgaa
+cccacatgaatgtgattcttggcaatttctaatccactaaagcttttccgttgaatctgg
+ttgtagatatttatataagttcactaattaagatcacggtagtatattgatagtgatgtc
+tttgcaagaggttggccgaggaatttacggattctctattgatacaatttgtctggctta
+taactcttaaggctgaaccaggcgtttttagacgacttgatcagctgttagaatggtttg
+gactccctctttcatgtcagtaacatttcagccgttattgttacgatatgcttgaacaat
+attgatctaccacacacccatagtatattttataggtcatgctgttacctacgagcatgg
+tattccacttcccattcaatgagtattcaacatcactagcctcagagatgatgacccacc
+tctaataacgtcacgttgcggccatgtgaaacctgaacttgagtagacgatatcaagcgc
+tttaaattgcatataacatttgagggtaaagctaagcggatgctttatataatcaatact
+caataataagatttgattgcattttagagttatgacacgacatagttcactaacgagtta
+ctattcccagatctagactgaagtactgatcgagacgatccttacgtcgatgatcgttag
+ttatcgacttaggtcgggtctctagcggtattggtacttaaccggacactatactaataa
+cccatgatcaaagcataacagaatacagacgataatttcgccaacatatatgtacagacc
+ccaagcatgagaagctcattgaaagctatcattgaagtcccgctcacaatgtgtcttttc
+cagacggtttaactggttcccgggagtcctggagtttcgacttacataaatggaaacaat
+gtattttgctaatttatctatagcgtcatttggaccaatacagaatattatgttgcctag
+taatccactataacccgcaagtgctgatagaaaatttttagacgatttataaatgcccca
+agtatccctcccgtgaatcctccgttatactaattagtattcgttcatacgtataccgcg
+catatatgaacatttggcgataaggcgcgtgaattgttacgtgacagagatagcagtttc
+ttgtgatatggttaacagacgtacatgaagggaaactttatatctatagtgatgcttccg
+tagaaataccgccactggtctgccaatgatgaagtatgtagctttaggtttgtactatga
+ggctttcgtttgtttgcagagtataacagttgcgagtgaaaaaccgacgaatttatacta
+atacgctttcactattggctacaaaatagggaagagtttcaatcatgagagggagtatat
+ggatgctttgtagctaaaggtagaacgtatgtatatgctgccgttcattcttgaaagata
+cataagcgataagttacgacaattataagcaacatccctaccttcgtaacgatttcactg
+ttactgcgcttgaaatacactatggggctattggcggagagaagcagatcgcgccgagca
+tatacgagacctataatgttgatgatagagaaggcgtctgaattgatacatcgaagtaca
+ctttctttcgtagtatctctcgtcctctttctatctccggacacaagaattaagttatat
+atatagagtcttaccaatcatgttgaatcctgattctcagagttctttggcgggccttgt
+gatgactgagaaacaatgcaatattgctccaaatttcctaagcaaattctcggttatgtt
+atgttatcagcaaagcgttacgttatgttatttaaatctggaatgacggagcgaagttct
+tatgtcggtgtgggaataattcttttgaagacagcactccttaaataatatcgctccgtg
+tttgtatttatcgaatgggtctgtaaccttgcacaagcaaatcggtggtgtatatatcgg
+ataacaattaatacgatgttcatagtgacagtatactgatcgagtcctctaaagtcaatt
+acctcacttaacaatctcattgatgttgtgtcattcccggtatcgcccgtagtatgtgct
+ctgattgaccgagtgtgaaccaaggaacatctactaatgcctttgttaggtaagatctct
+ctgaattccttcgtgccaacttaaaacattatcaaaatttcttctacttggattaactac
+ttttacgagcatggcaaattcccctgtggaagacggttcattattatcggaaaccttata
+gaaattgcgtgttgactgaaattagatttttattgtaagagttgcatctttgcgattcct
+ctggtctagcttccaatgaacagtcctcccttctattcgacatcgggtccttcgtacatg
+tctttgcgatgtaataattaggttcggagtgtggccttaatgggtgcaactaggaataca
+acgcaaatttgctgacatgatagcaaatcggtatgccggcaccaaaacgtgctccttgct
+tagcttgtgaatgagactcagtagttaaataaatccatatctgcaatcgattccacaggt
+attgtccactatctttgaactactctaagagatacaagcttagctgagaccgaggtgtat
+atgactacgctgatatctgtaaggtaccaatgcaggcaaagtatgcgagaagctaatacc
+ggctgtttccagctttataagattaaaatttggctgtcctggcggcctcagaattgttct
+atcgtaatcagttggttcattaattagctaagtacgaggtacaacttatctgtcccagaa
+cagctccacaagtttttttacagccgaaacccctgtgtgaatcttaatatccaagcgcgt
+tatctgattagagtttacaactcagtattttatcagtacgttttgtttccaacattaccc
+ggtatgacaaaatgacgccacgtgtcgaataatggtctgaccaatgtaggaagtgaaaag
+ataaatattgcctacacatactgaattcaggcaatgcgttttattcgaaaggtcatataa
+ctagaaaacatgatgaattcttatcggatccttttactagcatagtgttggcgaacacct
+cgtaatgctcagcggcaaattggactgcgggtccttatcatacattttttttcaatatag
+gcgattggtctaggttagtgattccccaacacttaaggtttgctgacattcataccctca
+gcaacttcctctcaaaaattagagtgagttggtggtcttataagaccgttgattatttga
+ggtggtcaaatgatggtgcgatgcacaaatcgttataatcgtactctgtagacaataacc
+cattgtagtgccgattttgtgcataatacaagaaggaggatataaaaatgacttttcaat
+aatattggctattagcaacaagaaggagaatcctcattaagttagcaaccgcagggggta
+ctgcagtccaaggaggtttcattggagagagcagtatgaaaacggcaattatgattgtga
+gattcgctgaagattgtgtctctgattttcctagatagaataagctatagctacttaatc
+aactcttaactgtggagactatcctgatgatctgaataccccatttacaaaattccatat
+caatgaggctaacgcttaaatttcatttctccatcgtaacaaaaatcagcctttttatac
+aagacaaaacactgcttccattacgggtagcaatggttgctcgactactggtagcgtcgt
+gatgtggtgataaagctgtcttgcgtttatacttaaacaaattttgacctgacataatgg
+agcgacttatcggatgttgccgatctttagggtcatctattaagcttatacgaaaaaggg
+acaagcacgttacgtaatctggtaggactgggtacctagaaacgcaagaggaggcgaact
+ccaatatctgtaagaacagaaaaatacaggagtccttttcatttttcaagttaacaatat
+aagtaggagcttagagaggcttgcatgaaaatcgttaggaattacagaataggcagagag
+tggggcgtgtagactacattcttcaggccccacaatatgggttataggttaaactgcact
+ttttgcgatctcccgaaatactgtcgttctctgcgaaccacgctcgttccttttgctgta
+gtccacgttcatccaactattcagataaacaagatcgcagaattaaagcttaaccatatc
+ttgatagcccatcgtgtatggggcatgtatgtgcaaacaaaagacctcaatcttgtctgc
+gagagggaggaaaatttagacaaacataattcattctttcgactggacacgctaaggttt
+ggacaaactttgtatctatatctggaggcctgtattccagcccttcttttaataagattt
+acggcttaaactatggatatttgccaggaaatgacactgctattgacaggaacataattt
+tgattcaaacctcattgttaattattttatatctcctgtttttatatcagaatgcttctg
+tcctagaaggcatactcaaggtgagggctcgaggaatgaatcataatagaccggccccta
+ttaatattggttcaattctttcttacataacgcggaatttgattgcacgaacaccgggaa
+cacataaccgtatagcgcccgttatgctagtgcctagcgactgggaccgtggagtctata
+tcgtctttctaccattattaatctaaggatataccactttaagtcctttcaactaacata
+aggcgcattccatgcgctaaggaccttgaatttattatttcttacatgataaaagatcga
+gtcgacgggaacaaaaggctacgtactcaataaagtgcagtttactaagagccctttttc
+tggcttgtggagactatcataacatgaagatgttttgacattcaatagtttgcaaaacaa
+acttactttgtgtagtattgaacgagatctttccaattgccccatagcaggaatagttat
+atattgcagatcgcggtgtaacgcactccaaatccatcgcggtgtgtgagggtaagcgac
+ttaaagaattacggtttttgatcaaagcacagtgagagttgagcaaattacagttatacg
+acttaattcagtctccataaattgaaacgacacttcttaacgggaggaccagacacgttc
+attaagtgaggagtgcactttttgactttaaaaacatggtaatcaatttaaaccacttga
+tatgtatatgaacagatttgaagttatttctgttttaatacactgggagttctgtcaata
+tcgcaggaaccgcctgacgtcccctatcacacctcagagggtaaagggacaggggaaagg
+gtaatcgaggggtagggaacgtagttggcacacccaatggacgaataaatgctgccatat
+ccacggagggcgggattgcggttgattttaaggcgatggtaacctgaatgtaatagatca
+tcaaatgcctcctccactggaaattactgcgtacatccgctgagaattgcaatggagtgt
+ctcggtttttctttaaacaaaaccaaattgacaacttcatagtataatttttgcacatta
+caagcgttaattaacaaacttactttgctgttagctgcctatatttgtccgacaatataa
+ctggatatctctgcgagaactgtaaattaacggcacttggaacataatagttcctattgg
+taacgacgttgtaggcggcaattatccggtggaagaattgacaactgcagttgaactgca
+tgaaagtcaaatctctcgtaagtataactttagaagactccaaggtacccagaacctctt
+cagcggacacgatcgctatcaatcaataaggattattcactgaaaccgctcatatctgga
+ggtggacgtttttcttcgaaaagcttgtcaaaggactcatcaaatttttggccgtgctaa
+tcgacacacctgttattttcatgaccggataggacatctcgcggaaattcgggtaacagc
+tgggtagatataggacctcccctacgtattaatgataagcctgtcataactagcttggtt
+taccgaagagacaataaacattcgagcgctcgtgccaaactcggtgcattacgtttgaat
+aaatcggtaacatgtactattactctgcctaacggcacttacccgtttgggtccatgggg
+taaccgctcgatgttgacagaattatgctaaagtcgtttaagatcccgattaccgaaaat
+ctggttatgtctgagcattcgtacactgcgtattaagatcaggttgaacaggttcctaac
+aaattttgtgacctaaagtgaaactaggtcgtactctgggcatgttttatgtcgtggcgt
+atgcatgtgctgacacttctaaaaccaaattaaggctttatccaatatgggtccttaagt
+gctaaacatcattcacaatttcaagacagattgttggtcttgtcgattccgcatctgtcg
+ccaaattgacacatcgtaaaccaggtacatcggtaattatatgttgactaaactaccgtg
+tgtattctggctctaggtacggcgaacaagtacgatgtgcttaagaagccctcaccccag
+acgagcccgcgtaggtcacatcagcagatcctaagtaattccgttttattgtcctgaggg
+agtaggatcgacgaactctacaagtcgctttgtcgtgccttataggctatttcgggtcaa
+tgtagcgtcaaatgaactattgtcatctgtacgagttaactaagtgtctatcgccaacta
+aaagacgtctcgatggttctttatgcggacctgtcatatcattgactggcacttgcttac
+atccaaataacacgtttgttagcggatagtcgttaagtgtgcgcaagatcatgaggcggg
+gggggtaatatttcgccctctacatgataaatgaataagtaagaagatgatctttttgtg
+gcggtaccttaagcgtactcctgtcgacgagttactactaaaggaatgtagggttctgga
+tctatgaaaagcgacctccatatatatacgggcctaagcggagtaaaataagtgatcaat
+ggactaacattgaaatgttagtattgtcgaccattgagggctggtaaatcttatttacgg
+gcgtgggaaaacgaacgtgatatggtttagcatgggatgcaagcactcgttaatgcttac
+tttagttggttgcgggaacaacaggaggctatactaactggtagcgttcttgcttccatt
+atgttattattataattaaaaataagacatatggtagagttgtagtcagggtggatcggg
+ttgtctataacgttggaataatcaaaactatcgttaacaaaaacgaaatttaagtcggtg
+cggtggaatgcgcctacctcatgtgcaccacacattcacagcacacccctcattataggc
+aaggaagcaaacaaaaaaaagttaatcgaccgtatccgaccttaaattttaaaataaata
+gaaacacttagcggtaatgaaaagataggactaaaattcactagtatcctggaacgaggc
+aacagagttatctagatggtaacgaggtgctgcatcaagatgtatgatttttggtccgct
+gtgtggaatacctctattgatatacaagtgactttctcggtaataacgcacttcacaatg
+tgttgtttcttttctatgtattttgcaagagaaagaagcttagtataggtacacctcaga
+gatgtttcgtgtaaatcgtatcacatggtataactgcaggaggaacattatccaaattca
+ccacaattactaatccacccttttacttttactaaagatatattaattctcatgttgtct
+gaattgtataacccggtaccctgggagcgtatcgaaggataccaattgaagtcctcgagg
+catgttacaacacacgacttccttccgtctattcagacactcaacgagactaacttttcc
+taggtaatcaatgatattgggtaactcgtggcatcttatagttattgatccggctctttt
+gtagatcctgtgcgactcgtgcgctaattaagactggctctcttgcgcaggggatacgtt
+tattctacgtacccgatttggttactactaagcggcctttcttcaaacttgcagttgtga
+cttacattcctatttcttcaaagcagggaagggttacagggagagacttattgagatacg
+attggaatttccatgtacaatcgttaatacgcttgtagaccagcaactcagtatagagat
+ccgtttcctaaagggtgagcggtaggggcaaggcaataagaaattactaaaaccctagtt
+gttaatataagaacgattcgaaacaataggattgcccaagggggtgcgaacatggtgtaa
+atcaaagagaaataggcattgttaaaacccgcacgtttctagtacgcaagaggaacgtcg
+gtaaccagttctcaaagatcctaacctaaaaggggcttattctactttttccgacactca
+atggacgagacaaacatgaacggatagctttaggtctcgttgaatgcaaagaatagaatc
+gttattattaatcggtttccattatctatatgcggtatagatctccgagaggaccctgta
+aactagctctgcggtttaactggtgctaatagaccgccactatgttattgcttctagctc
+ctagcgtcttatcatgttatacattaatgtcgcatattggacagtagccaggcttggatg
+gatcgccgacaaaaagaaaagactttccctgtaaggacttaactattacatataacttgg
+atcattaatctgcaaattagagtaacggtctttcaccagcttcatattccaacgtggcgc
+tagtcgatatcccatgaagtttaaaactagaattggcagtctcacttcacagtgcgtatc
+tatacgacaaaagtggtcgatttgcataaatatcttatcgatattcaggttattaccgat
+tccttgctaacgctagaagtcacaccagagtaataataattccagacacctgtgaaataa
+tcggtcactacggatagactagtaacgataatacgtatagtccataaaagttgaatttta
+ggggctaaagatattagcaatactggtctagcctaatcgtcgatagcaaagggctgtgag
+gatttctcctacattttcgaccaattgtatcgataggaatagttacagtcacgcttgtag
+atgtaagagatgacgttattcttagggttcttaagtcggggggtaatttaagaccactag
+taaaggtagaggcgtacacagtaaacgatattttgaaatcgtcaaaaaaaagtttacaac
+atcctttaagttagcaactgattttagtggcaaccttaacggttgaattgatctactaat
+acaggcctacaccgaagggtacagataatgattcttactaccctaacatgatagagtcct
+gtcctatctcataggtcgacattttaaattcgtaatgagcaacgaagatcgtttcccaat
+ttgcaacattcacttatagacttcaggttatttcgtgctaacattaagatagaatataat
+cagtcgttaagaaactattatccagctttcgtcaaccataaagattaaaaactgaaactt
+ggcaagatatgaatagctatcctgctttaaccgatcgtatgagatgctttgtagcaagaa
+aagtgactagcacttgtgtttagtaaagcgggagagtgcggtaattaatattaatatact
+attaagctacacagcaaaggctgcaataatgttagtaagtagaacataaaggtattctcc
+acaagtaataaatagtgtgagctaattgactaacttaactctcgcgacaagtgatgtgga
+taagatgactcatatcgtctttttctgtagtgccgacatcccacctggatcgaacaattc
+cttctagttatcgactttgattacctatcctattaaacagatagggttgtaaagtcagaa
+aatgatcggcttgcgttggtctaccatagctagagttagaacgcgtagatagaggccttt
+tgttgccaacgtgggggtgggatgagtctgggcgagcgtgactttctttcgtgtccgaat
+ttgtttaacatccattagattagatgtttgtgttttgggtctgatgtcctaactactttc
+tcagtgaaactaatgtcatcatccaagtaaaatagtccgatgaagtctccgttttcggcc
+gaagcttgtctataacgtatataaagtcgctgaatttagaacacaccttatctatgttgt
+aaagttactttattccaaaggacgtgcacgaagcgtgagtgtgggaaggaacttaaagtc
+ggatcactcttgtcagtgtagataagaatttctttcatacttcactggaatccggcgtat
+ggatatctctaccgcgtcatctggtggtgtctgcggtaaaaagtcttgctgcacgagtct
+gagaaatttttggtgccatcacatcgtaactgtacaacgaacaaatagcatcaggccttc
+ttatccagcgtgaagtctaattatttcacaagctttcctaagtatgtaaatccctcactt
+aatgatgcttgcgccaatgaggatagaggacattgcatgtacgtaggactattctccaag
+gggtcttctattttgttagcgaaaattgttacagcctaatgttagagcggcgtacgactt
+tataccagatactttcattagatatgcaaatatccaattaaatcatagtagtatcgtggt
+atggacaatcaaaaaagacccgttgtgatatgatgtttttctagttcgttctcatatata
+tagatcaacaatgaataatctcatgatctataaccgatgtatatttatattccggttgac
+tgctccggtgcaattcactacggacactaatgactaatatggcgcctttcatcagaaacg
+ctaaatatgattaatgaattaagggagtattatctaattattagagagtagcagttagtc
+tgatattttcggtgtatgtgttagccgttataatgctgtctttttatcagtgagaacagg
+gagtgtgtagtgttgtatgcttcactttatgactctggttatatccctcggagaacaaga
+ataagagtacgagaagttcggtcattgaggatgaaatagaaccgctagacgaatggactc
+acgtttataaaactatgtatcacagtactacagctaactctgaagtccgagaagcttttg
+taggacaaaacgttataagtacctttcgcagaatacggccgtgcatacctgttataaggc
+gtagtagggacaccatgctatccctcatatagagctacactaataccattacatggtgac
+tatcgtttacggccatcatctgtaagcgatcatgcctcgttagcatccgtacaatctcgc
+atggcgtcactgcagaaaaaccccgtgcggattttgagtcagaactattcgaagcttctc
+aatccttttccattatggcatagcaagtgacgactcgtcagccatgggaataatagcact
+aatccgattacttatgaattagaacccacatgaatgtgattctgcgaattgtctaagaat
+ctaatgattttccggtgaatatggttgttgttatttattgaacttatattattaacatca
+cccttcgttagtgatagtcagctatttccaagaggttccccgagcatttttaccattctc
+tagtcatacaagttggagcgcttttaaatctttaggctgatcaaggcgttttgtctagaa
+ttctgcagatgttagattcgtgtgcaatccctcttgcatgtcagtaacaggtcacccgtt
+tttcgttacatatgctggtaaaatattcatagtaataactacaatacttgatttgttacg
+taatgctcgtacataacacaatcgtattccacggaacagtaaagctctattattctgatc
+gagcctaagagaggatcacactacgctattaaagtcacgttcacgaaatctcaaacctca
+actgctggtgaccagttatagacagtgtaattccatattacatgtcaggcttaagctaac
+ccgagcctttatataagctataatcaagaattagattggagtgcattttagacttatcta
+tcgaaatagtgatagtaagagtttatatgacctgatctagactgatgttctcttccacaa
+cagccttaaggcgtggagcctttcttatactattaggtcgcgtcgagagccctattcgta
+atgttaacgacactagactaatatacaatgagctaagaataacacaagtcacaagataat
+ttacaaatcatatatctacagtccacaaccatcactagcgattgcaaagcgttattggta
+ctaccgctctaaatcggtatgtgcaagacgcgttaactggttcaagcctctcctgctcgt
+gagactgaaagaaatcgaaaatatggatgtgcctaattgttcttgtgagtcatgtgcaac
+tatacagtttagtttggtcaagactatgcaactattaacagcatgtgcgcattgaatatt
+tggtgtcgattgataaatgccccaacgttccatcacgtctataagccgtgttactaatgt
+gtattagtgcatacctattcagaccatagttcaactgttggactgaaggcccgtcttggg
+gttcgtgaatgagagtgcagtttcttgtcttttccttaactgacctaaatgaaggcaatc
+ggtttatctagagtcatgcttaaggtgaatttcagccaatgggctcccattgagctagta
+tggtgctttacctttgtaagtggtggctttccttggtgtgctgactttaacacggcagag
+tgattatccgaagaatggataataagacgctggcaatattggctaataaagtccgatgag
+tttcaatcatgactgcgaggagatccatgcggtgtacctaaacctacatcgtatgtattt
+gctgacgttcattcttgatacataaagatccgatatcggtccactttgtttaccaaaagc
+cctaccttcgtaacgatggaaatgtgaatgagagtgaaatacacgatggggatattgccg
+gtgagtacaagttagaccacacattagaactgacctatattcgtcatcatagagatggag
+tatgaattgattctgcgaagtacactggctttacgagtatctagacgccgcggtatatct
+cccgtcaatactatgaaggtatatatatagaggctgaaaattcatgttcaatcctctttc
+taagagtgagtgggagccccttctgttgtcggagtaaaaaggcattattcctcaaattgt
+cagaagcaaagtatacgtgatgtttgcttagaacaaaagagttaccttagggtaggtaaa
+tctcgattcaccgagagaagtgattttggcggtgtgcgattaattcttttgatgacagat
+ctcattattttatatagctccctctttgtatttagagtttgcgtaggtaacctggcaaaa
+ccatatcccggggggagagtgcgctgaacattttatacgatgtgattactcaaaggataa
+ggttcgaggcctctatactcatggaactatcttataattataatggatcgtggctcattc
+cacctatccaaacttctttgtgatctgatgctacgagtgtgaacaaacgtacatcttcta
+aggaatttgggacgtttcatagctcgcatttcattcctgaaaacttaaatatttttaaaa
+attgattctactgcgaggaactaaggtgtagacaagcccttagtaaccggtggatgtcgc
+ttcagttttatagcaaacattattcaatttcagtcttgactgaaattagtttgttagtgt
+tagaggtccatatgtcacatgcatatggtctagatgccattgtacagtaataccttagat
+tagtattagcggcatgcgtacttggatttcacttgtaagaatgagcttaggacggtcgcc
+tgtagggctgcaaataggaatacttacaatttttgatgacttgttagcatatcgctatca
+cccataaaaaacctgatacttgatgagcgggtgattgagactatgtactgatataattca
+atagctccaatagatgaaacagctatgcgcctatttatgtcaaataatcgatgtgataca
+agcttagagctgaacgagcgcgagtggaattagcggtgatctctatcctaaaaagccacg
+aaatcgatcccagaagctaatacccgaggtgtcaagcttgagttcagttaaatttgcatc
+tcatgccccacgaagaatgggtagagagtttgaaggtgcttctggattttcctaagtacg
+tggtaaaaatttgatgtaaatgaacacctcctaatggttgtgttaaccacaaacccctgg
+gtgaatctgattagccaacccagtgatctgatttcagttgtcaaatctcttttttataac
+taccttttgtttccataatttaaccggatctcataatgaacaaacgggtagaataatggt
+agcacatagcgagcttgtctattcagaaatatggcctactcagaatgtattctccaaatc
+agtgttatgcgaaacgtaattttacgtgtaataatgatgatttcttatcggttccttgta
+ctacaatactcttgcccaacaaatactaagcataacagcaaaattcgaatccccctcctt
+ttaataaatggtttttcaatatagccgattcgtattcgttagtctttcaccaactattaa
+cctggcatctaattaataaaatcaccaaaggactctataatatgacagtcacttcggcct
+cttttaagacagttgattattgcaggtccgcaattgatggtgacatgcacaattagttag
+aatccgactatggagacaattaacaattgtagtgcccatttggtccagttgacttcaacc
+acgagttataaaggtattttaatttatagtcgatagtaccaacaacaagcacaatcataa
+ttatgttagaaaacccagggggtaatgctctaaatccagctttaaggccagagtgcacta
+tgaaatcgccattgatcattgtgtcattcgctgaacttggtgtctaggaggtgccgagtg
+agaatatcagataccttatgaagcaacgattatatctggactagatcatgatgatcggaa
+taaaacattgaaataagtccttatcaaggagcataaacattttatttaatttatacttcg
+taaataaattcagaattttttttcaagacattaatctgagtaaatgacggctagaaaggg
+ttcctactcgaatcgtagcctacgcatgtgggcagtaacctggcttgcgtttttactgaa
+acaaaggttcaccggaaagaaggctgccacttttagcttcttgacgatctttagcgtcat
+atttttagattagtcgaaaaacggaaaacaaacttaacgaagctggttgcacggggtacc
+gagaaaccaaagagcaggacaactccttgatcgggaagaactgaaatagacagctgtcat
+tttcattggtcaacttatcaatataacgaccaccgtagtgacgcttgcatgaaaatactg
+aggatgtaaactatagccagtcaggcccgcgtgttgactaattgatgaagcaaacaaaat
+agccggtattcgttaaaaggaacgggttgccagctacagatatactctaggtatatccca
+aacaagagacgtcctttggctgttgtaatcggtcataatacttgtcacataaacaagatc
+gctgaattaaacattaaacagttagtgatacacaatcgtggttggggctgggatgtgcaa
+taaaaagtcatctatcgtctatcacagagcgacgtaaatttagacaaacattattatttc
+ttgacaatggaatcgataagcgttcctctaacttggtatatatatctcgaccccgggatt
+ccagccattcttgtatgaagatttaaccatttaactatgcatagttgaatggtaaggaaa
+atgatattgactgcaacagattttggatgcaaaaatatttgtgaattattggttatatac
+tggttgtatagcacaatcattaggtcctagaaggcatactcaacctcagcgagagagcta
+gcatgcataattgtaccgcccatattaatattcctgaaatgatttcttacattacgccca
+atttcagtcatcgaacacccccatcaatttacccgatagagaacgtgatcatacgcaata
+ccctatgcgaacgtccactctatagcgtctgtatacaatgattattcgttccatttacaa
+cgttaagtaatttaaacttacataaggacaaggaaatccgcgaacctcctggaatgtatg
+agttatttatgcagttaacttcgtctcgaccggaactaaaggcgtcgtacgaatgaaagg
+ccacttttagaagagacctttgtatccattgtggagaatatcataaattcaagatggggt
+gtcatgctattcggtcctaaacattcttaatggctgttctattgttagtctgatttaaaa
+tggaaccatagcacgaatagttagatagggctcatacccctgtaacgatctacaaatcct
+tccccgggtgtgtgcgttagcgacggaaagttttacggtttgtgatcaaagaacactcac
+acgtcagattattacactgatacgaattatttcagtcgacagtaattgaatagaaactta
+ttaacgccagcacctgacacggtaagtaaggcaggtctgaactgtttgactgtaaaaaaa
+tggtaatatttttaaaaatcttgatttctatatcaaatgatgtgtagttttttctctgtt
+attaaaatcccagtgcgcgaaatttagatcgttacgactcacgtacaagatcacacatca
+cacgcgttagcgaaagcggaatggctaatacagccctacgcaacgtagtgggatcaacat
+atggacgaatttatgctcaatgagccaacctcccccgcattgcggttcattttaaggcct
+gggtaacatctatcgtttagataatcaaaggaatccgactatgcaattgtctgacttcat
+ccgctctcaagtccaatgcaggcgctacgtgtttctttaatcaataccatattgaaatcg
+taatacgataattgttgctattgactacaggttatgaaaaaacttactttgcgggtacat
+gcatatttttgtaccacattattacgcgatatctctcagtgtactctaaattaaaccctc
+ttcgaacattttagttcctattcgtaaacacgtgctacgcggcaatttgccggtcgtaga
+atggacaactccagttcaactgcatgtaactcatagctcgcgttagtataaattgactag
+tagccatgggacaaagtaactagtcagcggaaaagatccctttaaagatatatgcaggtt
+gcaagcataaagctcattgctcgaggtgcaccgtggtattccaaaagcgtctctatcgta
+tcttctaattttgggccgtgagaatcgaaactactctgatttgctgcacacgttaggtaa
+tatcgcccattttcccgtataagctccgtacttatacgaactacacgaccttttaagcat
+tagccgctcatatcgtgattcgtgtacagatgagtctattaaaattacagacatactcca
+tatctcgctccttgaactttgaataatgcgctaacttgtactatgaataggcagaaccca
+actttcccgtttgcgtcaagcggggaaacgatacatgttgtcagatttatgattatctag
+ttttagatcacgtttaccgataatcggctgtggtctgagcagtcctacactgagtattta
+cttcagcttcatatcggtccgaaaaaaggttgtgaccgaatgtcaaaatacggagtacga
+tgggcatcttttttcgagtcgcggttgcagggcagcaaaaggcttaaaccatttttacga
+tttttactatagcggtcatgaagtgcgaaactgcttgcaaattttctacacacattgtgg
+ctcttgtccttgaagcttatggcgaaaatttgaaacatagtataccagggaaagcgcgaa
+ttatttggtgactaatagtccgtgggtttgagccatatacctaacgccataaactacgtg
+gtgctttagatgcaatctaaacagaacagaaagcgtagcgctcatcagcacagactaact
+ttttcagtttgagtcgccggagggacttcgagacaagaacgcgtcaagtcgcttgcgcgg
+cacggattcgattgggcggctcaatcttgcctaatttctactattgtcagctgtacgact
+gtactaagtgtatagccccaaataaaagaagtatcgatgcgtctttatgaccaaaggtct
+tataattgaagcgcacttccgttcatcaaattaaatcctggcttacccgattctccggaa
+gtctgacctagagattgacgacggccgcgtattattgagacctcttcaggattaatcaat
+aacgaagtagttgatctgtttggcgacgtaccttaagccgactccgctacacgagtttct
+actaaaccaatgtagccttatgcttagatgaataccgtcctaattagatattccggcata
+acagcagtaaattatctgttcaatggacgaacattgaattgttagtattctacacaagtc
+aggcctcgtaaatattaggtaaggccgtgggataacctacgtgatatgcttgagcttgcg
+ttgcaagctctcgttaatcattaatttaggtgcgtgagggttaaacaccagcatattcta
+tatgctagacgtcttccttaaaggatcgtagtattataattaataataagaaatatggtt
+gacgtctagtcagcgggcatacgctgctctatatactggcattattcaaaacttgacggt
+aaaaaaacgaattttaaggcgctcacgtcgaatgagccgaactcatgggaaccaaaatgt
+cacagaaaacacctctttattgccaagcatgcaataaaaaaaatgttaatagtacgttta
+cgacattttattttataataaagagaaactattacacctattgatatgataggacgtaaa
+ttaacgagtagcctgcatagaggcaaatgaggtttctacatggtatagacctgatgctga
+aacatcgatgagttttggtcccctcgctcgttgaaatctagtcatttactactgtctttc
+gagctattataccacttcactatgtggtgtttctttgctatgtatggggctagtcaaaca
+tgatgactatagctacaactcagagagcgggcgtgttaagagtatctcatgctagaactg
+cacgacgaacttgatacaaagtaacaacatttacgattccacaaggtgactttgaagaaa
+catagtttaattctctgcttcgatcatttctataaaccggtaccatcgcagcggatagat
+gcataacatttctactactccaggcatcttaaaacacacgtagtacttcactagattaag
+acacgataagtgtataacttggcagtgggaagcaaggagattggcgaactcctggcatct
+gttacgttttgttcaggctcggttgttgataatgtccgactcctgccatattgaagactc
+gctcgagggagatcgggattcgttgattataagtacacgtgttccgtaatactatgaggc
+agtgattcaaaatggcacttctgacttacatgactaggtattattaccacggaagcgtta
+aaggcacactcttatggacttaagattgcaagtgccttcttctagcctgaattcgcgggt
+tcaacacaaactctctttagacatccgttgcctaaaggctgagacgtaggggcaaccctt
+taactatgtactaaaaaactagttggtaatttaacaacgtgtccaatcaagacgatgcac
+caacgcggtgcgaaaatcgggttaagcaaacacaaataggaattgtgataaaccccacct
+tgagaggtcgcaagaccaacctcgggaacaacggctctaagagaataacctaaatccgga
+tgagtagactgtgtaactctctaaagggaagtgaaaaaaagctaagcatacatttaggtc
+tcctgcattgcattcaattgaatcgtttgtattatgagctgtacagtagctatatcagct
+atagttatcccagaggaacaggtaaactagctctgagcgtgaaatccggatattagaacc
+cctagatgggattgattctagctaatacaggcttatctggttttacagttatctagatga
+ttggtaaggtgaaacgcttggtgccttccaccacttaaacaaaagtattgcccgggaagc
+tattttctaggtattataaagtcgagcattaatatcaatttgacagtaaaggtctttcac
+cagcttcatatgccatagggcccatactcgatttaaattgaacggtttaacgagtattgg
+aactctcacttataactgagtagctatacgaaaaatctggtccatttccagaaatttatt
+atcgatttgctgcttagtacccaggaagtgataacccttgaaggcacaacactgtaataa
+gttttcctgtcacatctgtaatattcggtcactacgcattcacgactaaagataattact
+atactaattaaaagttcaatgttagggccgaatcatagtagaaattctcgtctagcctaa
+tcggacttacctatgggctgtgaggatttatcagtatgtggacaaaaatgctagagatag
+gtatagttaaagtcaccatggtacatctatgtgaggaagtttgtagttcgcttctttagt
+ccgggcgtttgggatgacaactactatacgtagagccgtactcaggattagatagtgtga
+aagagtcaaataaaagggttaatattaatttaacgttgcaaatgtgtttaggccaaacat
+taaccgttgtagggatattctaatacaggccttcaccgaaccctaatgataatctgtctt
+aataacattaaatgattgtctccgctacgagctcttagggcctcattttaaatgactaat
+gtccaaagaagagactttcccaatttcaatctgtcacgtatagacggcaccttagtgagt
+catatcattaagatagaagattatcaggagggaagtttctattatcaaccgttacgcaac
+cataaacttttaaatctcataatggcattgagatcaagagctttcatgatggtaaagttc
+gtatgtgatgctggggagctagatatcggtataccacttcggttgtggtaagcccgagtg
+ggccgttagtaatattaatagacgattatccgacaatgcattcgctgaaataatcttact
+taggagaaattaatgctatgagccaaaactatttatgtctgtcacattattgactaaagt
+atctatcgacaaaactgatgtccataagttgtagcagatagtcggtgtatggtgtcacca
+atgaaaacctcgagcgaaaaatgaattatagttatccaatttgagtaaattgcctattat
+acagataggcttgtttagtcagataaggttccgcttgaggtgctctaacttagcgagagt
+tagaaagcctagtgagaggcattttggtgccaaactccggctcgcatgagtaggccagag
+agtcactttctttcgtcgaagaagttggtgaacagccttttgattagttgtttgtcttgt
+ggctatgtgctactatataagttagaacgcaaactaatctaatcagcaaagtaaaatagg
+accttgaacgagacggggtacgccgttgaggctcgagatagtagataaactagaggaatg
+tagataaaacattagctagggggtttagttactggattacataggaagtgcaccatcacg
+gtgtgggggttcgtacgtaaagtcgcatcaatattgtcagtggacttaacaagttcgtgc
+ataatgaaatcctatacggactttgcatatctctaccgactcatctggtcgtctatgcgg
+gtaattgtattgctccaagtggatgactattttggcgtcccagcacatagtaaatgtaaa
+tccttataatagcataagcaattattagactgcgtgaagtcttagtagttctcaagcttt
+acgttgtatgtaaataactcacgtaatcagccgtccccaaatcaccattgaggtcattga
+atgtacggagcactattatcaatgcggtatgcgattttctgagcgattattgttaaagac
+ttagcgttgagccccggaacacttgattacagattctttaaggagttatccaaatatcat
+tttaaataatagtagtatcgtgctttggacaataaaaaaagacccgttctcttatgttgt
+tttgcgacgtacttctctgatatatacttcaactatgaagattctattcatcgataaccc
+aggtatatttatatgcccgttcactgcgcagggcaaattatctacggacaataatgacgt
+agttggacccggtaagaactaacgcttaatatgattaaggatgtatgccagtattatctt
+attatgtcagagtagaagtttctctgagattttccgtcgttgtggtacaccggatttggc
+tctctttttagaactgagaactcggagtgtgtagtcttgtttccttcaatttatcaatat
+gcttttataccgccctcatcaactataacaggacgacaagttccgtcttgctccatcata
+tactaccgatacaccaatcgtatcaagtttagtatacttgctttctctcttctacagctt
+actcgcttgtccgagaagcggttggtgctcataaagttagtagtaaatgtacaactagta
+gccagtccttacctgtttttacgactactacggacaccatgagatacagaagttagtgct
+acaattataccattacatgctcaatatcgttgtcggccataagatcgaagagtgcatcac
+gcgtgtgaatacgtaaaatctaccatcccgtcaatgcacaaaaacacactccccttgttg
+actaacatcttttacaagaggctaaatcattgtccaggatcgaataccttgtgtacaatc
+gtcacccatcggaagaataccacttttccgatgtagtatgatttacaaaaaacatctatg
+tgagtaggccaattgtagtagaatatattcatttgaccgtcattagccttcttcttaggt
+tgtgtacggatagtaggtacataaaccgtcgtgtggcatacgctgcgatttcatacagct
+gccaacaccttttttaccaggctagagtcagaaaagttggagccatgttaaatagttacc
+atcataaaccactgttgtctactagtctgatcagctttcatgcctgtgcaagcaatatgg
+attctcacgtaatggtaacaactgttgcgttacttaggctggttaatttgtcagagtaat
+aaatacatgtcttgttgtgtttcctaatcctcggaaagtacacaagcctaggaataggaa
+aagtaaagctcttttattctgatagtgactaactcaggatctaaatacgcgattatacta
+accttcaccaaagctcaaaaatcatctgctggtgaccagttatagacagggtaattcaat
+atttaatgtctcccttaacatttcaccagcatggattgaagatagtataaagttttacat
+ggcagtcattgtgtcacggttctatacaaattctgatagttagacggtatttgaaatgtg
+cttctagcatggtatcttacacaactgaatgaacgactggagccgttcgtatactatttg
+cgagcctcgagaccccgtttcctaatgttaacgaatatagtataatataaattgtgatat
+gaataacacaagtaactacagtttggacaattaattgttctaaactaaaaatcattcact
+tcagatggcatagagttatggctactacacatataaagcggtatgtgaaacacccgtttt
+agccggaaaccctctactgctcgggacaatgaatgatttccaaaatatggatgtgcagaa
+ttgttagtgtgactcaggtccaaatagacactttagtttcgtcaagtcgttgcaaagttt
+aaaaccatcgcagcattctttatttggtctacattgagaaatgaaaaaacgtgacagaaa
+gtctagaagaactgtgaataatgtctattactgattaactagtaagacattagtgcatct
+ggtccactgaagcacccgcttggcgttaggcaatctctgtgaactgtcgtggctgttccg
+gtaatgtacgaaagcaagcctataggttgatcgagtcgcttcattaaggtcaatttcaca
+atatccgatcacattgtgctaggttcgtcctttaccttgcttagtgctgcatgtacgggg
+tgtcatgacttgttatcggcagactctttatcccaagaatggataatatgtacatggaaa
+gtgtccataattaagtcccttcactgtaaagaatgactgccacgtgatccatgaggtcta
+cagaaaccgacttacttgctttttgatcaacttaattatggattcataaagttcagatat
+cggtacaattggtgtacaatatgaaattaatgaggaaacatggaaatctgaatgacagtg
+atagaaaagatccccatttgcccggtcagttcatgttacaccactcattagtactgtaag
+tgtttcgtcagcattgagatccacgatcatgtgtttatgccttcgaaactggatgtacga
+cgatcgagacgaagaggtatatataacctaaatactaggtacgttgttagagagacgatg
+aaaattaatcgtcaatacgctggcgaacactgagggggacccaatgctcttctcggtcta
+aaaaggaatgtgtcagaaattggtcagttcaaaagtagaccggatctttgcggagaacaa
+ttcacggaacgtagcgttgggaaatatcctttctaccacacatcggattttcgccctctc
+ccattatttattgtgttctcacatagaattattgtttagacatccctcgttgtatggaga
+gttgcccgagcgtaaaggcataatccatataccgccgggtgagtgacctgaaattgtttt
+tagttgggatttcgctatggattagcttacacgaagagattctaatggtactataggata
+attataatgctgcgtggcgcagtacaccgttacaaacgtcgttcgcatatgtggctaaca
+cggtgaaaatacctacatcgtatttgcaatttcggtcgtttcatagagcgcattgaatta
+ctcaaaaattatatatgttgattatttgattagactgcgtggaaagaaggggtactcaag
+ccatttgtaaaagctgcatctcgcttaagtttgagagcttacattagtctatttcagtct
+tctaggaaatgtctgtgtgagtggttgtcgtccataggtcactggcatatgcgattcatg
+acatgctaaactaagaaagtagattactattaccggcatgcctaatgcgattgcactgct
+atgaaggtgcggacgtcgcgcccatgtagccctgataataccaatacttacatttggtca
+gcaattctgacattatacctagcacccataaatttactcagacttgaggacaggctcttg
+gagtcgatcttctgtttgtatgcatgtgatcatatagatgaataagcgatgcgactagtt
+agggcatagtatagatctgtgtatacagttcagctgaacgtccgcgagtggaagtacagc
+tgagatctatcctaaaatgcaaccatatcgttcacacatgatatgaacccagggggaaac
+attgagttcagttaaattggcagcgaatcccccaagaagaaggcggagtgacgttgaacg
+ggcttatggtttttcagtacttcctccgtataagttgagcgaaatgtaaacagaataatc
+gttgtgttaacaacattaaaatcgcggaatatgatgagaatacacagtgtgagcatttca
+cttgtaaaatatctttggtagaacttactttgctttaaatatgttaaaccgatctaataa
+tctacaaaacggtagattttgcctagcacattgcgtccttctctattcagatagaggcaa
+tactcagaaggttttatccaaagcactgtgttgactaacctaagttttagtctaataatc
+atgattgattataggtgccgtggactacatgactcgtccacaaataatacttagcagatc
+agcaattggccaagcacccgacttttatttaatggttgtgcaatagtccagattcgtatt
+cgggactctttcaaataatagtttcctggcatctaagtaagaaaagctcataaggaagcg
+atattatgacacgctcttccgccgctgttttgaaacttgagtattgctcgtccgaaattg
+agggtcacttcaaaatttactgagaagacgaagatcgactaaagttaaaatgctagtcca
+cagttggtcaagttgaattcatccacgagttatatagctattttaatttatagtcgagtg
+tacaaaaaacatccacaataagatttatcttagaataacaacccccgtatcatcgaaatc
+ctccgttatggcctgactcctcgagcttatagcatttgtgctggcgctcttgccaggaac
+ttgctcgcgaggtggtgacgagtgagatgatcagtttcattatgatgatacgattttatc
+gcgactagttaatcatcatagcaagtaaaatttgaattatgtcattatcatgctccatta
+acaggttatttaattgatactgacgaaattttttcacaatgggttttctagaatttaata
+tcagtaattgaagccttcataggggtcctactagtatcctacacgacgcaggtccgcagt
+atcctggagggacgtgttactgattaaaagggtcaaaggaatgaaggctcacaatgttac
+ctgcttcaccatagtgagccgatgagttttacattagtactaaatcccaaatcatacttt
+acgatgaggcttgctagcgctaaagagaatacatacaccaccacatagaattgttagcga
+tgatatcaaatagactcctggaagtgtcagggggaaactgttcaatatttcgtccacagg
+actgaccaggcatggaaaagactgacgttggaaactataccatctcacgcccgacgcttc
+actaattgatgatccaaaaaatatagcccggattcctgattagcaaagggttcacagaga
+aagatattatcgacgtatatcccaaaaaacagacgtaatgtgcatcttcgaatcgggatg
+aatacttgtatcataaaaatgtgacctctagtatacaggttaatgttagtgatacacaat
+actcgtgggccatgggttctcaaataaaatgtaatattgcgtcgatcactcacccacgta
+tttggtctaattatgttttatttagtgacaatccaatagataaccggtcctattaagggc
+tatatttttagcgaccacgcgtttaaacaaaggattgtatgtagatggtaccagtttaat
+tgccagtgggcaatcctaagcaaaatgagattctatcctaaagtttgggcttgatataag
+atttcggatgtatgggttttataatcgttggagagctcaatcatgagctaatacatggat
+ttcgctacctcaccgagagaccttgcatgaagaattctaaccaaaagtttaataggccgg
+attggattgagttaattaagaccttgttcagtcatagtaaaaacccttaaattttaccga
+ttgacaaagtgagcagtcgcaataccctatgcgaaacgcctcgatagtgactaggtatac
+aaggtttttgagttcctttgaaatagttaactaatttaaaattaattaacgacatggaaa
+tcacagaacctaatgctttgtaggagttatttatgctgtttactgcctctacaaccctaa
+taaagcagtcctaagaatgaaacgcatcttttagttcagaaagtggtatccagggtggtc
+aatttaataaattcaacatcgggtctcaggatattcggtcatataatttattaagggctc
+ttcgagtcttactctgagtgaaattggaaacagtcatccttttcgttgtgaggcatctta
+caccgctatcgatatacaatgcattccaccgcggtgtcccgtacacaaggaaacttgtta
+ccttggggatataagaaaactcacacgtctcattattaaactgagtacaatttttgcacg
+agaaagtaatgcaatacaatatgatgaaagccagctaatgaaaagggatggaacgcacct
+cggatctgttgcactggattaaaatccgattatttttaaaaatattcagtgctagagcat
+atcaggtctacttttttatctggtatgtaaagcccacggagcgatagtgagatccttacg
+actcaacgaaaagttataacataactcccgttagccaaagcccaatcccgattactgccc
+taccctaacgtctgccatctaaatatcgaacttgttatgatcaatgtgactacctcccac
+cctttccccttcatttgttccactggggataagctagcgttttcagaatcaatgcaataa
+gaatagccaattgtctcacttcatcagagctcttggcaattccaggcgctacgtggttct
+ggaatatattcatttttcaaatagtaatacgtttagtgttgctattgtctacacgtttgg
+atattacgttatgtgagcggacatcaatagttgtctaactctttagtaagccagagatag
+cactcttagcgaatggataccatcttccataagtttagttaatagtccgaaacaactgct
+tcgagcatatttgaacctccttgtaggcaaatagcctcttcaaagcaatcttactaatag
+atagagtttgttttaagggactactagaaatgggacaatcttaatagtatgacctaaact
+gacatttaaagatatatccaggtggcaagcataaagatcattgcgccacctccaccgtgg
+gattacttatcagtcgatatcctatatgctaagtttgcgacggcagaatacaaactaagc
+tgagttgatgctaaccttacctatgataccccattggaccggttaacagccctacttatt
+ccaaataaaagaacttttatgctgtagaagctattatagtgatgcctggtaacttcagta
+tattaaaatgacacacatacgccatatagagctcctggaactttgaataatgagcgaact
+tcgaagttgaagagcaagaaaccatatgtcacggttgcctaaagcccggtaaccagacat
+gtgctatcattgatcattatcgaggttttcataaccttgacccattatcggctgtgcgcg
+gacaagtacttaaatcactagtttcttcacctgcttatcggtaagaaataaggttggcaa
+agaatcgcataagacggacgtagagccgcagcgttgtgcgagtccaggtgcatgcgcagc
+aataggattttaaattttgttccatttttaatttagccgtaaggatgtccgtaaatgatt
+gaaaattggattcaatctttgggcctatgctactggaacctgatcgacaaaatttcaaac
+atacgttaactccgaaagaccgtatttttgcggctagaatagtcagtcgcttggagccat
+ataccttaccacttaaacgacgtgctcctgtagttgaaatataaacagaacacaaagact
+accgatcatatcaactgaagatctttgtaactttgaggcgaagcaccctcttcgagacaa
+ctaagagtaaagtaccgggcgccgcaaggagtcgattgggaccctaaatcttgacgaatt
+gctaagaggctcagagctaccactgtaatttctctagagcccataataaatgaacgatac
+atccgtaggtagcacctaagggattataatggaagccaaatgcagttaataatattatat
+actggcgtacacgattcgacggatctctcacatagtgattcacgacccccccctttgatt
+gacacagcgtcagcattttgcaagaacgatcttctgcatagggtgcgccaccgtaaggat
+gacgtcgaagctacaactgggtataatttaccatgcttccctgatgctgagtgcaataca
+ctaagaatgagtttttaccccatatcaccagtatttgttctgttattgcgaagaaatggc
+tatgctgagttggcgactaaagtcacccatcctttttattaggtaaccccctcccttaaa
+ctaactgatttgctggagctgccctgcatacatatactttatcatttatggacgtccgtg
+acgcttattatccaccatagtcgatatgctacacggattcattaatggatcgtaggagtt
+taagttatatttactaagatcggtctcggctactatcccgccttacccggcgctatttac
+ggccatttttaatatattgacggtaattattcctatggtttcgaccgcacgtccttggac
+aagaaagaatggcaaaaaaaatgtaaaagaaaaaaaatattgagtccctaccatcatata
+aaaaatatgtgatgagtaacttgacgaaatgttagtggttattaaagactatctattaca
+ccttttgttttctgtcgtagtatattaaagtctagaagccttacaggaaaatcagggtta
+tacagccgatactccgcagcatgaatcatcgaggaggtgtcctaccatcgcgccttgtaa
+tcttgtctgtgtatactgtatttagaccttttatacaaagtaaatatctcggctttatgt
+gattgggaggggcctactcaaacatgatgacttgacctaataatcactgtgcgggcgtct
+tatgactagctattccttgaaatccaccaccaaatggttaatatgtaaaaactttgacga
+tgaaacaaggtgaatgtgtagttactttgtgtaattagctgcgtcgagcattgcttgtaa
+aaccgtcaatcgcacacgttacttccataaaatttctacgaatacacccttcttaaaaaa
+aacgtaggaattcacgagtttaacaaacgataactgtataaagtggaagtccgaagaaag
+cagatgcccgaactactcgaagatgtttcgttttcttaaccataggggcttcttaatggc
+ccactacgcacattttgttcaagcccgagagggacatccccattacgggagtattactaa
+aactgttccgtaatacgttcagcaagggatgaaaaaggccactgctcaagttattgacgt
+gggagtattacatcggaagcctgaatcccacactatgatggtctgtacaggcctagggac
+tgcgtctagacggtattaccggcttctaatcatacgatcgtgagtcttaacgggaagtaa
+ggctcacacctaccccaaaccatttatctatgtaagtataaaattgtgcgtaagtgttca
+aagtggacaataaagacgtggcaaaaacccccgcacataagccgctttagatttcacaaa
+taccaatgcggttaaaaacatccttgagtcgtacatacaccatactcgcgttaaacggat
+ataacagaagataataaatccggatgtggagtcggtgtaactatagaaagccaagtgaaa
+taatgcttaccagtcatttagctatacggctttcatttcatgtcaagagggtggagtttg
+acctgtacagttgatatatcaccgatacttagaactcacctaaagctaaaattgctcgca
+gcgtgtaatccgcatattacaaacaatagatgggattcattatacataagacacgatgat
+ctgctttttcaggttgcgagatgttgcctatcgtcaatcgagtcctgccttacaccactt
+aaacaaaagtattgacagggaacctattttcgaggtattatatagtccagcttgaatatc
+aatttgacagttaacctagtgaaaatcagtaagaggaaatacgccacattctccagtgaa
+attctacgggttatcgtctagtccaactatcaattataactcacgagatataagtaaatt
+ctcgtacttggcctgatttttattatactttggatccttagtaaacaggaagggagaaac
+cttcaacgaaaaacactggattttgttttactctcaaagctcttatatgacggaaatacc
+ctgtcaagtcttaactttattactagactaatgaaatgggcttggggtggccagaatcat
+agtacaatttagcggatacactattcggactttcctatcggctgtctggttggataagta
+tggggactaataggctagacatacctatacttaaactatacaggcgtcatctatctctgc
+aactttggagttccctgatgttctcccgccctttgggttcacatcttctataccgacacc
+cctaataacgattagtttgtgggttagagtaaattaatacggttaatattaatgtatcgt
+tgaaaagctggtgtcgccaataaggtaaccggctaggcagagtatatgtcacgaagtata
+actaccctaatgataagctgtaggaataaaattaatgctgtctctaagcgaagagatatt
+tccgactctgttttaatgacgaatctcattacttctgacttgcaaatgttcaatatggca
+cggtttcacggcacctttgtgacgcatataatgaacttagaagattataacgacggaact
+ttatatgataatccgttacgattaaagaatctgttaaatatcataatggcattcagttct
+agaccgtgcatcatggtaaacttactttctctgcatggcgacatacatttcgctattcaa
+attcgcgtgtggttacacccactcgcacctttggaatattaagagaagatgatcagaaaa
+tccattcgctcaatttttctgacgtacgtctaatttatcctaggagacaaatcgttttat
+gtctctcacatttttgaagaaaggttcgagagacaatactcaggtcctgaactgctagaa
+gatactcggtggagcgtggcaacaatgaaaaactcgtgacataaatgaatgatacttttc
+caagttcagttaagtgaatatgtttaacatacccggcttttcgatcttaagctgacgctg
+gacgtgcgagtaatgtcagtctcttacatacactagtgactccaagtttcgtcaaaaacg
+ccccctcccttctcgagcccactcacgctatgtattgacgcgaacttgttcgggatcaga
+cttttcaggagttcggtcgcgtgtccctatgtgctaatatataagttagatcgcattaga
+tgctaatctgaatacttatagacgaccttcaacgagaacgggtaccaccttgaggctaga
+gttaggtgtgaaacgacaggtagggacatataaaatttgagtgcggctttagttaagggt
+ttaattacctactcaaacatcacgctcgcgcccttcgtacgtaatcgaccatctagaggc
+taaggggactgtactaggtagtgattaatgatatcctagacgcacgtgccttagatcttc
+agactctgatggtccgcgatcaccgtaattgtagtcctccaactcgatcactttgttggc
+gtcaaagaaattacgatatctaaatacttataatacaataaccaaggatgagaatgactc
+atcgcgttggagttatattgcttgaagttctatggaatgaaagcacgttatctgccgtcc
+caatatctccagtgagctaattcattggacggtccactttgatcaatccccgaggagatg
+ttcggacactttagtctgtaacacttagcgttgagaccacgaacaattgattactcagtc
+ttgaaggtgttttccaaagttcattttaaataagactacgataggcctttcctattgata
+taaactacccggctctgttgttcgtgtgagtcgtacttctctgtgtttttctgattatag
+caagattcgattcttagtgtaaacagcgatttttatttgacccgtcaatgagaagcgcat
+aggatctaagcaaaattatcaagttgtgccacaaggtaagatctttccagttattgcagg
+taggatgtatcccacgttgatagtatgaggtctgacgtcaactgtctaggagagttgacc
+gcgtgcgggtacaccggatttgcatcgatgttgagaacgcagaactcccactgtcgtggc
+ggcgttcctgatatttagcaagaggcgttgataaagccctcatcatctagatctcgacct
+catctgccctcttgctccatcattttctacacagactactttcctatctacgttagtata
+attgctttctatcttagtatcatttagagcttctccgtcaacaggttcgtgctattaaag
+ttagtacgaaagggacaacttgtagcaacgcatttaatcggttttcgactacttcgcaca
+aaatcagataaagaagtttgtcattctattagacattgaattgcgcaattgacttgtacc
+acttatgatcgaacactgaatcaagactgtgattaactaaaatagacaagccactatatc
+aactaataaaaacgcccctggtggtcgaacatagttgactacaggataattaattggact
+ggagccattacattctctacaatcgtatcacttcccaagtagacaactttgaccttgtag
+tttcatgtacaaaaaaatgctttcgcaggagcacattggtagttcaatagtttcatggga
+acctcttgagccgtcttctgtgggtgtgttcggatagtaggtactgataaagtcgtgtcg
+ctttcgatgagagggaattcaccggaaaacaccttggttaacaggatagtctatgtaaac
+ttcgagacatgtttaagagttaccagcttaatccacggtgctctactagtatcatcagct
+gtcttgcctcgcctagaaatatgcattctatcgttatcctatcaacggttgccgtactga
+gcagccttattgtggaagagtaatatataaatgtagtcttgtctttacgaagcagacgta
+agtaataatgacttggaataccaaaactaaacatagtggattatcatactcaagaactct
+ccagataaataacagtttttacgatacgtcaccaatgagcttaaagattaggatcctcaa
+aactgatacaaacgctaattcatttgttattggatccagtatcagttaaactgaatggag
+tgaagattgtagaatgttgttctggcctcgcatggggtctaggtgatatacaatttctca
+tacttacacggtagtggaaatctgattctagcttcgtagctgactatactcaaggaacca
+ctgctcaaggtaggagactagttccgaccctacagtcaaagtggccgaagcttaaactat
+agactagttgttaaatgctgatttcaagatatcatctatatacagtttggacaattatgt
+gtgcgaaactaaaattcatgctattcagatggatttcacttatgccttagaaacagatat
+tgcccgagctcaatcaacagttttagccggaaacaatcgaagcatagggacaatgtatct
+tttcctaaattgccatgtgcagatttctgagtgtcacgaagcgcataatagaatcttgtg
+ttgcctcaactcgttgaaaagtttaaaacaatcgcagcagtctttttggggtctactgtg
+tgtttgcaaaataactgaaagaaacgcttgaacaactctgaagtagctcgagtactcatt
+aaagtgtaacacattagtgaatatcggccaatgaaccaaacgcttcccggtacgctatct
+ctctcatcgggaggcgatgtgcaggttatctacgaaagcatccctttacgttgagagtgt
+cgatgcatgaacctcattgtaacaatagcccagcaaattctcatacgtgcctcagggtcc
+gggcgtactcctccatggaagggcgcgcatctagtgttataccaactcgctttttaacta
+ctatgctgtagttctacaggcatagtggccagtattttctaacttctctggatagatgct
+ctcactcctcatccatcacggcttcagtttacgtcttacttgcttgttcagcaacggatg
+gaggcattaagtatcttcactgttccctaaaattgctgttcaatatcaaagtaaggacga
+tacagggaaagctcaagcacactcattgaatactgccccagttgcaacctcacttaatct
+gacaaaaataatgactactctaagtgttgcggaagcagtctcttccacgagcttgtctgt
+atcacttcgtataggcatgtaactcgatagacacgaacaccgagtgagaaactatattct
+tgcttccgtgtgtgtgacaccaggtaattgatgcggatataagctggagatcactcacgc
+ccacacaaggcgctgctacctctttattccaatgtgtaagaatttgctaacttcatttct
+agaccgcagctttgcggtcataatttcacggtacggacccttgggttagagacttgataa
+cacacttcgcagtttccaccgcgcacatgttttagtggcttctaacatagaatttttgtt
+gtgacataaagagtgcgtgggagacttgcccgaccgttaagccataatcaattgaaagcc
+ccgtgagtcacatctaattggttgtactgcgcatttagctatcctttagctgactcgaag
+agattcgattcctaatataggttaattagatggctgccgcgcgaagtaaaacgtgaaaaa
+cgtagtgcgcagatctgcataactcgcgcttaattacttatgagtagttccaagttcgct
+acgttatgagagagattggaattaagcaaatatgttttatggtgattttgggatgagaag
+gactgctaagtacggctactaaacaaatttctaaaaccgccatctaccttatcttggaga
+catttaagttgtatatgtcactagtctagcttttgtctgtgggacgcgttctcggaatga
+gggaaatgcaagagccgattcatcaaatgcttatctaagaaagtagtggactattacacc
+aagcacgaatgccagggaactgctttcttgctcaggacctcgcgacaaggtaccccgcat
+aagtcctagaattacatttggtcagcaatgctgacatttgaccgtgaaaacataatttta
+atcagaaggcagctcacccgcttgctctagatcttatctttgtatgaatgtcagaattta
+ctgcaatatccgttccgaatagtgagggcttagtatagttctctgtatacaggtcacatc
+aaactccccctgtcctagtacagctctgagctttaattaattgcatacatttccttcaat
+catcagatgaaaacaccgcgaatcatgctcttctcgtatagggcaagagaagcaacaaac
+aactagcccgactcacgttcatccgccgtatccttgttcagttcttactccgtattaggt
+cagcgaaatctaatcagaataatcggtcgcgtatcaaaattaaaatcccgcttgaggttg
+acaattaaaacgctgagcagttatcggctattagatagtggggtgaaagtaattggctgg
+aattatgttaaaacgtgatattaagctaaaatacgctacttgttgccgacctaattcagt
+cattcgatattcagttagagccaagaataacaagcttgtataaattgaacggggtgcact
+aaacgatgtgttactctaatattcagcttggagtatacctgaaggcgaattcatgtatcg
+gccaataataagacgttgaagatcacaatttggactagcaaaagaaggtgatttatgcgt
+ggggattgagtccactgtacgagtacggtctctggaaaattataggttcagggaatataa
+ggaagtaaagataattaccaagagatttttggtatcgctatgacccagaggtgttctaac
+gtctgttttgatccgcagaatttctgcctcaatgcatatttgacggacttgaactagagc
+ctctaaagttaaatggcgacgcaactgttcctaaacttcaattattactactcttttttt
+cctagggtattgtagaggccagtggacaaaataaatcaaatttaagatgtttcggacatt
+aacatcccccgtagcatagaaatcatcagttatccaatctctcatcgagcttttacaatt
+tctgctggcgctatggacagcatatgccgcgagacctccgcaagactcacttgatcactg
+taagtatcttcattagaggttagagcctatagttaagctgctgacctagtaaaattggta
+ttttctaattttattgctcaagttaaaggttagtgaagggataatgacgttatttttgaa
+caatgggttgtattcaattttatatcacgaatggaacccttcattcccggcataatacta
+gacgacacgaacaagctccgatctatcagccaggcacgtgttaaggtttaattccggcaa
+accaatgaagcatcaaaaggtgacctgatgcaacttagggtcacgatgagtttttcagga
+ctacttattacctattaataagttaacatgagccttcataccccgtaagacaatacatac
+tccaccaattagaattctgagccatcttatctttttgtatcatcgaagggtatggccgaa
+taggttaattagttactcctaacgtctctacaggcatgcatttgacgcaccttcgaaaat
+agtcaatctctcgccacacgcgtctagtatgcagcatcaaaaatatagtccacggtttcc
+ggattaccaaacgcggcaaagagaaacattgtatcgacggagataacttaatacagaagg
+aaggggcatcttcgaatacggatgaataattctatctgtttattctgacatcttgttttc
+aggttaatcttacgcattcaaatgacgcctgccccatgcgtgcgcaattattttctaata
+ttgacgagagcaatctcactccttttgggtctatttatgttttattgaggcacaagccta
+tacagaacaggtactattaaggccgtgagtgtgagactcaaaccgtggaaacaaaggatg
+ggttgttcttggtacaagttttagtgcatgtgggcaatccttaccaaaatcagatgctat
+ccttaactttgggctgcatttaagatggcggttggaggcctgtgagaatcctgcgtgtca
+tctttaatgaccgaattcatccatgtagattcagatcacacactcattccttgatgttgt
+ctaaacaaaagttgttgtggacgcattggagggagttaagtaacaacttgggatcgcata
+cttataaaaattatatgttaaactttcacaaacgctgaagtccaaagtaactagcccaaa
+cgcctcgagagtcactaggtattaatggtgtttgagttcctgtgaaatagtgttcgaagg
+taaaatttatgtaccaaatcgaaagaacacttaataaggcttgcttgcacggaggtatga
+tgtttactgactctacaaccctaattttccagtacgtacattcattccaataggttagtt
+ctcaaagtgctatacaggctcctcaattgatgatatgcttcagccgctctatggatatta
+gctcattttatttaggaagcccgcttagaggcttactatgagggaaatgccaaaatgtca
+tacttttcggtgtgtcccatatgacaccgctttacatagaatttgaattaaaacgcgctc
+tcccgttcactaccatacttggtaccgtgcgcatattacatatagatataggatcatttt
+ttaaagctgtactaggtttgatcgacaatcttatgctatactatatgatgtaaccctcat
+aatcaataccgatcgtacgatcctagcataggtggcaagcgattttatgccgattattgt
+gttaaatagtctgtgagtgtgattatcagggctacgttggtagaggggttgtatagacct
+cgcacacattgtgacatacttaacaatatacgaaaactgatataataaatccccttaccc
+aaacaccaatcccgttgaatcaactaccataacgtctcccatataaattgcctacttgtt
+tgcataaatctgaatacataacaccattgcaccttcttgtgttccaatcccgttaagatt
+gccttgtcagatgatatgcaagaacaatagcatttgctagcaattattaacagctcttcg
+aattgcctccacataacgcgggagggtatattttaatttggcaaatactaagtactgttg
+gcgtcatatgctattaacggttggatattaagttatgtcagccgtaagcaagagtgggcg
+aaatattttgttacccagtgagagcactcttagagtttggatacaataggccatatgttg
+acttaagaggacgtaactacgccgtacaccattgttcaaccgacttcttggcaaatagaa
+tcgtattagcaatcttaagaatagagacacgttcgtgttagggtatactacaaatccgaa
+aatcttaagaggatcacctaaactgaaatttatacatatttcaacgtggatagatttaac
+ataattcagccacctccaacctgggagtaattttcagtagatttactagatgattagtgg
+cccaacgcacttgactatataagatctggggatcctaacctgacctatgagacaaaattg
+gaaacgttaacagcccttatgtgtacaaagaaaagtaagttgttgctgttcaacagatga
+tagtcatgacgcgtaacttcactatagtaaattgaaacaaatacgcaatttagacagaat
+ggtacggtcatgaatgacagtaattcgaagtgctagaccaacttaaaataggtaaacgtg
+cccgaaaccccccttaacagaaagctgctatcatggtgcagtatcgacgtgttcagaaac
+ttgtaacttttgagcaggtccgagcacatggaagtatatcacgtgtttctgaaccggctt
+atccctaagatatatccgtcgcaaactttcgatttagtcccacgtagagcccaagcgttg
+tgcgactccacgtgcatgcccagaaatacgagtttaaatttggttacatggttaattttg
+accgaagcatcgcactttatgattgataattggattcaatatgtcgccctatgcgaatgc
+aacatgatccacaatttggctataagacgtttaatccgtatcacactttgtttgcggcta
+gtatagtaacgcccgtgcaccaagagtcagtaacaattataagtactccgcaggtacttc
+aaatataaaaactaatcaaacacgacccatatgatcatctgaagatatttggaactttct
+cgacaaccaccctcgtactcaatacttacactaatcgacaggcacacgcaacgtgtacag
+tcgcaccatattgagtcaagatttgcttagtggcgatgagcgtacacgcttatttctcta
+gtcacaattagttatctacgagacatcacgagggagcaaataagcgatgttatggctaca
+cataggcacgtatgaatatgatataagccagttaaacagtcgaaccatcgagcaaattct
+catgcaccaacccacacgttgaggcacaaagagtaagctgtttgaatgtaacttcttctg
+ctgagcgggccccaacgtaaggatcaactagaagagaaaactcggtattagtttaaatgc
+gtcacggagcatgagtgcatttcactaagaatgtctgtgtaaccaatataacatctattt
+gttatctgattgcctacttatggctttgcggtcgtggcgactaatgtctccaatcctttt
+gaggtcggtaccaactccctttaaattacgctgtgcaggctcatgcactgcatacatata
+cggtagcaggtagggacctcacgcacccttattataatcaatagtagttatcagtcaacg
+aggcaggaatgctgaggtcgaggtgttggtatattttctatgtgccgtctaggcgactat
+cacgcattaccaggcgagatttaagccaattttgaatatagtcaacgtaatttttactat
+gggttccaccgaaacgccttgcacaactaagaatcccataaaatatcgatatcaaataaa
+agattgtgtcaataccttcatatatattttttcggttgactaacgtgaactaaggttagg
+ggttttgtatgtctatataggaaacagtttcttttctgtcctactttagtaaagtcttca
+agccttactccaaaatcacggtgattaagccgttactcagcagcatgattctgcctgctc
+gggtcctaaaatccagccttgtaagagtcgctgtgtattagctagggagacctttgttaa
+aaaggatatatcgcggcgggatgtgagtgcgtggcgcatactcaatcttcagctcgtgtc
+attataatatctctcccccacgcttttcactagatatgccgtgtaagcaaacaccttatg
+cttaatttcgaaaatattggtacttgaaaaaagctgtaggggtacttaatgtctggtagg
+agatcaggagagaattgagtgtaaaaccgtaaagccctcacctgacttcatgtaaatggc
+ttagaagactccatgatttaataaatactacgaaggaaagactggatctaaagataactc
+tagtaaggccaactcccttcaatgctgttgccagttataatccaagagctgtccttttct
+gaaccatagcggcttctgaagcgaactagaagcaaagttggttctagccagacagccaca
+taccctgtacgggtgtattactaaaactggtccggtattagttcaccaagggaggaatta
+ggcaaaggatctaggtatgcaagtcggagtattacatccctaccctgaatccatcaatag
+gttcctctgtactggccttcgcaatgagtattcaaggttgtacagccgtataataataag
+atagtgactatgaacgggaagtaacccgctcaccttccccaaaacattgttatatctaag
+tattaaagtctgccgtagtgttaatactcgaaaataaacaactggcaaattacaccgcac
+ttaagccgcttttgatttatatttttccaatgcgcttttaaaaataattcagtcctacat
+actaattaagacccttaaacggagatatcacaagttaagttttaaccatctcgactaggt
+ggaactatagatacccaactcaatttatcattacctgtaatgttcctagaaggattgcat
+ttcatgtcaagacggtggagtttcacagcgaaacttcagtgtgaacagattctgagaaat
+cacctaaacctattagtcagagcacccggttagaaccagttgtcaaaaaatagagcggtt
+gcatgagacagaagtaacgatgagatccgttgtaacgttgagacatctggcctatcgtca
+atacagtcctcccttaaaaatatttttaaatactaggcaaacccaacataggttagtcct
+atgtgatacgccacatggtatatcattttgtaacgttacctagggataatcaggaagtgg
+aattacgcaaaagtagacagtgaaatgcttagggttatagtctagtccaaagataaagga
+taaagcacgtcagagaactatattagccgaatgggaatcattgttaggagactgtggatc
+atgtctaaaaagcaacgcagaaacagtcatcgaaaaaatctcgtttttgtttgaatctaa
+aagagctttgatgaccgatagtacctgtatactagttactgtattacgtgtctaatgatt
+tcggattggggtccccagaatcagacgtcattgtagacgattcaagtttaccaatttaat
+ttcccagctctccttggagaactatcgccaataattgcagtcactttccttttctgaaac
+gataaagccgtcagagttctctgcaacgttggacttacctgaggttctaacccactttcg
+gttctaatagtagttaacgacacaacgaataacctttactgtggggctttcacgatattt
+tttcgcttattattaatggttacgtcataagctggtgtccaaattaaggttaccggcttc
+gcagagtagttgtatccaagtataacttccctaatcataagatcgaggtagaaaattaat
+gctgtctctaaccgaacagatatgtcccactatgtggtatggacgttgctaattacttct
+gaagggaaattggtcattatggatacgtgtctaccatcaggtcggacgcagatatggttc
+tgtcttcagttgatccaccgttctttataggataataactgacgattaaagattatggta
+aatagattaagccaattctcttcttgtcagtgaagcatccttaactgacttgctctgcag
+cccctcatacatttagctattcaaagtaccggctcgtttcaaactctcccacctttggaa
+gaggttgtcaacttgataagtatatcatttacagcattttttcggacgtacctctaatgt
+ttcattgcagaaaattagttttttctatcgcacattttgcaagtaacgttagagacacaa
+ttatctgcgaatgaactgctagatctgacgaccgggagcctcgcaaatatcaaaaaagac
+tgacatatatcaaggagtcgttgacaagtgctggtaagtcaattggtttatctgtcccgg
+cgtttcgatcttaagctgaccatgcacggcagagtaatgtcactctcgttcttacaagtc
+tgtctccaagggtcggcaaaaaagacccctccattctcgagcccactcacgatatgtagg
+gacgacaacttgtgcggcttatgaattgtctggactgcgggcgagggtccatatctccga
+agttagaagggacatacctttagatgataagatcaattcttattgacgaaattcatccac
+aacggggaacaacttcaccctagacttacgtctgaaaagacacctagcgtcttataaaag
+gtcagtgccccgtttcgtaaggctggaattacctacgcaaacttaaacctcgcgcccttc
+cttacgtatcgacaagatagaggctatcgcgaatgtactacggaggcatgaatcatatac
+tagaaccaagtgcctgtgatattaacaagatgatccgacgcgagcaccgtaattctaggc
+ataaaactccagcaatttgggggccgaaaacaaatgacgttagctaattaattatatgac
+atgatcaaaggaggtcaatcacgcatcgagttcgacgtatattcattgaacttcgtgcgt
+ttgaaagaaacttttatgaaggcaaaattgatcctgtctcctatttcatgcgtacctcct
+agttgataattccccgagcagtggttaggacacttttgtcggtatcaagttccggtctca
+aaacgtaaaattctgtaatctgtatggatggtctgtgaattagttaatttttatgaagtc
+gtcgagacgcagttcctattgatttattctaaacggagatgtgcttcgtgggactcggaa
+gtagatctgtgtttatgattattgctactttagatgctgactgttaactccgtgttgttt
+ttcaaccgtatatcacaaccgaattggatagaacctatagtttcaagttctgccacaagg
+tatcatatttacagttagtgctggttgcttctttcaaacgtggtgagtttgtgctatcac
+gtcaacggtagagctcagtggaccgagtgcgcgttcaaccctgttccagagagggtgtga
+tagcacatataccacgctcgtcgaggcgttcatgatagtttgcaagagccggtgttaaac
+acatattattattgttatccaactaatcggacctatgcataaagcattgtctaaacagaa
+taattgcctatatacggtagttttagtgatttatatcttagtatcagttagagcttcgaa
+ctcttcaggttcctcatatttaacgttcttcgaaagcgaaaacttctacaaacgaatgta
+agcggttttccaagtagtacctataaatcacagaaagatctgtctcagtatagttgaaat
+ggtattcagctagtgacgtgtaccaattatcatagttcactcaagcaagacgctcattaa
+cgaatatagacaagacactatatcatataataaaaaagaacatggtgctcgaacatagtt
+gaattcaccatattgaaggggaatgctgacatgtaattcgctactagacgatcaattccc
+tacttgtcaaagttgaactggtacgttcttggaattaaatatgattgcgctggaccaaat
+tgcgacttcttgagtttcagggcaaacgattgagccggaggatgtccgtctcttaccttt
+cttgcttatgataaacgacggtccctgtacatcactgggaattctcagcaaaaataattg
+ggtaaatcgagactcgatgtattcggccacaaaggtgttagacgttaaagattattcaac
+ggggcgataataggatcataaccggtatgcaagcgcattgaaagagccatgagatcctta
+tccgataaacgctgcacggtatgtgcagccttattgtcgatcacgaatttataaatgtag
+tctgggctgtaagttgaagacctaagttataatgaagtgcaataccaaatcgattcatag
+tggattatcagactcaagatatctcctgataaattacagttgttaagatacggataaaat
+gagatttaagattagcagcctctaatctgtttcaatcccgttggaatgtggtatgcgatc
+aaggttaagttaaaatcaagcctgtcttcagtcttgattcttgttctgccatcgcatgcg
+gtctacgtgagttaatatgtagcttacgttctagcttgtgctaatctgagtatagattcg
+tagaggaatattatcaagcttccacgcctcaacgtacgtgtattggtcacacaagacact
+aaaagtggaagtagcgtaaactatagtctagttgttaaatgctcagttcttgttatattc
+gatatactcttggctaatttatgtctgagtatataaaattaatgatattaacttgcattt
+cacggatcccttagaaaaagattttgaccgagcgcattataaacggttacaccgaatcaa
+tagaagcatacccaatagctttctttgaatttattgcctgcgcaacttggctgactctct
+agatccgaataattctatatggtcgtgacgaaactagttcattactgtttaaaatgccaa
+catgtcttttgggccgataatggctctttgcaaaattactcaatgatacgattgatcaaa
+gcggtagttgctagtggtagcatgtaagtctatcaaatgtctgattatccgaaaatcttc
+caaaagagtccacgtaccatatctatctcatagcgacgcgaggggaaccttatctaacta
+tcattccatttaccgggtgactctcgatgcaggatccgattgggataaattgcccagaaa
+tggctcattcctgactaagggtaaggccgttctcagcaagggaaccccgcgaatctaggc
+ttataccatctagattgttaactacttgcctgtagttctacagccatactggacagttgt
+ttctaaatgatcgggattcatgctagcactcctctgaatgcaccgcgtaagtttaactat
+tacgtccgtgggcagataaggatggaggctgtatgtatcttaactgttacctaatatggc
+tggtaattatcaaagtaaggaccttaatgccatagcgctagcaatcgctttgtatactga
+ccatgtgccaacctctcttaatctgtaaaatataatgtcttagctaactgtggacgatca
+tgtctctgcctagagcttcgctgtatcaattcctatagccagcgtactagtgacacaaca
+acaccgtgtgagaaaagatattagtccttacgtctgtctctctacagcttattgatgagg
+attgaacatggacatatagctccccctcaaaagcagatgctacctctttattccattctc
+gaacatttgccgaacttaatttcgacaaacctgaggtcacgtcttaatttatcggtaacg
+tcacgtccctttgagactggataaatatattaccaggggccaacgagcaattgttggagg
+cgcttctataatacaaggtgtcttgtcaaagaaagacggcgtgcgtctcgtgcaactcac
+ttaaccaatattaatgtgaaacccccctctctcacatcttatgcggtgtactgccctggt
+acatttcctgtacaggactccaacagtgtagattcctaagatagctgttggagttgcctc
+acgccagatcgaaaaactgaataaactagtgagctgagctgcagaaataccgcttaatta
+cttatgactagttcaaagggacctacgtgatgtcagacattgcaaggaagaaattaggtt
+tgtgcgtcattttggctggactagcactccttacttcccctactattcaaatgtcgtaaa
+cagcatgagacaggatcgtgctgacatttaaggtctattgggaacgaggctacctttggt
+cgcgcgctcgcgttctccgaatgaccgaaatgcatgagcacagtatgcaattgcttatag
+atctaaggtctggtcgttgaaaccaagcacgtaggcctgggaaatcagttcttcctcagc
+aactacacaaaagcgtccaagcattagtacttgtagtaaatgtccgaacctatgcgctca
+tttgaaagtcaaaaaatatttttaagcagtaggcacctaacccgattcctctacttagta
+gctttctttgattctcagaattgactgcaatatcactgcacaattctgtgccattactag
+acttctctgtattaacgtctcatcttactaacactcgcctaggacacatctgagagtgaa
+gtatttcaatacatttactgaaatcttcagttctaaaatccccgaataaggctcttatcg
+gtttggccaacacaagaaaaaaacttcttgcaccactcaccttcatacgcaggagcctgg
+ggaacttagtaataactatttcggcagacaaagcttataacaagttgccggcgcgtataa
+tatttaaaagaccccttgagctgctcaattaaaacgctcacctggtataggctattagat
+agtgccgtcttagtaaggggcgggaattatcggataaactgatattttgataaaataacc
+gacttgttcacgacataagtcactaaggagattttatctttctccaaagtatatcttcct
+tggataatttcaaagcgctgcaatttaagttctgttactagtttatgctgctgggaggtg
+accggaaggcgtagtaatctagaggcaaattataagaagttcatcatatcattttcgact
+acaaaaacaaggtgttgtatgccggcgcattgtgtaaactggacgagtaccctagatgga
+aaattatacgttaagccaagatttcgatgtaatgataattacctacacatttttgctatc
+cataggaacaagagctgttctataggctcgtggcatacgaacatttgctgccgctatgaa
+tattggaagctcttcaactacagactctattcttaattgccgtcgaaaatgggccgaatc
+ggctattattaatactcggtttttccgaggggattgttgtcgacagtcgtaattattatt
+aatattgatgttggtgaggtcatttaaatacaaccttgcagacaatgaataagggatcca
+atctctcatactccttttacaattgctcatgcccctatgcaaaccttatgccgccacacc
+tccgcaactctctcttctgaactgtaagtagcttcattactggtttgagactatactgaa
+gctgatgacattctaaaatggctattttcgaatgtgattcataatgtttatcgtttggga
+tggcagaatcacgttatttttgatatagcccgggtattctattgtatagaacgtatgcta
+caagtcattccccgaagaagactagaagtaaacaacatgcgaccatcgttaagccacgca
+aggctgtagctttatttcccgataacctatcttccataaatagcggacagcaggatactg
+acgctcaacatcagtggttatggtctaatttttaacttttaataaggtaacttcagcagg
+catacacagtaactctttaatttataatcaaattagaagtctgacacttcttatattttt
+ctatcatccaacgcgatcgcccattagcttattgtgttactaataacgtatctaaaccaa
+tccttttcaagctactgcctatattgtcaatatatacaaacaacaggatagtaggctgct
+taaaaaatattgtcaaccgtgtacgctttacaatacccggaaatcacaaactttgtagac
+aacgagtgaaatttatacactacgaagggccagcgtacaagacccatgaattaggcgata
+tgtttattctgacatattggtttatccttaatctgtcgctgtaaaatgaagccgccccca
+tccctgcgaattttttttcgaagattcacgactgaaatataaatacgtttggctatattt
+atgttggagggaggcaatagcctttactgttaaccgaagatttagccagtgagtgtgaca
+ctaaaacactggaataaatgcaggcgttcttctgggtaaaaggtttagtcaatctcgcct
+ataagttcatatagctctggatataattatctggcccatgcatttatcatggcgcttggt
+gccctgtgtgaagccggcctctcatattgaaggtccgaagtattccatgtacattaagat
+cactctctcattcatgcatcttggcttaacaaatctggttgtccaagctttccaggcacg
+tatggtacaaattcggatcgaatacttataaaaatgatatgttaaactgtctaaaacgct
+catctacaaagtaaagtgcactaaccaatagagtctcaagaccgtgtaatgctggtgcac
+tgaatgtgtaatacggttagaagggattagttatgttacaaatccattgaaaacttaaga
+agcattgcgtgctcggagggtgcatcttttatcaagagactaacattattttcaacgacg
+tacatgctttacaatagggtacttatcaaacgccgagaaacgcgcctatagtgatgttat
+gattatgacccgatatccattggaccgaattttatgtaggttcccagcgtactcgcgtaa
+tatctcggtattgccataatgtaatacttgtcggtctctcccagatgaaaaagcgttaca
+gagtatttcaatgaaaaacagcgcgcaacgtcaatacctttaggggtaacggccgctgat
+ttcatatagatatacgataagttggtatagctctactaggtggcatccacaatcgttgca
+tttactatagctggttacaatcataatctataccgttccttacatactaccatagcggga
+tagcgtttttttgccgttgattgggtttaagaggatgtcagtctcattatatccgattcg
+gtgggagagccgttgttttcaaatcgcacactttgtgacataatgtacaagataacaaaa
+ctgatataagatataaactgtcaatatcaccttgacacttgaatcaaagtaaattaactc
+gcaaatataatttgactaattgggtgcagatttctcaattaataaaaaaatggcaccgga
+tgggcttacaagccccttatcattcacttgtatcatgatttccaagaacaatagaatttg
+ctagcaagtatgaacagagattcgaattgcatccacagtacgccggagcgtttattttaa
+tgtggatatgacgatgtactgttggcggcatttgctagtaaccggtccttatttacgtag
+cgcacacgtaagcatgtctgggagaaatatggtggtacaatctcagagaaagattacagt
+ttggtttaaataggacttatcgggtcggaagtggaacttaataagcagtacacaattggg
+caacagacgtcttgcctattacaataggattacaatgcgttagatttcagacacgttcgt
+gtttggctattcgtcaattccctaaatagttagacgatcaactattatcaaagtgattct
+ttgttcatcctccattcatgtaacagatggcacactacgcataacgccgaggaattttaa
+cgagatttaagagagcagttcgggcacaacccacttgactttataacagctcggcagcat
+aaacggtaatatgtgacaaatttccaaacgttataagaacgtatgtgtacttagaaaact
+aagtggttcatgttcaacagatgtgacgcagcaagcctaacttatctattggttttgcta
+taaaagaacaaagttacacagaatcctaagggcttgtttcacacttatgcctagtgcttc
+accatcttaaaatagcgaaaccggcacgaatcaaaccttaaaacaatgcgcagatattgg
+tgatggtgactccgggtatgataatggtaactgttgaccagcgcccacctcatcgaagta
+tagaaagtggttaggataaggatgagaccgaacttatttccggccataactttagatttt
+ctacctagtacacaacatcagggcggacacgaaaccgccatcacatcatataccaggttt
+aatttgcttaatgggggaagtgtcaacgaaccttcgaactttagcaggcatatggccatt
+atatatggccccagagcagaatgctacagcagacaaaatttggatttatgtagtttaata
+cctatcaaacttggtgtgaccatacttgtctaacgacagtgcacaaagtgtaagttacaa
+ttattactactcagcagcttctgcaatgataaaatcttatcatacacgtcacatatgata
+atatctacttagggggaacgggctccacaacctacatagtactcaatacttacactattc
+gacaggcacaccaaacctgtacagtcccaaaagattgagtcaactttgcagtactgcaga
+tcacagtaatagcttagttagcgagtcaaaattagttttctacgagactgcacgaccgtg
+caaatttccgatgtgttggctacaaatagcaacgtatgaatttgtttgaagccacgtaaa
+ctgtacaaccttagagataagtctcaggctactaaaaacacgttgtggcactaacaggat
+catggttgattcttacttattcggctgaccggcccaataagtaaccttcaactagaacag
+aataatcgggagtagtttaattcagtcaaggtgcaggtctcattgtaactaacaagctct
+gtgtaaccaagttaaaatcgttttcttagcggattccctacttatggatttgagctcgtc
+cacaatattcgatacaagaagtttgtggtccgtaacaacgaaattttaattacgctgtgc
+agcctcatccaaggaattaatagaaggttgatggtaggctccgaacgctccatgattata
+atcaagtggactgtgcagtaaacgaggaaggtatcctgacgtcgtggtgttcgtttttgt
+tatttgtgccctatacgagtagataaaccatgaacagcacagtgtgaacccatggttgat
+tttaggctaccttatttttaatttccgttacacagaaacgaattccacaactaacatgcc
+attaatttttcgatatcttataaaagatggtcgaaattcattcatttattttttttcggt
+tctcgaaagtcaactaagctgtcgcgttttgtttctctttagaggtaaaagtggctttga
+tctcctacgtttggatactagtcaaccattactccatttgatccgtgagtatcacctgtc
+taacatccagcattatgactcctcggcgaagaaaagacacacttcttagagtcgatgtgt
+attagctagggacacagttgtttaatacgatagtgagcccagggagggcagtgcgtcccc
+cagtagatttattcagctagtgtaagtataagatatctcacccacgaggttcaagtgata
+tgcagtcttagaataatacttatcctgaatttcgatattatgggtacttcaataatccgc
+tagcgctactttatgtctcgttggacagcaggacacatggcagtcttaaacactaaagac
+atcacctgaatgaatgtaatgggattacaagaatcaatgaggtattatatacgacgtagg
+aaactctggatatatacagtaatctagttacgccatcgcacttcattcctctggaaactt
+agaagacatcagctgtacgtggaggaaccagacccccgtatgtagccaaatagaaccaaa
+gttgcttatacaaacacacccaatgacaatggaccgctggagttcgtaaactcggaacgt
+agtactgcacaaacccagcatttagcaataggagctacgtatgcaactcccacgtggtaa
+taccttcaagctatcaatatataggtgcctagctaatcgcattcgcaagcagtattcaag
+cttgtaaaccagtataataattacagaggctctatgaaacccaactttccagctaaaagt
+cccaattaaatggttatttc
diff --git a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/regexdna/regexdna.csharp-6.cs b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/regexdna/regexdna.csharp-6.cs
new file mode 100644
index 0000000000..19928012ba
--- /dev/null
+++ b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/regexdna/regexdna.csharp-6.cs
@@ -0,0 +1,230 @@
+// 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.
+/* The Computer Language Benchmarks Game
+   http://benchmarksgame.alioth.debian.org/
+ *
+ * contributed by Jimmy Tang
+ *
+ * modified for use with xunit-performance
+ */
+
+using Microsoft.Xunit.Performance;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Threading;
+
+[assembly: OptimizeForBenchmarks]
+[assembly: MeasureInstructionsRetired]
+
+namespace BenchmarksGame
+{
+
+public static class Regexdna
+{
+
+#if DEBUG
+    const bool Verbose = true;
+    const int Iterations = 1;
+    const string InputFile = "regexdna-input25.txt";
+#else
+    const bool Verbose = false;
+    const int Iterations = 6;
+    const string InputFile = "regexdna-input25000.txt";
+#endif
+
+   static string FindInput(string s)
+   {
+       string CoreRoot = System.Environment.GetEnvironmentVariable("CORE_ROOT");
+
+       if (CoreRoot == null)
+       {
+           Console.WriteLine("This benchmark requries CORE_ROOT to be set");
+           return null;
+       }
+
+       string inputFile = s ?? InputFile;
+
+       // Normal testing -- input file will end up next to the assembly
+       // and CoreRoot points at the test overlay dir
+       string[] pathPartsNormal = new string[] {
+           CoreRoot, "..", "..", "JIT", "Performance",
+           "CodeQuality", "BenchmarksGame", "regexdna", "regexdna", inputFile
+       };
+
+       string inputPathNormal = Path.Combine(pathPartsNormal);
+
+       // Perf testing -- input file will end up next to the assembly
+       // and CoreRoot points at this directory
+       string[] pathPartsPerf = new string[] { CoreRoot, inputFile };
+
+       string inputPathPerf = Path.Combine(pathPartsPerf);
+
+       string inputPath = null;
+
+       if (File.Exists(inputPathNormal))
+       {
+           inputPath = inputPathNormal;
+       }
+       else if (File.Exists(inputPathPerf))
+       {
+           inputPath = inputPathPerf;
+       }
+
+       if (inputPath != null)
+       {
+           Console.WriteLine("Using input file {0}", inputPath);
+       }
+       else
+       {
+           Console.WriteLine("Unable to find input file {0}", inputFile);
+       }
+
+       return inputPath;
+   }
+
+   public static int Main(string[] args)
+   {
+       string inputFile = InputFile;
+       int iterations = Iterations;
+       bool verbose = Verbose;
+
+       for (int i = 0; i < args.Length; i++)
+       {
+           if (args[i] == "-v")
+           {
+               verbose = true;
+           }
+           else if (args[i] == "-q")
+           {
+               verbose = false;
+           }
+           else if (args[i] == "-i")
+           {
+               i++;
+
+               if (i < args.Length)
+               {
+                   Int32.TryParse(args[i], out iterations);
+               }
+           }
+           else
+           {
+               inputFile = args[i];
+           }
+       }
+
+       string fullInputFile = FindInput(inputFile);
+
+       if (fullInputFile == null)
+       {
+           Console.WriteLine("unable to find input");
+           return -1;
+       }
+
+       if (iterations != Iterations)
+       {
+           Console.WriteLine("Running {0} iterations", iterations);
+       }
+
+       using (var r = File.OpenText(fullInputFile))
+       {
+           string sequence = r.ReadToEnd();
+
+           // Warmup
+
+           BenchInner(verbose, sequence);
+
+           Stopwatch sw = Stopwatch.StartNew();
+           for (int j = 0; j < iterations; j++)
+           {
+               BenchInner(verbose, sequence);
+           }
+           sw.Stop();
+
+           Console.WriteLine("regexdna [{0} iters]: {1}ms", iterations, sw.ElapsedMilliseconds);
+       }
+
+       return 100;
+   }
+
+   static void BenchInner(bool verbose, string sequence)
+   {
+       int initialLength = sequence.Length;
+
+       sequence = Regex.Replace(sequence, ">.*\n|\n", "");
+       int codeLength = sequence.Length;
+
+       string[] variants = {
+           "agggtaaa|tttaccct"
+           ,"[cgt]gggtaaa|tttaccc[acg]"
+           ,"a[act]ggtaaa|tttacc[agt]t"
+           ,"ag[act]gtaaa|tttac[agt]ct"
+           ,"agg[act]taaa|ttta[agt]cct"
+           ,"aggg[acg]aaa|ttt[cgt]ccct"
+           ,"agggt[cgt]aa|tt[acg]accct"
+           ,"agggta[cgt]a|t[acg]taccct"
+           ,"agggtaa[cgt]|[acg]ttaccct"
+       };
+
+       var flags = variants.Select((v, i) => {
+           var flag = new ManualResetEvent(false);
+           ThreadPool.QueueUserWorkItem(x => {
+               variants[i] += " " + Regex.Matches(sequence, v).Count;
+               flag.Set();
+           });
+           return flag;
+       });
+       WaitHandle.WaitAll(flags.ToArray());
+       if (verbose)
+       {
+           Console.WriteLine(string.Join("\n", variants));
+       }
+
+       var dict = new Dictionary<string, string> {
+           {"B", "(c|g|t)"}, {"D", "(a|g|t)"},   {"H", "(a|c|t)"}, {"K", "(g|t)"},
+           {"M", "(a|c)"},   {"N", "(a|c|g|t)"}, {"R", "(a|g)"},   {"S", "(c|g)"},
+           {"V", "(a|c|g)"}, {"W", "(a|t)"},     {"Y", "(c|t)"}
+       };
+
+       sequence = new Regex("[WYKMSRBDVHN]").Replace(sequence, m => dict[m.Value]);
+
+       if (verbose)
+       {
+           Console.WriteLine("\n{0}\n{1}\n{2}", initialLength, codeLength, sequence.Length);
+       }
+   }
+
+   [Benchmark]
+   public static void Bench()
+   {
+       string fullInputFile = FindInput(InputFile);
+
+       if (fullInputFile == null)
+       {
+           throw new Exception("unable to find input");
+       }
+
+       using (var r = File.OpenText(fullInputFile))
+       {
+           string sequence = r.ReadToEnd();
+
+           foreach (var iteration in Benchmark.Iterations)
+           {
+               using (iteration.StartMeasurement())
+               {
+                   for (int i = 0; i < Iterations; i++)
+                   {
+                       BenchInner(false, sequence);
+                   }
+               }
+           }
+       }
+   }
+}
+
+}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeCompareTo1.csproj b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/regexdna/regexdna.csproj
index 93ba3ddb4a..e77f257b42 100644
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeCompareTo1.csproj
+++ b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/regexdna/regexdna.csproj
@@ -13,33 +13,41 @@
     <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
     <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
+    <NuGetTargetMoniker>.NETStandard,Version=v1.4</NuGetTargetMoniker>
   </PropertyGroup>
   <!-- Default configurations to help VS understand the configurations -->
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
   </PropertyGroup>
+  <PropertyGroup>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+  </PropertyGroup>
   <ItemGroup>
     <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
       <Visible>False</Visible>
     </CodeAnalysisDependentAssemblyPaths>
   </ItemGroup>
   <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimecompareto1.cs" />
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
   <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+    <Compile Include="regexdna.csharp-6.cs" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
+    <Content Include="regexdna-input25.txt">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
+    <Content Include="regexdna-input25000.txt">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
   </ItemGroup>
+  <PropertyGroup>
+    <ProjectJson>$(JitPackagesConfigFileDirectory)benchmark\project.json</ProjectJson>
+    <ProjectLockJson>$(JitPackagesConfigFileDirectory)benchmark\project.lock.json</ProjectLockJson>
+  </PropertyGroup>
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
   <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
   </PropertyGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/revcomp/revcomp-input25.txt b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/revcomp/revcomp-input25.txt
new file mode 100644
index 0000000000..f749b06ea7
--- /dev/null
+++ b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/revcomp/revcomp-input25.txt
@@ -0,0 +1,9 @@
+>ONE Homo sapiens alu
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+>TWO IUB ambiguity codes
+cttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcg
+tactDtDagcctatt
+>THREE Homo sapiens frequency
+gtttgtgttgcgttatagtctatttgtggacacagtatggtcaaatgacgtcttttgatc
+tgacggcgttaacaaagatactctgggcaacacacatacttctctcatgttgtttcttcg
+gacct
diff --git a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/revcomp/revcomp-input25000.txt b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/revcomp/revcomp-input25000.txt
new file mode 100644
index 0000000000..fd4414b176
--- /dev/null
+++ b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/revcomp/revcomp-input25000.txt
@@ -0,0 +1,4171 @@
+>ONE Homo sapiens alu
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATC
+>TWO IUB ambiguity codes
+cttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcg
+tactDtDagcctatttSVHtHttKtgtHMaSattgWaHKHttttagacatWatgtRgaaa
+NtactMcSMtYtcMgRtacttctWBacgaaatatagScDtttgaagacacatagtVgYgt
+cattHWtMMWcStgttaggKtSgaYaaccWStcgBttgcgaMttBYatcWtgacaYcaga
+gtaBDtRacttttcWatMttDBcatWtatcttactaBgaYtcttgttttttttYaaScYa
+HgtgttNtSatcMtcVaaaStccRcctDaataataStcYtRDSaMtDttgttSagtRRca
+tttHatSttMtWgtcgtatSSagactYaaattcaMtWatttaSgYttaRgKaRtccactt
+tattRggaMcDaWaWagttttgacatgttctacaaaRaatataataaMttcgDacgaSSt
+acaStYRctVaNMtMgtaggcKatcttttattaaaaagVWaHKYagtttttatttaacct
+tacgtVtcVaattVMBcttaMtttaStgacttagattWWacVtgWYagWVRctDattBYt
+gtttaagaagattattgacVatMaacattVctgtBSgaVtgWWggaKHaatKWcBScSWa
+accRVacacaaactaccScattRatatKVtactatatttHttaagtttSKtRtacaaagt
+RDttcaaaaWgcacatWaDgtDKacgaacaattacaRNWaatHtttStgttattaaMtgt
+tgDcgtMgcatBtgcttcgcgaDWgagctgcgaggggVtaaScNatttacttaatgacag
+cccccacatYScaMgtaggtYaNgttctgaMaacNaMRaacaaacaKctacatagYWctg
+ttWaaataaaataRattagHacacaagcgKatacBttRttaagtatttccgatctHSaat
+actcNttMaagtattMtgRtgaMgcataatHcMtaBSaRattagttgatHtMttaaKagg
+YtaaBataSaVatactWtataVWgKgttaaaacagtgcgRatatacatVtHRtVYataSa
+KtWaStVcNKHKttactatccctcatgWHatWaRcttactaggatctataDtDHBttata
+aaaHgtacVtagaYttYaKcctattcttcttaataNDaaggaaaDYgcggctaaWSctBa
+aNtgctggMBaKctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacg
+gtttNattgVtttctgtBaWgtaattcaagtcaVWtactNggattctttaYtaaagccgc
+tcttagHVggaYtgtNcDaVagctctctKgacgtatagYcctRYHDtgBattDaaDgccK
+tcHaaStttMcctagtattgcRgWBaVatHaaaataYtgtttagMDMRtaataaggatMt
+ttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtcattttcWattRSHcVagaagtacg
+ggtaKVattKYagactNaatgtttgKMMgYNtcccgSKttctaStatatNVataYHgtNa
+BKRgNacaactgatttcctttaNcgatttctctataScaHtataRagtcRVttacDSDtt
+aRtSatacHgtSKacYagttMHtWataggatgactNtatSaNctataVtttRNKtgRacc
+tttYtatgttactttttcctttaaacatacaHactMacacggtWataMtBVacRaSaatc
+cgtaBVttccagccBcttaRKtgtgcctttttRtgtcagcRttKtaaacKtaaatctcac
+aattgcaNtSBaaccgggttattaaBcKatDagttactcttcattVtttHaaggctKKga
+tacatcBggScagtVcacattttgaHaDSgHatRMaHWggtatatRgccDttcgtatcga
+aacaHtaagttaRatgaVacttagattVKtaaYttaaatcaNatccRttRRaMScNaaaD
+gttVHWgtcHaaHgacVaWtgttScactaagSgttatcttagggDtaccagWattWtRtg
+ttHWHacgattBtgVcaYatcggttgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcV
+taBtWaaYatcDRaaRtSctgaHaYRttagatMatgcatttNattaDttaattgttctaa
+ccctcccctagaWBtttHtBccttagaVaatMcBHagaVcWcagBVttcBtaYMccagat
+gaaaaHctctaacgttagNWRtcggattNatcRaNHttcagtKttttgWatWttcSaNgg
+gaWtactKKMaacatKatacNattgctWtatctaVgagctatgtRaHtYcWcttagccaa
+tYttWttaWSSttaHcaaaaagVacVgtaVaRMgattaVcDactttcHHggHRtgNcctt
+tYatcatKgctcctctatVcaaaaKaaaagtatatctgMtWtaaaacaStttMtcgactt
+taSatcgDataaactaaacaagtaaVctaggaSccaatMVtaaSKNVattttgHccatca
+cBVctgcaVatVttRtactgtVcaattHgtaaattaaattttYtatattaaRSgYtgBag
+aHSBDgtagcacRHtYcBgtcacttacactaYcgctWtattgSHtSatcataaatataHt
+cgtYaaMNgBaatttaRgaMaatatttBtttaaaHHKaatctgatWatYaacttMctctt
+ttVctagctDaaagtaVaKaKRtaacBgtatccaaccactHHaagaagaaggaNaaatBW
+attccgStaMSaMatBttgcatgRSacgttVVtaaDMtcSgVatWcaSatcttttVatag
+ttactttacgatcaccNtaDVgSRcgVcgtgaacgaNtaNatatagtHtMgtHcMtagaa
+attBgtataRaaaacaYKgtRccYtatgaagtaataKgtaaMttgaaRVatgcagaKStc
+tHNaaatctBBtcttaYaBWHgtVtgacagcaRcataWctcaBcYacYgatDgtDHccta
+aagacYRcaggattHaYgtKtaatgcVcaataMYacccatatcacgWDBtgaatcBaata
+cKcttRaRtgatgaBDacggtaattaaYtataStgVHDtDctgactcaaatKtacaatgc
+gYatBtRaDatHaactgtttatatDttttaaaKVccYcaaccNcBcgHaaVcattHctcg
+attaaatBtatgcaaaaatYMctSactHatacgaWacattacMBgHttcgaatVaaaaca
+BatatVtctgaaaaWtctRacgBMaatSgRgtgtcgactatcRtattaScctaStagKga
+DcWgtYtDDWKRgRtHatRtggtcgaHgggcgtattaMgtcagccaBggWVcWctVaaat
+tcgNaatcKWagcNaHtgaaaSaaagctcYctttRVtaaaatNtataaccKtaRgtttaM
+tgtKaBtRtNaggaSattHatatWactcagtgtactaKctatttgRYYatKatgtccgtR
+tttttatttaatatVgKtttgtatgtNtataRatWYNgtRtHggtaaKaYtKSDcatcKg
+taaYatcSRctaVtSMWtVtRWHatttagataDtVggacagVcgKWagBgatBtaaagNc
+aRtagcataBggactaacacRctKgttaatcctHgDgttKHHagttgttaatgHBtatHc
+DaagtVaBaRccctVgtgDtacRHSctaagagcggWYaBtSaKtHBtaaactYacgNKBa
+VYgtaacttagtVttcttaatgtBtatMtMtttaattaatBWccatRtttcatagVgMMt
+agctStKctaMactacDNYgKYHgaWcgaHgagattacVgtttgtRaSttaWaVgataat
+gtgtYtaStattattMtNgWtgttKaccaatagNYttattcgtatHcWtctaaaNVYKKt
+tWtggcDtcgaagtNcagatacgcattaagaccWctgcagcttggNSgaNcHggatgtVt
+catNtRaaBNcHVagagaaBtaaSggDaatWaatRccaVgggStctDaacataKttKatt
+tggacYtattcSatcttagcaatgaVBMcttDattctYaaRgatgcattttNgVHtKcYR
+aatRKctgtaaacRatVSagctgtWacBtKVatctgttttKcgtctaaDcaagtatcSat
+aWVgcKKataWaYttcccSaatgaaaacccWgcRctWatNcWtBRttYaattataaNgac
+acaatagtttVNtataNaYtaatRaVWKtBatKagtaatataDaNaaaaataMtaagaaS
+tccBcaatNgaataWtHaNactgtcDtRcYaaVaaaaaDgtttRatctatgHtgttKtga
+aNSgatactttcgagWaaatctKaaDaRttgtggKKagcDgataaattgSaacWaVtaNM
+acKtcaDaaatttctRaaVcagNacaScRBatatctRatcctaNatWgRtcDcSaWSgtt
+RtKaRtMtKaatgttBHcYaaBtgatSgaSWaScMgatNtctcctatttctYtatMatMt
+RRtSaattaMtagaaaaStcgVgRttSVaScagtgDtttatcatcatacRcatatDctta
+tcatVRtttataaHtattcYtcaaaatactttgVctagtaaYttagatagtSYacKaaac
+gaaKtaaatagataatSatatgaaatSgKtaatVtttatcctgKHaatHattagaaccgt
+YaaHactRcggSBNgtgctaaBagBttgtRttaaattYtVRaaaattgtaatVatttctc
+ttcatgBcVgtgKgaHaaatattYatagWacNctgaaMcgaattStagWaSgtaaKagtt
+ttaagaDgatKcctgtaHtcatggKttVDatcaaggtYcgccagNgtgcVttttagagat
+gctaccacggggtNttttaSHaNtatNcctcatSaaVgtactgBHtagcaYggYVKNgta
+KBcRttgaWatgaatVtagtcgattYgatgtaatttacDacSctgctaaaStttaWMagD
+aaatcaVYctccgggcgaVtaaWtStaKMgDtttcaaMtVgBaatccagNaaatcYRMBg
+gttWtaaScKttMWtYataRaDBMaDataatHBcacDaaKDactaMgagttDattaHatH
+taYatDtattDcRNStgaatattSDttggtattaaNSYacttcDMgYgBatWtaMagact
+VWttctttgYMaYaacRgHWaattgRtaagcattctMKVStatactacHVtatgatcBtV
+NataaBttYtSttacKgggWgYDtgaVtYgatDaacattYgatggtRDaVDttNactaSa
+MtgNttaacaaSaBStcDctaccacagacgcaHatMataWKYtaYattMcaMtgSttDag
+cHacgatcaHttYaKHggagttccgatYcaatgatRaVRcaagatcagtatggScctata
+ttaNtagcgacgtgKaaWaactSgagtMYtcttccaKtStaacggMtaagNttattatcg
+tctaRcactctctDtaacWYtgaYaSaagaWtNtatttRacatgNaatgttattgWDDcN
+aHcctgaaHacSgaataaRaataMHttatMtgaSDSKatatHHaNtacagtccaYatWtc
+actaactatKDacSaStcggataHgYatagKtaatKagStaNgtatactatggRHacttg
+tattatgtDVagDVaRctacMYattDgtttYgtctatggtKaRSttRccRtaaccttaga
+gRatagSaaMaacgcaNtatgaaatcaRaagataatagatactcHaaYKBctccaagaRa
+BaStNagataggcgaatgaMtagaatgtcaKttaaatgtaWcaBttaatRcggtgNcaca
+aKtttScRtWtgcatagtttWYaagBttDKgcctttatMggNttattBtctagVtacata
+aaYttacacaaRttcYtWttgHcaYYtaMgBaBatctNgcDtNttacgacDcgataaSat
+YaSttWtcctatKaatgcagHaVaacgctgcatDtgttaSataaaaYSNttatagtaNYt
+aDaaaNtggggacttaBggcHgcgtNtaaMcctggtVtaKcgNacNtatVaSWctWtgaW
+cggNaBagctctgaYataMgaagatBSttctatacttgtgtKtaattttRagtDtacata
+tatatgatNHVgBMtKtaKaNttDHaagatactHaccHtcatttaaagttVaMcNgHata
+tKtaNtgYMccttatcaaNagctggacStttcNtggcaVtattactHaSttatgNMVatt
+MMDtMactattattgWMSgtHBttStStgatatRaDaagattttctatMtaaaaaggtac
+taaVttaSacNaatactgMttgacHaHRttgMacaaaatagttaatatWKRgacDgaRta
+tatttattatcYttaWtgtBRtWatgHaaattHataagtVaDtWaVaWtgStcgtMSgaS
+RgMKtaaataVacataatgtaSaatttagtcgaaHtaKaatgcacatcggRaggSKctDc
+agtcSttcccStYtccRtctctYtcaaKcgagtaMttttcRaYDttgttatctaatcata
+NctctgctatcaMatactataggDaHaaSttMtaDtcNatataattctMcStaaBYtaNa
+gatgtaatHagagSttgWHVcttatKaYgDctcttggtgttMcRaVgSgggtagacaata
+aDtaattSaDaNaHaBctattgNtaccaaRgaVtKNtaaYggHtaKKgHcatctWtctDt
+ttctttggSDtNtaStagttataaacaattgcaBaBWggHgcaaaBtYgctaatgaaatW
+cDcttHtcMtWWattBHatcatcaaatctKMagtDNatttWaBtHaaaNgMttaaStagt
+tctctaatDtcRVaYttgttMtRtgtcaSaaYVgSWDRtaatagctcagDgcWWaaaBaa
+RaBctgVgggNgDWStNaNBKcBctaaKtttDcttBaaggBttgaccatgaaaNgttttt
+tttatctatgttataccaaDRaaSagtaVtDtcaWatBtacattaWacttaSgtattggD
+gKaaatScaattacgWcagKHaaccaYcRcaRttaDttRtttHgaHVggcttBaRgtccc
+tDatKaVtKtcRgYtaKttacgtatBtStaagcaattaagaRgBagSaattccSWYttta
+ttVaataNctgHgttaaNBgcVYgtRtcccagWNaaaacaDNaBcaaaaRVtcWMgBagM
+tttattacgDacttBtactatcattggaaatVccggttRttcatagttVYcatYaSHaHc
+ttaaagcNWaHataaaRWtctVtRYtagHtaaaYMataHYtNBctNtKaatattStgaMc
+BtRgctaKtgcScSttDgYatcVtggaaKtaagatWccHccgKYctaNNctacaWctttt
+gcRtgtVcgaKttcMRHgctaHtVaataaDtatgKDcttatBtDttggNtacttttMtga
+acRattaaNagaactcaaaBBVtcDtcgaStaDctgaaaSgttMaDtcgttcaccaaaag
+gWtcKcgSMtcDtatgtttStaaBtatagDcatYatWtaaaBacaKgcaDatgRggaaYc
+taRtccagattDaWtttggacBaVcHtHtaacDacYgtaatataMagaatgHMatcttat
+acgtatttttatattacHactgttataMgStYaattYaccaattgagtcaaattaYtgta
+tcatgMcaDcgggtcttDtKgcatgWRtataatatRacacNRBttcHtBgcRttgtgcgt
+catacMtttBctatctBaatcattMttMYgattaaVYatgDaatVagtattDacaacDMa
+tcMtHcccataagatgBggaccattVWtRtSacatgctcaaggggYtttDtaaNgNtaaB
+atggaatgtctRtaBgBtcNYatatNRtagaacMgagSaSDDSaDcctRagtVWSHtVSR
+ggaacaBVaccgtttaStagaacaMtactccagtttVctaaRaaHttNcttagcaattta
+ttaatRtaaaatctaacDaBttggSagagctacHtaaRWgattcaaBtctRtSHaNtgta
+cattVcaHaNaagtataccacaWtaRtaaVKgMYaWgttaKggKMtKcgWatcaDatYtK
+SttgtacgaccNctSaattcDcatcttcaaaDKttacHtggttHggRRaRcaWacaMtBW
+VHSHgaaMcKattgtaRWttScNattBBatYtaNRgcggaagacHSaattRtttcYgacc
+BRccMacccKgatgaacttcgDgHcaaaaaRtatatDtatYVtttttHgSHaSaatagct
+NYtaHYaVYttattNtttgaaaYtaKttWtctaNtgagaaaNctNDctaaHgttagDcRt
+tatagccBaacgcaRBtRctRtggtaMYYttWtgataatcgaataattattataVaaaaa
+ttacNRVYcaaMacNatRttcKatMctgaagactaattataaYgcKcaSYaatMNctcaa
+cgtgatttttBacNtgatDccaattattKWWcattttatatatgatBcDtaaaagttgaa
+VtaHtaHHtBtataRBgtgDtaataMttRtDgDcttattNtggtctatctaaBcatctaR
+atgNacWtaatgaagtcMNaacNgHttatactaWgcNtaStaRgttaaHacccgaYStac
+aaaatWggaYaWgaattattcMaactcBKaaaRVNcaNRDcYcgaBctKaacaaaaaSgc
+tccYBBHYaVagaatagaaaacagYtctVccaMtcgtttVatcaatttDRtgWctagtac
+RttMctgtDctttcKtWttttataaatgVttgBKtgtKWDaWagMtaaagaaattDVtag
+gttacatcatttatgtcgMHaVcttaBtVRtcgtaYgBRHatttHgaBcKaYWaatcNSc
+tagtaaaaatttacaatcactSWacgtaatgKttWattagttttNaggtctcaagtcact
+attcttctaagKggaataMgtttcataagataaaaatagattatDgcBVHWgaBKttDgc
+atRHaagcaYcRaattattatgtMatatattgHDtcaDtcaaaHctStattaatHaccga
+cNattgatatattttgtgtDtRatagSacaMtcRtcattcccgacacSattgttKaWatt
+NHcaacttccgtttSRtgtctgDcgctcaaMagVtBctBMcMcWtgtaacgactctcttR
+ggRKSttgYtYatDccagttDgaKccacgVatWcataVaaagaataMgtgataaKYaaat
+cHDaacgataYctRtcYatcgcaMgtNttaBttttgatttaRtStgcaacaaaataccVg
+aaDgtVgDcStctatatttattaaaaRKDatagaaagaKaaYYcaYSgKStctccSttac
+agtcNactttDVttagaaagMHttRaNcSaRaMgBttattggtttaRMggatggcKDgWR
+tNaataataWKKacttcKWaaagNaBttaBatMHtccattaacttccccYtcBcYRtaga
+ttaagctaaYBDttaNtgaaaccHcaRMtKtaaHMcNBttaNaNcVcgVttWNtDaBatg
+ataaVtcWKcttRggWatcattgaRagHgaattNtatttctctattaattaatgaDaaMa
+tacgttgggcHaYVaaNaDDttHtcaaHtcVVDgBVagcMacgtgttaaBRNtatRtcag
+taagaggtttaagacaVaaggttaWatctccgtVtaDtcDatttccVatgtacNtttccg
+tHttatKgScBatgtVgHtYcWagcaKtaMYaaHgtaattaSaHcgcagtWNaatNccNN
+YcacgVaagaRacttctcattcccRtgtgtaattagcSttaaStWaMtctNNcSMacatt
+ataaactaDgtatWgtagtttaagaaaattgtagtNagtcaataaatttgatMMYactaa
+tatcggBWDtVcYttcDHtVttatacYaRgaMaacaStaatcRttttVtagaDtcacWat
+ttWtgaaaagaaagNRacDtttStVatBaDNtaactatatcBSMcccaSttccggaMatg
+attaaWatKMaBaBatttgataNctgttKtVaagtcagScgaaaDggaWgtgttttKtWt
+atttHaatgtagttcactaaKMagttSYBtKtaYgaactcagagRtatagtVtatcaaaW
+YagcgNtaDagtacNSaaYDgatBgtcgataacYDtaaactacagWDcYKaagtttatta
+gcatcgagttKcatDaattgattatDtcagRtWSKtcgNtMaaaaacaMttKcaWcaaSV
+MaaaccagMVtaMaDtMaHaBgaacataBBVtaatVYaNSWcSgNtDNaaKacacBttta
+tKtgtttcaaHaMctcagtaacgtcgYtactDcgcctaNgagagcYgatattttaaattt
+ccattttacatttDaaRctattttWctttacgtDatYtttcagacgcaaVttagtaaKaa
+aRtgVtccataBggacttatttgtttaWNtgttVWtaWNVDaattgtatttBaagcBtaa
+BttaaVatcHcaVgacattccNggtcgacKttaaaRtagRtctWagaYggtgMtataatM
+tgaaRttattttgWcttNtDRRgMDKacagaaaaggaaaRStcccagtYccVattaNaaK
+StNWtgacaVtagaagcttSaaDtcacaacgDYacWDYtgtttKatcVtgcMaDaSKStV
+cgtagaaWaKaagtttcHaHgMgMtctataagBtKaaaKKcactggagRRttaagaBaaN
+atVVcgRcKSttDaactagtSttSattgttgaaRYatggttVttaataaHttccaagDtg
+atNWtaagHtgcYtaactRgcaatgMgtgtRaatRaNaacHKtagactactggaatttcg
+ccataacgMctRgatgttaccctaHgtgWaYcactcacYaattcttaBtgacttaaacct
+gYgaWatgBttcttVttcgttWttMcNYgtaaaatctYgMgaaattacNgaHgaacDVVM
+tttggtHtctaaRgtacagacgHtVtaBMNBgattagcttaRcttacaHcRctgttcaaD
+BggttKaacatgKtttYataVaNattccgMcgcgtagtRaVVaattaKaatggttRgaMc
+agtatcWBttNtHagctaatctagaaNaaacaYBctatcgcVctBtgcaaagDgttVtga
+HtactSNYtaaNccatgtgDacgaVtDcgKaRtacDcttgctaagggcagMDagggtBWR
+tttSgccttttttaacgtcHctaVtVDtagatcaNMaVtcVacatHctDWNaataRgcgt
+aVHaggtaaaaSgtttMtattDgBtctgatSgtRagagYtctSaKWaataMgattRKtaa
+catttYcgtaacacattRWtBtcggtaaatMtaaacBatttctKagtcDtttgcBtKYYB
+aKttctVttgttaDtgattttcttccacttgSaaacggaaaNDaattcYNNaWcgaaYat
+tttMgcBtcatRtgtaaagatgaWtgaccaYBHgaatagataVVtHtttVgYBtMctaMt
+cctgaDcYttgtccaaaRNtacagcMctKaaaggatttacatgtttaaWSaYaKttBtag
+DacactagctMtttNaKtctttcNcSattNacttggaacaatDagtattRtgSHaataat
+gccVgacccgatactatccctgtRctttgagaSgatcatatcgDcagWaaHSgctYYWta
+tHttggttctttatVattatcgactaagtgtagcatVgtgHMtttgtttcgttaKattcM
+atttgtttWcaaStNatgtHcaaaDtaagBaKBtRgaBgDtSagtatMtaacYaatYtVc
+KatgtgcaacVaaaatactKcRgtaYtgtNgBBNcKtcttaccttKgaRaYcaNKtactt
+tgagSBtgtRagaNgcaaaNcacagtVtttHWatgttaNatBgtttaatNgVtctgaata
+tcaRtattcttttttttRaaKcRStctcggDgKagattaMaaaKtcaHacttaataataK
+taRgDtKVBttttcgtKaggHHcatgttagHggttNctcgtatKKagVagRaaaggaaBt
+NatttVKcRttaHctaHtcaaatgtaggHccaBataNaNaggttgcWaatctgatYcaaa
+HaatWtaVgaaBttagtaagaKKtaaaKtRHatMaDBtBctagcatWtatttgWttVaaa
+ScMNattRactttgtYtttaaaagtaagtMtaMaSttMBtatgaBtttaKtgaatgagYg
+tNNacMtcNRacMMHcttWtgtRtctttaacaacattattcYaMagBaacYttMatcttK
+cRMtgMNccattaRttNatHaHNaSaaHMacacaVaatacaKaSttHatattMtVatWga
+ttttttaYctttKttHgScWaacgHtttcaVaaMgaacagNatcgttaacaaaaagtaca
+HBNaattgttKtcttVttaaBtctgctacgBgcWtttcaggacacatMgacatcccagcg
+gMgaVKaBattgacttaatgacacacaaaaaatRKaaBctacgtRaDcgtagcVBaacDS
+BHaaaaSacatatacagacRNatcttNaaVtaaaataHattagtaaaaSWccgtatWatg
+gDttaactattgcccatcttHaSgYataBttBaactattBtcHtgatcaataSttaBtat
+KSHYttWggtcYtttBttaataccRgVatStaHaKagaatNtagRMNgtcttYaaSaact
+cagDSgagaaYtMttDtMRVgWKWtgMaKtKaDttttgactatacataatcNtatNaHat
+tVagacgYgatatatttttgtStWaaatctWaMgagaRttRatacgStgattcttaagaD
+taWccaaatRcagcagaaNKagtaaDggcgccBtYtagSBMtactaaataMataBSacRM
+gDgattMMgtcHtcaYDtRaDaacggttDaggcMtttatgttaNctaattaVacgaaMMt
+aatDccSgtattgaRtWWaccaccgagtactMcgVNgctDctaMScatagcgtcaactat
+acRacgHRttgctatttaatgaattataYKttgtaagWgtYttgcHgMtaMattWaWVta
+RgcttgYgttBHtYataSccStBtgtagMgtDtggcVaaSBaatagDttgBgtctttctc
+attttaNagtHKtaMWcYactVcgcgtatMVtttRacVagDaatcttgctBBcRDgcaac
+KttgatSKtYtagBMagaRtcgBattHcBWcaactgatttaatttWDccatttatcgagS
+KaWttataHactaHMttaatHtggaHtHagaatgtKtaaRactgtttMatacgatcaagD
+gatKaDctataMggtHDtggHacctttRtatcttYattttgacttgaaSaataaatYcgB
+aaaaccgNatVBttMacHaKaataagtatKgtcaagactcttaHttcggaattgttDtct
+aaccHttttWaaatgaaatataaaWattccYDtKtaaaacggtgaggWVtctattagtga
+ctattaagtMgtttaagcatttgSgaaatatccHaaggMaaaattttcWtatKctagDtY
+tMcctagagHcactttactatacaaacattaacttaHatcVMYattYgVgtMttaaRtga
+aataaDatcaHgtHHatKcDYaatcttMtNcgatYatgSaMaNtcttKcWataScKggta
+tcttacgcttWaaagNatgMgHtctttNtaacVtgttcMaaRatccggggactcMtttaY
+MtcWRgNctgNccKatcttgYDcMgattNYaRagatHaaHgKctcataRDttacatBatc
+cattgDWttatttaWgtcggagaaaaatacaatacSNtgggtttccttacSMaagBatta
+caMaNcactMttatgaRBacYcYtcaaaWtagctSaacttWgDMHgaggatgBVgcHaDt
+ggaactttggtcNatNgtaKaBcccaNtaagttBaacagtatacDYttcctNgWgcgSMc
+acatStctHatgRcNcgtacacaatRttMggaNKKggataaaSaYcMVcMgtaMaHtgat
+tYMatYcggtcttcctHtcDccgtgRatcattgcgccgatatMaaYaataaYSggatagc
+gcBtNtaaaScaKgttBgagVagttaKagagtatVaactaSacWactSaKatWccaKaaa
+atBKgaaKtDMattttgtaaatcRctMatcaaMagMttDgVatggMaaWgttcgaWatga
+aatttgRtYtattaWHKcRgctacatKttctaccaaHttRatctaYattaaWatVNccat
+NgagtcKttKataStRaatatattcctRWatDctVagttYDgSBaatYgttttgtVaatt
+taatagcagMatRaacttBctattgtMagagattaaactaMatVtHtaaatctRgaaaaa
+aaatttWacaacaYccYDSaattMatgaccKtaBKWBattgtcaagcHKaagttMMtaat
+ttcKcMagNaaKagattggMagaggtaatttYacatcWaaDgatMgKHacMacgcVaaca
+DtaDatatYggttBcgtatgWgaSatttgtagaHYRVacaRtctHaaRtatgaactaata
+tctSSBgggaaHMWtcaagatKgagtDaSatagttgattVRatNtctMtcSaagaSHaat
+aNataataRaaRgattctttaataaagWaRHcYgcatgtWRcttgaaggaMcaataBRaa
+ccagStaaacNtttcaatataYtaatatgHaDgcStcWttaacctaRgtYaRtataKtgM
+ttttatgactaaaatttacYatcccRWtttHRtattaaatgtttatatttgttYaatMca
+RcSVaaDatcgtaYMcatgtagacatgaaattgRtcaaYaaYtRBatKacttataccaNa
+aattVaBtctggacaagKaaYaaatatWtMtatcYaaVNtcgHaactBaagKcHgtctac
+aatWtaDtSgtaHcataHtactgataNctRgttMtDcDttatHtcgtacatcccaggStt
+aBgtcacacWtccNMcNatMVaVgtccDYStatMaccDatggYaRKaaagataRatttHK
+tSaaatDgataaacttaHgttgVBtcttVttHgDacgaKatgtatatNYataactctSat
+atatattgcHRRYttStggaactHgttttYtttaWtatMcttttctatctDtagVHYgMR
+BgtHttcctaatYRttKtaagatggaVRataKDctaMtKBNtMtHNtWtttYcVtattMc
+gRaacMcctNSctcatttaaagDcaHtYccSgatgcaatYaaaaDcttcgtaWtaattct
+cgttttScttggtaatctttYgtctaactKataHacctMctcttacHtKataacacagcN
+RatgKatttttSaaatRYcgDttaMRcgaaattactMtgcgtaagcgttatBtttttaat
+taagtNacatHgttcRgacKcBBtVgatKttcgaBaatactDRgtRtgaNacWtcacYtt
+aaKcgttctHaKttaNaMgWgWaggtctRgaKgWttSttBtDcNtgtttacaaatYcDRt
+gVtgcctattcNtctaaaDMNttttNtggctgagaVctDaacVtWccaagtaacacaNct
+gaScattccDHcVBatcgatgtMtaatBgHaatDctMYgagaatgYWKcctaatNaStHa
+aaKccgHgcgtYaaYtattgtStgtgcaaRtattaKatattagaWVtcaMtBagttatta
+gNaWHcVgcaattttDcMtgtaRHVYtHtctgtaaaaHVtMKacatcgNaatttMatatg
+ttgttactagWYtaRacgataKagYNKcattataNaRtgaacKaYgcaaYYacaNccHat
+MatDcNgtHttRaWttagaaDcaaaaaatagggtKDtStaDaRtaVtHWKNtgtattVct
+SVgRgataDaRaWataBgaagaaKtaataaYgDcaStaNgtaDaaggtattHaRaWMYaY
+aWtggttHYgagVtgtgcttttcaaDKcagVcgttagacNaaWtagtaataDttctggtt
+VcatcataaagtgKaaaNaMtaBBaattaatWaattgctHaVKaSgDaaVKaHtatatat
+HatcatSBagNgHtatcHYMHgttDgtaHtBttWatcgtttaRaattgStKgSKNWKatc
+agDtctcagatttctRtYtBatBgHHtKaWtgYBgacVVWaKtacKcDttKMaKaVcggt
+gttataagaataaHaatattagtataatMHgttYgaRttagtaRtcaaVatacggtcMcg
+agtaaRttacWgactKRYataaaagSattYaWgagatYagKagatgSaagKgttaatMgg
+tataatgttWYttatgagaaacctNVataatHcccKtDctcctaatactggctHggaSag
+gRtKHaWaattcgSatMatttagaggcYtctaMcgctcataSatatgRagacNaaDagga
+VBagaYttKtacNaKgtSYtagttggaWcatcWttaatctatgaVtcgtgtMtatcaYcg
+tRccaaYgDctgcMgtgtWgacWtgataacacgcgctBtgttaKtYDtatDcatcagKaV
+MctaatcttgVcaaRgcRMtDcgattaHttcaNatgaatMtactacVgtRgatggaWttt
+actaaKatgagSaaKggtaNtactVaYtaaKRagaacccacaMtaaMtKtatBcttgtaa
+WBtMctaataaVcDaaYtcRHBtcgttNtaaHatttBNgRStVDattBatVtaagttaYa
+tVattaagaBcacggtSgtVtatttaRattgatgtaHDKgcaatattKtggcctatgaWD
+KRYcggattgRctatNgatacaatMNttctgtcRBYRaaaHctNYattcHtaWcaattct
+BtMKtVgYataatMgYtcagcttMDataVtggRtKtgaatgccNcRttcaMtRgattaac
+attRcagcctHtWMtgtDRagaKaBtgDttYaaaaKatKgatctVaaYaacWcgcatagB
+VtaNtRtYRaggBaaBtgKgttacataagagcatgtRattccacttaccatRaaatgWgD
+aMHaYVgVtaSctatcgKaatatattaDgacccYagtgtaYNaaatKcagtBRgagtcca
+tgKgaaaccBgaagBtgSttWtacgatWHaYatcgatttRaaNRgcaNaKVacaNtDgat
+tgHVaatcDaagcgtatgcNttaDataatcSataaKcaataaHWataBtttatBtcaKtK
+tatagttaDgSaYctacaRatNtaWctSaatatttYaKaKtaccWtatcRagacttaYtt
+VcKgSDcgagaagatccHtaattctSttatggtKYgtMaHagVaBRatttctgtRgtcta
+tgggtaHKgtHacHtSYacgtacacHatacKaaBaVaccaDtatcSaataaHaagagaat
+ScagactataaRttagcaaVcaHataKgDacatWccccaagcaBgagWatctaYttgaaa
+tctVNcYtttWagHcgcgcDcVaaatgttKcHtNtcaatagtgtNRaactttttcaatgg
+WgBcgDtgVgtttctacMtaaataaaRggaaacWaHttaRtNtgctaaRRtVBctYtVta
+tDcattDtgaccYatagatYRKatNYKttNgcctagtaWtgaactaMVaacctgaStttc
+tgaKVtaaVaRKDttVtVctaDNtataaaDtccccaagtWtcgatcactDgYaBcatcct
+MtVtacDaaBtYtMaKNatNtcaNacgDatYcatcgcaRatWBgaacWttKttagYtaat
+tcggttgSWttttDWctttacYtatatWtcatDtMgtBttgRtVDggttaacYtacgtac
+atgaattgaaWcttMStaDgtatattgaDtcRBcattSgaaVBRgagccaaKtttcDgcg
+aSMtatgWattaKttWtgDBMaggBBttBaatWttRtgcNtHcgttttHtKtcWtagHSt
+aacagttgatatBtaWSaWggtaataaMttaKacDaatactcBttcaatatHttcBaaSa
+aatYggtaRtatNtHcaatcaHtagVtgtattataNggaMtcttHtNagctaaaggtaga
+YctMattNaMVNtcKtactBKcaHHcBttaSagaKacataYgctaKaYgttYcgacWVtt
+WtSagcaacatcccHaccKtcttaacgaKttcacKtNtacHtatatRtaaatacactaBt
+ttgaHaRttggttWtatYagcatYDatcggagagcWBataagRtacctataRKgtBgatg
+aDatataSttagBaHtaatNtaDWcWtgtaattacagKttcNtMagtattaNgtctcgtc
+ctcttBaHaKcKccgtRcaaYagSattaagtKataDatatatagtcDtaacaWHcaKttD
+gaaRcgtgYttgtcatatNtatttttatggccHtgDtYHtWgttatYaacaattcaWtat
+NgctcaaaSttRgctaatcaaatNatcgtttaBtNNVtgttataagcaaagattBacgtD
+atttNatttaaaDcBgtaSKgacgtagataatttcHMVNttgttBtDtgtaWKaaRMcKM
+tHtaVtagataWctccNNaSWtVaHatctcMgggDgtNHtDaDttatatVWttgttattt
+aacctttcacaaggaSaDcggttttttatatVtctgVtaacaStDVaKactaMtttaSNa
+gtgaaattaNacttSKctattcctctaSagKcaVttaagNaVcttaVaaRNaHaaHttat
+gtHttgtgatMccaggtaDcgaccgtWgtWMtttaHcRtattgScctatttKtaaccaag
+tYagaHgtWcHaatgccKNRtttagtMYSgaDatctgtgaWDtccMNcgHgcaaacNDaa
+aRaStDWtcaaaaHKtaNBctagBtgtattaactaattttVctagaatggcWSatMaccc
+ttHttaSgSgtgMRcatRVKtatctgaaaccDNatYgaaVHNgatMgHRtacttaaaRta
+tStRtDtatDttYatattHggaBcttHgcgattgaKcKtttcRataMtcgaVttWacatN
+catacctRataDDatVaWNcggttgaHtgtMacVtttaBHtgagVttMaataattatgtt
+cttagtttgtgcDtSatttgBtcaacHattaaBagVWcgcaSYttMgcttacYKtVtatc
+aYaKctgBatgcgggcYcaaaaacgNtctagKBtattatctttKtaVttatagtaYtRag
+NtaYataaVtgaatatcHgcaaRataHtacacatgtaNtgtcgYatWMatttgaactacR
+ctaWtWtatacaatctBatatgYtaagtatgtgtatSttactVatcttYtaBcKgRaSgg
+RaaaaatgcagtaaaWgtaRgcgataatcBaataccgtatttttccatcNHtatWYgatH
+SaaaDHttgctgtccHtggggcctaataatttttctatattYWtcattBtgBRcVttaVM
+RSgctaatMagtYtttaaaaatBRtcBttcaaVtaacagctccSaaSttKNtHtKYcagc
+agaaaccccRtttttaaDcDtaStatccaagcgctHtatcttaDRYgatDHtWcaaaBcW
+gKWHttHataagHacgMNKttMKHccaYcatMVaacgttaKgYcaVaaBtacgcaacttt
+MctaaHaatgtBatgagaSatgtatgSRgHgWaVWgataaatatttccKagVgataattW
+aHNcYggaaatgctHtKtaDtctaaagtMaatVDVactWtSaaWaaMtaHtaSKtcBRaN
+cttStggtBttacNagcatagRgtKtgcgaacaacBcgKaatgataagatgaaaattgta
+ctgcgggtccHHWHaaNacaBttNKtKtcaaBatatgctaHNgtKcDWgtttatNgVDHg
+accaacWctKaaggHttgaRgYaatHcaBacaatgagcaaattactgtaVaaYaDtagat
+tgagNKggtggtgKtWKaatacagDRtatRaMRtgattDggtcaaYRtatttNtagaDtc
+acaaSDctDtataatcgtactaHttatacaatYaacaaHttHatHtgcgatRRttNgcat
+SVtacWWgaaggagtatVMaVaaattScDDKNcaYBYaDatHgtctatBagcaacaagaa
+tgagaaRcataaKNaRtBDatcaaacgcattttttaaBtcSgtacaRggatgtMNaattg
+gatatWtgagtattaaaVctgcaYMtatgatttttYgaHtgtcttaagWBttHttgtctt
+attDtcgtatWtataataSgctaHagcDVcNtaatcaagtaBDaWaDgtttagYctaNcc
+DtaKtaHcttaataacccaRKtacaVaatNgcWRaMgaattatgaBaaagattVYaHMDc
+aDHtcRcgYtcttaaaWaaaVKgatacRtttRRKYgaatacaWVacVcRtatMacaBtac
+tggMataaattttHggNagSctacHgtBagcgtcgtgattNtttgatSaaggMttctttc
+ttNtYNagBtaaacaaatttMgaccttacataattgYtcgacBtVMctgStgMDtagtaR
+ctHtatgttcatatVRNWataDKatWcgaaaaagttaaaagcacgHNacgtaatctttMR
+tgacttttDacctataaacgaaatatgattagaactccSYtaBctttaataacWgaaaYa
+tagatgWttcatKtNgatttttcaagHtaYgaaRaDaagtaggagcttatVtagtctttc
+attaaaatcgKtattaRttacagVaDatgcatVgattgggtctttHVtagKaaRBtaHta
+aggccccaaaaKatggtttaMWgtBtaaacttcactttKHtcgatctccctaYaBacMgt
+cttBaBaNgcgaaacaatctagtHccHtKttcRtRVttccVctttcatacYagMVtMcag
+aMaaacaataBctgYtaatRaaagattaaccatVRatHtaRagcgcaBcgDttStttttc
+VtttaDtKgcaaWaaaaatSccMcVatgtKgtaKgcgatatgtagtSaaaDttatacaaa
+catYaRRcVRHctKtcgacKttaaVctaDaatgttMggRcWaacttttHaDaKaDaBctg
+taggcgtttaHBccatccattcNHtDaYtaataMttacggctNVaacDattgatatttta
+cVttSaattacaaRtataNDgacVtgaacataVRttttaDtcaaacataYDBtttaatBa
+DtttYDaDaMccMttNBttatatgagaaMgaNtattHccNataattcaHagtgaaggDga
+tgtatatatgYatgaStcataaBStWacgtcccataRMaaDattggttaaattcMKtctM
+acaBSactcggaatDDgatDgcWctaacaccgggaVcacWKVacggtaNatatacctMta
+tgatagtgcaKagggVaDtgtaacttggagtcKatatcgMcttRaMagcattaBRaStct
+YSggaHYtacaactMBaagDcaBDRaaacMYacaHaattagcattaaaHgcgctaaggSc
+cKtgaaKtNaBtatDDcKBSaVtgatVYaagVtctSgMctacgttaacWaaattctSgtD
+actaaStaaattgcagBBRVctaatatacctNttMcRggctttMttagacRaHcaBaacV
+KgaataHttttMgYgattcYaNRgttMgcVaaacaVVcDHaatttgKtMYgtatBtVVct
+WgVtatHtacaaHttcacgatagcagtaaNattBatatatttcVgaDagcggttMaagtc
+ScHagaaatgcYNggcgtttttMtStggtRatctacttaaatVVtBacttHNttttaRca
+aatcacagHgagagtMgatcSWaNRacagDtatactaaDKaSRtgattctccatSaaRtt
+aaYctacacNtaRtaactggatgaccYtacactttaattaattgattYgttcagDtNKtt
+agDttaaaaaaaBtttaaNaYWKMBaaaacVcBMtatWtgBatatgaacVtattMtYatM
+NYDKNcKgDttDaVtaaaatgggatttctgtaaatWtctcWgtVVagtcgRgacttcccc
+taDcacagcRcagagtgtWSatgtacatgttaaSttgtaaHcgatgggMagtgaacttat
+RtttaVcaccaWaMgtactaatSSaHtcMgaaYtatcgaaggYgggcgtgaNDtgttMNg
+aNDMtaattcgVttttaacatgVatgtWVMatatcaKgaaattcaBcctccWcttgaaWH
+tWgHtcgNWgaRgctcBgSgaattgcaaHtgattgtgNagtDttHHgBttaaWcaaWagc
+aSaHHtaaaVctRaaMagtaDaatHtDMtcVaWMtagSagcttHSattaacaaagtRacM
+tRtctgttagcMtcaBatVKtKtKacgagaSNatSactgtatatcBctgagVtYactgta
+aattaaaggcYgDHgtaacatSRDatMMccHatKgttaacgactKtgKagtcttcaaHRV
+tccttKgtSataatttacaactggatDNgaacttcaRtVaagDcaWatcBctctHYatHa
+DaaatttagYatSatccaWtttagaaatVaacBatHcatcgtacaatatcgcNYRcaata
+YaRaYtgattVttgaatgaVaactcRcaNStgtgtattMtgaggtNttBaDRcgaaaagc
+tNgBcWaWgtSaDcVtgVaatMKBtttcgtttctaaHctaaagYactgMtatBDtcStga
+ccgtSDattYaataHctgggaYYttcggttaWaatctggtRagWMaDagtaacBccacta
+cgHWMKaatgatWatcctgHcaBaSctVtcMtgtDttacctaVgatYcWaDRaaaaRtag
+atcgaMagtggaRaWctctgMgcWttaagKBRtaaDaaWtctgtaagYMttactaHtaat
+cttcataacggcacBtSgcgttNHtgtHccatgttttaaagtatcgaKtMttVcataYBB
+aKtaMVaVgtattNDSataHcagtWMtaggtaSaaKgttgBtVtttgttatcatKcgHac
+acRtctHatNVagSBgatgHtgaRaSgttRcctaacaaattDNttgacctaaYtBgaaaa
+tagttattactcttttgatgtNNtVtgtatMgtcttRttcatttgatgacacttcHSaaa
+ccaWWDtWagtaRDDVNacVaRatgttBccttaatHtgtaaacStcVNtcacaSRttcYa
+gacagaMMttttgMcNttBcgWBtactgVtaRttctccaaYHBtaaagaBattaYacgat
+ttacatctgtaaMKaRYtttttactaaVatWgctBtttDVttctggcDaHaggDaagtcg
+aWcaagtagtWttHtgKtVataStccaMcWcaagataagatcactctHatgtcYgaKcat
+cagatactaagNSStHcctRRNtattgtccttagttagMVgtatagactaactctVcaat
+MctgtttgtgttgccttatWgtaBVtttctggMcaaKgDWtcgtaaYStgSactatttHg
+atctgKagtagBtVacRaagRtMctatgggcaaaKaaaatacttcHctaRtgtDcttDat
+taggaaatttcYHaRaaBttaatggcacKtgctHVcaDcaaaVDaaaVcgMttgtNagcg
+taDWgtcgttaatDgKgagcSatatcSHtagtagttggtgtHaWtaHKtatagctgtVga
+ttaBVaatgaataagtaatVatSttaHctttKtttgtagttaccttaatcgtagtcctgB
+cgactatttVcMacHaaaggaatgDatggKtaHtgStatattaaSagctWcctccRtata
+BaDYcgttgcNaagaggatRaaaYtaWgNtSMcaatttactaacatttaaWttHtatBat
+tgtcgacaatNgattgcNgtMaaaKaBDattHacttggtRtttaYaacgVactBtaBaKt
+gBttatgVttgtVttcaatcWcNctDBaaBgaDHacBttattNtgtDtatttVSaaacag
+gatgcRatSgtaSaNtgBatagttcHBgcBBaaattaHgtDattatDaKaatBaaYaaMa
+ataaataKtttYtagtBgMatNcatgtttgaNagtgttgtgKaNaSagtttgaSMaYBca
+aaacDStagttVacaaaaactaaWttBaagtctgtgcgtMgtaattctcctacctcaNtt
+taaccaaaaVtBcacataacaccccBcWMtatVtggaatgaWtcaaWaaaaaaaaWtDta
+atatRcctDWtcctaccMtVVatKttaWaaKaaatataaagScHBagaggBaSMtaWaVt
+atattactSaaaKNaactatNatccttgaYctattcaaaVgatttYHcRagattttaSat
+aggttattcVtaaagaKgtattattKtRttNcggcRgtgtgtWYtaacHgKatKgatYta
+cYagDtWcHBDctctgRaYKaYagcactKcacSaRtBttttBHKcMtNtcBatttatttt
+tgSatVgaaagaWtcDtagDatatgMacaacRgatatatgtttgtKtNRaatatNatgYc
+aHtgHataacKtgagtagtaacYttaNccaaatHcacaacaVDtagtaYtccagcattNt
+acKtBtactaaagaBatVtKaaHBctgStgtBgtatgaSNtgDataaccctgtagcaBgt
+gatcttaDataStgaMaccaSBBgWagtacKcgattgaDgNNaaaacacagtSatBacKD
+gcgtataBKcatacactaSaatYtYcDaactHttcatRtttaatcaattataRtttgtaa
+gMcgNttcatcBtYBagtNWNMtSHcattcRctttttRWgaKacKttgggagBcgttcgc
+MaWHtaatactgtctctatttataVgtttaBScttttaBMaNaatMacactYtBMggtHa
+cMagtaRtctgcatttaHtcaaaatttgagKtgNtactBacaHtcgtatttctMaSRagc
+agttaatgtNtaaattgagagWcKtaNttagVtacgatttgaatttcgRtgtWcVatcgt
+taaDVctgtttBWgaccagaaagtcSgtVtatagaBccttttcctaaattgHtatcggRa
+ttttcaaggcYSKaagWaWtRactaaaacccBatMtttBaatYtaagaactSttcgaaSc
+aatagtattgaccaagtgttttctaacatgtttNVaatcaaagagaaaNattaaRtttta
+VaaaccgcaggNMtatattVctcaagaggaacgBgtttaacaagttcKcYaatatactaa
+ccBaaaSggttcNtattctagttRtBacgScVctcaatttaatYtaaaaaaatgSaatga
+tagaMBRatgRcMcgttgaWHtcaVYgaatYtaatctttYttatRaWtctgBtDcgatNa
+tcKaBaDgatgtaNatWKctccgatattaacattNaaacDatgBgttctgtDtaaaMggt
+gaBaSHataacgccSctaBtttaRBtcNHcDatcDcctagagtcRtaBgWttDRVHagat
+tYatgtatcWtaHtttYcattWtaaagtctNgtStggRNcgcggagSSaaagaaaatYcH
+DtcgctttaatgYcKBVSgtattRaYBaDaaatBgtatgaHtaaRaRgcaSWNtagatHa
+acttNctBtcaccatctMcatattccaSatttgcgaDagDgtatYtaaaVDtaagtttWV
+aagtagYatRttaagDcNgacKBcScagHtattatcDaDactaaaaaYgHttBcgaDttg
+gataaaKSRcBMaBcgaBSttcWtgNBatRaccgattcatttataacggHVtaattcaca
+agagVttaaRaatVVRKcgWtVgacctgDgYaaHaWtctttcacMagggatVgactagMa
+aataKaaNWagKatagNaaWtaaaatttgaattttatttgctaaVgaHatBatcaaBWcB
+gttcMatcgBaaNgttcgSNaggSaRtttgHtRtattaNttcDcatSaVttttcgaaaaa
+ttgHatctaRaggSaNatMDaaatDcacgattttagaHgHaWtYgattaatHNSttatMS
+gggNtcKtYatRggtttgtMWVtttaYtagcagBagHaYagttatatggtBacYcattaR
+SataBatMtttaaatctHcaaaSaaaagttNSaaWcWRccRtKaagtBWtcaaattSttM
+tattggaaaccttaacgttBtWatttatatWcDaatagattcctScacctaagggRaaYt
+aNaatgVtBcttaaBaacaMVaaattatStYgRcctgtactatcMcVKatttcgSgatRH
+MaaaHtagtaaHtVgcaaataatatcgKKtgccaatBNgaaWcVttgagttaKatagttc
+aggKDatDtattgaKaVcaKtaataDataataHSaHcattagttaatRVYcNaHtaRcaa
+ggtNHcgtcaaccaBaaagYtHWaaaRcKgaYaaDttgcWYtataRgaatatgtYtgcKt
+aNttWacatYHctRaDtYtattcBttttatcSataYaYgttWaRagcacHMgtttHtYtt
+YaatcggtatStttcgtRSattaaDaKMaatatactaNBaWgctacacYtgaYVgtgHta
+aaRaaRgHtagtWattataaaSDaaWtgMattatcgaaaagtaYRSaWtSgNtBgagcRY
+aMDtactaacttaWgtatctagacaagNtattHggataatYttYatcataDcgHgttBtt
+ctttVttgccgaaWtaaaacgKgtatctaaaaaNtccDtaDatBMaMggaatNKtatBaa
+atVtccRaHtaSacataHattgtttKVYattcataVaattWtcgtgMttcttKtgtctaa
+cVtatctatatBRataactcgKatStatattcatHHRttKtccaacgtgggtgRgtgaMt
+attattggctatcgtgacMtRcBDtcttgtactaatRHttttaagatcgVMDStattatY
+BtttDttgtBtNttgRcMtYtgBacHaWaBaatDKctaagtgaaactaatgRaaKgatcc
+aagNaaaatattaggWNtaagtatacttttKcgtcggSYtcttgRctataYcttatataa
+agtatattaatttataVaacacaDHatctatttttKYVatHRactttaBHccaWagtact
+BtcacgaVgcgttRtttttttSVgtSagtBaaattctgaHgactcttgMcattttagVta
+agaattHctHtcaDaaNtaacRggWatagttcgtSttgaDatcNgNagctagDgatcNtt
+KgttgtaDtctttRaaYStRatDtgMggactSttaDtagSaVtBDttgtDgccatcacaM
+attaaaMtNacaVcgSWcVaaDatcaHaatgaattaMtatccVtctBtaattgtWattat
+BRcWcaatgNNtactWYtDaKttaaatcactcagtRaaRgatggtKgcgccaaHgaggat
+StattYcaNMtcaBttacttatgagDaNtaMgaaWtgtttcttctaHtMNgttatctaWW
+atMtBtaaatagDVatgtBYtatcggcttaagacMRtaHScgatatYgRDtcattatSDa
+HggaaataNgaWSRRaaaBaatagBattaDctttgHWNttacaataaaaaaatacggttt
+gHgVtaHtWMttNtBtctagtMcgKMgHgYtataHaNagWtcaacYattaataYRgtaWK
+gaBctataaccgatttaHaNBRaRaMtccggtNgacMtctcatttgcaattcWgMactta
+caaDaaNtactWatVtttagccttMaatcagVaagtctVaaDaBtattaattaYtNaYtg
+gattaKtaKctYaMtattYgatattataatKtVgDcttatatNBtcgttgtStttttMag
+aggttaHYSttcKgtcKtDNtataagttataagSgttatDtRttattgttttSNggRtca
+aKMNatgaatattgtBWtaMacctgggYgaSgaagYataagattacgagaatBtggtRcV
+HtgYggaDgaYaKagWagctatagacgaaHgtWaNgacttHRatVaWacKYtgRVNgVcS
+gRWctacatcKSactctgWYtBggtataagcttNRttVtgRcaWaaatDMatYattaact
+ttcgaagRatSctgccttgcRKaccHtttSNVagtagHagBagttagaccaRtataBcca
+taatSHatRtcHagacBWatagcaMtacaRtgtgaaBatctKRtScttccaNaatcNgta
+atatWtcaMgactctBtWtaaNactHaaaaRctcgcatggctMcaaNtcagaaaaacaca
+gtggggWttRttagtaagaVctVMtcgaatcttcMaaaHcaHBttcgattatgtcaDagc
+YRtBtYcgacMgtDcagcgaNgttaataatagcagKYYtcgtaBtYctMaRtaRtDagaa
+aacacatgYaBttgattattcgaaNttBctSataaMataWRgaHtttccgtDgaYtatgg
+tDgHKgMtatttVtMtVagttaRatMattRagataaccctKctMtSttgaHagtcStcta
+tttccSagatgttccacgaggYNttHRacgattcDatatDcataaaatBBttatcgaHtN
+HaaatatDNaggctgaNcaaggagttBttMgRagVatBcRtaWgatgBtSgaKtcgHttt
+gaatcaaDaHttcSBgHcagtVaaSttDcagccgttNBtgttHagYtattctttRWaaVt
+SttcatatKaaRaaaNacaVtVctMtSDtDtRHRcgtaatgctcttaaatSacacaatcg
+HattcaWcttaaaatHaaatcNctWttaNMcMtaKctVtcctaagYgatgatcYaaaRac
+tctaRDaYagtaacgtDgaggaaatctcaaacatcaScttcKttNtaccatNtaNataca
+tttHaaDHgcaDatMWaaBttcRggctMaagctVYcacgatcaDttatYtaatcKatWat
+caatVYtNagatttgattgaYttttYgacttVtcKaRagaaaHVgDtaMatKYagagttN
+atWttaccNtYtcDWgSatgaRgtMatgKtcgacaagWtacttaagtcgKtgatccttNc
+ttatagMatHVggtagcgHctatagccctYttggtaattKNaacgaaYatatVctaataM
+aaaYtgVtcKaYtaataacagaatHcacVagatYWHttagaaSMaatWtYtgtaaagNaa
+acaVgaWtcacNWgataNttcaSagctMDaRttgNactaccgataMaaatgtttattDtc
+aagacgctDHYYatggttcaagccNctccttcMctttagacBtaaWtaWVHggaaaaNat
+ttaDtDtgctaaHHtMtatNtMtagtcatttgcaaaRatacagRHtatDNtgtDgaatVg
+tVNtcaaatYBMaaaagcaKgtgatgatMgWWMaHttttMgMagatDtataaattaacca
+actMtacataaattgRataatacgBtKtaataattRgtatDagDtcRDacctatRcagag
+cSHatNtcaScNtttggacNtaaggaccgtgKNttgttNcttgaaRgYgRtNtcagttBc
+ttttcHtKtgcttYaaNgYagtaaatgaatggWaMattBHtatctatSgtcYtgcHtaat
+tHgaaMtHcagaaSatggtatgccaHBtYtcNattWtgtNgctttaggtttgtWatNtgH
+tgcDttactttttttgcNtactKtWRaVcttcatagtgSNKaNccgaataaBttataata
+YtSagctttaaatSttggctaaKSaatRccgWHgagDttaaatcatgagMtcgagtVtaD
+ggaBtatttgDacataaacgtagYRagBWtgDStKDgatgaagttcattatttaKWcata
+aatWRgatataRgttRacaaNKttNtKagaaYaStaactScattattaacgatttaaatg
+DtaattagatHgaYataaactatggggatVHtgccgtNgatNYcaStRtagaccacWcaM
+tatRagHgVactYtWHtcttcatgatWgagaKggagtatgaWtDtVtNaNtcgYYgtaaa
+ctttaDtBactagtaDctatagtaatatttatatataacgHaaaRagKattSagttYtSt
+atatatagtcttaaaaMtcatgttcaaDactgRttctaagagDtatttttagcgacttgt
+gRtgNctgSgRaaaaatgcaMtYtDcatcaaYKttHcatSWgaaaatDataggttatgBD
+MtgttataacaaYSgagttacgttatgtDStttaaatctcgWKtcSacgagagaSgttat
+BMDgtcggtgtgcgaNtaSHBatBtttVMgVcagaNatcaDDaKMtMYtatagaBccctc
+tDtgtatttatatKNtgggtatgtRaacttgaWaaYgcaHatccctggtttStatMtcgc
+MtaaaWKttMVtWctVtgttaKDWctgWaVttaDVatgKtagagtcatctaKWgtaaMtt
+SacBaMattaKaaHDataattgWtgttttgtcatBacacgtStacaaagtNctNtgtgat
+cHtWttcKaagagttttaaaaWacgRacatctNatVStgaatDHgttWcgtRKcatatat
+ctcaNttaaBDcctgaaaaaDtaYaHaKttNtaYVaVtttaDtctacttctWttaactaa
+ttttMagWcaatcccNKYtBaacatgttgaKgKcgcBHaatDMttatatcSWacatDatR
+cWaMtDgatBctHgScttaaaHtSgKtDtttattgtRStWgttccatatttcacWttcat
+attgtaHVgaBtacaMtgMaaagDaataactDatattagMaNBagcttcattcgtaaKtg
+tatttcacMtgBaVtaattStcttagtYgtgtcgccttKatgggtgaWaataggaatacM
+MagaSKRttBgatgacRtgMtagaSRataggtatcaccgaNaaaWSWacDgatacttgat
+tagcttgtgVMttatYctaRgHVcDtVRRtSaMtcaVtVtatcaYaHatattaaVaatct
+aBtgtacRatNtatttgaYatSaHctaNgNtYtYaYagattVgatcRtaacgYggtgtat
+KttaatMagatgRtatatgHaKccHaaaaYtgaacgaWaNgtYHgacagaYtctaVtacc
+cgatttttaaagcDttatNRgattKaaattttcatctaatgccgcaataataattgttat
+YtagtRNtaagttggtHaKttWMtDKgatSagBYcgRggtWaVaattHtatgtaaaMgSa
+aagataaKaaKgttDttttRaagaacaWRcaacDgtgttaatattaKtatcaWacacatt
+tVtctgatHRcagtttNcaaatcNctNttttataactWacBBttgBttaaaRaWtBKaaa
+cgtatcRcaMaatgYacaaaagtgBataStWYtggtatgacaKWtctSgcKHgtcNaMNc
+ataSatattgactacMcataattNVtDaRccaaatcagttttYttagYaacgtaatMtMV
+atNgKaaMaaBgattaKttatDaBcttKtccttttacDagaYtacHgttggacaaaVaat
+agtYatcataSgatcaaWVttcgaatgaccctccttNtaSBWaatttDttttcaatatYg
+gctatDcttatNctttagDcMttcaacWaaNattSYgctttcaHcRaattaataaaatcV
+ccRaattactctaMaVRattacagtgRcDtcgtgctcttNtWVtacagtHtatHaBDtcW
+ggtgctcaaRHtatgtDgacStgcaaaVKtagttataatactaatatgtagScaatRSac
+aattgtattgcagatHHtgBcaatKKtaaMMcaRcgactatKBaMaYatgKatttDaaNt
+RatattgtatWttagcaaaaacaWgcacaaHcataYtDaHgttataaSacgcagggggtY
+atgcKctaaaHgcVgctBDaVttccStagNgcSgtatgVYaMatcaWRBtVtgYttgtgR
+cYttcgctgaacNttgtgtctattWttttcctagMtagaWtaKgatStScatMaBtaSta
+SactattYNatctgtacRatYDaatgatgatatgaatYaaaaSHttaaYMaWtDcaNHaB
+caYtgVgcatVaacattMRatBtaatttaDacRtagtaaaNYVSMtcagaaDtttDHtRc
+YatacSNKaaMcHgatBaaVttactggBYgaYatttttgcDacHctWatcgtagagtact
+cattDggtcatKaSgctttatttagtDtRBacttaWYaaaattttgaccttaaWtaatgc
+RgccacttMtaggKtcBtgacgaHctttatcgtcStatMHDNagattatNagVaaaWcgg
+aaaYcaVactDYactaStattgBHtcYctgggtacatataaYcgaYagaggaggacaVat
+acHRtYtctgtaVgaYcNgaaaNatacVgcNgtaatttDcatttttcaacttSNcaaDat
+VYctSgcaccttagMgacgcttgaSttaaaatagttaggRHttaaacMatagcaWgMgag
+tcgctagtgtKgactaaHttattaWgcaaaaaaSatatgcgttaBNggttaYVatgaact
+ttttgccatataaataRatSaBctagttataBccgaaacaagatacttaattttgaHgHM
+gtaaKctttaYtaaRacBMtBaYgaBaaacaYtVtagcRgWatHaWagattWSacStMHa
+tttaDagacaatcgtgtKtttggaMtgtWtgtgcaaNaaaaWtKaaBcMWtcttctatga
+cVgagcgaggHaYYtttWgSaaYYaWtRYHHaMDtctttacaatggaaMctataagcttB
+cgHcNWaatttgtatatYtStatctagcactgtVttccagaaattaDtttaRtVataBtt
+WagcatDMVactYtgcatWtttgaaMggKaatgaaaaHtataDtgYcMggVaaatSMHtt
+tgVttaYaWaataRttgttaYttattttRtWtataaBgtDtttatatcVgaaBcaDtatg
+tcaDagaWtgaYtWctcVagctcagctatatagcRVtcaKtaataatHgNaccgaaaatV
+HBaatattcgttaVYttatttctBYaatKaagaccVStttcattgaMagSaaaaccccWK
+caaNtMYacctaDStagaaatttatcatVgtcaatacccKattgtaaagtggWgtatatV
+tagBcttDaBacaattWtDYKtatRKggStRtaaaWatBtaagtaattDaaaaBRacWta
+agtacaSttaaatccgctaaccKaattgVWttDattatttattKaMtcYtMRWagMtcgK
+gBagacgggVaaNaaatgctKcgtaataaKtaaagtccWcttHMatSYgataaatDttBa
+HccattgBttSgaaHYtaataaaMtgaagatgtttBgRcattaRaDHcttBgaMaWaaVM
+MattaatttgtgBRctattgKMagNcMtatttaaaWttgaaacatWgcScgYYDYgttYt
+VtattgcKcWtagcggtgBaSctaKatacaaVtcaRDccccgtgttBgKgggtHagcgaa
+ttaaagMMttScggtDttttaHcSaagaacactcacactBcVgaKNaDHacacttatSag
+aattSKHtcagtataaatKaaHtgaaRagaaVcBtaHtaaatcgatcWcaRtaaaattta
+WttaagtcaggRctgaWcttDttgactttaVSaaaatggtaWDaRMtBtaaaaaKatBga
+tMtctatatcaVaMgatttgNagtDRttDatcttttaMtYaaatcggagttctctaYatN
+tagaNcgMMactacHcaagtaaaatStaSaacaHcacSgggtNKatggaaagcggaaKgg
+gtaYtacSgccgBaggcRacgtVgDtggaMcYaaaMatggacgYStKKatgaBcaaRtSt
+ccSagcRccgccgcSDtgcggBDgaDtBtSSggacMttttaWcatcMatgtNMBWgataa
+tcaaVtgaataataaNatgcaaNttNctgacDMcaHccgatgKgWVttccaStggattct
+cDacttttttctttaaNcWaMWccWKWttgaaaMctDaaBactRtVattttBtcMaNttW
+cKacagttKSttaYaWSactHSaBtHgatgttacatgcatatMtttgtaacScWHBatHa
+ctggatatatctgagMgRSatctaaSttaVagcaRcttggaYaatKHtagBBactattcg
+taaagaagttgtVcgatgaVatHMtcaggtcgKSgWattgaaaVctccVgtDcaaatgaa
+HgMYactcaMatatatattNVttWtWaatttacRagKataaaNtttacaaWgMVactatt
+aSgaggVaaagVtaccDRHaaataRaHaRgcattMttcaatcaKaaataDcaDKtctcga
+ggBggacctDtttatHacWVaWgatDctaNaNcgKatcMtcMaatBtttggacgtgataa
+tagaaacRactcBtattttaKtgSaaggKtaggRaVtatagcccaNRttaccttSMaaga
+tcggDacNBatWcgaactacactaactNBtaStgVtNagcatctaVtaKatKgaBtcgtt
+tWaagWMgagRaNatHaaaaDtacagacaBagtgcaHaNatctcBccNttaagttDgaat
+aaNtcgctaacRBgtaatSttaatatgcataacccaSattKcccttDttggtcaatgggt
+tWaacgatacattBtgMaYgaRttatgatKaKgtattDtKWgataacgNBtaccgaKWat
+cttcttKtgtcttagcattcctWcaaHgagtatDMSgKtcagcttgVHaKcttDaataaa
+VaatttDgtgaaataaRgtcaVaatacttagtVatatgggcatgtDDtMtgtatBggatt
+HtgcVtgtgatcaaSattatKYVaacSNNttNWcgaHttKDaaMYHatcgttaattaStt
+gctWaacHtaKBtaaaaKHttcRWgaaWcRtBtttggBcDtgtacNttaagcKtaHgtag
+aaaaRttgaaacatagtWRaacYggtaaatcgctYaBtWDRtgttgSctaaKatNcattg
+tgtMttatccatatagctSacgccSNaaactacgNtgtgcttMatSKtcaaBaNaaacat
+aacagaaatagtagctcNcatcVgaagStaataVcDKKttcagDHDtattctaatgaggg
+RgBMctatacaagYactctMaaagtcgctttctcgtgaattatNcgatMtttaggcBaaa
+tctNtactaaRKtgKactattgtcatatgtacgagttMaaHSSgHgBatatcgcaSaata
+aaWgaagtatagaHgcttctttatgaccWaatttaRtaDaatttaatcgaaattgattMc
+atcaWaMtaWaKactttctBacactatNgtccttaWgtctgaccKatStaKtgagtacgg
+gcgcgtYNtatttagacctctKcatgatKWStcaataactaWgMSgHtgatctttttgtc
+gacgtSacttaYgcctWctcctctacaagVtttMaBactWVaccaYtgtSgcgttattcK
+tatStgaaKaccgNaataaHtatWtYtRacggcaDaScagcagHaYWRtRNcDtHtcVWt
+ggaataaaYttgVaNtgttagtYttgtagSaaatDgaggccDcgBRYStattatttaagg
+ccgHgggYRaaccMaagttatSttctttagcMtgcgMtgaSagaNaDagttSatgattWa
+tttagtDgcttgagtgMKaYWaYccagcaHatKctaKaDgctagacttattgattaaYtt
+atcttattattStaattWaRaYBWagYaatatgttRgScttgBagDaWgcgtgcVDaggc
+ttgtctaDRKacttgcaKBWRtaaVaSctKtacttMaaSVaWWcgSaNtttSWgtcggtc
+acttggVVtgagaataaataaDttgaaccaaaaMttaaaagaaaaaaaatcNBtatMgcc
+WagcaNgaVaNaaaaaaYaMgttaWtatHaagtNtacgacaBtMMattttWNaRtaaata
+gYaScKattacagctVKBtWNSKgYtYgtWatHaVatDaaatWgDatcctggSRagagta
+aaaMgatttRtaHacatggtaKagVcctgatgaMtaaYgatgtattattttHggBaccaD
+ctctggNNtYaatctVttgVtRtVcRacttNctttataggHSRtaRacaaattaacHaHg
+tgttgtttcBtBtatWtgtattttgcKagMcaaagaMtattagtStagcBacYaaHcagV
+gWtgtttcgtgDHaVtagDatcRaRtggtWtaactgcacgaggaaaRttSDaaVaSttaa
+aaacSMttactaNtcaacaattDtacttttYatVSacYtWtMttaattatcKtcttctat
+caKDtctStSaaacggtYccatgtgagagtWtagWKgcaBaaaaKttgNactaatcgagg
+cWtcDDaaaaaacactHattaattcactatYttaagacactaKaagRtRataaattttca
+tHggtaataaatgataHtggctaacBacDgtaatattRtYgtDNDBgKtcaggcHatttt
+gHNgWtaatttccgactactgacatVNttYYgactcgctctatttagaMcgggatHcgtt
+tatBaDSagBaaaagRttBggttaaBactVHgatgaatttattcaaaattgcacttcDga
+cttYcVttactVtttatBaKHagaWgtgaatggBtaaSggcagacNcttaDttVgMtWag
+attggVatttacHtctNcMatacttSatMagcttgtNcYaaScaYactcKctKtagScSt
+cagtttcatWaatggtgagaggHaggggcaacgcRKtaRcMaNtHaatRaRaaactVtBt
+gttaatRtWWcaaagKttccaaKaaatacgVttcacaaacgcggtgagaRaatggtgDMW
+atcWVScacaaaDaggaaHtgttSMaaaaaccYccDBtatYgtMagcSagaccaVcctcg
+gtVWaaagttatcNaagataataSaataaaKccgtaDtYttatYcttHttaagKcMctaa
+atggaatRgaaaVaaVtcKYaggatWcaBtDaggDatccttcYNtgcSMRgaRtNgaatc
+gttRttatDVMtagctttacatDVtatatatcagctaDagMtataccYgaggYaaatgDa
+aaatSgctctgatgtttVaaBcctgataKtagaaaccaKatatgttaDtgaDtatagata
+atacagtaDtatcNtgtDMtYcattRVtctataNtWttggNaSgtMgaaYctctDggHtg
+gHDccaccacKKaaacaaaatRatttccctttaagcRattMHctattHaRtataVattgg
+atcSttaaHaHgaaHNDtacattSaaggDatttcaaaYgctBcatattaaaKagtgccca
+tSctcgatRtaaaMtgWactttNMaWctYgRatDggaactcDcaattaKaactgagtatc
+tataagYaaaSRctggtacWtttccWtaYRtKHattatagWtKttaNgcDtatHacccat
+taatttataacgctMgaagtaacaacagMgtaYHYVtKMHtacMgKcaaatctgRYataN
+tcgttcaatacggWtMcaatYcBWaagYtVaDNagtatagDaaNtaaaYtttcYWttttS
+tgggataaMgatattagaaYtNctcttcBagactaYDcgtacHDWccKaHgttcttHgVg
+gVDttatcatKaMttttacWaaSattctatagaHaggKaDagBtaaagtcYccattgtYc
+atctaNgRgVtgaagtDKttatBKcggDtattRYgHccgtgcgBNMtttVRgacaYctSc
+taRacgtagagccgtacRaagtaHKagStSttttgYSatattaaaWHaaWagttDKaaNa
+NHaaHttaYcttMtcaaatgKttBtSgtccaaVaattSaacgttgNattgatatNctaWt
+VcagtactKcWacgVagggHaaRgaDaatcMttattaataacaBMaaVtgYtKgRgHact
+gtactatcBaMtVggtagKcYtHtBSaattagtaatgMcaVVagYYgWtactttccaaSt
+tDgaaMaMttcacttYtRgacttcagcttWtttagtgataMaattaagVtagaatatKat
+aagtagttaagHMRaDattaHaaVcctDtagtcVYcaataaYcNttNaaaHctcaRaatt
+tcaNRgatSHgVatagctRtcatgaBttMaaagRtcgHVtgRgStgatttgtagaKagaR
+WRctgNaHYgaaatBctgtttRttNWagaccgagKgtgcggHKVttaatattaatataat
+aDtaNcctacaaRgcaNMctctgaaSHWWHcttagtNagtWgWaaKtYaNgcBattatcc
+aaaSctRRHKaNtKcBgtgagaDRWBttactaaattSMctatatagaaYacDgatttccV
+taagRtgRataatatagtctttttatgtMgtcaacaaNtaaaaactctWtagaVaaaDta
+attatagtBStcgaatDtgattVaatMtcaDattVKWaagatagggttgtMRSgtcYgWM
+aatgNtagtcBttagtttctctWaaMtVgctWgSgtHagaSagactagKtagWggcattt
+HgttgacaaactcggggHggcWBgVgtatgggagVgagtcVcBtDctttagtctaagVWt
+HtgtttaScatacMBtKgattatRtgtttgtctttDggcHaBtRtgtaataNataattta
+taWctgaYWataStcHaatcRtaaVagDWaSatagtaccNDgaagtatacgttttacgac
+gKRtattgDctatRRattVtStaaactagatgVatttagaMaSaaaattVtatYtgttgt
+RMagtHaatttSttaaYNaggWagtgcacgaMcactgHgtgtgggHMgtKacttaaYgtc
+gcatcSatattgBaagtttacMtYagSatttatttaVtaaDtaWaHcgNatactgactHt
+ggWtataDcDScatactcStcDtgtcgtgtatgaggtHaaNKgDattgcBccaagKgtat
+gacKSMtttttgttcaaatcaaYtagtaSatgDaaaMccKNaMaatagaataagcaatta
+ttataaMgagtgaSgtctNYttattHaNaYYtcDDtaatNRgtatttaaYtaaatcactH
+VaHcStccttcccaaVatcVggatKtatgRaaDBgaYtttacttYggactSDtaBcaaNg
+gggtattatattBDcttagagYNMatBgttYaagactMatgttRgatacccgtaacacBH
+tatKacWgatRcHttaattYtKtStccaaatVDcaNKHHaaataatagtagtatcttgct
+NDggVaVVtaVaRaaagSaccgttctcMtVtgNBgtDtttctYgttactBctcRtStWtW
+DScMtcWSaRatgaataRHctaNtcStctYtWacagatgtatYBtHaHWBtacggtDcaa
+BtatcaggtcaVattaNctactgaaaatWaDgactNWtMtggagaattBaataYcMWYcg
+atMYatWtgattSatgaRtDaRgccagtSttatatRaBtattRcWtagtVgaagttMcta
+ttatatDttaggtctKtgtgtBagacgttatRKtgatctatttBtataactgataacKcg
+gagtgHgtVttcttgtKDgcDtaYatBDatcaatattgttNtaBacatcgcNcaKcaWcR
+ataWcVgtacgScaWgttcggHcMttcRccatgaRStYgNacagatacYacWWtggNaDc
+WagttHatMaNaatNtcDMDcMaKgHNatScVgatKWatatgNRgtccgYgaagattDHg
+tMtcHaSNaaattBatRagtaaatttacaagHWtKatcaagtccHtYcctgttKDMSgta
+ctactVctgacaaaaHgatatacataatKtStHgctScSatNatacaYttaaWHtctgaa
+tYtagtHtKaggccWBaStaDctaagagNtaatcaatcgttNgaYDaagtaaaaHataga
+atcgcgBaYaBgaacSaaWaaaaactccgcMttHttYgtaagaMctKBtacSagattcBa
+aWtaattttacRttatcgaRtacaRHgtgRagaaBcttaVgacVDgggaatVatagaact
+RRtacgYttNattVHgaHttacaaaaaaaYtcRWtgtgattatgccaSDtttatKWgaat
+atSNDgattttaacgtcSRtatggttcttcBtWtttMtBtMScttaHatBattHacYtaY
+acattcgttKgtcStSctcKtatatttcaKSgagcttccaacaccRDtttDaccattata
+tSgtcWtVaaagttgtagccattDtYaatattDaccatcVDaaRccagttttgtcHacMa
+ttcHgaNcatgttKcVttcctgtgcSataaatattgaKtctaWctMRaKggtaYcaagtt
+DttcgttacRtatgatggHNaWMtKttcatattaaDaSaBaaaMtMatBgKtttgHtHac
+taatcatcgtWaatKaaWcaWtcctVttaaNaggaaaagtaaagaDctNttaDBaBgata
+gMgaataacRcYggatcRaaaHaagatRDtVRactaYagttcaccaaWtctcSSaaatcS
+KattctggDgaacagDtaDagacagtgtaattcaStYttNaStgtaHgccttaScatMRc
+accWtcatttatRtaagatWtNataaWtMNtDVgWttgcWgtgaRttttRgWcttMtcta
+HacaaYtKctgaBagtRagacttDatNttaaaDgRtatNcHatcSDgtBatcttacVcYa
+cNgaattaacgagttgYgacttDattatacBattMgctagcctagatVcaactNttccta
+atgtDaacgYaNatagMatSWtYBaaaRtgMtatSRgaataYaScaVgtaScMagatNNt
+ttacaaHBaWtNtRtctaaacDaaaaWMcaNtcVaDNcagaDtgcWKYgagttaHtgcDY
+ataaacataBaWWtcggtatgtgaaScaacctttRNatcgttaaagcaDctaatgcBatt
+tacaattVaMgSMMtccYaaaBYtggattttcataWttgBtatDtBgactaatgtccWaa
+HataaScHttWttDtcgtcaagMctMDtaaaatRtBaaaacaatgtcagcatBgNNBVtt
+ttttcBacWtttWtSWWtgaaaaSacgBtaaataaagtcDStaagaactgttaatYatgD
+ctattactgaHtaaatStHaagacaKtagDtaaHaDgttccaaDtaaggacactctDggc
+gtDagtcWaHgRcHgDgaSctttattgtcttttccttRYaDgNactaaatcaWggcNSBa
+gttttatatStKgtcRtgattaaggtcaSBttaacaaKatgggatcaaattgRgcBagtN
+tcgDcatttWcctttgtNagDgctgcatttactttgtgtcaBgSatttNHaMcggcagSc
+tcKDtWBaagSagWatggYtVatSRgKagattgaVatKttcgatYatKYSgDaacNtcVg
+tttaWataWtgVctgcgSggMgatccatgagttgtWcatYWWcctVcNHagtNtgtKttt
+gatcaacttaSttattgatNcatWaVgNHcagStVHcggHacaaDttgDttWcaaRaKga
+aatKaattagtaWacattgaaatgtgaatgacagtgaRVtaaYagYtcggcatMttgaag
+gDgagDRcaKgHtacacaaaMcaBtagHactgKaatRtNttcttcatcatNgYgStggac
+tatgSMttgKtDaDgacRRgtWaVattgatttaagYctatatagactaagaggtatWtat
+aaactaYaHRctStgKWcgtRtKtYtYtagacgattRaaYBtaStcttaWataatcHtta
+taRcactgagtgggagccaattctcDtgDaggHcDRVaVVggaaBtRttaataaRRttgt
+aagKNcaVWWgtatacctgatcttBtcttRgaWcaVRKcagttSacttagcgtKtgtYWa
+tatcgNttcKaccacacVKctgattBtggacgtctgacaDtWKttattttgMBgKaacaD
+ataattWtBtBRtVtacataaatatttgtWtttatagtDtgcctagctHYaatgcaNaaR
+caatVtacctgggggKtagBgagaBgRaaNttttMtMagMtgtgattNctcNaKggWtMa
+tcttagWgtaatatatNctaYBggKaataBattYtaattataVtggNtcgtgtctaatta
+aacctHtacaaactDctDtctgatatgMtgataacWctgtgYSaaNScgDYaWtatDatM
+KgcaatttctgNcgtHtaWtagatatcYBttaattactcaaaVattYRWtatttDtaNMY
+MttgattataatgcgNggWaatYagttgBagNcaagaaaDtRgtaaaagctgcatctagc
+ttaVgtBttatagcKMSaattYtHcMaBttcagtcttgKatgVSVttKgttttttagtgt
+DHgNggtcaVtatttaacNtgaatatgctatMcatgaaaBtgBSaWctaataaattatYt
+tagtaDtaccggaatgagtaattggatttaacBtctSMgWYtgKgattacgRctctccaa
+tgtaggcctgaNaatScgYataaBBacaKtHtttcatgaaHtgBtagaKHVtacctVtca
+accaDaaWNHNaatgataattgatgWcagggtcMBtgSgRataHctMctgMHHtKaBtaa
+MtMgataaRWtagYtgaaMaSgctYtgcgaaHatDtatgtcWRatKatatYDcBgNtRaR
+acattMcagaHgaaagRccgcgWttggSatBagagcHgYtatctVtcatYaaVRtcaSac
+aMYDcgRtcaaWgaRgataMtaaaacaggtgtaaYcattgWgDHcWgttaVatttgcatc
+taatccacaaagaagSatgcgtagRgagtHDgaVcgtgcttatggMttttcatKSctNac
+HcctMaKRatttgatctaaatgHaaScataataatgtttgtgtHaVcaaaaNHaaaatcg
+ctgSVtattVttagaaNWcacagtgKtatgattHcYcttgDaWVataBatBttttWtaac
+tNaattttctttaaYHaMtttaaaccgStcHaVBaatcRacaaWactgtagVKtNRtcct
+agcWaatNgctKccttctcDaBDcatYHatatgcaataaBaagaatgDMttaHcaaYYtc
+actgttRtgacRaacctaWtBtBMagBctaaBaWtgatgVtttattataggttaattgta
+atYcaRtVctcttgcacSaaMaatactRSgcataKcagcaVNKttcgSatcaaactaatt
+DtaHtNaVtgttttttaWVtatNccagWttcgtatBcgttVctcBttaaaaMSaDattKR
+cctttcataHaattaatWaaataKcaHVaggaatataBYKHVtgVcVgtcHcttccgcct
+attDtMMgWaacttgWttYtttcMcgtcctaaVHtgWtggtgacKtcaWaYMttacttag
+VWtacgSatatcgWcKaaatHKaaaYttgtagtcaacWtttggtcaagttgaaBBaSHac
+VcgYgttWBSRWggtattttaYDtHatattcgatNttacaaaaVacaMccaaYStaataR
+ttVtcttagaVKaacaWcgccgtRatcatctaaatccMcctttaMggccHgYcDgaKcta
+tgMRYBagcaNDtgMtcRttgtgHaRttacatgaWcDtgctgtataggNggtgaatagBg
+agYNtatcagKtHcatBatgVKgaHWagattRDatatcgYcHagRtaatgWtcStagcVa
+tNaaaaKttgRaRBYNgtaaDtStaVRgcMccatMWaaattBDatttaatttataaHtag
+tVVaDRMKBtaacaatttttttDaRSgaaKDtVaBatcagtaaMttaagcctRgaNVggg
+ttcataatagNatcctacactacgcatgtcggaYgtaKcatggattgactttHtaattWN
+RaaWYggttcaaaggaaNtaatgcHcaaaattBtagcttattcaagVtatttWgcctaKt
+atBttDYcattagDacKVaYNccgYaYRaaMaattRaagaHtatgcttgcRagcgctSaa
+tagaaRacaRacSccagcacVMataatHgRtagcgaKgYRaDcVWSDVgRaMgcDgtaat
+tttaYttggtaaWcttKDaaYtatMRcgKccYcagtYcBgRccattcaKtgaSSRtactg
+acgHtgtaaaaBatWgcaMcBcYcgccagactcttcSatYattgatgaNccaaaaWaKat
+VgcaggtWtBcgttaRMagcaaagtgttcacatataaagaHWtKatctacttatatcacY
+RaaVagataagtaattttgatgtBctaataggtaRtaaHaattgtaRcStYSYaWRgMta
+caHcNSttVNScattNKaaKgBtagtgatYcaaaStactggttggggaBggtNtgtcaaW
+BaYVSNgtaataBNtagtatatcacMcScccVcgtVRRtttNcKaSRNaNtHRttattta
+ttgacaatggSaBagataaccgttcctaDNaattgctVtatNtHtatagSccaagctKtt
+aaacaaattattgtSHgMWgStttNaccattBMYatRtccStNgttgaaBcctVagcaaa
+atgatattcRaBccMWaagKtttttcMtgaRYNaataDttgttWRttattggHtNtataa
+tggttgtStYgaMcYVtcattaggtaatVcaNggaRtNataMWcctcYgcgagagRgcHM
+gcWtgaYtVSttgDaacgaaaatMttYWtWttcctgaKNttatttattRaattaagaccM
+KtttcWgtcaBagKSaWaaacaNtaYaDtBNaaagWtHgacaaagtgVtcatKcgcaatV
+aactatgcgaaactccNctatatMgactatttatSaaVttNttRttagHtccKtHtaaaN
+atttYVctaatttaaaatHWaNtSacgaaaHggaaatcacagVYcctaattcMNtgtYtg
+agttatttaBtcRgBHNacBtactctagaacgcKaaDWYYgcattactVagaYtgaVVcg
+caNctttBagKRcSgaaatttgtatccattgtggHcaatRtaVtaSaBtcYYcatcgtgt
+cHaVttaHattctgtcaBSNYaKBBattaatggctgtHatattgtBacDcBgatttaaaN
+tggaaaaYtNcaKagRRtRgttRtMtWgggatcNtacacctgtWKagatataaYVMtaaD
+taaacctctgtgtgccttScacWaggaYacttttKacgtttgtgataKYagaYaVatcWc
+SattaMcatBYttYaaatgStKagWattKtttaWgtagaaSgtRattcSaDagVaMatta
+ttYaagccSgcNaaDgaaSaggtaNgtWactaWcgHctgaNatttttcaatgtaMHSWaR
+tggtaNtaHBtttWWaaatattcVtBtctStWtaWMaBcatttcDagttDtttatatgtt
+WBtNaYatcccSgtgagcgaRYtBtagaDacBtaagaataWactaaaagKtaKaWaataa
+cKcccgDtagccaaagcggaatcgctSRtacKgcactacccHaactMgtgccaBaRaaaB
+VtcgSacRKtttStgatcaaHgKtaaKaccHaccacccKttgagcttcSttttKKcgacB
+gggtYMaatcBStcgDBtMcataWtaWaMtgaataagaaDatccSYDtgBatgactBaVt
+aagatctcNMgtcaWKtgcWggcgatacgtgtttatttWaDaNWBNaaNtNttcaaatag
+taatScgHtMWttgttgaBaDtgNatSaagtttHttaNaNKaattKatttgatcgtVcat
+gaatatBtttctaacKaNttVttSagccatRtatatcactcHHatctWSKttaMacaaDa
+ttccaRaYttttagttaatattcctYaacVactgctMcgagcaMYtttgaagctagtKgN
+WttgaaaMatcaMcttcSVatcaatgtNactaaBagatagagtDMgtNtNWatttSaHac
+tagaaaDggtaaaaNctMaatagtaHgacgMaaacMtacatHtaSagaHatYDccagtBt
+gaWatcYtVaagataattgatcgacctgcaacgttttattacNMWNcattataDVDacta
+tattatYattttgcgaagtgagYVtagYaWaHaatctgWttttatgcHaacgttaccDaK
+tatagaccaDDttaacgtHBaacatccgtYaBtVtNccaaataaaatVactDttSKtcMt
+DSgaagctaMtatattgattactgtNaagNBcagHaDattaaaWttacacaaatactcaa
+tSDatagctcaDttWactttgaStaaDtagatSaaDtgtaatKtgVataggaagWSaaaa
+KatttaaagtttgcgtaaagcccggNWaacatacatgttctaRcaHttVtcattatctag
+ttttNcataaacDttWaagVtNYtaggctttggtatgagaWgtactNaVatcactVttBK
+cttaaccttcMtatcggtaataYaMaYggttgtcaaagSWHctaRMSatVcggactMata
+tccgaatcttttttcgagtccagtttgaMtcgcatcaaKagtattRMaaaKDBttDNcca
+tttttaaBNtVtccgtaatgaKgtcagMVSattatttaWaattttaHNcaaMaHttgtgg
+ctattctacDtgaagattatcgacaaVRHttcSaSaatactNHWaaNcgtWaWgaccgRS
+ttNtHtcttcKatYatatBaagtcgctBtgagccatatScctKaagaaKDaWactWagBg
+ctgattBagKtgaaataBaaaaagSacScaaagagtagcgaDaYtaMcaYcKtaataMat
+ttttaactttgYgtcgaaggacgcHctBcgYgaaVacRYagagBaaYgtagattgcgagt
+caagtStDagatBgtgaccctaSWtctDgactaSHttctWatWttctaWtatctYacact
+gBWatKKctgtatYgacaaHSatYSaNgSagtatagatgagtatttatgaccMaatgtaH
+tStaWttgYagccaWattcagtBaYtaaNaBtaNatactggcttWcaagatDctacggaN
+ctatcacatSgKgattgacgacccccgagtNDtattgagaaatattaatcVttNKtaaWt
+YacgSNcBHgttgWtatgtttcgccaactKaattaRgacgNataatctacaacKgttBat
+YatNMSaaaNtctKgacttatgcttatKtcaVtVcagDaataattYgNtRtHaagcaata
+HcacaVgtaNNHtHDatgttaMNtggWagSVaRttcMVDtcttWgtRttctacKaaVttc
+VcgcatcctHRKtattSgttSacgaagtcccRDVaacBWagtgYtKtgattgSgaBtgcc
+BtcaKacaDatacttHatcattNatttacgtcagtgaggcBtaRNaRcaSgcatattatS
+tatgctYcacgtattcattaaRtgStcttWgtattKtSYttNaHaRtNYcRaYtVtggtD
+cKcttctactaMcacggcMtacgcttctatatHtaatggcattMDtaaMaKattgaagtB
+aaKMVMNacKaDtttKNcgagctaaagtccMMtgagaagVaataatggcaWaaaaVaBgt
+aSaVgaaaSaaaataDttVtBccaNagcSBgaMaDaVaVYYRVBgttYMtagtaactDta
+agWaattBtattttMDYHtSaStScRaKatattacacctMttgNBKtcRtRggNagtYMa
+ttaaatMctYgaatgcKHagSggaaaaBcaggtHtatWcatcgtStagMcctcatgatta
+WRcStcgWtgRgttttcctaacatcgctcgDDtRaatatMgtcMtHtMaDYatgDattta
+tagctKDtYHaaaaattaSatatctggtctttattttatMtgtYttgtcatactcaaVcY
+BgatgSctKtYcctWaRaataWcMgNgcgggagtcttRMgactataHaHtgctNtVaatc
+aaccacgSRaDtgKtaaMSKgtaaaaWaKtttVagSDtaaaaaatgttYattttNagMHa
+aRtNgBttWattatatgcttatatcatttatKtKaaaagctRaaatcgcYgacgNtacNt
+ccVtSaaatttcDVctaatacWgcaMtcttSaaWaaaWagtagtaattaactagRttaVc
+SaaatataacHgHatWaattggaagtgcgSSgaaVtgYgSttccatWVataatcgaatat
+gHtRcgtBttcttaaggatatgttgtBcNtaatgtcacVatactgaaatMBttRRcRatc
+catagagggacatcgccWttagttgWttatKagtaaaagHtttccttSatVatKtgagca
+atttattaaYVattcaaattctgSattRaMtgaatMgttattattacaNcggVagcctta
+aKgccYcaaDattWtggMcttMacWttccMVgtgaattctDaBYgacttKYtBacatgct
+DcRaaKaaRaatatctttagKcKtaactttaatNaaggctgScacctYgcgcaaaccaHt
+tVHcBaDgtaatHaHVaaatMgttggtSatHtNNaaVagtgtacaataaagacgKttcaa
+aWVacagctcacWHaatcctgtBNWtaNMKcVcVSWtSgcaattctgKtVVaaacaRaat
+tgatRcgBacaKacVccVMactagcgMNaaactgataDaSgagaatVHaatVSVtccgga
+tgRgtagRatttgtaactaBataVaggcaagHgaaSMSaKgctRagcStNcatttVgcta
+tacttcNDtcaKBDcaHtDcaatagttHttattMBgagctgtaaagtMgatStStcagat
+atYcBtataacRcaggRaaaggtaWSatKgatatgagcgtgMYatcagcatVttSgaaaa
+aatatatgttYttcattatacataatVcacgattataDggttBtRaagtHMtatagaDgN
+ttggDaKctBcaaRcgattcgtgccttacaaaWattYWVcaaWagDattgaaagggaaga
+HattBtatVggtaHtWtaMagtccagaKttSatatcaStDtgWaagtKWaggtatttaWa
+aRcattaatStgaaVtacggaacatKctacatHtaaaBtcNWatttBBaNatRcDattcg
+aactataaattataactcagtSgatataagRaYaKHctggtaaNtttaaNgaRHtttatt
+atacNttttaDccttYgtaaacaggaagtgataaacatBgaSgtaaaaaaVcBgtWNtRM
+ttBttaaBgtaaaatatcHNStaBtaggtaVatYaccNtBaWagRctNSacRtMatDact
+StVctaaDtaYSRgttaRNttttKggccagaaBcatagtYcaYNtDatcgtatVcaatWR
+taggaattMcatRtgggatgtcMggMtttataagtaBgtggacNaaKYtgctWgagYtWc
+ctWtVcttaaactaRacatggtRcatctSDcHcMgcaactttttagttaccttattHRgt
+acggcactDBggtMHcVaaRatKctSHacctacaccactaaHaacgSttagKtKttttgN
+HVgagtaYaMtVYNVcggttaSBaBtaatttSRcgtBgaWaatctttttKggacaWKaat
+tKSaccttgDRgtcatatDatVMtMaVcgaattaNaagMWccctaaHgataatatgtatt
+WataaaatBaaMtgRttcHctaagctaagatatattMcggactaRttttKaSttactWYt
+gBcaMMacRRgNtactttaaaSKtttcaYBaBttaVagtRtHcWaggaVccttNgtgagt
+catataWttYScMtWgVRgattWtaSggacggWWctBHatattataaKaagttactaMRa
+aataSRaDttDaaatataVHaatggaaBDgWgHtcKStVcatHtaatcatggBWaagHta
+gtMtgHcHtcatggggWcatacaHNHagcDatRcaaattcgcttgDggDNVcaacgSgtg
+gcaccttMttaatattVYtVgaagRttaBcagVaYaHcaRDBagatgaVHtNMtcttact
+DaggMgMaattRWDcctVtgagaaaaSKatHHttVDgtctgtcacatHNttgaatSaagt
+KBatatagacaaRVctcWtgtacKtaacHtgHataSgVtactaggtttatggBgtcaaaY
+aDgaaaaaatcgMtagaKaYatgaattatYcttKtacaatttgWttMaatBgaatSttMt
+NaVgVtScgcttctBHKgtaRcNBaatcDtacgattgacgtgctatNaaBtMgagNgKct
+tWcWKacactYgttVgNcgaattttcttgaaaaactacccctcgcNtgMctatcccacMc
+actcMatttatttagtagaacMNtttcttgYKaWtaaBtttcWttagHtgtttctcttgt
+ggctatgDgctaatWDataatttagaNcgcRRNataKtctaataHgaaMYctNaKWtact
+aacDtgaVcgagaactggtaccaactHgaggctagagHHagtMgKtaaactacaggMatg
+tYgSBaKaaaattMgatRtggggtHBVgttaattgKttaaRDacgMactcaaacStaaag
+ctctgtgccttcgtSagtSaRctacaataKatattctaVgtgtaattRacKagttattga
+MtaatgaNatacDataaggactttccNtStatatKaagaataKtatggtcctctatgagg
+ttaaDtgtattgataaaactggatcactKBtttggcgtcaaagaaaNtagtWKatctaaW
+BactDaBaYtacaWtaSgcaattattWgaaBgactgaKctatBRgtagttaBaRRgattt
+aagBHctStgtVYRtaaataaagtMWtcHgcattcacaaMWtcMccWttgVgcHaWttca
+NtgtVaggNgcVatKttataaWDcccctatgatVttttattacagRBBWttcttRaWgaa
+tBVgcgtHgWgaccagtYacaattgSttaaMcVtDatttaVttRgttKtcaYWatKtaaD
+tttWaYtaatYctSctatagtcctBtccMaMMtaMYHaSSgKaaacttctcBtMtgDtgt
+ttttagRcgtacttataHgKtNtMtKcBtaNKaHStgSagYHtataDtcKtagRtNWaac
+VgctVtRtttStNtgaaccttaVatgagaaggtcaKSttaDataagcYaSatNStcaatD
+NgttcgacaatttaSgaRaBNNacattRatNtgSttHVtgWHgtSHccaactKttYtatH
+YttVtgHcNgactMcaacttBatatgSgattttacgtatttgtggtScaacggYtHtgca
+tctatttttWtaSatcagaYatcgcagtgtgtMgtattctttcattaRatttStcaatat
+gcttDtStaaagaccDcVtaWNcHYtWMaMcgaacKcaNcttacctaBtgcDacatcaHK
+tRcDaaacataaRacNNtccDataNactttatBSDYatDtctBtaBatctDatKaMcatt
+MatatcDHctaagRgYVcatgttcgtgataHDYaagttSgHYctaaatgtaaaactNgta
+gaaactaattRaatcttttBKcgaatSctMaggVaVaaatgagataaataSgttKgtcat
+KaKatDYtaaaRttYaMtgctcSatRtagttttagcaaNtaKgatcgWYcacDgaatcaa
+tactgBgaNtaactaaWatatacaatacactaNatcaVaKaaMaaaaaatcaccBtgttg
+NctaacaBattttaaKWcaggataWMtaattgtaaHtgVtcgaHtScaHtctcHacVata
+gtaMcaaKtcccSagMYtWcaaatHHtaagRttDagtMtcYtttaaWWaaaVaRtcHNtc
+tcSttagcacaKttgtagtNgWYtatKDtcatttgaacctcKHtatccttattcttNggt
+BgtgtKaggWtYgtStgtVaRtaRaaagtagtgtcgcKtKagatgagYtttaatKcScct
+gaaaaaRaaHtttttaaaVgtatagKctaNtKaSVgttcgagacattttRSatagttSac
+ataMtaYHccacttttctatactagtatgaBaagctttaMtgaatgtcaKYtaaatatgg
+attataNcgBHatcctaRaaactgttgacttYaHtStcatcctDaMBttgtaWgagtaat
+WKataaaBgBattcttttctttaatWStaatacgNaagtWaMaaNgactMtgaaDaggaa
+aSctaSSgatatDttattatcatagBcaataVcHcRgcStaHaaatWagatHttMHacta
+RacttaYaaaaNtataHKVaataKtatgatcgtcVaaWgttYtVcaaYggctRWttaaKt
+RttDaKtgtatcaattWKaatBHaaaaNgaatggStHgVVgatMgBYtaRNgBDttMcNt
+ggaNgtcaHtgttDcNaggBtatYtacVaNttctcWtactHYcSctgtYtDtgWaatcHg
+atDatatcHtcttatattaaKaRYaDgaatgSYcgactgcRgaagttagtStYatYtttc
+cgacactacagKcaaagDttaatVatcttaaacRaDatRcBatKNtNtaaaHtcBgatKH
+cWStSRaKaSMgtaKaBacWgDDttgYaaYttaNtDgHtatSaSataaaaMBaaDtaMat
+DaagWtggaMtRcacttatggctNataaaaatatWNMtacctatgtcaYKaRacagttHD
+agccgtaaYcaatataatcatagggaaSatgMYBcKBBtaaRVRatRtccVtgtgaagVN
+ttcttagtgtcWataVggtaaNaatVgVaKctttNgtttagtaaagBatBtgaYSagHtt
+SYaacaStcgcagaSttcDBtKtttggtctacNttgNgKNNtcaaaaKWactgaaYgaYa
+ctatHtaWcaactgttSatNVtgtctSttYctgattVaatKgtaYcaaattSgttaStat
+ggtccaatgSWccaaactattgccgttacgcNatcHctctcaKatgtagtctattttaag
+gHRatcDaagSaVgaVNccaBKtacgtttStagKgtctaHtcattaYcctaVKtttaYaa
+atYtccgataaaVttcDgatWcgBtcctaatttNaattgctDYgtgatcaatttaagggc
+tctcatcKattgBtaBagcaYcKctctttNtaacHacNStggRtMatHHgtacatgcaMa
+gtgtccatRWttRKctaaaDtcMctttaNVgaNtcMatcacHcctgWtaaStcacgtctN
+aagRNNaagMaDtactDgctttttcatcYacttaKttatgcStDaStNaMgDtaacKtMt
+acctaaWattggtttNaaVHatgaaattaattacgVNaaWtggaWatctgVatcacYctc
+VHMtVaNacNtcccaWtttgcaacctcWctHaatcttWcaaaYaBaattSctYatctaag
+DgBttagtaSgaWtBcRcKtccYatatcKBgtctttatgaaHDcgNaMatggatgtWagR
+ctStagagaagaacagctWtNtataaaataRatHatKgctNactHgttRgRgVcRacatg
+HYaNttaHtattaNStaagatgtagaHcVctcYgggccYcaaaatgatcttctagctctH
+MaMMgcaVtgHgtaagaWHHtggtaactBcaMNNctagaacggWtctttgaggHcYNaaM
+HtaYcttKaagtSccgttgggNMStatacDttataaaVaYcKtcgcattttcgacctctc
+acVttNtttattgtcttctaVcatagaattMttgtHtMgacataaatagttctMtgtWgW
+ctttcaagYgcgtNaagcaaDaVHaaStMtaaagccccgtgVgtcacatcHVaDtgttBt
+BacBtcggYttDagaDYtccMttagcttacNcgaagatRtDataRtgctaatatatgRtW
+VttatWKtgcBgactcgagaSgtaaaaagttaaWaaagtatttctcWtatcBtcataacN
+cgctcRKaaDKactRaNtagtatBtgaaatttcgcDactttaNtYgagagaNttgaatta
+ataaaSMattRHNtYtgttgaDBRBttgWttagSatgacDggNVagRWcggctacDaYSg
+aaattHgtYaaagctccVtatacattaMctttgSgacatBKaattRgtaBRtttaactat
+tctagcMKMtttctgtgtgVgtctttcDcgtaaMtaggtaaaDtcaYtatccgattcYtg
+aaRttctKaNctaYgYaattYgRttWctWttaaaccaatcactVatgcgYttgaaatgat
+KBcNRgctcatgaccHagcgaaaatgtVgccatcaBSatKccRStSattaaatttggtaa
+gcVattctgVcattMtacatMgaaaaaataYNDtDaatcatWattcaggNcaccctcBtg
+cKcHagYtatBatgBttgtVttaYBgBgataaHNtacRtcaaBaKcagNtcagaatYgtt
+WgggaNDagtatagRtctcDtDaHScagttcYcatcSYacHcagagNgtgcHagtacagc
+tgRtatatMtaatRaWMHgaaKacaBRtagHtaaaNcVHcatWBgWaaacWccggtaaRc
+attgMgttaNgttVMVttgcaagagaatcaaaaaagYScKVtgccgacHgacgttcaMcc
+tcattatgcBttttaagtKatDactccgBatHYgttcatcgaaatctSaKaagaatWVtc
+gttgtcttaMaaYaSDtaaaataccgcKMtatgKtgScaaDMaaaactgtgagcVtttaR
+cttgtaNMatatatttggtMgYVatDaatttgctttaaRtaBgttaYaaagKtataMtWS
+tcHaaaaNacgctacMttDDgactacaNaatBcagtcattatatSttaVgRtWgSggcaa
+tSataVgSYgctBttataaYRRgaactgtgHtgacHWSactYNgtttBactatWStaNtc
+StcMttgattStacctgaattctWatNaaHgMatattcaaaKWaBaataatHKgaWgata
+YcaWMBtgtacKagaaaaagaattttWttDaMtggttgtgaNMtVtDcaacNttactatt
+acggKctatttaaaaBKatagttHaatggaatatYWgtaVtNaaYgataatMaccWagag
+atRttMtgKaMcgatattaacaagatgttBBcNaYattcNgtRttgaBcctaagaSMttc
+MtcctcYattcaNaRBttaatgVcMNgaacKagatcgNctaWVgttaaYRtgctSctaaa
+aNtttgctaaScttcVattaHtaaMacNgttNtKHMcctattttaRtttVtSgtacatBg
+tVaaSSaMVaRBcaSaRHtaWtWHttMtattVcaMtWaaaNaccccgHYtcatagaaRta
+aBaatttaBccaatcRctcatagWgcBHRtacaaDttcBgaHggcgctaHtgacagcSNa
+ttcctcgagaccBggtcaagWctgVcRDgVtaagtttaattatcMtgatNagYttHtYta
+gccRatagDtaatcNtaKtacaMSgDaaaatttgHaHtRDgtaattKtaMHgaBcaWtBN
+YaWgtttStttaSttgataatgactMKatHBtttaVcYatgggttttaDKcSatttMata
+tcagtYaBtgVacaatHcaDMcccgtaataatagDataatVaaagaagaVtctccgaRgt
+RtaatcgagtcacttgttSatgNDHaSNRcggtaSaagcSaBgWSgcatcaaWatgttac
+atgattcWacMtagtgNcacgatgatttttRcWttSgtaatMRRBaacNWRHaaBaattD
+aagStgatccttcaDacccctKaagScSSHaaYHWcHcaWcaaaMBataattgDtagccW
+tcRHataMNKtMgHaBcatcgaagtgtaRgtgggaVMatgttaWRtStBHactaaRaact
+NctcHaaaggcatgcVHKHgaatcSccttggSaWatWtNcaaBctaRagaaacacgcttc
+KatRattcWtgYDaaaaaaNatWtKgaacgtNttactgWHBaccaWacggttcaaVgaga
+aacVtMttatagaagtatWtaaaNHYaMacagWagtaatttgcatcttcgaatacggaHt
+aatVattctaDaHtRKRaNHcttacatcDKttMDKaWggDtaatcttYctcWtRaaaaKt
+aatcctgccccatgcgDtctaaVMtWRKKDctaatatDgactagWtaaaBcKcacMactM
+HHttgDataKHDaDttHttatttagtcaaVatccKWtacWtSVcaggtaatatDSatgcc
+tKtatDtttagacKaaaagcgtttaaSaaaYtgattgtKtgBMcKttgDaaaagttBRat
+HgcaKgDgtgcWataatMWgcVaVatcYgWttaDatcatNaVgtttgggcttgaHRDaWg
+atttctgMHgtVtgccttBtWtaatcgttcgKgRcaBaRMtaattWgctaatMaVBccaH
+tDagaBNaataRcacYcYcHcatBgaNtgaNgKHttctYaacaaaYgBttRNtNggaagc
+WtDggattgagtHaWttVacaaaBtgttaNctaatactKaMaaaaaDtaRatttDaaagN
+ttcYcaaactcMgaYgtacaaatMaaatYtcacVaacgaaDagatWgBgaataggtWtKa
+aMtgDttHtgagttaatttgVaaDagttNMataatttaSVattNaDtKVccaaatcgaYV
+taaaacKRaataatgaBDtctRtgVcttatttYtgaHgttBWatgaatatacSaacctSa
+tNNRccagtactKagaRtgSKMcgaaDattttagtHcKcaaagtggtataaaggctccta
+SatHtaMtRKattaNRcWtccgctataKggatWttaggtaatHDRatttattRWgcgatc
+ttagSgtcttactatgYgttYaVBtgcaYaaRtDaatacHHtDcttHgBgNcccataDta
+aaaatctNtacatatWaRMBgaattaaaacgctctctcaagtKcacNacgVRVcttttta
+acttgctcStatRScaRaMataNaKagtatcattRttNaVatcKgtacNatttttgaNcg
+acaaKctHWtgaKStacMaBatgWttNSacaaKcaDaatcWaKaccgYBggMScgaMcct
+agcaDatgtttcVatgtRBtKNWHtcctWDtatttttNNSaatattcMttgatKgNgaNB
+atcSggtctRcttttttatatggtNttDYNYgaaaKctcacacYHRgttacatacttYac
+aataNaagaaaagttataNaataSatacagttScacVaScaccSWtccagKHtaatcaaa
+tVacatWacgBctccaataHaaYtMtacKacHttttKtcataWWtgtgaatWaataaaaa
+catttcaccttaHtttgttccaatcccgRBaWgatKgagtttBaVgaNtaNVBgcaataa
+gaatagcaKRttgtatcaattaMtaacatataDBgtaaNttcaNcgagatYactggttat
+gtNVtaBNtDaaDtDttaSaWtactaVtHactttNttcttcatWttcDatKaacgtttgg
+VDaDtVagttatgtcagactKaatcaYtSgttttataaataDttKttKagacWgHgatat
+aaatcttagatNKtttWtWaaatattacSHaRgtttScttaatWttacgRRaaMactcat
+BacaccatRtttgaacctacttcDMggcVaSBagaatcttaKMagcaVtctDVataWtSg
+atagacttBctDtBNWgtgKatWctYgaaStccgVaaaDattYatagtatcaacBaWYct
+gaaatttaKVgYtStNtcaVggtggaNYgaRtMaacataSttcagacVactcaVaagtgg
+tattaaDBNDaagtatatMtactatatgatRSgtttgccaacgcacRMtacRYNataaga
+tcMgttgatcataaacttVcatatgWtacaaaWttggaaactttaScataactRattMtD
+acVYataaaagMaattttKtgaBttKcaacatattVtagtcatgactcgDaacDtaWcta
+tRttSSYNtgWaScaaataagaaatKtagacataatggNaatttcSKtVWtgacagKWat
+tcgVatttcKWgagcaWgNKaaaatatgtaaacgttcactaaWgacaccBNaacagaaSt
+ctgctaHcVtttMtcYttStagYcgtttBcRtaYacttgNaacMtDRtagcatgtgcgag
+cScaMgtaatBaKataactMttttattaRcattattatacgtaagSNatVRgcttcgaVa
+acHNtctaHBKYgKaccYcttagagcccaVgatttgttagactaaacgtgcaBgccaWga
+VataggattDBWaattttgtBacWtttttaatDtMgaactaagcVtctcagBMKatgatt
+gaNaVttggatDaSaBatttcgccatatgctaattgYacatgatccacaaMHtttcKYKa
+WtYcgDtNaaDccgNaNcacacHKttDtttaggctagRVtYgtaactagctttcacaaat
+YtHaattYacaattaMSagMactcctcatgtScttcaaYtataaaaScHYaKcaYacact
+VcacataNtaBcaRatgYagVBatttgtaactttgRggacaagcVacctattacRcaaMa
+cHRagagtaVNctacagtgagacgaaaggKttacattgggacaataKNtattcaagWKtt
+gatNagNtgctaNgagatNacSatctNatttatctatRgaaaatKatNKSBcKactatac
+StcagtaggtVtcaaaBYYgctattKtWNttcRacaaaNatgaacttaRtaaDSttVBYt
+aatccagtNaaacRttagaaccRBatataWaatKctcattcSacWaacaacactDttVtt
+gacYaagagtaSgcMttBttaVNgRVagKDcttcttcNtaggttgcgacYacttaaggVH
+caagDagaagataaVaatctgtatRatDtKaaSDgattcaattYtcatgYgtgaVMtMaa
+ctaagaatgRgDtHttaaccaatStaaaaMctVDDtgttatcttaBBgccNacKMaHggc
+BMttctgNctHggagaataYMgtaMccaataattHttYttKggtKaccaactcccHtMSa
+atNactcRtttcatgcKcatgcacttcatSaatatactttVtaYttDattgWcctcactc
+YccattaDDaHaaKcaatSttagKtWtcatRcaactattaattYaDggKtagtNcgSgtt
+tKRgtDWtVHtDNcHWNtKtccgtctagtatSctaBcacgcaBtaacatgagatVtttaa
+ggcaVttBttaStWtattgYaggtSatBMBDactVtggttDagacataaactactBgcac
+aacMaagaStccaWNaaSYMYtgtaKaMcYSaHaaaatatttMgtcaaDScaKtcaBVta
+MVMRRDMtcttRBgWctaacttgaacNaatgttWgtggBtRttHVKgKcHVtatattSaa
+aatBttcBtttcDgHccBagtRBRttaVagBctRcaagcattacKccaWVWtaVcggtta
+tNaSgccgKtYcBaagcWgcatgaNHaKtagNgcHcgtgtcataaaatagagacttgHYa
+tattctaBgtttatRatctatttagacattttNtWaaSagtaHatRtctcggatttatgt
+gatBtctRggggcatWctaSVMaRtcatgKattgRcatMaHaataNcBcDcaggcactat
+tHBgaatStatattcatBgMVataaSacVacKHatggttaaBKtgtaSaWMattttMacK
+tgaaWaaWgctgRatgtgDacBtSaHtDgtgtMVttagatgattagagaSttgattgtSa
+aacagHaaatacaRcaccBtaaDtcaMtKaaStttatKagaataaNcaaBtattKaVNaW
+aNactagtYattaaagWgHttaMcKaSagatSactctatMSagtggaYctcacKKgaSMg
+cRgKtgccagNMataatccaVgatcttHagttttcttaaccataggggcttaDtYatcga
+aaMataagcaaatBttgHHcHagacagagaggcacWtacccMttacgtgNttattYctVa
+aactgttaagtKatMagttcacaaagggatgaVNMatgcaSattatcKagtHaBtgaagB
+cggagtWttVaaDaccMScactgVatccaRaSatattNtgcBatgBaaNgtcaBMgggaa
+tgagtatRgaatgtNttacaggcttaHaataaHSagatagtgVctattaaagggaagDWV
+ccatcKaaaatRccccaSVaaatttMtatStgtWagtStMaaatBctgcctKWgttDDaS
+KactctaaVRtaSWcVactggaaaaNMaaaccgcacNtaVgaagcttDNgaDBtaMaMKN
+tKccaVtgctcttMMYaaaaHaattcWgHcgtacatWaMaaKtaataccgBDaYRaggat
+atSKcScYagMtaatKHMtaaccatgHgtagDaggtgtaaatatagaKVgccRYctcRaK
+BKWtgatHYcaHgBaYtttMcatataatgaDttcatttaStgtcVSgacggtggVgtBtg
+acatgtaaSgtBgatKtKtaYcatVtNattataaaHaSccHaaagctSMKattcatagca
+cagtgBRataacaatMttKcWaaaaatagStcggRttaattatWaataatMaYagatgVt
+atccttttHaScgtBgagWcatgBtgcctatcgtaaWHacagtactgaattaaaaaNatt
+RNMaSSNSctattcaaagccVVcatattttagMcgtattNtVBactacScattgKVtata
+aKtttgNaWcttNacctagtgaNaaDcagtaWgKggaaKtacgcaaaYttatacSttgYa
+YttcDNagggttVDagHatSgtacYVatataVattataSataacgKgatVtVacHYRWtt
+atcctaaDtgtaaDgRDttttattWtaaDttggatcattNgtVaaaVggaaggcYgSWaa
+attcWHcgaSaVWaMatctMDtHBgttttaatctaWaagatatDKtVttaccgaMatRaa
+aBttaNagHatDHWcDtBVttaatKtMataYttSRHHcgtaHDtggttccaaagRRtaWt
+VctRcaNDttatacgatMcaatNHtacgaattBaatHtcccatctctccBtgtataYcta
+tgtcgaaDYWtNggatNcacRtMaatNtKcttSYSctaDaaaggctDaStatKtataBgc
+VaatttggYcttaaatgatgtHctaaccaactttgggttcMaaDattatKtVacgVcSca
+actSataSccHttYctttgtggcDtMcactaNSBtMRBMaggttWKtattaatgtKHact
+tcaMVatctgttgtccaaYNtaagttKaacttctHcgcWtYttatMBgBaMacaattaDa
+actNaaatSatcVtSSgatctatgNatSYaattRatgcDgtctataagagaagRgatatt
+tcccaataHgttttWKtgaagNRtctaaBtWcHHcDgaattgaaaKtgttaaRtatgtaM
+aggDttcMaccaMaattDctgYctaWtStaNtgRKaBtNcMHcSttMtaKccYacgNNct
+ttatStgVtaYtaagttaagaBHaaStVKHatgttRVWtataMtSatgcaattcMcttat
+KgMcagtgaatcYtcctNaYcttactttctcttcatggcgNcatScStBtagctWtHaaW
+attaccgtctcgtBMcaaacKctcccaacttBgtWStVttMRgKcVagHttVtaagMaNa
+tcaHttacatcYKttDBtatgSattVcgBcBVYttHNtcatKgcYgaaSaKtatttttMt
+ctatctaSaattDttcWagHSacgttagYgacWaSaDKatcNgctaatgVSctgctYgaK
+gKtaataggtggagcgtcgaaaaRYtgYWYSaatacBgacWtaNStcaattWtRctttta
+aSYgttcNgtBWWgtgaatHttttBaMcMtKccagtattttcgaHaDtSVgatgaacatg
+cacgtcagagDYattBcagDctcttNcNtaaaatRctgMcDacaagtttagtcaaSSaag
+aaacatacaDtctctYgcaaacBcaagaBatgtattgacgagYacBDgttcgtgRtaMga
+attttcNtgVcttctgtctagtgtccatatctgatYatNtatVWgttacaDacaHDDagW
+tgataWtatcaaBRatDRtMgVcgaaattcSMagYgWacgggtaacaaattcagcatagS
+gttactBctgSVWatYcYgcBWgggRcHtataSaattBcagHgcgcctttKcttWaggct
+ttaaDtRacBactaaVaaKtaaacctcgcgccattactKactKSDcgacaVtatatagga
+taKctcgSatgHSatVcgtagtgaBtSYtgaBataatStaaccaagttcaDtHtatatta
+acYatattatcctacgagatcaccgtVSttctYgtcataaVactcgWtaVatttgttgga
+ctaaaVcaSaDtYcgNtYtctVaMtaattatWRtWcaNtaKcaaYggatgNgaatcaatc
+RtcgagtHcgVgttataHDcatttaagttctHtcgMRHtaaagaVactBMtatgaagtaa
+aaaBNtataaNttcKcctaNttaaDtcgMacgDcaMatttgYtaaNtcaccgatgagMtg
+ttaggWcacHttNgtcttHYMcaattKcagttcNcaaaacgNaaSattgKttaaBaKtta
+tttaMggHcttttaaRNVgttaYttttMVRtYVgRatKcgVtacgaatttccBatBgYBR
+tSKKctaaaatgatatgBtcttcgtttgacHagtaattatatctgDtBttatgaDtatKt
+cKRcRttagattattagHgDNaaaKgcgMtHtttKtDtgaaaagtaMatcagaaccgaat
+KgtatatVaccRaKYtDHtcSagtBgtgccWaaaggtYKcaHatDDaaattDStDtcKgg
+tMgcMtgtHtcaaVcgtttNtagtNtgKgctaDcScgBcWSatgtatagcKgWgttgaac
+gagtgcgcgtKaaaacgRtttccatatatttttMgaKagcVcVRataccWctctcgBcga
+ggcgttaatgaHYtttHtaSWtagcagtttKtYaacaaataMtaNDatRgMBaBacSaat
+aSDctgaactattgataaRtaVtttHatWaacWtVaHaaBDtactYtaDactttSgtKtR
+attgatttatatattattataattBatagattctaacDcRMaaggttcgtcatattRVYc
+ttKgtRcgWaatcgaaWWatDctacaaaagaattHaatctgttttacYatKatBaccMaM
+aaVtcacStaaYgYKgtttctcattatattNgSaaHtgRaBtcataKYtHtacttgtaca
+aaDtYtgatagNRcYatgaStaaagactgtcWDtYaatVaNStagaaaWtaaaataDYtc
+aMatSVBVaaaYagaaaattgtgcDagWSaStattttaatNcacgataNBtaattggaat
+gcMgacattHaattctctaaMatactaBaaattacaHWgBNtNaaSattttaacHtgtag
+tBtcRtttSaNNaYaMaDtatDtagaKggYgcaaSttgctactDcNRtWgtttaVtggca
+aactattgSgaagtattatgDgcgtgtcttagcNtRctKggtMaHgaDaaagtactgtcg
+atttagatcagNggtaattaKaatgaaYaaHaattggttVaaMggatactctaBgtYHMc
+ttccVcaaWtgttHHRgagttKaaagaBtaRtaaWaggttctatRatSgtatcYtaWcat
+gtaBtcaatctaatRgaYYtWtccattataBacttWtcctaHaaaaggttgacgtRattK
+gaagcattSBtttctaNcSctSStNtYtWaWtgtagtcttgtctttaagNKgaagacgDa
+RgtNaBaVDgaattggaYtaccSVYKctSKKcatagttgSttatcStactcaatSMataH
+caKgatWVYtNacagtttBtRagYHaagtaNaaVVDgatattMaagattagcatcctaMa
+aMctgNtMcSaRcgctHMttaattDtttYttcgataaagtMtaagttaWaaDcaatccKg
+tgMMcatBgtRtaHBcttgtBaBggcaDcgaWttgggtaDaggtgatRtYaMWDttatcN
+tVcttRaKagctRgtgcNaatctgattatagattagtatatgaataDNatcYaggKRaca
+atcaHcaagttagtKgRatRgttaagaaaatacVctaaaagtgtaagKVgcttSWaaHat
+agHctagtDgDtSaVtgatcatttaNKgKHataKBctatatWaNgtttgcRaVNttaDgt
+cttagHYKatYaVaBtaatgaBattaYcNtgcaBtHaacttVtccatDagVaaaYgWtND
+BgacagVgctcaRtaHaaacttttacaaggaSRaaatagaagaatacccVaHatcBRtct
+tttaaDMHWtHgacMtctcaagKDttctgYctctcNagaMgcgaaDWatMcMatatttDc
+tttactaVSctagttcaRKWgtttKRaVaaKtacaacaKttatttttggcctataaDgtc
+BctBDgcYYaatNactcaaRgaRWcgattgVNcWaatctgKagDMgctatKttRatcatt
+MaagtctaRaVaattKctgaKtatccgaaRatcHMaaaaaagattccacgtacgaDStat
+atctcataggtacgcgatgtgaaggtHYtatWagKVKgaMDcaatttWccttgKgagtct
+agatgaatgVRcctaMttgtaRaaYtRtaacWgaaaMttatcatNcgttactaaggtDaa
+ggcagtRctcatcaatggYagccagcgaatatagtgttWtaccaRctagatttDtaaatR
+cDKtccHtBWgttctWaagccYBSgtggaaagHNttHtctaaattaBatggaDMgaBgat
+atcaatactcMtaaKtcYccgatDaYgHDBaagBattWattgatttttaagaRaaggatg
+gYggaKttaKtBVBcttaWcttBtacctYaNYttgctgtBaaMtWtcWaagtaaggWcgM
+DaaNtccWMWtatcMVgaSaRctaKtBgKWDacDgaaaaNgttcaaaaataMcttaWtat
+gNaVaaRataWtgKctRatataagtgttgacgaKgaNgtaHattaaRagSgattctatgt
+YtcaattagBYBatccYtgtNacHagHtacVcVacaacaccgNgBtataYaatWHSttat
+tgctDacttgtgHgHcMcHacagctRSDtgattaggaDHtYagatggagWtaMatcRccc
+acRaaaYagcagatgatacatatttVBBcaaMtctctaWgaNtttcctaVcttaYBDBct
+RgSaagcNgatttcacgtcRDaVBttaRaggtaaggHcacttccgDBKgagaatttataa
+aMaRattagcVgtttacaaagagaaaMtgDtttYttggcttataKaStacaVttBttctt
+gBcVaataaagagtgagBgcgNcNattgaaacRcactDaaccaatWMtaaHtBgaaacaa
+ccctcMctcaaatctMWttggttttacttagcRtttacatRtccBttVcatgaaBacaYg
+agHttatWDtcctSatRtYggHtNMttRgNtgcatcacgacagaHgtYaSaactgaaNWV
+agtagttagaNgatctgcatWYaDacataHtaWttaatHaDgactYgttcaSVtttacct
+aatttaDgRcagacaDtgcYVttaagaSSKBYtgHtDtNtcgtcWttDtgtcNtgacKag
+cactccDMacDNcccctWataRKcaaatttctRVaacagcaMtataaattWBctttgKgV
+catttaVgtDgtatHtgtaSctagtatagcBtBtgtatgtcgcMcgagttctacgaaBgW
+ccgaWatgcaRtWtaagYttaNtcWaHtgattYDatWRgRWagtRcHggNatNttWaaac
+aSgcaatMatgacNgggaSatgatttcBHcctaaggWactacagaaaagctMcaaagaYt
+HVgtaaHKgKattVaWtttcctaWgaKattatgMaattBgaaagtgaSaaaWtSNBtttY
+ataVgNatgaSgcBaaccatattcctctagRtattatctttctMtgaRtctcYgaatDtR
+cHgcRVtWtaacDtcacYatRcttNgcgaDtVctWtacHtatatgtatKaaggtaNcata
+KRaataacacDctcctWgtSaWcatcDgatatBtaatHSNBtcaataaStHtacttaYaD
+aMtaagMtgNaaaaNccccgYWHaatgcBcttaBcgtMBKggccaVgacaWgaaaaaVYc
+RKctMgcaccWctcSacttcVtacgaagtYtcctttttaYgttattaataactSttRggt
+cVgagWRStatKataYcaatNMtacttcgcttVBaYRaKttaaYatacagctBgagcttc
+HcaatBaaaVcgctcacaMgttaHaggctaDtSgatattggggBgRMagtaattggattg
+YYHtVtcttSRYaacttataBtNKgatVaWSDWacatVcttgttgaagScaDaSttcact
+aattagatKttaMcHtMgKccaYatKataMcKNgattgtYtaaRHHcaWagctgtgcYat
+MHaatRDgtgttYctatNKtSDtaKgcBttgagtKtacatgaaggcgMatDaWtcBatag
+taaaatNYtSVgVatttcaNgRtaRaaNBttggaatVgaaaaagaaggtgNtttVBgcct
+tgtgaBtgMgtaaacBgtactWgtaacctatatggaSYattYtVgtttaagccaRtatRM
+cgWMgDVSNgataatBRccNagagStHttBgctaBagatattaacaagaggttttcDaRa
+gtcDgtHttcataagaacaKBttaBgactaRatgaaDYHttgVagcMcBDgYactWgSga
+cBataMMcttSaRHgcagKcgaaYaDgttcataYKcttcMWttattaaBacDcttDtttB
+catVggttVHtgtMgKcgaaVgtcgMaaHHYBMaHtaaKaDttaNgNtttttaggMcWtt
+NaaaDaaaaactRgaatagSVHtaataagttStccaatcHataatacMcattHtacaatt
+tctgatggacatatgcaaacaKBatgcagacagVcctccgcaacNatcMaHtcMtaSctg
+taYgtStcBtcatDacRggttRgagaaHatVcttYWgaDtatgYcaBKgtSWVYtttctW
+ttHtctaYttttaBtcataaNgtBRaNcgttKgtgVKgggVtWatcWagttSttttttaM
+aRWtccgttttattaHatttBVtataSctRWtgcMacaattaStBcacggaatRatactV
+gaagMaaagWacaMgctaacaHctHtaatacacgaYagtcttKagcDttaKBHccgtaHa
+acaKVtcMKcaataaaNaggttSaatcatgaNaaBtacggBcaagatcRgttttHaNgtK
+ctYatBHHtaaaDNHtaVtVagttVacKtcYgcattcatacaaagtaacKaKKtaaNtNa
+taaNaaSaBtagaattctgacacNtaHtataBDttBctataatagYSctgtaHcgccgaM
+BaggttaMHtKgttactaaHaacgDatataaagcaWtgaMtttgVatcKaattcgHVNat
+NgDaaYtataHacaaacaagagtatatDStgcNgcRtaaWVVaDStNgtcaaacgDttaa
+ggNttWcaVNaccctgaaaMcagVYVaMtBgtatacSacgSgNtaaaDtRaBSaWcNacg
+YaggtcaYtattagVStaccgatgSStMattctWtattHtHaDtatgYaatattgtttta
+NggttVatcttRcgaNtHaVaStgaagactcacaaatcactgataaKBtNHtttctWWta
+ttgactacNtaWatataaaBaatBttgggtatYtttYtgttttVttgagtcVaMVgaatN
+taaNgKMaacgtaatattKWggcagtgRttgtgacactaaYacactggaaKaWYRgcatg
+cgttctBcttggtVaaWgtttHagtcaatctcggaNWtaatBNcaMVKStaNcMtgatat
+aatDYMctttcgcatgcYtHtVNgStggagcBtggMgccctgtgNtVatactgcctcHca
+taDBtaStgNcagaYttaMtcaYtgtagatDaagaHaaaRcRataattcaDtcaDgttgt
+atRaaaaYaRgtttDBgDcgaagcNttgcVttcacttaMgtMWaYaattcggaDcgaVtY
+attaBYaaaattaHVttttWaacDttaRaSWactcBgaRctacaVStBaaatRgaacMSa
+agaatagYtNctcaatagctNttaVtgctgtttgYcttaatgtgMaStactgDBagVSgg
+tSKMYttDatgtMaaSaVtccSRMgaaaactHaatWWtcatttctDgcMcggVtgtRtca
+tctttNatcaatatYaKaaaatKWtDDDaaactaagtacRHtcKttacaataggttWctt
+ataSaYctgctVtaaVggatcctaHVttgWtgHtWttaDHaNgaccctatatgcWtNtta
+cctaYtttDWtttaggHNgccatattacKggattVatatcRcggRWMtgcaVRaaHgtaa
+taattttaggtctcDccaatatgSaaaagatDtaaVtYgNaHBtcaYttaaaaacagata
+taaagttaaaDWccMHMattggtaaagtccgaKtatDKaVHaBagaBatactataVttDt
+tDaMagctctaaDSggtttgaDacacVatcttNtgatKtVaBStatgNtgDKYcaatcat
+aWtcNatYccgRtcgBHacaBaatagaVtagcttgaKagcgHtttDNtgaagMttStttt
+gDDKRWtagtaBgtgagtgBcaDtWtaHcctatHatttgttWgagcggDtgtRDRcaaat
+agcacacRtDgtgVaWtaattRacVataBWacSYWVctgYtWDaVtaKataaacttKaaa
+MVHaaaaKNtaaacttgVataaaatMaaatMaagtatcaaRtatSYRtBtaataattgtt
+tgaWtaNNtctcaatNaataaaaaaattgaaaattattgtgttaaYatccccHtaNcatt
+cacttttaMgVDtaDMtcaWSgYWcSYtSgaatHtgctagaVattaBtaaaYgatattcg
+aaBtgaaDacacatRaagcgggagggDMtatDttaatttggaKSNtactRMttactgtBg
+gcgtcatNttctattaVacgttccKtVttMacttWtctaYcacgtaVtaaRgKcttggat
+SYatattttgttacaaMgtgagagaSatattWcagDttggNtNaaYtaggaaKtYHcttg
+KattWagNgtaagHHVatYatcattaaaaaYtHgttcaaaataattatBgcaKWKtagaa
+tagtatBagaaMtattMagaMtHcWgYcacgttagtgtDNggctatNatRcYYHtaacMa
+SStattRagRcgataaaatWNNatgaaatttVtKcRtKtDtaaMcctccaDRcaHtBSWc
+YtaKttcacaaMaataaMaactccgSgtYattDtaWctagatBtaatSgatgatHKgttg
+caaaaagaScHtgaaHRDatSagatcBcggcatcatYVaatgMaatStgNgWaaaaMttg
+cYaaagttSHaYgaaatHattBgtaaMRagSaSacBaagtttttcatgttaaYcagYtgK
+tYctaStcaagcgtaVattaNatWtHgtHKNDtcNaKaVaStSacaaStttagaaataat
+gcDSatgtaKtgMMtcaaagtNattacMYgtgctNgVcaaNcDtaaaVtYggtaaaactg
+caagaWNcaaacctDSaaSgVaKtctcatataMtggBtaRttKtagRcctgttaHgWRaa
+ttgDaaatttHtaccagctcagaccKaaBctaagtatWtaVagBgtttatgaHaaggatt
+StaactWacKDVtMHccgtacaMWYctDtagatttRctaccRagtWcWgaaaaMcagttc
+tgacSctaaaactgaatcacaNcaMWtWccYgtttNaatttggttaaNtggttSattttc
+aacgYVccMtcgaactBtatcYttcYDVMttcgattaKWtatttagcaatatcagWatgc
+RVaatgRtacWaVVBttggatRtaNgRagttDYataacDVBcaaactttgtttgaccata
+gHMtRctaWcgacagtgcVcaaVgRgtaagtRaaaattSBKacBaatcagaatgtHattc
+aVRtatVSSaKatNataWRVaaagMaacataDgataWHatcNYcMtatttggaSatttcH
+cgacaYcaKaaatattacHcSaBVatHacactaMDataaaggcacaacaSacctgtaaRg
+tcccaaaatWtDtagtcaagNtttgatDacDgcagaDcWgatDaaKagctDWtttatatW
+gDcaaaWttStDtKtatSagVgaaKtaacgaccgMgaSaatRRcagYtgttNDggcHSca
+aYDWtcaacgtaHgaStKtgMtRtaatccagtDaaacHgtacaaccHtagataNaattat
+cVtgaKaaNaaaaaaaagttgMgtcRaNaacagtaKcaBgtttgaMDgDMacttattatg
+aDgagcgtcacaaRaagtYaggMtaaactagaacagVaMWataggtatHagtttaaHtca
+gtaaatgRgcatgRctgaMttBaaataagWVtcHctgtgtYaaaaVtKtaSaaBatMttt
+gttatattattcaaBYctBWtggatBtgaggDagtgcacVataRBctaBaaaataatttt
+tNggtccgtVaaaaataaattBHaatBaagaHgttaagcctaatcaaatgaYtKaatYta
+aggtMgaRggtWgggNactaacgaRaaattSttWtaataaVtHgtacttNtaagHaSacg
+WggaYggNStcctgacgDcgHggtttHggtNtMtttDatNDgtgacgtatacgatKatat
+aaacaattSaaagcagatKtttSagcaaMttttgaKtMtagtcRacctKSttBttaatMt
+gcgttacaaagaVaataattcaSaaWcBVacYKtacaNBaaKRtRtcgWtWBaRKVtYWW
+WgattgBctaaatKaattaYtMtSBMBHDtBtaggDtcNctWYagtgSaaBaVtcttNgt
+cgttHtgtMtctatKtatVggKaSaagtttattttatgtactactHtHttSMactatHca
+agaattVataaaMKNtaMccgtgatDaHcaacttRataacaNgaatcSBtatgacBcctc
+gggtaatWaaWtacacaattctRVgattctatgtgtatHagatagggacVaattttDtNa
+WKagtatatHtagacgaggtatgtcagtgagHccccaatNataKMBaHtcWgctagtgHa
+atBatSataDatatcacccaagattttcSatKgatWtgaagtcBMataaHaaMaattatg
+cttWWtttcgVKYNBattggtacttcaaMaVNcctcHatcgctVcttKatgtctctBMgg
+acatcaggacSgaKttgagtctKVYaaagtaaSgaaaHaWactgRattaaBttVaHtgga
+ttagRWtaaDaaatgatttSMBWMaDactScgRYtgaVagNctgtSBataKacStHRatc
+tVgBKaggccaRctaacttcYKtcaDcttgaaacBBataatacYMgWgctgtacttttat
+gaSaaatYcccgattattRStccaaaBagaacaaaVtttgcttatagaaacacScccSaN
+taaaaBgtaaggcDgtSttRatMYSWatcgtaacgtStBagttaVaaaScccSggaMDBS
+gcaaKaggatatacgtatgcWactccgVctNttMaYtaaatKaaatgKStaaaHaKatat
+gBtcctatgtVaBggaatBcgcaatgagtatHcYagctDgtWaaccagtatWWtaRtKag
+atagtgKatatgaaaggcaWgtNKaaagataWaatHaaaaaKMaaatttBtatHtctNac
+tKtBVVagtatcacgtMgtgttaKtaatcgaaMHtYKNcMaatgcaSaaDBaaaaagaWa
+DtWMgaacatttDcatttaBaBtDttaaSMtcagcttttRWWaataattcNctactWaat
+NaBaattaagaaacttYRHaccatatKtaKcNVgttYagttBtaaaaVtctcgVctagct
+cgSVatatagVtMcaaHRctaHStttNtcattRaatgtaRtgttaatYtaagcattgaat
+ttaKtctaKKgaaggtcgMctttcWaagcgWaKcttcYttgtgaRaagMtDatgWgYaat
+aKaatSWScatKBtYgtaagagaVcacgctHStaacaSgBtgtaNRYaaWtWcKgaccDt
+gaWtgagMaYgVVgBaRacYtcKgatcagttgtaKcgttgagNaStctggaatVtactaS
+NtaaagtaatcaattaaVaaDattHDBaHKDHctVggcaaacccKMaatVtgttacBcct
+StgBgMtScgaaHcatgctMtStaVttttcDaNagtDVaatYcggaDaYtaactaNgtcc
+aattSacaaaaRgtagaaKgtcRSNtgatBacccttMtactatKgtaaRMagataMatgV
+tVKagaRagtcagMgMaatRHNttagaagaatgggaatcHtttttSgtNgYatgtgcYta
+atgDctMaaaMccVScgcRgKNaaagtaMtacaKaMNaBatagBttttcttttYatataN
+aWcagatttgMtgaaacaBYtHaaatgtaDactatttNatttKttSattgBatSRtgKHt
+tacgattgcggtaaaaacHHtaNgMcgHaVDtgtagaagatBaaagDttaacSatttaat
+ttaccagatataattggVgaRctRtcgccVatRNtDgcagBcVaHtBaatDttatgKRKa
+gataaRgcagtaKgagttatatcaMSagttccRcttaaatgatcttataaacaaatttcc
+cttaBaWtagtagttMaacMaKaaaagHatYKactttRatgtctcgattBcSagaDKttt
+HtBaccttNttVttVVtggttacgtaaBMRgatcgtctacaaNBtaVggttYaaggattc
+caNgRgtagBtgtaBacaagtataaatBaaatKRtaMtKHgatcgYggDSgKRaSttHSt
+catgtatatWacacRacHcatYtttaacYatatgtgttNtgcSagDHgataYttNattat
+cVattcaaYttggtaRHtWtcgaBacgtttaBaccaBaatgtcgcNagaNtKtaDtgDta
+tgDaBtcKgtBgatacNaccDDatttYtKggMtYNtaactgVacattaaHgMttatcgtH
+MNtataBtKSgccaVttaBcttattcBaagtgaWtaRtcctDVRatgaattgatatgaWg
+ccacDaatKaHtttacatNttaWNWgtacaggctacttBaYaaatatacaaaatttcgNH
+gMgttHctcKYcttgMtaacBaDVtaatttacagaRttttttagcKagtKactatMRtgt
+DtaattccRcaaKSttagttttBtctatagaKaVttttgcNagtKVccttagRgWaNaKW
+ttataDgcgaatgMKatgatRcYtctgVagaccgcgVgactagaWaaHNtcRNRKaatac
+tcYaNtSDKtcVVggNgDagtttaaKRgttaDcgtNNgtcaYttggtttYtatgtaaagg
+attttagatattKMcatgYaaatcaVactcagagtRYtgtaactatagtBaDtVaWatDa
+tctataaaSgggtactaYaKKWagaaaaataaattatagRcaaaVataVagatatgtagg
+cWagacRWattctgacgcDtaBcYattgtaDggMatgagcgagaggctaaatVtctcagR
+agDtSgKNcgtVcStacatttagNtgatSNgatcYVtHattHtBgMacRaattaHBacRc
+NaaccctVaaYaattcVccatacKcttSagtctgKMNagRaNcatNgcgHattStSKYRg
+gtcagtcaccattttagtMaccctggVattHaatVagaaMaattaVacatacacaaatta
+attacgtKtagaaaMgatWgWccatYtagacKatctKatMcggYcgcatgHRtcStVtaa
+tHgSaaaVagtgaatgtgYtattaYcRagatgatcataacacSgaYaactMKttatRcga
+ataaMSatacNgaMatttcggccacgaYYMcaKattRagDtRtatMVBtaattWtMHgNa
+WDgStaaSNggStcBcVYtaYagaHtacagttccMcgtYtYttcattgSWcttagttcgt
+HtgVRYgaMacttBtatcaactaaaaVtDgataaDgtatcatYDttaStgccBacctaaB
+agttgRtaSBtaaaagWgcacBggttagcMaYatttBgtaggtRBaSagttcacgtaDaY
+aaaacDSaKattctgtSatatgtatggVBcctctgtgaaHDKgttaRttttBMHgRMgHa
+gtagMgacgaagttaatattgRtHtHttatYaaagcagatgtgattagtggcactactVa
+ttagatctctgtttatcattYttgatHcHttagStgatgactctDaaatcagtgttgttt
+ttcYaaagtatatcYcaSaacaVttcgWtatKaaaHWtRgtttaKacttctgaaNaYacc
+tNtcStatttaaagttKgtgatcctBcaBtctttaaaKagttgDtWctDtgtgctataKa
+gtaNHatctagYgatcMgtggYaagactgacacttaRaaccHgttcaYtagWtggtgBcS
+tacaMcMHataaaNagatactccaggagttaatcatRttttgaKNgSgcaggtgttRaYc
+aaataBtaDtatHgBtatacKaataKtaggaaatatgcataaHgaKttttatMaaaNgMa
+tYattgaatNtatVaggtKctttHattcatttatYtattagtataYtttagYcattagaa
+ataHtaaccttactcatYttHMRagttctDagNSVgcgVaNNattctVcaaVagaattta
+agaggttttacRagtagtaaaBaBaaMtaScKgVaRcNtctgtataagtatVgtDgHaYt
+tcHYttaagatRgtgaattctYaaaattRtcWtacDDaRatcaKtaSacaagctaNttRY
+agMSDKtWgWaYNgaaaatatNtaatatHMtMWRaRacaaaatgctgctacNKaKtagtt
+gVatDaVccatSDtgaSggcgWatccBgaaVtgtaWttagatVaBWtacgWtaYattaaa
+tMctDgDaaKatttgaaatgctWctttaHtggHaBBSRVBWtgattgagatccNcaaaHt
+>THREE Homo sapiens frequency
+gcactagtattgtcgggatcccattaacaggctcaaccacgagctcacgcgaggacatgt
+agtccgtatctttaacgaagcgacagcgacagaactcccatggataaccaattataaggc
+ccgtaatcctctagacatcgtttaccaataaatccgctttctccgtaatcatgttgaata
+ccccagagtagtccagatgataaccgatgaaacacaagtctttctcaatgcacttacggt
+gaacttattaccgccaacgtagctcatcaaggttgcgacatctagttgtgtgtttgcgac
+gagcccagcgaacttcatcaactttcgtatattcaacgccttgtaattttactttaagac
+gcctggtgatgtagattcttagataatcagtttgttatcggctgtactttaccataattt
+cacaggtttcaggtcaagaagattatagctgtatatacagttccatgctcggtgcacaga
+aacgtgatcggataataatcaatcgcttatgtcgtctttaggcgtatccaatacatgccc
+cgataccgcagtgtatttcgacatgtaggtataccgtcgcatttgagctcgagtcaggac
+gtcagctagattagattccttaatagaatataccgacctctagtccgaactaaactatag
+ataacgccaacttcaggttaattgtctagtcgtctgtttgcagatgggattcttagatga
+gtgagtatcggccatattggttcgagcactttagtttttgatgcataggatatgcaatgt
+atagctgaaagtactttatctgtttcaaactcacattgattaaaccggtaaacctttaaa
+gactacaagaaaatattcagtgagggcaattttgtcaatcacaatcttccagctagagat
+acttcacaatttgtcttgaggctacgcaacattagacggattttcgcgttttattgaaat
+aatcgaggggcccaagagtatccatagttcattttgtaagatttctttacaggcttatta
+cagcttcttcagactcctacatgcttacgagttatatgctagcatgtgaacaatagatta
+atatacaggaaaacgtacattgagagagatgaccctacacagcgcaaccgttgagtactt
+tcattaaagggtaacgctctcgagacagcatccttaagatggccttattgtcaaatcatt
+tgcagaagtacgcaagatccctaaccaacgtagaagaatccctacaaacacatgagacgc
+ggtgaaaatagacagggtgttagtattcaatcttcggagtatcaatttcgccaatcttgg
+tgagaaagcataccctttcttcagagaaagaagatcaatcataacactatctttaacgag
+gtacgcacgcgcatcattacctgcctccatggatctttaggatagcggaaagtattggca
+gcgtattgtgatttcgttcctactttatcaatttcacattcatatacatgtcttttatca
+aaatcgccaataagataggatgagctatattagatgctagtagagttcgcgccaacatca
+tcgataggaatactcaggacagcgtgataggacttttcaatccctaatactctctataat
+tataactctctcttaagtttggaggcagtaacgcgctctatataatcagtttgctgcacc
+attcttcagcctctgatacatacaaataaattccacagcagtaagagggtttaattgaga
+catcttgggaacttaggattttactctaacatcaccgaaacgattattggataccgtacc
+taaacgaactttctcaaggcagtaatataggacatccgcaataacacaaatgctgcctcc
+ccaggagttatgtcttcctggaggctatatcttacacccactcactataggcaaactaaa
+gtttaaatgttgattgtctaaaaaaaagatagataagagttggccggcgtagcacatgcg
+aaagtgaatcgtaagctataattctctggacttgaagttctgtcctgttcctctgcaaga
+aacaaacttcctttaaagctatttacgacgcacatctcagcaagttataaacatgttgga
+agtttctagtcggaattcccaaagaacggatctatctaatgcattcctacatttttcctg
+tctgccgatggtgccatcctattcaaagaatttcttaaaagtagattaaatgggactttt
+aacaatgagtaaccttacgcctctaagggttcctcgagtgccatacaccagtcaggtccg
+agccacatacacggagaacattctaacatagcattctcaactcgatcatttgcaggttac
+ttctttcctatcctagtgctaaaaatcatacttgcaatcccatagcacggattaagaacc
+taagaaacaattcagtaaaacatgttcgaattcttggtatgggaacatcattgcagctat
+ggtctaacgcattaatgtttgggtacatcttccatcatataaacaggaagagtctgacga
+cagggagtgcttgcgatcatgtctatcattgtgaaatcaaattgtagctcacatgtcgtc
+tatgagagcgtgtatccgataagatttagaaaaatagaagtcgtataagatctcactgaa
+cttttgaatgaatgtgaagcatatatgatctgctttaataaaactttatccataggatac
+gtttccaaatcaattcaataattattagtcaaaatagataaggatgaacaacctgaaggc
+cgatcggacgtagaaagtggtcccatcactttgagttgatattgttgaaccacacgttat
+tatggttttcaaacagtctcaggatattgtatatacagataatccgataccagttgtctg
+acgcccctcttacgtaccccaccctttgtgacgtttaaagcagttgttcagtattttaaa
+ctaggcggcaactaatttggaaagaagcacagtggatatgtctaaattcttgttattcag
+gcctgaatttaatacaccgcatagttaacttcgcggtagagttgttcatcatgcctcctc
+taagctaccacttctatgatacaccaatagttgttctacggaatctgataattggccaag
+tcataaacttccgctgcgttcaacccccttgctcgaatatccaactcgaaaagacagcct
+tttggtgtccggaacaaatcagttacttcttttctgatgttaattctctgtggtcagata
+cagaccaaaaactccgcggatttaccatcctccaagaacaaatttgcatcaacatagcat
+tttggctacatattctaagtctcaatagtttaggttttcaactacattatcccaacatta
+ggattggaggaataatagctgggtaagtccccttgcgtctacaatcgactattttttatg
+aatatgcttctgccgcacctatggttattaaaaaagtcatgactttgaagaaccctgaaa
+agatagatgaatcaggtgtaatggcagcagccaaagagcatataattagcaacactctaa
+gaacattatagatatgatgatagcgatcgtcatgatgttatccggtcacaatagtagctt
+catcagctaattcgttttgccagtggtgacttgcgctggaagaatcgttatacggtccct
+tccctcttgatacggtgggggcttattcaaccgcgtggattgggttgtcatacttgcatt
+aaacgatgtaaaccatctagtagtcaactatactaaatcacaaaatagtgatcaatacat
+acccgcttcatggttttaaccatttaattgattaaagatattccgctaagaaccattatc
+tacctaaactgatcgccgtatcctagtagtttgaaatttgatgtaccgtaatgatcaacg
+aagtaaaacgttatattgtatgtagaataataggtcttggagctaaatgatgtgattggt
+agtgaagacttacccttacaactttaccggtttctcggaagaatatactagagaatcaat
+gcatgggctacataagcactttagtctaatgagataaaaaatacacgagtcttccatcat
+gaattttttgtcgaaaaactcgaacctggtaatttaaaccatatatctttatgtcgtcaa
+taactctcatatgttttatataacttcccaatcacgacttgtaactgcttgttcgactga
+gctgtttgagctatgaggccgggatccggttgagctacatctatttgctacaagaaaaat
+gaaagcacatttgttgggagttctggctacactcatagagaaataagtggcccgagtggg
+tgcggcctgcctccatattcaagtgtatcttaaaccaagtggttccaacgctcgcgctaa
+agaattaaagcctttatttcctccacggagtagcccgtaatccggttcgaaagagaccat
+tgaagttaattttcatatccagtgaagtttaggcacaagcatgtgttctgccacatgcct
+caaagcgctcttcaaccaagatatgattcatcctaacttcgatgaatgcgtctgtaacat
+aaatatagaaggaatgattcggcgagttaattttcgccttctccaacatggcatccctac
+gttcgttataaggaccatacatgtaggttttaaaggtttgcggttaatcgatatttacat
+catagaaattctatagtcaaatttacaagactctagatactcactcgttgcagccggcta
+ggaagcgctttgtaccttacttcccttttcgttgcgtaatatgaatttcatatagtaagt
+tcaaggcactcatacctccgtgaagagggtagatagactattaaagttgtttaatagtac
+gtattgatggaaatgacccgtaggagatttaccactcaatccacaagattcgctgctgtg
+cattatcaaaacagtgcatgtcgaaacatgggttgggtccttcaaacacgaatccaggta
+gagatacctttgcaatttttcgatgaaggcgaccgagataaatgagctataacactgtat
+gtcttttgattgctataaaacacagaaacggatattaatttaggccgtaaccaacatctg
+ttatttgacatagaacagatggtcctttacagcgtattccggccttaatattgaggtcca
+gtgtattgtcctcctttaaagaagttgattgtaactgacttaaataagacatgtcaccca
+ttcactgggttgcaactgctggccctttttgtccatcgcacgctaatgtgataacagtac
+cgccctcacacctgcgtttaaaagacataaatgtcgctatgaaggttattcattaatttt
+agctgttttcttagaaaaggtaaatttaaaattgaaaaggctagaaaactaaagttacga
+caaatgtgtttgtcaagtaggcgggcatcattgagattgtaagaaataaagccataacca
+gccccggaatagaaaatgttaaggaaaggcgatcttctttgaattcttattgtcaagtgc
+agtcatacgttcttatcagaggacattgcaataaaatctaacaccctcccttgtgtggtt
+gggccatttgtacttcgaagcgtccaccatgtgcagaggataacggaatgtggttccgtc
+ccataaacgatcattctcgcccacttagtggcgcggtaaatcgctctcatagaggtaact
+ggcctgtaatgtccaatgttaggctaccttctccaactttagtacaacgaataatgtccg
+attaacaaggagtcaatttgtcatgaccagttcattcaggtacttgtatctatacggacg
+cgttccagagtagtatttgaaattttgaggttctactgataagtttagctatcgctgtat
+gtctgaataagaatttaatgtttatcttcgataaataacaattaacaactcctaggtgat
+acactgtgaagtctgctgttccccaaattacatatgctattttgttcacataccatgaag
+ttaagctaagtgctctataatggcataaacggttatcaaactagctcgaatttcttttat
+tacgccggaagcggattaactgctgtagatcaaacacgttaggatagtgtcgttttcata
+tatatctaaattcggtctaacatgcattacccatgcttgataacgtagcacttcgcagtc
+taattatgtaatgtccgtttaaccaaactttaaaaaagtttatctatcaccagtgatgcc
+tcatcgtgactacccggatctttagcctttagggtctaaacagaactaatattactacgt
+gtcatactccggagcttaaccaggtgaaacttatttgttaaccaaatttagtgacagggt
+agaaatacgtatcaaattaacccagcaatacaataagcatgaaaataattgtaatcgggt
+ttgggccggaatcccgcttggcgaaaacttaatgacatagtgtgatgcattttgcactgg
+attgagccacaaactcaactagcattatgctcaatatttggccagtgttctacggtttga
+aatttataaaggccgcgcaaaagtcttgtagttacaaacgcataaatctcgaacgtaata
+ggtttaattagaacatccgtaggatttctgtttatagtagatttatactaaatgttctga
+ttagattctgacggccttacccatacaattaataaagacgaatatattagttatagttta
+ctatccaaataaattaagcgaatcgaaataaactgtcacgatactgggcagttatcaact
+tatcacttatacagttcggacactctatattggtctgtgagtactctatcaaactaactc
+ataagttaactgcgcttccattaaatttcaatacgttcttgtgctgtgtacaaacctata
+atcgaataaatgacacatatggagatgcataataaaaaaaacggctccatatttctcgtt
+aatcgggcattcttaaggaggagcatctcaccaaaaataacgttcctgataagtcttaac
+tattagaccgtcttcgggaatgaacgaaacctcaagctagcatggtatagttcttgatag
+cgcgtaaattctgataatactgggcggacagctggaaattagttgccagtgcacctacgc
+aaatagtttacataaatcaacgggctccgaacgtaaatacaaagggttagttacatcgca
+acaagatgaaaagcatgtatgtctaccgtcatccgtccctaacaaacataaaggtggtga
+agaatctcgtaggtcaactataactccatccttgaagcaactactccgcgtccgtgtgcg
+tagttcgcaacgagaacactactgaaaaaagctaaacaactctcggtacaaatgcggctt
+gtgtcgataaagttggtggtagtgcacggaataacataacaaggaatattatttattcaa
+attttttgtgactgttatttgttttctgcctagaatgtaaggatgtgttttttgtgacct
+gatagttacgcttatttcaggtccacggtgcgtgagagtgtgtcctataacggcagggga
+gcgaagtagtgtcctttagactattcaaggtagaattttgataacgctctataaaaggta
+gaaaatcatgattgagcaataagaccccaacttatcaaaaaaggagttctcgacagcgcg
+tgtacagtccctataacggctgtatttcctgtgtcacaacaccctcccatcgcactcaaa
+atgtagatttatgatcagacgctaacttgttcttagagaaaaatacacgggatactctgt
+gcaacgatttcattaataaggtgcagcttgggacttttttggccgtaggctttattaaca
+ttcacagtaggtagcgagacttcctatgaaccaatcatgccacgcgttttaacgtttcaa
+atataagctaggaagcgtttgccaggacttctataatgcaccgttttttttagtacttcc
+ttactagccttagtttatgttagagtctttccaattacaaaggattgaatagccaaaatt
+tctacaattctcagcgaacgccagcttaatctaaacacgagcttcaaatattctacatat
+cggcaggagtcaatatataaatatgaaaatcgtaccatcctcgtacttttagaccaaacg
+tcttcggataattaaatcctttttcaattaccacagtacgtgcattagaactactgctat
+gaaagtaaaccttgaaatatagtcctcaagagcgtatccaagtacattgcacgtgtatac
+agtcgtataaacgagttgatgttctgacgctagagcttaccattcgttaaacagataact
+aaaatttaatggctgagtgacttagtgttttcgacaaacgtcgcggatgtagactattgt
+ttataagcaatttttaaaaacatatgttcaaaacggtatgggatatgtcgaattccacag
+gggtttatgtaccatagaagtatgtataaggtactaaaggtttaaatctgtgatattcgg
+ttcggtgaaaatcagactagtcacacttagtgtctgtaaattagattgggtgaaggtaag
+cgatcccgaactctacaaggcatgggatgagattctaccgactccggataacactttacg
+atcgcgcataactctagctcttagataagtttaacttgtcgatctcataaacagttcaaa
+atctgcgatttattgtatcaaatccatcctctatcttctataatcatctgaaccgcgata
+cggcactatgagccaagtgaagattgaatccaagaaagctataattggtttattttagtc
+catttaaattaagtccggtataagtgctctgtacaatatgcagtctcatgggcatatacg
+ttaactaccttttgatacttcgaattggtaaaatatcgactatcgatttgcagtaaaagg
+tgtagagtccaattactctttcctgttacatacgatctcttagtttggacaactagccca
+tgatggcgctcctctagcgcatgaacctactttataattacatctttatcgatgaatttt
+tttagactgcggaggccttgagttttaacagggctgctaaatttcttaagcgattagacg
+gtagcgtcgtacgctacttgcttggaacaggcaccgaaaatattgatctactattgcgtc
+aactctattctgctaatagcgatggcaaatcacagaagccctcttagtgacaatagttgt
+caactatatctaagtcgacctttactgtatcaacgatcacggagagaattaccgaatacg
+aaacctcaggactaaaaaacggaaaggatttgtcgacggtaaatataatacttgttaagg
+gtagcgacacaggtatactttgggtgtaaacgtggtgcttcccggaacgattttcagacc
+agaaaattgttccggtaaccaggaaatctcgtctgcgttaattcgtgttagtaaacttga
+tcttcagactccttcttttcgttgcagcgagacttaaattatatctgcgaaatagtgccc
+cgtgcatacttcagatggtaggagataccatttggcccattgtgactttacgcgattaat
+taaccgacatacatctgttcctgagctatgatcgtctgaataaattacggtctcctcttg
+atacctaatggtttctggagacgtttctcatgttcaaatggatagcaggagatcgcttca
+tcaagtttagctacgcagagcatcaaaatatgtatgggaaagtcgatttccaaaccagaa
+gggataaagagaaataacggacttctccgtagattagcctgatattttgatgggaatcat
+ggcggcacatacgtaagagttgcgtgaacgaatattttggacggcgggagacacatatcg
+gccattcgttaaggtctctatattggacatcacaagcttagcagtatgagctactaacac
+tcaagacattattgattttttcaagatatgtttcattcctctaccgctattcccatacgt
+tcgattcgccgggtgagcgaaaccacgggactgaggttaagctaatcaataacaactcgt
+tgcgatagagacctatgtatactagagagaattccccaacatttttacaaaaacaaagca
+gactaaaatagatacagtccctccatacaattaggaccaacatgttattgccgatcctag
+cacacacaccacaaactcagaacttctgtcttacctatgaaagggtctgcacttctgatt
+gtacgtgtctaattagcattaatattaaaactaattaggataaactataggtacgagctt
+tactataagtcactaggtgttttccgatcgaaaaacgggaccttcaagccttggtaagta
+catttaggataaagaaaaaaaggaaggtacgtgactaatctgtctaaactgacaatagag
+tagtacctacatgcttcatgtcaagtcttaatacgcaagcgctctcgttatactgctcaa
+caaaactcataaagttggactccatcatttagaatcatagggaccaaaacatttatttgc
+tactgtcactttgtaggtgttctattctgaattcctcatattgatacatgaatcggaata
+cctgtggatcccttaggacgcacgtgctttctttacgtcagaatacatattgtcagaatc
+gagaagttccatgcaattaagaattcgcctctttgaaaactcatatccccacatataggg
+tccaccgttattcggaaacgatataataattattccagcgttgagcgtcccttaagagcg
+cattttcgcttggcctttcttctacgactctacaacgcaagtggctgtgtggagtttacc
+acagcgcagcaccccatagaactacctctgagagcgcgagatggtggcagtatgctctgc
+agctagcgtttagaacgcgcccgcgcattaaccagtcatattaaaatggactgtcttaat
+tgtcggcattaggagcaatattaactgatgagggtatcggtcgcagaagtaatgacggaa
+atacgcctctagtccgcagagatacgattacagactcagatcccctaacaagcaaaacga
+ttaaatcggaatcactccccctatgacatatttgaaatacacaagaaaccacgcaacatg
+tcccgcattctcaaccgcgctttataagatgttgagtctgagaattagatgacctaactg
+caagaatcatggcgagtttatctagtaggcaagtctgtaccctagggttcgaacgctgtg
+acgtcgtgatcggtctaaggacttagatgataaccaagaactggtttaccgagtactttc
+actattaggagtaattacatgcgttcaccgcggaatacgacgaaattttttcatatcttt
+atgagcgagatcgtgtcgtctttgcattgcaacagtcgctaccagtaattgctgatcaat
+tatagattcattatacagatgcttacttttctctattcaatactgtcatgagttgttttt
+aaataagcaccagaattatgtcgcctagtataatcttgcttccacttgaatcaatgcgat
+ggacagtattctactgattgcaaagtagtctatttcggcttagcagtacgcatgcctatt
+tttttgcaggcacagaataatatgcaactaggattctcggcatccaattaacaggctaaa
+acaccaccgaaagacaggtaatctacgaagttgatgtttactacagaaagcgaatgatat
+cacttggagaacattttagatgcccccttttaatctagactgagtgtaccaatatatcac
+cggtctaccgaatcagcttgaataaaccactctagtactcatgataaccgagcatacaca
+tgtatttctcaatgcactgaaggtgaactgtttacaccataccttgcgaatcaacgtggc
+gacttatacttctgtctttgagtacagcacaccctaatgaatctaagttagttgttgata
+cgaattgtaatttgactggatctcgcctcctcatctagattcttagagaagatgtttctt
+atagccggtactgtaactttattgatctggtttatggtaatcaacattttacctctattt
+aaacgtccttgcgccgtgcactcaatcctgatcggtttagattcaagcgattatcgagtc
+tggaggccgagaaaagaaatgcacagagtaagctctctattgcgacatctacgtagaaac
+tcgcatttcagatcgagtaagcaactctcattgtgttgattcagtaatacaagattacct
+acgcttctacgaaatatactatagatttagcctacgtcacctttagtgtcgagtcggagc
+tttgaagatcggatgcggtgtggactgtgtataggcaattttgctgcgagctcgtgactt
+ttggttgatgtcgatatcaatgggatacctcaaacgtctttatctctggataactcacat
+tgagtataccggtaaaaatttattctattcatctaaatagtcagtgagggctagggtcgc
+aatcacattaggccacatacacatacttaacatgttctattgacccgacccaactttagt
+agcattgtagccgtttatgcaaatatgccaggcgccaaacactagccagagggcattttg
+ttacatttatttaatcgattattacacagtcggaacacgcctacatgcgttcgacttatt
+tgcgacatggtcaacaattcagtaatttaatccaaaacctaaagtcagagacatgacact
+aaaatcacattaaggtcagttagtgaaggaatggctaaccagctagagaatgcatcatta
+acaggcacttattgtcaaatattttccagatctaagcaacatcacgttaaaaagtacaac
+aatcacttaaaacacatcagtccaggtgtaattagaaagccgcttagtaggcaagcgtag
+gagtataaatgtagacaatagtcgggacttagcagacactggatgcagtcatagaagatc
+ttgcataacacgttagggttagagctacgaacgcccatcattaactgcctaaagcgtgcg
+tgagcttagcgctaacttttccaacacgtttgtgatttcgttcataatgtatcaatttca
+cagtcatatacagggagtgtagaaaaatcgcaattaacatacgttgacctatttttgttc
+agagttcagttagagcctaatgattcgagagcaataatcaggacagcctcataggaagtg
+tcaatcacttagaagctatattattataaatcgctctttactgtcgtcgaaggaacgagc
+gagagagaatcagttgcctgcaactggcttaacaatatgatacataaaaatattttcatc
+accactaagacggtggaattcagacttattggcaacttaggatgggactattaaataacc
+cataagatgttgggataaagttacgaaacgaaagggatatagcctgttagataggaaatc
+cccaataaaacatagccggcctccacagcagtgatctattccgccacgcgatatctttat
+accacgcaatataccaataataaaggttaaatgtggttgcgatttaaaaaagatacatat
+cagttgcaccgcgtagcaaatccgtatgtgaagcgtaacctagaattatagcgtctgcaa
+gttctctaagcttcctctgcaagatacaatatgactttttagcttttttactaccaaatc
+tcagaatcttagaaacaggttggtacgtgctactcggaattcccaaagtaccctgctata
+tatgccattccttcattggtccgggctcaccatggggccatcatagtaatagaaggtagt
+aaaactagttgatttccgacttttaacaatcactatcctgacccagatatgggttccgac
+tggcccttactccagtaagggcagacacacagacaacgagaacttgataactttgaattc
+tcaaatcgatcattgcaacgtgacttatttactagcctactcctataattcatacgtcaa
+atacatttcaacggaggaagataataagtaaatattcactaaataatggtcgaaggagtc
+ctttgccaacataagtccacatatgcgctatagattttttcttggggttcatattcaata
+agataaacagcaagagtatcacgtcagcgagtcattgagatcttggctagcattgtgata
+gcatattctacctaaatggtagtctagcacagagtggataagatatcagttagatataga
+caagtactataacagatctcgcttcgttggattgtatggctagctttgatgatatgattt
+tataaaaattgatccagacctgacctggccaattatattcattttttatgagtaaaaata
+gataaccatgaaaatactcaagccccttaggacgtacaaagtggtaacataaatttcagg
+tgttattctgcaaccacacctgttttgggttttcaaaaaggctaagcagattggttttac
+agataatccctgaacactggtatctcccaacgatgtcgttcccaacccttgctgaccttt
+taagctctgctgaagttttgtaaactaggcggaaaatatgttcgatagatccactcgcct
+gaggtagaaattcgtcttagtaacgcctctttggattacacagaatagtgtactgacacg
+tacactgctgcagcagccatacgctaacattaaaattcgttgagtctacatttgttgtta
+ttcggattatgttattgggaatagtatttttattcccctgcgtgaaaccacatggataga
+ttagcctactcctaaagactcccttttggtctacggttcaattctcttactgagtttatg
+ttcgtaattatatcggcgcagtgaatctcctaattatcaccggagttaccagacgccatg
+aacttatggccagaaacattgcatgtggcctacataggattagtatcaagagtttacgtt
+tgcaacgacatttgaccaacttgaccattcctgcttgtagaccgcgggaactcccctgca
+cgcgactatagaagttggtggtggatgtggcttatgccgcaaatatggttttgaaaaaag
+taatctattgcttgatacctgaattgagacatgtataagggctattgccagatgaaaaac
+tgcatataaggtcaaacaatataagaacattatacataggatcttagcgttcctcaggat
+ggtatacgctataaagtctagcttcagcagctaaggagttttgccagtgcggacttccgc
+tggaagattaggtttaaccgccctgacatcttcataaggtcgggcctgattcaaacccct
+ggagtgccgtctcatacttgaattaatcgatggaaaacttcttctagtctaatattatta
+ttaacaaatgacggttcaataaataacaccgtaagggtgggaaactgttaagtgatgaat
+cattttaacctatcatccattagctacagataatgataccccgatccgactagggggtaa
+gtggttgttccgttaggataaaccatgtaaaacgttagagggtttgtagattaattggta
+ttccagataaatgaggtcagggcgagtgatcaattacactgaaaaattgtcagcttgcgc
+ggtagttgttaagacagtataaatgaaggggattcagaagcaagtttctcgattgactga
+atttataaaccagtcgtcaatcatgatttttgtgtcgattaaagcctaaatggtaattta
+aaccattgatatttatcgagtctataaatatctttggttgtatattacttcacaatcacc
+aattctaaatgattcttccactgtgcgggtggagatatcaggacgggttaaggttgacct
+acatcgttttgatacaacaaaaatcaaagcacatggctggggacttctcgatactatctt
+tgagatagtacgggcaagagtgggtgacgcctccctacattttcaagtctatcggataac
+ttctcggtaaaacgctcgcgatatagttttaaagcattgatttaatccacgcaggagcaa
+gttttaccggtcgaatgagaaaattcaacgtaagtgtcatatccagtcatggttagccaa
+aagcatgggttatccaaaaggaataaaacagctcttcaacaaagagatgaggcttcataa
+cttcgatgaatgcgtatggttctgatatatagatcgatgcatgaggacactttattttag
+ccggcgaattaatggaatccatacgttacttatttggacatgacttctaggtgtttttgc
+tgtcccgtttagcgatatttacagattagtatttcgtttctcatagttaattgtatctag
+atactaactcgttgaagacgcataccttgccatttgtacaggacttaactgttccgtgcg
+taatttgaatttcttataggttcttcaaggcacgaatacctcactcatgaccgttcatac
+tctagttaaggtcgggaatactacgtatgcagggaattgtaacctaggagatttacaact
+ctttaaacaagagtcgctgaggtccaggatcaaaacactgaatctcctaacttcgggtgc
+ctccgtaaatcacctagaaacctactcatacatttgcaattttgagatgtaggcgaaaga
+gagaaatctgctttttaacggtatctcttgggattccttttaaaaacacataacgatagt
+aatgtaccaagtaaccaaaagctgggatgtgtctgtgtactgatccgccgtgtcagagta
+gtccgccatgaatattgacgtcaaggctagtgtcatcaggtattgatgttcattgtaaat
+gaaggaatgaactaatgtcaccaagtaaagggggtgaaaatgctccccagggttctacag
+acatagagatggtcagaacacgacccccctctcaacgcagtgtatttgaaatatatggac
+atatctaccttattctgtaattttagatgtgttctgtgtataccgatattgataagtcaa
+taggcttgattacgtatcttaagacaaatctgtttcgcaagtaggaccgcatctttcaga
+ttgtttctttttatgccataacctgcccaggaattcaaaaggttatcgatacccgatatg
+ctgtgaattattattctaatggccactcattcctgcttatatctggaattggcatgaata
+tcttacaacctaaagtctggcgttgcgccagttctacttcgtaccggacaccatctccag
+tcgttaaccgaaggtgggtacgtcacataaaagttcattagaccacactttgtgccgacg
+tatatagatatattacacgtatagggaatgttttctcctaggtgacccgaccttctacta
+aggttgtacatcgtataatggcccattaactacgaggaaagtggtattgacctggtaatg
+cacgttcttcgatatataccgacgaggtaaagtctactattgcaaagtttgacgttatac
+tgataagtttagatttccctggatcgcgcatgaacaatgtatgcgttatctgccatatat
+aacatgttacaaatccttggggatactatcgctactatcatcggaccaaaattaaatagg
+ctagtgtcttatcagaacatcatgtttaccgaactgatctattttccaatttaagctgat
+attacgtccgcgtatttattttagttccccggatgacgattatctgagctacatcataca
+agttagcatactcgccggtgcattgatttcttatttcgctatatcttcaagttcacaggc
+ttcatatagttccaattagcagtataattaggttttgtaactttaaccatactttataaa
+aggttatattgcacaactgatcaagcatccgctataacccgagctttaccagttagcggc
+taataacaaataagatgacttcgtgtcatacgaccgtcatgatcatgctctaacttaggt
+gggaaccaaatttaggcaatgggtagtaataagtataaaatgataccacatatactataa
+caatgaaattatttgtaatccggtttgccaacgtatcccccttcgcgataaattaatgac
+atagggtcatccatgtgccaatcgtgtgtgccaaaatctcaaattcaattatcatcaata
+ttggccaagtgttataagcgttgaaagtgatataggccgccaaaaagtagtctacttaaa
+aaccaatatttatcgttcgttattgctggtagtacaacatcacgagcatttctcttttga
+gttgatttatactatatctgctgatgtgattatgtcccacttacccagaatattaagaaa
+gtcctagattgtaggtatacttgactataaatataatttaagactatacaaataatctgg
+ctacattatgccatcgtagaaactgataacgtagtaacgtcggacactagattttggtcg
+gggagtaatctagcatactaacgaatttgttaaatccgctgaaagtatatgtcattacct
+gcttggcctgtcttcaatacgtttagactattaaggactcatttcgagatccagtattaa
+ttatacgcatccatatttatactgaagacggattgagttaggacgacaagctaaacaaat
+attaagttaaggattagtattatattgtagaaactcgtcgggttggaacgattcatcatc
+atagaatgcgttacttattcagagagacttaattcggttatgactggcagctcacctgga
+aagtaggtgaaaggcaacagaagaatattgttgactgaattctacgggctacgaacgtaa
+ttacaaagcggttcgtaaagagcataaagatcaatacaatggatctctacagtattacgt
+aaataacatacataaacctggtgttgattcgactagctcatagattaatcattaattgaa
+gctacgaagacgcggaagtctgcggagtgagcaaacagtaatcgactgataaatgcttat
+aatatcgcgcttaaatgccgcatggtgtacattaacgtgggggtagtcaaaggaatatat
+ttactaggaatattagttatgcaaatgttgtgtcaatgtgatgtgttttatccagacatt
+ggatgcatggctgtgggggcacaggatacttaccattagttcacctacaagcggcgtgag
+agggtctcagttttagccagcgcagagaagtacgggcctttagacgattaatgctagaat
+tgtcataaacctcgtgaaaagctagttaataatcatggtgctagaagaacacaacttttc
+tataaaccagttctcgactgacagtcgtaactcactatatcgccgctttgtactgtcgca
+aaaaaacctcacatagaaagaaaaatctactgggtgcatcagtagagatcgtgttctgag
+agataaatacaccggatacgatctgcatcgagttcatgtattaggtcaagcttgggactg
+ttgtgccagtagcattttttaacagtcaaagtagggtgagacacgtcatatcataatata
+tgccatcgaggtttaaagtttatatgataagctagcatgcgttgcaatcgtattcttgaa
+tgctccgtggtttgtactaattcctttatagactgagtgtatcgtacactcggtacaatt
+acaaaggatggaagagcaaataggtcttcaattataacagtaccccaccttaatctaaaa
+accagcttcaattagtattaatttcgccaggagtatatatataaatatctaaagactaaa
+agactcgtacttttacaacttacgtcgtagcataattaaatcatgggtaaatgtcatcag
+taagtgcattagaaatactcctttgtaaggatacagtgaatgtgtctcagcaagtcagta
+gaaatggaaattcatactcgattaaggcctataaaactgttgttggtatctacagagtga
+ttaaaattagtgaatcagattacgaaaatgttttcccgctcgcacttacgcgtttagaca
+aaagtacaggtggtacaattggctgtagtagaattttggtataaaataggtgataaaccg
+gatgggtgtgggcgaattcaaaagcggtttttgttccatagaactatgtagttggttata
+aaggttgtaatctcggagattaggttagggcttaatcagaatagtaacaatttctctatg
+taaagtacagtgggtgatcgtatgagttcacgaactcttaatgccatgcctggacaggat
+aaacaatacgcatataacttgacgatcgagcttatatcgacctatttgagaagtttaacg
+ggtcgatataatatacaggtcttaatagccgattttttctagaaaagcaatcctatatct
+tagttaatcagatcaaccccgtgaacgatatatcagcaaactgaacattgtatacaacat
+tcctttttgtccgggtggggactccatttaaagtatctcacctagaactcagcggtaata
+gatgcagtctcttgcccagttacggtaactaaatgttgatacttagaattgctaaatttt
+agtctagacatttccaggtaaaccggtagacgacaatttctctgtcatctgtcataagat
+cgcttagtgtgctcaaattgcaattgagggccctactatagacaatcatcagacttttta
+attaaatagttttccatgaatgtgttgtcaaggcggaccccttcacttttatcacggctc
+ataaatgtcgtatgactgtagtcggtagcggccttcgagtcttcaggggaaatggaaaag
+aaattaggcttctaagatggactataatcgattaggctaattccgttcgcaaatcacaga
+agcaatcttactcaaaattgttggaatcgatagcgaacgcgaccgtgaatgtttaaaagt
+gctcgcacagaattacccaatacctatcatcacgacttaaatacccaaagcagttgtagt
+cgcgtaatagattaagtctgaagcctagagacaaagggatactgggcggggaaacctgct
+ccttcacggtaacatggtaacaacagaatttggttaaggttaaaacgaaatatactcgga
+gtgaattactgttaggtttcgtcatcggatcaataagtagtttccgtgaagacactctta
+tattagatctccgaaattctgacccgtgcattaggcacttggtaggagattccatttgga
+acttgctcaatgtaagccagtaatgttccgaaataattcgctgcaggagcgaggagccgc
+tgaataaaggaccctcgcatcttgttaccttatggttgagggtcaccgttctctgcgtca
+attccagagctggagatacattcatcaacgttacctacgcacagaataaaaagatcgagc
+gctaactcgttttcctaaacacaacggatttagacaaattaccgaatgcgccggagagta
+gcatcttagtgtcatgcctatcatggcggctcagtacgaagagttcaggcatcgaatatt
+gtggtagcccgcactcaaagttccgccattaggtaagctatatattgtggtcagaacttg
+aggacaactatgagctactaaaaataaacaattttgtcatttgttctagatatgtggcat
+tcatcgaacgcttgtaccagaagttacattcgcagcgtgagcgaataaacccgaatgagc
+gtaacattatcaataacatatagttcagatagagaacgaggtattcgacagagaattacc
+caacattggttattaatctatgcagaataatttagataatgtcactacataatattagga
+ccaaaaggtgattccccagaagacaaaacaataaacaatctcacatattcgctagtacct
+atgtatgggtatgatcttctgattggacggggataatttccaggtatattaaaacttatt
+accataatctagacctaagagaggttatataagtaaagagctgtgttccgatagaaaaac
+ccgaccttaaagacttgcgaagtaaattttgctttaacaaaaaaacctacgtaagggaat
+attctgtataaactgaaaagtcaggtgtaactacatgagtcatgtcttcgattaattaca
+atgcgatctcgttattctgatcaactaatatcataaactgccactacatcttgtacaatc
+attcgcaacaatacttttatgtgctaaggtcacgtgcttcctctgctatgctgatttaat
+cagattcataaaggaatacgaataactctggatccattaccacgcaagggatttatttac
+ggctgattactttttggctgttgacagaactgccatgaaagtaagatgtcgcatcttgca
+taaataatagcacctaatatagccgacaaagtgattccgataacagattttaagttgtcc
+agccttgagactccatgaagaccgcttgggagcttccccgtgattagaagaatctaaatc
+ccaagtggatggggggagtttaaatctcagcaccaacaaatagtacttcctctcagagcg
+cgtcatggtcgaaggagcctatcctgatagaggtttgaaagcgcacgcgcatttaactgt
+catattaaattggaatctcgtaagtgtcggcagtacgacaaattttaactgatgtcggta
+tacggagaagaaggaagcacgcattgaagcagctacgcagaactgagaagatgacactct
+aagatacaattaatacaaaaacgttttaagcccaatctatcaacagatgtaagatgtcta
+atacacaagaataaaaccttcatgtcccgatgtataataacagctttatttctgctggtc
+gaggtgaagtagtggaaattactccatcttgctgcgcgtctttatagtgttggctactct
+gtaaccgacgcgtccatccctctctcctagtgatccgtatatccaattagaggataacca
+acatctgcgttaccgacgaatttaaatttttcgactatttaattccgttcaaacccgtat
+tcgtagtaagtgtttcatagatttatgaccgacatcgtgtacgagttgcagtgcatatgt
+agataccactaattgctgatctaggatacatgctttataaacatgcttacttggctattt
+tatttactgtcatgtgggggtttttattttcaacaagtatgtgctaccattggataatct
+ggcttcaaattgaagatatgcgttccaaacttgtctactgtttgctaagtaggagttgtc
+ccattagaactacgcagcacgtggtttgtgatcgaaaagaataattggcaaatacgaggc
+tagccttcaaatttaatgcagattactcctcagaaacacacgtaagcgacgaacgtgatg
+tttactacacaatgcgtatcatagaaattcgtgataatttttgttccaacctttgaatct
+agactgagtggaaaaagatttcaccgggataccgtttatgctggttttaaaaactcgtcg
+aatcatcttataactgcattcaaatggatttctcaatcatctgtacgtcaactgttttaa
+caataacgtcagaataaaccggcacaatgagacggcggtctttcactacaccacaccctt
+aggattataagtgacgtgtggattcgaattctaaggtgacgggatctacaagcctcagct
+acattaggtctgaagatctttcgtatagccgcgtatgttactgtttggatatgggttatg
+ctaatcaacagttgacagcgagtgaaacggccttgcgacctgaaatctttacggttacct
+tttgattcaagacaggatcgacgatggaccacgtgaaatgaattcaaaactgtaacatcg
+cttgtgcctcagcgaccgagtaacgacaagttcacatcctctatgcaactatcattgtgg
+tcattaaggtattcaagattaactaagagtcgaccatatattctagagttttacaattag
+gaaccgttagtctagactaggagcgtgcaacatcgcaggaggtgtggactgtcttgaccc
+aagttgcctgacacatagtgtcttttgcttcatgtccttagcaatgcgatacctcaatcg
+tagttttatcgggataaataacatggtgtttaaccctattaatggtttctattaatctaa
+attgtaaggcagcccttgggtcgaaagcacattaggccacatacacagtatgaaattgtt
+cgagtgtccagaccataattgactaccatggtacacggtgttgctattatgactcccgca
+aaactcttgacagagggaattttggtacattgatgtaatcgatgatttaacagtaggaac
+tagacgtcatccgttagactgagttccgacatgctcaaattgtcaggatttttatccaat
+aactaatggctctcacatgtaaataaaatcacattaacgtcacttagtgatggattcgct
+aaacagatagactatcattcatgaactggcactgtttcgattatatttgcaacatcgaac
+atacttaaagttaaatacgacatcattcaattaaaaaaattcagtacacctctaatgagt
+atcccgctttggaggaaagagtagcactttaaatggacaatttaggccggactttcctgt
+aaatggatgaagtcattgtacagcttgaataaatcgttagggttagtccttacatccacc
+atatgttaatgaataaagcctgagggaccttagagctaacttgtccaacacgttgctcat
+ttacttaataaggttgaaatgtatcagtaagtgacagcgagtgtagattttgaccattta
+actgaccttcacagttttgtcttcagacgtcacttacaccataatgatgacagagcttgt
+agatgcacacactcattcctagtgtaaatcaagtagtagctagattattataaagagata
+ttttctggcgtcgaacgtaacacagagagagtataaggggcatgataatggcttatcaat
+atgtgtaagaaaaagtttttaatatcatctaactcggtggaatgcacacttatggccaac
+tgaccttgggacgagttaagataccataagaggttgcctgtaagttaagataacaaaggg
+atattccatctttgtgtgctaagaacctatttatatttgcagccataaaaacctctgtgc
+tatgcagccaccagagttatttatacaaagaaagagaccatttagatacgttaattctgc
+ttgcgatttattaaacagacatttcacgtccaaccactacaaaagccctatcgcaagacg
+atcattgtattatagcctatgcaacgtagctaagcggccgaggaatcataaaatatgaat
+tgttacattgtttactacatatgatcacaatctttgtaaaaggttcgttcgtgatactac
+catgtacctaactaacctgagatatatgcaatgacttatggggtcagcgcgcaacatccg
+caaagcatagtaatacaaggtaggaaaacttctggatttcccaaggttataatgctctat
+actgaccaagagatccgttacgactcgcaatgaatactctaagggcactcacaaagaaaa
+ccactaattgataaatttcaatgataatatcctgaattgcatcgtgtatgagttacgaga
+agtcgcatttaatgaattagtcatagaaatgtcatagcaggaacataattactatatttt
+aacgatttaatcgtagttggagtcctttcccaaattatgtcatcagttccgatttagatg
+ttttcgggcccttcttagtaaagaagttaatatccaagactagctcctcacccacgcatg
+cacatattcgcgagaagtctgatagaatattcgacagaaatgcgactctagctcacactc
+gttaactgatcaggtacttatagacaagtacgttatcagatatcgcttcggggcattgtt
+gcgctacctttgtgcatagcagttttgaaaaattgttcaagacctgaacgggaaaatgat
+attatttttttaggaggaataatacagtaccatgtaaatactcaaccaccttacgtactt
+cttacgccgaacatatatggcacgtgttattcggctaacaaaactgttgtgccttttcta
+taaggataagcagattcgttttaaacatatgacctgtaaactgggatctacaaaagaggt
+acttaaaataaattgcgcaacggtttagatctgcggatctttggttaaagagcaccatta
+gatgtgccatacttcctatcgcctgagcgagaatttagtctgaggaaccactcttgggat
+ttaaaacaattcggttaggacacctactcggcggatgaagcaatacgataacattaaaag
+tcgttcagtctaattttggtcgtagtacgatgagctgatggccaattgtatttttattaa
+cagcactgaaacaaaatggagactttagactaatactaaagtctcaatgttcgtcgaacc
+ttaaatgctcggaatgaggggatcttcggaagtatagcgccgaagtgtatctcattatta
+taacaccagtgtacagacgacatctaattatggccagaaactgtcattgtgccattaaga
+ggattagtagatagtctggaccgtggaatagaattttgaccaaattgaccagtcctgctt
+gtagacagcgcgatctaaactgcacgagaatatacaagttggtggtgcttgtggctgagc
+acgctaagatgcgtttgtttttacgattctagtgcttcttaacgcaattcagtcttctag
+atccgctattccaacatcaatatctcaatttaaggtcaatatatataacaaaattagaca
+gagcagctgacacttacgaagcatcgtagaaccgatatagtcgaccttatgatgatatgg
+acgtgtccaagtccgcacttccgatgcatcttgacggtgaaccgaaatgaaatcttcatt
+agggcccccatgtgtcaaaccactcgagtcccgtctctgaagtcaagtattactgcgaaa
+aattcgtctactattagtttattatgaacttatgacgcttaaataaattaaacagtaagc
+ctgggaaaatgttaaggcaggaatctttgtaacagttcataatgttgctaaagattatca
+gaccccgtgaagacttcgggctttgggcttcgtaccgtagcataatacatctatatagtt
+agaggcttgcgtgttgttgtgctattccacatatagcagctctgggcgactcttcaatga
+aaatgaaaaatggtaacctggcgacctacttgttaagtcagtttaattcaaggggattaa
+gtaccaagggtcgagtttctctgtatttattatactgtaggcaagaagcttttttggcga
+gatttaagacttaagcctatggtaaaaatttgatagtgagcgactatagtaagagatttg
+ggtggttagtaattaaaattctcctatgctaaatcaggcgtacaatctgagggtgcacat
+ttctcgacgcgtgaaccttcaccgaaagcgtgtggattatacaaatttcaaacatattgg
+cggggcacttatccataatagatttctgtttgtacgccaaactctgcctcacccctccat
+aaattgtattggctagaggttaaattctccgtaaatagagacacatatagttttatacaa
+ttgtttgaatcaaagcacgagaaacttttaaccgtacattgacaaatgtcttcggatggg
+gcagagcatctcttcgtgacccaaatcaatcgctgagcaataagcaagaaaacacagatt
+atacaaagagatctggatgaagatattcgtgcaatcactatcgttatgttagagagttcc
+atgcatgaggactcgttttttgaccaggagaattaagccaagaaataactgacgtatttc
+caaatgaattctacgtgtttttcctgtcacctttagccagtgttaaagatgactatggag
+tttcgaataggttattctatagacattataacgagtggaacacccataccttcacagtgc
+taaaggtaggaacgggtacgtcaggtagttcaagggattttaggttcttaatccaacgaa
+gaaataacgcatcacccgtcattctattgttttcgtcgggattacttagtaggcagggta
+ttctaacctacctgagttacaaatctttaaaaaactggccatgaggtcatggtgataaaa
+tctgaatcgcctaaattcgcgtccctaaggaaatatactagaatccgtctcagaaagtgc
+aaaggttgacttcttcccctaacacagaattctcagttttatagctatctagtggcattc
+ctttttataaaactttacgtttgtaagggtccaactttacaaaagctcggatgtgtatgt
+gtaatcttccgccgtgtaagacttggaacccatgtatattgacggcatggcgtggctaag
+caggtattgatcttcagtgtaaagcaaggtatgttctaatctaacaatgtaaagccgggg
+attagccgccaaaggggtctaatgacatagagatgctctgaaatcgtaccaactataaaa
+gcacgggatttgaaatatagcgacagatcttccgtattctgttagttgacatctgtgctg
+tctttaccgattgtgatttggctttagcagtcatttagtttcgttactcattgctcgtgc
+gatagttccaccgaatatggcacattcgttctttttttccattttactgcaaaccttttc
+aaaagctgatcgataccactgatgatggcattgattagtcgattggcaactatgtcctgc
+ttatatctccaattgcattgaatatagtaaaaaataaaggctcgccttcccaatgggcta
+cggagtacacgaaaaaatcgcaactcgtttaaccaagcgccgtacctaacatataagtga
+ttgagacaaatagttctccagacgtattgagatatatgtctcctataggcaagcgtttct
+aattgctgaccagaaattagaattaggttgttaatactatattcgaccattttattccac
+gaatgtgctattctactggtattgctccgtatgcgatatataaccaacacggaaagtcgt
+cgattgcaaagtggctccgtagaatcatttctggtcatttaccgggagcgcgcttgaaca
+atggatgcggtatctgccatattgttattgttaaaaagacttccgcttactatcgcttcg
+atcatcggaaaaatattaatgaggattgggtcgtataagaaaatcatcttttcagttcgc
+agatttttgccaatttaaccggttatttcgtcagacttggtagtgtagttacaagcatca
+cgattatatcagctacagaattaaactgtcctgactcgacggggcagtgtgtgagtattg
+cgctatatattcaaggtaacaggaggcatataggtcatagtacaaggataatgaggtttg
+ctaactttaaaaattattgatttaacggttgattgaaaatctctgcaagatgacgctaga
+acacctgatgttcaagtttgccgataataacatataagatgaattactgtctttagaccc
+tcatgttaatccgctaacttagggcggaaacaatgttaggctatgcggagtaagtactat
+attatgataccacatagaatttaacattcatatgatgtctaatacccgttcccaaccttg
+caaccgtcccgattaattaagcaattacggtcatcaatgggccaatcctgtctcaaaaat
+tatcatattcaaggttcagctattttggcaatgggtgagtaccgttcttagtgatttacg
+aacccataatctaggcgacttaatatacaagatttagagttacgttttccgggtagtaca
+tattaacgaccatggatcgggtgaggtgttgtattagttatctgatcttgtcagtagctc
+ccaatgtcccagaatattatgtttctactagagtgttcgtatactggaatttaaatatta
+tgtaagactagacaaattttatggatacattaggccatcgtagaatatgatatagttgta
+acgtccctctatagattttcggagggcaggtatattgcttaataaagatgttcggaaatc
+agcggaaaggatttgtaattaactgatgcgcagcgcttaaataagtttagactattaagc
+tatatgttcgacagcatgtagttttttttaccagaaagtgttatactgatgacccatgga
+ggtagctcctcatgataaaaatattgttacttaagcattactattatagtgttcaaacta
+gtaccgttgcatactttaagaatcagacatggcgtttcttatgcagacacacttttttag
+ctgttgacgcccacctcacatccatagtaggtcaatcgcataagaacaatattctggact
+gttttattacccagaagaaagttttttctttccggttcgttaagacaataaagatcattt
+cattcgttctcttaacgatgaactaaagtacttaaagtatccgcctcttgtttcgactag
+cgcatagtgtaataattaaggcaagataagaagaacaggaacgcgcacgtcggagataac
+tctaatagtctctttattccgtttaatatagcccgtaattgcaccatgcgctacagtaac
+ggccgccttcgcaaacctatttatgtaattccaagtttaggtatgcaatggttggggcaa
+tgtgaggggttttatcaagactttcgttgcttcgcggggggcgcaaagcagactttacag
+tagttaaccgaaaaccgcagggagtcgctctaagtgttaccaacccctcactactacgcg
+aaggtactcgattattccttgaatgggctgaaacatcgtgattagcgtcttatgattcag
+gctgatagaagaaaacttattttctatattccacgtatacaatcacactcgtaactaaat
+agttcccagcgttgtaatgtcgctataataaataaaatacaaagaaaattcgtctgggtg
+cataagtacagttagtcgtctgtcacataaataatccgcagtcgatctcattacaggtat
+tgttgttggtcaaccttcgcaaggtggtccaagtagcattgttgaacagtaaaactaccg
+tcacacaaggaatatcataatagatgccatacacggttttacttgatatgtttacagtcc
+ttgagttgcaatcgtagtattgtttcatccggggtgtgtacgaagtaatttagacaaggt
+gtgtagcggtcactaggtaaaatgacttaggatggatgagcatttaggtattctatgata
+acactaaccatcatgtttctaaaatcctcaggaaatttgtattattttaccaacctgtat
+ttatagaaagtgcttttgacttaaagaagccgaagtgttcaaattaaggagtacctgatt
+gaaagaatggggaattgtaatctgtaactcaattacaaataagccgttctaaggattaag
+gctttgtgtctaagcaactcacgtgaattcgaaattcatactcgattaacgactttaata
+ctcttctgcgtatctacagactcatttaaattacggaatatgttttcgtttttggtttcc
+agctcgcacgtacgcgtttacaaataaggacacctggtacaattggctggagtacaatgt
+tggtttttatttgctgattatcccgatccctgtgggcgttggcataaccgggttttcttc
+aagactactttcgtgttgcttatatacctggtaatatcggtgagtagcttagggcttaat
+cacaatactaacaagttctctatggattggacagggcggcatccgttgactgaacgatct
+attaatccattccctgcactggataaacaagacccatttaaattgaccatagagatgtta
+gcgtcatatttctgttcgtgatagggtacatatattataaacggattatgagcagtggtt
+ttctagaaaagcattcatagttaggagtgtatcagatcataccactgaaccatagagcac
+aattctctactggctatacttcattcctttttgtccgggtggggacgaaatttaaaggtt
+ctaacctagaacgcagagcgaattgatcaaggcgctggccaagtgaacggttctaaatgt
+tcttaatgagaattgcgtattttgactattgacagggcatcgtaaaccgctactcgactt
+ggtatctgtaatctgtatgtagatagagtacgggcctataattcaaattcagccaccgaa
+gattcacaatcttcagacgtttgaaggaaagaggtttactggtatgtggtgtcaagcccc
+acccattctctgttatatccgagcattaatgtagtttcactgtactacggtcacgccgta
+gagtcggcagggcaaatccaaaacaatttaggctgagaagtggcactataatagtttagc
+ctaagtcccttcgctaataactcaacaaagatgacgcaaaagtcggcgaatagattgcgt
+tcgcgtaagggtatcttgaatactgatagctctcatggtaccaagaactttcataacctc
+tttatttaccaaacctgttctactagcgttagtgttttagtctgtagccgacacaaaaac
+cgagaatggccggcgtaaccggcgcctgcaagctaacatgggatcaaaactattggctta
+acgtttaatcgaatgagactagcactgtattactctttcgtttcggcagcggatcaataa
+ggaggtgacggcatcactctcttatagtagatatcacttattctcacaacggaagtagga
+tcttccgtcctcattaaatttgcaactggctcaatgtaacactgtaatgttaacaaagta
+tgagctgaaggtcagagcagacgatgtagtaaggtccctcgaagctgcttacagtatcct
+tgaggctcaacgggctatgcggaaattccagacctcgagttacattatgaaacgtgtcat
+tccatctcattaaatagttcgtgccctatcgccttgtaatataaacaaccgtttttgtct
+attttcccaaggagaaggagagtagcagcttagtggcttgcctatatggccccctaagta
+cgtactcggcacgcttagaagattgggctaccccgcactatatgttcccaaagtaggtaa
+cctagatagtgtcgtatgaaattcaggtcatcgatgagagtataaaaatatacaattttg
+gcaggggttatacattgcgggcatgaagagtaacattggacatgaacggacattcgaacc
+ctgtgagtttaataccctatctccggatcattataaagtaaatatacgtcacttactcta
+cgtgcgtttagacagtctttgaaactaaattggttatttttctttcatctagatttgtct
+gtatctaactaaattatagttccacataaagctgattcaactgaagacataaatataaac
+tttctaacatagtagcgaggaaagagctatgcctagcatcggatcatgcgtccgcgagta
+gttcctggtagagttaaaagtttttccagaatctagaccgaacacagggtagtgaacgaa
+agtgcgcggtgaacatacataataccgaacgtaaacaattccgttcgtattgttgctgta
+tctatatttcctacgtaaggctatttgatctataatatgaaaagtcacgtcgaaataaat
+caggaagcgcttcgagtatgtacattcagatctccttagtatcatcaaattatagatttt
+acggccacgaattattggtctagatgtcccaaaaataatttgatgtcagtagcgatcgtg
+cttcctcggagttgaggttggaagaagagtcattatgctataccaagaactctccatcca
+gtacctagaaaggcaggtatgtaccgctcattaattttgcgatcttgacagatctgcatg
+caaagtaacttgtaccagatggcttttataatagaaactaagtttcccgaataacggtgt
+acgataacagatttttaggtgtacagacgtctgactcaatgaacacacattgggacctgc
+cccgggaggagtagtagataattaccttctccagcgcgggtcttttaatatcacaacata
+aaaatactaattaatatcacacaccctcatcctcgatggagcctagcatcatacacgttt
+gatagacaacgccaattttactgtaatatgatattcgaatctagtatgtggacgctgtac
+cacattgtttaaaggagctccctttaccgacatgaacgaagcaagctttgtacaagatac
+gaagaactcagtactggtaactataagagacaatttatacataaaagtgttaagaccatt
+atataaaaagaggtatgaggtctttgtaactacaataatacattcatcgaacgatggaga
+ataacagagttatttctgctgctcgagctctagttctgctaatttctcaatcttgatgcc
+actcgtttgagtcttccattcgctcttaacgacgcgtacatccctctctcctactcttac
+ctatatcctattactggttaacctacatctccgggaaagacgtaggtaaagtggtccacg
+attgtattcacttataacacctagtagtactatgtgttgctgagagtgaggacacactta
+ctctacgagttcaagtccatatggacattacactttttcagcatctaggtgtcatgatgt
+attaacagccgttaggggctatttgattttatcgattgtcggcgtgtgtattttcaacaa
+ctaggtgctacaattcgtgaataggcatgaaaattcaagattgcagttcctatcttgtat
+aatctttcctttggacgagttgtaccatttcaactaacctgcaagtggggggtcatccat
+atgaagatttgccaaatacctggagaccctgaaaagtttatccagattaataataacaaa
+caaacctaagcgaagaacgtcagctttaataaactatcactatcatagaaattcctgtta
+attgttcttccaaacgttgaatagactatcacgggtaatagattgaacacggagaacgtt
+tatccggcttgtaaaatatcgtcgaatctgctgataactcaattatattcgatggagaat
+tcatatctaccgcttagcttttaaaaattaagtcagattattccgccacaatgagaaggc
+gcgagtgcactaatcaaatcacttaggattattacggacgtctgcattacaatgctttgg
+ggtagggttatacaagcatatgattctttaggtctcttgatcgggcgtttaccaccgtag
+cttaatgttggcatatccgtgatcctaatattctgttgtcagcgtgtgtataggaatgca
+caacgcaaatctttaagctgacctgttcatgaaagacaggagacacgaggcaccacctca
+attctatgcaaaactctaacatagcgtggcactatgagtacgtgtaacgacaaggtctca
+tactcgatcctaagataattctcgtctggaaggttttaatctttaactaagagtagaact
+tagtttattgacttttacaattaggatacggttcgcgactctaccacagggcatcatacc
+tggagctctgctatctcgtgaccaaagtggcagcacacatagggtcgggtcctgcatcta
+ctgagcaatccctttaagcattcctagtttgagagccatttagatattgctgtttaaacc
+gattaatggtttctattattataaagtgtaacgctcccattcgggacattgaaaattagc
+aataagacaatgtatgatattcggcgagtctcaacaacattatggtctaccatgggacaa
+ggggttgatatgatgaatccacaaaaaatagtcaaacacccatggttcgttaagtgaggg
+tatccaggtgttataaggacgatctagaagtattcaggtacacggtgttcagacatgctc
+taattgtcaggttgtttataatttaacgtatcgctctctattctaaataatataaaatta
+accgctcgtagggatgctttccagtaaaagatacactatcattaaggttatgcaaatgtg
+gcgatttgatttgaatcttagtacattcttaaacttaaatacgtattatttaaagtaaat
+atattatctaaaccgcttttgtctatccacatttcgtcgaatcacgacctcgttaatgcg
+acaatttacgaccctctttcatctaaagcgatcatctatttcttctgattgatgtaatac
+tgacccttactccgtacatacaaatgatggtaagcaagaatgactgacgctcctgtcacc
+tttcgtggcaatcaactggcgctggtactgaagtagcttgaaagggatatggatgtgtat
+gccaggcttcattttgacaatttttctgtcctgctcagtgttgtctgaagtcgtatcgta
+cacaataatgatgactctcattgtagatccaatcacgctttcctacgctaatgaaagttc
+tagatagtgtaggtgttagacagaggttagcgcctacatccttacacacacagtgttgaa
+cggcaagcataatcgagtatcaatagctgtatgtatttgtttggaatatcatatttctcc
+cgcctttgaacaatgatgccaaaatgtcctgccctagagttatgataaaataactgctgc
+cctgtaacttaagtttacaaaccgatattcaatcgttgtgtcctatgaaaatatttatat
+ttgcaccaagaaaatcatctgtgcgatgaacaaaacacagtgatttataaatacaaagag
+tacatttagttaccggattgcggcttgacatttattttacagaattttatcggcaaaaca
+cttcatatgaactatcgcttcacgataagtctatgatagactagcattcgtagagaacag
+gaagagcaatcattatatatgaagtgttacagtgggtactacatatgagatcattaggtc
+tatatccggccttcctcataagaccttggaaatatcttacatcagagatatcaaaggaag
+tatgggcgaacccagaaaaagccccaaagaatagtaattcatcggacgtaatagtctggt
+tttaactaggggttattgatatttaagctaaaagagttccctgaacactcgaaatgtata
+atctatcccaactaaaaaagtatacctctaattcagaaatgtcattgagattagactgat
+gtcaatacgctaggaggtaagacaagtagaagtttttgatttaggaattgaaatgtaata
+cctccatcttaagttctatattttaaagttttatgcggacttcgagtaagtgcacaaatg
+atggcataagtgcccagttacatgtttgcggccccgtatgagtaatgatctgtttatcaa
+tctctagctactatcccacgaatgcactgatgccagtcatggcgcttacattagtcgaca
+gaaatccgacgatacctatcacgcgtgaactgttctggttcttattcaattcgaagtgat
+ctcagatacattacggccatgcttgcccttcatgtctgctgagcagttttgttataggct
+gaatctcctctaagcgaaattgataggatttttggtggtcgatttagtctgtacctgctt
+attaagattcaaaatgacctacttcttacgccgaaatgatagggatcggctgaggaggat
+aaatatacgctggtgcctggtatttatccagaacaagttgcctgtgtatcagatgaactc
+taatctccgagataaaaaacaggtacgtaaaataaaggccgcaaagggttacatctcagg
+atcgtggcgtatagtccaccattagttctgacttacttaatatagactgaccgagattgt
+agtatgtggatccaagcttgccatgtaaaacatgtcggttagcaaaacgtataggagcat
+gatcaaagaagagttaattaatagtactgcactataattgtcggcggagtaccatgagct
+gttgcccaattcgatgtttattaacagcacgcataaaaaatccagacttttcaattagaa
+ttaactataaatggtccgcgaaccttaaatgatcggaaggacgggatctgccgttgtata
+gaccccaactctatctaatttttataacacctctgtaatcaacaaatcttattatgccat
+cattatgtcattcgccaagtaagtccagttcgagattctctggaccgtgcaatagtattg
+tcaaattatggtaatggaatccttcttctaacacccttagaaaagccacgagaattgaca
+agttgggcgtgcttgtccaggagcaacataagtgccgtttctttttacgatgatagggat
+tcttaaagcttttctctattctagatcccagttgccatcatcaatatctcaattgatgct
+cattatatagttcttatttagtatgtccagatgtcactgaagatcctgcctagaaccgat
+attctcgacaggatcatcagttcgacggggcaaacgcacctatgcacatccatcttgacc
+gtgaaacgaaaggaaagagtcagtaccgacccaatgtggaaaaaaactcctgtccacgat
+atgtaggcaagttttactgcctttaattagtagtcgattagtgtagtttgatattatcta
+ccttatagaatgtaaacagtaacccggccttaatggtttggcaggattctttgtaaaagt
+taataatgttcataaactttatcagaaaacctgaagtagtccgcctttcgcctgcgtaac
+gttgcagattaattcgttttacggagtggcttgcgtcttgttgtccgagtacacatattg
+ctcctctcccccactcttctaggaaaatcaattatgctaacctgcagaccttcttcttta
+ctatctttaatgcatgcccagtatgttcatagggtagacttgctatctattttgtataat
+ctacgaatgatgcttggggcgcgacttttaacaattaagccgttgggtataatttgagag
+ggtgccacgatagtaagagatttccggcgtgagtaaggaaaatgataataggattaagca
+ggcgtaatagctcaccctcctcagttctccaaccctgaaccggctaagtatgactgtgca
+gtattaattttgaatacatattgcagcccctaggatacattatagatgtctctttcttac
+ccaaactcgcccgcaccaagaaagaatgtggattcgattgaggttaaattagccggaatt
+acagacacagattcttgtttacaattgtgggaagaaaaccacctcaaacgttgaaaccta
+cattcacaaatggattacgttggggatgagaatcgattccggtcaaaaatcatgcccgga
+gcaataaccaagaattcacagaggattaatacacttctccatgaagataggactgcttgc
+actatccttatctttgtgtcttccttcaagcaccaatcgtttggggacaaccacaattat
+gccaagaaataacggaaggtgttccaaatctatgagtccgcggtttcatcgcaacgtttc
+actgtgggtatcatgactttggactttagatttgggtattctagagactgtagaaagact
+gcaacaacaagacattcacagggcgaaacctaggaaaggggaccgcacgttgtgctaggg
+atgtttccttaggaatccatacatgtaagaaagaatcaaccgtaattatagtgttttcgg
+ccccttgaattacgtgcatgcctttgctaaaagacctctgggaaatagattgaatattct
+ggacagcagcgaatcctgattatatctcaagcgaatatatgacccgcaagaaggatttat
+actagaataagtctaagaaagggcattgggtcacttcttccactaacacacttttatcag
+ttttataccttgagagtcccatgcatttttatatatatttaactttcgttgcgtaaaact
+ttaaatatgatccgtgctctatctctaatctgaacaacggtatcacgtcgaacaaatcta
+gtggctacgaatcgcgtcgctaagaacggtttcttctgctggcgttagctacgtatcttc
+tatgctaaaaatgtatagccccgcattagcagcaaaaccgggagaatcaaatacacatcc
+gatgaaatcgtaacaaagataaaacaacgcgatttctatgtttgccaaagtgattaagtt
+gtatcgtaggggtcagcgctgatgtcttttcagtttgggttttggatttaccagtctttt
+agtttcggtactatttgatcgggacattcgtccaaacatgatggctcattcgttcttttt
+ttcaattttaatcaaaaccttgtatttacctgatacattaaactgagcatcgcatggagg
+tggagattcccatatatgtaatcatttgatatcctattccattctttttagttataaata
+aacgctccactgcacaatgggagtaggacttcaccaataattagcatctactgtaaacaa
+gcgccgtaacgaaatgattactgattgagaaaaataggtctcaacaacttttgacagata
+tgtatccgatacccaagcgttgctaattgcgcaaaagtaagtagaattacggtcgtatta
+cttgttgccaaatggttattactccaatgggctattctaatccgatggatacgtaggaga
+gagtgtacctacaccgaaactcgtagtgggcttagtggctacgtagaagctgttcgggtc
+agttacagcgtgcgaccttgtaaaatcgatcacggtgatgaattattgttattgtttaaa
+agaagtcccctgaatagcccttagataatacgaaaatttgttatgtccagtcgctcgtat
+atcaaaagattcggttaagttcgcagagttttgccaagtttacaggtgatttactaacac
+ttgggagggtacgtacaaccatcacctggttagcagagaatgaattatacggtcatgtcg
+cgaagggcaagtgtgtgagtattgaccgagttattaaacgtaaatgcaggcatttacgtc
+ataggacatcgagtttgtcctttgcgaaatgttaaatttatggttttttccgttgagtga
+taatagctgcaacatgaagatagtaaaactgaggttaaactttcaccatattaaattata
+tgttcaattacgcgatgtacaaactaatgttaatcagatttaggagcgcgcttaatatgg
+gtccctatcccgactttgtacgagattttgataaaaaatagtattgtaaattcatttgat
+ggcgtagaaccgggcaaaaccttgaaaaaggacacatttaggatgctatttccctaagaa
+agcggaaaatcctggctcaatatttataatagtaatggttaagattgtggcccaatcgct
+gagtacccgtcttacgctttttccaacacataatcgacgagaatgtatttaaatgtttga
+gacttacgttttccgcgtacttattattaaagtcattggagagggtgtcgtctgggtgta
+gttttctcatctgctcaggagctaaaaatgtaaatctattggttgtttctaattctgtcg
+tccgtgtaggctatttaatttttatggtacacttgaatatgtttagccataatgtagcca
+atactacaatatcagatacttgtatacgacctatagacttttgccgaccgctcgtagagt
+gatttagaaagatgttcggatagcacagcaatcgtttgcgaatgtaagcatgcgaagcga
+gtatttaactgttgactattttgctatatgttactctgaatgttgttttttttaccagaa
+tgtgttataatgatcaaccatgcacgttcctactaatcatataaattttgttacgtaagc
+ttttctatgatagtggtctaaagactacccttgcatactttaagattaagacatgcactt
+taggaggaactcacacgttttgagctgttctagcccacctataagccattcgtccgcaat
+cccataactacaatagtcggcaatcttttattacccagaactaacgtttttatttcccgg
+tacgtatcacattaatcttaatttaatgcgtgagagtaacgatgaacgaaagttatttat
+gtttaagccgcttcttgagaatacagattactgttagaatgaaggcatcataactagaac
+accaacgcgcacctcgcacattactctaatagtagctttattcagtttaatatagacagt
+atttgaaccaggcgctaatgttaaggcccccttcgaaaaccttgttatgttattccatgt
+ggtcggaggatttgcggggcgatagcgctgggcggggatcaacaatttcgttcatgcgag
+cgcccccataaccagtaggtacagttcggaaaagaaaaccccacgcactcgctagaagtg
+ttacaatcacatcacttcgtaccgaagggactactgtattccgtcttggggatgtaacag
+actgattacagtcttatgatgaagcctcattcatctaaaattagttgatttattccacgg
+atactatcacactcctatagaaagagttaccaccgtgggaagctagatataataaataaa
+agacatacaatattagtatggctcatgatctacacttactcggatctctctttttttata
+accagtagatcgcattacacgtattgttgttccgcatcaggccctaggggctcaaacttc
+catggtggataactaaaacgtccgtcactaaacgaagatattaatagatgaaatacacgg
+gtttacttgatttctgttcagtcattcacgggaaatcctaggagtctttcataacggcgg
+tcttagtaggaatgtagtcaagctctgtagaggtctcgacggaattggtatttcctggca
+tcacaatttacctagtattggagatcacttaaaataatgttgagataataatcaggatat
+ttctagtatgtgacaaacctctatttagtgattgtgattttcaattaaacaagacgtagg
+ggtcaaattaacgactacatgttggaaagaaggccgaattgtaatatctaactcatgtac
+taagaagaagtgctttcgtttaaggctttctgtctaacattctaacgtcaattcctatgt
+aatactactgtaaccaagttattactcggctgcgtagataaagtctcatgtaaatgacgg
+tttatctgttacttttgggtttcaacctagctaggacgccggtactaattacgacacctg
+cgtatagtgcagggtgttcaatgtgcctttttatgtccggattataaccatccctctccc
+acttggaatatcaccgggttcttaatgacttagttcgtcttccttattttccgggtaaga
+tcgctgtggaccggacccattttgatctagtctaaaaaggtatatagcgtttcgtctggc
+ccgcttacgttcactgaaacttagattaatcaatgcactgcactggattaacaagaacat
+gttatagtgtactgacacatgttagactaagaggtctgttcgggttagccgacttatatg
+tttaaccgattttgacaactgggttgagagataacaatgaagagtgaggactgtagaaga
+tcttaaaactgtaccatagtgctcaattcgctaatggcttgaattatttaattgttctaa
+ccctggcgtcgaatttttttggttcgaaaatacttagcacagcgtattgttcaacgagat
+gcacaactgtaccgttagaaagcggcttaatgacaaggcagtattgtgactattgacagg
+gaatcctaaaaagctactcgaattggtatatggaagaggtatgtactgagaggtcgcgcc
+tattagtcaaattctgccaaagaagagtcaaaagcttaactagtttgatggtatgaggtt
+taatgctaggtggtctataccaccaaaaagtatatgggatatcccagaatttatcgactt
+tcaatcgtctaccgtcacgacgtacactaggcagccctaatccaaaacttttgaggatga
+gtactgccactattatactgtaccatttgtaacttacattttatatcttcaaagaggtag
+atattgtcggccattactgtcacttacactaagggtagcttgattactgatacctctcat
+ggtaaaaagtaatttaagaacctatttttttacataacctctgctactaccgttagtgtt
+ttagtcggttcaagtcacaaaatccctgtagcgcacccctataagcagaaggaaacctta
+atgcggataaaaacttttgccggaaccgttaatcctatgagaataccactcttggaatcg
+gtcctttaggctgaggatatagaacgaggggaacgcatcaatctaggttaggtgagagaa
+ctttgtatcaaaacgcaagtaccatatgccgtcctcagtaaattgccaaatgcagaaatc
+ttacactcttttcttaactaagtatgagagcaacctcactcctgaacagcttgttaccta
+acgagaagaggctttaagtagcctggagcctcaaccggatatccggatttgactctcatc
+cacttacatgatgattacggtcattacatctcatgattttctgagtgccctatagactgg
+gaatttaatctaccctgtttctatttgttaacaaggagaaccactggtcaagatgacgcg
+cttccatttatgccaccataagtaagttctcggaacccttacatgattggcctaccaacc
+tatatatgtgaccaatgtacggtacatagagtgtggcctatcatattcaggtcatcgagc
+tcagtatttaaagattatatggtcgctgggggtattcagtgcgcgatggaagactaacat
+tggaaatcaacggaattgacaacacgctcactttaataacctatctcaggataagtttaa
+tgtaattagacggaactttctctaactccgtgtactaactctttgaaaataatgtgggta
+tttttatttcatctagatttgtctgtatcgaaagaaagtattggtccaaataatcctcag
+taaaatcaagtcataaatataaaatttagatcttaggacagaggaaagtgctttcccgag
+cataggatctggcctacgccagtagttcatgcttgtgttaaaagttgttactgtttatag
+tccgtactcagggtagtgttcgatactcagcggggaactgacatattacactaaggaatc
+aaggcccttcgtatgggtcatgtttatatatttaattacttacgctatttgatcgagaat
+agctatagtaacgtcgtaagaatgcaggatgcgattcgagtttgtaaattcacagatact
+gtgtatcatattattatagatgttaaggcatagaattattggtattgatgtacaaaaaat
+tatgggtgggcagtaccgataggcattacgagcagtgcagcttggaagaactggatgtat
+cctataactagtaagagccttaaaggtactacatacccagggatgttaccatcattaatt
+tggccatcttcaatcttcgcaatgcatactttcttctacaagatgccttttagaagacaa
+aataagtgtcaacaataacgctgtaacttaactctgttgtacgtggaatcaagtctcact
+aaagcaactaacattccgacatgcaaacgcaggactactagattattaaattcgccagcc
+cgcctcgtttaatataacatcataaaaattctaagtaatatctcacacactaatccgcca
+tcgtccatagcatcagtcacctgtcttacacaaacacatgtttaatcgatgttgttatgc
+caagctagtttcgcgaccatgtaactaattgtggaaagctgctaccttgaacgacatcaa
+ccatcctacctttgtacaacagaccaacatctctgtactggtaaatagatctgaaaagtt
+ataaatataactgttttcacattgatagaaaaacagctatgtgctatttgtatatactat
+aataaattaagcgaaacatggagattaaaacagtgttttctcatcctccacctcttgttc
+tgctaatttataattcttgatgccactcgtgtgagtcgtccattcgatcgtaaagaaccc
+gacataaatagatacgacgctgaacgagatcctatttctcctgaaaattattagcacggt
+aactcctagggatagtggtactagttggtatgaacgtataaaaacttgtactactttctc
+gggatgtgagggagcaaactattactcgaccagtgcaacgcattatcgacagtaaaagtt
+ttcagctgatacctgtctggatggattatatgcaggtaggcgagagtggattgtagcgat
+gctcggcgggggtattttaaaaatctaggtgataaaagtcctgtttagccaggaaaagtc
+atcattgcactgcatatcgtcgattagctgtcatttcgtccactggtaccagttcaacgt
+acatcaaagtccgggcgcatccatatcaagttttgcaatagtactccagaccatgaaatg
+gttatccagattaataataacttaatatactttcactacatactcagcgggtattaaatt
+tcactttatgtcaaaggactcttatgtggtcttcaaaaaggtctagagtctatcacgcct
+aattgtgtgaaaaccgagtaacttgatcagccttgtaaaatatagtagaatatgatgtta
+aatcatttatattccagggagattgaatagcttacgattagctggtataatttaactcac
+atgattaagcaaatatctgtaggaccgagggaaagaataaaataaagtaccatgagttcg
+gaacgctgcattacatggcgttgggctagcctgatacaagaagatgagtatggagctctc
+ttcatcgggacgtgacaaccctagcgtaatcttggcagatcccggagcagatgattatcg
+tctaacactgtctttaccaatgcacaacgcatagatttaacctgaactgttctggattca
+ctcctgactacagcctacaactcatttctatgcataactcttaaagacagtcgcaatatc
+agtacctctatacacatcggatcagactagatcataagataagtctcctctggatccttg
+tattctgttaagtacactacaaatttgtttagtgtctgggacaattacgataagggtcgc
+gactagaccacagggcatatgacctccaccgctcctagcgagtctccaatctgcaagcac
+tcatacgctaggggcatgaatcgactgtcaatgcactgtaagatttacgagggtgagacc
+catttagatatgcctcgtttaaccgttttaggcttgataggatgagtttgtcgatccatc
+aaattcccgacattcatattgtccaataagtatatctagcttattcggactcgctaaact
+aaattatggtataaatgccgtcaaccggtgcatttgttcaatcaacaaattatagtcaat
+ctcccatggggccttatggcagcgtatacagctggtataacgaccatatacaactatgaa
+cggactagctgtgaactaagcagattattggatccttgtgtataattttaagtttcgatc
+tatatgctatagtatagaaaatgttccgatcgtacgcttcctttacagttaaacagtcta
+tatcatgaagcttatccaaagctggacatttgatggcaatcttacttaattatgaaactt
+aattacctattattgaaagtatttatatgatcgaataagatttgctctataaacaggtcg
+tccattcacgacctagtgattgcgtaaattgaccaacctaggtaatctaaagcctgcatc
+tatttcttatcattcatgttatactgacccgttctcagtacttaaaaatgatcgtaagca
+agaatcactcacgctcatgtcacatttagtcgaaataaactgccgatgggaaggaagttc
+cgtcattgcgatatcgatgtctatcccacgcgtcattttcaaattggttatctacggata
+actgtgcgatgaactactataggtcaaaattatcttcaatctcattctagatcatataaa
+gatgtccttcgcgattgatacgtctacagtgtgttggtgttacacagagggtagcgacta
+cttacttactaactctctcttgatccgcaagcataagccaggttaaagtgctctatcttt
+ttctgtggattataatagttataccgccttgcatctaggtgcccattaggtaatgcccta
+gtgttttcataaatttactcctgccatctaacgttactttaatttcccagattcaatagg
+tctctcatttgaaaattgttatatgtcaacaaagaatataatagctgagtggaacaatac
+actgtgagggagtaatacatactctaaattttctttacggtttgcgcctgcacagttttt
+tttatctatgtgatccgcataaaaagtaatttcaacgttccattcaagttaagtcttggt
+gacactagcattaggagagatcaccaagaccattatttatttagctagggtttaagtcgg
+ttagaaatatcagataatgaggtctttatccggccttacgcagtagaaattggaaatttc
+gtaaagcactgagttcaatggaagtatggccgaacccacataatgcacaaatcaagtcga
+tttcttccgtccttttagtctcctgggaactacgggttattcatagttaagctaaatcag
+ttaacggaactagacaaatgtataatagttcccaaatatatatctataaatcttatgcag
+ttagggaatgcagatttgaatcatggcaatacgctagctcggaactcaactacaagtgtt
+ggatgtacgaattcaaaggtattacatccttatgatgttcttttttggatacttttatga
+cgacttccacgaagtgaaattatgttcgaatatctgaacagttacttggttgagcccaag
+gatgacgaatgttctgtttataattctcgtcataatataaatacaagcatatgaggccag
+tcatggagctttcatttggactaacatttccgtagagtcatatcacgcctgtaatctgat
+ccgtctttttctattcgaagtgttatcagatacatgacgcccttgcgtgacattcatggc
+tcctgacatcgggtcttttaggctgaatctaatctaacccaatttgtttggattgtgggt
+cctccattttgtctgttaatgcttattaagattaaaaatgtactacgtatttagacctaa
+tgattgcgatacgctgtggaccattaatataagctgcgccaggggatttttccagatcat
+ctggcctgtgtatatgttcaaatctaatagccgagagaaattactccgacggaaaataaa
+ggcagataagcgtttcagagcaccatcgtggcgtttagtcaacctttagttcggaattta
+ttaatatacaatctcactctttggacgagctccttaaaagatgcccttgtatatcatgtc
+ccgtacctaaaagtataccagcatcatcaaagaacagttaaggaatacgactgctctata
+attgtccgaggagtaccttctcatctgccaatagtcgttgggttggaaaacaacgcatta
+atatgccacacttgtcaattagaagtttctataaaggggacgagtaactgatttgagacc
+tagcacggcagaggacgttcgtgtgacaacatctctttataagtttgagataaaatcgct
+aatctacaatgattatttgccaatcattatcgaatgcgcaaagtatctcctgttcgtgat
+tctagcctaaggccattactatggtcaaattatgctaatcgaagcagtcttctaacaccc
+ttagaaaagcaaacactattgaatactgccgccgcattcgccagcaccaacataactgca
+cgtgcttttttccatgattggcattatgaaagatttgatctatgattcttaccagttgca
+atattcaatttagcatgtgttcctaattattgtgttattatggtctatctcatcatgtaa
+atgaagatcatgacgtcaacacagattctagtcaggatcatcagttcctcggggaaatcg
+cacctaggaacagccttatgcaaccgctaaacaaagcaatgaggatgtaccgacaaaagc
+tcgatttaaaagcctcgaaacgagatgtacgaatcgtttactgccttttatgaggagtcg
+agtactgttggttcatatttgctacatgattgtatgtaataacgatcccgccctttatcg
+gttcgatcctttatggcgataagttatgaatcgtcagtatctttagatcaaaaactcaac
+tagtacccagttccccggaggaacggtcatgattaatgcgttttacggtctcccgtccct
+cttcttgtcagaggaatcagtttcatccgatcccactcgatgattggtatagctatttgc
+cgaaaagccacaacgtattcggtactatcttgtttgattcccctgtatcttaattcgcga
+cacttgatatcttttgtgtttaatcgacgaatcatcctgggggcgacacttgttacaatt
+atccagttgcgtttaatggctgtgggtcacaagattgttagacaggtcccgcgtgtcgta
+ggaaattgataattggagtttgcaggacgaatagctcacccgcctaagtgatccaaccct
+catcaggataactatcactgggcagtattatttttgatttcatatgccaccccctaggag
+actgtagtcatgtatctttcttacccaatctagcccgaaacaagaaagaatgtcgattcc
+agtcaccttttattagaccgatttacacacaaagtgtcttggtttaaaggctggcatgaa
+tacatactcaaaagttgaaaacgacttgctctattcgattaccttcgcgatctcaatcga
+ttacgctaaattttaatgcccgctgaaatatccaacatttaaaacaggattaattctctg
+atccatgaacttaggactcattgcacgtgacttatctttctctcttaattcatgctccaa
+tacggtgggctaaaccacttttatcacatgaatgtacgcaacgtgttaataagctatgag
+tacgcgggggcagcgaaacgggtcaatctgggtatcttctattgggacggtacatttcgg
+ttttatagactatgtagttacacggcatcaacatgtaattaaaacggcgtaacctaggaa
+agccgaacgcaccttgggattgccatgtgtccggaggattacatacatctaagaaacatt
+ctaaactatgtatagtcgtttacgacccttgtagtacgtgcatcccttggcgaaaagtac
+tctgggtattagagtgtatattatcgacagcaccgaatcctcattttatagcttgacaat
+ttatgacccgaaagaaccttttataagtctataagtatatctaacgcaattgcggcactg
+agtccactaactatctttgagcagtgttatacagtgagacgccatggaaggggtttatat
+attttactgtcgttccctaaaaagttaattatcagacctgcgcgatctcgtagatgaaca
+acgcgatctagtcgaaaaatgcttgtggctaccattccagtcgagatcaaccgtttctgc
+ggatcgcgttacattccttgcttatttgcgataaatcgatacaaccccattaccagaaaa
+acccggagaatcaattactctgcagatcttatactaaaaaagagattacaacccctgttc
+tatgtgtcccaaagtgagtaacgtggagcgttggggtaagagcggagcgattttaacttt
+cgcttttccattttccagtattgtactttacgttatatttgagcggcacattcgtcaaaa
+catgatccatatggactgaggtgtttaaatgttaatcaaataattgtattttcagctgac
+tttaaaatctgcagccattggaggtggagattccaatagatgtaagcaggtgatatcata
+tgcaattcttgtgacttattaagataccagacacggcacaatcgcagtagcacgtaaaca
+ataatgacaatcgacggttaaattccgaacgtaagatatgtttacggatgcactaaaata
+ggtagcaacaacgtttctctgagatgtataagttaccaaacactggagaattccgctaaa
+ctaaggacaatttccgtcgtattaattgttgacaaatggttagtaatacattcgcagtgg
+ataatccgttgcatacctagcactgagtgtaaataaaaccaatcgactactggcatttcg
+ggctaacgactagatgttagcctatgtgaaagcctcacacatgcttattgccttcacggt
+gagcaatgtttcttattcgttattagaagtcacctgtagagacagtagagatgacctaaa
+tttggtttgtccagtcccgaggtgatctaatgattaggttaacttagaacagtggtcaat
+tggttaaagctgatttacgaacacttccgaggggtcgtaaaacattaaactggtgagaac
+agtatgatgtattcggtcatctagacaaccccatcgctgggagtttggacagtgttatga
+ttcgtaaatccaccatgtgtccgaattcgaaatcctgttgctccggggagatagggttaa
+tttaggcttttttacggtgtggcatattagctcaaacatcaacattcttaaaatcagcgt
+aaacggtcaccagttgatatttgttctgctaggaagcgatgtacaaaataagcttaataa
+gatttaggtccgaccttaatttcggtccatagcacctctttctaagtgttttgcttaaat
+aattgtattgttattgattttctgcgagttgaacacggaaaataagtcaaaaaggacact
+tttaggttcatatgtaccgatgaatgcgcaatagaatcgagaaatttttagattagtaat
+cgtgatgattgtggccaaatcccgcactaaacggctttcgctgtttccaaaaaattttag
+tccactaggtatttaaatgttggacactgaacgtggaagccgtcgtattatgaaactaat
+ggcagaggggctcctctgcgtgtactttgagcagatgctatcgtcagaaaaaggtaaatc
+ttttggttctttataattctggcgtccgtgtagcctagtgaatgtgtttggttcaagtga
+atttgtttagccagaatggaccaattacgtcattagctgttacgtctatacgaaatatag
+actgtggacgacccatcgtagagtcatgtagttacatgtgaccttagaacaccaatcgtg
+tgcgattgtaagcaggacaacacagtattgtactggtcaattggttcatagatctgacta
+tgaatcttcgtttttgtacaacaatctcggtgaagcttcaaaaagcctccttcctaataa
+tcagttaatttttcgtaaggttcctgttcgaggttagtcgtataaagacgaaacggcctt
+aatgtaacattaactattccactgtaggtggatctaacaaggttggacatgtgctaccaa
+taagataagaatttcgtccgcaatacaatatctacttttgtagcctatcttggattaaca
+acaacttacgttggtatttcaccggacgtatcaaatgattctgattttaatgactgagag
+taaacatcaacgaatcttatgtatctttaagccgctgcttgacaagtcacattactgtta
+gaatgaacgcttcattactacaaaacctaccaccaactcccacattaatattatactaga
+tgtttgaagtttatttgacaaaggttttcaaaaagcacagaatcgttacgaacacgtaca
+ttaaattgttagggtattaattgtggtcggtgcatttccggccccatagcgctccgcggg
+gagaaactatggccttcatgacagcccccccataacatctaggtaatggtcggataacta
+taaacaaccctctccagagaactgtgaaaataaaatctcttagtacacaagcgtatactg
+gtttaagtcttgcccatcttaaagactcttttcactattttcttgatgcctcattcttct
+aatattaggtgattttttaatccgagaatataaaaagacgatagaaagtgttaaaacacg
+gcgtagcgacatattttaaagaaatgaaatactttttgactatccctcatgatctaaact
+tacgcggagctatctttttgtataacatgtacagagaattaatccgatgcttcttccgat
+taaggacatagcgccgaaaacgtcatggcggcttatcgatatcgtaacgcactataccaa
+gtgattaagtgatcaatgaatacgggtttcgggatttctgttaagtcatgcacggcaaat
+acttggagtcttgaataacgccgcgcgtagtacgaaggttctcaagctcgcgtgacgtat
+agaccgtattgctatttcctgccttctcaattgtccgaggattgctgataacttaaaata
+aggttgagtttttaataacgatttgtcgagtttgggaaaatcctcgtttgtgtgtttgtc
+attttcaagttatcaagaactacgggtataatttacgacgtaatgttggtttgatgcccg
+attgcgaatatcgtacgaatggtatttgtacaactgctttcctttatcgattgctcgaga
+acattataaagtctattactatggattaagactgtatacaagtgtttaagcggagcccgt
+gataatctataaggttttggtacctttatctgttacttttgccttgaaacatacatacgt
+acacgggaatatttacctaaacgccgtatagtccagcctcgtatttgggccgtgttttgt
+cagcattttaaactgaaagcgcccacttgcattataacccggtgcggaatctcttagtga
+ctcgtcaggagtttacgcctttgagacctctcgacaggacccattttgatctagtcgtta
+taggtagagtgcctttcctatcgcaccattaccttctagcaaacttagagtattcaatga
+aatcatatcctgtttatactaaatgttataggctaatgacacagctgacactaagaggtc
+tcttcgggttacccgaatgagttgtttatacgatgttgacaactcgggggagtcatttca
+atgaagactgaggactcttgatcagattaaaacgcttaatgactgataatttagattatg
+ccgtgtattatttaagtgggcgaaccctcccctagaatgggtttcctgagaaaagtctta
+gaacacagtattctgaatccagatgcaaatcgctaacgttagtaagcggctgtagctctt
+ggcagtttggtcaatagtcaatcgcaatccgtttaaccgtctactattcctagagcgaag
+agctatgttctgacacgtccccaatattaggcaaaggctccaaaagaacagtcaattgat
+taactacgggcttggtttctccgtgaatccttgcgccgctataccacataaaaggatagc
+ggtgataccacaagtttgcgacgttaaagcgtcgaccctcaacaagtacactagcaaccc
+cttagcaattaattttgtccatcactactgccaagagttgactggaccagttggaaatga
+catttgatatattaatagagctacatattgtaccactttactgtcacttacactaaccct
+agcgtgattactcatacatatattcgtaaattctaagttatgatactagttttgtaaatt
+taatcggcgaagacacgttctcttgtacgagcttcaactaaatatttcactgtagccaac
+cactttaaccagaaggataccttaatgccgatataatattgtccaggaaacgttaatact
+ttcacaagacaaagcttggaagaggtactttacgatcacctgatagatcgaccggaacga
+ttctatataggtttggtctgagaaatttgtagctaaaaccatgttccataggaactcctc
+tgtaatgggcaaaatgcagatagcgttcaatcgttgcttaactatctatcacagcatcct
+aactcctcaacagcttctttcctaaagacatcagcaggtaagttgacggcacccgataac
+ccagagcacgattggaatctaatactctgtatggatcattacgctaagtaaatataatga
+ttttctgactcaaagttacactgcgaattttatattaactggttctatttgttaaatacc
+acaacctctcgtcaacaggtcgcgatgcaagtgatccaaaaatatctaacttataccaac
+cattacttctggcgcagaaaaacatagatatctgaacaatcgaccgttaagactgtctcg
+ccgatcttaggaacctaatactgctcagtagttattgtttatttgggccatccccggatt
+atgtcagccatggaacactaaaagtcctaatctaacctatggacaaaaagctcactttta
+taaaattgctcaccttatgttgattgttatttgtccgaaatgtctataactcagtgtact
+atctattggaaaattatggccggagttttattgaatatacttttgtatgttgagaaagaa
+tgttgtcgtaataattatcagctggaaaatcatctaatatatattatattgagatattac
+gacagacctaagtgctttcccgtcatgagcagatggactaacactcttggtaatccttct
+cgttttagttggtaatgtttagtctaagtaatatcccgactcttacttactcagagcgga
+aatgactttttaaactaacgtttaaaggcacttagtatgcgtcagggttatttttttaat
+tacgtacccttgtgcagagagtttagctattcgatcctacttagtatgaaccatgagagt
+acaggttggtaattcacagagaaggtcgagaagattatttttgatgtttaccaatactat
+gaggcgtattcatcgaaataattttatggctgcgcacttcacatacgcaggaagaccact
+gcagcttgctagatctggatgtatcattgtacttctaagagcctgaaaggtaatacattc
+ccagcgagcgtaacagattgtatggggacatattcaatcttagcaatgcattcgttcttc
+gaaatcaggcatttttgatgtcataagttctgtcaactataaccctggaactttaatctg
+ttgttcgtcgaatcaaggatcaagaaagcttctaaaaggcccaaagcaaaacccaccact
+acttcagttttaaattagaatcacaccctagggtattagataataattaaatgtcttagg
+aagagatatcaaaagatgcagacatcctcaagtgaataagtctccggtctttcacaaaca
+catggttaagcgatgtggttttgactagagacgttcgccaccatcgtaatatttctggtt
+acctgcgaacgtgaaccaaatcttacttcatacattgcttaaacagtacaacttatctct
+tatcctatagagatctcaaaagtttgtatttttactggtttcaaattgagagaaaaactg
+cgttctccgatttctatattattgtttaaatgatgccaaacatccagtttaaaacacggt
+gtgatcagccgactcagattcgtatcctatgttagaatgagtcatcaaactacggtcacg
+cgtacattacagagtaaactacacgaatgaaagagataagaagatgaaagagttaatagg
+tctcctgttaattatgagaaccctaactactacggattggcctactagtgggttggaacg
+gatataaaattcgactaagttcgcggcatgtcaggctcctaaatatgaagagaactcggc
+atcgaattatccacagtaatagttggaacatgattcctctatgcatggtgtatatccacg
+tacgccagtgtgcagtgtagccatgcgaccacgggcgttgtgaatattcttcctcagaaa
+aggactgttgagcaaggaattggattctgtgaacggaatatagtcgagtagatggaattt
+cctacactgcgaaaaggtcatagtaaatcaaacgccgcgcgcagacatatcttcttggca
+attagtactccactaaatcaattggttataaacttttagaatatctttatataagttcac
+tacttacgctgcgggtagtatatttaaagtgatgtcttaggaatcttatggcggcggaat
+aaacggcttgactatagataccctaattctggcataaccctgtaacgtgtgaagcatgct
+ttaatagacgactagatcagcttatagaatggatatgactgccacattgaagagattaac
+attagcgggtataatgttacgaacttgtttaacaaaatagctctaccacacacgcatagt
+ataatataaaggtcctggagttcgctacgagcctggaattgcagttcccctaccctgagt
+aaacaagatcagtatggacctatcttctgacccacgtgtaaaaactaccgttagcggccc
+tgagaacggtgaagttgattatcggctaacactcgctttaccaaggaacaaacaattgat
+ggaacaggtaagcggctggattctatcctgaatacagcataataatatttgctttcaata
+tatagttatgacactcccaatatcactaactctttacaaatcggatatgaagagtgaatt
+agagatggagccgatcgttccttgtattctggtaagtactcgactaatgtgtgtagtcta
+ggggtaaaggtccttaaccgtcgagtctagaactcacgcattatgaaatcctccgagcat
+agagactctaaattcgccaagcaataagtcccgacgcgaaggatgagaagctcattgaac
+tgtaacatttacgtcgggctcaccatgttacatatgcagcgggtaaaagtttttgcctgg
+agtggttgagtttcgcgatacataaaaggccccactttcatatggtcaaatatctatatc
+gtgctttggacgactcgataaactaaagtagcctagtaatgccctaaaccgctgcatttg
+tgcaataaaaaatttagagtatatataacttccggacgtatggctgccttgaatcctcgg
+atatcgtccttatacaacgatgaacggtatagctcggaactatgcagattaggcgatcct
+tgggttgaatttttagtttccatagatatgagttagttttgatatggttaccatacgtcc
+ctgcattgaaacttaatctgtatattgattgatccttagcaatagcggcacatttctggg
+caatatgacttaattaggttacggtttttactatgatggatacgttttatatgatagaat
+aacagttgctatttaaacaggtactacattcaactaatactgtttcactattgtgtccaa
+catagggaatatattgcctgaatagatgtattatcaggcatcttttacgctccaggtaga
+actaattaaaaatgatccttagaaactttcaagcaacataagctaaaagttacgccaatt
+ataagccacatcggtaggatcttcaggcattcccatatccttctctatcaatcccgtctg
+ttgctaattggttatctaagcatatcgcggcgagcatctacgataggtataaagttgctg
+ctatctaattcgtcataatatatacatggaattacagattcatacgtcttcagtctcgtg
+gtgtttctaagagcggacccaagaattacgtaatatctctctcgtgttacccaagaagtt
+gacacgtgattgtcagctatctttttctggcgatgttaatagttataaacaattgcatat
+agctgcaaattagctaatcaaatactcgtttcttaaatgttatcagcaaagctttaggtt
+ctgtaatttcactgtgtaaagagggcgctaagttcaaaattggtttttggcaacaaacaa
+tttaatagcgcagtgcaaaaataatatctcagggtgtaattatttctctaattggtcttt
+acggttggaccaggcaatgggttttttatctatgtgataccaattaaaagtaatttcaaa
+gtgacattaaacttaagtattgctgtcaagaccattacgacacttcaccaacacatttat
+gtattgtgctacgcggtatggcccgtagtaatttctgatattgaccgcgttatcagcaag
+tacgctgtacaaatgccaaatttagtaaagctctgtgtgcattccaaggtgcccacatca
+cacattatcaacatatcatgtcgttgtattacgtccttttactagcctgggaaataccgg
+tgattcagagtgaacataaatctctgaaagctactagacaaagctagtatagttaaaata
+tatatttcttttaatattaggatctttgcgattgcacatttcaagcatcgcattaaccta
+cctccgtactcttctacaacggttgcatgtacgatttctatgcgatgaaatacttatgtt
+cttagtttggggttactttgttcacctagtcctcgaacgcaaattagcttcgaatatctg
+aaaagtgtatgcgggcaccaaaacgatctcgattcttaggtttataattatagtcagaag
+ataaatacatgcatatctggacactcttccacatgtcatgtcgactaactttgaactaca
+gtcatatatagactgttatctgatccgtatgtgtctattactactcttatctgagaaagg
+acccaatggagtcacagtaagcgatcatgtcatcggggctttttccctgattataagatt
+acactattgctgtgcttggggcctcctactttttctatcttaatcattttgtacattaaa
+aagctaagaagtaggtacaacttatctttcccatacgagctggaccattaatttaacagc
+cgcaaggcgagttttaatgttaatctggaagggctttatgttctaagcttttagcactga
+gaaattaatccgtaggaaattaatcccacataacccggtaagagaaccttacgccccgtt
+actaataatgttctgcgcaatgtaggaagtgacaagctcactcttgcgacgagctcctta
+atacaggccctgcgttatattcgaccgtacctataactagaccaccatcttaaatgtaca
+gttatggttttcgacgcatagagtatgggaccacctcgaaatgctcagctgcaaattgta
+ctgggggtggttatcaaacatttaatatgaatctatggtaaagtactagtttatagatag
+ccgaacactaaaggtttgcagaccttcctcccctgaggaacttcgtgtcacaaattagat
+tgagaaggtggtgataaaatcgcgtatctacaatgatttggtgcaaatatttatcgattg
+cccaatcgttctactcgtactctttatagcctaacgccttttcttggcgctaattagcct
+aatccaagaaggagtctaacaaaattacttaaccatactcttgtctattcggcccacgca
+tgcgcaagctcaaaaagttctcaacgggcgtttttacttgagtcccaggaggtaacattg
+gatctatgagtcttaacagtggaaatatgatttttagattgtgttcagatttattgtctt
+attttggtctatctcatcagctatagctacataatgacgtcttaactgtttcgactaacc
+ttcagatctgactaccccaaatacaacatagcaaaagaatgatgctaacgcttaactatc
+ctttcacgatcttaacaaaaaagctccatttaaaagaatcgaaaacagatctaccattcg
+tggaatcaatttttggacgagtactggtcgggtcgtgcttatttgctacaggattgtttc
+gtataacgttcaagcactttagcggttccatccttgatggcgttaactgatgatgcgtaa
+gtttatggtgatctaaaactctactacgaaccaggtcccagcacgaaacgtcatctttaa
+tgagtttttaggtctccaggcactaggctgcgaagtggaatatgtgtcatcagagacaaa
+tagatgattcctatagctttttgcagttaagccactaagtaggcggttctatagggtttc
+attcaaatcgatcgtaattcccgactctgcatagcgtgggtcttgtatagaccattcttc
+aggcccgccacaatggtttcaagtttcaacttccgtttattggctgtccctcaatagagt
+cgttctcagggcacgactctcgttcgttattcataagtccagtttgatccacgaatacag
+aacacgcatatctgataataaaagcttaacgataactttcacgcgcatggtttatttttg
+atttattaggcaaccaaataccagaatgtagtcagcgatatgtagtaaaatttagacaaa
+cataaaacaaagtatcgccattacagtctcctgttaggagaacctttttatcaatatgtg
+taggcgtgtattggcgcccttgatttaataataattacggctaaacgtattgatattttc
+caggaactgccccatctcatgagatgaccctaaattttattcacacctcatttttaattc
+ttttatatcacgattatttatctgagcaagcatctttgcaagcattcatagtgacggtgc
+tgtctctatgaatgcatgctaatatacggtgcgctaaacatattggttcaattcaatgta
+agctacctcggaatttgcttgcactaagacggggaagccaaaacggtaaatcgccgtata
+tgctagtgccaagggacttgtccgttggagtcactatggagttacaagcattataaatct
+aaggaaatcgcagtatcagtccttaccccaaagatacttcgcattccctggggtacggac
+catgaaatacttctttcatacatgataaacgatggagactcggttaccaccctggtagtt
+actccatcaattggagttaactaagatcgctattacaggctttattagccaatcatcaca
+agcctctttttagagattcacaagttagcaaaccaaagttcctttgataagtctttaacg
+agatctatcccaattccggctaggagtaaaatttatatatttgagatcggggttaaagtc
+acacgcaatgcaaggggtttttatatggtaatgtccttccctaattaggtaattttcaga
+cctccgagagagagtagatcaacaacgcgttatactcctaaaatgcttgtcgataacatg
+acactacagatcatccctggatgagcatcgactttcattacttgattagttcagttaatt
+cgtttcaaaccattttcaacaaaatcccccagtagatatgtatatgcacatcttagacta
+aataacagttttcataccctgggatttgtgtcactatctcaggaacgtcgagacgtcccc
+tatcaccgcagcgagggtaactggccctgttccattgtaatcgatgggacgggacgttat
+attgcagacccaaagtagtaataaattcagccatatggacggagggggggaattgttaag
+aatataattcgattttcagctgaatgtaaaagctccagccattcctcctccacttgacat
+tagttcgaagaaggtctgagaattggaattgcttgtgacgttttttgtttccagacaagg
+aaatagcccagtaccaagtataatattatgacaatagaagcttaaattcacaacgtaaca
+tatctgttagcatgctctaatagaccgagaaaataagtgtctatgtgtgcgagaactgtc
+aattcacggcagtagtcacctaatctaacgtctagttcccgactatgaagtcttcacaaa
+tggttagtaataatttcccagtggagtagaagtggcataacgtgcactctctgttaataa
+tacctttagactactcccatttcgccagaacgtcttgatggtaccctatgggaaacactc
+acacatgcttattgcctgcaacctcagcaatgtgtcgtatgcggtatttctacgaacagc
+tagtgaaaggactgatgacctaattttggtttctcaagtccagacgtgatattttgatga
+ccgtatctgacatctctgggcaattcggttaacctctggtacgaaatagtccgtcgcgta
+ggtaaaaatgataatgctgtcatcactatcatgttttagctaagctacactaccccatcg
+ctcgcacgtggcaaagtgtgaggattccgatatcatccatgtgtacgaattcctaatact
+cttgctcagggcacttagggttattgtagcctgtgttaccgtctcgcatattagatcatt
+aatcaacagtcttataatcaccgtaatcggtaaacagttgttatttgttctgataggtag
+acagctaataaagatgctgttgaacagttacgtcccacctttattgccctacagtgaaac
+tagttcttactctgttgctgtaatatgtctagggttattgatttgctgccacttcaaaac
+ggaaattaagtcattaacgaaaatggttccttcataggtaaagatcaatccccaattgaa
+gccagaaattttgagatgtcgattcctgatcattcgccaaatttacagctcgtaaacgag
+ttccatgtgtaaaaaaatgttgagtccactagcttgtttattctggctcaaggtacgtgg
+aacacgtagtattttgatactaatgccagacccgctacgatccctgtactgtgagcagag
+ccgatcctcagaaatagctaaatcttgtgcttcgttagaagtctcgactacgtgtagcct
+agtgtttgtgttgcgttatagtctatttgtggacacagtatggtcaaatgacgtcttttg
+atctgacggcgttaacaaagatactctgggcaacacacatacttctctcatgttgtttct
+tcggacctttcataacctttcctggcacatggttagctgcacatcacaggattgtaaggg
+tctagtggttcagtgagcggaatatcattcgtcggtggtgttaatctatctcggtgtagc
+ttataaatgcatccgtaagaatattatgtttatttgtcggtacgttcatggtagtggtgt
+cgccgatttagacgtaaaggcatgtatggatcttgatctatgcaaaggtaggtccatcta
+tatacgttgcacagcggatacaaataagataagaatttactaacatttaaattttcttat
+tgtcgagcatagattggaggaaaaacttatttacttggtatttaaacggaagtttctaat
+gtttatgattggatgcacggacagtttactgcttactttcttaggtttcttgaacaacag
+gatgcactagtaacatgtctcgttcatgcttccattaagttcttcttaaacttacacaaa
+ctacctaatttagagttgacgagatggttgaacgtgttgtgacaaacgtttgcaaaatgc
+acagtatcgttaccaaaaagtacatttaagtgtgtgcgtaggaattctgctacgtccatt
+gcaggccacattcacatcccacccctgaatatatggactgaatcacacacaccaaatttc
+atctaccttatcgtagcataactattaacaaacatatacagacttcgcggtaaataaaat
+atattagtacacaaccgtatactggttgaactattgcccagctttaagacgcttttaact
+aggtgcttgatcaagaagtattattatatgacggcagtgtgtaatacctgaatagatata
+gacgttagattgtctgaaaacacgccgtagagacatttttgttagatatgtatttctttt
+tgacgagccagcatcttagtatctgaagacgagctatatgtttgtagaaaatcgactgac
+attgtatacgaggcggcgtaagattaaccaaattccccagaattagtaatggcgccttat
+cgatttactaacgatatataacttgtgatgttgtctgcaatgtatacccgtgtaggctgt
+gctcttatcgaaggaaacgcattgaagtccaggctggatgaaaccaccgcgtacttccat
+gcgtctatacatagcgtcaccgatactacgttttgctatgtaatccattctaatgggtaa
+gaggattcctcttatagtaaaatatgcttgactttttaagaaccattgggagtggttggc
+aaaataatagtgggtgtctttctcagtgtatagttttctacaactacccctattaggtta
+caagtaatctggctttcttgccacttggcgatgatagttagattcgtatttctacaacgc
+agttactgtatccatggcgcgagataattagatacgatttgaatttggatgtagactcgt
+tactactgttgtagaccagcacgtgagtatctagatgggtttgctaccttgttagcggac
+ttttgccgggaaaaagacatacgtacaaccgtatattttactataagcagtattggccac
+cctcgtattgcggcagggtgtgctcacctggttaaaatgaaagagaaaaattccatttta
+aaacccggaggaatctattactgacgaggaaggtgtttaacccgttgagacatctcctaa
+cgtaaaaggttcatattctagttattccgagagtcactttcctatccaaacatgaactga
+tagcataatgacaggttgaatggaaagcatatcctgtttattctaaatctgtttcgctaa
+tcaatatgctgtcacgaactcggagcttacccttacaactatgtgttctgtttaccaggt
+gctaatatcccggcactcttttcatgcatgtcgctcctagcgtcatctgatttaatagct
+taatgtctcatattttacagtagccagtgtagtatggaaggcggcgaaccagcccctaca
+ttgggtttcctgacataagtattacatatcacttgtctgattacacagcaaaatcgctaa
+ccttactttgcgcatgtagctattggaactttgggctagtgtctatcccattaagtttaa
+cagtagactagtccgtgagcgatcaccgagcttatgtctcgtacccaagttttggatttg
+gatcaaaaactactcgatattcatgatctacgggcttcctttctccgggtatcattgcgc
+cgagattaaaaataaaacgatagcgctgtgaaaacatgtttgacacgggatagcgtagaa
+actaaacaacgaatagaccatccaatttgaattttattgggtccagcacttcgccatagt
+gttgaatggtaaagttcgaaaggaaatttgttatattaattctgctacattttcgaccac
+ttgtatctcaaggacaatatcccttgaggcttttagcagaaagagatgccgtaattctaa
+gggatgataataggttgggaaatttaagagcagtagtaacggtcgcgggttcgaccttaa
+actatatatttaaatctagccaaacaagttaacaacaaccataaagttatgaccttatta
+tattggcaagcttaacgttttaattgctctagtaatagagtggtagaggtaagggaccat
+cacctgattcttcctccgcaaccattatatagacgtgtcgtctgacaaatttcgagataa
+aacattcgtccttagcaacgaatatcgaatggcaattagccacattgagttaaatagttg
+aggatatttcttgcacagaatcagatctaatctaatgattcgttactaaacacttcacca
+ggtatcgtgaaggctcaagattacccagagaacctttgcaatataagaatatgtatgcag
+cattaccctaagtaattatattctttttctgactcaaagtgacaagccctagtgtatatt
+aaatcggtatatttgggaaattcctcaaactatcctaatcaggtagccatgaaagtgatc
+aaaaaagttcgtacttataccatacatgaattctggccaagtaaaaaatagattgcgcaa
+aattcgtaccttaagtctctcgccaagatattaggatcctattactcatatcgtgttttt
+ctttattgccgccatccccggagtatctcacccatccttctcttaaaggcctaatattac
+ctatgcaaataaacatatattgttgaaaattgagaacctgatcgtgattcttatgtgtac
+catatgtatagtaatcacgcgactatatagtgctttagtatcgcccgtgggtgagtgaat
+attctgggctagcgtgagatagtttcttgtcctaatatttttcagatcgaatagcttcta
+tttttgtgtttattgacatatgtcgaaactccttactcagtgaaagtcatgaccagatcc
+acgaacaatcttcggaatcagtctcgttttacggcggaatcttgagtctaacttatatcc
+cgtcgcttactttctaacaccccttatgtatttttaaaattacgtttattcgaacgtact
+tggcggaagcgttattttttgaagtaagttacattgggcagactcttgacattttcgata
+cgactttctttcatccatcacaggactcgttcgtattgatatcagaagctcgtgatgatt
+agttgtcttctttaccaatactttgaggcctattctgcgaaatttttgttgccctgcgaa
+cttcacataccaaggaacacctcgcaacatgccttcatatccatcgttcattgtaattct
+tacacaatgaatcctaagtaattacatccctgcgtaaaagatggtaggggcactgaggat
+atattaccaagcatttagttatgagtaatcagcaatgtttcttgtattaagttctctaaa
+atagttacatcgtaatgttatctcgggttccgcgaataaacgagatagattcattatata
+tggccctaagcaaaaacctcctcgtattctgttggtaattagaatcacacaatacgggtt
+gagatattaattatttgtagtacgaagagatataaaaagatgaacaattactcaagtcaa
+gatgtatacgggatttataataaaaatcgggtagagatctgctttgcaattcagacgtgc
+cactaaatcgtaatatgtcgcgttacatcagaaagggtaactattattaattaataaagg
+gcttaatcactacatattagatcttatccgatagtcttatctattcgttgtatttttaag
+cggttctaattcagtcattatatcagtgctccgagttctttattattgttttaaggatga
+caaaatgcctcttgttataacgctgggagaagcagactaagagtcggagcagttggtaga
+atgaggctgcaaaagacggtctcgacgaatggacagactttactaaaccaatgaaagaca
+gaagtagagcaaagtctgaagtggtatcagcttaattatgacaacccttaatacttccct
+ttcgccgaatactggcgtggaaaggttttaaaagtcgaagtagttagaggcatctctcgc
+tcataaataggtagactactcgcaatccaatgtgactatgtaatactgggaacatcagtc
+cgcgatgcagcgtgtttatcaaccgtccccactcgcctggggagacatgagaccaccccc
+gtggggattattagtccgcagtaatcgactcttgacaatccttttcgattatgtcatagc
+aatttacgacagttcagcgaagtgactactcggcgaaatggtattactaaagcattcgaa
+cccacatgaatgtgattcttggcaatttctaatccactaaagcttttccgttgaatctgg
+ttgtagatatttatataagttcactaattaagatcacggtagtatattgatagtgatgtc
+tttgcaagaggttggccgaggaatttacggattctctattgatacaatttgtctggctta
+taactcttaaggctgaaccaggcgtttttagacgacttgatcagctgttagaatggtttg
+gactccctctttcatgtcagtaacatttcagccgttattgttacgatatgcttgaacaat
+attgatctaccacacacccatagtatattttataggtcatgctgttacctacgagcatgg
+tattccacttcccattcaatgagtattcaacatcactagcctcagagatgatgacccacc
+tctaataacgtcacgttgcggccatgtgaaacctgaacttgagtagacgatatcaagcgc
+tttaaattgcatataacatttgagggtaaagctaagcggatgctttatataatcaatact
+caataataagatttgattgcattttagagttatgacacgacatagttcactaacgagtta
+ctattcccagatctagactgaagtactgatcgagacgatccttacgtcgatgatcgttag
+ttatcgacttaggtcgggtctctagcggtattggtacttaaccggacactatactaataa
+cccatgatcaaagcataacagaatacagacgataatttcgccaacatatatgtacagacc
+ccaagcatgagaagctcattgaaagctatcattgaagtcccgctcacaatgtgtcttttc
+cagacggtttaactggttcccgggagtcctggagtttcgacttacataaatggaaacaat
+gtattttgctaatttatctatagcgtcatttggaccaatacagaatattatgttgcctag
+taatccactataacccgcaagtgctgatagaaaatttttagacgatttataaatgcccca
+agtatccctcccgtgaatcctccgttatactaattagtattcgttcatacgtataccgcg
+catatatgaacatttggcgataaggcgcgtgaattgttacgtgacagagatagcagtttc
+ttgtgatatggttaacagacgtacatgaagggaaactttatatctatagtgatgcttccg
+tagaaataccgccactggtctgccaatgatgaagtatgtagctttaggtttgtactatga
+ggctttcgtttgtttgcagagtataacagttgcgagtgaaaaaccgacgaatttatacta
+atacgctttcactattggctacaaaatagggaagagtttcaatcatgagagggagtatat
+ggatgctttgtagctaaaggtagaacgtatgtatatgctgccgttcattcttgaaagata
+cataagcgataagttacgacaattataagcaacatccctaccttcgtaacgatttcactg
+ttactgcgcttgaaatacactatggggctattggcggagagaagcagatcgcgccgagca
+tatacgagacctataatgttgatgatagagaaggcgtctgaattgatacatcgaagtaca
+ctttctttcgtagtatctctcgtcctctttctatctccggacacaagaattaagttatat
+atatagagtcttaccaatcatgttgaatcctgattctcagagttctttggcgggccttgt
+gatgactgagaaacaatgcaatattgctccaaatttcctaagcaaattctcggttatgtt
+atgttatcagcaaagcgttacgttatgttatttaaatctggaatgacggagcgaagttct
+tatgtcggtgtgggaataattcttttgaagacagcactccttaaataatatcgctccgtg
+tttgtatttatcgaatgggtctgtaaccttgcacaagcaaatcggtggtgtatatatcgg
+ataacaattaatacgatgttcatagtgacagtatactgatcgagtcctctaaagtcaatt
+acctcacttaacaatctcattgatgttgtgtcattcccggtatcgcccgtagtatgtgct
+ctgattgaccgagtgtgaaccaaggaacatctactaatgcctttgttaggtaagatctct
+ctgaattccttcgtgccaacttaaaacattatcaaaatttcttctacttggattaactac
+ttttacgagcatggcaaattcccctgtggaagacggttcattattatcggaaaccttata
+gaaattgcgtgttgactgaaattagatttttattgtaagagttgcatctttgcgattcct
+ctggtctagcttccaatgaacagtcctcccttctattcgacatcgggtccttcgtacatg
+tctttgcgatgtaataattaggttcggagtgtggccttaatgggtgcaactaggaataca
+acgcaaatttgctgacatgatagcaaatcggtatgccggcaccaaaacgtgctccttgct
+tagcttgtgaatgagactcagtagttaaataaatccatatctgcaatcgattccacaggt
+attgtccactatctttgaactactctaagagatacaagcttagctgagaccgaggtgtat
+atgactacgctgatatctgtaaggtaccaatgcaggcaaagtatgcgagaagctaatacc
+ggctgtttccagctttataagattaaaatttggctgtcctggcggcctcagaattgttct
+atcgtaatcagttggttcattaattagctaagtacgaggtacaacttatctgtcccagaa
+cagctccacaagtttttttacagccgaaacccctgtgtgaatcttaatatccaagcgcgt
+tatctgattagagtttacaactcagtattttatcagtacgttttgtttccaacattaccc
+ggtatgacaaaatgacgccacgtgtcgaataatggtctgaccaatgtaggaagtgaaaag
+ataaatattgcctacacatactgaattcaggcaatgcgttttattcgaaaggtcatataa
+ctagaaaacatgatgaattcttatcggatccttttactagcatagtgttggcgaacacct
+cgtaatgctcagcggcaaattggactgcgggtccttatcatacattttttttcaatatag
+gcgattggtctaggttagtgattccccaacacttaaggtttgctgacattcataccctca
+gcaacttcctctcaaaaattagagtgagttggtggtcttataagaccgttgattatttga
+ggtggtcaaatgatggtgcgatgcacaaatcgttataatcgtactctgtagacaataacc
+cattgtagtgccgattttgtgcataatacaagaaggaggatataaaaatgacttttcaat
+aatattggctattagcaacaagaaggagaatcctcattaagttagcaaccgcagggggta
+ctgcagtccaaggaggtttcattggagagagcagtatgaaaacggcaattatgattgtga
+gattcgctgaagattgtgtctctgattttcctagatagaataagctatagctacttaatc
+aactcttaactgtggagactatcctgatgatctgaataccccatttacaaaattccatat
+caatgaggctaacgcttaaatttcatttctccatcgtaacaaaaatcagcctttttatac
+aagacaaaacactgcttccattacgggtagcaatggttgctcgactactggtagcgtcgt
+gatgtggtgataaagctgtcttgcgtttatacttaaacaaattttgacctgacataatgg
+agcgacttatcggatgttgccgatctttagggtcatctattaagcttatacgaaaaaggg
+acaagcacgttacgtaatctggtaggactgggtacctagaaacgcaagaggaggcgaact
+ccaatatctgtaagaacagaaaaatacaggagtccttttcatttttcaagttaacaatat
+aagtaggagcttagagaggcttgcatgaaaatcgttaggaattacagaataggcagagag
+tggggcgtgtagactacattcttcaggccccacaatatgggttataggttaaactgcact
+ttttgcgatctcccgaaatactgtcgttctctgcgaaccacgctcgttccttttgctgta
+gtccacgttcatccaactattcagataaacaagatcgcagaattaaagcttaaccatatc
+ttgatagcccatcgtgtatggggcatgtatgtgcaaacaaaagacctcaatcttgtctgc
+gagagggaggaaaatttagacaaacataattcattctttcgactggacacgctaaggttt
+ggacaaactttgtatctatatctggaggcctgtattccagcccttcttttaataagattt
+acggcttaaactatggatatttgccaggaaatgacactgctattgacaggaacataattt
+tgattcaaacctcattgttaattattttatatctcctgtttttatatcagaatgcttctg
+tcctagaaggcatactcaaggtgagggctcgaggaatgaatcataatagaccggccccta
+ttaatattggttcaattctttcttacataacgcggaatttgattgcacgaacaccgggaa
+cacataaccgtatagcgcccgttatgctagtgcctagcgactgggaccgtggagtctata
+tcgtctttctaccattattaatctaaggatataccactttaagtcctttcaactaacata
+aggcgcattccatgcgctaaggaccttgaatttattatttcttacatgataaaagatcga
+gtcgacgggaacaaaaggctacgtactcaataaagtgcagtttactaagagccctttttc
+tggcttgtggagactatcataacatgaagatgttttgacattcaatagtttgcaaaacaa
+acttactttgtgtagtattgaacgagatctttccaattgccccatagcaggaatagttat
+atattgcagatcgcggtgtaacgcactccaaatccatcgcggtgtgtgagggtaagcgac
+ttaaagaattacggtttttgatcaaagcacagtgagagttgagcaaattacagttatacg
+acttaattcagtctccataaattgaaacgacacttcttaacgggaggaccagacacgttc
+attaagtgaggagtgcactttttgactttaaaaacatggtaatcaatttaaaccacttga
+tatgtatatgaacagatttgaagttatttctgttttaatacactgggagttctgtcaata
+tcgcaggaaccgcctgacgtcccctatcacacctcagagggtaaagggacaggggaaagg
+gtaatcgaggggtagggaacgtagttggcacacccaatggacgaataaatgctgccatat
+ccacggagggcgggattgcggttgattttaaggcgatggtaacctgaatgtaatagatca
+tcaaatgcctcctccactggaaattactgcgtacatccgctgagaattgcaatggagtgt
+ctcggtttttctttaaacaaaaccaaattgacaacttcatagtataatttttgcacatta
+caagcgttaattaacaaacttactttgctgttagctgcctatatttgtccgacaatataa
+ctggatatctctgcgagaactgtaaattaacggcacttggaacataatagttcctattgg
+taacgacgttgtaggcggcaattatccggtggaagaattgacaactgcagttgaactgca
+tgaaagtcaaatctctcgtaagtataactttagaagactccaaggtacccagaacctctt
+cagcggacacgatcgctatcaatcaataaggattattcactgaaaccgctcatatctgga
+ggtggacgtttttcttcgaaaagcttgtcaaaggactcatcaaatttttggccgtgctaa
+tcgacacacctgttattttcatgaccggataggacatctcgcggaaattcgggtaacagc
+tgggtagatataggacctcccctacgtattaatgataagcctgtcataactagcttggtt
+taccgaagagacaataaacattcgagcgctcgtgccaaactcggtgcattacgtttgaat
+aaatcggtaacatgtactattactctgcctaacggcacttacccgtttgggtccatgggg
+taaccgctcgatgttgacagaattatgctaaagtcgtttaagatcccgattaccgaaaat
+ctggttatgtctgagcattcgtacactgcgtattaagatcaggttgaacaggttcctaac
+aaattttgtgacctaaagtgaaactaggtcgtactctgggcatgttttatgtcgtggcgt
+atgcatgtgctgacacttctaaaaccaaattaaggctttatccaatatgggtccttaagt
+gctaaacatcattcacaatttcaagacagattgttggtcttgtcgattccgcatctgtcg
+ccaaattgacacatcgtaaaccaggtacatcggtaattatatgttgactaaactaccgtg
+tgtattctggctctaggtacggcgaacaagtacgatgtgcttaagaagccctcaccccag
+acgagcccgcgtaggtcacatcagcagatcctaagtaattccgttttattgtcctgaggg
+agtaggatcgacgaactctacaagtcgctttgtcgtgccttataggctatttcgggtcaa
+tgtagcgtcaaatgaactattgtcatctgtacgagttaactaagtgtctatcgccaacta
+aaagacgtctcgatggttctttatgcggacctgtcatatcattgactggcacttgcttac
+atccaaataacacgtttgttagcggatagtcgttaagtgtgcgcaagatcatgaggcggg
+gggggtaatatttcgccctctacatgataaatgaataagtaagaagatgatctttttgtg
+gcggtaccttaagcgtactcctgtcgacgagttactactaaaggaatgtagggttctgga
+tctatgaaaagcgacctccatatatatacgggcctaagcggagtaaaataagtgatcaat
+ggactaacattgaaatgttagtattgtcgaccattgagggctggtaaatcttatttacgg
+gcgtgggaaaacgaacgtgatatggtttagcatgggatgcaagcactcgttaatgcttac
+tttagttggttgcgggaacaacaggaggctatactaactggtagcgttcttgcttccatt
+atgttattattataattaaaaataagacatatggtagagttgtagtcagggtggatcggg
+ttgtctataacgttggaataatcaaaactatcgttaacaaaaacgaaatttaagtcggtg
+cggtggaatgcgcctacctcatgtgcaccacacattcacagcacacccctcattataggc
+aaggaagcaaacaaaaaaaagttaatcgaccgtatccgaccttaaattttaaaataaata
+gaaacacttagcggtaatgaaaagataggactaaaattcactagtatcctggaacgaggc
+aacagagttatctagatggtaacgaggtgctgcatcaagatgtatgatttttggtccgct
+gtgtggaatacctctattgatatacaagtgactttctcggtaataacgcacttcacaatg
+tgttgtttcttttctatgtattttgcaagagaaagaagcttagtataggtacacctcaga
+gatgtttcgtgtaaatcgtatcacatggtataactgcaggaggaacattatccaaattca
+ccacaattactaatccacccttttacttttactaaagatatattaattctcatgttgtct
+gaattgtataacccggtaccctgggagcgtatcgaaggataccaattgaagtcctcgagg
+catgttacaacacacgacttccttccgtctattcagacactcaacgagactaacttttcc
+taggtaatcaatgatattgggtaactcgtggcatcttatagttattgatccggctctttt
+gtagatcctgtgcgactcgtgcgctaattaagactggctctcttgcgcaggggatacgtt
+tattctacgtacccgatttggttactactaagcggcctttcttcaaacttgcagttgtga
+cttacattcctatttcttcaaagcagggaagggttacagggagagacttattgagatacg
+attggaatttccatgtacaatcgttaatacgcttgtagaccagcaactcagtatagagat
+ccgtttcctaaagggtgagcggtaggggcaaggcaataagaaattactaaaaccctagtt
+gttaatataagaacgattcgaaacaataggattgcccaagggggtgcgaacatggtgtaa
+atcaaagagaaataggcattgttaaaacccgcacgtttctagtacgcaagaggaacgtcg
+gtaaccagttctcaaagatcctaacctaaaaggggcttattctactttttccgacactca
+atggacgagacaaacatgaacggatagctttaggtctcgttgaatgcaaagaatagaatc
+gttattattaatcggtttccattatctatatgcggtatagatctccgagaggaccctgta
+aactagctctgcggtttaactggtgctaatagaccgccactatgttattgcttctagctc
+ctagcgtcttatcatgttatacattaatgtcgcatattggacagtagccaggcttggatg
+gatcgccgacaaaaagaaaagactttccctgtaaggacttaactattacatataacttgg
+atcattaatctgcaaattagagtaacggtctttcaccagcttcatattccaacgtggcgc
+tagtcgatatcccatgaagtttaaaactagaattggcagtctcacttcacagtgcgtatc
+tatacgacaaaagtggtcgatttgcataaatatcttatcgatattcaggttattaccgat
+tccttgctaacgctagaagtcacaccagagtaataataattccagacacctgtgaaataa
+tcggtcactacggatagactagtaacgataatacgtatagtccataaaagttgaatttta
+ggggctaaagatattagcaatactggtctagcctaatcgtcgatagcaaagggctgtgag
+gatttctcctacattttcgaccaattgtatcgataggaatagttacagtcacgcttgtag
+atgtaagagatgacgttattcttagggttcttaagtcggggggtaatttaagaccactag
+taaaggtagaggcgtacacagtaaacgatattttgaaatcgtcaaaaaaaagtttacaac
+atcctttaagttagcaactgattttagtggcaaccttaacggttgaattgatctactaat
+acaggcctacaccgaagggtacagataatgattcttactaccctaacatgatagagtcct
+gtcctatctcataggtcgacattttaaattcgtaatgagcaacgaagatcgtttcccaat
+ttgcaacattcacttatagacttcaggttatttcgtgctaacattaagatagaatataat
+cagtcgttaagaaactattatccagctttcgtcaaccataaagattaaaaactgaaactt
+ggcaagatatgaatagctatcctgctttaaccgatcgtatgagatgctttgtagcaagaa
+aagtgactagcacttgtgtttagtaaagcgggagagtgcggtaattaatattaatatact
+attaagctacacagcaaaggctgcaataatgttagtaagtagaacataaaggtattctcc
+acaagtaataaatagtgtgagctaattgactaacttaactctcgcgacaagtgatgtgga
+taagatgactcatatcgtctttttctgtagtgccgacatcccacctggatcgaacaattc
+cttctagttatcgactttgattacctatcctattaaacagatagggttgtaaagtcagaa
+aatgatcggcttgcgttggtctaccatagctagagttagaacgcgtagatagaggccttt
+tgttgccaacgtgggggtgggatgagtctgggcgagcgtgactttctttcgtgtccgaat
+ttgtttaacatccattagattagatgtttgtgttttgggtctgatgtcctaactactttc
+tcagtgaaactaatgtcatcatccaagtaaaatagtccgatgaagtctccgttttcggcc
+gaagcttgtctataacgtatataaagtcgctgaatttagaacacaccttatctatgttgt
+aaagttactttattccaaaggacgtgcacgaagcgtgagtgtgggaaggaacttaaagtc
+ggatcactcttgtcagtgtagataagaatttctttcatacttcactggaatccggcgtat
+ggatatctctaccgcgtcatctggtggtgtctgcggtaaaaagtcttgctgcacgagtct
+gagaaatttttggtgccatcacatcgtaactgtacaacgaacaaatagcatcaggccttc
+ttatccagcgtgaagtctaattatttcacaagctttcctaagtatgtaaatccctcactt
+aatgatgcttgcgccaatgaggatagaggacattgcatgtacgtaggactattctccaag
+gggtcttctattttgttagcgaaaattgttacagcctaatgttagagcggcgtacgactt
+tataccagatactttcattagatatgcaaatatccaattaaatcatagtagtatcgtggt
+atggacaatcaaaaaagacccgttgtgatatgatgtttttctagttcgttctcatatata
+tagatcaacaatgaataatctcatgatctataaccgatgtatatttatattccggttgac
+tgctccggtgcaattcactacggacactaatgactaatatggcgcctttcatcagaaacg
+ctaaatatgattaatgaattaagggagtattatctaattattagagagtagcagttagtc
+tgatattttcggtgtatgtgttagccgttataatgctgtctttttatcagtgagaacagg
+gagtgtgtagtgttgtatgcttcactttatgactctggttatatccctcggagaacaaga
+ataagagtacgagaagttcggtcattgaggatgaaatagaaccgctagacgaatggactc
+acgtttataaaactatgtatcacagtactacagctaactctgaagtccgagaagcttttg
+taggacaaaacgttataagtacctttcgcagaatacggccgtgcatacctgttataaggc
+gtagtagggacaccatgctatccctcatatagagctacactaataccattacatggtgac
+tatcgtttacggccatcatctgtaagcgatcatgcctcgttagcatccgtacaatctcgc
+atggcgtcactgcagaaaaaccccgtgcggattttgagtcagaactattcgaagcttctc
+aatccttttccattatggcatagcaagtgacgactcgtcagccatgggaataatagcact
+aatccgattacttatgaattagaacccacatgaatgtgattctgcgaattgtctaagaat
+ctaatgattttccggtgaatatggttgttgttatttattgaacttatattattaacatca
+cccttcgttagtgatagtcagctatttccaagaggttccccgagcatttttaccattctc
+tagtcatacaagttggagcgcttttaaatctttaggctgatcaaggcgttttgtctagaa
+ttctgcagatgttagattcgtgtgcaatccctcttgcatgtcagtaacaggtcacccgtt
+tttcgttacatatgctggtaaaatattcatagtaataactacaatacttgatttgttacg
+taatgctcgtacataacacaatcgtattccacggaacagtaaagctctattattctgatc
+gagcctaagagaggatcacactacgctattaaagtcacgttcacgaaatctcaaacctca
+actgctggtgaccagttatagacagtgtaattccatattacatgtcaggcttaagctaac
+ccgagcctttatataagctataatcaagaattagattggagtgcattttagacttatcta
+tcgaaatagtgatagtaagagtttatatgacctgatctagactgatgttctcttccacaa
+cagccttaaggcgtggagcctttcttatactattaggtcgcgtcgagagccctattcgta
+atgttaacgacactagactaatatacaatgagctaagaataacacaagtcacaagataat
+ttacaaatcatatatctacagtccacaaccatcactagcgattgcaaagcgttattggta
+ctaccgctctaaatcggtatgtgcaagacgcgttaactggttcaagcctctcctgctcgt
+gagactgaaagaaatcgaaaatatggatgtgcctaattgttcttgtgagtcatgtgcaac
+tatacagtttagtttggtcaagactatgcaactattaacagcatgtgcgcattgaatatt
+tggtgtcgattgataaatgccccaacgttccatcacgtctataagccgtgttactaatgt
+gtattagtgcatacctattcagaccatagttcaactgttggactgaaggcccgtcttggg
+gttcgtgaatgagagtgcagtttcttgtcttttccttaactgacctaaatgaaggcaatc
+ggtttatctagagtcatgcttaaggtgaatttcagccaatgggctcccattgagctagta
+tggtgctttacctttgtaagtggtggctttccttggtgtgctgactttaacacggcagag
+tgattatccgaagaatggataataagacgctggcaatattggctaataaagtccgatgag
+tttcaatcatgactgcgaggagatccatgcggtgtacctaaacctacatcgtatgtattt
+gctgacgttcattcttgatacataaagatccgatatcggtccactttgtttaccaaaagc
+cctaccttcgtaacgatggaaatgtgaatgagagtgaaatacacgatggggatattgccg
+gtgagtacaagttagaccacacattagaactgacctatattcgtcatcatagagatggag
+tatgaattgattctgcgaagtacactggctttacgagtatctagacgccgcggtatatct
+cccgtcaatactatgaaggtatatatatagaggctgaaaattcatgttcaatcctctttc
+taagagtgagtgggagccccttctgttgtcggagtaaaaaggcattattcctcaaattgt
+cagaagcaaagtatacgtgatgtttgcttagaacaaaagagttaccttagggtaggtaaa
+tctcgattcaccgagagaagtgattttggcggtgtgcgattaattcttttgatgacagat
+ctcattattttatatagctccctctttgtatttagagtttgcgtaggtaacctggcaaaa
+ccatatcccggggggagagtgcgctgaacattttatacgatgtgattactcaaaggataa
+ggttcgaggcctctatactcatggaactatcttataattataatggatcgtggctcattc
+cacctatccaaacttctttgtgatctgatgctacgagtgtgaacaaacgtacatcttcta
+aggaatttgggacgtttcatagctcgcatttcattcctgaaaacttaaatatttttaaaa
+attgattctactgcgaggaactaaggtgtagacaagcccttagtaaccggtggatgtcgc
+ttcagttttatagcaaacattattcaatttcagtcttgactgaaattagtttgttagtgt
+tagaggtccatatgtcacatgcatatggtctagatgccattgtacagtaataccttagat
+tagtattagcggcatgcgtacttggatttcacttgtaagaatgagcttaggacggtcgcc
+tgtagggctgcaaataggaatacttacaatttttgatgacttgttagcatatcgctatca
+cccataaaaaacctgatacttgatgagcgggtgattgagactatgtactgatataattca
+atagctccaatagatgaaacagctatgcgcctatttatgtcaaataatcgatgtgataca
+agcttagagctgaacgagcgcgagtggaattagcggtgatctctatcctaaaaagccacg
+aaatcgatcccagaagctaatacccgaggtgtcaagcttgagttcagttaaatttgcatc
+tcatgccccacgaagaatgggtagagagtttgaaggtgcttctggattttcctaagtacg
+tggtaaaaatttgatgtaaatgaacacctcctaatggttgtgttaaccacaaacccctgg
+gtgaatctgattagccaacccagtgatctgatttcagttgtcaaatctcttttttataac
+taccttttgtttccataatttaaccggatctcataatgaacaaacgggtagaataatggt
+agcacatagcgagcttgtctattcagaaatatggcctactcagaatgtattctccaaatc
+agtgttatgcgaaacgtaattttacgtgtaataatgatgatttcttatcggttccttgta
+ctacaatactcttgcccaacaaatactaagcataacagcaaaattcgaatccccctcctt
+ttaataaatggtttttcaatatagccgattcgtattcgttagtctttcaccaactattaa
+cctggcatctaattaataaaatcaccaaaggactctataatatgacagtcacttcggcct
+cttttaagacagttgattattgcaggtccgcaattgatggtgacatgcacaattagttag
+aatccgactatggagacaattaacaattgtagtgcccatttggtccagttgacttcaacc
+acgagttataaaggtattttaatttatagtcgatagtaccaacaacaagcacaatcataa
+ttatgttagaaaacccagggggtaatgctctaaatccagctttaaggccagagtgcacta
+tgaaatcgccattgatcattgtgtcattcgctgaacttggtgtctaggaggtgccgagtg
+agaatatcagataccttatgaagcaacgattatatctggactagatcatgatgatcggaa
+taaaacattgaaataagtccttatcaaggagcataaacattttatttaatttatacttcg
+taaataaattcagaattttttttcaagacattaatctgagtaaatgacggctagaaaggg
+ttcctactcgaatcgtagcctacgcatgtgggcagtaacctggcttgcgtttttactgaa
+acaaaggttcaccggaaagaaggctgccacttttagcttcttgacgatctttagcgtcat
+atttttagattagtcgaaaaacggaaaacaaacttaacgaagctggttgcacggggtacc
+gagaaaccaaagagcaggacaactccttgatcgggaagaactgaaatagacagctgtcat
+tttcattggtcaacttatcaatataacgaccaccgtagtgacgcttgcatgaaaatactg
+aggatgtaaactatagccagtcaggcccgcgtgttgactaattgatgaagcaaacaaaat
+agccggtattcgttaaaaggaacgggttgccagctacagatatactctaggtatatccca
+aacaagagacgtcctttggctgttgtaatcggtcataatacttgtcacataaacaagatc
+gctgaattaaacattaaacagttagtgatacacaatcgtggttggggctgggatgtgcaa
+taaaaagtcatctatcgtctatcacagagcgacgtaaatttagacaaacattattatttc
+ttgacaatggaatcgataagcgttcctctaacttggtatatatatctcgaccccgggatt
+ccagccattcttgtatgaagatttaaccatttaactatgcatagttgaatggtaaggaaa
+atgatattgactgcaacagattttggatgcaaaaatatttgtgaattattggttatatac
+tggttgtatagcacaatcattaggtcctagaaggcatactcaacctcagcgagagagcta
+gcatgcataattgtaccgcccatattaatattcctgaaatgatttcttacattacgccca
+atttcagtcatcgaacacccccatcaatttacccgatagagaacgtgatcatacgcaata
+ccctatgcgaacgtccactctatagcgtctgtatacaatgattattcgttccatttacaa
+cgttaagtaatttaaacttacataaggacaaggaaatccgcgaacctcctggaatgtatg
+agttatttatgcagttaacttcgtctcgaccggaactaaaggcgtcgtacgaatgaaagg
+ccacttttagaagagacctttgtatccattgtggagaatatcataaattcaagatggggt
+gtcatgctattcggtcctaaacattcttaatggctgttctattgttagtctgatttaaaa
+tggaaccatagcacgaatagttagatagggctcatacccctgtaacgatctacaaatcct
+tccccgggtgtgtgcgttagcgacggaaagttttacggtttgtgatcaaagaacactcac
+acgtcagattattacactgatacgaattatttcagtcgacagtaattgaatagaaactta
+ttaacgccagcacctgacacggtaagtaaggcaggtctgaactgtttgactgtaaaaaaa
+tggtaatatttttaaaaatcttgatttctatatcaaatgatgtgtagttttttctctgtt
+attaaaatcccagtgcgcgaaatttagatcgttacgactcacgtacaagatcacacatca
+cacgcgttagcgaaagcggaatggctaatacagccctacgcaacgtagtgggatcaacat
+atggacgaatttatgctcaatgagccaacctcccccgcattgcggttcattttaaggcct
+gggtaacatctatcgtttagataatcaaaggaatccgactatgcaattgtctgacttcat
+ccgctctcaagtccaatgcaggcgctacgtgtttctttaatcaataccatattgaaatcg
+taatacgataattgttgctattgactacaggttatgaaaaaacttactttgcgggtacat
+gcatatttttgtaccacattattacgcgatatctctcagtgtactctaaattaaaccctc
+ttcgaacattttagttcctattcgtaaacacgtgctacgcggcaatttgccggtcgtaga
+atggacaactccagttcaactgcatgtaactcatagctcgcgttagtataaattgactag
+tagccatgggacaaagtaactagtcagcggaaaagatccctttaaagatatatgcaggtt
+gcaagcataaagctcattgctcgaggtgcaccgtggtattccaaaagcgtctctatcgta
+tcttctaattttgggccgtgagaatcgaaactactctgatttgctgcacacgttaggtaa
+tatcgcccattttcccgtataagctccgtacttatacgaactacacgaccttttaagcat
+tagccgctcatatcgtgattcgtgtacagatgagtctattaaaattacagacatactcca
+tatctcgctccttgaactttgaataatgcgctaacttgtactatgaataggcagaaccca
+actttcccgtttgcgtcaagcggggaaacgatacatgttgtcagatttatgattatctag
+ttttagatcacgtttaccgataatcggctgtggtctgagcagtcctacactgagtattta
+cttcagcttcatatcggtccgaaaaaaggttgtgaccgaatgtcaaaatacggagtacga
+tgggcatcttttttcgagtcgcggttgcagggcagcaaaaggcttaaaccatttttacga
+tttttactatagcggtcatgaagtgcgaaactgcttgcaaattttctacacacattgtgg
+ctcttgtccttgaagcttatggcgaaaatttgaaacatagtataccagggaaagcgcgaa
+ttatttggtgactaatagtccgtgggtttgagccatatacctaacgccataaactacgtg
+gtgctttagatgcaatctaaacagaacagaaagcgtagcgctcatcagcacagactaact
+ttttcagtttgagtcgccggagggacttcgagacaagaacgcgtcaagtcgcttgcgcgg
+cacggattcgattgggcggctcaatcttgcctaatttctactattgtcagctgtacgact
+gtactaagtgtatagccccaaataaaagaagtatcgatgcgtctttatgaccaaaggtct
+tataattgaagcgcacttccgttcatcaaattaaatcctggcttacccgattctccggaa
+gtctgacctagagattgacgacggccgcgtattattgagacctcttcaggattaatcaat
+aacgaagtagttgatctgtttggcgacgtaccttaagccgactccgctacacgagtttct
+actaaaccaatgtagccttatgcttagatgaataccgtcctaattagatattccggcata
+acagcagtaaattatctgttcaatggacgaacattgaattgttagtattctacacaagtc
+aggcctcgtaaatattaggtaaggccgtgggataacctacgtgatatgcttgagcttgcg
+ttgcaagctctcgttaatcattaatttaggtgcgtgagggttaaacaccagcatattcta
+tatgctagacgtcttccttaaaggatcgtagtattataattaataataagaaatatggtt
+gacgtctagtcagcgggcatacgctgctctatatactggcattattcaaaacttgacggt
+aaaaaaacgaattttaaggcgctcacgtcgaatgagccgaactcatgggaaccaaaatgt
+cacagaaaacacctctttattgccaagcatgcaataaaaaaaatgttaatagtacgttta
+cgacattttattttataataaagagaaactattacacctattgatatgataggacgtaaa
+ttaacgagtagcctgcatagaggcaaatgaggtttctacatggtatagacctgatgctga
+aacatcgatgagttttggtcccctcgctcgttgaaatctagtcatttactactgtctttc
+gagctattataccacttcactatgtggtgtttctttgctatgtatggggctagtcaaaca
+tgatgactatagctacaactcagagagcgggcgtgttaagagtatctcatgctagaactg
+cacgacgaacttgatacaaagtaacaacatttacgattccacaaggtgactttgaagaaa
+catagtttaattctctgcttcgatcatttctataaaccggtaccatcgcagcggatagat
+gcataacatttctactactccaggcatcttaaaacacacgtagtacttcactagattaag
+acacgataagtgtataacttggcagtgggaagcaaggagattggcgaactcctggcatct
+gttacgttttgttcaggctcggttgttgataatgtccgactcctgccatattgaagactc
+gctcgagggagatcgggattcgttgattataagtacacgtgttccgtaatactatgaggc
+agtgattcaaaatggcacttctgacttacatgactaggtattattaccacggaagcgtta
+aaggcacactcttatggacttaagattgcaagtgccttcttctagcctgaattcgcgggt
+tcaacacaaactctctttagacatccgttgcctaaaggctgagacgtaggggcaaccctt
+taactatgtactaaaaaactagttggtaatttaacaacgtgtccaatcaagacgatgcac
+caacgcggtgcgaaaatcgggttaagcaaacacaaataggaattgtgataaaccccacct
+tgagaggtcgcaagaccaacctcgggaacaacggctctaagagaataacctaaatccgga
+tgagtagactgtgtaactctctaaagggaagtgaaaaaaagctaagcatacatttaggtc
+tcctgcattgcattcaattgaatcgtttgtattatgagctgtacagtagctatatcagct
+atagttatcccagaggaacaggtaaactagctctgagcgtgaaatccggatattagaacc
+cctagatgggattgattctagctaatacaggcttatctggttttacagttatctagatga
+ttggtaaggtgaaacgcttggtgccttccaccacttaaacaaaagtattgcccgggaagc
+tattttctaggtattataaagtcgagcattaatatcaatttgacagtaaaggtctttcac
+cagcttcatatgccatagggcccatactcgatttaaattgaacggtttaacgagtattgg
+aactctcacttataactgagtagctatacgaaaaatctggtccatttccagaaatttatt
+atcgatttgctgcttagtacccaggaagtgataacccttgaaggcacaacactgtaataa
+gttttcctgtcacatctgtaatattcggtcactacgcattcacgactaaagataattact
+atactaattaaaagttcaatgttagggccgaatcatagtagaaattctcgtctagcctaa
+tcggacttacctatgggctgtgaggatttatcagtatgtggacaaaaatgctagagatag
+gtatagttaaagtcaccatggtacatctatgtgaggaagtttgtagttcgcttctttagt
+ccgggcgtttgggatgacaactactatacgtagagccgtactcaggattagatagtgtga
+aagagtcaaataaaagggttaatattaatttaacgttgcaaatgtgtttaggccaaacat
+taaccgttgtagggatattctaatacaggccttcaccgaaccctaatgataatctgtctt
+aataacattaaatgattgtctccgctacgagctcttagggcctcattttaaatgactaat
+gtccaaagaagagactttcccaatttcaatctgtcacgtatagacggcaccttagtgagt
+catatcattaagatagaagattatcaggagggaagtttctattatcaaccgttacgcaac
+cataaacttttaaatctcataatggcattgagatcaagagctttcatgatggtaaagttc
+gtatgtgatgctggggagctagatatcggtataccacttcggttgtggtaagcccgagtg
+ggccgttagtaatattaatagacgattatccgacaatgcattcgctgaaataatcttact
+taggagaaattaatgctatgagccaaaactatttatgtctgtcacattattgactaaagt
+atctatcgacaaaactgatgtccataagttgtagcagatagtcggtgtatggtgtcacca
+atgaaaacctcgagcgaaaaatgaattatagttatccaatttgagtaaattgcctattat
+acagataggcttgtttagtcagataaggttccgcttgaggtgctctaacttagcgagagt
+tagaaagcctagtgagaggcattttggtgccaaactccggctcgcatgagtaggccagag
+agtcactttctttcgtcgaagaagttggtgaacagccttttgattagttgtttgtcttgt
+ggctatgtgctactatataagttagaacgcaaactaatctaatcagcaaagtaaaatagg
+accttgaacgagacggggtacgccgttgaggctcgagatagtagataaactagaggaatg
+tagataaaacattagctagggggtttagttactggattacataggaagtgcaccatcacg
+gtgtgggggttcgtacgtaaagtcgcatcaatattgtcagtggacttaacaagttcgtgc
+ataatgaaatcctatacggactttgcatatctctaccgactcatctggtcgtctatgcgg
+gtaattgtattgctccaagtggatgactattttggcgtcccagcacatagtaaatgtaaa
+tccttataatagcataagcaattattagactgcgtgaagtcttagtagttctcaagcttt
+acgttgtatgtaaataactcacgtaatcagccgtccccaaatcaccattgaggtcattga
+atgtacggagcactattatcaatgcggtatgcgattttctgagcgattattgttaaagac
+ttagcgttgagccccggaacacttgattacagattctttaaggagttatccaaatatcat
+tttaaataatagtagtatcgtgctttggacaataaaaaaagacccgttctcttatgttgt
+tttgcgacgtacttctctgatatatacttcaactatgaagattctattcatcgataaccc
+aggtatatttatatgcccgttcactgcgcagggcaaattatctacggacaataatgacgt
+agttggacccggtaagaactaacgcttaatatgattaaggatgtatgccagtattatctt
+attatgtcagagtagaagtttctctgagattttccgtcgttgtggtacaccggatttggc
+tctctttttagaactgagaactcggagtgtgtagtcttgtttccttcaatttatcaatat
+gcttttataccgccctcatcaactataacaggacgacaagttccgtcttgctccatcata
+tactaccgatacaccaatcgtatcaagtttagtatacttgctttctctcttctacagctt
+actcgcttgtccgagaagcggttggtgctcataaagttagtagtaaatgtacaactagta
+gccagtccttacctgtttttacgactactacggacaccatgagatacagaagttagtgct
+acaattataccattacatgctcaatatcgttgtcggccataagatcgaagagtgcatcac
+gcgtgtgaatacgtaaaatctaccatcccgtcaatgcacaaaaacacactccccttgttg
+actaacatcttttacaagaggctaaatcattgtccaggatcgaataccttgtgtacaatc
+gtcacccatcggaagaataccacttttccgatgtagtatgatttacaaaaaacatctatg
+tgagtaggccaattgtagtagaatatattcatttgaccgtcattagccttcttcttaggt
+tgtgtacggatagtaggtacataaaccgtcgtgtggcatacgctgcgatttcatacagct
+gccaacaccttttttaccaggctagagtcagaaaagttggagccatgttaaatagttacc
+atcataaaccactgttgtctactagtctgatcagctttcatgcctgtgcaagcaatatgg
+attctcacgtaatggtaacaactgttgcgttacttaggctggttaatttgtcagagtaat
+aaatacatgtcttgttgtgtttcctaatcctcggaaagtacacaagcctaggaataggaa
+aagtaaagctcttttattctgatagtgactaactcaggatctaaatacgcgattatacta
+accttcaccaaagctcaaaaatcatctgctggtgaccagttatagacagggtaattcaat
+atttaatgtctcccttaacatttcaccagcatggattgaagatagtataaagttttacat
+ggcagtcattgtgtcacggttctatacaaattctgatagttagacggtatttgaaatgtg
+cttctagcatggtatcttacacaactgaatgaacgactggagccgttcgtatactatttg
+cgagcctcgagaccccgtttcctaatgttaacgaatatagtataatataaattgtgatat
+gaataacacaagtaactacagtttggacaattaattgttctaaactaaaaatcattcact
+tcagatggcatagagttatggctactacacatataaagcggtatgtgaaacacccgtttt
+agccggaaaccctctactgctcgggacaatgaatgatttccaaaatatggatgtgcagaa
+ttgttagtgtgactcaggtccaaatagacactttagtttcgtcaagtcgttgcaaagttt
+aaaaccatcgcagcattctttatttggtctacattgagaaatgaaaaaacgtgacagaaa
+gtctagaagaactgtgaataatgtctattactgattaactagtaagacattagtgcatct
+ggtccactgaagcacccgcttggcgttaggcaatctctgtgaactgtcgtggctgttccg
+gtaatgtacgaaagcaagcctataggttgatcgagtcgcttcattaaggtcaatttcaca
+atatccgatcacattgtgctaggttcgtcctttaccttgcttagtgctgcatgtacgggg
+tgtcatgacttgttatcggcagactctttatcccaagaatggataatatgtacatggaaa
+gtgtccataattaagtcccttcactgtaaagaatgactgccacgtgatccatgaggtcta
+cagaaaccgacttacttgctttttgatcaacttaattatggattcataaagttcagatat
+cggtacaattggtgtacaatatgaaattaatgaggaaacatggaaatctgaatgacagtg
+atagaaaagatccccatttgcccggtcagttcatgttacaccactcattagtactgtaag
+tgtttcgtcagcattgagatccacgatcatgtgtttatgccttcgaaactggatgtacga
+cgatcgagacgaagaggtatatataacctaaatactaggtacgttgttagagagacgatg
+aaaattaatcgtcaatacgctggcgaacactgagggggacccaatgctcttctcggtcta
+aaaaggaatgtgtcagaaattggtcagttcaaaagtagaccggatctttgcggagaacaa
+ttcacggaacgtagcgttgggaaatatcctttctaccacacatcggattttcgccctctc
+ccattatttattgtgttctcacatagaattattgtttagacatccctcgttgtatggaga
+gttgcccgagcgtaaaggcataatccatataccgccgggtgagtgacctgaaattgtttt
+tagttgggatttcgctatggattagcttacacgaagagattctaatggtactataggata
+attataatgctgcgtggcgcagtacaccgttacaaacgtcgttcgcatatgtggctaaca
+cggtgaaaatacctacatcgtatttgcaatttcggtcgtttcatagagcgcattgaatta
+ctcaaaaattatatatgttgattatttgattagactgcgtggaaagaaggggtactcaag
+ccatttgtaaaagctgcatctcgcttaagtttgagagcttacattagtctatttcagtct
+tctaggaaatgtctgtgtgagtggttgtcgtccataggtcactggcatatgcgattcatg
+acatgctaaactaagaaagtagattactattaccggcatgcctaatgcgattgcactgct
+atgaaggtgcggacgtcgcgcccatgtagccctgataataccaatacttacatttggtca
+gcaattctgacattatacctagcacccataaatttactcagacttgaggacaggctcttg
+gagtcgatcttctgtttgtatgcatgtgatcatatagatgaataagcgatgcgactagtt
+agggcatagtatagatctgtgtatacagttcagctgaacgtccgcgagtggaagtacagc
+tgagatctatcctaaaatgcaaccatatcgttcacacatgatatgaacccagggggaaac
+attgagttcagttaaattggcagcgaatcccccaagaagaaggcggagtgacgttgaacg
+ggcttatggtttttcagtacttcctccgtataagttgagcgaaatgtaaacagaataatc
+gttgtgttaacaacattaaaatcgcggaatatgatgagaatacacagtgtgagcatttca
+cttgtaaaatatctttggtagaacttactttgctttaaatatgttaaaccgatctaataa
+tctacaaaacggtagattttgcctagcacattgcgtccttctctattcagatagaggcaa
+tactcagaaggttttatccaaagcactgtgttgactaacctaagttttagtctaataatc
+atgattgattataggtgccgtggactacatgactcgtccacaaataatacttagcagatc
+agcaattggccaagcacccgacttttatttaatggttgtgcaatagtccagattcgtatt
+cgggactctttcaaataatagtttcctggcatctaagtaagaaaagctcataaggaagcg
+atattatgacacgctcttccgccgctgttttgaaacttgagtattgctcgtccgaaattg
+agggtcacttcaaaatttactgagaagacgaagatcgactaaagttaaaatgctagtcca
+cagttggtcaagttgaattcatccacgagttatatagctattttaatttatagtcgagtg
+tacaaaaaacatccacaataagatttatcttagaataacaacccccgtatcatcgaaatc
+ctccgttatggcctgactcctcgagcttatagcatttgtgctggcgctcttgccaggaac
+ttgctcgcgaggtggtgacgagtgagatgatcagtttcattatgatgatacgattttatc
+gcgactagttaatcatcatagcaagtaaaatttgaattatgtcattatcatgctccatta
+acaggttatttaattgatactgacgaaattttttcacaatgggttttctagaatttaata
+tcagtaattgaagccttcataggggtcctactagtatcctacacgacgcaggtccgcagt
+atcctggagggacgtgttactgattaaaagggtcaaaggaatgaaggctcacaatgttac
+ctgcttcaccatagtgagccgatgagttttacattagtactaaatcccaaatcatacttt
+acgatgaggcttgctagcgctaaagagaatacatacaccaccacatagaattgttagcga
+tgatatcaaatagactcctggaagtgtcagggggaaactgttcaatatttcgtccacagg
+actgaccaggcatggaaaagactgacgttggaaactataccatctcacgcccgacgcttc
+actaattgatgatccaaaaaatatagcccggattcctgattagcaaagggttcacagaga
+aagatattatcgacgtatatcccaaaaaacagacgtaatgtgcatcttcgaatcgggatg
+aatacttgtatcataaaaatgtgacctctagtatacaggttaatgttagtgatacacaat
+actcgtgggccatgggttctcaaataaaatgtaatattgcgtcgatcactcacccacgta
+tttggtctaattatgttttatttagtgacaatccaatagataaccggtcctattaagggc
+tatatttttagcgaccacgcgtttaaacaaaggattgtatgtagatggtaccagtttaat
+tgccagtgggcaatcctaagcaaaatgagattctatcctaaagtttgggcttgatataag
+atttcggatgtatgggttttataatcgttggagagctcaatcatgagctaatacatggat
+ttcgctacctcaccgagagaccttgcatgaagaattctaaccaaaagtttaataggccgg
+attggattgagttaattaagaccttgttcagtcatagtaaaaacccttaaattttaccga
+ttgacaaagtgagcagtcgcaataccctatgcgaaacgcctcgatagtgactaggtatac
+aaggtttttgagttcctttgaaatagttaactaatttaaaattaattaacgacatggaaa
+tcacagaacctaatgctttgtaggagttatttatgctgtttactgcctctacaaccctaa
+taaagcagtcctaagaatgaaacgcatcttttagttcagaaagtggtatccagggtggtc
+aatttaataaattcaacatcgggtctcaggatattcggtcatataatttattaagggctc
+ttcgagtcttactctgagtgaaattggaaacagtcatccttttcgttgtgaggcatctta
+caccgctatcgatatacaatgcattccaccgcggtgtcccgtacacaaggaaacttgtta
+ccttggggatataagaaaactcacacgtctcattattaaactgagtacaatttttgcacg
+agaaagtaatgcaatacaatatgatgaaagccagctaatgaaaagggatggaacgcacct
+cggatctgttgcactggattaaaatccgattatttttaaaaatattcagtgctagagcat
+atcaggtctacttttttatctggtatgtaaagcccacggagcgatagtgagatccttacg
+actcaacgaaaagttataacataactcccgttagccaaagcccaatcccgattactgccc
+taccctaacgtctgccatctaaatatcgaacttgttatgatcaatgtgactacctcccac
+cctttccccttcatttgttccactggggataagctagcgttttcagaatcaatgcaataa
+gaatagccaattgtctcacttcatcagagctcttggcaattccaggcgctacgtggttct
+ggaatatattcatttttcaaatagtaatacgtttagtgttgctattgtctacacgtttgg
+atattacgttatgtgagcggacatcaatagttgtctaactctttagtaagccagagatag
+cactcttagcgaatggataccatcttccataagtttagttaatagtccgaaacaactgct
+tcgagcatatttgaacctccttgtaggcaaatagcctcttcaaagcaatcttactaatag
+atagagtttgttttaagggactactagaaatgggacaatcttaatagtatgacctaaact
+gacatttaaagatatatccaggtggcaagcataaagatcattgcgccacctccaccgtgg
+gattacttatcagtcgatatcctatatgctaagtttgcgacggcagaatacaaactaagc
+tgagttgatgctaaccttacctatgataccccattggaccggttaacagccctacttatt
+ccaaataaaagaacttttatgctgtagaagctattatagtgatgcctggtaacttcagta
+tattaaaatgacacacatacgccatatagagctcctggaactttgaataatgagcgaact
+tcgaagttgaagagcaagaaaccatatgtcacggttgcctaaagcccggtaaccagacat
+gtgctatcattgatcattatcgaggttttcataaccttgacccattatcggctgtgcgcg
+gacaagtacttaaatcactagtttcttcacctgcttatcggtaagaaataaggttggcaa
+agaatcgcataagacggacgtagagccgcagcgttgtgcgagtccaggtgcatgcgcagc
+aataggattttaaattttgttccatttttaatttagccgtaaggatgtccgtaaatgatt
+gaaaattggattcaatctttgggcctatgctactggaacctgatcgacaaaatttcaaac
+atacgttaactccgaaagaccgtatttttgcggctagaatagtcagtcgcttggagccat
+ataccttaccacttaaacgacgtgctcctgtagttgaaatataaacagaacacaaagact
+accgatcatatcaactgaagatctttgtaactttgaggcgaagcaccctcttcgagacaa
+ctaagagtaaagtaccgggcgccgcaaggagtcgattgggaccctaaatcttgacgaatt
+gctaagaggctcagagctaccactgtaatttctctagagcccataataaatgaacgatac
+atccgtaggtagcacctaagggattataatggaagccaaatgcagttaataatattatat
+actggcgtacacgattcgacggatctctcacatagtgattcacgacccccccctttgatt
+gacacagcgtcagcattttgcaagaacgatcttctgcatagggtgcgccaccgtaaggat
+gacgtcgaagctacaactgggtataatttaccatgcttccctgatgctgagtgcaataca
+ctaagaatgagtttttaccccatatcaccagtatttgttctgttattgcgaagaaatggc
+tatgctgagttggcgactaaagtcacccatcctttttattaggtaaccccctcccttaaa
+ctaactgatttgctggagctgccctgcatacatatactttatcatttatggacgtccgtg
+acgcttattatccaccatagtcgatatgctacacggattcattaatggatcgtaggagtt
+taagttatatttactaagatcggtctcggctactatcccgccttacccggcgctatttac
+ggccatttttaatatattgacggtaattattcctatggtttcgaccgcacgtccttggac
+aagaaagaatggcaaaaaaaatgtaaaagaaaaaaaatattgagtccctaccatcatata
+aaaaatatgtgatgagtaacttgacgaaatgttagtggttattaaagactatctattaca
+ccttttgttttctgtcgtagtatattaaagtctagaagccttacaggaaaatcagggtta
+tacagccgatactccgcagcatgaatcatcgaggaggtgtcctaccatcgcgccttgtaa
+tcttgtctgtgtatactgtatttagaccttttatacaaagtaaatatctcggctttatgt
+gattgggaggggcctactcaaacatgatgacttgacctaataatcactgtgcgggcgtct
+tatgactagctattccttgaaatccaccaccaaatggttaatatgtaaaaactttgacga
+tgaaacaaggtgaatgtgtagttactttgtgtaattagctgcgtcgagcattgcttgtaa
+aaccgtcaatcgcacacgttacttccataaaatttctacgaatacacccttcttaaaaaa
+aacgtaggaattcacgagtttaacaaacgataactgtataaagtggaagtccgaagaaag
+cagatgcccgaactactcgaagatgtttcgttttcttaaccataggggcttcttaatggc
+ccactacgcacattttgttcaagcccgagagggacatccccattacgggagtattactaa
+aactgttccgtaatacgttcagcaagggatgaaaaaggccactgctcaagttattgacgt
+gggagtattacatcggaagcctgaatcccacactatgatggtctgtacaggcctagggac
+tgcgtctagacggtattaccggcttctaatcatacgatcgtgagtcttaacgggaagtaa
+ggctcacacctaccccaaaccatttatctatgtaagtataaaattgtgcgtaagtgttca
+aagtggacaataaagacgtggcaaaaacccccgcacataagccgctttagatttcacaaa
+taccaatgcggttaaaaacatccttgagtcgtacatacaccatactcgcgttaaacggat
+ataacagaagataataaatccggatgtggagtcggtgtaactatagaaagccaagtgaaa
+taatgcttaccagtcatttagctatacggctttcatttcatgtcaagagggtggagtttg
+acctgtacagttgatatatcaccgatacttagaactcacctaaagctaaaattgctcgca
+gcgtgtaatccgcatattacaaacaatagatgggattcattatacataagacacgatgat
+ctgctttttcaggttgcgagatgttgcctatcgtcaatcgagtcctgccttacaccactt
+aaacaaaagtattgacagggaacctattttcgaggtattatatagtccagcttgaatatc
+aatttgacagttaacctagtgaaaatcagtaagaggaaatacgccacattctccagtgaa
+attctacgggttatcgtctagtccaactatcaattataactcacgagatataagtaaatt
+ctcgtacttggcctgatttttattatactttggatccttagtaaacaggaagggagaaac
+cttcaacgaaaaacactggattttgttttactctcaaagctcttatatgacggaaatacc
+ctgtcaagtcttaactttattactagactaatgaaatgggcttggggtggccagaatcat
+agtacaatttagcggatacactattcggactttcctatcggctgtctggttggataagta
+tggggactaataggctagacatacctatacttaaactatacaggcgtcatctatctctgc
+aactttggagttccctgatgttctcccgccctttgggttcacatcttctataccgacacc
+cctaataacgattagtttgtgggttagagtaaattaatacggttaatattaatgtatcgt
+tgaaaagctggtgtcgccaataaggtaaccggctaggcagagtatatgtcacgaagtata
+actaccctaatgataagctgtaggaataaaattaatgctgtctctaagcgaagagatatt
+tccgactctgttttaatgacgaatctcattacttctgacttgcaaatgttcaatatggca
+cggtttcacggcacctttgtgacgcatataatgaacttagaagattataacgacggaact
+ttatatgataatccgttacgattaaagaatctgttaaatatcataatggcattcagttct
+agaccgtgcatcatggtaaacttactttctctgcatggcgacatacatttcgctattcaa
+attcgcgtgtggttacacccactcgcacctttggaatattaagagaagatgatcagaaaa
+tccattcgctcaatttttctgacgtacgtctaatttatcctaggagacaaatcgttttat
+gtctctcacatttttgaagaaaggttcgagagacaatactcaggtcctgaactgctagaa
+gatactcggtggagcgtggcaacaatgaaaaactcgtgacataaatgaatgatacttttc
+caagttcagttaagtgaatatgtttaacatacccggcttttcgatcttaagctgacgctg
+gacgtgcgagtaatgtcagtctcttacatacactagtgactccaagtttcgtcaaaaacg
+ccccctcccttctcgagcccactcacgctatgtattgacgcgaacttgttcgggatcaga
+cttttcaggagttcggtcgcgtgtccctatgtgctaatatataagttagatcgcattaga
+tgctaatctgaatacttatagacgaccttcaacgagaacgggtaccaccttgaggctaga
+gttaggtgtgaaacgacaggtagggacatataaaatttgagtgcggctttagttaagggt
+ttaattacctactcaaacatcacgctcgcgcccttcgtacgtaatcgaccatctagaggc
+taaggggactgtactaggtagtgattaatgatatcctagacgcacgtgccttagatcttc
+agactctgatggtccgcgatcaccgtaattgtagtcctccaactcgatcactttgttggc
+gtcaaagaaattacgatatctaaatacttataatacaataaccaaggatgagaatgactc
+atcgcgttggagttatattgcttgaagttctatggaatgaaagcacgttatctgccgtcc
+caatatctccagtgagctaattcattggacggtccactttgatcaatccccgaggagatg
+ttcggacactttagtctgtaacacttagcgttgagaccacgaacaattgattactcagtc
+ttgaaggtgttttccaaagttcattttaaataagactacgataggcctttcctattgata
+taaactacccggctctgttgttcgtgtgagtcgtacttctctgtgtttttctgattatag
+caagattcgattcttagtgtaaacagcgatttttatttgacccgtcaatgagaagcgcat
+aggatctaagcaaaattatcaagttgtgccacaaggtaagatctttccagttattgcagg
+taggatgtatcccacgttgatagtatgaggtctgacgtcaactgtctaggagagttgacc
+gcgtgcgggtacaccggatttgcatcgatgttgagaacgcagaactcccactgtcgtggc
+ggcgttcctgatatttagcaagaggcgttgataaagccctcatcatctagatctcgacct
+catctgccctcttgctccatcattttctacacagactactttcctatctacgttagtata
+attgctttctatcttagtatcatttagagcttctccgtcaacaggttcgtgctattaaag
+ttagtacgaaagggacaacttgtagcaacgcatttaatcggttttcgactacttcgcaca
+aaatcagataaagaagtttgtcattctattagacattgaattgcgcaattgacttgtacc
+acttatgatcgaacactgaatcaagactgtgattaactaaaatagacaagccactatatc
+aactaataaaaacgcccctggtggtcgaacatagttgactacaggataattaattggact
+ggagccattacattctctacaatcgtatcacttcccaagtagacaactttgaccttgtag
+tttcatgtacaaaaaaatgctttcgcaggagcacattggtagttcaatagtttcatggga
+acctcttgagccgtcttctgtgggtgtgttcggatagtaggtactgataaagtcgtgtcg
+ctttcgatgagagggaattcaccggaaaacaccttggttaacaggatagtctatgtaaac
+ttcgagacatgtttaagagttaccagcttaatccacggtgctctactagtatcatcagct
+gtcttgcctcgcctagaaatatgcattctatcgttatcctatcaacggttgccgtactga
+gcagccttattgtggaagagtaatatataaatgtagtcttgtctttacgaagcagacgta
+agtaataatgacttggaataccaaaactaaacatagtggattatcatactcaagaactct
+ccagataaataacagtttttacgatacgtcaccaatgagcttaaagattaggatcctcaa
+aactgatacaaacgctaattcatttgttattggatccagtatcagttaaactgaatggag
+tgaagattgtagaatgttgttctggcctcgcatggggtctaggtgatatacaatttctca
+tacttacacggtagtggaaatctgattctagcttcgtagctgactatactcaaggaacca
+ctgctcaaggtaggagactagttccgaccctacagtcaaagtggccgaagcttaaactat
+agactagttgttaaatgctgatttcaagatatcatctatatacagtttggacaattatgt
+gtgcgaaactaaaattcatgctattcagatggatttcacttatgccttagaaacagatat
+tgcccgagctcaatcaacagttttagccggaaacaatcgaagcatagggacaatgtatct
+tttcctaaattgccatgtgcagatttctgagtgtcacgaagcgcataatagaatcttgtg
+ttgcctcaactcgttgaaaagtttaaaacaatcgcagcagtctttttggggtctactgtg
+tgtttgcaaaataactgaaagaaacgcttgaacaactctgaagtagctcgagtactcatt
+aaagtgtaacacattagtgaatatcggccaatgaaccaaacgcttcccggtacgctatct
+ctctcatcgggaggcgatgtgcaggttatctacgaaagcatccctttacgttgagagtgt
+cgatgcatgaacctcattgtaacaatagcccagcaaattctcatacgtgcctcagggtcc
+gggcgtactcctccatggaagggcgcgcatctagtgttataccaactcgctttttaacta
+ctatgctgtagttctacaggcatagtggccagtattttctaacttctctggatagatgct
+ctcactcctcatccatcacggcttcagtttacgtcttacttgcttgttcagcaacggatg
+gaggcattaagtatcttcactgttccctaaaattgctgttcaatatcaaagtaaggacga
+tacagggaaagctcaagcacactcattgaatactgccccagttgcaacctcacttaatct
+gacaaaaataatgactactctaagtgttgcggaagcagtctcttccacgagcttgtctgt
+atcacttcgtataggcatgtaactcgatagacacgaacaccgagtgagaaactatattct
+tgcttccgtgtgtgtgacaccaggtaattgatgcggatataagctggagatcactcacgc
+ccacacaaggcgctgctacctctttattccaatgtgtaagaatttgctaacttcatttct
+agaccgcagctttgcggtcataatttcacggtacggacccttgggttagagacttgataa
+cacacttcgcagtttccaccgcgcacatgttttagtggcttctaacatagaatttttgtt
+gtgacataaagagtgcgtgggagacttgcccgaccgttaagccataatcaattgaaagcc
+ccgtgagtcacatctaattggttgtactgcgcatttagctatcctttagctgactcgaag
+agattcgattcctaatataggttaattagatggctgccgcgcgaagtaaaacgtgaaaaa
+cgtagtgcgcagatctgcataactcgcgcttaattacttatgagtagttccaagttcgct
+acgttatgagagagattggaattaagcaaatatgttttatggtgattttgggatgagaag
+gactgctaagtacggctactaaacaaatttctaaaaccgccatctaccttatcttggaga
+catttaagttgtatatgtcactagtctagcttttgtctgtgggacgcgttctcggaatga
+gggaaatgcaagagccgattcatcaaatgcttatctaagaaagtagtggactattacacc
+aagcacgaatgccagggaactgctttcttgctcaggacctcgcgacaaggtaccccgcat
+aagtcctagaattacatttggtcagcaatgctgacatttgaccgtgaaaacataatttta
+atcagaaggcagctcacccgcttgctctagatcttatctttgtatgaatgtcagaattta
+ctgcaatatccgttccgaatagtgagggcttagtatagttctctgtatacaggtcacatc
+aaactccccctgtcctagtacagctctgagctttaattaattgcatacatttccttcaat
+catcagatgaaaacaccgcgaatcatgctcttctcgtatagggcaagagaagcaacaaac
+aactagcccgactcacgttcatccgccgtatccttgttcagttcttactccgtattaggt
+cagcgaaatctaatcagaataatcggtcgcgtatcaaaattaaaatcccgcttgaggttg
+acaattaaaacgctgagcagttatcggctattagatagtggggtgaaagtaattggctgg
+aattatgttaaaacgtgatattaagctaaaatacgctacttgttgccgacctaattcagt
+cattcgatattcagttagagccaagaataacaagcttgtataaattgaacggggtgcact
+aaacgatgtgttactctaatattcagcttggagtatacctgaaggcgaattcatgtatcg
+gccaataataagacgttgaagatcacaatttggactagcaaaagaaggtgatttatgcgt
+ggggattgagtccactgtacgagtacggtctctggaaaattataggttcagggaatataa
+ggaagtaaagataattaccaagagatttttggtatcgctatgacccagaggtgttctaac
+gtctgttttgatccgcagaatttctgcctcaatgcatatttgacggacttgaactagagc
+ctctaaagttaaatggcgacgcaactgttcctaaacttcaattattactactcttttttt
+cctagggtattgtagaggccagtggacaaaataaatcaaatttaagatgtttcggacatt
+aacatcccccgtagcatagaaatcatcagttatccaatctctcatcgagcttttacaatt
+tctgctggcgctatggacagcatatgccgcgagacctccgcaagactcacttgatcactg
+taagtatcttcattagaggttagagcctatagttaagctgctgacctagtaaaattggta
+ttttctaattttattgctcaagttaaaggttagtgaagggataatgacgttatttttgaa
+caatgggttgtattcaattttatatcacgaatggaacccttcattcccggcataatacta
+gacgacacgaacaagctccgatctatcagccaggcacgtgttaaggtttaattccggcaa
+accaatgaagcatcaaaaggtgacctgatgcaacttagggtcacgatgagtttttcagga
+ctacttattacctattaataagttaacatgagccttcataccccgtaagacaatacatac
+tccaccaattagaattctgagccatcttatctttttgtatcatcgaagggtatggccgaa
+taggttaattagttactcctaacgtctctacaggcatgcatttgacgcaccttcgaaaat
+agtcaatctctcgccacacgcgtctagtatgcagcatcaaaaatatagtccacggtttcc
+ggattaccaaacgcggcaaagagaaacattgtatcgacggagataacttaatacagaagg
+aaggggcatcttcgaatacggatgaataattctatctgtttattctgacatcttgttttc
+aggttaatcttacgcattcaaatgacgcctgccccatgcgtgcgcaattattttctaata
+ttgacgagagcaatctcactccttttgggtctatttatgttttattgaggcacaagccta
+tacagaacaggtactattaaggccgtgagtgtgagactcaaaccgtggaaacaaaggatg
+ggttgttcttggtacaagttttagtgcatgtgggcaatccttaccaaaatcagatgctat
+ccttaactttgggctgcatttaagatggcggttggaggcctgtgagaatcctgcgtgtca
+tctttaatgaccgaattcatccatgtagattcagatcacacactcattccttgatgttgt
+ctaaacaaaagttgttgtggacgcattggagggagttaagtaacaacttgggatcgcata
+cttataaaaattatatgttaaactttcacaaacgctgaagtccaaagtaactagcccaaa
+cgcctcgagagtcactaggtattaatggtgtttgagttcctgtgaaatagtgttcgaagg
+taaaatttatgtaccaaatcgaaagaacacttaataaggcttgcttgcacggaggtatga
+tgtttactgactctacaaccctaattttccagtacgtacattcattccaataggttagtt
+ctcaaagtgctatacaggctcctcaattgatgatatgcttcagccgctctatggatatta
+gctcattttatttaggaagcccgcttagaggcttactatgagggaaatgccaaaatgtca
+tacttttcggtgtgtcccatatgacaccgctttacatagaatttgaattaaaacgcgctc
+tcccgttcactaccatacttggtaccgtgcgcatattacatatagatataggatcatttt
+ttaaagctgtactaggtttgatcgacaatcttatgctatactatatgatgtaaccctcat
+aatcaataccgatcgtacgatcctagcataggtggcaagcgattttatgccgattattgt
+gttaaatagtctgtgagtgtgattatcagggctacgttggtagaggggttgtatagacct
+cgcacacattgtgacatacttaacaatatacgaaaactgatataataaatccccttaccc
+aaacaccaatcccgttgaatcaactaccataacgtctcccatataaattgcctacttgtt
+tgcataaatctgaatacataacaccattgcaccttcttgtgttccaatcccgttaagatt
+gccttgtcagatgatatgcaagaacaatagcatttgctagcaattattaacagctcttcg
+aattgcctccacataacgcgggagggtatattttaatttggcaaatactaagtactgttg
+gcgtcatatgctattaacggttggatattaagttatgtcagccgtaagcaagagtgggcg
+aaatattttgttacccagtgagagcactcttagagtttggatacaataggccatatgttg
+acttaagaggacgtaactacgccgtacaccattgttcaaccgacttcttggcaaatagaa
+tcgtattagcaatcttaagaatagagacacgttcgtgttagggtatactacaaatccgaa
+aatcttaagaggatcacctaaactgaaatttatacatatttcaacgtggatagatttaac
+ataattcagccacctccaacctgggagtaattttcagtagatttactagatgattagtgg
+cccaacgcacttgactatataagatctggggatcctaacctgacctatgagacaaaattg
+gaaacgttaacagcccttatgtgtacaaagaaaagtaagttgttgctgttcaacagatga
+tagtcatgacgcgtaacttcactatagtaaattgaaacaaatacgcaatttagacagaat
+ggtacggtcatgaatgacagtaattcgaagtgctagaccaacttaaaataggtaaacgtg
+cccgaaaccccccttaacagaaagctgctatcatggtgcagtatcgacgtgttcagaaac
+ttgtaacttttgagcaggtccgagcacatggaagtatatcacgtgtttctgaaccggctt
+atccctaagatatatccgtcgcaaactttcgatttagtcccacgtagagcccaagcgttg
+tgcgactccacgtgcatgcccagaaatacgagtttaaatttggttacatggttaattttg
+accgaagcatcgcactttatgattgataattggattcaatatgtcgccctatgcgaatgc
+aacatgatccacaatttggctataagacgtttaatccgtatcacactttgtttgcggcta
+gtatagtaacgcccgtgcaccaagagtcagtaacaattataagtactccgcaggtacttc
+aaatataaaaactaatcaaacacgacccatatgatcatctgaagatatttggaactttct
+cgacaaccaccctcgtactcaatacttacactaatcgacaggcacacgcaacgtgtacag
+tcgcaccatattgagtcaagatttgcttagtggcgatgagcgtacacgcttatttctcta
+gtcacaattagttatctacgagacatcacgagggagcaaataagcgatgttatggctaca
+cataggcacgtatgaatatgatataagccagttaaacagtcgaaccatcgagcaaattct
+catgcaccaacccacacgttgaggcacaaagagtaagctgtttgaatgtaacttcttctg
+ctgagcgggccccaacgtaaggatcaactagaagagaaaactcggtattagtttaaatgc
+gtcacggagcatgagtgcatttcactaagaatgtctgtgtaaccaatataacatctattt
+gttatctgattgcctacttatggctttgcggtcgtggcgactaatgtctccaatcctttt
+gaggtcggtaccaactccctttaaattacgctgtgcaggctcatgcactgcatacatata
+cggtagcaggtagggacctcacgcacccttattataatcaatagtagttatcagtcaacg
+aggcaggaatgctgaggtcgaggtgttggtatattttctatgtgccgtctaggcgactat
+cacgcattaccaggcgagatttaagccaattttgaatatagtcaacgtaatttttactat
+gggttccaccgaaacgccttgcacaactaagaatcccataaaatatcgatatcaaataaa
+agattgtgtcaataccttcatatatattttttcggttgactaacgtgaactaaggttagg
+ggttttgtatgtctatataggaaacagtttcttttctgtcctactttagtaaagtcttca
+agccttactccaaaatcacggtgattaagccgttactcagcagcatgattctgcctgctc
+gggtcctaaaatccagccttgtaagagtcgctgtgtattagctagggagacctttgttaa
+aaaggatatatcgcggcgggatgtgagtgcgtggcgcatactcaatcttcagctcgtgtc
+attataatatctctcccccacgcttttcactagatatgccgtgtaagcaaacaccttatg
+cttaatttcgaaaatattggtacttgaaaaaagctgtaggggtacttaatgtctggtagg
+agatcaggagagaattgagtgtaaaaccgtaaagccctcacctgacttcatgtaaatggc
+ttagaagactccatgatttaataaatactacgaaggaaagactggatctaaagataactc
+tagtaaggccaactcccttcaatgctgttgccagttataatccaagagctgtccttttct
+gaaccatagcggcttctgaagcgaactagaagcaaagttggttctagccagacagccaca
+taccctgtacgggtgtattactaaaactggtccggtattagttcaccaagggaggaatta
+ggcaaaggatctaggtatgcaagtcggagtattacatccctaccctgaatccatcaatag
+gttcctctgtactggccttcgcaatgagtattcaaggttgtacagccgtataataataag
+atagtgactatgaacgggaagtaacccgctcaccttccccaaaacattgttatatctaag
+tattaaagtctgccgtagtgttaatactcgaaaataaacaactggcaaattacaccgcac
+ttaagccgcttttgatttatatttttccaatgcgcttttaaaaataattcagtcctacat
+actaattaagacccttaaacggagatatcacaagttaagttttaaccatctcgactaggt
+ggaactatagatacccaactcaatttatcattacctgtaatgttcctagaaggattgcat
+ttcatgtcaagacggtggagtttcacagcgaaacttcagtgtgaacagattctgagaaat
+cacctaaacctattagtcagagcacccggttagaaccagttgtcaaaaaatagagcggtt
+gcatgagacagaagtaacgatgagatccgttgtaacgttgagacatctggcctatcgtca
+atacagtcctcccttaaaaatatttttaaatactaggcaaacccaacataggttagtcct
+atgtgatacgccacatggtatatcattttgtaacgttacctagggataatcaggaagtgg
+aattacgcaaaagtagacagtgaaatgcttagggttatagtctagtccaaagataaagga
+taaagcacgtcagagaactatattagccgaatgggaatcattgttaggagactgtggatc
+atgtctaaaaagcaacgcagaaacagtcatcgaaaaaatctcgtttttgtttgaatctaa
+aagagctttgatgaccgatagtacctgtatactagttactgtattacgtgtctaatgatt
+tcggattggggtccccagaatcagacgtcattgtagacgattcaagtttaccaatttaat
+ttcccagctctccttggagaactatcgccaataattgcagtcactttccttttctgaaac
+gataaagccgtcagagttctctgcaacgttggacttacctgaggttctaacccactttcg
+gttctaatagtagttaacgacacaacgaataacctttactgtggggctttcacgatattt
+tttcgcttattattaatggttacgtcataagctggtgtccaaattaaggttaccggcttc
+gcagagtagttgtatccaagtataacttccctaatcataagatcgaggtagaaaattaat
+gctgtctctaaccgaacagatatgtcccactatgtggtatggacgttgctaattacttct
+gaagggaaattggtcattatggatacgtgtctaccatcaggtcggacgcagatatggttc
+tgtcttcagttgatccaccgttctttataggataataactgacgattaaagattatggta
+aatagattaagccaattctcttcttgtcagtgaagcatccttaactgacttgctctgcag
+cccctcatacatttagctattcaaagtaccggctcgtttcaaactctcccacctttggaa
+gaggttgtcaacttgataagtatatcatttacagcattttttcggacgtacctctaatgt
+ttcattgcagaaaattagttttttctatcgcacattttgcaagtaacgttagagacacaa
+ttatctgcgaatgaactgctagatctgacgaccgggagcctcgcaaatatcaaaaaagac
+tgacatatatcaaggagtcgttgacaagtgctggtaagtcaattggtttatctgtcccgg
+cgtttcgatcttaagctgaccatgcacggcagagtaatgtcactctcgttcttacaagtc
+tgtctccaagggtcggcaaaaaagacccctccattctcgagcccactcacgatatgtagg
+gacgacaacttgtgcggcttatgaattgtctggactgcgggcgagggtccatatctccga
+agttagaagggacatacctttagatgataagatcaattcttattgacgaaattcatccac
+aacggggaacaacttcaccctagacttacgtctgaaaagacacctagcgtcttataaaag
+gtcagtgccccgtttcgtaaggctggaattacctacgcaaacttaaacctcgcgcccttc
+cttacgtatcgacaagatagaggctatcgcgaatgtactacggaggcatgaatcatatac
+tagaaccaagtgcctgtgatattaacaagatgatccgacgcgagcaccgtaattctaggc
+ataaaactccagcaatttgggggccgaaaacaaatgacgttagctaattaattatatgac
+atgatcaaaggaggtcaatcacgcatcgagttcgacgtatattcattgaacttcgtgcgt
+ttgaaagaaacttttatgaaggcaaaattgatcctgtctcctatttcatgcgtacctcct
+agttgataattccccgagcagtggttaggacacttttgtcggtatcaagttccggtctca
+aaacgtaaaattctgtaatctgtatggatggtctgtgaattagttaatttttatgaagtc
+gtcgagacgcagttcctattgatttattctaaacggagatgtgcttcgtgggactcggaa
+gtagatctgtgtttatgattattgctactttagatgctgactgttaactccgtgttgttt
+ttcaaccgtatatcacaaccgaattggatagaacctatagtttcaagttctgccacaagg
+tatcatatttacagttagtgctggttgcttctttcaaacgtggtgagtttgtgctatcac
+gtcaacggtagagctcagtggaccgagtgcgcgttcaaccctgttccagagagggtgtga
+tagcacatataccacgctcgtcgaggcgttcatgatagtttgcaagagccggtgttaaac
+acatattattattgttatccaactaatcggacctatgcataaagcattgtctaaacagaa
+taattgcctatatacggtagttttagtgatttatatcttagtatcagttagagcttcgaa
+ctcttcaggttcctcatatttaacgttcttcgaaagcgaaaacttctacaaacgaatgta
+agcggttttccaagtagtacctataaatcacagaaagatctgtctcagtatagttgaaat
+ggtattcagctagtgacgtgtaccaattatcatagttcactcaagcaagacgctcattaa
+cgaatatagacaagacactatatcatataataaaaaagaacatggtgctcgaacatagtt
+gaattcaccatattgaaggggaatgctgacatgtaattcgctactagacgatcaattccc
+tacttgtcaaagttgaactggtacgttcttggaattaaatatgattgcgctggaccaaat
+tgcgacttcttgagtttcagggcaaacgattgagccggaggatgtccgtctcttaccttt
+cttgcttatgataaacgacggtccctgtacatcactgggaattctcagcaaaaataattg
+ggtaaatcgagactcgatgtattcggccacaaaggtgttagacgttaaagattattcaac
+ggggcgataataggatcataaccggtatgcaagcgcattgaaagagccatgagatcctta
+tccgataaacgctgcacggtatgtgcagccttattgtcgatcacgaatttataaatgtag
+tctgggctgtaagttgaagacctaagttataatgaagtgcaataccaaatcgattcatag
+tggattatcagactcaagatatctcctgataaattacagttgttaagatacggataaaat
+gagatttaagattagcagcctctaatctgtttcaatcccgttggaatgtggtatgcgatc
+aaggttaagttaaaatcaagcctgtcttcagtcttgattcttgttctgccatcgcatgcg
+gtctacgtgagttaatatgtagcttacgttctagcttgtgctaatctgagtatagattcg
+tagaggaatattatcaagcttccacgcctcaacgtacgtgtattggtcacacaagacact
+aaaagtggaagtagcgtaaactatagtctagttgttaaatgctcagttcttgttatattc
+gatatactcttggctaatttatgtctgagtatataaaattaatgatattaacttgcattt
+cacggatcccttagaaaaagattttgaccgagcgcattataaacggttacaccgaatcaa
+tagaagcatacccaatagctttctttgaatttattgcctgcgcaacttggctgactctct
+agatccgaataattctatatggtcgtgacgaaactagttcattactgtttaaaatgccaa
+catgtcttttgggccgataatggctctttgcaaaattactcaatgatacgattgatcaaa
+gcggtagttgctagtggtagcatgtaagtctatcaaatgtctgattatccgaaaatcttc
+caaaagagtccacgtaccatatctatctcatagcgacgcgaggggaaccttatctaacta
+tcattccatttaccgggtgactctcgatgcaggatccgattgggataaattgcccagaaa
+tggctcattcctgactaagggtaaggccgttctcagcaagggaaccccgcgaatctaggc
+ttataccatctagattgttaactacttgcctgtagttctacagccatactggacagttgt
+ttctaaatgatcgggattcatgctagcactcctctgaatgcaccgcgtaagtttaactat
+tacgtccgtgggcagataaggatggaggctgtatgtatcttaactgttacctaatatggc
+tggtaattatcaaagtaaggaccttaatgccatagcgctagcaatcgctttgtatactga
+ccatgtgccaacctctcttaatctgtaaaatataatgtcttagctaactgtggacgatca
+tgtctctgcctagagcttcgctgtatcaattcctatagccagcgtactagtgacacaaca
+acaccgtgtgagaaaagatattagtccttacgtctgtctctctacagcttattgatgagg
+attgaacatggacatatagctccccctcaaaagcagatgctacctctttattccattctc
+gaacatttgccgaacttaatttcgacaaacctgaggtcacgtcttaatttatcggtaacg
+tcacgtccctttgagactggataaatatattaccaggggccaacgagcaattgttggagg
+cgcttctataatacaaggtgtcttgtcaaagaaagacggcgtgcgtctcgtgcaactcac
+ttaaccaatattaatgtgaaacccccctctctcacatcttatgcggtgtactgccctggt
+acatttcctgtacaggactccaacagtgtagattcctaagatagctgttggagttgcctc
+acgccagatcgaaaaactgaataaactagtgagctgagctgcagaaataccgcttaatta
+cttatgactagttcaaagggacctacgtgatgtcagacattgcaaggaagaaattaggtt
+tgtgcgtcattttggctggactagcactccttacttcccctactattcaaatgtcgtaaa
+cagcatgagacaggatcgtgctgacatttaaggtctattgggaacgaggctacctttggt
+cgcgcgctcgcgttctccgaatgaccgaaatgcatgagcacagtatgcaattgcttatag
+atctaaggtctggtcgttgaaaccaagcacgtaggcctgggaaatcagttcttcctcagc
+aactacacaaaagcgtccaagcattagtacttgtagtaaatgtccgaacctatgcgctca
+tttgaaagtcaaaaaatatttttaagcagtaggcacctaacccgattcctctacttagta
+gctttctttgattctcagaattgactgcaatatcactgcacaattctgtgccattactag
+acttctctgtattaacgtctcatcttactaacactcgcctaggacacatctgagagtgaa
+gtatttcaatacatttactgaaatcttcagttctaaaatccccgaataaggctcttatcg
+gtttggccaacacaagaaaaaaacttcttgcaccactcaccttcatacgcaggagcctgg
+ggaacttagtaataactatttcggcagacaaagcttataacaagttgccggcgcgtataa
+tatttaaaagaccccttgagctgctcaattaaaacgctcacctggtataggctattagat
+agtgccgtcttagtaaggggcgggaattatcggataaactgatattttgataaaataacc
+gacttgttcacgacataagtcactaaggagattttatctttctccaaagtatatcttcct
+tggataatttcaaagcgctgcaatttaagttctgttactagtttatgctgctgggaggtg
+accggaaggcgtagtaatctagaggcaaattataagaagttcatcatatcattttcgact
+acaaaaacaaggtgttgtatgccggcgcattgtgtaaactggacgagtaccctagatgga
+aaattatacgttaagccaagatttcgatgtaatgataattacctacacatttttgctatc
+cataggaacaagagctgttctataggctcgtggcatacgaacatttgctgccgctatgaa
+tattggaagctcttcaactacagactctattcttaattgccgtcgaaaatgggccgaatc
+ggctattattaatactcggtttttccgaggggattgttgtcgacagtcgtaattattatt
+aatattgatgttggtgaggtcatttaaatacaaccttgcagacaatgaataagggatcca
+atctctcatactccttttacaattgctcatgcccctatgcaaaccttatgccgccacacc
+tccgcaactctctcttctgaactgtaagtagcttcattactggtttgagactatactgaa
+gctgatgacattctaaaatggctattttcgaatgtgattcataatgtttatcgtttggga
+tggcagaatcacgttatttttgatatagcccgggtattctattgtatagaacgtatgcta
+caagtcattccccgaagaagactagaagtaaacaacatgcgaccatcgttaagccacgca
+aggctgtagctttatttcccgataacctatcttccataaatagcggacagcaggatactg
+acgctcaacatcagtggttatggtctaatttttaacttttaataaggtaacttcagcagg
+catacacagtaactctttaatttataatcaaattagaagtctgacacttcttatattttt
+ctatcatccaacgcgatcgcccattagcttattgtgttactaataacgtatctaaaccaa
+tccttttcaagctactgcctatattgtcaatatatacaaacaacaggatagtaggctgct
+taaaaaatattgtcaaccgtgtacgctttacaatacccggaaatcacaaactttgtagac
+aacgagtgaaatttatacactacgaagggccagcgtacaagacccatgaattaggcgata
+tgtttattctgacatattggtttatccttaatctgtcgctgtaaaatgaagccgccccca
+tccctgcgaattttttttcgaagattcacgactgaaatataaatacgtttggctatattt
+atgttggagggaggcaatagcctttactgttaaccgaagatttagccagtgagtgtgaca
+ctaaaacactggaataaatgcaggcgttcttctgggtaaaaggtttagtcaatctcgcct
+ataagttcatatagctctggatataattatctggcccatgcatttatcatggcgcttggt
+gccctgtgtgaagccggcctctcatattgaaggtccgaagtattccatgtacattaagat
+cactctctcattcatgcatcttggcttaacaaatctggttgtccaagctttccaggcacg
+tatggtacaaattcggatcgaatacttataaaaatgatatgttaaactgtctaaaacgct
+catctacaaagtaaagtgcactaaccaatagagtctcaagaccgtgtaatgctggtgcac
+tgaatgtgtaatacggttagaagggattagttatgttacaaatccattgaaaacttaaga
+agcattgcgtgctcggagggtgcatcttttatcaagagactaacattattttcaacgacg
+tacatgctttacaatagggtacttatcaaacgccgagaaacgcgcctatagtgatgttat
+gattatgacccgatatccattggaccgaattttatgtaggttcccagcgtactcgcgtaa
+tatctcggtattgccataatgtaatacttgtcggtctctcccagatgaaaaagcgttaca
+gagtatttcaatgaaaaacagcgcgcaacgtcaatacctttaggggtaacggccgctgat
+ttcatatagatatacgataagttggtatagctctactaggtggcatccacaatcgttgca
+tttactatagctggttacaatcataatctataccgttccttacatactaccatagcggga
+tagcgtttttttgccgttgattgggtttaagaggatgtcagtctcattatatccgattcg
+gtgggagagccgttgttttcaaatcgcacactttgtgacataatgtacaagataacaaaa
+ctgatataagatataaactgtcaatatcaccttgacacttgaatcaaagtaaattaactc
+gcaaatataatttgactaattgggtgcagatttctcaattaataaaaaaatggcaccgga
+tgggcttacaagccccttatcattcacttgtatcatgatttccaagaacaatagaatttg
+ctagcaagtatgaacagagattcgaattgcatccacagtacgccggagcgtttattttaa
+tgtggatatgacgatgtactgttggcggcatttgctagtaaccggtccttatttacgtag
+cgcacacgtaagcatgtctgggagaaatatggtggtacaatctcagagaaagattacagt
+ttggtttaaataggacttatcgggtcggaagtggaacttaataagcagtacacaattggg
+caacagacgtcttgcctattacaataggattacaatgcgttagatttcagacacgttcgt
+gtttggctattcgtcaattccctaaatagttagacgatcaactattatcaaagtgattct
+ttgttcatcctccattcatgtaacagatggcacactacgcataacgccgaggaattttaa
+cgagatttaagagagcagttcgggcacaacccacttgactttataacagctcggcagcat
+aaacggtaatatgtgacaaatttccaaacgttataagaacgtatgtgtacttagaaaact
+aagtggttcatgttcaacagatgtgacgcagcaagcctaacttatctattggttttgcta
+taaaagaacaaagttacacagaatcctaagggcttgtttcacacttatgcctagtgcttc
+accatcttaaaatagcgaaaccggcacgaatcaaaccttaaaacaatgcgcagatattgg
+tgatggtgactccgggtatgataatggtaactgttgaccagcgcccacctcatcgaagta
+tagaaagtggttaggataaggatgagaccgaacttatttccggccataactttagatttt
+ctacctagtacacaacatcagggcggacacgaaaccgccatcacatcatataccaggttt
+aatttgcttaatgggggaagtgtcaacgaaccttcgaactttagcaggcatatggccatt
+atatatggccccagagcagaatgctacagcagacaaaatttggatttatgtagtttaata
+cctatcaaacttggtgtgaccatacttgtctaacgacagtgcacaaagtgtaagttacaa
+ttattactactcagcagcttctgcaatgataaaatcttatcatacacgtcacatatgata
+atatctacttagggggaacgggctccacaacctacatagtactcaatacttacactattc
+gacaggcacaccaaacctgtacagtcccaaaagattgagtcaactttgcagtactgcaga
+tcacagtaatagcttagttagcgagtcaaaattagttttctacgagactgcacgaccgtg
+caaatttccgatgtgttggctacaaatagcaacgtatgaatttgtttgaagccacgtaaa
+ctgtacaaccttagagataagtctcaggctactaaaaacacgttgtggcactaacaggat
+catggttgattcttacttattcggctgaccggcccaataagtaaccttcaactagaacag
+aataatcgggagtagtttaattcagtcaaggtgcaggtctcattgtaactaacaagctct
+gtgtaaccaagttaaaatcgttttcttagcggattccctacttatggatttgagctcgtc
+cacaatattcgatacaagaagtttgtggtccgtaacaacgaaattttaattacgctgtgc
+agcctcatccaaggaattaatagaaggttgatggtaggctccgaacgctccatgattata
+atcaagtggactgtgcagtaaacgaggaaggtatcctgacgtcgtggtgttcgtttttgt
+tatttgtgccctatacgagtagataaaccatgaacagcacagtgtgaacccatggttgat
+tttaggctaccttatttttaatttccgttacacagaaacgaattccacaactaacatgcc
+attaatttttcgatatcttataaaagatggtcgaaattcattcatttattttttttcggt
+tctcgaaagtcaactaagctgtcgcgttttgtttctctttagaggtaaaagtggctttga
+tctcctacgtttggatactagtcaaccattactccatttgatccgtgagtatcacctgtc
+taacatccagcattatgactcctcggcgaagaaaagacacacttcttagagtcgatgtgt
+attagctagggacacagttgtttaatacgatagtgagcccagggagggcagtgcgtcccc
+cagtagatttattcagctagtgtaagtataagatatctcacccacgaggttcaagtgata
+tgcagtcttagaataatacttatcctgaatttcgatattatgggtacttcaataatccgc
+tagcgctactttatgtctcgttggacagcaggacacatggcagtcttaaacactaaagac
+atcacctgaatgaatgtaatgggattacaagaatcaatgaggtattatatacgacgtagg
+aaactctggatatatacagtaatctagttacgccatcgcacttcattcctctggaaactt
+agaagacatcagctgtacgtggaggaaccagacccccgtatgtagccaaatagaaccaaa
+gttgcttatacaaacacacccaatgacaatggaccgctggagttcgtaaactcggaacgt
+agtactgcacaaacccagcatttagcaataggagctacgtatgcaactcccacgtggtaa
+taccttcaagctatcaatatataggtgcctagctaatcgcattcgcaagcagtattcaag
+cttgtaaaccagtataataattacagaggctctatgaaacccaactttccagctaaaagt
+cccaattaaatggttatttc
diff --git a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/revcomp/revcomp.csharp-1.cs b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/revcomp/revcomp.csharp-1.cs
new file mode 100644
index 0000000000..4e875742e8
--- /dev/null
+++ b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/revcomp/revcomp.csharp-1.cs
@@ -0,0 +1,250 @@
+// 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.
+/* The Computer Language Benchmarks Game
+   http://benchmarksgame.alioth.debian.org/
+
+   contributed by Robert F. Tobler to process large blocks of byte arrays
+
+   modified for use with xunit-performance
+*/
+
+using Microsoft.Xunit.Performance;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+
+[assembly: OptimizeForBenchmarks]
+[assembly: MeasureInstructionsRetired]
+
+namespace BenchmarksGame
+{
+
+public static class Revcomp
+{
+
+#if DEBUG
+    const int Iterations = 1;
+    const string InputFile = "revcomp-input25.txt";
+#else
+    const int Iterations = 800;
+    const string InputFile = "revcomp-input25000.txt";
+#endif
+
+   struct Block {
+      public byte[] Data; public int Count;
+      public int Read(BinaryReader r) {
+         Data = r.ReadBytes(16384); Count++; return Data.Length;
+      }
+      public Index IndexOf(byte b, int o) {
+         return new Index { Block = Count, Pos = Array.IndexOf(Data, b, o) };
+      }
+   }
+
+   struct Index {
+      public int Block; public int Pos;
+      public static readonly Index None = new Index { Block = -1, Pos = -1 };
+      public bool InBlock(Block b) { return Block == b.Count; }
+   }
+
+   const byte Gt = (byte)'>';
+   const byte Lf = (byte)'\n';
+
+   static string FindInput(string s)
+   {
+       string CoreRoot = System.Environment.GetEnvironmentVariable("CORE_ROOT");
+
+       if (CoreRoot == null)
+       {
+           Console.WriteLine("This benchmark requries CORE_ROOT to be set");
+           return null;
+       }
+
+       string inputFile = s ?? InputFile;
+
+       // Normal testing -- input file will end up next to the assembly
+       // and CoreRoot points at the test overlay dir
+       string[] pathPartsNormal = new string[] {
+           CoreRoot, "..", "..", "JIT", "Performance",
+           "CodeQuality", "BenchmarksGame", "revcomp", "revcomp", inputFile
+       };
+
+       string inputPathNormal = Path.Combine(pathPartsNormal);
+
+       // Perf testing -- input file will end up next to the assembly
+       // and CoreRoot points at this directory
+       string[] pathPartsPerf = new string[] { CoreRoot, inputFile };
+
+       string inputPathPerf = Path.Combine(pathPartsPerf);
+
+       string inputPath = null;
+
+       if (File.Exists(inputPathNormal))
+       {
+           inputPath = inputPathNormal;
+       }
+       else if (File.Exists(inputPathPerf))
+       {
+           inputPath = inputPathPerf;
+       }
+
+       if (inputPath != null)
+       {
+           Console.WriteLine("Using input file {0}", inputPath);
+       }
+       else
+       {
+           Console.WriteLine("Unable to find input file {0}", inputFile);
+       }
+
+       return inputPath;
+   }
+
+   static int Main(string[] args)
+   {
+       bool verbose = false;
+       string inputFile = InputFile;
+       int iterations = Iterations;
+
+       for (int i = 0; i < args.Length; i++)
+       {
+           if (args[i] == "-v")
+           {
+               verbose = true;
+           }
+           if (args[i] == "-i")
+           {
+               i++;
+
+               if (i < args.Length)
+               {
+                   Int32.TryParse(args[i], out iterations);
+               }
+           }
+           else
+           {
+               inputFile = args[i];
+           }
+       }
+
+       string fullInputFile = FindInput(inputFile);
+
+       if (fullInputFile == null)
+       {
+           return -1;
+       }
+
+       if (iterations != Iterations)
+       {
+           Console.WriteLine("Running {0} iterations", iterations);
+       }
+
+       // Warmup
+       BenchInner(false, fullInputFile);
+
+       Stopwatch sw = Stopwatch.StartNew();
+       for (int j = 0; j < iterations; j++)
+       {
+           BenchInner(verbose, fullInputFile);
+       }
+       sw.Stop();
+       Console.WriteLine("revcomp [{0} iters]: {1}ms", iterations, sw.ElapsedMilliseconds);
+
+       return 100;
+   }
+
+   static void BenchInner(bool doOutput, string inputFile)
+   {
+      InitComplements();
+      var seq = new List<byte[]>();
+      var b = new Block { Count = -1 };
+      Index line = Index.None, start = Index.None, end = Index.None;
+      using (var r = new BinaryReader(File.OpenRead(inputFile))) {
+          using (var w = doOutput ? Console.OpenStandardOutput() : Stream.Null) {
+              while (b.Read(r) > 0) {
+                  seq.Add(b.Data);
+                  if (line.Pos < 0) line = b.IndexOf(Gt, 0);
+                  while (line.Pos >= 0) {
+                      if (start.Pos < 0) {
+                          var off = line.InBlock(b) ? line.Pos : 0;
+                          start = b.IndexOf(Lf, off);
+                          if (start.Pos < 0) {
+                              w.Write(b.Data, off, b.Data.Length - off);
+                              seq.Clear(); break;
+                          }
+                          w.Write(b.Data, off, start.Pos + 1 - off);
+                      }
+                      if (end.Pos < 0) {
+                          end = b.IndexOf(Gt, start.InBlock(b) ? start.Pos : 0);
+                          if (end.Pos < 0) break;
+                      }
+                      w.Reverse(start.Pos, end.Pos, seq);
+                      if (seq.Count > 1) seq.RemoveRange(0, seq.Count - 1);
+                      line = end; end = Index.None; start = Index.None;
+                  }
+              }
+              if (start.Pos >= 0 && end.Pos < 0)
+              w.Reverse(start.Pos, seq[seq.Count -1].Length, seq);
+          }
+      }
+   }
+
+   const string Seq = "ABCDGHKMRTVYabcdghkmrtvy";
+   const string Rev = "TVGHCDMKYABRTVGHCDMKYABR";
+   static byte[] comp = new byte[256];
+
+   static void InitComplements() {
+      for (byte i = 0; i < 255; i++) comp[i] = i;
+      for (int i = 0; i < Seq.Length; i++)
+         comp[(byte)Seq[i]] = (byte)Rev[i];
+      comp[Lf] = 0;  comp[(byte)' '] = 0;
+   }
+
+   const int LineLen = 61;
+   const int BufSize = LineLen * 269;
+   static byte[] buf = new byte[BufSize];
+
+   static void Reverse(this Stream w, int si, int ei, List<byte[]> bl) {
+      int bi = 0, line = LineLen - 1;
+      for (int ri = bl.Count-1; ri >= 0; ri--) {
+         var b = bl[ri]; int off = ri == 0 ? si : 0;
+         for (int i = (ri == bl.Count-1 ? ei : b.Length)-1; i >= off; i--) {
+            var c = comp[b[i]]; if (c > 0) buf[bi++] = c;
+            if (bi == line) {
+               buf[bi++] = Lf; line += LineLen;
+               if (bi == BufSize) {
+                  w.Write(buf, 0, BufSize); bi = 0; line = LineLen - 1;
+               }
+            }
+         }
+      }
+      if (bi > 0) {
+          if (buf[bi-1] != Lf) buf[bi++] = Lf; w.Write(buf, 0, bi);
+      }
+   }
+
+   [Benchmark]
+   public static void Bench()
+   {
+       string inputFile = FindInput(InputFile);
+
+       if (inputFile == null)
+       {
+           throw new Exception("unable to find input");
+       }
+
+        foreach (var iteration in Benchmark.Iterations)
+        {
+            using (iteration.StartMeasurement())
+            {
+                for (int i = 0; i < Iterations; i++)
+                {
+                    BenchInner(false, inputFile);
+                }
+            }
+        }
+   }
+}
+
+}
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeCompare.csproj b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/revcomp/revcomp.csproj
index fc59c167fe..b44017b188 100644
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeCompare.csproj
+++ b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/revcomp/revcomp.csproj
@@ -13,33 +13,41 @@
     <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
     <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
+    <NuGetTargetMoniker>.NETStandard,Version=v1.4</NuGetTargetMoniker>
   </PropertyGroup>
   <!-- Default configurations to help VS understand the configurations -->
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
   </PropertyGroup>
+  <PropertyGroup>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+  </PropertyGroup>
   <ItemGroup>
     <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
       <Visible>False</Visible>
     </CodeAnalysisDependentAssemblyPaths>
   </ItemGroup>
   <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimecompare.cs" />
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
   <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+    <Compile Include="revcomp.csharp-1.cs" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
+    <Content Include="revcomp-input25.txt">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
+    <Content Include="revcomp-input25000.txt">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
   </ItemGroup>
+  <PropertyGroup>
+    <ProjectJson>$(JitPackagesConfigFileDirectory)benchmark\project.json</ProjectJson>
+    <ProjectLockJson>$(JitPackagesConfigFileDirectory)benchmark\project.lock.json</ProjectLockJson>
+  </PropertyGroup>
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
   <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
   </PropertyGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/tests/src/JIT/Performance/CodeQuality/Bytemark/ByteMark.cs b/tests/src/JIT/Performance/CodeQuality/Bytemark/ByteMark.cs
index 10699c67dc..03f45045da 100644
--- a/tests/src/JIT/Performance/CodeQuality/Bytemark/ByteMark.cs
+++ b/tests/src/JIT/Performance/CodeQuality/Bytemark/ByteMark.cs
@@ -120,10 +120,12 @@ internal class global
     public const int LUARRAYROWS = 101;
     public const int LUARRAYCOLS = 101;
 
-
     // EMFLOAT constants
     public const int CPUEMFLOATLOOPMAX = 50000;
     public const int EMFARRAYSIZE = 3000;
+
+    // FOURIER constants
+    public const int FOURIERARRAYSIZE = 100;
 }
 
 /*
@@ -183,7 +185,7 @@ public abstract class HuffStruct : HarnessTest
 
 public abstract class FourierStruct : HarnessTest
 {
-    public int arraysize;                       /* Size of coeff. arrays */
+    public int arraysize = global.FOURIERARRAYSIZE;
     public override void ShowStats()
     {
         ByteMark.OutputString(
@@ -1261,15 +1263,15 @@ public class ByteMark
         global.write_to_file = false;
     }
 
-    const int NumericSortJaggedIterations = 20;
+    const int NumericSortJaggedIterations = 10;
 
     [Benchmark]
     public static void BenchNumericSortJagged()
     {
         Setup();
         NumericSortJagged t = new NumericSortJagged();
-        t.numarrays = 1000;
-        t.adjust = 0;
+        t.numarrays = 200;
+        t.adjust = 1;
 
         foreach (var iteration in Benchmark.Iterations)
         {
@@ -1283,15 +1285,15 @@ public class ByteMark
         }
     }
 
-    const int NumericSortRectangularIterations = 20;
+    const int NumericSortRectangularIterations = 5;
 
     [Benchmark]
     public static void BenchNumericSortRectangular()
     {
         Setup();
         NumericSortRect t = new NumericSortRect();
-        t.numarrays = 1000;
-        t.adjust = 0;
+        t.numarrays = 200;
+        t.adjust = 1;
 
         foreach (var iteration in Benchmark.Iterations)
         {
@@ -1312,8 +1314,8 @@ public class ByteMark
     {
         Setup();
         StringSort t = new StringSort();
-        t.numarrays = 1000;
-        t.adjust = 0;
+        t.numarrays = 40;
+        t.adjust = 1;
 
         foreach (var iteration in Benchmark.Iterations)
         {
@@ -1326,14 +1328,15 @@ public class ByteMark
             }
         }
     }
-    const int BitOpsIterations = 15;
+
+    const int BitOpsIterations = 100000;
 
     [Benchmark]
     public static void BenchBitOps()
     {
         Setup();
         BitOps t = new BitOps();
-        t.adjust = 0;
+        t.adjust = 1;
 
         foreach (var iteration in Benchmark.Iterations)
         {
@@ -1347,15 +1350,15 @@ public class ByteMark
         }
     }
 
-    const int EmFloatIterations = 8;
+    const int EmFloatIterations = 10;
 
     [Benchmark]
     public static void BenchEmFloat()
     {
         Setup();
         EmFloatStruct t = new EMFloat();
-        t.loops = 100;
-        t.adjust = 0;
+        t.loops = 50;
+        t.adjust = 1;
 
         foreach (var iteration in Benchmark.Iterations)
         {
@@ -1369,15 +1372,15 @@ public class ByteMark
         }
     }
 
-    const int EmFloatClassIterations = 8;
+    const int EmFloatClassIterations = 2;
 
     [Benchmark]
     public static void BenchEmFloatClass()
     {
         Setup();
         EmFloatStruct t = new EMFloatClass();
-        t.loops = 100;
-        t.adjust = 0;
+        t.loops = 50;
+        t.adjust = 1;
 
         foreach (var iteration in Benchmark.Iterations)
         {
@@ -1391,14 +1394,14 @@ public class ByteMark
         }
     }
 
-    const int FourierIterations = 20;
+    const int FourierIterations = 300;
 
     [Benchmark]
     public static void BenchFourier()
     {
         Setup();
         FourierStruct t = new Fourier();
-        t.adjust = 0;
+        t.adjust = 1;
 
         foreach (var iteration in Benchmark.Iterations)
         {
@@ -1412,15 +1415,15 @@ public class ByteMark
         }
     }
 
-    const int AssignJaggedIterations = 15;
+    const int AssignJaggedIterations = 2;
 
     [Benchmark]
     public static void BenchAssignJagged()
     {
         Setup();
         AssignStruct t = new AssignJagged();
-        t.numarrays = 1000;
-        t.adjust = 0;
+        t.numarrays = 25;
+        t.adjust = 1;
 
         foreach (var iteration in Benchmark.Iterations)
         {
@@ -1434,15 +1437,15 @@ public class ByteMark
         }
     }
 
-    const int AssignRectangularIterations = 20;
+    const int AssignRectangularIterations = 5;
 
     [Benchmark]
     public static void BenchAssignRectangular()
     {
         Setup();
         AssignStruct t = new AssignRect();
-        t.numarrays = 1000;
-        t.adjust = 0;
+        t.numarrays = 10;
+        t.adjust = 1;
 
         foreach (var iteration in Benchmark.Iterations)
         {
@@ -1456,7 +1459,7 @@ public class ByteMark
         }
     }
 
-    const int IDEAEncryptionIterations = 20;
+    const int IDEAEncryptionIterations = 50;
 
     [Benchmark]
     public static void BenchIDEAEncryption()
@@ -1464,7 +1467,7 @@ public class ByteMark
         Setup();
         IDEAStruct t = new IDEAEncryption();
         t.loops = 100;
-        t.adjust = 0;
+        t.adjust = 1;
 
         foreach (var iteration in Benchmark.Iterations)
         {
@@ -1478,15 +1481,15 @@ public class ByteMark
         }
     }
 
-    const int NeuralJaggedIterations = 20;
+    const int NeuralJaggedIterations = 10;
 
     [Benchmark]
     public static void BenchNeuralJagged()
     {
         Setup();
         NNetStruct t = new NeuralJagged();
-        t.loops = 100;
-        t.adjust = 0;
+        t.loops = 3;
+        t.adjust = 1;
 
         foreach (var iteration in Benchmark.Iterations)
         {
@@ -1500,15 +1503,15 @@ public class ByteMark
         }
     }
 
-    const int NeuralIterations = 12;
+    const int NeuralIterations = 20;
 
     [Benchmark]
     public static void BenchNeural()
     {
         Setup();
         NNetStruct t = new Neural();
-        t.loops = 100;
-        t.adjust = 0;
+        t.loops = 1;
+        t.adjust = 1;
 
         foreach (var iteration in Benchmark.Iterations)
         {
@@ -1522,15 +1525,15 @@ public class ByteMark
         }
     }
 
-    const int LUDecompIterations = 20;
+    const int LUDecompIterations = 10;
 
     [Benchmark]
     public static void BenchLUDecomp()
     {
         Setup();
         LUStruct t = new LUDecomp();
-        t.numarrays = 1000;
-        t.adjust = 0;
+        t.numarrays = 250;
+        t.adjust = 1;
 
         foreach (var iteration in Benchmark.Iterations)
         {
diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_370233/DevDiv_370233.il b/tests/src/JIT/Regression/JitBlue/DevDiv_370233/DevDiv_370233.il
new file mode 100644
index 0000000000..3da4b63953
--- /dev/null
+++ b/tests/src/JIT/Regression/JitBlue/DevDiv_370233/DevDiv_370233.il
@@ -0,0 +1,136 @@
+.assembly extern mscorlib{}
+.assembly DevDiv_370233{}
+.class C extends [mscorlib]System.Object
+{
+   .method static unsigned int32 M(bool, bool)
+   {
+      .maxstack  65535
+      .locals init (unsigned int32, unsigned int64, unsigned int8, unsigned int8, native int, float64, char, unsigned int16, bool, char, bool)
+
+      ldloc 0x0006
+      ldc.i4 0x11467af6
+      shr
+      conv.ovf.u8
+      dup
+      sub
+      ldloc.s 0x06
+      ldloc.s 0x07
+      neg
+      rem.un
+      conv.ovf.i8.un
+      xor
+      neg
+      conv.ovf.u
+      conv.r4
+      ldloc 0x0005
+      ldloc.s 0x05
+      ckfinite
+      ckfinite
+      conv.r4
+      ceq
+      ldarg 0x0001
+      conv.r4
+      pop
+      pop
+      ldloc 0x0001
+      ldloc 0x0001
+      neg
+      conv.i8
+      ldloc.s 0x04
+      shr
+      clt.un
+      conv.ovf.i1.un
+      conv.i8
+      not
+      nop
+      ldc.i8 0x16cb54ea7cfcd50d
+      ldloc 0x0001
+      clt
+      ldloc.s 0x01
+      conv.ovf.u1
+      conv.ovf.i2.un
+      cgt
+      conv.ovf.i8
+      ldc.i8 0x6be45c7b8c08f1d5
+      conv.ovf.u8
+      ldloc.s 0x01
+      add.ovf
+      not
+      ldloc.s 0x03
+      shr.un
+      ldloc.s 0x01
+      add
+      not
+      ldloc.s 0x03
+      neg
+      shr
+      nop
+      conv.u4
+      neg
+      shr.un
+      ceq
+      ldloc 0x0001
+      conv.r4
+      ldc.r8 float64(0x9b4c7410aec1e6d3)
+      add
+      ldloc.s 0x00
+      ldarg.s 0x00
+      xor
+      ldloc.s 0x08
+      mul
+      not
+      conv.r.un
+      ldloc.s 0x02
+      ldloc 0x0006
+      add
+      conv.r4
+      mul
+      cgt
+      ldloc.s 0x05
+      ldloc.s 0x05
+      cgt.un
+      ldarg 0x0001
+      not
+      shl
+      div
+      ldc.i8 0x5892c0a0bd150d05
+      ldc.i8 0x8c33eb17e67e9772
+      neg
+      ceq
+      not
+      ldloc.s 0x00
+      ldloc 0x0003
+      ceq
+      or
+      pop
+      xor
+      conv.r.un
+      ceq
+      conv.u2
+      ret
+   }
+
+   .method static int32 Main() cil managed
+   {
+       .entrypoint
+
+       .try
+       {
+           ldc.i4     0
+           ldc.i4.s   0
+           call unsigned int32 C::M(bool, bool)
+           pop
+           leave.s done
+       }
+       catch [mscorlib]System.Exception
+       {
+           pop
+           leave.s done
+       }
+
+   done:
+       ldc.i4 100
+       ret
+   }
+}
+// Dumped 1
diff --git a/tests/src/CoreMangLib/system/text/encoding/Shift_Jis.csproj b/tests/src/JIT/Regression/JitBlue/DevDiv_370233/DevDiv_370233.ilproj
index 3b9cd94f3e..4642defb16 100644
--- a/tests/src/CoreMangLib/system/text/encoding/Shift_Jis.csproj
+++ b/tests/src/JIT/Regression/JitBlue/DevDiv_370233/DevDiv_370233.ilproj
@@ -4,6 +4,7 @@
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <AssemblyName>$(MSBuildProjectName)</AssemblyName>
     <SchemaVersion>2.0</SchemaVersion>
     <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
     <OutputType>Exe</OutputType>
@@ -13,10 +14,6 @@
     <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
     <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
   </PropertyGroup>
   <!-- Default configurations to help VS understand the configurations -->
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
@@ -28,18 +25,27 @@
       <Visible>False</Visible>
     </CodeAnalysisDependentAssemblyPaths>
   </ItemGroup>
+  <PropertyGroup>
+    <DebugType>None</DebugType>
+    <Optimize>True</Optimize>
+  </PropertyGroup>
   <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="shift_jis.cs" />
+    <Compile Include="DevDiv_370233.il" />
   </ItemGroup>
+  <PropertyGroup>
+    <CLRTestBatchPreCommands><![CDATA[
+$(CLRTestBatchPreCommands)
+set COMPlus_JitStressRegs=0x200
+]]></CLRTestBatchPreCommands>
+  <BashCLRTestPreCommands><![CDATA[
+$(BashCLRTestPreCommands)
+export COMPlus_JitStressRegs=0x200
+]]></BashCLRTestPreCommands>
+  </PropertyGroup>
   <ItemGroup>
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
   <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
+  </PropertyGroup> 
+</Project>
diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_377155/DevDiv_377155.il b/tests/src/JIT/Regression/JitBlue/DevDiv_377155/DevDiv_377155.il
new file mode 100644
index 0000000000..4c1ab4a125
--- /dev/null
+++ b/tests/src/JIT/Regression/JitBlue/DevDiv_377155/DevDiv_377155.il
@@ -0,0 +1,75 @@
+// ProcessName - 'ILGEN'
+.assembly extern mscorlib{}
+.assembly DevDiv_377155{}
+.class C extends [mscorlib]System.Object
+{
+   .method static float32 M() cil managed noinlining
+   {
+      .maxstack  65535
+      .locals init (float64, native unsigned int, native int, char, unsigned int64, bool)
+
+      ldloc.s 0x04
+      conv.ovf.u8.un
+      conv.ovf.u2.un
+      ldc.r8 float64(0x9eda41f595fa8ca8)
+      conv.r4
+      conv.u8
+      pop
+      ldc.i4 0x1de50978
+      ldloc 0x0004
+      ldloc.s 0x04
+      or
+      ldc.i8 0x2d9c5178675b7af5
+      ldloc 0x0004
+      ldloc 0x0004
+      mul
+      ldloc.s 0x04
+      conv.ovf.u2.un
+      shr.un
+      not
+      not
+      or
+      cgt.un
+      ldc.i4 0xbdc937ef
+      ldloc.s 0x05
+      add.ovf.un
+      clt.un
+      shl
+      not
+      neg
+      shr.un
+      conv.r4
+      ckfinite
+      ldloc.s 0x00
+      clt.un
+      nop
+      brtrue IL_0052
+      nop
+IL_0052:
+      ldloc 0x0000
+      ret
+   }
+
+   .method static int32 Main() cil managed
+   {
+       .entrypoint
+
+       .try
+       {
+           call float32 C::M()
+           pop
+           leave.s done
+       }
+       catch [mscorlib]System.Exception
+       {
+           pop
+           leave.s done
+       }
+
+   done:
+       ldc.i4 100
+       ret
+   }
+
+}
+// Dumped 1
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeNow.csproj b/tests/src/JIT/Regression/JitBlue/DevDiv_377155/DevDiv_377155.ilproj
index bfc039f80f..32d609496e 100644
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeNow.csproj
+++ b/tests/src/JIT/Regression/JitBlue/DevDiv_377155/DevDiv_377155.ilproj
@@ -4,6 +4,7 @@
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <AssemblyName>$(MSBuildProjectName)</AssemblyName>
     <SchemaVersion>2.0</SchemaVersion>
     <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
     <OutputType>Exe</OutputType>
@@ -13,10 +14,6 @@
     <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
     <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
   </PropertyGroup>
   <!-- Default configurations to help VS understand the configurations -->
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
@@ -28,18 +25,27 @@
       <Visible>False</Visible>
     </CodeAnalysisDependentAssemblyPaths>
   </ItemGroup>
+  <PropertyGroup>
+    <DebugType>None</DebugType>
+    <Optimize>True</Optimize>
+  </PropertyGroup>
   <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimenow.cs" />
+    <Compile Include="DevDiv_377155.il" />
   </ItemGroup>
+  <PropertyGroup>
+    <CLRTestBatchPreCommands><![CDATA[
+$(CLRTestBatchPreCommands)
+set COMPlus_JitStressRegs=0x200
+]]></CLRTestBatchPreCommands>
+  <BashCLRTestPreCommands><![CDATA[
+$(BashCLRTestPreCommands)
+export COMPlus_JitStressRegs=0x200
+]]></BashCLRTestPreCommands>
+  </PropertyGroup>
   <ItemGroup>
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-  </ItemGroup>
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
   <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
-  </PropertyGroup>
-</Project>
\ No newline at end of file
+  </PropertyGroup> 
+</Project>
diff --git a/tests/src/JIT/SIMD/Vector3GetHash.cs b/tests/src/JIT/SIMD/Vector3GetHash.cs
new file mode 100644
index 0000000000..21742e0ef3
--- /dev/null
+++ b/tests/src/JIT/SIMD/Vector3GetHash.cs
@@ -0,0 +1,80 @@
+// 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.
+
+// This was copied from corefx\src\System.Numerics.Vectors\tests\Vector3Tests.cs.
+// It exposed a bug in morph, in which a SIMD field was being morphed in
+// a MACK_Ind context, even though it was under a GT_IND(G_ADDR()).
+// This was corefx issue #15713, and was "fixed" with coreclr PR # 9496,
+// and a new issue, #9518, has been filed to track the underlying unexpected
+// MACK_Ind context, which causes us to mark the Vector3 local as do-not-enregister.
+
+using System;
+using System.Numerics;
+
+internal partial class VectorTest
+{
+    private const int Pass = 100;
+    private const int Fail = -1;
+
+    public class Assert
+    {
+        public static void Equal(float f1, float f2)
+        {
+            if (f1 != f2)
+            {
+                throw new Exception("Assert.Equal failed");
+            }
+        }
+        public static void NotEqual(float f1, float f2)
+        {
+            if (f1 == f2)
+            {
+                throw new Exception("Assert.NotEqual failed");
+            }
+        }
+    }
+    public struct SimpleVector3
+    {
+        public static void Vector3GetHashCodeTest()
+        {
+            Vector3 v1 = new Vector3(2.0f, 3.0f, 3.3f);
+            Vector3 v2 = new Vector3(2.0f, 3.0f, 3.3f);
+            Vector3 v3 = new Vector3(2.0f, 3.0f, 3.3f);
+            Vector3 v5 = new Vector3(3.0f, 2.0f, 3.3f);
+            Assert.Equal(v1.GetHashCode(), v1.GetHashCode());
+            Assert.Equal(v1.GetHashCode(), v2.GetHashCode());
+            Assert.NotEqual(v1.GetHashCode(), v5.GetHashCode());
+            Assert.Equal(v1.GetHashCode(), v3.GetHashCode());
+            Vector3 v4 = new Vector3(0.0f, 0.0f, 0.0f);
+            Vector3 v6 = new Vector3(1.0f, 0.0f, 0.0f);
+            Vector3 v7 = new Vector3(0.0f, 1.0f, 0.0f);
+            Vector3 v8 = new Vector3(1.0f, 1.0f, 1.0f);
+            Vector3 v9 = new Vector3(1.0f, 1.0f, 0.0f);
+            Assert.NotEqual(v4.GetHashCode(), v6.GetHashCode());
+            Assert.NotEqual(v4.GetHashCode(), v7.GetHashCode());
+            Assert.NotEqual(v4.GetHashCode(), v8.GetHashCode());
+            Assert.NotEqual(v7.GetHashCode(), v6.GetHashCode());
+            Assert.NotEqual(v8.GetHashCode(), v6.GetHashCode());
+            Assert.NotEqual(v8.GetHashCode(), v9.GetHashCode());
+            Assert.NotEqual(v7.GetHashCode(), v9.GetHashCode());
+        }
+
+        public static int Main( string[] args )
+        {
+            int returnVal = Pass;
+
+            try
+            {
+                Vector3GetHashCodeTest();
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine("FAILED: " + e.Message);
+                returnVal = Fail;
+            }
+            return returnVal;
+        }
+    }
+}
+
diff --git a/tests/src/CoreMangLib/system/datetime/Co7510ParseExact_formatarray.csproj b/tests/src/JIT/SIMD/Vector3GetHash_r.csproj
index 6475443219..183dccf3f4 100644
--- a/tests/src/CoreMangLib/system/datetime/Co7510ParseExact_formatarray.csproj
+++ b/tests/src/JIT/SIMD/Vector3GetHash_r.csproj
@@ -13,32 +13,34 @@
     <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
     <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
   </PropertyGroup>
   <!-- Default configurations to help VS understand the configurations -->
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
   </PropertyGroup>
   <ItemGroup>
     <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
       <Visible>False</Visible>
     </CodeAnalysisDependentAssemblyPaths>
   </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="co7510parseexact_formatarray.cs" />
-  </ItemGroup>
+  <PropertyGroup>
+    <DebugType>None</DebugType>
+    <Optimize></Optimize>
+  </PropertyGroup>
   <ItemGroup>
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
+    <Compile Include="Vector3GetHash.cs" />
   </ItemGroup>
+  <!--  <PropertyGroup>
+    <ProjectJson>$(JitPackagesConfigFileDirectory)threading+thread\project.json</ProjectJson>
+    <ProjectLockJson>$(JitPackagesConfigFileDirectory)threading+thread\project.lock.json</ProjectLockJson>
+  </PropertyGroup>-->
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
   <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
   </PropertyGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/tests/src/CoreMangLib/cti/system/datetime/DateTimeKind.csproj b/tests/src/JIT/SIMD/Vector3GetHash_ro.csproj
index 069fff57c6..3228f62369 100644
--- a/tests/src/CoreMangLib/cti/system/datetime/DateTimeKind.csproj
+++ b/tests/src/JIT/SIMD/Vector3GetHash_ro.csproj
@@ -13,33 +13,34 @@
     <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
     <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <ReferenceLocalMscorlib>false</ReferenceLocalMscorlib>
-    <CLRTestKind>BuildAndRun</CLRTestKind>
-    <CLRTestPriority>1</CLRTestPriority>
   </PropertyGroup>
   <!-- Default configurations to help VS understand the configurations -->
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
   </PropertyGroup>
   <ItemGroup>
     <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
       <Visible>False</Visible>
     </CodeAnalysisDependentAssemblyPaths>
   </ItemGroup>
-  <ItemGroup>
-    <!-- Add Compile Object Here -->
-    <Compile Include="datetimekind.cs" />
-  </ItemGroup>
+  <PropertyGroup>
+    <DebugType>None</DebugType>
+    <Optimize>True</Optimize>
+  </PropertyGroup>
   <ItemGroup>
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
-    <ProjectReference Include="../../../../Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
+    <Compile Include="Vector3GetHash.cs" />
   </ItemGroup>
+  <!--  <PropertyGroup>
+    <ProjectJson>$(JitPackagesConfigFileDirectory)threading+thread\project.json</ProjectJson>
+    <ProjectLockJson>$(JitPackagesConfigFileDirectory)threading+thread\project.lock.json</ProjectLockJson>
+  </PropertyGroup>-->
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
   <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' ">
   </PropertyGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/tests/src/JIT/SIMD/VectorMin.cs b/tests/src/JIT/SIMD/VectorMin.cs
index 8757eba5b9..4a9fd90038 100644
--- a/tests/src/JIT/SIMD/VectorMin.cs
+++ b/tests/src/JIT/SIMD/VectorMin.cs
@@ -39,6 +39,7 @@ internal partial class VectorTest
             if (!(CheckValue<float>(C.X, result))) return Fail;
             if (!(CheckValue<float>(C.Y, result))) return Fail;
             if (!(CheckValue<float>(C.Z, result))) return Fail;
+            if (!(CheckValue<float>(C.W, result))) return Fail;
             return Pass;
         }
     }
diff --git a/tests/src/JIT/SIMD/VectorReturn.cs b/tests/src/JIT/SIMD/VectorReturn.cs
index d1785af450..083f4b274e 100644
--- a/tests/src/JIT/SIMD/VectorReturn.cs
+++ b/tests/src/JIT/SIMD/VectorReturn.cs
@@ -11,50 +11,134 @@ internal partial class VectorTest
 {
     private const int Pass = 100;
     private const int Fail = -1;
-    private static Vector2[] s_A;
-    private static Vector2 s_p0;
-    private static Vector2 s_p1;
-    private static Vector2 s_p2;
-    private static Vector2 s_p3;
+
+    private static Vector2[] s_v2_array;
+    private static Vector2 s_v2_0;
+    private static Vector2 s_v2_1;
+    private static Vector2 s_v2_2;
+    private static Vector2 s_v2_3;
+
+    private static Vector3[] s_v3_array;
+    private static Vector3 s_v3_0;
+    private static Vector3 s_v3_1;
+    private static Vector3 s_v3_2;
+    private static Vector3 s_v3_3;
+
+    private static Vector4[] s_v4_array;
+    private static Vector4 s_v4_0;
+    private static Vector4 s_v4_1;
+    private static Vector4 s_v4_2;
+    private static Vector4 s_v4_3;
 
     [MethodImplAttribute(MethodImplOptions.NoInlining)]
     public static void init()
     {
-        s_A = new Vector2[10];
         Random random = new Random(100);
+
+        s_v2_array = new Vector2[10];
+        for (int i = 0; i < 10; i++)
+        {
+            s_v2_array[i] = new Vector2(random.Next(100));
+        }
+        s_v2_0 = new Vector2(random.Next(100));
+        s_v2_1 = new Vector2(random.Next(100));
+        s_v2_2 = new Vector2(random.Next(100));
+        s_v2_3 = new Vector2(random.Next(100));
+
+        s_v3_array = new Vector3[10];
         for (int i = 0; i < 10; i++)
         {
-            s_A[i] = new Vector2(random.Next(100));
+            s_v3_array[i] = new Vector3(random.Next(100));
         }
-        s_p0 = new Vector2(random.Next(100));
-        s_p1 = new Vector2(random.Next(100));
-        s_p2 = new Vector2(random.Next(100));
-        s_p3 = new Vector2(random.Next(100));
+        s_v3_0 = new Vector3(random.Next(100));
+        s_v3_1 = new Vector3(random.Next(100));
+        s_v3_2 = new Vector3(random.Next(100));
+        s_v3_3 = new Vector3(random.Next(100));
+
+        s_v4_array = new Vector4[10];
+        for (int i = 0; i < 10; i++)
+        {
+            s_v4_array[i] = new Vector4(random.Next(100));
+        }
+        s_v4_0 = new Vector4(random.Next(100));
+        s_v4_1 = new Vector4(random.Next(100));
+        s_v4_2 = new Vector4(random.Next(100));
+        s_v4_3 = new Vector4(random.Next(100));
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector2 F1(float t)
+    public static Vector2 F1_v2(float t)
     {
         float ti = 1 - t;
         float t0 = ti * ti * ti;
         float t1 = 3 * ti * ti * t;
         float t2 = 3 * ti * t * t;
         float t3 = t * t * t;
-        return (t0 * s_p0) + (t1 * s_p1) + (t2 * s_p2) + (t3 * s_p3);
+        return (t0 * s_v2_0) + (t1 * s_v2_1) + (t2 * s_v2_2) + (t3 * s_v2_3);
     }
 
     [MethodImplAttribute(MethodImplOptions.NoInlining)]
-    public static Vector2 F2(float u)
+    public static Vector2 F2_v2(float u)
     {
         if (u < 0)
-            return s_A[0];
+            return s_v2_array[0];
         if (u >= 1)
-            return s_A[1];
+            return s_v2_array[1];
         if (u < 0.1)
-            return s_A[2];
+            return s_v2_array[2];
         if (u > 0.9)
-            return s_A[3];
-        return F1(u);
+            return s_v2_array[3];
+        return F1_v2(u);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector3 F1_v3(float t)
+    {
+        float ti = 1 - t;
+        float t0 = ti * ti * ti;
+        float t1 = 3 * ti * ti * t;
+        float t2 = 3 * ti * t * t;
+        float t3 = t * t * t;
+        return (t0 * s_v3_0) + (t1 * s_v3_1) + (t2 * s_v3_2) + (t3 * s_v3_3);
+    }
+
+    [MethodImplAttribute(MethodImplOptions.NoInlining)]
+    public static Vector3 F2_v3(float u)
+    {
+        if (u < 0)
+            return s_v3_array[0];
+        if (u >= 1)
+            return s_v3_array[1];
+        if (u < 0.1)
+            return s_v3_array[2];
+        if (u > 0.9)
+            return s_v3_array[3];
+        return F1_v3(u);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4 F1_v4(float t)
+    {
+        float ti = 1 - t;
+        float t0 = ti * ti * ti;
+        float t1 = 3 * ti * ti * t;
+        float t2 = 3 * ti * t * t;
+        float t3 = t * t * t;
+        return (t0 * s_v4_0) + (t1 * s_v4_1) + (t2 * s_v4_2) + (t3 * s_v4_3);
+    }
+
+    [MethodImplAttribute(MethodImplOptions.NoInlining)]
+    public static Vector4 F2_v4(float u)
+    {
+        if (u < 0)
+            return s_v4_array[0];
+        if (u >= 1)
+            return s_v4_array[1];
+        if (u < 0.1)
+            return s_v4_array[2];
+        if (u > 0.9)
+            return s_v4_array[3];
+        return F1_v4(u);
     }
 
     [MethodImplAttribute(MethodImplOptions.NoInlining)]
@@ -133,25 +217,51 @@ internal partial class VectorTest
     public static int Main()
     {
         init();
-        Vector2 result = F2(0.5F);
-        Vector2 expectedResult = F1(0.5F);
-        Console.WriteLine("Result is " + result.ToString());
-        if (!CheckValue<float>(result.X, expectedResult.X) || !CheckValue<float>(result.Y, expectedResult.Y))
+
+        Vector2 result_v2 = F2_v2(0.5F);
+        Vector2 expectedResult_v2 = F1_v2(0.5F);
+        Console.WriteLine("Result is " + result_v2.ToString());
+        if (!CheckValue<float>(result_v2.X, expectedResult_v2.X) || !CheckValue<float>(result_v2.Y, expectedResult_v2.Y))
+        {
+            Console.WriteLine("Expected result is " + expectedResult_v2.ToString());
+            Console.WriteLine("Vector2 test FAILED");
+            return Fail;
+        }
+
+        Vector3 result_v3 = F2_v3(0.6F);
+        Vector3 expectedResult_v3 = F1_v3(0.6F);
+        Console.WriteLine("Result is " + result_v3.ToString());
+        if (!CheckValue<float>(result_v3.X, expectedResult_v3.X) ||
+            !CheckValue<float>(result_v3.Y, expectedResult_v3.Y) ||
+            !CheckValue<float>(result_v3.Z, expectedResult_v3.Z))
+        {
+            Console.WriteLine("Expected result is " + expectedResult_v3.ToString());
+            Console.WriteLine("Vector3 test FAILED");
+            return Fail;
+        }
+
+        Vector4 result_v4 = F2_v4(0.7F);
+        Vector4 expectedResult_v4 = F1_v4(0.7F);
+        Console.WriteLine("Result is " + result_v4.ToString());
+        if (!CheckValue<float>(result_v4.X, expectedResult_v4.X) ||
+            !CheckValue<float>(result_v4.Y, expectedResult_v4.Y) ||
+            !CheckValue<float>(result_v4.Z, expectedResult_v4.Z) ||
+            !CheckValue<float>(result_v4.W, expectedResult_v4.W))
         {
-            Console.WriteLine("Expected result is " + expectedResult.ToString());
-            Console.WriteLine("FAILED");
+            Console.WriteLine("Expected result is " + expectedResult_v4.ToString());
+            Console.WriteLine("Vector4 test FAILED");
             return Fail;
         }
 
         if (VectorTReturnTest() != Pass)
         {
-            Console.WriteLine("FAILED");
+            Console.WriteLine("VectorTReturnTest FAILED");
             return Fail;
         }
 
         if (Vector3ReturnTest() != Pass)
         {
-            Console.WriteLine("FAILED");
+            Console.WriteLine("Vector3ReturnTest FAILED");
             return Fail;
         }
 
diff --git a/tests/src/JIT/SIMD/VectorUtil.cs b/tests/src/JIT/SIMD/VectorUtil.cs
index 6501aac767..2249ff84e0 100644
--- a/tests/src/JIT/SIMD/VectorUtil.cs
+++ b/tests/src/JIT/SIMD/VectorUtil.cs
@@ -26,7 +26,7 @@ internal partial class VectorTest
         }
         if (returnVal == false)
         {
-            Console.WriteLine("CheckValue failed for " + expectedValue + " of type " + typeof(T).ToString());
+            Console.WriteLine("CheckValue failed for type " + typeof(T).ToString() + ". Expected: {0} (0x{0:X}), Got: {1} (0x{1:X})", expectedValue, value);
         }
         return returnVal;
     }
diff --git a/tests/src/JIT/config/benchmark+roslyn/project.json b/tests/src/JIT/config/benchmark+roslyn/project.json
index 07d127704d..8c03f09e08 100644
--- a/tests/src/JIT/config/benchmark+roslyn/project.json
+++ b/tests/src/JIT/config/benchmark+roslyn/project.json
@@ -4,7 +4,7 @@
     "Microsoft.DotNet.xunit.performance": "1.0.0-alpha-build0040",
     "Microsoft.DotNet.xunit.performance.analysis": "1.0.0-alpha-build0040",
     "Microsoft.DotNet.xunit.performance.runner.Windows": "1.0.0-alpha-build0040",
-    "Microsoft.NETCore.Platforms": "2.0.0-beta-24924-02",
+    "Microsoft.NETCore.Platforms": "2.0.0-beta-25007-01",
     "System.Console": "4.4.0-beta-24913-02",
     "System.Dynamic.Runtime": "4.4.0-beta-24913-02",
     "System.Linq": "4.4.0-beta-24913-02",
diff --git a/tests/src/JIT/config/benchmark+serialize/project.json b/tests/src/JIT/config/benchmark+serialize/project.json
index c3e31c3d3d..7cc415cd3c 100644
--- a/tests/src/JIT/config/benchmark+serialize/project.json
+++ b/tests/src/JIT/config/benchmark+serialize/project.json
@@ -3,7 +3,7 @@
     "Microsoft.DotNet.xunit.performance": "1.0.0-alpha-build0040",
     "Microsoft.DotNet.xunit.performance.analysis": "1.0.0-alpha-build0040",
     "Microsoft.DotNet.xunit.performance.runner.Windows": "1.0.0-alpha-build0040",
-    "Microsoft.NETCore.Platforms": "2.0.0-beta-24924-02",
+    "Microsoft.NETCore.Platforms": "2.0.0-beta-25007-01",
     "Newtonsoft.Json": "7.0.1",
     "System.Console": "4.4.0-beta-24913-02",
     "System.IO": "4.4.0-beta-24913-02",
diff --git a/tests/src/JIT/config/benchmark/project.json b/tests/src/JIT/config/benchmark/project.json
index 3d091c10da..2a989f150f 100644
--- a/tests/src/JIT/config/benchmark/project.json
+++ b/tests/src/JIT/config/benchmark/project.json
@@ -3,11 +3,12 @@
     "Microsoft.DotNet.xunit.performance": "1.0.0-alpha-build0040",
     "Microsoft.DotNet.xunit.performance.analysis": "1.0.0-alpha-build0040",
     "Microsoft.DotNet.xunit.performance.runner.Windows": "1.0.0-alpha-build0040",
-    "Microsoft.NETCore.Platforms": "2.0.0-beta-24924-02",
+    "Microsoft.NETCore.Platforms": "2.0.0-beta-25007-01",
     "System.Collections.NonGeneric": "4.4.0-beta-24913-02",
     "System.Console": "4.4.0-beta-24913-02",
     "System.IO.FileSystem": "4.4.0-beta-24913-02",
     "System.Linq": "4.4.0-beta-24913-02",
+    "System.Linq.Parallel": "4.4.0-beta-24913-02",
     "System.Linq.Expressions": "4.4.0-beta-24913-02",
     "System.Memory": "4.4.0-beta-24913-02",
     "System.Numerics.Vectors": "4.4.0-beta-24913-02",
@@ -21,6 +22,7 @@
     "System.Threading": "4.4.0-beta-24913-02",
     "System.Threading.Tasks": "4.4.0-beta-24913-02",
     "System.Threading.Tasks.Parallel": "4.4.0-beta-24913-02",
+    "System.Threading.ThreadPool": "4.4.0-beta-24913-02",
     "System.Diagnostics.Process": "4.4.0-beta-24913-02",
     "System.Xml.XmlDocument": "4.4.0-beta-24913-02",
     "System.Xml.XPath": "4.4.0-beta-24913-02",
diff --git a/tests/src/JIT/config/extra/project.json b/tests/src/JIT/config/extra/project.json
index 894b0eaf47..6eb6621dbf 100644
--- a/tests/src/JIT/config/extra/project.json
+++ b/tests/src/JIT/config/extra/project.json
@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "Microsoft.NETCore.Platforms": "2.0.0-beta-24924-02",
+    "Microsoft.NETCore.Platforms": "2.0.0-beta-25007-01",
     "System.Collections": "4.4.0-beta-24913-02",
     "System.Console": "4.4.0-beta-24913-02",
     "System.Diagnostics.Debug": "4.4.0-beta-24913-02",
@@ -24,9 +24,12 @@
     "win7-x86": {},
     "win7-x64": {},
     "ubuntu.14.04-x64": {},
+    "ubuntu.16.04-x64": {},
+    "ubuntu.16.10-x64": {},
     "osx.10.10-x64": {},
     "centos.7-x64": {},
     "rhel.7-x64": {},
-    "debian.8-x64": {}
+    "debian.8-x64": {},
+    "fedora.23-x64": {}
   }
 }
diff --git a/tests/src/JIT/config/minimal/project.json b/tests/src/JIT/config/minimal/project.json
index f21355b860..a3ae795da5 100644
--- a/tests/src/JIT/config/minimal/project.json
+++ b/tests/src/JIT/config/minimal/project.json
@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "Microsoft.NETCore.Platforms": "2.0.0-beta-24924-02",
+    "Microsoft.NETCore.Platforms": "2.0.0-beta-25007-01",
     "System.Console": "4.4.0-beta-24913-02",
     "System.Runtime": "4.4.0-beta-24913-02",
     "System.Runtime.Extensions": "4.4.0-beta-24913-02",
@@ -13,9 +13,12 @@
     "win7-x86": {},
     "win7-x64": {},
     "ubuntu.14.04-x64": {},
+    "ubuntu.16.04-x64": {},
+    "ubuntu.16.10-x64": {},
     "osx.10.10-x64": {},
     "centos.7-x64": {},
     "rhel.7-x64": {},
-    "debian.8-x64": {}
+    "debian.8-x64": {},
+    "fedora.23-x64": {}
   }
 }
diff --git a/tests/src/JIT/config/threading+thread/project.json b/tests/src/JIT/config/threading+thread/project.json
index 01c2ee8e6c..c071d59dde 100644
--- a/tests/src/JIT/config/threading+thread/project.json
+++ b/tests/src/JIT/config/threading+thread/project.json
@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "Microsoft.NETCore.Platforms": "2.0.0-beta-24924-02",
+    "Microsoft.NETCore.Platforms": "2.0.0-beta-25007-01",
     "System.Console": "4.4.0-beta-24913-02",
     "System.Numerics.Vectors": "4.4.0-beta-24913-02",
     "System.Runtime": "4.4.0-beta-24913-02",
@@ -15,9 +15,12 @@
     "win7-x86": {},
     "win7-x64": {},
     "ubuntu.14.04-x64": {},
+    "ubuntu.16.04-x64": {},
+    "ubuntu.16.10-x64": {},
     "osx.10.10-x64": {},
     "centos.7-x64": {},
     "rhel.7-x64": {},
-    "debian.8-x64": {}
+    "debian.8-x64": {},
+    "fedora.23-x64": {}
   }
 }
diff --git a/tests/src/JIT/config/threading/project.json b/tests/src/JIT/config/threading/project.json
index 773e1cda33..fee08e069c 100644
--- a/tests/src/JIT/config/threading/project.json
+++ b/tests/src/JIT/config/threading/project.json
@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "Microsoft.NETCore.Platforms": "2.0.0-beta-24924-02",
+    "Microsoft.NETCore.Platforms": "2.0.0-beta-25007-01",
     "System.Console": "4.4.0-beta-24913-02",
     "System.Runtime": "4.4.0-beta-24913-02",
     "System.Runtime.Extensions": "4.4.0-beta-24913-02",
@@ -13,9 +13,12 @@
     "win7-x86": {},
     "win7-x64": {},
     "ubuntu.14.04-x64": {},
+    "ubuntu.16.04-x64": {},
+    "ubuntu.16.10-x64": {},
     "osx.10.10-x64": {},
     "centos.7-x64": {},
     "rhel.7-x64": {},
-    "debian.8-x64": {}
+    "debian.8-x64": {},
+    "fedora.23-x64": {}
   }
 }
diff --git a/tests/src/TestWrappersConfig/project.json b/tests/src/TestWrappersConfig/project.json
index f255e3044f..b740fed73a 100644
--- a/tests/src/TestWrappersConfig/project.json
+++ b/tests/src/TestWrappersConfig/project.json
@@ -1,5 +1,6 @@
 {
   "dependencies": {
+    "Microsoft.NETCore.Platforms": "2.0.0-beta-25007-01",
     "xunit": "2.2.0-beta2-build3300",
     "xunit.assert": "2.2.0-beta2-build3300",
     "xunit.core": "2.2.0-beta2-build3300",
@@ -8,7 +9,7 @@
   "frameworks": {
     "netcoreapp1.1": {
       "imports": [
-        "dnxcore50",  
+        "dnxcore50",
         "portable-net45+win8"
       ]
     },
@@ -20,9 +21,12 @@
     "win7-x86": {},
     "win7-x64": {},
     "ubuntu.14.04-x64": {},
+    "ubuntu.16.04-x64": {},
+    "ubuntu.16.10-x64": {},
     "osx.10.10-x64": {},
     "centos.7-x64": {},
     "rhel.7-x64": {},
-    "debian.8-x64": {}
+    "debian.8-x64": {},
+    "fedora.23-x64": {}
   }
 }
diff --git a/tests/src/dir.common.props b/tests/src/dir.common.props
index d5de5794d0..5a7ee2e83a 100644
--- a/tests/src/dir.common.props
+++ b/tests/src/dir.common.props
@@ -45,7 +45,7 @@
     <__NativeTestIntermediatesDir Condition="'$(__NativeTestIntermediatesDir)' == ''">$([System.IO.Path]::GetFullPath($(BaseOutputPathWithConfig)..\obj\$(BuildOS).$(Platform).$(Configuration)\Native\))</__NativeTestIntermediatesDir>
     <BuildProjectRelativeDir>$(MSBuildProjectName)\</BuildProjectRelativeDir>
     <BuildProjectRelativeDir Condition="'$(MSBuildProjectDirectory.Contains($(SourceDir)))'">$([System.String]::Copy('$(MSBuildProjectDirectory)').Replace($(SourceDir),''))\$(MSBuildProjectName)</BuildProjectRelativeDir>
-    <IntermediateOutputPath>$(BaseIntermediateOutputPath)$(BuildProjectRelativeDir)</IntermediateOutputPath>
+    <IntermediateOutputPath>$(BaseIntermediateOutputPath)$(BuildProjectRelativeDir)\</IntermediateOutputPath>
     <OutputPath>$(BaseOutputPathWithConfig)$(BuildProjectRelativeDir)\</OutputPath>
     <TestWorkingDir Condition="'$(TestWorkingDir)'==''">$(BaseOutputPath)\testStagingDir\</TestWorkingDir>
     <TestPath Condition="'$(TestPath)'==''">$(TestWorkingDir)$(OSPlatformConfig)\$(MSBuildProjectName)/</TestPath>
diff --git a/tests/src/dir.props b/tests/src/dir.props
index e8cdfd4036..2fb2e1942b 100644
--- a/tests/src/dir.props
+++ b/tests/src/dir.props
@@ -34,7 +34,6 @@
       <PropertyGroup>
         <TargetsWindows>true</TargetsWindows>
         <TestNugetRuntimeId>win7-x64</TestNugetRuntimeId>
-        <DefaultTestTFM>net45</DefaultTestTFM>
       </PropertyGroup>
     </When>
     <When Condition="'$(OSGroup)'=='Linux'">
@@ -67,14 +66,8 @@
 
   <PropertyGroup>
     <TargetsUnknownUnix Condition="'$(TargetsUnix)' == 'true' AND '$(OSGroup)' != 'FreeBSD' AND '$(OSGroup)' != 'Linux' AND '$(OSGroup)' != 'OSX'">true</TargetsUnknownUnix>
-  </PropertyGroup>
-
-  <!-- Default Test platform to deploy the netstandard compiled tests to -->
-  <PropertyGroup>
-    <!-- we default TestTFM and FilterToTestTFM to netcoreapp1.0 if they are not explicity defined -->
-    <DefaultTestTFM Condition="'$(DefaultTestTFM)'==''">netcoreapp1.0</DefaultTestTFM>
-    <TestTFM Condition="'$(TestTFM)'==''">$(DefaultTestTFM)</TestTFM>
-    <FilterToTestTFM Condition="'$(FilterToTestTFM)'==''">$(DefaultTestTFM)</FilterToTestTFM>
+    <Language Condition="'$(Language)' == '' and  '$(MSBuildProjectExtension)' == '.csproj'">C#</Language>
+    <Language Condition="'$(Language)' == '' and  '$(MSBuildProjectExtension)' == '.ilproj'">IL</Language>
   </PropertyGroup>
 
   <!-- Set default ZapRequire level (used only when CrossGen is enabled) -->
diff --git a/tests/src/dirs.proj b/tests/src/dirs.proj
index 99a50a4f6c..5314c27cfa 100644
--- a/tests/src/dirs.proj
+++ b/tests/src/dirs.proj
@@ -16,10 +16,14 @@
     <ItemGroup>
       <DisabledProjects Include="TestWrappers*\*\*.csproj" />
       <DisabledProjects Include="*\**\cs_template.csproj" />
-      <DisabledProjects Include="Common\Coreclr.TestWrapper\Coreclr.TestWrapper.csproj" />
+      <DisabledProjects Include="Common\Coreclr.TestWrapper\Coreclr.TestWrapper.csproj" Condition="'$(BuildTestsAgainstPackages)' != 'true'" />
+      <DisabledProjects Include="Common\Desktop.Coreclr.TestWrapper\Desktop.Coreclr.TestWrapper.csproj" Condition="'$(BuildTestsAgainstPackages)' == 'true'" />
       <DisabledProjects Include="Common\test_runtime\test_runtime.csproj" />
       <DisabledProjects Include="Common\test_dependencies\test_dependencies.csproj" />
+      <DisabledProjects Include="Common\build_against_pkg_dependencies\build_against_pkg_dependencies.csproj" />
+      <DisabledProjects Include="Common\targeting_pack_ref\targeting_pack_ref.csproj" />
       <DisabledProjects Include="GC\Performance\Framework\GCPerfTestFramework.csproj" />
+      <DisabledProjects Include="JIT\superpmi\superpmicollect.csproj" Condition="'$(BuildTestsAgainstPackages)' == 'true'" />
       <DisabledProjects Include="Loader\classloader\generics\regressions\DD117522\Test.csproj" />
       <DisabledProjects Include="Loader\classloader\generics\GenericMethods\VSW491668.csproj" /> <!-- issue 5501 -->
     </ItemGroup>
diff --git a/tests/src/managed/Compilation/HelloWorld.cs b/tests/src/managed/Compilation/HelloWorld.cs
index 67e0148005..bbf92a3117 100644
--- a/tests/src/managed/Compilation/HelloWorld.cs
+++ b/tests/src/managed/Compilation/HelloWorld.cs
@@ -8,7 +8,7 @@ class C
 {
     static int Main()
     {
-        Console.WriteLine("Hello " + "world");
+        LowLevelConsole.WriteLine("Hello " + "world");
         return 100;
     }
 }
diff --git a/tests/src/performance/project.json b/tests/src/performance/project.json
index 564aa9a168..e1af7fc15f 100644
--- a/tests/src/performance/project.json
+++ b/tests/src/performance/project.json
@@ -3,7 +3,7 @@
     "Microsoft.DotNet.xunit.performance": "1.0.0-alpha-build0040",
     "Microsoft.DotNet.xunit.performance.analysis": "1.0.0-alpha-build0040",
     "Microsoft.DotNet.xunit.performance.runner.Windows": "1.0.0-alpha-build0040",
-    "Microsoft.NETCore.Platforms": "2.0.0-beta-24924-02",
+    "Microsoft.NETCore.Platforms": "2.0.0-beta-25007-01",
     "System.Collections.NonGeneric": "4.4.0-beta-24913-02",
     "System.Console": "4.4.0-beta-24913-02",
     "System.IO.FileSystem": "4.4.0-beta-24913-02",
diff --git a/tests/src/readytorun/main.cs b/tests/src/readytorun/main.cs
index bbdd101759..783c1fd3cb 100644
--- a/tests/src/readytorun/main.cs
+++ b/tests/src/readytorun/main.cs
@@ -99,6 +99,11 @@ class Program
         {
              ((Object)s).ToString();
         }
+
+        // Enum.GetHashCode optimization requires special treatment
+        // in native signature encoding
+        MyEnum e = MyEnum.Apple;
+        e.GetHashCode();
     }
 
     static void TestConstrainedMethodCalls_Unsupported()
diff --git a/tests/src/readytorun/test.cs b/tests/src/readytorun/test.cs
index 40199b41e8..8a6beaea15 100644
--- a/tests/src/readytorun/test.cs
+++ b/tests/src/readytorun/test.cs
@@ -403,3 +403,10 @@ public class ByteChildClass : ByteBaseClass
         ChildByte = 67;
     }
 }
+
+public enum MyEnum
+{
+    Apple = 1,
+    Banana = 2,
+    Orange = 3
+}
diff --git a/tests/testsFailingOutsideWindows.txt b/tests/testsFailingOutsideWindows.txt
index de94b2802e..901172b394 100644
--- a/tests/testsFailingOutsideWindows.txt
+++ b/tests/testsFailingOutsideWindows.txt
@@ -79,3 +79,4 @@ Loader/classloader/TypeGeneratorTests/TypeGeneratorTest681/Generated681/Generate
 Loader/classloader/TypeGeneratorTests/TypeGeneratorTest682/Generated682/Generated682.sh
 Loader/classloader/TypeGeneratorTests/TypeGeneratorTest683/Generated683/Generated683.sh
 JIT/opt/perf/doublealign/Locals/Locals.sh
+JIT/Regression/JitBlue/DevDiv_377155/DevDiv_377155/DevDiv_377155.sh